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_type_valid(struct drm_property *property)
55 if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE)
56 return !(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
57 return !!(property->flags & DRM_MODE_PROP_LEGACY_TYPE);
61 * drm_property_create - create a new property type
63 * @flags: flags specifying the property type
64 * @name: name of the property
65 * @num_values: number of pre-defined values
67 * This creates a new generic drm property which can then be attached to a drm
68 * object with drm_object_attach_property(). The returned property object must
69 * be freed with drm_property_destroy(), which is done automatically when
70 * calling drm_mode_config_cleanup().
73 * A pointer to the newly created property on success, NULL on failure.
75 struct drm_property *drm_property_create(struct drm_device *dev, int flags,
76 const char *name, int num_values)
78 struct drm_property *property = NULL;
81 property = kzalloc(sizeof(struct drm_property), GFP_KERNEL);
88 property->values = kcalloc(num_values, sizeof(uint64_t),
90 if (!property->values)
94 ret = drm_mode_object_add(dev, &property->base, DRM_MODE_OBJECT_PROPERTY);
98 property->flags = flags;
99 property->num_values = num_values;
100 INIT_LIST_HEAD(&property->enum_list);
103 strncpy(property->name, name, DRM_PROP_NAME_LEN);
104 property->name[DRM_PROP_NAME_LEN-1] = '\0';
107 list_add_tail(&property->head, &dev->mode_config.property_list);
109 WARN_ON(!drm_property_type_valid(property));
113 kfree(property->values);
117 EXPORT_SYMBOL(drm_property_create);
120 * drm_property_create_enum - create a new enumeration property type
122 * @flags: flags specifying the property type
123 * @name: name of the property
124 * @props: enumeration lists with property values
125 * @num_values: number of pre-defined values
127 * This creates a new generic drm property which can then be attached to a drm
128 * object with drm_object_attach_property(). The returned property object must
129 * be freed with drm_property_destroy(), which is done automatically when
130 * calling drm_mode_config_cleanup().
132 * Userspace is only allowed to set one of the predefined values for enumeration
136 * A pointer to the newly created property on success, NULL on failure.
138 struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags,
140 const struct drm_prop_enum_list *props,
143 struct drm_property *property;
146 flags |= DRM_MODE_PROP_ENUM;
148 property = drm_property_create(dev, flags, name, num_values);
152 for (i = 0; i < num_values; i++) {
153 ret = drm_property_add_enum(property, i,
157 drm_property_destroy(dev, property);
164 EXPORT_SYMBOL(drm_property_create_enum);
167 * drm_property_create_bitmask - create a new bitmask property type
169 * @flags: flags specifying the property type
170 * @name: name of the property
171 * @props: enumeration lists with property bitflags
172 * @num_props: size of the @props array
173 * @supported_bits: bitmask of all supported enumeration values
175 * This creates a new bitmask drm property which can then be attached to a drm
176 * object with drm_object_attach_property(). The returned property object must
177 * be freed with drm_property_destroy(), which is done automatically when
178 * calling drm_mode_config_cleanup().
180 * Compared to plain enumeration properties userspace is allowed to set any
181 * or'ed together combination of the predefined property bitflag values
184 * A pointer to the newly created property on success, NULL on failure.
186 struct drm_property *drm_property_create_bitmask(struct drm_device *dev,
187 int flags, const char *name,
188 const struct drm_prop_enum_list *props,
190 uint64_t supported_bits)
192 struct drm_property *property;
193 int i, ret, index = 0;
194 int num_values = hweight64(supported_bits);
196 flags |= DRM_MODE_PROP_BITMASK;
198 property = drm_property_create(dev, flags, name, num_values);
201 for (i = 0; i < num_props; i++) {
202 if (!(supported_bits & (1ULL << props[i].type)))
205 if (WARN_ON(index >= num_values)) {
206 drm_property_destroy(dev, property);
210 ret = drm_property_add_enum(property, index++,
214 drm_property_destroy(dev, property);
221 EXPORT_SYMBOL(drm_property_create_bitmask);
223 static struct drm_property *property_create_range(struct drm_device *dev,
224 int flags, const char *name,
225 uint64_t min, uint64_t max)
227 struct drm_property *property;
229 property = drm_property_create(dev, flags, name, 2);
233 property->values[0] = min;
234 property->values[1] = max;
240 * drm_property_create_range - create a new unsigned ranged property type
242 * @flags: flags specifying the property type
243 * @name: name of the property
244 * @min: minimum value of the property
245 * @max: maximum value of the property
247 * This creates a new generic drm property which can then be attached to a drm
248 * object with drm_object_attach_property(). The returned property object must
249 * be freed with drm_property_destroy(), which is done automatically when
250 * calling drm_mode_config_cleanup().
252 * Userspace is allowed to set any unsigned integer value in the (min, max)
256 * A pointer to the newly created property on success, NULL on failure.
258 struct drm_property *drm_property_create_range(struct drm_device *dev, int flags,
260 uint64_t min, uint64_t max)
262 return property_create_range(dev, DRM_MODE_PROP_RANGE | flags,
265 EXPORT_SYMBOL(drm_property_create_range);
268 * drm_property_create_signed_range - create a new signed ranged property type
270 * @flags: flags specifying the property type
271 * @name: name of the property
272 * @min: minimum value of the property
273 * @max: maximum value of the property
275 * This creates a new generic drm property which can then be attached to a drm
276 * object with drm_object_attach_property(). The returned property object must
277 * be freed with drm_property_destroy(), which is done automatically when
278 * calling drm_mode_config_cleanup().
280 * Userspace is allowed to set any signed integer value in the (min, max)
284 * A pointer to the newly created property on success, NULL on failure.
286 struct drm_property *drm_property_create_signed_range(struct drm_device *dev,
287 int flags, const char *name,
288 int64_t min, int64_t max)
290 return property_create_range(dev, DRM_MODE_PROP_SIGNED_RANGE | flags,
291 name, I642U64(min), I642U64(max));
293 EXPORT_SYMBOL(drm_property_create_signed_range);
296 * drm_property_create_object - create a new object property type
298 * @flags: flags specifying the property type
299 * @name: name of the property
300 * @type: object type from DRM_MODE_OBJECT_* defines
302 * This creates a new generic drm property which can then be attached to a drm
303 * object with drm_object_attach_property(). The returned property object must
304 * be freed with drm_property_destroy(), which is done automatically when
305 * calling drm_mode_config_cleanup().
307 * Userspace is only allowed to set this to any property value of the given
308 * @type. Only useful for atomic properties, which is enforced.
311 * A pointer to the newly created property on success, NULL on failure.
313 struct drm_property *drm_property_create_object(struct drm_device *dev,
314 int flags, const char *name,
317 struct drm_property *property;
319 flags |= DRM_MODE_PROP_OBJECT;
321 if (WARN_ON(!(flags & DRM_MODE_PROP_ATOMIC)))
324 property = drm_property_create(dev, flags, name, 1);
328 property->values[0] = type;
332 EXPORT_SYMBOL(drm_property_create_object);
335 * drm_property_create_bool - create a new boolean property type
337 * @flags: flags specifying the property type
338 * @name: name of the property
340 * This creates a new generic drm property which can then be attached to a drm
341 * object with drm_object_attach_property(). The returned property object must
342 * be freed with drm_property_destroy(), which is done automatically when
343 * calling drm_mode_config_cleanup().
345 * This is implemented as a ranged property with only {0, 1} as valid values.
348 * A pointer to the newly created property on success, NULL on failure.
350 struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags,
353 return drm_property_create_range(dev, flags, name, 0, 1);
355 EXPORT_SYMBOL(drm_property_create_bool);
358 * drm_property_add_enum - add a possible value to an enumeration property
359 * @property: enumeration property to change
360 * @index: index of the new enumeration
361 * @value: value of the new enumeration
362 * @name: symbolic name of the new enumeration
364 * This functions adds enumerations to a property.
366 * It's use is deprecated, drivers should use one of the more specific helpers
367 * to directly create the property with all enumerations already attached.
370 * Zero on success, error code on failure.
372 int drm_property_add_enum(struct drm_property *property, int index,
373 uint64_t value, const char *name)
375 struct drm_property_enum *prop_enum;
377 if (!(drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
378 drm_property_type_is(property, DRM_MODE_PROP_BITMASK)))
382 * Bitmask enum properties have the additional constraint of values
385 if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK) &&
389 if (!list_empty(&property->enum_list)) {
390 list_for_each_entry(prop_enum, &property->enum_list, head) {
391 if (prop_enum->value == value) {
392 strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
393 prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
399 prop_enum = kzalloc(sizeof(struct drm_property_enum), GFP_KERNEL);
403 strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
404 prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
405 prop_enum->value = value;
407 property->values[index] = value;
408 list_add_tail(&prop_enum->head, &property->enum_list);
411 EXPORT_SYMBOL(drm_property_add_enum);
414 * drm_property_destroy - destroy a drm property
416 * @property: property to destry
418 * This function frees a property including any attached resources like
419 * enumeration values.
421 void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
423 struct drm_property_enum *prop_enum, *pt;
425 list_for_each_entry_safe(prop_enum, pt, &property->enum_list, head) {
426 list_del(&prop_enum->head);
430 if (property->num_values)
431 kfree(property->values);
432 drm_mode_object_unregister(dev, &property->base);
433 list_del(&property->head);
436 EXPORT_SYMBOL(drm_property_destroy);
438 int drm_mode_getproperty_ioctl(struct drm_device *dev,
439 void *data, struct drm_file *file_priv)
441 struct drm_mode_get_property *out_resp = data;
442 struct drm_property *property;
446 struct drm_property_enum *prop_enum;
447 struct drm_mode_property_enum __user *enum_ptr;
448 uint64_t __user *values_ptr;
450 if (!drm_core_check_feature(dev, DRIVER_MODESET))
453 property = drm_property_find(dev, out_resp->prop_id);
457 strncpy(out_resp->name, property->name, DRM_PROP_NAME_LEN);
458 out_resp->name[DRM_PROP_NAME_LEN-1] = 0;
459 out_resp->flags = property->flags;
461 value_count = property->num_values;
462 values_ptr = u64_to_user_ptr(out_resp->values_ptr);
464 for (i = 0; i < value_count; i++) {
465 if (i < out_resp->count_values &&
466 put_user(property->values[i], values_ptr + i)) {
470 out_resp->count_values = value_count;
473 enum_ptr = u64_to_user_ptr(out_resp->enum_blob_ptr);
475 if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) ||
476 drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
477 list_for_each_entry(prop_enum, &property->enum_list, head) {
479 if (out_resp->count_enum_blobs < enum_count)
482 if (copy_to_user(&enum_ptr[copied].value,
483 &prop_enum->value, sizeof(uint64_t)))
486 if (copy_to_user(&enum_ptr[copied].name,
487 &prop_enum->name, DRM_PROP_NAME_LEN))
491 out_resp->count_enum_blobs = enum_count;
495 * NOTE: The idea seems to have been to use this to read all the blob
496 * property values. But nothing ever added them to the corresponding
497 * list, userspace always used the special-purpose get_blob ioctl to
498 * read the value for a blob property. It also doesn't make a lot of
499 * sense to return values here when everything else is just metadata for
500 * the property itself.
502 if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
503 out_resp->count_enum_blobs = 0;
508 static void drm_property_free_blob(struct kref *kref)
510 struct drm_property_blob *blob =
511 container_of(kref, struct drm_property_blob, base.refcount);
513 mutex_lock(&blob->dev->mode_config.blob_lock);
514 list_del(&blob->head_global);
515 mutex_unlock(&blob->dev->mode_config.blob_lock);
517 drm_mode_object_unregister(blob->dev, &blob->base);
523 * drm_property_create_blob - Create new blob property
524 * @dev: DRM device to create property for
525 * @length: Length to allocate for blob data
526 * @data: If specified, copies data into blob
528 * Creates a new blob property for a specified DRM device, optionally
529 * copying data. Note that blob properties are meant to be invariant, hence the
530 * data must be filled out before the blob is used as the value of any property.
533 * New blob property with a single reference on success, or an ERR_PTR
536 struct drm_property_blob *
537 drm_property_create_blob(struct drm_device *dev, size_t length,
540 struct drm_property_blob *blob;
543 if (!length || length > INT_MAX - sizeof(struct drm_property_blob))
544 return ERR_PTR(-EINVAL);
546 blob = kvzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
548 return ERR_PTR(-ENOMEM);
550 /* This must be explicitly initialised, so we can safely call list_del
551 * on it in the removal handler, even if it isn't in a file list. */
552 INIT_LIST_HEAD(&blob->head_file);
553 blob->length = length;
557 memcpy(blob->data, data, length);
559 ret = __drm_mode_object_add(dev, &blob->base, DRM_MODE_OBJECT_BLOB,
560 true, drm_property_free_blob);
563 return ERR_PTR(-EINVAL);
566 mutex_lock(&dev->mode_config.blob_lock);
567 list_add_tail(&blob->head_global,
568 &dev->mode_config.property_blob_list);
569 mutex_unlock(&dev->mode_config.blob_lock);
573 EXPORT_SYMBOL(drm_property_create_blob);
576 * drm_property_blob_put - release a blob property reference
577 * @blob: DRM blob property
579 * Releases a reference to a blob property. May free the object.
581 void drm_property_blob_put(struct drm_property_blob *blob)
586 drm_mode_object_put(&blob->base);
588 EXPORT_SYMBOL(drm_property_blob_put);
590 void drm_property_destroy_user_blobs(struct drm_device *dev,
591 struct drm_file *file_priv)
593 struct drm_property_blob *blob, *bt;
596 * When the file gets released that means no one else can access the
597 * blob list any more, so no need to grab dev->blob_lock.
599 list_for_each_entry_safe(blob, bt, &file_priv->blobs, head_file) {
600 list_del_init(&blob->head_file);
601 drm_property_blob_put(blob);
606 * drm_property_blob_get - acquire blob property reference
607 * @blob: DRM blob property
609 * Acquires a reference to an existing blob property. Returns @blob, which
610 * allows this to be used as a shorthand in assignments.
612 struct drm_property_blob *drm_property_blob_get(struct drm_property_blob *blob)
614 drm_mode_object_get(&blob->base);
617 EXPORT_SYMBOL(drm_property_blob_get);
620 * drm_property_lookup_blob - look up a blob property and take a reference
622 * @id: id of the blob property
624 * If successful, this takes an additional reference to the blob property.
625 * callers need to make sure to eventually unreference the returned property
626 * again, using drm_property_blob_put().
629 * NULL on failure, pointer to the blob on success.
631 struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev,
634 struct drm_mode_object *obj;
635 struct drm_property_blob *blob = NULL;
637 obj = __drm_mode_object_find(dev, id, DRM_MODE_OBJECT_BLOB);
639 blob = obj_to_blob(obj);
642 EXPORT_SYMBOL(drm_property_lookup_blob);
645 * drm_property_replace_global_blob - replace existing blob property
647 * @replace: location of blob property pointer to be replaced
648 * @length: length of data for new blob, or 0 for no data
649 * @data: content for new blob, or NULL for no data
650 * @obj_holds_id: optional object for property holding blob ID
651 * @prop_holds_id: optional property holding blob ID
652 * @return 0 on success or error on failure
654 * This function will replace a global property in the blob list, optionally
655 * updating a property which holds the ID of that property.
657 * If length is 0 or data is NULL, no new blob will be created, and the holding
658 * property, if specified, will be set to 0.
660 * Access to the replace pointer is assumed to be protected by the caller, e.g.
661 * by holding the relevant modesetting object lock for its parent.
663 * For example, a drm_connector has a 'PATH' property, which contains the ID
664 * of a blob property with the value of the MST path information. Calling this
665 * function with replace pointing to the connector's path_blob_ptr, length and
666 * data set for the new path information, obj_holds_id set to the connector's
667 * base object, and prop_holds_id set to the path property name, will perform
668 * a completely atomic update. The access to path_blob_ptr is protected by the
669 * caller holding a lock on the connector.
671 int drm_property_replace_global_blob(struct drm_device *dev,
672 struct drm_property_blob **replace,
675 struct drm_mode_object *obj_holds_id,
676 struct drm_property *prop_holds_id)
678 struct drm_property_blob *new_blob = NULL;
679 struct drm_property_blob *old_blob = NULL;
682 WARN_ON(replace == NULL);
686 if (length && data) {
687 new_blob = drm_property_create_blob(dev, length, data);
688 if (IS_ERR(new_blob))
689 return PTR_ERR(new_blob);
693 ret = drm_object_property_set_value(obj_holds_id,
696 new_blob->base.id : 0);
701 drm_property_blob_put(old_blob);
707 drm_property_blob_put(new_blob);
710 EXPORT_SYMBOL(drm_property_replace_global_blob);
713 * drm_property_replace_blob - replace a blob property
714 * @blob: a pointer to the member blob to be replaced
715 * @new_blob: the new blob to replace with
717 * Return: true if the blob was in fact replaced.
719 bool drm_property_replace_blob(struct drm_property_blob **blob,
720 struct drm_property_blob *new_blob)
722 struct drm_property_blob *old_blob = *blob;
724 if (old_blob == new_blob)
727 drm_property_blob_put(old_blob);
729 drm_property_blob_get(new_blob);
733 EXPORT_SYMBOL(drm_property_replace_blob);
735 int drm_mode_getblob_ioctl(struct drm_device *dev,
736 void *data, struct drm_file *file_priv)
738 struct drm_mode_get_blob *out_resp = data;
739 struct drm_property_blob *blob;
742 if (!drm_core_check_feature(dev, DRIVER_MODESET))
745 blob = drm_property_lookup_blob(dev, out_resp->blob_id);
749 if (out_resp->length == blob->length) {
750 if (copy_to_user(u64_to_user_ptr(out_resp->data),
757 out_resp->length = blob->length;
759 drm_property_blob_put(blob);
764 int drm_mode_createblob_ioctl(struct drm_device *dev,
765 void *data, struct drm_file *file_priv)
767 struct drm_mode_create_blob *out_resp = data;
768 struct drm_property_blob *blob;
771 if (!drm_core_check_feature(dev, DRIVER_MODESET))
774 blob = drm_property_create_blob(dev, out_resp->length, NULL);
776 return PTR_ERR(blob);
778 if (copy_from_user(blob->data,
779 u64_to_user_ptr(out_resp->data),
785 /* Dropping the lock between create_blob and our access here is safe
786 * as only the same file_priv can remove the blob; at this point, it is
787 * not associated with any file_priv. */
788 mutex_lock(&dev->mode_config.blob_lock);
789 out_resp->blob_id = blob->base.id;
790 list_add_tail(&blob->head_file, &file_priv->blobs);
791 mutex_unlock(&dev->mode_config.blob_lock);
796 drm_property_blob_put(blob);
800 int drm_mode_destroyblob_ioctl(struct drm_device *dev,
801 void *data, struct drm_file *file_priv)
803 struct drm_mode_destroy_blob *out_resp = data;
804 struct drm_property_blob *blob = NULL, *bt;
808 if (!drm_core_check_feature(dev, DRIVER_MODESET))
811 blob = drm_property_lookup_blob(dev, out_resp->blob_id);
815 mutex_lock(&dev->mode_config.blob_lock);
816 /* Ensure the property was actually created by this user. */
817 list_for_each_entry(bt, &file_priv->blobs, head_file) {
829 /* We must drop head_file here, because we may not be the last
830 * reference on the blob. */
831 list_del_init(&blob->head_file);
832 mutex_unlock(&dev->mode_config.blob_lock);
834 /* One reference from lookup, and one from the filp. */
835 drm_property_blob_put(blob);
836 drm_property_blob_put(blob);
841 mutex_unlock(&dev->mode_config.blob_lock);
842 drm_property_blob_put(blob);
847 /* Some properties could refer to dynamic refcnt'd objects, or things that
848 * need special locking to handle lifetime issues (ie. to ensure the prop
849 * value doesn't become invalid part way through the property update due to
850 * race). The value returned by reference via 'obj' should be passed back
851 * to drm_property_change_valid_put() after the property is set (and the
852 * object to which the property is attached has a chance to take it's own
855 bool drm_property_change_valid_get(struct drm_property *property,
856 uint64_t value, struct drm_mode_object **ref)
860 if (property->flags & DRM_MODE_PROP_IMMUTABLE)
865 if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) {
866 if (value < property->values[0] || value > property->values[1])
869 } else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) {
870 int64_t svalue = U642I64(value);
872 if (svalue < U642I64(property->values[0]) ||
873 svalue > U642I64(property->values[1]))
876 } else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) {
877 uint64_t valid_mask = 0;
879 for (i = 0; i < property->num_values; i++)
880 valid_mask |= (1ULL << property->values[i]);
881 return !(value & ~valid_mask);
882 } else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) {
883 struct drm_property_blob *blob;
888 blob = drm_property_lookup_blob(property->dev, value);
895 } else if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
896 /* a zero value for an object property translates to null: */
900 *ref = __drm_mode_object_find(property->dev, value,
901 property->values[0]);
905 for (i = 0; i < property->num_values; i++)
906 if (property->values[i] == value)
911 void drm_property_change_valid_put(struct drm_property *property,
912 struct drm_mode_object *ref)
917 if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) {
918 drm_mode_object_put(ref);
919 } else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB))
920 drm_property_blob_put(obj_to_blob(ref));