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