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