cs5532_test.lst

CS5532的驱动程序

(0388) 				{
(0389) 					SPIWrite(msg_buffer[5]|(1<<3));
(0390) 				}
(0391) 				else
(0392) 				{
(0393) 					SPIWrite(msg_buffer[5]);
(0394) 				}
(0395) 				SPIWrite16(address);
(0396) 				SPIWrite(msg_buffer[i+10]);
(0397) 				//Check if we can do polling
(0398) 				if(msg_buffer[8]!=msg_buffer[i+10])
(0399) 				{
(0400) 					polling_address = address&0xFFFF;
(0401) 				}
(0402) 				//If not switch the mode hard waiting
(0403) 				else
(0404) 				{
(0405) 					mode = (mode&(~0x0E)) | 0x02;
(0406) 				}
(0407) 				//Different polling methods
(0408) 				//Hard waiting
(0409) 				if((mode&0x0E) == 0x02)
(0410) 				{
(0411) 					msDelay(msg_buffer[4]);
(0412) 				}
(0413) 				//Data polling
(0414) 				else if((mode&0x0E) == 0x04)
(0415) 				{
(0416) 					do{
(0417) 						//If we have an uneven byte read the
(0418) 						//high byte			
(0419) 						if(i&1)
(0420) 						{
(0421) 							SPIWrite(msg_buffer[7]|(1<<3));
(0422) 						}
(0423) 						else
(0424) 						{
(0425) 							SPIWrite(msg_buffer[7]);
(0426) 						}						
(0427) 						SPIWrite16(polling_address);
(0428) 						tmp=SPIWrite(0x00);
(0429) 					}while(tmp==msg_buffer[8]);
(0430) 				}
(0431) 				//RDY/BSY polling
(0432) 				else if((mode&0x0E) == 0x08)
(0433) 				{
(0434) 					while(universalComm(0xF0,0x00,0x00,0x00)&1);
(0435) 				}
(0436) 				//If something was not correct with the given mode do
(0437) 				//hard waiting. Should never reach this point
(0438) 				else
(0439) 				{
(0440) 					msDelay(msg_buffer[4]);					
(0441) 				}		
(0442) 				//increment (word) address only when we have an uneven (byte) address
(0443) 				if(i&1) address++;
(0444) 			}			
(0445) 		}
(0446) 		//Page Mode
(0447) 		else
(0448) 		{
(0449) 			for(i=0;i<block_size;i++)
(0450) 			{
(0451) 				//If we have an uneven（奇数） byte programm the
(0452) 				//high byte			
(0453) 				if(i&1)
(0454) 				{
(0455) 					SPIWrite(msg_buffer[5]|(1<<3));  	//高字节
(0456) 				}
(0457) 				else
(0458) 				{
(0459) 					SPIWrite(msg_buffer[5]);		//低字节
(0460) 				}
(0461) 				SPIWrite16(address);
(0462) 				SPIWrite(msg_buffer[i+10]);
(0463) 				//Check if we can do polling//用于数据轮寻，随意找一个地址
(0464) 				if(msg_buffer[8]!=msg_buffer[i+10])
(0465) 				{
(0466) 					//We have to check if we have an uneven byte. 
(0467) 					//Set the polling address to a byte address
(0468) 					//so that we can poll the right location
(0469) 					polling_address = (address&0xFFFF)*2;
(0470) 					if(i&1) polling_address++;
(0471) 				}
(0472) 				
(0473) 				//increment (word) address only when we have an uneven (byte) address
(0474) 				if(i&1) address++;
(0475) 			}
(0476) 			//If this page is complete the bit 7 of mode will be set and we programm the page
(0477) 			if(mode&0x80)  //页编程，并且选择等待的方式
(0478) 			{
(0479) 				SPIWrite(msg_buffer[6]);	
(0480) 				SPIWrite16(start_address);
(0481) 				SPIWrite(0x00);
(0482) 				//If we have no valid polling address switch to simple wait mode
(0483) 				if(polling_address==0)
(0484) 				{
(0485) 					mode = (mode&(~0x70)) | 0x10;
(0486) 				}
(0487) 				//Different polling methods
(0488) 				//Hard waiting
(0489) 				if((mode&0x70) == 0x10)
(0490) 				{
(0491) 					msDelay(msg_buffer[4]);
(0492) 				}
(0493) 				//Data polling
(0494) 				else if((mode&0x70) == 0x20)
(0495) 				{
(0496) 					do{
(0497) 						//If we have an uneven byte read the
(0498) 						//high byte			
(0499) 						if(polling_address%2)
(0500) 						{
(0501) 							SPIWrite(msg_buffer[7]|(1<<3));
(0502) 						}
(0503) 						else
(0504) 						{
(0505) 							SPIWrite(msg_buffer[7]);
(0506) 						}
(0507) 						SPIWrite16(polling_address/2);
(0508) 						tmp=SPIWrite(0x00);
(0509) 					}while(tmp==msg_buffer[8]);
(0510) 				}
(0511) 				//RDY/BSY polling
(0512) 				else if((mode&0x70) == 0x40)
(0513) 				{
(0514) 					while(universalComm(0xF0,0x00,0x00,0x00)&1);
(0515) 				}
(0516) 				//If something was not correct with the given mode do
(0517) 				//hard waiting. Should never reach this point
(0518) 				else
(0519) 				{
(0520) 					msDelay(msg_buffer[4]);					
(0521) 				}
(0522) 			}
(0523) 		}
(0524) 		num_bytes = 2;
(0525) 		msg_buffer[0] = CMD_PROGRAM_FLASH_ISP;
(0526) 	}
(0527) 	//命令CMD_READ_FLASH_ISP
(0528) 	else if(cmd==CMD_READ_FLASH_ISP)
(0529) 	{
(0530) 		LED_FLASH2;	
(0531) 		block_size = ((unsigned int)msg_buffer[1])<<8;
(0532) 		block_size |= msg_buffer[2];
(0533) 		tmp = msg_buffer[3];
(0534) 		
(0535) 		for(i=0;i<block_size;i++)
(0536) 		{
(0537) 			//Select Low or High-Byte
(0538) 			if(i&1)
(0539) 			{
(0540) 				SPIWrite(tmp|(1<<3));
(0541) 			}
(0542) 			else
(0543) 			{
(0544) 				SPIWrite(tmp);
(0545) 			}
(0546) 			
(0547) 			SPIWrite16(address&0xFFFF);
(0548) 			msg_buffer[i+2] = SPIWrite(0);
(0549) 			//increment (word) address only when we have an uneven (byte) address
(0550) 			if(i&1) address++;
(0551) 		}
(0552) 		
(0553) 		num_bytes = block_size+3;
(0554) 		msg_buffer[0] = CMD_READ_FLASH_ISP;
(0555) 		msg_buffer[1] = STATUS_CMD_OK;
(0556) 		msg_buffer[block_size+2] = STATUS_CMD_OK;
(0557) 	}
(0558) 	//命令CMD_PROGRAM_EEPROM_ISP
(0559) 	else if(cmd==CMD_PROGRAM_EEPROM_ISP)
(0560) 	{
(0561) 		block_size = ((unsigned int)msg_buffer[1])<<8;
(0562) 		block_size |= msg_buffer[2];
(0563) 		mode = msg_buffer[3];
(0564) 		
(0565) 		//Byte Mode
(0566) 		if((mode&1) == 0)
(0567) 		{		
(0568) 			for(i=0;i<block_size;i++)
(0569) 			{	
(0570) 				LED_FLASH2;	
(0571) 				SPIWrite(msg_buffer[5]);								
(0572) 				SPIWrite16(address&0xFFFF);
(0573) 				SPIWrite(msg_buffer[i+10]);
(0574) 				
(0575) 				//Check if we can do polling
(0576) 				if((msg_buffer[i+10]!=msg_buffer[8])&&(msg_buffer[i+10]!=msg_buffer[9]))
(0577) 				{
(0578) 					polling_address = address&0xFFFF;
(0579) 				}
(0580) 				//If not switch the mode hard waiting
(0581) 				else
(0582) 				{
(0583) 					mode = (mode&(~0x0E)) | 0x02;
(0584) 				}
(0585) 				
(0586) 				//Different polling methods
(0587) 				//Hard waiting
(0588) 				if((mode&0x0E) == 0x02)
(0589) 				{
(0590) 					msDelay(msg_buffer[4]);
(0591) 				}
(0592) 				//Data polling
(0593) 				else if((mode&0x0E) == 0x04)
(0594) 				{
(0595) 					do{
(0596) 						SPIWrite(msg_buffer[7]);
(0597) 						SPIWrite16(polling_address);
(0598) 						tmp=SPIWrite(0x00);
(0599) 					}while((tmp==msg_buffer[8])||(tmp==msg_buffer[9]));
(0600) 				}
(0601) 				//RDY/BSY polling
(0602) 				else if((mode&0x0E) == 0x08)
(0603) 				{
(0604) 					while(universalComm(0xF0,0x00,0x00,0x00)&1);
(0605) 					//while(spi_transfer_32(0xF0000000)&1);
(0606) 				}
(0607) 				//If something was not correct with the given mode do
(0608) 				//hard waiting. Should never reach this point
(0609) 				else
(0610) 				{
(0611) 					msDelay(msg_buffer[4]);					
(0612) 				}
(0613) 				
(0614) 				//increment address
(0615) 				address++;
(0616) 			}			
(0617) 		}
(0618) 		//Page Mode
(0619) 		else
(0620) 		{
(0621) 			
(0622) 			for(i=0;i<block_size;i++)
(0623) 			{
(0624) 				LED_FLASH2;
(0625) 				SPIWrite(msg_buffer[5]);
(0626) 				SPIWrite16(address&0xFFFF);
(0627) 				SPIWrite(msg_buffer[i+10]);
(0628) 				//Check if we can do polling
(0629) 				if((msg_buffer[i+10]!=msg_buffer[8])&&(msg_buffer[i+10]!=msg_buffer[9]))
(0630) 				{
(0631) 					polling_address = address&0xFFFF;
(0632) 				}
(0633) 				
(0634) 				//increment (word) address only when we have an uneven (byte) address
(0635) 				address++;
(0636) 			}
(0637) 			
(0638) 			//If this page is complete the bit 7 of mode will be set and we programm the page
(0639) 			if(mode&0x80)
(0640) 			{
(0641) 				SPIWrite(msg_buffer[6]);						
(0642) 				SPIWrite16(start_address&0xFFFF);
(0643) 				SPIWrite(0);
(0644) 				
(0645) 				//If we have no valid polling address switch to simple wait mode
(0646) 				if(polling_address==0)
(0647) 				{
(0648) 					mode = (mode&(~0x70)) | 0x10;
(0649) 				}
(0650) 				
(0651) 				//Different polling methods
(0652) 				//Hard waiting
(0653) 				if((mode&0x70) == 0x10)
(0654) 				{
(0655) 					msDelay(msg_buffer[4]);
(0656) 				}
(0657) 				//Data polling
(0658) 				else if((mode&0x70) == 0x20)
(0659) 				{
(0660) 					do{
(0661) 						//If we have an uneven byte read the
(0662) 						//high byte			
(0663) 						if(i&1)
(0664) 						{
(0665) 							SPIWrite(msg_buffer[7]|(1<<3));
(0666) 						}
(0667) 						else
(0668) 						{
(0669) 							SPIWrite(msg_buffer[7]);
(0670) 						}
(0671) 						SPIWrite16(polling_address);
(0672) 						tmp=SPIWrite(0x00);
(0673) 					}while(tmp==msg_buffer[8]);
(0674) 				}
(0675) 				//RDY/BSY polling
(0676) 				else if((mode&0x70) == 0x40)
(0677) 				{
(0678) 					while(universalComm(0xF0,0x00,0x00,0x00)&1);
(0679) 				}
(0680) 				//If something was not correct with the given mode do
(0681) 				//hard waiting. Should never reach this point
(0682) 				else
(0683) 				{
(0684) 					msDelay(msg_buffer[4]);					
(0685) 				}
(0686) 			}
(0687) 		}
(0688) 		
(0689) 		num_bytes = 2;
(0690) 		msg_buffer[0] = CMD_PROGRAM_EEPROM_ISP;
(0691) 		msg_buffer[1] = STATUS_CMD_OK;
(0692) 	}
(0693) 	//命令CMD_READ_EEPROM_ISP
(0694) 	else if(cmd==CMD_READ_EEPROM_ISP)
(0695) 	{
(0696) 		block_size = ((unsigned int)msg_buffer[1])<<8;
(0697) 		block_size |= msg_buffer[2];
(0698) 		tmp = msg_buffer[3];
(0699) 		
(0700) 		for(i=0;i<block_size;i++)
(0701) 		{
(0702) 			//Select Low or High-Byte
(0703) 			SPIWrite(tmp);
(0704) 			SPIWrite16(address&0xFFFF);
(0705) 			msg_buffer[i+2] = SPIWrite(0);
(0706) 			//increment address
(0707) 			address++;
(0708) 		}
(0709) 		num_bytes = block_size+3;
(0710) 		msg_buffer[0] = CMD_READ_EEPROM_ISP;
(0711) 		msg_buffer[1] = STATUS_CMD_OK;
(0712) 		msg_buffer[block_size+2] = STATUS_CMD_OK;
(0713) 	}
(0714) 	
(0715) 	//命令CMD_PROGRAM_FUSE_ISP
(0716) 	else if(cmd==CMD_PROGRAM_FUSE_ISP)
(0717) 	{
(0718) 		universalComm(msg_buffer[1],msg_buffer[2],msg_buffer[3],msg_buffer[4]);
(0719) 		num_bytes = 3;
(0720) 		msg_buffer[0] = CMD_PROGRAM_FUSE_ISP;
(0721) 		msg_buffer[1] = STATUS_CMD_OK;		
(0722) 		msg_buffer[2] = STATUS_CMD_OK;
(0723) 	}
(0724) 
(0725) 	//命令CMD_READ_FUSE_ISP
(0726) 	else if(cmd==CMD_READ_FUSE_ISP)
(0727) 	{	
(0728) 		tmp = SPIWrite(msg_buffer[2]);
(0729) 		if(msg_buffer[1] == 1) msg_buffer[2] = tmp;
(0730) 		tmp = SPIWrite(msg_buffer[3]);
(0731) 		if(msg_buffer[1] == 2) msg_buffer[2] = tmp;
(0732) 		tmp = SPIWrite(msg_buffer[4]);
(0733) 		if(msg_buffer[1] == 3) msg_buffer[2] = tmp;
(0734) 		tmp = SPIWrite(msg_buffer[5]);
(0735) 		if(msg_buffer[1] == 4) msg_buffer[2] = tmp;
(0736) 		num_bytes = 4;
(0737) 		msg_buffer[0] = CMD_READ_FUSE_ISP;
(0738) 		msg_buffer[1] = STATUS_CMD_OK;		
(0739) 		msg_buffer[3] = STATUS_CMD_OK;
(0740) 	}
(0741) 	
(0742) 	//命令CMD_PROGRAM_LOCK_ISP
(0743) 	else if(cmd==CMD_PROGRAM_LOCK_ISP)
(0744) 	{
(0745) 		universalComm(msg_buffer[1],msg_buffer[2],msg_buffer[3],msg_buffer[4]);
(0746) 		
(0747) 		num_bytes = 3;
(0748) 		msg_buffer[0] = CMD_PROGRAM_LOCK_ISP;
(0749) 		msg_buffer[1] = STATUS_CMD_OK;		
(0750) 		msg_buffer[2] = STATUS_CMD_OK;
(0751) 	}
(0752) 	//命令CMD_READ_LOCK_ISP
(0753) 	else if(cmd==CMD_READ_LOCK_ISP)
(0754) 	{
(0755) 		tmp = SPIWrite(msg_buffer[2]);
(0756) 		if(msg_buffer[1] == 1) msg_buffer[2] = tmp;
(0757) 		tmp = SPIWrite(msg_buffer[3]);
(0758) 		if(msg_buffer[1] == 2) msg_buffer[2] = tmp;
(0759) 		tmp = SPIWrite(msg_buffer[4]);
(0760) 		if(msg_buffer[1] == 3) msg_buffer[2] = tmp;
(0761) 		tmp = SPIWrite(msg_buffer[5]);
(0762) 		if(msg_buffer[1] == 4) msg_buffer[2] = tmp;
(0763) 		num_bytes = 4;
(0764) 		msg_buffer[0] = CMD_READ_LOCK_ISP;
(0765) 		msg_buffer[1] = STATUS_CMD_OK;		
(0766) 		msg_buffer[3] = STATUS_CMD_OK;
(0767) 	}
(0768) 	
(0769) 	//命令CMD_READ_SIGNATURE_ISP
(0770) 	else if(cmd==CMD_READ_SIGNATURE_ISP)
(0771) 	{
(0772) 		tmp = SPIWrite(msg_buffer[2]);
(0773) 		if(msg_buffer[1] == 1) msg_buffer[2] = tmp;
(0774) 		tmp = SPIWrite(msg_buffer[3]);
(0775) 		if(msg_buffer[1] == 2) msg_buffer[2] = tmp;
(0776) 		tmp = SPIWrite(msg_buffer[4]);
(0777) 		if(msg_buffer[1] == 3) msg_buffer[2] = tmp;
(0778) 		tmp = SPIWrite(msg_buffer[5]);
(0779) 		if(msg_buffer[1] == 4) msg_buffer[2] = tmp;
(0780) 		num_bytes = 4;
(0781) 		msg_buffer[0] = CMD_READ_SIGNATURE_ISP;
(0782) 		msg_buffer[1] = STATUS_CMD_OK;		
(0783) 		msg_buffer[3] = STATUS_CMD_OK;
(0784) 	}
(0785) 	
(0786) 	//命令CMD_READ_OSCCAL_ISP
(0787) 	else if(cmd==CMD_READ_OSCCAL_ISP)
(0788) 	{
(0789) 		tmp = SPIWrite(msg_buffer[2]);
(0790) 		if(msg_buffer[1] == 1) msg_buffer[2] = tmp;
(0791) 		tmp = SPIWrite(msg_buffer[3]);
(0792) 		if(msg_buffer[1] == 2) msg_buffer[2] = tmp;
(0793) 		tmp = SPIWrite(msg_buffer[4]);
(0794) 		if(msg_buffer[1] == 3) msg_buffer[2] = tmp;
(0795) 		tmp = SPIWrite(msg_buffer[5]);
(0796) 		if(msg_buffer[1] == 4) msg_buffer[2] = tmp;
(0797) 		num_bytes = 4;
(0798) 		msg_buffer[0] = CMD_READ_OSCCAL_ISP;
(0799) 		msg_buffer[1] = STATUS_CMD_OK;		
(0800) 		msg_buffer[3] = STATUS_CMD_OK;
(0801) 	}
(0802) 	else
(0803) 	{
(0804) 		num_bytes = 1;
(0805) 		msg_buffer[0] = STATUS_CMD_UNKNOWN;
(0806) 	}
(0807) 	//传送缓冲区数据
(0808) 	if(num_bytes>0)
(0809) 	{		
(0810) 		putChar(MESSAGE_START);
(0811) 		checkSum=MESSAGE_START;
(0812) 		putChar(seqNum);
(0813) 		checkSum^=seqNum;
(0814) 		tmp=(num_bytes&0xFF00)>>8;
(0815) 		putChar(tmp);
(0816) 		checkSum^=tmp;
(0817) 		tmp=num_bytes&0x00FF;
(0818) 		putChar(tmp);
(0819) 		checkSum^=tmp;
(0820) 		putChar(TOKEN);
(0821) 		checkSum^=TOKEN;
(0822) 		for(i=0;i<num_bytes;i++)
(0823) 		{
(0824) 			putChar(msg_buffer[i]);
(0825) 			checkSum^=msg_buffer[i];
(0826) 		}		
(0827) 		putChar(checkSum);
(0828) 		checkSum=0x00;		
(0829) 	}
(0830) 
(0831) }    
(0832) */
(0833) 
(0834) 
(0835) /**********************************************************************
(0836) functionName:void rx_pkg_process(void)
(0837) description:串口接收包处理
(0838) **********************************************************************/
(0839) void rx_pkg_process(void)
(0840) {
(0841) 	uint16 i;
(0842) 	uint08 cmd;
(0843) 	
(0844) 	cmd = uart_tx_buf[0];
    01CA 91400082  LDS	R20,uart_tx_buf
(0845) 	
(0846) 	if(msg_end_flag)
    01CC 90200066  LDS	R2,msg_end_flag
    01CE 2022      TST	R2
    01CF F0A9      BEQ	0x01E5
(0847) 	{
(0848) 		msg_end_flag=0;
    01D0 2422      CLR	R2
    01D1 92200066  STS	msg_end_flag,R2