Subversion Repositories Code-Repo

// ***********************************************************
// File: mmc.c 
// Description: Library to access a MultiMediaCard 
//              functions: init, read, write ...
//  C. Speck / S. Schauer
//  Texas Instruments, Inc
//  June 2005
//
// Version 1.1
//   corrected comments about connection the MMC to the MSP430
//   increased timeout in mmcGetXXResponse
//
// ***********************************************************
// MMC Lib
// ***********************************************************


/* ***********************************************************
* THIS PROGRAM IS PROVIDED "AS IS". TI MAKES NO WARRANTIES OR
* REPRESENTATIONS, EITHER EXPRESS, IMPLIED OR STATUTORY, 
* INCLUDING ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS 
* FOR A PARTICULAR PURPOSE, LACK OF VIRUSES, ACCURACY OR 
* COMPLETENESS OF RESPONSES, RESULTS AND LACK OF NEGLIGENCE. 
* TI DISCLAIMS ANY WARRANTY OF TITLE, QUIET ENJOYMENT, QUIET 
* POSSESSION, AND NON-INFRINGEMENT OF ANY THIRD PARTY 
* INTELLECTUAL PROPERTY RIGHTS WITH REGARD TO THE PROGRAM OR 
* YOUR USE OF THE PROGRAM.
*
* IN NO EVENT SHALL TI BE LIABLE FOR ANY SPECIAL, INCIDENTAL, 
* CONSEQUENTIAL OR INDIRECT DAMAGES, HOWEVER CAUSED, ON ANY 
* THEORY OF LIABILITY AND WHETHER OR NOT TI HAS BEEN ADVISED 
* OF THE POSSIBILITY OF SUCH DAMAGES, ARISING IN ANY WAY OUT 
* OF THIS AGREEMENT, THE PROGRAM, OR YOUR USE OF THE PROGRAM. 
* EXCLUDED DAMAGES INCLUDE, BUT ARE NOT LIMITED TO, COST OF 
* REMOVAL OR REINSTALLATION, COMPUTER TIME, LABOR COSTS, LOSS 
* OF GOODWILL, LOSS OF PROFITS, LOSS OF SAVINGS, OR LOSS OF 
* USE OR INTERRUPTION OF BUSINESS. IN NO EVENT WILL TI'S 
* AGGREGATE LIABILITY UNDER THIS AGREEMENT OR ARISING OUT OF 
* YOUR USE OF THE PROGRAM EXCEED FIVE HUNDRED DOLLARS 
* (U.S.$500).
*
* Unless otherwise stated, the Program written and copyrighted 
* by Texas Instruments is distributed as "freeware".  You may, 
* only under TI's copyright in the Program, use and modify the 
* Program without any charge or restriction.  You may 
* distribute to third parties, provided that you transfer a 
* copy of this license to the third party and the third party 
* agrees to these terms by its first use of the Program. You 
* must reproduce the copyright notice and any other legend of 
* ownership on each copy or partial copy, of the Program.
*
* You acknowledge and agree that the Program contains 
* copyrighted material, trade secrets and other TI proprietary 
* information and is protected by copyright laws, 
* international copyright treaties, and trade secret laws, as 
* well as other intellectual property laws.  To protect TI's 
* rights in the Program, you agree not to decompile, reverse 
* engineer, disassemble or otherwise translate any object code 
* versions of the Program to a human-readable form.  You agree 
* that in no event will you alter, remove or destroy any 
* copyright notice included in the Program.  TI reserves all 
* rights not specifically granted under this license. Except 
* as specifically provided herein, nothing in this agreement 
* shall be construed as conferring by implication, estoppel, 
* or otherwise, upon you, any license or other right under any 
* TI patents, copyrights or trade secrets.
*
* You may not use the Program in non-TI devices.
* ********************************************************* */


#ifndef _MMCLIB_C
#define _MMCLIB_C
//
//---------------------------------------------------------------
#include "mmc.h"
#include "hal_SPI.h"
#include "hal_hardware_board.h"

//#define withDMA

// Function Prototypes
char mmcGetResponse(void);
char mmcGetXXResponse(const char resp);
char mmcCheckBusy(void);
char mmcGoIdle();

// Initialize MMC card
char mmcInit(void)
{
    //raise CS and MOSI for 80 clock cycles
    //SendByte(0xff) 10 times with CS high
    //RAISE CS
    int i;

    // Port x Function           Dir       On/Off
    //         mmcCS         Out       0 - Active 1 - none Active
    //         Dout          Out       0 - off    1 - On -> init in SPI_Init
    //         Din           Inp       0 - off    1 - On -> init in SPI_Init
    //         Clk           Out       -                 -> init in SPI_Init
    //         mmcCD         In        0 - card inserted

//    // Init Port for MMC (default high)
//    MMC_PxOUT |= MMC_SIMO + MMC_SOMI + MMC_UCLK;
//    MMC_PxDIR |= MMC_SIMO + MMC_UCLK;
//    MMC_PxDIR &= ~MMC_SOMI;
//
//    // Chip Select
//    MMC_CS_PxOUT |= MMC_CS;
//    MMC_CS_PxDIR |= MMC_CS;
//
//      // Card Detect
//      MMC_CD_PxDIR &= ~MMC_CD;

    // Enable secondary function
#if SPI_SER_INTF == SER_INTF_BITBANG
    MMC_PxSEL |= MMC_SIMO + MMC_SOMI + MMC_UCLK;
#endif

    // Ping the card to check if it exists

    // Set the clock speed to something slow
    halSPISetSpeedLow();
    
    // Initialization sequence on powerup
    MMC_CS_HIGH();
    for(i=0;i<=9;i++)
        spiSendByte(DUMMY_CHAR);

    __delay_cycles(100);

    return (mmcGoIdle());
}


// Set MMC in Idle mode
char mmcGoIdle()
{
    char response=0x01;
    MMC_CS_LOW();

    // Send Command 0 to put MMC in SPI mode
    mmcSendCmd(MMC_GO_IDLE_STATE,0,0x95);

    // Now wait until idle state bit is cleared
    if(mmcGetResponse()!=0x01)
        return MMC_INIT_ERROR;

    while(response==0x01)
    {
        MMC_CS_HIGH();
        spiSendByte(DUMMY_CHAR);
        MMC_CS_LOW();
        mmcSendCmd(MMC_SEND_OP_COND,0x00,0xff);
        response=mmcGetResponse();
    }

    MMC_CS_HIGH();

    // Card is now initialized, increase the clock speed
    halSPISetSpeedHigh();

    spiSendByte(DUMMY_CHAR);
    spiSendByte(DUMMY_CHAR);

    return (MMC_SUCCESS);
}

// MMC Get Response
char mmcGetResponse(void)
{
    //Response comes 1-8bytes after command
    //the first bit will be a 0
    //followed by an error code
    //data will be 0xff until response
    int i=0;

    volatile unsigned char response;

    while(i<=64)
    {
        response=spiSendByte(DUMMY_CHAR);
        if(response==0x00)break;
        if(response==0x01)break;
        i++;
    }
    return response;
}

char mmcGetXXResponse(const char resp)
{
    //Response comes 1-8bytes after command
    //the first bit will be a 0
    //followed by an error code
    //data will be 0xff until response
    int i=0;

    char response;

    while(i<=1000)
    {
        response=spiSendByte(DUMMY_CHAR);
        if(response==resp)break;
        i++;
    }
    return response;
}

// Check if MMC card is still busy
char mmcCheckBusy(void)
{
    //Response comes 1-8bytes after command
    //the first bit will be a 0
    //followed by an error code
    //data will be 0xff until response
    int i=0;

    char response;
    char rvalue;
    while(i<=64)
    {
        response=spiSendByte(DUMMY_CHAR);
        response &= 0x1f;
        switch(response)
        {
            case 0x05: rvalue=MMC_SUCCESS;break;
            case 0x0b: return(MMC_CRC_ERROR);
            case 0x0d: return(MMC_WRITE_ERROR);
            default:
                rvalue = MMC_OTHER_ERROR;
            break;
        }
        if(rvalue==MMC_SUCCESS)break;
        i++;
    }
    i=0;
    do
    {
        response=spiSendByte(DUMMY_CHAR);
        i++;
    }while(response==0);
    return response;
}
// The card will respond with a standard response token followed by a data
// block suffixed with a 16 bit CRC.

// read a size Byte big block beginning at the address.
char mmcReadBlock(const unsigned long address, const unsigned long count, unsigned char *pBuffer)
{
    char rvalue = MMC_RESPONSE_ERROR;

    // Set the block length to read
    if (mmcSetBlockLength (count) == MMC_SUCCESS)   // block length could be set
    {
        // CS = LOW (on)
        MMC_CS_LOW ();
        // send read command MMC_READ_SINGLE_BLOCK=CMD17
        mmcSendCmd (MMC_READ_SINGLE_BLOCK,address, 0xFF);
        // Send 8 Clock pulses of delay, check if the MMC acknowledged the read block command
        // it will do this by sending an affirmative response
        // in the R1 format (0x00 is no errors)
        if (mmcGetResponse() == 0x00)
        {
            // now look for the data token to signify the start of
            // the data
            if (mmcGetXXResponse(MMC_START_DATA_BLOCK_TOKEN) == MMC_START_DATA_BLOCK_TOKEN)
            {
                // clock the actual data transfer and receive the bytes; spi_read automatically finds the Data Block
                spiReadFrame(pBuffer, count);
                // get CRC bytes (not really needed by us, but required by MMC)
                spiSendByte(DUMMY_CHAR);
                spiSendByte(DUMMY_CHAR);
                rvalue = MMC_SUCCESS;
            }
            else
            {
                // the data token was never received
                rvalue = MMC_DATA_TOKEN_ERROR;      // 3
            }
        }
        else
        {
            // the MMC never acknowledge the read command
            rvalue = MMC_RESPONSE_ERROR;          // 2
        }
    }
    else
    {
        rvalue = MMC_BLOCK_SET_ERROR;           // 1
    }
    MMC_CS_HIGH ();
    spiSendByte(DUMMY_CHAR);
    return rvalue;
}

char mmcWriteBlock (const unsigned long address, const unsigned long count, unsigned char *pBuffer)
{
    char rvalue = MMC_RESPONSE_ERROR;         // MMC_SUCCESS;
    //  char c = 0x00;

    // Set the block length to read
    if (mmcSetBlockLength (count) == MMC_SUCCESS)   // block length could be set
    {
        // CS = LOW (on)
        MMC_CS_LOW ();
        // send write command
        mmcSendCmd (MMC_WRITE_BLOCK,address, 0xFF);

        // check if the MMC acknowledged the write block command
        // it will do this by sending an affirmative response
        // in the R1 format (0x00 is no errors)
        if (mmcGetXXResponse(MMC_R1_RESPONSE) == MMC_R1_RESPONSE)
        {
            spiSendByte(DUMMY_CHAR);
            // send the data token to signify the start of the data
            spiSendByte(0xfe);
            // clock the actual data transfer and transmitt the bytes

            spiSendFrame(pBuffer, count);

            // put CRC bytes (not really needed by us, but required by MMC)
            spiSendByte(DUMMY_CHAR);
            spiSendByte(DUMMY_CHAR);
            // read the data response xxx0<status>1 : status 010: Data accected, status 101: Data
            //   rejected due to a crc error, status 110: Data rejected due to a Write error.
            mmcCheckBusy();
            rvalue = MMC_SUCCESS;
        }
        else
        {
            // the MMC never acknowledge the write command
            rvalue = MMC_RESPONSE_ERROR;   // 2
        }
    }
    else
    {
        rvalue = MMC_BLOCK_SET_ERROR;   // 1
    }
    // give the MMC the required clocks to finish up what ever it needs to do
    //  for (i = 0; i < 9; ++i)
    //    spiSendByte(0xff);

    MMC_CS_HIGH ();
    // Send 8 Clock pulses of delay.
    spiSendByte(DUMMY_CHAR);
    return rvalue;
}


// Send command to MMC
void mmcSendCmd (const char cmd, unsigned long data, const char crc)
{
    unsigned char frame[6];
    char temp;
    int i;
    frame[0]=(cmd|0x40);
    for(i=3;i>=0;i--){
        temp=(char)(data>>(8*i));
        frame[4-i]=(temp);
    }
    frame[5]=(crc);
    spiSendFrame(frame,6);
}


//--------------- set blocklength 2^n ------------------------------------------------------
char mmcSetBlockLength (const unsigned long blocklength)
{
    // CS = LOW (on)
    MMC_CS_LOW ();
    // Set the block length to read
    mmcSendCmd(MMC_SET_BLOCKLEN, blocklength, 0xFF);

    // get response from MMC - make sure that its 0x00 (R1 ok response format)
    if(mmcGetResponse()!=0x00)
    { mmcInit();
        mmcSendCmd(MMC_SET_BLOCKLEN, blocklength, 0xFF);
        mmcGetResponse();
    }

    MMC_CS_HIGH ();

    // Send 8 Clock pulses of delay.
    spiSendByte(DUMMY_CHAR);

    return MMC_SUCCESS;
}


// Reading the contents of the CSD and CID registers in SPI mode is a simple read-block transaction.
char mmcReadRegister (const char cmd_register, const unsigned char length, unsigned char *pBuffer)
{
    char uc = 0;
    char rvalue = MMC_TIMEOUT_ERROR;

    if (mmcSetBlockLength (length) == MMC_SUCCESS)
    {
        MMC_CS_LOW ();
        // CRC not used: 0xff as last byte
        mmcSendCmd(cmd_register, 0x000000, 0xff);

        // wait for response
        // in the R1 format (0x00 is no errors)
        if (mmcGetResponse() == 0x00)
        {
            if (mmcGetXXResponse(0xfe)== 0xfe)
                for (uc = 0; uc < length; uc++)
                    pBuffer[uc] = spiSendByte(DUMMY_CHAR);  //mmc_buffer[uc] = spiSendByte(0xff);
            // get CRC bytes (not really needed by us, but required by MMC)
            spiSendByte(DUMMY_CHAR);
            spiSendByte(DUMMY_CHAR);
            rvalue = MMC_SUCCESS;
        }
        else
            rvalue = MMC_RESPONSE_ERROR;
        // CS = HIGH (off)
        MMC_CS_HIGH ();

        // Send 8 Clock pulses of delay.
        spiSendByte(DUMMY_CHAR);
    }
    MMC_CS_HIGH ();
    return rvalue;
} 


#include "math.h"
unsigned long mmcReadCardSize(void)
{
    // Read contents of Card Specific Data (CSD)

    unsigned long MMC_CardSize;
    unsigned short i,        // index
                    j,      // index
                    b,      // temporary variable
                    response,   // MMC response to command
                    mmc_C_SIZE;

    unsigned char mmc_READ_BL_LEN,  // Read block length
                    mmc_C_SIZE_MULT;

    MMC_CS_LOW ();

    spiSendByte(MMC_READ_CSD);   // CMD 9
    for(i=4; i>0; i--)      // Send four dummy bytes
        spiSendByte(0);
    spiSendByte(DUMMY_CHAR);   // Send CRC byte

    response = mmcGetResponse();

    // data transmission always starts with 0xFE
    b = spiSendByte(DUMMY_CHAR);

    if( !response )
    {
        while (b != 0xFE) b = spiSendByte(DUMMY_CHAR);
        // bits 127:87
        for(j=5; j>0; j--)          // Host must keep the clock running for at
            b = spiSendByte(DUMMY_CHAR);

        // 4 bits of READ_BL_LEN
        // bits 84:80
        b =spiSendByte(DUMMY_CHAR);  // lower 4 bits of CCC and
        mmc_READ_BL_LEN = b & 0x0F;
        b = spiSendByte(DUMMY_CHAR);
        // bits 73:62  C_Size
        // xxCC CCCC CCCC CC
        mmc_C_SIZE = (b & 0x03) << 10;
        b = spiSendByte(DUMMY_CHAR);
        mmc_C_SIZE += b << 2;
        b = spiSendByte(DUMMY_CHAR);
        mmc_C_SIZE += b >> 6;
        // bits 55:53
        b = spiSendByte(DUMMY_CHAR);
        // bits 49:47
        mmc_C_SIZE_MULT = (b & 0x03) << 1;
        b = spiSendByte(DUMMY_CHAR);
        mmc_C_SIZE_MULT += b >> 7;
        // bits 41:37
        b = spiSendByte(DUMMY_CHAR);
        b = spiSendByte(DUMMY_CHAR);
        b = spiSendByte(DUMMY_CHAR);
        b = spiSendByte(DUMMY_CHAR);
        b = spiSendByte(DUMMY_CHAR);
    }

    for(j=4; j>0; j--)          // Host must keep the clock running for at
        b = spiSendByte(DUMMY_CHAR);  // least Ncr (max = 4 bytes) cycles after
                                                             // the card response is received
    b = spiSendByte(DUMMY_CHAR);
    MMC_CS_LOW ();

    MMC_CardSize = (mmc_C_SIZE + 1);
    // power function with base 2 is better with a loop
    // i = (pow(2,mmc_C_SIZE_MULT+2)+0.5);
    for(i = 2,j=mmc_C_SIZE_MULT+2; j>1; j--)
        i <<= 1;
    MMC_CardSize *= i;
    // power function with base 2 is better with a loop
    //i = (pow(2,mmc_READ_BL_LEN)+0.5);
    for(i = 2,j=mmc_READ_BL_LEN; j>1; j--)
        i <<= 1;
    MMC_CardSize *= i;

    return (MMC_CardSize);

}

char mmcPing(void) {
        if (!(MMC_CD_PxIN & MMC_CD))
                return (MMC_SUCCESS);
        else
                return (MMC_INIT_ERROR);
}

#ifdef withDMA
#ifdef __IAR_SYSTEMS_ICC__
#pragma vector = DACDMA_VECTOR
__interrupt void DMA_isr(void)
#endif

#ifdef __TI_COMPILER_VERSION__
__interrupt void DMA_isr(void);
DMA_ISR(DMA_isr)
__interrupt void DMA_isr(void)
#endif
{
    DMA0CTL &= ~(DMAIFG);
    LPM3_EXIT;
}
#endif


//---------------------------------------------------------------------
#endif /* _MMCLIB_C */