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