drivers/gpu/drm/drm_crtc.c

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