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