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/drmP.h> 24 #include <drm/drm_connector.h> 25 #include <drm/drm_edid.h> 26 #include <drm/drm_encoder.h> 27 28 #include "drm_crtc_internal.h" 29 #include "drm_internal.h" 30 31 /** 32 * DOC: overview 33 * 34 * In DRM connectors are the general abstraction for display sinks, and include 35 * als fixed panels or anything else that can display pixels in some form. As 36 * opposed to all other KMS objects representing hardware (like CRTC, encoder or 37 * plane abstractions) connectors can be hotplugged and unplugged at runtime. 38 * Hence they are reference-counted using drm_connector_get() and 39 * drm_connector_put(). 40 * 41 * KMS driver must create, initialize, register and attach at a &struct 42 * drm_connector for each such sink. The instance is created as other KMS 43 * objects and initialized by setting the following fields. The connector is 44 * initialized with a call to drm_connector_init() with a pointer to the 45 * &struct drm_connector_funcs and a connector type, and then exposed to 46 * userspace with a call to drm_connector_register(). 47 * 48 * Connectors must be attached to an encoder to be used. For devices that map 49 * connectors to encoders 1:1, the connector should be attached at 50 * initialization time with a call to drm_mode_connector_attach_encoder(). The 51 * driver must also set the &drm_connector.encoder field to point to the 52 * attached encoder. 53 * 54 * For connectors which are not fixed (like built-in panels) the driver needs to 55 * support hotplug notifications. The simplest way to do that is by using the 56 * probe helpers, see drm_kms_helper_poll_init() for connectors which don't have 57 * hardware support for hotplug interrupts. Connectors with hardware hotplug 58 * support can instead use e.g. drm_helper_hpd_irq_event(). 59 */ 60 61 struct drm_conn_prop_enum_list { 62 int type; 63 const char *name; 64 struct ida ida; 65 }; 66 67 /* 68 * Connector and encoder types. 69 */ 70 static struct drm_conn_prop_enum_list drm_connector_enum_list[] = { 71 { DRM_MODE_CONNECTOR_Unknown, "Unknown" }, 72 { DRM_MODE_CONNECTOR_VGA, "VGA" }, 73 { DRM_MODE_CONNECTOR_DVII, "DVI-I" }, 74 { DRM_MODE_CONNECTOR_DVID, "DVI-D" }, 75 { DRM_MODE_CONNECTOR_DVIA, "DVI-A" }, 76 { DRM_MODE_CONNECTOR_Composite, "Composite" }, 77 { DRM_MODE_CONNECTOR_SVIDEO, "SVIDEO" }, 78 { DRM_MODE_CONNECTOR_LVDS, "LVDS" }, 79 { DRM_MODE_CONNECTOR_Component, "Component" }, 80 { DRM_MODE_CONNECTOR_9PinDIN, "DIN" }, 81 { DRM_MODE_CONNECTOR_DisplayPort, "DP" }, 82 { DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" }, 83 { DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" }, 84 { DRM_MODE_CONNECTOR_TV, "TV" }, 85 { DRM_MODE_CONNECTOR_eDP, "eDP" }, 86 { DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" }, 87 { DRM_MODE_CONNECTOR_DSI, "DSI" }, 88 { DRM_MODE_CONNECTOR_DPI, "DPI" }, 89 }; 90 91 void drm_connector_ida_init(void) 92 { 93 int i; 94 95 for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++) 96 ida_init(&drm_connector_enum_list[i].ida); 97 } 98 99 void drm_connector_ida_destroy(void) 100 { 101 int i; 102 103 for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++) 104 ida_destroy(&drm_connector_enum_list[i].ida); 105 } 106 107 /** 108 * drm_connector_get_cmdline_mode - reads the user's cmdline mode 109 * @connector: connector to quwery 110 * 111 * The kernel supports per-connector configuration of its consoles through 112 * use of the video= parameter. This function parses that option and 113 * extracts the user's specified mode (or enable/disable status) for a 114 * particular connector. This is typically only used during the early fbdev 115 * setup. 116 */ 117 static void drm_connector_get_cmdline_mode(struct drm_connector *connector) 118 { 119 struct drm_cmdline_mode *mode = &connector->cmdline_mode; 120 char *option = NULL; 121 122 if (fb_get_options(connector->name, &option)) 123 return; 124 125 if (!drm_mode_parse_command_line_for_connector(option, 126 connector, 127 mode)) 128 return; 129 130 if (mode->force) { 131 DRM_INFO("forcing %s connector %s\n", connector->name, 132 drm_get_connector_force_name(mode->force)); 133 connector->force = mode->force; 134 } 135 136 DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n", 137 connector->name, 138 mode->xres, mode->yres, 139 mode->refresh_specified ? mode->refresh : 60, 140 mode->rb ? " reduced blanking" : "", 141 mode->margins ? " with margins" : "", 142 mode->interlace ? " interlaced" : ""); 143 } 144 145 static void drm_connector_free(struct kref *kref) 146 { 147 struct drm_connector *connector = 148 container_of(kref, struct drm_connector, base.refcount); 149 struct drm_device *dev = connector->dev; 150 151 drm_mode_object_unregister(dev, &connector->base); 152 connector->funcs->destroy(connector); 153 } 154 155 /** 156 * drm_connector_init - Init a preallocated connector 157 * @dev: DRM device 158 * @connector: the connector to init 159 * @funcs: callbacks for this connector 160 * @connector_type: user visible type of the connector 161 * 162 * Initialises a preallocated connector. Connectors should be 163 * subclassed as part of driver connector objects. 164 * 165 * Returns: 166 * Zero on success, error code on failure. 167 */ 168 int drm_connector_init(struct drm_device *dev, 169 struct drm_connector *connector, 170 const struct drm_connector_funcs *funcs, 171 int connector_type) 172 { 173 struct drm_mode_config *config = &dev->mode_config; 174 int ret; 175 struct ida *connector_ida = 176 &drm_connector_enum_list[connector_type].ida; 177 178 ret = __drm_mode_object_add(dev, &connector->base, 179 DRM_MODE_OBJECT_CONNECTOR, 180 false, drm_connector_free); 181 if (ret) 182 return ret; 183 184 connector->base.properties = &connector->properties; 185 connector->dev = dev; 186 connector->funcs = funcs; 187 188 ret = ida_simple_get(&config->connector_ida, 0, 0, GFP_KERNEL); 189 if (ret < 0) 190 goto out_put; 191 connector->index = ret; 192 ret = 0; 193 194 connector->connector_type = connector_type; 195 connector->connector_type_id = 196 ida_simple_get(connector_ida, 1, 0, GFP_KERNEL); 197 if (connector->connector_type_id < 0) { 198 ret = connector->connector_type_id; 199 goto out_put_id; 200 } 201 connector->name = 202 kasprintf(GFP_KERNEL, "%s-%d", 203 drm_connector_enum_list[connector_type].name, 204 connector->connector_type_id); 205 if (!connector->name) { 206 ret = -ENOMEM; 207 goto out_put_type_id; 208 } 209 210 INIT_LIST_HEAD(&connector->probed_modes); 211 INIT_LIST_HEAD(&connector->modes); 212 mutex_init(&connector->mutex); 213 connector->edid_blob_ptr = NULL; 214 connector->status = connector_status_unknown; 215 216 drm_connector_get_cmdline_mode(connector); 217 218 /* We should add connectors at the end to avoid upsetting the connector 219 * index too much. */ 220 spin_lock_irq(&config->connector_list_lock); 221 list_add_tail(&connector->head, &config->connector_list); 222 config->num_connector++; 223 spin_unlock_irq(&config->connector_list_lock); 224 225 if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL) 226 drm_object_attach_property(&connector->base, 227 config->edid_property, 228 0); 229 230 drm_object_attach_property(&connector->base, 231 config->dpms_property, 0); 232 233 drm_object_attach_property(&connector->base, 234 config->link_status_property, 235 0); 236 237 if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { 238 drm_object_attach_property(&connector->base, config->prop_crtc_id, 0); 239 } 240 241 connector->debugfs_entry = NULL; 242 out_put_type_id: 243 if (ret) 244 ida_simple_remove(connector_ida, connector->connector_type_id); 245 out_put_id: 246 if (ret) 247 ida_simple_remove(&config->connector_ida, connector->index); 248 out_put: 249 if (ret) 250 drm_mode_object_unregister(dev, &connector->base); 251 252 return ret; 253 } 254 EXPORT_SYMBOL(drm_connector_init); 255 256 /** 257 * drm_mode_connector_attach_encoder - attach a connector to an encoder 258 * @connector: connector to attach 259 * @encoder: encoder to attach @connector to 260 * 261 * This function links up a connector to an encoder. Note that the routing 262 * restrictions between encoders and crtcs are exposed to userspace through the 263 * possible_clones and possible_crtcs bitmasks. 264 * 265 * Returns: 266 * Zero on success, negative errno on failure. 267 */ 268 int drm_mode_connector_attach_encoder(struct drm_connector *connector, 269 struct drm_encoder *encoder) 270 { 271 int i; 272 273 /* 274 * In the past, drivers have attempted to model the static association 275 * of connector to encoder in simple connector/encoder devices using a 276 * direct assignment of connector->encoder = encoder. This connection 277 * is a logical one and the responsibility of the core, so drivers are 278 * expected not to mess with this. 279 * 280 * Note that the error return should've been enough here, but a large 281 * majority of drivers ignores the return value, so add in a big WARN 282 * to get people's attention. 283 */ 284 if (WARN_ON(connector->encoder)) 285 return -EINVAL; 286 287 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 288 if (connector->encoder_ids[i] == 0) { 289 connector->encoder_ids[i] = encoder->base.id; 290 return 0; 291 } 292 } 293 return -ENOMEM; 294 } 295 EXPORT_SYMBOL(drm_mode_connector_attach_encoder); 296 297 static void drm_mode_remove(struct drm_connector *connector, 298 struct drm_display_mode *mode) 299 { 300 list_del(&mode->head); 301 drm_mode_destroy(connector->dev, mode); 302 } 303 304 /** 305 * drm_connector_cleanup - cleans up an initialised connector 306 * @connector: connector to cleanup 307 * 308 * Cleans up the connector but doesn't free the object. 309 */ 310 void drm_connector_cleanup(struct drm_connector *connector) 311 { 312 struct drm_device *dev = connector->dev; 313 struct drm_display_mode *mode, *t; 314 315 /* The connector should have been removed from userspace long before 316 * it is finally destroyed. 317 */ 318 if (WARN_ON(connector->registered)) 319 drm_connector_unregister(connector); 320 321 if (connector->tile_group) { 322 drm_mode_put_tile_group(dev, connector->tile_group); 323 connector->tile_group = NULL; 324 } 325 326 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) 327 drm_mode_remove(connector, mode); 328 329 list_for_each_entry_safe(mode, t, &connector->modes, head) 330 drm_mode_remove(connector, mode); 331 332 ida_simple_remove(&drm_connector_enum_list[connector->connector_type].ida, 333 connector->connector_type_id); 334 335 ida_simple_remove(&dev->mode_config.connector_ida, 336 connector->index); 337 338 kfree(connector->display_info.bus_formats); 339 drm_mode_object_unregister(dev, &connector->base); 340 kfree(connector->name); 341 connector->name = NULL; 342 spin_lock_irq(&dev->mode_config.connector_list_lock); 343 list_del(&connector->head); 344 dev->mode_config.num_connector--; 345 spin_unlock_irq(&dev->mode_config.connector_list_lock); 346 347 WARN_ON(connector->state && !connector->funcs->atomic_destroy_state); 348 if (connector->state && connector->funcs->atomic_destroy_state) 349 connector->funcs->atomic_destroy_state(connector, 350 connector->state); 351 352 mutex_destroy(&connector->mutex); 353 354 memset(connector, 0, sizeof(*connector)); 355 } 356 EXPORT_SYMBOL(drm_connector_cleanup); 357 358 /** 359 * drm_connector_register - register a connector 360 * @connector: the connector to register 361 * 362 * Register userspace interfaces for a connector 363 * 364 * Returns: 365 * Zero on success, error code on failure. 366 */ 367 int drm_connector_register(struct drm_connector *connector) 368 { 369 int ret = 0; 370 371 if (!connector->dev->registered) 372 return 0; 373 374 mutex_lock(&connector->mutex); 375 if (connector->registered) 376 goto unlock; 377 378 ret = drm_sysfs_connector_add(connector); 379 if (ret) 380 goto unlock; 381 382 ret = drm_debugfs_connector_add(connector); 383 if (ret) { 384 goto err_sysfs; 385 } 386 387 if (connector->funcs->late_register) { 388 ret = connector->funcs->late_register(connector); 389 if (ret) 390 goto err_debugfs; 391 } 392 393 drm_mode_object_register(connector->dev, &connector->base); 394 395 connector->registered = true; 396 goto unlock; 397 398 err_debugfs: 399 drm_debugfs_connector_remove(connector); 400 err_sysfs: 401 drm_sysfs_connector_remove(connector); 402 unlock: 403 mutex_unlock(&connector->mutex); 404 return ret; 405 } 406 EXPORT_SYMBOL(drm_connector_register); 407 408 /** 409 * drm_connector_unregister - unregister a connector 410 * @connector: the connector to unregister 411 * 412 * Unregister userspace interfaces for a connector 413 */ 414 void drm_connector_unregister(struct drm_connector *connector) 415 { 416 mutex_lock(&connector->mutex); 417 if (!connector->registered) { 418 mutex_unlock(&connector->mutex); 419 return; 420 } 421 422 if (connector->funcs->early_unregister) 423 connector->funcs->early_unregister(connector); 424 425 drm_sysfs_connector_remove(connector); 426 drm_debugfs_connector_remove(connector); 427 428 connector->registered = false; 429 mutex_unlock(&connector->mutex); 430 } 431 EXPORT_SYMBOL(drm_connector_unregister); 432 433 void drm_connector_unregister_all(struct drm_device *dev) 434 { 435 struct drm_connector *connector; 436 struct drm_connector_list_iter conn_iter; 437 438 drm_connector_list_iter_begin(dev, &conn_iter); 439 drm_for_each_connector_iter(connector, &conn_iter) 440 drm_connector_unregister(connector); 441 drm_connector_list_iter_end(&conn_iter); 442 } 443 444 int drm_connector_register_all(struct drm_device *dev) 445 { 446 struct drm_connector *connector; 447 struct drm_connector_list_iter conn_iter; 448 int ret = 0; 449 450 drm_connector_list_iter_begin(dev, &conn_iter); 451 drm_for_each_connector_iter(connector, &conn_iter) { 452 ret = drm_connector_register(connector); 453 if (ret) 454 break; 455 } 456 drm_connector_list_iter_end(&conn_iter); 457 458 if (ret) 459 drm_connector_unregister_all(dev); 460 return ret; 461 } 462 463 /** 464 * drm_get_connector_status_name - return a string for connector status 465 * @status: connector status to compute name of 466 * 467 * In contrast to the other drm_get_*_name functions this one here returns a 468 * const pointer and hence is threadsafe. 469 */ 470 const char *drm_get_connector_status_name(enum drm_connector_status status) 471 { 472 if (status == connector_status_connected) 473 return "connected"; 474 else if (status == connector_status_disconnected) 475 return "disconnected"; 476 else 477 return "unknown"; 478 } 479 EXPORT_SYMBOL(drm_get_connector_status_name); 480 481 /** 482 * drm_get_connector_force_name - return a string for connector force 483 * @force: connector force to get name of 484 * 485 * Returns: const pointer to name. 486 */ 487 const char *drm_get_connector_force_name(enum drm_connector_force force) 488 { 489 switch (force) { 490 case DRM_FORCE_UNSPECIFIED: 491 return "unspecified"; 492 case DRM_FORCE_OFF: 493 return "off"; 494 case DRM_FORCE_ON: 495 return "on"; 496 case DRM_FORCE_ON_DIGITAL: 497 return "digital"; 498 default: 499 return "unknown"; 500 } 501 } 502 503 #ifdef CONFIG_LOCKDEP 504 static struct lockdep_map connector_list_iter_dep_map = { 505 .name = "drm_connector_list_iter" 506 }; 507 #endif 508 509 /** 510 * drm_connector_list_iter_begin - initialize a connector_list iterator 511 * @dev: DRM device 512 * @iter: connector_list iterator 513 * 514 * Sets @iter up to walk the &drm_mode_config.connector_list of @dev. @iter 515 * must always be cleaned up again by calling drm_connector_list_iter_end(). 516 * Iteration itself happens using drm_connector_list_iter_next() or 517 * drm_for_each_connector_iter(). 518 */ 519 void drm_connector_list_iter_begin(struct drm_device *dev, 520 struct drm_connector_list_iter *iter) 521 { 522 iter->dev = dev; 523 iter->conn = NULL; 524 lock_acquire_shared_recursive(&connector_list_iter_dep_map, 0, 1, NULL, _RET_IP_); 525 } 526 EXPORT_SYMBOL(drm_connector_list_iter_begin); 527 528 /** 529 * drm_connector_list_iter_next - return next connector 530 * @iter: connectr_list iterator 531 * 532 * Returns the next connector for @iter, or NULL when the list walk has 533 * completed. 534 */ 535 struct drm_connector * 536 drm_connector_list_iter_next(struct drm_connector_list_iter *iter) 537 { 538 struct drm_connector *old_conn = iter->conn; 539 struct drm_mode_config *config = &iter->dev->mode_config; 540 struct list_head *lhead; 541 unsigned long flags; 542 543 spin_lock_irqsave(&config->connector_list_lock, flags); 544 lhead = old_conn ? &old_conn->head : &config->connector_list; 545 546 do { 547 if (lhead->next == &config->connector_list) { 548 iter->conn = NULL; 549 break; 550 } 551 552 lhead = lhead->next; 553 iter->conn = list_entry(lhead, struct drm_connector, head); 554 555 /* loop until it's not a zombie connector */ 556 } while (!kref_get_unless_zero(&iter->conn->base.refcount)); 557 spin_unlock_irqrestore(&config->connector_list_lock, flags); 558 559 if (old_conn) 560 drm_connector_put(old_conn); 561 562 return iter->conn; 563 } 564 EXPORT_SYMBOL(drm_connector_list_iter_next); 565 566 /** 567 * drm_connector_list_iter_end - tear down a connector_list iterator 568 * @iter: connector_list iterator 569 * 570 * Tears down @iter and releases any resources (like &drm_connector references) 571 * acquired while walking the list. This must always be called, both when the 572 * iteration completes fully or when it was aborted without walking the entire 573 * list. 574 */ 575 void drm_connector_list_iter_end(struct drm_connector_list_iter *iter) 576 { 577 iter->dev = NULL; 578 if (iter->conn) 579 drm_connector_put(iter->conn); 580 lock_release(&connector_list_iter_dep_map, 0, _RET_IP_); 581 } 582 EXPORT_SYMBOL(drm_connector_list_iter_end); 583 584 static const struct drm_prop_enum_list drm_subpixel_enum_list[] = { 585 { SubPixelUnknown, "Unknown" }, 586 { SubPixelHorizontalRGB, "Horizontal RGB" }, 587 { SubPixelHorizontalBGR, "Horizontal BGR" }, 588 { SubPixelVerticalRGB, "Vertical RGB" }, 589 { SubPixelVerticalBGR, "Vertical BGR" }, 590 { SubPixelNone, "None" }, 591 }; 592 593 /** 594 * drm_get_subpixel_order_name - return a string for a given subpixel enum 595 * @order: enum of subpixel_order 596 * 597 * Note you could abuse this and return something out of bounds, but that 598 * would be a caller error. No unscrubbed user data should make it here. 599 */ 600 const char *drm_get_subpixel_order_name(enum subpixel_order order) 601 { 602 return drm_subpixel_enum_list[order].name; 603 } 604 EXPORT_SYMBOL(drm_get_subpixel_order_name); 605 606 static const struct drm_prop_enum_list drm_dpms_enum_list[] = { 607 { DRM_MODE_DPMS_ON, "On" }, 608 { DRM_MODE_DPMS_STANDBY, "Standby" }, 609 { DRM_MODE_DPMS_SUSPEND, "Suspend" }, 610 { DRM_MODE_DPMS_OFF, "Off" } 611 }; 612 DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list) 613 614 static const struct drm_prop_enum_list drm_link_status_enum_list[] = { 615 { DRM_MODE_LINK_STATUS_GOOD, "Good" }, 616 { DRM_MODE_LINK_STATUS_BAD, "Bad" }, 617 }; 618 619 /** 620 * drm_display_info_set_bus_formats - set the supported bus formats 621 * @info: display info to store bus formats in 622 * @formats: array containing the supported bus formats 623 * @num_formats: the number of entries in the fmts array 624 * 625 * Store the supported bus formats in display info structure. 626 * See MEDIA_BUS_FMT_* definitions in include/uapi/linux/media-bus-format.h for 627 * a full list of available formats. 628 */ 629 int drm_display_info_set_bus_formats(struct drm_display_info *info, 630 const u32 *formats, 631 unsigned int num_formats) 632 { 633 u32 *fmts = NULL; 634 635 if (!formats && num_formats) 636 return -EINVAL; 637 638 if (formats && num_formats) { 639 fmts = kmemdup(formats, sizeof(*formats) * num_formats, 640 GFP_KERNEL); 641 if (!fmts) 642 return -ENOMEM; 643 } 644 645 kfree(info->bus_formats); 646 info->bus_formats = fmts; 647 info->num_bus_formats = num_formats; 648 649 return 0; 650 } 651 EXPORT_SYMBOL(drm_display_info_set_bus_formats); 652 653 /* Optional connector properties. */ 654 static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] = { 655 { DRM_MODE_SCALE_NONE, "None" }, 656 { DRM_MODE_SCALE_FULLSCREEN, "Full" }, 657 { DRM_MODE_SCALE_CENTER, "Center" }, 658 { DRM_MODE_SCALE_ASPECT, "Full aspect" }, 659 }; 660 661 static const struct drm_prop_enum_list drm_aspect_ratio_enum_list[] = { 662 { DRM_MODE_PICTURE_ASPECT_NONE, "Automatic" }, 663 { DRM_MODE_PICTURE_ASPECT_4_3, "4:3" }, 664 { DRM_MODE_PICTURE_ASPECT_16_9, "16:9" }, 665 }; 666 667 static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = { 668 { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ 669 { DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ 670 { DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ 671 }; 672 DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list) 673 674 static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = { 675 { DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */ 676 { DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ 677 { DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ 678 }; 679 DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name, 680 drm_dvi_i_subconnector_enum_list) 681 682 static const struct drm_prop_enum_list drm_tv_select_enum_list[] = { 683 { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ 684 { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ 685 { DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ 686 { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */ 687 { DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */ 688 }; 689 DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list) 690 691 static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = { 692 { DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */ 693 { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ 694 { DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ 695 { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */ 696 { DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */ 697 }; 698 DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name, 699 drm_tv_subconnector_enum_list) 700 701 /** 702 * DOC: standard connector properties 703 * 704 * DRM connectors have a few standardized properties: 705 * 706 * EDID: 707 * Blob property which contains the current EDID read from the sink. This 708 * is useful to parse sink identification information like vendor, model 709 * and serial. Drivers should update this property by calling 710 * drm_mode_connector_update_edid_property(), usually after having parsed 711 * the EDID using drm_add_edid_modes(). Userspace cannot change this 712 * property. 713 * DPMS: 714 * Legacy property for setting the power state of the connector. For atomic 715 * drivers this is only provided for backwards compatibility with existing 716 * drivers, it remaps to controlling the "ACTIVE" property on the CRTC the 717 * connector is linked to. Drivers should never set this property directly, 718 * it is handled by the DRM core by calling the &drm_connector_funcs.dpms 719 * callback. For atomic drivers the remapping to the "ACTIVE" property is 720 * implemented in the DRM core. This is the only standard connector 721 * property that userspace can change. 722 * 723 * Note that this property cannot be set through the MODE_ATOMIC ioctl, 724 * userspace must use "ACTIVE" on the CRTC instead. 725 * 726 * WARNING: 727 * 728 * For userspace also running on legacy drivers the "DPMS" semantics are a 729 * lot more complicated. First, userspace cannot rely on the "DPMS" value 730 * returned by the GETCONNECTOR actually reflecting reality, because many 731 * drivers fail to update it. For atomic drivers this is taken care of in 732 * drm_atomic_helper_update_legacy_modeset_state(). 733 * 734 * The second issue is that the DPMS state is only well-defined when the 735 * connector is connected to a CRTC. In atomic the DRM core enforces that 736 * "ACTIVE" is off in such a case, no such checks exists for "DPMS". 737 * 738 * Finally, when enabling an output using the legacy SETCONFIG ioctl then 739 * "DPMS" is forced to ON. But see above, that might not be reflected in 740 * the software value on legacy drivers. 741 * 742 * Summarizing: Only set "DPMS" when the connector is known to be enabled, 743 * assume that a successful SETCONFIG call also sets "DPMS" to on, and 744 * never read back the value of "DPMS" because it can be incorrect. 745 * PATH: 746 * Connector path property to identify how this sink is physically 747 * connected. Used by DP MST. This should be set by calling 748 * drm_mode_connector_set_path_property(), in the case of DP MST with the 749 * path property the MST manager created. Userspace cannot change this 750 * property. 751 * TILE: 752 * Connector tile group property to indicate how a set of DRM connector 753 * compose together into one logical screen. This is used by both high-res 754 * external screens (often only using a single cable, but exposing multiple 755 * DP MST sinks), or high-res integrated panels (like dual-link DSI) which 756 * are not gen-locked. Note that for tiled panels which are genlocked, like 757 * dual-link LVDS or dual-link DSI, the driver should try to not expose the 758 * tiling and virtualize both &drm_crtc and &drm_plane if needed. Drivers 759 * should update this value using drm_mode_connector_set_tile_property(). 760 * Userspace cannot change this property. 761 * link-status: 762 * Connector link-status property to indicate the status of link. The default 763 * value of link-status is "GOOD". If something fails during or after modeset, 764 * the kernel driver may set this to "BAD" and issue a hotplug uevent. Drivers 765 * should update this value using drm_mode_connector_set_link_status_property(). 766 * 767 * Connectors also have one standardized atomic property: 768 * 769 * CRTC_ID: 770 * Mode object ID of the &drm_crtc this connector should be connected to. 771 */ 772 773 int drm_connector_create_standard_properties(struct drm_device *dev) 774 { 775 struct drm_property *prop; 776 777 prop = drm_property_create(dev, DRM_MODE_PROP_BLOB | 778 DRM_MODE_PROP_IMMUTABLE, 779 "EDID", 0); 780 if (!prop) 781 return -ENOMEM; 782 dev->mode_config.edid_property = prop; 783 784 prop = drm_property_create_enum(dev, 0, 785 "DPMS", drm_dpms_enum_list, 786 ARRAY_SIZE(drm_dpms_enum_list)); 787 if (!prop) 788 return -ENOMEM; 789 dev->mode_config.dpms_property = prop; 790 791 prop = drm_property_create(dev, 792 DRM_MODE_PROP_BLOB | 793 DRM_MODE_PROP_IMMUTABLE, 794 "PATH", 0); 795 if (!prop) 796 return -ENOMEM; 797 dev->mode_config.path_property = prop; 798 799 prop = drm_property_create(dev, 800 DRM_MODE_PROP_BLOB | 801 DRM_MODE_PROP_IMMUTABLE, 802 "TILE", 0); 803 if (!prop) 804 return -ENOMEM; 805 dev->mode_config.tile_property = prop; 806 807 prop = drm_property_create_enum(dev, 0, "link-status", 808 drm_link_status_enum_list, 809 ARRAY_SIZE(drm_link_status_enum_list)); 810 if (!prop) 811 return -ENOMEM; 812 dev->mode_config.link_status_property = prop; 813 814 return 0; 815 } 816 817 /** 818 * drm_mode_create_dvi_i_properties - create DVI-I specific connector properties 819 * @dev: DRM device 820 * 821 * Called by a driver the first time a DVI-I connector is made. 822 */ 823 int drm_mode_create_dvi_i_properties(struct drm_device *dev) 824 { 825 struct drm_property *dvi_i_selector; 826 struct drm_property *dvi_i_subconnector; 827 828 if (dev->mode_config.dvi_i_select_subconnector_property) 829 return 0; 830 831 dvi_i_selector = 832 drm_property_create_enum(dev, 0, 833 "select subconnector", 834 drm_dvi_i_select_enum_list, 835 ARRAY_SIZE(drm_dvi_i_select_enum_list)); 836 dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector; 837 838 dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 839 "subconnector", 840 drm_dvi_i_subconnector_enum_list, 841 ARRAY_SIZE(drm_dvi_i_subconnector_enum_list)); 842 dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector; 843 844 return 0; 845 } 846 EXPORT_SYMBOL(drm_mode_create_dvi_i_properties); 847 848 /** 849 * drm_create_tv_properties - create TV specific connector properties 850 * @dev: DRM device 851 * @num_modes: number of different TV formats (modes) supported 852 * @modes: array of pointers to strings containing name of each format 853 * 854 * Called by a driver's TV initialization routine, this function creates 855 * the TV specific connector properties for a given device. Caller is 856 * responsible for allocating a list of format names and passing them to 857 * this routine. 858 */ 859 int drm_mode_create_tv_properties(struct drm_device *dev, 860 unsigned int num_modes, 861 const char * const modes[]) 862 { 863 struct drm_property *tv_selector; 864 struct drm_property *tv_subconnector; 865 unsigned int i; 866 867 if (dev->mode_config.tv_select_subconnector_property) 868 return 0; 869 870 /* 871 * Basic connector properties 872 */ 873 tv_selector = drm_property_create_enum(dev, 0, 874 "select subconnector", 875 drm_tv_select_enum_list, 876 ARRAY_SIZE(drm_tv_select_enum_list)); 877 if (!tv_selector) 878 goto nomem; 879 880 dev->mode_config.tv_select_subconnector_property = tv_selector; 881 882 tv_subconnector = 883 drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 884 "subconnector", 885 drm_tv_subconnector_enum_list, 886 ARRAY_SIZE(drm_tv_subconnector_enum_list)); 887 if (!tv_subconnector) 888 goto nomem; 889 dev->mode_config.tv_subconnector_property = tv_subconnector; 890 891 /* 892 * Other, TV specific properties: margins & TV modes. 893 */ 894 dev->mode_config.tv_left_margin_property = 895 drm_property_create_range(dev, 0, "left margin", 0, 100); 896 if (!dev->mode_config.tv_left_margin_property) 897 goto nomem; 898 899 dev->mode_config.tv_right_margin_property = 900 drm_property_create_range(dev, 0, "right margin", 0, 100); 901 if (!dev->mode_config.tv_right_margin_property) 902 goto nomem; 903 904 dev->mode_config.tv_top_margin_property = 905 drm_property_create_range(dev, 0, "top margin", 0, 100); 906 if (!dev->mode_config.tv_top_margin_property) 907 goto nomem; 908 909 dev->mode_config.tv_bottom_margin_property = 910 drm_property_create_range(dev, 0, "bottom margin", 0, 100); 911 if (!dev->mode_config.tv_bottom_margin_property) 912 goto nomem; 913 914 dev->mode_config.tv_mode_property = 915 drm_property_create(dev, DRM_MODE_PROP_ENUM, 916 "mode", num_modes); 917 if (!dev->mode_config.tv_mode_property) 918 goto nomem; 919 920 for (i = 0; i < num_modes; i++) 921 drm_property_add_enum(dev->mode_config.tv_mode_property, i, 922 i, modes[i]); 923 924 dev->mode_config.tv_brightness_property = 925 drm_property_create_range(dev, 0, "brightness", 0, 100); 926 if (!dev->mode_config.tv_brightness_property) 927 goto nomem; 928 929 dev->mode_config.tv_contrast_property = 930 drm_property_create_range(dev, 0, "contrast", 0, 100); 931 if (!dev->mode_config.tv_contrast_property) 932 goto nomem; 933 934 dev->mode_config.tv_flicker_reduction_property = 935 drm_property_create_range(dev, 0, "flicker reduction", 0, 100); 936 if (!dev->mode_config.tv_flicker_reduction_property) 937 goto nomem; 938 939 dev->mode_config.tv_overscan_property = 940 drm_property_create_range(dev, 0, "overscan", 0, 100); 941 if (!dev->mode_config.tv_overscan_property) 942 goto nomem; 943 944 dev->mode_config.tv_saturation_property = 945 drm_property_create_range(dev, 0, "saturation", 0, 100); 946 if (!dev->mode_config.tv_saturation_property) 947 goto nomem; 948 949 dev->mode_config.tv_hue_property = 950 drm_property_create_range(dev, 0, "hue", 0, 100); 951 if (!dev->mode_config.tv_hue_property) 952 goto nomem; 953 954 return 0; 955 nomem: 956 return -ENOMEM; 957 } 958 EXPORT_SYMBOL(drm_mode_create_tv_properties); 959 960 /** 961 * drm_mode_create_scaling_mode_property - create scaling mode property 962 * @dev: DRM device 963 * 964 * Called by a driver the first time it's needed, must be attached to desired 965 * connectors. 966 * 967 * Atomic drivers should use drm_connector_attach_scaling_mode_property() 968 * instead to correctly assign &drm_connector_state.picture_aspect_ratio 969 * in the atomic state. 970 */ 971 int drm_mode_create_scaling_mode_property(struct drm_device *dev) 972 { 973 struct drm_property *scaling_mode; 974 975 if (dev->mode_config.scaling_mode_property) 976 return 0; 977 978 scaling_mode = 979 drm_property_create_enum(dev, 0, "scaling mode", 980 drm_scaling_mode_enum_list, 981 ARRAY_SIZE(drm_scaling_mode_enum_list)); 982 983 dev->mode_config.scaling_mode_property = scaling_mode; 984 985 return 0; 986 } 987 EXPORT_SYMBOL(drm_mode_create_scaling_mode_property); 988 989 /** 990 * drm_connector_attach_scaling_mode_property - attach atomic scaling mode property 991 * @connector: connector to attach scaling mode property on. 992 * @scaling_mode_mask: or'ed mask of BIT(%DRM_MODE_SCALE_\*). 993 * 994 * This is used to add support for scaling mode to atomic drivers. 995 * The scaling mode will be set to &drm_connector_state.picture_aspect_ratio 996 * and can be used from &drm_connector_helper_funcs->atomic_check for validation. 997 * 998 * This is the atomic version of drm_mode_create_scaling_mode_property(). 999 * 1000 * Returns: 1001 * Zero on success, negative errno on failure. 1002 */ 1003 int drm_connector_attach_scaling_mode_property(struct drm_connector *connector, 1004 u32 scaling_mode_mask) 1005 { 1006 struct drm_device *dev = connector->dev; 1007 struct drm_property *scaling_mode_property; 1008 int i, j = 0; 1009 const unsigned valid_scaling_mode_mask = 1010 (1U << ARRAY_SIZE(drm_scaling_mode_enum_list)) - 1; 1011 1012 if (WARN_ON(hweight32(scaling_mode_mask) < 2 || 1013 scaling_mode_mask & ~valid_scaling_mode_mask)) 1014 return -EINVAL; 1015 1016 scaling_mode_property = 1017 drm_property_create(dev, DRM_MODE_PROP_ENUM, "scaling mode", 1018 hweight32(scaling_mode_mask)); 1019 1020 if (!scaling_mode_property) 1021 return -ENOMEM; 1022 1023 for (i = 0; i < ARRAY_SIZE(drm_scaling_mode_enum_list); i++) { 1024 int ret; 1025 1026 if (!(BIT(i) & scaling_mode_mask)) 1027 continue; 1028 1029 ret = drm_property_add_enum(scaling_mode_property, j++, 1030 drm_scaling_mode_enum_list[i].type, 1031 drm_scaling_mode_enum_list[i].name); 1032 1033 if (ret) { 1034 drm_property_destroy(dev, scaling_mode_property); 1035 1036 return ret; 1037 } 1038 } 1039 1040 drm_object_attach_property(&connector->base, 1041 scaling_mode_property, 0); 1042 1043 connector->scaling_mode_property = scaling_mode_property; 1044 1045 return 0; 1046 } 1047 EXPORT_SYMBOL(drm_connector_attach_scaling_mode_property); 1048 1049 /** 1050 * drm_mode_create_aspect_ratio_property - create aspect ratio property 1051 * @dev: DRM device 1052 * 1053 * Called by a driver the first time it's needed, must be attached to desired 1054 * connectors. 1055 * 1056 * Returns: 1057 * Zero on success, negative errno on failure. 1058 */ 1059 int drm_mode_create_aspect_ratio_property(struct drm_device *dev) 1060 { 1061 if (dev->mode_config.aspect_ratio_property) 1062 return 0; 1063 1064 dev->mode_config.aspect_ratio_property = 1065 drm_property_create_enum(dev, 0, "aspect ratio", 1066 drm_aspect_ratio_enum_list, 1067 ARRAY_SIZE(drm_aspect_ratio_enum_list)); 1068 1069 if (dev->mode_config.aspect_ratio_property == NULL) 1070 return -ENOMEM; 1071 1072 return 0; 1073 } 1074 EXPORT_SYMBOL(drm_mode_create_aspect_ratio_property); 1075 1076 /** 1077 * drm_mode_create_suggested_offset_properties - create suggests offset properties 1078 * @dev: DRM device 1079 * 1080 * Create the the suggested x/y offset property for connectors. 1081 */ 1082 int drm_mode_create_suggested_offset_properties(struct drm_device *dev) 1083 { 1084 if (dev->mode_config.suggested_x_property && dev->mode_config.suggested_y_property) 1085 return 0; 1086 1087 dev->mode_config.suggested_x_property = 1088 drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested X", 0, 0xffffffff); 1089 1090 dev->mode_config.suggested_y_property = 1091 drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested Y", 0, 0xffffffff); 1092 1093 if (dev->mode_config.suggested_x_property == NULL || 1094 dev->mode_config.suggested_y_property == NULL) 1095 return -ENOMEM; 1096 return 0; 1097 } 1098 EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties); 1099 1100 /** 1101 * drm_mode_connector_set_path_property - set tile property on connector 1102 * @connector: connector to set property on. 1103 * @path: path to use for property; must not be NULL. 1104 * 1105 * This creates a property to expose to userspace to specify a 1106 * connector path. This is mainly used for DisplayPort MST where 1107 * connectors have a topology and we want to allow userspace to give 1108 * them more meaningful names. 1109 * 1110 * Returns: 1111 * Zero on success, negative errno on failure. 1112 */ 1113 int drm_mode_connector_set_path_property(struct drm_connector *connector, 1114 const char *path) 1115 { 1116 struct drm_device *dev = connector->dev; 1117 int ret; 1118 1119 ret = drm_property_replace_global_blob(dev, 1120 &connector->path_blob_ptr, 1121 strlen(path) + 1, 1122 path, 1123 &connector->base, 1124 dev->mode_config.path_property); 1125 return ret; 1126 } 1127 EXPORT_SYMBOL(drm_mode_connector_set_path_property); 1128 1129 /** 1130 * drm_mode_connector_set_tile_property - set tile property on connector 1131 * @connector: connector to set property on. 1132 * 1133 * This looks up the tile information for a connector, and creates a 1134 * property for userspace to parse if it exists. The property is of 1135 * the form of 8 integers using ':' as a separator. 1136 * 1137 * Returns: 1138 * Zero on success, errno on failure. 1139 */ 1140 int drm_mode_connector_set_tile_property(struct drm_connector *connector) 1141 { 1142 struct drm_device *dev = connector->dev; 1143 char tile[256]; 1144 int ret; 1145 1146 if (!connector->has_tile) { 1147 ret = drm_property_replace_global_blob(dev, 1148 &connector->tile_blob_ptr, 1149 0, 1150 NULL, 1151 &connector->base, 1152 dev->mode_config.tile_property); 1153 return ret; 1154 } 1155 1156 snprintf(tile, 256, "%d:%d:%d:%d:%d:%d:%d:%d", 1157 connector->tile_group->id, connector->tile_is_single_monitor, 1158 connector->num_h_tile, connector->num_v_tile, 1159 connector->tile_h_loc, connector->tile_v_loc, 1160 connector->tile_h_size, connector->tile_v_size); 1161 1162 ret = drm_property_replace_global_blob(dev, 1163 &connector->tile_blob_ptr, 1164 strlen(tile) + 1, 1165 tile, 1166 &connector->base, 1167 dev->mode_config.tile_property); 1168 return ret; 1169 } 1170 EXPORT_SYMBOL(drm_mode_connector_set_tile_property); 1171 1172 /** 1173 * drm_mode_connector_update_edid_property - update the edid property of a connector 1174 * @connector: drm connector 1175 * @edid: new value of the edid property 1176 * 1177 * This function creates a new blob modeset object and assigns its id to the 1178 * connector's edid property. 1179 * 1180 * Returns: 1181 * Zero on success, negative errno on failure. 1182 */ 1183 int drm_mode_connector_update_edid_property(struct drm_connector *connector, 1184 const struct edid *edid) 1185 { 1186 struct drm_device *dev = connector->dev; 1187 size_t size = 0; 1188 int ret; 1189 1190 /* ignore requests to set edid when overridden */ 1191 if (connector->override_edid) 1192 return 0; 1193 1194 if (edid) 1195 size = EDID_LENGTH * (1 + edid->extensions); 1196 1197 ret = drm_property_replace_global_blob(dev, 1198 &connector->edid_blob_ptr, 1199 size, 1200 edid, 1201 &connector->base, 1202 dev->mode_config.edid_property); 1203 return ret; 1204 } 1205 EXPORT_SYMBOL(drm_mode_connector_update_edid_property); 1206 1207 /** 1208 * drm_mode_connector_set_link_status_property - Set link status property of a connector 1209 * @connector: drm connector 1210 * @link_status: new value of link status property (0: Good, 1: Bad) 1211 * 1212 * In usual working scenario, this link status property will always be set to 1213 * "GOOD". If something fails during or after a mode set, the kernel driver 1214 * may set this link status property to "BAD". The caller then needs to send a 1215 * hotplug uevent for userspace to re-check the valid modes through 1216 * GET_CONNECTOR_IOCTL and retry modeset. 1217 * 1218 * Note: Drivers cannot rely on userspace to support this property and 1219 * issue a modeset. As such, they may choose to handle issues (like 1220 * re-training a link) without userspace's intervention. 1221 * 1222 * The reason for adding this property is to handle link training failures, but 1223 * it is not limited to DP or link training. For example, if we implement 1224 * asynchronous setcrtc, this property can be used to report any failures in that. 1225 */ 1226 void drm_mode_connector_set_link_status_property(struct drm_connector *connector, 1227 uint64_t link_status) 1228 { 1229 struct drm_device *dev = connector->dev; 1230 1231 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 1232 connector->state->link_status = link_status; 1233 drm_modeset_unlock(&dev->mode_config.connection_mutex); 1234 } 1235 EXPORT_SYMBOL(drm_mode_connector_set_link_status_property); 1236 1237 int drm_mode_connector_set_obj_prop(struct drm_mode_object *obj, 1238 struct drm_property *property, 1239 uint64_t value) 1240 { 1241 int ret = -EINVAL; 1242 struct drm_connector *connector = obj_to_connector(obj); 1243 1244 /* Do DPMS ourselves */ 1245 if (property == connector->dev->mode_config.dpms_property) { 1246 ret = (*connector->funcs->dpms)(connector, (int)value); 1247 } else if (connector->funcs->set_property) 1248 ret = connector->funcs->set_property(connector, property, value); 1249 1250 if (!ret) 1251 drm_object_property_set_value(&connector->base, property, value); 1252 return ret; 1253 } 1254 1255 int drm_mode_connector_property_set_ioctl(struct drm_device *dev, 1256 void *data, struct drm_file *file_priv) 1257 { 1258 struct drm_mode_connector_set_property *conn_set_prop = data; 1259 struct drm_mode_obj_set_property obj_set_prop = { 1260 .value = conn_set_prop->value, 1261 .prop_id = conn_set_prop->prop_id, 1262 .obj_id = conn_set_prop->connector_id, 1263 .obj_type = DRM_MODE_OBJECT_CONNECTOR 1264 }; 1265 1266 /* It does all the locking and checking we need */ 1267 return drm_mode_obj_set_property_ioctl(dev, &obj_set_prop, file_priv); 1268 } 1269 1270 static struct drm_encoder *drm_connector_get_encoder(struct drm_connector *connector) 1271 { 1272 /* For atomic drivers only state objects are synchronously updated and 1273 * protected by modeset locks, so check those first. */ 1274 if (connector->state) 1275 return connector->state->best_encoder; 1276 return connector->encoder; 1277 } 1278 1279 static bool drm_mode_expose_to_userspace(const struct drm_display_mode *mode, 1280 const struct drm_file *file_priv) 1281 { 1282 /* 1283 * If user-space hasn't configured the driver to expose the stereo 3D 1284 * modes, don't expose them. 1285 */ 1286 if (!file_priv->stereo_allowed && drm_mode_is_stereo(mode)) 1287 return false; 1288 1289 return true; 1290 } 1291 1292 int drm_mode_getconnector(struct drm_device *dev, void *data, 1293 struct drm_file *file_priv) 1294 { 1295 struct drm_mode_get_connector *out_resp = data; 1296 struct drm_connector *connector; 1297 struct drm_encoder *encoder; 1298 struct drm_display_mode *mode; 1299 int mode_count = 0; 1300 int encoders_count = 0; 1301 int ret = 0; 1302 int copied = 0; 1303 int i; 1304 struct drm_mode_modeinfo u_mode; 1305 struct drm_mode_modeinfo __user *mode_ptr; 1306 uint32_t __user *encoder_ptr; 1307 1308 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1309 return -EINVAL; 1310 1311 memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo)); 1312 1313 connector = drm_connector_lookup(dev, file_priv, out_resp->connector_id); 1314 if (!connector) 1315 return -ENOENT; 1316 1317 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) 1318 if (connector->encoder_ids[i] != 0) 1319 encoders_count++; 1320 1321 if ((out_resp->count_encoders >= encoders_count) && encoders_count) { 1322 copied = 0; 1323 encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr); 1324 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 1325 if (connector->encoder_ids[i] != 0) { 1326 if (put_user(connector->encoder_ids[i], 1327 encoder_ptr + copied)) { 1328 ret = -EFAULT; 1329 goto out; 1330 } 1331 copied++; 1332 } 1333 } 1334 } 1335 out_resp->count_encoders = encoders_count; 1336 1337 out_resp->connector_id = connector->base.id; 1338 out_resp->connector_type = connector->connector_type; 1339 out_resp->connector_type_id = connector->connector_type_id; 1340 1341 mutex_lock(&dev->mode_config.mutex); 1342 if (out_resp->count_modes == 0) { 1343 connector->funcs->fill_modes(connector, 1344 dev->mode_config.max_width, 1345 dev->mode_config.max_height); 1346 } 1347 1348 out_resp->mm_width = connector->display_info.width_mm; 1349 out_resp->mm_height = connector->display_info.height_mm; 1350 out_resp->subpixel = connector->display_info.subpixel_order; 1351 out_resp->connection = connector->status; 1352 1353 /* delayed so we get modes regardless of pre-fill_modes state */ 1354 list_for_each_entry(mode, &connector->modes, head) 1355 if (drm_mode_expose_to_userspace(mode, file_priv)) 1356 mode_count++; 1357 1358 /* 1359 * This ioctl is called twice, once to determine how much space is 1360 * needed, and the 2nd time to fill it. 1361 */ 1362 if ((out_resp->count_modes >= mode_count) && mode_count) { 1363 copied = 0; 1364 mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr; 1365 list_for_each_entry(mode, &connector->modes, head) { 1366 if (!drm_mode_expose_to_userspace(mode, file_priv)) 1367 continue; 1368 1369 drm_mode_convert_to_umode(&u_mode, mode); 1370 if (copy_to_user(mode_ptr + copied, 1371 &u_mode, sizeof(u_mode))) { 1372 ret = -EFAULT; 1373 mutex_unlock(&dev->mode_config.mutex); 1374 1375 goto out; 1376 } 1377 copied++; 1378 } 1379 } 1380 out_resp->count_modes = mode_count; 1381 mutex_unlock(&dev->mode_config.mutex); 1382 1383 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 1384 encoder = drm_connector_get_encoder(connector); 1385 if (encoder) 1386 out_resp->encoder_id = encoder->base.id; 1387 else 1388 out_resp->encoder_id = 0; 1389 1390 /* Only grab properties after probing, to make sure EDID and other 1391 * properties reflect the latest status. */ 1392 ret = drm_mode_object_get_properties(&connector->base, file_priv->atomic, 1393 (uint32_t __user *)(unsigned long)(out_resp->props_ptr), 1394 (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr), 1395 &out_resp->count_props); 1396 drm_modeset_unlock(&dev->mode_config.connection_mutex); 1397 1398 out: 1399 drm_connector_put(connector); 1400 1401 return ret; 1402 } 1403 1404 1405 /** 1406 * DOC: Tile group 1407 * 1408 * Tile groups are used to represent tiled monitors with a unique integer 1409 * identifier. Tiled monitors using DisplayID v1.3 have a unique 8-byte handle, 1410 * we store this in a tile group, so we have a common identifier for all tiles 1411 * in a monitor group. The property is called "TILE". Drivers can manage tile 1412 * groups using drm_mode_create_tile_group(), drm_mode_put_tile_group() and 1413 * drm_mode_get_tile_group(). But this is only needed for internal panels where 1414 * the tile group information is exposed through a non-standard way. 1415 */ 1416 1417 static void drm_tile_group_free(struct kref *kref) 1418 { 1419 struct drm_tile_group *tg = container_of(kref, struct drm_tile_group, refcount); 1420 struct drm_device *dev = tg->dev; 1421 mutex_lock(&dev->mode_config.idr_mutex); 1422 idr_remove(&dev->mode_config.tile_idr, tg->id); 1423 mutex_unlock(&dev->mode_config.idr_mutex); 1424 kfree(tg); 1425 } 1426 1427 /** 1428 * drm_mode_put_tile_group - drop a reference to a tile group. 1429 * @dev: DRM device 1430 * @tg: tile group to drop reference to. 1431 * 1432 * drop reference to tile group and free if 0. 1433 */ 1434 void drm_mode_put_tile_group(struct drm_device *dev, 1435 struct drm_tile_group *tg) 1436 { 1437 kref_put(&tg->refcount, drm_tile_group_free); 1438 } 1439 EXPORT_SYMBOL(drm_mode_put_tile_group); 1440 1441 /** 1442 * drm_mode_get_tile_group - get a reference to an existing tile group 1443 * @dev: DRM device 1444 * @topology: 8-bytes unique per monitor. 1445 * 1446 * Use the unique bytes to get a reference to an existing tile group. 1447 * 1448 * RETURNS: 1449 * tile group or NULL if not found. 1450 */ 1451 struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev, 1452 char topology[8]) 1453 { 1454 struct drm_tile_group *tg; 1455 int id; 1456 mutex_lock(&dev->mode_config.idr_mutex); 1457 idr_for_each_entry(&dev->mode_config.tile_idr, tg, id) { 1458 if (!memcmp(tg->group_data, topology, 8)) { 1459 if (!kref_get_unless_zero(&tg->refcount)) 1460 tg = NULL; 1461 mutex_unlock(&dev->mode_config.idr_mutex); 1462 return tg; 1463 } 1464 } 1465 mutex_unlock(&dev->mode_config.idr_mutex); 1466 return NULL; 1467 } 1468 EXPORT_SYMBOL(drm_mode_get_tile_group); 1469 1470 /** 1471 * drm_mode_create_tile_group - create a tile group from a displayid description 1472 * @dev: DRM device 1473 * @topology: 8-bytes unique per monitor. 1474 * 1475 * Create a tile group for the unique monitor, and get a unique 1476 * identifier for the tile group. 1477 * 1478 * RETURNS: 1479 * new tile group or error. 1480 */ 1481 struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev, 1482 char topology[8]) 1483 { 1484 struct drm_tile_group *tg; 1485 int ret; 1486 1487 tg = kzalloc(sizeof(*tg), GFP_KERNEL); 1488 if (!tg) 1489 return ERR_PTR(-ENOMEM); 1490 1491 kref_init(&tg->refcount); 1492 memcpy(tg->group_data, topology, 8); 1493 tg->dev = dev; 1494 1495 mutex_lock(&dev->mode_config.idr_mutex); 1496 ret = idr_alloc(&dev->mode_config.tile_idr, tg, 1, 0, GFP_KERNEL); 1497 if (ret >= 0) { 1498 tg->id = ret; 1499 } else { 1500 kfree(tg); 1501 tg = ERR_PTR(ret); 1502 } 1503 1504 mutex_unlock(&dev->mode_config.idr_mutex); 1505 return tg; 1506 } 1507 EXPORT_SYMBOL(drm_mode_create_tile_group); 1508