drm_connector.h source code [Linux/include/drm/drm_connector.h]

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

Browse the source code of Linux/include/drm/drm_connector.h