| /* Copyright (c) 2016-2017, The Linux Foundation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 and |
| * only version 2 as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| */ |
| |
| #include "msm_prop.h" |
| |
| void msm_property_init(struct msm_property_info *info, |
| struct drm_mode_object *base, |
| struct drm_device *dev, |
| struct drm_property **property_array, |
| struct msm_property_data *property_data, |
| uint32_t property_count, |
| uint32_t blob_count, |
| uint32_t state_size) |
| { |
| /* prevent access if any of these are NULL */ |
| if (!base || !dev || !property_array || !property_data) { |
| property_count = 0; |
| blob_count = 0; |
| |
| DRM_ERROR("invalid arguments, forcing zero properties\n"); |
| return; |
| } |
| |
| /* can't have more blob properties than total properties */ |
| if (blob_count > property_count) { |
| blob_count = property_count; |
| |
| DBG("Capping number of blob properties to %d", blob_count); |
| } |
| |
| if (!info) { |
| DRM_ERROR("info pointer is NULL\n"); |
| } else { |
| info->base = base; |
| info->dev = dev; |
| info->property_array = property_array; |
| info->property_data = property_data; |
| info->property_count = property_count; |
| info->blob_count = blob_count; |
| info->install_request = 0; |
| info->install_count = 0; |
| info->recent_idx = 0; |
| info->is_active = false; |
| info->state_size = state_size; |
| info->state_cache_size = 0; |
| mutex_init(&info->property_lock); |
| |
| memset(property_data, |
| 0, |
| sizeof(struct msm_property_data) * |
| property_count); |
| } |
| } |
| |
| void msm_property_destroy(struct msm_property_info *info) |
| { |
| if (!info) |
| return; |
| |
| /* free state cache */ |
| while (info->state_cache_size > 0) |
| kfree(info->state_cache[--(info->state_cache_size)]); |
| |
| mutex_destroy(&info->property_lock); |
| } |
| |
| int msm_property_pop_dirty(struct msm_property_info *info, |
| struct msm_property_state *property_state) |
| { |
| struct list_head *item; |
| int rc = 0; |
| |
| if (!info || !property_state || !property_state->values) { |
| DRM_ERROR("invalid argument(s)\n"); |
| return -EINVAL; |
| } |
| |
| mutex_lock(&info->property_lock); |
| if (list_empty(&property_state->dirty_list)) { |
| rc = -EAGAIN; |
| } else { |
| item = property_state->dirty_list.next; |
| list_del_init(item); |
| rc = container_of(item, struct msm_property_value, dirty_node) |
| - property_state->values; |
| DRM_DEBUG_KMS("property %d dirty\n", rc); |
| } |
| mutex_unlock(&info->property_lock); |
| |
| return rc; |
| } |
| |
| /** |
| * _msm_property_set_dirty_no_lock - flag given property as being dirty |
| * This function doesn't mutex protect the |
| * dirty linked list. |
| * @info: Pointer to property info container struct |
| * @property_state: Pointer to property state container struct |
| * @property_idx: Property index |
| */ |
| static void _msm_property_set_dirty_no_lock( |
| struct msm_property_info *info, |
| struct msm_property_state *property_state, |
| uint32_t property_idx) |
| { |
| if (!info || !property_state || !property_state->values || |
| property_idx >= info->property_count) { |
| DRM_ERROR("invalid argument(s), idx %u\n", property_idx); |
| return; |
| } |
| |
| /* avoid re-inserting if already dirty */ |
| if (!list_empty(&property_state->values[property_idx].dirty_node)) { |
| DRM_DEBUG_KMS("property %u already dirty\n", property_idx); |
| return; |
| } |
| |
| list_add_tail(&property_state->values[property_idx].dirty_node, |
| &property_state->dirty_list); |
| } |
| |
| /** |
| * _msm_property_install_integer - install standard drm range property |
| * @info: Pointer to property info container struct |
| * @name: Property name |
| * @flags: Other property type flags, e.g. DRM_MODE_PROP_IMMUTABLE |
| * @min: Min property value |
| * @max: Max property value |
| * @init: Default Property value |
| * @property_idx: Property index |
| * @force_dirty: Whether or not to filter 'dirty' status on unchanged values |
| */ |
| static void _msm_property_install_integer(struct msm_property_info *info, |
| const char *name, int flags, uint64_t min, uint64_t max, |
| uint64_t init, uint32_t property_idx, bool force_dirty) |
| { |
| struct drm_property **prop; |
| |
| if (!info) |
| return; |
| |
| ++info->install_request; |
| |
| if (!name || (property_idx >= info->property_count)) { |
| DRM_ERROR("invalid argument(s), %s\n", name ? name : "null"); |
| } else { |
| prop = &info->property_array[property_idx]; |
| /* |
| * Properties need to be attached to each drm object that |
| * uses them, but only need to be created once |
| */ |
| if (*prop == 0) { |
| *prop = drm_property_create_range(info->dev, |
| flags, name, min, max); |
| if (*prop == 0) |
| DRM_ERROR("create %s property failed\n", name); |
| } |
| |
| /* save init value for later */ |
| info->property_data[property_idx].default_value = init; |
| info->property_data[property_idx].force_dirty = force_dirty; |
| |
| /* always attach property, if created */ |
| if (*prop) { |
| drm_object_attach_property(info->base, *prop, init); |
| ++info->install_count; |
| } |
| } |
| } |
| |
| void msm_property_install_range(struct msm_property_info *info, |
| const char *name, int flags, uint64_t min, uint64_t max, |
| uint64_t init, uint32_t property_idx) |
| { |
| _msm_property_install_integer(info, name, flags, |
| min, max, init, property_idx, false); |
| } |
| |
| void msm_property_install_volatile_range(struct msm_property_info *info, |
| const char *name, int flags, uint64_t min, uint64_t max, |
| uint64_t init, uint32_t property_idx) |
| { |
| _msm_property_install_integer(info, name, flags, |
| min, max, init, property_idx, true); |
| } |
| |
| void msm_property_install_rotation(struct msm_property_info *info, |
| unsigned int supported_rotations, uint32_t property_idx) |
| { |
| struct drm_property **prop; |
| |
| if (!info) |
| return; |
| |
| ++info->install_request; |
| |
| if (property_idx >= info->property_count) { |
| DRM_ERROR("invalid property index %d\n", property_idx); |
| } else { |
| prop = &info->property_array[property_idx]; |
| /* |
| * Properties need to be attached to each drm object that |
| * uses them, but only need to be created once |
| */ |
| if (*prop == 0) { |
| *prop = drm_mode_create_rotation_property(info->dev, |
| supported_rotations); |
| if (*prop == 0) |
| DRM_ERROR("create rotation property failed\n"); |
| } |
| |
| /* save init value for later */ |
| info->property_data[property_idx].default_value = 0; |
| info->property_data[property_idx].force_dirty = false; |
| |
| /* always attach property, if created */ |
| if (*prop) { |
| drm_object_attach_property(info->base, *prop, 0); |
| ++info->install_count; |
| } |
| } |
| } |
| |
| void msm_property_install_enum(struct msm_property_info *info, |
| const char *name, int flags, int is_bitmask, |
| const struct drm_prop_enum_list *values, int num_values, |
| uint32_t property_idx) |
| { |
| struct drm_property **prop; |
| |
| if (!info) |
| return; |
| |
| ++info->install_request; |
| |
| if (!name || !values || !num_values || |
| (property_idx >= info->property_count)) { |
| DRM_ERROR("invalid argument(s), %s\n", name ? name : "null"); |
| } else { |
| prop = &info->property_array[property_idx]; |
| /* |
| * Properties need to be attached to each drm object that |
| * uses them, but only need to be created once |
| */ |
| if (*prop == 0) { |
| /* 'bitmask' is a special type of 'enum' */ |
| if (is_bitmask) |
| *prop = drm_property_create_bitmask(info->dev, |
| DRM_MODE_PROP_BITMASK | flags, |
| name, values, num_values, -1); |
| else |
| *prop = drm_property_create_enum(info->dev, |
| DRM_MODE_PROP_ENUM | flags, |
| name, values, num_values); |
| if (*prop == 0) |
| DRM_ERROR("create %s property failed\n", name); |
| } |
| |
| /* save init value for later */ |
| info->property_data[property_idx].default_value = 0; |
| info->property_data[property_idx].force_dirty = false; |
| |
| /* always attach property, if created */ |
| if (*prop) { |
| drm_object_attach_property(info->base, *prop, 0); |
| ++info->install_count; |
| } |
| } |
| } |
| |
| void msm_property_install_blob(struct msm_property_info *info, |
| const char *name, int flags, uint32_t property_idx) |
| { |
| struct drm_property **prop; |
| |
| if (!info) |
| return; |
| |
| ++info->install_request; |
| |
| if (!name || (property_idx >= info->blob_count)) { |
| DRM_ERROR("invalid argument(s), %s\n", name ? name : "null"); |
| } else { |
| prop = &info->property_array[property_idx]; |
| /* |
| * Properties need to be attached to each drm object that |
| * uses them, but only need to be created once |
| */ |
| if (*prop == 0) { |
| /* use 'create' for blob property place holder */ |
| *prop = drm_property_create(info->dev, |
| DRM_MODE_PROP_BLOB | flags, name, 0); |
| if (*prop == 0) |
| DRM_ERROR("create %s property failed\n", name); |
| } |
| |
| /* save init value for later */ |
| info->property_data[property_idx].default_value = 0; |
| info->property_data[property_idx].force_dirty = true; |
| |
| /* always attach property, if created */ |
| if (*prop) { |
| drm_object_attach_property(info->base, *prop, -1); |
| ++info->install_count; |
| } |
| } |
| } |
| |
| int msm_property_install_get_status(struct msm_property_info *info) |
| { |
| int rc = -ENOMEM; |
| |
| if (info && (info->install_request == info->install_count)) |
| rc = 0; |
| |
| return rc; |
| } |
| |
| int msm_property_index(struct msm_property_info *info, |
| struct drm_property *property) |
| { |
| uint32_t count; |
| int32_t idx; |
| int rc = -EINVAL; |
| |
| if (!info || !property) { |
| DRM_ERROR("invalid argument(s)\n"); |
| } else { |
| /* |
| * Linear search, but start from last found index. This will |
| * help if any single property is accessed multiple times in a |
| * row. Ideally, we could keep a list of properties sorted in |
| * the order of most recent access, but that may be overkill |
| * for now. |
| */ |
| mutex_lock(&info->property_lock); |
| idx = info->recent_idx; |
| count = info->property_count; |
| while (count) { |
| --count; |
| |
| /* stop searching on match */ |
| if (info->property_array[idx] == property) { |
| info->recent_idx = idx; |
| rc = idx; |
| break; |
| } |
| |
| /* move to next valid index */ |
| if (--idx < 0) |
| idx = info->property_count - 1; |
| } |
| mutex_unlock(&info->property_lock); |
| } |
| |
| return rc; |
| } |
| |
| int msm_property_set_dirty(struct msm_property_info *info, |
| struct msm_property_state *property_state, |
| int property_idx) |
| { |
| if (!info || !property_state || !property_state->values) { |
| DRM_ERROR("invalid argument(s)\n"); |
| return -EINVAL; |
| } |
| mutex_lock(&info->property_lock); |
| _msm_property_set_dirty_no_lock(info, property_state, property_idx); |
| mutex_unlock(&info->property_lock); |
| return 0; |
| } |
| |
| int msm_property_atomic_set(struct msm_property_info *info, |
| struct msm_property_state *property_state, |
| struct drm_property *property, uint64_t val) |
| { |
| struct drm_property_blob *blob; |
| int property_idx, rc = -EINVAL; |
| |
| property_idx = msm_property_index(info, property); |
| if (!info || !property_state || |
| (property_idx == -EINVAL) || !property_state->values) { |
| DRM_DEBUG("invalid argument(s)\n"); |
| } else { |
| /* extra handling for incoming properties */ |
| mutex_lock(&info->property_lock); |
| if ((property->flags & DRM_MODE_PROP_BLOB) && |
| (property_idx < info->blob_count)) { |
| /* DRM lookup also takes a reference */ |
| blob = drm_property_lookup_blob(info->dev, |
| (uint32_t)val); |
| if (!blob) { |
| DRM_ERROR("blob not found\n"); |
| val = 0; |
| } else { |
| DBG("Blob %u saved", blob->base.id); |
| val = blob->base.id; |
| |
| /* save blob - need to clear previous ref */ |
| if (property_state->values[property_idx].blob) |
| drm_property_unreference_blob( |
| property_state->values[ |
| property_idx].blob); |
| property_state->values[property_idx].blob = |
| blob; |
| } |
| } |
| |
| /* update value and flag as dirty */ |
| if (property_state->values[property_idx].value != val || |
| info->property_data[property_idx].force_dirty) { |
| property_state->values[property_idx].value = val; |
| _msm_property_set_dirty_no_lock(info, property_state, |
| property_idx); |
| |
| DBG("%s - %lld", property->name, val); |
| } |
| mutex_unlock(&info->property_lock); |
| rc = 0; |
| } |
| |
| return rc; |
| } |
| |
| int msm_property_atomic_get(struct msm_property_info *info, |
| struct msm_property_state *property_state, |
| struct drm_property *property, uint64_t *val) |
| { |
| int property_idx, rc = -EINVAL; |
| |
| property_idx = msm_property_index(info, property); |
| if (!info || (property_idx == -EINVAL) || |
| !property_state->values || !val) { |
| DRM_DEBUG("Invalid argument(s)\n"); |
| } else { |
| mutex_lock(&info->property_lock); |
| *val = property_state->values[property_idx].value; |
| mutex_unlock(&info->property_lock); |
| rc = 0; |
| } |
| |
| return rc; |
| } |
| |
| void *msm_property_alloc_state(struct msm_property_info *info) |
| { |
| void *state = NULL; |
| |
| if (!info) { |
| DRM_ERROR("invalid property info\n"); |
| return NULL; |
| } |
| |
| mutex_lock(&info->property_lock); |
| if (info->state_cache_size) |
| state = info->state_cache[--(info->state_cache_size)]; |
| mutex_unlock(&info->property_lock); |
| |
| if (!state && info->state_size) |
| state = kmalloc(info->state_size, GFP_KERNEL); |
| |
| if (!state) |
| DRM_ERROR("failed to allocate state\n"); |
| |
| return state; |
| } |
| |
| /** |
| * _msm_property_free_state - helper function for freeing local state objects |
| * @info: Pointer to property info container struct |
| * @st: Pointer to state object |
| */ |
| static void _msm_property_free_state(struct msm_property_info *info, void *st) |
| { |
| if (!info || !st) |
| return; |
| |
| mutex_lock(&info->property_lock); |
| if (info->state_cache_size < MSM_PROP_STATE_CACHE_SIZE) |
| info->state_cache[(info->state_cache_size)++] = st; |
| else |
| kfree(st); |
| mutex_unlock(&info->property_lock); |
| } |
| |
| void msm_property_reset_state(struct msm_property_info *info, void *state, |
| struct msm_property_state *property_state, |
| struct msm_property_value *property_values) |
| { |
| uint32_t i; |
| |
| if (!info) { |
| DRM_ERROR("invalid property info\n"); |
| return; |
| } |
| |
| if (state) |
| memset(state, 0, info->state_size); |
| |
| if (property_state) { |
| property_state->property_count = info->property_count; |
| property_state->values = property_values; |
| INIT_LIST_HEAD(&property_state->dirty_list); |
| } |
| |
| /* |
| * Assign default property values. This helper is mostly used |
| * to initialize newly created state objects. |
| */ |
| if (property_values) |
| for (i = 0; i < info->property_count; ++i) { |
| property_values[i].value = |
| info->property_data[i].default_value; |
| property_values[i].blob = NULL; |
| INIT_LIST_HEAD(&property_values[i].dirty_node); |
| } |
| } |
| |
| void msm_property_duplicate_state(struct msm_property_info *info, |
| void *old_state, void *state, |
| struct msm_property_state *property_state, |
| struct msm_property_value *property_values) |
| { |
| uint32_t i; |
| |
| if (!info || !old_state || !state) { |
| DRM_ERROR("invalid argument(s)\n"); |
| return; |
| } |
| |
| memcpy(state, old_state, info->state_size); |
| |
| if (!property_state) |
| return; |
| |
| INIT_LIST_HEAD(&property_state->dirty_list); |
| property_state->values = property_values; |
| |
| if (property_state->values) |
| /* add ref count for blobs and initialize dirty nodes */ |
| for (i = 0; i < info->property_count; ++i) { |
| if (property_state->values[i].blob) |
| drm_property_reference_blob( |
| property_state->values[i].blob); |
| INIT_LIST_HEAD(&property_state->values[i].dirty_node); |
| } |
| } |
| |
| void msm_property_destroy_state(struct msm_property_info *info, void *state, |
| struct msm_property_state *property_state) |
| { |
| uint32_t i; |
| |
| if (!info || !state) { |
| DRM_ERROR("invalid argument(s)\n"); |
| return; |
| } |
| if (property_state && property_state->values) { |
| /* remove ref count for blobs */ |
| for (i = 0; i < info->property_count; ++i) |
| if (property_state->values[i].blob) { |
| drm_property_unreference_blob( |
| property_state->values[i].blob); |
| property_state->values[i].blob = NULL; |
| } |
| } |
| |
| _msm_property_free_state(info, state); |
| } |
| |
| void *msm_property_get_blob(struct msm_property_info *info, |
| struct msm_property_state *property_state, |
| size_t *byte_len, |
| uint32_t property_idx) |
| { |
| struct drm_property_blob *blob; |
| size_t len = 0; |
| void *rc = 0; |
| |
| if (!info || !property_state || !property_state->values || |
| (property_idx >= info->blob_count)) { |
| DRM_ERROR("invalid argument(s)\n"); |
| } else { |
| blob = property_state->values[property_idx].blob; |
| if (blob) { |
| len = blob->length; |
| rc = &blob->data; |
| } |
| } |
| |
| if (byte_len) |
| *byte_len = len; |
| |
| return rc; |
| } |
| |
| int msm_property_set_blob(struct msm_property_info *info, |
| struct drm_property_blob **blob_reference, |
| void *blob_data, |
| size_t byte_len, |
| uint32_t property_idx) |
| { |
| struct drm_property_blob *blob = NULL; |
| int rc = -EINVAL; |
| |
| if (!info || !blob_reference || (property_idx >= info->blob_count)) { |
| DRM_ERROR("invalid argument(s)\n"); |
| } else { |
| /* create blob */ |
| if (blob_data && byte_len) { |
| blob = drm_property_create_blob(info->dev, |
| byte_len, |
| blob_data); |
| if (IS_ERR_OR_NULL(blob)) { |
| rc = PTR_ERR(blob); |
| DRM_ERROR("failed to create blob, %d\n", rc); |
| goto exit; |
| } |
| } |
| |
| /* update drm object */ |
| rc = drm_object_property_set_value(info->base, |
| info->property_array[property_idx], |
| blob ? blob->base.id : 0); |
| if (rc) { |
| DRM_ERROR("failed to set blob to property\n"); |
| if (blob) |
| drm_property_unreference_blob(blob); |
| goto exit; |
| } |
| |
| /* update local reference */ |
| if (*blob_reference) |
| drm_property_unreference_blob(*blob_reference); |
| *blob_reference = blob; |
| } |
| |
| exit: |
| return rc; |
| } |
| |
| int msm_property_set_property(struct msm_property_info *info, |
| struct msm_property_state *property_state, |
| uint32_t property_idx, |
| uint64_t val) |
| { |
| int rc = -EINVAL; |
| |
| if (!info || (property_idx >= info->property_count) || |
| property_idx < info->blob_count || |
| !property_state || !property_state->values) { |
| DRM_ERROR("invalid argument(s)\n"); |
| } else { |
| struct drm_property *drm_prop; |
| |
| mutex_lock(&info->property_lock); |
| |
| /* update cached value */ |
| property_state->values[property_idx].value = val; |
| |
| /* update the new default value for immutables */ |
| drm_prop = info->property_array[property_idx]; |
| if (drm_prop->flags & DRM_MODE_PROP_IMMUTABLE) |
| info->property_data[property_idx].default_value = val; |
| |
| mutex_unlock(&info->property_lock); |
| |
| /* update drm object */ |
| rc = drm_object_property_set_value(info->base, drm_prop, val); |
| if (rc) |
| DRM_ERROR("failed set property value, idx %d rc %d\n", |
| property_idx, rc); |
| |
| } |
| |
| return rc; |
| } |
| |