xref: /openbmc/linux/include/drm/drm_crtc.h (revision b34e08d5)
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 <drm/drm_mode.h>
35 #include <drm/drm_fourcc.h>
36 
37 struct drm_device;
38 struct drm_mode_set;
39 struct drm_framebuffer;
40 struct drm_object_properties;
41 struct drm_file;
42 struct drm_clip_rect;
43 
44 #define DRM_MODE_OBJECT_CRTC 0xcccccccc
45 #define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0
46 #define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0
47 #define DRM_MODE_OBJECT_MODE 0xdededede
48 #define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0
49 #define DRM_MODE_OBJECT_FB 0xfbfbfbfb
50 #define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
51 #define DRM_MODE_OBJECT_PLANE 0xeeeeeeee
52 #define DRM_MODE_OBJECT_BRIDGE 0xbdbdbdbd
53 
54 struct drm_mode_object {
55 	uint32_t id;
56 	uint32_t type;
57 	struct drm_object_properties *properties;
58 };
59 
60 #define DRM_OBJECT_MAX_PROPERTY 24
61 struct drm_object_properties {
62 	int count;
63 	uint32_t ids[DRM_OBJECT_MAX_PROPERTY];
64 	uint64_t values[DRM_OBJECT_MAX_PROPERTY];
65 };
66 
67 enum drm_connector_force {
68 	DRM_FORCE_UNSPECIFIED,
69 	DRM_FORCE_OFF,
70 	DRM_FORCE_ON,         /* force on analog part normally */
71 	DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */
72 };
73 
74 #include <drm/drm_modes.h>
75 
76 enum drm_connector_status {
77 	connector_status_connected = 1,
78 	connector_status_disconnected = 2,
79 	connector_status_unknown = 3,
80 };
81 
82 enum subpixel_order {
83 	SubPixelUnknown = 0,
84 	SubPixelHorizontalRGB,
85 	SubPixelHorizontalBGR,
86 	SubPixelVerticalRGB,
87 	SubPixelVerticalBGR,
88 	SubPixelNone,
89 };
90 
91 #define DRM_COLOR_FORMAT_RGB444		(1<<0)
92 #define DRM_COLOR_FORMAT_YCRCB444	(1<<1)
93 #define DRM_COLOR_FORMAT_YCRCB422	(1<<2)
94 /*
95  * Describes a given display (e.g. CRT or flat panel) and its limitations.
96  */
97 struct drm_display_info {
98 	char name[DRM_DISPLAY_INFO_LEN];
99 
100 	/* Physical size */
101         unsigned int width_mm;
102 	unsigned int height_mm;
103 
104 	/* Clock limits FIXME: storage format */
105 	unsigned int min_vfreq, max_vfreq;
106 	unsigned int min_hfreq, max_hfreq;
107 	unsigned int pixel_clock;
108 	unsigned int bpc;
109 
110 	enum subpixel_order subpixel_order;
111 	u32 color_formats;
112 
113 	u8 cea_rev;
114 };
115 
116 struct drm_framebuffer_funcs {
117 	/* note: use drm_framebuffer_remove() */
118 	void (*destroy)(struct drm_framebuffer *framebuffer);
119 	int (*create_handle)(struct drm_framebuffer *fb,
120 			     struct drm_file *file_priv,
121 			     unsigned int *handle);
122 	/**
123 	 * Optinal callback for the dirty fb ioctl.
124 	 *
125 	 * Userspace can notify the driver via this callback
126 	 * that a area of the framebuffer has changed and should
127 	 * be flushed to the display hardware.
128 	 *
129 	 * See documentation in drm_mode.h for the struct
130 	 * drm_mode_fb_dirty_cmd for more information as all
131 	 * the semantics and arguments have a one to one mapping
132 	 * on this function.
133 	 */
134 	int (*dirty)(struct drm_framebuffer *framebuffer,
135 		     struct drm_file *file_priv, unsigned flags,
136 		     unsigned color, struct drm_clip_rect *clips,
137 		     unsigned num_clips);
138 };
139 
140 struct drm_framebuffer {
141 	struct drm_device *dev;
142 	/*
143 	 * Note that the fb is refcounted for the benefit of driver internals,
144 	 * for example some hw, disabling a CRTC/plane is asynchronous, and
145 	 * scanout does not actually complete until the next vblank.  So some
146 	 * cleanup (like releasing the reference(s) on the backing GEM bo(s))
147 	 * should be deferred.  In cases like this, the driver would like to
148 	 * hold a ref to the fb even though it has already been removed from
149 	 * userspace perspective.
150 	 */
151 	struct kref refcount;
152 	/*
153 	 * Place on the dev->mode_config.fb_list, access protected by
154 	 * dev->mode_config.fb_lock.
155 	 */
156 	struct list_head head;
157 	struct drm_mode_object base;
158 	const struct drm_framebuffer_funcs *funcs;
159 	unsigned int pitches[4];
160 	unsigned int offsets[4];
161 	unsigned int width;
162 	unsigned int height;
163 	/* depth can be 15 or 16 */
164 	unsigned int depth;
165 	int bits_per_pixel;
166 	int flags;
167 	uint32_t pixel_format; /* fourcc format */
168 	struct list_head filp_head;
169 	/* if you are using the helper */
170 	void *helper_private;
171 };
172 
173 struct drm_property_blob {
174 	struct drm_mode_object base;
175 	struct list_head head;
176 	unsigned int length;
177 	unsigned char data[];
178 };
179 
180 struct drm_property_enum {
181 	uint64_t value;
182 	struct list_head head;
183 	char name[DRM_PROP_NAME_LEN];
184 };
185 
186 struct drm_property {
187 	struct list_head head;
188 	struct drm_mode_object base;
189 	uint32_t flags;
190 	char name[DRM_PROP_NAME_LEN];
191 	uint32_t num_values;
192 	uint64_t *values;
193 
194 	struct list_head enum_blob_list;
195 };
196 
197 struct drm_crtc;
198 struct drm_connector;
199 struct drm_encoder;
200 struct drm_pending_vblank_event;
201 struct drm_plane;
202 struct drm_bridge;
203 
204 /**
205  * drm_crtc_funcs - control CRTCs for a given device
206  * @save: save CRTC state
207  * @restore: restore CRTC state
208  * @reset: reset CRTC after state has been invalidated (e.g. resume)
209  * @cursor_set: setup the cursor
210  * @cursor_move: move the cursor
211  * @gamma_set: specify color ramp for CRTC
212  * @destroy: deinit and free object
213  * @set_property: called when a property is changed
214  * @set_config: apply a new CRTC configuration
215  * @page_flip: initiate a page flip
216  *
217  * The drm_crtc_funcs structure is the central CRTC management structure
218  * in the DRM.  Each CRTC controls one or more connectors (note that the name
219  * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc.
220  * connectors, not just CRTs).
221  *
222  * Each driver is responsible for filling out this structure at startup time,
223  * in addition to providing other modesetting features, like i2c and DDC
224  * bus accessors.
225  */
226 struct drm_crtc_funcs {
227 	/* Save CRTC state */
228 	void (*save)(struct drm_crtc *crtc); /* suspend? */
229 	/* Restore CRTC state */
230 	void (*restore)(struct drm_crtc *crtc); /* resume? */
231 	/* Reset CRTC state */
232 	void (*reset)(struct drm_crtc *crtc);
233 
234 	/* cursor controls */
235 	int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,
236 			  uint32_t handle, uint32_t width, uint32_t height);
237 	int (*cursor_set2)(struct drm_crtc *crtc, struct drm_file *file_priv,
238 			   uint32_t handle, uint32_t width, uint32_t height,
239 			   int32_t hot_x, int32_t hot_y);
240 	int (*cursor_move)(struct drm_crtc *crtc, int x, int y);
241 
242 	/* Set gamma on the CRTC */
243 	void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
244 			  uint32_t start, uint32_t size);
245 	/* Object destroy routine */
246 	void (*destroy)(struct drm_crtc *crtc);
247 
248 	int (*set_config)(struct drm_mode_set *set);
249 
250 	/*
251 	 * Flip to the given framebuffer.  This implements the page
252 	 * flip ioctl described in drm_mode.h, specifically, the
253 	 * implementation must return immediately and block all
254 	 * rendering to the current fb until the flip has completed.
255 	 * If userspace set the event flag in the ioctl, the event
256 	 * argument will point to an event to send back when the flip
257 	 * completes, otherwise it will be NULL.
258 	 */
259 	int (*page_flip)(struct drm_crtc *crtc,
260 			 struct drm_framebuffer *fb,
261 			 struct drm_pending_vblank_event *event,
262 			 uint32_t flags);
263 
264 	int (*set_property)(struct drm_crtc *crtc,
265 			    struct drm_property *property, uint64_t val);
266 };
267 
268 /**
269  * drm_crtc - central CRTC control structure
270  * @dev: parent DRM device
271  * @head: list management
272  * @base: base KMS object for ID tracking etc.
273  * @primary: primary plane for this CRTC
274  * @cursor: cursor plane for this CRTC
275  * @enabled: is this CRTC enabled?
276  * @mode: current mode timings
277  * @hwmode: mode timings as programmed to hw regs
278  * @invert_dimensions: for purposes of error checking crtc vs fb sizes,
279  *    invert the width/height of the crtc.  This is used if the driver
280  *    is performing 90 or 270 degree rotated scanout
281  * @x: x position on screen
282  * @y: y position on screen
283  * @funcs: CRTC control functions
284  * @gamma_size: size of gamma ramp
285  * @gamma_store: gamma ramp values
286  * @framedur_ns: precise frame timing
287  * @framedur_ns: precise line timing
288  * @pixeldur_ns: precise pixel timing
289  * @helper_private: mid-layer private data
290  * @properties: property tracking for this CRTC
291  *
292  * Each CRTC may have one or more connectors associated with it.  This structure
293  * allows the CRTC to be controlled.
294  */
295 struct drm_crtc {
296 	struct drm_device *dev;
297 	struct list_head head;
298 
299 	/**
300 	 * crtc mutex
301 	 *
302 	 * This provides a read lock for the overall crtc state (mode, dpms
303 	 * state, ...) and a write lock for everything which can be update
304 	 * without a full modeset (fb, cursor data, ...)
305 	 */
306 	struct mutex mutex;
307 
308 	struct drm_mode_object base;
309 
310 	/* primary and cursor planes for CRTC */
311 	struct drm_plane *primary;
312 	struct drm_plane *cursor;
313 
314 	/* Temporary tracking of the old fb while a modeset is ongoing. Used
315 	 * by drm_mode_set_config_internal to implement correct refcounting. */
316 	struct drm_framebuffer *old_fb;
317 
318 	bool enabled;
319 
320 	/* Requested mode from modesetting. */
321 	struct drm_display_mode mode;
322 
323 	/* Programmed mode in hw, after adjustments for encoders,
324 	 * crtc, panel scaling etc. Needed for timestamping etc.
325 	 */
326 	struct drm_display_mode hwmode;
327 
328 	bool invert_dimensions;
329 
330 	int x, y;
331 	const struct drm_crtc_funcs *funcs;
332 
333 	/* CRTC gamma size for reporting to userspace */
334 	uint32_t gamma_size;
335 	uint16_t *gamma_store;
336 
337 	/* Constants needed for precise vblank and swap timestamping. */
338 	int framedur_ns, linedur_ns, pixeldur_ns;
339 
340 	/* if you are using the helper */
341 	void *helper_private;
342 
343 	struct drm_object_properties properties;
344 };
345 
346 
347 /**
348  * drm_connector_funcs - control connectors on a given device
349  * @dpms: set power state (see drm_crtc_funcs above)
350  * @save: save connector state
351  * @restore: restore connector state
352  * @reset: reset connector after state has been invalidated (e.g. resume)
353  * @detect: is this connector active?
354  * @fill_modes: fill mode list for this connector
355  * @set_property: property for this connector may need an update
356  * @destroy: make object go away
357  * @force: notify the driver that the connector is forced on
358  *
359  * Each CRTC may have one or more connectors attached to it.  The functions
360  * below allow the core DRM code to control connectors, enumerate available modes,
361  * etc.
362  */
363 struct drm_connector_funcs {
364 	void (*dpms)(struct drm_connector *connector, int mode);
365 	void (*save)(struct drm_connector *connector);
366 	void (*restore)(struct drm_connector *connector);
367 	void (*reset)(struct drm_connector *connector);
368 
369 	/* Check to see if anything is attached to the connector.
370 	 * @force is set to false whilst polling, true when checking the
371 	 * connector due to user request. @force can be used by the driver
372 	 * to avoid expensive, destructive operations during automated
373 	 * probing.
374 	 */
375 	enum drm_connector_status (*detect)(struct drm_connector *connector,
376 					    bool force);
377 	int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);
378 	int (*set_property)(struct drm_connector *connector, struct drm_property *property,
379 			     uint64_t val);
380 	void (*destroy)(struct drm_connector *connector);
381 	void (*force)(struct drm_connector *connector);
382 };
383 
384 /**
385  * drm_encoder_funcs - encoder controls
386  * @reset: reset state (e.g. at init or resume time)
387  * @destroy: cleanup and free associated data
388  *
389  * Encoders sit between CRTCs and connectors.
390  */
391 struct drm_encoder_funcs {
392 	void (*reset)(struct drm_encoder *encoder);
393 	void (*destroy)(struct drm_encoder *encoder);
394 };
395 
396 #define DRM_CONNECTOR_MAX_ENCODER 3
397 
398 /**
399  * drm_encoder - central DRM encoder structure
400  * @dev: parent DRM device
401  * @head: list management
402  * @base: base KMS object
403  * @encoder_type: one of the %DRM_MODE_ENCODER_<foo> types in drm_mode.h
404  * @possible_crtcs: bitmask of potential CRTC bindings
405  * @possible_clones: bitmask of potential sibling encoders for cloning
406  * @crtc: currently bound CRTC
407  * @bridge: bridge associated to the encoder
408  * @funcs: control functions
409  * @helper_private: mid-layer private data
410  *
411  * CRTCs drive pixels to encoders, which convert them into signals
412  * appropriate for a given connector or set of connectors.
413  */
414 struct drm_encoder {
415 	struct drm_device *dev;
416 	struct list_head head;
417 
418 	struct drm_mode_object base;
419 	int encoder_type;
420 	uint32_t possible_crtcs;
421 	uint32_t possible_clones;
422 
423 	struct drm_crtc *crtc;
424 	struct drm_bridge *bridge;
425 	const struct drm_encoder_funcs *funcs;
426 	void *helper_private;
427 };
428 
429 /* should we poll this connector for connects and disconnects */
430 /* hot plug detectable */
431 #define DRM_CONNECTOR_POLL_HPD (1 << 0)
432 /* poll for connections */
433 #define DRM_CONNECTOR_POLL_CONNECT (1 << 1)
434 /* can cleanly poll for disconnections without flickering the screen */
435 /* DACs should rarely do this without a lot of testing */
436 #define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2)
437 
438 #define MAX_ELD_BYTES	128
439 
440 /**
441  * drm_connector - central DRM connector control structure
442  * @dev: parent DRM device
443  * @kdev: kernel device for sysfs attributes
444  * @attr: sysfs attributes
445  * @head: list management
446  * @base: base KMS object
447  * @connector_type: one of the %DRM_MODE_CONNECTOR_<foo> types from drm_mode.h
448  * @connector_type_id: index into connector type enum
449  * @interlace_allowed: can this connector handle interlaced modes?
450  * @doublescan_allowed: can this connector handle doublescan?
451  * @modes: modes available on this connector (from fill_modes() + user)
452  * @status: one of the drm_connector_status enums (connected, not, or unknown)
453  * @probed_modes: list of modes derived directly from the display
454  * @display_info: information about attached display (e.g. from EDID)
455  * @funcs: connector control functions
456  * @edid_blob_ptr: DRM property containing EDID if present
457  * @properties: property tracking for this connector
458  * @polled: a %DRM_CONNECTOR_POLL_<foo> value for core driven polling
459  * @dpms: current dpms state
460  * @helper_private: mid-layer private data
461  * @force: a %DRM_FORCE_<foo> state for forced mode sets
462  * @encoder_ids: valid encoders for this connector
463  * @encoder: encoder driving this connector, if any
464  * @eld: EDID-like data, if present
465  * @dvi_dual: dual link DVI, if found
466  * @max_tmds_clock: max clock rate, if found
467  * @latency_present: AV delay info from ELD, if found
468  * @video_latency: video latency info from ELD, if found
469  * @audio_latency: audio latency info from ELD, if found
470  * @null_edid_counter: track sinks that give us all zeros for the EDID
471  *
472  * Each connector may be connected to one or more CRTCs, or may be clonable by
473  * another connector if they can share a CRTC.  Each connector also has a specific
474  * position in the broader display (referred to as a 'screen' though it could
475  * span multiple monitors).
476  */
477 struct drm_connector {
478 	struct drm_device *dev;
479 	struct device *kdev;
480 	struct device_attribute *attr;
481 	struct list_head head;
482 
483 	struct drm_mode_object base;
484 
485 	int connector_type;
486 	int connector_type_id;
487 	bool interlace_allowed;
488 	bool doublescan_allowed;
489 	bool stereo_allowed;
490 	struct list_head modes; /* list of modes on this connector */
491 
492 	enum drm_connector_status status;
493 
494 	/* these are modes added by probing with DDC or the BIOS */
495 	struct list_head probed_modes;
496 
497 	struct drm_display_info display_info;
498 	const struct drm_connector_funcs *funcs;
499 
500 	struct drm_property_blob *edid_blob_ptr;
501 	struct drm_object_properties properties;
502 
503 	uint8_t polled; /* DRM_CONNECTOR_POLL_* */
504 
505 	/* requested DPMS state */
506 	int dpms;
507 
508 	void *helper_private;
509 
510 	/* forced on connector */
511 	enum drm_connector_force force;
512 	uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER];
513 	struct drm_encoder *encoder; /* currently active encoder */
514 
515 	/* EDID bits */
516 	uint8_t eld[MAX_ELD_BYTES];
517 	bool dvi_dual;
518 	int max_tmds_clock;	/* in MHz */
519 	bool latency_present[2];
520 	int video_latency[2];	/* [0]: progressive, [1]: interlaced */
521 	int audio_latency[2];
522 	int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */
523 	unsigned bad_edid_counter;
524 };
525 
526 /**
527  * drm_plane_funcs - driver plane control functions
528  * @update_plane: update the plane configuration
529  * @disable_plane: shut down the plane
530  * @destroy: clean up plane resources
531  * @set_property: called when a property is changed
532  */
533 struct drm_plane_funcs {
534 	int (*update_plane)(struct drm_plane *plane,
535 			    struct drm_crtc *crtc, struct drm_framebuffer *fb,
536 			    int crtc_x, int crtc_y,
537 			    unsigned int crtc_w, unsigned int crtc_h,
538 			    uint32_t src_x, uint32_t src_y,
539 			    uint32_t src_w, uint32_t src_h);
540 	int (*disable_plane)(struct drm_plane *plane);
541 	void (*destroy)(struct drm_plane *plane);
542 
543 	int (*set_property)(struct drm_plane *plane,
544 			    struct drm_property *property, uint64_t val);
545 };
546 
547 enum drm_plane_type {
548 	DRM_PLANE_TYPE_OVERLAY,
549 	DRM_PLANE_TYPE_PRIMARY,
550 	DRM_PLANE_TYPE_CURSOR,
551 };
552 
553 /**
554  * drm_plane - central DRM plane control structure
555  * @dev: DRM device this plane belongs to
556  * @head: for list management
557  * @base: base mode object
558  * @possible_crtcs: pipes this plane can be bound to
559  * @format_types: array of formats supported by this plane
560  * @format_count: number of formats supported
561  * @crtc: currently bound CRTC
562  * @fb: currently bound fb
563  * @funcs: helper functions
564  * @properties: property tracking for this plane
565  * @type: type of plane (overlay, primary, cursor)
566  */
567 struct drm_plane {
568 	struct drm_device *dev;
569 	struct list_head head;
570 
571 	struct drm_mode_object base;
572 
573 	uint32_t possible_crtcs;
574 	uint32_t *format_types;
575 	uint32_t format_count;
576 
577 	struct drm_crtc *crtc;
578 	struct drm_framebuffer *fb;
579 
580 	const struct drm_plane_funcs *funcs;
581 
582 	struct drm_object_properties properties;
583 
584 	enum drm_plane_type type;
585 };
586 
587 /**
588  * drm_bridge_funcs - drm_bridge control functions
589  * @mode_fixup: Try to fixup (or reject entirely) proposed mode for this bridge
590  * @disable: Called right before encoder prepare, disables the bridge
591  * @post_disable: Called right after encoder prepare, for lockstepped disable
592  * @mode_set: Set this mode to the bridge
593  * @pre_enable: Called right before encoder commit, for lockstepped commit
594  * @enable: Called right after encoder commit, enables the bridge
595  * @destroy: make object go away
596  */
597 struct drm_bridge_funcs {
598 	bool (*mode_fixup)(struct drm_bridge *bridge,
599 			   const struct drm_display_mode *mode,
600 			   struct drm_display_mode *adjusted_mode);
601 	void (*disable)(struct drm_bridge *bridge);
602 	void (*post_disable)(struct drm_bridge *bridge);
603 	void (*mode_set)(struct drm_bridge *bridge,
604 			 struct drm_display_mode *mode,
605 			 struct drm_display_mode *adjusted_mode);
606 	void (*pre_enable)(struct drm_bridge *bridge);
607 	void (*enable)(struct drm_bridge *bridge);
608 	void (*destroy)(struct drm_bridge *bridge);
609 };
610 
611 /**
612  * drm_bridge - central DRM bridge control structure
613  * @dev: DRM device this bridge belongs to
614  * @head: list management
615  * @base: base mode object
616  * @funcs: control functions
617  * @driver_private: pointer to the bridge driver's internal context
618  */
619 struct drm_bridge {
620 	struct drm_device *dev;
621 	struct list_head head;
622 
623 	struct drm_mode_object base;
624 
625 	const struct drm_bridge_funcs *funcs;
626 	void *driver_private;
627 };
628 
629 /**
630  * drm_mode_set - new values for a CRTC config change
631  * @head: list management
632  * @fb: framebuffer to use for new config
633  * @crtc: CRTC whose configuration we're about to change
634  * @mode: mode timings to use
635  * @x: position of this CRTC relative to @fb
636  * @y: position of this CRTC relative to @fb
637  * @connectors: array of connectors to drive with this CRTC if possible
638  * @num_connectors: size of @connectors array
639  *
640  * Represents a single crtc the connectors that it drives with what mode
641  * and from which framebuffer it scans out from.
642  *
643  * This is used to set modes.
644  */
645 struct drm_mode_set {
646 	struct drm_framebuffer *fb;
647 	struct drm_crtc *crtc;
648 	struct drm_display_mode *mode;
649 
650 	uint32_t x;
651 	uint32_t y;
652 
653 	struct drm_connector **connectors;
654 	size_t num_connectors;
655 };
656 
657 /**
658  * struct drm_mode_config_funcs - basic driver provided mode setting functions
659  * @fb_create: create a new framebuffer object
660  * @output_poll_changed: function to handle output configuration changes
661  *
662  * Some global (i.e. not per-CRTC, connector, etc) mode setting functions that
663  * involve drivers.
664  */
665 struct drm_mode_config_funcs {
666 	struct drm_framebuffer *(*fb_create)(struct drm_device *dev,
667 					     struct drm_file *file_priv,
668 					     struct drm_mode_fb_cmd2 *mode_cmd);
669 	void (*output_poll_changed)(struct drm_device *dev);
670 };
671 
672 /**
673  * drm_mode_group - group of mode setting resources for potential sub-grouping
674  * @num_crtcs: CRTC count
675  * @num_encoders: encoder count
676  * @num_connectors: connector count
677  * @id_list: list of KMS object IDs in this group
678  *
679  * Currently this simply tracks the global mode setting state.  But in the
680  * future it could allow groups of objects to be set aside into independent
681  * control groups for use by different user level processes (e.g. two X servers
682  * running simultaneously on different heads, each with their own mode
683  * configuration and freedom of mode setting).
684  */
685 struct drm_mode_group {
686 	uint32_t num_crtcs;
687 	uint32_t num_encoders;
688 	uint32_t num_connectors;
689 	uint32_t num_bridges;
690 
691 	/* list of object IDs for this group */
692 	uint32_t *id_list;
693 };
694 
695 /**
696  * drm_mode_config - Mode configuration control structure
697  * @mutex: mutex protecting KMS related lists and structures
698  * @idr_mutex: mutex for KMS ID allocation and management
699  * @crtc_idr: main KMS ID tracking object
700  * @num_fb: number of fbs available
701  * @fb_list: list of framebuffers available
702  * @num_connector: number of connectors on this device
703  * @connector_list: list of connector objects
704  * @num_bridge: number of bridges on this device
705  * @bridge_list: list of bridge objects
706  * @num_encoder: number of encoders on this device
707  * @encoder_list: list of encoder objects
708  * @num_crtc: number of CRTCs on this device
709  * @crtc_list: list of CRTC objects
710  * @min_width: minimum pixel width on this device
711  * @min_height: minimum pixel height on this device
712  * @max_width: maximum pixel width on this device
713  * @max_height: maximum pixel height on this device
714  * @funcs: core driver provided mode setting functions
715  * @fb_base: base address of the framebuffer
716  * @poll_enabled: track polling status for this device
717  * @output_poll_work: delayed work for polling in process context
718  * @*_property: core property tracking
719  *
720  * Core mode resource tracking structure.  All CRTC, encoders, and connectors
721  * enumerated by the driver are added here, as are global properties.  Some
722  * global restrictions are also here, e.g. dimension restrictions.
723  */
724 struct drm_mode_config {
725 	struct mutex mutex; /* protects configuration (mode lists etc.) */
726 	struct mutex idr_mutex; /* for IDR management */
727 	struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
728 	/* this is limited to one for now */
729 
730 
731 	/**
732 	 * fb_lock - mutex to protect fb state
733 	 *
734 	 * Besides the global fb list his also protects the fbs list in the
735 	 * file_priv
736 	 */
737 	struct mutex fb_lock;
738 	int num_fb;
739 	struct list_head fb_list;
740 
741 	int num_connector;
742 	struct list_head connector_list;
743 	int num_bridge;
744 	struct list_head bridge_list;
745 	int num_encoder;
746 	struct list_head encoder_list;
747 
748 	/*
749 	 * Track # of overlay planes separately from # of total planes.  By
750 	 * default we only advertise overlay planes to userspace; if userspace
751 	 * sets the "universal plane" capability bit, we'll go ahead and
752 	 * expose all planes.
753 	 */
754 	int num_overlay_plane;
755 	int num_total_plane;
756 	struct list_head plane_list;
757 
758 	int num_crtc;
759 	struct list_head crtc_list;
760 
761 	struct list_head property_list;
762 
763 	int min_width, min_height;
764 	int max_width, max_height;
765 	const struct drm_mode_config_funcs *funcs;
766 	resource_size_t fb_base;
767 
768 	/* output poll support */
769 	bool poll_enabled;
770 	bool poll_running;
771 	struct delayed_work output_poll_work;
772 
773 	/* pointers to standard properties */
774 	struct list_head property_blob_list;
775 	struct drm_property *edid_property;
776 	struct drm_property *dpms_property;
777 	struct drm_property *plane_type_property;
778 
779 	/* DVI-I properties */
780 	struct drm_property *dvi_i_subconnector_property;
781 	struct drm_property *dvi_i_select_subconnector_property;
782 
783 	/* TV properties */
784 	struct drm_property *tv_subconnector_property;
785 	struct drm_property *tv_select_subconnector_property;
786 	struct drm_property *tv_mode_property;
787 	struct drm_property *tv_left_margin_property;
788 	struct drm_property *tv_right_margin_property;
789 	struct drm_property *tv_top_margin_property;
790 	struct drm_property *tv_bottom_margin_property;
791 	struct drm_property *tv_brightness_property;
792 	struct drm_property *tv_contrast_property;
793 	struct drm_property *tv_flicker_reduction_property;
794 	struct drm_property *tv_overscan_property;
795 	struct drm_property *tv_saturation_property;
796 	struct drm_property *tv_hue_property;
797 
798 	/* Optional properties */
799 	struct drm_property *scaling_mode_property;
800 	struct drm_property *dirty_info_property;
801 
802 	/* dumb ioctl parameters */
803 	uint32_t preferred_depth, prefer_shadow;
804 
805 	/* whether async page flip is supported or not */
806 	bool async_page_flip;
807 
808 	/* cursor size */
809 	uint32_t cursor_width, cursor_height;
810 };
811 
812 #define obj_to_crtc(x) container_of(x, struct drm_crtc, base)
813 #define obj_to_connector(x) container_of(x, struct drm_connector, base)
814 #define obj_to_encoder(x) container_of(x, struct drm_encoder, base)
815 #define obj_to_mode(x) container_of(x, struct drm_display_mode, base)
816 #define obj_to_fb(x) container_of(x, struct drm_framebuffer, base)
817 #define obj_to_property(x) container_of(x, struct drm_property, base)
818 #define obj_to_blob(x) container_of(x, struct drm_property_blob, base)
819 #define obj_to_plane(x) container_of(x, struct drm_plane, base)
820 
821 struct drm_prop_enum_list {
822 	int type;
823 	char *name;
824 };
825 
826 extern void drm_modeset_lock_all(struct drm_device *dev);
827 extern void drm_modeset_unlock_all(struct drm_device *dev);
828 extern void drm_warn_on_modeset_not_all_locked(struct drm_device *dev);
829 
830 extern int drm_crtc_init_with_planes(struct drm_device *dev,
831 				     struct drm_crtc *crtc,
832 				     struct drm_plane *primary,
833 				     void *cursor,
834 				     const struct drm_crtc_funcs *funcs);
835 extern int drm_crtc_init(struct drm_device *dev,
836 			 struct drm_crtc *crtc,
837 			 const struct drm_crtc_funcs *funcs);
838 extern void drm_crtc_cleanup(struct drm_crtc *crtc);
839 extern unsigned int drm_crtc_index(struct drm_crtc *crtc);
840 
841 /**
842  * drm_crtc_mask - find the mask of a registered CRTC
843  * @crtc: CRTC to find mask for
844  *
845  * Given a registered CRTC, return the mask bit of that CRTC for an
846  * encoder's possible_crtcs field.
847  */
848 static inline uint32_t drm_crtc_mask(struct drm_crtc *crtc)
849 {
850 	return 1 << drm_crtc_index(crtc);
851 }
852 
853 extern void drm_connector_ida_init(void);
854 extern void drm_connector_ida_destroy(void);
855 extern int drm_connector_init(struct drm_device *dev,
856 			      struct drm_connector *connector,
857 			      const struct drm_connector_funcs *funcs,
858 			      int connector_type);
859 
860 extern void drm_connector_cleanup(struct drm_connector *connector);
861 /* helper to unplug all connectors from sysfs for device */
862 extern void drm_connector_unplug_all(struct drm_device *dev);
863 
864 extern int drm_bridge_init(struct drm_device *dev, struct drm_bridge *bridge,
865 			   const struct drm_bridge_funcs *funcs);
866 extern void drm_bridge_cleanup(struct drm_bridge *bridge);
867 
868 extern int drm_encoder_init(struct drm_device *dev,
869 			    struct drm_encoder *encoder,
870 			    const struct drm_encoder_funcs *funcs,
871 			    int encoder_type);
872 
873 /**
874  * drm_encoder_crtc_ok - can a given crtc drive a given encoder?
875  * @encoder: encoder to test
876  * @crtc: crtc to test
877  *
878  * Return false if @encoder can't be driven by @crtc, true otherwise.
879  */
880 static inline bool drm_encoder_crtc_ok(struct drm_encoder *encoder,
881 				       struct drm_crtc *crtc)
882 {
883 	return !!(encoder->possible_crtcs & drm_crtc_mask(crtc));
884 }
885 
886 extern int drm_universal_plane_init(struct drm_device *dev,
887 				    struct drm_plane *plane,
888 				    unsigned long possible_crtcs,
889 				    const struct drm_plane_funcs *funcs,
890 				    const uint32_t *formats,
891 				    uint32_t format_count,
892 				    enum drm_plane_type type);
893 extern int drm_plane_init(struct drm_device *dev,
894 			  struct drm_plane *plane,
895 			  unsigned long possible_crtcs,
896 			  const struct drm_plane_funcs *funcs,
897 			  const uint32_t *formats, uint32_t format_count,
898 			  bool is_primary);
899 extern void drm_plane_cleanup(struct drm_plane *plane);
900 extern void drm_plane_force_disable(struct drm_plane *plane);
901 extern int drm_crtc_check_viewport(const struct drm_crtc *crtc,
902 				   int x, int y,
903 				   const struct drm_display_mode *mode,
904 				   const struct drm_framebuffer *fb);
905 
906 extern void drm_encoder_cleanup(struct drm_encoder *encoder);
907 
908 extern const char *drm_get_connector_name(const struct drm_connector *connector);
909 extern const char *drm_get_connector_status_name(enum drm_connector_status status);
910 extern const char *drm_get_subpixel_order_name(enum subpixel_order order);
911 extern const char *drm_get_dpms_name(int val);
912 extern const char *drm_get_dvi_i_subconnector_name(int val);
913 extern const char *drm_get_dvi_i_select_name(int val);
914 extern const char *drm_get_tv_subconnector_name(int val);
915 extern const char *drm_get_tv_select_name(int val);
916 extern void drm_fb_release(struct drm_file *file_priv);
917 extern int drm_mode_group_init_legacy_group(struct drm_device *dev, struct drm_mode_group *group);
918 extern bool drm_probe_ddc(struct i2c_adapter *adapter);
919 extern struct edid *drm_get_edid(struct drm_connector *connector,
920 				 struct i2c_adapter *adapter);
921 extern struct edid *drm_edid_duplicate(const struct edid *edid);
922 extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid);
923 extern void drm_mode_config_init(struct drm_device *dev);
924 extern void drm_mode_config_reset(struct drm_device *dev);
925 extern void drm_mode_config_cleanup(struct drm_device *dev);
926 
927 extern int drm_mode_connector_update_edid_property(struct drm_connector *connector,
928 						struct edid *edid);
929 extern int drm_object_property_set_value(struct drm_mode_object *obj,
930 					 struct drm_property *property,
931 					 uint64_t val);
932 extern int drm_object_property_get_value(struct drm_mode_object *obj,
933 					 struct drm_property *property,
934 					 uint64_t *value);
935 extern int drm_framebuffer_init(struct drm_device *dev,
936 				struct drm_framebuffer *fb,
937 				const struct drm_framebuffer_funcs *funcs);
938 extern struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
939 						      uint32_t id);
940 extern void drm_framebuffer_unreference(struct drm_framebuffer *fb);
941 extern void drm_framebuffer_reference(struct drm_framebuffer *fb);
942 extern void drm_framebuffer_remove(struct drm_framebuffer *fb);
943 extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
944 extern void drm_framebuffer_unregister_private(struct drm_framebuffer *fb);
945 
946 extern void drm_object_attach_property(struct drm_mode_object *obj,
947 				       struct drm_property *property,
948 				       uint64_t init_val);
949 extern struct drm_property *drm_property_create(struct drm_device *dev, int flags,
950 						const char *name, int num_values);
951 extern struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
952 					 const char *name,
953 					 const struct drm_prop_enum_list *props,
954 					 int num_values);
955 struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
956 					 int flags, const char *name,
957 					 const struct drm_prop_enum_list *props,
958 					 int num_values);
959 struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
960 					 const char *name,
961 					 uint64_t min, uint64_t max);
962 extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property);
963 extern int drm_property_add_enum(struct drm_property *property, int index,
964 				 uint64_t value, const char *name);
965 extern int drm_mode_create_dvi_i_properties(struct drm_device *dev);
966 extern int drm_mode_create_tv_properties(struct drm_device *dev, int num_formats,
967 				     char *formats[]);
968 extern int drm_mode_create_scaling_mode_property(struct drm_device *dev);
969 extern int drm_mode_create_dirty_info_property(struct drm_device *dev);
970 extern const char *drm_get_encoder_name(const struct drm_encoder *encoder);
971 
972 extern int drm_mode_connector_attach_encoder(struct drm_connector *connector,
973 					     struct drm_encoder *encoder);
974 extern int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
975 					 int gamma_size);
976 extern struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
977 		uint32_t id, uint32_t type);
978 /* IOCTLs */
979 extern int drm_mode_getresources(struct drm_device *dev,
980 				 void *data, struct drm_file *file_priv);
981 extern int drm_mode_getplane_res(struct drm_device *dev, void *data,
982 				   struct drm_file *file_priv);
983 extern int drm_mode_getcrtc(struct drm_device *dev,
984 			    void *data, struct drm_file *file_priv);
985 extern int drm_mode_getconnector(struct drm_device *dev,
986 			      void *data, struct drm_file *file_priv);
987 extern int drm_mode_set_config_internal(struct drm_mode_set *set);
988 extern int drm_mode_setcrtc(struct drm_device *dev,
989 			    void *data, struct drm_file *file_priv);
990 extern int drm_mode_getplane(struct drm_device *dev,
991 			       void *data, struct drm_file *file_priv);
992 extern int drm_mode_setplane(struct drm_device *dev,
993 			       void *data, struct drm_file *file_priv);
994 extern int drm_mode_cursor_ioctl(struct drm_device *dev,
995 				void *data, struct drm_file *file_priv);
996 extern int drm_mode_cursor2_ioctl(struct drm_device *dev,
997 				void *data, struct drm_file *file_priv);
998 extern int drm_mode_addfb(struct drm_device *dev,
999 			  void *data, struct drm_file *file_priv);
1000 extern int drm_mode_addfb2(struct drm_device *dev,
1001 			   void *data, struct drm_file *file_priv);
1002 extern uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth);
1003 extern int drm_mode_rmfb(struct drm_device *dev,
1004 			 void *data, struct drm_file *file_priv);
1005 extern int drm_mode_getfb(struct drm_device *dev,
1006 			  void *data, struct drm_file *file_priv);
1007 extern int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
1008 				  void *data, struct drm_file *file_priv);
1009 
1010 extern int drm_mode_getproperty_ioctl(struct drm_device *dev,
1011 				      void *data, struct drm_file *file_priv);
1012 extern int drm_mode_getblob_ioctl(struct drm_device *dev,
1013 				  void *data, struct drm_file *file_priv);
1014 extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
1015 					      void *data, struct drm_file *file_priv);
1016 extern int drm_mode_getencoder(struct drm_device *dev,
1017 			       void *data, struct drm_file *file_priv);
1018 extern int drm_mode_gamma_get_ioctl(struct drm_device *dev,
1019 				    void *data, struct drm_file *file_priv);
1020 extern int drm_mode_gamma_set_ioctl(struct drm_device *dev,
1021 				    void *data, struct drm_file *file_priv);
1022 extern u8 drm_match_cea_mode(const struct drm_display_mode *to_match);
1023 extern bool drm_detect_hdmi_monitor(struct edid *edid);
1024 extern bool drm_detect_monitor_audio(struct edid *edid);
1025 extern bool drm_rgb_quant_range_selectable(struct edid *edid);
1026 extern int drm_mode_page_flip_ioctl(struct drm_device *dev,
1027 				    void *data, struct drm_file *file_priv);
1028 extern int drm_add_modes_noedid(struct drm_connector *connector,
1029 				int hdisplay, int vdisplay);
1030 extern void drm_set_preferred_mode(struct drm_connector *connector,
1031 				   int hpref, int vpref);
1032 
1033 extern int drm_edid_header_is_valid(const u8 *raw_edid);
1034 extern bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid);
1035 extern bool drm_edid_is_valid(struct edid *edid);
1036 struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
1037 					   int hsize, int vsize, int fresh,
1038 					   bool rb);
1039 
1040 extern int drm_mode_create_dumb_ioctl(struct drm_device *dev,
1041 				      void *data, struct drm_file *file_priv);
1042 extern int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
1043 				    void *data, struct drm_file *file_priv);
1044 extern int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
1045 				      void *data, struct drm_file *file_priv);
1046 extern int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
1047 					     struct drm_file *file_priv);
1048 extern int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
1049 					   struct drm_file *file_priv);
1050 
1051 extern void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
1052 				 int *bpp);
1053 extern int drm_format_num_planes(uint32_t format);
1054 extern int drm_format_plane_cpp(uint32_t format, int plane);
1055 extern int drm_format_horz_chroma_subsampling(uint32_t format);
1056 extern int drm_format_vert_chroma_subsampling(uint32_t format);
1057 extern const char *drm_get_format_name(uint32_t format);
1058 
1059 /* Helpers */
1060 static inline struct drm_crtc *drm_crtc_find(struct drm_device *dev,
1061 	uint32_t id)
1062 {
1063 	struct drm_mode_object *mo;
1064 	mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_CRTC);
1065 	return mo ? obj_to_crtc(mo) : NULL;
1066 }
1067 
1068 static inline struct drm_encoder *drm_encoder_find(struct drm_device *dev,
1069 	uint32_t id)
1070 {
1071 	struct drm_mode_object *mo;
1072 	mo = drm_mode_object_find(dev, id, DRM_MODE_OBJECT_ENCODER);
1073 	return mo ? obj_to_encoder(mo) : NULL;
1074 }
1075 
1076 /* Plane list iterator for legacy (overlay only) planes. */
1077 #define drm_for_each_legacy_plane(plane, planelist) \
1078 	list_for_each_entry(plane, planelist, head) \
1079 		if (plane->type == DRM_PLANE_TYPE_OVERLAY)
1080 
1081 #endif /* __DRM_CRTC_H__ */
1082