w25x32_wr.c

C语言源代码及相关资料

#if defined(UART_SEMCONTROL)
				OSSemPost(gw_pSysFlashSem);
#else
				OSSchedUnlock();
#endif // end of #if defined(SYSTEM_SEMCONTROL)
		return	FALSE;
	}
#if defined(UART_SEMCONTROL)
				OSSemPost(gw_pSysFlashSem);
#else
				OSSchedUnlock();
#endif // end of #if defined(SYSTEM_SEMCONTROL)			
	return	TRUE;
		    	
}

//写盲区数据
uint8	W25X32_WRITE_2_BlindSection(uint8	*	uiReviceBuf0,uint32	uiNum)
{
	uint8	i=0;
	const	uint8	pageLen=0xff;
	//保存到盲区，Flash
#if defined(SYSTEM_SEMCONTROL)
				INT8U SysFlashErr;
				OSSemPend(gw_pSysFlashSem, 0, &SysFlashErr);
#else
				OSSchedLock();
#endif // end of #if defined(SYSTEM_SEMCONTROL)

	if(cur_BlindSection_SaveAddr==0)
	{
		W25X32_Erase_2(FIRSTSEC,FIRSTSEC);
	}
	else
	{
		if((uint32)((cur_BlindSection_SaveAddr+uiNum)/SEC_SIZE) > (uint32)(cur_BlindSection_SaveAddr/SEC_SIZE))
		{
			W25X32_Erase_2((cur_BlindSection_SaveAddr+uiNum)/SEC_SIZE,(cur_BlindSection_SaveAddr+uiNum)/SEC_SIZE);
		}
	}
	for(i=0;i<uiNum/pageLen;i++)
	{	
		W25X32_WR_2(cur_BlindSection_SaveAddr+i*pageLen,uiReviceBuf0+i*pageLen,pageLen);
		OSTimeDly(3);
		
	}
	if(uiNum%pageLen>0)
	{
		OSTimeDly(3);
		W25X32_WR_2(cur_BlindSection_SaveAddr+i*pageLen,uiReviceBuf0+i*pageLen,uiNum%pageLen);
	}
	cur_BlindSection_SaveAddr+=uiNum;
	
#if defined(UART_SEMCONTROL)
				OSSemPost(gw_pSysFlashSem);
#else
				OSSchedUnlock();
#endif // end of #if defined(SYSTEM_SEMCONTROL)	

	{//盲区保存的当前地址
	
		uint8	tempBuff[4];
		uint8	i=0;
		memset(tempBuff,0,sizeof(tempBuff));
		for(i=0;i<sizeof(tempBuff);i++)
			tempBuff[i]=(uint8)(cur_BlindSection_SaveAddr>>(8*(sizeof(tempBuff)-i-1)));
		SaveCustomValue(0x0014,tempBuff);
	}
	
	return 	TRUE;
	
}

uint8	W25X32_READ_2_BlindSection(uint8	*	uiReviceBuf0,uint32	*	puiNum)
{
	uint16	len=0;
	uint8	buff[2];
	memset(buff,0,sizeof(buff));
	
	W25X32_READ_2_Semphore(cur_BlindSection_RepairAddr,sizeof(buff),buff);	//读长度
	len=(uint16)(buff[0]<<8)+(uint16)buff[1];
	if((len>(GPRSINFOLEN-50))||(len<0x11))	//非法数据	
		return	FALSE;
	*puiNum=(uint32)len;	//数据包长度
	W25X32_READ_2_Semphore(cur_BlindSection_RepairAddr,*puiNum,uiReviceBuf0);	//读数据包所有内容
	
	return 	TRUE;
	
}

/*******************************************************************************************************
*							                    Max add for extend flash w/r area									     *
********************************************************************************************************/
uint8	Ini_Sec_counter(uint8 *sec_no, uint8 sec_mark, uint8 sec_default )
{
	INT8U	currentsec[1], newcounter[3];
	uint32	secno;
	char		temp[30];
	secno = (uint32)(*sec_no);
	
	W25X32_READ_Semphore(GetAddr(secno, SEC_SIZE-1),sizeof(currentsec), (uint8 *)currentsec);					//check the section is workable or not
	while( (currentsec[0] != sec_mark) && (secno<MAX_SEC_NO) ) 					//find the work section
	{
		secno++;
		W25X32_READ_Semphore(GetAddr(secno, SEC_SIZE-1), sizeof(currentsec), (uint8 *)currentsec);
	}
	if( secno==MAX_SEC_NO )											//if not found, set the mark and counter to default section
	{
		secno = (uint32)(*sec_no);
		currentsec[0] = sec_mark;											
		//W25X32_WRITE(GetAddr(osecno, SEC_SIZE-1), sizeof(currentsec), (uint8 *)currentsec,  sizeof(currentsec));	//set mark (S, C, W, M)
		W25X32_WR(GetAddr(secno, SEC_SIZE-1), (uint8 *)currentsec, (uint32) sizeof(currentsec));	//set mark (S, C, W, M)
		newcounter[0] = 0x00;
		newcounter[1] = 0x00;
		newcounter[2] = 0x00;
		//W25X32_WRITE(GetAddr(osecno, SEC_SIZE-4),  sizeof(newcounter), (uint8 *)newcounter,  sizeof(newcounter));	//set counter to 0
		W25X32_WR(GetAddr(secno, SEC_SIZE-4), (uint8 *)newcounter,  (uint32) sizeof(newcounter));	//set counter to 0
	}
	else
		(*sec_no) =(uint8) secno;
	
	sprintf(temp,"Ini sec:%d to mark:%c\n",secno, sec_mark);
	uartWrite(UART3,(uint8	*)temp,strlen(temp),NULL);
	return TRUE;
}

uint8	Reset_All_Sec()
{
	W25X32_Erase_Semphore(1, MAX_SEC_NO);											//erase all work section
	
	return TRUE;
}

uint8	Test_Count_Sec(uint8 sec_no, uint16 maxcount, uint8 fillchar)										//count how many time to erase & write data in one sector
{
	INT8U	currentcounter[3], newcounter[3];
	uint32	ccounter;
	if (sec_no >1 && sec_no <= MAX_SEC_NO)
	{
		ccounter=0;
		//W25X32_READ(GetAddr(sec_no, SEC_SIZE-3),2,newcounter);
		//ccounter = (uint16) newcounter;
		while(ccounter < 0xFFFF && ccounter <= maxcount )
		{
			W25X32_Erase_Semphore(sec_no,sec_no );
			currentcounter[0] = (ccounter / 0xFF) / 0xFF;
			currentcounter[1] = (ccounter / 0xFF) % 0xFF;
			currentcounter[2] = ccounter % 0xFF;
			ccounter++;
			W25X32_WRITE(GetAddr(sec_no, SEC_SIZE-4), sizeof(currentcounter),  (uint8 *)currentcounter, sizeof(currentcounter));	
			W25X32_READ_Semphore(GetAddr(sec_no, SEC_SIZE-4),sizeof(newcounter), (uint8 *)newcounter);
			UART3_output_digit((uint16)*newcounter,3);
			if( (uint32)*currentcounter != (uint32)*newcounter)
			{
				uartWrite(UART3,(uint8	*)"Flash fail\r\n",strlen("Flash fail\r\n"),NULL); 	//测试	
				UART3_output_digit(  (uint16)*currentcounter,  4);
				ccounter = 0xFFFF;
			}
		}		
	}
	else
		uartWrite(UART3,(uint8	*)"Sector NO error!\r\n",strlen("Sector NO error!\r\n"),NULL); 	//测试
	return TRUE;
}

uint8	Dump_Sec(uint8 sec_no)
{
	uint16 i;
	INT8U	data[1];
	uartWrite(UART3,(uint8	*)"Sector ",strlen("Sector "),NULL); 	//测试
	UART3_output_digit(  sec_no,  2);
	uartWrite(UART3,(uint8	*)" dump start:\r\n",strlen(" dump start:\r\n"),NULL); 	//测试
	for( i=0; i<SEC_SIZE; i++)
	{
		W25X32_READ_Semphore(GetAddr(sec_no,i),sizeof(data), (uint8  *)data);
		UART3_output_digit(  (uint16)*data,  1);
	}	
	uartWrite(UART3,(uint8	*)"\r\ndump end:\r\n",strlen("\r\ndump end:\r\n"),NULL); 	//测试
	return TRUE;
}

uint8	UART3_output_digit( uint16 val, uint8 digit)
{
	INT8U	data, asciidata[9];
	uint8 i;
	if( digit <= 4 & digit > 0 )
	{
		for(i=0; i<digit*2; i++)
		{
			data = val%16;
			if( data > 9 )
				asciidata[digit*2-i-1] = data-10 + 'A';
			else
				asciidata[digit*2-i-1] = data + '0';
			val = val / 16;	
		}
		asciidata[digit*2]='\0';
		uartWrite(UART3,(uint8	*)asciidata,digit*2,NULL); 
	}
	else
		uartWrite(UART3,(uint8	*)"DigitError\r\n",strlen("DigitError\r\n"),NULL);	
	return TRUE;	
}


// 将buff写入从地址Oid_Addr开始的Flash存储单元里
uint8 W25X32_WRITE_BLOCK(uint32 Oid_Addr,  uint32 Oid_Len,  uint8 * Buff,  uint32  Data_Size)
{
	const	uint8	pageLen=0xff;
	uint8	i=0; 
	uint8	*	temp;
	
	OSMemQuery(IntBuffer_Big,&MemInfo);
	if(MemInfo.OSNFree > (uint8)(Data_Size/BlockSize_Big))
	{
		temp=(INT8U *)OSMemGet(IntBuffer_Big,&err);		//使用获得的内存块
		W25X32_READ_Semphore(GetAddr(Oid_Addr/SEC_SIZE,0),Data_Size,temp);
//		W25X32_Erase(Oid_Addr/SEC_SIZE, Oid_Addr/SEC_SIZE); 			//don't erase
		memmove(temp+Oid_Addr%SEC_SIZE,Buff,Oid_Len);
		for(i=0;i<Data_Size/pageLen;i++)
		{
			W25X32_WR(GetAddr(Oid_Addr/SEC_SIZE,i*pageLen),temp+i*pageLen,pageLen);
			OSTimeDly(3);
		}
		if(Data_Size%pageLen>0)
		{
			W25X32_WR(GetAddr(Oid_Addr/SEC_SIZE,i*pageLen),temp+i*pageLen,Data_Size%pageLen);
			OSTimeDly(3);
		}
		OSMemPut(IntBuffer_Big,temp);		//释放获得的内存块
		uartWrite(UART3,(uint8	*)"WriteBlock\r\n",strlen("WriteBlock\r\n"),NULL);
	}
	else
		return	FALSE;
		
	return	TRUE;
		    	
}
/*******************************************************************************************************
*									                            End Of File										     *
********************************************************************************************************/