/*** Main function ***/
void ICACHE_FLASH_ATTR user_init() {
uart_div_modify(0, UART_CLK_FREQ / BAUD);
os_printf("Startup from %d...\r\n", system_get_rst_info()->reason);
gpio_init();
ap_init();
// HTTPD
espFsInit((void*)(webpages_espfs_start));
httpdInit(builtInUrls, 80);
// Set GPIO2 (DCF77 pin) to input, disable pullup
gpio_output_set(0, 0, 0, 2);
PIN_PULLUP_DIS(PERIPHS_IO_MUX_GPIO2_U);
// DCF77 read timer
os_timer_disarm(&dcf_read_timer);
os_timer_setfn(&dcf_read_timer, (os_timer_func_t *) dcf_read_timer_cb, NULL);
os_timer_arm(&dcf_read_timer, 5, 1);
// Second increase timer
os_timer_disarm(&time_inc_timer);
os_timer_setfn(&time_inc_timer, (os_timer_func_t *) time_inc_timer_cb, NULL);
os_timer_arm(&time_inc_timer, 1000, 1);
// DCF77 decode timer: decide wheter 1 or 0
dcf_decode_timer_adjust();
os_printf(" completed!\r\n\r\n");
system_os_task(loop, user_procTaskPrio, user_procTaskQueue, user_procTaskQueueLen);
system_os_post(user_procTaskPrio, 0, 0);
}
int main(int argc, char *argv[])
{
/* update progname from argv[0] */
set_progname(argv[0]);
const struct ap_Option options[] = {
{'h', "help", ap_no, 0, 0},
{'v', "version", ap_no, 0, 0},
{0, 0, ap_no, 0, 0}
};
if (!ap_init(&parser, argc, (const char* const*) argv, options, 0))
critx("could not allocate memory for option parser");
if (ap_error(&parser)) {
errx("%s", ap_error(&parser));
usage(EXIT_FAILURE);
}
/* parse command line */
for (int argind = 0; argind < ap_arguments(&parser); argind++) {
const int code = ap_code(&parser, argind);
switch (code) {
case 0:
break;
case 'h':
usage(EXIT_SUCCESS);
break;
case 'v':
fprintf(stderr, "%s %s\n%s\n%s\n\n%s\n", progname,
FLOWGRIND_VERSION, FLOWGRIND_COPYRIGHT,
FLOWGRIND_COPYING, FLOWGRIND_AUTHORS);
exit(EXIT_SUCCESS);
break;
default:
errx("uncaught option: %s", ap_argument(&parser, argind));
usage(EXIT_FAILURE);
break;
}
}
if (!ap_arguments(&parser)) {
errx("no address given");
usage(EXIT_FAILURE);
}
xmlrpc_env rpc_env;
xmlrpc_env_init(&rpc_env);
xmlrpc_client_setup_global_const(&rpc_env);
for (int argind = 0; argind < ap_arguments(&parser); argind++)
/* if non-option, it is an address */
if (!ap_code(&parser, argind))
stop_flows(ap_argument(&parser, argind));
xmlrpc_env_clean(&rpc_env);
xmlrpc_client_teardown_global_const();
ap_free(&parser);
}
void task_sys_init(void* p_data)
{
BOOL ret = FALSE;
u32* pstack_pnt = NULL;
mem_mgr_partition_param_t partition_param = { 0 };
//init memory manager, to the memory end
mem_mgr_init(g_sys_mem, SYS_MEMORY_END);
/* create SYS partition */
partition_param.id = MEM_SYS_PARTITION;
partition_param.size = SYS_PARTITION_SIZE;
partition_param.p_addr = g_sys_mem;
partition_param.atom_size = SYS_PARTITION_ATOM;
partition_param.user_id = SYS_MODULE_SYSTEM;
partition_param.method_id = MEM_METHOD_NORMAL;
ret = MEM_CREATE_PARTITION(&partition_param);
MT_ASSERT(FALSE != ret);
OS_PRINTF("create patition ok!\n");
//register malloc/free function, using system partition
mtos_mem_init(my_malloc, my_free);
OS_PRINTF("init mem ok!\n");
mtos_ticks_init(SYS_CPU_CLOCK);
//init message queue
ret = mtos_message_init();
MT_ASSERT(FALSE != ret);
#ifdef CORE_DUMP_DEBUG
//start statistic task, MUST BE in the first task!
mtos_stat_init();
#endif
//create timer task
pstack_pnt = (u32*)mtos_malloc(SYS_TIMER_TASK_STKSIZE);
MT_ASSERT(pstack_pnt != NULL);
ret = mtos_task_create("Timer",
Task_SysTimer,
(void *)0,
SYS_TIMER_TASK_PRIORITY,
pstack_pnt,
SYS_TIMER_TASK_STKSIZE);
MT_ASSERT(FALSE != ret);
OS_PRINTF("create timer task ok!\n");
mtos_task_sleep(25);
OS_PRINTF("start ap init!\n");
ap_init();
OS_PRINTF("ap init ok!\n");
mtos_task_exit( );
}
/* This function overruns the same function in marvell_bl31_setup.c */
void bl31_plat_arch_setup(void)
{
int cp;
uintptr_t *mailbox = (void *)PLAT_MARVELL_MAILBOX_BASE;
/* initialize the timer for mdelay/udelay functionality */
plat_delay_timer_init();
/* configure apn806 */
ap_init();
/* In marvell_bl31_plat_arch_setup, el3 mmu is configured.
* el3 mmu configuration MUST be called after apn806_init, if not,
* this will cause an hang in init_io_win
* (after setting the IO windows GCR values).
*/
if (mailbox[MBOX_IDX_MAGIC] != MVEBU_MAILBOX_MAGIC_NUM ||
mailbox[MBOX_IDX_SUSPEND_MAGIC] != MVEBU_MAILBOX_SUSPEND_STATE)
marvell_bl31_plat_arch_setup();
for (cp = 0; cp < CP_COUNT; cp++) {
/* configure cp110 for CP0*/
if (cp == 1)
mci_initialize(MVEBU_MCI0);
/* initialize MCI & CP1 */
cp110_init(MVEBU_CP_REGS_BASE(cp),
STREAM_ID_BASE + (cp * MAX_STREAM_ID_PER_CP));
/* Should be called only after setting IOB windows */
marvell_bl31_mpp_init(cp);
}
/* initialize IPC between MSS and ATF */
if (mailbox[MBOX_IDX_MAGIC] != MVEBU_MAILBOX_MAGIC_NUM ||
mailbox[MBOX_IDX_SUSPEND_MAGIC] != MVEBU_MAILBOX_SUSPEND_STATE)
marvell_bl31_mss_init();
/* Configure GPIO */
marvell_gpio_config();
marvell_bl31_security_setup();
}
int main( const int argc, const char * const argv[] )
{
int argind;
bool loose = false;
const struct ap_Option options[] =
{
{ 'G', "traditional", ap_no },
{ 'h', "help", ap_no },
{ 'l', "loose-exit-status", ap_no },
{ 'p', "prompt", ap_yes },
{ 'r', "restricted", ap_no },
{ 's', "quiet", ap_no },
{ 's', "silent", ap_no },
{ 'v', "verbose", ap_no },
{ 'V', "version", ap_no },
{ 0 , 0, ap_no } };
struct Arg_parser parser;
if( !ap_init( &parser, argc, argv, options, 0 ) )
{ show_error( "Memory exhausted.", 0, false ); return 1; }
if( ap_error( &parser ) ) /* bad option */
{ show_error( ap_error( &parser ), 0, true ); return 1; }
invocation_name = argv[0];
for( argind = 0; argind < ap_arguments( &parser ); ++argind )
{
const int code = ap_code( &parser, argind );
const char * const arg = ap_argument( &parser, argind );
if( !code ) break; /* no more options */
switch( code )
{
case 'G': traditional_ = true; break; /* backward compatibility */
case 'h': show_help(); return 0;
case 'l': loose = true; break;
case 'p': set_prompt( arg ); break;
case 'r': restricted_ = true; break;
case 's': scripted_ = true; break;
case 'v': set_verbose(); break;
case 'V': show_version(); return 0;
default : show_error( "internal error: uncaught option.", 0, false );
return 3;
}
} /* end process options */
setlocale( LC_ALL, "" );
if( !init_buffers() ) return 1;
while( argind < ap_arguments( &parser ) )
{
const char * const arg = ap_argument( &parser, argind );
if( !strcmp( arg, "-" ) ) { scripted_ = true; ++argind; continue; }
if( may_access_filename( arg ) )
{
if( read_file( arg, 0 ) < 0 && is_regular_file( 0 ) )
return 2;
else if( arg[0] != '!' ) set_def_filename( arg );
}
else
{
fputs( "?\n", stderr );
if( arg[0] ) set_error_msg( "Invalid filename" );
if( is_regular_file( 0 ) ) return 2;
}
break;
}
ap_free( &parser );
return main_loop( loose );
}
void TaskStart(void* p_data)
{
extern u32 _end;
u32 bss_end = (u32)(&_end);
BOOL ret = FALSE;
ota_trigger_t ota_trigger = 0;
//uio_device_t *p_dev = NULL;
u32* pstack_pnt = NULL;
// u8 content[5] = {' ', ' ', 'O', 'N', 0};
u32 heap_start = 0;
u32 cpuclk = 0;
heap_start = ROUNDUP(bss_end,4);
mtos_irq_init();
hal_concerto_attach( );
mtos_register_putchar(uart_write_byte);
mtos_register_getchar(uart_read_byte);
hal_module_clk_get(HAL_CPU0, &cpuclk);
mtos_ticks_init(cpuclk);
OS_PRINTF("\r\n====OTA TaskStart====\n");
uart_init(0);
uart_init(1);
uart_set_param(0, 115200, 8, 1, 0);
uart_set_param(1, 115200, 8, 1, 0);
OS_PRINTF("\n OTA start \n\n");
OS_PRINTF("\n Built at %s \n", buildSTR);
OS_PRINTF("\n 1. mem_start[%x]\n", heap_start);
OS_PRINTF("\n 2. system memory size[%x]\n", SYS_MEMORY_END);
mem_mgr_init((u8 *)heap_start,
SYS_PARTITION_SIZE);
OS_PRINTF("\n 1. mem_start[0x%x],size=0x%x\n", heap_start,
SYS_PARTITION_SIZE);
dlmem_init((void *)heap_start,
SYS_PARTITION_SIZE);
mtos_mem_init(dl_malloc, dl_free);
OS_PRINTF("init mem ok!\n");
//init message queue
ret = mtos_message_init();
MT_ASSERT(FALSE != ret);
#ifdef CORE_DUMP_DEBUG
//start statistic task, MUST BE in the first task!
mtos_stat_init();
#endif
//create timer task
pstack_pnt = (u32*)mtos_malloc(SYS_TIMER_TASK_STKSIZE);
MT_ASSERT(pstack_pnt != NULL);
ret = mtos_task_create((u8 *)"Timer",
Task_SysTimer,
(void *)0,
SYS_TIMER_TASK_PRIORITY,
pstack_pnt,
SYS_TIMER_TASK_STKSIZE);
MT_ASSERT(FALSE != ret);
mtos_task_sleep(25);
ap_init();
ret = ota_check();
OS_PRINTF("OTA check %d\n", ota_trigger);
//{
// ota_info_t otai = {0};
// ota_read_otai(&otai);
// otai.ota_tri = OTA_TRI_FORC;
// otai.sys_mode = SYS_DVBS;
// ota_write_otai(&otai);
//}
//p_dev = dev_find_identifier(NULL, DEV_IDT_TYPE, SYS_DEV_TYPE_UIO);
//MT_ASSERT(NULL != p_dev);
if(ret == FALSE)
{
//clear frontpanel.
//uio_display(p_dev, " ", 4);
reback_to_boot();
}
else
{
//uio_display(p_dev, content, 4);
}
mtos_task_exit( );
}
/*ARGSUSED*/
cfga_err_t
cfga_list_ext(
const char *ap_id,
cfga_list_data_t **ap_id_list,
int *nlist,
const char *options,
const char *listopts,
char **errstring,
cfga_flags_t flags)
{
int i;
int apcnt;
const char *f;
apd_t *a;
size_t szl, szp;
cfga_list_data_t *aplist, *ap;
cfga_err_t rc;
rc = CFGA_LIB_ERROR;
aplist = NULL;
f = ap_cmd_name(CMD_STATUS);
DBG("cfga_list_ext(%s %x)\n", ap_id, flags);
if ((a = apd_alloc(ap_id, flags, errstring, NULL, NULL)) == NULL)
return (rc);
else if ((rc = ap_cmd_parse(a, f, options, NULL)) != CFGA_OK)
goto done;
apcnt = ap_cnt(a);
DBG("apcnt=%d\n", apcnt);
if ((aplist = calloc(apcnt, sizeof (*aplist))) == NULL) {
rc = CFGA_LIB_ERROR;
ap_err(a, ERR_CMD_FAIL, CMD_STATUS);
goto done;
}
ap = aplist;
szl = sizeof (ap->ap_log_id);
szp = sizeof (ap->ap_phys_id);
/*
* Initialize the AP specified directly by the caller.
* The target ID for the 0th element already includes
* the (potential) dynamic portion. The dynamic portion
* does need to be appended to the path to form the
* physical apid for components.
*/
(void) strncpy(ap->ap_log_id, a->target, szl - 1);
(void) snprintf(ap->ap_phys_id, szp, "%s%s%s", a->path,
a->tgt != AP_BOARD ? "::" : "",
a->tgt != AP_BOARD ? a->cid : "");
DBG("ap_phys_id=%s ap_log_id=%s\n", ap->ap_phys_id, ap->ap_log_id);
if (a->tgt == AP_BOARD) {
ap_init(a, ap++);
/*
* Initialize the components, if any.
*/
for (i = 0; i < apcnt - 1; i++, ap++) {
char dyn[MAXPATHLEN];
ap_cm_id(a, i, dyn, sizeof (dyn));
(void) snprintf(ap->ap_log_id, szl, "%s::%s",
a->target, dyn);
(void) snprintf(ap->ap_phys_id, szp, "%s::%s",
a->path, dyn);
ap_cm_init(a, ap, i);
DBG("ap_phys_id=%s ap_log_id=%s\n",
ap->ap_phys_id, ap->ap_log_id);
}
} else
ap_cm_init(a, ap, 0);
apd_free(a);
*ap_id_list = aplist;
*nlist = apcnt;
return (CFGA_OK);
done:
s_free(aplist);
apd_free(a);
return (rc);
}
void TaskStart (void *data)
{
extern u32 _end;
u32 bss_end = (u32)(&_end);
BOOL ret = FALSE;
u32 *pstack_pnt = NULL;
u32 heap_start = 0;
// u32 montage_auto = 0;
u32 cpuclk = 0;
heap_start = ROUNDUP(bss_end,4);
mtos_irq_init();
hal_concerto_attach( );
mtos_register_putchar(uart_write_byte);
mtos_register_getchar(uart_read_byte_polling);
//mtos_ticks_init(SYS_CPU_CLOCK);
hal_module_clk_get(HAL_CPU0, &cpuclk);
mtos_ticks_init(cpuclk);
gpio_mux();
mem_mgr_partition_param_t partition_param = { 0 };
uart_init(0);
uart_init(1);
//init memory manager, to the memory end
mem_mgr_init((u8 *)heap_start, SYSTEM_MEMORY_END);
//create system partition
partition_param.id = MEM_SYS_PARTITION;
partition_param.size = SYS_PARTITION_SIZE;
partition_param.p_addr = (u8 *)heap_start;
partition_param.atom_size = SYS_PARTITION_ATOM;
partition_param.user_id = SYS_MODULE_SYSTEM;
partition_param.method_id = MEM_METHOD_NORMAL;
ret = MEM_CREATE_PARTITION(&partition_param);
MT_ASSERT(FALSE != ret);
mtos_mem_init(mt_mem_malloc, mt_mem_free);
//create timer task
pstack_pnt = (u32*)mtos_malloc(SYS_TIMER_TASK_STK_SIZE);
MT_ASSERT(pstack_pnt != NULL);
ret = mtos_task_create((u8 *)"Timer",
Task_SysTimer,
(void *)0,
SYS_TIMER_TASK_PRIORITY,
pstack_pnt,
SYS_TIMER_TASK_STK_SIZE);
MT_ASSERT(FALSE != ret);
// init_dual_printk();
//init message queue
mtos_irq_enable(TRUE);
ret = mtos_message_init();
MT_ASSERT(FALSE != ret);
mtos_task_sleep(100);
ap_init();
mtos_task_exit();
}
int main( const int argc, const char * const argv[] )
{
char verbose = 0;
const struct ap_Option options[] =
{
{ 'H', "hidden", ap_no },
{ 'V', "version", ap_no },
{ 'a', "append", ap_no },
{ 'b', "block", ap_yes },
{ 'c', "casual", ap_maybe },
{ 'h', "help", ap_no },
{ 'o', 0, ap_yes },
{ 'q', "quiet", ap_no },
{ 'u', "uncaught", ap_no },
{ 'v', "verbose", ap_no },
{ 256, "orphan", ap_no },
{ 0, 0, ap_no } };
struct Arg_parser parser;
int argind;
invocation_name = argv[0];
if( !ap_init( &parser, argc, argv, options, 0 ) )
{ show_error( "Memory exhausted.", 0, 0 ); return 1; }
if( ap_error( &parser ) ) /* bad option */
{ show_error( ap_error( &parser ), 0, 1 ); return 1; }
for( argind = 0; argind < ap_arguments( &parser ); ++argind )
{
const int code = ap_code( &parser, argind );
if( !code ) break; /* no more options */
switch( code )
{
case 'H': break; /* example, do nothing */
case 'V': show_version(); return 0;
case 'a': break; /* example, do nothing */
case 'b': break; /* example, do nothing */
case 'c': break; /* example, do nothing */
case 'h': show_help( verbose ); return 0;
case 'o': break; /* example, do nothing */
case 'q': verbose = 0; break;
/* case 'u': break; */ /* intentionally not caught */
case 'v': verbose = 1; break;
case 256: break; /* example, do nothing */
default : internal_error( "uncaught option" );
}
} /* end process options */
for( argind = 0; argind < ap_arguments( &parser ); ++argind )
{
const int code = ap_code( &parser, argind );
const char * const arg = ap_argument( &parser, argind );
if( code ) /* option */
{
const char * const name = optname( code, options );
if( !name[1] )
printf( "option '-%c'", name[0] );
else
printf( "option '--%s'", name );
if( arg[0] )
printf( " with argument '%s'", arg );
}
else /* non-option */
printf( "non-option argument '%s'", arg );
printf( "\n" );
}
if( !ap_arguments( &parser ) ) printf( "Hello, world!\n" );
return 0;
}
/******************************************************************//**
* @brief Parsing commandline arguments.
*
* @param[in] argc - count of arguments strings
* @param[in] argv[] - array of arguments strings
*
* @retval err_result_ok - if execution was successful
* @retval err_not_found - if no arguments found
* @retval err_result_error - if parsing was unsuccessful
*********************************************************************/
errType process_cmdLine(int argc, char *argv[])
{
/**
* @todo reorganize process to external library
*/
errType result=err_result_ok;
/// 1. Define arguments type: with (\a ap_yes) or without (\a ap_no) parameters
const ap_Option options[] =
{
{ 'V', "version", ap_no },
{ 'h', "help", ap_no },
{ 'v', "verbose", ap_no },
{ 'u', "srv_udp_port", ap_yes},
{ 's', "eqp_udp_send_port", ap_yes},
{ 'r', "eqp_udp_recv_port", ap_yes},
{ 'i', "eqp_ip_addr", ap_yes},
{ 0, 0, ap_no } };
Arg_parser parser;
int argind;
///2. Initialize arguments parser ::ap_init
if( !ap_init( &parser, argc, argv, options, 0 ) )
{ show_error( "Необходимо задать аргументы запуска!", 0, 0 ); return err_not_found; }
///3. Check for parsing errors ::ap_error
if( ap_error( &parser ) ) /* bad option */
{ show_error( ap_error( &parser ), 0, 1 ); return err_result_error; }
///4. Execute all arguments after it parsing
for( argind = 0; argind < ap_arguments( &parser ); ++argind )
{
/// - get code of argument ::ap_code
const int code = ap_code( &parser, argind );
if( !code ) break; // no more options
/// - switch with argument code value
switch( code ){
/// - execute
case 'V': show_version(); return err_extra;
case 'h': show_help( verbose_level ); return err_extra;
case 'v': verbose_level = 1; break;
case 'u': break;
case 's': break;
case 'r': break;
case 'i': break;
default : internal_error( "неподдерживаемая опция" ); return err_extra;
}
} // end process options
///4. Execute only arguments with parameters after it parsing
for( argind = 0; argind < ap_arguments( &parser ); ++argind )
{
/// - get code of argument ::ap_code
const int code = ap_code( &parser, argind );
/// - get argument parameter ::ap_argument
const char * arg = ap_argument( &parser, argind );
/// - switch with argument code value
switch(code){
/// - execute
case 'u':
wUdp=atol(arg);
break;
case 's':
eq_udp_sending_port=atol(arg);
break;
case 'r':
eq_udp_listen_port=atol(arg);
break;
case 'i':
strcpy(eq_ip_addr, arg);
inet_aton(eq_ip_addr,&equipAddr);
break;
default:
break;
}
if( !code ) { // option
// non-option
printf( "аргумент `%s' не является опцией", arg );
printf( "\n" );
result=err_result_error;
}
}
if (!ap_arguments( &parser )) result=err_result_ok;
return result;
}
void TaskStart (void *data)
{
extern u32 _end;
u32 bss_end = (u32)(&_end);
BOOL ret = FALSE;
u32 *pstack_pnt = NULL;
u32 heap_start = 0;
// u32 montage_auto = 0;
u32 cpuclk = 0;
heap_start = ROUNDUP(bss_end,4);
mtos_irq_init();
// hal_warriors_attach(&hal_config);
extern void hal_concerto_attach(void);
hal_concerto_attach( );
mtos_register_putchar(uart_write_byte);
mtos_register_getchar(uart_read_byte_polling);
//mtos_ticks_init(SYS_CPU_CLOCK);
hal_module_clk_get(HAL_CPU0, &cpuclk);
mtos_ticks_init(cpuclk);
mem_mgr_partition_param_t partition_param = { 0 };//, partition2_param = { 0 };
uart_init(0);
uart_init(1);
//init memory manager, to the memory end
mem_mgr_init((u8 *)heap_start, SYSTEM_MEMORY_END);
//create system partition
partition_param.id = MEM_SYS_PARTITION;
partition_param.size = SYS_PARTITION_SIZE;
partition_param.p_addr = (u8 *)heap_start;
partition_param.atom_size = SYS_PARTITION_ATOM;
partition_param.user_id = SYS_MODULE_SYSTEM;
partition_param.method_id = MEM_METHOD_NORMAL;
ret = MEM_CREATE_PARTITION(&partition_param);
MT_ASSERT(FALSE != ret);
#if 0
OS_PRINTF("\n 1. mem_start[0x%x]\n", heap_start);
OS_PRINTF("\n 2. system memory size[%d]\n", SYSTEM_MEMORY_END);
OS_PRINTF("SYS_PARTITION_SIZE is %x\n", SYS_PARTITION_SIZE);
OS_PRINTF("create SYS_PARTITION111 ok!\n");
partition2_param.id = MEM_DMA_PARTITION;
partition2_param.size = DMA_PARTITION_SIZE;
partition2_param.p_addr = (u8 *)((heap_start + SYS_PARTITION_SIZE + 0x40000) | 0xa0000000);
partition2_param.atom_size = DMA_PARTITION_ATOM;
partition2_param.user_id = SYS_MODULE_SYSTEM;
partition2_param.method_id = MEM_METHOD_NORMAL;
OS_PRINTF("\n 1. mem_start[0x%x]\n", partition2_param.p_addr);
OS_PRINTF("\n 2. system memory size[%d]\n", SYSTEM_MEMORY_END);
OS_PRINTF("SYS_PARTITION_SIZE is 0x%x\n", DMA_PARTITION_SIZE);
ret = MEM_CREATE_PARTITION(&partition2_param);
MT_ASSERT(FALSE != ret);
#endif
mtos_mem_init(mt_mem_malloc, mt_mem_free);
#if 0
OS_PRINTF("Now check os version!\n");
u32 os_version = get_os_version();
if (os_version != 0x11112222) {
OS_PRINTF("Wrong os version, please talk with os person!\n");
}
OS_PRINTF("Os version pass!\n");
if(CPU_IS_AP) {
OS_PRINTF("AP CPU id get pass \n");
}else{
OS_PRINTF("cannot get right cpu id \n");
}
#endif
//create timer task
pstack_pnt = (u32*)mtos_malloc(SYS_TIMER_TASK_STK_SIZE);
MT_ASSERT(pstack_pnt != NULL);
ret = mtos_task_create((u8 *)"Timer",
Task_SysTimer,
(void *)0,
SYS_TIMER_TASK_PRIORITY,
pstack_pnt,
SYS_TIMER_TASK_STK_SIZE);
MT_ASSERT(FALSE != ret);
// init_dual_printk();
//init message queue
//OS_PRINTF("start mtos_irq_enable!!!!!!!!!!!!!!\n");
mtos_irq_enable(TRUE);
ret = mtos_message_init();
MT_ASSERT(FALSE != ret);
#ifdef CORE_DUMP_DEBUG
mtos_stat_init();
#endif
init_section();
mtos_task_sleep(100);
ap_init();
mtos_task_exit();
}
void task_sys_init(void *p_data)
{
BOOL ret = FALSE;
u32 *p_pstack_pnt = NULL;
mem_mgr_partition_param_t partition_param = { 0 };
extern void Task_SysTimer(void *p_data);
extern void ap_init(void);
hal_config_t hal_config = {0};
hal_win32_attach(&hal_config);
//init memory manager, to the memory end
mem_mgr_init((u8 *)get_mem_addr(), SYS_MEMORY_END);
/* create SYS partition */
partition_param.id = MEM_SYS_PARTITION;
partition_param.size = SYS_PARTITION_SIZE;
partition_param.p_addr = (u8 *)get_mem_addr();
partition_param.atom_size = SYS_PARTITION_ATOM;
partition_param.user_id = SYS_MODULE_SYSTEM;
partition_param.method_id = MEM_METHOD_NORMAL;
ret = MEM_CREATE_PARTITION(&partition_param);
MT_ASSERT(FALSE != ret);
OS_PRINTF("create patition ok!\n");
//register malloc/free function, using system partition
mtos_mem_init(my_malloc, my_free);
OS_PRINTF("init mem ok!\n");
mtos_ticks_init(SYS_CPU_CLOCK);
//init message queue
ret = mtos_message_init();
MT_ASSERT(FALSE != ret);
#ifdef CORE_DUMP_DEBUG
//start statistic task, MUST BE in the first task!
mtos_stat_init();
#endif
//create timer task
p_pstack_pnt = (u32*)mtos_malloc(SYS_TIMER_TASK_STKSIZE);
MT_ASSERT(p_pstack_pnt != NULL);
ret = mtos_task_create((u8 *)"Timer",
Task_SysTimer,
(void *)0,
SYS_TIMER_TASK_PRIORITY,
p_pstack_pnt,
SYS_TIMER_TASK_STKSIZE);
MT_ASSERT(FALSE != ret);
OS_PRINTF("create timer task ok!\n");
mtos_task_sleep(M_TASK_SLEEP_TIME);//25
OS_PRINTF("start ap init!\n");
ret = ota_check();
if(ret == TRUE)
{
ap_init();
OS_PRINTF("ap init ok!\n");
}
else
{
MT_ASSERT(0);
}
mtos_task_exit();
}
void TaskStart (void *data)
{
extern u32 _end;
u32 bss_end = (u32)(&_end);
BOOL ret = FALSE;
u32 heap_start = 0;
u32 cpuclk = 0;
heap_start = ROUNDUP(bss_end,4);
mtos_irq_init();
extern void hal_concerto_attach(void);
hal_concerto_attach( );
mtos_register_putchar(uart_write_byte);
mtos_register_getchar(uart_read_byte);
hal_module_clk_get(HAL_CPU0, &cpuclk);
mtos_ticks_init(cpuclk);
/* uart1 pin mux */
gpio_mux();
uart_init(0);
uart_init(1);
uart_set_param(0, 115200, 8, 1, 0);
uart_set_param(1, 115200, 8, 1, 0);
OS_PRINTF("\n FastLogo app start\n");
OS_PRINTF("\n Built at %s \n", buildSTR);
OS_PRINTF("\n 1. heap_start[0x%x]\n", heap_start);
OS_PRINTF("\n 2. whole memory size[0x%x]\n", (WHOLE_MEM_END & 0xFFFFFFF));
OS_PRINTF("\n 3. SYS_PARTITION_SIZE is 0x%x, GUI_RESOURCE_BUFFER_ADDR is 0x%x\n", SYS_PARTITION_SIZE, GUI_RESOURCE_BUFFER_ADDR);
if((heap_start + SYS_PARTITION_SIZE) > (GUI_RESOURCE_BUFFER_ADDR + 0x80000000))
{
OS_PRINTF("system partition is overlaped %d\n", (heap_start + SYS_PARTITION_SIZE) - GUI_RESOURCE_BUFFER_ADDR - 0x80000000);
MT_ASSERT(0);
}
//init memory manager, only 11M
//mem_mgr_init((u8 *)heap_start, SYS_PARTITION_SIZE + (1 * 1024 * 1024));
OS_PRINTF("\n 4. free mem size 0x%x address from 0x%x to 0x%x\n",
(GUI_RESOURCE_BUFFER_ADDR | 0x80000000) - (heap_start + SYS_PARTITION_SIZE),
(heap_start + SYS_PARTITION_SIZE),(GUI_RESOURCE_BUFFER_ADDR | 0x80000000));
mem_mgr_init((u8 *)heap_start,
SYS_PARTITION_SIZE);
OS_PRINTF("\n 5. mem_mgr_start[0x%x],size=0x%x\n", heap_start,
SYS_PARTITION_SIZE);
dlmem_init((void *)heap_start,
SYS_PARTITION_SIZE);
mtos_mem_init(dl_malloc, dl_free);
OS_PRINTF("init mem ok!\n");
//enable interrupt
mtos_irq_enable(TRUE);
//init message queue
ret = mtos_message_init();
MT_ASSERT(FALSE != ret);
ap_init();
mtos_task_exit();
}
static UWORD crysbind(WORD opcode, LONG pglobal, WORD control[], WORD int_in[], WORD int_out[], LONG addr_in[])
{
LONG maddr;
LONG tree;
WORD mouse, ret;
WORD unsupported = FALSE;
maddr = 0;
ret = TRUE;
switch(opcode)
{
/* Application Manager */
case APPL_INIT:
#if DBG_GEMSUPER
aestrace("appl_init()");
#endif
LWSET(pglobal, AES_VERSION); /* version number */
LWSET(pglobal+2, 0x0001); /* num of concurrent procs*/
/* LLSET(pglobal, 0x00010200L);
*/
LWSET(pglobal+4, rlr->p_pid);
sh_deskf(0, pglobal+6);
LWSET(pglobal+20, gl_nplanes);
LLSET(pglobal+22, ADDR(&D));
/* reset dispatcher */
/* count to let the app*/
/* run a while. */
dspcnt = 0;
ret = ap_init();
break;
case APPL_READ:
case APPL_WRITE:
ap_rdwr(opcode == APPL_READ ? MU_MESAG : MU_SDMSG,
fpdnm(NULLPTR, AP_RWID), AP_LENGTH, AP_PBUFF);
break;
case APPL_FIND:
ret = ap_find( AP_PNAME );
break;
case APPL_TPLAY:
ap_tplay(AP_TBUFFER, AP_TLENGTH, AP_TSCALE);
break;
case APPL_TRECORD:
ret = ap_trecd(AP_TBUFFER, AP_TLENGTH);
break;
#if CONF_WITH_PCGEM
case APPL_YIELD:
dsptch();
break;
#endif
case APPL_EXIT:
#if DBG_GEMSUPER
aestrace("appl_exit()");
#endif
ap_exit();
break;
/* Event Manager */
case EVNT_KEYBD:
ret = ev_block(MU_KEYBD, 0x0L);
break;
case EVNT_BUTTON:
ret = ev_button(B_CLICKS, B_MASK, B_STATE, &EV_MX);
break;
case EVNT_MOUSE:
ret = ev_mouse((MOBLK *)&MO_FLAGS, &EV_MX);
break;
case EVNT_MESAG:
#if DBG_GEMSUPER
aestrace("evnt_mesag()");
#endif
ap_rdwr(MU_MESAG, rlr, 16, ME_PBUFF);
break;
case EVNT_TIMER:
ev_timer( HW(T_HICOUNT) + LW(T_LOCOUNT) );
break;
case EVNT_MULTI:
#if DBG_GEMSUPER
aestrace("evnt_multi()");
#endif
if (MU_FLAGS & MU_TIMER)
maddr = HW(MT_HICOUNT) + LW(MT_LOCOUNT);
tree = HW(MB_CLICKS) | LW((MB_MASK << 8) | MB_STATE);
ret = ev_multi(MU_FLAGS, (MOBLK *)&MMO1_FLAGS, (MOBLK *)&MMO2_FLAGS,
maddr, tree, MME_PBUFF, &EV_MX);
break;
case EVNT_DCLICK:
ret = ev_dclick(EV_DCRATE, EV_DCSETIT);
break;
/* Menu Manager */
case MENU_BAR:
if (gl_mnppd == rlr || gl_mnppd == NULL)
mn_bar(MM_ITREE, SHOW_IT, rlr->p_pid);
else
menu_tree[rlr->p_pid] = (SHOW_IT) ? MM_ITREE : 0x0L;
break;
case MENU_ICHECK:
do_chg(MM_ITREE, ITEM_NUM, CHECKED, CHECK_IT, FALSE, FALSE);
break;
case MENU_IENABLE:
do_chg(MM_ITREE, (ITEM_NUM & 0x7fff), DISABLED,
!ENABLE_IT, ((ITEM_NUM & 0x8000) != 0x0), FALSE);
break;
case MENU_TNORMAL:
if (gl_mntree == menu_tree[rlr->p_pid])
do_chg(MM_ITREE, TITLE_NUM, SELECTED, !NORMAL_IT,
TRUE, TRUE);
break;
case MENU_TEXT:
tree = MM_ITREE;
strcpy((char *)LLGET(OB_SPEC(ITEM_NUM)),
(char *)MM_PTEXT);
break;
case MENU_REGISTER:
ret = mn_register(MM_PID, MM_PSTR);
break;
case MENU_UNREGISTER:
#if CONF_WITH_PCGEM
/* distinguish between menu_unregister() and menu_popup() */
if (IN_LEN == 1)
mn_unregister( MM_MID );
else
#endif
unsupported = TRUE;
break;
case MENU_CLICK:
/* distinguish between menu_click() and menu_attach() */
/*
* although menu_click() is PC-GEM only, it's always
* enabled because the desktop uses it.
*/
if (IN_LEN == 2) {
if (MN_SETIT)
gl_mnclick = MN_CLICK;
ret = gl_mnclick;
} else
unsupported = TRUE;
break;
/* Object Manager */
case OBJC_ADD:
ob_add(OB_TREE, OB_PARENT, OB_CHILD);
break;
case OBJC_DELETE:
ob_delete(OB_TREE, OB_DELOB);
break;
case OBJC_DRAW:
gsx_sclip((GRECT *)&OB_XCLIP);
ob_draw(OB_TREE, OB_DRAWOB, OB_DEPTH);
break;
case OBJC_FIND:
ret = ob_find(OB_TREE, OB_STARTOB, OB_DEPTH,
OB_MX, OB_MY);
break;
case OBJC_OFFSET:
ob_offset(OB_TREE, OB_OBJ, &OB_XOFF, &OB_YOFF);
break;
case OBJC_ORDER:
ob_order(OB_TREE, OB_OBJ, OB_NEWPOS);
break;
case OBJC_EDIT:
gsx_sclip(&gl_rfull);
OB_ODX = OB_IDX;
ret = ob_edit(OB_TREE, OB_OBJ, OB_CHAR, &OB_ODX, OB_KIND);
break;
case OBJC_CHANGE:
gsx_sclip((GRECT *)&OB_XCLIP);
ob_change(OB_TREE, OB_DRAWOB, OB_NEWSTATE, OB_REDRAW);
break;
/* Form Manager */
case FORM_DO:
ret = fm_do(FM_FORM, FM_START);
break;
case FORM_DIAL:
ret = fm_dial(FM_TYPE, (GRECT *)&FM_X);
break;
case FORM_ALERT:
ret = fm_alert(FM_DEFBUT, FM_ASTRING);
break;
case FORM_ERROR:
ret = fm_error(FM_ERRNUM);
break;
case FORM_CENTER:
ob_center(FM_FORM, (GRECT *)&FM_XC);
break;
case FORM_KEYBD:
gsx_sclip(&gl_rfull);
FM_OCHAR = FM_ICHAR;
FM_ONXTOB = FM_INXTOB;
ret = fm_keybd(FM_FORM, FM_OBJ, &FM_OCHAR, &FM_ONXTOB);
break;
case FORM_BUTTON:
gsx_sclip(&gl_rfull);
ret = fm_button(FM_FORM, FM_OBJ, FM_CLKS, &FM_ONXTOB);
break;
/* Graphics Manager */
case GRAF_RUBBOX:
gr_rubbox(GR_I1, GR_I2, GR_I3, GR_I4,
&GR_O1, &GR_O2);
break;
case GRAF_DRAGBOX:
gr_dragbox(GR_I1, GR_I2, GR_I3, GR_I4, (GRECT *)&GR_I5,
&GR_O1, &GR_O2);
break;
case GRAF_MBOX:
gr_movebox(GR_I1, GR_I2, GR_I3, GR_I4, GR_I5, GR_I6);
break;
case GRAF_GROWBOX:
gr_growbox((GRECT *)&GR_I1, (GRECT *)&GR_I5);
break;
case GRAF_SHRINKBOX:
gr_shrinkbox((GRECT *)&GR_I1, (GRECT *)&GR_I5);
break;
case GRAF_WATCHBOX:
ret = gr_watchbox(GR_TREE, GR_OBJ, GR_INSTATE, GR_OUTSTATE);
break;
case GRAF_SLIDEBOX:
ret = gr_slidebox(GR_TREE, GR_PARENT, GR_OBJ, GR_ISVERT);
break;
case GRAF_HANDLE:
GR_WCHAR = gl_wchar;
GR_HCHAR = gl_hchar;
GR_WBOX = gl_wbox;
GR_HBOX = gl_hbox;
ret = gl_handle;
break;
case GRAF_MOUSE:
if (GR_MNUMBER > 255)
{
if (GR_MNUMBER == M_OFF)
gsx_moff();
if (GR_MNUMBER == M_ON)
gsx_mon();
}
else
{
if (GR_MNUMBER != 255)
{
switch(GR_MNUMBER) {
case 1:
mouse = MICE01;
break;
case 2:
mouse = MICE02;
break;
case 3:
mouse = MICE03;
break;
case 4:
mouse = MICE04;
break;
case 5:
mouse = MICE05;
break;
case 6:
mouse = MICE06;
break;
case 7:
mouse = MICE07;
break;
default:
mouse = MICE00;
break;
}
maddr = *(LONG *) &rs_bitblk[mouse];
}
else
maddr = GR_MADDR;
gsx_mfset(maddr);
}
break;
case GRAF_MKSTATE:
gr_mkstate(&GR_MX, &GR_MY, &GR_MSTATE, &GR_KSTATE);
break;
/* Scrap Manager */
case SCRP_READ:
ret = sc_read((BYTE*)SC_PATH);
break;
case SCRP_WRITE:
ret = sc_write((const BYTE*)SC_PATH);
break;
#if CONF_WITH_PCGEM
case SCRP_CLEAR:
ret = sc_clear();
break;
#endif
/* File Selector Manager */
case FSEL_INPUT:
ret = fs_input((BYTE*)FS_IPATH, (BYTE*)FS_ISEL, &FS_BUTTON, NULL);
break;
case FSEL_EXINPUT:
ret = fs_input((BYTE*)FS_IPATH, (BYTE*)FS_ISEL, &FS_BUTTON, (BYTE *)FS_ILABEL);
break;
/* Window Manager */
case WIND_CREATE:
ret = wm_create(WM_KIND, (GRECT *)&WM_WX);
break;
case WIND_OPEN:
wm_open(WM_HANDLE, (GRECT *)&WM_WX);
break;
case WIND_CLOSE:
wm_close(WM_HANDLE);
break;
case WIND_DELETE:
wm_delete(WM_HANDLE);
break;
case WIND_GET:
wm_get(WM_HANDLE, WM_WFIELD, &WM_OX);
break;
case WIND_SET:
wm_set(WM_HANDLE, WM_WFIELD, &WM_IX);
break;
case WIND_FIND:
ret = wm_find(WM_MX, WM_MY);
break;
case WIND_UPDATE:
wm_update(WM_BEGUP);
break;
case WIND_CALC:
wm_calc(WM_WCTYPE, WM_WCKIND, WM_WCIX, WM_WCIY,
WM_WCIW, WM_WCIH, &WM_WCOX, &WM_WCOY,
&WM_WCOW, &WM_WCOH);
break;
case WIND_NEW:
wm_new();
break;
/* Resource Manager */
case RSRC_LOAD:
ret = rs_load(pglobal, RS_PFNAME);
break;
case RSRC_FREE:
ret = rs_free(pglobal);
break;
case RSRC_GADDR:
ret = rs_gaddr(pglobal, RS_TYPE, RS_INDEX, &ad_rso);
break;
case RSRC_SADDR:
ret = rs_saddr(pglobal, RS_TYPE, RS_INDEX, RS_INADDR);
break;
case RSRC_OBFIX:
rs_obfix(RS_TREE, RS_OBJ);
break;
/* Shell Manager */
case SHEL_READ:
sh_read((BYTE*)SH_PCMD, (BYTE*)SH_PTAIL);
break;
case SHEL_WRITE:
ret = sh_write(SH_DOEX, SH_ISGR, SH_ISCR, (const BYTE*)SH_PCMD, (const BYTE*)SH_PTAIL);
break;
case SHEL_GET:
sh_get((void*)SH_PBUFFER, SH_LEN);
break;
case SHEL_PUT:
sh_put((const void *)SH_PDATA, SH_LEN);
break;
case SHEL_FIND:
ret = sh_find((BYTE*)SH_PATH);
break;
case SHEL_ENVRN:
sh_envrn((BYTE**)SH_PATH, (const BYTE*)SH_SRCH);
break;
#if CONF_WITH_PCGEM
case SHEL_RDEF:
sh_rdef((BYTE*)SH_LPCMD, (BYTE*)SH_LPDIR);
break;
case SHEL_WDEF:
sh_wdef((const BYTE*)SH_LPCMD, (const BYTE*)SH_LPDIR);
break;
#endif
default:
unsupported = TRUE;
break;
}
if (unsupported) {
kprintf("Bad AES function %d\n", opcode);
if (opcode != 0) /* Ignore the 0 since some PRGs are this call */
fm_show(ALNOFUNC, &opcode, 1);
ret = -1;
}
return(ret);
}
