mmcard.c

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2007 by egnite Software GmbH. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY EGNITE SOFTWARE GMBH 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 EGNITE
 * SOFTWARE GMBH 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.
 *
 * For additional information see http://www.ethernut.de/
 */

#include <cfg/mmci.h>

#if 0
/* Use for local debugging. */
#define NUTDEBUG
#include <stdio.h>
#endif

#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <memdebug.h>

#include <sys/heap.h>
#include <sys/timer.h>
#include <sys/event.h>
#include <fs/dospart.h>
#include <fs/fs.h>

#include <dev/blockdev.h>
#include <dev/mmcard.h>


#ifndef MMC_BLOCK_SIZE

#define MMC_BLOCK_SIZE          512
#endif

#ifndef MMC_MAX_INIT_POLLS

#define MMC_MAX_INIT_POLLS      512
#endif

#ifndef MMC_MAX_RESET_POLLS

#define MMC_MAX_RESET_POLLS     255
#endif

#ifndef MMC_MAX_WRITE_POLLS

#define MMC_MAX_WRITE_POLLS     1024
#endif

#ifndef MMC_MAX_WRITE_RETRIES

#define MMC_MAX_WRITE_RETRIES   32
#endif

#ifndef MMC_MAX_READ_RETRIES

#define MMC_MAX_READ_RETRIES    8
#endif

#ifndef MMC_MAX_REG_POLLS

#define MMC_MAX_REG_POLLS       512
#endif

#ifndef MMC_MAX_CMDACK_POLLS

#define MMC_MAX_CMDACK_POLLS    1024
#endif

#ifndef MMC_MAX_R1_POLLS

#define MMC_MAX_R1_POLLS        1024
#endif

typedef struct _MMCFCB {
    NUTDEVICE *fcb_fsdev;

    DOSPART fcb_part;

    uint32_t fcb_blknum;

    uint8_t fcb_blkbuf[MMC_BLOCK_SIZE];
} MMCFCB;

/*
 * Several routines call NutSleep, which results in a context switch.
 * This mutual exclusion semaphore takes care, that multiple threads
 * do not interfere with each other.
 */
static HANDLE mutex;

static void MmCardTxCmd(MMCIFC * ifc, uint8_t cmd, uint32_t param)
{
    unsigned int tmo = MMC_MAX_CMDACK_POLLS;
    uint8_t ch;

    /* Enable card select. */
    (*ifc->mmcifc_cs) (1);
    /*
     * Repeat sending nothing until we receive nothing. Actually
     * it should be sufficient to send a single 0xFF value, but
     * running a loop seems to fix certain kind of sync problems.
     */
    while ((ch = (*ifc->mmcifc_io) (0xFF)) != 0xFF) {
        if (--tmo == 0) {
#ifdef NUTDEBUG
            printf("[MMCmd%u Timeout %02X]\n", cmd, ch);
#endif
            break;
        }
        if (tmo < MMC_MAX_CMDACK_POLLS / 4) {
            NutSleep(1);
        }
    }
    /* Send command and parameter. */
    (*ifc->mmcifc_io) (MMCMD_HOST | cmd);
    (*ifc->mmcifc_io) ((uint8_t) (param >> 24));
    (*ifc->mmcifc_io) ((uint8_t) (param >> 16));
    (*ifc->mmcifc_io) ((uint8_t) (param >> 8));
    (*ifc->mmcifc_io) ((uint8_t) param);
    /*
     * We are running with CRC disabled. However, the reset command must
     * be send with a valid CRC. Fortunately this command is sent with a
     * fixed parameter value of zero, which results in a fixed CRC value
     */
    (*ifc->mmcifc_io) (MMCMD_RESET_CRC);
}

static uint8_t MmCardRxR1(MMCIFC * ifc)
{
    uint8_t rc;
    int i;

    for (i = 0; i < MMC_MAX_R1_POLLS; i++) {
        if ((rc = (*ifc->mmcifc_io) (0xFF)) != 0xFF) {
            break;
        }
    }
    return rc;
}

static uint16_t MmCardRxR2(MMCIFC * ifc)
{
    uint16_t rc;

    rc = MmCardRxR1(ifc);
    rc <<= 8;
    rc += (*ifc->mmcifc_io) (0xFF);

    return rc;
}

static uint8_t MmCardRxR3(MMCIFC * ifc, uint32_t * ocr)
{
    uint8_t rc;
    int i;

    /* The first byte is equal to the R1 response. */
    rc = MmCardRxR1(ifc);
    /* Receive the operating condition. */
    for (i = 0; i < 4; i++) {
        *ocr <<= 8;
        *ocr |= (*ifc->mmcifc_io) (0xFF);
    }
    return rc;
}

static int MmCardReset(MMCIFC * ifc)
{
    int i;
    uint8_t rsp;

    /*
     * Initialize the low level card interface.
     */
    if ((*ifc->mmcifc_in) ()) {
        return -1;
    }

    /*
     * 80 bits of ones with deactivated chip select will put the card 
     * in SPI mode.
     */
    (*ifc->mmcifc_cs) (0);
    for (i = 0; i < 10; i++) {
        (*ifc->mmcifc_io) (0xFF);
    }

    /*
     * Switch to idle state and wait until initialization is running
     * or idle state is reached.
     */
    for (i = 0; i < MMC_MAX_RESET_POLLS; i++) {
        MmCardTxCmd(ifc, MMCMD_GO_IDLE_STATE, 0);
        rsp = MmCardRxR1(ifc);
        (*ifc->mmcifc_cs) (0);
        if (rsp == MMR1_IDLE_STATE || rsp == MMR1_NOT_IDLE) {
            return 0;
        }
    }
    return -1;
}

static int MmCardInit(MMCIFC * ifc)
{
    int i;
    uint8_t rsp;

    /*
     * Try to switch to SPI mode. Looks like a retry helps to fix
     * certain synchronization problems.
     */
    if (MmCardReset(ifc)) {
        if (MmCardReset(ifc)) {
#ifdef NUTDEBUG
            printf("[CardReset failed]");
#endif
            return -1;
        }
    }

    /*
     * Wait for a really long time until card is initialized
     * and enters idle state.
     */
    for (i = 0; i < MMC_MAX_INIT_POLLS; i++) {
        /*
         * In SPI mode SEND_OP_COND is a dummy, used to poll the card
         * for initialization finished. Thus, there are no parameters
         * and no operation condition data is sent back.
         */
        MmCardTxCmd(ifc, MMCMD_SEND_OP_COND, 0);
        rsp = MmCardRxR1(ifc);
        (*ifc->mmcifc_cs) (0);
        if (rsp == MMR1_IDLE_STATE) {
#ifdef NUTDEBUG
            printf("[CardIdle]");
#endif
            /* Initialize MMC access mutex semaphore. */
            NutEventPost(&mutex);
            return 0;
        }
        if (i > MMC_MAX_INIT_POLLS / 4) {
            NutSleep(1);
        }
    }
#ifdef NUTDEBUG
    printf("[CardInit failed]");
#endif
    return -1;
}

static int MmCardReadOrVerify(MMCIFC * ifc, uint32_t blk, uint8_t * buf, int vflg)
{
    int rc = -1;
    int retries = 64;
    int i;
    uint8_t rsp;

    /* Gain mutex access. */
    NutEventWait(&mutex, 0);

    while (retries--) {
        MmCardTxCmd(ifc, MMCMD_READ_SINGLE_BLOCK, blk << 9);
        if ((rsp = MmCardRxR1(ifc)) == 0x00) {
            if ((rsp = MmCardRxR1(ifc)) == 0xFE) {
                rc = 0;
                if (vflg) {
                    for (i = 0; i < MMC_BLOCK_SIZE; i++) {
                        if (*buf != (*ifc->mmcifc_io) (0xFF)) {
                            rc = -1;
                        }
                        buf++;
                    }
                } else {
                    for (i = 0; i < MMC_BLOCK_SIZE; i++) {
                        *buf = (*ifc->mmcifc_io) (0xFF);
                        buf++;
                    }
                }
                (*ifc->mmcifc_io) (0xff);
                (*ifc->mmcifc_io) (0xff);
                (*ifc->mmcifc_cs) (0);
                break;
            }
        }
        (*ifc->mmcifc_cs) (0);
    }

    /* Release mutex access. */
    NutEventPost(&mutex);

    return rc;
}

static int MmCardWrite(MMCIFC * ifc, uint32_t blk, CONST uint8_t * buf)
{
    int rc = -1;
    int retries = MMC_MAX_WRITE_RETRIES;
    int tmo;
    int i;
    uint8_t rsp;

    /* Gain mutex access. */
    NutEventWait(&mutex, 0);

    while (retries--) {
        MmCardTxCmd(ifc, MMCMD_WRITE_BLOCK, blk << 9);
        if ((rsp = MmCardRxR1(ifc)) == 0x00) {
            (*ifc->mmcifc_io) (0xFF);
            (*ifc->mmcifc_io) (0xFE);
            for (i = 0; i < MMC_BLOCK_SIZE; i++) {
                (*ifc->mmcifc_io) (*buf);
                buf++;
            }
            // (*ifc->mmcifc_io)(0xFF);
            // (*ifc->mmcifc_io)(0xFF);
            if ((rsp = MmCardRxR1(ifc)) == 0xE5) {
                for (tmo = 0; tmo < MMC_MAX_WRITE_POLLS; tmo++) {
                    if ((*ifc->mmcifc_io) (0xFF) == 0xFF) {
                        break;
                    }
                    if (tmo > MMC_MAX_WRITE_POLLS - MMC_MAX_WRITE_POLLS / 32) {
                        NutSleep(1);
                    }
                }
                if (tmo) {
                    rc = 0;
                    break;
                }
#ifdef NUTDEBUG
                printf("[MMCWR Timeout]\n");
#endif
            }
        }
        (*ifc->mmcifc_cs) (0);
    }
    (*ifc->mmcifc_cs) (0);

    /* Release mutex access. */
    NutEventPost(&mutex);

    return rc;
}

int MmCardBlockRead(NUTFILE * nfp, void *buffer, int num)
{
    MMCFCB *fcb = (MMCFCB *) nfp->nf_fcb;
    uint32_t blk = fcb->fcb_blknum;
    NUTDEVICE *dev = (NUTDEVICE *) nfp->nf_dev;
    MMCIFC *ifc = (MMCIFC *) dev->dev_icb;

    if ((*ifc->mmcifc_cd) () != 1) {
        return -1;
    }
    if (buffer == 0) {
        buffer = fcb->fcb_blkbuf;
    }
    blk += fcb->fcb_part.part_sect_offs;

#ifdef MMC_VERIFY_AFTER
    {
        int i;
        /*
         * It would be much better to verify the checksum than to re-read
         * and verify the data block.
         */
        for (i = 0; i < MMC_MAX_READ_RETRIES; i++) {
            if (MmCardReadOrVerify(ifc, blk, buffer, 0) == 0) {
                if (MmCardReadOrVerify(ifc, blk, buffer, 1) == 0) {
                    return 1;
                }
            }
        }
    }
#else
    if (MmCardReadOrVerify(ifc, blk, buffer, 0) == 0) {
        return 1;
    }
#endif
    return -1;
}

int MmCardBlockWrite(NUTFILE * nfp, CONST void *buffer, int num)
{
    MMCFCB *fcb = (MMCFCB *) nfp->nf_fcb;
    uint32_t blk = fcb->fcb_blknum;
    NUTDEVICE *dev = (NUTDEVICE *) nfp->nf_dev;
    MMCIFC *ifc = (MMCIFC *) dev->dev_icb;

    if ((*ifc->mmcifc_cd) () != 1) {
        return -1;
    }
    if (buffer == 0) {
        buffer = fcb->fcb_blkbuf;
    }
    blk += fcb->fcb_part.part_sect_offs;

#ifdef MMC_VERIFY_AFTER
    {
        int i;

        for (i = 0; i < MMC_MAX_READ_RETRIES; i++) {
            if (MmCardWrite(ifc, blk, buffer) == 0) {
                if (MmCardReadOrVerify(ifc, blk, (void *) buffer, 1) == 0) {
                    return 1;
                }
                if (MmCardReadOrVerify(ifc, blk, (void *) buffer, 1) == 0) {
                    return 1;
                }
            }
        }
    }
#else
    if (MmCardWrite(ifc, blk, buffer) == 0) {
        return 1;
    }
#endif
    return -1;
}

#ifdef __HARVARD_ARCH__

int MmCardBlockWrite_P(NUTFILE * nfp, PGM_P buffer, int num)
{
    return -1;
}
#endif

NUTFILE *MmCardMount(NUTDEVICE * dev, CONST char *name, int mode, int acc)
{
    int partno = 0;
    int i;
    NUTDEVICE *fsdev;
    NUTFILE *nfp;
    MMCFCB *fcb;
    DOSPART *part;
    MMCIFC *ifc = (MMCIFC *) dev->dev_icb;
    FSCP_VOL_MOUNT mparm;

    /* Return an error if no card is detected. */
    if ((*ifc->mmcifc_cd) () == 0) {
        errno = ENODEV;
        return NUTFILE_EOF;
    }

    /* Set the card in SPI mode. */
    if (MmCardInit(ifc)) {
        errno = ENODEV;
        return NUTFILE_EOF;
    }

    /* Parse the name for a partition number and a file system driver. */
    if (*name) {
        partno = atoi(name);
        do {
            name++;
        } while (*name && *name != '/');
        if (*name == '/') {
            name++;
        }
    }

    /*
     * Check the list of registered devices for the given name of the
     * files system driver. If none has been specified, get the first
     * file system driver in the list. Hopefully the application
     * registered one only.
     */
    for (fsdev = nutDeviceList; fsdev; fsdev = fsdev->dev_next) {
        if (*name == 0) {
            if (fsdev->dev_type == IFTYP_FS) {
                break;
            }
        } else if (strcmp(fsdev->dev_name, name) == 0) {
            break;
        }
    }

    if (fsdev == 0) {
#ifdef NUTDEBUG
        printf("[No FSDriver]");
#endif
        errno = ENODEV;
        return NUTFILE_EOF;
    }

    if ((fcb = calloc(1, sizeof(MMCFCB))) == 0) {
        errno = ENOMEM;
        return NUTFILE_EOF;
    }
    fcb->fcb_fsdev = fsdev;

    /* Read MBR. */
    if (MmCardReadOrVerify(ifc, 0, fcb->fcb_blkbuf, 0)) {
        free(fcb);
        return NUTFILE_EOF;
    }
    /* Check for the cookie at the end of this sector. */
        if (fcb->fcb_blkbuf[DOSPART_MAGICPOS] != 0x55 || fcb->fcb_blkbuf[DOSPART_MAGICPOS + 1] != 0xAA) {
        free(fcb);
        return NUTFILE_EOF;
        }
    /* Check for the partition table. */
        if(fcb->fcb_blkbuf[DOSPART_TYPEPOS] == 'F' && 
       fcb->fcb_blkbuf[DOSPART_TYPEPOS + 1] == 'A' &&
       fcb->fcb_blkbuf[DOSPART_TYPEPOS + 2] == 'T') {
        /* No partition table. Assume FAT12 and 32MB size. */
        fcb->fcb_part.part_type = PTYPE_FAT12;
        fcb->fcb_part.part_sect_offs = 0;
        fcb->fcb_part.part_sects = 65536; /* How to find out? */
        }
    else {
        /* Read partition table. */
        part = (DOSPART *) & fcb->fcb_blkbuf[DOSPART_SECTORPOS];
        for (i = 1; i <= 4; i++) {
            if (partno) {
                if (i == partno) {
                    /* Found specified partition number. */
                    fcb->fcb_part = *part;
                    break;
                }
            } else if (part->part_state & 0x80) {
                /* Located first active partition. */
                fcb->fcb_part = *part;
                break;
            }
            part++;
        }

        if (fcb->fcb_part.part_type == PTYPE_EMPTY) {
            free(fcb);
            return NUTFILE_EOF;
        }
    }

    if ((nfp = NutHeapAlloc(sizeof(NUTFILE))) == 0) {
        free(fcb);
        errno = ENOMEM;
        return NUTFILE_EOF;
    }
    nfp->nf_next = 0;
    nfp->nf_dev = dev;
    nfp->nf_fcb = fcb;

    /*
     * Mount the file system volume.
     */
    mparm.fscp_bmnt = nfp;
    mparm.fscp_part_type = fcb->fcb_part.part_type;
    if (fsdev->dev_ioctl(fsdev, FS_VOL_MOUNT, &mparm)) {
        MmCardUnmount(nfp);
        return NUTFILE_EOF;
    }
    return nfp;
}

int MmCardUnmount(NUTFILE * nfp)
{
    int rc = -1;

    if (nfp) {
        MMCFCB *fcb = (MMCFCB *) nfp->nf_fcb;

        if (fcb) {
            NUTDEVICE *dev = (NUTDEVICE *) nfp->nf_dev;
            MMCIFC *ifc = (MMCIFC *) dev->dev_icb;

            if ((*ifc->mmcifc_cd) () == 1) {
                rc = fcb->fcb_fsdev->dev_ioctl(fcb->fcb_fsdev, FS_VOL_UNMOUNT, NULL);
            }
            free(fcb);
        }
        free(nfp);
    }
    return rc;
}

static int MmCardGetReg(MMCIFC * ifc, uint8_t cmd, uint8_t * rbp, int siz)
{
    int rc = -1;
    int retries = MMC_MAX_REG_POLLS;
    int i;

    /* Gain mutex access. */
    NutEventWait(&mutex, 0);

    while (retries--) {
        /* Send the command to the card. This will select the card. */
        MmCardTxCmd(ifc, cmd, 0);
        /* Wait for OK response from the card. */
        if (MmCardRxR1(ifc) == 0x00) {
            /* Wait for data from the card. */
            if (MmCardRxR1(ifc) == 0xFE) {
                for (i = 0; i < siz; i++) {
                    *rbp++ = (*ifc->mmcifc_io) (0xFF);
                }
                /* Ignore the CRC. */
                (*ifc->mmcifc_io) (0xFF);
                (*ifc->mmcifc_io) (0xFF);
                /* De-activate card selection. */
                (*ifc->mmcifc_cs) (0);
                /* Return a positive result. */
                rc = 0;
                break;
            }
        }
        /* De-activate card selection. */
        (*ifc->mmcifc_cs) (0);
    }

    /* Release mutex access. */
    NutEventPost(&mutex);

    return rc;
}

int MmCardIOCtl(NUTDEVICE * dev, int req, void *conf)
{
    int rc = 0;
    MMCIFC *ifc = (MMCIFC *) dev->dev_icb;

    switch (req) {
    case NUTBLKDEV_MEDIAAVAIL:
        {
            int *flg = (int *) conf;
            *flg = (*ifc->mmcifc_cd) ();
        }
        break;
    case NUTBLKDEV_MEDIACHANGE:
        {
            int *flg = (int *) conf;
            if ((*ifc->mmcifc_cd) () != 1) {
                *flg = 1;
            } else {
                *flg = 0;
            }
        }
        break;
    case NUTBLKDEV_INFO:
        {
            BLKPAR_INFO *par = (BLKPAR_INFO *) conf;
            MMCFCB *fcb = (MMCFCB *) par->par_nfp->nf_fcb;

            par->par_nblks = fcb->fcb_part.part_sects;
            par->par_blksz = MMC_BLOCK_SIZE;
            par->par_blkbp = fcb->fcb_blkbuf;
        }
        break;
    case NUTBLKDEV_SEEK:
        {
            BLKPAR_SEEK *par = (BLKPAR_SEEK *) conf;
            MMCFCB *fcb = (MMCFCB *) par->par_nfp->nf_fcb;

            fcb->fcb_blknum = par->par_blknum;
        }
        break;
    case MMCARD_GETSTATUS:
        {
            uint16_t *s = (uint16_t *) conf;

            /* Gain mutex access. */
            NutEventWait(&mutex, 0);

            MmCardTxCmd(ifc, MMCMD_SEND_STATUS, 0);
            *s = MmCardRxR2(ifc);

            /* Release mutex access. */
            NutEventPost(&mutex);
        }
        break;
    case MMCARD_GETOCR:
        /* Gain mutex access. */
        NutEventWait(&mutex, 0);

        MmCardTxCmd(ifc, MMCMD_READ_OCR, 0);
        if (MmCardRxR3(ifc, (uint32_t *) conf) != MMR1_IDLE_STATE) {
            rc = -1;
        }

        /* Release mutex access. */
        NutEventPost(&mutex);
        break;
    case MMCARD_GETCID:
        rc = MmCardGetReg(ifc, MMCMD_SEND_CID, (uint8_t *) conf, sizeof(MMC_CID));
        break;
    case MMCARD_GETCSD:
        rc = MmCardGetReg(ifc, MMCMD_SEND_CSD, (uint8_t *) conf, sizeof(MMC_CSD));
        break;
    default:
        rc = -1;
        break;
    }
    return rc;
}

int MmCardDevInit(NUTDEVICE * dev)
{
    return 0;
}