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