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