mmc.c

Go to the documentation of this file.

/*! \file mmc.c \brief MultiMedia and SD Flash Card Interface. */
//*****************************************************************************
//
// File Name    : 'mmc.c'
// Title        : MultiMedia and SD Flash Card Interface
// Author       : Pascal Stang - Copyright (C) 2004
// Created      : 2004.09.22
// Revised      : 2006.06.12
// Version      : 0.1
// Target MCU   : Atmel AVR Series
// Editor Tabs  : 4
//
// NOTE: This code is currently below version 1.0, and therefore is considered
// to be lacking in some functionality or documentation, or may not be fully
// tested.  Nonetheless, you can expect most functions to work.
//
// This code is distributed under the GNU Public License
//      which can be found at http://www.gnu.org/licenses/gpl.txt
//
//*****************************************************************************

//----- Include Files ---------------------------------------------------------
#include <avr/io.h>         // include I/O definitions (port names, pin names, etc)
#include <avr/interrupt.h>  // include interrupt support

#include "global.h"     // include our global settings
#include "spi.h"        // include spi bus support

#include "rprintf.h"

#include "mmc.h"

// include project-specific hardware configuration
#include "mmcconf.h"

// Global variables

// Functions

void mmcInit(void)
{
    // initialize SPI interface
    spiInit();
    // release chip select
    sbi(MMC_CS_DDR, MMC_CS_PIN);
    sbi(MMC_CS_PORT,MMC_CS_PIN);
}

u08 mmcReset(void)
{
    u08 i;
    u08 retry;
    u08 r1=0;

    retry = 0;
    do
    {
        // send dummy bytes with CS high before accessing
        for(i=0;i<10;i++) spiTransferByte(0xFF);
        // resetting card, go to SPI mode
        r1 = mmcSendCommand(MMC_GO_IDLE_STATE, 0);
        #ifdef MMC_DEBUG
        rprintf("MMC_GO_IDLE_STATE: R1=0x%x\r\n", r1);
        #endif
        // do retry counter
        retry++;
        if(retry>10) return -1;
    } while(r1 != 0x01);

    // TODO: check card parameters for voltage compliance
    // before issuing initialize command

    retry = 0;
    do
    {
        // initializing card for operation
        r1 = mmcSendCommand(MMC_SEND_OP_COND, 0);
        #ifdef MMC_DEBUG
        rprintf("MMC_SEND_OP_COND: R1=0x%x\r\n", r1);
        #endif
        // do retry counter
        retry++;
        if(retry>100) return -1;
    } while(r1);
        
    // turn off CRC checking to simplify communication
    r1 = mmcSendCommand(MMC_CRC_ON_OFF, 0);
    #ifdef MMC_DEBUG
    rprintf("MMC_CRC_ON_OFF: R1=0x%x\r\n", r1);
    #endif

    // set block length to 512 bytes
    r1 = mmcSendCommand(MMC_SET_BLOCKLEN, 512);
    #ifdef MMC_DEBUG
    rprintf("MMC_SET_BLOCKLEN: R1=0x%x\r\n", r1);
    #endif

    // return success
    return 0;
}

u08 mmcSendCommand(u08 cmd, u32 arg)
{
    u08 r1;

    // assert chip select
    cbi(MMC_CS_PORT,MMC_CS_PIN);
    // issue the command
    r1 = mmcCommand(cmd, arg);
    // release chip select
    sbi(MMC_CS_PORT,MMC_CS_PIN);

    return r1;
}

u08 mmcRead(u32 sector, u08* buffer)
{
    u08 r1;
    u16 i;

    // assert chip select
    cbi(MMC_CS_PORT,MMC_CS_PIN);
    // issue command
    r1 = mmcCommand(MMC_READ_SINGLE_BLOCK, sector<<9);
    #ifdef MMC_DEBUG
    rprintf("MMC Read Block R1=0x%x\r\n", r1);
    #endif
    // check for valid response
    if(r1 != 0x00)
        return r1;
    // wait for block start
    while(spiTransferByte(0xFF) != MMC_STARTBLOCK_READ);
    // read in data
    for(i=0; i<0x200; i++)
    {
        *buffer++ = spiTransferByte(0xFF);
    }
    // read 16-bit CRC
    spiTransferByte(0xFF);
    spiTransferByte(0xFF);
    // release chip select
    sbi(MMC_CS_PORT,MMC_CS_PIN);
    // return success
    return 0;
}

u08 mmcWrite(u32 sector, u08* buffer)
{
    u08 r1;
    u16 i;

    // assert chip select
    cbi(MMC_CS_PORT,MMC_CS_PIN);
    // issue command
    r1 = mmcCommand(MMC_WRITE_BLOCK, sector<<9);
    #ifdef MMC_DEBUG
    rprintf("MMC Write Block R1=0x%x\r\n", r1);
    #endif
    // check for valid response
    if(r1 != 0x00)
        return r1;
    // send dummy
    spiTransferByte(0xFF);
    // send data start token
    spiTransferByte(MMC_STARTBLOCK_WRITE);
    // write data
    for(i=0; i<0x200; i++)
    {
        spiTransferByte(*buffer++);
    }
    // write 16-bit CRC (dummy values)
    spiTransferByte(0xFF);
    spiTransferByte(0xFF);
    // read data response token
    r1 = spiTransferByte(0xFF);
    if( (r1&MMC_DR_MASK) != MMC_DR_ACCEPT)
        return r1;
    #ifdef MMC_DEBUG
    rprintf("Data Response Token=0x%x\r\n", r1);
    #endif
    // wait until card not busy
    while(!spiTransferByte(0xFF));
    // release chip select
    sbi(MMC_CS_PORT,MMC_CS_PIN);
    // return success
    return 0;
}

u08 mmcCommand(u08 cmd, u32 arg)
{
    u08 r1;
    u08 retry=0;
    // send command
    spiTransferByte(cmd | 0x40);
    spiTransferByte(arg>>24);
    spiTransferByte(arg>>16);
    spiTransferByte(arg>>8);
    spiTransferByte(arg);
    spiTransferByte(0x95);  // crc valid only for MMC_GO_IDLE_STATE
    // end command
    // wait for response
    // if more than 8 retries, card has timed-out
    // return the received 0xFF
    while((r1 = spiTransferByte(0xFF)) == 0xFF)
        if(retry++ > 8) break;
    // return response
    return r1;
}

---