sde: Implement rotator session management in rotator controller
1. Implement session management in rotator controller.
2. Create rotator session for each layer that needs rotation.
3. Allocate rotator output buffer on rotator commit.
4. Associate the allocated output buffer with rotator session.
5. Destroy the session and the buffers associated with it on removal
of a rotation layer on every rotator perpare.
Change-Id: I30da084a80f3b0057624f21cf1d5e88d80cd8114
diff --git a/displayengine/include/core/buffer_allocator.h b/displayengine/include/core/buffer_allocator.h
index 4081c54..d81c414 100644
--- a/displayengine/include/core/buffer_allocator.h
+++ b/displayengine/include/core/buffer_allocator.h
@@ -90,8 +90,7 @@
implemented by the client. Buffer manager in display engine will use these methods to
allocate/deallocate buffers for display engine.
- @sa CompManager::Init
- @sa ResManager::Init
+ @sa CoreInterface::CreateCore
*/
class BufferAllocator {
public:
@@ -102,8 +101,6 @@
@param[in] buffer_info \link BufferInfo \endlink
@return \link DisplayError \endlink
-
- @sa BufferManager
*/
virtual DisplayError AllocateBuffer(BufferInfo *buffer_info) = 0;
@@ -115,8 +112,6 @@
@param[in] buffer_info \link BufferInfo \endlink
@return \link DisplayError \endlink
-
- @sa BufferManager
*/
virtual DisplayError FreeBuffer(BufferInfo *buffer_info) = 0;
diff --git a/displayengine/include/core/buffer_sync_handler.h b/displayengine/include/core/buffer_sync_handler.h
index d0d062e..699d1a1 100644
--- a/displayengine/include/core/buffer_sync_handler.h
+++ b/displayengine/include/core/buffer_sync_handler.h
@@ -45,9 +45,7 @@
implemented by the client. Buffer manager and HWFramebuffer in display engine will use these
methods to wait for buffer sync fd to be signaled/merge two buffer sync fds into one.
- @sa CompManager::Init
- @sa ResManager::Init
- @sa HWInterface::Create
+ @sa CoreInterface::CreateCore
*/
class BufferSyncHandler {
public:
@@ -58,8 +56,6 @@
@param[in] fd
@return \link DisplayError \endlink
-
- @sa BufferManager::GetNextBuffer
*/
virtual DisplayError SyncWait(int fd) = 0;
@@ -74,8 +70,6 @@
@param[out] merged_fd
@return \link DisplayError \endlink
-
- @sa HWFrameBuffer::RotatorCommit
*/
virtual DisplayError SyncMerge(int fd1, int fd2, int *merged_fd) = 0;
diff --git a/displayengine/include/core/debug_interface.h b/displayengine/include/core/debug_interface.h
index ff72321..9e83e46 100644
--- a/displayengine/include/core/debug_interface.h
+++ b/displayengine/include/core/debug_interface.h
@@ -46,8 +46,7 @@
kTagStrategy, //!< Debug log is tagged for strategy decisions.
kTagCompManager, //!< Debug log is tagged for composition manager.
kTagDriverConfig, //!< Debug log is tagged for driver config.
- kTagBufferManager, //!< Debug log is tagged for buffer manager state transitions.
- kTagOfflineCtrl, //!< Debug log is tagged for offline controller.
+ kTagRotator, //!< Debug log is tagged for rotator.
kTagScalar, //!< Debug log is tagged for Scalar Helper.
};
diff --git a/displayengine/libs/core/Android.mk b/displayengine/libs/core/Android.mk
index 5623283..b1948fd 100644
--- a/displayengine/libs/core/Android.mk
+++ b/displayengine/libs/core/Android.mk
@@ -25,9 +25,9 @@
strategy_default.cpp \
res_manager.cpp \
res_config.cpp \
- offline_ctrl.cpp \
+ rotator_ctrl.cpp \
dump_impl.cpp \
- buffer_manager.cpp \
+ session_manager.cpp \
scalar_helper.cpp \
$(LOCAL_HW_INTF_PATH)/hw_info.cpp \
$(LOCAL_HW_INTF_PATH)/hw_device.cpp \
diff --git a/displayengine/libs/core/buffer_manager.cpp b/displayengine/libs/core/buffer_manager.cpp
deleted file mode 100644
index 95c310a..0000000
--- a/displayengine/libs/core/buffer_manager.cpp
+++ /dev/null
@@ -1,293 +0,0 @@
-/*
-* Copyright (c) 2015, 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 <utils/debug.h>
-#include <utils/constants.h>
-#include <sys/mman.h>
-#include <fcntl.h>
-
-#include "buffer_manager.h"
-
-#define __CLASS__ "BufferManager"
-
-namespace sde {
-
-// --------------------------------- BufferSlot Implementation -------------------------------------
-
-DisplayError BufferManager::BufferSlot::Init() {
- uint32_t buffer_count = hw_buffer_info.buffer_config.buffer_count;
- size_t buffer_size = hw_buffer_info.alloc_buffer_info.size;
-
- release_fd = new int[buffer_count];
- if (release_fd == NULL) {
- return kErrorMemory;
- }
-
- offset = new uint32_t[buffer_count];
- if (offset == NULL) {
- delete[] release_fd;
- release_fd = NULL;
- return kErrorMemory;
- }
-
- for (uint32_t idx = 0; idx < buffer_count; idx++) {
- release_fd[idx] = -1;
- offset[idx] = UINT32((buffer_size / buffer_count) * idx);
- }
- curr_index = 0;
-
- return kErrorNone;
-}
-
-DisplayError BufferManager::BufferSlot::Deinit() {
- uint32_t buffer_count = hw_buffer_info.buffer_config.buffer_count;
-
- for (uint32_t idx = 0; idx < buffer_count; idx++) {
- if (release_fd[idx] >= 0) {
- close(release_fd[idx]);
- release_fd[idx] = -1;
- }
- }
-
- if (offset) {
- delete[] offset;
- offset = NULL;
- }
-
- if (release_fd) {
- delete[] release_fd;
- release_fd = NULL;
- }
-
- state = kBufferSlotFree;
- hw_buffer_info = HWBufferInfo();
-
- return kErrorNone;
-}
-
-// BufferManager State Transition
-// *******************************************************
-// Current State * Next State
-// *****************************************
-// * FREE READY ACQUIRED
-// *******************************************************
-// FREE * NA NA GetNextBuffer()
-// READY * Stop() NA GetNextBuffer()
-// ACQUIRED * NA Start() NA
-//********************************************************
-
-// ------------------------------- BufferManager Implementation ------------------------------------
-
-BufferManager::BufferManager(BufferAllocator *buffer_allocator,
- BufferSyncHandler *buffer_sync_handler)
- : buffer_allocator_(buffer_allocator), buffer_sync_handler_(buffer_sync_handler),
- num_used_slot_(0) {
-}
-
-void BufferManager::Start() {
- uint32_t slot = 0, num_ready_slot = 0;
-
- // Change the state of acquired buffer_slot to kBufferSlotReady
- while ((num_ready_slot < num_used_slot_) && (slot < kMaxBufferSlotCount)) {
- if (buffer_slot_[slot].state == kBufferSlotFree) {
- slot++;
- continue;
- }
-
- buffer_slot_[slot++].state = kBufferSlotReady;
- num_ready_slot++;
- }
-}
-
-DisplayError BufferManager::GetNextBuffer(HWBufferInfo *hw_buffer_info) {
- DisplayError error = kErrorNone;
- const BufferConfig &buffer_config = hw_buffer_info->buffer_config;
-
- DLOGI_IF(kTagBufferManager, "Input: w = %d h = %d f = %d", buffer_config.width,
- buffer_config.height, buffer_config.format);
-
- uint32_t free_slot = num_used_slot_;
- uint32_t acquired_slot = kMaxBufferSlotCount;
- uint32_t num_used_slot = 0;
-
- // First look for a buffer slot in ready state, if no buffer slot found in ready state matching
- // with current input config, assign a buffer slot in free state and allocate buffers for it.
- for (uint32_t slot = 0; slot < kMaxBufferSlotCount && num_used_slot < num_used_slot_; slot++) {
- HWBufferInfo &hw_buffer_info = buffer_slot_[slot].hw_buffer_info;
-
- if (buffer_slot_[slot].state == kBufferSlotFree) {
- free_slot = slot;
- } else {
- if ((buffer_slot_[slot].state == kBufferSlotReady)) {
- if ((::memcmp(&buffer_config, &hw_buffer_info.buffer_config, sizeof(BufferConfig)) == 0)) {
- buffer_slot_[slot].state = kBufferSlotAcquired;
- acquired_slot = slot;
- break;
- }
- }
- num_used_slot++;
- }
- }
-
- // If the input config does not match with existing config, then allocate buffers for the new
- // buffer slot and change the state to kBufferSlotAcquired
- if (acquired_slot == kMaxBufferSlotCount) {
- if (free_slot >= kMaxBufferSlotCount) {
- return kErrorMemory;
- }
-
- buffer_slot_[free_slot].hw_buffer_info.buffer_config = hw_buffer_info->buffer_config;
-
- error = buffer_allocator_->AllocateBuffer(&buffer_slot_[free_slot].hw_buffer_info);
- if (error != kErrorNone) {
- return error;
- }
-
- buffer_slot_[free_slot].Init();
- buffer_slot_[free_slot].state = kBufferSlotAcquired;
- acquired_slot = free_slot;
- num_used_slot_++;
-
- DLOGI_IF(kTagBufferManager, "Allocate Buffer acquired_slot = %d ", acquired_slot);
- }
-
- const AllocatedBufferInfo &alloc_buffer_info =
- buffer_slot_[acquired_slot].hw_buffer_info.alloc_buffer_info;
- uint32_t curr_index = buffer_slot_[acquired_slot].curr_index;
-
- // Wait for the release fence fd before buffer slot being given to the client.
- buffer_sync_handler_->SyncWait(buffer_slot_[acquired_slot].release_fd[curr_index]);
- buffer_slot_[acquired_slot].release_fd[curr_index] = -1;
-
- hw_buffer_info->output_buffer.width = buffer_config.width;
- hw_buffer_info->output_buffer.height = buffer_config.height;
- hw_buffer_info->output_buffer.format = buffer_config.format;
- hw_buffer_info->output_buffer.flags.secure = buffer_config.secure;
-
- hw_buffer_info->output_buffer.planes[0].stride = alloc_buffer_info.stride;
- hw_buffer_info->output_buffer.planes[0].fd = alloc_buffer_info.fd;
- hw_buffer_info->output_buffer.planes[0].offset = buffer_slot_[acquired_slot].offset[curr_index];
- hw_buffer_info->slot = acquired_slot;
-
- DLOGI_IF(kTagBufferManager, "Output: w = %d h = %d f = %d session_id %d acquired slot = %d " \
- "num_used_slot %d curr_index = %d offset %d", hw_buffer_info->output_buffer.width,
- hw_buffer_info->output_buffer.height, hw_buffer_info->output_buffer.format,
- hw_buffer_info->session_id, acquired_slot, num_used_slot_, curr_index,
- hw_buffer_info->output_buffer.planes[0].offset);
-
- return kErrorNone;
-}
-
-DisplayError BufferManager::Stop(int *session_ids) {
- DisplayError error = kErrorNone;
- uint32_t slot = 0, count = 0;
-
- // Free all the buffer slots which were not acquired in the current cycle and deallocate the
- // buffers associated with it.
- while ((num_used_slot_ > 0) && (slot < kMaxBufferSlotCount)) {
- if (buffer_slot_[slot].state == kBufferSlotReady) {
- if (buffer_slot_[slot].hw_buffer_info.session_id != -1) {
- session_ids[count++] = buffer_slot_[slot].hw_buffer_info.session_id;
- }
-
- error = FreeBufferSlot(slot);
- if (error != kErrorNone) {
- return error;
- }
-
- num_used_slot_--;
- }
- slot++;
- }
-
- session_ids[count] = -1;
-
- return kErrorNone;
-}
-
-DisplayError BufferManager::SetReleaseFd(uint32_t slot, int fd) {
- if ((slot >= kMaxBufferSlotCount) || (buffer_slot_[slot].state != kBufferSlotAcquired)) {
- DLOGE("Invalid Parameters slot %d state %s", slot, buffer_slot_[slot].state);
- kErrorParameters;
- }
-
- uint32_t &curr_index = buffer_slot_[slot].curr_index;
- const HWBufferInfo &hw_buffer_info = buffer_slot_[slot].hw_buffer_info;
- uint32_t buffer_count = hw_buffer_info.buffer_config.buffer_count;
-
- // 1. Store the release fence fd, so that buffer manager waits for the release fence fd to be
- // signaled and gives the buffer slot to the client.
- // 2. Modify the curr_index to point to next buffer.
- buffer_slot_[slot].release_fd[curr_index] = fd;
- curr_index = (curr_index + 1) % buffer_count;
-
- DLOGI_IF(kTagBufferManager, "w = %d h = %d f = %d session_id %d slot = %d curr_index = %d " \
- "sync fd %d", hw_buffer_info.output_buffer.width, hw_buffer_info.output_buffer.height,
- hw_buffer_info.output_buffer.format, hw_buffer_info.session_id, slot, curr_index, fd);
-
- return kErrorNone;
-}
-
-
-DisplayError BufferManager::SetSessionId(uint32_t slot, int session_id) {
- if ((slot >= kMaxBufferSlotCount) || (buffer_slot_[slot].state != kBufferSlotAcquired)) {
- DLOGE("Invalid Parameters slot %d state %s", slot, buffer_slot_[slot].state);
- kErrorParameters;
- }
-
- HWBufferInfo *hw_buffer_info = &buffer_slot_[slot].hw_buffer_info;
-
- hw_buffer_info->session_id = session_id;
-
- DLOGI_IF(kTagBufferManager, "w = %d h = %d f = %d session_id %d slot = %d",
- hw_buffer_info->output_buffer.width, hw_buffer_info->output_buffer.height,
- hw_buffer_info->output_buffer.format, hw_buffer_info->session_id, slot);
-
- return kErrorNone;
-}
-
-DisplayError BufferManager::FreeBufferSlot(uint32_t slot) {
- DisplayError error = kErrorNone;
-
- HWBufferInfo *hw_buffer_info = &buffer_slot_[slot].hw_buffer_info;
-
- error = buffer_allocator_->FreeBuffer(hw_buffer_info);
- if (error != kErrorNone) {
- return error;
- }
-
- DLOGI_IF(kTagBufferManager, "session_id %d slot = %d num_used_slot %d",
- hw_buffer_info->session_id, slot, num_used_slot_);
-
- buffer_slot_[slot].Deinit();
-
- return kErrorNone;
-}
-
-} // namespace sde
diff --git a/displayengine/libs/core/comp_manager.cpp b/displayengine/libs/core/comp_manager.cpp
index 4e101a3..a694297 100644
--- a/displayengine/libs/core/comp_manager.cpp
+++ b/displayengine/libs/core/comp_manager.cpp
@@ -39,13 +39,12 @@
registered_displays_(0), configured_displays_(0), safe_mode_(false) {
}
-DisplayError CompManager::Init(const HWResourceInfo &hw_res_info, BufferAllocator *buffer_allocator,
- BufferSyncHandler *buffer_sync_handler) {
+DisplayError CompManager::Init(const HWResourceInfo &hw_res_info) {
SCOPE_LOCK(locker_);
DisplayError error = kErrorNone;
- error = res_mgr_.Init(hw_res_info, buffer_allocator, buffer_sync_handler);
+ error = res_mgr_.Init(hw_res_info);
if (error != kErrorNone) {
return error;
}
diff --git a/displayengine/libs/core/comp_manager.h b/displayengine/libs/core/comp_manager.h
index 06871f1..951019b 100644
--- a/displayengine/libs/core/comp_manager.h
+++ b/displayengine/libs/core/comp_manager.h
@@ -36,8 +36,7 @@
class CompManager : public DumpImpl {
public:
CompManager();
- DisplayError Init(const HWResourceInfo &hw_res_info_, BufferAllocator *buffer_allocator,
- BufferSyncHandler *buffer_sync_handler_);
+ DisplayError Init(const HWResourceInfo &hw_res_info_);
DisplayError Deinit();
DisplayError RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
const HWPanelInfo &hw_panel_info, Handle *res_mgr_hnd);
diff --git a/displayengine/libs/core/core_impl.cpp b/displayengine/libs/core/core_impl.cpp
index f04bbb9..4f68fcb 100644
--- a/displayengine/libs/core/core_impl.cpp
+++ b/displayengine/libs/core/core_impl.cpp
@@ -31,6 +31,7 @@
#include "display_hdmi.h"
#include "display_virtual.h"
#include "hw_info_interface.h"
+#include "rotator_ctrl.h"
#define __CLASS__ "CoreImpl"
@@ -39,7 +40,7 @@
CoreImpl::CoreImpl(CoreEventHandler *event_handler, BufferAllocator *buffer_allocator,
BufferSyncHandler *buffer_sync_handler)
: event_handler_(event_handler), buffer_allocator_(buffer_allocator),
- buffer_sync_handler_(buffer_sync_handler), hw_resource_(NULL) {
+ buffer_sync_handler_(buffer_sync_handler), hw_resource_(NULL), rotator_ctrl_(NULL) {
}
DisplayError CoreImpl::Init() {
@@ -62,16 +63,24 @@
goto CleanUpOnError;
}
- error = comp_mgr_.Init(*hw_resource_, buffer_allocator_, buffer_sync_handler_);
+ error = comp_mgr_.Init(*hw_resource_);
if (error != kErrorNone) {
- comp_mgr_.Deinit();
goto CleanUpOnError;
}
- error = offline_ctrl_.Init(buffer_sync_handler_);
- if (error != kErrorNone) {
+ rotator_ctrl_ = new RotatorCtrl();
+ if (!rotator_ctrl_) {
+ comp_mgr_.Deinit();
+ error = kErrorMemory;
goto CleanUpOnError;
}
+
+ error = rotator_ctrl_->Init(buffer_allocator_, buffer_sync_handler_);
+ if (error != kErrorNone) {
+ delete rotator_ctrl_;
+ rotator_ctrl_ = NULL;
+ }
+
return kErrorNone;
CleanUpOnError:
@@ -88,7 +97,7 @@
DisplayError CoreImpl::Deinit() {
SCOPE_LOCK(locker_);
- offline_ctrl_.Deinit();
+ rotator_ctrl_->Deinit();
comp_mgr_.Deinit();
HWInfoInterface::Destroy(hw_info_intf_);
@@ -108,15 +117,15 @@
switch (type) {
case kPrimary:
display_base = new DisplayPrimary(event_handler, hw_info_intf_, buffer_sync_handler_,
- &comp_mgr_, &offline_ctrl_);
+ &comp_mgr_, rotator_ctrl_);
break;
case kHDMI:
display_base = new DisplayHDMI(event_handler, hw_info_intf_, buffer_sync_handler_,
- &comp_mgr_, &offline_ctrl_);
+ &comp_mgr_, rotator_ctrl_);
break;
case kVirtual:
display_base = new DisplayVirtual(event_handler, hw_info_intf_, buffer_sync_handler_,
- &comp_mgr_, &offline_ctrl_);
+ &comp_mgr_, rotator_ctrl_);
break;
default:
DLOGE("Spurious display type %d", type);
diff --git a/displayengine/libs/core/core_impl.h b/displayengine/libs/core/core_impl.h
index 03733a8..5ac1613 100644
--- a/displayengine/libs/core/core_impl.h
+++ b/displayengine/libs/core/core_impl.h
@@ -31,13 +31,13 @@
#include "hw_interface.h"
#include "comp_manager.h"
-#include "offline_ctrl.h"
#define SET_REVISION(major, minor) ((major << 8) | minor)
namespace sde {
class HWInfoInterface;
+class RotatorCtrl;
class CoreImpl : public CoreInterface {
public:
@@ -66,7 +66,7 @@
BufferSyncHandler *buffer_sync_handler_;
HWResourceInfo *hw_resource_;
CompManager comp_mgr_;
- OfflineCtrl offline_ctrl_;
+ RotatorCtrl *rotator_ctrl_;
HWInfoInterface *hw_info_intf_;
};
diff --git a/displayengine/libs/core/display_base.cpp b/displayengine/libs/core/display_base.cpp
index a70a7c9..964ad16 100644
--- a/displayengine/libs/core/display_base.cpp
+++ b/displayengine/libs/core/display_base.cpp
@@ -26,7 +26,7 @@
#include <utils/debug.h>
#include "display_base.h"
-#include "offline_ctrl.h"
+#include "rotator_ctrl.h"
#define __CLASS__ "DisplayBase"
@@ -35,10 +35,10 @@
// TODO(user): Have a single structure handle carries all the interface pointers and variables.
DisplayBase::DisplayBase(DisplayType display_type, DisplayEventHandler *event_handler,
HWDeviceType hw_device_type, BufferSyncHandler *buffer_sync_handler,
- CompManager *comp_manager, OfflineCtrl *offline_ctrl)
+ CompManager *comp_manager, RotatorCtrl *rotator_ctrl)
: display_type_(display_type), event_handler_(event_handler), hw_device_type_(hw_device_type),
buffer_sync_handler_(buffer_sync_handler), comp_manager_(comp_manager),
- offline_ctrl_(offline_ctrl), state_(kStateOff), hw_device_(0), display_comp_ctx_(0),
+ rotator_ctrl_(rotator_ctrl), state_(kStateOff), hw_device_(0), display_comp_ctx_(0),
display_attributes_(NULL), num_modes_(0), active_mode_index_(0), pending_commit_(false),
vsync_enable_(false) {
}
@@ -79,9 +79,11 @@
goto CleanupOnError;
}
- error = offline_ctrl_->RegisterDisplay(display_type_, &display_offline_ctx_);
- if (error != kErrorNone) {
- goto CleanupOnError;
+ if (rotator_ctrl_) {
+ error = rotator_ctrl_->RegisterDisplay(display_type_, &display_rotator_ctx_);
+ if (error != kErrorNone) {
+ goto CleanupOnError;
+ }
}
return kErrorNone;
@@ -102,7 +104,9 @@
}
DisplayError DisplayBase::Deinit() {
- offline_ctrl_->UnregisterDisplay(display_offline_ctx_);
+ if (rotator_ctrl_) {
+ rotator_ctrl_->UnregisterDisplay(display_rotator_ctx_);
+ }
comp_manager_->UnregisterDisplay(display_comp_ctx_);
@@ -137,7 +141,13 @@
break;
}
- error = offline_ctrl_->Prepare(display_offline_ctx_, &hw_layers_);
+ if (IsRotationRequired(&hw_layers_)) {
+ if (!rotator_ctrl_) {
+ continue;
+ }
+ error = rotator_ctrl_->Prepare(display_rotator_ctx_, &hw_layers_);
+ }
+
if (error == kErrorNone) {
error = hw_intf_->Validate(&hw_layers_);
if (error == kErrorNone) {
@@ -162,30 +172,41 @@
return kErrorParameters;
}
- if (state_ == kStateOn) {
- if (!pending_commit_) {
- DLOGE("Commit: Corresponding Prepare() is not called for display = %d", display_type_);
- return kErrorUndefined;
- }
-
- error = offline_ctrl_->Commit(display_offline_ctx_, &hw_layers_);
- if (error == kErrorNone) {
- error = hw_intf_->Commit(&hw_layers_);
- if (error == kErrorNone) {
- error = comp_manager_->PostCommit(display_comp_ctx_, &hw_layers_);
- if (error != kErrorNone) {
- DLOGE("Composition manager PostCommit failed");
- }
- } else {
- DLOGE("Unexpected error. Commit failed on driver.");
- }
- }
- } else {
+ if (state_ != kStateOn) {
return kErrorNotSupported;
}
+ if (!pending_commit_) {
+ DLOGE("Commit: Corresponding Prepare() is not called for display = %d", display_type_);
+ return kErrorUndefined;
+ }
+
pending_commit_ = false;
+ if (rotator_ctrl_ && IsRotationRequired(&hw_layers_)) {
+ error = rotator_ctrl_->Commit(display_rotator_ctx_, &hw_layers_);
+ if (error != kErrorNone) {
+ return error;
+ }
+ }
+
+ error = hw_intf_->Commit(&hw_layers_);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ if (rotator_ctrl_ && IsRotationRequired(&hw_layers_)) {
+ error = rotator_ctrl_->PostCommit(display_rotator_ctx_, &hw_layers_);
+ if (error != kErrorNone) {
+ return error;
+ }
+ }
+
+ error = comp_manager_->PostCommit(display_comp_ctx_, &hw_layers_);
+ if (error != kErrorNone) {
+ return error;
+ }
+
return kErrorNone;
}
@@ -402,10 +423,13 @@
Layer &layer = hw_layers_.info.stack->layers[hw_layers_.info.index[i]];
LayerBuffer *input_buffer = layer.input_buffer;
HWLayerConfig &layer_config = hw_layers_.config[i];
+
HWPipeInfo &left_pipe = hw_layers_.config[i].left_pipe;
HWPipeInfo &right_pipe = hw_layers_.config[i].right_pipe;
- HWRotateInfo &left_rotate = hw_layers_.config[i].rotates[0];
- HWRotateInfo &right_rotate = hw_layers_.config[i].rotates[1];
+
+ HWRotatorSession &hw_rotator_session = layer_config.hw_rotator_session;
+ HWRotateInfo &left_rotate = hw_rotator_session.hw_rotate_info[0];
+ HWRotateInfo &right_rotate = hw_rotator_session.hw_rotate_info[1];
DumpImpl::AppendString(buffer, length, "\n\nsde idx: %u, actual idx: %u", i,
hw_layers_.info.index[i]);
@@ -454,5 +478,20 @@
return (num_modes_ == 1) ? 0 : -1;
}
+bool DisplayBase::IsRotationRequired(HWLayers *hw_layers) {
+ HWLayersInfo &layer_info = hw_layers->info;
+
+ for (uint32_t i = 0; i < layer_info.count; i++) {
+ Layer& layer = layer_info.stack->layers[layer_info.index[i]];
+ HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+
+ if (hw_rotator_session->hw_block_count) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
} // namespace sde
diff --git a/displayengine/libs/core/display_base.h b/displayengine/libs/core/display_base.h
index 6d107a0..1edef9e 100644
--- a/displayengine/libs/core/display_base.h
+++ b/displayengine/libs/core/display_base.h
@@ -31,18 +31,17 @@
#include "hw_interface.h"
#include "comp_manager.h"
-#include "buffer_manager.h"
namespace sde {
-class OfflineCtrl;
+class RotatorCtrl;
class DisplayBase : public DisplayInterface {
public:
DisplayBase(DisplayType display_type, DisplayEventHandler *event_handler,
HWDeviceType hw_device_type, BufferSyncHandler *buffer_sync_handler,
- CompManager *comp_manager, OfflineCtrl *offline_ctrl);
+ CompManager *comp_manager, RotatorCtrl *rotator_ctrl);
virtual ~DisplayBase() { }
virtual DisplayError Init();
virtual DisplayError Deinit();
@@ -61,6 +60,9 @@
virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
virtual DisplayError SetDisplayMode(uint32_t mode);
+ private:
+ bool IsRotationRequired(HWLayers *hw_layers);
+
protected:
// DumpImpl method
void AppendDump(char *buffer, uint32_t length);
@@ -75,11 +77,11 @@
HWPanelInfo hw_panel_info_;
BufferSyncHandler *buffer_sync_handler_;
CompManager *comp_manager_;
- OfflineCtrl *offline_ctrl_;
+ RotatorCtrl *rotator_ctrl_;
DisplayState state_;
Handle hw_device_;
Handle display_comp_ctx_;
- Handle display_offline_ctx_;
+ Handle display_rotator_ctx_;
HWDisplayAttributes *display_attributes_;
uint32_t num_modes_;
uint32_t active_mode_index_;
diff --git a/displayengine/libs/core/display_hdmi.cpp b/displayengine/libs/core/display_hdmi.cpp
index 2b6ba81..65ea21f 100644
--- a/displayengine/libs/core/display_hdmi.cpp
+++ b/displayengine/libs/core/display_hdmi.cpp
@@ -35,9 +35,9 @@
DisplayHDMI::DisplayHDMI(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
- OfflineCtrl *offline_ctrl)
+ RotatorCtrl *rotator_ctrl)
: DisplayBase(kHDMI, event_handler, kDeviceHDMI, buffer_sync_handler, comp_manager,
- offline_ctrl), hw_info_intf_(hw_info_intf) {
+ rotator_ctrl), hw_info_intf_(hw_info_intf) {
}
DisplayError DisplayHDMI::Init() {
diff --git a/displayengine/libs/core/display_hdmi.h b/displayengine/libs/core/display_hdmi.h
index fc2be21..1a96884 100644
--- a/displayengine/libs/core/display_hdmi.h
+++ b/displayengine/libs/core/display_hdmi.h
@@ -36,7 +36,7 @@
public:
DisplayHDMI(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
- OfflineCtrl *offline_ctrl);
+ RotatorCtrl *rotator_ctrl);
virtual DisplayError Init();
virtual DisplayError Deinit();
virtual DisplayError Prepare(LayerStack *layer_stack);
diff --git a/displayengine/libs/core/display_primary.cpp b/displayengine/libs/core/display_primary.cpp
index dcc9a0a..de5b2d0 100644
--- a/displayengine/libs/core/display_primary.cpp
+++ b/displayengine/libs/core/display_primary.cpp
@@ -35,9 +35,9 @@
DisplayPrimary::DisplayPrimary(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
- OfflineCtrl *offline_ctrl)
+ RotatorCtrl *rotator_ctrl)
: DisplayBase(kPrimary, event_handler, kDevicePrimary, buffer_sync_handler, comp_manager,
- offline_ctrl), hw_info_intf_(hw_info_intf) {
+ rotator_ctrl), hw_info_intf_(hw_info_intf) {
}
DisplayError DisplayPrimary::Init() {
diff --git a/displayengine/libs/core/display_primary.h b/displayengine/libs/core/display_primary.h
index 8ce4f28..a09975d 100644
--- a/displayengine/libs/core/display_primary.h
+++ b/displayengine/libs/core/display_primary.h
@@ -36,7 +36,7 @@
public:
DisplayPrimary(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
- OfflineCtrl *offline_ctrl);
+ RotatorCtrl *rotator_ctrl);
virtual DisplayError Init();
virtual DisplayError Deinit();
virtual DisplayError Prepare(LayerStack *layer_stack);
diff --git a/displayengine/libs/core/display_virtual.cpp b/displayengine/libs/core/display_virtual.cpp
index a5af9bf..5480f0e 100644
--- a/displayengine/libs/core/display_virtual.cpp
+++ b/displayengine/libs/core/display_virtual.cpp
@@ -35,9 +35,9 @@
DisplayVirtual::DisplayVirtual(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
- OfflineCtrl *offline_ctrl)
+ RotatorCtrl *rotator_ctrl)
: DisplayBase(kVirtual, event_handler, kDeviceVirtual, buffer_sync_handler, comp_manager,
- offline_ctrl), hw_info_intf_(hw_info_intf) {
+ rotator_ctrl), hw_info_intf_(hw_info_intf) {
}
DisplayError DisplayVirtual::Init() {
diff --git a/displayengine/libs/core/display_virtual.h b/displayengine/libs/core/display_virtual.h
index 419c6ec..8e7a764 100644
--- a/displayengine/libs/core/display_virtual.h
+++ b/displayengine/libs/core/display_virtual.h
@@ -36,7 +36,7 @@
public:
DisplayVirtual(DisplayEventHandler *event_handler, HWInfoInterface *hw_info_intf,
BufferSyncHandler *buffer_sync_handler, CompManager *comp_manager,
- OfflineCtrl *offline_ctrl);
+ RotatorCtrl *rotator_ctrl);
virtual DisplayError Init();
virtual DisplayError Deinit();
virtual DisplayError Prepare(LayerStack *layer_stack);
diff --git a/displayengine/libs/core/fb/hw_device.cpp b/displayengine/libs/core/fb/hw_device.cpp
index a0a0fe2..184dc64 100644
--- a/displayengine/libs/core/fb/hw_device.cpp
+++ b/displayengine/libs/core/fb/hw_device.cpp
@@ -209,14 +209,15 @@
LayerBuffer *input_buffer = layer.input_buffer;
HWPipeInfo *left_pipe = &hw_layers->config[i].left_pipe;
HWPipeInfo *right_pipe = &hw_layers->config[i].right_pipe;
+ HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
mdp_input_layer mdp_layer;
for (uint32_t count = 0; count < 2; count++) {
HWPipeInfo *pipe_info = (count == 0) ? left_pipe : right_pipe;
- HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
+ HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
- if (rotate_info->valid) {
- input_buffer = &rotate_info->hw_buffer_info.output_buffer;
+ if (hw_rotate_info->valid) {
+ input_buffer = &hw_rotator_session->output_buffer;
}
if (pipe_info->valid) {
@@ -272,8 +273,9 @@
DLOGV_IF(kTagDriverConfig, "in_w %d, in_h %d, in_f %d", mdp_buffer.width, mdp_buffer.height,
mdp_buffer.format);
DLOGV_IF(kTagDriverConfig, "plane_alpha %d, zorder %d, blending %d, horz_deci %d, "
- "vert_deci %d", mdp_layer.alpha, mdp_layer.z_order, mdp_layer.blend_op,
- mdp_layer.horz_deci, mdp_layer.vert_deci);
+ "vert_deci %d, pipe_id = 0x%x, mdp_flags 0x%x", mdp_layer.alpha, mdp_layer.z_order,
+ mdp_layer.blend_op, mdp_layer.horz_deci, mdp_layer.vert_deci, mdp_layer.pipe_ndx,
+ mdp_layer.flags);
DLOGV_IF(kTagDriverConfig, "src_rect [%d, %d, %d, %d]", mdp_layer.src_rect.x,
mdp_layer.src_rect.y, mdp_layer.src_rect.w, mdp_layer.src_rect.h);
DLOGV_IF(kTagDriverConfig, "dst_rect [%d, %d, %d, %d]", mdp_layer.dst_rect.x,
@@ -305,11 +307,11 @@
mdp_out_layer_.buffer.height = output_buffer->height;
SetFormat(output_buffer->format, &mdp_out_layer_.buffer.format);
- DLOGI_IF(kTagDriverConfig, "******************* Output buffer Info **********************");
+ DLOGI_IF(kTagDriverConfig, "********************* Output buffer Info ************************");
DLOGI_IF(kTagDriverConfig, "out_w %d, out_h %d, out_f %d, wb_id %d",
mdp_out_layer_.buffer.width, mdp_out_layer_.buffer.height,
mdp_out_layer_.buffer.format, mdp_out_layer_.writeback_ndx);
- DLOGI_IF(kTagDriverConfig, "*************************************************************");
+ DLOGI_IF(kTagDriverConfig, "*****************************************************************");
}
mdp_commit.flags |= MDP_VALIDATE_LAYER;
@@ -326,13 +328,13 @@
mdp_layer_commit_v1 &mdp_commit = layer_commit.commit_v1;
mdp_input_layer *mdp_layers = mdp_commit.input_layers;
- DLOGE("mdp_commt: flags = %x, release fence = %x", mdp_commit.flags, mdp_commit.release_fence);
+ DLOGE("mdp_commit: flags = %x, release fence = %x", mdp_commit.flags, mdp_commit.release_fence);
DLOGE("left_roi: x = %d, y = %d, w = %d, h = %d", mdp_commit.left_roi.x, mdp_commit.left_roi.y,
mdp_commit.left_roi.w, mdp_commit.left_roi.h);
DLOGE("right_roi: x = %d, y = %d, w = %d, h = %d", mdp_commit.right_roi.x,
mdp_commit.right_roi.y, mdp_commit.right_roi.w, mdp_commit.right_roi.h);
for (uint32_t i = 0; i < mdp_commit.input_layer_cnt; i++) {
- DLOGE("mdp_commt: layer_cnt = %d, pipe_ndx = %x, zorder = %d, flags = %x",
+ DLOGE("mdp_commit: layer_cnt = %d, pipe_ndx = %x, zorder = %d, flags = %x",
i, mdp_layers[i].pipe_ndx, mdp_layers[i].z_order, mdp_layers[i].flags);
mdp_rect &src_rect = mdp_layers[i].src_rect;
DLOGE("src rect: x = %d, y = %d, w = %d, h = %d",
@@ -361,13 +363,14 @@
LayerBuffer *input_buffer = stack->layers[layer_index].input_buffer;
HWPipeInfo *left_pipe = &hw_layers->config[i].left_pipe;
HWPipeInfo *right_pipe = &hw_layers->config[i].right_pipe;
+ HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
for (uint32_t count = 0; count < 2; count++) {
HWPipeInfo *pipe_info = (count == 0) ? left_pipe : right_pipe;
- HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
+ HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
- if (rotate_info->valid) {
- input_buffer = &rotate_info->hw_buffer_info.output_buffer;
+ if (hw_rotate_info->valid) {
+ input_buffer = &hw_rotator_session->output_buffer;
}
if (pipe_info->valid) {
@@ -416,11 +419,11 @@
mdp_out_layer_.buffer.fence = output_buffer->acquire_fence_fd;
- DLOGI_IF(kTagDriverConfig, "******************* Output buffer Info **********************");
+ DLOGI_IF(kTagDriverConfig, "********************** Output buffer Info ***********************");
DLOGI_IF(kTagDriverConfig, "out_fd %d, out_offset %d, out_stride %d, acquire_fence %d",
mdp_out_layer_.buffer.planes[0].fd, mdp_out_layer_.buffer.planes[0].offset,
mdp_out_layer_.buffer.planes[0].stride, mdp_out_layer_.buffer.fence);
- DLOGI_IF(kTagDriverConfig, "*************************************************************");
+ DLOGI_IF(kTagDriverConfig, "*****************************************************************");
}
mdp_commit.release_fence = -1;
@@ -442,8 +445,9 @@
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
uint32_t layer_index = hw_layer_info.index[i];
LayerBuffer *input_buffer = stack->layers[layer_index].input_buffer;
- HWRotateInfo *left_rotate = &hw_layers->config[i].rotates[0];
- HWRotateInfo *right_rotate = &hw_layers->config[i].rotates[1];
+ HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+ HWRotateInfo *left_rotate = &hw_rotator_session->hw_rotate_info[0];
+ HWRotateInfo *right_rotate = &hw_rotator_session->hw_rotate_info[1];
if (!left_rotate->valid && !right_rotate->valid) {
input_buffer->release_fence_fd = dup(mdp_commit.release_fence);
@@ -451,9 +455,9 @@
}
for (uint32_t count = 0; count < 2; count++) {
- HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
- if (rotate_info->valid) {
- input_buffer = &rotate_info->hw_buffer_info.output_buffer;
+ HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
+ if (hw_rotate_info->valid) {
+ input_buffer = &hw_rotator_session->output_buffer;
input_buffer->release_fence_fd = dup(mdp_commit.release_fence);
close_(input_buffer->acquire_fence_fd);
input_buffer->acquire_fence_fd = -1;
@@ -463,7 +467,7 @@
DLOGI_IF(kTagDriverConfig, "*************************** %s Commit Input ************************",
device_name_);
DLOGI_IF(kTagDriverConfig, "retire_fence_fd %d", stack->retire_fence_fd);
- DLOGI_IF(kTagDriverConfig, "*************************************************************");
+ DLOGI_IF(kTagDriverConfig, "*******************************************************************");
close_(mdp_commit.release_fence);
@@ -527,7 +531,7 @@
DisplayError HWDevice::SetStride(HWDeviceType device_type, LayerBufferFormat format,
uint32_t width, uint32_t *target) {
- // TODO(user): This SetStride function is an workaround to satisfy the driver expectation for
+ // TODO(user): This SetStride function is a workaround to satisfy the driver expectation for
// rotator and virtual devices. Eventually this will be taken care in the driver.
if (device_type != kDeviceRotator && device_type != kDeviceVirtual) {
*target = width;
diff --git a/displayengine/libs/core/fb/hw_rotator.cpp b/displayengine/libs/core/fb/hw_rotator.cpp
index cc9caa5..cc9bd1a 100644
--- a/displayengine/libs/core/fb/hw_rotator.cpp
+++ b/displayengine/libs/core/fb/hw_rotator.cpp
@@ -36,8 +36,8 @@
namespace sde {
-DisplayError HWRotatorInterface::Create(HWRotatorInterface **intf,
- BufferSyncHandler *buffer_sync_handler) {
+DisplayError HWRotatorInterface::Create(BufferSyncHandler *buffer_sync_handler,
+ HWRotatorInterface **intf) {
DisplayError error = kErrorNone;
HWRotator *hw_rotator = NULL;
@@ -85,64 +85,93 @@
return kErrorNone;
}
-DisplayError HWRotator::OpenSession(HWRotateInfo *rotate_info) {
- LayerBuffer *input_buffer = rotate_info->input_buffer;
- HWBufferInfo *rot_buf_info = &rotate_info->hw_buffer_info;
+DisplayError HWRotator::OpenSession(HWRotatorSession *hw_rotator_session) {
+ uint32_t frame_rate = hw_rotator_session->hw_session_config.frame_rate;
+ LayerBufferFormat src_format = hw_rotator_session->hw_session_config.src_format;
+ LayerBufferFormat dst_format = hw_rotator_session->hw_session_config.dst_format;
+ bool rot90 = (hw_rotator_session->transform.rotation == 90.0f);
- ResetRotatorParams();
+ for (uint32_t i = 0; i < hw_rotator_session->hw_block_count; i++) {
+ HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[i];
- STRUCT_VAR(mdp_rotation_config, mdp_rot_config);
- mdp_rot_config.version = MDP_ROTATION_REQUEST_VERSION_1_0;
- mdp_rot_config.input.width = input_buffer->width;
- mdp_rot_config.input.height = input_buffer->height;
- HWDevice::SetFormat(input_buffer->format, &mdp_rot_config.input.format);
- mdp_rot_config.output.width = rot_buf_info->output_buffer.width;
- mdp_rot_config.output.height = rot_buf_info->output_buffer.height;
- HWDevice::SetFormat(rot_buf_info->output_buffer.format, &mdp_rot_config.output.format);
- mdp_rot_config.frame_rate = rotate_info->frame_rate;
+ if (!hw_rotate_info->valid) {
+ continue;
+ }
- if (ioctl_(HWDevice::device_fd_, MDSS_ROTATION_OPEN, &mdp_rot_config) < 0) {
- IOCTL_LOGE(MDSS_ROTATION_OPEN, HWDevice::device_type_);
- return kErrorHardware;
+ uint32_t src_width = UINT32(hw_rotate_info->src_roi.right - hw_rotate_info->src_roi.left);
+ uint32_t src_height =
+ UINT32(hw_rotate_info->src_roi.bottom - hw_rotate_info->src_roi.top);
+
+ uint32_t dst_width = UINT32(hw_rotate_info->dst_roi.right - hw_rotate_info->dst_roi.left);
+ uint32_t dst_height =
+ UINT32(hw_rotate_info->dst_roi.bottom - hw_rotate_info->dst_roi.top);
+
+ STRUCT_VAR(mdp_rotation_config, mdp_rot_config);
+
+ mdp_rot_config.version = MDP_ROTATION_REQUEST_VERSION_1_0;
+ mdp_rot_config.input.width = src_width;
+ mdp_rot_config.input.height = src_height;
+ SetFormat(src_format, &mdp_rot_config.input.format);
+ mdp_rot_config.output.width = dst_width;
+ mdp_rot_config.output.height = dst_height;
+ SetFormat(dst_format, &mdp_rot_config.output.format);
+ mdp_rot_config.frame_rate = frame_rate;
+
+ if (rot90) {
+ mdp_rot_config.flags |= MDP_ROTATION_90;
+ }
+
+ if (ioctl_(device_fd_, MDSS_ROTATION_OPEN, &mdp_rot_config) < 0) {
+ IOCTL_LOGE(MDSS_ROTATION_OPEN, device_type_);
+ return kErrorHardware;
+ }
+
+ hw_rotate_info->rotate_id = mdp_rot_config.session_id;
+
+ DLOGV_IF(kTagDriverConfig, "session_id %d", hw_rotate_info->rotate_id);
}
- rot_buf_info->session_id = mdp_rot_config.session_id;
-
- DLOGV_IF(kTagDriverConfig, "session_id %d", rot_buf_info->session_id);
-
return kErrorNone;
}
-DisplayError HWRotator::CloseSession(int32_t session_id) {
- if (ioctl_(HWDevice::device_fd_, MDSS_ROTATION_CLOSE, (uint32_t)session_id) < 0) {
- IOCTL_LOGE(MDSS_ROTATION_CLOSE, HWDevice::device_type_);
- return kErrorHardware;
- }
+DisplayError HWRotator::CloseSession(HWRotatorSession *hw_rotator_session) {
+ for (uint32_t i = 0; i < hw_rotator_session->hw_block_count; i++) {
+ HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[i];
- DLOGV_IF(kTagDriverConfig, "session_id %d", session_id);
+ if (!hw_rotate_info->valid) {
+ continue;
+ }
+
+ if (ioctl_(device_fd_, MDSS_ROTATION_CLOSE, UINT32(hw_rotate_info->rotate_id)) < 0) {
+ IOCTL_LOGE(MDSS_ROTATION_CLOSE, device_type_);
+ return kErrorHardware;
+ }
+
+ DLOGV_IF(kTagDriverConfig, "session_id %d", hw_rotate_info->rotate_id);
+ }
return kErrorNone;
}
-void HWRotator::SetRotatorCtrlParams(HWLayers *hw_layers) {
+void HWRotator::SetCtrlParams(HWLayers *hw_layers) {
DLOGV_IF(kTagDriverConfig, "************************* %s Validate Input ************************",
HWDevice::device_name_);
- ResetRotatorParams();
+ ResetParams();
HWLayersInfo &hw_layer_info = hw_layers->info;
uint32_t &rot_count = mdp_rot_request_.count;
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
+ HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+ bool rot90 = (layer.transform.rotation == 90.0f);
- for (uint32_t count = 0; count < 2; count++) {
- HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
+ for (uint32_t count = 0; count < hw_rotator_session->hw_block_count; count++) {
+ HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
- if (rotate_info->valid) {
- HWBufferInfo *rot_buf_info = &rotate_info->hw_buffer_info;
+ if (hw_rotate_info->valid) {
mdp_rotation_item *mdp_rot_item = &mdp_rot_request_.list[rot_count];
- bool rot90 = (layer.transform.rotation == 90.0f);
if (rot90) {
mdp_rot_item->flags |= MDP_ROTATION_90;
@@ -156,8 +185,8 @@
mdp_rot_item->flags |= MDP_ROTATION_FLIP_UD;
}
- HWDevice::SetRect(rotate_info->src_roi, &mdp_rot_item->src_rect);
- HWDevice::SetRect(rotate_info->dst_roi, &mdp_rot_item->dst_rect);
+ SetRect(hw_rotate_info->src_roi, &mdp_rot_item->src_rect);
+ SetRect(hw_rotate_info->dst_roi, &mdp_rot_item->dst_rect);
// TODO(user): Need to assign the writeback id and pipe id returned from resource manager.
mdp_rot_item->pipe_idx = 0;
@@ -165,11 +194,13 @@
mdp_rot_item->input.width = layer.input_buffer->width;
mdp_rot_item->input.height = layer.input_buffer->height;
- HWDevice::SetFormat(layer.input_buffer->format, &mdp_rot_item->input.format);
+ SetFormat(layer.input_buffer->format, &mdp_rot_item->input.format);
- mdp_rot_item->output.width = rot_buf_info->output_buffer.width;
- mdp_rot_item->output.height = rot_buf_info->output_buffer.height;
- HWDevice::SetFormat(rot_buf_info->output_buffer.format, &mdp_rot_item->output.format);
+ mdp_rot_item->output.width = hw_rotator_session->output_buffer.width;
+ mdp_rot_item->output.height = hw_rotator_session->output_buffer.height;
+ SetFormat(hw_rotator_session->output_buffer.format, &mdp_rot_item->output.format);
+
+ mdp_rot_item->session_id = hw_rotate_info->rotate_id;
rot_count++;
@@ -179,8 +210,9 @@
mdp_rot_item->input.width, mdp_rot_item->input.height, mdp_rot_item->input.format,
mdp_rot_item->output.width, mdp_rot_item->output.height,
mdp_rot_item->output.format);
- DLOGV_IF(kTagDriverConfig, "pipe_id %d, wb_id %d, rot_flag %d", mdp_rot_item->pipe_idx,
- mdp_rot_item->wb_idx, mdp_rot_item->flags);
+ DLOGV_IF(kTagDriverConfig, "pipe_id 0x%x, wb_id %d, rot_flag 0x%x, session_id %d",
+ mdp_rot_item->pipe_idx, mdp_rot_item->wb_idx, mdp_rot_item->flags,
+ mdp_rot_item->session_id);
DLOGV_IF(kTagDriverConfig, "src_rect [%d, %d, %d, %d]", mdp_rot_item->src_rect.x,
mdp_rot_item->src_rect.y, mdp_rot_item->src_rect.w, mdp_rot_item->src_rect.h);
DLOGV_IF(kTagDriverConfig, "dst_rect [%d, %d, %d, %d]", mdp_rot_item->dst_rect.x,
@@ -191,7 +223,7 @@
}
}
-void HWRotator::SetRotatorBufferParams(HWLayers *hw_layers) {
+void HWRotator::SetBufferParams(HWLayers *hw_layers) {
HWLayersInfo &hw_layer_info = hw_layers->info;
uint32_t rot_count = 0;
@@ -201,26 +233,26 @@
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
+ HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
- for (uint32_t count = 0; count < 2; count++) {
- HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
+ for (uint32_t count = 0; count < hw_rotator_session->hw_block_count; count++) {
+ HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
- if (rotate_info->valid) {
- HWBufferInfo *rot_buf_info = &rotate_info->hw_buffer_info;
+ if (hw_rotate_info->valid) {
mdp_rotation_item *mdp_rot_item = &mdp_rot_request_.list[rot_count];
mdp_rot_item->input.planes[0].fd = layer.input_buffer->planes[0].fd;
mdp_rot_item->input.planes[0].offset = layer.input_buffer->planes[0].offset;
- HWDevice::SetStride(HWDevice::device_type_, layer.input_buffer->format,
- layer.input_buffer->width, &mdp_rot_item->input.planes[0].stride);
+ SetStride(device_type_, layer.input_buffer->format, layer.input_buffer->width,
+ &mdp_rot_item->input.planes[0].stride);
mdp_rot_item->input.plane_count = 1;
mdp_rot_item->input.fence = layer.input_buffer->acquire_fence_fd;
- mdp_rot_item->output.planes[0].fd = rot_buf_info->output_buffer.planes[0].fd;
- mdp_rot_item->output.planes[0].offset = rot_buf_info->output_buffer.planes[0].offset;
- HWDevice::SetStride(HWDevice::device_type_, rot_buf_info->output_buffer.format,
- rot_buf_info->output_buffer.planes[0].stride,
- &mdp_rot_item->output.planes[0].stride);
+ mdp_rot_item->output.planes[0].fd = hw_rotator_session->output_buffer.planes[0].fd;
+ mdp_rot_item->output.planes[0].offset = hw_rotator_session->output_buffer.planes[0].offset;
+ SetStride(device_type_, hw_rotator_session->output_buffer.format,
+ hw_rotator_session->output_buffer.planes[0].stride,
+ &mdp_rot_item->output.planes[0].stride);
mdp_rot_item->output.plane_count = 1;
mdp_rot_item->output.fence = -1;
@@ -243,7 +275,7 @@
}
DisplayError HWRotator::Validate(HWLayers *hw_layers) {
- SetRotatorCtrlParams(hw_layers);
+ SetCtrlParams(hw_layers);
mdp_rot_request_.flags = MDSS_ROTATION_REQUEST_VALIDATE;
if (ioctl_(HWDevice::device_fd_, MDSS_ROTATION_REQUEST, &mdp_rot_request_) < 0) {
@@ -258,9 +290,9 @@
HWLayersInfo &hw_layer_info = hw_layers->info;
uint32_t rot_count = 0;
- SetRotatorCtrlParams(hw_layers);
+ SetCtrlParams(hw_layers);
- SetRotatorBufferParams(hw_layers);
+ SetBufferParams(hw_layers);
mdp_rot_request_.flags &= ~MDSS_ROTATION_REQUEST_VALIDATE;
if (ioctl_(HWDevice::device_fd_, MDSS_ROTATION_REQUEST, &mdp_rot_request_) < 0) {
@@ -270,20 +302,20 @@
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
+ HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
layer.input_buffer->release_fence_fd = -1;
- for (uint32_t count = 0; count < 2; count++) {
- HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
+ for (uint32_t count = 0; count < hw_rotator_session->hw_block_count; count++) {
+ HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
- if (rotate_info->valid) {
- HWBufferInfo *rot_buf_info = &rotate_info->hw_buffer_info;
+ if (hw_rotate_info->valid) {
mdp_rotation_item *mdp_rot_item = &mdp_rot_request_.list[rot_count];
HWDevice::SyncMerge(layer.input_buffer->release_fence_fd, dup(mdp_rot_item->output.fence),
&layer.input_buffer->release_fence_fd);
- rot_buf_info->output_buffer.acquire_fence_fd = dup(mdp_rot_item->output.fence);
+ hw_rotator_session->output_buffer.acquire_fence_fd = dup(mdp_rot_item->output.fence);
close_(mdp_rot_item->output.fence);
rot_count++;
@@ -294,7 +326,7 @@
return kErrorNone;
}
-void HWRotator::ResetRotatorParams() {
+void HWRotator::ResetParams() {
memset(&mdp_rot_request_, 0, sizeof(mdp_rot_request_));
memset(&mdp_rot_layers_, 0, sizeof(mdp_rot_layers_));
diff --git a/displayengine/libs/core/fb/hw_rotator.h b/displayengine/libs/core/fb/hw_rotator.h
index 6e7727d..3b4eebe 100644
--- a/displayengine/libs/core/fb/hw_rotator.h
+++ b/displayengine/libs/core/fb/hw_rotator.h
@@ -44,15 +44,15 @@
explicit HWRotator(BufferSyncHandler *buffer_sync_handler);
virtual DisplayError Open();
virtual DisplayError Close();
- virtual DisplayError OpenSession(HWRotateInfo *hw_layers);
- virtual DisplayError CloseSession(int32_t session_id);
+ virtual DisplayError OpenSession(HWRotatorSession *hw_session_info);
+ virtual DisplayError CloseSession(HWRotatorSession *hw_session_info);
virtual DisplayError Validate(HWLayers *hw_layers);
virtual DisplayError Commit(HWLayers *hw_layers);
private:
- void ResetRotatorParams();
- void SetRotatorCtrlParams(HWLayers *hw_layers);
- void SetRotatorBufferParams(HWLayers *hw_layers);
+ void ResetParams();
+ void SetCtrlParams(HWLayers *hw_layers);
+ void SetBufferParams(HWLayers *hw_layers);
struct mdp_rotation_request mdp_rot_request_;
struct mdp_rotation_item mdp_rot_layers_[kMaxSDELayers * 2]; // split panel (left + right)
diff --git a/displayengine/libs/core/hw_interface.h b/displayengine/libs/core/hw_interface.h
index e8e0c63..44ac367 100644
--- a/displayengine/libs/core/hw_interface.h
+++ b/displayengine/libs/core/hw_interface.h
@@ -43,33 +43,65 @@
kHWBlockMax
};
-struct HWBufferInfo : public BufferInfo {
- LayerBuffer output_buffer;
- int session_id;
- uint32_t slot;
+struct HWSessionConfig {
+ uint32_t src_width;
+ uint32_t src_height;
+ LayerBufferFormat src_format;
+ uint32_t dst_width;
+ uint32_t dst_height;
+ LayerBufferFormat dst_format;
+ uint32_t buffer_count;
+ bool secure;
+ bool cache;
+ uint32_t frame_rate;
- HWBufferInfo() : session_id(-1), slot(0) { }
+ HWSessionConfig()
+ : src_width(0), src_height(0), src_format(kFormatInvalid), dst_width(0), dst_height(0),
+ dst_format(kFormatInvalid), buffer_count(0), secure(false), cache(false), frame_rate(0) { }
+
+ bool operator != (const HWSessionConfig &input_config) const {
+ if ((src_width != input_config.src_width) || (src_height != input_config.src_height) ||
+ (src_format != input_config.src_format) || (dst_width != input_config.dst_width) ||
+ (dst_height != input_config.dst_height) || (dst_format != input_config.dst_format) ||
+ (buffer_count != input_config.buffer_count) || (secure != input_config.secure) ||
+ (cache != input_config.cache) || (frame_rate != input_config.frame_rate)) {
+ return true;
+ }
+
+ return false;
+ }
+
+ bool operator == (const HWSessionConfig &input_config) const {
+ return !(operator != (input_config));
+ }
};
struct HWRotateInfo {
- LayerBuffer *input_buffer;
uint32_t pipe_id;
LayerRect src_roi;
LayerRect dst_roi;
- LayerBufferFormat dst_format;
HWBlockType writeback_id;
- float downscale_ratio;
- HWBufferInfo hw_buffer_info;
bool valid;
- uint32_t frame_rate;
+ int rotate_id;
- HWRotateInfo() : input_buffer(NULL), pipe_id(0), dst_format(kFormatInvalid),
- writeback_id(kHWWriteback0), downscale_ratio(1.0f), valid(false),
- frame_rate(0) { }
+ HWRotateInfo()
+ : pipe_id(0), writeback_id(kHWWriteback0), valid(false), rotate_id(-1) { }
void Reset() { *this = HWRotateInfo(); }
};
+struct HWRotatorSession {
+ HWRotateInfo hw_rotate_info[kMaxRotatePerLayer];
+ uint32_t hw_block_count; // number of rotator hw blocks used by rotator session
+ float downscale_ratio;
+ LayerTransform transform;
+ HWSessionConfig hw_session_config;
+ LayerBuffer output_buffer;
+ int session_id;
+
+ HWRotatorSession() : hw_block_count(0), downscale_ratio(1.0f), session_id(-1) { }
+};
+
struct HWPipeInfo {
uint32_t pipe_id;
LayerRect src_roi;
@@ -79,8 +111,8 @@
bool valid;
uint32_t z_order;
- HWPipeInfo() : pipe_id(0), horizontal_decimation(0), vertical_decimation(0), valid(false),
- z_order(0) { }
+ HWPipeInfo()
+ : pipe_id(0), horizontal_decimation(0), vertical_decimation(0), valid(false), z_order(0) { }
void Reset() { *this = HWPipeInfo(); }
};
@@ -89,10 +121,9 @@
bool use_non_dma_pipe; // set by client
HWPipeInfo left_pipe; // pipe for left side of output
HWPipeInfo right_pipe; // pipe for right side of output
- uint32_t num_rotate; // number of rotate
- HWRotateInfo rotates[kMaxRotatePerLayer]; // rotation for the buffer
+ HWRotatorSession hw_rotator_session;
- HWLayerConfig() : use_non_dma_pipe(false), num_rotate(0) { }
+ HWLayerConfig() : use_non_dma_pipe(false) { }
void Reset() { *this = HWLayerConfig(); }
};
@@ -100,11 +131,6 @@
struct HWLayers {
HWLayersInfo info;
HWLayerConfig config[kMaxSDELayers];
- int closed_session_ids[kMaxSDELayers * 2]; // split panel (left + right)
-
- HWLayers() { memset(closed_session_ids, -1, sizeof(closed_session_ids)); }
-
- void Reset() { *this = HWLayers(); }
};
struct HWDisplayAttributes : DisplayConfigVariableInfo {
diff --git a/displayengine/libs/core/hw_rotator_interface.h b/displayengine/libs/core/hw_rotator_interface.h
index 35876d6..0de5d52 100644
--- a/displayengine/libs/core/hw_rotator_interface.h
+++ b/displayengine/libs/core/hw_rotator_interface.h
@@ -30,15 +30,16 @@
class BufferSyncHandler;
struct HWRotateInfo;
struct HWLayers;
+struct HWRotatorSession;
class HWRotatorInterface {
public:
- static DisplayError Create(HWRotatorInterface **intf, BufferSyncHandler *buffer_sync_handler);
+ static DisplayError Create(BufferSyncHandler *buffer_sync_handler, HWRotatorInterface **intf);
static DisplayError Destroy(HWRotatorInterface *intf);
virtual DisplayError Open() = 0;
virtual DisplayError Close() = 0;
- virtual DisplayError OpenSession(HWRotateInfo *rotate_info) = 0;
- virtual DisplayError CloseSession(int32_t session_id) = 0;
+ virtual DisplayError OpenSession(HWRotatorSession *hw_rotator_session) = 0;
+ virtual DisplayError CloseSession(HWRotatorSession *hw_rotator_session) = 0;
virtual DisplayError Validate(HWLayers *hw_layers) = 0;
virtual DisplayError Commit(HWLayers *hw_layers) = 0;
diff --git a/displayengine/libs/core/offline_ctrl.cpp b/displayengine/libs/core/offline_ctrl.cpp
deleted file mode 100644
index b7d5eef..0000000
--- a/displayengine/libs/core/offline_ctrl.cpp
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
-* Copyright (c) 2014 - 2015, 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 <utils/constants.h>
-#include <utils/debug.h>
-
-#include "offline_ctrl.h"
-#include "hw_rotator_interface.h"
-#include <core/buffer_sync_handler.h>
-#include "hw_interface.h"
-
-#define __CLASS__ "OfflineCtrl"
-
-namespace sde {
-
-// TODO(user): Move this offline controller under composition manager like other modules
-// [resource manager]. Implement session management and buffer management in offline controller.
-OfflineCtrl::OfflineCtrl() : hw_rotator_intf_(NULL), hw_rotator_present_(false) {
-}
-
-DisplayError OfflineCtrl::Init(BufferSyncHandler *buffer_sync_handler) {
- DisplayError error = kErrorNone;
-
- error = HWRotatorInterface::Create(&hw_rotator_intf_, buffer_sync_handler);
- if (error != kErrorNone) {
- if (hw_rotator_intf_) {
- HWRotatorInterface::Destroy(hw_rotator_intf_);
- }
- return error;
- }
-
- error = hw_rotator_intf_->Open();
- if (error != kErrorNone) {
- DLOGW("Failed to open rotator device");
- } else {
- hw_rotator_present_ = true;
- }
-
- return kErrorNone;
-}
-
-DisplayError OfflineCtrl::Deinit() {
- DisplayError error = kErrorNone;
-
- error = hw_rotator_intf_->Close();
- if (error != kErrorNone) {
- DLOGW("Failed to close rotator device");
- return error;
- }
- hw_rotator_present_ = false;
- HWRotatorInterface::Destroy(hw_rotator_intf_);
-
- return kErrorNone;
-}
-
-DisplayError OfflineCtrl::RegisterDisplay(DisplayType type, Handle *display_ctx) {
- DisplayOfflineContext *disp_offline_ctx = new DisplayOfflineContext();
- if (disp_offline_ctx == NULL) {
- return kErrorMemory;
- }
-
- disp_offline_ctx->display_type = type;
- *display_ctx = disp_offline_ctx;
-
- return kErrorNone;
-}
-
-void OfflineCtrl::UnregisterDisplay(Handle display_ctx) {
- DisplayOfflineContext *disp_offline_ctx = reinterpret_cast<DisplayOfflineContext *>(display_ctx);
-
- delete disp_offline_ctx;
- disp_offline_ctx = NULL;
-}
-
-
-DisplayError OfflineCtrl::Prepare(Handle display_ctx, HWLayers *hw_layers) {
- DisplayError error = kErrorNone;
-
- DisplayOfflineContext *disp_offline_ctx = reinterpret_cast<DisplayOfflineContext *>(display_ctx);
-
- disp_offline_ctx->pending_rot_commit = false;
-
- if (!hw_rotator_present_ && IsRotationRequired(hw_layers)) {
- DLOGV_IF(kTagOfflineCtrl, "No Rotator device found");
- return kErrorHardware;
- }
-
- error = CloseRotatorSession(hw_layers);
- if (error != kErrorNone) {
- DLOGE("Close rotator session failed for display %d", disp_offline_ctx->display_type);
- return error;
- }
-
-
- if (IsRotationRequired(hw_layers)) {
- error = OpenRotatorSession(hw_layers);
- if (error != kErrorNone) {
- DLOGE("Open rotator session failed for display %d", disp_offline_ctx->display_type);
- return error;
- }
-
- error = hw_rotator_intf_->Validate(hw_layers);
- if (error != kErrorNone) {
- DLOGE("Rotator validation failed for display %d", disp_offline_ctx->display_type);
- return error;
- }
- disp_offline_ctx->pending_rot_commit = true;
- }
-
- return kErrorNone;
-}
-
-DisplayError OfflineCtrl::Commit(Handle display_ctx, HWLayers *hw_layers) {
- DisplayError error = kErrorNone;
-
- DisplayOfflineContext *disp_offline_ctx = reinterpret_cast<DisplayOfflineContext *>(display_ctx);
-
- if (disp_offline_ctx->pending_rot_commit) {
- error = hw_rotator_intf_->Commit(hw_layers);
- if (error != kErrorNone) {
- DLOGE("Rotator commit failed for display %d", disp_offline_ctx->display_type);
- return error;
- }
- disp_offline_ctx->pending_rot_commit = false;
- }
-
- return kErrorNone;
-}
-
-DisplayError OfflineCtrl::OpenRotatorSession(HWLayers *hw_layers) {
- HWLayersInfo &hw_layer_info = hw_layers->info;
- DisplayError error = kErrorNone;
-
- for (uint32_t i = 0; i < hw_layer_info.count; i++) {
- Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
- bool rot90 = (layer.transform.rotation == 90.0f);
-
- for (uint32_t count = 0; count < 2; count++) {
- HWRotateInfo *rotate_info = &hw_layers->config[i].rotates[count];
- HWBufferInfo *rot_buf_info = &rotate_info->hw_buffer_info;
-
- if (!rotate_info->valid || rot_buf_info->session_id >= 0) {
- continue;
- }
-
- rotate_info->input_buffer = layer.input_buffer;
- rotate_info->frame_rate = layer.frame_rate;
-
- error = hw_rotator_intf_->OpenSession(rotate_info);
- if (error != kErrorNone) {
- return error;
- }
- }
- }
-
- return kErrorNone;
-}
-
-DisplayError OfflineCtrl::CloseRotatorSession(HWLayers *hw_layers) {
- DisplayError error = kErrorNone;
- uint32_t i = 0;
-
- while (hw_layers->closed_session_ids[i] >= 0) {
- error = hw_rotator_intf_->CloseSession(hw_layers->closed_session_ids[i]);
- if (error != kErrorNone) {
- return error;
- }
- hw_layers->closed_session_ids[i++] = -1;
- }
-
- return kErrorNone;
-}
-
-bool OfflineCtrl::IsRotationRequired(HWLayers *hw_layers) {
- HWLayersInfo &layer_info = hw_layers->info;
-
- for (uint32_t i = 0; i < layer_info.count; i++) {
- Layer& layer = layer_info.stack->layers[layer_info.index[i]];
-
- HWRotateInfo *rotate = &hw_layers->config[i].rotates[0];
- if (rotate->valid) {
- return true;
- }
-
- rotate = &hw_layers->config[i].rotates[1];
- if (rotate->valid) {
- return true;
- }
- }
- return false;
-}
-
-} // namespace sde
-
diff --git a/displayengine/libs/core/res_config.cpp b/displayengine/libs/core/res_config.cpp
index ecd8ef1..3cea3db 100644
--- a/displayengine/libs/core/res_config.cpp
+++ b/displayengine/libs/core/res_config.cpp
@@ -44,7 +44,8 @@
void ResManager::RotationConfig(const Layer &layer, const float &downscale, LayerRect *src_rect,
struct HWLayerConfig *layer_config, uint32_t *rotate_count) {
- HWRotateInfo *rotate = &layer_config->rotates[0];
+ HWRotatorSession *hw_rotator_session = &layer_config->hw_rotator_session;
+ HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[0];
float src_width = src_rect->right - src_rect->left;
float src_height = src_rect->bottom - src_rect->top;
bool rot90 = IsRotationNeeded(layer.transform.rotation);
@@ -54,7 +55,7 @@
dst_rect.top = 0.0f;
dst_rect.left = 0.0f;
- rotate->downscale_ratio = downscale;
+ hw_rotator_session->downscale_ratio = downscale;
uint32_t align_x, align_y;
GetAlignFactor(layer.input_buffer->format, &align_x, &align_y);
@@ -79,21 +80,17 @@
dst_rect.bottom = src_height / downscale;
}
- rotate->src_roi = *src_rect;
- rotate->valid = true;
- rotate->dst_roi = dst_rect;
+ hw_rotate_info->src_roi = *src_rect;
+ hw_rotate_info->valid = true;
+ hw_rotate_info->dst_roi = dst_rect;
- // Set WHF for Rotator output
- LayerBufferFormat output_format;
+ LayerBufferFormat *output_format = &hw_rotator_session->output_buffer.format;
SetRotatorOutputFormat(layer.input_buffer->format, is_opaque, rot90, (downscale > 1.0f),
- &output_format);
- HWBufferInfo *hw_buffer_info = &rotate->hw_buffer_info;
- hw_buffer_info->buffer_config.format = output_format;
- hw_buffer_info->buffer_config.width = UINT32(rotate->dst_roi.right);
- hw_buffer_info->buffer_config.height = UINT32(rotate->dst_roi.bottom);
+ output_format);
*src_rect = dst_rect;
- layer_config->num_rotate = 1;
+ hw_rotator_session->hw_block_count = 1;
+ hw_rotator_session->transform = layer.transform;
(*rotate_count)++;
}
@@ -254,6 +251,9 @@
struct HWLayerConfig *layer_config = &hw_layers->config[i];
HWPipeInfo &left_pipe = layer_config->left_pipe;
HWPipeInfo &right_pipe = layer_config->right_pipe;
+ HWRotatorSession *hw_rotator_session = &layer_config->hw_rotator_session;
+ LayerTransform transform = layer.transform;
+ bool rot90 = IsRotationNeeded(transform.rotation);
if (!CalculateCropRects(scissor, layer.transform, &src_rect, &dst_rect)) {
layer_config->Reset();
@@ -274,12 +274,11 @@
// config rotator first
for (uint32_t j = 0; j < kMaxRotatePerLayer; j++) {
- layer_config->rotates[j].Reset();
+ hw_rotator_session->hw_rotate_info[j].Reset();
}
- layer_config->num_rotate = 0;
+ hw_rotator_session->hw_block_count = 0;
- LayerTransform transform = layer.transform;
- if (IsRotationNeeded(transform.rotation) || UINT32(rot_scale) != 1) {
+ if (rot90 || UINT32(rot_scale) != 1) {
RotationConfig(layer, rot_scale, &src_rect, layer_config, rotate_count);
// rotator will take care of flipping, reset tranform
transform = LayerTransform();
@@ -306,10 +305,10 @@
i, layer_config->left_pipe.valid);
Log(kTagResources, "input layer src_rect", layer.src_rect);
Log(kTagResources, "input layer dst_rect", layer.dst_rect);
- for (uint32_t k = 0; k < layer_config->num_rotate; k++) {
+ for (uint32_t k = 0; k < hw_rotator_session->hw_block_count; k++) {
DLOGV_IF(kTagResources, "rotate num = %d, scale_x = %.2f", k, rot_scale);
- Log(kTagResources, "rotate src", layer_config->rotates[k].src_roi);
- Log(kTagResources, "rotate dst", layer_config->rotates[k].dst_roi);
+ Log(kTagResources, "rotate src", hw_rotator_session->hw_rotate_info[k].src_roi);
+ Log(kTagResources, "rotate dst", hw_rotator_session->hw_rotate_info[k].dst_roi);
}
Log(kTagResources, "cropped src_rect", src_rect);
diff --git a/displayengine/libs/core/res_manager.cpp b/displayengine/libs/core/res_manager.cpp
index 1499bb9..418e78f 100644
--- a/displayengine/libs/core/res_manager.cpp
+++ b/displayengine/libs/core/res_manager.cpp
@@ -39,19 +39,12 @@
buffer_allocator_(NULL), buffer_sync_handler_(NULL) {
}
-DisplayError ResManager::Init(const HWResourceInfo &hw_res_info, BufferAllocator *buffer_allocator,
- BufferSyncHandler *buffer_sync_handler) {
+DisplayError ResManager::Init(const HWResourceInfo &hw_res_info) {
hw_res_info_ = hw_res_info;
- buffer_sync_handler_ = buffer_sync_handler;
-
if (!hw_res_info_.max_mixer_width)
hw_res_info_.max_mixer_width = kMaxSourcePipeWidth;
- buffer_allocator_ = buffer_allocator;
-
- buffer_sync_handler_ = buffer_sync_handler;
-
DisplayError error = kErrorNone;
num_pipe_ = hw_res_info_.num_vig_pipe + hw_res_info_.num_rgb_pipe + hw_res_info_.num_dma_pipe;
@@ -171,13 +164,6 @@
}
display_resource_ctx->hw_panel_info_ = hw_panel_info;
- display_resource_ctx->buffer_manager = new BufferManager(buffer_allocator_, buffer_sync_handler_);
- if (display_resource_ctx->buffer_manager == NULL) {
- delete display_resource_ctx;
- display_resource_ctx = NULL;
- return kErrorMemory;
- }
-
hw_block_ctx_[hw_block_id].is_in_use = true;
display_resource_ctx->display_attributes = attributes;
@@ -313,6 +299,7 @@
for (uint32_t i = 0; i < layer_info.count; i++) {
Layer &layer = layer_info.stack->layers[layer_info.index[i]];
struct HWLayerConfig &layer_config = hw_layers->config[i];
+ HWRotatorSession &hw_rotator_session = layer_config.hw_rotator_session;
bool use_non_dma_pipe = layer_config.use_non_dma_pipe;
// TODO(user): set this from comp_manager
@@ -320,8 +307,8 @@
use_non_dma_pipe = true;
}
- for (uint32_t j = 0; j < layer_config.num_rotate; j++) {
- AssignRotator(&layer_config.rotates[j], &rotate_count);
+ for (uint32_t j = 0; j < hw_rotator_session.hw_block_count; j++) {
+ AssignRotator(&hw_rotator_session.hw_rotate_info[j], &rotate_count);
}
HWPipeInfo *pipe_info = &layer_config.left_pipe;
@@ -404,12 +391,6 @@
goto CleanupOnError;
}
- error = AllocRotatorBuffer(display_ctx, hw_layers);
- if (error != kErrorNone) {
- DLOGV_IF(kTagResources, "Rotator buffer allocation failed");
- goto CleanupOnError;
- }
-
return kErrorNone;
CleanupOnError:
@@ -643,84 +624,8 @@
}
}
-DisplayError ResManager::AllocRotatorBuffer(Handle display_ctx, HWLayers *hw_layers) {
- DisplayResourceContext *display_resource_ctx =
- reinterpret_cast<DisplayResourceContext *>(display_ctx);
- DisplayError error = kErrorNone;
-
- BufferManager *buffer_manager = display_resource_ctx->buffer_manager;
- HWLayersInfo &layer_info = hw_layers->info;
-
- // TODO(user): Do session management during prepare and allocate buffer and associate that with
- // the session during commit.
- buffer_manager->Start();
-
- for (uint32_t i = 0; i < layer_info.count; i++) {
- Layer& layer = layer_info.stack->layers[layer_info.index[i]];
- HWRotateInfo *rotate = &hw_layers->config[i].rotates[0];
-
- if (rotate->valid) {
- HWBufferInfo *hw_buffer_info = &rotate->hw_buffer_info;
- // Allocate two rotator output buffers by default for double buffering.
- hw_buffer_info->buffer_config.buffer_count = 2;
- hw_buffer_info->buffer_config.secure = layer.input_buffer->flags.secure;
-
- error = buffer_manager->GetNextBuffer(hw_buffer_info);
- if (error != kErrorNone) {
- return error;
- }
- }
-
- rotate = &hw_layers->config[i].rotates[1];
- if (rotate->valid) {
- HWBufferInfo *hw_buffer_info = &rotate->hw_buffer_info;
- // Allocate two rotator output buffers by default for double buffering.
- hw_buffer_info->buffer_config.buffer_count = 2;
- hw_buffer_info->buffer_config.secure = layer.input_buffer->flags.secure;
-
- error = buffer_manager->GetNextBuffer(hw_buffer_info);
- if (error != kErrorNone) {
- return error;
- }
- }
- }
- buffer_manager->Stop(hw_layers->closed_session_ids);
-
- return kErrorNone;
-}
-
DisplayError ResManager::PostPrepare(Handle display_ctx, HWLayers *hw_layers) {
SCOPE_LOCK(locker_);
- DisplayResourceContext *display_resource_ctx =
- reinterpret_cast<DisplayResourceContext *>(display_ctx);
- DisplayError error = kErrorNone;
-
- BufferManager *buffer_manager = display_resource_ctx->buffer_manager;
- HWLayersInfo &layer_info = hw_layers->info;
-
- for (uint32_t i = 0; i < layer_info.count; i++) {
- Layer& layer = layer_info.stack->layers[layer_info.index[i]];
- HWRotateInfo *rotate = &hw_layers->config[i].rotates[0];
-
- if (rotate->valid) {
- HWBufferInfo *hw_buffer_info = &rotate->hw_buffer_info;
-
- error = buffer_manager->SetSessionId(hw_buffer_info->slot, hw_buffer_info->session_id);
- if (error != kErrorNone) {
- return error;
- }
- }
-
- rotate = &hw_layers->config[i].rotates[1];
- if (rotate->valid) {
- HWBufferInfo *hw_buffer_info = &rotate->hw_buffer_info;
-
- error = buffer_manager->SetSessionId(hw_buffer_info->slot, hw_buffer_info->session_id);
- if (error != kErrorNone) {
- return error;
- }
- }
- }
return kErrorNone;
}
@@ -780,35 +685,6 @@
}
display_resource_ctx->frame_start = false;
- BufferManager *buffer_manager = display_resource_ctx->buffer_manager;
- HWLayersInfo &layer_info = hw_layers->info;
-
- for (uint32_t i = 0; i < layer_info.count; i++) {
- Layer& layer = layer_info.stack->layers[layer_info.index[i]];
- HWRotateInfo *rotate = &hw_layers->config[i].rotates[0];
-
- if (rotate->valid) {
- HWBufferInfo *rot_buf_info = &rotate->hw_buffer_info;
-
- error = buffer_manager->SetReleaseFd(rot_buf_info->slot,
- rot_buf_info->output_buffer.release_fence_fd);
- if (error != kErrorNone) {
- return error;
- }
- }
-
- rotate = &hw_layers->config[i].rotates[1];
- if (rotate->valid) {
- HWBufferInfo *rot_buf_info = &rotate->hw_buffer_info;
-
- error = buffer_manager->SetReleaseFd(rot_buf_info->slot,
- rot_buf_info->output_buffer.release_fence_fd);
- if (error != kErrorNone) {
- return error;
- }
- }
- }
-
return kErrorNone;
}
diff --git a/displayengine/libs/core/res_manager.h b/displayengine/libs/core/res_manager.h
index 99ac874..2219eba 100644
--- a/displayengine/libs/core/res_manager.h
+++ b/displayengine/libs/core/res_manager.h
@@ -31,15 +31,13 @@
#include "hw_interface.h"
#include "dump_impl.h"
-#include "buffer_manager.h"
namespace sde {
class ResManager : public DumpImpl {
public:
ResManager();
- DisplayError Init(const HWResourceInfo &hw_res_info, BufferAllocator *buffer_allocator,
- BufferSyncHandler *buffer_sync_handler);
+ DisplayError Init(const HWResourceInfo &hw_res_info);
DisplayError Deinit();
DisplayError RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
const HWPanelInfo &hw_panel_info, Handle *display_ctx);
@@ -117,7 +115,6 @@
struct DisplayResourceContext {
HWDisplayAttributes display_attributes;
- BufferManager *buffer_manager;
DisplayType display_type;
HWBlockType hw_block_id;
HWPanelInfo hw_panel_info_;
@@ -129,13 +126,6 @@
DisplayResourceContext() : hw_block_id(kHWBlockMax), frame_count(0), session_id(-1),
rotate_count(0), frame_start(false), max_mixer_stages(0) { }
-
- ~DisplayResourceContext() {
- if (buffer_manager) {
- delete buffer_manager;
- buffer_manager = NULL;
- }
- }
};
struct HWBlockContext {
@@ -203,7 +193,6 @@
const uint32_t roate_cnt);
void AssignRotator(HWRotateInfo *rotate, uint32_t *rotate_cnt);
void ClearRotator(DisplayResourceContext *display_resource_ctx);
- DisplayError AllocRotatorBuffer(Handle display_ctx, HWLayers *hw_layers);
void SetRotatorOutputFormat(const LayerBufferFormat &input_format, const bool &is_opaque,
const bool &rot90, const bool &downscale,
LayerBufferFormat *output_format);
diff --git a/displayengine/libs/core/rotator_ctrl.cpp b/displayengine/libs/core/rotator_ctrl.cpp
new file mode 100644
index 0000000..701006c
--- /dev/null
+++ b/displayengine/libs/core/rotator_ctrl.cpp
@@ -0,0 +1,233 @@
+/*
+* Copyright (c) 2014 - 2015, 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 <utils/constants.h>
+#include <utils/debug.h>
+#include <utils/rect.h>
+#include <core/buffer_allocator.h>
+#include <core/buffer_sync_handler.h>
+
+#include "rotator_ctrl.h"
+#include "hw_rotator_interface.h"
+#include "hw_interface.h"
+#include "session_manager.h"
+
+#define __CLASS__ "RotatorCtrl"
+
+namespace sde {
+
+RotatorCtrl::RotatorCtrl() : hw_rotator_intf_(NULL) {
+}
+
+DisplayError RotatorCtrl::Init(BufferAllocator *buffer_allocator,
+ BufferSyncHandler *buffer_sync_handler) {
+ DisplayError error = kErrorNone;
+
+ error = HWRotatorInterface::Create(buffer_sync_handler, &hw_rotator_intf_);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ error = hw_rotator_intf_->Open();
+ if (error != kErrorNone) {
+ DLOGE("Failed to open rotator device");
+ return error;
+ }
+
+ session_manager_ = new SessionManager(hw_rotator_intf_, buffer_allocator, buffer_sync_handler);
+ if (session_manager_ == NULL) {
+ HWRotatorInterface::Destroy(hw_rotator_intf_);
+ return kErrorMemory;
+ }
+
+ return kErrorNone;
+}
+
+DisplayError RotatorCtrl::Deinit() {
+ DisplayError error = kErrorNone;
+
+ error = hw_rotator_intf_->Close();
+ if (error != kErrorNone) {
+ DLOGW("Failed to close rotator device");
+ return error;
+ }
+
+ if (session_manager_) {
+ delete session_manager_;
+ session_manager_ = NULL;
+ }
+
+ HWRotatorInterface::Destroy(hw_rotator_intf_);
+
+ return kErrorNone;
+}
+
+DisplayError RotatorCtrl::RegisterDisplay(DisplayType type, Handle *display_ctx) {
+ DisplaRotatorContext *disp_rotator_ctx = new DisplaRotatorContext();
+ if (disp_rotator_ctx == NULL) {
+ return kErrorMemory;
+ }
+
+ disp_rotator_ctx->display_type = type;
+ *display_ctx = disp_rotator_ctx;
+
+ return kErrorNone;
+}
+
+void RotatorCtrl::UnregisterDisplay(Handle display_ctx) {
+ DisplaRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplaRotatorContext *>(display_ctx);
+
+ delete disp_rotator_ctx;
+ disp_rotator_ctx = NULL;
+}
+
+
+DisplayError RotatorCtrl::Prepare(Handle display_ctx, HWLayers *hw_layers) {
+ DisplayError error = kErrorNone;
+
+ DisplaRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplaRotatorContext *>(display_ctx);
+
+ error = PrepareSessions(hw_layers);
+ if (error != kErrorNone) {
+ DLOGE("Prepare rotator session failed for display %d", disp_rotator_ctx->display_type);
+ return error;
+ }
+
+ error = hw_rotator_intf_->Validate(hw_layers);
+ if (error != kErrorNone) {
+ DLOGE("Rotator validation failed for display %d", disp_rotator_ctx->display_type);
+ return error;
+ }
+
+ return kErrorNone;
+}
+
+DisplayError RotatorCtrl::Commit(Handle display_ctx, HWLayers *hw_layers) {
+ DisplayError error = kErrorNone;
+
+ DisplaRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplaRotatorContext *>(display_ctx);
+
+ error = GetOutputBuffers(hw_layers);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ error = hw_rotator_intf_->Commit(hw_layers);
+ if (error != kErrorNone) {
+ DLOGE("Rotator commit failed for display %d", disp_rotator_ctx->display_type);
+ return error;
+ }
+
+ return kErrorNone;
+}
+
+DisplayError RotatorCtrl::PostCommit(Handle display_ctx, HWLayers *hw_layers) {
+ HWLayersInfo &hw_layer_info = hw_layers->info;
+ DisplayError error = kErrorNone;
+ DisplaRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplaRotatorContext *>(display_ctx);
+
+ for (uint32_t i = 0; i < hw_layer_info.count; i++) {
+ Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
+ HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+
+ if (!hw_rotator_session->hw_block_count) {
+ continue;
+ }
+
+ error = session_manager_->SetReleaseFd(hw_rotator_session);
+ if (error != kErrorNone) {
+ DLOGE("Rotator Post commit failed for display %d", disp_rotator_ctx->display_type);
+ return error;
+ }
+ }
+
+ return kErrorNone;
+}
+
+DisplayError RotatorCtrl::PrepareSessions(HWLayers *hw_layers) {
+ HWLayersInfo &hw_layer_info = hw_layers->info;
+ DisplayError error = kErrorNone;
+
+ session_manager_->Start();
+
+ for (uint32_t i = 0; i < hw_layer_info.count; i++) {
+ Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
+ HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+ HWSessionConfig &hw_session_config = hw_rotator_session->hw_session_config;
+ HWRotateInfo *left_rotate = &hw_rotator_session->hw_rotate_info[0];
+ HWRotateInfo *right_rotate = &hw_rotator_session->hw_rotate_info[1];
+
+ if (!hw_rotator_session->hw_block_count) {
+ continue;
+ }
+
+ hw_session_config.src_width = UINT32(layer.src_rect.right - layer.src_rect.left);
+ hw_session_config.src_height = UINT32(layer.src_rect.bottom - layer.src_rect.top);
+ hw_session_config.src_format = layer.input_buffer->format;
+
+ LayerRect dst_rect = Union(left_rotate->dst_roi, right_rotate->dst_roi);
+
+ hw_session_config.dst_width = UINT32(dst_rect.right - dst_rect.left);
+ hw_session_config.dst_height = UINT32(dst_rect.bottom - dst_rect.top);
+ hw_session_config.dst_format = hw_rotator_session->output_buffer.format;
+
+ // Allocate two rotator output buffers by default for double buffering.
+ hw_session_config.buffer_count = kDoubleBuffering;
+ hw_session_config.secure = layer.input_buffer->flags.secure;
+ hw_session_config.frame_rate = layer.frame_rate;
+
+ error = session_manager_->OpenSession(hw_rotator_session);
+ if (error != kErrorNone) {
+ return error;
+ }
+ }
+
+ session_manager_->Stop();
+
+ return kErrorNone;
+}
+
+DisplayError RotatorCtrl::GetOutputBuffers(HWLayers *hw_layers) {
+ HWLayersInfo &hw_layer_info = hw_layers->info;
+ DisplayError error = kErrorNone;
+
+ for (uint32_t i = 0; i < hw_layer_info.count; i++) {
+ Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
+ HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+
+ if (!hw_rotator_session->hw_block_count) {
+ continue;
+ }
+
+ error = session_manager_->GetNextBuffer(hw_rotator_session);
+ if (error != kErrorNone) {
+ return error;
+ }
+ }
+
+ return kErrorNone;
+}
+
+} // namespace sde
+
diff --git a/displayengine/libs/core/offline_ctrl.h b/displayengine/libs/core/rotator_ctrl.h
similarity index 76%
rename from displayengine/libs/core/offline_ctrl.h
rename to displayengine/libs/core/rotator_ctrl.h
index 1525bb8..083f4ca 100644
--- a/displayengine/libs/core/offline_ctrl.h
+++ b/displayengine/libs/core/rotator_ctrl.h
@@ -22,8 +22,8 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef __OFFLINE_CTRL_H__
-#define __OFFLINE_CTRL_H__
+#ifndef __ROTATOR_CTRL_H__
+#define __ROTATOR_CTRL_H__
#include <utils/locker.h>
#include <utils/debug.h>
@@ -32,36 +32,43 @@
namespace sde {
class HWRotatorInterface;
+class BufferAllocator;
class BufferSyncHandler;
struct HWLayers;
+class SessionManager;
-class OfflineCtrl {
+class RotatorCtrl {
public:
- OfflineCtrl();
- DisplayError Init(BufferSyncHandler *buffer_sync_handler);
+ RotatorCtrl();
+ DisplayError Init(BufferAllocator *buffer_allocator, BufferSyncHandler *buffer_sync_handler);
DisplayError Deinit();
DisplayError RegisterDisplay(DisplayType type, Handle *display_ctx);
void UnregisterDisplay(Handle display_ctx);
DisplayError Prepare(Handle display_ctx, HWLayers *hw_layers);
DisplayError Commit(Handle display_ctx, HWLayers *hw_layers);
+ DisplayError PostCommit(Handle display_ctx, HWLayers *hw_layers);
private:
- struct DisplayOfflineContext {
- DisplayType display_type;
- bool pending_rot_commit;
-
- DisplayOfflineContext() : display_type(kPrimary), pending_rot_commit(false) { }
+ enum {
+ kSingleBuffering = 1,
+ kDoubleBuffering = 2,
+ kTripleBuffering = 3,
};
- DisplayError OpenRotatorSession(HWLayers *hw_layers);
- DisplayError CloseRotatorSession(HWLayers *hw_layers);
- bool IsRotationRequired(HWLayers *hw_layers);
+ struct DisplaRotatorContext {
+ DisplayType display_type;
+
+ DisplaRotatorContext() : display_type(kPrimary) { }
+ };
+
+ DisplayError PrepareSessions(HWLayers *hw_layers);
+ DisplayError GetOutputBuffers(HWLayers *hw_layers);
HWRotatorInterface *hw_rotator_intf_;
- bool hw_rotator_present_;
+ SessionManager *session_manager_;
};
} // namespace sde
-#endif // __OFFLINE_CTRL_H__
+#endif // __ROTATOR_CTRL_H__
diff --git a/displayengine/libs/core/scalar_helper.cpp b/displayengine/libs/core/scalar_helper.cpp
index 55b462f..c81e343 100644
--- a/displayengine/libs/core/scalar_helper.cpp
+++ b/displayengine/libs/core/scalar_helper.cpp
@@ -137,6 +137,7 @@
LayerBufferFormat format = layer.input_buffer->format;
HWPipeInfo* left_pipe = &hw_layers->config[i].left_pipe;
HWPipeInfo* right_pipe = &hw_layers->config[i].right_pipe;
+ HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
// Prepare data structure for lib scalar
uint32_t flags = 0;
@@ -152,12 +153,12 @@
for (uint32_t count = 0; count < 2; count++) {
HWPipeInfo* hw_pipe = (count == 0) ? left_pipe : right_pipe;
- HWRotateInfo* rotate_info = &hw_layers->config[i].rotates[count];
+ HWRotateInfo* hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
scalar::PipeInfo* pipe = (count == 0) ? &layer_info.left_pipe : &layer_info.right_pipe;
- if (rotate_info->valid) {
- width = rotate_info->hw_buffer_info.buffer_config.width;
- format = rotate_info->hw_buffer_info.buffer_config.format;
+ if (hw_rotate_info->valid) {
+ width = UINT32(hw_rotate_info->dst_roi.right - hw_rotate_info->dst_roi.left);
+ format = hw_rotator_session->output_buffer.format;
}
pipe->flags = flags;
diff --git a/displayengine/libs/core/session_manager.cpp b/displayengine/libs/core/session_manager.cpp
new file mode 100644
index 0000000..f87bf10
--- /dev/null
+++ b/displayengine/libs/core/session_manager.cpp
@@ -0,0 +1,351 @@
+/*
+* Copyright (c) 2015, 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 <utils/debug.h>
+#include <utils/constants.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+
+#include "session_manager.h"
+#include "hw_rotator_interface.h"
+
+#define __CLASS__ "SessionManager"
+
+namespace sde {
+
+// SessionManager State Transition
+// *******************************************************
+// Current State * Next State
+// *****************************************
+// * RELEASED READY ACQUIRED
+// *******************************************************
+// RELEASED * NA NA OpenSession()
+// READY * Stop() NA OpenSession()
+// ACQUIRED * NA Start() NA
+//********************************************************
+
+// ------------------------------- SessionManager Implementation -----------------------------------
+
+SessionManager::SessionManager(HWRotatorInterface *hw_rotator_intf,
+ BufferAllocator *buffer_allocator,
+ BufferSyncHandler *buffer_sync_handler)
+ : hw_rotator_intf_(hw_rotator_intf), buffer_allocator_(buffer_allocator),
+ buffer_sync_handler_(buffer_sync_handler), active_session_count_(0) {
+}
+
+void SessionManager::Start() {
+ uint32_t session_count = 0;
+ uint32_t ready_session_count = 0;
+
+ // Change the state of acquired session to kSessionReady
+ while ((ready_session_count < active_session_count_) && (session_count < kMaxSessionCount)) {
+ if (session_list_[session_count].state == kSessionReleased) {
+ session_count++;
+ continue;
+ }
+
+ session_list_[session_count++].state = kSessionReady;
+ ready_session_count++;
+ }
+}
+
+DisplayError SessionManager::OpenSession(HWRotatorSession *hw_rotator_session) {
+ DisplayError error = kErrorNone;
+
+ const HWSessionConfig &input_config = hw_rotator_session->hw_session_config;
+
+ DLOGI_IF(kTagRotator, "Src buffer: width = %d, height = %d, format = %d",
+ input_config.src_width, input_config.src_height, input_config.src_format);
+ DLOGI_IF(kTagRotator, "Dst buffer: width = %d, height = %d, format = %d",
+ input_config.dst_width, input_config.dst_height, input_config.dst_format);
+ DLOGI_IF(kTagRotator, "buffer_count = %d, secure = %d, cache = %d, frame_rate = %d",
+ input_config.buffer_count, input_config.secure, input_config.cache,
+ input_config.frame_rate);
+
+ uint32_t free_session = active_session_count_;
+ uint32_t acquired_session = kMaxSessionCount;
+ uint32_t ready_session_count = 0;
+
+ // First look for a session in ready state, if no session found in ready state matching
+ // with current input session config, assign a session in released state.
+ for (uint32_t session_count = 0; session_count < kMaxSessionCount &&
+ ready_session_count < active_session_count_; session_count++) {
+ HWSessionConfig &hw_session_config =
+ session_list_[session_count].hw_rotator_session.hw_session_config;
+
+ if (session_list_[session_count].state == kSessionReleased) {
+ free_session = session_count;
+ continue;
+ }
+
+ if (session_list_[session_count].state != kSessionReady) {
+ continue;
+ }
+
+ if (input_config == hw_session_config) {
+ session_list_[session_count].state = kSessionAcquired;
+ acquired_session = session_count;
+ break;
+ }
+
+ ready_session_count++;
+ }
+
+ // If the input config does not match with existing config, then add new session and change the
+ // state to kSessionAcquired
+ if (acquired_session == kMaxSessionCount) {
+ if (free_session >= kMaxSessionCount) {
+ return kErrorMemory;
+ }
+
+ error = AcquireSession(hw_rotator_session, &session_list_[free_session]);
+ if (error !=kErrorNone) {
+ return error;
+ }
+
+ acquired_session = free_session;
+ hw_rotator_session->session_id = acquired_session;
+ active_session_count_++;
+
+ DLOGV_IF(kTagRotator, "Acquire new session Output: width = %d, height = %d, format = %d, " \
+ "session_id %d", hw_rotator_session->output_buffer.width,
+ hw_rotator_session->output_buffer.height, hw_rotator_session->output_buffer.format,
+ hw_rotator_session->session_id);
+
+ return kErrorNone;
+ }
+
+ hw_rotator_session->output_buffer.width = input_config.dst_width;
+ hw_rotator_session->output_buffer.height = input_config.dst_height;
+ hw_rotator_session->output_buffer.format = input_config.dst_format;
+ hw_rotator_session->output_buffer.flags.secure = input_config.secure;
+ hw_rotator_session->session_id = acquired_session;
+
+ DLOGV_IF(kTagRotator, "Acquire existing session Output: width = %d, height = %d, format = %d, " \
+ "session_id %d", hw_rotator_session->output_buffer.width,
+ hw_rotator_session->output_buffer.height, hw_rotator_session->output_buffer.format,
+ hw_rotator_session->session_id);
+
+ return kErrorNone;
+}
+
+DisplayError SessionManager::GetNextBuffer(HWRotatorSession *hw_rotator_session) {
+ DisplayError error = kErrorNone;
+
+ int session_id = hw_rotator_session->session_id;
+ if (session_id > kMaxSessionCount) {
+ return kErrorParameters;
+ }
+
+ Session *session = &session_list_[session_id];
+ if (session->state != kSessionAcquired) {
+ DLOGE("Invalid session state %d", session->state);
+ kErrorParameters;
+ }
+
+ uint32_t curr_index = session->curr_index;
+
+ BufferInfo *buffer_info = &session->buffer_info;
+ if (buffer_info->alloc_buffer_info.fd < 0) {
+ const uint32_t &buffer_count = buffer_info->buffer_config.buffer_count;
+ const size_t &buffer_size = buffer_info->alloc_buffer_info.size;
+
+ error = buffer_allocator_->AllocateBuffer(buffer_info);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ for (uint32_t idx = 0; idx < buffer_count; idx++) {
+ session->offset[idx] = UINT32((buffer_size / buffer_count) * idx);
+ }
+ }
+
+ // Wait for the release fence fd before the session being given to the client.
+ buffer_sync_handler_->SyncWait(session->release_fd[curr_index]);
+ close(session->release_fd[curr_index]);
+ session->release_fd[curr_index] = -1;
+
+ hw_rotator_session->output_buffer.planes[0].stride = buffer_info->alloc_buffer_info.stride;
+ hw_rotator_session->output_buffer.planes[0].fd = buffer_info->alloc_buffer_info.fd;
+ hw_rotator_session->output_buffer.planes[0].offset = session->offset[curr_index];
+
+ DLOGI_IF(kTagRotator, "Output: width = %d, height = %d, format = %d, stride %d, " \
+ "curr_index = %d, offset %d, fd %d, session_id %d,",
+ hw_rotator_session->output_buffer.width, hw_rotator_session->output_buffer.height,
+ hw_rotator_session->output_buffer.format,
+ hw_rotator_session->output_buffer.planes[0].stride, curr_index,
+ hw_rotator_session->output_buffer.planes[0].offset,
+ hw_rotator_session->output_buffer.planes[0].fd, hw_rotator_session->session_id);
+
+ return kErrorNone;
+}
+
+DisplayError SessionManager::Stop() {
+ DisplayError error = kErrorNone;
+ uint32_t session_id = 0;
+
+ // Release all the sessions which were not acquired in the current cycle and deallocate the
+ // buffers associated with it.
+ while ((active_session_count_ > 0) && (session_id < kMaxSessionCount)) {
+ if (session_list_[session_id].state == kSessionReady) {
+ error = ReleaseSession(&session_list_[session_id]);
+ if (error != kErrorNone) {
+ return error;
+ }
+ active_session_count_--;
+
+ DLOGI_IF(kTagRotator, "session_id = %d, active_session_count = %d", session_id,
+ active_session_count_);
+ }
+ session_id++;
+ }
+
+ return kErrorNone;
+}
+
+DisplayError SessionManager::SetReleaseFd(HWRotatorSession *hw_rotator_session) {
+ int session_id = hw_rotator_session->session_id;
+ if (session_id > kMaxSessionCount) {
+ return kErrorParameters;
+ }
+
+ Session *session = &session_list_[session_id];
+ if (session->state != kSessionAcquired) {
+ DLOGE("Invalid session state %d", session->state);
+ kErrorParameters;
+ }
+
+ uint32_t &curr_index = session->curr_index;
+ uint32_t buffer_count = hw_rotator_session->hw_session_config.buffer_count;
+
+ // 1. Store the release fence fd, so that session manager waits for the release fence fd
+ // to be signaled and populates the session info to the client.
+ // 2. Modify the curr_index to point to next buffer.
+ session->release_fd[curr_index] = hw_rotator_session->output_buffer.release_fence_fd;
+
+ curr_index = (curr_index + 1) % buffer_count;
+
+ DLOGI_IF(kTagRotator, "session_id %d, curr_index = %d, release fd %d", session_id,
+ curr_index, hw_rotator_session->output_buffer.release_fence_fd);
+
+ return kErrorNone;
+}
+
+DisplayError SessionManager::AcquireSession(HWRotatorSession *hw_rotator_session,
+ Session *session) {
+ DisplayError error = kErrorNone;
+ const HWSessionConfig &input_config = hw_rotator_session->hw_session_config;
+
+ error = hw_rotator_intf_->OpenSession(hw_rotator_session);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ hw_rotator_session->output_buffer = LayerBuffer();
+ hw_rotator_session->output_buffer.width = input_config.dst_width;
+ hw_rotator_session->output_buffer.height = input_config.dst_height;
+ hw_rotator_session->output_buffer.format = input_config.dst_format;
+ hw_rotator_session->output_buffer.flags.secure = input_config.secure;
+
+ uint32_t buffer_count = hw_rotator_session->hw_session_config.buffer_count;
+
+ session->release_fd = new int[buffer_count];
+ if (session->release_fd == NULL) {
+ return kErrorMemory;
+ }
+
+ session->offset = new uint32_t[buffer_count];
+ if (session->offset == NULL) {
+ delete[] session->release_fd;
+ session->release_fd = NULL;
+ return kErrorMemory;
+ }
+
+ for (uint32_t idx = 0; idx < buffer_count; idx++) {
+ session->release_fd[idx] = -1;
+ session->offset[idx] = 0;
+ }
+ session->curr_index = 0;
+
+ session->hw_rotator_session = HWRotatorSession();
+ session->buffer_info = BufferInfo();
+
+ BufferInfo *buffer_info = &session->buffer_info;
+ buffer_info->buffer_config.buffer_count = hw_rotator_session->hw_session_config.buffer_count;
+ buffer_info->buffer_config.secure = hw_rotator_session->hw_session_config.secure;
+ buffer_info->buffer_config.cache = hw_rotator_session->hw_session_config.cache;
+ buffer_info->buffer_config.width = hw_rotator_session->hw_session_config.dst_width;
+ buffer_info->buffer_config.height = hw_rotator_session->hw_session_config.dst_height;
+ buffer_info->buffer_config.format = hw_rotator_session->hw_session_config.dst_format;
+
+ session->state = kSessionAcquired;
+ session->hw_rotator_session = *hw_rotator_session;
+
+ return kErrorNone;
+}
+
+DisplayError SessionManager::ReleaseSession(Session *session) {
+ DisplayError error = kErrorNone;
+
+ BufferInfo *buffer_info = &session->buffer_info;
+
+ error = buffer_allocator_->FreeBuffer(buffer_info);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ error = hw_rotator_intf_->CloseSession(&session->hw_rotator_session);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ uint32_t buffer_count = buffer_info->buffer_config.buffer_count;
+
+ for (uint32_t idx = 0; idx < buffer_count; idx++) {
+ if (session->release_fd[idx] >= 0) {
+ close(session->release_fd[idx]);
+ session->release_fd[idx] = -1;
+ }
+ }
+ session->state = kSessionReleased;
+
+ if (session->offset) {
+ delete[] session->offset;
+ session->offset = NULL;
+ }
+
+ if (session->release_fd) {
+ delete[] session->release_fd;
+ session->release_fd = NULL;
+ }
+
+ return kErrorNone;
+}
+
+} // namespace sde
diff --git a/displayengine/libs/core/buffer_manager.h b/displayengine/libs/core/session_manager.h
similarity index 60%
rename from displayengine/libs/core/buffer_manager.h
rename to displayengine/libs/core/session_manager.h
index 29bcd03..b27ba8b 100644
--- a/displayengine/libs/core/buffer_manager.h
+++ b/displayengine/libs/core/session_manager.h
@@ -27,8 +27,8 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef __BUFFER_MANAGER_H__
-#define __BUFFER_MANAGER_H__
+#ifndef __SESSION_MANAGER_H__
+#define __SESSION_MANAGER_H__
#include <utils/locker.h>
#include <core/buffer_allocator.h>
@@ -36,47 +36,52 @@
namespace sde {
-class BufferManager {
+class HWRotatorInterface;
+
+class SessionManager {
public:
- BufferManager(BufferAllocator *buffer_allocator, BufferSyncHandler *buffer_sync_handler);
+ SessionManager(HWRotatorInterface *hw_intf, BufferAllocator *buffer_allocator,
+ BufferSyncHandler *buffer_sync_handler);
void Start();
- DisplayError GetNextBuffer(HWBufferInfo *hw_buffer_info);
- DisplayError Stop(int *session_ids);
- DisplayError SetReleaseFd(uint32_t slot, int fd);
- DisplayError SetSessionId(uint32_t slot, int session_id);
+ DisplayError Stop();
+ DisplayError OpenSession(HWRotatorSession *hw_rotator_session);
+ DisplayError GetNextBuffer(HWRotatorSession *hw_rotator_session);
+ DisplayError SetReleaseFd(HWRotatorSession *hw_rotator_session);
private:
- static const uint32_t kMaxBufferSlotCount = 32;
+ // TODO(user): Read from hw capability instead of hardcoding
+ static const int kMaxSessionCount = 32;
- enum kBufferSlotState {
- kBufferSlotFree = 0,
- kBufferSlotReady = 1,
- kBufferSlotAcquired = 2,
+ enum SessionState {
+ kSessionReleased = 0,
+ kSessionReady = 1,
+ kSessionAcquired = 2,
};
- struct BufferSlot {
- HWBufferInfo hw_buffer_info;
- kBufferSlotState state;
+ struct Session {
+ HWRotatorSession hw_rotator_session;
+ BufferInfo buffer_info;
+ SessionState state;
int *release_fd;
uint32_t *offset;
uint32_t curr_index;
- BufferSlot() : state(kBufferSlotFree), release_fd(NULL), offset(NULL), curr_index(0) { }
- DisplayError Init();
- DisplayError Deinit();
+ Session() : state(kSessionReleased), release_fd(NULL), offset(NULL), curr_index(0) { }
};
- DisplayError FreeBufferSlot(uint32_t index);
+ DisplayError AcquireSession(HWRotatorSession *hw_rotator_session, Session *session);
+ DisplayError ReleaseSession(Session *session);
- BufferSlot buffer_slot_[kMaxBufferSlotCount];
+ Session session_list_[kMaxSessionCount];
+ HWRotatorInterface *hw_rotator_intf_;
BufferAllocator *buffer_allocator_;
BufferSyncHandler *buffer_sync_handler_;
- uint32_t num_used_slot_;
+ uint32_t active_session_count_; // number of sessions in ready/acquired state.
};
} // namespace sde
-#endif // __BUFFER_MANAGER_H__
+#endif // __SESSION_MANAGER_H__
diff --git a/displayengine/libs/hwc/hwc_debugger.cpp b/displayengine/libs/hwc/hwc_debugger.cpp
index d35e9cf..38f4f5c 100644
--- a/displayengine/libs/hwc/hwc_debugger.cpp
+++ b/displayengine/libs/hwc/hwc_debugger.cpp
@@ -76,19 +76,11 @@
}
}
-void HWCDebugHandler::DebugBufferManager(bool enable) {
+void HWCDebugHandler::DebugRotator(bool enable) {
if (enable) {
- SET_BIT(debug_flags_, kTagBufferManager);
+ SET_BIT(debug_flags_, kTagRotator);
} else {
- CLEAR_BIT(debug_flags_, kTagBufferManager);
- }
-}
-
-void HWCDebugHandler::DebugOfflineCtrl(bool enable) {
- if (enable) {
- SET_BIT(debug_flags_, kTagOfflineCtrl);
- } else {
- CLEAR_BIT(debug_flags_, kTagOfflineCtrl);
+ CLEAR_BIT(debug_flags_, kTagRotator);
}
}
diff --git a/displayengine/libs/hwc/hwc_debugger.h b/displayengine/libs/hwc/hwc_debugger.h
index def31db..2fed120 100644
--- a/displayengine/libs/hwc/hwc_debugger.h
+++ b/displayengine/libs/hwc/hwc_debugger.h
@@ -59,8 +59,7 @@
static void DebugStrategy(bool enable);
static void DebugCompManager(bool enable);
static void DebugDriverConfig(bool enable);
- static void DebugBufferManager(bool enable);
- static void DebugOfflineCtrl(bool enable);
+ static void DebugRotator(bool enable);
virtual void Error(DebugTag tag, const char *format, ...);
virtual void Warning(DebugTag tag, const char *format, ...);
diff --git a/displayengine/libs/hwc/hwc_session.cpp b/displayengine/libs/hwc/hwc_session.cpp
index 652d7e0..2201aa6 100644
--- a/displayengine/libs/hwc/hwc_session.cpp
+++ b/displayengine/libs/hwc/hwc_session.cpp
@@ -706,8 +706,7 @@
case qService::IQService::DEBUG_ROTATOR:
HWCDebugHandler::DebugResources(enable);
HWCDebugHandler::DebugDriverConfig(enable);
- HWCDebugHandler::DebugBufferManager(enable);
- HWCDebugHandler::DebugOfflineCtrl(enable);
+ HWCDebugHandler::DebugRotator(enable);
break;
default: