source: soft/giet_vm/giet_drivers/sdc_driver.c @ 331

///////////////////////////////////////////////////////////////////////////////////
// File     : sdc_driver.c
// Date     : 31/08/2012
// Author   : cesar fuguet
// Copyright (c) UPMC-LIP6
///////////////////////////////////////////////////////////////////////////////////

#include <hard_config.h>
#include <sdc_driver.h>
#include <tty_driver.h>
#include <utils.h>

#define SYSCLK_FREQ           50000000
#define SDCARD_RESET_ITER_MAX 4

static struct sdcard_dev sdcard;
static struct spi_dev*   spi;

///////////////////////////////////////////////////////////////////////////////
//      _sdc_enable()
// This function enables SD Card select signal
///////////////////////////////////////////////////////////////////////////////
static void _sdc_enable()
{
    spi_ss_assert(sdcard.spi, sdcard.slave_id);
}

///////////////////////////////////////////////////////////////////////////////
//      _sdc_enable()
// This function disables SD Card select signal
///////////////////////////////////////////////////////////////////////////////
static void _sdc_disable()
{
    spi_ss_deassert(sdcard.spi, sdcard.slave_id);
}

///////////////////////////////////////////////////////////////////////////////
//      _sdc_gen_tick()
// This function writes on the SPI tx register to generate SD card clock ticks
// - tick_count: number of ticks to generate (1 tick -> 8 clocks) 
///////////////////////////////////////////////////////////////////////////////
static void _sdc_gen_tick(unsigned int tick_count)
{
    register int i = 0;
    while(i++ < tick_count) spi_put_tx(sdcard.spi, 0xFF, 0);
}

///////////////////////////////////////////////////////////////////////////////
//      _sdc_lseek()
// This function changes the SD card access pointer position in terms of
// blocks
// - lba: number of logical block to move the pointer
///////////////////////////////////////////////////////////////////////////////
void _sdc_lseek(unsigned int lba)
{
    sdcard.access_pointer = sdcard.block_length * lba;
}

///////////////////////////////////////////////////////////////////////////////
//      _sdc_receive_char()
// This function gets a byte from the SD card
///////////////////////////////////////////////////////////////////////////////
static unsigned char _sdc_receive_char()
{
    _sdc_gen_tick(1);

    return spi_get_rx(sdcard.spi, 0);
}

///////////////////////////////////////////////////////////////////////////////
//      _sdc_wait_response()
// This function returns when a valid response from the SD card is received or
// a timeout has been triggered
// Returns the SD card response value
///////////////////////////////////////////////////////////////////////////////
static unsigned char _sdc_wait_response()
{
    unsigned char sdcard_rsp;
    register int  iter;

    iter       = 0;
    sdcard_rsp = _sdc_receive_char();
    while (
            (iter < SDCARD_COMMAND_TIMEOUT) &&
            !SDCARD_CHECK_R1_VALID(sdcard_rsp)
          )
    {
        sdcard_rsp = _sdc_receive_char();
        iter++;
    }

    return sdcard_rsp;
}

///////////////////////////////////////////////////////////////////////////////
//      _sdc_wait_data_block()
// This function returns when a data block from the SD card is received (data
// block start marker received).
// It must be called after a read command
///////////////////////////////////////////////////////////////////////////////
static void _sdc_wait_data_block()
{
        while (_sdc_receive_char() != 0xFE);
}

///////////////////////////////////////////////////////////////////////////////
//      _sdc_send_command()
// This function sends a command to the SD card
// - index: CMD index
// - app: type of command
// - args: CMD arguments vector
// - crc7: CRC (7 bits) to send
///////////////////////////////////////////////////////////////////////////////
static int _sdc_send_command ( int      index,
                               int      app  ,
                               void *   args ,
                               unsigned crc7 )
{
    unsigned char sdcard_rsp;
    unsigned char * _args;

    _sdc_gen_tick(5);  

    if (app == SDCARD_ACMD)
    {
        spi_put_tx(sdcard.spi, 0x40 | 55         , 0 );// CMD and START bit
        spi_put_tx(sdcard.spi, 0x00              , 0 );// Argument[0]
        spi_put_tx(sdcard.spi, 0x00              , 0 );// Argument[1]
        spi_put_tx(sdcard.spi, 0x00              , 0 );// Argument[2]
        spi_put_tx(sdcard.spi, 0x00              , 0 );// Argument[3]
        spi_put_tx(sdcard.spi, 0x01 | (crc7 << 1), 0 );// END bit

        sdcard_rsp = _sdc_wait_response();
        if (SDCARD_CHECK_R1_ERROR(sdcard_rsp))
        {
            return sdcard_rsp;        
        }
    }

    _args = (unsigned char *) args;

    _sdc_gen_tick(1);  

    spi_put_tx(sdcard.spi, 0x40 | index      , 0 );
    spi_put_tx(sdcard.spi, _args[0]          , 0 );
    spi_put_tx(sdcard.spi, _args[1]          , 0 );
    spi_put_tx(sdcard.spi, _args[2]          , 0 );
    spi_put_tx(sdcard.spi, _args[3]          , 0 );
    spi_put_tx(sdcard.spi, 0x01 | (crc7 << 1), 0 );

    return _sdc_wait_response();
}

///////////////////////////////////////////////////////////////////////////////
//      _sdc_open()
// This function initializes the SD card (reset procedure)
// - channel: channel index (only channel 0 is supported)
// Returns 0 if success, other value if failure
///////////////////////////////////////////////////////////////////////////////
static int _sdc_open( unsigned int channel )
{
        unsigned char args[4];
        unsigned char sdcard_rsp;
        unsigned int  iter, ersp;

        sdcard.spi      = spi;
        sdcard.slave_id = channel;

        // supply SD card ramp up time (min 74 cycles)
        _sdc_gen_tick(10);

        // Assert slave select signal
        // Send CMD0 (Reset Command)
        // Deassert slave select signal
        _sdc_enable();

        args[0] = 0;
        args[1] = 0;
        args[2] = 0;
        args[3] = 0;
        sdcard_rsp = _sdc_send_command(0, SDCARD_CMD, args, 0x4A);
        if ( sdcard_rsp != 0x01 )
        {
                _printf("[SDC ERROR] card CMD0 failed\n");
                return sdcard_rsp;
        }

        _sdc_disable();

        // send CMD8. If card is pre-v2, It will reply with illegal command.
        // Otherwise we announce sdhc support.
        _sdc_enable();
        args[0] = 0;
        args[1] = 0;
        args[2] = 0x01;
        args[3] = 0x01;
        sdcard_rsp = _sdc_send_command(8, SDCARD_CMD, args, 0x63);
        if (!SDCARD_CHECK_R1_VALID(sdcard_rsp))
    {
                _printf("[SDC ERROR] card CMD8 failed\n");
                return sdcard_rsp;
        }
        if (!SDCARD_CHECK_R1_ERROR(sdcard_rsp))
    {
                // no error, command accepted. get whole reply
                ersp = _sdc_receive_char();
                ersp = (ersp << 8) | _sdc_receive_char();
                ersp = (ersp << 8) | _sdc_receive_char();
                ersp = (ersp << 8) | _sdc_receive_char();
                if ((ersp & 0xffff) != 0x0101) 
        {
                        // voltage mismatch
                        _printf("[SDC ERROR] card CMD8 mismatch : ersp = %x\n");
                        return sdcard_rsp;
                }
                _printf("[SDC WARNING] v2 or later ");
                sdcard.sdhc = 1;
        }
    else if ((sdcard_rsp & SDCARD_R1_ILLEGAL_CMD) == 0)
    {
                // other error
                _printf("[SDC ERROR] card CMD8 error\n");
                return sdcard_rsp;
        }
    else
    {
                sdcard.sdhc = 0;
        }
        _sdc_disable();

        // send CMD41, enabling the card
        _sdc_enable();
        args[0] = sdcard.sdhc ? 0x40: 0;
        args[1] = 0;
        args[2] = 0;
        args[3] = 0;

        iter = 0;
        while( iter++ < SDCARD_COMMAND_TIMEOUT )
        {
                sdcard_rsp = _sdc_send_command(41, SDCARD_ACMD, args, 0x00);
                if( sdcard_rsp == 0x01 )
                {
                        continue;
                }

                break;
        }

        _sdc_disable();
        if (sdcard_rsp)
    {
                _printf("[SDC ERROR] ACMD41 failed\n");
                return sdcard_rsp;
        }
        if (sdcard.sdhc != 0)
    {
                // get the card capacity to see if it's really HC
                _sdc_enable();
                args[0] = sdcard.sdhc ? 0x40: 0;
                args[1] = 0;
                args[2] = 0;
                args[3] = 0;
        sdcard_rsp = _sdc_send_command(58, SDCARD_CMD, args, 0x00);
                if (sdcard_rsp)
        {
                        _printf("[SDC ERROR] CMD58 failed\n");
                        return sdcard_rsp;
                }
                ersp = _sdc_receive_char();
                ersp = (ersp << 8) | _sdc_receive_char();
                ersp = (ersp << 8) | _sdc_receive_char();
                ersp = (ersp << 8) | _sdc_receive_char();
                if (ersp & 0x40000000)
        {
                        _printf(" SDHC ");
                } 
        else
        {
                        sdcard.sdhc = 0;
                }
                _sdc_disable();
        }
        _printf("card detected\n");
        return 0;
}

///////////////////////////////////////////////////////////////////////////////
//      _sdc_set_block_size()
// This function sets the block size in bytes of the SD card
// - len: block size in bytes (only 512 bytes supported)
// Returns 0 if success, other value if failure
///////////////////////////////////////////////////////////////////////////////
static unsigned int _sdc_set_block_size(unsigned int len)
{
    unsigned char args[4];
    unsigned char sdcard_rsp;
    register int i;

    // For now, supported block size is 512 bytes
    if (len != 512) return 1;

    // When using high capacity SDCARD, the block_length is not a number of bytes
    // but a number of blocks (transfer unit)
    if (sdcard.sdhc)
    {
        sdcard.block_length = len / 512;
        return 0;
    }

    for (i = 0; i < 4; i++)
    {
        args[i] = (len >> (32 - (i+1)*8)) & 0xFF;
    }

    _sdc_enable();

    sdcard_rsp = _sdc_send_command(16, SDCARD_CMD, args, 0x00);
    if ( SDCARD_CHECK_R1_ERROR(sdcard_rsp) )
    {
        _sdc_disable();
        return sdcard_rsp;
    }

    _sdc_disable();

    sdcard.block_length = len;

        return 0;
}

///////////////////////////////////////////////////////////////////////////////
//      _sdc_init()
// This function initializes the SPI controller and call sdc_open to
// initializes SD card
// - channel: channel to initialize (only channel 0 supported)
// Returns 0 if success, other value if failure
///////////////////////////////////////////////////////////////////////////////
unsigned int _sdc_init()
{
    spi = (struct spi_dev*)SEG_IOC_BASE;

    // initializing the SPI controller
    _spi_init (
        spi           ,
        200000        , /**< SPI_clk: 200 Khz */
        SYSCLK_FREQ   , /**< Sys_clk          */
        8             , /**< Charlen: 8       */
        SPI_TX_NEGEDGE,
        SPI_RX_POSEDGE
    );

    // initializing the SD Card
    unsigned int iter = 0;
    unsigned char sdcard_rsp;
    unsigned int i;

    while(1)
    {
        _printf("[SDC WARNING] Trying to initialize SD card...\n");

        sdcard_rsp = _sdc_open( 0 );  // only channel 0
        if (sdcard_rsp == 0)
        {
            _printf("OK\n");
            break;
        }

        _printf("KO\n");

        for (i = 0; i < 1000; i++);

        if (++iter >= SDCARD_RESET_ITER_MAX)
        {
            _printf("\n[SDC ERROR] During SD card reset to IDLE state "
                    "/ card response = %x\n", sdcard_rsp );
            _exit();
        }
    }

    // set the block length of the SD Card
    sdcard_rsp = _sdc_set_block_size(512);
    if (sdcard_rsp)
    {
        _printf("[SDC ERROR] During SD card blocklen initialization\n");
        _exit();
    }

    // incrementing SDCARD clock frequency for normal function
    _spi_init (
        spi         ,
        10000000    , // SPI_clk 10 Mhz
        SYSCLK_FREQ , // Sys_clk
        -1          , // Charlen: 8
        -1          ,
        -1
    );

    _printf("[SDC WARNING] Finish SD card initialization\n\r");

    return 0;
}


///////////////////////////////////////////////////////////////////////////////
//     _sdc_read()
// Transfer data from the block device to a memory buffer. 
// - mode     : BOOT / KERNEL / USER
// - lba      : first block index on the block device
// - buffer   : base address of the memory buffer (must be word aligned)
// - count    : number of blocks to be transfered.
// Returns 0 if success, > 0 if error.
///////////////////////////////////////////////////////////////////////////////
unsigned int _sdc_read( unsigned int mode,
                        unsigned int lba,
                        paddr_t      buffer,
                        unsigned int count )
{
    unsigned char args[4];
    unsigned char sdcard_rsp;
    unsigned int i;
    unsigned int curr = lba;
    unsigned int last = lba + count;

    for ( ; curr < last ; curr++ )
    {
        _sdc_lseek(curr);

        for (i = 0; i < 4; i++)
        {
            args[i] = (sdcard.access_pointer >> (32 - (i+1)*8)) & 0xFF;
        }

        _sdc_enable();

        sdcard_rsp = _sdc_send_command(17, SDCARD_CMD, args, 0x00);
        if ( SDCARD_CHECK_R1_ERROR(sdcard_rsp) )
        {
            _sdc_disable();
            return sdcard_rsp;
        }

        _sdc_wait_data_block();

        if (spi_get_data(sdcard.spi, buffer, 512 ))
        {
            _sdc_disable();
            return 1;
        }

        // Get the CRC16 (comes at the end of the data block)
        _sdc_receive_char(); // first byte
        _sdc_receive_char(); // second byte

        _sdc_disable();

        buffer += 512;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//     _sdc_write() (not supported for now)
// Transfer data from memory buffer to SD card device. 
// - mode     : BOOT / KERNEL / USER
// - lba      : destination first block index on the SD card
// - buffer   : base address of the memory buffer (must be word aligned)
// - count    : number of blocks to be transfered.
// Returns 0 if success, > 0 if error.
///////////////////////////////////////////////////////////////////////////////
unsigned int _sdc_write( unsigned int mode,
                         unsigned int lba,
                         paddr_t      buffer,
                         unsigned int count )
{
        return 0;
}

///////////////////////////////////////////////////////////////////////////////
// Transfer data from memory buffer to SD card device. 
// - channel: channel index
// - status: this pointer is used to transmit the status value to caller. 
// Returns 0 if success, > 0 if error.
///////////////////////////////////////////////////////////////////////////////
unsigned int _sdc_get_status()
{
    _printf("[SDC ERROR] function _sdc_get_status() should not be called\n");
    _exit();

    return 0;  // to avoid a warning
}

///////////////////////////////////////////////////////////////////////////////
// Returns the block size in bytes of the SD card
///////////////////////////////////////////////////////////////////////////////
unsigned int _sdc_get_block_size()
{
    if (sdcard.sdhc) return sdcard.block_length*512;
    else             return sdcard.block_length;
}

// Local Variables:
// tab-width: 4
// c-basic-offset: 4
// c-file-offsets:((innamespace . 0)(inline-open . 0))
// indent-tabs-mode: nil
// End:
// vim: filetype=c:expandtab:shiftwidth=4:tabstop=4:softtabstop=4