spi.c

atmelsam7s64做mp3解码的源程序

#include "AT91SAM7S64.h"
#include "Board.h"
#include "datatype.h"
#include "spi.h"


extern  Byte    gl_buffer[];
extern  INT16U  u16GlBufferPos;
extern  Byte    SPI_Init;

//------------------------------------------------------------------------
void delay(INT16U time)
{
    INT16U i;
       for(i=0; i<time; i++);
}


//------------------------------------------------------------------------
void vSpiInit(void)
{
    *AT91C_PMC_PCER   |= SPI_CLK_MASK;  //SPI_CLK enable
    *AT91C_PIOA_PDR   |= SPIMASK;       //PIO Disable
    *AT91C_PIOA_ASR   |= SPIMASK;       //A,B Peripheral,select A
    *AT91C_PIOA_PPUER |= SPIPULLUP;     //Pull-up enable   
    *AT91C_SPI_MR     = 0x0600001b;     //0x06   delay time
                                        //0x00   pcs NPCS
                                        //0x00   reserved
                                        //0x1b   00011011 ;LLB=0,MODFDIS=1,FDIV=1,PCSDEC=0,PS=1,MSTR=1
                                        
    *AT91C_SPI_CSR0   = 0x0a0a0208;     //DLYBCT=10,DLYBS=10,SCBR=2,BITS=0000,CSAAT=1,NCPHA=0,CPOL=0(used for vs1003b)
    *AT91C_SPI_CSR1   = 0x0a0a0208;     //DLYBCT=10,DLYBS=10,SCBR=2,BITS=0000,CSAAT=1,NCPHA=0,CPOL=0(used for mmc sd card)
   
    *AT91C_SPI_CSR3   = 0x0a0a0208;     //usd for SPCK out
    
    *AT91C_SPI_CR     = 0x00000001;     //SPI enable
} 



//-------------------------------------------------------------------------
void vSPCK_Out(void)
{
   while( !(*AT91C_SPI_SR & 0x000002FF) );
   *AT91C_SPI_TDR = 0x00070000 | 0xff;    //LASTXFER=0,PCS=0111 
}


//-------------------------------------------------------------------------
void vSentMMC(INT8U data)
{
    while( !(*AT91C_SPI_SR & 0x00000200) );
    *AT91C_SPI_TDR = 0x000d0000 | data;    //LASTXFER=0,PCS=1101
}                               


//-------------------------------------------------------------------------
void vSentVs1003(INT8U data)
{
    while( !(*AT91C_SPI_SR & 0x00000200) );
    *AT91C_SPI_TDR = 0x000e0000 | data;    //LASTXFER=0,PCS=1110   
}


//-------------------------------------------------------------------------
INT16U vReadMMC()
{
   INT16U temp;
   
   *AT91C_SPI_TDR = 0x000d0000 | 0x00;    //LASTXFER=0,PCS=1101 
   while( !(*AT91C_SPI_SR & 0x00000001) );
   temp = *AT91C_SPI_RDR;
   return temp;
}




//------------------------------------------------------------------------
void  PIO_Init(void) 
{
   *AT91C_PMC_SCER = AT91C_CKGR_MOSCEN;
   *AT91C_PMC_PCER = 1 << AT91C_ID_PIOA;

   *AT91C_PIOA_PER |= (MMC_PORT_MASK | LED_MASK);
   *AT91C_PIOA_OER |= (MMC_PORT_OUT_MASK | LED_MASK);
   *AT91C_PIOA_ODR |= MMC_PORT_IN_MASK;
   *AT91C_PIOA_PPUER |= SPIPULLUP;     //Pull-up enable
   
   *AT91C_PIOA_SODR = LED1;
} 


//------------------------------------------------------------------------
INT8U vGet_MISO(void)
{
   if(*AT91C_PIOA_PDSR & MMC_MISO)
      return 1;
   else
      return 0;
}      

//------------------------------------------------------------------------
INT8U vGet_DREQ(void)
{
   if(*AT91C_PIOA_PDSR & VS1003_DREQ)
      return 1;
   else
      return 0;
}


//-------------------------------------------------------------------------
void vMmcWriteByte(INT8U u8Data)
{
   INT8U i;
   
   for(i=0; i<8; i++)
   {
      MMC_CLK_LOW();
      
      if(SPI_Init)
        delay(1000);
        
      if( ((u8Data<<i) & 0x80) == 0x80 )
        MMC_MOSI_HIGH();
      else
        MMC_MOSI_LOW();
        
      if(SPI_Init)
        delay(1000);
        
      MMC_CLK_HIGH(); 
   }
   MMC_MOSI_HIGH();
}


//-------------------------------------------------------------------------
INT8U vMmcReadByte(void)
{
   INT8U i;
   INT8U u8Data = 1;
   
   for(i=0; i<8; i++)
   {
      MMC_CLK_LOW();
      
      if(SPI_Init)
        delay(1000);
        
      u8Data = (u8Data << 1) + vGet_MISO();
      
      if(SPI_Init)
        delay(1000);  
      
      MMC_CLK_HIGH();
   }
   return(u8Data);
}


//-------------------------------------------------------------------------
INT8U vMmcWriteCommand(INT8U* pCommand)
{
   INT8U i;
   INT8U temp;
   INT8U u8Retry = 0;
   
   MMC_CS_HIGH();
   vMmcWriteByte(0xff);
   MMC_CS_LOW();
   
   for(i=0; i<6; i++)
      vMmcWriteByte(*pCommand ++);
     
   vMmcReadByte();
   
   do
   {
      temp = vMmcReadByte();
      u8Retry ++;
   }
   while( (temp == 0xff) && (u8Retry < 100) );
   return(temp); 
}

//------------------------------------------------------------------------
INT8U vMmcReadBlock(INT8U* pCommand, INT8U* pBuffer, INT16U u16Bytes)
{
    INT16U i;
    INT8U u8Retry,temp;
   
    u8Retry = 0;
    do
    {
       temp = vMmcWriteCommand(pCommand);
       u8Retry ++;
       if(u8Retry == 100)
       {
          return(0xff);
       }
    }
    while(temp != 0);
    
    while (vMmcReadByte() != 0xfe);
   
   //Write blocks(normal 512Bytes) to MMC/SD-Card
    for (i=0; i<u16Bytes; i++)
    {
       *pBuffer++ = vMmcReadByte();
    }
   
   //CRC-Byte
    vMmcReadByte();//CRC - Byte 
    vMmcReadByte();//CRC - Byte
	
   //set MMC_Chip_Select to high (MMC/SD-Card invalid)
    MMC_CS_HIGH();
    return(0);
}


//------------------------------------------------------------------------
INT8U vMmcReadSector(INT32U addr, INT8U *Buffer)
{	
   //Command 16 is reading Blocks from MMC/SD-Card
   INT8U CMD[] = {0x51,0x00,0x00,0x00,0x00,0xFF}; 
   INT8U temp;
   
   //Address conversation(logic block address-->byte address)  
   addr = addr << 9; //addr = addr * 512

   CMD[1] = ((addr & 0xFF000000) >>24 );
   CMD[2] = ((addr & 0x00FF0000) >>16 );
   CMD[3] = ((addr & 0x0000FF00) >>8 );

   temp = vMmcReadBlock(CMD, Buffer, 512);
   
   return(temp);
}



//------------------------------------------------------------------------
INT8U MMC_Init()
{
    INT8U CMD[] = {0x40,0x00,0x00,0x00,0x00,0x95};
    INT8U i;
    INT8U u8Retry;
    INT8U temp;

    delay(0xffff);

    for(i=0; i<0x0f; i++)    //at lease 74 clock
    {
        vMmcWriteByte(0xff);
    } 
    
    u8Retry = 0;
    do
    {
       temp = vMmcWriteCommand(CMD);
       u8Retry ++;
       if(u8Retry == 200)
       {
           *AT91C_PIOA_CODR = LED1;
           return (0);
       }
    }
    while(temp != 1);
    
    CMD[0] = 0x41;
    CMD[5] = 0xff;
    
    u8Retry = 0;
    do
    {
       temp = vMmcWriteCommand(CMD);
       u8Retry ++;
       if(u8Retry == 100)
       {
           *AT91C_PIOA_CODR = LED1;
           return (0);
       }
    }
    while(temp != 0); 
 
    return (1);    
}


//-------------------------------------------------------------------------
void VS1003_SCI_Write(INT8U u8RegNumber, INT16U u16Data)
{
    VS1003_DS_HIGH();
    VS1003_CS_LOW();
    
    vMmcWriteByte(0x02);                     //write opcode
    vMmcWriteByte(u8RegNumber);              //reg id
    vMmcWriteByte((u16Data & 0xff00) >> 8);  //high byte
    vMmcWriteByte(u16Data & 0x00ff);         //low  byte
    
    VS1003_CS_HIGH();
}

//-------------------------------------------------------------------------
INT16U VS1003_SCI_Read(INT8U u8RegNumber)
{
    INT16U temp;
    
    VS1003_DS_HIGH();
    VS1003_CS_LOW();
    
    vMmcWriteByte(0x03);                     //write opcode
    vMmcWriteByte(u8RegNumber);              //reg id
    
    temp = vMmcReadByte();                   //high byte
    temp = (temp << 8) + vMmcReadByte();     //low  byte
    
    VS1003_CS_HIGH();
    
    return (temp);
}


//-------------------------------------------------------------------------
INT16U VS1003_SDI_Write(INT8U* pData, INT16U u16DataNumber)
{
    INT16U i;
    
    VS1003_DS_LOW();
    
    for(i=0; i<u16DataNumber; i++)
    {
       vMmcWriteByte(*pData ++);
    }  
    
    VS1003_DS_HIGH();
}


//-------------------------------------------------------------------------
ata_install()
{}

hdd_uninstall()
{}



INT8U mmc_read_byte()
{
   if(u16GlBufferPos < 512)
      return(gl_buffer[u16GlBufferPos ++]);
}

INT8U mmc_read_open(INT32U u32Postion)
{
   vMmcReadSector(u32Postion, gl_buffer);
   u16GlBufferPos = 0;
   return OK;
}



hdd_read_close()
{
}

hdd_write_byte(INT8U a)
{}

hdd_write_open(INT32U pos)
{}

hdd_write_close()
{}

hdd_format()
{}

hdd_read_long_big_endian()
{}


/*
hdd_read_one_sector()
{}

hdd_write_one_sector()
{}
*/