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/ctype.h> 33 #include <linux/list.h> 34 #include <linux/slab.h> 35 #include <linux/export.h> 36 #include <drm/drmP.h> 37 #include <drm/drm_crtc.h> 38 #include <drm/drm_edid.h> 39 #include <drm/drm_fourcc.h> 40 #include <drm/drm_modeset_lock.h> 41 #include <drm/drm_atomic.h> 42 43 #include "drm_crtc_internal.h" 44 #include "drm_internal.h" 45 46 static struct drm_framebuffer * 47 internal_framebuffer_create(struct drm_device *dev, 48 struct drm_mode_fb_cmd2 *r, 49 struct drm_file *file_priv); 50 51 /* Avoid boilerplate. I'm tired of typing. */ 52 #define DRM_ENUM_NAME_FN(fnname, list) \ 53 const char *fnname(int val) \ 54 { \ 55 int i; \ 56 for (i = 0; i < ARRAY_SIZE(list); i++) { \ 57 if (list[i].type == val) \ 58 return list[i].name; \ 59 } \ 60 return "(unknown)"; \ 61 } 62 63 /* 64 * Global properties 65 */ 66 static const struct drm_prop_enum_list drm_dpms_enum_list[] = { 67 { DRM_MODE_DPMS_ON, "On" }, 68 { DRM_MODE_DPMS_STANDBY, "Standby" }, 69 { DRM_MODE_DPMS_SUSPEND, "Suspend" }, 70 { DRM_MODE_DPMS_OFF, "Off" } 71 }; 72 73 DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list) 74 75 static const struct drm_prop_enum_list drm_plane_type_enum_list[] = { 76 { DRM_PLANE_TYPE_OVERLAY, "Overlay" }, 77 { DRM_PLANE_TYPE_PRIMARY, "Primary" }, 78 { DRM_PLANE_TYPE_CURSOR, "Cursor" }, 79 }; 80 81 /* 82 * Optional properties 83 */ 84 static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] = { 85 { DRM_MODE_SCALE_NONE, "None" }, 86 { DRM_MODE_SCALE_FULLSCREEN, "Full" }, 87 { DRM_MODE_SCALE_CENTER, "Center" }, 88 { DRM_MODE_SCALE_ASPECT, "Full aspect" }, 89 }; 90 91 static const struct drm_prop_enum_list drm_aspect_ratio_enum_list[] = { 92 { DRM_MODE_PICTURE_ASPECT_NONE, "Automatic" }, 93 { DRM_MODE_PICTURE_ASPECT_4_3, "4:3" }, 94 { DRM_MODE_PICTURE_ASPECT_16_9, "16:9" }, 95 }; 96 97 /* 98 * Non-global properties, but "required" for certain connectors. 99 */ 100 static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = { 101 { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ 102 { DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ 103 { DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ 104 }; 105 106 DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list) 107 108 static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = { 109 { DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */ 110 { DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ 111 { DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ 112 }; 113 114 DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name, 115 drm_dvi_i_subconnector_enum_list) 116 117 static const struct drm_prop_enum_list drm_tv_select_enum_list[] = { 118 { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ 119 { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ 120 { DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ 121 { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */ 122 { DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */ 123 }; 124 125 DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list) 126 127 static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = { 128 { DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */ 129 { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ 130 { DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ 131 { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */ 132 { DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */ 133 }; 134 135 DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name, 136 drm_tv_subconnector_enum_list) 137 138 static const struct drm_prop_enum_list drm_dirty_info_enum_list[] = { 139 { DRM_MODE_DIRTY_OFF, "Off" }, 140 { DRM_MODE_DIRTY_ON, "On" }, 141 { DRM_MODE_DIRTY_ANNOTATE, "Annotate" }, 142 }; 143 144 struct drm_conn_prop_enum_list { 145 int type; 146 const char *name; 147 struct ida ida; 148 }; 149 150 /* 151 * Connector and encoder types. 152 */ 153 static struct drm_conn_prop_enum_list drm_connector_enum_list[] = { 154 { DRM_MODE_CONNECTOR_Unknown, "Unknown" }, 155 { DRM_MODE_CONNECTOR_VGA, "VGA" }, 156 { DRM_MODE_CONNECTOR_DVII, "DVI-I" }, 157 { DRM_MODE_CONNECTOR_DVID, "DVI-D" }, 158 { DRM_MODE_CONNECTOR_DVIA, "DVI-A" }, 159 { DRM_MODE_CONNECTOR_Composite, "Composite" }, 160 { DRM_MODE_CONNECTOR_SVIDEO, "SVIDEO" }, 161 { DRM_MODE_CONNECTOR_LVDS, "LVDS" }, 162 { DRM_MODE_CONNECTOR_Component, "Component" }, 163 { DRM_MODE_CONNECTOR_9PinDIN, "DIN" }, 164 { DRM_MODE_CONNECTOR_DisplayPort, "DP" }, 165 { DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" }, 166 { DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" }, 167 { DRM_MODE_CONNECTOR_TV, "TV" }, 168 { DRM_MODE_CONNECTOR_eDP, "eDP" }, 169 { DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" }, 170 { DRM_MODE_CONNECTOR_DSI, "DSI" }, 171 }; 172 173 static const struct drm_prop_enum_list drm_encoder_enum_list[] = { 174 { DRM_MODE_ENCODER_NONE, "None" }, 175 { DRM_MODE_ENCODER_DAC, "DAC" }, 176 { DRM_MODE_ENCODER_TMDS, "TMDS" }, 177 { DRM_MODE_ENCODER_LVDS, "LVDS" }, 178 { DRM_MODE_ENCODER_TVDAC, "TV" }, 179 { DRM_MODE_ENCODER_VIRTUAL, "Virtual" }, 180 { DRM_MODE_ENCODER_DSI, "DSI" }, 181 { DRM_MODE_ENCODER_DPMST, "DP MST" }, 182 }; 183 184 static const struct drm_prop_enum_list drm_subpixel_enum_list[] = { 185 { SubPixelUnknown, "Unknown" }, 186 { SubPixelHorizontalRGB, "Horizontal RGB" }, 187 { SubPixelHorizontalBGR, "Horizontal BGR" }, 188 { SubPixelVerticalRGB, "Vertical RGB" }, 189 { SubPixelVerticalBGR, "Vertical BGR" }, 190 { SubPixelNone, "None" }, 191 }; 192 193 void drm_connector_ida_init(void) 194 { 195 int i; 196 197 for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++) 198 ida_init(&drm_connector_enum_list[i].ida); 199 } 200 201 void drm_connector_ida_destroy(void) 202 { 203 int i; 204 205 for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++) 206 ida_destroy(&drm_connector_enum_list[i].ida); 207 } 208 209 /** 210 * drm_get_connector_status_name - return a string for connector status 211 * @status: connector status to compute name of 212 * 213 * In contrast to the other drm_get_*_name functions this one here returns a 214 * const pointer and hence is threadsafe. 215 */ 216 const char *drm_get_connector_status_name(enum drm_connector_status status) 217 { 218 if (status == connector_status_connected) 219 return "connected"; 220 else if (status == connector_status_disconnected) 221 return "disconnected"; 222 else 223 return "unknown"; 224 } 225 EXPORT_SYMBOL(drm_get_connector_status_name); 226 227 /** 228 * drm_get_subpixel_order_name - return a string for a given subpixel enum 229 * @order: enum of subpixel_order 230 * 231 * Note you could abuse this and return something out of bounds, but that 232 * would be a caller error. No unscrubbed user data should make it here. 233 */ 234 const char *drm_get_subpixel_order_name(enum subpixel_order order) 235 { 236 return drm_subpixel_enum_list[order].name; 237 } 238 EXPORT_SYMBOL(drm_get_subpixel_order_name); 239 240 static char printable_char(int c) 241 { 242 return isascii(c) && isprint(c) ? c : '?'; 243 } 244 245 /** 246 * drm_get_format_name - return a string for drm fourcc format 247 * @format: format to compute name of 248 * 249 * Note that the buffer used by this function is globally shared and owned by 250 * the function itself. 251 * 252 * FIXME: This isn't really multithreading safe. 253 */ 254 const char *drm_get_format_name(uint32_t format) 255 { 256 static char buf[32]; 257 258 snprintf(buf, sizeof(buf), 259 "%c%c%c%c %s-endian (0x%08x)", 260 printable_char(format & 0xff), 261 printable_char((format >> 8) & 0xff), 262 printable_char((format >> 16) & 0xff), 263 printable_char((format >> 24) & 0x7f), 264 format & DRM_FORMAT_BIG_ENDIAN ? "big" : "little", 265 format); 266 267 return buf; 268 } 269 EXPORT_SYMBOL(drm_get_format_name); 270 271 /* 272 * Internal function to assign a slot in the object idr and optionally 273 * register the object into the idr. 274 */ 275 static int drm_mode_object_get_reg(struct drm_device *dev, 276 struct drm_mode_object *obj, 277 uint32_t obj_type, 278 bool register_obj) 279 { 280 int ret; 281 282 mutex_lock(&dev->mode_config.idr_mutex); 283 ret = idr_alloc(&dev->mode_config.crtc_idr, register_obj ? obj : NULL, 1, 0, GFP_KERNEL); 284 if (ret >= 0) { 285 /* 286 * Set up the object linking under the protection of the idr 287 * lock so that other users can't see inconsistent state. 288 */ 289 obj->id = ret; 290 obj->type = obj_type; 291 } 292 mutex_unlock(&dev->mode_config.idr_mutex); 293 294 return ret < 0 ? ret : 0; 295 } 296 297 /** 298 * drm_mode_object_get - allocate a new modeset identifier 299 * @dev: DRM device 300 * @obj: object pointer, used to generate unique ID 301 * @obj_type: object type 302 * 303 * Create a unique identifier based on @ptr in @dev's identifier space. Used 304 * for tracking modes, CRTCs and connectors. Note that despite the _get postfix 305 * modeset identifiers are _not_ reference counted. Hence don't use this for 306 * reference counted modeset objects like framebuffers. 307 * 308 * Returns: 309 * New unique (relative to other objects in @dev) integer identifier for the 310 * object. 311 */ 312 int drm_mode_object_get(struct drm_device *dev, 313 struct drm_mode_object *obj, uint32_t obj_type) 314 { 315 return drm_mode_object_get_reg(dev, obj, obj_type, true); 316 } 317 318 static void drm_mode_object_register(struct drm_device *dev, 319 struct drm_mode_object *obj) 320 { 321 mutex_lock(&dev->mode_config.idr_mutex); 322 idr_replace(&dev->mode_config.crtc_idr, obj, obj->id); 323 mutex_unlock(&dev->mode_config.idr_mutex); 324 } 325 326 /** 327 * drm_mode_object_put - free a modeset identifer 328 * @dev: DRM device 329 * @object: object to free 330 * 331 * Free @id from @dev's unique identifier pool. Note that despite the _get 332 * postfix modeset identifiers are _not_ reference counted. Hence don't use this 333 * for reference counted modeset objects like framebuffers. 334 */ 335 void drm_mode_object_put(struct drm_device *dev, 336 struct drm_mode_object *object) 337 { 338 mutex_lock(&dev->mode_config.idr_mutex); 339 idr_remove(&dev->mode_config.crtc_idr, object->id); 340 mutex_unlock(&dev->mode_config.idr_mutex); 341 } 342 343 static struct drm_mode_object *_object_find(struct drm_device *dev, 344 uint32_t id, uint32_t type) 345 { 346 struct drm_mode_object *obj = NULL; 347 348 mutex_lock(&dev->mode_config.idr_mutex); 349 obj = idr_find(&dev->mode_config.crtc_idr, id); 350 if (obj && type != DRM_MODE_OBJECT_ANY && obj->type != type) 351 obj = NULL; 352 if (obj && obj->id != id) 353 obj = NULL; 354 /* don't leak out unref'd fb's */ 355 if (obj && (obj->type == DRM_MODE_OBJECT_FB)) 356 obj = NULL; 357 mutex_unlock(&dev->mode_config.idr_mutex); 358 359 return obj; 360 } 361 362 /** 363 * drm_mode_object_find - look up a drm object with static lifetime 364 * @dev: drm device 365 * @id: id of the mode object 366 * @type: type of the mode object 367 * 368 * Note that framebuffers cannot be looked up with this functions - since those 369 * are reference counted, they need special treatment. Even with 370 * DRM_MODE_OBJECT_ANY (although that will simply return NULL 371 * rather than WARN_ON()). 372 */ 373 struct drm_mode_object *drm_mode_object_find(struct drm_device *dev, 374 uint32_t id, uint32_t type) 375 { 376 struct drm_mode_object *obj = NULL; 377 378 /* Framebuffers are reference counted and need their own lookup 379 * function.*/ 380 WARN_ON(type == DRM_MODE_OBJECT_FB); 381 obj = _object_find(dev, id, type); 382 return obj; 383 } 384 EXPORT_SYMBOL(drm_mode_object_find); 385 386 /** 387 * drm_framebuffer_init - initialize a framebuffer 388 * @dev: DRM device 389 * @fb: framebuffer to be initialized 390 * @funcs: ... with these functions 391 * 392 * Allocates an ID for the framebuffer's parent mode object, sets its mode 393 * functions & device file and adds it to the master fd list. 394 * 395 * IMPORTANT: 396 * This functions publishes the fb and makes it available for concurrent access 397 * by other users. Which means by this point the fb _must_ be fully set up - 398 * since all the fb attributes are invariant over its lifetime, no further 399 * locking but only correct reference counting is required. 400 * 401 * Returns: 402 * Zero on success, error code on failure. 403 */ 404 int drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb, 405 const struct drm_framebuffer_funcs *funcs) 406 { 407 int ret; 408 409 mutex_lock(&dev->mode_config.fb_lock); 410 kref_init(&fb->refcount); 411 INIT_LIST_HEAD(&fb->filp_head); 412 fb->dev = dev; 413 fb->funcs = funcs; 414 415 ret = drm_mode_object_get(dev, &fb->base, DRM_MODE_OBJECT_FB); 416 if (ret) 417 goto out; 418 419 dev->mode_config.num_fb++; 420 list_add(&fb->head, &dev->mode_config.fb_list); 421 out: 422 mutex_unlock(&dev->mode_config.fb_lock); 423 424 return 0; 425 } 426 EXPORT_SYMBOL(drm_framebuffer_init); 427 428 /* dev->mode_config.fb_lock must be held! */ 429 static void __drm_framebuffer_unregister(struct drm_device *dev, 430 struct drm_framebuffer *fb) 431 { 432 mutex_lock(&dev->mode_config.idr_mutex); 433 idr_remove(&dev->mode_config.crtc_idr, fb->base.id); 434 mutex_unlock(&dev->mode_config.idr_mutex); 435 436 fb->base.id = 0; 437 } 438 439 static void drm_framebuffer_free(struct kref *kref) 440 { 441 struct drm_framebuffer *fb = 442 container_of(kref, struct drm_framebuffer, refcount); 443 struct drm_device *dev = fb->dev; 444 445 /* 446 * The lookup idr holds a weak reference, which has not necessarily been 447 * removed at this point. Check for that. 448 */ 449 mutex_lock(&dev->mode_config.fb_lock); 450 if (fb->base.id) { 451 /* Mark fb as reaped and drop idr ref. */ 452 __drm_framebuffer_unregister(dev, fb); 453 } 454 mutex_unlock(&dev->mode_config.fb_lock); 455 456 fb->funcs->destroy(fb); 457 } 458 459 static struct drm_framebuffer *__drm_framebuffer_lookup(struct drm_device *dev, 460 uint32_t id) 461 { 462 struct drm_mode_object *obj = NULL; 463 struct drm_framebuffer *fb; 464 465 mutex_lock(&dev->mode_config.idr_mutex); 466 obj = idr_find(&dev->mode_config.crtc_idr, id); 467 if (!obj || (obj->type != DRM_MODE_OBJECT_FB) || (obj->id != id)) 468 fb = NULL; 469 else 470 fb = obj_to_fb(obj); 471 mutex_unlock(&dev->mode_config.idr_mutex); 472 473 return fb; 474 } 475 476 /** 477 * drm_framebuffer_lookup - look up a drm framebuffer and grab a reference 478 * @dev: drm device 479 * @id: id of the fb object 480 * 481 * If successful, this grabs an additional reference to the framebuffer - 482 * callers need to make sure to eventually unreference the returned framebuffer 483 * again, using @drm_framebuffer_unreference. 484 */ 485 struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev, 486 uint32_t id) 487 { 488 struct drm_framebuffer *fb; 489 490 mutex_lock(&dev->mode_config.fb_lock); 491 fb = __drm_framebuffer_lookup(dev, id); 492 if (fb) { 493 if (!kref_get_unless_zero(&fb->refcount)) 494 fb = NULL; 495 } 496 mutex_unlock(&dev->mode_config.fb_lock); 497 498 return fb; 499 } 500 EXPORT_SYMBOL(drm_framebuffer_lookup); 501 502 /** 503 * drm_framebuffer_unreference - unref a framebuffer 504 * @fb: framebuffer to unref 505 * 506 * This functions decrements the fb's refcount and frees it if it drops to zero. 507 */ 508 void drm_framebuffer_unreference(struct drm_framebuffer *fb) 509 { 510 DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount)); 511 kref_put(&fb->refcount, drm_framebuffer_free); 512 } 513 EXPORT_SYMBOL(drm_framebuffer_unreference); 514 515 /** 516 * drm_framebuffer_reference - incr the fb refcnt 517 * @fb: framebuffer 518 * 519 * This functions increments the fb's refcount. 520 */ 521 void drm_framebuffer_reference(struct drm_framebuffer *fb) 522 { 523 DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount)); 524 kref_get(&fb->refcount); 525 } 526 EXPORT_SYMBOL(drm_framebuffer_reference); 527 528 /** 529 * drm_framebuffer_unregister_private - unregister a private fb from the lookup idr 530 * @fb: fb to unregister 531 * 532 * Drivers need to call this when cleaning up driver-private framebuffers, e.g. 533 * those used for fbdev. Note that the caller must hold a reference of it's own, 534 * i.e. the object may not be destroyed through this call (since it'll lead to a 535 * locking inversion). 536 */ 537 void drm_framebuffer_unregister_private(struct drm_framebuffer *fb) 538 { 539 struct drm_device *dev = fb->dev; 540 541 mutex_lock(&dev->mode_config.fb_lock); 542 /* Mark fb as reaped and drop idr ref. */ 543 __drm_framebuffer_unregister(dev, fb); 544 mutex_unlock(&dev->mode_config.fb_lock); 545 } 546 EXPORT_SYMBOL(drm_framebuffer_unregister_private); 547 548 /** 549 * drm_framebuffer_cleanup - remove a framebuffer object 550 * @fb: framebuffer to remove 551 * 552 * Cleanup framebuffer. This function is intended to be used from the drivers 553 * ->destroy callback. It can also be used to clean up driver private 554 * framebuffers embedded into a larger structure. 555 * 556 * Note that this function does not remove the fb from active usuage - if it is 557 * still used anywhere, hilarity can ensue since userspace could call getfb on 558 * the id and get back -EINVAL. Obviously no concern at driver unload time. 559 * 560 * Also, the framebuffer will not be removed from the lookup idr - for 561 * user-created framebuffers this will happen in in the rmfb ioctl. For 562 * driver-private objects (e.g. for fbdev) drivers need to explicitly call 563 * drm_framebuffer_unregister_private. 564 */ 565 void drm_framebuffer_cleanup(struct drm_framebuffer *fb) 566 { 567 struct drm_device *dev = fb->dev; 568 569 mutex_lock(&dev->mode_config.fb_lock); 570 list_del(&fb->head); 571 dev->mode_config.num_fb--; 572 mutex_unlock(&dev->mode_config.fb_lock); 573 } 574 EXPORT_SYMBOL(drm_framebuffer_cleanup); 575 576 /** 577 * drm_framebuffer_remove - remove and unreference a framebuffer object 578 * @fb: framebuffer to remove 579 * 580 * Scans all the CRTCs and planes in @dev's mode_config. If they're 581 * using @fb, removes it, setting it to NULL. Then drops the reference to the 582 * passed-in framebuffer. Might take the modeset locks. 583 * 584 * Note that this function optimizes the cleanup away if the caller holds the 585 * last reference to the framebuffer. It is also guaranteed to not take the 586 * modeset locks in this case. 587 */ 588 void drm_framebuffer_remove(struct drm_framebuffer *fb) 589 { 590 struct drm_device *dev = fb->dev; 591 struct drm_crtc *crtc; 592 struct drm_plane *plane; 593 struct drm_mode_set set; 594 int ret; 595 596 WARN_ON(!list_empty(&fb->filp_head)); 597 598 /* 599 * drm ABI mandates that we remove any deleted framebuffers from active 600 * useage. But since most sane clients only remove framebuffers they no 601 * longer need, try to optimize this away. 602 * 603 * Since we're holding a reference ourselves, observing a refcount of 1 604 * means that we're the last holder and can skip it. Also, the refcount 605 * can never increase from 1 again, so we don't need any barriers or 606 * locks. 607 * 608 * Note that userspace could try to race with use and instate a new 609 * usage _after_ we've cleared all current ones. End result will be an 610 * in-use fb with fb-id == 0. Userspace is allowed to shoot its own foot 611 * in this manner. 612 */ 613 if (atomic_read(&fb->refcount.refcount) > 1) { 614 drm_modeset_lock_all(dev); 615 /* remove from any CRTC */ 616 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 617 if (crtc->primary->fb == fb) { 618 /* should turn off the crtc */ 619 memset(&set, 0, sizeof(struct drm_mode_set)); 620 set.crtc = crtc; 621 set.fb = NULL; 622 ret = drm_mode_set_config_internal(&set); 623 if (ret) 624 DRM_ERROR("failed to reset crtc %p when fb was deleted\n", crtc); 625 } 626 } 627 628 list_for_each_entry(plane, &dev->mode_config.plane_list, head) { 629 if (plane->fb == fb) 630 drm_plane_force_disable(plane); 631 } 632 drm_modeset_unlock_all(dev); 633 } 634 635 drm_framebuffer_unreference(fb); 636 } 637 EXPORT_SYMBOL(drm_framebuffer_remove); 638 639 DEFINE_WW_CLASS(crtc_ww_class); 640 641 /** 642 * drm_crtc_init_with_planes - Initialise a new CRTC object with 643 * specified primary and cursor planes. 644 * @dev: DRM device 645 * @crtc: CRTC object to init 646 * @primary: Primary plane for CRTC 647 * @cursor: Cursor plane for CRTC 648 * @funcs: callbacks for the new CRTC 649 * 650 * Inits a new object created as base part of a driver crtc object. 651 * 652 * Returns: 653 * Zero on success, error code on failure. 654 */ 655 int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc, 656 struct drm_plane *primary, 657 struct drm_plane *cursor, 658 const struct drm_crtc_funcs *funcs) 659 { 660 struct drm_mode_config *config = &dev->mode_config; 661 int ret; 662 663 crtc->dev = dev; 664 crtc->funcs = funcs; 665 crtc->invert_dimensions = false; 666 667 drm_modeset_lock_init(&crtc->mutex); 668 ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC); 669 if (ret) 670 return ret; 671 672 crtc->base.properties = &crtc->properties; 673 674 list_add_tail(&crtc->head, &config->crtc_list); 675 config->num_crtc++; 676 677 crtc->primary = primary; 678 crtc->cursor = cursor; 679 if (primary) 680 primary->possible_crtcs = 1 << drm_crtc_index(crtc); 681 if (cursor) 682 cursor->possible_crtcs = 1 << drm_crtc_index(crtc); 683 684 if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { 685 drm_object_attach_property(&crtc->base, config->prop_active, 0); 686 } 687 688 return 0; 689 } 690 EXPORT_SYMBOL(drm_crtc_init_with_planes); 691 692 /** 693 * drm_crtc_cleanup - Clean up the core crtc usage 694 * @crtc: CRTC to cleanup 695 * 696 * This function cleans up @crtc and removes it from the DRM mode setting 697 * core. Note that the function does *not* free the crtc structure itself, 698 * this is the responsibility of the caller. 699 */ 700 void drm_crtc_cleanup(struct drm_crtc *crtc) 701 { 702 struct drm_device *dev = crtc->dev; 703 704 kfree(crtc->gamma_store); 705 crtc->gamma_store = NULL; 706 707 drm_modeset_lock_fini(&crtc->mutex); 708 709 drm_mode_object_put(dev, &crtc->base); 710 list_del(&crtc->head); 711 dev->mode_config.num_crtc--; 712 713 WARN_ON(crtc->state && !crtc->funcs->atomic_destroy_state); 714 if (crtc->state && crtc->funcs->atomic_destroy_state) 715 crtc->funcs->atomic_destroy_state(crtc, crtc->state); 716 717 memset(crtc, 0, sizeof(*crtc)); 718 } 719 EXPORT_SYMBOL(drm_crtc_cleanup); 720 721 /** 722 * drm_crtc_index - find the index of a registered CRTC 723 * @crtc: CRTC to find index for 724 * 725 * Given a registered CRTC, return the index of that CRTC within a DRM 726 * device's list of CRTCs. 727 */ 728 unsigned int drm_crtc_index(struct drm_crtc *crtc) 729 { 730 unsigned int index = 0; 731 struct drm_crtc *tmp; 732 733 list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head) { 734 if (tmp == crtc) 735 return index; 736 737 index++; 738 } 739 740 BUG(); 741 } 742 EXPORT_SYMBOL(drm_crtc_index); 743 744 /* 745 * drm_mode_remove - remove and free a mode 746 * @connector: connector list to modify 747 * @mode: mode to remove 748 * 749 * Remove @mode from @connector's mode list, then free it. 750 */ 751 static void drm_mode_remove(struct drm_connector *connector, 752 struct drm_display_mode *mode) 753 { 754 list_del(&mode->head); 755 drm_mode_destroy(connector->dev, mode); 756 } 757 758 /** 759 * drm_display_info_set_bus_formats - set the supported bus formats 760 * @info: display info to store bus formats in 761 * @formats: array containing the supported bus formats 762 * @num_formats: the number of entries in the fmts array 763 * 764 * Store the supported bus formats in display info structure. 765 * See MEDIA_BUS_FMT_* definitions in include/uapi/linux/media-bus-format.h for 766 * a full list of available formats. 767 */ 768 int drm_display_info_set_bus_formats(struct drm_display_info *info, 769 const u32 *formats, 770 unsigned int num_formats) 771 { 772 u32 *fmts = NULL; 773 774 if (!formats && num_formats) 775 return -EINVAL; 776 777 if (formats && num_formats) { 778 fmts = kmemdup(formats, sizeof(*formats) * num_formats, 779 GFP_KERNEL); 780 if (!fmts) 781 return -ENOMEM; 782 } 783 784 kfree(info->bus_formats); 785 info->bus_formats = fmts; 786 info->num_bus_formats = num_formats; 787 788 return 0; 789 } 790 EXPORT_SYMBOL(drm_display_info_set_bus_formats); 791 792 /** 793 * drm_connector_get_cmdline_mode - reads the user's cmdline mode 794 * @connector: connector to quwery 795 * 796 * The kernel supports per-connector configration of its consoles through 797 * use of the video= parameter. This function parses that option and 798 * extracts the user's specified mode (or enable/disable status) for a 799 * particular connector. This is typically only used during the early fbdev 800 * setup. 801 */ 802 static void drm_connector_get_cmdline_mode(struct drm_connector *connector) 803 { 804 struct drm_cmdline_mode *mode = &connector->cmdline_mode; 805 char *option = NULL; 806 807 if (fb_get_options(connector->name, &option)) 808 return; 809 810 if (!drm_mode_parse_command_line_for_connector(option, 811 connector, 812 mode)) 813 return; 814 815 if (mode->force) { 816 const char *s; 817 818 switch (mode->force) { 819 case DRM_FORCE_OFF: 820 s = "OFF"; 821 break; 822 case DRM_FORCE_ON_DIGITAL: 823 s = "ON - dig"; 824 break; 825 default: 826 case DRM_FORCE_ON: 827 s = "ON"; 828 break; 829 } 830 831 DRM_INFO("forcing %s connector %s\n", connector->name, s); 832 connector->force = mode->force; 833 } 834 835 DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n", 836 connector->name, 837 mode->xres, mode->yres, 838 mode->refresh_specified ? mode->refresh : 60, 839 mode->rb ? " reduced blanking" : "", 840 mode->margins ? " with margins" : "", 841 mode->interlace ? " interlaced" : ""); 842 } 843 844 /** 845 * drm_connector_init - Init a preallocated connector 846 * @dev: DRM device 847 * @connector: the connector to init 848 * @funcs: callbacks for this connector 849 * @connector_type: user visible type of the connector 850 * 851 * Initialises a preallocated connector. Connectors should be 852 * subclassed as part of driver connector objects. 853 * 854 * Returns: 855 * Zero on success, error code on failure. 856 */ 857 int drm_connector_init(struct drm_device *dev, 858 struct drm_connector *connector, 859 const struct drm_connector_funcs *funcs, 860 int connector_type) 861 { 862 struct drm_mode_config *config = &dev->mode_config; 863 int ret; 864 struct ida *connector_ida = 865 &drm_connector_enum_list[connector_type].ida; 866 867 drm_modeset_lock_all(dev); 868 869 ret = drm_mode_object_get_reg(dev, &connector->base, DRM_MODE_OBJECT_CONNECTOR, false); 870 if (ret) 871 goto out_unlock; 872 873 connector->base.properties = &connector->properties; 874 connector->dev = dev; 875 connector->funcs = funcs; 876 connector->connector_type = connector_type; 877 connector->connector_type_id = 878 ida_simple_get(connector_ida, 1, 0, GFP_KERNEL); 879 if (connector->connector_type_id < 0) { 880 ret = connector->connector_type_id; 881 goto out_put; 882 } 883 connector->name = 884 kasprintf(GFP_KERNEL, "%s-%d", 885 drm_connector_enum_list[connector_type].name, 886 connector->connector_type_id); 887 if (!connector->name) { 888 ret = -ENOMEM; 889 goto out_put; 890 } 891 892 INIT_LIST_HEAD(&connector->probed_modes); 893 INIT_LIST_HEAD(&connector->modes); 894 connector->edid_blob_ptr = NULL; 895 connector->status = connector_status_unknown; 896 897 drm_connector_get_cmdline_mode(connector); 898 899 /* We should add connectors at the end to avoid upsetting the connector 900 * index too much. */ 901 list_add_tail(&connector->head, &config->connector_list); 902 config->num_connector++; 903 904 if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL) 905 drm_object_attach_property(&connector->base, 906 config->edid_property, 907 0); 908 909 drm_object_attach_property(&connector->base, 910 config->dpms_property, 0); 911 912 if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { 913 drm_object_attach_property(&connector->base, config->prop_crtc_id, 0); 914 } 915 916 connector->debugfs_entry = NULL; 917 918 out_put: 919 if (ret) 920 drm_mode_object_put(dev, &connector->base); 921 922 out_unlock: 923 drm_modeset_unlock_all(dev); 924 925 return ret; 926 } 927 EXPORT_SYMBOL(drm_connector_init); 928 929 /** 930 * drm_connector_cleanup - cleans up an initialised connector 931 * @connector: connector to cleanup 932 * 933 * Cleans up the connector but doesn't free the object. 934 */ 935 void drm_connector_cleanup(struct drm_connector *connector) 936 { 937 struct drm_device *dev = connector->dev; 938 struct drm_display_mode *mode, *t; 939 940 if (connector->tile_group) { 941 drm_mode_put_tile_group(dev, connector->tile_group); 942 connector->tile_group = NULL; 943 } 944 945 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) 946 drm_mode_remove(connector, mode); 947 948 list_for_each_entry_safe(mode, t, &connector->modes, head) 949 drm_mode_remove(connector, mode); 950 951 ida_remove(&drm_connector_enum_list[connector->connector_type].ida, 952 connector->connector_type_id); 953 954 kfree(connector->display_info.bus_formats); 955 drm_mode_object_put(dev, &connector->base); 956 kfree(connector->name); 957 connector->name = NULL; 958 list_del(&connector->head); 959 dev->mode_config.num_connector--; 960 961 WARN_ON(connector->state && !connector->funcs->atomic_destroy_state); 962 if (connector->state && connector->funcs->atomic_destroy_state) 963 connector->funcs->atomic_destroy_state(connector, 964 connector->state); 965 966 memset(connector, 0, sizeof(*connector)); 967 } 968 EXPORT_SYMBOL(drm_connector_cleanup); 969 970 /** 971 * drm_connector_index - find the index of a registered connector 972 * @connector: connector to find index for 973 * 974 * Given a registered connector, return the index of that connector within a DRM 975 * device's list of connectors. 976 */ 977 unsigned int drm_connector_index(struct drm_connector *connector) 978 { 979 unsigned int index = 0; 980 struct drm_connector *tmp; 981 struct drm_mode_config *config = &connector->dev->mode_config; 982 983 WARN_ON(!drm_modeset_is_locked(&config->connection_mutex)); 984 985 list_for_each_entry(tmp, &connector->dev->mode_config.connector_list, head) { 986 if (tmp == connector) 987 return index; 988 989 index++; 990 } 991 992 BUG(); 993 } 994 EXPORT_SYMBOL(drm_connector_index); 995 996 /** 997 * drm_connector_register - register a connector 998 * @connector: the connector to register 999 * 1000 * Register userspace interfaces for a connector 1001 * 1002 * Returns: 1003 * Zero on success, error code on failure. 1004 */ 1005 int drm_connector_register(struct drm_connector *connector) 1006 { 1007 int ret; 1008 1009 drm_mode_object_register(connector->dev, &connector->base); 1010 1011 ret = drm_sysfs_connector_add(connector); 1012 if (ret) 1013 return ret; 1014 1015 ret = drm_debugfs_connector_add(connector); 1016 if (ret) { 1017 drm_sysfs_connector_remove(connector); 1018 return ret; 1019 } 1020 1021 return 0; 1022 } 1023 EXPORT_SYMBOL(drm_connector_register); 1024 1025 /** 1026 * drm_connector_unregister - unregister a connector 1027 * @connector: the connector to unregister 1028 * 1029 * Unregister userspace interfaces for a connector 1030 */ 1031 void drm_connector_unregister(struct drm_connector *connector) 1032 { 1033 drm_sysfs_connector_remove(connector); 1034 drm_debugfs_connector_remove(connector); 1035 } 1036 EXPORT_SYMBOL(drm_connector_unregister); 1037 1038 1039 /** 1040 * drm_connector_unplug_all - unregister connector userspace interfaces 1041 * @dev: drm device 1042 * 1043 * This function unregisters all connector userspace interfaces in sysfs. Should 1044 * be call when the device is disconnected, e.g. from an usb driver's 1045 * ->disconnect callback. 1046 */ 1047 void drm_connector_unplug_all(struct drm_device *dev) 1048 { 1049 struct drm_connector *connector; 1050 1051 /* taking the mode config mutex ends up in a clash with sysfs */ 1052 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 1053 drm_connector_unregister(connector); 1054 1055 } 1056 EXPORT_SYMBOL(drm_connector_unplug_all); 1057 1058 /** 1059 * drm_encoder_init - Init a preallocated encoder 1060 * @dev: drm device 1061 * @encoder: the encoder to init 1062 * @funcs: callbacks for this encoder 1063 * @encoder_type: user visible type of the encoder 1064 * 1065 * Initialises a preallocated encoder. Encoder should be 1066 * subclassed as part of driver encoder objects. 1067 * 1068 * Returns: 1069 * Zero on success, error code on failure. 1070 */ 1071 int drm_encoder_init(struct drm_device *dev, 1072 struct drm_encoder *encoder, 1073 const struct drm_encoder_funcs *funcs, 1074 int encoder_type) 1075 { 1076 int ret; 1077 1078 drm_modeset_lock_all(dev); 1079 1080 ret = drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER); 1081 if (ret) 1082 goto out_unlock; 1083 1084 encoder->dev = dev; 1085 encoder->encoder_type = encoder_type; 1086 encoder->funcs = funcs; 1087 encoder->name = kasprintf(GFP_KERNEL, "%s-%d", 1088 drm_encoder_enum_list[encoder_type].name, 1089 encoder->base.id); 1090 if (!encoder->name) { 1091 ret = -ENOMEM; 1092 goto out_put; 1093 } 1094 1095 list_add_tail(&encoder->head, &dev->mode_config.encoder_list); 1096 dev->mode_config.num_encoder++; 1097 1098 out_put: 1099 if (ret) 1100 drm_mode_object_put(dev, &encoder->base); 1101 1102 out_unlock: 1103 drm_modeset_unlock_all(dev); 1104 1105 return ret; 1106 } 1107 EXPORT_SYMBOL(drm_encoder_init); 1108 1109 /** 1110 * drm_encoder_cleanup - cleans up an initialised encoder 1111 * @encoder: encoder to cleanup 1112 * 1113 * Cleans up the encoder but doesn't free the object. 1114 */ 1115 void drm_encoder_cleanup(struct drm_encoder *encoder) 1116 { 1117 struct drm_device *dev = encoder->dev; 1118 1119 drm_modeset_lock_all(dev); 1120 drm_mode_object_put(dev, &encoder->base); 1121 kfree(encoder->name); 1122 list_del(&encoder->head); 1123 dev->mode_config.num_encoder--; 1124 drm_modeset_unlock_all(dev); 1125 1126 memset(encoder, 0, sizeof(*encoder)); 1127 } 1128 EXPORT_SYMBOL(drm_encoder_cleanup); 1129 1130 /** 1131 * drm_universal_plane_init - Initialize a new universal plane object 1132 * @dev: DRM device 1133 * @plane: plane object to init 1134 * @possible_crtcs: bitmask of possible CRTCs 1135 * @funcs: callbacks for the new plane 1136 * @formats: array of supported formats (%DRM_FORMAT_*) 1137 * @format_count: number of elements in @formats 1138 * @type: type of plane (overlay, primary, cursor) 1139 * 1140 * Initializes a plane object of type @type. 1141 * 1142 * Returns: 1143 * Zero on success, error code on failure. 1144 */ 1145 int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane, 1146 unsigned long possible_crtcs, 1147 const struct drm_plane_funcs *funcs, 1148 const uint32_t *formats, uint32_t format_count, 1149 enum drm_plane_type type) 1150 { 1151 struct drm_mode_config *config = &dev->mode_config; 1152 int ret; 1153 1154 ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE); 1155 if (ret) 1156 return ret; 1157 1158 drm_modeset_lock_init(&plane->mutex); 1159 1160 plane->base.properties = &plane->properties; 1161 plane->dev = dev; 1162 plane->funcs = funcs; 1163 plane->format_types = kmalloc_array(format_count, sizeof(uint32_t), 1164 GFP_KERNEL); 1165 if (!plane->format_types) { 1166 DRM_DEBUG_KMS("out of memory when allocating plane\n"); 1167 drm_mode_object_put(dev, &plane->base); 1168 return -ENOMEM; 1169 } 1170 1171 memcpy(plane->format_types, formats, format_count * sizeof(uint32_t)); 1172 plane->format_count = format_count; 1173 plane->possible_crtcs = possible_crtcs; 1174 plane->type = type; 1175 1176 list_add_tail(&plane->head, &config->plane_list); 1177 config->num_total_plane++; 1178 if (plane->type == DRM_PLANE_TYPE_OVERLAY) 1179 config->num_overlay_plane++; 1180 1181 drm_object_attach_property(&plane->base, 1182 config->plane_type_property, 1183 plane->type); 1184 1185 if (drm_core_check_feature(dev, DRIVER_ATOMIC)) { 1186 drm_object_attach_property(&plane->base, config->prop_fb_id, 0); 1187 drm_object_attach_property(&plane->base, config->prop_crtc_id, 0); 1188 drm_object_attach_property(&plane->base, config->prop_crtc_x, 0); 1189 drm_object_attach_property(&plane->base, config->prop_crtc_y, 0); 1190 drm_object_attach_property(&plane->base, config->prop_crtc_w, 0); 1191 drm_object_attach_property(&plane->base, config->prop_crtc_h, 0); 1192 drm_object_attach_property(&plane->base, config->prop_src_x, 0); 1193 drm_object_attach_property(&plane->base, config->prop_src_y, 0); 1194 drm_object_attach_property(&plane->base, config->prop_src_w, 0); 1195 drm_object_attach_property(&plane->base, config->prop_src_h, 0); 1196 } 1197 1198 return 0; 1199 } 1200 EXPORT_SYMBOL(drm_universal_plane_init); 1201 1202 /** 1203 * drm_plane_init - Initialize a legacy plane 1204 * @dev: DRM device 1205 * @plane: plane object to init 1206 * @possible_crtcs: bitmask of possible CRTCs 1207 * @funcs: callbacks for the new plane 1208 * @formats: array of supported formats (%DRM_FORMAT_*) 1209 * @format_count: number of elements in @formats 1210 * @is_primary: plane type (primary vs overlay) 1211 * 1212 * Legacy API to initialize a DRM plane. 1213 * 1214 * New drivers should call drm_universal_plane_init() instead. 1215 * 1216 * Returns: 1217 * Zero on success, error code on failure. 1218 */ 1219 int drm_plane_init(struct drm_device *dev, struct drm_plane *plane, 1220 unsigned long possible_crtcs, 1221 const struct drm_plane_funcs *funcs, 1222 const uint32_t *formats, uint32_t format_count, 1223 bool is_primary) 1224 { 1225 enum drm_plane_type type; 1226 1227 type = is_primary ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY; 1228 return drm_universal_plane_init(dev, plane, possible_crtcs, funcs, 1229 formats, format_count, type); 1230 } 1231 EXPORT_SYMBOL(drm_plane_init); 1232 1233 /** 1234 * drm_plane_cleanup - Clean up the core plane usage 1235 * @plane: plane to cleanup 1236 * 1237 * This function cleans up @plane and removes it from the DRM mode setting 1238 * core. Note that the function does *not* free the plane structure itself, 1239 * this is the responsibility of the caller. 1240 */ 1241 void drm_plane_cleanup(struct drm_plane *plane) 1242 { 1243 struct drm_device *dev = plane->dev; 1244 1245 drm_modeset_lock_all(dev); 1246 kfree(plane->format_types); 1247 drm_mode_object_put(dev, &plane->base); 1248 1249 BUG_ON(list_empty(&plane->head)); 1250 1251 list_del(&plane->head); 1252 dev->mode_config.num_total_plane--; 1253 if (plane->type == DRM_PLANE_TYPE_OVERLAY) 1254 dev->mode_config.num_overlay_plane--; 1255 drm_modeset_unlock_all(dev); 1256 1257 WARN_ON(plane->state && !plane->funcs->atomic_destroy_state); 1258 if (plane->state && plane->funcs->atomic_destroy_state) 1259 plane->funcs->atomic_destroy_state(plane, plane->state); 1260 1261 memset(plane, 0, sizeof(*plane)); 1262 } 1263 EXPORT_SYMBOL(drm_plane_cleanup); 1264 1265 /** 1266 * drm_plane_index - find the index of a registered plane 1267 * @plane: plane to find index for 1268 * 1269 * Given a registered plane, return the index of that CRTC within a DRM 1270 * device's list of planes. 1271 */ 1272 unsigned int drm_plane_index(struct drm_plane *plane) 1273 { 1274 unsigned int index = 0; 1275 struct drm_plane *tmp; 1276 1277 list_for_each_entry(tmp, &plane->dev->mode_config.plane_list, head) { 1278 if (tmp == plane) 1279 return index; 1280 1281 index++; 1282 } 1283 1284 BUG(); 1285 } 1286 EXPORT_SYMBOL(drm_plane_index); 1287 1288 /** 1289 * drm_plane_force_disable - Forcibly disable a plane 1290 * @plane: plane to disable 1291 * 1292 * Forces the plane to be disabled. 1293 * 1294 * Used when the plane's current framebuffer is destroyed, 1295 * and when restoring fbdev mode. 1296 */ 1297 void drm_plane_force_disable(struct drm_plane *plane) 1298 { 1299 int ret; 1300 1301 if (!plane->fb) 1302 return; 1303 1304 plane->old_fb = plane->fb; 1305 ret = plane->funcs->disable_plane(plane); 1306 if (ret) { 1307 DRM_ERROR("failed to disable plane with busy fb\n"); 1308 plane->old_fb = NULL; 1309 return; 1310 } 1311 /* disconnect the plane from the fb and crtc: */ 1312 drm_framebuffer_unreference(plane->old_fb); 1313 plane->old_fb = NULL; 1314 plane->fb = NULL; 1315 plane->crtc = NULL; 1316 } 1317 EXPORT_SYMBOL(drm_plane_force_disable); 1318 1319 static int drm_mode_create_standard_properties(struct drm_device *dev) 1320 { 1321 struct drm_property *prop; 1322 1323 /* 1324 * Standard properties (apply to all connectors) 1325 */ 1326 prop = drm_property_create(dev, DRM_MODE_PROP_BLOB | 1327 DRM_MODE_PROP_IMMUTABLE, 1328 "EDID", 0); 1329 if (!prop) 1330 return -ENOMEM; 1331 dev->mode_config.edid_property = prop; 1332 1333 prop = drm_property_create_enum(dev, 0, 1334 "DPMS", drm_dpms_enum_list, 1335 ARRAY_SIZE(drm_dpms_enum_list)); 1336 if (!prop) 1337 return -ENOMEM; 1338 dev->mode_config.dpms_property = prop; 1339 1340 prop = drm_property_create(dev, 1341 DRM_MODE_PROP_BLOB | 1342 DRM_MODE_PROP_IMMUTABLE, 1343 "PATH", 0); 1344 if (!prop) 1345 return -ENOMEM; 1346 dev->mode_config.path_property = prop; 1347 1348 prop = drm_property_create(dev, 1349 DRM_MODE_PROP_BLOB | 1350 DRM_MODE_PROP_IMMUTABLE, 1351 "TILE", 0); 1352 if (!prop) 1353 return -ENOMEM; 1354 dev->mode_config.tile_property = prop; 1355 1356 prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 1357 "type", drm_plane_type_enum_list, 1358 ARRAY_SIZE(drm_plane_type_enum_list)); 1359 if (!prop) 1360 return -ENOMEM; 1361 dev->mode_config.plane_type_property = prop; 1362 1363 prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, 1364 "SRC_X", 0, UINT_MAX); 1365 if (!prop) 1366 return -ENOMEM; 1367 dev->mode_config.prop_src_x = prop; 1368 1369 prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, 1370 "SRC_Y", 0, UINT_MAX); 1371 if (!prop) 1372 return -ENOMEM; 1373 dev->mode_config.prop_src_y = prop; 1374 1375 prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, 1376 "SRC_W", 0, UINT_MAX); 1377 if (!prop) 1378 return -ENOMEM; 1379 dev->mode_config.prop_src_w = prop; 1380 1381 prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, 1382 "SRC_H", 0, UINT_MAX); 1383 if (!prop) 1384 return -ENOMEM; 1385 dev->mode_config.prop_src_h = prop; 1386 1387 prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC, 1388 "CRTC_X", INT_MIN, INT_MAX); 1389 if (!prop) 1390 return -ENOMEM; 1391 dev->mode_config.prop_crtc_x = prop; 1392 1393 prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC, 1394 "CRTC_Y", INT_MIN, INT_MAX); 1395 if (!prop) 1396 return -ENOMEM; 1397 dev->mode_config.prop_crtc_y = prop; 1398 1399 prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, 1400 "CRTC_W", 0, INT_MAX); 1401 if (!prop) 1402 return -ENOMEM; 1403 dev->mode_config.prop_crtc_w = prop; 1404 1405 prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, 1406 "CRTC_H", 0, INT_MAX); 1407 if (!prop) 1408 return -ENOMEM; 1409 dev->mode_config.prop_crtc_h = prop; 1410 1411 prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC, 1412 "FB_ID", DRM_MODE_OBJECT_FB); 1413 if (!prop) 1414 return -ENOMEM; 1415 dev->mode_config.prop_fb_id = prop; 1416 1417 prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC, 1418 "CRTC_ID", DRM_MODE_OBJECT_CRTC); 1419 if (!prop) 1420 return -ENOMEM; 1421 dev->mode_config.prop_crtc_id = prop; 1422 1423 prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC, 1424 "ACTIVE"); 1425 if (!prop) 1426 return -ENOMEM; 1427 dev->mode_config.prop_active = prop; 1428 1429 return 0; 1430 } 1431 1432 /** 1433 * drm_mode_create_dvi_i_properties - create DVI-I specific connector properties 1434 * @dev: DRM device 1435 * 1436 * Called by a driver the first time a DVI-I connector is made. 1437 */ 1438 int drm_mode_create_dvi_i_properties(struct drm_device *dev) 1439 { 1440 struct drm_property *dvi_i_selector; 1441 struct drm_property *dvi_i_subconnector; 1442 1443 if (dev->mode_config.dvi_i_select_subconnector_property) 1444 return 0; 1445 1446 dvi_i_selector = 1447 drm_property_create_enum(dev, 0, 1448 "select subconnector", 1449 drm_dvi_i_select_enum_list, 1450 ARRAY_SIZE(drm_dvi_i_select_enum_list)); 1451 dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector; 1452 1453 dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 1454 "subconnector", 1455 drm_dvi_i_subconnector_enum_list, 1456 ARRAY_SIZE(drm_dvi_i_subconnector_enum_list)); 1457 dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector; 1458 1459 return 0; 1460 } 1461 EXPORT_SYMBOL(drm_mode_create_dvi_i_properties); 1462 1463 /** 1464 * drm_create_tv_properties - create TV specific connector properties 1465 * @dev: DRM device 1466 * @num_modes: number of different TV formats (modes) supported 1467 * @modes: array of pointers to strings containing name of each format 1468 * 1469 * Called by a driver's TV initialization routine, this function creates 1470 * the TV specific connector properties for a given device. Caller is 1471 * responsible for allocating a list of format names and passing them to 1472 * this routine. 1473 */ 1474 int drm_mode_create_tv_properties(struct drm_device *dev, 1475 unsigned int num_modes, 1476 char *modes[]) 1477 { 1478 struct drm_property *tv_selector; 1479 struct drm_property *tv_subconnector; 1480 unsigned int i; 1481 1482 if (dev->mode_config.tv_select_subconnector_property) 1483 return 0; 1484 1485 /* 1486 * Basic connector properties 1487 */ 1488 tv_selector = drm_property_create_enum(dev, 0, 1489 "select subconnector", 1490 drm_tv_select_enum_list, 1491 ARRAY_SIZE(drm_tv_select_enum_list)); 1492 dev->mode_config.tv_select_subconnector_property = tv_selector; 1493 1494 tv_subconnector = 1495 drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 1496 "subconnector", 1497 drm_tv_subconnector_enum_list, 1498 ARRAY_SIZE(drm_tv_subconnector_enum_list)); 1499 dev->mode_config.tv_subconnector_property = tv_subconnector; 1500 1501 /* 1502 * Other, TV specific properties: margins & TV modes. 1503 */ 1504 dev->mode_config.tv_left_margin_property = 1505 drm_property_create_range(dev, 0, "left margin", 0, 100); 1506 1507 dev->mode_config.tv_right_margin_property = 1508 drm_property_create_range(dev, 0, "right margin", 0, 100); 1509 1510 dev->mode_config.tv_top_margin_property = 1511 drm_property_create_range(dev, 0, "top margin", 0, 100); 1512 1513 dev->mode_config.tv_bottom_margin_property = 1514 drm_property_create_range(dev, 0, "bottom margin", 0, 100); 1515 1516 dev->mode_config.tv_mode_property = 1517 drm_property_create(dev, DRM_MODE_PROP_ENUM, 1518 "mode", num_modes); 1519 for (i = 0; i < num_modes; i++) 1520 drm_property_add_enum(dev->mode_config.tv_mode_property, i, 1521 i, modes[i]); 1522 1523 dev->mode_config.tv_brightness_property = 1524 drm_property_create_range(dev, 0, "brightness", 0, 100); 1525 1526 dev->mode_config.tv_contrast_property = 1527 drm_property_create_range(dev, 0, "contrast", 0, 100); 1528 1529 dev->mode_config.tv_flicker_reduction_property = 1530 drm_property_create_range(dev, 0, "flicker reduction", 0, 100); 1531 1532 dev->mode_config.tv_overscan_property = 1533 drm_property_create_range(dev, 0, "overscan", 0, 100); 1534 1535 dev->mode_config.tv_saturation_property = 1536 drm_property_create_range(dev, 0, "saturation", 0, 100); 1537 1538 dev->mode_config.tv_hue_property = 1539 drm_property_create_range(dev, 0, "hue", 0, 100); 1540 1541 return 0; 1542 } 1543 EXPORT_SYMBOL(drm_mode_create_tv_properties); 1544 1545 /** 1546 * drm_mode_create_scaling_mode_property - create scaling mode property 1547 * @dev: DRM device 1548 * 1549 * Called by a driver the first time it's needed, must be attached to desired 1550 * connectors. 1551 */ 1552 int drm_mode_create_scaling_mode_property(struct drm_device *dev) 1553 { 1554 struct drm_property *scaling_mode; 1555 1556 if (dev->mode_config.scaling_mode_property) 1557 return 0; 1558 1559 scaling_mode = 1560 drm_property_create_enum(dev, 0, "scaling mode", 1561 drm_scaling_mode_enum_list, 1562 ARRAY_SIZE(drm_scaling_mode_enum_list)); 1563 1564 dev->mode_config.scaling_mode_property = scaling_mode; 1565 1566 return 0; 1567 } 1568 EXPORT_SYMBOL(drm_mode_create_scaling_mode_property); 1569 1570 /** 1571 * drm_mode_create_aspect_ratio_property - create aspect ratio property 1572 * @dev: DRM device 1573 * 1574 * Called by a driver the first time it's needed, must be attached to desired 1575 * connectors. 1576 * 1577 * Returns: 1578 * Zero on success, negative errno on failure. 1579 */ 1580 int drm_mode_create_aspect_ratio_property(struct drm_device *dev) 1581 { 1582 if (dev->mode_config.aspect_ratio_property) 1583 return 0; 1584 1585 dev->mode_config.aspect_ratio_property = 1586 drm_property_create_enum(dev, 0, "aspect ratio", 1587 drm_aspect_ratio_enum_list, 1588 ARRAY_SIZE(drm_aspect_ratio_enum_list)); 1589 1590 if (dev->mode_config.aspect_ratio_property == NULL) 1591 return -ENOMEM; 1592 1593 return 0; 1594 } 1595 EXPORT_SYMBOL(drm_mode_create_aspect_ratio_property); 1596 1597 /** 1598 * drm_mode_create_dirty_property - create dirty property 1599 * @dev: DRM device 1600 * 1601 * Called by a driver the first time it's needed, must be attached to desired 1602 * connectors. 1603 */ 1604 int drm_mode_create_dirty_info_property(struct drm_device *dev) 1605 { 1606 struct drm_property *dirty_info; 1607 1608 if (dev->mode_config.dirty_info_property) 1609 return 0; 1610 1611 dirty_info = 1612 drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE, 1613 "dirty", 1614 drm_dirty_info_enum_list, 1615 ARRAY_SIZE(drm_dirty_info_enum_list)); 1616 dev->mode_config.dirty_info_property = dirty_info; 1617 1618 return 0; 1619 } 1620 EXPORT_SYMBOL(drm_mode_create_dirty_info_property); 1621 1622 /** 1623 * drm_mode_create_suggested_offset_properties - create suggests offset properties 1624 * @dev: DRM device 1625 * 1626 * Create the the suggested x/y offset property for connectors. 1627 */ 1628 int drm_mode_create_suggested_offset_properties(struct drm_device *dev) 1629 { 1630 if (dev->mode_config.suggested_x_property && dev->mode_config.suggested_y_property) 1631 return 0; 1632 1633 dev->mode_config.suggested_x_property = 1634 drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested X", 0, 0xffffffff); 1635 1636 dev->mode_config.suggested_y_property = 1637 drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested Y", 0, 0xffffffff); 1638 1639 if (dev->mode_config.suggested_x_property == NULL || 1640 dev->mode_config.suggested_y_property == NULL) 1641 return -ENOMEM; 1642 return 0; 1643 } 1644 EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties); 1645 1646 static int drm_mode_group_init(struct drm_device *dev, struct drm_mode_group *group) 1647 { 1648 uint32_t total_objects = 0; 1649 1650 total_objects += dev->mode_config.num_crtc; 1651 total_objects += dev->mode_config.num_connector; 1652 total_objects += dev->mode_config.num_encoder; 1653 1654 group->id_list = kcalloc(total_objects, sizeof(uint32_t), GFP_KERNEL); 1655 if (!group->id_list) 1656 return -ENOMEM; 1657 1658 group->num_crtcs = 0; 1659 group->num_connectors = 0; 1660 group->num_encoders = 0; 1661 return 0; 1662 } 1663 1664 void drm_mode_group_destroy(struct drm_mode_group *group) 1665 { 1666 kfree(group->id_list); 1667 group->id_list = NULL; 1668 } 1669 1670 /* 1671 * NOTE: Driver's shouldn't ever call drm_mode_group_init_legacy_group - it is 1672 * the drm core's responsibility to set up mode control groups. 1673 */ 1674 int drm_mode_group_init_legacy_group(struct drm_device *dev, 1675 struct drm_mode_group *group) 1676 { 1677 struct drm_crtc *crtc; 1678 struct drm_encoder *encoder; 1679 struct drm_connector *connector; 1680 int ret; 1681 1682 ret = drm_mode_group_init(dev, group); 1683 if (ret) 1684 return ret; 1685 1686 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) 1687 group->id_list[group->num_crtcs++] = crtc->base.id; 1688 1689 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) 1690 group->id_list[group->num_crtcs + group->num_encoders++] = 1691 encoder->base.id; 1692 1693 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 1694 group->id_list[group->num_crtcs + group->num_encoders + 1695 group->num_connectors++] = connector->base.id; 1696 1697 return 0; 1698 } 1699 EXPORT_SYMBOL(drm_mode_group_init_legacy_group); 1700 1701 void drm_reinit_primary_mode_group(struct drm_device *dev) 1702 { 1703 drm_modeset_lock_all(dev); 1704 drm_mode_group_destroy(&dev->primary->mode_group); 1705 drm_mode_group_init_legacy_group(dev, &dev->primary->mode_group); 1706 drm_modeset_unlock_all(dev); 1707 } 1708 EXPORT_SYMBOL(drm_reinit_primary_mode_group); 1709 1710 /** 1711 * drm_crtc_convert_to_umode - convert a drm_display_mode into a modeinfo 1712 * @out: drm_mode_modeinfo struct to return to the user 1713 * @in: drm_display_mode to use 1714 * 1715 * Convert a drm_display_mode into a drm_mode_modeinfo structure to return to 1716 * the user. 1717 */ 1718 static void drm_crtc_convert_to_umode(struct drm_mode_modeinfo *out, 1719 const struct drm_display_mode *in) 1720 { 1721 WARN(in->hdisplay > USHRT_MAX || in->hsync_start > USHRT_MAX || 1722 in->hsync_end > USHRT_MAX || in->htotal > USHRT_MAX || 1723 in->hskew > USHRT_MAX || in->vdisplay > USHRT_MAX || 1724 in->vsync_start > USHRT_MAX || in->vsync_end > USHRT_MAX || 1725 in->vtotal > USHRT_MAX || in->vscan > USHRT_MAX, 1726 "timing values too large for mode info\n"); 1727 1728 out->clock = in->clock; 1729 out->hdisplay = in->hdisplay; 1730 out->hsync_start = in->hsync_start; 1731 out->hsync_end = in->hsync_end; 1732 out->htotal = in->htotal; 1733 out->hskew = in->hskew; 1734 out->vdisplay = in->vdisplay; 1735 out->vsync_start = in->vsync_start; 1736 out->vsync_end = in->vsync_end; 1737 out->vtotal = in->vtotal; 1738 out->vscan = in->vscan; 1739 out->vrefresh = in->vrefresh; 1740 out->flags = in->flags; 1741 out->type = in->type; 1742 strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN); 1743 out->name[DRM_DISPLAY_MODE_LEN-1] = 0; 1744 } 1745 1746 /** 1747 * drm_crtc_convert_umode - convert a modeinfo into a drm_display_mode 1748 * @out: drm_display_mode to return to the user 1749 * @in: drm_mode_modeinfo to use 1750 * 1751 * Convert a drm_mode_modeinfo into a drm_display_mode structure to return to 1752 * the caller. 1753 * 1754 * Returns: 1755 * Zero on success, negative errno on failure. 1756 */ 1757 static int drm_crtc_convert_umode(struct drm_display_mode *out, 1758 const struct drm_mode_modeinfo *in) 1759 { 1760 if (in->clock > INT_MAX || in->vrefresh > INT_MAX) 1761 return -ERANGE; 1762 1763 if ((in->flags & DRM_MODE_FLAG_3D_MASK) > DRM_MODE_FLAG_3D_MAX) 1764 return -EINVAL; 1765 1766 out->clock = in->clock; 1767 out->hdisplay = in->hdisplay; 1768 out->hsync_start = in->hsync_start; 1769 out->hsync_end = in->hsync_end; 1770 out->htotal = in->htotal; 1771 out->hskew = in->hskew; 1772 out->vdisplay = in->vdisplay; 1773 out->vsync_start = in->vsync_start; 1774 out->vsync_end = in->vsync_end; 1775 out->vtotal = in->vtotal; 1776 out->vscan = in->vscan; 1777 out->vrefresh = in->vrefresh; 1778 out->flags = in->flags; 1779 out->type = in->type; 1780 strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN); 1781 out->name[DRM_DISPLAY_MODE_LEN-1] = 0; 1782 1783 return 0; 1784 } 1785 1786 /** 1787 * drm_mode_getresources - get graphics configuration 1788 * @dev: drm device for the ioctl 1789 * @data: data pointer for the ioctl 1790 * @file_priv: drm file for the ioctl call 1791 * 1792 * Construct a set of configuration description structures and return 1793 * them to the user, including CRTC, connector and framebuffer configuration. 1794 * 1795 * Called by the user via ioctl. 1796 * 1797 * Returns: 1798 * Zero on success, negative errno on failure. 1799 */ 1800 int drm_mode_getresources(struct drm_device *dev, void *data, 1801 struct drm_file *file_priv) 1802 { 1803 struct drm_mode_card_res *card_res = data; 1804 struct list_head *lh; 1805 struct drm_framebuffer *fb; 1806 struct drm_connector *connector; 1807 struct drm_crtc *crtc; 1808 struct drm_encoder *encoder; 1809 int ret = 0; 1810 int connector_count = 0; 1811 int crtc_count = 0; 1812 int fb_count = 0; 1813 int encoder_count = 0; 1814 int copied = 0, i; 1815 uint32_t __user *fb_id; 1816 uint32_t __user *crtc_id; 1817 uint32_t __user *connector_id; 1818 uint32_t __user *encoder_id; 1819 struct drm_mode_group *mode_group; 1820 1821 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1822 return -EINVAL; 1823 1824 1825 mutex_lock(&file_priv->fbs_lock); 1826 /* 1827 * For the non-control nodes we need to limit the list of resources 1828 * by IDs in the group list for this node 1829 */ 1830 list_for_each(lh, &file_priv->fbs) 1831 fb_count++; 1832 1833 /* handle this in 4 parts */ 1834 /* FBs */ 1835 if (card_res->count_fbs >= fb_count) { 1836 copied = 0; 1837 fb_id = (uint32_t __user *)(unsigned long)card_res->fb_id_ptr; 1838 list_for_each_entry(fb, &file_priv->fbs, filp_head) { 1839 if (put_user(fb->base.id, fb_id + copied)) { 1840 mutex_unlock(&file_priv->fbs_lock); 1841 return -EFAULT; 1842 } 1843 copied++; 1844 } 1845 } 1846 card_res->count_fbs = fb_count; 1847 mutex_unlock(&file_priv->fbs_lock); 1848 1849 /* mode_config.mutex protects the connector list against e.g. DP MST 1850 * connector hot-adding. CRTC/Plane lists are invariant. */ 1851 mutex_lock(&dev->mode_config.mutex); 1852 if (!drm_is_primary_client(file_priv)) { 1853 1854 mode_group = NULL; 1855 list_for_each(lh, &dev->mode_config.crtc_list) 1856 crtc_count++; 1857 1858 list_for_each(lh, &dev->mode_config.connector_list) 1859 connector_count++; 1860 1861 list_for_each(lh, &dev->mode_config.encoder_list) 1862 encoder_count++; 1863 } else { 1864 1865 mode_group = &file_priv->master->minor->mode_group; 1866 crtc_count = mode_group->num_crtcs; 1867 connector_count = mode_group->num_connectors; 1868 encoder_count = mode_group->num_encoders; 1869 } 1870 1871 card_res->max_height = dev->mode_config.max_height; 1872 card_res->min_height = dev->mode_config.min_height; 1873 card_res->max_width = dev->mode_config.max_width; 1874 card_res->min_width = dev->mode_config.min_width; 1875 1876 /* CRTCs */ 1877 if (card_res->count_crtcs >= crtc_count) { 1878 copied = 0; 1879 crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr; 1880 if (!mode_group) { 1881 list_for_each_entry(crtc, &dev->mode_config.crtc_list, 1882 head) { 1883 DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id); 1884 if (put_user(crtc->base.id, crtc_id + copied)) { 1885 ret = -EFAULT; 1886 goto out; 1887 } 1888 copied++; 1889 } 1890 } else { 1891 for (i = 0; i < mode_group->num_crtcs; i++) { 1892 if (put_user(mode_group->id_list[i], 1893 crtc_id + copied)) { 1894 ret = -EFAULT; 1895 goto out; 1896 } 1897 copied++; 1898 } 1899 } 1900 } 1901 card_res->count_crtcs = crtc_count; 1902 1903 /* Encoders */ 1904 if (card_res->count_encoders >= encoder_count) { 1905 copied = 0; 1906 encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr; 1907 if (!mode_group) { 1908 list_for_each_entry(encoder, 1909 &dev->mode_config.encoder_list, 1910 head) { 1911 DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id, 1912 encoder->name); 1913 if (put_user(encoder->base.id, encoder_id + 1914 copied)) { 1915 ret = -EFAULT; 1916 goto out; 1917 } 1918 copied++; 1919 } 1920 } else { 1921 for (i = mode_group->num_crtcs; i < mode_group->num_crtcs + mode_group->num_encoders; i++) { 1922 if (put_user(mode_group->id_list[i], 1923 encoder_id + copied)) { 1924 ret = -EFAULT; 1925 goto out; 1926 } 1927 copied++; 1928 } 1929 1930 } 1931 } 1932 card_res->count_encoders = encoder_count; 1933 1934 /* Connectors */ 1935 if (card_res->count_connectors >= connector_count) { 1936 copied = 0; 1937 connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr; 1938 if (!mode_group) { 1939 list_for_each_entry(connector, 1940 &dev->mode_config.connector_list, 1941 head) { 1942 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", 1943 connector->base.id, 1944 connector->name); 1945 if (put_user(connector->base.id, 1946 connector_id + copied)) { 1947 ret = -EFAULT; 1948 goto out; 1949 } 1950 copied++; 1951 } 1952 } else { 1953 int start = mode_group->num_crtcs + 1954 mode_group->num_encoders; 1955 for (i = start; i < start + mode_group->num_connectors; i++) { 1956 if (put_user(mode_group->id_list[i], 1957 connector_id + copied)) { 1958 ret = -EFAULT; 1959 goto out; 1960 } 1961 copied++; 1962 } 1963 } 1964 } 1965 card_res->count_connectors = connector_count; 1966 1967 DRM_DEBUG_KMS("CRTC[%d] CONNECTORS[%d] ENCODERS[%d]\n", card_res->count_crtcs, 1968 card_res->count_connectors, card_res->count_encoders); 1969 1970 out: 1971 mutex_unlock(&dev->mode_config.mutex); 1972 return ret; 1973 } 1974 1975 /** 1976 * drm_mode_getcrtc - get CRTC configuration 1977 * @dev: drm device for the ioctl 1978 * @data: data pointer for the ioctl 1979 * @file_priv: drm file for the ioctl call 1980 * 1981 * Construct a CRTC configuration structure to return to the user. 1982 * 1983 * Called by the user via ioctl. 1984 * 1985 * Returns: 1986 * Zero on success, negative errno on failure. 1987 */ 1988 int drm_mode_getcrtc(struct drm_device *dev, 1989 void *data, struct drm_file *file_priv) 1990 { 1991 struct drm_mode_crtc *crtc_resp = data; 1992 struct drm_crtc *crtc; 1993 1994 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1995 return -EINVAL; 1996 1997 crtc = drm_crtc_find(dev, crtc_resp->crtc_id); 1998 if (!crtc) 1999 return -ENOENT; 2000 2001 drm_modeset_lock_crtc(crtc, crtc->primary); 2002 crtc_resp->x = crtc->x; 2003 crtc_resp->y = crtc->y; 2004 crtc_resp->gamma_size = crtc->gamma_size; 2005 if (crtc->primary->fb) 2006 crtc_resp->fb_id = crtc->primary->fb->base.id; 2007 else 2008 crtc_resp->fb_id = 0; 2009 2010 if (crtc->enabled) { 2011 2012 drm_crtc_convert_to_umode(&crtc_resp->mode, &crtc->mode); 2013 crtc_resp->mode_valid = 1; 2014 2015 } else { 2016 crtc_resp->mode_valid = 0; 2017 } 2018 drm_modeset_unlock_crtc(crtc); 2019 2020 return 0; 2021 } 2022 2023 static bool drm_mode_expose_to_userspace(const struct drm_display_mode *mode, 2024 const struct drm_file *file_priv) 2025 { 2026 /* 2027 * If user-space hasn't configured the driver to expose the stereo 3D 2028 * modes, don't expose them. 2029 */ 2030 if (!file_priv->stereo_allowed && drm_mode_is_stereo(mode)) 2031 return false; 2032 2033 return true; 2034 } 2035 2036 static struct drm_encoder *drm_connector_get_encoder(struct drm_connector *connector) 2037 { 2038 /* For atomic drivers only state objects are synchronously updated and 2039 * protected by modeset locks, so check those first. */ 2040 if (connector->state) 2041 return connector->state->best_encoder; 2042 return connector->encoder; 2043 } 2044 2045 /* helper for getconnector and getproperties ioctls */ 2046 static int get_properties(struct drm_mode_object *obj, bool atomic, 2047 uint32_t __user *prop_ptr, uint64_t __user *prop_values, 2048 uint32_t *arg_count_props) 2049 { 2050 int props_count; 2051 int i, ret, copied; 2052 2053 props_count = obj->properties->count; 2054 if (!atomic) 2055 props_count -= obj->properties->atomic_count; 2056 2057 if ((*arg_count_props >= props_count) && props_count) { 2058 for (i = 0, copied = 0; copied < props_count; i++) { 2059 struct drm_property *prop = obj->properties->properties[i]; 2060 uint64_t val; 2061 2062 if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic) 2063 continue; 2064 2065 ret = drm_object_property_get_value(obj, prop, &val); 2066 if (ret) 2067 return ret; 2068 2069 if (put_user(prop->base.id, prop_ptr + copied)) 2070 return -EFAULT; 2071 2072 if (put_user(val, prop_values + copied)) 2073 return -EFAULT; 2074 2075 copied++; 2076 } 2077 } 2078 *arg_count_props = props_count; 2079 2080 return 0; 2081 } 2082 2083 /** 2084 * drm_mode_getconnector - get connector configuration 2085 * @dev: drm device for the ioctl 2086 * @data: data pointer for the ioctl 2087 * @file_priv: drm file for the ioctl call 2088 * 2089 * Construct a connector configuration structure to return to the user. 2090 * 2091 * Called by the user via ioctl. 2092 * 2093 * Returns: 2094 * Zero on success, negative errno on failure. 2095 */ 2096 int drm_mode_getconnector(struct drm_device *dev, void *data, 2097 struct drm_file *file_priv) 2098 { 2099 struct drm_mode_get_connector *out_resp = data; 2100 struct drm_connector *connector; 2101 struct drm_encoder *encoder; 2102 struct drm_display_mode *mode; 2103 int mode_count = 0; 2104 int encoders_count = 0; 2105 int ret = 0; 2106 int copied = 0; 2107 int i; 2108 struct drm_mode_modeinfo u_mode; 2109 struct drm_mode_modeinfo __user *mode_ptr; 2110 uint32_t __user *encoder_ptr; 2111 2112 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2113 return -EINVAL; 2114 2115 memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo)); 2116 2117 DRM_DEBUG_KMS("[CONNECTOR:%d:?]\n", out_resp->connector_id); 2118 2119 mutex_lock(&dev->mode_config.mutex); 2120 2121 connector = drm_connector_find(dev, out_resp->connector_id); 2122 if (!connector) { 2123 ret = -ENOENT; 2124 goto out_unlock; 2125 } 2126 2127 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) 2128 if (connector->encoder_ids[i] != 0) 2129 encoders_count++; 2130 2131 if (out_resp->count_modes == 0) { 2132 connector->funcs->fill_modes(connector, 2133 dev->mode_config.max_width, 2134 dev->mode_config.max_height); 2135 } 2136 2137 /* delayed so we get modes regardless of pre-fill_modes state */ 2138 list_for_each_entry(mode, &connector->modes, head) 2139 if (drm_mode_expose_to_userspace(mode, file_priv)) 2140 mode_count++; 2141 2142 out_resp->connector_id = connector->base.id; 2143 out_resp->connector_type = connector->connector_type; 2144 out_resp->connector_type_id = connector->connector_type_id; 2145 out_resp->mm_width = connector->display_info.width_mm; 2146 out_resp->mm_height = connector->display_info.height_mm; 2147 out_resp->subpixel = connector->display_info.subpixel_order; 2148 out_resp->connection = connector->status; 2149 2150 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 2151 encoder = drm_connector_get_encoder(connector); 2152 if (encoder) 2153 out_resp->encoder_id = encoder->base.id; 2154 else 2155 out_resp->encoder_id = 0; 2156 2157 /* 2158 * This ioctl is called twice, once to determine how much space is 2159 * needed, and the 2nd time to fill it. 2160 */ 2161 if ((out_resp->count_modes >= mode_count) && mode_count) { 2162 copied = 0; 2163 mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr; 2164 list_for_each_entry(mode, &connector->modes, head) { 2165 if (!drm_mode_expose_to_userspace(mode, file_priv)) 2166 continue; 2167 2168 drm_crtc_convert_to_umode(&u_mode, mode); 2169 if (copy_to_user(mode_ptr + copied, 2170 &u_mode, sizeof(u_mode))) { 2171 ret = -EFAULT; 2172 goto out; 2173 } 2174 copied++; 2175 } 2176 } 2177 out_resp->count_modes = mode_count; 2178 2179 ret = get_properties(&connector->base, file_priv->atomic, 2180 (uint32_t __user *)(unsigned long)(out_resp->props_ptr), 2181 (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr), 2182 &out_resp->count_props); 2183 if (ret) 2184 goto out; 2185 2186 if ((out_resp->count_encoders >= encoders_count) && encoders_count) { 2187 copied = 0; 2188 encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr); 2189 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 2190 if (connector->encoder_ids[i] != 0) { 2191 if (put_user(connector->encoder_ids[i], 2192 encoder_ptr + copied)) { 2193 ret = -EFAULT; 2194 goto out; 2195 } 2196 copied++; 2197 } 2198 } 2199 } 2200 out_resp->count_encoders = encoders_count; 2201 2202 out: 2203 drm_modeset_unlock(&dev->mode_config.connection_mutex); 2204 2205 out_unlock: 2206 mutex_unlock(&dev->mode_config.mutex); 2207 2208 return ret; 2209 } 2210 2211 static struct drm_crtc *drm_encoder_get_crtc(struct drm_encoder *encoder) 2212 { 2213 struct drm_connector *connector; 2214 struct drm_device *dev = encoder->dev; 2215 bool uses_atomic = false; 2216 2217 /* For atomic drivers only state objects are synchronously updated and 2218 * protected by modeset locks, so check those first. */ 2219 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 2220 if (!connector->state) 2221 continue; 2222 2223 uses_atomic = true; 2224 2225 if (connector->state->best_encoder != encoder) 2226 continue; 2227 2228 return connector->state->crtc; 2229 } 2230 2231 /* Don't return stale data (e.g. pending async disable). */ 2232 if (uses_atomic) 2233 return NULL; 2234 2235 return encoder->crtc; 2236 } 2237 2238 /** 2239 * drm_mode_getencoder - get encoder configuration 2240 * @dev: drm device for the ioctl 2241 * @data: data pointer for the ioctl 2242 * @file_priv: drm file for the ioctl call 2243 * 2244 * Construct a encoder configuration structure to return to the user. 2245 * 2246 * Called by the user via ioctl. 2247 * 2248 * Returns: 2249 * Zero on success, negative errno on failure. 2250 */ 2251 int drm_mode_getencoder(struct drm_device *dev, void *data, 2252 struct drm_file *file_priv) 2253 { 2254 struct drm_mode_get_encoder *enc_resp = data; 2255 struct drm_encoder *encoder; 2256 struct drm_crtc *crtc; 2257 2258 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2259 return -EINVAL; 2260 2261 encoder = drm_encoder_find(dev, enc_resp->encoder_id); 2262 if (!encoder) 2263 return -ENOENT; 2264 2265 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL); 2266 crtc = drm_encoder_get_crtc(encoder); 2267 if (crtc) 2268 enc_resp->crtc_id = crtc->base.id; 2269 else if (encoder->crtc) 2270 enc_resp->crtc_id = encoder->crtc->base.id; 2271 else 2272 enc_resp->crtc_id = 0; 2273 drm_modeset_unlock(&dev->mode_config.connection_mutex); 2274 2275 enc_resp->encoder_type = encoder->encoder_type; 2276 enc_resp->encoder_id = encoder->base.id; 2277 enc_resp->possible_crtcs = encoder->possible_crtcs; 2278 enc_resp->possible_clones = encoder->possible_clones; 2279 2280 return 0; 2281 } 2282 2283 /** 2284 * drm_mode_getplane_res - enumerate all plane resources 2285 * @dev: DRM device 2286 * @data: ioctl data 2287 * @file_priv: DRM file info 2288 * 2289 * Construct a list of plane ids to return to the user. 2290 * 2291 * Called by the user via ioctl. 2292 * 2293 * Returns: 2294 * Zero on success, negative errno on failure. 2295 */ 2296 int drm_mode_getplane_res(struct drm_device *dev, void *data, 2297 struct drm_file *file_priv) 2298 { 2299 struct drm_mode_get_plane_res *plane_resp = data; 2300 struct drm_mode_config *config; 2301 struct drm_plane *plane; 2302 uint32_t __user *plane_ptr; 2303 int copied = 0; 2304 unsigned num_planes; 2305 2306 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2307 return -EINVAL; 2308 2309 config = &dev->mode_config; 2310 2311 if (file_priv->universal_planes) 2312 num_planes = config->num_total_plane; 2313 else 2314 num_planes = config->num_overlay_plane; 2315 2316 /* 2317 * This ioctl is called twice, once to determine how much space is 2318 * needed, and the 2nd time to fill it. 2319 */ 2320 if (num_planes && 2321 (plane_resp->count_planes >= num_planes)) { 2322 plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr; 2323 2324 /* Plane lists are invariant, no locking needed. */ 2325 list_for_each_entry(plane, &config->plane_list, head) { 2326 /* 2327 * Unless userspace set the 'universal planes' 2328 * capability bit, only advertise overlays. 2329 */ 2330 if (plane->type != DRM_PLANE_TYPE_OVERLAY && 2331 !file_priv->universal_planes) 2332 continue; 2333 2334 if (put_user(plane->base.id, plane_ptr + copied)) 2335 return -EFAULT; 2336 copied++; 2337 } 2338 } 2339 plane_resp->count_planes = num_planes; 2340 2341 return 0; 2342 } 2343 2344 /** 2345 * drm_mode_getplane - get plane configuration 2346 * @dev: DRM device 2347 * @data: ioctl data 2348 * @file_priv: DRM file info 2349 * 2350 * Construct a plane configuration structure to return to the user. 2351 * 2352 * Called by the user via ioctl. 2353 * 2354 * Returns: 2355 * Zero on success, negative errno on failure. 2356 */ 2357 int drm_mode_getplane(struct drm_device *dev, void *data, 2358 struct drm_file *file_priv) 2359 { 2360 struct drm_mode_get_plane *plane_resp = data; 2361 struct drm_plane *plane; 2362 uint32_t __user *format_ptr; 2363 2364 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2365 return -EINVAL; 2366 2367 plane = drm_plane_find(dev, plane_resp->plane_id); 2368 if (!plane) 2369 return -ENOENT; 2370 2371 drm_modeset_lock(&plane->mutex, NULL); 2372 if (plane->crtc) 2373 plane_resp->crtc_id = plane->crtc->base.id; 2374 else 2375 plane_resp->crtc_id = 0; 2376 2377 if (plane->fb) 2378 plane_resp->fb_id = plane->fb->base.id; 2379 else 2380 plane_resp->fb_id = 0; 2381 drm_modeset_unlock(&plane->mutex); 2382 2383 plane_resp->plane_id = plane->base.id; 2384 plane_resp->possible_crtcs = plane->possible_crtcs; 2385 plane_resp->gamma_size = 0; 2386 2387 /* 2388 * This ioctl is called twice, once to determine how much space is 2389 * needed, and the 2nd time to fill it. 2390 */ 2391 if (plane->format_count && 2392 (plane_resp->count_format_types >= plane->format_count)) { 2393 format_ptr = (uint32_t __user *)(unsigned long)plane_resp->format_type_ptr; 2394 if (copy_to_user(format_ptr, 2395 plane->format_types, 2396 sizeof(uint32_t) * plane->format_count)) { 2397 return -EFAULT; 2398 } 2399 } 2400 plane_resp->count_format_types = plane->format_count; 2401 2402 return 0; 2403 } 2404 2405 /* 2406 * setplane_internal - setplane handler for internal callers 2407 * 2408 * Note that we assume an extra reference has already been taken on fb. If the 2409 * update fails, this reference will be dropped before return; if it succeeds, 2410 * the previous framebuffer (if any) will be unreferenced instead. 2411 * 2412 * src_{x,y,w,h} are provided in 16.16 fixed point format 2413 */ 2414 static int __setplane_internal(struct drm_plane *plane, 2415 struct drm_crtc *crtc, 2416 struct drm_framebuffer *fb, 2417 int32_t crtc_x, int32_t crtc_y, 2418 uint32_t crtc_w, uint32_t crtc_h, 2419 /* src_{x,y,w,h} values are 16.16 fixed point */ 2420 uint32_t src_x, uint32_t src_y, 2421 uint32_t src_w, uint32_t src_h) 2422 { 2423 int ret = 0; 2424 unsigned int fb_width, fb_height; 2425 unsigned int i; 2426 2427 /* No fb means shut it down */ 2428 if (!fb) { 2429 plane->old_fb = plane->fb; 2430 ret = plane->funcs->disable_plane(plane); 2431 if (!ret) { 2432 plane->crtc = NULL; 2433 plane->fb = NULL; 2434 } else { 2435 plane->old_fb = NULL; 2436 } 2437 goto out; 2438 } 2439 2440 /* Check whether this plane is usable on this CRTC */ 2441 if (!(plane->possible_crtcs & drm_crtc_mask(crtc))) { 2442 DRM_DEBUG_KMS("Invalid crtc for plane\n"); 2443 ret = -EINVAL; 2444 goto out; 2445 } 2446 2447 /* Check whether this plane supports the fb pixel format. */ 2448 for (i = 0; i < plane->format_count; i++) 2449 if (fb->pixel_format == plane->format_types[i]) 2450 break; 2451 if (i == plane->format_count) { 2452 DRM_DEBUG_KMS("Invalid pixel format %s\n", 2453 drm_get_format_name(fb->pixel_format)); 2454 ret = -EINVAL; 2455 goto out; 2456 } 2457 2458 fb_width = fb->width << 16; 2459 fb_height = fb->height << 16; 2460 2461 /* Make sure source coordinates are inside the fb. */ 2462 if (src_w > fb_width || 2463 src_x > fb_width - src_w || 2464 src_h > fb_height || 2465 src_y > fb_height - src_h) { 2466 DRM_DEBUG_KMS("Invalid source coordinates " 2467 "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n", 2468 src_w >> 16, ((src_w & 0xffff) * 15625) >> 10, 2469 src_h >> 16, ((src_h & 0xffff) * 15625) >> 10, 2470 src_x >> 16, ((src_x & 0xffff) * 15625) >> 10, 2471 src_y >> 16, ((src_y & 0xffff) * 15625) >> 10); 2472 ret = -ENOSPC; 2473 goto out; 2474 } 2475 2476 plane->old_fb = plane->fb; 2477 ret = plane->funcs->update_plane(plane, crtc, fb, 2478 crtc_x, crtc_y, crtc_w, crtc_h, 2479 src_x, src_y, src_w, src_h); 2480 if (!ret) { 2481 plane->crtc = crtc; 2482 plane->fb = fb; 2483 fb = NULL; 2484 } else { 2485 plane->old_fb = NULL; 2486 } 2487 2488 out: 2489 if (fb) 2490 drm_framebuffer_unreference(fb); 2491 if (plane->old_fb) 2492 drm_framebuffer_unreference(plane->old_fb); 2493 plane->old_fb = NULL; 2494 2495 return ret; 2496 } 2497 2498 static int setplane_internal(struct drm_plane *plane, 2499 struct drm_crtc *crtc, 2500 struct drm_framebuffer *fb, 2501 int32_t crtc_x, int32_t crtc_y, 2502 uint32_t crtc_w, uint32_t crtc_h, 2503 /* src_{x,y,w,h} values are 16.16 fixed point */ 2504 uint32_t src_x, uint32_t src_y, 2505 uint32_t src_w, uint32_t src_h) 2506 { 2507 int ret; 2508 2509 drm_modeset_lock_all(plane->dev); 2510 ret = __setplane_internal(plane, crtc, fb, 2511 crtc_x, crtc_y, crtc_w, crtc_h, 2512 src_x, src_y, src_w, src_h); 2513 drm_modeset_unlock_all(plane->dev); 2514 2515 return ret; 2516 } 2517 2518 /** 2519 * drm_mode_setplane - configure a plane's configuration 2520 * @dev: DRM device 2521 * @data: ioctl data* 2522 * @file_priv: DRM file info 2523 * 2524 * Set plane configuration, including placement, fb, scaling, and other factors. 2525 * Or pass a NULL fb to disable (planes may be disabled without providing a 2526 * valid crtc). 2527 * 2528 * Returns: 2529 * Zero on success, negative errno on failure. 2530 */ 2531 int drm_mode_setplane(struct drm_device *dev, void *data, 2532 struct drm_file *file_priv) 2533 { 2534 struct drm_mode_set_plane *plane_req = data; 2535 struct drm_plane *plane; 2536 struct drm_crtc *crtc = NULL; 2537 struct drm_framebuffer *fb = NULL; 2538 2539 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2540 return -EINVAL; 2541 2542 /* Give drivers some help against integer overflows */ 2543 if (plane_req->crtc_w > INT_MAX || 2544 plane_req->crtc_x > INT_MAX - (int32_t) plane_req->crtc_w || 2545 plane_req->crtc_h > INT_MAX || 2546 plane_req->crtc_y > INT_MAX - (int32_t) plane_req->crtc_h) { 2547 DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n", 2548 plane_req->crtc_w, plane_req->crtc_h, 2549 plane_req->crtc_x, plane_req->crtc_y); 2550 return -ERANGE; 2551 } 2552 2553 /* 2554 * First, find the plane, crtc, and fb objects. If not available, 2555 * we don't bother to call the driver. 2556 */ 2557 plane = drm_plane_find(dev, plane_req->plane_id); 2558 if (!plane) { 2559 DRM_DEBUG_KMS("Unknown plane ID %d\n", 2560 plane_req->plane_id); 2561 return -ENOENT; 2562 } 2563 2564 if (plane_req->fb_id) { 2565 fb = drm_framebuffer_lookup(dev, plane_req->fb_id); 2566 if (!fb) { 2567 DRM_DEBUG_KMS("Unknown framebuffer ID %d\n", 2568 plane_req->fb_id); 2569 return -ENOENT; 2570 } 2571 2572 crtc = drm_crtc_find(dev, plane_req->crtc_id); 2573 if (!crtc) { 2574 DRM_DEBUG_KMS("Unknown crtc ID %d\n", 2575 plane_req->crtc_id); 2576 return -ENOENT; 2577 } 2578 } 2579 2580 /* 2581 * setplane_internal will take care of deref'ing either the old or new 2582 * framebuffer depending on success. 2583 */ 2584 return setplane_internal(plane, crtc, fb, 2585 plane_req->crtc_x, plane_req->crtc_y, 2586 plane_req->crtc_w, plane_req->crtc_h, 2587 plane_req->src_x, plane_req->src_y, 2588 plane_req->src_w, plane_req->src_h); 2589 } 2590 2591 /** 2592 * drm_mode_set_config_internal - helper to call ->set_config 2593 * @set: modeset config to set 2594 * 2595 * This is a little helper to wrap internal calls to the ->set_config driver 2596 * interface. The only thing it adds is correct refcounting dance. 2597 * 2598 * Returns: 2599 * Zero on success, negative errno on failure. 2600 */ 2601 int drm_mode_set_config_internal(struct drm_mode_set *set) 2602 { 2603 struct drm_crtc *crtc = set->crtc; 2604 struct drm_framebuffer *fb; 2605 struct drm_crtc *tmp; 2606 int ret; 2607 2608 /* 2609 * NOTE: ->set_config can also disable other crtcs (if we steal all 2610 * connectors from it), hence we need to refcount the fbs across all 2611 * crtcs. Atomic modeset will have saner semantics ... 2612 */ 2613 list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head) 2614 tmp->primary->old_fb = tmp->primary->fb; 2615 2616 fb = set->fb; 2617 2618 ret = crtc->funcs->set_config(set); 2619 if (ret == 0) { 2620 crtc->primary->crtc = crtc; 2621 crtc->primary->fb = fb; 2622 } 2623 2624 list_for_each_entry(tmp, &crtc->dev->mode_config.crtc_list, head) { 2625 if (tmp->primary->fb) 2626 drm_framebuffer_reference(tmp->primary->fb); 2627 if (tmp->primary->old_fb) 2628 drm_framebuffer_unreference(tmp->primary->old_fb); 2629 tmp->primary->old_fb = NULL; 2630 } 2631 2632 return ret; 2633 } 2634 EXPORT_SYMBOL(drm_mode_set_config_internal); 2635 2636 /** 2637 * drm_crtc_get_hv_timing - Fetches hdisplay/vdisplay for given mode 2638 * @mode: mode to query 2639 * @hdisplay: hdisplay value to fill in 2640 * @vdisplay: vdisplay value to fill in 2641 * 2642 * The vdisplay value will be doubled if the specified mode is a stereo mode of 2643 * the appropriate layout. 2644 */ 2645 void drm_crtc_get_hv_timing(const struct drm_display_mode *mode, 2646 int *hdisplay, int *vdisplay) 2647 { 2648 struct drm_display_mode adjusted; 2649 2650 drm_mode_copy(&adjusted, mode); 2651 drm_mode_set_crtcinfo(&adjusted, CRTC_STEREO_DOUBLE_ONLY); 2652 *hdisplay = adjusted.crtc_hdisplay; 2653 *vdisplay = adjusted.crtc_vdisplay; 2654 } 2655 EXPORT_SYMBOL(drm_crtc_get_hv_timing); 2656 2657 /** 2658 * drm_crtc_check_viewport - Checks that a framebuffer is big enough for the 2659 * CRTC viewport 2660 * @crtc: CRTC that framebuffer will be displayed on 2661 * @x: x panning 2662 * @y: y panning 2663 * @mode: mode that framebuffer will be displayed under 2664 * @fb: framebuffer to check size of 2665 */ 2666 int drm_crtc_check_viewport(const struct drm_crtc *crtc, 2667 int x, int y, 2668 const struct drm_display_mode *mode, 2669 const struct drm_framebuffer *fb) 2670 2671 { 2672 int hdisplay, vdisplay; 2673 2674 drm_crtc_get_hv_timing(mode, &hdisplay, &vdisplay); 2675 2676 if (crtc->invert_dimensions) 2677 swap(hdisplay, vdisplay); 2678 2679 if (hdisplay > fb->width || 2680 vdisplay > fb->height || 2681 x > fb->width - hdisplay || 2682 y > fb->height - vdisplay) { 2683 DRM_DEBUG_KMS("Invalid fb size %ux%u for CRTC viewport %ux%u+%d+%d%s.\n", 2684 fb->width, fb->height, hdisplay, vdisplay, x, y, 2685 crtc->invert_dimensions ? " (inverted)" : ""); 2686 return -ENOSPC; 2687 } 2688 2689 return 0; 2690 } 2691 EXPORT_SYMBOL(drm_crtc_check_viewport); 2692 2693 /** 2694 * drm_mode_setcrtc - set CRTC configuration 2695 * @dev: drm device for the ioctl 2696 * @data: data pointer for the ioctl 2697 * @file_priv: drm file for the ioctl call 2698 * 2699 * Build a new CRTC configuration based on user request. 2700 * 2701 * Called by the user via ioctl. 2702 * 2703 * Returns: 2704 * Zero on success, negative errno on failure. 2705 */ 2706 int drm_mode_setcrtc(struct drm_device *dev, void *data, 2707 struct drm_file *file_priv) 2708 { 2709 struct drm_mode_config *config = &dev->mode_config; 2710 struct drm_mode_crtc *crtc_req = data; 2711 struct drm_crtc *crtc; 2712 struct drm_connector **connector_set = NULL, *connector; 2713 struct drm_framebuffer *fb = NULL; 2714 struct drm_display_mode *mode = NULL; 2715 struct drm_mode_set set; 2716 uint32_t __user *set_connectors_ptr; 2717 int ret; 2718 int i; 2719 2720 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2721 return -EINVAL; 2722 2723 /* For some reason crtc x/y offsets are signed internally. */ 2724 if (crtc_req->x > INT_MAX || crtc_req->y > INT_MAX) 2725 return -ERANGE; 2726 2727 drm_modeset_lock_all(dev); 2728 crtc = drm_crtc_find(dev, crtc_req->crtc_id); 2729 if (!crtc) { 2730 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id); 2731 ret = -ENOENT; 2732 goto out; 2733 } 2734 DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id); 2735 2736 if (crtc_req->mode_valid) { 2737 /* If we have a mode we need a framebuffer. */ 2738 /* If we pass -1, set the mode with the currently bound fb */ 2739 if (crtc_req->fb_id == -1) { 2740 if (!crtc->primary->fb) { 2741 DRM_DEBUG_KMS("CRTC doesn't have current FB\n"); 2742 ret = -EINVAL; 2743 goto out; 2744 } 2745 fb = crtc->primary->fb; 2746 /* Make refcounting symmetric with the lookup path. */ 2747 drm_framebuffer_reference(fb); 2748 } else { 2749 fb = drm_framebuffer_lookup(dev, crtc_req->fb_id); 2750 if (!fb) { 2751 DRM_DEBUG_KMS("Unknown FB ID%d\n", 2752 crtc_req->fb_id); 2753 ret = -ENOENT; 2754 goto out; 2755 } 2756 } 2757 2758 mode = drm_mode_create(dev); 2759 if (!mode) { 2760 ret = -ENOMEM; 2761 goto out; 2762 } 2763 2764 ret = drm_crtc_convert_umode(mode, &crtc_req->mode); 2765 if (ret) { 2766 DRM_DEBUG_KMS("Invalid mode\n"); 2767 goto out; 2768 } 2769 2770 mode->status = drm_mode_validate_basic(mode); 2771 if (mode->status != MODE_OK) { 2772 ret = -EINVAL; 2773 goto out; 2774 } 2775 2776 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V); 2777 2778 ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y, 2779 mode, fb); 2780 if (ret) 2781 goto out; 2782 2783 } 2784 2785 if (crtc_req->count_connectors == 0 && mode) { 2786 DRM_DEBUG_KMS("Count connectors is 0 but mode set\n"); 2787 ret = -EINVAL; 2788 goto out; 2789 } 2790 2791 if (crtc_req->count_connectors > 0 && (!mode || !fb)) { 2792 DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n", 2793 crtc_req->count_connectors); 2794 ret = -EINVAL; 2795 goto out; 2796 } 2797 2798 if (crtc_req->count_connectors > 0) { 2799 u32 out_id; 2800 2801 /* Avoid unbounded kernel memory allocation */ 2802 if (crtc_req->count_connectors > config->num_connector) { 2803 ret = -EINVAL; 2804 goto out; 2805 } 2806 2807 connector_set = kmalloc_array(crtc_req->count_connectors, 2808 sizeof(struct drm_connector *), 2809 GFP_KERNEL); 2810 if (!connector_set) { 2811 ret = -ENOMEM; 2812 goto out; 2813 } 2814 2815 for (i = 0; i < crtc_req->count_connectors; i++) { 2816 set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr; 2817 if (get_user(out_id, &set_connectors_ptr[i])) { 2818 ret = -EFAULT; 2819 goto out; 2820 } 2821 2822 connector = drm_connector_find(dev, out_id); 2823 if (!connector) { 2824 DRM_DEBUG_KMS("Connector id %d unknown\n", 2825 out_id); 2826 ret = -ENOENT; 2827 goto out; 2828 } 2829 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", 2830 connector->base.id, 2831 connector->name); 2832 2833 connector_set[i] = connector; 2834 } 2835 } 2836 2837 set.crtc = crtc; 2838 set.x = crtc_req->x; 2839 set.y = crtc_req->y; 2840 set.mode = mode; 2841 set.connectors = connector_set; 2842 set.num_connectors = crtc_req->count_connectors; 2843 set.fb = fb; 2844 ret = drm_mode_set_config_internal(&set); 2845 2846 out: 2847 if (fb) 2848 drm_framebuffer_unreference(fb); 2849 2850 kfree(connector_set); 2851 drm_mode_destroy(dev, mode); 2852 drm_modeset_unlock_all(dev); 2853 return ret; 2854 } 2855 2856 /** 2857 * drm_mode_cursor_universal - translate legacy cursor ioctl call into a 2858 * universal plane handler call 2859 * @crtc: crtc to update cursor for 2860 * @req: data pointer for the ioctl 2861 * @file_priv: drm file for the ioctl call 2862 * 2863 * Legacy cursor ioctl's work directly with driver buffer handles. To 2864 * translate legacy ioctl calls into universal plane handler calls, we need to 2865 * wrap the native buffer handle in a drm_framebuffer. 2866 * 2867 * Note that we assume any handle passed to the legacy ioctls was a 32-bit ARGB 2868 * buffer with a pitch of 4*width; the universal plane interface should be used 2869 * directly in cases where the hardware can support other buffer settings and 2870 * userspace wants to make use of these capabilities. 2871 * 2872 * Returns: 2873 * Zero on success, negative errno on failure. 2874 */ 2875 static int drm_mode_cursor_universal(struct drm_crtc *crtc, 2876 struct drm_mode_cursor2 *req, 2877 struct drm_file *file_priv) 2878 { 2879 struct drm_device *dev = crtc->dev; 2880 struct drm_framebuffer *fb = NULL; 2881 struct drm_mode_fb_cmd2 fbreq = { 2882 .width = req->width, 2883 .height = req->height, 2884 .pixel_format = DRM_FORMAT_ARGB8888, 2885 .pitches = { req->width * 4 }, 2886 .handles = { req->handle }, 2887 }; 2888 int32_t crtc_x, crtc_y; 2889 uint32_t crtc_w = 0, crtc_h = 0; 2890 uint32_t src_w = 0, src_h = 0; 2891 int ret = 0; 2892 2893 BUG_ON(!crtc->cursor); 2894 WARN_ON(crtc->cursor->crtc != crtc && crtc->cursor->crtc != NULL); 2895 2896 /* 2897 * Obtain fb we'll be using (either new or existing) and take an extra 2898 * reference to it if fb != null. setplane will take care of dropping 2899 * the reference if the plane update fails. 2900 */ 2901 if (req->flags & DRM_MODE_CURSOR_BO) { 2902 if (req->handle) { 2903 fb = internal_framebuffer_create(dev, &fbreq, file_priv); 2904 if (IS_ERR(fb)) { 2905 DRM_DEBUG_KMS("failed to wrap cursor buffer in drm framebuffer\n"); 2906 return PTR_ERR(fb); 2907 } 2908 } else { 2909 fb = NULL; 2910 } 2911 } else { 2912 fb = crtc->cursor->fb; 2913 if (fb) 2914 drm_framebuffer_reference(fb); 2915 } 2916 2917 if (req->flags & DRM_MODE_CURSOR_MOVE) { 2918 crtc_x = req->x; 2919 crtc_y = req->y; 2920 } else { 2921 crtc_x = crtc->cursor_x; 2922 crtc_y = crtc->cursor_y; 2923 } 2924 2925 if (fb) { 2926 crtc_w = fb->width; 2927 crtc_h = fb->height; 2928 src_w = fb->width << 16; 2929 src_h = fb->height << 16; 2930 } 2931 2932 /* 2933 * setplane_internal will take care of deref'ing either the old or new 2934 * framebuffer depending on success. 2935 */ 2936 ret = __setplane_internal(crtc->cursor, crtc, fb, 2937 crtc_x, crtc_y, crtc_w, crtc_h, 2938 0, 0, src_w, src_h); 2939 2940 /* Update successful; save new cursor position, if necessary */ 2941 if (ret == 0 && req->flags & DRM_MODE_CURSOR_MOVE) { 2942 crtc->cursor_x = req->x; 2943 crtc->cursor_y = req->y; 2944 } 2945 2946 return ret; 2947 } 2948 2949 static int drm_mode_cursor_common(struct drm_device *dev, 2950 struct drm_mode_cursor2 *req, 2951 struct drm_file *file_priv) 2952 { 2953 struct drm_crtc *crtc; 2954 int ret = 0; 2955 2956 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2957 return -EINVAL; 2958 2959 if (!req->flags || (~DRM_MODE_CURSOR_FLAGS & req->flags)) 2960 return -EINVAL; 2961 2962 crtc = drm_crtc_find(dev, req->crtc_id); 2963 if (!crtc) { 2964 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id); 2965 return -ENOENT; 2966 } 2967 2968 /* 2969 * If this crtc has a universal cursor plane, call that plane's update 2970 * handler rather than using legacy cursor handlers. 2971 */ 2972 drm_modeset_lock_crtc(crtc, crtc->cursor); 2973 if (crtc->cursor) { 2974 ret = drm_mode_cursor_universal(crtc, req, file_priv); 2975 goto out; 2976 } 2977 2978 if (req->flags & DRM_MODE_CURSOR_BO) { 2979 if (!crtc->funcs->cursor_set && !crtc->funcs->cursor_set2) { 2980 ret = -ENXIO; 2981 goto out; 2982 } 2983 /* Turns off the cursor if handle is 0 */ 2984 if (crtc->funcs->cursor_set2) 2985 ret = crtc->funcs->cursor_set2(crtc, file_priv, req->handle, 2986 req->width, req->height, req->hot_x, req->hot_y); 2987 else 2988 ret = crtc->funcs->cursor_set(crtc, file_priv, req->handle, 2989 req->width, req->height); 2990 } 2991 2992 if (req->flags & DRM_MODE_CURSOR_MOVE) { 2993 if (crtc->funcs->cursor_move) { 2994 ret = crtc->funcs->cursor_move(crtc, req->x, req->y); 2995 } else { 2996 ret = -EFAULT; 2997 goto out; 2998 } 2999 } 3000 out: 3001 drm_modeset_unlock_crtc(crtc); 3002 3003 return ret; 3004 3005 } 3006 3007 3008 /** 3009 * drm_mode_cursor_ioctl - set CRTC's cursor configuration 3010 * @dev: drm device for the ioctl 3011 * @data: data pointer for the ioctl 3012 * @file_priv: drm file for the ioctl call 3013 * 3014 * Set the cursor configuration based on user request. 3015 * 3016 * Called by the user via ioctl. 3017 * 3018 * Returns: 3019 * Zero on success, negative errno on failure. 3020 */ 3021 int drm_mode_cursor_ioctl(struct drm_device *dev, 3022 void *data, struct drm_file *file_priv) 3023 { 3024 struct drm_mode_cursor *req = data; 3025 struct drm_mode_cursor2 new_req; 3026 3027 memcpy(&new_req, req, sizeof(struct drm_mode_cursor)); 3028 new_req.hot_x = new_req.hot_y = 0; 3029 3030 return drm_mode_cursor_common(dev, &new_req, file_priv); 3031 } 3032 3033 /** 3034 * drm_mode_cursor2_ioctl - set CRTC's cursor configuration 3035 * @dev: drm device for the ioctl 3036 * @data: data pointer for the ioctl 3037 * @file_priv: drm file for the ioctl call 3038 * 3039 * Set the cursor configuration based on user request. This implements the 2nd 3040 * version of the cursor ioctl, which allows userspace to additionally specify 3041 * the hotspot of the pointer. 3042 * 3043 * Called by the user via ioctl. 3044 * 3045 * Returns: 3046 * Zero on success, negative errno on failure. 3047 */ 3048 int drm_mode_cursor2_ioctl(struct drm_device *dev, 3049 void *data, struct drm_file *file_priv) 3050 { 3051 struct drm_mode_cursor2 *req = data; 3052 3053 return drm_mode_cursor_common(dev, req, file_priv); 3054 } 3055 3056 /** 3057 * drm_mode_legacy_fb_format - compute drm fourcc code from legacy description 3058 * @bpp: bits per pixels 3059 * @depth: bit depth per pixel 3060 * 3061 * Computes a drm fourcc pixel format code for the given @bpp/@depth values. 3062 * Useful in fbdev emulation code, since that deals in those values. 3063 */ 3064 uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth) 3065 { 3066 uint32_t fmt; 3067 3068 switch (bpp) { 3069 case 8: 3070 fmt = DRM_FORMAT_C8; 3071 break; 3072 case 16: 3073 if (depth == 15) 3074 fmt = DRM_FORMAT_XRGB1555; 3075 else 3076 fmt = DRM_FORMAT_RGB565; 3077 break; 3078 case 24: 3079 fmt = DRM_FORMAT_RGB888; 3080 break; 3081 case 32: 3082 if (depth == 24) 3083 fmt = DRM_FORMAT_XRGB8888; 3084 else if (depth == 30) 3085 fmt = DRM_FORMAT_XRGB2101010; 3086 else 3087 fmt = DRM_FORMAT_ARGB8888; 3088 break; 3089 default: 3090 DRM_ERROR("bad bpp, assuming x8r8g8b8 pixel format\n"); 3091 fmt = DRM_FORMAT_XRGB8888; 3092 break; 3093 } 3094 3095 return fmt; 3096 } 3097 EXPORT_SYMBOL(drm_mode_legacy_fb_format); 3098 3099 /** 3100 * drm_mode_addfb - add an FB to the graphics configuration 3101 * @dev: drm device for the ioctl 3102 * @data: data pointer for the ioctl 3103 * @file_priv: drm file for the ioctl call 3104 * 3105 * Add a new FB to the specified CRTC, given a user request. This is the 3106 * original addfb ioctl which only supported RGB formats. 3107 * 3108 * Called by the user via ioctl. 3109 * 3110 * Returns: 3111 * Zero on success, negative errno on failure. 3112 */ 3113 int drm_mode_addfb(struct drm_device *dev, 3114 void *data, struct drm_file *file_priv) 3115 { 3116 struct drm_mode_fb_cmd *or = data; 3117 struct drm_mode_fb_cmd2 r = {}; 3118 int ret; 3119 3120 /* convert to new format and call new ioctl */ 3121 r.fb_id = or->fb_id; 3122 r.width = or->width; 3123 r.height = or->height; 3124 r.pitches[0] = or->pitch; 3125 r.pixel_format = drm_mode_legacy_fb_format(or->bpp, or->depth); 3126 r.handles[0] = or->handle; 3127 3128 ret = drm_mode_addfb2(dev, &r, file_priv); 3129 if (ret) 3130 return ret; 3131 3132 or->fb_id = r.fb_id; 3133 3134 return 0; 3135 } 3136 3137 static int format_check(const struct drm_mode_fb_cmd2 *r) 3138 { 3139 uint32_t format = r->pixel_format & ~DRM_FORMAT_BIG_ENDIAN; 3140 3141 switch (format) { 3142 case DRM_FORMAT_C8: 3143 case DRM_FORMAT_RGB332: 3144 case DRM_FORMAT_BGR233: 3145 case DRM_FORMAT_XRGB4444: 3146 case DRM_FORMAT_XBGR4444: 3147 case DRM_FORMAT_RGBX4444: 3148 case DRM_FORMAT_BGRX4444: 3149 case DRM_FORMAT_ARGB4444: 3150 case DRM_FORMAT_ABGR4444: 3151 case DRM_FORMAT_RGBA4444: 3152 case DRM_FORMAT_BGRA4444: 3153 case DRM_FORMAT_XRGB1555: 3154 case DRM_FORMAT_XBGR1555: 3155 case DRM_FORMAT_RGBX5551: 3156 case DRM_FORMAT_BGRX5551: 3157 case DRM_FORMAT_ARGB1555: 3158 case DRM_FORMAT_ABGR1555: 3159 case DRM_FORMAT_RGBA5551: 3160 case DRM_FORMAT_BGRA5551: 3161 case DRM_FORMAT_RGB565: 3162 case DRM_FORMAT_BGR565: 3163 case DRM_FORMAT_RGB888: 3164 case DRM_FORMAT_BGR888: 3165 case DRM_FORMAT_XRGB8888: 3166 case DRM_FORMAT_XBGR8888: 3167 case DRM_FORMAT_RGBX8888: 3168 case DRM_FORMAT_BGRX8888: 3169 case DRM_FORMAT_ARGB8888: 3170 case DRM_FORMAT_ABGR8888: 3171 case DRM_FORMAT_RGBA8888: 3172 case DRM_FORMAT_BGRA8888: 3173 case DRM_FORMAT_XRGB2101010: 3174 case DRM_FORMAT_XBGR2101010: 3175 case DRM_FORMAT_RGBX1010102: 3176 case DRM_FORMAT_BGRX1010102: 3177 case DRM_FORMAT_ARGB2101010: 3178 case DRM_FORMAT_ABGR2101010: 3179 case DRM_FORMAT_RGBA1010102: 3180 case DRM_FORMAT_BGRA1010102: 3181 case DRM_FORMAT_YUYV: 3182 case DRM_FORMAT_YVYU: 3183 case DRM_FORMAT_UYVY: 3184 case DRM_FORMAT_VYUY: 3185 case DRM_FORMAT_AYUV: 3186 case DRM_FORMAT_NV12: 3187 case DRM_FORMAT_NV21: 3188 case DRM_FORMAT_NV16: 3189 case DRM_FORMAT_NV61: 3190 case DRM_FORMAT_NV24: 3191 case DRM_FORMAT_NV42: 3192 case DRM_FORMAT_YUV410: 3193 case DRM_FORMAT_YVU410: 3194 case DRM_FORMAT_YUV411: 3195 case DRM_FORMAT_YVU411: 3196 case DRM_FORMAT_YUV420: 3197 case DRM_FORMAT_YVU420: 3198 case DRM_FORMAT_YUV422: 3199 case DRM_FORMAT_YVU422: 3200 case DRM_FORMAT_YUV444: 3201 case DRM_FORMAT_YVU444: 3202 return 0; 3203 default: 3204 DRM_DEBUG_KMS("invalid pixel format %s\n", 3205 drm_get_format_name(r->pixel_format)); 3206 return -EINVAL; 3207 } 3208 } 3209 3210 static int framebuffer_check(const struct drm_mode_fb_cmd2 *r) 3211 { 3212 int ret, hsub, vsub, num_planes, i; 3213 3214 ret = format_check(r); 3215 if (ret) { 3216 DRM_DEBUG_KMS("bad framebuffer format %s\n", 3217 drm_get_format_name(r->pixel_format)); 3218 return ret; 3219 } 3220 3221 hsub = drm_format_horz_chroma_subsampling(r->pixel_format); 3222 vsub = drm_format_vert_chroma_subsampling(r->pixel_format); 3223 num_planes = drm_format_num_planes(r->pixel_format); 3224 3225 if (r->width == 0 || r->width % hsub) { 3226 DRM_DEBUG_KMS("bad framebuffer width %u\n", r->width); 3227 return -EINVAL; 3228 } 3229 3230 if (r->height == 0 || r->height % vsub) { 3231 DRM_DEBUG_KMS("bad framebuffer height %u\n", r->height); 3232 return -EINVAL; 3233 } 3234 3235 for (i = 0; i < num_planes; i++) { 3236 unsigned int width = r->width / (i != 0 ? hsub : 1); 3237 unsigned int height = r->height / (i != 0 ? vsub : 1); 3238 unsigned int cpp = drm_format_plane_cpp(r->pixel_format, i); 3239 3240 if (!r->handles[i]) { 3241 DRM_DEBUG_KMS("no buffer object handle for plane %d\n", i); 3242 return -EINVAL; 3243 } 3244 3245 if ((uint64_t) width * cpp > UINT_MAX) 3246 return -ERANGE; 3247 3248 if ((uint64_t) height * r->pitches[i] + r->offsets[i] > UINT_MAX) 3249 return -ERANGE; 3250 3251 if (r->pitches[i] < width * cpp) { 3252 DRM_DEBUG_KMS("bad pitch %u for plane %d\n", r->pitches[i], i); 3253 return -EINVAL; 3254 } 3255 } 3256 3257 return 0; 3258 } 3259 3260 static struct drm_framebuffer * 3261 internal_framebuffer_create(struct drm_device *dev, 3262 struct drm_mode_fb_cmd2 *r, 3263 struct drm_file *file_priv) 3264 { 3265 struct drm_mode_config *config = &dev->mode_config; 3266 struct drm_framebuffer *fb; 3267 int ret; 3268 3269 if (r->flags & ~DRM_MODE_FB_INTERLACED) { 3270 DRM_DEBUG_KMS("bad framebuffer flags 0x%08x\n", r->flags); 3271 return ERR_PTR(-EINVAL); 3272 } 3273 3274 if ((config->min_width > r->width) || (r->width > config->max_width)) { 3275 DRM_DEBUG_KMS("bad framebuffer width %d, should be >= %d && <= %d\n", 3276 r->width, config->min_width, config->max_width); 3277 return ERR_PTR(-EINVAL); 3278 } 3279 if ((config->min_height > r->height) || (r->height > config->max_height)) { 3280 DRM_DEBUG_KMS("bad framebuffer height %d, should be >= %d && <= %d\n", 3281 r->height, config->min_height, config->max_height); 3282 return ERR_PTR(-EINVAL); 3283 } 3284 3285 ret = framebuffer_check(r); 3286 if (ret) 3287 return ERR_PTR(ret); 3288 3289 fb = dev->mode_config.funcs->fb_create(dev, file_priv, r); 3290 if (IS_ERR(fb)) { 3291 DRM_DEBUG_KMS("could not create framebuffer\n"); 3292 return fb; 3293 } 3294 3295 return fb; 3296 } 3297 3298 /** 3299 * drm_mode_addfb2 - add an FB to the graphics configuration 3300 * @dev: drm device for the ioctl 3301 * @data: data pointer for the ioctl 3302 * @file_priv: drm file for the ioctl call 3303 * 3304 * Add a new FB to the specified CRTC, given a user request with format. This is 3305 * the 2nd version of the addfb ioctl, which supports multi-planar framebuffers 3306 * and uses fourcc codes as pixel format specifiers. 3307 * 3308 * Called by the user via ioctl. 3309 * 3310 * Returns: 3311 * Zero on success, negative errno on failure. 3312 */ 3313 int drm_mode_addfb2(struct drm_device *dev, 3314 void *data, struct drm_file *file_priv) 3315 { 3316 struct drm_mode_fb_cmd2 *r = data; 3317 struct drm_framebuffer *fb; 3318 3319 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 3320 return -EINVAL; 3321 3322 fb = internal_framebuffer_create(dev, r, file_priv); 3323 if (IS_ERR(fb)) 3324 return PTR_ERR(fb); 3325 3326 /* Transfer ownership to the filp for reaping on close */ 3327 3328 DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id); 3329 mutex_lock(&file_priv->fbs_lock); 3330 r->fb_id = fb->base.id; 3331 list_add(&fb->filp_head, &file_priv->fbs); 3332 mutex_unlock(&file_priv->fbs_lock); 3333 3334 return 0; 3335 } 3336 3337 /** 3338 * drm_mode_rmfb - remove an FB from the configuration 3339 * @dev: drm device for the ioctl 3340 * @data: data pointer for the ioctl 3341 * @file_priv: drm file for the ioctl call 3342 * 3343 * Remove the FB specified by the user. 3344 * 3345 * Called by the user via ioctl. 3346 * 3347 * Returns: 3348 * Zero on success, negative errno on failure. 3349 */ 3350 int drm_mode_rmfb(struct drm_device *dev, 3351 void *data, struct drm_file *file_priv) 3352 { 3353 struct drm_framebuffer *fb = NULL; 3354 struct drm_framebuffer *fbl = NULL; 3355 uint32_t *id = data; 3356 int found = 0; 3357 3358 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 3359 return -EINVAL; 3360 3361 mutex_lock(&file_priv->fbs_lock); 3362 mutex_lock(&dev->mode_config.fb_lock); 3363 fb = __drm_framebuffer_lookup(dev, *id); 3364 if (!fb) 3365 goto fail_lookup; 3366 3367 list_for_each_entry(fbl, &file_priv->fbs, filp_head) 3368 if (fb == fbl) 3369 found = 1; 3370 if (!found) 3371 goto fail_lookup; 3372 3373 /* Mark fb as reaped, we still have a ref from fpriv->fbs. */ 3374 __drm_framebuffer_unregister(dev, fb); 3375 3376 list_del_init(&fb->filp_head); 3377 mutex_unlock(&dev->mode_config.fb_lock); 3378 mutex_unlock(&file_priv->fbs_lock); 3379 3380 drm_framebuffer_remove(fb); 3381 3382 return 0; 3383 3384 fail_lookup: 3385 mutex_unlock(&dev->mode_config.fb_lock); 3386 mutex_unlock(&file_priv->fbs_lock); 3387 3388 return -ENOENT; 3389 } 3390 3391 /** 3392 * drm_mode_getfb - get FB info 3393 * @dev: drm device for the ioctl 3394 * @data: data pointer for the ioctl 3395 * @file_priv: drm file for the ioctl call 3396 * 3397 * Lookup the FB given its ID and return info about it. 3398 * 3399 * Called by the user via ioctl. 3400 * 3401 * Returns: 3402 * Zero on success, negative errno on failure. 3403 */ 3404 int drm_mode_getfb(struct drm_device *dev, 3405 void *data, struct drm_file *file_priv) 3406 { 3407 struct drm_mode_fb_cmd *r = data; 3408 struct drm_framebuffer *fb; 3409 int ret; 3410 3411 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 3412 return -EINVAL; 3413 3414 fb = drm_framebuffer_lookup(dev, r->fb_id); 3415 if (!fb) 3416 return -ENOENT; 3417 3418 r->height = fb->height; 3419 r->width = fb->width; 3420 r->depth = fb->depth; 3421 r->bpp = fb->bits_per_pixel; 3422 r->pitch = fb->pitches[0]; 3423 if (fb->funcs->create_handle) { 3424 if (file_priv->is_master || capable(CAP_SYS_ADMIN) || 3425 drm_is_control_client(file_priv)) { 3426 ret = fb->funcs->create_handle(fb, file_priv, 3427 &r->handle); 3428 } else { 3429 /* GET_FB() is an unprivileged ioctl so we must not 3430 * return a buffer-handle to non-master processes! For 3431 * backwards-compatibility reasons, we cannot make 3432 * GET_FB() privileged, so just return an invalid handle 3433 * for non-masters. */ 3434 r->handle = 0; 3435 ret = 0; 3436 } 3437 } else { 3438 ret = -ENODEV; 3439 } 3440 3441 drm_framebuffer_unreference(fb); 3442 3443 return ret; 3444 } 3445 3446 /** 3447 * drm_mode_dirtyfb_ioctl - flush frontbuffer rendering on an FB 3448 * @dev: drm device for the ioctl 3449 * @data: data pointer for the ioctl 3450 * @file_priv: drm file for the ioctl call 3451 * 3452 * Lookup the FB and flush out the damaged area supplied by userspace as a clip 3453 * rectangle list. Generic userspace which does frontbuffer rendering must call 3454 * this ioctl to flush out the changes on manual-update display outputs, e.g. 3455 * usb display-link, mipi manual update panels or edp panel self refresh modes. 3456 * 3457 * Modesetting drivers which always update the frontbuffer do not need to 3458 * implement the corresponding ->dirty framebuffer callback. 3459 * 3460 * Called by the user via ioctl. 3461 * 3462 * Returns: 3463 * Zero on success, negative errno on failure. 3464 */ 3465 int drm_mode_dirtyfb_ioctl(struct drm_device *dev, 3466 void *data, struct drm_file *file_priv) 3467 { 3468 struct drm_clip_rect __user *clips_ptr; 3469 struct drm_clip_rect *clips = NULL; 3470 struct drm_mode_fb_dirty_cmd *r = data; 3471 struct drm_framebuffer *fb; 3472 unsigned flags; 3473 int num_clips; 3474 int ret; 3475 3476 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 3477 return -EINVAL; 3478 3479 fb = drm_framebuffer_lookup(dev, r->fb_id); 3480 if (!fb) 3481 return -ENOENT; 3482 3483 num_clips = r->num_clips; 3484 clips_ptr = (struct drm_clip_rect __user *)(unsigned long)r->clips_ptr; 3485 3486 if (!num_clips != !clips_ptr) { 3487 ret = -EINVAL; 3488 goto out_err1; 3489 } 3490 3491 flags = DRM_MODE_FB_DIRTY_FLAGS & r->flags; 3492 3493 /* If userspace annotates copy, clips must come in pairs */ 3494 if (flags & DRM_MODE_FB_DIRTY_ANNOTATE_COPY && (num_clips % 2)) { 3495 ret = -EINVAL; 3496 goto out_err1; 3497 } 3498 3499 if (num_clips && clips_ptr) { 3500 if (num_clips < 0 || num_clips > DRM_MODE_FB_DIRTY_MAX_CLIPS) { 3501 ret = -EINVAL; 3502 goto out_err1; 3503 } 3504 clips = kcalloc(num_clips, sizeof(*clips), GFP_KERNEL); 3505 if (!clips) { 3506 ret = -ENOMEM; 3507 goto out_err1; 3508 } 3509 3510 ret = copy_from_user(clips, clips_ptr, 3511 num_clips * sizeof(*clips)); 3512 if (ret) { 3513 ret = -EFAULT; 3514 goto out_err2; 3515 } 3516 } 3517 3518 if (fb->funcs->dirty) { 3519 ret = fb->funcs->dirty(fb, file_priv, flags, r->color, 3520 clips, num_clips); 3521 } else { 3522 ret = -ENOSYS; 3523 } 3524 3525 out_err2: 3526 kfree(clips); 3527 out_err1: 3528 drm_framebuffer_unreference(fb); 3529 3530 return ret; 3531 } 3532 3533 3534 /** 3535 * drm_fb_release - remove and free the FBs on this file 3536 * @priv: drm file for the ioctl 3537 * 3538 * Destroy all the FBs associated with @filp. 3539 * 3540 * Called by the user via ioctl. 3541 * 3542 * Returns: 3543 * Zero on success, negative errno on failure. 3544 */ 3545 void drm_fb_release(struct drm_file *priv) 3546 { 3547 struct drm_device *dev = priv->minor->dev; 3548 struct drm_framebuffer *fb, *tfb; 3549 3550 /* 3551 * When the file gets released that means no one else can access the fb 3552 * list any more, so no need to grab fpriv->fbs_lock. And we need to 3553 * avoid upsetting lockdep since the universal cursor code adds a 3554 * framebuffer while holding mutex locks. 3555 * 3556 * Note that a real deadlock between fpriv->fbs_lock and the modeset 3557 * locks is impossible here since no one else but this function can get 3558 * at it any more. 3559 */ 3560 list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) { 3561 3562 mutex_lock(&dev->mode_config.fb_lock); 3563 /* Mark fb as reaped, we still have a ref from fpriv->fbs. */ 3564 __drm_framebuffer_unregister(dev, fb); 3565 mutex_unlock(&dev->mode_config.fb_lock); 3566 3567 list_del_init(&fb->filp_head); 3568 3569 /* This will also drop the fpriv->fbs reference. */ 3570 drm_framebuffer_remove(fb); 3571 } 3572 } 3573 3574 /** 3575 * drm_property_create - create a new property type 3576 * @dev: drm device 3577 * @flags: flags specifying the property type 3578 * @name: name of the property 3579 * @num_values: number of pre-defined values 3580 * 3581 * This creates a new generic drm property which can then be attached to a drm 3582 * object with drm_object_attach_property. The returned property object must be 3583 * freed with drm_property_destroy. 3584 * 3585 * Note that the DRM core keeps a per-device list of properties and that, if 3586 * drm_mode_config_cleanup() is called, it will destroy all properties created 3587 * by the driver. 3588 * 3589 * Returns: 3590 * A pointer to the newly created property on success, NULL on failure. 3591 */ 3592 struct drm_property *drm_property_create(struct drm_device *dev, int flags, 3593 const char *name, int num_values) 3594 { 3595 struct drm_property *property = NULL; 3596 int ret; 3597 3598 property = kzalloc(sizeof(struct drm_property), GFP_KERNEL); 3599 if (!property) 3600 return NULL; 3601 3602 property->dev = dev; 3603 3604 if (num_values) { 3605 property->values = kcalloc(num_values, sizeof(uint64_t), 3606 GFP_KERNEL); 3607 if (!property->values) 3608 goto fail; 3609 } 3610 3611 ret = drm_mode_object_get(dev, &property->base, DRM_MODE_OBJECT_PROPERTY); 3612 if (ret) 3613 goto fail; 3614 3615 property->flags = flags; 3616 property->num_values = num_values; 3617 INIT_LIST_HEAD(&property->enum_list); 3618 3619 if (name) { 3620 strncpy(property->name, name, DRM_PROP_NAME_LEN); 3621 property->name[DRM_PROP_NAME_LEN-1] = '\0'; 3622 } 3623 3624 list_add_tail(&property->head, &dev->mode_config.property_list); 3625 3626 WARN_ON(!drm_property_type_valid(property)); 3627 3628 return property; 3629 fail: 3630 kfree(property->values); 3631 kfree(property); 3632 return NULL; 3633 } 3634 EXPORT_SYMBOL(drm_property_create); 3635 3636 /** 3637 * drm_property_create_enum - create a new enumeration property type 3638 * @dev: drm device 3639 * @flags: flags specifying the property type 3640 * @name: name of the property 3641 * @props: enumeration lists with property values 3642 * @num_values: number of pre-defined values 3643 * 3644 * This creates a new generic drm property which can then be attached to a drm 3645 * object with drm_object_attach_property. The returned property object must be 3646 * freed with drm_property_destroy. 3647 * 3648 * Userspace is only allowed to set one of the predefined values for enumeration 3649 * properties. 3650 * 3651 * Returns: 3652 * A pointer to the newly created property on success, NULL on failure. 3653 */ 3654 struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags, 3655 const char *name, 3656 const struct drm_prop_enum_list *props, 3657 int num_values) 3658 { 3659 struct drm_property *property; 3660 int i, ret; 3661 3662 flags |= DRM_MODE_PROP_ENUM; 3663 3664 property = drm_property_create(dev, flags, name, num_values); 3665 if (!property) 3666 return NULL; 3667 3668 for (i = 0; i < num_values; i++) { 3669 ret = drm_property_add_enum(property, i, 3670 props[i].type, 3671 props[i].name); 3672 if (ret) { 3673 drm_property_destroy(dev, property); 3674 return NULL; 3675 } 3676 } 3677 3678 return property; 3679 } 3680 EXPORT_SYMBOL(drm_property_create_enum); 3681 3682 /** 3683 * drm_property_create_bitmask - create a new bitmask property type 3684 * @dev: drm device 3685 * @flags: flags specifying the property type 3686 * @name: name of the property 3687 * @props: enumeration lists with property bitflags 3688 * @num_props: size of the @props array 3689 * @supported_bits: bitmask of all supported enumeration values 3690 * 3691 * This creates a new bitmask drm property which can then be attached to a drm 3692 * object with drm_object_attach_property. The returned property object must be 3693 * freed with drm_property_destroy. 3694 * 3695 * Compared to plain enumeration properties userspace is allowed to set any 3696 * or'ed together combination of the predefined property bitflag values 3697 * 3698 * Returns: 3699 * A pointer to the newly created property on success, NULL on failure. 3700 */ 3701 struct drm_property *drm_property_create_bitmask(struct drm_device *dev, 3702 int flags, const char *name, 3703 const struct drm_prop_enum_list *props, 3704 int num_props, 3705 uint64_t supported_bits) 3706 { 3707 struct drm_property *property; 3708 int i, ret, index = 0; 3709 int num_values = hweight64(supported_bits); 3710 3711 flags |= DRM_MODE_PROP_BITMASK; 3712 3713 property = drm_property_create(dev, flags, name, num_values); 3714 if (!property) 3715 return NULL; 3716 for (i = 0; i < num_props; i++) { 3717 if (!(supported_bits & (1ULL << props[i].type))) 3718 continue; 3719 3720 if (WARN_ON(index >= num_values)) { 3721 drm_property_destroy(dev, property); 3722 return NULL; 3723 } 3724 3725 ret = drm_property_add_enum(property, index++, 3726 props[i].type, 3727 props[i].name); 3728 if (ret) { 3729 drm_property_destroy(dev, property); 3730 return NULL; 3731 } 3732 } 3733 3734 return property; 3735 } 3736 EXPORT_SYMBOL(drm_property_create_bitmask); 3737 3738 static struct drm_property *property_create_range(struct drm_device *dev, 3739 int flags, const char *name, 3740 uint64_t min, uint64_t max) 3741 { 3742 struct drm_property *property; 3743 3744 property = drm_property_create(dev, flags, name, 2); 3745 if (!property) 3746 return NULL; 3747 3748 property->values[0] = min; 3749 property->values[1] = max; 3750 3751 return property; 3752 } 3753 3754 /** 3755 * drm_property_create_range - create a new unsigned ranged property type 3756 * @dev: drm device 3757 * @flags: flags specifying the property type 3758 * @name: name of the property 3759 * @min: minimum value of the property 3760 * @max: maximum value of the property 3761 * 3762 * This creates a new generic drm property which can then be attached to a drm 3763 * object with drm_object_attach_property. The returned property object must be 3764 * freed with drm_property_destroy. 3765 * 3766 * Userspace is allowed to set any unsigned integer value in the (min, max) 3767 * range inclusive. 3768 * 3769 * Returns: 3770 * A pointer to the newly created property on success, NULL on failure. 3771 */ 3772 struct drm_property *drm_property_create_range(struct drm_device *dev, int flags, 3773 const char *name, 3774 uint64_t min, uint64_t max) 3775 { 3776 return property_create_range(dev, DRM_MODE_PROP_RANGE | flags, 3777 name, min, max); 3778 } 3779 EXPORT_SYMBOL(drm_property_create_range); 3780 3781 /** 3782 * drm_property_create_signed_range - create a new signed ranged property type 3783 * @dev: drm device 3784 * @flags: flags specifying the property type 3785 * @name: name of the property 3786 * @min: minimum value of the property 3787 * @max: maximum value of the property 3788 * 3789 * This creates a new generic drm property which can then be attached to a drm 3790 * object with drm_object_attach_property. The returned property object must be 3791 * freed with drm_property_destroy. 3792 * 3793 * Userspace is allowed to set any signed integer value in the (min, max) 3794 * range inclusive. 3795 * 3796 * Returns: 3797 * A pointer to the newly created property on success, NULL on failure. 3798 */ 3799 struct drm_property *drm_property_create_signed_range(struct drm_device *dev, 3800 int flags, const char *name, 3801 int64_t min, int64_t max) 3802 { 3803 return property_create_range(dev, DRM_MODE_PROP_SIGNED_RANGE | flags, 3804 name, I642U64(min), I642U64(max)); 3805 } 3806 EXPORT_SYMBOL(drm_property_create_signed_range); 3807 3808 /** 3809 * drm_property_create_object - create a new object property type 3810 * @dev: drm device 3811 * @flags: flags specifying the property type 3812 * @name: name of the property 3813 * @type: object type from DRM_MODE_OBJECT_* defines 3814 * 3815 * This creates a new generic drm property which can then be attached to a drm 3816 * object with drm_object_attach_property. The returned property object must be 3817 * freed with drm_property_destroy. 3818 * 3819 * Userspace is only allowed to set this to any property value of the given 3820 * @type. Only useful for atomic properties, which is enforced. 3821 * 3822 * Returns: 3823 * A pointer to the newly created property on success, NULL on failure. 3824 */ 3825 struct drm_property *drm_property_create_object(struct drm_device *dev, 3826 int flags, const char *name, uint32_t type) 3827 { 3828 struct drm_property *property; 3829 3830 flags |= DRM_MODE_PROP_OBJECT; 3831 3832 if (WARN_ON(!(flags & DRM_MODE_PROP_ATOMIC))) 3833 return NULL; 3834 3835 property = drm_property_create(dev, flags, name, 1); 3836 if (!property) 3837 return NULL; 3838 3839 property->values[0] = type; 3840 3841 return property; 3842 } 3843 EXPORT_SYMBOL(drm_property_create_object); 3844 3845 /** 3846 * drm_property_create_bool - create a new boolean property type 3847 * @dev: drm device 3848 * @flags: flags specifying the property type 3849 * @name: name of the property 3850 * 3851 * This creates a new generic drm property which can then be attached to a drm 3852 * object with drm_object_attach_property. The returned property object must be 3853 * freed with drm_property_destroy. 3854 * 3855 * This is implemented as a ranged property with only {0, 1} as valid values. 3856 * 3857 * Returns: 3858 * A pointer to the newly created property on success, NULL on failure. 3859 */ 3860 struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags, 3861 const char *name) 3862 { 3863 return drm_property_create_range(dev, flags, name, 0, 1); 3864 } 3865 EXPORT_SYMBOL(drm_property_create_bool); 3866 3867 /** 3868 * drm_property_add_enum - add a possible value to an enumeration property 3869 * @property: enumeration property to change 3870 * @index: index of the new enumeration 3871 * @value: value of the new enumeration 3872 * @name: symbolic name of the new enumeration 3873 * 3874 * This functions adds enumerations to a property. 3875 * 3876 * It's use is deprecated, drivers should use one of the more specific helpers 3877 * to directly create the property with all enumerations already attached. 3878 * 3879 * Returns: 3880 * Zero on success, error code on failure. 3881 */ 3882 int drm_property_add_enum(struct drm_property *property, int index, 3883 uint64_t value, const char *name) 3884 { 3885 struct drm_property_enum *prop_enum; 3886 3887 if (!(drm_property_type_is(property, DRM_MODE_PROP_ENUM) || 3888 drm_property_type_is(property, DRM_MODE_PROP_BITMASK))) 3889 return -EINVAL; 3890 3891 /* 3892 * Bitmask enum properties have the additional constraint of values 3893 * from 0 to 63 3894 */ 3895 if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK) && 3896 (value > 63)) 3897 return -EINVAL; 3898 3899 if (!list_empty(&property->enum_list)) { 3900 list_for_each_entry(prop_enum, &property->enum_list, head) { 3901 if (prop_enum->value == value) { 3902 strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN); 3903 prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0'; 3904 return 0; 3905 } 3906 } 3907 } 3908 3909 prop_enum = kzalloc(sizeof(struct drm_property_enum), GFP_KERNEL); 3910 if (!prop_enum) 3911 return -ENOMEM; 3912 3913 strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN); 3914 prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0'; 3915 prop_enum->value = value; 3916 3917 property->values[index] = value; 3918 list_add_tail(&prop_enum->head, &property->enum_list); 3919 return 0; 3920 } 3921 EXPORT_SYMBOL(drm_property_add_enum); 3922 3923 /** 3924 * drm_property_destroy - destroy a drm property 3925 * @dev: drm device 3926 * @property: property to destry 3927 * 3928 * This function frees a property including any attached resources like 3929 * enumeration values. 3930 */ 3931 void drm_property_destroy(struct drm_device *dev, struct drm_property *property) 3932 { 3933 struct drm_property_enum *prop_enum, *pt; 3934 3935 list_for_each_entry_safe(prop_enum, pt, &property->enum_list, head) { 3936 list_del(&prop_enum->head); 3937 kfree(prop_enum); 3938 } 3939 3940 if (property->num_values) 3941 kfree(property->values); 3942 drm_mode_object_put(dev, &property->base); 3943 list_del(&property->head); 3944 kfree(property); 3945 } 3946 EXPORT_SYMBOL(drm_property_destroy); 3947 3948 /** 3949 * drm_object_attach_property - attach a property to a modeset object 3950 * @obj: drm modeset object 3951 * @property: property to attach 3952 * @init_val: initial value of the property 3953 * 3954 * This attaches the given property to the modeset object with the given initial 3955 * value. Currently this function cannot fail since the properties are stored in 3956 * a statically sized array. 3957 */ 3958 void drm_object_attach_property(struct drm_mode_object *obj, 3959 struct drm_property *property, 3960 uint64_t init_val) 3961 { 3962 int count = obj->properties->count; 3963 3964 if (count == DRM_OBJECT_MAX_PROPERTY) { 3965 WARN(1, "Failed to attach object property (type: 0x%x). Please " 3966 "increase DRM_OBJECT_MAX_PROPERTY by 1 for each time " 3967 "you see this message on the same object type.\n", 3968 obj->type); 3969 return; 3970 } 3971 3972 obj->properties->properties[count] = property; 3973 obj->properties->values[count] = init_val; 3974 obj->properties->count++; 3975 if (property->flags & DRM_MODE_PROP_ATOMIC) 3976 obj->properties->atomic_count++; 3977 } 3978 EXPORT_SYMBOL(drm_object_attach_property); 3979 3980 /** 3981 * drm_object_property_set_value - set the value of a property 3982 * @obj: drm mode object to set property value for 3983 * @property: property to set 3984 * @val: value the property should be set to 3985 * 3986 * This functions sets a given property on a given object. This function only 3987 * changes the software state of the property, it does not call into the 3988 * driver's ->set_property callback. 3989 * 3990 * Returns: 3991 * Zero on success, error code on failure. 3992 */ 3993 int drm_object_property_set_value(struct drm_mode_object *obj, 3994 struct drm_property *property, uint64_t val) 3995 { 3996 int i; 3997 3998 for (i = 0; i < obj->properties->count; i++) { 3999 if (obj->properties->properties[i] == property) { 4000 obj->properties->values[i] = val; 4001 return 0; 4002 } 4003 } 4004 4005 return -EINVAL; 4006 } 4007 EXPORT_SYMBOL(drm_object_property_set_value); 4008 4009 /** 4010 * drm_object_property_get_value - retrieve the value of a property 4011 * @obj: drm mode object to get property value from 4012 * @property: property to retrieve 4013 * @val: storage for the property value 4014 * 4015 * This function retrieves the softare state of the given property for the given 4016 * property. Since there is no driver callback to retrieve the current property 4017 * value this might be out of sync with the hardware, depending upon the driver 4018 * and property. 4019 * 4020 * Returns: 4021 * Zero on success, error code on failure. 4022 */ 4023 int drm_object_property_get_value(struct drm_mode_object *obj, 4024 struct drm_property *property, uint64_t *val) 4025 { 4026 int i; 4027 4028 /* read-only properties bypass atomic mechanism and still store 4029 * their value in obj->properties->values[].. mostly to avoid 4030 * having to deal w/ EDID and similar props in atomic paths: 4031 */ 4032 if (drm_core_check_feature(property->dev, DRIVER_ATOMIC) && 4033 !(property->flags & DRM_MODE_PROP_IMMUTABLE)) 4034 return drm_atomic_get_property(obj, property, val); 4035 4036 for (i = 0; i < obj->properties->count; i++) { 4037 if (obj->properties->properties[i] == property) { 4038 *val = obj->properties->values[i]; 4039 return 0; 4040 } 4041 } 4042 4043 return -EINVAL; 4044 } 4045 EXPORT_SYMBOL(drm_object_property_get_value); 4046 4047 /** 4048 * drm_mode_getproperty_ioctl - get the property metadata 4049 * @dev: DRM device 4050 * @data: ioctl data 4051 * @file_priv: DRM file info 4052 * 4053 * This function retrieves the metadata for a given property, like the different 4054 * possible values for an enum property or the limits for a range property. 4055 * 4056 * Blob properties are special 4057 * 4058 * Called by the user via ioctl. 4059 * 4060 * Returns: 4061 * Zero on success, negative errno on failure. 4062 */ 4063 int drm_mode_getproperty_ioctl(struct drm_device *dev, 4064 void *data, struct drm_file *file_priv) 4065 { 4066 struct drm_mode_get_property *out_resp = data; 4067 struct drm_property *property; 4068 int enum_count = 0; 4069 int value_count = 0; 4070 int ret = 0, i; 4071 int copied; 4072 struct drm_property_enum *prop_enum; 4073 struct drm_mode_property_enum __user *enum_ptr; 4074 uint64_t __user *values_ptr; 4075 4076 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 4077 return -EINVAL; 4078 4079 drm_modeset_lock_all(dev); 4080 property = drm_property_find(dev, out_resp->prop_id); 4081 if (!property) { 4082 ret = -ENOENT; 4083 goto done; 4084 } 4085 4086 if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) || 4087 drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) { 4088 list_for_each_entry(prop_enum, &property->enum_list, head) 4089 enum_count++; 4090 } 4091 4092 value_count = property->num_values; 4093 4094 strncpy(out_resp->name, property->name, DRM_PROP_NAME_LEN); 4095 out_resp->name[DRM_PROP_NAME_LEN-1] = 0; 4096 out_resp->flags = property->flags; 4097 4098 if ((out_resp->count_values >= value_count) && value_count) { 4099 values_ptr = (uint64_t __user *)(unsigned long)out_resp->values_ptr; 4100 for (i = 0; i < value_count; i++) { 4101 if (copy_to_user(values_ptr + i, &property->values[i], sizeof(uint64_t))) { 4102 ret = -EFAULT; 4103 goto done; 4104 } 4105 } 4106 } 4107 out_resp->count_values = value_count; 4108 4109 if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) || 4110 drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) { 4111 if ((out_resp->count_enum_blobs >= enum_count) && enum_count) { 4112 copied = 0; 4113 enum_ptr = (struct drm_mode_property_enum __user *)(unsigned long)out_resp->enum_blob_ptr; 4114 list_for_each_entry(prop_enum, &property->enum_list, head) { 4115 4116 if (copy_to_user(&enum_ptr[copied].value, &prop_enum->value, sizeof(uint64_t))) { 4117 ret = -EFAULT; 4118 goto done; 4119 } 4120 4121 if (copy_to_user(&enum_ptr[copied].name, 4122 &prop_enum->name, DRM_PROP_NAME_LEN)) { 4123 ret = -EFAULT; 4124 goto done; 4125 } 4126 copied++; 4127 } 4128 } 4129 out_resp->count_enum_blobs = enum_count; 4130 } 4131 4132 /* 4133 * NOTE: The idea seems to have been to use this to read all the blob 4134 * property values. But nothing ever added them to the corresponding 4135 * list, userspace always used the special-purpose get_blob ioctl to 4136 * read the value for a blob property. It also doesn't make a lot of 4137 * sense to return values here when everything else is just metadata for 4138 * the property itself. 4139 */ 4140 if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) 4141 out_resp->count_enum_blobs = 0; 4142 done: 4143 drm_modeset_unlock_all(dev); 4144 return ret; 4145 } 4146 4147 static struct drm_property_blob * 4148 drm_property_create_blob(struct drm_device *dev, size_t length, 4149 const void *data) 4150 { 4151 struct drm_property_blob *blob; 4152 int ret; 4153 4154 if (!length || !data) 4155 return NULL; 4156 4157 blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL); 4158 if (!blob) 4159 return NULL; 4160 4161 ret = drm_mode_object_get(dev, &blob->base, DRM_MODE_OBJECT_BLOB); 4162 if (ret) { 4163 kfree(blob); 4164 return NULL; 4165 } 4166 4167 blob->length = length; 4168 4169 memcpy(blob->data, data, length); 4170 4171 list_add_tail(&blob->head, &dev->mode_config.property_blob_list); 4172 return blob; 4173 } 4174 4175 static void drm_property_destroy_blob(struct drm_device *dev, 4176 struct drm_property_blob *blob) 4177 { 4178 drm_mode_object_put(dev, &blob->base); 4179 list_del(&blob->head); 4180 kfree(blob); 4181 } 4182 4183 /** 4184 * drm_mode_getblob_ioctl - get the contents of a blob property value 4185 * @dev: DRM device 4186 * @data: ioctl data 4187 * @file_priv: DRM file info 4188 * 4189 * This function retrieves the contents of a blob property. The value stored in 4190 * an object's blob property is just a normal modeset object id. 4191 * 4192 * Called by the user via ioctl. 4193 * 4194 * Returns: 4195 * Zero on success, negative errno on failure. 4196 */ 4197 int drm_mode_getblob_ioctl(struct drm_device *dev, 4198 void *data, struct drm_file *file_priv) 4199 { 4200 struct drm_mode_get_blob *out_resp = data; 4201 struct drm_property_blob *blob; 4202 int ret = 0; 4203 void __user *blob_ptr; 4204 4205 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 4206 return -EINVAL; 4207 4208 drm_modeset_lock_all(dev); 4209 blob = drm_property_blob_find(dev, out_resp->blob_id); 4210 if (!blob) { 4211 ret = -ENOENT; 4212 goto done; 4213 } 4214 4215 if (out_resp->length == blob->length) { 4216 blob_ptr = (void __user *)(unsigned long)out_resp->data; 4217 if (copy_to_user(blob_ptr, blob->data, blob->length)) { 4218 ret = -EFAULT; 4219 goto done; 4220 } 4221 } 4222 out_resp->length = blob->length; 4223 4224 done: 4225 drm_modeset_unlock_all(dev); 4226 return ret; 4227 } 4228 4229 /** 4230 * drm_mode_connector_set_path_property - set tile property on connector 4231 * @connector: connector to set property on. 4232 * @path: path to use for property. 4233 * 4234 * This creates a property to expose to userspace to specify a 4235 * connector path. This is mainly used for DisplayPort MST where 4236 * connectors have a topology and we want to allow userspace to give 4237 * them more meaningful names. 4238 * 4239 * Returns: 4240 * Zero on success, negative errno on failure. 4241 */ 4242 int drm_mode_connector_set_path_property(struct drm_connector *connector, 4243 const char *path) 4244 { 4245 struct drm_device *dev = connector->dev; 4246 size_t size = strlen(path) + 1; 4247 int ret; 4248 4249 connector->path_blob_ptr = drm_property_create_blob(connector->dev, 4250 size, path); 4251 if (!connector->path_blob_ptr) 4252 return -EINVAL; 4253 4254 ret = drm_object_property_set_value(&connector->base, 4255 dev->mode_config.path_property, 4256 connector->path_blob_ptr->base.id); 4257 return ret; 4258 } 4259 EXPORT_SYMBOL(drm_mode_connector_set_path_property); 4260 4261 /** 4262 * drm_mode_connector_set_tile_property - set tile property on connector 4263 * @connector: connector to set property on. 4264 * 4265 * This looks up the tile information for a connector, and creates a 4266 * property for userspace to parse if it exists. The property is of 4267 * the form of 8 integers using ':' as a separator. 4268 * 4269 * Returns: 4270 * Zero on success, errno on failure. 4271 */ 4272 int drm_mode_connector_set_tile_property(struct drm_connector *connector) 4273 { 4274 struct drm_device *dev = connector->dev; 4275 int ret, size; 4276 char tile[256]; 4277 4278 if (connector->tile_blob_ptr) 4279 drm_property_destroy_blob(dev, connector->tile_blob_ptr); 4280 4281 if (!connector->has_tile) { 4282 connector->tile_blob_ptr = NULL; 4283 ret = drm_object_property_set_value(&connector->base, 4284 dev->mode_config.tile_property, 0); 4285 return ret; 4286 } 4287 4288 snprintf(tile, 256, "%d:%d:%d:%d:%d:%d:%d:%d", 4289 connector->tile_group->id, connector->tile_is_single_monitor, 4290 connector->num_h_tile, connector->num_v_tile, 4291 connector->tile_h_loc, connector->tile_v_loc, 4292 connector->tile_h_size, connector->tile_v_size); 4293 size = strlen(tile) + 1; 4294 4295 connector->tile_blob_ptr = drm_property_create_blob(connector->dev, 4296 size, tile); 4297 if (!connector->tile_blob_ptr) 4298 return -EINVAL; 4299 4300 ret = drm_object_property_set_value(&connector->base, 4301 dev->mode_config.tile_property, 4302 connector->tile_blob_ptr->base.id); 4303 return ret; 4304 } 4305 EXPORT_SYMBOL(drm_mode_connector_set_tile_property); 4306 4307 /** 4308 * drm_mode_connector_update_edid_property - update the edid property of a connector 4309 * @connector: drm connector 4310 * @edid: new value of the edid property 4311 * 4312 * This function creates a new blob modeset object and assigns its id to the 4313 * connector's edid property. 4314 * 4315 * Returns: 4316 * Zero on success, negative errno on failure. 4317 */ 4318 int drm_mode_connector_update_edid_property(struct drm_connector *connector, 4319 const struct edid *edid) 4320 { 4321 struct drm_device *dev = connector->dev; 4322 size_t size; 4323 int ret; 4324 4325 /* ignore requests to set edid when overridden */ 4326 if (connector->override_edid) 4327 return 0; 4328 4329 if (connector->edid_blob_ptr) 4330 drm_property_destroy_blob(dev, connector->edid_blob_ptr); 4331 4332 /* Delete edid, when there is none. */ 4333 if (!edid) { 4334 connector->edid_blob_ptr = NULL; 4335 ret = drm_object_property_set_value(&connector->base, dev->mode_config.edid_property, 0); 4336 return ret; 4337 } 4338 4339 size = EDID_LENGTH * (1 + edid->extensions); 4340 connector->edid_blob_ptr = drm_property_create_blob(connector->dev, 4341 size, edid); 4342 if (!connector->edid_blob_ptr) 4343 return -EINVAL; 4344 4345 ret = drm_object_property_set_value(&connector->base, 4346 dev->mode_config.edid_property, 4347 connector->edid_blob_ptr->base.id); 4348 4349 return ret; 4350 } 4351 EXPORT_SYMBOL(drm_mode_connector_update_edid_property); 4352 4353 /* Some properties could refer to dynamic refcnt'd objects, or things that 4354 * need special locking to handle lifetime issues (ie. to ensure the prop 4355 * value doesn't become invalid part way through the property update due to 4356 * race). The value returned by reference via 'obj' should be passed back 4357 * to drm_property_change_valid_put() after the property is set (and the 4358 * object to which the property is attached has a chance to take it's own 4359 * reference). 4360 */ 4361 bool drm_property_change_valid_get(struct drm_property *property, 4362 uint64_t value, struct drm_mode_object **ref) 4363 { 4364 int i; 4365 4366 if (property->flags & DRM_MODE_PROP_IMMUTABLE) 4367 return false; 4368 4369 *ref = NULL; 4370 4371 if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) { 4372 if (value < property->values[0] || value > property->values[1]) 4373 return false; 4374 return true; 4375 } else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) { 4376 int64_t svalue = U642I64(value); 4377 4378 if (svalue < U642I64(property->values[0]) || 4379 svalue > U642I64(property->values[1])) 4380 return false; 4381 return true; 4382 } else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) { 4383 uint64_t valid_mask = 0; 4384 4385 for (i = 0; i < property->num_values; i++) 4386 valid_mask |= (1ULL << property->values[i]); 4387 return !(value & ~valid_mask); 4388 } else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) { 4389 /* Only the driver knows */ 4390 return true; 4391 } else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) { 4392 /* a zero value for an object property translates to null: */ 4393 if (value == 0) 4394 return true; 4395 4396 /* handle refcnt'd objects specially: */ 4397 if (property->values[0] == DRM_MODE_OBJECT_FB) { 4398 struct drm_framebuffer *fb; 4399 fb = drm_framebuffer_lookup(property->dev, value); 4400 if (fb) { 4401 *ref = &fb->base; 4402 return true; 4403 } else { 4404 return false; 4405 } 4406 } else { 4407 return _object_find(property->dev, value, property->values[0]) != NULL; 4408 } 4409 } 4410 4411 for (i = 0; i < property->num_values; i++) 4412 if (property->values[i] == value) 4413 return true; 4414 return false; 4415 } 4416 4417 void drm_property_change_valid_put(struct drm_property *property, 4418 struct drm_mode_object *ref) 4419 { 4420 if (!ref) 4421 return; 4422 4423 if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) { 4424 if (property->values[0] == DRM_MODE_OBJECT_FB) 4425 drm_framebuffer_unreference(obj_to_fb(ref)); 4426 } 4427 } 4428 4429 /** 4430 * drm_mode_connector_property_set_ioctl - set the current value of a connector property 4431 * @dev: DRM device 4432 * @data: ioctl data 4433 * @file_priv: DRM file info 4434 * 4435 * This function sets the current value for a connectors's property. It also 4436 * calls into a driver's ->set_property callback to update the hardware state 4437 * 4438 * Called by the user via ioctl. 4439 * 4440 * Returns: 4441 * Zero on success, negative errno on failure. 4442 */ 4443 int drm_mode_connector_property_set_ioctl(struct drm_device *dev, 4444 void *data, struct drm_file *file_priv) 4445 { 4446 struct drm_mode_connector_set_property *conn_set_prop = data; 4447 struct drm_mode_obj_set_property obj_set_prop = { 4448 .value = conn_set_prop->value, 4449 .prop_id = conn_set_prop->prop_id, 4450 .obj_id = conn_set_prop->connector_id, 4451 .obj_type = DRM_MODE_OBJECT_CONNECTOR 4452 }; 4453 4454 /* It does all the locking and checking we need */ 4455 return drm_mode_obj_set_property_ioctl(dev, &obj_set_prop, file_priv); 4456 } 4457 4458 static int drm_mode_connector_set_obj_prop(struct drm_mode_object *obj, 4459 struct drm_property *property, 4460 uint64_t value) 4461 { 4462 int ret = -EINVAL; 4463 struct drm_connector *connector = obj_to_connector(obj); 4464 4465 /* Do DPMS ourselves */ 4466 if (property == connector->dev->mode_config.dpms_property) { 4467 if (connector->funcs->dpms) 4468 (*connector->funcs->dpms)(connector, (int)value); 4469 ret = 0; 4470 } else if (connector->funcs->set_property) 4471 ret = connector->funcs->set_property(connector, property, value); 4472 4473 /* store the property value if successful */ 4474 if (!ret) 4475 drm_object_property_set_value(&connector->base, property, value); 4476 return ret; 4477 } 4478 4479 static int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj, 4480 struct drm_property *property, 4481 uint64_t value) 4482 { 4483 int ret = -EINVAL; 4484 struct drm_crtc *crtc = obj_to_crtc(obj); 4485 4486 if (crtc->funcs->set_property) 4487 ret = crtc->funcs->set_property(crtc, property, value); 4488 if (!ret) 4489 drm_object_property_set_value(obj, property, value); 4490 4491 return ret; 4492 } 4493 4494 /** 4495 * drm_mode_plane_set_obj_prop - set the value of a property 4496 * @plane: drm plane object to set property value for 4497 * @property: property to set 4498 * @value: value the property should be set to 4499 * 4500 * This functions sets a given property on a given plane object. This function 4501 * calls the driver's ->set_property callback and changes the software state of 4502 * the property if the callback succeeds. 4503 * 4504 * Returns: 4505 * Zero on success, error code on failure. 4506 */ 4507 int drm_mode_plane_set_obj_prop(struct drm_plane *plane, 4508 struct drm_property *property, 4509 uint64_t value) 4510 { 4511 int ret = -EINVAL; 4512 struct drm_mode_object *obj = &plane->base; 4513 4514 if (plane->funcs->set_property) 4515 ret = plane->funcs->set_property(plane, property, value); 4516 if (!ret) 4517 drm_object_property_set_value(obj, property, value); 4518 4519 return ret; 4520 } 4521 EXPORT_SYMBOL(drm_mode_plane_set_obj_prop); 4522 4523 /** 4524 * drm_mode_obj_get_properties_ioctl - get the current value of a object's property 4525 * @dev: DRM device 4526 * @data: ioctl data 4527 * @file_priv: DRM file info 4528 * 4529 * This function retrieves the current value for an object's property. Compared 4530 * to the connector specific ioctl this one is extended to also work on crtc and 4531 * plane objects. 4532 * 4533 * Called by the user via ioctl. 4534 * 4535 * Returns: 4536 * Zero on success, negative errno on failure. 4537 */ 4538 int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data, 4539 struct drm_file *file_priv) 4540 { 4541 struct drm_mode_obj_get_properties *arg = data; 4542 struct drm_mode_object *obj; 4543 int ret = 0; 4544 4545 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 4546 return -EINVAL; 4547 4548 drm_modeset_lock_all(dev); 4549 4550 obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type); 4551 if (!obj) { 4552 ret = -ENOENT; 4553 goto out; 4554 } 4555 if (!obj->properties) { 4556 ret = -EINVAL; 4557 goto out; 4558 } 4559 4560 ret = get_properties(obj, file_priv->atomic, 4561 (uint32_t __user *)(unsigned long)(arg->props_ptr), 4562 (uint64_t __user *)(unsigned long)(arg->prop_values_ptr), 4563 &arg->count_props); 4564 4565 out: 4566 drm_modeset_unlock_all(dev); 4567 return ret; 4568 } 4569 4570 /** 4571 * drm_mode_obj_set_property_ioctl - set the current value of an object's property 4572 * @dev: DRM device 4573 * @data: ioctl data 4574 * @file_priv: DRM file info 4575 * 4576 * This function sets the current value for an object's property. It also calls 4577 * into a driver's ->set_property callback to update the hardware state. 4578 * Compared to the connector specific ioctl this one is extended to also work on 4579 * crtc and plane objects. 4580 * 4581 * Called by the user via ioctl. 4582 * 4583 * Returns: 4584 * Zero on success, negative errno on failure. 4585 */ 4586 int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data, 4587 struct drm_file *file_priv) 4588 { 4589 struct drm_mode_obj_set_property *arg = data; 4590 struct drm_mode_object *arg_obj; 4591 struct drm_mode_object *prop_obj; 4592 struct drm_property *property; 4593 int i, ret = -EINVAL; 4594 struct drm_mode_object *ref; 4595 4596 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 4597 return -EINVAL; 4598 4599 drm_modeset_lock_all(dev); 4600 4601 arg_obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type); 4602 if (!arg_obj) { 4603 ret = -ENOENT; 4604 goto out; 4605 } 4606 if (!arg_obj->properties) 4607 goto out; 4608 4609 for (i = 0; i < arg_obj->properties->count; i++) 4610 if (arg_obj->properties->properties[i]->base.id == arg->prop_id) 4611 break; 4612 4613 if (i == arg_obj->properties->count) 4614 goto out; 4615 4616 prop_obj = drm_mode_object_find(dev, arg->prop_id, 4617 DRM_MODE_OBJECT_PROPERTY); 4618 if (!prop_obj) { 4619 ret = -ENOENT; 4620 goto out; 4621 } 4622 property = obj_to_property(prop_obj); 4623 4624 if (!drm_property_change_valid_get(property, arg->value, &ref)) 4625 goto out; 4626 4627 switch (arg_obj->type) { 4628 case DRM_MODE_OBJECT_CONNECTOR: 4629 ret = drm_mode_connector_set_obj_prop(arg_obj, property, 4630 arg->value); 4631 break; 4632 case DRM_MODE_OBJECT_CRTC: 4633 ret = drm_mode_crtc_set_obj_prop(arg_obj, property, arg->value); 4634 break; 4635 case DRM_MODE_OBJECT_PLANE: 4636 ret = drm_mode_plane_set_obj_prop(obj_to_plane(arg_obj), 4637 property, arg->value); 4638 break; 4639 } 4640 4641 drm_property_change_valid_put(property, ref); 4642 4643 out: 4644 drm_modeset_unlock_all(dev); 4645 return ret; 4646 } 4647 4648 /** 4649 * drm_mode_connector_attach_encoder - attach a connector to an encoder 4650 * @connector: connector to attach 4651 * @encoder: encoder to attach @connector to 4652 * 4653 * This function links up a connector to an encoder. Note that the routing 4654 * restrictions between encoders and crtcs are exposed to userspace through the 4655 * possible_clones and possible_crtcs bitmasks. 4656 * 4657 * Returns: 4658 * Zero on success, negative errno on failure. 4659 */ 4660 int drm_mode_connector_attach_encoder(struct drm_connector *connector, 4661 struct drm_encoder *encoder) 4662 { 4663 int i; 4664 4665 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 4666 if (connector->encoder_ids[i] == 0) { 4667 connector->encoder_ids[i] = encoder->base.id; 4668 return 0; 4669 } 4670 } 4671 return -ENOMEM; 4672 } 4673 EXPORT_SYMBOL(drm_mode_connector_attach_encoder); 4674 4675 /** 4676 * drm_mode_crtc_set_gamma_size - set the gamma table size 4677 * @crtc: CRTC to set the gamma table size for 4678 * @gamma_size: size of the gamma table 4679 * 4680 * Drivers which support gamma tables should set this to the supported gamma 4681 * table size when initializing the CRTC. Currently the drm core only supports a 4682 * fixed gamma table size. 4683 * 4684 * Returns: 4685 * Zero on success, negative errno on failure. 4686 */ 4687 int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc, 4688 int gamma_size) 4689 { 4690 crtc->gamma_size = gamma_size; 4691 4692 crtc->gamma_store = kcalloc(gamma_size, sizeof(uint16_t) * 3, 4693 GFP_KERNEL); 4694 if (!crtc->gamma_store) { 4695 crtc->gamma_size = 0; 4696 return -ENOMEM; 4697 } 4698 4699 return 0; 4700 } 4701 EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size); 4702 4703 /** 4704 * drm_mode_gamma_set_ioctl - set the gamma table 4705 * @dev: DRM device 4706 * @data: ioctl data 4707 * @file_priv: DRM file info 4708 * 4709 * Set the gamma table of a CRTC to the one passed in by the user. Userspace can 4710 * inquire the required gamma table size through drm_mode_gamma_get_ioctl. 4711 * 4712 * Called by the user via ioctl. 4713 * 4714 * Returns: 4715 * Zero on success, negative errno on failure. 4716 */ 4717 int drm_mode_gamma_set_ioctl(struct drm_device *dev, 4718 void *data, struct drm_file *file_priv) 4719 { 4720 struct drm_mode_crtc_lut *crtc_lut = data; 4721 struct drm_crtc *crtc; 4722 void *r_base, *g_base, *b_base; 4723 int size; 4724 int ret = 0; 4725 4726 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 4727 return -EINVAL; 4728 4729 drm_modeset_lock_all(dev); 4730 crtc = drm_crtc_find(dev, crtc_lut->crtc_id); 4731 if (!crtc) { 4732 ret = -ENOENT; 4733 goto out; 4734 } 4735 4736 if (crtc->funcs->gamma_set == NULL) { 4737 ret = -ENOSYS; 4738 goto out; 4739 } 4740 4741 /* memcpy into gamma store */ 4742 if (crtc_lut->gamma_size != crtc->gamma_size) { 4743 ret = -EINVAL; 4744 goto out; 4745 } 4746 4747 size = crtc_lut->gamma_size * (sizeof(uint16_t)); 4748 r_base = crtc->gamma_store; 4749 if (copy_from_user(r_base, (void __user *)(unsigned long)crtc_lut->red, size)) { 4750 ret = -EFAULT; 4751 goto out; 4752 } 4753 4754 g_base = r_base + size; 4755 if (copy_from_user(g_base, (void __user *)(unsigned long)crtc_lut->green, size)) { 4756 ret = -EFAULT; 4757 goto out; 4758 } 4759 4760 b_base = g_base + size; 4761 if (copy_from_user(b_base, (void __user *)(unsigned long)crtc_lut->blue, size)) { 4762 ret = -EFAULT; 4763 goto out; 4764 } 4765 4766 crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size); 4767 4768 out: 4769 drm_modeset_unlock_all(dev); 4770 return ret; 4771 4772 } 4773 4774 /** 4775 * drm_mode_gamma_get_ioctl - get the gamma table 4776 * @dev: DRM device 4777 * @data: ioctl data 4778 * @file_priv: DRM file info 4779 * 4780 * Copy the current gamma table into the storage provided. This also provides 4781 * the gamma table size the driver expects, which can be used to size the 4782 * allocated storage. 4783 * 4784 * Called by the user via ioctl. 4785 * 4786 * Returns: 4787 * Zero on success, negative errno on failure. 4788 */ 4789 int drm_mode_gamma_get_ioctl(struct drm_device *dev, 4790 void *data, struct drm_file *file_priv) 4791 { 4792 struct drm_mode_crtc_lut *crtc_lut = data; 4793 struct drm_crtc *crtc; 4794 void *r_base, *g_base, *b_base; 4795 int size; 4796 int ret = 0; 4797 4798 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 4799 return -EINVAL; 4800 4801 drm_modeset_lock_all(dev); 4802 crtc = drm_crtc_find(dev, crtc_lut->crtc_id); 4803 if (!crtc) { 4804 ret = -ENOENT; 4805 goto out; 4806 } 4807 4808 /* memcpy into gamma store */ 4809 if (crtc_lut->gamma_size != crtc->gamma_size) { 4810 ret = -EINVAL; 4811 goto out; 4812 } 4813 4814 size = crtc_lut->gamma_size * (sizeof(uint16_t)); 4815 r_base = crtc->gamma_store; 4816 if (copy_to_user((void __user *)(unsigned long)crtc_lut->red, r_base, size)) { 4817 ret = -EFAULT; 4818 goto out; 4819 } 4820 4821 g_base = r_base + size; 4822 if (copy_to_user((void __user *)(unsigned long)crtc_lut->green, g_base, size)) { 4823 ret = -EFAULT; 4824 goto out; 4825 } 4826 4827 b_base = g_base + size; 4828 if (copy_to_user((void __user *)(unsigned long)crtc_lut->blue, b_base, size)) { 4829 ret = -EFAULT; 4830 goto out; 4831 } 4832 out: 4833 drm_modeset_unlock_all(dev); 4834 return ret; 4835 } 4836 4837 /** 4838 * drm_mode_page_flip_ioctl - schedule an asynchronous fb update 4839 * @dev: DRM device 4840 * @data: ioctl data 4841 * @file_priv: DRM file info 4842 * 4843 * This schedules an asynchronous update on a given CRTC, called page flip. 4844 * Optionally a drm event is generated to signal the completion of the event. 4845 * Generic drivers cannot assume that a pageflip with changed framebuffer 4846 * properties (including driver specific metadata like tiling layout) will work, 4847 * but some drivers support e.g. pixel format changes through the pageflip 4848 * ioctl. 4849 * 4850 * Called by the user via ioctl. 4851 * 4852 * Returns: 4853 * Zero on success, negative errno on failure. 4854 */ 4855 int drm_mode_page_flip_ioctl(struct drm_device *dev, 4856 void *data, struct drm_file *file_priv) 4857 { 4858 struct drm_mode_crtc_page_flip *page_flip = data; 4859 struct drm_crtc *crtc; 4860 struct drm_framebuffer *fb = NULL; 4861 struct drm_pending_vblank_event *e = NULL; 4862 unsigned long flags; 4863 int ret = -EINVAL; 4864 4865 if (page_flip->flags & ~DRM_MODE_PAGE_FLIP_FLAGS || 4866 page_flip->reserved != 0) 4867 return -EINVAL; 4868 4869 if ((page_flip->flags & DRM_MODE_PAGE_FLIP_ASYNC) && !dev->mode_config.async_page_flip) 4870 return -EINVAL; 4871 4872 crtc = drm_crtc_find(dev, page_flip->crtc_id); 4873 if (!crtc) 4874 return -ENOENT; 4875 4876 drm_modeset_lock_crtc(crtc, crtc->primary); 4877 if (crtc->primary->fb == NULL) { 4878 /* The framebuffer is currently unbound, presumably 4879 * due to a hotplug event, that userspace has not 4880 * yet discovered. 4881 */ 4882 ret = -EBUSY; 4883 goto out; 4884 } 4885 4886 if (crtc->funcs->page_flip == NULL) 4887 goto out; 4888 4889 fb = drm_framebuffer_lookup(dev, page_flip->fb_id); 4890 if (!fb) { 4891 ret = -ENOENT; 4892 goto out; 4893 } 4894 4895 ret = drm_crtc_check_viewport(crtc, crtc->x, crtc->y, &crtc->mode, fb); 4896 if (ret) 4897 goto out; 4898 4899 if (crtc->primary->fb->pixel_format != fb->pixel_format) { 4900 DRM_DEBUG_KMS("Page flip is not allowed to change frame buffer format.\n"); 4901 ret = -EINVAL; 4902 goto out; 4903 } 4904 4905 if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) { 4906 ret = -ENOMEM; 4907 spin_lock_irqsave(&dev->event_lock, flags); 4908 if (file_priv->event_space < sizeof(e->event)) { 4909 spin_unlock_irqrestore(&dev->event_lock, flags); 4910 goto out; 4911 } 4912 file_priv->event_space -= sizeof(e->event); 4913 spin_unlock_irqrestore(&dev->event_lock, flags); 4914 4915 e = kzalloc(sizeof(*e), GFP_KERNEL); 4916 if (e == NULL) { 4917 spin_lock_irqsave(&dev->event_lock, flags); 4918 file_priv->event_space += sizeof(e->event); 4919 spin_unlock_irqrestore(&dev->event_lock, flags); 4920 goto out; 4921 } 4922 4923 e->event.base.type = DRM_EVENT_FLIP_COMPLETE; 4924 e->event.base.length = sizeof(e->event); 4925 e->event.user_data = page_flip->user_data; 4926 e->base.event = &e->event.base; 4927 e->base.file_priv = file_priv; 4928 e->base.destroy = 4929 (void (*) (struct drm_pending_event *)) kfree; 4930 } 4931 4932 crtc->primary->old_fb = crtc->primary->fb; 4933 ret = crtc->funcs->page_flip(crtc, fb, e, page_flip->flags); 4934 if (ret) { 4935 if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) { 4936 spin_lock_irqsave(&dev->event_lock, flags); 4937 file_priv->event_space += sizeof(e->event); 4938 spin_unlock_irqrestore(&dev->event_lock, flags); 4939 kfree(e); 4940 } 4941 /* Keep the old fb, don't unref it. */ 4942 crtc->primary->old_fb = NULL; 4943 } else { 4944 /* 4945 * Warn if the driver hasn't properly updated the crtc->fb 4946 * field to reflect that the new framebuffer is now used. 4947 * Failing to do so will screw with the reference counting 4948 * on framebuffers. 4949 */ 4950 WARN_ON(crtc->primary->fb != fb); 4951 /* Unref only the old framebuffer. */ 4952 fb = NULL; 4953 } 4954 4955 out: 4956 if (fb) 4957 drm_framebuffer_unreference(fb); 4958 if (crtc->primary->old_fb) 4959 drm_framebuffer_unreference(crtc->primary->old_fb); 4960 crtc->primary->old_fb = NULL; 4961 drm_modeset_unlock_crtc(crtc); 4962 4963 return ret; 4964 } 4965 4966 /** 4967 * drm_mode_config_reset - call ->reset callbacks 4968 * @dev: drm device 4969 * 4970 * This functions calls all the crtc's, encoder's and connector's ->reset 4971 * callback. Drivers can use this in e.g. their driver load or resume code to 4972 * reset hardware and software state. 4973 */ 4974 void drm_mode_config_reset(struct drm_device *dev) 4975 { 4976 struct drm_crtc *crtc; 4977 struct drm_plane *plane; 4978 struct drm_encoder *encoder; 4979 struct drm_connector *connector; 4980 4981 list_for_each_entry(plane, &dev->mode_config.plane_list, head) 4982 if (plane->funcs->reset) 4983 plane->funcs->reset(plane); 4984 4985 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) 4986 if (crtc->funcs->reset) 4987 crtc->funcs->reset(crtc); 4988 4989 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) 4990 if (encoder->funcs->reset) 4991 encoder->funcs->reset(encoder); 4992 4993 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 4994 connector->status = connector_status_unknown; 4995 4996 if (connector->funcs->reset) 4997 connector->funcs->reset(connector); 4998 } 4999 } 5000 EXPORT_SYMBOL(drm_mode_config_reset); 5001 5002 /** 5003 * drm_mode_create_dumb_ioctl - create a dumb backing storage buffer 5004 * @dev: DRM device 5005 * @data: ioctl data 5006 * @file_priv: DRM file info 5007 * 5008 * This creates a new dumb buffer in the driver's backing storage manager (GEM, 5009 * TTM or something else entirely) and returns the resulting buffer handle. This 5010 * handle can then be wrapped up into a framebuffer modeset object. 5011 * 5012 * Note that userspace is not allowed to use such objects for render 5013 * acceleration - drivers must create their own private ioctls for such a use 5014 * case. 5015 * 5016 * Called by the user via ioctl. 5017 * 5018 * Returns: 5019 * Zero on success, negative errno on failure. 5020 */ 5021 int drm_mode_create_dumb_ioctl(struct drm_device *dev, 5022 void *data, struct drm_file *file_priv) 5023 { 5024 struct drm_mode_create_dumb *args = data; 5025 u32 cpp, stride, size; 5026 5027 if (!dev->driver->dumb_create) 5028 return -ENOSYS; 5029 if (!args->width || !args->height || !args->bpp) 5030 return -EINVAL; 5031 5032 /* overflow checks for 32bit size calculations */ 5033 /* NOTE: DIV_ROUND_UP() can overflow */ 5034 cpp = DIV_ROUND_UP(args->bpp, 8); 5035 if (!cpp || cpp > 0xffffffffU / args->width) 5036 return -EINVAL; 5037 stride = cpp * args->width; 5038 if (args->height > 0xffffffffU / stride) 5039 return -EINVAL; 5040 5041 /* test for wrap-around */ 5042 size = args->height * stride; 5043 if (PAGE_ALIGN(size) == 0) 5044 return -EINVAL; 5045 5046 /* 5047 * handle, pitch and size are output parameters. Zero them out to 5048 * prevent drivers from accidentally using uninitialized data. Since 5049 * not all existing userspace is clearing these fields properly we 5050 * cannot reject IOCTL with garbage in them. 5051 */ 5052 args->handle = 0; 5053 args->pitch = 0; 5054 args->size = 0; 5055 5056 return dev->driver->dumb_create(file_priv, dev, args); 5057 } 5058 5059 /** 5060 * drm_mode_mmap_dumb_ioctl - create an mmap offset for a dumb backing storage buffer 5061 * @dev: DRM device 5062 * @data: ioctl data 5063 * @file_priv: DRM file info 5064 * 5065 * Allocate an offset in the drm device node's address space to be able to 5066 * memory map a dumb buffer. 5067 * 5068 * Called by the user via ioctl. 5069 * 5070 * Returns: 5071 * Zero on success, negative errno on failure. 5072 */ 5073 int drm_mode_mmap_dumb_ioctl(struct drm_device *dev, 5074 void *data, struct drm_file *file_priv) 5075 { 5076 struct drm_mode_map_dumb *args = data; 5077 5078 /* call driver ioctl to get mmap offset */ 5079 if (!dev->driver->dumb_map_offset) 5080 return -ENOSYS; 5081 5082 return dev->driver->dumb_map_offset(file_priv, dev, args->handle, &args->offset); 5083 } 5084 5085 /** 5086 * drm_mode_destroy_dumb_ioctl - destroy a dumb backing strage buffer 5087 * @dev: DRM device 5088 * @data: ioctl data 5089 * @file_priv: DRM file info 5090 * 5091 * This destroys the userspace handle for the given dumb backing storage buffer. 5092 * Since buffer objects must be reference counted in the kernel a buffer object 5093 * won't be immediately freed if a framebuffer modeset object still uses it. 5094 * 5095 * Called by the user via ioctl. 5096 * 5097 * Returns: 5098 * Zero on success, negative errno on failure. 5099 */ 5100 int drm_mode_destroy_dumb_ioctl(struct drm_device *dev, 5101 void *data, struct drm_file *file_priv) 5102 { 5103 struct drm_mode_destroy_dumb *args = data; 5104 5105 if (!dev->driver->dumb_destroy) 5106 return -ENOSYS; 5107 5108 return dev->driver->dumb_destroy(file_priv, dev, args->handle); 5109 } 5110 5111 /** 5112 * drm_fb_get_bpp_depth - get the bpp/depth values for format 5113 * @format: pixel format (DRM_FORMAT_*) 5114 * @depth: storage for the depth value 5115 * @bpp: storage for the bpp value 5116 * 5117 * This only supports RGB formats here for compat with code that doesn't use 5118 * pixel formats directly yet. 5119 */ 5120 void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth, 5121 int *bpp) 5122 { 5123 switch (format) { 5124 case DRM_FORMAT_C8: 5125 case DRM_FORMAT_RGB332: 5126 case DRM_FORMAT_BGR233: 5127 *depth = 8; 5128 *bpp = 8; 5129 break; 5130 case DRM_FORMAT_XRGB1555: 5131 case DRM_FORMAT_XBGR1555: 5132 case DRM_FORMAT_RGBX5551: 5133 case DRM_FORMAT_BGRX5551: 5134 case DRM_FORMAT_ARGB1555: 5135 case DRM_FORMAT_ABGR1555: 5136 case DRM_FORMAT_RGBA5551: 5137 case DRM_FORMAT_BGRA5551: 5138 *depth = 15; 5139 *bpp = 16; 5140 break; 5141 case DRM_FORMAT_RGB565: 5142 case DRM_FORMAT_BGR565: 5143 *depth = 16; 5144 *bpp = 16; 5145 break; 5146 case DRM_FORMAT_RGB888: 5147 case DRM_FORMAT_BGR888: 5148 *depth = 24; 5149 *bpp = 24; 5150 break; 5151 case DRM_FORMAT_XRGB8888: 5152 case DRM_FORMAT_XBGR8888: 5153 case DRM_FORMAT_RGBX8888: 5154 case DRM_FORMAT_BGRX8888: 5155 *depth = 24; 5156 *bpp = 32; 5157 break; 5158 case DRM_FORMAT_XRGB2101010: 5159 case DRM_FORMAT_XBGR2101010: 5160 case DRM_FORMAT_RGBX1010102: 5161 case DRM_FORMAT_BGRX1010102: 5162 case DRM_FORMAT_ARGB2101010: 5163 case DRM_FORMAT_ABGR2101010: 5164 case DRM_FORMAT_RGBA1010102: 5165 case DRM_FORMAT_BGRA1010102: 5166 *depth = 30; 5167 *bpp = 32; 5168 break; 5169 case DRM_FORMAT_ARGB8888: 5170 case DRM_FORMAT_ABGR8888: 5171 case DRM_FORMAT_RGBA8888: 5172 case DRM_FORMAT_BGRA8888: 5173 *depth = 32; 5174 *bpp = 32; 5175 break; 5176 default: 5177 DRM_DEBUG_KMS("unsupported pixel format %s\n", 5178 drm_get_format_name(format)); 5179 *depth = 0; 5180 *bpp = 0; 5181 break; 5182 } 5183 } 5184 EXPORT_SYMBOL(drm_fb_get_bpp_depth); 5185 5186 /** 5187 * drm_format_num_planes - get the number of planes for format 5188 * @format: pixel format (DRM_FORMAT_*) 5189 * 5190 * Returns: 5191 * The number of planes used by the specified pixel format. 5192 */ 5193 int drm_format_num_planes(uint32_t format) 5194 { 5195 switch (format) { 5196 case DRM_FORMAT_YUV410: 5197 case DRM_FORMAT_YVU410: 5198 case DRM_FORMAT_YUV411: 5199 case DRM_FORMAT_YVU411: 5200 case DRM_FORMAT_YUV420: 5201 case DRM_FORMAT_YVU420: 5202 case DRM_FORMAT_YUV422: 5203 case DRM_FORMAT_YVU422: 5204 case DRM_FORMAT_YUV444: 5205 case DRM_FORMAT_YVU444: 5206 return 3; 5207 case DRM_FORMAT_NV12: 5208 case DRM_FORMAT_NV21: 5209 case DRM_FORMAT_NV16: 5210 case DRM_FORMAT_NV61: 5211 case DRM_FORMAT_NV24: 5212 case DRM_FORMAT_NV42: 5213 return 2; 5214 default: 5215 return 1; 5216 } 5217 } 5218 EXPORT_SYMBOL(drm_format_num_planes); 5219 5220 /** 5221 * drm_format_plane_cpp - determine the bytes per pixel value 5222 * @format: pixel format (DRM_FORMAT_*) 5223 * @plane: plane index 5224 * 5225 * Returns: 5226 * The bytes per pixel value for the specified plane. 5227 */ 5228 int drm_format_plane_cpp(uint32_t format, int plane) 5229 { 5230 unsigned int depth; 5231 int bpp; 5232 5233 if (plane >= drm_format_num_planes(format)) 5234 return 0; 5235 5236 switch (format) { 5237 case DRM_FORMAT_YUYV: 5238 case DRM_FORMAT_YVYU: 5239 case DRM_FORMAT_UYVY: 5240 case DRM_FORMAT_VYUY: 5241 return 2; 5242 case DRM_FORMAT_NV12: 5243 case DRM_FORMAT_NV21: 5244 case DRM_FORMAT_NV16: 5245 case DRM_FORMAT_NV61: 5246 case DRM_FORMAT_NV24: 5247 case DRM_FORMAT_NV42: 5248 return plane ? 2 : 1; 5249 case DRM_FORMAT_YUV410: 5250 case DRM_FORMAT_YVU410: 5251 case DRM_FORMAT_YUV411: 5252 case DRM_FORMAT_YVU411: 5253 case DRM_FORMAT_YUV420: 5254 case DRM_FORMAT_YVU420: 5255 case DRM_FORMAT_YUV422: 5256 case DRM_FORMAT_YVU422: 5257 case DRM_FORMAT_YUV444: 5258 case DRM_FORMAT_YVU444: 5259 return 1; 5260 default: 5261 drm_fb_get_bpp_depth(format, &depth, &bpp); 5262 return bpp >> 3; 5263 } 5264 } 5265 EXPORT_SYMBOL(drm_format_plane_cpp); 5266 5267 /** 5268 * drm_format_horz_chroma_subsampling - get the horizontal chroma subsampling factor 5269 * @format: pixel format (DRM_FORMAT_*) 5270 * 5271 * Returns: 5272 * The horizontal chroma subsampling factor for the 5273 * specified pixel format. 5274 */ 5275 int drm_format_horz_chroma_subsampling(uint32_t format) 5276 { 5277 switch (format) { 5278 case DRM_FORMAT_YUV411: 5279 case DRM_FORMAT_YVU411: 5280 case DRM_FORMAT_YUV410: 5281 case DRM_FORMAT_YVU410: 5282 return 4; 5283 case DRM_FORMAT_YUYV: 5284 case DRM_FORMAT_YVYU: 5285 case DRM_FORMAT_UYVY: 5286 case DRM_FORMAT_VYUY: 5287 case DRM_FORMAT_NV12: 5288 case DRM_FORMAT_NV21: 5289 case DRM_FORMAT_NV16: 5290 case DRM_FORMAT_NV61: 5291 case DRM_FORMAT_YUV422: 5292 case DRM_FORMAT_YVU422: 5293 case DRM_FORMAT_YUV420: 5294 case DRM_FORMAT_YVU420: 5295 return 2; 5296 default: 5297 return 1; 5298 } 5299 } 5300 EXPORT_SYMBOL(drm_format_horz_chroma_subsampling); 5301 5302 /** 5303 * drm_format_vert_chroma_subsampling - get the vertical chroma subsampling factor 5304 * @format: pixel format (DRM_FORMAT_*) 5305 * 5306 * Returns: 5307 * The vertical chroma subsampling factor for the 5308 * specified pixel format. 5309 */ 5310 int drm_format_vert_chroma_subsampling(uint32_t format) 5311 { 5312 switch (format) { 5313 case DRM_FORMAT_YUV410: 5314 case DRM_FORMAT_YVU410: 5315 return 4; 5316 case DRM_FORMAT_YUV420: 5317 case DRM_FORMAT_YVU420: 5318 case DRM_FORMAT_NV12: 5319 case DRM_FORMAT_NV21: 5320 return 2; 5321 default: 5322 return 1; 5323 } 5324 } 5325 EXPORT_SYMBOL(drm_format_vert_chroma_subsampling); 5326 5327 /** 5328 * drm_rotation_simplify() - Try to simplify the rotation 5329 * @rotation: Rotation to be simplified 5330 * @supported_rotations: Supported rotations 5331 * 5332 * Attempt to simplify the rotation to a form that is supported. 5333 * Eg. if the hardware supports everything except DRM_REFLECT_X 5334 * one could call this function like this: 5335 * 5336 * drm_rotation_simplify(rotation, BIT(DRM_ROTATE_0) | 5337 * BIT(DRM_ROTATE_90) | BIT(DRM_ROTATE_180) | 5338 * BIT(DRM_ROTATE_270) | BIT(DRM_REFLECT_Y)); 5339 * 5340 * to eliminate the DRM_ROTATE_X flag. Depending on what kind of 5341 * transforms the hardware supports, this function may not 5342 * be able to produce a supported transform, so the caller should 5343 * check the result afterwards. 5344 */ 5345 unsigned int drm_rotation_simplify(unsigned int rotation, 5346 unsigned int supported_rotations) 5347 { 5348 if (rotation & ~supported_rotations) { 5349 rotation ^= BIT(DRM_REFLECT_X) | BIT(DRM_REFLECT_Y); 5350 rotation = (rotation & ~0xf) | BIT((ffs(rotation & 0xf) + 1) % 4); 5351 } 5352 5353 return rotation; 5354 } 5355 EXPORT_SYMBOL(drm_rotation_simplify); 5356 5357 /** 5358 * drm_mode_config_init - initialize DRM mode_configuration structure 5359 * @dev: DRM device 5360 * 5361 * Initialize @dev's mode_config structure, used for tracking the graphics 5362 * configuration of @dev. 5363 * 5364 * Since this initializes the modeset locks, no locking is possible. Which is no 5365 * problem, since this should happen single threaded at init time. It is the 5366 * driver's problem to ensure this guarantee. 5367 * 5368 */ 5369 void drm_mode_config_init(struct drm_device *dev) 5370 { 5371 mutex_init(&dev->mode_config.mutex); 5372 drm_modeset_lock_init(&dev->mode_config.connection_mutex); 5373 mutex_init(&dev->mode_config.idr_mutex); 5374 mutex_init(&dev->mode_config.fb_lock); 5375 INIT_LIST_HEAD(&dev->mode_config.fb_list); 5376 INIT_LIST_HEAD(&dev->mode_config.crtc_list); 5377 INIT_LIST_HEAD(&dev->mode_config.connector_list); 5378 INIT_LIST_HEAD(&dev->mode_config.encoder_list); 5379 INIT_LIST_HEAD(&dev->mode_config.property_list); 5380 INIT_LIST_HEAD(&dev->mode_config.property_blob_list); 5381 INIT_LIST_HEAD(&dev->mode_config.plane_list); 5382 idr_init(&dev->mode_config.crtc_idr); 5383 idr_init(&dev->mode_config.tile_idr); 5384 5385 drm_modeset_lock_all(dev); 5386 drm_mode_create_standard_properties(dev); 5387 drm_modeset_unlock_all(dev); 5388 5389 /* Just to be sure */ 5390 dev->mode_config.num_fb = 0; 5391 dev->mode_config.num_connector = 0; 5392 dev->mode_config.num_crtc = 0; 5393 dev->mode_config.num_encoder = 0; 5394 dev->mode_config.num_overlay_plane = 0; 5395 dev->mode_config.num_total_plane = 0; 5396 } 5397 EXPORT_SYMBOL(drm_mode_config_init); 5398 5399 /** 5400 * drm_mode_config_cleanup - free up DRM mode_config info 5401 * @dev: DRM device 5402 * 5403 * Free up all the connectors and CRTCs associated with this DRM device, then 5404 * free up the framebuffers and associated buffer objects. 5405 * 5406 * Note that since this /should/ happen single-threaded at driver/device 5407 * teardown time, no locking is required. It's the driver's job to ensure that 5408 * this guarantee actually holds true. 5409 * 5410 * FIXME: cleanup any dangling user buffer objects too 5411 */ 5412 void drm_mode_config_cleanup(struct drm_device *dev) 5413 { 5414 struct drm_connector *connector, *ot; 5415 struct drm_crtc *crtc, *ct; 5416 struct drm_encoder *encoder, *enct; 5417 struct drm_framebuffer *fb, *fbt; 5418 struct drm_property *property, *pt; 5419 struct drm_property_blob *blob, *bt; 5420 struct drm_plane *plane, *plt; 5421 5422 list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list, 5423 head) { 5424 encoder->funcs->destroy(encoder); 5425 } 5426 5427 list_for_each_entry_safe(connector, ot, 5428 &dev->mode_config.connector_list, head) { 5429 connector->funcs->destroy(connector); 5430 } 5431 5432 list_for_each_entry_safe(property, pt, &dev->mode_config.property_list, 5433 head) { 5434 drm_property_destroy(dev, property); 5435 } 5436 5437 list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list, 5438 head) { 5439 drm_property_destroy_blob(dev, blob); 5440 } 5441 5442 /* 5443 * Single-threaded teardown context, so it's not required to grab the 5444 * fb_lock to protect against concurrent fb_list access. Contrary, it 5445 * would actually deadlock with the drm_framebuffer_cleanup function. 5446 * 5447 * Also, if there are any framebuffers left, that's a driver leak now, 5448 * so politely WARN about this. 5449 */ 5450 WARN_ON(!list_empty(&dev->mode_config.fb_list)); 5451 list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) { 5452 drm_framebuffer_remove(fb); 5453 } 5454 5455 list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list, 5456 head) { 5457 plane->funcs->destroy(plane); 5458 } 5459 5460 list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) { 5461 crtc->funcs->destroy(crtc); 5462 } 5463 5464 idr_destroy(&dev->mode_config.tile_idr); 5465 idr_destroy(&dev->mode_config.crtc_idr); 5466 drm_modeset_lock_fini(&dev->mode_config.connection_mutex); 5467 } 5468 EXPORT_SYMBOL(drm_mode_config_cleanup); 5469 5470 struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev, 5471 unsigned int supported_rotations) 5472 { 5473 static const struct drm_prop_enum_list props[] = { 5474 { DRM_ROTATE_0, "rotate-0" }, 5475 { DRM_ROTATE_90, "rotate-90" }, 5476 { DRM_ROTATE_180, "rotate-180" }, 5477 { DRM_ROTATE_270, "rotate-270" }, 5478 { DRM_REFLECT_X, "reflect-x" }, 5479 { DRM_REFLECT_Y, "reflect-y" }, 5480 }; 5481 5482 return drm_property_create_bitmask(dev, 0, "rotation", 5483 props, ARRAY_SIZE(props), 5484 supported_rotations); 5485 } 5486 EXPORT_SYMBOL(drm_mode_create_rotation_property); 5487 5488 /** 5489 * DOC: Tile group 5490 * 5491 * Tile groups are used to represent tiled monitors with a unique 5492 * integer identifier. Tiled monitors using DisplayID v1.3 have 5493 * a unique 8-byte handle, we store this in a tile group, so we 5494 * have a common identifier for all tiles in a monitor group. 5495 */ 5496 static void drm_tile_group_free(struct kref *kref) 5497 { 5498 struct drm_tile_group *tg = container_of(kref, struct drm_tile_group, refcount); 5499 struct drm_device *dev = tg->dev; 5500 mutex_lock(&dev->mode_config.idr_mutex); 5501 idr_remove(&dev->mode_config.tile_idr, tg->id); 5502 mutex_unlock(&dev->mode_config.idr_mutex); 5503 kfree(tg); 5504 } 5505 5506 /** 5507 * drm_mode_put_tile_group - drop a reference to a tile group. 5508 * @dev: DRM device 5509 * @tg: tile group to drop reference to. 5510 * 5511 * drop reference to tile group and free if 0. 5512 */ 5513 void drm_mode_put_tile_group(struct drm_device *dev, 5514 struct drm_tile_group *tg) 5515 { 5516 kref_put(&tg->refcount, drm_tile_group_free); 5517 } 5518 5519 /** 5520 * drm_mode_get_tile_group - get a reference to an existing tile group 5521 * @dev: DRM device 5522 * @topology: 8-bytes unique per monitor. 5523 * 5524 * Use the unique bytes to get a reference to an existing tile group. 5525 * 5526 * RETURNS: 5527 * tile group or NULL if not found. 5528 */ 5529 struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev, 5530 char topology[8]) 5531 { 5532 struct drm_tile_group *tg; 5533 int id; 5534 mutex_lock(&dev->mode_config.idr_mutex); 5535 idr_for_each_entry(&dev->mode_config.tile_idr, tg, id) { 5536 if (!memcmp(tg->group_data, topology, 8)) { 5537 if (!kref_get_unless_zero(&tg->refcount)) 5538 tg = NULL; 5539 mutex_unlock(&dev->mode_config.idr_mutex); 5540 return tg; 5541 } 5542 } 5543 mutex_unlock(&dev->mode_config.idr_mutex); 5544 return NULL; 5545 } 5546 5547 /** 5548 * drm_mode_create_tile_group - create a tile group from a displayid description 5549 * @dev: DRM device 5550 * @topology: 8-bytes unique per monitor. 5551 * 5552 * Create a tile group for the unique monitor, and get a unique 5553 * identifier for the tile group. 5554 * 5555 * RETURNS: 5556 * new tile group or error. 5557 */ 5558 struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev, 5559 char topology[8]) 5560 { 5561 struct drm_tile_group *tg; 5562 int ret; 5563 5564 tg = kzalloc(sizeof(*tg), GFP_KERNEL); 5565 if (!tg) 5566 return ERR_PTR(-ENOMEM); 5567 5568 kref_init(&tg->refcount); 5569 memcpy(tg->group_data, topology, 8); 5570 tg->dev = dev; 5571 5572 mutex_lock(&dev->mode_config.idr_mutex); 5573 ret = idr_alloc(&dev->mode_config.tile_idr, tg, 1, 0, GFP_KERNEL); 5574 if (ret >= 0) { 5575 tg->id = ret; 5576 } else { 5577 kfree(tg); 5578 tg = ERR_PTR(ret); 5579 } 5580 5581 mutex_unlock(&dev->mode_config.idr_mutex); 5582 return tg; 5583 } 5584