quickdev16/avr/usbload/mmc.c

/*#######################################################################################
Connect AVR to MMC/SD 

Copyright (C) 2004 Ulrich Radig

Bei Fragen und Verbesserungen wendet euch per EMail an

mail@ulrichradig.de

oder im Forum meiner Web Page : www.ulrichradig.de

Dieses Programm ist freie Software. Sie können es unter den Bedingungen der 
GNU General Public License, wie von der Free Software Foundation veröffentlicht, 
weitergeben und/oder modifizieren, entweder gemäß Version 2 der Lizenz oder 
(nach Ihrer Option) jeder späteren Version. 

Die Veröffentlichung dieses Programms erfolgt in der Hoffnung, 
daß es Ihnen von Nutzen sein wird, aber OHNE IRGENDEINE GARANTIE, 
sogar ohne die implizite Garantie der MARKTREIFE oder der VERWENDBARKEIT 
FÜR EINEN BESTIMMTEN ZWECK. Details finden Sie in der GNU General Public License. 

Sie sollten eine Kopie der GNU General Public License zusammen mit diesem 
Programm erhalten haben. 
Falls nicht, schreiben Sie an die Free Software Foundation, 
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. 
#######################################################################################*/

#include <avr/io.h>
#include <util/delay.h>         

#include "mmc.h"


uint8_t mmc_init()
{
    uint16_t Timeout = 0, i;
    MMC_REG |= ((1 << MMC_DO) | (1 << MMC_CS) | (1 << MMC_CLK));
    MMC_REG &= ~(1 << MMC_DI);
    MMC_WRITE |= ((1 << MMC_DO) | (1 << MMC_DI) | (1 << MMC_CS));
    _delay_ms(20);
    for (i = 0; i < 250; i++) {
        MMC_WRITE ^= (1 << MMC_CLK);
        _delay_us(4);
    }
    MMC_WRITE &= ~(1 << MMC_CLK);
    _delay_us(10);
    MMC_WRITE &= ~(1 << MMC_CS);
    _delay_us(3);
 
    uint8_t CMD[] = { 0x40, 0x00, 0x00, 0x00, 0x00, 0x95 };
    while (mmc_write_command(CMD) != 1) {
        if (Timeout++ > 20) {
            mmc_disable();
            return (1);
        }
    }
 
    Timeout = 0;
    CMD[0] = 0x41;
    CMD[5] = 0xFF;
    while (mmc_write_command(CMD) != 0) {
        if (Timeout++ > 800) {
            mmc_disable();
            return (9);
        }
    }
    return (0);
}
uint8_t mmc_write_command(uint8_t * cmd)
{
    uint8_t tmp = 0xff;
    uint16_t Timeout = 0;
    uint8_t a;
 
    for (a = 0; a < 0x06; a++) {
        mmc_write_byte(*cmd++);
    }
 
    while (tmp == 0xff) {
        tmp = mmc_read_byte();
        if (Timeout++ > 50) {
            break;
        }
    }
    return (tmp);
}
 
 
uint8_t mmc_read_byte(void)
{
    uint8_t Byte = 0, j;
    for (j = 0; j < 8; j++) {
        Byte = (Byte << 1);
        MMC_WRITE |= (1 << MMC_CLK);
        _delay_us(4);
        if (PINB & (1 << MMC_DI)) {
            Byte |= 1;
        }
 
        else {
            Byte &= ~1;
        }
        MMC_WRITE &= ~(1 << MMC_CLK);
        _delay_us(4);
    }
    return (Byte);
}
 
 
void mmc_write_byte(uint8_t Byte)
{
    uint8_t i;
    for (i = 0; i < 8; i++) {
        if (Byte & 0x80) {
            MMC_WRITE |= (1 << MMC_DO);
        }
 
        else {
            MMC_WRITE &= ~(1 << MMC_DO);
        }
        Byte = (Byte << 1);
        MMC_WRITE |= (1 << MMC_CLK);
        _delay_us(4);
        MMC_WRITE &= ~(1 << MMC_CLK);
        _delay_us(4);
    }
    MMC_WRITE |= (1 << MMC_DO);
}

uint8_t mmc_write_sector(uint32_t addr, uint8_t * Buffer)
{
    uint8_t tmp;
 
 
    uint8_t cmd[] = { 0x58, 0x00, 0x00, 0x00, 0x00, 0xFF };
    uint8_t a;
    uint16_t i;
 
    addr = addr << 9;
    cmd[1] = ((addr & 0xFF000000) >> 24);
    cmd[2] = ((addr & 0x00FF0000) >> 16);
    cmd[3] = ((addr & 0x0000FF00) >> 8);
 
 
    tmp = mmc_write_command(cmd);
    if (tmp != 0) {
        return (tmp);
    }
 
    for (a = 0; a < 100; a++) {
        mmc_read_byte();
    }
 
    mmc_write_byte(0xFE);
 
    for (a = 0; i < 512; i++) {
        mmc_write_byte(*Buffer++);
    }
 
    mmc_write_byte(0xFF);
    mmc_write_byte(0xFF);
 
    if ((mmc_read_byte() & 0x1F) != 0x05)
        return (1);
 
    while (mmc_read_byte() != 0xff) {
    };
    return (0);
}
 
 
void mmc_read_block(uint8_t * cmd, uint8_t * Buffer, uint16_t Bytes)
{
    uint16_t a;
 
    if (mmc_write_command(cmd) != 0) {
        return;
    }
 
    while (mmc_read_byte() != 0xfe) {
    };
 
 
    for (a = 0; a < Bytes; a++) {
        *Buffer++ = mmc_read_byte();
    }
 
    mmc_read_byte();
    mmc_read_byte();
    return;
}
 
uint8_t mmc_read_sector(uint32_t addr, uint8_t * Buffer)
{
 
 
    uint8_t cmd[] = { 0x51, 0x00, 0x00, 0x00, 0x00, 0xFF };
 
    addr = addr << 9;
    cmd[1] = ((addr & 0xFF000000) >> 24);
    cmd[2] = ((addr & 0x00FF0000) >> 16);
    cmd[3] = ((addr & 0x0000FF00) >> 8);
    mmc_read_block(cmd, Buffer, 512);
    return (0);
}
 
 
uint8_t mmc_read_cid(uint8_t * Buffer)
{
 
    uint8_t cmd[] = { 0x4A, 0x00, 0x00, 0x00, 0x00, 0xFF };
    mmc_read_block(cmd, Buffer, 16);
    return (0);
}
 
 
uint8_t mmc_read_csd(uint8_t * Buffer)
{
 
    uint8_t cmd[] = { 0x49, 0x00, 0x00, 0x00, 0x00, 0xFF };
    mmc_read_block(cmd, Buffer, 16);
    return (0);
}