1 /* $NetBSD: drm_property.c,v 1.4 2021/12/19 09:50:27 riastradh Exp $ */
2
3 /*
4 * Copyright (c) 2016 Intel Corporation
5 *
6 * Permission to use, copy, modify, distribute, and sell this software and its
7 * documentation for any purpose is hereby granted without fee, provided that
8 * the above copyright notice appear in all copies and that both that copyright
9 * notice and this permission notice appear in supporting documentation, and
10 * that the name of the copyright holders not be used in advertising or
11 * publicity pertaining to distribution of the software without specific,
12 * written prior permission. The copyright holders make no representations
13 * about the suitability of this software for any purpose. It is provided "as
14 * is" without express or implied warranty.
15 *
16 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
18 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
19 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
20 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
21 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
22 * OF THIS SOFTWARE.
23 */
24
25 #include <sys/cdefs.h>
26 __KERNEL_RCSID(0, "$NetBSD: drm_property.c,v 1.4 2021/12/19 09:50:27 riastradh Exp $");
27
28 #include <linux/mm.h>
29 #include <linux/export.h>
30 #include <linux/uaccess.h>
31
32 #include <drm/drm_crtc.h>
33 #include <drm/drm_drv.h>
34 #include <drm/drm_file.h>
35 #include <drm/drm_framebuffer.h>
36 #include <drm/drm_property.h>
37
38 #include "drm_crtc_internal.h"
39
40 /**
41 * DOC: overview
42 *
43 * Properties as represented by &drm_property are used to extend the modeset
44 * interface exposed to userspace. For the atomic modeset IOCTL properties are
45 * even the only way to transport metadata about the desired new modeset
46 * configuration from userspace to the kernel. Properties have a well-defined
47 * value range, which is enforced by the drm core. See the documentation of the
48 * flags member of &struct drm_property for an overview of the different
49 * property types and ranges.
50 *
51 * Properties don't store the current value directly, but need to be
52 * instatiated by attaching them to a &drm_mode_object with
53 * drm_object_attach_property().
54 *
55 * Property values are only 64bit. To support bigger piles of data (like gamma
56 * tables, color correction matrices or large structures) a property can instead
57 * point at a &drm_property_blob with that additional data.
58 *
59 * Properties are defined by their symbolic name, userspace must keep a
60 * per-object mapping from those names to the property ID used in the atomic
61 * IOCTL and in the get/set property IOCTL.
62 */
63
drm_property_flags_valid(u32 flags)64 static bool drm_property_flags_valid(u32 flags)
65 {
66 u32 legacy_type = flags & DRM_MODE_PROP_LEGACY_TYPE;
67 u32 ext_type = flags & DRM_MODE_PROP_EXTENDED_TYPE;
68
69 /* Reject undefined/deprecated flags */
70 if (flags & ~(DRM_MODE_PROP_LEGACY_TYPE |
71 DRM_MODE_PROP_EXTENDED_TYPE |
72 DRM_MODE_PROP_IMMUTABLE |
73 DRM_MODE_PROP_ATOMIC))
74 return false;
75
76 /* We want either a legacy type or an extended type, but not both */
77 if (!legacy_type == !ext_type)
78 return false;
79
80 /* Only one legacy type at a time please */
81 if (legacy_type && !is_power_of_2(legacy_type))
82 return false;
83
84 return true;
85 }
86
87 /**
88 * drm_property_create - create a new property type
89 * @dev: drm device
90 * @flags: flags specifying the property type
91 * @name: name of the property
92 * @num_values: number of pre-defined values
93 *
94 * This creates a new generic drm property which can then be attached to a drm
95 * object with drm_object_attach_property(). The returned property object must
96 * be freed with drm_property_destroy(), which is done automatically when
97 * calling drm_mode_config_cleanup().
98 *
99 * Returns:
100 * A pointer to the newly created property on success, NULL on failure.
101 */
drm_property_create(struct drm_device * dev,u32 flags,const char * name,int num_values)102 struct drm_property *drm_property_create(struct drm_device *dev,
103 u32 flags, const char *name,
104 int num_values)
105 {
106 struct drm_property *property = NULL;
107 int ret;
108
109 if (WARN_ON(!drm_property_flags_valid(flags)))
110 return NULL;
111
112 if (WARN_ON(strlen(name) >= DRM_PROP_NAME_LEN))
113 return NULL;
114
115 property = kzalloc(sizeof(struct drm_property), GFP_KERNEL);
116 if (!property)
117 return NULL;
118
119 property->dev = dev;
120
121 if (num_values) {
122 property->values = kcalloc(num_values, sizeof(uint64_t),
123 GFP_KERNEL);
124 if (!property->values)
125 goto fail;
126 }
127
128 ret = drm_mode_object_add(dev, &property->base, DRM_MODE_OBJECT_PROPERTY);
129 if (ret)
130 goto fail;
131
132 property->flags = flags;
133 property->num_values = num_values;
134 INIT_LIST_HEAD(&property->enum_list);
135
136 strncpy(property->name, name, DRM_PROP_NAME_LEN);
137 property->name[DRM_PROP_NAME_LEN-1] = '\0';
138
139 list_add_tail(&property->head, &dev->mode_config.property_list);
140
141 return property;
142 fail:
143 kfree(property->values);
144 kfree(property);
145 return NULL;
146 }
147 EXPORT_SYMBOL(drm_property_create);
148
149 /**
150 * drm_property_create_enum - create a new enumeration property type
151 * @dev: drm device
152 * @flags: flags specifying the property type
153 * @name: name of the property
154 * @props: enumeration lists with property values
155 * @num_values: number of pre-defined values
156 *
157 * This creates a new generic drm property which can then be attached to a drm
158 * object with drm_object_attach_property(). The returned property object must
159 * be freed with drm_property_destroy(), which is done automatically when
160 * calling drm_mode_config_cleanup().
161 *
162 * Userspace is only allowed to set one of the predefined values for enumeration
163 * properties.
164 *
165 * Returns:
166 * A pointer to the newly created property on success, NULL on failure.
167 */
drm_property_create_enum(struct drm_device * dev,u32 flags,const char * name,const struct drm_prop_enum_list * props,int num_values)168 struct drm_property *drm_property_create_enum(struct drm_device *dev,
169 u32 flags, const char *name,
170 const struct drm_prop_enum_list *props,
171 int num_values)
172 {
173 struct drm_property *property;
174 int i, ret;
175
176 flags |= DRM_MODE_PROP_ENUM;
177
178 property = drm_property_create(dev, flags, name, num_values);
179 if (!property)
180 return NULL;
181
182 for (i = 0; i < num_values; i++) {
183 ret = drm_property_add_enum(property,
184 props[i].type,
185 props[i].name);
186 if (ret) {
187 drm_property_destroy(dev, property);
188 return NULL;
189 }
190 }
191
192 return property;
193 }
194 EXPORT_SYMBOL(drm_property_create_enum);
195
196 /**
197 * drm_property_create_bitmask - create a new bitmask property type
198 * @dev: drm device
199 * @flags: flags specifying the property type
200 * @name: name of the property
201 * @props: enumeration lists with property bitflags
202 * @num_props: size of the @props array
203 * @supported_bits: bitmask of all supported enumeration values
204 *
205 * This creates a new bitmask drm property which can then be attached to a drm
206 * object with drm_object_attach_property(). The returned property object must
207 * be freed with drm_property_destroy(), which is done automatically when
208 * calling drm_mode_config_cleanup().
209 *
210 * Compared to plain enumeration properties userspace is allowed to set any
211 * or'ed together combination of the predefined property bitflag values
212 *
213 * Returns:
214 * A pointer to the newly created property on success, NULL on failure.
215 */
drm_property_create_bitmask(struct drm_device * dev,u32 flags,const char * name,const struct drm_prop_enum_list * props,int num_props,uint64_t supported_bits)216 struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
217 u32 flags, const char *name,
218 const struct drm_prop_enum_list *props,
219 int num_props,
220 uint64_t supported_bits)
221 {
222 struct drm_property *property;
223 int i, ret;
224 int num_values = hweight64(supported_bits);
225
226 flags |= DRM_MODE_PROP_BITMASK;
227
228 property = drm_property_create(dev, flags, name, num_values);
229 if (!property)
230 return NULL;
231 for (i = 0; i < num_props; i++) {
232 if (!(supported_bits & (1ULL << props[i].type)))
233 continue;
234
235 ret = drm_property_add_enum(property,
236 props[i].type,
237 props[i].name);
238 if (ret) {
239 drm_property_destroy(dev, property);
240 return NULL;
241 }
242 }
243
244 return property;
245 }
246 EXPORT_SYMBOL(drm_property_create_bitmask);
247
property_create_range(struct drm_device * dev,u32 flags,const char * name,uint64_t min,uint64_t max)248 static struct drm_property *property_create_range(struct drm_device *dev,
249 u32 flags, const char *name,
250 uint64_t min, uint64_t max)
251 {
252 struct drm_property *property;
253
254 property = drm_property_create(dev, flags, name, 2);
255 if (!property)
256 return NULL;
257
258 property->values[0] = min;
259 property->values[1] = max;
260
261 return property;
262 }
263
264 /**
265 * drm_property_create_range - create a new unsigned ranged property type
266 * @dev: drm device
267 * @flags: flags specifying the property type
268 * @name: name of the property
269 * @min: minimum value of the property
270 * @max: maximum value of the property
271 *
272 * This creates a new generic drm property which can then be attached to a drm
273 * object with drm_object_attach_property(). The returned property object must
274 * be freed with drm_property_destroy(), which is done automatically when
275 * calling drm_mode_config_cleanup().
276 *
277 * Userspace is allowed to set any unsigned integer value in the (min, max)
278 * range inclusive.
279 *
280 * Returns:
281 * A pointer to the newly created property on success, NULL on failure.
282 */
drm_property_create_range(struct drm_device * dev,u32 flags,const char * name,uint64_t min,uint64_t max)283 struct drm_property *drm_property_create_range(struct drm_device *dev,
284 u32 flags, const char *name,
285 uint64_t min, uint64_t max)
286 {
287 return property_create_range(dev, DRM_MODE_PROP_RANGE | flags,
288 name, min, max);
289 }
290 EXPORT_SYMBOL(drm_property_create_range);
291
292 /**
293 * drm_property_create_signed_range - create a new signed ranged property type
294 * @dev: drm device
295 * @flags: flags specifying the property type
296 * @name: name of the property
297 * @min: minimum value of the property
298 * @max: maximum value of the property
299 *
300 * This creates a new generic drm property which can then be attached to a drm
301 * object with drm_object_attach_property(). The returned property object must
302 * be freed with drm_property_destroy(), which is done automatically when
303 * calling drm_mode_config_cleanup().
304 *
305 * Userspace is allowed to set any signed integer value in the (min, max)
306 * range inclusive.
307 *
308 * Returns:
309 * A pointer to the newly created property on success, NULL on failure.
310 */
drm_property_create_signed_range(struct drm_device * dev,u32 flags,const char * name,int64_t min,int64_t max)311 struct drm_property *drm_property_create_signed_range(struct drm_device *dev,
312 u32 flags, const char *name,
313 int64_t min, int64_t max)
314 {
315 return property_create_range(dev, DRM_MODE_PROP_SIGNED_RANGE | flags,
316 name, I642U64(min), I642U64(max));
317 }
318 EXPORT_SYMBOL(drm_property_create_signed_range);
319
320 /**
321 * drm_property_create_object - create a new object property type
322 * @dev: drm device
323 * @flags: flags specifying the property type
324 * @name: name of the property
325 * @type: object type from DRM_MODE_OBJECT_* defines
326 *
327 * This creates a new generic drm property which can then be attached to a drm
328 * object with drm_object_attach_property(). The returned property object must
329 * be freed with drm_property_destroy(), which is done automatically when
330 * calling drm_mode_config_cleanup().
331 *
332 * Userspace is only allowed to set this to any property value of the given
333 * @type. Only useful for atomic properties, which is enforced.
334 *
335 * Returns:
336 * A pointer to the newly created property on success, NULL on failure.
337 */
drm_property_create_object(struct drm_device * dev,u32 flags,const char * name,uint32_t type)338 struct drm_property *drm_property_create_object(struct drm_device *dev,
339 u32 flags, const char *name,
340 uint32_t type)
341 {
342 struct drm_property *property;
343
344 flags |= DRM_MODE_PROP_OBJECT;
345
346 if (WARN_ON(!(flags & DRM_MODE_PROP_ATOMIC)))
347 return NULL;
348
349 property = drm_property_create(dev, flags, name, 1);
350 if (!property)
351 return NULL;
352
353 property->values[0] = type;
354
355 return property;
356 }
357 EXPORT_SYMBOL(drm_property_create_object);
358
359 /**
360 * drm_property_create_bool - create a new boolean property type
361 * @dev: drm device
362 * @flags: flags specifying the property type
363 * @name: name of the property
364 *
365 * This creates a new generic drm property which can then be attached to a drm
366 * object with drm_object_attach_property(). The returned property object must
367 * be freed with drm_property_destroy(), which is done automatically when
368 * calling drm_mode_config_cleanup().
369 *
370 * This is implemented as a ranged property with only {0, 1} as valid values.
371 *
372 * Returns:
373 * A pointer to the newly created property on success, NULL on failure.
374 */
drm_property_create_bool(struct drm_device * dev,u32 flags,const char * name)375 struct drm_property *drm_property_create_bool(struct drm_device *dev,
376 u32 flags, const char *name)
377 {
378 return drm_property_create_range(dev, flags, name, 0, 1);
379 }
380 EXPORT_SYMBOL(drm_property_create_bool);
381
382 /**
383 * drm_property_add_enum - add a possible value to an enumeration property
384 * @property: enumeration property to change
385 * @value: value of the new enumeration
386 * @name: symbolic name of the new enumeration
387 *
388 * This functions adds enumerations to a property.
389 *
390 * It's use is deprecated, drivers should use one of the more specific helpers
391 * to directly create the property with all enumerations already attached.
392 *
393 * Returns:
394 * Zero on success, error code on failure.
395 */
drm_property_add_enum(struct drm_property * property,uint64_t value,const char * name)396 int drm_property_add_enum(struct drm_property *property,
397 uint64_t value, const char *name)
398 {
399 struct drm_property_enum *prop_enum;
400 int index = 0;
401
402 if (WARN_ON(strlen(name) >= DRM_PROP_NAME_LEN))
403 return -EINVAL;
404
405 if (WARN_ON(!drm_property_type_is(property, DRM_MODE_PROP_ENUM) &&
406 !drm_property_type_is(property, DRM_MODE_PROP_BITMASK)))
407 return -EINVAL;
408
409 /*
410 * Bitmask enum properties have the additional constraint of values
411 * from 0 to 63
412 */
413 if (WARN_ON(drm_property_type_is(property, DRM_MODE_PROP_BITMASK) &&
414 value > 63))
415 return -EINVAL;
416
417 list_for_each_entry(prop_enum, &property->enum_list, head) {
418 if (WARN_ON(prop_enum->value == value))
419 return -EINVAL;
420 index++;
421 }
422
423 if (WARN_ON(index >= property->num_values))
424 return -EINVAL;
425
426 prop_enum = kzalloc(sizeof(struct drm_property_enum), GFP_KERNEL);
427 if (!prop_enum)
428 return -ENOMEM;
429
430 strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
431 prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
432 prop_enum->value = value;
433
434 property->values[index] = value;
435 list_add_tail(&prop_enum->head, &property->enum_list);
436 return 0;
437 }
438 EXPORT_SYMBOL(drm_property_add_enum);
439
440 /**
441 * drm_property_destroy - destroy a drm property
442 * @dev: drm device
443 * @property: property to destry
444 *
445 * This function frees a property including any attached resources like
446 * enumeration values.
447 */
drm_property_destroy(struct drm_device * dev,struct drm_property * property)448 void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
449 {
450 struct drm_property_enum *prop_enum, *pt;
451
452 list_for_each_entry_safe(prop_enum, pt, &property->enum_list, head) {
453 list_del(&prop_enum->head);
454 kfree(prop_enum);
455 }
456
457 if (property->num_values)
458 kfree(property->values);
459 drm_mode_object_unregister(dev, &property->base);
460 list_del(&property->head);
461 kfree(property);
462 }
463 EXPORT_SYMBOL(drm_property_destroy);
464
drm_mode_getproperty_ioctl(struct drm_device * dev,void * data,struct drm_file * file_priv)465 int drm_mode_getproperty_ioctl(struct drm_device *dev,
466 void *data, struct drm_file *file_priv)
467 {
468 struct drm_mode_get_property *out_resp = data;
469 struct drm_property *property;
470 int enum_count = 0;
471 int value_count = 0;
472 int i, copied;
473 struct drm_property_enum *prop_enum;
474 struct drm_mode_property_enum __user *enum_ptr;
475 uint64_t __user *values_ptr;
476
477 if (!drm_core_check_feature(dev, DRIVER_MODESET))
478 return -EOPNOTSUPP;
479
480 property = drm_property_find(dev, file_priv, out_resp->prop_id);
481 if (!property)
482 return -ENOENT;
483
484 strncpy(out_resp->name, property->name, DRM_PROP_NAME_LEN);
485 out_resp->name[DRM_PROP_NAME_LEN-1] = 0;
486 out_resp->flags = property->flags;
487
488 value_count = property->num_values;
489 values_ptr = u64_to_user_ptr(out_resp->values_ptr);
490
491 for (i = 0; i < value_count; i++) {
492 if (i < out_resp->count_values &&
493 put_user(property->values[i], values_ptr + i)) {
494 return -EFAULT;
495 }
496 }
497 out_resp->count_values = value_count;
498
499 copied = 0;
500 enum_ptr = u64_to_user_ptr(out_resp->enum_blob_ptr);
501
502 if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
503 drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
504 list_for_each_entry(prop_enum, &property->enum_list, head) {
505 enum_count++;
506 if (out_resp->count_enum_blobs < enum_count)
507 continue;
508
509 if (copy_to_user(&enum_ptr[copied].value,
510 &prop_enum->value, sizeof(uint64_t)))
511 return -EFAULT;
512
513 if (copy_to_user(&enum_ptr[copied].name,
514 &prop_enum->name, DRM_PROP_NAME_LEN))
515 return -EFAULT;
516 copied++;
517 }
518 out_resp->count_enum_blobs = enum_count;
519 }
520
521 /*
522 * NOTE: The idea seems to have been to use this to read all the blob
523 * property values. But nothing ever added them to the corresponding
524 * list, userspace always used the special-purpose get_blob ioctl to
525 * read the value for a blob property. It also doesn't make a lot of
526 * sense to return values here when everything else is just metadata for
527 * the property itself.
528 */
529 if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
530 out_resp->count_enum_blobs = 0;
531
532 return 0;
533 }
534
drm_property_free_blob(struct kref * kref)535 static void drm_property_free_blob(struct kref *kref)
536 {
537 struct drm_property_blob *blob =
538 container_of(kref, struct drm_property_blob, base.refcount);
539
540 mutex_lock(&blob->dev->mode_config.blob_lock);
541 list_del(&blob->head_global);
542 mutex_unlock(&blob->dev->mode_config.blob_lock);
543
544 drm_mode_object_unregister(blob->dev, &blob->base);
545
546 kvfree(blob);
547 }
548
549 /**
550 * drm_property_create_blob - Create new blob property
551 * @dev: DRM device to create property for
552 * @length: Length to allocate for blob data
553 * @data: If specified, copies data into blob
554 *
555 * Creates a new blob property for a specified DRM device, optionally
556 * copying data. Note that blob properties are meant to be invariant, hence the
557 * data must be filled out before the blob is used as the value of any property.
558 *
559 * Returns:
560 * New blob property with a single reference on success, or an ERR_PTR
561 * value on failure.
562 */
563 struct drm_property_blob *
drm_property_create_blob(struct drm_device * dev,size_t length,const void * data)564 drm_property_create_blob(struct drm_device *dev, size_t length,
565 const void *data)
566 {
567 struct drm_property_blob *blob;
568 int ret;
569
570 if (!length || length > INT_MAX - sizeof(struct drm_property_blob))
571 return ERR_PTR(-EINVAL);
572
573 blob = kvzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
574 if (!blob)
575 return ERR_PTR(-ENOMEM);
576
577 /* This must be explicitly initialised, so we can safely call list_del
578 * on it in the removal handler, even if it isn't in a file list. */
579 INIT_LIST_HEAD(&blob->head_file);
580 blob->data = (char *)blob + sizeof(*blob);
581 blob->length = length;
582 blob->dev = dev;
583
584 if (data)
585 memcpy(blob->data, data, length);
586
587 ret = __drm_mode_object_add(dev, &blob->base, DRM_MODE_OBJECT_BLOB,
588 true, drm_property_free_blob);
589 if (ret) {
590 kvfree(blob);
591 return ERR_PTR(-EINVAL);
592 }
593
594 mutex_lock(&dev->mode_config.blob_lock);
595 list_add_tail(&blob->head_global,
596 &dev->mode_config.property_blob_list);
597 mutex_unlock(&dev->mode_config.blob_lock);
598
599 return blob;
600 }
601 EXPORT_SYMBOL(drm_property_create_blob);
602
603 /**
604 * drm_property_blob_put - release a blob property reference
605 * @blob: DRM blob property
606 *
607 * Releases a reference to a blob property. May free the object.
608 */
drm_property_blob_put(struct drm_property_blob * blob)609 void drm_property_blob_put(struct drm_property_blob *blob)
610 {
611 if (!blob)
612 return;
613
614 drm_mode_object_put(&blob->base);
615 }
616 EXPORT_SYMBOL(drm_property_blob_put);
617
drm_property_destroy_user_blobs(struct drm_device * dev,struct drm_file * file_priv)618 void drm_property_destroy_user_blobs(struct drm_device *dev,
619 struct drm_file *file_priv)
620 {
621 struct drm_property_blob *blob, *bt;
622
623 /*
624 * When the file gets released that means no one else can access the
625 * blob list any more, so no need to grab dev->blob_lock.
626 */
627 list_for_each_entry_safe(blob, bt, &file_priv->blobs, head_file) {
628 list_del_init(&blob->head_file);
629 drm_property_blob_put(blob);
630 }
631 }
632
633 /**
634 * drm_property_blob_get - acquire blob property reference
635 * @blob: DRM blob property
636 *
637 * Acquires a reference to an existing blob property. Returns @blob, which
638 * allows this to be used as a shorthand in assignments.
639 */
drm_property_blob_get(struct drm_property_blob * blob)640 struct drm_property_blob *drm_property_blob_get(struct drm_property_blob *blob)
641 {
642 drm_mode_object_get(&blob->base);
643 return blob;
644 }
645 EXPORT_SYMBOL(drm_property_blob_get);
646
647 /**
648 * drm_property_lookup_blob - look up a blob property and take a reference
649 * @dev: drm device
650 * @id: id of the blob property
651 *
652 * If successful, this takes an additional reference to the blob property.
653 * callers need to make sure to eventually unreference the returned property
654 * again, using drm_property_blob_put().
655 *
656 * Return:
657 * NULL on failure, pointer to the blob on success.
658 */
drm_property_lookup_blob(struct drm_device * dev,uint32_t id)659 struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev,
660 uint32_t id)
661 {
662 struct drm_mode_object *obj;
663 struct drm_property_blob *blob = NULL;
664
665 obj = __drm_mode_object_find(dev, NULL, id, DRM_MODE_OBJECT_BLOB);
666 if (obj)
667 blob = obj_to_blob(obj);
668 return blob;
669 }
670 EXPORT_SYMBOL(drm_property_lookup_blob);
671
672 /**
673 * drm_property_replace_global_blob - replace existing blob property
674 * @dev: drm device
675 * @replace: location of blob property pointer to be replaced
676 * @length: length of data for new blob, or 0 for no data
677 * @data: content for new blob, or NULL for no data
678 * @obj_holds_id: optional object for property holding blob ID
679 * @prop_holds_id: optional property holding blob ID
680 * @return 0 on success or error on failure
681 *
682 * This function will replace a global property in the blob list, optionally
683 * updating a property which holds the ID of that property.
684 *
685 * If length is 0 or data is NULL, no new blob will be created, and the holding
686 * property, if specified, will be set to 0.
687 *
688 * Access to the replace pointer is assumed to be protected by the caller, e.g.
689 * by holding the relevant modesetting object lock for its parent.
690 *
691 * For example, a drm_connector has a 'PATH' property, which contains the ID
692 * of a blob property with the value of the MST path information. Calling this
693 * function with replace pointing to the connector's path_blob_ptr, length and
694 * data set for the new path information, obj_holds_id set to the connector's
695 * base object, and prop_holds_id set to the path property name, will perform
696 * a completely atomic update. The access to path_blob_ptr is protected by the
697 * caller holding a lock on the connector.
698 */
drm_property_replace_global_blob(struct drm_device * dev,struct drm_property_blob ** replace,size_t length,const void * data,struct drm_mode_object * obj_holds_id,struct drm_property * prop_holds_id)699 int drm_property_replace_global_blob(struct drm_device *dev,
700 struct drm_property_blob **replace,
701 size_t length,
702 const void *data,
703 struct drm_mode_object *obj_holds_id,
704 struct drm_property *prop_holds_id)
705 {
706 struct drm_property_blob *new_blob = NULL;
707 struct drm_property_blob *old_blob = NULL;
708 int ret;
709
710 WARN_ON(replace == NULL);
711
712 old_blob = *replace;
713
714 if (length && data) {
715 new_blob = drm_property_create_blob(dev, length, data);
716 if (IS_ERR(new_blob))
717 return PTR_ERR(new_blob);
718 }
719
720 if (obj_holds_id) {
721 ret = drm_object_property_set_value(obj_holds_id,
722 prop_holds_id,
723 new_blob ?
724 new_blob->base.id : 0);
725 if (ret != 0)
726 goto err_created;
727 }
728
729 drm_property_blob_put(old_blob);
730 *replace = new_blob;
731
732 return 0;
733
734 err_created:
735 drm_property_blob_put(new_blob);
736 return ret;
737 }
738 EXPORT_SYMBOL(drm_property_replace_global_blob);
739
740 /**
741 * drm_property_replace_blob - replace a blob property
742 * @blob: a pointer to the member blob to be replaced
743 * @new_blob: the new blob to replace with
744 *
745 * Return: true if the blob was in fact replaced.
746 */
drm_property_replace_blob(struct drm_property_blob ** blob,struct drm_property_blob * new_blob)747 bool drm_property_replace_blob(struct drm_property_blob **blob,
748 struct drm_property_blob *new_blob)
749 {
750 struct drm_property_blob *old_blob = *blob;
751
752 if (old_blob == new_blob)
753 return false;
754
755 drm_property_blob_put(old_blob);
756 if (new_blob)
757 drm_property_blob_get(new_blob);
758 *blob = new_blob;
759 return true;
760 }
761 EXPORT_SYMBOL(drm_property_replace_blob);
762
drm_mode_getblob_ioctl(struct drm_device * dev,void * data,struct drm_file * file_priv)763 int drm_mode_getblob_ioctl(struct drm_device *dev,
764 void *data, struct drm_file *file_priv)
765 {
766 struct drm_mode_get_blob *out_resp = data;
767 struct drm_property_blob *blob;
768 int ret = 0;
769
770 if (!drm_core_check_feature(dev, DRIVER_MODESET))
771 return -EOPNOTSUPP;
772
773 blob = drm_property_lookup_blob(dev, out_resp->blob_id);
774 if (!blob)
775 return -ENOENT;
776
777 if (out_resp->length == blob->length) {
778 if (copy_to_user(u64_to_user_ptr(out_resp->data),
779 blob->data,
780 blob->length)) {
781 ret = -EFAULT;
782 goto unref;
783 }
784 }
785 out_resp->length = blob->length;
786 unref:
787 drm_property_blob_put(blob);
788
789 return ret;
790 }
791
drm_mode_createblob_ioctl(struct drm_device * dev,void * data,struct drm_file * file_priv)792 int drm_mode_createblob_ioctl(struct drm_device *dev,
793 void *data, struct drm_file *file_priv)
794 {
795 struct drm_mode_create_blob *out_resp = data;
796 struct drm_property_blob *blob;
797 int ret = 0;
798
799 if (!drm_core_check_feature(dev, DRIVER_MODESET))
800 return -EOPNOTSUPP;
801
802 blob = drm_property_create_blob(dev, out_resp->length, NULL);
803 if (IS_ERR(blob))
804 return PTR_ERR(blob);
805
806 if (copy_from_user(blob->data,
807 u64_to_user_ptr(out_resp->data),
808 out_resp->length)) {
809 ret = -EFAULT;
810 goto out_blob;
811 }
812
813 /* Dropping the lock between create_blob and our access here is safe
814 * as only the same file_priv can remove the blob; at this point, it is
815 * not associated with any file_priv. */
816 mutex_lock(&dev->mode_config.blob_lock);
817 out_resp->blob_id = blob->base.id;
818 list_add_tail(&blob->head_file, &file_priv->blobs);
819 mutex_unlock(&dev->mode_config.blob_lock);
820
821 return 0;
822
823 out_blob:
824 drm_property_blob_put(blob);
825 return ret;
826 }
827
drm_mode_destroyblob_ioctl(struct drm_device * dev,void * data,struct drm_file * file_priv)828 int drm_mode_destroyblob_ioctl(struct drm_device *dev,
829 void *data, struct drm_file *file_priv)
830 {
831 struct drm_mode_destroy_blob *out_resp = data;
832 struct drm_property_blob *blob = NULL, *bt;
833 bool found = false;
834 int ret = 0;
835
836 if (!drm_core_check_feature(dev, DRIVER_MODESET))
837 return -EOPNOTSUPP;
838
839 blob = drm_property_lookup_blob(dev, out_resp->blob_id);
840 if (!blob)
841 return -ENOENT;
842
843 mutex_lock(&dev->mode_config.blob_lock);
844 /* Ensure the property was actually created by this user. */
845 list_for_each_entry(bt, &file_priv->blobs, head_file) {
846 if (bt == blob) {
847 found = true;
848 break;
849 }
850 }
851
852 if (!found) {
853 ret = -EPERM;
854 goto err;
855 }
856
857 /* We must drop head_file here, because we may not be the last
858 * reference on the blob. */
859 list_del_init(&blob->head_file);
860 mutex_unlock(&dev->mode_config.blob_lock);
861
862 /* One reference from lookup, and one from the filp. */
863 drm_property_blob_put(blob);
864 drm_property_blob_put(blob);
865
866 return 0;
867
868 err:
869 mutex_unlock(&dev->mode_config.blob_lock);
870 drm_property_blob_put(blob);
871
872 return ret;
873 }
874
875 /* Some properties could refer to dynamic refcnt'd objects, or things that
876 * need special locking to handle lifetime issues (ie. to ensure the prop
877 * value doesn't become invalid part way through the property update due to
878 * race). The value returned by reference via 'obj' should be passed back
879 * to drm_property_change_valid_put() after the property is set (and the
880 * object to which the property is attached has a chance to take its own
881 * reference).
882 */
drm_property_change_valid_get(struct drm_property * property,uint64_t value,struct drm_mode_object ** ref)883 bool drm_property_change_valid_get(struct drm_property *property,
884 uint64_t value, struct drm_mode_object **ref)
885 {
886 int i;
887
888 if (property->flags & DRM_MODE_PROP_IMMUTABLE)
889 return false;
890
891 *ref = NULL;
892
893 if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) {
894 if (value < property->values[0] || value > property->values[1])
895 return false;
896 return true;
897 } else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) {
898 int64_t svalue = U642I64(value);
899
900 if (svalue < U642I64(property->values[0]) ||
901 svalue > U642I64(property->values[1]))
902 return false;
903 return true;
904 } else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
905 uint64_t valid_mask = 0;
906
907 for (i = 0; i < property->num_values; i++)
908 valid_mask |= (1ULL << property->values[i]);
909 return !(value & ~valid_mask);
910 } else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
911 struct drm_property_blob *blob;
912
913 if (value == 0)
914 return true;
915
916 blob = drm_property_lookup_blob(property->dev, value);
917 if (blob) {
918 *ref = &blob->base;
919 return true;
920 } else {
921 return false;
922 }
923 } else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
924 /* a zero value for an object property translates to null: */
925 if (value == 0)
926 return true;
927
928 *ref = __drm_mode_object_find(property->dev, NULL, value,
929 property->values[0]);
930 return *ref != NULL;
931 }
932
933 for (i = 0; i < property->num_values; i++)
934 if (property->values[i] == value)
935 return true;
936 return false;
937 }
938
drm_property_change_valid_put(struct drm_property * property,struct drm_mode_object * ref)939 void drm_property_change_valid_put(struct drm_property *property,
940 struct drm_mode_object *ref)
941 {
942 if (!ref)
943 return;
944
945 if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
946 drm_mode_object_put(ref);
947 } else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
948 drm_property_blob_put(obj_to_blob(ref));
949 }
950