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