static int pvr_part_init_task_create(struct pvr_register_info *info)
{
OSAL_T_CTSK task_attribute;
if (pvr_part_init_task_id != OSAL_INVALID_ID)
{
DM_DEBUG("pvr_part_init_task() is running\n");
return 1;
}
MEMCPY(&l_pvr_reg_info, info, sizeof(struct pvr_register_info));
task_attribute.stksz = 0x2000;
task_attribute.quantum = 10;
task_attribute.itskpri = OSAL_PRI_NORMAL;
task_attribute.para1 = (UINT32)(&l_pvr_reg_info);
task_attribute.para2 = 0;
task_attribute.name[0] = 'P';
task_attribute.name[1] = 'P';
task_attribute.name[2] = 'I';
task_attribute.task = (FP)pvr_part_init_task;
pvr_part_init_task_id = osal_task_create(&task_attribute);
if (pvr_part_init_task_id == OSAL_INVALID_ID)
{
DM_ERROR("create pvr_part_init_task failed!\n");
return -1;
}
DM_DEBUG("create pvr_part_init_task() to init pvr partitions\n");
return 0;
}
void tr_threadCreate( tr_thread_t *t, void (* func )(unsigned long, unsigned long), void * arg, void *arg2, char * name )
{
t->func = func;
t->arg = arg;
t->arg2 = arg2;
t->name = strdup( name );
OSAL_T_CTSK t_ctsk;
OSAL_ID tsk_id;
//create the task
t_ctsk.itskpri = OSAL_PRI_NORMAL;
t_ctsk.stksz = 0x8000;
t_ctsk.quantum = 10;
t_ctsk.para1 = arg;
t_ctsk.para2 = arg2;
t_ctsk.name[0] = name[0];
t_ctsk.name[1] = name[1];
t_ctsk.name[2] = name[2];
t_ctsk.task = func;
tsk_id = osal_task_create(&t_ctsk);
tr_dbg("tsk_id [%s] = %d\n", name, tsk_id);
ASSERT(OSAL_INVALID_ID != tsk_id);
t->thread = tsk_id;
}
void usb_init(void)
{
osal_sem_t *sem;
osal_task_t *task;
memset(&wifi_usb_adapter,0,sizeof(wifi_usb_adapter_t));
sem = osal_sem_create("usbh", 0);
osal_assert(sem != NULL);
USB_Host_Semphore = sem;
sem = osal_sem_create("usbc", 0);
osal_assert(sem != NULL);
USB_CtrlReq_Semphore = sem;
USBH_Init(&USB_OTG_Core_dev,
USB_OTG_FS_CORE_ID,
&USB_Host,
&USBH_Class_Cb,
&USBH_USR_Cb);
/* Finally start USB host process thread */
task = osal_task_create("usbh", usbh_thread_entry, NULL, RT_USBH_THREAD_STACK_SIZE, \
RT_USBH_THREAD_PRIORITY);
osal_assert(task != NULL);
}
static USBH_Status _dev_probe ( USB_OTG_CORE_HANDLE *pdev, void * phost)
{
osal_task_t *task;
task = osal_task_create("usbm", _dev_probe_entry, NULL, RT_THREAD_STACK_SIZE, \
RT_USBEMU_THREAD_PRIORITY);
osal_assert(task != NULL);
return USBH_OK;
}
void wnet_init(void)
{
int i;
wnet_envar_t *p_wnet;
p_wnet_envar = &cms_envar.wnet;
p_wnet = p_wnet_envar;
memset(p_wnet, 0, WNET_ENVAR_T_LEN);
memcpy(&p_wnet->working_param, &cms_param.wnet, WNET_CONFIG_T_LEN);
/* Initialize the txbuf queue. */
INIT_LIST_HEAD(&p_wnet->txbuf_waiting_list);
INIT_LIST_HEAD(&p_wnet->txbuf_free_list);
for(i = 0; i< TXBUF_NUM; i++)
{
list_add_tail(&p_wnet->txbuf[i].list, &p_wnet->txbuf_free_list);
}
/* Initialize the rxbuf queue. */
INIT_LIST_HEAD(&p_wnet->rxbuf_waiting_list);
INIT_LIST_HEAD(&p_wnet->rxbuf_free_list);
for(i = 0; i < RXBUF_NUM; i++)
{
list_add_tail(&p_wnet->rxbuf[i].list, &p_wnet->rxbuf_free_list);
}
/* os object for wnet */
p_wnet->sem_wnet_tx = osal_sem_create("wntx", 0);
osal_assert(p_wnet->sem_wnet_tx != NULL);
p_wnet->sem_wnet_rx = osal_sem_create("wnrx", 0);
osal_assert(p_wnet->sem_wnet_rx != NULL);
p_wnet->task_wnet_tx = osal_task_create("wntx",
wnet_tx_thread_entry, p_wnet, RT_THREAD_STACK_SIZE, RT_WNETTX_THREAD_PRIORITY);
osal_assert(p_wnet->task_wnet_tx != NULL);
p_wnet->task_wnet_rx = osal_task_create("wnrx",
wnet_rx_thread_entry, p_wnet, RT_THREAD_STACK_SIZE, RT_WNETRX_THREAD_PRIORITY);
osal_assert(p_wnet->task_wnet_rx != NULL);
}
int rt_key_init(void)
{
osal_task_t *key_tid;
sys_envar_t *p_sys = &cms_envar.sys;
key_tid = osal_task_create("t-key",
key_thread_entry, p_sys,
RT_KEY_THREAD_STACK_SIZE, RT_KEY_THREAD_PRIORITY);
osal_assert(key_tid != NULL);
return 0;
}
/* 初始设备串口波特率9600而PC的GPS模拟工具115200,
time>6s 未能解析出正确GPS NMEA则判断为PC GPS工具输入,
set host uart1 baud to 115200 */
gps_set_host_baudrate(BAUD_RATE_115200);
cfg_flag = 1;
}
}
}
osal_delay(1);
}
}
//*******************************************************************************
// 函数名称 : void gps_init(void)
// 功能描述 : 初始化gps模块，例如屏蔽不需要的信息，天线断开延时
// 输入 : None
// 输出 : None
// 返回 : None
//******************************************************************************/
void gps_init(void)
{
osal_task_t *tid;
memset(&__GPSBuff, 0, sizeof(__GPSBuff));
gps_recv_cb = NULL;
tid = osal_task_create("t-gps",
rt_gps_thread_entry, RT_NULL,
RT_GPS_THREAD_STACK_SIZE, RT_GPS_THREAD_PRIORITY);
osal_assert(tid != RT_NULL)
}
UINT32 api_com_monitor()
{
UINT8 i = 0;
UINT8 ch = 0xff;
UINT8 *comtest_command = "comtest";
INT32 comtest_command_len = STRLEN(comtest_command) - 1;
UINT8 sync = 0;
UINT32 timeout = 1000;
OSAL_T_CTSK t_ctsk;
if (COM_MONITOR_CHECK_STBID &g_com_detect_flag)
{
i = 0;
while(sci_read_tm(SCI_FOR_RS232, &ch, timeout) == SUCCESS)
{
if((i <= comtest_command_len) && (comtest_command[i] == ch))
{
timeout = 1000 * 100;
sci_write(SCI_FOR_RS232, ch);
i++;
if (i > comtest_command_len) /* Is a comtest command string, wait for serial id trans */
{
t_ctsk.stksz = 0x2000;
t_ctsk.quantum = 10;
t_ctsk.itskpri = OSAL_PRI_NORMAL;
t_ctsk.name[0] = 'A';
t_ctsk.name[1] = 'S';
t_ctsk.name[2] = 'H';
t_ctsk.task = (FP)lib_ash_shell;
if(g_com_ash_id != OSAL_INVALID_ID)
{
osal_task_delete(g_com_ash_id);
}
g_com_ash_id = osal_task_create(&t_ctsk);
if (g_com_ash_id == OSAL_INVALID_ID)
return 1;
api_set_com_check_flag(COM_MONITOR_CHECK_PAUSE);
break;
}
}
else
break;
}
}
return 0;
}
void ipanel_task_init(UINT32 param1, UINT32 param2)
{
OSAL_T_CTSK task_param;
task_param.task = ipanel_task;
task_param.name[0] = 'D';
task_param.name[1] = 'E';
task_param.name[2] = 'O';
task_param.stksz = 0x18000;
task_param.itskpri = OSAL_PRI_NORMAL;
task_param.quantum = 10;
task_param.para1 = param1;
task_param.para2 = param2; //Reserved for future use.
if (OSAL_INVALID_ID == osal_task_create(&task_param))
ASSERT(0);
ALI_IPANEL_LEAVE_MUTEX(ALI_IPANEL_FLAG_ENTER_MW);
}
//TODO try to run with optimization Os
int main(void)
{
board_init();
// TODO blocking wait --> systick handler --> ...... freeRTOS hardfault
//wait_blocking_ms(1000); // wait a bit for power stable
// print_greeting(); TODO uart output before freeRTOS scheduler start will lead to hardfault
// find a way to fix this as tusb_init can output to uart when an error occurred
tusb_init();
//------------- application task init -------------//
(void) osal_task_create(&led_blinking_task_def);
#if TUSB_CFG_HOST_HID_KEYBOARD
keyboard_app_init();
#endif
#if TUSB_CFG_HOST_HID_MOUSE
mouse_app_init();
#endif
#if TUSB_CFG_HOST_CDC
cdc_serial_app_init();
#endif
//------------- start OS scheduler (never return) -------------//
#if TUSB_CFG_OS == TUSB_OS_FREERTOS
vTaskStartScheduler();
#elif TUSB_CFG_OS == TUSB_OS_NONE
os_none_start_scheduler();
#else
#error need to start RTOS schduler
#endif
//------------- this part of code should not be reached -------------//
hal_debugger_breakpoint();
while(1)
{
}
return 0;
}
static int create_transfer_task(UrlResource *rsrc, libnet_callback cb)
{
OSAL_T_CTSK t_ctsk;
OSAL_ID tsk_id;
t_ctsk.itskpri = OSAL_PRI_NORMAL;
t_ctsk.stksz = 0x8000;
t_ctsk.quantum = 10;
t_ctsk.para1 = (UINT32)rsrc;
t_ctsk.para2 = (UINT32)cb;
t_ctsk.name[0] = 'T';
t_ctsk.name[1] = 'R';
t_ctsk.name[2] = 'A';
t_ctsk.task = transfer;
tsk_id = osal_task_create(&t_ctsk);
LIBNET_DEBUG("tsk_id = %d\n", tsk_id);
ASSERT(OSAL_INVALID_ID != tsk_id);
return tsk_id;
}
BOOL cas_osdmsg_task_init(void)
{
ID subtitle_scroll_task_id ;//= OSAL_INVALID_ID;
OSAL_T_CMBF t_cmbf;
OSAL_T_CTSK t_ctsk;
//t_cmbf.mbfatr = TA_TFIFO;
t_cmbf.bufsz = 16 * sizeof(ControlMsg_t);
t_cmbf.maxmsz = sizeof(ControlMsg_t);
t_cmbf.name[0] = 's';
t_cmbf.name[1] = 'u';
t_cmbf.name[2] = 'b';
subtitle_scroll_mbf_id = OSAL_INVALID_ID;
subtitle_scroll_task_id = OSAL_INVALID_ID;
subtitle_scroll_mbf_id = osal_msgqueue_create(&t_cmbf);
if(OSAL_INVALID_ID == subtitle_scroll_mbf_id)
{
PRINTF("cre_mbf subtitle_scroll_mbf_id failed\n");
return FALSE;
}
t_ctsk.stksz = SUBTITLE_SCROLL_TASK_STACKSIZE;
t_ctsk.quantum = SUBTITLE_SCROLL_TASK_QUANTUM;
t_ctsk.itskpri = OSAL_PRI_NORMAL;
t_ctsk.name[0] = 's';
t_ctsk.name[1] = 'u';
t_ctsk.name[2] = 'b';
t_ctsk.task = (FP)subtitle_scroll_control_task;
subtitle_scroll_task_id = osal_task_create(&t_ctsk);
if(OSAL_INVALID_ID == subtitle_scroll_task_id)
{
//delete control_mbf_id
PRINTF("cre_tsk subtitle_scroll_task_id failed\n");
return FALSE;
}
//ap_osd_layer2_init();
cas_osd_dev = g_osd_dev;
MEMSET(&cti_subt_buf, 0, sizeof(cti_subt_buf));
return TRUE;
}
INT32 restart_netupdate_register(void)
{
OSAL_T_CTSK t_ctsk; //Net updata thread
MEMSET(&network_thread_struct, 0, sizeof(NETWORK_CTRL_T));
/* create auto netupdate thread */
t_ctsk.task = (OSAL_T_TASK_FUNC_PTR)restart_netupdate_process;
t_ctsk.itskpri = OSAL_PRI_NORMAL;
t_ctsk.stksz = 0x4000;
t_ctsk.quantum = 5;
t_ctsk.name[0] = 'N';
t_ctsk.name[1] = 'U';
t_ctsk.name[2] = 'D';
network_thread_struct.thread_id = osal_task_create(&t_ctsk);
if (OSAL_INVALID_ID == network_thread_struct.thread_id)
{
//ASSERT(0);
libc_printf("Creat updata process thread fail!!!\n");
return 0;
}
return 1;
}
RET_CODE usb_test_init(void)
{
OSAL_T_CMBF t_cmbf;
OSAL_T_CTSK usb_logo_task;
t_cmbf.bufsz = USB_IF_MBF_SIZE * sizeof(IfEvtMsg_t);
t_cmbf.maxmsz = sizeof(IfEvtMsg_t);
t_cmbf.name[0] = 'B';
t_cmbf.name[1] = 'U';
t_cmbf.name[2] = 'S';
usbd_logo_mbf_id = OSAL_INVALID_ID;
usbd_logo_mbf_id = osal_msgqueue_create(&t_cmbf);
if ( OSAL_INVALID_ID == usbd_logo_mbf_id )
{
USB_LOGO_PRINTF("cre_mbf usbd_mbf_id failed\n");
ASSERT(0);
}
usb_logo_task.task = (FP) usb_test_task;
usb_logo_task.itskpri = OSAL_PRI_NORMAL;
usb_logo_task.quantum = 10;
usb_logo_task.stksz = 0x2000;
usb_logo_task.para1 = 0;
usb_logo_task.para2 = 0;
usb_logo_task.name[0] = 'B';
usb_logo_task.name[1] = 'U';
usb_logo_task.name[2] = 'S';
if ( OSAL_INVALID_ID == osal_task_create(&usb_logo_task) )
{
USB_LOGO_PRINTF("cre_tsk usbd_task failed\n");
ASSERT(0);
}
usb_notsupport_dev = 0 ;
osal_task_sleep(100) ;
}
static int ogg_play_file(char *filename, mp_callback_func cb)
{
OSAL_T_CTSK ogg_engine_play_task_attribute;
unsigned long ogg_engine_flag;
PE_DBG_PRINTF("MusicEngine: ==> ogg_play_file()! \n");
//check parameters
if ((!filename) || (!cb) || (!ogg_file))
{
PE_DBG_PRINTF("MusicEngine: ogg_play_file() invalid parameter filename or cb or ogg_file! \n");
return -1;
}
//init ogg_file
#ifdef ENABLE_PE_CACHE
ogg_cache_id = pe_cache_open(filename, NULL, OGG_CACHE_SIZE, OGG_BLOCK_SIZE);
if(ogg_cache_id < 0)
{
PE_DBG_PRINTF("MusicEngine: ogg_play_file() pe_cache_open failed! \n");
return -1;
}
ogg_file->file = (FILE *)((UINT32)ogg_cache_id | PE_CACHE_ID_TAG); //只有在作了这个操作之后,以后的文件系统函数才是pe_cache接口
#else
ogg_file->file = fopen(filename, "rb");
if (!ogg_file->file)
{
PE_DBG_PRINTF("MusicEngine: ogg_play_file() fopen failed! \n");
return -1;
}
#endif
ogg_file->seek_to = 0;
ogg_file->command = 0;
ogg_file->stop_imm = TRUE;
ogg_engine.ogg_engine_flag_id = OSAL_INVALID_ID;
ogg_engine.ogg_engine_task_id = OSAL_INVALID_ID;
deca_io_control((struct deca_device *)dev_get_by_id(HLD_DEV_TYPE_DECA, 0), DECA_SET_STR_TYPE, AUDIO_OGG );
prev_sp_l = 0;
prev_sp_r = 0;
g_pcm_sample_num = 0;
g_pcm_current_using = 0;
g_temp_pcm_buff = (char *)(ogg_file->processed_pcm_buff+ON_PCM_BUFF_LEN*8);
//code to create flag
ogg_engine_flag = OGG_ENGINE_FLAG_INITIALIZE;
ogg_engine.ogg_engine_flag_id = osal_flag_create(ogg_engine_flag);
if ( ogg_engine.ogg_engine_flag_id == OSAL_INVALID_ID)
{
PE_DBG_PRINTF("MusicEngine: ogg_play_file() osal_flag_create failure! \n");
#ifdef ENABLE_PE_CACHE
pe_cache_close(ogg_cache_id);
ogg_cache_id = -1;
#else
fclose(ogg_file->file);
#endif
return -1;
}
//start thread
ogg_engine_play_task_attribute.stksz = OGG_ENGINE_PLAY_TASK_STACKSIZE*8;
ogg_engine_play_task_attribute.quantum = OGG_ENGINE_PLAY_TASK_QUANTUM;
ogg_engine_play_task_attribute.itskpri = OSAL_PRI_HIGH;//OSAL_PRI_NORMAL ;
ogg_engine_play_task_attribute.para1 = (unsigned long)cb;
//ogg_engine_play_task_attribute.para2 =;
ogg_engine_play_task_attribute.name[0] = 'O';
ogg_engine_play_task_attribute.name[1] = 'G';
ogg_engine_play_task_attribute.name[2] = 'G';
ogg_engine_play_task_attribute.task = (FP)ogg_play_task;
ogg_engine.ogg_engine_task_id = osal_task_create(&ogg_engine_play_task_attribute);
if(ogg_engine.ogg_engine_task_id == OSAL_INVALID_ID)
{
PE_DBG_PRINTF("MusicEngine: ogg_play_file() osal_task_create failed! \n");
osal_flag_delete(ogg_engine.ogg_engine_flag_id);
ogg_engine.ogg_engine_flag_id = OSAL_INVALID_ID;
#ifdef ENABLE_PE_CACHE
pe_cache_close(ogg_cache_id);
ogg_cache_id = -1;
#else
fclose(ogg_file->file);
#endif
return -1;
}
//code to sync
osal_flag_wait(&ogg_engine_flag, ogg_engine.ogg_engine_flag_id, OGG_ENGINE_FLAG_MASK, OSAL_TWF_ORW | OSAL_TWF_CLR, OSAL_WAIT_FOREVER_TIME);
if (ogg_engine_flag != OGG_ENGINE_FLAG_SUCCESS)
{
osal_flag_delete(ogg_engine.ogg_engine_flag_id);
ogg_engine.ogg_engine_flag_id = OSAL_INVALID_ID;
//fclose(ogg_file->file);
return -1;
}
PE_DBG_PRINTF("MusicEngine: <== ogg_play_file()! \n");
return 0;
}
//--------------------------------------------------------------------+
// APPLICATION CODE
//--------------------------------------------------------------------+
void msc_host_app_init(void)
{
osal_task_create( msc_host_app_task, "msc", 512, NULL, MSC_APP_TASK_PRIO);
diskio_init();
}
void vam_init(void)
{
int i;
vam_envar_t *p_vam = &p_cms_envar->vam;
uint8_t zero_pid[RCP_TEMP_ID_LEN] = {0};
p_vam_envar = p_vam;
memset(p_vam, 0, sizeof(vam_envar_t));
memcpy(&p_vam->working_param, &p_cms_param->vam, sizeof(vam_config_t));
if (0 == memcmp(p_cms_param->pid, zero_pid, RCP_TEMP_ID_LEN)){
for (i=0; i<RCP_TEMP_ID_LEN; i++){
p_vam->local.pid[i] = des(RCP_TEMP_ID_LEN-1-i);
}
}
else {
memcpy(p_vam->local.pid, p_cms_param->pid, RCP_TEMP_ID_LEN);
}
OSAL_MODULE_DBGPRT(MODULE_NAME, OSAL_DEBUG_INFO, "PID: %02x %02x %02x %02x\r\n", \
p_vam->local.pid[0], p_vam->local.pid[1], p_vam->local.pid[2], p_vam->local.pid[3]);
INIT_LIST_HEAD(&p_vam->neighbour_list);
INIT_LIST_HEAD(&p_vam->sta_free_list);
for(i = 0;i< VAM_NEIGHBOUR_MAXNUM;i++){
list_add_tail(&p_vam->remote[i].list, &p_vam->sta_free_list);
}
/* os object for vam */
p_vam->queue_vam = osal_queue_create("q-vam", VAM_QUEUE_SIZE);
osal_assert(p_vam->queue_vam != RT_NULL);
p_vam->task_vam = osal_task_create("t-vam",
vam_thread_entry, p_vam,
RT_VAM_THREAD_STACK_SIZE, RT_VAM_THREAD_PRIORITY);
osal_assert(p_vam->task_vam != RT_NULL)
p_vam->timer_send_bsm = osal_timer_create("tm-sb",timer_send_bsm_callback,p_vam,\
BSM_SEND_PERIOD_DEFAULT, RT_TIMER_FLAG_PERIODIC);
osal_assert(p_vam->timer_send_bsm != NULL);
p_vam->timer_bsm_pause = osal_timer_create("tm-bp",timer_bsm_pause_callback,p_vam,\
BSM_PAUSE_HOLDTIME_DEFAULT,RT_TIMER_FLAG_ONE_SHOT);
osal_assert(p_vam->timer_bsm_pause != RT_NULL);
p_vam->timer_send_evam = osal_timer_create("tm-se",timer_send_evam_callback, p_vam,\
EVAM_SEND_PERIOD_DEFAULT,RT_TIMER_FLAG_PERIODIC);
osal_assert(p_vam->timer_send_evam != RT_NULL);
p_vam->timer_gps_life = osal_timer_create("tm-gl",timer_gps_life_callback,p_vam,\
BSM_GPS_LIFE_DEFAULT, RT_TIMER_FLAG_ONE_SHOT);
osal_assert(p_vam->timer_gps_life != RT_NULL);
p_vam->timer_neighbour_life = osal_timer_create("tm-nl",timer_neigh_time_callback,p_vam,\
NEIGHBOUR_LIFE_ACCUR, RT_TIMER_FLAG_PERIODIC);
osal_assert(p_vam->timer_neighbour_life != RT_NULL);
p_vam->sem_sta = osal_sem_create("s-sta", 1);
osal_assert(p_vam->sem_sta != RT_NULL);
OSAL_MODULE_DBGPRT(MODULE_NAME, OSAL_DEBUG_INFO, "module initial\n");
}
afi->cylinders, afi->heads , afi->sectors, (long)afi->cylinders * (long)afi->heads * (long)afi->sectors );
}
#endif
#else //for TDS
t_FtlTsk.task=(FP)ali_ftl_thread;
t_FtlTsk.stksz=0x1000;
t_FtlTsk.quantum=10;
t_FtlTsk.itskpri=OSAL_PRI_NORMAL;
t_FtlTsk.para1=(UINT32)afi;
t_FtlTsk.para2=0;
t_FtlTsk.name[0]='F';
t_FtlTsk.name[1]='T';
t_FtlTsk.name[2]='L';
afi->FTL_TASK_ID=osal_task_create(&t_FtlTsk);
#endif
#endif
/* Test Ground */
#if 0 // for test "container_of"
libc_printf("aliFTLDevice: 0x%x\n", aliFTLDevice);
libc_printf("[c]aliFTLDevice: 0x%x\n", container_of(&(aliFTLDevice->blockPerPartition), struct ali_ftl_info, blockPerPartition));
#endif
#if 0 // for test "osal_get_tick"
#ifdef ALI_FTL_WITH_TIME_CHECK //for TDS
{
unsigned long lastJiffies = 0;
for(i = 0; i < 10000; i++) {
static INT32 pan_ch455_open(struct pan_device *dev)
{
struct pan_ch455_private *tp = (struct pan_ch455_private *)dev->priv;
struct pan_hw_info *hp = tp->hw_info;
UINT32 re;
UINT8 i;
tp->task_id = OSAL_INVALID_ID;
//Set i2c type id.
//tp->i2c_id = I2C_TYPE_SCB1;
//Config CH455 working mode.
tp->mode = CH455_MODE;
//Set bit mask for keyboard scan.
tp->mask_status = CH455_KEY_STATUS_MASK;
tp->mask_row = CH455_KEY_ROW_MASK;
tp->mask_column = CH455_KEY_COLUMN_MASK;
tp->key_cnt = 1;
tp->keypress_cnt = 0;
//Set repeat key interval to 300 ms.
tp->keypress_intv = 3;
tp->keypress_bak = PAN_KEY_INVALID;
//Set back status to up.
tp->bak_status = CH455_STATUS_UP;
re = pan_ch455_mode_set(dev);
if (tp->is_local == 1)
irc_m6303irc_init(tp->hw_info);
if (re)
return ERR_FAILUE;
// set the default display string.
for(i = 0; i < 8; i++)
{
tp->lock[i] = 0;
tp->disp_buff[i] = 0;
}
#ifdef _DEBUG_VERSION_
OSAL_T_CTSK task_param;
//creat ch455 task for keyboard scan.
task_param.task = (FP)panel_ch455_task;
task_param.stksz = 0x1000;
task_param.quantum = 10;
task_param.itskpri = OSAL_PRI_NORMAL;
task_param.para1= (UINT32)dev;
task_param.para2 = 0;
tp->task_id = osal_task_create(&task_param);
if(OSAL_INVALID_ID == tp->task_id)
{
PAN_CH455_PRINTF("%s()=>Create panel_ch455_task FAILED!\n", __FUNCTION__);
return ERR_FAILUE;
}
#endif
return SUCCESS;
}
