drivers/gpu/drm/drm_mode_object.c

   1 /*
   2  * Copyright (c) 2016 Intel Corporation
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting documentation, and
   8  * that the name of the copyright holders not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  The copyright holders make no representations
  11  * about the suitability of this software for any purpose.  It is provided "as
  12  * is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20  * OF THIS SOFTWARE.
  21  */
  22
  23 #include <linux/export.h>
  24 #include <linux/uaccess.h>
  25
  26 #include <drm/drm_atomic.h>
  27 #include <drm/drm_drv.h>
  28 #include <drm/drm_device.h>
  29 #include <drm/drm_file.h>
  30 #include <drm/drm_mode_object.h>
  31 #include <drm/drm_print.h>
  32
  33 #include "drm_crtc_internal.h"
  34
  35 /*
  36  * Internal function to assign a slot in the object idr and optionally
  37  * register the object into the idr.
  38  */
  39 int __drm_mode_object_add(struct drm_device *dev, struct drm_mode_object *obj,
  40                           uint32_t obj_type, bool register_obj,
  41                           void (*obj_free_cb)(struct kref *kref))
  42 {
  43         int ret;
  44
  45         mutex_lock(&dev->mode_config.idr_mutex);
  46         ret = idr_alloc(&dev->mode_config.object_idr, register_obj ? obj : NULL,
  47                         1, 0, GFP_KERNEL);
  48         if (ret >= 0) {
  49                 /*
  50                  * Set up the object linking under the protection of the idr
  51                  * lock so that other users can't see inconsistent state.
  52                  */
  53                 obj->id = ret;
  54                 obj->type = obj_type;
  55                 if (obj_free_cb) {
  56                         obj->free_cb = obj_free_cb;
  57                         kref_init(&obj->refcount);
  58                 }
  59         }
  60         mutex_unlock(&dev->mode_config.idr_mutex);
  61
  62         return ret < 0 ? ret : 0;
  63 }
  64
  65 /**
  66  * drm_mode_object_add - allocate a new modeset identifier
  67  * @dev: DRM device
  68  * @obj: object pointer, used to generate unique ID
  69  * @obj_type: object type
  70  *
  71  * Create a unique identifier based on @ptr in @dev's identifier space.  Used
  72  * for tracking modes, CRTCs and connectors.
  73  *
  74  * Returns:
  75  * Zero on success, error code on failure.
  76  */
  77 int drm_mode_object_add(struct drm_device *dev,
  78                         struct drm_mode_object *obj, uint32_t obj_type)
  79 {
  80         return __drm_mode_object_add(dev, obj, obj_type, true, NULL);
  81 }
  82
  83 void drm_mode_object_register(struct drm_device *dev,
  84                               struct drm_mode_object *obj)
  85 {
  86         mutex_lock(&dev->mode_config.idr_mutex);
  87         idr_replace(&dev->mode_config.object_idr, obj, obj->id);
  88         mutex_unlock(&dev->mode_config.idr_mutex);
  89 }
  90
  91 /**
  92  * drm_mode_object_unregister - free a modeset identifer
  93  * @dev: DRM device
  94  * @object: object to free
  95  *
  96  * Free @id from @dev's unique identifier pool.
  97  * This function can be called multiple times, and guards against
  98  * multiple removals.
  99  * These modeset identifiers are _not_ reference counted. Hence don't use this
 100  * for reference counted modeset objects like framebuffers.
 101  */
 102 void drm_mode_object_unregister(struct drm_device *dev,
 103                                 struct drm_mode_object *object)
 104 {
 105         mutex_lock(&dev->mode_config.idr_mutex);
 106         if (object->id) {
 107                 idr_remove(&dev->mode_config.object_idr, object->id);
 108                 object->id = 0;
 109         }
 110         mutex_unlock(&dev->mode_config.idr_mutex);
 111 }
 112
 113 /**
 114  * drm_lease_required - check types which must be leased to be used
 115  * @type: type of object
 116  *
 117  * Returns whether the provided type of drm_mode_object must
 118  * be owned or leased to be used by a process.
 119  */
 120 bool drm_mode_object_lease_required(uint32_t type)
 121 {
 122         switch(type) {
 123         case DRM_MODE_OBJECT_CRTC:
 124         case DRM_MODE_OBJECT_CONNECTOR:
 125         case DRM_MODE_OBJECT_PLANE:
 126                 return true;
 127         default:
 128                 return false;
 129         }
 130 }
 131
 132 struct drm_mode_object *__drm_mode_object_find(struct drm_device *dev,
 133                                                struct drm_file *file_priv,
 134                                                uint32_t id, uint32_t type)
 135 {
 136         struct drm_mode_object *obj = NULL;
 137
 138         mutex_lock(&dev->mode_config.idr_mutex);
 139         obj = idr_find(&dev->mode_config.object_idr, id);
 140         if (obj && type != DRM_MODE_OBJECT_ANY && obj->type != type)
 141                 obj = NULL;
 142         if (obj && obj->id != id)
 143                 obj = NULL;
 144
 145         if (obj && drm_mode_object_lease_required(obj->type) &&
 146             !_drm_lease_held(file_priv, obj->id))
 147                 obj = NULL;
 148
 149         if (obj && obj->free_cb) {
 150                 if (!kref_get_unless_zero(&obj->refcount))
 151                         obj = NULL;
 152         }
 153         mutex_unlock(&dev->mode_config.idr_mutex);
 154
 155         return obj;
 156 }
 157
 158 /**
 159  * drm_mode_object_find - look up a drm object with static lifetime
 160  * @dev: drm device
 161  * @file_priv: drm file
 162  * @id: id of the mode object
 163  * @type: type of the mode object
 164  *
 165  * This function is used to look up a modeset object. It will acquire a
 166  * reference for reference counted objects. This reference must be dropped again
 167  * by callind drm_mode_object_put().
 168  */
 169 struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
 170                 struct drm_file *file_priv,
 171                 uint32_t id, uint32_t type)
 172 {
 173         struct drm_mode_object *obj = NULL;
 174
 175         obj = __drm_mode_object_find(dev, file_priv, id, type);
 176         return obj;
 177 }
 178 EXPORT_SYMBOL(drm_mode_object_find);
 179
 180 /**
 181  * drm_mode_object_put - release a mode object reference
 182  * @obj: DRM mode object
 183  *
 184  * This function decrements the object's refcount if it is a refcounted modeset
 185  * object. It is a no-op on any other object. This is used to drop references
 186  * acquired with drm_mode_object_get().
 187  */
 188 void drm_mode_object_put(struct drm_mode_object *obj)
 189 {
 190         if (obj->free_cb) {
 191                 DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, kref_read(&obj->refcount));
 192                 kref_put(&obj->refcount, obj->free_cb);
 193         }
 194 }
 195 EXPORT_SYMBOL(drm_mode_object_put);
 196
 197 /**
 198  * drm_mode_object_get - acquire a mode object reference
 199  * @obj: DRM mode object
 200  *
 201  * This function increments the object's refcount if it is a refcounted modeset
 202  * object. It is a no-op on any other object. References should be dropped again
 203  * by calling drm_mode_object_put().
 204  */
 205 void drm_mode_object_get(struct drm_mode_object *obj)
 206 {
 207         if (obj->free_cb) {
 208                 DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, kref_read(&obj->refcount));
 209                 kref_get(&obj->refcount);
 210         }
 211 }
 212 EXPORT_SYMBOL(drm_mode_object_get);
 213
 214 /**
 215  * drm_object_attach_property - attach a property to a modeset object
 216  * @obj: drm modeset object
 217  * @property: property to attach
 218  * @init_val: initial value of the property
 219  *
 220  * This attaches the given property to the modeset object with the given initial
 221  * value. Currently this function cannot fail since the properties are stored in
 222  * a statically sized array.
 223  */
 224 void drm_object_attach_property(struct drm_mode_object *obj,
 225                                 struct drm_property *property,
 226                                 uint64_t init_val)
 227 {
 228         int count = obj->properties->count;
 229
 230         if (count == DRM_OBJECT_MAX_PROPERTY) {
 231                 WARN(1, "Failed to attach object property (type: 0x%x). Please "
 232                         "increase DRM_OBJECT_MAX_PROPERTY by 1 for each time "
 233                         "you see this message on the same object type.\n",
 234                         obj->type);
 235                 return;
 236         }
 237
 238         obj->properties->properties[count] = property;
 239         obj->properties->values[count] = init_val;
 240         obj->properties->count++;
 241 }
 242 EXPORT_SYMBOL(drm_object_attach_property);
 243
 244 /**
 245  * drm_object_property_set_value - set the value of a property
 246  * @obj: drm mode object to set property value for
 247  * @property: property to set
 248  * @val: value the property should be set to
 249  *
 250  * This function sets a given property on a given object. This function only
 251  * changes the software state of the property, it does not call into the
 252  * driver's ->set_property callback.
 253  *
 254  * Note that atomic drivers should not have any need to call this, the core will
 255  * ensure consistency of values reported back to userspace through the
 256  * appropriate ->atomic_get_property callback. Only legacy drivers should call
 257  * this function to update the tracked value (after clamping and other
 258  * restrictions have been applied).
 259  *
 260  * Returns:
 261  * Zero on success, error code on failure.
 262  */
 263 int drm_object_property_set_value(struct drm_mode_object *obj,
 264                                   struct drm_property *property, uint64_t val)
 265 {
 266         int i;
 267
 268         WARN_ON(drm_drv_uses_atomic_modeset(property->dev) &&
 269                 !(property->flags & DRM_MODE_PROP_IMMUTABLE));
 270
 271         for (i = 0; i < obj->properties->count; i++) {
 272                 if (obj->properties->properties[i] == property) {
 273                         obj->properties->values[i] = val;
 274                         return 0;
 275                 }
 276         }
 277
 278         return -EINVAL;
 279 }
 280 EXPORT_SYMBOL(drm_object_property_set_value);
 281
 282 static int __drm_object_property_get_value(struct drm_mode_object *obj,
 283                                            struct drm_property *property,
 284                                            uint64_t *val)
 285 {
 286         int i;
 287
 288         /* read-only properties bypass atomic mechanism and still store
 289          * their value in obj->properties->values[].. mostly to avoid
 290          * having to deal w/ EDID and similar props in atomic paths:
 291          */
 292         if (drm_drv_uses_atomic_modeset(property->dev) &&
 293                         !(property->flags & DRM_MODE_PROP_IMMUTABLE))
 294                 return drm_atomic_get_property(obj, property, val);
 295
 296         for (i = 0; i < obj->properties->count; i++) {
 297                 if (obj->properties->properties[i] == property) {
 298                         *val = obj->properties->values[i];
 299                         return 0;
 300                 }
 301
 302         }
 303
 304         return -EINVAL;
 305 }
 306
 307 /**
 308  * drm_object_property_get_value - retrieve the value of a property
 309  * @obj: drm mode object to get property value from
 310  * @property: property to retrieve
 311  * @val: storage for the property value
 312  *
 313  * This function retrieves the softare state of the given property for the given
 314  * property. Since there is no driver callback to retrieve the current property
 315  * value this might be out of sync with the hardware, depending upon the driver
 316  * and property.
 317  *
 318  * Atomic drivers should never call this function directly, the core will read
 319  * out property values through the various ->atomic_get_property callbacks.
 320  *
 321  * Returns:
 322  * Zero on success, error code on failure.
 323  */
 324 int drm_object_property_get_value(struct drm_mode_object *obj,
 325                                   struct drm_property *property, uint64_t *val)
 326 {
 327         WARN_ON(drm_drv_uses_atomic_modeset(property->dev));
 328
 329         return __drm_object_property_get_value(obj, property, val);
 330 }
 331 EXPORT_SYMBOL(drm_object_property_get_value);
 332
 333 /* helper for getconnector and getproperties ioctls */
 334 int drm_mode_object_get_properties(struct drm_mode_object *obj, bool atomic,
 335                                    uint32_t __user *prop_ptr,
 336                                    uint64_t __user *prop_values,
 337                                    uint32_t *arg_count_props)
 338 {
 339         int i, ret, count;
 340
 341         for (i = 0, count = 0; i < obj->properties->count; i++) {
 342                 struct drm_property *prop = obj->properties->properties[i];
 343                 uint64_t val;
 344
 345                 if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)
 346                         continue;
 347
 348                 if (*arg_count_props > count) {
 349                         ret = __drm_object_property_get_value(obj, prop, &val);
 350                         if (ret)
 351                                 return ret;
 352
 353                         if (put_user(prop->base.id, prop_ptr + count))
 354                                 return -EFAULT;
 355
 356                         if (put_user(val, prop_values + count))
 357                                 return -EFAULT;
 358                 }
 359
 360                 count++;
 361         }
 362         *arg_count_props = count;
 363
 364         return 0;
 365 }
 366
 367 /**
 368  * drm_mode_obj_get_properties_ioctl - get the current value of a object's property
 369  * @dev: DRM device
 370  * @data: ioctl data
 371  * @file_priv: DRM file info
 372  *
 373  * This function retrieves the current value for an object's property. Compared
 374  * to the connector specific ioctl this one is extended to also work on crtc and
 375  * plane objects.
 376  *
 377  * Called by the user via ioctl.
 378  *
 379  * Returns:
 380  * Zero on success, negative errno on failure.
 381  */
 382 int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
 383                                       struct drm_file *file_priv)
 384 {
 385         struct drm_mode_obj_get_properties *arg = data;
 386         struct drm_mode_object *obj;
 387         int ret = 0;
 388
 389         if (!drm_core_check_feature(dev, DRIVER_MODESET))
 390                 return -EOPNOTSUPP;
 391
 392         drm_modeset_lock_all(dev);
 393
 394         obj = drm_mode_object_find(dev, file_priv, arg->obj_id, arg->obj_type);
 395         if (!obj) {
 396                 ret = -ENOENT;
 397                 goto out;
 398         }
 399         if (!obj->properties) {
 400                 ret = -EINVAL;
 401                 goto out_unref;
 402         }
 403
 404         ret = drm_mode_object_get_properties(obj, file_priv->atomic,
 405                         (uint32_t __user *)(unsigned long)(arg->props_ptr),
 406                         (uint64_t __user *)(unsigned long)(arg->prop_values_ptr),
 407                         &arg->count_props);
 408
 409 out_unref:
 410         drm_mode_object_put(obj);
 411 out:
 412         drm_modeset_unlock_all(dev);
 413         return ret;
 414 }
 415
 416 struct drm_property *drm_mode_obj_find_prop_id(struct drm_mode_object *obj,
 417                                                uint32_t prop_id)
 418 {
 419         int i;
 420
 421         for (i = 0; i < obj->properties->count; i++)
 422                 if (obj->properties->properties[i]->base.id == prop_id)
 423                         return obj->properties->properties[i];
 424
 425         return NULL;
 426 }
 427
 428 static int set_property_legacy(struct drm_mode_object *obj,
 429                                struct drm_property *prop,
 430                                uint64_t prop_value)
 431 {
 432         struct drm_device *dev = prop->dev;
 433         struct drm_mode_object *ref;
 434         int ret = -EINVAL;
 435
 436         if (!drm_property_change_valid_get(prop, prop_value, &ref))
 437                 return -EINVAL;
 438
 439         drm_modeset_lock_all(dev);
 440         switch (obj->type) {
 441         case DRM_MODE_OBJECT_CONNECTOR:
 442                 ret = drm_connector_set_obj_prop(obj, prop, prop_value);
 443                 break;
 444         case DRM_MODE_OBJECT_CRTC:
 445                 ret = drm_mode_crtc_set_obj_prop(obj, prop, prop_value);
 446                 break;
 447         case DRM_MODE_OBJECT_PLANE:
 448                 ret = drm_mode_plane_set_obj_prop(obj_to_plane(obj),
 449                                                   prop, prop_value);
 450                 break;
 451         }
 452         drm_property_change_valid_put(prop, ref);
 453         drm_modeset_unlock_all(dev);
 454
 455         return ret;
 456 }
 457
 458 static int set_property_atomic(struct drm_mode_object *obj,
 459                                struct drm_file *file_priv,
 460                                struct drm_property *prop,
 461                                uint64_t prop_value)
 462 {
 463         struct drm_device *dev = prop->dev;
 464         struct drm_atomic_state *state;
 465         struct drm_modeset_acquire_ctx ctx;
 466         int ret;
 467
 468         state = drm_atomic_state_alloc(dev);
 469         if (!state)
 470                 return -ENOMEM;
 471
 472         drm_modeset_acquire_init(&ctx, 0);
 473         state->acquire_ctx = &ctx;
 474
 475 retry:
 476         if (prop == state->dev->mode_config.dpms_property) {
 477                 if (obj->type != DRM_MODE_OBJECT_CONNECTOR) {
 478                         ret = -EINVAL;
 479                         goto out;
 480                 }
 481
 482                 ret = drm_atomic_connector_commit_dpms(state,
 483                                                        obj_to_connector(obj),
 484                                                        prop_value);
 485         } else {
 486                 ret = drm_atomic_set_property(state, file_priv, obj, prop, prop_value);
 487                 if (ret)
 488                         goto out;
 489                 ret = drm_atomic_commit(state);
 490         }
 491 out:
 492         if (ret == -EDEADLK) {
 493                 drm_atomic_state_clear(state);
 494                 drm_modeset_backoff(&ctx);
 495                 goto retry;
 496         }
 497
 498         drm_atomic_state_put(state);
 499
 500         drm_modeset_drop_locks(&ctx);
 501         drm_modeset_acquire_fini(&ctx);
 502
 503         return ret;
 504 }
 505
 506 int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
 507                                     struct drm_file *file_priv)
 508 {
 509         struct drm_mode_obj_set_property *arg = data;
 510         struct drm_mode_object *arg_obj;
 511         struct drm_property *property;
 512         int ret = -EINVAL;
 513
 514         if (!drm_core_check_feature(dev, DRIVER_MODESET))
 515                 return -EOPNOTSUPP;
 516
 517         arg_obj = drm_mode_object_find(dev, file_priv, arg->obj_id, arg->obj_type);
 518         if (!arg_obj)
 519                 return -ENOENT;
 520
 521         if (!arg_obj->properties)
 522                 goto out_unref;
 523
 524         property = drm_mode_obj_find_prop_id(arg_obj, arg->prop_id);
 525         if (!property)
 526                 goto out_unref;
 527
 528         if (drm_drv_uses_atomic_modeset(property->dev))
 529                 ret = set_property_atomic(arg_obj, file_priv, property, arg->value);
 530         else
 531                 ret = set_property_legacy(arg_obj, property, arg->value);
 532
 533 out_unref:
 534         drm_mode_object_put(arg_obj);
 535         return ret;
 536 }