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