1/*
2 * Copyright (c) 2016 Intel Corporation
3 *
4 * Permission to use, copy, modify, distribute, and sell this software and its
5 * documentation for any purpose is hereby granted without fee, provided that
6 * the above copyright notice appear in all copies and that both that copyright
7 * notice and this permission notice appear in supporting documentation, and
8 * that the name of the copyright holders not be used in advertising or
9 * publicity pertaining to distribution of the software without specific,
10 * written prior permission. The copyright holders make no representations
11 * about the suitability of this software for any purpose. It is provided "as
12 * is" without express or implied warranty.
13 *
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
20 * OF THIS SOFTWARE.
21 */
22
23#include <linux/uaccess.h>
24
25#include <drm/drm_atomic.h>
26#include <drm/drm_color_mgmt.h>
27#include <drm/drm_crtc.h>
28#include <drm/drm_device.h>
29#include <drm/drm_drv.h>
30#include <drm/drm_print.h>
31
32#include "drm_crtc_internal.h"
33
34/**
35 * DOC: overview
36 *
37 * Color management or color space adjustments is supported through a set of 5
38 * properties on the &drm_crtc object. They are set up by calling
39 * drm_crtc_enable_color_mgmt().
40 *
41 * "DEGAMMA_LUT”:
42 * Blob property to set the degamma lookup table (LUT) mapping pixel data
43 * from the framebuffer before it is given to the transformation matrix.
44 * The data is interpreted as an array of &struct drm_color_lut elements.
45 * Hardware might choose not to use the full precision of the LUT elements
46 * nor use all the elements of the LUT (for example the hardware might
47 * choose to interpolate between LUT[0] and LUT[4]).
48 *
49 * Setting this to NULL (blob property value set to 0) means a
50 * linear/pass-thru gamma table should be used. This is generally the
51 * driver boot-up state too. Drivers can access this blob through
52 * &drm_crtc_state.degamma_lut.
53 *
54 * “DEGAMMA_LUT_SIZE”:
55 * Unsinged range property to give the size of the lookup table to be set
56 * on the DEGAMMA_LUT property (the size depends on the underlying
57 * hardware). If drivers support multiple LUT sizes then they should
58 * publish the largest size, and sub-sample smaller sized LUTs (e.g. for
59 * split-gamma modes) appropriately.
60 *
61 * “CTM”:
62 * Blob property to set the current transformation matrix (CTM) apply to
63 * pixel data after the lookup through the degamma LUT and before the
64 * lookup through the gamma LUT. The data is interpreted as a struct
65 * &drm_color_ctm.
66 *
67 * Setting this to NULL (blob property value set to 0) means a
68 * unit/pass-thru matrix should be used. This is generally the driver
69 * boot-up state too. Drivers can access the blob for the color conversion
70 * matrix through &drm_crtc_state.ctm.
71 *
72 * “GAMMA_LUT”:
73 * Blob property to set the gamma lookup table (LUT) mapping pixel data
74 * after the transformation matrix to data sent to the connector. The
75 * data is interpreted as an array of &struct drm_color_lut elements.
76 * Hardware might choose not to use the full precision of the LUT elements
77 * nor use all the elements of the LUT (for example the hardware might
78 * choose to interpolate between LUT[0] and LUT[4]).
79 *
80 * Setting this to NULL (blob property value set to 0) means a
81 * linear/pass-thru gamma table should be used. This is generally the
82 * driver boot-up state too. Drivers can access this blob through
83 * &drm_crtc_state.gamma_lut.
84 *
85 * Note that for mostly historical reasons stemming from Xorg heritage,
86 * this is also used to store the color map (also sometimes color lut, CLUT
87 * or color palette) for indexed formats like DRM_FORMAT_C8.
88 *
89 * “GAMMA_LUT_SIZE”:
90 * Unsigned range property to give the size of the lookup table to be set
91 * on the GAMMA_LUT property (the size depends on the underlying hardware).
92 * If drivers support multiple LUT sizes then they should publish the
93 * largest size, and sub-sample smaller sized LUTs (e.g. for split-gamma
94 * modes) appropriately.
95 *
96 * There is also support for a legacy gamma table, which is set up by calling
97 * drm_mode_crtc_set_gamma_size(). The DRM core will then alias the legacy gamma
98 * ramp with "GAMMA_LUT" or, if that is unavailable, "DEGAMMA_LUT".
99 *
100 * Support for different non RGB color encodings is controlled through
101 * &drm_plane specific COLOR_ENCODING and COLOR_RANGE properties. They
102 * are set up by calling drm_plane_create_color_properties().
103 *
104 * "COLOR_ENCODING":
105 * Optional plane enum property to support different non RGB
106 * color encodings. The driver can provide a subset of standard
107 * enum values supported by the DRM plane.
108 *
109 * "COLOR_RANGE":
110 * Optional plane enum property to support different non RGB
111 * color parameter ranges. The driver can provide a subset of
112 * standard enum values supported by the DRM plane.
113 */
114
115/**
116 * drm_color_ctm_s31_32_to_qm_n
117 *
118 * @user_input: input value
119 * @m: number of integer bits, only support m <= 32, include the sign-bit
120 * @n: number of fractional bits, only support n <= 32
121 *
122 * Convert and clamp S31.32 sign-magnitude to Qm.n (signed 2's complement).
123 * The sign-bit BIT(m+n-1) and above are 0 for positive value and 1 for negative
124 * the range of value is [-2^(m-1), 2^(m-1) - 2^-n]
125 *
126 * For example
127 * A Q3.12 format number:
128 * - required bit: 3 + 12 = 15bits
129 * - range: [-2^2, 2^2 - 2^−15]
130 *
131 * NOTE: the m can be zero if all bit_precision are used to present fractional
132 * bits like Q0.32
133 */
134u64 drm_color_ctm_s31_32_to_qm_n(u64 user_input, u32 m, u32 n)
135{
136 u64 mag = (user_input & ~BIT_ULL(63)) >> (32 - n);
137 bool negative = !!(user_input & BIT_ULL(63));
138 s64 val;
139
140 WARN_ON(m > 32 || n > 32);
141
142 val = clamp_val(mag, 0, negative ?
143 BIT_ULL(n + m - 1) : BIT_ULL(n + m - 1) - 1);
144
145 return negative ? -val : val;
146}
147EXPORT_SYMBOL(drm_color_ctm_s31_32_to_qm_n);
148
149/**
150 * drm_crtc_enable_color_mgmt - enable color management properties
151 * @crtc: DRM CRTC
152 * @degamma_lut_size: the size of the degamma lut (before CSC)
153 * @has_ctm: whether to attach ctm_property for CSC matrix
154 * @gamma_lut_size: the size of the gamma lut (after CSC)
155 *
156 * This function lets the driver enable the color correction
157 * properties on a CRTC. This includes 3 degamma, csc and gamma
158 * properties that userspace can set and 2 size properties to inform
159 * the userspace of the lut sizes. Each of the properties are
160 * optional. The gamma and degamma properties are only attached if
161 * their size is not 0 and ctm_property is only attached if has_ctm is
162 * true.
163 */
164void drm_crtc_enable_color_mgmt(struct drm_crtc *crtc,
165 uint degamma_lut_size,
166 bool has_ctm,
167 uint gamma_lut_size)
168{
169 struct drm_device *dev = crtc->dev;
170 struct drm_mode_config *config = &dev->mode_config;
171
172 if (degamma_lut_size) {
173 drm_object_attach_property(obj: &crtc->base,
174 property: config->degamma_lut_property, init_val: 0);
175 drm_object_attach_property(obj: &crtc->base,
176 property: config->degamma_lut_size_property,
177 init_val: degamma_lut_size);
178 }
179
180 if (has_ctm)
181 drm_object_attach_property(obj: &crtc->base,
182 property: config->ctm_property, init_val: 0);
183
184 if (gamma_lut_size) {
185 drm_object_attach_property(obj: &crtc->base,
186 property: config->gamma_lut_property, init_val: 0);
187 drm_object_attach_property(obj: &crtc->base,
188 property: config->gamma_lut_size_property,
189 init_val: gamma_lut_size);
190 }
191}
192EXPORT_SYMBOL(drm_crtc_enable_color_mgmt);
193
194/**
195 * drm_mode_crtc_set_gamma_size - set the gamma table size
196 * @crtc: CRTC to set the gamma table size for
197 * @gamma_size: size of the gamma table
198 *
199 * Drivers which support gamma tables should set this to the supported gamma
200 * table size when initializing the CRTC. Currently the drm core only supports a
201 * fixed gamma table size.
202 *
203 * Returns:
204 * Zero on success, negative errno on failure.
205 */
206int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
207 int gamma_size)
208{
209 uint16_t *r_base, *g_base, *b_base;
210 int i;
211
212 crtc->gamma_size = gamma_size;
213
214 crtc->gamma_store = kcalloc(n: gamma_size, size: sizeof(uint16_t) * 3,
215 GFP_KERNEL);
216 if (!crtc->gamma_store) {
217 crtc->gamma_size = 0;
218 return -ENOMEM;
219 }
220
221 r_base = crtc->gamma_store;
222 g_base = r_base + gamma_size;
223 b_base = g_base + gamma_size;
224 for (i = 0; i < gamma_size; i++) {
225 r_base[i] = i << 8;
226 g_base[i] = i << 8;
227 b_base[i] = i << 8;
228 }
229
230
231 return 0;
232}
233EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);
234
235/**
236 * drm_crtc_supports_legacy_gamma - does the crtc support legacy gamma correction table
237 * @crtc: CRTC object
238 *
239 * Returns true/false if the given crtc supports setting the legacy gamma
240 * correction table.
241 */
242static bool drm_crtc_supports_legacy_gamma(struct drm_crtc *crtc)
243{
244 u32 gamma_id = crtc->dev->mode_config.gamma_lut_property->base.id;
245 u32 degamma_id = crtc->dev->mode_config.degamma_lut_property->base.id;
246
247 if (!crtc->gamma_size)
248 return false;
249
250 if (crtc->funcs->gamma_set)
251 return true;
252
253 return !!(drm_mode_obj_find_prop_id(obj: &crtc->base, prop_id: gamma_id) ||
254 drm_mode_obj_find_prop_id(obj: &crtc->base, prop_id: degamma_id));
255}
256
257/**
258 * drm_crtc_legacy_gamma_set - set the legacy gamma correction table
259 * @crtc: CRTC object
260 * @red: red correction table
261 * @green: green correction table
262 * @blue: blue correction table
263 * @size: size of the tables
264 * @ctx: lock acquire context
265 *
266 * Implements support for legacy gamma correction table for drivers
267 * that have set drm_crtc_funcs.gamma_set or that support color management
268 * through the DEGAMMA_LUT/GAMMA_LUT properties. See
269 * drm_crtc_enable_color_mgmt() and the containing chapter for
270 * how the atomic color management and gamma tables work.
271 *
272 * This function sets the gamma using drm_crtc_funcs.gamma_set if set, or
273 * alternatively using crtc color management properties.
274 */
275static int drm_crtc_legacy_gamma_set(struct drm_crtc *crtc,
276 u16 *red, u16 *green, u16 *blue,
277 u32 size,
278 struct drm_modeset_acquire_ctx *ctx)
279{
280 struct drm_device *dev = crtc->dev;
281 struct drm_atomic_state *state;
282 struct drm_crtc_state *crtc_state;
283 struct drm_property_blob *blob;
284 struct drm_color_lut *blob_data;
285 u32 gamma_id = dev->mode_config.gamma_lut_property->base.id;
286 u32 degamma_id = dev->mode_config.degamma_lut_property->base.id;
287 bool use_gamma_lut;
288 int i, ret = 0;
289 bool replaced;
290
291 if (crtc->funcs->gamma_set)
292 return crtc->funcs->gamma_set(crtc, red, green, blue, size, ctx);
293
294 if (drm_mode_obj_find_prop_id(obj: &crtc->base, prop_id: gamma_id))
295 use_gamma_lut = true;
296 else if (drm_mode_obj_find_prop_id(obj: &crtc->base, prop_id: degamma_id))
297 use_gamma_lut = false;
298 else
299 return -ENODEV;
300
301 state = drm_atomic_state_alloc(dev: crtc->dev);
302 if (!state)
303 return -ENOMEM;
304
305 blob = drm_property_create_blob(dev,
306 length: sizeof(struct drm_color_lut) * size,
307 NULL);
308 if (IS_ERR(ptr: blob)) {
309 ret = PTR_ERR(ptr: blob);
310 blob = NULL;
311 goto fail;
312 }
313
314 /* Prepare GAMMA_LUT with the legacy values. */
315 blob_data = blob->data;
316 for (i = 0; i < size; i++) {
317 blob_data[i].red = red[i];
318 blob_data[i].green = green[i];
319 blob_data[i].blue = blue[i];
320 }
321
322 state->acquire_ctx = ctx;
323 crtc_state = drm_atomic_get_crtc_state(state, crtc);
324 if (IS_ERR(ptr: crtc_state)) {
325 ret = PTR_ERR(ptr: crtc_state);
326 goto fail;
327 }
328
329 /* Set GAMMA_LUT and reset DEGAMMA_LUT and CTM */
330 replaced = drm_property_replace_blob(blob: &crtc_state->degamma_lut,
331 new_blob: use_gamma_lut ? NULL : blob);
332 replaced |= drm_property_replace_blob(blob: &crtc_state->ctm, NULL);
333 replaced |= drm_property_replace_blob(blob: &crtc_state->gamma_lut,
334 new_blob: use_gamma_lut ? blob : NULL);
335 crtc_state->color_mgmt_changed |= replaced;
336
337 ret = drm_atomic_commit(state);
338
339fail:
340 drm_atomic_state_put(state);
341 drm_property_blob_put(blob);
342 return ret;
343}
344
345/**
346 * drm_mode_gamma_set_ioctl - set the gamma table
347 * @dev: DRM device
348 * @data: ioctl data
349 * @file_priv: DRM file info
350 *
351 * Set the gamma table of a CRTC to the one passed in by the user. Userspace can
352 * inquire the required gamma table size through drm_mode_gamma_get_ioctl.
353 *
354 * Called by the user via ioctl.
355 *
356 * Returns:
357 * Zero on success, negative errno on failure.
358 */
359int drm_mode_gamma_set_ioctl(struct drm_device *dev,
360 void *data, struct drm_file *file_priv)
361{
362 struct drm_mode_crtc_lut *crtc_lut = data;
363 struct drm_crtc *crtc;
364 void *r_base, *g_base, *b_base;
365 int size;
366 struct drm_modeset_acquire_ctx ctx;
367 int ret = 0;
368
369 if (!drm_core_check_feature(dev, feature: DRIVER_MODESET))
370 return -EOPNOTSUPP;
371
372 crtc = drm_crtc_find(dev, file_priv, id: crtc_lut->crtc_id);
373 if (!crtc)
374 return -ENOENT;
375
376 if (!drm_crtc_supports_legacy_gamma(crtc))
377 return -ENOSYS;
378
379 /* memcpy into gamma store */
380 if (crtc_lut->gamma_size != crtc->gamma_size)
381 return -EINVAL;
382
383 DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, ret);
384
385 size = crtc_lut->gamma_size * (sizeof(uint16_t));
386 r_base = crtc->gamma_store;
387 if (copy_from_user(to: r_base, from: (void __user *)(unsigned long)crtc_lut->red, n: size)) {
388 ret = -EFAULT;
389 goto out;
390 }
391
392 g_base = r_base + size;
393 if (copy_from_user(to: g_base, from: (void __user *)(unsigned long)crtc_lut->green, n: size)) {
394 ret = -EFAULT;
395 goto out;
396 }
397
398 b_base = g_base + size;
399 if (copy_from_user(to: b_base, from: (void __user *)(unsigned long)crtc_lut->blue, n: size)) {
400 ret = -EFAULT;
401 goto out;
402 }
403
404 ret = drm_crtc_legacy_gamma_set(crtc, red: r_base, green: g_base, blue: b_base,
405 size: crtc->gamma_size, ctx: &ctx);
406
407out:
408 DRM_MODESET_LOCK_ALL_END(dev, ctx, ret);
409 return ret;
410
411}
412
413/**
414 * drm_mode_gamma_get_ioctl - get the gamma table
415 * @dev: DRM device
416 * @data: ioctl data
417 * @file_priv: DRM file info
418 *
419 * Copy the current gamma table into the storage provided. This also provides
420 * the gamma table size the driver expects, which can be used to size the
421 * allocated storage.
422 *
423 * Called by the user via ioctl.
424 *
425 * Returns:
426 * Zero on success, negative errno on failure.
427 */
428int drm_mode_gamma_get_ioctl(struct drm_device *dev,
429 void *data, struct drm_file *file_priv)
430{
431 struct drm_mode_crtc_lut *crtc_lut = data;
432 struct drm_crtc *crtc;
433 void *r_base, *g_base, *b_base;
434 int size;
435 int ret = 0;
436
437 if (!drm_core_check_feature(dev, feature: DRIVER_MODESET))
438 return -EOPNOTSUPP;
439
440 crtc = drm_crtc_find(dev, file_priv, id: crtc_lut->crtc_id);
441 if (!crtc)
442 return -ENOENT;
443
444 /* memcpy into gamma store */
445 if (crtc_lut->gamma_size != crtc->gamma_size)
446 return -EINVAL;
447
448 drm_modeset_lock(lock: &crtc->mutex, NULL);
449 size = crtc_lut->gamma_size * (sizeof(uint16_t));
450 r_base = crtc->gamma_store;
451 if (copy_to_user(to: (void __user *)(unsigned long)crtc_lut->red, from: r_base, n: size)) {
452 ret = -EFAULT;
453 goto out;
454 }
455
456 g_base = r_base + size;
457 if (copy_to_user(to: (void __user *)(unsigned long)crtc_lut->green, from: g_base, n: size)) {
458 ret = -EFAULT;
459 goto out;
460 }
461
462 b_base = g_base + size;
463 if (copy_to_user(to: (void __user *)(unsigned long)crtc_lut->blue, from: b_base, n: size)) {
464 ret = -EFAULT;
465 goto out;
466 }
467out:
468 drm_modeset_unlock(lock: &crtc->mutex);
469 return ret;
470}
471
472static const char * const color_encoding_name[] = {
473 [DRM_COLOR_YCBCR_BT601] = "ITU-R BT.601 YCbCr",
474 [DRM_COLOR_YCBCR_BT709] = "ITU-R BT.709 YCbCr",
475 [DRM_COLOR_YCBCR_BT2020] = "ITU-R BT.2020 YCbCr",
476};
477
478static const char * const color_range_name[] = {
479 [DRM_COLOR_YCBCR_FULL_RANGE] = "YCbCr full range",
480 [DRM_COLOR_YCBCR_LIMITED_RANGE] = "YCbCr limited range",
481};
482
483/**
484 * drm_get_color_encoding_name - return a string for color encoding
485 * @encoding: color encoding to compute name of
486 *
487 * In contrast to the other drm_get_*_name functions this one here returns a
488 * const pointer and hence is threadsafe.
489 */
490const char *drm_get_color_encoding_name(enum drm_color_encoding encoding)
491{
492 if (WARN_ON(encoding >= ARRAY_SIZE(color_encoding_name)))
493 return "unknown";
494
495 return color_encoding_name[encoding];
496}
497
498/**
499 * drm_get_color_range_name - return a string for color range
500 * @range: color range to compute name of
501 *
502 * In contrast to the other drm_get_*_name functions this one here returns a
503 * const pointer and hence is threadsafe.
504 */
505const char *drm_get_color_range_name(enum drm_color_range range)
506{
507 if (WARN_ON(range >= ARRAY_SIZE(color_range_name)))
508 return "unknown";
509
510 return color_range_name[range];
511}
512
513/**
514 * drm_plane_create_color_properties - color encoding related plane properties
515 * @plane: plane object
516 * @supported_encodings: bitfield indicating supported color encodings
517 * @supported_ranges: bitfileld indicating supported color ranges
518 * @default_encoding: default color encoding
519 * @default_range: default color range
520 *
521 * Create and attach plane specific COLOR_ENCODING and COLOR_RANGE
522 * properties to @plane. The supported encodings and ranges should
523 * be provided in supported_encodings and supported_ranges bitmasks.
524 * Each bit set in the bitmask indicates that its number as enum
525 * value is supported.
526 */
527int drm_plane_create_color_properties(struct drm_plane *plane,
528 u32 supported_encodings,
529 u32 supported_ranges,
530 enum drm_color_encoding default_encoding,
531 enum drm_color_range default_range)
532{
533 struct drm_device *dev = plane->dev;
534 struct drm_property *prop;
535 struct drm_prop_enum_list enum_list[max_t(int, DRM_COLOR_ENCODING_MAX,
536 DRM_COLOR_RANGE_MAX)];
537 int i, len;
538
539 if (WARN_ON(supported_encodings == 0 ||
540 (supported_encodings & -BIT(DRM_COLOR_ENCODING_MAX)) != 0 ||
541 (supported_encodings & BIT(default_encoding)) == 0))
542 return -EINVAL;
543
544 if (WARN_ON(supported_ranges == 0 ||
545 (supported_ranges & -BIT(DRM_COLOR_RANGE_MAX)) != 0 ||
546 (supported_ranges & BIT(default_range)) == 0))
547 return -EINVAL;
548
549 len = 0;
550 for (i = 0; i < DRM_COLOR_ENCODING_MAX; i++) {
551 if ((supported_encodings & BIT(i)) == 0)
552 continue;
553
554 enum_list[len].type = i;
555 enum_list[len].name = color_encoding_name[i];
556 len++;
557 }
558
559 prop = drm_property_create_enum(dev, flags: 0, name: "COLOR_ENCODING",
560 props: enum_list, num_values: len);
561 if (!prop)
562 return -ENOMEM;
563 plane->color_encoding_property = prop;
564 drm_object_attach_property(obj: &plane->base, property: prop, init_val: default_encoding);
565 if (plane->state)
566 plane->state->color_encoding = default_encoding;
567
568 len = 0;
569 for (i = 0; i < DRM_COLOR_RANGE_MAX; i++) {
570 if ((supported_ranges & BIT(i)) == 0)
571 continue;
572
573 enum_list[len].type = i;
574 enum_list[len].name = color_range_name[i];
575 len++;
576 }
577
578 prop = drm_property_create_enum(dev, flags: 0, name: "COLOR_RANGE",
579 props: enum_list, num_values: len);
580 if (!prop)
581 return -ENOMEM;
582 plane->color_range_property = prop;
583 drm_object_attach_property(obj: &plane->base, property: prop, init_val: default_range);
584 if (plane->state)
585 plane->state->color_range = default_range;
586
587 return 0;
588}
589EXPORT_SYMBOL(drm_plane_create_color_properties);
590
591/**
592 * drm_color_lut_check - check validity of lookup table
593 * @lut: property blob containing LUT to check
594 * @tests: bitmask of tests to run
595 *
596 * Helper to check whether a userspace-provided lookup table is valid and
597 * satisfies hardware requirements. Drivers pass a bitmask indicating which of
598 * the tests in &drm_color_lut_tests should be performed.
599 *
600 * Returns 0 on success, -EINVAL on failure.
601 */
602int drm_color_lut_check(const struct drm_property_blob *lut, u32 tests)
603{
604 const struct drm_color_lut *entry;
605 int i;
606
607 if (!lut || !tests)
608 return 0;
609
610 entry = lut->data;
611 for (i = 0; i < drm_color_lut_size(blob: lut); i++) {
612 if (tests & DRM_COLOR_LUT_EQUAL_CHANNELS) {
613 if (entry[i].red != entry[i].blue ||
614 entry[i].red != entry[i].green) {
615 DRM_DEBUG_KMS("All LUT entries must have equal r/g/b\n");
616 return -EINVAL;
617 }
618 }
619
620 if (i > 0 && tests & DRM_COLOR_LUT_NON_DECREASING) {
621 if (entry[i].red < entry[i - 1].red ||
622 entry[i].green < entry[i - 1].green ||
623 entry[i].blue < entry[i - 1].blue) {
624 DRM_DEBUG_KMS("LUT entries must never decrease.\n");
625 return -EINVAL;
626 }
627 }
628 }
629
630 return 0;
631}
632EXPORT_SYMBOL(drm_color_lut_check);
633

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