drivers/gpu/drm/amd/display/dc/dce/dce_ipp.c

   1 /*
   2  * Copyright 2017 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
  26 #include <linux/slab.h>
  27
  28 #include "dce_ipp.h"
  29 #include "reg_helper.h"
  30 #include "dm_services.h"
  31
  32 #define REG(reg) \
  33         (ipp_dce->regs->reg)
  34
  35 #undef FN
  36 #define FN(reg_name, field_name) \
  37         ipp_dce->ipp_shift->field_name, ipp_dce->ipp_mask->field_name
  38
  39 #define CTX \
  40         ipp_dce->base.ctx
  41
  42
  43 static void dce_ipp_cursor_set_position(
  44         struct input_pixel_processor *ipp,
  45         const struct dc_cursor_position *position,
  46         const struct dc_cursor_mi_param *param)
  47 {
  48         struct dce_ipp *ipp_dce = TO_DCE_IPP(ipp);
  49
  50         /* lock cursor registers */
  51         REG_UPDATE(CUR_UPDATE, CURSOR_UPDATE_LOCK, true);
  52
  53         /* Flag passed in structure differentiates cursor enable/disable. */
  54         /* Update if it differs from cached state. */
  55         REG_UPDATE(CUR_CONTROL, CURSOR_EN, position->enable);
  56
  57         REG_SET_2(CUR_POSITION, 0,
  58                 CURSOR_X_POSITION, position->x,
  59                 CURSOR_Y_POSITION, position->y);
  60
  61         REG_SET_2(CUR_HOT_SPOT, 0,
  62                 CURSOR_HOT_SPOT_X, position->x_hotspot,
  63                 CURSOR_HOT_SPOT_Y, position->y_hotspot);
  64
  65         /* unlock cursor registers */
  66         REG_UPDATE(CUR_UPDATE, CURSOR_UPDATE_LOCK, false);
  67 }
  68
  69 static void dce_ipp_cursor_set_attributes(
  70         struct input_pixel_processor *ipp,
  71         const struct dc_cursor_attributes *attributes)
  72 {
  73         struct dce_ipp *ipp_dce = TO_DCE_IPP(ipp);
  74         int mode;
  75
  76         /* Lock cursor registers */
  77         REG_UPDATE(CUR_UPDATE, CURSOR_UPDATE_LOCK, true);
  78
  79         /* Program cursor control */
  80         switch (attributes->color_format) {
  81         case CURSOR_MODE_MONO:
  82                 mode = 0;
  83                 break;
  84         case CURSOR_MODE_COLOR_1BIT_AND:
  85                 mode = 1;
  86                 break;
  87         case CURSOR_MODE_COLOR_PRE_MULTIPLIED_ALPHA:
  88                 mode = 2;
  89                 break;
  90         case CURSOR_MODE_COLOR_UN_PRE_MULTIPLIED_ALPHA:
  91                 mode = 3;
  92                 break;
  93         default:
  94                 BREAK_TO_DEBUGGER(); /* unsupported */
  95                 mode = 0;
  96         }
  97
  98         REG_UPDATE_3(CUR_CONTROL,
  99                 CURSOR_MODE, mode,
 100                 CURSOR_2X_MAGNIFY, attributes->attribute_flags.bits.ENABLE_MAGNIFICATION,
 101                 CUR_INV_TRANS_CLAMP, attributes->attribute_flags.bits.INVERSE_TRANSPARENT_CLAMPING);
 102
 103         if (attributes->color_format == CURSOR_MODE_MONO) {
 104                 REG_SET_3(CUR_COLOR1, 0,
 105                         CUR_COLOR1_BLUE, 0,
 106                         CUR_COLOR1_GREEN, 0,
 107                         CUR_COLOR1_RED, 0);
 108
 109                 REG_SET_3(CUR_COLOR2, 0,
 110                         CUR_COLOR2_BLUE, 0xff,
 111                         CUR_COLOR2_GREEN, 0xff,
 112                         CUR_COLOR2_RED, 0xff);
 113         }
 114
 115         /*
 116          * Program cursor size -- NOTE: HW spec specifies that HW register
 117          * stores size as (height - 1, width - 1)
 118          */
 119         REG_SET_2(CUR_SIZE, 0,
 120                 CURSOR_WIDTH, attributes->width-1,
 121                 CURSOR_HEIGHT, attributes->height-1);
 122
 123         /* Program cursor surface address */
 124         /* SURFACE_ADDRESS_HIGH: Higher order bits (39:32) of hardware cursor
 125          * surface base address in byte. It is 4K byte aligned.
 126          * The correct way to program cursor surface address is to first write
 127          * to CUR_SURFACE_ADDRESS_HIGH, and then write to CUR_SURFACE_ADDRESS
 128          */
 129         REG_SET(CUR_SURFACE_ADDRESS_HIGH, 0,
 130                 CURSOR_SURFACE_ADDRESS_HIGH, attributes->address.high_part);
 131
 132         REG_SET(CUR_SURFACE_ADDRESS, 0,
 133                 CURSOR_SURFACE_ADDRESS, attributes->address.low_part);
 134
 135         /* Unlock Cursor registers. */
 136         REG_UPDATE(CUR_UPDATE, CURSOR_UPDATE_LOCK, false);
 137 }
 138
 139
 140 static void dce_ipp_program_prescale(struct input_pixel_processor *ipp,
 141                                      struct ipp_prescale_params *params)
 142 {
 143         struct dce_ipp *ipp_dce = TO_DCE_IPP(ipp);
 144
 145         /* set to bypass mode first before change */
 146         REG_UPDATE(PRESCALE_GRPH_CONTROL,
 147                    GRPH_PRESCALE_BYPASS, 1);
 148
 149         REG_SET_2(PRESCALE_VALUES_GRPH_R, 0,
 150                   GRPH_PRESCALE_SCALE_R, params->scale,
 151                   GRPH_PRESCALE_BIAS_R, params->bias);
 152
 153         REG_SET_2(PRESCALE_VALUES_GRPH_G, 0,
 154                   GRPH_PRESCALE_SCALE_G, params->scale,
 155                   GRPH_PRESCALE_BIAS_G, params->bias);
 156
 157         REG_SET_2(PRESCALE_VALUES_GRPH_B, 0,
 158                   GRPH_PRESCALE_SCALE_B, params->scale,
 159                   GRPH_PRESCALE_BIAS_B, params->bias);
 160
 161         if (params->mode != IPP_PRESCALE_MODE_BYPASS) {
 162                 REG_UPDATE(PRESCALE_GRPH_CONTROL,
 163                            GRPH_PRESCALE_BYPASS, 0);
 164
 165                 /* If prescale is in use, then legacy lut should be bypassed */
 166                 REG_UPDATE(INPUT_GAMMA_CONTROL,
 167                            GRPH_INPUT_GAMMA_MODE, 1);
 168         }
 169 }
 170
 171 static void dce_ipp_program_input_lut(
 172         struct input_pixel_processor *ipp,
 173         const struct dc_gamma *gamma)
 174 {
 175         int i;
 176         struct dce_ipp *ipp_dce = TO_DCE_IPP(ipp);
 177
 178         /* power on LUT memory */
 179         if (REG(DCFE_MEM_PWR_CTRL))
 180                 REG_SET(DCFE_MEM_PWR_CTRL, 0, DCP_LUT_MEM_PWR_DIS, 1);
 181
 182         /* enable all */
 183         REG_SET(DC_LUT_WRITE_EN_MASK, 0, DC_LUT_WRITE_EN_MASK, 0x7);
 184
 185         /* 256 entry mode */
 186         REG_UPDATE(DC_LUT_RW_MODE, DC_LUT_RW_MODE, 0);
 187
 188         /* LUT-256, unsigned, integer, new u0.12 format */
 189         REG_SET_3(DC_LUT_CONTROL, 0,
 190                 DC_LUT_DATA_R_FORMAT, 3,
 191                 DC_LUT_DATA_G_FORMAT, 3,
 192                 DC_LUT_DATA_B_FORMAT, 3);
 193
 194         /* start from index 0 */
 195         REG_SET(DC_LUT_RW_INDEX, 0,
 196                 DC_LUT_RW_INDEX, 0);
 197
 198         for (i = 0; i < gamma->num_entries; i++) {
 199                 REG_SET(DC_LUT_SEQ_COLOR, 0, DC_LUT_SEQ_COLOR,
 200                                 dc_fixpt_round(
 201                                         gamma->entries.red[i]));
 202                 REG_SET(DC_LUT_SEQ_COLOR, 0, DC_LUT_SEQ_COLOR,
 203                                 dc_fixpt_round(
 204                                         gamma->entries.green[i]));
 205                 REG_SET(DC_LUT_SEQ_COLOR, 0, DC_LUT_SEQ_COLOR,
 206                                 dc_fixpt_round(
 207                                         gamma->entries.blue[i]));
 208         }
 209
 210         /* power off LUT memory */
 211         if (REG(DCFE_MEM_PWR_CTRL))
 212                 REG_SET(DCFE_MEM_PWR_CTRL, 0, DCP_LUT_MEM_PWR_DIS, 0);
 213
 214         /* bypass prescale, enable legacy LUT */
 215         REG_UPDATE(PRESCALE_GRPH_CONTROL, GRPH_PRESCALE_BYPASS, 1);
 216         REG_UPDATE(INPUT_GAMMA_CONTROL, GRPH_INPUT_GAMMA_MODE, 0);
 217 }
 218
 219 static void dce_ipp_set_degamma(
 220         struct input_pixel_processor *ipp,
 221         enum ipp_degamma_mode mode)
 222 {
 223         struct dce_ipp *ipp_dce = TO_DCE_IPP(ipp);
 224         uint32_t degamma_type = (mode == IPP_DEGAMMA_MODE_HW_sRGB) ? 1 : 0;
 225
 226         ASSERT(mode == IPP_DEGAMMA_MODE_BYPASS || mode == IPP_DEGAMMA_MODE_HW_sRGB);
 227
 228         REG_SET_3(DEGAMMA_CONTROL, 0,
 229                   GRPH_DEGAMMA_MODE, degamma_type,
 230                   CURSOR_DEGAMMA_MODE, degamma_type,
 231                   CURSOR2_DEGAMMA_MODE, degamma_type);
 232 }
 233
 234 static const struct ipp_funcs dce_ipp_funcs = {
 235         .ipp_cursor_set_attributes = dce_ipp_cursor_set_attributes,
 236         .ipp_cursor_set_position = dce_ipp_cursor_set_position,
 237         .ipp_program_prescale = dce_ipp_program_prescale,
 238         .ipp_program_input_lut = dce_ipp_program_input_lut,
 239         .ipp_set_degamma = dce_ipp_set_degamma
 240 };
 241
 242 /*****************************************/
 243 /* Constructor, Destructor               */
 244 /*****************************************/
 245
 246 void dce_ipp_construct(
 247         struct dce_ipp *ipp_dce,
 248         struct dc_context *ctx,
 249         int inst,
 250         const struct dce_ipp_registers *regs,
 251         const struct dce_ipp_shift *ipp_shift,
 252         const struct dce_ipp_mask *ipp_mask)
 253 {
 254         ipp_dce->base.ctx = ctx;
 255         ipp_dce->base.inst = inst;
 256         ipp_dce->base.funcs = &dce_ipp_funcs;
 257
 258         ipp_dce->regs = regs;
 259         ipp_dce->ipp_shift = ipp_shift;
 260         ipp_dce->ipp_mask = ipp_mask;
 261 }
 262
 263 void dce_ipp_destroy(struct input_pixel_processor **ipp)
 264 {
 265         kfree(TO_DCE_IPP(*ipp));
 266         *ipp = NULL;
 267 }