sd.c

Go to the documentation of this file.

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Secure Digital (SD) card specific support code
 * This code is controller independent
 */
 
#include <commonlib/sd_mmc_ctrlr.h>
#include <commonlib/storage.h>
#include <delay.h>
#include <endian.h>
 
#include "sd_mmc.h"
#include "storage.h"
 
int sd_send_if_cond(struct storage_media *media)
{
        struct mmc_command cmd;
        struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 
        cmd.cmdidx = SD_CMD_SEND_IF_COND;
        /* Set if controller supports voltages between 2.7 and 3.6 V. */
        cmd.cmdarg = ((ctrlr->voltages & 0xff8000) != 0) << 8 | 0xaa;
        cmd.resp_type = CARD_RSP_R7;
        cmd.flags = 0;
        int err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
        if (err)
                return err;
 
        if ((cmd.response[0] & 0xff) != 0xaa)
                return CARD_UNUSABLE_ERR;
        media->version = SD_VERSION_2;
        return 0;
}
 
int sd_send_op_cond(struct storage_media *media)
{
        int err;
        struct mmc_command cmd;
        struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 
        int tries = SD_MMC_IO_RETRIES;
        while (tries--) {
                cmd.cmdidx = MMC_CMD_APP_CMD;
                cmd.resp_type = CARD_RSP_R1;
                cmd.cmdarg = 0;
                cmd.flags = 0;
 
                err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
                if (err)
                        return err;
 
                cmd.cmdidx = SD_CMD_APP_SEND_OP_COND;
                cmd.resp_type = CARD_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 = (ctrlr->voltages & 0xff8000);
 
                if (media->version == SD_VERSION_2)
                        cmd.cmdarg |= OCR_HCS;
 
                err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
                if (err)
                        return err;
 
                // OCR_BUSY means "initialization complete".
                if (cmd.response[0] & OCR_BUSY)
                        break;
 
                udelay(100);
        }
        if (tries < 0)
                return CARD_UNUSABLE_ERR;
 
        if (media->version != SD_VERSION_2)
                media->version = SD_VERSION_1_0;
 
        media->ocr = cmd.response[0];
        media->high_capacity = ((media->ocr & OCR_HCS) == OCR_HCS);
        media->rca = 0;
        return 0;
}
 
static int sd_switch(struct sd_mmc_ctrlr *ctrlr, int mode, int group,
        uint8_t value, uint8_t *resp)
{
        /* Switch the frequency */
        struct mmc_command cmd;
        cmd.cmdidx = SD_CMD_SWITCH_FUNC;
        cmd.resp_type = CARD_RSP_R1;
        cmd.cmdarg = (mode << 31) | (0xffffff & ~(0xf << (group * 4))) |
                     (value << (group * 4));
        cmd.flags = 0;
 
        struct mmc_data data;
        data.dest = (char *)resp;
        data.blocksize = 64;
        data.blocks = 1;
        data.flags = DATA_FLAG_READ;
 
        return ctrlr->send_cmd(ctrlr, &cmd, &data);
}
 
static void sd_recalculate_clock(struct storage_media *media)
{
        uint32_t clock = 1;
 
        if (media->caps & DRVR_CAP_HS)
                clock = CLOCK_50MHZ;
        else
                clock = CLOCK_25MHZ;
        SET_CLOCK(media->ctrlr, clock);
}
 
int sd_change_freq(struct storage_media *media)
{
        int delay;
        int err, timeout;
        struct mmc_command cmd;
        struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
        struct mmc_data data;
        ALLOC_CACHE_ALIGN_BUFFER(uint32_t, scr, 2);
        ALLOC_CACHE_ALIGN_BUFFER(uint32_t, switch_status, 16);
 
        media->caps = 0;
 
        /* Read the SCR to find out if this card supports higher speeds */
        cmd.cmdidx = MMC_CMD_APP_CMD;
        cmd.resp_type = CARD_RSP_R1;
        cmd.cmdarg = media->rca << 16;
        cmd.flags = 0;
 
        err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
        if (err)
                return err;
 
        cmd.cmdidx = SD_CMD_APP_SEND_SCR;
        cmd.resp_type = CARD_RSP_R1;
        cmd.cmdarg = 0;
        cmd.flags = 0;
 
        timeout = 3;
        while (timeout--) {
                data.dest = (char *)scr;
                data.blocksize = 8;
                data.blocks = 1;
                data.flags = DATA_FLAG_READ;
                err = ctrlr->send_cmd(ctrlr, &cmd, &data);
                if (!err)
                        break;
        }
        if (err) {
                sd_mmc_error("%s returning %d\n", __func__, err);
                return err;
        }
 
        media->scr[0] = be32toh(scr[0]);
        media->scr[1] = be32toh(scr[1]);
 
        switch ((media->scr[0] >> 24) & 0xf) {
        case 0:
                media->version = SD_VERSION_1_0;
                break;
        case 1:
                media->version = SD_VERSION_1_10;
                break;
        case 2:
                media->version = SD_VERSION_2;
                break;
        default:
                media->version = SD_VERSION_1_0;
                break;
        }
 
        if (media->scr[0] & SD_DATA_4BIT)
                media->caps |= DRVR_CAP_4BIT;
 
        /* Version 1.0 doesn't support switching */
        if (media->version == SD_VERSION_1_0)
                goto out;
 
        timeout = 4;
        while (timeout--) {
                err = sd_switch(ctrlr, SD_SWITCH_CHECK, 0, 1,
                                (uint8_t *)switch_status);
                if (err)
                        return err;
 
                /* The high-speed function is busy.  Try again */
                if (!(ntohl(switch_status[7]) & SD_HIGHSPEED_BUSY))
                        break;
        }
 
        /* If high-speed isn't supported, we return */
        if (!(ntohl(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
                goto out;
 
        /*
         * If the controller doesn't support SD_HIGHSPEED, do not switch the
         * card to HIGHSPEED mode even if the card support SD_HIGHSPPED.
         * This can avoid a further problem when the card runs in different
         * mode than the controller.
         */
        if (!((ctrlr->caps & DRVR_CAP_HS52) && (ctrlr->caps & DRVR_CAP_HS)))
                goto out;
 
        /* Give the card time to recover after the switch operation.  Wait for
         * 9 (>= 8) clock cycles receiving the switch status.
         */
        delay = (9000000 + ctrlr->bus_hz - 1) / ctrlr->bus_hz;
        udelay(delay);
 
        /* Switch to high speed */
        err = sd_switch(ctrlr, SD_SWITCH_SWITCH, 0, 1,
                        (uint8_t *)switch_status);
        if (err)
                return err;
 
        /* Give the card time to perform the switch operation.  Wait for 9
         * (>= 8) clock cycles receiving the switch status.
         */
        udelay(delay);
 
        if ((ntohl(switch_status[4]) & 0x0f000000) == 0x01000000) {
                media->caps |= DRVR_CAP_HS;
                SET_TIMING(ctrlr, BUS_TIMING_SD_HS);
        }
 
out:
        sd_recalculate_clock(media);
        return 0;
}
 
int sd_set_bus_width(struct storage_media *media)
{
        int err;
        struct mmc_command cmd;
        struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 
        if (media->caps & DRVR_CAP_4BIT) {
                cmd.cmdidx = MMC_CMD_APP_CMD;
                cmd.resp_type = CARD_RSP_R1;
                cmd.cmdarg = media->rca << 16;
                cmd.flags = 0;
 
                err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
                if (err)
                        return err;
 
                cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
                cmd.resp_type = CARD_RSP_R1;
                cmd.cmdarg = 2;
                cmd.flags = 0;
                err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
                if (err)
                        return err;
 
                SET_BUS_WIDTH(ctrlr, 4);
        }
        return 0;
}
 
int sd_set_partition(struct storage_media *media,
        unsigned int partition_number)
{
        /* Validate the partition number */
        if (partition_number)
                return -1;
 
        /* Update the partition number */
        media->partition_config = partition_number;
        return 0;
}
 
const char *sd_partition_name(struct storage_media *media,
        unsigned int partition_number)
{
        return "";
}