Line data Source code
1 : /*
2 : * Copyright (c) 2016 Intel Corporation
3 : *
4 : * Permission to use, copy, modify, distribute, and sell this software and its
5 : * documentation for any purpose is hereby granted without fee, provided that
6 : * the above copyright notice appear in all copies and that both that copyright
7 : * notice and this permission notice appear in supporting documentation, and
8 : * that the name of the copyright holders not be used in advertising or
9 : * publicity pertaining to distribution of the software without specific,
10 : * written prior permission. The copyright holders make no representations
11 : * about the suitability of this software for any purpose. It is provided "as
12 : * is" without express or implied warranty.
13 : *
14 : * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15 : * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16 : * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17 : * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18 : * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19 : * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
20 : * OF THIS SOFTWARE.
21 : */
22 :
23 : #ifndef __DRM_CONNECTOR_H__
24 : #define __DRM_CONNECTOR_H__
25 :
26 : #include <linux/list.h>
27 : #include <linux/llist.h>
28 : #include <linux/ctype.h>
29 : #include <linux/hdmi.h>
30 : #include <linux/notifier.h>
31 : #include <drm/drm_mode_object.h>
32 : #include <drm/drm_util.h>
33 : #include <drm/drm_property.h>
34 :
35 : #include <uapi/drm/drm_mode.h>
36 :
37 : struct drm_connector_helper_funcs;
38 : struct drm_modeset_acquire_ctx;
39 : struct drm_device;
40 : struct drm_crtc;
41 : struct drm_encoder;
42 : struct drm_panel;
43 : struct drm_property;
44 : struct drm_property_blob;
45 : struct drm_printer;
46 : struct drm_privacy_screen;
47 : struct edid;
48 : struct i2c_adapter;
49 :
50 : enum drm_connector_force {
51 : DRM_FORCE_UNSPECIFIED,
52 : DRM_FORCE_OFF,
53 : DRM_FORCE_ON, /* force on analog part normally */
54 : DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */
55 : };
56 :
57 : /**
58 : * enum drm_connector_status - status for a &drm_connector
59 : *
60 : * This enum is used to track the connector status. There are no separate
61 : * #defines for the uapi!
62 : */
63 : enum drm_connector_status {
64 : /**
65 : * @connector_status_connected: The connector is definitely connected to
66 : * a sink device, and can be enabled.
67 : */
68 : connector_status_connected = 1,
69 : /**
70 : * @connector_status_disconnected: The connector isn't connected to a
71 : * sink device which can be autodetect. For digital outputs like DP or
72 : * HDMI (which can be realiable probed) this means there's really
73 : * nothing there. It is driver-dependent whether a connector with this
74 : * status can be lit up or not.
75 : */
76 : connector_status_disconnected = 2,
77 : /**
78 : * @connector_status_unknown: The connector's status could not be
79 : * reliably detected. This happens when probing would either cause
80 : * flicker (like load-detection when the connector is in use), or when a
81 : * hardware resource isn't available (like when load-detection needs a
82 : * free CRTC). It should be possible to light up the connector with one
83 : * of the listed fallback modes. For default configuration userspace
84 : * should only try to light up connectors with unknown status when
85 : * there's not connector with @connector_status_connected.
86 : */
87 : connector_status_unknown = 3,
88 : };
89 :
90 : /**
91 : * enum drm_connector_registration_state - userspace registration status for
92 : * a &drm_connector
93 : *
94 : * This enum is used to track the status of initializing a connector and
95 : * registering it with userspace, so that DRM can prevent bogus modesets on
96 : * connectors that no longer exist.
97 : */
98 : enum drm_connector_registration_state {
99 : /**
100 : * @DRM_CONNECTOR_INITIALIZING: The connector has just been created,
101 : * but has yet to be exposed to userspace. There should be no
102 : * additional restrictions to how the state of this connector may be
103 : * modified.
104 : */
105 : DRM_CONNECTOR_INITIALIZING = 0,
106 :
107 : /**
108 : * @DRM_CONNECTOR_REGISTERED: The connector has been fully initialized
109 : * and registered with sysfs, as such it has been exposed to
110 : * userspace. There should be no additional restrictions to how the
111 : * state of this connector may be modified.
112 : */
113 : DRM_CONNECTOR_REGISTERED = 1,
114 :
115 : /**
116 : * @DRM_CONNECTOR_UNREGISTERED: The connector has either been exposed
117 : * to userspace and has since been unregistered and removed from
118 : * userspace, or the connector was unregistered before it had a chance
119 : * to be exposed to userspace (e.g. still in the
120 : * @DRM_CONNECTOR_INITIALIZING state). When a connector is
121 : * unregistered, there are additional restrictions to how its state
122 : * may be modified:
123 : *
124 : * - An unregistered connector may only have its DPMS changed from
125 : * On->Off. Once DPMS is changed to Off, it may not be switched back
126 : * to On.
127 : * - Modesets are not allowed on unregistered connectors, unless they
128 : * would result in disabling its assigned CRTCs. This means
129 : * disabling a CRTC on an unregistered connector is OK, but enabling
130 : * one is not.
131 : * - Removing a CRTC from an unregistered connector is OK, but new
132 : * CRTCs may never be assigned to an unregistered connector.
133 : */
134 : DRM_CONNECTOR_UNREGISTERED = 2,
135 : };
136 :
137 : enum subpixel_order {
138 : SubPixelUnknown = 0,
139 : SubPixelHorizontalRGB,
140 : SubPixelHorizontalBGR,
141 : SubPixelVerticalRGB,
142 : SubPixelVerticalBGR,
143 : SubPixelNone,
144 :
145 : };
146 :
147 : /**
148 : * enum drm_connector_tv_mode - Analog TV output mode
149 : *
150 : * This enum is used to indicate the TV output mode used on an analog TV
151 : * connector.
152 : *
153 : * WARNING: The values of this enum is uABI since they're exposed in the
154 : * "TV mode" connector property.
155 : */
156 : enum drm_connector_tv_mode {
157 : /**
158 : * @DRM_MODE_TV_MODE_NTSC: CCIR System M (aka 525-lines)
159 : * together with the NTSC Color Encoding.
160 : */
161 : DRM_MODE_TV_MODE_NTSC,
162 :
163 : /**
164 : * @DRM_MODE_TV_MODE_NTSC_443: Variant of
165 : * @DRM_MODE_TV_MODE_NTSC. Uses a color subcarrier frequency
166 : * of 4.43 MHz.
167 : */
168 : DRM_MODE_TV_MODE_NTSC_443,
169 :
170 : /**
171 : * @DRM_MODE_TV_MODE_NTSC_J: Variant of @DRM_MODE_TV_MODE_NTSC
172 : * used in Japan. Uses a black level equals to the blanking
173 : * level.
174 : */
175 : DRM_MODE_TV_MODE_NTSC_J,
176 :
177 : /**
178 : * @DRM_MODE_TV_MODE_PAL: CCIR System B together with the PAL
179 : * color system.
180 : */
181 : DRM_MODE_TV_MODE_PAL,
182 :
183 : /**
184 : * @DRM_MODE_TV_MODE_PAL_M: CCIR System M (aka 525-lines)
185 : * together with the PAL color encoding
186 : */
187 : DRM_MODE_TV_MODE_PAL_M,
188 :
189 : /**
190 : * @DRM_MODE_TV_MODE_PAL_N: CCIR System N together with the PAL
191 : * color encoding. It uses 625 lines, but has a color subcarrier
192 : * frequency of 3.58MHz, the SECAM color space, and narrower
193 : * channels compared to most of the other PAL variants.
194 : */
195 : DRM_MODE_TV_MODE_PAL_N,
196 :
197 : /**
198 : * @DRM_MODE_TV_MODE_SECAM: CCIR System B together with the
199 : * SECAM color system.
200 : */
201 : DRM_MODE_TV_MODE_SECAM,
202 :
203 : /**
204 : * @DRM_MODE_TV_MODE_MAX: Number of analog TV output modes.
205 : *
206 : * Internal implementation detail; this is not uABI.
207 : */
208 : DRM_MODE_TV_MODE_MAX,
209 : };
210 :
211 : /**
212 : * struct drm_scrambling: sink's scrambling support.
213 : */
214 : struct drm_scrambling {
215 : /**
216 : * @supported: scrambling supported for rates > 340 Mhz.
217 : */
218 : bool supported;
219 : /**
220 : * @low_rates: scrambling supported for rates <= 340 Mhz.
221 : */
222 : bool low_rates;
223 : };
224 :
225 : /*
226 : * struct drm_scdc - Information about scdc capabilities of a HDMI 2.0 sink
227 : *
228 : * Provides SCDC register support and capabilities related information on a
229 : * HDMI 2.0 sink. In case of a HDMI 1.4 sink, all parameter must be 0.
230 : */
231 : struct drm_scdc {
232 : /**
233 : * @supported: status control & data channel present.
234 : */
235 : bool supported;
236 : /**
237 : * @read_request: sink is capable of generating scdc read request.
238 : */
239 : bool read_request;
240 : /**
241 : * @scrambling: sink's scrambling capabilities
242 : */
243 : struct drm_scrambling scrambling;
244 : };
245 :
246 : /**
247 : * struct drm_hdmi_dsc_cap - DSC capabilities of HDMI sink
248 : *
249 : * Describes the DSC support provided by HDMI 2.1 sink.
250 : * The information is fetched fom additional HFVSDB blocks defined
251 : * for HDMI 2.1.
252 : */
253 : struct drm_hdmi_dsc_cap {
254 : /** @v_1p2: flag for dsc1.2 version support by sink */
255 : bool v_1p2;
256 :
257 : /** @native_420: Does sink support DSC with 4:2:0 compression */
258 : bool native_420;
259 :
260 : /**
261 : * @all_bpp: Does sink support all bpp with 4:4:4: or 4:2:2
262 : * compressed formats
263 : */
264 : bool all_bpp;
265 :
266 : /**
267 : * @bpc_supported: compressed bpc supported by sink : 10, 12 or 16 bpc
268 : */
269 : u8 bpc_supported;
270 :
271 : /** @max_slices: maximum number of Horizontal slices supported by */
272 : u8 max_slices;
273 :
274 : /** @clk_per_slice : max pixel clock in MHz supported per slice */
275 : int clk_per_slice;
276 :
277 : /** @max_lanes : dsc max lanes supported for Fixed rate Link training */
278 : u8 max_lanes;
279 :
280 : /** @max_frl_rate_per_lane : maximum frl rate with DSC per lane */
281 : u8 max_frl_rate_per_lane;
282 :
283 : /** @total_chunk_kbytes: max size of chunks in KBs supported per line*/
284 : u8 total_chunk_kbytes;
285 : };
286 :
287 : /**
288 : * struct drm_hdmi_info - runtime information about the connected HDMI sink
289 : *
290 : * Describes if a given display supports advanced HDMI 2.0 features.
291 : * This information is available in CEA-861-F extension blocks (like HF-VSDB).
292 : */
293 : struct drm_hdmi_info {
294 : /** @scdc: sink's scdc support and capabilities */
295 : struct drm_scdc scdc;
296 :
297 : /**
298 : * @y420_vdb_modes: bitmap of modes which can support ycbcr420
299 : * output only (not normal RGB/YCBCR444/422 outputs). The max VIC
300 : * defined by the CEA-861-G spec is 219, so the size is 256 bits to map
301 : * up to 256 VICs.
302 : */
303 : unsigned long y420_vdb_modes[BITS_TO_LONGS(256)];
304 :
305 : /**
306 : * @y420_cmdb_modes: bitmap of modes which can support ycbcr420
307 : * output also, along with normal HDMI outputs. The max VIC defined by
308 : * the CEA-861-G spec is 219, so the size is 256 bits to map up to 256
309 : * VICs.
310 : */
311 : unsigned long y420_cmdb_modes[BITS_TO_LONGS(256)];
312 :
313 : /** @y420_dc_modes: bitmap of deep color support index */
314 : u8 y420_dc_modes;
315 :
316 : /** @max_frl_rate_per_lane: support fixed rate link */
317 : u8 max_frl_rate_per_lane;
318 :
319 : /** @max_lanes: supported by sink */
320 : u8 max_lanes;
321 :
322 : /** @dsc_cap: DSC capabilities of the sink */
323 : struct drm_hdmi_dsc_cap dsc_cap;
324 : };
325 :
326 : /**
327 : * enum drm_link_status - connector's link_status property value
328 : *
329 : * This enum is used as the connector's link status property value.
330 : * It is set to the values defined in uapi.
331 : *
332 : * @DRM_LINK_STATUS_GOOD: DP Link is Good as a result of successful
333 : * link training
334 : * @DRM_LINK_STATUS_BAD: DP Link is BAD as a result of link training
335 : * failure
336 : */
337 : enum drm_link_status {
338 : DRM_LINK_STATUS_GOOD = DRM_MODE_LINK_STATUS_GOOD,
339 : DRM_LINK_STATUS_BAD = DRM_MODE_LINK_STATUS_BAD,
340 : };
341 :
342 : /**
343 : * enum drm_panel_orientation - panel_orientation info for &drm_display_info
344 : *
345 : * This enum is used to track the (LCD) panel orientation. There are no
346 : * separate #defines for the uapi!
347 : *
348 : * @DRM_MODE_PANEL_ORIENTATION_UNKNOWN: The drm driver has not provided any
349 : * panel orientation information (normal
350 : * for non panels) in this case the "panel
351 : * orientation" connector prop will not be
352 : * attached.
353 : * @DRM_MODE_PANEL_ORIENTATION_NORMAL: The top side of the panel matches the
354 : * top side of the device's casing.
355 : * @DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP: The top side of the panel matches the
356 : * bottom side of the device's casing, iow
357 : * the panel is mounted upside-down.
358 : * @DRM_MODE_PANEL_ORIENTATION_LEFT_UP: The left side of the panel matches the
359 : * top side of the device's casing.
360 : * @DRM_MODE_PANEL_ORIENTATION_RIGHT_UP: The right side of the panel matches the
361 : * top side of the device's casing.
362 : */
363 : enum drm_panel_orientation {
364 : DRM_MODE_PANEL_ORIENTATION_UNKNOWN = -1,
365 : DRM_MODE_PANEL_ORIENTATION_NORMAL = 0,
366 : DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP,
367 : DRM_MODE_PANEL_ORIENTATION_LEFT_UP,
368 : DRM_MODE_PANEL_ORIENTATION_RIGHT_UP,
369 : };
370 :
371 : /**
372 : * struct drm_monitor_range_info - Panel's Monitor range in EDID for
373 : * &drm_display_info
374 : *
375 : * This struct is used to store a frequency range supported by panel
376 : * as parsed from EDID's detailed monitor range descriptor block.
377 : *
378 : * @min_vfreq: This is the min supported refresh rate in Hz from
379 : * EDID's detailed monitor range.
380 : * @max_vfreq: This is the max supported refresh rate in Hz from
381 : * EDID's detailed monitor range
382 : */
383 : struct drm_monitor_range_info {
384 : u16 min_vfreq;
385 : u16 max_vfreq;
386 : };
387 :
388 : /**
389 : * struct drm_luminance_range_info - Panel's luminance range for
390 : * &drm_display_info. Calculated using data in EDID
391 : *
392 : * This struct is used to store a luminance range supported by panel
393 : * as calculated using data from EDID's static hdr metadata.
394 : *
395 : * @min_luminance: This is the min supported luminance value
396 : *
397 : * @max_luminance: This is the max supported luminance value
398 : */
399 : struct drm_luminance_range_info {
400 : u32 min_luminance;
401 : u32 max_luminance;
402 : };
403 :
404 : /**
405 : * enum drm_privacy_screen_status - privacy screen status
406 : *
407 : * This enum is used to track and control the state of the integrated privacy
408 : * screen present on some display panels, via the "privacy-screen sw-state"
409 : * and "privacy-screen hw-state" properties. Note the _LOCKED enum values
410 : * are only valid for the "privacy-screen hw-state" property.
411 : *
412 : * @PRIVACY_SCREEN_DISABLED:
413 : * The privacy-screen on the panel is disabled
414 : * @PRIVACY_SCREEN_ENABLED:
415 : * The privacy-screen on the panel is enabled
416 : * @PRIVACY_SCREEN_DISABLED_LOCKED:
417 : * The privacy-screen on the panel is disabled and locked (cannot be changed)
418 : * @PRIVACY_SCREEN_ENABLED_LOCKED:
419 : * The privacy-screen on the panel is enabled and locked (cannot be changed)
420 : */
421 : enum drm_privacy_screen_status {
422 : PRIVACY_SCREEN_DISABLED = 0,
423 : PRIVACY_SCREEN_ENABLED,
424 : PRIVACY_SCREEN_DISABLED_LOCKED,
425 : PRIVACY_SCREEN_ENABLED_LOCKED,
426 : };
427 :
428 : /**
429 : * enum drm_colorspace - color space
430 : *
431 : * This enum is a consolidated colorimetry list supported by HDMI and
432 : * DP protocol standard. The respective connectors will register
433 : * a property with the subset of this list (supported by that
434 : * respective protocol). Userspace will set the colorspace through
435 : * a colorspace property which will be created and exposed to
436 : * userspace.
437 : *
438 : * DP definitions come from the DP v2.0 spec
439 : * HDMI definitions come from the CTA-861-H spec
440 : *
441 : * A note on YCC and RGB variants:
442 : *
443 : * Since userspace is not aware of the encoding on the wire
444 : * (RGB or YCbCr), drivers are free to pick the appropriate
445 : * variant, regardless of what userspace selects. E.g., if
446 : * BT2020_RGB is selected by userspace a driver will pick
447 : * BT2020_YCC if the encoding on the wire is YUV444 or YUV420.
448 : *
449 : * @DRM_MODE_COLORIMETRY_DEFAULT:
450 : * Driver specific behavior.
451 : * @DRM_MODE_COLORIMETRY_NO_DATA:
452 : * Driver specific behavior.
453 : * @DRM_MODE_COLORIMETRY_SMPTE_170M_YCC:
454 : * (HDMI)
455 : * SMPTE ST 170M colorimetry format
456 : * @DRM_MODE_COLORIMETRY_BT709_YCC:
457 : * (HDMI, DP)
458 : * ITU-R BT.709 colorimetry format
459 : * @DRM_MODE_COLORIMETRY_XVYCC_601:
460 : * (HDMI, DP)
461 : * xvYCC601 colorimetry format
462 : * @DRM_MODE_COLORIMETRY_XVYCC_709:
463 : * (HDMI, DP)
464 : * xvYCC709 colorimetry format
465 : * @DRM_MODE_COLORIMETRY_SYCC_601:
466 : * (HDMI, DP)
467 : * sYCC601 colorimetry format
468 : * @DRM_MODE_COLORIMETRY_OPYCC_601:
469 : * (HDMI, DP)
470 : * opYCC601 colorimetry format
471 : * @DRM_MODE_COLORIMETRY_OPRGB:
472 : * (HDMI, DP)
473 : * opRGB colorimetry format
474 : * @DRM_MODE_COLORIMETRY_BT2020_CYCC:
475 : * (HDMI, DP)
476 : * ITU-R BT.2020 Y'c C'bc C'rc (constant luminance) colorimetry format
477 : * @DRM_MODE_COLORIMETRY_BT2020_RGB:
478 : * (HDMI, DP)
479 : * ITU-R BT.2020 R' G' B' colorimetry format
480 : * @DRM_MODE_COLORIMETRY_BT2020_YCC:
481 : * (HDMI, DP)
482 : * ITU-R BT.2020 Y' C'b C'r colorimetry format
483 : * @DRM_MODE_COLORIMETRY_DCI_P3_RGB_D65:
484 : * (HDMI)
485 : * SMPTE ST 2113 P3D65 colorimetry format
486 : * @DRM_MODE_COLORIMETRY_DCI_P3_RGB_THEATER:
487 : * (HDMI)
488 : * SMPTE ST 2113 P3DCI colorimetry format
489 : * @DRM_MODE_COLORIMETRY_RGB_WIDE_FIXED:
490 : * (DP)
491 : * RGB wide gamut fixed point colorimetry format
492 : * @DRM_MODE_COLORIMETRY_RGB_WIDE_FLOAT:
493 : * (DP)
494 : * RGB wide gamut floating point
495 : * (scRGB (IEC 61966-2-2)) colorimetry format
496 : * @DRM_MODE_COLORIMETRY_BT601_YCC:
497 : * (DP)
498 : * ITU-R BT.601 colorimetry format
499 : * The DP spec does not say whether this is the 525 or the 625
500 : * line version.
501 : */
502 : enum drm_colorspace {
503 : /* For Default case, driver will set the colorspace */
504 : DRM_MODE_COLORIMETRY_DEFAULT = 0,
505 : /* CEA 861 Normal Colorimetry options */
506 : DRM_MODE_COLORIMETRY_NO_DATA = 0,
507 : DRM_MODE_COLORIMETRY_SMPTE_170M_YCC = 1,
508 : DRM_MODE_COLORIMETRY_BT709_YCC = 2,
509 : /* CEA 861 Extended Colorimetry Options */
510 : DRM_MODE_COLORIMETRY_XVYCC_601 = 3,
511 : DRM_MODE_COLORIMETRY_XVYCC_709 = 4,
512 : DRM_MODE_COLORIMETRY_SYCC_601 = 5,
513 : DRM_MODE_COLORIMETRY_OPYCC_601 = 6,
514 : DRM_MODE_COLORIMETRY_OPRGB = 7,
515 : DRM_MODE_COLORIMETRY_BT2020_CYCC = 8,
516 : DRM_MODE_COLORIMETRY_BT2020_RGB = 9,
517 : DRM_MODE_COLORIMETRY_BT2020_YCC = 10,
518 : /* Additional Colorimetry extension added as part of CTA 861.G */
519 : DRM_MODE_COLORIMETRY_DCI_P3_RGB_D65 = 11,
520 : DRM_MODE_COLORIMETRY_DCI_P3_RGB_THEATER = 12,
521 : /* Additional Colorimetry Options added for DP 1.4a VSC Colorimetry Format */
522 : DRM_MODE_COLORIMETRY_RGB_WIDE_FIXED = 13,
523 : DRM_MODE_COLORIMETRY_RGB_WIDE_FLOAT = 14,
524 : DRM_MODE_COLORIMETRY_BT601_YCC = 15,
525 : /* not a valid value; merely used for counting */
526 : DRM_MODE_COLORIMETRY_COUNT
527 : };
528 :
529 : /**
530 : * enum drm_bus_flags - bus_flags info for &drm_display_info
531 : *
532 : * This enum defines signal polarities and clock edge information for signals on
533 : * a bus as bitmask flags.
534 : *
535 : * The clock edge information is conveyed by two sets of symbols,
536 : * DRM_BUS_FLAGS_*_DRIVE_\* and DRM_BUS_FLAGS_*_SAMPLE_\*. When this enum is
537 : * used to describe a bus from the point of view of the transmitter, the
538 : * \*_DRIVE_\* flags should be used. When used from the point of view of the
539 : * receiver, the \*_SAMPLE_\* flags should be used. The \*_DRIVE_\* and
540 : * \*_SAMPLE_\* flags alias each other, with the \*_SAMPLE_POSEDGE and
541 : * \*_SAMPLE_NEGEDGE flags being equal to \*_DRIVE_NEGEDGE and \*_DRIVE_POSEDGE
542 : * respectively. This simplifies code as signals are usually sampled on the
543 : * opposite edge of the driving edge. Transmitters and receivers may however
544 : * need to take other signal timings into account to convert between driving
545 : * and sample edges.
546 : */
547 : enum drm_bus_flags {
548 : /**
549 : * @DRM_BUS_FLAG_DE_LOW:
550 : *
551 : * The Data Enable signal is active low
552 : */
553 : DRM_BUS_FLAG_DE_LOW = BIT(0),
554 :
555 : /**
556 : * @DRM_BUS_FLAG_DE_HIGH:
557 : *
558 : * The Data Enable signal is active high
559 : */
560 : DRM_BUS_FLAG_DE_HIGH = BIT(1),
561 :
562 : /**
563 : * @DRM_BUS_FLAG_PIXDATA_DRIVE_POSEDGE:
564 : *
565 : * Data is driven on the rising edge of the pixel clock
566 : */
567 : DRM_BUS_FLAG_PIXDATA_DRIVE_POSEDGE = BIT(2),
568 :
569 : /**
570 : * @DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE:
571 : *
572 : * Data is driven on the falling edge of the pixel clock
573 : */
574 : DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE = BIT(3),
575 :
576 : /**
577 : * @DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE:
578 : *
579 : * Data is sampled on the rising edge of the pixel clock
580 : */
581 : DRM_BUS_FLAG_PIXDATA_SAMPLE_POSEDGE = DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE,
582 :
583 : /**
584 : * @DRM_BUS_FLAG_PIXDATA_SAMPLE_NEGEDGE:
585 : *
586 : * Data is sampled on the falling edge of the pixel clock
587 : */
588 : DRM_BUS_FLAG_PIXDATA_SAMPLE_NEGEDGE = DRM_BUS_FLAG_PIXDATA_DRIVE_POSEDGE,
589 :
590 : /**
591 : * @DRM_BUS_FLAG_DATA_MSB_TO_LSB:
592 : *
593 : * Data is transmitted MSB to LSB on the bus
594 : */
595 : DRM_BUS_FLAG_DATA_MSB_TO_LSB = BIT(4),
596 :
597 : /**
598 : * @DRM_BUS_FLAG_DATA_LSB_TO_MSB:
599 : *
600 : * Data is transmitted LSB to MSB on the bus
601 : */
602 : DRM_BUS_FLAG_DATA_LSB_TO_MSB = BIT(5),
603 :
604 : /**
605 : * @DRM_BUS_FLAG_SYNC_DRIVE_POSEDGE:
606 : *
607 : * Sync signals are driven on the rising edge of the pixel clock
608 : */
609 : DRM_BUS_FLAG_SYNC_DRIVE_POSEDGE = BIT(6),
610 :
611 : /**
612 : * @DRM_BUS_FLAG_SYNC_DRIVE_NEGEDGE:
613 : *
614 : * Sync signals are driven on the falling edge of the pixel clock
615 : */
616 : DRM_BUS_FLAG_SYNC_DRIVE_NEGEDGE = BIT(7),
617 :
618 : /**
619 : * @DRM_BUS_FLAG_SYNC_SAMPLE_POSEDGE:
620 : *
621 : * Sync signals are sampled on the rising edge of the pixel clock
622 : */
623 : DRM_BUS_FLAG_SYNC_SAMPLE_POSEDGE = DRM_BUS_FLAG_SYNC_DRIVE_NEGEDGE,
624 :
625 : /**
626 : * @DRM_BUS_FLAG_SYNC_SAMPLE_NEGEDGE:
627 : *
628 : * Sync signals are sampled on the falling edge of the pixel clock
629 : */
630 : DRM_BUS_FLAG_SYNC_SAMPLE_NEGEDGE = DRM_BUS_FLAG_SYNC_DRIVE_POSEDGE,
631 :
632 : /**
633 : * @DRM_BUS_FLAG_SHARP_SIGNALS:
634 : *
635 : * Set if the Sharp-specific signals (SPL, CLS, PS, REV) must be used
636 : */
637 : DRM_BUS_FLAG_SHARP_SIGNALS = BIT(8),
638 : };
639 :
640 : /**
641 : * struct drm_display_info - runtime data about the connected sink
642 : *
643 : * Describes a given display (e.g. CRT or flat panel) and its limitations. For
644 : * fixed display sinks like built-in panels there's not much difference between
645 : * this and &struct drm_connector. But for sinks with a real cable this
646 : * structure is meant to describe all the things at the other end of the cable.
647 : *
648 : * For sinks which provide an EDID this can be filled out by calling
649 : * drm_add_edid_modes().
650 : */
651 : struct drm_display_info {
652 : /**
653 : * @width_mm: Physical width in mm.
654 : */
655 : unsigned int width_mm;
656 :
657 : /**
658 : * @height_mm: Physical height in mm.
659 : */
660 : unsigned int height_mm;
661 :
662 : /**
663 : * @bpc: Maximum bits per color channel. Used by HDMI and DP outputs.
664 : */
665 : unsigned int bpc;
666 :
667 : /**
668 : * @subpixel_order: Subpixel order of LCD panels.
669 : */
670 : enum subpixel_order subpixel_order;
671 :
672 : #define DRM_COLOR_FORMAT_RGB444 (1<<0)
673 : #define DRM_COLOR_FORMAT_YCBCR444 (1<<1)
674 : #define DRM_COLOR_FORMAT_YCBCR422 (1<<2)
675 : #define DRM_COLOR_FORMAT_YCBCR420 (1<<3)
676 :
677 : /**
678 : * @panel_orientation: Read only connector property for built-in panels,
679 : * indicating the orientation of the panel vs the device's casing.
680 : * drm_connector_init() sets this to DRM_MODE_PANEL_ORIENTATION_UNKNOWN.
681 : * When not UNKNOWN this gets used by the drm_fb_helpers to rotate the
682 : * fb to compensate and gets exported as prop to userspace.
683 : */
684 : int panel_orientation;
685 :
686 : /**
687 : * @color_formats: HDMI Color formats, selects between RGB and YCrCb
688 : * modes. Used DRM_COLOR_FORMAT\_ defines, which are _not_ the same ones
689 : * as used to describe the pixel format in framebuffers, and also don't
690 : * match the formats in @bus_formats which are shared with v4l.
691 : */
692 : u32 color_formats;
693 :
694 : /**
695 : * @bus_formats: Pixel data format on the wire, somewhat redundant with
696 : * @color_formats. Array of size @num_bus_formats encoded using
697 : * MEDIA_BUS_FMT\_ defines shared with v4l and media drivers.
698 : */
699 : const u32 *bus_formats;
700 : /**
701 : * @num_bus_formats: Size of @bus_formats array.
702 : */
703 : unsigned int num_bus_formats;
704 :
705 : /**
706 : * @bus_flags: Additional information (like pixel signal polarity) for
707 : * the pixel data on the bus, using &enum drm_bus_flags values
708 : * DRM_BUS_FLAGS\_.
709 : */
710 : u32 bus_flags;
711 :
712 : /**
713 : * @max_tmds_clock: Maximum TMDS clock rate supported by the
714 : * sink in kHz. 0 means undefined.
715 : */
716 : int max_tmds_clock;
717 :
718 : /**
719 : * @dvi_dual: Dual-link DVI sink?
720 : */
721 : bool dvi_dual;
722 :
723 : /**
724 : * @is_hdmi: True if the sink is an HDMI device.
725 : *
726 : * This field shall be used instead of calling
727 : * drm_detect_hdmi_monitor() when possible.
728 : */
729 : bool is_hdmi;
730 :
731 : /**
732 : * @has_audio: True if the sink supports audio.
733 : *
734 : * This field shall be used instead of calling
735 : * drm_detect_monitor_audio() when possible.
736 : */
737 : bool has_audio;
738 :
739 : /**
740 : * @has_hdmi_infoframe: Does the sink support the HDMI infoframe?
741 : */
742 : bool has_hdmi_infoframe;
743 :
744 : /**
745 : * @rgb_quant_range_selectable: Does the sink support selecting
746 : * the RGB quantization range?
747 : */
748 : bool rgb_quant_range_selectable;
749 :
750 : /**
751 : * @edid_hdmi_rgb444_dc_modes: Mask of supported hdmi deep color modes
752 : * in RGB 4:4:4. Even more stuff redundant with @bus_formats.
753 : */
754 : u8 edid_hdmi_rgb444_dc_modes;
755 :
756 : /**
757 : * @edid_hdmi_ycbcr444_dc_modes: Mask of supported hdmi deep color
758 : * modes in YCbCr 4:4:4. Even more stuff redundant with @bus_formats.
759 : */
760 : u8 edid_hdmi_ycbcr444_dc_modes;
761 :
762 : /**
763 : * @cea_rev: CEA revision of the HDMI sink.
764 : */
765 : u8 cea_rev;
766 :
767 : /**
768 : * @hdmi: advance features of a HDMI sink.
769 : */
770 : struct drm_hdmi_info hdmi;
771 :
772 : /**
773 : * @non_desktop: Non desktop display (HMD).
774 : */
775 : bool non_desktop;
776 :
777 : /**
778 : * @monitor_range: Frequency range supported by monitor range descriptor
779 : */
780 : struct drm_monitor_range_info monitor_range;
781 :
782 : /**
783 : * @luminance_range: Luminance range supported by panel
784 : */
785 : struct drm_luminance_range_info luminance_range;
786 :
787 : /**
788 : * @mso_stream_count: eDP Multi-SST Operation (MSO) stream count from
789 : * the DisplayID VESA vendor block. 0 for conventional Single-Stream
790 : * Transport (SST), or 2 or 4 MSO streams.
791 : */
792 : u8 mso_stream_count;
793 :
794 : /**
795 : * @mso_pixel_overlap: eDP MSO segment pixel overlap, 0-8 pixels.
796 : */
797 : u8 mso_pixel_overlap;
798 :
799 : /**
800 : * @max_dsc_bpp: Maximum DSC target bitrate, if it is set to 0 the
801 : * monitor's default value is used instead.
802 : */
803 : u32 max_dsc_bpp;
804 :
805 : /**
806 : * @vics: Array of vics_len VICs. Internal to EDID parsing.
807 : */
808 : u8 *vics;
809 :
810 : /**
811 : * @vics_len: Number of elements in vics. Internal to EDID parsing.
812 : */
813 : int vics_len;
814 :
815 : /**
816 : * @quirks: EDID based quirks. Internal to EDID parsing.
817 : */
818 : u32 quirks;
819 : };
820 :
821 : int drm_display_info_set_bus_formats(struct drm_display_info *info,
822 : const u32 *formats,
823 : unsigned int num_formats);
824 :
825 : /**
826 : * struct drm_connector_tv_margins - TV connector related margins
827 : *
828 : * Describes the margins in pixels to put around the image on TV
829 : * connectors to deal with overscan.
830 : */
831 : struct drm_connector_tv_margins {
832 : /**
833 : * @bottom: Bottom margin in pixels.
834 : */
835 : unsigned int bottom;
836 :
837 : /**
838 : * @left: Left margin in pixels.
839 : */
840 : unsigned int left;
841 :
842 : /**
843 : * @right: Right margin in pixels.
844 : */
845 : unsigned int right;
846 :
847 : /**
848 : * @top: Top margin in pixels.
849 : */
850 : unsigned int top;
851 : };
852 :
853 : /**
854 : * struct drm_tv_connector_state - TV connector related states
855 : * @select_subconnector: selected subconnector
856 : * @subconnector: detected subconnector
857 : * @margins: TV margins
858 : * @legacy_mode: Legacy TV mode, driver specific value
859 : * @mode: TV mode
860 : * @brightness: brightness in percent
861 : * @contrast: contrast in percent
862 : * @flicker_reduction: flicker reduction in percent
863 : * @overscan: overscan in percent
864 : * @saturation: saturation in percent
865 : * @hue: hue in percent
866 : */
867 : struct drm_tv_connector_state {
868 : enum drm_mode_subconnector select_subconnector;
869 : enum drm_mode_subconnector subconnector;
870 : struct drm_connector_tv_margins margins;
871 : unsigned int legacy_mode;
872 : unsigned int mode;
873 : unsigned int brightness;
874 : unsigned int contrast;
875 : unsigned int flicker_reduction;
876 : unsigned int overscan;
877 : unsigned int saturation;
878 : unsigned int hue;
879 : };
880 :
881 : /**
882 : * struct drm_connector_state - mutable connector state
883 : */
884 : struct drm_connector_state {
885 : /** @connector: backpointer to the connector */
886 : struct drm_connector *connector;
887 :
888 : /**
889 : * @crtc: CRTC to connect connector to, NULL if disabled.
890 : *
891 : * Do not change this directly, use drm_atomic_set_crtc_for_connector()
892 : * instead.
893 : */
894 : struct drm_crtc *crtc;
895 :
896 : /**
897 : * @best_encoder:
898 : *
899 : * Used by the atomic helpers to select the encoder, through the
900 : * &drm_connector_helper_funcs.atomic_best_encoder or
901 : * &drm_connector_helper_funcs.best_encoder callbacks.
902 : *
903 : * This is also used in the atomic helpers to map encoders to their
904 : * current and previous connectors, see
905 : * drm_atomic_get_old_connector_for_encoder() and
906 : * drm_atomic_get_new_connector_for_encoder().
907 : *
908 : * NOTE: Atomic drivers must fill this out (either themselves or through
909 : * helpers), for otherwise the GETCONNECTOR and GETENCODER IOCTLs will
910 : * not return correct data to userspace.
911 : */
912 : struct drm_encoder *best_encoder;
913 :
914 : /**
915 : * @link_status: Connector link_status to keep track of whether link is
916 : * GOOD or BAD to notify userspace if retraining is necessary.
917 : */
918 : enum drm_link_status link_status;
919 :
920 : /** @state: backpointer to global drm_atomic_state */
921 : struct drm_atomic_state *state;
922 :
923 : /**
924 : * @commit: Tracks the pending commit to prevent use-after-free conditions.
925 : *
926 : * Is only set when @crtc is NULL.
927 : */
928 : struct drm_crtc_commit *commit;
929 :
930 : /** @tv: TV connector state */
931 : struct drm_tv_connector_state tv;
932 :
933 : /**
934 : * @self_refresh_aware:
935 : *
936 : * This tracks whether a connector is aware of the self refresh state.
937 : * It should be set to true for those connector implementations which
938 : * understand the self refresh state. This is needed since the crtc
939 : * registers the self refresh helpers and it doesn't know if the
940 : * connectors downstream have implemented self refresh entry/exit.
941 : *
942 : * Drivers should set this to true in atomic_check if they know how to
943 : * handle self_refresh requests.
944 : */
945 : bool self_refresh_aware;
946 :
947 : /**
948 : * @picture_aspect_ratio: Connector property to control the
949 : * HDMI infoframe aspect ratio setting.
950 : *
951 : * The %DRM_MODE_PICTURE_ASPECT_\* values much match the
952 : * values for &enum hdmi_picture_aspect
953 : */
954 : enum hdmi_picture_aspect picture_aspect_ratio;
955 :
956 : /**
957 : * @content_type: Connector property to control the
958 : * HDMI infoframe content type setting.
959 : * The %DRM_MODE_CONTENT_TYPE_\* values much
960 : * match the values.
961 : */
962 : unsigned int content_type;
963 :
964 : /**
965 : * @hdcp_content_type: Connector property to pass the type of
966 : * protected content. This is most commonly used for HDCP.
967 : */
968 : unsigned int hdcp_content_type;
969 :
970 : /**
971 : * @scaling_mode: Connector property to control the
972 : * upscaling, mostly used for built-in panels.
973 : */
974 : unsigned int scaling_mode;
975 :
976 : /**
977 : * @content_protection: Connector property to request content
978 : * protection. This is most commonly used for HDCP.
979 : */
980 : unsigned int content_protection;
981 :
982 : /**
983 : * @colorspace: State variable for Connector property to request
984 : * colorspace change on Sink. This is most commonly used to switch
985 : * to wider color gamuts like BT2020.
986 : */
987 : enum drm_colorspace colorspace;
988 :
989 : /**
990 : * @writeback_job: Writeback job for writeback connectors
991 : *
992 : * Holds the framebuffer and out-fence for a writeback connector. As
993 : * the writeback completion may be asynchronous to the normal commit
994 : * cycle, the writeback job lifetime is managed separately from the
995 : * normal atomic state by this object.
996 : *
997 : * See also: drm_writeback_queue_job() and
998 : * drm_writeback_signal_completion()
999 : */
1000 : struct drm_writeback_job *writeback_job;
1001 :
1002 : /**
1003 : * @max_requested_bpc: Connector property to limit the maximum bit
1004 : * depth of the pixels.
1005 : */
1006 : u8 max_requested_bpc;
1007 :
1008 : /**
1009 : * @max_bpc: Connector max_bpc based on the requested max_bpc property
1010 : * and the connector bpc limitations obtained from edid.
1011 : */
1012 : u8 max_bpc;
1013 :
1014 : /**
1015 : * @privacy_screen_sw_state: See :ref:`Standard Connector
1016 : * Properties<standard_connector_properties>`
1017 : */
1018 : enum drm_privacy_screen_status privacy_screen_sw_state;
1019 :
1020 : /**
1021 : * @hdr_output_metadata:
1022 : * DRM blob property for HDR output metadata
1023 : */
1024 : struct drm_property_blob *hdr_output_metadata;
1025 : };
1026 :
1027 : /**
1028 : * struct drm_connector_funcs - control connectors on a given device
1029 : *
1030 : * Each CRTC may have one or more connectors attached to it. The functions
1031 : * below allow the core DRM code to control connectors, enumerate available modes,
1032 : * etc.
1033 : */
1034 : struct drm_connector_funcs {
1035 : /**
1036 : * @dpms:
1037 : *
1038 : * Legacy entry point to set the per-connector DPMS state. Legacy DPMS
1039 : * is exposed as a standard property on the connector, but diverted to
1040 : * this callback in the drm core. Note that atomic drivers don't
1041 : * implement the 4 level DPMS support on the connector any more, but
1042 : * instead only have an on/off "ACTIVE" property on the CRTC object.
1043 : *
1044 : * This hook is not used by atomic drivers, remapping of the legacy DPMS
1045 : * property is entirely handled in the DRM core.
1046 : *
1047 : * RETURNS:
1048 : *
1049 : * 0 on success or a negative error code on failure.
1050 : */
1051 : int (*dpms)(struct drm_connector *connector, int mode);
1052 :
1053 : /**
1054 : * @reset:
1055 : *
1056 : * Reset connector hardware and software state to off. This function isn't
1057 : * called by the core directly, only through drm_mode_config_reset().
1058 : * It's not a helper hook only for historical reasons.
1059 : *
1060 : * Atomic drivers can use drm_atomic_helper_connector_reset() to reset
1061 : * atomic state using this hook.
1062 : */
1063 : void (*reset)(struct drm_connector *connector);
1064 :
1065 : /**
1066 : * @detect:
1067 : *
1068 : * Check to see if anything is attached to the connector. The parameter
1069 : * force is set to false whilst polling, true when checking the
1070 : * connector due to a user request. force can be used by the driver to
1071 : * avoid expensive, destructive operations during automated probing.
1072 : *
1073 : * This callback is optional, if not implemented the connector will be
1074 : * considered as always being attached.
1075 : *
1076 : * FIXME:
1077 : *
1078 : * Note that this hook is only called by the probe helper. It's not in
1079 : * the helper library vtable purely for historical reasons. The only DRM
1080 : * core entry point to probe connector state is @fill_modes.
1081 : *
1082 : * Note that the helper library will already hold
1083 : * &drm_mode_config.connection_mutex. Drivers which need to grab additional
1084 : * locks to avoid races with concurrent modeset changes need to use
1085 : * &drm_connector_helper_funcs.detect_ctx instead.
1086 : *
1087 : * Also note that this callback can be called no matter the
1088 : * state the connector is in. Drivers that need the underlying
1089 : * device to be powered to perform the detection will first need
1090 : * to make sure it's been properly enabled.
1091 : *
1092 : * RETURNS:
1093 : *
1094 : * drm_connector_status indicating the connector's status.
1095 : */
1096 : enum drm_connector_status (*detect)(struct drm_connector *connector,
1097 : bool force);
1098 :
1099 : /**
1100 : * @force:
1101 : *
1102 : * This function is called to update internal encoder state when the
1103 : * connector is forced to a certain state by userspace, either through
1104 : * the sysfs interfaces or on the kernel cmdline. In that case the
1105 : * @detect callback isn't called.
1106 : *
1107 : * FIXME:
1108 : *
1109 : * Note that this hook is only called by the probe helper. It's not in
1110 : * the helper library vtable purely for historical reasons. The only DRM
1111 : * core entry point to probe connector state is @fill_modes.
1112 : */
1113 : void (*force)(struct drm_connector *connector);
1114 :
1115 : /**
1116 : * @fill_modes:
1117 : *
1118 : * Entry point for output detection and basic mode validation. The
1119 : * driver should reprobe the output if needed (e.g. when hotplug
1120 : * handling is unreliable), add all detected modes to &drm_connector.modes
1121 : * and filter out any the device can't support in any configuration. It
1122 : * also needs to filter out any modes wider or higher than the
1123 : * parameters max_width and max_height indicate.
1124 : *
1125 : * The drivers must also prune any modes no longer valid from
1126 : * &drm_connector.modes. Furthermore it must update
1127 : * &drm_connector.status and &drm_connector.edid. If no EDID has been
1128 : * received for this output connector->edid must be NULL.
1129 : *
1130 : * Drivers using the probe helpers should use
1131 : * drm_helper_probe_single_connector_modes() to implement this
1132 : * function.
1133 : *
1134 : * RETURNS:
1135 : *
1136 : * The number of modes detected and filled into &drm_connector.modes.
1137 : */
1138 : int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);
1139 :
1140 : /**
1141 : * @set_property:
1142 : *
1143 : * This is the legacy entry point to update a property attached to the
1144 : * connector.
1145 : *
1146 : * This callback is optional if the driver does not support any legacy
1147 : * driver-private properties. For atomic drivers it is not used because
1148 : * property handling is done entirely in the DRM core.
1149 : *
1150 : * RETURNS:
1151 : *
1152 : * 0 on success or a negative error code on failure.
1153 : */
1154 : int (*set_property)(struct drm_connector *connector, struct drm_property *property,
1155 : uint64_t val);
1156 :
1157 : /**
1158 : * @late_register:
1159 : *
1160 : * This optional hook can be used to register additional userspace
1161 : * interfaces attached to the connector, light backlight control, i2c,
1162 : * DP aux or similar interfaces. It is called late in the driver load
1163 : * sequence from drm_connector_register() when registering all the
1164 : * core drm connector interfaces. Everything added from this callback
1165 : * should be unregistered in the early_unregister callback.
1166 : *
1167 : * This is called while holding &drm_connector.mutex.
1168 : *
1169 : * Returns:
1170 : *
1171 : * 0 on success, or a negative error code on failure.
1172 : */
1173 : int (*late_register)(struct drm_connector *connector);
1174 :
1175 : /**
1176 : * @early_unregister:
1177 : *
1178 : * This optional hook should be used to unregister the additional
1179 : * userspace interfaces attached to the connector from
1180 : * late_register(). It is called from drm_connector_unregister(),
1181 : * early in the driver unload sequence to disable userspace access
1182 : * before data structures are torndown.
1183 : *
1184 : * This is called while holding &drm_connector.mutex.
1185 : */
1186 : void (*early_unregister)(struct drm_connector *connector);
1187 :
1188 : /**
1189 : * @destroy:
1190 : *
1191 : * Clean up connector resources. This is called at driver unload time
1192 : * through drm_mode_config_cleanup(). It can also be called at runtime
1193 : * when a connector is being hot-unplugged for drivers that support
1194 : * connector hotplugging (e.g. DisplayPort MST).
1195 : */
1196 : void (*destroy)(struct drm_connector *connector);
1197 :
1198 : /**
1199 : * @atomic_duplicate_state:
1200 : *
1201 : * Duplicate the current atomic state for this connector and return it.
1202 : * The core and helpers guarantee that any atomic state duplicated with
1203 : * this hook and still owned by the caller (i.e. not transferred to the
1204 : * driver by calling &drm_mode_config_funcs.atomic_commit) will be
1205 : * cleaned up by calling the @atomic_destroy_state hook in this
1206 : * structure.
1207 : *
1208 : * This callback is mandatory for atomic drivers.
1209 : *
1210 : * Atomic drivers which don't subclass &struct drm_connector_state should use
1211 : * drm_atomic_helper_connector_duplicate_state(). Drivers that subclass the
1212 : * state structure to extend it with driver-private state should use
1213 : * __drm_atomic_helper_connector_duplicate_state() to make sure shared state is
1214 : * duplicated in a consistent fashion across drivers.
1215 : *
1216 : * It is an error to call this hook before &drm_connector.state has been
1217 : * initialized correctly.
1218 : *
1219 : * NOTE:
1220 : *
1221 : * If the duplicate state references refcounted resources this hook must
1222 : * acquire a reference for each of them. The driver must release these
1223 : * references again in @atomic_destroy_state.
1224 : *
1225 : * RETURNS:
1226 : *
1227 : * Duplicated atomic state or NULL when the allocation failed.
1228 : */
1229 : struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector);
1230 :
1231 : /**
1232 : * @atomic_destroy_state:
1233 : *
1234 : * Destroy a state duplicated with @atomic_duplicate_state and release
1235 : * or unreference all resources it references
1236 : *
1237 : * This callback is mandatory for atomic drivers.
1238 : */
1239 : void (*atomic_destroy_state)(struct drm_connector *connector,
1240 : struct drm_connector_state *state);
1241 :
1242 : /**
1243 : * @atomic_set_property:
1244 : *
1245 : * Decode a driver-private property value and store the decoded value
1246 : * into the passed-in state structure. Since the atomic core decodes all
1247 : * standardized properties (even for extensions beyond the core set of
1248 : * properties which might not be implemented by all drivers) this
1249 : * requires drivers to subclass the state structure.
1250 : *
1251 : * Such driver-private properties should really only be implemented for
1252 : * truly hardware/vendor specific state. Instead it is preferred to
1253 : * standardize atomic extension and decode the properties used to expose
1254 : * such an extension in the core.
1255 : *
1256 : * Do not call this function directly, use
1257 : * drm_atomic_connector_set_property() instead.
1258 : *
1259 : * This callback is optional if the driver does not support any
1260 : * driver-private atomic properties.
1261 : *
1262 : * NOTE:
1263 : *
1264 : * This function is called in the state assembly phase of atomic
1265 : * modesets, which can be aborted for any reason (including on
1266 : * userspace's request to just check whether a configuration would be
1267 : * possible). Drivers MUST NOT touch any persistent state (hardware or
1268 : * software) or data structures except the passed in @state parameter.
1269 : *
1270 : * Also since userspace controls in which order properties are set this
1271 : * function must not do any input validation (since the state update is
1272 : * incomplete and hence likely inconsistent). Instead any such input
1273 : * validation must be done in the various atomic_check callbacks.
1274 : *
1275 : * RETURNS:
1276 : *
1277 : * 0 if the property has been found, -EINVAL if the property isn't
1278 : * implemented by the driver (which shouldn't ever happen, the core only
1279 : * asks for properties attached to this connector). No other validation
1280 : * is allowed by the driver. The core already checks that the property
1281 : * value is within the range (integer, valid enum value, ...) the driver
1282 : * set when registering the property.
1283 : */
1284 : int (*atomic_set_property)(struct drm_connector *connector,
1285 : struct drm_connector_state *state,
1286 : struct drm_property *property,
1287 : uint64_t val);
1288 :
1289 : /**
1290 : * @atomic_get_property:
1291 : *
1292 : * Reads out the decoded driver-private property. This is used to
1293 : * implement the GETCONNECTOR IOCTL.
1294 : *
1295 : * Do not call this function directly, use
1296 : * drm_atomic_connector_get_property() instead.
1297 : *
1298 : * This callback is optional if the driver does not support any
1299 : * driver-private atomic properties.
1300 : *
1301 : * RETURNS:
1302 : *
1303 : * 0 on success, -EINVAL if the property isn't implemented by the
1304 : * driver (which shouldn't ever happen, the core only asks for
1305 : * properties attached to this connector).
1306 : */
1307 : int (*atomic_get_property)(struct drm_connector *connector,
1308 : const struct drm_connector_state *state,
1309 : struct drm_property *property,
1310 : uint64_t *val);
1311 :
1312 : /**
1313 : * @atomic_print_state:
1314 : *
1315 : * If driver subclasses &struct drm_connector_state, it should implement
1316 : * this optional hook for printing additional driver specific state.
1317 : *
1318 : * Do not call this directly, use drm_atomic_connector_print_state()
1319 : * instead.
1320 : */
1321 : void (*atomic_print_state)(struct drm_printer *p,
1322 : const struct drm_connector_state *state);
1323 :
1324 : /**
1325 : * @oob_hotplug_event:
1326 : *
1327 : * This will get called when a hotplug-event for a drm-connector
1328 : * has been received from a source outside the display driver / device.
1329 : */
1330 : void (*oob_hotplug_event)(struct drm_connector *connector);
1331 :
1332 : /**
1333 : * @debugfs_init:
1334 : *
1335 : * Allows connectors to create connector-specific debugfs files.
1336 : */
1337 : void (*debugfs_init)(struct drm_connector *connector, struct dentry *root);
1338 : };
1339 :
1340 : /**
1341 : * struct drm_cmdline_mode - DRM Mode passed through the kernel command-line
1342 : *
1343 : * Each connector can have an initial mode with additional options
1344 : * passed through the kernel command line. This structure allows to
1345 : * express those parameters and will be filled by the command-line
1346 : * parser.
1347 : */
1348 : struct drm_cmdline_mode {
1349 : /**
1350 : * @name:
1351 : *
1352 : * Name of the mode.
1353 : */
1354 : char name[DRM_DISPLAY_MODE_LEN];
1355 :
1356 : /**
1357 : * @specified:
1358 : *
1359 : * Has a mode been read from the command-line?
1360 : */
1361 : bool specified;
1362 :
1363 : /**
1364 : * @refresh_specified:
1365 : *
1366 : * Did the mode have a preferred refresh rate?
1367 : */
1368 : bool refresh_specified;
1369 :
1370 : /**
1371 : * @bpp_specified:
1372 : *
1373 : * Did the mode have a preferred BPP?
1374 : */
1375 : bool bpp_specified;
1376 :
1377 : /**
1378 : * @pixel_clock:
1379 : *
1380 : * Pixel Clock in kHz. Optional.
1381 : */
1382 : unsigned int pixel_clock;
1383 :
1384 : /**
1385 : * @xres:
1386 : *
1387 : * Active resolution on the X axis, in pixels.
1388 : */
1389 : int xres;
1390 :
1391 : /**
1392 : * @yres:
1393 : *
1394 : * Active resolution on the Y axis, in pixels.
1395 : */
1396 : int yres;
1397 :
1398 : /**
1399 : * @bpp:
1400 : *
1401 : * Bits per pixels for the mode.
1402 : */
1403 : int bpp;
1404 :
1405 : /**
1406 : * @refresh:
1407 : *
1408 : * Refresh rate, in Hertz.
1409 : */
1410 : int refresh;
1411 :
1412 : /**
1413 : * @rb:
1414 : *
1415 : * Do we need to use reduced blanking?
1416 : */
1417 : bool rb;
1418 :
1419 : /**
1420 : * @interlace:
1421 : *
1422 : * The mode is interlaced.
1423 : */
1424 : bool interlace;
1425 :
1426 : /**
1427 : * @cvt:
1428 : *
1429 : * The timings will be calculated using the VESA Coordinated
1430 : * Video Timings instead of looking up the mode from a table.
1431 : */
1432 : bool cvt;
1433 :
1434 : /**
1435 : * @margins:
1436 : *
1437 : * Add margins to the mode calculation (1.8% of xres rounded
1438 : * down to 8 pixels and 1.8% of yres).
1439 : */
1440 : bool margins;
1441 :
1442 : /**
1443 : * @force:
1444 : *
1445 : * Ignore the hotplug state of the connector, and force its
1446 : * state to one of the DRM_FORCE_* values.
1447 : */
1448 : enum drm_connector_force force;
1449 :
1450 : /**
1451 : * @rotation_reflection:
1452 : *
1453 : * Initial rotation and reflection of the mode setup from the
1454 : * command line. See DRM_MODE_ROTATE_* and
1455 : * DRM_MODE_REFLECT_*. The only rotations supported are
1456 : * DRM_MODE_ROTATE_0 and DRM_MODE_ROTATE_180.
1457 : */
1458 : unsigned int rotation_reflection;
1459 :
1460 : /**
1461 : * @panel_orientation:
1462 : *
1463 : * drm-connector "panel orientation" property override value,
1464 : * DRM_MODE_PANEL_ORIENTATION_UNKNOWN if not set.
1465 : */
1466 : enum drm_panel_orientation panel_orientation;
1467 :
1468 : /**
1469 : * @tv_margins: TV margins to apply to the mode.
1470 : */
1471 : struct drm_connector_tv_margins tv_margins;
1472 :
1473 : /**
1474 : * @tv_mode: TV mode standard. See DRM_MODE_TV_MODE_*.
1475 : */
1476 : enum drm_connector_tv_mode tv_mode;
1477 :
1478 : /**
1479 : * @tv_mode_specified:
1480 : *
1481 : * Did the mode have a preferred TV mode?
1482 : */
1483 : bool tv_mode_specified;
1484 : };
1485 :
1486 : /**
1487 : * struct drm_connector - central DRM connector control structure
1488 : *
1489 : * Each connector may be connected to one or more CRTCs, or may be clonable by
1490 : * another connector if they can share a CRTC. Each connector also has a specific
1491 : * position in the broader display (referred to as a 'screen' though it could
1492 : * span multiple monitors).
1493 : */
1494 : struct drm_connector {
1495 : /** @dev: parent DRM device */
1496 : struct drm_device *dev;
1497 : /** @kdev: kernel device for sysfs attributes */
1498 : struct device *kdev;
1499 : /** @attr: sysfs attributes */
1500 : struct device_attribute *attr;
1501 : /**
1502 : * @fwnode: associated fwnode supplied by platform firmware
1503 : *
1504 : * Drivers can set this to associate a fwnode with a connector, drivers
1505 : * are expected to get a reference on the fwnode when setting this.
1506 : * drm_connector_cleanup() will call fwnode_handle_put() on this.
1507 : */
1508 : struct fwnode_handle *fwnode;
1509 :
1510 : /**
1511 : * @head:
1512 : *
1513 : * List of all connectors on a @dev, linked from
1514 : * &drm_mode_config.connector_list. Protected by
1515 : * &drm_mode_config.connector_list_lock, but please only use
1516 : * &drm_connector_list_iter to walk this list.
1517 : */
1518 : struct list_head head;
1519 :
1520 : /**
1521 : * @global_connector_list_entry:
1522 : *
1523 : * Connector entry in the global connector-list, used by
1524 : * drm_connector_find_by_fwnode().
1525 : */
1526 : struct list_head global_connector_list_entry;
1527 :
1528 : /** @base: base KMS object */
1529 : struct drm_mode_object base;
1530 :
1531 : /** @name: human readable name, can be overwritten by the driver */
1532 : char *name;
1533 :
1534 : /**
1535 : * @mutex: Lock for general connector state, but currently only protects
1536 : * @registered. Most of the connector state is still protected by
1537 : * &drm_mode_config.mutex.
1538 : */
1539 : struct mutex mutex;
1540 :
1541 : /**
1542 : * @index: Compacted connector index, which matches the position inside
1543 : * the mode_config.list for drivers not supporting hot-add/removing. Can
1544 : * be used as an array index. It is invariant over the lifetime of the
1545 : * connector.
1546 : */
1547 : unsigned index;
1548 :
1549 : /**
1550 : * @connector_type:
1551 : * one of the DRM_MODE_CONNECTOR_<foo> types from drm_mode.h
1552 : */
1553 : int connector_type;
1554 : /** @connector_type_id: index into connector type enum */
1555 : int connector_type_id;
1556 : /**
1557 : * @interlace_allowed:
1558 : * Can this connector handle interlaced modes? Only used by
1559 : * drm_helper_probe_single_connector_modes() for mode filtering.
1560 : */
1561 : bool interlace_allowed;
1562 : /**
1563 : * @doublescan_allowed:
1564 : * Can this connector handle doublescan? Only used by
1565 : * drm_helper_probe_single_connector_modes() for mode filtering.
1566 : */
1567 : bool doublescan_allowed;
1568 : /**
1569 : * @stereo_allowed:
1570 : * Can this connector handle stereo modes? Only used by
1571 : * drm_helper_probe_single_connector_modes() for mode filtering.
1572 : */
1573 : bool stereo_allowed;
1574 :
1575 : /**
1576 : * @ycbcr_420_allowed : This bool indicates if this connector is
1577 : * capable of handling YCBCR 420 output. While parsing the EDID
1578 : * blocks it's very helpful to know if the source is capable of
1579 : * handling YCBCR 420 outputs.
1580 : */
1581 : bool ycbcr_420_allowed;
1582 :
1583 : /**
1584 : * @registration_state: Is this connector initializing, exposed
1585 : * (registered) with userspace, or unregistered?
1586 : *
1587 : * Protected by @mutex.
1588 : */
1589 : enum drm_connector_registration_state registration_state;
1590 :
1591 : /**
1592 : * @modes:
1593 : * Modes available on this connector (from fill_modes() + user).
1594 : * Protected by &drm_mode_config.mutex.
1595 : */
1596 : struct list_head modes;
1597 :
1598 : /**
1599 : * @status:
1600 : * One of the drm_connector_status enums (connected, not, or unknown).
1601 : * Protected by &drm_mode_config.mutex.
1602 : */
1603 : enum drm_connector_status status;
1604 :
1605 : /**
1606 : * @probed_modes:
1607 : * These are modes added by probing with DDC or the BIOS, before
1608 : * filtering is applied. Used by the probe helpers. Protected by
1609 : * &drm_mode_config.mutex.
1610 : */
1611 : struct list_head probed_modes;
1612 :
1613 : /**
1614 : * @display_info: Display information is filled from EDID information
1615 : * when a display is detected. For non hot-pluggable displays such as
1616 : * flat panels in embedded systems, the driver should initialize the
1617 : * &drm_display_info.width_mm and &drm_display_info.height_mm fields
1618 : * with the physical size of the display.
1619 : *
1620 : * Protected by &drm_mode_config.mutex.
1621 : */
1622 : struct drm_display_info display_info;
1623 :
1624 : /** @funcs: connector control functions */
1625 : const struct drm_connector_funcs *funcs;
1626 :
1627 : /**
1628 : * @edid_blob_ptr: DRM property containing EDID if present. Protected by
1629 : * &drm_mode_config.mutex. This should be updated only by calling
1630 : * drm_connector_update_edid_property().
1631 : */
1632 : struct drm_property_blob *edid_blob_ptr;
1633 :
1634 : /** @properties: property tracking for this connector */
1635 : struct drm_object_properties properties;
1636 :
1637 : /**
1638 : * @scaling_mode_property: Optional atomic property to control the
1639 : * upscaling. See drm_connector_attach_content_protection_property().
1640 : */
1641 : struct drm_property *scaling_mode_property;
1642 :
1643 : /**
1644 : * @vrr_capable_property: Optional property to help userspace
1645 : * query hardware support for variable refresh rate on a connector.
1646 : * connector. Drivers can add the property to a connector by
1647 : * calling drm_connector_attach_vrr_capable_property().
1648 : *
1649 : * This should be updated only by calling
1650 : * drm_connector_set_vrr_capable_property().
1651 : */
1652 : struct drm_property *vrr_capable_property;
1653 :
1654 : /**
1655 : * @colorspace_property: Connector property to set the suitable
1656 : * colorspace supported by the sink.
1657 : */
1658 : struct drm_property *colorspace_property;
1659 :
1660 : /**
1661 : * @path_blob_ptr:
1662 : *
1663 : * DRM blob property data for the DP MST path property. This should only
1664 : * be updated by calling drm_connector_set_path_property().
1665 : */
1666 : struct drm_property_blob *path_blob_ptr;
1667 :
1668 : /**
1669 : * @max_bpc_property: Default connector property for the max bpc to be
1670 : * driven out of the connector.
1671 : */
1672 : struct drm_property *max_bpc_property;
1673 :
1674 : /** @privacy_screen: drm_privacy_screen for this connector, or NULL. */
1675 : struct drm_privacy_screen *privacy_screen;
1676 :
1677 : /** @privacy_screen_notifier: privacy-screen notifier_block */
1678 : struct notifier_block privacy_screen_notifier;
1679 :
1680 : /**
1681 : * @privacy_screen_sw_state_property: Optional atomic property for the
1682 : * connector to control the integrated privacy screen.
1683 : */
1684 : struct drm_property *privacy_screen_sw_state_property;
1685 :
1686 : /**
1687 : * @privacy_screen_hw_state_property: Optional atomic property for the
1688 : * connector to report the actual integrated privacy screen state.
1689 : */
1690 : struct drm_property *privacy_screen_hw_state_property;
1691 :
1692 : #define DRM_CONNECTOR_POLL_HPD (1 << 0)
1693 : #define DRM_CONNECTOR_POLL_CONNECT (1 << 1)
1694 : #define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2)
1695 :
1696 : /**
1697 : * @polled:
1698 : *
1699 : * Connector polling mode, a combination of
1700 : *
1701 : * DRM_CONNECTOR_POLL_HPD
1702 : * The connector generates hotplug events and doesn't need to be
1703 : * periodically polled. The CONNECT and DISCONNECT flags must not
1704 : * be set together with the HPD flag.
1705 : *
1706 : * DRM_CONNECTOR_POLL_CONNECT
1707 : * Periodically poll the connector for connection.
1708 : *
1709 : * DRM_CONNECTOR_POLL_DISCONNECT
1710 : * Periodically poll the connector for disconnection, without
1711 : * causing flickering even when the connector is in use. DACs should
1712 : * rarely do this without a lot of testing.
1713 : *
1714 : * Set to 0 for connectors that don't support connection status
1715 : * discovery.
1716 : */
1717 : uint8_t polled;
1718 :
1719 : /**
1720 : * @dpms: Current dpms state. For legacy drivers the
1721 : * &drm_connector_funcs.dpms callback must update this. For atomic
1722 : * drivers, this is handled by the core atomic code, and drivers must
1723 : * only take &drm_crtc_state.active into account.
1724 : */
1725 : int dpms;
1726 :
1727 : /** @helper_private: mid-layer private data */
1728 : const struct drm_connector_helper_funcs *helper_private;
1729 :
1730 : /** @cmdline_mode: mode line parsed from the kernel cmdline for this connector */
1731 : struct drm_cmdline_mode cmdline_mode;
1732 : /** @force: a DRM_FORCE_<foo> state for forced mode sets */
1733 : enum drm_connector_force force;
1734 :
1735 : /**
1736 : * @edid_override: Override EDID set via debugfs.
1737 : *
1738 : * Do not modify or access outside of the drm_edid_override_* family of
1739 : * functions.
1740 : */
1741 : const struct drm_edid *edid_override;
1742 :
1743 : /**
1744 : * @edid_override_mutex: Protect access to edid_override.
1745 : */
1746 : struct mutex edid_override_mutex;
1747 :
1748 : /** @epoch_counter: used to detect any other changes in connector, besides status */
1749 : u64 epoch_counter;
1750 :
1751 : /**
1752 : * @possible_encoders: Bit mask of encoders that can drive this
1753 : * connector, drm_encoder_index() determines the index into the bitfield
1754 : * and the bits are set with drm_connector_attach_encoder().
1755 : */
1756 : u32 possible_encoders;
1757 :
1758 : /**
1759 : * @encoder: Currently bound encoder driving this connector, if any.
1760 : * Only really meaningful for non-atomic drivers. Atomic drivers should
1761 : * instead look at &drm_connector_state.best_encoder, and in case they
1762 : * need the CRTC driving this output, &drm_connector_state.crtc.
1763 : */
1764 : struct drm_encoder *encoder;
1765 :
1766 : #define MAX_ELD_BYTES 128
1767 : /** @eld: EDID-like data, if present */
1768 : uint8_t eld[MAX_ELD_BYTES];
1769 : /** @latency_present: AV delay info from ELD, if found */
1770 : bool latency_present[2];
1771 : /**
1772 : * @video_latency: Video latency info from ELD, if found.
1773 : * [0]: progressive, [1]: interlaced
1774 : */
1775 : int video_latency[2];
1776 : /**
1777 : * @audio_latency: audio latency info from ELD, if found
1778 : * [0]: progressive, [1]: interlaced
1779 : */
1780 : int audio_latency[2];
1781 :
1782 : /**
1783 : * @ddc: associated ddc adapter.
1784 : * A connector usually has its associated ddc adapter. If a driver uses
1785 : * this field, then an appropriate symbolic link is created in connector
1786 : * sysfs directory to make it easy for the user to tell which i2c
1787 : * adapter is for a particular display.
1788 : *
1789 : * The field should be set by calling drm_connector_init_with_ddc().
1790 : */
1791 : struct i2c_adapter *ddc;
1792 :
1793 : /**
1794 : * @null_edid_counter: track sinks that give us all zeros for the EDID.
1795 : * Needed to workaround some HW bugs where we get all 0s
1796 : */
1797 : int null_edid_counter;
1798 :
1799 : /** @bad_edid_counter: track sinks that give us an EDID with invalid checksum */
1800 : unsigned bad_edid_counter;
1801 :
1802 : /**
1803 : * @edid_corrupt: Indicates whether the last read EDID was corrupt. Used
1804 : * in Displayport compliance testing - Displayport Link CTS Core 1.2
1805 : * rev1.1 4.2.2.6
1806 : */
1807 : bool edid_corrupt;
1808 : /**
1809 : * @real_edid_checksum: real edid checksum for corrupted edid block.
1810 : * Required in Displayport 1.4 compliance testing
1811 : * rev1.1 4.2.2.6
1812 : */
1813 : u8 real_edid_checksum;
1814 :
1815 : /** @debugfs_entry: debugfs directory for this connector */
1816 : struct dentry *debugfs_entry;
1817 :
1818 : /**
1819 : * @state:
1820 : *
1821 : * Current atomic state for this connector.
1822 : *
1823 : * This is protected by &drm_mode_config.connection_mutex. Note that
1824 : * nonblocking atomic commits access the current connector state without
1825 : * taking locks. Either by going through the &struct drm_atomic_state
1826 : * pointers, see for_each_oldnew_connector_in_state(),
1827 : * for_each_old_connector_in_state() and
1828 : * for_each_new_connector_in_state(). Or through careful ordering of
1829 : * atomic commit operations as implemented in the atomic helpers, see
1830 : * &struct drm_crtc_commit.
1831 : */
1832 : struct drm_connector_state *state;
1833 :
1834 : /* DisplayID bits. FIXME: Extract into a substruct? */
1835 :
1836 : /**
1837 : * @tile_blob_ptr:
1838 : *
1839 : * DRM blob property data for the tile property (used mostly by DP MST).
1840 : * This is meant for screens which are driven through separate display
1841 : * pipelines represented by &drm_crtc, which might not be running with
1842 : * genlocked clocks. For tiled panels which are genlocked, like
1843 : * dual-link LVDS or dual-link DSI, the driver should try to not expose
1844 : * the tiling and virtualize both &drm_crtc and &drm_plane if needed.
1845 : *
1846 : * This should only be updated by calling
1847 : * drm_connector_set_tile_property().
1848 : */
1849 : struct drm_property_blob *tile_blob_ptr;
1850 :
1851 : /** @has_tile: is this connector connected to a tiled monitor */
1852 : bool has_tile;
1853 : /** @tile_group: tile group for the connected monitor */
1854 : struct drm_tile_group *tile_group;
1855 : /** @tile_is_single_monitor: whether the tile is one monitor housing */
1856 : bool tile_is_single_monitor;
1857 :
1858 : /** @num_h_tile: number of horizontal tiles in the tile group */
1859 : /** @num_v_tile: number of vertical tiles in the tile group */
1860 : uint8_t num_h_tile, num_v_tile;
1861 : /** @tile_h_loc: horizontal location of this tile */
1862 : /** @tile_v_loc: vertical location of this tile */
1863 : uint8_t tile_h_loc, tile_v_loc;
1864 : /** @tile_h_size: horizontal size of this tile. */
1865 : /** @tile_v_size: vertical size of this tile. */
1866 : uint16_t tile_h_size, tile_v_size;
1867 :
1868 : /**
1869 : * @free_node:
1870 : *
1871 : * List used only by &drm_connector_list_iter to be able to clean up a
1872 : * connector from any context, in conjunction with
1873 : * &drm_mode_config.connector_free_work.
1874 : */
1875 : struct llist_node free_node;
1876 :
1877 : /** @hdr_sink_metadata: HDR Metadata Information read from sink */
1878 : struct hdr_sink_metadata hdr_sink_metadata;
1879 : };
1880 :
1881 : #define obj_to_connector(x) container_of(x, struct drm_connector, base)
1882 :
1883 : int drm_connector_init(struct drm_device *dev,
1884 : struct drm_connector *connector,
1885 : const struct drm_connector_funcs *funcs,
1886 : int connector_type);
1887 : int drm_connector_init_with_ddc(struct drm_device *dev,
1888 : struct drm_connector *connector,
1889 : const struct drm_connector_funcs *funcs,
1890 : int connector_type,
1891 : struct i2c_adapter *ddc);
1892 : int drmm_connector_init(struct drm_device *dev,
1893 : struct drm_connector *connector,
1894 : const struct drm_connector_funcs *funcs,
1895 : int connector_type,
1896 : struct i2c_adapter *ddc);
1897 : void drm_connector_attach_edid_property(struct drm_connector *connector);
1898 : int drm_connector_register(struct drm_connector *connector);
1899 : void drm_connector_unregister(struct drm_connector *connector);
1900 : int drm_connector_attach_encoder(struct drm_connector *connector,
1901 : struct drm_encoder *encoder);
1902 :
1903 : void drm_connector_cleanup(struct drm_connector *connector);
1904 :
1905 : static inline unsigned int drm_connector_index(const struct drm_connector *connector)
1906 : {
1907 : return connector->index;
1908 : }
1909 :
1910 : static inline u32 drm_connector_mask(const struct drm_connector *connector)
1911 : {
1912 0 : return 1 << connector->index;
1913 : }
1914 :
1915 : /**
1916 : * drm_connector_lookup - lookup connector object
1917 : * @dev: DRM device
1918 : * @file_priv: drm file to check for lease against.
1919 : * @id: connector object id
1920 : *
1921 : * This function looks up the connector object specified by id
1922 : * add takes a reference to it.
1923 : */
1924 : static inline struct drm_connector *drm_connector_lookup(struct drm_device *dev,
1925 : struct drm_file *file_priv,
1926 : uint32_t id)
1927 : {
1928 : struct drm_mode_object *mo;
1929 0 : mo = drm_mode_object_find(dev, file_priv, id, DRM_MODE_OBJECT_CONNECTOR);
1930 0 : return mo ? obj_to_connector(mo) : NULL;
1931 : }
1932 :
1933 : /**
1934 : * drm_connector_get - acquire a connector reference
1935 : * @connector: DRM connector
1936 : *
1937 : * This function increments the connector's refcount.
1938 : */
1939 : static inline void drm_connector_get(struct drm_connector *connector)
1940 : {
1941 0 : drm_mode_object_get(&connector->base);
1942 : }
1943 :
1944 : /**
1945 : * drm_connector_put - release a connector reference
1946 : * @connector: DRM connector
1947 : *
1948 : * This function decrements the connector's reference count and frees the
1949 : * object if the reference count drops to zero.
1950 : */
1951 : static inline void drm_connector_put(struct drm_connector *connector)
1952 : {
1953 0 : drm_mode_object_put(&connector->base);
1954 : }
1955 :
1956 : /**
1957 : * drm_connector_is_unregistered - has the connector been unregistered from
1958 : * userspace?
1959 : * @connector: DRM connector
1960 : *
1961 : * Checks whether or not @connector has been unregistered from userspace.
1962 : *
1963 : * Returns:
1964 : * True if the connector was unregistered, false if the connector is
1965 : * registered or has not yet been registered with userspace.
1966 : */
1967 : static inline bool
1968 : drm_connector_is_unregistered(struct drm_connector *connector)
1969 : {
1970 0 : return READ_ONCE(connector->registration_state) ==
1971 : DRM_CONNECTOR_UNREGISTERED;
1972 : }
1973 :
1974 : void drm_connector_oob_hotplug_event(struct fwnode_handle *connector_fwnode);
1975 : const char *drm_get_connector_type_name(unsigned int connector_type);
1976 : const char *drm_get_connector_status_name(enum drm_connector_status status);
1977 : const char *drm_get_subpixel_order_name(enum subpixel_order order);
1978 : const char *drm_get_dpms_name(int val);
1979 : const char *drm_get_dvi_i_subconnector_name(int val);
1980 : const char *drm_get_dvi_i_select_name(int val);
1981 : const char *drm_get_tv_mode_name(int val);
1982 : const char *drm_get_tv_subconnector_name(int val);
1983 : const char *drm_get_tv_select_name(int val);
1984 : const char *drm_get_dp_subconnector_name(int val);
1985 : const char *drm_get_content_protection_name(int val);
1986 : const char *drm_get_hdcp_content_type_name(int val);
1987 :
1988 : int drm_get_tv_mode_from_name(const char *name, size_t len);
1989 :
1990 : int drm_mode_create_dvi_i_properties(struct drm_device *dev);
1991 : void drm_connector_attach_dp_subconnector_property(struct drm_connector *connector);
1992 :
1993 : int drm_mode_create_tv_margin_properties(struct drm_device *dev);
1994 : int drm_mode_create_tv_properties_legacy(struct drm_device *dev,
1995 : unsigned int num_modes,
1996 : const char * const modes[]);
1997 : int drm_mode_create_tv_properties(struct drm_device *dev,
1998 : unsigned int supported_tv_modes);
1999 : void drm_connector_attach_tv_margin_properties(struct drm_connector *conn);
2000 : int drm_mode_create_scaling_mode_property(struct drm_device *dev);
2001 : int drm_connector_attach_content_type_property(struct drm_connector *dev);
2002 : int drm_connector_attach_scaling_mode_property(struct drm_connector *connector,
2003 : u32 scaling_mode_mask);
2004 : int drm_connector_attach_vrr_capable_property(
2005 : struct drm_connector *connector);
2006 : int drm_connector_attach_colorspace_property(struct drm_connector *connector);
2007 : int drm_connector_attach_hdr_output_metadata_property(struct drm_connector *connector);
2008 : bool drm_connector_atomic_hdr_metadata_equal(struct drm_connector_state *old_state,
2009 : struct drm_connector_state *new_state);
2010 : int drm_mode_create_aspect_ratio_property(struct drm_device *dev);
2011 : int drm_mode_create_hdmi_colorspace_property(struct drm_connector *connector,
2012 : u32 supported_colorspaces);
2013 : int drm_mode_create_dp_colorspace_property(struct drm_connector *connector,
2014 : u32 supported_colorspaces);
2015 : int drm_mode_create_content_type_property(struct drm_device *dev);
2016 : int drm_mode_create_suggested_offset_properties(struct drm_device *dev);
2017 :
2018 : int drm_connector_set_path_property(struct drm_connector *connector,
2019 : const char *path);
2020 : int drm_connector_set_tile_property(struct drm_connector *connector);
2021 : int drm_connector_update_edid_property(struct drm_connector *connector,
2022 : const struct edid *edid);
2023 : void drm_connector_set_link_status_property(struct drm_connector *connector,
2024 : uint64_t link_status);
2025 : void drm_connector_set_vrr_capable_property(
2026 : struct drm_connector *connector, bool capable);
2027 : int drm_connector_set_panel_orientation(
2028 : struct drm_connector *connector,
2029 : enum drm_panel_orientation panel_orientation);
2030 : int drm_connector_set_panel_orientation_with_quirk(
2031 : struct drm_connector *connector,
2032 : enum drm_panel_orientation panel_orientation,
2033 : int width, int height);
2034 : int drm_connector_set_orientation_from_panel(
2035 : struct drm_connector *connector,
2036 : struct drm_panel *panel);
2037 : int drm_connector_attach_max_bpc_property(struct drm_connector *connector,
2038 : int min, int max);
2039 : void drm_connector_create_privacy_screen_properties(struct drm_connector *conn);
2040 : void drm_connector_attach_privacy_screen_properties(struct drm_connector *conn);
2041 : void drm_connector_attach_privacy_screen_provider(
2042 : struct drm_connector *connector, struct drm_privacy_screen *priv);
2043 : void drm_connector_update_privacy_screen(const struct drm_connector_state *connector_state);
2044 :
2045 : /**
2046 : * struct drm_tile_group - Tile group metadata
2047 : * @refcount: reference count
2048 : * @dev: DRM device
2049 : * @id: tile group id exposed to userspace
2050 : * @group_data: Sink-private data identifying this group
2051 : *
2052 : * @group_data corresponds to displayid vend/prod/serial for external screens
2053 : * with an EDID.
2054 : */
2055 : struct drm_tile_group {
2056 : struct kref refcount;
2057 : struct drm_device *dev;
2058 : int id;
2059 : u8 group_data[8];
2060 : };
2061 :
2062 : struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
2063 : const char topology[8]);
2064 : struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev,
2065 : const char topology[8]);
2066 : void drm_mode_put_tile_group(struct drm_device *dev,
2067 : struct drm_tile_group *tg);
2068 :
2069 : /**
2070 : * struct drm_connector_list_iter - connector_list iterator
2071 : *
2072 : * This iterator tracks state needed to be able to walk the connector_list
2073 : * within struct drm_mode_config. Only use together with
2074 : * drm_connector_list_iter_begin(), drm_connector_list_iter_end() and
2075 : * drm_connector_list_iter_next() respectively the convenience macro
2076 : * drm_for_each_connector_iter().
2077 : *
2078 : * Note that the return value of drm_connector_list_iter_next() is only valid
2079 : * up to the next drm_connector_list_iter_next() or
2080 : * drm_connector_list_iter_end() call. If you want to use the connector later,
2081 : * then you need to grab your own reference first using drm_connector_get().
2082 : */
2083 : struct drm_connector_list_iter {
2084 : /* private: */
2085 : struct drm_device *dev;
2086 : struct drm_connector *conn;
2087 : };
2088 :
2089 : void drm_connector_list_iter_begin(struct drm_device *dev,
2090 : struct drm_connector_list_iter *iter);
2091 : struct drm_connector *
2092 : drm_connector_list_iter_next(struct drm_connector_list_iter *iter);
2093 : void drm_connector_list_iter_end(struct drm_connector_list_iter *iter);
2094 :
2095 : bool drm_connector_has_possible_encoder(struct drm_connector *connector,
2096 : struct drm_encoder *encoder);
2097 : const char *drm_get_colorspace_name(enum drm_colorspace colorspace);
2098 :
2099 : /**
2100 : * drm_for_each_connector_iter - connector_list iterator macro
2101 : * @connector: &struct drm_connector pointer used as cursor
2102 : * @iter: &struct drm_connector_list_iter
2103 : *
2104 : * Note that @connector is only valid within the list body, if you want to use
2105 : * @connector after calling drm_connector_list_iter_end() then you need to grab
2106 : * your own reference first using drm_connector_get().
2107 : */
2108 : #define drm_for_each_connector_iter(connector, iter) \
2109 : while ((connector = drm_connector_list_iter_next(iter)))
2110 :
2111 : /**
2112 : * drm_connector_for_each_possible_encoder - iterate connector's possible encoders
2113 : * @connector: &struct drm_connector pointer
2114 : * @encoder: &struct drm_encoder pointer used as cursor
2115 : */
2116 : #define drm_connector_for_each_possible_encoder(connector, encoder) \
2117 : drm_for_each_encoder_mask(encoder, (connector)->dev, \
2118 : (connector)->possible_encoders)
2119 :
2120 : #endif
|
