netease
/
SmartAudio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
SmartAudio/package/allwinner/tina_multimedia/libcedarx/demo/xplayerdemo/disp.c

1613 lines
40 KiB
C
Raw Normal View History

init
2018-07-13 01:31:50 +00:00
#include "disp.h"
#if MODULE_DISP_COMPILE_CFG == 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <asm/types.h>
#include <linux/fb.h>
#include <linux/videodev2.h>
/*********************************************************************************************************
*
* Static Define
**********************************************************************************************************/
#define DISP_CLAR(x) memset(&(x), 0, sizeof(x))
/*********************************************************************************************************
*
* Static Variable
**********************************************************************************************************/
static INT8U DISP_LOG = 1;
#define DISP_DBG_LOG if(DISP_LOG) printf
/*********************************************************************************************************
*
* Extern And Global Variable
**********************************************************************************************************/
static INT32U disp_normal_layer = 100;
static INT32S disp_fd = 0;
static INT32U disp_scaler_layer = 0;
static __disp_layer_info_t disp_scaler_layer_info;
static INT8U disp_video_start_flag = 0;
#if 0
static INT32S disp_normal_fd = 0;
static INT32S disp_normal_fb_fd = 0;
static INT32U disp_normal_layer = 0;
static __disp_layer_info_t disp_normal_layer_info;
#endif
/*********************************************************************************************************
*
* Function Define
**********************************************************************************************************/
INT32S disp_layer_request(INT32S dispFd, INT32U *dispLayer, __disp_layer_work_mode_t workMode)
{
INT32U ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
INT32U tmpLayer = 0;
if(workMode > DISP_LAYER_WORK_MODE_SCALER || dispLayer == NULL){
DISP_DBG_LOG("%s:param error!\r\n", __func__);
goto errHdl;
}
DISP_CLAR(ioctlParam);
ioctlParam[DISP_IOCTL_ARG_OUT_SRC] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER] = workMode;
tmpLayer = ioctl(dispFd, DISP_CMD_LAYER_REQUEST, (void*)ioctlParam);
if(tmpLayer == 0){
DISP_DBG_LOG("%s:request disp layer failed!\r\n", __func__);
ret = -1;
goto errHdl;
}
*dispLayer = tmpLayer;
DISP_DBG_LOG("request layer = %u success\r\n", *dispLayer);
errHdl:
return ret;
}
INT32S disp_layer_release(INT32S dispFd, INT32U dispLayer)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
DISP_CLAR(ioctlParam);
ioctlParam[DISP_IOCTL_ARG_OUT_SRC] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER] = dispLayer;
ret = ioctl(dispFd, DISP_CMD_LAYER_RELEASE, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl release disp handle is not exist!\r\n", __func__);
goto errHdl;
}
DISP_DBG_LOG("release layer = %u success\r\n", dispLayer);
errHdl:
return ret;
}
INT32S disp_layer_open(INT32S dispFd, INT32U dispLayer)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
DISP_CLAR(ioctlParam);
ioctlParam[DISP_IOCTL_ARG_OUT_SRC] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER] = dispLayer;
ret = ioctl(dispFd, DISP_CMD_LAYER_OPEN, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl close disp handle is not exist!\r\n", __func__);
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_layer_close(INT32S dispFd, INT32U dispLayer)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
DISP_CLAR(ioctlParam);
ioctlParam[DISP_IOCTL_ARG_OUT_SRC] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER] = dispLayer;
ret = ioctl(dispFd, DISP_CMD_LAYER_CLOSE, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl close disp handle is not exist!\r\n", __func__);
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_layer_param_set(INT32S dispFd, INT32U dispLayer, __disp_layer_info_t *dispLayerInfo)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
if(dispLayerInfo == NULL){
DISP_DBG_LOG("%s:param error!\r\n", __func__);
ret = -1;
goto errHdl;
}
DISP_CLAR(ioctlParam);
ioctlParam[0] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[1] = dispLayer;
ioctlParam[2] = (INT32U)dispLayerInfo;
ioctl(dispFd, DISP_CMD_LAYER_SET_PARA, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl set disp layer param failed!\r\n", __func__);
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_layer_param_get(INT32S dispFd, INT32U dispLayer, __disp_layer_info_t *dispLayerInfo)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
if(dispLayerInfo == NULL){
DISP_DBG_LOG("%s:param error!\r\n", __func__);
ret = -1;
goto errHdl;
}
DISP_CLAR(ioctlParam);
ioctlParam[0] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[1] = dispLayer;
ioctlParam[2] = (INT32U)dispLayerInfo;
ioctl(dispFd, DISP_CMD_LAYER_GET_PARA, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl get disp layer param failed!\r\n", __func__);
goto errHdl;
}
errHdl:
return ret;
}
static INT32S disp_layer_cmd_cache(INT32S dispFd)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
DISP_CLAR(ioctlParam);
ioctlParam[0] = DISP_OUT_SRC_SEL_LCD;
ret = ioctl(dispFd, DISP_CMD_START_CMD_CACHE, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl set cmd cache failed!\r\n", __func__);
goto errHdl;
}
errHdl:
return ret;
}
static INT32S disp_layer_cmd_submit(INT32S dispFd)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
DISP_CLAR(ioctlParam);
ioctlParam[0] = DISP_OUT_SRC_SEL_LCD;
ret = ioctl(dispFd, DISP_CMD_EXECUTE_CMD_AND_STOP_CACHE, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl exec cmd and submit cache failed!\r\n", __func__);
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_layer_frm_buf_open(INT8S *path)
{
INT32S fbFd = 0;
if(path == NULL){ // /dev/fbxxx
DISP_DBG_LOG("%s:param error!\r\n", __func__);
fbFd = -1;
goto errHdl;
}
fbFd = open(path, O_RDWR);
if(fbFd == -1){
DISP_DBG_LOG("%s:open disp layer frame buffer handle error!\r\n", __func__);
goto errHdl;
}
errHdl:
return fbFd;
}
INT32S disp_layer_frm_buf_close(INT32S fbFd)
{
INT32S ret = 0;
ret = close(fbFd);
if(ret != 0){
DISP_DBG_LOG("%s:close disp layer frame buffer handle failed!\r\n", __func__);
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_layer_frm_buf_layer_get(INT32S fbFd, DISP_LAYER_ID fbLayerId, INT32U *fbLayer)
{
INT32S ret = 0;
INT32U tmpFbLayer;
if(fbLayer == NULL){
DISP_DBG_LOG("%s:param error!\r\n", __func__);
fbFd = -1;
goto errHdl;
}
if(fbLayerId == 0){
ret = ioctl(fbFd, FBIOGET_LAYER_HDL_0, (void*)&tmpFbLayer);
}else if(fbLayerId == 1){
ret = ioctl(fbFd, FBIOGET_LAYER_HDL_1, (void*)&tmpFbLayer);
}
if(ret != 0){
DISP_DBG_LOG("%s:ioctl get disp layer fb handle failed!\r\n", __func__);
goto errHdl;
}
*fbLayer = tmpFbLayer;
DISP_DBG_LOG("%s:fbLayer = %u\r\n", __func__, *fbLayer);
errHdl:
return ret;
}
INT32S disp_layer_frm_buf_view_set(INT32S fbFd, INT32U fbLayer, DISP_VIEW_MODE mode)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
__disp_cmd_t viewMode = 0xff;
if(mode >= DISP_VIEW_MODE_MAX){
DISP_DBG_LOG("%s:param error!\r\n", __func__);
ret = -1;
goto errHdl;
}
DISP_CLAR(ioctlParam);
ioctlParam[0] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[1] = fbLayer;
if(mode == DISP_VIEW_MODE_TOP){
viewMode = DISP_CMD_LAYER_TOP;
}else{
viewMode = DISP_CMD_LAYER_BOTTOM;
}
ioctl(fbFd, viewMode, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl get disp layer param failed!\r\n", __func__);
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_layer_on(INT32S dispFd, INT32U dispLayer)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
DISP_CLAR(ioctlParam);
ioctlParam[DISP_IOCTL_ARG_OUT_SRC] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER] = dispLayer;
ret = ioctl(dispFd, DISP_CMD_VIDEO_START, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl disp disp on failed!\r\n", __func__);
ret = -1;
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_layer_off(INT32S dispFd, INT32U dispLayer)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
DISP_CLAR(ioctlParam);
ioctlParam[DISP_IOCTL_ARG_OUT_SRC] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER] = dispLayer;
ret = ioctl(dispFd, DISP_CMD_VIDEO_STOP, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl disp disp off failed!\r\n", __func__);
ret = -1;
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_video_chanel_open(void)
{
INT32S ret = -1;
if (0 == disp_video_start_flag) {
printf("%s: open video chanel\n", __func__);
ret = disp_layer_open(disp_fd, disp_scaler_layer);
if(ret != 0){
DISP_DBG_LOG("%s:open disp layer failed!\r\n", __func__);
ret = -1;
goto errHdl;
}
ret = disp_layer_on(disp_fd, disp_scaler_layer);
if(ret != 0){
DISP_DBG_LOG("%s:disp layer disp on failed!\r\n", __func__);
ret = -2;
goto errHdl;
}
disp_video_start_flag = 1;
} else {
ret = 0; //video chanel already open
}
errHdl:
return ret;
}
INT32S disp_video_chanel_close(void)
{
INT32S ret = -1;
if (1 == disp_video_start_flag) {
ret = disp_layer_off(disp_fd, disp_scaler_layer);
if(ret != 0){
DISP_DBG_LOG("%s:disp layer disp off failed!\r\n", __func__);
ret = -1;
goto errHdl;
}
ret = disp_layer_close(disp_fd, disp_scaler_layer);
if(ret != 0){
DISP_DBG_LOG("%s:close disp layer failed!\r\n", __func__);
ret = -2;
goto errHdl;
}
disp_video_start_flag = 0;
} else {
ret = 0; //video chanel already closed
}
errHdl:
return ret;
}
static __disp_pixel_fmt_t convert_pixel_format(DISP_INPUT_FORMAT fbFmt)
{
__disp_pixel_fmt_t fmt = 0;
switch (fbFmt) {
case DISP_YUV420_PLANNAR:
fmt = DISP_FORMAT_YUV420;
break;
case DISP_MB32_PLANNAR:
fmt = DISP_FORMAT_YUV420;
break;
case DISP_ARGB8888_INTERLEAVED:
fmt = DISP_FORMAT_RGB888;
break;
default:
fmt = DISP_UNKOWN_FORMAT;
printf("%s: unkown input format, fbFmt=%d\n", __func__, fbFmt);
break;
}
return fmt;
}
static __disp_pixel_seq_t convert_pixel_seq(DISP_INPUT_FORMAT fbFmt)
{
__disp_pixel_seq_t seq = 0;
switch (fbFmt) {
case DISP_YUV420_PLANNAR:
seq = DISP_SEQ_UVUV;
break;
case DISP_MB32_PLANNAR:
seq = DISP_SEQ_UVUV;
break;
case DISP_ARGB8888_INTERLEAVED:
seq = DISP_SEQ_ARGB;
break;
default:
seq = DISP_UNKOWN_SEQ;
printf("%s: unkown input format, fbFmt=%d\n", __func__, fbFmt);
break;
}
return seq;
}
static __disp_pixel_mod_t convert_pixel_mod(DISP_INPUT_FORMAT fbFmt)
{
__disp_pixel_mod_t mod = 0;
switch (fbFmt) {
case DISP_YUV420_PLANNAR:
mod = DISP_MOD_NON_MB_PLANAR;
break;
case DISP_MB32_PLANNAR:
mod = DISP_MOD_MB_UV_COMBINED;
break;
case DISP_ARGB8888_INTERLEAVED:
mod = DISP_MOD_INTERLEAVED;
break;
default:
mod = DISP_UNKOWN_MOD;
printf("%s: unkown input format, fbFmt=%d\n", __func__, fbFmt);
break;
}
return mod;
}
INT32S disp_update_layer_param(INT32U img_width, INT32U img_height, DISP_INPUT_FORMAT fbFmt)
{
__disp_layer_info_t dispLayerInfo;
__disp_pixel_fmt_t format;
__disp_pixel_seq_t seq;
__disp_pixel_mod_t mode;
INT8U change_flag = 0;
INT32S ret = -1;
DISP_CLAR(dispLayerInfo);
//get param of layer
ret = disp_layer_param_get(disp_fd, disp_scaler_layer, &dispLayerInfo);
if (0 != ret) {
DISP_DBG_LOG("%s: fail to get layer param, fd=%d, layer=%u\n", __func__, disp_fd, disp_scaler_layer);
return -1;
}
if ((img_width != dispLayerInfo.fb.size.width) || (img_width != dispLayerInfo.src_win.width)) {
dispLayerInfo.fb.size.width = img_width;
dispLayerInfo.src_win.width = img_width;
change_flag = 1;
}
if ((img_height != dispLayerInfo.fb.size.height) || (img_height != dispLayerInfo.src_win.height)) {
dispLayerInfo.fb.size.height = img_height;
dispLayerInfo.src_win.height = img_height;
change_flag = 1;
}
format = convert_pixel_format(fbFmt);
if ((DISP_UNKOWN_FORMAT != format) && (dispLayerInfo.fb.format != format)) {
dispLayerInfo.fb.format = format;
change_flag = 1;
}
seq = convert_pixel_seq(fbFmt);
if ((DISP_UNKOWN_SEQ != seq) && (dispLayerInfo.fb.seq != seq)) {
dispLayerInfo.fb.seq = seq;
change_flag = 1;
}
mode = convert_pixel_mod(fbFmt);
if ((DISP_UNKOWN_MOD != mode) && (dispLayerInfo.fb.mode != mode)) {
dispLayerInfo.fb.mode = mode;
change_flag = 1;
}
//no need to update param of layer
if (0 == change_flag) {
return 0;
}
//set param to layer
ret = disp_layer_param_set(disp_fd, disp_scaler_layer, &dispLayerInfo);
if(ret != 0){
DISP_DBG_LOG("%s:fail to update param of layer(%u), ret=%d!\r\n", __func__, disp_scaler_layer, ret);
return -2;
}
DISP_DBG_LOG("%s: update param of layer(%u) ok\n", __func__, disp_scaler_layer);
return 0;
}
INT32S disp_normal_frm_buf_set(INT32U fbAddr)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
__disp_video_fb_t dispFbAddr;
__disp_layer_info_t dispLayerInfo;
if(fbAddr == 0){
DISP_DBG_LOG("%s:param error!gui layer addr=0x%x\r\n", __func__, fbAddr);
ret = -1;
goto errHdl;
}
DISP_CLAR(ioctlParam);
DISP_CLAR(dispFbAddr);
DISP_CLAR(dispLayerInfo);
ret = disp_layer_param_get(disp_fd, disp_normal_layer, &dispLayerInfo);
if(ret != 0){
DISP_DBG_LOG("%s: fail to get layer param, fd=%d, layer=%u\n", __func__, disp_fd, disp_normal_layer);
return -2;
}
dispLayerInfo.fb.addr[0] = fbAddr;
ret = disp_layer_param_set(disp_fd, disp_normal_layer, &dispLayerInfo);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl disp disp off failed!\r\n", __func__);
ret = -3;
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_scaler_frm_buf_set(INT32U fbAddr, INT32U img_width, INT32U img_height, DISP_INPUT_FORMAT fbFmt)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
__disp_video_fb_t dispFbAddr;
__disp_pixel_fmt_t format = 0;
INT32U h32aglin = 0;
INT32U w32aglin = 0;
INT32U h64aglin = 0;
DISP_DBG_LOG("%s: set addr=0x%x, w=%u, h=%u, fmt=%d\n", __func__, fbAddr, img_width, img_height, fbFmt);
if(fbAddr == 0){
DISP_DBG_LOG("%s:param error!\r\n", __func__);
ret = -1;
goto errHdl;
}
if (0 == disp_video_start_flag) {
DISP_DBG_LOG("%s: video is stop, cannot show video now\n", __func__);
return -2;
}
DISP_CLAR(ioctlParam);
DISP_CLAR(dispFbAddr);
(void)disp_update_layer_param(img_width, img_height, fbFmt);
// set disp frame buffer param
dispFbAddr.id = 0;
dispFbAddr.interlace = 0;
dispFbAddr.top_field_first = 0;
dispFbAddr.frame_rate = 25;
dispFbAddr.addr[0] = fbAddr;
format = convert_pixel_format(fbFmt);
switch(format){
case DISP_FORMAT_YUV422:
dispFbAddr.addr[1] = fbAddr + img_width * img_height;
dispFbAddr.addr[2] = fbAddr + img_width * img_height * 3 / 2;
break;
case DISP_FORMAT_YUV420:
if (DISP_MB32_PLANNAR == fbFmt) {
h32aglin = ((img_height + 31) & ~31);
w32aglin = ((img_width + 31) & ~31);
h64aglin = ((img_height + 63) & ~63);
dispFbAddr.addr[1] = fbAddr + w32aglin * h32aglin;
dispFbAddr.addr[2] = fbAddr + w32aglin * h32aglin + img_width * h64aglin /2;
} else {
dispFbAddr.addr[1] = fbAddr + img_width * img_height;
dispFbAddr.addr[2] = fbAddr + img_width * img_height * 5 / 4;
}
break;
case DISP_FORMAT_RGB888:
dispFbAddr.addr[1] = 0;
dispFbAddr.addr[2] = 0;
break;
default:
break;
}
ioctlParam[DISP_IOCTL_ARG_OUT_SRC] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER] = disp_scaler_layer;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER_PARAM] = (INT32U)&dispFbAddr;
ret = ioctl(disp_fd, DISP_CMD_VIDEO_SET_FB, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl disp disp off failed!\r\n", __func__);
ret = -3;
goto errHdl;
}
errHdl:
return ret;
}
static INT32S disp_video_addr_set(INT32U fbAddr, INT32U img_width, INT32U img_height, DISP_INPUT_FORMAT fbFmt)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
__disp_video_fb_t dispFbAddr;
__disp_pixel_fmt_t format = 0;
INT32U h32aglin = 0;
INT32U w32aglin = 0;
INT32U h64aglin = 0;
//DISP_DBG_LOG("%s: set addr=0x%x, w=%d, h=%d, fmt=%d\n", __func__, fbAddr, img_width, img_height, fbFmt);
if(fbAddr == 0){
printf("%s:param error!\r\n", __func__);
ret = -1;
goto errHdl;
}
if (0 == disp_video_start_flag) {
printf("%s: video is stop, cannot show video now\n", __func__);
return -2;
}
DISP_CLAR(ioctlParam);
DISP_CLAR(dispFbAddr);
// set disp frame buffer param
dispFbAddr.id = 0;
dispFbAddr.interlace = 0;
dispFbAddr.top_field_first = 0;
dispFbAddr.frame_rate = 25;
dispFbAddr.addr[0] = fbAddr;
format = convert_pixel_format(fbFmt);
switch(format){
case DISP_FORMAT_YUV422:
dispFbAddr.addr[1] = fbAddr + img_width * img_height;
dispFbAddr.addr[2] = fbAddr + img_width * img_height * 3 / 2;
break;
case DISP_FORMAT_YUV420:
if (DISP_MB32_PLANNAR == fbFmt) {
h32aglin = ((img_height + 31) & ~31);
w32aglin = ((img_width + 31) & ~31);
h64aglin = ((img_height + 63) & ~63);
dispFbAddr.addr[1] = fbAddr + w32aglin * h32aglin;
dispFbAddr.addr[2] = fbAddr + w32aglin * h32aglin + img_width * h64aglin /2;
} else {
dispFbAddr.addr[1] = fbAddr + img_width * img_height;
dispFbAddr.addr[2] = fbAddr + img_width * img_height * 5 / 4;
}
break;
case DISP_FORMAT_RGB888:
dispFbAddr.addr[1] = 0;
dispFbAddr.addr[2] = 0;
break;
default:
break;
}
ioctlParam[DISP_IOCTL_ARG_OUT_SRC] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER] = disp_scaler_layer;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER_PARAM] = (INT32U)&dispFbAddr;
ret = ioctl(disp_fd, DISP_CMD_VIDEO_SET_FB, (void*)ioctlParam);
if(ret != 0){
printf("%s:ioctl disp disp off failed!\r\n", __func__);
ret = -3;
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_ctrl_video_alpha(INT8U alpha)
{
__disp_layer_info_t dispLayerInfo;
INT32S ret = -1;
INT8U alphaVal = 0;
alphaVal = alpha;
DISP_CLAR(dispLayerInfo);
ret = disp_layer_param_get(disp_fd, disp_scaler_layer, &dispLayerInfo);
if (0 != ret) {
DISP_DBG_LOG("%s: fail to get layer param, fd=%d, layer=%u\n", __func__, disp_fd, disp_scaler_layer);
return -1;
}
dispLayerInfo.alpha_en = 1;
if (alphaVal != dispLayerInfo.alpha_val) {
dispLayerInfo.alpha_val = alphaVal;
}
ret = disp_layer_param_set(disp_fd, disp_scaler_layer, &dispLayerInfo);
if(ret != 0){
DISP_DBG_LOG("%s:set disp layer param failed, ret=%d!\r\n", __func__, ret);
return -2;
}
return 0;
}
static INT32S disp_video_addr_set_multi(INT32U *fbAddr, INT32U img_width, INT32U img_height, DISP_INPUT_FORMAT fbFmt)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
__disp_video_fb_t dispFbAddr;
__disp_pixel_fmt_t format = 0;
INT32U h32aglin = 0;
INT32U w32aglin = 0;
INT32U h64aglin = 0;
//DISP_DBG_LOG("%s: set addr=0x%x, w=%d, h=%d, fmt=%d\n", __func__, (unsigned int)fbAddr, img_width, img_height, fbFmt);
if(fbAddr == NULL){
printf("%s:param error!\r\n", __func__);
ret = -1;
goto errHdl;
}
if (0 == disp_video_start_flag) {
printf("%s: video is stop, cannot show video now\n", __func__);
return -2;
}
DISP_CLAR(ioctlParam);
DISP_CLAR(dispFbAddr);
// set disp frame buffer param
dispFbAddr.id = 0;
dispFbAddr.interlace = 0;
dispFbAddr.top_field_first = 0;
dispFbAddr.frame_rate = 25;
dispFbAddr.addr[0] = fbAddr[0];
dispFbAddr.addr[1] = fbAddr[1];
dispFbAddr.addr[2] = fbAddr[2];
ioctlParam[DISP_IOCTL_ARG_OUT_SRC] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER] = disp_scaler_layer;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER_PARAM] = (INT32U)&dispFbAddr;
ret = ioctl(disp_fd, DISP_CMD_VIDEO_SET_FB, (void*)ioctlParam);
if(ret != 0){
printf("%s:ioctl disp disp off failed!\r\n", __func__);
ret = -3;
goto errHdl;
}
errHdl:
return ret;
}
static void print_display_layer(__disp_layer_info_t *info)
{
printf("m:%d brs:%d pipe:%d alen:%d alval:%d srcx:%d srcy:%d srcw:%d srch:%d scnx:%d scny:%d scnw:%d scnh:%d a0:%x a1:%x a2:%x fbformat:%d fbw:%d fbh:%d\n",
info->mode,info->b_from_screen,info->pipe,info->alpha_en,info->alpha_val,info->src_win.x,info->src_win.y,info->src_win.width,info->src_win.height,
info->scn_win.x,info->scn_win.y,info->scn_win.width,info->scn_win.height,info->fb.addr[0],info->fb.addr[1],info->fb.addr[2],
info->fb.format,info->fb.size.width,info->fb.size.height);
}
/*
update all param at once, to get more faster
*/
INT32S disp_video_layer_param_set_with_multiaddr(INT32U *phy_addr, DISP_INPUT_FORMAT fmt, struct win_info win, INT8U apha)
{
__disp_layer_info_t dispLayerInfo;
struct st_mb32_img_info *src_win;
struct st_mb32_img_info *scn_win;
__disp_pixel_fmt_t format;
__disp_pixel_seq_t seq;
__disp_pixel_mod_t mode;
INT8U update_flag = 0;
INT32S ret = -1;
if (NULL == phy_addr) {
printf("%s: invalid phy address\n", __func__);
return -1;
}
disp_layer_cmd_cache(disp_fd); //protech param update
DISP_CLAR(dispLayerInfo);
ret = disp_layer_param_get(disp_fd, disp_scaler_layer, &dispLayerInfo);
if (0 != ret) {
DISP_DBG_LOG("%s: fail to get layer param, fd=%d, layer=%u\n", __func__, disp_fd, disp_scaler_layer);
ret = -1;
goto errHdl;
}
src_win = &(win.src_win);
scn_win = &(win.scn_win);
//check src window update
if((dispLayerInfo.src_win.x == src_win->outLeftOffset)
&&(dispLayerInfo.src_win.y == src_win->outTopOffset)
&&(dispLayerInfo.src_win.width == src_win->outRightOffset)
&&(dispLayerInfo.src_win.height == src_win->outBottomOffset)){
//DISP_DBG_LOG("%s: src win no need to update!\r\n", __func__);
} else {
dispLayerInfo.src_win.x = src_win->outLeftOffset;
dispLayerInfo.src_win.y = src_win->outTopOffset;
dispLayerInfo.src_win.width = src_win->outRightOffset;
dispLayerInfo.src_win.height = src_win->outBottomOffset;
update_flag = 1;
}
//check screen window update
if((dispLayerInfo.scn_win.x == scn_win->outLeftOffset) &&
(dispLayerInfo.scn_win.y == scn_win->outTopOffset) &&
(dispLayerInfo.scn_win.width == scn_win->outRightOffset) &&
(dispLayerInfo.scn_win.height == scn_win->outBottomOffset)){
//DISP_DBG_LOG("%s: scn win no need to update!\r\n", __func__);
} else {
dispLayerInfo.scn_win.x = scn_win->outLeftOffset;
dispLayerInfo.scn_win.y = scn_win->outTopOffset;
dispLayerInfo.scn_win.width = scn_win->outRightOffset;
dispLayerInfo.scn_win.height = scn_win->outBottomOffset;
update_flag = 1;
}
//check apha update
dispLayerInfo.alpha_en = 1;
if (apha == dispLayerInfo.alpha_val) {
//DISP_DBG_LOG("%s: apha value no need to update!\r\n", __func__);
} else {
dispLayerInfo.alpha_val = apha;
update_flag = 1;
}
if (win.width != dispLayerInfo.fb.size.width) {
dispLayerInfo.fb.size.width = win.width;
update_flag = 1;
}
if ((win.height != dispLayerInfo.fb.size.height) ) {
dispLayerInfo.fb.size.height = win.height;
update_flag = 1;
}
format = convert_pixel_format(fmt);
if ((DISP_UNKOWN_FORMAT != format) && (dispLayerInfo.fb.format != format)) {
dispLayerInfo.fb.format = format;
update_flag = 1;
}
seq = convert_pixel_seq(fmt);
if ((DISP_UNKOWN_SEQ != seq) && (dispLayerInfo.fb.seq != seq)) {
dispLayerInfo.fb.seq = seq;
update_flag = 1;
}
mode = convert_pixel_mod(fmt);
if ((DISP_UNKOWN_MOD != mode) && (dispLayerInfo.fb.mode != mode)) {
dispLayerInfo.fb.mode = mode;
update_flag = 1;
}
//dispLayerInfo.scn_win.width = 320;
//dispLayerInfo.scn_win.height = 240;
print_display_layer(&dispLayerInfo);
if (update_flag) {
ret = disp_layer_param_set(disp_fd, disp_scaler_layer, &dispLayerInfo);
if (0 != ret) {
DISP_DBG_LOG("%s: fail to get layer param, fd=%d, layer=%u\n", __func__, disp_fd, disp_scaler_layer);
}
} else {
ret = 0;
}
//sleep(1);
//disp_video_addr_set_multi(phy_addr, win.width, win.height, fmt);
disp_video_addr_set(phy_addr[0],720,480,fmt);
//return ret;
errHdl:
disp_layer_cmd_submit(disp_fd);
return ret;
}
/*
update all param at once, to get more faster
*/
INT32S disp_video_layer_param_set(INT32U phy_addr, DISP_INPUT_FORMAT fmt, struct win_info win, INT8U apha)
{
__disp_layer_info_t dispLayerInfo;
struct st_mb32_img_info *src_win;
struct st_mb32_img_info *scn_win;
__disp_pixel_fmt_t format;
__disp_pixel_seq_t seq;
__disp_pixel_mod_t mode;
INT8U update_flag = 0;
INT32S ret = -1;
if (0 == phy_addr) {
printf("%s: invalid phy address\n", __func__);
return -1;
}
disp_layer_cmd_cache(disp_fd); //protech param update
DISP_CLAR(dispLayerInfo);
ret = disp_layer_param_get(disp_fd, disp_scaler_layer, &dispLayerInfo);
if (0 != ret) {
DISP_DBG_LOG("%s: fail to get layer param, fd=%d, layer=%u\n", __func__, disp_fd, disp_scaler_layer);
ret = -1;
goto errHdl;
}
src_win = &(win.src_win);
scn_win = &(win.scn_win);
//check src window update
if((dispLayerInfo.src_win.x == src_win->outLeftOffset)
&&(dispLayerInfo.src_win.y == src_win->outTopOffset)
&&(dispLayerInfo.src_win.width == src_win->outRightOffset)
&&(dispLayerInfo.src_win.height == src_win->outBottomOffset)){
//DISP_DBG_LOG("%s: src win no need to update!\r\n", __func__);
} else {
dispLayerInfo.src_win.x = src_win->outLeftOffset;
dispLayerInfo.src_win.y = src_win->outTopOffset;
dispLayerInfo.src_win.width = src_win->outRightOffset;
dispLayerInfo.src_win.height = src_win->outBottomOffset;
update_flag = 1;
}
//check screen window update
if((dispLayerInfo.scn_win.x == scn_win->outLeftOffset) &&
(dispLayerInfo.scn_win.y == scn_win->outTopOffset) &&
(dispLayerInfo.scn_win.width == scn_win->outRightOffset) &&
(dispLayerInfo.scn_win.height == scn_win->outBottomOffset)){
//DISP_DBG_LOG("%s: scn win no need to update!\r\n", __func__);
} else {
dispLayerInfo.scn_win.x = scn_win->outLeftOffset;
dispLayerInfo.scn_win.y = scn_win->outTopOffset;
dispLayerInfo.scn_win.width = scn_win->outRightOffset;
dispLayerInfo.scn_win.height = scn_win->outBottomOffset;
update_flag = 1;
}
//check apha update
dispLayerInfo.alpha_en = 1;
if (apha == dispLayerInfo.alpha_val) {
//DISP_DBG_LOG("%s: apha value no need to update!\r\n", __func__);
} else {
dispLayerInfo.alpha_val = apha;
update_flag = 1;
}
if (win.width != dispLayerInfo.fb.size.width) {
dispLayerInfo.fb.size.width = win.width;
update_flag = 1;
}
if ((win.height != dispLayerInfo.fb.size.height) ) {
dispLayerInfo.fb.size.height = win.height;
update_flag = 1;
}
format = convert_pixel_format(fmt);
if ((DISP_UNKOWN_FORMAT != format) && (dispLayerInfo.fb.format != format)) {
dispLayerInfo.fb.format = format;
update_flag = 1;
}
seq = convert_pixel_seq(fmt);
if ((DISP_UNKOWN_SEQ != seq) && (dispLayerInfo.fb.seq != seq)) {
dispLayerInfo.fb.seq = seq;
update_flag = 1;
}
mode = convert_pixel_mod(fmt);
if ((DISP_UNKOWN_MOD != mode) && (dispLayerInfo.fb.mode != mode)) {
dispLayerInfo.fb.mode = mode;
update_flag = 1;
}
if (update_flag) {
ret = disp_layer_param_set(disp_fd, disp_scaler_layer, &dispLayerInfo);
if (0 != ret) {
DISP_DBG_LOG("%s: fail to get layer param, fd=%d, layer=%u\n", __func__, disp_fd, disp_scaler_layer);
}
} else {
ret = 0;
}
//sleep(1);
disp_video_addr_set(phy_addr, win.width, win.height, fmt);
//return ret;
errHdl:
disp_layer_cmd_submit(disp_fd);
return ret;
}
INT32S disp_rotate_set(INT32U angle)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
DISP_CLAR(ioctlParam);
if ((0 != angle) && (180 != angle)) {
printf("%s: param error, angle=%u\n", __func__, angle);
return -1;
}
ioctlParam[0] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[1] = angle;
ret = ioctl(disp_fd, DISP_CMD_SET_ROTATE, (void*)ioctlParam);
if(ret != 0){
printf("%s: set rotate failed, angle=%u!\r\n", __func__, angle);
ret = -2;
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_src_win_set(INT32U src_x, INT32U src_y, INT32U src_w, INT32U src_h)
{
__disp_layer_info_t dispLayerInfo;
INT32S ret = -1;
DISP_CLAR(dispLayerInfo);
ret = disp_layer_param_get(disp_fd, disp_scaler_layer, &dispLayerInfo);
if(0 != ret) {
DISP_DBG_LOG("%s: fail to get layer param, fd=%d, layer=%u\n", __func__, disp_fd, disp_scaler_layer);
return -2;
}
if((dispLayerInfo.scn_win.x == src_x) &&
(dispLayerInfo.scn_win.y == src_y) &&
(dispLayerInfo.scn_win.width == src_w) &&
(dispLayerInfo.scn_win.height == src_h)){
DISP_DBG_LOG("%s: src win no need to update!\r\n", __func__);
return 0;
}
dispLayerInfo.src_win.x = src_x;
dispLayerInfo.src_win.y = src_y;
dispLayerInfo.src_win.width = src_w;
dispLayerInfo.src_win.height = src_h;
DISP_DBG_LOG("%s: set source window: x=%u, y=%u, w=%u, h=%u\n", __func__, src_x, src_y, src_y, src_h);
ret = disp_layer_param_set(disp_fd, disp_scaler_layer, &dispLayerInfo);
if(ret != 0){
DISP_DBG_LOG("%s:set disp layer param failed, ret=%d!\r\n", __func__, ret);
return -3;
}
return 0;
}
/*
display buffer regard as a horizon screen, if you use MCU panel , you need to rotate 90 degree and reset the video
window like below:
case 0:
case 180:
scn_x = 0;
scn_y = GUI_TOP_STATUS_BAR_HEIGHT_PIXEL;
scn_w = GUI_FRM_BUF_WIDTH_PIXEL;
scn_h = GUI_FRM_BUF_HEIGHT_PIXEL - GUI_TOP_STATUS_BAR_HEIGHT_PIXEL - GUI_BOTTOM_STATUS_BAR_HEIGHT_PIXEL;
case 90:
case 270:
scn_x = GUI_TOP_STATUS_BAR_HEIGHT_PIXEL;
scn_y = 0;
scn_w = GUI_FRM_BUF_HEIGHT_PIXEL - GUI_TOP_STATUS_BAR_HEIGHT_PIXEL - GUI_BOTTOM_STATUS_BAR_HEIGHT_PIXEL;
scn_h = GUI_FRM_BUF_WIDTH_PIXEL;
*/
INT32S disp_scn_win_set(INT32U scn_x, INT32U scn_y, INT32U scn_w, INT32U scn_h)
{
__disp_layer_info_t dispLayerInfo;
INT32S ret = -1;
DISP_CLAR(dispLayerInfo);
ret = disp_layer_param_get(disp_fd, disp_scaler_layer, &dispLayerInfo);
if(0 != ret) {
DISP_DBG_LOG("%s: fail to get layer param, fd=%d, layer=%u\n", __func__, disp_fd, disp_scaler_layer);
return -2;
}
if((dispLayerInfo.scn_win.x == scn_x) &&
(dispLayerInfo.scn_win.y == scn_y) &&
(dispLayerInfo.scn_win.width == scn_w) &&
(dispLayerInfo.scn_win.height == scn_h)){
DISP_DBG_LOG("%s: scn win no need to update!\r\n", __func__);
return 0;
}
dispLayerInfo.scn_win.x = scn_x;
dispLayerInfo.scn_win.y = scn_y;
dispLayerInfo.scn_win.width = scn_w;
dispLayerInfo.scn_win.height = scn_h;
DISP_DBG_LOG("%s: set screen window: x=%u, y=%u, w=%u, h=%u\n", __func__, scn_x, scn_y, scn_y, scn_h);
ret = disp_layer_param_set(disp_fd, disp_scaler_layer, &dispLayerInfo);
if(ret != 0){
DISP_DBG_LOG("%s:set disp layer param failed, ret=%d!\r\n", __func__, ret);
return -3;
}
return 0;
}
INT32S disp_scaler_init(void)
{
INT32S ret = 0;
disp_fd = disp_open(DISP_DEV_NAME);
if(disp_fd == -1){
DISP_DBG_LOG("%s:open disp handle is not exist!\r\n", __func__);
ret = -1;
goto errHdl;
}
ret = disp_layer_request(disp_fd, &disp_scaler_layer, DISP_LAYER_WORK_MODE_SCALER);
if(ret != 0){
DISP_DBG_LOG("%s:request layer failed!\r\n", __func__);
ret = -3;
goto errHdl;
}
DISP_DBG_LOG("%s:disp_fd = %d, disp_scaler_layer = %u\r\n", __func__, disp_fd, disp_scaler_layer);
disp_scaler_layer_info.mode = DISP_LAYER_WORK_MODE_SCALER;
disp_scaler_layer_info.pipe = 1;
disp_scaler_layer_info.fb.addr[0] = 0;
disp_scaler_layer_info.fb.addr[1] = 0;
disp_scaler_layer_info.fb.addr[2] = 0;
disp_scaler_layer_info.fb.size.width = DISP_INPUT_WIDTH;
disp_scaler_layer_info.fb.size.height = DISP_INPUT_HEIGHT;
disp_scaler_layer_info.fb.mode = DISP_INPUT_MODE;
disp_scaler_layer_info.fb.format = DISP_INPUT_FMT;
disp_scaler_layer_info.fb.br_swap = 0;
disp_scaler_layer_info.fb.seq = DISP_INPUT_SEQ;
disp_scaler_layer_info.ck_enable = 0;
disp_scaler_layer_info.alpha_en = 1;
disp_scaler_layer_info.alpha_val = DISP_UI_ALPHA;
disp_scaler_layer_info.src_win.x = 0;
disp_scaler_layer_info.src_win.y = 0;
disp_scaler_layer_info.src_win.width = DISP_INPUT_WIDTH;
disp_scaler_layer_info.src_win.height = DISP_INPUT_HEIGHT;
disp_scaler_layer_info.scn_win.x = 0;
disp_scaler_layer_info.scn_win.y = 0;
disp_scaler_layer_info.scn_win.width = GUI_FRM_BUF_WIDTH_PIXEL;
disp_scaler_layer_info.scn_win.height = GUI_FRM_BUF_HEIGHT_PIXEL;
ret = disp_layer_param_set(disp_fd, disp_scaler_layer, &disp_scaler_layer_info);
if(ret != 0){
DISP_DBG_LOG("%s:set disp layer param failed!\r\n", __func__);
ret = -4;
goto errHdl;
}
DISP_DBG_LOG("%s:disp on ok\r\n", __func__);
errHdl:
return ret;
}
INT32S disp_scaler_uninit(void)
{
INT32S ret = 0;
/* close back light of panel before un-init disp module */
disp_close_backlight();
ret = disp_layer_off(disp_fd, disp_scaler_layer);
if(ret != 0){
DISP_DBG_LOG("%s:disp layer off failed,layer not open!\r\n", __func__);
}
ret = disp_layer_close(disp_fd, disp_scaler_layer);
if(ret != 0){
DISP_DBG_LOG("%s:close disp layer failed!\r\n", __func__);
ret = -1;
goto errHdl;
}
ret = disp_layer_release(disp_fd, disp_scaler_layer);
if(ret != 0){
DISP_DBG_LOG("%s:release disp layer failed!\r\n", __func__);
ret = -2;
goto errHdl;
}
ret = disp_lcd_off(disp_fd);
if(ret != 0){
DISP_DBG_LOG("%s:disp lcd off failed!\r\n", __func__);
ret = -4;
goto errHdl;
}
ret = disp_close(disp_fd);
if(ret != 0){
DISP_DBG_LOG("%s:close disp failed!\r\n", __func__);
ret = -5;
goto errHdl;
}
DISP_DBG_LOG("%s:disp on ok\r\n", __func__);
errHdl:
return ret;
}
#if 0
INT32S disp_normal_init(void)
{
INT32S ret = 0;
INT32U fbLayer;
disp_normal_fd = disp_open(DISP_DEV_NAME);
if(disp_normal_fd == -1){
DISP_DBG_LOG("%s:open disp handle is not exist!\r\n", __func__);
ret = -1;
goto errHdl;
}
ret = disp_lcd_on(disp_normal_fd);
if(ret != 0){
DISP_DBG_LOG("%s:disp lcd on failed!\r\n", __func__);
ret = -2;
goto errHdl;
}
ret = disp_layer_request(disp_normal_fd, &disp_normal_layer, DISP_LAYER_WORK_MODE_NORMAL);
if(ret != 0){
DISP_DBG_LOG("%s:request layer failed!\r\n", __func__);
ret = -3;
goto errHdl;
}
DISP_DBG_LOG("%s:disp_normal_fd = %d, disp_normal_layer = %d\r\n", __func__, disp_normal_fd, disp_normal_layer);
disp_normal_layer_info.mode = DISP_LAYER_WORK_MODE_NORMAL;
disp_normal_layer_info.pipe = 1;
disp_normal_layer_info.fb.addr[0] = 0;
disp_normal_layer_info.fb.addr[1] = 0;
disp_normal_layer_info.fb.addr[2] = 0;
disp_normal_layer_info.fb.size.width = GUI_RES_PIXEL_WIDTH;
disp_normal_layer_info.fb.size.height = GUI_RES_PIXEL_HEIGHT;
disp_normal_layer_info.fb.mode = DISP_UI_MODE;
disp_normal_layer_info.fb.format = DISP_UI_FMT;
disp_normal_layer_info.fb.br_swap = 0;
disp_normal_layer_info.fb.seq = DISP_UI_SEQ;
disp_normal_layer_info.ck_enable = 0;
disp_normal_layer_info.alpha_en = 1;
disp_normal_layer_info.alpha_val = 0x7f;
disp_normal_layer_info.src_win.x = 0;
disp_normal_layer_info.src_win.y = 0;
disp_normal_layer_info.src_win.width = GUI_RES_PIXEL_WIDTH;
disp_normal_layer_info.src_win.height = GUI_RES_PIXEL_HEIGHT;
disp_normal_layer_info.scn_win.x = 0;
disp_normal_layer_info.scn_win.y = 0;
disp_normal_layer_info.scn_win.width = GUI_RES_PIXEL_WIDTH;
disp_normal_layer_info.scn_win.height = GUI_RES_PIXEL_HEIGHT;
ret = disp_layer_param_set(disp_normal_fd, disp_normal_layer, &disp_scaler_layer_info);
if(ret != 0){
DISP_DBG_LOG("%s:set disp layer param failed!\r\n", __func__);
ret = -4;
goto errHdl;
}
ret = disp_layer_open(disp_normal_fd, disp_normal_layer);
if(ret != 0){
DISP_DBG_LOG("%s:open disp layer failed!\r\n", __func__);
ret = -5;
goto errHdl;
}
disp_scaler_fb_fd = disp_layer_frm_buf_open(GUI_MGR_FB_DEV_NAME);
if(disp_scaler_fb_fd == -1){
DISP_DBG_LOG("%s:open disp frame buffer handle is not exist!\r\n", __func__);
ret = -6;
goto errHdl;
}
ret = disp_layer_frm_buf_layer_get(disp_scaler_fb_fd, DISP_LAYER_ID_1, &fbLayer);
if(ret != 0){
DISP_DBG_LOG("%s:set disp layer view mode failed!\r\n", __func__);
ret = -7;
goto errHdl;
}
ret = disp_layer_frm_buf_view_set(disp_scaler_fb_fd, fbLayer, DISP_VIEW_MODE_TOP);
if(ret != 0){
DISP_DBG_LOG("%s:set disp layer view mode failed!\r\n", __func__);
ret = -8;
goto errHdl;
}
ret = disp_layer_on(disp_normal_fd, disp_normal_layer);
if(ret != 0){
DISP_DBG_LOG("%s:disp layer disp on failed!\r\n", __func__);
ret = -7;
goto errHdl;
}
ret = disp_lcd_on(disp_normal_fd);
if(ret != 0){
DISP_DBG_LOG("%s:disp lcd on failed!\r\n", __func__);
ret = -8;
goto errHdl;
}
DISP_DBG_LOG("%s:disp on ok\r\n", __func__);
errHdl:
return ret;
}
INT32S disp_normal_uninit(void)
{
INT32S ret = 0;
ret = disp_close(disp_normal_fd);
if(ret != 0){
DISP_DBG_LOG("%s:close disp failed!\r\n", __func__);
ret = -1;
goto errHdl;
}
ret = disp_layer_close(disp_normal_fd, disp_normal_layer);
if(ret != 0){
DISP_DBG_LOG("%s:close disp layer failed!\r\n", __func__);
ret = -2;
goto errHdl;
}
ret = disp_layer_release(disp_normal_fd, disp_normal_layer);
if(ret != 0){
DISP_DBG_LOG("%s:release disp layer failed!\r\n", __func__);
ret = -3;
goto errHdl;
}
ret = disp_layer_off(disp_normal_fd, disp_normal_layer);
if(ret != 0){
DISP_DBG_LOG("%s:disp layer off failed!\r\n", __func__);
ret = -6;
goto errHdl;
}
ret = disp_lcd_off(disp_normal_fd);
if(ret != 0){
DISP_DBG_LOG("%s:disp lcd off failed!\r\n", __func__);
ret = -7;
goto errHdl;
}
DISP_DBG_LOG("%s:disp on ok\r\n", __func__);
errHdl:
return ret;
}
#endif
INT32S disp_lcd_on(INT32S dispFd)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
DISP_CLAR(ioctlParam);
ioctlParam[DISP_IOCTL_ARG_OUT_SRC] = DISP_OUT_SRC_SEL_LCD;
ret = ioctl(dispFd, DISP_CMD_LCD_ON, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl disp handle is not exist!\r\n", __func__);
//dispFd = -1;
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_lcd_off(INT32S dispFd)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
DISP_CLAR(ioctlParam);
ioctlParam[DISP_IOCTL_ARG_OUT_SRC] = DISP_OUT_SRC_SEL_LCD;
ret = ioctl(dispFd, DISP_CMD_LCD_OFF, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s:ioctl close disp handle is not exist!\r\n", __func__);
ret = -1;
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_open(INT8S *path)
{
INT32S dispFd = 0;
if(path == NULL){
DISP_DBG_LOG("%s:param error!\r\n", __func__);
dispFd = -1;
goto errHdl;
}
dispFd = open(path, O_RDWR);
if(dispFd == -1){
DISP_DBG_LOG("%s:open disp handle error!\r\n", __func__);
goto errHdl;
}
errHdl:
return dispFd;
}
INT32S disp_open_backlight(void)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
DISP_CLAR(ioctlParam);
if (disp_fd <= 0) {
printf("%s: disp device has not open yet.\n", __func__);
return -1;
}
ioctlParam[0] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[1] = 100;
ret = ioctl(disp_fd, DISP_CMD_LCD_SET_BRIGHTNESS, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s: fail to open backlight!\r\n", __func__);
ret = -2;
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_close_backlight(void)
{
INT32S ret = 0;
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
DISP_CLAR(ioctlParam);
if (disp_fd <= 0) {
printf("%s: disp device has not open yet.\n", __func__);
return -1;
}
ioctlParam[0] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[1] = 0;
ret = ioctl(disp_fd, DISP_CMD_LCD_SET_BRIGHTNESS, (void*)ioctlParam);
if(ret != 0){
DISP_DBG_LOG("%s: fail to open backlight!\r\n", __func__);
ret = -2;
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_close(INT32S dispFd)
{
INT32S ret = 0;
ret = close(dispFd);
if(ret != 0){
DISP_DBG_LOG("%s:close disp handle failed!\r\n", __func__);
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_init(void)
{
INT32S ret = 0;
ret = disp_scaler_init();
if(ret != 0){
DISP_DBG_LOG("%s:disp scaler init failed!\r\n", __func__);
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_uninit(void)
{
INT32S ret = 0;
ret = disp_scaler_uninit();
if(ret != 0){
DISP_DBG_LOG("%s:disp scaler uninit failed!\r\n", __func__);
goto errHdl;
}
errHdl:
return ret;
}
INT32S disp_screenwidth_get()
{
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
INT32U width;
DISP_CLAR(ioctlParam);
ioctlParam[DISP_IOCTL_ARG_OUT_SRC] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER] = 0;
width = ioctl(disp_fd,DISP_CMD_SCN_GET_WIDTH,ioctlParam);
return width;
}
INT32S disp_screenheight_get()
{
INT32U ioctlParam[DISP_IOCTL_ARG_MAX];
INT32U height;
DISP_CLAR(ioctlParam);
ioctlParam[DISP_IOCTL_ARG_OUT_SRC] = DISP_OUT_SRC_SEL_LCD;
ioctlParam[DISP_IOCTL_ARG_OUT_LAYER] = 0;
height = ioctl(disp_fd,DISP_CMD_SCN_GET_HEIGHT,ioctlParam);
return height;
}
INT32S disp_get_cur_fd()
{
return disp_fd;
}
#endif // #if MODULE_DISP_COMPILE_CFG == 1