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 27 #include "drm_crtc_internal.h" 28 #include "drm_internal.h" 29 30 /** 31 * DOC: overview 32 * 33 * In DRM connectors are the general abstraction for display sinks, and include 34 * als fixed panels or anything else that can display pixels in some form. As 35 * opposed to all other KMS objects representing hardware (like CRTC, encoder or 36 * plane abstractions) connectors can be hotplugged and unplugged at runtime. 37 * Hence they are reference-counted using drm_connector_reference() and 38 * drm_connector_unreference(). 39 * 40 * KMS driver must create, initialize, register and attach at a struct 41 * &drm_connector for each such sink. The instance is created as other KMS 42 * objects and initialized by setting the following fields. 43 * 44 * The connector is then registered with a call to drm_connector_init() with a 45 * pointer to the connector functions and a connector type, and exposed through 46 * sysfs 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 struct &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 const char *s; 132 133 switch (mode->force) { 134 case DRM_FORCE_OFF: 135 s = "OFF"; 136 break; 137 case DRM_FORCE_ON_DIGITAL: 138 s = "ON - dig"; 139 break; 140 default: 141 case DRM_FORCE_ON: 142 s = "ON"; 143 break; 144 } 145 146 DRM_INFO("forcing %s connector %s\n", connector->name, s); 147 connector->force = mode->force; 148 } 149 150 DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n", 151 connector->name, 152 mode->xres, mode->yres, 153 mode->refresh_specified ? mode->refresh : 60, 154 mode->rb ? " reduced blanking" : "", 155 mode->margins ? " with margins" : "", 156 mode->interlace ? " interlaced" : ""); 157 } 158 159 static void drm_connector_free(struct kref *kref) 160 { 161 struct drm_connector *connector = 162 container_of(kref, struct drm_connector, base.refcount); 163 struct drm_device *dev = connector->dev; 164 165 drm_mode_object_unregister(dev, &connector->base); 166 connector->funcs->destroy(connector); 167 } 168 169 /** 170 * drm_connector_init - Init a preallocated connector 171 * @dev: DRM device 172 * @connector: the connector to init 173 * @funcs: callbacks for this connector 174 * @connector_type: user visible type of the connector 175 * 176 * Initialises a preallocated connector. Connectors should be 177 * subclassed as part of driver connector objects. 178 * 179 * Returns: 180 * Zero on success, error code on failure. 181 */ 182 int drm_connector_init(struct drm_device *dev, 183 struct drm_connector *connector, 184 const struct drm_connector_funcs *funcs, 185 int connector_type) 186 { 187 struct drm_mode_config *config = &dev->mode_config; 188 int ret; 189 struct ida *connector_ida = 190 &drm_connector_enum_list[connector_type].ida; 191 192 drm_modeset_lock_all(dev); 193 194 ret = drm_mode_object_get_reg(dev, &connector->base, 195 DRM_MODE_OBJECT_CONNECTOR, 196 false, drm_connector_free); 197 if (ret) 198 goto out_unlock; 199 200 connector->base.properties = &connector->properties; 201 connector->dev = dev; 202 connector->funcs = funcs; 203 204 ret = ida_simple_get(&config->connector_ida, 0, 0, GFP_KERNEL); 205 if (ret < 0) 206 goto out_put; 207 connector->index = ret; 208 ret = 0; 209 210 connector->connector_type = connector_type; 211 connector->connector_type_id = 212 ida_simple_get(connector_ida, 1, 0, GFP_KERNEL); 213 if (connector->connector_type_id < 0) { 214 ret = connector->connector_type_id; 215 goto out_put_id; 216 } 217 connector->name = 218 kasprintf(GFP_KERNEL, "%s-%d", 219 drm_connector_enum_list[connector_type].name, 220 connector->connector_type_id); 221 if (!connector->name) { 222 ret = -ENOMEM; 223 goto out_put_type_id; 224 } 225 226 INIT_LIST_HEAD(&connector->probed_modes); 227 INIT_LIST_HEAD(&connector->modes); 228 connector->edid_blob_ptr = NULL; 229 connector->status = connector_status_unknown; 230 231 drm_connector_get_cmdline_mode(connector); 232 233 /* We should add connectors at the end to avoid upsetting the connector 234 * index too much. */ 235 list_add_tail(&connector->head, &config->connector_list); 236 config->num_connector++; 237 238 if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL) 239 drm_object_attach_property(&connector->base, 240 config->edid_property, 241 0); 242 243 drm_object_attach_property(&connector->base, 244 config->dpms_property, 0); 245 246 if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { 247 drm_object_attach_property(&connector->base, config->prop_crtc_id, 0); 248 } 249 250 connector->debugfs_entry = NULL; 251 out_put_type_id: 252 if (ret) 253 ida_simple_remove(connector_ida, connector->connector_type_id); 254 out_put_id: 255 if (ret) 256 ida_simple_remove(&config->connector_ida, connector->index); 257 out_put: 258 if (ret) 259 drm_mode_object_unregister(dev, &connector->base); 260 261 out_unlock: 262 drm_modeset_unlock_all(dev); 263 264 return ret; 265 } 266 EXPORT_SYMBOL(drm_connector_init); 267 268 /** 269 * drm_mode_connector_attach_encoder - attach a connector to an encoder 270 * @connector: connector to attach 271 * @encoder: encoder to attach @connector to 272 * 273 * This function links up a connector to an encoder. Note that the routing 274 * restrictions between encoders and crtcs are exposed to userspace through the 275 * possible_clones and possible_crtcs bitmasks. 276 * 277 * Returns: 278 * Zero on success, negative errno on failure. 279 */ 280 int drm_mode_connector_attach_encoder(struct drm_connector *connector, 281 struct drm_encoder *encoder) 282 { 283 int i; 284 285 /* 286 * In the past, drivers have attempted to model the static association 287 * of connector to encoder in simple connector/encoder devices using a 288 * direct assignment of connector->encoder = encoder. This connection 289 * is a logical one and the responsibility of the core, so drivers are 290 * expected not to mess with this. 291 * 292 * Note that the error return should've been enough here, but a large 293 * majority of drivers ignores the return value, so add in a big WARN 294 * to get people's attention. 295 */ 296 if (WARN_ON(connector->encoder)) 297 return -EINVAL; 298 299 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 300 if (connector->encoder_ids[i] == 0) { 301 connector->encoder_ids[i] = encoder->base.id; 302 return 0; 303 } 304 } 305 return -ENOMEM; 306 } 307 EXPORT_SYMBOL(drm_mode_connector_attach_encoder); 308 309 static void drm_mode_remove(struct drm_connector *connector, 310 struct drm_display_mode *mode) 311 { 312 list_del(&mode->head); 313 drm_mode_destroy(connector->dev, mode); 314 } 315 316 /** 317 * drm_connector_cleanup - cleans up an initialised connector 318 * @connector: connector to cleanup 319 * 320 * Cleans up the connector but doesn't free the object. 321 */ 322 void drm_connector_cleanup(struct drm_connector *connector) 323 { 324 struct drm_device *dev = connector->dev; 325 struct drm_display_mode *mode, *t; 326 327 /* The connector should have been removed from userspace long before 328 * it is finally destroyed. 329 */ 330 if (WARN_ON(connector->registered)) 331 drm_connector_unregister(connector); 332 333 if (connector->tile_group) { 334 drm_mode_put_tile_group(dev, connector->tile_group); 335 connector->tile_group = NULL; 336 } 337 338 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) 339 drm_mode_remove(connector, mode); 340 341 list_for_each_entry_safe(mode, t, &connector->modes, head) 342 drm_mode_remove(connector, mode); 343 344 ida_simple_remove(&drm_connector_enum_list[connector->connector_type].ida, 345 connector->connector_type_id); 346 347 ida_simple_remove(&dev->mode_config.connector_ida, 348 connector->index); 349 350 kfree(connector->display_info.bus_formats); 351 drm_mode_object_unregister(dev, &connector->base); 352 kfree(connector->name); 353 connector->name = NULL; 354 list_del(&connector->head); 355 dev->mode_config.num_connector--; 356 357 WARN_ON(connector->state && !connector->funcs->atomic_destroy_state); 358 if (connector->state && connector->funcs->atomic_destroy_state) 359 connector->funcs->atomic_destroy_state(connector, 360 connector->state); 361 362 memset(connector, 0, sizeof(*connector)); 363 } 364 EXPORT_SYMBOL(drm_connector_cleanup); 365 366 /** 367 * drm_connector_register - register a connector 368 * @connector: the connector to register 369 * 370 * Register userspace interfaces for a connector 371 * 372 * Returns: 373 * Zero on success, error code on failure. 374 */ 375 int drm_connector_register(struct drm_connector *connector) 376 { 377 int ret; 378 379 if (connector->registered) 380 return 0; 381 382 ret = drm_sysfs_connector_add(connector); 383 if (ret) 384 return ret; 385 386 ret = drm_debugfs_connector_add(connector); 387 if (ret) { 388 goto err_sysfs; 389 } 390 391 if (connector->funcs->late_register) { 392 ret = connector->funcs->late_register(connector); 393 if (ret) 394 goto err_debugfs; 395 } 396 397 drm_mode_object_register(connector->dev, &connector->base); 398 399 connector->registered = true; 400 return 0; 401 402 err_debugfs: 403 drm_debugfs_connector_remove(connector); 404 err_sysfs: 405 drm_sysfs_connector_remove(connector); 406 return ret; 407 } 408 EXPORT_SYMBOL(drm_connector_register); 409 410 /** 411 * drm_connector_unregister - unregister a connector 412 * @connector: the connector to unregister 413 * 414 * Unregister userspace interfaces for a connector 415 */ 416 void drm_connector_unregister(struct drm_connector *connector) 417 { 418 if (!connector->registered) 419 return; 420 421 if (connector->funcs->early_unregister) 422 connector->funcs->early_unregister(connector); 423 424 drm_sysfs_connector_remove(connector); 425 drm_debugfs_connector_remove(connector); 426 427 connector->registered = false; 428 } 429 EXPORT_SYMBOL(drm_connector_unregister); 430 431 void drm_connector_unregister_all(struct drm_device *dev) 432 { 433 struct drm_connector *connector; 434 435 /* FIXME: taking the mode config mutex ends up in a clash with sysfs */ 436 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 437 drm_connector_unregister(connector); 438 } 439 440 int drm_connector_register_all(struct drm_device *dev) 441 { 442 struct drm_connector *connector; 443 int ret; 444 445 /* FIXME: taking the mode config mutex ends up in a clash with 446 * fbcon/backlight registration */ 447 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 448 ret = drm_connector_register(connector); 449 if (ret) 450 goto err; 451 } 452 453 return 0; 454 455 err: 456 mutex_unlock(&dev->mode_config.mutex); 457 drm_connector_unregister_all(dev); 458 return ret; 459 } 460 461 /** 462 * drm_get_connector_status_name - return a string for connector status 463 * @status: connector status to compute name of 464 * 465 * In contrast to the other drm_get_*_name functions this one here returns a 466 * const pointer and hence is threadsafe. 467 */ 468 const char *drm_get_connector_status_name(enum drm_connector_status status) 469 { 470 if (status == connector_status_connected) 471 return "connected"; 472 else if (status == connector_status_disconnected) 473 return "disconnected"; 474 else 475 return "unknown"; 476 } 477 EXPORT_SYMBOL(drm_get_connector_status_name); 478 479 static const struct drm_prop_enum_list drm_subpixel_enum_list[] = { 480 { SubPixelUnknown, "Unknown" }, 481 { SubPixelHorizontalRGB, "Horizontal RGB" }, 482 { SubPixelHorizontalBGR, "Horizontal BGR" }, 483 { SubPixelVerticalRGB, "Vertical RGB" }, 484 { SubPixelVerticalBGR, "Vertical BGR" }, 485 { SubPixelNone, "None" }, 486 }; 487 488 /** 489 * drm_get_subpixel_order_name - return a string for a given subpixel enum 490 * @order: enum of subpixel_order 491 * 492 * Note you could abuse this and return something out of bounds, but that 493 * would be a caller error. No unscrubbed user data should make it here. 494 */ 495 const char *drm_get_subpixel_order_name(enum subpixel_order order) 496 { 497 return drm_subpixel_enum_list[order].name; 498 } 499 EXPORT_SYMBOL(drm_get_subpixel_order_name); 500 501 static const struct drm_prop_enum_list drm_dpms_enum_list[] = { 502 { DRM_MODE_DPMS_ON, "On" }, 503 { DRM_MODE_DPMS_STANDBY, "Standby" }, 504 { DRM_MODE_DPMS_SUSPEND, "Suspend" }, 505 { DRM_MODE_DPMS_OFF, "Off" } 506 }; 507 DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list) 508 509 /** 510 * drm_display_info_set_bus_formats - set the supported bus formats 511 * @info: display info to store bus formats in 512 * @formats: array containing the supported bus formats 513 * @num_formats: the number of entries in the fmts array 514 * 515 * Store the supported bus formats in display info structure. 516 * See MEDIA_BUS_FMT_* definitions in include/uapi/linux/media-bus-format.h for 517 * a full list of available formats. 518 */ 519 int drm_display_info_set_bus_formats(struct drm_display_info *info, 520 const u32 *formats, 521 unsigned int num_formats) 522 { 523 u32 *fmts = NULL; 524 525 if (!formats && num_formats) 526 return -EINVAL; 527 528 if (formats && num_formats) { 529 fmts = kmemdup(formats, sizeof(*formats) * num_formats, 530 GFP_KERNEL); 531 if (!fmts) 532 return -ENOMEM; 533 } 534 535 kfree(info->bus_formats); 536 info->bus_formats = fmts; 537 info->num_bus_formats = num_formats; 538 539 return 0; 540 } 541 EXPORT_SYMBOL(drm_display_info_set_bus_formats); 542 543 /* Optional connector properties. */ 544 static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] = { 545 { DRM_MODE_SCALE_NONE, "None" }, 546 { DRM_MODE_SCALE_FULLSCREEN, "Full" }, 547 { DRM_MODE_SCALE_CENTER, "Center" }, 548 { DRM_MODE_SCALE_ASPECT, "Full aspect" }, 549 }; 550 551 static const struct drm_prop_enum_list drm_aspect_ratio_enum_list[] = { 552 { DRM_MODE_PICTURE_ASPECT_NONE, "Automatic" }, 553 { DRM_MODE_PICTURE_ASPECT_4_3, "4:3" }, 554 { DRM_MODE_PICTURE_ASPECT_16_9, "16:9" }, 555 }; 556 557 static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = { 558 { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ 559 { DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ 560 { DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ 561 }; 562 DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list) 563 564 static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = { 565 { DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */ 566 { DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ 567 { DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ 568 }; 569 DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name, 570 drm_dvi_i_subconnector_enum_list) 571 572 static const struct drm_prop_enum_list drm_tv_select_enum_list[] = { 573 { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ 574 { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ 575 { DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ 576 { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */ 577 { DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */ 578 }; 579 DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list) 580 581 static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = { 582 { DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */ 583 { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ 584 { DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ 585 { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */ 586 { DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */ 587 }; 588 DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name, 589 drm_tv_subconnector_enum_list) 590 591 int drm_connector_create_standard_properties(struct drm_device *dev) 592 { 593 struct drm_property *prop; 594 595 prop = drm_property_create(dev, DRM_MODE_PROP_BLOB | 596 DRM_MODE_PROP_IMMUTABLE, 597 "EDID", 0); 598 if (!prop) 599 return -ENOMEM; 600 dev->mode_config.edid_property = prop; 601 602 prop = drm_property_create_enum(dev, 0, 603 "DPMS", drm_dpms_enum_list, 604 ARRAY_SIZE(drm_dpms_enum_list)); 605 if (!prop) 606 return -ENOMEM; 607 dev->mode_config.dpms_property = prop; 608 609 prop = drm_property_create(dev, 610 DRM_MODE_PROP_BLOB | 611 DRM_MODE_PROP_IMMUTABLE, 612 "PATH", 0); 613 if (!prop) 614 return -ENOMEM; 615 dev->mode_config.path_property = prop; 616 617 prop = drm_property_create(dev, 618 DRM_MODE_PROP_BLOB | 619 DRM_MODE_PROP_IMMUTABLE, 620 "TILE", 0); 621 if (!prop) 622 return -ENOMEM; 623 dev->mode_config.tile_property = prop; 624 625 return 0; 626 } 627 628 /** 629 * drm_mode_create_dvi_i_properties - create DVI-I specific connector properties 630 * @dev: DRM device 631 * 632 * Called by a driver the first time a DVI-I connector is made. 633 */ 634 int drm_mode_create_dvi_i_properties(struct drm_device *dev) 635 { 636 struct drm_property *dvi_i_selector; 637 struct drm_property *dvi_i_subconnector; 638 639 if (dev->mode_config.dvi_i_select_subconnector_property) 640 return 0; 641 642 dvi_i_selector = 643 drm_property_create_enum(dev, 0, 644 "select subconnector", 645 drm_dvi_i_select_enum_list, 646 ARRAY_SIZE(drm_dvi_i_select_enum_list)); 647 dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector; 648 649 dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 650 "subconnector", 651 drm_dvi_i_subconnector_enum_list, 652 ARRAY_SIZE(drm_dvi_i_subconnector_enum_list)); 653 dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector; 654 655 return 0; 656 } 657 EXPORT_SYMBOL(drm_mode_create_dvi_i_properties); 658 659 /** 660 * drm_create_tv_properties - create TV specific connector properties 661 * @dev: DRM device 662 * @num_modes: number of different TV formats (modes) supported 663 * @modes: array of pointers to strings containing name of each format 664 * 665 * Called by a driver's TV initialization routine, this function creates 666 * the TV specific connector properties for a given device. Caller is 667 * responsible for allocating a list of format names and passing them to 668 * this routine. 669 */ 670 int drm_mode_create_tv_properties(struct drm_device *dev, 671 unsigned int num_modes, 672 const char * const modes[]) 673 { 674 struct drm_property *tv_selector; 675 struct drm_property *tv_subconnector; 676 unsigned int i; 677 678 if (dev->mode_config.tv_select_subconnector_property) 679 return 0; 680 681 /* 682 * Basic connector properties 683 */ 684 tv_selector = drm_property_create_enum(dev, 0, 685 "select subconnector", 686 drm_tv_select_enum_list, 687 ARRAY_SIZE(drm_tv_select_enum_list)); 688 if (!tv_selector) 689 goto nomem; 690 691 dev->mode_config.tv_select_subconnector_property = tv_selector; 692 693 tv_subconnector = 694 drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 695 "subconnector", 696 drm_tv_subconnector_enum_list, 697 ARRAY_SIZE(drm_tv_subconnector_enum_list)); 698 if (!tv_subconnector) 699 goto nomem; 700 dev->mode_config.tv_subconnector_property = tv_subconnector; 701 702 /* 703 * Other, TV specific properties: margins & TV modes. 704 */ 705 dev->mode_config.tv_left_margin_property = 706 drm_property_create_range(dev, 0, "left margin", 0, 100); 707 if (!dev->mode_config.tv_left_margin_property) 708 goto nomem; 709 710 dev->mode_config.tv_right_margin_property = 711 drm_property_create_range(dev, 0, "right margin", 0, 100); 712 if (!dev->mode_config.tv_right_margin_property) 713 goto nomem; 714 715 dev->mode_config.tv_top_margin_property = 716 drm_property_create_range(dev, 0, "top margin", 0, 100); 717 if (!dev->mode_config.tv_top_margin_property) 718 goto nomem; 719 720 dev->mode_config.tv_bottom_margin_property = 721 drm_property_create_range(dev, 0, "bottom margin", 0, 100); 722 if (!dev->mode_config.tv_bottom_margin_property) 723 goto nomem; 724 725 dev->mode_config.tv_mode_property = 726 drm_property_create(dev, DRM_MODE_PROP_ENUM, 727 "mode", num_modes); 728 if (!dev->mode_config.tv_mode_property) 729 goto nomem; 730 731 for (i = 0; i < num_modes; i++) 732 drm_property_add_enum(dev->mode_config.tv_mode_property, i, 733 i, modes[i]); 734 735 dev->mode_config.tv_brightness_property = 736 drm_property_create_range(dev, 0, "brightness", 0, 100); 737 if (!dev->mode_config.tv_brightness_property) 738 goto nomem; 739 740 dev->mode_config.tv_contrast_property = 741 drm_property_create_range(dev, 0, "contrast", 0, 100); 742 if (!dev->mode_config.tv_contrast_property) 743 goto nomem; 744 745 dev->mode_config.tv_flicker_reduction_property = 746 drm_property_create_range(dev, 0, "flicker reduction", 0, 100); 747 if (!dev->mode_config.tv_flicker_reduction_property) 748 goto nomem; 749 750 dev->mode_config.tv_overscan_property = 751 drm_property_create_range(dev, 0, "overscan", 0, 100); 752 if (!dev->mode_config.tv_overscan_property) 753 goto nomem; 754 755 dev->mode_config.tv_saturation_property = 756 drm_property_create_range(dev, 0, "saturation", 0, 100); 757 if (!dev->mode_config.tv_saturation_property) 758 goto nomem; 759 760 dev->mode_config.tv_hue_property = 761 drm_property_create_range(dev, 0, "hue", 0, 100); 762 if (!dev->mode_config.tv_hue_property) 763 goto nomem; 764 765 return 0; 766 nomem: 767 return -ENOMEM; 768 } 769 EXPORT_SYMBOL(drm_mode_create_tv_properties); 770 771 /** 772 * drm_mode_create_scaling_mode_property - create scaling mode property 773 * @dev: DRM device 774 * 775 * Called by a driver the first time it's needed, must be attached to desired 776 * connectors. 777 */ 778 int drm_mode_create_scaling_mode_property(struct drm_device *dev) 779 { 780 struct drm_property *scaling_mode; 781 782 if (dev->mode_config.scaling_mode_property) 783 return 0; 784 785 scaling_mode = 786 drm_property_create_enum(dev, 0, "scaling mode", 787 drm_scaling_mode_enum_list, 788 ARRAY_SIZE(drm_scaling_mode_enum_list)); 789 790 dev->mode_config.scaling_mode_property = scaling_mode; 791 792 return 0; 793 } 794 EXPORT_SYMBOL(drm_mode_create_scaling_mode_property); 795 796 /** 797 * drm_mode_create_aspect_ratio_property - create aspect ratio property 798 * @dev: DRM device 799 * 800 * Called by a driver the first time it's needed, must be attached to desired 801 * connectors. 802 * 803 * Returns: 804 * Zero on success, negative errno on failure. 805 */ 806 int drm_mode_create_aspect_ratio_property(struct drm_device *dev) 807 { 808 if (dev->mode_config.aspect_ratio_property) 809 return 0; 810 811 dev->mode_config.aspect_ratio_property = 812 drm_property_create_enum(dev, 0, "aspect ratio", 813 drm_aspect_ratio_enum_list, 814 ARRAY_SIZE(drm_aspect_ratio_enum_list)); 815 816 if (dev->mode_config.aspect_ratio_property == NULL) 817 return -ENOMEM; 818 819 return 0; 820 } 821 EXPORT_SYMBOL(drm_mode_create_aspect_ratio_property); 822 823 /** 824 * drm_mode_create_suggested_offset_properties - create suggests offset properties 825 * @dev: DRM device 826 * 827 * Create the the suggested x/y offset property for connectors. 828 */ 829 int drm_mode_create_suggested_offset_properties(struct drm_device *dev) 830 { 831 if (dev->mode_config.suggested_x_property && dev->mode_config.suggested_y_property) 832 return 0; 833 834 dev->mode_config.suggested_x_property = 835 drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested X", 0, 0xffffffff); 836 837 dev->mode_config.suggested_y_property = 838 drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested Y", 0, 0xffffffff); 839 840 if (dev->mode_config.suggested_x_property == NULL || 841 dev->mode_config.suggested_y_property == NULL) 842 return -ENOMEM; 843 return 0; 844 } 845 EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties); 846 847 /** 848 * drm_mode_connector_set_path_property - set tile property on connector 849 * @connector: connector to set property on. 850 * @path: path to use for property; must not be NULL. 851 * 852 * This creates a property to expose to userspace to specify a 853 * connector path. This is mainly used for DisplayPort MST where 854 * connectors have a topology and we want to allow userspace to give 855 * them more meaningful names. 856 * 857 * Returns: 858 * Zero on success, negative errno on failure. 859 */ 860 int drm_mode_connector_set_path_property(struct drm_connector *connector, 861 const char *path) 862 { 863 struct drm_device *dev = connector->dev; 864 int ret; 865 866 ret = drm_property_replace_global_blob(dev, 867 &connector->path_blob_ptr, 868 strlen(path) + 1, 869 path, 870 &connector->base, 871 dev->mode_config.path_property); 872 return ret; 873 } 874 EXPORT_SYMBOL(drm_mode_connector_set_path_property); 875 876 /** 877 * drm_mode_connector_set_tile_property - set tile property on connector 878 * @connector: connector to set property on. 879 * 880 * This looks up the tile information for a connector, and creates a 881 * property for userspace to parse if it exists. The property is of 882 * the form of 8 integers using ':' as a separator. 883 * 884 * Returns: 885 * Zero on success, errno on failure. 886 */ 887 int drm_mode_connector_set_tile_property(struct drm_connector *connector) 888 { 889 struct drm_device *dev = connector->dev; 890 char tile[256]; 891 int ret; 892 893 if (!connector->has_tile) { 894 ret = drm_property_replace_global_blob(dev, 895 &connector->tile_blob_ptr, 896 0, 897 NULL, 898 &connector->base, 899 dev->mode_config.tile_property); 900 return ret; 901 } 902 903 snprintf(tile, 256, "%d:%d:%d:%d:%d:%d:%d:%d", 904 connector->tile_group->id, connector->tile_is_single_monitor, 905 connector->num_h_tile, connector->num_v_tile, 906 connector->tile_h_loc, connector->tile_v_loc, 907 connector->tile_h_size, connector->tile_v_size); 908 909 ret = drm_property_replace_global_blob(dev, 910 &connector->tile_blob_ptr, 911 strlen(tile) + 1, 912 tile, 913 &connector->base, 914 dev->mode_config.tile_property); 915 return ret; 916 } 917 EXPORT_SYMBOL(drm_mode_connector_set_tile_property); 918 919 /** 920 * drm_mode_connector_update_edid_property - update the edid property of a connector 921 * @connector: drm connector 922 * @edid: new value of the edid property 923 * 924 * This function creates a new blob modeset object and assigns its id to the 925 * connector's edid property. 926 * 927 * Returns: 928 * Zero on success, negative errno on failure. 929 */ 930 int drm_mode_connector_update_edid_property(struct drm_connector *connector, 931 const struct edid *edid) 932 { 933 struct drm_device *dev = connector->dev; 934 size_t size = 0; 935 int ret; 936 937 /* ignore requests to set edid when overridden */ 938 if (connector->override_edid) 939 return 0; 940 941 if (edid) 942 size = EDID_LENGTH * (1 + edid->extensions); 943 944 ret = drm_property_replace_global_blob(dev, 945 &connector->edid_blob_ptr, 946 size, 947 edid, 948 &connector->base, 949 dev->mode_config.edid_property); 950 return ret; 951 } 952 EXPORT_SYMBOL(drm_mode_connector_update_edid_property); 953 954 int drm_mode_connector_set_obj_prop(struct drm_mode_object *obj, 955 struct drm_property *property, 956 uint64_t value) 957 { 958 int ret = -EINVAL; 959 struct drm_connector *connector = obj_to_connector(obj); 960 961 /* Do DPMS ourselves */ 962 if (property == connector->dev->mode_config.dpms_property) { 963 ret = (*connector->funcs->dpms)(connector, (int)value); 964 } else if (connector->funcs->set_property) 965 ret = connector->funcs->set_property(connector, property, value); 966 967 /* store the property value if successful */ 968 if (!ret) 969 drm_object_property_set_value(&connector->base, property, value); 970 return ret; 971 } 972 973 int drm_mode_connector_property_set_ioctl(struct drm_device *dev, 974 void *data, struct drm_file *file_priv) 975 { 976 struct drm_mode_connector_set_property *conn_set_prop = data; 977 struct drm_mode_obj_set_property obj_set_prop = { 978 .value = conn_set_prop->value, 979 .prop_id = conn_set_prop->prop_id, 980 .obj_id = conn_set_prop->connector_id, 981 .obj_type = DRM_MODE_OBJECT_CONNECTOR 982 }; 983 984 /* It does all the locking and checking we need */ 985 return drm_mode_obj_set_property_ioctl(dev, &obj_set_prop, file_priv); 986 } 987 988 static struct drm_encoder *drm_connector_get_encoder(struct drm_connector *connector) 989 { 990 /* For atomic drivers only state objects are synchronously updated and 991 * protected by modeset locks, so check those first. */ 992 if (connector->state) 993 return connector->state->best_encoder; 994 return connector->encoder; 995 } 996 997 static bool drm_mode_expose_to_userspace(const struct drm_display_mode *mode, 998 const struct drm_file *file_priv) 999 { 1000 /* 1001 * If user-space hasn't configured the driver to expose the stereo 3D 1002 * modes, don't expose them. 1003 */ 1004 if (!file_priv->stereo_allowed && drm_mode_is_stereo(mode)) 1005 return false; 1006 1007 return true; 1008 } 1009 1010 int drm_mode_getconnector(struct drm_device *dev, void *data, 1011 struct drm_file *file_priv) 1012 { 1013 struct drm_mode_get_connector *out_resp = data; 1014 struct drm_connector *connector; 1015 struct drm_encoder *encoder; 1016 struct drm_display_mode *mode; 1017 int mode_count = 0; 1018 int encoders_count = 0; 1019 int ret = 0; 1020 int copied = 0; 1021 int i; 1022 struct drm_mode_modeinfo u_mode; 1023 struct drm_mode_modeinfo __user *mode_ptr; 1024 uint32_t __user *encoder_ptr; 1025 1026 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1027 return -EINVAL; 1028 1029 memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo)); 1030 1031 mutex_lock(&dev->mode_config.mutex); 1032 1033 connector = drm_connector_lookup(dev, out_resp->connector_id); 1034 if (!connector) { 1035 ret = -ENOENT; 1036 goto out_unlock; 1037 } 1038 1039 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) 1040 if (connector->encoder_ids[i] != 0) 1041 encoders_count++; 1042 1043 if (out_resp->count_modes == 0) { 1044 connector->funcs->fill_modes(connector, 1045 dev->mode_config.max_width, 1046 dev->mode_config.max_height); 1047 } 1048 1049 /* delayed so we get modes regardless of pre-fill_modes state */ 1050 list_for_each_entry(mode, &connector->modes, head) 1051 if (drm_mode_expose_to_userspace(mode, file_priv)) 1052 mode_count++; 1053 1054 out_resp->connector_id = connector->base.id; 1055 out_resp->connector_type = connector->connector_type; 1056 out_resp->connector_type_id = connector->connector_type_id; 1057 out_resp->mm_width = connector->display_info.width_mm; 1058 out_resp->mm_height = connector->display_info.height_mm; 1059 out_resp->subpixel = connector->display_info.subpixel_order; 1060 out_resp->connection = connector->status; 1061 1062 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 1063 encoder = drm_connector_get_encoder(connector); 1064 if (encoder) 1065 out_resp->encoder_id = encoder->base.id; 1066 else 1067 out_resp->encoder_id = 0; 1068 1069 /* 1070 * This ioctl is called twice, once to determine how much space is 1071 * needed, and the 2nd time to fill it. 1072 */ 1073 if ((out_resp->count_modes >= mode_count) && mode_count) { 1074 copied = 0; 1075 mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr; 1076 list_for_each_entry(mode, &connector->modes, head) { 1077 if (!drm_mode_expose_to_userspace(mode, file_priv)) 1078 continue; 1079 1080 drm_mode_convert_to_umode(&u_mode, mode); 1081 if (copy_to_user(mode_ptr + copied, 1082 &u_mode, sizeof(u_mode))) { 1083 ret = -EFAULT; 1084 goto out; 1085 } 1086 copied++; 1087 } 1088 } 1089 out_resp->count_modes = mode_count; 1090 1091 ret = drm_mode_object_get_properties(&connector->base, file_priv->atomic, 1092 (uint32_t __user *)(unsigned long)(out_resp->props_ptr), 1093 (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr), 1094 &out_resp->count_props); 1095 if (ret) 1096 goto out; 1097 1098 if ((out_resp->count_encoders >= encoders_count) && encoders_count) { 1099 copied = 0; 1100 encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr); 1101 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 1102 if (connector->encoder_ids[i] != 0) { 1103 if (put_user(connector->encoder_ids[i], 1104 encoder_ptr + copied)) { 1105 ret = -EFAULT; 1106 goto out; 1107 } 1108 copied++; 1109 } 1110 } 1111 } 1112 out_resp->count_encoders = encoders_count; 1113 1114 out: 1115 drm_modeset_unlock(&dev->mode_config.connection_mutex); 1116 1117 drm_connector_unreference(connector); 1118 out_unlock: 1119 mutex_unlock(&dev->mode_config.mutex); 1120 1121 return ret; 1122 } 1123 1124