Subversion Repositories igor

/************************************************************************

**

**  Copyright (C) 2006  Jesper Hansen <jesper@redegg.net>

**  Modified and extended with write supportfor use with the IGOR Lisp machine

**

**  Interface functions for MMC/SD cards

**

**  File mmc_if.h

**

*************************************************************************

**

**  This program is free software; you can redistribute it and/or

**  modify it under the terms of the GNU General Public License

**  as published by the Free Software Foundation; either version 2

**  of the License, or (at your option) any later version.

**

**  This program is distributed in the hope that it will be useful,

**  but WITHOUT ANY WARRANTY; without even the implied warranty of

**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

**  GNU General Public License for more details.

**

**  You should have received a copy of the GNU General Public License

**  along with this program; if not, write to the Free Software Foundation,

**  Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

**

*************************************************************************/

/** \file mmc_if.c

        Simple MMC/SD-card functionality

*/

#include <avr/io.h>

#include <inttypes.h>

#include <stdio.h>

#include "mmc.h"

#include <device.h>

igordev_read_fn_t mmc_recv;

igordev_write_fn_t mmc_send;

igordev_init_fn_t mmcdevice_init;

igordev_flush_fn_t mmc_flush;

struct igordev igordev_mmc = {

        .init = mmcdevice_init,

        .read = mmc_recv,

        .write = mmc_send,

        .flush = mmc_flush,

        .read_status = 0,

        .write_status = 0,

        .priv = NULL

};

//LBA of the most recently read sector

int32_t buffered_lba = -1;

//Used to store the most recently read sector

uint8_t sectorbuffer[512];

void mmcdevice_init()

{

        igordev_mmc.read_status = igordev_mmc.write_status = IDEV_STATUS_OK;

        igordev_mmc.id = (CAN_READ | CAN_WRITE | ADDR_READ | ADDR_WRITE |

            (DEVTYPE_STORAGE << DEVTYPE_OFFSET));

        //TODO do something useful if init fails?

        /*uint8_t returncode = */

        mmc_init();

}

//No write support specified in the current design draft,

//but can be implemented later

uint8_t

mmc_send(uint64_t addr, uint8_t *data, uint8_t num)

{

        //LBA of the sector we want to read

        uint32_t lba = addr/SECTOR_SIZE;

        //Byte position within the sector

        uint16_t byte_addr = addr-SECTOR_SIZE*lba;

        //Read the sector that will be overwritten

        if (read_sector_to_buffer(lba) != 0) {

                //Write error

                igordev_mmc.write_status = IDEV_STATUS_ERROR;

                return 0;

        }

        uint64_t i;

        //Fill the sector with new data

        for (i = byte_addr; i < byte_addr + num && i < SECTOR_SIZE; i++) {

                sectorbuffer[i] = *data;

                data++;

        }

        //Write the modified sector back

        if (write_buffer_to_sector(lba) != 0) {

                //Read error

                igordev_mmc.write_status = IDEV_STATUS_ERROR;

                return 0;

        }

        //Repeat if data spans two sectors

        if (byte_addr + num > SECTOR_SIZE) {

                //Read the new sector

                if (read_sector_to_buffer(lba+1) != 0) {

                        //Read error

                        igordev_mmc.write_status = IDEV_STATUS_ERROR;

                        return i - byte_addr;

                }

                //Store the remaining bytes

                uint8_t j;

                for (j = 0; j < byte_addr + num - SECTOR_SIZE; j++) {

                        sectorbuffer[j] = *data;

                        data++;

                }

                //Write the modified sector back

                if (write_buffer_to_sector(lba+1) != 0) {

                        //Write error

                        igordev_mmc.write_status = IDEV_STATUS_ERROR;

                        return i - byte_addr;

                }

                igordev_mmc.write_status = IDEV_STATUS_OK;

                return j + i - addr;

        }

        igordev_mmc.write_status = IDEV_STATUS_OK;

        return (i - addr) ;

}

uint8_t

mmc_recv(uint64_t addr, uint8_t *data, uint8_t num)

{

        //LBA of the sector we want to read

        uint32_t lba = addr/SECTOR_SIZE;

        //Byte position within the sector

        uint16_t byte_addr = addr-SECTOR_SIZE*lba;

        //Read the sector

        if (read_sector_to_buffer(lba) != 0) {

                //Read error

                igordev_mmc.read_status = IDEV_STATUS_ERROR;

                return 0;

        }

        uint64_t i;

        //Loop through the sector data and store only the bytes that we want

        //for (i = byte_addr; i < byte_addr + num && i < SECTOR_SIZE; i++) {

        //      *data++ = sectorbuffer[i];

        for (i = byte_addr; i < byte_addr + num && i < SECTOR_SIZE; i++) {

                *data = sectorbuffer[i];

                data++;

        }

        if (byte_addr + num > SECTOR_SIZE) {

                //We didn't get all of the data in the first go,

                //so we must continue reading on the next sector

                //Read the new sector

                if (read_sector_to_buffer(lba+1) != 0) {

                        //Read error

                        igordev_mmc.read_status = IDEV_STATUS_ERROR;

                        return i - byte_addr;

                }

                //Store the remaining bytes

                uint8_t j;

                for (j = 0; j < byte_addr + num - SECTOR_SIZE; j++) {

                        *data = sectorbuffer[j];

                        data++;

                }

                igordev_mmc.read_status = IDEV_STATUS_OK;

                return j + i - addr;

        }

        igordev_mmc.read_status = IDEV_STATUS_OK;

        return (i - addr) ;

}

//Read a sector into the sector buffer

uint8_t read_sector_to_buffer(uint32_t lba)

{

        if (buffered_lba != lba) {

                if (mmc_readsector(lba, sectorbuffer) != 0) {

                        //We have a read error

                        //The buffered sector may be corrupted,

                        //so we make sure it's invalidated

                        buffered_lba = -1;

                        return 1;

                } else { //Successful read

                        buffered_lba = lba;

                        return 0;

                }

        }

        return 0;

}

//Write the sector buffer into a sector

uint8_t write_buffer_to_sector(uint32_t lba)

{

        if (mmc_writesector(lba, sectorbuffer) != 0) {

                //We have a write error

                //Invalidate the buffered sector

                buffered_lba = -1;

                return 1;

        } else { //Successful write

                buffered_lba = lba;

                return 0;

        }

}

/** Hardware SPI I/O.

        \param byte Data to send over SPI bus

        \return Received data from SPI bus

*/

uint8_t spi_byte(uint8_t byte)

{

        SPDR = byte;

        while(!(SPSR & (1<<SPIF)))

        {}

        return SPDR;

}

/** Send a command to the MMC/SD card.

        \param command  Command to send

        \param px       Command parameter 1

        \param py       Command parameter 2

*/

void mmc_send_command(uint8_t command, uint16_t px, uint16_t py)

{

        register union u16convert r;

        SPI_PORT &= ~(1 << MMC_CS);     // enable CS

        spi_byte(0xff);                 // dummy byte

        spi_byte(command | 0x40);

        r.value = px;

        spi_byte(r.bytes.high); // high byte of param x

        spi_byte(r.bytes.low);  // low byte of param x

        r.value = py;

        spi_byte(r.bytes.high); // high byte of param y

        spi_byte(r.bytes.low);  // low byte of param y

        spi_byte(0x95);                 // correct CRC for first command in SPI

                                        // after that CRC is ignored, so no problem with

                                        // always sending 0x95

        spi_byte(0xff);                 // ignore return byte

}

/** Get Token.

        Wait for and return a non-ff token from the MMC/SD card

        \return The received token or 0xFF if timeout

*/

uint8_t mmc_get(void)

{

        uint16_t i = 0xffff;

        uint8_t b = 0xff;

        while ((b == 0xff) && (--i))

        {

                b = spi_byte(0xff);

        }

        return b;

}

/** Get Datatoken.

        Wait for and return a data token from the MMC/SD card

        \return The received token or 0xFF if timeout

*/

uint8_t mmc_datatoken(void)

{

        uint16_t i = 0xffff;

        uint8_t b = 0xff;

        while ((b != 0xfe) && (--i))

        {

                b = spi_byte(0xff);

        }

        return b;

}

/** Finish Clocking and Release card.

        Send 10 clocks to the MMC/SD card

         and release the CS line

*/

void mmc_clock_and_release(void)

{

        uint8_t i;

        // SD cards require at least 8 final clocks

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

                spi_byte(0xff);

        SPI_PORT |= (1 << MMC_CS);      // release CS

}

/** Read MMC/SD sector.

         Read a single 512 byte sector from the MMC/SD card

        \param lba      Logical sectornumber to read

        \param buffer   Pointer to buffer for received data

        \return 0 on success, -1 on error

*/

int mmc_readsector(uint32_t lba, uint8_t *buffer)

{

        uint16_t i;

        // send read command and logical sector address

        mmc_send_command(17,(lba>>7) & 0xffff, (lba<<9) & 0xffff);

        if (mmc_datatoken() != 0xfe)            // if no valid token

        {

                mmc_clock_and_release();        // cleanup and  

                return -1;                      // return error code

        }

        for (i=0;i<512;i++)                      // read sector data

                *buffer++ = spi_byte(0xff);

        spi_byte(0xff);                         // ignore dummy checksum

        spi_byte(0xff);                         // ignore dummy checksum

        mmc_clock_and_release();                // cleanup

        return 0;                                // return success

}

//Write MMC/SD sector

int mmc_writesector(uint32_t lba, uint8_t *buffer)

{

        uint16_t i;

        // send write command and logical sector address

        mmc_send_command(24,(lba>>7) & 0xffff, (lba<<9) & 0xffff);

        spi_byte(0xfe);                         //Send data token

        for (i=0;i<512;i++)                      //Send sector data

                spi_byte(*buffer++);

        spi_byte(0xff);                         //Send dummy 16-bit checksum

        spi_byte(0xff);

        if ((mmc_get() & 0x0f) != 0x05) {       //Receive response token

                mmc_clock_and_release();

                return -1;                      //Write error

        }

        while (spi_byte(0xff) == 0x00) {

                //Wait for the card to finish writing, this can take

                //a very long time, i.e. several hundred milliseconds

        }

        mmc_clock_and_release();                //Cleanup

        return 0;                                //Return success

}

/** Init MMC/SD card.

        Initialize I/O ports for the MMC/SD interface and

        send init commands to the MMC/SD card

        \return 0 on success, other values on error

*/

uint8_t mmc_init(void)

{

//Run configure_spi() to setup the SPI port before initializing MMC.

        int i;

        for(i=0;i<10;i++)                // send 8 clocks while card power stabilizes

                spi_byte(0xff);

        mmc_send_command(0,0,0);   // send CMD0 - reset card

        if (mmc_get() != 1)                     // if no valid response code

        {

                mmc_clock_and_release();

                return 1;                               // card cannot be detected

        }

        //

        // send CMD1 until we get a 0 back, indicating card is done initializing 

        //

        i = 0xffff;                                             // max timeout

        while ((spi_byte(0xff) != 0) && (--i))   // wait for it

        {

                mmc_send_command(1,0,0);  // send CMD1 - activate card init

        }

        mmc_clock_and_release();                // clean up

        if (i == 0)                                              // if we timed out above

                return 2;                                       // return failure code

        return 0;

}

void

mmc_flush(void)

{

}