| // SPDX-License-Identifier: MIT | |
| /* | |
| * Copyright (C) 2023 Advanced Micro Devices, Inc. All rights reserved. | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining a | |
| * copy of this software and associated documentation files (the "Software"), | |
| * to deal in the Software without restriction, including without limitation | |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
| * and/or sell copies of the Software, and to permit persons to whom the | |
| * Software is furnished to do so, subject to the following conditions: | |
| * | |
| * The above copyright notice and this permission notice shall be included in | |
| * all copies or substantial portions of the Software. | |
| * | |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
| * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR | |
| * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, | |
| * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR | |
| * OTHER DEALINGS IN THE SOFTWARE. | |
| * | |
| * Authors: AMD | |
| * | |
| */ | |
| #include <drm/drm_colorop.h> | |
| #include <drm/drm_print.h> | |
| #include <drm/drm_drv.h> | |
| #include <drm/drm_plane.h> | |
| #include "drm_crtc_internal.h" | |
| /** | |
| * DOC: overview | |
| * | |
| * When userspace signals the &DRM_CLIENT_CAP_PLANE_COLOR_PIPELINE it | |
| * should use the COLOR_PIPELINE plane property and associated colorops | |
| * for any color operation on the &drm_plane. Setting of all old color | |
| * properties, such as COLOR_ENCODING and COLOR_RANGE, will be rejected | |
| * and the values of the properties will be ignored. | |
| * | |
| * Colorops are only advertised and valid for atomic drivers and atomic | |
| * userspace that signals the &DRM_CLIENT_CAP_PLANE_COLOR_PIPELINE | |
| * client cap. | |
| * | |
| * A colorop represents a single color operation. Colorops are chained | |
| * via the NEXT property and make up color pipelines. Color pipelines | |
| * are advertised and selected via the COLOR_PIPELINE &drm_plane | |
| * property. | |
| * | |
| * A colorop will be of a certain type, advertised by the read-only TYPE | |
| * property. Each type of colorop will advertise a different set of | |
| * properties and is programmed in a different manner. Types can be | |
| * enumerated 1D curves, 1D LUTs, 3D LUTs, matrices, etc. See the | |
| * &drm_colorop_type documentation for information on each type. | |
| * | |
| * If a colorop advertises the BYPASS property it can be bypassed. | |
| * | |
| * Information about colorop and color pipeline design decisions can be | |
| * found at rfc/color_pipeline.rst, but note that this document will | |
| * grow stale over time. | |
| */ | |
| static const struct drm_prop_enum_list drm_colorop_type_enum_list[] = { | |
| { DRM_COLOROP_1D_CURVE, "1D Curve" }, | |
| { DRM_COLOROP_1D_LUT, "1D LUT" }, | |
| { DRM_COLOROP_CTM_3X4, "3x4 Matrix"}, | |
| { DRM_COLOROP_MULTIPLIER, "Multiplier"}, | |
| { DRM_COLOROP_3D_LUT, "3D LUT"}, | |
| { DRM_COLOROP_FIXED_MATRIX, "Fixed Matrix"}, | |
| }; | |
| static const char * const colorop_curve_1d_type_names[] = { | |
| [DRM_COLOROP_1D_CURVE_SRGB_EOTF] = "sRGB EOTF", | |
| [DRM_COLOROP_1D_CURVE_SRGB_INV_EOTF] = "sRGB Inverse EOTF", | |
| [DRM_COLOROP_1D_CURVE_PQ_125_EOTF] = "PQ 125 EOTF", | |
| [DRM_COLOROP_1D_CURVE_PQ_125_INV_EOTF] = "PQ 125 Inverse EOTF", | |
| [DRM_COLOROP_1D_CURVE_BT2020_INV_OETF] = "BT.2020 Inverse OETF", | |
| [DRM_COLOROP_1D_CURVE_BT2020_OETF] = "BT.2020 OETF", | |
| [DRM_COLOROP_1D_CURVE_GAMMA22] = "Gamma 2.2", | |
| [DRM_COLOROP_1D_CURVE_GAMMA22_INV] = "Gamma 2.2 Inverse", | |
| }; | |
| static const struct drm_prop_enum_list drm_colorop_lut1d_interpolation_list[] = { | |
| { DRM_COLOROP_LUT1D_INTERPOLATION_LINEAR, "Linear" }, | |
| }; | |
| static const struct drm_prop_enum_list drm_colorop_lut3d_interpolation_list[] = { | |
| { DRM_COLOROP_LUT3D_INTERPOLATION_TETRAHEDRAL, "Tetrahedral" }, | |
| }; | |
| static const char * const colorop_fixed_matrix_type_names[] = { | |
| [DRM_COLOROP_FM_YCBCR601_FULL_RGB] = "YCbCr 601 Full to RGB", | |
| [DRM_COLOROP_FM_YCBCR601_LIMITED_RGB] = "YCbCr 601 Limited to RGB", | |
| [DRM_COLOROP_FM_YCBCR709_FULL_RGB] = "YCbCr 709 Full to RGB", | |
| [DRM_COLOROP_FM_YCBCR709_LIMITED_RGB] = "YCbCr 709 Limited to RGB", | |
| [DRM_COLOROP_FM_YCBCR2020_NC_FULL_RGB] = "YCbCr 2020 NC Full to RGB", | |
| [DRM_COLOROP_FM_YCBCR2020_NC_LIMITED_RGB] = "YCbCr 2020 NC Limited to RGB", | |
| }; | |
| /* Init Helpers */ | |
| static int drm_plane_colorop_init(struct drm_device *dev, struct drm_colorop *colorop, | |
| struct drm_plane *plane, const struct drm_colorop_funcs *funcs, | |
| enum drm_colorop_type type, | |
| uint32_t flags) | |
| { | |
| struct drm_mode_config *config = &dev->mode_config; | |
| struct drm_property *prop; | |
| int ret = 0; | |
| ret = drm_mode_object_add(dev, &colorop->base, DRM_MODE_OBJECT_COLOROP); | |
| if (ret) | |
| return ret; | |
| colorop->base.properties = &colorop->properties; | |
| colorop->dev = dev; | |
| colorop->type = type; | |
| colorop->plane = plane; | |
| colorop->next = NULL; | |
| colorop->funcs = funcs; | |
| list_add_tail(&colorop->head, &config->colorop_list); | |
| colorop->index = config->num_colorop++; | |
| /* add properties */ | |
| /* type */ | |
| prop = drm_property_create_enum(dev, | |
| DRM_MODE_PROP_IMMUTABLE, | |
| "TYPE", drm_colorop_type_enum_list, | |
| ARRAY_SIZE(drm_colorop_type_enum_list)); | |
| if (!prop) | |
| return -ENOMEM; | |
| colorop->type_property = prop; | |
| drm_object_attach_property(&colorop->base, | |
| colorop->type_property, | |
| colorop->type); | |
| if (flags & DRM_COLOROP_FLAG_ALLOW_BYPASS) { | |
| /* bypass */ | |
| prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC, | |
| "BYPASS"); | |
| if (!prop) | |
| return -ENOMEM; | |
| colorop->bypass_property = prop; | |
| drm_object_attach_property(&colorop->base, | |
| colorop->bypass_property, | |
| 1); | |
| } | |
| /* next */ | |
| prop = drm_property_create_object(dev, DRM_MODE_PROP_IMMUTABLE | DRM_MODE_PROP_ATOMIC, | |
| "NEXT", DRM_MODE_OBJECT_COLOROP); | |
| if (!prop) | |
| return -ENOMEM; | |
| colorop->next_property = prop; | |
| drm_object_attach_property(&colorop->base, | |
| colorop->next_property, | |
| 0); | |
| return ret; | |
| } | |
| /** | |
| * drm_colorop_cleanup - Cleanup a drm_colorop object in color_pipeline | |
| * | |
| * @colorop: The drm_colorop object to be cleaned | |
| */ | |
| void drm_colorop_cleanup(struct drm_colorop *colorop) | |
| { | |
| struct drm_device *dev = colorop->dev; | |
| struct drm_mode_config *config = &dev->mode_config; | |
| list_del(&colorop->head); | |
| config->num_colorop--; | |
| if (colorop->state) | |
| drm_colorop_atomic_destroy_state(colorop, colorop->state); | |
| } | |
| EXPORT_SYMBOL(drm_colorop_cleanup); | |
| /** | |
| * drm_colorop_destroy - destroy colorop | |
| * @colorop: drm colorop | |
| * | |
| * Destroys @colorop by performing common DRM cleanup and freeing the | |
| * colorop object. This can be used by drivers if they do not | |
| * require any driver-specific teardown. | |
| */ | |
| void drm_colorop_destroy(struct drm_colorop *colorop) | |
| { | |
| drm_colorop_cleanup(colorop); | |
| kfree(colorop); | |
| } | |
| EXPORT_SYMBOL(drm_colorop_destroy); | |
| /** | |
| * drm_colorop_pipeline_destroy - Helper for color pipeline destruction | |
| * | |
| * @dev: - The drm_device containing the drm_planes with the color_pipelines | |
| * | |
| * Provides a default color pipeline destroy handler for drm_device. | |
| */ | |
| void drm_colorop_pipeline_destroy(struct drm_device *dev) | |
| { | |
| struct drm_mode_config *config = &dev->mode_config; | |
| struct drm_colorop *colorop, *next; | |
| list_for_each_entry_safe(colorop, next, &config->colorop_list, head) { | |
| colorop->funcs->destroy(colorop); | |
| } | |
| } | |
| EXPORT_SYMBOL(drm_colorop_pipeline_destroy); | |
| /** | |
| * drm_plane_colorop_curve_1d_init - Initialize a DRM_COLOROP_1D_CURVE | |
| * | |
| * @dev: DRM device | |
| * @colorop: The drm_colorop object to initialize | |
| * @plane: The associated drm_plane | |
| * @funcs: control functions for the new colorop | |
| * @supported_tfs: A bitfield of supported drm_plane_colorop_curve_1d_init enum values, | |
| * created using BIT(curve_type) and combined with the OR '|' | |
| * operator. | |
| * @flags: bitmask of misc, see DRM_COLOROP_FLAG_* defines. | |
| * @return zero on success, -E value on failure | |
| */ | |
| int drm_plane_colorop_curve_1d_init(struct drm_device *dev, struct drm_colorop *colorop, | |
| struct drm_plane *plane, const struct drm_colorop_funcs *funcs, | |
| u64 supported_tfs, uint32_t flags) | |
| { | |
| struct drm_prop_enum_list enum_list[DRM_COLOROP_1D_CURVE_COUNT]; | |
| int i, len; | |
| struct drm_property *prop; | |
| int ret; | |
| if (!supported_tfs) { | |
| drm_err(dev, | |
| "No supported TFs for new 1D curve colorop on [PLANE:%d:%s]\n", | |
| plane->base.id, plane->name); | |
| return -EINVAL; | |
| } | |
| if ((supported_tfs & -BIT(DRM_COLOROP_1D_CURVE_COUNT)) != 0) { | |
| drm_err(dev, "Unknown TF provided on [PLANE:%d:%s]\n", | |
| plane->base.id, plane->name); | |
| return -EINVAL; | |
| } | |
| ret = drm_plane_colorop_init(dev, colorop, plane, funcs, DRM_COLOROP_1D_CURVE, flags); | |
| if (ret) | |
| return ret; | |
| len = 0; | |
| for (i = 0; i < DRM_COLOROP_1D_CURVE_COUNT; i++) { | |
| if ((supported_tfs & BIT(i)) == 0) | |
| continue; | |
| enum_list[len].type = i; | |
| enum_list[len].name = colorop_curve_1d_type_names[i]; | |
| len++; | |
| } | |
| if (WARN_ON(len <= 0)) | |
| return -EINVAL; | |
| /* initialize 1D curve only attribute */ | |
| prop = drm_property_create_enum(dev, DRM_MODE_PROP_ATOMIC, "CURVE_1D_TYPE", | |
| enum_list, len); | |
| if (!prop) | |
| return -ENOMEM; | |
| colorop->curve_1d_type_property = prop; | |
| drm_object_attach_property(&colorop->base, colorop->curve_1d_type_property, | |
| enum_list[0].type); | |
| drm_colorop_reset(colorop); | |
| return 0; | |
| } | |
| EXPORT_SYMBOL(drm_plane_colorop_curve_1d_init); | |
| static int drm_colorop_create_data_prop(struct drm_device *dev, struct drm_colorop *colorop) | |
| { | |
| struct drm_property *prop; | |
| /* data */ | |
| prop = drm_property_create(dev, DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB, | |
| "DATA", 0); | |
| if (!prop) | |
| return -ENOMEM; | |
| colorop->data_property = prop; | |
| drm_object_attach_property(&colorop->base, | |
| colorop->data_property, | |
| 0); | |
| return 0; | |
| } | |
| /** | |
| * drm_plane_colorop_curve_1d_lut_init - Initialize a DRM_COLOROP_1D_LUT | |
| * | |
| * @dev: DRM device | |
| * @colorop: The drm_colorop object to initialize | |
| * @plane: The associated drm_plane | |
| * @funcs: control functions for new colorop | |
| * @lut_size: LUT size supported by driver | |
| * @interpolation: 1D LUT interpolation type | |
| * @flags: bitmask of misc, see DRM_COLOROP_FLAG_* defines. | |
| * @return zero on success, -E value on failure | |
| */ | |
| int drm_plane_colorop_curve_1d_lut_init(struct drm_device *dev, struct drm_colorop *colorop, | |
| struct drm_plane *plane, | |
| const struct drm_colorop_funcs *funcs, | |
| uint32_t lut_size, | |
| enum drm_colorop_lut1d_interpolation_type interpolation, | |
| uint32_t flags) | |
| { | |
| struct drm_property *prop; | |
| int ret; | |
| ret = drm_plane_colorop_init(dev, colorop, plane, funcs, DRM_COLOROP_1D_LUT, flags); | |
| if (ret) | |
| return ret; | |
| /* initialize 1D LUT only attribute */ | |
| /* LUT size */ | |
| prop = drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE | DRM_MODE_PROP_ATOMIC, | |
| "SIZE", 0, UINT_MAX); | |
| if (!prop) | |
| return -ENOMEM; | |
| colorop->size_property = prop; | |
| drm_object_attach_property(&colorop->base, colorop->size_property, lut_size); | |
| colorop->size = lut_size; | |
| /* interpolation */ | |
| prop = drm_property_create_enum(dev, 0, "LUT1D_INTERPOLATION", | |
| drm_colorop_lut1d_interpolation_list, | |
| ARRAY_SIZE(drm_colorop_lut1d_interpolation_list)); | |
| if (!prop) | |
| return -ENOMEM; | |
| colorop->lut1d_interpolation_property = prop; | |
| drm_object_attach_property(&colorop->base, prop, interpolation); | |
| /* data */ | |
| ret = drm_colorop_create_data_prop(dev, colorop); | |
| if (ret) | |
| return ret; | |
| drm_colorop_reset(colorop); | |
| return 0; | |
| } | |
| EXPORT_SYMBOL(drm_plane_colorop_curve_1d_lut_init); | |
| int drm_plane_colorop_ctm_3x4_init(struct drm_device *dev, struct drm_colorop *colorop, | |
| struct drm_plane *plane, const struct drm_colorop_funcs *funcs, | |
| uint32_t flags) | |
| { | |
| int ret; | |
| ret = drm_plane_colorop_init(dev, colorop, plane, funcs, DRM_COLOROP_CTM_3X4, flags); | |
| if (ret) | |
| return ret; | |
| ret = drm_colorop_create_data_prop(dev, colorop); | |
| if (ret) | |
| return ret; | |
| drm_colorop_reset(colorop); | |
| return 0; | |
| } | |
| EXPORT_SYMBOL(drm_plane_colorop_ctm_3x4_init); | |
| /** | |
| * drm_plane_colorop_mult_init - Initialize a DRM_COLOROP_MULTIPLIER | |
| * | |
| * @dev: DRM device | |
| * @colorop: The drm_colorop object to initialize | |
| * @plane: The associated drm_plane | |
| * @funcs: control functions for the new colorop | |
| * @flags: bitmask of misc, see DRM_COLOROP_FLAG_* defines. | |
| * @return zero on success, -E value on failure | |
| */ | |
| int drm_plane_colorop_mult_init(struct drm_device *dev, struct drm_colorop *colorop, | |
| struct drm_plane *plane, const struct drm_colorop_funcs *funcs, | |
| uint32_t flags) | |
| { | |
| struct drm_property *prop; | |
| int ret; | |
| ret = drm_plane_colorop_init(dev, colorop, plane, funcs, DRM_COLOROP_MULTIPLIER, flags); | |
| if (ret) | |
| return ret; | |
| prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, "MULTIPLIER", 0, U64_MAX); | |
| if (!prop) | |
| return -ENOMEM; | |
| colorop->multiplier_property = prop; | |
| drm_object_attach_property(&colorop->base, colorop->multiplier_property, 0); | |
| drm_colorop_reset(colorop); | |
| return 0; | |
| } | |
| EXPORT_SYMBOL(drm_plane_colorop_mult_init); | |
| int drm_plane_colorop_3dlut_init(struct drm_device *dev, struct drm_colorop *colorop, | |
| struct drm_plane *plane, | |
| const struct drm_colorop_funcs *funcs, | |
| uint32_t lut_size, | |
| enum drm_colorop_lut3d_interpolation_type interpolation, | |
| uint32_t flags) | |
| { | |
| struct drm_property *prop; | |
| int ret; | |
| ret = drm_plane_colorop_init(dev, colorop, plane, funcs, DRM_COLOROP_3D_LUT, flags); | |
| if (ret) | |
| return ret; | |
| /* LUT size */ | |
| prop = drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE | DRM_MODE_PROP_ATOMIC, | |
| "SIZE", 0, UINT_MAX); | |
| if (!prop) | |
| return -ENOMEM; | |
| colorop->size_property = prop; | |
| drm_object_attach_property(&colorop->base, colorop->size_property, lut_size); | |
| colorop->size = lut_size; | |
| /* interpolation */ | |
| prop = drm_property_create_enum(dev, 0, "LUT3D_INTERPOLATION", | |
| drm_colorop_lut3d_interpolation_list, | |
| ARRAY_SIZE(drm_colorop_lut3d_interpolation_list)); | |
| if (!prop) | |
| return -ENOMEM; | |
| colorop->lut3d_interpolation_property = prop; | |
| drm_object_attach_property(&colorop->base, prop, interpolation); | |
| /* data */ | |
| ret = drm_colorop_create_data_prop(dev, colorop); | |
| if (ret) | |
| return ret; | |
| drm_colorop_reset(colorop); | |
| return 0; | |
| } | |
| EXPORT_SYMBOL(drm_plane_colorop_3dlut_init); | |
| /** | |
| * drm_plane_colorop_fixed_matrix_init - Initialize a DRM_COLOROP_FIXED_MATRIX | |
| * | |
| * @dev: DRM device | |
| * @colorop: The drm_colorop object to initialize | |
| * @plane: The associated drm_plane | |
| * @funcs: control functions for the new colorop | |
| * @supported_fm: A bitfield of supported drm_colorop_fixed_matrix_type enum values, | |
| * created using BIT(fixed_matrix_type) and combined with the OR '|' | |
| * operator. | |
| * @flags: bitmask of misc, see DRM_COLOROP_FLAG_* defines. | |
| * @return zero on success, -E value on failure | |
| */ | |
| int drm_plane_colorop_fixed_matrix_init(struct drm_device *dev, struct drm_colorop *colorop, | |
| struct drm_plane *plane, | |
| const struct drm_colorop_funcs *funcs, | |
| u64 supported_fm, uint32_t flags) | |
| { | |
| struct drm_prop_enum_list enum_list[DRM_COLOROP_FM_COUNT]; | |
| int i, len; | |
| struct drm_property *prop; | |
| int ret; | |
| if (!supported_fm) { | |
| drm_err(dev, | |
| "No supported FM type op for new Fixed Matrix colorop on [PLANE:%d:%s]\n", | |
| plane->base.id, plane->name); | |
| return -EINVAL; | |
| } | |
| if ((supported_fm & -BIT(DRM_COLOROP_FM_COUNT)) != 0) { | |
| drm_err(dev, "Unknown Fixed Matrix provided on [PLANE:%d:%s]\n", | |
| plane->base.id, plane->name); | |
| return -EINVAL; | |
| } | |
| ret = drm_plane_colorop_init(dev, colorop, plane, funcs, DRM_COLOROP_FIXED_MATRIX, flags); | |
| if (ret) | |
| return ret; | |
| len = 0; | |
| for (i = 0; i < DRM_COLOROP_FM_COUNT; i++) { | |
| if ((supported_fm & BIT(i)) == 0) | |
| continue; | |
| enum_list[len].type = i; | |
| enum_list[len].name = colorop_fixed_matrix_type_names[i]; | |
| len++; | |
| } | |
| if (WARN_ON(len <= 0)) | |
| return -EINVAL; | |
| prop = drm_property_create_enum(dev, DRM_MODE_PROP_ATOMIC, "FIXED_MATRIX_TYPE", | |
| enum_list, len); | |
| if (!prop) | |
| return -ENOMEM; | |
| colorop->fixed_matrix_type_property = prop; | |
| /* | |
| * Default to the first supported CSC mode as provided by the driver. | |
| * Intuitively this should be something that keeps the colorop in pixel bypass | |
| * mode but that is already handled via the standard colorop bypass | |
| * property. | |
| */ | |
| drm_object_attach_property(&colorop->base, colorop->fixed_matrix_type_property, | |
| enum_list[0].type); | |
| drm_colorop_reset(colorop); | |
| return 0; | |
| } | |
| EXPORT_SYMBOL(drm_plane_colorop_fixed_matrix_init); | |
| static void __drm_atomic_helper_colorop_duplicate_state(struct drm_colorop *colorop, | |
| struct drm_colorop_state *state) | |
| { | |
| memcpy(state, colorop->state, sizeof(*state)); | |
| if (state->data) | |
| drm_property_blob_get(state->data); | |
| } | |
| struct drm_colorop_state * | |
| drm_atomic_helper_colorop_duplicate_state(struct drm_colorop *colorop) | |
| { | |
| struct drm_colorop_state *state; | |
| if (WARN_ON(!colorop->state)) | |
| return NULL; | |
| state = kmalloc_obj(*state); | |
| if (state) | |
| __drm_atomic_helper_colorop_duplicate_state(colorop, state); | |
| return state; | |
| } | |
| /** | |
| * __drm_atomic_helper_colorop_destroy_state - release colorop state | |
| * @state: colorop state object to release | |
| * | |
| * Releases all resources stored in the colorop state without actually freeing | |
| * the memory of the colorop state. This is useful for drivers that subclass the | |
| * colorop state. | |
| */ | |
| static void __drm_atomic_helper_colorop_destroy_state(struct drm_colorop_state *state) | |
| { | |
| drm_property_blob_put(state->data); | |
| } | |
| void drm_colorop_atomic_destroy_state(struct drm_colorop *colorop, | |
| struct drm_colorop_state *state) | |
| { | |
| __drm_atomic_helper_colorop_destroy_state(state); | |
| kfree(state); | |
| } | |
| /** | |
| * __drm_colorop_state_init - Initializes colorop state to default values | |
| * @colorop_state: atomic colorop state, must not be NULL | |
| * @colorop: colorop object, must not be NULL | |
| * | |
| * Initializes the newly allocated @colorop_state with default | |
| * values. This is useful for drivers that subclass the colorop state. | |
| */ | |
| static void __drm_colorop_state_init(struct drm_colorop_state *colorop_state, | |
| struct drm_colorop *colorop) | |
| { | |
| u64 val; | |
| colorop_state->colorop = colorop; | |
| colorop_state->bypass = true; | |
| if (colorop->curve_1d_type_property) { | |
| if (!drm_object_property_get_default_value(&colorop->base, | |
| colorop->curve_1d_type_property, | |
| &val)) | |
| colorop_state->curve_1d_type = val; | |
| } | |
| if (colorop->lut1d_interpolation_property) { | |
| if (!drm_object_property_get_default_value(&colorop->base, | |
| colorop->lut1d_interpolation_property, | |
| &val)) | |
| colorop_state->lut1d_interpolation = val; | |
| } | |
| if (colorop->lut3d_interpolation_property) { | |
| if (!drm_object_property_get_default_value(&colorop->base, | |
| colorop->lut3d_interpolation_property, | |
| &val)) | |
| colorop_state->lut3d_interpolation = val; | |
| } | |
| if (colorop->fixed_matrix_type_property) { | |
| if (!drm_object_property_get_default_value(&colorop->base, | |
| colorop->fixed_matrix_type_property, | |
| &val)) | |
| colorop_state->fixed_matrix_type = val; | |
| } | |
| } | |
| /** | |
| * drm_atomic_helper_colorop_create_state - Allocates and initializes colorop atomic state | |
| * @colorop: drm colorop | |
| * | |
| * Initializes a pristine @drm_colorop_state. | |
| * | |
| * RETURNS: | |
| * Pointer to new colorop state, or ERR_PTR on failure. | |
| */ | |
| struct drm_colorop_state * | |
| drm_atomic_helper_colorop_create_state(struct drm_colorop *colorop) | |
| { | |
| struct drm_colorop_state *state; | |
| state = kzalloc_obj(*state); | |
| if (!state) | |
| return ERR_PTR(-ENOMEM); | |
| __drm_colorop_state_init(state, colorop); | |
| return state; | |
| } | |
| /** | |
| * __drm_colorop_reset - reset state on colorop | |
| * @colorop: drm colorop | |
| * @colorop_state: colorop state to assign | |
| * | |
| * Initializes the newly allocated @colorop_state and assigns it to the | |
| * &drm_colorop->state pointer of @colorop, usually required when | |
| * initializing the drivers or when called from the | |
| * &drm_colorop_funcs.reset hook. | |
| * | |
| * This is useful for drivers that subclass the colorop state. | |
| */ | |
| static void __drm_colorop_reset(struct drm_colorop *colorop, | |
| struct drm_colorop_state *colorop_state) | |
| { | |
| if (colorop_state) | |
| __drm_colorop_state_init(colorop_state, colorop); | |
| colorop->state = colorop_state; | |
| } | |
| void drm_colorop_reset(struct drm_colorop *colorop) | |
| { | |
| if (colorop->state) | |
| drm_colorop_atomic_destroy_state(colorop, colorop->state); | |
| colorop->state = kzalloc_obj(*colorop->state); | |
| if (colorop->state) | |
| __drm_colorop_reset(colorop, colorop->state); | |
| } | |
| static const char * const colorop_type_name[] = { | |
| [DRM_COLOROP_1D_CURVE] = "1D Curve", | |
| [DRM_COLOROP_1D_LUT] = "1D LUT", | |
| [DRM_COLOROP_CTM_3X4] = "3x4 Matrix", | |
| [DRM_COLOROP_MULTIPLIER] = "Multiplier", | |
| [DRM_COLOROP_3D_LUT] = "3D LUT", | |
| [DRM_COLOROP_FIXED_MATRIX] = "Fixed Matrix", | |
| }; | |
| static const char * const colorop_lu3d_interpolation_name[] = { | |
| [DRM_COLOROP_LUT3D_INTERPOLATION_TETRAHEDRAL] = "Tetrahedral", | |
| }; | |
| static const char * const colorop_lut1d_interpolation_name[] = { | |
| [DRM_COLOROP_LUT1D_INTERPOLATION_LINEAR] = "Linear", | |
| }; | |
| const char *drm_get_colorop_type_name(enum drm_colorop_type type) | |
| { | |
| if (WARN_ON(type >= ARRAY_SIZE(colorop_type_name))) | |
| return "unknown"; | |
| return colorop_type_name[type]; | |
| } | |
| const char *drm_get_colorop_curve_1d_type_name(enum drm_colorop_curve_1d_type type) | |
| { | |
| if (WARN_ON(type >= ARRAY_SIZE(colorop_curve_1d_type_names))) | |
| return "unknown"; | |
| return colorop_curve_1d_type_names[type]; | |
| } | |
| /** | |
| * drm_get_colorop_lut1d_interpolation_name: return a string for interpolation type | |
| * @type: interpolation type to compute name of | |
| * | |
| * In contrast to the other drm_get_*_name functions this one here returns a | |
| * const pointer and hence is threadsafe. | |
| */ | |
| const char *drm_get_colorop_lut1d_interpolation_name(enum drm_colorop_lut1d_interpolation_type type) | |
| { | |
| if (WARN_ON(type >= ARRAY_SIZE(colorop_lut1d_interpolation_name))) | |
| return "unknown"; | |
| return colorop_lut1d_interpolation_name[type]; | |
| } | |
| /** | |
| * drm_get_colorop_lut3d_interpolation_name - return a string for interpolation type | |
| * @type: interpolation type to compute name of | |
| * | |
| * In contrast to the other drm_get_*_name functions this one here returns a | |
| * const pointer and hence is threadsafe. | |
| */ | |
| const char *drm_get_colorop_lut3d_interpolation_name(enum drm_colorop_lut3d_interpolation_type type) | |
| { | |
| if (WARN_ON(type >= ARRAY_SIZE(colorop_lu3d_interpolation_name))) | |
| return "unknown"; | |
| return colorop_lu3d_interpolation_name[type]; | |
| } | |
| /** | |
| * drm_get_colorop_fixed_matrix_type_name: return a string for fixed matrix type | |
| * @type: fixed matrix type to compute name of | |
| * | |
| * In contrast to the other drm_get_*_name functions this one here returns a | |
| * const pointer and hence is threadsafe. | |
| */ | |
| const char *drm_get_colorop_fixed_matrix_type_name(enum drm_colorop_fixed_matrix_type type) | |
| { | |
| if (WARN_ON(type >= ARRAY_SIZE(colorop_fixed_matrix_type_names))) | |
| return "unknown"; | |
| return colorop_fixed_matrix_type_names[type]; | |
| } | |
| /** | |
| * drm_colorop_set_next_property - sets the next pointer | |
| * @colorop: drm colorop | |
| * @next: next colorop | |
| * | |
| * Should be used when constructing the color pipeline | |
| */ | |
| void drm_colorop_set_next_property(struct drm_colorop *colorop, struct drm_colorop *next) | |
| { | |
| drm_object_property_set_value(&colorop->base, | |
| colorop->next_property, | |
| next ? next->base.id : 0); | |
| colorop->next = next; | |
| } | |
| EXPORT_SYMBOL(drm_colorop_set_next_property); |