Home | History | Annotate | Download | only in drm 
      1 /*
      2 * Copyright (c) 2017, The Linux Foundation. All rights reserved.
      3 *
      4 * Redistribution and use in source and binary forms, with or without
      5 * modification, are permitted provided that the following conditions are
      6 * met:
      7 *     * Redistributions of source code must retain the above copyright
      8 *       notice, this list of conditions and the following disclaimer.
      9 *     * Redistributions in binary form must reproduce the above
     10 *       copyright notice, this list of conditions and the following
     11 *       disclaimer in the documentation and/or other materials provided
     12 *       with the distribution.
     13 *     * Neither the name of The Linux Foundation nor the names of its
     14 *       contributors may be used to endorse or promote products derived
     15 *       from this software without specific prior written permission.
     16 *
     17 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
     18 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
     20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
     21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
     24 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     25 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
     26 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
     27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     28 */
     29 
     30 #define __CLASS__ "HWColorManagerDRM"
     31 
     32 #ifdef PP_DRM_ENABLE
     33 #include <drm/msm_drm_pp.h>
     34 #endif
     35 #include <utils/debug.h>
     36 #include "hw_color_manager_drm.h"
     37 
     38 using sde_drm::kFeaturePcc;
     39 using sde_drm::kFeatureIgc;
     40 using sde_drm::kFeaturePgc;
     41 using sde_drm::kFeatureMixerGc;
     42 using sde_drm::kFeaturePaV2;
     43 using sde_drm::kFeatureDither;
     44 using sde_drm::kFeatureGamut;
     45 using sde_drm::kFeaturePADither;
     46 using sde_drm::kPPFeaturesMax;
     47 
     48 #ifdef PP_DRM_ENABLE
     49 static const uint32_t kPgcDataMask = 0x3FF;
     50 static const uint32_t kPgcShift = 16;
     51 #endif
     52 
     53 namespace sdm {
     54 
     55 DisplayError (*HWColorManagerDrm::GetDrmFeature[])(const PPFeatureInfo &, DRMPPFeatureInfo *) = {
     56         [kGlobalColorFeaturePcc] = &HWColorManagerDrm::GetDrmPCC,
     57         [kGlobalColorFeatureIgc] = &HWColorManagerDrm::GetDrmIGC,
     58         [kGlobalColorFeaturePgc] = &HWColorManagerDrm::GetDrmPGC,
     59         [kMixerColorFeatureGc] = &HWColorManagerDrm::GetDrmMixerGC,
     60         [kGlobalColorFeaturePaV2] = &HWColorManagerDrm::GetDrmPAV2,
     61         [kGlobalColorFeatureDither] = &HWColorManagerDrm::GetDrmDither,
     62         [kGlobalColorFeatureGamut] = &HWColorManagerDrm::GetDrmGamut,
     63         [kGlobalColorFeaturePADither] = &HWColorManagerDrm::GetDrmPADither,
     64 };
     65 
     66 void HWColorManagerDrm::FreeDrmFeatureData(DRMPPFeatureInfo *feature) {
     67   if (feature->payload)
     68     free(feature->payload);
     69 }
     70 
     71 uint32_t HWColorManagerDrm::GetFeatureVersion(const DRMPPFeatureInfo &feature) {
     72   uint32_t version = PPFeatureVersion::kSDEPpVersionInvalid;
     73 
     74   switch (feature.id) {
     75     case kFeaturePcc:
     76       break;
     77     case kFeatureIgc:
     78       break;
     79     case kFeaturePgc:
     80       if (feature.version == 1)
     81         version = PPFeatureVersion::kSDEPgcV17;
     82       break;
     83     case kFeatureMixerGc:
     84       break;
     85     case kFeaturePaV2:
     86       break;
     87     case kFeatureDither:
     88       break;
     89     case kFeatureGamut:
     90       if (feature.version == 1)
     91         version = PPFeatureVersion::kSDEGamutV17;
     92       else if (feature.version == 4)
     93         version = PPFeatureVersion::kSDEGamutV4;
     94       break;
     95     case kFeaturePADither:
     96       break;
     97     default:
     98       break;
     99   }
    100   return version;
    101 }
    102 
    103 DRMPPFeatureID HWColorManagerDrm::ToDrmFeatureId(uint32_t id) {
    104   DRMPPFeatureID ret = kPPFeaturesMax;
    105 
    106   switch (id) {
    107     case kGlobalColorFeaturePcc:
    108       ret = kFeaturePcc;
    109       break;
    110     case kGlobalColorFeatureIgc:
    111       ret = kFeatureIgc;
    112       break;
    113     case kGlobalColorFeaturePgc:
    114       ret = kFeaturePgc;
    115       break;
    116     case kMixerColorFeatureGc:
    117       ret = kFeatureMixerGc;
    118       break;
    119     case kGlobalColorFeaturePaV2:
    120       ret = kFeaturePaV2;
    121       break;
    122     case kGlobalColorFeatureDither:
    123       ret = kFeatureDither;
    124       break;
    125     case kGlobalColorFeatureGamut:
    126       ret = kFeatureGamut;
    127       break;
    128     case kGlobalColorFeaturePADither:
    129       ret = kFeaturePADither;
    130       break;
    131     default:
    132       break;
    133   }
    134   return ret;
    135 }
    136 
    137 DisplayError HWColorManagerDrm::GetDrmPCC(const PPFeatureInfo &in_data,
    138                                           DRMPPFeatureInfo *out_data) {
    139   DisplayError ret = kErrorNone;
    140   return ret;
    141 }
    142 
    143 DisplayError HWColorManagerDrm::GetDrmIGC(const PPFeatureInfo &in_data,
    144                                           DRMPPFeatureInfo *out_data) {
    145   DisplayError ret = kErrorNone;
    146   return ret;
    147 }
    148 
    149 DisplayError HWColorManagerDrm::GetDrmPGC(const PPFeatureInfo &in_data,
    150                                           DRMPPFeatureInfo *out_data) {
    151   DisplayError ret = kErrorNone;
    152 #ifdef PP_DRM_ENABLE
    153   struct SDEPgcLUTData *sde_pgc;
    154   struct drm_msm_pgc_lut *mdp_pgc;
    155 
    156   if (!out_data) {
    157     DLOGE("Invalid input parameter for gamut");
    158     return kErrorParameters;
    159   }
    160   sde_pgc = (struct SDEPgcLUTData *)in_data.GetConfigData();
    161   out_data->id = kFeaturePgc;
    162   out_data->type = sde_drm::kPropBlob;
    163   out_data->version = in_data.feature_version_;
    164   out_data->payload_size = sizeof(struct drm_msm_pgc_lut);
    165 
    166   if (in_data.enable_flags_ & kOpsDisable) {
    167     /* feature disable case */
    168     out_data->payload = NULL;
    169     return ret;
    170   } else if (!(in_data.enable_flags_ & kOpsEnable)) {
    171     out_data->payload = NULL;
    172     return kErrorParameters;
    173   }
    174 
    175   mdp_pgc = new drm_msm_pgc_lut();
    176   if (!mdp_pgc) {
    177     DLOGE("Failed to allocate memory for pgc");
    178     return kErrorMemory;
    179   }
    180 
    181   if (in_data.enable_flags_ & kOpsEnable)
    182     mdp_pgc->flags = PGC_8B_ROUND;
    183   else
    184     mdp_pgc->flags = 0;
    185 
    186   for (int i = 0, j = 0; i < PGC_TBL_LEN; i++, j += 2) {
    187     mdp_pgc->c0[i] = (sde_pgc->c0_data[j] & kPgcDataMask) |
    188         (sde_pgc->c0_data[j + 1] & kPgcDataMask) << kPgcShift;
    189     mdp_pgc->c1[i] = (sde_pgc->c1_data[j] & kPgcDataMask) |
    190         (sde_pgc->c1_data[j + 1] & kPgcDataMask) << kPgcShift;
    191     mdp_pgc->c2[i] = (sde_pgc->c2_data[j] & kPgcDataMask) |
    192         (sde_pgc->c2_data[j + 1] & kPgcDataMask) << kPgcShift;
    193   }
    194   out_data->payload = mdp_pgc;
    195 #endif
    196   return ret;
    197 }
    198 
    199 DisplayError HWColorManagerDrm::GetDrmMixerGC(const PPFeatureInfo &in_data,
    200                                               DRMPPFeatureInfo *out_data) {
    201   DisplayError ret = kErrorNone;
    202   return ret;
    203 }
    204 
    205 DisplayError HWColorManagerDrm::GetDrmPAV2(const PPFeatureInfo &in_data,
    206                                            DRMPPFeatureInfo *out_data) {
    207   DisplayError ret = kErrorNone;
    208   return ret;
    209 }
    210 
    211 DisplayError HWColorManagerDrm::GetDrmDither(const PPFeatureInfo &in_data,
    212                                              DRMPPFeatureInfo *out_data) {
    213   DisplayError ret = kErrorNone;
    214   return ret;
    215 }
    216 
    217 DisplayError HWColorManagerDrm::GetDrmGamut(const PPFeatureInfo &in_data,
    218                                             DRMPPFeatureInfo *out_data) {
    219   DisplayError ret = kErrorNone;
    220 #ifdef PP_DRM_ENABLE
    221   struct SDEGamutCfg *sde_gamut = NULL;
    222   struct drm_msm_3d_gamut *mdp_gamut = NULL;
    223   uint32_t size = 0;
    224 
    225   if (!out_data) {
    226     DLOGE("Invalid input parameter for gamut");
    227     return kErrorParameters;
    228   }
    229   sde_gamut = (struct SDEGamutCfg *)in_data.GetConfigData();
    230   out_data->id = kFeatureGamut;
    231   out_data->type = sde_drm::kPropBlob;
    232   out_data->version = in_data.feature_version_;
    233   out_data->payload_size = sizeof(struct drm_msm_3d_gamut);
    234   if (in_data.enable_flags_ & kOpsDisable) {
    235     /* feature disable case */
    236     out_data->payload = NULL;
    237     return ret;
    238   } else if (!(in_data.enable_flags_ & kOpsEnable)) {
    239     out_data->payload = NULL;
    240     return kErrorParameters;
    241   }
    242 
    243   mdp_gamut = new drm_msm_3d_gamut();
    244   if (!mdp_gamut) {
    245     DLOGE("Failed to allocate memory for gamut");
    246     return kErrorMemory;
    247   }
    248 
    249   if (sde_gamut->map_en)
    250     mdp_gamut->flags = GAMUT_3D_MAP_EN;
    251   else
    252     mdp_gamut->flags = 0;
    253 
    254   switch (sde_gamut->mode) {
    255     case SDEGamutCfgWrapper::GAMUT_FINE_MODE:
    256       mdp_gamut->mode = GAMUT_3D_MODE_17;
    257       size = GAMUT_3D_MODE17_TBL_SZ;
    258       break;
    259     case SDEGamutCfgWrapper::GAMUT_COARSE_MODE:
    260       mdp_gamut->mode = GAMUT_3D_MODE_5;
    261       size = GAMUT_3D_MODE5_TBL_SZ;
    262       break;
    263     case SDEGamutCfgWrapper::GAMUT_COARSE_MODE_13:
    264       mdp_gamut->mode = GAMUT_3D_MODE_13;
    265       size = GAMUT_3D_MODE13_TBL_SZ;
    266       break;
    267     default:
    268       DLOGE("Invalid gamut mode %d", sde_gamut->mode);
    269       free(mdp_gamut);
    270       return kErrorParameters;
    271   }
    272 
    273   if (sde_gamut->map_en)
    274     std::memcpy(mdp_gamut->scale_off, sde_gamut->scale_off_data,
    275                 sizeof(uint32_t) * GAMUT_3D_SCALE_OFF_SZ * GAMUT_3D_SCALE_OFF_TBL_NUM);
    276 
    277   for (uint32_t row = 0; row < GAMUT_3D_TBL_NUM; row++) {
    278     for (uint32_t col = 0; col < size; col++) {
    279       mdp_gamut->col[row][col].c0 = sde_gamut->c0_data[row][col];
    280       mdp_gamut->col[row][col].c2_c1 = sde_gamut->c1_c2_data[row][col];
    281     }
    282   }
    283   out_data->payload = mdp_gamut;
    284 #endif
    285   return ret;
    286 }
    287 
    288 DisplayError HWColorManagerDrm::GetDrmPADither(const PPFeatureInfo &in_data,
    289                                                DRMPPFeatureInfo *out_data) {
    290   DisplayError ret = kErrorNone;
    291   return ret;
    292 }
    293 
    294 }  // namespace sdm
    295