Merge tag 'devicetree-fixes-for-4.20-1' of git://git.kernel.org/pub/scm/linux/kernel...
[sfrench/cifs-2.6.git] / 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  * @dev: drm device
155  * @file_priv: drm file
156  * @id: id of the mode object
157  * @type: type of the mode object
158  *
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().
162  */
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)
166 {
167         struct drm_mode_object *obj = NULL;
168
169         obj = __drm_mode_object_find(dev, file_priv, id, type);
170         return obj;
171 }
172 EXPORT_SYMBOL(drm_mode_object_find);
173
174 /**
175  * drm_mode_object_put - release a mode object reference
176  * @obj: DRM mode object
177  *
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().
181  */
182 void drm_mode_object_put(struct drm_mode_object *obj)
183 {
184         if (obj->free_cb) {
185                 DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, kref_read(&obj->refcount));
186                 kref_put(&obj->refcount, obj->free_cb);
187         }
188 }
189 EXPORT_SYMBOL(drm_mode_object_put);
190
191 /**
192  * drm_mode_object_get - acquire a mode object reference
193  * @obj: DRM mode object
194  *
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().
198  */
199 void drm_mode_object_get(struct drm_mode_object *obj)
200 {
201         if (obj->free_cb) {
202                 DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, kref_read(&obj->refcount));
203                 kref_get(&obj->refcount);
204         }
205 }
206 EXPORT_SYMBOL(drm_mode_object_get);
207
208 /**
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
213  *
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.
217  */
218 void drm_object_attach_property(struct drm_mode_object *obj,
219                                 struct drm_property *property,
220                                 uint64_t init_val)
221 {
222         int count = obj->properties->count;
223
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",
228                         obj->type);
229                 return;
230         }
231
232         obj->properties->properties[count] = property;
233         obj->properties->values[count] = init_val;
234         obj->properties->count++;
235 }
236 EXPORT_SYMBOL(drm_object_attach_property);
237
238 /**
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
243  *
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.
247  *
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).
253  *
254  * Returns:
255  * Zero on success, error code on failure.
256  */
257 int drm_object_property_set_value(struct drm_mode_object *obj,
258                                   struct drm_property *property, uint64_t val)
259 {
260         int i;
261
262         WARN_ON(drm_drv_uses_atomic_modeset(property->dev) &&
263                 !(property->flags & DRM_MODE_PROP_IMMUTABLE));
264
265         for (i = 0; i < obj->properties->count; i++) {
266                 if (obj->properties->properties[i] == property) {
267                         obj->properties->values[i] = val;
268                         return 0;
269                 }
270         }
271
272         return -EINVAL;
273 }
274 EXPORT_SYMBOL(drm_object_property_set_value);
275
276 static int __drm_object_property_get_value(struct drm_mode_object *obj,
277                                            struct drm_property *property,
278                                            uint64_t *val)
279 {
280         int i;
281
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:
285          */
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);
289
290         for (i = 0; i < obj->properties->count; i++) {
291                 if (obj->properties->properties[i] == property) {
292                         *val = obj->properties->values[i];
293                         return 0;
294                 }
295
296         }
297
298         return -EINVAL;
299 }
300
301 /**
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
306  *
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
310  * and property.
311  *
312  * Atomic drivers should never call this function directly, the core will read
313  * out property values through the various ->atomic_get_property callbacks.
314  *
315  * Returns:
316  * Zero on success, error code on failure.
317  */
318 int drm_object_property_get_value(struct drm_mode_object *obj,
319                                   struct drm_property *property, uint64_t *val)
320 {
321         WARN_ON(drm_drv_uses_atomic_modeset(property->dev));
322
323         return __drm_object_property_get_value(obj, property, val);
324 }
325 EXPORT_SYMBOL(drm_object_property_get_value);
326
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)
332 {
333         int i, ret, count;
334
335         for (i = 0, count = 0; i < obj->properties->count; i++) {
336                 struct drm_property *prop = obj->properties->properties[i];
337                 uint64_t val;
338
339                 if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)
340                         continue;
341
342                 if (*arg_count_props > count) {
343                         ret = __drm_object_property_get_value(obj, prop, &val);
344                         if (ret)
345                                 return ret;
346
347                         if (put_user(prop->base.id, prop_ptr + count))
348                                 return -EFAULT;
349
350                         if (put_user(val, prop_values + count))
351                                 return -EFAULT;
352                 }
353
354                 count++;
355         }
356         *arg_count_props = count;
357
358         return 0;
359 }
360
361 /**
362  * drm_mode_obj_get_properties_ioctl - get the current value of a object's property
363  * @dev: DRM device
364  * @data: ioctl data
365  * @file_priv: DRM file info
366  *
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
369  * plane objects.
370  *
371  * Called by the user via ioctl.
372  *
373  * Returns:
374  * Zero on success, negative errno on failure.
375  */
376 int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
377                                       struct drm_file *file_priv)
378 {
379         struct drm_mode_obj_get_properties *arg = data;
380         struct drm_mode_object *obj;
381         int ret = 0;
382
383         if (!drm_core_check_feature(dev, DRIVER_MODESET))
384                 return -EOPNOTSUPP;
385
386         drm_modeset_lock_all(dev);
387
388         obj = drm_mode_object_find(dev, file_priv, arg->obj_id, arg->obj_type);
389         if (!obj) {
390                 ret = -ENOENT;
391                 goto out;
392         }
393         if (!obj->properties) {
394                 ret = -EINVAL;
395                 goto out_unref;
396         }
397
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),
401                         &arg->count_props);
402
403 out_unref:
404         drm_mode_object_put(obj);
405 out:
406         drm_modeset_unlock_all(dev);
407         return ret;
408 }
409
410 struct drm_property *drm_mode_obj_find_prop_id(struct drm_mode_object *obj,
411                                                uint32_t prop_id)
412 {
413         int i;
414
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];
418
419         return NULL;
420 }
421
422 static int set_property_legacy(struct drm_mode_object *obj,
423                                struct drm_property *prop,
424                                uint64_t prop_value)
425 {
426         struct drm_device *dev = prop->dev;
427         struct drm_mode_object *ref;
428         int ret = -EINVAL;
429
430         if (!drm_property_change_valid_get(prop, prop_value, &ref))
431                 return -EINVAL;
432
433         drm_modeset_lock_all(dev);
434         switch (obj->type) {
435         case DRM_MODE_OBJECT_CONNECTOR:
436                 ret = drm_connector_set_obj_prop(obj, prop, 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 -EOPNOTSUPP;
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 }