spi.c

lpc2368 source files

 /*   ***********  DEVELOPED BY RAVINDRANATH G *************/

/****************************************************************/
#include "lpc23xx.h"
#include "type.h"
#include "spi.h"
#include "uart.h"
#include "display_4x20.h"

/******************************************************************/

unsigned char p,Dummy;
void Rx_FIFO_clear(BYTE ssp_num);

void init_spi(void)	 
{
	S0SPCCR  = 0x20;
	S0SPCR   = 0x0838;
	FIO0DIR2 = 0x01;
	FIO0SET2  = 0X01;
	//SPTCR    = 0x02; 
}

void write_spi(char spi_dat) 
{
	S0SPDR = spi_dat;
	while(!(S0SPSR & 0x80));
}

char read_spi(void) 
{
	char spi_dat;

	S0SPDR = 0xff;
	while(!(S0SPSR & 0x80));
	spi_dat = S0SPDR;
	return spi_dat; 
}

//void ssp_init(void)	 
//{
//	SSP1CPSR  = 0x1C;
//	SSP1CR0  = 0x00c7;
//	SSP1CR1 = 0X02;
//	//FIO0DIR2 = 0x01;
//	//FIO0SET2  = 0X01;
//	//SPTCR    = 0x02; 
//}

void init_ssp(BYTE ssp_num)	 
{

	if(ssp_num == 0)
	{
		SSP0CPSR = 0x0C;	//0x1C 1MHz, 0x0C 2MHz
		SSP0CR0 = 0x00C7;
		SSP0CR1 = 0x02;
	}
	else if(ssp_num == 1)
	{
		SSP1CPSR = 0x0C;
		SSP1CR0 = 0x00C7;
		SSP1CR1 = 0x02;
	} 
}

void enable_ssp( BYTE ssp_num )
{
  if ( ssp_num == 0 )
  {
	SSP0CR1 = 0X02;
  }
  else
  {
	SSP1CR1 = 0X02;
  }
  return;
}

void disable_ssp( BYTE ssp_num )
{
  if ( ssp_num == 0 )
  {
	SSP0CR1 = 0X00;
  }
  else
  {
	SSP1CR1 = 0X00;
  }
  return;
}

void SSP_Send( BYTE ssp_num, BYTE *buf )
{
  int i,Length = 0;

  do
  {
	Length++;
  } while((*(buf+Length)) != '\0');

  if ( ssp_num == 0 )
  {
	for ( i = 0; i < Length; i++ )
	{
		/* as long as TNF bit is set (TxFIFO is not full), I can always transmit */
		SSP0DR = *buf;
		buf++;
		/* Wait until the Busy bit is cleared */
		while ( (SSP0SR & 0x10) );
	}
	return;
  }
  else if( ssp_num == 1 )
  {
	for ( i = 0; i < Length; i++ )
	{
		/* as long as TNF bit is set (TxFIFO is not full), I can always transmit */
		SSP1DR = *buf;
		buf++;
		/* Wait until the Busy bit is cleared */
		while ( (SSP1SR & 0x10) );
	}
	return;
  }  
   
}

void write_ssp(BYTE ssp_num, BYTE ssp_dat)
{

  if ( ssp_num == 0 )
  {
		/* as long as TNF bit is set (TxFIFO is not full), I can always transmit */
		while ( !(SSP0SR & 0x02) );
		SSP0DR = ssp_dat;
		while ( (SSP0SR & 0x10) );		/* Wait until the Busy bit is cleared */
  }
  else if( ssp_num == 1 )
  {
		/* as long as TNF bit is set (TxFIFO is not full), I can always transmit */
		while ( !(SSP1SR & 0x02) );
		SSP1DR = ssp_dat;
		while ( (SSP1SR & 0x10) ); 		/* Wait until the Busy bit is cleared */
  }  
}

BYTE read_ssp(BYTE ssp_num)
{

	if ( ssp_num == 0 )
	{
		Rx_FIFO_clear(0);
		SSP0DR = 0xFF;
		while (!(SSP0SR & 0x04) );
//		while ( (SSP0SR & 0x10) ); 
		return SSP0DR;
	}
	else if( ssp_num == 1 )
	{
		Rx_FIFO_clear(1);
		SSP1DR = 0xFF;
		while (!(SSP1SR & 0x04) );
//		while ( (SSP0SR & 0x10) );
		return SSP1DR;
	}
	else
	return 0;
}

void Rx_FIFO_clear(BYTE ssp_num)
{
	char s;
	if ( ssp_num == 0 )
	{
		for(s=0;s<8;s++)
			Dummy = SSP0DR;
	}
	else if( ssp_num == 1 )
	{
	 	for(s=0;s<8;s++)
			Dummy = SSP1DR;
	}

}
/******************************************/
//  SERIAL FLASH ROUTINES
/******************************************/
void cs_delay(void)
{
   unsigned int i_cs;
   for(i_cs=0;i_cs<5;i_cs++);
}


char ram2flash(unsigned int flshaddr, char *buff, int length)
{
   unsigned int templength,kk,mm_page_no,temp_data_addr;

   if((flshaddr+length)>4325375)
          return 1;                  //invalied page
   mm_page_no       = flshaddr / 528;
   temp_data_addr   = flshaddr % 528;
   while(length > 0)
   {   
		if((temp_data_addr+length) > 528)
		{
		  templength = 528 - temp_data_addr;
		}
		else
		templength = length;
		
		page2buffer(mm_page_no);
		
		FIO0CLR2 = 0X01;
		//cs = low;
		cs_delay();
	    
		//write_spi(0x84);
		write_ssp(0,0x84);
 		//write_spi(0x00);
		write_ssp(0,0x00);
		
		//write_spi((char)(temp_data_addr >> 8));
		//write_spi((char)(temp_data_addr));
		write_ssp(0,(char)(temp_data_addr >> 8));
		write_ssp(0,(char)(temp_data_addr ));

		for(kk=0;kk<templength;kk++)
		{
            //write_spi(*buff);
			write_ssp(0,*buff);
			buff++;
		}
		
		cs_delay();
		FIO0SET2 = 0X01;
		//cs = hi;
		cs_delay();
		
		buffer2page(mm_page_no);
		
		length = length - templength;
		mm_page_no++;
        temp_data_addr  = 0;
  }
  return 0;
}

char flash2ram(char *buff1, unsigned int flshaddr1, int length1)
{
    unsigned int mm_page_no1;
    unsigned int temp_data_addr1;

   if((flshaddr1+length1)>4325375)
          return 1;                  					       //invalied page
  mm_page_no1     = flshaddr1 / 528;
  temp_data_addr1 = flshaddr1 % 528;
  mm_page_no1 = mm_page_no1 <<2;
  
  busy_check();
  //while(SPISTAT & 0x10);								       //check if SPI is busy
  FIO0CLR2 = 0x01;
  //cs = low;
  cs_delay();
  
  //write_spi(0xe8);
  write_ssp(0,0xE8);
  //write_spi((char)(mm_page_no1 >> 8));
  write_ssp(0,(char)(mm_page_no1 >> 8));

  //write_spi((char)(mm_page_no1)|(char)(temp_data_addr1 >> 8));
  write_ssp(0,(char)(mm_page_no1)|(char)(temp_data_addr1 >> 8));

  //write_spi((char)(temp_data_addr1));
  write_ssp(0,(char)(temp_data_addr1));
  
//  write_spi(0x00);
//  write_spi(0x00);
//  write_spi(0x00);
//  write_spi(0x00);
  
	write_ssp(0,0x00);
	write_ssp(0,0x00);
	write_ssp(0,0x00);
	write_ssp(0,0x00);
	
//	Rx_FIFO_clear();

	while(length1!=0)
	{   
	  //*buff1= read_spi();
	  *buff1= read_ssp(0);
	  buff1++;
	  length1--;
	}

  cs_delay();
  FIO0SET2 = 0x01;
  //cs = hi;	
  cs_delay();
	
  return 0;

}

void busy_check(void)
{
    unsigned char del_flag;
    //delay_ms(50);
//	while(SPISTAT & 0x10);  		  //check if busy
     
    for(del_flag =0;del_flag<20;del_flag++);
	FIO0CLR2 = 0x01;
	//cs = low;
    for(del_flag =0;del_flag<20;del_flag++);
    
    //write_spi(0xd7);
	write_ssp(0,0xD7);
	del_flag = 0x00;				   
	
//	Rx_FIFO_clear();

	//while(!(del_flag & 0x80))del_flag = read_spi();
	while(!(del_flag & 0x80)){del_flag = read_ssp(0);}
   
   for(del_flag =0;del_flag<20;del_flag++);
   FIO0SET2 = 0x01;
   //cs = hi;	
   for(del_flag =0;del_flag<20;del_flag++);
}


void page2buffer(unsigned int flash_page)
{
 	busy_check();
	flash_page = flash_page<<2;
	 FIO0CLR2 = 0x01;
	//cs = low;
	cs_delay();
	
    //write_spi(0x53);
	write_ssp(0,0x53);

    //write_spi((char)(flash_page >> 8));
	write_ssp(0,(char)(flash_page >> 8));
    
    //write_spi((char)(flash_page));
	write_ssp(0,(char)(flash_page));
    
   //write_spi(0x00);
   write_ssp(0,0x00);

	cs_delay();
	FIO0SET2 = 0x01;
	//cs = hi;
	cs_delay();
	busy_check();
}

void buffer2page(unsigned int flash_page1)
{
    busy_check();
	flash_page1 = flash_page1<<2;
	FIO0CLR2 = 0x01;
	//cs = low;
    cs_delay();
	
    //write_spi(0x83);
	write_ssp(0,0x83);

    //write_spi((char)(flash_page1 >> 8));
	write_ssp(0,(char)(flash_page1 >> 8));
    
    //write_spi((char)(flash_page1));
	write_ssp(0,(char)(flash_page1));
    
    //write_spi(0x00);
	write_ssp(0,0x00);

    cs_delay();
	FIO0SET2 = 0x01;
	//cs = hi;
    cs_delay();
}