services/config/config_defs.h

/*
* Copyright (c) 2020 The Linux Foundation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*    * Redistributions of source code must retain the above copyright
*      notice, this list of conditions and the following disclaimer.
*    * Redistributions in binary form must reproduce the above
*      copyright notice, this list of conditions and the following
*      disclaimer in the documentation and/or other materials provided
*      with the distribution.
*    * Neither the name of The Linux Foundation. nor the names of its
*      contributors may be used to endorse or promote products derived
*      from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef __CONFIG_DEFS_H__
#define __CONFIG_DEFS_H__

#include <vector>
#include <string>

// #defines specifying the API level supported
// Client can use these API level #ifdefs in their implementation to call the
// corresponding DisplayConfig API independent of the underlying DisplayConfig
// implementation being present. When this ifdef gets enabled in this header, the
// client code will automatically get compiled.
#define DISPLAY_CONFIG_API_LEVEL_0

namespace DisplayConfig {

// enum definitions
enum class DisplayType : int {
  kInvalid,
  kPrimary,
  kExternal,
  kVirtual,
  kBuiltIn2,
};

enum class ExternalStatus : int {
  kInvalid,
  kOffline,
  kOnline,
  kPause,
  kResume,
};

enum class DynRefreshRateOp : int {
  kInvalid,
  kDisableMetadata,
  kEnableMetadata,
  kSetBinder,
};

enum class DisplayPortType : int {
  kInvalid,
  kDefault,
  kDsi,
  kDtv,
  kWriteback,
  kLvds,
  kEdp,
  kDp,
};

enum class PowerMode : int {
  kOff,
  kDoze,
  kOn,
  kDozeSuspend,
};

enum class QsyncMode : int {
  kNone,
  kWaitForFencesOneFrame,
  kWaitForFencesEachFrame,
  kWaitForCommitEachFrame,
};

enum class TUIEventType : int {
  kNone,
  kPrepareTUITransition,
  kStartTUITransition,
  kEndTUITransition,
};

// Input and Output Params structures
struct Attributes {
  uint32_t vsync_period = 0;
  uint32_t x_res = 0;
  uint32_t y_res = 0;
  float x_dpi = 0;
  float y_dpi = 0;
  DisplayPortType panel_type = DisplayPortType::kDefault;
  bool is_yuv = 0;
};

struct HDRCapsParams {
  std::vector<int> supported_hdr_types = {};
  float max_luminance = 0;
  float max_avg_luminance = 0;
  float min_luminance = 0;
};

struct StatusParams {
  DisplayType dpy = DisplayType::kInvalid;
  ExternalStatus status = ExternalStatus::kInvalid;
};

struct DynRefreshRateParams {
  DynRefreshRateOp op = DynRefreshRateOp::kInvalid;
  uint32_t refresh_rate = 0;
};

struct ConfigParams {
  DisplayType dpy = DisplayType::kInvalid;
  uint32_t config = 0;
};

struct AttributesParams {
  uint32_t config_index = 0;
  DisplayType dpy = DisplayType::kInvalid;
};

struct MinHdcpEncLevelChangedParams {
  DisplayType dpy = DisplayType::kInvalid;
  uint32_t min_enc_level = 0;
};

struct PartialUpdateParams {
  DisplayType dpy = DisplayType::kInvalid;
  bool enable = 0;
};

struct AnimationParams {
  uint64_t display_id = 0;
  bool animating = 0;
};

struct IdlePcParams {
  bool enable = 0;
  bool synchronous = 0;
};

struct DppsAdRoiParams {
  uint32_t display_id = 0;
  uint32_t h_start = 0;
  uint32_t h_end = 0;
  uint32_t v_start = 0;
  uint32_t v_end = 0;
  uint32_t factor_in = 0;
  uint32_t factor_out = 0;
};

struct PowerModeParams {
  uint32_t disp_id = 0;
  PowerMode power_mode = PowerMode::kOff;
};

struct LayerMaskParams {
  uint32_t disp_id = 0;
  uint64_t layer_id = 0;
};

struct PanelLumAttrParams {
  uint32_t disp_id = 0;
  float min_lum = 0;
  float max_lum = 0;
};

struct Rect {
  uint32_t left = 0;
  uint32_t top = 0;
  uint32_t right = 0;
  uint32_t bottom = 0;
};

struct CwbBufferParams {
  uint32_t disp_id = 0;
  Rect rect;
  bool post_processed = 0;
};

struct DsiClkParams {
  uint32_t disp_id = 0;
  uint64_t bit_clk = 0;
};

struct QsyncModeParams {
  uint32_t disp_id = 0;
  QsyncMode mode = QsyncMode::kNone;
};

struct SmartPanelCfgParams {
  uint32_t disp_id = 0;
  uint32_t config_id = 0;
};

struct VdsParams {
  uint32_t width = 0;
  uint32_t height = 0;
  int format = 0;
};

struct RotatorFormatParams {
  int hal_format = 0;
  bool ubwc = 0;
};

struct QsyncCallbackParams {
  bool qsync_enabled = 0;
  int refresh_rate = 0;
  int qsync_refresh_rate = 0;
};

struct TUIEventParams {
  DisplayType dpy = DisplayType::kInvalid;
  TUIEventType tui_event_type = TUIEventType::kNone;
};

/* Callback Interface */
class ConfigCallback {
 public:
  virtual void NotifyCWBBufferDone(int error, const native_handle_t *buffer) { }
  virtual void NotifyQsyncChange(bool qsync_enabled, int refresh_rate, int qsync_refresh_rate) { }

 protected:
  virtual ~ConfigCallback() { }
};

#define DEFAULT_RET { return -EINVAL; }

/* Config Interface */
class ConfigInterface {
 public:
  virtual int IsDisplayConnected(DisplayType dpy, bool *connected) DEFAULT_RET
  virtual int SetDisplayStatus(DisplayType dpy, ExternalStatus status) DEFAULT_RET
  virtual int ConfigureDynRefreshRate(DynRefreshRateOp op, uint32_t refresh_rate) DEFAULT_RET
  virtual int GetConfigCount(DisplayType dpy, uint32_t *count) DEFAULT_RET
  virtual int GetActiveConfig(DisplayType dpy, uint32_t *config) DEFAULT_RET
  virtual int SetActiveConfig(DisplayType dpy, uint32_t config) DEFAULT_RET
  virtual int GetDisplayAttributes(uint32_t config_index, DisplayType dpy,
                                   Attributes *attributes) DEFAULT_RET
  virtual int SetPanelBrightness(uint32_t level) DEFAULT_RET
  virtual int GetPanelBrightness(uint32_t *level) DEFAULT_RET
  virtual int MinHdcpEncryptionLevelChanged(DisplayType dpy, uint32_t min_enc_level) DEFAULT_RET
  virtual int RefreshScreen() DEFAULT_RET
  virtual int ControlPartialUpdate(DisplayType dpy, bool enable) DEFAULT_RET
  virtual int ToggleScreenUpdate(bool on) DEFAULT_RET
  virtual int SetIdleTimeout(uint32_t value) DEFAULT_RET
  virtual int GetHDRCapabilities(DisplayType dpy, HDRCapsParams *caps) DEFAULT_RET
  virtual int SetCameraLaunchStatus(uint32_t on) DEFAULT_RET
  virtual int DisplayBWTransactionPending(bool *status) DEFAULT_RET
  virtual int SetDisplayAnimating(uint64_t display_id, bool animating) DEFAULT_RET
  virtual int ControlIdlePowerCollapse(bool enable, bool synchronous) DEFAULT_RET
  virtual int GetWriteBackCapabilities(bool *is_wb_ubwc_supported) DEFAULT_RET
  virtual int SetDisplayDppsAdROI(uint32_t display_id, uint32_t h_start, uint32_t h_end,
                                  uint32_t v_start, uint32_t v_end, uint32_t factor_in,
                                  uint32_t factor_out) DEFAULT_RET
  virtual int UpdateVSyncSourceOnPowerModeOff() DEFAULT_RET
  virtual int UpdateVSyncSourceOnPowerModeDoze() DEFAULT_RET
  virtual int SetPowerMode(uint32_t disp_id, PowerMode power_mode) DEFAULT_RET
  virtual int IsPowerModeOverrideSupported(uint32_t disp_id, bool *supported) DEFAULT_RET
  virtual int IsHDRSupported(uint32_t disp_id, bool *supported) DEFAULT_RET
  virtual int IsWCGSupported(uint32_t disp_id, bool *supported) DEFAULT_RET
  virtual int SetLayerAsMask(uint32_t disp_id, uint64_t layer_id) DEFAULT_RET
  virtual int GetDebugProperty(const std::string prop_name, std::string *value) DEFAULT_RET
  virtual int GetActiveBuiltinDisplayAttributes(Attributes *attr) DEFAULT_RET
  virtual int SetPanelLuminanceAttributes(uint32_t disp_id, float min_lum,
                                          float max_lum) DEFAULT_RET
  virtual int IsBuiltInDisplay(uint32_t disp_id, bool *is_builtin) DEFAULT_RET
  virtual int IsAsyncVDSCreationSupported(bool *supported) DEFAULT_RET
  virtual int CreateVirtualDisplay(uint32_t width, uint32_t height, int format) DEFAULT_RET
  virtual int GetSupportedDSIBitClks(uint32_t disp_id, std::vector<uint64_t> *bit_clks) DEFAULT_RET
  virtual int GetDSIClk(uint32_t disp_id, uint64_t *bit_clk) DEFAULT_RET
  virtual int SetDSIClk(uint32_t disp_id, uint64_t bit_clk) DEFAULT_RET
  virtual int SetCWBOutputBuffer(uint32_t disp_id, const Rect rect, bool post_processed,
                                 const native_handle_t *buffer) DEFAULT_RET
  virtual int SetQsyncMode(uint32_t disp_id, QsyncMode mode) DEFAULT_RET
  virtual int IsSmartPanelConfig(uint32_t disp_id, uint32_t config_id, bool *is_smart) DEFAULT_RET
  virtual int IsRotatorSupportedFormat(int hal_format, bool ubwc, bool *supported) DEFAULT_RET
  virtual int ControlQsyncCallback(bool enable) DEFAULT_RET
  virtual int SendTUIEvent(DisplayType dpy, TUIEventType event_type) DEFAULT_RET

  // deprecated APIs
  virtual int GetDebugProperty(const std::string prop_name, std::string value) DEFAULT_RET
  virtual int GetSupportedDSIBitClks(uint32_t disp_id, std::vector<uint64_t> bit_clks) DEFAULT_RET

 protected:
  virtual ~ConfigInterface() { }
};

}  // namespace DisplayConfig

#endif  // __CONFIG_DEFS_H__