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