Subversion Repositories NaviCtrl

#include <stdio.h>

#include <string.h>

#include "91x_lib.h"

#include "uart.h"

#include "sdc.h"

#include "ssc.h"

#include "timer.h"

#include "crc16.h"

//                                              extern void SSC_Disable(void);

//________________________________________________________________________________________________________________________________________

#define CMD_GO_IDLE_STATE               0x00    /* CMD00: response R1 */

#define CMD_SEND_OP_COND                0x01    /* CMD01: response R1 */

#define CMD_SEND_IF_COND                0x08    /* CMD08: response R7 */

#define CMD_SEND_CSD                    0x09    /* CMD09: response R1 */

#define CMD_SEND_CID                    0x0A    /* CMD10: response R1 */

#define CMD_SEND_STATUS                 0x0D    /* CMD13: response R2 */

#define CMD_SET_BLOCKLEN                0x10    /* CMD16: arg0[31:0]: block length, response R1*/

#define CMD_READ_SINGLE_BLOCK   0x11    /* CMD17: arg0[31:0]: data address, response R1 */

#define CMD_WRITE_SINGLE_BLOCK  0x18    /* CMD24: arg0[31:0]: data address, response R1 */

#define CMD_APP_CMD                             0x37    /* CMD55: response R1 */

#define CMD_READ_OCR                    0x3A    /* CMD58: response R3 */

#define CMD_CRC_ON_OFF                  0x3B    /* CMD59: arg0[31:1]: stuff bits, arg0[0:0]: crc option, response R1 */                                                                         

#define ACMD_SEND_OP_COND               0x29    /* ACMD41: arg0[31]: stuff bits, arg0[30]: HCS, arg0[29:0] stuff bits*, response R1 */

#define R1_NO_ERR                               0x00

#define R1_IDLE_STATE                   0x01

#define R1_ERASE_RESET                  0x02

#define R1_ILLEGAL_CMD                  0x04

#define R1_COM_CRC_ERR                  0x08

#define R1_ERASE_SEQUENCE_ERR   0x10

#define R1_ADDRESS_ERR                  0x20

#define R1_PARAMETER_ERR                0x40

#define R1_BAD_RESPONSE                 0x80

#define R2_NO_ERR                               0x00

#define R2_CARD_LOCKED                  0x01

#define R2_ERASE_WRITE_PROT_ERR 0x02

#define R2_UNKOWN_ERR                   0x04

#define R2_CARD_CTRL_ERR                0x08

#define R2_CARD_ECC_ERR             0x10

#define R2_WRITE_PROT_ERR               0x20

#define R2_ERASE_PARAM_ERR              0x40

#define R2_OUT_OF_RANGE_ERR             0x80

#define DATA_START_TOKEN                0xFE

#define DATA_RESPONSE_MASK              0x1F 

#define DATA_RESPONSE_OK                0x05

#define DATA_RESPONSE_CRC_ERR   0x0B

#define DATA_RESPONSE_WRITE_ERR 0x1D

typedef enum

{

        VER_UNKNOWN,

        VER_1X,

        VER_20

} SDVersion_t;

typedef struct

{

  u8 Valid;

  SDVersion_t Version;  // HW-Version 

  u32 Capacity;                 // Memory capacity  in bytes

  u8 CID[16];                   // CID register

  u8 CSD[16];                   // CSD register

//________________________________________________________________________________________________________________________________________

        u8 i, a;

        u8 crc, Data;

        crc = 0; // init CRC buffer

        for (a = 0; a < len ;a++) // for every byte in the msg

        {

                for (i=0;i<8;i++) // for every bit in the byte

                {

                        crc <<= 1; // shift crc

                        Data <<= 1;     // shift data  for next bit

                }

        }

        crc = (crc<<1)|1; // set terminating bit to 1

        return(crc);

u8 SDC_WaitForBusy()

        u8 rsp = 0;

        SSC_ClearRxFifo();

        SSC_Enable();                           // enable chipselect.

        do     

        {

                rsp = SSC_GetChar();

                if(timeout++>500) break;

        }while(rsp != 0xFF);            // wait while card is busy (data out low)

        return(rsp);

}

//________________________________________________________________________________________________________________________________________

// Function:    SDC_SendCMDR1(u8 CmdNo, u32 arg);

// Description: This function send a command frame to the SD-Card in spi-mode. 

//                              

//

// Returnvalue: The function returns the first response byte like for R1 commands

u8 SDC_SendCMDR1(u8 CmdNo, u32 arg)

{

        u16 Timeout = 0;

        u16 a;

        u8 cmd[6];

        SSC_ClearRxFifo();      // clear the rx fifo

        SSC_Enable();           // enable chipselect.

        SDC_WaitForBusy();

        SSC_ClearRxFifo();      // clear the rx fifo

        SSC_GetChar();      // dummy to sync

        /* Send cmd10 (SEND_CID) */;

        cmd[1] = (arg & 0xFF000000)>>24;

        for (a = 0;a < 6; a++) // send the command sequence to the sdcard (6 bytes)

        do                                     

        {

                r1 = SSC_GetChar();       // get byte from sd-card

                if (Timeout++ > 500) return(r1);

        }while(r1 == 0xFF); // wait for the response byte from sd-card.

        return(r1);

}

//________________________________________________________________________________________________________________________________________

// Function:    SDC_SendACMDR1(u8 CmdNo, u32 arg);

// 

// Description: This function send a application command frame to the SD-Card in spi-mode. 

//                              

//

// Returnvalue: The function returns the first response byte like for R1 commands

// Returnvalue: SD_Result_t

SD_Result_t SDC_GetData(u8 CmdNo, u32 addr, u8 *Buffer, u32 len)

        u16 timeout;

        if (rsp != R1_NO_ERR)

                result = SD_ERROR_BAD_RESPONSE;

                goto end;

        }

        SSC_ClearRxFifo();

        do

        {

                if((rsp & 0xF0) == 0x00) // data error token 

                {

                        result = SD_ERROR_READ_DATA;

                        goto end;

                }

        }while(rsp != DATA_START_TOKEN);

        // data start token received

        for (a = 0; a < len; a++)       // read the block from the SSC

        {

                Buffer[a] = SSC_GetChar();

        }

        // Read two bytes CRC16-Data checksum

//      if(Crc16 != CRC16(Buffer, len)) result = SD_ERROR_CRC_DATA;

/*      else */result = SD_SUCCESS;

        end:

        //SSC_Disable();        // disable sdcard.

        if(result != SD_SUCCESS)

        {

                sprintf(text,"Error %02X reading data from sd card (R1=%02X).\r\n", result, rsp);

                SerialPutString(text);

        }

        return(result);

}

//________________________________________________________________________________________________________________________________________

// Function:    SDC_PrintCID(u8 * pCID);

// 

// Description: This function prints the CIS register in a human readable format. 

//                              

//

// Returnvalue: the function returns nothing

//________________________________________________________________________________________________________________________________________

void SDC_PrintCID(u8 * pCID)

{

        u8 text[50];

        u8 pn[6];

        u16 temp1, temp2;

        sprintf(text, "\r\nManufacturer ID: %i\r\n", pCID[0]);

        SerialPutString(text);

        memcpy(pn, &pCID[1], 2);

        pn[2] = '\0'; // terminate string

        sprintf(text, "Application ID: %s\r\n",pn);

        SerialPutString(text);

        memcpy(pn, &pCID[3], 5);

        pn[5] = '\0'; // terminate string

        sprintf(text, "Product Name: %s\r\n",pn);

        sprintf(text, "Manufac. Date: %i/%i\r\n\r\n",temp1, temp2);

        SerialPutString(text);

}

//________________________________________________________________________________________________________________________________________

// Funtion:     SDC_GetCID(u8 * pCID);

// 

// Description: This function reads the CIS register form the sd card in spi mode. 

//                              

SD_Result_t SDC_GetCID(u8 * pCID)

{

        return SDC_GetData(CMD_SEND_CID, 0UL, pCID, 16);

}

//________________________________________________________________________________________________________________________________________

// Funtion:     SDC_GetCSD(u8 * pCSD);

// 

// Description: This function reads the CSD register form the sd card in spi mode. 

//                              

//

// Returnvalue: the function returns error state

//________________________________________________________________________________________________________________________________________

{

        return SDC_GetData(CMD_SEND_CSD, 0UL, pCSD, 16);

}

//________________________________________________________________________________________________________________________________________

// 

//                              

//

// Returnvalue: the function returns 0 if the initialisation was successfull otherwise the function returns an errorcode.

//________________________________________________________________________________________________________________________________________

SD_Result_t SDC_Init(void)

{

        u8 text[50];

        u8 rsp[6]; // SD-SPI response buffer

        SD_Result_t result = SD_ERROR_UNKNOWN;

        if(SD_SWITCH) // init only if the SD-Switch is indicating a card in the slot

        {

                SerialPutString("\r\n  SSC init...");  

                SSC_Init();

                SerialPutString("ok");

                SerialPutString("\r\n  SDC init...");  

                SDCardInfo.Valid = 0;

                /* The host shall supply power to the card so that the voltage is reached to Vdd_min within 250ms and

                start to supply at least 74 SD clocks to the SD card with keeping cmd line to high. In case of SPI

                mode, CS shall be held to high during 74 clock cycles. */

                SSC_Disable(); // set SD_CS high

                SSC_ClearRxFifo();      // clear the rx fifo

                for (Timeout = 0; Timeout < 15; Timeout++)      // 15*8 = 120 cycles

                {

                        SSC_PutChar(0xFF);

                }

                // switch to idle state

                {

                        {

                                result = SD_ERROR_RESET;

                                goto end;                                                                              

                        }

                }

            // enable crc feature

/*              if(SDC_SendCMDR1(CMD_CRC_ON_OFF, 1UL) != R1_IDLE_STATE)

                {

                                sprintf(text,"Bad cmd59 R1=%02X.\r\n", rsp[0]);

                                SerialPutString(text);

                                result = SD_ERROR_BAD_RESPONSE;

                                goto end;

                }*/

                // check for card hw version                                            

                // 2.7-3.6V Range = 0x01, check pattern 0xAA

                rsp[0] = SDC_SendCMDR1(CMD_SEND_IF_COND, 0x000001AA);

                // answer to cmd58 is an R7 response (R1+ 4Byte IFCond)

                if(rsp[0] & R1_BAD_RESPONSE)

                {

                        sprintf(text,"Bad cmd8 R1=%02X.\r\n", rsp[0]);

                        SerialPutString(text);

                        result = SD_ERROR_BAD_RESPONSE;

                        goto end;

                }

                if(rsp[0] & R1_ILLEGAL_CMD)

                {

                        //Ver1.X SD Memory Card or not a SD Memory Card

                        SDCardInfo.Version = VER_1X;                   

                }

                else

                {

                   // Ver2.00 or later SD Memory Card

                   SDCardInfo.Version = VER_20;

                   for(Timeout = 1; Timeout < 5; Timeout++)

                   {

                                rsp[Timeout] = SSC_GetChar();

                   }

                   //check pattern

                   if(rsp[4]!= 0xAA)

                   {

                                SerialPutString("Bad cmd8 R7 check pattern.\r\n");

                                result = SD_ERROR_BAD_RESPONSE;

                                goto end;

                   }

                   if ( (rsp[3] & 0x0F)!= 0x01 ) // voltage range is not 2.7-3.6V

                   {

                                SerialPutString("Card is incompatible to 3.3V.\r\n");

                                result = SD_ERROR_BAD_VOLTAGE_RANGE;

                                goto end;              

                   }

                }

                rsp[0] = SDC_SendCMDR1(CMD_READ_OCR, 0UL);

                // answer to cmd58 is an R3 response (R1 + 4Byte OCR)

                if(rsp[0] & R1_BAD_RESPONSE)

                {

                        sprintf(text,"Bad cmd58 R1 %02x.\r\n", rsp[0]);

                        SerialPutString(text);

                        result = SD_ERROR_BAD_RESPONSE;

                        goto end;

                }

                {

                        SerialPutString("Not an SD-CARD.\r\n");

                        result = SD_ERROR_NO_SDCARD;

                        goto end;

                }

                // read 4 bytes of OCR register

                {

                        rsp[Timeout] = SSC_GetChar();

                }

                if((rsp[2] & 0x30) != 0x30)

                {

                        // supply voltage is not supported by sd-card

                        SerialPutString("Card is incompatible to 3.3V.\r\n");

                        result = SD_ERROR_BAD_VOLTAGE_RANGE;

                }

                // Initialize the sd-card sending continously ACMD_SEND_OP_COND (only supported by SD cards)

                Timeout =  SetDelay(2000); // set timeout to 2000 ms (large cards tend to longer) 

                do

                {

                        rsp[0] = SDC_SendACMDR1(ACMD_SEND_OP_COND, 0UL);

                        if(rsp[0] & R1_BAD_RESPONSE)

                        {

                                sprintf(text,"Bad Acmd41 R1=%02X.\r\n", rsp[0]);

                                SerialPutString(text);

                                result = SD_ERROR_BAD_RESPONSE;

                                goto end;

                        }

                        if(CheckDelay(Timeout))

                        {

                            SerialPutString("Init timeout.\r\n");

                                result = SD_ERROR_INITIALIZE;

                                goto end;

                        }

                } while(rsp[0] & R1_IDLE_STATE); // loop until idle state

                if(rsp[0] != R1_NO_ERR)

                {

                        SerialPutString("Init error.\r\n");

                        result = SD_ERROR_INITIALIZE;

                        goto end;      

                }

                /* set block size to 512 bytes */

        if(SDC_SendCMDR1(CMD_SET_BLOCKLEN, 512UL) != R1_NO_ERR)

        {

                SerialPutString("Error setting block length to 512.\r\n");

                        result = SD_ERROR_SET_BLOCKLEN;

                        goto end;

        }

                //SSC_Disable(); // set SD_CS high                                               

                // here is the right place to inrease the SPI boud rate to maximum              

                //SSC_Enable(); // set SD_CS high

                // read CID register

                result = SDC_GetCID((u8 *)&SDCardInfo.CID);

                if(result != SD_SUCCESS)

                {

                        SerialPutString("Error reading CID.\r\n");

                        goto end;

                }

                // read CSD register

                result = SDC_GetCSD((u8 *)&SDCardInfo.CSD);

                if(result != SD_SUCCESS)

                {

                        SerialPutString("Error reading CSD.\r\n");

                        goto end;

                }

                SerialPutString("ok\r\n");

                u8 c_size_mult, read_bl_len;

                u32 c_size;

                switch(SDCardInfo.CSD[0]>>6) // check CSD Version

                {

                case 0x00: // if CSD is V1.0 structure (2GB limit)

                        /*

                        memory capacity = BLOCKNR * BLOCK_LEN

                        BLOCKNR = (C_SIZE+1) * MULT

                        MULT = 2^(C_SIZE_MULT+2)

                        BLOCK_LEN = 2^READ_BL_LEN

                        C_SIZE      is 12 bits [73:62] in CSD register

                        C_SIZE_MULT is  3 bits [49:47] in CSD register

                        READ_BL_LEN is  4 bits [83:80] in CSD register

                        */

                        read_bl_len = (SDCardInfo.CSD[5] & 0x0F);               //CSD[05] -> [87:80]

                        c_size = ((u32)(SDCardInfo.CSD[6] & 0x03))<<10; //CSD[06] -> [79:72]

                        c_size |= ((u32)SDCardInfo.CSD[7])<<2;                  //CSD[07] -> [71:64]

                        c_size |= (u32)(SDCardInfo.CSD[8]>>6);                  //CSD[08] -> [63:56]

                        c_size_mult = (SDCardInfo.CSD[9] & 0x03)<<1;    //CSD[09] -> [55:48]

                        c_size_mult |=(SDCardInfo.CSD[10] & 0x80)>>7;   //CSD[10] -> [47:40]

                        SDCardInfo.Capacity = (u32)(c_size+1)*(1L<<(c_size_mult+2))*(1L<<read_bl_len);

                        break;

                case 0x01: // if CSD is V2.0 structure (HC SD-Card > 2GB) 

                        memory capacity = (C_SIZE+1) * 512K byte

                        C_SIZE is 22 bits [69:48] in CSR register

                        */

                        c_size = ((u32)(SDCardInfo.CSD[7] & 0x3F))<<16; //CSD[07] -> [71:64]

                        c_size |= ((u32)SDCardInfo.CSD[8])<<8;                  //CSD[08] -> [63:56]

                        c_size |= (u32)SDCardInfo.CSD[9];                               //CSD[09] -> [55:48];

                        SDCardInfo.Capacity = (c_size + 1)* 512L * 1024L;

                        break;

                default: //unknown CSD Version

                        SDCardInfo.Capacity = 0;

                        break; 

                }

                switch(SDCardInfo.Version)

                {

                        case VER_1X:

                                SerialPutString("  SD-CARD V1.x");

                                break;

                        case VER_20:

                                SerialPutString("  SD-CARD V2.0 or later");

        else

        {

                SSC_Deinit();

// Description: This function deinitialises the SDCard interface. 

//                              

//

// Returnvalue: the function returns 0 if the initialisation was successfull otherwise the function returns an errorcode.

//________________________________________________________________________________________________________________________________________

{

        SerialPutString("SDC deinit...");

// Funtion:     SDC_PutSector(void);

// 

// Description: This function writes one sector of data to the SSC 

//                              

//

// Returnvalue: SD_Result_t

//________________________________________________________________________________________________________________________________________

SD_Result_t SDC_PutSector(u32 addr, const u8 *Buffer)

{

        u8 rsp;

        u16 timeout = 0;

        u16 a, Crc16;

        //u32 Timeout = 0;

        SD_Result_t result = SD_ERROR_UNKNOWN;

        addr = addr << 9; // convert sectoradress to byteadress

        rsp = SDC_SendCMDR1(CMD_WRITE_SINGLE_BLOCK, addr);

        if (rsp != R1_NO_ERR)

        {

                result = SD_ERROR_BAD_RESPONSE;

                goto end;

        }

        SSC_ClearRxFifo();             

        for (a=0;a<20;a++)                                      // at least one byte

        {

                SSC_GetChar();

        }

        Crc16 = CRC16(Buffer, 512);         // calc checksum for data block

        SSC_PutChar(DATA_START_TOKEN);          // send data start of header to the SSC 

        for (a=0;a<512;a++)                                     // transmit one sector (normaly 512bytes) of data to the sdcard.

        {

                SSC_PutChar(Buffer[a]);

        }

        // write two bytes of crc16 to the sdcard

        SSC_PutChar((u8)(Crc16>>8));            // write high byte first

        SSC_PutChar((u8)(0x00FF&Crc16));        // lowbyte last

        SSC_ClearRxFifo();

        do                                                                      // wait for data response token

        {

                rsp = SSC_GetChar();

                if(timeout++>500) break;

        }while((rsp & 0x11) != 0x01 );

        // analyse data response token

        switch(rsp & DATA_RESPONSE_MASK)

        {

                case DATA_RESPONSE_OK:

                        result = SD_SUCCESS;

                        break;

                case DATA_RESPONSE_CRC_ERR:

                        result = SD_ERROR_CRC_DATA;

                        break;

                case DATA_RESPONSE_WRITE_ERR:

                        result = SD_ERROR_WRITE_DATA;

                        break;

                default:

                        result = SD_ERROR_UNKNOWN;

                        goto end;

                        break;

        }

        // wait until the sdcard is busy.

        rsp = SDC_WaitForBusy();

        if(rsp != 0xFF)

        {

                result =  SD_ERROR_TIMEOUT;

                goto end;

        }

        // check card status

        rsp = SDC_SendCMDR1(CMD_SEND_STATUS, 0);

        if(rsp != R1_NO_ERR)

        {

                result =  SD_ERROR_BAD_RESPONSE;

                SSC_GetChar();

                goto end;

        }