xref: /openbmc/linux/include/drm/drm_crtc.h (revision 92a2c6b2)
1 /*
2  * Copyright © 2006 Keith Packard
3  * Copyright © 2007-2008 Dave Airlie
4  * Copyright © 2007-2008 Intel Corporation
5  *   Jesse Barnes <jesse.barnes@intel.com>
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a
8  * copy of this software and associated documentation files (the "Software"),
9  * to deal in the Software without restriction, including without limitation
10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11  * and/or sell copies of the Software, and to permit persons to whom the
12  * Software is furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in
15  * all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
20  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23  * OTHER DEALINGS IN THE SOFTWARE.
24  */
25 #ifndef __DRM_CRTC_H__
26 #define __DRM_CRTC_H__
27 
28 #include <linux/i2c.h>
29 #include <linux/spinlock.h>
30 #include <linux/types.h>
31 #include <linux/idr.h>
32 #include <linux/fb.h>
33 #include <linux/hdmi.h>
34 #include <linux/media-bus-format.h>
35 #include <uapi/drm/drm_mode.h>
36 #include <uapi/drm/drm_fourcc.h>
37 #include <drm/drm_modeset_lock.h>
38 
39 struct drm_device;
40 struct drm_mode_set;
41 struct drm_framebuffer;
42 struct drm_object_properties;
43 struct drm_file;
44 struct drm_clip_rect;
45 struct device_node;
46 struct fence;
47 
48 #define DRM_MODE_OBJECT_CRTC 0xcccccccc
49 #define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0
50 #define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0
51 #define DRM_MODE_OBJECT_MODE 0xdededede
52 #define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0
53 #define DRM_MODE_OBJECT_FB 0xfbfbfbfb
54 #define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
55 #define DRM_MODE_OBJECT_PLANE 0xeeeeeeee
56 #define DRM_MODE_OBJECT_BRIDGE 0xbdbdbdbd
57 #define DRM_MODE_OBJECT_ANY 0
58 
59 struct drm_mode_object {
60 	uint32_t id;
61 	uint32_t type;
62 	struct drm_object_properties *properties;
63 };
64 
65 #define DRM_OBJECT_MAX_PROPERTY 24
66 struct drm_object_properties {
67 	int count, atomic_count;
68 	/* NOTE: if we ever start dynamically destroying properties (ie.
69 	 * not at drm_mode_config_cleanup() time), then we'd have to do
70 	 * a better job of detaching property from mode objects to avoid
71 	 * dangling property pointers:
72 	 */
73 	struct drm_property *properties[DRM_OBJECT_MAX_PROPERTY];
74 	/* do not read/write values directly, but use drm_object_property_get_value()
75 	 * and drm_object_property_set_value():
76 	 */
77 	uint64_t values[DRM_OBJECT_MAX_PROPERTY];
78 };
79 
80 static inline int64_t U642I64(uint64_t val)
81 {
82 	return (int64_t)*((int64_t *)&val);
83 }
84 static inline uint64_t I642U64(int64_t val)
85 {
86 	return (uint64_t)*((uint64_t *)&val);
87 }
88 
89 /* rotation property bits */
90 #define DRM_ROTATE_0	0
91 #define DRM_ROTATE_90	1
92 #define DRM_ROTATE_180	2
93 #define DRM_ROTATE_270	3
94 #define DRM_REFLECT_X	4
95 #define DRM_REFLECT_Y	5
96 
97 enum drm_connector_force {
98 	DRM_FORCE_UNSPECIFIED,
99 	DRM_FORCE_OFF,
100 	DRM_FORCE_ON,         /* force on analog part normally */
101 	DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */
102 };
103 
104 #include <drm/drm_modes.h>
105 
106 enum drm_connector_status {
107 	connector_status_connected = 1,
108 	connector_status_disconnected = 2,
109 	connector_status_unknown = 3,
110 };
111 
112 enum subpixel_order {
113 	SubPixelUnknown = 0,
114 	SubPixelHorizontalRGB,
115 	SubPixelHorizontalBGR,
116 	SubPixelVerticalRGB,
117 	SubPixelVerticalBGR,
118 	SubPixelNone,
119 };
120 
121 #define DRM_COLOR_FORMAT_RGB444		(1<<0)
122 #define DRM_COLOR_FORMAT_YCRCB444	(1<<1)
123 #define DRM_COLOR_FORMAT_YCRCB422	(1<<2)
124 /*
125  * Describes a given display (e.g. CRT or flat panel) and its limitations.
126  */
127 struct drm_display_info {
128 	char name[DRM_DISPLAY_INFO_LEN];
129 
130 	/* Physical size */
131         unsigned int width_mm;
132 	unsigned int height_mm;
133 
134 	/* Clock limits FIXME: storage format */
135 	unsigned int min_vfreq, max_vfreq;
136 	unsigned int min_hfreq, max_hfreq;
137 	unsigned int pixel_clock;
138 	unsigned int bpc;
139 
140 	enum subpixel_order subpixel_order;
141 	u32 color_formats;
142 
143 	const u32 *bus_formats;
144 	unsigned int num_bus_formats;
145 
146 	/* Mask of supported hdmi deep color modes */
147 	u8 edid_hdmi_dc_modes;
148 
149 	u8 cea_rev;
150 };
151 
152 /* data corresponds to displayid vend/prod/serial */
153 struct drm_tile_group {
154 	struct kref refcount;
155 	struct drm_device *dev;
156 	int id;
157 	u8 group_data[8];
158 };
159 
160 struct drm_framebuffer_funcs {
161 	/* note: use drm_framebuffer_remove() */
162 	void (*destroy)(struct drm_framebuffer *framebuffer);
163 	int (*create_handle)(struct drm_framebuffer *fb,
164 			     struct drm_file *file_priv,
165 			     unsigned int *handle);
166 	/*
167 	 * Optional callback for the dirty fb ioctl.
168 	 *
169 	 * Userspace can notify the driver via this callback
170 	 * that a area of the framebuffer has changed and should
171 	 * be flushed to the display hardware.
172 	 *
173 	 * See documentation in drm_mode.h for the struct
174 	 * drm_mode_fb_dirty_cmd for more information as all
175 	 * the semantics and arguments have a one to one mapping
176 	 * on this function.
177 	 */
178 	int (*dirty)(struct drm_framebuffer *framebuffer,
179 		     struct drm_file *file_priv, unsigned flags,
180 		     unsigned color, struct drm_clip_rect *clips,
181 		     unsigned num_clips);
182 };
183 
184 struct drm_framebuffer {
185 	struct drm_device *dev;
186 	/*
187 	 * Note that the fb is refcounted for the benefit of driver internals,
188 	 * for example some hw, disabling a CRTC/plane is asynchronous, and
189 	 * scanout does not actually complete until the next vblank.  So some
190 	 * cleanup (like releasing the reference(s) on the backing GEM bo(s))
191 	 * should be deferred.  In cases like this, the driver would like to
192 	 * hold a ref to the fb even though it has already been removed from
193 	 * userspace perspective.
194 	 */
195 	struct kref refcount;
196 	/*
197 	 * Place on the dev->mode_config.fb_list, access protected by
198 	 * dev->mode_config.fb_lock.
199 	 */
200 	struct list_head head;
201 	struct drm_mode_object base;
202 	const struct drm_framebuffer_funcs *funcs;
203 	unsigned int pitches[4];
204 	unsigned int offsets[4];
205 	unsigned int width;
206 	unsigned int height;
207 	/* depth can be 15 or 16 */
208 	unsigned int depth;
209 	int bits_per_pixel;
210 	int flags;
211 	uint32_t pixel_format; /* fourcc format */
212 	struct list_head filp_head;
213 	/* if you are using the helper */
214 	void *helper_private;
215 };
216 
217 struct drm_property_blob {
218 	struct drm_mode_object base;
219 	struct list_head head;
220 	size_t length;
221 	unsigned char data[];
222 };
223 
224 struct drm_property_enum {
225 	uint64_t value;
226 	struct list_head head;
227 	char name[DRM_PROP_NAME_LEN];
228 };
229 
230 struct drm_property {
231 	struct list_head head;
232 	struct drm_mode_object base;
233 	uint32_t flags;
234 	char name[DRM_PROP_NAME_LEN];
235 	uint32_t num_values;
236 	uint64_t *values;
237 	struct drm_device *dev;
238 
239 	struct list_head enum_list;
240 };
241 
242 struct drm_crtc;
243 struct drm_connector;
244 struct drm_encoder;
245 struct drm_pending_vblank_event;
246 struct drm_plane;
247 struct drm_bridge;
248 struct drm_atomic_state;
249 
250 /**
251  * struct drm_crtc_state - mutable CRTC state
252  * @crtc: backpointer to the CRTC
253  * @enable: whether the CRTC should be enabled, gates all other state
254  * @active: whether the CRTC is actively displaying (used for DPMS)
255  * @mode_changed: for use by helpers and drivers when computing state updates
256  * @active_changed: for use by helpers and drivers when computing state updates
257  * @plane_mask: bitmask of (1 << drm_plane_index(plane)) of attached planes
258  * @last_vblank_count: for helpers and drivers to capture the vblank of the
259  * 	update to ensure framebuffer cleanup isn't done too early
260  * @planes_changed: for use by helpers and drivers when computing state updates
261  * @adjusted_mode: for use by helpers and drivers to compute adjusted mode timings
262  * @mode: current mode timings
263  * @event: optional pointer to a DRM event to signal upon completion of the
264  * 	state update
265  * @state: backpointer to global drm_atomic_state
266  *
267  * Note that the distinction between @enable and @active is rather subtile:
268  * Flipping @active while @enable is set without changing anything else may
269  * never return in a failure from the ->atomic_check callback. Userspace assumes
270  * that a DPMS On will always succeed. In other words: @enable controls resource
271  * assignment, @active controls the actual hardware state.
272  */
273 struct drm_crtc_state {
274 	struct drm_crtc *crtc;
275 
276 	bool enable;
277 	bool active;
278 
279 	/* computed state bits used by helpers and drivers */
280 	bool planes_changed : 1;
281 	bool mode_changed : 1;
282 	bool active_changed : 1;
283 
284 	/* attached planes bitmask:
285 	 * WARNING: transitional helpers do not maintain plane_mask so
286 	 * drivers not converted over to atomic helpers should not rely
287 	 * on plane_mask being accurate!
288 	 */
289 	u32 plane_mask;
290 
291 	/* last_vblank_count: for vblank waits before cleanup */
292 	u32 last_vblank_count;
293 
294 	/* adjusted_mode: for use by helpers and drivers */
295 	struct drm_display_mode adjusted_mode;
296 
297 	struct drm_display_mode mode;
298 
299 	struct drm_pending_vblank_event *event;
300 
301 	struct drm_atomic_state *state;
302 };
303 
304 /**
305  * struct drm_crtc_funcs - control CRTCs for a given device
306  * @save: save CRTC state
307  * @restore: restore CRTC state
308  * @reset: reset CRTC after state has been invalidated (e.g. resume)
309  * @cursor_set: setup the cursor
310  * @cursor_set2: setup the cursor with hotspot, superseeds @cursor_set if set
311  * @cursor_move: move the cursor
312  * @gamma_set: specify color ramp for CRTC
313  * @destroy: deinit and free object
314  * @set_property: called when a property is changed
315  * @set_config: apply a new CRTC configuration
316  * @page_flip: initiate a page flip
317  * @atomic_duplicate_state: duplicate the atomic state for this CRTC
318  * @atomic_destroy_state: destroy an atomic state for this CRTC
319  * @atomic_set_property: set a property on an atomic state for this CRTC
320  *    (do not call directly, use drm_atomic_crtc_set_property())
321  * @atomic_get_property: get a property on an atomic state for this CRTC
322  *    (do not call directly, use drm_atomic_crtc_get_property())
323  *
324  * The drm_crtc_funcs structure is the central CRTC management structure
325  * in the DRM.  Each CRTC controls one or more connectors (note that the name
326  * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc.
327  * connectors, not just CRTs).
328  *
329  * Each driver is responsible for filling out this structure at startup time,
330  * in addition to providing other modesetting features, like i2c and DDC
331  * bus accessors.
332  */
333 struct drm_crtc_funcs {
334 	/* Save CRTC state */
335 	void (*save)(struct drm_crtc *crtc); /* suspend? */
336 	/* Restore CRTC state */
337 	void (*restore)(struct drm_crtc *crtc); /* resume? */
338 	/* Reset CRTC state */
339 	void (*reset)(struct drm_crtc *crtc);
340 
341 	/* cursor controls */
342 	int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,
343 			  uint32_t handle, uint32_t width, uint32_t height);
344 	int (*cursor_set2)(struct drm_crtc *crtc, struct drm_file *file_priv,
345 			   uint32_t handle, uint32_t width, uint32_t height,
346 			   int32_t hot_x, int32_t hot_y);
347 	int (*cursor_move)(struct drm_crtc *crtc, int x, int y);
348 
349 	/* Set gamma on the CRTC */
350 	void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
351 			  uint32_t start, uint32_t size);
352 	/* Object destroy routine */
353 	void (*destroy)(struct drm_crtc *crtc);
354 
355 	int (*set_config)(struct drm_mode_set *set);
356 
357 	/*
358 	 * Flip to the given framebuffer.  This implements the page
359 	 * flip ioctl described in drm_mode.h, specifically, the
360 	 * implementation must return immediately and block all
361 	 * rendering to the current fb until the flip has completed.
362 	 * If userspace set the event flag in the ioctl, the event
363 	 * argument will point to an event to send back when the flip
364 	 * completes, otherwise it will be NULL.
365 	 */
366 	int (*page_flip)(struct drm_crtc *crtc,
367 			 struct drm_framebuffer *fb,
368 			 struct drm_pending_vblank_event *event,
369 			 uint32_t flags);
370 
371 	int (*set_property)(struct drm_crtc *crtc,
372 			    struct drm_property *property, uint64_t val);
373 
374 	/* atomic update handling */
375 	struct drm_crtc_state *(*atomic_duplicate_state)(struct drm_crtc *crtc);
376 	void (*atomic_destroy_state)(struct drm_crtc *crtc,
377 				     struct drm_crtc_state *state);
378 	int (*atomic_set_property)(struct drm_crtc *crtc,
379 				   struct drm_crtc_state *state,
380 				   struct drm_property *property,
381 				   uint64_t val);
382 	int (*atomic_get_property)(struct drm_crtc *crtc,
383 				   const struct drm_crtc_state *state,
384 				   struct drm_property *property,
385 				   uint64_t *val);
386 };
387 
388 /**
389  * struct drm_crtc - central CRTC control structure
390  * @dev: parent DRM device
391  * @port: OF node used by drm_of_find_possible_crtcs()
392  * @head: list management
393  * @mutex: per-CRTC locking
394  * @base: base KMS object for ID tracking etc.
395  * @primary: primary plane for this CRTC
396  * @cursor: cursor plane for this CRTC
397  * @cursor_x: current x position of the cursor, used for universal cursor planes
398  * @cursor_y: current y position of the cursor, used for universal cursor planes
399  * @enabled: is this CRTC enabled?
400  * @mode: current mode timings
401  * @hwmode: mode timings as programmed to hw regs
402  * @invert_dimensions: for purposes of error checking crtc vs fb sizes,
403  *    invert the width/height of the crtc.  This is used if the driver
404  *    is performing 90 or 270 degree rotated scanout
405  * @x: x position on screen
406  * @y: y position on screen
407  * @funcs: CRTC control functions
408  * @gamma_size: size of gamma ramp
409  * @gamma_store: gamma ramp values
410  * @framedur_ns: precise frame timing
411  * @linedur_ns: precise line timing
412  * @pixeldur_ns: precise pixel timing
413  * @helper_private: mid-layer private data
414  * @properties: property tracking for this CRTC
415  * @state: current atomic state for this CRTC
416  * @acquire_ctx: per-CRTC implicit acquire context used by atomic drivers for
417  * 	legacy ioctls
418  *
419  * Each CRTC may have one or more connectors associated with it.  This structure
420  * allows the CRTC to be controlled.
421  */
422 struct drm_crtc {
423 	struct drm_device *dev;
424 	struct device_node *port;
425 	struct list_head head;
426 
427 	/*
428 	 * crtc mutex
429 	 *
430 	 * This provides a read lock for the overall crtc state (mode, dpms
431 	 * state, ...) and a write lock for everything which can be update
432 	 * without a full modeset (fb, cursor data, ...)
433 	 */
434 	struct drm_modeset_lock mutex;
435 
436 	struct drm_mode_object base;
437 
438 	/* primary and cursor planes for CRTC */
439 	struct drm_plane *primary;
440 	struct drm_plane *cursor;
441 
442 	/* position of cursor plane on crtc */
443 	int cursor_x;
444 	int cursor_y;
445 
446 	bool enabled;
447 
448 	/* Requested mode from modesetting. */
449 	struct drm_display_mode mode;
450 
451 	/* Programmed mode in hw, after adjustments for encoders,
452 	 * crtc, panel scaling etc. Needed for timestamping etc.
453 	 */
454 	struct drm_display_mode hwmode;
455 
456 	bool invert_dimensions;
457 
458 	int x, y;
459 	const struct drm_crtc_funcs *funcs;
460 
461 	/* CRTC gamma size for reporting to userspace */
462 	uint32_t gamma_size;
463 	uint16_t *gamma_store;
464 
465 	/* Constants needed for precise vblank and swap timestamping. */
466 	int framedur_ns, linedur_ns, pixeldur_ns;
467 
468 	/* if you are using the helper */
469 	void *helper_private;
470 
471 	struct drm_object_properties properties;
472 
473 	struct drm_crtc_state *state;
474 
475 	/*
476 	 * For legacy crtc ioctls so that atomic drivers can get at the locking
477 	 * acquire context.
478 	 */
479 	struct drm_modeset_acquire_ctx *acquire_ctx;
480 };
481 
482 /**
483  * struct drm_connector_state - mutable connector state
484  * @connector: backpointer to the connector
485  * @crtc: CRTC to connect connector to, NULL if disabled
486  * @best_encoder: can be used by helpers and drivers to select the encoder
487  * @state: backpointer to global drm_atomic_state
488  */
489 struct drm_connector_state {
490 	struct drm_connector *connector;
491 
492 	struct drm_crtc *crtc;  /* do not write directly, use drm_atomic_set_crtc_for_connector() */
493 
494 	struct drm_encoder *best_encoder;
495 
496 	struct drm_atomic_state *state;
497 };
498 
499 /**
500  * struct drm_connector_funcs - control connectors on a given device
501  * @dpms: set power state
502  * @save: save connector state
503  * @restore: restore connector state
504  * @reset: reset connector after state has been invalidated (e.g. resume)
505  * @detect: is this connector active?
506  * @fill_modes: fill mode list for this connector
507  * @set_property: property for this connector may need an update
508  * @destroy: make object go away
509  * @force: notify the driver that the connector is forced on
510  * @atomic_duplicate_state: duplicate the atomic state for this connector
511  * @atomic_destroy_state: destroy an atomic state for this connector
512  * @atomic_set_property: set a property on an atomic state for this connector
513  *    (do not call directly, use drm_atomic_connector_set_property())
514  * @atomic_get_property: get a property on an atomic state for this connector
515  *    (do not call directly, use drm_atomic_connector_get_property())
516  *
517  * Each CRTC may have one or more connectors attached to it.  The functions
518  * below allow the core DRM code to control connectors, enumerate available modes,
519  * etc.
520  */
521 struct drm_connector_funcs {
522 	void (*dpms)(struct drm_connector *connector, int mode);
523 	void (*save)(struct drm_connector *connector);
524 	void (*restore)(struct drm_connector *connector);
525 	void (*reset)(struct drm_connector *connector);
526 
527 	/* Check to see if anything is attached to the connector.
528 	 * @force is set to false whilst polling, true when checking the
529 	 * connector due to user request. @force can be used by the driver
530 	 * to avoid expensive, destructive operations during automated
531 	 * probing.
532 	 */
533 	enum drm_connector_status (*detect)(struct drm_connector *connector,
534 					    bool force);
535 	int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);
536 	int (*set_property)(struct drm_connector *connector, struct drm_property *property,
537 			     uint64_t val);
538 	void (*destroy)(struct drm_connector *connector);
539 	void (*force)(struct drm_connector *connector);
540 
541 	/* atomic update handling */
542 	struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector);
543 	void (*atomic_destroy_state)(struct drm_connector *connector,
544 				     struct drm_connector_state *state);
545 	int (*atomic_set_property)(struct drm_connector *connector,
546 				   struct drm_connector_state *state,
547 				   struct drm_property *property,
548 				   uint64_t val);
549 	int (*atomic_get_property)(struct drm_connector *connector,
550 				   const struct drm_connector_state *state,
551 				   struct drm_property *property,
552 				   uint64_t *val);
553 };
554 
555 /**
556  * struct drm_encoder_funcs - encoder controls
557  * @reset: reset state (e.g. at init or resume time)
558  * @destroy: cleanup and free associated data
559  *
560  * Encoders sit between CRTCs and connectors.
561  */
562 struct drm_encoder_funcs {
563 	void (*reset)(struct drm_encoder *encoder);
564 	void (*destroy)(struct drm_encoder *encoder);
565 };
566 
567 #define DRM_CONNECTOR_MAX_ENCODER 3
568 
569 /**
570  * struct drm_encoder - central DRM encoder structure
571  * @dev: parent DRM device
572  * @head: list management
573  * @base: base KMS object
574  * @name: encoder name
575  * @encoder_type: one of the %DRM_MODE_ENCODER_<foo> types in drm_mode.h
576  * @possible_crtcs: bitmask of potential CRTC bindings
577  * @possible_clones: bitmask of potential sibling encoders for cloning
578  * @crtc: currently bound CRTC
579  * @bridge: bridge associated to the encoder
580  * @funcs: control functions
581  * @helper_private: mid-layer private data
582  *
583  * CRTCs drive pixels to encoders, which convert them into signals
584  * appropriate for a given connector or set of connectors.
585  */
586 struct drm_encoder {
587 	struct drm_device *dev;
588 	struct list_head head;
589 
590 	struct drm_mode_object base;
591 	char *name;
592 	int encoder_type;
593 	uint32_t possible_crtcs;
594 	uint32_t possible_clones;
595 
596 	struct drm_crtc *crtc;
597 	struct drm_bridge *bridge;
598 	const struct drm_encoder_funcs *funcs;
599 	void *helper_private;
600 };
601 
602 /* should we poll this connector for connects and disconnects */
603 /* hot plug detectable */
604 #define DRM_CONNECTOR_POLL_HPD (1 << 0)
605 /* poll for connections */
606 #define DRM_CONNECTOR_POLL_CONNECT (1 << 1)
607 /* can cleanly poll for disconnections without flickering the screen */
608 /* DACs should rarely do this without a lot of testing */
609 #define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2)
610 
611 #define MAX_ELD_BYTES	128
612 
613 /**
614  * struct drm_connector - central DRM connector control structure
615  * @dev: parent DRM device
616  * @kdev: kernel device for sysfs attributes
617  * @attr: sysfs attributes
618  * @head: list management
619  * @base: base KMS object
620  * @name: connector name
621  * @connector_type: one of the %DRM_MODE_CONNECTOR_<foo> types from drm_mode.h
622  * @connector_type_id: index into connector type enum
623  * @interlace_allowed: can this connector handle interlaced modes?
624  * @doublescan_allowed: can this connector handle doublescan?
625  * @stereo_allowed: can this connector handle stereo modes?
626  * @modes: modes available on this connector (from fill_modes() + user)
627  * @status: one of the drm_connector_status enums (connected, not, or unknown)
628  * @probed_modes: list of modes derived directly from the display
629  * @display_info: information about attached display (e.g. from EDID)
630  * @funcs: connector control functions
631  * @edid_blob_ptr: DRM property containing EDID if present
632  * @properties: property tracking for this connector
633  * @path_blob_ptr: DRM blob property data for the DP MST path property
634  * @polled: a %DRM_CONNECTOR_POLL_<foo> value for core driven polling
635  * @dpms: current dpms state
636  * @helper_private: mid-layer private data
637  * @cmdline_mode: mode line parsed from the kernel cmdline for this connector
638  * @force: a %DRM_FORCE_<foo> state for forced mode sets
639  * @override_edid: has the EDID been overwritten through debugfs for testing?
640  * @encoder_ids: valid encoders for this connector
641  * @encoder: encoder driving this connector, if any
642  * @eld: EDID-like data, if present
643  * @dvi_dual: dual link DVI, if found
644  * @max_tmds_clock: max clock rate, if found
645  * @latency_present: AV delay info from ELD, if found
646  * @video_latency: video latency info from ELD, if found
647  * @audio_latency: audio latency info from ELD, if found
648  * @null_edid_counter: track sinks that give us all zeros for the EDID
649  * @bad_edid_counter: track sinks that give us an EDID with invalid checksum
650  * @debugfs_entry: debugfs directory for this connector
651  * @state: current atomic state for this connector
652  * @has_tile: is this connector connected to a tiled monitor
653  * @tile_group: tile group for the connected monitor
654  * @tile_is_single_monitor: whether the tile is one monitor housing
655  * @num_h_tile: number of horizontal tiles in the tile group
656  * @num_v_tile: number of vertical tiles in the tile group
657  * @tile_h_loc: horizontal location of this tile
658  * @tile_v_loc: vertical location of this tile
659  * @tile_h_size: horizontal size of this tile.
660  * @tile_v_size: vertical size of this tile.
661  *
662  * Each connector may be connected to one or more CRTCs, or may be clonable by
663  * another connector if they can share a CRTC.  Each connector also has a specific
664  * position in the broader display (referred to as a 'screen' though it could
665  * span multiple monitors).
666  */
667 struct drm_connector {
668 	struct drm_device *dev;
669 	struct device *kdev;
670 	struct device_attribute *attr;
671 	struct list_head head;
672 
673 	struct drm_mode_object base;
674 
675 	char *name;
676 	int connector_type;
677 	int connector_type_id;
678 	bool interlace_allowed;
679 	bool doublescan_allowed;
680 	bool stereo_allowed;
681 	struct list_head modes; /* list of modes on this connector */
682 
683 	enum drm_connector_status status;
684 
685 	/* these are modes added by probing with DDC or the BIOS */
686 	struct list_head probed_modes;
687 
688 	struct drm_display_info display_info;
689 	const struct drm_connector_funcs *funcs;
690 
691 	struct drm_property_blob *edid_blob_ptr;
692 	struct drm_object_properties properties;
693 
694 	struct drm_property_blob *path_blob_ptr;
695 
696 	struct drm_property_blob *tile_blob_ptr;
697 
698 	uint8_t polled; /* DRM_CONNECTOR_POLL_* */
699 
700 	/* requested DPMS state */
701 	int dpms;
702 
703 	void *helper_private;
704 
705 	/* forced on connector */
706 	struct drm_cmdline_mode cmdline_mode;
707 	enum drm_connector_force force;
708 	bool override_edid;
709 	uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER];
710 	struct drm_encoder *encoder; /* currently active encoder */
711 
712 	/* EDID bits */
713 	uint8_t eld[MAX_ELD_BYTES];
714 	bool dvi_dual;
715 	int max_tmds_clock;	/* in MHz */
716 	bool latency_present[2];
717 	int video_latency[2];	/* [0]: progressive, [1]: interlaced */
718 	int audio_latency[2];
719 	int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */
720 	unsigned bad_edid_counter;
721 
722 	struct dentry *debugfs_entry;
723 
724 	struct drm_connector_state *state;
725 
726 	/* DisplayID bits */
727 	bool has_tile;
728 	struct drm_tile_group *tile_group;
729 	bool tile_is_single_monitor;
730 
731 	uint8_t num_h_tile, num_v_tile;
732 	uint8_t tile_h_loc, tile_v_loc;
733 	uint16_t tile_h_size, tile_v_size;
734 };
735 
736 /**
737  * struct drm_plane_state - mutable plane state
738  * @plane: backpointer to the plane
739  * @crtc: currently bound CRTC, NULL if disabled
740  * @fb: currently bound framebuffer
741  * @fence: optional fence to wait for before scanning out @fb
742  * @crtc_x: left position of visible portion of plane on crtc
743  * @crtc_y: upper position of visible portion of plane on crtc
744  * @crtc_w: width of visible portion of plane on crtc
745  * @crtc_h: height of visible portion of plane on crtc
746  * @src_x: left position of visible portion of plane within
747  *	plane (in 16.16)
748  * @src_y: upper position of visible portion of plane within
749  *	plane (in 16.16)
750  * @src_w: width of visible portion of plane (in 16.16)
751  * @src_h: height of visible portion of plane (in 16.16)
752  * @state: backpointer to global drm_atomic_state
753  */
754 struct drm_plane_state {
755 	struct drm_plane *plane;
756 
757 	struct drm_crtc *crtc;   /* do not write directly, use drm_atomic_set_crtc_for_plane() */
758 	struct drm_framebuffer *fb;  /* do not write directly, use drm_atomic_set_fb_for_plane() */
759 	struct fence *fence;
760 
761 	/* Signed dest location allows it to be partially off screen */
762 	int32_t crtc_x, crtc_y;
763 	uint32_t crtc_w, crtc_h;
764 
765 	/* Source values are 16.16 fixed point */
766 	uint32_t src_x, src_y;
767 	uint32_t src_h, src_w;
768 
769 	/* Plane rotation */
770 	unsigned int rotation;
771 
772 	struct drm_atomic_state *state;
773 };
774 
775 
776 /**
777  * struct drm_plane_funcs - driver plane control functions
778  * @update_plane: update the plane configuration
779  * @disable_plane: shut down the plane
780  * @destroy: clean up plane resources
781  * @reset: reset plane after state has been invalidated (e.g. resume)
782  * @set_property: called when a property is changed
783  * @atomic_duplicate_state: duplicate the atomic state for this plane
784  * @atomic_destroy_state: destroy an atomic state for this plane
785  * @atomic_set_property: set a property on an atomic state for this plane
786  *    (do not call directly, use drm_atomic_plane_set_property())
787  * @atomic_get_property: get a property on an atomic state for this plane
788  *    (do not call directly, use drm_atomic_plane_get_property())
789  */
790 struct drm_plane_funcs {
791 	int (*update_plane)(struct drm_plane *plane,
792 			    struct drm_crtc *crtc, struct drm_framebuffer *fb,
793 			    int crtc_x, int crtc_y,
794 			    unsigned int crtc_w, unsigned int crtc_h,
795 			    uint32_t src_x, uint32_t src_y,
796 			    uint32_t src_w, uint32_t src_h);
797 	int (*disable_plane)(struct drm_plane *plane);
798 	void (*destroy)(struct drm_plane *plane);
799 	void (*reset)(struct drm_plane *plane);
800 
801 	int (*set_property)(struct drm_plane *plane,
802 			    struct drm_property *property, uint64_t val);
803 
804 	/* atomic update handling */
805 	struct drm_plane_state *(*atomic_duplicate_state)(struct drm_plane *plane);
806 	void (*atomic_destroy_state)(struct drm_plane *plane,
807 				     struct drm_plane_state *state);
808 	int (*atomic_set_property)(struct drm_plane *plane,
809 				   struct drm_plane_state *state,
810 				   struct drm_property *property,
811 				   uint64_t val);
812 	int (*atomic_get_property)(struct drm_plane *plane,
813 				   const struct drm_plane_state *state,
814 				   struct drm_property *property,
815 				   uint64_t *val);
816 };
817 
818 enum drm_plane_type {
819 	DRM_PLANE_TYPE_OVERLAY,
820 	DRM_PLANE_TYPE_PRIMARY,
821 	DRM_PLANE_TYPE_CURSOR,
822 };
823 
824 /**
825  * struct drm_plane - central DRM plane control structure
826  * @dev: DRM device this plane belongs to
827  * @head: for list management
828  * @base: base mode object
829  * @possible_crtcs: pipes this plane can be bound to
830  * @format_types: array of formats supported by this plane
831  * @format_count: number of formats supported
832  * @crtc: currently bound CRTC
833  * @fb: currently bound fb
834  * @old_fb: Temporary tracking of the old fb while a modeset is ongoing. Used by
835  * 	drm_mode_set_config_internal() to implement correct refcounting.
836  * @funcs: helper functions
837  * @properties: property tracking for this plane
838  * @type: type of plane (overlay, primary, cursor)
839  * @state: current atomic state for this plane
840  */
841 struct drm_plane {
842 	struct drm_device *dev;
843 	struct list_head head;
844 
845 	struct drm_modeset_lock mutex;
846 
847 	struct drm_mode_object base;
848 
849 	uint32_t possible_crtcs;
850 	uint32_t *format_types;
851 	uint32_t format_count;
852 
853 	struct drm_crtc *crtc;
854 	struct drm_framebuffer *fb;
855 
856 	struct drm_framebuffer *old_fb;
857 
858 	const struct drm_plane_funcs *funcs;
859 
860 	struct drm_object_properties properties;
861 
862 	enum drm_plane_type type;
863 
864 	void *helper_private;
865 
866 	struct drm_plane_state *state;
867 };
868 
869 /**
870  * struct drm_bridge_funcs - drm_bridge control functions
871  * @attach: Called during drm_bridge_attach
872  * @mode_fixup: Try to fixup (or reject entirely) proposed mode for this bridge
873  * @disable: Called right before encoder prepare, disables the bridge
874  * @post_disable: Called right after encoder prepare, for lockstepped disable
875  * @mode_set: Set this mode to the bridge
876  * @pre_enable: Called right before encoder commit, for lockstepped commit
877  * @enable: Called right after encoder commit, enables the bridge
878  */
879 struct drm_bridge_funcs {
880 	int (*attach)(struct drm_bridge *bridge);
881 	bool (*mode_fixup)(struct drm_bridge *bridge,
882 			   const struct drm_display_mode *mode,
883 			   struct drm_display_mode *adjusted_mode);
884 	void (*disable)(struct drm_bridge *bridge);
885 	void (*post_disable)(struct drm_bridge *bridge);
886 	void (*mode_set)(struct drm_bridge *bridge,
887 			 struct drm_display_mode *mode,
888 			 struct drm_display_mode *adjusted_mode);
889 	void (*pre_enable)(struct drm_bridge *bridge);
890 	void (*enable)(struct drm_bridge *bridge);
891 };
892 
893 /**
894  * struct drm_bridge - central DRM bridge control structure
895  * @dev: DRM device this bridge belongs to
896  * @of_node: device node pointer to the bridge
897  * @list: to keep track of all added bridges
898  * @base: base mode object
899  * @funcs: control functions
900  * @driver_private: pointer to the bridge driver's internal context
901  */
902 struct drm_bridge {
903 	struct drm_device *dev;
904 	struct drm_encoder *encoder;
905 #ifdef CONFIG_OF
906 	struct device_node *of_node;
907 #endif
908 	struct list_head list;
909 
910 	const struct drm_bridge_funcs *funcs;
911 	void *driver_private;
912 };
913 
914 /**
915  * struct struct drm_atomic_state - the global state object for atomic updates
916  * @dev: parent DRM device
917  * @allow_modeset: allow full modeset
918  * @legacy_cursor_update: hint to enforce legacy cursor ioctl semantics
919  * @planes: pointer to array of plane pointers
920  * @plane_states: pointer to array of plane states pointers
921  * @crtcs: pointer to array of CRTC pointers
922  * @crtc_states: pointer to array of CRTC states pointers
923  * @num_connector: size of the @connectors and @connector_states arrays
924  * @connectors: pointer to array of connector pointers
925  * @connector_states: pointer to array of connector states pointers
926  * @acquire_ctx: acquire context for this atomic modeset state update
927  */
928 struct drm_atomic_state {
929 	struct drm_device *dev;
930 	bool allow_modeset : 1;
931 	bool legacy_cursor_update : 1;
932 	struct drm_plane **planes;
933 	struct drm_plane_state **plane_states;
934 	struct drm_crtc **crtcs;
935 	struct drm_crtc_state **crtc_states;
936 	int num_connector;
937 	struct drm_connector **connectors;
938 	struct drm_connector_state **connector_states;
939 
940 	struct drm_modeset_acquire_ctx *acquire_ctx;
941 };
942 
943 
944 /**
945  * struct drm_mode_set - new values for a CRTC config change
946  * @fb: framebuffer to use for new config
947  * @crtc: CRTC whose configuration we're about to change
948  * @mode: mode timings to use
949  * @x: position of this CRTC relative to @fb
950  * @y: position of this CRTC relative to @fb
951  * @connectors: array of connectors to drive with this CRTC if possible
952  * @num_connectors: size of @connectors array
953  *
954  * Represents a single crtc the connectors that it drives with what mode
955  * and from which framebuffer it scans out from.
956  *
957  * This is used to set modes.
958  */
959 struct drm_mode_set {
960 	struct drm_framebuffer *fb;
961 	struct drm_crtc *crtc;
962 	struct drm_display_mode *mode;
963 
964 	uint32_t x;
965 	uint32_t y;
966 
967 	struct drm_connector **connectors;
968 	size_t num_connectors;
969 };
970 
971 /**
972  * struct drm_mode_config_funcs - basic driver provided mode setting functions
973  * @fb_create: create a new framebuffer object
974  * @output_poll_changed: function to handle output configuration changes
975  * @atomic_check: check whether a give atomic state update is possible
976  * @atomic_commit: commit an atomic state update previously verified with
977  * 	atomic_check()
978  *
979  * Some global (i.e. not per-CRTC, connector, etc) mode setting functions that
980  * involve drivers.
981  */
982 struct drm_mode_config_funcs {
983 	struct drm_framebuffer *(*fb_create)(struct drm_device *dev,
984 					     struct drm_file *file_priv,
985 					     struct drm_mode_fb_cmd2 *mode_cmd);
986 	void (*output_poll_changed)(struct drm_device *dev);
987 
988 	int (*atomic_check)(struct drm_device *dev,
989 			    struct drm_atomic_state *a);
990 	int (*atomic_commit)(struct drm_device *dev,
991 			     struct drm_atomic_state *a,
992 			     bool async);
993 };
994 
995 /**
996  * struct drm_mode_group - group of mode setting resources for potential sub-grouping
997  * @num_crtcs: CRTC count
998  * @num_encoders: encoder count
999  * @num_connectors: connector count
1000  * @num_bridges: bridge count
1001  * @id_list: list of KMS object IDs in this group
1002  *
1003  * Currently this simply tracks the global mode setting state.  But in the
1004  * future it could allow groups of objects to be set aside into independent
1005  * control groups for use by different user level processes (e.g. two X servers
1006  * running simultaneously on different heads, each with their own mode
1007  * configuration and freedom of mode setting).
1008  */
1009 struct drm_mode_group {
1010 	uint32_t num_crtcs;
1011 	uint32_t num_encoders;
1012 	uint32_t num_connectors;
1013 
1014 	/* list of object IDs for this group */
1015 	uint32_t *id_list;
1016 };
1017 
1018 /**
1019  * struct drm_mode_config - Mode configuration control structure
1020  * @mutex: mutex protecting KMS related lists and structures
1021  * @connection_mutex: ww mutex protecting connector state and routing
1022  * @acquire_ctx: global implicit acquire context used by atomic drivers for
1023  * 	legacy ioctls
1024  * @idr_mutex: mutex for KMS ID allocation and management
1025  * @crtc_idr: main KMS ID tracking object
1026  * @fb_lock: mutex to protect fb state and lists
1027  * @num_fb: number of fbs available
1028  * @fb_list: list of framebuffers available
1029  * @num_connector: number of connectors on this device
1030  * @connector_list: list of connector objects
1031  * @num_encoder: number of encoders on this device
1032  * @encoder_list: list of encoder objects
1033  * @num_overlay_plane: number of overlay planes on this device
1034  * @num_total_plane: number of universal (i.e. with primary/curso) planes on this device
1035  * @plane_list: list of plane objects
1036  * @num_crtc: number of CRTCs on this device
1037  * @crtc_list: list of CRTC objects
1038  * @property_list: list of property objects
1039  * @min_width: minimum pixel width on this device
1040  * @min_height: minimum pixel height on this device
1041  * @max_width: maximum pixel width on this device
1042  * @max_height: maximum pixel height on this device
1043  * @funcs: core driver provided mode setting functions
1044  * @fb_base: base address of the framebuffer
1045  * @poll_enabled: track polling support for this device
1046  * @poll_running: track polling status for this device
1047  * @output_poll_work: delayed work for polling in process context
1048  * @property_blob_list: list of all the blob property objects
1049  * @*_property: core property tracking
1050  * @preferred_depth: preferred RBG pixel depth, used by fb helpers
1051  * @prefer_shadow: hint to userspace to prefer shadow-fb rendering
1052  * @async_page_flip: does this device support async flips on the primary plane?
1053  * @cursor_width: hint to userspace for max cursor width
1054  * @cursor_height: hint to userspace for max cursor height
1055  *
1056  * Core mode resource tracking structure.  All CRTC, encoders, and connectors
1057  * enumerated by the driver are added here, as are global properties.  Some
1058  * global restrictions are also here, e.g. dimension restrictions.
1059  */
1060 struct drm_mode_config {
1061 	struct mutex mutex; /* protects configuration (mode lists etc.) */
1062 	struct drm_modeset_lock connection_mutex; /* protects connector->encoder and encoder->crtc links */
1063 	struct drm_modeset_acquire_ctx *acquire_ctx; /* for legacy _lock_all() / _unlock_all() */
1064 	struct mutex idr_mutex; /* for IDR management */
1065 	struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
1066 	struct idr tile_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
1067 	/* this is limited to one for now */
1068 
1069 	struct mutex fb_lock; /* proctects global and per-file fb lists */
1070 	int num_fb;
1071 	struct list_head fb_list;
1072 
1073 	int num_connector;
1074 	struct list_head connector_list;
1075 	int num_encoder;
1076 	struct list_head encoder_list;
1077 
1078 	/*
1079 	 * Track # of overlay planes separately from # of total planes.  By
1080 	 * default we only advertise overlay planes to userspace; if userspace
1081 	 * sets the "universal plane" capability bit, we'll go ahead and
1082 	 * expose all planes.
1083 	 */
1084 	int num_overlay_plane;
1085 	int num_total_plane;
1086 	struct list_head plane_list;
1087 
1088 	int num_crtc;
1089 	struct list_head crtc_list;
1090 
1091 	struct list_head property_list;
1092 
1093 	int min_width, min_height;
1094 	int max_width, max_height;
1095 	const struct drm_mode_config_funcs *funcs;
1096 	resource_size_t fb_base;
1097 
1098 	/* output poll support */
1099 	bool poll_enabled;
1100 	bool poll_running;
1101 	bool delayed_event;
1102 	struct delayed_work output_poll_work;
1103 
1104 	/* pointers to standard properties */
1105 	struct list_head property_blob_list;
1106 	struct drm_property *edid_property;
1107 	struct drm_property *dpms_property;
1108 	struct drm_property *path_property;
1109 	struct drm_property *tile_property;
1110 	struct drm_property *plane_type_property;
1111 	struct drm_property *rotation_property;
1112 	struct drm_property *prop_src_x;
1113 	struct drm_property *prop_src_y;
1114 	struct drm_property *prop_src_w;
1115 	struct drm_property *prop_src_h;
1116 	struct drm_property *prop_crtc_x;
1117 	struct drm_property *prop_crtc_y;
1118 	struct drm_property *prop_crtc_w;
1119 	struct drm_property *prop_crtc_h;
1120 	struct drm_property *prop_fb_id;
1121 	struct drm_property *prop_crtc_id;
1122 	struct drm_property *prop_active;
1123 
1124 	/* DVI-I properties */
1125 	struct drm_property *dvi_i_subconnector_property;
1126 	struct drm_property *dvi_i_select_subconnector_property;
1127 
1128 	/* TV properties */
1129 	struct drm_property *tv_subconnector_property;
1130 	struct drm_property *tv_select_subconnector_property;
1131 	struct drm_property *tv_mode_property;
1132 	struct drm_property *tv_left_margin_property;
1133 	struct drm_property *tv_right_margin_property;
1134 	struct drm_property *tv_top_margin_property;
1135 	struct drm_property *tv_bottom_margin_property;
1136 	struct drm_property *tv_brightness_property;
1137 	struct drm_property *tv_contrast_property;
1138 	struct drm_property *tv_flicker_reduction_property;
1139 	struct drm_property *tv_overscan_property;
1140 	struct drm_property *tv_saturation_property;
1141 	struct drm_property *tv_hue_property;
1142 
1143 	/* Optional properties */
1144 	struct drm_property *scaling_mode_property;
1145 	struct drm_property *aspect_ratio_property;
1146 	struct drm_property *dirty_info_property;
1147 
1148 	/* properties for virtual machine layout */
1149 	struct drm_property *suggested_x_property;
1150 	struct drm_property *suggested_y_property;
1151 
1152 	/* dumb ioctl parameters */
1153 	uint32_t preferred_depth, prefer_shadow;
1154 
1155 	/* whether async page flip is supported or not */
1156 	bool async_page_flip;
1157 
1158 	/* cursor size */
1159 	uint32_t cursor_width, cursor_height;
1160 };
1161 
1162 /**
1163  * drm_for_each_plane_mask - iterate over planes specified by bitmask
1164  * @plane: the loop cursor
1165  * @dev: the DRM device
1166  * @plane_mask: bitmask of plane indices
1167  *
1168  * Iterate over all planes specified by bitmask.
1169  */
1170 #define drm_for_each_plane_mask(plane, dev, plane_mask) \
1171 	list_for_each_entry((plane), &(dev)->mode_config.plane_list, head) \
1172 		if ((plane_mask) & (1 << drm_plane_index(plane)))
1173 
1174 
1175 #define obj_to_crtc(x) container_of(x, struct drm_crtc, base)
1176 #define obj_to_connector(x) container_of(x, struct drm_connector, base)
1177 #define obj_to_encoder(x) container_of(x, struct drm_encoder, base)
1178 #define obj_to_mode(x) container_of(x, struct drm_display_mode, base)
1179 #define obj_to_fb(x) container_of(x, struct drm_framebuffer, base)
1180 #define obj_to_property(x) container_of(x, struct drm_property, base)
1181 #define obj_to_blob(x) container_of(x, struct drm_property_blob, base)
1182 #define obj_to_plane(x) container_of(x, struct drm_plane, base)
1183 
1184 struct drm_prop_enum_list {
1185 	int type;
1186 	char *name;
1187 };
1188 
1189 extern int drm_crtc_init_with_planes(struct drm_device *dev,
1190 				     struct drm_crtc *crtc,
1191 				     struct drm_plane *primary,
1192 				     struct drm_plane *cursor,
1193 				     const struct drm_crtc_funcs *funcs);
1194 extern void drm_crtc_cleanup(struct drm_crtc *crtc);
1195 extern unsigned int drm_crtc_index(struct drm_crtc *crtc);
1196 
1197 /**
1198  * drm_crtc_mask - find the mask of a registered CRTC
1199  * @crtc: CRTC to find mask for
1200  *
1201  * Given a registered CRTC, return the mask bit of that CRTC for an
1202  * encoder's possible_crtcs field.
1203  */
1204 static inline uint32_t drm_crtc_mask(struct drm_crtc *crtc)
1205 {
1206 	return 1 << drm_crtc_index(crtc);
1207 }
1208 
1209 extern void drm_connector_ida_init(void);
1210 extern void drm_connector_ida_destroy(void);
1211 extern int drm_connector_init(struct drm_device *dev,
1212 			      struct drm_connector *connector,
1213 			      const struct drm_connector_funcs *funcs,
1214 			      int connector_type);
1215 int drm_connector_register(struct drm_connector *connector);
1216 void drm_connector_unregister(struct drm_connector *connector);
1217 
1218 extern void drm_connector_cleanup(struct drm_connector *connector);
1219 extern unsigned int drm_connector_index(struct drm_connector *connector);
1220 /* helper to unplug all connectors from sysfs for device */
1221 extern void drm_connector_unplug_all(struct drm_device *dev);
1222 
1223 extern int drm_bridge_add(struct drm_bridge *bridge);
1224 extern void drm_bridge_remove(struct drm_bridge *bridge);
1225 extern struct drm_bridge *of_drm_find_bridge(struct device_node *np);
1226 extern int drm_bridge_attach(struct drm_device *dev, struct drm_bridge *bridge);
1227 
1228 extern int drm_encoder_init(struct drm_device *dev,
1229 			    struct drm_encoder *encoder,
1230 			    const struct drm_encoder_funcs *funcs,
1231 			    int encoder_type);
1232 
1233 /**
1234  * drm_encoder_crtc_ok - can a given crtc drive a given encoder?
1235  * @encoder: encoder to test
1236  * @crtc: crtc to test
1237  *
1238  * Return false if @encoder can't be driven by @crtc, true otherwise.
1239  */
1240 static inline bool drm_encoder_crtc_ok(struct drm_encoder *encoder,
1241 				       struct drm_crtc *crtc)
1242 {
1243 	return !!(encoder->possible_crtcs & drm_crtc_mask(crtc));
1244 }
1245 
1246 extern int drm_universal_plane_init(struct drm_device *dev,
1247 				    struct drm_plane *plane,
1248 				    unsigned long possible_crtcs,
1249 				    const struct drm_plane_funcs *funcs,
1250 				    const uint32_t *formats,
1251 				    uint32_t format_count,
1252 				    enum drm_plane_type type);
1253 extern int drm_plane_init(struct drm_device *dev,
1254 			  struct drm_plane *plane,
1255 			  unsigned long possible_crtcs,
1256 			  const struct drm_plane_funcs *funcs,
1257 			  const uint32_t *formats, uint32_t format_count,
1258 			  bool is_primary);
1259 extern void drm_plane_cleanup(struct drm_plane *plane);
1260 extern unsigned int drm_plane_index(struct drm_plane *plane);
1261 extern void drm_plane_force_disable(struct drm_plane *plane);
1262 extern void drm_crtc_get_hv_timing(const struct drm_display_mode *mode,
1263 				   int *hdisplay, int *vdisplay);
1264 extern int drm_crtc_check_viewport(const struct drm_crtc *crtc,
1265 				   int x, int y,
1266 				   const struct drm_display_mode *mode,
1267 				   const struct drm_framebuffer *fb);
1268 
1269 extern void drm_encoder_cleanup(struct drm_encoder *encoder);
1270 
1271 extern const char *drm_get_connector_status_name(enum drm_connector_status status);
1272 extern const char *drm_get_subpixel_order_name(enum subpixel_order order);
1273 extern const char *drm_get_dpms_name(int val);
1274 extern const char *drm_get_dvi_i_subconnector_name(int val);
1275 extern const char *drm_get_dvi_i_select_name(int val);
1276 extern const char *drm_get_tv_subconnector_name(int val);
1277 extern const char *drm_get_tv_select_name(int val);
1278 extern void drm_fb_release(struct drm_file *file_priv);
1279 extern int drm_mode_group_init_legacy_group(struct drm_device *dev, struct drm_mode_group *group);
1280 extern void drm_mode_group_destroy(struct drm_mode_group *group);
1281 extern void drm_reinit_primary_mode_group(struct drm_device *dev);
1282 extern bool drm_probe_ddc(struct i2c_adapter *adapter);
1283 extern struct edid *drm_get_edid(struct drm_connector *connector,
1284 				 struct i2c_adapter *adapter);
1285 extern struct edid *drm_edid_duplicate(const struct edid *edid);
1286 extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid);
1287 extern void drm_mode_config_init(struct drm_device *dev);
1288 extern void drm_mode_config_reset(struct drm_device *dev);
1289 extern void drm_mode_config_cleanup(struct drm_device *dev);
1290 
1291 extern int drm_mode_connector_set_path_property(struct drm_connector *connector,
1292 						const char *path);
1293 int drm_mode_connector_set_tile_property(struct drm_connector *connector);
1294 extern int drm_mode_connector_update_edid_property(struct drm_connector *connector,
1295 						   const struct edid *edid);
1296 
1297 extern int drm_display_info_set_bus_formats(struct drm_display_info *info,
1298 					    const u32 *formats,
1299 					    unsigned int num_formats);
1300 
1301 static inline bool drm_property_type_is(struct drm_property *property,
1302 		uint32_t type)
1303 {
1304 	/* instanceof for props.. handles extended type vs original types: */
1305 	if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE)
1306 		return (property->flags & DRM_MODE_PROP_EXTENDED_TYPE) == type;
1307 	return property->flags & type;
1308 }
1309 
1310 static inline bool drm_property_type_valid(struct drm_property *property)
1311 {
1312 	if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE)
1313 		return !(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
1314 	return !!(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
1315 }
1316 
1317 extern int drm_object_property_set_value(struct drm_mode_object *obj,
1318 					 struct drm_property *property,
1319 					 uint64_t val);
1320 extern int drm_object_property_get_value(struct drm_mode_object *obj,
1321 					 struct drm_property *property,
1322 					 uint64_t *value);
1323 extern int drm_framebuffer_init(struct drm_device *dev,
1324 				struct drm_framebuffer *fb,
1325 				const struct drm_framebuffer_funcs *funcs);
1326 extern struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
1327 						      uint32_t id);
1328 extern void drm_framebuffer_unreference(struct drm_framebuffer *fb);
1329 extern void drm_framebuffer_reference(struct drm_framebuffer *fb);
1330 extern void drm_framebuffer_remove(struct drm_framebuffer *fb);
1331 extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
1332 extern void drm_framebuffer_unregister_private(struct drm_framebuffer *fb);
1333 
1334 extern void drm_object_attach_property(struct drm_mode_object *obj,
1335 				       struct drm_property *property,
1336 				       uint64_t init_val);
1337 extern struct drm_property *drm_property_create(struct drm_device *dev, int flags,
1338 						const char *name, int num_values);
1339 extern struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
1340 					 const char *name,
1341 					 const struct drm_prop_enum_list *props,
1342 					 int num_values);
1343 struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
1344 					 int flags, const char *name,
1345 					 const struct drm_prop_enum_list *props,
1346 					 int num_props,
1347 					 uint64_t supported_bits);
1348 struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
1349 					 const char *name,
1350 					 uint64_t min, uint64_t max);
1351 struct drm_property *drm_property_create_signed_range(struct drm_device *dev,
1352 					 int flags, const char *name,
1353 					 int64_t min, int64_t max);
1354 struct drm_property *drm_property_create_object(struct drm_device *dev,
1355 					 int flags, const char *name, uint32_t type);
1356 struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags,
1357 					 const char *name);
1358 extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property);
1359 extern int drm_property_add_enum(struct drm_property *property, int index,
1360 				 uint64_t value, const char *name);
1361 extern int drm_mode_create_dvi_i_properties(struct drm_device *dev);
1362 extern int drm_mode_create_tv_properties(struct drm_device *dev,
1363 					 unsigned int num_modes,
1364 					 char *modes[]);
1365 extern int drm_mode_create_scaling_mode_property(struct drm_device *dev);
1366 extern int drm_mode_create_aspect_ratio_property(struct drm_device *dev);
1367 extern int drm_mode_create_dirty_info_property(struct drm_device *dev);
1368 extern int drm_mode_create_suggested_offset_properties(struct drm_device *dev);
1369 extern bool drm_property_change_valid_get(struct drm_property *property,
1370 					 uint64_t value, struct drm_mode_object **ref);
1371 extern void drm_property_change_valid_put(struct drm_property *property,
1372 		struct drm_mode_object *ref);
1373 
1374 extern int drm_mode_connector_attach_encoder(struct drm_connector *connector,
1375 					     struct drm_encoder *encoder);
1376 extern int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
1377 					 int gamma_size);
1378 extern struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
1379 		uint32_t id, uint32_t type);
1380 
1381 /* IOCTLs */
1382 extern int drm_mode_getresources(struct drm_device *dev,
1383 				 void *data, struct drm_file *file_priv);
1384 extern int drm_mode_getplane_res(struct drm_device *dev, void *data,
1385 				   struct drm_file *file_priv);
1386 extern int drm_mode_getcrtc(struct drm_device *dev,
1387 			    void *data, struct drm_file *file_priv);
1388 extern int drm_mode_getconnector(struct drm_device *dev,
1389 			      void *data, struct drm_file *file_priv);
1390 extern int drm_mode_set_config_internal(struct drm_mode_set *set);
1391 extern int drm_mode_setcrtc(struct drm_device *dev,
1392 			    void *data, struct drm_file *file_priv);
1393 extern int drm_mode_getplane(struct drm_device *dev,
1394 			       void *data, struct drm_file *file_priv);
1395 extern int drm_mode_setplane(struct drm_device *dev,
1396 			       void *data, struct drm_file *file_priv);
1397 extern int drm_mode_cursor_ioctl(struct drm_device *dev,
1398 				void *data, struct drm_file *file_priv);
1399 extern int drm_mode_cursor2_ioctl(struct drm_device *dev,
1400 				void *data, struct drm_file *file_priv);
1401 extern int drm_mode_addfb(struct drm_device *dev,
1402 			  void *data, struct drm_file *file_priv);
1403 extern int drm_mode_addfb2(struct drm_device *dev,
1404 			   void *data, struct drm_file *file_priv);
1405 extern uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth);
1406 extern int drm_mode_rmfb(struct drm_device *dev,
1407 			 void *data, struct drm_file *file_priv);
1408 extern int drm_mode_getfb(struct drm_device *dev,
1409 			  void *data, struct drm_file *file_priv);
1410 extern int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
1411 				  void *data, struct drm_file *file_priv);
1412 
1413 extern int drm_mode_getproperty_ioctl(struct drm_device *dev,
1414 				      void *data, struct drm_file *file_priv);
1415 extern int drm_mode_getblob_ioctl(struct drm_device *dev,
1416 				  void *data, struct drm_file *file_priv);
1417 extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
1418 					      void *data, struct drm_file *file_priv);
1419 extern int drm_mode_getencoder(struct drm_device *dev,
1420 			       void *data, struct drm_file *file_priv);
1421 extern int drm_mode_gamma_get_ioctl(struct drm_device *dev,
1422 				    void *data, struct drm_file *file_priv);
1423 extern int drm_mode_gamma_set_ioctl(struct drm_device *dev,
1424 				    void *data, struct drm_file *file_priv);
1425 extern u8 drm_match_cea_mode(const struct drm_display_mode *to_match);
1426 extern enum hdmi_picture_aspect drm_get_cea_aspect_ratio(const u8 video_code);
1427 extern bool drm_detect_hdmi_monitor(struct edid *edid);
1428 extern bool drm_detect_monitor_audio(struct edid *edid);
1429 extern bool drm_rgb_quant_range_selectable(struct edid *edid);
1430 extern int drm_mode_page_flip_ioctl(struct drm_device *dev,
1431 				    void *data, struct drm_file *file_priv);
1432 extern int drm_add_modes_noedid(struct drm_connector *connector,
1433 				int hdisplay, int vdisplay);
1434 extern void drm_set_preferred_mode(struct drm_connector *connector,
1435 				   int hpref, int vpref);
1436 
1437 extern int drm_edid_header_is_valid(const u8 *raw_edid);
1438 extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid);
1439 extern bool drm_edid_is_valid(struct edid *edid);
1440 
1441 extern struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
1442 							 char topology[8]);
1443 extern struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev,
1444 					       char topology[8]);
1445 extern void drm_mode_put_tile_group(struct drm_device *dev,
1446 				   struct drm_tile_group *tg);
1447 struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
1448 					   int hsize, int vsize, int fresh,
1449 					   bool rb);
1450 
1451 extern int drm_mode_create_dumb_ioctl(struct drm_device *dev,
1452 				      void *data, struct drm_file *file_priv);
1453 extern int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
1454 				    void *data, struct drm_file *file_priv);
1455 extern int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
1456 				      void *data, struct drm_file *file_priv);
1457 extern int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
1458 					     struct drm_file *file_priv);
1459 extern int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
1460 					   struct drm_file *file_priv);
1461 extern int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
1462 				       struct drm_property *property,
1463 				       uint64_t value);
1464 extern int drm_mode_atomic_ioctl(struct drm_device *dev,
1465 				 void *data, struct drm_file *file_priv);
1466 
1467 extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
1468 				 int *bpp);
1469 extern int drm_format_num_planes(uint32_t format);
1470 extern int drm_format_plane_cpp(uint32_t format, int plane);
1471 extern int drm_format_horz_chroma_subsampling(uint32_t format);
1472 extern int drm_format_vert_chroma_subsampling(uint32_t format);
1473 extern const char *drm_get_format_name(uint32_t format);
1474 extern struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev,
1475 							      unsigned int supported_rotations);
1476 extern unsigned int drm_rotation_simplify(unsigned int rotation,
1477 					  unsigned int supported_rotations);
1478 
1479 /* Helpers */
1480 
1481 static inline struct drm_plane *drm_plane_find(struct drm_device *dev,
1482 		uint32_t id)
1483 {
1484 	struct drm_mode_object *mo;
1485 	mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PLANE);
1486 	return mo ? obj_to_plane(mo) : NULL;
1487 }
1488 
1489 static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev,
1490 	uint32_t id)
1491 {
1492 	struct drm_mode_object *mo;
1493 	mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CRTC);
1494 	return mo ? obj_to_crtc(mo) : NULL;
1495 }
1496 
1497 static inline struct drm_encoder *drm_encoder_find(struct drm_device *dev,
1498 	uint32_t id)
1499 {
1500 	struct drm_mode_object *mo;
1501 	mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
1502 	return mo ? obj_to_encoder(mo) : NULL;
1503 }
1504 
1505 static inline struct drm_connector *drm_connector_find(struct drm_device *dev,
1506 		uint32_t id)
1507 {
1508 	struct drm_mode_object *mo;
1509 	mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CONNECTOR);
1510 	return mo ? obj_to_connector(mo) : NULL;
1511 }
1512 
1513 static inline struct drm_property *drm_property_find(struct drm_device *dev,
1514 		uint32_t id)
1515 {
1516 	struct drm_mode_object *mo;
1517 	mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_PROPERTY);
1518 	return mo ? obj_to_property(mo) : NULL;
1519 }
1520 
1521 static inline struct drm_property_blob *
1522 drm_property_blob_find(struct drm_device *dev, uint32_t id)
1523 {
1524 	struct drm_mode_object *mo;
1525 	mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_BLOB);
1526 	return mo ? obj_to_blob(mo) : NULL;
1527 }
1528 
1529 /* Plane list iterator for legacy (overlay only) planes. */
1530 #define drm_for_each_legacy_plane(plane, planelist) \
1531 	list_for_each_entry(plane, planelist, head) \
1532 		if (plane->type == DRM_PLANE_TYPE_OVERLAY)
1533 
1534 #endif /* __DRM_CRTC_H__ */
1535