src/commonlib/storage/sd_mmc.c

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * MultiMediaCard (MMC), eMMC and Secure Digital (SD) common initialization
   4  * code which brings the card into the standby state.  This code is controller
   5  * independent.
   6  */
   7
   8 #include <commonlib/storage.h>
   9 #include <delay.h>
  10 #include <endian.h>
  11 #include <string.h>
  12
  13 #include "mmc.h"
  14 #include "sd_mmc.h"
  15 #include "storage.h"
  16
  17 uint64_t sd_mmc_extract_uint32_bits(const uint32_t *array, int start, int count)
  18 {
  19         int i;
  20         uint64_t value = 0;
  21
  22         for (i = 0; i < count; i++, start++) {
  23                 value <<= 1;
  24                 value |= (array[start / 32] >> (31 - (start % 32))) & 0x1;
  25         }
  26         return value;
  27 }
  28
  29 static uint32_t sd_mmc_calculate_transfer_speed(uint32_t csd0)
  30 {
  31         uint32_t mult, freq;
  32
  33         /* frequency bases, divided by 10 to be nice to platforms without
  34          * floating point */
  35         static const int fbase[] = {
  36                 10000,
  37                 100000,
  38                 1000000,
  39                 10000000,
  40         };
  41         /* Multiplier values for TRAN_SPEED. Multiplied by 10 to be nice
  42          * to platforms without floating point. */
  43         static const int multipliers[] = {
  44                 0,  // reserved
  45                 10,
  46                 12,
  47                 13,
  48                 15,
  49                 20,
  50                 25,
  51                 30,
  52                 35,
  53                 40,
  54                 45,
  55                 50,
  56                 55,
  57                 60,
  58                 70,
  59                 80,
  60         };
  61
  62         /* divide frequency by 10, since the mults are 10x bigger */
  63         freq = fbase[csd0 & 0x7];
  64         mult = multipliers[(csd0 >> 3) & 0xf];
  65         return freq * mult;
  66 }
  67
  68 int sd_mmc_go_idle(struct storage_media *media)
  69 {
  70         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
  71
  72         // Some cards can't accept idle commands without delay.
  73         if (ctrlr->mdelay_before_cmd0)
  74                 mdelay(ctrlr->mdelay_before_cmd0);
  75
  76         struct mmc_command cmd;
  77         cmd.cmdidx = MMC_CMD_GO_IDLE_STATE;
  78         cmd.cmdarg = 0;
  79         cmd.resp_type = CARD_RSP_NONE;
  80         cmd.flags = 0;
  81
  82         int err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
  83         if (err)
  84                 return err;
  85
  86         // Some cards need more than half second to respond to next command (ex,
  87         // SEND_OP_COND).
  88         if (ctrlr->mdelay_after_cmd0)
  89                 mdelay(ctrlr->mdelay_after_cmd0);
  90
  91         return 0;
  92 }
  93
  94 int sd_mmc_send_status(struct storage_media *media, ssize_t tries)
  95 {
  96         struct mmc_command cmd;
  97         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
  98
  99         cmd.cmdidx = MMC_CMD_SEND_STATUS;
 100         cmd.resp_type = CARD_RSP_R1;
 101         cmd.cmdarg = media->rca << 16;
 102         cmd.flags = 0;
 103
 104         while (tries--) {
 105                 int err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
 106                 if (err)
 107                         return err;
 108                 else if (cmd.response[0] & MMC_STATUS_RDY_FOR_DATA)
 109                         break;
 110                 else if (cmd.response[0] & MMC_STATUS_MASK) {
 111                         sd_mmc_error("Status Error: %#8.8x\n", cmd.response[0]);
 112                         return CARD_COMM_ERR;
 113                 }
 114
 115                 udelay(100);
 116         }
 117
 118         sd_mmc_trace("CURR STATE:%d\n",
 119                   (cmd.response[0] & MMC_STATUS_CURR_STATE) >> 9);
 120
 121         if (tries < 0) {
 122                 sd_mmc_error("Timeout waiting card ready\n");
 123                 return CARD_TIMEOUT;
 124         }
 125         return 0;
 126 }
 127
 128 int sd_mmc_set_blocklen(struct sd_mmc_ctrlr *ctrlr, int len)
 129 {
 130         struct mmc_command cmd;
 131         cmd.cmdidx = MMC_CMD_SET_BLOCKLEN;
 132         cmd.resp_type = CARD_RSP_R1;
 133         cmd.cmdarg = len;
 134         cmd.flags = 0;
 135
 136         return ctrlr->send_cmd(ctrlr, &cmd, NULL);
 137 }
 138
 139 int sd_mmc_enter_standby(struct storage_media *media)
 140 {
 141         struct mmc_command cmd;
 142         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 143         int err;
 144
 145         SET_BUS_WIDTH(ctrlr, 1);
 146         SET_CLOCK(ctrlr, 1);
 147
 148         /* Reset the Card */
 149         err = sd_mmc_go_idle(media);
 150         if (err)
 151                 return err;
 152
 153         /* Test for SD version 2 */
 154         err = CARD_TIMEOUT;
 155         if (CONFIG(COMMONLIB_STORAGE_SD)) {
 156                 err = sd_send_if_cond(media);
 157
 158                 /* Get SD card operating condition */
 159                 if (!err)
 160                         err = sd_send_op_cond(media);
 161         }
 162
 163         /* If the command timed out, we check for an MMC card */
 164         if (CONFIG(COMMONLIB_STORAGE_MMC) && (err == CARD_TIMEOUT)) {
 165                 /* Some cards seem to need this */
 166                 sd_mmc_go_idle(media);
 167
 168                 err = mmc_send_op_cond(media);
 169                 if (err == CARD_IN_PROGRESS)
 170                         err = mmc_complete_op_cond(media);
 171         }
 172
 173         if (err) {
 174                 sd_mmc_error(
 175                         "Card did not respond to voltage select!\n");
 176                 return CARD_UNUSABLE_ERR;
 177         }
 178
 179         /* Put the Card in Identify Mode */
 180         cmd.cmdidx = MMC_CMD_ALL_SEND_CID;
 181         cmd.resp_type = CARD_RSP_R2;
 182         cmd.cmdarg = 0;
 183         cmd.flags = 0;
 184         err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
 185         if (err)
 186                 return err;
 187         memcpy(media->cid, cmd.response, sizeof(media->cid));
 188
 189         /*
 190          * For MMC cards, set the Relative Address.
 191          * For SD cards, get the Relative Address.
 192          * This also puts the cards into Standby State
 193          */
 194         cmd.cmdidx = SD_CMD_SEND_RELATIVE_ADDR;
 195         cmd.cmdarg = media->rca << 16;
 196         cmd.resp_type = CARD_RSP_R6;
 197         cmd.flags = 0;
 198         err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
 199         if (err)
 200                 return err;
 201         if (IS_SD(media))
 202                 media->rca = (cmd.response[0] >> 16) & 0xffff;
 203
 204         /* Get the Card-Specific Data */
 205         cmd.cmdidx = MMC_CMD_SEND_CSD;
 206         cmd.resp_type = CARD_RSP_R2;
 207         cmd.cmdarg = media->rca << 16;
 208         cmd.flags = 0;
 209         err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
 210
 211         /* Waiting for the ready status */
 212         sd_mmc_send_status(media, SD_MMC_IO_RETRIES);
 213         if (err)
 214                 return err;
 215
 216         memcpy(media->csd, cmd.response, sizeof(media->csd));
 217         if (media->version == MMC_VERSION_UNKNOWN) {
 218                 int version = sd_mmc_extract_uint32_bits(media->csd, 2, 4);
 219                 switch (version) {
 220                 case 0:
 221                         media->version = MMC_VERSION_1_2;
 222                         break;
 223                 case 1:
 224                         media->version = MMC_VERSION_1_4;
 225                         break;
 226                 case 2:
 227                         media->version = MMC_VERSION_2_2;
 228                         break;
 229                 case 3:
 230                         media->version = MMC_VERSION_3;
 231                         break;
 232                 case 4:
 233                         media->version = MMC_VERSION_4;
 234                         break;
 235                 default:
 236                         media->version = MMC_VERSION_1_2;
 237                         break;
 238                 }
 239         }
 240         media->tran_speed = sd_mmc_calculate_transfer_speed(media->csd[0]);
 241
 242         /* Determine the read and write block lengths */
 243         media->read_bl_len = 1 << sd_mmc_extract_uint32_bits(media->csd, 44, 4);
 244         if (IS_SD(media))
 245                 media->write_bl_len = media->read_bl_len;
 246         else
 247                 media->write_bl_len =
 248                         1 << sd_mmc_extract_uint32_bits(media->csd, 102, 4);
 249
 250         sd_mmc_debug("mmc media info: version=%#x, tran_speed=%d\n",
 251               media->version, (int)media->tran_speed);
 252
 253         return 0;
 254 }