sde: Move locking to each display interface implementation
The lock over the display interface is now handled by each
implementation. This simplifies locking for cases when a display
interface implementation has a function it implements
differently.
Change-Id: I8e06680ea3a7621218ba34bc6db519db38554e8d
diff --git a/displayengine/include/utils/constants.h b/displayengine/include/utils/constants.h
index 8630d45..44e211c 100644
--- a/displayengine/include/utils/constants.h
+++ b/displayengine/include/utils/constants.h
@@ -27,9 +27,6 @@
#include <stdlib.h>
-#define LIKELY(exp) __builtin_expect((exp) != 0, true)
-#define UNLIKELY(exp) __builtin_expect((exp) != 0, false)
-
#define INT(exp) static_cast<int>(exp)
#define FLOAT(exp) static_cast<float>(exp)
#define UINT8(exp) static_cast<uint8_t>(exp)
diff --git a/displayengine/libs/core/core_impl.cpp b/displayengine/libs/core/core_impl.cpp
index 2732889..f04bbb9 100644
--- a/displayengine/libs/core/core_impl.cpp
+++ b/displayengine/libs/core/core_impl.cpp
@@ -123,7 +123,7 @@
return kErrorParameters;
}
- if (UNLIKELY(!display_base)) {
+ if (!display_base) {
return kErrorMemory;
}
diff --git a/displayengine/libs/core/core_interface.cpp b/displayengine/libs/core/core_interface.cpp
index c982b4d..0cfec66 100644
--- a/displayengine/libs/core/core_interface.cpp
+++ b/displayengine/libs/core/core_interface.cpp
@@ -64,16 +64,16 @@
// Check compatibility of client and core.
uint32_t lib_version = SDE_VERSION_TAG;
- if (UNLIKELY(GET_REVISION(client_version) > GET_REVISION(lib_version))) {
+ if (GET_REVISION(client_version) > GET_REVISION(lib_version)) {
return kErrorVersion;
- } else if (UNLIKELY(GET_DATA_ALIGNMENT(client_version) != GET_DATA_ALIGNMENT(lib_version))) {
+ } else if (GET_DATA_ALIGNMENT(client_version) != GET_DATA_ALIGNMENT(lib_version)) {
return kErrorDataAlignment;
- } else if (UNLIKELY(GET_INSTRUCTION_SET(client_version) != GET_INSTRUCTION_SET(lib_version))) {
+ } else if (GET_INSTRUCTION_SET(client_version) != GET_INSTRUCTION_SET(lib_version)) {
return kErrorInstructionSet;
}
CoreImpl *&core_impl = g_core.core_impl;
- if (UNLIKELY(core_impl)) {
+ if (core_impl) {
return kErrorUndefined;
}
@@ -86,12 +86,12 @@
return kErrorNotSupported;
}
- if (UNLIKELY(!core_impl)) {
+ if (!core_impl) {
return kErrorMemory;
}
DisplayError error = core_impl->Init();
- if (UNLIKELY(error != kErrorNone)) {
+ if (error != kErrorNone) {
delete core_impl;
core_impl = NULL;
return error;
@@ -109,7 +109,7 @@
DLOGI("Close handle");
CoreImpl *&core_impl = g_core.core_impl;
- if (UNLIKELY(!core_impl)) {
+ if (!core_impl) {
return kErrorUndefined;
}
diff --git a/displayengine/libs/core/display_base.cpp b/displayengine/libs/core/display_base.cpp
index b61d3a6..00e707c 100644
--- a/displayengine/libs/core/display_base.cpp
+++ b/displayengine/libs/core/display_base.cpp
@@ -45,17 +45,8 @@
DisplayError DisplayBase::Init() {
DisplayError error = kErrorNone;
-
- error = hw_intf_->Open(this);
- if (error != kErrorNone) {
- return error;
- }
-
- panel_info_ = HWPanelInfo();
- hw_intf_->GetHWPanelInfo(&panel_info_);
-
- // Set the idle timeout value to driver through sysfs node
- SetIdleTimeoutMs(Debug::GetIdleTimeoutMs());
+ hw_panel_info_ = HWPanelInfo();
+ hw_intf_->GetHWPanelInfo(&hw_panel_info_);
error = hw_intf_->GetNumDisplayAttributes(&num_modes_);
if (error != kErrorNone) {
@@ -89,7 +80,7 @@
}
error = offline_ctrl_->RegisterDisplay(display_type_, &display_offline_ctx_);
- if (UNLIKELY(error != kErrorNone)) {
+ if (error != kErrorNone) {
goto CleanupOnError;
}
@@ -126,8 +117,6 @@
}
DisplayError DisplayBase::Prepare(LayerStack *layer_stack) {
- SCOPE_LOCK(locker_);
-
DisplayError error = kErrorNone;
if (!layer_stack) {
@@ -167,8 +156,6 @@
}
DisplayError DisplayBase::Commit(LayerStack *layer_stack) {
- SCOPE_LOCK(locker_);
-
DisplayError error = kErrorNone;
if (!layer_stack) {
@@ -203,8 +190,6 @@
}
DisplayError DisplayBase::Flush() {
- SCOPE_LOCK(locker_);
-
DisplayError error = kErrorNone;
if (state_ != kStateOn) {
@@ -224,8 +209,6 @@
}
DisplayError DisplayBase::GetDisplayState(DisplayState *state) {
- SCOPE_LOCK(locker_);
-
if (!state) {
return kErrorParameters;
}
@@ -235,8 +218,6 @@
}
DisplayError DisplayBase::GetNumVariableInfoConfigs(uint32_t *count) {
- SCOPE_LOCK(locker_);
-
if (!count) {
return kErrorParameters;
}
@@ -247,8 +228,6 @@
}
DisplayError DisplayBase::GetConfig(DisplayConfigFixedInfo *fixed_info) {
- SCOPE_LOCK(locker_);
-
if (!fixed_info) {
return kErrorParameters;
}
@@ -257,8 +236,6 @@
}
DisplayError DisplayBase::GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info) {
- SCOPE_LOCK(locker_);
-
if (!variable_info || index >= num_modes_) {
return kErrorParameters;
}
@@ -269,8 +246,6 @@
}
DisplayError DisplayBase::GetActiveConfig(uint32_t *index) {
- SCOPE_LOCK(locker_);
-
if (!index) {
return kErrorParameters;
}
@@ -281,8 +256,6 @@
}
DisplayError DisplayBase::GetVSyncState(bool *enabled) {
- SCOPE_LOCK(locker_);
-
if (!enabled) {
return kErrorParameters;
}
@@ -291,8 +264,6 @@
}
DisplayError DisplayBase::SetDisplayState(DisplayState state) {
- SCOPE_LOCK(locker_);
-
DisplayError error = kErrorNone;
DLOGI("Set state = %d, display %d", state, display_type_);
@@ -338,7 +309,6 @@
}
DisplayError DisplayBase::SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
- SCOPE_LOCK(locker_);
DisplayError error = kErrorNone;
if (!variable_info) {
@@ -368,7 +338,6 @@
}
DisplayError DisplayBase::SetActiveConfig(uint32_t index) {
- SCOPE_LOCK(locker_);
DisplayError error = kErrorNone;
if (index >= num_modes_) {
@@ -392,15 +361,7 @@
return error;
}
-DisplayError DisplayBase::SetVSyncState(bool enable) {
- return kErrorNotSupported;
-}
-
-void DisplayBase::SetIdleTimeoutMs(uint32_t timeout_ms) { }
-
DisplayError DisplayBase::SetMaxMixerStages(uint32_t max_mixer_stages) {
- SCOPE_LOCK(locker_);
-
DisplayError error = kErrorNone;
if (comp_manager_) {
@@ -410,39 +371,17 @@
return error;
}
-DisplayError DisplayBase::VSync(int64_t timestamp) {
- if (vsync_enable_) {
- DisplayEventVSync vsync;
- vsync.timestamp = timestamp;
- event_handler_->VSync(vsync);
- }
-
- return kErrorNone;
-}
-
-DisplayError DisplayBase::Blank(bool blank) {
- return kErrorNone;
-}
-
-void DisplayBase::IdleTimeout() {
- bool need_refresh = comp_manager_->ProcessIdleTimeout(display_comp_ctx_);
- if (need_refresh) {
- event_handler_->Refresh();
- }
-}
-
void DisplayBase::AppendDump(char *buffer, uint32_t length) {
- SCOPE_LOCK(locker_);
-
- AppendString(buffer, length, "\n-----------------------");
- AppendString(buffer, length, "\ndevice type: %u", display_type_);
- AppendString(buffer, length, "\nstate: %u, vsync on: %u", state_, INT(vsync_enable_));
- AppendString(buffer, length, "\nnum configs: %u, active config index: %u",
- num_modes_, active_mode_index_);
+ DumpImpl::AppendString(buffer, length, "\n-----------------------");
+ DumpImpl::AppendString(buffer, length, "\ndevice type: %u", display_type_);
+ DumpImpl::AppendString(buffer, length, "\nstate: %u, vsync on: %u", state_, INT(vsync_enable_));
+ DumpImpl::AppendString(buffer, length, "\nnum configs: %u, active config index: %u",
+ num_modes_, active_mode_index_);
DisplayConfigVariableInfo &info = display_attributes_[active_mode_index_];
- AppendString(buffer, length, "\nres:%ux%u, dpi:%.2fx%.2f, fps:%.2f, vsync period: %u",
- info.x_pixels, info.y_pixels, info.x_dpi, info.y_dpi, info.fps, info.vsync_period_ns);
+ DumpImpl::AppendString(buffer, length, "\nres:%ux%u, dpi:%.2fx%.2f, fps:%.2f, vsync period: %u",
+ info.x_pixels, info.y_pixels, info.x_dpi, info.y_dpi, info.fps,
+ info.vsync_period_ns);
uint32_t num_layers = 0;
uint32_t num_hw_layers = 0;
@@ -451,8 +390,8 @@
num_hw_layers = hw_layers_.info.count;
}
- AppendString(buffer, length, "\n\nnum actual layers: %u, num sde layers: %u",
- num_layers, num_hw_layers);
+ DumpImpl::AppendString(buffer, length, "\n\nnum actual layers: %u, num sde layers: %u",
+ num_layers, num_hw_layers);
for (uint32_t i = 0; i < num_hw_layers; i++) {
Layer &layer = hw_layers_.info.stack->layers[hw_layers_.info.index[i]];
@@ -463,36 +402,37 @@
HWRotateInfo &left_rotate = hw_layers_.config[i].rotates[0];
HWRotateInfo &right_rotate = hw_layers_.config[i].rotates[1];
- AppendString(buffer, length, "\n\nsde idx: %u, actual idx: %u", i, hw_layers_.info.index[i]);
- AppendString(buffer, length, "\nw: %u, h: %u, fmt: %u",
- input_buffer->width, input_buffer->height, input_buffer->format);
+ DumpImpl::AppendString(buffer, length, "\n\nsde idx: %u, actual idx: %u", i,
+ hw_layers_.info.index[i]);
+ DumpImpl::AppendString(buffer, length, "\nw: %u, h: %u, fmt: %u",
+ input_buffer->width, input_buffer->height, input_buffer->format);
AppendRect(buffer, length, "\nsrc_rect:", &layer.src_rect);
AppendRect(buffer, length, "\ndst_rect:", &layer.dst_rect);
if (left_rotate.valid) {
- AppendString(buffer, length, "\n\tleft rotate =>");
- AppendString(buffer, length, "\n\t pipe id: 0x%x", left_rotate.pipe_id);
+ DumpImpl::AppendString(buffer, length, "\n\tleft rotate =>");
+ DumpImpl::AppendString(buffer, length, "\n\t pipe id: 0x%x", left_rotate.pipe_id);
AppendRect(buffer, length, "\n\t src_roi:", &left_rotate.src_roi);
AppendRect(buffer, length, "\n\t dst_roi:", &left_rotate.dst_roi);
}
if (right_rotate.valid) {
- AppendString(buffer, length, "\n\tright rotate =>");
- AppendString(buffer, length, "\n\t pipe id: 0x%x", right_rotate.pipe_id);
+ DumpImpl::AppendString(buffer, length, "\n\tright rotate =>");
+ DumpImpl::AppendString(buffer, length, "\n\t pipe id: 0x%x", right_rotate.pipe_id);
AppendRect(buffer, length, "\n\t src_roi:", &right_rotate.src_roi);
AppendRect(buffer, length, "\n\t dst_roi:", &right_rotate.dst_roi);
}
if (left_pipe.valid) {
- AppendString(buffer, length, "\n\tleft pipe =>");
- AppendString(buffer, length, "\n\t pipe id: 0x%x", left_pipe.pipe_id);
+ DumpImpl::AppendString(buffer, length, "\n\tleft pipe =>");
+ DumpImpl::AppendString(buffer, length, "\n\t pipe id: 0x%x", left_pipe.pipe_id);
AppendRect(buffer, length, "\n\t src_roi:", &left_pipe.src_roi);
AppendRect(buffer, length, "\n\t dst_roi:", &left_pipe.dst_roi);
}
if (right_pipe.valid) {
- AppendString(buffer, length, "\n\tright pipe =>");
- AppendString(buffer, length, "\n\t pipe id: 0x%x", right_pipe.pipe_id);
+ DumpImpl::AppendString(buffer, length, "\n\tright pipe =>");
+ DumpImpl::AppendString(buffer, length, "\n\t pipe id: 0x%x", right_pipe.pipe_id);
AppendRect(buffer, length, "\n\t src_roi:", &right_pipe.src_roi);
AppendRect(buffer, length, "\n\t dst_roi:", &right_pipe.dst_roi);
}
@@ -501,8 +441,8 @@
void DisplayBase::AppendRect(char *buffer, uint32_t length, const char *rect_name,
LayerRect *rect) {
- AppendString(buffer, length, "%s %.1f, %.1f, %.1f, %.1f",
- rect_name, rect->left, rect->top, rect->right, rect->bottom);
+ DumpImpl::AppendString(buffer, length, "%s %.1f, %.1f, %.1f, %.1f",
+ rect_name, rect->left, rect->top, rect->right, rect->bottom);
}
int DisplayBase::GetBestConfig() {
diff --git a/displayengine/libs/core/display_base.h b/displayengine/libs/core/display_base.h
index 51b0ac3..ec90510 100644
--- a/displayengine/libs/core/display_base.h
+++ b/displayengine/libs/core/display_base.h
@@ -38,7 +38,7 @@
class OfflineCtrl;
-class DisplayBase : public DisplayInterface, HWEventHandler, DumpImpl {
+class DisplayBase : public DisplayInterface {
public:
DisplayBase(DisplayType display_type, DisplayEventHandler *event_handler,
HWDeviceType hw_device_type, BufferSyncHandler *buffer_sync_handler,
@@ -58,28 +58,20 @@
virtual DisplayError SetDisplayState(DisplayState state);
virtual DisplayError SetActiveConfig(DisplayConfigVariableInfo *variable_info);
virtual DisplayError SetActiveConfig(uint32_t index);
- virtual DisplayError SetVSyncState(bool enable);
- virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
- // Implement the HWEventHandlers
- virtual DisplayError VSync(int64_t timestamp);
- virtual DisplayError Blank(bool blank);
- virtual void IdleTimeout();
-
+ protected:
// DumpImpl method
- virtual void AppendDump(char *buffer, uint32_t length);
+ void AppendDump(char *buffer, uint32_t length);
void AppendRect(char *buffer, uint32_t length, const char *rect_name, LayerRect *rect);
- protected:
virtual int GetBestConfig();
- Locker locker_;
DisplayType display_type_;
DisplayEventHandler *event_handler_;
HWDeviceType hw_device_type_;
HWInterface *hw_intf_;
- HWPanelInfo panel_info_;
+ HWPanelInfo hw_panel_info_;
BufferSyncHandler *buffer_sync_handler_;
CompManager *comp_manager_;
OfflineCtrl *offline_ctrl_;
diff --git a/displayengine/libs/core/display_hdmi.cpp b/displayengine/libs/core/display_hdmi.cpp
index 045c06c..56a12f1 100644
--- a/displayengine/libs/core/display_hdmi.cpp
+++ b/displayengine/libs/core/display_hdmi.cpp
@@ -48,7 +48,12 @@
if (error != kErrorNone) {
return error;
}
+
DisplayBase::hw_intf_ = hw_hdmi_intf_;
+ error = hw_hdmi_intf_->Open(NULL);
+ if (error != kErrorNone) {
+ return error;
+ }
error = DisplayBase::Init();
if (error != kErrorNone) {
@@ -70,6 +75,78 @@
return error;
}
+DisplayError DisplayHDMI::Prepare(LayerStack *layer_stack) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::Prepare(layer_stack);
+}
+
+DisplayError DisplayHDMI::Commit(LayerStack *layer_stack) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::Commit(layer_stack);
+}
+
+DisplayError DisplayHDMI::Flush() {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::Flush();
+}
+
+DisplayError DisplayHDMI::GetDisplayState(DisplayState *state) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetDisplayState(state);
+}
+
+DisplayError DisplayHDMI::GetNumVariableInfoConfigs(uint32_t *count) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetNumVariableInfoConfigs(count);
+}
+
+DisplayError DisplayHDMI::GetConfig(DisplayConfigFixedInfo *fixed_info) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetConfig(fixed_info);
+}
+
+DisplayError DisplayHDMI::GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetConfig(index, variable_info);
+}
+
+DisplayError DisplayHDMI::GetActiveConfig(uint32_t *index) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetActiveConfig(index);
+}
+
+DisplayError DisplayHDMI::GetVSyncState(bool *enabled) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetVSyncState(enabled);
+}
+
+DisplayError DisplayHDMI::SetDisplayState(DisplayState state) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::SetDisplayState(state);
+}
+
+DisplayError DisplayHDMI::SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::SetActiveConfig(variable_info);
+}
+
+DisplayError DisplayHDMI::SetActiveConfig(uint32_t index) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::SetActiveConfig(index);
+}
+
+DisplayError DisplayHDMI::SetVSyncState(bool enable) {
+ SCOPE_LOCK(locker_);
+ return kErrorNotSupported;
+}
+
+void DisplayHDMI::SetIdleTimeoutMs(uint32_t timeout_ms) { }
+
+DisplayError DisplayHDMI::SetMaxMixerStages(uint32_t max_mixer_stages) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::SetMaxMixerStages(max_mixer_stages);
+}
+
int DisplayHDMI::GetBestConfig() {
uint32_t best_config_mode = 0;
HWDisplayAttributes *best = &display_attributes_[0];
@@ -111,5 +188,10 @@
return best_config_mode;
}
+void DisplayHDMI::AppendDump(char *buffer, uint32_t length) {
+ SCOPE_LOCK(locker_);
+ DisplayBase::AppendDump(buffer, length);
+}
+
} // namespace sde
diff --git a/displayengine/libs/core/display_hdmi.h b/displayengine/libs/core/display_hdmi.h
index 506329b..8b3cf1b 100644
--- a/displayengine/libs/core/display_hdmi.h
+++ b/displayengine/libs/core/display_hdmi.h
@@ -32,16 +32,34 @@
class HWHDMIInterface;
class HWInfoInterface;
-class DisplayHDMI : public DisplayBase {
+class DisplayHDMI : public DisplayBase, DumpImpl {
public:
DisplayHDMI(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
OfflineCtrl *offline_ctrl);
virtual DisplayError Init();
virtual DisplayError Deinit();
- virtual int GetBestConfig();
+ virtual DisplayError Prepare(LayerStack *layer_stack);
+ virtual DisplayError Commit(LayerStack *layer_stack);
+ virtual DisplayError Flush();
+ virtual DisplayError GetDisplayState(DisplayState *state);
+ virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
+ virtual DisplayError GetConfig(DisplayConfigFixedInfo *fixed_info);
+ virtual DisplayError GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info);
+ virtual DisplayError GetActiveConfig(uint32_t *index);
+ virtual DisplayError GetVSyncState(bool *enabled);
+ virtual DisplayError SetDisplayState(DisplayState state);
+ virtual DisplayError SetActiveConfig(DisplayConfigVariableInfo *variable_info);
+ virtual DisplayError SetActiveConfig(uint32_t index);
+ virtual DisplayError SetVSyncState(bool enable);
+ virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
+ virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
+ virtual void AppendDump(char *buffer, uint32_t length);
private:
+ virtual int GetBestConfig();
+
+ Locker locker_;
HWHDMIInterface *hw_hdmi_intf_;
HWInfoInterface *hw_info_intf_;
};
diff --git a/displayengine/libs/core/display_primary.cpp b/displayengine/libs/core/display_primary.cpp
index 55e927c..542b46a 100644
--- a/displayengine/libs/core/display_primary.cpp
+++ b/displayengine/libs/core/display_primary.cpp
@@ -50,11 +50,21 @@
}
DisplayBase::hw_intf_ = hw_primary_intf_;
+ error = hw_primary_intf_->Open(this);
+ if (error != kErrorNone) {
+ return error;
+ }
+
error = DisplayBase::Init();
if (error != kErrorNone) {
HWPrimaryInterface::Destroy(hw_primary_intf_);
}
+ // Idle fallback feature is supported only for video mode panel.
+ if (hw_panel_info_.type == kVideoModePanel) {
+ hw_primary_intf_->SetIdleTimeoutMs(Debug::GetIdleTimeoutMs());
+ }
+
return error;
}
@@ -70,6 +80,66 @@
return error;
}
+DisplayError DisplayPrimary::Prepare(LayerStack *layer_stack) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::Prepare(layer_stack);
+}
+
+DisplayError DisplayPrimary::Commit(LayerStack *layer_stack) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::Commit(layer_stack);
+}
+
+DisplayError DisplayPrimary::Flush() {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::Flush();
+}
+
+DisplayError DisplayPrimary::GetDisplayState(DisplayState *state) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetDisplayState(state);
+}
+
+DisplayError DisplayPrimary::GetNumVariableInfoConfigs(uint32_t *count) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetNumVariableInfoConfigs(count);
+}
+
+DisplayError DisplayPrimary::GetConfig(DisplayConfigFixedInfo *fixed_info) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetConfig(fixed_info);
+}
+
+DisplayError DisplayPrimary::GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetConfig(index, variable_info);
+}
+
+DisplayError DisplayPrimary::GetActiveConfig(uint32_t *index) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetActiveConfig(index);
+}
+
+DisplayError DisplayPrimary::GetVSyncState(bool *enabled) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetVSyncState(enabled);
+}
+
+DisplayError DisplayPrimary::SetDisplayState(DisplayState state) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::SetDisplayState(state);
+}
+
+DisplayError DisplayPrimary::SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::SetActiveConfig(variable_info);
+}
+
+DisplayError DisplayPrimary::SetActiveConfig(uint32_t index) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::SetActiveConfig(index);
+}
+
DisplayError DisplayPrimary::SetVSyncState(bool enable) {
SCOPE_LOCK(locker_);
DisplayError error = kErrorNone;
@@ -84,12 +154,45 @@
}
void DisplayPrimary::SetIdleTimeoutMs(uint32_t timeout_ms) {
+ SCOPE_LOCK(locker_);
// Idle fallback feature is supported only for video mode panel.
- if (panel_info_.type == kCommandModePanel) {
- return;
+ if (hw_panel_info_.type == kVideoModePanel) {
+ hw_primary_intf_->SetIdleTimeoutMs(timeout_ms);
+ }
+}
+
+DisplayError DisplayPrimary::SetMaxMixerStages(uint32_t max_mixer_stages) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::SetMaxMixerStages(max_mixer_stages);
+}
+
+void DisplayPrimary::AppendDump(char *buffer, uint32_t length) {
+ SCOPE_LOCK(locker_);
+ DisplayBase::AppendDump(buffer, length);
+}
+
+DisplayError DisplayPrimary::VSync(int64_t timestamp) {
+ SCOPE_LOCK(locker_);
+ if (vsync_enable_) {
+ DisplayEventVSync vsync;
+ vsync.timestamp = timestamp;
+ event_handler_->VSync(vsync);
}
- hw_primary_intf_->SetIdleTimeoutMs(timeout_ms);
+ return kErrorNone;
+}
+
+DisplayError DisplayPrimary::Blank(bool blank) {
+ SCOPE_LOCK(locker_);
+ return kErrorNone;
+}
+
+void DisplayPrimary::IdleTimeout() {
+ SCOPE_LOCK(locker_);
+ bool need_refresh = comp_manager_->ProcessIdleTimeout(display_comp_ctx_);
+ if (need_refresh) {
+ event_handler_->Refresh();
+ }
}
} // namespace sde
diff --git a/displayengine/libs/core/display_primary.h b/displayengine/libs/core/display_primary.h
index 76fbb06..ea0050a 100644
--- a/displayengine/libs/core/display_primary.h
+++ b/displayengine/libs/core/display_primary.h
@@ -32,17 +32,37 @@
class HWPrimaryInterface;
class HWInfoInterface;
-class DisplayPrimary : public DisplayBase {
+class DisplayPrimary : public DisplayBase, DumpImpl, HWEventHandler {
public:
DisplayPrimary(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
OfflineCtrl *offline_ctrl);
virtual DisplayError Init();
virtual DisplayError Deinit();
+ virtual DisplayError Prepare(LayerStack *layer_stack);
+ virtual DisplayError Commit(LayerStack *layer_stack);
+ virtual DisplayError Flush();
+ virtual DisplayError GetDisplayState(DisplayState *state);
+ virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
+ virtual DisplayError GetConfig(DisplayConfigFixedInfo *fixed_info);
+ virtual DisplayError GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info);
+ virtual DisplayError GetActiveConfig(uint32_t *index);
+ virtual DisplayError GetVSyncState(bool *enabled);
+ virtual DisplayError SetDisplayState(DisplayState state);
+ virtual DisplayError SetActiveConfig(DisplayConfigVariableInfo *variable_info);
+ virtual DisplayError SetActiveConfig(uint32_t index);
virtual DisplayError SetVSyncState(bool enable);
virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
+ virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
+ virtual void AppendDump(char *buffer, uint32_t length);
+
+ // Implement the HWEventHandlers
+ virtual DisplayError VSync(int64_t timestamp);
+ virtual DisplayError Blank(bool blank);
+ virtual void IdleTimeout();
private:
+ Locker locker_;
HWPrimaryInterface *hw_primary_intf_;
HWInfoInterface *hw_info_intf_;
};
diff --git a/displayengine/libs/core/display_virtual.cpp b/displayengine/libs/core/display_virtual.cpp
index 359e6a3..7430c06 100644
--- a/displayengine/libs/core/display_virtual.cpp
+++ b/displayengine/libs/core/display_virtual.cpp
@@ -48,7 +48,12 @@
if (error != kErrorNone) {
return error;
}
+
DisplayBase::hw_intf_ = hw_virtual_intf_;
+ error = hw_virtual_intf_->Open(NULL);
+ if (error != kErrorNone) {
+ return error;
+ }
error = DisplayBase::Init();
if (error != kErrorNone) {
@@ -70,5 +75,82 @@
return error;
}
+DisplayError DisplayVirtual::Prepare(LayerStack *layer_stack) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::Prepare(layer_stack);
+}
+
+DisplayError DisplayVirtual::Commit(LayerStack *layer_stack) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::Commit(layer_stack);
+}
+
+DisplayError DisplayVirtual::Flush() {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::Flush();
+}
+
+DisplayError DisplayVirtual::GetDisplayState(DisplayState *state) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetDisplayState(state);
+}
+
+DisplayError DisplayVirtual::GetNumVariableInfoConfigs(uint32_t *count) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetNumVariableInfoConfigs(count);
+}
+
+DisplayError DisplayVirtual::GetConfig(DisplayConfigFixedInfo *fixed_info) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetConfig(fixed_info);
+}
+
+DisplayError DisplayVirtual::GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetConfig(index, variable_info);
+}
+
+DisplayError DisplayVirtual::GetActiveConfig(uint32_t *index) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetActiveConfig(index);
+}
+
+DisplayError DisplayVirtual::GetVSyncState(bool *enabled) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::GetVSyncState(enabled);
+}
+
+DisplayError DisplayVirtual::SetDisplayState(DisplayState state) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::SetDisplayState(state);
+}
+
+DisplayError DisplayVirtual::SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::SetActiveConfig(variable_info);
+}
+
+DisplayError DisplayVirtual::SetActiveConfig(uint32_t index) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::SetActiveConfig(index);
+}
+
+DisplayError DisplayVirtual::SetVSyncState(bool enable) {
+ SCOPE_LOCK(locker_);
+ return kErrorNotSupported;
+}
+
+void DisplayVirtual::SetIdleTimeoutMs(uint32_t timeout_ms) { }
+
+DisplayError DisplayVirtual::SetMaxMixerStages(uint32_t max_mixer_stages) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::SetMaxMixerStages(max_mixer_stages);
+}
+
+void DisplayVirtual::AppendDump(char *buffer, uint32_t length) {
+ SCOPE_LOCK(locker_);
+ DisplayBase::AppendDump(buffer, length);
+}
+
} // namespace sde
diff --git a/displayengine/libs/core/display_virtual.h b/displayengine/libs/core/display_virtual.h
index 7dee9fa..f7ba380 100644
--- a/displayengine/libs/core/display_virtual.h
+++ b/displayengine/libs/core/display_virtual.h
@@ -32,15 +32,32 @@
class HWVirtualInterface;
class HWInfoInterface;
-class DisplayVirtual : public DisplayBase {
+class DisplayVirtual : public DisplayBase, DumpImpl {
public:
DisplayVirtual(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
OfflineCtrl *offline_ctrl);
virtual DisplayError Init();
virtual DisplayError Deinit();
+ virtual DisplayError Prepare(LayerStack *layer_stack);
+ virtual DisplayError Commit(LayerStack *layer_stack);
+ virtual DisplayError Flush();
+ virtual DisplayError GetDisplayState(DisplayState *state);
+ virtual DisplayError GetNumVariableInfoConfigs(uint32_t *count);
+ virtual DisplayError GetConfig(DisplayConfigFixedInfo *fixed_info);
+ virtual DisplayError GetConfig(uint32_t index, DisplayConfigVariableInfo *variable_info);
+ virtual DisplayError GetActiveConfig(uint32_t *index);
+ virtual DisplayError GetVSyncState(bool *enabled);
+ virtual DisplayError SetDisplayState(DisplayState state);
+ virtual DisplayError SetActiveConfig(DisplayConfigVariableInfo *variable_info);
+ virtual DisplayError SetActiveConfig(uint32_t index);
+ virtual DisplayError SetVSyncState(bool enable);
+ virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
+ virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
+ virtual void AppendDump(char *buffer, uint32_t length);
private:
+ Locker locker_;
HWVirtualInterface *hw_virtual_intf_;
HWInfoInterface *hw_info_intf_;
};
diff --git a/displayengine/libs/core/fb/hw_virtual.cpp b/displayengine/libs/core/fb/hw_virtual.cpp
index 2d7cd3e..81b31d0 100644
--- a/displayengine/libs/core/fb/hw_virtual.cpp
+++ b/displayengine/libs/core/fb/hw_virtual.cpp
@@ -41,7 +41,7 @@
hw_virtual = new HWVirtual(buffer_sync_handler, hw_info_intf);
error = hw_virtual->Init();
- if (UNLIKELY(error != kErrorNone)) {
+ if (error != kErrorNone) {
delete hw_virtual;
} else {
*intf = hw_virtual;
diff --git a/displayengine/libs/hwc/hwc_display.cpp b/displayengine/libs/hwc/hwc_display.cpp
index 1be682d..654fc85 100644
--- a/displayengine/libs/hwc/hwc_display.cpp
+++ b/displayengine/libs/hwc/hwc_display.cpp
@@ -49,7 +49,7 @@
int HWCDisplay::Init() {
DisplayError error = core_intf_->CreateDisplay(type_, this, &display_intf_);
- if (UNLIKELY(error != kErrorNone)) {
+ if (error != kErrorNone) {
DLOGE("Display create failed. Error = %d display_type %d event_handler %p disp_intf %p",
error, type_, this, &display_intf_);
return -EINVAL;
@@ -60,7 +60,7 @@
int HWCDisplay::Deinit() {
DisplayError error = core_intf_->DestroyDisplay(display_intf_);
- if (UNLIKELY(error != kErrorNone)) {
+ if (error != kErrorNone) {
DLOGE("Display destroy failed. Error = %d", error);
return -EINVAL;
}
@@ -87,7 +87,7 @@
DLOGW("Unsupported event = %d", event);
}
- if (UNLIKELY(error != kErrorNone)) {
+ if (error != kErrorNone) {
DLOGE("Failed. event = %d, enable = %d, error = %d", event, enable, error);
return -EINVAL;
}
@@ -115,7 +115,7 @@
}
DisplayError error = display_intf_->SetDisplayState(state);
- if (UNLIKELY(error != kErrorNone)) {
+ if (error != kErrorNone) {
DLOGE("Set state failed. Error = %d", error);
return -EINVAL;
}
@@ -137,7 +137,7 @@
DisplayConfigVariableInfo variable_config;
error = display_intf_->GetConfig(config, &variable_config);
- if (UNLIKELY(error != kErrorNone)) {
+ if (error != kErrorNone) {
DLOGE("GetConfig variable info failed. Error = %d", error);
return -EINVAL;
}
@@ -243,8 +243,8 @@
// Layer array may be large enough to hold current number of layers.
// If not, re-allocate it now.
- if (UNLIKELY(layer_stack_memory_.size < required_size)) {
- if (LIKELY(layer_stack_memory_.raw)) {
+ if (layer_stack_memory_.size < required_size) {
+ if (layer_stack_memory_.raw) {
delete[] layer_stack_memory_.raw;
layer_stack_memory_.size = 0;
}
@@ -253,7 +253,7 @@
required_size = ROUND_UP(required_size, layer_stack_memory_.kSizeSteps);
layer_stack_memory_.raw = new uint8_t[required_size];
- if (UNLIKELY(!layer_stack_memory_.raw)) {
+ if (!layer_stack_memory_.raw) {
return -ENOMEM;
}