vs1001.c

Go to the documentation of this file.

#include <avr/io.h>
#include <avr/pgmspace.h>
#include "types.h"
#include "delay.h"
#include "vs1001.h"
#include "mmc.h" // for SPI routines

//
// VS1001 commands
//
#define VS1001_READ     0x03
#define VS1001_WRITE    0x02

#define write_byte_spi(data) (SpiByte(data))

/*
uint8 write_byte_spi(uint8 data)
{
        outp(data, SPDR);
        loop_until_bit_is_set(SPSR, SPIF);    
        
        return inp(SPDR);
}       

*/

// used for the sine_test function
const uint8     __attribute__ ((progmem)) SINETESTSTART[8]  = {0x53,0xef,0x6e,0x22,0,0,0,0};
const uint8     __attribute__ ((progmem)) SINETESTSTOP[8]   = {0x45,0x78,0x69,0x74,0,0,0,0};


void vs1001_read(uint8 address, uint16 count, uint16 *pData)
{
        uint8 i;

#ifdef VS1000_NEW
        SBI( xDCS_PORT, xDCS_PIN );     // xDCS hi
#else
        CBI( BSYNC_PORT, BSYNC_PIN );   // byte sync lo
#endif
        
        CBI( MP3_PORT, MP3_PIN);        // xCS lo
        write_byte_spi(VS1001_READ);
        write_byte_spi(address);

        while (count--)
        {
                *pData = write_byte_spi(0) << 8;
                *pData++ |= write_byte_spi(0);
        }

        SBI( MP3_PORT, MP3_PIN);        // xCS hi

        //this is absolutely neccessary!
        //delay(5); //wait 5 microseconds after sending data to control port
        for (i=0;i<8;i++)
                asm volatile("nop");

}



void vs1001_write(uint8 address, uint16 count, uint16 *pData)
{
        uint8 i;
        
#ifdef VS1000_NEW
        SBI( xDCS_PORT, xDCS_PIN );     // xDCS hi
#else
        CBI( BSYNC_PORT, BSYNC_PIN );   // byte sync lo
#endif  
        
        CBI( MP3_PORT, MP3_PIN);        // xCS lo
        
        write_byte_spi(VS1001_WRITE);
        write_byte_spi(address);

        while (count--)
        {
                write_byte_spi((uint8)((*pData) >> 8));
                write_byte_spi((uint8)*pData);
                pData++;
        }
        
        SBI( MP3_PORT, MP3_PIN);        // xCS hi

        //this is absolutely neccessary!
        //delay(5); //wait 5 microseconds after sending data to control port
        for (i=0;i<8;i++)
                asm volatile("nop");
}


/****************************************************************************
**
** MPEG Data Stream
**
****************************************************************************/


/* !!! WARNING !!!
        
ALL data on the spi lines is read as
input to the MPEG Stream by the vs1001 when :
-the BSYNC line is high and compiled in standard (vs1001 compatability) mode.
-the xDCS line is low in new (VS1002) mode.

If in New mode 

*/

inline void vs1001_send_data(unsigned char b)
{
        char i;
#ifdef VS1000_NEW
        CBI( xDCS_PORT,   xDCS_PIN );           //  XDCS lo
#else
        SBI( BSYNC_PORT,   BSYNC_PIN );         // byte sync hi
#endif
        //      outp(b, SPDR);                  // send data
        SPDR = b;                               // send data
        
        // release BSYNC before end of byte
#ifndef VS1000_NEW
        asm volatile("nop");
        asm volatile("nop"); 
        asm volatile("nop"); 
        CBI( BSYNC_PORT,   BSYNC_PIN );         // byte sync lo
#endif  
        // wait for data to be sent
        loop_until_bit_is_set(SPSR, SPIF); 
        
        //release xDCS after byte has been sent
#ifdef VS1000_NEW
        SBI( xDCS_PORT,   xDCS_PIN );           // byte XDCS hi
#endif
        i = SPDR;                               // clear SPIF
        

}


inline void vs1001_send_32(unsigned char *p)
{
        int j;

        
#ifdef VS1000_NEW
        CBI( xDCS_PORT,   xDCS_PIN );           // xDCS lo
#else
        SBI( BSYNC_PORT,   BSYNC_PIN );         // byte sync hi
#endif
        for (j=0;j<31;j++) 
        {
                SPDR = *p++ ;           // send data
                // wait for data to be sent
                loop_until_bit_is_set(SPSR, SPIF);   
        }
                
        SPDR = *p++ ;           // send last byte
                
#ifndef VS1000_NEW
        // release BSYNC before last bit of last byte.
        asm volatile("nop");
        asm volatile("nop");
        asm volatile("nop"); 
        CBI( BSYNC_PORT,   BSYNC_PIN );         // byte sync lo
#endif  
        // wait for data to be sent
        loop_until_bit_is_set(SPSR, SPIF);   

#ifdef VS1000_NEW
        SBI( xDCS_PORT,   xDCS_PIN );           // xDCS hi
#endif
        j = SPDR; // clear SPIF
}



/****************************************************************************
**
** Init and helper functions
**
****************************************************************************/


void vs1001_init_io(void)
{
#ifdef VS1000_NEW
        // setup xDCS (same as pin as BSYNC AFAIK)
        SBI( xDCS_DDR , xDCS_PIN );             // pin is output for xDCS 
        SBI( xDCS_PORT, xDCS_PIN );             // output High
#else
        // setup BSYNC
        SBI( BSYNC_DDR , BSYNC_PIN );           // pin is output for BSYNC
        CBI( BSYNC_PORT, BSYNC_PIN );           // output low
#endif
        // set the MP3/ChipSelect pin hi
        SBI( MP3_DDR , MP3_PIN);                // pin output for xCS
        SBI( MP3_PORT, MP3_PIN);                // output hi (deselect MP3)

        // set the /Reset pin hi
        SBI( RESET_DDR , RESET_PIN);            // pin output 
        SBI( RESET_PORT, RESET_PIN);            // output hi

        // Setup DREQ Pin
        CBI(DREQ_DDR , DREQ_PIN);               // pin input
        CBI(DREQ_PORT, DREQ_PIN);               // no pullup

}


void vs1001_init_chip(void)
{
        //we use a hardware reset, works much better 
        //than software rest, but makes a click noise.

        Delay(3);
        vs1001_reset(HARD_RESET);

        Delay(3);
        vs1001_nulls(32);
        vs1001_reset(SOFT_RESET);

    vs1001_sine_test();
}



void vs1001_reset(reset_e r)
{

        uint16 buf[2];

        if (r == SOFT_RESET)
        {
                
        //      Delay(200);             // 200 mS
                SPSR = (0<<SPI2X);                      //set spi to Fosc/4
                
                // set SW reset bit     
                buf[0] = SM_RESET ;
                vs1001_write(SCI_MODE,1,buf);   // set bit 2

                Delay(2);               // 2 mS

                while( !((DREQ_PORT) & (1<<DREQ_PIN)) ); //wait for DREQ

#ifdef VS1000_NEW
        buf[0] = SM_SDINEW ; 
        vs1001_write(SCI_MODE,1, buf);
#endif
        // set CLOCKF for 24.576 MHz
                // change to doubler //nick 7/7/04
                buf[0] = 0x9800;
                vs1001_write(SCI_CLOCKF,1,buf); 

#ifdef VS1001   
                // Force clock doubler see pg32 of VS10XX appl.notes
                buf[0] = 0x8008;
                vs1001_write(SCI_INT_FCTLH,1,buf);
#endif
                vs1001_nulls(32);
            
                SPSR = (1<<SPI2X);                      //set spi to Fosc/2
        }
        else if (r == HARD_RESET)
        {
                CBI(RESET_PORT, RESET_PIN);     // RESET- lo
                Delay(1);       // 1 mS     
                SBI(RESET_PORT, RESET_PIN);     // RESET- hi
                Delay(5);       // 5 mS     
        }
}

void vs1001_nulls(unsigned int nNulls)
{
        while (nNulls--)
                vs1001_send_data(0);
}

void vs_1001_setvolume(unsigned char left, unsigned char right)
{
        uint16 buf[2];

        buf[0] = (((uint16)left) << 8) | (uint16)right;

        vs1001_write(SCI_VOL, 1, buf);
}
        
void vs1001_sine_test(void)
{
    uint16 buf[2];
    int i,j ;
    
    buf[0]=0;
    
#ifdef VS1000_NEW
//    • Set New Mode by writing four SCI bytes: 0x2, 0x0, 0x8, 0x20 
    buf[0] |= SM_SDINEW ;
#endif
#if defined (VS1011) || defined(VS1053)
    buf[0] |= SM_TESTS;
#endif
    
    vs1001_write(SCI_MODE,1,buf);
    
    for(j=0; j<5;j++){
    //  • Activate the sine test by writing the following eight bytes to SDI: 0x53 0xEF 0x6E 0x22, 0, 0, 0, 0
        for (i=0;i<8;i++) {
            vs1001_send_data(pgm_read_byte(&SINETESTSTART[i]));   
        }  
    //  • Wait for example 500 ms. 
        Delay(500);
                             
    //  • Deactivate the sine test by writing to SDI: 0x45 0x78 0x69 0x74. 
        for (i=0;i<8;i++){
            vs1001_send_data(pgm_read_byte(&SINETESTSTOP[i]));   
         }          
                             
    //  • Wait for example 500 ms. 
         Delay(500);                    
    }
}