593 lines · c
1/*2 * Copyright (c) 2016 Intel Corporation3 *4 * Permission to use, copy, modify, distribute, and sell this software and its5 * documentation for any purpose is hereby granted without fee, provided that6 * the above copyright notice appear in all copies and that both that copyright7 * notice and this permission notice appear in supporting documentation, and8 * that the name of the copyright holders not be used in advertising or9 * publicity pertaining to distribution of the software without specific,10 * written prior permission. The copyright holders make no representations11 * about the suitability of this software for any purpose. It is provided "as12 * 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 NO16 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE20 * 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 optionally37 * register the object into the idr.38 */39int __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 WARN_ON(!dev->driver->load && dev->registered && !obj_free_cb);46 47 mutex_lock(&dev->mode_config.idr_mutex);48 ret = idr_alloc(&dev->mode_config.object_idr, register_obj ? obj : NULL,49 1, 0, GFP_KERNEL);50 if (ret >= 0) {51 /*52 * Set up the object linking under the protection of the idr53 * lock so that other users can't see inconsistent state.54 */55 obj->id = ret;56 obj->type = obj_type;57 if (obj_free_cb) {58 obj->free_cb = obj_free_cb;59 kref_init(&obj->refcount);60 }61 }62 mutex_unlock(&dev->mode_config.idr_mutex);63 64 return ret < 0 ? ret : 0;65}66 67/**68 * drm_mode_object_add - allocate a new modeset identifier69 * @dev: DRM device70 * @obj: object pointer, used to generate unique ID71 * @obj_type: object type72 *73 * Create a unique identifier based on @ptr in @dev's identifier space. Used74 * for tracking modes, CRTCs and connectors.75 *76 * Returns:77 * Zero on success, error code on failure.78 */79int drm_mode_object_add(struct drm_device *dev,80 struct drm_mode_object *obj, uint32_t obj_type)81{82 return __drm_mode_object_add(dev, obj, obj_type, true, NULL);83}84 85void drm_mode_object_register(struct drm_device *dev,86 struct drm_mode_object *obj)87{88 mutex_lock(&dev->mode_config.idr_mutex);89 idr_replace(&dev->mode_config.object_idr, obj, obj->id);90 mutex_unlock(&dev->mode_config.idr_mutex);91}92 93/**94 * drm_mode_object_unregister - free a modeset identifier95 * @dev: DRM device96 * @object: object to free97 *98 * Free @id from @dev's unique identifier pool.99 * This function can be called multiple times, and guards against100 * multiple removals.101 * These modeset identifiers are _not_ reference counted. Hence don't use this102 * for reference counted modeset objects like framebuffers.103 */104void drm_mode_object_unregister(struct drm_device *dev,105 struct drm_mode_object *object)106{107 WARN_ON(!dev->driver->load && dev->registered && !object->free_cb);108 109 mutex_lock(&dev->mode_config.idr_mutex);110 if (object->id) {111 idr_remove(&dev->mode_config.object_idr, object->id);112 object->id = 0;113 }114 mutex_unlock(&dev->mode_config.idr_mutex);115}116 117/**118 * drm_mode_object_lease_required - check types which must be leased to be used119 * @type: type of object120 *121 * Returns whether the provided type of drm_mode_object must122 * be owned or leased to be used by a process.123 */124bool drm_mode_object_lease_required(uint32_t type)125{126 switch(type) {127 case DRM_MODE_OBJECT_CRTC:128 case DRM_MODE_OBJECT_CONNECTOR:129 case DRM_MODE_OBJECT_PLANE:130 return true;131 default:132 return false;133 }134}135 136struct drm_mode_object *__drm_mode_object_find(struct drm_device *dev,137 struct drm_file *file_priv,138 uint32_t id, uint32_t type)139{140 struct drm_mode_object *obj = NULL;141 142 mutex_lock(&dev->mode_config.idr_mutex);143 obj = idr_find(&dev->mode_config.object_idr, id);144 if (obj && type != DRM_MODE_OBJECT_ANY && obj->type != type)145 obj = NULL;146 if (obj && obj->id != id)147 obj = NULL;148 149 if (obj && drm_mode_object_lease_required(obj->type) &&150 !_drm_lease_held(file_priv, obj->id)) {151 drm_dbg_kms(dev, "[OBJECT:%d] not included in lease", id);152 obj = NULL;153 }154 155 if (obj && obj->free_cb) {156 if (!kref_get_unless_zero(&obj->refcount))157 obj = NULL;158 }159 mutex_unlock(&dev->mode_config.idr_mutex);160 161 return obj;162}163 164/**165 * drm_mode_object_find - look up a drm object with static lifetime166 * @dev: drm device167 * @file_priv: drm file168 * @id: id of the mode object169 * @type: type of the mode object170 *171 * This function is used to look up a modeset object. It will acquire a172 * reference for reference counted objects. This reference must be dropped again173 * by callind drm_mode_object_put().174 */175struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,176 struct drm_file *file_priv,177 uint32_t id, uint32_t type)178{179 struct drm_mode_object *obj = NULL;180 181 obj = __drm_mode_object_find(dev, file_priv, id, type);182 return obj;183}184EXPORT_SYMBOL(drm_mode_object_find);185 186/**187 * drm_mode_object_put - release a mode object reference188 * @obj: DRM mode object189 *190 * This function decrements the object's refcount if it is a refcounted modeset191 * object. It is a no-op on any other object. This is used to drop references192 * acquired with drm_mode_object_get().193 */194void drm_mode_object_put(struct drm_mode_object *obj)195{196 if (obj->free_cb) {197 DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, kref_read(&obj->refcount));198 kref_put(&obj->refcount, obj->free_cb);199 }200}201EXPORT_SYMBOL(drm_mode_object_put);202 203/**204 * drm_mode_object_get - acquire a mode object reference205 * @obj: DRM mode object206 *207 * This function increments the object's refcount if it is a refcounted modeset208 * object. It is a no-op on any other object. References should be dropped again209 * by calling drm_mode_object_put().210 */211void drm_mode_object_get(struct drm_mode_object *obj)212{213 if (obj->free_cb) {214 DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, kref_read(&obj->refcount));215 kref_get(&obj->refcount);216 }217}218EXPORT_SYMBOL(drm_mode_object_get);219 220/**221 * drm_object_attach_property - attach a property to a modeset object222 * @obj: drm modeset object223 * @property: property to attach224 * @init_val: initial value of the property225 *226 * This attaches the given property to the modeset object with the given initial227 * value. Currently this function cannot fail since the properties are stored in228 * a statically sized array.229 *230 * Note that all properties must be attached before the object itself is231 * registered and accessible from userspace.232 */233void drm_object_attach_property(struct drm_mode_object *obj,234 struct drm_property *property,235 uint64_t init_val)236{237 int count = obj->properties->count;238 struct drm_device *dev = property->dev;239 240 241 if (obj->type == DRM_MODE_OBJECT_CONNECTOR) {242 struct drm_connector *connector = obj_to_connector(obj);243 244 WARN_ON(!dev->driver->load &&245 connector->registration_state == DRM_CONNECTOR_REGISTERED);246 } else {247 WARN_ON(!dev->driver->load && dev->registered);248 }249 250 if (count == DRM_OBJECT_MAX_PROPERTY) {251 WARN(1, "Failed to attach object property (type: 0x%x). Please "252 "increase DRM_OBJECT_MAX_PROPERTY by 1 for each time "253 "you see this message on the same object type.\n",254 obj->type);255 return;256 }257 258 obj->properties->properties[count] = property;259 obj->properties->values[count] = init_val;260 obj->properties->count++;261}262EXPORT_SYMBOL(drm_object_attach_property);263 264/**265 * drm_object_property_set_value - set the value of a property266 * @obj: drm mode object to set property value for267 * @property: property to set268 * @val: value the property should be set to269 *270 * This function sets a given property on a given object. This function only271 * changes the software state of the property, it does not call into the272 * driver's ->set_property callback.273 *274 * Note that atomic drivers should not have any need to call this, the core will275 * ensure consistency of values reported back to userspace through the276 * appropriate ->atomic_get_property callback. Only legacy drivers should call277 * this function to update the tracked value (after clamping and other278 * restrictions have been applied).279 *280 * Returns:281 * Zero on success, error code on failure.282 */283int drm_object_property_set_value(struct drm_mode_object *obj,284 struct drm_property *property, uint64_t val)285{286 int i;287 288 WARN_ON(drm_drv_uses_atomic_modeset(property->dev) &&289 !(property->flags & DRM_MODE_PROP_IMMUTABLE));290 291 for (i = 0; i < obj->properties->count; i++) {292 if (obj->properties->properties[i] == property) {293 obj->properties->values[i] = val;294 return 0;295 }296 }297 298 return -EINVAL;299}300EXPORT_SYMBOL(drm_object_property_set_value);301 302static int __drm_object_property_get_prop_value(struct drm_mode_object *obj,303 struct drm_property *property,304 uint64_t *val)305{306 int i;307 308 for (i = 0; i < obj->properties->count; i++) {309 if (obj->properties->properties[i] == property) {310 *val = obj->properties->values[i];311 return 0;312 }313 }314 315 return -EINVAL;316}317 318static int __drm_object_property_get_value(struct drm_mode_object *obj,319 struct drm_property *property,320 uint64_t *val)321{322 323 /* read-only properties bypass atomic mechanism and still store324 * their value in obj->properties->values[].. mostly to avoid325 * having to deal w/ EDID and similar props in atomic paths:326 */327 if (drm_drv_uses_atomic_modeset(property->dev) &&328 !(property->flags & DRM_MODE_PROP_IMMUTABLE))329 return drm_atomic_get_property(obj, property, val);330 331 return __drm_object_property_get_prop_value(obj, property, val);332}333 334/**335 * drm_object_property_get_value - retrieve the value of a property336 * @obj: drm mode object to get property value from337 * @property: property to retrieve338 * @val: storage for the property value339 *340 * This function retrieves the softare state of the given property for the given341 * property. Since there is no driver callback to retrieve the current property342 * value this might be out of sync with the hardware, depending upon the driver343 * and property.344 *345 * Atomic drivers should never call this function directly, the core will read346 * out property values through the various ->atomic_get_property callbacks.347 *348 * Returns:349 * Zero on success, error code on failure.350 */351int drm_object_property_get_value(struct drm_mode_object *obj,352 struct drm_property *property, uint64_t *val)353{354 WARN_ON(drm_drv_uses_atomic_modeset(property->dev));355 356 return __drm_object_property_get_value(obj, property, val);357}358EXPORT_SYMBOL(drm_object_property_get_value);359 360/**361 * drm_object_property_get_default_value - retrieve the default value of a362 * property when in atomic mode.363 * @obj: drm mode object to get property value from364 * @property: property to retrieve365 * @val: storage for the property value366 *367 * This function retrieves the default state of the given property as passed in368 * to drm_object_attach_property369 *370 * Only atomic drivers should call this function directly, as for non-atomic371 * drivers it will return the current value.372 *373 * Returns:374 * Zero on success, error code on failure.375 */376int drm_object_property_get_default_value(struct drm_mode_object *obj,377 struct drm_property *property,378 uint64_t *val)379{380 WARN_ON(!drm_drv_uses_atomic_modeset(property->dev));381 382 return __drm_object_property_get_prop_value(obj, property, val);383}384EXPORT_SYMBOL(drm_object_property_get_default_value);385 386/* helper for getconnector and getproperties ioctls */387int drm_mode_object_get_properties(struct drm_mode_object *obj, bool atomic,388 uint32_t __user *prop_ptr,389 uint64_t __user *prop_values,390 uint32_t *arg_count_props)391{392 int i, ret, count;393 394 for (i = 0, count = 0; i < obj->properties->count; i++) {395 struct drm_property *prop = obj->properties->properties[i];396 uint64_t val;397 398 if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)399 continue;400 401 if (*arg_count_props > count) {402 ret = __drm_object_property_get_value(obj, prop, &val);403 if (ret)404 return ret;405 406 if (put_user(prop->base.id, prop_ptr + count))407 return -EFAULT;408 409 if (put_user(val, prop_values + count))410 return -EFAULT;411 }412 413 count++;414 }415 *arg_count_props = count;416 417 return 0;418}419 420/**421 * drm_mode_obj_get_properties_ioctl - get the current value of a object's property422 * @dev: DRM device423 * @data: ioctl data424 * @file_priv: DRM file info425 *426 * This function retrieves the current value for an object's property. Compared427 * to the connector specific ioctl this one is extended to also work on crtc and428 * plane objects.429 *430 * Called by the user via ioctl.431 *432 * Returns:433 * Zero on success, negative errno on failure.434 */435int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,436 struct drm_file *file_priv)437{438 struct drm_mode_obj_get_properties *arg = data;439 struct drm_mode_object *obj;440 struct drm_modeset_acquire_ctx ctx;441 int ret = 0;442 443 if (!drm_core_check_feature(dev, DRIVER_MODESET))444 return -EOPNOTSUPP;445 446 DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, ret);447 448 obj = drm_mode_object_find(dev, file_priv, arg->obj_id, arg->obj_type);449 if (!obj) {450 ret = -ENOENT;451 goto out;452 }453 if (!obj->properties) {454 ret = -EINVAL;455 goto out_unref;456 }457 458 ret = drm_mode_object_get_properties(obj, file_priv->atomic,459 (uint32_t __user *)(unsigned long)(arg->props_ptr),460 (uint64_t __user *)(unsigned long)(arg->prop_values_ptr),461 &arg->count_props);462 463out_unref:464 drm_mode_object_put(obj);465out:466 DRM_MODESET_LOCK_ALL_END(dev, ctx, ret);467 return ret;468}469 470struct drm_property *drm_mode_obj_find_prop_id(struct drm_mode_object *obj,471 uint32_t prop_id)472{473 int i;474 475 for (i = 0; i < obj->properties->count; i++)476 if (obj->properties->properties[i]->base.id == prop_id)477 return obj->properties->properties[i];478 479 return NULL;480}481EXPORT_SYMBOL_FOR_TESTS_ONLY(drm_mode_obj_find_prop_id);482 483static int set_property_legacy(struct drm_mode_object *obj,484 struct drm_property *prop,485 uint64_t prop_value)486{487 struct drm_device *dev = prop->dev;488 struct drm_mode_object *ref;489 struct drm_modeset_acquire_ctx ctx;490 int ret = -EINVAL;491 492 if (!drm_property_change_valid_get(prop, prop_value, &ref))493 return -EINVAL;494 495 DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, ret);496 switch (obj->type) {497 case DRM_MODE_OBJECT_CONNECTOR:498 ret = drm_connector_set_obj_prop(obj, prop, prop_value);499 break;500 case DRM_MODE_OBJECT_CRTC:501 ret = drm_mode_crtc_set_obj_prop(obj, prop, prop_value);502 break;503 case DRM_MODE_OBJECT_PLANE:504 ret = drm_mode_plane_set_obj_prop(obj_to_plane(obj),505 prop, prop_value);506 break;507 }508 drm_property_change_valid_put(prop, ref);509 DRM_MODESET_LOCK_ALL_END(dev, ctx, ret);510 511 return ret;512}513 514static int set_property_atomic(struct drm_mode_object *obj,515 struct drm_file *file_priv,516 struct drm_property *prop,517 uint64_t prop_value)518{519 struct drm_device *dev = prop->dev;520 struct drm_atomic_state *state;521 struct drm_modeset_acquire_ctx ctx;522 int ret;523 524 state = drm_atomic_state_alloc(dev);525 if (!state)526 return -ENOMEM;527 528 drm_modeset_acquire_init(&ctx, 0);529 state->acquire_ctx = &ctx;530 531retry:532 if (prop == state->dev->mode_config.dpms_property) {533 if (obj->type != DRM_MODE_OBJECT_CONNECTOR) {534 ret = -EINVAL;535 goto out;536 }537 538 ret = drm_atomic_connector_commit_dpms(state,539 obj_to_connector(obj),540 prop_value);541 } else {542 ret = drm_atomic_set_property(state, file_priv, obj, prop, prop_value, false);543 if (ret)544 goto out;545 ret = drm_atomic_commit(state);546 }547out:548 if (ret == -EDEADLK) {549 drm_atomic_state_clear(state);550 drm_modeset_backoff(&ctx);551 goto retry;552 }553 554 drm_atomic_state_put(state);555 556 drm_modeset_drop_locks(&ctx);557 drm_modeset_acquire_fini(&ctx);558 559 return ret;560}561 562int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,563 struct drm_file *file_priv)564{565 struct drm_mode_obj_set_property *arg = data;566 struct drm_mode_object *arg_obj;567 struct drm_property *property;568 int ret = -EINVAL;569 570 if (!drm_core_check_feature(dev, DRIVER_MODESET))571 return -EOPNOTSUPP;572 573 arg_obj = drm_mode_object_find(dev, file_priv, arg->obj_id, arg->obj_type);574 if (!arg_obj)575 return -ENOENT;576 577 if (!arg_obj->properties)578 goto out_unref;579 580 property = drm_mode_obj_find_prop_id(arg_obj, arg->prop_id);581 if (!property)582 goto out_unref;583 584 if (drm_drv_uses_atomic_modeset(property->dev))585 ret = set_property_atomic(arg_obj, file_priv, property, arg->value);586 else587 ret = set_property_legacy(arg_obj, property, arg->value);588 589out_unref:590 drm_mode_object_put(arg_obj);591 return ret;592}593