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_color_mgmt.h>
26 #include <drm/drm_crtc.h>
27 #include <drm/drm_device.h>
28 #include <drm/drm_drv.h>
29 #include <drm/drm_print.h>
30
31 #include "drm_crtc_internal.h"
32
33 /**
34 * DOC: overview
35 *
36 * Color management or color space adjustments is supported through a set of 5
37 * properties on the &drm_crtc object. They are set up by calling
38 * drm_crtc_enable_color_mgmt().
39 *
40 * "DEGAMMA_LUT”:
41 * Blob property to set the degamma lookup table (LUT) mapping pixel data
42 * from the framebuffer before it is given to the transformation matrix.
43 * The data is interpreted as an array of &struct drm_color_lut elements.
44 * Hardware might choose not to use the full precision of the LUT elements
45 * nor use all the elements of the LUT (for example the hardware might
46 * choose to interpolate between LUT[0] and LUT[4]).
47 *
48 * Setting this to NULL (blob property value set to 0) means a
49 * linear/pass-thru gamma table should be used. This is generally the
50 * driver boot-up state too. Drivers can access this blob through
51 * &drm_crtc_state.degamma_lut.
52 *
53 * “DEGAMMA_LUT_SIZE”:
54 * Unsinged range property to give the size of the lookup table to be set
55 * on the DEGAMMA_LUT property (the size depends on the underlying
56 * hardware). If drivers support multiple LUT sizes then they should
57 * publish the largest size, and sub-sample smaller sized LUTs (e.g. for
58 * split-gamma modes) appropriately.
59 *
60 * “CTM”:
61 * Blob property to set the current transformation matrix (CTM) apply to
62 * pixel data after the lookup through the degamma LUT and before the
63 * lookup through the gamma LUT. The data is interpreted as a struct
64 * &drm_color_ctm.
65 *
66 * Setting this to NULL (blob property value set to 0) means a
67 * unit/pass-thru matrix should be used. This is generally the driver
68 * boot-up state too. Drivers can access the blob for the color conversion
69 * matrix through &drm_crtc_state.ctm.
70 *
71 * “GAMMA_LUT”:
72 * Blob property to set the gamma lookup table (LUT) mapping pixel data
73 * after the transformation matrix to data sent to the connector. The
74 * data is interpreted as an array of &struct drm_color_lut elements.
75 * Hardware might choose not to use the full precision of the LUT elements
76 * nor use all the elements of the LUT (for example the hardware might
77 * choose to interpolate between LUT[0] and LUT[4]).
78 *
79 * Setting this to NULL (blob property value set to 0) means a
80 * linear/pass-thru gamma table should be used. This is generally the
81 * driver boot-up state too. Drivers can access this blob through
82 * &drm_crtc_state.gamma_lut.
83 *
84 * “GAMMA_LUT_SIZE”:
85 * Unsigned range property to give the size of the lookup table to be set
86 * on the GAMMA_LUT property (the size depends on the underlying hardware).
87 * If drivers support multiple LUT sizes then they should publish the
88 * largest size, and sub-sample smaller sized LUTs (e.g. for split-gamma
89 * modes) appropriately.
90 *
91 * There is also support for a legacy gamma table, which is set up by calling
92 * drm_mode_crtc_set_gamma_size(). Drivers which support both should use
93 * drm_atomic_helper_legacy_gamma_set() to alias the legacy gamma ramp with the
94 * "GAMMA_LUT" property above.
95 *
96 * Support for different non RGB color encodings is controlled through
97 * &drm_plane specific COLOR_ENCODING and COLOR_RANGE properties. They
98 * are set up by calling drm_plane_create_color_properties().
99 *
100 * "COLOR_ENCODING"
101 * Optional plane enum property to support different non RGB
102 * color encodings. The driver can provide a subset of standard
103 * enum values supported by the DRM plane.
104 *
105 * "COLOR_RANGE"
106 * Optional plane enum property to support different non RGB
107 * color parameter ranges. The driver can provide a subset of
108 * standard enum values supported by the DRM plane.
109 */
110
111 /**
112 * drm_color_ctm_s31_32_to_qm_n
113 *
114 * @user_input: input value
115 * @m: number of integer bits, only support m <= 32, include the sign-bit
116 * @n: number of fractional bits, only support n <= 32
117 *
118 * Convert and clamp S31.32 sign-magnitude to Qm.n (signed 2's complement).
119 * The sign-bit BIT(m+n-1) and above are 0 for positive value and 1 for negative
120 * the range of value is [-2^(m-1), 2^(m-1) - 2^-n]
121 *
122 * For example
123 * A Q3.12 format number:
124 * - required bit: 3 + 12 = 15bits
125 * - range: [-2^2, 2^2 - 2^−15]
126 *
127 * NOTE: the m can be zero if all bit_precision are used to present fractional
128 * bits like Q0.32
129 */
drm_color_ctm_s31_32_to_qm_n(u64 user_input,u32 m,u32 n)130 u64 drm_color_ctm_s31_32_to_qm_n(u64 user_input, u32 m, u32 n)
131 {
132 u64 mag = (user_input & ~BIT_ULL(63)) >> (32 - n);
133 bool negative = !!(user_input & BIT_ULL(63));
134 s64 val;
135
136 WARN_ON(m > 32 || n > 32);
137
138 val = clamp_val(mag, 0, negative ?
139 BIT_ULL(n + m - 1) : BIT_ULL(n + m - 1) - 1);
140
141 return negative ? -val : val;
142 }
143 EXPORT_SYMBOL(drm_color_ctm_s31_32_to_qm_n);
144
145 /**
146 * drm_crtc_enable_color_mgmt - enable color management properties
147 * @crtc: DRM CRTC
148 * @degamma_lut_size: the size of the degamma lut (before CSC)
149 * @has_ctm: whether to attach ctm_property for CSC matrix
150 * @gamma_lut_size: the size of the gamma lut (after CSC)
151 *
152 * This function lets the driver enable the color correction
153 * properties on a CRTC. This includes 3 degamma, csc and gamma
154 * properties that userspace can set and 2 size properties to inform
155 * the userspace of the lut sizes. Each of the properties are
156 * optional. The gamma and degamma properties are only attached if
157 * their size is not 0 and ctm_property is only attached if has_ctm is
158 * true.
159 *
160 * Drivers should use drm_atomic_helper_legacy_gamma_set() to implement the
161 * legacy &drm_crtc_funcs.gamma_set callback.
162 */
drm_crtc_enable_color_mgmt(struct drm_crtc * crtc,uint degamma_lut_size,bool has_ctm,uint gamma_lut_size)163 void drm_crtc_enable_color_mgmt(struct drm_crtc *crtc,
164 uint degamma_lut_size,
165 bool has_ctm,
166 uint gamma_lut_size)
167 {
168 struct drm_device *dev = crtc->dev;
169 struct drm_mode_config *config = &dev->mode_config;
170
171 if (degamma_lut_size) {
172 drm_object_attach_property(&crtc->base,
173 config->degamma_lut_property, 0);
174 drm_object_attach_property(&crtc->base,
175 config->degamma_lut_size_property,
176 degamma_lut_size);
177 }
178
179 if (has_ctm)
180 drm_object_attach_property(&crtc->base,
181 config->ctm_property, 0);
182
183 if (gamma_lut_size) {
184 drm_object_attach_property(&crtc->base,
185 config->gamma_lut_property, 0);
186 drm_object_attach_property(&crtc->base,
187 config->gamma_lut_size_property,
188 gamma_lut_size);
189 }
190 }
191 EXPORT_SYMBOL(drm_crtc_enable_color_mgmt);
192
193 /**
194 * drm_mode_crtc_set_gamma_size - set the gamma table size
195 * @crtc: CRTC to set the gamma table size for
196 * @gamma_size: size of the gamma table
197 *
198 * Drivers which support gamma tables should set this to the supported gamma
199 * table size when initializing the CRTC. Currently the drm core only supports a
200 * fixed gamma table size.
201 *
202 * Returns:
203 * Zero on success, negative errno on failure.
204 */
drm_mode_crtc_set_gamma_size(struct drm_crtc * crtc,int gamma_size)205 int drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
206 int gamma_size)
207 {
208 uint16_t *r_base, *g_base, *b_base;
209 int i;
210
211 crtc->gamma_size = gamma_size;
212
213 crtc->gamma_store = kcalloc(gamma_size, sizeof(uint16_t) * 3,
214 GFP_KERNEL);
215 if (!crtc->gamma_store) {
216 crtc->gamma_size = 0;
217 return -ENOMEM;
218 }
219
220 r_base = crtc->gamma_store;
221 g_base = r_base + gamma_size;
222 b_base = g_base + gamma_size;
223 for (i = 0; i < gamma_size; i++) {
224 r_base[i] = i << 8;
225 g_base[i] = i << 8;
226 b_base[i] = i << 8;
227 }
228
229
230 return 0;
231 }
232 EXPORT_SYMBOL(drm_mode_crtc_set_gamma_size);
233
234 /**
235 * drm_mode_gamma_set_ioctl - set the gamma table
236 * @dev: DRM device
237 * @data: ioctl data
238 * @file_priv: DRM file info
239 *
240 * Set the gamma table of a CRTC to the one passed in by the user. Userspace can
241 * inquire the required gamma table size through drm_mode_gamma_get_ioctl.
242 *
243 * Called by the user via ioctl.
244 *
245 * Returns:
246 * Zero on success, negative errno on failure.
247 */
drm_mode_gamma_set_ioctl(struct drm_device * dev,void * data,struct drm_file * file_priv)248 int drm_mode_gamma_set_ioctl(struct drm_device *dev,
249 void *data, struct drm_file *file_priv)
250 {
251 struct drm_mode_crtc_lut *crtc_lut = data;
252 struct drm_crtc *crtc;
253 void *r_base, *g_base, *b_base;
254 int size;
255 struct drm_modeset_acquire_ctx ctx;
256 int ret = 0;
257
258 if (!drm_core_check_feature(dev, DRIVER_MODESET))
259 return -EOPNOTSUPP;
260
261 crtc = drm_crtc_find(dev, file_priv, crtc_lut->crtc_id);
262 if (!crtc)
263 return -ENOENT;
264
265 if (crtc->funcs->gamma_set == NULL)
266 return -ENOSYS;
267
268 /* memcpy into gamma store */
269 if (crtc_lut->gamma_size != crtc->gamma_size)
270 return -EINVAL;
271
272 DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, 0, ret);
273
274 size = crtc_lut->gamma_size * (sizeof(uint16_t));
275 r_base = crtc->gamma_store;
276 if (copy_from_user(r_base, (void __user *)(unsigned long)crtc_lut->red, size)) {
277 ret = -EFAULT;
278 goto out;
279 }
280
281 g_base = r_base + size;
282 if (copy_from_user(g_base, (void __user *)(unsigned long)crtc_lut->green, size)) {
283 ret = -EFAULT;
284 goto out;
285 }
286
287 b_base = g_base + size;
288 if (copy_from_user(b_base, (void __user *)(unsigned long)crtc_lut->blue, size)) {
289 ret = -EFAULT;
290 goto out;
291 }
292
293 ret = crtc->funcs->gamma_set(crtc, r_base, g_base, b_base,
294 crtc->gamma_size, &ctx);
295
296 out:
297 DRM_MODESET_LOCK_ALL_END(dev, ctx, ret);
298 return ret;
299
300 }
301
302 /**
303 * drm_mode_gamma_get_ioctl - get the gamma table
304 * @dev: DRM device
305 * @data: ioctl data
306 * @file_priv: DRM file info
307 *
308 * Copy the current gamma table into the storage provided. This also provides
309 * the gamma table size the driver expects, which can be used to size the
310 * allocated storage.
311 *
312 * Called by the user via ioctl.
313 *
314 * Returns:
315 * Zero on success, negative errno on failure.
316 */
drm_mode_gamma_get_ioctl(struct drm_device * dev,void * data,struct drm_file * file_priv)317 int drm_mode_gamma_get_ioctl(struct drm_device *dev,
318 void *data, struct drm_file *file_priv)
319 {
320 struct drm_mode_crtc_lut *crtc_lut = data;
321 struct drm_crtc *crtc;
322 void *r_base, *g_base, *b_base;
323 int size;
324 int ret = 0;
325
326 if (!drm_core_check_feature(dev, DRIVER_MODESET))
327 return -EOPNOTSUPP;
328
329 crtc = drm_crtc_find(dev, file_priv, crtc_lut->crtc_id);
330 if (!crtc)
331 return -ENOENT;
332
333 /* memcpy into gamma store */
334 if (crtc_lut->gamma_size != crtc->gamma_size)
335 return -EINVAL;
336
337 drm_modeset_lock(&crtc->mutex, NULL);
338 size = crtc_lut->gamma_size * (sizeof(uint16_t));
339 r_base = crtc->gamma_store;
340 if (copy_to_user((void __user *)(unsigned long)crtc_lut->red, r_base, size)) {
341 ret = -EFAULT;
342 goto out;
343 }
344
345 g_base = r_base + size;
346 if (copy_to_user((void __user *)(unsigned long)crtc_lut->green, g_base, size)) {
347 ret = -EFAULT;
348 goto out;
349 }
350
351 b_base = g_base + size;
352 if (copy_to_user((void __user *)(unsigned long)crtc_lut->blue, b_base, size)) {
353 ret = -EFAULT;
354 goto out;
355 }
356 out:
357 drm_modeset_unlock(&crtc->mutex);
358 return ret;
359 }
360
361 static const char * const color_encoding_name[] = {
362 [DRM_COLOR_YCBCR_BT601] = "ITU-R BT.601 YCbCr",
363 [DRM_COLOR_YCBCR_BT709] = "ITU-R BT.709 YCbCr",
364 [DRM_COLOR_YCBCR_BT2020] = "ITU-R BT.2020 YCbCr",
365 };
366
367 static const char * const color_range_name[] = {
368 [DRM_COLOR_YCBCR_FULL_RANGE] = "YCbCr full range",
369 [DRM_COLOR_YCBCR_LIMITED_RANGE] = "YCbCr limited range",
370 };
371
372 /**
373 * drm_get_color_encoding_name - return a string for color encoding
374 * @encoding: color encoding to compute name of
375 *
376 * In contrast to the other drm_get_*_name functions this one here returns a
377 * const pointer and hence is threadsafe.
378 */
drm_get_color_encoding_name(enum drm_color_encoding encoding)379 const char *drm_get_color_encoding_name(enum drm_color_encoding encoding)
380 {
381 if (WARN_ON(encoding >= ARRAY_SIZE(color_encoding_name)))
382 return "unknown";
383
384 return color_encoding_name[encoding];
385 }
386
387 /**
388 * drm_get_color_range_name - return a string for color range
389 * @range: color range to compute name of
390 *
391 * In contrast to the other drm_get_*_name functions this one here returns a
392 * const pointer and hence is threadsafe.
393 */
drm_get_color_range_name(enum drm_color_range range)394 const char *drm_get_color_range_name(enum drm_color_range range)
395 {
396 if (WARN_ON(range >= ARRAY_SIZE(color_range_name)))
397 return "unknown";
398
399 return color_range_name[range];
400 }
401
402 /**
403 * drm_plane_create_color_properties - color encoding related plane properties
404 * @plane: plane object
405 * @supported_encodings: bitfield indicating supported color encodings
406 * @supported_ranges: bitfileld indicating supported color ranges
407 * @default_encoding: default color encoding
408 * @default_range: default color range
409 *
410 * Create and attach plane specific COLOR_ENCODING and COLOR_RANGE
411 * properties to @plane. The supported encodings and ranges should
412 * be provided in supported_encodings and supported_ranges bitmasks.
413 * Each bit set in the bitmask indicates that its number as enum
414 * value is supported.
415 */
drm_plane_create_color_properties(struct drm_plane * plane,u32 supported_encodings,u32 supported_ranges,enum drm_color_encoding default_encoding,enum drm_color_range default_range)416 int drm_plane_create_color_properties(struct drm_plane *plane,
417 u32 supported_encodings,
418 u32 supported_ranges,
419 enum drm_color_encoding default_encoding,
420 enum drm_color_range default_range)
421 {
422 struct drm_device *dev = plane->dev;
423 struct drm_property *prop;
424 struct drm_prop_enum_list enum_list[max_t(int, DRM_COLOR_ENCODING_MAX,
425 DRM_COLOR_RANGE_MAX)];
426 int i, len;
427
428 if (WARN_ON(supported_encodings == 0 ||
429 (supported_encodings & -BIT(DRM_COLOR_ENCODING_MAX)) != 0 ||
430 (supported_encodings & BIT(default_encoding)) == 0))
431 return -EINVAL;
432
433 if (WARN_ON(supported_ranges == 0 ||
434 (supported_ranges & -BIT(DRM_COLOR_RANGE_MAX)) != 0 ||
435 (supported_ranges & BIT(default_range)) == 0))
436 return -EINVAL;
437
438 len = 0;
439 for (i = 0; i < DRM_COLOR_ENCODING_MAX; i++) {
440 if ((supported_encodings & BIT(i)) == 0)
441 continue;
442
443 enum_list[len].type = i;
444 enum_list[len].name = color_encoding_name[i];
445 len++;
446 }
447
448 prop = drm_property_create_enum(dev, 0, "COLOR_ENCODING",
449 enum_list, len);
450 if (!prop)
451 return -ENOMEM;
452 plane->color_encoding_property = prop;
453 drm_object_attach_property(&plane->base, prop, default_encoding);
454 if (plane->state)
455 plane->state->color_encoding = default_encoding;
456
457 len = 0;
458 for (i = 0; i < DRM_COLOR_RANGE_MAX; i++) {
459 if ((supported_ranges & BIT(i)) == 0)
460 continue;
461
462 enum_list[len].type = i;
463 enum_list[len].name = color_range_name[i];
464 len++;
465 }
466
467 prop = drm_property_create_enum(dev, 0, "COLOR_RANGE",
468 enum_list, len);
469 if (!prop)
470 return -ENOMEM;
471 plane->color_range_property = prop;
472 drm_object_attach_property(&plane->base, prop, default_range);
473 if (plane->state)
474 plane->state->color_range = default_range;
475
476 return 0;
477 }
478 EXPORT_SYMBOL(drm_plane_create_color_properties);
479
480 /**
481 * drm_color_lut_check - check validity of lookup table
482 * @lut: property blob containing LUT to check
483 * @tests: bitmask of tests to run
484 *
485 * Helper to check whether a userspace-provided lookup table is valid and
486 * satisfies hardware requirements. Drivers pass a bitmask indicating which of
487 * the tests in &drm_color_lut_tests should be performed.
488 *
489 * Returns 0 on success, -EINVAL on failure.
490 */
drm_color_lut_check(const struct drm_property_blob * lut,u32 tests)491 int drm_color_lut_check(const struct drm_property_blob *lut, u32 tests)
492 {
493 const struct drm_color_lut *entry;
494 int i;
495
496 if (!lut || !tests)
497 return 0;
498
499 entry = lut->data;
500 for (i = 0; i < drm_color_lut_size(lut); i++) {
501 if (tests & DRM_COLOR_LUT_EQUAL_CHANNELS) {
502 if (entry[i].red != entry[i].blue ||
503 entry[i].red != entry[i].green) {
504 DRM_DEBUG_KMS("All LUT entries must have equal r/g/b\n");
505 return -EINVAL;
506 }
507 }
508
509 if (i > 0 && tests & DRM_COLOR_LUT_NON_DECREASING) {
510 if (entry[i].red < entry[i - 1].red ||
511 entry[i].green < entry[i - 1].green ||
512 entry[i].blue < entry[i - 1].blue) {
513 DRM_DEBUG_KMS("LUT entries must never decrease.\n");
514 return -EINVAL;
515 }
516 }
517 }
518
519 return 0;
520 }
521 EXPORT_SYMBOL(drm_color_lut_check);
522
