1737 lines
55 KiB
C++
1737 lines
55 KiB
C++
/*
|
|
* Copyright (c) 2014 - 2018, 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 <core/dump_interface.h>
|
|
#include <core/buffer_allocator.h>
|
|
#include <private/color_params.h>
|
|
#include <utils/constants.h>
|
|
#include <utils/String16.h>
|
|
#include <cutils/properties.h>
|
|
#include <bfqio/bfqio.h>
|
|
#include <hardware_legacy/uevent.h>
|
|
#include <sys/resource.h>
|
|
#include <sys/prctl.h>
|
|
#include <binder/Parcel.h>
|
|
#include <QService.h>
|
|
#include <gr.h>
|
|
#include <gralloc_priv.h>
|
|
#include <display_config.h>
|
|
#include <utils/debug.h>
|
|
#include <sync/sync.h>
|
|
#include <profiler.h>
|
|
#include <bitset>
|
|
#include <vector>
|
|
|
|
#include "hwc_buffer_allocator.h"
|
|
#include "hwc_buffer_sync_handler.h"
|
|
#include "hwc_session.h"
|
|
#include "hwc_debugger.h"
|
|
#include "hwc_display_null.h"
|
|
#include "hwc_display_primary.h"
|
|
#include "hwc_display_virtual.h"
|
|
#include "hwc_display_external_test.h"
|
|
#include "qd_utils.h"
|
|
|
|
#define __CLASS__ "HWCSession"
|
|
|
|
#define HWC_UEVENT_SWITCH_HDMI "change@/devices/virtual/switch/hdmi"
|
|
#define HWC_UEVENT_GRAPHICS_FB0 "change@/devices/virtual/graphics/fb0"
|
|
|
|
static sdm::HWCSession::HWCModuleMethods g_hwc_module_methods;
|
|
|
|
hwc_module_t HAL_MODULE_INFO_SYM = {
|
|
.common = {
|
|
.tag = HARDWARE_MODULE_TAG,
|
|
.version_major = 2,
|
|
.version_minor = 0,
|
|
.id = HWC_HARDWARE_MODULE_ID,
|
|
.name = "QTI Hardware Composer Module",
|
|
.author = "CodeAurora Forum",
|
|
.methods = &g_hwc_module_methods,
|
|
.dso = 0,
|
|
.reserved = {0},
|
|
}
|
|
};
|
|
|
|
namespace sdm {
|
|
|
|
Locker HWCSession::locker_;
|
|
|
|
static void Invalidate(const struct hwc_procs *procs) {
|
|
}
|
|
|
|
static void VSync(const struct hwc_procs* procs, int disp, int64_t timestamp) {
|
|
}
|
|
|
|
static void Hotplug(const struct hwc_procs* procs, int disp, int connected) {
|
|
}
|
|
|
|
HWCSession::HWCSession(const hw_module_t *module) {
|
|
// By default, drop any events. Calls will be routed to SurfaceFlinger after registerProcs.
|
|
hwc_procs_default_.invalidate = Invalidate;
|
|
hwc_procs_default_.vsync = VSync;
|
|
hwc_procs_default_.hotplug = Hotplug;
|
|
|
|
hwc_composer_device_1_t::common.tag = HARDWARE_DEVICE_TAG;
|
|
hwc_composer_device_1_t::common.version = HWC_DEVICE_API_VERSION_1_5;
|
|
hwc_composer_device_1_t::common.module = const_cast<hw_module_t*>(module);
|
|
hwc_composer_device_1_t::common.close = Close;
|
|
hwc_composer_device_1_t::prepare = Prepare;
|
|
hwc_composer_device_1_t::set = Set;
|
|
hwc_composer_device_1_t::eventControl = EventControl;
|
|
hwc_composer_device_1_t::setPowerMode = SetPowerMode;
|
|
hwc_composer_device_1_t::query = Query;
|
|
hwc_composer_device_1_t::registerProcs = RegisterProcs;
|
|
hwc_composer_device_1_t::dump = Dump;
|
|
hwc_composer_device_1_t::getDisplayConfigs = GetDisplayConfigs;
|
|
hwc_composer_device_1_t::getDisplayAttributes = GetDisplayAttributes;
|
|
hwc_composer_device_1_t::getActiveConfig = GetActiveConfig;
|
|
hwc_composer_device_1_t::setActiveConfig = SetActiveConfig;
|
|
hwc_composer_device_1_t::setCursorPositionAsync = SetCursorPositionAsync;
|
|
}
|
|
|
|
int HWCSession::Init() {
|
|
int status = -EINVAL;
|
|
const char *qservice_name = "display.qservice";
|
|
|
|
// Start QService and connect to it.
|
|
qService::QService::init();
|
|
android::sp<qService::IQService> iqservice = android::interface_cast<qService::IQService>(
|
|
android::defaultServiceManager()->getService(android::String16(qservice_name)));
|
|
|
|
if (iqservice.get()) {
|
|
iqservice->connect(android::sp<qClient::IQClient>(this));
|
|
qservice_ = reinterpret_cast<qService::QService* >(iqservice.get());
|
|
} else {
|
|
DLOGE("Failed to acquire %s", qservice_name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
DisplayError error = CoreInterface::CreateCore(HWCDebugHandler::Get(), &buffer_allocator_,
|
|
&buffer_sync_handler_, &socket_handler_,
|
|
&core_intf_);
|
|
if (error != kErrorNone) {
|
|
DLOGE("Display core initialization failed. Error = %d", error);
|
|
return -EINVAL;
|
|
}
|
|
|
|
SCOPE_LOCK(uevent_locker_);
|
|
|
|
if (pthread_create(&uevent_thread_, NULL, &HWCUeventThread, this) < 0) {
|
|
DLOGE("Failed to start = %s, error = %s", uevent_thread_name_, strerror(errno));
|
|
CoreInterface::DestroyCore();
|
|
return -errno;
|
|
}
|
|
|
|
// Wait for uevent_init() to happen and let the uevent thread wait for uevents, so that hdmi
|
|
// connect/disconnect events won't be missed
|
|
uevent_locker_.Wait();
|
|
|
|
// Read which display is first, and create it and store it in primary slot
|
|
HWDisplayInterfaceInfo hw_disp_info;
|
|
error = core_intf_->GetFirstDisplayInterfaceType(&hw_disp_info);
|
|
if (error == kErrorNone) {
|
|
if (hw_disp_info.type == kHDMI) {
|
|
// HDMI is primary display. If already connected, then create it and store in
|
|
// primary display slot. If not connected, create a NULL display for now.
|
|
HWCDebugHandler::Get()->SetProperty("persist.sys.is_hdmi_primary", "1");
|
|
is_hdmi_primary_ = true;
|
|
if (hw_disp_info.is_connected) {
|
|
status = CreateExternalDisplay(HWC_DISPLAY_PRIMARY, 0, 0, false);
|
|
is_hdmi_yuv_ = IsDisplayYUV(HWC_DISPLAY_PRIMARY);
|
|
} else {
|
|
// NullDisplay simply closes all its fences, and advertizes a standard
|
|
// resolution to SurfaceFlinger
|
|
status = HWCDisplayNull::Create(core_intf_, &hwc_procs_,
|
|
&hwc_display_[HWC_DISPLAY_PRIMARY]);
|
|
}
|
|
} else {
|
|
// Create and power on primary display
|
|
status = HWCDisplayPrimary::Create(core_intf_, &buffer_allocator_, &hwc_procs_, qservice_,
|
|
&hwc_display_[HWC_DISPLAY_PRIMARY]);
|
|
}
|
|
} else {
|
|
// Create and power on primary display
|
|
status = HWCDisplayPrimary::Create(core_intf_, &buffer_allocator_, &hwc_procs_, qservice_,
|
|
&hwc_display_[HWC_DISPLAY_PRIMARY]);
|
|
}
|
|
|
|
if (status) {
|
|
CoreInterface::DestroyCore();
|
|
uevent_thread_exit_ = true;
|
|
pthread_join(uevent_thread_, NULL);
|
|
return status;
|
|
}
|
|
|
|
color_mgr_ = HWCColorManager::CreateColorManager();
|
|
if (!color_mgr_) {
|
|
DLOGW("Failed to load HWCColorManager.");
|
|
}
|
|
|
|
connected_displays_[HWC_DISPLAY_PRIMARY] = 1;
|
|
struct rlimit fd_limit = {};
|
|
getrlimit(RLIMIT_NOFILE, &fd_limit);
|
|
fd_limit.rlim_cur = fd_limit.rlim_cur * 2;
|
|
auto err = setrlimit(RLIMIT_NOFILE, &fd_limit);
|
|
if (err) {
|
|
DLOGW("Unable to increase fd limit - err: %d, %s", errno, strerror(errno));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int HWCSession::Deinit() {
|
|
HWCDisplayPrimary::Destroy(hwc_display_[HWC_DISPLAY_PRIMARY]);
|
|
hwc_display_[HWC_DISPLAY_PRIMARY] = 0;
|
|
if (color_mgr_) {
|
|
color_mgr_->DestroyColorManager();
|
|
}
|
|
uevent_thread_exit_ = true;
|
|
pthread_join(uevent_thread_, NULL);
|
|
|
|
DisplayError error = CoreInterface::DestroyCore();
|
|
if (error != kErrorNone) {
|
|
DLOGE("Display core de-initialization failed. Error = %d", error);
|
|
}
|
|
|
|
connected_displays_[HWC_DISPLAY_PRIMARY] = 0;
|
|
return 0;
|
|
}
|
|
|
|
int HWCSession::Open(const hw_module_t *module, const char *name, hw_device_t **device) {
|
|
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
|
|
|
|
if (!module || !name || !device) {
|
|
DLOGE("Invalid parameters.");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!strcmp(name, HWC_HARDWARE_COMPOSER)) {
|
|
HWCSession *hwc_session = new HWCSession(module);
|
|
if (!hwc_session) {
|
|
return -ENOMEM;
|
|
}
|
|
|
|
int status = hwc_session->Init();
|
|
if (status != 0) {
|
|
delete hwc_session;
|
|
return status;
|
|
}
|
|
|
|
hwc_composer_device_1_t *composer_device = hwc_session;
|
|
*device = reinterpret_cast<hw_device_t *>(composer_device);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int HWCSession::Close(hw_device_t *device) {
|
|
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
|
|
|
|
if (!device) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
hwc_composer_device_1_t *composer_device = reinterpret_cast<hwc_composer_device_1_t *>(device);
|
|
HWCSession *hwc_session = static_cast<HWCSession *>(composer_device);
|
|
|
|
hwc_session->Deinit();
|
|
delete hwc_session;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int HWCSession::Prepare(hwc_composer_device_1 *device, size_t num_displays,
|
|
hwc_display_contents_1_t **displays) {
|
|
DTRACE_SCOPED();
|
|
|
|
if (!device || !displays || num_displays > HWC_NUM_DISPLAY_TYPES) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
HWCSession *hwc_session = static_cast<HWCSession *>(device);
|
|
hwc_procs_t const *hwc_procs = NULL;
|
|
bool hotplug_connect = false;
|
|
|
|
// Hold mutex only in this scope.
|
|
{
|
|
SEQUENCE_ENTRY_SCOPE_LOCK(locker_);
|
|
|
|
hwc_procs = hwc_session->hwc_procs_;
|
|
|
|
if (hwc_session->reset_panel_) {
|
|
DLOGW("panel is in bad state, resetting the panel");
|
|
hwc_session->ResetPanel();
|
|
}
|
|
|
|
if (hwc_session->need_invalidate_) {
|
|
hwc_procs->invalidate(hwc_procs);
|
|
hwc_session->need_invalidate_ = false;
|
|
}
|
|
|
|
hwc_session->HandleSecureDisplaySession(displays);
|
|
|
|
if (hwc_session->color_mgr_) {
|
|
HWCDisplay *primary_display = hwc_session->hwc_display_[HWC_DISPLAY_PRIMARY];
|
|
if (primary_display && !hwc_session->is_hdmi_primary_) {
|
|
int ret = hwc_session->color_mgr_->SolidFillLayersPrepare(displays, primary_display);
|
|
if (ret)
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
for (ssize_t dpy = static_cast<ssize_t>(num_displays - 1); dpy >= 0; dpy--) {
|
|
hwc_display_contents_1_t *content_list = displays[dpy];
|
|
// If external display is connected, ignore virtual display content list.
|
|
// If virtual display content list is valid, connect virtual display if not connected.
|
|
// If virtual display content list is invalid, disconnect virtual display if connected.
|
|
// If external display connection is pending, connect external display when virtual
|
|
// display is destroyed.
|
|
// If HDMI is primary and the output format is YUV then ignore the virtual display
|
|
// content list.
|
|
if (dpy == HWC_DISPLAY_VIRTUAL) {
|
|
if (hwc_session->hwc_display_[HWC_DISPLAY_EXTERNAL] ||
|
|
(hwc_session->is_hdmi_primary_ && hwc_session->is_hdmi_yuv_)) {
|
|
continue;
|
|
}
|
|
|
|
bool valid_content = HWCDisplayVirtual::IsValidContentList(content_list);
|
|
bool connected = (hwc_session->hwc_display_[HWC_DISPLAY_VIRTUAL] != NULL);
|
|
|
|
if (valid_content && !connected) {
|
|
hwc_session->ConnectDisplay(HWC_DISPLAY_VIRTUAL, content_list);
|
|
} else if (!valid_content && connected) {
|
|
hwc_session->DisconnectDisplay(HWC_DISPLAY_VIRTUAL);
|
|
|
|
if (hwc_session->external_pending_connect_) {
|
|
DLOGI("Process pending external display connection");
|
|
hwc_session->ConnectDisplay(HWC_DISPLAY_EXTERNAL, NULL);
|
|
hwc_session->external_pending_connect_ = false;
|
|
hotplug_connect = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hwc_session->hwc_display_[dpy]) {
|
|
if (!content_list) {
|
|
DLOGI("Display[%d] connected. content_list is null", dpy);
|
|
} else if (!content_list->numHwLayers) {
|
|
DLOGE("Display[%d] connected. numHwLayers is zero", dpy);
|
|
} else {
|
|
hwc_session->hwc_display_[dpy]->Prepare(content_list);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hotplug_connect) {
|
|
// notify client
|
|
hwc_procs->hotplug(hwc_procs, HWC_DISPLAY_EXTERNAL, true);
|
|
}
|
|
// Return 0, else client will go into bad state
|
|
return 0;
|
|
}
|
|
|
|
int HWCSession::GetVsyncPeriod(int disp) {
|
|
SCOPE_LOCK(locker_);
|
|
// default value
|
|
int32_t vsync_period = 1000000000l / 60;
|
|
const uint32_t attribute = HWC_DISPLAY_VSYNC_PERIOD;
|
|
|
|
if (hwc_display_[disp]) {
|
|
hwc_display_[disp]->GetDisplayAttributes(0, &attribute, &vsync_period);
|
|
}
|
|
|
|
return vsync_period;
|
|
}
|
|
|
|
int HWCSession::Set(hwc_composer_device_1 *device, size_t num_displays,
|
|
hwc_display_contents_1_t **displays) {
|
|
DTRACE_SCOPED();
|
|
|
|
SEQUENCE_EXIT_SCOPE_LOCK(locker_);
|
|
|
|
if (!device || !displays || num_displays > HWC_NUM_DISPLAY_TYPES) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
HWCSession *hwc_session = static_cast<HWCSession *>(device);
|
|
|
|
if (hwc_session->color_mgr_) {
|
|
HWCDisplay *primary_display = hwc_session->hwc_display_[HWC_DISPLAY_PRIMARY];
|
|
if (primary_display) {
|
|
int ret = hwc_session->color_mgr_->SolidFillLayersSet(displays, primary_display);
|
|
if (ret)
|
|
return 0;
|
|
hwc_session->color_mgr_->SetColorModeDetailEnhancer(primary_display);
|
|
}
|
|
}
|
|
|
|
for (size_t dpy = 0; dpy < num_displays; dpy++) {
|
|
hwc_display_contents_1_t *content_list = displays[dpy];
|
|
|
|
// Drop virtual display composition if virtual display object could not be created
|
|
// due to HDMI concurrency.
|
|
if (dpy == HWC_DISPLAY_VIRTUAL && !hwc_session->hwc_display_[HWC_DISPLAY_VIRTUAL]) {
|
|
CloseAcquireFds(content_list);
|
|
if (content_list) {
|
|
content_list->retireFenceFd = -1;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (hwc_session->hwc_display_[dpy]) {
|
|
hwc_session->hwc_display_[dpy]->Commit(content_list);
|
|
}
|
|
CloseAcquireFds(content_list);
|
|
}
|
|
|
|
if (hwc_session->new_bw_mode_) {
|
|
hwc_display_contents_1_t *content_list = displays[HWC_DISPLAY_PRIMARY];
|
|
hwc_session->new_bw_mode_ = false;
|
|
if (hwc_session->bw_mode_release_fd_ >= 0) {
|
|
close(hwc_session->bw_mode_release_fd_);
|
|
}
|
|
hwc_session->bw_mode_release_fd_ = dup(content_list->retireFenceFd);
|
|
}
|
|
|
|
// This is only indicative of how many times SurfaceFlinger posts
|
|
// frames to the display.
|
|
CALC_FPS();
|
|
|
|
// Return 0, else client will go into bad state
|
|
return 0;
|
|
}
|
|
|
|
void HWCSession::CloseAcquireFds(hwc_display_contents_1_t *content_list) {
|
|
if (content_list) {
|
|
for (size_t i = 0; i < content_list->numHwLayers; i++) {
|
|
int &acquireFenceFd = content_list->hwLayers[i].acquireFenceFd;
|
|
if (acquireFenceFd >= 0) {
|
|
close(acquireFenceFd);
|
|
acquireFenceFd = -1;
|
|
}
|
|
}
|
|
|
|
int &outbufAcquireFenceFd = content_list->outbufAcquireFenceFd;
|
|
if (outbufAcquireFenceFd >= 0) {
|
|
close(outbufAcquireFenceFd);
|
|
outbufAcquireFenceFd = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool HWCSession::IsDisplayYUV(int disp) {
|
|
int error = -EINVAL;
|
|
bool is_yuv = false;
|
|
DisplayConfigVariableInfo attributes = {};
|
|
|
|
if (disp < 0 || disp >= HWC_NUM_DISPLAY_TYPES || !hwc_display_[disp]) {
|
|
DLOGE("Invalid input parameters. Display = %d", disp);
|
|
return is_yuv;
|
|
}
|
|
|
|
uint32_t active_config = 0;
|
|
error = hwc_display_[disp]->GetActiveDisplayConfig(&active_config);
|
|
if (!error) {
|
|
error = hwc_display_[disp]->GetDisplayAttributesForConfig(INT(active_config), &attributes);
|
|
if (error == 0) {
|
|
is_yuv = attributes.is_yuv;
|
|
} else {
|
|
DLOGW("Error querying display attributes. Display = %d, Config = %d", disp, active_config);
|
|
}
|
|
}
|
|
|
|
return is_yuv;
|
|
}
|
|
|
|
int HWCSession::EventControl(hwc_composer_device_1 *device, int disp, int event, int enable) {
|
|
SCOPE_LOCK(locker_);
|
|
|
|
if (!device) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
HWCSession *hwc_session = static_cast<HWCSession *>(device);
|
|
int status = -EINVAL;
|
|
if (hwc_session->hwc_display_[disp]) {
|
|
status = hwc_session->hwc_display_[disp]->EventControl(event, enable);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
int HWCSession::SetPowerMode(hwc_composer_device_1 *device, int disp, int mode) {
|
|
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
|
|
|
|
if (!device) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
HWCSession *hwc_session = static_cast<HWCSession *>(device);
|
|
int status = -EINVAL;
|
|
if (hwc_session->hwc_display_[disp]) {
|
|
status = hwc_session->hwc_display_[disp]->SetPowerMode(mode);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
int HWCSession::Query(hwc_composer_device_1 *device, int param, int *value) {
|
|
SCOPE_LOCK(locker_);
|
|
|
|
if (!device || !value) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
int status = 0;
|
|
|
|
switch (param) {
|
|
case HWC_BACKGROUND_LAYER_SUPPORTED:
|
|
value[0] = 1;
|
|
break;
|
|
|
|
default:
|
|
status = -EINVAL;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
void HWCSession::RegisterProcs(hwc_composer_device_1 *device, hwc_procs_t const *procs) {
|
|
SCOPE_LOCK(locker_);
|
|
|
|
if (!device || !procs) {
|
|
return;
|
|
}
|
|
|
|
HWCSession *hwc_session = static_cast<HWCSession *>(device);
|
|
hwc_session->hwc_procs_ = procs;
|
|
}
|
|
|
|
void HWCSession::Dump(hwc_composer_device_1 *device, char *buffer, int length) {
|
|
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
|
|
|
|
if (!device || !buffer || !length) {
|
|
return;
|
|
}
|
|
|
|
DumpInterface::GetDump(buffer, UINT32(length));
|
|
}
|
|
|
|
int HWCSession::GetDisplayConfigs(hwc_composer_device_1 *device, int disp, uint32_t *configs,
|
|
size_t *num_configs) {
|
|
SCOPE_LOCK(locker_);
|
|
|
|
if (!device || !configs || !num_configs) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (disp < HWC_DISPLAY_PRIMARY || disp > HWC_NUM_PHYSICAL_DISPLAY_TYPES) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
HWCSession *hwc_session = static_cast<HWCSession *>(device);
|
|
int status = -EINVAL;
|
|
if (hwc_session->hwc_display_[disp]) {
|
|
status = hwc_session->hwc_display_[disp]->GetDisplayConfigs(configs, num_configs);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
int HWCSession::GetDisplayAttributes(hwc_composer_device_1 *device, int disp, uint32_t config,
|
|
const uint32_t *display_attributes, int32_t *values) {
|
|
SCOPE_LOCK(locker_);
|
|
|
|
if (!device || !display_attributes || !values) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (disp < HWC_DISPLAY_PRIMARY || disp > HWC_NUM_PHYSICAL_DISPLAY_TYPES) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
HWCSession *hwc_session = static_cast<HWCSession *>(device);
|
|
int status = -EINVAL;
|
|
if (hwc_session->hwc_display_[disp]) {
|
|
status = hwc_session->hwc_display_[disp]->GetDisplayAttributes(config, display_attributes,
|
|
values);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
int HWCSession::GetActiveConfig(hwc_composer_device_1 *device, int disp) {
|
|
SCOPE_LOCK(locker_);
|
|
|
|
if (!device) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (disp < HWC_DISPLAY_PRIMARY || disp > HWC_NUM_PHYSICAL_DISPLAY_TYPES) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
HWCSession *hwc_session = static_cast<HWCSession *>(device);
|
|
int active_config = -1;
|
|
if (hwc_session->hwc_display_[disp]) {
|
|
active_config = hwc_session->hwc_display_[disp]->GetActiveConfig();
|
|
}
|
|
|
|
return active_config;
|
|
}
|
|
|
|
int HWCSession::SetActiveConfig(hwc_composer_device_1 *device, int disp, int index) {
|
|
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
|
|
|
|
if (!device) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (disp < HWC_DISPLAY_PRIMARY || disp > HWC_NUM_PHYSICAL_DISPLAY_TYPES) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
HWCSession *hwc_session = static_cast<HWCSession *>(device);
|
|
int status = -EINVAL;
|
|
|
|
if (hwc_session->hwc_display_[disp]) {
|
|
status = hwc_session->hwc_display_[disp]->SetActiveConfig(index);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
int HWCSession::SetCursorPositionAsync(hwc_composer_device_1 *device, int disp, int x, int y) {
|
|
DTRACE_SCOPED();
|
|
|
|
SCOPE_LOCK(locker_);
|
|
|
|
if (!device || (disp < HWC_DISPLAY_PRIMARY) || (disp > HWC_DISPLAY_VIRTUAL)) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
int status = -EINVAL;
|
|
HWCSession *hwc_session = static_cast<HWCSession *>(device);
|
|
if (hwc_session->hwc_display_[disp]) {
|
|
status = hwc_session->hwc_display_[disp]->SetCursorPosition(x, y);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
int HWCSession::ConnectDisplay(int disp, hwc_display_contents_1_t *content_list) {
|
|
DLOGI("Display = %d", disp);
|
|
|
|
int status = 0;
|
|
uint32_t primary_width = 0;
|
|
uint32_t primary_height = 0;
|
|
|
|
hwc_display_[HWC_DISPLAY_PRIMARY]->GetFrameBufferResolution(&primary_width, &primary_height);
|
|
|
|
if (disp == HWC_DISPLAY_EXTERNAL) {
|
|
status = CreateExternalDisplay(disp, primary_width, primary_height, false);
|
|
connected_displays_[HWC_DISPLAY_EXTERNAL] = 1;
|
|
} else if (disp == HWC_DISPLAY_VIRTUAL) {
|
|
status = HWCDisplayVirtual::Create(core_intf_, &hwc_procs_, primary_width, primary_height,
|
|
content_list, &hwc_display_[disp]);
|
|
connected_displays_[HWC_DISPLAY_VIRTUAL] = 1;
|
|
} else {
|
|
DLOGE("Invalid display type");
|
|
return -1;
|
|
}
|
|
|
|
if (!status) {
|
|
hwc_display_[disp]->SetSecureDisplay(secure_display_active_, true);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
int HWCSession::DisconnectDisplay(int disp) {
|
|
DLOGI("Display = %d", disp);
|
|
|
|
if (disp == HWC_DISPLAY_EXTERNAL) {
|
|
HWCDisplayExternal::Destroy(hwc_display_[disp]);
|
|
connected_displays_[HWC_DISPLAY_EXTERNAL] = 0;
|
|
} else if (disp == HWC_DISPLAY_VIRTUAL) {
|
|
HWCDisplayVirtual::Destroy(hwc_display_[disp]);
|
|
connected_displays_[HWC_DISPLAY_VIRTUAL] = 0;
|
|
} else {
|
|
DLOGE("Invalid display type");
|
|
return -1;
|
|
}
|
|
|
|
hwc_display_[disp] = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
android::status_t HWCSession::notifyCallback(uint32_t command, const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
|
|
|
|
android::status_t status = 0;
|
|
|
|
switch (command) {
|
|
case qService::IQService::DYNAMIC_DEBUG:
|
|
DynamicDebug(input_parcel);
|
|
break;
|
|
|
|
case qService::IQService::SCREEN_REFRESH:
|
|
hwc_procs_->invalidate(hwc_procs_);
|
|
break;
|
|
|
|
case qService::IQService::SET_IDLE_TIMEOUT:
|
|
if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
|
|
uint32_t timeout = UINT32(input_parcel->readInt32());
|
|
hwc_display_[HWC_DISPLAY_PRIMARY]->SetIdleTimeoutMs(timeout);
|
|
}
|
|
break;
|
|
|
|
case qService::IQService::SET_FRAME_DUMP_CONFIG:
|
|
SetFrameDumpConfig(input_parcel);
|
|
break;
|
|
|
|
case qService::IQService::SET_MAX_PIPES_PER_MIXER:
|
|
status = SetMaxMixerStages(input_parcel);
|
|
break;
|
|
|
|
case qService::IQService::SET_DISPLAY_MODE:
|
|
status = SetDisplayMode(input_parcel);
|
|
break;
|
|
|
|
case qService::IQService::SET_SECONDARY_DISPLAY_STATUS:
|
|
status = SetSecondaryDisplayStatus(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::CONFIGURE_DYN_REFRESH_RATE:
|
|
status = ConfigureRefreshRate(input_parcel);
|
|
break;
|
|
|
|
case qService::IQService::SET_VIEW_FRAME:
|
|
break;
|
|
|
|
case qService::IQService::TOGGLE_SCREEN_UPDATES:
|
|
status = ToggleScreenUpdates(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::QDCM_SVC_CMDS:
|
|
status = QdcmCMDHandler(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::MIN_HDCP_ENCRYPTION_LEVEL_CHANGED:
|
|
status = OnMinHdcpEncryptionLevelChange(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::CONTROL_PARTIAL_UPDATE:
|
|
status = ControlPartialUpdate(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::SET_ACTIVE_CONFIG:
|
|
status = HandleSetActiveDisplayConfig(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::GET_ACTIVE_CONFIG:
|
|
status = HandleGetActiveDisplayConfig(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::GET_CONFIG_COUNT:
|
|
status = HandleGetDisplayConfigCount(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::GET_DISPLAY_ATTRIBUTES_FOR_CONFIG:
|
|
status = HandleGetDisplayAttributesForConfig(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::GET_PANEL_BRIGHTNESS:
|
|
status = GetPanelBrightness(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::SET_PANEL_BRIGHTNESS:
|
|
status = SetPanelBrightness(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::GET_DISPLAY_VISIBLE_REGION:
|
|
status = GetVisibleDisplayRect(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::SET_CAMERA_STATUS:
|
|
status = SetDynamicBWForCamera(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::GET_BW_TRANSACTION_STATUS:
|
|
status = GetBWTransactionStatus(input_parcel, output_parcel);
|
|
break;
|
|
|
|
case qService::IQService::SET_LAYER_MIXER_RESOLUTION:
|
|
status = SetMixerResolution(input_parcel);
|
|
break;
|
|
|
|
case qService::IQService::GET_HDR_CAPABILITIES:
|
|
status = GetHdrCapabilities(input_parcel, output_parcel);
|
|
break;
|
|
|
|
default:
|
|
DLOGW("QService command = %d is not supported", command);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
android::status_t HWCSession::ToggleScreenUpdates(const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
int input = input_parcel->readInt32();
|
|
int error = android::BAD_VALUE;
|
|
|
|
if (hwc_display_[HWC_DISPLAY_PRIMARY] && (input <= 1) && (input >= 0)) {
|
|
error = hwc_display_[HWC_DISPLAY_PRIMARY]->ToggleScreenUpdates(input == 1);
|
|
if (error != 0) {
|
|
DLOGE("Failed to toggle screen updates = %d. Error = %d", input, error);
|
|
}
|
|
}
|
|
output_parcel->writeInt32(error);
|
|
|
|
return error;
|
|
}
|
|
|
|
android::status_t HWCSession::SetPanelBrightness(const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
int level = input_parcel->readInt32();
|
|
int error = android::BAD_VALUE;
|
|
|
|
if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
|
|
error = hwc_display_[HWC_DISPLAY_PRIMARY]->SetPanelBrightness(level);
|
|
if (error != 0) {
|
|
DLOGE("Failed to set the panel brightness = %d. Error = %d", level, error);
|
|
}
|
|
}
|
|
output_parcel->writeInt32(error);
|
|
|
|
return error;
|
|
}
|
|
|
|
android::status_t HWCSession::GetPanelBrightness(const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
int error = android::BAD_VALUE;
|
|
int ret = error;
|
|
|
|
if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
|
|
error = hwc_display_[HWC_DISPLAY_PRIMARY]->GetPanelBrightness(&ret);
|
|
if (error != 0) {
|
|
ret = error;
|
|
DLOGE("Failed to get the panel brightness. Error = %d", error);
|
|
}
|
|
}
|
|
output_parcel->writeInt32(ret);
|
|
|
|
return error;
|
|
}
|
|
|
|
android::status_t HWCSession::ControlPartialUpdate(const android::Parcel *input_parcel,
|
|
android::Parcel *out) {
|
|
DisplayError error = kErrorNone;
|
|
int ret = 0;
|
|
uint32_t disp_id = UINT32(input_parcel->readInt32());
|
|
uint32_t enable = UINT32(input_parcel->readInt32());
|
|
|
|
if (disp_id != HWC_DISPLAY_PRIMARY) {
|
|
DLOGW("CONTROL_PARTIAL_UPDATE is not applicable for display = %d", disp_id);
|
|
ret = -EINVAL;
|
|
out->writeInt32(ret);
|
|
return ret;
|
|
}
|
|
|
|
if (!hwc_display_[HWC_DISPLAY_PRIMARY]) {
|
|
DLOGE("primary display object is not instantiated");
|
|
ret = -EINVAL;
|
|
out->writeInt32(ret);
|
|
return ret;
|
|
}
|
|
|
|
uint32_t pending = 0;
|
|
error = hwc_display_[HWC_DISPLAY_PRIMARY]->ControlPartialUpdate(enable, &pending);
|
|
|
|
if (error == kErrorNone) {
|
|
if (!pending) {
|
|
out->writeInt32(ret);
|
|
return ret;
|
|
}
|
|
} else if (error == kErrorNotSupported) {
|
|
out->writeInt32(ret);
|
|
return ret;
|
|
} else {
|
|
ret = -EINVAL;
|
|
out->writeInt32(ret);
|
|
return ret;
|
|
}
|
|
|
|
// Todo(user): Unlock it before sending events to client. It may cause deadlocks in future.
|
|
hwc_procs_->invalidate(hwc_procs_);
|
|
|
|
// Wait until partial update control is complete
|
|
ret = locker_.WaitFinite(kPartialUpdateControlTimeoutMs);
|
|
|
|
out->writeInt32(ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
android::status_t HWCSession::HandleSetActiveDisplayConfig(const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
int config = input_parcel->readInt32();
|
|
int dpy = input_parcel->readInt32();
|
|
int error = android::BAD_VALUE;
|
|
|
|
if (dpy > HWC_DISPLAY_VIRTUAL) {
|
|
return android::BAD_VALUE;
|
|
}
|
|
|
|
if (hwc_display_[dpy]) {
|
|
error = hwc_display_[dpy]->SetActiveDisplayConfig(config);
|
|
if (error == 0) {
|
|
hwc_procs_->invalidate(hwc_procs_);
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
android::status_t HWCSession::HandleGetActiveDisplayConfig(const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
int dpy = input_parcel->readInt32();
|
|
int error = android::BAD_VALUE;
|
|
|
|
if (dpy > HWC_DISPLAY_VIRTUAL) {
|
|
return android::BAD_VALUE;
|
|
}
|
|
|
|
if (hwc_display_[dpy]) {
|
|
uint32_t config = 0;
|
|
error = hwc_display_[dpy]->GetActiveDisplayConfig(&config);
|
|
if (error == 0) {
|
|
output_parcel->writeInt32(INT(config));
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
android::status_t HWCSession::HandleGetDisplayConfigCount(const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
int dpy = input_parcel->readInt32();
|
|
int error = android::BAD_VALUE;
|
|
|
|
if (dpy > HWC_DISPLAY_VIRTUAL) {
|
|
return android::BAD_VALUE;
|
|
}
|
|
|
|
uint32_t count = 0;
|
|
if (hwc_display_[dpy]) {
|
|
error = hwc_display_[dpy]->GetDisplayConfigCount(&count);
|
|
if (error == 0) {
|
|
output_parcel->writeInt32(INT(count));
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
android::status_t HWCSession::SetDisplayPort(DisplayPort sdm_disp_port, int *hwc_disp_port) {
|
|
if (!hwc_disp_port) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
switch (sdm_disp_port) {
|
|
case kPortDSI:
|
|
*hwc_disp_port = qdutils::DISPLAY_PORT_DSI;
|
|
break;
|
|
case kPortDTV:
|
|
*hwc_disp_port = qdutils::DISPLAY_PORT_DTV;
|
|
break;
|
|
case kPortLVDS:
|
|
*hwc_disp_port = qdutils::DISPLAY_PORT_LVDS;
|
|
break;
|
|
case kPortEDP:
|
|
*hwc_disp_port = qdutils::DISPLAY_PORT_EDP;
|
|
break;
|
|
case kPortWriteBack:
|
|
*hwc_disp_port = qdutils::DISPLAY_PORT_WRITEBACK;
|
|
break;
|
|
case kPortDP:
|
|
*hwc_disp_port = qdutils::DISPLAY_PORT_DP;
|
|
break;
|
|
case kPortDefault:
|
|
*hwc_disp_port = qdutils::DISPLAY_PORT_DEFAULT;
|
|
break;
|
|
default:
|
|
DLOGE("Invalid sdm display port %d", sdm_disp_port);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
android::status_t HWCSession::HandleGetDisplayAttributesForConfig(const android::Parcel
|
|
*input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
int config = input_parcel->readInt32();
|
|
int dpy = input_parcel->readInt32();
|
|
int error = android::BAD_VALUE;
|
|
DisplayConfigVariableInfo display_attributes;
|
|
DisplayPort sdm_disp_port = kPortDefault;
|
|
int hwc_disp_port = qdutils::DISPLAY_PORT_DEFAULT;
|
|
|
|
if (dpy < HWC_DISPLAY_PRIMARY || dpy >= HWC_NUM_DISPLAY_TYPES || config < 0) {
|
|
return android::BAD_VALUE;
|
|
}
|
|
|
|
if (hwc_display_[dpy]) {
|
|
error = hwc_display_[dpy]->GetDisplayAttributesForConfig(config, &display_attributes);
|
|
if (error == 0) {
|
|
hwc_display_[dpy]->GetDisplayPort(&sdm_disp_port);
|
|
|
|
SetDisplayPort(sdm_disp_port, &hwc_disp_port);
|
|
|
|
output_parcel->writeInt32(INT(display_attributes.vsync_period_ns));
|
|
output_parcel->writeInt32(INT(display_attributes.x_pixels));
|
|
output_parcel->writeInt32(INT(display_attributes.y_pixels));
|
|
output_parcel->writeFloat(display_attributes.x_dpi);
|
|
output_parcel->writeFloat(display_attributes.y_dpi);
|
|
output_parcel->writeInt32(hwc_disp_port);
|
|
output_parcel->writeInt32(display_attributes.is_yuv);
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
android::status_t HWCSession::SetSecondaryDisplayStatus(const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
int ret = -EINVAL;
|
|
|
|
uint32_t display_id = UINT32(input_parcel->readInt32());
|
|
uint32_t display_status = UINT32(input_parcel->readInt32());
|
|
|
|
DLOGI("Display = %d, Status = %d", display_id, display_status);
|
|
|
|
if (display_id >= HWC_NUM_DISPLAY_TYPES) {
|
|
DLOGE("Invalid display_id");
|
|
} else if (display_id == HWC_DISPLAY_PRIMARY) {
|
|
DLOGE("Not supported for this display");
|
|
} else if (!hwc_display_[display_id]) {
|
|
DLOGW("Display is not connected");
|
|
} else {
|
|
ret = hwc_display_[display_id]->SetDisplayStatus(display_status);
|
|
}
|
|
|
|
output_parcel->writeInt32(ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
android::status_t HWCSession::ConfigureRefreshRate(const android::Parcel *input_parcel) {
|
|
uint32_t operation = UINT32(input_parcel->readInt32());
|
|
switch (operation) {
|
|
case qdutils::DISABLE_METADATA_DYN_REFRESH_RATE:
|
|
return hwc_display_[HWC_DISPLAY_PRIMARY]->Perform(
|
|
HWCDisplayPrimary::SET_METADATA_DYN_REFRESH_RATE, false);
|
|
case qdutils::ENABLE_METADATA_DYN_REFRESH_RATE:
|
|
return hwc_display_[HWC_DISPLAY_PRIMARY]->Perform(
|
|
HWCDisplayPrimary::SET_METADATA_DYN_REFRESH_RATE, true);
|
|
case qdutils::SET_BINDER_DYN_REFRESH_RATE:
|
|
{
|
|
uint32_t refresh_rate = UINT32(input_parcel->readInt32());
|
|
return hwc_display_[HWC_DISPLAY_PRIMARY]->Perform(
|
|
HWCDisplayPrimary::SET_BINDER_DYN_REFRESH_RATE,
|
|
refresh_rate);
|
|
}
|
|
default:
|
|
DLOGW("Invalid operation %d", operation);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
android::status_t HWCSession::SetDisplayMode(const android::Parcel *input_parcel) {
|
|
uint32_t mode = UINT32(input_parcel->readInt32());
|
|
return hwc_display_[HWC_DISPLAY_PRIMARY]->Perform(HWCDisplayPrimary::SET_DISPLAY_MODE, mode);
|
|
}
|
|
|
|
android::status_t HWCSession::SetMaxMixerStages(const android::Parcel *input_parcel) {
|
|
DisplayError error = kErrorNone;
|
|
std::bitset<32> bit_mask_display_type = UINT32(input_parcel->readInt32());
|
|
uint32_t max_mixer_stages = UINT32(input_parcel->readInt32());
|
|
|
|
if (bit_mask_display_type[HWC_DISPLAY_PRIMARY]) {
|
|
if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
|
|
error = hwc_display_[HWC_DISPLAY_PRIMARY]->SetMaxMixerStages(max_mixer_stages);
|
|
if (error != kErrorNone) {
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bit_mask_display_type[HWC_DISPLAY_EXTERNAL]) {
|
|
if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
|
|
error = hwc_display_[HWC_DISPLAY_EXTERNAL]->SetMaxMixerStages(max_mixer_stages);
|
|
if (error != kErrorNone) {
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bit_mask_display_type[HWC_DISPLAY_VIRTUAL]) {
|
|
if (hwc_display_[HWC_DISPLAY_VIRTUAL]) {
|
|
error = hwc_display_[HWC_DISPLAY_VIRTUAL]->SetMaxMixerStages(max_mixer_stages);
|
|
if (error != kErrorNone) {
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
android::status_t HWCSession::SetDynamicBWForCamera(const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
DisplayError error = kErrorNone;
|
|
uint32_t camera_status = UINT32(input_parcel->readInt32());
|
|
HWBwModes mode = camera_status > 0 ? kBwCamera : kBwDefault;
|
|
|
|
// trigger invalidate to apply new bw caps.
|
|
hwc_procs_->invalidate(hwc_procs_);
|
|
|
|
error = core_intf_->SetMaxBandwidthMode(mode);
|
|
if (error != kErrorNone) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
new_bw_mode_ = true;
|
|
need_invalidate_ = true;
|
|
|
|
return 0;
|
|
}
|
|
|
|
android::status_t HWCSession::GetBWTransactionStatus(const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
bool state = true;
|
|
|
|
if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
|
|
if (sync_wait(bw_mode_release_fd_, 0) < 0) {
|
|
DLOGI("bw_transaction_release_fd is not yet signalled: err= %s", strerror(errno));
|
|
state = false;
|
|
}
|
|
output_parcel->writeInt32(state);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void HWCSession::SetFrameDumpConfig(const android::Parcel *input_parcel) {
|
|
uint32_t frame_dump_count = UINT32(input_parcel->readInt32());
|
|
std::bitset<32> bit_mask_display_type = UINT32(input_parcel->readInt32());
|
|
uint32_t bit_mask_layer_type = UINT32(input_parcel->readInt32());
|
|
|
|
if (bit_mask_display_type[HWC_DISPLAY_PRIMARY]) {
|
|
if (hwc_display_[HWC_DISPLAY_PRIMARY]) {
|
|
hwc_display_[HWC_DISPLAY_PRIMARY]->SetFrameDumpConfig(frame_dump_count, bit_mask_layer_type);
|
|
}
|
|
}
|
|
|
|
if (bit_mask_display_type[HWC_DISPLAY_EXTERNAL]) {
|
|
if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
|
|
hwc_display_[HWC_DISPLAY_EXTERNAL]->SetFrameDumpConfig(frame_dump_count, bit_mask_layer_type);
|
|
}
|
|
}
|
|
|
|
if (bit_mask_display_type[HWC_DISPLAY_VIRTUAL]) {
|
|
if (hwc_display_[HWC_DISPLAY_VIRTUAL]) {
|
|
hwc_display_[HWC_DISPLAY_VIRTUAL]->SetFrameDumpConfig(frame_dump_count, bit_mask_layer_type);
|
|
}
|
|
}
|
|
}
|
|
|
|
android::status_t HWCSession::SetMixerResolution(const android::Parcel *input_parcel) {
|
|
DisplayError error = kErrorNone;
|
|
uint32_t dpy = UINT32(input_parcel->readInt32());
|
|
|
|
if (dpy != HWC_DISPLAY_PRIMARY) {
|
|
DLOGI("Resoulution change not supported for this display %d", dpy);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!hwc_display_[HWC_DISPLAY_PRIMARY]) {
|
|
DLOGI("Primary display is not initialized");
|
|
return -EINVAL;
|
|
}
|
|
|
|
uint32_t width = UINT32(input_parcel->readInt32());
|
|
uint32_t height = UINT32(input_parcel->readInt32());
|
|
|
|
error = hwc_display_[HWC_DISPLAY_PRIMARY]->SetMixerResolution(width, height);
|
|
if (error != kErrorNone) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
android::status_t HWCSession::GetHdrCapabilities(const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
uint32_t display_id = UINT32(input_parcel->readInt32());
|
|
if (display_id >= HWC_NUM_DISPLAY_TYPES) {
|
|
DLOGE("Invalid display id = %d", display_id);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (hwc_display_[display_id] == NULL) {
|
|
DLOGW("Display = %d not initialized", display_id);
|
|
return -EINVAL;
|
|
}
|
|
|
|
DisplayConfigFixedInfo fixed_info = {};
|
|
int ret = hwc_display_[display_id]->GetDisplayFixedConfig(&fixed_info);
|
|
if (ret) {
|
|
DLOGE("Failed");
|
|
return ret;
|
|
}
|
|
|
|
if (!fixed_info.hdr_supported) {
|
|
DLOGI("HDR is not supported");
|
|
return 0;
|
|
}
|
|
|
|
std::vector<int32_t> supported_hdr_types;
|
|
// Only HDR10 supported now, in future add other supported HDR formats(HLG, DolbyVision)
|
|
supported_hdr_types.push_back(HAL_HDR_HDR10);
|
|
|
|
static const float kLuminanceFactor = 10000.0;
|
|
// luminance is expressed in the unit of 0.0001 cd/m2, convert it to 1cd/m2.
|
|
float max_luminance = FLOAT(fixed_info.max_luminance)/kLuminanceFactor;
|
|
float max_average_luminance = FLOAT(fixed_info.average_luminance)/kLuminanceFactor;
|
|
float min_luminance = FLOAT(fixed_info.min_luminance)/kLuminanceFactor;
|
|
|
|
if (output_parcel != nullptr) {
|
|
output_parcel->writeInt32Vector(supported_hdr_types);
|
|
output_parcel->writeFloat(max_luminance);
|
|
output_parcel->writeFloat(max_average_luminance);
|
|
output_parcel->writeFloat(min_luminance);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void HWCSession::DynamicDebug(const android::Parcel *input_parcel) {
|
|
int type = input_parcel->readInt32();
|
|
bool enable = (input_parcel->readInt32() > 0);
|
|
DLOGI("type = %d enable = %d", type, enable);
|
|
int verbose_level = input_parcel->readInt32();
|
|
|
|
switch (type) {
|
|
case qService::IQService::DEBUG_ALL:
|
|
HWCDebugHandler::DebugAll(enable, verbose_level);
|
|
break;
|
|
|
|
case qService::IQService::DEBUG_MDPCOMP:
|
|
HWCDebugHandler::DebugStrategy(enable, verbose_level);
|
|
HWCDebugHandler::DebugCompManager(enable, verbose_level);
|
|
break;
|
|
|
|
case qService::IQService::DEBUG_PIPE_LIFECYCLE:
|
|
HWCDebugHandler::DebugResources(enable, verbose_level);
|
|
break;
|
|
|
|
case qService::IQService::DEBUG_DRIVER_CONFIG:
|
|
HWCDebugHandler::DebugDriverConfig(enable, verbose_level);
|
|
break;
|
|
|
|
case qService::IQService::DEBUG_ROTATOR:
|
|
HWCDebugHandler::DebugResources(enable, verbose_level);
|
|
HWCDebugHandler::DebugDriverConfig(enable, verbose_level);
|
|
HWCDebugHandler::DebugRotator(enable, verbose_level);
|
|
break;
|
|
|
|
case qService::IQService::DEBUG_QDCM:
|
|
HWCDebugHandler::DebugQdcm(enable, verbose_level);
|
|
break;
|
|
|
|
default:
|
|
DLOGW("type = %d is not supported", type);
|
|
}
|
|
}
|
|
|
|
android::status_t HWCSession::QdcmCMDHandler(const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
int ret = 0;
|
|
int32_t *brightness_value = NULL;
|
|
uint32_t display_id(0);
|
|
PPPendingParams pending_action;
|
|
PPDisplayAPIPayload resp_payload, req_payload;
|
|
|
|
if (!color_mgr_) {
|
|
return -1;
|
|
}
|
|
|
|
pending_action.action = kNoAction;
|
|
pending_action.params = NULL;
|
|
|
|
// Read display_id, payload_size and payload from in_parcel.
|
|
ret = HWCColorManager::CreatePayloadFromParcel(*input_parcel, &display_id, &req_payload);
|
|
if (!ret) {
|
|
if (HWC_DISPLAY_PRIMARY == display_id && hwc_display_[HWC_DISPLAY_PRIMARY])
|
|
ret = hwc_display_[HWC_DISPLAY_PRIMARY]->ColorSVCRequestRoute(req_payload,
|
|
&resp_payload, &pending_action);
|
|
|
|
if (HWC_DISPLAY_EXTERNAL == display_id && hwc_display_[HWC_DISPLAY_EXTERNAL])
|
|
ret = hwc_display_[HWC_DISPLAY_EXTERNAL]->ColorSVCRequestRoute(req_payload, &resp_payload,
|
|
&pending_action);
|
|
}
|
|
|
|
if (ret) {
|
|
output_parcel->writeInt32(ret); // first field in out parcel indicates return code.
|
|
req_payload.DestroyPayload();
|
|
resp_payload.DestroyPayload();
|
|
return ret;
|
|
}
|
|
|
|
switch (pending_action.action) {
|
|
case kInvalidating:
|
|
hwc_procs_->invalidate(hwc_procs_);
|
|
break;
|
|
case kEnterQDCMMode:
|
|
ret = color_mgr_->EnableQDCMMode(true, hwc_display_[HWC_DISPLAY_PRIMARY]);
|
|
break;
|
|
case kExitQDCMMode:
|
|
ret = color_mgr_->EnableQDCMMode(false, hwc_display_[HWC_DISPLAY_PRIMARY]);
|
|
break;
|
|
case kApplySolidFill:
|
|
ret = color_mgr_->SetSolidFill(pending_action.params,
|
|
true, hwc_display_[HWC_DISPLAY_PRIMARY]);
|
|
hwc_procs_->invalidate(hwc_procs_);
|
|
break;
|
|
case kDisableSolidFill:
|
|
ret = color_mgr_->SetSolidFill(pending_action.params,
|
|
false, hwc_display_[HWC_DISPLAY_PRIMARY]);
|
|
hwc_procs_->invalidate(hwc_procs_);
|
|
break;
|
|
case kSetPanelBrightness:
|
|
brightness_value = reinterpret_cast<int32_t*>(resp_payload.payload);
|
|
if (brightness_value == NULL) {
|
|
DLOGE("Brightness value is Null");
|
|
return -EINVAL;
|
|
}
|
|
if (HWC_DISPLAY_PRIMARY == display_id)
|
|
ret = hwc_display_[HWC_DISPLAY_PRIMARY]->SetPanelBrightness(*brightness_value);
|
|
break;
|
|
case kEnableFrameCapture:
|
|
ret = color_mgr_->SetFrameCapture(pending_action.params,
|
|
true, hwc_display_[HWC_DISPLAY_PRIMARY]);
|
|
hwc_procs_->invalidate(hwc_procs_);
|
|
break;
|
|
case kDisableFrameCapture:
|
|
ret = color_mgr_->SetFrameCapture(pending_action.params,
|
|
false, hwc_display_[HWC_DISPLAY_PRIMARY]);
|
|
break;
|
|
case kConfigureDetailedEnhancer:
|
|
ret = color_mgr_->SetDetailedEnhancer(pending_action.params,
|
|
hwc_display_[HWC_DISPLAY_PRIMARY]);
|
|
hwc_procs_->invalidate(hwc_procs_);
|
|
break;
|
|
case kInvalidatingAndkSetPanelBrightness:
|
|
brightness_value = reinterpret_cast<int32_t*>(resp_payload.payload);
|
|
if (brightness_value == NULL) {
|
|
DLOGE("Brightness value is Null");
|
|
return -EINVAL;
|
|
}
|
|
if (HWC_DISPLAY_PRIMARY == display_id)
|
|
ret = hwc_display_[HWC_DISPLAY_PRIMARY]->CachePanelBrightness(*brightness_value);
|
|
hwc_procs_->invalidate(hwc_procs_);
|
|
break;
|
|
case kNoAction:
|
|
break;
|
|
default:
|
|
DLOGW("Invalid pending action = %d!", pending_action.action);
|
|
break;
|
|
}
|
|
|
|
// for display API getter case, marshall returned params into out_parcel.
|
|
output_parcel->writeInt32(ret);
|
|
HWCColorManager::MarshallStructIntoParcel(resp_payload, output_parcel);
|
|
req_payload.DestroyPayload();
|
|
resp_payload.DestroyPayload();
|
|
|
|
return (ret? -EINVAL : 0);
|
|
}
|
|
|
|
android::status_t HWCSession::OnMinHdcpEncryptionLevelChange(const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
int ret = -EINVAL;
|
|
uint32_t display_id = UINT32(input_parcel->readInt32());
|
|
uint32_t min_enc_level = UINT32(input_parcel->readInt32());
|
|
|
|
DLOGI("Display %d", display_id);
|
|
|
|
if (display_id >= HWC_NUM_DISPLAY_TYPES) {
|
|
DLOGE("Invalid display_id");
|
|
} else if (display_id != HWC_DISPLAY_EXTERNAL) {
|
|
DLOGE("Not supported for display");
|
|
} else if (!hwc_display_[display_id]) {
|
|
DLOGW("Display is not connected");
|
|
} else {
|
|
ret = hwc_display_[display_id]->OnMinHdcpEncryptionLevelChange(min_enc_level);
|
|
}
|
|
|
|
output_parcel->writeInt32(ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void* HWCSession::HWCUeventThread(void *context) {
|
|
if (context) {
|
|
return reinterpret_cast<HWCSession *>(context)->HWCUeventThreadHandler();
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void* HWCSession::HWCUeventThreadHandler() {
|
|
static char uevent_data[PAGE_SIZE];
|
|
int length = 0;
|
|
|
|
uevent_locker_.Lock();
|
|
prctl(PR_SET_NAME, uevent_thread_name_, 0, 0, 0);
|
|
setpriority(PRIO_PROCESS, 0, HAL_PRIORITY_URGENT_DISPLAY);
|
|
android_set_rt_ioprio(0, 1);
|
|
if (!uevent_init()) {
|
|
DLOGE("Failed to init uevent");
|
|
pthread_exit(0);
|
|
uevent_locker_.Signal();
|
|
uevent_locker_.Unlock();
|
|
return NULL;
|
|
}
|
|
|
|
uevent_locker_.Signal();
|
|
uevent_locker_.Unlock();
|
|
|
|
while (!uevent_thread_exit_) {
|
|
// keep last 2 zeroes to ensure double 0 termination
|
|
length = uevent_next_event(uevent_data, INT32(sizeof(uevent_data)) - 2);
|
|
|
|
if (strcasestr(HWC_UEVENT_SWITCH_HDMI, uevent_data)) {
|
|
DLOGI("Uevent HDMI = %s", uevent_data);
|
|
int connected = GetEventValue(uevent_data, length, "SWITCH_STATE=");
|
|
if (connected >= 0) {
|
|
DLOGI("HDMI = %s", connected ? "connected" : "disconnected");
|
|
if (HotPlugHandler(connected) == -1) {
|
|
DLOGE("Failed handling Hotplug = %s", connected ? "connected" : "disconnected");
|
|
}
|
|
}
|
|
} else if (strcasestr(HWC_UEVENT_GRAPHICS_FB0, uevent_data)) {
|
|
DLOGI("Uevent FB0 = %s", uevent_data);
|
|
int panel_reset = GetEventValue(uevent_data, length, "PANEL_ALIVE=");
|
|
if (panel_reset == 0) {
|
|
if (hwc_procs_) {
|
|
reset_panel_ = true;
|
|
hwc_procs_->invalidate(hwc_procs_);
|
|
} else {
|
|
DLOGW("Ignore resetpanel - hwc_proc not registered");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pthread_exit(0);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
int HWCSession::GetEventValue(const char *uevent_data, int length, const char *event_info) {
|
|
const char *iterator_str = uevent_data;
|
|
while (((iterator_str - uevent_data) <= length) && (*iterator_str)) {
|
|
const char *pstr = strstr(iterator_str, event_info);
|
|
if (pstr != NULL) {
|
|
return (atoi(iterator_str + strlen(event_info)));
|
|
}
|
|
iterator_str += strlen(iterator_str) + 1;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
void HWCSession::ResetPanel() {
|
|
int status = -EINVAL;
|
|
|
|
DLOGI("Powering off primary");
|
|
status = hwc_display_[HWC_DISPLAY_PRIMARY]->SetPowerMode(HWC_POWER_MODE_OFF);
|
|
if (status) {
|
|
DLOGE("power-off on primary failed with error = %d", status);
|
|
}
|
|
|
|
DLOGI("Restoring power mode on primary");
|
|
int32_t mode = INT(hwc_display_[HWC_DISPLAY_PRIMARY]->GetLastPowerMode());
|
|
status = hwc_display_[HWC_DISPLAY_PRIMARY]->SetPowerMode(mode);
|
|
if (status) {
|
|
DLOGE("Setting power mode = %d on primary failed with error = %d", mode, status);
|
|
}
|
|
|
|
status = hwc_display_[HWC_DISPLAY_PRIMARY]->EventControl(HWC_EVENT_VSYNC, 1);
|
|
if (status) {
|
|
DLOGE("enabling vsync failed for primary with error = %d", status);
|
|
}
|
|
|
|
reset_panel_ = false;
|
|
}
|
|
|
|
int HWCSession::HotPlugHandler(bool connected) {
|
|
int status = 0;
|
|
bool notify_hotplug = false;
|
|
bool refresh_screen = false;
|
|
|
|
// To prevent sending events to client while a lock is held, acquire scope locks only within
|
|
// below scope so that those get automatically unlocked after the scope ends.
|
|
{
|
|
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
|
|
|
|
if (!hwc_display_[HWC_DISPLAY_PRIMARY]) {
|
|
DLOGE("Primay display is not connected.");
|
|
return -1;
|
|
}
|
|
|
|
|
|
HWCDisplay *primary_display = hwc_display_[HWC_DISPLAY_PRIMARY];
|
|
HWCDisplay *external_display = NULL;
|
|
HWCDisplay *null_display = NULL;
|
|
|
|
if (primary_display->GetDisplayClass() == DISPLAY_CLASS_EXTERNAL) {
|
|
external_display = static_cast<HWCDisplayExternal *>(hwc_display_[HWC_DISPLAY_PRIMARY]);
|
|
} else if (primary_display->GetDisplayClass() == DISPLAY_CLASS_NULL) {
|
|
null_display = static_cast<HWCDisplayNull *>(hwc_display_[HWC_DISPLAY_PRIMARY]);
|
|
}
|
|
|
|
// If primary display connected is a NULL display, then replace it with the external display
|
|
if (connected) {
|
|
// If we are in HDMI as primary and the primary display just got plugged in
|
|
if (is_hdmi_primary_ && null_display) {
|
|
uint32_t primary_width, primary_height;
|
|
int status = 0;
|
|
null_display->GetFrameBufferResolution(&primary_width, &primary_height);
|
|
delete null_display;
|
|
hwc_display_[HWC_DISPLAY_PRIMARY] = NULL;
|
|
|
|
// Create external display with a forced framebuffer resolution to that of what the NULL
|
|
// display had. This is necessary because SurfaceFlinger does not dynamically update
|
|
// framebuffer resolution once it reads it at bootup. So we always have to have the NULL
|
|
// display/external display both at the bootup resolution.
|
|
status = CreateExternalDisplay(HWC_DISPLAY_PRIMARY, primary_width, primary_height, true);
|
|
if (status) {
|
|
DLOGE("Could not create external display");
|
|
return -1;
|
|
}
|
|
|
|
status = hwc_display_[HWC_DISPLAY_PRIMARY]->SetPowerMode(HWC_POWER_MODE_NORMAL);
|
|
if (status) {
|
|
DLOGE("power-on on primary failed with error = %d", status);
|
|
}
|
|
|
|
is_hdmi_yuv_ = IsDisplayYUV(HWC_DISPLAY_PRIMARY);
|
|
|
|
// Next, go ahead and enable vsync on external display. This is expliclity required
|
|
// because in HDMI as primary case, SurfaceFlinger may not be aware of underlying
|
|
// changing display. and thus may not explicitly enable vsync
|
|
|
|
status = hwc_display_[HWC_DISPLAY_PRIMARY]->EventControl(HWC_EVENT_VSYNC, true);
|
|
if (status) {
|
|
DLOGE("Error enabling vsync for HDMI as primary case");
|
|
}
|
|
// Don't do hotplug notification for HDMI as primary case for now
|
|
notify_hotplug = false;
|
|
refresh_screen = true;
|
|
} else {
|
|
if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
|
|
DLOGE("HDMI is already connected");
|
|
return -1;
|
|
}
|
|
|
|
// Connect external display if virtual display is not connected.
|
|
// Else, defer external display connection and process it when virtual display
|
|
// tears down; Do not notify SurfaceFlinger since connection is deferred now.
|
|
if (!hwc_display_[HWC_DISPLAY_VIRTUAL]) {
|
|
status = ConnectDisplay(HWC_DISPLAY_EXTERNAL, NULL);
|
|
if (status) {
|
|
return status;
|
|
}
|
|
notify_hotplug = true;
|
|
} else {
|
|
DLOGI("Virtual display is connected, pending connection");
|
|
external_pending_connect_ = true;
|
|
}
|
|
}
|
|
} else {
|
|
// Do not return error if external display is not in connected status.
|
|
// Due to virtual display concurrency, external display connection might be still pending
|
|
// but hdmi got disconnected before pending connection could be processed.
|
|
|
|
if (is_hdmi_primary_ && external_display) {
|
|
uint32_t x_res, y_res;
|
|
external_display->GetFrameBufferResolution(&x_res, &y_res);
|
|
// Need to manually disable VSYNC as SF is not aware of connect/disconnect cases
|
|
// for HDMI as primary
|
|
external_display->EventControl(HWC_EVENT_VSYNC, false);
|
|
HWCDisplayExternal::Destroy(external_display);
|
|
|
|
HWCDisplayNull *null_display;
|
|
|
|
int status = HWCDisplayNull::Create(core_intf_, &hwc_procs_,
|
|
reinterpret_cast<HWCDisplay **>(&null_display));
|
|
|
|
if (status) {
|
|
DLOGE("Could not create Null display when primary got disconnected");
|
|
return -1;
|
|
}
|
|
|
|
null_display->SetResolution(x_res, y_res);
|
|
hwc_display_[HWC_DISPLAY_PRIMARY] = null_display;
|
|
|
|
// Don't do hotplug notification for HDMI as primary case for now
|
|
notify_hotplug = false;
|
|
} else {
|
|
if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
|
|
status = DisconnectDisplay(HWC_DISPLAY_EXTERNAL);
|
|
notify_hotplug = true;
|
|
}
|
|
external_pending_connect_ = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (connected && (notify_hotplug || refresh_screen)) {
|
|
// trigger screen refresh to ensure sufficient resources are available to process new
|
|
// new display connection.
|
|
hwc_procs_->invalidate(hwc_procs_);
|
|
uint32_t vsync_period = UINT32(GetVsyncPeriod(HWC_DISPLAY_PRIMARY));
|
|
usleep(vsync_period * 2 / 1000);
|
|
}
|
|
// notify client
|
|
if (notify_hotplug) {
|
|
hwc_procs_->hotplug(hwc_procs_, HWC_DISPLAY_EXTERNAL, connected);
|
|
}
|
|
|
|
qservice_->onHdmiHotplug(INT(connected));
|
|
|
|
return 0;
|
|
}
|
|
|
|
void HWCSession::HandleSecureDisplaySession(hwc_display_contents_1_t **displays) {
|
|
secure_display_active_ = false;
|
|
if (!*displays) {
|
|
DLOGW("Invalid display contents");
|
|
return;
|
|
}
|
|
|
|
hwc_display_contents_1_t *content_list = displays[HWC_DISPLAY_PRIMARY];
|
|
if (!content_list) {
|
|
DLOGW("Invalid primary content list");
|
|
return;
|
|
}
|
|
size_t num_hw_layers = content_list->numHwLayers;
|
|
|
|
for (size_t i = 0; i < num_hw_layers - 1; i++) {
|
|
hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
|
|
const private_handle_t *pvt_handle = static_cast<const private_handle_t *>(hwc_layer.handle);
|
|
if (pvt_handle && pvt_handle->flags & private_handle_t::PRIV_FLAGS_SECURE_DISPLAY) {
|
|
secure_display_active_ = true;
|
|
}
|
|
}
|
|
|
|
// Force flush on primary during transitions(secure<->non secure)
|
|
// when external displays are connected.
|
|
bool force_flush = false;
|
|
if ((connected_displays_[HWC_DISPLAY_PRIMARY] == 1) &&
|
|
((connected_displays_[HWC_DISPLAY_EXTERNAL] == 1) ||
|
|
(connected_displays_[HWC_DISPLAY_VIRTUAL] == 1))) {
|
|
force_flush = true;
|
|
}
|
|
|
|
for (ssize_t dpy = static_cast<ssize_t>(HWC_NUM_DISPLAY_TYPES - 1); dpy >= 0; dpy--) {
|
|
if (hwc_display_[dpy]) {
|
|
hwc_display_[dpy]->SetSecureDisplay(secure_display_active_, force_flush);
|
|
}
|
|
}
|
|
}
|
|
|
|
android::status_t HWCSession::GetVisibleDisplayRect(const android::Parcel *input_parcel,
|
|
android::Parcel *output_parcel) {
|
|
int dpy = input_parcel->readInt32();
|
|
|
|
if (dpy < HWC_DISPLAY_PRIMARY || dpy >= HWC_NUM_DISPLAY_TYPES) {
|
|
return android::BAD_VALUE;;
|
|
}
|
|
|
|
if (!hwc_display_[dpy]) {
|
|
return android::NO_INIT;
|
|
}
|
|
|
|
hwc_rect_t visible_rect = {0, 0, 0, 0};
|
|
int error = hwc_display_[dpy]->GetVisibleDisplayRect(&visible_rect);
|
|
if (error < 0) {
|
|
return error;
|
|
}
|
|
|
|
output_parcel->writeInt32(visible_rect.left);
|
|
output_parcel->writeInt32(visible_rect.top);
|
|
output_parcel->writeInt32(visible_rect.right);
|
|
output_parcel->writeInt32(visible_rect.bottom);
|
|
|
|
return android::NO_ERROR;
|
|
}
|
|
|
|
int HWCSession::CreateExternalDisplay(int disp, uint32_t primary_width, uint32_t primary_height,
|
|
bool use_primary_res) {
|
|
uint32_t panel_bpp = 0;
|
|
uint32_t pattern_type = 0;
|
|
|
|
if (qdutils::isDPConnected()) {
|
|
qdutils::getDPTestConfig(&panel_bpp, &pattern_type);
|
|
}
|
|
|
|
if (panel_bpp && pattern_type) {
|
|
return HWCDisplayExternalTest::Create(core_intf_, &hwc_procs_, qservice_, panel_bpp,
|
|
pattern_type, &hwc_display_[disp]);
|
|
}
|
|
|
|
return HWCDisplayExternal::Create(core_intf_, &hwc_procs_, primary_width, primary_height,
|
|
qservice_, use_primary_res, &hwc_display_[disp]);
|
|
}
|
|
|
|
} // namespace sdm
|
|
|