sd_mmc.c

Go to the documentation of this file.

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * MultiMediaCard (MMC), eMMC and Secure Digital (SD) common initialization
 * code which brings the card into the standby state.  This code is controller
 * independent.
 */
 
#include <commonlib/storage.h>
#include <delay.h>
#include <endian.h>
#include <string.h>
 
#include "mmc.h"
#include "sd_mmc.h"
#include "storage.h"
 
uint64_t sd_mmc_extract_uint32_bits(const uint32_t *array, int start, int count)
{
        int i;
        uint64_t value = 0;
 
        for (i = 0; i < count; i++, start++) {
                value <<= 1;
                value |= (array[start / 32] >> (31 - (start % 32))) & 0x1;
        }
        return value;
}
 
static uint32_t sd_mmc_calculate_transfer_speed(uint32_t csd0)
{
        uint32_t mult, freq;
 
        /* 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,
        };
 
        /* divide frequency by 10, since the mults are 10x bigger */
        freq = fbase[csd0 & 0x7];
        mult = multipliers[(csd0 >> 3) & 0xf];
        return freq * mult;
}
 
int sd_mmc_go_idle(struct storage_media *media)
{
        struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 
        // Some cards can't accept idle commands without delay.
        if (ctrlr->mdelay_before_cmd0)
                mdelay(ctrlr->mdelay_before_cmd0);
 
        struct mmc_command cmd;
        cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
        cmd.cmdarg = 0;
        cmd.resp_type = CARD_RSP_NONE;
        cmd.flags = 0;
 
        int err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
        if (err)
                return err;
 
        // Some cards need more than half second to respond to next command (ex,
        // SEND_OP_COND).
        if (ctrlr->mdelay_after_cmd0)
                mdelay(ctrlr->mdelay_after_cmd0);
 
        return 0;
}
 
int sd_mmc_send_status(struct storage_media *media, ssize_t tries)
{
        struct mmc_command cmd;
        struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 
        cmd.cmdidx = MMC_CMD_SEND_STATUS;
        cmd.resp_type = CARD_RSP_R1;
        cmd.cmdarg = media->rca << 16;
        cmd.flags = 0;
 
        while (tries--) {
                int err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
                if (err)
                        return err;
                else if (cmd.response[0] & MMC_STATUS_RDY_FOR_DATA)
                        break;
                else if (cmd.response[0] & MMC_STATUS_MASK) {
                        sd_mmc_error("Status Error: %#8.8x\n", cmd.response[0]);
                        return CARD_COMM_ERR;
                }
 
                udelay(100);
        }
 
        sd_mmc_trace("CURR STATE:%d\n",
                  (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9);
 
        if (tries < 0) {
                sd_mmc_error("Timeout waiting card ready\n");
                return CARD_TIMEOUT;
        }
        return 0;
}
 
int sd_mmc_set_blocklen(struct sd_mmc_ctrlr *ctrlr, int len)
{
        struct mmc_command cmd;
        cmd.cmdidx = MMC_CMD_SET_BLOCKLEN;
        cmd.resp_type = CARD_RSP_R1;
        cmd.cmdarg = len;
        cmd.flags = 0;
 
        return ctrlr->send_cmd(ctrlr, &cmd, NULL);
}
 
int sd_mmc_enter_standby(struct storage_media *media)
{
        struct mmc_command cmd;
        struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
        int err;
 
        SET_BUS_WIDTH(ctrlr, 1);
        SET_CLOCK(ctrlr, 1);
 
        /* Reset the Card */
        err = sd_mmc_go_idle(media);
        if (err)
                return err;
 
        /* Test for SD version 2 */
        err = CARD_TIMEOUT;
        if (CONFIG(COMMONLIB_STORAGE_SD)) {
                err = sd_send_if_cond(media);
 
                /* Get SD card operating condition */
                if (!err)
                        err = sd_send_op_cond(media);
        }
 
        /* If the command timed out, we check for an MMC card */
        if (CONFIG(COMMONLIB_STORAGE_MMC) && (err == CARD_TIMEOUT)) {
                /* Some cards seem to need this */
                sd_mmc_go_idle(media);
 
                err = mmc_send_op_cond(media);
                if (err == CARD_IN_PROGRESS)
                        err = mmc_complete_op_cond(media);
        }
 
        if (err) {
                sd_mmc_error(
                        "Card did not respond to voltage select!\n");
                return CARD_UNUSABLE_ERR;
        }
 
        /* Put the Card in Identify Mode */
        cmd.cmdidx = MMC_CMD_ALL_SEND_CID;
        cmd.resp_type = CARD_RSP_R2;
        cmd.cmdarg = 0;
        cmd.flags = 0;
        err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
        if (err)
                return err;
        memcpy(media->cid, cmd.response, sizeof(media->cid));
 
        /*
         * For MMC cards, set the Relative Address.
         * For SD cards, get the Relative Address.
         * This also puts the cards into Standby State
         */
        cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
        cmd.cmdarg = media->rca << 16;
        cmd.resp_type = CARD_RSP_R6;
        cmd.flags = 0;
        err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
        if (err)
                return err;
        if (IS_SD(media))
                media->rca = (cmd.response[0] >> 16) & 0xffff;
 
        /* Get the Card-Specific Data */
        cmd.cmdidx = MMC_CMD_SEND_CSD;
        cmd.resp_type = CARD_RSP_R2;
        cmd.cmdarg = media->rca << 16;
        cmd.flags = 0;
        err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
 
        /* Waiting for the ready status */
        sd_mmc_send_status(media, SD_MMC_IO_RETRIES);
        if (err)
                return err;
 
        memcpy(media->csd, cmd.response, sizeof(media->csd));
        if (media->version == MMC_VERSION_UNKNOWN) {
                int version = sd_mmc_extract_uint32_bits(media->csd, 2, 4);
                switch (version) {
                case 0:
                        media->version = MMC_VERSION_1_2;
                        break;
                case 1:
                        media->version = MMC_VERSION_1_4;
                        break;
                case 2:
                        media->version = MMC_VERSION_2_2;
                        break;
                case 3:
                        media->version = MMC_VERSION_3;
                        break;
                case 4:
                        media->version = MMC_VERSION_4;
                        break;
                default:
                        media->version = MMC_VERSION_1_2;
                        break;
                }
        }
        media->tran_speed = sd_mmc_calculate_transfer_speed(media->csd[0]);
 
        /* Determine the read and write block lengths */
        media->read_bl_len = 1 << sd_mmc_extract_uint32_bits(media->csd, 44, 4);
        if (IS_SD(media))
                media->write_bl_len = media->read_bl_len;
        else
                media->write_bl_len =
                        1 << sd_mmc_extract_uint32_bits(media->csd, 102, 4);
 
        sd_mmc_debug("mmc media info: version=%#x, tran_speed=%d\n",
              media->version, (int)media->tran_speed);
 
        return 0;
}