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