diff --git a/Android.bp b/Android.bp index 8b6997e7..947077ec 100644 --- a/Android.bp +++ b/Android.bp @@ -6,5 +6,6 @@ cc_library_headers { "include", "libdisplayconfig", "libqdmetadata", + "services", ], } diff --git a/services/config/client_interface.h b/services/config/client_interface.h new file mode 100644 index 00000000..faf772a5 --- /dev/null +++ b/services/config/client_interface.h @@ -0,0 +1,49 @@ +/* +* 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 __CLIENT_INTERFACE_H__ +#define __CLIENT_INTERFACE_H__ + +#include "config_defs.h" + +namespace DisplayConfig { + +class ClientInterface : public ConfigInterface { + public: + static int Create(std::string client_name, ConfigCallback *callback, + ClientInterface **intf); + static void Destroy(ClientInterface *intf); + + protected: + virtual ~ClientInterface() { } +}; + +} // namespace DisplayConfig + +#endif // __CLIENT_INTERFACE_H__ diff --git a/services/config/config_defs.h b/services/config/config_defs.h new file mode 100644 index 00000000..77eea44f --- /dev/null +++ b/services/config/config_defs.h @@ -0,0 +1,291 @@ +/* +* 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 +#include + +// #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, +}; + +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, +}; + +// 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 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; +}; + +/* 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 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 + + protected: + virtual ~ConfigInterface() { } +}; + +} // namespace DisplayConfig + +#endif // __CONFIG_DEFS_H__ diff --git a/services/config/device_interface.h b/services/config/device_interface.h new file mode 100644 index 00000000..7d859102 --- /dev/null +++ b/services/config/device_interface.h @@ -0,0 +1,57 @@ +/* +* 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 __DEVICE_INTERFACE_H__ +#define __DEVICE_INTERFACE_H__ + +#include "config_defs.h" + +namespace DisplayConfig { + +class ClientContext { + public: + virtual int RegisterClientContext(std::shared_ptr callback, + ConfigInterface **intf) { return -EINVAL; } + virtual void UnRegisterClientContext(ConfigInterface *intf) { } + + protected: + virtual ~ClientContext() { } +}; + +class DeviceInterface { + public: + static int RegisterDevice(ClientContext *intf); + + protected: + virtual ~DeviceInterface() { } +}; + +} // namespace DisplayConfig + +#endif // __DEVICE_INTERFACE_H__ diff --git a/services/config/src/Android.bp b/services/config/src/Android.bp new file mode 100644 index 00000000..355849af --- /dev/null +++ b/services/config/src/Android.bp @@ -0,0 +1,24 @@ +cc_library_shared { + name: "libdisplayconfig.qti", + vendor_available: true, + product_specific: true, + cflags: [ + "-Wno-sign-conversion", + "-Wno-unused-parameter", + "-DLOG_TAG=\"libdisplayconfigqti\"", + ], + shared_libs: [ + "libhidlbase", + "libutils", + "vendor.display.config@2.0" + ], + header_libs: ["libhardware_headers", "display_intf_headers"], + srcs: [ + "client_interface.cpp", + "client_impl.cpp", + "device_impl.cpp", + "device_interface.cpp", + ], + export_header_lib_headers: ["display_intf_headers"], +} + diff --git a/services/config/src/client_impl.cpp b/services/config/src/client_impl.cpp new file mode 100644 index 00000000..b3dd3e89 --- /dev/null +++ b/services/config/src/client_impl.cpp @@ -0,0 +1,864 @@ +/* +* 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. +*/ + +#include +#include + +#include "client_impl.h" + +namespace DisplayConfig { + +int ClientImpl::Init(std::string client_name, ConfigCallback *callback) { + display_config_ = IDisplayConfig::getService(); + // Unable to find Display Config 2.0 service. Fail Init. + if (!display_config_) { + return -1; + } + int32_t error = 0; + uint64_t handle = 0; + auto hidl_callback = [&error, &handle] (int32_t err, uint64_t client_handle) { + error = err; + handle = client_handle; + }; + int pid = getpid(); + display_config_->registerClient(client_name + std::to_string(pid), this, hidl_callback); + client_handle_ = handle; + callback_ = callback; + + return 0; +} + +int ClientImpl::IsDisplayConnected(DisplayType dpy, bool *connected) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&dpy), sizeof(DisplayType)); + const bool *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kIsDisplayConnected, input_params, {}, hidl_cb); + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + + if (!error) { + *connected = *output; + } + + return error; +} + +int ClientImpl::SetDisplayStatus(DisplayType dpy, ExternalStatus status) { + struct StatusParams input = {dpy, status}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), sizeof(struct StatusParams)); + int error = 0; + + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kSetDisplayStatus, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::ConfigureDynRefreshRate(DynRefreshRateOp op, uint32_t refresh_rate) { + struct DynRefreshRateParams input = {op, refresh_rate}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), + sizeof(struct DynRefreshRateParams)); + int error = 0; + + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kConfigureDynRefreshRate, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::GetConfigCount(DisplayType dpy, uint32_t *count) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&dpy), sizeof(DisplayType)); + const uint32_t *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kGetConfigCount, input_params, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + *count = *output; + + return error; +} + +int ClientImpl::GetActiveConfig(DisplayType dpy, uint32_t *config) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&dpy), sizeof(DisplayType)); + const uint32_t *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kGetActiveConfig, input_params, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + *config = *output; + + return error; +} + +int ClientImpl::SetActiveConfig(DisplayType dpy, uint32_t config) { + struct ConfigParams input = {dpy, config}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), sizeof(struct ConfigParams)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kSetActiveConfig, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::GetDisplayAttributes(uint32_t config_index, DisplayType dpy, + Attributes *attributes) { + struct AttributesParams input = {config_index, dpy}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), sizeof(struct AttributesParams)); + const struct Attributes *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kGetDisplayAttributes, input_params, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + if (!error) { + *attributes = *output; + } + + return error; +} + +int ClientImpl::SetPanelBrightness(uint32_t level) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&level), sizeof(uint32_t)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kSetPanelBrightness, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::GetPanelBrightness(uint32_t *level) { + const uint32_t *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kGetPanelBrightness, {}, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + if (!error) { + *level = *output; + } + + return error; +} + +int ClientImpl::MinHdcpEncryptionLevelChanged(DisplayType dpy, uint32_t min_enc_level) { + struct MinHdcpEncLevelChangedParams input = {dpy, min_enc_level}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), + sizeof(struct MinHdcpEncLevelChangedParams)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kMinHdcpEncryptionLevelChanged, + input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::RefreshScreen() { + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kRefreshScreen, {}, {}, hidl_cb); + + return error; +} + +int ClientImpl::ControlPartialUpdate(DisplayType dpy, bool enable) { + struct PartialUpdateParams input = {dpy, enable}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), + sizeof(struct PartialUpdateParams)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kControlPartialUpdate, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::ToggleScreenUpdate(bool on) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&on), sizeof(bool)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kToggleScreenUpdate, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::SetIdleTimeout(uint32_t value) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&value), sizeof(uint32_t)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kSetIdleTimeout, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::GetHDRCapabilities(DisplayType dpy, HDRCapsParams *caps) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&dpy), sizeof(DisplayType)); + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kGetHdrCapabilities, input_params, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + + if (!error) { + const int32_t *hdr_caps; + const float *lum; + size_t size = output_params.size(); + size_t hdr_caps_size = size - 3 * sizeof(float); + hdr_caps_size /= sizeof(int32_t); + hdr_caps = reinterpret_cast(data); + for (size_t i = 0; i < hdr_caps_size; i++) { + caps->supported_hdr_types.push_back(*hdr_caps); + hdr_caps++; + } + lum = reinterpret_cast(hdr_caps); + caps->max_luminance = lum[0]; + caps->max_avg_luminance = lum[1]; + caps->min_luminance = lum[2]; + } + + return error; +} + +int ClientImpl::SetCameraLaunchStatus(uint32_t on) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&on), sizeof(uint32_t)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kSetCameraLaunchStatus, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::DisplayBWTransactionPending(bool *status) { + const bool *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kDisplayBwTransactionPending, {}, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + if (!error) { + *status = *output; + } + + return error; +} + +int ClientImpl::SetDisplayAnimating(uint64_t display_id, bool animating) { + struct AnimationParams input = {display_id, animating}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), sizeof(struct AnimationParams)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kSetDisplayAnimating, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::ControlIdlePowerCollapse(bool enable, bool synchronous) { + struct IdlePcParams input = {enable, synchronous}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), sizeof(struct IdlePcParams)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kControlIdlePowerCollapse, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::GetWriteBackCapabilities(bool *is_wb_ubwc_supported) { + const bool *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kGetWritebackCapabilities, {}, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + if (!error) { + *is_wb_ubwc_supported = *output; + } + + return error; +} + +int ClientImpl::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) { + struct DppsAdRoiParams input = {display_id, h_start, h_end, v_start, v_end, + factor_in, factor_out}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), sizeof(struct DppsAdRoiParams)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kSetDisplayDppsAdRoi, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::UpdateVSyncSourceOnPowerModeOff() { + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kUpdateVsyncSourceOnPowerModeOff, {}, {}, hidl_cb); + + return error; +} + +int ClientImpl::UpdateVSyncSourceOnPowerModeDoze() { + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kUpdateVsyncSourceOnPowerModeDoze, {}, {}, hidl_cb); + + return error; +} + +int ClientImpl::SetPowerMode(uint32_t disp_id, PowerMode power_mode) { + struct PowerModeParams input = {disp_id, power_mode}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), sizeof(struct PowerModeParams)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kSetPowerMode, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::IsPowerModeOverrideSupported(uint32_t disp_id, bool *supported) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&disp_id), sizeof(uint32_t)); + const bool *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kIsPowerModeOverrideSupported, + input_params, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + + if (!error) { + *supported = *output; + } + + return error; +} + +int ClientImpl::IsHDRSupported(uint32_t disp_id, bool *supported) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&disp_id), sizeof(uint32_t)); + const bool *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kIsHdrSupported, input_params, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + + if (!error) { + *supported = *output; + } + + return error; +} + +int ClientImpl::IsWCGSupported(uint32_t disp_id, bool *supported) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&disp_id), sizeof(int32_t)); + const bool *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kIsWcgSupported, input_params, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + + if (!error) { + *supported = *output; + } + + return error; +} + +int ClientImpl::SetLayerAsMask(uint32_t disp_id, uint64_t layer_id) { + struct LayerMaskParams input = {disp_id, layer_id}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), sizeof(struct LayerMaskParams)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kSetLayerAsMask, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::GetDebugProperty(const std::string prop_name, std::string value) { + ByteStream input_params; + uint8_t *data_input = reinterpret_cast(const_cast(prop_name.data())); + input_params.setToExternal(reinterpret_cast(data_input), + prop_name.size() * sizeof(char)); + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kGetDebugProperty, input_params, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + const char *name = reinterpret_cast(data); + std::string output(name); + if (!error) { + value = output; + } + + return error; +} + +int ClientImpl::GetActiveBuiltinDisplayAttributes(Attributes *attr) { + const struct Attributes *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kGetActiveBuiltinDisplayAttributes, {}, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + if (!error) { + *attr = *output; + } + + return error; +} + +int ClientImpl::SetPanelLuminanceAttributes(uint32_t disp_id, float min_lum, float max_lum) { + struct PanelLumAttrParams input = {disp_id, min_lum, max_lum}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), sizeof(struct PanelLumAttrParams)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kSetPanelLuminanceAttributes, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::IsBuiltInDisplay(uint32_t disp_id, bool *is_builtin) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&disp_id), sizeof(uint32_t)); + const bool *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kIsBuiltinDisplay, input_params, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + + if (!error) { + *is_builtin = *output; + } + + return error; +} + +int ClientImpl::SetCWBOutputBuffer(uint32_t disp_id, const Rect rect, bool post_processed, + const native_handle_t *buffer) { + if (callback_ == nullptr) { + return -EINVAL; + } + + struct CwbBufferParams input = {disp_id, rect, post_processed}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), sizeof(struct CwbBufferParams)); + + hidl_handle handle = buffer; + std::vector handle_vector; + handle_vector.push_back(buffer); + HandleStream input_handles = handle_vector; + + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kSetCwbOutputBuffer, input_params, + input_handles, hidl_cb); + + return error; +} + +int ClientImpl::GetSupportedDSIBitClks(uint32_t disp_id, std::vector bit_clks) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&disp_id), sizeof(uint32_t)); + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kGetSupportedDsiBitclks, input_params, {}, hidl_cb); + + if (!error) { + const uint8_t *data = output_params.data(); + const uint64_t *bit_clks_data = reinterpret_cast(data); + int num_bit_clks = static_cast(output_params.size() / sizeof(uint64_t)); + for (int i = 0; i < num_bit_clks; i++) { + bit_clks.push_back(bit_clks_data[i]); + } + } + + return error; +} + +int ClientImpl::GetDSIClk(uint32_t disp_id, uint64_t *bit_clk) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&disp_id), sizeof(uint32_t)); + const uint64_t *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kGetDsiClk, input_params, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + + if (!error) { + *bit_clk = *output; + } + + return error; +} + +int ClientImpl::SetDSIClk(uint32_t disp_id, uint64_t bit_clk) { + struct DsiClkParams input = {disp_id, bit_clk}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), sizeof(struct DsiClkParams)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kSetDsiClk, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::SetQsyncMode(uint32_t disp_id, QsyncMode mode) { + struct QsyncModeParams input = {disp_id, mode}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), sizeof(struct QsyncModeParams)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kSetQsyncMode, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::IsSmartPanelConfig(uint32_t disp_id, uint32_t config_id, bool *is_smart) { + struct SmartPanelCfgParams input = {disp_id, config_id}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), + sizeof(struct SmartPanelCfgParams)); + const bool *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kIsSmartPanelConfig, input_params, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + + if (!error) { + *is_smart = *output; + } + + return error; +} + +int ClientImpl::IsAsyncVDSCreationSupported(bool *supported) { + const bool *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kIsAsyncVdsSupported, {}, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + + if (!error) { + *supported = *output; + } + + return error; +} + +int ClientImpl::CreateVirtualDisplay(uint32_t width, uint32_t height, int32_t format) { + struct VdsParams input = {width, height, format}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), sizeof(struct VdsParams)); + int error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kCreateVirtualDisplay, input_params, {}, hidl_cb); + + return error; +} + +int ClientImpl::IsRotatorSupportedFormat(int hal_format, bool ubwc, bool *supported) { + struct RotatorFormatParams input = {hal_format, ubwc}; + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&input), + sizeof(struct RotatorFormatParams)); + const bool *output; + ByteStream output_params; + int error = 0; + auto hidl_cb = [&error, &output_params] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + output_params = params; + }; + + display_config_->perform(client_handle_, kIsRotatorSupportedFormat, input_params, {}, hidl_cb); + + const uint8_t *data = output_params.data(); + output = reinterpret_cast(data); + + if (!error) { + *supported = *output; + } + + return error; +} + +int ClientImpl::ControlQsyncCallback(bool enable) { + ByteStream input_params; + input_params.setToExternal(reinterpret_cast(&enable), sizeof(bool)); + int32_t error = 0; + auto hidl_cb = [&error] (int32_t err, ByteStream params, HandleStream handles) { + error = err; + }; + + display_config_->perform(client_handle_, kControlQsyncCallback, input_params, {}, hidl_cb); + + return error; +} + +void ClientImpl::ParseNotifyCWBBufferDone(const ByteStream &input_params, + const HandleStream &input_handles) { + const int *error; + + if (input_params.size() == 0 || input_handles.size() == 0) { + return; + } + + const uint8_t *data = input_params.data(); + error = reinterpret_cast(data); + hidl_handle buffer = input_handles[0]; + callback_->NotifyCWBBufferDone(*error, buffer.getNativeHandle()); +} + +void ClientImpl::ParseNotifyQsyncChange(const ByteStream &input_params) { + const struct QsyncCallbackParams *qsync_data; + + if (input_params.size() == 0) { + return; + } + + const uint8_t *data = input_params.data(); + qsync_data = reinterpret_cast(data); + callback_->NotifyQsyncChange(qsync_data->qsync_enabled, qsync_data->refresh_rate, + qsync_data->qsync_refresh_rate); +} + +Return ClientImpl::perform(uint32_t op_code, const ByteStream &input_params, + const HandleStream &input_handles) { + switch (op_code) { + case kSetCwbOutputBuffer: + ParseNotifyCWBBufferDone(input_params, input_handles); + break; + case kControlQsyncCallback: + ParseNotifyQsyncChange(input_params); + break; + default: + break; + } + + return Void(); +} + +} // namespace DisplayConfig diff --git a/services/config/src/client_impl.h b/services/config/src/client_impl.h new file mode 100644 index 00000000..f90a4e08 --- /dev/null +++ b/services/config/src/client_impl.h @@ -0,0 +1,115 @@ +/* +* 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 __CLIENT_IMPL_H__ +#define __CLIENT_IMPL_H__ + +#include +#include +#include +#include +#include + +#include "opcode_types.h" + +namespace DisplayConfig { + +using vendor::display::config::V2_0::IDisplayConfig; +using vendor::display::config::V2_0::IDisplayConfigCallback; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::hidl_handle; +using ::android::hardware::hidl_vec; + +typedef hidl_vec ByteStream; +typedef hidl_vec HandleStream; + +class ClientImpl : public ClientInterface, public IDisplayConfigCallback { + public: + int Init(std::string client_name, ConfigCallback *callback); + + virtual int IsDisplayConnected(DisplayType dpy, bool *connected); + virtual int SetDisplayStatus(DisplayType dpy, ExternalStatus status); + virtual int ConfigureDynRefreshRate(DynRefreshRateOp op, uint32_t refresh_rate); + virtual int GetConfigCount(DisplayType dpy, uint32_t *count); + virtual int GetActiveConfig(DisplayType dpy, uint32_t *config); + virtual int SetActiveConfig(DisplayType dpy, uint32_t config); + virtual int GetDisplayAttributes(uint32_t config_index, DisplayType dpy, Attributes *attributes); + virtual int SetPanelBrightness(uint32_t level); + virtual int GetPanelBrightness(uint32_t *level); + virtual int MinHdcpEncryptionLevelChanged(DisplayType dpy, uint32_t min_enc_level); + virtual int RefreshScreen(); + virtual int ControlPartialUpdate(DisplayType dpy, bool enable); + virtual int ToggleScreenUpdate(bool on); + virtual int SetIdleTimeout(uint32_t value); + virtual int GetHDRCapabilities(DisplayType dpy, HDRCapsParams *caps); + virtual int SetCameraLaunchStatus(uint32_t on); + virtual int DisplayBWTransactionPending(bool *status); + virtual int SetDisplayAnimating(uint64_t display_id, bool animating); + virtual int ControlIdlePowerCollapse(bool enable, bool synchronous); + virtual int GetWriteBackCapabilities(bool *is_wb_ubwc_supported); + 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); + virtual int UpdateVSyncSourceOnPowerModeOff(); + virtual int UpdateVSyncSourceOnPowerModeDoze(); + virtual int SetPowerMode(uint32_t disp_id, PowerMode power_mode); + virtual int IsPowerModeOverrideSupported(uint32_t disp_id, bool *supported); + virtual int IsHDRSupported(uint32_t disp_id, bool *supported); + virtual int IsWCGSupported(uint32_t disp_id, bool *supported); + virtual int SetLayerAsMask(uint32_t disp_id, uint64_t layer_id); + virtual int GetDebugProperty(const std::string prop_name, std::string value); + virtual int GetActiveBuiltinDisplayAttributes(Attributes *attr); + virtual int SetPanelLuminanceAttributes(uint32_t disp_id, float min_lum, float max_lum); + virtual int IsBuiltInDisplay(uint32_t disp_id, bool *is_builtin); + virtual int IsAsyncVDSCreationSupported(bool *supported); + virtual int CreateVirtualDisplay(uint32_t width, uint32_t height, int format); + virtual int GetSupportedDSIBitClks(uint32_t disp_id, std::vector bit_clks); + virtual int GetDSIClk(uint32_t disp_id, uint64_t *bit_clk); + virtual int SetDSIClk(uint32_t disp_id, uint64_t bit_clk); + virtual int SetCWBOutputBuffer(uint32_t disp_id, const Rect rect, bool post_processed, + const native_handle_t *buffer); + virtual int SetQsyncMode(uint32_t disp_id, QsyncMode mode); + virtual int IsSmartPanelConfig(uint32_t disp_id, uint32_t config_id, bool *is_smart); + virtual int IsRotatorSupportedFormat(int hal_format, bool ubwc, bool *supported); + virtual int ControlQsyncCallback(bool enable); + + private: + virtual Return perform(uint32_t op_code, const ByteStream &input_params, + const HandleStream &input_handles); + void ParseNotifyCWBBufferDone(const ByteStream &input_params, const HandleStream &input_handles); + void ParseNotifyQsyncChange(const ByteStream &input_params); + android::sp display_config_ = nullptr; + ConfigCallback *callback_ = nullptr; + uint64_t client_handle_ = 0; +}; + +} // namespace DisplayConfig + +#endif // __CLIENT_IMPL_H__ diff --git a/services/config/src/client_interface.cpp b/services/config/src/client_interface.cpp new file mode 100644 index 00000000..94be1b9b --- /dev/null +++ b/services/config/src/client_interface.cpp @@ -0,0 +1,63 @@ +/* +* 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. +*/ + +#include + +#include "client_impl.h" + +namespace DisplayConfig { + +int ClientInterface::Create(std::string client_name, ConfigCallback *callback, + ClientInterface **intf) { + if (!intf) { + return -1; + } + + ClientImpl *impl = new ClientImpl(); + if (!impl) { + return -1; + } + + int ret = impl->Init(client_name, callback); + if (ret) { + delete impl; + return -1; + } + + *intf = impl; + return 0; +} + +void ClientInterface::Destroy(ClientInterface *intf) { + if (intf) { + delete static_cast(intf); + } +} + +} // namespace DisplayConfig diff --git a/services/config/src/device_impl.cpp b/services/config/src/device_impl.cpp new file mode 100644 index 00000000..97e8a829 --- /dev/null +++ b/services/config/src/device_impl.cpp @@ -0,0 +1,835 @@ +/* +* 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. +*/ + +#include +#include + +#include "device_impl.h" + +namespace DisplayConfig { + +DeviceImpl *DeviceImpl::device_obj_ = nullptr; +std::mutex DeviceImpl::device_lock_; + +int DeviceImpl::CreateInstance(ClientContext *intf) { + std::lock_guard lock(device_lock_); + if (!device_obj_) { + device_obj_ = new DeviceImpl(); + if (!device_obj_) { + return -1; + } + + android::status_t status = device_obj_->IDisplayConfig::registerAsService(); + // Unable to start Display Config 2.0 service. Fail Init. + if (status != android::OK) { + delete device_obj_; + device_obj_ = nullptr; + return -1; + } + device_obj_->intf_ = intf; + } + + return 0; +} + +Return DeviceImpl::registerClient(const hidl_string &client_name, + const sp& callback, + registerClient_cb _hidl_cb) { + int32_t error = 0; + std::string client_name_str = client_name.c_str(); + if (client_name_str.empty()) { + error = -EINVAL; + _hidl_cb(error, 0); + return Void(); + } + + uint64_t client_handle = static_cast(client_id_++); + std::shared_ptr device_client(new DeviceClientContext(callback)); + if (callback) { + callback->linkToDeath(this, client_handle); + } + ConfigInterface *intf = nullptr; + intf_->RegisterClientContext(device_client, &intf); + device_client->SetDeviceConfigIntf(intf); + + display_config_map_.emplace(std::make_pair(client_handle, device_client)); + _hidl_cb(error, client_handle); + return Void(); +} + +void DeviceImpl::serviceDied(uint64_t client_handle, + const android::wp<::android::hidl::base::V1_0::IBase>& callback) { + std::lock_guard lock(death_service_mutex_); + auto itr = display_config_map_.find(client_handle); + std::shared_ptr client = itr->second; + ConfigInterface *intf = client->GetDeviceConfigIntf(); + intf_->UnRegisterClientContext(intf); + client.reset(); + display_config_map_.erase(itr); +} + +DeviceImpl::DeviceClientContext::DeviceClientContext(const sp callback) { + callback_ = callback; +} + +void DeviceImpl::DeviceClientContext::SetDeviceConfigIntf(ConfigInterface *intf) { + intf_ = intf; +} + +ConfigInterface* DeviceImpl::DeviceClientContext::GetDeviceConfigIntf() { + return intf_; +} + +void DeviceImpl::DeviceClientContext::NotifyCWBBufferDone(int32_t error, + const native_handle_t *buffer) { + ByteStream output_params; + HandleStream output_handles; + std::vector handles; + + output_params.setToExternal(reinterpret_cast(&error), sizeof(int)); + handles.push_back(buffer); + output_handles = handles; + + auto status = callback_->perform(kSetCwbOutputBuffer, output_params, output_handles); + if (status.isDeadObject()) { + return; + } +} + +void DeviceImpl::DeviceClientContext::NotifyQsyncChange(bool qsync_enabled, int32_t refresh_rate, + int32_t qsync_refresh_rate) { + struct QsyncCallbackParams data = {qsync_enabled, refresh_rate, qsync_refresh_rate}; + ByteStream output_params; + + output_params.setToExternal(reinterpret_cast(&data), sizeof(data)); + + auto status = callback_->perform(kControlQsyncCallback, output_params, {}); + if (status.isDeadObject()) { + return; + } +} + +void DeviceImpl::DeviceClientContext::ParseIsDisplayConnected(const ByteStream &input_params, + perform_cb _hidl_cb) { + const DisplayType *dpy; + bool connected = false; + ByteStream output_params; + + const uint8_t *data = input_params.data(); + dpy = reinterpret_cast(data); + int32_t error = intf_->IsDisplayConnected(*dpy, &connected); + + output_params.setToExternal(reinterpret_cast(&connected), + sizeof(connected)); + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseSetDisplayStatus(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct StatusParams *display_status; + const uint8_t *data = input_params.data(); + display_status = reinterpret_cast(data); + int32_t error = intf_->SetDisplayStatus(display_status->dpy, + display_status->status); + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseConfigureDynRefreshRate(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct DynRefreshRateParams *dyn_refresh_data; + const uint8_t *data = input_params.data(); + dyn_refresh_data = reinterpret_cast(data); + int32_t error = intf_->ConfigureDynRefreshRate(dyn_refresh_data->op, + dyn_refresh_data->refresh_rate); + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseGetConfigCount(const ByteStream &input_params, + perform_cb _hidl_cb) { + const DisplayType *dpy; + uint32_t count = 0; + ByteStream output_params; + + if (input_params.size() == 0) { + _hidl_cb(-ENODATA, {}, {}); + return; + } + + const uint8_t *data = input_params.data(); + dpy = reinterpret_cast(data); + int32_t error = intf_->GetConfigCount(*dpy, &count); + output_params.setToExternal(reinterpret_cast(&count), + sizeof(uint32_t)); + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseGetActiveConfig(const ByteStream &input_params, + perform_cb _hidl_cb) { + const DisplayType *dpy; + uint32_t config = 0; + ByteStream output_params; + + const uint8_t *data = input_params.data(); + dpy = reinterpret_cast(data); + int32_t error = intf_->GetActiveConfig(*dpy, &config); + output_params.setToExternal(reinterpret_cast(&config), + sizeof(uint32_t)); + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseSetActiveConfig(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct ConfigParams *set_active_cfg_data; + + const uint8_t *data = input_params.data(); + set_active_cfg_data = reinterpret_cast(data); + int32_t error = intf_->SetActiveConfig(set_active_cfg_data->dpy, + set_active_cfg_data->config); + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseGetDisplayAttributes(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct AttributesParams *get_disp_attr_data; + struct Attributes attributes = {}; + ByteStream output_params; + int32_t error = -EINVAL; + + const uint8_t *data = input_params.data(); + get_disp_attr_data = reinterpret_cast(data); + error = intf_->GetDisplayAttributes(get_disp_attr_data->config_index, get_disp_attr_data->dpy, + &attributes); + output_params.setToExternal(reinterpret_cast(&attributes), + sizeof(struct Attributes)); + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseSetPanelBrightness(const ByteStream &input_params, + perform_cb _hidl_cb) { + const uint32_t *level; + int32_t error = 0; + + const uint8_t *data = input_params.data(); + level = reinterpret_cast(data); + error = intf_->SetPanelBrightness(*level); + + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseGetPanelBrightness(perform_cb _hidl_cb) { + uint32_t level = 0; + ByteStream output_params; + int32_t error = -EINVAL; + + error = intf_->GetPanelBrightness(&level); + output_params.setToExternal(reinterpret_cast(&level), + sizeof(uint32_t)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseMinHdcpEncryptionLevelChanged( + const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct MinHdcpEncLevelChangedParams *min_hdcp_enc_level_data; + int32_t error = 0; + + const uint8_t *data = input_params.data(); + min_hdcp_enc_level_data = reinterpret_cast(data); + error = intf_->MinHdcpEncryptionLevelChanged(min_hdcp_enc_level_data->dpy, + min_hdcp_enc_level_data->min_enc_level); + + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseRefreshScreen(perform_cb _hidl_cb) { + int32_t error = intf_->RefreshScreen(); + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseControlPartialUpdate(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct PartialUpdateParams *partial_update_data; + int32_t error = 0; + + const uint8_t *data = input_params.data(); + partial_update_data = reinterpret_cast(data); + error = intf_->ControlPartialUpdate(partial_update_data->dpy, partial_update_data->enable); + + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseToggleScreenUpdate(const ByteStream &input_params, + perform_cb _hidl_cb) { + const bool *on; + int32_t error = 0; + + const uint8_t *data = input_params.data(); + on = reinterpret_cast(data); + error = intf_->ToggleScreenUpdate(on); + + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseSetIdleTimeout(const ByteStream &input_params, + perform_cb _hidl_cb) { + const uint32_t *timeout_value; + + const uint8_t *data = input_params.data(); + timeout_value = reinterpret_cast(data); + int32_t error = intf_->SetIdleTimeout(*timeout_value); + + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseGetHdrCapabilities(const ByteStream &input_params, + perform_cb _hidl_cb) { + const DisplayType *dpy; + ByteStream output_params; + struct HDRCapsParams hdr_caps; + int32_t *data_output; + int32_t error = -EINVAL; + + const uint8_t *data = input_params.data(); + dpy = reinterpret_cast(data); + error = intf_->GetHDRCapabilities(*dpy, &hdr_caps); + + data_output = reinterpret_cast(malloc(sizeof(int32_t) * + hdr_caps.supported_hdr_types.size() + 3 * sizeof(float))); + for (int i = 0; i < hdr_caps.supported_hdr_types.size(); i++) { + data_output[i] = hdr_caps.supported_hdr_types[i]; + } + float *lum = reinterpret_cast(&data_output[hdr_caps.supported_hdr_types.size()]); + *lum = hdr_caps.max_luminance; + lum++; + *lum = hdr_caps.max_avg_luminance; + lum++; + *lum = hdr_caps.min_luminance; + output_params.setToExternal(reinterpret_cast(data_output), sizeof(int32_t) * + hdr_caps.supported_hdr_types.size() + 3 * sizeof(float)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseSetCameraLaunchStatus(const ByteStream &input_params, + perform_cb _hidl_cb) { + const uint32_t *launch_status_data; + + const uint8_t *data = input_params.data(); + launch_status_data = reinterpret_cast(data); + + int32_t error = intf_->SetCameraLaunchStatus(*launch_status_data); + + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseDisplayBwTransactionPending(perform_cb _hidl_cb) { + bool status = true; + ByteStream output_params; + + int32_t error = intf_->DisplayBWTransactionPending(&status); + output_params.setToExternal(reinterpret_cast(&status), + sizeof(bool)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseSetDisplayAnimating(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct AnimationParams *display_animating_data; + + const uint8_t *data = input_params.data(); + display_animating_data = reinterpret_cast(data); + int32_t error = intf_->SetDisplayAnimating(display_animating_data->display_id, + display_animating_data->animating); + + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseControlIdlePowerCollapse(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct IdlePcParams *idle_pc_data; + + const uint8_t *data = input_params.data(); + idle_pc_data = reinterpret_cast(data); + int32_t error = intf_->ControlIdlePowerCollapse(idle_pc_data->enable, idle_pc_data->synchronous); + + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseGetWritebackCapabilities(perform_cb _hidl_cb) { + bool is_wb_ubwc_supported; + ByteStream output_params; + + int32_t error = intf_->GetWriteBackCapabilities(&is_wb_ubwc_supported); + output_params.setToExternal(reinterpret_cast(&is_wb_ubwc_supported), + sizeof(bool)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseSetDisplayDppsAdRoi(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct DppsAdRoiParams *ad_roi_data; + + const uint8_t *data = input_params.data(); + ad_roi_data = reinterpret_cast(data); + + int32_t error = intf_->SetDisplayDppsAdROI(ad_roi_data->display_id, ad_roi_data->h_start, + ad_roi_data->h_end, ad_roi_data->v_start, + ad_roi_data->v_end, ad_roi_data->factor_in, + ad_roi_data->factor_out); + + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseUpdateVsyncSourceOnPowerModeOff(perform_cb _hidl_cb) { + int32_t error = intf_->UpdateVSyncSourceOnPowerModeOff(); + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseUpdateVsyncSourceOnPowerModeDoze(perform_cb _hidl_cb) { + int32_t error = intf_->UpdateVSyncSourceOnPowerModeDoze(); + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseSetPowerMode(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct PowerModeParams *set_power_mode_data; + + const uint8_t *data = input_params.data(); + set_power_mode_data = reinterpret_cast(data); + int32_t error = intf_->SetPowerMode(set_power_mode_data->disp_id, + set_power_mode_data->power_mode); + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseIsPowerModeOverrideSupported( + const ByteStream &input_params, + perform_cb _hidl_cb) { + const uint32_t *disp_id; + bool supported = false; + ByteStream output_params; + + const uint8_t *data = input_params.data(); + disp_id = reinterpret_cast(data); + int32_t error = intf_->IsPowerModeOverrideSupported(*disp_id, &supported); + output_params.setToExternal(reinterpret_cast(&supported), + sizeof(bool)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseIsHdrSupported(const ByteStream &input_params, + perform_cb _hidl_cb) { + const uint32_t *disp_id; + bool supported; + ByteStream output_params; + + const uint8_t *data = input_params.data(); + disp_id = reinterpret_cast(data); + int32_t error = intf_->IsHDRSupported(*disp_id, &supported); + output_params.setToExternal(reinterpret_cast(&supported), + sizeof(bool)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseIsWcgSupported(const ByteStream &input_params, + perform_cb _hidl_cb) { + const int32_t *disp_id; + bool supported = false; + ByteStream output_params; + + const uint8_t *data = input_params.data(); + disp_id = reinterpret_cast(data); + int32_t error = intf_->IsWCGSupported(*disp_id, &supported); + output_params.setToExternal(reinterpret_cast(&supported), + sizeof(bool)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseSetLayerAsMask(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct LayerMaskParams *layer_mask_data; + + const uint8_t *data = input_params.data(); + layer_mask_data = reinterpret_cast(data); + int32_t error = intf_->SetLayerAsMask(layer_mask_data->disp_id, layer_mask_data->layer_id); + + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseGetDebugProperty(const ByteStream &input_params, + perform_cb _hidl_cb) { + std::string value; + ByteStream output_params; + + const uint8_t *data = input_params.data(); + const char *name = reinterpret_cast(data); + std::string prop_name(name); + int32_t error = intf_->GetDebugProperty(prop_name, value); + uint8_t *data_output = reinterpret_cast(value.data()); + output_params.setToExternal(reinterpret_cast(&data_output), + value.size() * sizeof(char)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseGetActiveBuiltinDisplayAttributes(perform_cb _hidl_cb) { + struct Attributes attr; + ByteStream output_params; + + int32_t error = intf_->GetActiveBuiltinDisplayAttributes(&attr); + output_params.setToExternal(reinterpret_cast(&attr), sizeof(Attributes)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseSetPanelLuminanceAttributes( + const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct PanelLumAttrParams *panel_lum_attr_data; + + const uint8_t *data = input_params.data(); + panel_lum_attr_data = reinterpret_cast(data); + int32_t error = intf_->SetPanelLuminanceAttributes(panel_lum_attr_data->disp_id, + panel_lum_attr_data->min_lum, + panel_lum_attr_data->max_lum); + + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseIsBuiltinDisplay(const ByteStream &input_params, + perform_cb _hidl_cb) { + const uint32_t *disp_id; + bool is_builtin = false; + ByteStream output_params; + + const uint8_t *data = input_params.data(); + disp_id = reinterpret_cast(data); + int32_t error = intf_->IsBuiltInDisplay(*disp_id, &is_builtin); + output_params.setToExternal(reinterpret_cast(&is_builtin), + sizeof(bool)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseSetCwbOutputBuffer(uint64_t clientHandle, + const ByteStream &input_params, + const HandleStream &input_handles, + perform_cb _hidl_cb) { + const struct CwbBufferParams *cwb_buffer_data; + + const uint8_t *data = input_params.data(); + cwb_buffer_data = reinterpret_cast(data); + hidl_handle buffer = input_handles[0]; + + if (!callback_ || !buffer.getNativeHandle()) { + _hidl_cb(-1, {}, {}); + return; + } + + int32_t error = intf_->SetCWBOutputBuffer(cwb_buffer_data->disp_id , cwb_buffer_data->rect, + cwb_buffer_data->post_processed, + buffer.getNativeHandle()); + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseGetSupportedDsiBitclks(const ByteStream &input_params, + perform_cb _hidl_cb) { + const uint32_t *disp_id; + ByteStream output_params; + std::vector bit_clks; + uint64_t *bit_clks_data; + + const uint8_t *data = input_params.data(); + disp_id = reinterpret_cast(data); + int32_t error = intf_->GetSupportedDSIBitClks(*disp_id, bit_clks); + + bit_clks_data = reinterpret_cast(malloc(sizeof(uint64_t) * bit_clks.size())); + for (int i = 0; i < bit_clks.size(); i++) { + bit_clks_data[i] = bit_clks[i]; + } + output_params.setToExternal(reinterpret_cast(bit_clks_data), + sizeof(uint64_t) * bit_clks.size()); + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseGetDsiClk(const ByteStream &input_params, + perform_cb _hidl_cb) { + const uint32_t *disp_id; + uint64_t bit_clk = 0; + ByteStream output_params; + + const uint8_t *data = input_params.data(); + disp_id = reinterpret_cast(data); + int32_t error = intf_->GetDSIClk(*disp_id, &bit_clk); + output_params.setToExternal(reinterpret_cast(&bit_clk), + sizeof(uint64_t)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseSetDsiClk(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct DsiClkParams *set_dsi_clk_data; + + const uint8_t *data = input_params.data(); + set_dsi_clk_data = reinterpret_cast(data); + int32_t error = intf_->SetDSIClk(set_dsi_clk_data->disp_id, set_dsi_clk_data->bit_clk); + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseSetQsyncMode(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct QsyncModeParams *set_qsync_mode_data; + + const uint8_t *data = input_params.data(); + set_qsync_mode_data = reinterpret_cast(data); + int32_t error = intf_->SetQsyncMode(set_qsync_mode_data->disp_id, set_qsync_mode_data->mode); + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseIsSmartPanelConfig(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct SmartPanelCfgParams *smart_panel_cfg_data; + bool is_smart = false; + ByteStream output_params; + + const uint8_t *data = input_params.data(); + smart_panel_cfg_data = reinterpret_cast(data); + int32_t error = intf_->IsSmartPanelConfig(smart_panel_cfg_data->disp_id, + smart_panel_cfg_data->config_id, &is_smart); + output_params.setToExternal(reinterpret_cast(&is_smart), + sizeof(bool)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseIsAsyncVdsSupported(perform_cb _hidl_cb) { + bool is_supported; + ByteStream output_params; + + int32_t error = intf_->IsAsyncVDSCreationSupported(&is_supported); + output_params.setToExternal(reinterpret_cast(&is_supported), + sizeof(bool)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseCreateVirtualDisplay(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct VdsParams *vds_input_data; + + const uint8_t *data = input_params.data(); + vds_input_data = reinterpret_cast(data); + + int32_t error = intf_->CreateVirtualDisplay(vds_input_data->width, vds_input_data->height, + vds_input_data->format); + + _hidl_cb(error, {}, {}); +} + +void DeviceImpl::DeviceClientContext::ParseIsRotatorSupportedFormat(const ByteStream &input_params, + perform_cb _hidl_cb) { + const struct RotatorFormatParams *input_data; + bool supported = false; + ByteStream output_params; + + const uint8_t *data = input_params.data(); + input_data = reinterpret_cast(data); + int32_t error = intf_->IsRotatorSupportedFormat(input_data->hal_format, input_data->ubwc, + &supported); + output_params.setToExternal(reinterpret_cast(&supported), + sizeof(bool)); + + _hidl_cb(error, output_params, {}); +} + +void DeviceImpl::DeviceClientContext::ParseControlQsyncCallback(uint64_t client_handle, + const ByteStream &input_params, + perform_cb _hidl_cb) { + const bool *enable; + + const uint8_t *data = input_params.data(); + enable = reinterpret_cast(data); + + int32_t error = intf_->ControlQsyncCallback(*enable); + + _hidl_cb(error, {}, {}); +} + +Return DeviceImpl::perform(uint64_t client_handle, uint32_t op_code, + const ByteStream &input_params, const HandleStream &input_handles, + perform_cb _hidl_cb) { + int32_t error = 0; + auto itr = display_config_map_.find(client_handle); + if (itr == display_config_map_.end()) { + error = -EINVAL; + _hidl_cb(error, {}, {}); + return Void(); + } + + std::shared_ptr client = itr->second; + switch (op_code) { + case kIsDisplayConnected: + client->ParseIsDisplayConnected(input_params, _hidl_cb); + break; + case kSetDisplayStatus: + client->ParseSetDisplayStatus(input_params, _hidl_cb); + break; + case kConfigureDynRefreshRate: + client->ParseConfigureDynRefreshRate(input_params, _hidl_cb); + break; + case kGetConfigCount: + client->ParseGetConfigCount(input_params, _hidl_cb); + break; + case kGetActiveConfig: + client->ParseGetActiveConfig(input_params, _hidl_cb); + break; + case kSetActiveConfig: + client->ParseSetActiveConfig(input_params, _hidl_cb); + break; + case kGetDisplayAttributes: + client->ParseGetDisplayAttributes(input_params, _hidl_cb); + break; + case kSetPanelBrightness: + client->ParseSetPanelBrightness(input_params, _hidl_cb); + break; + case kGetPanelBrightness: + client->ParseGetPanelBrightness(_hidl_cb); + break; + case kMinHdcpEncryptionLevelChanged: + client->ParseMinHdcpEncryptionLevelChanged(input_params, _hidl_cb); + break; + case kRefreshScreen: + client->ParseRefreshScreen(_hidl_cb); + break; + case kControlPartialUpdate: + client->ParseControlPartialUpdate(input_params, _hidl_cb); + break; + case kToggleScreenUpdate: + client->ParseToggleScreenUpdate(input_params, _hidl_cb); + break; + case kSetIdleTimeout: + client->ParseSetIdleTimeout(input_params, _hidl_cb); + break; + case kGetHdrCapabilities: + client->ParseGetHdrCapabilities(input_params, _hidl_cb); + break; + case kSetCameraLaunchStatus: + client->ParseSetCameraLaunchStatus(input_params, _hidl_cb); + break; + case kDisplayBwTransactionPending: + client->ParseDisplayBwTransactionPending(_hidl_cb); + break; + case kSetDisplayAnimating: + client->ParseSetDisplayAnimating(input_params, _hidl_cb); + break; + case kControlIdlePowerCollapse: + client->ParseControlIdlePowerCollapse(input_params, _hidl_cb); + break; + case kGetWritebackCapabilities: + client->ParseGetWritebackCapabilities(_hidl_cb); + break; + case kSetDisplayDppsAdRoi: + client->ParseSetDisplayDppsAdRoi(input_params, _hidl_cb); + break; + case kUpdateVsyncSourceOnPowerModeOff: + client->ParseUpdateVsyncSourceOnPowerModeOff(_hidl_cb); + break; + case kUpdateVsyncSourceOnPowerModeDoze: + client->ParseUpdateVsyncSourceOnPowerModeDoze(_hidl_cb); + break; + case kSetPowerMode: + client->ParseSetPowerMode(input_params, _hidl_cb); + break; + case kIsPowerModeOverrideSupported: + client->ParseIsPowerModeOverrideSupported(input_params, _hidl_cb); + break; + case kIsHdrSupported: + client->ParseIsHdrSupported(input_params, _hidl_cb); + break; + case kIsWcgSupported: + client->ParseIsWcgSupported(input_params, _hidl_cb); + break; + case kSetLayerAsMask: + client->ParseSetLayerAsMask(input_params, _hidl_cb); + break; + case kGetDebugProperty: + client->ParseGetDebugProperty(input_params, _hidl_cb); + break; + case kGetActiveBuiltinDisplayAttributes: + client->ParseGetActiveBuiltinDisplayAttributes(_hidl_cb); + break; + case kSetPanelLuminanceAttributes: + client->ParseSetPanelLuminanceAttributes(input_params, _hidl_cb); + break; + case kIsBuiltinDisplay: + client->ParseIsBuiltinDisplay(input_params, _hidl_cb); + break; + case kSetCwbOutputBuffer: + client->ParseSetCwbOutputBuffer(client_handle, input_params, input_handles, _hidl_cb); + break; + case kGetSupportedDsiBitclks: + client->ParseGetSupportedDsiBitclks(input_params, _hidl_cb); + break; + case kGetDsiClk: + client->ParseGetDsiClk(input_params, _hidl_cb); + break; + case kSetDsiClk: + client->ParseSetDsiClk(input_params, _hidl_cb); + break; + case kSetQsyncMode: + client->ParseSetQsyncMode(input_params, _hidl_cb); + break; + case kIsSmartPanelConfig: + client->ParseIsSmartPanelConfig(input_params, _hidl_cb); + break; + case kIsAsyncVdsSupported: + client->ParseIsAsyncVdsSupported(_hidl_cb); + break; + case kCreateVirtualDisplay: + client->ParseCreateVirtualDisplay(input_params, _hidl_cb); + break; + case kIsRotatorSupportedFormat: + client->ParseIsRotatorSupportedFormat(input_params, _hidl_cb); + break; + case kControlQsyncCallback: + client->ParseControlQsyncCallback(client_handle, input_params, _hidl_cb); + break; + default: + break; + } + return Void(); +} + +} // namespace DisplayConfig diff --git a/services/config/src/device_impl.h b/services/config/src/device_impl.h new file mode 100644 index 00000000..96e93511 --- /dev/null +++ b/services/config/src/device_impl.h @@ -0,0 +1,141 @@ +/* +* 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 __DEVICE_IMPL_H__ +#define __DEVICE_IMPL_H__ + +#include +#include + +#include +#include +#include +#include +#include + +#include "opcode_types.h" + +namespace DisplayConfig { + +using vendor::display::config::V2_0::IDisplayConfig; +using vendor::display::config::V2_0::IDisplayConfigCallback; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::hidl_handle; +using ::android::hardware::hidl_string; +using ::android::hardware::hidl_vec; +using ::android::sp; + +typedef hidl_vec ByteStream; +typedef hidl_vec HandleStream; + +class DeviceImpl : public IDisplayConfig, public android::hardware::hidl_death_recipient { + public: + static int CreateInstance(ClientContext *intf); + + private: + class DeviceClientContext : public ConfigCallback { + public: + explicit DeviceClientContext(const sp callback); + + void SetDeviceConfigIntf(ConfigInterface *intf); + ConfigInterface* GetDeviceConfigIntf(); + + virtual void NotifyCWBBufferDone(int32_t error, const native_handle_t *buffer); + virtual void NotifyQsyncChange(bool qsync_enabled, int32_t refresh_rate, + int32_t qsync_refresh_rate); + + void ParseIsDisplayConnected(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseSetDisplayStatus(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseConfigureDynRefreshRate(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseGetConfigCount(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseGetActiveConfig(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseSetActiveConfig(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseGetDisplayAttributes(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseSetPanelBrightness(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseGetPanelBrightness(perform_cb _hidl_cb); + void ParseMinHdcpEncryptionLevelChanged(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseRefreshScreen(perform_cb _hidl_cb); + void ParseControlPartialUpdate(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseToggleScreenUpdate(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseSetIdleTimeout(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseGetHdrCapabilities(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseSetCameraLaunchStatus(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseDisplayBwTransactionPending(perform_cb _hidl_cb); + void ParseSetDisplayAnimating(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseControlIdlePowerCollapse(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseGetWritebackCapabilities(perform_cb _hidl_cb); + void ParseSetDisplayDppsAdRoi(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseUpdateVsyncSourceOnPowerModeOff(perform_cb _hidl_cb); + void ParseUpdateVsyncSourceOnPowerModeDoze(perform_cb _hidl_cb); + void ParseSetPowerMode(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseIsPowerModeOverrideSupported(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseIsHdrSupported(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseIsWcgSupported(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseSetLayerAsMask(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseGetDebugProperty(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseGetActiveBuiltinDisplayAttributes(perform_cb _hidl_cb); + void ParseSetPanelLuminanceAttributes(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseIsBuiltinDisplay(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseSetCwbOutputBuffer(uint64_t clientHandle, const ByteStream &input_params, + const HandleStream &inputHandles, perform_cb _hidl_cb); + void ParseGetSupportedDsiBitclks(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseGetDsiClk(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseSetDsiClk(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseSetQsyncMode(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseIsSmartPanelConfig(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseIsAsyncVdsSupported(perform_cb _hidl_cb); + void ParseCreateVirtualDisplay(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseIsRotatorSupportedFormat(const ByteStream &input_params, perform_cb _hidl_cb); + void ParseControlQsyncCallback(uint64_t client_handle, const ByteStream &input_params, + perform_cb _hidl_cb); + + private: + ConfigInterface *intf_ = nullptr; + sp callback_; + }; + + Return registerClient(const hidl_string &client_name, const sp& cb, + registerClient_cb _hidl_cb) override; + Return perform(uint64_t client_handle, uint32_t op_code, const ByteStream &input_params, + const HandleStream &input_handles, perform_cb _hidl_cb) override; + void serviceDied(uint64_t client_handle, + const android::wp<::android::hidl::base::V1_0::IBase>& callback); + + ClientContext *intf_ = nullptr; + std::map> display_config_map_; + uint64_t client_id_ = 0; + std::mutex death_service_mutex_; + static DeviceImpl *device_obj_; + static std::mutex device_lock_; +}; + +} // namespace DisplayConfig + +#endif // __DEVICE_IMPL_H__ diff --git a/services/config/src/device_interface.cpp b/services/config/src/device_interface.cpp new file mode 100644 index 00000000..0c2d6b73 --- /dev/null +++ b/services/config/src/device_interface.cpp @@ -0,0 +1,42 @@ +/* +* 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. +*/ + +#include "device_impl.h" + +namespace DisplayConfig { + +int DeviceInterface::RegisterDevice(ClientContext *intf) { + if (!intf) { + return -1; + } + + return DeviceImpl::CreateInstance(intf); +} + +} // namespace DisplayConfig diff --git a/services/config/src/opcode_types.h b/services/config/src/opcode_types.h new file mode 100644 index 00000000..1b28105e --- /dev/null +++ b/services/config/src/opcode_types.h @@ -0,0 +1,82 @@ +/* +* 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 __OPCODE_TYPES_H__ +#define __OPCODE_TYPES_H__ + +namespace DisplayConfig { + +enum OpCode { + kIsDisplayConnected = 0, + kSetDisplayStatus = 1, + kConfigureDynRefreshRate = 2, + kGetConfigCount = 3, + kGetActiveConfig = 4, + kSetActiveConfig = 5, + kGetDisplayAttributes = 6, + kSetPanelBrightness = 7, + kGetPanelBrightness = 8, + kMinHdcpEncryptionLevelChanged = 9, + kRefreshScreen = 10, + kControlPartialUpdate = 11, + kToggleScreenUpdate = 12, + kSetIdleTimeout = 13, + kGetHdrCapabilities = 14, + kSetCameraLaunchStatus = 15, + kDisplayBwTransactionPending = 16, + kSetDisplayAnimating = 17, + kControlIdlePowerCollapse = 18, + kGetWritebackCapabilities = 19, + kSetDisplayDppsAdRoi = 20, + kUpdateVsyncSourceOnPowerModeOff = 21, + kUpdateVsyncSourceOnPowerModeDoze = 22, + kSetPowerMode = 23, + kIsPowerModeOverrideSupported = 24, + kIsHdrSupported = 25, + kIsWcgSupported = 26, + kSetLayerAsMask = 27, + kGetDebugProperty = 28, + kGetActiveBuiltinDisplayAttributes = 29, + kSetPanelLuminanceAttributes = 30, + kIsBuiltinDisplay = 31, + kSetCwbOutputBuffer = 32, + kGetSupportedDsiBitclks = 33, + kGetDsiClk = 34, + kSetDsiClk = 35, + kSetQsyncMode = 36, + kIsSmartPanelConfig = 37, + kIsAsyncVdsSupported = 38, + kCreateVirtualDisplay = 39, + kIsRotatorSupportedFormat = 40, + kControlQsyncCallback = 41, +}; + +} // namespace DisplayConfig + +#endif // __OPCODE_TYPES_H__