vkms_config.h

  1/* SPDX-License-Identifier: GPL-2.0+ */
  2
  3#ifndef _VKMS_CONFIG_H_
  4#define _VKMS_CONFIG_H_
  5
  6#include <linux/list.h>
  7#include <linux/types.h>
  8#include <linux/xarray.h>
  9
 10#include <drm/drm_connector.h>
 11
 12#include "vkms_drv.h"
 13
 14/**
 15 * struct vkms_config - General configuration for VKMS driver
 16 *
 17 * @dev_name: Name of the device
 18 * @planes: List of planes configured for the device
 19 * @crtcs: List of CRTCs configured for the device
 20 * @encoders: List of encoders configured for the device
 21 * @connectors: List of connectors configured for the device
 22 * @dev: Used to store the current VKMS device. Only set when the device is instantiated.
 23 */
 24struct vkms_config {
 25	const char *dev_name;
 26	struct list_head planes;
 27	struct list_head crtcs;
 28	struct list_head encoders;
 29	struct list_head connectors;
 30	struct vkms_device *dev;
 31};
 32
 33/**
 34 * struct vkms_config_plane
 35 *
 36 * @link: Link to the others planes in vkms_config
 37 * @config: The vkms_config this plane belongs to
 38 * @type: Type of the plane. The creator of configuration needs to ensures that
 39 *        at least one primary plane is present.
 40 * @possible_crtcs: Array of CRTCs that can be used with this plane
 41 * @plane: Internal usage. This pointer should never be considered as valid.
 42 *         It can be used to store a temporary reference to a VKMS plane during
 43 *         device creation. This pointer is not managed by the configuration and
 44 *         must be managed by other means.
 45 */
 46struct vkms_config_plane {
 47	struct list_head link;
 48	struct vkms_config *config;
 49
 50	enum drm_plane_type type;
 51	struct xarray possible_crtcs;
 52	bool default_pipeline;
 53
 54	/* Internal usage */
 55	struct vkms_plane *plane;
 56};
 57
 58/**
 59 * struct vkms_config_crtc
 60 *
 61 * @link: Link to the others CRTCs in vkms_config
 62 * @config: The vkms_config this CRTC belongs to
 63 * @writeback: If true, a writeback buffer can be attached to the CRTC
 64 * @crtc: Internal usage. This pointer should never be considered as valid.
 65 *        It can be used to store a temporary reference to a VKMS CRTC during
 66 *        device creation. This pointer is not managed by the configuration and
 67 *        must be managed by other means.
 68 */
 69struct vkms_config_crtc {
 70	struct list_head link;
 71	struct vkms_config *config;
 72
 73	bool writeback;
 74
 75	/* Internal usage */
 76	struct vkms_output *crtc;
 77};
 78
 79/**
 80 * struct vkms_config_encoder
 81 *
 82 * @link: Link to the others encoders in vkms_config
 83 * @config: The vkms_config this CRTC belongs to
 84 * @possible_crtcs: Array of CRTCs that can be used with this encoder
 85 * @encoder: Internal usage. This pointer should never be considered as valid.
 86 *           It can be used to store a temporary reference to a VKMS encoder
 87 *           during device creation. This pointer is not managed by the
 88 *           configuration and must be managed by other means.
 89 */
 90struct vkms_config_encoder {
 91	struct list_head link;
 92	struct vkms_config *config;
 93
 94	struct xarray possible_crtcs;
 95
 96	/* Internal usage */
 97	struct drm_encoder *encoder;
 98};
 99
100/**
101 * struct vkms_config_connector
102 *
103 * @link: Link to the others connector in vkms_config
104 * @config: The vkms_config this connector belongs to
105 * @status: Status (connected, disconnected...) of the connector
106 * @possible_encoders: Array of encoders that can be used with this connector
107 * @connector: Internal usage. This pointer should never be considered as valid.
108 *             It can be used to store a temporary reference to a VKMS connector
109 *             during device creation. This pointer is not managed by the
110 *             configuration and must be managed by other means.
111 */
112struct vkms_config_connector {
113	struct list_head link;
114	struct vkms_config *config;
115
116	enum drm_connector_status status;
117	struct xarray possible_encoders;
118
119	/* Internal usage */
120	struct vkms_connector *connector;
121};
122
123/**
124 * vkms_config_for_each_plane - Iterate over the vkms_config planes
125 * @config: &struct vkms_config pointer
126 * @plane_cfg: &struct vkms_config_plane pointer used as cursor
127 */
128#define vkms_config_for_each_plane(config, plane_cfg) \
129	list_for_each_entry((plane_cfg), &(config)->planes, link)
130
131/**
132 * vkms_config_for_each_crtc - Iterate over the vkms_config CRTCs
133 * @config: &struct vkms_config pointer
134 * @crtc_cfg: &struct vkms_config_crtc pointer used as cursor
135 */
136#define vkms_config_for_each_crtc(config, crtc_cfg) \
137	list_for_each_entry((crtc_cfg), &(config)->crtcs, link)
138
139/**
140 * vkms_config_for_each_encoder - Iterate over the vkms_config encoders
141 * @config: &struct vkms_config pointer
142 * @encoder_cfg: &struct vkms_config_encoder pointer used as cursor
143 */
144#define vkms_config_for_each_encoder(config, encoder_cfg) \
145	list_for_each_entry((encoder_cfg), &(config)->encoders, link)
146
147/**
148 * vkms_config_for_each_connector - Iterate over the vkms_config connectors
149 * @config: &struct vkms_config pointer
150 * @connector_cfg: &struct vkms_config_connector pointer used as cursor
151 */
152#define vkms_config_for_each_connector(config, connector_cfg) \
153	list_for_each_entry((connector_cfg), &(config)->connectors, link)
154
155/**
156 * vkms_config_plane_for_each_possible_crtc - Iterate over the vkms_config_plane
157 * possible CRTCs
158 * @plane_cfg: &struct vkms_config_plane pointer
159 * @idx: Index of the cursor
160 * @possible_crtc: &struct vkms_config_crtc pointer used as cursor
161 */
162#define vkms_config_plane_for_each_possible_crtc(plane_cfg, idx, possible_crtc) \
163	xa_for_each(&(plane_cfg)->possible_crtcs, idx, (possible_crtc))
164
165/**
166 * vkms_config_encoder_for_each_possible_crtc - Iterate over the
167 * vkms_config_encoder possible CRTCs
168 * @encoder_cfg: &struct vkms_config_encoder pointer
169 * @idx: Index of the cursor
170 * @possible_crtc: &struct vkms_config_crtc pointer used as cursor
171 */
172#define vkms_config_encoder_for_each_possible_crtc(encoder_cfg, idx, possible_crtc) \
173	xa_for_each(&(encoder_cfg)->possible_crtcs, idx, (possible_crtc))
174
175/**
176 * vkms_config_connector_for_each_possible_encoder - Iterate over the
177 * vkms_config_connector possible encoders
178 * @connector_cfg: &struct vkms_config_connector pointer
179 * @idx: Index of the cursor
180 * @possible_encoder: &struct vkms_config_encoder pointer used as cursor
181 */
182#define vkms_config_connector_for_each_possible_encoder(connector_cfg, idx, possible_encoder) \
183	xa_for_each(&(connector_cfg)->possible_encoders, idx, (possible_encoder))
184
185/**
186 * vkms_config_create() - Create a new VKMS configuration
187 * @dev_name: Name of the device
188 *
189 * Returns:
190 * The new vkms_config or an error. Call vkms_config_destroy() to free the
191 * returned configuration.
192 */
193struct vkms_config *vkms_config_create(const char *dev_name);
194
195/**
196 * vkms_config_default_create() - Create the configuration for the default device
197 * @enable_cursor: Create or not a cursor plane
198 * @enable_writeback: Create or not a writeback connector
199 * @enable_overlay: Create or not overlay planes
200 *
201 * Returns:
202 * The default vkms_config or an error. Call vkms_config_destroy() to free the
203 * returned configuration.
204 */
205struct vkms_config *vkms_config_default_create(bool enable_cursor,
206					       bool enable_writeback,
207					       bool enable_overlay,
208					       bool enable_plane_pipeline);
209
210/**
211 * vkms_config_destroy() - Free a VKMS configuration
212 * @config: vkms_config to free
213 */
214void vkms_config_destroy(struct vkms_config *config);
215
216/**
217 * vkms_config_get_device_name() - Return the name of the device
218 * @config: Configuration to get the device name from
219 *
220 * Returns:
221 * The device name. Only valid while @config is valid.
222 */
223static inline const char *
224vkms_config_get_device_name(struct vkms_config *config)
225{
226	return config->dev_name;
227}
228
229/**
230 * vkms_config_get_num_crtcs() - Return the number of CRTCs in the configuration
231 * @config: Configuration to get the number of CRTCs from
232 */
233static inline size_t vkms_config_get_num_crtcs(struct vkms_config *config)
234{
235	return list_count_nodes(&config->crtcs);
236}
237
238/**
239 * vkms_config_is_valid() - Validate a configuration
240 * @config: Configuration to validate
241 *
242 * Returns:
243 * Whether the configuration is valid or not.
244 * For example, a configuration without primary planes is not valid.
245 */
246bool vkms_config_is_valid(const struct vkms_config *config);
247
248/**
249 * vkms_config_register_debugfs() - Register a debugfs file to show the device's
250 * configuration
251 * @vkms_device: Device to register
252 */
253void vkms_config_register_debugfs(struct vkms_device *vkms_device);
254
255/**
256 * vkms_config_create_plane() - Add a new plane configuration
257 * @config: Configuration to add the plane to
258 *
259 * Returns:
260 * The new plane configuration or an error. Call vkms_config_destroy_plane() to
261 * free the returned plane configuration.
262 */
263struct vkms_config_plane *vkms_config_create_plane(struct vkms_config *config);
264
265/**
266 * vkms_config_destroy_plane() - Remove and free a plane configuration
267 * @plane_cfg: Plane configuration to destroy
268 */
269void vkms_config_destroy_plane(struct vkms_config_plane *plane_cfg);
270
271/**
272 * vkms_config_plane_type() - Return the plane type
273 * @plane_cfg: Plane to get the type from
274 */
275static inline enum drm_plane_type
276vkms_config_plane_get_type(struct vkms_config_plane *plane_cfg)
277{
278	return plane_cfg->type;
279}
280
281/**
282 * vkms_config_plane_set_type() - Set the plane type
283 * @plane_cfg: Plane to set the type to
284 * @type: New plane type
285 */
286static inline void
287vkms_config_plane_set_type(struct vkms_config_plane *plane_cfg,
288			   enum drm_plane_type type)
289{
290	plane_cfg->type = type;
291}
292
293/**
294 * vkms_config_plane_get_default_pipeline() - Return if the plane will
295 * be created with the default pipeline
296 * @plane_cfg: Plane to get the information from
297 */
298static inline bool
299vkms_config_plane_get_default_pipeline(struct vkms_config_plane *plane_cfg)
300{
301	return plane_cfg->default_pipeline;
302}
303
304/**
305 * vkms_config_plane_set_default_pipeline() - Set if the plane will
306 * be created with the default pipeline
307 * @plane_cfg: Plane to configure the pipeline
308 * @default_pipeline: New default pipeline value
309 */
310static inline void
311vkms_config_plane_set_default_pipeline(struct vkms_config_plane *plane_cfg,
312				       bool default_pipeline)
313{
314	plane_cfg->default_pipeline = default_pipeline;
315}
316
317/**
318 * vkms_config_plane_attach_crtc - Attach a plane to a CRTC
319 * @plane_cfg: Plane to attach
320 * @crtc_cfg: CRTC to attach @plane_cfg to
321 */
322int __must_check vkms_config_plane_attach_crtc(struct vkms_config_plane *plane_cfg,
323					       struct vkms_config_crtc *crtc_cfg);
324
325/**
326 * vkms_config_plane_detach_crtc - Detach a plane from a CRTC
327 * @plane_cfg: Plane to detach
328 * @crtc_cfg: CRTC to detach @plane_cfg from
329 */
330void vkms_config_plane_detach_crtc(struct vkms_config_plane *plane_cfg,
331				   struct vkms_config_crtc *crtc_cfg);
332
333/**
334 * vkms_config_create_crtc() - Add a new CRTC configuration
335 * @config: Configuration to add the CRTC to
336 *
337 * Returns:
338 * The new CRTC configuration or an error. Call vkms_config_destroy_crtc() to
339 * free the returned CRTC configuration.
340 */
341struct vkms_config_crtc *vkms_config_create_crtc(struct vkms_config *config);
342
343/**
344 * vkms_config_destroy_crtc() - Remove and free a CRTC configuration
345 * @config: Configuration to remove the CRTC from
346 * @crtc_cfg: CRTC configuration to destroy
347 */
348void vkms_config_destroy_crtc(struct vkms_config *config,
349			      struct vkms_config_crtc *crtc_cfg);
350
351/**
352 * vkms_config_crtc_get_writeback() - If a writeback connector will be created
353 * @crtc_cfg: CRTC with or without a writeback connector
354 */
355static inline bool
356vkms_config_crtc_get_writeback(struct vkms_config_crtc *crtc_cfg)
357{
358	return crtc_cfg->writeback;
359}
360
361/**
362 * vkms_config_crtc_set_writeback() - If a writeback connector will be created
363 * @crtc_cfg: Target CRTC
364 * @writeback: Enable or disable the writeback connector
365 */
366static inline void
367vkms_config_crtc_set_writeback(struct vkms_config_crtc *crtc_cfg,
368			       bool writeback)
369{
370	crtc_cfg->writeback = writeback;
371}
372
373/**
374 * vkms_config_crtc_primary_plane() - Return the primary plane for a CRTC
375 * @config: Configuration containing the CRTC
376 * @crtc_config: Target CRTC
377 *
378 * Note that, if multiple primary planes are found, the first one is returned.
379 * In this case, the configuration will be invalid. See vkms_config_is_valid().
380 *
381 * Returns:
382 * The primary plane or NULL if none is assigned yet.
383 */
384struct vkms_config_plane *vkms_config_crtc_primary_plane(const struct vkms_config *config,
385							 struct vkms_config_crtc *crtc_cfg);
386
387/**
388 * vkms_config_crtc_cursor_plane() - Return the cursor plane for a CRTC
389 * @config: Configuration containing the CRTC
390 * @crtc_config: Target CRTC
391 *
392 * Note that, if multiple cursor planes are found, the first one is returned.
393 * In this case, the configuration will be invalid. See vkms_config_is_valid().
394 *
395 * Returns:
396 * The cursor plane or NULL if none is assigned yet.
397 */
398struct vkms_config_plane *vkms_config_crtc_cursor_plane(const struct vkms_config *config,
399							struct vkms_config_crtc *crtc_cfg);
400
401/**
402 * vkms_config_create_encoder() - Add a new encoder configuration
403 * @config: Configuration to add the encoder to
404 *
405 * Returns:
406 * The new encoder configuration or an error. Call vkms_config_destroy_encoder()
407 * to free the returned encoder configuration.
408 */
409struct vkms_config_encoder *vkms_config_create_encoder(struct vkms_config *config);
410
411/**
412 * vkms_config_destroy_encoder() - Remove and free a encoder configuration
413 * @config: Configuration to remove the encoder from
414 * @encoder_cfg: Encoder configuration to destroy
415 */
416void vkms_config_destroy_encoder(struct vkms_config *config,
417				 struct vkms_config_encoder *encoder_cfg);
418
419/**
420 * vkms_config_encoder_attach_crtc - Attach a encoder to a CRTC
421 * @encoder_cfg: Encoder to attach
422 * @crtc_cfg: CRTC to attach @encoder_cfg to
423 */
424int __must_check vkms_config_encoder_attach_crtc(struct vkms_config_encoder *encoder_cfg,
425						 struct vkms_config_crtc *crtc_cfg);
426
427/**
428 * vkms_config_encoder_detach_crtc - Detach a encoder from a CRTC
429 * @encoder_cfg: Encoder to detach
430 * @crtc_cfg: CRTC to detach @encoder_cfg from
431 */
432void vkms_config_encoder_detach_crtc(struct vkms_config_encoder *encoder_cfg,
433				     struct vkms_config_crtc *crtc_cfg);
434
435/**
436 * vkms_config_create_connector() - Add a new connector configuration
437 * @config: Configuration to add the connector to
438 *
439 * Returns:
440 * The new connector configuration or an error. Call
441 * vkms_config_destroy_connector() to free the returned connector configuration.
442 */
443struct vkms_config_connector *vkms_config_create_connector(struct vkms_config *config);
444
445/**
446 * vkms_config_destroy_connector() - Remove and free a connector configuration
447 * @connector_cfg: Connector configuration to destroy
448 */
449void vkms_config_destroy_connector(struct vkms_config_connector *connector_cfg);
450
451/**
452 * vkms_config_connector_attach_encoder - Attach a connector to an encoder
453 * @connector_cfg: Connector to attach
454 * @encoder_cfg: Encoder to attach @connector_cfg to
455 */
456int __must_check vkms_config_connector_attach_encoder(struct vkms_config_connector *connector_cfg,
457						      struct vkms_config_encoder *encoder_cfg);
458
459/**
460 * vkms_config_connector_detach_encoder - Detach a connector from an encoder
461 * @connector_cfg: Connector to detach
462 * @encoder_cfg: Encoder to detach @connector_cfg from
463 */
464void vkms_config_connector_detach_encoder(struct vkms_config_connector *connector_cfg,
465					  struct vkms_config_encoder *encoder_cfg);
466
467/**
468 * vkms_config_connector_get_status() - Return the status of the connector
469 * @connector_cfg: Connector to get the status from
470 */
471static inline enum drm_connector_status
472vkms_config_connector_get_status(struct vkms_config_connector *connector_cfg)
473{
474	return connector_cfg->status;
475}
476
477/**
478 * vkms_config_connector_set_status() - Set the status of the connector
479 * @connector_cfg: Connector to set the status to
480 * @status: New connector status
481 */
482static inline void
483vkms_config_connector_set_status(struct vkms_config_connector *connector_cfg,
484				 enum drm_connector_status status)
485{
486	connector_cfg->status = status;
487}
488
489#endif /* _VKMS_CONFIG_H_ */