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