Google Git
Sign in
android / platform / hardware / qcom / display / f880c950c1df96f4c5ba8c6641e98805e8ca6980 / . / msm8996 / sdm / libs / core / fb / hw_device.cpp
blob: e4f8daea70188148a5a1a9de822dbb052ad27a8d [file] [log] [blame]
/*
* Copyright (c) 2014 - 2016, 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.
*/
#define __STDC_FORMAT_MACROS
#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <linux/fb.h>
#include <utils/constants.h>
#include <utils/debug.h>
#include <utils/sys.h>
#include <vector>
#include <algorithm>
#include "hw_device.h"
#include "hw_info_interface.h"
#define __CLASS__ "HWDevice"
namespace sdm {
HWDevice::HWDevice(BufferSyncHandler *buffer_sync_handler)
: fb_node_index_(-1), fb_path_("/sys/devices/virtual/graphics/fb"), hotplug_enabled_(false),
buffer_sync_handler_(buffer_sync_handler), synchronous_commit_(false) {
}
DisplayError HWDevice::Init(HWEventHandler *eventhandler) {
DisplayError error = kErrorNone;
char device_name[64] = {0};
event_handler_ = eventhandler;
// Read the fb node index
fb_node_index_ = GetFBNodeIndex(device_type_);
if (fb_node_index_ == -1) {
DLOGE("%s should be present", device_name_);
return kErrorHardware;
}
// Populate Panel Info (Used for Partial Update)
PopulateHWPanelInfo();
// Populate HW Capabilities
hw_resource_ = HWResourceInfo();
hw_info_intf_->GetHWResourceInfo(&hw_resource_);
snprintf(device_name, sizeof(device_name), "%s%d", "/dev/graphics/fb", fb_node_index_);
device_fd_ = Sys::open_(device_name, O_RDWR);
if (device_fd_ < 0) {
DLOGE("open %s failed err = %d errstr = %s", device_name, errno, strerror(errno));
return kErrorResources;
}
return error;
}
DisplayError HWDevice::Deinit() {
if (device_fd_ >= 0) {
Sys::close_(device_fd_);
device_fd_ = -1;
}
return kErrorNone;
}
DisplayError HWDevice::GetActiveConfig(uint32_t *active_config) {
*active_config = 0;
return kErrorNone;
}
DisplayError HWDevice::GetNumDisplayAttributes(uint32_t *count) {
*count = 1;
return kErrorNone;
}
DisplayError HWDevice::GetDisplayAttributes(uint32_t index,
HWDisplayAttributes *display_attributes) {
return kErrorNone;
}
DisplayError HWDevice::GetHWPanelInfo(HWPanelInfo *panel_info) {
*panel_info = hw_panel_info_;
return kErrorNone;
}
DisplayError HWDevice::SetDisplayAttributes(uint32_t index) {
return kErrorNone;
}
DisplayError HWDevice::GetConfigIndex(uint32_t mode, uint32_t *index) {
return kErrorNone;
}
DisplayError HWDevice::PowerOn() {
DTRACE_SCOPED();
if (Sys::ioctl_(device_fd_, FBIOBLANK, FB_BLANK_UNBLANK) < 0) {
if (errno == ESHUTDOWN) {
DLOGI_IF(kTagDriverConfig, "Driver is processing shutdown sequence");
return kErrorShutDown;
}
IOCTL_LOGE(FB_BLANK_UNBLANK, device_type_);
return kErrorHardware;
}
// Need to turn on HPD
if (!hotplug_enabled_) {
hotplug_enabled_ = EnableHotPlugDetection(1);
}
return kErrorNone;
}
DisplayError HWDevice::PowerOff() {
return kErrorNone;
}
DisplayError HWDevice::Doze() {
return kErrorNone;
}
DisplayError HWDevice::DozeSuspend() {
return kErrorNone;
}
DisplayError HWDevice::Standby() {
return kErrorNone;
}
DisplayError HWDevice::Validate(HWLayers *hw_layers) {
DTRACE_SCOPED();
DisplayError error = kErrorNone;
HWLayersInfo &hw_layer_info = hw_layers->info;
LayerStack *stack = hw_layer_info.stack;
DLOGV_IF(kTagDriverConfig, "************************** %s Validate Input ***********************",
device_name_);
DLOGV_IF(kTagDriverConfig, "SDE layer count is %d", hw_layer_info.count);
mdp_layer_commit_v1 &mdp_commit = mdp_disp_commit_.commit_v1;
uint32_t &mdp_layer_count = mdp_commit.input_layer_cnt;
DLOGI_IF(kTagDriverConfig, "left_roi: x = %d, y = %d, w = %d, h = %d", mdp_commit.left_roi.x,
mdp_commit.left_roi.y, mdp_commit.left_roi.w, mdp_commit.left_roi.h);
DLOGI_IF(kTagDriverConfig, "right_roi: x = %d, y = %d, w = %d, h = %d", mdp_commit.right_roi.x,
mdp_commit.right_roi.y, mdp_commit.right_roi.w, mdp_commit.right_roi.h);
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
uint32_t layer_index = hw_layer_info.index[i];
Layer &layer = stack->layers[layer_index];
LayerBuffer *input_buffer = layer.input_buffer;
HWPipeInfo *left_pipe = &hw_layers->config[i].left_pipe;
HWPipeInfo *right_pipe = &hw_layers->config[i].right_pipe;
HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
bool is_rotator_used = (hw_rotator_session->hw_block_count != 0);
bool is_cursor_pipe_used = (hw_layer_info.use_hw_cursor & layer.flags.cursor);
for (uint32_t count = 0; count < 2; count++) {
HWPipeInfo *pipe_info = (count == 0) ? left_pipe : right_pipe;
HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
if (hw_rotate_info->valid) {
input_buffer = &hw_rotator_session->output_buffer;
}
if (pipe_info->valid) {
mdp_input_layer &mdp_layer = mdp_in_layers_[mdp_layer_count];
mdp_layer_buffer &mdp_buffer = mdp_layer.buffer;
mdp_buffer.width = input_buffer->width;
mdp_buffer.height = input_buffer->height;
mdp_buffer.comp_ratio.denom = 1000;
mdp_buffer.comp_ratio.numer = UINT32(hw_layers->config[i].compression * 1000);
if (layer.flags.solid_fill) {
mdp_buffer.format = MDP_ARGB_8888;
} else {
error = SetFormat(input_buffer->format, &mdp_buffer.format);
if (error != kErrorNone) {
return error;
}
}
mdp_layer.alpha = layer.plane_alpha;
mdp_layer.z_order = UINT16(pipe_info->z_order);
mdp_layer.transp_mask = 0xffffffff;
SetBlending(layer.blending, &mdp_layer.blend_op);
mdp_layer.pipe_ndx = pipe_info->pipe_id;
mdp_layer.horz_deci = pipe_info->horizontal_decimation;
mdp_layer.vert_deci = pipe_info->vertical_decimation;
SetRect(pipe_info->src_roi, &mdp_layer.src_rect);
SetRect(pipe_info->dst_roi, &mdp_layer.dst_rect);
SetMDPFlags(layer, is_rotator_used, is_cursor_pipe_used, &mdp_layer.flags);
SetCSC(layer.csc, &mdp_layer.color_space);
if (pipe_info->set_igc) {
SetIGC(layer, mdp_layer_count);
}
mdp_layer.bg_color = layer.solid_fill_color;
if (pipe_info->scale_data.enable_pixel_ext) {
SetHWScaleData(pipe_info->scale_data, mdp_layer_count);
mdp_layer.flags |= MDP_LAYER_ENABLE_PIXEL_EXT;
}
// Send scale data to MDP driver
mdp_layer.scale = GetScaleDataRef(mdp_layer_count);
mdp_layer_count++;
DLOGV_IF(kTagDriverConfig, "******************* Layer[%d] %s pipe Input ******************",
i, count ? "Right" : "Left");
DLOGV_IF(kTagDriverConfig, "in_w %d, in_h %d, in_f %d", mdp_buffer.width, mdp_buffer.height,
mdp_buffer.format);
DLOGV_IF(kTagDriverConfig, "plane_alpha %d, zorder %d, blending %d, horz_deci %d, "
"vert_deci %d, pipe_id = 0x%x, mdp_flags 0x%x", mdp_layer.alpha, mdp_layer.z_order,
mdp_layer.blend_op, mdp_layer.horz_deci, mdp_layer.vert_deci, mdp_layer.pipe_ndx,
mdp_layer.flags);
DLOGV_IF(kTagDriverConfig, "src_rect [%d, %d, %d, %d]", mdp_layer.src_rect.x,
mdp_layer.src_rect.y, mdp_layer.src_rect.w, mdp_layer.src_rect.h);
DLOGV_IF(kTagDriverConfig, "dst_rect [%d, %d, %d, %d]", mdp_layer.dst_rect.x,
mdp_layer.dst_rect.y, mdp_layer.dst_rect.w, mdp_layer.dst_rect.h);
for (int j = 0; j < 4; j++) {
mdp_scale_data *scale = reinterpret_cast<mdp_scale_data*>(mdp_layer.scale);
DLOGV_IF(kTagDriverConfig, "Scale Data[%d]: Phase=[%x %x %x %x] Pixel_Ext=[%d %d %d %d]",
j, scale->init_phase_x[j], scale->phase_step_x[j], scale->init_phase_y[j],
scale->phase_step_y[j], scale->num_ext_pxls_left[j], scale->num_ext_pxls_top[j],
scale->num_ext_pxls_right[j], scale->num_ext_pxls_btm[j]);
DLOGV_IF(kTagDriverConfig, "Fetch=[%d %d %d %d] Repeat=[%d %d %d %d] roi_width = %d",
scale->left_ftch[j], scale->top_ftch[j], scale->right_ftch[j], scale->btm_ftch[j],
scale->left_rpt[j], scale->top_rpt[j], scale->right_rpt[j], scale->btm_rpt[j],
scale->roi_w[j]);
}
DLOGV_IF(kTagDriverConfig, "*************************************************************");
}
}
}
if (device_type_ == kDeviceVirtual) {
LayerBuffer *output_buffer = hw_layers->info.stack->output_buffer;
// Fill WB index for virtual based on number of rotator WB blocks present in the HW.
// Eg: If 2 WB rotator blocks available, the WB index for virtual will be 2, as the
// indexing of WB blocks start from 0.
mdp_out_layer_.writeback_ndx = hw_resource_.hw_rot_info.num_rotator;
mdp_out_layer_.buffer.width = output_buffer->width;
mdp_out_layer_.buffer.height = output_buffer->height;
if (output_buffer->flags.secure) {
mdp_out_layer_.flags |= MDP_LAYER_SECURE_SESSION;
}
mdp_out_layer_.buffer.comp_ratio.denom = 1000;
mdp_out_layer_.buffer.comp_ratio.numer = UINT32(hw_layers->output_compression * 1000);
SetFormat(output_buffer->format, &mdp_out_layer_.buffer.format);
DLOGI_IF(kTagDriverConfig, "********************* Output buffer Info ************************");
DLOGI_IF(kTagDriverConfig, "out_w %d, out_h %d, out_f %d, wb_id %d",
mdp_out_layer_.buffer.width, mdp_out_layer_.buffer.height,
mdp_out_layer_.buffer.format, mdp_out_layer_.writeback_ndx);
DLOGI_IF(kTagDriverConfig, "*****************************************************************");
}
mdp_commit.flags |= MDP_VALIDATE_LAYER;
if (Sys::ioctl_(device_fd_, INT(MSMFB_ATOMIC_COMMIT), &mdp_disp_commit_) < 0) {
if (errno == ESHUTDOWN) {
DLOGI_IF(kTagDriverConfig, "Driver is processing shutdown sequence");
return kErrorShutDown;
}
IOCTL_LOGE(MSMFB_ATOMIC_COMMIT, device_type_);
DumpLayerCommit(mdp_disp_commit_);
return kErrorHardware;
}
return kErrorNone;
}
void HWDevice::DumpLayerCommit(const mdp_layer_commit &layer_commit) {
const mdp_layer_commit_v1 &mdp_commit = layer_commit.commit_v1;
const mdp_input_layer *mdp_layers = mdp_commit.input_layers;
const mdp_rect &l_roi = mdp_commit.left_roi;
const mdp_rect &r_roi = mdp_commit.right_roi;
DLOGI("mdp_commit: flags = %x, release fence = %x", mdp_commit.flags, mdp_commit.release_fence);
DLOGI("left_roi: x = %d, y = %d, w = %d, h = %d", l_roi.x, l_roi.y, l_roi.w, l_roi.h);
DLOGI("right_roi: x = %d, y = %d, w = %d, h = %d", r_roi.x, r_roi.y, r_roi.w, r_roi.h);
for (uint32_t i = 0; i < mdp_commit.input_layer_cnt; i++) {
const mdp_input_layer &layer = mdp_layers[i];
const mdp_rect &src_rect = layer.src_rect;
const mdp_rect &dst_rect = layer.dst_rect;
DLOGI("layer = %d, pipe_ndx = %x, z = %d, flags = %x",
i, layer.pipe_ndx, layer.z_order, layer.flags);
DLOGI("src_rect: x = %d, y = %d, w = %d, h = %d",
src_rect.x, src_rect.y, src_rect.w, src_rect.h);
DLOGI("dst_rect: x = %d, y = %d, w = %d, h = %d",
dst_rect.x, dst_rect.y, dst_rect.w, dst_rect.h);
}
}
DisplayError HWDevice::Commit(HWLayers *hw_layers) {
DTRACE_SCOPED();
HWLayersInfo &hw_layer_info = hw_layers->info;
LayerStack *stack = hw_layer_info.stack;
DLOGV_IF(kTagDriverConfig, "*************************** %s Commit Input ************************",
device_name_);
DLOGV_IF(kTagDriverConfig, "SDE layer count is %d", hw_layer_info.count);
mdp_layer_commit_v1 &mdp_commit = mdp_disp_commit_.commit_v1;
uint32_t mdp_layer_index = 0;
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
uint32_t layer_index = hw_layer_info.index[i];
LayerBuffer *input_buffer = stack->layers[layer_index].input_buffer;
HWPipeInfo *left_pipe = &hw_layers->config[i].left_pipe;
HWPipeInfo *right_pipe = &hw_layers->config[i].right_pipe;
HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
for (uint32_t count = 0; count < 2; count++) {
HWPipeInfo *pipe_info = (count == 0) ? left_pipe : right_pipe;
HWRotateInfo *hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
if (hw_rotate_info->valid) {
input_buffer = &hw_rotator_session->output_buffer;
}
if (pipe_info->valid) {
mdp_layer_buffer &mdp_buffer = mdp_in_layers_[mdp_layer_index].buffer;
mdp_input_layer &mdp_layer = mdp_in_layers_[mdp_layer_index];
if (input_buffer->planes[0].fd >= 0) {
mdp_buffer.plane_count = 1;
mdp_buffer.planes[0].fd = input_buffer->planes[0].fd;
mdp_buffer.planes[0].offset = input_buffer->planes[0].offset;
SetStride(device_type_, input_buffer->format, input_buffer->planes[0].stride,
&mdp_buffer.planes[0].stride);
} else {
mdp_buffer.plane_count = 0;
}
mdp_buffer.fence = input_buffer->acquire_fence_fd;
mdp_layer_index++;
DLOGV_IF(kTagDriverConfig, "****************** Layer[%d] %s pipe Input *******************",
i, count ? "Right" : "Left");
DLOGI_IF(kTagDriverConfig, "in_w %d, in_h %d, in_f %d, horz_deci %d, vert_deci %d",
mdp_buffer.width, mdp_buffer.height, mdp_buffer.format, mdp_layer.horz_deci,
mdp_layer.vert_deci);
DLOGI_IF(kTagDriverConfig, "in_buf_fd %d, in_buf_offset %d, in_buf_stride %d, " \
"in_plane_count %d, in_fence %d, layer count %d", mdp_buffer.planes[0].fd,
mdp_buffer.planes[0].offset, mdp_buffer.planes[0].stride, mdp_buffer.plane_count,
mdp_buffer.fence, mdp_commit.input_layer_cnt);
DLOGV_IF(kTagDriverConfig, "*************************************************************");
}
}
}
if (device_type_ == kDeviceVirtual) {
LayerBuffer *output_buffer = hw_layers->info.stack->output_buffer;
if (output_buffer->planes[0].fd >= 0) {
mdp_out_layer_.buffer.planes[0].fd = output_buffer->planes[0].fd;
mdp_out_layer_.buffer.planes[0].offset = output_buffer->planes[0].offset;
SetStride(device_type_, output_buffer->format, output_buffer->planes[0].stride,
&mdp_out_layer_.buffer.planes[0].stride);
mdp_out_layer_.buffer.plane_count = 1;
} else {
DLOGE("Invalid output buffer fd");
return kErrorParameters;
}
mdp_out_layer_.buffer.fence = output_buffer->acquire_fence_fd;
DLOGI_IF(kTagDriverConfig, "********************** Output buffer Info ***********************");
DLOGI_IF(kTagDriverConfig, "out_fd %d, out_offset %d, out_stride %d, acquire_fence %d",
mdp_out_layer_.buffer.planes[0].fd, mdp_out_layer_.buffer.planes[0].offset,
mdp_out_layer_.buffer.planes[0].stride, mdp_out_layer_.buffer.fence);
DLOGI_IF(kTagDriverConfig, "*****************************************************************");
}
mdp_commit.release_fence = -1;
mdp_commit.flags &= UINT32(~MDP_VALIDATE_LAYER);
if (synchronous_commit_) {
mdp_commit.flags |= MDP_COMMIT_WAIT_FOR_FINISH;
}
if (Sys::ioctl_(device_fd_, INT(MSMFB_ATOMIC_COMMIT), &mdp_disp_commit_) < 0) {
if (errno == ESHUTDOWN) {
DLOGI_IF(kTagDriverConfig, "Driver is processing shutdown sequence");
return kErrorShutDown;
}
IOCTL_LOGE(MSMFB_ATOMIC_COMMIT, device_type_);
DumpLayerCommit(mdp_disp_commit_);
synchronous_commit_ = false;
return kErrorHardware;
}
stack->retire_fence_fd = mdp_commit.retire_fence;
// MDP returns only one release fence for the entire layer stack. Duplicate this fence into all
// layers being composed by MDP.
std::vector<uint32_t> fence_dup_flag;
fence_dup_flag.clear();
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
uint32_t layer_index = hw_layer_info.index[i];
LayerBuffer *input_buffer = stack->layers[layer_index].input_buffer;
HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
if (hw_rotator_session->hw_block_count) {
input_buffer = &hw_rotator_session->output_buffer;
}
// Make sure the release fence is duplicated only once for each buffer.
if (std::find(fence_dup_flag.begin(), fence_dup_flag.end(), layer_index) ==
fence_dup_flag.end()) {
input_buffer->release_fence_fd = Sys::dup_(mdp_commit.release_fence);
fence_dup_flag.push_back(layer_index);
}
}
fence_dup_flag.clear();
hw_layer_info.sync_handle = Sys::dup_(mdp_commit.release_fence);
DLOGI_IF(kTagDriverConfig, "*************************** %s Commit Input ************************",
device_name_);
DLOGI_IF(kTagDriverConfig, "retire_fence_fd %d", stack->retire_fence_fd);
DLOGI_IF(kTagDriverConfig, "*******************************************************************");
if (mdp_commit.release_fence >= 0) {
Sys::close_(mdp_commit.release_fence);
}
if (synchronous_commit_) {
// A synchronous commit can be requested when changing the display mode so we need to update
// panel info.
PopulateHWPanelInfo();
synchronous_commit_ = false;
}
return kErrorNone;
}
DisplayError HWDevice::Flush() {
ResetDisplayParams();
mdp_layer_commit_v1 &mdp_commit = mdp_disp_commit_.commit_v1;
mdp_commit.input_layer_cnt = 0;
mdp_commit.output_layer = NULL;
mdp_commit.flags &= UINT32(~MDP_VALIDATE_LAYER);
if (Sys::ioctl_(device_fd_, INT(MSMFB_ATOMIC_COMMIT), &mdp_disp_commit_) < 0) {
if (errno == ESHUTDOWN) {
DLOGI_IF(kTagDriverConfig, "Driver is processing shutdown sequence");
return kErrorShutDown;
}
IOCTL_LOGE(MSMFB_ATOMIC_COMMIT, device_type_);
DumpLayerCommit(mdp_disp_commit_);
return kErrorHardware;
}
return kErrorNone;
}
DisplayError HWDevice::SetFormat(const LayerBufferFormat &source, uint32_t *target) {
switch (source) {
case kFormatARGB8888: *target = MDP_ARGB_8888; break;
case kFormatRGBA8888: *target = MDP_RGBA_8888; break;
case kFormatBGRA8888: *target = MDP_BGRA_8888; break;
case kFormatRGBX8888: *target = MDP_RGBX_8888; break;
case kFormatBGRX8888: *target = MDP_BGRX_8888; break;
case kFormatRGBA5551: *target = MDP_RGBA_5551; break;
case kFormatRGBA4444: *target = MDP_RGBA_4444; break;
case kFormatRGB888: *target = MDP_RGB_888; break;
case kFormatBGR888: *target = MDP_BGR_888; break;
case kFormatRGB565: *target = MDP_RGB_565; break;
case kFormatBGR565: *target = MDP_BGR_565; break;
case kFormatYCbCr420Planar: *target = MDP_Y_CB_CR_H2V2; break;
case kFormatYCrCb420Planar: *target = MDP_Y_CR_CB_H2V2; break;
case kFormatYCrCb420PlanarStride16: *target = MDP_Y_CR_CB_GH2V2; break;
case kFormatYCbCr420SemiPlanar: *target = MDP_Y_CBCR_H2V2; break;
case kFormatYCrCb420SemiPlanar: *target = MDP_Y_CRCB_H2V2; break;
case kFormatYCbCr422H1V2SemiPlanar: *target = MDP_Y_CBCR_H1V2; break;
case kFormatYCrCb422H1V2SemiPlanar: *target = MDP_Y_CRCB_H1V2; break;
case kFormatYCbCr422H2V1SemiPlanar: *target = MDP_Y_CBCR_H2V1; break;
case kFormatYCrCb422H2V1SemiPlanar: *target = MDP_Y_CRCB_H2V1; break;
case kFormatYCbCr422H2V1Packed: *target = MDP_YCBYCR_H2V1; break;
case kFormatYCbCr420SemiPlanarVenus: *target = MDP_Y_CBCR_H2V2_VENUS; break;
case kFormatRGBA8888Ubwc: *target = MDP_RGBA_8888_UBWC; break;
case kFormatRGBX8888Ubwc: *target = MDP_RGBX_8888_UBWC; break;
case kFormatBGR565Ubwc: *target = MDP_RGB_565_UBWC; break;
case kFormatYCbCr420SPVenusUbwc: *target = MDP_Y_CBCR_H2V2_UBWC; break;
case kFormatRGBA1010102: *target = MDP_RGBA_1010102; break;
case kFormatARGB2101010: *target = MDP_ARGB_2101010; break;
case kFormatRGBX1010102: *target = MDP_RGBX_1010102; break;
case kFormatXRGB2101010: *target = MDP_XRGB_2101010; break;
case kFormatBGRA1010102: *target = MDP_BGRA_1010102; break;
case kFormatABGR2101010: *target = MDP_ABGR_2101010; break;
case kFormatBGRX1010102: *target = MDP_BGRX_1010102; break;
case kFormatXBGR2101010: *target = MDP_XBGR_2101010; break;
case kFormatRGBA1010102Ubwc: *target = MDP_RGBA_1010102_UBWC; break;
case kFormatRGBX1010102Ubwc: *target = MDP_RGBX_1010102_UBWC; break;
case kFormatYCbCr420P010: *target = MDP_Y_CBCR_H2V2_P010; break;
case kFormatYCbCr420TP10Ubwc: *target = MDP_Y_CBCR_H2V2_TP10_UBWC; break;
default:
DLOGE("Unsupported format type %d", source);
return kErrorParameters;
}
return kErrorNone;
}
DisplayError HWDevice::SetStride(HWDeviceType device_type, LayerBufferFormat format,
uint32_t width, uint32_t *target) {
// TODO(user): This SetStride function is a workaround to satisfy the driver expectation for
// rotator and virtual devices. Eventually this will be taken care in the driver.
if (device_type != kDeviceRotator && device_type != kDeviceVirtual) {
*target = width;
return kErrorNone;
}
switch (format) {
case kFormatARGB8888:
case kFormatRGBA8888:
case kFormatBGRA8888:
case kFormatRGBX8888:
case kFormatBGRX8888:
case kFormatRGBA8888Ubwc:
case kFormatRGBX8888Ubwc:
case kFormatRGBA1010102:
case kFormatARGB2101010:
case kFormatRGBX1010102:
case kFormatXRGB2101010:
case kFormatBGRA1010102:
case kFormatABGR2101010:
case kFormatBGRX1010102:
case kFormatXBGR2101010:
case kFormatRGBA1010102Ubwc:
case kFormatRGBX1010102Ubwc:
*target = width * 4;
break;
case kFormatRGB888:
case kFormatBGR888:
*target = width * 3;
break;
case kFormatRGB565:
case kFormatBGR565:
case kFormatBGR565Ubwc:
*target = width * 2;
break;
case kFormatYCbCr420SemiPlanarVenus:
case kFormatYCbCr420SPVenusUbwc:
case kFormatYCbCr420Planar:
case kFormatYCrCb420Planar:
case kFormatYCrCb420PlanarStride16:
case kFormatYCbCr420SemiPlanar:
case kFormatYCrCb420SemiPlanar:
case kFormatYCbCr420P010:
case kFormatYCbCr420TP10Ubwc:
*target = width;
break;
case kFormatYCbCr422H2V1Packed:
case kFormatYCrCb422H2V1SemiPlanar:
case kFormatYCrCb422H1V2SemiPlanar:
case kFormatYCbCr422H2V1SemiPlanar:
case kFormatYCbCr422H1V2SemiPlanar:
case kFormatRGBA5551:
case kFormatRGBA4444:
*target = width * 2;
break;
default:
DLOGE("Unsupported format type %d", format);
return kErrorParameters;
}
return kErrorNone;
}
void HWDevice::SetBlending(const LayerBlending &source, mdss_mdp_blend_op *target) {
switch (source) {
case kBlendingPremultiplied: *target = BLEND_OP_PREMULTIPLIED; break;
case kBlendingOpaque: *target = BLEND_OP_OPAQUE; break;
case kBlendingCoverage: *target = BLEND_OP_COVERAGE; break;
default: *target = BLEND_OP_NOT_DEFINED; break;
}
}
void HWDevice::SetRect(const LayerRect &source, mdp_rect *target) {
target->x = UINT32(source.left);
target->y = UINT32(source.top);
target->w = UINT32(source.right) - target->x;
target->h = UINT32(source.bottom) - target->y;
}
void HWDevice::SetMDPFlags(const Layer &layer, const bool &is_rotator_used,
bool is_cursor_pipe_used, uint32_t *mdp_flags) {
LayerBuffer *input_buffer = layer.input_buffer;
// Flips will be taken care by rotator, if layer uses rotator for downscale/rotation. So ignore
// flip flags for MDP.
if (!is_rotator_used) {
if (layer.transform.flip_vertical) {
*mdp_flags |= MDP_LAYER_FLIP_UD;
}
if (layer.transform.flip_horizontal) {
*mdp_flags |= MDP_LAYER_FLIP_LR;
}
if (input_buffer->flags.interlace) {
*mdp_flags |= MDP_LAYER_DEINTERLACE;
}
}
if (input_buffer->flags.secure) {
*mdp_flags |= MDP_LAYER_SECURE_SESSION;
}
if (input_buffer->flags.secure_display) {
*mdp_flags |= MDP_LAYER_SECURE_DISPLAY_SESSION;
}
if (layer.flags.solid_fill) {
*mdp_flags |= MDP_LAYER_SOLID_FILL;
}
if (hw_panel_info_.mode != kModeCommand && layer.flags.cursor && is_cursor_pipe_used) {
// command mode panels does not support async position update
*mdp_flags |= MDP_LAYER_ASYNC;
}
}
int HWDevice::GetFBNodeIndex(HWDeviceType device_type) {
for (int i = 0; i <= kDeviceVirtual; i++) {
HWPanelInfo panel_info;
GetHWPanelInfoByNode(i, &panel_info);
switch (device_type) {
case kDevicePrimary:
if (panel_info.is_primary_panel) {
return i;
}
break;
case kDeviceHDMI:
if (panel_info.is_pluggable == true) {
return i;
}
break;
case kDeviceVirtual:
if (panel_info.port == kPortWriteBack) {
return i;
}
break;
default:
break;
}
}
return -1;
}
void HWDevice::PopulateHWPanelInfo() {
hw_panel_info_ = HWPanelInfo();
GetHWPanelInfoByNode(fb_node_index_, &hw_panel_info_);
DLOGI("Device type = %d, Display Port = %d, Display Mode = %d, Device Node = %d, Is Primary = %d",
device_type_, hw_panel_info_.port, hw_panel_info_.mode, fb_node_index_,
hw_panel_info_.is_primary_panel);
DLOGI("Partial Update = %d, Dynamic FPS = %d",
hw_panel_info_.partial_update, hw_panel_info_.dynamic_fps);
DLOGI("Align: left = %d, width = %d, top = %d, height = %d",
hw_panel_info_.left_align, hw_panel_info_.width_align,
hw_panel_info_.top_align, hw_panel_info_.height_align);
DLOGI("ROI: min_width = %d, min_height = %d, need_merge = %d",
hw_panel_info_.min_roi_width, hw_panel_info_.min_roi_height,
hw_panel_info_.needs_roi_merge);
DLOGI("FPS: min = %d, max =%d", hw_panel_info_.min_fps, hw_panel_info_.max_fps);
DLOGI("Left Split = %d, Right Split = %d", hw_panel_info_.split_info.left_split,
hw_panel_info_.split_info.right_split);
}
void HWDevice::GetHWPanelNameByNode(int device_node, HWPanelInfo *panel_info) {
if (!panel_info) {
DLOGE("PanelInfo pointer in invalid.");
return;
}
char *string_buffer = reinterpret_cast<char*>(malloc(sizeof(char) * kMaxStringLength));
if (!string_buffer) {
DLOGE("Failed to allocated string_buffer memory");
return;
}
snprintf(string_buffer, kMaxStringLength, "%s%d/msm_fb_panel_info", fb_path_, device_node);
FILE *fileptr = Sys::fopen_(string_buffer, "r");
if (!fileptr) {
DLOGW("Failed to open msm_fb_panel_info node device node %d", device_node);
} else {
size_t len = kMaxStringLength;
while ((Sys::getline_(&string_buffer, &len, fileptr)) != -1) {
uint32_t token_count = 0;
const uint32_t max_count = 10;
char *tokens[max_count] = { NULL };
if (!ParseLine(string_buffer, "=\n", tokens, max_count, &token_count)) {
if (!strncmp(tokens[0], "panel_name", strlen("panel_name"))) {
snprintf(panel_info->panel_name, sizeof(panel_info->panel_name), "%s", tokens[1]);
break;
}
}
}
Sys::fclose_(fileptr);
}
free(string_buffer);
}
void HWDevice::GetHWPanelInfoByNode(int device_node, HWPanelInfo *panel_info) {
if (!panel_info) {
DLOGE("PanelInfo pointer in invalid.");
return;
}
char stringbuffer[kMaxStringLength];
FILE *fileptr = NULL;
snprintf(stringbuffer, sizeof(stringbuffer), "%s%d/msm_fb_panel_info", fb_path_, device_node);
fileptr = Sys::fopen_(stringbuffer, "r");
if (!fileptr) {
DLOGW("Failed to open msm_fb_panel_info node device node %d", device_node);
return;
}
char *line = stringbuffer;
size_t len = kMaxStringLength;
ssize_t read;
while ((read = Sys::getline_(&line, &len, fileptr)) != -1) {
uint32_t token_count = 0;
const uint32_t max_count = 10;
char *tokens[max_count] = { NULL };
if (!ParseLine(line, tokens, max_count, &token_count)) {
if (!strncmp(tokens[0], "pu_en", strlen("pu_en"))) {
panel_info->partial_update = atoi(tokens[1]);
} else if (!strncmp(tokens[0], "xstart", strlen("xstart"))) {
panel_info->left_align = atoi(tokens[1]);
} else if (!strncmp(tokens[0], "walign", strlen("walign"))) {
panel_info->width_align = atoi(tokens[1]);
} else if (!strncmp(tokens[0], "ystart", strlen("ystart"))) {
panel_info->top_align = atoi(tokens[1]);
} else if (!strncmp(tokens[0], "halign", strlen("halign"))) {
panel_info->height_align = atoi(tokens[1]);
} else if (!strncmp(tokens[0], "min_w", strlen("min_w"))) {
panel_info->min_roi_width = atoi(tokens[1]);
} else if (!strncmp(tokens[0], "min_h", strlen("min_h"))) {
panel_info->min_roi_height = atoi(tokens[1]);
} else if (!strncmp(tokens[0], "roi_merge", strlen("roi_merge"))) {
panel_info->needs_roi_merge = atoi(tokens[1]);
} else if (!strncmp(tokens[0], "dyn_fps_en", strlen("dyn_fps_en"))) {
panel_info->dynamic_fps = atoi(tokens[1]);
} else if (!strncmp(tokens[0], "min_fps", strlen("min_fps"))) {
panel_info->min_fps = UINT32(atoi(tokens[1]));
} else if (!strncmp(tokens[0], "max_fps", strlen("max_fps"))) {
panel_info->max_fps = UINT32(atoi(tokens[1]));
} else if (!strncmp(tokens[0], "primary_panel", strlen("primary_panel"))) {
panel_info->is_primary_panel = atoi(tokens[1]);
} else if (!strncmp(tokens[0], "is_pluggable", strlen("is_pluggable"))) {
panel_info->is_pluggable = atoi(tokens[1]);
}
}
}
Sys::fclose_(fileptr);
GetHWDisplayPortAndMode(device_node, &panel_info->port, &panel_info->mode);
GetSplitInfo(device_node, panel_info);
GetHWPanelNameByNode(device_node, panel_info);
GetHWPanelMaxBrightnessFromNode(panel_info);
}
void HWDevice::GetHWDisplayPortAndMode(int device_node, HWDisplayPort *port, HWDisplayMode *mode) {
*port = kPortDefault;
*mode = kModeDefault;
char *stringbuffer = reinterpret_cast<char*>(malloc(sizeof(char) * kMaxStringLength));
if (!stringbuffer) {
DLOGE("Failed to allocated string_buffer memory");
return;
}
snprintf(stringbuffer, kMaxStringLength, "%s%d/msm_fb_type", fb_path_, device_node);
FILE *fileptr = Sys::fopen_(stringbuffer, "r");
if (!fileptr) {
DLOGW("File not found %s", stringbuffer);
free(stringbuffer);
return;
}
size_t len = kMaxStringLength;
ssize_t read = Sys::getline_(&stringbuffer, &len, fileptr);
if (read == -1) {
Sys::fclose_(fileptr);
free(stringbuffer);
return;
}
if ((strncmp(stringbuffer, "mipi dsi cmd panel", strlen("mipi dsi cmd panel")) == 0)) {
*port = kPortDSI;
*mode = kModeCommand;
} else if ((strncmp(stringbuffer, "mipi dsi video panel", strlen("mipi dsi video panel")) == 0)) {
*port = kPortDSI;
*mode = kModeVideo;
} else if ((strncmp(stringbuffer, "lvds panel", strlen("lvds panel")) == 0)) {
*port = kPortLVDS;
*mode = kModeVideo;
} else if ((strncmp(stringbuffer, "edp panel", strlen("edp panel")) == 0)) {
*port = kPortEDP;
*mode = kModeVideo;
} else if ((strncmp(stringbuffer, "dtv panel", strlen("dtv panel")) == 0)) {
*port = kPortDTv;
*mode = kModeVideo;
} else if ((strncmp(stringbuffer, "writeback panel", strlen("writeback panel")) == 0)) {
*port = kPortWriteBack;
*mode = kModeCommand;
}
Sys::fclose_(fileptr);
free(stringbuffer);
return;
}
void HWDevice::GetSplitInfo(int device_node, HWPanelInfo *panel_info) {
char stringbuffer[kMaxStringLength];
FILE *fileptr = NULL;
uint32_t token_count = 0;
const uint32_t max_count = 10;
char *tokens[max_count] = { NULL };
// Split info - for MDSS Version 5 - No need to check version here
snprintf(stringbuffer , sizeof(stringbuffer), "%s%d/msm_fb_split", fb_path_, device_node);
fileptr = Sys::fopen_(stringbuffer, "r");
if (!fileptr) {
DLOGW("File not found %s", stringbuffer);
return;
}
char *line = stringbuffer;
size_t len = kMaxStringLength;
ssize_t read;
// Format "left right" space as delimiter
read = Sys::getline_(&line, &len, fileptr);
if (read > 0) {
if (!ParseLine(line, tokens, max_count, &token_count)) {
panel_info->split_info.left_split = UINT32(atoi(tokens[0]));
panel_info->split_info.right_split = UINT32(atoi(tokens[1]));
}
}
Sys::fclose_(fileptr);
}
void HWDevice::GetHWPanelMaxBrightnessFromNode(HWPanelInfo *panel_info) {
char brightness[kMaxStringLength] = { 0 };
char kMaxBrightnessNode[64] = { 0 };
snprintf(kMaxBrightnessNode, sizeof(kMaxBrightnessNode), "%s",
"/sys/class/leds/lcd-backlight/max_brightness");
panel_info->panel_max_brightness = 0;
int fd = Sys::open_(kMaxBrightnessNode, O_RDONLY);
if (fd < 0) {
DLOGW("Failed to open max brightness node = %s, error = %s", kMaxBrightnessNode,
strerror(errno));
return;
}
if (Sys::pread_(fd, brightness, sizeof(brightness), 0) > 0) {
panel_info->panel_max_brightness = atoi(brightness);
DLOGW("Max brightness level = %d", panel_info->panel_max_brightness);
} else {
DLOGW("Failed to read max brightness level. error = %s", strerror(errno));
}
Sys::close_(fd);
}
int HWDevice::ParseLine(char *input, char *tokens[], const uint32_t max_token, uint32_t *count) {
char *tmp_token = NULL;
char *temp_ptr;
uint32_t index = 0;
const char *delim = ", =\n";
if (!input) {
return -1;
}
tmp_token = strtok_r(input, delim, &temp_ptr);
while (tmp_token && index < max_token) {
tokens[index++] = tmp_token;
tmp_token = strtok_r(NULL, delim, &temp_ptr);
}
*count = index;
return 0;
}
int HWDevice::ParseLine(char *input, const char *delim, char *tokens[],
const uint32_t max_token, uint32_t *count) {
char *tmp_token = NULL;
char *temp_ptr;
uint32_t index = 0;
if (!input) {
return -1;
}
tmp_token = strtok_r(input, delim, &temp_ptr);
while (tmp_token && index < max_token) {
tokens[index++] = tmp_token;
tmp_token = strtok_r(NULL, delim, &temp_ptr);
}
*count = index;
return 0;
}
bool HWDevice::EnableHotPlugDetection(int enable) {
char hpdpath[kMaxStringLength];
int hdmi_node_index = GetFBNodeIndex(kDeviceHDMI);
if (hdmi_node_index < 0) {
return false;
}
snprintf(hpdpath , sizeof(hpdpath), "%s%d/hpd", fb_path_, hdmi_node_index);
char value = enable ? '1' : '0';
ssize_t length = SysFsWrite(hpdpath, &value, sizeof(value));
if (length <= 0) {
return false;
}
return true;
}
void HWDevice::ResetDisplayParams() {
memset(&mdp_disp_commit_, 0, sizeof(mdp_disp_commit_));
memset(&mdp_in_layers_, 0, sizeof(mdp_in_layers_));
memset(&mdp_out_layer_, 0, sizeof(mdp_out_layer_));
memset(&scale_data_, 0, sizeof(scale_data_));
memset(&pp_params_, 0, sizeof(pp_params_));
memset(&igc_lut_data_, 0, sizeof(igc_lut_data_));
for (uint32_t i = 0; i < kMaxSDELayers * 2; i++) {
mdp_in_layers_[i].buffer.fence = -1;
}
mdp_disp_commit_.version = MDP_COMMIT_VERSION_1_0;
mdp_disp_commit_.commit_v1.input_layers = mdp_in_layers_;
mdp_disp_commit_.commit_v1.output_layer = &mdp_out_layer_;
mdp_disp_commit_.commit_v1.release_fence = -1;
mdp_disp_commit_.commit_v1.retire_fence = -1;
}
void HWDevice::SetHWScaleData(const ScaleData &scale, uint32_t index) {
mdp_scale_data *mdp_scale = GetScaleDataRef(index);
mdp_scale->enable_pxl_ext = scale.enable_pixel_ext;
for (int i = 0; i < 4; i++) {
const HWPlane &plane = scale.plane[i];
mdp_scale->init_phase_x[i] = plane.init_phase_x;
mdp_scale->phase_step_x[i] = plane.phase_step_x;
mdp_scale->init_phase_y[i] = plane.init_phase_y;
mdp_scale->phase_step_y[i] = plane.phase_step_y;
mdp_scale->num_ext_pxls_left[i] = plane.left.extension;
mdp_scale->left_ftch[i] = plane.left.overfetch;
mdp_scale->left_rpt[i] = plane.left.repeat;
mdp_scale->num_ext_pxls_top[i] = plane.top.extension;
mdp_scale->top_ftch[i] = plane.top.overfetch;
mdp_scale->top_rpt[i] = plane.top.repeat;
mdp_scale->num_ext_pxls_right[i] = plane.right.extension;
mdp_scale->right_ftch[i] = plane.right.overfetch;
mdp_scale->right_rpt[i] = plane.right.repeat;
mdp_scale->num_ext_pxls_btm[i] = plane.bottom.extension;
mdp_scale->btm_ftch[i] = plane.bottom.overfetch;
mdp_scale->btm_rpt[i] = plane.bottom.repeat;
mdp_scale->roi_w[i] = plane.roi_width;
}
}
void HWDevice::SetCSC(LayerCSC source, mdp_color_space *color_space) {
switch (source) {
case kCSCLimitedRange601: *color_space = MDP_CSC_ITU_R_601; break;
case kCSCFullRange601: *color_space = MDP_CSC_ITU_R_601_FR; break;
case kCSCLimitedRange709: *color_space = MDP_CSC_ITU_R_709; break;
}
}
void HWDevice::SetIGC(const Layer &layer, uint32_t index) {
mdp_input_layer &mdp_layer = mdp_in_layers_[index];
mdp_overlay_pp_params &pp_params = pp_params_[index];
mdp_igc_lut_data_v1_7 &igc_lut_data = igc_lut_data_[index];
switch (layer.igc) {
case kIGCsRGB:
igc_lut_data.table_fmt = mdp_igc_srgb;
pp_params.igc_cfg.ops = MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE;
break;
default:
pp_params.igc_cfg.ops = MDP_PP_OPS_DISABLE;
break;
}
pp_params.config_ops = MDP_OVERLAY_PP_IGC_CFG;
pp_params.igc_cfg.version = mdp_igc_v1_7;
pp_params.igc_cfg.cfg_payload = &igc_lut_data;
mdp_layer.pp_info = &pp_params;
mdp_layer.flags |= MDP_LAYER_PP;
}
DisplayError HWDevice::SetCursorPosition(HWLayers *hw_layers, int x, int y) {
DTRACE_SCOPED();
HWLayersInfo &hw_layer_info = hw_layers->info;
uint32_t count = hw_layer_info.count;
uint32_t cursor_index = count - 1;
HWPipeInfo *left_pipe = &hw_layers->config[cursor_index].left_pipe;
STRUCT_VAR(mdp_async_layer, async_layer);
async_layer.flags = MDP_LAYER_ASYNC;
async_layer.pipe_ndx = left_pipe->pipe_id;
async_layer.src.x = UINT32(left_pipe->src_roi.left);
async_layer.src.y = UINT32(left_pipe->src_roi.top);
async_layer.dst.x = UINT32(x);
async_layer.dst.y = UINT32(y);
STRUCT_VAR(mdp_position_update, pos_update);
pos_update.input_layer_cnt = 1;
pos_update.input_layers = &async_layer;
if (Sys::ioctl_(device_fd_, INT(MSMFB_ASYNC_POSITION_UPDATE), &pos_update) < 0) {
if (errno == ESHUTDOWN) {
DLOGI_IF(kTagDriverConfig, "Driver is processing shutdown sequence");
return kErrorShutDown;
}
IOCTL_LOGE(MSMFB_ASYNC_POSITION_UPDATE, device_type_);
return kErrorHardware;
}
return kErrorNone;
}
DisplayError HWDevice::GetPPFeaturesVersion(PPFeatureVersion *vers) {
return kErrorNotSupported;
}
DisplayError HWDevice::SetPPFeatures(PPFeaturesConfig *feature_list) {
return kErrorNotSupported;
}
DisplayError HWDevice::SetVSyncState(bool enable) {
return kErrorNotSupported;
}
void HWDevice::SetIdleTimeoutMs(uint32_t timeout_ms) {
}
DisplayError HWDevice::SetDisplayMode(const HWDisplayMode hw_display_mode) {
return kErrorNotSupported;
}
DisplayError HWDevice::SetRefreshRate(uint32_t refresh_rate) {
return kErrorNotSupported;
}
DisplayError HWDevice::SetPanelBrightness(int level) {
return kErrorNotSupported;
}
DisplayError HWDevice::GetHWScanInfo(HWScanInfo *scan_info) {
return kErrorNotSupported;
}
DisplayError HWDevice::GetVideoFormat(uint32_t config_index, uint32_t *video_format) {
return kErrorNotSupported;
}
DisplayError HWDevice::GetMaxCEAFormat(uint32_t *max_cea_format) {
return kErrorNotSupported;
}
DisplayError HWDevice::OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level) {
return kErrorNotSupported;
}
DisplayError HWDevice::GetPanelBrightness(int *level) {
return kErrorNotSupported;
}
ssize_t HWDevice::SysFsWrite(const char* file_node, const char* value, ssize_t length) {
int fd = Sys::open_(file_node, O_RDWR, 0);
if (fd < 0) {
DLOGW("Open failed = %s", file_node);
return -1;
}
ssize_t len = Sys::pwrite_(fd, value, static_cast<size_t>(length), 0);
if (len <= 0) {
DLOGE("Write failed for path %s with value %s", file_node, value);
}
Sys::close_(fd);
return len;
}
DisplayError HWDevice::SetS3DMode(HWS3DMode s3d_mode) {
return kErrorNotSupported;
}
} // namespace sdm