cgi_status cgi_cs_fec_set(cgi_handler_param_t *p)
{
cs_callback_context_t context;
cs_uint8 fec_mode;
if(epon_request_onu_fec_get(context,ONU_DEVICEID_FOR_API,ONU_LLIDPORT_FOR_API,&fec_mode) != CS_E_OK)
{
cs_printf("get fec status error\n");
return CS_E_ERROR;
}
if(fec_mode == 1)
{
fec_mode = 0;
}
else
{
fec_mode = 1;
}
if(epon_request_onu_fec_set(context,ONU_DEVICEID_FOR_API,ONU_LLIDPORT_FOR_API,fec_mode) != CS_E_OK)
{
cs_printf("set fec status error\n");
return CS_E_ERROR;
}
cgi_send_int(p,CGI_OK);
return CS_E_OK;
}
void cs_buf_print_mem(cs_uint32 level , cs_uint32 module_id , cs_int8 *pbuf , cs_int32 len)
{
cs_uint32 time = (cs_uint32)cs_current_time();
cs_printf("\r\n==============================================================================");
cs_printf("\r\n%08x: module=%s , level=%d",time,cs_sys_mod_desc_get(module_id),level);
cs_buf_print(pbuf, len);
}
static void startup_cfg_help()
{
cs_printf("scfg show - dump all startup configuration\n");
cs_printf("scfg show h - dump all startup configuration in hex-mode\n");
cs_printf("scfg reset - set all configuration to default value\n");
cs_printf("scfg set <T> <V> - set specific field value(T:type, V:value)\n");
cs_printf("scfg clear <type> - clear specific field\n");
}
int _main(uint32_t memory_size) {
init(memory_size);
cs_printf("Welcome to MicOS\n");
// Paging test
int *n = (int *)0x800003FF;
*n = 1;
cs_printf("This variable is %u, come from %h\n", *n, n);
return 0;
}
cs_int32 cs_sys_log_init()
{
#if 0
struct stat file_stat;
DIR *pDir = NULL;
pDir = opendir("/log");
if(pDir == NULL)
{
if(mkdir("/log", 0) != 0)
{
cs_printf("\r\n Open log directory failed.");
return 0;
}
}
sys_log_ctrl.log_fp = (void *)fopen(sys_log_file,"r+");
if(sys_log_ctrl.log_fp == NULL)
{
sys_log_ctrl.log_fp = (void *)fopen(sys_log_file,"w+");
}
fstat(fileno((FILE *)sys_log_ctrl.log_fp), &file_stat);
if(file_stat.st_size >= MAX_LOG_FILE_SIZE)
{
fseek((FILE *)sys_log_ctrl.log_fp , 0 , SEEK_SET);
fp_cursor = 0;
}
else
{
fseek((FILE *)sys_log_ctrl.log_fp , 0 , SEEK_END);
fp_cursor = file_stat.st_size;
}
return 0;
#else
cs_uint32 part_index = flash_part_id_to_part_index(IROS_FLASH_PARTITION_LOG_ID);
pSysLog = (cs_sys_log_t *)malloc(sizeof(cs_sys_log_t));
if(pSysLog == NULL)
{
cs_printf("Allocate sys log memory failed.\n");
return 0;
}
memcpy(pSysLog , flash_dev.info.super_block.part_tab[part_index].part_loc , sizeof(cs_sys_log_t));
if(pSysLog->log_magic != 0x12345678)
{
memset(pSysLog , 0 , sizeof(cs_sys_log_t));
pSysLog->log_magic = 0x12345678;
pSysLog->log_cursor = 0;
}
cs_mutex_init(&sys_log_mutex, "syslogmutex", 0);
cs_circle_timer_add(CS_LOG_WRITE_INTERVAL*1000, cs_sys_log_timer_notify, NULL);
return 0;
#endif
}
cs_status app_ipintf_inband_enable()
{
cs_status ret = CS_E_OK;
int ret_w;
ret_w = get_userdata_from_flash((unsigned char *)&g_slow_path_ip_cfg, GWD_PRODUCT_CFG_OFFSET_W, sizeof(g_slow_path_ip_cfg));
if(ret_w)
{
cs_printf("get ipdate fail..\n");
}
if(APP_IPINTF_INBNAD_MGNT == ipintf_info.inband) {
APP_IPINTF_LOG(IROS_LOG_LEVEL_INF,"No need set to INBAND \n");
return CS_E_OK;
}
#if 0
#else
cs_uint32 device_ip;
cs_uint32 device_mask;
cs_uint32 device_gateway;
cs_uint16 device_vlan;
ret = ip_info_get_from_global(&device_ip, &device_mask, &device_gateway, &device_vlan);
if(CS_E_OK != ret)
{
cs_printf("ip_info_get_from_global fail\n");
}
else
{
#if 0
cs_printf("ip_info_get_from_global success\n");
#endif
}
#endif
#if 0
ret = app_ipintf_ip_config_set(g_slow_path_ip_cfg.inband_ip,g_slow_path_ip_cfg.inband_ip_mask,0);
#else
// ret = app_ipintf_ip_config_set(device_ip,device_mask, device_gateway);
#endif
if(ret != CS_E_OK) {
return ret;
}
#if 1
ret = app_ipintf_set_wan_cfg(APP_IPINTF_INBNAD_MGNT, 0,device_vlan, 0, 0);
#else
ret = app_ipintf_set_wan_cfg(APP_IPINTF_OUTBNAD_MGNT, 0,device_vlan, 0, 0);
#endif
APP_IPINTF_LOG(IROS_LOG_LEVEL_INF,"Set to INBAND \n");
return ret;
}
void img_upgrade_show()
{
cs_printf("status:---------(%d)\n", g_img_upgrade_cb.status);
cs_printf("cabllback:-------(%p)\n", g_img_upgrade_cb.callback);
cs_printf("max size:--------(%d)\n", g_img_upgrade_cb.size);
cs_printf("curr size:--------(%d)\n", g_img_upgrade_cb.curr_len);
cs_printf("total size:--------(%d)\n", g_img_upgrade_cb.total_len);
cs_printf("next seq:--------(%d)\n", g_img_upgrade_cb.next_seq);
cs_printf("conf policy-------(%d)\n", g_img_upgrade_cb.direct_confirm);
cs_printf("watch dog-------(%d)\n", g_img_upgrade_cb.watchdog_enable);
cs_printf("name:-----------(%s)\n", g_img_upgrade_cb.name);
cs_printf("buff addr:--------(%p)\n", g_img_upgrade_cb.buf);
}
static int startup_config_write_to_flash(void *addr , int len)
{
#ifdef HAVE_SCFG_PROTECTION
unsigned int part_index = IROS_FLASH_PARTITION_INDEX_ANY;
#endif
char *startup_cfg_addr = NULL;
int written_len = 0;
if(!scfg_autosave_flag)
return 0;
#ifdef HAVE_SCFG_PROTECTION
part_index = flash_part_id_to_part_index(SCFG_PARTION);
if(active_part_index == part_index)
active_part_index = flash_part_id_to_part_index(SCFG_PARTION1);
else
active_part_index = part_index;
#endif
if(active_part_index == IROS_FLASH_PARTITION_INDEX_ANY)
{
if(scfg_warning_flag == 0)
cs_printf("write startup-cfg error!\n");
return -1;
}
startup_cfg_addr = flash_dev.info.super_block.part_tab[active_part_index].part_loc;
if (flash_part_write_init(active_part_index, startup_cfg_addr)) { /* prepare to write flash */
startup_cfg_encrypt((char *)addr+sizeof(tlv_header_t), len-sizeof(tlv_header_t));
written_len = flash_write(startup_cfg_addr, (char *)addr, len);
flash_part_write_done(active_part_index);
flash_write_verify(startup_cfg_addr, (char *)addr, len);
if(written_len != len)
{
startup_cfg_decrypt((char *)addr+sizeof(tlv_header_t), len-sizeof(tlv_header_t));
if(scfg_warning_flag == 0)
cs_printf("write startup-config error\n");
return -1;
}
startup_cfg_decrypt((char *)addr+sizeof(tlv_header_t), len-sizeof(tlv_header_t));
if(scfg_warning_flag == 0)
cs_printf("write startup-cfg successfully\n");
return 0;
}
else
{
if(scfg_warning_flag == 0)
cs_printf("write startup-cfg error\n");
}
return -1;
}
void app_ipintf_mac_table_dump(cs_uint32 port)
{
cs_uint32 i = 0;
cs_printf("ARP table:\n");
for(i=0; i<IPINTF_MAC_ENTRY_MAX; i++){
if(MACTBL[i].used) {
cs_printf("index = %2d: used %d,hit %d, vlanid %4d, dpid %d,"
"ESA = %02X %02X %02X %02X %02X %02X\n",i,
MACTBL[i].used,MACTBL[i].hit, MACTBL[i].vlanid, MACTBL[i].dpid,
MACTBL[i].mac[0],MACTBL[i].mac[1],MACTBL[i].mac[2],
MACTBL[i].mac[3],MACTBL[i].mac[4],MACTBL[i].mac[5]);
}
}
}
/* Invalid standby blob XIP crc to 0xFFFFFFFF for Bug 23377 */
cs_uint32 standby_blob_crc_invalidate(void)
{
blob_info_desc_t *active_blob_info;
blob_info_desc_t *standby_blob_info;
unsigned int act_blob_idex,sty_blob_idex;
cs_callback_context_t context;
void *temp_ptr=NULL;
act_blob_idex = current_blob_desc.blob_idx;
active_blob_info = blob_info_tab[act_blob_idex];
/* if current active blob is not commited invalid standby blob crc */
if(active_blob_info->is_not_confirmed){
/* Disable watchdog enabled by loader for Bug 28609 */
cs_plat_wdt_disable(context,0,0);
/* used to back up first block data*/
temp_ptr=iros_malloc(IROS_MID_SYS, flash_dev.info.super_block.block_size);
if(NULL == temp_ptr){
cs_printf("Invalidate standby blob xip crc failed for no memory\n");
return CS_ERROR;
}
sty_blob_idex = 0x1 &(act_blob_idex + 1);
/* back up standby data */
memcpy(temp_ptr,blob_info_tab[sty_blob_idex],flash_dev.info.super_block.block_size);
standby_blob_info = (blob_info_desc_t *)temp_ptr;
standby_blob_info->xip_crc32 = 0xffffffff;
/* prepare to write flash with erase */
if (flash_part_write_init(blob_part_tab[sty_blob_idex],
(char*)blob_info_tab[sty_blob_idex])) {
flash_write((char *)blob_info_tab[sty_blob_idex],
(char *)temp_ptr, flash_dev.info.super_block.block_size);
cs_printf("Standby blob xip crc invalidated \n");
flash_part_write_done(blob_part_tab[sty_blob_idex]);
}
else {
// cs_printf("Standby blob invalidate failed \n");
iros_free(temp_ptr);
return CS_ERROR;
}
iros_free(temp_ptr);
}
return CS_OK;
}
void cs_sys_log_timer_proc(void *data)
{
cs_uint32 part_index = flash_part_id_to_part_index(IROS_FLASH_PARTITION_LOG_ID);
char *log_addr = NULL;
int written_len = 0;
if(log_is_changed == 0) /*sys log is changed*/
return;
cs_mutex_lock(sys_log_mutex);
log_addr = flash_dev.info.super_block.part_tab[part_index].part_loc;
flash_part_write_init(part_index, log_addr);
written_len = flash_write(log_addr, (char *)pSysLog, sizeof(cs_sys_log_t));
flash_part_write_done(part_index);
sys_log_write = 0;
log_is_changed = 0;
if(written_len != sizeof(cs_sys_log_t))
{
cs_printf("write log error\n");
cs_mutex_unlock(sys_log_mutex);
return;
}
cs_mutex_unlock(sys_log_mutex);
return;
}
cs_status ssp_oper_trigger_done(void)
{
AHB_SSP_CTRL_t ctrl;
cs_uint32 cnt = SSP_POLL_TIME;
/* start the control to receive the data.
* poll until it finishes */
CS_REG_READ(IROS_AHB_SSP_CTRL, ctrl.wrd);
ctrl.bf.sspstart = 1;
CS_REG_WRITE(IROS_AHB_SSP_CTRL, ctrl.wrd);
do {
CS_REG_READ(IROS_AHB_SSP_CTRL, ctrl.wrd);
if (ctrl.bf.sspdone) {
break;
}
} while (cnt--);
if (cnt <= 0) {
/* unable to receive completely before count runs out */
cs_printf("couldn't complete receiving data\n");
return CS_E_TIMEOUT;
}
/* write sspdone back to register to clear off */
CS_REG_READ(IROS_AHB_SSP_CTRL, ctrl.wrd);
ctrl.bf.sspdone = 1;
CS_REG_WRITE(IROS_AHB_SSP_CTRL, ctrl.wrd);
return CS_E_OK;
}
void handle_cs_oams(
cs_uint32 port,
cs_uint8 *frame,
cs_uint32 len)
{
cs_oam_pdu_hdr_t * oam_pdu = (cs_oam_pdu_hdr_t*)frame;
switch(oam_pdu->opcode)
{
case CS_OAM_OPCODE_HELLO:
#ifdef HAVE_ONU_HELLO
onu_hello_proc(oam_pdu->data, (cs_int32)(len - sizeof(cs_oam_pdu_hdr_t)), g_oam_port);
#endif
break;
case CS_OAM_OPCODE_EVENT:
#ifdef HAVE_ONU_EVENT
onu_event_proc(oam_pdu->data, (cs_int32)(len - sizeof(cs_oam_pdu_hdr_t)), g_oam_port);
#endif
break;
default:
cs_printf("Not support opcode %d\n", oam_pdu->opcode);
return;
}
}
cgi_status cgi_cs_qos_quen_map_get(cgi_handler_param_t * p)
{
cs_callback_context_t qos_context;
cs_pri_cos_map_t quen_map;
cs_uint8 index;
cs_int8 buff[CGI_MAX_BUFF_LEN];
cs_int8 tmpBuff[CGI_MAX_BUFF_LEN];
memset(buff, 0, sizeof(buff));
sprintf(buff, "%s", "{quen_map:\"");
if(epon_request_onu_dot1p_map_get(qos_context,QOS_DEVICE_ID,LLID_PORTID,&quen_map) != CS_E_OK)
{
cs_printf("get dot1p map error\n");
return CS_E_ERROR;
}
for(index=0;index<8;index++)
{
memset(tmpBuff, 0, sizeof(tmpBuff));
sprintf(tmpBuff, "%d", quen_map.cos[index]);
strcat(buff, tmpBuff);
}
strcat(buff,"\" }");
CGI_DEBUG("send buf = %s \n",buff);
cgi_send_str(p, buff,strlen(buff));
return CS_E_OK;
}
static void startup_config_clear(int type)
{
int field_idx = -1;
cfg_field_t *pField = NULL;
unsigned char c_v = 0;
unsigned short s_v = 0;
unsigned int i_v = 0;
unsigned char buf[64];
tlv_header_t *pHeader = NULL;
cs_uint8 active_cnt = 9;
tlv_instance_t *pInst = (tlv_instance_t *)gStartupInst;
field_idx = startup_config_field_idx_get(type);
if(field_idx == -1)
{
cs_printf("Invalid type.\n");
return;
}
pHeader = (tlv_header_t *)pInst->base_address;
#ifdef HAVE_SCFG_PROTECTION
active_cnt = pHeader->active;
if(active_cnt == SCFG_MAX_CNT)
active_cnt = 0;
else
active_cnt++;
#else
active_cnt = SCFG_MAX_CNT;
#endif
tlv_write_active(gStartupInst , active_cnt);
pField = &glb_field[field_idx];
switch(pField->value_type)
{
case FIELD_TYPE_CHAR:
c_v = (unsigned char)pField->dflt_val;
tlv_write_char(gStartupInst, type , c_v);
break;
case FIELD_TYPE_SHORT:
s_v = (unsigned short)pField->dflt_val;
tlv_write_short(gStartupInst, type , s_v);
break;
case FIELD_TYPE_INT:
i_v = (unsigned int)pField->dflt_val;
tlv_write_int(gStartupInst, type , i_v);
break;
case FIELD_TYPE_BUFF:
tlv_write_buffer(gStartupInst, type, pField->value_max_len, pField->value_max_len, pField->dflt_buf);
break;
case FIELD_TYPE_STRING:
memset(buf , 0, sizeof(buf));
tlv_write_buffer(gStartupInst, type, pField->value_max_len, pField->value_max_len, buf);
break;
default:
break;
}
return;
}
void __show_uni_status(cs_port_id_t portid)
{
cs_callback_context_t context;
cs_status status = 0;
cs_sdl_port_link_status_t link_status;
cs_sdl_port_ether_speed_t speed;
cs_sdl_port_ether_duplex_t duplex;
cs_sdl_port_autoneg_status_t auto_neg;
//portid = CS_UNI_PORT_ID1;
if(portid == CS_UPLINK_PORT || portid == CS_DOWNLINK_PORT){
return;
}
status = epon_request_onu_port_link_status_get(context, 0, 0, portid, &link_status);
if(status != CS_E_OK){
cs_printf("epon_request_onu_port_link_status_get failed \n");
return;
}
status = epon_request_onu_port_speed_get(context, 0, 0, portid, &speed);
if(status != CS_E_OK){
cs_printf("epon_request_onu_port_speed_get failed \n");
return;
}
status = epon_request_onu_port_duplex_get(context, 0, 0, portid, &duplex);
if(status != CS_E_OK){
cs_printf("epon_request_onu_port_duplex_get failed \n");
return;
}
status = epon_request_onu_port_auto_neg_get(context, 0, 0, portid, &auto_neg);
if(status != CS_E_OK){
cs_printf("epon_request_onu_port_auto_neg_get failed \n");
return;
}
cs_printf("----------------------------------\n");
cs_printf("Link is %s!\n", (link_status == SDL_PORT_ADMIN_UP) ? "UP" : "DOWN");
cs_printf("Actual speed is %s!\n", actualspeed2string[speed]);
cs_printf("Actual duplex is %s\n", actualduplex2string[duplex]);
cs_printf("Auto neg is %s\n", autoneg2string[auto_neg]);
cs_printf("----------------------------------\n");
}
void cs_sys_log_dump()
{
#if 0
FILE *fp = NULL;
cs_int8 str[2*CS_LOG_SIZE];
cs_uint32 count_str = 0;
fp = fopen(sys_log_file , "r");
if(fp == NULL)
return;
memset(str , 0 , sizeof(str));
while(fgets(str, sizeof(str), fp) != NULL)
{
cs_printf("%s",str);
count_str++;
if(count_str >= 30)
{
cs_thread_delay(10);
count_str = 0;
}
memset(str , 0 , sizeof(str));
}
fclose(fp);
return;
#else
char str[MAX_SYS_LOG_LEN+1];
int i;
int cursor = 0;
cs_mutex_lock(sys_log_mutex);
for(i = 0 ; i < MAX_SYS_LOG_NUM ; i++)
{
cursor = (pSysLog->log_cursor + i)%MAX_SYS_LOG_NUM;
if(pSysLog->log_buf[cursor][0] == '\0')
continue;
memset(str , 0 , MAX_SYS_LOG_LEN+1);
memcpy(str , pSysLog->log_buf[cursor] , MAX_SYS_LOG_LEN);
cs_printf("%s",str);
}
cs_mutex_unlock(sys_log_mutex);
return;
#endif
}
void cs_buffer_dump(cs_int8 *comment , cs_int8 *buf , cs_int32 len)
{
#ifdef HAVE_LOG_THREAD
cs_log_t *log;
cs_int32 comment_len=0;
cs_int32 buf_len = 0;
log = (cs_log_t *)cs_mem_malloc(sys_log_ctrl.mempool_id);
if(log == NULL)
return;
memset(log , 0 , sizeof(cs_log_t));
log->log_level = -1;
log->module_id = -1;
log->time = cs_current_time();
log->log_type = CS_LOG_HEX_TYPE;
comment_len = (strlen(comment) >= CS_LOG_COMMENT_LEN)?CS_LOG_COMMENT_LEN-1:strlen(comment);
buf_len = (len >= CS_LOG_SIZE-CS_LOG_COMMENT_LEN-4)?CS_LOG_SIZE-CS_LOG_COMMENT_LEN-4-1:len;
log->a.b.len = buf_len;
memcpy(log->a.b.comment , comment , comment_len);
memcpy(log->a.b.buf , buf , buf_len);
if(CS_E_OSAL_OK != cs_queue_put(sys_log_ctrl.log_queue_id, (void *)&log, sizeof(cs_uint32) , CS_OSAL_NO_WAIT , 0))
{
cs_mem_free((cs_uint8 *)log);
return;
}
#else
int i;
cs_printf("\n\n#%s ",comment);
for(i = 0 ; i < len ; i++)
{
if(i%16 == 0)
{
cs_printf("\n");
cs_printf("%06x ", i);
}
cs_printf("%02x ",buf[i]);
}
#endif
return;
}
sal_cmd_result_t startup_cfg_cmd_enc(int argc, char **argv)
{
unsigned char flag = 0;
tlv_header_t *pHeader = NULL;
cs_uint8 active_cnt = 9;
tlv_instance_t *pInst = (tlv_instance_t *)gStartupInst;
if(argc != 3)
{
cs_printf("scfg enc enable - Enable startup config encryption.\n");
cs_printf("scfg enc disable - Disable startup config encryption.\n");
return SAL_CMD_OK;
}
pHeader = (tlv_header_t *)pInst->base_address;
#ifdef HAVE_SCFG_PROTECTION
active_cnt = pHeader->active;
if(active_cnt == SCFG_MAX_CNT)
active_cnt = 0;
else
active_cnt++;
#else
active_cnt = SCFG_MAX_CNT;
#endif
tlv_write_active(gStartupInst , active_cnt);
if(!strcmp(argv[2],"enable"))
{
startup_cfg_enc_enable(1);
tlv_read_flag(gStartupInst, &flag);
flag = flag|TLV_CFG_ENC_FLAG;
tlv_write_flag(gStartupInst, flag);
}
if(!strcmp(argv[2],"disable"))
{
startup_cfg_enc_enable(0);
tlv_read_flag(gStartupInst, &flag);
flag = flag&(~TLV_CFG_ENC_FLAG);
tlv_write_flag(gStartupInst, flag);
}
return SAL_CMD_OK;
}
/* This function will exchange active blob and standby blob */
cs_uint32 iros_image_commit(void)
{
blob_info_desc_t *active_blob_info;
blob_info_desc_t *standby_blob_info;
unsigned int act_blob_idex,sty_blob_idex;
void *temp_ptr=NULL;
/* used to back up first block data*/
temp_ptr=iros_malloc(IROS_MID_SYS, flash_dev.info.super_block.block_size);
if(NULL == temp_ptr){
cs_printf("commit failed no memory\n");
return CS_ERROR;
}
act_blob_idex = active_blob_get();
active_blob_info = blob_info_tab[act_blob_idex];
sty_blob_idex = 0x1 &(act_blob_idex + 1);
/* back up standby data */
memcpy(temp_ptr, blob_info_tab[sty_blob_idex], flash_dev.info.super_block.block_size);
standby_blob_info = (blob_info_desc_t *)temp_ptr;
standby_blob_info->is_not_confirmed = 0;
standby_blob_info->xip_crc32 = 0xffffffff;
if(standby_blob_info->upgrade_stamp < active_blob_info->upgrade_stamp)
standby_blob_info->upgrade_stamp = active_blob_info->upgrade_stamp + 1;
/* prepare to write flash without erase */
if (flash_part_write_init(blob_part_tab[sty_blob_idex],
(char*)blob_info_tab[sty_blob_idex])) {
flash_write((char *)blob_info_tab[sty_blob_idex],
(char *)temp_ptr, flash_dev.info.super_block.block_size);
cs_printf("Cur blob committed..\n");
flash_part_write_done(blob_part_tab[sty_blob_idex]);
}
else {
cs_printf("Cur blob commit failed..\n");
iros_free(temp_ptr);
return CS_ERROR;
}
iros_free(temp_ptr);
return CS_OK;
}
cgi_status cgi_cs_qos_quen_cnt_get(cgi_handler_param_t * p)
{
cs_int8 buff[CGI_MAX_BUFF_LEN];
cs_int8 tmpBuff[CGI_MAX_BUFF_LEN];
cs_callback_context_t context;
cs_uint8 que;
cs_uint16 size;
cs_uint8 us[8];
cs_uint8 ds[8];
for(que=0;que < 8;que++ )
{
if(epon_request_onu_que_size_get(context,0,0,0x01,que,&size) != CS_E_OK)
{
cs_printf("get qos max quen count error\n");
return CS_E_ERROR;
} else {
us[que] = size;
}
}
for(que=0;que<8;que++)
{
if(epon_request_onu_que_size_get(context,0,0,0x00,que,&size) != CS_E_OK)
{
cs_printf("get qos max quen count error\n");
return CS_E_ERROR;
} else {
ds[que] = size;
}
}
memset(buff, 0, sizeof(buff));
sprintf(buff, "%s", "{");
memset(tmpBuff, 0, sizeof(tmpBuff));
sprintf(tmpBuff, "us_qCnt0:%d, us_qCnt1:%d, us_qCnt2:%d, us_qCnt3:%d, us_qCnt4:%d, us_qCnt5:%d, us_qCnt6:%d, us_qCnt7:%d, ds_qCnt0:%d, ds_qCnt1:%d, ds_qCnt2:%d, ds_qCnt3:%d, ds_qCnt4:%d, ds_qCnt5:%d, ds_qCnt6:%d, ds_qCnt7:%d",
us[0],us[1],us[2],us[3],us[4],us[5],us[6],us[7],ds[0],ds[1],ds[2],ds[3],ds[4],ds[5],ds[6],ds[7]);
strcat(buff, tmpBuff);
strcat(buff," }");
CGI_DEBUG("send buf = %s \n",buff);
cgi_send_str(p, buff,strlen(buff));
return CS_E_OK;
}
void cs_buf_print(cs_int8 *pbuf , cs_int32 len)
{
cs_int32 i , j=0 ,k;
cs_int8 strbuf[16];
cs_int32 remain_len=0;
cs_printf("\r\n==============================================================================");
for(i = 0 ; i < len ; i++) {
if(i%16 == 0) {
j = 0;
cs_printf("\r\n%08x: ",(cs_uint32)pbuf+i);
memset(strbuf , 0 , sizeof(strbuf));
remain_len = len - i;
}
strbuf[i%16] = *((cs_int8 *)(pbuf+i));
cs_printf("%02x ",*((cs_int8 *)(pbuf+i)));
if(++j == 8)
cs_printf(" ");
if(remain_len == j && (remain_len%16) != 0)
{
if(j < 8) cs_printf(" ");
for( ; j < 16 ; j++)
{
cs_printf(" ");
}
}
if(j == 16)
{
remain_len = 0;
cs_printf("; ");
for(k = 0 ; k < 16 ; k++)
{
if(strbuf[k] >= ' ' && strbuf[k]<='~')
cs_printf("%c",strbuf[k]);
else
cs_printf(".",strbuf[k]);
}
}
}
printf("\r\n\n");
return;
}
static void startup_config_dump_hex()
{
int i;
tlv_header_t *pHeader = NULL;
tlv_instance_t *pInst = (tlv_instance_t *)gStartupInst;
int total_len = 0;
unsigned char *pbuf = NULL;
pHeader = (tlv_header_t *)pInst->base_address;
pbuf = (unsigned char *)pHeader;
total_len = sizeof(tlv_header_t)+ntohl(pHeader->cfg_len);
for(i = 0 ; i < total_len ; i++)
{
if(i%16 == 0)
cs_printf("\n");
cs_printf("%02x ",pbuf[i]);
}
cs_printf("\n");
return;
}
void iros_log_level_proc(int level, int modid)
{
int i = 0;
if(level == -1)
{
for(i = 0; i < CS_MAX_MODULE_NUMBER; i++)
{
cs_printf("mod %02d: logging print level %1d\n", i, sys_log_ctrl.mod_info[i].print_level);
}
return;
}
if(modid == -1)
{
if(level >= 0 && level <= 7)
{
for (i = 0; i < CS_MAX_MODULE_NUMBER; i++)
{
sys_log_ctrl.mod_info[i].print_level = level;
}
}
else
{
cs_printf("invalid logging print level %1d\n", level);
}
return;
}
if(modid < 0 || modid >= CS_MAX_MODULE_NUMBER || level < 0 || level > 7)
{
cs_printf("invalid mod id and level: %d %d\n", modid, level);
return;
}
sys_log_ctrl.mod_info[modid].print_level = level;
return;
}
int gw_comm_onu_msg_send(unsigned char GwOpcode, unsigned int SendSerNo, unsigned char *pSentData,const unsigned short SendDataSize, unsigned char *pSessionIdfield)
{
int ret = 0;
if(0 == CommOnuMsgSend(GwOpcode, SendSerNo, pSentData, SendDataSize, pSessionIdfield))
{
ret = 0;
}
else
{
cs_printf("CommOnuMsgSend err!\n");
ret = -1;
}
return ret;
}
void cs_sys_log_clr()
{
int i;
char fn[32];
cs_mutex_lock(sys_log_mutex);
if(sys_log_ctrl.log_fp != NULL)
{
fclose((FILE *)sys_log_ctrl.log_fp);
cs_printf("Close current file\n");
sys_log_ctrl.log_fp = NULL;
}
for(i = 0 ; i < MAX_LOG_FILE_NUM ; i++)
{
memset(fn,0,sizeof(fn));
sprintf(fn,"/log/log%d.txt",i);
remove(fn);
cs_printf("Remove file %s\n",fn);
}
current_file = 0;
fp_cursor = 0;
cs_mutex_unlock(sys_log_mutex);
return;
}
void cs_log_show(cs_log_t *log)
{
cs_int8 buf[2*CS_LOG_SIZE];
cs_int32 i;
memset(buf , 0 , sizeof(buf));
if(log->log_type == CS_LOG_MSG_TYPE)
{
for(i = 0 ; i < strlen(log->a.log_buf) ; i++)
{
if(log->a.log_buf[i] != '\r' && log->a.log_buf[i] != '\n')
break;
buf[i] = log->a.log_buf[i];
}
sprintf(buf+i , "[%08x:%s:%d] ",log->time,cs_sys_mod_desc_get(log->module_id) ,log->log_level);
memcpy(buf+strlen(buf) , log->a.log_buf+i , strlen(log->a.log_buf)-i);
cs_printf("%s",buf);
return;
}
if(log->log_type == CS_LOG_HEX_TYPE)
{
cs_printf("\n\n#%s ",log->a.b.comment);
for(i = 0 ; i < log->a.b.len ; i++)
{
if(i%16 == 0)
{
cs_printf("\n");
cs_printf("%06x ", i);
}
cs_printf("%02x ",log->a.b.buf[i]);
}
return;
}
}
void cs_sys_log_dump()
{
FILE *fp = NULL;
cs_int8 str[2*CS_LOG_SIZE];
cs_uint32 count_str = 0;
int i;
char fn[32];
cs_mutex_lock(sys_log_mutex);
for(i = 0 ; i < MAX_LOG_FILE_NUM ; i++)
{
memset(fn,0,sizeof(fn));
sprintf(fn,"/log/log%d.txt",i);
fp = fopen(fn , "r");
if(fp == NULL)
continue;
cs_printf("==== %s ====\n",fn);
memset(str , 0 , sizeof(str));
while(fgets(str, sizeof(str), fp) != NULL)
{
cs_printf("%s",str);
count_str++;
if(count_str >= 30)
{
cs_thread_delay(10);
count_str = 0;
}
memset(str , 0 , sizeof(str));
}
fclose(fp);
}
cs_mutex_unlock(sys_log_mutex);
return;
}
void telnetd_init()
{
cs_uint32 telnet_thread_id;
cs_uint32 ret;
cs_uint32 telnet_wr_th_id;
memset(&g_console, 0, sizeof(g_console));
cs_semaphore_init(&g_console.rd_avail, "cosonle_rd_avail", 0, 0);
cs_mutex_init(&g_console.lock, "console_lock", 0);
g_console.full = 0;
g_console.empty = 1;
ret = cs_thread_create(&telnet_wr_th_id,
"telnet wrt",
(const void *)telnetd_wrt_thread_entry, (void *)0,
TELNETD_THREAD_STACKSIZE/2,
TELNETD_THREAD_PRIORITY+1,
0);
ret = cs_thread_create(&telnet_thread_id,
TELENTD_THREAD_NAME,
(const void *)telnetd_thread_entry, (void *)0,
TELNETD_THREAD_STACKSIZE,
TELNETD_THREAD_PRIORITY,
0);
if (ret != CS_E_OK)
{
cs_printf("telnetd thread failed to create\n");
}
else
{
cs_printf("telnetd thread created\n");
}
}
void c_testdraw()
{
gbuf_color=rt_alloc(RT_4B, 0);
gbuf_normal=rt_alloc(RT_4B, 0);
gbuf_depth=rt_alloc(RT_DEPTH, 0);
cs_printf("color=%i, normal=%i, depth=%i\n", gbuf_color,gbuf_normal,gbuf_depth);
float dx,dy=0,dz;
dx=cvar_getf("strafespeed", NULL);
dy=cvar_getf("verticalspeed", NULL);
dz=cvar_getf("forwardspeed", NULL);
float du=cvar_getf("spinspeed", NULL);
cam3_movetg("testcam3", dx,dy,dz);
cam3_update("testcam3", du, 1.0/60.0);
cam3_use("testcam3");
float modelview[16];
glGetFloatv(GL_MODELVIEW_MATRIX, modelview);
glGetFloatv(GL_PROJECTION_MATRIX, projection);
invmat4(invproj, projection);
invmat4(invmodelview, modelview);
glEnable(GL_DEPTH_TEST);
rnd_clearall();
test_initgbuf();
glDisable(GL_DEPTH_TEST);
// test_motionblur();
// test_dof2();
// test_gaussianblur();
color_tex[0]=gbuf_color;
depth_tex[0]=gbuf_depth;
filter_use("test.fil");
vfs_use(-1);
memcpy(prevmodelview, modelview, 16*sizeof(float));
rt_free(gbuf_color);
rt_free(gbuf_normal);
rt_free(gbuf_depth);
}
