Home | History | Annotate | Download | only in private 
      1 /* Copyright (c) 2015-2016, The Linux Foundataion. All rights reserved.
      2 *
      3 * Redistribution and use in source and binary forms, with or without
      4 * modification, are permitted provided that the following conditions are
      5 * met:
      6 *     * Redistributions of source code must retain the above copyright
      7 *       notice, this list of conditions and the following disclaimer.
      8 *     * Redistributions in binary form must reproduce the above
      9 *       copyright notice, this list of conditions and the following
     10 *       disclaimer in the documentation and/or other materials provided
     11 *       with the distribution.
     12 *     * Neither the name of The Linux Foundation nor the names of its
     13 *       contributors may be used to endorse or promote products derived
     14 *       from this software without specific prior written permission.
     15 *
     16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
     17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
     18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
     19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
     20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
     23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
     25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
     26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 *
     28 */
     29 
     30 #ifndef __COLOR_PARAMS_H__
     31 #define __COLOR_PARAMS_H__
     32 
     33 #include <stdio.h>
     34 #include <string.h>
     35 #include <utils/locker.h>
     36 #include <utils/constants.h>
     37 #include <core/sdm_types.h>
     38 #include <core/display_interface.h>
     39 #include "hw_info_types.h"
     40 
     41 namespace sdm {
     42 
     43 // Bitmap Pending action to indicate to the caller what's pending to be taken care of.
     44 enum PendingAction {
     45   kInvalidating = BITMAP(0),
     46   kApplySolidFill = BITMAP(1),
     47   kDisableSolidFill = BITMAP(2),
     48   kEnterQDCMMode = BITMAP(3),
     49   kExitQDCMMode = BITMAP(4),
     50   kSetPanelBrightness = BITMAP(5),
     51   kEnableFrameCapture = BITMAP(6),
     52   kDisableFrameCapture = BITMAP(7),
     53   kConfigureDetailedEnhancer = BITMAP(8),
     54   kGetDetailedEnhancerData = BITMAP(21),
     55   kNoAction = BITMAP(31),
     56 };
     57 
     58 // ENUM to identify different Postprocessing feature block to program.
     59 // Note: For each new entry added here, also need update hw_interface::GetPPFeaturesVersion<>
     60 // AND HWPrimary::SetPPFeatures<>.
     61 enum PPGlobalColorFeatureID {
     62   kGlobalColorFeaturePcc,
     63   kGlobalColorFeatureIgc,
     64   kGlobalColorFeaturePgc,
     65   kMixerColorFeatureGc,
     66   kGlobalColorFeaturePaV2,
     67   kGlobalColorFeatureDither,
     68   kGlobalColorFeatureGamut,
     69   kGlobalColorFeaturePADither,
     70   kMaxNumPPFeatures,
     71 };
     72 
     73 struct PPPendingParams {
     74   PendingAction action = kNoAction;
     75   void *params = NULL;
     76 };
     77 
     78 struct PPColorInfo {
     79   uint32_t r_bitdepth = 0;
     80   uint32_t r = 0;
     81   uint32_t g_bitdepth = 0;
     82   uint32_t g = 0;
     83   uint32_t b_bitdepth = 0;
     84   uint32_t b = 0;
     85 };
     86 
     87 struct PPColorFillParams {
     88   uint32_t flags = 0;
     89   struct {
     90     uint32_t width = 0;
     91     uint32_t height = 0;
     92     int32_t x = 0;
     93     int32_t y = 0;
     94   } rect;
     95 
     96   PPColorInfo color;
     97 };
     98 
     99 struct PPFeatureVersion {
    100   // SDE ASIC versioning its PP block at each specific feature level.
    101   static const uint32_t kSDEIgcV17 = 1;
    102   static const uint32_t kSDEPgcV17 = 5;
    103   static const uint32_t kSDEDitherV17 = 7;
    104   static const uint32_t kSDEGamutV17 = 9;
    105   static const uint32_t kSDEPaV17 = 11;
    106   static const uint32_t kSDEPccV17 = 13;
    107   static const uint32_t kSDELegacyPP = 15;
    108   static const uint32_t kSDEPADitherV17 = 16;
    109   static const uint32_t kSDEIgcV30 = 17;
    110 
    111   uint32_t version[kMaxNumPPFeatures];
    112   PPFeatureVersion() { memset(version, 0, sizeof(version)); }
    113 };
    114 
    115 struct PPHWAttributes : HWResourceInfo, HWPanelInfo, DisplayConfigVariableInfo {
    116   char panel_name[256] = "generic_panel";
    117   PPFeatureVersion version;
    118   int panel_max_brightness = 0;
    119 
    120   void Set(const HWResourceInfo &hw_res, const HWPanelInfo &panel_info,
    121            const DisplayConfigVariableInfo &attr, const PPFeatureVersion &feature_ver);
    122 };
    123 
    124 struct PPDisplayAPIPayload {
    125   bool own_payload = false;  // to indicate if *payload is owned by this or just a reference.
    126   uint32_t size = 0;
    127   uint8_t *payload = NULL;
    128 
    129   PPDisplayAPIPayload() = default;
    130   PPDisplayAPIPayload(uint32_t size, uint8_t *param)
    131       : size(size), payload(param) {}
    132 
    133   template <typename T>
    134   DisplayError CreatePayload(T *&output) {
    135     DisplayError ret = kErrorNone;
    136 
    137     payload = new uint8_t[sizeof(T)]();
    138     if (!payload) {
    139       ret = kErrorMemory;
    140       output = NULL;
    141     } else {
    142       this->size = sizeof(T);
    143       output = reinterpret_cast<T *>(payload);
    144       own_payload = true;
    145     }
    146     return ret;
    147   }
    148 
    149   DisplayError CreatePayloadBytes(uint32_t size_in_bytes, uint8_t **output) {
    150     DisplayError ret = kErrorNone;
    151 
    152     payload = new uint8_t[size_in_bytes]();
    153     if (!payload) {
    154       ret = kErrorMemory;
    155       *output = NULL;
    156     } else {
    157       this->size = size_in_bytes;
    158       *output = payload;
    159       own_payload = true;
    160     }
    161     return ret;
    162   }
    163 
    164   inline void DestroyPayload() {
    165     if (payload && own_payload) {
    166       delete[] payload;
    167       payload = NULL;
    168       size = 0;
    169     } else {
    170       payload = NULL;
    171       size = 0;
    172     }
    173   }
    174 };
    175 
    176 struct PPRectInfo {
    177   uint32_t width;
    178   uint32_t height;
    179   int32_t x;
    180   int32_t y;
    181 };
    182 
    183 typedef enum {
    184   PP_PIXEL_FORMAT_NONE = 0,
    185   PP_PIXEL_FORMAT_RGB_888,
    186   PP_PIXEL_FORMAT_RGB_2101010,
    187   PP_PIXEL_FORMAT_MAX,
    188   PP_PIXEL_FORMAT_FORCE32BIT = 0x7FFFFFFF,
    189 } PPPixelFormats;
    190 
    191 struct PPFrameCaptureInputParams {
    192   PPRectInfo rect;
    193   PPPixelFormats out_pix_format;
    194   uint32_t flags;
    195 };
    196 
    197 struct PPFrameCaptureData {
    198   PPFrameCaptureInputParams input_params;
    199   uint8_t *buffer;
    200   uint32_t buffer_stride;
    201   uint32_t buffer_size;
    202 };
    203 
    204 static const uint32_t kDeTuningFlagSharpFactor = 0x01;
    205 static const uint32_t kDeTuningFlagClip = 0x02;
    206 static const uint32_t kDeTuningFlagThrQuiet = 0x04;
    207 static const uint32_t kDeTuningFlagThrDieout = 0x08;
    208 static const uint32_t kDeTuningFlagThrLow = 0x10;
    209 static const uint32_t kDeTuningFlagThrHigh = 0x20;
    210 static const uint32_t kDeTuningFlagContentQualLevel = 0x40;
    211 
    212 typedef enum {
    213   kDeContentQualUnknown,
    214   kDeContentQualLow,
    215   kDeContentQualMedium,
    216   kDeContentQualHigh,
    217   kDeContentQualMax,
    218 } PPDEContentQualLevel;
    219 
    220 typedef enum {
    221   kDeContentTypeUnknown,
    222   kDeContentTypeVideo,
    223   kDeContentTypeGraphics,
    224   kDeContentTypeMax,
    225 } PPDEContentType;
    226 
    227 struct PPDETuningCfg {
    228   uint32_t flags = 0;
    229   int32_t sharp_factor = 0;
    230   uint16_t thr_quiet = 0;
    231   uint16_t thr_dieout = 0;
    232   uint16_t thr_low = 0;
    233   uint16_t thr_high = 0;
    234   uint16_t clip = 0;
    235   PPDEContentQualLevel quality = kDeContentQualUnknown;
    236   PPDEContentType content_type = kDeContentTypeUnknown;
    237 };
    238 
    239 struct PPDETuningCfgData {
    240   uint32_t cfg_en = 0;
    241   PPDETuningCfg params;
    242   bool cfg_pending = false;
    243 };
    244 
    245 struct SDEGamutCfg {
    246   static const int kGamutTableNum = 4;
    247   static const int kGamutScaleoffTableNum = 3;
    248   static const int kGamutTableSize = 1229;
    249   static const int kGamutTableCoarseSize = 32;
    250   static const int kGamutScaleoffSize = 16;
    251   uint32_t mode;
    252   uint32_t map_en;
    253   uint32_t tbl_size[kGamutTableNum];
    254   uint32_t *c0_data[kGamutTableNum];
    255   uint32_t *c1_c2_data[kGamutTableNum];
    256   uint32_t tbl_scale_off_sz[kGamutScaleoffTableNum];
    257   uint32_t *scale_off_data[kGamutScaleoffTableNum];
    258 };
    259 
    260 struct SDEPccCoeff {
    261   uint32_t c = 0;
    262   uint32_t r = 0;
    263   uint32_t g = 0;
    264   uint32_t b = 0;
    265   uint32_t rg = 0;
    266   uint32_t gb = 0;
    267   uint32_t rb = 0;
    268   uint32_t rgb = 0;
    269 };
    270 
    271 struct SDEPccCfg {
    272   SDEPccCoeff red;
    273   SDEPccCoeff green;
    274   SDEPccCoeff blue;
    275 
    276   static SDEPccCfg *Init(uint32_t arg __attribute__((__unused__)));
    277   SDEPccCfg *GetConfig() { return this; }
    278 };
    279 
    280 struct SDEDitherCfg {
    281   uint32_t g_y_depth;
    282   uint32_t r_cr_depth;
    283   uint32_t b_cb_depth;
    284   uint32_t length;
    285   uint32_t dither_matrix[16];
    286   uint32_t temporal_en;
    287 
    288   static SDEDitherCfg *Init(uint32_t arg __attribute__((__unused__)));
    289   SDEDitherCfg *GetConfig() { return this; }
    290 };
    291 
    292 struct SDEPADitherData {
    293   uint64_t data_flags;
    294   uint32_t matrix_size;
    295   uint64_t matrix_data_addr;
    296   uint32_t strength;
    297   uint32_t offset_en;
    298 };
    299 
    300 class SDEPADitherWrapper : private SDEPADitherData {
    301  public:
    302   static SDEPADitherWrapper *Init(uint32_t arg __attribute__((__unused__)));
    303   ~SDEPADitherWrapper() {
    304     if (buffer_)
    305       delete[] buffer_;
    306   }
    307   inline SDEPADitherData *GetConfig(void) { return this; }
    308 
    309  private:
    310   SDEPADitherWrapper() {}
    311   uint32_t *buffer_ = NULL;
    312 };
    313 
    314 struct SDEPaMemColorData {
    315   uint32_t adjust_p0 = 0;
    316   uint32_t adjust_p1 = 0;
    317   uint32_t adjust_p2 = 0;
    318   uint32_t blend_gain = 0;
    319   uint8_t sat_hold = 0;
    320   uint8_t val_hold = 0;
    321   uint32_t hue_region = 0;
    322   uint32_t sat_region = 0;
    323   uint32_t val_region = 0;
    324 };
    325 
    326 struct SDEPaData {
    327   static const int kSixZoneLUTSize = 384;
    328   uint32_t mode = 0;
    329   uint32_t hue_adj = 0;
    330   uint32_t sat_adj = 0;
    331   uint32_t val_adj = 0;
    332   uint32_t cont_adj;
    333   SDEPaMemColorData skin;
    334   SDEPaMemColorData sky;
    335   SDEPaMemColorData foliage;
    336   uint32_t six_zone_thresh = 0;
    337   uint32_t six_zone_adj_p0 = 0;
    338   uint32_t six_zone_adj_p1 = 0;
    339   uint8_t six_zone_sat_hold = 0;
    340   uint8_t six_zone_val_hold = 0;
    341   uint32_t six_zone_len = 0;
    342   uint32_t *six_zone_curve_p0 = NULL;
    343   uint32_t *six_zone_curve_p1 = NULL;
    344 };
    345 
    346 struct SDEIgcLUTData {
    347   static const int kMaxIgcLUTEntries = 256;
    348   uint32_t table_fmt = 0;
    349   uint32_t len = 0;
    350   uint32_t *c0_c1_data = NULL;
    351   uint32_t *c2_data = NULL;
    352 };
    353 
    354 struct SDEIgcV30LUTData {
    355   static const int kMaxIgcLUTEntries = 256;
    356   uint32_t table_fmt = 0;
    357   uint32_t len = 0;
    358   uint64_t c0_c1_data = 0;
    359   uint64_t c2_data = 0;
    360   uint32_t strength = 0;
    361 };
    362 
    363 struct SDEPgcLUTData {
    364   static const int kPgcLUTEntries = 1024;
    365   uint32_t len = 0;
    366   uint32_t *c0_data = NULL;
    367   uint32_t *c1_data = NULL;
    368   uint32_t *c2_data = NULL;
    369 };
    370 
    371 struct SDEDisplayMode {
    372   static const int kMaxModeNameSize = 256;
    373   int32_t id = -1;
    374   uint32_t type = 0;
    375   char name[kMaxModeNameSize] = {0};
    376 };
    377 
    378 // Wrapper on HW block config data structure to encapsulate the details of allocating
    379 // and destroying from the caller.
    380 class SDEGamutCfgWrapper : private SDEGamutCfg {
    381  public:
    382   enum GamutMode {
    383     GAMUT_FINE_MODE = 0x01,
    384     GAMUT_COARSE_MODE,
    385   };
    386 
    387   // This factory method will be used by libsdm-color.so data producer to be populated with
    388   // converted config values for SDE feature blocks.
    389   static SDEGamutCfgWrapper *Init(uint32_t arg);
    390 
    391   // Data consumer<Commit thread> will be responsible to destroy it once the feature is commited.
    392   ~SDEGamutCfgWrapper() {
    393     if (buffer_)
    394       delete[] buffer_;
    395   }
    396 
    397   // Data consumer will use this method to retrieve contained feature configuration.
    398   inline SDEGamutCfg *GetConfig(void) { return this; }
    399 
    400  private:
    401   SDEGamutCfgWrapper() {}
    402   uint32_t *buffer_ = NULL;
    403 };
    404 
    405 class SDEPaCfgWrapper : private SDEPaData {
    406  public:
    407   static SDEPaCfgWrapper *Init(uint32_t arg = 0);
    408   ~SDEPaCfgWrapper() {
    409     if (buffer_)
    410       delete[] buffer_;
    411   }
    412   inline SDEPaData *GetConfig(void) { return this; }
    413 
    414  private:
    415   SDEPaCfgWrapper() {}
    416   uint32_t *buffer_ = NULL;
    417 };
    418 
    419 class SDEIgcLUTWrapper : private SDEIgcLUTData {
    420  public:
    421   static SDEIgcLUTWrapper *Init(uint32_t arg __attribute__((__unused__)));
    422   ~SDEIgcLUTWrapper() {
    423     if (buffer_)
    424       delete[] buffer_;
    425   }
    426   inline SDEIgcLUTData *GetConfig(void) { return this; }
    427 
    428  private:
    429   SDEIgcLUTWrapper() {}
    430   uint32_t *buffer_ = NULL;
    431 };
    432 
    433 class SDEIgcV30LUTWrapper : private SDEIgcV30LUTData {
    434  public:
    435   static SDEIgcV30LUTWrapper *Init(uint32_t arg __attribute__((__unused__)));
    436   ~SDEIgcV30LUTWrapper() {
    437     if (buffer_)
    438       delete[] buffer_;
    439   }
    440   inline SDEIgcV30LUTData *GetConfig(void) { return this; }
    441 
    442  private:
    443   SDEIgcV30LUTWrapper(const SDEIgcV30LUTWrapper& src) { /* do not create copies */ }
    444   SDEIgcV30LUTWrapper& operator=(const SDEIgcV30LUTWrapper&) { return *this; }
    445   SDEIgcV30LUTWrapper() {}
    446   uint32_t *buffer_ = NULL;
    447 };
    448 
    449 class SDEPgcLUTWrapper : private SDEPgcLUTData {
    450  public:
    451   static SDEPgcLUTWrapper *Init(uint32_t arg __attribute__((__unused__)));
    452   ~SDEPgcLUTWrapper() {
    453     if (buffer_)
    454       delete[] buffer_;
    455   }
    456   inline SDEPgcLUTData *GetConfig(void) { return this; }
    457 
    458  private:
    459   SDEPgcLUTWrapper() {}
    460   uint32_t *buffer_ = NULL;
    461 };
    462 
    463 // Base Postprocessing features information.
    464 class PPFeatureInfo {
    465  public:
    466   uint32_t enable_flags_ = 0;  // bitmap to indicate subset of parameters enabling or not.
    467   uint32_t feature_version_ = 0;
    468   uint32_t feature_id_ = 0;
    469   uint32_t disp_id_ = 0;
    470   uint32_t pipe_id_ = 0;
    471 
    472   virtual ~PPFeatureInfo() {}
    473   virtual void *GetConfigData(void) const = 0;
    474 };
    475 
    476 // Individual Postprocessing feature representing physical attributes and information
    477 // This template class wrapping around abstract data type representing different
    478 // post-processing features. It will take output from ColorManager converting from raw metadata.
    479 // The configuration will directly pass into HWInterface to program the hardware accordingly.
    480 template <typename T>
    481 class TPPFeatureInfo : public PPFeatureInfo {
    482  public:
    483   virtual ~TPPFeatureInfo() {
    484     if (params_)
    485       delete params_;
    486   }
    487 
    488   // API for data consumer to get underlying data configs to program into pp hardware block.
    489   virtual void *GetConfigData(void) const { return params_->GetConfig(); }
    490 
    491   // API for data producer to get access to underlying data configs to populate it.
    492   T *GetParamsReference(void) { return params_; }
    493 
    494   // API for create this template object.
    495   static TPPFeatureInfo *Init(uint32_t arg = 0) {
    496     TPPFeatureInfo *info = new TPPFeatureInfo();
    497     if (info) {
    498       info->params_ = T::Init(arg);
    499       if (!info->params_) {
    500         delete info;
    501         info = NULL;
    502       }
    503     }
    504 
    505     return info;
    506   }
    507 
    508  protected:
    509   TPPFeatureInfo() = default;
    510 
    511  private:
    512   T *params_ = NULL;
    513 };
    514 
    515 // This singleton class serves as data exchanging central between data producer
    516 // <libsdm-color.so> and data consumer<SDM and HWC.>
    517 // This class defines PP pending features to be programmed, which generated from
    518 // ColorManager. Dirty flag indicates some features are available to be programmed.
    519 // () Lock is needed since the object wil be accessed from 2 tasks.
    520 // All API exposed are not threadsafe, it's caller's responsiblity to acquire the locker.
    521 class PPFeaturesConfig {
    522  public:
    523   PPFeaturesConfig() { memset(feature_, 0, sizeof(feature_)); }
    524   ~PPFeaturesConfig() { Reset(); }
    525 
    526   // ColorManager installs one TFeatureInfo<T> to take the output configs computed
    527   // from ColorManager, containing all physical features to be programmed and also compute
    528   // metadata/populate into T.
    529   inline DisplayError AddFeature(uint32_t feature_id, PPFeatureInfo *feature) {
    530     if (feature_id < kMaxNumPPFeatures)
    531       feature_[feature_id] = feature;
    532 
    533     return kErrorNone;
    534   }
    535 
    536   inline Locker &GetLocker(void) { return locker_; }
    537   inline PPFrameCaptureData *GetFrameCaptureData(void) { return &frame_capture_data; }
    538   inline PPDETuningCfgData *GetDETuningCfgData(void) { return &de_tuning_data_; }
    539   // Once all features are consumed, destroy/release all TFeatureInfo<T> on the list,
    540   // then clear dirty_ flag and return the lock to the TFeatureInfo<T> producer.
    541   void Reset();
    542 
    543   // Consumer to call this to retrieve all the TFeatureInfo<T> on the list to be programmed.
    544   DisplayError RetrieveNextFeature(PPFeatureInfo **feature);
    545 
    546   inline bool IsDirty() { return dirty_; }
    547   inline void MarkAsDirty() { dirty_ = true; }
    548 
    549  private:
    550   bool dirty_ = 0;
    551   Locker locker_;
    552   PPFeatureInfo *feature_[kMaxNumPPFeatures];  // reference to TFeatureInfo<T>.
    553   uint32_t next_idx_ = 0;
    554   PPFrameCaptureData frame_capture_data;
    555   PPDETuningCfgData de_tuning_data_;
    556 };
    557 
    558 }  // namespace sdm
    559 
    560 #endif  // __COLOR_PARAMS_H__
    561