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