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 #include <drm/drm_auth.h> 24 #include <drm/drm_connector.h> 25 #include <drm/drm_drv.h> 26 #include <drm/drm_edid.h> 27 #include <drm/drm_encoder.h> 28 #include <drm/drm_file.h> 29 #include <drm/drm_managed.h> 30 #include <drm/drm_panel.h> 31 #include <drm/drm_print.h> 32 #include <drm/drm_privacy_screen_consumer.h> 33 #include <drm/drm_sysfs.h> 34 #include <drm/drm_utils.h> 35 36 #include <linux/property.h> 37 #include <linux/uaccess.h> 38 39 #include <video/cmdline.h> 40 41 #include "drm_crtc_internal.h" 42 #include "drm_internal.h" 43 44 /** 45 * DOC: overview 46 * 47 * In DRM connectors are the general abstraction for display sinks, and include 48 * also fixed panels or anything else that can display pixels in some form. As 49 * opposed to all other KMS objects representing hardware (like CRTC, encoder or 50 * plane abstractions) connectors can be hotplugged and unplugged at runtime. 51 * Hence they are reference-counted using drm_connector_get() and 52 * drm_connector_put(). 53 * 54 * KMS driver must create, initialize, register and attach at a &struct 55 * drm_connector for each such sink. The instance is created as other KMS 56 * objects and initialized by setting the following fields. The connector is 57 * initialized with a call to drm_connector_init() with a pointer to the 58 * &struct drm_connector_funcs and a connector type, and then exposed to 59 * userspace with a call to drm_connector_register(). 60 * 61 * Connectors must be attached to an encoder to be used. For devices that map 62 * connectors to encoders 1:1, the connector should be attached at 63 * initialization time with a call to drm_connector_attach_encoder(). The 64 * driver must also set the &drm_connector.encoder field to point to the 65 * attached encoder. 66 * 67 * For connectors which are not fixed (like built-in panels) the driver needs to 68 * support hotplug notifications. The simplest way to do that is by using the 69 * probe helpers, see drm_kms_helper_poll_init() for connectors which don't have 70 * hardware support for hotplug interrupts. Connectors with hardware hotplug 71 * support can instead use e.g. drm_helper_hpd_irq_event(). 72 */ 73 74 /* 75 * Global connector list for drm_connector_find_by_fwnode(). 76 * Note drm_connector_[un]register() first take connector->lock and then 77 * take the connector_list_lock. 78 */ 79 static DEFINE_MUTEX(connector_list_lock); 80 static LIST_HEAD(connector_list); 81 82 struct drm_conn_prop_enum_list { 83 int type; 84 const char *name; 85 struct ida ida; 86 }; 87 88 /* 89 * Connector and encoder types. 90 */ 91 static struct drm_conn_prop_enum_list drm_connector_enum_list[] = { 92 { DRM_MODE_CONNECTOR_Unknown, "Unknown" }, 93 { DRM_MODE_CONNECTOR_VGA, "VGA" }, 94 { DRM_MODE_CONNECTOR_DVII, "DVI-I" }, 95 { DRM_MODE_CONNECTOR_DVID, "DVI-D" }, 96 { DRM_MODE_CONNECTOR_DVIA, "DVI-A" }, 97 { DRM_MODE_CONNECTOR_Composite, "Composite" }, 98 { DRM_MODE_CONNECTOR_SVIDEO, "SVIDEO" }, 99 { DRM_MODE_CONNECTOR_LVDS, "LVDS" }, 100 { DRM_MODE_CONNECTOR_Component, "Component" }, 101 { DRM_MODE_CONNECTOR_9PinDIN, "DIN" }, 102 { DRM_MODE_CONNECTOR_DisplayPort, "DP" }, 103 { DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" }, 104 { DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" }, 105 { DRM_MODE_CONNECTOR_TV, "TV" }, 106 { DRM_MODE_CONNECTOR_eDP, "eDP" }, 107 { DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" }, 108 { DRM_MODE_CONNECTOR_DSI, "DSI" }, 109 { DRM_MODE_CONNECTOR_DPI, "DPI" }, 110 { DRM_MODE_CONNECTOR_WRITEBACK, "Writeback" }, 111 { DRM_MODE_CONNECTOR_SPI, "SPI" }, 112 { DRM_MODE_CONNECTOR_USB, "USB" }, 113 }; 114 115 void drm_connector_ida_init(void) 116 { 117 int i; 118 119 for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++) 120 ida_init(&drm_connector_enum_list[i].ida); 121 } 122 123 void drm_connector_ida_destroy(void) 124 { 125 int i; 126 127 for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++) 128 ida_destroy(&drm_connector_enum_list[i].ida); 129 } 130 131 /** 132 * drm_get_connector_type_name - return a string for connector type 133 * @type: The connector type (DRM_MODE_CONNECTOR_*) 134 * 135 * Returns: the name of the connector type, or NULL if the type is not valid. 136 */ 137 const char *drm_get_connector_type_name(unsigned int type) 138 { 139 if (type < ARRAY_SIZE(drm_connector_enum_list)) 140 return drm_connector_enum_list[type].name; 141 142 return NULL; 143 } 144 EXPORT_SYMBOL(drm_get_connector_type_name); 145 146 /** 147 * drm_connector_get_cmdline_mode - reads the user's cmdline mode 148 * @connector: connector to query 149 * 150 * The kernel supports per-connector configuration of its consoles through 151 * use of the video= parameter. This function parses that option and 152 * extracts the user's specified mode (or enable/disable status) for a 153 * particular connector. This is typically only used during the early fbdev 154 * setup. 155 */ 156 static void drm_connector_get_cmdline_mode(struct drm_connector *connector) 157 { 158 struct drm_cmdline_mode *mode = &connector->cmdline_mode; 159 const char *option; 160 161 option = video_get_options(connector->name); 162 if (!option) 163 return; 164 165 if (!drm_mode_parse_command_line_for_connector(option, 166 connector, 167 mode)) 168 return; 169 170 if (mode->force) { 171 DRM_INFO("forcing %s connector %s\n", connector->name, 172 drm_get_connector_force_name(mode->force)); 173 connector->force = mode->force; 174 } 175 176 if (mode->panel_orientation != DRM_MODE_PANEL_ORIENTATION_UNKNOWN) { 177 DRM_INFO("cmdline forces connector %s panel_orientation to %d\n", 178 connector->name, mode->panel_orientation); 179 drm_connector_set_panel_orientation(connector, 180 mode->panel_orientation); 181 } 182 183 DRM_DEBUG_KMS("cmdline mode for connector %s %s %dx%d@%dHz%s%s%s\n", 184 connector->name, mode->name, 185 mode->xres, mode->yres, 186 mode->refresh_specified ? mode->refresh : 60, 187 mode->rb ? " reduced blanking" : "", 188 mode->margins ? " with margins" : "", 189 mode->interlace ? " interlaced" : ""); 190 } 191 192 static void drm_connector_free(struct kref *kref) 193 { 194 struct drm_connector *connector = 195 container_of(kref, struct drm_connector, base.refcount); 196 struct drm_device *dev = connector->dev; 197 198 drm_mode_object_unregister(dev, &connector->base); 199 connector->funcs->destroy(connector); 200 } 201 202 void drm_connector_free_work_fn(struct work_struct *work) 203 { 204 struct drm_connector *connector, *n; 205 struct drm_device *dev = 206 container_of(work, struct drm_device, mode_config.connector_free_work); 207 struct drm_mode_config *config = &dev->mode_config; 208 unsigned long flags; 209 struct llist_node *freed; 210 211 spin_lock_irqsave(&config->connector_list_lock, flags); 212 freed = llist_del_all(&config->connector_free_list); 213 spin_unlock_irqrestore(&config->connector_list_lock, flags); 214 215 llist_for_each_entry_safe(connector, n, freed, free_node) { 216 drm_mode_object_unregister(dev, &connector->base); 217 connector->funcs->destroy(connector); 218 } 219 } 220 221 static int __drm_connector_init(struct drm_device *dev, 222 struct drm_connector *connector, 223 const struct drm_connector_funcs *funcs, 224 int connector_type, 225 struct i2c_adapter *ddc) 226 { 227 struct drm_mode_config *config = &dev->mode_config; 228 int ret; 229 struct ida *connector_ida = 230 &drm_connector_enum_list[connector_type].ida; 231 232 WARN_ON(drm_drv_uses_atomic_modeset(dev) && 233 (!funcs->atomic_destroy_state || 234 !funcs->atomic_duplicate_state)); 235 236 ret = __drm_mode_object_add(dev, &connector->base, 237 DRM_MODE_OBJECT_CONNECTOR, 238 false, drm_connector_free); 239 if (ret) 240 return ret; 241 242 connector->base.properties = &connector->properties; 243 connector->dev = dev; 244 connector->funcs = funcs; 245 246 /* connector index is used with 32bit bitmasks */ 247 ret = ida_alloc_max(&config->connector_ida, 31, GFP_KERNEL); 248 if (ret < 0) { 249 DRM_DEBUG_KMS("Failed to allocate %s connector index: %d\n", 250 drm_connector_enum_list[connector_type].name, 251 ret); 252 goto out_put; 253 } 254 connector->index = ret; 255 ret = 0; 256 257 connector->connector_type = connector_type; 258 connector->connector_type_id = 259 ida_alloc_min(connector_ida, 1, GFP_KERNEL); 260 if (connector->connector_type_id < 0) { 261 ret = connector->connector_type_id; 262 goto out_put_id; 263 } 264 connector->name = 265 kasprintf(GFP_KERNEL, "%s-%d", 266 drm_connector_enum_list[connector_type].name, 267 connector->connector_type_id); 268 if (!connector->name) { 269 ret = -ENOMEM; 270 goto out_put_type_id; 271 } 272 273 /* provide ddc symlink in sysfs */ 274 connector->ddc = ddc; 275 276 INIT_LIST_HEAD(&connector->global_connector_list_entry); 277 INIT_LIST_HEAD(&connector->probed_modes); 278 INIT_LIST_HEAD(&connector->modes); 279 mutex_init(&connector->mutex); 280 mutex_init(&connector->edid_override_mutex); 281 mutex_init(&connector->hdmi.infoframes.lock); 282 connector->edid_blob_ptr = NULL; 283 connector->epoch_counter = 0; 284 connector->tile_blob_ptr = NULL; 285 connector->status = connector_status_unknown; 286 connector->display_info.panel_orientation = 287 DRM_MODE_PANEL_ORIENTATION_UNKNOWN; 288 289 drm_connector_get_cmdline_mode(connector); 290 291 /* We should add connectors at the end to avoid upsetting the connector 292 * index too much. 293 */ 294 spin_lock_irq(&config->connector_list_lock); 295 list_add_tail(&connector->head, &config->connector_list); 296 config->num_connector++; 297 spin_unlock_irq(&config->connector_list_lock); 298 299 if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL && 300 connector_type != DRM_MODE_CONNECTOR_WRITEBACK) 301 drm_connector_attach_edid_property(connector); 302 303 drm_object_attach_property(&connector->base, 304 config->dpms_property, 0); 305 306 drm_object_attach_property(&connector->base, 307 config->link_status_property, 308 0); 309 310 drm_object_attach_property(&connector->base, 311 config->non_desktop_property, 312 0); 313 drm_object_attach_property(&connector->base, 314 config->tile_property, 315 0); 316 317 if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { 318 drm_object_attach_property(&connector->base, config->prop_crtc_id, 0); 319 } 320 321 connector->debugfs_entry = NULL; 322 out_put_type_id: 323 if (ret) 324 ida_free(connector_ida, connector->connector_type_id); 325 out_put_id: 326 if (ret) 327 ida_free(&config->connector_ida, connector->index); 328 out_put: 329 if (ret) 330 drm_mode_object_unregister(dev, &connector->base); 331 332 return ret; 333 } 334 335 /** 336 * drm_connector_init - Init a preallocated connector 337 * @dev: DRM device 338 * @connector: the connector to init 339 * @funcs: callbacks for this connector 340 * @connector_type: user visible type of the connector 341 * 342 * Initialises a preallocated connector. Connectors should be 343 * subclassed as part of driver connector objects. 344 * 345 * At driver unload time the driver's &drm_connector_funcs.destroy hook 346 * should call drm_connector_cleanup() and free the connector structure. 347 * The connector structure should not be allocated with devm_kzalloc(). 348 * 349 * Note: consider using drmm_connector_init() instead of 350 * drm_connector_init() to let the DRM managed resource infrastructure 351 * take care of cleanup and deallocation. 352 * 353 * Returns: 354 * Zero on success, error code on failure. 355 */ 356 int drm_connector_init(struct drm_device *dev, 357 struct drm_connector *connector, 358 const struct drm_connector_funcs *funcs, 359 int connector_type) 360 { 361 if (drm_WARN_ON(dev, !(funcs && funcs->destroy))) 362 return -EINVAL; 363 364 return __drm_connector_init(dev, connector, funcs, connector_type, NULL); 365 } 366 EXPORT_SYMBOL(drm_connector_init); 367 368 /** 369 * drm_connector_init_with_ddc - Init a preallocated connector 370 * @dev: DRM device 371 * @connector: the connector to init 372 * @funcs: callbacks for this connector 373 * @connector_type: user visible type of the connector 374 * @ddc: pointer to the associated ddc adapter 375 * 376 * Initialises a preallocated connector. Connectors should be 377 * subclassed as part of driver connector objects. 378 * 379 * At driver unload time the driver's &drm_connector_funcs.destroy hook 380 * should call drm_connector_cleanup() and free the connector structure. 381 * The connector structure should not be allocated with devm_kzalloc(). 382 * 383 * Ensures that the ddc field of the connector is correctly set. 384 * 385 * Note: consider using drmm_connector_init() instead of 386 * drm_connector_init_with_ddc() to let the DRM managed resource 387 * infrastructure take care of cleanup and deallocation. 388 * 389 * Returns: 390 * Zero on success, error code on failure. 391 */ 392 int drm_connector_init_with_ddc(struct drm_device *dev, 393 struct drm_connector *connector, 394 const struct drm_connector_funcs *funcs, 395 int connector_type, 396 struct i2c_adapter *ddc) 397 { 398 if (drm_WARN_ON(dev, !(funcs && funcs->destroy))) 399 return -EINVAL; 400 401 return __drm_connector_init(dev, connector, funcs, connector_type, ddc); 402 } 403 EXPORT_SYMBOL(drm_connector_init_with_ddc); 404 405 static void drm_connector_cleanup_action(struct drm_device *dev, 406 void *ptr) 407 { 408 struct drm_connector *connector = ptr; 409 410 drm_connector_cleanup(connector); 411 } 412 413 /** 414 * drmm_connector_init - Init a preallocated connector 415 * @dev: DRM device 416 * @connector: the connector to init 417 * @funcs: callbacks for this connector 418 * @connector_type: user visible type of the connector 419 * @ddc: optional pointer to the associated ddc adapter 420 * 421 * Initialises a preallocated connector. Connectors should be 422 * subclassed as part of driver connector objects. 423 * 424 * Cleanup is automatically handled with a call to 425 * drm_connector_cleanup() in a DRM-managed action. 426 * 427 * The connector structure should be allocated with drmm_kzalloc(). 428 * 429 * Returns: 430 * Zero on success, error code on failure. 431 */ 432 int drmm_connector_init(struct drm_device *dev, 433 struct drm_connector *connector, 434 const struct drm_connector_funcs *funcs, 435 int connector_type, 436 struct i2c_adapter *ddc) 437 { 438 int ret; 439 440 if (drm_WARN_ON(dev, funcs && funcs->destroy)) 441 return -EINVAL; 442 443 ret = __drm_connector_init(dev, connector, funcs, connector_type, ddc); 444 if (ret) 445 return ret; 446 447 ret = drmm_add_action_or_reset(dev, drm_connector_cleanup_action, 448 connector); 449 if (ret) 450 return ret; 451 452 return 0; 453 } 454 EXPORT_SYMBOL(drmm_connector_init); 455 456 /** 457 * drmm_connector_hdmi_init - Init a preallocated HDMI connector 458 * @dev: DRM device 459 * @connector: A pointer to the HDMI connector to init 460 * @vendor: HDMI Controller Vendor name 461 * @product: HDMI Controller Product name 462 * @funcs: callbacks for this connector 463 * @hdmi_funcs: HDMI-related callbacks for this connector 464 * @connector_type: user visible type of the connector 465 * @ddc: optional pointer to the associated ddc adapter 466 * @supported_formats: Bitmask of @hdmi_colorspace listing supported output formats 467 * @max_bpc: Maximum bits per char the HDMI connector supports 468 * 469 * Initialises a preallocated HDMI connector. Connectors can be 470 * subclassed as part of driver connector objects. 471 * 472 * Cleanup is automatically handled with a call to 473 * drm_connector_cleanup() in a DRM-managed action. 474 * 475 * The connector structure should be allocated with drmm_kzalloc(). 476 * 477 * Returns: 478 * Zero on success, error code on failure. 479 */ 480 int drmm_connector_hdmi_init(struct drm_device *dev, 481 struct drm_connector *connector, 482 const char *vendor, const char *product, 483 const struct drm_connector_funcs *funcs, 484 const struct drm_connector_hdmi_funcs *hdmi_funcs, 485 int connector_type, 486 struct i2c_adapter *ddc, 487 unsigned long supported_formats, 488 unsigned int max_bpc) 489 { 490 int ret; 491 492 if (!vendor || !product) 493 return -EINVAL; 494 495 if ((strlen(vendor) > DRM_CONNECTOR_HDMI_VENDOR_LEN) || 496 (strlen(product) > DRM_CONNECTOR_HDMI_PRODUCT_LEN)) 497 return -EINVAL; 498 499 if (!(connector_type == DRM_MODE_CONNECTOR_HDMIA || 500 connector_type == DRM_MODE_CONNECTOR_HDMIB)) 501 return -EINVAL; 502 503 if (!supported_formats || !(supported_formats & BIT(HDMI_COLORSPACE_RGB))) 504 return -EINVAL; 505 506 if (!(max_bpc == 8 || max_bpc == 10 || max_bpc == 12)) 507 return -EINVAL; 508 509 ret = drmm_connector_init(dev, connector, funcs, connector_type, ddc); 510 if (ret) 511 return ret; 512 513 connector->hdmi.supported_formats = supported_formats; 514 strtomem_pad(connector->hdmi.vendor, vendor, 0); 515 strtomem_pad(connector->hdmi.product, product, 0); 516 517 /* 518 * drm_connector_attach_max_bpc_property() requires the 519 * connector to have a state. 520 */ 521 if (connector->funcs->reset) 522 connector->funcs->reset(connector); 523 524 drm_connector_attach_max_bpc_property(connector, 8, max_bpc); 525 connector->max_bpc = max_bpc; 526 527 if (max_bpc > 8) 528 drm_connector_attach_hdr_output_metadata_property(connector); 529 530 connector->hdmi.funcs = hdmi_funcs; 531 532 return 0; 533 } 534 EXPORT_SYMBOL(drmm_connector_hdmi_init); 535 536 /** 537 * drm_connector_attach_edid_property - attach edid property. 538 * @connector: the connector 539 * 540 * Some connector types like DRM_MODE_CONNECTOR_VIRTUAL do not get a 541 * edid property attached by default. This function can be used to 542 * explicitly enable the edid property in these cases. 543 */ 544 void drm_connector_attach_edid_property(struct drm_connector *connector) 545 { 546 struct drm_mode_config *config = &connector->dev->mode_config; 547 548 drm_object_attach_property(&connector->base, 549 config->edid_property, 550 0); 551 } 552 EXPORT_SYMBOL(drm_connector_attach_edid_property); 553 554 /** 555 * drm_connector_attach_encoder - attach a connector to an encoder 556 * @connector: connector to attach 557 * @encoder: encoder to attach @connector to 558 * 559 * This function links up a connector to an encoder. Note that the routing 560 * restrictions between encoders and crtcs are exposed to userspace through the 561 * possible_clones and possible_crtcs bitmasks. 562 * 563 * Returns: 564 * Zero on success, negative errno on failure. 565 */ 566 int drm_connector_attach_encoder(struct drm_connector *connector, 567 struct drm_encoder *encoder) 568 { 569 /* 570 * In the past, drivers have attempted to model the static association 571 * of connector to encoder in simple connector/encoder devices using a 572 * direct assignment of connector->encoder = encoder. This connection 573 * is a logical one and the responsibility of the core, so drivers are 574 * expected not to mess with this. 575 * 576 * Note that the error return should've been enough here, but a large 577 * majority of drivers ignores the return value, so add in a big WARN 578 * to get people's attention. 579 */ 580 if (WARN_ON(connector->encoder)) 581 return -EINVAL; 582 583 connector->possible_encoders |= drm_encoder_mask(encoder); 584 585 return 0; 586 } 587 EXPORT_SYMBOL(drm_connector_attach_encoder); 588 589 /** 590 * drm_connector_has_possible_encoder - check if the connector and encoder are 591 * associated with each other 592 * @connector: the connector 593 * @encoder: the encoder 594 * 595 * Returns: 596 * True if @encoder is one of the possible encoders for @connector. 597 */ 598 bool drm_connector_has_possible_encoder(struct drm_connector *connector, 599 struct drm_encoder *encoder) 600 { 601 return connector->possible_encoders & drm_encoder_mask(encoder); 602 } 603 EXPORT_SYMBOL(drm_connector_has_possible_encoder); 604 605 static void drm_mode_remove(struct drm_connector *connector, 606 struct drm_display_mode *mode) 607 { 608 list_del(&mode->head); 609 drm_mode_destroy(connector->dev, mode); 610 } 611 612 /** 613 * drm_connector_cleanup - cleans up an initialised connector 614 * @connector: connector to cleanup 615 * 616 * Cleans up the connector but doesn't free the object. 617 */ 618 void drm_connector_cleanup(struct drm_connector *connector) 619 { 620 struct drm_device *dev = connector->dev; 621 struct drm_display_mode *mode, *t; 622 623 /* The connector should have been removed from userspace long before 624 * it is finally destroyed. 625 */ 626 if (WARN_ON(connector->registration_state == 627 DRM_CONNECTOR_REGISTERED)) 628 drm_connector_unregister(connector); 629 630 if (connector->privacy_screen) { 631 drm_privacy_screen_put(connector->privacy_screen); 632 connector->privacy_screen = NULL; 633 } 634 635 if (connector->tile_group) { 636 drm_mode_put_tile_group(dev, connector->tile_group); 637 connector->tile_group = NULL; 638 } 639 640 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) 641 drm_mode_remove(connector, mode); 642 643 list_for_each_entry_safe(mode, t, &connector->modes, head) 644 drm_mode_remove(connector, mode); 645 646 ida_free(&drm_connector_enum_list[connector->connector_type].ida, 647 connector->connector_type_id); 648 649 ida_free(&dev->mode_config.connector_ida, connector->index); 650 651 kfree(connector->display_info.bus_formats); 652 kfree(connector->display_info.vics); 653 drm_mode_object_unregister(dev, &connector->base); 654 kfree(connector->name); 655 connector->name = NULL; 656 fwnode_handle_put(connector->fwnode); 657 connector->fwnode = NULL; 658 spin_lock_irq(&dev->mode_config.connector_list_lock); 659 list_del(&connector->head); 660 dev->mode_config.num_connector--; 661 spin_unlock_irq(&dev->mode_config.connector_list_lock); 662 663 WARN_ON(connector->state && !connector->funcs->atomic_destroy_state); 664 if (connector->state && connector->funcs->atomic_destroy_state) 665 connector->funcs->atomic_destroy_state(connector, 666 connector->state); 667 668 mutex_destroy(&connector->hdmi.infoframes.lock); 669 mutex_destroy(&connector->mutex); 670 671 memset(connector, 0, sizeof(*connector)); 672 673 if (dev->registered) 674 drm_sysfs_hotplug_event(dev); 675 } 676 EXPORT_SYMBOL(drm_connector_cleanup); 677 678 /** 679 * drm_connector_register - register a connector 680 * @connector: the connector to register 681 * 682 * Register userspace interfaces for a connector. Only call this for connectors 683 * which can be hotplugged after drm_dev_register() has been called already, 684 * e.g. DP MST connectors. All other connectors will be registered automatically 685 * when calling drm_dev_register(). 686 * 687 * When the connector is no longer available, callers must call 688 * drm_connector_unregister(). 689 * 690 * Returns: 691 * Zero on success, error code on failure. 692 */ 693 int drm_connector_register(struct drm_connector *connector) 694 { 695 int ret = 0; 696 697 if (!connector->dev->registered) 698 return 0; 699 700 mutex_lock(&connector->mutex); 701 if (connector->registration_state != DRM_CONNECTOR_INITIALIZING) 702 goto unlock; 703 704 ret = drm_sysfs_connector_add(connector); 705 if (ret) 706 goto unlock; 707 708 drm_debugfs_connector_add(connector); 709 710 if (connector->funcs->late_register) { 711 ret = connector->funcs->late_register(connector); 712 if (ret) 713 goto err_debugfs; 714 } 715 716 ret = drm_sysfs_connector_add_late(connector); 717 if (ret) 718 goto err_late_register; 719 720 drm_mode_object_register(connector->dev, &connector->base); 721 722 connector->registration_state = DRM_CONNECTOR_REGISTERED; 723 724 /* Let userspace know we have a new connector */ 725 drm_sysfs_connector_hotplug_event(connector); 726 727 if (connector->privacy_screen) 728 drm_privacy_screen_register_notifier(connector->privacy_screen, 729 &connector->privacy_screen_notifier); 730 731 mutex_lock(&connector_list_lock); 732 list_add_tail(&connector->global_connector_list_entry, &connector_list); 733 mutex_unlock(&connector_list_lock); 734 goto unlock; 735 736 err_late_register: 737 if (connector->funcs->early_unregister) 738 connector->funcs->early_unregister(connector); 739 err_debugfs: 740 drm_debugfs_connector_remove(connector); 741 drm_sysfs_connector_remove(connector); 742 unlock: 743 mutex_unlock(&connector->mutex); 744 return ret; 745 } 746 EXPORT_SYMBOL(drm_connector_register); 747 748 /** 749 * drm_connector_unregister - unregister a connector 750 * @connector: the connector to unregister 751 * 752 * Unregister userspace interfaces for a connector. Only call this for 753 * connectors which have been registered explicitly by calling 754 * drm_connector_register(). 755 */ 756 void drm_connector_unregister(struct drm_connector *connector) 757 { 758 mutex_lock(&connector->mutex); 759 if (connector->registration_state != DRM_CONNECTOR_REGISTERED) { 760 mutex_unlock(&connector->mutex); 761 return; 762 } 763 764 mutex_lock(&connector_list_lock); 765 list_del_init(&connector->global_connector_list_entry); 766 mutex_unlock(&connector_list_lock); 767 768 if (connector->privacy_screen) 769 drm_privacy_screen_unregister_notifier( 770 connector->privacy_screen, 771 &connector->privacy_screen_notifier); 772 773 drm_sysfs_connector_remove_early(connector); 774 775 if (connector->funcs->early_unregister) 776 connector->funcs->early_unregister(connector); 777 778 drm_debugfs_connector_remove(connector); 779 drm_sysfs_connector_remove(connector); 780 781 connector->registration_state = DRM_CONNECTOR_UNREGISTERED; 782 mutex_unlock(&connector->mutex); 783 } 784 EXPORT_SYMBOL(drm_connector_unregister); 785 786 void drm_connector_unregister_all(struct drm_device *dev) 787 { 788 struct drm_connector *connector; 789 struct drm_connector_list_iter conn_iter; 790 791 drm_connector_list_iter_begin(dev, &conn_iter); 792 drm_for_each_connector_iter(connector, &conn_iter) 793 drm_connector_unregister(connector); 794 drm_connector_list_iter_end(&conn_iter); 795 } 796 797 int drm_connector_register_all(struct drm_device *dev) 798 { 799 struct drm_connector *connector; 800 struct drm_connector_list_iter conn_iter; 801 int ret = 0; 802 803 drm_connector_list_iter_begin(dev, &conn_iter); 804 drm_for_each_connector_iter(connector, &conn_iter) { 805 ret = drm_connector_register(connector); 806 if (ret) 807 break; 808 } 809 drm_connector_list_iter_end(&conn_iter); 810 811 if (ret) 812 drm_connector_unregister_all(dev); 813 return ret; 814 } 815 816 /** 817 * drm_get_connector_status_name - return a string for connector status 818 * @status: connector status to compute name of 819 * 820 * In contrast to the other drm_get_*_name functions this one here returns a 821 * const pointer and hence is threadsafe. 822 * 823 * Returns: connector status string 824 */ 825 const char *drm_get_connector_status_name(enum drm_connector_status status) 826 { 827 if (status == connector_status_connected) 828 return "connected"; 829 else if (status == connector_status_disconnected) 830 return "disconnected"; 831 else 832 return "unknown"; 833 } 834 EXPORT_SYMBOL(drm_get_connector_status_name); 835 836 /** 837 * drm_get_connector_force_name - return a string for connector force 838 * @force: connector force to get name of 839 * 840 * Returns: const pointer to name. 841 */ 842 const char *drm_get_connector_force_name(enum drm_connector_force force) 843 { 844 switch (force) { 845 case DRM_FORCE_UNSPECIFIED: 846 return "unspecified"; 847 case DRM_FORCE_OFF: 848 return "off"; 849 case DRM_FORCE_ON: 850 return "on"; 851 case DRM_FORCE_ON_DIGITAL: 852 return "digital"; 853 default: 854 return "unknown"; 855 } 856 } 857 858 #ifdef CONFIG_LOCKDEP 859 static struct lockdep_map connector_list_iter_dep_map = { 860 .name = "drm_connector_list_iter" 861 }; 862 #endif 863 864 /** 865 * drm_connector_list_iter_begin - initialize a connector_list iterator 866 * @dev: DRM device 867 * @iter: connector_list iterator 868 * 869 * Sets @iter up to walk the &drm_mode_config.connector_list of @dev. @iter 870 * must always be cleaned up again by calling drm_connector_list_iter_end(). 871 * Iteration itself happens using drm_connector_list_iter_next() or 872 * drm_for_each_connector_iter(). 873 */ 874 void drm_connector_list_iter_begin(struct drm_device *dev, 875 struct drm_connector_list_iter *iter) 876 { 877 iter->dev = dev; 878 iter->conn = NULL; 879 lock_acquire_shared_recursive(&connector_list_iter_dep_map, 0, 1, NULL, _RET_IP_); 880 } 881 EXPORT_SYMBOL(drm_connector_list_iter_begin); 882 883 /* 884 * Extra-safe connector put function that works in any context. Should only be 885 * used from the connector_iter functions, where we never really expect to 886 * actually release the connector when dropping our final reference. 887 */ 888 static void 889 __drm_connector_put_safe(struct drm_connector *conn) 890 { 891 struct drm_mode_config *config = &conn->dev->mode_config; 892 893 lockdep_assert_held(&config->connector_list_lock); 894 895 if (!refcount_dec_and_test(&conn->base.refcount.refcount)) 896 return; 897 898 llist_add(&conn->free_node, &config->connector_free_list); 899 schedule_work(&config->connector_free_work); 900 } 901 902 /** 903 * drm_connector_list_iter_next - return next connector 904 * @iter: connector_list iterator 905 * 906 * Returns: the next connector for @iter, or NULL when the list walk has 907 * completed. 908 */ 909 struct drm_connector * 910 drm_connector_list_iter_next(struct drm_connector_list_iter *iter) 911 { 912 struct drm_connector *old_conn = iter->conn; 913 struct drm_mode_config *config = &iter->dev->mode_config; 914 struct list_head *lhead; 915 unsigned long flags; 916 917 spin_lock_irqsave(&config->connector_list_lock, flags); 918 lhead = old_conn ? &old_conn->head : &config->connector_list; 919 920 do { 921 if (lhead->next == &config->connector_list) { 922 iter->conn = NULL; 923 break; 924 } 925 926 lhead = lhead->next; 927 iter->conn = list_entry(lhead, struct drm_connector, head); 928 929 /* loop until it's not a zombie connector */ 930 } while (!kref_get_unless_zero(&iter->conn->base.refcount)); 931 932 if (old_conn) 933 __drm_connector_put_safe(old_conn); 934 spin_unlock_irqrestore(&config->connector_list_lock, flags); 935 936 return iter->conn; 937 } 938 EXPORT_SYMBOL(drm_connector_list_iter_next); 939 940 /** 941 * drm_connector_list_iter_end - tear down a connector_list iterator 942 * @iter: connector_list iterator 943 * 944 * Tears down @iter and releases any resources (like &drm_connector references) 945 * acquired while walking the list. This must always be called, both when the 946 * iteration completes fully or when it was aborted without walking the entire 947 * list. 948 */ 949 void drm_connector_list_iter_end(struct drm_connector_list_iter *iter) 950 { 951 struct drm_mode_config *config = &iter->dev->mode_config; 952 unsigned long flags; 953 954 iter->dev = NULL; 955 if (iter->conn) { 956 spin_lock_irqsave(&config->connector_list_lock, flags); 957 __drm_connector_put_safe(iter->conn); 958 spin_unlock_irqrestore(&config->connector_list_lock, flags); 959 } 960 lock_release(&connector_list_iter_dep_map, _RET_IP_); 961 } 962 EXPORT_SYMBOL(drm_connector_list_iter_end); 963 964 static const struct drm_prop_enum_list drm_subpixel_enum_list[] = { 965 { SubPixelUnknown, "Unknown" }, 966 { SubPixelHorizontalRGB, "Horizontal RGB" }, 967 { SubPixelHorizontalBGR, "Horizontal BGR" }, 968 { SubPixelVerticalRGB, "Vertical RGB" }, 969 { SubPixelVerticalBGR, "Vertical BGR" }, 970 { SubPixelNone, "None" }, 971 }; 972 973 /** 974 * drm_get_subpixel_order_name - return a string for a given subpixel enum 975 * @order: enum of subpixel_order 976 * 977 * Note you could abuse this and return something out of bounds, but that 978 * would be a caller error. No unscrubbed user data should make it here. 979 * 980 * Returns: string describing an enumerated subpixel property 981 */ 982 const char *drm_get_subpixel_order_name(enum subpixel_order order) 983 { 984 return drm_subpixel_enum_list[order].name; 985 } 986 EXPORT_SYMBOL(drm_get_subpixel_order_name); 987 988 static const struct drm_prop_enum_list drm_dpms_enum_list[] = { 989 { DRM_MODE_DPMS_ON, "On" }, 990 { DRM_MODE_DPMS_STANDBY, "Standby" }, 991 { DRM_MODE_DPMS_SUSPEND, "Suspend" }, 992 { DRM_MODE_DPMS_OFF, "Off" } 993 }; 994 DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list) 995 996 static const struct drm_prop_enum_list drm_link_status_enum_list[] = { 997 { DRM_MODE_LINK_STATUS_GOOD, "Good" }, 998 { DRM_MODE_LINK_STATUS_BAD, "Bad" }, 999 }; 1000 1001 /** 1002 * drm_display_info_set_bus_formats - set the supported bus formats 1003 * @info: display info to store bus formats in 1004 * @formats: array containing the supported bus formats 1005 * @num_formats: the number of entries in the fmts array 1006 * 1007 * Store the supported bus formats in display info structure. 1008 * See MEDIA_BUS_FMT_* definitions in include/uapi/linux/media-bus-format.h for 1009 * a full list of available formats. 1010 * 1011 * Returns: 1012 * 0 on success or a negative error code on failure. 1013 */ 1014 int drm_display_info_set_bus_formats(struct drm_display_info *info, 1015 const u32 *formats, 1016 unsigned int num_formats) 1017 { 1018 u32 *fmts = NULL; 1019 1020 if (!formats && num_formats) 1021 return -EINVAL; 1022 1023 if (formats && num_formats) { 1024 fmts = kmemdup(formats, sizeof(*formats) * num_formats, 1025 GFP_KERNEL); 1026 if (!fmts) 1027 return -ENOMEM; 1028 } 1029 1030 kfree(info->bus_formats); 1031 info->bus_formats = fmts; 1032 info->num_bus_formats = num_formats; 1033 1034 return 0; 1035 } 1036 EXPORT_SYMBOL(drm_display_info_set_bus_formats); 1037 1038 /* Optional connector properties. */ 1039 static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] = { 1040 { DRM_MODE_SCALE_NONE, "None" }, 1041 { DRM_MODE_SCALE_FULLSCREEN, "Full" }, 1042 { DRM_MODE_SCALE_CENTER, "Center" }, 1043 { DRM_MODE_SCALE_ASPECT, "Full aspect" }, 1044 }; 1045 1046 static const struct drm_prop_enum_list drm_aspect_ratio_enum_list[] = { 1047 { DRM_MODE_PICTURE_ASPECT_NONE, "Automatic" }, 1048 { DRM_MODE_PICTURE_ASPECT_4_3, "4:3" }, 1049 { DRM_MODE_PICTURE_ASPECT_16_9, "16:9" }, 1050 }; 1051 1052 static const struct drm_prop_enum_list drm_content_type_enum_list[] = { 1053 { DRM_MODE_CONTENT_TYPE_NO_DATA, "No Data" }, 1054 { DRM_MODE_CONTENT_TYPE_GRAPHICS, "Graphics" }, 1055 { DRM_MODE_CONTENT_TYPE_PHOTO, "Photo" }, 1056 { DRM_MODE_CONTENT_TYPE_CINEMA, "Cinema" }, 1057 { DRM_MODE_CONTENT_TYPE_GAME, "Game" }, 1058 }; 1059 1060 static const struct drm_prop_enum_list drm_panel_orientation_enum_list[] = { 1061 { DRM_MODE_PANEL_ORIENTATION_NORMAL, "Normal" }, 1062 { DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP, "Upside Down" }, 1063 { DRM_MODE_PANEL_ORIENTATION_LEFT_UP, "Left Side Up" }, 1064 { DRM_MODE_PANEL_ORIENTATION_RIGHT_UP, "Right Side Up" }, 1065 }; 1066 1067 static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = { 1068 { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ 1069 { DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ 1070 { DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ 1071 }; 1072 DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list) 1073 1074 static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = { 1075 { DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I, TV-out and DP */ 1076 { DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ 1077 { DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ 1078 }; 1079 DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name, 1080 drm_dvi_i_subconnector_enum_list) 1081 1082 static const struct drm_prop_enum_list drm_tv_mode_enum_list[] = { 1083 { DRM_MODE_TV_MODE_NTSC, "NTSC" }, 1084 { DRM_MODE_TV_MODE_NTSC_443, "NTSC-443" }, 1085 { DRM_MODE_TV_MODE_NTSC_J, "NTSC-J" }, 1086 { DRM_MODE_TV_MODE_PAL, "PAL" }, 1087 { DRM_MODE_TV_MODE_PAL_M, "PAL-M" }, 1088 { DRM_MODE_TV_MODE_PAL_N, "PAL-N" }, 1089 { DRM_MODE_TV_MODE_SECAM, "SECAM" }, 1090 }; 1091 DRM_ENUM_NAME_FN(drm_get_tv_mode_name, drm_tv_mode_enum_list) 1092 1093 /** 1094 * drm_get_tv_mode_from_name - Translates a TV mode name into its enum value 1095 * @name: TV Mode name we want to convert 1096 * @len: Length of @name 1097 * 1098 * Translates @name into an enum drm_connector_tv_mode. 1099 * 1100 * Returns: the enum value on success, a negative errno otherwise. 1101 */ 1102 int drm_get_tv_mode_from_name(const char *name, size_t len) 1103 { 1104 unsigned int i; 1105 1106 for (i = 0; i < ARRAY_SIZE(drm_tv_mode_enum_list); i++) { 1107 const struct drm_prop_enum_list *item = &drm_tv_mode_enum_list[i]; 1108 1109 if (strlen(item->name) == len && !strncmp(item->name, name, len)) 1110 return item->type; 1111 } 1112 1113 return -EINVAL; 1114 } 1115 EXPORT_SYMBOL(drm_get_tv_mode_from_name); 1116 1117 static const struct drm_prop_enum_list drm_tv_select_enum_list[] = { 1118 { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ 1119 { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ 1120 { DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ 1121 { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */ 1122 { DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */ 1123 }; 1124 DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list) 1125 1126 static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = { 1127 { DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I, TV-out and DP */ 1128 { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ 1129 { DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ 1130 { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */ 1131 { DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */ 1132 }; 1133 DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name, 1134 drm_tv_subconnector_enum_list) 1135 1136 static const struct drm_prop_enum_list drm_dp_subconnector_enum_list[] = { 1137 { DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I, TV-out and DP */ 1138 { DRM_MODE_SUBCONNECTOR_VGA, "VGA" }, /* DP */ 1139 { DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DP */ 1140 { DRM_MODE_SUBCONNECTOR_HDMIA, "HDMI" }, /* DP */ 1141 { DRM_MODE_SUBCONNECTOR_DisplayPort, "DP" }, /* DP */ 1142 { DRM_MODE_SUBCONNECTOR_Wireless, "Wireless" }, /* DP */ 1143 { DRM_MODE_SUBCONNECTOR_Native, "Native" }, /* DP */ 1144 }; 1145 1146 DRM_ENUM_NAME_FN(drm_get_dp_subconnector_name, 1147 drm_dp_subconnector_enum_list) 1148 1149 1150 static const char * const colorspace_names[] = { 1151 /* For Default case, driver will set the colorspace */ 1152 [DRM_MODE_COLORIMETRY_DEFAULT] = "Default", 1153 /* Standard Definition Colorimetry based on CEA 861 */ 1154 [DRM_MODE_COLORIMETRY_SMPTE_170M_YCC] = "SMPTE_170M_YCC", 1155 [DRM_MODE_COLORIMETRY_BT709_YCC] = "BT709_YCC", 1156 /* Standard Definition Colorimetry based on IEC 61966-2-4 */ 1157 [DRM_MODE_COLORIMETRY_XVYCC_601] = "XVYCC_601", 1158 /* High Definition Colorimetry based on IEC 61966-2-4 */ 1159 [DRM_MODE_COLORIMETRY_XVYCC_709] = "XVYCC_709", 1160 /* Colorimetry based on IEC 61966-2-1/Amendment 1 */ 1161 [DRM_MODE_COLORIMETRY_SYCC_601] = "SYCC_601", 1162 /* Colorimetry based on IEC 61966-2-5 [33] */ 1163 [DRM_MODE_COLORIMETRY_OPYCC_601] = "opYCC_601", 1164 /* Colorimetry based on IEC 61966-2-5 */ 1165 [DRM_MODE_COLORIMETRY_OPRGB] = "opRGB", 1166 /* Colorimetry based on ITU-R BT.2020 */ 1167 [DRM_MODE_COLORIMETRY_BT2020_CYCC] = "BT2020_CYCC", 1168 /* Colorimetry based on ITU-R BT.2020 */ 1169 [DRM_MODE_COLORIMETRY_BT2020_RGB] = "BT2020_RGB", 1170 /* Colorimetry based on ITU-R BT.2020 */ 1171 [DRM_MODE_COLORIMETRY_BT2020_YCC] = "BT2020_YCC", 1172 /* Added as part of Additional Colorimetry Extension in 861.G */ 1173 [DRM_MODE_COLORIMETRY_DCI_P3_RGB_D65] = "DCI-P3_RGB_D65", 1174 [DRM_MODE_COLORIMETRY_DCI_P3_RGB_THEATER] = "DCI-P3_RGB_Theater", 1175 [DRM_MODE_COLORIMETRY_RGB_WIDE_FIXED] = "RGB_WIDE_FIXED", 1176 /* Colorimetry based on scRGB (IEC 61966-2-2) */ 1177 [DRM_MODE_COLORIMETRY_RGB_WIDE_FLOAT] = "RGB_WIDE_FLOAT", 1178 [DRM_MODE_COLORIMETRY_BT601_YCC] = "BT601_YCC", 1179 }; 1180 1181 /** 1182 * drm_get_colorspace_name - return a string for color encoding 1183 * @colorspace: color space to compute name of 1184 * 1185 * In contrast to the other drm_get_*_name functions this one here returns a 1186 * const pointer and hence is threadsafe. 1187 */ 1188 const char *drm_get_colorspace_name(enum drm_colorspace colorspace) 1189 { 1190 if (colorspace < ARRAY_SIZE(colorspace_names) && colorspace_names[colorspace]) 1191 return colorspace_names[colorspace]; 1192 else 1193 return "(null)"; 1194 } 1195 1196 static const u32 hdmi_colorspaces = 1197 BIT(DRM_MODE_COLORIMETRY_SMPTE_170M_YCC) | 1198 BIT(DRM_MODE_COLORIMETRY_BT709_YCC) | 1199 BIT(DRM_MODE_COLORIMETRY_XVYCC_601) | 1200 BIT(DRM_MODE_COLORIMETRY_XVYCC_709) | 1201 BIT(DRM_MODE_COLORIMETRY_SYCC_601) | 1202 BIT(DRM_MODE_COLORIMETRY_OPYCC_601) | 1203 BIT(DRM_MODE_COLORIMETRY_OPRGB) | 1204 BIT(DRM_MODE_COLORIMETRY_BT2020_CYCC) | 1205 BIT(DRM_MODE_COLORIMETRY_BT2020_RGB) | 1206 BIT(DRM_MODE_COLORIMETRY_BT2020_YCC) | 1207 BIT(DRM_MODE_COLORIMETRY_DCI_P3_RGB_D65) | 1208 BIT(DRM_MODE_COLORIMETRY_DCI_P3_RGB_THEATER); 1209 1210 /* 1211 * As per DP 1.4a spec, 2.2.5.7.5 VSC SDP Payload for Pixel Encoding/Colorimetry 1212 * Format Table 2-120 1213 */ 1214 static const u32 dp_colorspaces = 1215 BIT(DRM_MODE_COLORIMETRY_RGB_WIDE_FIXED) | 1216 BIT(DRM_MODE_COLORIMETRY_RGB_WIDE_FLOAT) | 1217 BIT(DRM_MODE_COLORIMETRY_OPRGB) | 1218 BIT(DRM_MODE_COLORIMETRY_DCI_P3_RGB_D65) | 1219 BIT(DRM_MODE_COLORIMETRY_BT2020_RGB) | 1220 BIT(DRM_MODE_COLORIMETRY_BT601_YCC) | 1221 BIT(DRM_MODE_COLORIMETRY_BT709_YCC) | 1222 BIT(DRM_MODE_COLORIMETRY_XVYCC_601) | 1223 BIT(DRM_MODE_COLORIMETRY_XVYCC_709) | 1224 BIT(DRM_MODE_COLORIMETRY_SYCC_601) | 1225 BIT(DRM_MODE_COLORIMETRY_OPYCC_601) | 1226 BIT(DRM_MODE_COLORIMETRY_BT2020_CYCC) | 1227 BIT(DRM_MODE_COLORIMETRY_BT2020_YCC); 1228 1229 static const struct drm_prop_enum_list broadcast_rgb_names[] = { 1230 { DRM_HDMI_BROADCAST_RGB_AUTO, "Automatic" }, 1231 { DRM_HDMI_BROADCAST_RGB_FULL, "Full" }, 1232 { DRM_HDMI_BROADCAST_RGB_LIMITED, "Limited 16:235" }, 1233 }; 1234 1235 /* 1236 * drm_hdmi_connector_get_broadcast_rgb_name - Return a string for HDMI connector RGB broadcast selection 1237 * @broadcast_rgb: Broadcast RGB selection to compute name of 1238 * 1239 * Returns: the name of the Broadcast RGB selection, or NULL if the type 1240 * is not valid. 1241 */ 1242 const char * 1243 drm_hdmi_connector_get_broadcast_rgb_name(enum drm_hdmi_broadcast_rgb broadcast_rgb) 1244 { 1245 if (broadcast_rgb >= ARRAY_SIZE(broadcast_rgb_names)) 1246 return NULL; 1247 1248 return broadcast_rgb_names[broadcast_rgb].name; 1249 } 1250 EXPORT_SYMBOL(drm_hdmi_connector_get_broadcast_rgb_name); 1251 1252 static const char * const output_format_str[] = { 1253 [HDMI_COLORSPACE_RGB] = "RGB", 1254 [HDMI_COLORSPACE_YUV420] = "YUV 4:2:0", 1255 [HDMI_COLORSPACE_YUV422] = "YUV 4:2:2", 1256 [HDMI_COLORSPACE_YUV444] = "YUV 4:4:4", 1257 }; 1258 1259 /* 1260 * drm_hdmi_connector_get_output_format_name() - Return a string for HDMI connector output format 1261 * @fmt: Output format to compute name of 1262 * 1263 * Returns: the name of the output format, or NULL if the type is not 1264 * valid. 1265 */ 1266 const char * 1267 drm_hdmi_connector_get_output_format_name(enum hdmi_colorspace fmt) 1268 { 1269 if (fmt >= ARRAY_SIZE(output_format_str)) 1270 return NULL; 1271 1272 return output_format_str[fmt]; 1273 } 1274 EXPORT_SYMBOL(drm_hdmi_connector_get_output_format_name); 1275 1276 /** 1277 * DOC: standard connector properties 1278 * 1279 * DRM connectors have a few standardized properties: 1280 * 1281 * EDID: 1282 * Blob property which contains the current EDID read from the sink. This 1283 * is useful to parse sink identification information like vendor, model 1284 * and serial. Drivers should update this property by calling 1285 * drm_connector_update_edid_property(), usually after having parsed 1286 * the EDID using drm_add_edid_modes(). Userspace cannot change this 1287 * property. 1288 * 1289 * User-space should not parse the EDID to obtain information exposed via 1290 * other KMS properties (because the kernel might apply limits, quirks or 1291 * fixups to the EDID). For instance, user-space should not try to parse 1292 * mode lists from the EDID. 1293 * DPMS: 1294 * Legacy property for setting the power state of the connector. For atomic 1295 * drivers this is only provided for backwards compatibility with existing 1296 * drivers, it remaps to controlling the "ACTIVE" property on the CRTC the 1297 * connector is linked to. Drivers should never set this property directly, 1298 * it is handled by the DRM core by calling the &drm_connector_funcs.dpms 1299 * callback. For atomic drivers the remapping to the "ACTIVE" property is 1300 * implemented in the DRM core. 1301 * 1302 * Note that this property cannot be set through the MODE_ATOMIC ioctl, 1303 * userspace must use "ACTIVE" on the CRTC instead. 1304 * 1305 * WARNING: 1306 * 1307 * For userspace also running on legacy drivers the "DPMS" semantics are a 1308 * lot more complicated. First, userspace cannot rely on the "DPMS" value 1309 * returned by the GETCONNECTOR actually reflecting reality, because many 1310 * drivers fail to update it. For atomic drivers this is taken care of in 1311 * drm_atomic_helper_update_legacy_modeset_state(). 1312 * 1313 * The second issue is that the DPMS state is only well-defined when the 1314 * connector is connected to a CRTC. In atomic the DRM core enforces that 1315 * "ACTIVE" is off in such a case, no such checks exists for "DPMS". 1316 * 1317 * Finally, when enabling an output using the legacy SETCONFIG ioctl then 1318 * "DPMS" is forced to ON. But see above, that might not be reflected in 1319 * the software value on legacy drivers. 1320 * 1321 * Summarizing: Only set "DPMS" when the connector is known to be enabled, 1322 * assume that a successful SETCONFIG call also sets "DPMS" to on, and 1323 * never read back the value of "DPMS" because it can be incorrect. 1324 * PATH: 1325 * Connector path property to identify how this sink is physically 1326 * connected. Used by DP MST. This should be set by calling 1327 * drm_connector_set_path_property(), in the case of DP MST with the 1328 * path property the MST manager created. Userspace cannot change this 1329 * property. 1330 * 1331 * In the case of DP MST, the property has the format 1332 * ``mst:<parent>-<ports>`` where ``<parent>`` is the KMS object ID of the 1333 * parent connector and ``<ports>`` is a hyphen-separated list of DP MST 1334 * port numbers. Note, KMS object IDs are not guaranteed to be stable 1335 * across reboots. 1336 * TILE: 1337 * Connector tile group property to indicate how a set of DRM connector 1338 * compose together into one logical screen. This is used by both high-res 1339 * external screens (often only using a single cable, but exposing multiple 1340 * DP MST sinks), or high-res integrated panels (like dual-link DSI) which 1341 * are not gen-locked. Note that for tiled panels which are genlocked, like 1342 * dual-link LVDS or dual-link DSI, the driver should try to not expose the 1343 * tiling and virtualise both &drm_crtc and &drm_plane if needed. Drivers 1344 * should update this value using drm_connector_set_tile_property(). 1345 * Userspace cannot change this property. 1346 * link-status: 1347 * Connector link-status property to indicate the status of link. The 1348 * default value of link-status is "GOOD". If something fails during or 1349 * after modeset, the kernel driver may set this to "BAD" and issue a 1350 * hotplug uevent. Drivers should update this value using 1351 * drm_connector_set_link_status_property(). 1352 * 1353 * When user-space receives the hotplug uevent and detects a "BAD" 1354 * link-status, the sink doesn't receive pixels anymore (e.g. the screen 1355 * becomes completely black). The list of available modes may have 1356 * changed. User-space is expected to pick a new mode if the current one 1357 * has disappeared and perform a new modeset with link-status set to 1358 * "GOOD" to re-enable the connector. 1359 * 1360 * If multiple connectors share the same CRTC and one of them gets a "BAD" 1361 * link-status, the other are unaffected (ie. the sinks still continue to 1362 * receive pixels). 1363 * 1364 * When user-space performs an atomic commit on a connector with a "BAD" 1365 * link-status without resetting the property to "GOOD", the sink may 1366 * still not receive pixels. When user-space performs an atomic commit 1367 * which resets the link-status property to "GOOD" without the 1368 * ALLOW_MODESET flag set, it might fail because a modeset is required. 1369 * 1370 * User-space can only change link-status to "GOOD", changing it to "BAD" 1371 * is a no-op. 1372 * 1373 * For backwards compatibility with non-atomic userspace the kernel 1374 * tries to automatically set the link-status back to "GOOD" in the 1375 * SETCRTC IOCTL. This might fail if the mode is no longer valid, similar 1376 * to how it might fail if a different screen has been connected in the 1377 * interim. 1378 * non_desktop: 1379 * Indicates the output should be ignored for purposes of displaying a 1380 * standard desktop environment or console. This is most likely because 1381 * the output device is not rectilinear. 1382 * Content Protection: 1383 * This property is used by userspace to request the kernel protect future 1384 * content communicated over the link. When requested, kernel will apply 1385 * the appropriate means of protection (most often HDCP), and use the 1386 * property to tell userspace the protection is active. 1387 * 1388 * Drivers can set this up by calling 1389 * drm_connector_attach_content_protection_property() on initialization. 1390 * 1391 * The value of this property can be one of the following: 1392 * 1393 * DRM_MODE_CONTENT_PROTECTION_UNDESIRED = 0 1394 * The link is not protected, content is transmitted in the clear. 1395 * DRM_MODE_CONTENT_PROTECTION_DESIRED = 1 1396 * Userspace has requested content protection, but the link is not 1397 * currently protected. When in this state, kernel should enable 1398 * Content Protection as soon as possible. 1399 * DRM_MODE_CONTENT_PROTECTION_ENABLED = 2 1400 * Userspace has requested content protection, and the link is 1401 * protected. Only the driver can set the property to this value. 1402 * If userspace attempts to set to ENABLED, kernel will return 1403 * -EINVAL. 1404 * 1405 * A few guidelines: 1406 * 1407 * - DESIRED state should be preserved until userspace de-asserts it by 1408 * setting the property to UNDESIRED. This means ENABLED should only 1409 * transition to UNDESIRED when the user explicitly requests it. 1410 * - If the state is DESIRED, kernel should attempt to re-authenticate the 1411 * link whenever possible. This includes across disable/enable, dpms, 1412 * hotplug, downstream device changes, link status failures, etc.. 1413 * - Kernel sends uevent with the connector id and property id through 1414 * @drm_hdcp_update_content_protection, upon below kernel triggered 1415 * scenarios: 1416 * 1417 * - DESIRED -> ENABLED (authentication success) 1418 * - ENABLED -> DESIRED (termination of authentication) 1419 * - Please note no uevents for userspace triggered property state changes, 1420 * which can't fail such as 1421 * 1422 * - DESIRED/ENABLED -> UNDESIRED 1423 * - UNDESIRED -> DESIRED 1424 * - Userspace is responsible for polling the property or listen to uevents 1425 * to determine when the value transitions from ENABLED to DESIRED. 1426 * This signifies the link is no longer protected and userspace should 1427 * take appropriate action (whatever that might be). 1428 * 1429 * HDCP Content Type: 1430 * This Enum property is used by the userspace to declare the content type 1431 * of the display stream, to kernel. Here display stream stands for any 1432 * display content that userspace intended to display through HDCP 1433 * encryption. 1434 * 1435 * Content Type of a stream is decided by the owner of the stream, as 1436 * "HDCP Type0" or "HDCP Type1". 1437 * 1438 * The value of the property can be one of the below: 1439 * - "HDCP Type0": DRM_MODE_HDCP_CONTENT_TYPE0 = 0 1440 * - "HDCP Type1": DRM_MODE_HDCP_CONTENT_TYPE1 = 1 1441 * 1442 * When kernel starts the HDCP authentication (see "Content Protection" 1443 * for details), it uses the content type in "HDCP Content Type" 1444 * for performing the HDCP authentication with the display sink. 1445 * 1446 * Please note in HDCP spec versions, a link can be authenticated with 1447 * HDCP 2.2 for Content Type 0/Content Type 1. Where as a link can be 1448 * authenticated with HDCP1.4 only for Content Type 0(though it is implicit 1449 * in nature. As there is no reference for Content Type in HDCP1.4). 1450 * 1451 * HDCP2.2 authentication protocol itself takes the "Content Type" as a 1452 * parameter, which is a input for the DP HDCP2.2 encryption algo. 1453 * 1454 * In case of Type 0 content protection request, kernel driver can choose 1455 * either of HDCP spec versions 1.4 and 2.2. When HDCP2.2 is used for 1456 * "HDCP Type 0", a HDCP 2.2 capable repeater in the downstream can send 1457 * that content to a HDCP 1.4 authenticated HDCP sink (Type0 link). 1458 * But if the content is classified as "HDCP Type 1", above mentioned 1459 * HDCP 2.2 repeater wont send the content to the HDCP sink as it can't 1460 * authenticate the HDCP1.4 capable sink for "HDCP Type 1". 1461 * 1462 * Please note userspace can be ignorant of the HDCP versions used by the 1463 * kernel driver to achieve the "HDCP Content Type". 1464 * 1465 * At current scenario, classifying a content as Type 1 ensures that the 1466 * content will be displayed only through the HDCP2.2 encrypted link. 1467 * 1468 * Note that the HDCP Content Type property is introduced at HDCP 2.2, and 1469 * defaults to type 0. It is only exposed by drivers supporting HDCP 2.2 1470 * (hence supporting Type 0 and Type 1). Based on how next versions of 1471 * HDCP specs are defined content Type could be used for higher versions 1472 * too. 1473 * 1474 * If content type is changed when "Content Protection" is not UNDESIRED, 1475 * then kernel will disable the HDCP and re-enable with new type in the 1476 * same atomic commit. And when "Content Protection" is ENABLED, it means 1477 * that link is HDCP authenticated and encrypted, for the transmission of 1478 * the Type of stream mentioned at "HDCP Content Type". 1479 * 1480 * HDR_OUTPUT_METADATA: 1481 * Connector property to enable userspace to send HDR Metadata to 1482 * driver. This metadata is based on the composition and blending 1483 * policies decided by user, taking into account the hardware and 1484 * sink capabilities. The driver gets this metadata and creates a 1485 * Dynamic Range and Mastering Infoframe (DRM) in case of HDMI, 1486 * SDP packet (Non-audio INFOFRAME SDP v1.3) for DP. This is then 1487 * sent to sink. This notifies the sink of the upcoming frame's Color 1488 * Encoding and Luminance parameters. 1489 * 1490 * Userspace first need to detect the HDR capabilities of sink by 1491 * reading and parsing the EDID. Details of HDR metadata for HDMI 1492 * are added in CTA 861.G spec. For DP , its defined in VESA DP 1493 * Standard v1.4. It needs to then get the metadata information 1494 * of the video/game/app content which are encoded in HDR (basically 1495 * using HDR transfer functions). With this information it needs to 1496 * decide on a blending policy and compose the relevant 1497 * layers/overlays into a common format. Once this blending is done, 1498 * userspace will be aware of the metadata of the composed frame to 1499 * be send to sink. It then uses this property to communicate this 1500 * metadata to driver which then make a Infoframe packet and sends 1501 * to sink based on the type of encoder connected. 1502 * 1503 * Userspace will be responsible to do Tone mapping operation in case: 1504 * - Some layers are HDR and others are SDR 1505 * - HDR layers luminance is not same as sink 1506 * 1507 * It will even need to do colorspace conversion and get all layers 1508 * to one common colorspace for blending. It can use either GL, Media 1509 * or display engine to get this done based on the capabilities of the 1510 * associated hardware. 1511 * 1512 * Driver expects metadata to be put in &struct hdr_output_metadata 1513 * structure from userspace. This is received as blob and stored in 1514 * &drm_connector_state.hdr_output_metadata. It parses EDID and saves the 1515 * sink metadata in &struct hdr_sink_metadata, as 1516 * &drm_connector.hdr_sink_metadata. Driver uses 1517 * drm_hdmi_infoframe_set_hdr_metadata() helper to set the HDR metadata, 1518 * hdmi_drm_infoframe_pack() to pack the infoframe as per spec, in case of 1519 * HDMI encoder. 1520 * 1521 * max bpc: 1522 * This range property is used by userspace to limit the bit depth. When 1523 * used the driver would limit the bpc in accordance with the valid range 1524 * supported by the hardware and sink. Drivers to use the function 1525 * drm_connector_attach_max_bpc_property() to create and attach the 1526 * property to the connector during initialization. 1527 * 1528 * Connectors also have one standardized atomic property: 1529 * 1530 * CRTC_ID: 1531 * Mode object ID of the &drm_crtc this connector should be connected to. 1532 * 1533 * Connectors for LCD panels may also have one standardized property: 1534 * 1535 * panel orientation: 1536 * On some devices the LCD panel is mounted in the casing in such a way 1537 * that the up/top side of the panel does not match with the top side of 1538 * the device. Userspace can use this property to check for this. 1539 * Note that input coordinates from touchscreens (input devices with 1540 * INPUT_PROP_DIRECT) will still map 1:1 to the actual LCD panel 1541 * coordinates, so if userspace rotates the picture to adjust for 1542 * the orientation it must also apply the same transformation to the 1543 * touchscreen input coordinates. This property is initialized by calling 1544 * drm_connector_set_panel_orientation() or 1545 * drm_connector_set_panel_orientation_with_quirk() 1546 * 1547 * scaling mode: 1548 * This property defines how a non-native mode is upscaled to the native 1549 * mode of an LCD panel: 1550 * 1551 * None: 1552 * No upscaling happens, scaling is left to the panel. Not all 1553 * drivers expose this mode. 1554 * Full: 1555 * The output is upscaled to the full resolution of the panel, 1556 * ignoring the aspect ratio. 1557 * Center: 1558 * No upscaling happens, the output is centered within the native 1559 * resolution the panel. 1560 * Full aspect: 1561 * The output is upscaled to maximize either the width or height 1562 * while retaining the aspect ratio. 1563 * 1564 * This property should be set up by calling 1565 * drm_connector_attach_scaling_mode_property(). Note that drivers 1566 * can also expose this property to external outputs, in which case they 1567 * must support "None", which should be the default (since external screens 1568 * have a built-in scaler). 1569 * 1570 * subconnector: 1571 * This property is used by DVI-I, TVout and DisplayPort to indicate different 1572 * connector subtypes. Enum values more or less match with those from main 1573 * connector types. 1574 * For DVI-I and TVout there is also a matching property "select subconnector" 1575 * allowing to switch between signal types. 1576 * DP subconnector corresponds to a downstream port. 1577 * 1578 * privacy-screen sw-state, privacy-screen hw-state: 1579 * These 2 optional properties can be used to query the state of the 1580 * electronic privacy screen that is available on some displays; and in 1581 * some cases also control the state. If a driver implements these 1582 * properties then both properties must be present. 1583 * 1584 * "privacy-screen hw-state" is read-only and reflects the actual state 1585 * of the privacy-screen, possible values: "Enabled", "Disabled, 1586 * "Enabled-locked", "Disabled-locked". The locked states indicate 1587 * that the state cannot be changed through the DRM API. E.g. there 1588 * might be devices where the firmware-setup options, or a hardware 1589 * slider-switch, offer always on / off modes. 1590 * 1591 * "privacy-screen sw-state" can be set to change the privacy-screen state 1592 * when not locked. In this case the driver must update the hw-state 1593 * property to reflect the new state on completion of the commit of the 1594 * sw-state property. Setting the sw-state property when the hw-state is 1595 * locked must be interpreted by the driver as a request to change the 1596 * state to the set state when the hw-state becomes unlocked. E.g. if 1597 * "privacy-screen hw-state" is "Enabled-locked" and the sw-state 1598 * gets set to "Disabled" followed by the user unlocking the state by 1599 * changing the slider-switch position, then the driver must set the 1600 * state to "Disabled" upon receiving the unlock event. 1601 * 1602 * In some cases the privacy-screen's actual state might change outside of 1603 * control of the DRM code. E.g. there might be a firmware handled hotkey 1604 * which toggles the actual state, or the actual state might be changed 1605 * through another userspace API such as writing /proc/acpi/ibm/lcdshadow. 1606 * In this case the driver must update both the hw-state and the sw-state 1607 * to reflect the new value, overwriting any pending state requests in the 1608 * sw-state. Any pending sw-state requests are thus discarded. 1609 * 1610 * Note that the ability for the state to change outside of control of 1611 * the DRM master process means that userspace must not cache the value 1612 * of the sw-state. Caching the sw-state value and including it in later 1613 * atomic commits may lead to overriding a state change done through e.g. 1614 * a firmware handled hotkey. Therefor userspace must not include the 1615 * privacy-screen sw-state in an atomic commit unless it wants to change 1616 * its value. 1617 * 1618 * left margin, right margin, top margin, bottom margin: 1619 * Add margins to the connector's viewport. This is typically used to 1620 * mitigate overscan on TVs. 1621 * 1622 * The value is the size in pixels of the black border which will be 1623 * added. The attached CRTC's content will be scaled to fill the whole 1624 * area inside the margin. 1625 * 1626 * The margins configuration might be sent to the sink, e.g. via HDMI AVI 1627 * InfoFrames. 1628 * 1629 * Drivers can set up these properties by calling 1630 * drm_mode_create_tv_margin_properties(). 1631 */ 1632 1633 int drm_connector_create_standard_properties(struct drm_device *dev) 1634 { 1635 struct drm_property *prop; 1636 1637 prop = drm_property_create(dev, DRM_MODE_PROP_BLOB | 1638 DRM_MODE_PROP_IMMUTABLE, 1639 "EDID", 0); 1640 if (!prop) 1641 return -ENOMEM; 1642 dev->mode_config.edid_property = prop; 1643 1644 prop = drm_property_create_enum(dev, 0, 1645 "DPMS", drm_dpms_enum_list, 1646 ARRAY_SIZE(drm_dpms_enum_list)); 1647 if (!prop) 1648 return -ENOMEM; 1649 dev->mode_config.dpms_property = prop; 1650 1651 prop = drm_property_create(dev, 1652 DRM_MODE_PROP_BLOB | 1653 DRM_MODE_PROP_IMMUTABLE, 1654 "PATH", 0); 1655 if (!prop) 1656 return -ENOMEM; 1657 dev->mode_config.path_property = prop; 1658 1659 prop = drm_property_create(dev, 1660 DRM_MODE_PROP_BLOB | 1661 DRM_MODE_PROP_IMMUTABLE, 1662 "TILE", 0); 1663 if (!prop) 1664 return -ENOMEM; 1665 dev->mode_config.tile_property = prop; 1666 1667 prop = drm_property_create_enum(dev, 0, "link-status", 1668 drm_link_status_enum_list, 1669 ARRAY_SIZE(drm_link_status_enum_list)); 1670 if (!prop) 1671 return -ENOMEM; 1672 dev->mode_config.link_status_property = prop; 1673 1674 prop = drm_property_create_bool(dev, DRM_MODE_PROP_IMMUTABLE, "non-desktop"); 1675 if (!prop) 1676 return -ENOMEM; 1677 dev->mode_config.non_desktop_property = prop; 1678 1679 prop = drm_property_create(dev, DRM_MODE_PROP_BLOB, 1680 "HDR_OUTPUT_METADATA", 0); 1681 if (!prop) 1682 return -ENOMEM; 1683 dev->mode_config.hdr_output_metadata_property = prop; 1684 1685 return 0; 1686 } 1687 1688 /** 1689 * drm_mode_create_dvi_i_properties - create DVI-I specific connector properties 1690 * @dev: DRM device 1691 * 1692 * Called by a driver the first time a DVI-I connector is made. 1693 * 1694 * Returns: %0 1695 */ 1696 int drm_mode_create_dvi_i_properties(struct drm_device *dev) 1697 { 1698 struct drm_property *dvi_i_selector; 1699 struct drm_property *dvi_i_subconnector; 1700 1701 if (dev->mode_config.dvi_i_select_subconnector_property) 1702 return 0; 1703 1704 dvi_i_selector = 1705 drm_property_create_enum(dev, 0, 1706 "select subconnector", 1707 drm_dvi_i_select_enum_list, 1708 ARRAY_SIZE(drm_dvi_i_select_enum_list)); 1709 dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector; 1710 1711 dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 1712 "subconnector", 1713 drm_dvi_i_subconnector_enum_list, 1714 ARRAY_SIZE(drm_dvi_i_subconnector_enum_list)); 1715 dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector; 1716 1717 return 0; 1718 } 1719 EXPORT_SYMBOL(drm_mode_create_dvi_i_properties); 1720 1721 /** 1722 * drm_connector_attach_dp_subconnector_property - create subconnector property for DP 1723 * @connector: drm_connector to attach property 1724 * 1725 * Called by a driver when DP connector is created. 1726 */ 1727 void drm_connector_attach_dp_subconnector_property(struct drm_connector *connector) 1728 { 1729 struct drm_mode_config *mode_config = &connector->dev->mode_config; 1730 1731 if (!mode_config->dp_subconnector_property) 1732 mode_config->dp_subconnector_property = 1733 drm_property_create_enum(connector->dev, 1734 DRM_MODE_PROP_IMMUTABLE, 1735 "subconnector", 1736 drm_dp_subconnector_enum_list, 1737 ARRAY_SIZE(drm_dp_subconnector_enum_list)); 1738 1739 drm_object_attach_property(&connector->base, 1740 mode_config->dp_subconnector_property, 1741 DRM_MODE_SUBCONNECTOR_Unknown); 1742 } 1743 EXPORT_SYMBOL(drm_connector_attach_dp_subconnector_property); 1744 1745 /** 1746 * DOC: HDMI connector properties 1747 * 1748 * Broadcast RGB (HDMI specific) 1749 * Indicates the Quantization Range (Full vs Limited) used. The color 1750 * processing pipeline will be adjusted to match the value of the 1751 * property, and the Infoframes will be generated and sent accordingly. 1752 * 1753 * This property is only relevant if the HDMI output format is RGB. If 1754 * it's one of the YCbCr variant, it will be ignored. 1755 * 1756 * The CRTC attached to the connector must be configured by user-space to 1757 * always produce full-range pixels. 1758 * 1759 * The value of this property can be one of the following: 1760 * 1761 * Automatic: 1762 * The quantization range is selected automatically based on the 1763 * mode according to the HDMI specifications (HDMI 1.4b - Section 1764 * 6.6 - Video Quantization Ranges). 1765 * 1766 * Full: 1767 * Full quantization range is forced. 1768 * 1769 * Limited 16:235: 1770 * Limited quantization range is forced. Unlike the name suggests, 1771 * this works for any number of bits-per-component. 1772 * 1773 * Property values other than Automatic can result in colors being off (if 1774 * limited is selected but the display expects full), or a black screen 1775 * (if full is selected but the display expects limited). 1776 * 1777 * Drivers can set up this property by calling 1778 * drm_connector_attach_broadcast_rgb_property(). 1779 * 1780 * content type (HDMI specific): 1781 * Indicates content type setting to be used in HDMI infoframes to indicate 1782 * content type for the external device, so that it adjusts its display 1783 * settings accordingly. 1784 * 1785 * The value of this property can be one of the following: 1786 * 1787 * No Data: 1788 * Content type is unknown 1789 * Graphics: 1790 * Content type is graphics 1791 * Photo: 1792 * Content type is photo 1793 * Cinema: 1794 * Content type is cinema 1795 * Game: 1796 * Content type is game 1797 * 1798 * The meaning of each content type is defined in CTA-861-G table 15. 1799 * 1800 * Drivers can set up this property by calling 1801 * drm_connector_attach_content_type_property(). Decoding to 1802 * infoframe values is done through drm_hdmi_avi_infoframe_content_type(). 1803 */ 1804 1805 /* 1806 * TODO: Document the properties: 1807 * - brightness 1808 * - contrast 1809 * - flicker reduction 1810 * - hue 1811 * - mode 1812 * - overscan 1813 * - saturation 1814 * - select subconnector 1815 */ 1816 /** 1817 * DOC: Analog TV Connector Properties 1818 * 1819 * TV Mode: 1820 * Indicates the TV Mode used on an analog TV connector. The value 1821 * of this property can be one of the following: 1822 * 1823 * NTSC: 1824 * TV Mode is CCIR System M (aka 525-lines) together with 1825 * the NTSC Color Encoding. 1826 * 1827 * NTSC-443: 1828 * 1829 * TV Mode is CCIR System M (aka 525-lines) together with 1830 * the NTSC Color Encoding, but with a color subcarrier 1831 * frequency of 4.43MHz 1832 * 1833 * NTSC-J: 1834 * 1835 * TV Mode is CCIR System M (aka 525-lines) together with 1836 * the NTSC Color Encoding, but with a black level equal to 1837 * the blanking level. 1838 * 1839 * PAL: 1840 * 1841 * TV Mode is CCIR System B (aka 625-lines) together with 1842 * the PAL Color Encoding. 1843 * 1844 * PAL-M: 1845 * 1846 * TV Mode is CCIR System M (aka 525-lines) together with 1847 * the PAL Color Encoding. 1848 * 1849 * PAL-N: 1850 * 1851 * TV Mode is CCIR System N together with the PAL Color 1852 * Encoding, a color subcarrier frequency of 3.58MHz, the 1853 * SECAM color space, and narrower channels than other PAL 1854 * variants. 1855 * 1856 * SECAM: 1857 * 1858 * TV Mode is CCIR System B (aka 625-lines) together with 1859 * the SECAM Color Encoding. 1860 * 1861 * Drivers can set up this property by calling 1862 * drm_mode_create_tv_properties(). 1863 */ 1864 1865 /** 1866 * drm_connector_attach_content_type_property - attach content-type property 1867 * @connector: connector to attach content type property on. 1868 * 1869 * Called by a driver the first time a HDMI connector is made. 1870 * 1871 * Returns: %0 1872 */ 1873 int drm_connector_attach_content_type_property(struct drm_connector *connector) 1874 { 1875 if (!drm_mode_create_content_type_property(connector->dev)) 1876 drm_object_attach_property(&connector->base, 1877 connector->dev->mode_config.content_type_property, 1878 DRM_MODE_CONTENT_TYPE_NO_DATA); 1879 return 0; 1880 } 1881 EXPORT_SYMBOL(drm_connector_attach_content_type_property); 1882 1883 /** 1884 * drm_connector_attach_tv_margin_properties - attach TV connector margin 1885 * properties 1886 * @connector: DRM connector 1887 * 1888 * Called by a driver when it needs to attach TV margin props to a connector. 1889 * Typically used on SDTV and HDMI connectors. 1890 */ 1891 void drm_connector_attach_tv_margin_properties(struct drm_connector *connector) 1892 { 1893 struct drm_device *dev = connector->dev; 1894 1895 drm_object_attach_property(&connector->base, 1896 dev->mode_config.tv_left_margin_property, 1897 0); 1898 drm_object_attach_property(&connector->base, 1899 dev->mode_config.tv_right_margin_property, 1900 0); 1901 drm_object_attach_property(&connector->base, 1902 dev->mode_config.tv_top_margin_property, 1903 0); 1904 drm_object_attach_property(&connector->base, 1905 dev->mode_config.tv_bottom_margin_property, 1906 0); 1907 } 1908 EXPORT_SYMBOL(drm_connector_attach_tv_margin_properties); 1909 1910 /** 1911 * drm_mode_create_tv_margin_properties - create TV connector margin properties 1912 * @dev: DRM device 1913 * 1914 * Called by a driver's HDMI connector initialization routine, this function 1915 * creates the TV margin properties for a given device. No need to call this 1916 * function for an SDTV connector, it's already called from 1917 * drm_mode_create_tv_properties_legacy(). 1918 * 1919 * Returns: 1920 * 0 on success or a negative error code on failure. 1921 */ 1922 int drm_mode_create_tv_margin_properties(struct drm_device *dev) 1923 { 1924 if (dev->mode_config.tv_left_margin_property) 1925 return 0; 1926 1927 dev->mode_config.tv_left_margin_property = 1928 drm_property_create_range(dev, 0, "left margin", 0, 100); 1929 if (!dev->mode_config.tv_left_margin_property) 1930 return -ENOMEM; 1931 1932 dev->mode_config.tv_right_margin_property = 1933 drm_property_create_range(dev, 0, "right margin", 0, 100); 1934 if (!dev->mode_config.tv_right_margin_property) 1935 return -ENOMEM; 1936 1937 dev->mode_config.tv_top_margin_property = 1938 drm_property_create_range(dev, 0, "top margin", 0, 100); 1939 if (!dev->mode_config.tv_top_margin_property) 1940 return -ENOMEM; 1941 1942 dev->mode_config.tv_bottom_margin_property = 1943 drm_property_create_range(dev, 0, "bottom margin", 0, 100); 1944 if (!dev->mode_config.tv_bottom_margin_property) 1945 return -ENOMEM; 1946 1947 return 0; 1948 } 1949 EXPORT_SYMBOL(drm_mode_create_tv_margin_properties); 1950 1951 /** 1952 * drm_mode_create_tv_properties_legacy - create TV specific connector properties 1953 * @dev: DRM device 1954 * @num_modes: number of different TV formats (modes) supported 1955 * @modes: array of pointers to strings containing name of each format 1956 * 1957 * Called by a driver's TV initialization routine, this function creates 1958 * the TV specific connector properties for a given device. Caller is 1959 * responsible for allocating a list of format names and passing them to 1960 * this routine. 1961 * 1962 * NOTE: This functions registers the deprecated "mode" connector 1963 * property to select the analog TV mode (ie, NTSC, PAL, etc.). New 1964 * drivers must use drm_mode_create_tv_properties() instead. 1965 * 1966 * Returns: 1967 * 0 on success or a negative error code on failure. 1968 */ 1969 int drm_mode_create_tv_properties_legacy(struct drm_device *dev, 1970 unsigned int num_modes, 1971 const char * const modes[]) 1972 { 1973 struct drm_property *tv_selector; 1974 struct drm_property *tv_subconnector; 1975 unsigned int i; 1976 1977 if (dev->mode_config.tv_select_subconnector_property) 1978 return 0; 1979 1980 /* 1981 * Basic connector properties 1982 */ 1983 tv_selector = drm_property_create_enum(dev, 0, 1984 "select subconnector", 1985 drm_tv_select_enum_list, 1986 ARRAY_SIZE(drm_tv_select_enum_list)); 1987 if (!tv_selector) 1988 goto nomem; 1989 1990 dev->mode_config.tv_select_subconnector_property = tv_selector; 1991 1992 tv_subconnector = 1993 drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 1994 "subconnector", 1995 drm_tv_subconnector_enum_list, 1996 ARRAY_SIZE(drm_tv_subconnector_enum_list)); 1997 if (!tv_subconnector) 1998 goto nomem; 1999 dev->mode_config.tv_subconnector_property = tv_subconnector; 2000 2001 /* 2002 * Other, TV specific properties: margins & TV modes. 2003 */ 2004 if (drm_mode_create_tv_margin_properties(dev)) 2005 goto nomem; 2006 2007 if (num_modes) { 2008 dev->mode_config.legacy_tv_mode_property = 2009 drm_property_create(dev, DRM_MODE_PROP_ENUM, 2010 "mode", num_modes); 2011 if (!dev->mode_config.legacy_tv_mode_property) 2012 goto nomem; 2013 2014 for (i = 0; i < num_modes; i++) 2015 drm_property_add_enum(dev->mode_config.legacy_tv_mode_property, 2016 i, modes[i]); 2017 } 2018 2019 dev->mode_config.tv_brightness_property = 2020 drm_property_create_range(dev, 0, "brightness", 0, 100); 2021 if (!dev->mode_config.tv_brightness_property) 2022 goto nomem; 2023 2024 dev->mode_config.tv_contrast_property = 2025 drm_property_create_range(dev, 0, "contrast", 0, 100); 2026 if (!dev->mode_config.tv_contrast_property) 2027 goto nomem; 2028 2029 dev->mode_config.tv_flicker_reduction_property = 2030 drm_property_create_range(dev, 0, "flicker reduction", 0, 100); 2031 if (!dev->mode_config.tv_flicker_reduction_property) 2032 goto nomem; 2033 2034 dev->mode_config.tv_overscan_property = 2035 drm_property_create_range(dev, 0, "overscan", 0, 100); 2036 if (!dev->mode_config.tv_overscan_property) 2037 goto nomem; 2038 2039 dev->mode_config.tv_saturation_property = 2040 drm_property_create_range(dev, 0, "saturation", 0, 100); 2041 if (!dev->mode_config.tv_saturation_property) 2042 goto nomem; 2043 2044 dev->mode_config.tv_hue_property = 2045 drm_property_create_range(dev, 0, "hue", 0, 100); 2046 if (!dev->mode_config.tv_hue_property) 2047 goto nomem; 2048 2049 return 0; 2050 nomem: 2051 return -ENOMEM; 2052 } 2053 EXPORT_SYMBOL(drm_mode_create_tv_properties_legacy); 2054 2055 /** 2056 * drm_mode_create_tv_properties - create TV specific connector properties 2057 * @dev: DRM device 2058 * @supported_tv_modes: Bitmask of TV modes supported (See DRM_MODE_TV_MODE_*) 2059 * 2060 * Called by a driver's TV initialization routine, this function creates 2061 * the TV specific connector properties for a given device. 2062 * 2063 * Returns: 2064 * 0 on success or a negative error code on failure. 2065 */ 2066 int drm_mode_create_tv_properties(struct drm_device *dev, 2067 unsigned int supported_tv_modes) 2068 { 2069 struct drm_prop_enum_list tv_mode_list[DRM_MODE_TV_MODE_MAX]; 2070 struct drm_property *tv_mode; 2071 unsigned int i, len = 0; 2072 2073 if (dev->mode_config.tv_mode_property) 2074 return 0; 2075 2076 for (i = 0; i < DRM_MODE_TV_MODE_MAX; i++) { 2077 if (!(supported_tv_modes & BIT(i))) 2078 continue; 2079 2080 tv_mode_list[len].type = i; 2081 tv_mode_list[len].name = drm_get_tv_mode_name(i); 2082 len++; 2083 } 2084 2085 tv_mode = drm_property_create_enum(dev, 0, "TV mode", 2086 tv_mode_list, len); 2087 if (!tv_mode) 2088 return -ENOMEM; 2089 2090 dev->mode_config.tv_mode_property = tv_mode; 2091 2092 return drm_mode_create_tv_properties_legacy(dev, 0, NULL); 2093 } 2094 EXPORT_SYMBOL(drm_mode_create_tv_properties); 2095 2096 /** 2097 * drm_mode_create_scaling_mode_property - create scaling mode property 2098 * @dev: DRM device 2099 * 2100 * Called by a driver the first time it's needed, must be attached to desired 2101 * connectors. 2102 * 2103 * Atomic drivers should use drm_connector_attach_scaling_mode_property() 2104 * instead to correctly assign &drm_connector_state.scaling_mode 2105 * in the atomic state. 2106 * 2107 * Returns: %0 2108 */ 2109 int drm_mode_create_scaling_mode_property(struct drm_device *dev) 2110 { 2111 struct drm_property *scaling_mode; 2112 2113 if (dev->mode_config.scaling_mode_property) 2114 return 0; 2115 2116 scaling_mode = 2117 drm_property_create_enum(dev, 0, "scaling mode", 2118 drm_scaling_mode_enum_list, 2119 ARRAY_SIZE(drm_scaling_mode_enum_list)); 2120 2121 dev->mode_config.scaling_mode_property = scaling_mode; 2122 2123 return 0; 2124 } 2125 EXPORT_SYMBOL(drm_mode_create_scaling_mode_property); 2126 2127 /** 2128 * DOC: Variable refresh properties 2129 * 2130 * Variable refresh rate capable displays can dynamically adjust their 2131 * refresh rate by extending the duration of their vertical front porch 2132 * until page flip or timeout occurs. This can reduce or remove stuttering 2133 * and latency in scenarios where the page flip does not align with the 2134 * vblank interval. 2135 * 2136 * An example scenario would be an application flipping at a constant rate 2137 * of 48Hz on a 60Hz display. The page flip will frequently miss the vblank 2138 * interval and the same contents will be displayed twice. This can be 2139 * observed as stuttering for content with motion. 2140 * 2141 * If variable refresh rate was active on a display that supported a 2142 * variable refresh range from 35Hz to 60Hz no stuttering would be observable 2143 * for the example scenario. The minimum supported variable refresh rate of 2144 * 35Hz is below the page flip frequency and the vertical front porch can 2145 * be extended until the page flip occurs. The vblank interval will be 2146 * directly aligned to the page flip rate. 2147 * 2148 * Not all userspace content is suitable for use with variable refresh rate. 2149 * Large and frequent changes in vertical front porch duration may worsen 2150 * perceived stuttering for input sensitive applications. 2151 * 2152 * Panel brightness will also vary with vertical front porch duration. Some 2153 * panels may have noticeable differences in brightness between the minimum 2154 * vertical front porch duration and the maximum vertical front porch duration. 2155 * Large and frequent changes in vertical front porch duration may produce 2156 * observable flickering for such panels. 2157 * 2158 * Userspace control for variable refresh rate is supported via properties 2159 * on the &drm_connector and &drm_crtc objects. 2160 * 2161 * "vrr_capable": 2162 * Optional &drm_connector boolean property that drivers should attach 2163 * with drm_connector_attach_vrr_capable_property() on connectors that 2164 * could support variable refresh rates. Drivers should update the 2165 * property value by calling drm_connector_set_vrr_capable_property(). 2166 * 2167 * Absence of the property should indicate absence of support. 2168 * 2169 * "VRR_ENABLED": 2170 * Default &drm_crtc boolean property that notifies the driver that the 2171 * content on the CRTC is suitable for variable refresh rate presentation. 2172 * The driver will take this property as a hint to enable variable 2173 * refresh rate support if the receiver supports it, ie. if the 2174 * "vrr_capable" property is true on the &drm_connector object. The 2175 * vertical front porch duration will be extended until page-flip or 2176 * timeout when enabled. 2177 * 2178 * The minimum vertical front porch duration is defined as the vertical 2179 * front porch duration for the current mode. 2180 * 2181 * The maximum vertical front porch duration is greater than or equal to 2182 * the minimum vertical front porch duration. The duration is derived 2183 * from the minimum supported variable refresh rate for the connector. 2184 * 2185 * The driver may place further restrictions within these minimum 2186 * and maximum bounds. 2187 */ 2188 2189 /** 2190 * drm_connector_attach_vrr_capable_property - creates the 2191 * vrr_capable property 2192 * @connector: connector to create the vrr_capable property on. 2193 * 2194 * This is used by atomic drivers to add support for querying 2195 * variable refresh rate capability for a connector. 2196 * 2197 * Returns: 2198 * Zero on success, negative errno on failure. 2199 */ 2200 int drm_connector_attach_vrr_capable_property( 2201 struct drm_connector *connector) 2202 { 2203 struct drm_device *dev = connector->dev; 2204 struct drm_property *prop; 2205 2206 if (!connector->vrr_capable_property) { 2207 prop = drm_property_create_bool(dev, DRM_MODE_PROP_IMMUTABLE, 2208 "vrr_capable"); 2209 if (!prop) 2210 return -ENOMEM; 2211 2212 connector->vrr_capable_property = prop; 2213 drm_object_attach_property(&connector->base, prop, 0); 2214 } 2215 2216 return 0; 2217 } 2218 EXPORT_SYMBOL(drm_connector_attach_vrr_capable_property); 2219 2220 /** 2221 * drm_connector_attach_scaling_mode_property - attach atomic scaling mode property 2222 * @connector: connector to attach scaling mode property on. 2223 * @scaling_mode_mask: or'ed mask of BIT(%DRM_MODE_SCALE_\*). 2224 * 2225 * This is used to add support for scaling mode to atomic drivers. 2226 * The scaling mode will be set to &drm_connector_state.scaling_mode 2227 * and can be used from &drm_connector_helper_funcs->atomic_check for validation. 2228 * 2229 * This is the atomic version of drm_mode_create_scaling_mode_property(). 2230 * 2231 * Returns: 2232 * Zero on success, negative errno on failure. 2233 */ 2234 int drm_connector_attach_scaling_mode_property(struct drm_connector *connector, 2235 u32 scaling_mode_mask) 2236 { 2237 struct drm_device *dev = connector->dev; 2238 struct drm_property *scaling_mode_property; 2239 int i; 2240 const unsigned valid_scaling_mode_mask = 2241 (1U << ARRAY_SIZE(drm_scaling_mode_enum_list)) - 1; 2242 2243 if (WARN_ON(hweight32(scaling_mode_mask) < 2 || 2244 scaling_mode_mask & ~valid_scaling_mode_mask)) 2245 return -EINVAL; 2246 2247 scaling_mode_property = 2248 drm_property_create(dev, DRM_MODE_PROP_ENUM, "scaling mode", 2249 hweight32(scaling_mode_mask)); 2250 2251 if (!scaling_mode_property) 2252 return -ENOMEM; 2253 2254 for (i = 0; i < ARRAY_SIZE(drm_scaling_mode_enum_list); i++) { 2255 int ret; 2256 2257 if (!(BIT(i) & scaling_mode_mask)) 2258 continue; 2259 2260 ret = drm_property_add_enum(scaling_mode_property, 2261 drm_scaling_mode_enum_list[i].type, 2262 drm_scaling_mode_enum_list[i].name); 2263 2264 if (ret) { 2265 drm_property_destroy(dev, scaling_mode_property); 2266 2267 return ret; 2268 } 2269 } 2270 2271 drm_object_attach_property(&connector->base, 2272 scaling_mode_property, 0); 2273 2274 connector->scaling_mode_property = scaling_mode_property; 2275 2276 return 0; 2277 } 2278 EXPORT_SYMBOL(drm_connector_attach_scaling_mode_property); 2279 2280 /** 2281 * drm_mode_create_aspect_ratio_property - create aspect ratio property 2282 * @dev: DRM device 2283 * 2284 * Called by a driver the first time it's needed, must be attached to desired 2285 * connectors. 2286 * 2287 * Returns: 2288 * Zero on success, negative errno on failure. 2289 */ 2290 int drm_mode_create_aspect_ratio_property(struct drm_device *dev) 2291 { 2292 if (dev->mode_config.aspect_ratio_property) 2293 return 0; 2294 2295 dev->mode_config.aspect_ratio_property = 2296 drm_property_create_enum(dev, 0, "aspect ratio", 2297 drm_aspect_ratio_enum_list, 2298 ARRAY_SIZE(drm_aspect_ratio_enum_list)); 2299 2300 if (dev->mode_config.aspect_ratio_property == NULL) 2301 return -ENOMEM; 2302 2303 return 0; 2304 } 2305 EXPORT_SYMBOL(drm_mode_create_aspect_ratio_property); 2306 2307 /** 2308 * DOC: standard connector properties 2309 * 2310 * Colorspace: 2311 * This property helps select a suitable colorspace based on the sink 2312 * capability. Modern sink devices support wider gamut like BT2020. 2313 * This helps switch to BT2020 mode if the BT2020 encoded video stream 2314 * is being played by the user, same for any other colorspace. Thereby 2315 * giving a good visual experience to users. 2316 * 2317 * The expectation from userspace is that it should parse the EDID 2318 * and get supported colorspaces. Use this property and switch to the 2319 * one supported. Sink supported colorspaces should be retrieved by 2320 * userspace from EDID and driver will not explicitly expose them. 2321 * 2322 * Basically the expectation from userspace is: 2323 * - Set up CRTC DEGAMMA/CTM/GAMMA to convert to some sink 2324 * colorspace 2325 * - Set this new property to let the sink know what it 2326 * converted the CRTC output to. 2327 * - This property is just to inform sink what colorspace 2328 * source is trying to drive. 2329 * 2330 * Because between HDMI and DP have different colorspaces, 2331 * drm_mode_create_hdmi_colorspace_property() is used for HDMI connector and 2332 * drm_mode_create_dp_colorspace_property() is used for DP connector. 2333 */ 2334 2335 static int drm_mode_create_colorspace_property(struct drm_connector *connector, 2336 u32 supported_colorspaces) 2337 { 2338 struct drm_device *dev = connector->dev; 2339 u32 colorspaces = supported_colorspaces | BIT(DRM_MODE_COLORIMETRY_DEFAULT); 2340 struct drm_prop_enum_list enum_list[DRM_MODE_COLORIMETRY_COUNT]; 2341 int i, len; 2342 2343 if (connector->colorspace_property) 2344 return 0; 2345 2346 if (!supported_colorspaces) { 2347 drm_err(dev, "No supported colorspaces provded on [CONNECTOR:%d:%s]\n", 2348 connector->base.id, connector->name); 2349 return -EINVAL; 2350 } 2351 2352 if ((supported_colorspaces & -BIT(DRM_MODE_COLORIMETRY_COUNT)) != 0) { 2353 drm_err(dev, "Unknown colorspace provded on [CONNECTOR:%d:%s]\n", 2354 connector->base.id, connector->name); 2355 return -EINVAL; 2356 } 2357 2358 len = 0; 2359 for (i = 0; i < DRM_MODE_COLORIMETRY_COUNT; i++) { 2360 if ((colorspaces & BIT(i)) == 0) 2361 continue; 2362 2363 enum_list[len].type = i; 2364 enum_list[len].name = colorspace_names[i]; 2365 len++; 2366 } 2367 2368 connector->colorspace_property = 2369 drm_property_create_enum(dev, DRM_MODE_PROP_ENUM, "Colorspace", 2370 enum_list, 2371 len); 2372 2373 if (!connector->colorspace_property) 2374 return -ENOMEM; 2375 2376 return 0; 2377 } 2378 2379 /** 2380 * drm_mode_create_hdmi_colorspace_property - create hdmi colorspace property 2381 * @connector: connector to create the Colorspace property on. 2382 * @supported_colorspaces: bitmap of supported color spaces 2383 * 2384 * Called by a driver the first time it's needed, must be attached to desired 2385 * HDMI connectors. 2386 * 2387 * Returns: 2388 * Zero on success, negative errno on failure. 2389 */ 2390 int drm_mode_create_hdmi_colorspace_property(struct drm_connector *connector, 2391 u32 supported_colorspaces) 2392 { 2393 u32 colorspaces; 2394 2395 if (supported_colorspaces) 2396 colorspaces = supported_colorspaces & hdmi_colorspaces; 2397 else 2398 colorspaces = hdmi_colorspaces; 2399 2400 return drm_mode_create_colorspace_property(connector, colorspaces); 2401 } 2402 EXPORT_SYMBOL(drm_mode_create_hdmi_colorspace_property); 2403 2404 /** 2405 * drm_mode_create_dp_colorspace_property - create dp colorspace property 2406 * @connector: connector to create the Colorspace property on. 2407 * @supported_colorspaces: bitmap of supported color spaces 2408 * 2409 * Called by a driver the first time it's needed, must be attached to desired 2410 * DP connectors. 2411 * 2412 * Returns: 2413 * Zero on success, negative errno on failure. 2414 */ 2415 int drm_mode_create_dp_colorspace_property(struct drm_connector *connector, 2416 u32 supported_colorspaces) 2417 { 2418 u32 colorspaces; 2419 2420 if (supported_colorspaces) 2421 colorspaces = supported_colorspaces & dp_colorspaces; 2422 else 2423 colorspaces = dp_colorspaces; 2424 2425 return drm_mode_create_colorspace_property(connector, colorspaces); 2426 } 2427 EXPORT_SYMBOL(drm_mode_create_dp_colorspace_property); 2428 2429 /** 2430 * drm_mode_create_content_type_property - create content type property 2431 * @dev: DRM device 2432 * 2433 * Called by a driver the first time it's needed, must be attached to desired 2434 * connectors. 2435 * 2436 * Returns: 2437 * Zero on success, negative errno on failure. 2438 */ 2439 int drm_mode_create_content_type_property(struct drm_device *dev) 2440 { 2441 if (dev->mode_config.content_type_property) 2442 return 0; 2443 2444 dev->mode_config.content_type_property = 2445 drm_property_create_enum(dev, 0, "content type", 2446 drm_content_type_enum_list, 2447 ARRAY_SIZE(drm_content_type_enum_list)); 2448 2449 if (dev->mode_config.content_type_property == NULL) 2450 return -ENOMEM; 2451 2452 return 0; 2453 } 2454 EXPORT_SYMBOL(drm_mode_create_content_type_property); 2455 2456 /** 2457 * drm_mode_create_suggested_offset_properties - create suggests offset properties 2458 * @dev: DRM device 2459 * 2460 * Create the suggested x/y offset property for connectors. 2461 * 2462 * Returns: 2463 * 0 on success or a negative error code on failure. 2464 */ 2465 int drm_mode_create_suggested_offset_properties(struct drm_device *dev) 2466 { 2467 if (dev->mode_config.suggested_x_property && dev->mode_config.suggested_y_property) 2468 return 0; 2469 2470 dev->mode_config.suggested_x_property = 2471 drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested X", 0, 0xffffffff); 2472 2473 dev->mode_config.suggested_y_property = 2474 drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested Y", 0, 0xffffffff); 2475 2476 if (dev->mode_config.suggested_x_property == NULL || 2477 dev->mode_config.suggested_y_property == NULL) 2478 return -ENOMEM; 2479 return 0; 2480 } 2481 EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties); 2482 2483 /** 2484 * drm_connector_set_path_property - set tile property on connector 2485 * @connector: connector to set property on. 2486 * @path: path to use for property; must not be NULL. 2487 * 2488 * This creates a property to expose to userspace to specify a 2489 * connector path. This is mainly used for DisplayPort MST where 2490 * connectors have a topology and we want to allow userspace to give 2491 * them more meaningful names. 2492 * 2493 * Returns: 2494 * Zero on success, negative errno on failure. 2495 */ 2496 int drm_connector_set_path_property(struct drm_connector *connector, 2497 const char *path) 2498 { 2499 struct drm_device *dev = connector->dev; 2500 int ret; 2501 2502 ret = drm_property_replace_global_blob(dev, 2503 &connector->path_blob_ptr, 2504 strlen(path) + 1, 2505 path, 2506 &connector->base, 2507 dev->mode_config.path_property); 2508 return ret; 2509 } 2510 EXPORT_SYMBOL(drm_connector_set_path_property); 2511 2512 /** 2513 * drm_connector_set_tile_property - set tile property on connector 2514 * @connector: connector to set property on. 2515 * 2516 * This looks up the tile information for a connector, and creates a 2517 * property for userspace to parse if it exists. The property is of 2518 * the form of 8 integers using ':' as a separator. 2519 * This is used for dual port tiled displays with DisplayPort SST 2520 * or DisplayPort MST connectors. 2521 * 2522 * Returns: 2523 * Zero on success, errno on failure. 2524 */ 2525 int drm_connector_set_tile_property(struct drm_connector *connector) 2526 { 2527 struct drm_device *dev = connector->dev; 2528 char tile[256]; 2529 int ret; 2530 2531 if (!connector->has_tile) { 2532 ret = drm_property_replace_global_blob(dev, 2533 &connector->tile_blob_ptr, 2534 0, 2535 NULL, 2536 &connector->base, 2537 dev->mode_config.tile_property); 2538 return ret; 2539 } 2540 2541 snprintf(tile, 256, "%d:%d:%d:%d:%d:%d:%d:%d", 2542 connector->tile_group->id, connector->tile_is_single_monitor, 2543 connector->num_h_tile, connector->num_v_tile, 2544 connector->tile_h_loc, connector->tile_v_loc, 2545 connector->tile_h_size, connector->tile_v_size); 2546 2547 ret = drm_property_replace_global_blob(dev, 2548 &connector->tile_blob_ptr, 2549 strlen(tile) + 1, 2550 tile, 2551 &connector->base, 2552 dev->mode_config.tile_property); 2553 return ret; 2554 } 2555 EXPORT_SYMBOL(drm_connector_set_tile_property); 2556 2557 /** 2558 * drm_connector_set_link_status_property - Set link status property of a connector 2559 * @connector: drm connector 2560 * @link_status: new value of link status property (0: Good, 1: Bad) 2561 * 2562 * In usual working scenario, this link status property will always be set to 2563 * "GOOD". If something fails during or after a mode set, the kernel driver 2564 * may set this link status property to "BAD". The caller then needs to send a 2565 * hotplug uevent for userspace to re-check the valid modes through 2566 * GET_CONNECTOR_IOCTL and retry modeset. 2567 * 2568 * Note: Drivers cannot rely on userspace to support this property and 2569 * issue a modeset. As such, they may choose to handle issues (like 2570 * re-training a link) without userspace's intervention. 2571 * 2572 * The reason for adding this property is to handle link training failures, but 2573 * it is not limited to DP or link training. For example, if we implement 2574 * asynchronous setcrtc, this property can be used to report any failures in that. 2575 */ 2576 void drm_connector_set_link_status_property(struct drm_connector *connector, 2577 uint64_t link_status) 2578 { 2579 struct drm_device *dev = connector->dev; 2580 2581 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 2582 connector->state->link_status = link_status; 2583 drm_modeset_unlock(&dev->mode_config.connection_mutex); 2584 } 2585 EXPORT_SYMBOL(drm_connector_set_link_status_property); 2586 2587 /** 2588 * drm_connector_attach_max_bpc_property - attach "max bpc" property 2589 * @connector: connector to attach max bpc property on. 2590 * @min: The minimum bit depth supported by the connector. 2591 * @max: The maximum bit depth supported by the connector. 2592 * 2593 * This is used to add support for limiting the bit depth on a connector. 2594 * 2595 * Returns: 2596 * Zero on success, negative errno on failure. 2597 */ 2598 int drm_connector_attach_max_bpc_property(struct drm_connector *connector, 2599 int min, int max) 2600 { 2601 struct drm_device *dev = connector->dev; 2602 struct drm_property *prop; 2603 2604 prop = connector->max_bpc_property; 2605 if (!prop) { 2606 prop = drm_property_create_range(dev, 0, "max bpc", min, max); 2607 if (!prop) 2608 return -ENOMEM; 2609 2610 connector->max_bpc_property = prop; 2611 } 2612 2613 drm_object_attach_property(&connector->base, prop, max); 2614 connector->state->max_requested_bpc = max; 2615 connector->state->max_bpc = max; 2616 2617 return 0; 2618 } 2619 EXPORT_SYMBOL(drm_connector_attach_max_bpc_property); 2620 2621 /** 2622 * drm_connector_attach_hdr_output_metadata_property - attach "HDR_OUTPUT_METADA" property 2623 * @connector: connector to attach the property on. 2624 * 2625 * This is used to allow the userspace to send HDR Metadata to the 2626 * driver. 2627 * 2628 * Returns: 2629 * Zero on success, negative errno on failure. 2630 */ 2631 int drm_connector_attach_hdr_output_metadata_property(struct drm_connector *connector) 2632 { 2633 struct drm_device *dev = connector->dev; 2634 struct drm_property *prop = dev->mode_config.hdr_output_metadata_property; 2635 2636 drm_object_attach_property(&connector->base, prop, 0); 2637 2638 return 0; 2639 } 2640 EXPORT_SYMBOL(drm_connector_attach_hdr_output_metadata_property); 2641 2642 /** 2643 * drm_connector_attach_broadcast_rgb_property - attach "Broadcast RGB" property 2644 * @connector: connector to attach the property on. 2645 * 2646 * This is used to add support for forcing the RGB range on a connector 2647 * 2648 * Returns: 2649 * Zero on success, negative errno on failure. 2650 */ 2651 int drm_connector_attach_broadcast_rgb_property(struct drm_connector *connector) 2652 { 2653 struct drm_device *dev = connector->dev; 2654 struct drm_property *prop; 2655 2656 prop = connector->broadcast_rgb_property; 2657 if (!prop) { 2658 prop = drm_property_create_enum(dev, DRM_MODE_PROP_ENUM, 2659 "Broadcast RGB", 2660 broadcast_rgb_names, 2661 ARRAY_SIZE(broadcast_rgb_names)); 2662 if (!prop) 2663 return -EINVAL; 2664 2665 connector->broadcast_rgb_property = prop; 2666 } 2667 2668 drm_object_attach_property(&connector->base, prop, 2669 DRM_HDMI_BROADCAST_RGB_AUTO); 2670 2671 return 0; 2672 } 2673 EXPORT_SYMBOL(drm_connector_attach_broadcast_rgb_property); 2674 2675 /** 2676 * drm_connector_attach_colorspace_property - attach "Colorspace" property 2677 * @connector: connector to attach the property on. 2678 * 2679 * This is used to allow the userspace to signal the output colorspace 2680 * to the driver. 2681 * 2682 * Returns: 2683 * Zero on success, negative errno on failure. 2684 */ 2685 int drm_connector_attach_colorspace_property(struct drm_connector *connector) 2686 { 2687 struct drm_property *prop = connector->colorspace_property; 2688 2689 drm_object_attach_property(&connector->base, prop, DRM_MODE_COLORIMETRY_DEFAULT); 2690 2691 return 0; 2692 } 2693 EXPORT_SYMBOL(drm_connector_attach_colorspace_property); 2694 2695 /** 2696 * drm_connector_atomic_hdr_metadata_equal - checks if the hdr metadata changed 2697 * @old_state: old connector state to compare 2698 * @new_state: new connector state to compare 2699 * 2700 * This is used by HDR-enabled drivers to test whether the HDR metadata 2701 * have changed between two different connector state (and thus probably 2702 * requires a full blown mode change). 2703 * 2704 * Returns: 2705 * True if the metadata are equal, False otherwise 2706 */ 2707 bool drm_connector_atomic_hdr_metadata_equal(struct drm_connector_state *old_state, 2708 struct drm_connector_state *new_state) 2709 { 2710 struct drm_property_blob *old_blob = old_state->hdr_output_metadata; 2711 struct drm_property_blob *new_blob = new_state->hdr_output_metadata; 2712 2713 if (!old_blob || !new_blob) 2714 return old_blob == new_blob; 2715 2716 if (old_blob->length != new_blob->length) 2717 return false; 2718 2719 return !memcmp(old_blob->data, new_blob->data, old_blob->length); 2720 } 2721 EXPORT_SYMBOL(drm_connector_atomic_hdr_metadata_equal); 2722 2723 /** 2724 * drm_connector_set_vrr_capable_property - sets the variable refresh rate 2725 * capable property for a connector 2726 * @connector: drm connector 2727 * @capable: True if the connector is variable refresh rate capable 2728 * 2729 * Should be used by atomic drivers to update the indicated support for 2730 * variable refresh rate over a connector. 2731 */ 2732 void drm_connector_set_vrr_capable_property( 2733 struct drm_connector *connector, bool capable) 2734 { 2735 if (!connector->vrr_capable_property) 2736 return; 2737 2738 drm_object_property_set_value(&connector->base, 2739 connector->vrr_capable_property, 2740 capable); 2741 } 2742 EXPORT_SYMBOL(drm_connector_set_vrr_capable_property); 2743 2744 /** 2745 * drm_connector_set_panel_orientation - sets the connector's panel_orientation 2746 * @connector: connector for which to set the panel-orientation property. 2747 * @panel_orientation: drm_panel_orientation value to set 2748 * 2749 * This function sets the connector's panel_orientation and attaches 2750 * a "panel orientation" property to the connector. 2751 * 2752 * Calling this function on a connector where the panel_orientation has 2753 * already been set is a no-op (e.g. the orientation has been overridden with 2754 * a kernel commandline option). 2755 * 2756 * It is allowed to call this function with a panel_orientation of 2757 * DRM_MODE_PANEL_ORIENTATION_UNKNOWN, in which case it is a no-op. 2758 * 2759 * The function shouldn't be called in panel after drm is registered (i.e. 2760 * drm_dev_register() is called in drm). 2761 * 2762 * Returns: 2763 * Zero on success, negative errno on failure. 2764 */ 2765 int drm_connector_set_panel_orientation( 2766 struct drm_connector *connector, 2767 enum drm_panel_orientation panel_orientation) 2768 { 2769 struct drm_device *dev = connector->dev; 2770 struct drm_display_info *info = &connector->display_info; 2771 struct drm_property *prop; 2772 2773 /* Already set? */ 2774 if (info->panel_orientation != DRM_MODE_PANEL_ORIENTATION_UNKNOWN) 2775 return 0; 2776 2777 /* Don't attach the property if the orientation is unknown */ 2778 if (panel_orientation == DRM_MODE_PANEL_ORIENTATION_UNKNOWN) 2779 return 0; 2780 2781 info->panel_orientation = panel_orientation; 2782 2783 prop = dev->mode_config.panel_orientation_property; 2784 if (!prop) { 2785 prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 2786 "panel orientation", 2787 drm_panel_orientation_enum_list, 2788 ARRAY_SIZE(drm_panel_orientation_enum_list)); 2789 if (!prop) 2790 return -ENOMEM; 2791 2792 dev->mode_config.panel_orientation_property = prop; 2793 } 2794 2795 drm_object_attach_property(&connector->base, prop, 2796 info->panel_orientation); 2797 return 0; 2798 } 2799 EXPORT_SYMBOL(drm_connector_set_panel_orientation); 2800 2801 /** 2802 * drm_connector_set_panel_orientation_with_quirk - set the 2803 * connector's panel_orientation after checking for quirks 2804 * @connector: connector for which to init the panel-orientation property. 2805 * @panel_orientation: drm_panel_orientation value to set 2806 * @width: width in pixels of the panel, used for panel quirk detection 2807 * @height: height in pixels of the panel, used for panel quirk detection 2808 * 2809 * Like drm_connector_set_panel_orientation(), but with a check for platform 2810 * specific (e.g. DMI based) quirks overriding the passed in panel_orientation. 2811 * 2812 * Returns: 2813 * Zero on success, negative errno on failure. 2814 */ 2815 int drm_connector_set_panel_orientation_with_quirk( 2816 struct drm_connector *connector, 2817 enum drm_panel_orientation panel_orientation, 2818 int width, int height) 2819 { 2820 int orientation_quirk; 2821 2822 orientation_quirk = drm_get_panel_orientation_quirk(width, height); 2823 if (orientation_quirk != DRM_MODE_PANEL_ORIENTATION_UNKNOWN) 2824 panel_orientation = orientation_quirk; 2825 2826 return drm_connector_set_panel_orientation(connector, 2827 panel_orientation); 2828 } 2829 EXPORT_SYMBOL(drm_connector_set_panel_orientation_with_quirk); 2830 2831 /** 2832 * drm_connector_set_orientation_from_panel - 2833 * set the connector's panel_orientation from panel's callback. 2834 * @connector: connector for which to init the panel-orientation property. 2835 * @panel: panel that can provide orientation information. 2836 * 2837 * Drm drivers should call this function before drm_dev_register(). 2838 * Orientation is obtained from panel's .get_orientation() callback. 2839 * 2840 * Returns: 2841 * Zero on success, negative errno on failure. 2842 */ 2843 int drm_connector_set_orientation_from_panel( 2844 struct drm_connector *connector, 2845 struct drm_panel *panel) 2846 { 2847 enum drm_panel_orientation orientation; 2848 2849 if (panel && panel->funcs && panel->funcs->get_orientation) 2850 orientation = panel->funcs->get_orientation(panel); 2851 else 2852 orientation = DRM_MODE_PANEL_ORIENTATION_UNKNOWN; 2853 2854 return drm_connector_set_panel_orientation(connector, orientation); 2855 } 2856 EXPORT_SYMBOL(drm_connector_set_orientation_from_panel); 2857 2858 static const struct drm_prop_enum_list privacy_screen_enum[] = { 2859 { PRIVACY_SCREEN_DISABLED, "Disabled" }, 2860 { PRIVACY_SCREEN_ENABLED, "Enabled" }, 2861 { PRIVACY_SCREEN_DISABLED_LOCKED, "Disabled-locked" }, 2862 { PRIVACY_SCREEN_ENABLED_LOCKED, "Enabled-locked" }, 2863 }; 2864 2865 /** 2866 * drm_connector_create_privacy_screen_properties - create the drm connecter's 2867 * privacy-screen properties. 2868 * @connector: connector for which to create the privacy-screen properties 2869 * 2870 * This function creates the "privacy-screen sw-state" and "privacy-screen 2871 * hw-state" properties for the connector. They are not attached. 2872 */ 2873 void 2874 drm_connector_create_privacy_screen_properties(struct drm_connector *connector) 2875 { 2876 if (connector->privacy_screen_sw_state_property) 2877 return; 2878 2879 /* Note sw-state only supports the first 2 values of the enum */ 2880 connector->privacy_screen_sw_state_property = 2881 drm_property_create_enum(connector->dev, DRM_MODE_PROP_ENUM, 2882 "privacy-screen sw-state", 2883 privacy_screen_enum, 2); 2884 2885 connector->privacy_screen_hw_state_property = 2886 drm_property_create_enum(connector->dev, 2887 DRM_MODE_PROP_IMMUTABLE | DRM_MODE_PROP_ENUM, 2888 "privacy-screen hw-state", 2889 privacy_screen_enum, 2890 ARRAY_SIZE(privacy_screen_enum)); 2891 } 2892 EXPORT_SYMBOL(drm_connector_create_privacy_screen_properties); 2893 2894 /** 2895 * drm_connector_attach_privacy_screen_properties - attach the drm connecter's 2896 * privacy-screen properties. 2897 * @connector: connector on which to attach the privacy-screen properties 2898 * 2899 * This function attaches the "privacy-screen sw-state" and "privacy-screen 2900 * hw-state" properties to the connector. The initial state of both is set 2901 * to "Disabled". 2902 */ 2903 void 2904 drm_connector_attach_privacy_screen_properties(struct drm_connector *connector) 2905 { 2906 if (!connector->privacy_screen_sw_state_property) 2907 return; 2908 2909 drm_object_attach_property(&connector->base, 2910 connector->privacy_screen_sw_state_property, 2911 PRIVACY_SCREEN_DISABLED); 2912 2913 drm_object_attach_property(&connector->base, 2914 connector->privacy_screen_hw_state_property, 2915 PRIVACY_SCREEN_DISABLED); 2916 } 2917 EXPORT_SYMBOL(drm_connector_attach_privacy_screen_properties); 2918 2919 static void drm_connector_update_privacy_screen_properties( 2920 struct drm_connector *connector, bool set_sw_state) 2921 { 2922 enum drm_privacy_screen_status sw_state, hw_state; 2923 2924 drm_privacy_screen_get_state(connector->privacy_screen, 2925 &sw_state, &hw_state); 2926 2927 if (set_sw_state) 2928 connector->state->privacy_screen_sw_state = sw_state; 2929 drm_object_property_set_value(&connector->base, 2930 connector->privacy_screen_hw_state_property, hw_state); 2931 } 2932 2933 static int drm_connector_privacy_screen_notifier( 2934 struct notifier_block *nb, unsigned long action, void *data) 2935 { 2936 struct drm_connector *connector = 2937 container_of(nb, struct drm_connector, privacy_screen_notifier); 2938 struct drm_device *dev = connector->dev; 2939 2940 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 2941 drm_connector_update_privacy_screen_properties(connector, true); 2942 drm_modeset_unlock(&dev->mode_config.connection_mutex); 2943 2944 drm_sysfs_connector_property_event(connector, 2945 connector->privacy_screen_sw_state_property); 2946 drm_sysfs_connector_property_event(connector, 2947 connector->privacy_screen_hw_state_property); 2948 2949 return NOTIFY_DONE; 2950 } 2951 2952 /** 2953 * drm_connector_attach_privacy_screen_provider - attach a privacy-screen to 2954 * the connector 2955 * @connector: connector to attach the privacy-screen to 2956 * @priv: drm_privacy_screen to attach 2957 * 2958 * Create and attach the standard privacy-screen properties and register 2959 * a generic notifier for generating sysfs-connector-status-events 2960 * on external changes to the privacy-screen status. 2961 * This function takes ownership of the passed in drm_privacy_screen and will 2962 * call drm_privacy_screen_put() on it when the connector is destroyed. 2963 */ 2964 void drm_connector_attach_privacy_screen_provider( 2965 struct drm_connector *connector, struct drm_privacy_screen *priv) 2966 { 2967 connector->privacy_screen = priv; 2968 connector->privacy_screen_notifier.notifier_call = 2969 drm_connector_privacy_screen_notifier; 2970 2971 drm_connector_create_privacy_screen_properties(connector); 2972 drm_connector_update_privacy_screen_properties(connector, true); 2973 drm_connector_attach_privacy_screen_properties(connector); 2974 } 2975 EXPORT_SYMBOL(drm_connector_attach_privacy_screen_provider); 2976 2977 /** 2978 * drm_connector_update_privacy_screen - update connector's privacy-screen sw-state 2979 * @connector_state: connector-state to update the privacy-screen for 2980 * 2981 * This function calls drm_privacy_screen_set_sw_state() on the connector's 2982 * privacy-screen. 2983 * 2984 * If the connector has no privacy-screen, then this is a no-op. 2985 */ 2986 void drm_connector_update_privacy_screen(const struct drm_connector_state *connector_state) 2987 { 2988 struct drm_connector *connector = connector_state->connector; 2989 int ret; 2990 2991 if (!connector->privacy_screen) 2992 return; 2993 2994 ret = drm_privacy_screen_set_sw_state(connector->privacy_screen, 2995 connector_state->privacy_screen_sw_state); 2996 if (ret) { 2997 drm_err(connector->dev, "Error updating privacy-screen sw_state\n"); 2998 return; 2999 } 3000 3001 /* The hw_state property value may have changed, update it. */ 3002 drm_connector_update_privacy_screen_properties(connector, false); 3003 } 3004 EXPORT_SYMBOL(drm_connector_update_privacy_screen); 3005 3006 int drm_connector_set_obj_prop(struct drm_mode_object *obj, 3007 struct drm_property *property, 3008 uint64_t value) 3009 { 3010 int ret = -EINVAL; 3011 struct drm_connector *connector = obj_to_connector(obj); 3012 3013 /* Do DPMS ourselves */ 3014 if (property == connector->dev->mode_config.dpms_property) { 3015 ret = (*connector->funcs->dpms)(connector, (int)value); 3016 } else if (connector->funcs->set_property) 3017 ret = connector->funcs->set_property(connector, property, value); 3018 3019 if (!ret) 3020 drm_object_property_set_value(&connector->base, property, value); 3021 return ret; 3022 } 3023 3024 int drm_connector_property_set_ioctl(struct drm_device *dev, 3025 void *data, struct drm_file *file_priv) 3026 { 3027 struct drm_mode_connector_set_property *conn_set_prop = data; 3028 struct drm_mode_obj_set_property obj_set_prop = { 3029 .value = conn_set_prop->value, 3030 .prop_id = conn_set_prop->prop_id, 3031 .obj_id = conn_set_prop->connector_id, 3032 .obj_type = DRM_MODE_OBJECT_CONNECTOR 3033 }; 3034 3035 /* It does all the locking and checking we need */ 3036 return drm_mode_obj_set_property_ioctl(dev, &obj_set_prop, file_priv); 3037 } 3038 3039 static struct drm_encoder *drm_connector_get_encoder(struct drm_connector *connector) 3040 { 3041 /* For atomic drivers only state objects are synchronously updated and 3042 * protected by modeset locks, so check those first. 3043 */ 3044 if (connector->state) 3045 return connector->state->best_encoder; 3046 return connector->encoder; 3047 } 3048 3049 static bool 3050 drm_mode_expose_to_userspace(const struct drm_display_mode *mode, 3051 const struct list_head *modes, 3052 const struct drm_file *file_priv) 3053 { 3054 /* 3055 * If user-space hasn't configured the driver to expose the stereo 3D 3056 * modes, don't expose them. 3057 */ 3058 if (!file_priv->stereo_allowed && drm_mode_is_stereo(mode)) 3059 return false; 3060 /* 3061 * If user-space hasn't configured the driver to expose the modes 3062 * with aspect-ratio, don't expose them. However if such a mode 3063 * is unique, let it be exposed, but reset the aspect-ratio flags 3064 * while preparing the list of user-modes. 3065 */ 3066 if (!file_priv->aspect_ratio_allowed) { 3067 const struct drm_display_mode *mode_itr; 3068 3069 list_for_each_entry(mode_itr, modes, head) { 3070 if (mode_itr->expose_to_userspace && 3071 drm_mode_match(mode_itr, mode, 3072 DRM_MODE_MATCH_TIMINGS | 3073 DRM_MODE_MATCH_CLOCK | 3074 DRM_MODE_MATCH_FLAGS | 3075 DRM_MODE_MATCH_3D_FLAGS)) 3076 return false; 3077 } 3078 } 3079 3080 return true; 3081 } 3082 3083 int drm_mode_getconnector(struct drm_device *dev, void *data, 3084 struct drm_file *file_priv) 3085 { 3086 struct drm_mode_get_connector *out_resp = data; 3087 struct drm_connector *connector; 3088 struct drm_encoder *encoder; 3089 struct drm_display_mode *mode; 3090 int mode_count = 0; 3091 int encoders_count = 0; 3092 int ret = 0; 3093 int copied = 0; 3094 struct drm_mode_modeinfo u_mode; 3095 struct drm_mode_modeinfo __user *mode_ptr; 3096 uint32_t __user *encoder_ptr; 3097 bool is_current_master; 3098 3099 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 3100 return -EOPNOTSUPP; 3101 3102 memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo)); 3103 3104 connector = drm_connector_lookup(dev, file_priv, out_resp->connector_id); 3105 if (!connector) 3106 return -ENOENT; 3107 3108 encoders_count = hweight32(connector->possible_encoders); 3109 3110 if ((out_resp->count_encoders >= encoders_count) && encoders_count) { 3111 copied = 0; 3112 encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr); 3113 3114 drm_connector_for_each_possible_encoder(connector, encoder) { 3115 if (put_user(encoder->base.id, encoder_ptr + copied)) { 3116 ret = -EFAULT; 3117 goto out; 3118 } 3119 copied++; 3120 } 3121 } 3122 out_resp->count_encoders = encoders_count; 3123 3124 out_resp->connector_id = connector->base.id; 3125 out_resp->connector_type = connector->connector_type; 3126 out_resp->connector_type_id = connector->connector_type_id; 3127 3128 is_current_master = drm_is_current_master(file_priv); 3129 3130 mutex_lock(&dev->mode_config.mutex); 3131 if (out_resp->count_modes == 0) { 3132 if (is_current_master) 3133 connector->funcs->fill_modes(connector, 3134 dev->mode_config.max_width, 3135 dev->mode_config.max_height); 3136 else 3137 drm_dbg_kms(dev, "User-space requested a forced probe on [CONNECTOR:%d:%s] but is not the DRM master, demoting to read-only probe\n", 3138 connector->base.id, connector->name); 3139 } 3140 3141 out_resp->mm_width = connector->display_info.width_mm; 3142 out_resp->mm_height = connector->display_info.height_mm; 3143 out_resp->subpixel = connector->display_info.subpixel_order; 3144 out_resp->connection = connector->status; 3145 3146 /* delayed so we get modes regardless of pre-fill_modes state */ 3147 list_for_each_entry(mode, &connector->modes, head) { 3148 WARN_ON(mode->expose_to_userspace); 3149 3150 if (drm_mode_expose_to_userspace(mode, &connector->modes, 3151 file_priv)) { 3152 mode->expose_to_userspace = true; 3153 mode_count++; 3154 } 3155 } 3156 3157 /* 3158 * This ioctl is called twice, once to determine how much space is 3159 * needed, and the 2nd time to fill it. 3160 */ 3161 if ((out_resp->count_modes >= mode_count) && mode_count) { 3162 copied = 0; 3163 mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr; 3164 list_for_each_entry(mode, &connector->modes, head) { 3165 if (!mode->expose_to_userspace) 3166 continue; 3167 3168 /* Clear the tag for the next time around */ 3169 mode->expose_to_userspace = false; 3170 3171 drm_mode_convert_to_umode(&u_mode, mode); 3172 /* 3173 * Reset aspect ratio flags of user-mode, if modes with 3174 * aspect-ratio are not supported. 3175 */ 3176 if (!file_priv->aspect_ratio_allowed) 3177 u_mode.flags &= ~DRM_MODE_FLAG_PIC_AR_MASK; 3178 if (copy_to_user(mode_ptr + copied, 3179 &u_mode, sizeof(u_mode))) { 3180 ret = -EFAULT; 3181 3182 /* 3183 * Clear the tag for the rest of 3184 * the modes for the next time around. 3185 */ 3186 list_for_each_entry_continue(mode, &connector->modes, head) 3187 mode->expose_to_userspace = false; 3188 3189 mutex_unlock(&dev->mode_config.mutex); 3190 3191 goto out; 3192 } 3193 copied++; 3194 } 3195 } else { 3196 /* Clear the tag for the next time around */ 3197 list_for_each_entry(mode, &connector->modes, head) 3198 mode->expose_to_userspace = false; 3199 } 3200 3201 out_resp->count_modes = mode_count; 3202 mutex_unlock(&dev->mode_config.mutex); 3203 3204 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 3205 encoder = drm_connector_get_encoder(connector); 3206 if (encoder) 3207 out_resp->encoder_id = encoder->base.id; 3208 else 3209 out_resp->encoder_id = 0; 3210 3211 /* Only grab properties after probing, to make sure EDID and other 3212 * properties reflect the latest status. 3213 */ 3214 ret = drm_mode_object_get_properties(&connector->base, file_priv->atomic, 3215 (uint32_t __user *)(unsigned long)(out_resp->props_ptr), 3216 (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr), 3217 &out_resp->count_props); 3218 drm_modeset_unlock(&dev->mode_config.connection_mutex); 3219 3220 out: 3221 drm_connector_put(connector); 3222 3223 return ret; 3224 } 3225 3226 /** 3227 * drm_connector_find_by_fwnode - Find a connector based on the associated fwnode 3228 * @fwnode: fwnode for which to find the matching drm_connector 3229 * 3230 * This functions looks up a drm_connector based on its associated fwnode. When 3231 * a connector is found a reference to the connector is returned. The caller must 3232 * call drm_connector_put() to release this reference when it is done with the 3233 * connector. 3234 * 3235 * Returns: A reference to the found connector or an ERR_PTR(). 3236 */ 3237 struct drm_connector *drm_connector_find_by_fwnode(struct fwnode_handle *fwnode) 3238 { 3239 struct drm_connector *connector, *found = ERR_PTR(-ENODEV); 3240 3241 if (!fwnode) 3242 return ERR_PTR(-ENODEV); 3243 3244 mutex_lock(&connector_list_lock); 3245 3246 list_for_each_entry(connector, &connector_list, global_connector_list_entry) { 3247 if (connector->fwnode == fwnode || 3248 (connector->fwnode && connector->fwnode->secondary == fwnode)) { 3249 drm_connector_get(connector); 3250 found = connector; 3251 break; 3252 } 3253 } 3254 3255 mutex_unlock(&connector_list_lock); 3256 3257 return found; 3258 } 3259 3260 /** 3261 * drm_connector_oob_hotplug_event - Report out-of-band hotplug event to connector 3262 * @connector_fwnode: fwnode_handle to report the event on 3263 * @status: hot plug detect logical state 3264 * 3265 * On some hardware a hotplug event notification may come from outside the display 3266 * driver / device. An example of this is some USB Type-C setups where the hardware 3267 * muxes the DisplayPort data and aux-lines but does not pass the altmode HPD 3268 * status bit to the GPU's DP HPD pin. 3269 * 3270 * This function can be used to report these out-of-band events after obtaining 3271 * a drm_connector reference through calling drm_connector_find_by_fwnode(). 3272 */ 3273 void drm_connector_oob_hotplug_event(struct fwnode_handle *connector_fwnode, 3274 enum drm_connector_status status) 3275 { 3276 struct drm_connector *connector; 3277 3278 connector = drm_connector_find_by_fwnode(connector_fwnode); 3279 if (IS_ERR(connector)) 3280 return; 3281 3282 if (connector->funcs->oob_hotplug_event) 3283 connector->funcs->oob_hotplug_event(connector, status); 3284 3285 drm_connector_put(connector); 3286 } 3287 EXPORT_SYMBOL(drm_connector_oob_hotplug_event); 3288 3289 3290 /** 3291 * DOC: Tile group 3292 * 3293 * Tile groups are used to represent tiled monitors with a unique integer 3294 * identifier. Tiled monitors using DisplayID v1.3 have a unique 8-byte handle, 3295 * we store this in a tile group, so we have a common identifier for all tiles 3296 * in a monitor group. The property is called "TILE". Drivers can manage tile 3297 * groups using drm_mode_create_tile_group(), drm_mode_put_tile_group() and 3298 * drm_mode_get_tile_group(). But this is only needed for internal panels where 3299 * the tile group information is exposed through a non-standard way. 3300 */ 3301 3302 static void drm_tile_group_free(struct kref *kref) 3303 { 3304 struct drm_tile_group *tg = container_of(kref, struct drm_tile_group, refcount); 3305 struct drm_device *dev = tg->dev; 3306 3307 mutex_lock(&dev->mode_config.idr_mutex); 3308 idr_remove(&dev->mode_config.tile_idr, tg->id); 3309 mutex_unlock(&dev->mode_config.idr_mutex); 3310 kfree(tg); 3311 } 3312 3313 /** 3314 * drm_mode_put_tile_group - drop a reference to a tile group. 3315 * @dev: DRM device 3316 * @tg: tile group to drop reference to. 3317 * 3318 * drop reference to tile group and free if 0. 3319 */ 3320 void drm_mode_put_tile_group(struct drm_device *dev, 3321 struct drm_tile_group *tg) 3322 { 3323 kref_put(&tg->refcount, drm_tile_group_free); 3324 } 3325 EXPORT_SYMBOL(drm_mode_put_tile_group); 3326 3327 /** 3328 * drm_mode_get_tile_group - get a reference to an existing tile group 3329 * @dev: DRM device 3330 * @topology: 8-bytes unique per monitor. 3331 * 3332 * Use the unique bytes to get a reference to an existing tile group. 3333 * 3334 * RETURNS: 3335 * tile group or NULL if not found. 3336 */ 3337 struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev, 3338 const char topology[8]) 3339 { 3340 struct drm_tile_group *tg; 3341 int id; 3342 3343 mutex_lock(&dev->mode_config.idr_mutex); 3344 idr_for_each_entry(&dev->mode_config.tile_idr, tg, id) { 3345 if (!memcmp(tg->group_data, topology, 8)) { 3346 if (!kref_get_unless_zero(&tg->refcount)) 3347 tg = NULL; 3348 mutex_unlock(&dev->mode_config.idr_mutex); 3349 return tg; 3350 } 3351 } 3352 mutex_unlock(&dev->mode_config.idr_mutex); 3353 return NULL; 3354 } 3355 EXPORT_SYMBOL(drm_mode_get_tile_group); 3356 3357 /** 3358 * drm_mode_create_tile_group - create a tile group from a displayid description 3359 * @dev: DRM device 3360 * @topology: 8-bytes unique per monitor. 3361 * 3362 * Create a tile group for the unique monitor, and get a unique 3363 * identifier for the tile group. 3364 * 3365 * RETURNS: 3366 * new tile group or NULL. 3367 */ 3368 struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev, 3369 const char topology[8]) 3370 { 3371 struct drm_tile_group *tg; 3372 int ret; 3373 3374 tg = kzalloc(sizeof(*tg), GFP_KERNEL); 3375 if (!tg) 3376 return NULL; 3377 3378 kref_init(&tg->refcount); 3379 memcpy(tg->group_data, topology, 8); 3380 tg->dev = dev; 3381 3382 mutex_lock(&dev->mode_config.idr_mutex); 3383 ret = idr_alloc(&dev->mode_config.tile_idr, tg, 1, 0, GFP_KERNEL); 3384 if (ret >= 0) { 3385 tg->id = ret; 3386 } else { 3387 kfree(tg); 3388 tg = NULL; 3389 } 3390 3391 mutex_unlock(&dev->mode_config.idr_mutex); 3392 return tg; 3393 } 3394 EXPORT_SYMBOL(drm_mode_create_tile_group); 3395