hwc2: add support for IDisplayConfig 2.0
Adapt hardware composer's device implementation to
IDisplayConfig 2.0 version.
Change-Id: I950e4400a9cac216a11b99ea081e739f644ad15e
CRs-Fixed: 2692007
diff --git a/config/display-product.mk b/config/display-product.mk
index 9366c89..522afef 100644
--- a/config/display-product.mk
+++ b/config/display-product.mk
@@ -15,6 +15,7 @@
memtrack.$(TARGET_BOARD_PLATFORM) \
libqdMetaData.vendor \
libdisplayconfig.vendor \
+ libdisplayconfig.qti.vendor \
vendor.display.config@1.0.vendor \
vendor.display.config@1.1.vendor \
vendor.display.config@1.2.vendor \
@@ -26,6 +27,7 @@
vendor.display.config@1.8.vendor \
vendor.display.config@1.9.vendor \
vendor.display.config@1.10.vendor \
+ vendor.display.config@2.0.vendor \
vendor.qti.hardware.display.mapper@3.0 \
vendor.qti.hardware.display.mapper@4.0.vendor \
modetest
diff --git a/sdm/libs/hwc2/Android.mk b/sdm/libs/hwc2/Android.mk
index b011642..9416708 100644
--- a/sdm/libs/hwc2/Android.mk
+++ b/sdm/libs/hwc2/Android.mk
@@ -21,7 +21,7 @@
LOCAL_SHARED_LIBRARIES := libsdmcore libqservice libbinder libhardware libhardware_legacy \
libutils libcutils libsync libqdutils libqdMetaData \
libdisplaydebug libsdmutils libc++ liblog libgrallocutils libui \
- libgpu_tonemapper libhidlbase libhidltransport \
+ libgpu_tonemapper libhidlbase libhidltransport libdisplayconfig.qti \
android.hardware.graphics.mapper@2.0 \
android.hardware.graphics.mapper@2.1 \
android.hardware.graphics.mapper@3.0 \
@@ -40,7 +40,8 @@
vendor.display.config@1.8 \
vendor.display.config@1.9 \
vendor.display.config@1.10 \
- vendor.display.config@1.11
+ vendor.display.config@1.11 \
+ vendor.display.config@2.0
ifeq ($(TARGET_BOARD_AUTO), true)
LOCAL_CFLAGS += -DCONFIG_BASEID_FROM_PROP
diff --git a/sdm/libs/hwc2/android.hardware.graphics.composer-qti-display.xml b/sdm/libs/hwc2/android.hardware.graphics.composer-qti-display.xml
index 1fda637..8cea3e3 100644
--- a/sdm/libs/hwc2/android.hardware.graphics.composer-qti-display.xml
+++ b/sdm/libs/hwc2/android.hardware.graphics.composer-qti-display.xml
@@ -39,7 +39,7 @@
<hal format="hidl">
<name>vendor.display.config</name>
<transport>hwbinder</transport>
- <version>1.11</version>
+ <version>2.0</version>
<interface>
<name>IDisplayConfig</name>
<instance>default</instance>
diff --git a/sdm/libs/hwc2/hwc_session.cpp b/sdm/libs/hwc2/hwc_session.cpp
index c9bdf7b..738f97e 100644
--- a/sdm/libs/hwc2/hwc_session.cpp
+++ b/sdm/libs/hwc2/hwc_session.cpp
@@ -1446,7 +1446,7 @@
DLOGE("QService command = %d: input_parcel needed.", command);
break;
}
- status = setIdleTimeout(UINT32(input_parcel->readInt32()));
+ status = SetIdleTimeout(UINT32(input_parcel->readInt32()));
break;
case qService::IQService::SET_FRAME_DUMP_CONFIG:
@@ -1481,7 +1481,7 @@
int disp_id = INT(input_parcel->readInt32());
HWCDisplay::DisplayStatus disp_status =
static_cast<HWCDisplay::DisplayStatus>(input_parcel->readInt32());
- status = SetSecondaryDisplayStatus(disp_id, disp_status);
+ status = SetDisplayStatus(disp_id, disp_status);
output_parcel->writeInt32(status);
}
break;
@@ -1504,7 +1504,7 @@
break;
}
int32_t input = input_parcel->readInt32();
- status = toggleScreenUpdate(input == 1);
+ status = ToggleScreenUpdate(input == 1);
output_parcel->writeInt32(status);
}
break;
@@ -1630,7 +1630,7 @@
break;
}
uint32_t camera_status = UINT32(input_parcel->readInt32());
- status = setCameraLaunchStatus(camera_status);
+ status = SetCameraLaunchStatus(camera_status);
}
break;
@@ -3448,7 +3448,7 @@
auto enable = input_parcel->readInt32();
auto synchronous = input_parcel->readInt32();
- return static_cast<android::status_t>(controlIdlePowerCollapse(enable, synchronous));
+ return static_cast<android::status_t>(ControlIdlePowerCollapse(enable, synchronous));
}
hwc2_display_t HWCSession::GetActiveBuiltinDisplay() {
diff --git a/sdm/libs/hwc2/hwc_session.h b/sdm/libs/hwc2/hwc_session.h
index f056290..e749f7d 100644
--- a/sdm/libs/hwc2/hwc_session.h
+++ b/sdm/libs/hwc2/hwc_session.h
@@ -20,8 +20,8 @@
#ifndef __HWC_SESSION_H__
#define __HWC_SESSION_H__
-#include <vendor/display/config/1.11/IDisplayConfig.h>
-
+#include <cutils/native_handle.h>
+#include <config/device_interface.h>
#include <core/core_interface.h>
#include <utils/locker.h>
#include <qd_utils.h>
@@ -29,6 +29,7 @@
#include <vector>
#include <utility>
#include <map>
+#include <string>
#include "hwc_callbacks.h"
#include "hwc_layers.h"
@@ -45,9 +46,6 @@
namespace sdm {
-using vendor::display::config::V1_11::IDisplayConfig;
-using vendor::display::config::V1_10::IDisplayCWBCallback;
-
using ::android::hardware::Return;
using ::android::hardware::hidl_string;
using android::hardware::hidl_handle;
@@ -55,6 +53,8 @@
int32_t GetDataspaceFromColorMode(ColorMode mode);
+typedef DisplayConfig::DisplayType DispType;
+
// Create a singleton uevent listener thread valid for life of hardware composer process.
// This thread blocks on uevents poll inside uevent library implementation. This poll exits
// only when there is a valid uevent, it can not be interrupted otherwise. Tieing life cycle
@@ -84,8 +84,8 @@
constexpr int32_t kDataspaceSaturationPropertyElements = 9;
constexpr int32_t kPropertyMax = 256;
-class HWCSession : hwc2_device_t, HWCUEventListener, IDisplayConfig, public qClient::BnQClient,
- public HWCDisplayEventHandler {
+class HWCSession : hwc2_device_t, HWCUEventListener, public qClient::BnQClient,
+ public HWCDisplayEventHandler, public DisplayConfig::ClientContext {
public:
struct HWCModuleMethods : public hw_module_methods_t {
HWCModuleMethods() { hw_module_methods_t::open = HWCSession::Open; }
@@ -219,6 +219,10 @@
hwc_vsync_period_change_constraints_t *vsync_period_change_constraints,
hwc_vsync_period_change_timeline_t *out_timeline);
+ virtual int RegisterClientContext(std::shared_ptr<DisplayConfig::ConfigCallback> callback,
+ DisplayConfig::ConfigInterface **intf);
+ virtual void UnRegisterClientContext(DisplayConfig::ConfigInterface *intf);
+
// HWCDisplayEventHandler
virtual void DisplayPowerReset();
@@ -232,6 +236,59 @@
static Locker display_config_locker_;
private:
+
+ class DisplayConfigImpl: public DisplayConfig::ConfigInterface {
+ public:
+ explicit DisplayConfigImpl(std::weak_ptr<DisplayConfig::ConfigCallback> callback,
+ HWCSession *hwc_session);
+
+ private:
+ virtual int IsDisplayConnected(DispType dpy, bool *connected);
+ virtual int SetDisplayStatus(DispType dpy, DisplayConfig::ExternalStatus status);
+ virtual int ConfigureDynRefreshRate(DisplayConfig::DynRefreshRateOp op, uint32_t refresh_rate);
+ virtual int GetConfigCount(DispType dpy, uint32_t *count);
+ virtual int GetActiveConfig(DispType dpy, uint32_t *config);
+ virtual int SetActiveConfig(DispType dpy, uint32_t config);
+ virtual int GetDisplayAttributes(uint32_t config_index, DispType dpy,
+ DisplayConfig::Attributes *attributes);
+ virtual int SetPanelBrightness(uint32_t level);
+ virtual int GetPanelBrightness(uint32_t *level);
+ virtual int MinHdcpEncryptionLevelChanged(DispType dpy, uint32_t min_enc_level);
+ virtual int RefreshScreen();
+ virtual int ControlPartialUpdate(DispType dpy, bool enable);
+ virtual int ToggleScreenUpdate(bool on);
+ virtual int SetIdleTimeout(uint32_t value);
+ virtual int GetHDRCapabilities(DispType dpy, DisplayConfig::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, DisplayConfig::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(DisplayConfig::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 GetSupportedDSIBitClks(uint32_t disp_id, std::vector<uint64_t> 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 DisplayConfig::Rect rect,
+ bool post_processed, const native_handle_t *buffer);
+ virtual int SetQsyncMode(uint32_t disp_id, DisplayConfig::QsyncMode mode);
+
+ std::weak_ptr<DisplayConfig::ConfigCallback> callback_;
+ HWCSession *hwc_session_ = nullptr;
+ };
+
struct DisplayMapInfo {
hwc2_display_t client_id = HWCCallbacks::kNumDisplays; // mapped sf id for this display
int32_t sdm_id = -1; // sdm id for this display
@@ -272,14 +329,21 @@
void DestroyPluggableDisplay(DisplayMapInfo *map_info);
void DestroyNonPluggableDisplay(DisplayMapInfo *map_info);
int GetVsyncPeriod(int disp);
- int32_t GetConfigCount(int disp_id, uint32_t *count);
- int32_t GetActiveConfigIndex(int disp_id, uint32_t *config);
- int32_t SetActiveConfigIndex(int disp_id, uint32_t config);
- int32_t ControlPartialUpdate(int dpy, bool enable);
- int32_t DisplayBWTransactionPending(bool *status);
- int32_t SetSecondaryDisplayStatus(int disp_id, HWCDisplay::DisplayStatus status);
- int32_t MinHdcpEncryptionLevelChanged(int disp_id, uint32_t min_enc_level);
- int32_t IsWbUbwcSupported(int *value);
+ int GetConfigCount(int disp_id, uint32_t *count);
+ int GetActiveConfigIndex(int disp_id, uint32_t *config);
+ int SetActiveConfigIndex(int disp_id, uint32_t config);
+ int ControlPartialUpdate(int dpy, bool enable);
+ int DisplayBWTransactionPending(bool *status);
+ int SetDisplayStatus(int disp_id, HWCDisplay::DisplayStatus status);
+ int MinHdcpEncryptionLevelChanged(int disp_id, uint32_t min_enc_level);
+ int IsWbUbwcSupported(bool *value);
+ int SetIdleTimeout(uint32_t value);
+ int ToggleScreenUpdate(bool on);
+ int SetCameraLaunchStatus(uint32_t on);
+ 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);
+ int ControlIdlePowerCollapse(bool enable, bool synchronous);
int32_t SetDynamicDSIClock(int64_t disp_id, uint32_t bitrate);
bool HasHDRSupport(HWCDisplay *hwc_display);
int32_t getDisplayBrightness(uint32_t display, float *brightness);
@@ -288,62 +352,6 @@
// service methods
void StartServices();
- // Methods from ::android::hardware::display::config::V1_0::IDisplayConfig follow.
- Return<void> isDisplayConnected(IDisplayConfig::DisplayType dpy,
- isDisplayConnected_cb _hidl_cb) override;
- Return<int32_t> setSecondayDisplayStatus(IDisplayConfig::DisplayType dpy,
- IDisplayConfig::DisplayExternalStatus status) override;
- Return<int32_t> configureDynRefeshRate(IDisplayConfig::DisplayDynRefreshRateOp op,
- uint32_t refreshRate) override;
- Return<void> getConfigCount(IDisplayConfig::DisplayType dpy,
- getConfigCount_cb _hidl_cb) override;
- Return<void> getActiveConfig(IDisplayConfig::DisplayType dpy,
- getActiveConfig_cb _hidl_cb) override;
- Return<int32_t> setActiveConfig(IDisplayConfig::DisplayType dpy, uint32_t config) override;
- Return<void> getDisplayAttributes(uint32_t configIndex, IDisplayConfig::DisplayType dpy,
- getDisplayAttributes_cb _hidl_cb) override;
- Return<int32_t> setPanelBrightness(uint32_t level) override;
- Return<void> getPanelBrightness(getPanelBrightness_cb _hidl_cb) override;
- Return<int32_t> minHdcpEncryptionLevelChanged(IDisplayConfig::DisplayType dpy,
- uint32_t min_enc_level) override;
- Return<int32_t> refreshScreen() override;
- Return<int32_t> controlPartialUpdate(IDisplayConfig::DisplayType dpy, bool enable) override;
- Return<int32_t> toggleScreenUpdate(bool on) override;
- Return<int32_t> setIdleTimeout(uint32_t value) override;
- Return<void> getHDRCapabilities(IDisplayConfig::DisplayType dpy,
- getHDRCapabilities_cb _hidl_cb) override;
- Return<int32_t> setCameraLaunchStatus(uint32_t on) override;
- Return<void> displayBWTransactionPending(displayBWTransactionPending_cb _hidl_cb) override;
- Return<int32_t> setDisplayAnimating(uint64_t display_id, bool animating) override;
- Return<int32_t> setDisplayIndex(IDisplayConfig::DisplayTypeExt disp_type,
- uint32_t base, uint32_t count) override;
- Return<int32_t> controlIdlePowerCollapse(bool enable, bool synchronous) override;
- Return<void> getWriteBackCapabilities(getWriteBackCapabilities_cb _hidl_cb) override;
- Return<int32_t> SetDisplayDppsAdROI(uint32_t dispaly_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) override;
- Return<int32_t> updateVSyncSourceOnPowerModeOff() override;
- Return<int32_t> updateVSyncSourceOnPowerModeDoze() override;
- Return<int32_t> setPowerMode(uint32_t disp_id, PowerMode power_mode) override;
- Return<bool> isPowerModeOverrideSupported(uint32_t disp_id) override;
- Return<bool> isHDRSupported(uint32_t disp_id) override;
- Return<bool> isWCGSupported(uint32_t disp_id) override;
- Return<int32_t> setLayerAsMask(uint32_t disp_id, uint64_t layer_id) override;
- Return<void> getDebugProperty(const hidl_string &prop_name,
- getDebugProperty_cb _hidl_cb) override;
- Return<void> getActiveBuiltinDisplayAttributes(getDisplayAttributes_cb _hidl_cb) override;
- Return<int32_t> setPanelLuminanceAttributes(uint32_t disp_id, float min_lum,
- float max_lum) override;
- Return<bool> isBuiltInDisplay(uint32_t disp_id) override;
- Return<void> getSupportedDSIBitClks(uint32_t disp_id,
- getSupportedDSIBitClks_cb _hidl_cb) override;
- Return<uint64_t> getDSIClk(uint32_t disp_id) override;
- Return<int32_t> setDSIClk(uint32_t disp_id, uint64_t bit_clk) override;
- Return<int32_t> setCWBOutputBuffer(const ::android::sp<IDisplayCWBCallback> &callback,
- uint32_t disp_id, const Rect &rect, bool post_processed,
- const hidl_handle& buffer) override;
- Return<int32_t> setQsyncMode(uint32_t disp_id, IDisplayConfig::QsyncMode mode) override;
-
// QClient methods
virtual android::status_t notifyCallback(uint32_t command, const android::Parcel *input_parcel,
android::Parcel *output_parcel);
diff --git a/sdm/libs/hwc2/hwc_session_services.cpp b/sdm/libs/hwc2/hwc_session_services.cpp
index abd2786..1115eb8 100644
--- a/sdm/libs/hwc2/hwc_session_services.cpp
+++ b/sdm/libs/hwc2/hwc_session_services.cpp
@@ -32,6 +32,8 @@
#include <sync/sync.h>
#include <vector>
#include <string>
+#include <errno.h>
+#include <math.h>
#include "hwc_buffer_sync_handler.h"
#include "hwc_session.h"
@@ -41,26 +43,24 @@
namespace sdm {
-using ::android::hardware::Void;
-
void HWCSession::StartServices() {
- android::status_t status = IDisplayConfig::registerAsService();
- if (status != android::OK) {
- DLOGW("Could not register IDisplayConfig as service (%d).", status);
+ int error = DisplayConfig::DeviceInterface::RegisterDevice(this);
+ if (error) {
+ DLOGW("Could not register IDisplayConfig as service (%d).", error);
} else {
DLOGI("IDisplayConfig service registration completed.");
}
}
-int MapDisplayType(IDisplayConfig::DisplayType dpy) {
+int MapDisplayType(DispType dpy) {
switch (dpy) {
- case IDisplayConfig::DisplayType::DISPLAY_PRIMARY:
+ case DispType::kPrimary:
return qdutils::DISPLAY_PRIMARY;
- case IDisplayConfig::DisplayType::DISPLAY_EXTERNAL:
+ case DispType::kExternal:
return qdutils::DISPLAY_EXTERNAL;
- case IDisplayConfig::DisplayType::DISPLAY_VIRTUAL:
+ case DispType::kVirtual:
return qdutils::DISPLAY_VIRTUAL;
default:
@@ -70,18 +70,18 @@
return -EINVAL;
}
-HWCDisplay::DisplayStatus MapExternalStatus(IDisplayConfig::DisplayExternalStatus status) {
+HWCDisplay::DisplayStatus MapExternalStatus(DisplayConfig::ExternalStatus status) {
switch (status) {
- case IDisplayConfig::DisplayExternalStatus::EXTERNAL_OFFLINE:
+ case DisplayConfig::ExternalStatus::kOffline:
return HWCDisplay::kDisplayStatusOffline;
- case IDisplayConfig::DisplayExternalStatus::EXTERNAL_ONLINE:
+ case DisplayConfig::ExternalStatus::kOnline:
return HWCDisplay::kDisplayStatusOnline;
- case IDisplayConfig::DisplayExternalStatus::EXTERNAL_PAUSE:
+ case DisplayConfig::ExternalStatus::kPause:
return HWCDisplay::kDisplayStatusPause;
- case IDisplayConfig::DisplayExternalStatus::EXTERNAL_RESUME:
+ case DisplayConfig::ExternalStatus::kResume:
return HWCDisplay::kDisplayStatusResume;
default:
@@ -91,27 +91,47 @@
return HWCDisplay::kDisplayStatusInvalid;
}
-// Methods from ::vendor::hardware::display::config::V1_0::IDisplayConfig follow.
-Return<void> HWCSession::isDisplayConnected(IDisplayConfig::DisplayType dpy,
- isDisplayConnected_cb _hidl_cb) {
- int32_t error = -EINVAL;
- bool connected = false;
+int HWCSession::RegisterClientContext(std::shared_ptr<DisplayConfig::ConfigCallback> callback,
+ DisplayConfig::ConfigInterface **intf) {
+ if (!intf) {
+ DLOGE("Invalid DisplayConfigIntf location");
+ return -EINVAL;
+ }
+
+ std::weak_ptr<DisplayConfig::ConfigCallback> wp_callback = callback;
+ DisplayConfigImpl *impl = new DisplayConfigImpl(wp_callback, this);
+ *intf = impl;
+
+ return 0;
+}
+
+void HWCSession::UnRegisterClientContext(DisplayConfig::ConfigInterface *intf) {
+ delete static_cast<DisplayConfigImpl *>(intf);
+}
+
+HWCSession::DisplayConfigImpl::DisplayConfigImpl(
+ std::weak_ptr<DisplayConfig::ConfigCallback> callback,
+ HWCSession *hwc_session) {
+ callback_ = callback;
+ hwc_session_ = hwc_session;
+}
+
+int HWCSession::DisplayConfigImpl::IsDisplayConnected(DispType dpy, bool *connected) {
int disp_id = MapDisplayType(dpy);
- int disp_idx = GetDisplayIndex(disp_id);
+ int disp_idx = hwc_session_->GetDisplayIndex(disp_id);
if (disp_idx == -1) {
DLOGE("Invalid display = %d", disp_id);
+ return -EINVAL;
} else {
- SEQUENCE_WAIT_SCOPE_LOCK(locker_[disp_idx]);
- connected = hwc_display_[disp_idx];
- error = 0;
+ SEQUENCE_WAIT_SCOPE_LOCK(hwc_session_->locker_[disp_idx]);
+ *connected = hwc_session_->hwc_display_[disp_idx];
}
- _hidl_cb(error, connected);
- return Void();
+ return 0;
}
-int32_t HWCSession::SetSecondaryDisplayStatus(int disp_id, HWCDisplay::DisplayStatus status) {
+int HWCSession::SetDisplayStatus(int disp_id, HWCDisplay::DisplayStatus status) {
int disp_idx = GetDisplayIndex(disp_id);
int err = -EINVAL;
if (disp_idx == -1) {
@@ -151,15 +171,15 @@
return err;
}
-Return<int32_t> HWCSession::setSecondayDisplayStatus(IDisplayConfig::DisplayType dpy,
- IDisplayConfig::DisplayExternalStatus status) {
- return SetSecondaryDisplayStatus(MapDisplayType(dpy), MapExternalStatus(status));
+int HWCSession::DisplayConfigImpl::SetDisplayStatus(DispType dpy,
+ DisplayConfig::ExternalStatus status) {
+ return hwc_session_->SetDisplayStatus(MapDisplayType(dpy), MapExternalStatus(status));
}
-Return<int32_t> HWCSession::configureDynRefeshRate(IDisplayConfig::DisplayDynRefreshRateOp op,
- uint32_t refreshRate) {
- SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
- HWCDisplay *hwc_display = hwc_display_[HWC_DISPLAY_PRIMARY];
+int HWCSession::DisplayConfigImpl::ConfigureDynRefreshRate(DisplayConfig::DynRefreshRateOp op,
+ uint32_t refresh_rate) {
+ SEQUENCE_WAIT_SCOPE_LOCK(hwc_session_->locker_[HWC_DISPLAY_PRIMARY]);
+ HWCDisplay *hwc_display = hwc_session_->hwc_display_[HWC_DISPLAY_PRIMARY];
if (!hwc_display) {
DLOGW("Display = %d is not connected.", HWC_DISPLAY_PRIMARY);
@@ -167,14 +187,14 @@
}
switch (op) {
- case IDisplayConfig::DisplayDynRefreshRateOp::DISABLE_METADATA_DYN_REFRESH_RATE:
+ case DisplayConfig::DynRefreshRateOp::kDisableMetadata:
return hwc_display->Perform(HWCDisplayBuiltIn::SET_METADATA_DYN_REFRESH_RATE, false);
- case IDisplayConfig::DisplayDynRefreshRateOp::ENABLE_METADATA_DYN_REFRESH_RATE:
+ case DisplayConfig::DynRefreshRateOp::kEnableMetadata:
return hwc_display->Perform(HWCDisplayBuiltIn::SET_METADATA_DYN_REFRESH_RATE, true);
- case IDisplayConfig::DisplayDynRefreshRateOp::SET_BINDER_DYN_REFRESH_RATE:
- return hwc_display->Perform(HWCDisplayBuiltIn::SET_BINDER_DYN_REFRESH_RATE, refreshRate);
+ case DisplayConfig::DynRefreshRateOp::kSetBinder:
+ return hwc_display->Perform(HWCDisplayBuiltIn::SET_BINDER_DYN_REFRESH_RATE, refresh_rate);
default:
DLOGW("Invalid operation %d", op);
@@ -184,7 +204,7 @@
return 0;
}
-int32_t HWCSession::GetConfigCount(int disp_id, uint32_t *count) {
+int HWCSession::GetConfigCount(int disp_id, uint32_t *count) {
int disp_idx = GetDisplayIndex(disp_id);
if (disp_idx == -1) {
DLOGE("Invalid display = %d", disp_id);
@@ -200,17 +220,11 @@
return -EINVAL;
}
-Return<void> HWCSession::getConfigCount(IDisplayConfig::DisplayType dpy,
- getConfigCount_cb _hidl_cb) {
- uint32_t count = 0;
- int32_t error = GetConfigCount(MapDisplayType(dpy), &count);
-
- _hidl_cb(error, count);
-
- return Void();
+int HWCSession::DisplayConfigImpl::GetConfigCount(DispType dpy, uint32_t *count) {
+ return hwc_session_->GetConfigCount(MapDisplayType(dpy), count);
}
-int32_t HWCSession::GetActiveConfigIndex(int disp_id, uint32_t *config) {
+int HWCSession::GetActiveConfigIndex(int disp_id, uint32_t *config) {
int disp_idx = GetDisplayIndex(disp_id);
if (disp_idx == -1) {
DLOGE("Invalid display = %d", disp_id);
@@ -226,17 +240,11 @@
return -EINVAL;
}
-Return<void> HWCSession::getActiveConfig(IDisplayConfig::DisplayType dpy,
- getActiveConfig_cb _hidl_cb) {
- uint32_t config = 0;
- int32_t error = GetActiveConfigIndex(MapDisplayType(dpy), &config);
-
- _hidl_cb(error, config);
-
- return Void();
+int HWCSession::DisplayConfigImpl::GetActiveConfig(DispType dpy, uint32_t *config) {
+ return hwc_session_->GetActiveConfigIndex(MapDisplayType(dpy), config);
}
-int32_t HWCSession::SetActiveConfigIndex(int disp_id, uint32_t config) {
+int HWCSession::SetActiveConfigIndex(int disp_id, uint32_t config) {
int disp_idx = GetDisplayIndex(disp_id);
if (disp_idx == -1) {
DLOGE("Invalid display = %d", disp_id);
@@ -244,7 +252,7 @@
}
SEQUENCE_WAIT_SCOPE_LOCK(locker_[disp_idx]);
- int32_t error = -EINVAL;
+ int error = -EINVAL;
if (hwc_display_[disp_idx]) {
error = hwc_display_[disp_idx]->SetActiveDisplayConfig(config);
if (!error) {
@@ -255,69 +263,69 @@
return error;
}
-Return<int32_t> HWCSession::setActiveConfig(IDisplayConfig::DisplayType dpy, uint32_t config) {
- return SetActiveConfigIndex(MapDisplayType(dpy), config);
+int HWCSession::DisplayConfigImpl::SetActiveConfig(DispType dpy, uint32_t config) {
+ return hwc_session_->SetActiveConfigIndex(MapDisplayType(dpy), config);
}
-Return<void> HWCSession::getDisplayAttributes(uint32_t configIndex,
- IDisplayConfig::DisplayType dpy,
- getDisplayAttributes_cb _hidl_cb) {
- int32_t error = -EINVAL;
- IDisplayConfig::DisplayAttributes display_attributes = {};
+int HWCSession::DisplayConfigImpl::GetDisplayAttributes(uint32_t config_index, DispType dpy,
+ DisplayConfig::Attributes *attributes) {
+ int error = -EINVAL;
+
int disp_id = MapDisplayType(dpy);
- int disp_idx = GetDisplayIndex(disp_id);
+ int disp_idx = hwc_session_->GetDisplayIndex(disp_id);
if (disp_idx == -1) {
DLOGE("Invalid display = %d", disp_id);
} else {
- SEQUENCE_WAIT_SCOPE_LOCK(locker_[disp_idx]);
- if (hwc_display_[disp_idx]) {
+ SEQUENCE_WAIT_SCOPE_LOCK(hwc_session_->locker_[disp_idx]);
+ if (hwc_session_->hwc_display_[disp_idx]) {
DisplayConfigVariableInfo var_info;
- error = hwc_display_[disp_idx]->GetDisplayAttributesForConfig(INT(configIndex), &var_info);
+ error = hwc_session_->hwc_display_[disp_idx]->GetDisplayAttributesForConfig(INT(config_index),
+ &var_info);
if (!error) {
- display_attributes.vsyncPeriod = var_info.vsync_period_ns;
- display_attributes.xRes = var_info.x_pixels;
- display_attributes.yRes = var_info.y_pixels;
- display_attributes.xDpi = var_info.x_dpi;
- display_attributes.yDpi = var_info.y_dpi;
- display_attributes.panelType = IDisplayConfig::DisplayPortType::DISPLAY_PORT_DEFAULT;
- display_attributes.isYuv = var_info.is_yuv;
+ attributes->vsync_period = var_info.vsync_period_ns;
+ attributes->x_res = var_info.x_pixels;
+ attributes->y_res = var_info.y_pixels;
+ attributes->x_dpi = var_info.x_dpi;
+ attributes->y_dpi = var_info.y_dpi;
+ attributes->panel_type = DisplayConfig::DisplayPortType::kDefault;
+ attributes->is_yuv = var_info.is_yuv;
}
}
}
- _hidl_cb(error, display_attributes);
- return Void();
+ return error;
}
-Return<int32_t> HWCSession::setPanelBrightness(uint32_t level) {
+int HWCSession::DisplayConfigImpl::SetPanelBrightness(uint32_t level) {
if (!(0 <= level && level <= 255)) {
return -EINVAL;
}
- hwc2_device_t *device = static_cast<hwc2_device_t *>(this);
+ hwc2_device_t *device = static_cast<hwc2_device_t *>(hwc_session_);
if (level == 0) {
- return INT32(SetDisplayBrightness(device, HWC_DISPLAY_PRIMARY, -1.0f));
+ return INT32(hwc_session_->SetDisplayBrightness(device, HWC_DISPLAY_PRIMARY, -1.0f));
} else {
- return INT32(SetDisplayBrightness(device, HWC_DISPLAY_PRIMARY, (level - 1)/254.0f));
+ return INT32(hwc_session_->SetDisplayBrightness(device, HWC_DISPLAY_PRIMARY,
+ (level - 1)/254.0f));
}
}
-Return<void> HWCSession::getPanelBrightness(getPanelBrightness_cb _hidl_cb) {
+int HWCSession::DisplayConfigImpl::GetPanelBrightness(uint32_t *level) {
float brightness = -1.0f;
int32_t error = -EINVAL;
- error = getDisplayBrightness(HWC_DISPLAY_PRIMARY, &brightness);
+ error = hwc_session_->getDisplayBrightness(HWC_DISPLAY_PRIMARY, &brightness);
if (brightness == -1.0f) {
- _hidl_cb(error, 0);
+ *level = 0;
} else {
- _hidl_cb(error, static_cast<uint32_t>(254.0f*brightness + 1));
+ *level = static_cast<uint32_t>(254.0f*brightness + 1);
}
- return Void();
+ return error;
}
-int32_t HWCSession::MinHdcpEncryptionLevelChanged(int disp_id, uint32_t min_enc_level) {
+int HWCSession::MinHdcpEncryptionLevelChanged(int disp_id, uint32_t min_enc_level) {
DLOGI("Display %d", disp_id);
int disp_idx = GetDisplayIndex(disp_id);
@@ -338,19 +346,18 @@
return -EINVAL;
}
-Return<int32_t> HWCSession::minHdcpEncryptionLevelChanged(IDisplayConfig::DisplayType dpy,
- uint32_t min_enc_level) {
- return MinHdcpEncryptionLevelChanged(MapDisplayType(dpy), min_enc_level);
+int HWCSession::DisplayConfigImpl::MinHdcpEncryptionLevelChanged(DispType dpy,
+ uint32_t min_enc_level) {
+ return hwc_session_->MinHdcpEncryptionLevelChanged(MapDisplayType(dpy), min_enc_level);
}
-Return<int32_t> HWCSession::refreshScreen() {
- SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
- Refresh(HWC_DISPLAY_PRIMARY);
-
+int HWCSession::DisplayConfigImpl::RefreshScreen() {
+ SEQUENCE_WAIT_SCOPE_LOCK(hwc_session_->locker_[HWC_DISPLAY_PRIMARY]);
+ hwc_session_->Refresh(HWC_DISPLAY_PRIMARY);
return 0;
}
-int32_t HWCSession::ControlPartialUpdate(int disp_id, bool enable) {
+int HWCSession::ControlPartialUpdate(int disp_id, bool enable) {
int disp_idx = GetDisplayIndex(disp_id);
if (disp_idx == -1) {
DLOGE("Invalid display = %d", disp_id);
@@ -386,16 +393,16 @@
Refresh(HWC_DISPLAY_PRIMARY);
// Wait until partial update control is complete
- int32_t error = locker_[disp_idx].WaitFinite(kCommitDoneTimeoutMs);
+ int error = locker_[disp_idx].WaitFinite(kCommitDoneTimeoutMs);
return error;
}
-Return<int32_t> HWCSession::controlPartialUpdate(IDisplayConfig::DisplayType dpy, bool enable) {
- return ControlPartialUpdate(MapDisplayType(dpy), enable);
+int HWCSession::DisplayConfigImpl::ControlPartialUpdate(DispType dpy, bool enable) {
+ return hwc_session_->ControlPartialUpdate(MapDisplayType(dpy), enable);
}
-Return<int32_t> HWCSession::toggleScreenUpdate(bool on) {
+int HWCSession::ToggleScreenUpdate(bool on) {
SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
int32_t error = -EINVAL;
@@ -409,7 +416,11 @@
return error;
}
-Return<int32_t> HWCSession::setIdleTimeout(uint32_t value) {
+int HWCSession::DisplayConfigImpl::ToggleScreenUpdate(bool on) {
+ return hwc_session_->ToggleScreenUpdate(on);
+}
+
+int HWCSession::SetIdleTimeout(uint32_t value) {
SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
@@ -421,26 +432,24 @@
return -ENODEV;
}
-Return<void> HWCSession::getHDRCapabilities(IDisplayConfig::DisplayType dpy,
- getHDRCapabilities_cb _hidl_cb) {
- int32_t error = -EINVAL;
- IDisplayConfig::DisplayHDRCapabilities hdr_caps = {};
+int HWCSession::DisplayConfigImpl::SetIdleTimeout(uint32_t value) {
+ return hwc_session_->SetIdleTimeout(value);
+}
+
+int HWCSession::DisplayConfigImpl::GetHDRCapabilities(DispType dpy,
+ DisplayConfig::HDRCapsParams *caps) {
+ int error = -EINVAL;
do {
- if (!_hidl_cb) {
- DLOGE("_hidl_cb callback not provided.");
- break;
- }
-
int disp_id = MapDisplayType(dpy);
- int disp_idx = GetDisplayIndex(disp_id);
+ int disp_idx = hwc_session_->GetDisplayIndex(disp_id);
if (disp_idx == -1) {
DLOGE("Invalid display = %d", disp_id);
break;
}
- SCOPE_LOCK(locker_[disp_id]);
- HWCDisplay *hwc_display = hwc_display_[disp_idx];
+ SCOPE_LOCK(hwc_session_->locker_[disp_id]);
+ HWCDisplay *hwc_display = hwc_session_->hwc_display_[disp_idx];
if (!hwc_display) {
DLOGW("Display = %d is not connected.", disp_idx);
error = -ENODEV;
@@ -463,21 +472,19 @@
}
// query hdr caps
- hdr_caps.supportedHdrTypes.resize(out_num_types);
+ caps->supported_hdr_types.resize(out_num_types);
- if (hwc_display->GetHdrCapabilities(&out_num_types, hdr_caps.supportedHdrTypes.data(),
+ if (hwc_display->GetHdrCapabilities(&out_num_types, caps->supported_hdr_types.data(),
&out_max_luminance, &out_max_average_luminance,
&out_min_luminance) == HWC2::Error::None) {
error = 0;
}
} while (false);
- _hidl_cb(error, hdr_caps);
-
- return Void();
+ return error;
}
-Return<int32_t> HWCSession::setCameraLaunchStatus(uint32_t on) {
+int HWCSession::SetCameraLaunchStatus(uint32_t on) {
hwc2_display_t active_builtin_disp_id = GetActiveBuiltinDisplay();
if (active_builtin_disp_id >= HWCCallbacks::kNumDisplays) {
DLOGE("No active displays");
@@ -515,7 +522,11 @@
return 0;
}
-int32_t HWCSession::DisplayBWTransactionPending(bool *status) {
+int HWCSession::DisplayConfigImpl::SetCameraLaunchStatus(uint32_t on) {
+ return hwc_session_->SetCameraLaunchStatus(on);
+}
+
+int HWCSession::DisplayBWTransactionPending(bool *status) {
SEQUENCE_WAIT_SCOPE_LOCK(locker_[HWC_DISPLAY_PRIMARY]);
if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
@@ -531,32 +542,16 @@
return -ENODEV;
}
-Return<void> HWCSession::displayBWTransactionPending(displayBWTransactionPending_cb _hidl_cb) {
- bool status = true;
-
- if (!_hidl_cb) {
- DLOGE("_hidl_cb callback not provided.");
- return Void();
- }
-
- int32_t error = DisplayBWTransactionPending(&status);
-
- _hidl_cb(error, status);
-
- return Void();
+int HWCSession::DisplayConfigImpl::DisplayBWTransactionPending(bool *status) {
+ return hwc_session_->DisplayBWTransactionPending(status);
}
-Return<int32_t> HWCSession::setDisplayAnimating(uint64_t display_id, bool animating ) {
- return CallDisplayFunction(static_cast<hwc2_device_t *>(this), display_id,
- &HWCDisplay::SetDisplayAnimating, animating);
+int HWCSession::DisplayConfigImpl::SetDisplayAnimating(uint64_t display_id, bool animating) {
+ return hwc_session_->CallDisplayFunction(static_cast<hwc2_device_t *>(hwc_session_), display_id,
+ &HWCDisplay::SetDisplayAnimating, animating);
}
-Return<int32_t> HWCSession::setDisplayIndex(IDisplayConfig::DisplayTypeExt disp_type,
- uint32_t base, uint32_t count) {
- return -1;
-}
-
-Return<int32_t> HWCSession::controlIdlePowerCollapse(bool enable, bool synchronous) {
+int HWCSession::ControlIdlePowerCollapse(bool enable, bool synchronous) {
hwc2_display_t active_builtin_disp_id = GetActiveBuiltinDisplay();
if (active_builtin_disp_id >= HWCCallbacks::kNumDisplays) {
DLOGE("No active displays");
@@ -573,7 +568,7 @@
return (err == kErrorNotSupported) ? 0 : -EINVAL;
}
Refresh(active_builtin_disp_id);
- int32_t error = locker_[active_builtin_disp_id].WaitFinite(kCommitDoneTimeoutMs);
+ int error = locker_[active_builtin_disp_id].WaitFinite(kCommitDoneTimeoutMs);
if (error == ETIMEDOUT) {
DLOGE("Timed out!! Next frame commit done event not received!!");
return error;
@@ -599,7 +594,11 @@
return -ENODEV;
}
-int32_t HWCSession::IsWbUbwcSupported(int *value) {
+int HWCSession::DisplayConfigImpl::ControlIdlePowerCollapse(bool enable, bool synchronous) {
+ return hwc_session_->ControlIdlePowerCollapse(enable, synchronous);
+}
+
+int HWCSession::IsWbUbwcSupported(bool *value) {
HWDisplaysInfo hw_displays_info = {};
DisplayError error = core_intf_->GetDisplaysStatus(&hw_displays_info);
if (error != kErrorNone) {
@@ -616,118 +615,128 @@
return error;
}
-Return<void> HWCSession::getWriteBackCapabilities(getWriteBackCapabilities_cb _hidl_cb) {
- int value = 0;
- IDisplayConfig::WriteBackCapabilities wb_caps = {};
- int32_t error = IsWbUbwcSupported(&value);
- wb_caps.isWbUbwcSupported = value;
- _hidl_cb(error, wb_caps);
-
- return Void();
+int HWCSession::DisplayConfigImpl::GetWriteBackCapabilities(bool *isWbUbwcSupported) {
+ return hwc_session_->IsWbUbwcSupported(isWbUbwcSupported);
}
-Return<int32_t> HWCSession::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) {
+int HWCSession::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) {
return CallDisplayFunction(static_cast<hwc2_device_t *>(this), display_id,
&HWCDisplay::SetDisplayDppsAdROI, h_start, h_end, v_start, v_end,
factor_in, factor_out);
}
-Return<int32_t> HWCSession::updateVSyncSourceOnPowerModeOff() {
+int HWCSession::DisplayConfigImpl::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) {
+ return hwc_session_->SetDisplayDppsAdROI(display_id, h_start, h_end, v_start, v_end,
+ factor_in, factor_out);
+}
+
+int HWCSession::DisplayConfigImpl::UpdateVSyncSourceOnPowerModeOff() {
return 0;
}
-Return<int32_t> HWCSession::updateVSyncSourceOnPowerModeDoze() {
+int HWCSession::DisplayConfigImpl::UpdateVSyncSourceOnPowerModeDoze() {
return 0;
}
-Return<bool> HWCSession::isPowerModeOverrideSupported(uint32_t disp_id) {
- if (!async_powermode_ || (disp_id > HWCCallbacks::kNumRealDisplays)) {
- return false;
+int HWCSession::DisplayConfigImpl::IsPowerModeOverrideSupported(uint32_t disp_id,
+ bool *supported) {
+ if (!hwc_session_->async_powermode_ || (disp_id > HWCCallbacks::kNumRealDisplays)) {
+ *supported = false;
+ } else {
+ *supported = true;
}
- return true;
+ return 0;
}
-Return<int32_t> HWCSession::setPowerMode(uint32_t disp_id, PowerMode power_mode) {
- SCOPE_LOCK(display_config_locker_);
+int HWCSession::DisplayConfigImpl::SetPowerMode(uint32_t disp_id,
+ DisplayConfig::PowerMode power_mode) {
+ SCOPE_LOCK(hwc_session_->display_config_locker_);
- if (!isPowerModeOverrideSupported(disp_id)) {
+ bool supported = false;
+ IsPowerModeOverrideSupported(disp_id, &supported);
+ if (!supported) {
return 0;
}
DLOGI("disp_id: %d power_mode: %d", disp_id, power_mode);
HWCDisplay::HWCLayerStack stack = {};
- hwc2_display_t dummy_disp_id = map_hwc_display_.at(disp_id);
+ hwc2_display_t dummy_disp_id = hwc_session_->map_hwc_display_.at(disp_id);
{
// Power state transition start.
- Locker::ScopeLock lock_power(power_state_[disp_id]);
- Locker::ScopeLock lock_primary(locker_[disp_id]);
- Locker::ScopeLock lock_dummy(locker_[dummy_disp_id]);
+ Locker::ScopeLock lock_power(hwc_session_->power_state_[disp_id]);
+ Locker::ScopeLock lock_primary(hwc_session_->locker_[disp_id]);
+ Locker::ScopeLock lock_dummy(hwc_session_->locker_[dummy_disp_id]);
- power_state_transition_[disp_id] = true;
+ hwc_session_->power_state_transition_[disp_id] = true;
// Pass on the complete stack to dummy display.
- hwc_display_[disp_id]->GetLayerStack(&stack);
+ hwc_session_->hwc_display_[disp_id]->GetLayerStack(&stack);
// Update the same stack onto dummy display.
- hwc_display_[dummy_disp_id]->SetLayerStack(&stack);
+ hwc_session_->hwc_display_[dummy_disp_id]->SetLayerStack(&stack);
}
{
- SCOPE_LOCK(locker_[disp_id]);
+ SCOPE_LOCK(hwc_session_->locker_[disp_id]);
auto mode = static_cast<HWC2::PowerMode>(power_mode);
- hwc_display_[disp_id]->SetPowerMode(mode, false /* teardown */);
+ hwc_session_->hwc_display_[disp_id]->SetPowerMode(mode, false /* teardown */);
}
{
// Power state transition end.
- Locker::ScopeLock lock_power(power_state_[disp_id]);
- Locker::ScopeLock lock_primary(locker_[disp_id]);
- Locker::ScopeLock lock_dummy(locker_[dummy_disp_id]);
+ Locker::ScopeLock lock_power(hwc_session_->power_state_[disp_id]);
+ Locker::ScopeLock lock_primary(hwc_session_->locker_[disp_id]);
+ Locker::ScopeLock lock_dummy(hwc_session_->locker_[dummy_disp_id]);
// Pass on the layer stack to real display.
- hwc_display_[dummy_disp_id]->GetLayerStack(&stack);
+ hwc_session_->hwc_display_[dummy_disp_id]->GetLayerStack(&stack);
// Update the same stack onto real display.
- hwc_display_[disp_id]->SetLayerStack(&stack);
+ hwc_session_->hwc_display_[disp_id]->SetLayerStack(&stack);
// Read display has got layerstack. Update the fences.
- hwc_display_[disp_id]->PostPowerMode();
+ hwc_session_->hwc_display_[disp_id]->PostPowerMode();
- power_state_transition_[disp_id] = false;
+ hwc_session_->power_state_transition_[disp_id] = false;
}
return 0;
}
-Return<bool> HWCSession::isHDRSupported(uint32_t disp_id) {
+int HWCSession::DisplayConfigImpl::IsHDRSupported(uint32_t disp_id, bool *supported) {
if (disp_id < 0 || disp_id >= HWCCallbacks::kNumDisplays) {
DLOGE("Not valid display");
- return false;
+ return -EINVAL;
}
- SCOPE_LOCK(locker_[disp_id]);
+ SCOPE_LOCK(hwc_session_->locker_[disp_id]);
- if (is_hdr_display_.size() <= disp_id) {
+ if (hwc_session_->is_hdr_display_.size() <= disp_id) {
DLOGW("is_hdr_display_ is not initialized for display %d!! Reporting it as HDR not supported",
disp_id);
- return false;
+ *supported = false;
+ return 0;
}
- return static_cast<bool>(is_hdr_display_[disp_id]);
+ *supported = static_cast<bool>(hwc_session_->is_hdr_display_[disp_id]);
+ return 0;
}
-Return<bool> HWCSession::isWCGSupported(uint32_t disp_id) {
+int HWCSession::DisplayConfigImpl::IsWCGSupported(uint32_t disp_id, bool *supported) {
// todo(user): Query wcg from sdm. For now assume them same.
- return isHDRSupported(disp_id);
+ return IsHDRSupported(disp_id, supported);
}
-Return<int32_t> HWCSession::setLayerAsMask(uint32_t disp_id, uint64_t layer_id) {
- SCOPE_LOCK(locker_[disp_id]);
- HWCDisplay *hwc_display = hwc_display_[disp_id];
+int HWCSession::DisplayConfigImpl::SetLayerAsMask(uint32_t disp_id, uint64_t layer_id) {
+ SCOPE_LOCK(hwc_session_->locker_[disp_id]);
+ HWCDisplay *hwc_display = hwc_session_->hwc_display_[disp_id];
if (!hwc_display) {
DLOGW("Display = %d is not connected.", disp_id);
return -EINVAL;
}
- if (disable_mask_layer_hint_) {
+ if (hwc_session_->disable_mask_layer_hint_) {
DLOGW("Mask layer hint is disabled!");
return -EINVAL;
}
@@ -742,153 +751,148 @@
return 0;
}
-Return<void> HWCSession::getDebugProperty(const hidl_string &prop_name,
- getDebugProperty_cb _hidl_cb) {
+int HWCSession::DisplayConfigImpl::GetDebugProperty(const std::string prop_name,
+ std::string value) {
std::string vendor_prop_name = DISP_PROP_PREFIX;
- char value[64] = {};
- hidl_string result = "";
- int32_t error = -EINVAL;
+ int error = -EINVAL;
+ char val[64] = {};
vendor_prop_name += prop_name.c_str();
- if (HWCDebugHandler::Get()->GetProperty(vendor_prop_name.c_str(), value) == kErrorNone) {
- result = value;
+ if (HWCDebugHandler::Get()->GetProperty(vendor_prop_name.c_str(), val) == kErrorNone) {
+ value = val;
error = 0;
}
- _hidl_cb(result, error);
-
- return Void();
+ return error;
}
-Return<void> HWCSession::getActiveBuiltinDisplayAttributes(
- getDisplayAttributes_cb _hidl_cb) {
- int32_t error = -EINVAL;
- IDisplayConfig::DisplayAttributes display_attributes = {};
- hwc2_display_t disp_id = GetActiveBuiltinDisplay();
+int HWCSession::DisplayConfigImpl::GetActiveBuiltinDisplayAttributes(
+ DisplayConfig::Attributes *attr) {
+ int error = -EINVAL;
+ hwc2_display_t disp_id = hwc_session_->GetActiveBuiltinDisplay();
if (disp_id >= HWCCallbacks::kNumDisplays) {
DLOGE("Invalid display = %d", disp_id);
} else {
- if (hwc_display_[disp_id]) {
+ if (hwc_session_->hwc_display_[disp_id]) {
uint32_t config_index = 0;
- HWC2::Error ret = hwc_display_[disp_id]->GetActiveConfig(&config_index);
+ HWC2::Error ret = hwc_session_->hwc_display_[disp_id]->GetActiveConfig(&config_index);
if (ret != HWC2::Error::None) {
goto err;
}
DisplayConfigVariableInfo var_info;
- error = hwc_display_[disp_id]->GetDisplayAttributesForConfig(INT(config_index), &var_info);
+ error = hwc_session_->hwc_display_[disp_id]->GetDisplayAttributesForConfig(INT(config_index),
+ &var_info);
if (!error) {
- display_attributes.vsyncPeriod = var_info.vsync_period_ns;
- display_attributes.xRes = var_info.x_pixels;
- display_attributes.yRes = var_info.y_pixels;
- display_attributes.xDpi = var_info.x_dpi;
- display_attributes.yDpi = var_info.y_dpi;
- display_attributes.panelType = IDisplayConfig::DisplayPortType::DISPLAY_PORT_DEFAULT;
- display_attributes.isYuv = var_info.is_yuv;
+ attr->vsync_period = var_info.vsync_period_ns;
+ attr->x_res = var_info.x_pixels;
+ attr->y_res = var_info.y_pixels;
+ attr->x_dpi = var_info.x_dpi;
+ attr->y_dpi = var_info.y_dpi;
+ attr->panel_type = DisplayConfig::DisplayPortType::kDefault;
+ attr->is_yuv = var_info.is_yuv;
}
}
}
err:
- _hidl_cb(error, display_attributes);
-
- return Void();
+ return error;
}
-Return<int32_t> HWCSession::setPanelLuminanceAttributes(uint32_t disp_id, float pan_min_lum,
- float pan_max_lum) {
+int HWCSession::DisplayConfigImpl::SetPanelLuminanceAttributes(uint32_t disp_id, float pan_min_lum,
+ float pan_max_lum) {
// currently doing only for virtual display
if (disp_id != qdutils::DISPLAY_VIRTUAL) {
return -EINVAL;
}
- std::lock_guard<std::mutex> obj(mutex_lum_);
- set_min_lum_ = pan_min_lum;
- set_max_lum_ = pan_max_lum;
- DLOGI("set max_lum %f, min_lum %f", set_max_lum_, set_min_lum_);
+ std::lock_guard<std::mutex> obj(hwc_session_->mutex_lum_);
+ hwc_session_->set_min_lum_ = pan_min_lum;
+ hwc_session_->set_max_lum_ = pan_max_lum;
+ DLOGI("set max_lum %f, min_lum %f", pan_max_lum, pan_min_lum);
return 0;
}
-Return<bool> HWCSession::isBuiltInDisplay(uint32_t disp_id) {
- if ((map_info_primary_.client_id == disp_id) && (map_info_primary_.disp_type == kBuiltIn))
- return true;
-
- for (auto &info : map_info_builtin_) {
- if (disp_id == info.client_id) {
- return true;
- }
- }
-
- return false;
-}
-
-Return<void> HWCSession::getSupportedDSIBitClks(uint32_t disp_id,
- getSupportedDSIBitClks_cb _hidl_cb) {
- SCOPE_LOCK(locker_[disp_id]);
- if (!hwc_display_[disp_id]) {
- return Void();
- }
-
- std::vector<uint64_t> bit_clks;
- hwc_display_[disp_id]->GetSupportedDSIClock(&bit_clks);
-
- hidl_vec<uint64_t> hidl_bit_clks = bit_clks;
- _hidl_cb(hidl_bit_clks);
-
- return Void();
-}
-
-Return<uint64_t> HWCSession::getDSIClk(uint32_t disp_id) {
- SCOPE_LOCK(locker_[disp_id]);
- if (!hwc_display_[disp_id]) {
+int HWCSession::DisplayConfigImpl::IsBuiltInDisplay(uint32_t disp_id, bool *is_builtin) {
+ if ((hwc_session_->map_info_primary_.client_id == disp_id) &&
+ (hwc_session_->map_info_primary_.disp_type == kBuiltIn)) {
+ *is_builtin = true;
return 0;
}
- uint64_t bit_clk = 0;
- hwc_display_[disp_id]->GetDynamicDSIClock(&bit_clk);
+ for (auto &info : hwc_session_->map_info_builtin_) {
+ if (disp_id == info.client_id) {
+ *is_builtin = true;
+ return 0;
+ }
+ }
- return bit_clk;
+ *is_builtin = false;
+ return 0;
}
-Return<int32_t> HWCSession::setDSIClk(uint32_t disp_id, uint64_t bit_clk) {
- SCOPE_LOCK(locker_[disp_id]);
- if (!hwc_display_[disp_id]) {
+int HWCSession::DisplayConfigImpl::GetSupportedDSIBitClks(uint32_t disp_id,
+ std::vector<uint64_t> bit_clks) {
+ SCOPE_LOCK(hwc_session_->locker_[disp_id]);
+ if (!hwc_session_->hwc_display_[disp_id]) {
+ return -EINVAL;
+ }
+
+ hwc_session_->hwc_display_[disp_id]->GetSupportedDSIClock(&bit_clks);
+ return 0;
+}
+
+int HWCSession::DisplayConfigImpl::GetDSIClk(uint32_t disp_id, uint64_t *bit_clk) {
+ SCOPE_LOCK(hwc_session_->locker_[disp_id]);
+ if (!hwc_session_->hwc_display_[disp_id]) {
+ return -EINVAL;
+ }
+
+ hwc_session_->hwc_display_[disp_id]->GetDynamicDSIClock(bit_clk);
+
+ return 0;
+}
+
+int HWCSession::DisplayConfigImpl::SetDSIClk(uint32_t disp_id, uint64_t bit_clk) {
+ SCOPE_LOCK(hwc_session_->locker_[disp_id]);
+ if (!hwc_session_->hwc_display_[disp_id]) {
return -1;
}
- return hwc_display_[disp_id]->SetDynamicDSIClock(bit_clk);
+ return hwc_session_->hwc_display_[disp_id]->SetDynamicDSIClock(bit_clk);
}
-Return<int32_t> HWCSession::setCWBOutputBuffer(const ::android::sp<IDisplayCWBCallback> &callback,
- uint32_t disp_id, const Rect &rect,
- bool post_processed, const hidl_handle& buffer) {
+int HWCSession::DisplayConfigImpl::SetCWBOutputBuffer(uint32_t disp_id,
+ const DisplayConfig::Rect rect,
+ bool post_processed,
+ const native_handle_t *buffer) {
return -1;
}
-Return<int32_t> HWCSession::setQsyncMode(uint32_t disp_id, IDisplayConfig::QsyncMode mode) {
- SEQUENCE_WAIT_SCOPE_LOCK(locker_[disp_id]);
- if (!hwc_display_[disp_id]) {
+int HWCSession::DisplayConfigImpl::SetQsyncMode(uint32_t disp_id, DisplayConfig::QsyncMode mode) {
+ SEQUENCE_WAIT_SCOPE_LOCK(hwc_session_->locker_[disp_id]);
+ if (!hwc_session_->hwc_display_[disp_id]) {
return -1;
}
QSyncMode qsync_mode = kQSyncModeNone;
switch (mode) {
- case IDisplayConfig::QsyncMode::NONE:
+ case DisplayConfig::QsyncMode::kNone:
qsync_mode = kQSyncModeNone;
break;
- case IDisplayConfig::QsyncMode::WAIT_FOR_FENCES_ONE_FRAME:
+ case DisplayConfig::QsyncMode::kWaitForFencesOneFrame:
qsync_mode = kQsyncModeOneShot;
break;
- case IDisplayConfig::QsyncMode::WAIT_FOR_FENCES_EACH_FRAME:
+ case DisplayConfig::QsyncMode::kWaitForFencesEachFrame:
qsync_mode = kQsyncModeOneShotContinuous;
break;
- case IDisplayConfig::QsyncMode::WAIT_FOR_COMMIT_EACH_FRAME:
+ case DisplayConfig::QsyncMode::kWaitForCommitEachFrame:
qsync_mode = kQSyncModeContinuous;
break;
}
- hwc_display_[disp_id]->SetQSyncMode(qsync_mode);
+ hwc_session_->hwc_display_[disp_id]->SetQSyncMode(qsync_mode);
return 0;
}