1989 lines
69 KiB
C++
1989 lines
69 KiB
C++
/* Copyright Statement:
|
|
*
|
|
* This software/firmware and related documentation ("MediaTek Software") are
|
|
* protected under relevant copyright laws. The information contained herein is
|
|
* confidential and proprietary to MediaTek Inc. and/or its licensors. Without
|
|
* the prior written permission of MediaTek inc. and/or its licensors, any
|
|
* reproduction, modification, use or disclosure of MediaTek Software, and
|
|
* information contained herein, in whole or in part, shall be strictly
|
|
* prohibited.
|
|
*
|
|
* MediaTek Inc. (C) 2010. All rights reserved.
|
|
*
|
|
* BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
|
|
* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
|
|
* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
|
|
* ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
|
|
* WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
|
|
* NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
|
|
* RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
|
|
* INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
|
|
* TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
|
|
* RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
|
|
* OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
|
|
* SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
|
|
* RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
|
|
* STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
|
|
* ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
|
|
* RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
|
|
* MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
|
|
* CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
|
|
*
|
|
* The following software/firmware and/or related documentation ("MediaTek
|
|
* Software") have been modified by MediaTek Inc. All revisions are subject to
|
|
* any receiver's applicable license agreements with MediaTek Inc.
|
|
*/
|
|
|
|
#define MTK_LOG_ENABLE 1
|
|
#include <dlfcn.h>
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
#include <sys/ioctl.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <sched.h>
|
|
#include <sys/time.h>
|
|
#include <sys/resource.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include <utils/RefBase.h>
|
|
#include <utils/StrongPointer.h>
|
|
|
|
#include <cutils/ashmem.h>
|
|
#include <cutils/log.h>
|
|
#include <cutils/atomic.h>
|
|
#include <cutils/properties.h>
|
|
#include <cutils/klog.h>
|
|
|
|
/* include linux framebuffer header */
|
|
#include <linux/fb.h>
|
|
#include <unistd.h>
|
|
#include <binder/IBinder.h>
|
|
#include <gui/IGraphicBufferProducer.h>
|
|
|
|
/* include surface flinger header */
|
|
#include <gui/LayerState.h>
|
|
|
|
#include <binder/IPCThreadState.h>
|
|
|
|
#include <hardware/hardware.h>
|
|
#include <hardware/gralloc.h>
|
|
|
|
#include <android/native_window.h>
|
|
#include <android/rect.h>
|
|
|
|
//#include <ui/Rect.h>
|
|
//#include <ui/Region.h>
|
|
//#include <ui/DisplayConfig.h>
|
|
#include <ui/DisplayState.h>
|
|
#include <ui/GraphicBuffer.h>
|
|
|
|
#include <gui/Surface.h>
|
|
#include <gui/SurfaceComposerClient.h>
|
|
#include <gui/ISurfaceComposer.h>
|
|
|
|
#include <fs_mgr.h>
|
|
|
|
#include <chrono>
|
|
|
|
/* include drm_resources */
|
|
#include <libdrm_macros.h>
|
|
|
|
#include "charging_animation.h"
|
|
|
|
//#include <sysenv_utils.h>
|
|
|
|
#include "utils.h"
|
|
|
|
#ifdef SLOGD
|
|
#undef SLOGD
|
|
//#define SLOGD(x,...) do { KLOG_ERROR("libshowlogo", x); } while (0)
|
|
#define SLOGD(...) \
|
|
do \
|
|
{ \
|
|
KLOG_ERROR("libshowlogo", __VA_ARGS__); \
|
|
} while (0)
|
|
#endif
|
|
|
|
#ifdef SLOGE
|
|
#undef SLOGE
|
|
//#define SLOGE(x,...) do { KLOG_ERROR("libshowlogo", x); } while (0)
|
|
#define SLOGE(...) \
|
|
do \
|
|
{ \
|
|
KLOG_ERROR("libshowlogo", __VA_ARGS__); \
|
|
} while (0)
|
|
#endif
|
|
|
|
using namespace android;
|
|
using android::fs_mgr::Fstab;
|
|
using android::fs_mgr::GetEntryForMountPoint;
|
|
using android::fs_mgr::ReadDefaultFstab;
|
|
using namespace std::chrono;
|
|
|
|
#if 0
|
|
#if defined(MSSI_MTK_CARRIEREXPRESS_PACK)
|
|
#define ENV_MAGIC 'e'
|
|
#define ENV_READ _IOW(ENV_MAGIC, 1, int)
|
|
#define ENV_WRITE _IOW(ENV_MAGIC, 2, int)
|
|
#define BUF_MAX_LEN 20
|
|
#define NAME_E "mtk_usp_operator"
|
|
#define VALUE_E "120"
|
|
|
|
/*
|
|
struct env_ioctl
|
|
{
|
|
char *name;
|
|
int name_len;
|
|
char *value;
|
|
int value_len;
|
|
};*/
|
|
|
|
/* Operator number */
|
|
#define OPTR_NUM_OP01 1
|
|
#define OPTR_NUM_OP02 2
|
|
#define OPTR_NUM_OP09 9
|
|
|
|
/* Count of logos for different charging animations */
|
|
#define LOGOS_COUNT_NORMAL_CHARGING_ANIM 38
|
|
#define LOGOS_COUNT_FAST_CHARGING_ANIM 18
|
|
#define LOGOS_COUNT_WIRELESS_CHARGING_ANIM 29
|
|
|
|
#define MAX_OPERATOR_SUPPORT 5
|
|
|
|
#endif
|
|
#endif
|
|
|
|
sp<SurfaceComposerClient> client;
|
|
sp<SurfaceControl> surfaceControl;
|
|
|
|
ANativeWindow_Buffer outBuffer;
|
|
ANativeWindowBuffer *buf;
|
|
sp<GraphicBuffer> gb;
|
|
|
|
sp<Surface> surface;
|
|
ui::DisplayState mDisplayState;
|
|
//DisplayConfig dinfo;
|
|
|
|
static LCM_SCREEN_T phical_screen;
|
|
|
|
static int fb_fd = 0;
|
|
static int drm_fd = 0;
|
|
// logo.bin
|
|
static uint64_t *logo_addr = NULL;
|
|
static unsigned long logo_offset = 0;
|
|
// use for decompress logo resource
|
|
static void *dec_logo_addr = NULL;
|
|
// use for nmap framebuffer
|
|
static unsigned int *fb_addr = NULL;
|
|
// use double fb address
|
|
static unsigned int *lk_fb_addr = NULL;
|
|
static unsigned int *charging_fb_addr = NULL;
|
|
static unsigned int *kernel_fb_addr = NULL;
|
|
static unsigned int use_double_addr = 0;
|
|
|
|
static struct fb_var_screeninfo vinfo;
|
|
static struct fb_fix_screeninfo finfo;
|
|
libDrmApi libdrmApi;
|
|
chargingAnimationDimensionAPI chargingAnimationDimension;
|
|
static unsigned int fb_size = 0;
|
|
|
|
//dualdisplay - parameters for 2nd LCD - start
|
|
//extern & declare in header file
|
|
static LCM_SCREEN_T phical_screen_ext;
|
|
static unsigned int *fb_addr_ext = NULL;
|
|
// use double fb address
|
|
static unsigned int *lk_fb_addr_ext = NULL;
|
|
static unsigned int *charging_fb_addr_ext = NULL;
|
|
static unsigned int *kernel_fb_addr_ext = NULL;
|
|
//single or multibin
|
|
bool is_multibin = false;
|
|
static struct fb_var_screeninfo vinfo_ext;
|
|
static struct fb_fix_screeninfo finfo_ext;
|
|
libDrmApi libdrmApi_ext;
|
|
chargingAnimationDimensionAPI chargingAnimationDimension_ext;
|
|
static unsigned int fb_size_ext = 0;
|
|
ANativeWindow_Buffer outBuffer_ext;
|
|
ANativeWindowBuffer *buf_ext;
|
|
sp<Surface> surface_ext;
|
|
//dualdisplay - parameters for 2nd LCD - end
|
|
|
|
static int show_animationm_ver = VERION_OLD_ANIMATION;
|
|
static int draw_anim_mode = DRAW_ANIM_MODE_SURFACE;
|
|
|
|
// kernel logo index may be different for different logo.bin
|
|
static int kernel_logo_position = KERNEL_LOGO_INDEX;
|
|
// add a flag for exiting on abnormal case
|
|
static int error_flag = 0;
|
|
// get system properties
|
|
int getValue(char *key, char *defValue);
|
|
|
|
//get the right partition path of logo
|
|
#define LOGO_MNT_POINT "/logo"
|
|
struct fstab *fstab;
|
|
|
|
#if 0
|
|
#if defined(MSSI_MTK_CARRIEREXPRESS_PACK)
|
|
/*
|
|
* get active operator
|
|
*
|
|
*/
|
|
int get_active_optr(){
|
|
int fd;
|
|
int n;
|
|
int active_optr = -1;
|
|
|
|
//struct env_ioctl en_ctl;
|
|
char *name = NULL;
|
|
const char *value = NULL;
|
|
|
|
//memset(&en_ctl,0x00,sizeof(struct env_ioctl));
|
|
|
|
fd= open("/proc/lk_env",O_RDWR);
|
|
|
|
if (fd<= 0) {
|
|
if (MTK_LOG_ENABLE == 1) {
|
|
SLOGD("[libshowlogo] ERROR open fail %d\n",fd);
|
|
}
|
|
return -1;
|
|
}
|
|
if (MTK_LOG_ENABLE == 1) {
|
|
SLOGD("[libshowlogo] open /proc/lk_env ok\n");
|
|
}
|
|
name = (char *)malloc(BUF_MAX_LEN);
|
|
memset(name,0x00,BUF_MAX_LEN);
|
|
memcpy(name,NAME_E,strlen(NAME_E)+1);
|
|
|
|
#if 0 //test
|
|
value = (char *)malloc(BUF_MAX_LEN);
|
|
memset(value,0x00,BUF_MAX_LEN);
|
|
memcpy(value,VALUE_E,strlen(VALUE_E)+1);
|
|
|
|
en_ctl.name = name;
|
|
en_ctl.value = value;
|
|
en_ctl.name_len = strlen(name)+1;
|
|
en_ctl.value_len = strlen(value)+1;
|
|
SLOGD("[libshowlogo] write %s = %s\n",name,value);
|
|
n=ioctl(fd,ENV_WRITE,&en_ctl);
|
|
if (n<0) {
|
|
SLOGD("[libshowlogo] ERROR write fail %d\n",n);
|
|
} else {
|
|
SLOGD("[libshowlogo] SysEnv Write 3 successfull %d\n",n);
|
|
}
|
|
memset(value,0x00,BUF_MAX_LEN);
|
|
en_ctl.value_len = BUF_MAX_LEN;
|
|
#endif
|
|
|
|
printf("read %s \n",name);
|
|
|
|
//n=ioctl(fd,ENV_READ,&en_ctl);
|
|
value = sysenv_get((const char *)name);
|
|
|
|
if (value == NULL) {
|
|
if (MTK_LOG_ENABLE == 1) {
|
|
SLOGD("[libshowlogo] ERROR read fail \n");
|
|
}
|
|
|
|
//SLOGD("[libshowlogo] ERROR read fail errorno: %d\n",errno);
|
|
//SLOGD("[libshowlogo] ERROR read fail error_msg: %s\n",strerror(errno));
|
|
} else {
|
|
//active_optr = atoi(en_ctl.value);
|
|
active_optr = atoi(value);
|
|
if (MTK_LOG_ENABLE == 1) {
|
|
SLOGD("[libshowlogo] SysEnv read value: %d\n",active_optr);
|
|
}
|
|
}
|
|
if (MTK_LOG_ENABLE == 1) {
|
|
SLOGD("[libshowlogo] read %s : %s\n",name,value);
|
|
}
|
|
free(name);
|
|
//free(value);
|
|
close(fd);
|
|
return active_optr;
|
|
}
|
|
|
|
/*
|
|
* get default operator.
|
|
*
|
|
*/
|
|
#ifdef GLOBAL_DEVICE_DEFAULT_OPTR
|
|
static int get_default_operator(){
|
|
#if GLOBAL_DEVICE_DEFAULT_OPTR == OPTR_NUM_OP01
|
|
return OPTR_NUM_OP01;
|
|
#elif GLOBAL_DEVICE_DEFAULT_OPTR == OPTR_NUM_OP02
|
|
return OPTR_NUM_OP02;
|
|
#elif GLOBAL_DEVICE_DEFAULT_OPTR == OPTR_NUM_OP09
|
|
return OPTR_NUM_OP09;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* get system properties from device.mk file
|
|
*/
|
|
int getValue(char* key, char* defValue) {
|
|
char buf[PROPERTY_VALUE_MAX];
|
|
int len = property_get(key,buf,defValue);
|
|
if (MTK_LOG_ENABLE == 1){
|
|
SLOGD("[libshowlogo: %s %d] buf = %s, key = %s\n",__FUNCTION__,__LINE__, buf, key);
|
|
}
|
|
return (atoi(buf));
|
|
}
|
|
|
|
/*
|
|
* get Logo index when the global device feature is enabled.
|
|
*
|
|
*/
|
|
static int get_logo_index(bool isBoot)
|
|
{
|
|
int logo_index = 0;
|
|
int optrs[MAX_OPERATOR_SUPPORT];
|
|
int i = 0, j = 0, optr_index = -1, optr_number = -1;
|
|
int to_include_fast_charging = getValue("ro.vendor.mtk_fast_charging_support" , "0");
|
|
|
|
#if defined(MTK_CARRIEREXPRESS_PACK_OP01)
|
|
optrs[i++] = OPTR_NUM_OP01;
|
|
#endif
|
|
|
|
#if defined(MTK_CARRIEREXPRESS_PACK_OP02)
|
|
optrs[i++] = OPTR_NUM_OP02;
|
|
#endif
|
|
|
|
#if defined(MTK_CARRIEREXPRESS_PACK_OP09)
|
|
optrs[i++] = OPTR_NUM_OP09;
|
|
#endif
|
|
|
|
logo_index = 1;
|
|
#if !defined(MTK_ALPS_BOX_SUPPORT)
|
|
logo_index += LOGOS_COUNT_NORMAL_CHARGING_ANIM;
|
|
#endif
|
|
if( to_include_fast_charging == 1) {
|
|
logo_index += LOGOS_COUNT_FAST_CHARGING_ANIM;
|
|
}
|
|
#if defined(MSSI_MTK_WIRELESS_CHARGER_SUPPORT)
|
|
logo_index += LOGOS_COUNT_WIRELESS_CHARGING_ANIM;
|
|
#endif
|
|
|
|
// sysenv read property.
|
|
optr_number = get_active_optr();
|
|
if (optr_number == -1) {
|
|
#if !defined(GLOBAL_DEVICE_DEFAULT_OPTR)
|
|
if (MTK_LOG_ENABLE == 1) {
|
|
SLOGD("[libshowlogo: get_logo_index() - Show OM]\n");
|
|
}
|
|
if (isBoot) {
|
|
return 0;
|
|
} else {
|
|
return kernel_logo_position;
|
|
}
|
|
#else
|
|
if (MTK_LOG_ENABLE == 1) {
|
|
SLOGD("[libshowlogo: get_logo_index() - Default Operator]\n");
|
|
}
|
|
optr_number = get_default_operator();
|
|
#endif
|
|
} else {
|
|
if (MTK_LOG_ENABLE == 1) {
|
|
SLOGD("[libshowlogo: get_logo_index() - Active Optr Number : %d]\n",optr_number);
|
|
}
|
|
}
|
|
|
|
for(j = 0; j < i && j < MAX_OPERATOR_SUPPORT; j++){
|
|
if (optrs[j] == optr_number) {
|
|
if (MTK_LOG_ENABLE == 1) {
|
|
SLOGD("[libshowlogo: get_logo_index() - Active Optr Index : %d]\n",j);
|
|
}
|
|
optr_index = j;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (optr_index == -1) {
|
|
if (MTK_LOG_ENABLE == 1) {
|
|
SLOGD("[libshowlogo: get_logo_index() - Operator not present in region : %d]\n",optr_number);
|
|
}
|
|
if(isBoot) { //Show OM
|
|
return 0;
|
|
} else {
|
|
return kernel_logo_position;
|
|
}
|
|
}
|
|
if (MTK_LOG_ENABLE == 1) {
|
|
SLOGD("[libshowlogo: get_logo_index() - Logo index without Optr : %d]\n",logo_index);
|
|
}
|
|
logo_index = logo_index + optr_index*2; // calculate the LK Logo index#endif
|
|
if (MTK_LOG_ENABLE == 1) {
|
|
SLOGD("[libshowlogo: get_logo_index() - Logo index with Optr : %d]\n",logo_index);
|
|
}
|
|
if (!isBoot) {
|
|
logo_index += 1;
|
|
}
|
|
|
|
return logo_index;
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
/*
|
|
* free fstab
|
|
*
|
|
*/
|
|
void free_fstab(void)
|
|
{
|
|
}
|
|
|
|
/*
|
|
* Set charging animation version
|
|
*
|
|
*/
|
|
void set_anim_version(int version)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]set animationm_version = :%d, MAX_SUPPORT_ANIM_VER = %d", __FUNCTION__, __LINE__, version, MAX_SUPPORT_ANIM_VER);
|
|
}
|
|
if ((version > (MAX_SUPPORT_ANIM_VER)) || (version < VERION_OLD_ANIMATION))
|
|
{
|
|
show_animationm_ver = VERION_OLD_ANIMATION;
|
|
}
|
|
else
|
|
{
|
|
show_animationm_ver = version;
|
|
}
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]show_animationm_ver = :%d", __FUNCTION__, __LINE__, show_animationm_ver);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set charging animation drawing method
|
|
*
|
|
*/
|
|
void set_draw_mode(int draw_mode)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]0 --use framebuffer, 1--use surface flinger ,draw_anim_mode = :%d", __FUNCTION__, __LINE__, draw_mode);
|
|
}
|
|
if ((draw_mode != (DRAW_ANIM_MODE_FB)) && (draw_mode != (DRAW_ANIM_MODE_SURFACE)))
|
|
{
|
|
draw_anim_mode = DRAW_ANIM_MODE_SURFACE;
|
|
}
|
|
else
|
|
{
|
|
draw_anim_mode = draw_mode;
|
|
}
|
|
}
|
|
|
|
/* return value:
|
|
* 0, error or read nothing
|
|
* !0, read counts
|
|
*/
|
|
int read_from_file(const char *path, char *buf, int size)
|
|
{
|
|
if (!path)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int fd = open(path, O_RDONLY);
|
|
if (fd == -1)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int count = read(fd, buf, size);
|
|
if (count > 0)
|
|
{
|
|
count = (count < size) ? count : size - 1;
|
|
while (count > 0 && buf[count - 1] == '\n')
|
|
count--;
|
|
buf[count] = '\0';
|
|
}
|
|
else
|
|
{
|
|
buf[0] = '\0';
|
|
}
|
|
|
|
close(fd);
|
|
return count;
|
|
}
|
|
|
|
int get_int_value(const char *path)
|
|
{
|
|
int size = 32;
|
|
char buf[size];
|
|
if (!read_from_file(path, buf, size))
|
|
return 0;
|
|
return atoi(buf);
|
|
}
|
|
|
|
/*
|
|
* return value:
|
|
* 1: fast charging
|
|
* 0: normal charging
|
|
*/
|
|
int get_fast_charging_state()
|
|
{
|
|
int state = get_int_value(CHARGER_FAST_PATH);
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGI("get_fast_charging_state: %d\n", state);
|
|
}
|
|
|
|
if (state != 1)
|
|
{
|
|
state = 0;
|
|
}
|
|
return state;
|
|
}
|
|
|
|
/*
|
|
* Charging animation init
|
|
*
|
|
*/
|
|
void anim_init()
|
|
{
|
|
chargingAnimationDimension.IS_DRM = 0;
|
|
fb_fd = open(FB_NODE_PATH, O_RDWR);
|
|
if (fb_fd < 0)
|
|
{
|
|
SLOGE("[libshowlogo: %s %d]open dev file fail, errno = %d trying DRM \n", __FUNCTION__, __LINE__, errno);
|
|
close(fb_fd);
|
|
int res = anim_drm_pre_init();
|
|
if(res != 0) {
|
|
SLOGE("[libshowlogo: %s %d] failed to preinit drm, charging animation will not be shown \n", __FUNCTION__, __LINE__, errno);
|
|
chargingAnimationDimension.IS_DRM = -1;
|
|
chargingAnimationDimension_ext.IS_DRM = -1;
|
|
error_flag = 1;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SLOGE("[libshowlogo: %s %d] FB_SUPPORTED with fb_fd = %d \n", __FUNCTION__, __LINE__, fb_fd);
|
|
|
|
ioctl(fb_fd, FBIOGET_VSCREENINFO, &vinfo);
|
|
ioctl(fb_fd, FBIOGET_FSCREENINFO, &finfo);
|
|
SLOGE("[libshowlogo: %s %d] IOCTL SUCCESS with fb_fd = %d \n", __FUNCTION__, __LINE__, fb_fd);
|
|
chargingAnimationDimension.HDISPLAY = vinfo.xres;
|
|
chargingAnimationDimension.VDISPLAY = vinfo.yres;
|
|
chargingAnimationDimension.FB_BPP = vinfo.bits_per_pixel;
|
|
chargingAnimationDimension.FB_WIDTH = vinfo.xres_virtual;
|
|
chargingAnimationDimension.IS_DRM = 0;
|
|
SLOGD("[libshowlogo: %s %d] LCD 1 - FB_SUPPORTED HDISPLAY= %d VDISPLAY= %d FB_BPP= %d FB_WIDTH= %d \n", __FUNCTION__, __LINE__, chargingAnimationDimension.HDISPLAY, chargingAnimationDimension.VDISPLAY, chargingAnimationDimension.FB_BPP, chargingAnimationDimension.FB_WIDTH);
|
|
|
|
ioctl(fb_fd, FBIOGET_VSCREENINFO, &vinfo_ext);
|
|
ioctl(fb_fd, FBIOGET_FSCREENINFO, &finfo_ext);
|
|
SLOGE("[libshowlogo: %s %d] IOCTL SUCCESS with fb_fd = %d \n", __FUNCTION__, __LINE__, fb_fd);
|
|
chargingAnimationDimension_ext.HDISPLAY = vinfo_ext.xres;
|
|
chargingAnimationDimension_ext.VDISPLAY = vinfo_ext.yres;
|
|
chargingAnimationDimension_ext.FB_BPP = vinfo_ext.bits_per_pixel;
|
|
chargingAnimationDimension_ext.FB_WIDTH = vinfo_ext.xres_virtual;
|
|
chargingAnimationDimension_ext.IS_DRM = 0;
|
|
SLOGD("[libshowlogo: %s %d] LCD 2 - FB_SUPPORTED HDISPLAY= %d VDISPLAY= %d FB_BPP= %d FB_WIDTH= %d \n", __FUNCTION__, __LINE__, chargingAnimationDimension_ext.HDISPLAY, chargingAnimationDimension_ext.VDISPLAY, chargingAnimationDimension_ext.FB_BPP, chargingAnimationDimension_ext.FB_WIDTH);
|
|
}
|
|
|
|
init_charging_animation_ui_dimension();
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
}
|
|
anim_logo_init();
|
|
|
|
if (chargingAnimationDimension.IS_DRM == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]DRM init in progress \n", __FUNCTION__, __LINE__);
|
|
anim_drm_init();
|
|
}
|
|
else
|
|
{
|
|
SLOGD("[libshowlogo: %s %d] FB init in progress \n", __FUNCTION__, __LINE__);
|
|
if (draw_anim_mode == (DRAW_ANIM_MODE_FB))
|
|
{
|
|
anim_fb_init();
|
|
}
|
|
else
|
|
{
|
|
anim_surface_init();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Charging animation set buffer address
|
|
*
|
|
*/
|
|
|
|
void anim_set_buffer_address(int index)
|
|
{
|
|
if (index == BOOT_LOGO_INDEX)
|
|
{
|
|
fb_addr = lk_fb_addr;
|
|
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
fb_addr_ext = lk_fb_addr_ext;
|
|
}
|
|
else if (index == kernel_logo_position)
|
|
{
|
|
fb_addr = kernel_fb_addr;
|
|
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
fb_addr_ext = kernel_fb_addr_ext;
|
|
}
|
|
else
|
|
{
|
|
anim_fb_addr_switch();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Charging animation deinit
|
|
*
|
|
*/
|
|
void anim_deinit()
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
}
|
|
anim_logo_deinit();
|
|
|
|
if (chargingAnimationDimension.IS_DRM == 1)
|
|
{
|
|
anim_drm_deinit();
|
|
}
|
|
else
|
|
{
|
|
if (draw_anim_mode == (DRAW_ANIM_MODE_FB))
|
|
{
|
|
anim_fb_deinit();
|
|
}
|
|
else
|
|
{
|
|
anim_surface_deinit();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
*
|
|
* To calculate logo offset for logo_2 in case of multibin
|
|
* fd - recieves fd for logo.img
|
|
* return offset value for logo_2
|
|
*
|
|
*/
|
|
static unsigned long calculate_logo2_offset (int fd)
|
|
{
|
|
int len = 0;
|
|
unsigned long offset = 0;
|
|
part_hdr_t para;
|
|
SLOGD("[libshowlogo: %s %d] \n", __FUNCTION__, __LINE__);
|
|
for(int i = 0; i < 3; i++) {
|
|
// skip logo 1
|
|
len = read(fd,¶,sizeof(part_hdr_t));
|
|
|
|
SLOGD("[libshowlogo: %s %d] looping in logo data, loop= %d len= %d \n", __FUNCTION__, __LINE__, i, len);
|
|
|
|
if(strcmp(para.info.name, "logo") == 0)
|
|
{
|
|
set_logo_multibin_status(false);
|
|
lseek(fd, 0, SEEK_SET);
|
|
SLOGD("[libshowlogo: %s %d] Singlebin logo\n", __FUNCTION__, __LINE__);
|
|
return offset;
|
|
}
|
|
|
|
offset += sizeof(union part_hdr_t) + ROUNDUP(para.info.dsz, para.info.align_sz);
|
|
off_t off_seek = lseek(fd,offset,0);
|
|
if (off_seek == -1) {
|
|
SLOGD("[libshowlogo: %s %d] - lseek failed \n",__FUNCTION__, __LINE__);
|
|
offset = 0;
|
|
return offset;
|
|
}
|
|
}
|
|
SLOGD("[libshowlogo: %s %d] Multibin logo\n", __FUNCTION__, __LINE__);
|
|
SLOGD("[libshowlogo: %s %d] return offset = %lu \n", __FUNCTION__, __LINE__, offset);
|
|
set_logo_multibin_status(true);
|
|
return offset;
|
|
}
|
|
|
|
/*
|
|
* Charging animation logo.bin related init
|
|
*
|
|
*/
|
|
void anim_logo_init(void)
|
|
{
|
|
// read and de-compress logo data here
|
|
int fd = 0;
|
|
int len = 0;
|
|
SLOGD("[libshowlogo: %s %d]",__FUNCTION__, __LINE__);
|
|
|
|
fd = open("/dev/block/by-name/logo", O_RDONLY);
|
|
|
|
if (fd > 0){
|
|
SLOGD("[libshowlogo: %s %d] - /logo as active slot \n", __FUNCTION__, __LINE__);
|
|
}
|
|
else
|
|
{
|
|
fd = open("/dev/block/by-name/logo_a", O_RDONLY);
|
|
SLOGD("[libshowlogo: %s %d] - /logo_a as active logo slot \n", __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
// for calulating offset in case of multi-bin logo
|
|
logo_offset = calculate_logo2_offset(fd);
|
|
|
|
//single bin
|
|
if(!get_logo_multibin_status())
|
|
{
|
|
// if single-bin is found, use fd
|
|
logo_addr = (uint64_t *)malloc(LOGO_BUFFER_SIZE);
|
|
|
|
if (logo_addr == NULL)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
//single bin
|
|
SLOGE("[libshowlogo: %s %d]allocate logo buffer fail \n", __FUNCTION__, __LINE__);
|
|
}
|
|
goto error_return;
|
|
}
|
|
// skip image header
|
|
len = read(fd, logo_addr, 512);
|
|
if (len < 0)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGE("[libshowlogo: %s %d]read from logo addr for buffer is failed! \n", __FUNCTION__, __LINE__);
|
|
}
|
|
goto error_return;
|
|
}
|
|
|
|
// read the img data
|
|
len = read(fd, logo_addr, LOGO_BUFFER_SIZE - 512);
|
|
}
|
|
else
|
|
{ // multibin
|
|
part_hdr_t para;
|
|
|
|
// skip img header
|
|
len = read(fd,¶,sizeof(part_hdr_t));
|
|
SLOGD("\n ========== \n magic = %x \n dsize = %x \n name = %s offset = %lu len = %d \n", para.info.magic , para.info.dsz, para.info.name, logo_offset, len);
|
|
logo_addr = (uint64_t *)malloc(para.info.dsz);
|
|
|
|
if (logo_addr == NULL)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGE("[libshowlogo: %s %d]allocate logo buffer fail, size=0x%08x \n", __FUNCTION__, __LINE__, LOGO_BUFFER_SIZE);
|
|
}
|
|
goto error_return;
|
|
}
|
|
if (para.info.dsz <= sizeof(part_hdr_t)) {
|
|
SLOGE("[libshowlogo: %s %d]para.info.dsz is wrong, dsize = %x \n", __FUNCTION__, __LINE__, para.info.dsz);
|
|
goto error_return;
|
|
}
|
|
// (1) read the image
|
|
len = read(fd, logo_addr, para.info.dsz);
|
|
}
|
|
|
|
if (len < 0)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGE("[libshowlogo: %s %d]read from logo addr for buffer is failed! \n", __FUNCTION__, __LINE__);
|
|
}
|
|
goto error_return;
|
|
}
|
|
close(fd);
|
|
|
|
if (show_animationm_ver > 0)
|
|
{
|
|
unsigned int *pinfo = (unsigned int *)logo_addr;
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]pinfo[0]=%d, pinfo[1]=%d\n", __FUNCTION__, __LINE__, pinfo[0], pinfo[1]);
|
|
}
|
|
|
|
if ((show_animationm_ver == VERION_WIRELESS_CHARGING_ANIMATION) && (pinfo[0] < ANIM_V2_LOGO_NUM))
|
|
{
|
|
set_anim_version(VERION_NEW_ANIMATION);
|
|
}
|
|
if (pinfo[0] < ANIM_V1_LOGO_NUM)
|
|
{
|
|
kernel_logo_position = ANIM_V0_LOGO_NUM - 1;
|
|
set_anim_version(VERION_OLD_ANIMATION);
|
|
}
|
|
}
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]show_animationm_ver = :%d", __FUNCTION__, __LINE__, show_animationm_ver);
|
|
}
|
|
SLOGD("[libshowlogo: %s %d]",__FUNCTION__, __LINE__);
|
|
return;
|
|
|
|
error_return:
|
|
if (fd >= 0)
|
|
{
|
|
close(fd);
|
|
}
|
|
sleep(3);
|
|
error_flag = 1;
|
|
SLOGD("[libshowlogo: %s %d] error return !!!\n", __FUNCTION__, __LINE__);
|
|
// to prevent interlace operation with MD reset
|
|
}
|
|
|
|
/*
|
|
* Charging animation logo.bin related deinit
|
|
*
|
|
*/
|
|
void anim_logo_deinit(void)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
}
|
|
free_fstab();
|
|
free(logo_addr);
|
|
logo_addr = NULL;
|
|
free(dec_logo_addr);
|
|
dec_logo_addr = NULL;
|
|
}
|
|
|
|
/*
|
|
* Charging animation framebuffer related init
|
|
*
|
|
*/
|
|
int anim_fb_init(void)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
}
|
|
fb_size = finfo.line_length * vinfo.yres;
|
|
dec_logo_addr = (uint64_t *)malloc(fb_size);
|
|
|
|
if (dec_logo_addr == NULL)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGE("[libshowlogo: %s %d]allocate dec_logo_addr buffer fail \n", __FUNCTION__, __LINE__);
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
lk_fb_addr = (unsigned int *)mmap(0, fb_size * 3, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);
|
|
charging_fb_addr = (unsigned int *)((uint64_t) lk_fb_addr + fb_size);
|
|
kernel_fb_addr = (unsigned int *)((uint64_t) charging_fb_addr + fb_size);
|
|
fb_addr = lk_fb_addr;
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]vinfo:xres = %d, yres = %d, xres_virtual =%d, bits_per_pixel = %d,red.offset = %d,blue.offset = %d\n", __FUNCTION__, __LINE__, vinfo.xres, vinfo.yres, vinfo.xres_virtual, vinfo.bits_per_pixel, vinfo.red.offset, vinfo.blue.offset);
|
|
SLOGD("[libshowlogo: %s %d]fb_size =%d, fb_addr = %ld,charging_fb_addr=%ld\n", __FUNCTION__, __LINE__, fb_size, (long)fb_addr, (long)charging_fb_addr);
|
|
}
|
|
|
|
if (fb_addr == NULL || charging_fb_addr == NULL)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
SLOGE("ChargingAnimation mmap for 1st LCD failed\n");
|
|
|
|
munmap(lk_fb_addr, fb_size * 2);
|
|
close(fb_fd);
|
|
error_flag = 1;
|
|
return -1;
|
|
}
|
|
|
|
phical_screen.bits_per_pixel = chargingAnimationDimension.FB_BPP;
|
|
phical_screen.fill_dst_bits = chargingAnimationDimension.FB_BPP;
|
|
phical_screen.red_offset = vinfo.red.offset;
|
|
phical_screen.blue_offset = vinfo.blue.offset;
|
|
phical_screen.width = chargingAnimationDimension.HDISPLAY;
|
|
phical_screen.height = chargingAnimationDimension.VDISPLAY;
|
|
phical_screen.allignWidth = fb_size / (((chargingAnimationDimension.FB_BPP / 8) * chargingAnimationDimension.VDISPLAY));
|
|
phical_screen.needAllign = 1;
|
|
phical_screen.need180Adjust = 1;
|
|
phical_screen.fb_size = fb_size;
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
SLOGD("[libshowlogo: %s %d]MTK_LCM_PHYSICAL_ROTATION = %s\n", __FUNCTION__, __LINE__, MTK_LCM_PHYSICAL_ROTATION);
|
|
|
|
int rotation = getRotation();
|
|
if (MTK_LOG_ENABLE == 1)
|
|
SLOGD("[libshowlogo: %s %d]rotation = %d\n", __FUNCTION__, __LINE__, rotation);
|
|
|
|
if (ORIENTATION_270 == rotation) //270
|
|
phical_screen.rotation = 270;
|
|
else if (ORIENTATION_90 == rotation) //90
|
|
phical_screen.rotation = 90;
|
|
else if ((ORIENTATION_180 == rotation) && (phical_screen.need180Adjust == 1)) //180
|
|
phical_screen.rotation = 180;
|
|
else
|
|
phical_screen.rotation = 0;
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo]phical_screen: width= %d,height= %d,bits_per_pixel =%d,needAllign = %d,allignWidth=%d rotation =%d ,need180Adjust = %d\n",
|
|
phical_screen.width, phical_screen.height,
|
|
phical_screen.bits_per_pixel, phical_screen.needAllign,
|
|
phical_screen.allignWidth, phical_screen.rotation, phical_screen.need180Adjust);
|
|
SLOGD("[libshowlogo: %s %d]show old animtion= 1, running show_animationm_ver %d\n", __FUNCTION__, __LINE__, show_animationm_ver);
|
|
SLOGD("[libshowlogo: %s %d]draw_anim_mode = 1, running mode %d\n", __FUNCTION__, __LINE__, draw_anim_mode);
|
|
}
|
|
|
|
//dualdisplay - start
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
{
|
|
phical_screen_ext.bits_per_pixel = chargingAnimationDimension_ext.FB_BPP;
|
|
phical_screen_ext.fill_dst_bits = chargingAnimationDimension_ext.FB_BPP;
|
|
phical_screen_ext.red_offset = vinfo_ext.red.offset;
|
|
phical_screen_ext.blue_offset = vinfo_ext.blue.offset;
|
|
phical_screen_ext.width = chargingAnimationDimension_ext.HDISPLAY;
|
|
phical_screen_ext.height = chargingAnimationDimension_ext.VDISPLAY;
|
|
phical_screen_ext.allignWidth = fb_size_ext / (((chargingAnimationDimension_ext.FB_BPP / 8) * chargingAnimationDimension_ext.VDISPLAY));
|
|
phical_screen_ext.needAllign = 1;
|
|
phical_screen_ext.need180Adjust = 1;
|
|
phical_screen_ext.fb_size = fb_size_ext;
|
|
//dualdisplay - 2nd LCD not to support rotation
|
|
phical_screen_ext.rotation = 0;
|
|
|
|
fb_size_ext = finfo_ext.line_length * vinfo_ext.yres;
|
|
lk_fb_addr_ext = (unsigned int *)mmap(0, fb_size_ext * 3, PROT_READ | PROT_WRITE, MAP_SHARED, fb_fd, 0);
|
|
charging_fb_addr_ext = (unsigned int *)((uint64_t) lk_fb_addr_ext + fb_size_ext);
|
|
kernel_fb_addr_ext = (unsigned int *)((uint64_t) charging_fb_addr_ext + fb_size_ext);
|
|
fb_addr_ext = lk_fb_addr_ext;
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]vinfo_ext:xres = %d, yres = %d, xres_virtual =%d, bits_per_pixel = %d,red.offset = %d,blue.offset = %d\n", __FUNCTION__, __LINE__, vinfo_ext.xres, vinfo_ext.yres, vinfo_ext.xres_virtual, vinfo_ext.bits_per_pixel, vinfo_ext.red.offset, vinfo_ext.blue.offset);
|
|
SLOGD("[libshowlogo: %s %d]fb_size_ext =%d, fb_addr_ext = %ld,charging_fb_addr_ext=%ld\n", __FUNCTION__, __LINE__, fb_size_ext, (long)fb_addr_ext, (long)charging_fb_addr_ext);
|
|
}
|
|
if (fb_addr_ext == NULL || charging_fb_addr_ext == NULL)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGE("ChargingAnimation mmap for 2nd LCD failed\n");
|
|
}
|
|
munmap(lk_fb_addr, fb_size * 2);
|
|
munmap(lk_fb_addr_ext, fb_size_ext * 2);
|
|
close(fb_fd);
|
|
error_flag = 1;
|
|
|
|
return -1;
|
|
}
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
//dualdisplay
|
|
SLOGD("[libshowlogo]phical_screen_ext: width= %d,height= %d,bits_per_pixel =%d,needAllign = %d,allignWidth=%d rotation =%d ,need180Adjust = %d\n",
|
|
phical_screen_ext.width, phical_screen_ext.height,
|
|
phical_screen_ext.bits_per_pixel, phical_screen_ext.needAllign,
|
|
phical_screen_ext.allignWidth, phical_screen_ext.rotation, phical_screen_ext.need180Adjust);
|
|
}
|
|
}
|
|
//dualdisplay - end
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Charging animation framebuffer related deinit
|
|
*
|
|
*/
|
|
void anim_fb_deinit(void)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
|
|
munmap(lk_fb_addr, fb_size * 3);
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
munmap(lk_fb_addr_ext, fb_size_ext * 3);
|
|
|
|
close(fb_fd);
|
|
}
|
|
|
|
/*
|
|
* Charging animation framebuffer switch buffer
|
|
*
|
|
*/
|
|
void anim_fb_addr_switch(void)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]use_double_addr =%d \n", __FUNCTION__, __LINE__, use_double_addr);
|
|
}
|
|
if (use_double_addr == 0)
|
|
{
|
|
use_double_addr++;
|
|
fb_addr = kernel_fb_addr;
|
|
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
fb_addr_ext = kernel_fb_addr_ext;
|
|
}
|
|
else
|
|
{
|
|
use_double_addr = 0;
|
|
fb_addr = charging_fb_addr;
|
|
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
fb_addr_ext = charging_fb_addr_ext;
|
|
}
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]LCD 1 - fb_addr =%ld \n", __FUNCTION__, __LINE__, (long)fb_addr);
|
|
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
SLOGD("[libshowlogo: %s %d]LCD 2 - fb_addr_ext =%ld \n", __FUNCTION__, __LINE__, (long)fb_addr_ext);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Charging animation framebuffer update
|
|
*
|
|
*/
|
|
void anim_fb_disp_update(void)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
if (fb_addr == charging_fb_addr)
|
|
{
|
|
vinfo.yoffset = vinfo.yres;
|
|
}
|
|
else if (fb_addr == kernel_fb_addr)
|
|
{
|
|
vinfo.yoffset = vinfo.yres * 2;
|
|
}
|
|
else
|
|
{
|
|
vinfo.yoffset = 0;
|
|
}
|
|
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
{
|
|
if (fb_addr_ext == charging_fb_addr_ext)
|
|
{
|
|
vinfo_ext.yoffset = vinfo_ext.yres;
|
|
}
|
|
else if (fb_addr_ext == kernel_fb_addr_ext)
|
|
{
|
|
vinfo_ext.yoffset = vinfo_ext.yres * 2;
|
|
}
|
|
else
|
|
{
|
|
vinfo_ext.yoffset = 0;
|
|
}
|
|
}
|
|
vinfo.activate |= (FB_ACTIVATE_FORCE | FB_ACTIVATE_NOW);
|
|
vinfo_ext.activate |= (FB_ACTIVATE_FORCE | FB_ACTIVATE_NOW);
|
|
|
|
if (ioctl(fb_fd, FBIOPUT_VSCREENINFO, &vinfo) < 0)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGE("ioctl FBIOPUT_VSCREENINFO for LCD 1 - flip failed\n");
|
|
}
|
|
}
|
|
|
|
if ((is_ext_lcd_present()) && (ioctl(fb_fd, FBIOPUT_VSCREENINFO, &vinfo_ext) < 0))
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGE("ioctl FBIOPUT_VSCREENINFO for LCD 2 - flip failed\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Charging animation surface flinger related init
|
|
*
|
|
*/
|
|
void anim_surface_init(void)
|
|
{
|
|
#if 0
|
|
SurfaceComposerClient::Transaction t;
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
}
|
|
client = new SurfaceComposerClient();
|
|
|
|
const sp<IBinder> dtoken = SurfaceComposerClient::getInternalDisplayToken();
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]ChargingAnimation getDisplayInfo()...\n", __FUNCTION__, __LINE__);
|
|
}
|
|
status_t status = SurfaceComposerClient::getActiveDisplayConfig(dtoken, &dinfo);
|
|
SurfaceComposerClient::getDisplayState(dtoken, &mDisplayState);
|
|
|
|
if (status)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]error=%x %d", __FUNCTION__, __LINE__, status, status);
|
|
}
|
|
}
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
// FIXME: orientation need to get from DisplayInfo
|
|
SLOGD("[libshowlogo: %s %d]dinfo.w=%d,dinfo.h=%d\n", __FUNCTION__, __LINE__, dinfo.resolution.getWidth(), dinfo.resolution.getHeight());
|
|
SLOGD("[libshowlogo: %s %d]set default orientation\n", __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
t.setDisplayProjection(dtoken, mDisplayState.orientation, Rect(dinfo.resolution.getWidth(), dinfo.resolution.getHeight()), Rect(dinfo.resolution.getWidth(), dinfo.resolution.getHeight()));
|
|
t.apply();
|
|
|
|
int dinfo_width = dinfo.resolution.getWidth();
|
|
int dinfo_height = dinfo.resolution.getHeight();
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]dinfo_width=%d, dinfo_height=%d \n", __FUNCTION__, __LINE__, dinfo_width, dinfo_height);
|
|
}
|
|
|
|
surfaceControl = client->createSurface(String8("charging-surface"), dinfo_width, dinfo_height, PIXEL_FORMAT_BGRA_8888);
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]set layer geometry\n", __FUNCTION__, __LINE__);
|
|
}
|
|
// set layer geometry
|
|
t.setLayer(surfaceControl, 2000000)
|
|
.apply();
|
|
|
|
// data structure to access surface content
|
|
surface = surfaceControl->getSurface();
|
|
|
|
phical_screen.width = dinfo.resolution.getWidth();
|
|
phical_screen.height = dinfo.resolution.getHeight();
|
|
// for we adjust the roration avove, so no need to consider rotation
|
|
phical_screen.rotation = 0;
|
|
phical_screen.need180Adjust = 0;
|
|
|
|
int err;
|
|
int fenceFd = -1;
|
|
ANativeWindow *window = surface.get();
|
|
status_t result = native_window_api_connect(window, NATIVE_WINDOW_API_CPU);
|
|
if (result == NO_ERROR)
|
|
{
|
|
err = window->dequeueBuffer(window, &buf, &fenceFd);
|
|
sp<Fence> mFence(new Fence(fenceFd));
|
|
mFence->wait(Fence::TIMEOUT_NEVER);
|
|
if (err)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGE("[libshowlogo: %s %d]%s\n", __FUNCTION__, __LINE__, strerror(-err));
|
|
}
|
|
}
|
|
gb = GraphicBuffer::from(buf);
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]gb->getStride(): %d\n", __FUNCTION__, __LINE__, gb->getStride());
|
|
}
|
|
/* phical_screen: needAllign and need180Adjust need confirm */
|
|
phical_screen.needAllign = 1;
|
|
phical_screen.allignWidth = gb->getStride();
|
|
|
|
window->cancelBuffer(window, buf, fenceFd);
|
|
|
|
// use PIXEL_FORMAT_RGBA_8888 for surface flinger
|
|
phical_screen.bits_per_pixel = 32;
|
|
phical_screen.fill_dst_bits = 32;
|
|
fb_size = dinfo.resolution.getWidth() * dinfo.resolution.getHeight() * 4;
|
|
|
|
dec_logo_addr = malloc(fb_size);
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]fb_size =%d\n", __FUNCTION__, __LINE__, fb_size);
|
|
}
|
|
|
|
phical_screen.fb_size = fb_size;
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[show_logo_common] phical_screen: width= %d,height= %d,bits_per_pixel =%d,needAllign = %d,allignWidth=%d rotation =%d ,need180Adjust = %d\n",
|
|
phical_screen.width, phical_screen.height, phical_screen.bits_per_pixel, phical_screen.needAllign, phical_screen.allignWidth, phical_screen.rotation, phical_screen.need180Adjust);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* Charging animation surface flinger related deinit
|
|
*
|
|
*/
|
|
void anim_surface_deinit(void)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
}
|
|
surface = surfaceControl->getSurface();
|
|
ANativeWindow *window = surface.get();
|
|
//dualdisplay - TBD
|
|
native_window_api_disconnect(window, NATIVE_WINDOW_API_CPU);
|
|
//surfaceControl->release(); // TODO : Find alternate method to release surface. Done for build error
|
|
client->dispose();
|
|
}
|
|
|
|
/*
|
|
* Show special logo with the index in logo.bin
|
|
*
|
|
*/
|
|
void anim_show_logo(int index)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]draw_anim_mode=%d, show index = %d\n", __FUNCTION__, __LINE__, draw_anim_mode, index);
|
|
}
|
|
|
|
if (draw_anim_mode == (DRAW_ANIM_MODE_FB))
|
|
{
|
|
anim_set_buffer_address(index);
|
|
fill_animation_logo(get_actual_logo_index(index), fb_addr, dec_logo_addr, logo_addr, phical_screen);
|
|
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
fill_animation_logo(get_actual_logo_index(index), fb_addr_ext, dec_logo_addr, logo_addr, phical_screen_ext);
|
|
|
|
if (chargingAnimationDimension.IS_DRM == 1)
|
|
anim_drm_disp_update();
|
|
else
|
|
anim_fb_disp_update();
|
|
}
|
|
else
|
|
{
|
|
ARect tmpRect, tmpRect_ext;
|
|
|
|
tmpRect.left = 0;
|
|
tmpRect.top = 0;
|
|
tmpRect.right = phical_screen.width;
|
|
tmpRect.bottom = phical_screen.height;
|
|
|
|
tmpRect_ext.left = 0;
|
|
tmpRect_ext.top = 0;
|
|
tmpRect_ext.right = phical_screen_ext.width;
|
|
tmpRect_ext.bottom = phical_screen_ext.height;
|
|
|
|
status_t lockResult = surface->lock(&outBuffer, &tmpRect);
|
|
status_t lockResult_ext = surface_ext->lock(&outBuffer_ext, &tmpRect_ext);
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]outBuffer.bits = %ld\n", __FUNCTION__, __LINE__, (long)outBuffer.bits);
|
|
SLOGD("[libshowlogo: %s %d]surface->lock return = 0x%08x, %d\n", __FUNCTION__, __LINE__, lockResult, lockResult);
|
|
|
|
SLOGD("[libshowlogo: %s %d]outBuffer_ext.bits = %ld\n", __FUNCTION__, __LINE__, (long)outBuffer_ext.bits);
|
|
SLOGD("[libshowlogo: %s %d]ext surface->lock return = 0x%08x, %d\n", __FUNCTION__, __LINE__, lockResult_ext, lockResult_ext);
|
|
}
|
|
if (0 == lockResult)
|
|
{
|
|
fill_animation_logo(get_actual_logo_index(index), (void *)outBuffer.bits, dec_logo_addr, logo_addr, phical_screen);
|
|
fill_animation_logo(get_actual_logo_index(index), (void *)outBuffer_ext.bits, dec_logo_addr, logo_addr, phical_screen_ext);
|
|
surface->unlockAndPost();
|
|
surface_ext->unlockAndPost();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Show first boot logo when phone boot up
|
|
*
|
|
*/
|
|
void show_boot_logo(void)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]show boot logo, index = 0 \n", __FUNCTION__, __LINE__);
|
|
}
|
|
if (error_flag == 0)
|
|
{
|
|
|
|
anim_show_logo(BOOT_LOGO_INDEX);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Show kernel logo when phone boot up
|
|
*
|
|
*/
|
|
void show_kernel_logo()
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]show kernel logo, index = 38 \n", __FUNCTION__, __LINE__);
|
|
}
|
|
if (error_flag == 0)
|
|
{
|
|
anim_show_logo(kernel_logo_position);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Show low battery logo
|
|
*
|
|
*/
|
|
void show_low_battery(void)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]show low battery logo, index = 2 \n", __FUNCTION__, __LINE__);
|
|
}
|
|
if (error_flag == 0)
|
|
{
|
|
anim_show_logo(LOW_BATTERY_INDEX);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Show charging over logo
|
|
*
|
|
*/
|
|
void show_charger_ov_logo(void)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]show charger_ov logo, index = 3 \n", __FUNCTION__, __LINE__);
|
|
}
|
|
if (error_flag == 0)
|
|
{
|
|
anim_show_logo(CHARGER_OV_INDEX);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Draw black screen
|
|
*
|
|
*/
|
|
void show_black_logo(void)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
|
|
if (draw_anim_mode == (DRAW_ANIM_MODE_FB))
|
|
{
|
|
anim_fb_addr_switch();
|
|
memset((unsigned short *)fb_addr, 0x00, fb_size);
|
|
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
memset((unsigned short *)fb_addr_ext, 0x00, fb_size_ext);
|
|
|
|
if (chargingAnimationDimension.IS_DRM == 1)
|
|
anim_drm_disp_update();
|
|
else
|
|
anim_fb_disp_update();
|
|
}
|
|
else
|
|
{
|
|
ARect tmpRect, tmpRect_ext;
|
|
|
|
tmpRect.left = 0;
|
|
tmpRect.top = 0;
|
|
tmpRect.right = phical_screen.width;
|
|
tmpRect.bottom = phical_screen.height;
|
|
|
|
tmpRect_ext.left = 0;
|
|
tmpRect_ext.top = 0;
|
|
tmpRect_ext.right = phical_screen_ext.width;
|
|
tmpRect_ext.bottom = phical_screen_ext.height;
|
|
|
|
status_t lockResult = surface->lock(&outBuffer, &tmpRect);
|
|
status_t lockResult_ext = surface_ext->lock(&outBuffer_ext, &tmpRect_ext);
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]outBuffer.bits = %ld, surface->lock return = 0x%08x,\n", __FUNCTION__, __LINE__, (long)outBuffer.bits, lockResult);
|
|
SLOGD("[libshowlogo: %s %d]outBuffer_ext.bits = %ld, surface->lock return = 0x%08x,\n", __FUNCTION__, __LINE__, (long)outBuffer_ext.bits, lockResult);
|
|
}
|
|
if (0 == lockResult)
|
|
{
|
|
ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format);
|
|
ssize_t bpr_ext = outBuffer_ext.stride * bytesPerPixel(outBuffer_ext.format);
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]bpr = %d\n", __FUNCTION__, __LINE__, (int)bpr);
|
|
SLOGD("[libshowlogo: %s %d]bpr_ext = %d\n", __FUNCTION__, __LINE__, (int)bpr_ext);
|
|
}
|
|
memset((unsigned short *)outBuffer.bits, 0x00, bpr * outBuffer.height);
|
|
memset((unsigned short *)outBuffer_ext.bits, 0x00, bpr_ext * outBuffer_ext.height);
|
|
|
|
surface->unlockAndPost();
|
|
surface_ext->unlockAndPost();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Show charging animation with battery capacity
|
|
*
|
|
*/
|
|
void show_battery_capacity(unsigned int capacity)
|
|
{
|
|
bool ext_lcd_supported = false;
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]capacity =%d\n", __FUNCTION__, __LINE__, capacity);
|
|
}
|
|
if(chargingAnimationDimension.IS_DRM == -1) {
|
|
SLOGE("[libshowlogo: %s %d]DRM was failed. no animation will be there \n", __FUNCTION__, __LINE__);
|
|
return;
|
|
}
|
|
ext_lcd_supported = is_ext_lcd_present();
|
|
int has_fast_charging = getValue("ro.vendor.mtk_fast_charging_support", "0");
|
|
if (draw_anim_mode == (DRAW_ANIM_MODE_FB))
|
|
{
|
|
anim_fb_addr_switch();
|
|
if (has_fast_charging == 1)
|
|
{
|
|
if (2 != show_animationm_ver && get_fast_charging_state())
|
|
{
|
|
fill_animation_battery_fast_charging(capacity, (void *)fb_addr, dec_logo_addr, logo_addr, phical_screen, draw_anim_mode);
|
|
|
|
if (ext_lcd_supported) //2nd lcd present
|
|
fill_animation_battery_fast_charging(capacity, (void *)fb_addr_ext, dec_logo_addr, logo_addr, phical_screen_ext, draw_anim_mode);
|
|
}
|
|
else
|
|
{
|
|
fill_animation_battery_by_ver(capacity, (void *)fb_addr, dec_logo_addr, logo_addr, phical_screen, show_animationm_ver);
|
|
|
|
if (ext_lcd_supported) //2nd lcd present
|
|
fill_animation_battery_by_ver(capacity, (void *)fb_addr_ext, dec_logo_addr, logo_addr, phical_screen_ext, draw_anim_mode);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fill_animation_battery_by_ver(capacity, (void *)fb_addr, dec_logo_addr, logo_addr, phical_screen, show_animationm_ver);
|
|
|
|
if (ext_lcd_supported) //2nd lcd present
|
|
fill_animation_battery_by_ver(capacity, (void *)fb_addr_ext, dec_logo_addr, logo_addr, phical_screen_ext, draw_anim_mode);
|
|
}
|
|
|
|
if (chargingAnimationDimension.IS_DRM == 1)
|
|
anim_drm_disp_update();
|
|
else
|
|
anim_fb_disp_update();
|
|
}
|
|
else
|
|
{
|
|
ARect tmpRect, tmpRect_ext;
|
|
|
|
tmpRect.left = 0;
|
|
tmpRect.top = 0;
|
|
tmpRect.right = phical_screen.width;
|
|
tmpRect.bottom = phical_screen.height;
|
|
|
|
tmpRect_ext.left = 0;
|
|
tmpRect_ext.top = 0;
|
|
tmpRect_ext.right = phical_screen.width;
|
|
tmpRect_ext.bottom = phical_screen.height;
|
|
|
|
status_t lockResult = surface->lock(&outBuffer, &tmpRect);
|
|
status_t lockResult_ext = surface_ext->lock(&outBuffer_ext, &tmpRect_ext);
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]outBuffer.bits = %ld, surface->lock return = 0x%08x,\n", __FUNCTION__, __LINE__, (long)outBuffer.bits, lockResult);
|
|
SLOGD("[libshowlogo: %s %d]outBuffer_ext.bits = %ld, surface->lock return = 0x%08x,\n", __FUNCTION__, __LINE__, (long)outBuffer_ext.bits, lockResult_ext);
|
|
}
|
|
if (0 == lockResult)
|
|
{
|
|
if (has_fast_charging == 1)
|
|
{
|
|
if (2 != show_animationm_ver && get_fast_charging_state())
|
|
{
|
|
fill_animation_battery_fast_charging(capacity, (void *)outBuffer.bits, dec_logo_addr, logo_addr, phical_screen, draw_anim_mode);
|
|
fill_animation_battery_fast_charging(capacity, (void *)outBuffer_ext.bits, dec_logo_addr, logo_addr, phical_screen_ext, draw_anim_mode);
|
|
}
|
|
else
|
|
{
|
|
fill_animation_battery_by_ver(capacity, (void *)outBuffer.bits, dec_logo_addr, logo_addr, phical_screen, show_animationm_ver);
|
|
fill_animation_battery_by_ver(capacity, (void *)outBuffer_ext.bits, dec_logo_addr, logo_addr, phical_screen_ext, show_animationm_ver);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fill_animation_battery_by_ver(capacity, (void *)outBuffer.bits, dec_logo_addr, logo_addr, phical_screen, show_animationm_ver);
|
|
fill_animation_battery_by_ver(capacity, (void *)outBuffer_ext.bits, dec_logo_addr, logo_addr, phical_screen_ext, show_animationm_ver);
|
|
}
|
|
|
|
surface->unlockAndPost();
|
|
surface_ext->unlockAndPost();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Show fast charging animation with battery capacity
|
|
* code for test fast charging
|
|
*/
|
|
void show_fast_charging(unsigned int capacity)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]capacity =%d\n", __FUNCTION__, __LINE__, capacity);
|
|
}
|
|
if (draw_anim_mode == (DRAW_ANIM_MODE_FB))
|
|
{
|
|
anim_fb_addr_switch();
|
|
fill_animation_battery_fast_charging(capacity, (void *)fb_addr, dec_logo_addr, logo_addr, phical_screen, draw_anim_mode);
|
|
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
fill_animation_battery_fast_charging(capacity, (void *)fb_addr_ext, dec_logo_addr, logo_addr, phical_screen_ext, draw_anim_mode);
|
|
|
|
if (chargingAnimationDimension.IS_DRM == 1)
|
|
anim_drm_disp_update();
|
|
else
|
|
anim_fb_disp_update();
|
|
}
|
|
else
|
|
{
|
|
ARect tmpRect, tmpRect_ext;
|
|
tmpRect.left = 0;
|
|
tmpRect.top = 0;
|
|
tmpRect.right = phical_screen.width;
|
|
tmpRect.bottom = phical_screen.height;
|
|
tmpRect_ext.left = 0;
|
|
tmpRect_ext.top = 0;
|
|
tmpRect_ext.right = phical_screen_ext.width;
|
|
tmpRect_ext.bottom = phical_screen_ext.height;
|
|
status_t lockResult = surface->lock(&outBuffer, &tmpRect);
|
|
status_t lockResult_ext = surface_ext->lock(&outBuffer_ext, &tmpRect_ext);
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]LCD 1 - outBuffer.bits = %ld, surface->lock return = 0x%08x,\n", __FUNCTION__, __LINE__, (long)outBuffer.bits, lockResult);
|
|
SLOGD("[libshowlogo: %s %d]LCD 2 - ext outBuffer.bits = %ld, surface->lock return = 0x%08x,\n", __FUNCTION__, __LINE__, (long)outBuffer_ext.bits, lockResult_ext);
|
|
}
|
|
if (0 == lockResult)
|
|
{
|
|
fill_animation_battery_fast_charging(capacity, (void *)outBuffer.bits, dec_logo_addr, logo_addr, phical_screen, draw_anim_mode);
|
|
fill_animation_battery_fast_charging(capacity, (void *)outBuffer_ext.bits, dec_logo_addr, logo_addr, phical_screen_ext, draw_anim_mode);
|
|
|
|
surface->unlockAndPost();
|
|
surface_ext->unlockAndPost();
|
|
}
|
|
}
|
|
}
|
|
|
|
int anim_drm_pre_init()
|
|
{
|
|
int res = 0;
|
|
|
|
SLOGD("[libshowlogo: %s %d] drm_resource_object = %p \n", __FUNCTION__, __LINE__, &drm_resource_object);
|
|
res = init_resource(&drm_resource_object);
|
|
|
|
if(res != 0) {
|
|
SLOGD("[libshowlogo: %s %d] drm_resource pre_init failed. \n", __FUNCTION__, __LINE__);
|
|
return res;
|
|
}
|
|
|
|
SLOGD("[libshowlogo: %s %d] drm_resource_successfully initialised \n", __FUNCTION__, __LINE__);
|
|
SLOGD("[libshowlogo: %s %d] drm_resource_object = %p mconnector = %p \n",
|
|
__FUNCTION__, __LINE__, &drm_resource_object, &(drm_resource_object.mConnector));
|
|
|
|
SLOGD("[libshowlogo: %s %d] drm_resource_object = %p mconnector = %p mconnector_ext = %p \n",
|
|
__FUNCTION__, __LINE__, &drm_resource_object,
|
|
&(drm_resource_object.mConnector), &(drm_resource_object.mConnector_ext));
|
|
|
|
// map drmResouce to libdrm structure in charging animation.h
|
|
libdrmApi.DrmInfo = drm_resource_object.mConnector->mModes[0].mInfo;
|
|
libdrmApi.DrmFb = &(drm_resource_object.fb);
|
|
SLOGD("[libshowlogo: %s %d] LCD 1 drmfb saved bpp=%d", __FUNCTION__, __LINE__, drm_resource_object.fb.bpp);
|
|
|
|
// set macro to be used in show_animaton_common
|
|
chargingAnimationDimension.HDISPLAY = libdrmApi.DrmInfo.hdisplay;
|
|
chargingAnimationDimension.VDISPLAY = libdrmApi.DrmInfo.vdisplay;
|
|
chargingAnimationDimension.FB_BPP = drm_resource_object.fb.bpp;
|
|
chargingAnimationDimension.FB_WIDTH = drm_resource_object.fb.width;
|
|
chargingAnimationDimension.IS_DRM = 1;
|
|
SLOGD("[libshowlogo: %s %d] LCD 1 hdisplay = %d vdisplay = %d fb->width = %d\n",
|
|
__FUNCTION__, __LINE__, chargingAnimationDimension.HDISPLAY,
|
|
chargingAnimationDimension.VDISPLAY, drm_resource_object.fb.width);
|
|
|
|
//dualdisplay - set parameters for 2nd LCD
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
{
|
|
libdrmApi_ext.DrmInfo = drm_resource_object.mConnector_ext->mModes[0].mInfo;
|
|
libdrmApi_ext.DrmFb = &(drm_resource_object.fb_ext);
|
|
SLOGD("[libshowlogo: %s %d] LCD 2 drmfb saved bpp=%d", __FUNCTION__, __LINE__, drm_resource_object.fb.bpp);
|
|
// set macro to be used in show_animaton_common
|
|
chargingAnimationDimension_ext.HDISPLAY = libdrmApi_ext.DrmInfo.hdisplay;
|
|
chargingAnimationDimension_ext.VDISPLAY = libdrmApi_ext.DrmInfo.vdisplay;
|
|
chargingAnimationDimension_ext.FB_BPP = drm_resource_object.fb_ext.bpp;
|
|
chargingAnimationDimension_ext.FB_WIDTH = drm_resource_object.fb_ext.width;
|
|
chargingAnimationDimension_ext.IS_DRM = 1;
|
|
SLOGD("[libshowlogo: %s %d] LCD 2 hdisplay = %d vdisplay = %d fb->width = %d\n",
|
|
__FUNCTION__, __LINE__, chargingAnimationDimension_ext.HDISPLAY,
|
|
chargingAnimationDimension_ext.VDISPLAY, drm_resource_object.fb_ext.width);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
void init_drm_addresses(void)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
}
|
|
drm_fd = drm_resource_object.mDrmFd;
|
|
SLOGD("[libshowlogo: %s %d] drm_fd = %d bpp = %d bo->fd = %d", __FUNCTION__, __LINE__, drm_fd, chargingAnimationDimension.FB_BPP, drm_resource_object.mBo[drm_resource_object.mPinPon].fd);
|
|
fb_size = (chargingAnimationDimension.HDISPLAY * (chargingAnimationDimension.FB_BPP / 8)) * chargingAnimationDimension.VDISPLAY;
|
|
SLOGD("[libshowlogo: %s %d] fb_size = %u", __FUNCTION__, __LINE__, fb_size);
|
|
|
|
dec_logo_addr = (unsigned int *)malloc(fb_size);
|
|
|
|
if (dec_logo_addr == NULL)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGE("[libshowlogo: %s %d]allocate dec_logo_addr buffer fail \n", __FUNCTION__, __LINE__);
|
|
}
|
|
assert(0);
|
|
}
|
|
SLOGD("[libshowlogo: %s %d] dec_logo_addr = %p", __FUNCTION__, __LINE__, dec_logo_addr);
|
|
lk_fb_addr = (unsigned int *)drm_mmap(0, fb_size, PROT_READ | PROT_WRITE, MAP_SHARED, drm_resource_object.mBo[drm_resource_object.mPinPon].fd, 0);
|
|
SLOGD("[libshowlogo: %s %d] lk_fb_addr = %p %u", __FUNCTION__, __LINE__, lk_fb_addr, lk_fb_addr);
|
|
charging_fb_addr = (unsigned int *)drm_mmap(0, fb_size, PROT_READ | PROT_WRITE, MAP_SHARED, drm_resource_object.mBo[drm_resource_object.mPinPon].fd, 0);
|
|
SLOGD("[libshowlogo: %s %d] charging_fb_addr = %p %u", __FUNCTION__, __LINE__, charging_fb_addr, charging_fb_addr);
|
|
kernel_fb_addr = (unsigned int *)drm_mmap(0, fb_size, PROT_READ | PROT_WRITE, MAP_SHARED, drm_resource_object.mBo[drm_resource_object.mPinPon].fd, 0);
|
|
SLOGD("[libshowlogo: %s %d] kernel_fb_addr = %p %u", __FUNCTION__, __LINE__, kernel_fb_addr, kernel_fb_addr);
|
|
fb_addr = lk_fb_addr;
|
|
SLOGD("[libshowlogo: %s %d] fb_addr = %p %u", __FUNCTION__, __LINE__, fb_addr, fb_addr);
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]vinfo:xres = %d, yres = %d, xres_virtual =%d, bits_per_pixel = %d,red.offset = %d,blue.offset = %d\n", __FUNCTION__, __LINE__, chargingAnimationDimension.HDISPLAY, chargingAnimationDimension.VDISPLAY, chargingAnimationDimension.FB_WIDTH, chargingAnimationDimension.FB_BPP, 8, 24);
|
|
// in drm, bo format -> argb8888 , red.offset = 8 and blue.offset = 24
|
|
SLOGD("[libshowlogo: %s %d]fb_size =%d, fb_addr = %ld,charging_fb_addr=%ld\n", __FUNCTION__, __LINE__, fb_size, (long)fb_addr, (long)charging_fb_addr);
|
|
}
|
|
|
|
//dualdisplay - start
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
{
|
|
fb_size_ext = (chargingAnimationDimension_ext.HDISPLAY * (chargingAnimationDimension_ext.FB_BPP / 8)) * chargingAnimationDimension_ext.VDISPLAY;
|
|
SLOGD("[libshowlogo: %s %d] fb_size_ext = %u", __FUNCTION__, __LINE__, fb_size_ext);
|
|
lk_fb_addr_ext = (unsigned int *)drm_mmap(0, fb_size_ext, PROT_READ | PROT_WRITE, MAP_SHARED, drm_resource_object.mBo_ext[drm_resource_object.mPinPon_ext].fd, 0);
|
|
SLOGD("[libshowlogo: %s %d] lk_fb_addr_ext = %p %u", __FUNCTION__, __LINE__, lk_fb_addr_ext, lk_fb_addr_ext);
|
|
charging_fb_addr_ext = (unsigned int *)drm_mmap(0, fb_size_ext, PROT_READ | PROT_WRITE, MAP_SHARED, drm_resource_object.mBo_ext[drm_resource_object.mPinPon_ext].fd, 0);
|
|
SLOGD("[libshowlogo: %s %d] charging_fb_addr_ext = %p %u", __FUNCTION__, __LINE__, charging_fb_addr_ext, charging_fb_addr_ext);
|
|
kernel_fb_addr_ext = (unsigned int *)drm_mmap(0, fb_size_ext, PROT_READ | PROT_WRITE, MAP_SHARED, drm_resource_object.mBo_ext[drm_resource_object.mPinPon_ext].fd, 0);
|
|
SLOGD("[libshowlogo: %s %d] kernel_fb_addr_ext = %p %u", __FUNCTION__, __LINE__, kernel_fb_addr_ext, kernel_fb_addr_ext);
|
|
fb_addr_ext = lk_fb_addr_ext;
|
|
SLOGD("[libshowlogo: %s %d] fb_addr_ext = %p %u", __FUNCTION__, __LINE__, fb_addr_ext, fb_addr_ext);
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]vinfo_ext:xres = %d, yres = %d, xres_virtual =%d, bits_per_pixel = %d,red.offset = %d,blue.offset = %d\n",
|
|
__FUNCTION__, __LINE__, chargingAnimationDimension_ext.HDISPLAY, chargingAnimationDimension_ext.VDISPLAY,
|
|
chargingAnimationDimension_ext.FB_WIDTH, chargingAnimationDimension_ext.FB_BPP, 8, 24);
|
|
// in drm, bo format -> argb8888 , red.offset = 8 and blue.offset = 24
|
|
SLOGD("[libshowlogo: %s %d]fb_size_ext =%d, fb_addr_ext = %ld,charging_fb_addr_ext=%ld\n", __FUNCTION__, __LINE__, fb_size_ext, (long)fb_addr_ext, (long)charging_fb_addr_ext);
|
|
}
|
|
}
|
|
//dualdisplay - end
|
|
|
|
if (fb_addr == NULL || charging_fb_addr == NULL)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGE("ChargingAnimation mmap fail\n");
|
|
}
|
|
drm_munmap(charging_fb_addr, fb_size);
|
|
drm_munmap(lk_fb_addr, fb_size);
|
|
//2nd lcd present
|
|
if ((is_ext_lcd_present()) && (fb_addr_ext == NULL || charging_fb_addr_ext == NULL))
|
|
{
|
|
drm_munmap(charging_fb_addr_ext, fb_size_ext);
|
|
drm_munmap(lk_fb_addr_ext, fb_size_ext);
|
|
}
|
|
close(drm_fd);
|
|
error_flag = 1;
|
|
}
|
|
}
|
|
|
|
void free_drm_address(void) {
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
}
|
|
struct DrmBo *bo = &(drm_resource_object.mBo[drm_resource_object.mPinPon]);
|
|
|
|
if (kernel_fb_addr != NULL)
|
|
drm_munmap(kernel_fb_addr, bo->size);
|
|
if (charging_fb_addr != NULL)
|
|
drm_munmap(charging_fb_addr, bo->size);
|
|
if (lk_fb_addr != NULL)
|
|
drm_munmap(lk_fb_addr, bo->size);
|
|
|
|
if (is_ext_lcd_present())
|
|
{
|
|
struct DrmBo *bo_ext = &(drm_resource_object.mBo_ext[drm_resource_object.mPinPon_ext]);
|
|
|
|
if (kernel_fb_addr_ext != NULL)
|
|
drm_munmap(kernel_fb_addr_ext, bo_ext->size);
|
|
if (charging_fb_addr_ext != NULL)
|
|
drm_munmap(charging_fb_addr_ext, bo_ext->size);
|
|
if (lk_fb_addr_ext != NULL)
|
|
drm_munmap(lk_fb_addr_ext, bo_ext->size);
|
|
}
|
|
}
|
|
|
|
int anim_drm_init(void)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
}
|
|
init_drm_addresses();
|
|
phical_screen.bits_per_pixel = chargingAnimationDimension.FB_BPP;
|
|
phical_screen.fill_dst_bits = chargingAnimationDimension.FB_BPP;
|
|
phical_screen.red_offset = 0;
|
|
phical_screen.blue_offset = 16;
|
|
phical_screen.width = chargingAnimationDimension.HDISPLAY;
|
|
phical_screen.height = chargingAnimationDimension.VDISPLAY;
|
|
phical_screen.allignWidth = fb_size / (((chargingAnimationDimension.FB_BPP / 8) * chargingAnimationDimension.VDISPLAY));
|
|
phical_screen.needAllign = 1;
|
|
phical_screen.need180Adjust = 1;
|
|
phical_screen.fb_size = fb_size;
|
|
|
|
int rotation = getRotation();
|
|
if (MTK_LOG_ENABLE == 1)
|
|
SLOGD("[libshowlogo: %s %d]rotation = %d\n", __FUNCTION__, __LINE__, rotation);
|
|
|
|
if (ORIENTATION_270 == rotation) //270
|
|
phical_screen.rotation = 270;
|
|
else if (ORIENTATION_90 == rotation) //90
|
|
phical_screen.rotation = 90;
|
|
else if ((ORIENTATION_180 == rotation) && (phical_screen.need180Adjust == 1)) //180
|
|
phical_screen.rotation = 180;
|
|
else
|
|
phical_screen.rotation = 0;
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]LCD 1 - MTK_LCM_PHYSICAL_ROTATION = %s , red_offset = %d , blue_offset = %d\n align_width = %d",
|
|
__FUNCTION__, __LINE__, MTK_LCM_PHYSICAL_ROTATION, phical_screen.red_offset, phical_screen.blue_offset, phical_screen.allignWidth);
|
|
SLOGD("[libshowlogo]phical_screen: width= %d,height= %d,bits_per_pixel =%d,needAllign = %d,allignWidth=%d rotation =%d ,need180Adjust = %d\n",
|
|
phical_screen.width, phical_screen.height,
|
|
phical_screen.bits_per_pixel, phical_screen.needAllign,
|
|
phical_screen.allignWidth, phical_screen.rotation, phical_screen.need180Adjust);
|
|
SLOGD("[libshowlogo: %s %d]show old animtion= 1, running show_animationm_ver %d\n", __FUNCTION__, __LINE__, show_animationm_ver);
|
|
SLOGD("[libshowlogo: %s %d]draw_anim_mode = 1, running mode %d\n", __FUNCTION__, __LINE__, draw_anim_mode);
|
|
}
|
|
|
|
//dualdisplay - start
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
{
|
|
phical_screen_ext.bits_per_pixel = chargingAnimationDimension_ext.FB_BPP;
|
|
phical_screen_ext.fill_dst_bits = chargingAnimationDimension_ext.FB_BPP;
|
|
phical_screen_ext.red_offset = 0;
|
|
phical_screen_ext.blue_offset = 16;
|
|
phical_screen_ext.width = chargingAnimationDimension_ext.HDISPLAY;
|
|
phical_screen_ext.height = chargingAnimationDimension_ext.VDISPLAY;
|
|
phical_screen_ext.allignWidth = fb_size_ext / (((chargingAnimationDimension_ext.FB_BPP / 8) * chargingAnimationDimension_ext.VDISPLAY));
|
|
phical_screen_ext.needAllign = 1;
|
|
phical_screen_ext.need180Adjust = 0;
|
|
phical_screen_ext.fb_size = fb_size_ext;
|
|
//dualdisplay - 2nd LCD not to support rotation, hence no need to set it for 2nd LCD, it will be zero (0) always
|
|
phical_screen_ext.rotation = 0;
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
SLOGD("[libshowlogo: %s %d]LCD 2 - MTK_LCM_PHYSICAL_ROTATION = %s , red_offset_ext = %d , blue_offset_ext = %d\n align_width_ext = %d",
|
|
__FUNCTION__, __LINE__, MTK_LCM_PHYSICAL_ROTATION, phical_screen_ext.red_offset, phical_screen_ext.blue_offset, phical_screen_ext.allignWidth);
|
|
}
|
|
//dualdisplay - end
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
//dualdisplay - for 2nd LCD
|
|
SLOGD("[libshowlogo]phical_screen_ext: width= %d,height= %d,bits_per_pixel =%d,needAllign = %d,allignWidth=%d rotation =%d ,need180Adjust = %d\n",
|
|
phical_screen_ext.width, phical_screen_ext.height,
|
|
phical_screen_ext.bits_per_pixel, phical_screen_ext.needAllign,
|
|
phical_screen_ext.allignWidth, phical_screen_ext.rotation, phical_screen_ext.need180Adjust);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void anim_drm_deinit()
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
}
|
|
struct DrmBo *bo = &(drm_resource_object.mBo[drm_resource_object.mPinPon]);
|
|
struct DrmBo *bo_ext = &(drm_resource_object.mBo_ext[drm_resource_object.mPinPon_ext]);
|
|
|
|
if (kernel_fb_addr != NULL)
|
|
drm_munmap(kernel_fb_addr, bo->size);
|
|
if (charging_fb_addr != NULL)
|
|
drm_munmap(charging_fb_addr, bo->size);
|
|
if (lk_fb_addr != NULL)
|
|
drm_munmap(lk_fb_addr, bo->size);
|
|
|
|
if (drm_resource_object.mCrtc_ext != NULL)
|
|
{
|
|
if (kernel_fb_addr_ext != NULL)
|
|
drm_munmap(kernel_fb_addr_ext, bo_ext->size);
|
|
if (charging_fb_addr_ext != NULL)
|
|
drm_munmap(charging_fb_addr_ext, bo_ext->size);
|
|
if (lk_fb_addr_ext != NULL)
|
|
drm_munmap(lk_fb_addr_ext, bo_ext->size);
|
|
}
|
|
|
|
freeResource(&drm_resource_object);
|
|
close(drm_fd);
|
|
}
|
|
|
|
void anim_drm_disp_update(void)
|
|
{
|
|
int res, res_ext = 0;
|
|
uint32_t connectorId = getConnectorId(*(drm_resource_object.mConnector));
|
|
drmModeModeInfo modeInfo = getModeInfo(drm_resource_object.mConnector->mModes[0]);
|
|
uint32_t crtcId = getCrtcId(*(drm_resource_object.mCrtc));
|
|
struct DrmBo *bo = &(drm_resource_object.mBo[drm_resource_object.mPinPon]);
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo: %s %d]\n", __FUNCTION__, __LINE__);
|
|
SLOGD("[libshowlogo: %s %d] if reach here, everything was successfull in libdrm \n", __FUNCTION__, __LINE__);
|
|
SLOGD("[libshowlogo %s %d] drm_resource_object = %p ", __FUNCTION__, __LINE__, drm_resource_object);
|
|
}
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo %s %d] drmmodeinfo got success", __FUNCTION__, __LINE__);
|
|
SLOGD("[libshowlogo %s %d] LCD 1 - data for crtc => mdrmfd = %d ,\n crtcId = %d,\n fbId = %d,\n x= %d,\n Y = %d,\n connectorId = %p ,\n 1,\n modeInfo = %p %p",
|
|
__FUNCTION__, __LINE__, drm_resource_object.mDrmFd, crtcId, bo->fbId, 0, 0, &connectorId, &modeInfo, modeInfo);
|
|
SLOGD("[drm_resource %s %d] LCD 1 - drmmodeinfo before setCrtc = %d,\n hdisplay = %d, hsync_start = %d, hsync_end = %d, htotal = %d, hskew = %d, \n vdisplay = %d, vsync_start = %d, vsync_end = %d, vtotal = %d, vscan = %d, \n vrefresh = %d, flags = %d, type = %d",
|
|
__FUNCTION__, __LINE__, modeInfo.clock, modeInfo.hdisplay, modeInfo.hsync_start, modeInfo.hsync_end, modeInfo.htotal, modeInfo.hskew, modeInfo.vdisplay, modeInfo.vsync_start, modeInfo.vsync_end, modeInfo.vtotal, modeInfo.vtotal, modeInfo.vscan, modeInfo.vrefresh, modeInfo.flags, modeInfo.type);
|
|
}
|
|
res = drmModeSetCrtc(drm_resource_object.mDrmFd, crtcId, bo->fbId, 0, 0, &connectorId, 1, &modeInfo);
|
|
|
|
if (res != 0)
|
|
SLOGE("[libshowlogo %s %d] LCD 1 - failed to set crtc: %d", __FUNCTION__, __LINE__, res);
|
|
else
|
|
SLOGD("[libshowlogo %s %d] LCD 1 - draw a frame [%zu]fb_id=%u crtc=%u conn=%u ", __FUNCTION__, __LINE__, drm_resource_object.mPinPon, drm_resource_object.mBo[drm_resource_object.mPinPon].fbId, crtcId, connectorId);
|
|
|
|
if (drm_resource_object.mCrtc_ext != NULL)
|
|
{
|
|
uint32_t connectorId_ext = getConnectorId(*(drm_resource_object.mConnector_ext));
|
|
drmModeModeInfo modeInfo_ext = getModeInfo(drm_resource_object.mConnector_ext->mModes[0]);
|
|
uint32_t crtcId_ext = getCrtcId(*(drm_resource_object.mCrtc_ext));
|
|
struct DrmBo *bo_ext = &(drm_resource_object.mBo_ext[drm_resource_object.mPinPon_ext]);
|
|
|
|
res_ext = drmModeSetCrtc(drm_resource_object.mDrmFd, crtcId_ext, bo_ext->fbId, 0, 0, &connectorId_ext, 1, &modeInfo_ext);
|
|
if (res_ext != 0)
|
|
SLOGE("[libshowlogo %s %d] LCD 2 - failed to set crtc: %d", __FUNCTION__, __LINE__, res);
|
|
else
|
|
SLOGD("[libshowlogo %s %d] LCD 2 - draw a frame [%zu]fb_id=%u crtc=%u conn=%u ", __FUNCTION__, __LINE__, drm_resource_object.mPinPon_ext, drm_resource_object.mBo_ext[drm_resource_object.mPinPon_ext].fbId, crtcId_ext, connectorId_ext);
|
|
|
|
if (MTK_LOG_ENABLE == 1)
|
|
{
|
|
SLOGD("[libshowlogo %s %d] LCD 2 - data for crtc => mdrmfd = %d ,\n crtcId = %d,\n fbId = %d,\n x= %d,\n Y = %d,\n connectorId = %p ,\n 1,\n modeInfo = %p %p",
|
|
__FUNCTION__, __LINE__, drm_resource_object.mDrmFd, crtcId_ext, bo_ext->fbId, 0, 0, &connectorId_ext, &modeInfo_ext, modeInfo_ext);
|
|
SLOGD("[drm_resource %s %d] LCD 2 - drmmodeinfo before setCrtc = %d,\n hdisplay = %d, hsync_start = %d, hsync_end = %d, htotal = %d, hskew = %d, \n vdisplay = %d, vsync_start = %d, vsync_end = %d, vtotal = %d, vscan = %d, \n vrefresh = %d, flags = %d, type = %d",
|
|
__FUNCTION__, __LINE__, modeInfo_ext.clock, modeInfo_ext.hdisplay, modeInfo_ext.hsync_start, modeInfo_ext.hsync_end, modeInfo_ext.htotal, modeInfo_ext.hskew, modeInfo_ext.vdisplay, modeInfo_ext.vsync_start, modeInfo_ext.vsync_end, modeInfo_ext.vtotal, modeInfo_ext.vtotal, modeInfo_ext.vscan, modeInfo_ext.vrefresh, modeInfo_ext.flags, modeInfo_ext.type);
|
|
}
|
|
}
|
|
|
|
free_drm_address();
|
|
drm_resource_object.mPinPon = (drm_resource_object.mPinPon + 1) % MAX_BO_SIZE;
|
|
|
|
if (drm_resource_object.mCrtc_ext != NULL)
|
|
drm_resource_object.mPinPon_ext = (drm_resource_object.mPinPon_ext + 1) % MAX_BO_SIZE;
|
|
|
|
init_drm_addresses();
|
|
SLOGD("[libshowlogo: %s %d] LCD 1 - drm dropped nextBuffer = %d\n", __FUNCTION__, __LINE__, drm_resource_object.mPinPon);
|
|
|
|
if (drm_resource_object.mCrtc_ext != NULL)
|
|
SLOGD("[libshowlogo: %s %d] LCD 2 - drm dropped nextBuffer = %d\n", __FUNCTION__, __LINE__, drm_resource_object.mPinPon_ext);
|
|
}
|
|
|
|
/* to check whether DRM is supported or not */
|
|
int is_drm()
|
|
{
|
|
return chargingAnimationDimension.IS_DRM;
|
|
}
|
|
|
|
/* to turn of KPOC in DRM */
|
|
|
|
void turn_off_drm_display(void)
|
|
{
|
|
SLOGD("[libshowlogo %s %d] Turning off KPOC display \n", __FUNCTION__, __LINE__);
|
|
uint32_t connectorId = getConnectorId(*(drm_resource_object.mConnector));
|
|
uint32_t crtcId = getCrtcId(*(drm_resource_object.mCrtc));
|
|
int res = drmModeSetCrtc(drm_resource_object.mDrmFd, crtcId, 0, 0, 0, nullptr, 0, nullptr);
|
|
|
|
if (res != 0)
|
|
{
|
|
SLOGE("[libshowlogo %s %d] LCD 1 - failed to set crtc: %d \n", __FUNCTION__, __LINE__, res);
|
|
}
|
|
else
|
|
{
|
|
SLOGD("[libshowlogo %s %d] LCD 1 - draw a frame [%zu]fb_id=%u crtc=%u conn=%u \n",
|
|
__FUNCTION__, __LINE__, drm_resource_object.mPinPon, drm_resource_object.mBo[drm_resource_object.mPinPon].fbId, crtcId, connectorId);
|
|
}
|
|
|
|
if (is_ext_lcd_present()) //2nd lcd present
|
|
{
|
|
uint32_t connectorId_ext = getConnectorId(*(drm_resource_object.mConnector_ext));
|
|
uint32_t crtcId_ext = getCrtcId(*(drm_resource_object.mCrtc_ext));
|
|
int res_ext = drmModeSetCrtc(drm_resource_object.mDrmFd, crtcId_ext, 0, 0, 0, nullptr, 0, nullptr);
|
|
if (res_ext != 0)
|
|
{
|
|
SLOGE("[libshowlogo %s %d] LCD 2 - failed to set crtc: %d \n", __FUNCTION__, __LINE__, res_ext);
|
|
}
|
|
else
|
|
{
|
|
SLOGD("[libshowlogo %s %d] LCD 2 - draw a frame [%zu]fb_id=%u crtc=%u conn=%u \n",
|
|
__FUNCTION__, __LINE__, drm_resource_object.mPinPon_ext, drm_resource_object.mBo_ext[drm_resource_object.mPinPon_ext].fbId, crtcId_ext, connectorId_ext);
|
|
}
|
|
}
|
|
|
|
free_drm_address();
|
|
init_drm_addresses();
|
|
SLOGD("[libshowlogo: %s %d]] Turning off KPOC display completed \n", __FUNCTION__, __LINE__);
|
|
}
|
|
|
|
int get_ext_lcd_width(void)
|
|
{
|
|
if (is_ext_lcd_present())
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
SLOGD("[libshowlogo %s %d] ext lcd width = %d\n", __FUNCTION__, __LINE__, phical_screen_ext.width);
|
|
|
|
return phical_screen_ext.width;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
int get_ext_lcd_height(void)
|
|
{
|
|
if (is_ext_lcd_present())
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
SLOGD("[libshowlogo %s %d] ext lcd height = %d\n", __FUNCTION__, __LINE__, phical_screen_ext.height);
|
|
|
|
return phical_screen_ext.height;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
bool get_logo_multibin_status(void)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
SLOGD("[libshowlogo %s %d] multibin status = %d\n", __FUNCTION__, __LINE__, is_multibin);
|
|
return is_multibin;
|
|
}
|
|
|
|
void set_logo_multibin_status(bool bin_status)
|
|
{
|
|
if (MTK_LOG_ENABLE == 1)
|
|
SLOGD("[libshowlogo %s %d] multibin status = %d\n", __FUNCTION__, __LINE__, bin_status);
|
|
is_multibin = bin_status;
|
|
}
|