Пример #1
0
//初始化中断相关变量
void Init_Interr_Sram(void)
{
  
  mem_set((void *)(&Key_Value_Pub),0,sizeof(Key_Value_Pub),\
               (void *)(&Key_Value_Pub),sizeof(Key_Value_Pub));   
  INIT_STRUCT_VAR(Key_Value_Pub);
  
  mem_set((void *)(&Irda_Wake_Ctrl),0,sizeof(Irda_Wake_Ctrl),\
               (void *)(&Irda_Wake_Ctrl),sizeof(Irda_Wake_Ctrl));   
  INIT_STRUCT_VAR(Irda_Wake_Ctrl);

#ifdef REMOTER_FUNC_EN  
    mem_set((void *)(&Irda_Decode_Ctrl),0,sizeof(Irda_Decode_Ctrl),\
          (void *)(&Irda_Decode_Ctrl),sizeof(Irda_Decode_Ctrl));
    INIT_STRUCT_VAR(Irda_Decode_Ctrl);
#endif
    
  mem_set((void *)(&Pulse_Num_Temp),0,sizeof(Pulse_Num_Temp),\
        (void *)(&Pulse_Num_Temp),sizeof(Pulse_Num_Temp));
  INIT_STRUCT_VAR(Pulse_Num_Temp); 
  
  Irda_WkUP_Ms_Timr=Ms_Timer_Pub;
  Key_WkUP_Ms_Timr=Ms_Timer_Pub;
  
  mem_set((void *)(&Curr_Media_Status),0,sizeof(Curr_Media_Status),\
        (void *)(&Curr_Media_Status),sizeof(Curr_Media_Status));
  SET_STRUCT_SUM(Curr_Media_Status);    
}
Пример #2
0
void initialize_private_mib(void)
{
	TROUT_FUNC_ENTER;
    mem_set(&P_MIB, 0, sizeof(p_mib_t));

    mem_set(P_MIB.bssid, 0, 6);
    mem_set(P_MIB.bcst_addr, 0xFF, 6);

    P_MIB.auth_type        = (UWORD8)OPEN_SYSTEM;
    P_MIB.scan_type        = ACTIVE_SCAN;
    P_MIB.listen_interval  = 3;
    P_MIB.chan_mgmt_enable = TV_FALSE;
    P_MIB.chan_switch_cnt  = MAX(2 * mget_DTIMPeriod(), WIFI_MIN_CH_SWITCH_CNT);
    P_MIB.chan_switch_mode = 1;

#ifdef MAC_802_11H
	if(get_current_start_freq() == RC_START_FREQ_5)
    	P_MIB.chan_mgmt_enable = TV_TRUE;
#endif /* MAC_802_11H */

//chenq add for wapi 2012-09-19
#ifdef MAC_WAPI_SUPP

	memset(&P_WAPI_MIB,0x00,sizeof(p_wapi_mib_t));

	P_WAPI_MIB.wapi_enable = TV_FALSE;
	P_WAPI_MIB.wapi_key_ok = TV_FALSE;
#endif


}
Пример #3
0
void cavan_sha_finish(struct cavan_sha_context *context, u8 *digest)
{
	u64 bits = context->count << 3;

	cavan_sha_update(context, "\x80", 1);

	if (context->remain > sizeof(context->buff) - sizeof(bits)) {
		mem_set(context->buff + context->remain, 0, sizeof(context->buff) - context->remain);
		context->transform(context->digest, context->dwbuff);
		mem_set(context->buff, 0, context->remain);
	} else {
		mem_set(context->buff + context->remain, 0, sizeof(context->buff) - context->remain - sizeof(bits));
	}

	if (context->flags & SHA_FLAG_SWAP) {
		mem_copy_invert8(context->buff + sizeof(context->buff) - sizeof(bits), (void *) &bits, sizeof(bits));
	} else {
		mem_copy(context->buff + sizeof(context->buff) - sizeof(bits), (void *) &bits, sizeof(bits));
	}

	context->transform(context->digest, context->dwbuff);

	if (context->flags & SHA_FLAG_SWAP) {
		mem_swap32((u32 *) digest, context->digest, context->digest_size >> 2);
	} else {
Пример #4
0
//从ROM中读出当前需量数据
void Read_Demand_Data_From_Rom()
{
  INT8U Err,Re,Rate,i;
  S_Demand *p;
  
  //先读取掉电存储区数据
  //再读普通数据
  //最后读备份区数据
  Re=CHECK_STRUCT_SUM(Cur_Rate_Info);
  if(ASSERT(A_WARNING,0!=Re))
    Check_Data_Avail();
  
  OS_Sem_Pend(PUB_BUF0_SEM_ID); 
  p=(S_Demand *)Pub_Buf0;
  if(Read_Storage_Data(CUR_DEMAND_PD,p,p,sizeof(Pub_Buf0),&Err)!=sizeof(Cur_Demand) ||\
     Check_Demand_Data((S_Demand *)p)==0)
  {
    DEBUG_PRINT(HUCK,DEBUG_0,"Read CUR_DEMAND_PD data error");
    OS_TimeDly_Ms(500);
    //读取总和当前费率需量
    for(i=0;i<2;i++)
    {
      if(i==0)
        Rate=0;//读总需量时偏移为0
      else
        Rate=Cur_Rate_Info.Rate;//非总时根据费率计算偏移

      p->Rate=Cur_Rate_Info.Rate;
      //从当前数据区读取当前和总费率的需量数据
      if(Read_Demand_Rate_Data(Rate,(void *)&p->Demand[i],(void *)&p->Demand[i],sizeof(S_One_Demand))!=ONE_DEMAND_SAVE_SIZE)
      {
        DEBUG_PRINT(HUCK,DEBUG_0,"Read CUR_DEMAND Rate %d data error",Rate);
        mem_set((void *)&p->Demand[i],0,sizeof(p->Demand[i]),(void *)&p->Demand[i],sizeof(p->Demand[i]));
      }
    }
  }

  
  if(Check_Demand_Data((S_Demand *)p)==0)
  {
    ASSERT(A_WARNING,0);
    mem_set(p,0,sizeof(Cur_Demand),p,sizeof(Pub_Buf0));
  }
  
  DIS_PD_INT;//更新Cur_Demand数据前关掉电中断
  mem_cpy((void *)&Cur_Demand,p,sizeof(Cur_Demand),(void *)&Cur_Demand,sizeof(Cur_Demand));
  INIT_STRUCT_VAR(Cur_Demand);
  SET_DATA_READY_FLAG(Cur_Demand);
  SET_STRUCT_SUM(Cur_Demand);
  EN_PD_INT;
  
  OS_Sem_Post(PUB_BUF0_SEM_ID);  
  //SET_STRUCT_SUM(Cur_Demand); 
  //更新当前存储区和备份存储区,补冻函数可能要用到这两个区,因此要保证这两个区的数据更新
  Save_Cur_Demand_Data();
  Save_Cur_Demand_Bak_Data();
}
Пример #5
0
// 事件处理函数
//注意:该函数调用Read_Event_Status查询某个事件状态时,是该事件发生前的状态
//例如 某事件发生,调用该函数处理,则该函数内调用Read_Event_Status时返回0
// 相反,某事件结束,调用该函数处理,则该函数内调用Read_Event_Status时返回1
void Event_Data_Proc(INT8U Event_ID,INT8U Occur_Or_End)
{
  INT8U Total_Event_ID;
  INT8U Clr_Demand_Man_Flag;
  INT8U Op_ID[4],Op_ID1[4];
  
  _Debug_Print("\r\n++++++++++Event Data Proc,ID:%d,%s++++++++++",Event_ID,(Occur_Or_End EQ EVENT_OCCUR)?"Occur":"End");
  
  Clr_Demand_Man_Flag = 0;
  if(Event_ID EQ ID_EVENT_CLR_DEMAND_MAN)//手动清需量转为通信清需量,同一事件ID处理,但是手动清需量的操作者ID为全FF
  {
    Clr_Demand_Man_Flag = 1;
    Event_ID = ID_EVENT_CLR_DEMAND_COM;
    //当前操作者id先备份
    mem_set(Op_ID1, 0xFF, sizeof(Op_ID1), Op_ID1, sizeof(Op_ID1));
    Store_Op_ID(Op_ID1, Op_ID, Op_ID, sizeof(Op_ID));
  }
  else if(Event_ID EQ ID_EVENT_RELAY_ON || Event_ID EQ ID_EVENT_RELAY_OFF) //拉合闸,本地拉合闸记录操作者代码为FF
  {
    if(Relay_Status.Switch_Cause EQ S_OFF_PREPAID) //本地拉闸需要置操作者代码为全FF
    {
      mem_set(Op_ID1, 0xFF, sizeof(Op_ID1), Op_ID1, sizeof(Op_ID1));
      Store_Op_ID(Op_ID1, Op_ID, Op_ID, sizeof(Op_ID));      
    }
    else //远程拉闸需要采用其操作者代码
    {
      Store_Op_ID((INT8U *)Event_Data.Relay_Status.Op_ID, Op_ID, Op_ID, sizeof(Op_ID)); 
    }   
  }
  
  Event_Cumu_Proc(Event_ID,Occur_Or_End,EVENT_REAL);
  
  Total_Event_ID = Get_Total_Event_ID(Event_ID);//本事件对应的总计数也要处理
  if(Total_Event_ID != NULL_EVENT_ID)
  {
    Debug_Print("Total Event Proc");
    Event_Cumu_Proc(Total_Event_ID,Occur_Or_End,EVENT_REAL);
  }
  Event_Separate_Proc(Event_ID,Occur_Or_End,EVENT_REAL);
 
  //恢复操作者ID
  if(Clr_Demand_Man_Flag EQ 1)
  {
    Restore_Op_ID(Op_ID);
  }
  else if(Event_ID EQ ID_EVENT_RELAY_ON || Event_ID EQ ID_EVENT_RELAY_OFF)
  {
    Restore_Op_ID(Op_ID);      
  }
  
  Debug_Print("++++++++++Event Data Proc:End++++++++++\r\n");
  OS_TimeDly_Ms(10); //延迟10ms
}
Пример #6
0
void Test_Memory(void)
{
  INT8U j,Flag,RandBuf[TEST_BUF_LEN];
  INT16U i;
  INT32U timr;  
  static INT16U RdErr[MAX_MEM_NUM],WrErr[MAX_MEM_NUM],CompareErr[MAX_MEM_NUM];
    
  mem_set(Drv_Test_Buf+ID_TEST_EXT_U10,0x01,MAX_MEM_NUM,Drv_Test_Buf+ID_TEST_EXT_U10,MAX_MEM_NUM);
  Temp_Timer_Bak=Ms_Timer_Pub; //用来查看花费的时间
  for(i=0;i<EPPROM_TEST_NUM;i++)
  {
    mem_set(RandBuf,0x55+i,sizeof(RandBuf),RandBuf,sizeof(RandBuf));
    for(j=ID_TEST_EXT_U10;j<=ID_MEM_IIC_U15;j++)
    {  
      Flag=!Write_EEPROM_Dvice_PUCK(j,TEST_ADDR[j],TEST_BUF_LEN,RandBuf);
      WrErr[j]+=Flag;
  
      mem_set(Test_Temp_Buf,0x33,sizeof(Test_Temp_Buf),Test_Temp_Buf,sizeof(Test_Temp_Buf));
      Flag=!Read_EEPROM_Dvice_PUCK(j,TEST_ADDR[j],TEST_BUF_LEN,Test_Temp_Buf);
      RdErr[j]+=Flag;
     
      if((memcmp(Test_Temp_Buf,RandBuf,TEST_BUF_LEN)!=0)||(Test_Temp_Buf[TEST_BUF_LEN]!=0x33))//比较相等,但底层不能多写造成越界!
       CompareErr[j]++;
      
     if(RdErr[j]|WrErr[j]|CompareErr[j])   //有其中一个错误发生,置标志失败标志
      Drv_Test_Buf[j]=0;
    }
    
    Flag=!flash_writ_abs(TEST_FLASH_ADDR,RandBuf,TEST_BUF_LEN);
    WrErr[j]+=Flag;

    mem_set(Test_Temp_Buf,0x33,sizeof(Test_Temp_Buf),Test_Temp_Buf,sizeof(Test_Temp_Buf));
    Flag=!flash_read_abs(TEST_FLASH_ADDR,Test_Temp_Buf,TEST_BUF_LEN);
    RdErr[j]+=Flag;
   
    if((memcmp(Test_Temp_Buf,RandBuf,TEST_BUF_LEN)!=0)||(Test_Temp_Buf[TEST_BUF_LEN]!=0x33))//比较相等,但底层不能多写造成越界!//比较
    CompareErr[j]++; 
     
   if(RdErr[ID_TEST_EXT_U8]|WrErr[ID_TEST_EXT_U8]|CompareErr[ID_TEST_EXT_U8])  //有其中一个错误发生,置标志失败
    Drv_Test_Buf[ID_TEST_EXT_U8]=0;
  }

  timr=Ms_Timer_Pub-Temp_Timer_Bak;
  DEBUG_PRINT(PUCK,PRINT_PUCK_MEA_EN,"|-----------------------Test Memory-----------------------------------|");
  DEBUG_PRINT(PUCK,PRINT_PUCK_MEA_EN,"| Total_Times      Read_Err        Write_Err   Compare_Err  Result    |");
  
  for(j=ID_TEST_EXT_U10;j<=ID_TEST_EXT_U8;j++)
    DEBUG_PRINT(PUCK,PRINT_PUCK_MEA_EN,"|%s      %3d           %3d              %3d           %3d  %s   |",\
                          Const_Drv_Test[j],EPPROM_TEST_NUM,RdErr[j],WrErr[j],CompareErr[j],TEST_INFO[Drv_Test_Buf[j]]);
 
  DEBUG_PRINT(PUCK,PRINT_PUCK_MEA_EN,"|       All Run Time=%9ldMS                                      |",timr); 
  DEBUG_PRINT(PUCK,PRINT_PUCK_MEA_EN,"|---------------------------------------------------------------------|"); 
}
Пример #7
0
static void mem_write_auto(int idx)
{
 	switch(codefreakdec(mem_gv.mem_table[idx].addr) >> 28)
	{
	case 1:		//1xxxxxxx
		mem_set(codefreakdec(mem_gv.mem_table[idx].addr) & 0xFFFFFFF, (unsigned int)&mem_gv.mem_table[idx].value, 2);
		break;
	case 2:		//2xxxxxxx
		mem_set(codefreakdec(mem_gv.mem_table[idx].addr) & 0xFFFFFFF, (unsigned int)&mem_gv.mem_table[idx].value, 4);
		break;
	default: 	//0xxxxxxx
		switch(mem_gv.mem_table[idx].type)
		{
		case 1:
			mem_set(codefreakdec(mem_gv.mem_table[idx].addr), (unsigned int)&mem_gv.mem_table[idx].value, 1);
			break;
		case 2:
			mem_set(codefreakdec(mem_gv.mem_table[idx].addr), (unsigned int)&mem_gv.mem_table[idx].value, 2);
			break;
		case 3:
			mem_set(codefreakdec(mem_gv.mem_table[idx].addr), (unsigned int)&mem_gv.mem_table[idx].value, 4);
			break;
		default:
			if(mem_gv.mem_table[idx].value < 0x100)
				mem_set(codefreakdec(mem_gv.mem_table[idx].addr), (unsigned int)&mem_gv.mem_table[idx].value, 1);
			else if(codefreakdec(mem_gv.mem_table[idx].addr) < 0x10000)
				mem_set(codefreakdec(mem_gv.mem_table[idx].addr), (unsigned int)&mem_gv.mem_table[idx].value, 2);
			else
				mem_set(codefreakdec(mem_gv.mem_table[idx].addr), (unsigned int)&mem_gv.mem_table[idx].value, 4);
			break;
		}
 		break;
	} 
}
Пример #8
0
static Handle vbv_init(void)
{
    int i;
    u8* vbv_buf;
    vbv_t* vbv;

    vbv = (vbv_t*)mem_alloc(sizeof(vbv_t));
    if (vbv) {
        mem_set(vbv, 0, sizeof(vbv_t));
        
        vbv->frame_fifo.in_frames = (stream_frame_t*)mem_alloc(VBV_MAX_FRAME_NUM * sizeof(stream_frame_t));
        if (!vbv->frame_fifo.in_frames) {
            mem_free(vbv);
            return NULL;
        }
        
        mem_set(vbv->frame_fifo.in_frames, 0, VBV_MAX_FRAME_NUM * sizeof(stream_frame_t));
        for(i = 0; i < VBV_MAX_FRAME_NUM; i++)
        {
            vbv->frame_fifo.in_frames[i].vstream.id = i;
        }
                
        vbv_buf = (u8*)mem_palloc(VBV_FRAME_SIZE, 1024);
        if (!vbv_buf) {
            mem_free(vbv); 
            mem_free(vbv->frame_fifo.in_frames); 
            return NULL;
        }
        
        vbv->vbv_buf     = vbv_buf;
        vbv->vbv_buf_end = vbv_buf + VBV_FRAME_SIZE;
        vbv->max_size    = VBV_FRAME_SIZE;
        vbv->write_addr  = vbv_buf;
        vbv->valid_size  = 0;
        
        vbv->frame_fifo.frame_num     = 0;
        vbv->frame_fifo.write_index   = 0;
        vbv->frame_fifo.max_frame_num = VBV_MAX_FRAME_NUM;
        
        vbv->frame_queue.frame_num = 0;
        vbv->frame_queue.head      = NULL;
        
        pthread_mutex_init(&vbv->mutex, NULL);
        return (Handle)vbv;
    }

    return NULL;
}
Пример #9
0
/**********************************************************************************
函数功能:填满整屏
入口:    无
出口:    无
**********************************************************************************/
void FillAllScreen(void)
{
  mem_set(Show_Lcd_Ram,0xff,sizeof(Show_Lcd_Ram),Show_Lcd_Ram,sizeof(Show_Lcd_Ram));    
  Show_Lcd_Flag=1;
  UpdataLcdShow();
  //OS_TimeDly_Ms(150);//500ms睡眠
}
Пример #10
0
/**********************************************************************************
LCD显示每屏结果
**********************************************************************************/
void Dis_Per_Item(INT8U Item)
{
  INT8U i;
    
  if(Item>=MAX_ID_TEST_NUM)
    return ;
  
  if(Drv_Test_Buf[Item]>1)
    return ;
  
  mem_set(Temp_Buf_PUCK,0x00,sizeof(Temp_Buf_PUCK),Temp_Buf_PUCK,sizeof(Temp_Buf_PUCK));
  strcpy((char *)Temp_Buf_PUCK,(char*)Const_Drv_Test[Item]);
  
  if(Drv_Test_Buf[Item]==0)
   strcpy((char *)Temp_Buf_PUCK+5,"Error");
  else
   strcpy((char *)Temp_Buf_PUCK+5," 6ood");
  
  for(i=3;i<=12;i++)
    SetOnLED8Device_PUCK(N_LED(i),Temp_Buf_PUCK[i-3]);
  
  SetOnLED8Device_PUCK(N_LED(20),Item/10+'0');
  SetOnLED8Device_PUCK(N_LED(21),Item%10+'0');
  UpdataLcdShow();
}
Пример #11
0
//需量检查当前费率是否发生了变化,如果变化了,则读出当前费率的最大需量值
void Demand_Check_Rate_Change()
{
  INT8U Re;

  Re=1;
  Re=CHECK_STRUCT_SUM(Cur_Rate_Info);
  Re=CHECK_STRUCT_SUM(Cur_Demand);
  if(ASSERT(A_WARNING,1==Re))
    Check_Data_Avail();

  if(Cur_Rate_Info.Rate!=Cur_Demand.Rate)//费率已经发生变化了
  {
    DEBUG_PRINT(HUCK,DEBUG_0,"Rate_Changed!Save Old Rate Demand && Read New Rate Demand");
    Save_Cur_Demand_Data();//先将Cur_Demand数据保存起来
    Save_Cur_Demand_Bak_Data();

    //重新根据当前费率读取需量数据
    Cur_Demand.Rate=Cur_Rate_Info.Rate;
    //读出该分费率数据
    if(Read_Demand_Rate_Data(Cur_Demand.Rate,(void *)&Cur_Demand.Demand[1],(void *)&Cur_Demand.Demand[1],sizeof(S_One_Demand))!=ONE_DEMAND_SAVE_SIZE)
    {
      mem_set((void *)&Cur_Demand.Demand[1],0,sizeof(Cur_Demand.Demand[1]),(void *)&Cur_Demand.Demand[1],sizeof(Cur_Demand.Demand[1]));
      SET_STRUCT_SUM(Cur_Demand.Demand[1]);
    }
    SET_STRUCT_SUM(Cur_Demand);
    
    Save_Cur_Demand_PD_Data();//更新掉电存储区的需量数据
  }
}
Пример #12
0
cedarv_decoder_t* libcedarv_init(s32* return_value)
{
    video_decoder_t* p;

    *return_value = CEDARV_RESULT_ERR_FAIL;

    p = (video_decoder_t*)mem_alloc(sizeof(video_decoder_t));
    if (p == NULL)
    {
        *return_value = CEDARV_RESULT_ERR_NO_MEMORY;
        return NULL;
    }
    mem_set(p, 0, sizeof(video_decoder_t));

    p->icedarv.open             = vdecoder_open;
    p->icedarv.close            = vdecoder_close;
    p->icedarv.decode           = vdecoder_decode;
    p->icedarv.ioctrl           = vdecoder_io_ctrl;
    p->icedarv.request_write    = vdecoder_request_write;
    p->icedarv.update_data      = vdecoder_update_data;
    p->icedarv.display_request  = vdeocder_display_request;
    p->icedarv.display_release  = vdecoder_display_release;
    p->icedarv.set_vstream_info = vdecoder_set_video_bitstream_info;
    p->icedarv.query_quality    = vdecoder_query_quality;

    p->config_info.max_video_width  = MAX_SUPPORTED_VIDEO_WIDTH;
    p->config_info.max_video_height = MAX_SUPPORTED_VIDEO_HEIGHT;

    cedardev_init();
    ve_init_clock();

    *return_value = CEDARV_RESULT_OK;

    return (cedarv_decoder_t*)p;
}
Пример #13
0
cedarx_result_e libcedarx_display_open(void)
{
    cedarx_display_t* display;
    
    if (!cedarx_decoder)
        return CEDARX_RESULT_NO_INIT;

    display = (cedarx_display_t*)mem_alloc(sizeof(cedarx_display_t));
    if (!display)
      return CEDARX_RESULT_NO_ENOUGH_MEMORY;
    
    mem_set(display, 0, sizeof(cedarx_display_t));
    cedarx_display = display;

    display->fd = open("/dev/disp", O_RDWR);
    if (display->fd == -1) {
        free(display);
        cedarx_display = NULL;
        return CEDARX_RESULT_DE_FAILED; 
    }

    display->info.layer = -1;
    pthread_mutex_init(&display->mutex, NULL);
   
    return CEDARX_RESULT_OK; 
}
Пример #14
0
int cavan_font_init(struct cavan_font *font)
{
	byte *body;

	if (font->body)
	{
		return 0;
	}

	body = malloc(font->width * font->height);
	if (body == NULL)
	{
		pr_error_info("malloc");
		return -ENOMEM;
	}

	font->body = body;
	font->stride = font->width * font->cheight;

	if (font->rundata && font->rundata_size > 0)
	{
		const byte *rundata, *rundata_end;

		for (rundata = font->rundata, rundata_end = rundata + font->rundata_size; rundata < rundata_end; rundata++)
		{
			int count = (*rundata) & 0x7F;

			mem_set(body, ((*rundata) & (1 << 7)) ? 0xFF : 0, count);
			body += count;
		}
	}

	return 0;
}
Пример #15
0
static
FRESULT create_name (
	DIR *dj,			/* Pointer to the directory object */
	const char **path	/* Pointer to pointer to the segment in the path string */
)
{
	BYTE c, ni, si, i, *sfn;
	const char *p;

	/* Create file name in directory form */
	sfn = dj->fn;
	mem_set(sfn, ' ', 11);
	si = i = 0; ni = 8;
	p = *path;
	for (;;) {
		c = p[si++];
		if (c < ' ' || c == '/') break;	/* Break on end of segment */
		if (c == '.' || i >= ni) {
			if (ni != 8 || c != '.') return FR_INVALID_NAME;
			i = 8; ni = 11;
			continue;
		}
		if (c >= 0x7F || chk_chr(" +,;[=\\]\"*:<>\?|", c))	/* Reject unallowable chrs for SFN */
			return FR_INVALID_NAME;
		if (c >='a' && c <= 'z') c -= 0x20;
		sfn[i++] = c;
	}
	if (!i) return FR_INVALID_NAME;		/* Reject null string */
	*path = &p[si];						/* Rerurn pointer to the next segment */

	sfn[11] = (c < ' ') ? 1 : 0;		/* Set last segment flag if end of path */

	return FR_OK;
}
Пример #16
0
/**********************************************************************************
测试EPPROM
**********************************************************************************/
void Test_Epprom_Err(void)
{  
  INT8U Err;  
  mem_set(Temp_Buf_PUCK,0xa5,sizeof(Temp_Buf_PUCK),Temp_Buf_PUCK,sizeof(Temp_Buf_PUCK));
  I2cReset();
  Read_Storage_Data(0x10003,Temp_Buf_PUCK,Temp_Buf_PUCK,180,&Err);
  
}
void initialize_wmm(void)
{
    mem_set(g_wmm_capability, 0, MAX_STA_SUPPORTED);
    init_qif_table();
    //destroy_mac_qmu(&g_q_handle);	//masked by chengwg, 2013-01-15.

	//init_mac_qmu();	//masked by chengwg, 2013-01-15.
}
Пример #18
0
void math_memory_shift_left_byte(const byte *mem, size_t mem_size, size_t shift, byte *res, size_t res_size)
{
	if (res == NULL) {
		res = (byte *) mem;
	}

	if (res_size == 0) {
		res_size = mem_size;
	}

	if (shift < mem_size && shift < res_size) {
		math_memory_copy(res + shift, res_size - shift, mem, mem_size - shift);
		mem_set(res, 0, shift);
	} else {
		mem_set(res, 0, res_size);
	}
}
Пример #19
0
int main()
{
	int num = 0x4D;
	mem_set(&num, 42, sizeof(num));
	printf("num = %d\n length = %lu\n",num,sizeof(num));
    //name_print(my_name);
    return 0;
}
Пример #20
0
void modem_init (void) {
  /* Initializes the modem variables and control signals DTR & RTS. */
  mlen = 0;
  mem_set (mbuf, 0, sizeof(mbuf));
  wait_for  = 0;
  wait_conn = 0;
  modem_st = MODEM_IDLE;
}
Пример #21
0
/**********************************************************************************
函数功能:初始化显示RAM
入口:    无
出口:    无
**********************************************************************************/
void InitLcdAllRam(void)
{
  
 //mem_set(Show_Lcd_Ram,0x00,MAX_SEG+1,Show_Lcd_Ram,MAX_SEG+1);
  //mem_set(Show_Lcd_Ram,0x00,sizeof(Show_Lcd_Ram),Show_Lcd_Ram,sizeof(Show_Lcd_Ram));
  //mem_set(void *pDst, INT8U Value,INT32U SetLen,void *pDst_Start,INT32U Dst_Len)
   mem_set(Show_Lcd_Ram,0x00,sizeof(Show_Lcd_Ram),Show_Lcd_Ram,sizeof(Show_Lcd_Ram)); 
}
Пример #22
0
//设置默认的需量数据
void Set_Def_Cur_Demand_Data()
{
  INT8U i,Re;
  INT32U Off;
  //将初始需量写入存储器中  
  DEBUG_PRINT(HUCK,DEBUG_0,"Set Def Demand Data");
  mem_set((void *)&Cur_Demand,0,sizeof(Cur_Demand),(void *)&Cur_Demand,sizeof(Cur_Demand));
  SET_STRUCT_SUM(Cur_Demand.Demand[0]);
  SET_STRUCT_SUM(Cur_Demand.Demand[1]);
  
  INIT_STRUCT_VAR(Cur_Demand);
  SET_DATA_READY_FLAG(Cur_Demand);
  
  SET_STRUCT_SUM(Cur_Demand); 
  
  //将各个费率的需量数据清0
  for(i=0;i<=MAX_RATES;i++)
  {
    Cur_Demand.Rate=i;
    SET_STRUCT_SUM(Cur_Demand);
    
    Off=DEMAND_RATE_OFF(Cur_Demand.Rate);
    Re=Write_Storage_Data_Fix_Len(CUR_DEMAND,Off,(void *)&Cur_Demand.Demand[0],ONE_DEMAND_SAVE_SIZE);
    ASSERT(A_WARNING,NO_ERR==Re);
    
    Off=DEMAND_RATE_OFF(Cur_Demand.Rate);
    Re=Write_Storage_Data_Fix_Len(CUR_DEMAND_BAK,Off,(void *)&Cur_Demand.Demand[0],ONE_DEMAND_SAVE_SIZE);
    ASSERT(A_WARNING,NO_ERR==Re);    
  }

  mem_set((void *)&Cur_Demand,0,sizeof(Cur_Demand),(void *)&Cur_Demand,sizeof(Cur_Demand)); 
  Cur_Demand.Rate=0;
  SET_STRUCT_SUM(Cur_Demand.Demand[0]);
  SET_STRUCT_SUM(Cur_Demand.Demand[1]);

  INIT_STRUCT_VAR(Cur_Demand);
  SET_DATA_READY_FLAG(Cur_Demand);

  SET_STRUCT_SUM(Cur_Demand);
  
  mem_set((void *)&Demand_Accu,0,sizeof(Demand_Accu),(void *)&Demand_Accu,sizeof(Demand_Accu));//清中间累加单元
  SET_STRUCT_SUM(Demand_Accu);
  
  Save_Cur_Demand_PD_Data();  
}
Пример #23
0
//需量清0,入口参数pTime表示清除的时间点,一般是当前时间
//清需量后要根据该时间点计算下次需量数据冻结的时间
void Demand_Clear(S_HEX_Time *pTime)
{
  //Demand_Accu_Clear();//清累加,跨月的情况下一定要清累加?
  mem_set((void *)&Cur_Demand,0,sizeof(Cur_Demand),(void *)&Cur_Demand,sizeof(Cur_Demand));//清需量
  SET_STRUCT_SUM(Cur_Demand.Demand[0]);
  SET_STRUCT_SUM(Cur_Demand.Demand[1]);
  SET_STRUCT_SUM(Cur_Demand);

}
Пример #24
0
void math_memory_copy(byte *dest, size_t dest_size, const byte *src, size_t src_size)
{
	size_t size = MIN(dest_size, src_size);

	mem_move(dest, src, size);

	if (dest_size > size) {
		mem_set(dest + size, 0, dest_size - size);
	}
}
Пример #25
0
void mnew_RSNAStats(UWORD8 index)
{
    /* Reset all the counters and RNSA information */
    mem_set(&(MIB_11I.dot11RSNAStatsEntry[index]), 0,
            sizeof(dot11RSNAStatsEntry_t));

    /* Set the index of the Entry and the version number for the RSNA */
    MIB_11I.dot11RSNAStatsEntry[index].dot11RSNAStatsIndex   = index;
    MIB_11I.dot11RSNAStatsEntry[index].dot11RSNAStatsVersion = MIB_11I.
                                                        dot11RSNAConfigVersion;
}
Пример #26
0
/*
=======================================
    像素填充
=======================================
*/
CR_API void_t
line_fill (
  __CR_IN__ uint_t  line,
  __CR_IN__ byte_t  c
    )
{
    /* 颜色扩展到1个字节 */
    c &= 3;
    c |= (c << 2);
    c |= (c << 4);

    /* 填充整个屏幕 */
    if (line >= SCREEN_LINE) {
        mem_set(s_backs, c, SCREEN_SIZE);
        return;
    }

    /* 只填充一行 */
    line *= (SCREEN_BPL * 16);
    mem_set(&s_backs[line], c, SCREEN_BPL * 16);
}
Пример #27
0
/**********************************************************************************
函数功能:更新显示屏
入口:    Flag----1:表示初始化;0:表示进入主程序调用
出口:    无
**********************************************************************************/
void UpdataLcdShow(void)
{
  if(Show_Lcd_Flag)
  {
    
    //mem_set(Show_Lcd_Ram,0xff,sizeof(Show_Lcd_Ram),Show_Lcd_Ram,sizeof(Show_Lcd_Ram));    
    //HTLCDWriteMultiData(0,Show_Lcd_Ram,sizeof(Show_Lcd_Ram));
    //mem_set(Show_Lcd_Ram,0x0f,sizeof(Show_Lcd_Ram),Show_Lcd_Ram,sizeof(Show_Lcd_Ram));
    HTLCDWriteMultiData(0,Show_Lcd_Ram,sizeof(Show_Lcd_Ram));
    Show_Lcd_Flag=0;
    mem_set(Show_Lcd_Ram,0x00,sizeof(Show_Lcd_Ram),Show_Lcd_Ram,sizeof(Show_Lcd_Ram));    
  }
}
Пример #28
0
static
FRESULT create_name (
    DIR *dj,			/* Pointer to the directory object */
    const char **path	/* Pointer to pointer to the segment in the path string */
)
{
    BYTE c, ni, si, i, *sfn;
    const char *p;
#if _USE_LCC
#ifdef _EXCVT
    static const BYTE cvt[] = _EXCVT;
#endif
#endif

    /* Create file name in directory form */
    sfn = dj->fn;
    mem_set(sfn, ' ', 11);
    si = i = 0;
    ni = 8;
    p = *path;
    for (;;) {
        c = p[si++];
        if (c <= ' ' || c == '/') break;	/* Break on end of segment */
        if (c == '.' || i >= ni) {
            if (ni != 8 || c != '.') break;
            i = 8;
            ni = 11;
            continue;
        }
#if _USE_LCC
#ifdef _EXCVT
        if (c >= 0x80)					/* To upper extended char (SBCS) */
            c = cvt[c - 0x80];
#endif
        if (IsDBCS1(c) && i < ni - 1) {	/* DBC 1st byte? */
            BYTE d = p[si++];			/* Get 2nd byte */
            sfn[i++] = c;
            sfn[i++] = d;
        } else
#endif
        {   /* Single byte code */
            if (_USE_LCC && IsLower(c)) c -= 0x20;	/* toupper */
            sfn[i++] = c;
        }
    }
    *path = &p[si];						/* Rerurn pointer to the next segment */

    sfn[11] = (c <= ' ') ? 1 : 0;		/* Set last segment flag if end of path */

    return FR_OK;
}
Пример #29
0
static Handle fbm_init(u32 max_frame_num,
            u32 min_frame_num, u32 size_y[2],
            u32 size_u[2], u32 size_v[2],
            u32 size_alpha[2], _3d_mode_e out_3d_mode,
            pixel_format_e format, void* parent)
{
    s32 i;
    fbm_t*  fbm;
    cedarx_decoder_t* decoder = cedarx_decoder;
    
//    libve_io_ctrl(LIBVE_COMMAND_GET_PARENT, (u32)&decoder, parent);
//    if (!decoder)
//        return NULL;

    fbm = (fbm_t*) mem_alloc(sizeof(fbm_t));
    if(!fbm)
        return NULL;
    
    mem_set(fbm, 0, sizeof(fbm_t));
    fbm->size_y[0] = size_y[0];
    fbm->size_u[0] = size_u[0];
    fbm->mode = out_3d_mode;
    if (fbm->mode == _3D_MODE_DOUBLE_STREAM) {
        fbm->size_y[1] = size_y[1];
        fbm->size_u[1] = size_u[1];
    }
    
    for(i = 0; i < FBM_MAX_FRAME_NUM; i++) {
        fbm->frames[i].status                   = FS_EMPTY;
    	fbm->frames[i].vpicture.id              = i;
        fbm->frames[i].vpicture._3d_mode        = fbm->mode;
        fbm->frames[i].vpicture.size_y          = fbm->size_y[0];
        fbm->frames[i].vpicture.size_u          = fbm->size_u[0];
        fbm->frames[i].vpicture.size_v          = fbm->size_v[0];
        fbm->frames[i].vpicture.size_alpha      = fbm->size_alpha[0];
        fbm->frames[i].vpicture.size_y2         = fbm->size_y[1];
        fbm->frames[i].vpicture.size_u2         = fbm->size_u[1];
        fbm->frames[i].vpicture.size_v2         = fbm->size_v[1];
        fbm->frames[i].vpicture.size_alpha2     = fbm->size_alpha[1];
        if(i < max_frame_num) {
            fbm_enqueue_tail(&fbm->empty_queue, &fbm->frames[i]);
            fbm->init_frame_num ++;
        }
    }
    
    fbm->decoder = decoder;
    decoder->fbm = fbm;
    pthread_mutex_init(&fbm->mutex, NULL);
    
    return (Handle)fbm;
}
Пример #30
0
void hello_world()
{
	const int length = 10;
	int* a = 0;
	int* b = length * sizeof(int);
	int* res = 2*length * sizeof(int);
	int i;

	for(i=0; i<length; i++)
		a[i] = i;

	mem_set(b, length, 1);
	vector_add(res, a, b, length);
}