src/commonlib/storage/sd.c

   1 /* This file is part of the coreboot project. */
   2 /* SPDX-License-Identifier: GPL-2.0-or-later */
   3 /*
   4  * Secure Digital (SD) card specific support code
   5  * This code is controller independent
   6  */
   7
   8 #include <commonlib/sd_mmc_ctrlr.h>
   9 #include <commonlib/storage.h>
  10 #include <delay.h>
  11 #include <endian.h>
  12
  13 #include "sd_mmc.h"
  14 #include "storage.h"
  15
  16 int sd_send_if_cond(struct storage_media *media)
  17 {
  18         struct mmc_command cmd;
  19         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
  20
  21         cmd.cmdidx = SD_CMD_SEND_IF_COND;
  22         /* Set if controller supports voltages between 2.7 and 3.6 V. */
  23         cmd.cmdarg = ((ctrlr->voltages & 0xff8000) != 0) << 8 | 0xaa;
  24         cmd.resp_type = CARD_RSP_R7;
  25         cmd.flags = 0;
  26         int err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
  27         if (err)
  28                 return err;
  29
  30         if ((cmd.response[0] & 0xff) != 0xaa)
  31                 return CARD_UNUSABLE_ERR;
  32         media->version = SD_VERSION_2;
  33         return 0;
  34 }
  35
  36 int sd_send_op_cond(struct storage_media *media)
  37 {
  38         int err;
  39         struct mmc_command cmd;
  40         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
  41
  42         int tries = SD_MMC_IO_RETRIES;
  43         while (tries--) {
  44                 cmd.cmdidx = MMC_CMD_APP_CMD;
  45                 cmd.resp_type = CARD_RSP_R1;
  46                 cmd.cmdarg = 0;
  47                 cmd.flags = 0;
  48
  49                 err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
  50                 if (err)
  51                         return err;
  52
  53                 cmd.cmdidx = SD_CMD_APP_SEND_OP_COND;
  54                 cmd.resp_type = CARD_RSP_R3;
  55
  56                 /*
  57                  * Most cards do not answer if some reserved bits
  58                  * in the ocr are set. However, Some controller
  59                  * can set bit 7 (reserved for low voltages), but
  60                  * how to manage low voltages SD card is not yet
  61                  * specified.
  62                  */
  63                 cmd.cmdarg = (ctrlr->voltages & 0xff8000);
  64
  65                 if (media->version == SD_VERSION_2)
  66                         cmd.cmdarg |= OCR_HCS;
  67
  68                 err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
  69                 if (err)
  70                         return err;
  71
  72                 // OCR_BUSY means "initialization complete".
  73                 if (cmd.response[0] & OCR_BUSY)
  74                         break;
  75
  76                 udelay(100);
  77         }
  78         if (tries < 0)
  79                 return CARD_UNUSABLE_ERR;
  80
  81         if (media->version != SD_VERSION_2)
  82                 media->version = SD_VERSION_1_0;
  83
  84         media->ocr = cmd.response[0];
  85         media->high_capacity = ((media->ocr & OCR_HCS) == OCR_HCS);
  86         media->rca = 0;
  87         return 0;
  88 }
  89
  90 static int sd_switch(struct sd_mmc_ctrlr *ctrlr, int mode, int group,
  91         uint8_t value, uint8_t *resp)
  92 {
  93         /* Switch the frequency */
  94         struct mmc_command cmd;
  95         cmd.cmdidx = SD_CMD_SWITCH_FUNC;
  96         cmd.resp_type = CARD_RSP_R1;
  97         cmd.cmdarg = (mode << 31) | (0xffffff & ~(0xf << (group * 4))) |
  98                      (value << (group * 4));
  99         cmd.flags = 0;
 100
 101         struct mmc_data data;
 102         data.dest = (char *)resp;
 103         data.blocksize = 64;
 104         data.blocks = 1;
 105         data.flags = DATA_FLAG_READ;
 106
 107         return ctrlr->send_cmd(ctrlr, &cmd, &data);
 108 }
 109
 110 static void sd_recalculate_clock(struct storage_media *media)
 111 {
 112         uint32_t clock = 1;
 113
 114         if (media->caps & DRVR_CAP_HS)
 115                 clock = CLOCK_50MHZ;
 116         else
 117                 clock = CLOCK_25MHZ;
 118         SET_CLOCK(media->ctrlr, clock);
 119 }
 120
 121 int sd_change_freq(struct storage_media *media)
 122 {
 123         int delay;
 124         int err, timeout;
 125         struct mmc_command cmd;
 126         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 127         struct mmc_data data;
 128         ALLOC_CACHE_ALIGN_BUFFER(uint32_t, scr, 2);
 129         ALLOC_CACHE_ALIGN_BUFFER(uint32_t, switch_status, 16);
 130
 131         media->caps = 0;
 132
 133         /* Read the SCR to find out if this card supports higher speeds */
 134         cmd.cmdidx = MMC_CMD_APP_CMD;
 135         cmd.resp_type = CARD_RSP_R1;
 136         cmd.cmdarg = media->rca << 16;
 137         cmd.flags = 0;
 138
 139         err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
 140         if (err)
 141                 return err;
 142
 143         cmd.cmdidx = SD_CMD_APP_SEND_SCR;
 144         cmd.resp_type = CARD_RSP_R1;
 145         cmd.cmdarg = 0;
 146         cmd.flags = 0;
 147
 148         timeout = 3;
 149         while (timeout--) {
 150                 data.dest = (char *)scr;
 151                 data.blocksize = 8;
 152                 data.blocks = 1;
 153                 data.flags = DATA_FLAG_READ;
 154                 err = ctrlr->send_cmd(ctrlr, &cmd, &data);
 155                 if (!err)
 156                         break;
 157         }
 158         if (err) {
 159                 sd_mmc_error("%s returning %d\n", __func__, err);
 160                 return err;
 161         }
 162
 163         media->scr[0] = be32toh(scr[0]);
 164         media->scr[1] = be32toh(scr[1]);
 165
 166         switch ((media->scr[0] >> 24) & 0xf) {
 167         case 0:
 168                 media->version = SD_VERSION_1_0;
 169                 break;
 170         case 1:
 171                 media->version = SD_VERSION_1_10;
 172                 break;
 173         case 2:
 174                 media->version = SD_VERSION_2;
 175                 break;
 176         default:
 177                 media->version = SD_VERSION_1_0;
 178                 break;
 179         }
 180
 181         if (media->scr[0] & SD_DATA_4BIT)
 182                 media->caps |= DRVR_CAP_4BIT;
 183
 184         /* Version 1.0 doesn't support switching */
 185         if (media->version == SD_VERSION_1_0)
 186                 goto out;
 187
 188         timeout = 4;
 189         while (timeout--) {
 190                 err = sd_switch(ctrlr, SD_SWITCH_CHECK, 0, 1,
 191                                 (uint8_t *)switch_status);
 192                 if (err)
 193                         return err;
 194
 195                 /* The high-speed function is busy.  Try again */
 196                 if (!(ntohl(switch_status[7]) & SD_HIGHSPEED_BUSY))
 197                         break;
 198         }
 199
 200         /* If high-speed isn't supported, we return */
 201         if (!(ntohl(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
 202                 goto out;
 203
 204         /*
 205          * If the controller doesn't support SD_HIGHSPEED, do not switch the
 206          * card to HIGHSPEED mode even if the card support SD_HIGHSPPED.
 207          * This can avoid a further problem when the card runs in different
 208          * mode than the controller.
 209          */
 210         if (!((ctrlr->caps & DRVR_CAP_HS52) && (ctrlr->caps & DRVR_CAP_HS)))
 211                 goto out;
 212
 213         /* Give the card time to recover after the switch operation.  Wait for
 214          * 9 (>= 8) clock cycles receiving the switch status.
 215          */
 216         delay = (9000000 + ctrlr->bus_hz - 1) / ctrlr->bus_hz;
 217         udelay(delay);
 218
 219         /* Switch to high speed */
 220         err = sd_switch(ctrlr, SD_SWITCH_SWITCH, 0, 1,
 221                         (uint8_t *)switch_status);
 222         if (err)
 223                 return err;
 224
 225         /* Give the card time to perform the switch operation.  Wait for 9
 226          * (>= 8) clock cycles receiving the switch status.
 227          */
 228         udelay(delay);
 229
 230         if ((ntohl(switch_status[4]) & 0x0f000000) == 0x01000000) {
 231                 media->caps |= DRVR_CAP_HS;
 232                 SET_TIMING(ctrlr, BUS_TIMING_SD_HS);
 233         }
 234
 235 out:
 236         sd_recalculate_clock(media);
 237         return 0;
 238 }
 239
 240 int sd_set_bus_width(struct storage_media *media)
 241 {
 242         int err;
 243         struct mmc_command cmd;
 244         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 245
 246         if (media->caps & DRVR_CAP_4BIT) {
 247                 cmd.cmdidx = MMC_CMD_APP_CMD;
 248                 cmd.resp_type = CARD_RSP_R1;
 249                 cmd.cmdarg = media->rca << 16;
 250                 cmd.flags = 0;
 251
 252                 err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
 253                 if (err)
 254                         return err;
 255
 256                 cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
 257                 cmd.resp_type = CARD_RSP_R1;
 258                 cmd.cmdarg = 2;
 259                 cmd.flags = 0;
 260                 err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
 261                 if (err)
 262                         return err;
 263
 264                 SET_BUS_WIDTH(ctrlr, 4);
 265         }
 266         return 0;
 267 }
 268
 269
 270 int sd_set_partition(struct storage_media *media,
 271         unsigned int partition_number)
 272 {
 273         /* Validate the partition number */
 274         if (partition_number)
 275                 return -1;
 276
 277         /* Update the partition number */
 278         media->partition_config = partition_number;
 279         return 0;
 280 }
 281
 282 const char *sd_partition_name(struct storage_media *media,
 283         unsigned int partition_number)
 284 {
 285         return "";
 286 }