You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1743 lines
53 KiB
1743 lines
53 KiB
/*
|
|
* Copyright (c) 2014-2021, 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 <android-base/file.h>
|
|
#include <cutils/properties.h>
|
|
#include <cutils/sockets.h>
|
|
#include <utils/constants.h>
|
|
#include <utils/debug.h>
|
|
#include <utils/utils.h>
|
|
#include <stdarg.h>
|
|
#include <sync/sync.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include <map>
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "hwc_display_builtin.h"
|
|
#include "hwc_debugger.h"
|
|
#include "hwc_session.h"
|
|
|
|
#define __CLASS__ "HWCDisplayBuiltIn"
|
|
|
|
namespace sdm {
|
|
|
|
static void SetRect(LayerRect &src_rect, GLRect *target) {
|
|
target->left = src_rect.left;
|
|
target->top = src_rect.top;
|
|
target->right = src_rect.right;
|
|
target->bottom = src_rect.bottom;
|
|
}
|
|
|
|
static std::string LoadPanelGammaCalibration() {
|
|
constexpr char file[] = "/mnt/vendor/persist/display/gamma_calib_data.cal";
|
|
std::ifstream ifs(file);
|
|
|
|
if (!ifs.is_open()) {
|
|
DLOGW("Unable to open gamma calibration '%s', error = %s", file, strerror(errno));
|
|
return {};
|
|
}
|
|
|
|
std::string raw_data, gamma;
|
|
while (std::getline(ifs, raw_data, '\r')) {
|
|
gamma.append(raw_data.c_str());
|
|
gamma.append(" ");
|
|
std::getline(ifs, raw_data);
|
|
}
|
|
ifs.close();
|
|
|
|
/* eliminate space character in the last byte */
|
|
if (!gamma.empty()) {
|
|
gamma.pop_back();
|
|
}
|
|
|
|
return gamma;
|
|
}
|
|
|
|
static DisplayError WritePanelGammaTableToDriver(const std::string &gamma_data) {
|
|
constexpr char gamma_path[] = "/sys/devices/platform/soc/soc:qcom,dsi-display-primary/gamma";
|
|
int fd = open(gamma_path, O_WRONLY);
|
|
if (fd < 0) {
|
|
DLOGW("Unable to open gamma node '%s', error = %s", gamma_path, strerror(errno));
|
|
return kErrorFileDescriptor;
|
|
}
|
|
|
|
constexpr int max_retries = 5;
|
|
ssize_t len;
|
|
int retry_count = 0;
|
|
DisplayError error = kErrorNone;
|
|
while ((len = pwrite(fd, gamma_data.c_str(), gamma_data.size(), 0)) != gamma_data.size()) {
|
|
if ((len == -1 && errno != EINTR && errno != EAGAIN) || (++retry_count > max_retries)) {
|
|
DLOGE("Failed to write gamma calibration(retry %d), error = %s", retry_count,
|
|
strerror(errno));
|
|
break;
|
|
}
|
|
}
|
|
close(fd);
|
|
|
|
if (len != gamma_data.size()) {
|
|
error = kErrorResources;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
static DisplayError UpdatePanelGammaTable(enum HWCDisplay::PanelGammaSource source) {
|
|
std::string gamma_data = {};
|
|
DisplayError error;
|
|
if (source == HWCDisplay::kGammaDefault) {
|
|
gamma_data = "default";
|
|
} else if (source == HWCDisplay::kGammaCalibration) {
|
|
gamma_data = LoadPanelGammaCalibration();
|
|
}
|
|
|
|
if (!gamma_data.empty()) {
|
|
error = WritePanelGammaTableToDriver(gamma_data);
|
|
} else {
|
|
error = kErrorParameters;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
int HWCDisplayBuiltIn::Create(CoreInterface *core_intf, BufferAllocator *buffer_allocator,
|
|
HWCCallbacks *callbacks, HWCDisplayEventHandler *event_handler,
|
|
qService::QService *qservice, hwc2_display_t id, int32_t sdm_id,
|
|
HWCDisplay **hwc_display) {
|
|
int status = 0;
|
|
uint32_t builtin_width = 0;
|
|
uint32_t builtin_height = 0;
|
|
|
|
HWCDisplay *hwc_display_builtin =
|
|
new HWCDisplayBuiltIn(core_intf, buffer_allocator, callbacks, event_handler, qservice, id,
|
|
sdm_id);
|
|
status = hwc_display_builtin->Init();
|
|
if (status) {
|
|
delete hwc_display_builtin;
|
|
return status;
|
|
}
|
|
|
|
hwc_display_builtin->GetMixerResolution(&builtin_width, &builtin_height);
|
|
int width = 0, height = 0;
|
|
HWCDebugHandler::Get()->GetProperty(FB_WIDTH_PROP, &width);
|
|
HWCDebugHandler::Get()->GetProperty(FB_HEIGHT_PROP, &height);
|
|
if (width > 0 && height > 0) {
|
|
builtin_width = UINT32(width);
|
|
builtin_height = UINT32(height);
|
|
}
|
|
|
|
status = hwc_display_builtin->SetFrameBufferResolution(builtin_width, builtin_height);
|
|
if (status) {
|
|
Destroy(hwc_display_builtin);
|
|
return status;
|
|
}
|
|
|
|
*hwc_display = hwc_display_builtin;
|
|
|
|
return status;
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::Destroy(HWCDisplay *hwc_display) {
|
|
hwc_display->Deinit();
|
|
delete hwc_display;
|
|
}
|
|
|
|
HWCDisplayBuiltIn::HWCDisplayBuiltIn(CoreInterface *core_intf, BufferAllocator *buffer_allocator,
|
|
HWCCallbacks *callbacks, HWCDisplayEventHandler *event_handler,
|
|
qService::QService *qservice, hwc2_display_t id,
|
|
int32_t sdm_id)
|
|
: HWCDisplay(core_intf, buffer_allocator, callbacks, event_handler, qservice, kBuiltIn, id,
|
|
sdm_id, DISPLAY_CLASS_BUILTIN),
|
|
buffer_allocator_(buffer_allocator),
|
|
cpu_hint_(NULL), layer_stitch_task_(*this) {
|
|
}
|
|
|
|
int HWCDisplayBuiltIn::Init() {
|
|
cpu_hint_ = new CPUHint();
|
|
if (cpu_hint_->Init(static_cast<HWCDebugHandler *>(HWCDebugHandler::Get())) != kErrorNone) {
|
|
delete cpu_hint_;
|
|
cpu_hint_ = NULL;
|
|
}
|
|
|
|
use_metadata_refresh_rate_ = true;
|
|
int disable_metadata_dynfps = 0;
|
|
HWCDebugHandler::Get()->GetProperty(DISABLE_METADATA_DYNAMIC_FPS_PROP, &disable_metadata_dynfps);
|
|
if (disable_metadata_dynfps) {
|
|
use_metadata_refresh_rate_ = false;
|
|
}
|
|
|
|
int status = HWCDisplay::Init();
|
|
if (status) {
|
|
return status;
|
|
}
|
|
color_mode_ = new HWCColorMode(display_intf_);
|
|
color_mode_->Init();
|
|
|
|
int value = 0;
|
|
HWCDebugHandler::Get()->GetProperty(ENABLE_OPTIMIZE_REFRESH, &value);
|
|
enable_optimize_refresh_ = (value == 1);
|
|
if (enable_optimize_refresh_) {
|
|
DLOGI("Drop redundant drawcycles %" PRIu64 , id_);
|
|
}
|
|
|
|
int vsyncs = 0;
|
|
HWCDebugHandler::Get()->GetProperty(DEFER_FPS_FRAME_COUNT, &vsyncs);
|
|
if (vsyncs > 0) {
|
|
SetVsyncsApplyRateChange(UINT32(vsyncs));
|
|
}
|
|
|
|
is_primary_ = display_intf_->IsPrimaryDisplay();
|
|
|
|
if (is_primary_) {
|
|
int enable_bw_limits = 0;
|
|
HWCDebugHandler::Get()->GetProperty(ENABLE_BW_LIMITS, &enable_bw_limits);
|
|
enable_bw_limits_ = (enable_bw_limits == 1);
|
|
if (enable_bw_limits_) {
|
|
DLOGI("Enable BW Limits %" PRIu64, id_);
|
|
}
|
|
windowed_display_ = Debug::GetWindowRect(&window_rect_.left, &window_rect_.top,
|
|
&window_rect_.right, &window_rect_.bottom) != kErrorUndefined;
|
|
DLOGI("Window rect : [%f %f %f %f]", window_rect_.left, window_rect_.top,
|
|
window_rect_.right, window_rect_.bottom);
|
|
|
|
value = 0;
|
|
HWCDebugHandler::Get()->GetProperty(ENABLE_POMS_DURING_DOZE, &value);
|
|
enable_poms_during_doze_ = (value == 1);
|
|
if (enable_poms_during_doze_) {
|
|
DLOGI("Enable POMS during Doze mode %" PRIu64 , id_);
|
|
}
|
|
}
|
|
|
|
value = 0;
|
|
DebugHandler::Get()->GetProperty(DISABLE_DYNAMIC_FPS, &value);
|
|
disable_dyn_fps_ = (value == 1);
|
|
DLOGI("disable_dyn_fps_: %d", disable_dyn_fps_);
|
|
|
|
uint32_t config_index = 0;
|
|
GetActiveDisplayConfig(&config_index);
|
|
DisplayConfigVariableInfo attr = {};
|
|
GetDisplayAttributesForConfig(INT(config_index), &attr);
|
|
active_refresh_rate_ = attr.fps;
|
|
|
|
DLOGI("active_refresh_rate: %d", active_refresh_rate_);
|
|
|
|
value = 0;
|
|
HWCDebugHandler::Get()->GetProperty(ENHANCE_IDLE_TIME, &value);
|
|
enhance_idle_time_ = (value == 1);
|
|
DLOGI("enhance_idle_time: %d", enhance_idle_time_);
|
|
|
|
HWCDebugHandler::Get()->GetProperty(PERF_HINT_WINDOW_PROP, &perf_hint_window_);
|
|
HWCDebugHandler::Get()->GetProperty(ENABLE_PERF_HINT_LARGE_COMP_CYCLE,
|
|
&perf_hint_large_comp_cycle_);
|
|
|
|
return status;
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::Dump(std::ostringstream *os) {
|
|
HWCDisplay::Dump(os);
|
|
*os << histogram.Dump();
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::ValidateUiScaling() {
|
|
if (is_primary_ || !is_cmd_mode_) {
|
|
force_reset_validate_ = false;
|
|
return;
|
|
}
|
|
|
|
for (auto &hwc_layer : layer_set_) {
|
|
Layer *layer = hwc_layer->GetSDMLayer();
|
|
if (hwc_layer->IsScalingPresent() && !layer->input_buffer.flags.video) {
|
|
force_reset_validate_ = true;
|
|
return;
|
|
}
|
|
}
|
|
force_reset_validate_ = false;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::Validate(uint32_t *out_num_types, uint32_t *out_num_requests) {
|
|
auto status = HWC2::Error::None;
|
|
DisplayError error = kErrorNone;
|
|
|
|
DTRACE_SCOPED();
|
|
|
|
if (display_paused_) {
|
|
MarkLayersForGPUBypass();
|
|
return status;
|
|
}
|
|
|
|
if (color_tranform_failed_) {
|
|
// Must fall back to client composition
|
|
MarkLayersForClientComposition();
|
|
}
|
|
|
|
// Fill in the remaining blanks in the layers and add them to the SDM layerstack
|
|
BuildLayerStack();
|
|
|
|
// Check for scaling layers during Doze mode
|
|
ValidateUiScaling();
|
|
|
|
// Add stitch layer to layer stack.
|
|
AppendStitchLayer();
|
|
|
|
// Checks and replaces layer stack for solid fill
|
|
SolidFillPrepare();
|
|
|
|
// Apply current Color Mode and Render Intent.
|
|
if (color_mode_->ApplyCurrentColorModeWithRenderIntent(
|
|
static_cast<bool>(layer_stack_.flags.hdr_present)) != HWC2::Error::None) {
|
|
// Fallback to GPU Composition, if Color Mode can't be applied.
|
|
MarkLayersForClientComposition();
|
|
}
|
|
|
|
bool pending_output_dump = dump_frame_count_ && dump_output_to_file_;
|
|
|
|
if (readback_buffer_queued_ || pending_output_dump) {
|
|
// RHS values were set in FrameCaptureAsync() called from a binder thread. They are picked up
|
|
// here in a subsequent draw round. Readback is not allowed for any secure use case.
|
|
readback_configured_ = !layer_stack_.flags.secure_present;
|
|
if (readback_configured_) {
|
|
DisablePartialUpdateOneFrame();
|
|
layer_stack_.output_buffer = &output_buffer_;
|
|
layer_stack_.flags.post_processed_output = post_processed_output_;
|
|
}
|
|
}
|
|
|
|
uint32_t num_updating_layers = GetUpdatingLayersCount();
|
|
bool one_updating_layer = (num_updating_layers == 1);
|
|
if (num_updating_layers != 0) {
|
|
ToggleCPUHint(one_updating_layer);
|
|
}
|
|
|
|
uint32_t refresh_rate = GetOptimalRefreshRate(one_updating_layer);
|
|
bool idle_screen = GetUpdatingAppLayersCount() == 0;
|
|
error = display_intf_->SetRefreshRate(refresh_rate, force_refresh_rate_, idle_screen);
|
|
|
|
// Get the refresh rate set.
|
|
display_intf_->GetRefreshRate(&refresh_rate);
|
|
bool vsync_source = (callbacks_->GetVsyncSource() == id_);
|
|
|
|
if (error == kErrorNone) {
|
|
if (vsync_source && ((current_refresh_rate_ < refresh_rate) ||
|
|
(enhance_idle_time_ && (current_refresh_rate_ != refresh_rate)))) {
|
|
DTRACE_BEGIN("HWC2::Vsync::Enable");
|
|
// Display is ramping up from idle.
|
|
// Client realizes need for resync upon change in config.
|
|
// Since we know config has changed, triggering vsync proactively
|
|
// can help in reducing pipeline delays to enable events.
|
|
SetVsyncEnabled(HWC2::Vsync::Enable);
|
|
DTRACE_END();
|
|
}
|
|
// On success, set current refresh rate to new refresh rate.
|
|
current_refresh_rate_ = refresh_rate;
|
|
}
|
|
|
|
if (layer_set_.empty()) {
|
|
// Avoid flush for Command mode panel.
|
|
flush_ = !client_connected_;
|
|
validated_ = true;
|
|
return status;
|
|
}
|
|
|
|
status = PrepareLayerStack(out_num_types, out_num_requests);
|
|
SetCpuPerfHintLargeCompCycle();
|
|
pending_commit_ = true;
|
|
return status;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::CommitLayerStack() {
|
|
skip_commit_ = CanSkipCommit();
|
|
return HWCDisplay::CommitLayerStack();
|
|
}
|
|
|
|
bool HWCDisplayBuiltIn::CanSkipCommit() {
|
|
if (layer_stack_invalid_) {
|
|
return false;
|
|
}
|
|
|
|
// Reject repeated drawcycle requests if it satisfies all conditions.
|
|
// 1. None of the layerstack attributes changed.
|
|
// 2. No new buffer latched.
|
|
// 3. No refresh request triggered by HWC.
|
|
// 4. This display is not source of vsync.
|
|
bool buffers_latched = false;
|
|
for (auto &hwc_layer : layer_set_) {
|
|
buffers_latched |= hwc_layer->BufferLatched();
|
|
hwc_layer->ResetBufferFlip();
|
|
}
|
|
|
|
bool vsync_source = (callbacks_->GetVsyncSource() == id_);
|
|
bool skip_commit = enable_optimize_refresh_ && !pending_commit_ && !buffers_latched &&
|
|
!pending_refresh_ && !vsync_source;
|
|
pending_refresh_ = false;
|
|
|
|
return skip_commit;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::CommitStitchLayers() {
|
|
if (disable_layer_stitch_) {
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
if (!validated_ || skip_commit_) {
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
LayerStitchContext ctx = {};
|
|
Layer *stitch_layer = stitch_target_->GetSDMLayer();
|
|
LayerBuffer &output_buffer = stitch_layer->input_buffer;
|
|
for (auto &layer : layer_stack_.layers) {
|
|
LayerComposition &composition = layer->composition;
|
|
if (composition != kCompositionStitch) {
|
|
continue;
|
|
}
|
|
|
|
StitchParams params = {};
|
|
// Stitch target doesn't have an input fence.
|
|
// Render all layers at specified destination.
|
|
LayerBuffer &input_buffer = layer->input_buffer;
|
|
params.src_hnd = reinterpret_cast<const private_handle_t *>(input_buffer.buffer_id);
|
|
params.dst_hnd = reinterpret_cast<const private_handle_t *>(output_buffer.buffer_id);
|
|
SetRect(layer->stitch_info.dst_rect, ¶ms.dst_rect);
|
|
SetRect(layer->stitch_info.slice_rect, ¶ms.scissor_rect);
|
|
params.src_acquire_fence = input_buffer.acquire_fence;
|
|
|
|
ctx.stitch_params.push_back(params);
|
|
}
|
|
|
|
if (!ctx.stitch_params.size()) {
|
|
// No layers marked for stitch.
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
layer_stitch_task_.PerformTask(LayerStitchTaskCode::kCodeStitch, &ctx);
|
|
// Set release fence.
|
|
output_buffer.acquire_fence = ctx.release_fence;
|
|
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::CacheAvrStatus() {
|
|
QSyncMode qsync_mode = kQSyncModeNone;
|
|
|
|
DisplayError error = display_intf_->GetQSyncMode(&qsync_mode);
|
|
if (error != kErrorNone) {
|
|
return;
|
|
}
|
|
|
|
bool qsync_enabled = (qsync_mode != kQSyncModeNone);
|
|
if (qsync_enabled_ != qsync_enabled) {
|
|
qsync_reconfigured_ = true;
|
|
qsync_enabled_ = qsync_enabled;
|
|
} else {
|
|
qsync_reconfigured_ = false;
|
|
}
|
|
}
|
|
|
|
bool HWCDisplayBuiltIn::IsQsyncCallbackNeeded(bool *qsync_enabled, int32_t *refresh_rate,
|
|
int32_t *qsync_refresh_rate) {
|
|
if (!qsync_reconfigured_) {
|
|
return false;
|
|
}
|
|
|
|
bool vsync_source = (callbacks_->GetVsyncSource() == id_);
|
|
// Qsync callback not needed if this display is not the source of vsync
|
|
if (!vsync_source) {
|
|
return false;
|
|
}
|
|
|
|
*qsync_enabled = qsync_enabled_;
|
|
uint32_t current_rate = 0;
|
|
display_intf_->GetRefreshRate(¤t_rate);
|
|
*refresh_rate = INT32(current_rate);
|
|
*qsync_refresh_rate = min_refresh_rate_;
|
|
|
|
return true;
|
|
}
|
|
|
|
int HWCDisplayBuiltIn::GetBwCode(const DisplayConfigVariableInfo &attr) {
|
|
uint32_t min_refresh_rate = 0, max_refresh_rate = 0;
|
|
display_intf_->GetRefreshRateRange(&min_refresh_rate, &max_refresh_rate);
|
|
uint32_t fps = attr.smart_panel ? attr.fps : max_refresh_rate;
|
|
|
|
if (fps <= 60) {
|
|
return kBwLow;
|
|
} else if (fps <= 90) {
|
|
return kBwMedium;
|
|
} else {
|
|
return kBwHigh;
|
|
}
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::SetBwLimitHint(bool enable) {
|
|
if (!enable_bw_limits_) {
|
|
return;
|
|
}
|
|
|
|
if (!enable) {
|
|
thermal_bandwidth_client_cancel_request(const_cast<char*>(kDisplayBwName));
|
|
curr_refresh_rate_ = 0;
|
|
return;
|
|
}
|
|
|
|
uint32_t config_index = 0;
|
|
DisplayConfigVariableInfo attr = {};
|
|
GetActiveDisplayConfig(&config_index);
|
|
GetDisplayAttributesForConfig(INT(config_index), &attr);
|
|
if (attr.fps != curr_refresh_rate_ || attr.smart_panel != is_smart_panel_) {
|
|
int bw_code = GetBwCode(attr);
|
|
int req_data = thermal_bandwidth_client_merge_input_info(bw_code, 0);
|
|
int error = thermal_bandwidth_client_request(const_cast<char*>(kDisplayBwName), req_data);
|
|
if (error) {
|
|
DLOGE("Thermal bandwidth request failed %d", error);
|
|
}
|
|
curr_refresh_rate_ = attr.fps;
|
|
is_smart_panel_ = attr.smart_panel;
|
|
}
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::SetPartialUpdate(DisplayConfigFixedInfo fixed_info) {
|
|
partial_update_enabled_ = fixed_info.partial_update || (!fixed_info.is_cmdmode);
|
|
for (auto hwc_layer : layer_set_) {
|
|
hwc_layer->SetPartialUpdate(partial_update_enabled_);
|
|
}
|
|
client_target_->SetPartialUpdate(partial_update_enabled_);
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetPowerMode(HWC2::PowerMode mode, bool teardown) {
|
|
DisplayConfigFixedInfo fixed_info = {};
|
|
display_intf_->GetConfig(&fixed_info);
|
|
bool command_mode = fixed_info.is_cmdmode;
|
|
|
|
auto status = HWCDisplay::SetPowerMode(mode, teardown);
|
|
if (status != HWC2::Error::None) {
|
|
return status;
|
|
}
|
|
|
|
display_intf_->GetConfig(&fixed_info);
|
|
is_cmd_mode_ = fixed_info.is_cmdmode;
|
|
if (is_cmd_mode_ != command_mode) {
|
|
SetPartialUpdate(fixed_info);
|
|
}
|
|
|
|
if (mode == HWC2::PowerMode::Off) {
|
|
SetBwLimitHint(false);
|
|
}
|
|
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::Present(shared_ptr<Fence> *out_retire_fence) {
|
|
auto status = HWC2::Error::None;
|
|
|
|
DTRACE_SCOPED();
|
|
|
|
if (display_paused_) {
|
|
DisplayError error = display_intf_->Flush(&layer_stack_);
|
|
validated_ = false;
|
|
if (error != kErrorNone) {
|
|
DLOGE("Flush failed. Error = %d", error);
|
|
}
|
|
} else {
|
|
CacheAvrStatus();
|
|
DisplayConfigFixedInfo fixed_info = {};
|
|
display_intf_->GetConfig(&fixed_info);
|
|
bool command_mode = fixed_info.is_cmdmode;
|
|
|
|
status = CommitStitchLayers();
|
|
if (status != HWC2::Error::None) {
|
|
DLOGE("Stitch failed: %d", status);
|
|
return status;
|
|
}
|
|
|
|
status = CommitLayerStack();
|
|
if (status == HWC2::Error::None) {
|
|
HandleFrameOutput();
|
|
PostCommitStitchLayers();
|
|
status = HWCDisplay::PostCommitLayerStack(out_retire_fence);
|
|
SetBwLimitHint(true);
|
|
display_intf_->GetConfig(&fixed_info);
|
|
is_cmd_mode_ = fixed_info.is_cmdmode;
|
|
if (is_cmd_mode_ != command_mode) {
|
|
SetPartialUpdate(fixed_info);
|
|
}
|
|
|
|
// For video mode panel with dynamic fps, update the active mode index.
|
|
// This is needed to report the correct Vsync period when client queries
|
|
// using GetDisplayVsyncPeriod API.
|
|
if (!is_cmd_mode_ && !disable_dyn_fps_) {
|
|
hwc2_config_t active_config = hwc_config_map_.at(0);
|
|
GetActiveConfig(&active_config);
|
|
SetActiveConfigIndex(active_config);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (CC_UNLIKELY(!has_config_hbm_threshold_)) {
|
|
uint32_t panel_x, panel_y;
|
|
GetPanelResolution(&panel_x, &panel_y);
|
|
hbm_threshold_px_ = float(panel_x * panel_y) * hbm_threshold_pct_;
|
|
DLOGI("Configure hbm_threshold_px_ to %f", hbm_threshold_px_);
|
|
|
|
has_config_hbm_threshold_ = true;
|
|
}
|
|
|
|
const bool enable_hbm(hdr_largest_layer_px_ > hbm_threshold_px_);
|
|
if (high_brightness_mode_ != enable_hbm) {
|
|
HbmState state = enable_hbm ? HbmState::HDR : HbmState::OFF;
|
|
auto status = SetHbm(state, HWC);
|
|
if (status == HWC2::Error::None) {
|
|
high_brightness_mode_ = enable_hbm;
|
|
} else {
|
|
DLOGE("failed to setHbm to %d", enable_hbm);
|
|
}
|
|
}
|
|
|
|
pending_commit_ = false;
|
|
|
|
// In case of scaling UI layer for command mode, reset validate
|
|
if (force_reset_validate_) {
|
|
validated_ = false;
|
|
display_intf_->ClearLUTs();
|
|
}
|
|
return status;
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::PostCommitStitchLayers() {
|
|
if (disable_layer_stitch_) {
|
|
return;
|
|
}
|
|
|
|
// Close Stitch buffer acquire fence.
|
|
Layer *stitch_layer = stitch_target_->GetSDMLayer();
|
|
LayerBuffer &output_buffer = stitch_layer->input_buffer;
|
|
for (auto &layer : layer_stack_.layers) {
|
|
LayerComposition &composition = layer->composition;
|
|
if (composition != kCompositionStitch) {
|
|
continue;
|
|
}
|
|
LayerBuffer &input_buffer = layer->input_buffer;
|
|
input_buffer.release_fence = output_buffer.acquire_fence;
|
|
}
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::GetColorModes(uint32_t *out_num_modes, ColorMode *out_modes) {
|
|
if (out_modes == nullptr) {
|
|
*out_num_modes = color_mode_->GetColorModeCount();
|
|
} else {
|
|
color_mode_->GetColorModes(out_num_modes, out_modes);
|
|
}
|
|
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::GetRenderIntents(ColorMode mode, uint32_t *out_num_intents,
|
|
RenderIntent *out_intents) {
|
|
if (out_intents == nullptr) {
|
|
*out_num_intents = color_mode_->GetRenderIntentCount(mode);
|
|
} else {
|
|
color_mode_->GetRenderIntents(mode, out_num_intents, out_intents);
|
|
}
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetColorMode(ColorMode mode) {
|
|
return SetColorModeWithRenderIntent(mode, RenderIntent::COLORIMETRIC);
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetColorModeWithRenderIntent(ColorMode mode, RenderIntent intent) {
|
|
auto status = color_mode_->CacheColorModeWithRenderIntent(mode, intent);
|
|
if (status != HWC2::Error::None) {
|
|
DLOGE("failed for mode = %d intent = %d", mode, intent);
|
|
return status;
|
|
}
|
|
callbacks_->Refresh(id_);
|
|
validated_ = false;
|
|
return status;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetColorModeById(int32_t color_mode_id) {
|
|
auto status = color_mode_->SetColorModeById(color_mode_id);
|
|
if (status != HWC2::Error::None) {
|
|
DLOGE("failed for mode = %d", color_mode_id);
|
|
return status;
|
|
}
|
|
|
|
callbacks_->Refresh(id_);
|
|
validated_ = false;
|
|
|
|
return status;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetColorModeFromClientApi(int32_t color_mode_id) {
|
|
DisplayError error = kErrorNone;
|
|
std::string mode_string;
|
|
|
|
error = display_intf_->GetColorModeName(color_mode_id, &mode_string);
|
|
if (error) {
|
|
DLOGE("Failed to get mode name for mode %d", color_mode_id);
|
|
return HWC2::Error::BadParameter;
|
|
}
|
|
|
|
auto status = color_mode_->SetColorModeFromClientApi(mode_string);
|
|
if (status != HWC2::Error::None) {
|
|
DLOGE("Failed to set mode = %d", color_mode_id);
|
|
return status;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::RestoreColorTransform() {
|
|
auto status = color_mode_->RestoreColorTransform();
|
|
if (status != HWC2::Error::None) {
|
|
DLOGE("failed to RestoreColorTransform");
|
|
return status;
|
|
}
|
|
|
|
callbacks_->Refresh(id_);
|
|
|
|
return status;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetColorTransform(const float *matrix,
|
|
android_color_transform_t hint) {
|
|
if (!matrix) {
|
|
return HWC2::Error::BadParameter;
|
|
}
|
|
|
|
auto status = color_mode_->SetColorTransform(matrix, hint);
|
|
if (status != HWC2::Error::None) {
|
|
DLOGE("failed for hint = %d", hint);
|
|
color_tranform_failed_ = true;
|
|
return status;
|
|
}
|
|
|
|
callbacks_->Refresh(id_);
|
|
color_tranform_failed_ = false;
|
|
validated_ = false;
|
|
|
|
return status;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetReadbackBuffer(const native_handle_t *buffer,
|
|
shared_ptr<Fence> acquire_fence,
|
|
bool post_processed_output, CWBClient client) {
|
|
if (cwb_client_ != client && cwb_client_ != kCWBClientNone) {
|
|
DLOGE("CWB is in use with client = %d", cwb_client_);
|
|
return HWC2::Error::NoResources;
|
|
}
|
|
|
|
const private_handle_t *handle = reinterpret_cast<const private_handle_t *>(buffer);
|
|
if (!handle || (handle->fd < 0)) {
|
|
return HWC2::Error::BadParameter;
|
|
}
|
|
|
|
// Configure the output buffer as Readback buffer
|
|
output_buffer_.width = UINT32(handle->width);
|
|
output_buffer_.height = UINT32(handle->height);
|
|
output_buffer_.unaligned_width = UINT32(handle->unaligned_width);
|
|
output_buffer_.unaligned_height = UINT32(handle->unaligned_height);
|
|
output_buffer_.format = HWCLayer::GetSDMFormat(handle->format, handle->flags);
|
|
output_buffer_.planes[0].fd = handle->fd;
|
|
output_buffer_.planes[0].stride = UINT32(handle->width);
|
|
output_buffer_.acquire_fence = acquire_fence;
|
|
output_buffer_.handle_id = handle->id;
|
|
|
|
post_processed_output_ = post_processed_output;
|
|
readback_buffer_queued_ = true;
|
|
readback_configured_ = false;
|
|
validated_ = false;
|
|
cwb_client_ = client;
|
|
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::GetReadbackBufferFence(shared_ptr<Fence> *release_fence) {
|
|
auto status = HWC2::Error::None;
|
|
|
|
if (readback_configured_ && output_buffer_.release_fence) {
|
|
*release_fence = output_buffer_.release_fence;
|
|
} else {
|
|
status = HWC2::Error::Unsupported;
|
|
}
|
|
|
|
post_processed_output_ = false;
|
|
readback_buffer_queued_ = false;
|
|
readback_configured_ = false;
|
|
output_buffer_ = {};
|
|
cwb_client_ = kCWBClientNone;
|
|
|
|
return status;
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::TeardownConcurrentWriteback(void) {
|
|
DisplayError error = kErrorNotSupported;
|
|
if (Fence::Wait(output_buffer_.release_fence) != kErrorNone) {
|
|
DLOGE("sync_wait error errno = %d, desc = %s", errno, strerror(errno));
|
|
return kErrorResources;
|
|
}
|
|
|
|
if (display_intf_) {
|
|
error = display_intf_->TeardownConcurrentWriteback();
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetDisplayDppsAdROI(uint32_t h_start, uint32_t h_end,
|
|
uint32_t v_start, uint32_t v_end,
|
|
uint32_t factor_in, uint32_t factor_out) {
|
|
DisplayError error = kErrorNone;
|
|
DisplayDppsAd4RoiCfg dpps_ad4_roi_cfg = {};
|
|
uint32_t panel_width = 0, panel_height = 0;
|
|
constexpr uint16_t kMaxFactorVal = 0xffff;
|
|
|
|
if (h_start >= h_end || v_start >= v_end || factor_in > kMaxFactorVal ||
|
|
factor_out > kMaxFactorVal) {
|
|
DLOGE("Invalid roi region = [%u, %u, %u, %u, %u, %u]",
|
|
h_start, h_end, v_start, v_end, factor_in, factor_out);
|
|
return HWC2::Error::BadParameter;
|
|
}
|
|
|
|
GetPanelResolution(&panel_width, &panel_height);
|
|
|
|
if (h_start >= panel_width || h_end > panel_width ||
|
|
v_start >= panel_height || v_end > panel_height) {
|
|
DLOGE("Invalid roi region = [%u, %u, %u, %u], panel resolution = [%u, %u]",
|
|
h_start, h_end, v_start, v_end, panel_width, panel_height);
|
|
return HWC2::Error::BadParameter;
|
|
}
|
|
|
|
dpps_ad4_roi_cfg.h_start = h_start;
|
|
dpps_ad4_roi_cfg.h_end = h_end;
|
|
dpps_ad4_roi_cfg.v_start = v_start;
|
|
dpps_ad4_roi_cfg.v_end = v_end;
|
|
dpps_ad4_roi_cfg.factor_in = factor_in;
|
|
dpps_ad4_roi_cfg.factor_out = factor_out;
|
|
|
|
error = display_intf_->SetDisplayDppsAdROI(&dpps_ad4_roi_cfg);
|
|
if (error)
|
|
return HWC2::Error::BadConfig;
|
|
|
|
callbacks_->Refresh(id_);
|
|
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetFrameTriggerMode(uint32_t mode) {
|
|
DisplayError error = kErrorNone;
|
|
FrameTriggerMode trigger_mode = kFrameTriggerDefault;
|
|
|
|
if (mode >= kFrameTriggerMax) {
|
|
DLOGE("Invalid input mode %d", mode);
|
|
return HWC2::Error::BadParameter;
|
|
}
|
|
|
|
trigger_mode = static_cast<FrameTriggerMode>(mode);
|
|
error = display_intf_->SetFrameTriggerMode(trigger_mode);
|
|
if (error)
|
|
return HWC2::Error::BadConfig;
|
|
|
|
callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
|
|
validated_ = false;
|
|
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
int HWCDisplayBuiltIn::Perform(uint32_t operation, ...) {
|
|
va_list args;
|
|
va_start(args, operation);
|
|
int val = 0;
|
|
LayerSolidFill *solid_fill_color;
|
|
LayerRect *rect = NULL;
|
|
|
|
switch (operation) {
|
|
case SET_METADATA_DYN_REFRESH_RATE:
|
|
val = va_arg(args, int32_t);
|
|
SetMetaDataRefreshRateFlag(val);
|
|
break;
|
|
case SET_BINDER_DYN_REFRESH_RATE:
|
|
val = va_arg(args, int32_t);
|
|
ForceRefreshRate(UINT32(val));
|
|
break;
|
|
case SET_DISPLAY_MODE:
|
|
val = va_arg(args, int32_t);
|
|
SetDisplayMode(UINT32(val));
|
|
break;
|
|
case SET_QDCM_SOLID_FILL_INFO:
|
|
solid_fill_color = va_arg(args, LayerSolidFill*);
|
|
SetQDCMSolidFillInfo(true, *solid_fill_color);
|
|
break;
|
|
case UNSET_QDCM_SOLID_FILL_INFO:
|
|
solid_fill_color = va_arg(args, LayerSolidFill*);
|
|
SetQDCMSolidFillInfo(false, *solid_fill_color);
|
|
break;
|
|
case SET_QDCM_SOLID_FILL_RECT:
|
|
rect = va_arg(args, LayerRect*);
|
|
solid_fill_rect_ = *rect;
|
|
break;
|
|
default:
|
|
DLOGW("Invalid operation %d", operation);
|
|
va_end(args);
|
|
return -EINVAL;
|
|
}
|
|
va_end(args);
|
|
validated_ = false;
|
|
|
|
return 0;
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::SetDisplayMode(uint32_t mode) {
|
|
DisplayError error = kErrorNone;
|
|
|
|
if (display_intf_) {
|
|
error = display_intf_->SetDisplayMode(mode);
|
|
if (error == kErrorNone) {
|
|
DisplayConfigFixedInfo fixed_info = {};
|
|
display_intf_->GetConfig(&fixed_info);
|
|
is_cmd_mode_ = fixed_info.is_cmdmode;
|
|
partial_update_enabled_ = fixed_info.partial_update;
|
|
for (auto hwc_layer : layer_set_) {
|
|
hwc_layer->SetPartialUpdate(partial_update_enabled_);
|
|
}
|
|
client_target_->SetPartialUpdate(partial_update_enabled_);
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::SetMetaDataRefreshRateFlag(bool enable) {
|
|
int disable_metadata_dynfps = 0;
|
|
|
|
HWCDebugHandler::Get()->GetProperty(DISABLE_METADATA_DYNAMIC_FPS_PROP, &disable_metadata_dynfps);
|
|
if (disable_metadata_dynfps) {
|
|
return;
|
|
}
|
|
use_metadata_refresh_rate_ = enable;
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::SetQDCMSolidFillInfo(bool enable, const LayerSolidFill &color) {
|
|
solid_fill_enable_ = enable;
|
|
solid_fill_color_ = color;
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::ToggleCPUHint(bool set) {
|
|
if (!cpu_hint_ || !perf_hint_window_) {
|
|
return;
|
|
}
|
|
|
|
if (set) {
|
|
cpu_hint_->Set();
|
|
} else {
|
|
cpu_hint_->Reset();
|
|
}
|
|
}
|
|
|
|
int HWCDisplayBuiltIn::HandleSecureSession(const std::bitset<kSecureMax> &secure_sessions,
|
|
bool *power_on_pending, bool is_active_secure_display) {
|
|
if (!power_on_pending) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!is_active_secure_display) {
|
|
// Do handling as done on non-primary displays.
|
|
DLOGI("Default handling for display %" PRIu64 " %d-%d", id_, sdm_id_, type_);
|
|
return HWCDisplay::HandleSecureSession(secure_sessions, power_on_pending,
|
|
is_active_secure_display);
|
|
}
|
|
|
|
if (current_power_mode_ != HWC2::PowerMode::On) {
|
|
return 0;
|
|
}
|
|
|
|
if (active_secure_sessions_[kSecureDisplay] != secure_sessions[kSecureDisplay]) {
|
|
SecureEvent secure_event =
|
|
secure_sessions.test(kSecureDisplay) ? kSecureDisplayStart : kSecureDisplayEnd;
|
|
DisplayError err = display_intf_->HandleSecureEvent(secure_event, &layer_stack_);
|
|
if (err != kErrorNone) {
|
|
DLOGE("Set secure event failed");
|
|
return err;
|
|
}
|
|
|
|
DLOGI("SecureDisplay state changed from %d to %d for display %" PRIu64 " %d-%d",
|
|
active_secure_sessions_.test(kSecureDisplay), secure_sessions.test(kSecureDisplay),
|
|
id_, sdm_id_, type_);
|
|
}
|
|
active_secure_sessions_ = secure_sessions;
|
|
*power_on_pending = false;
|
|
return 0;
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::ForceRefreshRate(uint32_t refresh_rate) {
|
|
if ((refresh_rate && (refresh_rate < min_refresh_rate_ || refresh_rate > max_refresh_rate_)) ||
|
|
force_refresh_rate_ == refresh_rate) {
|
|
// Cannot honor force refresh rate, as its beyond the range or new request is same
|
|
return;
|
|
}
|
|
|
|
force_refresh_rate_ = refresh_rate;
|
|
|
|
callbacks_->Refresh(id_);
|
|
|
|
return;
|
|
}
|
|
|
|
uint32_t HWCDisplayBuiltIn::GetOptimalRefreshRate(bool one_updating_layer) {
|
|
if (force_refresh_rate_) {
|
|
return force_refresh_rate_;
|
|
} else if (use_metadata_refresh_rate_ && one_updating_layer && metadata_refresh_rate_) {
|
|
return metadata_refresh_rate_;
|
|
}
|
|
|
|
DLOGV_IF(kTagClient, "active_refresh_rate_: %d", active_refresh_rate_);
|
|
return active_refresh_rate_;
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::SetIdleTimeoutMs(uint32_t timeout_ms) {
|
|
display_intf_->SetIdleTimeoutMs(timeout_ms);
|
|
validated_ = false;
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::HandleFrameOutput() {
|
|
if (readback_buffer_queued_) {
|
|
validated_ = false;
|
|
}
|
|
|
|
if (frame_capture_buffer_queued_) {
|
|
HandleFrameCapture();
|
|
} else if (dump_output_to_file_) {
|
|
HandleFrameDump();
|
|
}
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::HandleFrameCapture() {
|
|
if (readback_configured_ && output_buffer_.release_fence) {
|
|
frame_capture_status_ = Fence::Wait(output_buffer_.release_fence);
|
|
}
|
|
|
|
frame_capture_buffer_queued_ = false;
|
|
readback_buffer_queued_ = false;
|
|
post_processed_output_ = false;
|
|
readback_configured_ = false;
|
|
output_buffer_ = {};
|
|
cwb_client_ = kCWBClientNone;
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::HandleFrameDump() {
|
|
if (dump_frame_count_) {
|
|
int ret = 0;
|
|
ret = Fence::Wait(output_buffer_.release_fence);
|
|
if (ret != kErrorNone) {
|
|
DLOGE("sync_wait error errno = %d, desc = %s", errno, strerror(errno));
|
|
}
|
|
|
|
if (!ret) {
|
|
DumpOutputBuffer(output_buffer_info_, output_buffer_base_, layer_stack_.retire_fence);
|
|
validated_ = false;
|
|
}
|
|
|
|
if (0 == (dump_frame_count_ - 1)) {
|
|
dump_output_to_file_ = false;
|
|
// Unmap and Free buffer
|
|
if (munmap(output_buffer_base_, output_buffer_info_.alloc_buffer_info.size) != 0) {
|
|
DLOGE("unmap failed with err %d", errno);
|
|
}
|
|
if (buffer_allocator_->FreeBuffer(&output_buffer_info_) != 0) {
|
|
DLOGE("FreeBuffer failed");
|
|
}
|
|
|
|
readback_buffer_queued_ = false;
|
|
post_processed_output_ = false;
|
|
readback_configured_ = false;
|
|
|
|
output_buffer_ = {};
|
|
output_buffer_info_ = {};
|
|
output_buffer_base_ = nullptr;
|
|
cwb_client_ = kCWBClientNone;
|
|
}
|
|
}
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type,
|
|
int32_t format, bool post_processed) {
|
|
HWCDisplay::SetFrameDumpConfig(count, bit_mask_layer_type, format, post_processed);
|
|
dump_output_to_file_ = bit_mask_layer_type & (1 << OUTPUT_LAYER_DUMP);
|
|
DLOGI("output_layer_dump_enable %d", dump_output_to_file_);
|
|
|
|
if (dump_output_to_file_) {
|
|
if (cwb_client_ != kCWBClientNone) {
|
|
DLOGW("CWB is in use with client = %d", cwb_client_);
|
|
return HWC2::Error::NoResources;
|
|
}
|
|
}
|
|
|
|
if (!count || !dump_output_to_file_ || (output_buffer_info_.alloc_buffer_info.fd >= 0)) {
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
// Allocate and map output buffer
|
|
if (post_processed) {
|
|
// To dump post-processed (DSPP) output, use Panel resolution.
|
|
GetPanelResolution(&output_buffer_info_.buffer_config.width,
|
|
&output_buffer_info_.buffer_config.height);
|
|
} else {
|
|
// To dump Layer Mixer output, use FrameBuffer resolution.
|
|
GetFrameBufferResolution(&output_buffer_info_.buffer_config.width,
|
|
&output_buffer_info_.buffer_config.height);
|
|
}
|
|
|
|
output_buffer_info_.buffer_config.format = HWCLayer::GetSDMFormat(format, 0);
|
|
output_buffer_info_.buffer_config.buffer_count = 1;
|
|
if (buffer_allocator_->AllocateBuffer(&output_buffer_info_) != 0) {
|
|
DLOGE("Buffer allocation failed");
|
|
output_buffer_info_ = {};
|
|
return HWC2::Error::NoResources;
|
|
}
|
|
|
|
void *buffer = mmap(NULL, output_buffer_info_.alloc_buffer_info.size, PROT_READ | PROT_WRITE,
|
|
MAP_SHARED, output_buffer_info_.alloc_buffer_info.fd, 0);
|
|
|
|
if (buffer == MAP_FAILED) {
|
|
DLOGE("mmap failed with err %d", errno);
|
|
buffer_allocator_->FreeBuffer(&output_buffer_info_);
|
|
output_buffer_info_ = {};
|
|
return HWC2::Error::NoResources;
|
|
}
|
|
|
|
output_buffer_base_ = buffer;
|
|
const native_handle_t *handle = static_cast<native_handle_t *>(output_buffer_info_.private_data);
|
|
SetReadbackBuffer(handle, nullptr, post_processed, kCWBClientFrameDump);
|
|
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
int HWCDisplayBuiltIn::FrameCaptureAsync(const BufferInfo &output_buffer_info,
|
|
bool post_processed_output) {
|
|
if (cwb_client_ != kCWBClientNone) {
|
|
DLOGE("CWB is in use with client = %d", cwb_client_);
|
|
return -1;
|
|
}
|
|
|
|
// Note: This function is called in context of a binder thread and a lock is already held
|
|
if (output_buffer_info.alloc_buffer_info.fd < 0) {
|
|
DLOGE("Invalid fd %d", output_buffer_info.alloc_buffer_info.fd);
|
|
return -1;
|
|
}
|
|
|
|
auto panel_width = 0u;
|
|
auto panel_height = 0u;
|
|
auto fb_width = 0u;
|
|
auto fb_height = 0u;
|
|
|
|
GetPanelResolution(&panel_width, &panel_height);
|
|
GetFrameBufferResolution(&fb_width, &fb_height);
|
|
|
|
if (post_processed_output && (output_buffer_info.buffer_config.width < panel_width ||
|
|
output_buffer_info.buffer_config.height < panel_height)) {
|
|
DLOGE("Buffer dimensions should not be less than panel resolution");
|
|
return -1;
|
|
} else if (!post_processed_output && (output_buffer_info.buffer_config.width < fb_width ||
|
|
output_buffer_info.buffer_config.height < fb_height)) {
|
|
DLOGE("Buffer dimensions should not be less than FB resolution");
|
|
return -1;
|
|
}
|
|
|
|
const native_handle_t *buffer = static_cast<native_handle_t *>(output_buffer_info.private_data);
|
|
SetReadbackBuffer(buffer, nullptr, post_processed_output, kCWBClientColor);
|
|
frame_capture_buffer_queued_ = true;
|
|
frame_capture_status_ = -EAGAIN;
|
|
|
|
return 0;
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::SetDetailEnhancerConfig
|
|
(const DisplayDetailEnhancerData &de_data) {
|
|
DisplayError error = kErrorNotSupported;
|
|
|
|
if (display_intf_) {
|
|
error = display_intf_->SetDetailEnhancerData(de_data);
|
|
validated_ = false;
|
|
}
|
|
return error;
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::ControlPartialUpdate(bool enable, uint32_t *pending) {
|
|
DisplayError error = kErrorNone;
|
|
|
|
if (display_intf_) {
|
|
error = display_intf_->ControlPartialUpdate(enable, pending);
|
|
validated_ = false;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::DisablePartialUpdateOneFrame() {
|
|
DisplayError error = kErrorNone;
|
|
|
|
if (display_intf_) {
|
|
error = display_intf_->DisablePartialUpdateOneFrame();
|
|
validated_ = false;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetDisplayedContentSamplingEnabledVndService(bool enabled) {
|
|
std::unique_lock<decltype(sampling_mutex)> lk(sampling_mutex);
|
|
vndservice_sampling_vote = enabled;
|
|
if (api_sampling_vote || vndservice_sampling_vote) {
|
|
histogram.start();
|
|
display_intf_->colorSamplingOn();
|
|
} else {
|
|
display_intf_->colorSamplingOff();
|
|
histogram.stop();
|
|
}
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetDisplayedContentSamplingEnabled(int32_t enabled,
|
|
uint8_t component_mask,
|
|
uint64_t max_frames) {
|
|
if ((enabled != HWC2_DISPLAYED_CONTENT_SAMPLING_ENABLE) &&
|
|
(enabled != HWC2_DISPLAYED_CONTENT_SAMPLING_DISABLE))
|
|
return HWC2::Error::BadParameter;
|
|
|
|
std::unique_lock<decltype(sampling_mutex)> lk(sampling_mutex);
|
|
if (enabled == HWC2_DISPLAYED_CONTENT_SAMPLING_ENABLE) {
|
|
api_sampling_vote = true;
|
|
} else {
|
|
api_sampling_vote = false;
|
|
}
|
|
|
|
auto start = api_sampling_vote || vndservice_sampling_vote;
|
|
if (start && max_frames == 0) {
|
|
histogram.start();
|
|
display_intf_->colorSamplingOn();
|
|
} else if (start) {
|
|
histogram.start(max_frames);
|
|
display_intf_->colorSamplingOn();
|
|
} else {
|
|
display_intf_->colorSamplingOff();
|
|
histogram.stop();
|
|
}
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::GetDisplayedContentSamplingAttributes(
|
|
int32_t *format, int32_t *dataspace, uint8_t *supported_components) {
|
|
return histogram.getAttributes(format, dataspace, supported_components);
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::GetDisplayedContentSample(
|
|
uint64_t max_frames, uint64_t timestamp, uint64_t *numFrames,
|
|
int32_t samples_size[NUM_HISTOGRAM_COLOR_COMPONENTS],
|
|
uint64_t *samples[NUM_HISTOGRAM_COLOR_COMPONENTS]) {
|
|
histogram.collect(max_frames, timestamp, samples_size, samples, numFrames);
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::SetMixerResolution(uint32_t width, uint32_t height) {
|
|
DisplayError error = display_intf_->SetMixerResolution(width, height);
|
|
callbacks_->Refresh(id_);
|
|
validated_ = false;
|
|
return error;
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::GetMixerResolution(uint32_t *width, uint32_t *height) {
|
|
return display_intf_->GetMixerResolution(width, height);
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetQSyncMode(QSyncMode qsync_mode) {
|
|
// Client needs to ensure that config change and qsync mode change
|
|
// are not triggered in the same drawcycle.
|
|
if (pending_config_) {
|
|
DLOGE("Failed to set qsync mode. Pending active config transition");
|
|
return HWC2::Error::Unsupported;
|
|
}
|
|
|
|
auto err = display_intf_->SetQSyncMode(qsync_mode);
|
|
if (err != kErrorNone) {
|
|
return HWC2::Error::Unsupported;
|
|
}
|
|
|
|
validated_ = false;
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::ControlIdlePowerCollapse(bool enable, bool synchronous) {
|
|
DisplayError error = kErrorNone;
|
|
|
|
if (display_intf_) {
|
|
error = display_intf_->ControlIdlePowerCollapse(enable, synchronous);
|
|
validated_ = false;
|
|
}
|
|
return error;
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::SetDynamicDSIClock(uint64_t bitclk) {
|
|
DisablePartialUpdateOneFrame();
|
|
DisplayError error = display_intf_->SetDynamicDSIClock(bitclk);
|
|
if (error != kErrorNone) {
|
|
DLOGE(" failed: Clk: %" PRIu64 " Error: %d", bitclk, error);
|
|
return error;
|
|
}
|
|
|
|
callbacks_->Refresh(id_);
|
|
validated_ = false;
|
|
|
|
return kErrorNone;
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::GetDynamicDSIClock(uint64_t *bitclk) {
|
|
if (display_intf_) {
|
|
return display_intf_->GetDynamicDSIClock(bitclk);
|
|
}
|
|
|
|
return kErrorNotSupported;
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::GetSupportedDSIClock(std::vector<uint64_t> *bitclk_rates) {
|
|
if (display_intf_) {
|
|
return display_intf_->GetSupportedDSIClock(bitclk_rates);
|
|
}
|
|
|
|
return kErrorNotSupported;
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::SetStandByMode(bool enable) {
|
|
if (enable) {
|
|
if (!display_null_.IsActive()) {
|
|
stored_display_intf_ = display_intf_;
|
|
display_intf_ = &display_null_;
|
|
display_null_.SetActive(true);
|
|
DLOGD("Null display is connected successfully");
|
|
} else {
|
|
DLOGD("Null display is already connected.");
|
|
}
|
|
} else {
|
|
if (display_null_.IsActive()) {
|
|
display_intf_ = stored_display_intf_;
|
|
validated_ = false;
|
|
display_null_.SetActive(false);
|
|
DLOGD("Display is connected successfully");
|
|
} else {
|
|
DLOGD("Display is already connected.");
|
|
}
|
|
}
|
|
return kErrorNone;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::UpdateDisplayId(hwc2_display_t id) {
|
|
id_ = id;
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetPendingRefresh() {
|
|
pending_refresh_ = true;
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetPanelBrightness(float brightness) {
|
|
DisplayError ret = display_intf_->SetPanelBrightness(brightness);
|
|
if (ret != kErrorNone) {
|
|
return HWC2::Error::NoResources;
|
|
}
|
|
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::GetPanelBrightness(float *brightness) {
|
|
DisplayError ret = display_intf_->GetPanelBrightness(brightness);
|
|
if (ret != kErrorNone) {
|
|
return HWC2::Error::NoResources;
|
|
}
|
|
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::GetPanelMaxBrightness(uint32_t *max_brightness_level) {
|
|
DisplayError ret = display_intf_->GetPanelMaxBrightness(max_brightness_level);
|
|
if (ret != kErrorNone) {
|
|
return HWC2::Error::NoResources;
|
|
}
|
|
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::SetCurrentPanelGammaSource(enum PanelGammaSource source) {
|
|
DisplayError error = UpdatePanelGammaTable(source);
|
|
if (error == kErrorNone) {
|
|
current_panel_gamma_source_ = source;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetBLScale(uint32_t level) {
|
|
DisplayError ret = display_intf_->SetBLScale(level);
|
|
if (ret != kErrorNone) {
|
|
return HWC2::Error::NoResources;
|
|
}
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::UpdatePowerMode(HWC2::PowerMode mode) {
|
|
current_power_mode_ = mode;
|
|
validated_ = false;
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetClientTarget(buffer_handle_t target,
|
|
shared_ptr<Fence> acquire_fence,
|
|
int32_t dataspace, hwc_region_t damage) {
|
|
HWC2::Error error = HWCDisplay::SetClientTarget(target, acquire_fence, dataspace, damage);
|
|
if (error != HWC2::Error::None) {
|
|
return error;
|
|
}
|
|
|
|
// windowed_display and dynamic scaling are not supported.
|
|
if (windowed_display_) {
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
Layer *sdm_layer = client_target_->GetSDMLayer();
|
|
uint32_t fb_width = 0, fb_height = 0;
|
|
|
|
GetFrameBufferResolution(&fb_width, &fb_height);
|
|
|
|
if (fb_width != sdm_layer->input_buffer.unaligned_width ||
|
|
fb_height != sdm_layer->input_buffer.unaligned_height) {
|
|
if (SetFrameBufferConfig(sdm_layer->input_buffer.unaligned_width,
|
|
sdm_layer->input_buffer.unaligned_height)) {
|
|
return HWC2::Error::BadParameter;
|
|
}
|
|
}
|
|
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
bool HWCDisplayBuiltIn::IsSmartPanelConfig(uint32_t config_id) {
|
|
if (config_id < hwc_config_map_.size()) {
|
|
uint32_t index = hwc_config_map_.at(config_id);
|
|
return variable_config_map_.at(index).smart_panel;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool HWCDisplayBuiltIn::HasSmartPanelConfig(void) {
|
|
if (!enable_poms_during_doze_) {
|
|
uint32_t config = 0;
|
|
GetActiveDisplayConfig(&config);
|
|
return IsSmartPanelConfig(config);
|
|
}
|
|
|
|
for (auto &config : variable_config_map_) {
|
|
if (config.second.smart_panel) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int HWCDisplayBuiltIn::Deinit() {
|
|
// Destory color convert instance. This destroys thread and underlying GL resources.
|
|
if (gl_layer_stitch_) {
|
|
layer_stitch_task_.PerformTask(LayerStitchTaskCode::kCodeDestroyInstance, nullptr);
|
|
}
|
|
|
|
histogram.stop();
|
|
return HWCDisplay::Deinit();
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::OnTask(const LayerStitchTaskCode &task_code,
|
|
SyncTask<LayerStitchTaskCode>::TaskContext *task_context) {
|
|
switch (task_code) {
|
|
case LayerStitchTaskCode::kCodeGetInstance: {
|
|
gl_layer_stitch_ = GLLayerStitch::GetInstance(false /* Non-secure */);
|
|
}
|
|
break;
|
|
case LayerStitchTaskCode::kCodeStitch: {
|
|
DTRACE_SCOPED();
|
|
LayerStitchContext* ctx = reinterpret_cast<LayerStitchContext*>(task_context);
|
|
gl_layer_stitch_->Blit(ctx->stitch_params, &(ctx->release_fence));
|
|
}
|
|
break;
|
|
case LayerStitchTaskCode::kCodeDestroyInstance: {
|
|
if (gl_layer_stitch_) {
|
|
GLLayerStitch::Destroy(gl_layer_stitch_);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool HWCDisplayBuiltIn::InitLayerStitch() {
|
|
if (!is_primary_) {
|
|
// Disable on all non-primary builtins.
|
|
DLOGI("Non-primary builtin.");
|
|
disable_layer_stitch_ = true;
|
|
return true;
|
|
}
|
|
|
|
// Disable by default.
|
|
int value = 1;
|
|
Debug::Get()->GetProperty(DISABLE_LAYER_STITCH, &value);
|
|
disable_layer_stitch_ = (value == 1);
|
|
|
|
if (disable_layer_stitch_) {
|
|
DLOGI("Layer Stitch Disabled !!!");
|
|
return true;
|
|
}
|
|
|
|
// Initialize stitch context. This will be non-secure.
|
|
layer_stitch_task_.PerformTask(LayerStitchTaskCode::kCodeGetInstance, nullptr);
|
|
if (gl_layer_stitch_ == nullptr) {
|
|
DLOGE("Failed to get LayerStitch Instance");
|
|
return false;
|
|
}
|
|
|
|
if (!AllocateStitchBuffer()) {
|
|
return true;
|
|
}
|
|
|
|
stitch_target_ = new HWCLayer(id_, static_cast<HWCBufferAllocator *>(buffer_allocator_));
|
|
|
|
// Populate buffer params and pvt handle.
|
|
InitStitchTarget();
|
|
|
|
DLOGI("Created LayerStitch instance: %p", gl_layer_stitch_);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool HWCDisplayBuiltIn::AllocateStitchBuffer() {
|
|
// Buffer dimensions: FB width * (1.5 * height)
|
|
|
|
DisplayError error = display_intf_->GetFrameBufferConfig(&fb_config_);
|
|
if (error != kErrorNone) {
|
|
DLOGE("Get frame buffer config failed. Error = %d", error);
|
|
return false;
|
|
}
|
|
|
|
BufferConfig &config = buffer_info_.buffer_config;
|
|
config.width = fb_config_.x_pixels;
|
|
config.height = fb_config_.y_pixels * kBufferHeightFactor;
|
|
|
|
// By default UBWC is enabled and below property is global enable/disable for all
|
|
// buffers allocated through gralloc , including framebuffer targets.
|
|
int ubwc_disabled = 0;
|
|
HWCDebugHandler::Get()->GetProperty(DISABLE_UBWC_PROP, &ubwc_disabled);
|
|
config.format = ubwc_disabled ? kFormatRGBA8888 : kFormatRGBA8888Ubwc;
|
|
|
|
config.gfx_client = true;
|
|
|
|
// Populate default params.
|
|
config.secure = false;
|
|
config.cache = false;
|
|
config.secure_camera = false;
|
|
|
|
error = buffer_allocator_->AllocateBuffer(&buffer_info_);
|
|
|
|
if (error != kErrorNone) {
|
|
DLOGE("Failed to allocate buffer. Error: %d", error);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::InitStitchTarget() {
|
|
LayerBuffer buffer = {};
|
|
buffer.planes[0].fd = buffer_info_.alloc_buffer_info.fd;
|
|
buffer.planes[0].offset = 0;
|
|
buffer.planes[0].stride = buffer_info_.alloc_buffer_info.stride;
|
|
buffer.size = buffer_info_.alloc_buffer_info.size;
|
|
buffer.handle_id = buffer_info_.alloc_buffer_info.id;
|
|
buffer.width = buffer_info_.alloc_buffer_info.aligned_width;
|
|
buffer.height = buffer_info_.alloc_buffer_info.aligned_height;
|
|
buffer.unaligned_width = fb_config_.x_pixels;
|
|
buffer.unaligned_height = fb_config_.y_pixels * kBufferHeightFactor;
|
|
buffer.format = buffer_info_.alloc_buffer_info.format;
|
|
|
|
Layer *sdm_stitch_target = stitch_target_->GetSDMLayer();
|
|
sdm_stitch_target->composition = kCompositionStitchTarget;
|
|
sdm_stitch_target->input_buffer = buffer;
|
|
sdm_stitch_target->input_buffer.buffer_id = reinterpret_cast<uint64_t>(buffer_info_.private_data);
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::AppendStitchLayer() {
|
|
if (disable_layer_stitch_) {
|
|
return;
|
|
}
|
|
|
|
// Append stitch target buffer to layer stack.
|
|
Layer *sdm_stitch_target = stitch_target_->GetSDMLayer();
|
|
sdm_stitch_target->composition = kCompositionStitchTarget;
|
|
sdm_stitch_target->dst_rect = {0, 0, FLOAT(fb_config_.x_pixels), FLOAT(fb_config_.y_pixels)};
|
|
layer_stack_.layers.push_back(sdm_stitch_target);
|
|
}
|
|
|
|
DisplayError HWCDisplayBuiltIn::HistogramEvent(int fd, uint32_t blob_id) {
|
|
histogram.notify_histogram_event(fd, blob_id);
|
|
return kErrorNone;
|
|
}
|
|
|
|
int HWCDisplayBuiltIn::PostInit() {
|
|
auto status = InitLayerStitch();
|
|
if (!status) {
|
|
DLOGW("Failed to initialize Layer Stitch context");
|
|
// Disable layer stitch.
|
|
disable_layer_stitch_ = true;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool HWCDisplayBuiltIn::HasReadBackBufferSupport() {
|
|
DisplayConfigFixedInfo fixed_info = {};
|
|
display_intf_->GetConfig(&fixed_info);
|
|
|
|
return fixed_info.readback_supported;
|
|
}
|
|
|
|
uint32_t HWCDisplayBuiltIn::GetUpdatingAppLayersCount() {
|
|
uint32_t updating_count = 0;
|
|
|
|
for (auto layer:layer_stack_.layers) {
|
|
if (layer->composition == kCompositionGPUTarget) {
|
|
break;
|
|
}
|
|
if (layer->flags.updating) {
|
|
updating_count++;
|
|
}
|
|
}
|
|
|
|
return updating_count;
|
|
}
|
|
|
|
bool HWCDisplayBuiltIn::IsDisplayIdle() {
|
|
// Notify only if this display is source of vsync.
|
|
bool vsync_source = (callbacks_->GetVsyncSource() == id_);
|
|
return vsync_source && display_idle_;
|
|
}
|
|
|
|
void HWCDisplayBuiltIn::SetCpuPerfHintLargeCompCycle() {
|
|
if (!cpu_hint_ || !perf_hint_large_comp_cycle_) {
|
|
DLOGV_IF(kTagResources, "cpu_hint_ not initialized or property not set");
|
|
return;
|
|
}
|
|
|
|
for (auto hwc_layer : layer_set_) {
|
|
Layer *layer = hwc_layer->GetSDMLayer();
|
|
if (layer->composition == kCompositionGPU) {
|
|
DLOGV_IF(kTagResources, "Set perf hint for large comp cycle");
|
|
int hwc_tid = gettid();
|
|
cpu_hint_->ReqHintsOffload(kPerfHintLargeCompCycle, hwc_tid);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::ApplyHbmLocked() {
|
|
if (!mHasHbmNode)
|
|
return HWC2::Error::Unsupported;
|
|
|
|
HbmState state = HbmState::OFF;
|
|
for (auto req : mHbmSates) {
|
|
if (req == HbmState::SUNLIGHT) {
|
|
state = HbmState::SUNLIGHT;
|
|
break;
|
|
} else if (req == HbmState::HDR) {
|
|
state = HbmState::HDR;
|
|
}
|
|
}
|
|
|
|
if (state == mCurHbmState)
|
|
return HWC2::Error::None;
|
|
|
|
std::string action = std::to_string(static_cast<int>(state));
|
|
if (!android::base::WriteStringToFile(action, kHighBrightnessModeNode)) {
|
|
DLOGE("Failed to write hbm node = %s, error = %s ", kHighBrightnessModeNode, strerror(errno));
|
|
} else {
|
|
DLOGI("write %s to HBM sysfs file succeeded", action.c_str());
|
|
}
|
|
|
|
mCurHbmState = state;
|
|
|
|
return HWC2::Error::None;
|
|
}
|
|
|
|
bool HWCDisplayBuiltIn::IsHbmSupported() {
|
|
if (!mHasHbmNode)
|
|
return false;
|
|
|
|
bool is_hbm_supported = false;
|
|
std::string buffer;
|
|
if (!android::base::ReadFileToString(kHighBrightnessModeNode, &buffer)) {
|
|
DLOGE("Failed to read hbm node = %s, error = %s ", kHighBrightnessModeNode, strerror(errno));
|
|
} else if (buffer == "unsupported") {
|
|
DLOGI("kernel driver does not support hbm");
|
|
} else {
|
|
is_hbm_supported = true;
|
|
}
|
|
|
|
return is_hbm_supported;
|
|
}
|
|
|
|
HWC2::Error HWCDisplayBuiltIn::SetHbm(HbmState state, HbmClient client) {
|
|
auto status = HWC2::Error::None;
|
|
if (client >= CLIENT_MAX)
|
|
return HWC2::Error::BadParameter;
|
|
|
|
std::unique_lock<decltype(hbm_mutex)> lk(hbm_mutex);
|
|
|
|
/* save and apply the request state */
|
|
if (mHbmSates[client] != state) {
|
|
mHbmSates[client] = state;
|
|
|
|
status = ApplyHbmLocked();
|
|
if (INT32(status) != HWC2_ERROR_NONE)
|
|
DLOGE("Failed to apply hbm node, error = %d", status);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
HbmState HWCDisplayBuiltIn::GetHbm() {
|
|
return mCurHbmState;
|
|
}
|
|
|
|
} // namespace sdm
|