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 | 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, ptr: register_obj ? obj : NULL, |
49 | start: 1, end: 0, GFP_KERNEL); |
50 | if (ret >= 0) { |
51 | /* |
52 | * Set up the object linking under the protection of the idr |
53 | * 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(kref: &obj->refcount); |
60 | } |
61 | } |
62 | mutex_unlock(lock: &dev->mode_config.idr_mutex); |
63 | |
64 | return ret < 0 ? ret : 0; |
65 | } |
66 | |
67 | /** |
68 | * drm_mode_object_add - allocate a new modeset identifier |
69 | * @dev: DRM device |
70 | * @obj: object pointer, used to generate unique ID |
71 | * @obj_type: object type |
72 | * |
73 | * Create a unique identifier based on @ptr in @dev's identifier space. Used |
74 | * for tracking modes, CRTCs and connectors. |
75 | * |
76 | * Returns: |
77 | * Zero on success, error code on failure. |
78 | */ |
79 | int 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, register_obj: true, NULL); |
83 | } |
84 | |
85 | void 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, id: obj->id); |
90 | mutex_unlock(lock: &dev->mode_config.idr_mutex); |
91 | } |
92 | |
93 | /** |
94 | * drm_mode_object_unregister - free a modeset identifier |
95 | * @dev: DRM device |
96 | * @object: object to free |
97 | * |
98 | * Free @id from @dev's unique identifier pool. |
99 | * This function can be called multiple times, and guards against |
100 | * multiple removals. |
101 | * These modeset identifiers are _not_ reference counted. Hence don't use this |
102 | * for reference counted modeset objects like framebuffers. |
103 | */ |
104 | void 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, id: object->id); |
112 | object->id = 0; |
113 | } |
114 | mutex_unlock(lock: &dev->mode_config.idr_mutex); |
115 | } |
116 | |
117 | /** |
118 | * drm_mode_object_lease_required - check types which must be leased to be used |
119 | * @type: type of object |
120 | * |
121 | * Returns whether the provided type of drm_mode_object must |
122 | * be owned or leased to be used by a process. |
123 | */ |
124 | bool 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 | |
136 | struct 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(type: obj->type) && |
150 | !_drm_lease_held(file_priv, id: 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(kref: &obj->refcount)) |
157 | obj = NULL; |
158 | } |
159 | mutex_unlock(lock: &dev->mode_config.idr_mutex); |
160 | |
161 | return obj; |
162 | } |
163 | |
164 | /** |
165 | * drm_mode_object_find - look up a drm object with static lifetime |
166 | * @dev: drm device |
167 | * @file_priv: drm file |
168 | * @id: id of the mode object |
169 | * @type: type of the mode object |
170 | * |
171 | * This function is used to look up a modeset object. It will acquire a |
172 | * reference for reference counted objects. This reference must be dropped again |
173 | * by callind drm_mode_object_put(). |
174 | */ |
175 | struct 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 | } |
184 | EXPORT_SYMBOL(drm_mode_object_find); |
185 | |
186 | /** |
187 | * drm_mode_object_put - release a mode object reference |
188 | * @obj: DRM mode object |
189 | * |
190 | * This function decrements the object's refcount if it is a refcounted modeset |
191 | * object. It is a no-op on any other object. This is used to drop references |
192 | * acquired with drm_mode_object_get(). |
193 | */ |
194 | void 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(kref: &obj->refcount, release: obj->free_cb); |
199 | } |
200 | } |
201 | EXPORT_SYMBOL(drm_mode_object_put); |
202 | |
203 | /** |
204 | * drm_mode_object_get - acquire a mode object reference |
205 | * @obj: DRM mode object |
206 | * |
207 | * This function increments the object's refcount if it is a refcounted modeset |
208 | * object. It is a no-op on any other object. References should be dropped again |
209 | * by calling drm_mode_object_put(). |
210 | */ |
211 | void 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(kref: &obj->refcount); |
216 | } |
217 | } |
218 | EXPORT_SYMBOL(drm_mode_object_get); |
219 | |
220 | /** |
221 | * drm_object_attach_property - attach a property to a modeset object |
222 | * @obj: drm modeset object |
223 | * @property: property to attach |
224 | * @init_val: initial value of the property |
225 | * |
226 | * This attaches the given property to the modeset object with the given initial |
227 | * value. Currently this function cannot fail since the properties are stored in |
228 | * a statically sized array. |
229 | * |
230 | * Note that all properties must be attached before the object itself is |
231 | * registered and accessible from userspace. |
232 | */ |
233 | void 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 | } |
262 | EXPORT_SYMBOL(drm_object_attach_property); |
263 | |
264 | /** |
265 | * drm_object_property_set_value - set the value of a property |
266 | * @obj: drm mode object to set property value for |
267 | * @property: property to set |
268 | * @val: value the property should be set to |
269 | * |
270 | * This function sets a given property on a given object. This function only |
271 | * changes the software state of the property, it does not call into the |
272 | * driver's ->set_property callback. |
273 | * |
274 | * Note that atomic drivers should not have any need to call this, the core will |
275 | * ensure consistency of values reported back to userspace through the |
276 | * appropriate ->atomic_get_property callback. Only legacy drivers should call |
277 | * this function to update the tracked value (after clamping and other |
278 | * restrictions have been applied). |
279 | * |
280 | * Returns: |
281 | * Zero on success, error code on failure. |
282 | */ |
283 | int 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 | } |
300 | EXPORT_SYMBOL(drm_object_property_set_value); |
301 | |
302 | static 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 | |
318 | static 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 store |
324 | * their value in obj->properties->values[].. mostly to avoid |
325 | * having to deal w/ EDID and similar props in atomic paths: |
326 | */ |
327 | if (drm_drv_uses_atomic_modeset(dev: 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 property |
336 | * @obj: drm mode object to get property value from |
337 | * @property: property to retrieve |
338 | * @val: storage for the property value |
339 | * |
340 | * This function retrieves the softare state of the given property for the given |
341 | * property. Since there is no driver callback to retrieve the current property |
342 | * value this might be out of sync with the hardware, depending upon the driver |
343 | * and property. |
344 | * |
345 | * Atomic drivers should never call this function directly, the core will read |
346 | * out property values through the various ->atomic_get_property callbacks. |
347 | * |
348 | * Returns: |
349 | * Zero on success, error code on failure. |
350 | */ |
351 | int 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 | } |
358 | EXPORT_SYMBOL(drm_object_property_get_value); |
359 | |
360 | /** |
361 | * drm_object_property_get_default_value - retrieve the default value of a |
362 | * property when in atomic mode. |
363 | * @obj: drm mode object to get property value from |
364 | * @property: property to retrieve |
365 | * @val: storage for the property value |
366 | * |
367 | * This function retrieves the default state of the given property as passed in |
368 | * to drm_object_attach_property |
369 | * |
370 | * Only atomic drivers should call this function directly, as for non-atomic |
371 | * drivers it will return the current value. |
372 | * |
373 | * Returns: |
374 | * Zero on success, error code on failure. |
375 | */ |
376 | int 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 | } |
384 | EXPORT_SYMBOL(drm_object_property_get_default_value); |
385 | |
386 | /* helper for getconnector and getproperties ioctls */ |
387 | int 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, property: prop, val: &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 property |
422 | * @dev: DRM device |
423 | * @data: ioctl data |
424 | * @file_priv: DRM file info |
425 | * |
426 | * This function retrieves the current value for an object's property. Compared |
427 | * to the connector specific ioctl this one is extended to also work on crtc and |
428 | * plane objects. |
429 | * |
430 | * Called by the user via ioctl. |
431 | * |
432 | * Returns: |
433 | * Zero on success, negative errno on failure. |
434 | */ |
435 | int 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, feature: 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, atomic: file_priv->atomic, |
459 | prop_ptr: (uint32_t __user *)(unsigned long)(arg->props_ptr), |
460 | prop_values: (uint64_t __user *)(unsigned long)(arg->prop_values_ptr), |
461 | arg_count_props: &arg->count_props); |
462 | |
463 | out_unref: |
464 | drm_mode_object_put(obj); |
465 | out: |
466 | DRM_MODESET_LOCK_ALL_END(dev, ctx, ret); |
467 | return ret; |
468 | } |
469 | |
470 | struct 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 | } |
481 | |
482 | static int set_property_legacy(struct drm_mode_object *obj, |
483 | struct drm_property *prop, |
484 | uint64_t prop_value) |
485 | { |
486 | struct drm_device *dev = prop->dev; |
487 | struct drm_mode_object *ref; |
488 | struct drm_modeset_acquire_ctx ctx; |
489 | int ret = -EINVAL; |
490 | |
491 | if (!drm_property_change_valid_get(property: prop, value: prop_value, ref: &ref)) |
492 | return -EINVAL; |
493 | |
494 | DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, ret); |
495 | switch (obj->type) { |
496 | case DRM_MODE_OBJECT_CONNECTOR: |
497 | ret = drm_connector_set_obj_prop(obj, property: prop, value: prop_value); |
498 | break; |
499 | case DRM_MODE_OBJECT_CRTC: |
500 | ret = drm_mode_crtc_set_obj_prop(obj, property: prop, value: prop_value); |
501 | break; |
502 | case DRM_MODE_OBJECT_PLANE: |
503 | ret = drm_mode_plane_set_obj_prop(obj_to_plane(obj), |
504 | property: prop, value: prop_value); |
505 | break; |
506 | } |
507 | drm_property_change_valid_put(property: prop, ref); |
508 | DRM_MODESET_LOCK_ALL_END(dev, ctx, ret); |
509 | |
510 | return ret; |
511 | } |
512 | |
513 | static int set_property_atomic(struct drm_mode_object *obj, |
514 | struct drm_file *file_priv, |
515 | struct drm_property *prop, |
516 | uint64_t prop_value) |
517 | { |
518 | struct drm_device *dev = prop->dev; |
519 | struct drm_atomic_state *state; |
520 | struct drm_modeset_acquire_ctx ctx; |
521 | int ret; |
522 | |
523 | state = drm_atomic_state_alloc(dev); |
524 | if (!state) |
525 | return -ENOMEM; |
526 | |
527 | drm_modeset_acquire_init(ctx: &ctx, flags: 0); |
528 | state->acquire_ctx = &ctx; |
529 | |
530 | retry: |
531 | if (prop == state->dev->mode_config.dpms_property) { |
532 | if (obj->type != DRM_MODE_OBJECT_CONNECTOR) { |
533 | ret = -EINVAL; |
534 | goto out; |
535 | } |
536 | |
537 | ret = drm_atomic_connector_commit_dpms(state, |
538 | obj_to_connector(obj), |
539 | mode: prop_value); |
540 | } else { |
541 | ret = drm_atomic_set_property(state, file_priv, obj, prop, prop_value); |
542 | if (ret) |
543 | goto out; |
544 | ret = drm_atomic_commit(state); |
545 | } |
546 | out: |
547 | if (ret == -EDEADLK) { |
548 | drm_atomic_state_clear(state); |
549 | drm_modeset_backoff(ctx: &ctx); |
550 | goto retry; |
551 | } |
552 | |
553 | drm_atomic_state_put(state); |
554 | |
555 | drm_modeset_drop_locks(ctx: &ctx); |
556 | drm_modeset_acquire_fini(ctx: &ctx); |
557 | |
558 | return ret; |
559 | } |
560 | |
561 | int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data, |
562 | struct drm_file *file_priv) |
563 | { |
564 | struct drm_mode_obj_set_property *arg = data; |
565 | struct drm_mode_object *arg_obj; |
566 | struct drm_property *property; |
567 | int ret = -EINVAL; |
568 | |
569 | if (!drm_core_check_feature(dev, feature: DRIVER_MODESET)) |
570 | return -EOPNOTSUPP; |
571 | |
572 | arg_obj = drm_mode_object_find(dev, file_priv, arg->obj_id, arg->obj_type); |
573 | if (!arg_obj) |
574 | return -ENOENT; |
575 | |
576 | if (!arg_obj->properties) |
577 | goto out_unref; |
578 | |
579 | property = drm_mode_obj_find_prop_id(obj: arg_obj, prop_id: arg->prop_id); |
580 | if (!property) |
581 | goto out_unref; |
582 | |
583 | if (drm_drv_uses_atomic_modeset(dev: property->dev)) |
584 | ret = set_property_atomic(obj: arg_obj, file_priv, prop: property, prop_value: arg->value); |
585 | else |
586 | ret = set_property_legacy(obj: arg_obj, prop: property, prop_value: arg->value); |
587 | |
588 | out_unref: |
589 | drm_mode_object_put(arg_obj); |
590 | return ret; |
591 | } |
592 | |