source: umon/main/common/sd.c @ 98883c2

/**************************************************************************
 *
 * Copyright (c) 2013 Alcatel-Lucent
 * 
 * Alcatel Lucent licenses this file to You under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License.  A copy of the License is contained the
 * file LICENSE at the top level of this repository.
 * You may also obtain a copy of the License at:
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************
 *
 * sd.c:
 *
 * This code is the user interface portion of the sd (compact flash)
 * command for uMon.
 * This command is intended to be the "interface" portion of some
 * other command (for example "fatfs").  Refer to the discussion in
 * fatfs.c for more details.
 *
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */

#include "config.h"
#if INCLUDE_SD
#include "stddefs.h"
#include "genlib.h"
#include "cli.h"
#include "timer.h"
#include "tfs.h"
#include "tfsprivate.h"
#include "sd.h"

struct sdinfo sdInfoTbl[SD_DEVTOT];
char sdVerbose;
static int sdInum;              /* Interface number: to support multiple SD interfaces.
                                                 * Typically this will always be zero.
                                                 */


static struct sdcmd sdCardCmdTbl[] = {
        { GO_IDLE_STATE,                        R1_RLEN,        R1      },
        { SEND_OP_COND,                         R1_RLEN,        R1      },
        { SWITCH_FUNC,                          R1_RLEN,        R1      },
        { SEND_IF_COND,                         R7_RLEN,        R7      },
        { SEND_CSD,                                     R1_RLEN,        R1      },
        { SEND_CID,                                     R1_RLEN,        R1      },
        { STOP_TRANSMISSION,            R1_RLEN,        R1B     },
        { SEND_STATUS,                          R2_RLEN,        R2      },
        { SET_BLOCKLEN,                         R1_RLEN,        R1      },
        { READ_SINGLE_BLK,                      R1_RLEN,        R1      },
        { READ_MULTIPLE_BLK,            R1_RLEN,        R1      },
        { WRITE_BLK,                            R1_RLEN,        R1B     },
        { WRITE_MULTIPLE_BLK,           R1_RLEN,        R1B     },
        { PROGRAM_CSD,                          R1_RLEN,        R1      },
        { SET_WRITE_PROT,                       R1_RLEN,        R1B     },
        { CLR_WRITE_PROT,                       R1_RLEN,        R1B     },
        { SEND_WRITE_PROT,                      R1_RLEN,        R1      },
        { ERASE_WR_BLK_START_ADDR,      R1_RLEN,        R1      },
        { ERASE_WR_BLK_END_ADDR,        R1_RLEN,        R1      },
        { ERASE,                                        R1_RLEN,        R1B     },
        { LOCK_UNLOCK,                          R1_RLEN,        R1      },
        { APP_CMD,                                      R1_RLEN,        R1      },
        { GEN_CMD,                                      R1_RLEN,        R1      },
        { READ_OCR,                                     R3_RLEN,        R3      },
        { CRC_ON_OFF,                           R1_RLEN,        R1      },
        { SD_SEND_OP_COND,                      R1_RLEN,        R1      },
        { -1,-1,-1      }
};

char *SdHelp[] = {
        "Secure Digital Flash Interface",
        "[options] {operation} [args]...",
#if INCLUDE_VERBOSEHELP
        "",
        "Options:",
        " -i ##  interface # (default is 0)",
        " -v     additive verbosity",
        "",
        "Operations:",
        " init [prefix]",
        " cmd {cmdnum} [arg]",
        " read {dest} {blk} {blktot}",
        " write {src} {blk} {blktot}",
#endif
        0
};

int
SdCmd(int argc, char *argv[])
{
        char *cmd, *buf, *prefix, varname[16];
        int opt, verbose, sdret, blknum, blkcnt;

        verbose = 0;
        while ((opt=getopt(argc,argv,"i:v")) != -1) {
                switch(opt) {
                        case 'i':
                                sdInum = atoi(optarg);  /* sticky */
                                break;
                        case 'v':
                                verbose++;
                                break;
                        default:
                                return(CMD_PARAM_ERROR);
                }
        }

        if (argc < optind + 1)
                return(CMD_PARAM_ERROR);

        cmd = argv[optind];

        if (sdInum >= SD_DEVTOT) {
                printf("Configured to support %d SD interface%s\n",
                        SD_DEVTOT,SD_DEVTOT == 1 ? "" : "s");
                return(CMD_FAILURE);
        }

        if (sdInstalled(sdInum) == 0) {
                printf("SDCard not installed\n");
                return(CMD_FAILURE);
        }

        if (strcmp(cmd,"init") == 0) {
                sdret = sdInit(sdInum, verbose);
                if (sdret < 0) {
                        printf("sdInit returned %d\n",sdret);
                        return(CMD_FAILURE);
                }

                // If prefix is specified, then load shell variables:
                if (argc == optind+2) {
                        prefix = argv[optind+1];
                        if (strlen(prefix)+4 > sizeof(varname)) {
                                printf("prefix %s too long\n",prefix);
                                return(CMD_PARAM_ERROR);
                        }

                        sprintf(varname,"%s_RD",prefix);
                        shell_sprintf(varname,"0x%lx",(long)sdRead);

                        sprintf(varname,"%s_WR",prefix);
                        shell_sprintf(varname,"0x%lx",(long)sdWrite);
                }

                shell_sprintf("SD_BLKSIZE","0x%lx",SD_BLKSIZE);
        }
        else if (strcmp(cmd,"cmd") == 0) {
                ulong cmdarg;
                uchar resp[8];
                int rtot, i, cmdnum;

                cmdarg = 0;
                memset((char *)resp,0xff,sizeof(resp));

                if ((argc != (optind+2)) && (argc != (optind+3)))
                        return(CMD_PARAM_ERROR);

                cmdnum = (uchar)strtoul(argv[optind+1],0,0);
                if (argc == optind+3)
                        cmdarg = strtoul(argv[optind+2],0,0);
                sdret = sdCardCmd(sdInum, cmdnum , cmdarg ,resp);
                if (sdret < 0) {
                        printf("sdCardCmd returned %d\n",sdret);
                        return(CMD_FAILURE);
                }

                rtot = sdCmdrlen(cmdnum);

                printf("CMD_%d resp: ",cmdnum);
                for(i=0;i<rtot;i++)
                        printf("%02x ",resp[i]);
                printf("\n");
        }
        else if (strcmp(cmd,"read") == 0) {
                if (argc != optind+4)
                        return(CMD_PARAM_ERROR);

                buf = (char *)strtoul(argv[optind+1],0,0);
                blknum = strtoul(argv[optind+2],0,0);
                blkcnt = strtoul(argv[optind+3],0,0);

                sdret = sdRead(sdInum,buf,blknum,blkcnt);
                if (sdret < 0) {
                        printf("sdRead returned %d\n",sdret);
                        return(CMD_FAILURE);
                }
        }
        else if (strcmp(cmd,"write") == 0) {
                if (argc != optind+4)
                        return(CMD_PARAM_ERROR);
                buf = (char *)strtoul(argv[optind+1],0,0);
                blknum = strtoul(argv[optind+2],0,0);
                blkcnt = strtoul(argv[optind+3],0,0);

                sdret = sdWrite(sdInum,buf,blknum,blkcnt);
                if (sdret < 0) {
                        printf("sdWrite returned %d\n",sdret);
                        return(CMD_FAILURE);
                }
        }
        else {
                printf("sd op <%s> not found\n",cmd);
                return(CMD_FAILURE);
        }

        return(CMD_SUCCESS);
}

/* sdCmdrlen():
 * Given the command number, return the response length.
 */
int
sdCmdrlen(int cmd)
{
        struct sdcmd *sdp = sdCardCmdTbl;

        while(sdp->cmd != -1) {
                if (cmd == sdp->cmd)
                        return(sdp->rlen);
                sdp++;
        }
        return(-1);
}
        
/* sdCmdrtype():
 * Given the command number, return the response type.
 */
int
sdCmdrtype(int cmd)
{
        struct sdcmd *sdp = sdCardCmdTbl;

        while(sdp->cmd != -1) {
                if (cmd == sdp->cmd)
                        return(sdp->rtype);
                sdp++;
        }
        return(-1);
}

static char *months[] = {
        "???", "Jan", "Feb", "Mar", "Apr", "May", "Jun",
        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
};

void
sdShowCID(uchar *cid)
{
        int             year, mon;

        printf("  Manufacturer ID:    x%02x\n", cid[0]);
        printf("  OEM/Application ID: x%02x%02x\n", cid[1],cid[2]);
        printf("  Product name:       %c%c%c%c%c\n",
                cid[3],cid[4],cid[5],cid[6],cid[7]);
        printf("  Product rev:        x%02x\n", cid[8]);
        printf("  Product serialno:   x%02x%02x%02x%02x\n",
                cid[9],cid[10],cid[11],cid[12]);

        year = (((cid[13] & 0x0f) << 4) | ((cid[14] & 0xf0) >> 4));
        mon = (cid[14] & 0x0f);
        if ((mon < 1) || (mon > 12))
                mon = 0;
        printf("  Manufactured:       %s/%d\n",months[mon],2000+year);
}

void
sdShowCSD(uchar *csd)
{
        uchar csdver;
        long long capacity;
        int mult, csize, csm, rbl;
        int blocknr, blocklen, i;

        printf("  CSD Response: ");
        for(i=0;i<16;i++)
                printf("%02x ",csd[i]);
        printf("\n");

        mult = csize = csm = rbl = 0;

        if ((csd[0] & 0xc0) == 0)
                csdver = 1;
        else if ((csd[0] & 0xc0) == 0x40)
                csdver = 2;
        else {
                printf("Invalid CSD structure type\n");
                return;
        }

        printf("  CSD version %d.0\n",csdver);
        if (csdver == 1) {
                rbl = csd[5] & 0x0f;
                csize = ((csd[8] & 0xC0) >> 6);
                csize |= (csd[7] << 2);
                csize |= ((csd[6] & 0x03) << 10);
                csm = (csd[9] & 0x03);
                csm <<= 1;
                csm |= ((csd[10] & 0x80) >> 7);

                mult = (1 << (csm+2));
                blocknr = (csize+1)*mult;
                blocklen = (1 << rbl);
                capacity = (long long)((long long)blocknr * (long long)blocklen);
                //printf("  (csm=%d, csize=%d, rbl=%d, mult=%d, blknr=%d, blkln=%d)\n",
                //      csm, csize, rbl, mult, blocknr, blocklen);
        }
        else if (csdver == 2) {
                rbl = csd[5] & 0x0f;
                csize = (csd[7] & 0x3f) << 16;
                csize |= (csd[8] << 8);
                csize |= csd[9];
                capacity = (long long)((long long)(csize + 1) * 512LL * 1024LL);
        }
        else {
                printf("  Unrecognized CSD version.\n");
                return;
        }
        printf("  Card capacity: %lld bytes\n",capacity);
}

/* sdGenericStartup():
 * Called by the interface-specific sdInit() code to do the generic
 * portion of the SD-Card initialization.
 *
 * Refer to the flowchart shown in figure 7.2 of the Simplified
 * Physical Layer Specification for an overview of the initialization.
 * 
 * The card wakes up in SD bus mode, so the first thing we need to d
 * here (after the very basic initialization of the SPI pin config) is
 * to get the card into SPI mode.
 * By default, the card assumes CRC checking is disabled.  The field used
 * to hold the CRC is still part of the protocol, but it is ignored.  If
 * needed, the master can turn it on with CMD59.
 */
int
sdGenericStartup(int interface)
{
        ulong   hcs;
        uchar   resp[16], cid[16], csd[16];
        int             retry, rc, version;
    struct elapsed_tmr tmr;
        int check_pattern_retry = 2;

        sdInfoTbl[interface].initialized = 0;

        rc = 0;
        check_pattern_retry = 2;

        // Start with at least 74 clocks to powerup the card...
        sdPowerup(10);

        // Put card in SPI mode:

        // This command always seems to fail on the first try after a
        // powerup, so give it a few attempts...
        for(retry=0;retry<3;retry++) {
                if ((rc = sdCardCmd(interface,GO_IDLE_STATE,0,resp)) != -1)
                        break;
        }

        if (retry == 3) {
                printf("\nSD GO_IDLE_STATE failed, card installed?\n");
                return(-1);
        }

        // According to Physical Layer Simplified Spec (PLSS), it is mandatory
        // for the host compliant to Version 2.00 to send CMD8 (SEND_IF_COND).
        // If CMD8 is not recognized (illegal command), then we can assume that
        // the card is version 1.00.
        // The argument sent with the command is defined in section 4.3.13
        // of the PLSS.  
        // The spec says that if the check-patter test fails, to retry...
        do {
                if ((rc = sdCardCmd(interface,SEND_IF_COND,SEND_IF_COND_ARG,resp)) == -1)
                        return(-1);
                
                if (resp[0] & R1_ILLEGAL_CMD) {
                        version = VERSION_10;
                        hcs = 0;
                        break;  // Check pattern only applies to V2 and later
                }
                else {
                        // The card should echo back the VHS and check pattern...
                        if (resp[3] != VHS27_36) {
                                if (sdVerbose & 2)
                                        printf("SDCARD not 3.3v compliant!\n");
                                return(-1);
                        }
                        if (resp[4] != CHECK_PATTERN) {
                                if (--check_pattern_retry <= 0) {
                                        if (sdVerbose & 2)
                                                printf("SDCARD check-pattern failed.\n");
                                        return(-1);
                                }
                        }       
                        version = VERSION_20;
                        hcs = HCS;
                }
        } while(resp[4] != CHECK_PATTERN);

        // Read OCR to make sure the card will run at 3.3v...
        if ((rc = sdCardCmd(interface,READ_OCR,hcs,resp)) == -1)
                return(-1);

        if ((resp[2] & MSK_OCR_33) != MSK_OCR_33) {
                if (sdVerbose & 2)
                        printf("SDCARD: OCR_33 failed, card isn't 3.3v capable\n");
                return(-1);
        }

        // Wait for card to complete initialization:
    startElapsedTimer(&tmr,1000);
        while(1) {
                if ((rc = sdCardCmd(interface,SD_SEND_OP_COND,HCS,resp)) == -1)
                        return(-1);
                if ((resp[0] & R1_IDLE) == 0)
                        break;
        if(msecElapsed(&tmr)) {
                        printf("SDCARD: gaveup waiting for init to complete.\n");
                        return(-1);
                }
        }

        if (version == VERSION_20) {
                // Get CCS...
                if ((rc = sdCardCmd(interface,READ_OCR,0,resp)) == -1) 
                        return(-1);
        }
        else {
                if ((rc = sdCardCmd(interface,SET_BLOCKLEN,SD_BLKSIZE,resp)) == -1)
                        return(-1);
        }

        if (sdVerbose) {
                printf("SD/SPI Initialized (version %s)\n",
                        version == VERSION_10 ? "1.0" : ">=2.0");
        }

        sdInfoTbl[interface].cardversion = version;

        sdReadCxD(interface,cid,SEND_CID);
        if (sdVerbose)
                sdShowCID(cid);
        sdReadCxD(interface,csd,SEND_CSD);
        if (sdVerbose)
                sdShowCSD(csd);

        if ((csd[0] & 0xc0) == 0x00)
                sdInfoTbl[interface].highcapacity = 0;
        else
                sdInfoTbl[interface].highcapacity = 1;

        sdInfoTbl[interface].initialized = 1;
        return(0);
}

/* Got this crc7 code off the web...
 * The original text claimed "use-as-you-wish"...
 */
#define POLYNOM (0x9)        // polynomical value to XOR when 1 pops out.

static unsigned char
Encode(uchar seed, uchar input, uchar depth)
{
        uchar regval, count, cc;

        regval = seed;
        cc = input;  

        for (count = depth ; count--   ;  cc <<= 1) {
                regval = (regval << 1) + ((cc & 0x80) ? 1 : 0);
                if (regval & 0x80)
                        regval ^= POLYNOM;
        }
        return(regval & 0x7f); // return lower 7 bits of CRC as value to use.
}

uchar
crc7(uchar seed, uchar *buf, int len)
{
        int i;
        uchar crc;

        crc = seed;
        for (i = 0; i < len; i++)
                crc = Encode(crc, buf[i], 8);

        crc = Encode(crc,0,7);
        crc = (crc << 1) + 1;
        return(crc);
}

#ifdef INCLUDE_SD_DUMMY_FUNCS
/* This code is included here just for simulating the SD
 * interface (temporarily if a real one isn't ready.  In a real system,
 * the INCLUDE_SD_DUMMY_FUNCS definition would be off.
 */

int
sdInit(int interface, int verbose)
{
        if (interface != 0)
                return(-1);

        return(0);
}

int
sdRead(int interface, char *buf, int blk, int blkcnt)
{
        char *from;
        int     size;

        if (interface != 0)
                return(-1);

        from = (char *)(blk * SD_BLKSIZE);
        size = blkcnt * SD_BLKSIZE;
        memcpy(buf,from,size);
        return(0);
}

int
sdWrite(int interface, char *buf, int blk, int blkcnt)
{
        char *to;
        int     size;

        if (interface != 0)
                return(-1);

        to = (char *)(blk * SD_BLKSIZE);
        size = blkcnt * SD_BLKSIZE;
        memcpy(to,buf,size);
        return(0);
}

/* sdInstalled():
 * Return 1 if installed, 0 if not installed or -1 if 
 * the hardware can't detect installation.
 */
int
sdInstalled(int interface)
{
        return(-1);
}

#endif

#endif