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