drm_crtc.c revision e5e3b44c676be2dac97efd94e581e14a073e4ca7
1/* 2 * Copyright (c) 2006-2008 Intel Corporation 3 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie> 4 * Copyright (c) 2008 Red Hat Inc. 5 * 6 * DRM core CRTC related functions 7 * 8 * Permission to use, copy, modify, distribute, and sell this software and its 9 * documentation for any purpose is hereby granted without fee, provided that 10 * the above copyright notice appear in all copies and that both that copyright 11 * notice and this permission notice appear in supporting documentation, and 12 * that the name of the copyright holders not be used in advertising or 13 * publicity pertaining to distribution of the software without specific, 14 * written prior permission. The copyright holders make no representations 15 * about the suitability of this software for any purpose. It is provided "as 16 * is" without express or implied warranty. 17 * 18 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 19 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 20 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR 21 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 22 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 23 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 24 * OF THIS SOFTWARE. 25 * 26 * Authors: 27 * Keith Packard 28 * Eric Anholt <eric@anholt.net> 29 * Dave Airlie <airlied@linux.ie> 30 * Jesse Barnes <jesse.barnes@intel.com> 31 */ 32#include <linux/list.h> 33#include <linux/slab.h> 34#include <linux/export.h> 35#include "drm.h" 36#include "drmP.h" 37#include "drm_crtc.h" 38#include "drm_edid.h" 39#include "drm_fourcc.h" 40 41struct drm_prop_enum_list { 42 int type; 43 char *name; 44}; 45 46/* Avoid boilerplate. I'm tired of typing. */ 47#define DRM_ENUM_NAME_FN(fnname, list) \ 48 char *fnname(int val) \ 49 { \ 50 int i; \ 51 for (i = 0; i < ARRAY_SIZE(list); i++) { \ 52 if (list[i].type == val) \ 53 return list[i].name; \ 54 } \ 55 return "(unknown)"; \ 56 } 57 58/* 59 * Global properties 60 */ 61static struct drm_prop_enum_list drm_dpms_enum_list[] = 62{ { DRM_MODE_DPMS_ON, "On" }, 63 { DRM_MODE_DPMS_STANDBY, "Standby" }, 64 { DRM_MODE_DPMS_SUSPEND, "Suspend" }, 65 { DRM_MODE_DPMS_OFF, "Off" } 66}; 67 68DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list) 69 70/* 71 * Optional properties 72 */ 73static struct drm_prop_enum_list drm_scaling_mode_enum_list[] = 74{ 75 { DRM_MODE_SCALE_NONE, "None" }, 76 { DRM_MODE_SCALE_FULLSCREEN, "Full" }, 77 { DRM_MODE_SCALE_CENTER, "Center" }, 78 { DRM_MODE_SCALE_ASPECT, "Full aspect" }, 79}; 80 81static struct drm_prop_enum_list drm_dithering_mode_enum_list[] = 82{ 83 { DRM_MODE_DITHERING_OFF, "Off" }, 84 { DRM_MODE_DITHERING_ON, "On" }, 85 { DRM_MODE_DITHERING_AUTO, "Automatic" }, 86}; 87 88/* 89 * Non-global properties, but "required" for certain connectors. 90 */ 91static struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = 92{ 93 { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ 94 { DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ 95 { DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ 96}; 97 98DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list) 99 100static struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = 101{ 102 { DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */ 103 { DRM_MODE_SUBCONNECTOR_DVID, "DVI-D" }, /* DVI-I */ 104 { DRM_MODE_SUBCONNECTOR_DVIA, "DVI-A" }, /* DVI-I */ 105}; 106 107DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name, 108 drm_dvi_i_subconnector_enum_list) 109 110static struct drm_prop_enum_list drm_tv_select_enum_list[] = 111{ 112 { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */ 113 { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ 114 { DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ 115 { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */ 116 { DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */ 117}; 118 119DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list) 120 121static struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = 122{ 123 { DRM_MODE_SUBCONNECTOR_Unknown, "Unknown" }, /* DVI-I and TV-out */ 124 { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */ 125 { DRM_MODE_SUBCONNECTOR_SVIDEO, "SVIDEO" }, /* TV-out */ 126 { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */ 127 { DRM_MODE_SUBCONNECTOR_SCART, "SCART" }, /* TV-out */ 128}; 129 130DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name, 131 drm_tv_subconnector_enum_list) 132 133static struct drm_prop_enum_list drm_dirty_info_enum_list[] = { 134 { DRM_MODE_DIRTY_OFF, "Off" }, 135 { DRM_MODE_DIRTY_ON, "On" }, 136 { DRM_MODE_DIRTY_ANNOTATE, "Annotate" }, 137}; 138 139DRM_ENUM_NAME_FN(drm_get_dirty_info_name, 140 drm_dirty_info_enum_list) 141 142struct drm_conn_prop_enum_list { 143 int type; 144 char *name; 145 int count; 146}; 147 148/* 149 * Connector and encoder types. 150 */ 151static struct drm_conn_prop_enum_list drm_connector_enum_list[] = 152{ { DRM_MODE_CONNECTOR_Unknown, "Unknown", 0 }, 153 { DRM_MODE_CONNECTOR_VGA, "VGA", 0 }, 154 { DRM_MODE_CONNECTOR_DVII, "DVI-I", 0 }, 155 { DRM_MODE_CONNECTOR_DVID, "DVI-D", 0 }, 156 { DRM_MODE_CONNECTOR_DVIA, "DVI-A", 0 }, 157 { DRM_MODE_CONNECTOR_Composite, "Composite", 0 }, 158 { DRM_MODE_CONNECTOR_SVIDEO, "SVIDEO", 0 }, 159 { DRM_MODE_CONNECTOR_LVDS, "LVDS", 0 }, 160 { DRM_MODE_CONNECTOR_Component, "Component", 0 }, 161 { DRM_MODE_CONNECTOR_9PinDIN, "DIN", 0 }, 162 { DRM_MODE_CONNECTOR_DisplayPort, "DP", 0 }, 163 { DRM_MODE_CONNECTOR_HDMIA, "HDMI-A", 0 }, 164 { DRM_MODE_CONNECTOR_HDMIB, "HDMI-B", 0 }, 165 { DRM_MODE_CONNECTOR_TV, "TV", 0 }, 166 { DRM_MODE_CONNECTOR_eDP, "eDP", 0 }, 167 { DRM_MODE_CONNECTOR_VIRTUAL, "Virtual", 0}, 168}; 169 170static struct drm_prop_enum_list drm_encoder_enum_list[] = 171{ { DRM_MODE_ENCODER_NONE, "None" }, 172 { DRM_MODE_ENCODER_DAC, "DAC" }, 173 { DRM_MODE_ENCODER_TMDS, "TMDS" }, 174 { DRM_MODE_ENCODER_LVDS, "LVDS" }, 175 { DRM_MODE_ENCODER_TVDAC, "TV" }, 176 { DRM_MODE_ENCODER_VIRTUAL, "Virtual" }, 177}; 178 179char *drm_get_encoder_name(struct drm_encoder *encoder) 180{ 181 static char buf[32]; 182 183 snprintf(buf, 32, "%s-%d", 184 drm_encoder_enum_list[encoder->encoder_type].name, 185 encoder->base.id); 186 return buf; 187} 188EXPORT_SYMBOL(drm_get_encoder_name); 189 190char *drm_get_connector_name(struct drm_connector *connector) 191{ 192 static char buf[32]; 193 194 snprintf(buf, 32, "%s-%d", 195 drm_connector_enum_list[connector->connector_type].name, 196 connector->connector_type_id); 197 return buf; 198} 199EXPORT_SYMBOL(drm_get_connector_name); 200 201char *drm_get_connector_status_name(enum drm_connector_status status) 202{ 203 if (status == connector_status_connected) 204 return "connected"; 205 else if (status == connector_status_disconnected) 206 return "disconnected"; 207 else 208 return "unknown"; 209} 210 211/** 212 * drm_mode_object_get - allocate a new identifier 213 * @dev: DRM device 214 * @ptr: object pointer, used to generate unique ID 215 * @type: object type 216 * 217 * LOCKING: 218 * 219 * Create a unique identifier based on @ptr in @dev's identifier space. Used 220 * for tracking modes, CRTCs and connectors. 221 * 222 * RETURNS: 223 * New unique (relative to other objects in @dev) integer identifier for the 224 * object. 225 */ 226static int drm_mode_object_get(struct drm_device *dev, 227 struct drm_mode_object *obj, uint32_t obj_type) 228{ 229 int new_id = 0; 230 int ret; 231 232again: 233 if (idr_pre_get(&dev->mode_config.crtc_idr, GFP_KERNEL) == 0) { 234 DRM_ERROR("Ran out memory getting a mode number\n"); 235 return -EINVAL; 236 } 237 238 mutex_lock(&dev->mode_config.idr_mutex); 239 ret = idr_get_new_above(&dev->mode_config.crtc_idr, obj, 1, &new_id); 240 mutex_unlock(&dev->mode_config.idr_mutex); 241 if (ret == -EAGAIN) 242 goto again; 243 244 obj->id = new_id; 245 obj->type = obj_type; 246 return 0; 247} 248 249/** 250 * drm_mode_object_put - free an identifer 251 * @dev: DRM device 252 * @id: ID to free 253 * 254 * LOCKING: 255 * Caller must hold DRM mode_config lock. 256 * 257 * Free @id from @dev's unique identifier pool. 258 */ 259static void drm_mode_object_put(struct drm_device *dev, 260 struct drm_mode_object *object) 261{ 262 mutex_lock(&dev->mode_config.idr_mutex); 263 idr_remove(&dev->mode_config.crtc_idr, object->id); 264 mutex_unlock(&dev->mode_config.idr_mutex); 265} 266 267struct drm_mode_object *drm_mode_object_find(struct drm_device *dev, 268 uint32_t id, uint32_t type) 269{ 270 struct drm_mode_object *obj = NULL; 271 272 mutex_lock(&dev->mode_config.idr_mutex); 273 obj = idr_find(&dev->mode_config.crtc_idr, id); 274 if (!obj || (obj->type != type) || (obj->id != id)) 275 obj = NULL; 276 mutex_unlock(&dev->mode_config.idr_mutex); 277 278 return obj; 279} 280EXPORT_SYMBOL(drm_mode_object_find); 281 282/** 283 * drm_framebuffer_init - initialize a framebuffer 284 * @dev: DRM device 285 * 286 * LOCKING: 287 * Caller must hold mode config lock. 288 * 289 * Allocates an ID for the framebuffer's parent mode object, sets its mode 290 * functions & device file and adds it to the master fd list. 291 * 292 * RETURNS: 293 * Zero on success, error code on failure. 294 */ 295int drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb, 296 const struct drm_framebuffer_funcs *funcs) 297{ 298 int ret; 299 300 ret = drm_mode_object_get(dev, &fb->base, DRM_MODE_OBJECT_FB); 301 if (ret) { 302 return ret; 303 } 304 305 fb->dev = dev; 306 fb->funcs = funcs; 307 dev->mode_config.num_fb++; 308 list_add(&fb->head, &dev->mode_config.fb_list); 309 310 return 0; 311} 312EXPORT_SYMBOL(drm_framebuffer_init); 313 314/** 315 * drm_framebuffer_cleanup - remove a framebuffer object 316 * @fb: framebuffer to remove 317 * 318 * LOCKING: 319 * Caller must hold mode config lock. 320 * 321 * Scans all the CRTCs in @dev's mode_config. If they're using @fb, removes 322 * it, setting it to NULL. 323 */ 324void drm_framebuffer_cleanup(struct drm_framebuffer *fb) 325{ 326 struct drm_device *dev = fb->dev; 327 struct drm_crtc *crtc; 328 struct drm_plane *plane; 329 struct drm_mode_set set; 330 int ret; 331 332 /* remove from any CRTC */ 333 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { 334 if (crtc->fb == fb) { 335 /* should turn off the crtc */ 336 memset(&set, 0, sizeof(struct drm_mode_set)); 337 set.crtc = crtc; 338 set.fb = NULL; 339 ret = crtc->funcs->set_config(&set); 340 if (ret) 341 DRM_ERROR("failed to reset crtc %p when fb was deleted\n", crtc); 342 } 343 } 344 345 list_for_each_entry(plane, &dev->mode_config.plane_list, head) { 346 if (plane->fb == fb) { 347 /* should turn off the crtc */ 348 ret = plane->funcs->disable_plane(plane); 349 if (ret) 350 DRM_ERROR("failed to disable plane with busy fb\n"); 351 } 352 } 353 354 drm_mode_object_put(dev, &fb->base); 355 list_del(&fb->head); 356 dev->mode_config.num_fb--; 357} 358EXPORT_SYMBOL(drm_framebuffer_cleanup); 359 360/** 361 * drm_crtc_init - Initialise a new CRTC object 362 * @dev: DRM device 363 * @crtc: CRTC object to init 364 * @funcs: callbacks for the new CRTC 365 * 366 * LOCKING: 367 * Caller must hold mode config lock. 368 * 369 * Inits a new object created as base part of an driver crtc object. 370 */ 371void drm_crtc_init(struct drm_device *dev, struct drm_crtc *crtc, 372 const struct drm_crtc_funcs *funcs) 373{ 374 crtc->dev = dev; 375 crtc->funcs = funcs; 376 377 mutex_lock(&dev->mode_config.mutex); 378 drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC); 379 380 list_add_tail(&crtc->head, &dev->mode_config.crtc_list); 381 dev->mode_config.num_crtc++; 382 mutex_unlock(&dev->mode_config.mutex); 383} 384EXPORT_SYMBOL(drm_crtc_init); 385 386/** 387 * drm_crtc_cleanup - Cleans up the core crtc usage. 388 * @crtc: CRTC to cleanup 389 * 390 * LOCKING: 391 * Caller must hold mode config lock. 392 * 393 * Cleanup @crtc. Removes from drm modesetting space 394 * does NOT free object, caller does that. 395 */ 396void drm_crtc_cleanup(struct drm_crtc *crtc) 397{ 398 struct drm_device *dev = crtc->dev; 399 400 if (crtc->gamma_store) { 401 kfree(crtc->gamma_store); 402 crtc->gamma_store = NULL; 403 } 404 405 drm_mode_object_put(dev, &crtc->base); 406 list_del(&crtc->head); 407 dev->mode_config.num_crtc--; 408} 409EXPORT_SYMBOL(drm_crtc_cleanup); 410 411/** 412 * drm_mode_probed_add - add a mode to a connector's probed mode list 413 * @connector: connector the new mode 414 * @mode: mode data 415 * 416 * LOCKING: 417 * Caller must hold mode config lock. 418 * 419 * Add @mode to @connector's mode list for later use. 420 */ 421void drm_mode_probed_add(struct drm_connector *connector, 422 struct drm_display_mode *mode) 423{ 424 list_add(&mode->head, &connector->probed_modes); 425} 426EXPORT_SYMBOL(drm_mode_probed_add); 427 428/** 429 * drm_mode_remove - remove and free a mode 430 * @connector: connector list to modify 431 * @mode: mode to remove 432 * 433 * LOCKING: 434 * Caller must hold mode config lock. 435 * 436 * Remove @mode from @connector's mode list, then free it. 437 */ 438void drm_mode_remove(struct drm_connector *connector, 439 struct drm_display_mode *mode) 440{ 441 list_del(&mode->head); 442 kfree(mode); 443} 444EXPORT_SYMBOL(drm_mode_remove); 445 446/** 447 * drm_connector_init - Init a preallocated connector 448 * @dev: DRM device 449 * @connector: the connector to init 450 * @funcs: callbacks for this connector 451 * @name: user visible name of the connector 452 * 453 * LOCKING: 454 * Caller must hold @dev's mode_config lock. 455 * 456 * Initialises a preallocated connector. Connectors should be 457 * subclassed as part of driver connector objects. 458 */ 459void drm_connector_init(struct drm_device *dev, 460 struct drm_connector *connector, 461 const struct drm_connector_funcs *funcs, 462 int connector_type) 463{ 464 mutex_lock(&dev->mode_config.mutex); 465 466 connector->dev = dev; 467 connector->funcs = funcs; 468 drm_mode_object_get(dev, &connector->base, DRM_MODE_OBJECT_CONNECTOR); 469 connector->connector_type = connector_type; 470 connector->connector_type_id = 471 ++drm_connector_enum_list[connector_type].count; /* TODO */ 472 INIT_LIST_HEAD(&connector->user_modes); 473 INIT_LIST_HEAD(&connector->probed_modes); 474 INIT_LIST_HEAD(&connector->modes); 475 connector->edid_blob_ptr = NULL; 476 477 list_add_tail(&connector->head, &dev->mode_config.connector_list); 478 dev->mode_config.num_connector++; 479 480 if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL) 481 drm_connector_attach_property(connector, 482 dev->mode_config.edid_property, 483 0); 484 485 drm_connector_attach_property(connector, 486 dev->mode_config.dpms_property, 0); 487 488 mutex_unlock(&dev->mode_config.mutex); 489} 490EXPORT_SYMBOL(drm_connector_init); 491 492/** 493 * drm_connector_cleanup - cleans up an initialised connector 494 * @connector: connector to cleanup 495 * 496 * LOCKING: 497 * Caller must hold @dev's mode_config lock. 498 * 499 * Cleans up the connector but doesn't free the object. 500 */ 501void drm_connector_cleanup(struct drm_connector *connector) 502{ 503 struct drm_device *dev = connector->dev; 504 struct drm_display_mode *mode, *t; 505 506 list_for_each_entry_safe(mode, t, &connector->probed_modes, head) 507 drm_mode_remove(connector, mode); 508 509 list_for_each_entry_safe(mode, t, &connector->modes, head) 510 drm_mode_remove(connector, mode); 511 512 list_for_each_entry_safe(mode, t, &connector->user_modes, head) 513 drm_mode_remove(connector, mode); 514 515 mutex_lock(&dev->mode_config.mutex); 516 drm_mode_object_put(dev, &connector->base); 517 list_del(&connector->head); 518 dev->mode_config.num_connector--; 519 mutex_unlock(&dev->mode_config.mutex); 520} 521EXPORT_SYMBOL(drm_connector_cleanup); 522 523void drm_encoder_init(struct drm_device *dev, 524 struct drm_encoder *encoder, 525 const struct drm_encoder_funcs *funcs, 526 int encoder_type) 527{ 528 mutex_lock(&dev->mode_config.mutex); 529 530 encoder->dev = dev; 531 532 drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER); 533 encoder->encoder_type = encoder_type; 534 encoder->funcs = funcs; 535 536 list_add_tail(&encoder->head, &dev->mode_config.encoder_list); 537 dev->mode_config.num_encoder++; 538 539 mutex_unlock(&dev->mode_config.mutex); 540} 541EXPORT_SYMBOL(drm_encoder_init); 542 543void drm_encoder_cleanup(struct drm_encoder *encoder) 544{ 545 struct drm_device *dev = encoder->dev; 546 mutex_lock(&dev->mode_config.mutex); 547 drm_mode_object_put(dev, &encoder->base); 548 list_del(&encoder->head); 549 dev->mode_config.num_encoder--; 550 mutex_unlock(&dev->mode_config.mutex); 551} 552EXPORT_SYMBOL(drm_encoder_cleanup); 553 554int drm_plane_init(struct drm_device *dev, struct drm_plane *plane, 555 unsigned long possible_crtcs, 556 const struct drm_plane_funcs *funcs, 557 uint32_t *formats, uint32_t format_count) 558{ 559 mutex_lock(&dev->mode_config.mutex); 560 561 plane->dev = dev; 562 drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE); 563 plane->funcs = funcs; 564 plane->format_types = kmalloc(sizeof(uint32_t) * format_count, 565 GFP_KERNEL); 566 if (!plane->format_types) { 567 DRM_DEBUG_KMS("out of memory when allocating plane\n"); 568 drm_mode_object_put(dev, &plane->base); 569 mutex_unlock(&dev->mode_config.mutex); 570 return -ENOMEM; 571 } 572 573 memcpy(plane->format_types, formats, format_count * sizeof(uint32_t)); 574 plane->format_count = format_count; 575 plane->possible_crtcs = possible_crtcs; 576 577 list_add_tail(&plane->head, &dev->mode_config.plane_list); 578 dev->mode_config.num_plane++; 579 580 mutex_unlock(&dev->mode_config.mutex); 581 582 return 0; 583} 584EXPORT_SYMBOL(drm_plane_init); 585 586void drm_plane_cleanup(struct drm_plane *plane) 587{ 588 struct drm_device *dev = plane->dev; 589 590 mutex_lock(&dev->mode_config.mutex); 591 kfree(plane->format_types); 592 drm_mode_object_put(dev, &plane->base); 593 list_del(&plane->head); 594 dev->mode_config.num_plane--; 595 mutex_unlock(&dev->mode_config.mutex); 596} 597EXPORT_SYMBOL(drm_plane_cleanup); 598 599/** 600 * drm_mode_create - create a new display mode 601 * @dev: DRM device 602 * 603 * LOCKING: 604 * Caller must hold DRM mode_config lock. 605 * 606 * Create a new drm_display_mode, give it an ID, and return it. 607 * 608 * RETURNS: 609 * Pointer to new mode on success, NULL on error. 610 */ 611struct drm_display_mode *drm_mode_create(struct drm_device *dev) 612{ 613 struct drm_display_mode *nmode; 614 615 nmode = kzalloc(sizeof(struct drm_display_mode), GFP_KERNEL); 616 if (!nmode) 617 return NULL; 618 619 drm_mode_object_get(dev, &nmode->base, DRM_MODE_OBJECT_MODE); 620 return nmode; 621} 622EXPORT_SYMBOL(drm_mode_create); 623 624/** 625 * drm_mode_destroy - remove a mode 626 * @dev: DRM device 627 * @mode: mode to remove 628 * 629 * LOCKING: 630 * Caller must hold mode config lock. 631 * 632 * Free @mode's unique identifier, then free it. 633 */ 634void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode) 635{ 636 drm_mode_object_put(dev, &mode->base); 637 638 kfree(mode); 639} 640EXPORT_SYMBOL(drm_mode_destroy); 641 642static int drm_mode_create_standard_connector_properties(struct drm_device *dev) 643{ 644 struct drm_property *edid; 645 struct drm_property *dpms; 646 int i; 647 648 /* 649 * Standard properties (apply to all connectors) 650 */ 651 edid = drm_property_create(dev, DRM_MODE_PROP_BLOB | 652 DRM_MODE_PROP_IMMUTABLE, 653 "EDID", 0); 654 dev->mode_config.edid_property = edid; 655 656 dpms = drm_property_create(dev, DRM_MODE_PROP_ENUM, 657 "DPMS", ARRAY_SIZE(drm_dpms_enum_list)); 658 for (i = 0; i < ARRAY_SIZE(drm_dpms_enum_list); i++) 659 drm_property_add_enum(dpms, i, drm_dpms_enum_list[i].type, 660 drm_dpms_enum_list[i].name); 661 dev->mode_config.dpms_property = dpms; 662 663 return 0; 664} 665 666/** 667 * drm_mode_create_dvi_i_properties - create DVI-I specific connector properties 668 * @dev: DRM device 669 * 670 * Called by a driver the first time a DVI-I connector is made. 671 */ 672int drm_mode_create_dvi_i_properties(struct drm_device *dev) 673{ 674 struct drm_property *dvi_i_selector; 675 struct drm_property *dvi_i_subconnector; 676 int i; 677 678 if (dev->mode_config.dvi_i_select_subconnector_property) 679 return 0; 680 681 dvi_i_selector = 682 drm_property_create(dev, DRM_MODE_PROP_ENUM, 683 "select subconnector", 684 ARRAY_SIZE(drm_dvi_i_select_enum_list)); 685 for (i = 0; i < ARRAY_SIZE(drm_dvi_i_select_enum_list); i++) 686 drm_property_add_enum(dvi_i_selector, i, 687 drm_dvi_i_select_enum_list[i].type, 688 drm_dvi_i_select_enum_list[i].name); 689 dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector; 690 691 dvi_i_subconnector = 692 drm_property_create(dev, DRM_MODE_PROP_ENUM | 693 DRM_MODE_PROP_IMMUTABLE, 694 "subconnector", 695 ARRAY_SIZE(drm_dvi_i_subconnector_enum_list)); 696 for (i = 0; i < ARRAY_SIZE(drm_dvi_i_subconnector_enum_list); i++) 697 drm_property_add_enum(dvi_i_subconnector, i, 698 drm_dvi_i_subconnector_enum_list[i].type, 699 drm_dvi_i_subconnector_enum_list[i].name); 700 dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector; 701 702 return 0; 703} 704EXPORT_SYMBOL(drm_mode_create_dvi_i_properties); 705 706/** 707 * drm_create_tv_properties - create TV specific connector properties 708 * @dev: DRM device 709 * @num_modes: number of different TV formats (modes) supported 710 * @modes: array of pointers to strings containing name of each format 711 * 712 * Called by a driver's TV initialization routine, this function creates 713 * the TV specific connector properties for a given device. Caller is 714 * responsible for allocating a list of format names and passing them to 715 * this routine. 716 */ 717int drm_mode_create_tv_properties(struct drm_device *dev, int num_modes, 718 char *modes[]) 719{ 720 struct drm_property *tv_selector; 721 struct drm_property *tv_subconnector; 722 int i; 723 724 if (dev->mode_config.tv_select_subconnector_property) 725 return 0; 726 727 /* 728 * Basic connector properties 729 */ 730 tv_selector = drm_property_create(dev, DRM_MODE_PROP_ENUM, 731 "select subconnector", 732 ARRAY_SIZE(drm_tv_select_enum_list)); 733 for (i = 0; i < ARRAY_SIZE(drm_tv_select_enum_list); i++) 734 drm_property_add_enum(tv_selector, i, 735 drm_tv_select_enum_list[i].type, 736 drm_tv_select_enum_list[i].name); 737 dev->mode_config.tv_select_subconnector_property = tv_selector; 738 739 tv_subconnector = 740 drm_property_create(dev, DRM_MODE_PROP_ENUM | 741 DRM_MODE_PROP_IMMUTABLE, "subconnector", 742 ARRAY_SIZE(drm_tv_subconnector_enum_list)); 743 for (i = 0; i < ARRAY_SIZE(drm_tv_subconnector_enum_list); i++) 744 drm_property_add_enum(tv_subconnector, i, 745 drm_tv_subconnector_enum_list[i].type, 746 drm_tv_subconnector_enum_list[i].name); 747 dev->mode_config.tv_subconnector_property = tv_subconnector; 748 749 /* 750 * Other, TV specific properties: margins & TV modes. 751 */ 752 dev->mode_config.tv_left_margin_property = 753 drm_property_create(dev, DRM_MODE_PROP_RANGE, 754 "left margin", 2); 755 dev->mode_config.tv_left_margin_property->values[0] = 0; 756 dev->mode_config.tv_left_margin_property->values[1] = 100; 757 758 dev->mode_config.tv_right_margin_property = 759 drm_property_create(dev, DRM_MODE_PROP_RANGE, 760 "right margin", 2); 761 dev->mode_config.tv_right_margin_property->values[0] = 0; 762 dev->mode_config.tv_right_margin_property->values[1] = 100; 763 764 dev->mode_config.tv_top_margin_property = 765 drm_property_create(dev, DRM_MODE_PROP_RANGE, 766 "top margin", 2); 767 dev->mode_config.tv_top_margin_property->values[0] = 0; 768 dev->mode_config.tv_top_margin_property->values[1] = 100; 769 770 dev->mode_config.tv_bottom_margin_property = 771 drm_property_create(dev, DRM_MODE_PROP_RANGE, 772 "bottom margin", 2); 773 dev->mode_config.tv_bottom_margin_property->values[0] = 0; 774 dev->mode_config.tv_bottom_margin_property->values[1] = 100; 775 776 dev->mode_config.tv_mode_property = 777 drm_property_create(dev, DRM_MODE_PROP_ENUM, 778 "mode", num_modes); 779 for (i = 0; i < num_modes; i++) 780 drm_property_add_enum(dev->mode_config.tv_mode_property, i, 781 i, modes[i]); 782 783 dev->mode_config.tv_brightness_property = 784 drm_property_create(dev, DRM_MODE_PROP_RANGE, 785 "brightness", 2); 786 dev->mode_config.tv_brightness_property->values[0] = 0; 787 dev->mode_config.tv_brightness_property->values[1] = 100; 788 789 dev->mode_config.tv_contrast_property = 790 drm_property_create(dev, DRM_MODE_PROP_RANGE, 791 "contrast", 2); 792 dev->mode_config.tv_contrast_property->values[0] = 0; 793 dev->mode_config.tv_contrast_property->values[1] = 100; 794 795 dev->mode_config.tv_flicker_reduction_property = 796 drm_property_create(dev, DRM_MODE_PROP_RANGE, 797 "flicker reduction", 2); 798 dev->mode_config.tv_flicker_reduction_property->values[0] = 0; 799 dev->mode_config.tv_flicker_reduction_property->values[1] = 100; 800 801 dev->mode_config.tv_overscan_property = 802 drm_property_create(dev, DRM_MODE_PROP_RANGE, 803 "overscan", 2); 804 dev->mode_config.tv_overscan_property->values[0] = 0; 805 dev->mode_config.tv_overscan_property->values[1] = 100; 806 807 dev->mode_config.tv_saturation_property = 808 drm_property_create(dev, DRM_MODE_PROP_RANGE, 809 "saturation", 2); 810 dev->mode_config.tv_saturation_property->values[0] = 0; 811 dev->mode_config.tv_saturation_property->values[1] = 100; 812 813 dev->mode_config.tv_hue_property = 814 drm_property_create(dev, DRM_MODE_PROP_RANGE, 815 "hue", 2); 816 dev->mode_config.tv_hue_property->values[0] = 0; 817 dev->mode_config.tv_hue_property->values[1] = 100; 818 819 return 0; 820} 821EXPORT_SYMBOL(drm_mode_create_tv_properties); 822 823/** 824 * drm_mode_create_scaling_mode_property - create scaling mode property 825 * @dev: DRM device 826 * 827 * Called by a driver the first time it's needed, must be attached to desired 828 * connectors. 829 */ 830int drm_mode_create_scaling_mode_property(struct drm_device *dev) 831{ 832 struct drm_property *scaling_mode; 833 int i; 834 835 if (dev->mode_config.scaling_mode_property) 836 return 0; 837 838 scaling_mode = 839 drm_property_create(dev, DRM_MODE_PROP_ENUM, "scaling mode", 840 ARRAY_SIZE(drm_scaling_mode_enum_list)); 841 for (i = 0; i < ARRAY_SIZE(drm_scaling_mode_enum_list); i++) 842 drm_property_add_enum(scaling_mode, i, 843 drm_scaling_mode_enum_list[i].type, 844 drm_scaling_mode_enum_list[i].name); 845 846 dev->mode_config.scaling_mode_property = scaling_mode; 847 848 return 0; 849} 850EXPORT_SYMBOL(drm_mode_create_scaling_mode_property); 851 852/** 853 * drm_mode_create_dithering_property - create dithering property 854 * @dev: DRM device 855 * 856 * Called by a driver the first time it's needed, must be attached to desired 857 * connectors. 858 */ 859int drm_mode_create_dithering_property(struct drm_device *dev) 860{ 861 struct drm_property *dithering_mode; 862 int i; 863 864 if (dev->mode_config.dithering_mode_property) 865 return 0; 866 867 dithering_mode = 868 drm_property_create(dev, DRM_MODE_PROP_ENUM, "dithering", 869 ARRAY_SIZE(drm_dithering_mode_enum_list)); 870 for (i = 0; i < ARRAY_SIZE(drm_dithering_mode_enum_list); i++) 871 drm_property_add_enum(dithering_mode, i, 872 drm_dithering_mode_enum_list[i].type, 873 drm_dithering_mode_enum_list[i].name); 874 dev->mode_config.dithering_mode_property = dithering_mode; 875 876 return 0; 877} 878EXPORT_SYMBOL(drm_mode_create_dithering_property); 879 880/** 881 * drm_mode_create_dirty_property - create dirty property 882 * @dev: DRM device 883 * 884 * Called by a driver the first time it's needed, must be attached to desired 885 * connectors. 886 */ 887int drm_mode_create_dirty_info_property(struct drm_device *dev) 888{ 889 struct drm_property *dirty_info; 890 int i; 891 892 if (dev->mode_config.dirty_info_property) 893 return 0; 894 895 dirty_info = 896 drm_property_create(dev, DRM_MODE_PROP_ENUM | 897 DRM_MODE_PROP_IMMUTABLE, 898 "dirty", 899 ARRAY_SIZE(drm_dirty_info_enum_list)); 900 for (i = 0; i < ARRAY_SIZE(drm_dirty_info_enum_list); i++) 901 drm_property_add_enum(dirty_info, i, 902 drm_dirty_info_enum_list[i].type, 903 drm_dirty_info_enum_list[i].name); 904 dev->mode_config.dirty_info_property = dirty_info; 905 906 return 0; 907} 908EXPORT_SYMBOL(drm_mode_create_dirty_info_property); 909 910/** 911 * drm_mode_config_init - initialize DRM mode_configuration structure 912 * @dev: DRM device 913 * 914 * LOCKING: 915 * None, should happen single threaded at init time. 916 * 917 * Initialize @dev's mode_config structure, used for tracking the graphics 918 * configuration of @dev. 919 */ 920void drm_mode_config_init(struct drm_device *dev) 921{ 922 mutex_init(&dev->mode_config.mutex); 923 mutex_init(&dev->mode_config.idr_mutex); 924 INIT_LIST_HEAD(&dev->mode_config.fb_list); 925 INIT_LIST_HEAD(&dev->mode_config.crtc_list); 926 INIT_LIST_HEAD(&dev->mode_config.connector_list); 927 INIT_LIST_HEAD(&dev->mode_config.encoder_list); 928 INIT_LIST_HEAD(&dev->mode_config.property_list); 929 INIT_LIST_HEAD(&dev->mode_config.property_blob_list); 930 INIT_LIST_HEAD(&dev->mode_config.plane_list); 931 idr_init(&dev->mode_config.crtc_idr); 932 933 mutex_lock(&dev->mode_config.mutex); 934 drm_mode_create_standard_connector_properties(dev); 935 mutex_unlock(&dev->mode_config.mutex); 936 937 /* Just to be sure */ 938 dev->mode_config.num_fb = 0; 939 dev->mode_config.num_connector = 0; 940 dev->mode_config.num_crtc = 0; 941 dev->mode_config.num_encoder = 0; 942} 943EXPORT_SYMBOL(drm_mode_config_init); 944 945int drm_mode_group_init(struct drm_device *dev, struct drm_mode_group *group) 946{ 947 uint32_t total_objects = 0; 948 949 total_objects += dev->mode_config.num_crtc; 950 total_objects += dev->mode_config.num_connector; 951 total_objects += dev->mode_config.num_encoder; 952 953 group->id_list = kzalloc(total_objects * sizeof(uint32_t), GFP_KERNEL); 954 if (!group->id_list) 955 return -ENOMEM; 956 957 group->num_crtcs = 0; 958 group->num_connectors = 0; 959 group->num_encoders = 0; 960 return 0; 961} 962 963int drm_mode_group_init_legacy_group(struct drm_device *dev, 964 struct drm_mode_group *group) 965{ 966 struct drm_crtc *crtc; 967 struct drm_encoder *encoder; 968 struct drm_connector *connector; 969 int ret; 970 971 if ((ret = drm_mode_group_init(dev, group))) 972 return ret; 973 974 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) 975 group->id_list[group->num_crtcs++] = crtc->base.id; 976 977 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) 978 group->id_list[group->num_crtcs + group->num_encoders++] = 979 encoder->base.id; 980 981 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 982 group->id_list[group->num_crtcs + group->num_encoders + 983 group->num_connectors++] = connector->base.id; 984 985 return 0; 986} 987 988/** 989 * drm_mode_config_cleanup - free up DRM mode_config info 990 * @dev: DRM device 991 * 992 * LOCKING: 993 * Caller must hold mode config lock. 994 * 995 * Free up all the connectors and CRTCs associated with this DRM device, then 996 * free up the framebuffers and associated buffer objects. 997 * 998 * FIXME: cleanup any dangling user buffer objects too 999 */ 1000void drm_mode_config_cleanup(struct drm_device *dev) 1001{ 1002 struct drm_connector *connector, *ot; 1003 struct drm_crtc *crtc, *ct; 1004 struct drm_encoder *encoder, *enct; 1005 struct drm_framebuffer *fb, *fbt; 1006 struct drm_property *property, *pt; 1007 struct drm_plane *plane, *plt; 1008 1009 list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list, 1010 head) { 1011 encoder->funcs->destroy(encoder); 1012 } 1013 1014 list_for_each_entry_safe(connector, ot, 1015 &dev->mode_config.connector_list, head) { 1016 connector->funcs->destroy(connector); 1017 } 1018 1019 list_for_each_entry_safe(property, pt, &dev->mode_config.property_list, 1020 head) { 1021 drm_property_destroy(dev, property); 1022 } 1023 1024 list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) { 1025 fb->funcs->destroy(fb); 1026 } 1027 1028 list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) { 1029 crtc->funcs->destroy(crtc); 1030 } 1031 1032 list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list, 1033 head) { 1034 plane->funcs->destroy(plane); 1035 } 1036} 1037EXPORT_SYMBOL(drm_mode_config_cleanup); 1038 1039/** 1040 * drm_crtc_convert_to_umode - convert a drm_display_mode into a modeinfo 1041 * @out: drm_mode_modeinfo struct to return to the user 1042 * @in: drm_display_mode to use 1043 * 1044 * LOCKING: 1045 * None. 1046 * 1047 * Convert a drm_display_mode into a drm_mode_modeinfo structure to return to 1048 * the user. 1049 */ 1050void drm_crtc_convert_to_umode(struct drm_mode_modeinfo *out, 1051 struct drm_display_mode *in) 1052{ 1053 out->clock = in->clock; 1054 out->hdisplay = in->hdisplay; 1055 out->hsync_start = in->hsync_start; 1056 out->hsync_end = in->hsync_end; 1057 out->htotal = in->htotal; 1058 out->hskew = in->hskew; 1059 out->vdisplay = in->vdisplay; 1060 out->vsync_start = in->vsync_start; 1061 out->vsync_end = in->vsync_end; 1062 out->vtotal = in->vtotal; 1063 out->vscan = in->vscan; 1064 out->vrefresh = in->vrefresh; 1065 out->flags = in->flags; 1066 out->type = in->type; 1067 strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN); 1068 out->name[DRM_DISPLAY_MODE_LEN-1] = 0; 1069} 1070 1071/** 1072 * drm_crtc_convert_to_umode - convert a modeinfo into a drm_display_mode 1073 * @out: drm_display_mode to return to the user 1074 * @in: drm_mode_modeinfo to use 1075 * 1076 * LOCKING: 1077 * None. 1078 * 1079 * Convert a drm_mode_modeinfo into a drm_display_mode structure to return to 1080 * the caller. 1081 */ 1082void drm_crtc_convert_umode(struct drm_display_mode *out, 1083 struct drm_mode_modeinfo *in) 1084{ 1085 out->clock = in->clock; 1086 out->hdisplay = in->hdisplay; 1087 out->hsync_start = in->hsync_start; 1088 out->hsync_end = in->hsync_end; 1089 out->htotal = in->htotal; 1090 out->hskew = in->hskew; 1091 out->vdisplay = in->vdisplay; 1092 out->vsync_start = in->vsync_start; 1093 out->vsync_end = in->vsync_end; 1094 out->vtotal = in->vtotal; 1095 out->vscan = in->vscan; 1096 out->vrefresh = in->vrefresh; 1097 out->flags = in->flags; 1098 out->type = in->type; 1099 strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN); 1100 out->name[DRM_DISPLAY_MODE_LEN-1] = 0; 1101} 1102 1103/** 1104 * drm_mode_getresources - get graphics configuration 1105 * @inode: inode from the ioctl 1106 * @filp: file * from the ioctl 1107 * @cmd: cmd from ioctl 1108 * @arg: arg from ioctl 1109 * 1110 * LOCKING: 1111 * Takes mode config lock. 1112 * 1113 * Construct a set of configuration description structures and return 1114 * them to the user, including CRTC, connector and framebuffer configuration. 1115 * 1116 * Called by the user via ioctl. 1117 * 1118 * RETURNS: 1119 * Zero on success, errno on failure. 1120 */ 1121int drm_mode_getresources(struct drm_device *dev, void *data, 1122 struct drm_file *file_priv) 1123{ 1124 struct drm_mode_card_res *card_res = data; 1125 struct list_head *lh; 1126 struct drm_framebuffer *fb; 1127 struct drm_connector *connector; 1128 struct drm_crtc *crtc; 1129 struct drm_encoder *encoder; 1130 int ret = 0; 1131 int connector_count = 0; 1132 int crtc_count = 0; 1133 int fb_count = 0; 1134 int encoder_count = 0; 1135 int copied = 0, i; 1136 uint32_t __user *fb_id; 1137 uint32_t __user *crtc_id; 1138 uint32_t __user *connector_id; 1139 uint32_t __user *encoder_id; 1140 struct drm_mode_group *mode_group; 1141 1142 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1143 return -EINVAL; 1144 1145 mutex_lock(&dev->mode_config.mutex); 1146 1147 /* 1148 * For the non-control nodes we need to limit the list of resources 1149 * by IDs in the group list for this node 1150 */ 1151 list_for_each(lh, &file_priv->fbs) 1152 fb_count++; 1153 1154 mode_group = &file_priv->master->minor->mode_group; 1155 if (file_priv->master->minor->type == DRM_MINOR_CONTROL) { 1156 1157 list_for_each(lh, &dev->mode_config.crtc_list) 1158 crtc_count++; 1159 1160 list_for_each(lh, &dev->mode_config.connector_list) 1161 connector_count++; 1162 1163 list_for_each(lh, &dev->mode_config.encoder_list) 1164 encoder_count++; 1165 } else { 1166 1167 crtc_count = mode_group->num_crtcs; 1168 connector_count = mode_group->num_connectors; 1169 encoder_count = mode_group->num_encoders; 1170 } 1171 1172 card_res->max_height = dev->mode_config.max_height; 1173 card_res->min_height = dev->mode_config.min_height; 1174 card_res->max_width = dev->mode_config.max_width; 1175 card_res->min_width = dev->mode_config.min_width; 1176 1177 /* handle this in 4 parts */ 1178 /* FBs */ 1179 if (card_res->count_fbs >= fb_count) { 1180 copied = 0; 1181 fb_id = (uint32_t __user *)(unsigned long)card_res->fb_id_ptr; 1182 list_for_each_entry(fb, &file_priv->fbs, filp_head) { 1183 if (put_user(fb->base.id, fb_id + copied)) { 1184 ret = -EFAULT; 1185 goto out; 1186 } 1187 copied++; 1188 } 1189 } 1190 card_res->count_fbs = fb_count; 1191 1192 /* CRTCs */ 1193 if (card_res->count_crtcs >= crtc_count) { 1194 copied = 0; 1195 crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr; 1196 if (file_priv->master->minor->type == DRM_MINOR_CONTROL) { 1197 list_for_each_entry(crtc, &dev->mode_config.crtc_list, 1198 head) { 1199 DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id); 1200 if (put_user(crtc->base.id, crtc_id + copied)) { 1201 ret = -EFAULT; 1202 goto out; 1203 } 1204 copied++; 1205 } 1206 } else { 1207 for (i = 0; i < mode_group->num_crtcs; i++) { 1208 if (put_user(mode_group->id_list[i], 1209 crtc_id + copied)) { 1210 ret = -EFAULT; 1211 goto out; 1212 } 1213 copied++; 1214 } 1215 } 1216 } 1217 card_res->count_crtcs = crtc_count; 1218 1219 /* Encoders */ 1220 if (card_res->count_encoders >= encoder_count) { 1221 copied = 0; 1222 encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr; 1223 if (file_priv->master->minor->type == DRM_MINOR_CONTROL) { 1224 list_for_each_entry(encoder, 1225 &dev->mode_config.encoder_list, 1226 head) { 1227 DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id, 1228 drm_get_encoder_name(encoder)); 1229 if (put_user(encoder->base.id, encoder_id + 1230 copied)) { 1231 ret = -EFAULT; 1232 goto out; 1233 } 1234 copied++; 1235 } 1236 } else { 1237 for (i = mode_group->num_crtcs; i < mode_group->num_crtcs + mode_group->num_encoders; i++) { 1238 if (put_user(mode_group->id_list[i], 1239 encoder_id + copied)) { 1240 ret = -EFAULT; 1241 goto out; 1242 } 1243 copied++; 1244 } 1245 1246 } 1247 } 1248 card_res->count_encoders = encoder_count; 1249 1250 /* Connectors */ 1251 if (card_res->count_connectors >= connector_count) { 1252 copied = 0; 1253 connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr; 1254 if (file_priv->master->minor->type == DRM_MINOR_CONTROL) { 1255 list_for_each_entry(connector, 1256 &dev->mode_config.connector_list, 1257 head) { 1258 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", 1259 connector->base.id, 1260 drm_get_connector_name(connector)); 1261 if (put_user(connector->base.id, 1262 connector_id + copied)) { 1263 ret = -EFAULT; 1264 goto out; 1265 } 1266 copied++; 1267 } 1268 } else { 1269 int start = mode_group->num_crtcs + 1270 mode_group->num_encoders; 1271 for (i = start; i < start + mode_group->num_connectors; i++) { 1272 if (put_user(mode_group->id_list[i], 1273 connector_id + copied)) { 1274 ret = -EFAULT; 1275 goto out; 1276 } 1277 copied++; 1278 } 1279 } 1280 } 1281 card_res->count_connectors = connector_count; 1282 1283 DRM_DEBUG_KMS("CRTC[%d] CONNECTORS[%d] ENCODERS[%d]\n", card_res->count_crtcs, 1284 card_res->count_connectors, card_res->count_encoders); 1285 1286out: 1287 mutex_unlock(&dev->mode_config.mutex); 1288 return ret; 1289} 1290 1291/** 1292 * drm_mode_getcrtc - get CRTC configuration 1293 * @inode: inode from the ioctl 1294 * @filp: file * from the ioctl 1295 * @cmd: cmd from ioctl 1296 * @arg: arg from ioctl 1297 * 1298 * LOCKING: 1299 * Caller? (FIXME) 1300 * 1301 * Construct a CRTC configuration structure to return to the user. 1302 * 1303 * Called by the user via ioctl. 1304 * 1305 * RETURNS: 1306 * Zero on success, errno on failure. 1307 */ 1308int drm_mode_getcrtc(struct drm_device *dev, 1309 void *data, struct drm_file *file_priv) 1310{ 1311 struct drm_mode_crtc *crtc_resp = data; 1312 struct drm_crtc *crtc; 1313 struct drm_mode_object *obj; 1314 int ret = 0; 1315 1316 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1317 return -EINVAL; 1318 1319 mutex_lock(&dev->mode_config.mutex); 1320 1321 obj = drm_mode_object_find(dev, crtc_resp->crtc_id, 1322 DRM_MODE_OBJECT_CRTC); 1323 if (!obj) { 1324 ret = -EINVAL; 1325 goto out; 1326 } 1327 crtc = obj_to_crtc(obj); 1328 1329 crtc_resp->x = crtc->x; 1330 crtc_resp->y = crtc->y; 1331 crtc_resp->gamma_size = crtc->gamma_size; 1332 if (crtc->fb) 1333 crtc_resp->fb_id = crtc->fb->base.id; 1334 else 1335 crtc_resp->fb_id = 0; 1336 1337 if (crtc->enabled) { 1338 1339 drm_crtc_convert_to_umode(&crtc_resp->mode, &crtc->mode); 1340 crtc_resp->mode_valid = 1; 1341 1342 } else { 1343 crtc_resp->mode_valid = 0; 1344 } 1345 1346out: 1347 mutex_unlock(&dev->mode_config.mutex); 1348 return ret; 1349} 1350 1351/** 1352 * drm_mode_getconnector - get connector configuration 1353 * @inode: inode from the ioctl 1354 * @filp: file * from the ioctl 1355 * @cmd: cmd from ioctl 1356 * @arg: arg from ioctl 1357 * 1358 * LOCKING: 1359 * Caller? (FIXME) 1360 * 1361 * Construct a connector configuration structure to return to the user. 1362 * 1363 * Called by the user via ioctl. 1364 * 1365 * RETURNS: 1366 * Zero on success, errno on failure. 1367 */ 1368int drm_mode_getconnector(struct drm_device *dev, void *data, 1369 struct drm_file *file_priv) 1370{ 1371 struct drm_mode_get_connector *out_resp = data; 1372 struct drm_mode_object *obj; 1373 struct drm_connector *connector; 1374 struct drm_display_mode *mode; 1375 int mode_count = 0; 1376 int props_count = 0; 1377 int encoders_count = 0; 1378 int ret = 0; 1379 int copied = 0; 1380 int i; 1381 struct drm_mode_modeinfo u_mode; 1382 struct drm_mode_modeinfo __user *mode_ptr; 1383 uint32_t __user *prop_ptr; 1384 uint64_t __user *prop_values; 1385 uint32_t __user *encoder_ptr; 1386 1387 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1388 return -EINVAL; 1389 1390 memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo)); 1391 1392 DRM_DEBUG_KMS("[CONNECTOR:%d:?]\n", out_resp->connector_id); 1393 1394 mutex_lock(&dev->mode_config.mutex); 1395 1396 obj = drm_mode_object_find(dev, out_resp->connector_id, 1397 DRM_MODE_OBJECT_CONNECTOR); 1398 if (!obj) { 1399 ret = -EINVAL; 1400 goto out; 1401 } 1402 connector = obj_to_connector(obj); 1403 1404 for (i = 0; i < DRM_CONNECTOR_MAX_PROPERTY; i++) { 1405 if (connector->property_ids[i] != 0) { 1406 props_count++; 1407 } 1408 } 1409 1410 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 1411 if (connector->encoder_ids[i] != 0) { 1412 encoders_count++; 1413 } 1414 } 1415 1416 if (out_resp->count_modes == 0) { 1417 connector->funcs->fill_modes(connector, 1418 dev->mode_config.max_width, 1419 dev->mode_config.max_height); 1420 } 1421 1422 /* delayed so we get modes regardless of pre-fill_modes state */ 1423 list_for_each_entry(mode, &connector->modes, head) 1424 mode_count++; 1425 1426 out_resp->connector_id = connector->base.id; 1427 out_resp->connector_type = connector->connector_type; 1428 out_resp->connector_type_id = connector->connector_type_id; 1429 out_resp->mm_width = connector->display_info.width_mm; 1430 out_resp->mm_height = connector->display_info.height_mm; 1431 out_resp->subpixel = connector->display_info.subpixel_order; 1432 out_resp->connection = connector->status; 1433 if (connector->encoder) 1434 out_resp->encoder_id = connector->encoder->base.id; 1435 else 1436 out_resp->encoder_id = 0; 1437 1438 /* 1439 * This ioctl is called twice, once to determine how much space is 1440 * needed, and the 2nd time to fill it. 1441 */ 1442 if ((out_resp->count_modes >= mode_count) && mode_count) { 1443 copied = 0; 1444 mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr; 1445 list_for_each_entry(mode, &connector->modes, head) { 1446 drm_crtc_convert_to_umode(&u_mode, mode); 1447 if (copy_to_user(mode_ptr + copied, 1448 &u_mode, sizeof(u_mode))) { 1449 ret = -EFAULT; 1450 goto out; 1451 } 1452 copied++; 1453 } 1454 } 1455 out_resp->count_modes = mode_count; 1456 1457 if ((out_resp->count_props >= props_count) && props_count) { 1458 copied = 0; 1459 prop_ptr = (uint32_t __user *)(unsigned long)(out_resp->props_ptr); 1460 prop_values = (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr); 1461 for (i = 0; i < DRM_CONNECTOR_MAX_PROPERTY; i++) { 1462 if (connector->property_ids[i] != 0) { 1463 if (put_user(connector->property_ids[i], 1464 prop_ptr + copied)) { 1465 ret = -EFAULT; 1466 goto out; 1467 } 1468 1469 if (put_user(connector->property_values[i], 1470 prop_values + copied)) { 1471 ret = -EFAULT; 1472 goto out; 1473 } 1474 copied++; 1475 } 1476 } 1477 } 1478 out_resp->count_props = props_count; 1479 1480 if ((out_resp->count_encoders >= encoders_count) && encoders_count) { 1481 copied = 0; 1482 encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr); 1483 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 1484 if (connector->encoder_ids[i] != 0) { 1485 if (put_user(connector->encoder_ids[i], 1486 encoder_ptr + copied)) { 1487 ret = -EFAULT; 1488 goto out; 1489 } 1490 copied++; 1491 } 1492 } 1493 } 1494 out_resp->count_encoders = encoders_count; 1495 1496out: 1497 mutex_unlock(&dev->mode_config.mutex); 1498 return ret; 1499} 1500 1501int drm_mode_getencoder(struct drm_device *dev, void *data, 1502 struct drm_file *file_priv) 1503{ 1504 struct drm_mode_get_encoder *enc_resp = data; 1505 struct drm_mode_object *obj; 1506 struct drm_encoder *encoder; 1507 int ret = 0; 1508 1509 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1510 return -EINVAL; 1511 1512 mutex_lock(&dev->mode_config.mutex); 1513 obj = drm_mode_object_find(dev, enc_resp->encoder_id, 1514 DRM_MODE_OBJECT_ENCODER); 1515 if (!obj) { 1516 ret = -EINVAL; 1517 goto out; 1518 } 1519 encoder = obj_to_encoder(obj); 1520 1521 if (encoder->crtc) 1522 enc_resp->crtc_id = encoder->crtc->base.id; 1523 else 1524 enc_resp->crtc_id = 0; 1525 enc_resp->encoder_type = encoder->encoder_type; 1526 enc_resp->encoder_id = encoder->base.id; 1527 enc_resp->possible_crtcs = encoder->possible_crtcs; 1528 enc_resp->possible_clones = encoder->possible_clones; 1529 1530out: 1531 mutex_unlock(&dev->mode_config.mutex); 1532 return ret; 1533} 1534 1535/** 1536 * drm_mode_getplane_res - get plane info 1537 * @dev: DRM device 1538 * @data: ioctl data 1539 * @file_priv: DRM file info 1540 * 1541 * Return an plane count and set of IDs. 1542 */ 1543int drm_mode_getplane_res(struct drm_device *dev, void *data, 1544 struct drm_file *file_priv) 1545{ 1546 struct drm_mode_get_plane_res *plane_resp = data; 1547 struct drm_mode_config *config; 1548 struct drm_plane *plane; 1549 uint32_t __user *plane_ptr; 1550 int copied = 0, ret = 0; 1551 1552 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1553 return -EINVAL; 1554 1555 mutex_lock(&dev->mode_config.mutex); 1556 config = &dev->mode_config; 1557 1558 /* 1559 * This ioctl is called twice, once to determine how much space is 1560 * needed, and the 2nd time to fill it. 1561 */ 1562 if (config->num_plane && 1563 (plane_resp->count_planes >= config->num_plane)) { 1564 plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr; 1565 1566 list_for_each_entry(plane, &config->plane_list, head) { 1567 if (put_user(plane->base.id, plane_ptr + copied)) { 1568 ret = -EFAULT; 1569 goto out; 1570 } 1571 copied++; 1572 } 1573 } 1574 plane_resp->count_planes = config->num_plane; 1575 1576out: 1577 mutex_unlock(&dev->mode_config.mutex); 1578 return ret; 1579} 1580 1581/** 1582 * drm_mode_getplane - get plane info 1583 * @dev: DRM device 1584 * @data: ioctl data 1585 * @file_priv: DRM file info 1586 * 1587 * Return plane info, including formats supported, gamma size, any 1588 * current fb, etc. 1589 */ 1590int drm_mode_getplane(struct drm_device *dev, void *data, 1591 struct drm_file *file_priv) 1592{ 1593 struct drm_mode_get_plane *plane_resp = data; 1594 struct drm_mode_object *obj; 1595 struct drm_plane *plane; 1596 uint32_t __user *format_ptr; 1597 int ret = 0; 1598 1599 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1600 return -EINVAL; 1601 1602 mutex_lock(&dev->mode_config.mutex); 1603 obj = drm_mode_object_find(dev, plane_resp->plane_id, 1604 DRM_MODE_OBJECT_PLANE); 1605 if (!obj) { 1606 ret = -ENOENT; 1607 goto out; 1608 } 1609 plane = obj_to_plane(obj); 1610 1611 if (plane->crtc) 1612 plane_resp->crtc_id = plane->crtc->base.id; 1613 else 1614 plane_resp->crtc_id = 0; 1615 1616 if (plane->fb) 1617 plane_resp->fb_id = plane->fb->base.id; 1618 else 1619 plane_resp->fb_id = 0; 1620 1621 plane_resp->plane_id = plane->base.id; 1622 plane_resp->possible_crtcs = plane->possible_crtcs; 1623 plane_resp->gamma_size = plane->gamma_size; 1624 1625 /* 1626 * This ioctl is called twice, once to determine how much space is 1627 * needed, and the 2nd time to fill it. 1628 */ 1629 if (plane->format_count && 1630 (plane_resp->count_format_types >= plane->format_count)) { 1631 format_ptr = (uint32_t __user *)(unsigned long)plane_resp->format_type_ptr; 1632 if (copy_to_user(format_ptr, 1633 plane->format_types, 1634 sizeof(uint32_t) * plane->format_count)) { 1635 ret = -EFAULT; 1636 goto out; 1637 } 1638 } 1639 plane_resp->count_format_types = plane->format_count; 1640 1641out: 1642 mutex_unlock(&dev->mode_config.mutex); 1643 return ret; 1644} 1645 1646/** 1647 * drm_mode_setplane - set up or tear down an plane 1648 * @dev: DRM device 1649 * @data: ioctl data* 1650 * @file_prive: DRM file info 1651 * 1652 * Set plane info, including placement, fb, scaling, and other factors. 1653 * Or pass a NULL fb to disable. 1654 */ 1655int drm_mode_setplane(struct drm_device *dev, void *data, 1656 struct drm_file *file_priv) 1657{ 1658 struct drm_mode_set_plane *plane_req = data; 1659 struct drm_mode_object *obj; 1660 struct drm_plane *plane; 1661 struct drm_crtc *crtc; 1662 struct drm_framebuffer *fb; 1663 int ret = 0; 1664 1665 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1666 return -EINVAL; 1667 1668 mutex_lock(&dev->mode_config.mutex); 1669 1670 /* 1671 * First, find the plane, crtc, and fb objects. If not available, 1672 * we don't bother to call the driver. 1673 */ 1674 obj = drm_mode_object_find(dev, plane_req->plane_id, 1675 DRM_MODE_OBJECT_PLANE); 1676 if (!obj) { 1677 DRM_DEBUG_KMS("Unknown plane ID %d\n", 1678 plane_req->plane_id); 1679 ret = -ENOENT; 1680 goto out; 1681 } 1682 plane = obj_to_plane(obj); 1683 1684 /* No fb means shut it down */ 1685 if (!plane_req->fb_id) { 1686 plane->funcs->disable_plane(plane); 1687 plane->crtc = NULL; 1688 plane->fb = NULL; 1689 goto out; 1690 } 1691 1692 obj = drm_mode_object_find(dev, plane_req->crtc_id, 1693 DRM_MODE_OBJECT_CRTC); 1694 if (!obj) { 1695 DRM_DEBUG_KMS("Unknown crtc ID %d\n", 1696 plane_req->crtc_id); 1697 ret = -ENOENT; 1698 goto out; 1699 } 1700 crtc = obj_to_crtc(obj); 1701 1702 obj = drm_mode_object_find(dev, plane_req->fb_id, 1703 DRM_MODE_OBJECT_FB); 1704 if (!obj) { 1705 DRM_DEBUG_KMS("Unknown framebuffer ID %d\n", 1706 plane_req->fb_id); 1707 ret = -ENOENT; 1708 goto out; 1709 } 1710 fb = obj_to_fb(obj); 1711 1712 ret = plane->funcs->update_plane(plane, crtc, fb, 1713 plane_req->crtc_x, plane_req->crtc_y, 1714 plane_req->crtc_w, plane_req->crtc_h, 1715 plane_req->src_x, plane_req->src_y, 1716 plane_req->src_w, plane_req->src_h); 1717 if (!ret) { 1718 plane->crtc = crtc; 1719 plane->fb = fb; 1720 } 1721 1722out: 1723 mutex_unlock(&dev->mode_config.mutex); 1724 1725 return ret; 1726} 1727 1728/** 1729 * drm_mode_setcrtc - set CRTC configuration 1730 * @inode: inode from the ioctl 1731 * @filp: file * from the ioctl 1732 * @cmd: cmd from ioctl 1733 * @arg: arg from ioctl 1734 * 1735 * LOCKING: 1736 * Caller? (FIXME) 1737 * 1738 * Build a new CRTC configuration based on user request. 1739 * 1740 * Called by the user via ioctl. 1741 * 1742 * RETURNS: 1743 * Zero on success, errno on failure. 1744 */ 1745int drm_mode_setcrtc(struct drm_device *dev, void *data, 1746 struct drm_file *file_priv) 1747{ 1748 struct drm_mode_config *config = &dev->mode_config; 1749 struct drm_mode_crtc *crtc_req = data; 1750 struct drm_mode_object *obj; 1751 struct drm_crtc *crtc, *crtcfb; 1752 struct drm_connector **connector_set = NULL, *connector; 1753 struct drm_framebuffer *fb = NULL; 1754 struct drm_display_mode *mode = NULL; 1755 struct drm_mode_set set; 1756 uint32_t __user *set_connectors_ptr; 1757 int ret = 0; 1758 int i; 1759 1760 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1761 return -EINVAL; 1762 1763 mutex_lock(&dev->mode_config.mutex); 1764 obj = drm_mode_object_find(dev, crtc_req->crtc_id, 1765 DRM_MODE_OBJECT_CRTC); 1766 if (!obj) { 1767 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id); 1768 ret = -EINVAL; 1769 goto out; 1770 } 1771 crtc = obj_to_crtc(obj); 1772 DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id); 1773 1774 if (crtc_req->mode_valid) { 1775 /* If we have a mode we need a framebuffer. */ 1776 /* If we pass -1, set the mode with the currently bound fb */ 1777 if (crtc_req->fb_id == -1) { 1778 list_for_each_entry(crtcfb, 1779 &dev->mode_config.crtc_list, head) { 1780 if (crtcfb == crtc) { 1781 DRM_DEBUG_KMS("Using current fb for " 1782 "setmode\n"); 1783 fb = crtc->fb; 1784 } 1785 } 1786 } else { 1787 obj = drm_mode_object_find(dev, crtc_req->fb_id, 1788 DRM_MODE_OBJECT_FB); 1789 if (!obj) { 1790 DRM_DEBUG_KMS("Unknown FB ID%d\n", 1791 crtc_req->fb_id); 1792 ret = -EINVAL; 1793 goto out; 1794 } 1795 fb = obj_to_fb(obj); 1796 } 1797 1798 mode = drm_mode_create(dev); 1799 drm_crtc_convert_umode(mode, &crtc_req->mode); 1800 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V); 1801 } 1802 1803 if (crtc_req->count_connectors == 0 && mode) { 1804 DRM_DEBUG_KMS("Count connectors is 0 but mode set\n"); 1805 ret = -EINVAL; 1806 goto out; 1807 } 1808 1809 if (crtc_req->count_connectors > 0 && (!mode || !fb)) { 1810 DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n", 1811 crtc_req->count_connectors); 1812 ret = -EINVAL; 1813 goto out; 1814 } 1815 1816 if (crtc_req->count_connectors > 0) { 1817 u32 out_id; 1818 1819 /* Avoid unbounded kernel memory allocation */ 1820 if (crtc_req->count_connectors > config->num_connector) { 1821 ret = -EINVAL; 1822 goto out; 1823 } 1824 1825 connector_set = kmalloc(crtc_req->count_connectors * 1826 sizeof(struct drm_connector *), 1827 GFP_KERNEL); 1828 if (!connector_set) { 1829 ret = -ENOMEM; 1830 goto out; 1831 } 1832 1833 for (i = 0; i < crtc_req->count_connectors; i++) { 1834 set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr; 1835 if (get_user(out_id, &set_connectors_ptr[i])) { 1836 ret = -EFAULT; 1837 goto out; 1838 } 1839 1840 obj = drm_mode_object_find(dev, out_id, 1841 DRM_MODE_OBJECT_CONNECTOR); 1842 if (!obj) { 1843 DRM_DEBUG_KMS("Connector id %d unknown\n", 1844 out_id); 1845 ret = -EINVAL; 1846 goto out; 1847 } 1848 connector = obj_to_connector(obj); 1849 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", 1850 connector->base.id, 1851 drm_get_connector_name(connector)); 1852 1853 connector_set[i] = connector; 1854 } 1855 } 1856 1857 set.crtc = crtc; 1858 set.x = crtc_req->x; 1859 set.y = crtc_req->y; 1860 set.mode = mode; 1861 set.connectors = connector_set; 1862 set.num_connectors = crtc_req->count_connectors; 1863 set.fb = fb; 1864 ret = crtc->funcs->set_config(&set); 1865 1866out: 1867 kfree(connector_set); 1868 mutex_unlock(&dev->mode_config.mutex); 1869 return ret; 1870} 1871 1872int drm_mode_cursor_ioctl(struct drm_device *dev, 1873 void *data, struct drm_file *file_priv) 1874{ 1875 struct drm_mode_cursor *req = data; 1876 struct drm_mode_object *obj; 1877 struct drm_crtc *crtc; 1878 int ret = 0; 1879 1880 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1881 return -EINVAL; 1882 1883 if (!req->flags) 1884 return -EINVAL; 1885 1886 mutex_lock(&dev->mode_config.mutex); 1887 obj = drm_mode_object_find(dev, req->crtc_id, DRM_MODE_OBJECT_CRTC); 1888 if (!obj) { 1889 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id); 1890 ret = -EINVAL; 1891 goto out; 1892 } 1893 crtc = obj_to_crtc(obj); 1894 1895 if (req->flags & DRM_MODE_CURSOR_BO) { 1896 if (!crtc->funcs->cursor_set) { 1897 ret = -ENXIO; 1898 goto out; 1899 } 1900 /* Turns off the cursor if handle is 0 */ 1901 ret = crtc->funcs->cursor_set(crtc, file_priv, req->handle, 1902 req->width, req->height); 1903 } 1904 1905 if (req->flags & DRM_MODE_CURSOR_MOVE) { 1906 if (crtc->funcs->cursor_move) { 1907 ret = crtc->funcs->cursor_move(crtc, req->x, req->y); 1908 } else { 1909 ret = -EFAULT; 1910 goto out; 1911 } 1912 } 1913out: 1914 mutex_unlock(&dev->mode_config.mutex); 1915 return ret; 1916} 1917 1918/* Original addfb only supported RGB formats, so figure out which one */ 1919uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth) 1920{ 1921 uint32_t fmt; 1922 1923 switch (bpp) { 1924 case 8: 1925 fmt = DRM_FORMAT_RGB332; 1926 break; 1927 case 16: 1928 if (depth == 15) 1929 fmt = DRM_FORMAT_XRGB1555; 1930 else 1931 fmt = DRM_FORMAT_RGB565; 1932 break; 1933 case 24: 1934 fmt = DRM_FORMAT_RGB888; 1935 break; 1936 case 32: 1937 if (depth == 24) 1938 fmt = DRM_FORMAT_XRGB8888; 1939 else if (depth == 30) 1940 fmt = DRM_FORMAT_XRGB2101010; 1941 else 1942 fmt = DRM_FORMAT_ARGB8888; 1943 break; 1944 default: 1945 DRM_ERROR("bad bpp, assuming x8r8g8b8 pixel format\n"); 1946 fmt = DRM_FORMAT_XRGB8888; 1947 break; 1948 } 1949 1950 return fmt; 1951} 1952EXPORT_SYMBOL(drm_mode_legacy_fb_format); 1953 1954/** 1955 * drm_mode_addfb - add an FB to the graphics configuration 1956 * @inode: inode from the ioctl 1957 * @filp: file * from the ioctl 1958 * @cmd: cmd from ioctl 1959 * @arg: arg from ioctl 1960 * 1961 * LOCKING: 1962 * Takes mode config lock. 1963 * 1964 * Add a new FB to the specified CRTC, given a user request. 1965 * 1966 * Called by the user via ioctl. 1967 * 1968 * RETURNS: 1969 * Zero on success, errno on failure. 1970 */ 1971int drm_mode_addfb(struct drm_device *dev, 1972 void *data, struct drm_file *file_priv) 1973{ 1974 struct drm_mode_fb_cmd *or = data; 1975 struct drm_mode_fb_cmd2 r = {}; 1976 struct drm_mode_config *config = &dev->mode_config; 1977 struct drm_framebuffer *fb; 1978 int ret = 0; 1979 1980 /* Use new struct with format internally */ 1981 r.fb_id = or->fb_id; 1982 r.width = or->width; 1983 r.height = or->height; 1984 r.pitches[0] = or->pitch; 1985 r.pixel_format = drm_mode_legacy_fb_format(or->bpp, or->depth); 1986 r.handles[0] = or->handle; 1987 1988 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1989 return -EINVAL; 1990 1991 if ((config->min_width > r.width) || (r.width > config->max_width)) 1992 return -EINVAL; 1993 1994 if ((config->min_height > r.height) || (r.height > config->max_height)) 1995 return -EINVAL; 1996 1997 mutex_lock(&dev->mode_config.mutex); 1998 1999 /* TODO check buffer is sufficiently large */ 2000 /* TODO setup destructor callback */ 2001 2002 fb = dev->mode_config.funcs->fb_create(dev, file_priv, &r); 2003 if (IS_ERR(fb)) { 2004 DRM_ERROR("could not create framebuffer\n"); 2005 ret = PTR_ERR(fb); 2006 goto out; 2007 } 2008 2009 or->fb_id = fb->base.id; 2010 list_add(&fb->filp_head, &file_priv->fbs); 2011 DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id); 2012 2013out: 2014 mutex_unlock(&dev->mode_config.mutex); 2015 return ret; 2016} 2017 2018/** 2019 * drm_mode_addfb2 - add an FB to the graphics configuration 2020 * @inode: inode from the ioctl 2021 * @filp: file * from the ioctl 2022 * @cmd: cmd from ioctl 2023 * @arg: arg from ioctl 2024 * 2025 * LOCKING: 2026 * Takes mode config lock. 2027 * 2028 * Add a new FB to the specified CRTC, given a user request with format. 2029 * 2030 * Called by the user via ioctl. 2031 * 2032 * RETURNS: 2033 * Zero on success, errno on failure. 2034 */ 2035int drm_mode_addfb2(struct drm_device *dev, 2036 void *data, struct drm_file *file_priv) 2037{ 2038 struct drm_mode_fb_cmd2 *r = data; 2039 struct drm_mode_config *config = &dev->mode_config; 2040 struct drm_framebuffer *fb; 2041 int ret = 0; 2042 2043 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2044 return -EINVAL; 2045 2046 if ((config->min_width > r->width) || (r->width > config->max_width)) { 2047 DRM_ERROR("bad framebuffer width %d, should be >= %d && <= %d\n", 2048 r->width, config->min_width, config->max_width); 2049 return -EINVAL; 2050 } 2051 if ((config->min_height > r->height) || (r->height > config->max_height)) { 2052 DRM_ERROR("bad framebuffer height %d, should be >= %d && <= %d\n", 2053 r->height, config->min_height, config->max_height); 2054 return -EINVAL; 2055 } 2056 2057 mutex_lock(&dev->mode_config.mutex); 2058 2059 fb = dev->mode_config.funcs->fb_create(dev, file_priv, r); 2060 if (IS_ERR(fb)) { 2061 DRM_ERROR("could not create framebuffer\n"); 2062 ret = PTR_ERR(fb); 2063 goto out; 2064 } 2065 2066 r->fb_id = fb->base.id; 2067 list_add(&fb->filp_head, &file_priv->fbs); 2068 DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id); 2069 2070out: 2071 mutex_unlock(&dev->mode_config.mutex); 2072 return ret; 2073} 2074 2075/** 2076 * drm_mode_rmfb - remove an FB from the configuration 2077 * @inode: inode from the ioctl 2078 * @filp: file * from the ioctl 2079 * @cmd: cmd from ioctl 2080 * @arg: arg from ioctl 2081 * 2082 * LOCKING: 2083 * Takes mode config lock. 2084 * 2085 * Remove the FB specified by the user. 2086 * 2087 * Called by the user via ioctl. 2088 * 2089 * RETURNS: 2090 * Zero on success, errno on failure. 2091 */ 2092int drm_mode_rmfb(struct drm_device *dev, 2093 void *data, struct drm_file *file_priv) 2094{ 2095 struct drm_mode_object *obj; 2096 struct drm_framebuffer *fb = NULL; 2097 struct drm_framebuffer *fbl = NULL; 2098 uint32_t *id = data; 2099 int ret = 0; 2100 int found = 0; 2101 2102 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2103 return -EINVAL; 2104 2105 mutex_lock(&dev->mode_config.mutex); 2106 obj = drm_mode_object_find(dev, *id, DRM_MODE_OBJECT_FB); 2107 /* TODO check that we really get a framebuffer back. */ 2108 if (!obj) { 2109 ret = -EINVAL; 2110 goto out; 2111 } 2112 fb = obj_to_fb(obj); 2113 2114 list_for_each_entry(fbl, &file_priv->fbs, filp_head) 2115 if (fb == fbl) 2116 found = 1; 2117 2118 if (!found) { 2119 ret = -EINVAL; 2120 goto out; 2121 } 2122 2123 /* TODO release all crtc connected to the framebuffer */ 2124 /* TODO unhock the destructor from the buffer object */ 2125 2126 list_del(&fb->filp_head); 2127 fb->funcs->destroy(fb); 2128 2129out: 2130 mutex_unlock(&dev->mode_config.mutex); 2131 return ret; 2132} 2133 2134/** 2135 * drm_mode_getfb - get FB info 2136 * @inode: inode from the ioctl 2137 * @filp: file * from the ioctl 2138 * @cmd: cmd from ioctl 2139 * @arg: arg from ioctl 2140 * 2141 * LOCKING: 2142 * Caller? (FIXME) 2143 * 2144 * Lookup the FB given its ID and return info about it. 2145 * 2146 * Called by the user via ioctl. 2147 * 2148 * RETURNS: 2149 * Zero on success, errno on failure. 2150 */ 2151int drm_mode_getfb(struct drm_device *dev, 2152 void *data, struct drm_file *file_priv) 2153{ 2154 struct drm_mode_fb_cmd *r = data; 2155 struct drm_mode_object *obj; 2156 struct drm_framebuffer *fb; 2157 int ret = 0; 2158 2159 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2160 return -EINVAL; 2161 2162 mutex_lock(&dev->mode_config.mutex); 2163 obj = drm_mode_object_find(dev, r->fb_id, DRM_MODE_OBJECT_FB); 2164 if (!obj) { 2165 ret = -EINVAL; 2166 goto out; 2167 } 2168 fb = obj_to_fb(obj); 2169 2170 r->height = fb->height; 2171 r->width = fb->width; 2172 r->depth = fb->depth; 2173 r->bpp = fb->bits_per_pixel; 2174 r->pitch = fb->pitch; 2175 fb->funcs->create_handle(fb, file_priv, &r->handle); 2176 2177out: 2178 mutex_unlock(&dev->mode_config.mutex); 2179 return ret; 2180} 2181 2182int drm_mode_dirtyfb_ioctl(struct drm_device *dev, 2183 void *data, struct drm_file *file_priv) 2184{ 2185 struct drm_clip_rect __user *clips_ptr; 2186 struct drm_clip_rect *clips = NULL; 2187 struct drm_mode_fb_dirty_cmd *r = data; 2188 struct drm_mode_object *obj; 2189 struct drm_framebuffer *fb; 2190 unsigned flags; 2191 int num_clips; 2192 int ret = 0; 2193 2194 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2195 return -EINVAL; 2196 2197 mutex_lock(&dev->mode_config.mutex); 2198 obj = drm_mode_object_find(dev, r->fb_id, DRM_MODE_OBJECT_FB); 2199 if (!obj) { 2200 ret = -EINVAL; 2201 goto out_err1; 2202 } 2203 fb = obj_to_fb(obj); 2204 2205 num_clips = r->num_clips; 2206 clips_ptr = (struct drm_clip_rect __user *)(unsigned long)r->clips_ptr; 2207 2208 if (!num_clips != !clips_ptr) { 2209 ret = -EINVAL; 2210 goto out_err1; 2211 } 2212 2213 flags = DRM_MODE_FB_DIRTY_FLAGS & r->flags; 2214 2215 /* If userspace annotates copy, clips must come in pairs */ 2216 if (flags & DRM_MODE_FB_DIRTY_ANNOTATE_COPY && (num_clips % 2)) { 2217 ret = -EINVAL; 2218 goto out_err1; 2219 } 2220 2221 if (num_clips && clips_ptr) { 2222 clips = kzalloc(num_clips * sizeof(*clips), GFP_KERNEL); 2223 if (!clips) { 2224 ret = -ENOMEM; 2225 goto out_err1; 2226 } 2227 2228 ret = copy_from_user(clips, clips_ptr, 2229 num_clips * sizeof(*clips)); 2230 if (ret) { 2231 ret = -EFAULT; 2232 goto out_err2; 2233 } 2234 } 2235 2236 if (fb->funcs->dirty) { 2237 ret = fb->funcs->dirty(fb, file_priv, flags, r->color, 2238 clips, num_clips); 2239 } else { 2240 ret = -ENOSYS; 2241 goto out_err2; 2242 } 2243 2244out_err2: 2245 kfree(clips); 2246out_err1: 2247 mutex_unlock(&dev->mode_config.mutex); 2248 return ret; 2249} 2250 2251 2252/** 2253 * drm_fb_release - remove and free the FBs on this file 2254 * @filp: file * from the ioctl 2255 * 2256 * LOCKING: 2257 * Takes mode config lock. 2258 * 2259 * Destroy all the FBs associated with @filp. 2260 * 2261 * Called by the user via ioctl. 2262 * 2263 * RETURNS: 2264 * Zero on success, errno on failure. 2265 */ 2266void drm_fb_release(struct drm_file *priv) 2267{ 2268 struct drm_device *dev = priv->minor->dev; 2269 struct drm_framebuffer *fb, *tfb; 2270 2271 mutex_lock(&dev->mode_config.mutex); 2272 list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) { 2273 list_del(&fb->filp_head); 2274 fb->funcs->destroy(fb); 2275 } 2276 mutex_unlock(&dev->mode_config.mutex); 2277} 2278 2279/** 2280 * drm_mode_attachmode - add a mode to the user mode list 2281 * @dev: DRM device 2282 * @connector: connector to add the mode to 2283 * @mode: mode to add 2284 * 2285 * Add @mode to @connector's user mode list. 2286 */ 2287static int drm_mode_attachmode(struct drm_device *dev, 2288 struct drm_connector *connector, 2289 struct drm_display_mode *mode) 2290{ 2291 int ret = 0; 2292 2293 list_add_tail(&mode->head, &connector->user_modes); 2294 return ret; 2295} 2296 2297int drm_mode_attachmode_crtc(struct drm_device *dev, struct drm_crtc *crtc, 2298 struct drm_display_mode *mode) 2299{ 2300 struct drm_connector *connector; 2301 int ret = 0; 2302 struct drm_display_mode *dup_mode; 2303 int need_dup = 0; 2304 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 2305 if (!connector->encoder) 2306 break; 2307 if (connector->encoder->crtc == crtc) { 2308 if (need_dup) 2309 dup_mode = drm_mode_duplicate(dev, mode); 2310 else 2311 dup_mode = mode; 2312 ret = drm_mode_attachmode(dev, connector, dup_mode); 2313 if (ret) 2314 return ret; 2315 need_dup = 1; 2316 } 2317 } 2318 return 0; 2319} 2320EXPORT_SYMBOL(drm_mode_attachmode_crtc); 2321 2322static int drm_mode_detachmode(struct drm_device *dev, 2323 struct drm_connector *connector, 2324 struct drm_display_mode *mode) 2325{ 2326 int found = 0; 2327 int ret = 0; 2328 struct drm_display_mode *match_mode, *t; 2329 2330 list_for_each_entry_safe(match_mode, t, &connector->user_modes, head) { 2331 if (drm_mode_equal(match_mode, mode)) { 2332 list_del(&match_mode->head); 2333 drm_mode_destroy(dev, match_mode); 2334 found = 1; 2335 break; 2336 } 2337 } 2338 2339 if (!found) 2340 ret = -EINVAL; 2341 2342 return ret; 2343} 2344 2345int drm_mode_detachmode_crtc(struct drm_device *dev, struct drm_display_mode *mode) 2346{ 2347 struct drm_connector *connector; 2348 2349 list_for_each_entry(connector, &dev->mode_config.connector_list, head) { 2350 drm_mode_detachmode(dev, connector, mode); 2351 } 2352 return 0; 2353} 2354EXPORT_SYMBOL(drm_mode_detachmode_crtc); 2355 2356/** 2357 * drm_fb_attachmode - Attach a user mode to an connector 2358 * @inode: inode from the ioctl 2359 * @filp: file * from the ioctl 2360 * @cmd: cmd from ioctl 2361 * @arg: arg from ioctl 2362 * 2363 * This attaches a user specified mode to an connector. 2364 * Called by the user via ioctl. 2365 * 2366 * RETURNS: 2367 * Zero on success, errno on failure. 2368 */ 2369int drm_mode_attachmode_ioctl(struct drm_device *dev, 2370 void *data, struct drm_file *file_priv) 2371{ 2372 struct drm_mode_mode_cmd *mode_cmd = data; 2373 struct drm_connector *connector; 2374 struct drm_display_mode *mode; 2375 struct drm_mode_object *obj; 2376 struct drm_mode_modeinfo *umode = &mode_cmd->mode; 2377 int ret = 0; 2378 2379 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2380 return -EINVAL; 2381 2382 mutex_lock(&dev->mode_config.mutex); 2383 2384 obj = drm_mode_object_find(dev, mode_cmd->connector_id, DRM_MODE_OBJECT_CONNECTOR); 2385 if (!obj) { 2386 ret = -EINVAL; 2387 goto out; 2388 } 2389 connector = obj_to_connector(obj); 2390 2391 mode = drm_mode_create(dev); 2392 if (!mode) { 2393 ret = -ENOMEM; 2394 goto out; 2395 } 2396 2397 drm_crtc_convert_umode(mode, umode); 2398 2399 ret = drm_mode_attachmode(dev, connector, mode); 2400out: 2401 mutex_unlock(&dev->mode_config.mutex); 2402 return ret; 2403} 2404 2405 2406/** 2407 * drm_fb_detachmode - Detach a user specified mode from an connector 2408 * @inode: inode from the ioctl 2409 * @filp: file * from the ioctl 2410 * @cmd: cmd from ioctl 2411 * @arg: arg from ioctl 2412 * 2413 * Called by the user via ioctl. 2414 * 2415 * RETURNS: 2416 * Zero on success, errno on failure. 2417 */ 2418int drm_mode_detachmode_ioctl(struct drm_device *dev, 2419 void *data, struct drm_file *file_priv) 2420{ 2421 struct drm_mode_object *obj; 2422 struct drm_mode_mode_cmd *mode_cmd = data; 2423 struct drm_connector *connector; 2424 struct drm_display_mode mode; 2425 struct drm_mode_modeinfo *umode = &mode_cmd->mode; 2426 int ret = 0; 2427 2428 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2429 return -EINVAL; 2430 2431 mutex_lock(&dev->mode_config.mutex); 2432 2433 obj = drm_mode_object_find(dev, mode_cmd->connector_id, DRM_MODE_OBJECT_CONNECTOR); 2434 if (!obj) { 2435 ret = -EINVAL; 2436 goto out; 2437 } 2438 connector = obj_to_connector(obj); 2439 2440 drm_crtc_convert_umode(&mode, umode); 2441 ret = drm_mode_detachmode(dev, connector, &mode); 2442out: 2443 mutex_unlock(&dev->mode_config.mutex); 2444 return ret; 2445} 2446 2447struct drm_property *drm_property_create(struct drm_device *dev, int flags, 2448 const char *name, int num_values) 2449{ 2450 struct drm_property *property = NULL; 2451 2452 property = kzalloc(sizeof(struct drm_property), GFP_KERNEL); 2453 if (!property) 2454 return NULL; 2455 2456 if (num_values) { 2457 property->values = kzalloc(sizeof(uint64_t)*num_values, GFP_KERNEL); 2458 if (!property->values) 2459 goto fail; 2460 } 2461 2462 drm_mode_object_get(dev, &property->base, DRM_MODE_OBJECT_PROPERTY); 2463 property->flags = flags; 2464 property->num_values = num_values; 2465 INIT_LIST_HEAD(&property->enum_blob_list); 2466 2467 if (name) 2468 strncpy(property->name, name, DRM_PROP_NAME_LEN); 2469 2470 list_add_tail(&property->head, &dev->mode_config.property_list); 2471 return property; 2472fail: 2473 kfree(property); 2474 return NULL; 2475} 2476EXPORT_SYMBOL(drm_property_create); 2477 2478int drm_property_add_enum(struct drm_property *property, int index, 2479 uint64_t value, const char *name) 2480{ 2481 struct drm_property_enum *prop_enum; 2482 2483 if (!(property->flags & DRM_MODE_PROP_ENUM)) 2484 return -EINVAL; 2485 2486 if (!list_empty(&property->enum_blob_list)) { 2487 list_for_each_entry(prop_enum, &property->enum_blob_list, head) { 2488 if (prop_enum->value == value) { 2489 strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN); 2490 prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0'; 2491 return 0; 2492 } 2493 } 2494 } 2495 2496 prop_enum = kzalloc(sizeof(struct drm_property_enum), GFP_KERNEL); 2497 if (!prop_enum) 2498 return -ENOMEM; 2499 2500 strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN); 2501 prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0'; 2502 prop_enum->value = value; 2503 2504 property->values[index] = value; 2505 list_add_tail(&prop_enum->head, &property->enum_blob_list); 2506 return 0; 2507} 2508EXPORT_SYMBOL(drm_property_add_enum); 2509 2510void drm_property_destroy(struct drm_device *dev, struct drm_property *property) 2511{ 2512 struct drm_property_enum *prop_enum, *pt; 2513 2514 list_for_each_entry_safe(prop_enum, pt, &property->enum_blob_list, head) { 2515 list_del(&prop_enum->head); 2516 kfree(prop_enum); 2517 } 2518 2519 if (property->num_values) 2520 kfree(property->values); 2521 drm_mode_object_put(dev, &property->base); 2522 list_del(&property->head); 2523 kfree(property); 2524} 2525EXPORT_SYMBOL(drm_property_destroy); 2526 2527int drm_connector_attach_property(struct drm_connector *connector, 2528 struct drm_property *property, uint64_t init_val) 2529{ 2530 int i; 2531 2532 for (i = 0; i < DRM_CONNECTOR_MAX_PROPERTY; i++) { 2533 if (connector->property_ids[i] == 0) { 2534 connector->property_ids[i] = property->base.id; 2535 connector->property_values[i] = init_val; 2536 break; 2537 } 2538 } 2539 2540 if (i == DRM_CONNECTOR_MAX_PROPERTY) 2541 return -EINVAL; 2542 return 0; 2543} 2544EXPORT_SYMBOL(drm_connector_attach_property); 2545 2546int drm_connector_property_set_value(struct drm_connector *connector, 2547 struct drm_property *property, uint64_t value) 2548{ 2549 int i; 2550 2551 for (i = 0; i < DRM_CONNECTOR_MAX_PROPERTY; i++) { 2552 if (connector->property_ids[i] == property->base.id) { 2553 connector->property_values[i] = value; 2554 break; 2555 } 2556 } 2557 2558 if (i == DRM_CONNECTOR_MAX_PROPERTY) 2559 return -EINVAL; 2560 return 0; 2561} 2562EXPORT_SYMBOL(drm_connector_property_set_value); 2563 2564int drm_connector_property_get_value(struct drm_connector *connector, 2565 struct drm_property *property, uint64_t *val) 2566{ 2567 int i; 2568 2569 for (i = 0; i < DRM_CONNECTOR_MAX_PROPERTY; i++) { 2570 if (connector->property_ids[i] == property->base.id) { 2571 *val = connector->property_values[i]; 2572 break; 2573 } 2574 } 2575 2576 if (i == DRM_CONNECTOR_MAX_PROPERTY) 2577 return -EINVAL; 2578 return 0; 2579} 2580EXPORT_SYMBOL(drm_connector_property_get_value); 2581 2582int drm_mode_getproperty_ioctl(struct drm_device *dev, 2583 void *data, struct drm_file *file_priv) 2584{ 2585 struct drm_mode_object *obj; 2586 struct drm_mode_get_property *out_resp = data; 2587 struct drm_property *property; 2588 int enum_count = 0; 2589 int blob_count = 0; 2590 int value_count = 0; 2591 int ret = 0, i; 2592 int copied; 2593 struct drm_property_enum *prop_enum; 2594 struct drm_mode_property_enum __user *enum_ptr; 2595 struct drm_property_blob *prop_blob; 2596 uint32_t __user *blob_id_ptr; 2597 uint64_t __user *values_ptr; 2598 uint32_t __user *blob_length_ptr; 2599 2600 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2601 return -EINVAL; 2602 2603 mutex_lock(&dev->mode_config.mutex); 2604 obj = drm_mode_object_find(dev, out_resp->prop_id, DRM_MODE_OBJECT_PROPERTY); 2605 if (!obj) { 2606 ret = -EINVAL; 2607 goto done; 2608 } 2609 property = obj_to_property(obj); 2610 2611 if (property->flags & DRM_MODE_PROP_ENUM) { 2612 list_for_each_entry(prop_enum, &property->enum_blob_list, head) 2613 enum_count++; 2614 } else if (property->flags & DRM_MODE_PROP_BLOB) { 2615 list_for_each_entry(prop_blob, &property->enum_blob_list, head) 2616 blob_count++; 2617 } 2618 2619 value_count = property->num_values; 2620 2621 strncpy(out_resp->name, property->name, DRM_PROP_NAME_LEN); 2622 out_resp->name[DRM_PROP_NAME_LEN-1] = 0; 2623 out_resp->flags = property->flags; 2624 2625 if ((out_resp->count_values >= value_count) && value_count) { 2626 values_ptr = (uint64_t __user *)(unsigned long)out_resp->values_ptr; 2627 for (i = 0; i < value_count; i++) { 2628 if (copy_to_user(values_ptr + i, &property->values[i], sizeof(uint64_t))) { 2629 ret = -EFAULT; 2630 goto done; 2631 } 2632 } 2633 } 2634 out_resp->count_values = value_count; 2635 2636 if (property->flags & DRM_MODE_PROP_ENUM) { 2637 if ((out_resp->count_enum_blobs >= enum_count) && enum_count) { 2638 copied = 0; 2639 enum_ptr = (struct drm_mode_property_enum __user *)(unsigned long)out_resp->enum_blob_ptr; 2640 list_for_each_entry(prop_enum, &property->enum_blob_list, head) { 2641 2642 if (copy_to_user(&enum_ptr[copied].value, &prop_enum->value, sizeof(uint64_t))) { 2643 ret = -EFAULT; 2644 goto done; 2645 } 2646 2647 if (copy_to_user(&enum_ptr[copied].name, 2648 &prop_enum->name, DRM_PROP_NAME_LEN)) { 2649 ret = -EFAULT; 2650 goto done; 2651 } 2652 copied++; 2653 } 2654 } 2655 out_resp->count_enum_blobs = enum_count; 2656 } 2657 2658 if (property->flags & DRM_MODE_PROP_BLOB) { 2659 if ((out_resp->count_enum_blobs >= blob_count) && blob_count) { 2660 copied = 0; 2661 blob_id_ptr = (uint32_t __user *)(unsigned long)out_resp->enum_blob_ptr; 2662 blob_length_ptr = (uint32_t __user *)(unsigned long)out_resp->values_ptr; 2663 2664 list_for_each_entry(prop_blob, &property->enum_blob_list, head) { 2665 if (put_user(prop_blob->base.id, blob_id_ptr + copied)) { 2666 ret = -EFAULT; 2667 goto done; 2668 } 2669 2670 if (put_user(prop_blob->length, blob_length_ptr + copied)) { 2671 ret = -EFAULT; 2672 goto done; 2673 } 2674 2675 copied++; 2676 } 2677 } 2678 out_resp->count_enum_blobs = blob_count; 2679 } 2680done: 2681 mutex_unlock(&dev->mode_config.mutex); 2682 return ret; 2683} 2684 2685static struct drm_property_blob *drm_property_create_blob(struct drm_device *dev, int length, 2686 void *data) 2687{ 2688 struct drm_property_blob *blob; 2689 2690 if (!length || !data) 2691 return NULL; 2692 2693 blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL); 2694 if (!blob) 2695 return NULL; 2696 2697 blob->data = (void *)((char *)blob + sizeof(struct drm_property_blob)); 2698 blob->length = length; 2699 2700 memcpy(blob->data, data, length); 2701 2702 drm_mode_object_get(dev, &blob->base, DRM_MODE_OBJECT_BLOB); 2703 2704 list_add_tail(&blob->head, &dev->mode_config.property_blob_list); 2705 return blob; 2706} 2707 2708static void drm_property_destroy_blob(struct drm_device *dev, 2709 struct drm_property_blob *blob) 2710{ 2711 drm_mode_object_put(dev, &blob->base); 2712 list_del(&blob->head); 2713 kfree(blob); 2714} 2715 2716int drm_mode_getblob_ioctl(struct drm_device *dev, 2717 void *data, struct drm_file *file_priv) 2718{ 2719 struct drm_mode_object *obj; 2720 struct drm_mode_get_blob *out_resp = data; 2721 struct drm_property_blob *blob; 2722 int ret = 0; 2723 void __user *blob_ptr; 2724 2725 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2726 return -EINVAL; 2727 2728 mutex_lock(&dev->mode_config.mutex); 2729 obj = drm_mode_object_find(dev, out_resp->blob_id, DRM_MODE_OBJECT_BLOB); 2730 if (!obj) { 2731 ret = -EINVAL; 2732 goto done; 2733 } 2734 blob = obj_to_blob(obj); 2735 2736 if (out_resp->length == blob->length) { 2737 blob_ptr = (void __user *)(unsigned long)out_resp->data; 2738 if (copy_to_user(blob_ptr, blob->data, blob->length)){ 2739 ret = -EFAULT; 2740 goto done; 2741 } 2742 } 2743 out_resp->length = blob->length; 2744 2745done: 2746 mutex_unlock(&dev->mode_config.mutex); 2747 return ret; 2748} 2749 2750int drm_mode_connector_update_edid_property(struct drm_connector *connector, 2751 struct edid *edid) 2752{ 2753 struct drm_device *dev = connector->dev; 2754 int ret = 0, size; 2755 2756 if (connector->edid_blob_ptr) 2757 drm_property_destroy_blob(dev, connector->edid_blob_ptr); 2758 2759 /* Delete edid, when there is none. */ 2760 if (!edid) { 2761 connector->edid_blob_ptr = NULL; 2762 ret = drm_connector_property_set_value(connector, dev->mode_config.edid_property, 0); 2763 return ret; 2764 } 2765 2766 size = EDID_LENGTH * (1 + edid->extensions); 2767 connector->edid_blob_ptr = drm_property_create_blob(connector->dev, 2768 size, edid); 2769 2770 ret = drm_connector_property_set_value(connector, 2771 dev->mode_config.edid_property, 2772 connector->edid_blob_ptr->base.id); 2773 2774 return ret; 2775} 2776EXPORT_SYMBOL(drm_mode_connector_update_edid_property); 2777 2778int drm_mode_connector_property_set_ioctl(struct drm_device *dev, 2779 void *data, struct drm_file *file_priv) 2780{ 2781 struct drm_mode_connector_set_property *out_resp = data; 2782 struct drm_mode_object *obj; 2783 struct drm_property *property; 2784 struct drm_connector *connector; 2785 int ret = -EINVAL; 2786 int i; 2787 2788 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2789 return -EINVAL; 2790 2791 mutex_lock(&dev->mode_config.mutex); 2792 2793 obj = drm_mode_object_find(dev, out_resp->connector_id, DRM_MODE_OBJECT_CONNECTOR); 2794 if (!obj) { 2795 goto out; 2796 } 2797 connector = obj_to_connector(obj); 2798 2799 for (i = 0; i < DRM_CONNECTOR_MAX_PROPERTY; i++) { 2800 if (connector->property_ids[i] == out_resp->prop_id) 2801 break; 2802 } 2803 2804 if (i == DRM_CONNECTOR_MAX_PROPERTY) { 2805 goto out; 2806 } 2807 2808 obj = drm_mode_object_find(dev, out_resp->prop_id, DRM_MODE_OBJECT_PROPERTY); 2809 if (!obj) { 2810 goto out; 2811 } 2812 property = obj_to_property(obj); 2813 2814 if (property->flags & DRM_MODE_PROP_IMMUTABLE) 2815 goto out; 2816 2817 if (property->flags & DRM_MODE_PROP_RANGE) { 2818 if (out_resp->value < property->values[0]) 2819 goto out; 2820 2821 if (out_resp->value > property->values[1]) 2822 goto out; 2823 } else { 2824 int found = 0; 2825 for (i = 0; i < property->num_values; i++) { 2826 if (property->values[i] == out_resp->value) { 2827 found = 1; 2828 break; 2829 } 2830 } 2831 if (!found) { 2832 goto out; 2833 } 2834 } 2835 2836 /* Do DPMS ourselves */ 2837 if (property == connector->dev->mode_config.dpms_property) { 2838 if (connector->funcs->dpms) 2839 (*connector->funcs->dpms)(connector, (int) out_resp->value); 2840 ret = 0; 2841 } else if (connector->funcs->set_property) 2842 ret = connector->funcs->set_property(connector, property, out_resp->value); 2843 2844 /* store the property value if successful */ 2845 if (!ret) 2846 drm_connector_property_set_value(connector, property, out_resp->value); 2847out: 2848 mutex_unlock(&dev->mode_config.mutex); 2849 return ret; 2850} 2851 2852int drm_mode_connector_attach_encoder(struct drm_connector *connector, 2853 struct drm_encoder *encoder) 2854{ 2855 int i; 2856 2857 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 2858 if (connector->encoder_ids[i] == 0) { 2859 connector->encoder_ids[i] = encoder->base.id; 2860 return 0; 2861 } 2862 } 2863 return -ENOMEM; 2864} 2865EXPORT_SYMBOL(drm_mode_connector_attach_encoder); 2866 2867void drm_mode_connector_detach_encoder(struct drm_connector *connector, 2868 struct drm_encoder *encoder) 2869{ 2870 int i; 2871 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) { 2872 if (connector->encoder_ids[i] == encoder->base.id) { 2873 connector->encoder_ids[i] = 0; 2874 if (connector->encoder == encoder) 2875 connector->encoder = NULL; 2876 break; 2877 } 2878 } 2879} 2880EXPORT_SYMBOL(drm_mode_connector_detach_encoder); 2881 2882bool drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc, 2883 int gamma_size) 2884{ 2885 crtc->gamma_size = gamma_size; 2886 2887 crtc->gamma_store = kzalloc(gamma_size * sizeof(uint16_t) * 3, GFP_KERNEL); 2888 if (!crtc->gamma_store) { 2889 crtc->gamma_size = 0; 2890 return false; 2891 } 2892 2893 return true; 2894} 2895EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size); 2896 2897int drm_mode_gamma_set_ioctl(struct drm_device *dev, 2898 void *data, struct drm_file *file_priv) 2899{ 2900 struct drm_mode_crtc_lut *crtc_lut = data; 2901 struct drm_mode_object *obj; 2902 struct drm_crtc *crtc; 2903 void *r_base, *g_base, *b_base; 2904 int size; 2905 int ret = 0; 2906 2907 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2908 return -EINVAL; 2909 2910 mutex_lock(&dev->mode_config.mutex); 2911 obj = drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC); 2912 if (!obj) { 2913 ret = -EINVAL; 2914 goto out; 2915 } 2916 crtc = obj_to_crtc(obj); 2917 2918 /* memcpy into gamma store */ 2919 if (crtc_lut->gamma_size != crtc->gamma_size) { 2920 ret = -EINVAL; 2921 goto out; 2922 } 2923 2924 size = crtc_lut->gamma_size * (sizeof(uint16_t)); 2925 r_base = crtc->gamma_store; 2926 if (copy_from_user(r_base, (void __user *)(unsigned long)crtc_lut->red, size)) { 2927 ret = -EFAULT; 2928 goto out; 2929 } 2930 2931 g_base = r_base + size; 2932 if (copy_from_user(g_base, (void __user *)(unsigned long)crtc_lut->green, size)) { 2933 ret = -EFAULT; 2934 goto out; 2935 } 2936 2937 b_base = g_base + size; 2938 if (copy_from_user(b_base, (void __user *)(unsigned long)crtc_lut->blue, size)) { 2939 ret = -EFAULT; 2940 goto out; 2941 } 2942 2943 crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size); 2944 2945out: 2946 mutex_unlock(&dev->mode_config.mutex); 2947 return ret; 2948 2949} 2950 2951int drm_mode_gamma_get_ioctl(struct drm_device *dev, 2952 void *data, struct drm_file *file_priv) 2953{ 2954 struct drm_mode_crtc_lut *crtc_lut = data; 2955 struct drm_mode_object *obj; 2956 struct drm_crtc *crtc; 2957 void *r_base, *g_base, *b_base; 2958 int size; 2959 int ret = 0; 2960 2961 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 2962 return -EINVAL; 2963 2964 mutex_lock(&dev->mode_config.mutex); 2965 obj = drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC); 2966 if (!obj) { 2967 ret = -EINVAL; 2968 goto out; 2969 } 2970 crtc = obj_to_crtc(obj); 2971 2972 /* memcpy into gamma store */ 2973 if (crtc_lut->gamma_size != crtc->gamma_size) { 2974 ret = -EINVAL; 2975 goto out; 2976 } 2977 2978 size = crtc_lut->gamma_size * (sizeof(uint16_t)); 2979 r_base = crtc->gamma_store; 2980 if (copy_to_user((void __user *)(unsigned long)crtc_lut->red, r_base, size)) { 2981 ret = -EFAULT; 2982 goto out; 2983 } 2984 2985 g_base = r_base + size; 2986 if (copy_to_user((void __user *)(unsigned long)crtc_lut->green, g_base, size)) { 2987 ret = -EFAULT; 2988 goto out; 2989 } 2990 2991 b_base = g_base + size; 2992 if (copy_to_user((void __user *)(unsigned long)crtc_lut->blue, b_base, size)) { 2993 ret = -EFAULT; 2994 goto out; 2995 } 2996out: 2997 mutex_unlock(&dev->mode_config.mutex); 2998 return ret; 2999} 3000 3001int drm_mode_page_flip_ioctl(struct drm_device *dev, 3002 void *data, struct drm_file *file_priv) 3003{ 3004 struct drm_mode_crtc_page_flip *page_flip = data; 3005 struct drm_mode_object *obj; 3006 struct drm_crtc *crtc; 3007 struct drm_framebuffer *fb; 3008 struct drm_pending_vblank_event *e = NULL; 3009 unsigned long flags; 3010 int ret = -EINVAL; 3011 3012 if (page_flip->flags & ~DRM_MODE_PAGE_FLIP_FLAGS || 3013 page_flip->reserved != 0) 3014 return -EINVAL; 3015 3016 mutex_lock(&dev->mode_config.mutex); 3017 obj = drm_mode_object_find(dev, page_flip->crtc_id, DRM_MODE_OBJECT_CRTC); 3018 if (!obj) 3019 goto out; 3020 crtc = obj_to_crtc(obj); 3021 3022 if (crtc->fb == NULL) { 3023 /* The framebuffer is currently unbound, presumably 3024 * due to a hotplug event, that userspace has not 3025 * yet discovered. 3026 */ 3027 ret = -EBUSY; 3028 goto out; 3029 } 3030 3031 if (crtc->funcs->page_flip == NULL) 3032 goto out; 3033 3034 obj = drm_mode_object_find(dev, page_flip->fb_id, DRM_MODE_OBJECT_FB); 3035 if (!obj) 3036 goto out; 3037 fb = obj_to_fb(obj); 3038 3039 if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) { 3040 ret = -ENOMEM; 3041 spin_lock_irqsave(&dev->event_lock, flags); 3042 if (file_priv->event_space < sizeof e->event) { 3043 spin_unlock_irqrestore(&dev->event_lock, flags); 3044 goto out; 3045 } 3046 file_priv->event_space -= sizeof e->event; 3047 spin_unlock_irqrestore(&dev->event_lock, flags); 3048 3049 e = kzalloc(sizeof *e, GFP_KERNEL); 3050 if (e == NULL) { 3051 spin_lock_irqsave(&dev->event_lock, flags); 3052 file_priv->event_space += sizeof e->event; 3053 spin_unlock_irqrestore(&dev->event_lock, flags); 3054 goto out; 3055 } 3056 3057 e->event.base.type = DRM_EVENT_FLIP_COMPLETE; 3058 e->event.base.length = sizeof e->event; 3059 e->event.user_data = page_flip->user_data; 3060 e->base.event = &e->event.base; 3061 e->base.file_priv = file_priv; 3062 e->base.destroy = 3063 (void (*) (struct drm_pending_event *)) kfree; 3064 } 3065 3066 ret = crtc->funcs->page_flip(crtc, fb, e); 3067 if (ret) { 3068 spin_lock_irqsave(&dev->event_lock, flags); 3069 file_priv->event_space += sizeof e->event; 3070 spin_unlock_irqrestore(&dev->event_lock, flags); 3071 kfree(e); 3072 } 3073 3074out: 3075 mutex_unlock(&dev->mode_config.mutex); 3076 return ret; 3077} 3078 3079void drm_mode_config_reset(struct drm_device *dev) 3080{ 3081 struct drm_crtc *crtc; 3082 struct drm_encoder *encoder; 3083 struct drm_connector *connector; 3084 3085 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) 3086 if (crtc->funcs->reset) 3087 crtc->funcs->reset(crtc); 3088 3089 list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) 3090 if (encoder->funcs->reset) 3091 encoder->funcs->reset(encoder); 3092 3093 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 3094 if (connector->funcs->reset) 3095 connector->funcs->reset(connector); 3096} 3097EXPORT_SYMBOL(drm_mode_config_reset); 3098 3099int drm_mode_create_dumb_ioctl(struct drm_device *dev, 3100 void *data, struct drm_file *file_priv) 3101{ 3102 struct drm_mode_create_dumb *args = data; 3103 3104 if (!dev->driver->dumb_create) 3105 return -ENOSYS; 3106 return dev->driver->dumb_create(file_priv, dev, args); 3107} 3108 3109int drm_mode_mmap_dumb_ioctl(struct drm_device *dev, 3110 void *data, struct drm_file *file_priv) 3111{ 3112 struct drm_mode_map_dumb *args = data; 3113 3114 /* call driver ioctl to get mmap offset */ 3115 if (!dev->driver->dumb_map_offset) 3116 return -ENOSYS; 3117 3118 return dev->driver->dumb_map_offset(file_priv, dev, args->handle, &args->offset); 3119} 3120 3121int drm_mode_destroy_dumb_ioctl(struct drm_device *dev, 3122 void *data, struct drm_file *file_priv) 3123{ 3124 struct drm_mode_destroy_dumb *args = data; 3125 3126 if (!dev->driver->dumb_destroy) 3127 return -ENOSYS; 3128 3129 return dev->driver->dumb_destroy(file_priv, dev, args->handle); 3130} 3131 3132/* 3133 * Just need to support RGB formats here for compat with code that doesn't 3134 * use pixel formats directly yet. 3135 */ 3136void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth, 3137 int *bpp) 3138{ 3139 switch (format) { 3140 case DRM_FORMAT_RGB332: 3141 case DRM_FORMAT_BGR233: 3142 *depth = 8; 3143 *bpp = 8; 3144 break; 3145 case DRM_FORMAT_XRGB1555: 3146 case DRM_FORMAT_XBGR1555: 3147 case DRM_FORMAT_RGBX5551: 3148 case DRM_FORMAT_BGRX5551: 3149 case DRM_FORMAT_ARGB1555: 3150 case DRM_FORMAT_ABGR1555: 3151 case DRM_FORMAT_RGBA5551: 3152 case DRM_FORMAT_BGRA5551: 3153 *depth = 15; 3154 *bpp = 16; 3155 break; 3156 case DRM_FORMAT_RGB565: 3157 case DRM_FORMAT_BGR565: 3158 *depth = 16; 3159 *bpp = 16; 3160 break; 3161 case DRM_FORMAT_RGB888: 3162 case DRM_FORMAT_BGR888: 3163 *depth = 24; 3164 *bpp = 24; 3165 break; 3166 case DRM_FORMAT_XRGB8888: 3167 case DRM_FORMAT_XBGR8888: 3168 case DRM_FORMAT_RGBX8888: 3169 case DRM_FORMAT_BGRX8888: 3170 *depth = 24; 3171 *bpp = 32; 3172 break; 3173 case DRM_FORMAT_XRGB2101010: 3174 case DRM_FORMAT_XBGR2101010: 3175 case DRM_FORMAT_RGBX1010102: 3176 case DRM_FORMAT_BGRX1010102: 3177 case DRM_FORMAT_ARGB2101010: 3178 case DRM_FORMAT_ABGR2101010: 3179 case DRM_FORMAT_RGBA1010102: 3180 case DRM_FORMAT_BGRA1010102: 3181 *depth = 30; 3182 *bpp = 32; 3183 break; 3184 case DRM_FORMAT_ARGB8888: 3185 case DRM_FORMAT_ABGR8888: 3186 case DRM_FORMAT_RGBA8888: 3187 case DRM_FORMAT_BGRA8888: 3188 *depth = 32; 3189 *bpp = 32; 3190 break; 3191 default: 3192 DRM_DEBUG_KMS("unsupported pixel format\n"); 3193 *depth = 0; 3194 *bpp = 0; 3195 break; 3196 } 3197} 3198EXPORT_SYMBOL(drm_fb_get_bpp_depth); 3199