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 struct drm_mode_object *__drm_mode_object_find(struct drm_device *dev,
 108                                                uint32_t id, uint32_t type)
 109 {
 110         struct drm_mode_object *obj = NULL;
 111
 112         mutex_lock(&dev->mode_config.idr_mutex);
 113         obj = idr_find(&dev->mode_config.crtc_idr, id);
 114         if (obj && type != DRM_MODE_OBJECT_ANY && obj->type != type)
 115                 obj = NULL;
 116         if (obj && obj->id != id)
 117                 obj = NULL;
 118
 119         if (obj && obj->free_cb) {
 120                 if (!kref_get_unless_zero(&obj->refcount))
 121                         obj = NULL;
 122         }
 123         mutex_unlock(&dev->mode_config.idr_mutex);
 124
 125         return obj;
 126 }
 127
 128 /**
 129  * drm_mode_object_find - look up a drm object with static lifetime
 130  * @dev: drm device
 131  * @id: id of the mode object
 132  * @type: type of the mode object
 133  *
 134  * This function is used to look up a modeset object. It will acquire a
 135  * reference for reference counted objects. This reference must be dropped again
 136  * by callind drm_mode_object_put().
 137  */
 138 struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
 139                 uint32_t id, uint32_t type)
 140 {
 141         struct drm_mode_object *obj = NULL;
 142
 143         obj = __drm_mode_object_find(dev, id, type);
 144         return obj;
 145 }
 146 EXPORT_SYMBOL(drm_mode_object_find);
 147
 148 /**
 149  * drm_mode_object_put - release a mode object reference
 150  * @obj: DRM mode object
 151  *
 152  * This function decrements the object's refcount if it is a refcounted modeset
 153  * object. It is a no-op on any other object. This is used to drop references
 154  * acquired with drm_mode_object_get().
 155  */
 156 void drm_mode_object_put(struct drm_mode_object *obj)
 157 {
 158         if (obj->free_cb) {
 159                 DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, kref_read(&obj->refcount));
 160                 kref_put(&obj->refcount, obj->free_cb);
 161         }
 162 }
 163 EXPORT_SYMBOL(drm_mode_object_put);
 164
 165 /**
 166  * drm_mode_object_get - acquire a mode object reference
 167  * @obj: DRM mode object
 168  *
 169  * This function increments the object's refcount if it is a refcounted modeset
 170  * object. It is a no-op on any other object. References should be dropped again
 171  * by calling drm_mode_object_put().
 172  */
 173 void drm_mode_object_get(struct drm_mode_object *obj)
 174 {
 175         if (obj->free_cb) {
 176                 DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, kref_read(&obj->refcount));
 177                 kref_get(&obj->refcount);
 178         }
 179 }
 180 EXPORT_SYMBOL(drm_mode_object_get);
 181
 182 /**
 183  * drm_object_attach_property - attach a property to a modeset object
 184  * @obj: drm modeset object
 185  * @property: property to attach
 186  * @init_val: initial value of the property
 187  *
 188  * This attaches the given property to the modeset object with the given initial
 189  * value. Currently this function cannot fail since the properties are stored in
 190  * a statically sized array.
 191  */
 192 void drm_object_attach_property(struct drm_mode_object *obj,
 193                                 struct drm_property *property,
 194                                 uint64_t init_val)
 195 {
 196         int count = obj->properties->count;
 197
 198         if (count == DRM_OBJECT_MAX_PROPERTY) {
 199                 WARN(1, "Failed to attach object property (type: 0x%x). Please "
 200                         "increase DRM_OBJECT_MAX_PROPERTY by 1 for each time "
 201                         "you see this message on the same object type.\n",
 202                         obj->type);
 203                 return;
 204         }
 205
 206         obj->properties->properties[count] = property;
 207         obj->properties->values[count] = init_val;
 208         obj->properties->count++;
 209 }
 210 EXPORT_SYMBOL(drm_object_attach_property);
 211
 212 /**
 213  * drm_object_property_set_value - set the value of a property
 214  * @obj: drm mode object to set property value for
 215  * @property: property to set
 216  * @val: value the property should be set to
 217  *
 218  * This function sets a given property on a given object. This function only
 219  * changes the software state of the property, it does not call into the
 220  * driver's ->set_property callback.
 221  *
 222  * Note that atomic drivers should not have any need to call this, the core will
 223  * ensure consistency of values reported back to userspace through the
 224  * appropriate ->atomic_get_property callback. Only legacy drivers should call
 225  * this function to update the tracked value (after clamping and other
 226  * restrictions have been applied).
 227  *
 228  * Returns:
 229  * Zero on success, error code on failure.
 230  */
 231 int drm_object_property_set_value(struct drm_mode_object *obj,
 232                                   struct drm_property *property, uint64_t val)
 233 {
 234         int i;
 235
 236         WARN_ON(drm_drv_uses_atomic_modeset(property->dev) &&
 237                 !(property->flags & DRM_MODE_PROP_IMMUTABLE));
 238
 239         for (i = 0; i < obj->properties->count; i++) {
 240                 if (obj->properties->properties[i] == property) {
 241                         obj->properties->values[i] = val;
 242                         return 0;
 243                 }
 244         }
 245
 246         return -EINVAL;
 247 }
 248 EXPORT_SYMBOL(drm_object_property_set_value);
 249
 250 int __drm_object_property_get_value(struct drm_mode_object *obj,
 251                                   struct drm_property *property, uint64_t *val)
 252 {
 253         int i;
 254
 255         /* read-only properties bypass atomic mechanism and still store
 256          * their value in obj->properties->values[].. mostly to avoid
 257          * having to deal w/ EDID and similar props in atomic paths:
 258          */
 259         if (drm_drv_uses_atomic_modeset(property->dev) &&
 260                         !(property->flags & DRM_MODE_PROP_IMMUTABLE))
 261                 return drm_atomic_get_property(obj, property, val);
 262
 263         for (i = 0; i < obj->properties->count; i++) {
 264                 if (obj->properties->properties[i] == property) {
 265                         *val = obj->properties->values[i];
 266                         return 0;
 267                 }
 268
 269         }
 270
 271         return -EINVAL;
 272 }
 273
 274 /**
 275  * drm_object_property_get_value - retrieve the value of a property
 276  * @obj: drm mode object to get property value from
 277  * @property: property to retrieve
 278  * @val: storage for the property value
 279  *
 280  * This function retrieves the softare state of the given property for the given
 281  * property. Since there is no driver callback to retrieve the current property
 282  * value this might be out of sync with the hardware, depending upon the driver
 283  * and property.
 284  *
 285  * Atomic drivers should never call this function directly, the core will read
 286  * out property values through the various ->atomic_get_property callbacks.
 287  *
 288  * Returns:
 289  * Zero on success, error code on failure.
 290  */
 291 int drm_object_property_get_value(struct drm_mode_object *obj,
 292                                   struct drm_property *property, uint64_t *val)
 293 {
 294         WARN_ON(drm_drv_uses_atomic_modeset(property->dev));
 295
 296         return __drm_object_property_get_value(obj, property, val);
 297 }
 298 EXPORT_SYMBOL(drm_object_property_get_value);
 299
 300 /* helper for getconnector and getproperties ioctls */
 301 int drm_mode_object_get_properties(struct drm_mode_object *obj, bool atomic,
 302                                    uint32_t __user *prop_ptr,
 303                                    uint64_t __user *prop_values,
 304                                    uint32_t *arg_count_props)
 305 {
 306         int i, ret, count;
 307
 308         for (i = 0, count = 0; i < obj->properties->count; i++) {
 309                 struct drm_property *prop = obj->properties->properties[i];
 310                 uint64_t val;
 311
 312                 if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)
 313                         continue;
 314
 315                 if (*arg_count_props > count) {
 316                         ret = __drm_object_property_get_value(obj, prop, &val);
 317                         if (ret)
 318                                 return ret;
 319
 320                         if (put_user(prop->base.id, prop_ptr + count))
 321                                 return -EFAULT;
 322
 323                         if (put_user(val, prop_values + count))
 324                                 return -EFAULT;
 325                 }
 326
 327                 count++;
 328         }
 329         *arg_count_props = count;
 330
 331         return 0;
 332 }
 333
 334 /**
 335  * drm_mode_obj_get_properties_ioctl - get the current value of a object's property
 336  * @dev: DRM device
 337  * @data: ioctl data
 338  * @file_priv: DRM file info
 339  *
 340  * This function retrieves the current value for an object's property. Compared
 341  * to the connector specific ioctl this one is extended to also work on crtc and
 342  * plane objects.
 343  *
 344  * Called by the user via ioctl.
 345  *
 346  * Returns:
 347  * Zero on success, negative errno on failure.
 348  */
 349 int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
 350                                       struct drm_file *file_priv)
 351 {
 352         struct drm_mode_obj_get_properties *arg = data;
 353         struct drm_mode_object *obj;
 354         int ret = 0;
 355
 356         if (!drm_core_check_feature(dev, DRIVER_MODESET))
 357                 return -EINVAL;
 358
 359         drm_modeset_lock_all(dev);
 360
 361         obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
 362         if (!obj) {
 363                 ret = -ENOENT;
 364                 goto out;
 365         }
 366         if (!obj->properties) {
 367                 ret = -EINVAL;
 368                 goto out_unref;
 369         }
 370
 371         ret = drm_mode_object_get_properties(obj, file_priv->atomic,
 372                         (uint32_t __user *)(unsigned long)(arg->props_ptr),
 373                         (uint64_t __user *)(unsigned long)(arg->prop_values_ptr),
 374                         &arg->count_props);
 375
 376 out_unref:
 377         drm_mode_object_put(obj);
 378 out:
 379         drm_modeset_unlock_all(dev);
 380         return ret;
 381 }
 382
 383 struct drm_property *drm_mode_obj_find_prop_id(struct drm_mode_object *obj,
 384                                                uint32_t prop_id)
 385 {
 386         int i;
 387
 388         for (i = 0; i < obj->properties->count; i++)
 389                 if (obj->properties->properties[i]->base.id == prop_id)
 390                         return obj->properties->properties[i];
 391
 392         return NULL;
 393 }
 394
 395 static int set_property_legacy(struct drm_mode_object *obj,
 396                                struct drm_property *prop,
 397                                uint64_t prop_value)
 398 {
 399         struct drm_device *dev = prop->dev;
 400         struct drm_mode_object *ref;
 401         int ret = -EINVAL;
 402
 403         if (!drm_property_change_valid_get(prop, prop_value, &ref))
 404                 return -EINVAL;
 405
 406         drm_modeset_lock_all(dev);
 407         switch (obj->type) {
 408         case DRM_MODE_OBJECT_CONNECTOR:
 409                 ret = drm_mode_connector_set_obj_prop(obj, prop,
 410                                                       prop_value);
 411                 break;
 412         case DRM_MODE_OBJECT_CRTC:
 413                 ret = drm_mode_crtc_set_obj_prop(obj, prop, prop_value);
 414                 break;
 415         case DRM_MODE_OBJECT_PLANE:
 416                 ret = drm_mode_plane_set_obj_prop(obj_to_plane(obj),
 417                                                   prop, prop_value);
 418                 break;
 419         }
 420         drm_property_change_valid_put(prop, ref);
 421         drm_modeset_unlock_all(dev);
 422
 423         return ret;
 424 }
 425
 426 static int set_property_atomic(struct drm_mode_object *obj,
 427                                struct drm_property *prop,
 428                                uint64_t prop_value)
 429 {
 430         struct drm_device *dev = prop->dev;
 431         struct drm_atomic_state *state;
 432         struct drm_modeset_acquire_ctx ctx;
 433         int ret;
 434
 435         drm_modeset_acquire_init(&ctx, 0);
 436
 437         state = drm_atomic_state_alloc(dev);
 438         if (!state)
 439                 return -ENOMEM;
 440         state->acquire_ctx = &ctx;
 441 retry:
 442         if (prop == state->dev->mode_config.dpms_property) {
 443                 if (obj->type != DRM_MODE_OBJECT_CONNECTOR) {
 444                         ret = -EINVAL;
 445                         goto out;
 446                 }
 447
 448                 ret = drm_atomic_connector_commit_dpms(state,
 449                                                        obj_to_connector(obj),
 450                                                        prop_value);
 451         } else {
 452                 ret = drm_atomic_set_property(state, obj, prop, prop_value);
 453                 if (ret)
 454                         goto out;
 455                 ret = drm_atomic_commit(state);
 456         }
 457 out:
 458         if (ret == -EDEADLK) {
 459                 drm_atomic_state_clear(state);
 460                 drm_modeset_backoff(&ctx);
 461                 goto retry;
 462         }
 463
 464         drm_atomic_state_put(state);
 465
 466         drm_modeset_drop_locks(&ctx);
 467         drm_modeset_acquire_fini(&ctx);
 468
 469         return ret;
 470 }
 471
 472 int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
 473                                     struct drm_file *file_priv)
 474 {
 475         struct drm_mode_obj_set_property *arg = data;
 476         struct drm_mode_object *arg_obj;
 477         struct drm_property *property;
 478         int ret = -EINVAL;
 479
 480         if (!drm_core_check_feature(dev, DRIVER_MODESET))
 481                 return -EINVAL;
 482
 483         arg_obj = drm_mode_object_find(dev, arg->obj_id, arg->obj_type);
 484         if (!arg_obj)
 485                 return -ENOENT;
 486
 487         if (!arg_obj->properties)
 488                 goto out_unref;
 489
 490         property = drm_mode_obj_find_prop_id(arg_obj, arg->prop_id);
 491         if (!property)
 492                 goto out_unref;
 493
 494         if (drm_drv_uses_atomic_modeset(property->dev))
 495                 ret = set_property_atomic(arg_obj, property, arg->value);
 496         else
 497                 ret = set_property_legacy(arg_obj, property, arg->value);
 498
 499 out_unref:
 500         drm_mode_object_put(arg_obj);
 501         return ret;
 502 }