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