// TI File $Revision: /main/1 $
// Checkin $Date: January 15, 2008   10:49:54 $
//###########################################################################
//
// FILE:   Example_2823xSpi_FFDLB.c
//
// TITLE:  DSP2823x Device Spi Digital Loop Back program. 
//
// ASSUMPTIONS:
//
//    This program requires the DSP2823x header files. 
// 
//    This program uses the internal loop back test mode of the peripheral. 
//    Other then boot mode pin configuration, no other hardware configuration
//    is required. 
//
//    As supplied, this project is configured for "boot to SARAM" 
//    operation.  The 2823x Boot Mode table is shown below.  
//    For information on configuring the boot mode of an eZdsp, 
//    please refer to the documentation included with the eZdsp,  
//
//       $Boot_Table:
//
//         GPIO87   GPIO86     GPIO85   GPIO84
//          XA15     XA14       XA13     XA12
//           PU       PU         PU       PU
//        ==========================================
//            1        1          1        1    Jump to Flash
//            1        1          1        0    SCI-A boot
//            1        1          0        1    SPI-A boot
//            1        1          0        0    I2C-A boot
//            1        0          1        1    eCAN-A boot
//            1        0          1        0    McBSP-A boot
//            1        0          0        1    Jump to XINTF x16
//            1        0          0        0    Jump to XINTF x32
//            0        1          1        1    Jump to OTP
//            0        1          1        0    Parallel GPIO I/O boot
//            0        1          0        1    Parallel XINTF boot
//            0        1          0        0    Jump to SARAM	    <- "boot to SARAM"
//            0        0          1        1    Branch to check boot mode
//            0        0          1        0    Boot to flash, bypass ADC cal
//            0        0          0        1    Boot to SARAM, bypass ADC cal
//            0        0          0        0    Boot to SCI-A, bypass ADC cal
//                                              Boot_Table_End$
//
// DESCRIPTION:
//
//    This program is a SPI example that uses the internal loopback of
//    the peripheral.  Interrupts are not used.
//
//    A stream of data is sent and then compared to the recieved stream.
//  
//    The sent data looks like this:
//    0000 0001 0002 0003 0004 0005 0006 0007 .... FFFE FFFF
//
//    This pattern is repeated forever.  
//
//          Watch Variables:         
//                sdata - sent data
//                rdata - received data
//		
////###########################################################################		
// Original Author: S.S.
//
// $TI Release: DSP2833x Header Files V1.10 $
// $Release Date: February 15, 2008 $
//###########################################################################


#include "DSP2833x_Device.h"     // DSP2823x Headerfile Include File
#include "DSP2833x_examples.h"   // DSP2823x Examples Include File
extern	void play_Udisc();
//////////////////////////////////////
/*
#define SPI_SEL_REG *(Uint16 *)0x4500
#define LED_SPI  0X00
const   Uint16  LedCode[]={0X7E7E,0X2929,0X2C2C,0X6666,0XA4A4,0XA0A0,0X3E3E,0X2020,0X2424};
*/
///////////////////////////////////////
// Prototype statements for functions found within this file.
// interrupt void ISRTimer2(void);
/*
void delay_loop(void);
void spi_xmit(Uint16 a);
void spi_fifo_init(void);
void spi_init(void);
void error(void);
//////////////////////////////////////
unsigned int count;

void delay(unsigned int);
void ldelay(unsigned int);
void WriteLED(unsigned int);
*/
//////////////////////////////////////////////////
void main(void)
{
//   Uint16 sdata;  // send data
 //  Uint16 rdata;  // received data

// Step 1. Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
// This example function is found in the DSP2833x_SysCtrl.c file.
   InitSysCtrl();

// Step 2. Initalize GPIO: 
// This example function is found in the DSP2833x_Gpio.c file and
// illustrates how to set the GPIO to it's default state.
// InitGpio();  // Skipped for this example  
// Setup only the GP I/O only for SPI-A functionality
// This function is found in DSP2833x_Spi.c
   InitXintf();
   InitSpiaGpio();

// Step 3. Clear all interrupts and initialize PIE vector table:
// Disable CPU interrupts 
   DINT;

// Initialize PIE control registers to their default state.
// The default state is all PIE interrupts disabled and flags
// are cleared.  
// This function is found in the DSP2833x_PieCtrl.c file.
   InitPieCtrl();

// Disable CPU interrupts and clear all CPU interrupt flags:
   IER = 0x0000;
   IFR = 0x0000;
   
// Initialize the PIE vector table with pointers to the shell Interrupt 
// Service Routines (ISR).  
// This will populate the entire table, even if the interrupt
// is not used in this example.  This is useful for debug purposes.
// The shell ISR routines are found in DSP2833x_DefaultIsr.c.
// This function is found in DSP2833x_PieVect.c.
   InitPieVectTable();
	
// Step 4. Initialize all the Device Peripherals:
// This function is found in DSP2833x_InitPeripherals.c
// InitPeripherals(); // Not required for this example
//   spi_fifo_init();	  // Initialize the Spi FIFO
 //  spi_init();		  // init SPI

// Step 5. User specific code:
// Interrupts are not used in this example. 
 //  sdata = 0x0000;							
  // for(;;)
 //  {    
     // Transmit data
 //    spi_xmit(sdata);
     // Wait until data is received
 //    while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) { } 			
     // Check against sent data
 //    rdata = SpiaRegs.SPIRXBUF;				
 //   if(rdata != sdata) error();
 //    sdata++;
//	 if (sdata>0x200) break;
//   }
 //  for(;;);
////////////////////////////////////////////////
    	spi_initialization();					//Initialize SPI	

// 	Step 5. User specific code:	

	//Initialize test data for known data to transmit to card
//	for(i=0;i<1024;i++)						 
//	{										
//		write_buffer[i] = testdata;
	//	testdata += 0x0100;			//Card accepts 8 bit data so upper 8 bits are used
	//}

   //	led_initialization();			//Initialize all LEDs
   	sd_card_insertion();			//Check for card insertion
	sd_initialization();			//Initialize card

	sd_read_register(SEND_CSD);		//Read CSD register
	sd_read_register(READ_OCR);		//Read OCR register
	sd_read_register(SEND_CID);		//Read CID register


//	sd_write_block(0, write_buffer);	//Write to sector specified
//	sd_read_block(0, read_buffer);	//Read from sector specified
 //   sd_erase_block(0, 1);				//Erase sector range specified
//	sd_read_block(0, read_buffer);	//Read from sector specified
  play_Udisc();

    asm("     ESTOP0");  // test failed!! Stop!
    for (;;);






//////////////////////////////////////////
} 	


// Step 7. Insert all local Interrupt Service Routines (ISRs) and functions here:	
/*
void delay_loop()
{
    long      i;
    for (i = 0; i < 1000000; i++) {}
}


void error(void)
{
    asm("     ESTOP0");						// Test failed!! Stop!
    for (;;);
}

void spi_init()
{    
	SpiaRegs.SPICCR.all =0x000a;//0x000F;	             // Reset on, rising edge, 16-bit char bits  
	SpiaRegs.SPICTL.all =0x0006;    		     // Enable master mode, normal phase,
                                                 // enable talk, and SPI int disabled.
	SpiaRegs.SPIBRR =0x001d;									
    SpiaRegs.SPICCR.all =0x008a;		         // Relinquish SPI from Reset   
    SpiaRegs.SPIPRI.bit.FREE = 1;                // Set so breakpoints don't disturb xmission
}

void spi_xmit(Uint16 a)
{
    SpiaRegs.SPITXBUF=a;
}    

void spi_fifo_init()										
{
// Initialize SPI FIFO registers
    SpiaRegs.SPIFFTX.all=0xE040;
    SpiaRegs.SPIFFRX.all=0x204f;
    SpiaRegs.SPIFFCT.all=0x0;
}  
//////////////////////////////////////////////////////////////
void WriteLED(unsigned int index)
{

     
   if(SpiaRegs.SPISTS.bit.BUFFULL_FLAG != 1)
	spi_xmit((unsigned int)( LedCode[index]));

	delay(2000);

}
	
void ldelay(unsigned int k)
{
    while(k>0)
    {
        k--;
        delay(50000);
	}
}	

void delay(unsigned int t)
{
	while(t>0)
		t--;
}
*/
//===========================================================================
// No more.
//===========================================================================

