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