1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
32
33
34int __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.object_idr, register_obj ? obj : NULL,
42 1, 0, GFP_KERNEL);
43 if (ret >= 0) {
44
45
46
47
48 obj->id = ret;
49 obj->type = obj_type;
50 if (obj_free_cb) {
51 obj->free_cb = obj_free_cb;
52 kref_init(&obj->refcount);
53 }
54 }
55 mutex_unlock(&dev->mode_config.idr_mutex);
56
57 return ret < 0 ? ret : 0;
58}
59
60
61
62
63
64
65
66
67
68
69
70
71
72int drm_mode_object_add(struct drm_device *dev,
73 struct drm_mode_object *obj, uint32_t obj_type)
74{
75 return __drm_mode_object_add(dev, obj, obj_type, true, NULL);
76}
77
78void drm_mode_object_register(struct drm_device *dev,
79 struct drm_mode_object *obj)
80{
81 mutex_lock(&dev->mode_config.idr_mutex);
82 idr_replace(&dev->mode_config.object_idr, obj, obj->id);
83 mutex_unlock(&dev->mode_config.idr_mutex);
84}
85
86
87
88
89
90
91
92
93
94
95
96
97void drm_mode_object_unregister(struct drm_device *dev,
98 struct drm_mode_object *object)
99{
100 mutex_lock(&dev->mode_config.idr_mutex);
101 if (object->id) {
102 idr_remove(&dev->mode_config.object_idr, object->id);
103 object->id = 0;
104 }
105 mutex_unlock(&dev->mode_config.idr_mutex);
106}
107
108
109
110
111
112
113
114
115bool drm_mode_object_lease_required(uint32_t type)
116{
117 switch(type) {
118 case DRM_MODE_OBJECT_CRTC:
119 case DRM_MODE_OBJECT_CONNECTOR:
120 case DRM_MODE_OBJECT_PLANE:
121 return true;
122 default:
123 return false;
124 }
125}
126
127struct drm_mode_object *__drm_mode_object_find(struct drm_device *dev,
128 struct drm_file *file_priv,
129 uint32_t id, uint32_t type)
130{
131 struct drm_mode_object *obj = NULL;
132
133 mutex_lock(&dev->mode_config.idr_mutex);
134 obj = idr_find(&dev->mode_config.object_idr, id);
135 if (obj && type != DRM_MODE_OBJECT_ANY && obj->type != type)
136 obj = NULL;
137 if (obj && obj->id != id)
138 obj = NULL;
139
140 if (obj && drm_mode_object_lease_required(obj->type) &&
141 !_drm_lease_held(file_priv, obj->id))
142 obj = NULL;
143
144 if (obj && obj->free_cb) {
145 if (!kref_get_unless_zero(&obj->refcount))
146 obj = NULL;
147 }
148 mutex_unlock(&dev->mode_config.idr_mutex);
149
150 return obj;
151}
152
153
154
155
156
157
158
159
160
161
162
163
164struct drm_mode_object *drm_mode_object_find(struct drm_device *dev,
165 struct drm_file *file_priv,
166 uint32_t id, uint32_t type)
167{
168 struct drm_mode_object *obj = NULL;
169
170 obj = __drm_mode_object_find(dev, file_priv, id, type);
171 return obj;
172}
173EXPORT_SYMBOL(drm_mode_object_find);
174
175
176
177
178
179
180
181
182
183void drm_mode_object_put(struct drm_mode_object *obj)
184{
185 if (obj->free_cb) {
186 DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, kref_read(&obj->refcount));
187 kref_put(&obj->refcount, obj->free_cb);
188 }
189}
190EXPORT_SYMBOL(drm_mode_object_put);
191
192
193
194
195
196
197
198
199
200void drm_mode_object_get(struct drm_mode_object *obj)
201{
202 if (obj->free_cb) {
203 DRM_DEBUG("OBJ ID: %d (%d)\n", obj->id, kref_read(&obj->refcount));
204 kref_get(&obj->refcount);
205 }
206}
207EXPORT_SYMBOL(drm_mode_object_get);
208
209
210
211
212
213
214
215
216
217
218
219void drm_object_attach_property(struct drm_mode_object *obj,
220 struct drm_property *property,
221 uint64_t init_val)
222{
223 int count = obj->properties->count;
224
225 if (count == DRM_OBJECT_MAX_PROPERTY) {
226 WARN(1, "Failed to attach object property (type: 0x%x). Please "
227 "increase DRM_OBJECT_MAX_PROPERTY by 1 for each time "
228 "you see this message on the same object type.\n",
229 obj->type);
230 return;
231 }
232
233 obj->properties->properties[count] = property;
234 obj->properties->values[count] = init_val;
235 obj->properties->count++;
236}
237EXPORT_SYMBOL(drm_object_attach_property);
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258int drm_object_property_set_value(struct drm_mode_object *obj,
259 struct drm_property *property, uint64_t val)
260{
261 int i;
262
263 WARN_ON(drm_drv_uses_atomic_modeset(property->dev) &&
264 !(property->flags & DRM_MODE_PROP_IMMUTABLE));
265
266 for (i = 0; i < obj->properties->count; i++) {
267 if (obj->properties->properties[i] == property) {
268 obj->properties->values[i] = val;
269 return 0;
270 }
271 }
272
273 return -EINVAL;
274}
275EXPORT_SYMBOL(drm_object_property_set_value);
276
277static int __drm_object_property_get_value(struct drm_mode_object *obj,
278 struct drm_property *property,
279 uint64_t *val)
280{
281 int i;
282
283
284
285
286
287 if (drm_drv_uses_atomic_modeset(property->dev) &&
288 !(property->flags & DRM_MODE_PROP_IMMUTABLE))
289 return drm_atomic_get_property(obj, property, val);
290
291 for (i = 0; i < obj->properties->count; i++) {
292 if (obj->properties->properties[i] == property) {
293 *val = obj->properties->values[i];
294 return 0;
295 }
296
297 }
298
299 return -EINVAL;
300}
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319int drm_object_property_get_value(struct drm_mode_object *obj,
320 struct drm_property *property, uint64_t *val)
321{
322 WARN_ON(drm_drv_uses_atomic_modeset(property->dev));
323
324 return __drm_object_property_get_value(obj, property, val);
325}
326EXPORT_SYMBOL(drm_object_property_get_value);
327
328
329int drm_mode_object_get_properties(struct drm_mode_object *obj, bool atomic,
330 uint32_t __user *prop_ptr,
331 uint64_t __user *prop_values,
332 uint32_t *arg_count_props)
333{
334 int i, ret, count;
335
336 for (i = 0, count = 0; i < obj->properties->count; i++) {
337 struct drm_property *prop = obj->properties->properties[i];
338 uint64_t val;
339
340 if ((prop->flags & DRM_MODE_PROP_ATOMIC) && !atomic)
341 continue;
342
343 if (*arg_count_props > count) {
344 ret = __drm_object_property_get_value(obj, prop, &val);
345 if (ret)
346 return ret;
347
348 if (put_user(prop->base.id, prop_ptr + count))
349 return -EFAULT;
350
351 if (put_user(val, prop_values + count))
352 return -EFAULT;
353 }
354
355 count++;
356 }
357 *arg_count_props = count;
358
359 return 0;
360}
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377int drm_mode_obj_get_properties_ioctl(struct drm_device *dev, void *data,
378 struct drm_file *file_priv)
379{
380 struct drm_mode_obj_get_properties *arg = data;
381 struct drm_mode_object *obj;
382 int ret = 0;
383
384 if (!drm_core_check_feature(dev, DRIVER_MODESET))
385 return -EOPNOTSUPP;
386
387 drm_modeset_lock_all(dev);
388
389 obj = drm_mode_object_find(dev, file_priv, arg->obj_id, arg->obj_type);
390 if (!obj) {
391 ret = -ENOENT;
392 goto out;
393 }
394 if (!obj->properties) {
395 ret = -EINVAL;
396 goto out_unref;
397 }
398
399 ret = drm_mode_object_get_properties(obj, file_priv->atomic,
400 (uint32_t __user *)(unsigned long)(arg->props_ptr),
401 (uint64_t __user *)(unsigned long)(arg->prop_values_ptr),
402 &arg->count_props);
403
404out_unref:
405 drm_mode_object_put(obj);
406out:
407 drm_modeset_unlock_all(dev);
408 return ret;
409}
410
411struct drm_property *drm_mode_obj_find_prop_id(struct drm_mode_object *obj,
412 uint32_t prop_id)
413{
414 int i;
415
416 for (i = 0; i < obj->properties->count; i++)
417 if (obj->properties->properties[i]->base.id == prop_id)
418 return obj->properties->properties[i];
419
420 return NULL;
421}
422
423static int set_property_legacy(struct drm_mode_object *obj,
424 struct drm_property *prop,
425 uint64_t prop_value)
426{
427 struct drm_device *dev = prop->dev;
428 struct drm_mode_object *ref;
429 int ret = -EINVAL;
430
431 if (!drm_property_change_valid_get(prop, prop_value, &ref))
432 return -EINVAL;
433
434 drm_modeset_lock_all(dev);
435 switch (obj->type) {
436 case DRM_MODE_OBJECT_CONNECTOR:
437 ret = drm_connector_set_obj_prop(obj, prop, prop_value);
438 break;
439 case DRM_MODE_OBJECT_CRTC:
440 ret = drm_mode_crtc_set_obj_prop(obj, prop, prop_value);
441 break;
442 case DRM_MODE_OBJECT_PLANE:
443 ret = drm_mode_plane_set_obj_prop(obj_to_plane(obj),
444 prop, prop_value);
445 break;
446 }
447 drm_property_change_valid_put(prop, ref);
448 drm_modeset_unlock_all(dev);
449
450 return ret;
451}
452
453static int set_property_atomic(struct drm_mode_object *obj,
454 struct drm_property *prop,
455 uint64_t prop_value)
456{
457 struct drm_device *dev = prop->dev;
458 struct drm_atomic_state *state;
459 struct drm_modeset_acquire_ctx ctx;
460 int ret;
461
462 state = drm_atomic_state_alloc(dev);
463 if (!state)
464 return -ENOMEM;
465
466 drm_modeset_acquire_init(&ctx, 0);
467 state->acquire_ctx = &ctx;
468
469retry:
470 if (prop == state->dev->mode_config.dpms_property) {
471 if (obj->type != DRM_MODE_OBJECT_CONNECTOR) {
472 ret = -EINVAL;
473 goto out;
474 }
475
476 ret = drm_atomic_connector_commit_dpms(state,
477 obj_to_connector(obj),
478 prop_value);
479 } else {
480 ret = drm_atomic_set_property(state, obj, prop, prop_value);
481 if (ret)
482 goto out;
483 ret = drm_atomic_commit(state);
484 }
485out:
486 if (ret == -EDEADLK) {
487 drm_atomic_state_clear(state);
488 drm_modeset_backoff(&ctx);
489 goto retry;
490 }
491
492 drm_atomic_state_put(state);
493
494 drm_modeset_drop_locks(&ctx);
495 drm_modeset_acquire_fini(&ctx);
496
497 return ret;
498}
499
500int drm_mode_obj_set_property_ioctl(struct drm_device *dev, void *data,
501 struct drm_file *file_priv)
502{
503 struct drm_mode_obj_set_property *arg = data;
504 struct drm_mode_object *arg_obj;
505 struct drm_property *property;
506 int ret = -EINVAL;
507
508 if (!drm_core_check_feature(dev, DRIVER_MODESET))
509 return -EOPNOTSUPP;
510
511 arg_obj = drm_mode_object_find(dev, file_priv, arg->obj_id, arg->obj_type);
512 if (!arg_obj)
513 return -ENOENT;
514
515 if (!arg_obj->properties)
516 goto out_unref;
517
518 property = drm_mode_obj_find_prop_id(arg_obj, arg->prop_id);
519 if (!property)
520 goto out_unref;
521
522 if (drm_drv_uses_atomic_modeset(property->dev))
523 ret = set_property_atomic(arg_obj, property, arg->value);
524 else
525 ret = set_property_legacy(arg_obj, property, arg->value);
526
527out_unref:
528 drm_mode_object_put(arg_obj);
529 return ret;
530}
531