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 */ 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 */ 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 */ 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 */ 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(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 */ 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 */ 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 */ 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 */ 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 */ 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