source: umon/main/common/sd.c @ a7b6f00

/**************************************************************************
 *
 * 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