drivers/gpu/drm/drm_crtc.c

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