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 -ENOMEM;
 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         else if (ret)
 239                 return ret;
 240
 241         obj->id = new_id;
 242         obj->type = obj_type;
 243         return 0;
 244 }
 245
 246 /**
 247  * drm_mode_object_put - free an identifer
 248  * @dev: DRM device
 249  * @id: ID to free
 250  *
 251  * LOCKING:
 252  * Caller must hold DRM mode_config lock.
 253  *
 254  * Free @id from @dev's unique identifier pool.
 255  */
 256 static void drm_mode_object_put(struct drm_device *dev,
 257                                 struct drm_mode_object *object)
 258 {
 259         mutex_lock(&dev->mode_config.idr_mutex);
 260         idr_remove(&dev->mode_config.crtc_idr, object->id);
 261         mutex_unlock(&dev->mode_config.idr_mutex);
 262 }
 263
 264 struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
 265                 uint32_t id, uint32_t type)
 266 {
 267         struct drm_mode_object *obj = NULL;
 268
 269         mutex_lock(&dev->mode_config.idr_mutex);
 270         obj = idr_find(&dev->mode_config.crtc_idr, id);
 271         if (!obj || (obj->type != type) || (obj->id != id))
 272                 obj = NULL;
 273         mutex_unlock(&dev->mode_config.idr_mutex);
 274
 275         return obj;
 276 }
 277 EXPORT_SYMBOL(drm_mode_object_find);
 278
 279 /**
 280  * drm_framebuffer_init - initialize a framebuffer
 281  * @dev: DRM device
 282  *
 283  * LOCKING:
 284  * Caller must hold mode config lock.
 285  *
 286  * Allocates an ID for the framebuffer's parent mode object, sets its mode
 287  * functions & device file and adds it to the master fd list.
 288  *
 289  * RETURNS:
 290  * Zero on success, error code on failure.
 291  */
 292 int drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb,
 293                          const struct drm_framebuffer_funcs *funcs)
 294 {
 295         int ret;
 296
 297         ret = drm_mode_object_get(dev, &fb->base, DRM_MODE_OBJECT_FB);
 298         if (ret)
 299                 return ret;
 300
 301         fb->dev = dev;
 302         fb->funcs = funcs;
 303         dev->mode_config.num_fb++;
 304         list_add(&fb->head, &dev->mode_config.fb_list);
 305
 306         return 0;
 307 }
 308 EXPORT_SYMBOL(drm_framebuffer_init);
 309
 310 /**
 311  * drm_framebuffer_cleanup - remove a framebuffer object
 312  * @fb: framebuffer to remove
 313  *
 314  * LOCKING:
 315  * Caller must hold mode config lock.
 316  *
 317  * Scans all the CRTCs in @dev's mode_config.  If they're using @fb, removes
 318  * it, setting it to NULL.
 319  */
 320 void drm_framebuffer_cleanup(struct drm_framebuffer *fb)
 321 {
 322         struct drm_device *dev = fb->dev;
 323         struct drm_crtc *crtc;
 324         struct drm_plane *plane;
 325         struct drm_mode_set set;
 326         int ret;
 327
 328         /* remove from any CRTC */
 329         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 330                 if (crtc->fb == fb) {
 331                         /* should turn off the crtc */
 332                         memset(&set, 0, sizeof(struct drm_mode_set));
 333                         set.crtc = crtc;
 334                         set.fb = NULL;
 335                         ret = crtc->funcs->set_config(&set);
 336                         if (ret)
 337                                 DRM_ERROR("failed to reset crtc %p when fb was deleted\n", crtc);
 338                 }
 339         }
 340
 341         list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
 342                 if (plane->fb == fb) {
 343                         /* should turn off the crtc */
 344                         ret = plane->funcs->disable_plane(plane);
 345                         if (ret)
 346                                 DRM_ERROR("failed to disable plane with busy fb\n");
 347                         /* disconnect the plane from the fb and crtc: */
 348                         plane->fb = NULL;
 349                         plane->crtc = NULL;
 350                 }
 351         }
 352
 353         drm_mode_object_put(dev, &fb->base);
 354         list_del(&fb->head);
 355         dev->mode_config.num_fb--;
 356 }
 357 EXPORT_SYMBOL(drm_framebuffer_cleanup);
 358
 359 /**
 360  * drm_crtc_init - Initialise a new CRTC object
 361  * @dev: DRM device
 362  * @crtc: CRTC object to init
 363  * @funcs: callbacks for the new CRTC
 364  *
 365  * LOCKING:
 366  * Takes mode_config lock.
 367  *
 368  * Inits a new object created as base part of an driver crtc object.
 369  *
 370  * RETURNS:
 371  * Zero on success, error code on failure.
 372  */
 373 int drm_crtc_init(struct drm_device *dev, struct drm_crtc *crtc,
 374                    const struct drm_crtc_funcs *funcs)
 375 {
 376         int ret;
 377
 378         crtc->dev = dev;
 379         crtc->funcs = funcs;
 380
 381         mutex_lock(&dev->mode_config.mutex);
 382
 383         ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
 384         if (ret)
 385                 goto out;
 386
 387         crtc->base.properties = &crtc->properties;
 388
 389         list_add_tail(&crtc->head, &dev->mode_config.crtc_list);
 390         dev->mode_config.num_crtc++;
 391
 392  out:
 393         mutex_unlock(&dev->mode_config.mutex);
 394
 395         return ret;
 396 }
 397 EXPORT_SYMBOL(drm_crtc_init);
 398
 399 /**
 400  * drm_crtc_cleanup - Cleans up the core crtc usage.
 401  * @crtc: CRTC to cleanup
 402  *
 403  * LOCKING:
 404  * Caller must hold mode config lock.
 405  *
 406  * Cleanup @crtc. Removes from drm modesetting space
 407  * does NOT free object, caller does that.
 408  */
 409 void drm_crtc_cleanup(struct drm_crtc *crtc)
 410 {
 411         struct drm_device *dev = crtc->dev;
 412
 413         if (crtc->gamma_store) {
 414                 kfree(crtc->gamma_store);
 415                 crtc->gamma_store = NULL;
 416         }
 417
 418         drm_mode_object_put(dev, &crtc->base);
 419         list_del(&crtc->head);
 420         dev->mode_config.num_crtc--;
 421 }
 422 EXPORT_SYMBOL(drm_crtc_cleanup);
 423
 424 /**
 425  * drm_mode_probed_add - add a mode to a connector's probed mode list
 426  * @connector: connector the new mode
 427  * @mode: mode data
 428  *
 429  * LOCKING:
 430  * Caller must hold mode config lock.
 431  *
 432  * Add @mode to @connector's mode list for later use.
 433  */
 434 void drm_mode_probed_add(struct drm_connector *connector,
 435                          struct drm_display_mode *mode)
 436 {
 437         list_add(&mode->head, &connector->probed_modes);
 438 }
 439 EXPORT_SYMBOL(drm_mode_probed_add);
 440
 441 /**
 442  * drm_mode_remove - remove and free a mode
 443  * @connector: connector list to modify
 444  * @mode: mode to remove
 445  *
 446  * LOCKING:
 447  * Caller must hold mode config lock.
 448  *
 449  * Remove @mode from @connector's mode list, then free it.
 450  */
 451 void drm_mode_remove(struct drm_connector *connector,
 452                      struct drm_display_mode *mode)
 453 {
 454         list_del(&mode->head);
 455         drm_mode_destroy(connector->dev, mode);
 456 }
 457 EXPORT_SYMBOL(drm_mode_remove);
 458
 459 /**
 460  * drm_connector_init - Init a preallocated connector
 461  * @dev: DRM device
 462  * @connector: the connector to init
 463  * @funcs: callbacks for this connector
 464  * @name: user visible name of the connector
 465  *
 466  * LOCKING:
 467  * Takes mode config lock.
 468  *
 469  * Initialises a preallocated connector. Connectors should be
 470  * subclassed as part of driver connector objects.
 471  *
 472  * RETURNS:
 473  * Zero on success, error code on failure.
 474  */
 475 int drm_connector_init(struct drm_device *dev,
 476                        struct drm_connector *connector,
 477                        const struct drm_connector_funcs *funcs,
 478                        int connector_type)
 479 {
 480         int ret;
 481
 482         mutex_lock(&dev->mode_config.mutex);
 483
 484         ret = drm_mode_object_get(dev, &connector->base, DRM_MODE_OBJECT_CONNECTOR);
 485         if (ret)
 486                 goto out;
 487
 488         connector->base.properties = &connector->properties;
 489         connector->dev = dev;
 490         connector->funcs = funcs;
 491         connector->connector_type = connector_type;
 492         connector->connector_type_id =
 493                 ++drm_connector_enum_list[connector_type].count; /* TODO */
 494         INIT_LIST_HEAD(&connector->user_modes);
 495         INIT_LIST_HEAD(&connector->probed_modes);
 496         INIT_LIST_HEAD(&connector->modes);
 497         connector->edid_blob_ptr = NULL;
 498
 499         list_add_tail(&connector->head, &dev->mode_config.connector_list);
 500         dev->mode_config.num_connector++;
 501
 502         if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL)
 503                 drm_connector_attach_property(connector,
 504                                               dev->mode_config.edid_property,
 505                                               0);
 506
 507         drm_connector_attach_property(connector,
 508                                       dev->mode_config.dpms_property, 0);
 509
 510  out:
 511         mutex_unlock(&dev->mode_config.mutex);
 512
 513         return ret;
 514 }
 515 EXPORT_SYMBOL(drm_connector_init);
 516
 517 /**
 518  * drm_connector_cleanup - cleans up an initialised connector
 519  * @connector: connector to cleanup
 520  *
 521  * LOCKING:
 522  * Takes mode config lock.
 523  *
 524  * Cleans up the connector but doesn't free the object.
 525  */
 526 void drm_connector_cleanup(struct drm_connector *connector)
 527 {
 528         struct drm_device *dev = connector->dev;
 529         struct drm_display_mode *mode, *t;
 530
 531         list_for_each_entry_safe(mode, t, &connector->probed_modes, head)
 532                 drm_mode_remove(connector, mode);
 533
 534         list_for_each_entry_safe(mode, t, &connector->modes, head)
 535                 drm_mode_remove(connector, mode);
 536
 537         list_for_each_entry_safe(mode, t, &connector->user_modes, head)
 538                 drm_mode_remove(connector, mode);
 539
 540         mutex_lock(&dev->mode_config.mutex);
 541         drm_mode_object_put(dev, &connector->base);
 542         list_del(&connector->head);
 543         dev->mode_config.num_connector--;
 544         mutex_unlock(&dev->mode_config.mutex);
 545 }
 546 EXPORT_SYMBOL(drm_connector_cleanup);
 547
 548 void drm_connector_unplug_all(struct drm_device *dev)
 549 {
 550         struct drm_connector *connector;
 551
 552         /* taking the mode config mutex ends up in a clash with sysfs */
 553         list_for_each_entry(connector, &dev->mode_config.connector_list, head)
 554                 drm_sysfs_connector_remove(connector);
 555
 556 }
 557 EXPORT_SYMBOL(drm_connector_unplug_all);
 558
 559 int drm_encoder_init(struct drm_device *dev,
 560                       struct drm_encoder *encoder,
 561                       const struct drm_encoder_funcs *funcs,
 562                       int encoder_type)
 563 {
 564         int ret;
 565
 566         mutex_lock(&dev->mode_config.mutex);
 567
 568         ret = drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER);
 569         if (ret)
 570                 goto out;
 571
 572         encoder->dev = dev;
 573         encoder->encoder_type = encoder_type;
 574         encoder->funcs = funcs;
 575
 576         list_add_tail(&encoder->head, &dev->mode_config.encoder_list);
 577         dev->mode_config.num_encoder++;
 578
 579  out:
 580         mutex_unlock(&dev->mode_config.mutex);
 581
 582         return ret;
 583 }
 584 EXPORT_SYMBOL(drm_encoder_init);
 585
 586 void drm_encoder_cleanup(struct drm_encoder *encoder)
 587 {
 588         struct drm_device *dev = encoder->dev;
 589         mutex_lock(&dev->mode_config.mutex);
 590         drm_mode_object_put(dev, &encoder->base);
 591         list_del(&encoder->head);
 592         dev->mode_config.num_encoder--;
 593         mutex_unlock(&dev->mode_config.mutex);
 594 }
 595 EXPORT_SYMBOL(drm_encoder_cleanup);
 596
 597 int drm_plane_init(struct drm_device *dev, struct drm_plane *plane,
 598                    unsigned long possible_crtcs,
 599                    const struct drm_plane_funcs *funcs,
 600                    const uint32_t *formats, uint32_t format_count,
 601                    bool priv)
 602 {
 603         int ret;
 604
 605         mutex_lock(&dev->mode_config.mutex);
 606
 607         ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE);
 608         if (ret)
 609                 goto out;
 610
 611         plane->base.properties = &plane->properties;
 612         plane->dev = dev;
 613         plane->funcs = funcs;
 614         plane->format_types = kmalloc(sizeof(uint32_t) * format_count,
 615                                       GFP_KERNEL);
 616         if (!plane->format_types) {
 617                 DRM_DEBUG_KMS("out of memory when allocating plane\n");
 618                 drm_mode_object_put(dev, &plane->base);
 619                 ret = -ENOMEM;
 620                 goto out;
 621         }
 622
 623         memcpy(plane->format_types, formats, format_count * sizeof(uint32_t));
 624         plane->format_count = format_count;
 625         plane->possible_crtcs = possible_crtcs;
 626
 627         /* private planes are not exposed to userspace, but depending on
 628          * display hardware, might be convenient to allow sharing programming
 629          * for the scanout engine with the crtc implementation.
 630          */
 631         if (!priv) {
 632                 list_add_tail(&plane->head, &dev->mode_config.plane_list);
 633                 dev->mode_config.num_plane++;
 634         } else {
 635                 INIT_LIST_HEAD(&plane->head);
 636         }
 637
 638  out:
 639         mutex_unlock(&dev->mode_config.mutex);
 640
 641         return ret;
 642 }
 643 EXPORT_SYMBOL(drm_plane_init);
 644
 645 void drm_plane_cleanup(struct drm_plane *plane)
 646 {
 647         struct drm_device *dev = plane->dev;
 648
 649         mutex_lock(&dev->mode_config.mutex);
 650         kfree(plane->format_types);
 651         drm_mode_object_put(dev, &plane->base);
 652         /* if not added to a list, it must be a private plane */
 653         if (!list_empty(&plane->head)) {
 654                 list_del(&plane->head);
 655                 dev->mode_config.num_plane--;
 656         }
 657         mutex_unlock(&dev->mode_config.mutex);
 658 }
 659 EXPORT_SYMBOL(drm_plane_cleanup);
 660
 661 /**
 662  * drm_mode_create - create a new display mode
 663  * @dev: DRM device
 664  *
 665  * LOCKING:
 666  * Caller must hold DRM mode_config lock.
 667  *
 668  * Create a new drm_display_mode, give it an ID, and return it.
 669  *
 670  * RETURNS:
 671  * Pointer to new mode on success, NULL on error.
 672  */
 673 struct drm_display_mode *drm_mode_create(struct drm_device *dev)
 674 {
 675         struct drm_display_mode *nmode;
 676
 677         nmode = kzalloc(sizeof(struct drm_display_mode), GFP_KERNEL);
 678         if (!nmode)
 679                 return NULL;
 680
 681         if (drm_mode_object_get(dev, &nmode->base, DRM_MODE_OBJECT_MODE)) {
 682                 kfree(nmode);
 683                 return NULL;
 684         }
 685
 686         return nmode;
 687 }
 688 EXPORT_SYMBOL(drm_mode_create);
 689
 690 /**
 691  * drm_mode_destroy - remove a mode
 692  * @dev: DRM device
 693  * @mode: mode to remove
 694  *
 695  * LOCKING:
 696  * Caller must hold mode config lock.
 697  *
 698  * Free @mode's unique identifier, then free it.
 699  */
 700 void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode)
 701 {
 702         if (!mode)
 703                 return;
 704
 705         drm_mode_object_put(dev, &mode->base);
 706
 707         kfree(mode);
 708 }
 709 EXPORT_SYMBOL(drm_mode_destroy);
 710
 711 static int drm_mode_create_standard_connector_properties(struct drm_device *dev)
 712 {
 713         struct drm_property *edid;
 714         struct drm_property *dpms;
 715
 716         /*
 717          * Standard properties (apply to all connectors)
 718          */
 719         edid = drm_property_create(dev, DRM_MODE_PROP_BLOB |
 720                                    DRM_MODE_PROP_IMMUTABLE,
 721                                    "EDID", 0);
 722         dev->mode_config.edid_property = edid;
 723
 724         dpms = drm_property_create_enum(dev, 0,
 725                                    "DPMS", drm_dpms_enum_list,
 726                                    ARRAY_SIZE(drm_dpms_enum_list));
 727         dev->mode_config.dpms_property = dpms;
 728
 729         return 0;
 730 }
 731
 732 /**
 733  * drm_mode_create_dvi_i_properties - create DVI-I specific connector properties
 734  * @dev: DRM device
 735  *
 736  * Called by a driver the first time a DVI-I connector is made.
 737  */
 738 int drm_mode_create_dvi_i_properties(struct drm_device *dev)
 739 {
 740         struct drm_property *dvi_i_selector;
 741         struct drm_property *dvi_i_subconnector;
 742
 743         if (dev->mode_config.dvi_i_select_subconnector_property)
 744                 return 0;
 745
 746         dvi_i_selector =
 747                 drm_property_create_enum(dev, 0,
 748                                     "select subconnector",
 749                                     drm_dvi_i_select_enum_list,
 750                                     ARRAY_SIZE(drm_dvi_i_select_enum_list));
 751         dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector;
 752
 753         dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
 754                                     "subconnector",
 755                                     drm_dvi_i_subconnector_enum_list,
 756                                     ARRAY_SIZE(drm_dvi_i_subconnector_enum_list));
 757         dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector;
 758
 759         return 0;
 760 }
 761 EXPORT_SYMBOL(drm_mode_create_dvi_i_properties);
 762
 763 /**
 764  * drm_create_tv_properties - create TV specific connector properties
 765  * @dev: DRM device
 766  * @num_modes: number of different TV formats (modes) supported
 767  * @modes: array of pointers to strings containing name of each format
 768  *
 769  * Called by a driver's TV initialization routine, this function creates
 770  * the TV specific connector properties for a given device.  Caller is
 771  * responsible for allocating a list of format names and passing them to
 772  * this routine.
 773  */
 774 int drm_mode_create_tv_properties(struct drm_device *dev, int num_modes,
 775                                   char *modes[])
 776 {
 777         struct drm_property *tv_selector;
 778         struct drm_property *tv_subconnector;
 779         int i;
 780
 781         if (dev->mode_config.tv_select_subconnector_property)
 782                 return 0;
 783
 784         /*
 785          * Basic connector properties
 786          */
 787         tv_selector = drm_property_create_enum(dev, 0,
 788                                           "select subconnector",
 789                                           drm_tv_select_enum_list,
 790                                           ARRAY_SIZE(drm_tv_select_enum_list));
 791         dev->mode_config.tv_select_subconnector_property = tv_selector;
 792
 793         tv_subconnector =
 794                 drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
 795                                     "subconnector",
 796                                     drm_tv_subconnector_enum_list,
 797                                     ARRAY_SIZE(drm_tv_subconnector_enum_list));
 798         dev->mode_config.tv_subconnector_property = tv_subconnector;
 799
 800         /*
 801          * Other, TV specific properties: margins & TV modes.
 802          */
 803         dev->mode_config.tv_left_margin_property =
 804                 drm_property_create_range(dev, 0, "left margin", 0, 100);
 805
 806         dev->mode_config.tv_right_margin_property =
 807                 drm_property_create_range(dev, 0, "right margin", 0, 100);
 808
 809         dev->mode_config.tv_top_margin_property =
 810                 drm_property_create_range(dev, 0, "top margin", 0, 100);
 811
 812         dev->mode_config.tv_bottom_margin_property =
 813                 drm_property_create_range(dev, 0, "bottom margin", 0, 100);
 814
 815         dev->mode_config.tv_mode_property =
 816                 drm_property_create(dev, DRM_MODE_PROP_ENUM,
 817                                     "mode", num_modes);
 818         for (i = 0; i < num_modes; i++)
 819                 drm_property_add_enum(dev->mode_config.tv_mode_property, i,
 820                                       i, modes[i]);
 821
 822         dev->mode_config.tv_brightness_property =
 823                 drm_property_create_range(dev, 0, "brightness", 0, 100);
 824
 825         dev->mode_config.tv_contrast_property =
 826                 drm_property_create_range(dev, 0, "contrast", 0, 100);
 827
 828         dev->mode_config.tv_flicker_reduction_property =
 829                 drm_property_create_range(dev, 0, "flicker reduction", 0, 100);
 830
 831         dev->mode_config.tv_overscan_property =
 832                 drm_property_create_range(dev, 0, "overscan", 0, 100);
 833
 834         dev->mode_config.tv_saturation_property =
 835                 drm_property_create_range(dev, 0, "saturation", 0, 100);
 836
 837         dev->mode_config.tv_hue_property =
 838                 drm_property_create_range(dev, 0, "hue", 0, 100);
 839
 840         return 0;
 841 }
 842 EXPORT_SYMBOL(drm_mode_create_tv_properties);
 843
 844 /**
 845  * drm_mode_create_scaling_mode_property - create scaling mode property
 846  * @dev: DRM device
 847  *
 848  * Called by a driver the first time it's needed, must be attached to desired
 849  * connectors.
 850  */
 851 int drm_mode_create_scaling_mode_property(struct drm_device *dev)
 852 {
 853         struct drm_property *scaling_mode;
 854
 855         if (dev->mode_config.scaling_mode_property)
 856                 return 0;
 857
 858         scaling_mode =
 859                 drm_property_create_enum(dev, 0, "scaling mode",
 860                                 drm_scaling_mode_enum_list,
 861                                     ARRAY_SIZE(drm_scaling_mode_enum_list));
 862
 863         dev->mode_config.scaling_mode_property = scaling_mode;
 864
 865         return 0;
 866 }
 867 EXPORT_SYMBOL(drm_mode_create_scaling_mode_property);
 868
 869 /**
 870  * drm_mode_create_dithering_property - create dithering property
 871  * @dev: DRM device
 872  *
 873  * Called by a driver the first time it's needed, must be attached to desired
 874  * connectors.
 875  */
 876 int drm_mode_create_dithering_property(struct drm_device *dev)
 877 {
 878         struct drm_property *dithering_mode;
 879
 880         if (dev->mode_config.dithering_mode_property)
 881                 return 0;
 882
 883         dithering_mode =
 884                 drm_property_create_enum(dev, 0, "dithering",
 885                                 drm_dithering_mode_enum_list,
 886                                     ARRAY_SIZE(drm_dithering_mode_enum_list));
 887         dev->mode_config.dithering_mode_property = dithering_mode;
 888
 889         return 0;
 890 }
 891 EXPORT_SYMBOL(drm_mode_create_dithering_property);
 892
 893 /**
 894  * drm_mode_create_dirty_property - create dirty property
 895  * @dev: DRM device
 896  *
 897  * Called by a driver the first time it's needed, must be attached to desired
 898  * connectors.
 899  */
 900 int drm_mode_create_dirty_info_property(struct drm_device *dev)
 901 {
 902         struct drm_property *dirty_info;
 903
 904         if (dev->mode_config.dirty_info_property)
 905                 return 0;
 906
 907         dirty_info =
 908                 drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
 909                                     "dirty",
 910                                     drm_dirty_info_enum_list,
 911                                     ARRAY_SIZE(drm_dirty_info_enum_list));
 912         dev->mode_config.dirty_info_property = dirty_info;
 913
 914         return 0;
 915 }
 916 EXPORT_SYMBOL(drm_mode_create_dirty_info_property);
 917
 918 /**
 919  * drm_mode_config_init - initialize DRM mode_configuration structure
 920  * @dev: DRM device
 921  *
 922  * LOCKING:
 923  * None, should happen single threaded at init time.
 924  *
 925  * Initialize @dev's mode_config structure, used for tracking the graphics
 926  * configuration of @dev.
 927  */
 928 void drm_mode_config_init(struct drm_device *dev)
 929 {
 930         mutex_init(&dev->mode_config.mutex);
 931         mutex_init(&dev->mode_config.idr_mutex);
 932         INIT_LIST_HEAD(&dev->mode_config.fb_list);
 933         INIT_LIST_HEAD(&dev->mode_config.crtc_list);
 934         INIT_LIST_HEAD(&dev->mode_config.connector_list);
 935         INIT_LIST_HEAD(&dev->mode_config.encoder_list);
 936         INIT_LIST_HEAD(&dev->mode_config.property_list);
 937         INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
 938         INIT_LIST_HEAD(&dev->mode_config.plane_list);
 939         idr_init(&dev->mode_config.crtc_idr);
 940
 941         mutex_lock(&dev->mode_config.mutex);
 942         drm_mode_create_standard_connector_properties(dev);
 943         mutex_unlock(&dev->mode_config.mutex);
 944
 945         /* Just to be sure */
 946         dev->mode_config.num_fb = 0;
 947         dev->mode_config.num_connector = 0;
 948         dev->mode_config.num_crtc = 0;
 949         dev->mode_config.num_encoder = 0;
 950 }
 951 EXPORT_SYMBOL(drm_mode_config_init);
 952
 953 int drm_mode_group_init(struct drm_device *dev, struct drm_mode_group *group)
 954 {
 955         uint32_t total_objects = 0;
 956
 957         total_objects += dev->mode_config.num_crtc;
 958         total_objects += dev->mode_config.num_connector;
 959         total_objects += dev->mode_config.num_encoder;
 960
 961         group->id_list = kzalloc(total_objects * sizeof(uint32_t), GFP_KERNEL);
 962         if (!group->id_list)
 963                 return -ENOMEM;
 964
 965         group->num_crtcs = 0;
 966         group->num_connectors = 0;
 967         group->num_encoders = 0;
 968         return 0;
 969 }
 970
 971 int drm_mode_group_init_legacy_group(struct drm_device *dev,
 972                                      struct drm_mode_group *group)
 973 {
 974         struct drm_crtc *crtc;
 975         struct drm_encoder *encoder;
 976         struct drm_connector *connector;
 977         int ret;
 978
 979         if ((ret = drm_mode_group_init(dev, group)))
 980                 return ret;
 981
 982         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
 983                 group->id_list[group->num_crtcs++] = crtc->base.id;
 984
 985         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
 986                 group->id_list[group->num_crtcs + group->num_encoders++] =
 987                 encoder->base.id;
 988
 989         list_for_each_entry(connector, &dev->mode_config.connector_list, head)
 990                 group->id_list[group->num_crtcs + group->num_encoders +
 991                                group->num_connectors++] = connector->base.id;
 992
 993         return 0;
 994 }
 995 EXPORT_SYMBOL(drm_mode_group_init_legacy_group);
 996
 997 /**
 998  * drm_mode_config_cleanup - free up DRM mode_config info
 999  * @dev: DRM device
1000  *
1001  * LOCKING:
1002  * Caller must hold mode config lock.
1003  *
1004  * Free up all the connectors and CRTCs associated with this DRM device, then
1005  * free up the framebuffers and associated buffer objects.
1006  *
1007  * FIXME: cleanup any dangling user buffer objects too
1008  */
1009 void drm_mode_config_cleanup(struct drm_device *dev)
1010 {
1011         struct drm_connector *connector, *ot;
1012         struct drm_crtc *crtc, *ct;
1013         struct drm_encoder *encoder, *enct;
1014         struct drm_framebuffer *fb, *fbt;
1015         struct drm_property *property, *pt;
1016         struct drm_plane *plane, *plt;
1017
1018         list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list,
1019                                  head) {
1020                 encoder->funcs->destroy(encoder);
1021         }
1022
1023         list_for_each_entry_safe(connector, ot,
1024                                  &dev->mode_config.connector_list, head) {
1025                 connector->funcs->destroy(connector);
1026         }
1027
1028         list_for_each_entry_safe(property, pt, &dev->mode_config.property_list,
1029                                  head) {
1030                 drm_property_destroy(dev, property);
1031         }
1032
1033         list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
1034                 fb->funcs->destroy(fb);
1035         }
1036
1037         list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) {
1038                 crtc->funcs->destroy(crtc);
1039         }
1040
1041         list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list,
1042                                  head) {
1043                 plane->funcs->destroy(plane);
1044         }
1045
1046         idr_remove_all(&dev->mode_config.crtc_idr);
1047         idr_destroy(&dev->mode_config.crtc_idr);
1048 }
1049 EXPORT_SYMBOL(drm_mode_config_cleanup);
1050
1051 /**
1052  * drm_crtc_convert_to_umode - convert a drm_display_mode into a modeinfo
1053  * @out: drm_mode_modeinfo struct to return to the user
1054  * @in: drm_display_mode to use
1055  *
1056  * LOCKING:
1057  * None.
1058  *
1059  * Convert a drm_display_mode into a drm_mode_modeinfo structure to return to
1060  * the user.
1061  */
1062 static void drm_crtc_convert_to_umode(struct drm_mode_modeinfo *out,
1063                                       const struct drm_display_mode *in)
1064 {
1065         WARN(in->hdisplay > USHRT_MAX || in->hsync_start > USHRT_MAX ||
1066              in->hsync_end > USHRT_MAX || in->htotal > USHRT_MAX ||
1067              in->hskew > USHRT_MAX || in->vdisplay > USHRT_MAX ||
1068              in->vsync_start > USHRT_MAX || in->vsync_end > USHRT_MAX ||
1069              in->vtotal > USHRT_MAX || in->vscan > USHRT_MAX,
1070              "timing values too large for mode info\n");
1071
1072         out->clock = in->clock;
1073         out->hdisplay = in->hdisplay;
1074         out->hsync_start = in->hsync_start;
1075         out->hsync_end = in->hsync_end;
1076         out->htotal = in->htotal;
1077         out->hskew = in->hskew;
1078         out->vdisplay = in->vdisplay;
1079         out->vsync_start = in->vsync_start;
1080         out->vsync_end = in->vsync_end;
1081         out->vtotal = in->vtotal;
1082         out->vscan = in->vscan;
1083         out->vrefresh = in->vrefresh;
1084         out->flags = in->flags;
1085         out->type = in->type;
1086         strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
1087         out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
1088 }
1089
1090 /**
1091  * drm_crtc_convert_to_umode - convert a modeinfo into a drm_display_mode
1092  * @out: drm_display_mode to return to the user
1093  * @in: drm_mode_modeinfo to use
1094  *
1095  * LOCKING:
1096  * None.
1097  *
1098  * Convert a drm_mode_modeinfo into a drm_display_mode structure to return to
1099  * the caller.
1100  *
1101  * RETURNS:
1102  * Zero on success, errno on failure.
1103  */
1104 static int drm_crtc_convert_umode(struct drm_display_mode *out,
1105                                   const struct drm_mode_modeinfo *in)
1106 {
1107         if (in->clock > INT_MAX || in->vrefresh > INT_MAX)
1108                 return -ERANGE;
1109
1110         out->clock = in->clock;
1111         out->hdisplay = in->hdisplay;
1112         out->hsync_start = in->hsync_start;
1113         out->hsync_end = in->hsync_end;
1114         out->htotal = in->htotal;
1115         out->hskew = in->hskew;
1116         out->vdisplay = in->vdisplay;
1117         out->vsync_start = in->vsync_start;
1118         out->vsync_end = in->vsync_end;
1119         out->vtotal = in->vtotal;
1120         out->vscan = in->vscan;
1121         out->vrefresh = in->vrefresh;
1122         out->flags = in->flags;
1123         out->type = in->type;
1124         strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
1125         out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
1126
1127         return 0;
1128 }
1129
1130 /**
1131  * drm_mode_getresources - get graphics configuration
1132  * @inode: inode from the ioctl
1133  * @filp: file * from the ioctl
1134  * @cmd: cmd from ioctl
1135  * @arg: arg from ioctl
1136  *
1137  * LOCKING:
1138  * Takes mode config lock.
1139  *
1140  * Construct a set of configuration description structures and return
1141  * them to the user, including CRTC, connector and framebuffer configuration.
1142  *
1143  * Called by the user via ioctl.
1144  *
1145  * RETURNS:
1146  * Zero on success, errno on failure.
1147  */
1148 int drm_mode_getresources(struct drm_device *dev, void *data,
1149                           struct drm_file *file_priv)
1150 {
1151         struct drm_mode_card_res *card_res = data;
1152         struct list_head *lh;
1153         struct drm_framebuffer *fb;
1154         struct drm_connector *connector;
1155         struct drm_crtc *crtc;
1156         struct drm_encoder *encoder;
1157         int ret = 0;
1158         int connector_count = 0;
1159         int crtc_count = 0;
1160         int fb_count = 0;
1161         int encoder_count = 0;
1162         int copied = 0, i;
1163         uint32_t __user *fb_id;
1164         uint32_t __user *crtc_id;
1165         uint32_t __user *connector_id;
1166         uint32_t __user *encoder_id;
1167         struct drm_mode_group *mode_group;
1168
1169         if (!drm_core_check_feature(dev, DRIVER_MODESET))
1170                 return -EINVAL;
1171
1172         mutex_lock(&dev->mode_config.mutex);
1173
1174         /*
1175          * For the non-control nodes we need to limit the list of resources
1176          * by IDs in the group list for this node
1177          */
1178         list_for_each(lh, &file_priv->fbs)
1179                 fb_count++;
1180
1181         mode_group = &file_priv->master->minor->mode_group;
1182         if (file_priv->master->minor->type == DRM_MINOR_CONTROL) {
1183
1184                 list_for_each(lh, &dev->mode_config.crtc_list)
1185                         crtc_count++;
1186
1187                 list_for_each(lh, &dev->mode_config.connector_list)
1188                         connector_count++;
1189
1190                 list_for_each(lh, &dev->mode_config.encoder_list)
1191                         encoder_count++;
1192         } else {
1193
1194                 crtc_count = mode_group->num_crtcs;
1195                 connector_count = mode_group->num_connectors;
1196                 encoder_count = mode_group->num_encoders;
1197         }
1198
1199         card_res->max_height = dev->mode_config.max_height;
1200         card_res->min_height = dev->mode_config.min_height;
1201         card_res->max_width = dev->mode_config.max_width;
1202         card_res->min_width = dev->mode_config.min_width;
1203
1204         /* handle this in 4 parts */
1205         /* FBs */
1206         if (card_res->count_fbs >= fb_count) {
1207                 copied = 0;
1208                 fb_id = (uint32_t __user *)(unsigned long)card_res->fb_id_ptr;
1209                 list_for_each_entry(fb, &file_priv->fbs, filp_head) {
1210                         if (put_user(fb->base.id, fb_id + copied)) {
1211                                 ret = -EFAULT;
1212                                 goto out;
1213                         }
1214                         copied++;
1215                 }
1216         }
1217         card_res->count_fbs = fb_count;
1218
1219         /* CRTCs */
1220         if (card_res->count_crtcs >= crtc_count) {
1221                 copied = 0;
1222                 crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr;
1223                 if (file_priv->master->minor->type == DRM_MINOR_CONTROL) {
1224                         list_for_each_entry(crtc, &dev->mode_config.crtc_list,
1225                                             head) {
1226                                 DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
1227                                 if (put_user(crtc->base.id, crtc_id + copied)) {
1228                                         ret = -EFAULT;
1229                                         goto out;
1230                                 }
1231                                 copied++;
1232                         }
1233                 } else {
1234                         for (i = 0; i < mode_group->num_crtcs; i++) {
1235                                 if (put_user(mode_group->id_list[i],
1236                                              crtc_id + copied)) {
1237                                         ret = -EFAULT;
1238                                         goto out;
1239                                 }
1240                                 copied++;
1241                         }
1242                 }
1243         }
1244         card_res->count_crtcs = crtc_count;
1245
1246         /* Encoders */
1247         if (card_res->count_encoders >= encoder_count) {
1248                 copied = 0;
1249                 encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr;
1250                 if (file_priv->master->minor->type == DRM_MINOR_CONTROL) {
1251                         list_for_each_entry(encoder,
1252                                             &dev->mode_config.encoder_list,
1253                                             head) {
1254                                 DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id,
1255                                                 drm_get_encoder_name(encoder));
1256                                 if (put_user(encoder->base.id, encoder_id +
1257                                              copied)) {
1258                                         ret = -EFAULT;
1259                                         goto out;
1260                                 }
1261                                 copied++;
1262                         }
1263                 } else {
1264                         for (i = mode_group->num_crtcs; i < mode_group->num_crtcs + mode_group->num_encoders; i++) {
1265                                 if (put_user(mode_group->id_list[i],
1266                                              encoder_id + copied)) {
1267                                         ret = -EFAULT;
1268                                         goto out;
1269                                 }
1270                                 copied++;
1271                         }
1272
1273                 }
1274         }
1275         card_res->count_encoders = encoder_count;
1276
1277         /* Connectors */
1278         if (card_res->count_connectors >= connector_count) {
1279                 copied = 0;
1280                 connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr;
1281                 if (file_priv->master->minor->type == DRM_MINOR_CONTROL) {
1282                         list_for_each_entry(connector,
1283                                             &dev->mode_config.connector_list,
1284                                             head) {
1285                                 DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
1286                                         connector->base.id,
1287                                         drm_get_connector_name(connector));
1288                                 if (put_user(connector->base.id,
1289                                              connector_id + copied)) {
1290                                         ret = -EFAULT;
1291                                         goto out;
1292                                 }
1293                                 copied++;
1294                         }
1295                 } else {
1296                         int start = mode_group->num_crtcs +
1297                                 mode_group->num_encoders;
1298                         for (i = start; i < start + mode_group->num_connectors; i++) {
1299                                 if (put_user(mode_group->id_list[i],
1300                                              connector_id + copied)) {
1301                                         ret = -EFAULT;
1302                                         goto out;
1303                                 }
1304                                 copied++;
1305                         }
1306                 }
1307         }
1308         card_res->count_connectors = connector_count;
1309
1310         DRM_DEBUG_KMS("CRTC[%d] CONNECTORS[%d] ENCODERS[%d]\n", card_res->count_crtcs,
1311                   card_res->count_connectors, card_res->count_encoders);
1312
1313 out:
1314         mutex_unlock(&dev->mode_config.mutex);
1315         return ret;
1316 }
1317
1318 /**
1319  * drm_mode_getcrtc - get CRTC configuration
1320  * @inode: inode from the ioctl
1321  * @filp: file * from the ioctl
1322  * @cmd: cmd from ioctl
1323  * @arg: arg from ioctl
1324  *
1325  * LOCKING:
1326  * Takes mode config lock.
1327  *
1328  * Construct a CRTC configuration structure to return to the user.
1329  *
1330  * Called by the user via ioctl.
1331  *
1332  * RETURNS:
1333  * Zero on success, errno on failure.
1334  */
1335 int drm_mode_getcrtc(struct drm_device *dev,
1336                      void *data, struct drm_file *file_priv)
1337 {
1338         struct drm_mode_crtc *crtc_resp = data;
1339         struct drm_crtc *crtc;
1340         struct drm_mode_object *obj;
1341         int ret = 0;
1342
1343         if (!drm_core_check_feature(dev, DRIVER_MODESET))
1344                 return -EINVAL;
1345
1346         mutex_lock(&dev->mode_config.mutex);
1347
1348         obj = drm_mode_object_find(dev, crtc_resp->crtc_id,
1349                                    DRM_MODE_OBJECT_CRTC);
1350         if (!obj) {
1351                 ret = -EINVAL;
1352                 goto out;
1353         }
1354         crtc = obj_to_crtc(obj);
1355
1356         crtc_resp->x = crtc->x;
1357         crtc_resp->y = crtc->y;
1358         crtc_resp->gamma_size = crtc->gamma_size;
1359         if (crtc->fb)
1360                 crtc_resp->fb_id = crtc->fb->base.id;
1361         else
1362                 crtc_resp->fb_id = 0;
1363
1364         if (crtc->enabled) {
1365
1366                 drm_crtc_convert_to_umode(&crtc_resp->mode, &crtc->mode);
1367                 crtc_resp->mode_valid = 1;
1368
1369         } else {
1370                 crtc_resp->mode_valid = 0;
1371         }
1372
1373 out:
1374         mutex_unlock(&dev->mode_config.mutex);
1375         return ret;
1376 }
1377
1378 /**
1379  * drm_mode_getconnector - get connector configuration
1380  * @inode: inode from the ioctl
1381  * @filp: file * from the ioctl
1382  * @cmd: cmd from ioctl
1383  * @arg: arg from ioctl
1384  *
1385  * LOCKING:
1386  * Takes mode config lock.
1387  *
1388  * Construct a connector configuration structure to return to the user.
1389  *
1390  * Called by the user via ioctl.
1391  *
1392  * RETURNS:
1393  * Zero on success, errno on failure.
1394  */
1395 int drm_mode_getconnector(struct drm_device *dev, void *data,
1396                           struct drm_file *file_priv)
1397 {
1398         struct drm_mode_get_connector *out_resp = data;
1399         struct drm_mode_object *obj;
1400         struct drm_connector *connector;
1401         struct drm_display_mode *mode;
1402         int mode_count = 0;
1403         int props_count = 0;
1404         int encoders_count = 0;
1405         int ret = 0;
1406         int copied = 0;
1407         int i;
1408         struct drm_mode_modeinfo u_mode;
1409         struct drm_mode_modeinfo __user *mode_ptr;
1410         uint32_t __user *prop_ptr;
1411         uint64_t __user *prop_values;
1412         uint32_t __user *encoder_ptr;
1413
1414         if (!drm_core_check_feature(dev, DRIVER_MODESET))
1415                 return -EINVAL;
1416
1417         memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
1418
1419         DRM_DEBUG_KMS("[CONNECTOR:%d:?]\n", out_resp->connector_id);
1420
1421         mutex_lock(&dev->mode_config.mutex);
1422
1423         obj = drm_mode_object_find(dev, out_resp->connector_id,
1424                                    DRM_MODE_OBJECT_CONNECTOR);
1425         if (!obj) {
1426                 ret = -EINVAL;
1427                 goto out;
1428         }
1429         connector = obj_to_connector(obj);
1430
1431         props_count = connector->properties.count;
1432
1433         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
1434                 if (connector->encoder_ids[i] != 0) {
1435                         encoders_count++;
1436                 }
1437         }
1438
1439         if (out_resp->count_modes == 0) {
1440                 connector->funcs->fill_modes(connector,
1441                                              dev->mode_config.max_width,
1442                                              dev->mode_config.max_height);
1443         }
1444
1445         /* delayed so we get modes regardless of pre-fill_modes state */
1446         list_for_each_entry(mode, &connector->modes, head)
1447                 mode_count++;
1448
1449         out_resp->connector_id = connector->base.id;
1450         out_resp->connector_type = connector->connector_type;
1451         out_resp->connector_type_id = connector->connector_type_id;
1452         out_resp->mm_width = connector->display_info.width_mm;
1453         out_resp->mm_height = connector->display_info.height_mm;
1454         out_resp->subpixel = connector->display_info.subpixel_order;
1455         out_resp->connection = connector->status;
1456         if (connector->encoder)
1457                 out_resp->encoder_id = connector->encoder->base.id;
1458         else
1459                 out_resp->encoder_id = 0;
1460
1461         /*
1462          * This ioctl is called twice, once to determine how much space is
1463          * needed, and the 2nd time to fill it.
1464          */
1465         if ((out_resp->count_modes >= mode_count) && mode_count) {
1466                 copied = 0;
1467                 mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr;
1468                 list_for_each_entry(mode, &connector->modes, head) {
1469                         drm_crtc_convert_to_umode(&u_mode, mode);
1470                         if (copy_to_user(mode_ptr + copied,
1471                                          &u_mode, sizeof(u_mode))) {
1472                                 ret = -EFAULT;
1473                                 goto out;
1474                         }
1475                         copied++;
1476                 }
1477         }
1478         out_resp->count_modes = mode_count;
1479
1480         if ((out_resp->count_props >= props_count) && props_count) {
1481                 copied = 0;
1482                 prop_ptr = (uint32_t __user *)(unsigned long)(out_resp->props_ptr);
1483                 prop_values = (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr);
1484                 for (i = 0; i < connector->properties.count; i++) {
1485                         if (put_user(connector->properties.ids[i],
1486                                      prop_ptr + copied)) {
1487                                 ret = -EFAULT;
1488                                 goto out;
1489                         }
1490
1491                         if (put_user(connector->properties.values[i],
1492                                      prop_values + copied)) {
1493                                 ret = -EFAULT;
1494                                 goto out;
1495                         }
1496                         copied++;
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;
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_DEBUG_KMS("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(const 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(const 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_DEBUG_KMS("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_DEBUG_KMS("bad framebuffer width %u\n", r->height);
2204                 return -EINVAL;
2205         }
2206
2207         if (r->height == 0 || r->height % vsub) {
2208                 DRM_DEBUG_KMS("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_DEBUG_KMS("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_DEBUG_KMS("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;
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_DEBUG_KMS("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_DEBUG_KMS("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_DEBUG_KMS("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;
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;
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;
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_bitmask(struct drm_device *dev,
2753                                          int flags, const char *name,
2754                                          const struct drm_prop_enum_list *props,
2755                                          int num_values)
2756 {
2757         struct drm_property *property;
2758         int i, ret;
2759
2760         flags |= DRM_MODE_PROP_BITMASK;
2761
2762         property = drm_property_create(dev, flags, name, num_values);
2763         if (!property)
2764                 return NULL;
2765
2766         for (i = 0; i < num_values; i++) {
2767                 ret = drm_property_add_enum(property, i,
2768                                       props[i].type,
2769                                       props[i].name);
2770                 if (ret) {
2771                         drm_property_destroy(dev, property);
2772                         return NULL;
2773                 }
2774         }
2775
2776         return property;
2777 }
2778 EXPORT_SYMBOL(drm_property_create_bitmask);
2779
2780 struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
2781                                          const char *name,
2782                                          uint64_t min, uint64_t max)
2783 {
2784         struct drm_property *property;
2785
2786         flags |= DRM_MODE_PROP_RANGE;
2787
2788         property = drm_property_create(dev, flags, name, 2);
2789         if (!property)
2790                 return NULL;
2791
2792         property->values[0] = min;
2793         property->values[1] = max;
2794
2795         return property;
2796 }
2797 EXPORT_SYMBOL(drm_property_create_range);
2798
2799 int drm_property_add_enum(struct drm_property *property, int index,
2800                           uint64_t value, const char *name)
2801 {
2802         struct drm_property_enum *prop_enum;
2803
2804         if (!(property->flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)))
2805                 return -EINVAL;
2806
2807         /*
2808          * Bitmask enum properties have the additional constraint of values
2809          * from 0 to 63
2810          */
2811         if ((property->flags & DRM_MODE_PROP_BITMASK) && (value > 63))
2812                 return -EINVAL;
2813
2814         if (!list_empty(&property->enum_blob_list)) {
2815                 list_for_each_entry(prop_enum, &property->enum_blob_list, head) {
2816                         if (prop_enum->value == value) {
2817                                 strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
2818                                 prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
2819                                 return 0;
2820                         }
2821                 }
2822         }
2823
2824         prop_enum = kzalloc(sizeof(struct drm_property_enum), GFP_KERNEL);
2825         if (!prop_enum)
2826                 return -ENOMEM;
2827
2828         strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
2829         prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
2830         prop_enum->value = value;
2831
2832         property->values[index] = value;
2833         list_add_tail(&prop_enum->head, &property->enum_blob_list);
2834         return 0;
2835 }
2836 EXPORT_SYMBOL(drm_property_add_enum);
2837
2838 void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
2839 {
2840         struct drm_property_enum *prop_enum, *pt;
2841
2842         list_for_each_entry_safe(prop_enum, pt, &property->enum_blob_list, head) {
2843                 list_del(&prop_enum->head);
2844                 kfree(prop_enum);
2845         }
2846
2847         if (property->num_values)
2848                 kfree(property->values);
2849         drm_mode_object_put(dev, &property->base);
2850         list_del(&property->head);
2851         kfree(property);
2852 }
2853 EXPORT_SYMBOL(drm_property_destroy);
2854
2855 void drm_connector_attach_property(struct drm_connector *connector,
2856                                struct drm_property *property, uint64_t init_val)
2857 {
2858         drm_object_attach_property(&connector->base, property, init_val);
2859 }
2860 EXPORT_SYMBOL(drm_connector_attach_property);
2861
2862 int drm_connector_property_set_value(struct drm_connector *connector,
2863                                   struct drm_property *property, uint64_t value)
2864 {
2865         return drm_object_property_set_value(&connector->base, property, value);
2866 }
2867 EXPORT_SYMBOL(drm_connector_property_set_value);
2868
2869 int drm_connector_property_get_value(struct drm_connector *connector,
2870                                   struct drm_property *property, uint64_t *val)
2871 {
2872         return drm_object_property_get_value(&connector->base, property, val);
2873 }
2874 EXPORT_SYMBOL(drm_connector_property_get_value);
2875
2876 void drm_object_attach_property(struct drm_mode_object *obj,
2877                                 struct drm_property *property,
2878                                 uint64_t init_val)
2879 {
2880         int count = obj->properties->count;
2881
2882         if (count == DRM_OBJECT_MAX_PROPERTY) {
2883                 WARN(1, "Failed to attach object property (type: 0x%x). Please "
2884                         "increase DRM_OBJECT_MAX_PROPERTY by 1 for each time "
2885                         "you see this message on the same object type.\n",
2886                         obj->type);
2887                 return;
2888         }
2889
2890         obj->properties->ids[count] = property->base.id;
2891         obj->properties->values[count] = init_val;
2892         obj->properties->count++;
2893 }
2894 EXPORT_SYMBOL(drm_object_attach_property);
2895
2896 int drm_object_property_set_value(struct drm_mode_object *obj,
2897                                   struct drm_property *property, uint64_t val)
2898 {
2899         int i;
2900
2901         for (i = 0; i < obj->properties->count; i++) {
2902                 if (obj->properties->ids[i] == property->base.id) {
2903                         obj->properties->values[i] = val;
2904                         return 0;
2905                 }
2906         }
2907
2908         return -EINVAL;
2909 }
2910 EXPORT_SYMBOL(drm_object_property_set_value);
2911
2912 int drm_object_property_get_value(struct drm_mode_object *obj,
2913                                   struct drm_property *property, uint64_t *val)
2914 {
2915         int i;
2916
2917         for (i = 0; i < obj->properties->count; i++) {
2918                 if (obj->properties->ids[i] == property->base.id) {
2919                         *val = obj->properties->values[i];
2920                         return 0;
2921                 }
2922         }
2923
2924         return -EINVAL;
2925 }
2926 EXPORT_SYMBOL(drm_object_property_get_value);
2927
2928 int drm_mode_getproperty_ioctl(struct drm_device *dev,
2929                                void *data, struct drm_file *file_priv)
2930 {
2931         struct drm_mode_object *obj;
2932         struct drm_mode_get_property *out_resp = data;
2933         struct drm_property *property;
2934         int enum_count = 0;
2935         int blob_count = 0;
2936         int value_count = 0;
2937         int ret = 0, i;
2938         int copied;
2939         struct drm_property_enum *prop_enum;
2940         struct drm_mode_property_enum __user *enum_ptr;
2941         struct drm_property_blob *prop_blob;
2942         uint32_t __user *blob_id_ptr;
2943         uint64_t __user *values_ptr;
2944         uint32_t __user *blob_length_ptr;
2945
2946         if (!drm_core_check_feature(dev, DRIVER_MODESET))
2947                 return -EINVAL;
2948
2949         mutex_lock(&dev->mode_config.mutex);
2950         obj = drm_mode_object_find(dev, out_resp->prop_id, DRM_MODE_OBJECT_PROPERTY);
2951         if (!obj) {
2952                 ret = -EINVAL;
2953                 goto done;
2954         }
2955         property = obj_to_property(obj);
2956
2957         if (property->flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)) {
2958                 list_for_each_entry(prop_enum, &property->enum_blob_list, head)
2959                         enum_count++;
2960         } else if (property->flags & DRM_MODE_PROP_BLOB) {
2961                 list_for_each_entry(prop_blob, &property->enum_blob_list, head)
2962                         blob_count++;
2963         }
2964
2965         value_count = property->num_values;
2966
2967         strncpy(out_resp->name, property->name, DRM_PROP_NAME_LEN);
2968         out_resp->name[DRM_PROP_NAME_LEN-1] = 0;
2969         out_resp->flags = property->flags;
2970
2971         if ((out_resp->count_values >= value_count) && value_count) {
2972                 values_ptr = (uint64_t __user *)(unsigned long)out_resp->values_ptr;
2973                 for (i = 0; i < value_count; i++) {
2974                         if (copy_to_user(values_ptr + i, &property->values[i], sizeof(uint64_t))) {
2975                                 ret = -EFAULT;
2976                                 goto done;
2977                         }
2978                 }
2979         }
2980         out_resp->count_values = value_count;
2981
2982         if (property->flags & (DRM_MODE_PROP_ENUM | DRM_MODE_PROP_BITMASK)) {
2983                 if ((out_resp->count_enum_blobs >= enum_count) && enum_count) {
2984                         copied = 0;
2985                         enum_ptr = (struct drm_mode_property_enum __user *)(unsigned long)out_resp->enum_blob_ptr;
2986                         list_for_each_entry(prop_enum, &property->enum_blob_list, head) {
2987
2988                                 if (copy_to_user(&enum_ptr[copied].value, &prop_enum->value, sizeof(uint64_t))) {
2989                                         ret = -EFAULT;
2990                                         goto done;
2991                                 }
2992
2993                                 if (copy_to_user(&enum_ptr[copied].name,
2994                                                  &prop_enum->name, DRM_PROP_NAME_LEN)) {
2995                                         ret = -EFAULT;
2996                                         goto done;
2997                                 }
2998                                 copied++;
2999                         }
3000                 }
3001                 out_resp->count_enum_blobs = enum_count;
3002         }
3003
3004         if (property->flags & DRM_MODE_PROP_BLOB) {
3005                 if ((out_resp->count_enum_blobs >= blob_count) && blob_count) {
3006                         copied = 0;
3007                         blob_id_ptr = (uint32_t __user *)(unsigned long)out_resp->enum_blob_ptr;
3008                         blob_length_ptr = (uint32_t __user *)(unsigned long)out_resp->values_ptr;
3009
3010                         list_for_each_entry(prop_blob, &property->enum_blob_list, head) {
3011                                 if (put_user(prop_blob->base.id, blob_id_ptr + copied)) {
3012                                         ret = -EFAULT;
3013                                         goto done;
3014                                 }
3015
3016                                 if (put_user(prop_blob->length, blob_length_ptr + copied)) {
3017                                         ret = -EFAULT;
3018                                         goto done;
3019                                 }
3020
3021                                 copied++;
3022                         }
3023                 }
3024                 out_resp->count_enum_blobs = blob_count;
3025         }
3026 done:
3027         mutex_unlock(&dev->mode_config.mutex);
3028         return ret;
3029 }
3030
3031 static struct drm_property_blob *drm_property_create_blob(struct drm_device *dev, int length,
3032                                                           void *data)
3033 {
3034         struct drm_property_blob *blob;
3035         int ret;
3036
3037         if (!length || !data)
3038                 return NULL;
3039
3040         blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
3041         if (!blob)
3042                 return NULL;
3043
3044         ret = drm_mode_object_get(dev, &blob->base, DRM_MODE_OBJECT_BLOB);
3045         if (ret) {
3046                 kfree(blob);
3047                 return NULL;
3048         }
3049
3050         blob->length = length;
3051
3052         memcpy(blob->data, data, length);
3053
3054         list_add_tail(&blob->head, &dev->mode_config.property_blob_list);
3055         return blob;
3056 }
3057
3058 static void drm_property_destroy_blob(struct drm_device *dev,
3059                                struct drm_property_blob *blob)
3060 {
3061         drm_mode_object_put(dev, &blob->base);
3062         list_del(&blob->head);
3063         kfree(blob);
3064 }
3065
3066 int drm_mode_getblob_ioctl(struct drm_device *dev,
3067                            void *data, struct drm_file *file_priv)
3068 {
3069         struct drm_mode_object *obj;
3070         struct drm_mode_get_blob *out_resp = data;
3071         struct drm_property_blob *blob;
3072         int ret = 0;
3073         void __user *blob_ptr;
3074
3075         if (!drm_core_check_feature(dev, DRIVER_MODESET))
3076                 return -EINVAL;
3077
3078         mutex_lock(&dev->mode_config.mutex);
3079         obj = drm_mode_object_find(dev, out_resp->blob_id, DRM_MODE_OBJECT_BLOB);
3080         if (!obj) {
3081                 ret = -EINVAL;
3082                 goto done;
3083         }
3084         blob = obj_to_blob(obj);
3085
3086         if (out_resp->length == blob->length) {
3087                 blob_ptr = (void __user *)(unsigned long)out_resp->data;
3088                 if (copy_to_user(blob_ptr, blob->data, blob->length)){
3089                         ret = -EFAULT;
3090                         goto done;
3091                 }
3092         }
3093         out_resp->length = blob->length;
3094
3095 done:
3096         mutex_unlock(&dev->mode_config.mutex);
3097         return ret;
3098 }
3099
3100 int drm_mode_connector_update_edid_property(struct drm_connector *connector,
3101                                             struct edid *edid)
3102 {
3103         struct drm_device *dev = connector->dev;
3104         int ret, size;
3105
3106         if (connector->edid_blob_ptr)
3107                 drm_property_destroy_blob(dev, connector->edid_blob_ptr);
3108
3109         /* Delete edid, when there is none. */
3110         if (!edid) {
3111                 connector->edid_blob_ptr = NULL;
3112                 ret = drm_connector_property_set_value(connector, dev->mode_config.edid_property, 0);
3113                 return ret;
3114         }
3115
3116         size = EDID_LENGTH * (1 + edid->extensions);
3117         connector->edid_blob_ptr = drm_property_create_blob(connector->dev,
3118                                                             size, edid);
3119
3120         ret = drm_connector_property_set_value(connector,
3121                                                dev->mode_config.edid_property,
3122                                                connector->edid_blob_ptr->base.id);
3123
3124         return ret;
3125 }
3126 EXPORT_SYMBOL(drm_mode_connector_update_edid_property);
3127
3128 static bool drm_property_change_is_valid(struct drm_property *property,
3129                                          uint64_t value)
3130 {
3131         if (property->flags & DRM_MODE_PROP_IMMUTABLE)
3132                 return false;
3133         if (property->flags & DRM_MODE_PROP_RANGE) {
3134                 if (value < property->values[0] || value > property->values[1])
3135                         return false;
3136                 return true;
3137         } else if (property->flags & DRM_MODE_PROP_BITMASK) {
3138                 int i;
3139                 uint64_t valid_mask = 0;
3140                 for (i = 0; i < property->num_values; i++)
3141                         valid_mask |= (1ULL << property->values[i]);
3142                 return !(value & ~valid_mask);
3143         } else {
3144                 int i;
3145                 for (i = 0; i < property->num_values; i++)
3146                         if (property->values[i] == value)
3147                                 return true;
3148                 return false;
3149         }
3150 }
3151
3152 int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
3153                                        void *data, struct drm_file *file_priv)
3154 {
3155         struct drm_mode_connector_set_property *conn_set_prop = data;
3156         struct drm_mode_obj_set_property obj_set_prop = {
3157                 .value = conn_set_prop->value,
3158                 .prop_id = conn_set_prop->prop_id,
3159                 .obj_id = conn_set_prop->connector_id,
3160                 .obj_type = DRM_MODE_OBJECT_CONNECTOR
3161         };
3162
3163         /* It does all the locking and checking we need */
3164         return drm_mode_obj_set_property_ioctl(dev, &obj_set_prop, file_priv);
3165 }
3166
3167 static int drm_mode_connector_set_obj_prop(struct drm_mode_object *obj,
3168                                            struct drm_property *property,
3169                                            uint64_t value)
3170 {
3171         int ret = -EINVAL;
3172         struct drm_connector *connector = obj_to_connector(obj);
3173
3174         /* Do DPMS ourselves */
3175         if (property == connector->dev->mode_config.dpms_property) {
3176                 if (connector->funcs->dpms)
3177                         (*connector->funcs->dpms)(connector, (int)value);
3178                 ret = 0;
3179         } else if (connector->funcs->set_property)
3180                 ret = connector->funcs->set_property(connector, property, value);
3181
3182         /* store the property value if successful */
3183         if (!ret)
3184                 drm_connector_property_set_value(connector, property, value);
3185         return ret;
3186 }
3187
3188 static int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj,
3189                                       struct drm_property *property,
3190                                       uint64_t value)
3191 {
3192         int ret = -EINVAL;
3193         struct drm_crtc *crtc = obj_to_crtc(obj);
3194
3195         if (crtc->funcs->set_property)
3196                 ret = crtc->funcs->set_property(crtc, property, value);
3197         if (!ret)
3198                 drm_object_property_set_value(obj, property, value);
3199
3200         return ret;
3201 }
3202
3203 static int drm_mode_plane_set_obj_prop(struct drm_mode_object *obj,
3204                                       struct drm_property *property,
3205                                       uint64_t value)
3206 {
3207         int ret = -EINVAL;
3208         struct drm_plane *plane = obj_to_plane(obj);
3209
3210         if (plane->funcs->set_property)
3211                 ret = plane->funcs->set_property(plane, property, value);
3212         if (!ret)
3213                 drm_object_property_set_value(obj, property, value);
3214
3215         return ret;
3216 }
3217
3218 int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
3219                                       struct drm_file *file_priv)
3220 {
3221         struct drm_mode_obj_get_properties *arg = data;
3222         struct drm_mode_object *obj;
3223         int ret = 0;
3224         int i;
3225         int copied = 0;
3226         int props_count = 0;
3227         uint32_t __user *props_ptr;
3228         uint64_t __user *prop_values_ptr;
3229
3230         if (!drm_core_check_feature(dev, DRIVER_MODESET))
3231                 return -EINVAL;
3232
3233         mutex_lock(&dev->mode_config.mutex);
3234
3235         obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
3236         if (!obj) {
3237                 ret = -EINVAL;
3238                 goto out;
3239         }
3240         if (!obj->properties) {
3241                 ret = -EINVAL;
3242                 goto out;
3243         }
3244
3245         props_count = obj->properties->count;
3246
3247         /* This ioctl is called twice, once to determine how much space is
3248          * needed, and the 2nd time to fill it. */
3249         if ((arg->count_props >= props_count) && props_count) {
3250                 copied = 0;
3251                 props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
3252                 prop_values_ptr = (uint64_t __user *)(unsigned long)
3253                                   (arg->prop_values_ptr);
3254                 for (i = 0; i < props_count; i++) {
3255                         if (put_user(obj->properties->ids[i],
3256                                      props_ptr + copied)) {
3257                                 ret = -EFAULT;
3258                                 goto out;
3259                         }
3260                         if (put_user(obj->properties->values[i],
3261                                      prop_values_ptr + copied)) {
3262                                 ret = -EFAULT;
3263                                 goto out;
3264                         }
3265                         copied++;
3266                 }
3267         }
3268         arg->count_props = props_count;
3269 out:
3270         mutex_unlock(&dev->mode_config.mutex);
3271         return ret;
3272 }
3273
3274 int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
3275                                     struct drm_file *file_priv)
3276 {
3277         struct drm_mode_obj_set_property *arg = data;
3278         struct drm_mode_object *arg_obj;
3279         struct drm_mode_object *prop_obj;
3280         struct drm_property *property;
3281         int ret = -EINVAL;
3282         int i;
3283
3284         if (!drm_core_check_feature(dev, DRIVER_MODESET))
3285                 return -EINVAL;
3286
3287         mutex_lock(&dev->mode_config.mutex);
3288
3289         arg_obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
3290         if (!arg_obj)
3291                 goto out;
3292         if (!arg_obj->properties)
3293                 goto out;
3294
3295         for (i = 0; i < arg_obj->properties->count; i++)
3296                 if (arg_obj->properties->ids[i] == arg->prop_id)
3297                         break;
3298
3299         if (i == arg_obj->properties->count)
3300                 goto out;
3301
3302         prop_obj = drm_mode_object_find(dev, arg->prop_id,
3303                                         DRM_MODE_OBJECT_PROPERTY);
3304         if (!prop_obj)
3305                 goto out;
3306         property = obj_to_property(prop_obj);
3307
3308         if (!drm_property_change_is_valid(property, arg->value))
3309                 goto out;
3310
3311         switch (arg_obj->type) {
3312         case DRM_MODE_OBJECT_CONNECTOR:
3313                 ret = drm_mode_connector_set_obj_prop(arg_obj, property,
3314                                                       arg->value);
3315                 break;
3316         case DRM_MODE_OBJECT_CRTC:
3317                 ret = drm_mode_crtc_set_obj_prop(arg_obj, property, arg->value);
3318                 break;
3319         case DRM_MODE_OBJECT_PLANE:
3320                 ret = drm_mode_plane_set_obj_prop(arg_obj, property, arg->value);
3321                 break;
3322         }
3323
3324 out:
3325         mutex_unlock(&dev->mode_config.mutex);
3326         return ret;
3327 }
3328
3329 int drm_mode_connector_attach_encoder(struct drm_connector *connector,
3330                                       struct drm_encoder *encoder)
3331 {
3332         int i;
3333
3334         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
3335                 if (connector->encoder_ids[i] == 0) {
3336                         connector->encoder_ids[i] = encoder->base.id;
3337                         return 0;
3338                 }
3339         }
3340         return -ENOMEM;
3341 }
3342 EXPORT_SYMBOL(drm_mode_connector_attach_encoder);
3343
3344 void drm_mode_connector_detach_encoder(struct drm_connector *connector,
3345                                     struct drm_encoder *encoder)
3346 {
3347         int i;
3348         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
3349                 if (connector->encoder_ids[i] == encoder->base.id) {
3350                         connector->encoder_ids[i] = 0;
3351                         if (connector->encoder == encoder)
3352                                 connector->encoder = NULL;
3353                         break;
3354                 }
3355         }
3356 }
3357 EXPORT_SYMBOL(drm_mode_connector_detach_encoder);
3358
3359 int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
3360                                   int gamma_size)
3361 {
3362         crtc->gamma_size = gamma_size;
3363
3364         crtc->gamma_store = kzalloc(gamma_size * sizeof(uint16_t) * 3, GFP_KERNEL);
3365         if (!crtc->gamma_store) {
3366                 crtc->gamma_size = 0;
3367                 return -ENOMEM;
3368         }
3369
3370         return 0;
3371 }
3372 EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);
3373
3374 int drm_mode_gamma_set_ioctl(struct drm_device *dev,
3375                              void *data, struct drm_file *file_priv)
3376 {
3377         struct drm_mode_crtc_lut *crtc_lut = data;
3378         struct drm_mode_object *obj;
3379         struct drm_crtc *crtc;
3380         void *r_base, *g_base, *b_base;
3381         int size;
3382         int ret = 0;
3383
3384         if (!drm_core_check_feature(dev, DRIVER_MODESET))
3385                 return -EINVAL;
3386
3387         mutex_lock(&dev->mode_config.mutex);
3388         obj = drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC);
3389         if (!obj) {
3390                 ret = -EINVAL;
3391                 goto out;
3392         }
3393         crtc = obj_to_crtc(obj);
3394
3395         if (crtc->funcs->gamma_set == NULL) {
3396                 ret = -ENOSYS;
3397                 goto out;
3398         }
3399
3400         /* memcpy into gamma store */
3401         if (crtc_lut->gamma_size != crtc->gamma_size) {
3402                 ret = -EINVAL;
3403                 goto out;
3404         }
3405
3406         size = crtc_lut->gamma_size * (sizeof(uint16_t));
3407         r_base = crtc->gamma_store;
3408         if (copy_from_user(r_base, (void __user *)(unsigned long)crtc_lut->red, size)) {
3409                 ret = -EFAULT;
3410                 goto out;
3411         }
3412
3413         g_base = r_base + size;
3414         if (copy_from_user(g_base, (void __user *)(unsigned long)crtc_lut->green, size)) {
3415                 ret = -EFAULT;
3416                 goto out;
3417         }
3418
3419         b_base = g_base + size;
3420         if (copy_from_user(b_base, (void __user *)(unsigned long)crtc_lut->blue, size)) {
3421                 ret = -EFAULT;
3422                 goto out;
3423         }
3424
3425         crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
3426
3427 out:
3428         mutex_unlock(&dev->mode_config.mutex);
3429         return ret;
3430
3431 }
3432
3433 int drm_mode_gamma_get_ioctl(struct drm_device *dev,
3434                              void *data, struct drm_file *file_priv)
3435 {
3436         struct drm_mode_crtc_lut *crtc_lut = data;
3437         struct drm_mode_object *obj;
3438         struct drm_crtc *crtc;
3439         void *r_base, *g_base, *b_base;
3440         int size;
3441         int ret = 0;
3442
3443         if (!drm_core_check_feature(dev, DRIVER_MODESET))
3444                 return -EINVAL;
3445
3446         mutex_lock(&dev->mode_config.mutex);
3447         obj = drm_mode_object_find(dev, crtc_lut->crtc_id, DRM_MODE_OBJECT_CRTC);
3448         if (!obj) {
3449                 ret = -EINVAL;
3450                 goto out;
3451         }
3452         crtc = obj_to_crtc(obj);
3453
3454         /* memcpy into gamma store */
3455         if (crtc_lut->gamma_size != crtc->gamma_size) {
3456                 ret = -EINVAL;
3457                 goto out;
3458         }
3459
3460         size = crtc_lut->gamma_size * (sizeof(uint16_t));
3461         r_base = crtc->gamma_store;
3462         if (copy_to_user((void __user *)(unsigned long)crtc_lut->red, r_base, size)) {
3463                 ret = -EFAULT;
3464                 goto out;
3465         }
3466
3467         g_base = r_base + size;
3468         if (copy_to_user((void __user *)(unsigned long)crtc_lut->green, g_base, size)) {
3469                 ret = -EFAULT;
3470                 goto out;
3471         }
3472
3473         b_base = g_base + size;
3474         if (copy_to_user((void __user *)(unsigned long)crtc_lut->blue, b_base, size)) {
3475                 ret = -EFAULT;
3476                 goto out;
3477         }
3478 out:
3479         mutex_unlock(&dev->mode_config.mutex);
3480         return ret;
3481 }
3482
3483 int drm_mode_page_flip_ioctl(struct drm_device *dev,
3484                              void *data, struct drm_file *file_priv)
3485 {
3486         struct drm_mode_crtc_page_flip *page_flip = data;
3487         struct drm_mode_object *obj;
3488         struct drm_crtc *crtc;
3489         struct drm_framebuffer *fb;
3490         struct drm_pending_vblank_event *e = NULL;
3491         unsigned long flags;
3492         int ret = -EINVAL;
3493
3494         if (page_flip->flags & ~DRM_MODE_PAGE_FLIP_FLAGS ||
3495             page_flip->reserved != 0)
3496                 return -EINVAL;
3497
3498         mutex_lock(&dev->mode_config.mutex);
3499         obj = drm_mode_object_find(dev, page_flip->crtc_id, DRM_MODE_OBJECT_CRTC);
3500         if (!obj)
3501                 goto out;
3502         crtc = obj_to_crtc(obj);
3503
3504         if (crtc->fb == NULL) {
3505                 /* The framebuffer is currently unbound, presumably
3506                  * due to a hotplug event, that userspace has not
3507                  * yet discovered.
3508                  */
3509                 ret = -EBUSY;
3510                 goto out;
3511         }
3512
3513         if (crtc->funcs->page_flip == NULL)
3514                 goto out;
3515
3516         obj = drm_mode_object_find(dev, page_flip->fb_id, DRM_MODE_OBJECT_FB);
3517         if (!obj)
3518                 goto out;
3519         fb = obj_to_fb(obj);
3520
3521         if (crtc->mode.hdisplay > fb->width ||
3522             crtc->mode.vdisplay > fb->height ||
3523             crtc->x > fb->width - crtc->mode.hdisplay ||
3524             crtc->y > fb->height - crtc->mode.vdisplay) {
3525                 DRM_DEBUG_KMS("Invalid fb size %ux%u for CRTC viewport %ux%u+%d+%d.\n",
3526                               fb->width, fb->height,
3527                               crtc->mode.hdisplay, crtc->mode.vdisplay,
3528                               crtc->x, crtc->y);
3529                 ret = -ENOSPC;
3530                 goto out;
3531         }
3532
3533         if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) {
3534                 ret = -ENOMEM;
3535                 spin_lock_irqsave(&dev->event_lock, flags);
3536                 if (file_priv->event_space < sizeof e->event) {
3537                         spin_unlock_irqrestore(&dev->event_lock, flags);
3538                         goto out;
3539                 }
3540                 file_priv->event_space -= sizeof e->event;
3541                 spin_unlock_irqrestore(&dev->event_lock, flags);
3542
3543                 e = kzalloc(sizeof *e, GFP_KERNEL);
3544                 if (e == NULL) {
3545                         spin_lock_irqsave(&dev->event_lock, flags);
3546                         file_priv->event_space += sizeof e->event;
3547                         spin_unlock_irqrestore(&dev->event_lock, flags);
3548                         goto out;
3549                 }
3550
3551                 e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
3552                 e->event.base.length = sizeof e->event;
3553                 e->event.user_data = page_flip->user_data;
3554                 e->base.event = &e->event.base;
3555                 e->base.file_priv = file_priv;
3556                 e->base.destroy =
3557                         (void (*) (struct drm_pending_event *)) kfree;
3558         }
3559
3560         ret = crtc->funcs->page_flip(crtc, fb, e);
3561         if (ret) {
3562                 if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) {
3563                         spin_lock_irqsave(&dev->event_lock, flags);
3564                         file_priv->event_space += sizeof e->event;
3565                         spin_unlock_irqrestore(&dev->event_lock, flags);
3566                         kfree(e);
3567                 }
3568         }
3569
3570 out:
3571         mutex_unlock(&dev->mode_config.mutex);
3572         return ret;
3573 }
3574
3575 void drm_mode_config_reset(struct drm_device *dev)
3576 {
3577         struct drm_crtc *crtc;
3578         struct drm_encoder *encoder;
3579         struct drm_connector *connector;
3580
3581         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
3582                 if (crtc->funcs->reset)
3583                         crtc->funcs->reset(crtc);
3584
3585         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
3586                 if (encoder->funcs->reset)
3587                         encoder->funcs->reset(encoder);
3588
3589         list_for_each_entry(connector, &dev->mode_config.connector_list, head)
3590                 if (connector->funcs->reset)
3591                         connector->funcs->reset(connector);
3592 }
3593 EXPORT_SYMBOL(drm_mode_config_reset);
3594
3595 int drm_mode_create_dumb_ioctl(struct drm_device *dev,
3596                                void *data, struct drm_file *file_priv)
3597 {
3598         struct drm_mode_create_dumb *args = data;
3599
3600         if (!dev->driver->dumb_create)
3601                 return -ENOSYS;
3602         return dev->driver->dumb_create(file_priv, dev, args);
3603 }
3604
3605 int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
3606                              void *data, struct drm_file *file_priv)
3607 {
3608         struct drm_mode_map_dumb *args = data;
3609
3610         /* call driver ioctl to get mmap offset */
3611         if (!dev->driver->dumb_map_offset)
3612                 return -ENOSYS;
3613
3614         return dev->driver->dumb_map_offset(file_priv, dev, args->handle, &args->offset);
3615 }
3616
3617 int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
3618                                 void *data, struct drm_file *file_priv)
3619 {
3620         struct drm_mode_destroy_dumb *args = data;
3621
3622         if (!dev->driver->dumb_destroy)
3623                 return -ENOSYS;
3624
3625         return dev->driver->dumb_destroy(file_priv, dev, args->handle);
3626 }
3627
3628 /*
3629  * Just need to support RGB formats here for compat with code that doesn't
3630  * use pixel formats directly yet.
3631  */
3632 void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
3633                           int *bpp)
3634 {
3635         switch (format) {
3636         case DRM_FORMAT_RGB332:
3637         case DRM_FORMAT_BGR233:
3638                 *depth = 8;
3639                 *bpp = 8;
3640                 break;
3641         case DRM_FORMAT_XRGB1555:
3642         case DRM_FORMAT_XBGR1555:
3643         case DRM_FORMAT_RGBX5551:
3644         case DRM_FORMAT_BGRX5551:
3645         case DRM_FORMAT_ARGB1555:
3646         case DRM_FORMAT_ABGR1555:
3647         case DRM_FORMAT_RGBA5551:
3648         case DRM_FORMAT_BGRA5551:
3649                 *depth = 15;
3650                 *bpp = 16;
3651                 break;
3652         case DRM_FORMAT_RGB565:
3653         case DRM_FORMAT_BGR565:
3654                 *depth = 16;
3655                 *bpp = 16;
3656                 break;
3657         case DRM_FORMAT_RGB888:
3658         case DRM_FORMAT_BGR888:
3659                 *depth = 24;
3660                 *bpp = 24;
3661                 break;
3662         case DRM_FORMAT_XRGB8888:
3663         case DRM_FORMAT_XBGR8888:
3664         case DRM_FORMAT_RGBX8888:
3665         case DRM_FORMAT_BGRX8888:
3666                 *depth = 24;
3667                 *bpp = 32;
3668                 break;
3669         case DRM_FORMAT_XRGB2101010:
3670         case DRM_FORMAT_XBGR2101010:
3671         case DRM_FORMAT_RGBX1010102:
3672         case DRM_FORMAT_BGRX1010102:
3673         case DRM_FORMAT_ARGB2101010:
3674         case DRM_FORMAT_ABGR2101010:
3675         case DRM_FORMAT_RGBA1010102:
3676         case DRM_FORMAT_BGRA1010102:
3677                 *depth = 30;
3678                 *bpp = 32;
3679                 break;
3680         case DRM_FORMAT_ARGB8888:
3681         case DRM_FORMAT_ABGR8888:
3682         case DRM_FORMAT_RGBA8888:
3683         case DRM_FORMAT_BGRA8888:
3684                 *depth = 32;
3685                 *bpp = 32;
3686                 break;
3687         default:
3688                 DRM_DEBUG_KMS("unsupported pixel format\n");
3689                 *depth = 0;
3690                 *bpp = 0;
3691                 break;
3692         }
3693 }
3694 EXPORT_SYMBOL(drm_fb_get_bpp_depth);
3695
3696 /**
3697  * drm_format_num_planes - get the number of planes for format
3698  * @format: pixel format (DRM_FORMAT_*)
3699  *
3700  * RETURNS:
3701  * The number of planes used by the specified pixel format.
3702  */
3703 int drm_format_num_planes(uint32_t format)
3704 {
3705         switch (format) {
3706         case DRM_FORMAT_YUV410:
3707         case DRM_FORMAT_YVU410:
3708         case DRM_FORMAT_YUV411:
3709         case DRM_FORMAT_YVU411:
3710         case DRM_FORMAT_YUV420:
3711         case DRM_FORMAT_YVU420:
3712         case DRM_FORMAT_YUV422:
3713         case DRM_FORMAT_YVU422:
3714         case DRM_FORMAT_YUV444:
3715         case DRM_FORMAT_YVU444:
3716                 return 3;
3717         case DRM_FORMAT_NV12:
3718         case DRM_FORMAT_NV21:
3719         case DRM_FORMAT_NV16:
3720         case DRM_FORMAT_NV61:
3721                 return 2;
3722         default:
3723                 return 1;
3724         }
3725 }
3726 EXPORT_SYMBOL(drm_format_num_planes);
3727
3728 /**
3729  * drm_format_plane_cpp - determine the bytes per pixel value
3730  * @format: pixel format (DRM_FORMAT_*)
3731  * @plane: plane index
3732  *
3733  * RETURNS:
3734  * The bytes per pixel value for the specified plane.
3735  */
3736 int drm_format_plane_cpp(uint32_t format, int plane)
3737 {
3738         unsigned int depth;
3739         int bpp;
3740
3741         if (plane >= drm_format_num_planes(format))
3742                 return 0;
3743
3744         switch (format) {
3745         case DRM_FORMAT_YUYV:
3746         case DRM_FORMAT_YVYU:
3747         case DRM_FORMAT_UYVY:
3748         case DRM_FORMAT_VYUY:
3749                 return 2;
3750         case DRM_FORMAT_NV12:
3751         case DRM_FORMAT_NV21:
3752         case DRM_FORMAT_NV16:
3753         case DRM_FORMAT_NV61:
3754                 return plane ? 2 : 1;
3755         case DRM_FORMAT_YUV410:
3756         case DRM_FORMAT_YVU410:
3757         case DRM_FORMAT_YUV411:
3758         case DRM_FORMAT_YVU411:
3759         case DRM_FORMAT_YUV420:
3760         case DRM_FORMAT_YVU420:
3761         case DRM_FORMAT_YUV422:
3762         case DRM_FORMAT_YVU422:
3763         case DRM_FORMAT_YUV444:
3764         case DRM_FORMAT_YVU444:
3765                 return 1;
3766         default:
3767                 drm_fb_get_bpp_depth(format, &depth, &bpp);
3768                 return bpp >> 3;
3769         }
3770 }
3771 EXPORT_SYMBOL(drm_format_plane_cpp);
3772
3773 /**
3774  * drm_format_horz_chroma_subsampling - get the horizontal chroma subsampling factor
3775  * @format: pixel format (DRM_FORMAT_*)
3776  *
3777  * RETURNS:
3778  * The horizontal chroma subsampling factor for the
3779  * specified pixel format.
3780  */
3781 int drm_format_horz_chroma_subsampling(uint32_t format)
3782 {
3783         switch (format) {
3784         case DRM_FORMAT_YUV411:
3785         case DRM_FORMAT_YVU411:
3786         case DRM_FORMAT_YUV410:
3787         case DRM_FORMAT_YVU410:
3788                 return 4;
3789         case DRM_FORMAT_YUYV:
3790         case DRM_FORMAT_YVYU:
3791         case DRM_FORMAT_UYVY:
3792         case DRM_FORMAT_VYUY:
3793         case DRM_FORMAT_NV12:
3794         case DRM_FORMAT_NV21:
3795         case DRM_FORMAT_NV16:
3796         case DRM_FORMAT_NV61:
3797         case DRM_FORMAT_YUV422:
3798         case DRM_FORMAT_YVU422:
3799         case DRM_FORMAT_YUV420:
3800         case DRM_FORMAT_YVU420:
3801                 return 2;
3802         default:
3803                 return 1;
3804         }
3805 }
3806 EXPORT_SYMBOL(drm_format_horz_chroma_subsampling);
3807
3808 /**
3809  * drm_format_vert_chroma_subsampling - get the vertical chroma subsampling factor
3810  * @format: pixel format (DRM_FORMAT_*)
3811  *
3812  * RETURNS:
3813  * The vertical chroma subsampling factor for the
3814  * specified pixel format.
3815  */
3816 int drm_format_vert_chroma_subsampling(uint32_t format)
3817 {
3818         switch (format) {
3819         case DRM_FORMAT_YUV410:
3820         case DRM_FORMAT_YVU410:
3821                 return 4;
3822         case DRM_FORMAT_YUV420:
3823         case DRM_FORMAT_YVU420:
3824         case DRM_FORMAT_NV12:
3825         case DRM_FORMAT_NV21:
3826                 return 2;
3827         default:
3828                 return 1;
3829         }
3830 }
3831 EXPORT_SYMBOL(drm_format_vert_chroma_subsampling);