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/ctype.h>
  33 #include <linux/list.h>
  34 #include <linux/slab.h>
  35 #include <linux/export.h>
  36 #include <drm/drmP.h>
  37 #include <drm/drm_crtc.h>
  38 #include <drm/drm_edid.h>
  39 #include <drm/drm_fourcc.h>
  40 #include <drm/drm_modeset_lock.h>
  41 #include <drm/drm_atomic.h>
  42
  43 #include "drm_crtc_internal.h"
  44 #include "drm_internal.h"
  45
  46 static struct drm_framebuffer *
  47 internal_framebuffer_create(struct drm_device *dev,
  48                             const struct drm_mode_fb_cmd2 *r,
  49                             struct drm_file *file_priv);
  50
  51 /* Avoid boilerplate.  I'm tired of typing. */
  52 #define DRM_ENUM_NAME_FN(fnname, list)                          \
  53         const char *fnname(int val)                             \
  54         {                                                       \
  55                 int i;                                          \
  56                 for (i = 0; i < ARRAY_SIZE(list); i++) {        \
  57                         if (list[i].type == val)                \
  58                                 return list[i].name;            \
  59                 }                                               \
  60                 return "(unknown)";                             \
  61         }
  62
  63 /*
  64  * Global properties
  65  */
  66 static const struct drm_prop_enum_list drm_dpms_enum_list[] = {
  67         { DRM_MODE_DPMS_ON, "On" },
  68         { DRM_MODE_DPMS_STANDBY, "Standby" },
  69         { DRM_MODE_DPMS_SUSPEND, "Suspend" },
  70         { DRM_MODE_DPMS_OFF, "Off" }
  71 };
  72
  73 DRM_ENUM_NAME_FN(drm_get_dpms_name, drm_dpms_enum_list)
  74
  75 static const struct drm_prop_enum_list drm_plane_type_enum_list[] = {
  76         { DRM_PLANE_TYPE_OVERLAY, "Overlay" },
  77         { DRM_PLANE_TYPE_PRIMARY, "Primary" },
  78         { DRM_PLANE_TYPE_CURSOR, "Cursor" },
  79 };
  80
  81 /*
  82  * Optional properties
  83  */
  84 static const struct drm_prop_enum_list drm_scaling_mode_enum_list[] = {
  85         { DRM_MODE_SCALE_NONE, "None" },
  86         { DRM_MODE_SCALE_FULLSCREEN, "Full" },
  87         { DRM_MODE_SCALE_CENTER, "Center" },
  88         { DRM_MODE_SCALE_ASPECT, "Full aspect" },
  89 };
  90
  91 static const struct drm_prop_enum_list drm_aspect_ratio_enum_list[] = {
  92         { DRM_MODE_PICTURE_ASPECT_NONE, "Automatic" },
  93         { DRM_MODE_PICTURE_ASPECT_4_3, "4:3" },
  94         { DRM_MODE_PICTURE_ASPECT_16_9, "16:9" },
  95 };
  96
  97 /*
  98  * Non-global properties, but "required" for certain connectors.
  99  */
 100 static const struct drm_prop_enum_list drm_dvi_i_select_enum_list[] = {
 101         { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */
 102         { DRM_MODE_SUBCONNECTOR_DVID,      "DVI-D"     }, /* DVI-I  */
 103         { DRM_MODE_SUBCONNECTOR_DVIA,      "DVI-A"     }, /* DVI-I  */
 104 };
 105
 106 DRM_ENUM_NAME_FN(drm_get_dvi_i_select_name, drm_dvi_i_select_enum_list)
 107
 108 static const struct drm_prop_enum_list drm_dvi_i_subconnector_enum_list[] = {
 109         { DRM_MODE_SUBCONNECTOR_Unknown,   "Unknown"   }, /* DVI-I and TV-out */
 110         { DRM_MODE_SUBCONNECTOR_DVID,      "DVI-D"     }, /* DVI-I  */
 111         { DRM_MODE_SUBCONNECTOR_DVIA,      "DVI-A"     }, /* DVI-I  */
 112 };
 113
 114 DRM_ENUM_NAME_FN(drm_get_dvi_i_subconnector_name,
 115                  drm_dvi_i_subconnector_enum_list)
 116
 117 static const struct drm_prop_enum_list drm_tv_select_enum_list[] = {
 118         { DRM_MODE_SUBCONNECTOR_Automatic, "Automatic" }, /* DVI-I and TV-out */
 119         { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */
 120         { DRM_MODE_SUBCONNECTOR_SVIDEO,    "SVIDEO"    }, /* TV-out */
 121         { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
 122         { DRM_MODE_SUBCONNECTOR_SCART,     "SCART"     }, /* TV-out */
 123 };
 124
 125 DRM_ENUM_NAME_FN(drm_get_tv_select_name, drm_tv_select_enum_list)
 126
 127 static const struct drm_prop_enum_list drm_tv_subconnector_enum_list[] = {
 128         { DRM_MODE_SUBCONNECTOR_Unknown,   "Unknown"   }, /* DVI-I and TV-out */
 129         { DRM_MODE_SUBCONNECTOR_Composite, "Composite" }, /* TV-out */
 130         { DRM_MODE_SUBCONNECTOR_SVIDEO,    "SVIDEO"    }, /* TV-out */
 131         { DRM_MODE_SUBCONNECTOR_Component, "Component" }, /* TV-out */
 132         { DRM_MODE_SUBCONNECTOR_SCART,     "SCART"     }, /* TV-out */
 133 };
 134
 135 DRM_ENUM_NAME_FN(drm_get_tv_subconnector_name,
 136                  drm_tv_subconnector_enum_list)
 137
 138 static const struct drm_prop_enum_list drm_dirty_info_enum_list[] = {
 139         { DRM_MODE_DIRTY_OFF,      "Off"      },
 140         { DRM_MODE_DIRTY_ON,       "On"       },
 141         { DRM_MODE_DIRTY_ANNOTATE, "Annotate" },
 142 };
 143
 144 struct drm_conn_prop_enum_list {
 145         int type;
 146         const char *name;
 147         struct ida ida;
 148 };
 149
 150 /*
 151  * Connector and encoder types.
 152  */
 153 static struct drm_conn_prop_enum_list drm_connector_enum_list[] = {
 154         { DRM_MODE_CONNECTOR_Unknown, "Unknown" },
 155         { DRM_MODE_CONNECTOR_VGA, "VGA" },
 156         { DRM_MODE_CONNECTOR_DVII, "DVI-I" },
 157         { DRM_MODE_CONNECTOR_DVID, "DVI-D" },
 158         { DRM_MODE_CONNECTOR_DVIA, "DVI-A" },
 159         { DRM_MODE_CONNECTOR_Composite, "Composite" },
 160         { DRM_MODE_CONNECTOR_SVIDEO, "SVIDEO" },
 161         { DRM_MODE_CONNECTOR_LVDS, "LVDS" },
 162         { DRM_MODE_CONNECTOR_Component, "Component" },
 163         { DRM_MODE_CONNECTOR_9PinDIN, "DIN" },
 164         { DRM_MODE_CONNECTOR_DisplayPort, "DP" },
 165         { DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" },
 166         { DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" },
 167         { DRM_MODE_CONNECTOR_TV, "TV" },
 168         { DRM_MODE_CONNECTOR_eDP, "eDP" },
 169         { DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" },
 170         { DRM_MODE_CONNECTOR_DSI, "DSI" },
 171 };
 172
 173 static const struct drm_prop_enum_list drm_encoder_enum_list[] = {
 174         { DRM_MODE_ENCODER_NONE, "None" },
 175         { DRM_MODE_ENCODER_DAC, "DAC" },
 176         { DRM_MODE_ENCODER_TMDS, "TMDS" },
 177         { DRM_MODE_ENCODER_LVDS, "LVDS" },
 178         { DRM_MODE_ENCODER_TVDAC, "TV" },
 179         { DRM_MODE_ENCODER_VIRTUAL, "Virtual" },
 180         { DRM_MODE_ENCODER_DSI, "DSI" },
 181         { DRM_MODE_ENCODER_DPMST, "DP MST" },
 182 };
 183
 184 static const struct drm_prop_enum_list drm_subpixel_enum_list[] = {
 185         { SubPixelUnknown, "Unknown" },
 186         { SubPixelHorizontalRGB, "Horizontal RGB" },
 187         { SubPixelHorizontalBGR, "Horizontal BGR" },
 188         { SubPixelVerticalRGB, "Vertical RGB" },
 189         { SubPixelVerticalBGR, "Vertical BGR" },
 190         { SubPixelNone, "None" },
 191 };
 192
 193 void drm_connector_ida_init(void)
 194 {
 195         int i;
 196
 197         for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
 198                 ida_init(&drm_connector_enum_list[i].ida);
 199 }
 200
 201 void drm_connector_ida_destroy(void)
 202 {
 203         int i;
 204
 205         for (i = 0; i < ARRAY_SIZE(drm_connector_enum_list); i++)
 206                 ida_destroy(&drm_connector_enum_list[i].ida);
 207 }
 208
 209 /**
 210  * drm_get_connector_status_name - return a string for connector status
 211  * @status: connector status to compute name of
 212  *
 213  * In contrast to the other drm_get_*_name functions this one here returns a
 214  * const pointer and hence is threadsafe.
 215  */
 216 const char *drm_get_connector_status_name(enum drm_connector_status status)
 217 {
 218         if (status == connector_status_connected)
 219                 return "connected";
 220         else if (status == connector_status_disconnected)
 221                 return "disconnected";
 222         else
 223                 return "unknown";
 224 }
 225 EXPORT_SYMBOL(drm_get_connector_status_name);
 226
 227 /**
 228  * drm_get_subpixel_order_name - return a string for a given subpixel enum
 229  * @order: enum of subpixel_order
 230  *
 231  * Note you could abuse this and return something out of bounds, but that
 232  * would be a caller error.  No unscrubbed user data should make it here.
 233  */
 234 const char *drm_get_subpixel_order_name(enum subpixel_order order)
 235 {
 236         return drm_subpixel_enum_list[order].name;
 237 }
 238 EXPORT_SYMBOL(drm_get_subpixel_order_name);
 239
 240 static char printable_char(int c)
 241 {
 242         return isascii(c) && isprint(c) ? c : '?';
 243 }
 244
 245 /**
 246  * drm_get_format_name - return a string for drm fourcc format
 247  * @format: format to compute name of
 248  *
 249  * Note that the buffer used by this function is globally shared and owned by
 250  * the function itself.
 251  *
 252  * FIXME: This isn't really multithreading safe.
 253  */
 254 const char *drm_get_format_name(uint32_t format)
 255 {
 256         static char buf[32];
 257
 258         snprintf(buf, sizeof(buf),
 259                  "%c%c%c%c %s-endian (0x%08x)",
 260                  printable_char(format & 0xff),
 261                  printable_char((format >> 8) & 0xff),
 262                  printable_char((format >> 16) & 0xff),
 263                  printable_char((format >> 24) & 0x7f),
 264                  format & DRM_FORMAT_BIG_ENDIAN ? "big" : "little",
 265                  format);
 266
 267         return buf;
 268 }
 269 EXPORT_SYMBOL(drm_get_format_name);
 270
 271 /*
 272  * Internal function to assign a slot in the object idr and optionally
 273  * register the object into the idr.
 274  */
 275 static int drm_mode_object_get_reg(struct drm_device *dev,
 276                                    struct drm_mode_object *obj,
 277                                    uint32_t obj_type,
 278                                    bool register_obj)
 279 {
 280         int ret;
 281
 282         mutex_lock(&dev->mode_config.idr_mutex);
 283         ret = idr_alloc(&dev->mode_config.crtc_idr, register_obj ? obj : NULL, 1, 0, GFP_KERNEL);
 284         if (ret >= 0) {
 285                 /*
 286                  * Set up the object linking under the protection of the idr
 287                  * lock so that other users can't see inconsistent state.
 288                  */
 289                 obj->id = ret;
 290                 obj->type = obj_type;
 291         }
 292         mutex_unlock(&dev->mode_config.idr_mutex);
 293
 294         return ret < 0 ? ret : 0;
 295 }
 296
 297 /**
 298  * drm_mode_object_get - allocate a new modeset identifier
 299  * @dev: DRM device
 300  * @obj: object pointer, used to generate unique ID
 301  * @obj_type: object type
 302  *
 303  * Create a unique identifier based on @ptr in @dev's identifier space.  Used
 304  * for tracking modes, CRTCs and connectors. Note that despite the _get postfix
 305  * modeset identifiers are _not_ reference counted. Hence don't use this for
 306  * reference counted modeset objects like framebuffers.
 307  *
 308  * Returns:
 309  * Zero on success, error code on failure.
 310  */
 311 int drm_mode_object_get(struct drm_device *dev,
 312                         struct drm_mode_object *obj, uint32_t obj_type)
 313 {
 314         return drm_mode_object_get_reg(dev, obj, obj_type, true);
 315 }
 316
 317 static void drm_mode_object_register(struct drm_device *dev,
 318                                      struct drm_mode_object *obj)
 319 {
 320         mutex_lock(&dev->mode_config.idr_mutex);
 321         idr_replace(&dev->mode_config.crtc_idr, obj, obj->id);
 322         mutex_unlock(&dev->mode_config.idr_mutex);
 323 }
 324
 325 /**
 326  * drm_mode_object_put - free a modeset identifer
 327  * @dev: DRM device
 328  * @object: object to free
 329  *
 330  * Free @id from @dev's unique identifier pool. Note that despite the _get
 331  * postfix modeset identifiers are _not_ reference counted. Hence don't use this
 332  * for reference counted modeset objects like framebuffers.
 333  */
 334 void drm_mode_object_put(struct drm_device *dev,
 335                          struct drm_mode_object *object)
 336 {
 337         mutex_lock(&dev->mode_config.idr_mutex);
 338         idr_remove(&dev->mode_config.crtc_idr, object->id);
 339         mutex_unlock(&dev->mode_config.idr_mutex);
 340 }
 341
 342 static struct drm_mode_object *_object_find(struct drm_device *dev,
 343                 uint32_t id, uint32_t type)
 344 {
 345         struct drm_mode_object *obj = NULL;
 346
 347         mutex_lock(&dev->mode_config.idr_mutex);
 348         obj = idr_find(&dev->mode_config.crtc_idr, id);
 349         if (obj && type != DRM_MODE_OBJECT_ANY && obj->type != type)
 350                 obj = NULL;
 351         if (obj && obj->id != id)
 352                 obj = NULL;
 353         /* don't leak out unref'd fb's */
 354         if (obj &&
 355             (obj->type == DRM_MODE_OBJECT_FB ||
 356              obj->type == DRM_MODE_OBJECT_BLOB))
 357                 obj = NULL;
 358         mutex_unlock(&dev->mode_config.idr_mutex);
 359
 360         return obj;
 361 }
 362
 363 /**
 364  * drm_mode_object_find - look up a drm object with static lifetime
 365  * @dev: drm device
 366  * @id: id of the mode object
 367  * @type: type of the mode object
 368  *
 369  * Note that framebuffers cannot be looked up with this functions - since those
 370  * are reference counted, they need special treatment.  Even with
 371  * DRM_MODE_OBJECT_ANY (although that will simply return NULL
 372  * rather than WARN_ON()).
 373  */
 374 struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
 375                 uint32_t id, uint32_t type)
 376 {
 377         struct drm_mode_object *obj = NULL;
 378
 379         /* Framebuffers are reference counted and need their own lookup
 380          * function.*/
 381         WARN_ON(type == DRM_MODE_OBJECT_FB || type == DRM_MODE_OBJECT_BLOB);
 382         obj = _object_find(dev, id, type);
 383         return obj;
 384 }
 385 EXPORT_SYMBOL(drm_mode_object_find);
 386
 387 /**
 388  * drm_framebuffer_init - initialize a framebuffer
 389  * @dev: DRM device
 390  * @fb: framebuffer to be initialized
 391  * @funcs: ... with these functions
 392  *
 393  * Allocates an ID for the framebuffer's parent mode object, sets its mode
 394  * functions & device file and adds it to the master fd list.
 395  *
 396  * IMPORTANT:
 397  * This functions publishes the fb and makes it available for concurrent access
 398  * by other users. Which means by this point the fb _must_ be fully set up -
 399  * since all the fb attributes are invariant over its lifetime, no further
 400  * locking but only correct reference counting is required.
 401  *
 402  * Returns:
 403  * Zero on success, error code on failure.
 404  */
 405 int drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb,
 406                          const struct drm_framebuffer_funcs *funcs)
 407 {
 408         int ret;
 409
 410         mutex_lock(&dev->mode_config.fb_lock);
 411         kref_init(&fb->refcount);
 412         INIT_LIST_HEAD(&fb->filp_head);
 413         fb->dev = dev;
 414         fb->funcs = funcs;
 415
 416         ret = drm_mode_object_get(dev, &fb->base, DRM_MODE_OBJECT_FB);
 417         if (ret)
 418                 goto out;
 419
 420         dev->mode_config.num_fb++;
 421         list_add(&fb->head, &dev->mode_config.fb_list);
 422 out:
 423         mutex_unlock(&dev->mode_config.fb_lock);
 424
 425         return ret;
 426 }
 427 EXPORT_SYMBOL(drm_framebuffer_init);
 428
 429 /* dev->mode_config.fb_lock must be held! */
 430 static void __drm_framebuffer_unregister(struct drm_device *dev,
 431                                          struct drm_framebuffer *fb)
 432 {
 433         mutex_lock(&dev->mode_config.idr_mutex);
 434         idr_remove(&dev->mode_config.crtc_idr, fb->base.id);
 435         mutex_unlock(&dev->mode_config.idr_mutex);
 436
 437         fb->base.id = 0;
 438 }
 439
 440 static void drm_framebuffer_free(struct kref *kref)
 441 {
 442         struct drm_framebuffer *fb =
 443                         container_of(kref, struct drm_framebuffer, refcount);
 444         struct drm_device *dev = fb->dev;
 445
 446         /*
 447          * The lookup idr holds a weak reference, which has not necessarily been
 448          * removed at this point. Check for that.
 449          */
 450         mutex_lock(&dev->mode_config.fb_lock);
 451         if (fb->base.id) {
 452                 /* Mark fb as reaped and drop idr ref. */
 453                 __drm_framebuffer_unregister(dev, fb);
 454         }
 455         mutex_unlock(&dev->mode_config.fb_lock);
 456
 457         fb->funcs->destroy(fb);
 458 }
 459
 460 static struct drm_framebuffer *__drm_framebuffer_lookup(struct drm_device *dev,
 461                                                         uint32_t id)
 462 {
 463         struct drm_mode_object *obj = NULL;
 464         struct drm_framebuffer *fb;
 465
 466         mutex_lock(&dev->mode_config.idr_mutex);
 467         obj = idr_find(&dev->mode_config.crtc_idr, id);
 468         if (!obj || (obj->type != DRM_MODE_OBJECT_FB) || (obj->id != id))
 469                 fb = NULL;
 470         else
 471                 fb = obj_to_fb(obj);
 472         mutex_unlock(&dev->mode_config.idr_mutex);
 473
 474         return fb;
 475 }
 476
 477 /**
 478  * drm_framebuffer_lookup - look up a drm framebuffer and grab a reference
 479  * @dev: drm device
 480  * @id: id of the fb object
 481  *
 482  * If successful, this grabs an additional reference to the framebuffer -
 483  * callers need to make sure to eventually unreference the returned framebuffer
 484  * again, using @drm_framebuffer_unreference.
 485  */
 486 struct drm_framebuffer *drm_framebuffer_lookup(struct drm_device *dev,
 487                                                uint32_t id)
 488 {
 489         struct drm_framebuffer *fb;
 490
 491         mutex_lock(&dev->mode_config.fb_lock);
 492         fb = __drm_framebuffer_lookup(dev, id);
 493         if (fb) {
 494                 if (!kref_get_unless_zero(&fb->refcount))
 495                         fb = NULL;
 496         }
 497         mutex_unlock(&dev->mode_config.fb_lock);
 498
 499         return fb;
 500 }
 501 EXPORT_SYMBOL(drm_framebuffer_lookup);
 502
 503 /**
 504  * drm_framebuffer_unreference - unref a framebuffer
 505  * @fb: framebuffer to unref
 506  *
 507  * This functions decrements the fb's refcount and frees it if it drops to zero.
 508  */
 509 void drm_framebuffer_unreference(struct drm_framebuffer *fb)
 510 {
 511         DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
 512         kref_put(&fb->refcount, drm_framebuffer_free);
 513 }
 514 EXPORT_SYMBOL(drm_framebuffer_unreference);
 515
 516 /**
 517  * drm_framebuffer_reference - incr the fb refcnt
 518  * @fb: framebuffer
 519  *
 520  * This functions increments the fb's refcount.
 521  */
 522 void drm_framebuffer_reference(struct drm_framebuffer *fb)
 523 {
 524         DRM_DEBUG("%p: FB ID: %d (%d)\n", fb, fb->base.id, atomic_read(&fb->refcount.refcount));
 525         kref_get(&fb->refcount);
 526 }
 527 EXPORT_SYMBOL(drm_framebuffer_reference);
 528
 529 /**
 530  * drm_framebuffer_unregister_private - unregister a private fb from the lookup idr
 531  * @fb: fb to unregister
 532  *
 533  * Drivers need to call this when cleaning up driver-private framebuffers, e.g.
 534  * those used for fbdev. Note that the caller must hold a reference of it's own,
 535  * i.e. the object may not be destroyed through this call (since it'll lead to a
 536  * locking inversion).
 537  */
 538 void drm_framebuffer_unregister_private(struct drm_framebuffer *fb)
 539 {
 540         struct drm_device *dev;
 541
 542         if (!fb)
 543                 return;
 544
 545         dev = fb->dev;
 546
 547         mutex_lock(&dev->mode_config.fb_lock);
 548         /* Mark fb as reaped and drop idr ref. */
 549         __drm_framebuffer_unregister(dev, fb);
 550         mutex_unlock(&dev->mode_config.fb_lock);
 551 }
 552 EXPORT_SYMBOL(drm_framebuffer_unregister_private);
 553
 554 /**
 555  * drm_framebuffer_cleanup - remove a framebuffer object
 556  * @fb: framebuffer to remove
 557  *
 558  * Cleanup framebuffer. This function is intended to be used from the drivers
 559  * ->destroy callback. It can also be used to clean up driver private
 560  *  framebuffers embedded into a larger structure.
 561  *
 562  * Note that this function does not remove the fb from active usuage - if it is
 563  * still used anywhere, hilarity can ensue since userspace could call getfb on
 564  * the id and get back -EINVAL. Obviously no concern at driver unload time.
 565  *
 566  * Also, the framebuffer will not be removed from the lookup idr - for
 567  * user-created framebuffers this will happen in in the rmfb ioctl. For
 568  * driver-private objects (e.g. for fbdev) drivers need to explicitly call
 569  * drm_framebuffer_unregister_private.
 570  */
 571 void drm_framebuffer_cleanup(struct drm_framebuffer *fb)
 572 {
 573         struct drm_device *dev = fb->dev;
 574
 575         mutex_lock(&dev->mode_config.fb_lock);
 576         list_del(&fb->head);
 577         dev->mode_config.num_fb--;
 578         mutex_unlock(&dev->mode_config.fb_lock);
 579 }
 580 EXPORT_SYMBOL(drm_framebuffer_cleanup);
 581
 582 /**
 583  * drm_framebuffer_remove - remove and unreference a framebuffer object
 584  * @fb: framebuffer to remove
 585  *
 586  * Scans all the CRTCs and planes in @dev's mode_config.  If they're
 587  * using @fb, removes it, setting it to NULL. Then drops the reference to the
 588  * passed-in framebuffer. Might take the modeset locks.
 589  *
 590  * Note that this function optimizes the cleanup away if the caller holds the
 591  * last reference to the framebuffer. It is also guaranteed to not take the
 592  * modeset locks in this case.
 593  */
 594 void drm_framebuffer_remove(struct drm_framebuffer *fb)
 595 {
 596         struct drm_device *dev;
 597         struct drm_crtc *crtc;
 598         struct drm_plane *plane;
 599         struct drm_mode_set set;
 600         int ret;
 601
 602         if (!fb)
 603                 return;
 604
 605         dev = fb->dev;
 606
 607         WARN_ON(!list_empty(&fb->filp_head));
 608
 609         /*
 610          * drm ABI mandates that we remove any deleted framebuffers from active
 611          * useage. But since most sane clients only remove framebuffers they no
 612          * longer need, try to optimize this away.
 613          *
 614          * Since we're holding a reference ourselves, observing a refcount of 1
 615          * means that we're the last holder and can skip it. Also, the refcount
 616          * can never increase from 1 again, so we don't need any barriers or
 617          * locks.
 618          *
 619          * Note that userspace could try to race with use and instate a new
 620          * usage _after_ we've cleared all current ones. End result will be an
 621          * in-use fb with fb-id == 0. Userspace is allowed to shoot its own foot
 622          * in this manner.
 623          */
 624         if (atomic_read(&fb->refcount.refcount) > 1) {
 625                 drm_modeset_lock_all(dev);
 626                 /* remove from any CRTC */
 627                 drm_for_each_crtc(crtc, dev) {
 628                         if (crtc->primary->fb == fb) {
 629                                 /* should turn off the crtc */
 630                                 memset(&set, 0, sizeof(struct drm_mode_set));
 631                                 set.crtc = crtc;
 632                                 set.fb = NULL;
 633                                 ret = drm_mode_set_config_internal(&set);
 634                                 if (ret)
 635                                         DRM_ERROR("failed to reset crtc %p when fb was deleted\n", crtc);
 636                         }
 637                 }
 638
 639                 drm_for_each_plane(plane, dev) {
 640                         if (plane->fb == fb)
 641                                 drm_plane_force_disable(plane);
 642                 }
 643                 drm_modeset_unlock_all(dev);
 644         }
 645
 646         drm_framebuffer_unreference(fb);
 647 }
 648 EXPORT_SYMBOL(drm_framebuffer_remove);
 649
 650 DEFINE_WW_CLASS(crtc_ww_class);
 651
 652 static unsigned int drm_num_crtcs(struct drm_device *dev)
 653 {
 654         unsigned int num = 0;
 655         struct drm_crtc *tmp;
 656
 657         drm_for_each_crtc(tmp, dev) {
 658                 num++;
 659         }
 660
 661         return num;
 662 }
 663
 664 /**
 665  * drm_crtc_init_with_planes - Initialise a new CRTC object with
 666  *    specified primary and cursor planes.
 667  * @dev: DRM device
 668  * @crtc: CRTC object to init
 669  * @primary: Primary plane for CRTC
 670  * @cursor: Cursor plane for CRTC
 671  * @funcs: callbacks for the new CRTC
 672  * @name: printf style format string for the CRTC name, or NULL for default name
 673  *
 674  * Inits a new object created as base part of a driver crtc object.
 675  *
 676  * Returns:
 677  * Zero on success, error code on failure.
 678  */
 679 int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc,
 680                               struct drm_plane *primary,
 681                               struct drm_plane *cursor,
 682                               const struct drm_crtc_funcs *funcs,
 683                               const char *name, ...)
 684 {
 685         struct drm_mode_config *config = &dev->mode_config;
 686         int ret;
 687
 688         WARN_ON(primary && primary->type != DRM_PLANE_TYPE_PRIMARY);
 689         WARN_ON(cursor && cursor->type != DRM_PLANE_TYPE_CURSOR);
 690
 691         crtc->dev = dev;
 692         crtc->funcs = funcs;
 693
 694         drm_modeset_lock_init(&crtc->mutex);
 695         ret = drm_mode_object_get(dev, &crtc->base, DRM_MODE_OBJECT_CRTC);
 696         if (ret)
 697                 return ret;
 698
 699         if (name) {
 700                 va_list ap;
 701
 702                 va_start(ap, name);
 703                 crtc->name = kvasprintf(GFP_KERNEL, name, ap);
 704                 va_end(ap);
 705         } else {
 706                 crtc->name = kasprintf(GFP_KERNEL, "crtc-%d",
 707                                        drm_num_crtcs(dev));
 708         }
 709         if (!crtc->name) {
 710                 drm_mode_object_put(dev, &crtc->base);
 711                 return -ENOMEM;
 712         }
 713
 714         crtc->base.properties = &crtc->properties;
 715
 716         list_add_tail(&crtc->head, &config->crtc_list);
 717         config->num_crtc++;
 718
 719         crtc->primary = primary;
 720         crtc->cursor = cursor;
 721         if (primary)
 722                 primary->possible_crtcs = 1 << drm_crtc_index(crtc);
 723         if (cursor)
 724                 cursor->possible_crtcs = 1 << drm_crtc_index(crtc);
 725
 726         if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
 727                 drm_object_attach_property(&crtc->base, config->prop_active, 0);
 728                 drm_object_attach_property(&crtc->base, config->prop_mode_id, 0);
 729         }
 730
 731         return 0;
 732 }
 733 EXPORT_SYMBOL(drm_crtc_init_with_planes);
 734
 735 /**
 736  * drm_crtc_cleanup - Clean up the core crtc usage
 737  * @crtc: CRTC to cleanup
 738  *
 739  * This function cleans up @crtc and removes it from the DRM mode setting
 740  * core. Note that the function does *not* free the crtc structure itself,
 741  * this is the responsibility of the caller.
 742  */
 743 void drm_crtc_cleanup(struct drm_crtc *crtc)
 744 {
 745         struct drm_device *dev = crtc->dev;
 746
 747         kfree(crtc->gamma_store);
 748         crtc->gamma_store = NULL;
 749
 750         drm_modeset_lock_fini(&crtc->mutex);
 751
 752         drm_mode_object_put(dev, &crtc->base);
 753         list_del(&crtc->head);
 754         dev->mode_config.num_crtc--;
 755
 756         WARN_ON(crtc->state && !crtc->funcs->atomic_destroy_state);
 757         if (crtc->state && crtc->funcs->atomic_destroy_state)
 758                 crtc->funcs->atomic_destroy_state(crtc, crtc->state);
 759
 760         kfree(crtc->name);
 761
 762         memset(crtc, 0, sizeof(*crtc));
 763 }
 764 EXPORT_SYMBOL(drm_crtc_cleanup);
 765
 766 /**
 767  * drm_crtc_index - find the index of a registered CRTC
 768  * @crtc: CRTC to find index for
 769  *
 770  * Given a registered CRTC, return the index of that CRTC within a DRM
 771  * device's list of CRTCs.
 772  */
 773 unsigned int drm_crtc_index(struct drm_crtc *crtc)
 774 {
 775         unsigned int index = 0;
 776         struct drm_crtc *tmp;
 777
 778         drm_for_each_crtc(tmp, crtc->dev) {
 779                 if (tmp == crtc)
 780                         return index;
 781
 782                 index++;
 783         }
 784
 785         BUG();
 786 }
 787 EXPORT_SYMBOL(drm_crtc_index);
 788
 789 /*
 790  * drm_mode_remove - remove and free a mode
 791  * @connector: connector list to modify
 792  * @mode: mode to remove
 793  *
 794  * Remove @mode from @connector's mode list, then free it.
 795  */
 796 static void drm_mode_remove(struct drm_connector *connector,
 797                             struct drm_display_mode *mode)
 798 {
 799         list_del(&mode->head);
 800         drm_mode_destroy(connector->dev, mode);
 801 }
 802
 803 /**
 804  * drm_display_info_set_bus_formats - set the supported bus formats
 805  * @info: display info to store bus formats in
 806  * @formats: array containing the supported bus formats
 807  * @num_formats: the number of entries in the fmts array
 808  *
 809  * Store the supported bus formats in display info structure.
 810  * See MEDIA_BUS_FMT_* definitions in include/uapi/linux/media-bus-format.h for
 811  * a full list of available formats.
 812  */
 813 int drm_display_info_set_bus_formats(struct drm_display_info *info,
 814                                      const u32 *formats,
 815                                      unsigned int num_formats)
 816 {
 817         u32 *fmts = NULL;
 818
 819         if (!formats && num_formats)
 820                 return -EINVAL;
 821
 822         if (formats && num_formats) {
 823                 fmts = kmemdup(formats, sizeof(*formats) * num_formats,
 824                                GFP_KERNEL);
 825                 if (!fmts)
 826                         return -ENOMEM;
 827         }
 828
 829         kfree(info->bus_formats);
 830         info->bus_formats = fmts;
 831         info->num_bus_formats = num_formats;
 832
 833         return 0;
 834 }
 835 EXPORT_SYMBOL(drm_display_info_set_bus_formats);
 836
 837 /**
 838  * drm_connector_get_cmdline_mode - reads the user's cmdline mode
 839  * @connector: connector to quwery
 840  *
 841  * The kernel supports per-connector configration of its consoles through
 842  * use of the video= parameter. This function parses that option and
 843  * extracts the user's specified mode (or enable/disable status) for a
 844  * particular connector. This is typically only used during the early fbdev
 845  * setup.
 846  */
 847 static void drm_connector_get_cmdline_mode(struct drm_connector *connector)
 848 {
 849         struct drm_cmdline_mode *mode = &connector->cmdline_mode;
 850         char *option = NULL;
 851
 852         if (fb_get_options(connector->name, &option))
 853                 return;
 854
 855         if (!drm_mode_parse_command_line_for_connector(option,
 856                                                        connector,
 857                                                        mode))
 858                 return;
 859
 860         if (mode->force) {
 861                 const char *s;
 862
 863                 switch (mode->force) {
 864                 case DRM_FORCE_OFF:
 865                         s = "OFF";
 866                         break;
 867                 case DRM_FORCE_ON_DIGITAL:
 868                         s = "ON - dig";
 869                         break;
 870                 default:
 871                 case DRM_FORCE_ON:
 872                         s = "ON";
 873                         break;
 874                 }
 875
 876                 DRM_INFO("forcing %s connector %s\n", connector->name, s);
 877                 connector->force = mode->force;
 878         }
 879
 880         DRM_DEBUG_KMS("cmdline mode for connector %s %dx%d@%dHz%s%s%s\n",
 881                       connector->name,
 882                       mode->xres, mode->yres,
 883                       mode->refresh_specified ? mode->refresh : 60,
 884                       mode->rb ? " reduced blanking" : "",
 885                       mode->margins ? " with margins" : "",
 886                       mode->interlace ?  " interlaced" : "");
 887 }
 888
 889 /**
 890  * drm_connector_init - Init a preallocated connector
 891  * @dev: DRM device
 892  * @connector: the connector to init
 893  * @funcs: callbacks for this connector
 894  * @connector_type: user visible type of the connector
 895  *
 896  * Initialises a preallocated connector. Connectors should be
 897  * subclassed as part of driver connector objects.
 898  *
 899  * Returns:
 900  * Zero on success, error code on failure.
 901  */
 902 int drm_connector_init(struct drm_device *dev,
 903                        struct drm_connector *connector,
 904                        const struct drm_connector_funcs *funcs,
 905                        int connector_type)
 906 {
 907         struct drm_mode_config *config = &dev->mode_config;
 908         int ret;
 909         struct ida *connector_ida =
 910                 &drm_connector_enum_list[connector_type].ida;
 911
 912         drm_modeset_lock_all(dev);
 913
 914         ret = drm_mode_object_get_reg(dev, &connector->base, DRM_MODE_OBJECT_CONNECTOR, false);
 915         if (ret)
 916                 goto out_unlock;
 917
 918         connector->base.properties = &connector->properties;
 919         connector->dev = dev;
 920         connector->funcs = funcs;
 921         connector->connector_type = connector_type;
 922         connector->connector_type_id =
 923                 ida_simple_get(connector_ida, 1, 0, GFP_KERNEL);
 924         if (connector->connector_type_id < 0) {
 925                 ret = connector->connector_type_id;
 926                 goto out_put;
 927         }
 928         connector->name =
 929                 kasprintf(GFP_KERNEL, "%s-%d",
 930                           drm_connector_enum_list[connector_type].name,
 931                           connector->connector_type_id);
 932         if (!connector->name) {
 933                 ret = -ENOMEM;
 934                 goto out_put;
 935         }
 936
 937         INIT_LIST_HEAD(&connector->probed_modes);
 938         INIT_LIST_HEAD(&connector->modes);
 939         connector->edid_blob_ptr = NULL;
 940         connector->status = connector_status_unknown;
 941
 942         drm_connector_get_cmdline_mode(connector);
 943
 944         /* We should add connectors at the end to avoid upsetting the connector
 945          * index too much. */
 946         list_add_tail(&connector->head, &config->connector_list);
 947         config->num_connector++;
 948
 949         if (connector_type != DRM_MODE_CONNECTOR_VIRTUAL)
 950                 drm_object_attach_property(&connector->base,
 951                                               config->edid_property,
 952                                               0);
 953
 954         drm_object_attach_property(&connector->base,
 955                                       config->dpms_property, 0);
 956
 957         if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
 958                 drm_object_attach_property(&connector->base, config->prop_crtc_id, 0);
 959         }
 960
 961         connector->debugfs_entry = NULL;
 962
 963 out_put:
 964         if (ret)
 965                 drm_mode_object_put(dev, &connector->base);
 966
 967 out_unlock:
 968         drm_modeset_unlock_all(dev);
 969
 970         return ret;
 971 }
 972 EXPORT_SYMBOL(drm_connector_init);
 973
 974 /**
 975  * drm_connector_cleanup - cleans up an initialised connector
 976  * @connector: connector to cleanup
 977  *
 978  * Cleans up the connector but doesn't free the object.
 979  */
 980 void drm_connector_cleanup(struct drm_connector *connector)
 981 {
 982         struct drm_device *dev = connector->dev;
 983         struct drm_display_mode *mode, *t;
 984
 985         if (connector->tile_group) {
 986                 drm_mode_put_tile_group(dev, connector->tile_group);
 987                 connector->tile_group = NULL;
 988         }
 989
 990         list_for_each_entry_safe(mode, t, &connector->probed_modes, head)
 991                 drm_mode_remove(connector, mode);
 992
 993         list_for_each_entry_safe(mode, t, &connector->modes, head)
 994                 drm_mode_remove(connector, mode);
 995
 996         ida_remove(&drm_connector_enum_list[connector->connector_type].ida,
 997                    connector->connector_type_id);
 998
 999         kfree(connector->display_info.bus_formats);
1000         drm_mode_object_put(dev, &connector->base);
1001         kfree(connector->name);
1002         connector->name = NULL;
1003         list_del(&connector->head);
1004         dev->mode_config.num_connector--;
1005
1006         WARN_ON(connector->state && !connector->funcs->atomic_destroy_state);
1007         if (connector->state && connector->funcs->atomic_destroy_state)
1008                 connector->funcs->atomic_destroy_state(connector,
1009                                                        connector->state);
1010
1011         memset(connector, 0, sizeof(*connector));
1012 }
1013 EXPORT_SYMBOL(drm_connector_cleanup);
1014
1015 /**
1016  * drm_connector_index - find the index of a registered connector
1017  * @connector: connector to find index for
1018  *
1019  * Given a registered connector, return the index of that connector within a DRM
1020  * device's list of connectors.
1021  */
1022 unsigned int drm_connector_index(struct drm_connector *connector)
1023 {
1024         unsigned int index = 0;
1025         struct drm_connector *tmp;
1026         struct drm_mode_config *config = &connector->dev->mode_config;
1027
1028         WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
1029
1030         drm_for_each_connector(tmp, connector->dev) {
1031                 if (tmp == connector)
1032                         return index;
1033
1034                 index++;
1035         }
1036
1037         BUG();
1038 }
1039 EXPORT_SYMBOL(drm_connector_index);
1040
1041 /**
1042  * drm_connector_register - register a connector
1043  * @connector: the connector to register
1044  *
1045  * Register userspace interfaces for a connector
1046  *
1047  * Returns:
1048  * Zero on success, error code on failure.
1049  */
1050 int drm_connector_register(struct drm_connector *connector)
1051 {
1052         int ret;
1053
1054         drm_mode_object_register(connector->dev, &connector->base);
1055
1056         ret = drm_sysfs_connector_add(connector);
1057         if (ret)
1058                 return ret;
1059
1060         ret = drm_debugfs_connector_add(connector);
1061         if (ret) {
1062                 drm_sysfs_connector_remove(connector);
1063                 return ret;
1064         }
1065
1066         return 0;
1067 }
1068 EXPORT_SYMBOL(drm_connector_register);
1069
1070 /**
1071  * drm_connector_unregister - unregister a connector
1072  * @connector: the connector to unregister
1073  *
1074  * Unregister userspace interfaces for a connector
1075  */
1076 void drm_connector_unregister(struct drm_connector *connector)
1077 {
1078         drm_sysfs_connector_remove(connector);
1079         drm_debugfs_connector_remove(connector);
1080 }
1081 EXPORT_SYMBOL(drm_connector_unregister);
1082
1083
1084 /**
1085  * drm_connector_unplug_all - unregister connector userspace interfaces
1086  * @dev: drm device
1087  *
1088  * This function unregisters all connector userspace interfaces in sysfs. Should
1089  * be call when the device is disconnected, e.g. from an usb driver's
1090  * ->disconnect callback.
1091  */
1092 void drm_connector_unplug_all(struct drm_device *dev)
1093 {
1094         struct drm_connector *connector;
1095
1096         /* FIXME: taking the mode config mutex ends up in a clash with sysfs */
1097         list_for_each_entry(connector, &dev->mode_config.connector_list, head)
1098                 drm_connector_unregister(connector);
1099
1100 }
1101 EXPORT_SYMBOL(drm_connector_unplug_all);
1102
1103 /**
1104  * drm_encoder_init - Init a preallocated encoder
1105  * @dev: drm device
1106  * @encoder: the encoder to init
1107  * @funcs: callbacks for this encoder
1108  * @encoder_type: user visible type of the encoder
1109  * @name: printf style format string for the encoder name, or NULL for default name
1110  *
1111  * Initialises a preallocated encoder. Encoder should be
1112  * subclassed as part of driver encoder objects.
1113  *
1114  * Returns:
1115  * Zero on success, error code on failure.
1116  */
1117 int drm_encoder_init(struct drm_device *dev,
1118                       struct drm_encoder *encoder,
1119                       const struct drm_encoder_funcs *funcs,
1120                       int encoder_type, const char *name, ...)
1121 {
1122         int ret;
1123
1124         drm_modeset_lock_all(dev);
1125
1126         ret = drm_mode_object_get(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER);
1127         if (ret)
1128                 goto out_unlock;
1129
1130         encoder->dev = dev;
1131         encoder->encoder_type = encoder_type;
1132         encoder->funcs = funcs;
1133         if (name) {
1134                 va_list ap;
1135
1136                 va_start(ap, name);
1137                 encoder->name = kvasprintf(GFP_KERNEL, name, ap);
1138                 va_end(ap);
1139         } else {
1140                 encoder->name = kasprintf(GFP_KERNEL, "%s-%d",
1141                                           drm_encoder_enum_list[encoder_type].name,
1142                                           encoder->base.id);
1143         }
1144         if (!encoder->name) {
1145                 ret = -ENOMEM;
1146                 goto out_put;
1147         }
1148
1149         list_add_tail(&encoder->head, &dev->mode_config.encoder_list);
1150         dev->mode_config.num_encoder++;
1151
1152 out_put:
1153         if (ret)
1154                 drm_mode_object_put(dev, &encoder->base);
1155
1156 out_unlock:
1157         drm_modeset_unlock_all(dev);
1158
1159         return ret;
1160 }
1161 EXPORT_SYMBOL(drm_encoder_init);
1162
1163 /**
1164  * drm_encoder_index - find the index of a registered encoder
1165  * @encoder: encoder to find index for
1166  *
1167  * Given a registered encoder, return the index of that encoder within a DRM
1168  * device's list of encoders.
1169  */
1170 unsigned int drm_encoder_index(struct drm_encoder *encoder)
1171 {
1172         unsigned int index = 0;
1173         struct drm_encoder *tmp;
1174
1175         drm_for_each_encoder(tmp, encoder->dev) {
1176                 if (tmp == encoder)
1177                         return index;
1178
1179                 index++;
1180         }
1181
1182         BUG();
1183 }
1184 EXPORT_SYMBOL(drm_encoder_index);
1185
1186 /**
1187  * drm_encoder_cleanup - cleans up an initialised encoder
1188  * @encoder: encoder to cleanup
1189  *
1190  * Cleans up the encoder but doesn't free the object.
1191  */
1192 void drm_encoder_cleanup(struct drm_encoder *encoder)
1193 {
1194         struct drm_device *dev = encoder->dev;
1195
1196         drm_modeset_lock_all(dev);
1197         drm_mode_object_put(dev, &encoder->base);
1198         kfree(encoder->name);
1199         list_del(&encoder->head);
1200         dev->mode_config.num_encoder--;
1201         drm_modeset_unlock_all(dev);
1202
1203         memset(encoder, 0, sizeof(*encoder));
1204 }
1205 EXPORT_SYMBOL(drm_encoder_cleanup);
1206
1207 static unsigned int drm_num_planes(struct drm_device *dev)
1208 {
1209         unsigned int num = 0;
1210         struct drm_plane *tmp;
1211
1212         drm_for_each_plane(tmp, dev) {
1213                 num++;
1214         }
1215
1216         return num;
1217 }
1218
1219 /**
1220  * drm_universal_plane_init - Initialize a new universal plane object
1221  * @dev: DRM device
1222  * @plane: plane object to init
1223  * @possible_crtcs: bitmask of possible CRTCs
1224  * @funcs: callbacks for the new plane
1225  * @formats: array of supported formats (%DRM_FORMAT_*)
1226  * @format_count: number of elements in @formats
1227  * @type: type of plane (overlay, primary, cursor)
1228  * @name: printf style format string for the plane name, or NULL for default name
1229  *
1230  * Initializes a plane object of type @type.
1231  *
1232  * Returns:
1233  * Zero on success, error code on failure.
1234  */
1235 int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane,
1236                              unsigned long possible_crtcs,
1237                              const struct drm_plane_funcs *funcs,
1238                              const uint32_t *formats, unsigned int format_count,
1239                              enum drm_plane_type type,
1240                              const char *name, ...)
1241 {
1242         struct drm_mode_config *config = &dev->mode_config;
1243         int ret;
1244
1245         ret = drm_mode_object_get(dev, &plane->base, DRM_MODE_OBJECT_PLANE);
1246         if (ret)
1247                 return ret;
1248
1249         drm_modeset_lock_init(&plane->mutex);
1250
1251         plane->base.properties = &plane->properties;
1252         plane->dev = dev;
1253         plane->funcs = funcs;
1254         plane->format_types = kmalloc_array(format_count, sizeof(uint32_t),
1255                                             GFP_KERNEL);
1256         if (!plane->format_types) {
1257                 DRM_DEBUG_KMS("out of memory when allocating plane\n");
1258                 drm_mode_object_put(dev, &plane->base);
1259                 return -ENOMEM;
1260         }
1261
1262         if (name) {
1263                 va_list ap;
1264
1265                 va_start(ap, name);
1266                 plane->name = kvasprintf(GFP_KERNEL, name, ap);
1267                 va_end(ap);
1268         } else {
1269                 plane->name = kasprintf(GFP_KERNEL, "plane-%d",
1270                                         drm_num_planes(dev));
1271         }
1272         if (!plane->name) {
1273                 kfree(plane->format_types);
1274                 drm_mode_object_put(dev, &plane->base);
1275                 return -ENOMEM;
1276         }
1277
1278         memcpy(plane->format_types, formats, format_count * sizeof(uint32_t));
1279         plane->format_count = format_count;
1280         plane->possible_crtcs = possible_crtcs;
1281         plane->type = type;
1282
1283         list_add_tail(&plane->head, &config->plane_list);
1284         config->num_total_plane++;
1285         if (plane->type == DRM_PLANE_TYPE_OVERLAY)
1286                 config->num_overlay_plane++;
1287
1288         drm_object_attach_property(&plane->base,
1289                                    config->plane_type_property,
1290                                    plane->type);
1291
1292         if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
1293                 drm_object_attach_property(&plane->base, config->prop_fb_id, 0);
1294                 drm_object_attach_property(&plane->base, config->prop_crtc_id, 0);
1295                 drm_object_attach_property(&plane->base, config->prop_crtc_x, 0);
1296                 drm_object_attach_property(&plane->base, config->prop_crtc_y, 0);
1297                 drm_object_attach_property(&plane->base, config->prop_crtc_w, 0);
1298                 drm_object_attach_property(&plane->base, config->prop_crtc_h, 0);
1299                 drm_object_attach_property(&plane->base, config->prop_src_x, 0);
1300                 drm_object_attach_property(&plane->base, config->prop_src_y, 0);
1301                 drm_object_attach_property(&plane->base, config->prop_src_w, 0);
1302                 drm_object_attach_property(&plane->base, config->prop_src_h, 0);
1303         }
1304
1305         return 0;
1306 }
1307 EXPORT_SYMBOL(drm_universal_plane_init);
1308
1309 /**
1310  * drm_plane_init - Initialize a legacy plane
1311  * @dev: DRM device
1312  * @plane: plane object to init
1313  * @possible_crtcs: bitmask of possible CRTCs
1314  * @funcs: callbacks for the new plane
1315  * @formats: array of supported formats (%DRM_FORMAT_*)
1316  * @format_count: number of elements in @formats
1317  * @is_primary: plane type (primary vs overlay)
1318  *
1319  * Legacy API to initialize a DRM plane.
1320  *
1321  * New drivers should call drm_universal_plane_init() instead.
1322  *
1323  * Returns:
1324  * Zero on success, error code on failure.
1325  */
1326 int drm_plane_init(struct drm_device *dev, struct drm_plane *plane,
1327                    unsigned long possible_crtcs,
1328                    const struct drm_plane_funcs *funcs,
1329                    const uint32_t *formats, unsigned int format_count,
1330                    bool is_primary)
1331 {
1332         enum drm_plane_type type;
1333
1334         type = is_primary ? DRM_PLANE_TYPE_PRIMARY : DRM_PLANE_TYPE_OVERLAY;
1335         return drm_universal_plane_init(dev, plane, possible_crtcs, funcs,
1336                                         formats, format_count, type, NULL);
1337 }
1338 EXPORT_SYMBOL(drm_plane_init);
1339
1340 /**
1341  * drm_plane_cleanup - Clean up the core plane usage
1342  * @plane: plane to cleanup
1343  *
1344  * This function cleans up @plane and removes it from the DRM mode setting
1345  * core. Note that the function does *not* free the plane structure itself,
1346  * this is the responsibility of the caller.
1347  */
1348 void drm_plane_cleanup(struct drm_plane *plane)
1349 {
1350         struct drm_device *dev = plane->dev;
1351
1352         drm_modeset_lock_all(dev);
1353         kfree(plane->format_types);
1354         drm_mode_object_put(dev, &plane->base);
1355
1356         BUG_ON(list_empty(&plane->head));
1357
1358         list_del(&plane->head);
1359         dev->mode_config.num_total_plane--;
1360         if (plane->type == DRM_PLANE_TYPE_OVERLAY)
1361                 dev->mode_config.num_overlay_plane--;
1362         drm_modeset_unlock_all(dev);
1363
1364         WARN_ON(plane->state && !plane->funcs->atomic_destroy_state);
1365         if (plane->state && plane->funcs->atomic_destroy_state)
1366                 plane->funcs->atomic_destroy_state(plane, plane->state);
1367
1368         kfree(plane->name);
1369
1370         memset(plane, 0, sizeof(*plane));
1371 }
1372 EXPORT_SYMBOL(drm_plane_cleanup);
1373
1374 /**
1375  * drm_plane_index - find the index of a registered plane
1376  * @plane: plane to find index for
1377  *
1378  * Given a registered plane, return the index of that CRTC within a DRM
1379  * device's list of planes.
1380  */
1381 unsigned int drm_plane_index(struct drm_plane *plane)
1382 {
1383         unsigned int index = 0;
1384         struct drm_plane *tmp;
1385
1386         drm_for_each_plane(tmp, plane->dev) {
1387                 if (tmp == plane)
1388                         return index;
1389
1390                 index++;
1391         }
1392
1393         BUG();
1394 }
1395 EXPORT_SYMBOL(drm_plane_index);
1396
1397 /**
1398  * drm_plane_from_index - find the registered plane at an index
1399  * @dev: DRM device
1400  * @idx: index of registered plane to find for
1401  *
1402  * Given a plane index, return the registered plane from DRM device's
1403  * list of planes with matching index.
1404  */
1405 struct drm_plane *
1406 drm_plane_from_index(struct drm_device *dev, int idx)
1407 {
1408         struct drm_plane *plane;
1409         unsigned int i = 0;
1410
1411         drm_for_each_plane(plane, dev) {
1412                 if (i == idx)
1413                         return plane;
1414                 i++;
1415         }
1416         return NULL;
1417 }
1418 EXPORT_SYMBOL(drm_plane_from_index);
1419
1420 /**
1421  * drm_plane_force_disable - Forcibly disable a plane
1422  * @plane: plane to disable
1423  *
1424  * Forces the plane to be disabled.
1425  *
1426  * Used when the plane's current framebuffer is destroyed,
1427  * and when restoring fbdev mode.
1428  */
1429 void drm_plane_force_disable(struct drm_plane *plane)
1430 {
1431         int ret;
1432
1433         if (!plane->fb)
1434                 return;
1435
1436         plane->old_fb = plane->fb;
1437         ret = plane->funcs->disable_plane(plane);
1438         if (ret) {
1439                 DRM_ERROR("failed to disable plane with busy fb\n");
1440                 plane->old_fb = NULL;
1441                 return;
1442         }
1443         /* disconnect the plane from the fb and crtc: */
1444         drm_framebuffer_unreference(plane->old_fb);
1445         plane->old_fb = NULL;
1446         plane->fb = NULL;
1447         plane->crtc = NULL;
1448 }
1449 EXPORT_SYMBOL(drm_plane_force_disable);
1450
1451 static int drm_mode_create_standard_properties(struct drm_device *dev)
1452 {
1453         struct drm_property *prop;
1454
1455         /*
1456          * Standard properties (apply to all connectors)
1457          */
1458         prop = drm_property_create(dev, DRM_MODE_PROP_BLOB |
1459                                    DRM_MODE_PROP_IMMUTABLE,
1460                                    "EDID", 0);
1461         if (!prop)
1462                 return -ENOMEM;
1463         dev->mode_config.edid_property = prop;
1464
1465         prop = drm_property_create_enum(dev, 0,
1466                                    "DPMS", drm_dpms_enum_list,
1467                                    ARRAY_SIZE(drm_dpms_enum_list));
1468         if (!prop)
1469                 return -ENOMEM;
1470         dev->mode_config.dpms_property = prop;
1471
1472         prop = drm_property_create(dev,
1473                                    DRM_MODE_PROP_BLOB |
1474                                    DRM_MODE_PROP_IMMUTABLE,
1475                                    "PATH", 0);
1476         if (!prop)
1477                 return -ENOMEM;
1478         dev->mode_config.path_property = prop;
1479
1480         prop = drm_property_create(dev,
1481                                    DRM_MODE_PROP_BLOB |
1482                                    DRM_MODE_PROP_IMMUTABLE,
1483                                    "TILE", 0);
1484         if (!prop)
1485                 return -ENOMEM;
1486         dev->mode_config.tile_property = prop;
1487
1488         prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
1489                                         "type", drm_plane_type_enum_list,
1490                                         ARRAY_SIZE(drm_plane_type_enum_list));
1491         if (!prop)
1492                 return -ENOMEM;
1493         dev->mode_config.plane_type_property = prop;
1494
1495         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
1496                         "SRC_X", 0, UINT_MAX);
1497         if (!prop)
1498                 return -ENOMEM;
1499         dev->mode_config.prop_src_x = prop;
1500
1501         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
1502                         "SRC_Y", 0, UINT_MAX);
1503         if (!prop)
1504                 return -ENOMEM;
1505         dev->mode_config.prop_src_y = prop;
1506
1507         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
1508                         "SRC_W", 0, UINT_MAX);
1509         if (!prop)
1510                 return -ENOMEM;
1511         dev->mode_config.prop_src_w = prop;
1512
1513         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
1514                         "SRC_H", 0, UINT_MAX);
1515         if (!prop)
1516                 return -ENOMEM;
1517         dev->mode_config.prop_src_h = prop;
1518
1519         prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
1520                         "CRTC_X", INT_MIN, INT_MAX);
1521         if (!prop)
1522                 return -ENOMEM;
1523         dev->mode_config.prop_crtc_x = prop;
1524
1525         prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
1526                         "CRTC_Y", INT_MIN, INT_MAX);
1527         if (!prop)
1528                 return -ENOMEM;
1529         dev->mode_config.prop_crtc_y = prop;
1530
1531         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
1532                         "CRTC_W", 0, INT_MAX);
1533         if (!prop)
1534                 return -ENOMEM;
1535         dev->mode_config.prop_crtc_w = prop;
1536
1537         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
1538                         "CRTC_H", 0, INT_MAX);
1539         if (!prop)
1540                 return -ENOMEM;
1541         dev->mode_config.prop_crtc_h = prop;
1542
1543         prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
1544                         "FB_ID", DRM_MODE_OBJECT_FB);
1545         if (!prop)
1546                 return -ENOMEM;
1547         dev->mode_config.prop_fb_id = prop;
1548
1549         prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
1550                         "CRTC_ID", DRM_MODE_OBJECT_CRTC);
1551         if (!prop)
1552                 return -ENOMEM;
1553         dev->mode_config.prop_crtc_id = prop;
1554
1555         prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC,
1556                         "ACTIVE");
1557         if (!prop)
1558                 return -ENOMEM;
1559         dev->mode_config.prop_active = prop;
1560
1561         prop = drm_property_create(dev,
1562                         DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB,
1563                         "MODE_ID", 0);
1564         if (!prop)
1565                 return -ENOMEM;
1566         dev->mode_config.prop_mode_id = prop;
1567
1568         return 0;
1569 }
1570
1571 /**
1572  * drm_mode_create_dvi_i_properties - create DVI-I specific connector properties
1573  * @dev: DRM device
1574  *
1575  * Called by a driver the first time a DVI-I connector is made.
1576  */
1577 int drm_mode_create_dvi_i_properties(struct drm_device *dev)
1578 {
1579         struct drm_property *dvi_i_selector;
1580         struct drm_property *dvi_i_subconnector;
1581
1582         if (dev->mode_config.dvi_i_select_subconnector_property)
1583                 return 0;
1584
1585         dvi_i_selector =
1586                 drm_property_create_enum(dev, 0,
1587                                     "select subconnector",
1588                                     drm_dvi_i_select_enum_list,
1589                                     ARRAY_SIZE(drm_dvi_i_select_enum_list));
1590         dev->mode_config.dvi_i_select_subconnector_property = dvi_i_selector;
1591
1592         dvi_i_subconnector = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
1593                                     "subconnector",
1594                                     drm_dvi_i_subconnector_enum_list,
1595                                     ARRAY_SIZE(drm_dvi_i_subconnector_enum_list));
1596         dev->mode_config.dvi_i_subconnector_property = dvi_i_subconnector;
1597
1598         return 0;
1599 }
1600 EXPORT_SYMBOL(drm_mode_create_dvi_i_properties);
1601
1602 /**
1603  * drm_create_tv_properties - create TV specific connector properties
1604  * @dev: DRM device
1605  * @num_modes: number of different TV formats (modes) supported
1606  * @modes: array of pointers to strings containing name of each format
1607  *
1608  * Called by a driver's TV initialization routine, this function creates
1609  * the TV specific connector properties for a given device.  Caller is
1610  * responsible for allocating a list of format names and passing them to
1611  * this routine.
1612  */
1613 int drm_mode_create_tv_properties(struct drm_device *dev,
1614                                   unsigned int num_modes,
1615                                   const char * const modes[])
1616 {
1617         struct drm_property *tv_selector;
1618         struct drm_property *tv_subconnector;
1619         unsigned int i;
1620
1621         if (dev->mode_config.tv_select_subconnector_property)
1622                 return 0;
1623
1624         /*
1625          * Basic connector properties
1626          */
1627         tv_selector = drm_property_create_enum(dev, 0,
1628                                           "select subconnector",
1629                                           drm_tv_select_enum_list,
1630                                           ARRAY_SIZE(drm_tv_select_enum_list));
1631         if (!tv_selector)
1632                 goto nomem;
1633
1634         dev->mode_config.tv_select_subconnector_property = tv_selector;
1635
1636         tv_subconnector =
1637                 drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
1638                                     "subconnector",
1639                                     drm_tv_subconnector_enum_list,
1640                                     ARRAY_SIZE(drm_tv_subconnector_enum_list));
1641         if (!tv_subconnector)
1642                 goto nomem;
1643         dev->mode_config.tv_subconnector_property = tv_subconnector;
1644
1645         /*
1646          * Other, TV specific properties: margins & TV modes.
1647          */
1648         dev->mode_config.tv_left_margin_property =
1649                 drm_property_create_range(dev, 0, "left margin", 0, 100);
1650         if (!dev->mode_config.tv_left_margin_property)
1651                 goto nomem;
1652
1653         dev->mode_config.tv_right_margin_property =
1654                 drm_property_create_range(dev, 0, "right margin", 0, 100);
1655         if (!dev->mode_config.tv_right_margin_property)
1656                 goto nomem;
1657
1658         dev->mode_config.tv_top_margin_property =
1659                 drm_property_create_range(dev, 0, "top margin", 0, 100);
1660         if (!dev->mode_config.tv_top_margin_property)
1661                 goto nomem;
1662
1663         dev->mode_config.tv_bottom_margin_property =
1664                 drm_property_create_range(dev, 0, "bottom margin", 0, 100);
1665         if (!dev->mode_config.tv_bottom_margin_property)
1666                 goto nomem;
1667
1668         dev->mode_config.tv_mode_property =
1669                 drm_property_create(dev, DRM_MODE_PROP_ENUM,
1670                                     "mode", num_modes);
1671         if (!dev->mode_config.tv_mode_property)
1672                 goto nomem;
1673
1674         for (i = 0; i < num_modes; i++)
1675                 drm_property_add_enum(dev->mode_config.tv_mode_property, i,
1676                                       i, modes[i]);
1677
1678         dev->mode_config.tv_brightness_property =
1679                 drm_property_create_range(dev, 0, "brightness", 0, 100);
1680         if (!dev->mode_config.tv_brightness_property)
1681                 goto nomem;
1682
1683         dev->mode_config.tv_contrast_property =
1684                 drm_property_create_range(dev, 0, "contrast", 0, 100);
1685         if (!dev->mode_config.tv_contrast_property)
1686                 goto nomem;
1687
1688         dev->mode_config.tv_flicker_reduction_property =
1689                 drm_property_create_range(dev, 0, "flicker reduction", 0, 100);
1690         if (!dev->mode_config.tv_flicker_reduction_property)
1691                 goto nomem;
1692
1693         dev->mode_config.tv_overscan_property =
1694                 drm_property_create_range(dev, 0, "overscan", 0, 100);
1695         if (!dev->mode_config.tv_overscan_property)
1696                 goto nomem;
1697
1698         dev->mode_config.tv_saturation_property =
1699                 drm_property_create_range(dev, 0, "saturation", 0, 100);
1700         if (!dev->mode_config.tv_saturation_property)
1701                 goto nomem;
1702
1703         dev->mode_config.tv_hue_property =
1704                 drm_property_create_range(dev, 0, "hue", 0, 100);
1705         if (!dev->mode_config.tv_hue_property)
1706                 goto nomem;
1707
1708         return 0;
1709 nomem:
1710         return -ENOMEM;
1711 }
1712 EXPORT_SYMBOL(drm_mode_create_tv_properties);
1713
1714 /**
1715  * drm_mode_create_scaling_mode_property - create scaling mode property
1716  * @dev: DRM device
1717  *
1718  * Called by a driver the first time it's needed, must be attached to desired
1719  * connectors.
1720  */
1721 int drm_mode_create_scaling_mode_property(struct drm_device *dev)
1722 {
1723         struct drm_property *scaling_mode;
1724
1725         if (dev->mode_config.scaling_mode_property)
1726                 return 0;
1727
1728         scaling_mode =
1729                 drm_property_create_enum(dev, 0, "scaling mode",
1730                                 drm_scaling_mode_enum_list,
1731                                     ARRAY_SIZE(drm_scaling_mode_enum_list));
1732
1733         dev->mode_config.scaling_mode_property = scaling_mode;
1734
1735         return 0;
1736 }
1737 EXPORT_SYMBOL(drm_mode_create_scaling_mode_property);
1738
1739 /**
1740  * drm_mode_create_aspect_ratio_property - create aspect ratio property
1741  * @dev: DRM device
1742  *
1743  * Called by a driver the first time it's needed, must be attached to desired
1744  * connectors.
1745  *
1746  * Returns:
1747  * Zero on success, negative errno on failure.
1748  */
1749 int drm_mode_create_aspect_ratio_property(struct drm_device *dev)
1750 {
1751         if (dev->mode_config.aspect_ratio_property)
1752                 return 0;
1753
1754         dev->mode_config.aspect_ratio_property =
1755                 drm_property_create_enum(dev, 0, "aspect ratio",
1756                                 drm_aspect_ratio_enum_list,
1757                                 ARRAY_SIZE(drm_aspect_ratio_enum_list));
1758
1759         if (dev->mode_config.aspect_ratio_property == NULL)
1760                 return -ENOMEM;
1761
1762         return 0;
1763 }
1764 EXPORT_SYMBOL(drm_mode_create_aspect_ratio_property);
1765
1766 /**
1767  * drm_mode_create_dirty_property - create dirty property
1768  * @dev: DRM device
1769  *
1770  * Called by a driver the first time it's needed, must be attached to desired
1771  * connectors.
1772  */
1773 int drm_mode_create_dirty_info_property(struct drm_device *dev)
1774 {
1775         struct drm_property *dirty_info;
1776
1777         if (dev->mode_config.dirty_info_property)
1778                 return 0;
1779
1780         dirty_info =
1781                 drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
1782                                     "dirty",
1783                                     drm_dirty_info_enum_list,
1784                                     ARRAY_SIZE(drm_dirty_info_enum_list));
1785         dev->mode_config.dirty_info_property = dirty_info;
1786
1787         return 0;
1788 }
1789 EXPORT_SYMBOL(drm_mode_create_dirty_info_property);
1790
1791 /**
1792  * drm_mode_create_suggested_offset_properties - create suggests offset properties
1793  * @dev: DRM device
1794  *
1795  * Create the the suggested x/y offset property for connectors.
1796  */
1797 int drm_mode_create_suggested_offset_properties(struct drm_device *dev)
1798 {
1799         if (dev->mode_config.suggested_x_property && dev->mode_config.suggested_y_property)
1800                 return 0;
1801
1802         dev->mode_config.suggested_x_property =
1803                 drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested X", 0, 0xffffffff);
1804
1805         dev->mode_config.suggested_y_property =
1806                 drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE, "suggested Y", 0, 0xffffffff);
1807
1808         if (dev->mode_config.suggested_x_property == NULL ||
1809             dev->mode_config.suggested_y_property == NULL)
1810                 return -ENOMEM;
1811         return 0;
1812 }
1813 EXPORT_SYMBOL(drm_mode_create_suggested_offset_properties);
1814
1815 /**
1816  * drm_mode_getresources - get graphics configuration
1817  * @dev: drm device for the ioctl
1818  * @data: data pointer for the ioctl
1819  * @file_priv: drm file for the ioctl call
1820  *
1821  * Construct a set of configuration description structures and return
1822  * them to the user, including CRTC, connector and framebuffer configuration.
1823  *
1824  * Called by the user via ioctl.
1825  *
1826  * Returns:
1827  * Zero on success, negative errno on failure.
1828  */
1829 int drm_mode_getresources(struct drm_device *dev, void *data,
1830                           struct drm_file *file_priv)
1831 {
1832         struct drm_mode_card_res *card_res = data;
1833         struct list_head *lh;
1834         struct drm_framebuffer *fb;
1835         struct drm_connector *connector;
1836         struct drm_crtc *crtc;
1837         struct drm_encoder *encoder;
1838         int ret = 0;
1839         int connector_count = 0;
1840         int crtc_count = 0;
1841         int fb_count = 0;
1842         int encoder_count = 0;
1843         int copied = 0;
1844         uint32_t __user *fb_id;
1845         uint32_t __user *crtc_id;
1846         uint32_t __user *connector_id;
1847         uint32_t __user *encoder_id;
1848
1849         if (!drm_core_check_feature(dev, DRIVER_MODESET))
1850                 return -EINVAL;
1851
1852
1853         mutex_lock(&file_priv->fbs_lock);
1854         /*
1855          * For the non-control nodes we need to limit the list of resources
1856          * by IDs in the group list for this node
1857          */
1858         list_for_each(lh, &file_priv->fbs)
1859                 fb_count++;
1860
1861         /* handle this in 4 parts */
1862         /* FBs */
1863         if (card_res->count_fbs >= fb_count) {
1864                 copied = 0;
1865                 fb_id = (uint32_t __user *)(unsigned long)card_res->fb_id_ptr;
1866                 list_for_each_entry(fb, &file_priv->fbs, filp_head) {
1867                         if (put_user(fb->base.id, fb_id + copied)) {
1868                                 mutex_unlock(&file_priv->fbs_lock);
1869                                 return -EFAULT;
1870                         }
1871                         copied++;
1872                 }
1873         }
1874         card_res->count_fbs = fb_count;
1875         mutex_unlock(&file_priv->fbs_lock);
1876
1877         /* mode_config.mutex protects the connector list against e.g. DP MST
1878          * connector hot-adding. CRTC/Plane lists are invariant. */
1879         mutex_lock(&dev->mode_config.mutex);
1880         drm_for_each_crtc(crtc, dev)
1881                 crtc_count++;
1882
1883         drm_for_each_connector(connector, dev)
1884                 connector_count++;
1885
1886         drm_for_each_encoder(encoder, dev)
1887                 encoder_count++;
1888
1889         card_res->max_height = dev->mode_config.max_height;
1890         card_res->min_height = dev->mode_config.min_height;
1891         card_res->max_width = dev->mode_config.max_width;
1892         card_res->min_width = dev->mode_config.min_width;
1893
1894         /* CRTCs */
1895         if (card_res->count_crtcs >= crtc_count) {
1896                 copied = 0;
1897                 crtc_id = (uint32_t __user *)(unsigned long)card_res->crtc_id_ptr;
1898                 drm_for_each_crtc(crtc, dev) {
1899                         DRM_DEBUG_KMS("[CRTC:%d:%s]\n",
1900                                       crtc->base.id, crtc->name);
1901                         if (put_user(crtc->base.id, crtc_id + copied)) {
1902                                 ret = -EFAULT;
1903                                 goto out;
1904                         }
1905                         copied++;
1906                 }
1907         }
1908         card_res->count_crtcs = crtc_count;
1909
1910         /* Encoders */
1911         if (card_res->count_encoders >= encoder_count) {
1912                 copied = 0;
1913                 encoder_id = (uint32_t __user *)(unsigned long)card_res->encoder_id_ptr;
1914                 drm_for_each_encoder(encoder, dev) {
1915                         DRM_DEBUG_KMS("[ENCODER:%d:%s]\n", encoder->base.id,
1916                                         encoder->name);
1917                         if (put_user(encoder->base.id, encoder_id +
1918                                      copied)) {
1919                                 ret = -EFAULT;
1920                                 goto out;
1921                         }
1922                         copied++;
1923                 }
1924         }
1925         card_res->count_encoders = encoder_count;
1926
1927         /* Connectors */
1928         if (card_res->count_connectors >= connector_count) {
1929                 copied = 0;
1930                 connector_id = (uint32_t __user *)(unsigned long)card_res->connector_id_ptr;
1931                 drm_for_each_connector(connector, dev) {
1932                         DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
1933                                 connector->base.id,
1934                                 connector->name);
1935                         if (put_user(connector->base.id,
1936                                      connector_id + copied)) {
1937                                 ret = -EFAULT;
1938                                 goto out;
1939                         }
1940                         copied++;
1941                 }
1942         }
1943         card_res->count_connectors = connector_count;
1944
1945         DRM_DEBUG_KMS("CRTC[%d] CONNECTORS[%d] ENCODERS[%d]\n", card_res->count_crtcs,
1946                   card_res->count_connectors, card_res->count_encoders);
1947
1948 out:
1949         mutex_unlock(&dev->mode_config.mutex);
1950         return ret;
1951 }
1952
1953 /**
1954  * drm_mode_getcrtc - get CRTC configuration
1955  * @dev: drm device for the ioctl
1956  * @data: data pointer for the ioctl
1957  * @file_priv: drm file for the ioctl call
1958  *
1959  * Construct a CRTC configuration structure to return to the user.
1960  *
1961  * Called by the user via ioctl.
1962  *
1963  * Returns:
1964  * Zero on success, negative errno on failure.
1965  */
1966 int drm_mode_getcrtc(struct drm_device *dev,
1967                      void *data, struct drm_file *file_priv)
1968 {
1969         struct drm_mode_crtc *crtc_resp = data;
1970         struct drm_crtc *crtc;
1971
1972         if (!drm_core_check_feature(dev, DRIVER_MODESET))
1973                 return -EINVAL;
1974
1975         crtc = drm_crtc_find(dev, crtc_resp->crtc_id);
1976         if (!crtc)
1977                 return -ENOENT;
1978
1979         drm_modeset_lock_crtc(crtc, crtc->primary);
1980         crtc_resp->gamma_size = crtc->gamma_size;
1981         if (crtc->primary->fb)
1982                 crtc_resp->fb_id = crtc->primary->fb->base.id;
1983         else
1984                 crtc_resp->fb_id = 0;
1985
1986         if (crtc->state) {
1987                 crtc_resp->x = crtc->primary->state->src_x >> 16;
1988                 crtc_resp->y = crtc->primary->state->src_y >> 16;
1989                 if (crtc->state->enable) {
1990                         drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->state->mode);
1991                         crtc_resp->mode_valid = 1;
1992
1993                 } else {
1994                         crtc_resp->mode_valid = 0;
1995                 }
1996         } else {
1997                 crtc_resp->x = crtc->x;
1998                 crtc_resp->y = crtc->y;
1999                 if (crtc->enabled) {
2000                         drm_mode_convert_to_umode(&crtc_resp->mode, &crtc->mode);
2001                         crtc_resp->mode_valid = 1;
2002
2003                 } else {
2004                         crtc_resp->mode_valid = 0;
2005                 }
2006         }
2007         drm_modeset_unlock_crtc(crtc);
2008
2009         return 0;
2010 }
2011
2012 static bool drm_mode_expose_to_userspace(const struct drm_display_mode *mode,
2013                                          const struct drm_file *file_priv)
2014 {
2015         /*
2016          * If user-space hasn't configured the driver to expose the stereo 3D
2017          * modes, don't expose them.
2018          */
2019         if (!file_priv->stereo_allowed && drm_mode_is_stereo(mode))
2020                 return false;
2021
2022         return true;
2023 }
2024
2025 static struct drm_encoder *drm_connector_get_encoder(struct drm_connector *connector)
2026 {
2027         /* For atomic drivers only state objects are synchronously updated and
2028          * protected by modeset locks, so check those first. */
2029         if (connector->state)
2030                 return connector->state->best_encoder;
2031         return connector->encoder;
2032 }
2033
2034 /* helper for getconnector and getproperties ioctls */
2035 static int get_properties(struct drm_mode_object *obj, bool atomic,
2036                 uint32_t __user *prop_ptr, uint64_t __user *prop_values,
2037                 uint32_t *arg_count_props)
2038 {
2039         int props_count;
2040         int i, ret, copied;
2041
2042         props_count = obj->properties->count;
2043         if (!atomic)
2044                 props_count -= obj->properties->atomic_count;
2045
2046         if ((*arg_count_props >= props_count) && props_count) {
2047                 for (i = 0, copied = 0; copied < props_count; i++) {
2048                         struct drm_property *prop = obj->properties->properties[i];
2049                         uint64_t val;
2050
2051                         if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)
2052                                 continue;
2053
2054                         ret = drm_object_property_get_value(obj, prop, &val);
2055                         if (ret)
2056                                 return ret;
2057
2058                         if (put_user(prop->base.id, prop_ptr + copied))
2059                                 return -EFAULT;
2060
2061                         if (put_user(val, prop_values + copied))
2062                                 return -EFAULT;
2063
2064                         copied++;
2065                 }
2066         }
2067         *arg_count_props = props_count;
2068
2069         return 0;
2070 }
2071
2072 /**
2073  * drm_mode_getconnector - get connector configuration
2074  * @dev: drm device for the ioctl
2075  * @data: data pointer for the ioctl
2076  * @file_priv: drm file for the ioctl call
2077  *
2078  * Construct a connector configuration structure to return to the user.
2079  *
2080  * Called by the user via ioctl.
2081  *
2082  * Returns:
2083  * Zero on success, negative errno on failure.
2084  */
2085 int drm_mode_getconnector(struct drm_device *dev, void *data,
2086                           struct drm_file *file_priv)
2087 {
2088         struct drm_mode_get_connector *out_resp = data;
2089         struct drm_connector *connector;
2090         struct drm_encoder *encoder;
2091         struct drm_display_mode *mode;
2092         int mode_count = 0;
2093         int encoders_count = 0;
2094         int ret = 0;
2095         int copied = 0;
2096         int i;
2097         struct drm_mode_modeinfo u_mode;
2098         struct drm_mode_modeinfo __user *mode_ptr;
2099         uint32_t __user *encoder_ptr;
2100
2101         if (!drm_core_check_feature(dev, DRIVER_MODESET))
2102                 return -EINVAL;
2103
2104         memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
2105
2106         DRM_DEBUG_KMS("[CONNECTOR:%d:?]\n", out_resp->connector_id);
2107
2108         mutex_lock(&dev->mode_config.mutex);
2109
2110         connector = drm_connector_find(dev, out_resp->connector_id);
2111         if (!connector) {
2112                 ret = -ENOENT;
2113                 goto out_unlock;
2114         }
2115
2116         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++)
2117                 if (connector->encoder_ids[i] != 0)
2118                         encoders_count++;
2119
2120         if (out_resp->count_modes == 0) {
2121                 connector->funcs->fill_modes(connector,
2122                                              dev->mode_config.max_width,
2123                                              dev->mode_config.max_height);
2124         }
2125
2126         /* delayed so we get modes regardless of pre-fill_modes state */
2127         list_for_each_entry(mode, &connector->modes, head)
2128                 if (drm_mode_expose_to_userspace(mode, file_priv))
2129                         mode_count++;
2130
2131         out_resp->connector_id = connector->base.id;
2132         out_resp->connector_type = connector->connector_type;
2133         out_resp->connector_type_id = connector->connector_type_id;
2134         out_resp->mm_width = connector->display_info.width_mm;
2135         out_resp->mm_height = connector->display_info.height_mm;
2136         out_resp->subpixel = connector->display_info.subpixel_order;
2137         out_resp->connection = connector->status;
2138
2139         drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
2140         encoder = drm_connector_get_encoder(connector);
2141         if (encoder)
2142                 out_resp->encoder_id = encoder->base.id;
2143         else
2144                 out_resp->encoder_id = 0;
2145
2146         /*
2147          * This ioctl is called twice, once to determine how much space is
2148          * needed, and the 2nd time to fill it.
2149          */
2150         if ((out_resp->count_modes >= mode_count) && mode_count) {
2151                 copied = 0;
2152                 mode_ptr = (struct drm_mode_modeinfo __user *)(unsigned long)out_resp->modes_ptr;
2153                 list_for_each_entry(mode, &connector->modes, head) {
2154                         if (!drm_mode_expose_to_userspace(mode, file_priv))
2155                                 continue;
2156
2157                         drm_mode_convert_to_umode(&u_mode, mode);
2158                         if (copy_to_user(mode_ptr + copied,
2159                                          &u_mode, sizeof(u_mode))) {
2160                                 ret = -EFAULT;
2161                                 goto out;
2162                         }
2163                         copied++;
2164                 }
2165         }
2166         out_resp->count_modes = mode_count;
2167
2168         ret = get_properties(&connector->base, file_priv->atomic,
2169                         (uint32_t __user *)(unsigned long)(out_resp->props_ptr),
2170                         (uint64_t __user *)(unsigned long)(out_resp->prop_values_ptr),
2171                         &out_resp->count_props);
2172         if (ret)
2173                 goto out;
2174
2175         if ((out_resp->count_encoders >= encoders_count) && encoders_count) {
2176                 copied = 0;
2177                 encoder_ptr = (uint32_t __user *)(unsigned long)(out_resp->encoders_ptr);
2178                 for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
2179                         if (connector->encoder_ids[i] != 0) {
2180                                 if (put_user(connector->encoder_ids[i],
2181                                              encoder_ptr + copied)) {
2182                                         ret = -EFAULT;
2183                                         goto out;
2184                                 }
2185                                 copied++;
2186                         }
2187                 }
2188         }
2189         out_resp->count_encoders = encoders_count;
2190
2191 out:
2192         drm_modeset_unlock(&dev->mode_config.connection_mutex);
2193
2194 out_unlock:
2195         mutex_unlock(&dev->mode_config.mutex);
2196
2197         return ret;
2198 }
2199
2200 static struct drm_crtc *drm_encoder_get_crtc(struct drm_encoder *encoder)
2201 {
2202         struct drm_connector *connector;
2203         struct drm_device *dev = encoder->dev;
2204         bool uses_atomic = false;
2205
2206         /* For atomic drivers only state objects are synchronously updated and
2207          * protected by modeset locks, so check those first. */
2208         drm_for_each_connector(connector, dev) {
2209                 if (!connector->state)
2210                         continue;
2211
2212                 uses_atomic = true;
2213
2214                 if (connector->state->best_encoder != encoder)
2215                         continue;
2216
2217                 return connector->state->crtc;
2218         }
2219
2220         /* Don't return stale data (e.g. pending async disable). */
2221         if (uses_atomic)
2222                 return NULL;
2223
2224         return encoder->crtc;
2225 }
2226
2227 /**
2228  * drm_mode_getencoder - get encoder configuration
2229  * @dev: drm device for the ioctl
2230  * @data: data pointer for the ioctl
2231  * @file_priv: drm file for the ioctl call
2232  *
2233  * Construct a encoder configuration structure to return to the user.
2234  *
2235  * Called by the user via ioctl.
2236  *
2237  * Returns:
2238  * Zero on success, negative errno on failure.
2239  */
2240 int drm_mode_getencoder(struct drm_device *dev, void *data,
2241                         struct drm_file *file_priv)
2242 {
2243         struct drm_mode_get_encoder *enc_resp = data;
2244         struct drm_encoder *encoder;
2245         struct drm_crtc *crtc;
2246
2247         if (!drm_core_check_feature(dev, DRIVER_MODESET))
2248                 return -EINVAL;
2249
2250         encoder = drm_encoder_find(dev, enc_resp->encoder_id);
2251         if (!encoder)
2252                 return -ENOENT;
2253
2254         drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
2255         crtc = drm_encoder_get_crtc(encoder);
2256         if (crtc)
2257                 enc_resp->crtc_id = crtc->base.id;
2258         else
2259                 enc_resp->crtc_id = 0;
2260         drm_modeset_unlock(&dev->mode_config.connection_mutex);
2261
2262         enc_resp->encoder_type = encoder->encoder_type;
2263         enc_resp->encoder_id = encoder->base.id;
2264         enc_resp->possible_crtcs = encoder->possible_crtcs;
2265         enc_resp->possible_clones = encoder->possible_clones;
2266
2267         return 0;
2268 }
2269
2270 /**
2271  * drm_mode_getplane_res - enumerate all plane resources
2272  * @dev: DRM device
2273  * @data: ioctl data
2274  * @file_priv: DRM file info
2275  *
2276  * Construct a list of plane ids to return to the user.
2277  *
2278  * Called by the user via ioctl.
2279  *
2280  * Returns:
2281  * Zero on success, negative errno on failure.
2282  */
2283 int drm_mode_getplane_res(struct drm_device *dev, void *data,
2284                           struct drm_file *file_priv)
2285 {
2286         struct drm_mode_get_plane_res *plane_resp = data;
2287         struct drm_mode_config *config;
2288         struct drm_plane *plane;
2289         uint32_t __user *plane_ptr;
2290         int copied = 0;
2291         unsigned num_planes;
2292
2293         if (!drm_core_check_feature(dev, DRIVER_MODESET))
2294                 return -EINVAL;
2295
2296         config = &dev->mode_config;
2297
2298         if (file_priv->universal_planes)
2299                 num_planes = config->num_total_plane;
2300         else
2301                 num_planes = config->num_overlay_plane;
2302
2303         /*
2304          * This ioctl is called twice, once to determine how much space is
2305          * needed, and the 2nd time to fill it.
2306          */
2307         if (num_planes &&
2308             (plane_resp->count_planes >= num_planes)) {
2309                 plane_ptr = (uint32_t __user *)(unsigned long)plane_resp->plane_id_ptr;
2310
2311                 /* Plane lists are invariant, no locking needed. */
2312                 drm_for_each_plane(plane, dev) {
2313                         /*
2314                          * Unless userspace set the 'universal planes'
2315                          * capability bit, only advertise overlays.
2316                          */
2317                         if (plane->type != DRM_PLANE_TYPE_OVERLAY &&
2318                             !file_priv->universal_planes)
2319                                 continue;
2320
2321                         if (put_user(plane->base.id, plane_ptr + copied))
2322                                 return -EFAULT;
2323                         copied++;
2324                 }
2325         }
2326         plane_resp->count_planes = num_planes;
2327
2328         return 0;
2329 }
2330
2331 /**
2332  * drm_mode_getplane - get plane configuration
2333  * @dev: DRM device
2334  * @data: ioctl data
2335  * @file_priv: DRM file info
2336  *
2337  * Construct a plane configuration structure to return to the user.
2338  *
2339  * Called by the user via ioctl.
2340  *
2341  * Returns:
2342  * Zero on success, negative errno on failure.
2343  */
2344 int drm_mode_getplane(struct drm_device *dev, void *data,
2345                       struct drm_file *file_priv)
2346 {
2347         struct drm_mode_get_plane *plane_resp = data;
2348         struct drm_plane *plane;
2349         uint32_t __user *format_ptr;
2350
2351         if (!drm_core_check_feature(dev, DRIVER_MODESET))
2352                 return -EINVAL;
2353
2354         plane = drm_plane_find(dev, plane_resp->plane_id);
2355         if (!plane)
2356                 return -ENOENT;
2357
2358         drm_modeset_lock(&plane->mutex, NULL);
2359         if (plane->crtc)
2360                 plane_resp->crtc_id = plane->crtc->base.id;
2361         else
2362                 plane_resp->crtc_id = 0;
2363
2364         if (plane->fb)
2365                 plane_resp->fb_id = plane->fb->base.id;
2366         else
2367                 plane_resp->fb_id = 0;
2368         drm_modeset_unlock(&plane->mutex);
2369
2370         plane_resp->plane_id = plane->base.id;
2371         plane_resp->possible_crtcs = plane->possible_crtcs;
2372         plane_resp->gamma_size = 0;
2373
2374         /*
2375          * This ioctl is called twice, once to determine how much space is
2376          * needed, and the 2nd time to fill it.
2377          */
2378         if (plane->format_count &&
2379             (plane_resp->count_format_types >= plane->format_count)) {
2380                 format_ptr = (uint32_t __user *)(unsigned long)plane_resp->format_type_ptr;
2381                 if (copy_to_user(format_ptr,
2382                                  plane->format_types,
2383                                  sizeof(uint32_t) * plane->format_count)) {
2384                         return -EFAULT;
2385                 }
2386         }
2387         plane_resp->count_format_types = plane->format_count;
2388
2389         return 0;
2390 }
2391
2392 /**
2393  * drm_plane_check_pixel_format - Check if the plane supports the pixel format
2394  * @plane: plane to check for format support
2395  * @format: the pixel format
2396  *
2397  * Returns:
2398  * Zero of @plane has @format in its list of supported pixel formats, -EINVAL
2399  * otherwise.
2400  */
2401 int drm_plane_check_pixel_format(const struct drm_plane *plane, u32 format)
2402 {
2403         unsigned int i;
2404
2405         for (i = 0; i < plane->format_count; i++) {
2406                 if (format == plane->format_types[i])
2407                         return 0;
2408         }
2409
2410         return -EINVAL;
2411 }
2412
2413 static int check_src_coords(uint32_t src_x, uint32_t src_y,
2414                             uint32_t src_w, uint32_t src_h,
2415                             const struct drm_framebuffer *fb)
2416 {
2417         unsigned int fb_width, fb_height;
2418
2419         fb_width = fb->width << 16;
2420         fb_height = fb->height << 16;
2421
2422         /* Make sure source coordinates are inside the fb. */
2423         if (src_w > fb_width ||
2424             src_x > fb_width - src_w ||
2425             src_h > fb_height ||
2426             src_y > fb_height - src_h) {
2427                 DRM_DEBUG_KMS("Invalid source coordinates "
2428                               "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
2429                               src_w >> 16, ((src_w & 0xffff) * 15625) >> 10,
2430                               src_h >> 16, ((src_h & 0xffff) * 15625) >> 10,
2431                               src_x >> 16, ((src_x & 0xffff) * 15625) >> 10,
2432                               src_y >> 16, ((src_y & 0xffff) * 15625) >> 10);
2433                 return -ENOSPC;
2434         }
2435
2436         return 0;
2437 }
2438
2439 /*
2440  * setplane_internal - setplane handler for internal callers
2441  *
2442  * Note that we assume an extra reference has already been taken on fb.  If the
2443  * update fails, this reference will be dropped before return; if it succeeds,
2444  * the previous framebuffer (if any) will be unreferenced instead.
2445  *
2446  * src_{x,y,w,h} are provided in 16.16 fixed point format
2447  */
2448 static int __setplane_internal(struct drm_plane *plane,
2449                                struct drm_crtc *crtc,
2450                                struct drm_framebuffer *fb,
2451                                int32_t crtc_x, int32_t crtc_y,
2452                                uint32_t crtc_w, uint32_t crtc_h,
2453                                /* src_{x,y,w,h} values are 16.16 fixed point */
2454                                uint32_t src_x, uint32_t src_y,
2455                                uint32_t src_w, uint32_t src_h)
2456 {
2457         int ret = 0;
2458
2459         /* No fb means shut it down */
2460         if (!fb) {
2461                 plane->old_fb = plane->fb;
2462                 ret = plane->funcs->disable_plane(plane);
2463                 if (!ret) {
2464                         plane->crtc = NULL;
2465                         plane->fb = NULL;
2466                 } else {
2467                         plane->old_fb = NULL;
2468                 }
2469                 goto out;
2470         }
2471
2472         /* Check whether this plane is usable on this CRTC */
2473         if (!(plane->possible_crtcs & drm_crtc_mask(crtc))) {
2474                 DRM_DEBUG_KMS("Invalid crtc for plane\n");
2475                 ret = -EINVAL;
2476                 goto out;
2477         }
2478
2479         /* Check whether this plane supports the fb pixel format. */
2480         ret = drm_plane_check_pixel_format(plane, fb->pixel_format);
2481         if (ret) {
2482                 DRM_DEBUG_KMS("Invalid pixel format %s\n",
2483                               drm_get_format_name(fb->pixel_format));
2484                 goto out;
2485         }
2486
2487         /* Give drivers some help against integer overflows */
2488         if (crtc_w > INT_MAX ||
2489             crtc_x > INT_MAX - (int32_t) crtc_w ||
2490             crtc_h > INT_MAX ||
2491             crtc_y > INT_MAX - (int32_t) crtc_h) {
2492                 DRM_DEBUG_KMS("Invalid CRTC coordinates %ux%u+%d+%d\n",
2493                               crtc_w, crtc_h, crtc_x, crtc_y);
2494                 ret = -ERANGE;
2495                 goto out;
2496         }
2497
2498         ret = check_src_coords(src_x, src_y, src_w, src_h, fb);
2499         if (ret)
2500                 goto out;
2501
2502         plane->old_fb = plane->fb;
2503         ret = plane->funcs->update_plane(plane, crtc, fb,
2504                                          crtc_x, crtc_y, crtc_w, crtc_h,
2505                                          src_x, src_y, src_w, src_h);
2506         if (!ret) {
2507                 plane->crtc = crtc;
2508                 plane->fb = fb;
2509                 fb = NULL;
2510         } else {
2511                 plane->old_fb = NULL;
2512         }
2513
2514 out:
2515         if (fb)
2516                 drm_framebuffer_unreference(fb);
2517         if (plane->old_fb)
2518                 drm_framebuffer_unreference(plane->old_fb);
2519         plane->old_fb = NULL;
2520
2521         return ret;
2522 }
2523
2524 static int setplane_internal(struct drm_plane *plane,
2525                              struct drm_crtc *crtc,
2526                              struct drm_framebuffer *fb,
2527                              int32_t crtc_x, int32_t crtc_y,
2528                              uint32_t crtc_w, uint32_t crtc_h,
2529                              /* src_{x,y,w,h} values are 16.16 fixed point */
2530                              uint32_t src_x, uint32_t src_y,
2531                              uint32_t src_w, uint32_t src_h)
2532 {
2533         int ret;
2534
2535         drm_modeset_lock_all(plane->dev);
2536         ret = __setplane_internal(plane, crtc, fb,
2537                                   crtc_x, crtc_y, crtc_w, crtc_h,
2538                                   src_x, src_y, src_w, src_h);
2539         drm_modeset_unlock_all(plane->dev);
2540
2541         return ret;
2542 }
2543
2544 /**
2545  * drm_mode_setplane - configure a plane's configuration
2546  * @dev: DRM device
2547  * @data: ioctl data*
2548  * @file_priv: DRM file info
2549  *
2550  * Set plane configuration, including placement, fb, scaling, and other factors.
2551  * Or pass a NULL fb to disable (planes may be disabled without providing a
2552  * valid crtc).
2553  *
2554  * Returns:
2555  * Zero on success, negative errno on failure.
2556  */
2557 int drm_mode_setplane(struct drm_device *dev, void *data,
2558                       struct drm_file *file_priv)
2559 {
2560         struct drm_mode_set_plane *plane_req = data;
2561         struct drm_plane *plane;
2562         struct drm_crtc *crtc = NULL;
2563         struct drm_framebuffer *fb = NULL;
2564
2565         if (!drm_core_check_feature(dev, DRIVER_MODESET))
2566                 return -EINVAL;
2567
2568         /*
2569          * First, find the plane, crtc, and fb objects.  If not available,
2570          * we don't bother to call the driver.
2571          */
2572         plane = drm_plane_find(dev, plane_req->plane_id);
2573         if (!plane) {
2574                 DRM_DEBUG_KMS("Unknown plane ID %d\n",
2575                               plane_req->plane_id);
2576                 return -ENOENT;
2577         }
2578
2579         if (plane_req->fb_id) {
2580                 fb = drm_framebuffer_lookup(dev, plane_req->fb_id);
2581                 if (!fb) {
2582                         DRM_DEBUG_KMS("Unknown framebuffer ID %d\n",
2583                                       plane_req->fb_id);
2584                         return -ENOENT;
2585                 }
2586
2587                 crtc = drm_crtc_find(dev, plane_req->crtc_id);
2588                 if (!crtc) {
2589                         DRM_DEBUG_KMS("Unknown crtc ID %d\n",
2590                                       plane_req->crtc_id);
2591                         return -ENOENT;
2592                 }
2593         }
2594
2595         /*
2596          * setplane_internal will take care of deref'ing either the old or new
2597          * framebuffer depending on success.
2598          */
2599         return setplane_internal(plane, crtc, fb,
2600                                  plane_req->crtc_x, plane_req->crtc_y,
2601                                  plane_req->crtc_w, plane_req->crtc_h,
2602                                  plane_req->src_x, plane_req->src_y,
2603                                  plane_req->src_w, plane_req->src_h);
2604 }
2605
2606 /**
2607  * drm_mode_set_config_internal - helper to call ->set_config
2608  * @set: modeset config to set
2609  *
2610  * This is a little helper to wrap internal calls to the ->set_config driver
2611  * interface. The only thing it adds is correct refcounting dance.
2612  *
2613  * Returns:
2614  * Zero on success, negative errno on failure.
2615  */
2616 int drm_mode_set_config_internal(struct drm_mode_set *set)
2617 {
2618         struct drm_crtc *crtc = set->crtc;
2619         struct drm_framebuffer *fb;
2620         struct drm_crtc *tmp;
2621         int ret;
2622
2623         /*
2624          * NOTE: ->set_config can also disable other crtcs (if we steal all
2625          * connectors from it), hence we need to refcount the fbs across all
2626          * crtcs. Atomic modeset will have saner semantics ...
2627          */
2628         drm_for_each_crtc(tmp, crtc->dev)
2629                 tmp->primary->old_fb = tmp->primary->fb;
2630
2631         fb = set->fb;
2632
2633         ret = crtc->funcs->set_config(set);
2634         if (ret == 0) {
2635                 crtc->primary->crtc = crtc;
2636                 crtc->primary->fb = fb;
2637         }
2638
2639         drm_for_each_crtc(tmp, crtc->dev) {
2640                 if (tmp->primary->fb)
2641                         drm_framebuffer_reference(tmp->primary->fb);
2642                 if (tmp->primary->old_fb)
2643                         drm_framebuffer_unreference(tmp->primary->old_fb);
2644                 tmp->primary->old_fb = NULL;
2645         }
2646
2647         return ret;
2648 }
2649 EXPORT_SYMBOL(drm_mode_set_config_internal);
2650
2651 /**
2652  * drm_crtc_get_hv_timing - Fetches hdisplay/vdisplay for given mode
2653  * @mode: mode to query
2654  * @hdisplay: hdisplay value to fill in
2655  * @vdisplay: vdisplay value to fill in
2656  *
2657  * The vdisplay value will be doubled if the specified mode is a stereo mode of
2658  * the appropriate layout.
2659  */
2660 void drm_crtc_get_hv_timing(const struct drm_display_mode *mode,
2661                             int *hdisplay, int *vdisplay)
2662 {
2663         struct drm_display_mode adjusted;
2664
2665         drm_mode_copy(&adjusted, mode);
2666         drm_mode_set_crtcinfo(&adjusted, CRTC_STEREO_DOUBLE_ONLY);
2667         *hdisplay = adjusted.crtc_hdisplay;
2668         *vdisplay = adjusted.crtc_vdisplay;
2669 }
2670 EXPORT_SYMBOL(drm_crtc_get_hv_timing);
2671
2672 /**
2673  * drm_crtc_check_viewport - Checks that a framebuffer is big enough for the
2674  *     CRTC viewport
2675  * @crtc: CRTC that framebuffer will be displayed on
2676  * @x: x panning
2677  * @y: y panning
2678  * @mode: mode that framebuffer will be displayed under
2679  * @fb: framebuffer to check size of
2680  */
2681 int drm_crtc_check_viewport(const struct drm_crtc *crtc,
2682                             int x, int y,
2683                             const struct drm_display_mode *mode,
2684                             const struct drm_framebuffer *fb)
2685
2686 {
2687         int hdisplay, vdisplay;
2688
2689         drm_crtc_get_hv_timing(mode, &hdisplay, &vdisplay);
2690
2691         if (crtc->state &&
2692             crtc->primary->state->rotation & (BIT(DRM_ROTATE_90) |
2693                                               BIT(DRM_ROTATE_270)))
2694                 swap(hdisplay, vdisplay);
2695
2696         return check_src_coords(x << 16, y << 16,
2697                                 hdisplay << 16, vdisplay << 16, fb);
2698 }
2699 EXPORT_SYMBOL(drm_crtc_check_viewport);
2700
2701 /**
2702  * drm_mode_setcrtc - set CRTC configuration
2703  * @dev: drm device for the ioctl
2704  * @data: data pointer for the ioctl
2705  * @file_priv: drm file for the ioctl call
2706  *
2707  * Build a new CRTC configuration based on user request.
2708  *
2709  * Called by the user via ioctl.
2710  *
2711  * Returns:
2712  * Zero on success, negative errno on failure.
2713  */
2714 int drm_mode_setcrtc(struct drm_device *dev, void *data,
2715                      struct drm_file *file_priv)
2716 {
2717         struct drm_mode_config *config = &dev->mode_config;
2718         struct drm_mode_crtc *crtc_req = data;
2719         struct drm_crtc *crtc;
2720         struct drm_connector **connector_set = NULL, *connector;
2721         struct drm_framebuffer *fb = NULL;
2722         struct drm_display_mode *mode = NULL;
2723         struct drm_mode_set set;
2724         uint32_t __user *set_connectors_ptr;
2725         int ret;
2726         int i;
2727
2728         if (!drm_core_check_feature(dev, DRIVER_MODESET))
2729                 return -EINVAL;
2730
2731         /*
2732          * Universal plane src offsets are only 16.16, prevent havoc for
2733          * drivers using universal plane code internally.
2734          */
2735         if (crtc_req->x & 0xffff0000 || crtc_req->y & 0xffff0000)
2736                 return -ERANGE;
2737
2738         drm_modeset_lock_all(dev);
2739         crtc = drm_crtc_find(dev, crtc_req->crtc_id);
2740         if (!crtc) {
2741                 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", crtc_req->crtc_id);
2742                 ret = -ENOENT;
2743                 goto out;
2744         }
2745         DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name);
2746
2747         if (crtc_req->mode_valid) {
2748                 /* If we have a mode we need a framebuffer. */
2749                 /* If we pass -1, set the mode with the currently bound fb */
2750                 if (crtc_req->fb_id == -1) {
2751                         if (!crtc->primary->fb) {
2752                                 DRM_DEBUG_KMS("CRTC doesn't have current FB\n");
2753                                 ret = -EINVAL;
2754                                 goto out;
2755                         }
2756                         fb = crtc->primary->fb;
2757                         /* Make refcounting symmetric with the lookup path. */
2758                         drm_framebuffer_reference(fb);
2759                 } else {
2760                         fb = drm_framebuffer_lookup(dev, crtc_req->fb_id);
2761                         if (!fb) {
2762                                 DRM_DEBUG_KMS("Unknown FB ID%d\n",
2763                                                 crtc_req->fb_id);
2764                                 ret = -ENOENT;
2765                                 goto out;
2766                         }
2767                 }
2768
2769                 mode = drm_mode_create(dev);
2770                 if (!mode) {
2771                         ret = -ENOMEM;
2772                         goto out;
2773                 }
2774
2775                 ret = drm_mode_convert_umode(mode, &crtc_req->mode);
2776                 if (ret) {
2777                         DRM_DEBUG_KMS("Invalid mode\n");
2778                         goto out;
2779                 }
2780
2781                 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
2782
2783                 /*
2784                  * Check whether the primary plane supports the fb pixel format.
2785                  * Drivers not implementing the universal planes API use a
2786                  * default formats list provided by the DRM core which doesn't
2787                  * match real hardware capabilities. Skip the check in that
2788                  * case.
2789                  */
2790                 if (!crtc->primary->format_default) {
2791                         ret = drm_plane_check_pixel_format(crtc->primary,
2792                                                            fb->pixel_format);
2793                         if (ret) {
2794                                 DRM_DEBUG_KMS("Invalid pixel format %s\n",
2795                                         drm_get_format_name(fb->pixel_format));
2796                                 goto out;
2797                         }
2798                 }
2799
2800                 ret = drm_crtc_check_viewport(crtc, crtc_req->x, crtc_req->y,
2801                                               mode, fb);
2802                 if (ret)
2803                         goto out;
2804
2805         }
2806
2807         if (crtc_req->count_connectors == 0 && mode) {
2808                 DRM_DEBUG_KMS("Count connectors is 0 but mode set\n");
2809                 ret = -EINVAL;
2810                 goto out;
2811         }
2812
2813         if (crtc_req->count_connectors > 0 && (!mode || !fb)) {
2814                 DRM_DEBUG_KMS("Count connectors is %d but no mode or fb set\n",
2815                           crtc_req->count_connectors);
2816                 ret = -EINVAL;
2817                 goto out;
2818         }
2819
2820         if (crtc_req->count_connectors > 0) {
2821                 u32 out_id;
2822
2823                 /* Avoid unbounded kernel memory allocation */
2824                 if (crtc_req->count_connectors > config->num_connector) {
2825                         ret = -EINVAL;
2826                         goto out;
2827                 }
2828
2829                 connector_set = kmalloc_array(crtc_req->count_connectors,
2830                                               sizeof(struct drm_connector *),
2831                                               GFP_KERNEL);
2832                 if (!connector_set) {
2833                         ret = -ENOMEM;
2834                         goto out;
2835                 }
2836
2837                 for (i = 0; i < crtc_req->count_connectors; i++) {
2838                         set_connectors_ptr = (uint32_t __user *)(unsigned long)crtc_req->set_connectors_ptr;
2839                         if (get_user(out_id, &set_connectors_ptr[i])) {
2840                                 ret = -EFAULT;
2841                                 goto out;
2842                         }
2843
2844                         connector = drm_connector_find(dev, out_id);
2845                         if (!connector) {
2846                                 DRM_DEBUG_KMS("Connector id %d unknown\n",
2847                                                 out_id);
2848                                 ret = -ENOENT;
2849                                 goto out;
2850                         }
2851                         DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
2852                                         connector->base.id,
2853                                         connector->name);
2854
2855                         connector_set[i] = connector;
2856                 }
2857         }
2858
2859         set.crtc = crtc;
2860         set.x = crtc_req->x;
2861         set.y = crtc_req->y;
2862         set.mode = mode;
2863         set.connectors = connector_set;
2864         set.num_connectors = crtc_req->count_connectors;
2865         set.fb = fb;
2866         ret = drm_mode_set_config_internal(&set);
2867
2868 out:
2869         if (fb)
2870                 drm_framebuffer_unreference(fb);
2871
2872         kfree(connector_set);
2873         drm_mode_destroy(dev, mode);
2874         drm_modeset_unlock_all(dev);
2875         return ret;
2876 }
2877
2878 /**
2879  * drm_mode_cursor_universal - translate legacy cursor ioctl call into a
2880  *     universal plane handler call
2881  * @crtc: crtc to update cursor for
2882  * @req: data pointer for the ioctl
2883  * @file_priv: drm file for the ioctl call
2884  *
2885  * Legacy cursor ioctl's work directly with driver buffer handles.  To
2886  * translate legacy ioctl calls into universal plane handler calls, we need to
2887  * wrap the native buffer handle in a drm_framebuffer.
2888  *
2889  * Note that we assume any handle passed to the legacy ioctls was a 32-bit ARGB
2890  * buffer with a pitch of 4*width; the universal plane interface should be used
2891  * directly in cases where the hardware can support other buffer settings and
2892  * userspace wants to make use of these capabilities.
2893  *
2894  * Returns:
2895  * Zero on success, negative errno on failure.
2896  */
2897 static int drm_mode_cursor_universal(struct drm_crtc *crtc,
2898                                      struct drm_mode_cursor2 *req,
2899                                      struct drm_file *file_priv)
2900 {
2901         struct drm_device *dev = crtc->dev;
2902         struct drm_framebuffer *fb = NULL;
2903         struct drm_mode_fb_cmd2 fbreq = {
2904                 .width = req->width,
2905                 .height = req->height,
2906                 .pixel_format = DRM_FORMAT_ARGB8888,
2907                 .pitches = { req->width * 4 },
2908                 .handles = { req->handle },
2909         };
2910         int32_t crtc_x, crtc_y;
2911         uint32_t crtc_w = 0, crtc_h = 0;
2912         uint32_t src_w = 0, src_h = 0;
2913         int ret = 0;
2914
2915         BUG_ON(!crtc->cursor);
2916         WARN_ON(crtc->cursor->crtc != crtc && crtc->cursor->crtc != NULL);
2917
2918         /*
2919          * Obtain fb we'll be using (either new or existing) and take an extra
2920          * reference to it if fb != null.  setplane will take care of dropping
2921          * the reference if the plane update fails.
2922          */
2923         if (req->flags & DRM_MODE_CURSOR_BO) {
2924                 if (req->handle) {
2925                         fb = internal_framebuffer_create(dev, &fbreq, file_priv);
2926                         if (IS_ERR(fb)) {
2927                                 DRM_DEBUG_KMS("failed to wrap cursor buffer in drm framebuffer\n");
2928                                 return PTR_ERR(fb);
2929                         }
2930                 } else {
2931                         fb = NULL;
2932                 }
2933         } else {
2934                 fb = crtc->cursor->fb;
2935                 if (fb)
2936                         drm_framebuffer_reference(fb);
2937         }
2938
2939         if (req->flags & DRM_MODE_CURSOR_MOVE) {
2940                 crtc_x = req->x;
2941                 crtc_y = req->y;
2942         } else {
2943                 crtc_x = crtc->cursor_x;
2944                 crtc_y = crtc->cursor_y;
2945         }
2946
2947         if (fb) {
2948                 crtc_w = fb->width;
2949                 crtc_h = fb->height;
2950                 src_w = fb->width << 16;
2951                 src_h = fb->height << 16;
2952         }
2953
2954         /*
2955          * setplane_internal will take care of deref'ing either the old or new
2956          * framebuffer depending on success.
2957          */
2958         ret = __setplane_internal(crtc->cursor, crtc, fb,
2959                                 crtc_x, crtc_y, crtc_w, crtc_h,
2960                                 0, 0, src_w, src_h);
2961
2962         /* Update successful; save new cursor position, if necessary */
2963         if (ret == 0 && req->flags & DRM_MODE_CURSOR_MOVE) {
2964                 crtc->cursor_x = req->x;
2965                 crtc->cursor_y = req->y;
2966         }
2967
2968         return ret;
2969 }
2970
2971 static int drm_mode_cursor_common(struct drm_device *dev,
2972                                   struct drm_mode_cursor2 *req,
2973                                   struct drm_file *file_priv)
2974 {
2975         struct drm_crtc *crtc;
2976         int ret = 0;
2977
2978         if (!drm_core_check_feature(dev, DRIVER_MODESET))
2979                 return -EINVAL;
2980
2981         if (!req->flags || (~DRM_MODE_CURSOR_FLAGS & req->flags))
2982                 return -EINVAL;
2983
2984         crtc = drm_crtc_find(dev, req->crtc_id);
2985         if (!crtc) {
2986                 DRM_DEBUG_KMS("Unknown CRTC ID %d\n", req->crtc_id);
2987                 return -ENOENT;
2988         }
2989
2990         /*
2991          * If this crtc has a universal cursor plane, call that plane's update
2992          * handler rather than using legacy cursor handlers.
2993          */
2994         drm_modeset_lock_crtc(crtc, crtc->cursor);
2995         if (crtc->cursor) {
2996                 ret = drm_mode_cursor_universal(crtc, req, file_priv);
2997                 goto out;
2998         }
2999
3000         if (req->flags & DRM_MODE_CURSOR_BO) {
3001                 if (!crtc->funcs->cursor_set && !crtc->funcs->cursor_set2) {
3002                         ret = -ENXIO;
3003                         goto out;
3004                 }
3005                 /* Turns off the cursor if handle is 0 */
3006                 if (crtc->funcs->cursor_set2)
3007                         ret = crtc->funcs->cursor_set2(crtc, file_priv, req->handle,
3008                                                       req->width, req->height, req->hot_x, req->hot_y);
3009                 else
3010                         ret = crtc->funcs->cursor_set(crtc, file_priv, req->handle,
3011                                                       req->width, req->height);
3012         }
3013
3014         if (req->flags & DRM_MODE_CURSOR_MOVE) {
3015                 if (crtc->funcs->cursor_move) {
3016                         ret = crtc->funcs->cursor_move(crtc, req->x, req->y);
3017                 } else {
3018                         ret = -EFAULT;
3019                         goto out;
3020                 }
3021         }
3022 out:
3023         drm_modeset_unlock_crtc(crtc);
3024
3025         return ret;
3026
3027 }
3028
3029
3030 /**
3031  * drm_mode_cursor_ioctl - set CRTC's cursor configuration
3032  * @dev: drm device for the ioctl
3033  * @data: data pointer for the ioctl
3034  * @file_priv: drm file for the ioctl call
3035  *
3036  * Set the cursor configuration based on user request.
3037  *
3038  * Called by the user via ioctl.
3039  *
3040  * Returns:
3041  * Zero on success, negative errno on failure.
3042  */
3043 int drm_mode_cursor_ioctl(struct drm_device *dev,
3044                           void *data, struct drm_file *file_priv)
3045 {
3046         struct drm_mode_cursor *req = data;
3047         struct drm_mode_cursor2 new_req;
3048
3049         memcpy(&new_req, req, sizeof(struct drm_mode_cursor));
3050         new_req.hot_x = new_req.hot_y = 0;
3051
3052         return drm_mode_cursor_common(dev, &new_req, file_priv);
3053 }
3054
3055 /**
3056  * drm_mode_cursor2_ioctl - set CRTC's cursor configuration
3057  * @dev: drm device for the ioctl
3058  * @data: data pointer for the ioctl
3059  * @file_priv: drm file for the ioctl call
3060  *
3061  * Set the cursor configuration based on user request. This implements the 2nd
3062  * version of the cursor ioctl, which allows userspace to additionally specify
3063  * the hotspot of the pointer.
3064  *
3065  * Called by the user via ioctl.
3066  *
3067  * Returns:
3068  * Zero on success, negative errno on failure.
3069  */
3070 int drm_mode_cursor2_ioctl(struct drm_device *dev,
3071                            void *data, struct drm_file *file_priv)
3072 {
3073         struct drm_mode_cursor2 *req = data;
3074
3075         return drm_mode_cursor_common(dev, req, file_priv);
3076 }
3077
3078 /**
3079  * drm_mode_legacy_fb_format - compute drm fourcc code from legacy description
3080  * @bpp: bits per pixels
3081  * @depth: bit depth per pixel
3082  *
3083  * Computes a drm fourcc pixel format code for the given @bpp/@depth values.
3084  * Useful in fbdev emulation code, since that deals in those values.
3085  */
3086 uint32_t drm_mode_legacy_fb_format(uint32_t bpp, uint32_t depth)
3087 {
3088         uint32_t fmt;
3089
3090         switch (bpp) {
3091         case 8:
3092                 fmt = DRM_FORMAT_C8;
3093                 break;
3094         case 16:
3095                 if (depth == 15)
3096                         fmt = DRM_FORMAT_XRGB1555;
3097                 else
3098                         fmt = DRM_FORMAT_RGB565;
3099                 break;
3100         case 24:
3101                 fmt = DRM_FORMAT_RGB888;
3102                 break;
3103         case 32:
3104                 if (depth == 24)
3105                         fmt = DRM_FORMAT_XRGB8888;
3106                 else if (depth == 30)
3107                         fmt = DRM_FORMAT_XRGB2101010;
3108                 else
3109                         fmt = DRM_FORMAT_ARGB8888;
3110                 break;
3111         default:
3112                 DRM_ERROR("bad bpp, assuming x8r8g8b8 pixel format\n");
3113                 fmt = DRM_FORMAT_XRGB8888;
3114                 break;
3115         }
3116
3117         return fmt;
3118 }
3119 EXPORT_SYMBOL(drm_mode_legacy_fb_format);
3120
3121 /**
3122  * drm_mode_addfb - add an FB to the graphics configuration
3123  * @dev: drm device for the ioctl
3124  * @data: data pointer for the ioctl
3125  * @file_priv: drm file for the ioctl call
3126  *
3127  * Add a new FB to the specified CRTC, given a user request. This is the
3128  * original addfb ioctl which only supported RGB formats.
3129  *
3130  * Called by the user via ioctl.
3131  *
3132  * Returns:
3133  * Zero on success, negative errno on failure.
3134  */
3135 int drm_mode_addfb(struct drm_device *dev,
3136                    void *data, struct drm_file *file_priv)
3137 {
3138         struct drm_mode_fb_cmd *or = data;
3139         struct drm_mode_fb_cmd2 r = {};
3140         int ret;
3141
3142         /* convert to new format and call new ioctl */
3143         r.fb_id = or->fb_id;
3144         r.width = or->width;
3145         r.height = or->height;
3146         r.pitches[0] = or->pitch;
3147         r.pixel_format = drm_mode_legacy_fb_format(or->bpp, or->depth);
3148         r.handles[0] = or->handle;
3149
3150         ret = drm_mode_addfb2(dev, &r, file_priv);
3151         if (ret)
3152                 return ret;
3153
3154         or->fb_id = r.fb_id;
3155
3156         return 0;
3157 }
3158
3159 static int format_check(const struct drm_mode_fb_cmd2 *r)
3160 {
3161         uint32_t format = r->pixel_format & ~DRM_FORMAT_BIG_ENDIAN;
3162
3163         switch (format) {
3164         case DRM_FORMAT_C8:
3165         case DRM_FORMAT_RGB332:
3166         case DRM_FORMAT_BGR233:
3167         case DRM_FORMAT_XRGB4444:
3168         case DRM_FORMAT_XBGR4444:
3169         case DRM_FORMAT_RGBX4444:
3170         case DRM_FORMAT_BGRX4444:
3171         case DRM_FORMAT_ARGB4444:
3172         case DRM_FORMAT_ABGR4444:
3173         case DRM_FORMAT_RGBA4444:
3174         case DRM_FORMAT_BGRA4444:
3175         case DRM_FORMAT_XRGB1555:
3176         case DRM_FORMAT_XBGR1555:
3177         case DRM_FORMAT_RGBX5551:
3178         case DRM_FORMAT_BGRX5551:
3179         case DRM_FORMAT_ARGB1555:
3180         case DRM_FORMAT_ABGR1555:
3181         case DRM_FORMAT_RGBA5551:
3182         case DRM_FORMAT_BGRA5551:
3183         case DRM_FORMAT_RGB565:
3184         case DRM_FORMAT_BGR565:
3185         case DRM_FORMAT_RGB888:
3186         case DRM_FORMAT_BGR888:
3187         case DRM_FORMAT_XRGB8888:
3188         case DRM_FORMAT_XBGR8888:
3189         case DRM_FORMAT_RGBX8888:
3190         case DRM_FORMAT_BGRX8888:
3191         case DRM_FORMAT_ARGB8888:
3192         case DRM_FORMAT_ABGR8888:
3193         case DRM_FORMAT_RGBA8888:
3194         case DRM_FORMAT_BGRA8888:
3195         case DRM_FORMAT_XRGB2101010:
3196         case DRM_FORMAT_XBGR2101010:
3197         case DRM_FORMAT_RGBX1010102:
3198         case DRM_FORMAT_BGRX1010102:
3199         case DRM_FORMAT_ARGB2101010:
3200         case DRM_FORMAT_ABGR2101010:
3201         case DRM_FORMAT_RGBA1010102:
3202         case DRM_FORMAT_BGRA1010102:
3203         case DRM_FORMAT_YUYV:
3204         case DRM_FORMAT_YVYU:
3205         case DRM_FORMAT_UYVY:
3206         case DRM_FORMAT_VYUY:
3207         case DRM_FORMAT_AYUV:
3208         case DRM_FORMAT_NV12:
3209         case DRM_FORMAT_NV21:
3210         case DRM_FORMAT_NV16:
3211         case DRM_FORMAT_NV61:
3212         case DRM_FORMAT_NV24:
3213         case DRM_FORMAT_NV42:
3214         case DRM_FORMAT_YUV410:
3215         case DRM_FORMAT_YVU410:
3216         case DRM_FORMAT_YUV411:
3217         case DRM_FORMAT_YVU411:
3218         case DRM_FORMAT_YUV420:
3219         case DRM_FORMAT_YVU420:
3220         case DRM_FORMAT_YUV422:
3221         case DRM_FORMAT_YVU422:
3222         case DRM_FORMAT_YUV444:
3223         case DRM_FORMAT_YVU444:
3224                 return 0;
3225         default:
3226                 DRM_DEBUG_KMS("invalid pixel format %s\n",
3227                               drm_get_format_name(r->pixel_format));
3228                 return -EINVAL;
3229         }
3230 }
3231
3232 static int framebuffer_check(const struct drm_mode_fb_cmd2 *r)
3233 {
3234         int ret, hsub, vsub, num_planes, i;
3235
3236         ret = format_check(r);
3237         if (ret) {
3238                 DRM_DEBUG_KMS("bad framebuffer format %s\n",
3239                               drm_get_format_name(r->pixel_format));
3240                 return ret;
3241         }
3242
3243         hsub = drm_format_horz_chroma_subsampling(r->pixel_format);
3244         vsub = drm_format_vert_chroma_subsampling(r->pixel_format);
3245         num_planes = drm_format_num_planes(r->pixel_format);
3246
3247         if (r->width == 0 || r->width % hsub) {
3248                 DRM_DEBUG_KMS("bad framebuffer width %u\n", r->width);
3249                 return -EINVAL;
3250         }
3251
3252         if (r->height == 0 || r->height % vsub) {
3253                 DRM_DEBUG_KMS("bad framebuffer height %u\n", r->height);
3254                 return -EINVAL;
3255         }
3256
3257         for (i = 0; i < num_planes; i++) {
3258                 unsigned int width = r->width / (i != 0 ? hsub : 1);
3259                 unsigned int height = r->height / (i != 0 ? vsub : 1);
3260                 unsigned int cpp = drm_format_plane_cpp(r->pixel_format, i);
3261
3262                 if (!r->handles[i]) {
3263                         DRM_DEBUG_KMS("no buffer object handle for plane %d\n", i);
3264                         return -EINVAL;
3265                 }
3266
3267                 if ((uint64_t) width * cpp > UINT_MAX)
3268                         return -ERANGE;
3269
3270                 if ((uint64_t) height * r->pitches[i] + r->offsets[i] > UINT_MAX)
3271                         return -ERANGE;
3272
3273                 if (r->pitches[i] < width * cpp) {
3274                         DRM_DEBUG_KMS("bad pitch %u for plane %d\n", r->pitches[i], i);
3275                         return -EINVAL;
3276                 }
3277
3278                 if (r->modifier[i] && !(r->flags & DRM_MODE_FB_MODIFIERS)) {
3279                         DRM_DEBUG_KMS("bad fb modifier %llu for plane %d\n",
3280                                       r->modifier[i], i);
3281                         return -EINVAL;
3282                 }
3283
3284                 /* modifier specific checks: */
3285                 switch (r->modifier[i]) {
3286                 case DRM_FORMAT_MOD_SAMSUNG_64_32_TILE:
3287                         /* NOTE: the pitch restriction may be lifted later if it turns
3288                          * out that no hw has this restriction:
3289                          */
3290                         if (r->pixel_format != DRM_FORMAT_NV12 ||
3291                                         width % 128 || height % 32 ||
3292                                         r->pitches[i] % 128) {
3293                                 DRM_DEBUG_KMS("bad modifier data for plane %d\n", i);
3294                                 return -EINVAL;
3295                         }
3296                         break;
3297
3298                 default:
3299                         break;
3300                 }
3301         }
3302
3303         for (i = num_planes; i < 4; i++) {
3304                 if (r->modifier[i]) {
3305                         DRM_DEBUG_KMS("non-zero modifier for unused plane %d\n", i);
3306                         return -EINVAL;
3307                 }
3308
3309                 /* Pre-FB_MODIFIERS userspace didn't clear the structs properly. */
3310                 if (!(r->flags & DRM_MODE_FB_MODIFIERS))
3311                         continue;
3312
3313                 if (r->handles[i]) {
3314                         DRM_DEBUG_KMS("buffer object handle for unused plane %d\n", i);
3315                         return -EINVAL;
3316                 }
3317
3318                 if (r->pitches[i]) {
3319                         DRM_DEBUG_KMS("non-zero pitch for unused plane %d\n", i);
3320                         return -EINVAL;
3321                 }
3322
3323                 if (r->offsets[i]) {
3324                         DRM_DEBUG_KMS("non-zero offset for unused plane %d\n", i);
3325                         return -EINVAL;
3326                 }
3327         }
3328
3329         return 0;
3330 }
3331
3332 static struct drm_framebuffer *
3333 internal_framebuffer_create(struct drm_device *dev,
3334                             const struct drm_mode_fb_cmd2 *r,
3335                             struct drm_file *file_priv)
3336 {
3337         struct drm_mode_config *config = &dev->mode_config;
3338         struct drm_framebuffer *fb;
3339         int ret;
3340
3341         if (r->flags & ~(DRM_MODE_FB_INTERLACED | DRM_MODE_FB_MODIFIERS)) {
3342                 DRM_DEBUG_KMS("bad framebuffer flags 0x%08x\n", r->flags);
3343                 return ERR_PTR(-EINVAL);
3344         }
3345
3346         if ((config->min_width > r->width) || (r->width > config->max_width)) {
3347                 DRM_DEBUG_KMS("bad framebuffer width %d, should be >= %d && <= %d\n",
3348                           r->width, config->min_width, config->max_width);
3349                 return ERR_PTR(-EINVAL);
3350         }
3351         if ((config->min_height > r->height) || (r->height > config->max_height)) {
3352                 DRM_DEBUG_KMS("bad framebuffer height %d, should be >= %d && <= %d\n",
3353                           r->height, config->min_height, config->max_height);
3354                 return ERR_PTR(-EINVAL);
3355         }
3356
3357         if (r->flags & DRM_MODE_FB_MODIFIERS &&
3358             !dev->mode_config.allow_fb_modifiers) {
3359                 DRM_DEBUG_KMS("driver does not support fb modifiers\n");
3360                 return ERR_PTR(-EINVAL);
3361         }
3362
3363         ret = framebuffer_check(r);
3364         if (ret)
3365                 return ERR_PTR(ret);
3366
3367         fb = dev->mode_config.funcs->fb_create(dev, file_priv, r);
3368         if (IS_ERR(fb)) {
3369                 DRM_DEBUG_KMS("could not create framebuffer\n");
3370                 return fb;
3371         }
3372
3373         return fb;
3374 }
3375
3376 /**
3377  * drm_mode_addfb2 - add an FB to the graphics configuration
3378  * @dev: drm device for the ioctl
3379  * @data: data pointer for the ioctl
3380  * @file_priv: drm file for the ioctl call
3381  *
3382  * Add a new FB to the specified CRTC, given a user request with format. This is
3383  * the 2nd version of the addfb ioctl, which supports multi-planar framebuffers
3384  * and uses fourcc codes as pixel format specifiers.
3385  *
3386  * Called by the user via ioctl.
3387  *
3388  * Returns:
3389  * Zero on success, negative errno on failure.
3390  */
3391 int drm_mode_addfb2(struct drm_device *dev,
3392                     void *data, struct drm_file *file_priv)
3393 {
3394         struct drm_mode_fb_cmd2 *r = data;
3395         struct drm_framebuffer *fb;
3396
3397         if (!drm_core_check_feature(dev, DRIVER_MODESET))
3398                 return -EINVAL;
3399
3400         fb = internal_framebuffer_create(dev, r, file_priv);
3401         if (IS_ERR(fb))
3402                 return PTR_ERR(fb);
3403
3404         /* Transfer ownership to the filp for reaping on close */
3405
3406         DRM_DEBUG_KMS("[FB:%d]\n", fb->base.id);
3407         mutex_lock(&file_priv->fbs_lock);
3408         r->fb_id = fb->base.id;
3409         list_add(&fb->filp_head, &file_priv->fbs);
3410         mutex_unlock(&file_priv->fbs_lock);
3411
3412         return 0;
3413 }
3414
3415 /**
3416  * drm_mode_rmfb - remove an FB from the configuration
3417  * @dev: drm device for the ioctl
3418  * @data: data pointer for the ioctl
3419  * @file_priv: drm file for the ioctl call
3420  *
3421  * Remove the FB specified by the user.
3422  *
3423  * Called by the user via ioctl.
3424  *
3425  * Returns:
3426  * Zero on success, negative errno on failure.
3427  */
3428 int drm_mode_rmfb(struct drm_device *dev,
3429                    void *data, struct drm_file *file_priv)
3430 {
3431         struct drm_framebuffer *fb = NULL;
3432         struct drm_framebuffer *fbl = NULL;
3433         uint32_t *id = data;
3434         int found = 0;
3435
3436         if (!drm_core_check_feature(dev, DRIVER_MODESET))
3437                 return -EINVAL;
3438
3439         mutex_lock(&file_priv->fbs_lock);
3440         mutex_lock(&dev->mode_config.fb_lock);
3441         fb = __drm_framebuffer_lookup(dev, *id);
3442         if (!fb)
3443                 goto fail_lookup;
3444
3445         list_for_each_entry(fbl, &file_priv->fbs, filp_head)
3446                 if (fb == fbl)
3447                         found = 1;
3448         if (!found)
3449                 goto fail_lookup;
3450
3451         list_del_init(&fb->filp_head);
3452         mutex_unlock(&dev->mode_config.fb_lock);
3453         mutex_unlock(&file_priv->fbs_lock);
3454
3455         drm_framebuffer_unreference(fb);
3456
3457         return 0;
3458
3459 fail_lookup:
3460         mutex_unlock(&dev->mode_config.fb_lock);
3461         mutex_unlock(&file_priv->fbs_lock);
3462
3463         return -ENOENT;
3464 }
3465
3466 /**
3467  * drm_mode_getfb - get FB info
3468  * @dev: drm device for the ioctl
3469  * @data: data pointer for the ioctl
3470  * @file_priv: drm file for the ioctl call
3471  *
3472  * Lookup the FB given its ID and return info about it.
3473  *
3474  * Called by the user via ioctl.
3475  *
3476  * Returns:
3477  * Zero on success, negative errno on failure.
3478  */
3479 int drm_mode_getfb(struct drm_device *dev,
3480                    void *data, struct drm_file *file_priv)
3481 {
3482         struct drm_mode_fb_cmd *r = data;
3483         struct drm_framebuffer *fb;
3484         int ret;
3485
3486         if (!drm_core_check_feature(dev, DRIVER_MODESET))
3487                 return -EINVAL;
3488
3489         fb = drm_framebuffer_lookup(dev, r->fb_id);
3490         if (!fb)
3491                 return -ENOENT;
3492
3493         r->height = fb->height;
3494         r->width = fb->width;
3495         r->depth = fb->depth;
3496         r->bpp = fb->bits_per_pixel;
3497         r->pitch = fb->pitches[0];
3498         if (fb->funcs->create_handle) {
3499                 if (file_priv->is_master || capable(CAP_SYS_ADMIN) ||
3500                     drm_is_control_client(file_priv)) {
3501                         ret = fb->funcs->create_handle(fb, file_priv,
3502                                                        &r->handle);
3503                 } else {
3504                         /* GET_FB() is an unprivileged ioctl so we must not
3505                          * return a buffer-handle to non-master processes! For
3506                          * backwards-compatibility reasons, we cannot make
3507                          * GET_FB() privileged, so just return an invalid handle
3508                          * for non-masters. */
3509                         r->handle = 0;
3510                         ret = 0;
3511                 }
3512         } else {
3513                 ret = -ENODEV;
3514         }
3515
3516         drm_framebuffer_unreference(fb);
3517
3518         return ret;
3519 }
3520
3521 /**
3522  * drm_mode_dirtyfb_ioctl - flush frontbuffer rendering on an FB
3523  * @dev: drm device for the ioctl
3524  * @data: data pointer for the ioctl
3525  * @file_priv: drm file for the ioctl call
3526  *
3527  * Lookup the FB and flush out the damaged area supplied by userspace as a clip
3528  * rectangle list. Generic userspace which does frontbuffer rendering must call
3529  * this ioctl to flush out the changes on manual-update display outputs, e.g.
3530  * usb display-link, mipi manual update panels or edp panel self refresh modes.
3531  *
3532  * Modesetting drivers which always update the frontbuffer do not need to
3533  * implement the corresponding ->dirty framebuffer callback.
3534  *
3535  * Called by the user via ioctl.
3536  *
3537  * Returns:
3538  * Zero on success, negative errno on failure.
3539  */
3540 int drm_mode_dirtyfb_ioctl(struct drm_device *dev,
3541                            void *data, struct drm_file *file_priv)
3542 {
3543         struct drm_clip_rect __user *clips_ptr;
3544         struct drm_clip_rect *clips = NULL;
3545         struct drm_mode_fb_dirty_cmd *r = data;
3546         struct drm_framebuffer *fb;
3547         unsigned flags;
3548         int num_clips;
3549         int ret;
3550
3551         if (!drm_core_check_feature(dev, DRIVER_MODESET))
3552                 return -EINVAL;
3553
3554         fb = drm_framebuffer_lookup(dev, r->fb_id);
3555         if (!fb)
3556                 return -ENOENT;
3557
3558         num_clips = r->num_clips;
3559         clips_ptr = (struct drm_clip_rect __user *)(unsigned long)r->clips_ptr;
3560
3561         if (!num_clips != !clips_ptr) {
3562                 ret = -EINVAL;
3563                 goto out_err1;
3564         }
3565
3566         flags = DRM_MODE_FB_DIRTY_FLAGS & r->flags;
3567
3568         /* If userspace annotates copy, clips must come in pairs */
3569         if (flags & DRM_MODE_FB_DIRTY_ANNOTATE_COPY && (num_clips % 2)) {
3570                 ret = -EINVAL;
3571                 goto out_err1;
3572         }
3573
3574         if (num_clips && clips_ptr) {
3575                 if (num_clips < 0 || num_clips > DRM_MODE_FB_DIRTY_MAX_CLIPS) {
3576                         ret = -EINVAL;
3577                         goto out_err1;
3578                 }
3579                 clips = kcalloc(num_clips, sizeof(*clips), GFP_KERNEL);
3580                 if (!clips) {
3581                         ret = -ENOMEM;
3582                         goto out_err1;
3583                 }
3584
3585                 ret = copy_from_user(clips, clips_ptr,
3586                                      num_clips * sizeof(*clips));
3587                 if (ret) {
3588                         ret = -EFAULT;
3589                         goto out_err2;
3590                 }
3591         }
3592
3593         if (fb->funcs->dirty) {
3594                 ret = fb->funcs->dirty(fb, file_priv, flags, r->color,
3595                                        clips, num_clips);
3596         } else {
3597                 ret = -ENOSYS;
3598         }
3599
3600 out_err2:
3601         kfree(clips);
3602 out_err1:
3603         drm_framebuffer_unreference(fb);
3604
3605         return ret;
3606 }
3607
3608
3609 /**
3610  * drm_fb_release - remove and free the FBs on this file
3611  * @priv: drm file for the ioctl
3612  *
3613  * Destroy all the FBs associated with @filp.
3614  *
3615  * Called by the user via ioctl.
3616  *
3617  * Returns:
3618  * Zero on success, negative errno on failure.
3619  */
3620 void drm_fb_release(struct drm_file *priv)
3621 {
3622         struct drm_framebuffer *fb, *tfb;
3623
3624         /*
3625          * When the file gets released that means no one else can access the fb
3626          * list any more, so no need to grab fpriv->fbs_lock. And we need to
3627          * avoid upsetting lockdep since the universal cursor code adds a
3628          * framebuffer while holding mutex locks.
3629          *
3630          * Note that a real deadlock between fpriv->fbs_lock and the modeset
3631          * locks is impossible here since no one else but this function can get
3632          * at it any more.
3633          */
3634         list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) {
3635                 list_del_init(&fb->filp_head);
3636
3637                 /* This drops the fpriv->fbs reference. */
3638                 drm_framebuffer_unreference(fb);
3639         }
3640 }
3641
3642 /**
3643  * drm_property_create - create a new property type
3644  * @dev: drm device
3645  * @flags: flags specifying the property type
3646  * @name: name of the property
3647  * @num_values: number of pre-defined values
3648  *
3649  * This creates a new generic drm property which can then be attached to a drm
3650  * object with drm_object_attach_property. The returned property object must be
3651  * freed with drm_property_destroy.
3652  *
3653  * Note that the DRM core keeps a per-device list of properties and that, if
3654  * drm_mode_config_cleanup() is called, it will destroy all properties created
3655  * by the driver.
3656  *
3657  * Returns:
3658  * A pointer to the newly created property on success, NULL on failure.
3659  */
3660 struct drm_property *drm_property_create(struct drm_device *dev, int flags,
3661                                          const char *name, int num_values)
3662 {
3663         struct drm_property *property = NULL;
3664         int ret;
3665
3666         property = kzalloc(sizeof(struct drm_property), GFP_KERNEL);
3667         if (!property)
3668                 return NULL;
3669
3670         property->dev = dev;
3671
3672         if (num_values) {
3673                 property->values = kcalloc(num_values, sizeof(uint64_t),
3674                                            GFP_KERNEL);
3675                 if (!property->values)
3676                         goto fail;
3677         }
3678
3679         ret = drm_mode_object_get(dev, &property->base, DRM_MODE_OBJECT_PROPERTY);
3680         if (ret)
3681                 goto fail;
3682
3683         property->flags = flags;
3684         property->num_values = num_values;
3685         INIT_LIST_HEAD(&property->enum_list);
3686
3687         if (name) {
3688                 strncpy(property->name, name, DRM_PROP_NAME_LEN);
3689                 property->name[DRM_PROP_NAME_LEN-1] = '\0';
3690         }
3691
3692         list_add_tail(&property->head, &dev->mode_config.property_list);
3693
3694         WARN_ON(!drm_property_type_valid(property));
3695
3696         return property;
3697 fail:
3698         kfree(property->values);
3699         kfree(property);
3700         return NULL;
3701 }
3702 EXPORT_SYMBOL(drm_property_create);
3703
3704 /**
3705  * drm_property_create_enum - create a new enumeration property type
3706  * @dev: drm device
3707  * @flags: flags specifying the property type
3708  * @name: name of the property
3709  * @props: enumeration lists with property values
3710  * @num_values: number of pre-defined values
3711  *
3712  * This creates a new generic drm property which can then be attached to a drm
3713  * object with drm_object_attach_property. The returned property object must be
3714  * freed with drm_property_destroy.
3715  *
3716  * Userspace is only allowed to set one of the predefined values for enumeration
3717  * properties.
3718  *
3719  * Returns:
3720  * A pointer to the newly created property on success, NULL on failure.
3721  */
3722 struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
3723                                          const char *name,
3724                                          const struct drm_prop_enum_list *props,
3725                                          int num_values)
3726 {
3727         struct drm_property *property;
3728         int i, ret;
3729
3730         flags |= DRM_MODE_PROP_ENUM;
3731
3732         property = drm_property_create(dev, flags, name, num_values);
3733         if (!property)
3734                 return NULL;
3735
3736         for (i = 0; i < num_values; i++) {
3737                 ret = drm_property_add_enum(property, i,
3738                                       props[i].type,
3739                                       props[i].name);
3740                 if (ret) {
3741                         drm_property_destroy(dev, property);
3742                         return NULL;
3743                 }
3744         }
3745
3746         return property;
3747 }
3748 EXPORT_SYMBOL(drm_property_create_enum);
3749
3750 /**
3751  * drm_property_create_bitmask - create a new bitmask property type
3752  * @dev: drm device
3753  * @flags: flags specifying the property type
3754  * @name: name of the property
3755  * @props: enumeration lists with property bitflags
3756  * @num_props: size of the @props array
3757  * @supported_bits: bitmask of all supported enumeration values
3758  *
3759  * This creates a new bitmask drm property which can then be attached to a drm
3760  * object with drm_object_attach_property. The returned property object must be
3761  * freed with drm_property_destroy.
3762  *
3763  * Compared to plain enumeration properties userspace is allowed to set any
3764  * or'ed together combination of the predefined property bitflag values
3765  *
3766  * Returns:
3767  * A pointer to the newly created property on success, NULL on failure.
3768  */
3769 struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
3770                                          int flags, const char *name,
3771                                          const struct drm_prop_enum_list *props,
3772                                          int num_props,
3773                                          uint64_t supported_bits)
3774 {
3775         struct drm_property *property;
3776         int i, ret, index = 0;
3777         int num_values = hweight64(supported_bits);
3778
3779         flags |= DRM_MODE_PROP_BITMASK;
3780
3781         property = drm_property_create(dev, flags, name, num_values);
3782         if (!property)
3783                 return NULL;
3784         for (i = 0; i < num_props; i++) {
3785                 if (!(supported_bits & (1ULL << props[i].type)))
3786                         continue;
3787
3788                 if (WARN_ON(index >= num_values)) {
3789                         drm_property_destroy(dev, property);
3790                         return NULL;
3791                 }
3792
3793                 ret = drm_property_add_enum(property, index++,
3794                                       props[i].type,
3795                                       props[i].name);
3796                 if (ret) {
3797                         drm_property_destroy(dev, property);
3798                         return NULL;
3799                 }
3800         }
3801
3802         return property;
3803 }
3804 EXPORT_SYMBOL(drm_property_create_bitmask);
3805
3806 static struct drm_property *property_create_range(struct drm_device *dev,
3807                                          int flags, const char *name,
3808                                          uint64_t min, uint64_t max)
3809 {
3810         struct drm_property *property;
3811
3812         property = drm_property_create(dev, flags, name, 2);
3813         if (!property)
3814                 return NULL;
3815
3816         property->values[0] = min;
3817         property->values[1] = max;
3818
3819         return property;
3820 }
3821
3822 /**
3823  * drm_property_create_range - create a new unsigned ranged property type
3824  * @dev: drm device
3825  * @flags: flags specifying the property type
3826  * @name: name of the property
3827  * @min: minimum value of the property
3828  * @max: maximum value of the property
3829  *
3830  * This creates a new generic drm property which can then be attached to a drm
3831  * object with drm_object_attach_property. The returned property object must be
3832  * freed with drm_property_destroy.
3833  *
3834  * Userspace is allowed to set any unsigned integer value in the (min, max)
3835  * range inclusive.
3836  *
3837  * Returns:
3838  * A pointer to the newly created property on success, NULL on failure.
3839  */
3840 struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
3841                                          const char *name,
3842                                          uint64_t min, uint64_t max)
3843 {
3844         return property_create_range(dev, DRM_MODE_PROP_RANGE | flags,
3845                         name, min, max);
3846 }
3847 EXPORT_SYMBOL(drm_property_create_range);
3848
3849 /**
3850  * drm_property_create_signed_range - create a new signed ranged property type
3851  * @dev: drm device
3852  * @flags: flags specifying the property type
3853  * @name: name of the property
3854  * @min: minimum value of the property
3855  * @max: maximum value of the property
3856  *
3857  * This creates a new generic drm property which can then be attached to a drm
3858  * object with drm_object_attach_property. The returned property object must be
3859  * freed with drm_property_destroy.
3860  *
3861  * Userspace is allowed to set any signed integer value in the (min, max)
3862  * range inclusive.
3863  *
3864  * Returns:
3865  * A pointer to the newly created property on success, NULL on failure.
3866  */
3867 struct drm_property *drm_property_create_signed_range(struct drm_device *dev,
3868                                          int flags, const char *name,
3869                                          int64_t min, int64_t max)
3870 {
3871         return property_create_range(dev, DRM_MODE_PROP_SIGNED_RANGE | flags,
3872                         name, I642U64(min), I642U64(max));
3873 }
3874 EXPORT_SYMBOL(drm_property_create_signed_range);
3875
3876 /**
3877  * drm_property_create_object - create a new object property type
3878  * @dev: drm device
3879  * @flags: flags specifying the property type
3880  * @name: name of the property
3881  * @type: object type from DRM_MODE_OBJECT_* defines
3882  *
3883  * This creates a new generic drm property which can then be attached to a drm
3884  * object with drm_object_attach_property. The returned property object must be
3885  * freed with drm_property_destroy.
3886  *
3887  * Userspace is only allowed to set this to any property value of the given
3888  * @type. Only useful for atomic properties, which is enforced.
3889  *
3890  * Returns:
3891  * A pointer to the newly created property on success, NULL on failure.
3892  */
3893 struct drm_property *drm_property_create_object(struct drm_device *dev,
3894                                          int flags, const char *name, uint32_t type)
3895 {
3896         struct drm_property *property;
3897
3898         flags |= DRM_MODE_PROP_OBJECT;
3899
3900         if (WARN_ON(!(flags & DRM_MODE_PROP_ATOMIC)))
3901                 return NULL;
3902
3903         property = drm_property_create(dev, flags, name, 1);
3904         if (!property)
3905                 return NULL;
3906
3907         property->values[0] = type;
3908
3909         return property;
3910 }
3911 EXPORT_SYMBOL(drm_property_create_object);
3912
3913 /**
3914  * drm_property_create_bool - create a new boolean property type
3915  * @dev: drm device
3916  * @flags: flags specifying the property type
3917  * @name: name of the property
3918  *
3919  * This creates a new generic drm property which can then be attached to a drm
3920  * object with drm_object_attach_property. The returned property object must be
3921  * freed with drm_property_destroy.
3922  *
3923  * This is implemented as a ranged property with only {0, 1} as valid values.
3924  *
3925  * Returns:
3926  * A pointer to the newly created property on success, NULL on failure.
3927  */
3928 struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags,
3929                                          const char *name)
3930 {
3931         return drm_property_create_range(dev, flags, name, 0, 1);
3932 }
3933 EXPORT_SYMBOL(drm_property_create_bool);
3934
3935 /**
3936  * drm_property_add_enum - add a possible value to an enumeration property
3937  * @property: enumeration property to change
3938  * @index: index of the new enumeration
3939  * @value: value of the new enumeration
3940  * @name: symbolic name of the new enumeration
3941  *
3942  * This functions adds enumerations to a property.
3943  *
3944  * It's use is deprecated, drivers should use one of the more specific helpers
3945  * to directly create the property with all enumerations already attached.
3946  *
3947  * Returns:
3948  * Zero on success, error code on failure.
3949  */
3950 int drm_property_add_enum(struct drm_property *property, int index,
3951                           uint64_t value, const char *name)
3952 {
3953         struct drm_property_enum *prop_enum;
3954
3955         if (!(drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
3956                         drm_property_type_is(property, DRM_MODE_PROP_BITMASK)))
3957                 return -EINVAL;
3958
3959         /*
3960          * Bitmask enum properties have the additional constraint of values
3961          * from 0 to 63
3962          */
3963         if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK) &&
3964                         (value > 63))
3965                 return -EINVAL;
3966
3967         if (!list_empty(&property->enum_list)) {
3968                 list_for_each_entry(prop_enum, &property->enum_list, head) {
3969                         if (prop_enum->value == value) {
3970                                 strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
3971                                 prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
3972                                 return 0;
3973                         }
3974                 }
3975         }
3976
3977         prop_enum = kzalloc(sizeof(struct drm_property_enum), GFP_KERNEL);
3978         if (!prop_enum)
3979                 return -ENOMEM;
3980
3981         strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
3982         prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
3983         prop_enum->value = value;
3984
3985         property->values[index] = value;
3986         list_add_tail(&prop_enum->head, &property->enum_list);
3987         return 0;
3988 }
3989 EXPORT_SYMBOL(drm_property_add_enum);
3990
3991 /**
3992  * drm_property_destroy - destroy a drm property
3993  * @dev: drm device
3994  * @property: property to destry
3995  *
3996  * This function frees a property including any attached resources like
3997  * enumeration values.
3998  */
3999 void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
4000 {
4001         struct drm_property_enum *prop_enum, *pt;
4002
4003         list_for_each_entry_safe(prop_enum, pt, &property->enum_list, head) {
4004                 list_del(&prop_enum->head);
4005                 kfree(prop_enum);
4006         }
4007
4008         if (property->num_values)
4009                 kfree(property->values);
4010         drm_mode_object_put(dev, &property->base);
4011         list_del(&property->head);
4012         kfree(property);
4013 }
4014 EXPORT_SYMBOL(drm_property_destroy);
4015
4016 /**
4017  * drm_object_attach_property - attach a property to a modeset object
4018  * @obj: drm modeset object
4019  * @property: property to attach
4020  * @init_val: initial value of the property
4021  *
4022  * This attaches the given property to the modeset object with the given initial
4023  * value. Currently this function cannot fail since the properties are stored in
4024  * a statically sized array.
4025  */
4026 void drm_object_attach_property(struct drm_mode_object *obj,
4027                                 struct drm_property *property,
4028                                 uint64_t init_val)
4029 {
4030         int count = obj->properties->count;
4031
4032         if (count == DRM_OBJECT_MAX_PROPERTY) {
4033                 WARN(1, "Failed to attach object property (type: 0x%x). Please "
4034                         "increase DRM_OBJECT_MAX_PROPERTY by 1 for each time "
4035                         "you see this message on the same object type.\n",
4036                         obj->type);
4037                 return;
4038         }
4039
4040         obj->properties->properties[count] = property;
4041         obj->properties->values[count] = init_val;
4042         obj->properties->count++;
4043         if (property->flags & DRM_MODE_PROP_ATOMIC)
4044                 obj->properties->atomic_count++;
4045 }
4046 EXPORT_SYMBOL(drm_object_attach_property);
4047
4048 /**
4049  * drm_object_property_set_value - set the value of a property
4050  * @obj: drm mode object to set property value for
4051  * @property: property to set
4052  * @val: value the property should be set to
4053  *
4054  * This functions sets a given property on a given object. This function only
4055  * changes the software state of the property, it does not call into the
4056  * driver's ->set_property callback.
4057  *
4058  * Returns:
4059  * Zero on success, error code on failure.
4060  */
4061 int drm_object_property_set_value(struct drm_mode_object *obj,
4062                                   struct drm_property *property, uint64_t val)
4063 {
4064         int i;
4065
4066         for (i = 0; i < obj->properties->count; i++) {
4067                 if (obj->properties->properties[i] == property) {
4068                         obj->properties->values[i] = val;
4069                         return 0;
4070                 }
4071         }
4072
4073         return -EINVAL;
4074 }
4075 EXPORT_SYMBOL(drm_object_property_set_value);
4076
4077 /**
4078  * drm_object_property_get_value - retrieve the value of a property
4079  * @obj: drm mode object to get property value from
4080  * @property: property to retrieve
4081  * @val: storage for the property value
4082  *
4083  * This function retrieves the softare state of the given property for the given
4084  * property. Since there is no driver callback to retrieve the current property
4085  * value this might be out of sync with the hardware, depending upon the driver
4086  * and property.
4087  *
4088  * Returns:
4089  * Zero on success, error code on failure.
4090  */
4091 int drm_object_property_get_value(struct drm_mode_object *obj,
4092                                   struct drm_property *property, uint64_t *val)
4093 {
4094         int i;
4095
4096         /* read-only properties bypass atomic mechanism and still store
4097          * their value in obj->properties->values[].. mostly to avoid
4098          * having to deal w/ EDID and similar props in atomic paths:
4099          */
4100         if (drm_core_check_feature(property->dev, DRIVER_ATOMIC) &&
4101                         !(property->flags & DRM_MODE_PROP_IMMUTABLE))
4102                 return drm_atomic_get_property(obj, property, val);
4103
4104         for (i = 0; i < obj->properties->count; i++) {
4105                 if (obj->properties->properties[i] == property) {
4106                         *val = obj->properties->values[i];
4107                         return 0;
4108                 }
4109         }
4110
4111         return -EINVAL;
4112 }
4113 EXPORT_SYMBOL(drm_object_property_get_value);
4114
4115 /**
4116  * drm_mode_getproperty_ioctl - get the property metadata
4117  * @dev: DRM device
4118  * @data: ioctl data
4119  * @file_priv: DRM file info
4120  *
4121  * This function retrieves the metadata for a given property, like the different
4122  * possible values for an enum property or the limits for a range property.
4123  *
4124  * Blob properties are special
4125  *
4126  * Called by the user via ioctl.
4127  *
4128  * Returns:
4129  * Zero on success, negative errno on failure.
4130  */
4131 int drm_mode_getproperty_ioctl(struct drm_device *dev,
4132                                void *data, struct drm_file *file_priv)
4133 {
4134         struct drm_mode_get_property *out_resp = data;
4135         struct drm_property *property;
4136         int enum_count = 0;
4137         int value_count = 0;
4138         int ret = 0, i;
4139         int copied;
4140         struct drm_property_enum *prop_enum;
4141         struct drm_mode_property_enum __user *enum_ptr;
4142         uint64_t __user *values_ptr;
4143
4144         if (!drm_core_check_feature(dev, DRIVER_MODESET))
4145                 return -EINVAL;
4146
4147         drm_modeset_lock_all(dev);
4148         property = drm_property_find(dev, out_resp->prop_id);
4149         if (!property) {
4150                 ret = -ENOENT;
4151                 goto done;
4152         }
4153
4154         if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
4155                         drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
4156                 list_for_each_entry(prop_enum, &property->enum_list, head)
4157                         enum_count++;
4158         }
4159
4160         value_count = property->num_values;
4161
4162         strncpy(out_resp->name, property->name, DRM_PROP_NAME_LEN);
4163         out_resp->name[DRM_PROP_NAME_LEN-1] = 0;
4164         out_resp->flags = property->flags;
4165
4166         if ((out_resp->count_values >= value_count) && value_count) {
4167                 values_ptr = (uint64_t __user *)(unsigned long)out_resp->values_ptr;
4168                 for (i = 0; i < value_count; i++) {
4169                         if (copy_to_user(values_ptr + i, &property->values[i], sizeof(uint64_t))) {
4170                                 ret = -EFAULT;
4171                                 goto done;
4172                         }
4173                 }
4174         }
4175         out_resp->count_values = value_count;
4176
4177         if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
4178                         drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
4179                 if ((out_resp->count_enum_blobs >= enum_count) && enum_count) {
4180                         copied = 0;
4181                         enum_ptr = (struct drm_mode_property_enum __user *)(unsigned long)out_resp->enum_blob_ptr;
4182                         list_for_each_entry(prop_enum, &property->enum_list, head) {
4183
4184                                 if (copy_to_user(&enum_ptr[copied].value, &prop_enum->value, sizeof(uint64_t))) {
4185                                         ret = -EFAULT;
4186                                         goto done;
4187                                 }
4188
4189                                 if (copy_to_user(&enum_ptr[copied].name,
4190                                                  &prop_enum->name, DRM_PROP_NAME_LEN)) {
4191                                         ret = -EFAULT;
4192                                         goto done;
4193                                 }
4194                                 copied++;
4195                         }
4196                 }
4197                 out_resp->count_enum_blobs = enum_count;
4198         }
4199
4200         /*
4201          * NOTE: The idea seems to have been to use this to read all the blob
4202          * property values. But nothing ever added them to the corresponding
4203          * list, userspace always used the special-purpose get_blob ioctl to
4204          * read the value for a blob property. It also doesn't make a lot of
4205          * sense to return values here when everything else is just metadata for
4206          * the property itself.
4207          */
4208         if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
4209                 out_resp->count_enum_blobs = 0;
4210 done:
4211         drm_modeset_unlock_all(dev);
4212         return ret;
4213 }
4214
4215 /**
4216  * drm_property_create_blob - Create new blob property
4217  *
4218  * Creates a new blob property for a specified DRM device, optionally
4219  * copying data.
4220  *
4221  * @dev: DRM device to create property for
4222  * @length: Length to allocate for blob data
4223  * @data: If specified, copies data into blob
4224  *
4225  * Returns:
4226  * New blob property with a single reference on success, or an ERR_PTR
4227  * value on failure.
4228  */
4229 struct drm_property_blob *
4230 drm_property_create_blob(struct drm_device *dev, size_t length,
4231                          const void *data)
4232 {
4233         struct drm_property_blob *blob;
4234         int ret;
4235
4236         if (!length || length > ULONG_MAX - sizeof(struct drm_property_blob))
4237                 return ERR_PTR(-EINVAL);
4238
4239         blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
4240         if (!blob)
4241                 return ERR_PTR(-ENOMEM);
4242
4243         /* This must be explicitly initialised, so we can safely call list_del
4244          * on it in the removal handler, even if it isn't in a file list. */
4245         INIT_LIST_HEAD(&blob->head_file);
4246         blob->length = length;
4247         blob->dev = dev;
4248
4249         if (data)
4250                 memcpy(blob->data, data, length);
4251
4252         mutex_lock(&dev->mode_config.blob_lock);
4253
4254         ret = drm_mode_object_get(dev, &blob->base, DRM_MODE_OBJECT_BLOB);
4255         if (ret) {
4256                 kfree(blob);
4257                 mutex_unlock(&dev->mode_config.blob_lock);
4258                 return ERR_PTR(-EINVAL);
4259         }
4260
4261         kref_init(&blob->refcount);
4262
4263         list_add_tail(&blob->head_global,
4264                       &dev->mode_config.property_blob_list);
4265
4266         mutex_unlock(&dev->mode_config.blob_lock);
4267
4268         return blob;
4269 }
4270 EXPORT_SYMBOL(drm_property_create_blob);
4271
4272 /**
4273  * drm_property_free_blob - Blob property destructor
4274  *
4275  * Internal free function for blob properties; must not be used directly.
4276  *
4277  * @kref: Reference
4278  */
4279 static void drm_property_free_blob(struct kref *kref)
4280 {
4281         struct drm_property_blob *blob =
4282                 container_of(kref, struct drm_property_blob, refcount);
4283
4284         WARN_ON(!mutex_is_locked(&blob->dev->mode_config.blob_lock));
4285
4286         list_del(&blob->head_global);
4287         list_del(&blob->head_file);
4288         drm_mode_object_put(blob->dev, &blob->base);
4289
4290         kfree(blob);
4291 }
4292
4293 /**
4294  * drm_property_unreference_blob - Unreference a blob property
4295  *
4296  * Drop a reference on a blob property. May free the object.
4297  *
4298  * @blob: Pointer to blob property
4299  */
4300 void drm_property_unreference_blob(struct drm_property_blob *blob)
4301 {
4302         struct drm_device *dev;
4303
4304         if (!blob)
4305                 return;
4306
4307         dev = blob->dev;
4308
4309         DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));
4310
4311         if (kref_put_mutex(&blob->refcount, drm_property_free_blob,
4312                            &dev->mode_config.blob_lock))
4313                 mutex_unlock(&dev->mode_config.blob_lock);
4314         else
4315                 might_lock(&dev->mode_config.blob_lock);
4316 }
4317 EXPORT_SYMBOL(drm_property_unreference_blob);
4318
4319 /**
4320  * drm_property_unreference_blob_locked - Unreference a blob property with blob_lock held
4321  *
4322  * Drop a reference on a blob property. May free the object. This must be
4323  * called with blob_lock held.
4324  *
4325  * @blob: Pointer to blob property
4326  */
4327 static void drm_property_unreference_blob_locked(struct drm_property_blob *blob)
4328 {
4329         if (!blob)
4330                 return;
4331
4332         DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));
4333
4334         kref_put(&blob->refcount, drm_property_free_blob);
4335 }
4336
4337 /**
4338  * drm_property_destroy_user_blobs - destroy all blobs created by this client
4339  * @dev:       DRM device
4340  * @file_priv: destroy all blobs owned by this file handle
4341  */
4342 void drm_property_destroy_user_blobs(struct drm_device *dev,
4343                                      struct drm_file *file_priv)
4344 {
4345         struct drm_property_blob *blob, *bt;
4346
4347         mutex_lock(&dev->mode_config.blob_lock);
4348
4349         list_for_each_entry_safe(blob, bt, &file_priv->blobs, head_file) {
4350                 list_del_init(&blob->head_file);
4351                 drm_property_unreference_blob_locked(blob);
4352         }
4353
4354         mutex_unlock(&dev->mode_config.blob_lock);
4355 }
4356
4357 /**
4358  * drm_property_reference_blob - Take a reference on an existing property
4359  *
4360  * Take a new reference on an existing blob property.
4361  *
4362  * @blob: Pointer to blob property
4363  */
4364 struct drm_property_blob *drm_property_reference_blob(struct drm_property_blob *blob)
4365 {
4366         DRM_DEBUG("%p: blob ID: %d (%d)\n", blob, blob->base.id, atomic_read(&blob->refcount.refcount));
4367         kref_get(&blob->refcount);
4368         return blob;
4369 }
4370 EXPORT_SYMBOL(drm_property_reference_blob);
4371
4372 /*
4373  * Like drm_property_lookup_blob, but does not return an additional reference.
4374  * Must be called with blob_lock held.
4375  */
4376 static struct drm_property_blob *__drm_property_lookup_blob(struct drm_device *dev,
4377                                                             uint32_t id)
4378 {
4379         struct drm_mode_object *obj = NULL;
4380         struct drm_property_blob *blob;
4381
4382         WARN_ON(!mutex_is_locked(&dev->mode_config.blob_lock));
4383
4384         mutex_lock(&dev->mode_config.idr_mutex);
4385         obj = idr_find(&dev->mode_config.crtc_idr, id);
4386         if (!obj || (obj->type != DRM_MODE_OBJECT_BLOB) || (obj->id != id))
4387                 blob = NULL;
4388         else
4389                 blob = obj_to_blob(obj);
4390         mutex_unlock(&dev->mode_config.idr_mutex);
4391
4392         return blob;
4393 }
4394
4395 /**
4396  * drm_property_lookup_blob - look up a blob property and take a reference
4397  * @dev: drm device
4398  * @id: id of the blob property
4399  *
4400  * If successful, this takes an additional reference to the blob property.
4401  * callers need to make sure to eventually unreference the returned property
4402  * again, using @drm_property_unreference_blob.
4403  */
4404 struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev,
4405                                                    uint32_t id)
4406 {
4407         struct drm_property_blob *blob;
4408
4409         mutex_lock(&dev->mode_config.blob_lock);
4410         blob = __drm_property_lookup_blob(dev, id);
4411         if (blob) {
4412                 if (!kref_get_unless_zero(&blob->refcount))
4413                         blob = NULL;
4414         }
4415         mutex_unlock(&dev->mode_config.blob_lock);
4416
4417         return blob;
4418 }
4419 EXPORT_SYMBOL(drm_property_lookup_blob);
4420
4421 /**
4422  * drm_property_replace_global_blob - atomically replace existing blob property
4423  * @dev: drm device
4424  * @replace: location of blob property pointer to be replaced
4425  * @length: length of data for new blob, or 0 for no data
4426  * @data: content for new blob, or NULL for no data
4427  * @obj_holds_id: optional object for property holding blob ID
4428  * @prop_holds_id: optional property holding blob ID
4429  * @return 0 on success or error on failure
4430  *
4431  * This function will atomically replace a global property in the blob list,
4432  * optionally updating a property which holds the ID of that property. It is
4433  * guaranteed to be atomic: no caller will be allowed to see intermediate
4434  * results, and either the entire operation will succeed and clean up the
4435  * previous property, or it will fail and the state will be unchanged.
4436  *
4437  * If length is 0 or data is NULL, no new blob will be created, and the holding
4438  * property, if specified, will be set to 0.
4439  *
4440  * Access to the replace pointer is assumed to be protected by the caller, e.g.
4441  * by holding the relevant modesetting object lock for its parent.
4442  *
4443  * For example, a drm_connector has a 'PATH' property, which contains the ID
4444  * of a blob property with the value of the MST path information. Calling this
4445  * function with replace pointing to the connector's path_blob_ptr, length and
4446  * data set for the new path information, obj_holds_id set to the connector's
4447  * base object, and prop_holds_id set to the path property name, will perform
4448  * a completely atomic update. The access to path_blob_ptr is protected by the
4449  * caller holding a lock on the connector.
4450  */
4451 static int drm_property_replace_global_blob(struct drm_device *dev,
4452                                             struct drm_property_blob **replace,
4453                                             size_t length,
4454                                             const void *data,
4455                                             struct drm_mode_object *obj_holds_id,
4456                                             struct drm_property *prop_holds_id)
4457 {
4458         struct drm_property_blob *new_blob = NULL;
4459         struct drm_property_blob *old_blob = NULL;
4460         int ret;
4461
4462         WARN_ON(replace == NULL);
4463
4464         old_blob = *replace;
4465
4466         if (length && data) {
4467                 new_blob = drm_property_create_blob(dev, length, data);
4468                 if (IS_ERR(new_blob))
4469                         return PTR_ERR(new_blob);
4470         }
4471
4472         /* This does not need to be synchronised with blob_lock, as the
4473          * get_properties ioctl locks all modesetting objects, and
4474          * obj_holds_id must be locked before calling here, so we cannot
4475          * have its value out of sync with the list membership modified
4476          * below under blob_lock. */
4477         if (obj_holds_id) {
4478                 ret = drm_object_property_set_value(obj_holds_id,
4479                                                     prop_holds_id,
4480                                                     new_blob ?
4481                                                         new_blob->base.id : 0);
4482                 if (ret != 0)
4483                         goto err_created;
4484         }
4485
4486         drm_property_unreference_blob(old_blob);
4487         *replace = new_blob;
4488
4489         return 0;
4490
4491 err_created:
4492         drm_property_unreference_blob(new_blob);
4493         return ret;
4494 }
4495
4496 /**
4497  * drm_mode_getblob_ioctl - get the contents of a blob property value
4498  * @dev: DRM device
4499  * @data: ioctl data
4500  * @file_priv: DRM file info
4501  *
4502  * This function retrieves the contents of a blob property. The value stored in
4503  * an object's blob property is just a normal modeset object id.
4504  *
4505  * Called by the user via ioctl.
4506  *
4507  * Returns:
4508  * Zero on success, negative errno on failure.
4509  */
4510 int drm_mode_getblob_ioctl(struct drm_device *dev,
4511                            void *data, struct drm_file *file_priv)
4512 {
4513         struct drm_mode_get_blob *out_resp = data;
4514         struct drm_property_blob *blob;
4515         int ret = 0;
4516         void __user *blob_ptr;
4517
4518         if (!drm_core_check_feature(dev, DRIVER_MODESET))
4519                 return -EINVAL;
4520
4521         drm_modeset_lock_all(dev);
4522         mutex_lock(&dev->mode_config.blob_lock);
4523         blob = __drm_property_lookup_blob(dev, out_resp->blob_id);
4524         if (!blob) {
4525                 ret = -ENOENT;
4526                 goto done;
4527         }
4528
4529         if (out_resp->length == blob->length) {
4530                 blob_ptr = (void __user *)(unsigned long)out_resp->data;
4531                 if (copy_to_user(blob_ptr, blob->data, blob->length)) {
4532                         ret = -EFAULT;
4533                         goto done;
4534                 }
4535         }
4536         out_resp->length = blob->length;
4537
4538 done:
4539         mutex_unlock(&dev->mode_config.blob_lock);
4540         drm_modeset_unlock_all(dev);
4541         return ret;
4542 }
4543
4544 /**
4545  * drm_mode_createblob_ioctl - create a new blob property
4546  * @dev: DRM device
4547  * @data: ioctl data
4548  * @file_priv: DRM file info
4549  *
4550  * This function creates a new blob property with user-defined values. In order
4551  * to give us sensible validation and checking when creating, rather than at
4552  * every potential use, we also require a type to be provided upfront.
4553  *
4554  * Called by the user via ioctl.
4555  *
4556  * Returns:
4557  * Zero on success, negative errno on failure.
4558  */
4559 int drm_mode_createblob_ioctl(struct drm_device *dev,
4560                               void *data, struct drm_file *file_priv)
4561 {
4562         struct drm_mode_create_blob *out_resp = data;
4563         struct drm_property_blob *blob;
4564         void __user *blob_ptr;
4565         int ret = 0;
4566
4567         if (!drm_core_check_feature(dev, DRIVER_MODESET))
4568                 return -EINVAL;
4569
4570         blob = drm_property_create_blob(dev, out_resp->length, NULL);
4571         if (IS_ERR(blob))
4572                 return PTR_ERR(blob);
4573
4574         blob_ptr = (void __user *)(unsigned long)out_resp->data;
4575         if (copy_from_user(blob->data, blob_ptr, out_resp->length)) {
4576                 ret = -EFAULT;
4577                 goto out_blob;
4578         }
4579
4580         /* Dropping the lock between create_blob and our access here is safe
4581          * as only the same file_priv can remove the blob; at this point, it is
4582          * not associated with any file_priv. */
4583         mutex_lock(&dev->mode_config.blob_lock);
4584         out_resp->blob_id = blob->base.id;
4585         list_add_tail(&blob->head_file, &file_priv->blobs);
4586         mutex_unlock(&dev->mode_config.blob_lock);
4587
4588         return 0;
4589
4590 out_blob:
4591         drm_property_unreference_blob(blob);
4592         return ret;
4593 }
4594
4595 /**
4596  * drm_mode_destroyblob_ioctl - destroy a user blob property
4597  * @dev: DRM device
4598  * @data: ioctl data
4599  * @file_priv: DRM file info
4600  *
4601  * Destroy an existing user-defined blob property.
4602  *
4603  * Called by the user via ioctl.
4604  *
4605  * Returns:
4606  * Zero on success, negative errno on failure.
4607  */
4608 int drm_mode_destroyblob_ioctl(struct drm_device *dev,
4609                                void *data, struct drm_file *file_priv)
4610 {
4611         struct drm_mode_destroy_blob *out_resp = data;
4612         struct drm_property_blob *blob = NULL, *bt;
4613         bool found = false;
4614         int ret = 0;
4615
4616         if (!drm_core_check_feature(dev, DRIVER_MODESET))
4617                 return -EINVAL;
4618
4619         mutex_lock(&dev->mode_config.blob_lock);
4620         blob = __drm_property_lookup_blob(dev, out_resp->blob_id);
4621         if (!blob) {
4622                 ret = -ENOENT;
4623                 goto err;
4624         }
4625
4626         /* Ensure the property was actually created by this user. */
4627         list_for_each_entry(bt, &file_priv->blobs, head_file) {
4628                 if (bt == blob) {
4629                         found = true;
4630                         break;
4631                 }
4632         }
4633
4634         if (!found) {
4635                 ret = -EPERM;
4636                 goto err;
4637         }
4638
4639         /* We must drop head_file here, because we may not be the last
4640          * reference on the blob. */
4641         list_del_init(&blob->head_file);
4642         drm_property_unreference_blob_locked(blob);
4643         mutex_unlock(&dev->mode_config.blob_lock);
4644
4645         return 0;
4646
4647 err:
4648         mutex_unlock(&dev->mode_config.blob_lock);
4649         return ret;
4650 }
4651
4652 /**
4653  * drm_mode_connector_set_path_property - set tile property on connector
4654  * @connector: connector to set property on.
4655  * @path: path to use for property; must not be NULL.
4656  *
4657  * This creates a property to expose to userspace to specify a
4658  * connector path. This is mainly used for DisplayPort MST where
4659  * connectors have a topology and we want to allow userspace to give
4660  * them more meaningful names.
4661  *
4662  * Returns:
4663  * Zero on success, negative errno on failure.
4664  */
4665 int drm_mode_connector_set_path_property(struct drm_connector *connector,
4666                                          const char *path)
4667 {
4668         struct drm_device *dev = connector->dev;
4669         int ret;
4670
4671         ret = drm_property_replace_global_blob(dev,
4672                                                &connector->path_blob_ptr,
4673                                                strlen(path) + 1,
4674                                                path,
4675                                                &connector->base,
4676                                                dev->mode_config.path_property);
4677         return ret;
4678 }
4679 EXPORT_SYMBOL(drm_mode_connector_set_path_property);
4680
4681 /**
4682  * drm_mode_connector_set_tile_property - set tile property on connector
4683  * @connector: connector to set property on.
4684  *
4685  * This looks up the tile information for a connector, and creates a
4686  * property for userspace to parse if it exists. The property is of
4687  * the form of 8 integers using ':' as a separator.
4688  *
4689  * Returns:
4690  * Zero on success, errno on failure.
4691  */
4692 int drm_mode_connector_set_tile_property(struct drm_connector *connector)
4693 {
4694         struct drm_device *dev = connector->dev;
4695         char tile[256];
4696         int ret;
4697
4698         if (!connector->has_tile) {
4699                 ret  = drm_property_replace_global_blob(dev,
4700                                                         &connector->tile_blob_ptr,
4701                                                         0,
4702                                                         NULL,
4703                                                         &connector->base,
4704                                                         dev->mode_config.tile_property);
4705                 return ret;
4706         }
4707
4708         snprintf(tile, 256, "%d:%d:%d:%d:%d:%d:%d:%d",
4709                  connector->tile_group->id, connector->tile_is_single_monitor,
4710                  connector->num_h_tile, connector->num_v_tile,
4711                  connector->tile_h_loc, connector->tile_v_loc,
4712                  connector->tile_h_size, connector->tile_v_size);
4713
4714         ret = drm_property_replace_global_blob(dev,
4715                                                &connector->tile_blob_ptr,
4716                                                strlen(tile) + 1,
4717                                                tile,
4718                                                &connector->base,
4719                                                dev->mode_config.tile_property);
4720         return ret;
4721 }
4722 EXPORT_SYMBOL(drm_mode_connector_set_tile_property);
4723
4724 /**
4725  * drm_mode_connector_update_edid_property - update the edid property of a connector
4726  * @connector: drm connector
4727  * @edid: new value of the edid property
4728  *
4729  * This function creates a new blob modeset object and assigns its id to the
4730  * connector's edid property.
4731  *
4732  * Returns:
4733  * Zero on success, negative errno on failure.
4734  */
4735 int drm_mode_connector_update_edid_property(struct drm_connector *connector,
4736                                             const struct edid *edid)
4737 {
4738         struct drm_device *dev = connector->dev;
4739         size_t size = 0;
4740         int ret;
4741
4742         /* ignore requests to set edid when overridden */
4743         if (connector->override_edid)
4744                 return 0;
4745
4746         if (edid)
4747                 size = EDID_LENGTH * (1 + edid->extensions);
4748
4749         ret = drm_property_replace_global_blob(dev,
4750                                                &connector->edid_blob_ptr,
4751                                                size,
4752                                                edid,
4753                                                &connector->base,
4754                                                dev->mode_config.edid_property);
4755         return ret;
4756 }
4757 EXPORT_SYMBOL(drm_mode_connector_update_edid_property);
4758
4759 /* Some properties could refer to dynamic refcnt'd objects, or things that
4760  * need special locking to handle lifetime issues (ie. to ensure the prop
4761  * value doesn't become invalid part way through the property update due to
4762  * race).  The value returned by reference via 'obj' should be passed back
4763  * to drm_property_change_valid_put() after the property is set (and the
4764  * object to which the property is attached has a chance to take it's own
4765  * reference).
4766  */
4767 bool drm_property_change_valid_get(struct drm_property *property,
4768                                          uint64_t value, struct drm_mode_object **ref)
4769 {
4770         int i;
4771
4772         if (property->flags & DRM_MODE_PROP_IMMUTABLE)
4773                 return false;
4774
4775         *ref = NULL;
4776
4777         if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) {
4778                 if (value < property->values[0] || value > property->values[1])
4779                         return false;
4780                 return true;
4781         } else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) {
4782                 int64_t svalue = U642I64(value);
4783
4784                 if (svalue < U642I64(property->values[0]) ||
4785                                 svalue > U642I64(property->values[1]))
4786                         return false;
4787                 return true;
4788         } else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
4789                 uint64_t valid_mask = 0;
4790
4791                 for (i = 0; i < property->num_values; i++)
4792                         valid_mask |= (1ULL << property->values[i]);
4793                 return !(value & ~valid_mask);
4794         } else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
4795                 struct drm_property_blob *blob;
4796
4797                 if (value == 0)
4798                         return true;
4799
4800                 blob = drm_property_lookup_blob(property->dev, value);
4801                 if (blob) {
4802                         *ref = &blob->base;
4803                         return true;
4804                 } else {
4805                         return false;
4806                 }
4807         } else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
4808                 /* a zero value for an object property translates to null: */
4809                 if (value == 0)
4810                         return true;
4811
4812                 /* handle refcnt'd objects specially: */
4813                 if (property->values[0] == DRM_MODE_OBJECT_FB) {
4814                         struct drm_framebuffer *fb;
4815                         fb = drm_framebuffer_lookup(property->dev, value);
4816                         if (fb) {
4817                                 *ref = &fb->base;
4818                                 return true;
4819                         } else {
4820                                 return false;
4821                         }
4822                 } else {
4823                         return _object_find(property->dev, value, property->values[0]) != NULL;
4824                 }
4825         }
4826
4827         for (i = 0; i < property->num_values; i++)
4828                 if (property->values[i] == value)
4829                         return true;
4830         return false;
4831 }
4832
4833 void drm_property_change_valid_put(struct drm_property *property,
4834                 struct drm_mode_object *ref)
4835 {
4836         if (!ref)
4837                 return;
4838
4839         if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
4840                 if (property->values[0] == DRM_MODE_OBJECT_FB)
4841                         drm_framebuffer_unreference(obj_to_fb(ref));
4842         } else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
4843                 drm_property_unreference_blob(obj_to_blob(ref));
4844 }
4845
4846 /**
4847  * drm_mode_connector_property_set_ioctl - set the current value of a connector property
4848  * @dev: DRM device
4849  * @data: ioctl data
4850  * @file_priv: DRM file info
4851  *
4852  * This function sets the current value for a connectors's property. It also
4853  * calls into a driver's ->set_property callback to update the hardware state
4854  *
4855  * Called by the user via ioctl.
4856  *
4857  * Returns:
4858  * Zero on success, negative errno on failure.
4859  */
4860 int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
4861                                        void *data, struct drm_file *file_priv)
4862 {
4863         struct drm_mode_connector_set_property *conn_set_prop = data;
4864         struct drm_mode_obj_set_property obj_set_prop = {
4865                 .value = conn_set_prop->value,
4866                 .prop_id = conn_set_prop->prop_id,
4867                 .obj_id = conn_set_prop->connector_id,
4868                 .obj_type = DRM_MODE_OBJECT_CONNECTOR
4869         };
4870
4871         /* It does all the locking and checking we need */
4872         return drm_mode_obj_set_property_ioctl(dev, &obj_set_prop, file_priv);
4873 }
4874
4875 static int drm_mode_connector_set_obj_prop(struct drm_mode_object *obj,
4876                                            struct drm_property *property,
4877                                            uint64_t value)
4878 {
4879         int ret = -EINVAL;
4880         struct drm_connector *connector = obj_to_connector(obj);
4881
4882         /* Do DPMS ourselves */
4883         if (property == connector->dev->mode_config.dpms_property) {
4884                 ret = (*connector->funcs->dpms)(connector, (int)value);
4885         } else if (connector->funcs->set_property)
4886                 ret = connector->funcs->set_property(connector, property, value);
4887
4888         /* store the property value if successful */
4889         if (!ret)
4890                 drm_object_property_set_value(&connector->base, property, value);
4891         return ret;
4892 }
4893
4894 static int drm_mode_crtc_set_obj_prop(struct drm_mode_object *obj,
4895                                       struct drm_property *property,
4896                                       uint64_t value)
4897 {
4898         int ret = -EINVAL;
4899         struct drm_crtc *crtc = obj_to_crtc(obj);
4900
4901         if (crtc->funcs->set_property)
4902                 ret = crtc->funcs->set_property(crtc, property, value);
4903         if (!ret)
4904                 drm_object_property_set_value(obj, property, value);
4905
4906         return ret;
4907 }
4908
4909 /**
4910  * drm_mode_plane_set_obj_prop - set the value of a property
4911  * @plane: drm plane object to set property value for
4912  * @property: property to set
4913  * @value: value the property should be set to
4914  *
4915  * This functions sets a given property on a given plane object. This function
4916  * calls the driver's ->set_property callback and changes the software state of
4917  * the property if the callback succeeds.
4918  *
4919  * Returns:
4920  * Zero on success, error code on failure.
4921  */
4922 int drm_mode_plane_set_obj_prop(struct drm_plane *plane,
4923                                 struct drm_property *property,
4924                                 uint64_t value)
4925 {
4926         int ret = -EINVAL;
4927         struct drm_mode_object *obj = &plane->base;
4928
4929         if (plane->funcs->set_property)
4930                 ret = plane->funcs->set_property(plane, property, value);
4931         if (!ret)
4932                 drm_object_property_set_value(obj, property, value);
4933
4934         return ret;
4935 }
4936 EXPORT_SYMBOL(drm_mode_plane_set_obj_prop);
4937
4938 /**
4939  * drm_mode_obj_get_properties_ioctl - get the current value of a object's property
4940  * @dev: DRM device
4941  * @data: ioctl data
4942  * @file_priv: DRM file info
4943  *
4944  * This function retrieves the current value for an object's property. Compared
4945  * to the connector specific ioctl this one is extended to also work on crtc and
4946  * plane objects.
4947  *
4948  * Called by the user via ioctl.
4949  *
4950  * Returns:
4951  * Zero on success, negative errno on failure.
4952  */
4953 int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
4954                                       struct drm_file *file_priv)
4955 {
4956         struct drm_mode_obj_get_properties *arg = data;
4957         struct drm_mode_object *obj;
4958         int ret = 0;
4959
4960         if (!drm_core_check_feature(dev, DRIVER_MODESET))
4961                 return -EINVAL;
4962
4963         drm_modeset_lock_all(dev);
4964
4965         obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
4966         if (!obj) {
4967                 ret = -ENOENT;
4968                 goto out;
4969         }
4970         if (!obj->properties) {
4971                 ret = -EINVAL;
4972                 goto out;
4973         }
4974
4975         ret = get_properties(obj, file_priv->atomic,
4976                         (uint32_t __user *)(unsigned long)(arg->props_ptr),
4977                         (uint64_t __user *)(unsigned long)(arg->prop_values_ptr),
4978                         &arg->count_props);
4979
4980 out:
4981         drm_modeset_unlock_all(dev);
4982         return ret;
4983 }
4984
4985 /**
4986  * drm_mode_obj_set_property_ioctl - set the current value of an object's property
4987  * @dev: DRM device
4988  * @data: ioctl data
4989  * @file_priv: DRM file info
4990  *
4991  * This function sets the current value for an object's property. It also calls
4992  * into a driver's ->set_property callback to update the hardware state.
4993  * Compared to the connector specific ioctl this one is extended to also work on
4994  * crtc and plane objects.
4995  *
4996  * Called by the user via ioctl.
4997  *
4998  * Returns:
4999  * Zero on success, negative errno on failure.
5000  */
5001 int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
5002                                     struct drm_file *file_priv)
5003 {
5004         struct drm_mode_obj_set_property *arg = data;
5005         struct drm_mode_object *arg_obj;
5006         struct drm_mode_object *prop_obj;
5007         struct drm_property *property;
5008         int i, ret = -EINVAL;
5009         struct drm_mode_object *ref;
5010
5011         if (!drm_core_check_feature(dev, DRIVER_MODESET))
5012                 return -EINVAL;
5013
5014         drm_modeset_lock_all(dev);
5015
5016         arg_obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
5017         if (!arg_obj) {
5018                 ret = -ENOENT;
5019                 goto out;
5020         }
5021         if (!arg_obj->properties)
5022                 goto out;
5023
5024         for (i = 0; i < arg_obj->properties->count; i++)
5025                 if (arg_obj->properties->properties[i]->base.id == arg->prop_id)
5026                         break;
5027
5028         if (i == arg_obj->properties->count)
5029                 goto out;
5030
5031         prop_obj = drm_mode_object_find(dev, arg->prop_id,
5032                                         DRM_MODE_OBJECT_PROPERTY);
5033         if (!prop_obj) {
5034                 ret = -ENOENT;
5035                 goto out;
5036         }
5037         property = obj_to_property(prop_obj);
5038
5039         if (!drm_property_change_valid_get(property, arg->value, &ref))
5040                 goto out;
5041
5042         switch (arg_obj->type) {
5043         case DRM_MODE_OBJECT_CONNECTOR:
5044                 ret = drm_mode_connector_set_obj_prop(arg_obj, property,
5045                                                       arg->value);
5046                 break;
5047         case DRM_MODE_OBJECT_CRTC:
5048                 ret = drm_mode_crtc_set_obj_prop(arg_obj, property, arg->value);
5049                 break;
5050         case DRM_MODE_OBJECT_PLANE:
5051                 ret = drm_mode_plane_set_obj_prop(obj_to_plane(arg_obj),
5052                                                   property, arg->value);
5053                 break;
5054         }
5055
5056         drm_property_change_valid_put(property, ref);
5057
5058 out:
5059         drm_modeset_unlock_all(dev);
5060         return ret;
5061 }
5062
5063 /**
5064  * drm_mode_connector_attach_encoder - attach a connector to an encoder
5065  * @connector: connector to attach
5066  * @encoder: encoder to attach @connector to
5067  *
5068  * This function links up a connector to an encoder. Note that the routing
5069  * restrictions between encoders and crtcs are exposed to userspace through the
5070  * possible_clones and possible_crtcs bitmasks.
5071  *
5072  * Returns:
5073  * Zero on success, negative errno on failure.
5074  */
5075 int drm_mode_connector_attach_encoder(struct drm_connector *connector,
5076                                       struct drm_encoder *encoder)
5077 {
5078         int i;
5079
5080         /*
5081          * In the past, drivers have attempted to model the static association
5082          * of connector to encoder in simple connector/encoder devices using a
5083          * direct assignment of connector->encoder = encoder. This connection
5084          * is a logical one and the responsibility of the core, so drivers are
5085          * expected not to mess with this.
5086          *
5087          * Note that the error return should've been enough here, but a large
5088          * majority of drivers ignores the return value, so add in a big WARN
5089          * to get people's attention.
5090          */
5091         if (WARN_ON(connector->encoder))
5092                 return -EINVAL;
5093
5094         for (i = 0; i < DRM_CONNECTOR_MAX_ENCODER; i++) {
5095                 if (connector->encoder_ids[i] == 0) {
5096                         connector->encoder_ids[i] = encoder->base.id;
5097                         return 0;
5098                 }
5099         }
5100         return -ENOMEM;
5101 }
5102 EXPORT_SYMBOL(drm_mode_connector_attach_encoder);
5103
5104 /**
5105  * drm_mode_crtc_set_gamma_size - set the gamma table size
5106  * @crtc: CRTC to set the gamma table size for
5107  * @gamma_size: size of the gamma table
5108  *
5109  * Drivers which support gamma tables should set this to the supported gamma
5110  * table size when initializing the CRTC. Currently the drm core only supports a
5111  * fixed gamma table size.
5112  *
5113  * Returns:
5114  * Zero on success, negative errno on failure.
5115  */
5116 int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
5117                                  int gamma_size)
5118 {
5119         crtc->gamma_size = gamma_size;
5120
5121         crtc->gamma_store = kcalloc(gamma_size, sizeof(uint16_t) * 3,
5122                                     GFP_KERNEL);
5123         if (!crtc->gamma_store) {
5124                 crtc->gamma_size = 0;
5125                 return -ENOMEM;
5126         }
5127
5128         return 0;
5129 }
5130 EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);
5131
5132 /**
5133  * drm_mode_gamma_set_ioctl - set the gamma table
5134  * @dev: DRM device
5135  * @data: ioctl data
5136  * @file_priv: DRM file info
5137  *
5138  * Set the gamma table of a CRTC to the one passed in by the user. Userspace can
5139  * inquire the required gamma table size through drm_mode_gamma_get_ioctl.
5140  *
5141  * Called by the user via ioctl.
5142  *
5143  * Returns:
5144  * Zero on success, negative errno on failure.
5145  */
5146 int drm_mode_gamma_set_ioctl(struct drm_device *dev,
5147                              void *data, struct drm_file *file_priv)
5148 {
5149         struct drm_mode_crtc_lut *crtc_lut = data;
5150         struct drm_crtc *crtc;
5151         void *r_base, *g_base, *b_base;
5152         int size;
5153         int ret = 0;
5154
5155         if (!drm_core_check_feature(dev, DRIVER_MODESET))
5156                 return -EINVAL;
5157
5158         drm_modeset_lock_all(dev);
5159         crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
5160         if (!crtc) {
5161                 ret = -ENOENT;
5162                 goto out;
5163         }
5164
5165         if (crtc->funcs->gamma_set == NULL) {
5166                 ret = -ENOSYS;
5167                 goto out;
5168         }
5169
5170         /* memcpy into gamma store */
5171         if (crtc_lut->gamma_size != crtc->gamma_size) {
5172                 ret = -EINVAL;
5173                 goto out;
5174         }
5175
5176         size = crtc_lut->gamma_size * (sizeof(uint16_t));
5177         r_base = crtc->gamma_store;
5178         if (copy_from_user(r_base, (void __user *)(unsigned long)crtc_lut->red, size)) {
5179                 ret = -EFAULT;
5180                 goto out;
5181         }
5182
5183         g_base = r_base + size;
5184         if (copy_from_user(g_base, (void __user *)(unsigned long)crtc_lut->green, size)) {
5185                 ret = -EFAULT;
5186                 goto out;
5187         }
5188
5189         b_base = g_base + size;
5190         if (copy_from_user(b_base, (void __user *)(unsigned long)crtc_lut->blue, size)) {
5191                 ret = -EFAULT;
5192                 goto out;
5193         }
5194
5195         crtc->funcs->gamma_set(crtc, r_base, g_base, b_base, 0, crtc->gamma_size);
5196
5197 out:
5198         drm_modeset_unlock_all(dev);
5199         return ret;
5200
5201 }
5202
5203 /**
5204  * drm_mode_gamma_get_ioctl - get the gamma table
5205  * @dev: DRM device
5206  * @data: ioctl data
5207  * @file_priv: DRM file info
5208  *
5209  * Copy the current gamma table into the storage provided. This also provides
5210  * the gamma table size the driver expects, which can be used to size the
5211  * allocated storage.
5212  *
5213  * Called by the user via ioctl.
5214  *
5215  * Returns:
5216  * Zero on success, negative errno on failure.
5217  */
5218 int drm_mode_gamma_get_ioctl(struct drm_device *dev,
5219                              void *data, struct drm_file *file_priv)
5220 {
5221         struct drm_mode_crtc_lut *crtc_lut = data;
5222         struct drm_crtc *crtc;
5223         void *r_base, *g_base, *b_base;
5224         int size;
5225         int ret = 0;
5226
5227         if (!drm_core_check_feature(dev, DRIVER_MODESET))
5228                 return -EINVAL;
5229
5230         drm_modeset_lock_all(dev);
5231         crtc = drm_crtc_find(dev, crtc_lut->crtc_id);
5232         if (!crtc) {
5233                 ret = -ENOENT;
5234                 goto out;
5235         }
5236
5237         /* memcpy into gamma store */
5238         if (crtc_lut->gamma_size != crtc->gamma_size) {
5239                 ret = -EINVAL;
5240                 goto out;
5241         }
5242
5243         size = crtc_lut->gamma_size * (sizeof(uint16_t));
5244         r_base = crtc->gamma_store;
5245         if (copy_to_user((void __user *)(unsigned long)crtc_lut->red, r_base, size)) {
5246                 ret = -EFAULT;
5247                 goto out;
5248         }
5249
5250         g_base = r_base + size;
5251         if (copy_to_user((void __user *)(unsigned long)crtc_lut->green, g_base, size)) {
5252                 ret = -EFAULT;
5253                 goto out;
5254         }
5255
5256         b_base = g_base + size;
5257         if (copy_to_user((void __user *)(unsigned long)crtc_lut->blue, b_base, size)) {
5258                 ret = -EFAULT;
5259                 goto out;
5260         }
5261 out:
5262         drm_modeset_unlock_all(dev);
5263         return ret;
5264 }
5265
5266 /**
5267  * drm_mode_page_flip_ioctl - schedule an asynchronous fb update
5268  * @dev: DRM device
5269  * @data: ioctl data
5270  * @file_priv: DRM file info
5271  *
5272  * This schedules an asynchronous update on a given CRTC, called page flip.
5273  * Optionally a drm event is generated to signal the completion of the event.
5274  * Generic drivers cannot assume that a pageflip with changed framebuffer
5275  * properties (including driver specific metadata like tiling layout) will work,
5276  * but some drivers support e.g. pixel format changes through the pageflip
5277  * ioctl.
5278  *
5279  * Called by the user via ioctl.
5280  *
5281  * Returns:
5282  * Zero on success, negative errno on failure.
5283  */
5284 int drm_mode_page_flip_ioctl(struct drm_device *dev,
5285                              void *data, struct drm_file *file_priv)
5286 {
5287         struct drm_mode_crtc_page_flip *page_flip = data;
5288         struct drm_crtc *crtc;
5289         struct drm_framebuffer *fb = NULL;
5290         struct drm_pending_vblank_event *e = NULL;
5291         int ret = -EINVAL;
5292
5293         if (page_flip->flags & ~DRM_MODE_PAGE_FLIP_FLAGS ||
5294             page_flip->reserved != 0)
5295                 return -EINVAL;
5296
5297         if ((page_flip->flags & DRM_MODE_PAGE_FLIP_ASYNC) && !dev->mode_config.async_page_flip)
5298                 return -EINVAL;
5299
5300         crtc = drm_crtc_find(dev, page_flip->crtc_id);
5301         if (!crtc)
5302                 return -ENOENT;
5303
5304         drm_modeset_lock_crtc(crtc, crtc->primary);
5305         if (crtc->primary->fb == NULL) {
5306                 /* The framebuffer is currently unbound, presumably
5307                  * due to a hotplug event, that userspace has not
5308                  * yet discovered.
5309                  */
5310                 ret = -EBUSY;
5311                 goto out;
5312         }
5313
5314         if (crtc->funcs->page_flip == NULL)
5315                 goto out;
5316
5317         fb = drm_framebuffer_lookup(dev, page_flip->fb_id);
5318         if (!fb) {
5319                 ret = -ENOENT;
5320                 goto out;
5321         }
5322
5323         if (crtc->state) {
5324                 const struct drm_plane_state *state = crtc->primary->state;
5325
5326                 ret = check_src_coords(state->src_x, state->src_y,
5327                                        state->src_w, state->src_h, fb);
5328         } else {
5329                 ret = drm_crtc_check_viewport(crtc, crtc->x, crtc->y, &crtc->mode, fb);
5330         }
5331         if (ret)
5332                 goto out;
5333
5334         if (crtc->primary->fb->pixel_format != fb->pixel_format) {
5335                 DRM_DEBUG_KMS("Page flip is not allowed to change frame buffer format.\n");
5336                 ret = -EINVAL;
5337                 goto out;
5338         }
5339
5340         if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT) {
5341                 e = kzalloc(sizeof *e, GFP_KERNEL);
5342                 if (!e) {
5343                         ret = -ENOMEM;
5344                         goto out;
5345                 }
5346                 e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
5347                 e->event.base.length = sizeof(e->event);
5348                 e->event.user_data = page_flip->user_data;
5349                 ret = drm_event_reserve_init(dev, file_priv, &e->base, &e->event.base);
5350                 if (ret) {
5351                         kfree(e);
5352                         goto out;
5353                 }
5354         }
5355
5356         crtc->primary->old_fb = crtc->primary->fb;
5357         ret = crtc->funcs->page_flip(crtc, fb, e, page_flip->flags);
5358         if (ret) {
5359                 if (page_flip->flags & DRM_MODE_PAGE_FLIP_EVENT)
5360                         drm_event_cancel_free(dev, &e->base);
5361                 /* Keep the old fb, don't unref it. */
5362                 crtc->primary->old_fb = NULL;
5363         } else {
5364                 crtc->primary->fb = fb;
5365                 /* Unref only the old framebuffer. */
5366                 fb = NULL;
5367         }
5368
5369 out:
5370         if (fb)
5371                 drm_framebuffer_unreference(fb);
5372         if (crtc->primary->old_fb)
5373                 drm_framebuffer_unreference(crtc->primary->old_fb);
5374         crtc->primary->old_fb = NULL;
5375         drm_modeset_unlock_crtc(crtc);
5376
5377         return ret;
5378 }
5379
5380 /**
5381  * drm_mode_config_reset - call ->reset callbacks
5382  * @dev: drm device
5383  *
5384  * This functions calls all the crtc's, encoder's and connector's ->reset
5385  * callback. Drivers can use this in e.g. their driver load or resume code to
5386  * reset hardware and software state.
5387  */
5388 void drm_mode_config_reset(struct drm_device *dev)
5389 {
5390         struct drm_crtc *crtc;
5391         struct drm_plane *plane;
5392         struct drm_encoder *encoder;
5393         struct drm_connector *connector;
5394
5395         drm_for_each_plane(plane, dev)
5396                 if (plane->funcs->reset)
5397                         plane->funcs->reset(plane);
5398
5399         drm_for_each_crtc(crtc, dev)
5400                 if (crtc->funcs->reset)
5401                         crtc->funcs->reset(crtc);
5402
5403         drm_for_each_encoder(encoder, dev)
5404                 if (encoder->funcs->reset)
5405                         encoder->funcs->reset(encoder);
5406
5407         mutex_lock(&dev->mode_config.mutex);
5408         drm_for_each_connector(connector, dev)
5409                 if (connector->funcs->reset)
5410                         connector->funcs->reset(connector);
5411         mutex_unlock(&dev->mode_config.mutex);
5412 }
5413 EXPORT_SYMBOL(drm_mode_config_reset);
5414
5415 /**
5416  * drm_mode_create_dumb_ioctl - create a dumb backing storage buffer
5417  * @dev: DRM device
5418  * @data: ioctl data
5419  * @file_priv: DRM file info
5420  *
5421  * This creates a new dumb buffer in the driver's backing storage manager (GEM,
5422  * TTM or something else entirely) and returns the resulting buffer handle. This
5423  * handle can then be wrapped up into a framebuffer modeset object.
5424  *
5425  * Note that userspace is not allowed to use such objects for render
5426  * acceleration - drivers must create their own private ioctls for such a use
5427  * case.
5428  *
5429  * Called by the user via ioctl.
5430  *
5431  * Returns:
5432  * Zero on success, negative errno on failure.
5433  */
5434 int drm_mode_create_dumb_ioctl(struct drm_device *dev,
5435                                void *data, struct drm_file *file_priv)
5436 {
5437         struct drm_mode_create_dumb *args = data;
5438         u32 cpp, stride, size;
5439
5440         if (!dev->driver->dumb_create)
5441                 return -ENOSYS;
5442         if (!args->width || !args->height || !args->bpp)
5443                 return -EINVAL;
5444
5445         /* overflow checks for 32bit size calculations */
5446         /* NOTE: DIV_ROUND_UP() can overflow */
5447         cpp = DIV_ROUND_UP(args->bpp, 8);
5448         if (!cpp || cpp > 0xffffffffU / args->width)
5449                 return -EINVAL;
5450         stride = cpp * args->width;
5451         if (args->height > 0xffffffffU / stride)
5452                 return -EINVAL;
5453
5454         /* test for wrap-around */
5455         size = args->height * stride;
5456         if (PAGE_ALIGN(size) == 0)
5457                 return -EINVAL;
5458
5459         /*
5460          * handle, pitch and size are output parameters. Zero them out to
5461          * prevent drivers from accidentally using uninitialized data. Since
5462          * not all existing userspace is clearing these fields properly we
5463          * cannot reject IOCTL with garbage in them.
5464          */
5465         args->handle = 0;
5466         args->pitch = 0;
5467         args->size = 0;
5468
5469         return dev->driver->dumb_create(file_priv, dev, args);
5470 }
5471
5472 /**
5473  * drm_mode_mmap_dumb_ioctl - create an mmap offset for a dumb backing storage buffer
5474  * @dev: DRM device
5475  * @data: ioctl data
5476  * @file_priv: DRM file info
5477  *
5478  * Allocate an offset in the drm device node's address space to be able to
5479  * memory map a dumb buffer.
5480  *
5481  * Called by the user via ioctl.
5482  *
5483  * Returns:
5484  * Zero on success, negative errno on failure.
5485  */
5486 int drm_mode_mmap_dumb_ioctl(struct drm_device *dev,
5487                              void *data, struct drm_file *file_priv)
5488 {
5489         struct drm_mode_map_dumb *args = data;
5490
5491         /* call driver ioctl to get mmap offset */
5492         if (!dev->driver->dumb_map_offset)
5493                 return -ENOSYS;
5494
5495         return dev->driver->dumb_map_offset(file_priv, dev, args->handle, &args->offset);
5496 }
5497
5498 /**
5499  * drm_mode_destroy_dumb_ioctl - destroy a dumb backing strage buffer
5500  * @dev: DRM device
5501  * @data: ioctl data
5502  * @file_priv: DRM file info
5503  *
5504  * This destroys the userspace handle for the given dumb backing storage buffer.
5505  * Since buffer objects must be reference counted in the kernel a buffer object
5506  * won't be immediately freed if a framebuffer modeset object still uses it.
5507  *
5508  * Called by the user via ioctl.
5509  *
5510  * Returns:
5511  * Zero on success, negative errno on failure.
5512  */
5513 int drm_mode_destroy_dumb_ioctl(struct drm_device *dev,
5514                                 void *data, struct drm_file *file_priv)
5515 {
5516         struct drm_mode_destroy_dumb *args = data;
5517
5518         if (!dev->driver->dumb_destroy)
5519                 return -ENOSYS;
5520
5521         return dev->driver->dumb_destroy(file_priv, dev, args->handle);
5522 }
5523
5524 /**
5525  * drm_fb_get_bpp_depth - get the bpp/depth values for format
5526  * @format: pixel format (DRM_FORMAT_*)
5527  * @depth: storage for the depth value
5528  * @bpp: storage for the bpp value
5529  *
5530  * This only supports RGB formats here for compat with code that doesn't use
5531  * pixel formats directly yet.
5532  */
5533 void drm_fb_get_bpp_depth(uint32_t format, unsigned int *depth,
5534                           int *bpp)
5535 {
5536         switch (format) {
5537         case DRM_FORMAT_C8:
5538         case DRM_FORMAT_RGB332:
5539         case DRM_FORMAT_BGR233:
5540                 *depth = 8;
5541                 *bpp = 8;
5542                 break;
5543         case DRM_FORMAT_XRGB1555:
5544         case DRM_FORMAT_XBGR1555:
5545         case DRM_FORMAT_RGBX5551:
5546         case DRM_FORMAT_BGRX5551:
5547         case DRM_FORMAT_ARGB1555:
5548         case DRM_FORMAT_ABGR1555:
5549         case DRM_FORMAT_RGBA5551:
5550         case DRM_FORMAT_BGRA5551:
5551                 *depth = 15;
5552                 *bpp = 16;
5553                 break;
5554         case DRM_FORMAT_RGB565:
5555         case DRM_FORMAT_BGR565:
5556                 *depth = 16;
5557                 *bpp = 16;
5558                 break;
5559         case DRM_FORMAT_RGB888:
5560         case DRM_FORMAT_BGR888:
5561                 *depth = 24;
5562                 *bpp = 24;
5563                 break;
5564         case DRM_FORMAT_XRGB8888:
5565         case DRM_FORMAT_XBGR8888:
5566         case DRM_FORMAT_RGBX8888:
5567         case DRM_FORMAT_BGRX8888:
5568                 *depth = 24;
5569                 *bpp = 32;
5570                 break;
5571         case DRM_FORMAT_XRGB2101010:
5572         case DRM_FORMAT_XBGR2101010:
5573         case DRM_FORMAT_RGBX1010102:
5574         case DRM_FORMAT_BGRX1010102:
5575         case DRM_FORMAT_ARGB2101010:
5576         case DRM_FORMAT_ABGR2101010:
5577         case DRM_FORMAT_RGBA1010102:
5578         case DRM_FORMAT_BGRA1010102:
5579                 *depth = 30;
5580                 *bpp = 32;
5581                 break;
5582         case DRM_FORMAT_ARGB8888:
5583         case DRM_FORMAT_ABGR8888:
5584         case DRM_FORMAT_RGBA8888:
5585         case DRM_FORMAT_BGRA8888:
5586                 *depth = 32;
5587                 *bpp = 32;
5588                 break;
5589         default:
5590                 DRM_DEBUG_KMS("unsupported pixel format %s\n",
5591                               drm_get_format_name(format));
5592                 *depth = 0;
5593                 *bpp = 0;
5594                 break;
5595         }
5596 }
5597 EXPORT_SYMBOL(drm_fb_get_bpp_depth);
5598
5599 /**
5600  * drm_format_num_planes - get the number of planes for format
5601  * @format: pixel format (DRM_FORMAT_*)
5602  *
5603  * Returns:
5604  * The number of planes used by the specified pixel format.
5605  */
5606 int drm_format_num_planes(uint32_t format)
5607 {
5608         switch (format) {
5609         case DRM_FORMAT_YUV410:
5610         case DRM_FORMAT_YVU410:
5611         case DRM_FORMAT_YUV411:
5612         case DRM_FORMAT_YVU411:
5613         case DRM_FORMAT_YUV420:
5614         case DRM_FORMAT_YVU420:
5615         case DRM_FORMAT_YUV422:
5616         case DRM_FORMAT_YVU422:
5617         case DRM_FORMAT_YUV444:
5618         case DRM_FORMAT_YVU444:
5619                 return 3;
5620         case DRM_FORMAT_NV12:
5621         case DRM_FORMAT_NV21:
5622         case DRM_FORMAT_NV16:
5623         case DRM_FORMAT_NV61:
5624         case DRM_FORMAT_NV24:
5625         case DRM_FORMAT_NV42:
5626                 return 2;
5627         default:
5628                 return 1;
5629         }
5630 }
5631 EXPORT_SYMBOL(drm_format_num_planes);
5632
5633 /**
5634  * drm_format_plane_cpp - determine the bytes per pixel value
5635  * @format: pixel format (DRM_FORMAT_*)
5636  * @plane: plane index
5637  *
5638  * Returns:
5639  * The bytes per pixel value for the specified plane.
5640  */
5641 int drm_format_plane_cpp(uint32_t format, int plane)
5642 {
5643         unsigned int depth;
5644         int bpp;
5645
5646         if (plane >= drm_format_num_planes(format))
5647                 return 0;
5648
5649         switch (format) {
5650         case DRM_FORMAT_YUYV:
5651         case DRM_FORMAT_YVYU:
5652         case DRM_FORMAT_UYVY:
5653         case DRM_FORMAT_VYUY:
5654                 return 2;
5655         case DRM_FORMAT_NV12:
5656         case DRM_FORMAT_NV21:
5657         case DRM_FORMAT_NV16:
5658         case DRM_FORMAT_NV61:
5659         case DRM_FORMAT_NV24:
5660         case DRM_FORMAT_NV42:
5661                 return plane ? 2 : 1;
5662         case DRM_FORMAT_YUV410:
5663         case DRM_FORMAT_YVU410:
5664         case DRM_FORMAT_YUV411:
5665         case DRM_FORMAT_YVU411:
5666         case DRM_FORMAT_YUV420:
5667         case DRM_FORMAT_YVU420:
5668         case DRM_FORMAT_YUV422:
5669         case DRM_FORMAT_YVU422:
5670         case DRM_FORMAT_YUV444:
5671         case DRM_FORMAT_YVU444:
5672                 return 1;
5673         default:
5674                 drm_fb_get_bpp_depth(format, &depth, &bpp);
5675                 return bpp >> 3;
5676         }
5677 }
5678 EXPORT_SYMBOL(drm_format_plane_cpp);
5679
5680 /**
5681  * drm_format_horz_chroma_subsampling - get the horizontal chroma subsampling factor
5682  * @format: pixel format (DRM_FORMAT_*)
5683  *
5684  * Returns:
5685  * The horizontal chroma subsampling factor for the
5686  * specified pixel format.
5687  */
5688 int drm_format_horz_chroma_subsampling(uint32_t format)
5689 {
5690         switch (format) {
5691         case DRM_FORMAT_YUV411:
5692         case DRM_FORMAT_YVU411:
5693         case DRM_FORMAT_YUV410:
5694         case DRM_FORMAT_YVU410:
5695                 return 4;
5696         case DRM_FORMAT_YUYV:
5697         case DRM_FORMAT_YVYU:
5698         case DRM_FORMAT_UYVY:
5699         case DRM_FORMAT_VYUY:
5700         case DRM_FORMAT_NV12:
5701         case DRM_FORMAT_NV21:
5702         case DRM_FORMAT_NV16:
5703         case DRM_FORMAT_NV61:
5704         case DRM_FORMAT_YUV422:
5705         case DRM_FORMAT_YVU422:
5706         case DRM_FORMAT_YUV420:
5707         case DRM_FORMAT_YVU420:
5708                 return 2;
5709         default:
5710                 return 1;
5711         }
5712 }
5713 EXPORT_SYMBOL(drm_format_horz_chroma_subsampling);
5714
5715 /**
5716  * drm_format_vert_chroma_subsampling - get the vertical chroma subsampling factor
5717  * @format: pixel format (DRM_FORMAT_*)
5718  *
5719  * Returns:
5720  * The vertical chroma subsampling factor for the
5721  * specified pixel format.
5722  */
5723 int drm_format_vert_chroma_subsampling(uint32_t format)
5724 {
5725         switch (format) {
5726         case DRM_FORMAT_YUV410:
5727         case DRM_FORMAT_YVU410:
5728                 return 4;
5729         case DRM_FORMAT_YUV420:
5730         case DRM_FORMAT_YVU420:
5731         case DRM_FORMAT_NV12:
5732         case DRM_FORMAT_NV21:
5733                 return 2;
5734         default:
5735                 return 1;
5736         }
5737 }
5738 EXPORT_SYMBOL(drm_format_vert_chroma_subsampling);
5739
5740 /**
5741  * drm_format_plane_width - width of the plane given the first plane
5742  * @width: width of the first plane
5743  * @format: pixel format
5744  * @plane: plane index
5745  *
5746  * Returns:
5747  * The width of @plane, given that the width of the first plane is @width.
5748  */
5749 int drm_format_plane_width(int width, uint32_t format, int plane)
5750 {
5751         if (plane >= drm_format_num_planes(format))
5752                 return 0;
5753
5754         if (plane == 0)
5755                 return width;
5756
5757         return width / drm_format_horz_chroma_subsampling(format);
5758 }
5759 EXPORT_SYMBOL(drm_format_plane_width);
5760
5761 /**
5762  * drm_format_plane_height - height of the plane given the first plane
5763  * @height: height of the first plane
5764  * @format: pixel format
5765  * @plane: plane index
5766  *
5767  * Returns:
5768  * The height of @plane, given that the height of the first plane is @height.
5769  */
5770 int drm_format_plane_height(int height, uint32_t format, int plane)
5771 {
5772         if (plane >= drm_format_num_planes(format))
5773                 return 0;
5774
5775         if (plane == 0)
5776                 return height;
5777
5778         return height / drm_format_vert_chroma_subsampling(format);
5779 }
5780 EXPORT_SYMBOL(drm_format_plane_height);
5781
5782 /**
5783  * drm_rotation_simplify() - Try to simplify the rotation
5784  * @rotation: Rotation to be simplified
5785  * @supported_rotations: Supported rotations
5786  *
5787  * Attempt to simplify the rotation to a form that is supported.
5788  * Eg. if the hardware supports everything except DRM_REFLECT_X
5789  * one could call this function like this:
5790  *
5791  * drm_rotation_simplify(rotation, BIT(DRM_ROTATE_0) |
5792  *                       BIT(DRM_ROTATE_90) | BIT(DRM_ROTATE_180) |
5793  *                       BIT(DRM_ROTATE_270) | BIT(DRM_REFLECT_Y));
5794  *
5795  * to eliminate the DRM_ROTATE_X flag. Depending on what kind of
5796  * transforms the hardware supports, this function may not
5797  * be able to produce a supported transform, so the caller should
5798  * check the result afterwards.
5799  */
5800 unsigned int drm_rotation_simplify(unsigned int rotation,
5801                                    unsigned int supported_rotations)
5802 {
5803         if (rotation & ~supported_rotations) {
5804                 rotation ^= BIT(DRM_REFLECT_X) | BIT(DRM_REFLECT_Y);
5805                 rotation = (rotation & DRM_REFLECT_MASK) |
5806                            BIT((ffs(rotation & DRM_ROTATE_MASK) + 1) % 4);
5807         }
5808
5809         return rotation;
5810 }
5811 EXPORT_SYMBOL(drm_rotation_simplify);
5812
5813 /**
5814  * drm_mode_config_init - initialize DRM mode_configuration structure
5815  * @dev: DRM device
5816  *
5817  * Initialize @dev's mode_config structure, used for tracking the graphics
5818  * configuration of @dev.
5819  *
5820  * Since this initializes the modeset locks, no locking is possible. Which is no
5821  * problem, since this should happen single threaded at init time. It is the
5822  * driver's problem to ensure this guarantee.
5823  *
5824  */
5825 void drm_mode_config_init(struct drm_device *dev)
5826 {
5827         mutex_init(&dev->mode_config.mutex);
5828         drm_modeset_lock_init(&dev->mode_config.connection_mutex);
5829         mutex_init(&dev->mode_config.idr_mutex);
5830         mutex_init(&dev->mode_config.fb_lock);
5831         mutex_init(&dev->mode_config.blob_lock);
5832         INIT_LIST_HEAD(&dev->mode_config.fb_list);
5833         INIT_LIST_HEAD(&dev->mode_config.crtc_list);
5834         INIT_LIST_HEAD(&dev->mode_config.connector_list);
5835         INIT_LIST_HEAD(&dev->mode_config.encoder_list);
5836         INIT_LIST_HEAD(&dev->mode_config.property_list);
5837         INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
5838         INIT_LIST_HEAD(&dev->mode_config.plane_list);
5839         idr_init(&dev->mode_config.crtc_idr);
5840         idr_init(&dev->mode_config.tile_idr);
5841
5842         drm_modeset_lock_all(dev);
5843         drm_mode_create_standard_properties(dev);
5844         drm_modeset_unlock_all(dev);
5845
5846         /* Just to be sure */
5847         dev->mode_config.num_fb = 0;
5848         dev->mode_config.num_connector = 0;
5849         dev->mode_config.num_crtc = 0;
5850         dev->mode_config.num_encoder = 0;
5851         dev->mode_config.num_overlay_plane = 0;
5852         dev->mode_config.num_total_plane = 0;
5853 }
5854 EXPORT_SYMBOL(drm_mode_config_init);
5855
5856 /**
5857  * drm_mode_config_cleanup - free up DRM mode_config info
5858  * @dev: DRM device
5859  *
5860  * Free up all the connectors and CRTCs associated with this DRM device, then
5861  * free up the framebuffers and associated buffer objects.
5862  *
5863  * Note that since this /should/ happen single-threaded at driver/device
5864  * teardown time, no locking is required. It's the driver's job to ensure that
5865  * this guarantee actually holds true.
5866  *
5867  * FIXME: cleanup any dangling user buffer objects too
5868  */
5869 void drm_mode_config_cleanup(struct drm_device *dev)
5870 {
5871         struct drm_connector *connector, *ot;
5872         struct drm_crtc *crtc, *ct;
5873         struct drm_encoder *encoder, *enct;
5874         struct drm_framebuffer *fb, *fbt;
5875         struct drm_property *property, *pt;
5876         struct drm_property_blob *blob, *bt;
5877         struct drm_plane *plane, *plt;
5878
5879         list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list,
5880                                  head) {
5881                 encoder->funcs->destroy(encoder);
5882         }
5883
5884         list_for_each_entry_safe(connector, ot,
5885                                  &dev->mode_config.connector_list, head) {
5886                 connector->funcs->destroy(connector);
5887         }
5888
5889         list_for_each_entry_safe(property, pt, &dev->mode_config.property_list,
5890                                  head) {
5891                 drm_property_destroy(dev, property);
5892         }
5893
5894         list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
5895                                  head_global) {
5896                 drm_property_unreference_blob(blob);
5897         }
5898
5899         /*
5900          * Single-threaded teardown context, so it's not required to grab the
5901          * fb_lock to protect against concurrent fb_list access. Contrary, it
5902          * would actually deadlock with the drm_framebuffer_cleanup function.
5903          *
5904          * Also, if there are any framebuffers left, that's a driver leak now,
5905          * so politely WARN about this.
5906          */
5907         WARN_ON(!list_empty(&dev->mode_config.fb_list));
5908         list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
5909                 drm_framebuffer_free(&fb->refcount);
5910         }
5911
5912         list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list,
5913                                  head) {
5914                 plane->funcs->destroy(plane);
5915         }
5916
5917         list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) {
5918                 crtc->funcs->destroy(crtc);
5919         }
5920
5921         idr_destroy(&dev->mode_config.tile_idr);
5922         idr_destroy(&dev->mode_config.crtc_idr);
5923         drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
5924 }
5925 EXPORT_SYMBOL(drm_mode_config_cleanup);
5926
5927 struct drm_property *drm_mode_create_rotation_property(struct drm_device *dev,
5928                                                        unsigned int supported_rotations)
5929 {
5930         static const struct drm_prop_enum_list props[] = {
5931                 { DRM_ROTATE_0,   "rotate-0" },
5932                 { DRM_ROTATE_90,  "rotate-90" },
5933                 { DRM_ROTATE_180, "rotate-180" },
5934                 { DRM_ROTATE_270, "rotate-270" },
5935                 { DRM_REFLECT_X,  "reflect-x" },
5936                 { DRM_REFLECT_Y,  "reflect-y" },
5937         };
5938
5939         return drm_property_create_bitmask(dev, 0, "rotation",
5940                                            props, ARRAY_SIZE(props),
5941                                            supported_rotations);
5942 }
5943 EXPORT_SYMBOL(drm_mode_create_rotation_property);
5944
5945 /**
5946  * DOC: Tile group
5947  *
5948  * Tile groups are used to represent tiled monitors with a unique
5949  * integer identifier. Tiled monitors using DisplayID v1.3 have
5950  * a unique 8-byte handle, we store this in a tile group, so we
5951  * have a common identifier for all tiles in a monitor group.
5952  */
5953 static void drm_tile_group_free(struct kref *kref)
5954 {
5955         struct drm_tile_group *tg = container_of(kref, struct drm_tile_group, refcount);
5956         struct drm_device *dev = tg->dev;
5957         mutex_lock(&dev->mode_config.idr_mutex);
5958         idr_remove(&dev->mode_config.tile_idr, tg->id);
5959         mutex_unlock(&dev->mode_config.idr_mutex);
5960         kfree(tg);
5961 }
5962
5963 /**
5964  * drm_mode_put_tile_group - drop a reference to a tile group.
5965  * @dev: DRM device
5966  * @tg: tile group to drop reference to.
5967  *
5968  * drop reference to tile group and free if 0.
5969  */
5970 void drm_mode_put_tile_group(struct drm_device *dev,
5971                              struct drm_tile_group *tg)
5972 {
5973         kref_put(&tg->refcount, drm_tile_group_free);
5974 }
5975
5976 /**
5977  * drm_mode_get_tile_group - get a reference to an existing tile group
5978  * @dev: DRM device
5979  * @topology: 8-bytes unique per monitor.
5980  *
5981  * Use the unique bytes to get a reference to an existing tile group.
5982  *
5983  * RETURNS:
5984  * tile group or NULL if not found.
5985  */
5986 struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev,
5987                                                char topology[8])
5988 {
5989         struct drm_tile_group *tg;
5990         int id;
5991         mutex_lock(&dev->mode_config.idr_mutex);
5992         idr_for_each_entry(&dev->mode_config.tile_idr, tg, id) {
5993                 if (!memcmp(tg->group_data, topology, 8)) {
5994                         if (!kref_get_unless_zero(&tg->refcount))
5995                                 tg = NULL;
5996                         mutex_unlock(&dev->mode_config.idr_mutex);
5997                         return tg;
5998                 }
5999         }
6000         mutex_unlock(&dev->mode_config.idr_mutex);
6001         return NULL;
6002 }
6003 EXPORT_SYMBOL(drm_mode_get_tile_group);
6004
6005 /**
6006  * drm_mode_create_tile_group - create a tile group from a displayid description
6007  * @dev: DRM device
6008  * @topology: 8-bytes unique per monitor.
6009  *
6010  * Create a tile group for the unique monitor, and get a unique
6011  * identifier for the tile group.
6012  *
6013  * RETURNS:
6014  * new tile group or error.
6015  */
6016 struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
6017                                                   char topology[8])
6018 {
6019         struct drm_tile_group *tg;
6020         int ret;
6021
6022         tg = kzalloc(sizeof(*tg), GFP_KERNEL);
6023         if (!tg)
6024                 return ERR_PTR(-ENOMEM);
6025
6026         kref_init(&tg->refcount);
6027         memcpy(tg->group_data, topology, 8);
6028         tg->dev = dev;
6029
6030         mutex_lock(&dev->mode_config.idr_mutex);
6031         ret = idr_alloc(&dev->mode_config.tile_idr, tg, 1, 0, GFP_KERNEL);
6032         if (ret >= 0) {
6033                 tg->id = ret;
6034         } else {
6035                 kfree(tg);
6036                 tg = ERR_PTR(ret);
6037         }
6038
6039         mutex_unlock(&dev->mode_config.idr_mutex);
6040         return tg;
6041 }
6042 EXPORT_SYMBOL(drm_mode_create_tile_group);