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