1 /* 2 * Copyright (c) 2006-2008 Intel Corporation 3 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie> 4 * Copyright (c) 2008 Red Hat Inc. 5 * 6 * DRM core CRTC related functions 7 * 8 * Permission to use, copy, modify, distribute, and sell this software and its 9 * documentation for any purpose is hereby granted without fee, provided that 10 * the above copyright notice appear in all copies and that both that copyright 11 * notice and this permission notice appear in supporting documentation, and 12 * that the name of the copyright holders not be used in advertising or 13 * publicity pertaining to distribution of the software without specific, 14 * written prior permission. The copyright holders make no representations 15 * about the suitability of this software for any purpose. It is provided "as 16 * is" without express or implied warranty. 17 * 18 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 19 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 20 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR 21 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 22 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 23 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 24 * OF THIS SOFTWARE. 25 * 26 * Authors: 27 * Keith Packard 28 * Eric Anholt <eric@anholt.net> 29 * Dave Airlie <airlied@linux.ie> 30 * Jesse Barnes <jesse.barnes@intel.com> 31 */ 32 #include <linux/list.h> 33 #include <linux/slab.h> 34 #include <linux/export.h> 35 #include <drm/drmP.h> 36 #include <drm/drm_crtc.h> 37 #include <drm/drm_edid.h> 38 #include <drm/drm_fourcc.h> 39 40 /* Avoid boilerplate. I'm tired of typing. */ 41 #define DRM_ENUM_NAME_FN(fnname, list) \ 42 char *fnname(int val) \ 43 { \ 44 int i; \ 45 for (i = 0; i < ARRAY_SIZE(list); i++) { \ 46 if (list[i].type == val) \ 47 return list[i].name; \ 48 } \ 49 return "(unknown)"; \ 50 } 51 52 /* 53 * Global properties 54 */ 55 static struct drm_prop_enum_list drm_dpms_enum_list[] = 56 { { DRM_MODE_DPMS_ON, "On" }, 57 { DRM_MODE_DPMS_STANDBY, "Standby" }, 58 { DRM_MODE_DPMS_SUSPEND, "Suspend" }, 59 { DRM_MODE_DPMS_OFF, "Off" } 60 }; 61 62 DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list) 63 64 /* 65 * Optional properties 66 */ 67 static struct drm_prop_enum_list drm_scaling_mode_enum_list[] = 68 { 69 { DRM_MODE_SCALE_NONE, "None" }, 70 { DRM_MODE_SCALE_FULLSCREEN, "Full" }, 71 { DRM_MODE_SCALE_CENTER, "Center" }, 72 { DRM_MODE_SCALE_ASPECT, "Full aspect" }, 73 }; 74 75 static struct drm_prop_enum_list drm_dithering_mode_enum_list[] = 76 { 77 { DRM_MODE_DITHERING_OFF, "Off" }, 78 { DRM_MODE_DITHERING_ON, "On" }, 79 { DRM_MODE_DITHERING_AUTO, "Automatic" }, 80 }; 81 82 /* 83 * Non-global properties, but "required" for certain connectors. 84 */ 85 static struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = 86 { 87 { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ 88 { DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ 89 { DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ 90 }; 91 92 DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list) 93 94 static struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = 95 { 96 { DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */ 97 { DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ 98 { DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ 99 }; 100 101 DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name, 102 drm_dvi_i_subconnector_enum_list) 103 104 static struct drm_prop_enum_list drm_tv_select_enum_list[] = 105 { 106 { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ 107 { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ 108 { DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ 109 { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */ 110 { DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */ 111 }; 112 113 DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list) 114 115 static struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = 116 { 117 { DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */ 118 { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ 119 { DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ 120 { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */ 121 { DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */ 122 }; 123 124 DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name, 125 drm_tv_subconnector_enum_list) 126 127 static struct drm_prop_enum_list drm_dirty_info_enum_list[] = { 128 { DRM_MODE_DIRTY_OFF, "Off" }, 129 { DRM_MODE_DIRTY_ON, "On" }, 130 { DRM_MODE_DIRTY_ANNOTATE, "Annotate" }, 131 }; 132 133 DRM_ENUM_NAME_FN(drm_get_dirty_info_name, 134 drm_dirty_info_enum_list) 135 136 struct drm_conn_prop_enum_list { 137 int type; 138 char *name; 139 int count; 140 }; 141 142 /* 143 * Connector and encoder types. 144 */ 145 static struct drm_conn_prop_enum_list drm_connector_enum_list[] = 146 { { DRM_MODE_CONNECTOR_Unknown, "Unknown", 0 }, 147 { DRM_MODE_CONNECTOR_VGA, "VGA", 0 }, 148 { DRM_MODE_CONNECTOR_DVII, "DVI-I", 0 }, 149 { DRM_MODE_CONNECTOR_DVID, "DVI-D", 0 }, 150 { DRM_MODE_CONNECTOR_DVIA, "DVI-A", 0 }, 151 { DRM_MODE_CONNECTOR_Composite, "Composite", 0 }, 152 { DRM_MODE_CONNECTOR_SVIDEO, "SVIDEO", 0 }, 153 { DRM_MODE_CONNECTOR_LVDS, "LVDS", 0 }, 154 { DRM_MODE_CONNECTOR_Component, "Component", 0 }, 155 { DRM_MODE_CONNECTOR_9PinDIN, "DIN", 0 }, 156 { DRM_MODE_CONNECTOR_DisplayPort, "DP", 0 }, 157 { DRM_MODE_CONNECTOR_HDMIA, "HDMI-A", 0 }, 158 { DRM_MODE_CONNECTOR_HDMIB, "HDMI-B", 0 }, 159 { DRM_MODE_CONNECTOR_TV, "TV", 0 }, 160 { DRM_MODE_CONNECTOR_eDP, "eDP", 0 }, 161 { DRM_MODE_CONNECTOR_VIRTUAL, "Virtual", 0}, 162 }; 163 164 static struct drm_prop_enum_list drm_encoder_enum_list[] = 165 { { DRM_MODE_ENCODER_NONE, "None" }, 166 { DRM_MODE_ENCODER_DAC, "DAC" }, 167 { DRM_MODE_ENCODER_TMDS, "TMDS" }, 168 { DRM_MODE_ENCODER_LVDS, "LVDS" }, 169 { DRM_MODE_ENCODER_TVDAC, "TV" }, 170 { DRM_MODE_ENCODER_VIRTUAL, "Virtual" }, 171 }; 172 173 char *drm_get_encoder_name(struct drm_encoder *encoder) 174 { 175 static char buf[32]; 176 177 snprintf(buf, 32, "%s-%d", 178 drm_encoder_enum_list[encoder->encoder_type].name, 179 encoder->base.id); 180 return buf; 181 } 182 EXPORT_SYMBOL(drm_get_encoder_name); 183 184 char *drm_get_connector_name(struct drm_connector *connector) 185 { 186 static char buf[32]; 187 188 snprintf(buf, 32, "%s-%d", 189 drm_connector_enum_list[connector->connector_type].name, 190 connector->connector_type_id); 191 return buf; 192 } 193 EXPORT_SYMBOL(drm_get_connector_name); 194 195 char *drm_get_connector_status_name(enum drm_connector_status status) 196 { 197 if (status == connector_status_connected) 198 return "connected"; 199 else if (status == connector_status_disconnected) 200 return "disconnected"; 201 else 202 return "unknown"; 203 } 204 205 /** 206 * drm_mode_object_get - allocate a new identifier 207 * @dev: DRM device 208 * @ptr: object pointer, used to generate unique ID 209 * @type: object type 210 * 211 * LOCKING: 212 * 213 * Create a unique identifier based on @ptr in @dev's identifier space. Used 214 * for tracking modes, CRTCs and connectors. 215 * 216 * RETURNS: 217 * New unique (relative to other objects in @dev) integer identifier for the 218 * object. 219 */ 220 static int drm_mode_object_get(struct drm_device *dev, 221 struct drm_mode_object *obj, uint32_t obj_type) 222 { 223 int new_id = 0; 224 int ret; 225 226 again: 227 if (idr_pre_get(&dev->mode_config.crtc_idr, GFP_KERNEL) == 0) { 228 DRM_ERROR("Ran out memory getting a mode number\n"); 229 return -ENOMEM; 230 } 231 232 mutex_lock(&dev->mode_config.idr_mutex); 233 ret = idr_get_new_above(&dev->mode_config.crtc_idr, obj, 1, &new_id); 234 mutex_unlock(&dev->mode_config.idr_mutex); 235 if (ret == -EAGAIN) 236 goto again; 237 else if (ret) 238 return ret; 239 240 obj->id = new_id; 241 obj->type = obj_type; 242 return 0; 243 } 244 245 /** 246 * drm_mode_object_put - free an identifer 247 * @dev: DRM device 248 * @id: ID to free 249 * 250 * LOCKING: 251 * Caller must hold DRM mode_config lock. 252 * 253 * Free @id from @dev's unique identifier pool. 254 */ 255 static void drm_mode_object_put(struct drm_device *dev, 256 struct drm_mode_object *object) 257 { 258 mutex_lock(&dev->mode_config.idr_mutex); 259 idr_remove(&dev->mode_config.crtc_idr, object->id); 260 mutex_unlock(&dev->mode_config.idr_mutex); 261 } 262 263 struct drm_mode_object *drm_mode_object_find(struct drm_device *dev, 264 uint32_t id, uint32_t type) 265 { 266 struct drm_mode_object *obj = NULL; 267 268 mutex_lock(&dev->mode_config.idr_mutex); 269 obj = idr_find(&dev->mode_config.crtc_idr, id); 270 if (!obj || (obj->type != type) || (obj->id != id)) 271 obj = NULL; 272 mutex_unlock(&dev->mode_config.idr_mutex); 273 274 return obj; 275 } 276 EXPORT_SYMBOL(drm_mode_object_find); 277 278 /** 279 * drm_framebuffer_init - initialize a framebuffer 280 * @dev: DRM device 281 * 282 * LOCKING: 283 * Caller must hold mode config lock. 284 * 285 * Allocates an ID for the framebuffer's parent mode object, sets its mode 286 * functions & device file and adds it to the master fd list. 287 * 288 * RETURNS: 289 * Zero on success, error code on failure. 290 */ 291 int drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb, 292 const struct drm_framebuffer_funcs *funcs) 293 { 294 int ret; 295 296 kref_init(&fb->refcount); 297 298 ret = drm_mode_object_get(dev, &fb->base, DRM_MODE_OBJECT_FB); 299 if (ret) 300 return ret; 301 302 fb->dev = dev; 303 fb->funcs = funcs; 304 dev->mode_config.num_fb++; 305 list_add(&fb->head, &dev->mode_config.fb_list); 306 307 return 0; 308 } 309 EXPORT_SYMBOL(drm_framebuffer_init); 310 311 static void drm_framebuffer_free(struct kref *kref) 312 { 313 struct drm_framebuffer *fb = 314 container_of(kref, struct drm_framebuffer, refcount); 315 fb->funcs->destroy(fb); 316 } 317 318 /** 319 * drm_framebuffer_unreference - unref a framebuffer 320 * 321 * LOCKING: 322 * Caller must hold mode config lock. 323 */ 324 void drm_framebuffer_unreference(struct drm_framebuffer *fb) 325 { 326 struct drm_device *dev = fb->dev; 327 DRM_DEBUG("FB ID: %d\n", fb->base.id); 328 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex)); 329 kref_put(&fb->refcount, drm_framebuffer_free); 330 } 331 EXPORT_SYMBOL(drm_framebuffer_unreference); 332 333 /** 334 * drm_framebuffer_reference - incr the fb refcnt 335 */ 336 void drm_framebuffer_reference(struct drm_framebuffer *fb) 337 { 338 DRM_DEBUG("FB ID: %d\n", fb->base.id); 339 kref_get(&fb->refcount); 340 } 341 EXPORT_SYMBOL(drm_framebuffer_reference); 342 343 /** 344 * drm_framebuffer_cleanup - remove a framebuffer object 345 * @fb: framebuffer to remove 346 * 347 * LOCKING: 348 * Caller must hold mode config lock. 349 * 350 * Scans all the CRTCs in @dev's mode_config. If they're using @fb, removes 351 * it, setting it to NULL. 352 */ 353 void drm_framebuffer_cleanup(struct drm_framebuffer *fb) 354 { 355 struct drm_device *dev = fb->dev; 356 /* 357 * This could be moved to drm_framebuffer_remove(), but for 358 * debugging is nice to keep around the list of fb's that are 359 * no longer associated w/ a drm_file but are not unreferenced 360 * yet. (i915 and omapdrm have debugfs files which will show 361 * this.) 362 */ 363 drm_mode_object_put(dev, &fb->base); 364 list_del(&fb->head); 365 dev->mode_config.num_fb--; 366 } 367 EXPORT_SYMBOL(drm_framebuffer_cleanup); 368 369 /** 370 * drm_framebuffer_remove - remove and unreference a framebuffer object 371 * @fb: framebuffer to remove 372 * 373 * LOCKING: 374 * Caller must hold mode config lock. 375 * 376 * Scans all the CRTCs and planes in @dev's mode_config. If they're 377 * using @fb, removes it, setting it to NULL. 378 */ 379 void drm_framebuffer_remove(struct drm_framebuffer *fb) 380 { 381 struct drm_device *dev = fb->dev; 382 struct drm_crtc *crtc; 383 struct drm_plane *plane; 384 struct drm_mode_set set; 385 int ret; 386 387 /* remove from any CRTC */ 388 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 389 if (crtc->fb == fb) { 390 /* should turn off the crtc */ 391 memset(&set, 0, sizeof(struct drm_mode_set)); 392 set.crtc = crtc; 393 set.fb = NULL; 394 ret = crtc->funcs->set_config(&set); 395 if (ret) 396 DRM_ERROR("failed to reset crtc %p when fb was deleted\n", crtc); 397 } 398 } 399 400 list_for_each_entry(plane, &dev->mode_config.plane_list, head) { 401 if (plane->fb == fb) { 402 /* should turn off the crtc */ 403 ret = plane->funcs->disable_plane(plane); 404 if (ret) 405 DRM_ERROR("failed to disable plane with busy fb\n"); 406 /* disconnect the plane from the fb and crtc: */ 407 plane->fb = NULL; 408 plane->crtc = NULL; 409 } 410 } 411 412 list_del(&fb->filp_head); 413 414 drm_framebuffer_unreference(fb); 415 } 416 EXPORT_SYMBOL(drm_framebuffer_remove); 417 418 /** 419 * drm_crtc_init - Initialise a new CRTC object 420 * @dev: DRM device 421 * @crtc: CRTC object to init 422 * @funcs: callbacks for the new CRTC 423 * 424 * LOCKING: 425 * Takes mode_config lock. 426 * 427 * Inits a new object created as base part of an driver crtc object. 428 * 429 * RETURNS: 430 * Zero on success, error code on failure. 431 */ 432 int drm_crtc_init(struct drm_device *dev, struct drm_crtc *crtc, 433 const struct drm_crtc_funcs *funcs) 434 { 435 int ret; 436 437 crtc->dev = dev; 438 crtc->funcs = funcs; 439 crtc->invert_dimensions = false; 440 441 mutex_lock(&dev->mode_config.mutex); 442 443 ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC); 444 if (ret) 445 goto out; 446 447 crtc->base.properties = &crtc->properties; 448 449 list_add_tail(&crtc->head, &dev->mode_config.crtc_list); 450 dev->mode_config.num_crtc++; 451 452 out: 453 mutex_unlock(&dev->mode_config.mutex); 454 455 return ret; 456 } 457 EXPORT_SYMBOL(drm_crtc_init); 458 459 /** 460 * drm_crtc_cleanup - Cleans up the core crtc usage. 461 * @crtc: CRTC to cleanup 462 * 463 * LOCKING: 464 * Caller must hold mode config lock. 465 * 466 * Cleanup @crtc. Removes from drm modesetting space 467 * does NOT free object, caller does that. 468 */ 469 void drm_crtc_cleanup(struct drm_crtc *crtc) 470 { 471 struct drm_device *dev = crtc->dev; 472 473 if (crtc->gamma_store) { 474 kfree(crtc->gamma_store); 475 crtc->gamma_store = NULL; 476 } 477 478 drm_mode_object_put(dev, &crtc->base); 479 list_del(&crtc->head); 480 dev->mode_config.num_crtc--; 481 } 482 EXPORT_SYMBOL(drm_crtc_cleanup); 483 484 /** 485 * drm_mode_probed_add - add a mode to a connector's probed mode list 486 * @connector: connector the new mode 487 * @mode: mode data 488 * 489 * LOCKING: 490 * Caller must hold mode config lock. 491 * 492 * Add @mode to @connector's mode list for later use. 493 */ 494 void drm_mode_probed_add(struct drm_connector *connector, 495 struct drm_display_mode *mode) 496 { 497 list_add(&mode->head, &connector->probed_modes); 498 } 499 EXPORT_SYMBOL(drm_mode_probed_add); 500 501 /** 502 * drm_mode_remove - remove and free a mode 503 * @connector: connector list to modify 504 * @mode: mode to remove 505 * 506 * LOCKING: 507 * Caller must hold mode config lock. 508 * 509 * Remove @mode from @connector's mode list, then free it. 510 */ 511 void drm_mode_remove(struct drm_connector *connector, 512 struct drm_display_mode *mode) 513 { 514 list_del(&mode->head); 515 drm_mode_destroy(connector->dev, mode); 516 } 517 EXPORT_SYMBOL(drm_mode_remove); 518 519 /** 520 * drm_connector_init - Init a preallocated connector 521 * @dev: DRM device 522 * @connector: the connector to init 523 * @funcs: callbacks for this connector 524 * @name: user visible name of the connector 525 * 526 * LOCKING: 527 * Takes mode config lock. 528 * 529 * Initialises a preallocated connector. Connectors should be 530 * subclassed as part of driver connector objects. 531 * 532 * RETURNS: 533 * Zero on success, error code on failure. 534 */ 535 int drm_connector_init(struct drm_device *dev, 536 struct drm_connector *connector, 537 const struct drm_connector_funcs *funcs, 538 int connector_type) 539 { 540 int ret; 541 542 mutex_lock(&dev->mode_config.mutex); 543 544 ret = drm_mode_object_get(dev, &connector->base, DRM_MODE_OBJECT_CONNECTOR); 545 if (ret) 546 goto out; 547 548 connector->base.properties = &connector->properties; 549 connector->dev = dev; 550 connector->funcs = funcs; 551 connector->connector_type = connector_type; 552 connector->connector_type_id = 553 ++drm_connector_enum_list[connector_type].count; /* TODO */ 554 INIT_LIST_HEAD(&connector->user_modes); 555 INIT_LIST_HEAD(&connector->probed_modes); 556 INIT_LIST_HEAD(&connector->modes); 557 connector->edid_blob_ptr = NULL; 558 559 list_add_tail(&connector->head, &dev->mode_config.connector_list); 560 dev->mode_config.num_connector++; 561 562 if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL) 563 drm_connector_attach_property(connector, 564 dev->mode_config.edid_property, 565 0); 566 567 drm_connector_attach_property(connector, 568 dev->mode_config.dpms_property, 0); 569 570 out: 571 mutex_unlock(&dev->mode_config.mutex); 572 573 return ret; 574 } 575 EXPORT_SYMBOL(drm_connector_init); 576 577 /** 578 * drm_connector_cleanup - cleans up an initialised connector 579 * @connector: connector to cleanup 580 * 581 * LOCKING: 582 * Takes mode config lock. 583 * 584 * Cleans up the connector but doesn't free the object. 585 */ 586 void drm_connector_cleanup(struct drm_connector *connector) 587 { 588 struct drm_device *dev = connector->dev; 589 struct drm_display_mode *mode, *t; 590 591 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) 592 drm_mode_remove(connector, mode); 593 594 list_for_each_entry_safe(mode, t, &connector->modes, head) 595 drm_mode_remove(connector, mode); 596 597 list_for_each_entry_safe(mode, t, &connector->user_modes, head) 598 drm_mode_remove(connector, mode); 599 600 mutex_lock(&dev->mode_config.mutex); 601 drm_mode_object_put(dev, &connector->base); 602 list_del(&connector->head); 603 dev->mode_config.num_connector--; 604 mutex_unlock(&dev->mode_config.mutex); 605 } 606 EXPORT_SYMBOL(drm_connector_cleanup); 607 608 void drm_connector_unplug_all(struct drm_device *dev) 609 { 610 struct drm_connector *connector; 611 612 /* taking the mode config mutex ends up in a clash with sysfs */ 613 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 614 drm_sysfs_connector_remove(connector); 615 616 } 617 EXPORT_SYMBOL(drm_connector_unplug_all); 618 619 int drm_encoder_init(struct drm_device *dev, 620 struct drm_encoder *encoder, 621 const struct drm_encoder_funcs *funcs, 622 int encoder_type) 623 { 624 int ret; 625 626 mutex_lock(&dev->mode_config.mutex); 627 628 ret = drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER); 629 if (ret) 630 goto out; 631 632 encoder->dev = dev; 633 encoder->encoder_type = encoder_type; 634 encoder->funcs = funcs; 635 636 list_add_tail(&encoder->head, &dev->mode_config.encoder_list); 637 dev->mode_config.num_encoder++; 638 639 out: 640 mutex_unlock(&dev->mode_config.mutex); 641 642 return ret; 643 } 644 EXPORT_SYMBOL(drm_encoder_init); 645 646 void drm_encoder_cleanup(struct drm_encoder *encoder) 647 { 648 struct drm_device *dev = encoder->dev; 649 mutex_lock(&dev->mode_config.mutex); 650 drm_mode_object_put(dev, &encoder->base); 651 list_del(&encoder->head); 652 dev->mode_config.num_encoder--; 653 mutex_unlock(&dev->mode_config.mutex); 654 } 655 EXPORT_SYMBOL(drm_encoder_cleanup); 656 657 int drm_plane_init(struct drm_device *dev, struct drm_plane *plane, 658 unsigned long possible_crtcs, 659 const struct drm_plane_funcs *funcs, 660 const uint32_t *formats, uint32_t format_count, 661 bool priv) 662 { 663 int ret; 664 665 mutex_lock(&dev->mode_config.mutex); 666 667 ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE); 668 if (ret) 669 goto out; 670 671 plane->base.properties = &plane->properties; 672 plane->dev = dev; 673 plane->funcs = funcs; 674 plane->format_types = kmalloc(sizeof(uint32_t) * format_count, 675 GFP_KERNEL); 676 if (!plane->format_types) { 677 DRM_DEBUG_KMS("out of memory when allocating plane\n"); 678 drm_mode_object_put(dev, &plane->base); 679 ret = -ENOMEM; 680 goto out; 681 } 682 683 memcpy(plane->format_types, formats, format_count * sizeof(uint32_t)); 684 plane->format_count = format_count; 685 plane->possible_crtcs = possible_crtcs; 686 687 /* private planes are not exposed to userspace, but depending on 688 * display hardware, might be convenient to allow sharing programming 689 * for the scanout engine with the crtc implementation. 690 */ 691 if (!priv) { 692 list_add_tail(&plane->head, &dev->mode_config.plane_list); 693 dev->mode_config.num_plane++; 694 } else { 695 INIT_LIST_HEAD(&plane->head); 696 } 697 698 out: 699 mutex_unlock(&dev->mode_config.mutex); 700 701 return ret; 702 } 703 EXPORT_SYMBOL(drm_plane_init); 704 705 void drm_plane_cleanup(struct drm_plane *plane) 706 { 707 struct drm_device *dev = plane->dev; 708 709 mutex_lock(&dev->mode_config.mutex); 710 kfree(plane->format_types); 711 drm_mode_object_put(dev, &plane->base); 712 /* if not added to a list, it must be a private plane */ 713 if (!list_empty(&plane->head)) { 714 list_del(&plane->head); 715 dev->mode_config.num_plane--; 716 } 717 mutex_unlock(&dev->mode_config.mutex); 718 } 719 EXPORT_SYMBOL(drm_plane_cleanup); 720 721 /** 722 * drm_mode_create - create a new display mode 723 * @dev: DRM device 724 * 725 * LOCKING: 726 * Caller must hold DRM mode_config lock. 727 * 728 * Create a new drm_display_mode, give it an ID, and return it. 729 * 730 * RETURNS: 731 * Pointer to new mode on success, NULL on error. 732 */ 733 struct drm_display_mode *drm_mode_create(struct drm_device *dev) 734 { 735 struct drm_display_mode *nmode; 736 737 nmode = kzalloc(sizeof(struct drm_display_mode), GFP_KERNEL); 738 if (!nmode) 739 return NULL; 740 741 if (drm_mode_object_get(dev, &nmode->base, DRM_MODE_OBJECT_MODE)) { 742 kfree(nmode); 743 return NULL; 744 } 745 746 return nmode; 747 } 748 EXPORT_SYMBOL(drm_mode_create); 749 750 /** 751 * drm_mode_destroy - remove a mode 752 * @dev: DRM device 753 * @mode: mode to remove 754 * 755 * LOCKING: 756 * Caller must hold mode config lock. 757 * 758 * Free @mode's unique identifier, then free it. 759 */ 760 void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode) 761 { 762 if (!mode) 763 return; 764 765 drm_mode_object_put(dev, &mode->base); 766 767 kfree(mode); 768 } 769 EXPORT_SYMBOL(drm_mode_destroy); 770 771 static int drm_mode_create_standard_connector_properties(struct drm_device *dev) 772 { 773 struct drm_property *edid; 774 struct drm_property *dpms; 775 776 /* 777 * Standard properties (apply to all connectors) 778 */ 779 edid = drm_property_create(dev, DRM_MODE_PROP_BLOB | 780 DRM_MODE_PROP_IMMUTABLE, 781 "EDID", 0); 782 dev->mode_config.edid_property = edid; 783 784 dpms = drm_property_create_enum(dev, 0, 785 "DPMS", drm_dpms_enum_list, 786 ARRAY_SIZE(drm_dpms_enum_list)); 787 dev->mode_config.dpms_property = dpms; 788 789 return 0; 790 } 791 792 /** 793 * drm_mode_create_dvi_i_properties - create DVI-I specific connector properties 794 * @dev: DRM device 795 * 796 * Called by a driver the first time a DVI-I connector is made. 797 */ 798 int drm_mode_create_dvi_i_properties(struct drm_device *dev) 799 { 800 struct drm_property *dvi_i_selector; 801 struct drm_property *dvi_i_subconnector; 802 803 if (dev->mode_config.dvi_i_select_subconnector_property) 804 return 0; 805 806 dvi_i_selector = 807 drm_property_create_enum(dev, 0, 808 "select subconnector", 809 drm_dvi_i_select_enum_list, 810 ARRAY_SIZE(drm_dvi_i_select_enum_list)); 811 dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector; 812 813 dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 814 "subconnector", 815 drm_dvi_i_subconnector_enum_list, 816 ARRAY_SIZE(drm_dvi_i_subconnector_enum_list)); 817 dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector; 818 819 return 0; 820 } 821 EXPORT_SYMBOL(drm_mode_create_dvi_i_properties); 822 823 /** 824 * drm_create_tv_properties - create TV specific connector properties 825 * @dev: DRM device 826 * @num_modes: number of different TV formats (modes) supported 827 * @modes: array of pointers to strings containing name of each format 828 * 829 * Called by a driver's TV initialization routine, this function creates 830 * the TV specific connector properties for a given device. Caller is 831 * responsible for allocating a list of format names and passing them to 832 * this routine. 833 */ 834 int drm_mode_create_tv_properties(struct drm_device *dev, int num_modes, 835 char *modes[]) 836 { 837 struct drm_property *tv_selector; 838 struct drm_property *tv_subconnector; 839 int i; 840 841 if (dev->mode_config.tv_select_subconnector_property) 842 return 0; 843 844 /* 845 * Basic connector properties 846 */ 847 tv_selector = drm_property_create_enum(dev, 0, 848 "select subconnector", 849 drm_tv_select_enum_list, 850 ARRAY_SIZE(drm_tv_select_enum_list)); 851 dev->mode_config.tv_select_subconnector_property = tv_selector; 852 853 tv_subconnector = 854 drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 855 "subconnector", 856 drm_tv_subconnector_enum_list, 857 ARRAY_SIZE(drm_tv_subconnector_enum_list)); 858 dev->mode_config.tv_subconnector_property = tv_subconnector; 859 860 /* 861 * Other, TV specific properties: margins & TV modes. 862 */ 863 dev->mode_config.tv_left_margin_property = 864 drm_property_create_range(dev, 0, "left margin", 0, 100); 865 866 dev->mode_config.tv_right_margin_property = 867 drm_property_create_range(dev, 0, "right margin", 0, 100); 868 869 dev->mode_config.tv_top_margin_property = 870 drm_property_create_range(dev, 0, "top margin", 0, 100); 871 872 dev->mode_config.tv_bottom_margin_property = 873 drm_property_create_range(dev, 0, "bottom margin", 0, 100); 874 875 dev->mode_config.tv_mode_property = 876 drm_property_create(dev, DRM_MODE_PROP_ENUM, 877 "mode", num_modes); 878 for (i = 0; i < num_modes; i++) 879 drm_property_add_enum(dev->mode_config.tv_mode_property, i, 880 i, modes[i]); 881 882 dev->mode_config.tv_brightness_property = 883 drm_property_create_range(dev, 0, "brightness", 0, 100); 884 885 dev->mode_config.tv_contrast_property = 886 drm_property_create_range(dev, 0, "contrast", 0, 100); 887 888 dev->mode_config.tv_flicker_reduction_property = 889 drm_property_create_range(dev, 0, "flicker reduction", 0, 100); 890 891 dev->mode_config.tv_overscan_property = 892 drm_property_create_range(dev, 0, "overscan", 0, 100); 893 894 dev->mode_config.tv_saturation_property = 895 drm_property_create_range(dev, 0, "saturation", 0, 100); 896 897 dev->mode_config.tv_hue_property = 898 drm_property_create_range(dev, 0, "hue", 0, 100); 899 900 return 0; 901 } 902 EXPORT_SYMBOL(drm_mode_create_tv_properties); 903 904 /** 905 * drm_mode_create_scaling_mode_property - create scaling mode property 906 * @dev: DRM device 907 * 908 * Called by a driver the first time it's needed, must be attached to desired 909 * connectors. 910 */ 911 int drm_mode_create_scaling_mode_property(struct drm_device *dev) 912 { 913 struct drm_property *scaling_mode; 914 915 if (dev->mode_config.scaling_mode_property) 916 return 0; 917 918 scaling_mode = 919 drm_property_create_enum(dev, 0, "scaling mode", 920 drm_scaling_mode_enum_list, 921 ARRAY_SIZE(drm_scaling_mode_enum_list)); 922 923 dev->mode_config.scaling_mode_property = scaling_mode; 924 925 return 0; 926 } 927 EXPORT_SYMBOL(drm_mode_create_scaling_mode_property); 928 929 /** 930 * drm_mode_create_dithering_property - create dithering property 931 * @dev: DRM device 932 * 933 * Called by a driver the first time it's needed, must be attached to desired 934 * connectors. 935 */ 936 int drm_mode_create_dithering_property(struct drm_device *dev) 937 { 938 struct drm_property *dithering_mode; 939 940 if (dev->mode_config.dithering_mode_property) 941 return 0; 942 943 dithering_mode = 944 drm_property_create_enum(dev, 0, "dithering", 945 drm_dithering_mode_enum_list, 946 ARRAY_SIZE(drm_dithering_mode_enum_list)); 947 dev->mode_config.dithering_mode_property = dithering_mode; 948 949 return 0; 950 } 951 EXPORT_SYMBOL(drm_mode_create_dithering_property); 952 953 /** 954 * drm_mode_create_dirty_property - create dirty property 955 * @dev: DRM device 956 * 957 * Called by a driver the first time it's needed, must be attached to desired 958 * connectors. 959 */ 960 int drm_mode_create_dirty_info_property(struct drm_device *dev) 961 { 962 struct drm_property *dirty_info; 963 964 if (dev->mode_config.dirty_info_property) 965 return 0; 966 967 dirty_info = 968 drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 969 "dirty", 970 drm_dirty_info_enum_list, 971 ARRAY_SIZE(drm_dirty_info_enum_list)); 972 dev->mode_config.dirty_info_property = dirty_info; 973 974 return 0; 975 } 976 EXPORT_SYMBOL(drm_mode_create_dirty_info_property); 977 978 /** 979 * drm_mode_config_init - initialize DRM mode_configuration structure 980 * @dev: DRM device 981 * 982 * LOCKING: 983 * None, should happen single threaded at init time. 984 * 985 * Initialize @dev's mode_config structure, used for tracking the graphics 986 * configuration of @dev. 987 */ 988 void drm_mode_config_init(struct drm_device *dev) 989 { 990 mutex_init(&dev->mode_config.mutex); 991 mutex_init(&dev->mode_config.idr_mutex); 992 INIT_LIST_HEAD(&dev->mode_config.fb_list); 993 INIT_LIST_HEAD(&dev->mode_config.crtc_list); 994 INIT_LIST_HEAD(&dev->mode_config.connector_list); 995 INIT_LIST_HEAD(&dev->mode_config.encoder_list); 996 INIT_LIST_HEAD(&dev->mode_config.property_list); 997 INIT_LIST_HEAD(&dev->mode_config.property_blob_list); 998 INIT_LIST_HEAD(&dev->mode_config.plane_list); 999 idr_init(&dev->mode_config.crtc_idr); 1000 1001 mutex_lock(&dev->mode_config.mutex); 1002 drm_mode_create_standard_connector_properties(dev); 1003 mutex_unlock(&dev->mode_config.mutex); 1004 1005 /* Just to be sure */ 1006 dev->mode_config.num_fb = 0; 1007 dev->mode_config.num_connector = 0; 1008 dev->mode_config.num_crtc = 0; 1009 dev->mode_config.num_encoder = 0; 1010 } 1011 EXPORT_SYMBOL(drm_mode_config_init); 1012 1013 int drm_mode_group_init(struct drm_device *dev, struct drm_mode_group *group) 1014 { 1015 uint32_t total_objects = 0; 1016 1017 total_objects += dev->mode_config.num_crtc; 1018 total_objects += dev->mode_config.num_connector; 1019 total_objects += dev->mode_config.num_encoder; 1020 1021 group->id_list = kzalloc(total_objects * sizeof(uint32_t), GFP_KERNEL); 1022 if (!group->id_list) 1023 return -ENOMEM; 1024 1025 group->num_crtcs = 0; 1026 group->num_connectors = 0; 1027 group->num_encoders = 0; 1028 return 0; 1029 } 1030 1031 int drm_mode_group_init_legacy_group(struct drm_device *dev, 1032 struct drm_mode_group *group) 1033 { 1034 struct drm_crtc *crtc; 1035 struct drm_encoder *encoder; 1036 struct drm_connector *connector; 1037 int ret; 1038 1039 if ((ret = drm_mode_group_init(dev, group))) 1040 return ret; 1041 1042 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) 1043 group->id_list[group->num_crtcs++] = crtc->base.id; 1044 1045 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) 1046 group->id_list[group->num_crtcs + group->num_encoders++] = 1047 encoder->base.id; 1048 1049 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 1050 group->id_list[group->num_crtcs + group->num_encoders + 1051 group->num_connectors++] = connector->base.id; 1052 1053 return 0; 1054 } 1055 EXPORT_SYMBOL(drm_mode_group_init_legacy_group); 1056 1057 /** 1058 * drm_mode_config_cleanup - free up DRM mode_config info 1059 * @dev: DRM device 1060 * 1061 * LOCKING: 1062 * Caller must hold mode config lock. 1063 * 1064 * Free up all the connectors and CRTCs associated with this DRM device, then 1065 * free up the framebuffers and associated buffer objects. 1066 * 1067 * FIXME: cleanup any dangling user buffer objects too 1068 */ 1069 void drm_mode_config_cleanup(struct drm_device *dev) 1070 { 1071 struct drm_connector *connector, *ot; 1072 struct drm_crtc *crtc, *ct; 1073 struct drm_encoder *encoder, *enct; 1074 struct drm_framebuffer *fb, *fbt; 1075 struct drm_property *property, *pt; 1076 struct drm_plane *plane, *plt; 1077 1078 list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list, 1079 head) { 1080 encoder->funcs->destroy(encoder); 1081 } 1082 1083 list_for_each_entry_safe(connector, ot, 1084 &dev->mode_config.connector_list, head) { 1085 connector->funcs->destroy(connector); 1086 } 1087 1088 list_for_each_entry_safe(property, pt, &dev->mode_config.property_list, 1089 head) { 1090 drm_property_destroy(dev, property); 1091 } 1092 1093 list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) { 1094 drm_framebuffer_remove(fb); 1095 } 1096 1097 list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list, 1098 head) { 1099 plane->funcs->destroy(plane); 1100 } 1101 1102 list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) { 1103 crtc->funcs->destroy(crtc); 1104 } 1105 1106 idr_remove_all(&dev->mode_config.crtc_idr); 1107 idr_destroy(&dev->mode_config.crtc_idr); 1108 } 1109 EXPORT_SYMBOL(drm_mode_config_cleanup); 1110 1111 /** 1112 * drm_crtc_convert_to_umode - convert a drm_display_mode into a modeinfo 1113 * @out: drm_mode_modeinfo struct to return to the user 1114 * @in: drm_display_mode to use 1115 * 1116 * LOCKING: 1117 * None. 1118 * 1119 * Convert a drm_display_mode into a drm_mode_modeinfo structure to return to 1120 * the user. 1121 */ 1122 static void drm_crtc_convert_to_umode(struct drm_mode_modeinfo *out, 1123 const struct drm_display_mode *in) 1124 { 1125 WARN(in->hdisplay > USHRT_MAX || in->hsync_start > USHRT_MAX || 1126 in->hsync_end > USHRT_MAX || in->htotal > USHRT_MAX || 1127 in->hskew > USHRT_MAX || in->vdisplay > USHRT_MAX || 1128 in->vsync_start > USHRT_MAX || in->vsync_end > USHRT_MAX || 1129 in->vtotal > USHRT_MAX || in->vscan > USHRT_MAX, 1130 "timing values too large for mode info\n"); 1131 1132 out->clock = in->clock; 1133 out->hdisplay = in->hdisplay; 1134 out->hsync_start = in->hsync_start; 1135 out->hsync_end = in->hsync_end; 1136 out->htotal = in->htotal; 1137 out->hskew = in->hskew; 1138 out->vdisplay = in->vdisplay; 1139 out->vsync_start = in->vsync_start; 1140 out->vsync_end = in->vsync_end; 1141 out->vtotal = in->vtotal; 1142 out->vscan = in->vscan; 1143 out->vrefresh = in->vrefresh; 1144 out->flags = in->flags; 1145 out->type = in->type; 1146 strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN); 1147 out->name[DRM_DISPLAY_MODE_LEN-1] = 0; 1148 } 1149 1150 /** 1151 * drm_crtc_convert_to_umode - convert a modeinfo into a drm_display_mode 1152 * @out: drm_display_mode to return to the user 1153 * @in: drm_mode_modeinfo to use 1154 * 1155 * LOCKING: 1156 * None. 1157 * 1158 * Convert a drm_mode_modeinfo into a drm_display_mode structure to return to 1159 * the caller. 1160 * 1161 * RETURNS: 1162 * Zero on success, errno on failure. 1163 */ 1164 static int drm_crtc_convert_umode(struct drm_display_mode *out, 1165 const struct drm_mode_modeinfo *in) 1166 { 1167 if (in->clock > INT_MAX || in->vrefresh > INT_MAX) 1168 return -ERANGE; 1169 1170 out->clock = in->clock; 1171 out->hdisplay = in->hdisplay; 1172 out->hsync_start = in->hsync_start; 1173 out->hsync_end = in->hsync_end; 1174 out->htotal = in->htotal; 1175 out->hskew = in->hskew; 1176 out->vdisplay = in->vdisplay; 1177 out->vsync_start = in->vsync_start; 1178 out->vsync_end = in->vsync_end; 1179 out->vtotal = in->vtotal; 1180 out->vscan = in->vscan; 1181 out->vrefresh = in->vrefresh; 1182 out->flags = in->flags; 1183 out->type = in->type; 1184 strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN); 1185 out->name[DRM_DISPLAY_MODE_LEN-1] = 0; 1186 1187 return 0; 1188 } 1189 1190 /** 1191 * drm_mode_getresources - get graphics configuration 1192 * @inode: inode from the ioctl 1193 * @filp: file * from the ioctl 1194 * @cmd: cmd from ioctl 1195 * @arg: arg from ioctl 1196 * 1197 * LOCKING: 1198 * Takes mode config lock. 1199 * 1200 * Construct a set of configuration description structures and return 1201 * them to the user, including CRTC, connector and framebuffer configuration. 1202 * 1203 * Called by the user via ioctl. 1204 * 1205 * RETURNS: 1206 * Zero on success, errno on failure. 1207 */ 1208 int drm_mode_getresources(struct drm_device *dev, void *data, 1209 struct drm_file *file_priv) 1210 { 1211 struct drm_mode_card_res *card_res = data; 1212 struct list_head *lh; 1213 struct drm_framebuffer *fb; 1214 struct drm_connector *connector; 1215 struct drm_crtc *crtc; 1216 struct drm_encoder *encoder; 1217 int ret = 0; 1218 int connector_count = 0; 1219 int crtc_count = 0; 1220 int fb_count = 0; 1221 int encoder_count = 0; 1222 int copied = 0, i; 1223 uint32_t __user *fb_id; 1224 uint32_t __user *crtc_id; 1225 uint32_t __user *connector_id; 1226 uint32_t __user *encoder_id; 1227 struct drm_mode_group *mode_group; 1228 1229 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1230 return -EINVAL; 1231 1232 mutex_lock(&dev->mode_config.mutex); 1233 1234 /* 1235 * For the non-control nodes we need to limit the list of resources 1236 * by IDs in the group list for this node 1237 */ 1238 list_for_each(lh, &file_priv->fbs) 1239 fb_count++; 1240 1241 mode_group = &file_priv->master->minor->mode_group; 1242 if (file_priv->master->minor->type == DRM_MINOR_CONTROL) { 1243 1244 list_for_each(lh, &dev->mode_config.crtc_list) 1245 crtc_count++; 1246 1247 list_for_each(lh, &dev->mode_config.connector_list) 1248 connector_count++; 1249 1250 list_for_each(lh, &dev->mode_config.encoder_list) 1251 encoder_count++; 1252 } else { 1253 1254 crtc_count = mode_group->num_crtcs; 1255 connector_count = mode_group->num_connectors; 1256 encoder_count = mode_group->num_encoders; 1257 } 1258 1259 card_res->max_height = dev->mode_config.max_height; 1260 card_res->min_height = dev->mode_config.min_height; 1261 card_res->max_width = dev->mode_config.max_width; 1262 card_res->min_width = dev->mode_config.min_width; 1263 1264 /* handle this in 4 parts */ 1265 /* FBs */ 1266 if (card_res->count_fbs >= fb_count) { 1267 copied = 0; 1268 fb_id = (uint32_t __user *)(unsigned long)card_res->fb_id_ptr; 1269 list_for_each_entry(fb, &file_priv->fbs, filp_head) { 1270 if (put_user(fb->base.id, fb_id + copied)) { 1271 ret = -EFAULT; 1272 goto out; 1273 } 1274 copied++; 1275 } 1276 } 1277 card_res->count_fbs = fb_count; 1278 1279 /* CRTCs */ 1280 if (card_res->count_crtcs >= crtc_count) { 1281 copied = 0; 1282 crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr; 1283 if (file_priv->master->minor->type == DRM_MINOR_CONTROL) { 1284 list_for_each_entry(crtc, &dev->mode_config.crtc_list, 1285 head) { 1286 DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id); 1287 if (put_user(crtc->base.id, crtc_id + copied)) { 1288 ret = -EFAULT; 1289 goto out; 1290 } 1291 copied++; 1292 } 1293 } else { 1294 for (i = 0; i < mode_group->num_crtcs; i++) { 1295 if (put_user(mode_group->id_list[i], 1296 crtc_id + copied)) { 1297 ret = -EFAULT; 1298 goto out; 1299 } 1300 copied++; 1301 } 1302 } 1303 } 1304 card_res->count_crtcs = crtc_count; 1305 1306 /* Encoders */ 1307 if (card_res->count_encoders >= encoder_count) { 1308 copied = 0; 1309 encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr; 1310 if (file_priv->master->minor->type == DRM_MINOR_CONTROL) { 1311 list_for_each_entry(encoder, 1312 &dev->mode_config.encoder_list, 1313 head) { 1314 DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id, 1315 drm_get_encoder_name(encoder)); 1316 if (put_user(encoder->base.id, encoder_id + 1317 copied)) { 1318 ret = -EFAULT; 1319 goto out; 1320 } 1321 copied++; 1322 } 1323 } else { 1324 for (i = mode_group->num_crtcs; i < mode_group->num_crtcs + mode_group->num_encoders; i++) { 1325 if (put_user(mode_group->id_list[i], 1326 encoder_id + copied)) { 1327 ret = -EFAULT; 1328 goto out; 1329 } 1330 copied++; 1331 } 1332 1333 } 1334 } 1335 card_res->count_encoders = encoder_count; 1336 1337 /* Connectors */ 1338 if (card_res->count_connectors >= connector_count) { 1339 copied = 0; 1340 connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr; 1341 if (file_priv->master->minor->type == DRM_MINOR_CONTROL) { 1342 list_for_each_entry(connector, 1343 &dev->mode_config.connector_list, 1344 head) { 1345 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", 1346 connector->base.id, 1347 drm_get_connector_name(connector)); 1348 if (put_user(connector->base.id, 1349 connector_id + copied)) { 1350 ret = -EFAULT; 1351 goto out; 1352 } 1353 copied++; 1354 } 1355 } else { 1356 int start = mode_group->num_crtcs + 1357 mode_group->num_encoders; 1358 for (i = start; i < start + mode_group->num_connectors; i++) { 1359 if (put_user(mode_group->id_list[i], 1360 connector_id + copied)) { 1361 ret = -EFAULT; 1362 goto out; 1363 } 1364 copied++; 1365 } 1366 } 1367 } 1368 card_res->count_connectors = connector_count; 1369 1370 DRM_DEBUG_KMS("CRTC[%d] CONNECTORS[%d] ENCODERS[%d]\n", card_res->count_crtcs, 1371 card_res->count_connectors, card_res->count_encoders); 1372 1373 out: 1374 mutex_unlock(&dev->mode_config.mutex); 1375 return ret; 1376 } 1377 1378 /** 1379 * drm_mode_getcrtc - get CRTC configuration 1380 * @inode: inode from the ioctl 1381 * @filp: file * from the ioctl 1382 * @cmd: cmd from ioctl 1383 * @arg: arg from ioctl 1384 * 1385 * LOCKING: 1386 * Takes mode config lock. 1387 * 1388 * Construct a CRTC configuration structure to return to the user. 1389 * 1390 * Called by the user via ioctl. 1391 * 1392 * RETURNS: 1393 * Zero on success, errno on failure. 1394 */ 1395 int drm_mode_getcrtc(struct drm_device *dev, 1396 void *data, struct drm_file *file_priv) 1397 { 1398 struct drm_mode_crtc *crtc_resp = data; 1399 struct drm_crtc *crtc; 1400 struct drm_mode_object *obj; 1401 int ret = 0; 1402 1403 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1404 return -EINVAL; 1405 1406 mutex_lock(&dev->mode_config.mutex); 1407 1408 obj = drm_mode_object_find(dev, crtc_resp->crtc_id, 1409 DRM_MODE_OBJECT_CRTC); 1410 if (!obj) { 1411 ret = -EINVAL; 1412 goto out; 1413 } 1414 crtc = obj_to_crtc(obj); 1415 1416 crtc_resp->x = crtc->x; 1417 crtc_resp->y = crtc->y; 1418 crtc_resp->gamma_size = crtc->gamma_size; 1419 if (crtc->fb) 1420 crtc_resp->fb_id = crtc->fb->base.id; 1421 else 1422 crtc_resp->fb_id = 0; 1423 1424 if (crtc->enabled) { 1425 1426 drm_crtc_convert_to_umode(&crtc_resp->mode, &crtc->mode); 1427 crtc_resp->mode_valid = 1; 1428 1429 } else { 1430 crtc_resp->mode_valid = 0; 1431 } 1432 1433 out: 1434 mutex_unlock(&dev->mode_config.mutex); 1435 return ret; 1436 } 1437 1438 /** 1439 * drm_mode_getconnector - get connector configuration 1440 * @inode: inode from the ioctl 1441 * @filp: file * from the ioctl 1442 * @cmd: cmd from ioctl 1443 * @arg: arg from ioctl 1444 * 1445 * LOCKING: 1446 * Takes mode config lock. 1447 * 1448 * Construct a connector configuration structure to return to the user. 1449 * 1450 * Called by the user via ioctl. 1451 * 1452 * RETURNS: 1453 * Zero on success, errno on failure. 1454 */ 1455 int drm_mode_getconnector(struct drm_device *dev, void *data, 1456 struct drm_file *file_priv) 1457 { 1458 struct drm_mode_get_connector *out_resp = data; 1459 struct drm_mode_object *obj; 1460 struct drm_connector *connector; 1461 struct drm_display_mode *mode; 1462 int mode_count = 0; 1463 int props_count = 0; 1464 int encoders_count = 0; 1465 int ret = 0; 1466 int copied = 0; 1467 int i; 1468 struct drm_mode_modeinfo u_mode; 1469 struct drm_mode_modeinfo __user *mode_ptr; 1470 uint32_t __user *prop_ptr; 1471 uint64_t __user *prop_values; 1472 uint32_t __user *encoder_ptr; 1473 1474 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1475 return -EINVAL; 1476 1477 memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo)); 1478 1479 DRM_DEBUG_KMS("[CONNECTOR:%d:?]\n", out_resp->connector_id); 1480 1481 mutex_lock(&dev->mode_config.mutex); 1482 1483 obj = drm_mode_object_find(dev, out_resp->connector_id, 1484 DRM_MODE_OBJECT_CONNECTOR); 1485 if (!obj) { 1486 ret = -EINVAL; 1487 goto out; 1488 } 1489 connector = obj_to_connector(obj); 1490 1491 props_count = connector->properties.count; 1492 1493 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 1494 if (connector->encoder_ids[i] != 0) { 1495 encoders_count++; 1496 } 1497 } 1498 1499 if (out_resp->count_modes == 0) { 1500 connector->funcs->fill_modes(connector, 1501 dev->mode_config.max_width, 1502 dev->mode_config.max_height); 1503 } 1504 1505 /* delayed so we get modes regardless of pre-fill_modes state */ 1506 list_for_each_entry(mode, &connector->modes, head) 1507 mode_count++; 1508 1509 out_resp->connector_id = connector->base.id; 1510 out_resp->connector_type = connector->connector_type; 1511 out_resp->connector_type_id = connector->connector_type_id; 1512 out_resp->mm_width = connector->display_info.width_mm; 1513 out_resp->mm_height = connector->display_info.height_mm; 1514 out_resp->subpixel = connector->display_info.subpixel_order; 1515 out_resp->connection = connector->status; 1516 if (connector->encoder) 1517 out_resp->encoder_id = connector->encoder->base.id; 1518 else 1519 out_resp->encoder_id = 0; 1520 1521 /* 1522 * This ioctl is called twice, once to determine how much space is 1523 * needed, and the 2nd time to fill it. 1524 */ 1525 if ((out_resp->count_modes >= mode_count) && mode_count) { 1526 copied = 0; 1527 mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr; 1528 list_for_each_entry(mode, &connector->modes, head) { 1529 drm_crtc_convert_to_umode(&u_mode, mode); 1530 if (copy_to_user(mode_ptr + copied, 1531 &u_mode, sizeof(u_mode))) { 1532 ret = -EFAULT; 1533 goto out; 1534 } 1535 copied++; 1536 } 1537 } 1538 out_resp->count_modes = mode_count; 1539 1540 if ((out_resp->count_props >= props_count) && props_count) { 1541 copied = 0; 1542 prop_ptr = (uint32_t __user *)(unsigned long)(out_resp->props_ptr); 1543 prop_values = (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr); 1544 for (i = 0; i < connector->properties.count; i++) { 1545 if (put_user(connector->properties.ids[i], 1546 prop_ptr + copied)) { 1547 ret = -EFAULT; 1548 goto out; 1549 } 1550 1551 if (put_user(connector->properties.values[i], 1552 prop_values + copied)) { 1553 ret = -EFAULT; 1554 goto out; 1555 } 1556 copied++; 1557 } 1558 } 1559 out_resp->count_props = props_count; 1560 1561 if ((out_resp->count_encoders >= encoders_count) && encoders_count) { 1562 copied = 0; 1563 encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr); 1564 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 1565 if (connector->encoder_ids[i] != 0) { 1566 if (put_user(connector->encoder_ids[i], 1567 encoder_ptr + copied)) { 1568 ret = -EFAULT; 1569 goto out; 1570 } 1571 copied++; 1572 } 1573 } 1574 } 1575 out_resp->count_encoders = encoders_count; 1576 1577 out: 1578 mutex_unlock(&dev->mode_config.mutex); 1579 return ret; 1580 } 1581 1582 int drm_mode_getencoder(struct drm_device *dev, void *data, 1583 struct drm_file *file_priv) 1584 { 1585 struct drm_mode_get_encoder *enc_resp = data; 1586 struct drm_mode_object *obj; 1587 struct drm_encoder *encoder; 1588 int ret = 0; 1589 1590 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1591 return -EINVAL; 1592 1593 mutex_lock(&dev->mode_config.mutex); 1594 obj = drm_mode_object_find(dev, enc_resp->encoder_id, 1595 DRM_MODE_OBJECT_ENCODER); 1596 if (!obj) { 1597 ret = -EINVAL; 1598 goto out; 1599 } 1600 encoder = obj_to_encoder(obj); 1601 1602 if (encoder->crtc) 1603 enc_resp->crtc_id = encoder->crtc->base.id; 1604 else 1605 enc_resp->crtc_id = 0; 1606 enc_resp->encoder_type = encoder->encoder_type; 1607 enc_resp->encoder_id = encoder->base.id; 1608 enc_resp->possible_crtcs = encoder->possible_crtcs; 1609 enc_resp->possible_clones = encoder->possible_clones; 1610 1611 out: 1612 mutex_unlock(&dev->mode_config.mutex); 1613 return ret; 1614 } 1615 1616 /** 1617 * drm_mode_getplane_res - get plane info 1618 * @dev: DRM device 1619 * @data: ioctl data 1620 * @file_priv: DRM file info 1621 * 1622 * LOCKING: 1623 * Takes mode config lock. 1624 * 1625 * Return an plane count and set of IDs. 1626 */ 1627 int drm_mode_getplane_res(struct drm_device *dev, void *data, 1628 struct drm_file *file_priv) 1629 { 1630 struct drm_mode_get_plane_res *plane_resp = data; 1631 struct drm_mode_config *config; 1632 struct drm_plane *plane; 1633 uint32_t __user *plane_ptr; 1634 int copied = 0, ret = 0; 1635 1636 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1637 return -EINVAL; 1638 1639 mutex_lock(&dev->mode_config.mutex); 1640 config = &dev->mode_config; 1641 1642 /* 1643 * This ioctl is called twice, once to determine how much space is 1644 * needed, and the 2nd time to fill it. 1645 */ 1646 if (config->num_plane && 1647 (plane_resp->count_planes >= config->num_plane)) { 1648 plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr; 1649 1650 list_for_each_entry(plane, &config->plane_list, head) { 1651 if (put_user(plane->base.id, plane_ptr + copied)) { 1652 ret = -EFAULT; 1653 goto out; 1654 } 1655 copied++; 1656 } 1657 } 1658 plane_resp->count_planes = config->num_plane; 1659 1660 out: 1661 mutex_unlock(&dev->mode_config.mutex); 1662 return ret; 1663 } 1664 1665 /** 1666 * drm_mode_getplane - get plane info 1667 * @dev: DRM device 1668 * @data: ioctl data 1669 * @file_priv: DRM file info 1670 * 1671 * LOCKING: 1672 * Takes mode config lock. 1673 * 1674 * Return plane info, including formats supported, gamma size, any 1675 * current fb, etc. 1676 */ 1677 int drm_mode_getplane(struct drm_device *dev, void *data, 1678 struct drm_file *file_priv) 1679 { 1680 struct drm_mode_get_plane *plane_resp = data; 1681 struct drm_mode_object *obj; 1682 struct drm_plane *plane; 1683 uint32_t __user *format_ptr; 1684 int ret = 0; 1685 1686 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1687 return -EINVAL; 1688 1689 mutex_lock(&dev->mode_config.mutex); 1690 obj = drm_mode_object_find(dev, plane_resp->plane_id, 1691 DRM_MODE_OBJECT_PLANE); 1692 if (!obj) { 1693 ret = -ENOENT; 1694 goto out; 1695 } 1696 plane = obj_to_plane(obj); 1697 1698 if (plane->crtc) 1699 plane_resp->crtc_id = plane->crtc->base.id; 1700 else 1701 plane_resp->crtc_id = 0; 1702 1703 if (plane->fb) 1704 plane_resp->fb_id = plane->fb->base.id; 1705 else 1706 plane_resp->fb_id = 0; 1707 1708 plane_resp->plane_id = plane->base.id; 1709 plane_resp->possible_crtcs = plane->possible_crtcs; 1710 plane_resp->gamma_size = plane->gamma_size; 1711 1712 /* 1713 * This ioctl is called twice, once to determine how much space is 1714 * needed, and the 2nd time to fill it. 1715 */ 1716 if (plane->format_count && 1717 (plane_resp->count_format_types >= plane->format_count)) { 1718 format_ptr = (uint32_t __user *)(unsigned long)plane_resp->format_type_ptr; 1719 if (copy_to_user(format_ptr, 1720 plane->format_types, 1721 sizeof(uint32_t) * plane->format_count)) { 1722 ret = -EFAULT; 1723 goto out; 1724 } 1725 } 1726 plane_resp->count_format_types = plane->format_count; 1727 1728 out: 1729 mutex_unlock(&dev->mode_config.mutex); 1730 return ret; 1731 } 1732 1733 /** 1734 * drm_mode_setplane - set up or tear down an plane 1735 * @dev: DRM device 1736 * @data: ioctl data* 1737 * @file_prive: DRM file info 1738 * 1739 * LOCKING: 1740 * Takes mode config lock. 1741 * 1742 * Set plane info, including placement, fb, scaling, and other factors. 1743 * Or pass a NULL fb to disable. 1744 */ 1745 int drm_mode_setplane(struct drm_device *dev, void *data, 1746 struct drm_file *file_priv) 1747 { 1748 struct drm_mode_set_plane *plane_req = data; 1749 struct drm_mode_object *obj; 1750 struct drm_plane *plane; 1751 struct drm_crtc *crtc; 1752 struct drm_framebuffer *fb; 1753 int ret = 0; 1754 unsigned int fb_width, fb_height; 1755 int i; 1756 1757 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1758 return -EINVAL; 1759 1760 mutex_lock(&dev->mode_config.mutex); 1761 1762 /* 1763 * First, find the plane, crtc, and fb objects. If not available, 1764 * we don't bother to call the driver. 1765 */ 1766 obj = drm_mode_object_find(dev, plane_req->plane_id, 1767 DRM_MODE_OBJECT_PLANE); 1768 if (!obj) { 1769 DRM_DEBUG_KMS("Unknown plane ID %d\n", 1770 plane_req->plane_id); 1771 ret = -ENOENT; 1772 goto out; 1773 } 1774 plane = obj_to_plane(obj); 1775 1776 /* No fb means shut it down */ 1777 if (!plane_req->fb_id) { 1778 plane->funcs->disable_plane(plane); 1779 plane->crtc = NULL; 1780 plane->fb = NULL; 1781 goto out; 1782 } 1783 1784 obj = drm_mode_object_find(dev, plane_req->crtc_id, 1785 DRM_MODE_OBJECT_CRTC); 1786 if (!obj) { 1787 DRM_DEBUG_KMS("Unknown crtc ID %d\n", 1788 plane_req->crtc_id); 1789 ret = -ENOENT; 1790 goto out; 1791 } 1792 crtc = obj_to_crtc(obj); 1793 1794 obj = drm_mode_object_find(dev, plane_req->fb_id, 1795 DRM_MODE_OBJECT_FB); 1796 if (!obj) { 1797 DRM_DEBUG_KMS("Unknown framebuffer ID %d\n", 1798 plane_req->fb_id); 1799 ret = -ENOENT; 1800 goto out; 1801 } 1802 fb = obj_to_fb(obj); 1803 1804 /* Check whether this plane supports the fb pixel format. */ 1805 for (i = 0; i < plane->format_count; i++) 1806 if (fb->pixel_format == plane->format_types[i]) 1807 break; 1808 if (i == plane->format_count) { 1809 DRM_DEBUG_KMS("Invalid pixel format 0x%08x\n", fb->pixel_format); 1810 ret = -EINVAL; 1811 goto out; 1812 } 1813 1814 fb_width = fb->width << 16; 1815 fb_height = fb->height << 16; 1816 1817 /* Make sure source coordinates are inside the fb. */ 1818 if (plane_req->src_w > fb_width || 1819 plane_req->src_x > fb_width - plane_req->src_w || 1820 plane_req->src_h > fb_height || 1821 plane_req->src_y > fb_height - plane_req->src_h) { 1822 DRM_DEBUG_KMS("Invalid source coordinates " 1823 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n", 1824 plane_req->src_w >> 16, 1825 ((plane_req->src_w & 0xffff) * 15625) >> 10, 1826 plane_req->src_h >> 16, 1827 ((plane_req->src_h & 0xffff) * 15625) >> 10, 1828 plane_req->src_x >> 16, 1829 ((plane_req->src_x & 0xffff) * 15625) >> 10, 1830 plane_req->src_y >> 16, 1831 ((plane_req->src_y & 0xffff) * 15625) >> 10); 1832 ret = -ENOSPC; 1833 goto out; 1834 } 1835 1836 /* Give drivers some help against integer overflows */ 1837 if (plane_req->crtc_w > INT_MAX || 1838 plane_req->crtc_x > INT_MAX - (int32_t) plane_req->crtc_w || 1839 plane_req->crtc_h > INT_MAX || 1840 plane_req->crtc_y > INT_MAX - (int32_t) plane_req->crtc_h) { 1841 DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n", 1842 plane_req->crtc_w, plane_req->crtc_h, 1843 plane_req->crtc_x, plane_req->crtc_y); 1844 ret = -ERANGE; 1845 goto out; 1846 } 1847 1848 ret = plane->funcs->update_plane(plane, crtc, fb, 1849 plane_req->crtc_x, plane_req->crtc_y, 1850 plane_req->crtc_w, plane_req->crtc_h, 1851 plane_req->src_x, plane_req->src_y, 1852 plane_req->src_w, plane_req->src_h); 1853 if (!ret) { 1854 plane->crtc = crtc; 1855 plane->fb = fb; 1856 } 1857 1858 out: 1859 mutex_unlock(&dev->mode_config.mutex); 1860 1861 return ret; 1862 } 1863 1864 /** 1865 * drm_mode_setcrtc - set CRTC configuration 1866 * @inode: inode from the ioctl 1867 * @filp: file * from the ioctl 1868 * @cmd: cmd from ioctl 1869 * @arg: arg from ioctl 1870 * 1871 * LOCKING: 1872 * Takes mode config lock. 1873 * 1874 * Build a new CRTC configuration based on user request. 1875 * 1876 * Called by the user via ioctl. 1877 * 1878 * RETURNS: 1879 * Zero on success, errno on failure. 1880 */ 1881 int drm_mode_setcrtc(struct drm_device *dev, void *data, 1882 struct drm_file *file_priv) 1883 { 1884 struct drm_mode_config *config = &dev->mode_config; 1885 struct drm_mode_crtc *crtc_req = data; 1886 struct drm_mode_object *obj; 1887 struct drm_crtc *crtc; 1888 struct drm_connector **connector_set = NULL, *connector; 1889 struct drm_framebuffer *fb = NULL; 1890 struct drm_display_mode *mode = NULL; 1891 struct drm_mode_set set; 1892 uint32_t __user *set_connectors_ptr; 1893 int ret; 1894 int i; 1895 1896 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1897 return -EINVAL; 1898 1899 /* For some reason crtc x/y offsets are signed internally. */ 1900 if (crtc_req->x > INT_MAX || crtc_req->y > INT_MAX) 1901 return -ERANGE; 1902 1903 mutex_lock(&dev->mode_config.mutex); 1904 obj = drm_mode_object_find(dev, crtc_req->crtc_id, 1905 DRM_MODE_OBJECT_CRTC); 1906 if (!obj) { 1907 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id); 1908 ret = -EINVAL; 1909 goto out; 1910 } 1911 crtc = obj_to_crtc(obj); 1912 DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id); 1913 1914 if (crtc_req->mode_valid) { 1915 int hdisplay, vdisplay; 1916 /* If we have a mode we need a framebuffer. */ 1917 /* If we pass -1, set the mode with the currently bound fb */ 1918 if (crtc_req->fb_id == -1) { 1919 if (!crtc->fb) { 1920 DRM_DEBUG_KMS("CRTC doesn't have current FB\n"); 1921 ret = -EINVAL; 1922 goto out; 1923 } 1924 fb = crtc->fb; 1925 } else { 1926 obj = drm_mode_object_find(dev, crtc_req->fb_id, 1927 DRM_MODE_OBJECT_FB); 1928 if (!obj) { 1929 DRM_DEBUG_KMS("Unknown FB ID%d\n", 1930 crtc_req->fb_id); 1931 ret = -EINVAL; 1932 goto out; 1933 } 1934 fb = obj_to_fb(obj); 1935 } 1936 1937 mode = drm_mode_create(dev); 1938 if (!mode) { 1939 ret = -ENOMEM; 1940 goto out; 1941 } 1942 1943 ret = drm_crtc_convert_umode(mode, &crtc_req->mode); 1944 if (ret) { 1945 DRM_DEBUG_KMS("Invalid mode\n"); 1946 goto out; 1947 } 1948 1949 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V); 1950 1951 hdisplay = mode->hdisplay; 1952 vdisplay = mode->vdisplay; 1953 1954 if (crtc->invert_dimensions) 1955 swap(hdisplay, vdisplay); 1956 1957 if (hdisplay > fb->width || 1958 vdisplay > fb->height || 1959 crtc_req->x > fb->width - hdisplay || 1960 crtc_req->y > fb->height - vdisplay) { 1961 DRM_DEBUG_KMS("Invalid fb size %ux%u for CRTC viewport %ux%u+%d+%d%s.\n", 1962 fb->width, fb->height, 1963 hdisplay, vdisplay, crtc_req->x, crtc_req->y, 1964 crtc->invert_dimensions ? " (inverted)" : ""); 1965 ret = -ENOSPC; 1966 goto out; 1967 } 1968 } 1969 1970 if (crtc_req->count_connectors == 0 && mode) { 1971 DRM_DEBUG_KMS("Count connectors is 0 but mode set\n"); 1972 ret = -EINVAL; 1973 goto out; 1974 } 1975 1976 if (crtc_req->count_connectors > 0 && (!mode || !fb)) { 1977 DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n", 1978 crtc_req->count_connectors); 1979 ret = -EINVAL; 1980 goto out; 1981 } 1982 1983 if (crtc_req->count_connectors > 0) { 1984 u32 out_id; 1985 1986 /* Avoid unbounded kernel memory allocation */ 1987 if (crtc_req->count_connectors > config->num_connector) { 1988 ret = -EINVAL; 1989 goto out; 1990 } 1991 1992 connector_set = kmalloc(crtc_req->count_connectors * 1993 sizeof(struct drm_connector *), 1994 GFP_KERNEL); 1995 if (!connector_set) { 1996 ret = -ENOMEM; 1997 goto out; 1998 } 1999 2000 for (i = 0; i < crtc_req->count_connectors; i++) { 2001 set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr; 2002 if (get_user(out_id, &set_connectors_ptr[i])) { 2003 ret = -EFAULT; 2004 goto out; 2005 } 2006 2007 obj = drm_mode_object_find(dev, out_id, 2008 DRM_MODE_OBJECT_CONNECTOR); 2009 if (!obj) { 2010 DRM_DEBUG_KMS("Connector id %d unknown\n", 2011 out_id); 2012 ret = -EINVAL; 2013 goto out; 2014 } 2015 connector = obj_to_connector(obj); 2016 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", 2017 connector->base.id, 2018 drm_get_connector_name(connector)); 2019 2020 connector_set[i] = connector; 2021 } 2022 } 2023 2024 set.crtc = crtc; 2025 set.x = crtc_req->x; 2026 set.y = crtc_req->y; 2027 set.mode = mode; 2028 set.connectors = connector_set; 2029 set.num_connectors = crtc_req->count_connectors; 2030 set.fb = fb; 2031 ret = crtc->funcs->set_config(&set); 2032 2033 out: 2034 kfree(connector_set); 2035 drm_mode_destroy(dev, mode); 2036 mutex_unlock(&dev->mode_config.mutex); 2037 return ret; 2038 } 2039 2040 int drm_mode_cursor_ioctl(struct drm_device *dev, 2041 void *data, struct drm_file *file_priv) 2042 { 2043 struct drm_mode_cursor *req = data; 2044 struct drm_mode_object *obj; 2045 struct drm_crtc *crtc; 2046 int ret = 0; 2047 2048 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2049 return -EINVAL; 2050 2051 if (!req->flags || (~DRM_MODE_CURSOR_FLAGS & req->flags)) 2052 return -EINVAL; 2053 2054 mutex_lock(&dev->mode_config.mutex); 2055 obj = drm_mode_object_find(dev, req->crtc_id, DRM_MODE_OBJECT_CRTC); 2056 if (!obj) { 2057 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id); 2058 ret = -EINVAL; 2059 goto out; 2060 } 2061 crtc = obj_to_crtc(obj); 2062 2063 if (req->flags & DRM_MODE_CURSOR_BO) { 2064 if (!crtc->funcs->cursor_set) { 2065 ret = -ENXIO; 2066 goto out; 2067 } 2068 /* Turns off the cursor if handle is 0 */ 2069 ret = crtc->funcs->cursor_set(crtc, file_priv, req->handle, 2070 req->width, req->height); 2071 } 2072 2073 if (req->flags & DRM_MODE_CURSOR_MOVE) { 2074 if (crtc->funcs->cursor_move) { 2075 ret = crtc->funcs->cursor_move(crtc, req->x, req->y); 2076 } else { 2077 ret = -EFAULT; 2078 goto out; 2079 } 2080 } 2081 out: 2082 mutex_unlock(&dev->mode_config.mutex); 2083 return ret; 2084 } 2085 2086 /* Original addfb only supported RGB formats, so figure out which one */ 2087 uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth) 2088 { 2089 uint32_t fmt; 2090 2091 switch (bpp) { 2092 case 8: 2093 fmt = DRM_FORMAT_RGB332; 2094 break; 2095 case 16: 2096 if (depth == 15) 2097 fmt = DRM_FORMAT_XRGB1555; 2098 else 2099 fmt = DRM_FORMAT_RGB565; 2100 break; 2101 case 24: 2102 fmt = DRM_FORMAT_RGB888; 2103 break; 2104 case 32: 2105 if (depth == 24) 2106 fmt = DRM_FORMAT_XRGB8888; 2107 else if (depth == 30) 2108 fmt = DRM_FORMAT_XRGB2101010; 2109 else 2110 fmt = DRM_FORMAT_ARGB8888; 2111 break; 2112 default: 2113 DRM_ERROR("bad bpp, assuming x8r8g8b8 pixel format\n"); 2114 fmt = DRM_FORMAT_XRGB8888; 2115 break; 2116 } 2117 2118 return fmt; 2119 } 2120 EXPORT_SYMBOL(drm_mode_legacy_fb_format); 2121 2122 /** 2123 * drm_mode_addfb - add an FB to the graphics configuration 2124 * @inode: inode from the ioctl 2125 * @filp: file * from the ioctl 2126 * @cmd: cmd from ioctl 2127 * @arg: arg from ioctl 2128 * 2129 * LOCKING: 2130 * Takes mode config lock. 2131 * 2132 * Add a new FB to the specified CRTC, given a user request. 2133 * 2134 * Called by the user via ioctl. 2135 * 2136 * RETURNS: 2137 * Zero on success, errno on failure. 2138 */ 2139 int drm_mode_addfb(struct drm_device *dev, 2140 void *data, struct drm_file *file_priv) 2141 { 2142 struct drm_mode_fb_cmd *or = data; 2143 struct drm_mode_fb_cmd2 r = {}; 2144 struct drm_mode_config *config = &dev->mode_config; 2145 struct drm_framebuffer *fb; 2146 int ret = 0; 2147 2148 /* Use new struct with format internally */ 2149 r.fb_id = or->fb_id; 2150 r.width = or->width; 2151 r.height = or->height; 2152 r.pitches[0] = or->pitch; 2153 r.pixel_format = drm_mode_legacy_fb_format(or->bpp, or->depth); 2154 r.handles[0] = or->handle; 2155 2156 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2157 return -EINVAL; 2158 2159 if ((config->min_width > r.width) || (r.width > config->max_width)) 2160 return -EINVAL; 2161 2162 if ((config->min_height > r.height) || (r.height > config->max_height)) 2163 return -EINVAL; 2164 2165 mutex_lock(&dev->mode_config.mutex); 2166 2167 /* TODO check buffer is sufficiently large */ 2168 /* TODO setup destructor callback */ 2169 2170 fb = dev->mode_config.funcs->fb_create(dev, file_priv, &r); 2171 if (IS_ERR(fb)) { 2172 DRM_DEBUG_KMS("could not create framebuffer\n"); 2173 ret = PTR_ERR(fb); 2174 goto out; 2175 } 2176 2177 or->fb_id = fb->base.id; 2178 list_add(&fb->filp_head, &file_priv->fbs); 2179 DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id); 2180 2181 out: 2182 mutex_unlock(&dev->mode_config.mutex); 2183 return ret; 2184 } 2185 2186 static int format_check(const struct drm_mode_fb_cmd2 *r) 2187 { 2188 uint32_t format = r->pixel_format & ~DRM_FORMAT_BIG_ENDIAN; 2189 2190 switch (format) { 2191 case DRM_FORMAT_C8: 2192 case DRM_FORMAT_RGB332: 2193 case DRM_FORMAT_BGR233: 2194 case DRM_FORMAT_XRGB4444: 2195 case DRM_FORMAT_XBGR4444: 2196 case DRM_FORMAT_RGBX4444: 2197 case DRM_FORMAT_BGRX4444: 2198 case DRM_FORMAT_ARGB4444: 2199 case DRM_FORMAT_ABGR4444: 2200 case DRM_FORMAT_RGBA4444: 2201 case DRM_FORMAT_BGRA4444: 2202 case DRM_FORMAT_XRGB1555: 2203 case DRM_FORMAT_XBGR1555: 2204 case DRM_FORMAT_RGBX5551: 2205 case DRM_FORMAT_BGRX5551: 2206 case DRM_FORMAT_ARGB1555: 2207 case DRM_FORMAT_ABGR1555: 2208 case DRM_FORMAT_RGBA5551: 2209 case DRM_FORMAT_BGRA5551: 2210 case DRM_FORMAT_RGB565: 2211 case DRM_FORMAT_BGR565: 2212 case DRM_FORMAT_RGB888: 2213 case DRM_FORMAT_BGR888: 2214 case DRM_FORMAT_XRGB8888: 2215 case DRM_FORMAT_XBGR8888: 2216 case DRM_FORMAT_RGBX8888: 2217 case DRM_FORMAT_BGRX8888: 2218 case DRM_FORMAT_ARGB8888: 2219 case DRM_FORMAT_ABGR8888: 2220 case DRM_FORMAT_RGBA8888: 2221 case DRM_FORMAT_BGRA8888: 2222 case DRM_FORMAT_XRGB2101010: 2223 case DRM_FORMAT_XBGR2101010: 2224 case DRM_FORMAT_RGBX1010102: 2225 case DRM_FORMAT_BGRX1010102: 2226 case DRM_FORMAT_ARGB2101010: 2227 case DRM_FORMAT_ABGR2101010: 2228 case DRM_FORMAT_RGBA1010102: 2229 case DRM_FORMAT_BGRA1010102: 2230 case DRM_FORMAT_YUYV: 2231 case DRM_FORMAT_YVYU: 2232 case DRM_FORMAT_UYVY: 2233 case DRM_FORMAT_VYUY: 2234 case DRM_FORMAT_AYUV: 2235 case DRM_FORMAT_NV12: 2236 case DRM_FORMAT_NV21: 2237 case DRM_FORMAT_NV16: 2238 case DRM_FORMAT_NV61: 2239 case DRM_FORMAT_NV24: 2240 case DRM_FORMAT_NV42: 2241 case DRM_FORMAT_YUV410: 2242 case DRM_FORMAT_YVU410: 2243 case DRM_FORMAT_YUV411: 2244 case DRM_FORMAT_YVU411: 2245 case DRM_FORMAT_YUV420: 2246 case DRM_FORMAT_YVU420: 2247 case DRM_FORMAT_YUV422: 2248 case DRM_FORMAT_YVU422: 2249 case DRM_FORMAT_YUV444: 2250 case DRM_FORMAT_YVU444: 2251 return 0; 2252 default: 2253 return -EINVAL; 2254 } 2255 } 2256 2257 static int framebuffer_check(const struct drm_mode_fb_cmd2 *r) 2258 { 2259 int ret, hsub, vsub, num_planes, i; 2260 2261 ret = format_check(r); 2262 if (ret) { 2263 DRM_DEBUG_KMS("bad framebuffer format 0x%08x\n", r->pixel_format); 2264 return ret; 2265 } 2266 2267 hsub = drm_format_horz_chroma_subsampling(r->pixel_format); 2268 vsub = drm_format_vert_chroma_subsampling(r->pixel_format); 2269 num_planes = drm_format_num_planes(r->pixel_format); 2270 2271 if (r->width == 0 || r->width % hsub) { 2272 DRM_DEBUG_KMS("bad framebuffer width %u\n", r->height); 2273 return -EINVAL; 2274 } 2275 2276 if (r->height == 0 || r->height % vsub) { 2277 DRM_DEBUG_KMS("bad framebuffer height %u\n", r->height); 2278 return -EINVAL; 2279 } 2280 2281 for (i = 0; i < num_planes; i++) { 2282 unsigned int width = r->width / (i != 0 ? hsub : 1); 2283 2284 if (!r->handles[i]) { 2285 DRM_DEBUG_KMS("no buffer object handle for plane %d\n", i); 2286 return -EINVAL; 2287 } 2288 2289 if (r->pitches[i] < drm_format_plane_cpp(r->pixel_format, i) * width) { 2290 DRM_DEBUG_KMS("bad pitch %u for plane %d\n", r->pitches[i], i); 2291 return -EINVAL; 2292 } 2293 } 2294 2295 return 0; 2296 } 2297 2298 /** 2299 * drm_mode_addfb2 - add an FB to the graphics configuration 2300 * @inode: inode from the ioctl 2301 * @filp: file * from the ioctl 2302 * @cmd: cmd from ioctl 2303 * @arg: arg from ioctl 2304 * 2305 * LOCKING: 2306 * Takes mode config lock. 2307 * 2308 * Add a new FB to the specified CRTC, given a user request with format. 2309 * 2310 * Called by the user via ioctl. 2311 * 2312 * RETURNS: 2313 * Zero on success, errno on failure. 2314 */ 2315 int drm_mode_addfb2(struct drm_device *dev, 2316 void *data, struct drm_file *file_priv) 2317 { 2318 struct drm_mode_fb_cmd2 *r = data; 2319 struct drm_mode_config *config = &dev->mode_config; 2320 struct drm_framebuffer *fb; 2321 int ret; 2322 2323 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2324 return -EINVAL; 2325 2326 if ((config->min_width > r->width) || (r->width > config->max_width)) { 2327 DRM_DEBUG_KMS("bad framebuffer width %d, should be >= %d && <= %d\n", 2328 r->width, config->min_width, config->max_width); 2329 return -EINVAL; 2330 } 2331 if ((config->min_height > r->height) || (r->height > config->max_height)) { 2332 DRM_DEBUG_KMS("bad framebuffer height %d, should be >= %d && <= %d\n", 2333 r->height, config->min_height, config->max_height); 2334 return -EINVAL; 2335 } 2336 2337 ret = framebuffer_check(r); 2338 if (ret) 2339 return ret; 2340 2341 mutex_lock(&dev->mode_config.mutex); 2342 2343 fb = dev->mode_config.funcs->fb_create(dev, file_priv, r); 2344 if (IS_ERR(fb)) { 2345 DRM_DEBUG_KMS("could not create framebuffer\n"); 2346 ret = PTR_ERR(fb); 2347 goto out; 2348 } 2349 2350 r->fb_id = fb->base.id; 2351 list_add(&fb->filp_head, &file_priv->fbs); 2352 DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id); 2353 2354 out: 2355 mutex_unlock(&dev->mode_config.mutex); 2356 return ret; 2357 } 2358 2359 /** 2360 * drm_mode_rmfb - remove an FB from the configuration 2361 * @inode: inode from the ioctl 2362 * @filp: file * from the ioctl 2363 * @cmd: cmd from ioctl 2364 * @arg: arg from ioctl 2365 * 2366 * LOCKING: 2367 * Takes mode config lock. 2368 * 2369 * Remove the FB specified by the user. 2370 * 2371 * Called by the user via ioctl. 2372 * 2373 * RETURNS: 2374 * Zero on success, errno on failure. 2375 */ 2376 int drm_mode_rmfb(struct drm_device *dev, 2377 void *data, struct drm_file *file_priv) 2378 { 2379 struct drm_mode_object *obj; 2380 struct drm_framebuffer *fb = NULL; 2381 struct drm_framebuffer *fbl = NULL; 2382 uint32_t *id = data; 2383 int ret = 0; 2384 int found = 0; 2385 2386 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2387 return -EINVAL; 2388 2389 mutex_lock(&dev->mode_config.mutex); 2390 obj = drm_mode_object_find(dev, *id, DRM_MODE_OBJECT_FB); 2391 /* TODO check that we really get a framebuffer back. */ 2392 if (!obj) { 2393 ret = -EINVAL; 2394 goto out; 2395 } 2396 fb = obj_to_fb(obj); 2397 2398 list_for_each_entry(fbl, &file_priv->fbs, filp_head) 2399 if (fb == fbl) 2400 found = 1; 2401 2402 if (!found) { 2403 ret = -EINVAL; 2404 goto out; 2405 } 2406 2407 drm_framebuffer_remove(fb); 2408 2409 out: 2410 mutex_unlock(&dev->mode_config.mutex); 2411 return ret; 2412 } 2413 2414 /** 2415 * drm_mode_getfb - get FB info 2416 * @inode: inode from the ioctl 2417 * @filp: file * from the ioctl 2418 * @cmd: cmd from ioctl 2419 * @arg: arg from ioctl 2420 * 2421 * LOCKING: 2422 * Takes mode config lock. 2423 * 2424 * Lookup the FB given its ID and return info about it. 2425 * 2426 * Called by the user via ioctl. 2427 * 2428 * RETURNS: 2429 * Zero on success, errno on failure. 2430 */ 2431 int drm_mode_getfb(struct drm_device *dev, 2432 void *data, struct drm_file *file_priv) 2433 { 2434 struct drm_mode_fb_cmd *r = data; 2435 struct drm_mode_object *obj; 2436 struct drm_framebuffer *fb; 2437 int ret = 0; 2438 2439 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2440 return -EINVAL; 2441 2442 mutex_lock(&dev->mode_config.mutex); 2443 obj = drm_mode_object_find(dev, r->fb_id, DRM_MODE_OBJECT_FB); 2444 if (!obj) { 2445 ret = -EINVAL; 2446 goto out; 2447 } 2448 fb = obj_to_fb(obj); 2449 2450 r->height = fb->height; 2451 r->width = fb->width; 2452 r->depth = fb->depth; 2453 r->bpp = fb->bits_per_pixel; 2454 r->pitch = fb->pitches[0]; 2455 fb->funcs->create_handle(fb, file_priv, &r->handle); 2456 2457 out: 2458 mutex_unlock(&dev->mode_config.mutex); 2459 return ret; 2460 } 2461 2462 int drm_mode_dirtyfb_ioctl(struct drm_device *dev, 2463 void *data, struct drm_file *file_priv) 2464 { 2465 struct drm_clip_rect __user *clips_ptr; 2466 struct drm_clip_rect *clips = NULL; 2467 struct drm_mode_fb_dirty_cmd *r = data; 2468 struct drm_mode_object *obj; 2469 struct drm_framebuffer *fb; 2470 unsigned flags; 2471 int num_clips; 2472 int ret; 2473 2474 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2475 return -EINVAL; 2476 2477 mutex_lock(&dev->mode_config.mutex); 2478 obj = drm_mode_object_find(dev, r->fb_id, DRM_MODE_OBJECT_FB); 2479 if (!obj) { 2480 ret = -EINVAL; 2481 goto out_err1; 2482 } 2483 fb = obj_to_fb(obj); 2484 2485 num_clips = r->num_clips; 2486 clips_ptr = (struct drm_clip_rect __user *)(unsigned long)r->clips_ptr; 2487 2488 if (!num_clips != !clips_ptr) { 2489 ret = -EINVAL; 2490 goto out_err1; 2491 } 2492 2493 flags = DRM_MODE_FB_DIRTY_FLAGS & r->flags; 2494 2495 /* If userspace annotates copy, clips must come in pairs */ 2496 if (flags & DRM_MODE_FB_DIRTY_ANNOTATE_COPY && (num_clips % 2)) { 2497 ret = -EINVAL; 2498 goto out_err1; 2499 } 2500 2501 if (num_clips && clips_ptr) { 2502 if (num_clips < 0 || num_clips > DRM_MODE_FB_DIRTY_MAX_CLIPS) { 2503 ret = -EINVAL; 2504 goto out_err1; 2505 } 2506 clips = kzalloc(num_clips * sizeof(*clips), GFP_KERNEL); 2507 if (!clips) { 2508 ret = -ENOMEM; 2509 goto out_err1; 2510 } 2511 2512 ret = copy_from_user(clips, clips_ptr, 2513 num_clips * sizeof(*clips)); 2514 if (ret) { 2515 ret = -EFAULT; 2516 goto out_err2; 2517 } 2518 } 2519 2520 if (fb->funcs->dirty) { 2521 ret = fb->funcs->dirty(fb, file_priv, flags, r->color, 2522 clips, num_clips); 2523 } else { 2524 ret = -ENOSYS; 2525 goto out_err2; 2526 } 2527 2528 out_err2: 2529 kfree(clips); 2530 out_err1: 2531 mutex_unlock(&dev->mode_config.mutex); 2532 return ret; 2533 } 2534 2535 2536 /** 2537 * drm_fb_release - remove and free the FBs on this file 2538 * @filp: file * from the ioctl 2539 * 2540 * LOCKING: 2541 * Takes mode config lock. 2542 * 2543 * Destroy all the FBs associated with @filp. 2544 * 2545 * Called by the user via ioctl. 2546 * 2547 * RETURNS: 2548 * Zero on success, errno on failure. 2549 */ 2550 void drm_fb_release(struct drm_file *priv) 2551 { 2552 struct drm_device *dev = priv->minor->dev; 2553 struct drm_framebuffer *fb, *tfb; 2554 2555 mutex_lock(&dev->mode_config.mutex); 2556 list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) { 2557 drm_framebuffer_remove(fb); 2558 } 2559 mutex_unlock(&dev->mode_config.mutex); 2560 } 2561 2562 /** 2563 * drm_mode_attachmode - add a mode to the user mode list 2564 * @dev: DRM device 2565 * @connector: connector to add the mode to 2566 * @mode: mode to add 2567 * 2568 * Add @mode to @connector's user mode list. 2569 */ 2570 static void drm_mode_attachmode(struct drm_device *dev, 2571 struct drm_connector *connector, 2572 struct drm_display_mode *mode) 2573 { 2574 list_add_tail(&mode->head, &connector->user_modes); 2575 } 2576 2577 int drm_mode_attachmode_crtc(struct drm_device *dev, struct drm_crtc *crtc, 2578 const struct drm_display_mode *mode) 2579 { 2580 struct drm_connector *connector; 2581 int ret = 0; 2582 struct drm_display_mode *dup_mode, *next; 2583 LIST_HEAD(list); 2584 2585 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 2586 if (!connector->encoder) 2587 continue; 2588 if (connector->encoder->crtc == crtc) { 2589 dup_mode = drm_mode_duplicate(dev, mode); 2590 if (!dup_mode) { 2591 ret = -ENOMEM; 2592 goto out; 2593 } 2594 list_add_tail(&dup_mode->head, &list); 2595 } 2596 } 2597 2598 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 2599 if (!connector->encoder) 2600 continue; 2601 if (connector->encoder->crtc == crtc) 2602 list_move_tail(list.next, &connector->user_modes); 2603 } 2604 2605 WARN_ON(!list_empty(&list)); 2606 2607 out: 2608 list_for_each_entry_safe(dup_mode, next, &list, head) 2609 drm_mode_destroy(dev, dup_mode); 2610 2611 return ret; 2612 } 2613 EXPORT_SYMBOL(drm_mode_attachmode_crtc); 2614 2615 static int drm_mode_detachmode(struct drm_device *dev, 2616 struct drm_connector *connector, 2617 struct drm_display_mode *mode) 2618 { 2619 int found = 0; 2620 int ret = 0; 2621 struct drm_display_mode *match_mode, *t; 2622 2623 list_for_each_entry_safe(match_mode, t, &connector->user_modes, head) { 2624 if (drm_mode_equal(match_mode, mode)) { 2625 list_del(&match_mode->head); 2626 drm_mode_destroy(dev, match_mode); 2627 found = 1; 2628 break; 2629 } 2630 } 2631 2632 if (!found) 2633 ret = -EINVAL; 2634 2635 return ret; 2636 } 2637 2638 int drm_mode_detachmode_crtc(struct drm_device *dev, struct drm_display_mode *mode) 2639 { 2640 struct drm_connector *connector; 2641 2642 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 2643 drm_mode_detachmode(dev, connector, mode); 2644 } 2645 return 0; 2646 } 2647 EXPORT_SYMBOL(drm_mode_detachmode_crtc); 2648 2649 /** 2650 * drm_fb_attachmode - Attach a user mode to an connector 2651 * @inode: inode from the ioctl 2652 * @filp: file * from the ioctl 2653 * @cmd: cmd from ioctl 2654 * @arg: arg from ioctl 2655 * 2656 * This attaches a user specified mode to an connector. 2657 * Called by the user via ioctl. 2658 * 2659 * RETURNS: 2660 * Zero on success, errno on failure. 2661 */ 2662 int drm_mode_attachmode_ioctl(struct drm_device *dev, 2663 void *data, struct drm_file *file_priv) 2664 { 2665 struct drm_mode_mode_cmd *mode_cmd = data; 2666 struct drm_connector *connector; 2667 struct drm_display_mode *mode; 2668 struct drm_mode_object *obj; 2669 struct drm_mode_modeinfo *umode = &mode_cmd->mode; 2670 int ret; 2671 2672 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2673 return -EINVAL; 2674 2675 mutex_lock(&dev->mode_config.mutex); 2676 2677 obj = drm_mode_object_find(dev, mode_cmd->connector_id, DRM_MODE_OBJECT_CONNECTOR); 2678 if (!obj) { 2679 ret = -EINVAL; 2680 goto out; 2681 } 2682 connector = obj_to_connector(obj); 2683 2684 mode = drm_mode_create(dev); 2685 if (!mode) { 2686 ret = -ENOMEM; 2687 goto out; 2688 } 2689 2690 ret = drm_crtc_convert_umode(mode, umode); 2691 if (ret) { 2692 DRM_DEBUG_KMS("Invalid mode\n"); 2693 drm_mode_destroy(dev, mode); 2694 goto out; 2695 } 2696 2697 drm_mode_attachmode(dev, connector, mode); 2698 out: 2699 mutex_unlock(&dev->mode_config.mutex); 2700 return ret; 2701 } 2702 2703 2704 /** 2705 * drm_fb_detachmode - Detach a user specified mode from an connector 2706 * @inode: inode from the ioctl 2707 * @filp: file * from the ioctl 2708 * @cmd: cmd from ioctl 2709 * @arg: arg from ioctl 2710 * 2711 * Called by the user via ioctl. 2712 * 2713 * RETURNS: 2714 * Zero on success, errno on failure. 2715 */ 2716 int drm_mode_detachmode_ioctl(struct drm_device *dev, 2717 void *data, struct drm_file *file_priv) 2718 { 2719 struct drm_mode_object *obj; 2720 struct drm_mode_mode_cmd *mode_cmd = data; 2721 struct drm_connector *connector; 2722 struct drm_display_mode mode; 2723 struct drm_mode_modeinfo *umode = &mode_cmd->mode; 2724 int ret; 2725 2726 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2727 return -EINVAL; 2728 2729 mutex_lock(&dev->mode_config.mutex); 2730 2731 obj = drm_mode_object_find(dev, mode_cmd->connector_id, DRM_MODE_OBJECT_CONNECTOR); 2732 if (!obj) { 2733 ret = -EINVAL; 2734 goto out; 2735 } 2736 connector = obj_to_connector(obj); 2737 2738 ret = drm_crtc_convert_umode(&mode, umode); 2739 if (ret) { 2740 DRM_DEBUG_KMS("Invalid mode\n"); 2741 goto out; 2742 } 2743 2744 ret = drm_mode_detachmode(dev, connector, &mode); 2745 out: 2746 mutex_unlock(&dev->mode_config.mutex); 2747 return ret; 2748 } 2749 2750 struct drm_property *drm_property_create(struct drm_device *dev, int flags, 2751 const char *name, int num_values) 2752 { 2753 struct drm_property *property = NULL; 2754 int ret; 2755 2756 property = kzalloc(sizeof(struct drm_property), GFP_KERNEL); 2757 if (!property) 2758 return NULL; 2759 2760 if (num_values) { 2761 property->values = kzalloc(sizeof(uint64_t)*num_values, GFP_KERNEL); 2762 if (!property->values) 2763 goto fail; 2764 } 2765 2766 ret = drm_mode_object_get(dev, &property->base, DRM_MODE_OBJECT_PROPERTY); 2767 if (ret) 2768 goto fail; 2769 2770 property->flags = flags; 2771 property->num_values = num_values; 2772 INIT_LIST_HEAD(&property->enum_blob_list); 2773 2774 if (name) { 2775 strncpy(property->name, name, DRM_PROP_NAME_LEN); 2776 property->name[DRM_PROP_NAME_LEN-1] = '\0'; 2777 } 2778 2779 list_add_tail(&property->head, &dev->mode_config.property_list); 2780 return property; 2781 fail: 2782 kfree(property->values); 2783 kfree(property); 2784 return NULL; 2785 } 2786 EXPORT_SYMBOL(drm_property_create); 2787 2788 struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags, 2789 const char *name, 2790 const struct drm_prop_enum_list *props, 2791 int num_values) 2792 { 2793 struct drm_property *property; 2794 int i, ret; 2795 2796 flags |= DRM_MODE_PROP_ENUM; 2797 2798 property = drm_property_create(dev, flags, name, num_values); 2799 if (!property) 2800 return NULL; 2801 2802 for (i = 0; i < num_values; i++) { 2803 ret = drm_property_add_enum(property, i, 2804 props[i].type, 2805 props[i].name); 2806 if (ret) { 2807 drm_property_destroy(dev, property); 2808 return NULL; 2809 } 2810 } 2811 2812 return property; 2813 } 2814 EXPORT_SYMBOL(drm_property_create_enum); 2815 2816 struct drm_property *drm_property_create_bitmask(struct drm_device *dev, 2817 int flags, const char *name, 2818 const struct drm_prop_enum_list *props, 2819 int num_values) 2820 { 2821 struct drm_property *property; 2822 int i, ret; 2823 2824 flags |= DRM_MODE_PROP_BITMASK; 2825 2826 property = drm_property_create(dev, flags, name, num_values); 2827 if (!property) 2828 return NULL; 2829 2830 for (i = 0; i < num_values; i++) { 2831 ret = drm_property_add_enum(property, i, 2832 props[i].type, 2833 props[i].name); 2834 if (ret) { 2835 drm_property_destroy(dev, property); 2836 return NULL; 2837 } 2838 } 2839 2840 return property; 2841 } 2842 EXPORT_SYMBOL(drm_property_create_bitmask); 2843 2844 struct drm_property *drm_property_create_range(struct drm_device *dev, int flags, 2845 const char *name, 2846 uint64_t min, uint64_t max) 2847 { 2848 struct drm_property *property; 2849 2850 flags |= DRM_MODE_PROP_RANGE; 2851 2852 property = drm_property_create(dev, flags, name, 2); 2853 if (!property) 2854 return NULL; 2855 2856 property->values[0] = min; 2857 property->values[1] = max; 2858 2859 return property; 2860 } 2861 EXPORT_SYMBOL(drm_property_create_range); 2862 2863 int drm_property_add_enum(struct drm_property *property, int index, 2864 uint64_t value, const char *name) 2865 { 2866 struct drm_property_enum *prop_enum; 2867 2868 if (!(property->flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK))) 2869 return -EINVAL; 2870 2871 /* 2872 * Bitmask enum properties have the additional constraint of values 2873 * from 0 to 63 2874 */ 2875 if ((property->flags & DRM_MODE_PROP_BITMASK) && (value > 63)) 2876 return -EINVAL; 2877 2878 if (!list_empty(&property->enum_blob_list)) { 2879 list_for_each_entry(prop_enum, &property->enum_blob_list, head) { 2880 if (prop_enum->value == value) { 2881 strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN); 2882 prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0'; 2883 return 0; 2884 } 2885 } 2886 } 2887 2888 prop_enum = kzalloc(sizeof(struct drm_property_enum), GFP_KERNEL); 2889 if (!prop_enum) 2890 return -ENOMEM; 2891 2892 strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN); 2893 prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0'; 2894 prop_enum->value = value; 2895 2896 property->values[index] = value; 2897 list_add_tail(&prop_enum->head, &property->enum_blob_list); 2898 return 0; 2899 } 2900 EXPORT_SYMBOL(drm_property_add_enum); 2901 2902 void drm_property_destroy(struct drm_device *dev, struct drm_property *property) 2903 { 2904 struct drm_property_enum *prop_enum, *pt; 2905 2906 list_for_each_entry_safe(prop_enum, pt, &property->enum_blob_list, head) { 2907 list_del(&prop_enum->head); 2908 kfree(prop_enum); 2909 } 2910 2911 if (property->num_values) 2912 kfree(property->values); 2913 drm_mode_object_put(dev, &property->base); 2914 list_del(&property->head); 2915 kfree(property); 2916 } 2917 EXPORT_SYMBOL(drm_property_destroy); 2918 2919 void drm_connector_attach_property(struct drm_connector *connector, 2920 struct drm_property *property, uint64_t init_val) 2921 { 2922 drm_object_attach_property(&connector->base, property, init_val); 2923 } 2924 EXPORT_SYMBOL(drm_connector_attach_property); 2925 2926 int drm_connector_property_set_value(struct drm_connector *connector, 2927 struct drm_property *property, uint64_t value) 2928 { 2929 return drm_object_property_set_value(&connector->base, property, value); 2930 } 2931 EXPORT_SYMBOL(drm_connector_property_set_value); 2932 2933 int drm_connector_property_get_value(struct drm_connector *connector, 2934 struct drm_property *property, uint64_t *val) 2935 { 2936 return drm_object_property_get_value(&connector->base, property, val); 2937 } 2938 EXPORT_SYMBOL(drm_connector_property_get_value); 2939 2940 void drm_object_attach_property(struct drm_mode_object *obj, 2941 struct drm_property *property, 2942 uint64_t init_val) 2943 { 2944 int count = obj->properties->count; 2945 2946 if (count == DRM_OBJECT_MAX_PROPERTY) { 2947 WARN(1, "Failed to attach object property (type: 0x%x). Please " 2948 "increase DRM_OBJECT_MAX_PROPERTY by 1 for each time " 2949 "you see this message on the same object type.\n", 2950 obj->type); 2951 return; 2952 } 2953 2954 obj->properties->ids[count] = property->base.id; 2955 obj->properties->values[count] = init_val; 2956 obj->properties->count++; 2957 } 2958 EXPORT_SYMBOL(drm_object_attach_property); 2959 2960 int drm_object_property_set_value(struct drm_mode_object *obj, 2961 struct drm_property *property, uint64_t val) 2962 { 2963 int i; 2964 2965 for (i = 0; i < obj->properties->count; i++) { 2966 if (obj->properties->ids[i] == property->base.id) { 2967 obj->properties->values[i] = val; 2968 return 0; 2969 } 2970 } 2971 2972 return -EINVAL; 2973 } 2974 EXPORT_SYMBOL(drm_object_property_set_value); 2975 2976 int drm_object_property_get_value(struct drm_mode_object *obj, 2977 struct drm_property *property, uint64_t *val) 2978 { 2979 int i; 2980 2981 for (i = 0; i < obj->properties->count; i++) { 2982 if (obj->properties->ids[i] == property->base.id) { 2983 *val = obj->properties->values[i]; 2984 return 0; 2985 } 2986 } 2987 2988 return -EINVAL; 2989 } 2990 EXPORT_SYMBOL(drm_object_property_get_value); 2991 2992 int drm_mode_getproperty_ioctl(struct drm_device *dev, 2993 void *data, struct drm_file *file_priv) 2994 { 2995 struct drm_mode_object *obj; 2996 struct drm_mode_get_property *out_resp = data; 2997 struct drm_property *property; 2998 int enum_count = 0; 2999 int blob_count = 0; 3000 int value_count = 0; 3001 int ret = 0, i; 3002 int copied; 3003 struct drm_property_enum *prop_enum; 3004 struct drm_mode_property_enum __user *enum_ptr; 3005 struct drm_property_blob *prop_blob; 3006 uint32_t __user *blob_id_ptr; 3007 uint64_t __user *values_ptr; 3008 uint32_t __user *blob_length_ptr; 3009 3010 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 3011 return -EINVAL; 3012 3013 mutex_lock(&dev->mode_config.mutex); 3014 obj = drm_mode_object_find(dev, out_resp->prop_id, DRM_MODE_OBJECT_PROPERTY); 3015 if (!obj) { 3016 ret = -EINVAL; 3017 goto done; 3018 } 3019 property = obj_to_property(obj); 3020 3021 if (property->flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)) { 3022 list_for_each_entry(prop_enum, &property->enum_blob_list, head) 3023 enum_count++; 3024 } else if (property->flags & DRM_MODE_PROP_BLOB) { 3025 list_for_each_entry(prop_blob, &property->enum_blob_list, head) 3026 blob_count++; 3027 } 3028 3029 value_count = property->num_values; 3030 3031 strncpy(out_resp->name, property->name, DRM_PROP_NAME_LEN); 3032 out_resp->name[DRM_PROP_NAME_LEN-1] = 0; 3033 out_resp->flags = property->flags; 3034 3035 if ((out_resp->count_values >= value_count) && value_count) { 3036 values_ptr = (uint64_t __user *)(unsigned long)out_resp->values_ptr; 3037 for (i = 0; i < value_count; i++) { 3038 if (copy_to_user(values_ptr + i, &property->values[i], sizeof(uint64_t))) { 3039 ret = -EFAULT; 3040 goto done; 3041 } 3042 } 3043 } 3044 out_resp->count_values = value_count; 3045 3046 if (property->flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)) { 3047 if ((out_resp->count_enum_blobs >= enum_count) && enum_count) { 3048 copied = 0; 3049 enum_ptr = (struct drm_mode_property_enum __user *)(unsigned long)out_resp->enum_blob_ptr; 3050 list_for_each_entry(prop_enum, &property->enum_blob_list, head) { 3051 3052 if (copy_to_user(&enum_ptr[copied].value, &prop_enum->value, sizeof(uint64_t))) { 3053 ret = -EFAULT; 3054 goto done; 3055 } 3056 3057 if (copy_to_user(&enum_ptr[copied].name, 3058 &prop_enum->name, DRM_PROP_NAME_LEN)) { 3059 ret = -EFAULT; 3060 goto done; 3061 } 3062 copied++; 3063 } 3064 } 3065 out_resp->count_enum_blobs = enum_count; 3066 } 3067 3068 if (property->flags & DRM_MODE_PROP_BLOB) { 3069 if ((out_resp->count_enum_blobs >= blob_count) && blob_count) { 3070 copied = 0; 3071 blob_id_ptr = (uint32_t __user *)(unsigned long)out_resp->enum_blob_ptr; 3072 blob_length_ptr = (uint32_t __user *)(unsigned long)out_resp->values_ptr; 3073 3074 list_for_each_entry(prop_blob, &property->enum_blob_list, head) { 3075 if (put_user(prop_blob->base.id, blob_id_ptr + copied)) { 3076 ret = -EFAULT; 3077 goto done; 3078 } 3079 3080 if (put_user(prop_blob->length, blob_length_ptr + copied)) { 3081 ret = -EFAULT; 3082 goto done; 3083 } 3084 3085 copied++; 3086 } 3087 } 3088 out_resp->count_enum_blobs = blob_count; 3089 } 3090 done: 3091 mutex_unlock(&dev->mode_config.mutex); 3092 return ret; 3093 } 3094 3095 static struct drm_property_blob *drm_property_create_blob(struct drm_device *dev, int length, 3096 void *data) 3097 { 3098 struct drm_property_blob *blob; 3099 int ret; 3100 3101 if (!length || !data) 3102 return NULL; 3103 3104 blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL); 3105 if (!blob) 3106 return NULL; 3107 3108 ret = drm_mode_object_get(dev, &blob->base, DRM_MODE_OBJECT_BLOB); 3109 if (ret) { 3110 kfree(blob); 3111 return NULL; 3112 } 3113 3114 blob->length = length; 3115 3116 memcpy(blob->data, data, length); 3117 3118 list_add_tail(&blob->head, &dev->mode_config.property_blob_list); 3119 return blob; 3120 } 3121 3122 static void drm_property_destroy_blob(struct drm_device *dev, 3123 struct drm_property_blob *blob) 3124 { 3125 drm_mode_object_put(dev, &blob->base); 3126 list_del(&blob->head); 3127 kfree(blob); 3128 } 3129 3130 int drm_mode_getblob_ioctl(struct drm_device *dev, 3131 void *data, struct drm_file *file_priv) 3132 { 3133 struct drm_mode_object *obj; 3134 struct drm_mode_get_blob *out_resp = data; 3135 struct drm_property_blob *blob; 3136 int ret = 0; 3137 void __user *blob_ptr; 3138 3139 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 3140 return -EINVAL; 3141 3142 mutex_lock(&dev->mode_config.mutex); 3143 obj = drm_mode_object_find(dev, out_resp->blob_id, DRM_MODE_OBJECT_BLOB); 3144 if (!obj) { 3145 ret = -EINVAL; 3146 goto done; 3147 } 3148 blob = obj_to_blob(obj); 3149 3150 if (out_resp->length == blob->length) { 3151 blob_ptr = (void __user *)(unsigned long)out_resp->data; 3152 if (copy_to_user(blob_ptr, blob->data, blob->length)){ 3153 ret = -EFAULT; 3154 goto done; 3155 } 3156 } 3157 out_resp->length = blob->length; 3158 3159 done: 3160 mutex_unlock(&dev->mode_config.mutex); 3161 return ret; 3162 } 3163 3164 int drm_mode_connector_update_edid_property(struct drm_connector *connector, 3165 struct edid *edid) 3166 { 3167 struct drm_device *dev = connector->dev; 3168 int ret, size; 3169 3170 if (connector->edid_blob_ptr) 3171 drm_property_destroy_blob(dev, connector->edid_blob_ptr); 3172 3173 /* Delete edid, when there is none. */ 3174 if (!edid) { 3175 connector->edid_blob_ptr = NULL; 3176 ret = drm_connector_property_set_value(connector, dev->mode_config.edid_property, 0); 3177 return ret; 3178 } 3179 3180 size = EDID_LENGTH * (1 + edid->extensions); 3181 connector->edid_blob_ptr = drm_property_create_blob(connector->dev, 3182 size, edid); 3183 3184 ret = drm_connector_property_set_value(connector, 3185 dev->mode_config.edid_property, 3186 connector->edid_blob_ptr->base.id); 3187 3188 return ret; 3189 } 3190 EXPORT_SYMBOL(drm_mode_connector_update_edid_property); 3191 3192 static bool drm_property_change_is_valid(struct drm_property *property, 3193 uint64_t value) 3194 { 3195 if (property->flags & DRM_MODE_PROP_IMMUTABLE) 3196 return false; 3197 if (property->flags & DRM_MODE_PROP_RANGE) { 3198 if (value < property->values[0] || value > property->values[1]) 3199 return false; 3200 return true; 3201 } else if (property->flags & DRM_MODE_PROP_BITMASK) { 3202 int i; 3203 uint64_t valid_mask = 0; 3204 for (i = 0; i < property->num_values; i++) 3205 valid_mask |= (1ULL << property->values[i]); 3206 return !(value & ~valid_mask); 3207 } else { 3208 int i; 3209 for (i = 0; i < property->num_values; i++) 3210 if (property->values[i] == value) 3211 return true; 3212 return false; 3213 } 3214 } 3215 3216 int drm_mode_connector_property_set_ioctl(struct drm_device *dev, 3217 void *data, struct drm_file *file_priv) 3218 { 3219 struct drm_mode_connector_set_property *conn_set_prop = data; 3220 struct drm_mode_obj_set_property obj_set_prop = { 3221 .value = conn_set_prop->value, 3222 .prop_id = conn_set_prop->prop_id, 3223 .obj_id = conn_set_prop->connector_id, 3224 .obj_type = DRM_MODE_OBJECT_CONNECTOR 3225 }; 3226 3227 /* It does all the locking and checking we need */ 3228 return drm_mode_obj_set_property_ioctl(dev, &obj_set_prop, file_priv); 3229 } 3230 3231 static int drm_mode_connector_set_obj_prop(struct drm_mode_object *obj, 3232 struct drm_property *property, 3233 uint64_t value) 3234 { 3235 int ret = -EINVAL; 3236 struct drm_connector *connector = obj_to_connector(obj); 3237 3238 /* Do DPMS ourselves */ 3239 if (property == connector->dev->mode_config.dpms_property) { 3240 if (connector->funcs->dpms) 3241 (*connector->funcs->dpms)(connector, (int)value); 3242 ret = 0; 3243 } else if (connector->funcs->set_property) 3244 ret = connector->funcs->set_property(connector, property, value); 3245 3246 /* store the property value if successful */ 3247 if (!ret) 3248 drm_connector_property_set_value(connector, property, value); 3249 return ret; 3250 } 3251 3252 static int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj, 3253 struct drm_property *property, 3254 uint64_t value) 3255 { 3256 int ret = -EINVAL; 3257 struct drm_crtc *crtc = obj_to_crtc(obj); 3258 3259 if (crtc->funcs->set_property) 3260 ret = crtc->funcs->set_property(crtc, property, value); 3261 if (!ret) 3262 drm_object_property_set_value(obj, property, value); 3263 3264 return ret; 3265 } 3266 3267 static int drm_mode_plane_set_obj_prop(struct drm_mode_object *obj, 3268 struct drm_property *property, 3269 uint64_t value) 3270 { 3271 int ret = -EINVAL; 3272 struct drm_plane *plane = obj_to_plane(obj); 3273 3274 if (plane->funcs->set_property) 3275 ret = plane->funcs->set_property(plane, property, value); 3276 if (!ret) 3277 drm_object_property_set_value(obj, property, value); 3278 3279 return ret; 3280 } 3281 3282 int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data, 3283 struct drm_file *file_priv) 3284 { 3285 struct drm_mode_obj_get_properties *arg = data; 3286 struct drm_mode_object *obj; 3287 int ret = 0; 3288 int i; 3289 int copied = 0; 3290 int props_count = 0; 3291 uint32_t __user *props_ptr; 3292 uint64_t __user *prop_values_ptr; 3293 3294 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 3295 return -EINVAL; 3296 3297 mutex_lock(&dev->mode_config.mutex); 3298 3299 obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type); 3300 if (!obj) { 3301 ret = -EINVAL; 3302 goto out; 3303 } 3304 if (!obj->properties) { 3305 ret = -EINVAL; 3306 goto out; 3307 } 3308 3309 props_count = obj->properties->count; 3310 3311 /* This ioctl is called twice, once to determine how much space is 3312 * needed, and the 2nd time to fill it. */ 3313 if ((arg->count_props >= props_count) && props_count) { 3314 copied = 0; 3315 props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr); 3316 prop_values_ptr = (uint64_t __user *)(unsigned long) 3317 (arg->prop_values_ptr); 3318 for (i = 0; i < props_count; i++) { 3319 if (put_user(obj->properties->ids[i], 3320 props_ptr + copied)) { 3321 ret = -EFAULT; 3322 goto out; 3323 } 3324 if (put_user(obj->properties->values[i], 3325 prop_values_ptr + copied)) { 3326 ret = -EFAULT; 3327 goto out; 3328 } 3329 copied++; 3330 } 3331 } 3332 arg->count_props = props_count; 3333 out: 3334 mutex_unlock(&dev->mode_config.mutex); 3335 return ret; 3336 } 3337 3338 int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data, 3339 struct drm_file *file_priv) 3340 { 3341 struct drm_mode_obj_set_property *arg = data; 3342 struct drm_mode_object *arg_obj; 3343 struct drm_mode_object *prop_obj; 3344 struct drm_property *property; 3345 int ret = -EINVAL; 3346 int i; 3347 3348 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 3349 return -EINVAL; 3350 3351 mutex_lock(&dev->mode_config.mutex); 3352 3353 arg_obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type); 3354 if (!arg_obj) 3355 goto out; 3356 if (!arg_obj->properties) 3357 goto out; 3358 3359 for (i = 0; i < arg_obj->properties->count; i++) 3360 if (arg_obj->properties->ids[i] == arg->prop_id) 3361 break; 3362 3363 if (i == arg_obj->properties->count) 3364 goto out; 3365 3366 prop_obj = drm_mode_object_find(dev, arg->prop_id, 3367 DRM_MODE_OBJECT_PROPERTY); 3368 if (!prop_obj) 3369 goto out; 3370 property = obj_to_property(prop_obj); 3371 3372 if (!drm_property_change_is_valid(property, arg->value)) 3373 goto out; 3374 3375 switch (arg_obj->type) { 3376 case DRM_MODE_OBJECT_CONNECTOR: 3377 ret = drm_mode_connector_set_obj_prop(arg_obj, property, 3378 arg->value); 3379 break; 3380 case DRM_MODE_OBJECT_CRTC: 3381 ret = drm_mode_crtc_set_obj_prop(arg_obj, property, arg->value); 3382 break; 3383 case DRM_MODE_OBJECT_PLANE: 3384 ret = drm_mode_plane_set_obj_prop(arg_obj, property, arg->value); 3385 break; 3386 } 3387 3388 out: 3389 mutex_unlock(&dev->mode_config.mutex); 3390 return ret; 3391 } 3392 3393 int drm_mode_connector_attach_encoder(struct drm_connector *connector, 3394 struct drm_encoder *encoder) 3395 { 3396 int i; 3397 3398 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 3399 if (connector->encoder_ids[i] == 0) { 3400 connector->encoder_ids[i] = encoder->base.id; 3401 return 0; 3402 } 3403 } 3404 return -ENOMEM; 3405 } 3406 EXPORT_SYMBOL(drm_mode_connector_attach_encoder); 3407 3408 void drm_mode_connector_detach_encoder(struct drm_connector *connector, 3409 struct drm_encoder *encoder) 3410 { 3411 int i; 3412 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 3413 if (connector->encoder_ids[i] == encoder->base.id) { 3414 connector->encoder_ids[i] = 0; 3415 if (connector->encoder == encoder) 3416 connector->encoder = NULL; 3417 break; 3418 } 3419 } 3420 } 3421 EXPORT_SYMBOL(drm_mode_connector_detach_encoder); 3422 3423 int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc, 3424 int gamma_size) 3425 { 3426 crtc->gamma_size = gamma_size; 3427 3428 crtc->gamma_store = kzalloc(gamma_size * sizeof(uint16_t) * 3, GFP_KERNEL); 3429 if (!crtc->gamma_store) { 3430 crtc->gamma_size = 0; 3431 return -ENOMEM; 3432 } 3433 3434 return 0; 3435 } 3436 EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size); 3437 3438 int drm_mode_gamma_set_ioctl(struct drm_device *dev, 3439 void *data, struct drm_file *file_priv) 3440 { 3441 struct drm_mode_crtc_lut *crtc_lut = data; 3442 struct drm_mode_object *obj; 3443 struct drm_crtc *crtc; 3444 void *r_base, *g_base, *b_base; 3445 int size; 3446 int ret = 0; 3447 3448 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 3449 return -EINVAL; 3450 3451 mutex_lock(&dev->mode_config.mutex); 3452 obj = drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC); 3453 if (!obj) { 3454 ret = -EINVAL; 3455 goto out; 3456 } 3457 crtc = obj_to_crtc(obj); 3458 3459 if (crtc->funcs->gamma_set == NULL) { 3460 ret = -ENOSYS; 3461 goto out; 3462 } 3463 3464 /* memcpy into gamma store */ 3465 if (crtc_lut->gamma_size != crtc->gamma_size) { 3466 ret = -EINVAL; 3467 goto out; 3468 } 3469 3470 size = crtc_lut->gamma_size * (sizeof(uint16_t)); 3471 r_base = crtc->gamma_store; 3472 if (copy_from_user(r_base, (void __user *)(unsigned long)crtc_lut->red, size)) { 3473 ret = -EFAULT; 3474 goto out; 3475 } 3476 3477 g_base = r_base + size; 3478 if (copy_from_user(g_base, (void __user *)(unsigned long)crtc_lut->green, size)) { 3479 ret = -EFAULT; 3480 goto out; 3481 } 3482 3483 b_base = g_base + size; 3484 if (copy_from_user(b_base, (void __user *)(unsigned long)crtc_lut->blue, size)) { 3485 ret = -EFAULT; 3486 goto out; 3487 } 3488 3489 crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size); 3490 3491 out: 3492 mutex_unlock(&dev->mode_config.mutex); 3493 return ret; 3494 3495 } 3496 3497 int drm_mode_gamma_get_ioctl(struct drm_device *dev, 3498 void *data, struct drm_file *file_priv) 3499 { 3500 struct drm_mode_crtc_lut *crtc_lut = data; 3501 struct drm_mode_object *obj; 3502 struct drm_crtc *crtc; 3503 void *r_base, *g_base, *b_base; 3504 int size; 3505 int ret = 0; 3506 3507 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 3508 return -EINVAL; 3509 3510 mutex_lock(&dev->mode_config.mutex); 3511 obj = drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC); 3512 if (!obj) { 3513 ret = -EINVAL; 3514 goto out; 3515 } 3516 crtc = obj_to_crtc(obj); 3517 3518 /* memcpy into gamma store */ 3519 if (crtc_lut->gamma_size != crtc->gamma_size) { 3520 ret = -EINVAL; 3521 goto out; 3522 } 3523 3524 size = crtc_lut->gamma_size * (sizeof(uint16_t)); 3525 r_base = crtc->gamma_store; 3526 if (copy_to_user((void __user *)(unsigned long)crtc_lut->red, r_base, size)) { 3527 ret = -EFAULT; 3528 goto out; 3529 } 3530 3531 g_base = r_base + size; 3532 if (copy_to_user((void __user *)(unsigned long)crtc_lut->green, g_base, size)) { 3533 ret = -EFAULT; 3534 goto out; 3535 } 3536 3537 b_base = g_base + size; 3538 if (copy_to_user((void __user *)(unsigned long)crtc_lut->blue, b_base, size)) { 3539 ret = -EFAULT; 3540 goto out; 3541 } 3542 out: 3543 mutex_unlock(&dev->mode_config.mutex); 3544 return ret; 3545 } 3546 3547 int drm_mode_page_flip_ioctl(struct drm_device *dev, 3548 void *data, struct drm_file *file_priv) 3549 { 3550 struct drm_mode_crtc_page_flip *page_flip = data; 3551 struct drm_mode_object *obj; 3552 struct drm_crtc *crtc; 3553 struct drm_framebuffer *fb; 3554 struct drm_pending_vblank_event *e = NULL; 3555 unsigned long flags; 3556 int hdisplay, vdisplay; 3557 int ret = -EINVAL; 3558 3559 if (page_flip->flags & ~DRM_MODE_PAGE_FLIP_FLAGS || 3560 page_flip->reserved != 0) 3561 return -EINVAL; 3562 3563 mutex_lock(&dev->mode_config.mutex); 3564 obj = drm_mode_object_find(dev, page_flip->crtc_id, DRM_MODE_OBJECT_CRTC); 3565 if (!obj) 3566 goto out; 3567 crtc = obj_to_crtc(obj); 3568 3569 if (crtc->fb == NULL) { 3570 /* The framebuffer is currently unbound, presumably 3571 * due to a hotplug event, that userspace has not 3572 * yet discovered. 3573 */ 3574 ret = -EBUSY; 3575 goto out; 3576 } 3577 3578 if (crtc->funcs->page_flip == NULL) 3579 goto out; 3580 3581 obj = drm_mode_object_find(dev, page_flip->fb_id, DRM_MODE_OBJECT_FB); 3582 if (!obj) 3583 goto out; 3584 fb = obj_to_fb(obj); 3585 3586 hdisplay = crtc->mode.hdisplay; 3587 vdisplay = crtc->mode.vdisplay; 3588 3589 if (crtc->invert_dimensions) 3590 swap(hdisplay, vdisplay); 3591 3592 if (hdisplay > fb->width || 3593 vdisplay > fb->height || 3594 crtc->x > fb->width - hdisplay || 3595 crtc->y > fb->height - vdisplay) { 3596 DRM_DEBUG_KMS("Invalid fb size %ux%u for CRTC viewport %ux%u+%d+%d%s.\n", 3597 fb->width, fb->height, hdisplay, vdisplay, crtc->x, crtc->y, 3598 crtc->invert_dimensions ? " (inverted)" : ""); 3599 ret = -ENOSPC; 3600 goto out; 3601 } 3602 3603 if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) { 3604 ret = -ENOMEM; 3605 spin_lock_irqsave(&dev->event_lock, flags); 3606 if (file_priv->event_space < sizeof e->event) { 3607 spin_unlock_irqrestore(&dev->event_lock, flags); 3608 goto out; 3609 } 3610 file_priv->event_space -= sizeof e->event; 3611 spin_unlock_irqrestore(&dev->event_lock, flags); 3612 3613 e = kzalloc(sizeof *e, GFP_KERNEL); 3614 if (e == NULL) { 3615 spin_lock_irqsave(&dev->event_lock, flags); 3616 file_priv->event_space += sizeof e->event; 3617 spin_unlock_irqrestore(&dev->event_lock, flags); 3618 goto out; 3619 } 3620 3621 e->event.base.type = DRM_EVENT_FLIP_COMPLETE; 3622 e->event.base.length = sizeof e->event; 3623 e->event.user_data = page_flip->user_data; 3624 e->base.event = &e->event.base; 3625 e->base.file_priv = file_priv; 3626 e->base.destroy = 3627 (void (*) (struct drm_pending_event *)) kfree; 3628 } 3629 3630 ret = crtc->funcs->page_flip(crtc, fb, e); 3631 if (ret) { 3632 if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) { 3633 spin_lock_irqsave(&dev->event_lock, flags); 3634 file_priv->event_space += sizeof e->event; 3635 spin_unlock_irqrestore(&dev->event_lock, flags); 3636 kfree(e); 3637 } 3638 } 3639 3640 out: 3641 mutex_unlock(&dev->mode_config.mutex); 3642 return ret; 3643 } 3644 3645 void drm_mode_config_reset(struct drm_device *dev) 3646 { 3647 struct drm_crtc *crtc; 3648 struct drm_encoder *encoder; 3649 struct drm_connector *connector; 3650 3651 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) 3652 if (crtc->funcs->reset) 3653 crtc->funcs->reset(crtc); 3654 3655 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) 3656 if (encoder->funcs->reset) 3657 encoder->funcs->reset(encoder); 3658 3659 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 3660 if (connector->funcs->reset) 3661 connector->funcs->reset(connector); 3662 } 3663 EXPORT_SYMBOL(drm_mode_config_reset); 3664 3665 int drm_mode_create_dumb_ioctl(struct drm_device *dev, 3666 void *data, struct drm_file *file_priv) 3667 { 3668 struct drm_mode_create_dumb *args = data; 3669 3670 if (!dev->driver->dumb_create) 3671 return -ENOSYS; 3672 return dev->driver->dumb_create(file_priv, dev, args); 3673 } 3674 3675 int drm_mode_mmap_dumb_ioctl(struct drm_device *dev, 3676 void *data, struct drm_file *file_priv) 3677 { 3678 struct drm_mode_map_dumb *args = data; 3679 3680 /* call driver ioctl to get mmap offset */ 3681 if (!dev->driver->dumb_map_offset) 3682 return -ENOSYS; 3683 3684 return dev->driver->dumb_map_offset(file_priv, dev, args->handle, &args->offset); 3685 } 3686 3687 int drm_mode_destroy_dumb_ioctl(struct drm_device *dev, 3688 void *data, struct drm_file *file_priv) 3689 { 3690 struct drm_mode_destroy_dumb *args = data; 3691 3692 if (!dev->driver->dumb_destroy) 3693 return -ENOSYS; 3694 3695 return dev->driver->dumb_destroy(file_priv, dev, args->handle); 3696 } 3697 3698 /* 3699 * Just need to support RGB formats here for compat with code that doesn't 3700 * use pixel formats directly yet. 3701 */ 3702 void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth, 3703 int *bpp) 3704 { 3705 switch (format) { 3706 case DRM_FORMAT_RGB332: 3707 case DRM_FORMAT_BGR233: 3708 *depth = 8; 3709 *bpp = 8; 3710 break; 3711 case DRM_FORMAT_XRGB1555: 3712 case DRM_FORMAT_XBGR1555: 3713 case DRM_FORMAT_RGBX5551: 3714 case DRM_FORMAT_BGRX5551: 3715 case DRM_FORMAT_ARGB1555: 3716 case DRM_FORMAT_ABGR1555: 3717 case DRM_FORMAT_RGBA5551: 3718 case DRM_FORMAT_BGRA5551: 3719 *depth = 15; 3720 *bpp = 16; 3721 break; 3722 case DRM_FORMAT_RGB565: 3723 case DRM_FORMAT_BGR565: 3724 *depth = 16; 3725 *bpp = 16; 3726 break; 3727 case DRM_FORMAT_RGB888: 3728 case DRM_FORMAT_BGR888: 3729 *depth = 24; 3730 *bpp = 24; 3731 break; 3732 case DRM_FORMAT_XRGB8888: 3733 case DRM_FORMAT_XBGR8888: 3734 case DRM_FORMAT_RGBX8888: 3735 case DRM_FORMAT_BGRX8888: 3736 *depth = 24; 3737 *bpp = 32; 3738 break; 3739 case DRM_FORMAT_XRGB2101010: 3740 case DRM_FORMAT_XBGR2101010: 3741 case DRM_FORMAT_RGBX1010102: 3742 case DRM_FORMAT_BGRX1010102: 3743 case DRM_FORMAT_ARGB2101010: 3744 case DRM_FORMAT_ABGR2101010: 3745 case DRM_FORMAT_RGBA1010102: 3746 case DRM_FORMAT_BGRA1010102: 3747 *depth = 30; 3748 *bpp = 32; 3749 break; 3750 case DRM_FORMAT_ARGB8888: 3751 case DRM_FORMAT_ABGR8888: 3752 case DRM_FORMAT_RGBA8888: 3753 case DRM_FORMAT_BGRA8888: 3754 *depth = 32; 3755 *bpp = 32; 3756 break; 3757 default: 3758 DRM_DEBUG_KMS("unsupported pixel format\n"); 3759 *depth = 0; 3760 *bpp = 0; 3761 break; 3762 } 3763 } 3764 EXPORT_SYMBOL(drm_fb_get_bpp_depth); 3765 3766 /** 3767 * drm_format_num_planes - get the number of planes for format 3768 * @format: pixel format (DRM_FORMAT_*) 3769 * 3770 * RETURNS: 3771 * The number of planes used by the specified pixel format. 3772 */ 3773 int drm_format_num_planes(uint32_t format) 3774 { 3775 switch (format) { 3776 case DRM_FORMAT_YUV410: 3777 case DRM_FORMAT_YVU410: 3778 case DRM_FORMAT_YUV411: 3779 case DRM_FORMAT_YVU411: 3780 case DRM_FORMAT_YUV420: 3781 case DRM_FORMAT_YVU420: 3782 case DRM_FORMAT_YUV422: 3783 case DRM_FORMAT_YVU422: 3784 case DRM_FORMAT_YUV444: 3785 case DRM_FORMAT_YVU444: 3786 return 3; 3787 case DRM_FORMAT_NV12: 3788 case DRM_FORMAT_NV21: 3789 case DRM_FORMAT_NV16: 3790 case DRM_FORMAT_NV61: 3791 case DRM_FORMAT_NV24: 3792 case DRM_FORMAT_NV42: 3793 return 2; 3794 default: 3795 return 1; 3796 } 3797 } 3798 EXPORT_SYMBOL(drm_format_num_planes); 3799 3800 /** 3801 * drm_format_plane_cpp - determine the bytes per pixel value 3802 * @format: pixel format (DRM_FORMAT_*) 3803 * @plane: plane index 3804 * 3805 * RETURNS: 3806 * The bytes per pixel value for the specified plane. 3807 */ 3808 int drm_format_plane_cpp(uint32_t format, int plane) 3809 { 3810 unsigned int depth; 3811 int bpp; 3812 3813 if (plane >= drm_format_num_planes(format)) 3814 return 0; 3815 3816 switch (format) { 3817 case DRM_FORMAT_YUYV: 3818 case DRM_FORMAT_YVYU: 3819 case DRM_FORMAT_UYVY: 3820 case DRM_FORMAT_VYUY: 3821 return 2; 3822 case DRM_FORMAT_NV12: 3823 case DRM_FORMAT_NV21: 3824 case DRM_FORMAT_NV16: 3825 case DRM_FORMAT_NV61: 3826 case DRM_FORMAT_NV24: 3827 case DRM_FORMAT_NV42: 3828 return plane ? 2 : 1; 3829 case DRM_FORMAT_YUV410: 3830 case DRM_FORMAT_YVU410: 3831 case DRM_FORMAT_YUV411: 3832 case DRM_FORMAT_YVU411: 3833 case DRM_FORMAT_YUV420: 3834 case DRM_FORMAT_YVU420: 3835 case DRM_FORMAT_YUV422: 3836 case DRM_FORMAT_YVU422: 3837 case DRM_FORMAT_YUV444: 3838 case DRM_FORMAT_YVU444: 3839 return 1; 3840 default: 3841 drm_fb_get_bpp_depth(format, &depth, &bpp); 3842 return bpp >> 3; 3843 } 3844 } 3845 EXPORT_SYMBOL(drm_format_plane_cpp); 3846 3847 /** 3848 * drm_format_horz_chroma_subsampling - get the horizontal chroma subsampling factor 3849 * @format: pixel format (DRM_FORMAT_*) 3850 * 3851 * RETURNS: 3852 * The horizontal chroma subsampling factor for the 3853 * specified pixel format. 3854 */ 3855 int drm_format_horz_chroma_subsampling(uint32_t format) 3856 { 3857 switch (format) { 3858 case DRM_FORMAT_YUV411: 3859 case DRM_FORMAT_YVU411: 3860 case DRM_FORMAT_YUV410: 3861 case DRM_FORMAT_YVU410: 3862 return 4; 3863 case DRM_FORMAT_YUYV: 3864 case DRM_FORMAT_YVYU: 3865 case DRM_FORMAT_UYVY: 3866 case DRM_FORMAT_VYUY: 3867 case DRM_FORMAT_NV12: 3868 case DRM_FORMAT_NV21: 3869 case DRM_FORMAT_NV16: 3870 case DRM_FORMAT_NV61: 3871 case DRM_FORMAT_YUV422: 3872 case DRM_FORMAT_YVU422: 3873 case DRM_FORMAT_YUV420: 3874 case DRM_FORMAT_YVU420: 3875 return 2; 3876 default: 3877 return 1; 3878 } 3879 } 3880 EXPORT_SYMBOL(drm_format_horz_chroma_subsampling); 3881 3882 /** 3883 * drm_format_vert_chroma_subsampling - get the vertical chroma subsampling factor 3884 * @format: pixel format (DRM_FORMAT_*) 3885 * 3886 * RETURNS: 3887 * The vertical chroma subsampling factor for the 3888 * specified pixel format. 3889 */ 3890 int drm_format_vert_chroma_subsampling(uint32_t format) 3891 { 3892 switch (format) { 3893 case DRM_FORMAT_YUV410: 3894 case DRM_FORMAT_YVU410: 3895 return 4; 3896 case DRM_FORMAT_YUV420: 3897 case DRM_FORMAT_YVU420: 3898 case DRM_FORMAT_NV12: 3899 case DRM_FORMAT_NV21: 3900 return 2; 3901 default: 3902 return 1; 3903 } 3904 } 3905 EXPORT_SYMBOL(drm_format_vert_chroma_subsampling); 3906