Subversion Repositories Code-Repo

/*

    VLSI Solution generic microcontroller example player / recorder for

    VS1053.

    v1.03 2012-12-11 HH  Recording command 'p' was VS1063 only -> removed

                                             Added chip type recognition

    v1.02 2012-12-04 HH  Command '_' incorrectly printed VS1063-specific fields

    v1.01 2012-11-28 HH  Untabified

    v1.00 2012-11-27 HH  First release

*/

#include "player.h"

#include "hal_SPI.h"

#include "hal_hardware_board.h"

#include "pff.h"

/* Download the latest VS1053a Patches package and its

     vs1053b-patches-flac.plg. If you want to use the smaller patch set

     which doesn't contain the FLAC decoder, use vs1053b-patches.plg instead.

     The patches package is available at

     http://www.vlsi.fi/en/support/software/vs10xxpatches.html */

//#include "vs1053b-patches.plg"

// Extracted plugin contents:

#define PLUGIN_SIZE 40

const unsigned short plugin[40] = { /* Compressed plugin */

        0x0007, 0x0001, 0x8010, 0x0006, 0x001c, 0x3e12, 0xb817, 0x3e14, /*    0 */

        0xf812, 0x3e01, 0xb811, 0x0007, 0x9717, 0x0020, 0xffd2, 0x0030, /*    8 */

        0x11d1, 0x3111, 0x8024, 0x3704, 0xc024, 0x3b81, 0x8024, 0x3101, /*   10 */

        0x8024, 0x3b81, 0x8024, 0x3f04, 0xc024, 0x2808, 0x4800, 0x36f1, /*   18 */

        0x9811, 0x0007, 0x0001, 0x8028, 0x0006, 0x0002, 0x2a00, 0x040e,

};

/* We also want to have the VS1053b Ogg Vorbis Encoder plugin. To get more

     than one plugin included, we'll have to include it in a slightly more

     tricky way. To get the plugin included below, download the latest version

     of the VS1053 Ogg Vorbis Encoder Application from

     http://www.vlsi.fi/en/support/software/vs10xxapplications.html */

// #define SKIP_PLUGIN_VARNAME

// const unsigned int encoderPlugin[] = {

// #include "venc44k2q05.plg"

// };

// #undef SKIP_PLUGIN_VARNAME

/* VS1053b IMA ADPCM Encoder Fix, available at

     http://www.vlsi.fi/en/support/software/vs10xxpatches.html */

// #define SKIP_PLUGIN_VARNAME

// const unsigned int imaFix[] = {

// #include "imafix.plg"

// };

// #undef SKIP_PLUGIN_VARNAME

#define FILE_BUFFER_SIZE        224  // Minimum 32!

#define SDI_MAX_TRANSFER_SIZE   32

#define SDI_END_FILL_BYTES_FLAC 12288

#define SDI_END_FILL_BYTES      2052

//#define REC_BUFFER_SIZE         224

#define REPORT_INTERVAL 4096

#define REPORT_INTERVAL_MIDI 512

#define min(a,b) (((a)<(b))?(a):(b))

enum AudioFormat {

    afUnknown,

    afRiff,

    afOggVorbis,

    afMp1,

    afMp2,

    afMp3,

    afAacMp4,

    afAacAdts,

    afAacAdif,

    afFlac,

    afWma,

    afMidi

} audioFormat = afUnknown;

const char *afName[] = {

    "unknown",

    "RIFF",

    "Ogg",

    "MP1",

    "MP2",

    "MP3",

    "AAC MP4",

    "AAC ADTS",

    "AAC ADIF",

    "FLAC",

    "WMA",

    "MIDI",

};

/*

 * SCI Write

 */

void WriteSci(unsigned char addr, unsigned int data) {

    unsigned char c;

    do {                    // Wait until DREQ is high

        c = VS10XX_DREQ_STAT();

    } while (c == 0);

    VS10XX_CS_LOW();

    spiSendByte(0x02);      // Write command code

    spiSendByte(addr);      // Write SCI register

    spiSendByte((unsigned char)(data >> 8));

    spiSendByte((unsigned char)(data & 0xFF));

    VS10XX_CS_HIGH();

}

/*

 * SCI Read

 */

unsigned int ReadSci(unsigned char addr) {

    unsigned char buffer[2];

    int ret;

    unsigned char c;

    do {                    // Wait until DREQ is high

        c = VS10XX_DREQ_STAT();

    } while (c == 0);

    VS10XX_CS_LOW();

    spiSendByte(0x03);      // Write command code

    spiSendByte(addr);      // Write SCI register

    spiReadFrame(buffer, 2);

    ret = buffer[0] << 8;

    ret |= buffer[1];

    VS10XX_CS_HIGH();

    return ret;

}

/*

 * SDI Write

 */

int WriteSdi(unsigned char *data, unsigned char bytes) {

    if (bytes > SDI_MAX_TRANSFER_SIZE)

        return -1;

    unsigned char c;

    do {                    // Wait until DREQ is high

        c = VS10XX_DREQ_STAT();

    } while (c == 0);

    VS10XX_DS_LOW();

    spiSendFrame(data, (unsigned int)bytes);

    VS10XX_DS_HIGH();

    return 0;

}

/*

    Read 32-bit increasing counter value from addr.

    Because the 32-bit value can change while reading it,

    read MSB's twice and decide which is the correct one.

*/

unsigned long ReadVS10xxMem32Counter(unsigned int addr) {

    unsigned int msbV1, lsb, msbV2;

    unsigned long res;

    WriteSci(SCI_WRAMADDR, addr+1);

    msbV1 = ReadSci(SCI_WRAM);

    WriteSci(SCI_WRAMADDR, addr);

    lsb = ReadSci(SCI_WRAM);

    msbV2 = ReadSci(SCI_WRAM);

    if (lsb < 0x8000U) {

        msbV1 = msbV2;

    }

    res = ((unsigned long)msbV1 << 16) | lsb;

    return res;

}

/*

    Read 32-bit non-changing value from addr.

*/

unsigned long ReadVS10xxMem32(unsigned int addr) {

    unsigned int lsb;

    WriteSci(SCI_WRAMADDR, addr);

    lsb = ReadSci(SCI_WRAM);

    return lsb | ((unsigned long)ReadSci(SCI_WRAM) << 16);

}

/*

    Read 16-bit value from addr.

*/

unsigned int ReadVS10xxMem(unsigned int addr) {

    WriteSci(SCI_WRAMADDR, addr);

    return ReadSci(SCI_WRAM);

}

/*

    Write 16-bit value to given VS10xx address

*/

void WriteVS10xxMem(unsigned int addr, unsigned int data) {

    WriteSci(SCI_WRAMADDR, addr);

    WriteSci(SCI_WRAM, data);

}

/*

    Write 32-bit value to given VS10xx address

*/

void WriteVS10xxMem32(unsigned int addr, unsigned long data) {

    WriteSci(SCI_WRAMADDR, addr);

    WriteSci(SCI_WRAM, (unsigned int)data);

    WriteSci(SCI_WRAM, (unsigned int)(data>>16));

}

/* Note: code SS_VER=2 is used for both VS1002 and VS1011e */

const unsigned int chipNumber[16] = {

    1001, 1011, 1011, 1003, 1053, 1033, 1063, 1103,

    0, 0, 0, 0, 0, 0, 0, 0

};

void Set32(unsigned char *d, unsigned long n) {

	unsigned int i;

    for (i=0; i<4; i++) {

        *d++ = (unsigned char)n;

        n >>= 8;

    }

}

void Set16(unsigned char *d, unsigned int n) {

	unsigned int i;

    for (i=0; i<2; i++) {

        *d++ = (unsigned char)n;

        n >>= 8;

    }

}

/*

    Loads a plugin.

    This is a slight modification of the LoadUserCode() example

    provided in many of VLSI Solution's program packages.

*/

void LoadPlugin(const unsigned short *d, unsigned short len) {

    unsigned int i = 0;

    while (i<len) {

        unsigned short addr, n, val;

        addr = d[i++];

        n = d[i++];

        if (n & 0x8000U) { /* RLE run, replicate n samples */

            n &= 0x7FFF;

            val = d[i++];

            while (n--) {

                WriteSci(addr, val);

            }

        } else {           /* Copy run, copy n samples */

            while (n--) {

                val = d[i++];

                WriteSci(addr, val);

            }

        }

    }

}

enum PlayerStates {

    psPlayback = 0,

    psStopped

} playerState;

/*

 * Executes a software reset

 */

void VS1053SoftwareReset(void) {

	unsigned char c;

	unsigned short oldMode = ReadSci(SCI_MODE);

	WriteSci(SCI_MODE, oldMode | SM_RESET);

	__delay_cycles(100);

	do {	// Wait until DREQ is high

		c = VS10XX_DREQ_STAT();

	} while (c == 0);

}

/*

    This function plays back an audio file.

    File playback:

        1. Send an audio file to VS1053b

        2. Read extra parameter value endFillByte

        3. Send at least 2052 bytes of endFillByte

        4. Set SCI_MODE bit SM_CANCEL

        5. Send at least 32 bytes of endFillByte

        6. Read SCI_MODE. If SM_CANCEL is set, goto step 5

            If still set after 2048 bytes, do a software reset

    Cancelling playback:

        1. Send a portion of an audio file to VS1053b

        2. Set SCI_MODE bit SM_CANCEL

        3. Continue to send audio file, check SM_CANCEL every 32 bytes

            If set, goto step 3

            If still set after 2048 bytes, do a software reset

        4. Read extra parameter value endFillByte

        5. Send 2052 bytes of endFillByte

*/

void VS1053PlayFile(const char *fileName) {

    unsigned char playBuf[FILE_BUFFER_SIZE];

    unsigned short bytesRead;			// Number of bytes read by pf_read()

    unsigned short bytesInBuffer;       // How many valid bytes in buffer left

    unsigned short pos = 0;             // File position

    int endFillByte = 0;                // What byte value to send after file

    int playMode = ReadVS10xxMem(PAR_PLAY_MODE);

    long nextReportPos = 0;             // File pointer where to next collect/report

    FRESULT res;

    unsigned int i;

    playerState = psPlayback;           // Set state to normal playback

    WriteSci(SCI_DECODE_TIME, 0);       // Reset DECODE_TIME

    res = pf_open(fileName);

    if (res != FR_OK)

        return;

    /* Main playback loop */

    // Read the entire file FILE_BUFFER_SIZE (32) bytes at a time

    do {

        unsigned char *bufP = playBuf;

        // Read FILE_BUFFER_SIZE (32) bytes from the file into the buffer

        res = pf_read(playBuf, FILE_BUFFER_SIZE, &bytesRead);

        if (res != FR_OK)

            break;

        bytesInBuffer = bytesRead;

        while (bytesInBuffer && playerState != psStopped) {

            if (!(playMode & PAR_PLAY_MODE_PAUSE_ENA)) {

                int bytesToWrite = min(SDI_MAX_TRANSFER_SIZE, bytesInBuffer);

                // This is the heart of the algorithm: on the following line

                // actual audio data gets sent to VS10xx.

                WriteSdi(bufP, bytesToWrite);

                bufP += bytesToWrite;

                bytesInBuffer -= bytesToWrite;

                pos += bytesToWrite;

            }

            /* If playback is going on as normal, see if we need to collect and

                 possibly report */

            if (playerState == psPlayback && pos >= nextReportPos) {

                nextReportPos += (audioFormat == afMidi || audioFormat == afUnknown) ?

                    REPORT_INTERVAL_MIDI : REPORT_INTERVAL;

                /* It is important to collect endFillByte while still in normal

                     playback. If we need to later cancel playback or run into any

                     trouble with e.g. a broken file, we need to be able to repeatedly

                     send this byte until the decoder has been able to exit. */

                endFillByte = ReadVS10xxMem(PAR_END_FILL_BYTE);

            }

        }

    } while(bytesRead == FILE_BUFFER_SIZE && playerState != psStopped);

    /* Earlier we collected endFillByte. Now, just in case the file was

         broken, or if a cancel playback command has been given, write

         SDI_END_FILL_BYTES (2052) bytes of endFillByte. */

    for (i = 0; i < FILE_BUFFER_SIZE; i++) {

        playBuf[i] = endFillByte;

    }

    for (i = 0; i < SDI_END_FILL_BYTES; i += SDI_MAX_TRANSFER_SIZE) {

        WriteSdi(playBuf, SDI_MAX_TRANSFER_SIZE);

    }

    /* If the file actually ended, and playback cancellation was not

         done earlier, do it now. */

    if (playerState == psPlayback) {

    	pos = SDI_MAX_TRANSFER_SIZE;

        unsigned short oldMode = ReadSci(SCI_MODE);

        WriteSci(SCI_MODE, oldMode | SM_CANCEL);

        // Write 32 bytes of endFillByte

        WriteSdi(playBuf, SDI_MAX_TRANSFER_SIZE);

        i = ReadSci(SCI_MODE);

        while (i & SM_CANCEL) {

        	// Reset after sending 2048 bytes

        	if (pos > 2048) {

        		VS1053SoftwareReset();

        		break;

        	}

            WriteSdi(playBuf, SDI_MAX_TRANSFER_SIZE);

            pos += SDI_MAX_TRANSFER_SIZE;

            i = ReadSci(SCI_MODE);

        }

    }

}

/*

 * Main initialization function

 */

int VS1053Init(void) {

    if (VSInitHardware() != 0)

        return 1;

    if (VSInitSoftware() != 0)

        return 1;

    return 0;

}

/*

    Hardware Initialization for VS1053.

*/

int VSInitHardware(void) {

    /* Write here your microcontroller code which puts VS10xx in hardware

         reset and back (set xRESET to 0 for at least a few clock cycles,

         then to 1). */

//    // Chip Command Select (idle high)

//    VS10XX_CS_PxOUT |= VS10XX_CS;

//    VS10XX_CS_PxDIR |= VS10XX_CS;

//

//    // Chip Data Select (idle high)

//    VS10XX_DC_PxOUT |= VS10XX_DC;

//    VS10XX_DC_PxDIR |= VS10XX_DC;

//

//    // Reset (idle high)

//    VS10XX_RESET_PxOUT |= VS10XX_RESET;

//    VS10XX_RESET_PxDIR |= VS10XX_RESET;

//

//    // DREQ Line

//    VS10XX_DREQ_PxDIR &= ~VS10XX_DREQ;

	CHIP_RESET_LOW();

    __delay_cycles(10000);

    CHIP_RESET_HIGH();

    unsigned char c;

	do {	// Wait until DREQ is high

		c = VS10XX_DREQ_STAT();

	} while (c == 0);

    return 0;

}

/*

    Software Initialization for VS1053.

    Note that you need to check whether SM_SDISHARE should be set in

    your application or not.

*/

int VSInitSoftware(void) {

    unsigned int ssVer;

    unsigned char c;

	do {	// Wait until DREQ is high

		c = VS10XX_DREQ_STAT();

	} while (c == 0);

    /* Initial SPI bus speed needs to be < 1.5Mhz */

    halSPISetSpeedLow();

    /* Start initialization with a dummy read, which makes sure our

         microcontroller chips selects and everything are where they

         are supposed to be and that VS10xx's SCI bus is in a known state. */

    ReadSci(SCI_MODE);

    /* First real operation is a software reset. After the software

         reset we know what the status of the IC is. You need, depending

         on your application, either set or not set SM_SDISHARE. See the

         datasheet for details. */

//    WriteSci(SCI_MODE, SM_SDINEW|SM_SDISHARE|SM_TESTS|SM_RESET);

    WriteSci(SCI_MODE, SM_SDINEW|SM_RESET);

    /* A quick sanity check: write to two registers, then test if we

         get the same results. Note that if you use a too high SPI

         speed, the MSB is the most likely to fail when read again. */

    WriteSci(SCI_HDAT0, 0xABAD);

    WriteSci(SCI_HDAT1, 0x1DEA);

    if (ReadSci(SCI_HDAT0) != 0xABAD || ReadSci(SCI_HDAT1) != 0x1DEA) {

    	// There is something wrong with VS10xx

        return 1;

    }

    /* Set the clock. Until this point we need to run SPI slow so that

         we do not exceed the maximum speeds mentioned in

         Chapter SPI Timing Diagram in the datasheet. */

    WriteSci(SCI_CLOCKF, HZ_TO_SC_FREQ(12288000) | SC_MULT_53_35X | SC_ADD_53_10X);

//    WriteSci(SCI_CLOCKF, 0x6000);

    __delay_cycles(10000);

    /* Now when we have upped the VS10xx clock speed, the microcontroller

		 SPI bus can run faster. Do that before you start playing or

		 recording files. */

    halSPISetSpeedHigh();

    /* A quick sanity check: write to two registers, then test if we

		 get the same results. Note that if you use a too high SPI

		 speed, the MSB is the most likely to fail when read again. */

	WriteSci(SCI_HDAT0, 0xABAD);

	WriteSci(SCI_HDAT1, 0x1DEA);

	if (ReadSci(SCI_HDAT0) != 0xABAD || ReadSci(SCI_HDAT1) != 0x1DEA) {

		// There is something wrong with VS10xx

		return 1;

	}

    /* Check VS10xx type */

    ssVer = ((ReadSci(SCI_STATUS) >> 4) & 15);

    if (chipNumber[ssVer]) {

    	// Chip is VS%d\n", chipNumber[ssVer]);

        if (chipNumber[ssVer] != 1053) {

        	// Incorrect chip

            return 1;

        }

    } else {

    	// Unknown VS10xx SCI_MODE field

        return 1;

    }

    /* Set up other parameters. */

//    WriteVS10xxMem(PAR_CONFIG1, PAR_CONFIG1_AAC_SBR_SELECTIVE_UPSAMPLE);

    /* Set volume level to max */

    WriteSci(SCI_VOL, 0x0000);

    /* Now it's time to load the proper patch set. */

    LoadPlugin(plugin, sizeof(plugin)/sizeof(plugin[0]));

    /* We're ready to go. */

    return 0;

}