2 * Copyright (c) 2016 Intel Corporation
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.
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
23 #include <linux/export.h>
25 #include <drm/drm_mode_object.h>
26 #include <drm/drm_atomic.h>
28 #include "drm_crtc_internal.h"
31 * Internal function to assign a slot in the object idr and optionally
32 * register the object into the idr.
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))
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);
44 * Set up the object linking under the protection of the idr
45 * lock so that other users can't see inconsistent state.
50 obj->free_cb = obj_free_cb;
51 kref_init(&obj->refcount);
54 mutex_unlock(&dev->mode_config.idr_mutex);
56 return ret < 0 ? ret : 0;
60 * drm_mode_object_add - allocate a new modeset identifier
62 * @obj: object pointer, used to generate unique ID
63 * @obj_type: object type
65 * Create a unique identifier based on @ptr in @dev's identifier space. Used
66 * for tracking modes, CRTCs and connectors.
69 * Zero on success, error code on failure.
71 int drm_mode_object_add(struct drm_device *dev,
72 struct drm_mode_object *obj, uint32_t obj_type)
74 return __drm_mode_object_add(dev, obj, obj_type, true, NULL);
77 void drm_mode_object_register(struct drm_device *dev,
78 struct drm_mode_object *obj)
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);
86 * drm_mode_object_unregister - free a modeset identifer
88 * @object: object to free
90 * Free @id from @dev's unique identifier pool.
91 * This function can be called multiple times, and guards against
93 * These modeset identifiers are _not_ reference counted. Hence don't use this
94 * for reference counted modeset objects like framebuffers.
96 void drm_mode_object_unregister(struct drm_device *dev,
97 struct drm_mode_object *object)
99 mutex_lock(&dev->mode_config.idr_mutex);
101 idr_remove(&dev->mode_config.crtc_idr, object->id);
104 mutex_unlock(&dev->mode_config.idr_mutex);
108 * drm_lease_required - check types which must be leased to be used
109 * @type: type of object
111 * Returns whether the provided type of drm_mode_object must
112 * be owned or leased to be used by a process.
114 bool drm_mode_object_lease_required(uint32_t type)
117 case DRM_MODE_OBJECT_CRTC:
118 case DRM_MODE_OBJECT_CONNECTOR:
119 case DRM_MODE_OBJECT_PLANE:
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)
130 struct drm_mode_object *obj = NULL;
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)
136 if (obj && obj->id != id)
139 if (obj && drm_mode_object_lease_required(obj->type) &&
140 !_drm_lease_held(file_priv, obj->id))
143 if (obj && obj->free_cb) {
144 if (!kref_get_unless_zero(&obj->refcount))
147 mutex_unlock(&dev->mode_config.idr_mutex);
153 * drm_mode_object_find - look up a drm object with static lifetime
155 * @file_priv: drm file
156 * @id: id of the mode object
157 * @type: type of the mode object
159 * This function is used to look up a modeset object. It will acquire a
160 * reference for reference counted objects. This reference must be dropped again
161 * by callind drm_mode_object_put().
163 struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
164 struct drm_file *file_priv,
165 uint32_t id, uint32_t type)
167 struct drm_mode_object *obj = NULL;
169 obj = __drm_mode_object_find(dev, file_priv, id, type);
172 EXPORT_SYMBOL(drm_mode_object_find);
175 * drm_mode_object_put - release a mode object reference
176 * @obj: DRM mode object
178 * This function decrements the object's refcount if it is a refcounted modeset
179 * object. It is a no-op on any other object. This is used to drop references
180 * acquired with drm_mode_object_get().
182 void drm_mode_object_put(struct drm_mode_object *obj)
185 DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, kref_read(&obj->refcount));
186 kref_put(&obj->refcount, obj->free_cb);
189 EXPORT_SYMBOL(drm_mode_object_put);
192 * drm_mode_object_get - acquire a mode object reference
193 * @obj: DRM mode object
195 * This function increments the object's refcount if it is a refcounted modeset
196 * object. It is a no-op on any other object. References should be dropped again
197 * by calling drm_mode_object_put().
199 void drm_mode_object_get(struct drm_mode_object *obj)
202 DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, kref_read(&obj->refcount));
203 kref_get(&obj->refcount);
206 EXPORT_SYMBOL(drm_mode_object_get);
209 * drm_object_attach_property - attach a property to a modeset object
210 * @obj: drm modeset object
211 * @property: property to attach
212 * @init_val: initial value of the property
214 * This attaches the given property to the modeset object with the given initial
215 * value. Currently this function cannot fail since the properties are stored in
216 * a statically sized array.
218 void drm_object_attach_property(struct drm_mode_object *obj,
219 struct drm_property *property,
222 int count = obj->properties->count;
224 if (count == DRM_OBJECT_MAX_PROPERTY) {
225 WARN(1, "Failed to attach object property (type: 0x%x). Please "
226 "increase DRM_OBJECT_MAX_PROPERTY by 1 for each time "
227 "you see this message on the same object type.\n",
232 obj->properties->properties[count] = property;
233 obj->properties->values[count] = init_val;
234 obj->properties->count++;
236 EXPORT_SYMBOL(drm_object_attach_property);
239 * drm_object_property_set_value - set the value of a property
240 * @obj: drm mode object to set property value for
241 * @property: property to set
242 * @val: value the property should be set to
244 * This function sets a given property on a given object. This function only
245 * changes the software state of the property, it does not call into the
246 * driver's ->set_property callback.
248 * Note that atomic drivers should not have any need to call this, the core will
249 * ensure consistency of values reported back to userspace through the
250 * appropriate ->atomic_get_property callback. Only legacy drivers should call
251 * this function to update the tracked value (after clamping and other
252 * restrictions have been applied).
255 * Zero on success, error code on failure.
257 int drm_object_property_set_value(struct drm_mode_object *obj,
258 struct drm_property *property, uint64_t val)
262 WARN_ON(drm_drv_uses_atomic_modeset(property->dev) &&
263 !(property->flags & DRM_MODE_PROP_IMMUTABLE));
265 for (i = 0; i < obj->properties->count; i++) {
266 if (obj->properties->properties[i] == property) {
267 obj->properties->values[i] = val;
274 EXPORT_SYMBOL(drm_object_property_set_value);
276 static int __drm_object_property_get_value(struct drm_mode_object *obj,
277 struct drm_property *property,
282 /* read-only properties bypass atomic mechanism and still store
283 * their value in obj->properties->values[].. mostly to avoid
284 * having to deal w/ EDID and similar props in atomic paths:
286 if (drm_drv_uses_atomic_modeset(property->dev) &&
287 !(property->flags & DRM_MODE_PROP_IMMUTABLE))
288 return drm_atomic_get_property(obj, property, val);
290 for (i = 0; i < obj->properties->count; i++) {
291 if (obj->properties->properties[i] == property) {
292 *val = obj->properties->values[i];
302 * drm_object_property_get_value - retrieve the value of a property
303 * @obj: drm mode object to get property value from
304 * @property: property to retrieve
305 * @val: storage for the property value
307 * This function retrieves the softare state of the given property for the given
308 * property. Since there is no driver callback to retrieve the current property
309 * value this might be out of sync with the hardware, depending upon the driver
312 * Atomic drivers should never call this function directly, the core will read
313 * out property values through the various ->atomic_get_property callbacks.
316 * Zero on success, error code on failure.
318 int drm_object_property_get_value(struct drm_mode_object *obj,
319 struct drm_property *property, uint64_t *val)
321 WARN_ON(drm_drv_uses_atomic_modeset(property->dev));
323 return __drm_object_property_get_value(obj, property, val);
325 EXPORT_SYMBOL(drm_object_property_get_value);
327 /* helper for getconnector and getproperties ioctls */
328 int drm_mode_object_get_properties(struct drm_mode_object *obj, bool atomic,
329 uint32_t __user *prop_ptr,
330 uint64_t __user *prop_values,
331 uint32_t *arg_count_props)
335 for (i = 0, count = 0; i < obj->properties->count; i++) {
336 struct drm_property *prop = obj->properties->properties[i];
339 if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)
342 if (*arg_count_props > count) {
343 ret = __drm_object_property_get_value(obj, prop, &val);
347 if (put_user(prop->base.id, prop_ptr + count))
350 if (put_user(val, prop_values + count))
356 *arg_count_props = count;
362 * drm_mode_obj_get_properties_ioctl - get the current value of a object's property
365 * @file_priv: DRM file info
367 * This function retrieves the current value for an object's property. Compared
368 * to the connector specific ioctl this one is extended to also work on crtc and
371 * Called by the user via ioctl.
374 * Zero on success, negative errno on failure.
376 int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
377 struct drm_file *file_priv)
379 struct drm_mode_obj_get_properties *arg = data;
380 struct drm_mode_object *obj;
383 if (!drm_core_check_feature(dev, DRIVER_MODESET))
386 drm_modeset_lock_all(dev);
388 obj = drm_mode_object_find(dev, file_priv, arg->obj_id, arg->obj_type);
393 if (!obj->properties) {
398 ret = drm_mode_object_get_properties(obj, file_priv->atomic,
399 (uint32_t __user *)(unsigned long)(arg->props_ptr),
400 (uint64_t __user *)(unsigned long)(arg->prop_values_ptr),
404 drm_mode_object_put(obj);
406 drm_modeset_unlock_all(dev);
410 struct drm_property *drm_mode_obj_find_prop_id(struct drm_mode_object *obj,
415 for (i = 0; i < obj->properties->count; i++)
416 if (obj->properties->properties[i]->base.id == prop_id)
417 return obj->properties->properties[i];
422 static int set_property_legacy(struct drm_mode_object *obj,
423 struct drm_property *prop,
426 struct drm_device *dev = prop->dev;
427 struct drm_mode_object *ref;
430 if (!drm_property_change_valid_get(prop, prop_value, &ref))
433 drm_modeset_lock_all(dev);
435 case DRM_MODE_OBJECT_CONNECTOR:
436 ret = drm_connector_set_obj_prop(obj, prop, prop_value);
438 case DRM_MODE_OBJECT_CRTC:
439 ret = drm_mode_crtc_set_obj_prop(obj, prop, prop_value);
441 case DRM_MODE_OBJECT_PLANE:
442 ret = drm_mode_plane_set_obj_prop(obj_to_plane(obj),
446 drm_property_change_valid_put(prop, ref);
447 drm_modeset_unlock_all(dev);
452 static int set_property_atomic(struct drm_mode_object *obj,
453 struct drm_property *prop,
456 struct drm_device *dev = prop->dev;
457 struct drm_atomic_state *state;
458 struct drm_modeset_acquire_ctx ctx;
461 drm_modeset_acquire_init(&ctx, 0);
463 state = drm_atomic_state_alloc(dev);
466 state->acquire_ctx = &ctx;
468 if (prop == state->dev->mode_config.dpms_property) {
469 if (obj->type != DRM_MODE_OBJECT_CONNECTOR) {
474 ret = drm_atomic_connector_commit_dpms(state,
475 obj_to_connector(obj),
478 ret = drm_atomic_set_property(state, obj, prop, prop_value);
481 ret = drm_atomic_commit(state);
484 if (ret == -EDEADLK) {
485 drm_atomic_state_clear(state);
486 drm_modeset_backoff(&ctx);
490 drm_atomic_state_put(state);
492 drm_modeset_drop_locks(&ctx);
493 drm_modeset_acquire_fini(&ctx);
498 int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
499 struct drm_file *file_priv)
501 struct drm_mode_obj_set_property *arg = data;
502 struct drm_mode_object *arg_obj;
503 struct drm_property *property;
506 if (!drm_core_check_feature(dev, DRIVER_MODESET))
509 arg_obj = drm_mode_object_find(dev, file_priv, arg->obj_id, arg->obj_type);
513 if (!arg_obj->properties)
516 property = drm_mode_obj_find_prop_id(arg_obj, arg->prop_id);
520 if (drm_drv_uses_atomic_modeset(property->dev))
521 ret = set_property_atomic(arg_obj, property, arg->value);
523 ret = set_property_legacy(arg_obj, property, arg->value);
526 drm_mode_object_put(arg_obj);