URL https://opencores.org/ocsvn/sd_card_controller/sd_card_controller/trunk
Subversion Repositories sd_card_controller

[/] [sd_card_controller/] [trunk/] [sw/] [example/] [src/] [mmc.c] - Blame information for rev 3

Details | Compare with Previous | View Log

/*
 * Copyright 2008, Freescale Semiconductor, Inc
 * Andy Fleming
 *
 * Based vaguely on the Linux code
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * 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
 */
 
#include "mmc.h"
#include <stdio.h>
#include <string.h>
 
void udelay(int t) {
#define US_DELAY 100
        volatile int us = US_DELAY;
        while(t--) {
                us = US_DELAY;
                while(us--);
        }
}
 
/* frequency bases */
/* divided by 10 to be nice to platforms without floating point */
static const int fbase[] = {
        10000,
        100000,
        1000000,
        10000000,
};
 
/* Multiplier values for TRAN_SPEED.  Multiplied by 10 to be nice
 * to platforms without floating point.
 */
static const int multipliers[] = {
        0,       /* reserved */
        10,
        12,
        13,
        15,
        20,
        25,
        30,
        35,
        40,
        45,
        50,
        55,
        60,
        70,
        80,
};
 
static void mmc_set_ios(struct mmc *mmc)
{
        mmc->set_ios(mmc);
}
 
static void mmc_set_bus_width(struct mmc *mmc, uint width)
{
        mmc->bus_width = width;
 
        mmc_set_ios(mmc);
}
 
static void mmc_set_clock(struct mmc *mmc, uint clock)
{
        if (clock > mmc->f_max)
                clock = mmc->f_max;
 
        if (clock < mmc->f_min)
                clock = mmc->f_min;
 
        mmc->clock = clock;
 
        mmc_set_ios(mmc);
}
 
static int mmc_send_cmd(struct mmc *mmc, struct mmc_cmd *cmd, struct mmc_data *data)
{
        int ret;
 
        ret = mmc->send_cmd(mmc, cmd, data);
 
        return ret;
}
 
static int mmc_go_idle(struct mmc* mmc)
{
        struct mmc_cmd cmd;
        int err;
 
        udelay(1000);
 
        cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
        cmd.cmdarg = 0;
        cmd.resp_type = MMC_RSP_NONE;
 
        err = mmc_send_cmd(mmc, &cmd, NULL);
 
        if (err)
                return err;
 
        udelay(2000);
 
        return 0;
}
 
static int mmc_send_if_cond(struct mmc *mmc)
{
        struct mmc_cmd cmd;
        int err;
 
        cmd.cmdidx = SD_CMD_SEND_IF_COND;
        /* We set the bit if the host supports voltages between 2.7 and 3.6 V */
        cmd.cmdarg = ((mmc->voltages & 0xff8000) != 0) << 8 | 0xaa;
        cmd.resp_type = MMC_RSP_R7;
 
        err = mmc_send_cmd(mmc, &cmd, NULL);
 
        if (err)
                return err;
 
        if ((cmd.response[0] & 0xff) != 0xaa)
                return UNUSABLE_ERR;
        else
                mmc->version = SD_VERSION_2;
 
        return 0;
}
 
static int sd_send_op_cond(struct mmc *mmc)
{
        int timeout = 1000;
        int err;
        struct mmc_cmd cmd;
 
        do {
                cmd.cmdidx = MMC_CMD_APP_CMD;
                cmd.resp_type = MMC_RSP_R1;
                cmd.cmdarg = 0;
 
                err = mmc_send_cmd(mmc, &cmd, NULL);
 
                if (err)
                        return err;
 
                cmd.cmdidx = SD_CMD_APP_SEND_OP_COND;
                cmd.resp_type = MMC_RSP_R3;
 
                /*
                 * Most cards do not answer if some reserved bits
                 * in the ocr are set. However, Some controller
                 * can set bit 7 (reserved for low voltages), but
                 * how to manage low voltages SD card is not yet
                 * specified.
                 */
                cmd.cmdarg = (mmc->voltages & 0xff8000);
 
                if (mmc->version == SD_VERSION_2)
                        cmd.cmdarg |= OCR_HCS;
 
                err = mmc_send_cmd(mmc, &cmd, NULL);
 
                if (err)
                        return err;
 
                udelay(1000);
        } while ((!(cmd.response[0] & OCR_BUSY)) && timeout--);
 
        if (timeout <= 0)
                return UNUSABLE_ERR;
 
        if (mmc->version != SD_VERSION_2)
                mmc->version = SD_VERSION_1_0;
 
        mmc->ocr = cmd.response[0];
 
        mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
        mmc->rca = 0;
 
        return 0;
}
 
static int mmc_send_op_cond(struct mmc *mmc)
{
        int timeout = 10000;
        struct mmc_cmd cmd;
        int err;
 
        /* Some cards seem to need this */
        mmc_go_idle(mmc);
 
        /* Asking to the card its capabilities */
        cmd.cmdidx = MMC_CMD_SEND_OP_COND;
        cmd.resp_type = MMC_RSP_R3;
        cmd.cmdarg = 0;
 
        err = mmc_send_cmd(mmc, &cmd, NULL);
 
        if (err)
                return err;
 
        udelay(1000);
 
        do {
                cmd.cmdidx = MMC_CMD_SEND_OP_COND;
                cmd.resp_type = MMC_RSP_R3;
                cmd.cmdarg =
                                (mmc->voltages &
                                (cmd.response[0] & OCR_VOLTAGE_MASK)) |
                                (cmd.response[0] & OCR_ACCESS_MODE);
 
                if (mmc->host_caps & MMC_MODE_HC)
                        cmd.cmdarg |= OCR_HCS;
 
                err = mmc_send_cmd(mmc, &cmd, NULL);
 
                if (err)
                        return err;
 
                udelay(1000);
        } while (!(cmd.response[0] & OCR_BUSY) && timeout--);
 
        if (timeout <= 0)
                return UNUSABLE_ERR;
 
        mmc->version = MMC_VERSION_UNKNOWN;
        mmc->ocr = cmd.response[0];
 
        mmc->high_capacity = ((mmc->ocr & OCR_HCS) == OCR_HCS);
        mmc->rca = 0;
 
        return 0;
}
 
static int mmc_send_status(struct mmc *mmc, int timeout)
{
        struct mmc_cmd cmd;
        int err, retries = 5;
 
        cmd.cmdidx = MMC_CMD_SEND_STATUS;
        cmd.resp_type = MMC_RSP_R1;
        cmd.cmdarg = mmc->rca << 16;
 
        do {
                err = mmc_send_cmd(mmc, &cmd, NULL);
                if (!err) {
                        if ((cmd.response[0] & MMC_STATUS_RDY_FOR_DATA) &&
                            (cmd.response[0] & MMC_STATUS_CURR_STATE) !=
                             MMC_STATE_PRG)
                                break;
                        else if (cmd.response[0] & MMC_STATUS_MASK) {
                                printf("Status Error: 0x%08X\n\r",
                                        cmd.response[0]);
                                return COMM_ERR;
                        }
                } else if (--retries < 0)
                        return err;
 
                udelay(1000);
 
        } while (timeout--);
 
        if (timeout <= 0) {
                printf("Timeout waiting card ready\n\r");
                return TIMEOUT;
        }
 
        return 0;
}
 
static int mmc_send_ext_csd(struct mmc *mmc, char *ext_csd)
{
        struct mmc_cmd cmd;
        struct mmc_data data;
        int err;
 
        /* Get the Card Status Register */
        cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
        cmd.resp_type = MMC_RSP_R1;
        cmd.cmdarg = 0;
 
        data.dest = (char *)ext_csd;
        data.blocks = 1;
        data.blocksize = 512;
        data.flags = MMC_DATA_READ;
 
        err = mmc_send_cmd(mmc, &cmd, &data);
 
        return err;
}
 
static int mmc_switch(struct mmc *mmc, char set, char index, char value)
{
        struct mmc_cmd cmd;
        int timeout = 1000;
        int ret;
 
        cmd.cmdidx = MMC_CMD_SWITCH;
        cmd.resp_type = MMC_RSP_R1b;
        cmd.cmdarg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) |
                                 (index << 16) |
                                 (value << 8);
 
        ret = mmc_send_cmd(mmc, &cmd, NULL);
 
        /* Waiting for the ready status */
        if (!ret)
                ret = mmc_send_status(mmc, timeout);
 
        return ret;
 
}
 
static int sd_switch(struct mmc *mmc, int mode, int group, char value, char *resp)
{
        struct mmc_cmd cmd;
        struct mmc_data data;
 
        /* Switch the frequency */
        cmd.cmdidx = SD_CMD_SWITCH_FUNC;
        cmd.resp_type = MMC_RSP_R1;
        cmd.cmdarg = (mode << 31) | 0xffffff;
        cmd.cmdarg &= ~(0xf << (group * 4));
        cmd.cmdarg |= value << (group * 4);
 
        data.dest = (char *)resp;
        data.blocksize = 64;
        data.blocks = 1;
        data.flags = MMC_DATA_READ;
 
        return mmc_send_cmd(mmc, &cmd, &data);
}
 
static int sd_change_freq(struct mmc *mmc)
{
        int err;
        struct mmc_cmd cmd;
        uint scr[2];
        uint switch_status[16];
        struct mmc_data data;
        int timeout;
 
        mmc->card_caps = 0;
 
        /* Read the SCR to find out if this card supports higher speeds */
        cmd.cmdidx = MMC_CMD_APP_CMD;
        cmd.resp_type = MMC_RSP_R1;
        cmd.cmdarg = mmc->rca << 16;
 
        err = mmc_send_cmd(mmc, &cmd, NULL);
 
        if (err)
                return err;
 
        cmd.cmdidx = SD_CMD_APP_SEND_SCR;
        cmd.resp_type = MMC_RSP_R1;
        cmd.cmdarg = 0;
 
        timeout = 3;
 
retry_scr:
        data.dest = (char *)scr;
        data.blocksize = 8;
        data.blocks = 1;
        data.flags = MMC_DATA_READ;
 
        err = mmc_send_cmd(mmc, &cmd, &data);
 
        if (err) {
                if (timeout--)
                        goto retry_scr;
 
                return err;
        }
 
        mmc->scr[0] = scr[0];
        mmc->scr[1] = scr[1];
 
        printf("SCR: %08x\n\r", mmc->scr[0]);
        printf("     %08x\n\r", mmc->scr[1]);
 
        switch ((mmc->scr[0] >> 24) & 0xf) {
                case 0:
                        mmc->version = SD_VERSION_1_0;
                        break;
                case 1:
                        mmc->version = SD_VERSION_1_10;
                        break;
                case 2:
                        mmc->version = SD_VERSION_2;
                        break;
                default:
                        mmc->version = SD_VERSION_1_0;
                        break;
        }
 
        if (mmc->scr[0] & SD_DATA_4BIT)
                mmc->card_caps |= MMC_MODE_4BIT;
 
        /* Version 1.0 doesn't support switching */
        if (mmc->version == SD_VERSION_1_0)
                return 0;
 
        timeout = 4;
        while (timeout--) {
                err = sd_switch(mmc, SD_SWITCH_CHECK, 0, 1,
                                (char *)switch_status);
 
                if (err)
                        return err;
 
                printf("switch status 7 %08x\n\r", switch_status[7]);
                printf("switch status 3 %08x\n\r", switch_status[3]);
                printf("switch status 4 %08x\n\r", switch_status[4]);
                /* The high-speed function is busy.  Try again */
                if (!(switch_status[7] & SD_HIGHSPEED_BUSY))
                        break;
        }
 
        /* If high-speed isn't supported, we return */
        if (!(switch_status[3] & SD_HIGHSPEED_SUPPORTED))
                return 0;
 
        /*
         * If the host doesn't support SD_HIGHSPEED, do not switch card to
         * HIGHSPEED mode even if the card support SD_HIGHSPPED.
         * This can avoid furthur problem when the card runs in different
         * mode between the host.
         */
        if (!((mmc->host_caps & MMC_MODE_HS_52MHz) &&
                (mmc->host_caps & MMC_MODE_HS)))
                return 0;
 
        err = sd_switch(mmc, SD_SWITCH_SWITCH, 0, 1, (char *)switch_status);
 
        if (err)
                return err;
 
        if ((switch_status[4] & 0x0f000000) == 0x01000000)
                mmc->card_caps |= MMC_MODE_HS;
 
        return 0;
}
 
static int mmc_change_freq(struct mmc *mmc)
{
        char ext_csd[512];
        char cardtype;
        int err;
 
        mmc->card_caps = 0;
 
        /* Only version 4 supports high-speed */
        if (mmc->version < MMC_VERSION_4)
                return 0;
 
        err = mmc_send_ext_csd(mmc, ext_csd);
 
        if (err)
                return err;
 
        cardtype = ext_csd[EXT_CSD_CARD_TYPE] & 0xf;
 
        err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, 1);
 
        if (err)
                return err;
 
        /* Now check to see that it worked */
        err = mmc_send_ext_csd(mmc, ext_csd);
 
        if (err)
                return err;
 
        /* No high-speed support */
        if (!ext_csd[EXT_CSD_HS_TIMING])
                return 0;
 
        /* High Speed is set, there are two types: 52MHz and 26MHz */
        if (cardtype & MMC_HS_52MHZ)
                mmc->card_caps |= MMC_MODE_HS_52MHz | MMC_MODE_HS;
        else
                mmc->card_caps |= MMC_MODE_HS;
 
        return 0;
}
 
static int mmc_startup(struct mmc *mmc)
{
        int err, width;
        uint mult, freq;
        uint cmult, csize, capacity;
        struct mmc_cmd cmd;
        char ext_csd[512];
        char test_csd[512];
        int timeout = 1000;
 
        /* Put the Card in Identify Mode */
        cmd.cmdidx = MMC_CMD_ALL_SEND_CID; /* cmd not supported in spi */
        cmd.resp_type = MMC_RSP_R2;
        cmd.cmdarg = 0;
 
        err = mmc_send_cmd(mmc, &cmd, NULL);
 
        if (err)
                return err;
 
        memcpy(mmc->cid, cmd.response, 16);
 
        /*
         * For MMC cards, set the Relative Address.
         * For SD cards, get the Relatvie Address.
         * This also puts the cards into Standby State
         */
        cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
        cmd.cmdarg = mmc->rca << 16;
        cmd.resp_type = MMC_RSP_R6;
 
        err = mmc_send_cmd(mmc, &cmd, NULL);
 
        if (err)
                return err;
 
        if (IS_SD(mmc))
                mmc->rca = (cmd.response[0] >> 16) & 0xffff;
 
        /* Get the Card-Specific Data */
        cmd.cmdidx = MMC_CMD_SEND_CSD;
        cmd.resp_type = MMC_RSP_R2;
        cmd.cmdarg = mmc->rca << 16;
 
        err = mmc_send_cmd(mmc, &cmd, NULL);
 
        /* Waiting for the ready status */
        mmc_send_status(mmc, timeout);
 
        if (err)
                return err;
 
        mmc->csd[0] = cmd.response[0];
        mmc->csd[1] = cmd.response[1];
        mmc->csd[2] = cmd.response[2];
        mmc->csd[3] = cmd.response[3];
 
        if (mmc->version == MMC_VERSION_UNKNOWN) {
                int version = (cmd.response[0] >> 26) & 0xf;
 
                switch (version) {
                        case 0:
                                mmc->version = MMC_VERSION_1_2;
                                break;
                        case 1:
                                mmc->version = MMC_VERSION_1_4;
                                break;
                        case 2:
                                mmc->version = MMC_VERSION_2_2;
                                break;
                        case 3:
                                mmc->version = MMC_VERSION_3;
                                break;
                        case 4:
                                mmc->version = MMC_VERSION_4;
                                break;
                        default:
                                mmc->version = MMC_VERSION_1_2;
                                break;
                }
        }
 
        /* divide frequency by 10, since the mults are 10x bigger */
        freq = fbase[(cmd.response[0] & 0x7)];
        mult = multipliers[((cmd.response[0] >> 3) & 0xf)];
 
        mmc->tran_speed = freq * mult;
 
        mmc->read_bl_len = 1 << ((cmd.response[1] >> 16) & 0xf);
 
        if (IS_SD(mmc))
                mmc->write_bl_len = mmc->read_bl_len;
        else
                mmc->write_bl_len = 1 << ((cmd.response[3] >> 22) & 0xf);
 
        if (mmc->high_capacity) {
                csize = (mmc->csd[1] & 0x3f) << 16
                        | (mmc->csd[2] & 0xffff0000) >> 16;
                cmult = 8;
        } else {
                csize = (mmc->csd[1] & 0x3ff) << 2
                        | (mmc->csd[2] & 0xc0000000) >> 30;
                cmult = (mmc->csd[2] & 0x00038000) >> 15;
        }
 
        mmc->capacity = (csize + 1) << (cmult + 2);
        mmc->capacity *= mmc->read_bl_len;
 
        if (mmc->read_bl_len > 512)
                mmc->read_bl_len = 512;
 
        if (mmc->write_bl_len > 512)
                mmc->write_bl_len = 512;
 
        /* Select the card, and put it into Transfer Mode */
        cmd.cmdidx = MMC_CMD_SELECT_CARD;
        cmd.resp_type = MMC_RSP_R1;
        cmd.cmdarg = mmc->rca << 16;
        err = mmc_send_cmd(mmc, &cmd, NULL);
 
        if (err)
                return err;
 
        /*
         * For SD, its erase group is always one sector
         */
        mmc->erase_grp_size = 1;
        mmc->part_config = MMCPART_NOAVAILABLE;
        if (!IS_SD(mmc) && (mmc->version >= MMC_VERSION_4)) {
                /* check  ext_csd version and capacity */
                err = mmc_send_ext_csd(mmc, ext_csd);
                if (!err & (ext_csd[EXT_CSD_REV] >= 2)) {
                        /*
                         * According to the JEDEC Standard, the value of
                         * ext_csd's capacity is valid if the value is more
                         * than 2GB
                         */
                        capacity = ext_csd[EXT_CSD_SEC_CNT] << 0
                                        | ext_csd[EXT_CSD_SEC_CNT + 1] << 8
                                        | ext_csd[EXT_CSD_SEC_CNT + 2] << 16
                                        | ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
                        capacity *= 512;
                        if ((capacity >> 20) > 2 * 1024)
                                mmc->capacity = capacity;
                }
 
                /*
                 * Check whether GROUP_DEF is set, if yes, read out
                 * group size from ext_csd directly, or calculate
                 * the group size from the csd value.
                 */
                if (ext_csd[EXT_CSD_ERASE_GROUP_DEF])
                        mmc->erase_grp_size =
                              ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] * 512 * 1024;
                else {
                        int erase_gsz, erase_gmul;
                        erase_gsz = (mmc->csd[2] & 0x00007c00) >> 10;
                        erase_gmul = (mmc->csd[2] & 0x000003e0) >> 5;
                        mmc->erase_grp_size = (erase_gsz + 1)
                                * (erase_gmul + 1);
                }
 
                /* store the partition info of emmc */
                if ((ext_csd[EXT_CSD_PARTITIONING_SUPPORT] & PART_SUPPORT) ||
                    ext_csd[EXT_CSD_BOOT_MULT])
                        mmc->part_config = ext_csd[EXT_CSD_PART_CONF];
        }
 
        if (IS_SD(mmc))
                err = sd_change_freq(mmc);
        else
                err = mmc_change_freq(mmc);
 
        if (err)
                return err;
 
        /* Restrict card's capabilities by what the host can do */
        mmc->card_caps &= mmc->host_caps;
 
        if (IS_SD(mmc)) {
                if (mmc->card_caps & MMC_MODE_4BIT) {
                        cmd.cmdidx = MMC_CMD_APP_CMD;
                        cmd.resp_type = MMC_RSP_R1;
                        cmd.cmdarg = mmc->rca << 16;
 
                        err = mmc_send_cmd(mmc, &cmd, NULL);
                        if (err)
                                return err;
 
                        cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
                        cmd.resp_type = MMC_RSP_R1;
                        cmd.cmdarg = 2;
                        err = mmc_send_cmd(mmc, &cmd, NULL);
                        if (err)
                                return err;
 
                        mmc_set_bus_width(mmc, 4);
                }
 
                if (mmc->card_caps & MMC_MODE_HS)
                        mmc->tran_speed = 50000000;
                else
                        mmc->tran_speed = 25000000;
        } else {
                width = ((mmc->host_caps & MMC_MODE_MASK_WIDTH_BITS) >>
                         MMC_MODE_WIDTH_BITS_SHIFT);
                for (; width >= 0; width--) {
                        /* Set the card to use 4 bit*/
                        err = mmc_switch(mmc, EXT_CSD_CMD_SET_NORMAL,
                                        EXT_CSD_BUS_WIDTH, width);
 
                        if (err)
                                continue;
 
                        if (!width) {
                                mmc_set_bus_width(mmc, 1);
                                break;
                        } else
                                mmc_set_bus_width(mmc, 4 * width);
 
                        err = mmc_send_ext_csd(mmc, test_csd);
                        if (!err && ext_csd[EXT_CSD_PARTITIONING_SUPPORT] \
                                    == test_csd[EXT_CSD_PARTITIONING_SUPPORT]
                                 && ext_csd[EXT_CSD_ERASE_GROUP_DEF] \
                                    == test_csd[EXT_CSD_ERASE_GROUP_DEF] \
                                 && ext_csd[EXT_CSD_REV] \
                                    == test_csd[EXT_CSD_REV]
                                 && ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] \
                                    == test_csd[EXT_CSD_HC_ERASE_GRP_SIZE]
                                 && memcmp(&ext_csd[EXT_CSD_SEC_CNT], \
                                        &test_csd[EXT_CSD_SEC_CNT], 4) == 0) {
 
                                mmc->card_caps |= width;
                                break;
                        }
                }
 
                if (mmc->card_caps & MMC_MODE_HS) {
                        if (mmc->card_caps & MMC_MODE_HS_52MHz)
                                mmc->tran_speed = 52000000;
                        else
                                mmc->tran_speed = 26000000;
                }
        }
 
        mmc_set_clock(mmc, mmc->tran_speed);
 
        return 0;
}
 
static int mmc_set_blocklen(struct mmc *mmc, int len)
{
        struct mmc_cmd cmd;
 
        cmd.cmdidx = MMC_CMD_SET_BLOCKLEN;
        cmd.resp_type = MMC_RSP_R1;
        cmd.cmdarg = len;
 
        return mmc_send_cmd(mmc, &cmd, NULL);
}
 
static int mmc_read_blocks(struct mmc *mmc, void *dst, size_t start, size_t blkcnt)
{
        struct mmc_cmd cmd;
        struct mmc_data data;
 
        if (blkcnt > 1)
                cmd.cmdidx = MMC_CMD_READ_MULTIPLE_BLOCK;
        else
                cmd.cmdidx = MMC_CMD_READ_SINGLE_BLOCK;
 
        if (mmc->high_capacity)
                cmd.cmdarg = start;
        else
                cmd.cmdarg = start * mmc->read_bl_len;
 
        cmd.resp_type = MMC_RSP_R1;
 
        data.dest = dst;
        data.blocks = blkcnt;
        data.blocksize = mmc->read_bl_len;
        data.flags = MMC_DATA_READ;
 
        if (mmc_send_cmd(mmc, &cmd, &data))
                return 0;
 
        if (blkcnt > 1) {
                cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
                cmd.cmdarg = 0;
                cmd.resp_type = MMC_RSP_R1b;
                if (mmc_send_cmd(mmc, &cmd, NULL)) {
                        printf("mmc fail to send stop cmd\n");
                        return 0;
                }
        }
 
        return blkcnt;
}
 
int mmc_init(struct mmc *mmc)
{
        int err;
 
        if (mmc->has_init)
                return 0;
 
        err = mmc->init(mmc);
 
        if (err)
                return err;
 
        mmc_set_bus_width(mmc, 1);
        mmc_set_clock(mmc, 1);
 
        /* Reset the Card */
        err = mmc_go_idle(mmc);
 
        if (err)
                return err;
 
        /* The internal partition reset to user partition(0) at every CMD0*/
        mmc->part_num = 0;
 
        /* Test for SD version 2 */
        err = mmc_send_if_cond(mmc);
 
        /* Now try to get the SD card's operating condition */
        err = sd_send_op_cond(mmc);
 
        /* If the command timed out, we check for an MMC card */
        if (err == TIMEOUT) {
                err = mmc_send_op_cond(mmc);
 
                if (err) {
                        printf("Card did not respond to voltage select!\n\r");
                        return UNUSABLE_ERR;
                }
        }
 
        err = mmc_startup(mmc);
        if (err)
                mmc->has_init = 0;
        else
                mmc->has_init = 1;
        return err;
}
 
size_t mmc_bread(struct mmc *mmc, size_t start, size_t blkcnt, void *dst)
{
        size_t cur, blocks_todo = blkcnt;
 
        if (blkcnt == 0)
                return 0;
 
        if ((start + blkcnt) > mmc->capacity / mmc->read_bl_len) {
                printf("MMC: block number 0x%lx exceeds max(0x%lx)\n",
                        start + blkcnt, mmc->capacity / mmc->read_bl_len);
                return 0;
        }
 
        if (mmc_set_blocklen(mmc, mmc->read_bl_len))
                return 0;
 
        do {
                cur = (blocks_todo > mmc->b_max) ?  mmc->b_max : blocks_todo;
                if(mmc_read_blocks(mmc, dst, start, cur) != cur)
                        return 0;
                blocks_todo -= cur;
                start += cur;
                dst += cur * mmc->read_bl_len;
        } while (blocks_todo > 0);
 
        return blkcnt;
}
 
void print_mmcinfo(struct mmc *mmc)
{
        printf("Device: %s\n\r", mmc->name);
        printf("Manufacturer ID: %x\n\r", mmc->cid[0] >> 24);
        printf("OEM: %x\n\r", (mmc->cid[0] >> 8) & 0xffff);
        printf("Name: %c%c%c%c%c \n\r", mmc->cid[0] & 0xff,
                        (mmc->cid[1] >> 24), (mmc->cid[1] >> 16) & 0xff,
                        (mmc->cid[1] >> 8) & 0xff, mmc->cid[1] & 0xff);
 
        printf("Tran Speed: %d\n\r", mmc->tran_speed);
        printf("Rd Block Len: %d\n\r", mmc->read_bl_len);
 
        printf("%s version %d.%d\n\r", IS_SD(mmc) ? "SD" : "MMC",
                        (mmc->version >> 4) & 0xf, mmc->version & 0xf);
 
        printf("High Capacity: %s\n\r", mmc->high_capacity ? "Yes" : "No");
        printf("Capacity: %ld\n\r", mmc->capacity);
 
        printf("Bus Width: %d-bit\n\r", mmc->bus_width);
}
 
 
 
Browse

Tools

Subversion Repositories sd_card_controller

[/] [sd_card_controller/] [trunk/] [sw/] [example/] [src/] [mmc.c] - Blame information for rev 3

Line No.	Rev	Author	Line
1	3	rozpruwacz	`/*`
2			`* Copyright 2008, Freescale Semiconductor, Inc`
3			`* Andy Fleming`
4			`*`
5			`* Based vaguely on the Linux code`
6			`*`
7			`* See file CREDITS for list of people who contributed to this`
8			`* project.`
9			`*`
10			`* This program is free software; you can redistribute it and/or`
11			`* modify it under the terms of the GNU General Public License as`
12			`* published by the Free Software Foundation; either version 2 of`
13			`* the License, or (at your option) any later version.`
14			`*`
15			`* This program is distributed in the hope that it will be useful,`
16			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
17			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
18			`* GNU General Public License for more details.`
19			`*`
20			`* You should have received a copy of the GNU General Public License`
21			`* along with this program; if not, write to the Free Software`
22			`* Foundation, Inc., 59 Temple Place, Suite 330, Boston,`
23			`* MA 02111-1307 USA`
24			`*/`
25
26			`#include "mmc.h"`
27			`#include <stdio.h>`
28			`#include <string.h>`
29
30			`void udelay(int t) {`
31			`#define US_DELAY 100`
32			`volatile int us = US_DELAY;`
33			`while(t--) {`
34			`us = US_DELAY;`
35			`while(us--);`
36			`}`
37			`}`
38
39			`/* frequency bases */`
40			`/* divided by 10 to be nice to platforms without floating point */`