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