159e71ee7SDaniel Vetter /* 259e71ee7SDaniel Vetter * Copyright (c) 2016 Intel Corporation 359e71ee7SDaniel Vetter * 459e71ee7SDaniel Vetter * Permission to use, copy, modify, distribute, and sell this software and its 559e71ee7SDaniel Vetter * documentation for any purpose is hereby granted without fee, provided that 659e71ee7SDaniel Vetter * the above copyright notice appear in all copies and that both that copyright 759e71ee7SDaniel Vetter * notice and this permission notice appear in supporting documentation, and 859e71ee7SDaniel Vetter * that the name of the copyright holders not be used in advertising or 959e71ee7SDaniel Vetter * publicity pertaining to distribution of the software without specific, 1059e71ee7SDaniel Vetter * written prior permission. The copyright holders make no representations 1159e71ee7SDaniel Vetter * about the suitability of this software for any purpose. It is provided "as 1259e71ee7SDaniel Vetter * is" without express or implied warranty. 1359e71ee7SDaniel Vetter * 1459e71ee7SDaniel Vetter * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 1559e71ee7SDaniel Vetter * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 1659e71ee7SDaniel Vetter * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR 1759e71ee7SDaniel Vetter * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 1859e71ee7SDaniel Vetter * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 1959e71ee7SDaniel Vetter * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 2059e71ee7SDaniel Vetter * OF THIS SOFTWARE. 2159e71ee7SDaniel Vetter */ 2259e71ee7SDaniel Vetter 2359e71ee7SDaniel Vetter #include <linux/export.h> 2459e71ee7SDaniel Vetter #include <drm/drmP.h> 2559e71ee7SDaniel Vetter #include <drm/drm_property.h> 2659e71ee7SDaniel Vetter 2759e71ee7SDaniel Vetter #include "drm_crtc_internal.h" 2859e71ee7SDaniel Vetter 2959e71ee7SDaniel Vetter static bool drm_property_type_valid(struct drm_property *property) 3059e71ee7SDaniel Vetter { 3159e71ee7SDaniel Vetter if (property->flags & DRM_MODE_PROP_EXTENDED_TYPE) 3259e71ee7SDaniel Vetter return !(property->flags & DRM_MODE_PROP_LEGACY_TYPE); 3359e71ee7SDaniel Vetter return !!(property->flags & DRM_MODE_PROP_LEGACY_TYPE); 3459e71ee7SDaniel Vetter } 3559e71ee7SDaniel Vetter 3659e71ee7SDaniel Vetter /** 3759e71ee7SDaniel Vetter * drm_property_create - create a new property type 3859e71ee7SDaniel Vetter * @dev: drm device 3959e71ee7SDaniel Vetter * @flags: flags specifying the property type 4059e71ee7SDaniel Vetter * @name: name of the property 4159e71ee7SDaniel Vetter * @num_values: number of pre-defined values 4259e71ee7SDaniel Vetter * 4359e71ee7SDaniel Vetter * This creates a new generic drm property which can then be attached to a drm 4459e71ee7SDaniel Vetter * object with drm_object_attach_property. The returned property object must be 4559e71ee7SDaniel Vetter * freed with drm_property_destroy. 4659e71ee7SDaniel Vetter * 4759e71ee7SDaniel Vetter * Note that the DRM core keeps a per-device list of properties and that, if 4859e71ee7SDaniel Vetter * drm_mode_config_cleanup() is called, it will destroy all properties created 4959e71ee7SDaniel Vetter * by the driver. 5059e71ee7SDaniel Vetter * 5159e71ee7SDaniel Vetter * Returns: 5259e71ee7SDaniel Vetter * A pointer to the newly created property on success, NULL on failure. 5359e71ee7SDaniel Vetter */ 5459e71ee7SDaniel Vetter struct drm_property *drm_property_create(struct drm_device *dev, int flags, 5559e71ee7SDaniel Vetter const char *name, int num_values) 5659e71ee7SDaniel Vetter { 5759e71ee7SDaniel Vetter struct drm_property *property = NULL; 5859e71ee7SDaniel Vetter int ret; 5959e71ee7SDaniel Vetter 6059e71ee7SDaniel Vetter property = kzalloc(sizeof(struct drm_property), GFP_KERNEL); 6159e71ee7SDaniel Vetter if (!property) 6259e71ee7SDaniel Vetter return NULL; 6359e71ee7SDaniel Vetter 6459e71ee7SDaniel Vetter property->dev = dev; 6559e71ee7SDaniel Vetter 6659e71ee7SDaniel Vetter if (num_values) { 6759e71ee7SDaniel Vetter property->values = kcalloc(num_values, sizeof(uint64_t), 6859e71ee7SDaniel Vetter GFP_KERNEL); 6959e71ee7SDaniel Vetter if (!property->values) 7059e71ee7SDaniel Vetter goto fail; 7159e71ee7SDaniel Vetter } 7259e71ee7SDaniel Vetter 7359e71ee7SDaniel Vetter ret = drm_mode_object_get(dev, &property->base, DRM_MODE_OBJECT_PROPERTY); 7459e71ee7SDaniel Vetter if (ret) 7559e71ee7SDaniel Vetter goto fail; 7659e71ee7SDaniel Vetter 7759e71ee7SDaniel Vetter property->flags = flags; 7859e71ee7SDaniel Vetter property->num_values = num_values; 7959e71ee7SDaniel Vetter INIT_LIST_HEAD(&property->enum_list); 8059e71ee7SDaniel Vetter 8159e71ee7SDaniel Vetter if (name) { 8259e71ee7SDaniel Vetter strncpy(property->name, name, DRM_PROP_NAME_LEN); 8359e71ee7SDaniel Vetter property->name[DRM_PROP_NAME_LEN-1] = '\0'; 8459e71ee7SDaniel Vetter } 8559e71ee7SDaniel Vetter 8659e71ee7SDaniel Vetter list_add_tail(&property->head, &dev->mode_config.property_list); 8759e71ee7SDaniel Vetter 8859e71ee7SDaniel Vetter WARN_ON(!drm_property_type_valid(property)); 8959e71ee7SDaniel Vetter 9059e71ee7SDaniel Vetter return property; 9159e71ee7SDaniel Vetter fail: 9259e71ee7SDaniel Vetter kfree(property->values); 9359e71ee7SDaniel Vetter kfree(property); 9459e71ee7SDaniel Vetter return NULL; 9559e71ee7SDaniel Vetter } 9659e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_create); 9759e71ee7SDaniel Vetter 9859e71ee7SDaniel Vetter /** 9959e71ee7SDaniel Vetter * drm_property_create_enum - create a new enumeration property type 10059e71ee7SDaniel Vetter * @dev: drm device 10159e71ee7SDaniel Vetter * @flags: flags specifying the property type 10259e71ee7SDaniel Vetter * @name: name of the property 10359e71ee7SDaniel Vetter * @props: enumeration lists with property values 10459e71ee7SDaniel Vetter * @num_values: number of pre-defined values 10559e71ee7SDaniel Vetter * 10659e71ee7SDaniel Vetter * This creates a new generic drm property which can then be attached to a drm 10759e71ee7SDaniel Vetter * object with drm_object_attach_property. The returned property object must be 10859e71ee7SDaniel Vetter * freed with drm_property_destroy. 10959e71ee7SDaniel Vetter * 11059e71ee7SDaniel Vetter * Userspace is only allowed to set one of the predefined values for enumeration 11159e71ee7SDaniel Vetter * properties. 11259e71ee7SDaniel Vetter * 11359e71ee7SDaniel Vetter * Returns: 11459e71ee7SDaniel Vetter * A pointer to the newly created property on success, NULL on failure. 11559e71ee7SDaniel Vetter */ 11659e71ee7SDaniel Vetter struct drm_property *drm_property_create_enum(struct drm_device *dev, int flags, 11759e71ee7SDaniel Vetter const char *name, 11859e71ee7SDaniel Vetter const struct drm_prop_enum_list *props, 11959e71ee7SDaniel Vetter int num_values) 12059e71ee7SDaniel Vetter { 12159e71ee7SDaniel Vetter struct drm_property *property; 12259e71ee7SDaniel Vetter int i, ret; 12359e71ee7SDaniel Vetter 12459e71ee7SDaniel Vetter flags |= DRM_MODE_PROP_ENUM; 12559e71ee7SDaniel Vetter 12659e71ee7SDaniel Vetter property = drm_property_create(dev, flags, name, num_values); 12759e71ee7SDaniel Vetter if (!property) 12859e71ee7SDaniel Vetter return NULL; 12959e71ee7SDaniel Vetter 13059e71ee7SDaniel Vetter for (i = 0; i < num_values; i++) { 13159e71ee7SDaniel Vetter ret = drm_property_add_enum(property, i, 13259e71ee7SDaniel Vetter props[i].type, 13359e71ee7SDaniel Vetter props[i].name); 13459e71ee7SDaniel Vetter if (ret) { 13559e71ee7SDaniel Vetter drm_property_destroy(dev, property); 13659e71ee7SDaniel Vetter return NULL; 13759e71ee7SDaniel Vetter } 13859e71ee7SDaniel Vetter } 13959e71ee7SDaniel Vetter 14059e71ee7SDaniel Vetter return property; 14159e71ee7SDaniel Vetter } 14259e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_create_enum); 14359e71ee7SDaniel Vetter 14459e71ee7SDaniel Vetter /** 14559e71ee7SDaniel Vetter * drm_property_create_bitmask - create a new bitmask property type 14659e71ee7SDaniel Vetter * @dev: drm device 14759e71ee7SDaniel Vetter * @flags: flags specifying the property type 14859e71ee7SDaniel Vetter * @name: name of the property 14959e71ee7SDaniel Vetter * @props: enumeration lists with property bitflags 15059e71ee7SDaniel Vetter * @num_props: size of the @props array 15159e71ee7SDaniel Vetter * @supported_bits: bitmask of all supported enumeration values 15259e71ee7SDaniel Vetter * 15359e71ee7SDaniel Vetter * This creates a new bitmask drm property which can then be attached to a drm 15459e71ee7SDaniel Vetter * object with drm_object_attach_property. The returned property object must be 15559e71ee7SDaniel Vetter * freed with drm_property_destroy. 15659e71ee7SDaniel Vetter * 15759e71ee7SDaniel Vetter * Compared to plain enumeration properties userspace is allowed to set any 15859e71ee7SDaniel Vetter * or'ed together combination of the predefined property bitflag values 15959e71ee7SDaniel Vetter * 16059e71ee7SDaniel Vetter * Returns: 16159e71ee7SDaniel Vetter * A pointer to the newly created property on success, NULL on failure. 16259e71ee7SDaniel Vetter */ 16359e71ee7SDaniel Vetter struct drm_property *drm_property_create_bitmask(struct drm_device *dev, 16459e71ee7SDaniel Vetter int flags, const char *name, 16559e71ee7SDaniel Vetter const struct drm_prop_enum_list *props, 16659e71ee7SDaniel Vetter int num_props, 16759e71ee7SDaniel Vetter uint64_t supported_bits) 16859e71ee7SDaniel Vetter { 16959e71ee7SDaniel Vetter struct drm_property *property; 17059e71ee7SDaniel Vetter int i, ret, index = 0; 17159e71ee7SDaniel Vetter int num_values = hweight64(supported_bits); 17259e71ee7SDaniel Vetter 17359e71ee7SDaniel Vetter flags |= DRM_MODE_PROP_BITMASK; 17459e71ee7SDaniel Vetter 17559e71ee7SDaniel Vetter property = drm_property_create(dev, flags, name, num_values); 17659e71ee7SDaniel Vetter if (!property) 17759e71ee7SDaniel Vetter return NULL; 17859e71ee7SDaniel Vetter for (i = 0; i < num_props; i++) { 17959e71ee7SDaniel Vetter if (!(supported_bits & (1ULL << props[i].type))) 18059e71ee7SDaniel Vetter continue; 18159e71ee7SDaniel Vetter 18259e71ee7SDaniel Vetter if (WARN_ON(index >= num_values)) { 18359e71ee7SDaniel Vetter drm_property_destroy(dev, property); 18459e71ee7SDaniel Vetter return NULL; 18559e71ee7SDaniel Vetter } 18659e71ee7SDaniel Vetter 18759e71ee7SDaniel Vetter ret = drm_property_add_enum(property, index++, 18859e71ee7SDaniel Vetter props[i].type, 18959e71ee7SDaniel Vetter props[i].name); 19059e71ee7SDaniel Vetter if (ret) { 19159e71ee7SDaniel Vetter drm_property_destroy(dev, property); 19259e71ee7SDaniel Vetter return NULL; 19359e71ee7SDaniel Vetter } 19459e71ee7SDaniel Vetter } 19559e71ee7SDaniel Vetter 19659e71ee7SDaniel Vetter return property; 19759e71ee7SDaniel Vetter } 19859e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_create_bitmask); 19959e71ee7SDaniel Vetter 20059e71ee7SDaniel Vetter static struct drm_property *property_create_range(struct drm_device *dev, 20159e71ee7SDaniel Vetter int flags, const char *name, 20259e71ee7SDaniel Vetter uint64_t min, uint64_t max) 20359e71ee7SDaniel Vetter { 20459e71ee7SDaniel Vetter struct drm_property *property; 20559e71ee7SDaniel Vetter 20659e71ee7SDaniel Vetter property = drm_property_create(dev, flags, name, 2); 20759e71ee7SDaniel Vetter if (!property) 20859e71ee7SDaniel Vetter return NULL; 20959e71ee7SDaniel Vetter 21059e71ee7SDaniel Vetter property->values[0] = min; 21159e71ee7SDaniel Vetter property->values[1] = max; 21259e71ee7SDaniel Vetter 21359e71ee7SDaniel Vetter return property; 21459e71ee7SDaniel Vetter } 21559e71ee7SDaniel Vetter 21659e71ee7SDaniel Vetter /** 21759e71ee7SDaniel Vetter * drm_property_create_range - create a new unsigned ranged property type 21859e71ee7SDaniel Vetter * @dev: drm device 21959e71ee7SDaniel Vetter * @flags: flags specifying the property type 22059e71ee7SDaniel Vetter * @name: name of the property 22159e71ee7SDaniel Vetter * @min: minimum value of the property 22259e71ee7SDaniel Vetter * @max: maximum value of the property 22359e71ee7SDaniel Vetter * 22459e71ee7SDaniel Vetter * This creates a new generic drm property which can then be attached to a drm 22559e71ee7SDaniel Vetter * object with drm_object_attach_property. The returned property object must be 22659e71ee7SDaniel Vetter * freed with drm_property_destroy. 22759e71ee7SDaniel Vetter * 22859e71ee7SDaniel Vetter * Userspace is allowed to set any unsigned integer value in the (min, max) 22959e71ee7SDaniel Vetter * range inclusive. 23059e71ee7SDaniel Vetter * 23159e71ee7SDaniel Vetter * Returns: 23259e71ee7SDaniel Vetter * A pointer to the newly created property on success, NULL on failure. 23359e71ee7SDaniel Vetter */ 23459e71ee7SDaniel Vetter struct drm_property *drm_property_create_range(struct drm_device *dev, int flags, 23559e71ee7SDaniel Vetter const char *name, 23659e71ee7SDaniel Vetter uint64_t min, uint64_t max) 23759e71ee7SDaniel Vetter { 23859e71ee7SDaniel Vetter return property_create_range(dev, DRM_MODE_PROP_RANGE | flags, 23959e71ee7SDaniel Vetter name, min, max); 24059e71ee7SDaniel Vetter } 24159e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_create_range); 24259e71ee7SDaniel Vetter 24359e71ee7SDaniel Vetter /** 24459e71ee7SDaniel Vetter * drm_property_create_signed_range - create a new signed ranged property type 24559e71ee7SDaniel Vetter * @dev: drm device 24659e71ee7SDaniel Vetter * @flags: flags specifying the property type 24759e71ee7SDaniel Vetter * @name: name of the property 24859e71ee7SDaniel Vetter * @min: minimum value of the property 24959e71ee7SDaniel Vetter * @max: maximum value of the property 25059e71ee7SDaniel Vetter * 25159e71ee7SDaniel Vetter * This creates a new generic drm property which can then be attached to a drm 25259e71ee7SDaniel Vetter * object with drm_object_attach_property. The returned property object must be 25359e71ee7SDaniel Vetter * freed with drm_property_destroy. 25459e71ee7SDaniel Vetter * 25559e71ee7SDaniel Vetter * Userspace is allowed to set any signed integer value in the (min, max) 25659e71ee7SDaniel Vetter * range inclusive. 25759e71ee7SDaniel Vetter * 25859e71ee7SDaniel Vetter * Returns: 25959e71ee7SDaniel Vetter * A pointer to the newly created property on success, NULL on failure. 26059e71ee7SDaniel Vetter */ 26159e71ee7SDaniel Vetter struct drm_property *drm_property_create_signed_range(struct drm_device *dev, 26259e71ee7SDaniel Vetter int flags, const char *name, 26359e71ee7SDaniel Vetter int64_t min, int64_t max) 26459e71ee7SDaniel Vetter { 26559e71ee7SDaniel Vetter return property_create_range(dev, DRM_MODE_PROP_SIGNED_RANGE | flags, 26659e71ee7SDaniel Vetter name, I642U64(min), I642U64(max)); 26759e71ee7SDaniel Vetter } 26859e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_create_signed_range); 26959e71ee7SDaniel Vetter 27059e71ee7SDaniel Vetter /** 27159e71ee7SDaniel Vetter * drm_property_create_object - create a new object property type 27259e71ee7SDaniel Vetter * @dev: drm device 27359e71ee7SDaniel Vetter * @flags: flags specifying the property type 27459e71ee7SDaniel Vetter * @name: name of the property 27559e71ee7SDaniel Vetter * @type: object type from DRM_MODE_OBJECT_* defines 27659e71ee7SDaniel Vetter * 27759e71ee7SDaniel Vetter * This creates a new generic drm property which can then be attached to a drm 27859e71ee7SDaniel Vetter * object with drm_object_attach_property. The returned property object must be 27959e71ee7SDaniel Vetter * freed with drm_property_destroy. 28059e71ee7SDaniel Vetter * 28159e71ee7SDaniel Vetter * Userspace is only allowed to set this to any property value of the given 28259e71ee7SDaniel Vetter * @type. Only useful for atomic properties, which is enforced. 28359e71ee7SDaniel Vetter * 28459e71ee7SDaniel Vetter * Returns: 28559e71ee7SDaniel Vetter * A pointer to the newly created property on success, NULL on failure. 28659e71ee7SDaniel Vetter */ 28759e71ee7SDaniel Vetter struct drm_property *drm_property_create_object(struct drm_device *dev, 28859e71ee7SDaniel Vetter int flags, const char *name, uint32_t type) 28959e71ee7SDaniel Vetter { 29059e71ee7SDaniel Vetter struct drm_property *property; 29159e71ee7SDaniel Vetter 29259e71ee7SDaniel Vetter flags |= DRM_MODE_PROP_OBJECT; 29359e71ee7SDaniel Vetter 29459e71ee7SDaniel Vetter if (WARN_ON(!(flags & DRM_MODE_PROP_ATOMIC))) 29559e71ee7SDaniel Vetter return NULL; 29659e71ee7SDaniel Vetter 29759e71ee7SDaniel Vetter property = drm_property_create(dev, flags, name, 1); 29859e71ee7SDaniel Vetter if (!property) 29959e71ee7SDaniel Vetter return NULL; 30059e71ee7SDaniel Vetter 30159e71ee7SDaniel Vetter property->values[0] = type; 30259e71ee7SDaniel Vetter 30359e71ee7SDaniel Vetter return property; 30459e71ee7SDaniel Vetter } 30559e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_create_object); 30659e71ee7SDaniel Vetter 30759e71ee7SDaniel Vetter /** 30859e71ee7SDaniel Vetter * drm_property_create_bool - create a new boolean property type 30959e71ee7SDaniel Vetter * @dev: drm device 31059e71ee7SDaniel Vetter * @flags: flags specifying the property type 31159e71ee7SDaniel Vetter * @name: name of the property 31259e71ee7SDaniel Vetter * 31359e71ee7SDaniel Vetter * This creates a new generic drm property which can then be attached to a drm 31459e71ee7SDaniel Vetter * object with drm_object_attach_property. The returned property object must be 31559e71ee7SDaniel Vetter * freed with drm_property_destroy. 31659e71ee7SDaniel Vetter * 31759e71ee7SDaniel Vetter * This is implemented as a ranged property with only {0, 1} as valid values. 31859e71ee7SDaniel Vetter * 31959e71ee7SDaniel Vetter * Returns: 32059e71ee7SDaniel Vetter * A pointer to the newly created property on success, NULL on failure. 32159e71ee7SDaniel Vetter */ 32259e71ee7SDaniel Vetter struct drm_property *drm_property_create_bool(struct drm_device *dev, int flags, 32359e71ee7SDaniel Vetter const char *name) 32459e71ee7SDaniel Vetter { 32559e71ee7SDaniel Vetter return drm_property_create_range(dev, flags, name, 0, 1); 32659e71ee7SDaniel Vetter } 32759e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_create_bool); 32859e71ee7SDaniel Vetter 32959e71ee7SDaniel Vetter /** 33059e71ee7SDaniel Vetter * drm_property_add_enum - add a possible value to an enumeration property 33159e71ee7SDaniel Vetter * @property: enumeration property to change 33259e71ee7SDaniel Vetter * @index: index of the new enumeration 33359e71ee7SDaniel Vetter * @value: value of the new enumeration 33459e71ee7SDaniel Vetter * @name: symbolic name of the new enumeration 33559e71ee7SDaniel Vetter * 33659e71ee7SDaniel Vetter * This functions adds enumerations to a property. 33759e71ee7SDaniel Vetter * 33859e71ee7SDaniel Vetter * It's use is deprecated, drivers should use one of the more specific helpers 33959e71ee7SDaniel Vetter * to directly create the property with all enumerations already attached. 34059e71ee7SDaniel Vetter * 34159e71ee7SDaniel Vetter * Returns: 34259e71ee7SDaniel Vetter * Zero on success, error code on failure. 34359e71ee7SDaniel Vetter */ 34459e71ee7SDaniel Vetter int drm_property_add_enum(struct drm_property *property, int index, 34559e71ee7SDaniel Vetter uint64_t value, const char *name) 34659e71ee7SDaniel Vetter { 34759e71ee7SDaniel Vetter struct drm_property_enum *prop_enum; 34859e71ee7SDaniel Vetter 34959e71ee7SDaniel Vetter if (!(drm_property_type_is(property, DRM_MODE_PROP_ENUM) || 35059e71ee7SDaniel Vetter drm_property_type_is(property, DRM_MODE_PROP_BITMASK))) 35159e71ee7SDaniel Vetter return -EINVAL; 35259e71ee7SDaniel Vetter 35359e71ee7SDaniel Vetter /* 35459e71ee7SDaniel Vetter * Bitmask enum properties have the additional constraint of values 35559e71ee7SDaniel Vetter * from 0 to 63 35659e71ee7SDaniel Vetter */ 35759e71ee7SDaniel Vetter if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK) && 35859e71ee7SDaniel Vetter (value > 63)) 35959e71ee7SDaniel Vetter return -EINVAL; 36059e71ee7SDaniel Vetter 36159e71ee7SDaniel Vetter if (!list_empty(&property->enum_list)) { 36259e71ee7SDaniel Vetter list_for_each_entry(prop_enum, &property->enum_list, head) { 36359e71ee7SDaniel Vetter if (prop_enum->value == value) { 36459e71ee7SDaniel Vetter strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN); 36559e71ee7SDaniel Vetter prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0'; 36659e71ee7SDaniel Vetter return 0; 36759e71ee7SDaniel Vetter } 36859e71ee7SDaniel Vetter } 36959e71ee7SDaniel Vetter } 37059e71ee7SDaniel Vetter 37159e71ee7SDaniel Vetter prop_enum = kzalloc(sizeof(struct drm_property_enum), GFP_KERNEL); 37259e71ee7SDaniel Vetter if (!prop_enum) 37359e71ee7SDaniel Vetter return -ENOMEM; 37459e71ee7SDaniel Vetter 37559e71ee7SDaniel Vetter strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN); 37659e71ee7SDaniel Vetter prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0'; 37759e71ee7SDaniel Vetter prop_enum->value = value; 37859e71ee7SDaniel Vetter 37959e71ee7SDaniel Vetter property->values[index] = value; 38059e71ee7SDaniel Vetter list_add_tail(&prop_enum->head, &property->enum_list); 38159e71ee7SDaniel Vetter return 0; 38259e71ee7SDaniel Vetter } 38359e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_add_enum); 38459e71ee7SDaniel Vetter 38559e71ee7SDaniel Vetter /** 38659e71ee7SDaniel Vetter * drm_property_destroy - destroy a drm property 38759e71ee7SDaniel Vetter * @dev: drm device 38859e71ee7SDaniel Vetter * @property: property to destry 38959e71ee7SDaniel Vetter * 39059e71ee7SDaniel Vetter * This function frees a property including any attached resources like 39159e71ee7SDaniel Vetter * enumeration values. 39259e71ee7SDaniel Vetter */ 39359e71ee7SDaniel Vetter void drm_property_destroy(struct drm_device *dev, struct drm_property *property) 39459e71ee7SDaniel Vetter { 39559e71ee7SDaniel Vetter struct drm_property_enum *prop_enum, *pt; 39659e71ee7SDaniel Vetter 39759e71ee7SDaniel Vetter list_for_each_entry_safe(prop_enum, pt, &property->enum_list, head) { 39859e71ee7SDaniel Vetter list_del(&prop_enum->head); 39959e71ee7SDaniel Vetter kfree(prop_enum); 40059e71ee7SDaniel Vetter } 40159e71ee7SDaniel Vetter 40259e71ee7SDaniel Vetter if (property->num_values) 40359e71ee7SDaniel Vetter kfree(property->values); 40459e71ee7SDaniel Vetter drm_mode_object_unregister(dev, &property->base); 40559e71ee7SDaniel Vetter list_del(&property->head); 40659e71ee7SDaniel Vetter kfree(property); 40759e71ee7SDaniel Vetter } 40859e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_destroy); 40959e71ee7SDaniel Vetter 41059e71ee7SDaniel Vetter /** 41159e71ee7SDaniel Vetter * drm_mode_getproperty_ioctl - get the property metadata 41259e71ee7SDaniel Vetter * @dev: DRM device 41359e71ee7SDaniel Vetter * @data: ioctl data 41459e71ee7SDaniel Vetter * @file_priv: DRM file info 41559e71ee7SDaniel Vetter * 41659e71ee7SDaniel Vetter * This function retrieves the metadata for a given property, like the different 41759e71ee7SDaniel Vetter * possible values for an enum property or the limits for a range property. 41859e71ee7SDaniel Vetter * 41959e71ee7SDaniel Vetter * Blob properties are special 42059e71ee7SDaniel Vetter * 42159e71ee7SDaniel Vetter * Called by the user via ioctl. 42259e71ee7SDaniel Vetter * 42359e71ee7SDaniel Vetter * Returns: 42459e71ee7SDaniel Vetter * Zero on success, negative errno on failure. 42559e71ee7SDaniel Vetter */ 42659e71ee7SDaniel Vetter int drm_mode_getproperty_ioctl(struct drm_device *dev, 42759e71ee7SDaniel Vetter void *data, struct drm_file *file_priv) 42859e71ee7SDaniel Vetter { 42959e71ee7SDaniel Vetter struct drm_mode_get_property *out_resp = data; 43059e71ee7SDaniel Vetter struct drm_property *property; 43159e71ee7SDaniel Vetter int enum_count = 0; 43259e71ee7SDaniel Vetter int value_count = 0; 43359e71ee7SDaniel Vetter int ret = 0, i; 43459e71ee7SDaniel Vetter int copied; 43559e71ee7SDaniel Vetter struct drm_property_enum *prop_enum; 43659e71ee7SDaniel Vetter struct drm_mode_property_enum __user *enum_ptr; 43759e71ee7SDaniel Vetter uint64_t __user *values_ptr; 43859e71ee7SDaniel Vetter 43959e71ee7SDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_MODESET)) 44059e71ee7SDaniel Vetter return -EINVAL; 44159e71ee7SDaniel Vetter 44259e71ee7SDaniel Vetter drm_modeset_lock_all(dev); 44359e71ee7SDaniel Vetter property = drm_property_find(dev, out_resp->prop_id); 44459e71ee7SDaniel Vetter if (!property) { 44559e71ee7SDaniel Vetter ret = -ENOENT; 44659e71ee7SDaniel Vetter goto done; 44759e71ee7SDaniel Vetter } 44859e71ee7SDaniel Vetter 44959e71ee7SDaniel Vetter if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) || 45059e71ee7SDaniel Vetter drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) { 45159e71ee7SDaniel Vetter list_for_each_entry(prop_enum, &property->enum_list, head) 45259e71ee7SDaniel Vetter enum_count++; 45359e71ee7SDaniel Vetter } 45459e71ee7SDaniel Vetter 45559e71ee7SDaniel Vetter value_count = property->num_values; 45659e71ee7SDaniel Vetter 45759e71ee7SDaniel Vetter strncpy(out_resp->name, property->name, DRM_PROP_NAME_LEN); 45859e71ee7SDaniel Vetter out_resp->name[DRM_PROP_NAME_LEN-1] = 0; 45959e71ee7SDaniel Vetter out_resp->flags = property->flags; 46059e71ee7SDaniel Vetter 46159e71ee7SDaniel Vetter if ((out_resp->count_values >= value_count) && value_count) { 46259e71ee7SDaniel Vetter values_ptr = (uint64_t __user *)(unsigned long)out_resp->values_ptr; 46359e71ee7SDaniel Vetter for (i = 0; i < value_count; i++) { 46459e71ee7SDaniel Vetter if (copy_to_user(values_ptr + i, &property->values[i], sizeof(uint64_t))) { 46559e71ee7SDaniel Vetter ret = -EFAULT; 46659e71ee7SDaniel Vetter goto done; 46759e71ee7SDaniel Vetter } 46859e71ee7SDaniel Vetter } 46959e71ee7SDaniel Vetter } 47059e71ee7SDaniel Vetter out_resp->count_values = value_count; 47159e71ee7SDaniel Vetter 47259e71ee7SDaniel Vetter if (drm_property_type_is(property, DRM_MODE_PROP_ENUM) || 47359e71ee7SDaniel Vetter drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) { 47459e71ee7SDaniel Vetter if ((out_resp->count_enum_blobs >= enum_count) && enum_count) { 47559e71ee7SDaniel Vetter copied = 0; 47659e71ee7SDaniel Vetter enum_ptr = (struct drm_mode_property_enum __user *)(unsigned long)out_resp->enum_blob_ptr; 47759e71ee7SDaniel Vetter list_for_each_entry(prop_enum, &property->enum_list, head) { 47859e71ee7SDaniel Vetter 47959e71ee7SDaniel Vetter if (copy_to_user(&enum_ptr[copied].value, &prop_enum->value, sizeof(uint64_t))) { 48059e71ee7SDaniel Vetter ret = -EFAULT; 48159e71ee7SDaniel Vetter goto done; 48259e71ee7SDaniel Vetter } 48359e71ee7SDaniel Vetter 48459e71ee7SDaniel Vetter if (copy_to_user(&enum_ptr[copied].name, 48559e71ee7SDaniel Vetter &prop_enum->name, DRM_PROP_NAME_LEN)) { 48659e71ee7SDaniel Vetter ret = -EFAULT; 48759e71ee7SDaniel Vetter goto done; 48859e71ee7SDaniel Vetter } 48959e71ee7SDaniel Vetter copied++; 49059e71ee7SDaniel Vetter } 49159e71ee7SDaniel Vetter } 49259e71ee7SDaniel Vetter out_resp->count_enum_blobs = enum_count; 49359e71ee7SDaniel Vetter } 49459e71ee7SDaniel Vetter 49559e71ee7SDaniel Vetter /* 49659e71ee7SDaniel Vetter * NOTE: The idea seems to have been to use this to read all the blob 49759e71ee7SDaniel Vetter * property values. But nothing ever added them to the corresponding 49859e71ee7SDaniel Vetter * list, userspace always used the special-purpose get_blob ioctl to 49959e71ee7SDaniel Vetter * read the value for a blob property. It also doesn't make a lot of 50059e71ee7SDaniel Vetter * sense to return values here when everything else is just metadata for 50159e71ee7SDaniel Vetter * the property itself. 50259e71ee7SDaniel Vetter */ 50359e71ee7SDaniel Vetter if (drm_property_type_is(property, DRM_MODE_PROP_BLOB)) 50459e71ee7SDaniel Vetter out_resp->count_enum_blobs = 0; 50559e71ee7SDaniel Vetter done: 50659e71ee7SDaniel Vetter drm_modeset_unlock_all(dev); 50759e71ee7SDaniel Vetter return ret; 50859e71ee7SDaniel Vetter } 50959e71ee7SDaniel Vetter 51059e71ee7SDaniel Vetter static void drm_property_free_blob(struct kref *kref) 51159e71ee7SDaniel Vetter { 51259e71ee7SDaniel Vetter struct drm_property_blob *blob = 51359e71ee7SDaniel Vetter container_of(kref, struct drm_property_blob, base.refcount); 51459e71ee7SDaniel Vetter 51559e71ee7SDaniel Vetter mutex_lock(&blob->dev->mode_config.blob_lock); 51659e71ee7SDaniel Vetter list_del(&blob->head_global); 51759e71ee7SDaniel Vetter mutex_unlock(&blob->dev->mode_config.blob_lock); 51859e71ee7SDaniel Vetter 51959e71ee7SDaniel Vetter drm_mode_object_unregister(blob->dev, &blob->base); 52059e71ee7SDaniel Vetter 52159e71ee7SDaniel Vetter kfree(blob); 52259e71ee7SDaniel Vetter } 52359e71ee7SDaniel Vetter 52459e71ee7SDaniel Vetter /** 52559e71ee7SDaniel Vetter * drm_property_create_blob - Create new blob property 52659e71ee7SDaniel Vetter * 52759e71ee7SDaniel Vetter * Creates a new blob property for a specified DRM device, optionally 52859e71ee7SDaniel Vetter * copying data. 52959e71ee7SDaniel Vetter * 53059e71ee7SDaniel Vetter * @dev: DRM device to create property for 53159e71ee7SDaniel Vetter * @length: Length to allocate for blob data 53259e71ee7SDaniel Vetter * @data: If specified, copies data into blob 53359e71ee7SDaniel Vetter * 53459e71ee7SDaniel Vetter * Returns: 53559e71ee7SDaniel Vetter * New blob property with a single reference on success, or an ERR_PTR 53659e71ee7SDaniel Vetter * value on failure. 53759e71ee7SDaniel Vetter */ 53859e71ee7SDaniel Vetter struct drm_property_blob * 53959e71ee7SDaniel Vetter drm_property_create_blob(struct drm_device *dev, size_t length, 54059e71ee7SDaniel Vetter const void *data) 54159e71ee7SDaniel Vetter { 54259e71ee7SDaniel Vetter struct drm_property_blob *blob; 54359e71ee7SDaniel Vetter int ret; 54459e71ee7SDaniel Vetter 54559e71ee7SDaniel Vetter if (!length || length > ULONG_MAX - sizeof(struct drm_property_blob)) 54659e71ee7SDaniel Vetter return ERR_PTR(-EINVAL); 54759e71ee7SDaniel Vetter 54859e71ee7SDaniel Vetter blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL); 54959e71ee7SDaniel Vetter if (!blob) 55059e71ee7SDaniel Vetter return ERR_PTR(-ENOMEM); 55159e71ee7SDaniel Vetter 55259e71ee7SDaniel Vetter /* This must be explicitly initialised, so we can safely call list_del 55359e71ee7SDaniel Vetter * on it in the removal handler, even if it isn't in a file list. */ 55459e71ee7SDaniel Vetter INIT_LIST_HEAD(&blob->head_file); 55559e71ee7SDaniel Vetter blob->length = length; 55659e71ee7SDaniel Vetter blob->dev = dev; 55759e71ee7SDaniel Vetter 55859e71ee7SDaniel Vetter if (data) 55959e71ee7SDaniel Vetter memcpy(blob->data, data, length); 56059e71ee7SDaniel Vetter 56159e71ee7SDaniel Vetter ret = drm_mode_object_get_reg(dev, &blob->base, DRM_MODE_OBJECT_BLOB, 56259e71ee7SDaniel Vetter true, drm_property_free_blob); 56359e71ee7SDaniel Vetter if (ret) { 56459e71ee7SDaniel Vetter kfree(blob); 56559e71ee7SDaniel Vetter return ERR_PTR(-EINVAL); 56659e71ee7SDaniel Vetter } 56759e71ee7SDaniel Vetter 56859e71ee7SDaniel Vetter mutex_lock(&dev->mode_config.blob_lock); 56959e71ee7SDaniel Vetter list_add_tail(&blob->head_global, 57059e71ee7SDaniel Vetter &dev->mode_config.property_blob_list); 57159e71ee7SDaniel Vetter mutex_unlock(&dev->mode_config.blob_lock); 57259e71ee7SDaniel Vetter 57359e71ee7SDaniel Vetter return blob; 57459e71ee7SDaniel Vetter } 57559e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_create_blob); 57659e71ee7SDaniel Vetter 57759e71ee7SDaniel Vetter /** 57859e71ee7SDaniel Vetter * drm_property_unreference_blob - Unreference a blob property 57959e71ee7SDaniel Vetter * 58059e71ee7SDaniel Vetter * Drop a reference on a blob property. May free the object. 58159e71ee7SDaniel Vetter * 58259e71ee7SDaniel Vetter * @blob: Pointer to blob property 58359e71ee7SDaniel Vetter */ 58459e71ee7SDaniel Vetter void drm_property_unreference_blob(struct drm_property_blob *blob) 58559e71ee7SDaniel Vetter { 58659e71ee7SDaniel Vetter if (!blob) 58759e71ee7SDaniel Vetter return; 58859e71ee7SDaniel Vetter 58959e71ee7SDaniel Vetter drm_mode_object_unreference(&blob->base); 59059e71ee7SDaniel Vetter } 59159e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_unreference_blob); 59259e71ee7SDaniel Vetter 59359e71ee7SDaniel Vetter /** 59459e71ee7SDaniel Vetter * drm_property_destroy_user_blobs - destroy all blobs created by this client 59559e71ee7SDaniel Vetter * @dev: DRM device 59659e71ee7SDaniel Vetter * @file_priv: destroy all blobs owned by this file handle 59759e71ee7SDaniel Vetter */ 59859e71ee7SDaniel Vetter void drm_property_destroy_user_blobs(struct drm_device *dev, 59959e71ee7SDaniel Vetter struct drm_file *file_priv) 60059e71ee7SDaniel Vetter { 60159e71ee7SDaniel Vetter struct drm_property_blob *blob, *bt; 60259e71ee7SDaniel Vetter 60359e71ee7SDaniel Vetter /* 60459e71ee7SDaniel Vetter * When the file gets released that means no one else can access the 60559e71ee7SDaniel Vetter * blob list any more, so no need to grab dev->blob_lock. 60659e71ee7SDaniel Vetter */ 60759e71ee7SDaniel Vetter list_for_each_entry_safe(blob, bt, &file_priv->blobs, head_file) { 60859e71ee7SDaniel Vetter list_del_init(&blob->head_file); 60959e71ee7SDaniel Vetter drm_property_unreference_blob(blob); 61059e71ee7SDaniel Vetter } 61159e71ee7SDaniel Vetter } 61259e71ee7SDaniel Vetter 61359e71ee7SDaniel Vetter /** 61459e71ee7SDaniel Vetter * drm_property_reference_blob - Take a reference on an existing property 61559e71ee7SDaniel Vetter * 61659e71ee7SDaniel Vetter * Take a new reference on an existing blob property. 61759e71ee7SDaniel Vetter * 61859e71ee7SDaniel Vetter * @blob: Pointer to blob property 61959e71ee7SDaniel Vetter */ 62059e71ee7SDaniel Vetter struct drm_property_blob *drm_property_reference_blob(struct drm_property_blob *blob) 62159e71ee7SDaniel Vetter { 62259e71ee7SDaniel Vetter drm_mode_object_reference(&blob->base); 62359e71ee7SDaniel Vetter return blob; 62459e71ee7SDaniel Vetter } 62559e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_reference_blob); 62659e71ee7SDaniel Vetter 62759e71ee7SDaniel Vetter /** 62859e71ee7SDaniel Vetter * drm_property_lookup_blob - look up a blob property and take a reference 62959e71ee7SDaniel Vetter * @dev: drm device 63059e71ee7SDaniel Vetter * @id: id of the blob property 63159e71ee7SDaniel Vetter * 63259e71ee7SDaniel Vetter * If successful, this takes an additional reference to the blob property. 63359e71ee7SDaniel Vetter * callers need to make sure to eventually unreference the returned property 63459e71ee7SDaniel Vetter * again, using @drm_property_unreference_blob. 63559e71ee7SDaniel Vetter */ 63659e71ee7SDaniel Vetter struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev, 63759e71ee7SDaniel Vetter uint32_t id) 63859e71ee7SDaniel Vetter { 63959e71ee7SDaniel Vetter struct drm_mode_object *obj; 64059e71ee7SDaniel Vetter struct drm_property_blob *blob = NULL; 64159e71ee7SDaniel Vetter 64259e71ee7SDaniel Vetter obj = __drm_mode_object_find(dev, id, DRM_MODE_OBJECT_BLOB); 64359e71ee7SDaniel Vetter if (obj) 64459e71ee7SDaniel Vetter blob = obj_to_blob(obj); 64559e71ee7SDaniel Vetter return blob; 64659e71ee7SDaniel Vetter } 64759e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_lookup_blob); 64859e71ee7SDaniel Vetter 64959e71ee7SDaniel Vetter /** 65059e71ee7SDaniel Vetter * drm_property_replace_global_blob - atomically replace existing blob property 65159e71ee7SDaniel Vetter * @dev: drm device 65259e71ee7SDaniel Vetter * @replace: location of blob property pointer to be replaced 65359e71ee7SDaniel Vetter * @length: length of data for new blob, or 0 for no data 65459e71ee7SDaniel Vetter * @data: content for new blob, or NULL for no data 65559e71ee7SDaniel Vetter * @obj_holds_id: optional object for property holding blob ID 65659e71ee7SDaniel Vetter * @prop_holds_id: optional property holding blob ID 65759e71ee7SDaniel Vetter * @return 0 on success or error on failure 65859e71ee7SDaniel Vetter * 65959e71ee7SDaniel Vetter * This function will atomically replace a global property in the blob list, 66059e71ee7SDaniel Vetter * optionally updating a property which holds the ID of that property. It is 66159e71ee7SDaniel Vetter * guaranteed to be atomic: no caller will be allowed to see intermediate 66259e71ee7SDaniel Vetter * results, and either the entire operation will succeed and clean up the 66359e71ee7SDaniel Vetter * previous property, or it will fail and the state will be unchanged. 66459e71ee7SDaniel Vetter * 66559e71ee7SDaniel Vetter * If length is 0 or data is NULL, no new blob will be created, and the holding 66659e71ee7SDaniel Vetter * property, if specified, will be set to 0. 66759e71ee7SDaniel Vetter * 66859e71ee7SDaniel Vetter * Access to the replace pointer is assumed to be protected by the caller, e.g. 66959e71ee7SDaniel Vetter * by holding the relevant modesetting object lock for its parent. 67059e71ee7SDaniel Vetter * 67159e71ee7SDaniel Vetter * For example, a drm_connector has a 'PATH' property, which contains the ID 67259e71ee7SDaniel Vetter * of a blob property with the value of the MST path information. Calling this 67359e71ee7SDaniel Vetter * function with replace pointing to the connector's path_blob_ptr, length and 67459e71ee7SDaniel Vetter * data set for the new path information, obj_holds_id set to the connector's 67559e71ee7SDaniel Vetter * base object, and prop_holds_id set to the path property name, will perform 67659e71ee7SDaniel Vetter * a completely atomic update. The access to path_blob_ptr is protected by the 67759e71ee7SDaniel Vetter * caller holding a lock on the connector. 67859e71ee7SDaniel Vetter */ 67959e71ee7SDaniel Vetter int drm_property_replace_global_blob(struct drm_device *dev, 68059e71ee7SDaniel Vetter struct drm_property_blob **replace, 68159e71ee7SDaniel Vetter size_t length, 68259e71ee7SDaniel Vetter const void *data, 68359e71ee7SDaniel Vetter struct drm_mode_object *obj_holds_id, 68459e71ee7SDaniel Vetter struct drm_property *prop_holds_id) 68559e71ee7SDaniel Vetter { 68659e71ee7SDaniel Vetter struct drm_property_blob *new_blob = NULL; 68759e71ee7SDaniel Vetter struct drm_property_blob *old_blob = NULL; 68859e71ee7SDaniel Vetter int ret; 68959e71ee7SDaniel Vetter 69059e71ee7SDaniel Vetter WARN_ON(replace == NULL); 69159e71ee7SDaniel Vetter 69259e71ee7SDaniel Vetter old_blob = *replace; 69359e71ee7SDaniel Vetter 69459e71ee7SDaniel Vetter if (length && data) { 69559e71ee7SDaniel Vetter new_blob = drm_property_create_blob(dev, length, data); 69659e71ee7SDaniel Vetter if (IS_ERR(new_blob)) 69759e71ee7SDaniel Vetter return PTR_ERR(new_blob); 69859e71ee7SDaniel Vetter } 69959e71ee7SDaniel Vetter 70059e71ee7SDaniel Vetter /* This does not need to be synchronised with blob_lock, as the 70159e71ee7SDaniel Vetter * get_properties ioctl locks all modesetting objects, and 70259e71ee7SDaniel Vetter * obj_holds_id must be locked before calling here, so we cannot 70359e71ee7SDaniel Vetter * have its value out of sync with the list membership modified 70459e71ee7SDaniel Vetter * below under blob_lock. */ 70559e71ee7SDaniel Vetter if (obj_holds_id) { 70659e71ee7SDaniel Vetter ret = drm_object_property_set_value(obj_holds_id, 70759e71ee7SDaniel Vetter prop_holds_id, 70859e71ee7SDaniel Vetter new_blob ? 70959e71ee7SDaniel Vetter new_blob->base.id : 0); 71059e71ee7SDaniel Vetter if (ret != 0) 71159e71ee7SDaniel Vetter goto err_created; 71259e71ee7SDaniel Vetter } 71359e71ee7SDaniel Vetter 71459e71ee7SDaniel Vetter drm_property_unreference_blob(old_blob); 71559e71ee7SDaniel Vetter *replace = new_blob; 71659e71ee7SDaniel Vetter 71759e71ee7SDaniel Vetter return 0; 71859e71ee7SDaniel Vetter 71959e71ee7SDaniel Vetter err_created: 72059e71ee7SDaniel Vetter drm_property_unreference_blob(new_blob); 72159e71ee7SDaniel Vetter return ret; 72259e71ee7SDaniel Vetter } 72359e71ee7SDaniel Vetter EXPORT_SYMBOL(drm_property_replace_global_blob); 72459e71ee7SDaniel Vetter 72559e71ee7SDaniel Vetter /** 72659e71ee7SDaniel Vetter * drm_mode_getblob_ioctl - get the contents of a blob property value 72759e71ee7SDaniel Vetter * @dev: DRM device 72859e71ee7SDaniel Vetter * @data: ioctl data 72959e71ee7SDaniel Vetter * @file_priv: DRM file info 73059e71ee7SDaniel Vetter * 73159e71ee7SDaniel Vetter * This function retrieves the contents of a blob property. The value stored in 73259e71ee7SDaniel Vetter * an object's blob property is just a normal modeset object id. 73359e71ee7SDaniel Vetter * 73459e71ee7SDaniel Vetter * Called by the user via ioctl. 73559e71ee7SDaniel Vetter * 73659e71ee7SDaniel Vetter * Returns: 73759e71ee7SDaniel Vetter * Zero on success, negative errno on failure. 73859e71ee7SDaniel Vetter */ 73959e71ee7SDaniel Vetter int drm_mode_getblob_ioctl(struct drm_device *dev, 74059e71ee7SDaniel Vetter void *data, struct drm_file *file_priv) 74159e71ee7SDaniel Vetter { 74259e71ee7SDaniel Vetter struct drm_mode_get_blob *out_resp = data; 74359e71ee7SDaniel Vetter struct drm_property_blob *blob; 74459e71ee7SDaniel Vetter int ret = 0; 74559e71ee7SDaniel Vetter void __user *blob_ptr; 74659e71ee7SDaniel Vetter 74759e71ee7SDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_MODESET)) 74859e71ee7SDaniel Vetter return -EINVAL; 74959e71ee7SDaniel Vetter 75059e71ee7SDaniel Vetter blob = drm_property_lookup_blob(dev, out_resp->blob_id); 75159e71ee7SDaniel Vetter if (!blob) 75259e71ee7SDaniel Vetter return -ENOENT; 75359e71ee7SDaniel Vetter 75459e71ee7SDaniel Vetter if (out_resp->length == blob->length) { 75559e71ee7SDaniel Vetter blob_ptr = (void __user *)(unsigned long)out_resp->data; 75659e71ee7SDaniel Vetter if (copy_to_user(blob_ptr, blob->data, blob->length)) { 75759e71ee7SDaniel Vetter ret = -EFAULT; 75859e71ee7SDaniel Vetter goto unref; 75959e71ee7SDaniel Vetter } 76059e71ee7SDaniel Vetter } 76159e71ee7SDaniel Vetter out_resp->length = blob->length; 76259e71ee7SDaniel Vetter unref: 76359e71ee7SDaniel Vetter drm_property_unreference_blob(blob); 76459e71ee7SDaniel Vetter 76559e71ee7SDaniel Vetter return ret; 76659e71ee7SDaniel Vetter } 76759e71ee7SDaniel Vetter 76859e71ee7SDaniel Vetter /** 76959e71ee7SDaniel Vetter * drm_mode_createblob_ioctl - create a new blob property 77059e71ee7SDaniel Vetter * @dev: DRM device 77159e71ee7SDaniel Vetter * @data: ioctl data 77259e71ee7SDaniel Vetter * @file_priv: DRM file info 77359e71ee7SDaniel Vetter * 77459e71ee7SDaniel Vetter * This function creates a new blob property with user-defined values. In order 77559e71ee7SDaniel Vetter * to give us sensible validation and checking when creating, rather than at 77659e71ee7SDaniel Vetter * every potential use, we also require a type to be provided upfront. 77759e71ee7SDaniel Vetter * 77859e71ee7SDaniel Vetter * Called by the user via ioctl. 77959e71ee7SDaniel Vetter * 78059e71ee7SDaniel Vetter * Returns: 78159e71ee7SDaniel Vetter * Zero on success, negative errno on failure. 78259e71ee7SDaniel Vetter */ 78359e71ee7SDaniel Vetter int drm_mode_createblob_ioctl(struct drm_device *dev, 78459e71ee7SDaniel Vetter void *data, struct drm_file *file_priv) 78559e71ee7SDaniel Vetter { 78659e71ee7SDaniel Vetter struct drm_mode_create_blob *out_resp = data; 78759e71ee7SDaniel Vetter struct drm_property_blob *blob; 78859e71ee7SDaniel Vetter void __user *blob_ptr; 78959e71ee7SDaniel Vetter int ret = 0; 79059e71ee7SDaniel Vetter 79159e71ee7SDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_MODESET)) 79259e71ee7SDaniel Vetter return -EINVAL; 79359e71ee7SDaniel Vetter 79459e71ee7SDaniel Vetter blob = drm_property_create_blob(dev, out_resp->length, NULL); 79559e71ee7SDaniel Vetter if (IS_ERR(blob)) 79659e71ee7SDaniel Vetter return PTR_ERR(blob); 79759e71ee7SDaniel Vetter 79859e71ee7SDaniel Vetter blob_ptr = (void __user *)(unsigned long)out_resp->data; 79959e71ee7SDaniel Vetter if (copy_from_user(blob->data, blob_ptr, out_resp->length)) { 80059e71ee7SDaniel Vetter ret = -EFAULT; 80159e71ee7SDaniel Vetter goto out_blob; 80259e71ee7SDaniel Vetter } 80359e71ee7SDaniel Vetter 80459e71ee7SDaniel Vetter /* Dropping the lock between create_blob and our access here is safe 80559e71ee7SDaniel Vetter * as only the same file_priv can remove the blob; at this point, it is 80659e71ee7SDaniel Vetter * not associated with any file_priv. */ 80759e71ee7SDaniel Vetter mutex_lock(&dev->mode_config.blob_lock); 80859e71ee7SDaniel Vetter out_resp->blob_id = blob->base.id; 80959e71ee7SDaniel Vetter list_add_tail(&blob->head_file, &file_priv->blobs); 81059e71ee7SDaniel Vetter mutex_unlock(&dev->mode_config.blob_lock); 81159e71ee7SDaniel Vetter 81259e71ee7SDaniel Vetter return 0; 81359e71ee7SDaniel Vetter 81459e71ee7SDaniel Vetter out_blob: 81559e71ee7SDaniel Vetter drm_property_unreference_blob(blob); 81659e71ee7SDaniel Vetter return ret; 81759e71ee7SDaniel Vetter } 81859e71ee7SDaniel Vetter 81959e71ee7SDaniel Vetter /** 82059e71ee7SDaniel Vetter * drm_mode_destroyblob_ioctl - destroy a user blob property 82159e71ee7SDaniel Vetter * @dev: DRM device 82259e71ee7SDaniel Vetter * @data: ioctl data 82359e71ee7SDaniel Vetter * @file_priv: DRM file info 82459e71ee7SDaniel Vetter * 82559e71ee7SDaniel Vetter * Destroy an existing user-defined blob property. 82659e71ee7SDaniel Vetter * 82759e71ee7SDaniel Vetter * Called by the user via ioctl. 82859e71ee7SDaniel Vetter * 82959e71ee7SDaniel Vetter * Returns: 83059e71ee7SDaniel Vetter * Zero on success, negative errno on failure. 83159e71ee7SDaniel Vetter */ 83259e71ee7SDaniel Vetter int drm_mode_destroyblob_ioctl(struct drm_device *dev, 83359e71ee7SDaniel Vetter void *data, struct drm_file *file_priv) 83459e71ee7SDaniel Vetter { 83559e71ee7SDaniel Vetter struct drm_mode_destroy_blob *out_resp = data; 83659e71ee7SDaniel Vetter struct drm_property_blob *blob = NULL, *bt; 83759e71ee7SDaniel Vetter bool found = false; 83859e71ee7SDaniel Vetter int ret = 0; 83959e71ee7SDaniel Vetter 84059e71ee7SDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_MODESET)) 84159e71ee7SDaniel Vetter return -EINVAL; 84259e71ee7SDaniel Vetter 84359e71ee7SDaniel Vetter blob = drm_property_lookup_blob(dev, out_resp->blob_id); 84459e71ee7SDaniel Vetter if (!blob) 84559e71ee7SDaniel Vetter return -ENOENT; 84659e71ee7SDaniel Vetter 84759e71ee7SDaniel Vetter mutex_lock(&dev->mode_config.blob_lock); 84859e71ee7SDaniel Vetter /* Ensure the property was actually created by this user. */ 84959e71ee7SDaniel Vetter list_for_each_entry(bt, &file_priv->blobs, head_file) { 85059e71ee7SDaniel Vetter if (bt == blob) { 85159e71ee7SDaniel Vetter found = true; 85259e71ee7SDaniel Vetter break; 85359e71ee7SDaniel Vetter } 85459e71ee7SDaniel Vetter } 85559e71ee7SDaniel Vetter 85659e71ee7SDaniel Vetter if (!found) { 85759e71ee7SDaniel Vetter ret = -EPERM; 85859e71ee7SDaniel Vetter goto err; 85959e71ee7SDaniel Vetter } 86059e71ee7SDaniel Vetter 86159e71ee7SDaniel Vetter /* We must drop head_file here, because we may not be the last 86259e71ee7SDaniel Vetter * reference on the blob. */ 86359e71ee7SDaniel Vetter list_del_init(&blob->head_file); 86459e71ee7SDaniel Vetter mutex_unlock(&dev->mode_config.blob_lock); 86559e71ee7SDaniel Vetter 86659e71ee7SDaniel Vetter /* One reference from lookup, and one from the filp. */ 86759e71ee7SDaniel Vetter drm_property_unreference_blob(blob); 86859e71ee7SDaniel Vetter drm_property_unreference_blob(blob); 86959e71ee7SDaniel Vetter 87059e71ee7SDaniel Vetter return 0; 87159e71ee7SDaniel Vetter 87259e71ee7SDaniel Vetter err: 87359e71ee7SDaniel Vetter mutex_unlock(&dev->mode_config.blob_lock); 87459e71ee7SDaniel Vetter drm_property_unreference_blob(blob); 87559e71ee7SDaniel Vetter 87659e71ee7SDaniel Vetter return ret; 87759e71ee7SDaniel Vetter } 87859e71ee7SDaniel Vetter 87959e71ee7SDaniel Vetter /* Some properties could refer to dynamic refcnt'd objects, or things that 88059e71ee7SDaniel Vetter * need special locking to handle lifetime issues (ie. to ensure the prop 88159e71ee7SDaniel Vetter * value doesn't become invalid part way through the property update due to 88259e71ee7SDaniel Vetter * race). The value returned by reference via 'obj' should be passed back 88359e71ee7SDaniel Vetter * to drm_property_change_valid_put() after the property is set (and the 88459e71ee7SDaniel Vetter * object to which the property is attached has a chance to take it's own 88559e71ee7SDaniel Vetter * reference). 88659e71ee7SDaniel Vetter */ 88759e71ee7SDaniel Vetter bool drm_property_change_valid_get(struct drm_property *property, 88859e71ee7SDaniel Vetter uint64_t value, struct drm_mode_object **ref) 88959e71ee7SDaniel Vetter { 89059e71ee7SDaniel Vetter int i; 89159e71ee7SDaniel Vetter 89259e71ee7SDaniel Vetter if (property->flags & DRM_MODE_PROP_IMMUTABLE) 89359e71ee7SDaniel Vetter return false; 89459e71ee7SDaniel Vetter 89559e71ee7SDaniel Vetter *ref = NULL; 89659e71ee7SDaniel Vetter 89759e71ee7SDaniel Vetter if (drm_property_type_is(property, DRM_MODE_PROP_RANGE)) { 89859e71ee7SDaniel Vetter if (value < property->values[0] || value > property->values[1]) 89959e71ee7SDaniel Vetter return false; 90059e71ee7SDaniel Vetter return true; 90159e71ee7SDaniel Vetter } else if (drm_property_type_is(property, DRM_MODE_PROP_SIGNED_RANGE)) { 90259e71ee7SDaniel Vetter int64_t svalue = U642I64(value); 90359e71ee7SDaniel Vetter 90459e71ee7SDaniel Vetter if (svalue < U642I64(property->values[0]) || 90559e71ee7SDaniel Vetter svalue > U642I64(property->values[1])) 90659e71ee7SDaniel Vetter return false; 90759e71ee7SDaniel Vetter return true; 90859e71ee7SDaniel Vetter } else if (drm_property_type_is(property, DRM_MODE_PROP_BITMASK)) { 90959e71ee7SDaniel Vetter uint64_t valid_mask = 0; 91059e71ee7SDaniel Vetter 91159e71ee7SDaniel Vetter for (i = 0; i < property->num_values; i++) 91259e71ee7SDaniel Vetter valid_mask |= (1ULL << property->values[i]); 91359e71ee7SDaniel Vetter return !(value & ~valid_mask); 91477953bd1SDaniel Vetter } else if (drm_property_type_is(property, DRM_MODE_PROP_BLOB) || 91577953bd1SDaniel Vetter drm_property_type_is(property, DRM_MODE_PROP_OBJECT)) { 91659e71ee7SDaniel Vetter /* a zero value for an object property translates to null: */ 91759e71ee7SDaniel Vetter if (value == 0) 91859e71ee7SDaniel Vetter return true; 91959e71ee7SDaniel Vetter 92059e71ee7SDaniel Vetter *ref = __drm_mode_object_find(property->dev, value, 92159e71ee7SDaniel Vetter property->values[0]); 92259e71ee7SDaniel Vetter return *ref != NULL; 92359e71ee7SDaniel Vetter } 92459e71ee7SDaniel Vetter 92559e71ee7SDaniel Vetter for (i = 0; i < property->num_values; i++) 92659e71ee7SDaniel Vetter if (property->values[i] == value) 92759e71ee7SDaniel Vetter return true; 92859e71ee7SDaniel Vetter return false; 92959e71ee7SDaniel Vetter } 93059e71ee7SDaniel Vetter 93159e71ee7SDaniel Vetter void drm_property_change_valid_put(struct drm_property *property, 93259e71ee7SDaniel Vetter struct drm_mode_object *ref) 93359e71ee7SDaniel Vetter { 93459e71ee7SDaniel Vetter if (!ref) 93559e71ee7SDaniel Vetter return; 93659e71ee7SDaniel Vetter 93777953bd1SDaniel Vetter if (drm_property_type_is(property, DRM_MODE_PROP_OBJECT) || 93877953bd1SDaniel Vetter drm_property_type_is(property, DRM_MODE_PROP_BLOB)) 93959e71ee7SDaniel Vetter drm_mode_object_unreference(ref); 94059e71ee7SDaniel Vetter } 941