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