1// SPDX-License-Identifier: MIT
2/*
3 * Copyright (C) 2023 Advanced Micro Devices, Inc. All rights reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 * OTHER DEALINGS IN THE SOFTWARE.
22 *
23 * Authors: AMD
24 *
25 */
26
27#include <drm/drm_colorop.h>
28#include <drm/drm_print.h>
29#include <drm/drm_drv.h>
30#include <drm/drm_plane.h>
31
32#include "drm_crtc_internal.h"
33
34/**
35 * DOC: overview
36 *
37 * When userspace signals the &DRM_CLIENT_CAP_PLANE_COLOR_PIPELINE it
38 * should use the COLOR_PIPELINE plane property and associated colorops
39 * for any color operation on the &drm_plane. Setting of all old color
40 * properties, such as COLOR_ENCODING and COLOR_RANGE, will be rejected
41 * and the values of the properties will be ignored.
42 *
43 * Colorops are only advertised and valid for atomic drivers and atomic
44 * userspace that signals the &DRM_CLIENT_CAP_PLANE_COLOR_PIPELINE
45 * client cap.
46 *
47 * A colorop represents a single color operation. Colorops are chained
48 * via the NEXT property and make up color pipelines. Color pipelines
49 * are advertised and selected via the COLOR_PIPELINE &drm_plane
50 * property.
51 *
52 * A colorop will be of a certain type, advertised by the read-only TYPE
53 * property. Each type of colorop will advertise a different set of
54 * properties and is programmed in a different manner. Types can be
55 * enumerated 1D curves, 1D LUTs, 3D LUTs, matrices, etc. See the
56 * &drm_colorop_type documentation for information on each type.
57 *
58 * If a colorop advertises the BYPASS property it can be bypassed.
59 *
60 * Information about colorop and color pipeline design decisions can be
61 * found at rfc/color_pipeline.rst, but note that this document will
62 * grow stale over time.
63 */
64
65static const struct drm_prop_enum_list drm_colorop_type_enum_list[] = {
66 { DRM_COLOROP_1D_CURVE, "1D Curve" },
67 { DRM_COLOROP_1D_LUT, "1D LUT" },
68 { DRM_COLOROP_CTM_3X4, "3x4 Matrix"},
69 { DRM_COLOROP_MULTIPLIER, "Multiplier"},
70 { DRM_COLOROP_3D_LUT, "3D LUT"},
71};
72
73static const char * const colorop_curve_1d_type_names[] = {
74 [DRM_COLOROP_1D_CURVE_SRGB_EOTF] = "sRGB EOTF",
75 [DRM_COLOROP_1D_CURVE_SRGB_INV_EOTF] = "sRGB Inverse EOTF",
76 [DRM_COLOROP_1D_CURVE_PQ_125_EOTF] = "PQ 125 EOTF",
77 [DRM_COLOROP_1D_CURVE_PQ_125_INV_EOTF] = "PQ 125 Inverse EOTF",
78 [DRM_COLOROP_1D_CURVE_BT2020_INV_OETF] = "BT.2020 Inverse OETF",
79 [DRM_COLOROP_1D_CURVE_BT2020_OETF] = "BT.2020 OETF",
80 [DRM_COLOROP_1D_CURVE_GAMMA22] = "Gamma 2.2",
81 [DRM_COLOROP_1D_CURVE_GAMMA22_INV] = "Gamma 2.2 Inverse",
82};
83
84static const struct drm_prop_enum_list drm_colorop_lut1d_interpolation_list[] = {
85 { DRM_COLOROP_LUT1D_INTERPOLATION_LINEAR, "Linear" },
86};
87
88
89static const struct drm_prop_enum_list drm_colorop_lut3d_interpolation_list[] = {
90 { DRM_COLOROP_LUT3D_INTERPOLATION_TETRAHEDRAL, "Tetrahedral" },
91};
92
93/* Init Helpers */
94
95static int drm_plane_colorop_init(struct drm_device *dev, struct drm_colorop *colorop,
96 struct drm_plane *plane, enum drm_colorop_type type,
97 uint32_t flags)
98{
99 struct drm_mode_config *config = &dev->mode_config;
100 struct drm_property *prop;
101 int ret = 0;
102
103 ret = drm_mode_object_add(dev, obj: &colorop->base, DRM_MODE_OBJECT_COLOROP);
104 if (ret)
105 return ret;
106
107 colorop->base.properties = &colorop->properties;
108 colorop->dev = dev;
109 colorop->type = type;
110 colorop->plane = plane;
111 colorop->next = NULL;
112
113 list_add_tail(new: &colorop->head, head: &config->colorop_list);
114 colorop->index = config->num_colorop++;
115
116 /* add properties */
117
118 /* type */
119 prop = drm_property_create_enum(dev,
120 DRM_MODE_PROP_IMMUTABLE,
121 name: "TYPE", props: drm_colorop_type_enum_list,
122 ARRAY_SIZE(drm_colorop_type_enum_list));
123
124 if (!prop)
125 return -ENOMEM;
126
127 colorop->type_property = prop;
128
129 drm_object_attach_property(obj: &colorop->base,
130 property: colorop->type_property,
131 init_val: colorop->type);
132
133 if (flags & DRM_COLOROP_FLAG_ALLOW_BYPASS) {
134 /* bypass */
135 prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC,
136 name: "BYPASS");
137 if (!prop)
138 return -ENOMEM;
139
140 colorop->bypass_property = prop;
141 drm_object_attach_property(obj: &colorop->base,
142 property: colorop->bypass_property,
143 init_val: 1);
144 }
145
146 /* next */
147 prop = drm_property_create_object(dev, DRM_MODE_PROP_IMMUTABLE | DRM_MODE_PROP_ATOMIC,
148 name: "NEXT", DRM_MODE_OBJECT_COLOROP);
149 if (!prop)
150 return -ENOMEM;
151 colorop->next_property = prop;
152 drm_object_attach_property(obj: &colorop->base,
153 property: colorop->next_property,
154 init_val: 0);
155
156 return ret;
157}
158
159/**
160 * drm_colorop_cleanup - Cleanup a drm_colorop object in color_pipeline
161 *
162 * @colorop: The drm_colorop object to be cleaned
163 */
164void drm_colorop_cleanup(struct drm_colorop *colorop)
165{
166 struct drm_device *dev = colorop->dev;
167 struct drm_mode_config *config = &dev->mode_config;
168
169 list_del(entry: &colorop->head);
170 config->num_colorop--;
171
172 if (colorop->state && colorop->state->data) {
173 drm_property_blob_put(blob: colorop->state->data);
174 colorop->state->data = NULL;
175 }
176
177 kfree(objp: colorop->state);
178}
179EXPORT_SYMBOL(drm_colorop_cleanup);
180
181/**
182 * drm_colorop_pipeline_destroy - Helper for color pipeline destruction
183 *
184 * @dev: - The drm_device containing the drm_planes with the color_pipelines
185 *
186 * Provides a default color pipeline destroy handler for drm_device.
187 */
188void drm_colorop_pipeline_destroy(struct drm_device *dev)
189{
190 struct drm_mode_config *config = &dev->mode_config;
191 struct drm_colorop *colorop, *next;
192
193 list_for_each_entry_safe(colorop, next, &config->colorop_list, head) {
194 drm_colorop_cleanup(colorop);
195 kfree(objp: colorop);
196 }
197}
198EXPORT_SYMBOL(drm_colorop_pipeline_destroy);
199
200/**
201 * drm_plane_colorop_curve_1d_init - Initialize a DRM_COLOROP_1D_CURVE
202 *
203 * @dev: DRM device
204 * @colorop: The drm_colorop object to initialize
205 * @plane: The associated drm_plane
206 * @supported_tfs: A bitfield of supported drm_plane_colorop_curve_1d_init enum values,
207 * created using BIT(curve_type) and combined with the OR '|'
208 * operator.
209 * @flags: bitmask of misc, see DRM_COLOROP_FLAG_* defines.
210 * @return zero on success, -E value on failure
211 */
212int drm_plane_colorop_curve_1d_init(struct drm_device *dev, struct drm_colorop *colorop,
213 struct drm_plane *plane, u64 supported_tfs, uint32_t flags)
214{
215 struct drm_prop_enum_list enum_list[DRM_COLOROP_1D_CURVE_COUNT];
216 int i, len;
217
218 struct drm_property *prop;
219 int ret;
220
221 if (!supported_tfs) {
222 drm_err(dev,
223 "No supported TFs for new 1D curve colorop on [PLANE:%d:%s]\n",
224 plane->base.id, plane->name);
225 return -EINVAL;
226 }
227
228 if ((supported_tfs & -BIT(DRM_COLOROP_1D_CURVE_COUNT)) != 0) {
229 drm_err(dev, "Unknown TF provided on [PLANE:%d:%s]\n",
230 plane->base.id, plane->name);
231 return -EINVAL;
232 }
233
234 ret = drm_plane_colorop_init(dev, colorop, plane, type: DRM_COLOROP_1D_CURVE, flags);
235 if (ret)
236 return ret;
237
238 len = 0;
239 for (i = 0; i < DRM_COLOROP_1D_CURVE_COUNT; i++) {
240 if ((supported_tfs & BIT(i)) == 0)
241 continue;
242
243 enum_list[len].type = i;
244 enum_list[len].name = colorop_curve_1d_type_names[i];
245 len++;
246 }
247
248 if (WARN_ON(len <= 0))
249 return -EINVAL;
250
251 /* initialize 1D curve only attribute */
252 prop = drm_property_create_enum(dev, DRM_MODE_PROP_ATOMIC, name: "CURVE_1D_TYPE",
253 props: enum_list, num_values: len);
254
255 if (!prop)
256 return -ENOMEM;
257
258 colorop->curve_1d_type_property = prop;
259 drm_object_attach_property(obj: &colorop->base, property: colorop->curve_1d_type_property,
260 init_val: enum_list[0].type);
261 drm_colorop_reset(colorop);
262
263 return 0;
264}
265EXPORT_SYMBOL(drm_plane_colorop_curve_1d_init);
266
267static int drm_colorop_create_data_prop(struct drm_device *dev, struct drm_colorop *colorop)
268{
269 struct drm_property *prop;
270
271 /* data */
272 prop = drm_property_create(dev, DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB,
273 name: "DATA", num_values: 0);
274 if (!prop)
275 return -ENOMEM;
276
277 colorop->data_property = prop;
278 drm_object_attach_property(obj: &colorop->base,
279 property: colorop->data_property,
280 init_val: 0);
281
282 return 0;
283}
284
285/**
286 * drm_plane_colorop_curve_1d_lut_init - Initialize a DRM_COLOROP_1D_LUT
287 *
288 * @dev: DRM device
289 * @colorop: The drm_colorop object to initialize
290 * @plane: The associated drm_plane
291 * @lut_size: LUT size supported by driver
292 * @interpolation: 1D LUT interpolation type
293 * @flags: bitmask of misc, see DRM_COLOROP_FLAG_* defines.
294 * @return zero on success, -E value on failure
295 */
296int drm_plane_colorop_curve_1d_lut_init(struct drm_device *dev, struct drm_colorop *colorop,
297 struct drm_plane *plane, uint32_t lut_size,
298 enum drm_colorop_lut1d_interpolation_type interpolation,
299 uint32_t flags)
300{
301 struct drm_property *prop;
302 int ret;
303
304 ret = drm_plane_colorop_init(dev, colorop, plane, type: DRM_COLOROP_1D_LUT, flags);
305 if (ret)
306 return ret;
307
308 /* initialize 1D LUT only attribute */
309 /* LUT size */
310 prop = drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE | DRM_MODE_PROP_ATOMIC,
311 name: "SIZE", min: 0, UINT_MAX);
312 if (!prop)
313 return -ENOMEM;
314
315 colorop->size_property = prop;
316 drm_object_attach_property(obj: &colorop->base, property: colorop->size_property, init_val: lut_size);
317 colorop->size = lut_size;
318
319 /* interpolation */
320 prop = drm_property_create_enum(dev, flags: 0, name: "LUT1D_INTERPOLATION",
321 props: drm_colorop_lut1d_interpolation_list,
322 ARRAY_SIZE(drm_colorop_lut1d_interpolation_list));
323 if (!prop)
324 return -ENOMEM;
325
326 colorop->lut1d_interpolation_property = prop;
327 drm_object_attach_property(obj: &colorop->base, property: prop, init_val: interpolation);
328 colorop->lut1d_interpolation = interpolation;
329
330 /* data */
331 ret = drm_colorop_create_data_prop(dev, colorop);
332 if (ret)
333 return ret;
334
335 drm_colorop_reset(colorop);
336
337 return 0;
338}
339EXPORT_SYMBOL(drm_plane_colorop_curve_1d_lut_init);
340
341int drm_plane_colorop_ctm_3x4_init(struct drm_device *dev, struct drm_colorop *colorop,
342 struct drm_plane *plane, uint32_t flags)
343{
344 int ret;
345
346 ret = drm_plane_colorop_init(dev, colorop, plane, type: DRM_COLOROP_CTM_3X4, flags);
347 if (ret)
348 return ret;
349
350 ret = drm_colorop_create_data_prop(dev, colorop);
351 if (ret)
352 return ret;
353
354 drm_colorop_reset(colorop);
355
356 return 0;
357}
358EXPORT_SYMBOL(drm_plane_colorop_ctm_3x4_init);
359
360/**
361 * drm_plane_colorop_mult_init - Initialize a DRM_COLOROP_MULTIPLIER
362 *
363 * @dev: DRM device
364 * @colorop: The drm_colorop object to initialize
365 * @plane: The associated drm_plane
366 * @flags: bitmask of misc, see DRM_COLOROP_FLAG_* defines.
367 * @return zero on success, -E value on failure
368 */
369int drm_plane_colorop_mult_init(struct drm_device *dev, struct drm_colorop *colorop,
370 struct drm_plane *plane, uint32_t flags)
371{
372 struct drm_property *prop;
373 int ret;
374
375 ret = drm_plane_colorop_init(dev, colorop, plane, type: DRM_COLOROP_MULTIPLIER, flags);
376 if (ret)
377 return ret;
378
379 prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC, name: "MULTIPLIER", min: 0, U64_MAX);
380 if (!prop)
381 return -ENOMEM;
382
383 colorop->multiplier_property = prop;
384 drm_object_attach_property(obj: &colorop->base, property: colorop->multiplier_property, init_val: 0);
385
386 drm_colorop_reset(colorop);
387
388 return 0;
389}
390EXPORT_SYMBOL(drm_plane_colorop_mult_init);
391
392int drm_plane_colorop_3dlut_init(struct drm_device *dev, struct drm_colorop *colorop,
393 struct drm_plane *plane,
394 uint32_t lut_size,
395 enum drm_colorop_lut3d_interpolation_type interpolation,
396 uint32_t flags)
397{
398 struct drm_property *prop;
399 int ret;
400
401 ret = drm_plane_colorop_init(dev, colorop, plane, type: DRM_COLOROP_3D_LUT, flags);
402 if (ret)
403 return ret;
404
405 /* LUT size */
406 prop = drm_property_create_range(dev, DRM_MODE_PROP_IMMUTABLE | DRM_MODE_PROP_ATOMIC,
407 name: "SIZE", min: 0, UINT_MAX);
408 if (!prop)
409 return -ENOMEM;
410
411 colorop->size_property = prop;
412 drm_object_attach_property(obj: &colorop->base, property: colorop->size_property, init_val: lut_size);
413 colorop->size = lut_size;
414
415 /* interpolation */
416 prop = drm_property_create_enum(dev, flags: 0, name: "LUT3D_INTERPOLATION",
417 props: drm_colorop_lut3d_interpolation_list,
418 ARRAY_SIZE(drm_colorop_lut3d_interpolation_list));
419 if (!prop)
420 return -ENOMEM;
421
422 colorop->lut3d_interpolation_property = prop;
423 drm_object_attach_property(obj: &colorop->base, property: prop, init_val: interpolation);
424 colorop->lut3d_interpolation = interpolation;
425
426 /* data */
427 ret = drm_colorop_create_data_prop(dev, colorop);
428 if (ret)
429 return ret;
430
431 drm_colorop_reset(colorop);
432
433 return 0;
434}
435EXPORT_SYMBOL(drm_plane_colorop_3dlut_init);
436
437static void __drm_atomic_helper_colorop_duplicate_state(struct drm_colorop *colorop,
438 struct drm_colorop_state *state)
439{
440 memcpy(state, colorop->state, sizeof(*state));
441
442 if (state->data)
443 drm_property_blob_get(blob: state->data);
444
445 state->bypass = true;
446}
447
448struct drm_colorop_state *
449drm_atomic_helper_colorop_duplicate_state(struct drm_colorop *colorop)
450{
451 struct drm_colorop_state *state;
452
453 if (WARN_ON(!colorop->state))
454 return NULL;
455
456 state = kmalloc(sizeof(*state), GFP_KERNEL);
457 if (state)
458 __drm_atomic_helper_colorop_duplicate_state(colorop, state);
459
460 return state;
461}
462
463void drm_colorop_atomic_destroy_state(struct drm_colorop *colorop,
464 struct drm_colorop_state *state)
465{
466 kfree(objp: state);
467}
468
469/**
470 * __drm_colorop_state_reset - resets colorop state to default values
471 * @colorop_state: atomic colorop state, must not be NULL
472 * @colorop: colorop object, must not be NULL
473 *
474 * Initializes the newly allocated @colorop_state with default
475 * values. This is useful for drivers that subclass the CRTC state.
476 */
477static void __drm_colorop_state_reset(struct drm_colorop_state *colorop_state,
478 struct drm_colorop *colorop)
479{
480 u64 val;
481
482 colorop_state->colorop = colorop;
483 colorop_state->bypass = true;
484
485 if (colorop->curve_1d_type_property) {
486 drm_object_property_get_default_value(obj: &colorop->base,
487 property: colorop->curve_1d_type_property,
488 val: &val);
489 colorop_state->curve_1d_type = val;
490 }
491}
492
493/**
494 * __drm_colorop_reset - reset state on colorop
495 * @colorop: drm colorop
496 * @colorop_state: colorop state to assign
497 *
498 * Initializes the newly allocated @colorop_state and assigns it to
499 * the &drm_crtc->state pointer of @colorop, usually required when
500 * initializing the drivers or when called from the &drm_colorop_funcs.reset
501 * hook.
502 *
503 * This is useful for drivers that subclass the colorop state.
504 */
505static void __drm_colorop_reset(struct drm_colorop *colorop,
506 struct drm_colorop_state *colorop_state)
507{
508 if (colorop_state)
509 __drm_colorop_state_reset(colorop_state, colorop);
510
511 colorop->state = colorop_state;
512}
513
514void drm_colorop_reset(struct drm_colorop *colorop)
515{
516 kfree(objp: colorop->state);
517 colorop->state = kzalloc(sizeof(*colorop->state), GFP_KERNEL);
518
519 if (colorop->state)
520 __drm_colorop_reset(colorop, colorop_state: colorop->state);
521}
522
523static const char * const colorop_type_name[] = {
524 [DRM_COLOROP_1D_CURVE] = "1D Curve",
525 [DRM_COLOROP_1D_LUT] = "1D LUT",
526 [DRM_COLOROP_CTM_3X4] = "3x4 Matrix",
527 [DRM_COLOROP_MULTIPLIER] = "Multiplier",
528 [DRM_COLOROP_3D_LUT] = "3D LUT",
529};
530
531static const char * const colorop_lu3d_interpolation_name[] = {
532 [DRM_COLOROP_LUT3D_INTERPOLATION_TETRAHEDRAL] = "Tetrahedral",
533};
534
535static const char * const colorop_lut1d_interpolation_name[] = {
536 [DRM_COLOROP_LUT1D_INTERPOLATION_LINEAR] = "Linear",
537};
538
539const char *drm_get_colorop_type_name(enum drm_colorop_type type)
540{
541 if (WARN_ON(type >= ARRAY_SIZE(colorop_type_name)))
542 return "unknown";
543
544 return colorop_type_name[type];
545}
546
547const char *drm_get_colorop_curve_1d_type_name(enum drm_colorop_curve_1d_type type)
548{
549 if (WARN_ON(type >= ARRAY_SIZE(colorop_curve_1d_type_names)))
550 return "unknown";
551
552 return colorop_curve_1d_type_names[type];
553}
554
555/**
556 * drm_get_colorop_lut1d_interpolation_name: return a string for interpolation type
557 * @type: interpolation type to compute name of
558 *
559 * In contrast to the other drm_get_*_name functions this one here returns a
560 * const pointer and hence is threadsafe.
561 */
562const char *drm_get_colorop_lut1d_interpolation_name(enum drm_colorop_lut1d_interpolation_type type)
563{
564 if (WARN_ON(type >= ARRAY_SIZE(colorop_lut1d_interpolation_name)))
565 return "unknown";
566
567 return colorop_lut1d_interpolation_name[type];
568}
569
570/**
571 * drm_get_colorop_lut3d_interpolation_name - return a string for interpolation type
572 * @type: interpolation type to compute name of
573 *
574 * In contrast to the other drm_get_*_name functions this one here returns a
575 * const pointer and hence is threadsafe.
576 */
577const char *drm_get_colorop_lut3d_interpolation_name(enum drm_colorop_lut3d_interpolation_type type)
578{
579 if (WARN_ON(type >= ARRAY_SIZE(colorop_lu3d_interpolation_name)))
580 return "unknown";
581
582 return colorop_lu3d_interpolation_name[type];
583}
584
585/**
586 * drm_colorop_set_next_property - sets the next pointer
587 * @colorop: drm colorop
588 * @next: next colorop
589 *
590 * Should be used when constructing the color pipeline
591 */
592void drm_colorop_set_next_property(struct drm_colorop *colorop, struct drm_colorop *next)
593{
594 drm_object_property_set_value(obj: &colorop->base,
595 property: colorop->next_property,
596 val: next ? next->base.id : 0);
597 colorop->next = next;
598}
599EXPORT_SYMBOL(drm_colorop_set_next_property);
600

source code of linux/drivers/gpu/drm/drm_colorop.c