sl811.c

SPI FLASH,SL811HST驱动

#include "sl811.h"
 
 extern  void GotoXY(unsigned char x,unsigned char y); 
 extern  void Print(const char * s);
 extern  void ClearLcd(void);

//========================================================================================
// Programme main
//========================================================================================

//************************************************************
//			SL811 FUNCTIONS
//************************************************************

/****************************************************************************************/
//Write one byte in sl811 register
/****************************************************************************************/
void sl811_write(unsigned char adr, unsigned char value)
{
	TRISD = 0x00;			
//	NCS = 0;				
	A0 = 0;					
	SL811_DATA = adr;		
	NWR = 0;				
	asm("nop");
	NWR = 1;
	A0 = 1;					
	SL811_DATA = value;		
	NWR = 0;				
	asm("nop");
	NWR = 1;
//	NCS = 1;				
//	TRISD = 0xFF;			
}
	

/****************************************************************************************/
// Read one byte in sl811 register
/****************************************************************************************/
unsigned char sl811_read(unsigned char adr)
{
	unsigned char value;
//	p_data_out();
	TRISD = 0x00;			
//	NCS = 0;
	A0 = 0;					
	SL811_DATA = adr;		
	NWR = 0;
	asm("nop");
	NWR = 1;
//	A0 = 1;				
//	p_data_in();
//	SL811_DATA=0x0;
	asm("nop");
	A0 = 1;	
	TRISD = 0xFF;
	NRD = 0;
//	asm("nop");
	value = SL811_DATA;		
	NRD = 1;
//	NCS = 1;
//	p_data_in();
	TRISD = 0xFF;			
	return value;
}

/****************************************************************************************/
//Write buffer 
/****************************************************************************************/
void sl811_write_buf(unsigned char adr, unsigned char * buffer, unsigned char size)
{
	unsigned char i;
	sl811_write(adr, buffer[0]);	
	size--;
	i = 1;
	while(size != 0)
	{
		sl811_write_next(buffer[i]);	
		i++;
		size--;
	}
}

/****************************************************************************************/
//Read buffer
/****************************************************************************************/
void sl811_read_buf(unsigned char adr, unsigned char * buffer, unsigned char size) 
{	
	unsigned char i;
	buffer[0] = sl811_read(adr);	
	size --;
	i = 1;
	while(size != 0)
	{
		buffer[i] = sl811_read_next(); 
		i++;
		size--;
	}
}

/****************************************************************************************/
//Write without specify address
/****************************************************************************************/
void sl811_write_next(unsigned char value)
{
	A0 = 1;				
//	NCS = 0;
//	p_data_out();
	TRISD = 0x00;		
	SL811_DATA = value;
	NWR = 0;
	asm("nop");
	NWR = 1;
//	NCS = 1;
//	p_data_in();
	TRISD = 0xFF;	
}

/****************************************************************************************/
//Read without specify address
/****************************************************************************************/
unsigned char sl811_read_next(void)
{
	unsigned char value;
//	NCS = 0;
	A0 = 1;					
//	p_data_in();
	TRISD = 0xFF;
	NRD = 0;
	asm("nop");
	value = SL811_DATA;		
	NRD = 1;
//	NCS = 1;
	return value;
}

/****************************************************************************************/
//	SET_ADDRESS function 
/****************************************************************************************/
unsigned char sl811_set_addr(void)
{
	unsigned char tmp;
	//adr=0x01;
	sl811_write(0x10, 0x00);
	sl811_write_next(0x05);
	sl811_write_next(adr);
	sl811_write_next(0x00);
	sl811_write_next(0x00);
	sl811_write_next(0x00);
	sl811_write_next(0x00);
	sl811_write_next(0x00);
	
	sl811_write(0x01, 0x10);			//buffer address
	sl811_write(0x02, 0x08);			//size max
	sl811_write(0x03, 0xD0);			//PID SETUP
	sl811_write(0x04, 0x00);			//device address

	sl811_write(0x0D, 0x01);
	sl811_write(0x00, 0x27);			//send command,
	for(tmp=255; tmp!= 0; tmp--)
	{
		asm("nop");
	} 

	while((sl811_read(0x0D)&0x01) == 0);  //=1:USB-A Done Interrupt
	
//wait ack : host send IN packet and device must answer an empty packet

	tmp = 0;
	while(tmp == 0)
	{
		sl811_write(0x01, 0x10);			//buffer address
		sl811_write(0x02, 0x08);			//size max
		sl811_write(0x03, 0x90);			//PID IN
		sl811_write(0x04, 0x00);			//device address

		sl811_write(0x0D, 0x01);
		sl811_write(0x00, 0x23);			//envoi commande
		for(tmp=255; tmp!= 0; tmp--)
		{
			asm("nop");
		} 

		while((sl811_read(0x0D)&0x01) == 0); //=1:USB-A Done Interrupt
		if((sl811_read(0x03)& 0x01) == 1)tmp = 2;   //=1:Transmission Acknowledge  ACK
	}
	if(sl811_read(0x04) != 8)return ERROR;
	return COMPLETED;
}


/****************************************************************************************/
//GET DESCRIPTOR function (device descriptor)
/****************************************************************************************/
void sl811_get_device_desc(unsigned char * buf)
{
	unsigned char tmp, err;
			
	sl811_write(0x10, 0x80);
	sl811_write_next(0x06);
	sl811_write_next(0x00);
	sl811_write_next(0x01);
	sl811_write_next(0x00);
	sl811_write_next(0x00);
	sl811_write_next(0x12);		
	sl811_write_next(0x00);

	sl811_write(0x01, 0x10);
	sl811_write(0x02, 0x08);		//size
	sl811_write(0x03, 0xD0);		//PID SETUP
	sl811_write(0x04, adr);			//device address
	
	sl811_write(0x0D, 0x01);		
	sl811_write(0x00, 0x27);		
	for(tmp=255; tmp!= 0; tmp--)
	{
		asm("nop");
	} 

	while((sl811_read(0x0D)&0x01) == 0);	 //=1:USB-A Done Interrupt


	pause_ms(2);
//get first bytes of descriptors
	tmp = 0;
	while(tmp == 0)
	{
		sl811_write(0x01, 0x10);		//adresse buffer
		sl811_write(0x02, 0x12);		//nombre maximal d'octet que l'on peut recevoir
		sl811_write(0x03, 0x90);		//PID IN
		sl811_write(0x04, adr);

		sl811_write(0x0D, 0x01);
		sl811_write(0x00, 0x23);		//envoi de la commande
		for(tmp=255; tmp!= 0; tmp--)
		{
			asm("nop");
		} 

		while((sl811_read(0x0D)&0x01) == 0);  //=1:USB-A Done Interrupt
		err = sl811_read(0x03);				
		if((err&0x40) == 0)tmp =2;			//==1:Slave returns NAK
		
	
	}

	if(sl811_read(0x04) == 0) 				//read number of recieved bytes
	{
		sl811_read_buf(0x10, buf, 0x12);	//copy 18 bytes  //设备描述符长度
	}
	else									//10 bytes again
	{
		sl811_read_buf(0x10, buf, 0x08);

		pause_ms(2);

//next 8 bytes of the descriptor
		tmp = 0;
		while(tmp == 0)
		{
			sl811_write(0x01, 0x10);		
			sl811_write(0x02, 0x08);
			sl811_write(0x03, 0x90);			//PID IN
			sl811_write(0x04, adr);

			sl811_write(0x0D, 0x01);
			sl811_write(0x00, 0x23);		//send command


			for(tmp=255; tmp!= 0; tmp--)
			{
				asm("nop");
			} 
	
			while((sl811_read(0x0D)&0x01) == 0);
			
			if((sl811_read(0x03)&0x40) == 0)tmp =2;
		
		}


		buf[8] = sl811_read(0x10);
		buf[9] = sl811_read_next();
		buf[10] = sl811_read_next();
		buf[11] = sl811_read_next();
		buf[12] = sl811_read_next();
		buf[13] = sl811_read_next();
		buf[14] = sl811_read_next();
		buf[15] = sl811_read_next();

		pause_ms(2);
	
//last 2 bytes of the descriptor
		tmp = 0;
		while(tmp == 0)
		{

			sl811_write(0x01, 0x20);	
			sl811_write(0x02, 0x02);
			sl811_write(0x03, 0x90);			//PID IN
			sl811_write(0x04, adr);

			sl811_write(0x0D, 0x01);
			sl811_write(0x00, 0x23);		//send command
			for(tmp=255; tmp!= 0; tmp--)
			{
				asm("nop");
			} 

			while((sl811_read(0x0D)&0x01) == 0);

			buf[16] = sl811_read(0x20);
			buf[17] = sl811_read_next();
		
			if((sl811_read(0x03)&0x40) == 0)tmp =2; //==1:Slave returns NAK
		}
	}	


	pause_ms(2);
// send PID OUT to finish transaction		

	sl811_write(0x01, 0x10);
	sl811_write(0x02, 0x00);		//size 0
	sl811_write(0x03, 0x10);		//PID OUT
	sl811_write(0x04, adr);			//device address
	
	sl811_write(0x0D, 0x01);
	sl811_write(0x00, 0x67);		
	for(tmp=255; tmp!= 0; tmp--)
	{
		asm("nop");
	} 

	while((sl811_read(0x0D)&0x01) == 0);
}



/****************************************************************************************/
//GET CONFIGURATION function (configuration descriptor)
/****************************************************************************************/
void sl811_get_device_conf(unsigned char * buf)
{
	unsigned char tmp, err;
	//Device descriptor	
	sl811_write(0x10, 0x80);
	sl811_write_next(0x06);
	sl811_write_next(0x00);
	sl811_write_next(0x02);
	sl811_write_next(0x00);
	sl811_write_next(0x00);
	sl811_write_next(0x20);		
	sl811_write_next(0x00);

	sl811_write(0x01, 0x10);		
	sl811_write(0x02, 0x08);		//size
	sl811_write(0x03, 0xD0);		//PID SETUP
	sl811_write(0x04, adr);			//device address
	sl811_write(0x0D, 0x01);		
	sl811_write(0x00, 0x07);		
	for(tmp=255; tmp!= 0; tmp--)
	{
		asm("nop");
	} 

	while((sl811_read(0x0D)&0x01) == 0);	//test flag

	pause_ms(2);
//get first bytes
	tmp = 0;
	while(tmp == 0)
	{
		sl811_write(0x01, 0x10);		
		sl811_write(0x02, 0x20);		//size
		sl811_write(0x03, 0x90);		//PID IN
		sl811_write(0x04, adr);

		sl811_write(0x0D, 0x01);
		sl811_write(0x00, 0x03);		//send cmd
		for(tmp=255; tmp!= 0; tmp--)
		{
			asm("nop");
		} 

		while((sl811_read(0x0D)&0x01) == 0);
		err = sl811_read(0x03);
		if((err&0x40) == 0)tmp =2;
		
	
	}

	if(sl811_read(0x04) == 0) 				//read number of bytes
	{
		sl811_read_buf(0x10, buf, 0x20);	//copy bytes
	}
	else									//1 bytes to read
	{
		sl811_read_buf(0x10, buf, 0x08);

		pause_ms(2);

//last bytes of the descriptor
		tmp = 0;
		while(tmp == 0)
		{
			sl811_write(0x01, 0x10);		
			sl811_write(0x02, 0x08);
			sl811_write(0x03, 0x90);		//PID IN
			sl811_write(0x04, adr);

			sl811_write(0x0D, 0x01);
			sl811_write(0x00, 0x03);		//send cmd


			for(tmp=255; tmp!= 0; tmp--)
			{
				asm("nop");
			} 
	
			while((sl811_read(0x0D)&0x01) == 0);
			if((sl811_read(0x03)&0x40) == 0)tmp =2;
		
		}