drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_color.c

   1 /*
   2  * Copyright 2018 Advanced Micro Devices, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: AMD
  23  *
  24  */
  25 #include "amdgpu.h"
  26 #include "amdgpu_mode.h"
  27 #include "amdgpu_dm.h"
  28 #include "dc.h"
  29 #include "modules/color/color_gamma.h"
  30 #include "basics/conversion.h"
  31
  32 /*
  33  * The DC interface to HW gives us the following color management blocks
  34  * per pipe (surface):
  35  *
  36  * - Input gamma LUT (de-normalized)
  37  * - Input CSC (normalized)
  38  * - Surface degamma LUT (normalized)
  39  * - Surface CSC (normalized)
  40  * - Surface regamma LUT (normalized)
  41  * - Output CSC (normalized)
  42  *
  43  * But these aren't a direct mapping to DRM color properties. The current DRM
  44  * interface exposes CRTC degamma, CRTC CTM and CRTC regamma while our hardware
  45  * is essentially giving:
  46  *
  47  * Plane CTM -> Plane degamma -> Plane CTM -> Plane regamma -> Plane CTM
  48  *
  49  * The input gamma LUT block isn't really applicable here since it operates
  50  * on the actual input data itself rather than the HW fp representation. The
  51  * input and output CSC blocks are technically available to use as part of
  52  * the DC interface but are typically used internally by DC for conversions
  53  * between color spaces. These could be blended together with user
  54  * adjustments in the future but for now these should remain untouched.
  55  *
  56  * The pipe blending also happens after these blocks so we don't actually
  57  * support any CRTC props with correct blending with multiple planes - but we
  58  * can still support CRTC color management properties in DM in most single
  59  * plane cases correctly with clever management of the DC interface in DM.
  60  *
  61  * As per DRM documentation, blocks should be in hardware bypass when their
  62  * respective property is set to NULL. A linear DGM/RGM LUT should also
  63  * considered as putting the respective block into bypass mode.
  64  *
  65  * This means that the following
  66  * configuration is assumed to be the default:
  67  *
  68  * Plane DGM Bypass -> Plane CTM Bypass -> Plane RGM Bypass -> ...
  69  * CRTC DGM Bypass -> CRTC CTM Bypass -> CRTC RGM Bypass
  70  */
  71
  72 #define MAX_DRM_LUT_VALUE 0xFFFF
  73
  74 /*
  75  * Initialize the color module.
  76  *
  77  * We're not using the full color module, only certain components.
  78  * Only call setup functions for components that we need.
  79  */
  80 void amdgpu_dm_init_color_mod(void)
  81 {
  82         setup_x_points_distribution();
  83 }
  84
  85 /* Extracts the DRM lut and lut size from a blob. */
  86 static const struct drm_color_lut *
  87 __extract_blob_lut(const struct drm_property_blob *blob, uint32_t *size)
  88 {
  89         *size = blob ? drm_color_lut_size(blob) : 0;
  90         return blob ? (struct drm_color_lut *)blob->data : NULL;
  91 }
  92
  93 /*
  94  * Return true if the given lut is a linear mapping of values, i.e. it acts
  95  * like a bypass LUT.
  96  *
  97  * It is considered linear if the lut represents:
  98  * f(a) = (0xFF00/MAX_COLOR_LUT_ENTRIES-1)a; for integer a in
  99  *                                           [0, MAX_COLOR_LUT_ENTRIES)
 100  */
 101 static bool __is_lut_linear(const struct drm_color_lut *lut, uint32_t size)
 102 {
 103         int i;
 104         uint32_t expected;
 105         int delta;
 106
 107         for (i = 0; i < size; i++) {
 108                 /* All color values should equal */
 109                 if ((lut[i].red != lut[i].green) || (lut[i].green != lut[i].blue))
 110                         return false;
 111
 112                 expected = i * MAX_DRM_LUT_VALUE / (size-1);
 113
 114                 /* Allow a +/-1 error. */
 115                 delta = lut[i].red - expected;
 116                 if (delta < -1 || 1 < delta)
 117                         return false;
 118         }
 119         return true;
 120 }
 121
 122 /**
 123  * Convert the drm_color_lut to dc_gamma. The conversion depends on the size
 124  * of the lut - whether or not it's legacy.
 125  */
 126 static void __drm_lut_to_dc_gamma(const struct drm_color_lut *lut,
 127                                   struct dc_gamma *gamma, bool is_legacy)
 128 {
 129         uint32_t r, g, b;
 130         int i;
 131
 132         if (is_legacy) {
 133                 for (i = 0; i < MAX_COLOR_LEGACY_LUT_ENTRIES; i++) {
 134                         r = drm_color_lut_extract(lut[i].red, 16);
 135                         g = drm_color_lut_extract(lut[i].green, 16);
 136                         b = drm_color_lut_extract(lut[i].blue, 16);
 137
 138                         gamma->entries.red[i] = dc_fixpt_from_int(r);
 139                         gamma->entries.green[i] = dc_fixpt_from_int(g);
 140                         gamma->entries.blue[i] = dc_fixpt_from_int(b);
 141                 }
 142                 return;
 143         }
 144
 145         /* else */
 146         for (i = 0; i < MAX_COLOR_LUT_ENTRIES; i++) {
 147                 r = drm_color_lut_extract(lut[i].red, 16);
 148                 g = drm_color_lut_extract(lut[i].green, 16);
 149                 b = drm_color_lut_extract(lut[i].blue, 16);
 150
 151                 gamma->entries.red[i] = dc_fixpt_from_fraction(r, MAX_DRM_LUT_VALUE);
 152                 gamma->entries.green[i] = dc_fixpt_from_fraction(g, MAX_DRM_LUT_VALUE);
 153                 gamma->entries.blue[i] = dc_fixpt_from_fraction(b, MAX_DRM_LUT_VALUE);
 154         }
 155 }
 156
 157 /*
 158  * Converts a DRM CTM to a DC CSC float matrix.
 159  * The matrix needs to be a 3x4 (12 entry) matrix.
 160  */
 161 static void __drm_ctm_to_dc_matrix(const struct drm_color_ctm *ctm,
 162                                    struct fixed31_32 *matrix)
 163 {
 164         int64_t val;
 165         int i;
 166
 167         /*
 168          * DRM gives a 3x3 matrix, but DC wants 3x4. Assuming we're operating
 169          * with homogeneous coordinates, augment the matrix with 0's.
 170          *
 171          * The format provided is S31.32, using signed-magnitude representation.
 172          * Our fixed31_32 is also S31.32, but is using 2's complement. We have
 173          * to convert from signed-magnitude to 2's complement.
 174          */
 175         for (i = 0; i < 12; i++) {
 176                 /* Skip 4th element */
 177                 if (i % 4 == 3) {
 178                         matrix[i] = dc_fixpt_zero;
 179                         continue;
 180                 }
 181
 182                 /* gamut_remap_matrix[i] = ctm[i - floor(i/4)] */
 183                 val = ctm->matrix[i - (i / 4)];
 184                 /* If negative, convert to 2's complement. */
 185                 if (val & (1ULL << 63))
 186                         val = -(val & ~(1ULL << 63));
 187
 188                 matrix[i].value = val;
 189         }
 190 }
 191
 192 /* Calculates the legacy transfer function - only for sRGB input space. */
 193 static int __set_legacy_tf(struct dc_transfer_func *func,
 194                            const struct drm_color_lut *lut, uint32_t lut_size,
 195                            bool has_rom)
 196 {
 197         struct dc_gamma *gamma = NULL;
 198         struct calculate_buffer cal_buffer = {0};
 199         bool res;
 200
 201         ASSERT(lut && lut_size == MAX_COLOR_LEGACY_LUT_ENTRIES);
 202
 203         cal_buffer.buffer_index = -1;
 204
 205         gamma = dc_create_gamma();
 206         if (!gamma)
 207                 return -ENOMEM;
 208
 209         gamma->type = GAMMA_RGB_256;
 210         gamma->num_entries = lut_size;
 211         __drm_lut_to_dc_gamma(lut, gamma, true);
 212
 213         res = mod_color_calculate_regamma_params(func, gamma, true, has_rom,
 214                                                  NULL, &cal_buffer);
 215
 216         dc_gamma_release(&gamma);
 217
 218         return res ? 0 : -ENOMEM;
 219 }
 220
 221 /* Calculates the output transfer function based on expected input space. */
 222 static int __set_output_tf(struct dc_transfer_func *func,
 223                            const struct drm_color_lut *lut, uint32_t lut_size,
 224                            bool has_rom)
 225 {
 226         struct dc_gamma *gamma = NULL;
 227         struct calculate_buffer cal_buffer = {0};
 228         bool res;
 229
 230         ASSERT(lut && lut_size == MAX_COLOR_LUT_ENTRIES);
 231
 232         cal_buffer.buffer_index = -1;
 233
 234         gamma = dc_create_gamma();
 235         if (!gamma)
 236                 return -ENOMEM;
 237
 238         gamma->num_entries = lut_size;
 239         __drm_lut_to_dc_gamma(lut, gamma, false);
 240
 241         if (func->tf == TRANSFER_FUNCTION_LINEAR) {
 242                 /*
 243                  * Color module doesn't like calculating regamma params
 244                  * on top of a linear input. But degamma params can be used
 245                  * instead to simulate this.
 246                  */
 247                 gamma->type = GAMMA_CUSTOM;
 248                 res = mod_color_calculate_degamma_params(NULL, func,
 249                                                         gamma, true);
 250         } else {
 251                 /*
 252                  * Assume sRGB. The actual mapping will depend on whether the
 253                  * input was legacy or not.
 254                  */
 255                 gamma->type = GAMMA_CS_TFM_1D;
 256                 res = mod_color_calculate_regamma_params(func, gamma, false,
 257                                                          has_rom, NULL, &cal_buffer);
 258         }
 259
 260         dc_gamma_release(&gamma);
 261
 262         return res ? 0 : -ENOMEM;
 263 }
 264
 265 /* Caculates the input transfer function based on expected input space. */
 266 static int __set_input_tf(struct dc_transfer_func *func,
 267                           const struct drm_color_lut *lut, uint32_t lut_size)
 268 {
 269         struct dc_gamma *gamma = NULL;
 270         bool res;
 271
 272         gamma = dc_create_gamma();
 273         if (!gamma)
 274                 return -ENOMEM;
 275
 276         gamma->type = GAMMA_CUSTOM;
 277         gamma->num_entries = lut_size;
 278
 279         __drm_lut_to_dc_gamma(lut, gamma, false);
 280
 281         res = mod_color_calculate_degamma_params(NULL, func, gamma, true);
 282         dc_gamma_release(&gamma);
 283
 284         return res ? 0 : -ENOMEM;
 285 }
 286
 287 /**
 288  * amdgpu_dm_update_crtc_color_mgmt: Maps DRM color management to DC stream.
 289  * @crtc: amdgpu_dm crtc state
 290  *
 291  * With no plane level color management properties we're free to use any
 292  * of the HW blocks as long as the CRTC CTM always comes before the
 293  * CRTC RGM and after the CRTC DGM.
 294  *
 295  * The CRTC RGM block will be placed in the RGM LUT block if it is non-linear.
 296  * The CRTC DGM block will be placed in the DGM LUT block if it is non-linear.
 297  * The CRTC CTM will be placed in the gamut remap block if it is non-linear.
 298  *
 299  * The RGM block is typically more fully featured and accurate across
 300  * all ASICs - DCE can't support a custom non-linear CRTC DGM.
 301  *
 302  * For supporting both plane level color management and CRTC level color
 303  * management at once we have to either restrict the usage of CRTC properties
 304  * or blend adjustments together.
 305  *
 306  * Returns 0 on success.
 307  */
 308 int amdgpu_dm_update_crtc_color_mgmt(struct dm_crtc_state *crtc)
 309 {
 310         struct dc_stream_state *stream = crtc->stream;
 311         struct amdgpu_device *adev = drm_to_adev(crtc->base.state->dev);
 312         bool has_rom = adev->asic_type <= CHIP_RAVEN;
 313         struct drm_color_ctm *ctm = NULL;
 314         const struct drm_color_lut *degamma_lut, *regamma_lut;
 315         uint32_t degamma_size, regamma_size;
 316         bool has_regamma, has_degamma;
 317         bool is_legacy;
 318         int r;
 319
 320         degamma_lut = __extract_blob_lut(crtc->base.degamma_lut, &degamma_size);
 321         if (degamma_lut && degamma_size != MAX_COLOR_LUT_ENTRIES)
 322                 return -EINVAL;
 323
 324         regamma_lut = __extract_blob_lut(crtc->base.gamma_lut, &regamma_size);
 325         if (regamma_lut && regamma_size != MAX_COLOR_LUT_ENTRIES &&
 326             regamma_size != MAX_COLOR_LEGACY_LUT_ENTRIES)
 327                 return -EINVAL;
 328
 329         has_degamma =
 330                 degamma_lut && !__is_lut_linear(degamma_lut, degamma_size);
 331
 332         has_regamma =
 333                 regamma_lut && !__is_lut_linear(regamma_lut, regamma_size);
 334
 335         is_legacy = regamma_size == MAX_COLOR_LEGACY_LUT_ENTRIES;
 336
 337         /* Reset all adjustments. */
 338         crtc->cm_has_degamma = false;
 339         crtc->cm_is_degamma_srgb = false;
 340
 341         /* Setup regamma and degamma. */
 342         if (is_legacy) {
 343                 /*
 344                  * Legacy regamma forces us to use the sRGB RGM as a base.
 345                  * This also means we can't use linear DGM since DGM needs
 346                  * to use sRGB as a base as well, resulting in incorrect CRTC
 347                  * DGM and CRTC CTM.
 348                  *
 349                  * TODO: Just map this to the standard regamma interface
 350                  * instead since this isn't really right. One of the cases
 351                  * where this setup currently fails is trying to do an
 352                  * inverse color ramp in legacy userspace.
 353                  */
 354                 crtc->cm_is_degamma_srgb = true;
 355                 stream->out_transfer_func->type = TF_TYPE_DISTRIBUTED_POINTS;
 356                 stream->out_transfer_func->tf = TRANSFER_FUNCTION_SRGB;
 357
 358                 r = __set_legacy_tf(stream->out_transfer_func, regamma_lut,
 359                                     regamma_size, has_rom);
 360                 if (r)
 361                         return r;
 362         } else if (has_regamma) {
 363                 /* CRTC RGM goes into RGM LUT. */
 364                 stream->out_transfer_func->type = TF_TYPE_DISTRIBUTED_POINTS;
 365                 stream->out_transfer_func->tf = TRANSFER_FUNCTION_LINEAR;
 366
 367                 r = __set_output_tf(stream->out_transfer_func, regamma_lut,
 368                                     regamma_size, has_rom);
 369                 if (r)
 370                         return r;
 371         } else {
 372                 /*
 373                  * No CRTC RGM means we can just put the block into bypass
 374                  * since we don't have any plane level adjustments using it.
 375                  */
 376                 stream->out_transfer_func->type = TF_TYPE_BYPASS;
 377                 stream->out_transfer_func->tf = TRANSFER_FUNCTION_LINEAR;
 378         }
 379
 380         /*
 381          * CRTC DGM goes into DGM LUT. It would be nice to place it
 382          * into the RGM since it's a more featured block but we'd
 383          * have to place the CTM in the OCSC in that case.
 384          */
 385         crtc->cm_has_degamma = has_degamma;
 386
 387         /* Setup CRTC CTM. */
 388         if (crtc->base.ctm) {
 389                 ctm = (struct drm_color_ctm *)crtc->base.ctm->data;
 390
 391                 /*
 392                  * Gamut remapping must be used for gamma correction
 393                  * since it comes before the regamma correction.
 394                  *
 395                  * OCSC could be used for gamma correction, but we'd need to
 396                  * blend the adjustments together with the required output
 397                  * conversion matrix - so just use the gamut remap block
 398                  * for now.
 399                  */
 400                 __drm_ctm_to_dc_matrix(ctm, stream->gamut_remap_matrix.matrix);
 401
 402                 stream->gamut_remap_matrix.enable_remap = true;
 403                 stream->csc_color_matrix.enable_adjustment = false;
 404         } else {
 405                 /* Bypass CTM. */
 406                 stream->gamut_remap_matrix.enable_remap = false;
 407                 stream->csc_color_matrix.enable_adjustment = false;
 408         }
 409
 410         return 0;
 411 }
 412
 413 /**
 414  * amdgpu_dm_update_plane_color_mgmt: Maps DRM color management to DC plane.
 415  * @crtc: amdgpu_dm crtc state
 416  * @ dc_plane_state: target DC surface
 417  *
 418  * Update the underlying dc_stream_state's input transfer function (ITF) in
 419  * preparation for hardware commit. The transfer function used depends on
 420  * the prepartion done on the stream for color management.
 421  *
 422  * Returns 0 on success.
 423  */
 424 int amdgpu_dm_update_plane_color_mgmt(struct dm_crtc_state *crtc,
 425                                       struct dc_plane_state *dc_plane_state)
 426 {
 427         const struct drm_color_lut *degamma_lut;
 428         enum dc_transfer_func_predefined tf = TRANSFER_FUNCTION_SRGB;
 429         uint32_t degamma_size;
 430         int r;
 431
 432         /* Get the correct base transfer function for implicit degamma. */
 433         switch (dc_plane_state->format) {
 434         case SURFACE_PIXEL_FORMAT_VIDEO_420_YCbCr:
 435         case SURFACE_PIXEL_FORMAT_VIDEO_420_YCrCb:
 436                 /* DC doesn't have a transfer function for BT601 specifically. */
 437                 tf = TRANSFER_FUNCTION_BT709;
 438                 break;
 439         default:
 440                 break;
 441         }
 442
 443         if (crtc->cm_has_degamma) {
 444                 degamma_lut = __extract_blob_lut(crtc->base.degamma_lut,
 445                                                  &degamma_size);
 446                 ASSERT(degamma_size == MAX_COLOR_LUT_ENTRIES);
 447
 448                 dc_plane_state->in_transfer_func->type =
 449                         TF_TYPE_DISTRIBUTED_POINTS;
 450
 451                 /*
 452                  * This case isn't fully correct, but also fairly
 453                  * uncommon. This is userspace trying to use a
 454                  * legacy gamma LUT + atomic degamma LUT
 455                  * at the same time.
 456                  *
 457                  * Legacy gamma requires the input to be in linear
 458                  * space, so that means we need to apply an sRGB
 459                  * degamma. But color module also doesn't support
 460                  * a user ramp in this case so the degamma will
 461                  * be lost.
 462                  *
 463                  * Even if we did support it, it's still not right:
 464                  *
 465                  * Input -> CRTC DGM -> sRGB DGM -> CRTC CTM ->
 466                  * sRGB RGM -> CRTC RGM -> Output
 467                  *
 468                  * The CSC will be done in the wrong space since
 469                  * we're applying an sRGB DGM on top of the CRTC
 470                  * DGM.
 471                  *
 472                  * TODO: Don't use the legacy gamma interface and just
 473                  * map these to the atomic one instead.
 474                  */
 475                 if (crtc->cm_is_degamma_srgb)
 476                         dc_plane_state->in_transfer_func->tf = tf;
 477                 else
 478                         dc_plane_state->in_transfer_func->tf =
 479                                 TRANSFER_FUNCTION_LINEAR;
 480
 481                 r = __set_input_tf(dc_plane_state->in_transfer_func,
 482                                    degamma_lut, degamma_size);
 483                 if (r)
 484                         return r;
 485         } else if (crtc->cm_is_degamma_srgb) {
 486                 /*
 487                  * For legacy gamma support we need the regamma input
 488                  * in linear space. Assume that the input is sRGB.
 489                  */
 490                 dc_plane_state->in_transfer_func->type = TF_TYPE_PREDEFINED;
 491                 dc_plane_state->in_transfer_func->tf = tf;
 492
 493                 if (tf != TRANSFER_FUNCTION_SRGB &&
 494                     !mod_color_calculate_degamma_params(NULL,
 495                             dc_plane_state->in_transfer_func, NULL, false))
 496                         return -ENOMEM;
 497         } else {
 498                 /* ...Otherwise we can just bypass the DGM block. */
 499                 dc_plane_state->in_transfer_func->type = TF_TYPE_BYPASS;
 500                 dc_plane_state->in_transfer_func->tf = TRANSFER_FUNCTION_LINEAR;
 501         }
 502
 503         return 0;
 504 }