path: root/library/ADK2/SD.c

/*
Copyright (c) 2011, Dmitry Grinberg (as published on http://dmitrygr.com)
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following condition is met: 

* Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer. 

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/


#define ADK_INTERNAL
#include "fwk.h"
#include "SD.h"





static const uint8_t pinCD = PORTA(5);
static const uint8_t pinsSD[] = {PORTA(7), PORTA(19), PORTA(20), PORTA(21)};
#define CS	0
#define SCLK	1
#define MOSI	2
#define MISO	3



#define FLAG_TIMEOUT        0x80
#define FLAG_PARAM_ERR        0x40
#define FLAG_ADDR_ERR        0x20
#define FLAG_ERZ_SEQ_ERR    0x10
#define FLAG_CMD_CRC_ERR    0x08
#define FLAG_ILLEGAL_CMD    0x04
#define FLAG_ERZ_RST        0x02
#define FLAG_IN_IDLE_MODE    0x01



char gSdSpiFast = 1;

static void sdClockSpeed(char fast){

    gSdSpiFast = fast;
}

static uint8_t sdSpiByte(uint32_t v){

    uint32_t r = 0;

    #define BIT(m, d)								\
		do{								\
                        gpioSetVal(pinsSD[MOSI], !!(v & (m)));			\
                        gpioSetVal(pinsSD[SCLK], 1);				\
                        d;							\
                        if(gpioGetVal(pinsSD[MISO]))				\
				r |= (m);					\
			gpioSetVal(pinsSD[SCLK], 0);				\
		}while(0)

    #define ASMBIT				\
		"lsls  %1, #1		\n\t"	\
		"ite   cs		\n\t"	\
		"strcs r4, [r2, #0x30]	\n\t"	\
		"strcc r4, [r2, #0x34]	\n\t"	\
		"str   r1, [r2, #0x30]	\n\t"	\
		"ldr   r3, [r2, #0x3C]	\n\t"	\
		"str   r1, [r2, #0x34]	\n\t"	\
		"lsrs  r3, #22		\n\t"	\
		"adcs  %0, %0		\n\t"
	
    if(gSdSpiFast){

        
        asm(
                "mov r4, #0x100000	\n\t"	//mosi
                "mov r1, #0x080000	\n\t"	//sclk
                "ldr r2, =0x400E0E00	\n\t"	//PIOA
                "lsl %1, #24		\n\t"	//cleverness
                ASMBIT
                ASMBIT
                ASMBIT
                ASMBIT
                ASMBIT
                ASMBIT
                ASMBIT
                ASMBIT
            :"=l"(r)
            :"l"(v)
            :"cc", "r4", "r1", "r2", "r3"
        );

    }
    else{

        volatile uint32_t x;
        uint8_t t;

        for(t = 0; t < 8; t++){

            BIT(1 << (7 - t), for(x = 0; x < 0x10; x += 2) x--);
            for(x = 0; x < 0x10; x += 2) x--;
        }
    }

    return r;
}

uint8_t* __attribute__((naked)) sdStreamSec(uint8_t* buf){

#define RDBIT					\
		"str   r1, [r2, #0x30]	\n\t"	\
		"ldr   r3, [r2, #0x3C]	\n\t"	\
		"str   r1, [r2, #0x34]	\n\t"	\
		"lsrs  r3, #22		\n\t"	\
		"adcs  r4, r4		\n\t"

    asm(
            "    push {r4,r5,lr}	\n\t"
            "    ldr r2, =0x400E0E00	\n\t"
            "    mov r1, #0x100000	\n\t"  //mosi
            "    str r1, [r2, #0x30]	\n\t"
            "    mov r1, #0x080000	\n\t"
            "    mov r5, #128		\n\t"
            "loop:			\n\t"
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
                RDBIT
            "    rev  r4, r4		\n\t"
            "    str  r4, [r0], #4	\n\t"
            "    subs r5, #1		\n\t"
            "    bne loop		\n\t"
            "    pop {r4,r5,pc}		\n\t"
    );
}

static void sdChipSelect(char on){

    gpioSetVal(pinsSD[CS], !on);
}

static uint8_t sdCrc7(uint8_t* chr,uint8_t cnt,uint8_t crc){

    uint8_t i, a;
    uint8_t Data;

    for(a = 0; a < cnt; a++){

        Data = chr[a];

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

            crc <<= 1;

            if( (Data & 0x80) ^ (crc & 0x80) ) crc ^= 0x09;

            Data <<= 1;
        }
    }

    return crc & 0x7F;
}

static inline void sdPrvSendCmd(uint8_t cmd, uint32_t param, char crc){

    uint8_t send[6];
    uint8_t L = crc ? 6 : 5;

    send[0] = cmd | 0x40;
    send[1] = param >> 24;
    send[2] = param >> 16;
    send[3] = param >> 8;
    send[4] = param;
    send[5] = crc ? (sdCrc7(send, 5, 0) << 1) | 1 : 0;

    for(cmd = 0; cmd < L; cmd++) sdSpiByte(send[cmd]);
}

static uint8_t sdPrvSimpleCommand(uint8_t cmd, uint32_t param, char crc, char cmdDone){    //do a command, return R1 reply

    uint8_t ret;
    uint8_t i = 0;

    sdChipSelect(1);
    sdPrvSendCmd(cmd, param, crc);

    do{        //our max wait time is 128 byte clocks (1024 clock ticks)

        ret = sdSpiByte(0xFF);

    }while(i++ < 128 && (ret == 0xFF));
    if(cmdDone){
        sdChipSelect(0);
        sdSpiByte(0xFF);
    }

    return ret;
}

static uint8_t sdPrvReadData(uint8_t* data, uint32_t sz, char cmdDone){

    uint8_t ret;
    uint16_t tries = 20000;

    do{
        ret = sdSpiByte(0xFF);
        if((ret & 0xF0) == 0x00) return ret;    //fail
        if(ret == 0xFE) break;
        tries--;
    }while(tries);

    if(!tries) return 0xFF;

    *data = ret;

    ret = 0;

    while(sz--) *data++ = sdSpiByte(0xFF);

    if(cmdDone){
        sdChipSelect(0);
        sdSpiByte(0xFF);
    }

    return ret;
}

static uint8_t sdPrvACMD(uint8_t cmd, uint32_t param, char crc){

    uint8_t ret;

    ret = sdPrvSimpleCommand(55, 0, crc, 1);
    if(ret & FLAG_TIMEOUT) return ret;
    if(ret & FLAG_ILLEGAL_CMD) return ret;

    return sdPrvSimpleCommand(cmd, param, crc, 1);
}

static char sdPrvCardInit(char sd, char hc){

    uint32_t time = 0;
    uint32_t resp;
    uint32_t param;

    param = hc ? (1UL<< 30) : 0;

    while(time++ < 10000UL){    //retry 10..0 times

        resp = sd ? sdPrvACMD(41, param, 1) : sdPrvSimpleCommand(1, param, 1, 1);
        if(resp & FLAG_TIMEOUT) break;
        if(!(resp & FLAG_IN_IDLE_MODE)) return 1;
    }

    return 0;
}

static uint32_t sdPrvGetBits(uint8_t* data,uint32_t numBytesInArray,uint32_t startBit,uint32_t len){//for CID and CSD data..

    uint32_t bitWrite = 0;
    uint32_t numBitsInArray = numBytesInArray * 8;
    uint32_t ret = 0;

    do{

        uint32_t bit,byte;

        bit = numBitsInArray - startBit - 1;
        byte = bit / 8;
        bit = 7 - (bit % 8);

        ret |= ((data[byte] >> bit) & 1) << (bitWrite++);

        startBit++;
    }while(--len);

    return ret;
}

static uint32_t sdPrvGetCardNumBlocks(char mmc,uint8_t* csd){

    uint32_t ver = sdPrvGetBits(csd,16,126,2);
    uint32_t cardSz = 0;


    if(ver == 0 || (mmc && ver <= 2)){

        uint32_t cSize = sdPrvGetBits(csd,16,62,12);
        uint32_t cSizeMult = sdPrvGetBits(csd,16,47,3);
        uint32_t readBlLen = sdPrvGetBits(csd,16,80,4);
        uint32_t blockLen,blockNr;
        uint32_t divTimes = 9;        //from bytes to blocks division

        blockLen = 1UL << readBlLen;
        blockNr = (cSize + 1) * (1UL << (cSizeMult + 2));

        /*
             multiplying those two produces result in bytes, we need it in blocks
             so we shift right 9 times. doing it after multiplication might fuck up
             the 4GB card, so we do it before, but to avoid killing significant bits
             we only cut the zero-valued bits, if at the end we end up with non-zero
             "divTimes", divide after multiplication, and thus underuse the card a bit.
             This will never happen in reality since 512 is 2^9, and we are
             multiplying two numbers whose product is a multiple of 2^9, so they
             togethr should have at least 9 lower zero bits.
        */

        while(divTimes && !(blockLen & 1)){

            blockLen = blockLen >> 1;
            divTimes--;
        }
        while(divTimes && !(blockNr & 1)){

            blockNr = blockNr >> 1;
            divTimes--;
        }

        cardSz = (blockNr * blockLen) >> divTimes;
    }
    else if(ver == 1){

        cardSz = sdPrvGetBits(csd,16,48,22)/*num 512K blocks*/ << 10;
    }


    return cardSz;
}

char sdInit(SD* sd){

    uint8_t v, t;
    uint16_t retries = 1050;
    uint8_t respBuf[16];

    dbgPrintf("SD: initing\n");

    gpioSetFun(pinCD, GPIO_FUNC_GPIO);
    gpioSetDir(pinCD, 1);

    for(v = 0; v < sizeof(pinsSD); v++){

        gpioSetFun(pinsSD[v], GPIO_FUNC_GPIO);
        gpioSetDir(pinsSD[v], 0);
        gpioSetVal(pinsSD[v], 0);
    }
    gpioSetDir(pinsSD[MISO], 1);
    gpioSetVal(pinsSD[CS], 1);

    sd->inited = 0;
    sd->SD = 0;
    sd->HC = 0;

    sdClockSpeed(0);
    sdChipSelect(0);
    for(v = 0; v < 10; v++) sdSpiByte(0xFF);    //80 clocks with CS not asserted to give card time to init

    while(0x01 != sdPrvSimpleCommand(0, 0, 1, 1)) if(!--retries) return 0;	//always a good idea
    
    v = sdPrvSimpleCommand(8, 0x000001AAUL, 1, 0);    //try CMD8 to init SDHC cards
    if(v & FLAG_TIMEOUT) return 0;
    sdSpiByte(0xFF);	//ignore the reply
    sdSpiByte(0xFF);
    sdSpiByte(0xFF);
    sdSpiByte(0xFF);
    sdChipSelect(0);
    sdSpiByte(0xFF);

    v = sdPrvSimpleCommand(55, 0, 1, 1);            //see if this is SD or MMC
    if(v & FLAG_TIMEOUT) return 0;
    sd->SD = !(v & FLAG_ILLEGAL_CMD);

    dbgPrintf("SD: card is likely %s\n", sd->SD ? "SD" : "MMC");

    if(sd->SD){

        if(!sdPrvCardInit(1, 1) && !sdPrvCardInit(1, 0)){

            return 0;
        }

        v = sdPrvSimpleCommand(58,0, 1, 0);    //see if it is HC
        t = sdSpiByte(0xFF);	//get the reply
        sdSpiByte(0xFF);
        sdSpiByte(0xFF);
        sdSpiByte(0xFF);
        sdChipSelect(0);
        sdSpiByte(0xFF);
        if(v) t = 0;
        if(t & 0x40) sd->HC = 1;
    }
    else{

        if(!sdPrvCardInit(0, 1) && !sdPrvCardInit(0, 0)){

            return 0;
        }
    }

    v = sdPrvSimpleCommand(59, 0, 1, 1);        //crc off
    if(v & FLAG_TIMEOUT) return 0;

    v = sdPrvSimpleCommand(9, 0, 0, 0);           //read CSD
    if(v & FLAG_TIMEOUT) return 0;

    v = sdPrvReadData(respBuf, 16, 1);
    if(v) return 0;

    sd->numSec = sdPrvGetCardNumBlocks(!sd->SD, respBuf);
    sd->inited = 1;

    sdClockSpeed(1);

    return 1;
}

uint32_t sdGetNumSec(SD* sd){

    return sd->inited ? sd->numSec : 0;
}

char sdSecRead(SD* sd, uint32_t sec, void* buf){    //CMD17

    uint8_t v, retry = 0;
    char ret = 0;

    if(!sd->inited) return 0;

    do{

        v = sdPrvSimpleCommand(17, sd->HC ? sec : sec << 9, 0, 0);
        if(v & FLAG_TIMEOUT) return 0;

        v = sdPrvReadData(buf, 0, 0);
        sdStreamSec(buf);
        sdSpiByte(0xFF);  //skip crc
        sdSpiByte(0xFF);
        sdChipSelect(0);
        if(!v){
            ret = 1;
            break;
        }
        
    
    }while(++retry < 5);    //retry up to 5 times

    return ret;
}


char sdSecWrite(SD* sd, uint32_t sec, const void* buf){    //CMD24

    uint32_t v16;
    uint8_t v, retry = 0;
    uint8_t* buf_ = buf;
    char ret = 0;


    if(!sd->inited) return 0;

    do{

        v = sdPrvSimpleCommand(24, sd->HC ? sec : sec << 9, 0, 0);
        if(v & FLAG_TIMEOUT) return 0;

        sdSpiByte(0xFF);    //as per SD-spi spec, we give it 8 clocks to consider the ramifications of the command we just sent

        sdSpiByte(0xFE);    //start of data block
        for(v16 = 0; v16 < SD_BLOCK_SIZE; v16++) sdSpiByte(*buf_++);    //data


        while((v = sdSpiByte(0xFF)) == 0xFF);    //wait while card isnt answering
        while(sdSpiByte(0xFF) != 0xFF);    //wait while card is busy

        if((v & 0x1F) == 5){
            ret = 1;
            break;
        }

    }while(++retry < 5);        //retry up to 5 times

    return ret;
}





//stream mode
char sdReadStart(SD* sd, uint32_t sec){

    uint8_t v;

    v = sdPrvSimpleCommand(18, sd->HC ? sec : sec << 9, 0, 0);
    if(v & FLAG_TIMEOUT) return 0;

    do{
        v = sdSpiByte(0xFF);
    }while(v == 0xFF);
    if(v != 0xFE){
        sdChipSelect(0);
        return 0;
    }
    return 1;
}

void sdNextSec(SD* sd){

    uint8_t v;

    sdSpiByte(0xFF);	//skip crc
    sdSpiByte(0xFF);

    do{
        v = sdSpiByte(0xFF);
    }while(v == 0xFF);
}

void sdSecReadStop(SD* sd){

    sdChipSelect(0);
    sdSpiByte(0xFF);	//skip crc
    sdSpiByte(0xFF);

    //cancel read
    sdPrvSimpleCommand(12, 0, 0, 1);
}