|
|
|
@ -27,6 +27,8 @@ |
|
|
|
|
#include <cutils/atomic.h> |
|
|
|
|
|
|
|
|
|
#include <EGL/egl.h> |
|
|
|
|
#include <sys/prctl.h> |
|
|
|
|
#include <fcntl.h> |
|
|
|
|
|
|
|
|
|
#include "SecHWCUtils.h" |
|
|
|
|
|
|
|
|
@ -63,7 +65,7 @@ static struct hw_module_methods_t hwc_module_methods = { |
|
|
|
|
hwc_module_t HAL_MODULE_INFO_SYM = { |
|
|
|
|
common: { |
|
|
|
|
tag: HARDWARE_MODULE_TAG, |
|
|
|
|
version_major: 1, |
|
|
|
|
version_major: 2, |
|
|
|
|
version_minor: 0, |
|
|
|
|
id: HWC_HARDWARE_MODULE_ID, |
|
|
|
|
name: "Samsung S5PC21X hwcomposer module", |
|
|
|
@ -74,8 +76,8 @@ hwc_module_t HAL_MODULE_INFO_SYM = { |
|
|
|
|
|
|
|
|
|
/*****************************************************************************/ |
|
|
|
|
|
|
|
|
|
static void dump_layer(hwc_layer_t const* l) { |
|
|
|
|
ALOGD("\ttype=%d, flags=%08x, handle=%p, tr=%02x, blend=%04x, " |
|
|
|
|
static void dump_layer(hwc_layer_1_t const* l) { |
|
|
|
|
SEC_HWC_Log(HWC_LOG_DEBUG,"\ttype=%d, flags=%08x, handle=%p, tr=%02x, blend=%04x, " |
|
|
|
|
"{%d,%d,%d,%d}, {%d,%d,%d,%d}", |
|
|
|
|
l->compositionType, l->flags, l->handle, l->transform, l->blending, |
|
|
|
|
l->sourceCrop.left, |
|
|
|
@ -88,7 +90,7 @@ static void dump_layer(hwc_layer_t const* l) { |
|
|
|
|
l->displayFrame.bottom); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void calculate_rect(struct hwc_win_info_t *win, hwc_layer_t *cur, |
|
|
|
|
void calculate_rect(struct hwc_win_info_t *win, hwc_layer_1_t *cur, |
|
|
|
|
sec_rect *rect) |
|
|
|
|
{ |
|
|
|
|
rect->x = cur->displayFrame.left; |
|
|
|
@ -118,7 +120,7 @@ void calculate_rect(struct hwc_win_info_t *win, hwc_layer_t *cur, |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static int set_src_dst_img_rect(hwc_layer_t *cur, |
|
|
|
|
static int set_src_dst_img_rect(hwc_layer_1_t *cur, |
|
|
|
|
struct hwc_win_info_t *win, |
|
|
|
|
struct sec_img *src_img, |
|
|
|
|
struct sec_img *dst_img, |
|
|
|
@ -194,62 +196,62 @@ static int set_src_dst_img_rect(hwc_layer_t *cur, |
|
|
|
|
src_rect->x = |
|
|
|
|
(0 - cur->displayFrame.left) |
|
|
|
|
*(src_img->w) |
|
|
|
|
/(cur->displayFrame.right - cur->displayFrame.left + 1); |
|
|
|
|
if (cur->displayFrame.right + 1 > win->lcd_info.xres) { |
|
|
|
|
/(cur->displayFrame.right - cur->displayFrame.left); |
|
|
|
|
if (cur->displayFrame.right > win->lcd_info.xres) { |
|
|
|
|
src_rect->w = |
|
|
|
|
(cur->sourceCrop.right - cur->sourceCrop.left + 1) - |
|
|
|
|
(cur->sourceCrop.right - cur->sourceCrop.left) - |
|
|
|
|
src_rect->x - |
|
|
|
|
(cur->displayFrame.right - win->lcd_info.xres) |
|
|
|
|
*(src_img->w) |
|
|
|
|
/(cur->displayFrame.right - cur->displayFrame.left + 1); |
|
|
|
|
/(cur->displayFrame.right - cur->displayFrame.left); |
|
|
|
|
} else { |
|
|
|
|
src_rect->w = |
|
|
|
|
(cur->sourceCrop.right - cur->sourceCrop.left + 1) - |
|
|
|
|
(cur->sourceCrop.right - cur->sourceCrop.left) - |
|
|
|
|
src_rect->x; |
|
|
|
|
} |
|
|
|
|
} else { |
|
|
|
|
src_rect->x = cur->sourceCrop.left; |
|
|
|
|
if (cur->displayFrame.right + 1 > win->lcd_info.xres) { |
|
|
|
|
if (cur->displayFrame.right > win->lcd_info.xres) { |
|
|
|
|
src_rect->w = |
|
|
|
|
(cur->sourceCrop.right - cur->sourceCrop.left + 1) - |
|
|
|
|
(cur->sourceCrop.right - cur->sourceCrop.left) - |
|
|
|
|
src_rect->x - |
|
|
|
|
(cur->displayFrame.right - win->lcd_info.xres) |
|
|
|
|
*(src_img->w) |
|
|
|
|
/(cur->displayFrame.right - cur->displayFrame.left + 1); |
|
|
|
|
/(cur->displayFrame.right - cur->displayFrame.left); |
|
|
|
|
} else { |
|
|
|
|
src_rect->w = |
|
|
|
|
(cur->sourceCrop.right - cur->sourceCrop.left + 1); |
|
|
|
|
(cur->sourceCrop.right - cur->sourceCrop.left); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
if (cur->displayFrame.top < 0) { |
|
|
|
|
src_rect->y = |
|
|
|
|
(0 - cur->displayFrame.top) |
|
|
|
|
*(src_img->h) |
|
|
|
|
/(cur->displayFrame.bottom - cur->displayFrame.top + 1); |
|
|
|
|
if (cur->displayFrame.bottom + 1 > win->lcd_info.yres) { |
|
|
|
|
/(cur->displayFrame.bottom - cur->displayFrame.top); |
|
|
|
|
if (cur->displayFrame.bottom > win->lcd_info.yres) { |
|
|
|
|
src_rect->h = |
|
|
|
|
(cur->sourceCrop.bottom - cur->sourceCrop.top + 1) - |
|
|
|
|
(cur->sourceCrop.bottom - cur->sourceCrop.top) - |
|
|
|
|
src_rect->y - |
|
|
|
|
(cur->displayFrame.bottom - win->lcd_info.yres) |
|
|
|
|
*(src_img->h) |
|
|
|
|
/(cur->displayFrame.bottom - cur->displayFrame.top + 1); |
|
|
|
|
/(cur->displayFrame.bottom - cur->displayFrame.top); |
|
|
|
|
} else { |
|
|
|
|
src_rect->h = |
|
|
|
|
(cur->sourceCrop.bottom - cur->sourceCrop.top + 1) - |
|
|
|
|
(cur->sourceCrop.bottom - cur->sourceCrop.top) - |
|
|
|
|
src_rect->y; |
|
|
|
|
} |
|
|
|
|
} else { |
|
|
|
|
src_rect->y = cur->sourceCrop.top; |
|
|
|
|
if (cur->displayFrame.bottom + 1 > win->lcd_info.yres) { |
|
|
|
|
if (cur->displayFrame.bottom > win->lcd_info.yres) { |
|
|
|
|
src_rect->h = |
|
|
|
|
(cur->sourceCrop.bottom - cur->sourceCrop.top + 1) - |
|
|
|
|
(cur->sourceCrop.bottom - cur->sourceCrop.top) - |
|
|
|
|
src_rect->y - |
|
|
|
|
(cur->displayFrame.bottom - win->lcd_info.yres) |
|
|
|
|
*(src_img->h) |
|
|
|
|
/(cur->displayFrame.bottom - cur->displayFrame.top + 1); |
|
|
|
|
/(cur->displayFrame.bottom - cur->displayFrame.top); |
|
|
|
|
} else { |
|
|
|
|
src_rect->h = |
|
|
|
|
(cur->sourceCrop.bottom - cur->sourceCrop.top + 1); |
|
|
|
|
(cur->sourceCrop.bottom - cur->sourceCrop.top); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
@ -301,7 +303,7 @@ static int set_src_dst_img_rect(hwc_layer_t *cur, |
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static int get_hwc_compos_decision(hwc_layer_t* cur, int iter, int win_cnt) |
|
|
|
|
static int get_hwc_compos_decision(hwc_layer_1_t* cur, int iter, int win_cnt) |
|
|
|
|
{ |
|
|
|
|
if(cur->flags & HWC_SKIP_LAYER || !cur->handle) { |
|
|
|
|
SEC_HWC_Log(HWC_LOG_DEBUG, "%s::is_skip_layer %d cur->handle %x ", |
|
|
|
@ -351,36 +353,6 @@ static int get_hwc_compos_decision(hwc_layer_t* cur, int iter, int win_cnt) |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#ifdef SUB_TITLES_HWC |
|
|
|
|
else if ((win_cnt > 0) && |
|
|
|
|
(prev_handle->usage & GRALLOC_USAGE_EXTERNAL_DISP)) { |
|
|
|
|
switch (prev_handle->format) { |
|
|
|
|
case HAL_PIXEL_FORMAT_RGBA_8888: |
|
|
|
|
case HAL_PIXEL_FORMAT_RGBX_8888: |
|
|
|
|
case HAL_PIXEL_FORMAT_BGRA_8888: |
|
|
|
|
case HAL_PIXEL_FORMAT_RGB_888: |
|
|
|
|
case HAL_PIXEL_FORMAT_RGB_565: |
|
|
|
|
case HAL_PIXEL_FORMAT_RGBA_5551: |
|
|
|
|
case HAL_PIXEL_FORMAT_RGBA_4444: |
|
|
|
|
compositionType = HWC_OVERLAY; |
|
|
|
|
break; |
|
|
|
|
default: |
|
|
|
|
compositionType = HWC_FRAMEBUFFER; |
|
|
|
|
break; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
SEC_HWC_Log(HWC_LOG_DEBUG, "2nd iter###%s:: compositionType %d bpp %d" |
|
|
|
|
" format %x src[%d %d %d %d] dst[%d %d %d %d] srcImg[%d %d]", |
|
|
|
|
__func__, compositionType, prev_handle->bpp, |
|
|
|
|
prev_handle->format, |
|
|
|
|
cur->sourceCrop.left, cur->sourceCrop.right, |
|
|
|
|
cur->sourceCrop.top, cur->sourceCrop.bottom, |
|
|
|
|
cur->displayFrame.left, cur->displayFrame.right, |
|
|
|
|
cur->displayFrame.top, cur->displayFrame.bottom, |
|
|
|
|
prev_handle->width, prev_handle->height); |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
SEC_HWC_Log(HWC_LOG_DEBUG, |
|
|
|
|
"%s::compositionType(%d)=>0:FB,1:OVERLAY \r\n" |
|
|
|
|
" format(0x%x),magic(0x%x),flags(%d),size(%d),offset(%d)" |
|
|
|
@ -404,7 +376,7 @@ static void reset_win_rect_info(hwc_win_info_t *win) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int assign_overlay_window(struct hwc_context_t *ctx, hwc_layer_t *cur, |
|
|
|
|
static int assign_overlay_window(struct hwc_context_t *ctx, hwc_layer_1_t *cur, |
|
|
|
|
int win_idx, int layer_idx) |
|
|
|
|
{ |
|
|
|
|
struct hwc_win_info_t *win; |
|
|
|
@ -453,15 +425,139 @@ static int assign_overlay_window(struct hwc_context_t *ctx, hwc_layer_t *cur, |
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static int hwc_prepare(hwc_composer_device_t *dev, hwc_layer_list_t* list) |
|
|
|
|
#ifdef SKIP_DUMMY_UI_LAY_DRAWING |
|
|
|
|
static void get_hwc_ui_lay_skipdraw_decision(struct hwc_context_t* ctx, |
|
|
|
|
hwc_display_contents_1_t* list) |
|
|
|
|
{ |
|
|
|
|
struct hwc_context_t* ctx = (struct hwc_context_t*)dev; |
|
|
|
|
int overlay_win_cnt = 0; |
|
|
|
|
int compositionType = 0; |
|
|
|
|
int ret; |
|
|
|
|
private_handle_t *prev_handle; |
|
|
|
|
hwc_layer_1_t* cur; |
|
|
|
|
int num_of_fb_lay_skip = 0; |
|
|
|
|
int fb_lay_tot = ctx->num_of_fb_layer + ctx->num_of_fb_lay_skip; |
|
|
|
|
|
|
|
|
|
if (fb_lay_tot > NUM_OF_DUMMY_WIN) |
|
|
|
|
return; |
|
|
|
|
|
|
|
|
|
if (fb_lay_tot < 1) { |
|
|
|
|
#ifdef GL_WA_OVLY_ALL |
|
|
|
|
ctx->ui_skip_frame_cnt++; |
|
|
|
|
if (ctx->ui_skip_frame_cnt >= THRES_FOR_SWAP) { |
|
|
|
|
ctx->ui_skip_frame_cnt = 0; |
|
|
|
|
ctx->num_of_fb_layer_prev = 1; |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
return; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (ctx->fb_lay_skip_initialized) { |
|
|
|
|
for (int cnt = 0; cnt < fb_lay_tot; cnt++) { |
|
|
|
|
cur = &list->hwLayers[ctx->win_virt[cnt].layer_index]; |
|
|
|
|
if (ctx->win_virt[cnt].layer_prev_buf == (uint32_t)cur->handle) |
|
|
|
|
num_of_fb_lay_skip++; |
|
|
|
|
} |
|
|
|
|
#ifdef GL_WA_OVLY_ALL |
|
|
|
|
if (ctx->ui_skip_frame_cnt >= THRES_FOR_SWAP) |
|
|
|
|
num_of_fb_lay_skip = 0; |
|
|
|
|
#endif |
|
|
|
|
if (num_of_fb_lay_skip != fb_lay_tot) { |
|
|
|
|
ctx->num_of_fb_layer = fb_lay_tot; |
|
|
|
|
ctx->num_of_fb_lay_skip = 0; |
|
|
|
|
#ifdef GL_WA_OVLY_ALL |
|
|
|
|
ctx->ui_skip_frame_cnt = 0; |
|
|
|
|
#endif |
|
|
|
|
for (int cnt = 0; cnt < fb_lay_tot; cnt++) { |
|
|
|
|
cur = &list->hwLayers[ctx->win_virt[cnt].layer_index]; |
|
|
|
|
ctx->win_virt[cnt].layer_prev_buf = (uint32_t)cur->handle; |
|
|
|
|
cur->compositionType = HWC_FRAMEBUFFER; |
|
|
|
|
ctx->win_virt[cnt].status = HWC_WIN_FREE; |
|
|
|
|
} |
|
|
|
|
} else { |
|
|
|
|
ctx->num_of_fb_layer = 0; |
|
|
|
|
ctx->num_of_fb_lay_skip = fb_lay_tot; |
|
|
|
|
#ifdef GL_WA_OVLY_ALL |
|
|
|
|
ctx->ui_skip_frame_cnt++; |
|
|
|
|
#endif |
|
|
|
|
for (int cnt = 0; cnt < fb_lay_tot; cnt++) { |
|
|
|
|
cur = &list->hwLayers[ctx->win_virt[cnt].layer_index]; |
|
|
|
|
cur->compositionType = HWC_OVERLAY; |
|
|
|
|
ctx->win_virt[cnt].status = HWC_WIN_RESERVED; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} else { |
|
|
|
|
ctx->num_of_fb_lay_skip = 0; |
|
|
|
|
for (int i = 0; i < list->numHwLayers ; i++) { |
|
|
|
|
if(num_of_fb_lay_skip >= NUM_OF_DUMMY_WIN) |
|
|
|
|
break; |
|
|
|
|
|
|
|
|
|
cur = &list->hwLayers[i]; |
|
|
|
|
if (cur->handle) { |
|
|
|
|
prev_handle = (private_handle_t *)(cur->handle); |
|
|
|
|
|
|
|
|
|
switch (prev_handle->format) { |
|
|
|
|
case HAL_PIXEL_FORMAT_RGBA_8888: |
|
|
|
|
case HAL_PIXEL_FORMAT_BGRA_8888: |
|
|
|
|
case HAL_PIXEL_FORMAT_RGBX_8888: |
|
|
|
|
case HAL_PIXEL_FORMAT_RGB_565: |
|
|
|
|
cur->compositionType = HWC_FRAMEBUFFER; |
|
|
|
|
ctx->win_virt[num_of_fb_lay_skip].layer_prev_buf = |
|
|
|
|
(uint32_t)cur->handle; |
|
|
|
|
ctx->win_virt[num_of_fb_lay_skip].layer_index = i; |
|
|
|
|
ctx->win_virt[num_of_fb_lay_skip].status = HWC_WIN_FREE; |
|
|
|
|
num_of_fb_lay_skip++; |
|
|
|
|
break; |
|
|
|
|
default: |
|
|
|
|
break; |
|
|
|
|
} |
|
|
|
|
} else { |
|
|
|
|
cur->compositionType = HWC_FRAMEBUFFER; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (num_of_fb_lay_skip == fb_lay_tot) |
|
|
|
|
ctx->fb_lay_skip_initialized = 1; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
//if geometry is not changed, there is no need to do any work here
|
|
|
|
|
if (!list || (!(list->flags & HWC_GEOMETRY_CHANGED))) |
|
|
|
|
return; |
|
|
|
|
|
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
static int hwc_prepare(hwc_composer_device_1_t *dev, size_t numDisplays, hwc_display_contents_1_t** displays) |
|
|
|
|
{ |
|
|
|
|
|
|
|
|
|
for (uint32_t i = 0; i < numDisplays; i++) { |
|
|
|
|
hwc_display_contents_1_t *list = displays[i];
|
|
|
|
|
struct hwc_context_t* ctx = (struct hwc_context_t*)dev; |
|
|
|
|
int overlay_win_cnt = 0; |
|
|
|
|
int compositionType = 0; |
|
|
|
|
int ret; |
|
|
|
|
#if defined(BOARD_USES_HDMI) |
|
|
|
|
android::SecHdmiClient *mHdmiClient = android::SecHdmiClient::getInstance(); |
|
|
|
|
int hdmi_cable_status = (int)mHdmiClient->getHdmiCableStatus(); |
|
|
|
|
|
|
|
|
|
ctx->hdmi_cable_status = hdmi_cable_status; |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
#ifdef SKIP_DUMMY_UI_LAY_DRAWING |
|
|
|
|
if ((list && (!(list->flags & HWC_GEOMETRY_CHANGED))) && |
|
|
|
|
(ctx->num_of_hwc_layer > 0)) { |
|
|
|
|
get_hwc_ui_lay_skipdraw_decision(ctx, list); |
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
ctx->fb_lay_skip_initialized = 0; |
|
|
|
|
ctx->num_of_fb_lay_skip = 0; |
|
|
|
|
#ifdef GL_WA_OVLY_ALL |
|
|
|
|
ctx->ui_skip_frame_cnt = 0; |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
for (int i = 0; i < NUM_OF_DUMMY_WIN; i++) { |
|
|
|
|
ctx->win_virt[i].layer_prev_buf = 0; |
|
|
|
|
ctx->win_virt[i].layer_index = -1; |
|
|
|
|
ctx->win_virt[i].status = HWC_WIN_FREE; |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
//if geometry is not changed, there is no need to do any work here
|
|
|
|
|
if (!list || (!(list->flags & HWC_GEOMETRY_CHANGED))) |
|
|
|
|
return 0; |
|
|
|
|
|
|
|
|
|
//all the windows are free here....
|
|
|
|
@ -473,9 +569,27 @@ static int hwc_prepare(hwc_composer_device_t *dev, hwc_layer_list_t* list) |
|
|
|
|
ctx->num_of_hwc_layer = 0; |
|
|
|
|
ctx->num_of_fb_layer = 0; |
|
|
|
|
ctx->num_2d_blit_layer = 0; |
|
|
|
|
ctx->num_of_ext_disp_video_layer = 0; |
|
|
|
|
|
|
|
|
|
for (int i = 0; i < list->numHwLayers; i++) { |
|
|
|
|
hwc_layer_1_t *cur = &list->hwLayers[i]; |
|
|
|
|
private_handle_t *prev_handle = NULL; |
|
|
|
|
if (cur->handle) { |
|
|
|
|
prev_handle = (private_handle_t *)(cur->handle); |
|
|
|
|
SEC_HWC_Log(HWC_LOG_DEBUG, "prev_handle->usage = %d", prev_handle->usage); |
|
|
|
|
if (prev_handle->usage & GRALLOC_USAGE_EXTERNAL_DISP) { |
|
|
|
|
ctx->num_of_ext_disp_layer++; |
|
|
|
|
if ((prev_handle->usage & GRALLOC_USAGE_EXTERNAL_DISP) || |
|
|
|
|
check_yuv_format((unsigned int)prev_handle->format) == 1) { |
|
|
|
|
ctx->num_of_ext_disp_video_layer++; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
for (int i = 0; i < list->numHwLayers ; i++) { |
|
|
|
|
hwc_layer_t* cur = &list->hwLayers[i]; |
|
|
|
|
hwc_layer_1_t* cur = &list->hwLayers[i]; |
|
|
|
|
private_handle_t *prev_handle = (private_handle_t *)(cur->handle); |
|
|
|
|
|
|
|
|
|
if (overlay_win_cnt < NUM_OF_WIN) { |
|
|
|
|
compositionType = get_hwc_compos_decision(cur, 0, overlay_win_cnt); |
|
|
|
@ -486,7 +600,7 @@ static int hwc_prepare(hwc_composer_device_t *dev, hwc_layer_list_t* list) |
|
|
|
|
} else { |
|
|
|
|
ret = assign_overlay_window(ctx, cur, overlay_win_cnt, i); |
|
|
|
|
if (ret != 0) { |
|
|
|
|
ALOGE("assign_overlay_window fail, change to frambuffer"); |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "assign_overlay_window fail, change to frambuffer"); |
|
|
|
|
cur->compositionType = HWC_FRAMEBUFFER; |
|
|
|
|
ctx->num_of_fb_layer++; |
|
|
|
|
continue; |
|
|
|
@ -501,32 +615,29 @@ static int hwc_prepare(hwc_composer_device_t *dev, hwc_layer_list_t* list) |
|
|
|
|
cur->compositionType = HWC_FRAMEBUFFER; |
|
|
|
|
ctx->num_of_fb_layer++; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#ifdef SUB_TITLES_HWC |
|
|
|
|
for (int i = 0; i < list->numHwLayers ; i++) { |
|
|
|
|
if (overlay_win_cnt < NUM_OF_WIN) { |
|
|
|
|
hwc_layer_t* cur = &list->hwLayers[i]; |
|
|
|
|
if (get_hwc_compos_decision(cur, 1, overlay_win_cnt) == HWC_OVERLAY) { |
|
|
|
|
ret = assign_overlay_window(ctx, cur, overlay_win_cnt, i); |
|
|
|
|
if (ret == 0) { |
|
|
|
|
cur->compositionType = HWC_OVERLAY; |
|
|
|
|
cur->hints = HWC_HINT_CLEAR_FB; |
|
|
|
|
overlay_win_cnt++; |
|
|
|
|
ctx->num_of_hwc_layer++; |
|
|
|
|
ctx->num_of_fb_layer--; |
|
|
|
|
ctx->num_2d_blit_layer = 1; |
|
|
|
|
} |
|
|
|
|
#if defined(BOARD_USES_HDMI) |
|
|
|
|
SEC_HWC_Log(HWC_LOG_DEBUG, "ext disp vid = %d, cable status = %d, composition type = %d", |
|
|
|
|
ctx->num_of_ext_disp_video_layer, ctx->hdmi_cable_status, compositionType); |
|
|
|
|
if (ctx->num_of_ext_disp_video_layer >= 2) { |
|
|
|
|
if ((ctx->hdmi_cable_status) && |
|
|
|
|
(compositionType == HWC_OVERLAY) && |
|
|
|
|
(prev_handle->usage & GRALLOC_USAGE_EXTERNAL_DISP)) { |
|
|
|
|
cur->compositionType = HWC_FRAMEBUFFER; |
|
|
|
|
ctx->num_of_hwc_layer--; |
|
|
|
|
overlay_win_cnt--; |
|
|
|
|
ctx->num_of_fb_layer++; |
|
|
|
|
cur->hints = 0; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
break; |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#if defined(BOARD_USES_HDMI) |
|
|
|
|
android::SecHdmiClient *mHdmiClient = android::SecHdmiClient::getInstance(); |
|
|
|
|
mHdmiClient = android::SecHdmiClient::getInstance(); |
|
|
|
|
mHdmiClient->setHdmiHwcLayer(ctx->num_of_hwc_layer); |
|
|
|
|
if (ctx->num_of_ext_disp_video_layer > 1) { |
|
|
|
|
mHdmiClient->setExtDispLayerNum(0); |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
if (list->numHwLayers != (ctx->num_of_fb_layer + ctx->num_of_hwc_layer)) |
|
|
|
@ -542,27 +653,27 @@ static int hwc_prepare(hwc_composer_device_t *dev, hwc_layer_list_t* list) |
|
|
|
|
reset_win_rect_info(&ctx->win[i]); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
} |
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static int hwc_set(hwc_composer_device_t *dev, |
|
|
|
|
hwc_display_t dpy, |
|
|
|
|
hwc_surface_t sur, |
|
|
|
|
hwc_layer_list_t* list) |
|
|
|
|
static int hwc_set(hwc_composer_device_1_t *dev, |
|
|
|
|
size_t numDisplays, |
|
|
|
|
hwc_display_contents_1_t** displays) |
|
|
|
|
{ |
|
|
|
|
struct hwc_context_t *ctx = (struct hwc_context_t *)dev; |
|
|
|
|
int skipped_window_mask = 0; |
|
|
|
|
hwc_layer_t* cur; |
|
|
|
|
hwc_layer_1_t* cur; |
|
|
|
|
struct hwc_win_info_t *win; |
|
|
|
|
int ret; |
|
|
|
|
int pmem_phyaddr; |
|
|
|
|
static int egl_check; |
|
|
|
|
int egl_run = 0; |
|
|
|
|
struct sec_img src_img; |
|
|
|
|
struct sec_img dst_img; |
|
|
|
|
struct sec_rect src_work_rect; |
|
|
|
|
struct sec_rect dst_work_rect; |
|
|
|
|
bool need_swap_buffers = ctx->num_of_fb_layer > 0; |
|
|
|
|
for (uint32_t i = 0; i < numDisplays; i++) { |
|
|
|
|
hwc_display_contents_1_t* list = displays[i];
|
|
|
|
|
|
|
|
|
|
memset(&src_img, 0, sizeof(src_img)); |
|
|
|
|
memset(&dst_img, 0, sizeof(dst_img)); |
|
|
|
@ -582,14 +693,45 @@ static int hwc_set(hwc_composer_device_t *dev, |
|
|
|
|
ctx->win[i].status = HWC_WIN_FREE; |
|
|
|
|
} |
|
|
|
|
ctx->num_of_hwc_layer = 0; |
|
|
|
|
need_swap_buffers = true; |
|
|
|
|
|
|
|
|
|
if (sur == NULL && dpy == NULL) |
|
|
|
|
if (list->sur == NULL && list->dpy == NULL) { |
|
|
|
|
#ifdef SKIP_DUMMY_UI_LAY_DRAWING |
|
|
|
|
ctx->fb_lay_skip_initialized = 0; |
|
|
|
|
#endif |
|
|
|
|
return HWC_EGL_ERROR; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if(ctx->num_of_hwc_layer > NUM_OF_WIN) |
|
|
|
|
ctx->num_of_hwc_layer = NUM_OF_WIN; |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* H/W composer documentation states: |
|
|
|
|
* There is an implicit layer containing opaque black |
|
|
|
|
* pixels behind all the layers in the list. |
|
|
|
|
* It is the responsibility of the hwcomposer module to make |
|
|
|
|
* sure black pixels are output (or blended from). |
|
|
|
|
* |
|
|
|
|
* Since we're using a blitter, we need to erase the frame-buffer when |
|
|
|
|
* switching to all-overlay mode. |
|
|
|
|
* |
|
|
|
|
*/ |
|
|
|
|
if (ctx->num_of_hwc_layer && |
|
|
|
|
ctx->num_of_fb_layer==0 && ctx->num_of_fb_layer_prev) { |
|
|
|
|
#ifdef SKIP_DUMMY_UI_LAY_DRAWING |
|
|
|
|
if (ctx->num_of_fb_lay_skip == 0) |
|
|
|
|
#endif |
|
|
|
|
{ |
|
|
|
|
glDisable(GL_SCISSOR_TEST); |
|
|
|
|
glClearColor(0, 0, 0, 0); |
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT); |
|
|
|
|
glEnable(GL_SCISSOR_TEST); |
|
|
|
|
need_swap_buffers = true; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
ctx->num_of_fb_layer_prev = ctx->num_of_fb_layer; |
|
|
|
|
|
|
|
|
|
//compose hardware layers here
|
|
|
|
|
for (int i = 0; i < ctx->num_of_hwc_layer - ctx->num_2d_blit_layer; i++) { |
|
|
|
|
win = &ctx->win[i]; |
|
|
|
@ -603,7 +745,7 @@ static int hwc_set(hwc_composer_device_t *dev, |
|
|
|
|
* double buffered (2 or more) this buffer is already rendered. |
|
|
|
|
* It is the redundant src buffer for FIMC rendering. |
|
|
|
|
*/ |
|
|
|
|
ALOGD("SKIP FIMC rendering for Layer%d", win->layer_index); |
|
|
|
|
|
|
|
|
|
#if defined(BOARD_USES_HDMI) |
|
|
|
|
skip_hdmi_rendering = 1; |
|
|
|
|
#endif |
|
|
|
@ -646,33 +788,6 @@ static int hwc_set(hwc_composer_device_t *dev, |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#ifdef SUB_TITLES_HWC |
|
|
|
|
if (ctx->num_2d_blit_layer) { |
|
|
|
|
g2d_rect srcRect; |
|
|
|
|
g2d_rect dstRect; |
|
|
|
|
|
|
|
|
|
win = &ctx->win[ctx->num_of_hwc_layer - 1]; |
|
|
|
|
cur = &list->hwLayers[win->layer_index]; |
|
|
|
|
set_src_dst_g2d_rect(cur, win, &srcRect, &dstRect); |
|
|
|
|
ret = runG2d(ctx, &srcRect, &dstRect, |
|
|
|
|
cur->transform); |
|
|
|
|
if (ret < 0) { |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::runG2d fail : ret=%d\n", |
|
|
|
|
__func__, ret); |
|
|
|
|
skipped_window_mask |= (1 << (ctx->num_of_hwc_layer - 1)); |
|
|
|
|
goto g2d_error; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
window_pan_display(win); |
|
|
|
|
|
|
|
|
|
win->buf_index = (win->buf_index + 1) % NUM_OF_WIN_BUF; |
|
|
|
|
if (win->power_state == 0) |
|
|
|
|
window_show(win); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
g2d_error: |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
if (skipped_window_mask) { |
|
|
|
|
//turn off the free windows
|
|
|
|
|
for (int i = 0; i < NUM_OF_WIN; i++) { |
|
|
|
@ -683,7 +798,7 @@ g2d_error: |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (0 < ctx->num_of_fb_layer) { |
|
|
|
|
if (need_swap_buffers) { |
|
|
|
|
#ifdef CHECK_EGL_FPS |
|
|
|
|
check_fps(); |
|
|
|
|
#endif |
|
|
|
@ -691,17 +806,7 @@ g2d_error: |
|
|
|
|
unsigned char pixels[4]; |
|
|
|
|
glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, pixels); |
|
|
|
|
#endif |
|
|
|
|
egl_check = 1; |
|
|
|
|
egl_run = 1; |
|
|
|
|
} else { |
|
|
|
|
if (egl_check == 1) { |
|
|
|
|
egl_check = 0; |
|
|
|
|
egl_run = 1; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (egl_run == 1) { |
|
|
|
|
EGLBoolean sucess = eglSwapBuffers((EGLDisplay)dpy, (EGLSurface)sur); |
|
|
|
|
EGLBoolean sucess = eglSwapBuffers((EGLDisplay)list->dpy, (EGLSurface)list->sur); |
|
|
|
|
if (!sucess) |
|
|
|
|
return HWC_EGL_ERROR; |
|
|
|
|
} |
|
|
|
@ -732,14 +837,14 @@ g2d_error: |
|
|
|
|
// To support S3D video playback (automatic TV mode change to 3D mode)
|
|
|
|
|
if (ctx->num_of_hwc_layer == 1) { |
|
|
|
|
if (src_img.usage != prev_usage) |
|
|
|
|
mHdmiClient->setHdmiResolution(DEFAULT_HDMI_RESOLUTION_VALUE); // V4L2_STD_1080P_60
|
|
|
|
|
mHdmiClient->setHdmiResolution(DEFAULT_HDMI_RESOLUTION_VALUE, android::SecHdmiClient::HDMI_2D); // V4L2_STD_1080P_60
|
|
|
|
|
|
|
|
|
|
if ((src_img.usage & GRALLOC_USAGE_PRIVATE_SBS_LR) || |
|
|
|
|
(src_img.usage & GRALLOC_USAGE_PRIVATE_SBS_RL)) |
|
|
|
|
mHdmiClient->setHdmiResolution(7209601); // V4L2_STD_TVOUT_720P_60_SBS_HALF
|
|
|
|
|
mHdmiClient->setHdmiResolution(DEFAULT_HDMI_S3D_SBS_RESOLUTION_VALUE, android::SecHdmiClient::HDMI_S3D_SBS); // V4L2_STD_TVOUT_720P_60_SBS_HALF
|
|
|
|
|
else if ((src_img.usage & GRALLOC_USAGE_PRIVATE_TB_LR) || |
|
|
|
|
(src_img.usage & GRALLOC_USAGE_PRIVATE_TB_RL)) |
|
|
|
|
mHdmiClient->setHdmiResolution(1080924); // V4L2_STD_TVOUT_1080P_24_TB
|
|
|
|
|
mHdmiClient->setHdmiResolution(DEFAULT_HDMI_S3D_TB_RESOLUTION_VALUE, android::SecHdmiClient::HDMI_S3D_TB); // V4L2_STD_TVOUT_1080P_24_TB
|
|
|
|
|
|
|
|
|
|
prev_usage = src_img.usage; |
|
|
|
|
} else { |
|
|
|
@ -747,7 +852,7 @@ g2d_error: |
|
|
|
|
(prev_usage & GRALLOC_USAGE_PRIVATE_SBS_RL) || |
|
|
|
|
(prev_usage & GRALLOC_USAGE_PRIVATE_TB_LR) || |
|
|
|
|
(prev_usage & GRALLOC_USAGE_PRIVATE_TB_RL)) |
|
|
|
|
mHdmiClient->setHdmiResolution(DEFAULT_HDMI_RESOLUTION_VALUE); // V4L2_STD_1080P_60
|
|
|
|
|
mHdmiClient->setHdmiResolution(DEFAULT_HDMI_RESOLUTION_VALUE, android::SecHdmiClient::HDMI_2D); // V4L2_STD_1080P_60
|
|
|
|
|
|
|
|
|
|
prev_usage = 0; |
|
|
|
|
} |
|
|
|
@ -756,8 +861,7 @@ g2d_error: |
|
|
|
|
if ((src_img.format == HAL_PIXEL_FORMAT_CUSTOM_YCbCr_420_SP_TILED)|| |
|
|
|
|
(src_img.format == HAL_PIXEL_FORMAT_CUSTOM_YCrCb_420_SP)) { |
|
|
|
|
ADDRS * addr = (ADDRS *)(src_img.base); |
|
|
|
|
|
|
|
|
|
mHdmiClient->blit2Hdmi(src_img.w, src_img.h, |
|
|
|
|
mHdmiClient->blit2Hdmi(src_work_rect.w, src_work_rect.h, |
|
|
|
|
src_img.format, |
|
|
|
|
(unsigned int)addr->addr_y, (unsigned int)addr->addr_cbcr, (unsigned int)addr->addr_cbcr, |
|
|
|
|
0, 0, |
|
|
|
@ -767,7 +871,7 @@ g2d_error: |
|
|
|
|
(src_img.format == HAL_PIXEL_FORMAT_YCrCb_420_SP) || |
|
|
|
|
(src_img.format == HAL_PIXEL_FORMAT_YCbCr_420_P) || |
|
|
|
|
(src_img.format == HAL_PIXEL_FORMAT_YV12)) { |
|
|
|
|
mHdmiClient->blit2Hdmi(src_img.w, src_img.h, |
|
|
|
|
mHdmiClient->blit2Hdmi(src_work_rect.w, src_work_rect.h, |
|
|
|
|
src_img.format, |
|
|
|
|
(unsigned int)ctx->fimc.params.src.buf_addr_phy_rgb_y, |
|
|
|
|
(unsigned int)ctx->fimc.params.src.buf_addr_phy_cb, |
|
|
|
@ -776,13 +880,90 @@ g2d_error: |
|
|
|
|
android::SecHdmiClient::HDMI_MODE_VIDEO, |
|
|
|
|
ctx->num_of_hwc_layer); |
|
|
|
|
} else { |
|
|
|
|
ALOGE("%s: Unsupported format = %d", __func__, src_img.format); |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s: Unsupported format = %d", __func__, src_img.format); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
} |
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static void hwc_registerProcs(struct hwc_composer_device_1* dev, |
|
|
|
|
hwc_procs_t const* procs) |
|
|
|
|
{ |
|
|
|
|
struct hwc_context_t* ctx = (struct hwc_context_t*)dev; |
|
|
|
|
ctx->procs = const_cast<hwc_procs_t *>(procs); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static int hwc_query(struct hwc_composer_device_1* dev, |
|
|
|
|
int what, int* value) |
|
|
|
|
{ |
|
|
|
|
struct hwc_context_t* ctx = (struct hwc_context_t*)dev; |
|
|
|
|
|
|
|
|
|
switch (what) { |
|
|
|
|
case HWC_BACKGROUND_LAYER_SUPPORTED: |
|
|
|
|
// we don't support the background layer yet
|
|
|
|
|
value[0] = 0; |
|
|
|
|
break; |
|
|
|
|
case HWC_VSYNC_PERIOD: |
|
|
|
|
// vsync period in nanosecond
|
|
|
|
|
value[0] = 1000000000.0 / 57; |
|
|
|
|
break; |
|
|
|
|
default: |
|
|
|
|
// unsupported query
|
|
|
|
|
return -EINVAL; |
|
|
|
|
} |
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static int hwc_eventControl(struct hwc_composer_device_1* dev, int dpy, |
|
|
|
|
int event, int enabled) |
|
|
|
|
{ |
|
|
|
|
struct hwc_context_t* ctx = (struct hwc_context_t*)dev; |
|
|
|
|
|
|
|
|
|
switch (event) { |
|
|
|
|
case HWC_EVENT_VSYNC: |
|
|
|
|
int val = !!enabled; |
|
|
|
|
int err = ioctl(ctx->win[0].fd, S3CFB_SET_VSYNC_INT, &val); |
|
|
|
|
if (err < 0) |
|
|
|
|
return -errno; |
|
|
|
|
|
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
return -EINVAL; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void *hwc_vsync_sysfs_loop(void *data) |
|
|
|
|
{ |
|
|
|
|
static char buf[4096]; |
|
|
|
|
int vsync_timestamp_fd; |
|
|
|
|
fd_set exceptfds; |
|
|
|
|
int res; |
|
|
|
|
int64_t timestamp = 0; |
|
|
|
|
hwc_context_t * ctx = (hwc_context_t *)(data); |
|
|
|
|
|
|
|
|
|
vsync_timestamp_fd = open("/sys/devices/platform/samsung-pd.2/s3cfb.0/vsync_time", O_RDONLY); |
|
|
|
|
char thread_name[64] = "hwcVsyncThread"; |
|
|
|
|
prctl(PR_SET_NAME, (unsigned long) &thread_name, 0, 0, 0); |
|
|
|
|
setpriority(PRIO_PROCESS, 0, -20); |
|
|
|
|
memset(buf, 0, sizeof(buf)); |
|
|
|
|
|
|
|
|
|
SEC_HWC_Log(HWC_LOG_DEBUG,"Using sysfs mechanism for VSYNC notification"); |
|
|
|
|
|
|
|
|
|
FD_ZERO(&exceptfds); |
|
|
|
|
FD_SET(vsync_timestamp_fd, &exceptfds); |
|
|
|
|
do { |
|
|
|
|
ssize_t len = read(vsync_timestamp_fd, buf, sizeof(buf)); |
|
|
|
|
timestamp = strtoull(buf, NULL, 0); |
|
|
|
|
ctx->procs->vsync(ctx->procs, 0, timestamp); |
|
|
|
|
select(vsync_timestamp_fd + 1, NULL, NULL, &exceptfds, NULL); |
|
|
|
|
lseek(vsync_timestamp_fd, 0, SEEK_SET); |
|
|
|
|
} while (1); |
|
|
|
|
|
|
|
|
|
return NULL; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static int hwc_device_close(struct hw_device_t *dev) |
|
|
|
|
{ |
|
|
|
|
struct hwc_context_t* ctx = (struct hwc_context_t*)dev; |
|
|
|
@ -793,23 +974,7 @@ static int hwc_device_close(struct hw_device_t *dev) |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyFimc fail", __func__); |
|
|
|
|
ret = -1; |
|
|
|
|
} |
|
|
|
|
#ifdef SUB_TITLES_HWC |
|
|
|
|
if (destroyG2d(&ctx->g2d) < 0) { |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyG2d() fail", __func__); |
|
|
|
|
ret = -1; |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
if (destroyMem(&ctx->s3c_mem) < 0) { |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyMem fail", __func__); |
|
|
|
|
ret = -1; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#ifdef USE_HW_PMEM |
|
|
|
|
if (destroyPmem(&ctx->sec_pmem) < 0) { |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyPmem fail", __func__); |
|
|
|
|
ret = -1; |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
for (i = 0; i < NUM_OF_WIN; i++) { |
|
|
|
|
if (window_close(&ctx->win[i]) < 0) |
|
|
|
|
SEC_HWC_Log(HWC_LOG_DEBUG, "%s::window_close() fail", __func__); |
|
|
|
@ -819,11 +984,17 @@ static int hwc_device_close(struct hw_device_t *dev) |
|
|
|
|
} |
|
|
|
|
return ret; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
static int hwc_blank(struct hwc_composer_device_1 *dev, int dpy, int blank) |
|
|
|
|
{ |
|
|
|
|
// We're using an older method of screen blanking based on
|
|
|
|
|
// early_suspend in the kernel. No need to do anything here.
|
|
|
|
|
return 0; |
|
|
|
|
}
|
|
|
|
|
static int hwc_device_open(const struct hw_module_t* module, const char* name, |
|
|
|
|
struct hw_device_t** device) |
|
|
|
|
{ |
|
|
|
|
int status = 0; |
|
|
|
|
int err = 0; |
|
|
|
|
struct hwc_win_info_t *win; |
|
|
|
|
|
|
|
|
|
if (strcmp(name, HWC_HARDWARE_COMPOSER)) |
|
|
|
@ -836,22 +1007,21 @@ static int hwc_device_open(const struct hw_module_t* module, const char* name, |
|
|
|
|
memset(dev, 0, sizeof(*dev)); |
|
|
|
|
|
|
|
|
|
/* initialize the procs */ |
|
|
|
|
dev->device.common.tag = HARDWARE_DEVICE_TAG; |
|
|
|
|
dev->device.common.version = 0; |
|
|
|
|
dev->device.common.module = const_cast<hw_module_t*>(module); |
|
|
|
|
dev->device.common.close = hwc_device_close; |
|
|
|
|
|
|
|
|
|
dev->device.prepare = hwc_prepare; |
|
|
|
|
dev->device.set = hwc_set; |
|
|
|
|
|
|
|
|
|
dev->device.common.tag = HARDWARE_DEVICE_TAG; |
|
|
|
|
dev->device.common.version = HWC_DEVICE_API_VERSION_1_0; |
|
|
|
|
dev->device.common.module = const_cast<hw_module_t*>(module); |
|
|
|
|
dev->device.common.close = hwc_device_close; |
|
|
|
|
dev->device.prepare = hwc_prepare; |
|
|
|
|
dev->device.set = hwc_set; |
|
|
|
|
dev->device.eventControl = hwc_eventControl; |
|
|
|
|
dev->device.blank = hwc_blank; |
|
|
|
|
dev->device.query = hwc_query; |
|
|
|
|
dev->device.registerProcs = hwc_registerProcs; |
|
|
|
|
*device = &dev->device.common; |
|
|
|
|
|
|
|
|
|
//initializing
|
|
|
|
|
memset(&(dev->fimc), 0, sizeof(s5p_fimc_t)); |
|
|
|
|
memset(&(dev->s3c_mem), 0, sizeof(struct s3c_mem_t)); |
|
|
|
|
#ifdef USE_HW_PMEM |
|
|
|
|
memset(&(dev->sec_pmem), 0, sizeof(sec_pmem_t)); |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
/* open WIN0 & WIN1 here */ |
|
|
|
|
for (int i = 0; i < NUM_OF_WIN; i++) { |
|
|
|
|
if (window_open(&(dev->win[i]), i) < 0) { |
|
|
|
@ -902,18 +1072,6 @@ static int hwc_device_open(const struct hw_module_t* module, const char* name, |
|
|
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#ifdef USE_HW_PMEM |
|
|
|
|
if (createPmem(&dev->sec_pmem, PMEM_SIZE) < 0) { |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::initPmem(%d) fail", __func__, PMEM_SIZE); |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
if (createMem(&dev->s3c_mem, 0, 0) < 0) { |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::createMem() fail (size=0)", __func__); |
|
|
|
|
status = -EINVAL; |
|
|
|
|
goto err; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
//create PP
|
|
|
|
|
if (createFimc(&dev->fimc) < 0) { |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::creatFimc() fail", __func__); |
|
|
|
@ -921,13 +1079,12 @@ static int hwc_device_open(const struct hw_module_t* module, const char* name, |
|
|
|
|
goto err; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#ifdef SUB_TITLES_HWC |
|
|
|
|
if (createG2d(&dev->g2d) < 0) { |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::createG2d() fail", __func__); |
|
|
|
|
status = -EINVAL; |
|
|
|
|
err = pthread_create(&dev->vsync_thread, NULL, hwc_vsync_sysfs_loop, dev); |
|
|
|
|
if (err) { |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::pthread_create() failed : %s", __func__, strerror(err)); |
|
|
|
|
status = -err; |
|
|
|
|
goto err; |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
SEC_HWC_Log(HWC_LOG_DEBUG, "%s:: hwc_device_open: SUCCESS", __func__); |
|
|
|
|
|
|
|
|
@ -936,17 +1093,6 @@ static int hwc_device_open(const struct hw_module_t* module, const char* name, |
|
|
|
|
err: |
|
|
|
|
if (destroyFimc(&dev->fimc) < 0) |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyFimc() fail", __func__); |
|
|
|
|
#ifdef SUB_TITLES_HWC |
|
|
|
|
if (destroyG2d(&dev->g2d) < 0) |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyG2d() fail", __func__); |
|
|
|
|
#endif |
|
|
|
|
if (destroyMem(&dev->s3c_mem) < 0) |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyMem() fail", __func__); |
|
|
|
|
|
|
|
|
|
#ifdef USE_HW_PMEM |
|
|
|
|
if (destroyPmem(&dev->sec_pmem) < 0) |
|
|
|
|
SEC_HWC_Log(HWC_LOG_ERROR, "%s::destroyPmem() fail", __func__); |
|
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
for (int i = 0; i < NUM_OF_WIN; i++) { |
|
|
|
|
if (window_close(&dev->win[i]) < 0) |
|
|
|
|