2 * Copyright (c) 2016 Intel Corporation
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.
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
23 #include <linux/export.h>
25 #include <drm/drm_property.h>
27 #include "drm_crtc_internal.h"
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.
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().
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.
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.
53 static bool drm_property_flags_valid(u32 flags)
55 u32 legacy_type = flags & DRM_MODE_PROP_LEGACY_TYPE;
56 u32 ext_type = flags & DRM_MODE_PROP_EXTENDED_TYPE;
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))
65 /* We want either a legacy type or an extended type, but not both */
66 if (!legacy_type == !ext_type)
69 /* Only one legacy type at a time please */
70 if (legacy_type && !is_power_of_2(legacy_type))
77 * drm_property_create - create a new property type
79 * @flags: flags specifying the property type
80 * @name: name of the property
81 * @num_values: number of pre-defined values
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().
89 * A pointer to the newly created property on success, NULL on failure.
91 struct drm_property *drm_property_create(struct drm_device *dev,
92 u32 flags, const char *name,
95 struct drm_property *property = NULL;
98 if (WARN_ON(!drm_property_flags_valid(flags)))
101 if (WARN_ON(strlen(name) >= DRM_PROP_NAME_LEN))
104 property = kzalloc(sizeof(struct drm_property), GFP_KERNEL);
111 property->values = kcalloc(num_values, sizeof(uint64_t),
113 if (!property->values)
117 ret = drm_mode_object_add(dev, &property->base, DRM_MODE_OBJECT_PROPERTY);
121 property->flags = flags;
122 property->num_values = num_values;
123 INIT_LIST_HEAD(&property->enum_list);
125 strncpy(property->name, name, DRM_PROP_NAME_LEN);
126 property->name[DRM_PROP_NAME_LEN-1] = '\0';
128 list_add_tail(&property->head, &dev->mode_config.property_list);
132 kfree(property->values);
136 EXPORT_SYMBOL(drm_property_create);
139 * drm_property_create_enum - create a new enumeration property type
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
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().
151 * Userspace is only allowed to set one of the predefined values for enumeration
155 * A pointer to the newly created property on success, NULL on failure.
157 struct drm_property *drm_property_create_enum(struct drm_device *dev,
158 u32 flags, const char *name,
159 const struct drm_prop_enum_list *props,
162 struct drm_property *property;
165 flags |= DRM_MODE_PROP_ENUM;
167 property = drm_property_create(dev, flags, name, num_values);
171 for (i = 0; i < num_values; i++) {
172 ret = drm_property_add_enum(property, i,
176 drm_property_destroy(dev, property);
183 EXPORT_SYMBOL(drm_property_create_enum);
186 * drm_property_create_bitmask - create a new bitmask property type
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
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().
199 * Compared to plain enumeration properties userspace is allowed to set any
200 * or'ed together combination of the predefined property bitflag values
203 * A pointer to the newly created property on success, NULL on failure.
205 struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
206 u32 flags, const char *name,
207 const struct drm_prop_enum_list *props,
209 uint64_t supported_bits)
211 struct drm_property *property;
212 int i, ret, index = 0;
213 int num_values = hweight64(supported_bits);
215 flags |= DRM_MODE_PROP_BITMASK;
217 property = drm_property_create(dev, flags, name, num_values);
220 for (i = 0; i < num_props; i++) {
221 if (!(supported_bits & (1ULL << props[i].type)))
224 if (WARN_ON(index >= num_values)) {
225 drm_property_destroy(dev, property);
229 ret = drm_property_add_enum(property, index++,
233 drm_property_destroy(dev, property);
240 EXPORT_SYMBOL(drm_property_create_bitmask);
242 static struct drm_property *property_create_range(struct drm_device *dev,
243 u32 flags, const char *name,
244 uint64_t min, uint64_t max)
246 struct drm_property *property;
248 property = drm_property_create(dev, flags, name, 2);
252 property->values[0] = min;
253 property->values[1] = max;
259 * drm_property_create_range - create a new unsigned ranged property type
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
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().
271 * Userspace is allowed to set any unsigned integer value in the (min, max)
275 * A pointer to the newly created property on success, NULL on failure.
277 struct drm_property *drm_property_create_range(struct drm_device *dev,
278 u32 flags, const char *name,
279 uint64_t min, uint64_t max)
281 return property_create_range(dev, DRM_MODE_PROP_RANGE | flags,
284 EXPORT_SYMBOL(drm_property_create_range);
287 * drm_property_create_signed_range - create a new signed ranged property type
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
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().
299 * Userspace is allowed to set any signed integer value in the (min, max)
303 * A pointer to the newly created property on success, NULL on failure.
305 struct drm_property *drm_property_create_signed_range(struct drm_device *dev,
306 u32 flags, const char *name,
307 int64_t min, int64_t max)
309 return property_create_range(dev, DRM_MODE_PROP_SIGNED_RANGE | flags,
310 name, I642U64(min), I642U64(max));
312 EXPORT_SYMBOL(drm_property_create_signed_range);
315 * drm_property_create_object - create a new object property type
317 * @flags: flags specifying the property type
318 * @name: name of the property
319 * @type: object type from DRM_MODE_OBJECT_* defines
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().
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.
330 * A pointer to the newly created property on success, NULL on failure.
332 struct drm_property *drm_property_create_object(struct drm_device *dev,
333 u32 flags, const char *name,
336 struct drm_property *property;
338 flags |= DRM_MODE_PROP_OBJECT;
340 if (WARN_ON(!(flags & DRM_MODE_PROP_ATOMIC)))
343 property = drm_property_create(dev, flags, name, 1);
347 property->values[0] = type;
351 EXPORT_SYMBOL(drm_property_create_object);
354 * drm_property_create_bool - create a new boolean property type
356 * @flags: flags specifying the property type
357 * @name: name of the property
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().
364 * This is implemented as a ranged property with only {0, 1} as valid values.
367 * A pointer to the newly created property on success, NULL on failure.
369 struct drm_property *drm_property_create_bool(struct drm_device *dev,
370 u32 flags, const char *name)
372 return drm_property_create_range(dev, flags, name, 0, 1);
374 EXPORT_SYMBOL(drm_property_create_bool);
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
383 * This functions adds enumerations to a property.
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.
389 * Zero on success, error code on failure.
391 int drm_property_add_enum(struct drm_property *property, int index,
392 uint64_t value, const char *name)
394 struct drm_property_enum *prop_enum;
396 if (WARN_ON(strlen(name) >= DRM_PROP_NAME_LEN))
399 if (WARN_ON(!drm_property_type_is(property, DRM_MODE_PROP_ENUM) &&
400 !drm_property_type_is(property, DRM_MODE_PROP_BITMASK)))
404 * Bitmask enum properties have the additional constraint of values
407 if (WARN_ON(drm_property_type_is(property, DRM_MODE_PROP_BITMASK) &&
411 list_for_each_entry(prop_enum, &property->enum_list, head) {
412 if (WARN_ON(prop_enum->value == value))
416 prop_enum = kzalloc(sizeof(struct drm_property_enum), GFP_KERNEL);
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;
424 property->values[index] = value;
425 list_add_tail(&prop_enum->head, &property->enum_list);
428 EXPORT_SYMBOL(drm_property_add_enum);
431 * drm_property_destroy - destroy a drm property
433 * @property: property to destry
435 * This function frees a property including any attached resources like
436 * enumeration values.
438 void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
440 struct drm_property_enum *prop_enum, *pt;
442 list_for_each_entry_safe(prop_enum, pt, &property->enum_list, head) {
443 list_del(&prop_enum->head);
447 if (property->num_values)
448 kfree(property->values);
449 drm_mode_object_unregister(dev, &property->base);
450 list_del(&property->head);
453 EXPORT_SYMBOL(drm_property_destroy);
455 int drm_mode_getproperty_ioctl(struct drm_device *dev,
456 void *data, struct drm_file *file_priv)
458 struct drm_mode_get_property *out_resp = data;
459 struct drm_property *property;
463 struct drm_property_enum *prop_enum;
464 struct drm_mode_property_enum __user *enum_ptr;
465 uint64_t __user *values_ptr;
467 if (!drm_core_check_feature(dev, DRIVER_MODESET))
470 property = drm_property_find(dev, file_priv, out_resp->prop_id);
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;
478 value_count = property->num_values;
479 values_ptr = u64_to_user_ptr(out_resp->values_ptr);
481 for (i = 0; i < value_count; i++) {
482 if (i < out_resp->count_values &&
483 put_user(property->values[i], values_ptr + i)) {
487 out_resp->count_values = value_count;
490 enum_ptr = u64_to_user_ptr(out_resp->enum_blob_ptr);
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) {
496 if (out_resp->count_enum_blobs < enum_count)
499 if (copy_to_user(&enum_ptr[copied].value,
500 &prop_enum->value, sizeof(uint64_t)))
503 if (copy_to_user(&enum_ptr[copied].name,
504 &prop_enum->name, DRM_PROP_NAME_LEN))
508 out_resp->count_enum_blobs = enum_count;
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.
519 if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
520 out_resp->count_enum_blobs = 0;
525 static void drm_property_free_blob(struct kref *kref)
527 struct drm_property_blob *blob =
528 container_of(kref, struct drm_property_blob, base.refcount);
530 mutex_lock(&blob->dev->mode_config.blob_lock);
531 list_del(&blob->head_global);
532 mutex_unlock(&blob->dev->mode_config.blob_lock);
534 drm_mode_object_unregister(blob->dev, &blob->base);
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
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.
550 * New blob property with a single reference on success, or an ERR_PTR
553 struct drm_property_blob *
554 drm_property_create_blob(struct drm_device *dev, size_t length,
557 struct drm_property_blob *blob;
560 if (!length || length > ULONG_MAX - sizeof(struct drm_property_blob))
561 return ERR_PTR(-EINVAL);
563 blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
565 return ERR_PTR(-ENOMEM);
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;
575 memcpy(blob->data, data, length);
577 ret = __drm_mode_object_add(dev, &blob->base, DRM_MODE_OBJECT_BLOB,
578 true, drm_property_free_blob);
581 return ERR_PTR(-EINVAL);
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);
591 EXPORT_SYMBOL(drm_property_create_blob);
594 * drm_property_blob_put - release a blob property reference
595 * @blob: DRM blob property
597 * Releases a reference to a blob property. May free the object.
599 void drm_property_blob_put(struct drm_property_blob *blob)
604 drm_mode_object_put(&blob->base);
606 EXPORT_SYMBOL(drm_property_blob_put);
608 void drm_property_destroy_user_blobs(struct drm_device *dev,
609 struct drm_file *file_priv)
611 struct drm_property_blob *blob, *bt;
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.
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);
624 * drm_property_blob_get - acquire blob property reference
625 * @blob: DRM blob property
627 * Acquires a reference to an existing blob property. Returns @blob, which
628 * allows this to be used as a shorthand in assignments.
630 struct drm_property_blob *drm_property_blob_get(struct drm_property_blob *blob)
632 drm_mode_object_get(&blob->base);
635 EXPORT_SYMBOL(drm_property_blob_get);
638 * drm_property_lookup_blob - look up a blob property and take a reference
640 * @id: id of the blob property
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().
647 * NULL on failure, pointer to the blob on success.
649 struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev,
652 struct drm_mode_object *obj;
653 struct drm_property_blob *blob = NULL;
655 obj = __drm_mode_object_find(dev, NULL, id, DRM_MODE_OBJECT_BLOB);
657 blob = obj_to_blob(obj);
660 EXPORT_SYMBOL(drm_property_lookup_blob);
663 * drm_property_replace_global_blob - replace existing blob property
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
672 * This function will replace a global property in the blob list, optionally
673 * updating a property which holds the ID of that property.
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.
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.
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.
689 int drm_property_replace_global_blob(struct drm_device *dev,
690 struct drm_property_blob **replace,
693 struct drm_mode_object *obj_holds_id,
694 struct drm_property *prop_holds_id)
696 struct drm_property_blob *new_blob = NULL;
697 struct drm_property_blob *old_blob = NULL;
700 WARN_ON(replace == NULL);
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);
711 ret = drm_object_property_set_value(obj_holds_id,
714 new_blob->base.id : 0);
719 drm_property_blob_put(old_blob);
725 drm_property_blob_put(new_blob);
728 EXPORT_SYMBOL(drm_property_replace_global_blob);
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
735 * Return: true if the blob was in fact replaced.
737 bool drm_property_replace_blob(struct drm_property_blob **blob,
738 struct drm_property_blob *new_blob)
740 struct drm_property_blob *old_blob = *blob;
742 if (old_blob == new_blob)
745 drm_property_blob_put(old_blob);
747 drm_property_blob_get(new_blob);
751 EXPORT_SYMBOL(drm_property_replace_blob);
753 int drm_mode_getblob_ioctl(struct drm_device *dev,
754 void *data, struct drm_file *file_priv)
756 struct drm_mode_get_blob *out_resp = data;
757 struct drm_property_blob *blob;
760 if (!drm_core_check_feature(dev, DRIVER_MODESET))
763 blob = drm_property_lookup_blob(dev, out_resp->blob_id);
767 if (out_resp->length == blob->length) {
768 if (copy_to_user(u64_to_user_ptr(out_resp->data),
775 out_resp->length = blob->length;
777 drm_property_blob_put(blob);
782 int drm_mode_createblob_ioctl(struct drm_device *dev,
783 void *data, struct drm_file *file_priv)
785 struct drm_mode_create_blob *out_resp = data;
786 struct drm_property_blob *blob;
789 if (!drm_core_check_feature(dev, DRIVER_MODESET))
792 blob = drm_property_create_blob(dev, out_resp->length, NULL);
794 return PTR_ERR(blob);
796 if (copy_from_user(blob->data,
797 u64_to_user_ptr(out_resp->data),
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);
814 drm_property_blob_put(blob);
818 int drm_mode_destroyblob_ioctl(struct drm_device *dev,
819 void *data, struct drm_file *file_priv)
821 struct drm_mode_destroy_blob *out_resp = data;
822 struct drm_property_blob *blob = NULL, *bt;
826 if (!drm_core_check_feature(dev, DRIVER_MODESET))
829 blob = drm_property_lookup_blob(dev, out_resp->blob_id);
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) {
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);
852 /* One reference from lookup, and one from the filp. */
853 drm_property_blob_put(blob);
854 drm_property_blob_put(blob);
859 mutex_unlock(&dev->mode_config.blob_lock);
860 drm_property_blob_put(blob);
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
873 bool drm_property_change_valid_get(struct drm_property *property,
874 uint64_t value, struct drm_mode_object **ref)
878 if (property->flags & DRM_MODE_PROP_IMMUTABLE)
883 if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) {
884 if (value < property->values[0] || value > property->values[1])
887 } else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) {
888 int64_t svalue = U642I64(value);
890 if (svalue < U642I64(property->values[0]) ||
891 svalue > U642I64(property->values[1]))
894 } else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
895 uint64_t valid_mask = 0;
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;
906 blob = drm_property_lookup_blob(property->dev, value);
913 } else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
914 /* a zero value for an object property translates to null: */
918 *ref = __drm_mode_object_find(property->dev, NULL, value,
919 property->values[0]);
923 for (i = 0; i < property->num_values; i++)
924 if (property->values[i] == value)
929 void drm_property_change_valid_put(struct drm_property *property,
930 struct drm_mode_object *ref)
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));