src/commonlib/storage/mmc.c

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * MultiMediaCard (MMC) and eMMC specific support code
   4  * This code is controller independent
   5  */
   6
   7 #include <cbmem.h>
   8 #include <commonlib/storage.h>
   9 #include <delay.h>
  10 #include "mmc.h"
  11 #include "sd_mmc.h"
  12 #include "storage.h"
  13 #include <string.h>
  14 #include <timer.h>
  15
  16 /* We pass in the cmd since otherwise the init seems to fail */
  17 static int mmc_send_op_cond_iter(struct storage_media *media,
  18         struct mmc_command *cmd, int use_arg)
  19 {
  20         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
  21
  22         cmd->cmdidx = MMC_CMD_SEND_OP_COND;
  23         cmd->resp_type = CARD_RSP_R3;
  24
  25         /* Set the controller's operating conditions */
  26         if (use_arg) {
  27                 uint32_t mask = media->op_cond_response &
  28                         (OCR_VOLTAGE_MASK | OCR_ACCESS_MODE);
  29                 cmd->cmdarg = ctrlr->voltages & mask;
  30
  31                 /* Always request high capacity if supported by the
  32                  * controller
  33                  */
  34                 if (ctrlr->caps & DRVR_CAP_HC)
  35                         cmd->cmdarg |= OCR_HCS;
  36         }
  37         cmd->flags = 0;
  38         int err = ctrlr->send_cmd(ctrlr, cmd, NULL);
  39         if (err)
  40                 return err;
  41
  42         media->op_cond_response = cmd->response[0];
  43         return 0;
  44 }
  45
  46 int mmc_send_op_cond(struct storage_media *media)
  47 {
  48         struct mmc_command cmd;
  49         int max_iters = 2;
  50
  51         /* Ask the card for its operating conditions */
  52         cmd.cmdarg = 0;
  53         for (int i = 0; i < max_iters; i++) {
  54                 int err = mmc_send_op_cond_iter(media, &cmd, i != 0);
  55                 if (err)
  56                         return err;
  57
  58                 // OCR_BUSY is active low, this bit set means
  59                 // "initialization complete".
  60                 if (media->op_cond_response & OCR_BUSY)
  61                         return 0;
  62         }
  63         return CARD_IN_PROGRESS;
  64 }
  65
  66 int mmc_complete_op_cond(struct storage_media *media)
  67 {
  68         struct mmc_command cmd;
  69         struct stopwatch sw;
  70
  71         stopwatch_init_msecs_expire(&sw, MMC_INIT_TIMEOUT_US_MS);
  72         while (1) {
  73                 // CMD1 queries whether initialization is done.
  74                 int err = mmc_send_op_cond_iter(media, &cmd, 1);
  75                 if (err)
  76                         return err;
  77
  78                 // OCR_BUSY means "initialization complete".
  79                 if (media->op_cond_response & OCR_BUSY)
  80                         break;
  81
  82                 // Check if init timeout has expired.
  83                 if (stopwatch_expired(&sw))
  84                         return CARD_UNUSABLE_ERR;
  85
  86                 udelay(100);
  87         }
  88
  89         media->version = MMC_VERSION_UNKNOWN;
  90         media->ocr = cmd.response[0];
  91
  92         media->high_capacity = ((media->ocr & OCR_HCS) == OCR_HCS);
  93         media->rca = 0;
  94         return 0;
  95 }
  96
  97 int mmc_send_ext_csd(struct sd_mmc_ctrlr *ctrlr, unsigned char *ext_csd)
  98 {
  99         struct mmc_command cmd;
 100         struct mmc_data data;
 101         int rv;
 102
 103         /* Get the Card Status Register */
 104         cmd.cmdidx = MMC_CMD_SEND_EXT_CSD;
 105         cmd.resp_type = CARD_RSP_R1;
 106         cmd.cmdarg = 0;
 107         cmd.flags = 0;
 108
 109         data.dest = (char *)ext_csd;
 110         data.blocks = 1;
 111         data.blocksize = 512;
 112         data.flags = DATA_FLAG_READ;
 113
 114         rv = ctrlr->send_cmd(ctrlr, &cmd, &data);
 115
 116         if (!rv && CONFIG(SD_MMC_TRACE)) {
 117                 int i, size;
 118
 119                 size = data.blocks * data.blocksize;
 120                 sd_mmc_trace("\t%p ext_csd:", ctrlr);
 121                 for (i = 0; i < size; i++) {
 122                         if (!(i % 32))
 123                                 sd_mmc_trace("\n");
 124                         sd_mmc_trace(" %2.2x", ext_csd[i]);
 125                 }
 126                 sd_mmc_trace("\n");
 127         }
 128         return rv;
 129 }
 130
 131 static int mmc_switch(struct storage_media *media, uint8_t index, uint8_t value)
 132 {
 133         struct mmc_command cmd;
 134         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 135
 136         cmd.cmdidx = MMC_CMD_SWITCH;
 137         cmd.resp_type = CARD_RSP_R1b;
 138         cmd.cmdarg = ((MMC_SWITCH_MODE_WRITE_BYTE << 24) |
 139                            (index << 16) | (value << 8));
 140         cmd.flags = 0;
 141
 142         int ret = ctrlr->send_cmd(ctrlr, &cmd, NULL);
 143
 144         /* Waiting for the ready status */
 145         sd_mmc_send_status(media, SD_MMC_IO_RETRIES);
 146         return ret;
 147
 148 }
 149
 150 static void mmc_recalculate_clock(struct storage_media *media)
 151 {
 152         uint32_t clock;
 153
 154         clock = CLOCK_26MHZ;
 155         if (media->caps & DRVR_CAP_HS) {
 156                 if ((media->caps & DRVR_CAP_HS200) ||
 157                     (media->caps & DRVR_CAP_HS400))
 158                         clock = CLOCK_200MHZ;
 159                 else if (media->caps & DRVR_CAP_HS52)
 160                         clock = CLOCK_52MHZ;
 161         }
 162         SET_CLOCK(media->ctrlr, clock);
 163 }
 164
 165 static int mmc_select_hs(struct storage_media *media)
 166 {
 167         int ret;
 168
 169         /* Switch the MMC device into high speed mode */
 170         ret = mmc_switch(media, EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS);
 171         if (ret) {
 172                 sd_mmc_error("Timing switch to high speed failed\n");
 173                 return ret;
 174         }
 175         sdhc_debug("SDHCI switched MMC to high speed\n");
 176
 177         /* Increase the controller clock speed */
 178         SET_TIMING(media->ctrlr, BUS_TIMING_MMC_HS);
 179         media->caps &= ~(DRVR_CAP_HS200 | DRVR_CAP_HS400);
 180         media->caps |= DRVR_CAP_HS52 | DRVR_CAP_HS;
 181         mmc_recalculate_clock(media);
 182         ret = sd_mmc_send_status(media, SD_MMC_IO_RETRIES);
 183         return ret;
 184 }
 185
 186 static int mmc_send_tuning_seq(struct sd_mmc_ctrlr *ctrlr, char *buffer)
 187 {
 188         struct mmc_command cmd;
 189         struct mmc_data data;
 190
 191         /* Request the device send the tuning sequence to the host */
 192         cmd.cmdidx = MMC_CMD_AUTO_TUNING_SEQUENCE;
 193         cmd.resp_type = CARD_RSP_R1;
 194         cmd.cmdarg = 0;
 195         cmd.flags = CMD_FLAG_IGNORE_INHIBIT;
 196
 197         data.dest = buffer;
 198         data.blocks = 1;
 199         data.blocksize = (ctrlr->bus_width == 8) ? 128 : 64;
 200         data.flags = DATA_FLAG_READ;
 201         return ctrlr->send_cmd(ctrlr, &cmd, &data);
 202 }
 203
 204 static int mmc_bus_tuning(struct storage_media *media)
 205 {
 206         ALLOC_CACHE_ALIGN_BUFFER(char, buffer, 128);
 207         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 208         int index;
 209         int successful;
 210
 211         /* Request the device send the tuning sequence up to 40 times */
 212         ctrlr->tuning_start(ctrlr, 0);
 213         for (index = 0; index < 40; index++) {
 214                 mmc_send_tuning_seq(ctrlr, buffer);
 215                 if (ctrlr->is_tuning_complete(ctrlr, &successful)) {
 216                         if (successful)
 217                                 return 0;
 218                         break;
 219                 }
 220         }
 221         sd_mmc_error("Bus tuning failed!\n");
 222         return -1;
 223 }
 224
 225 static int mmc_select_hs400(struct storage_media *media)
 226 {
 227         uint8_t bus_width;
 228         uint32_t caps;
 229         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 230         int ret;
 231         uint32_t timing;
 232
 233         /* Switch the MMC device into high speed mode */
 234         ret = mmc_select_hs(media);
 235         if (ret)
 236                 return ret;
 237
 238         /* Switch MMC device to 8-bit DDR with strobe */
 239         bus_width = EXT_CSD_DDR_BUS_WIDTH_8;
 240         caps = DRVR_CAP_HS400 | DRVR_CAP_HS52 | DRVR_CAP_HS;
 241         timing = BUS_TIMING_MMC_HS400;
 242         if ((ctrlr->caps & DRVR_CAP_ENHANCED_STROBE)
 243                 && (media->caps & DRVR_CAP_ENHANCED_STROBE)) {
 244                 bus_width |= EXT_CSD_BUS_WIDTH_STROBE;
 245                 caps |= DRVR_CAP_ENHANCED_STROBE;
 246                 timing = BUS_TIMING_MMC_HS400ES;
 247         }
 248         ret = mmc_switch(media, EXT_CSD_BUS_WIDTH, bus_width);
 249         if (ret) {
 250                 sd_mmc_error("Switching bus width for HS400 failed\n");
 251                 return ret;
 252         }
 253         sdhc_debug("SDHCI switched MMC to 8-bit DDR\n");
 254
 255         /* Set controller to 8-bit mode */
 256         SET_BUS_WIDTH(ctrlr, 8);
 257         media->caps |= EXT_CSD_BUS_WIDTH_8;
 258
 259         /* Switch MMC device to HS400 */
 260         ret = mmc_switch(media, EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS400);
 261         if (ret) {
 262                 sd_mmc_error("Switch to HS400 timing failed\n");
 263                 return ret;
 264         }
 265
 266         /* Set controller to 200 MHz and use receive strobe */
 267         SET_TIMING(ctrlr, timing);
 268         media->caps |= caps;
 269         mmc_recalculate_clock(media);
 270         ret = sd_mmc_send_status(media, SD_MMC_IO_RETRIES);
 271         return ret;
 272 }
 273
 274 static int mmc_select_hs200(struct storage_media *media)
 275 {
 276         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 277         int ret;
 278
 279         /* Switch the MMC device to 8-bit SDR */
 280         ret = mmc_switch(media, EXT_CSD_BUS_WIDTH, EXT_CSD_BUS_WIDTH_8);
 281         if (ret) {
 282                 sd_mmc_error("Switching bus width for HS200 failed\n");
 283                 return ret;
 284         }
 285
 286         /* Set controller to 8-bit mode */
 287         SET_BUS_WIDTH(ctrlr, 8);
 288         media->caps |= EXT_CSD_BUS_WIDTH_8;
 289
 290         /* Switch to HS200 */
 291         ret = mmc_switch(media, EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS200);
 292
 293         if (ret) {
 294                 sd_mmc_error("Switch to HS200 failed\n");
 295                 return ret;
 296         }
 297         sdhc_debug("SDHCI switched MMC to 8-bit SDR\n");
 298
 299         /* Set controller to 200 MHz */
 300         SET_TIMING(ctrlr, BUS_TIMING_MMC_HS200);
 301         media->caps |= DRVR_CAP_HS200 | DRVR_CAP_HS52 | DRVR_CAP_HS;
 302         mmc_recalculate_clock(media);
 303
 304         /* Tune the receive sampling point for the bus */
 305         if ((!ret) && (ctrlr->caps & DRVR_CAP_HS200_TUNING))
 306                 ret = mmc_bus_tuning(media);
 307         return ret;
 308 }
 309
 310 int mmc_change_freq(struct storage_media *media)
 311 {
 312         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 313         int err;
 314         ALLOC_CACHE_ALIGN_BUFFER(unsigned char, ext_csd, 512);
 315
 316         media->caps = 0;
 317
 318         /* Only version 4 supports high-speed */
 319         if (media->version < MMC_VERSION_4)
 320                 return 0;
 321
 322         err = mmc_send_ext_csd(ctrlr, ext_csd);
 323         if (err)
 324                 return err;
 325
 326         /* Determine if the device supports enhanced strobe */
 327         media->caps |= ext_csd[EXT_CSD_STROBE_SUPPORT]
 328                 ? DRVR_CAP_ENHANCED_STROBE : 0;
 329
 330         if ((ctrlr->caps & DRVR_CAP_HS400) &&
 331             (ext_csd[EXT_CSD_CARD_TYPE] & MMC_HS400))
 332                 err = mmc_select_hs400(media);
 333         else if ((ctrlr->caps & DRVR_CAP_HS200) &&
 334                  (ext_csd[EXT_CSD_CARD_TYPE] & MMC_HS_200MHZ))
 335                 err = mmc_select_hs200(media);
 336         else
 337                 err = mmc_select_hs(media);
 338
 339         return err;
 340 }
 341
 342 int mmc_set_bus_width(struct storage_media *media)
 343 {
 344         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 345         int err;
 346         int width;
 347
 348         ALLOC_CACHE_ALIGN_BUFFER(unsigned char, ext_csd, EXT_CSD_SIZE);
 349         ALLOC_CACHE_ALIGN_BUFFER(unsigned char, test_csd, EXT_CSD_SIZE);
 350
 351         /* Set the bus width */
 352         err = 0;
 353         for (width = EXT_CSD_BUS_WIDTH_8; width >= 0; width--) {
 354                 /* If HS200 is switched, Bus Width has been 8-bit */
 355                 if ((media->caps & DRVR_CAP_HS200) ||
 356                     (media->caps & DRVR_CAP_HS400))
 357                         break;
 358
 359                 /* Set the card to use 4 bit*/
 360                 err = mmc_switch(media, EXT_CSD_BUS_WIDTH, width);
 361                 if (err)
 362                         continue;
 363
 364                 if (!width) {
 365                         SET_BUS_WIDTH(ctrlr, 1);
 366                         break;
 367                 }
 368                 SET_BUS_WIDTH(ctrlr, 4 * width);
 369
 370                 err = mmc_send_ext_csd(ctrlr, test_csd);
 371                 if (!err &&
 372                     (ext_csd[EXT_CSD_PARTITIONING_SUPPORT] ==
 373                     test_csd[EXT_CSD_PARTITIONING_SUPPORT]) &&
 374                     (ext_csd[EXT_CSD_ERASE_GROUP_DEF] ==
 375                     test_csd[EXT_CSD_ERASE_GROUP_DEF]) &&
 376                     (ext_csd[EXT_CSD_REV] ==
 377                     test_csd[EXT_CSD_REV]) &&
 378                     (ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] ==
 379                     test_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
 380                     memcmp(&ext_csd[EXT_CSD_SEC_CNT],
 381                            &test_csd[EXT_CSD_SEC_CNT], 4) == 0) {
 382                         media->caps |= width;
 383                         break;
 384                 }
 385         }
 386         return err;
 387 }
 388
 389 int mmc_update_capacity(struct storage_media *media)
 390 {
 391         uint64_t capacity;
 392         struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
 393         int err;
 394         ALLOC_CACHE_ALIGN_BUFFER(unsigned char, ext_csd, EXT_CSD_SIZE);
 395         uint32_t erase_size;
 396         uint32_t hc_erase_size;
 397         uint64_t hc_wp_size;
 398         int index;
 399
 400         if (media->version < MMC_VERSION_4)
 401                 return 0;
 402
 403         /* check  ext_csd version and capacity */
 404         err = mmc_send_ext_csd(ctrlr, ext_csd);
 405         if (err)
 406                 return err;
 407
 408         if (ext_csd[EXT_CSD_REV] < 2)
 409                 return 0;
 410
 411         /* Determine the eMMC device information */
 412         media->partition_config = ext_csd[EXT_CSD_PART_CONF]
 413                 & EXT_CSD_PART_ACCESS_MASK;
 414
 415         /* Determine the user partition size
 416          *
 417          * According to the JEDEC Standard, the value of
 418          * ext_csd's capacity is valid if the value is
 419          * more than 2GB
 420          */
 421         capacity = (uint32_t)(ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
 422                     ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
 423                     ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
 424                     ext_csd[EXT_CSD_SEC_CNT + 3] << 24);
 425         capacity *= 512;
 426         if ((capacity >> 20) > 2 * 1024)
 427                 media->capacity[MMC_PARTITION_USER] = capacity;
 428
 429         /* Determine the boot partition sizes */
 430         hc_erase_size = ext_csd[224] * 512 * KiB;
 431         capacity = ext_csd[EXT_CSD_BOOT_SIZE_MULT] * 128 * KiB;
 432         media->capacity[MMC_PARTITION_BOOT_1] = capacity;
 433         media->capacity[MMC_PARTITION_BOOT_2] = capacity;
 434
 435         /* Determine the RPMB size */
 436         hc_wp_size = ext_csd[EXT_CSD_HC_WP_GRP_SIZE] * hc_erase_size;
 437         capacity = 128 * KiB * ext_csd[EXT_CSD_RPMB_SIZE_MULT];
 438         media->capacity[MMC_PARTITION_RPMB] = capacity;
 439
 440         /* Determine the general partition sizes */
 441         capacity = (ext_csd[EXT_CSD_GP_SIZE_MULT_GP0 + 2] << 16)
 442                 | (ext_csd[EXT_CSD_GP_SIZE_MULT_GP0 + 1] << 8)
 443                 | ext_csd[EXT_CSD_GP_SIZE_MULT_GP0];
 444         capacity *= hc_wp_size;
 445         media->capacity[MMC_PARTITION_GP1] = capacity;
 446
 447         capacity = (ext_csd[EXT_CSD_GP_SIZE_MULT_GP1 + 2] << 16)
 448                 | (ext_csd[EXT_CSD_GP_SIZE_MULT_GP1 + 1] << 8)
 449                 | ext_csd[EXT_CSD_GP_SIZE_MULT_GP1];
 450         capacity *= hc_wp_size;
 451         media->capacity[MMC_PARTITION_GP2] = capacity;
 452
 453         capacity = (ext_csd[EXT_CSD_GP_SIZE_MULT_GP2 + 2] << 16)
 454                 | (ext_csd[EXT_CSD_GP_SIZE_MULT_GP2 + 1] << 8)
 455                 | ext_csd[EXT_CSD_GP_SIZE_MULT_GP2];
 456         capacity *= hc_wp_size;
 457         media->capacity[MMC_PARTITION_GP3] = capacity;
 458
 459         capacity = (ext_csd[EXT_CSD_GP_SIZE_MULT_GP3 + 2] << 16)
 460                 | (ext_csd[EXT_CSD_GP_SIZE_MULT_GP3 + 1] << 8)
 461                 | ext_csd[EXT_CSD_GP_SIZE_MULT_GP3];
 462         capacity *= hc_wp_size;
 463         media->capacity[MMC_PARTITION_GP4] = capacity;
 464
 465         /* Determine the erase size */
 466         erase_size = (sd_mmc_extract_uint32_bits(media->csd,
 467                 81, 5) + 1) *
 468                 (sd_mmc_extract_uint32_bits(media->csd, 86, 5)
 469                 + 1);
 470         for (index = MMC_PARTITION_BOOT_1; index <= MMC_PARTITION_GP4;
 471                 index++) {
 472                 if (media->capacity[index] != 0) {
 473                         /* Enable the partitions  */
 474                         err = mmc_switch(media, EXT_CSD_ERASE_GROUP_DEF,
 475                                 EXT_CSD_PARTITION_ENABLE);
 476                         if (err) {
 477                                 sdhc_error("Failed to enable partition access\n");
 478                                 return err;
 479                         }
 480
 481                         /* Use HC erase group size */
 482                         erase_size = hc_erase_size / media->write_bl_len;
 483                         break;
 484                 }
 485         }
 486         media->erase_blocks = erase_size;
 487         media->trim_mult = ext_csd[EXT_CSD_TRIM_MULT];
 488
 489         return 0;
 490 }
 491
 492 int mmc_set_partition(struct storage_media *media,
 493         unsigned int partition_number)
 494 {
 495         uint8_t partition_config;
 496
 497         /* Validate the partition number */
 498         if ((partition_number > MMC_PARTITION_GP4)
 499                 || (!media->capacity[partition_number]))
 500                 return -1;
 501
 502         /* Update the partition register */
 503         partition_config = media->partition_config;
 504         partition_config &= ~EXT_CSD_PART_ACCESS_MASK;
 505         partition_config |= partition_number;
 506
 507         /* Select the new partition */
 508         int ret = mmc_switch(media, EXT_CSD_PART_CONF, partition_config);
 509         if (!ret)
 510                 media->partition_config = partition_config;
 511
 512         return ret;
 513 }
 514
 515 const char *mmc_partition_name(struct storage_media *media,
 516         unsigned int partition_number)
 517 {
 518         static const char *const partition_name[8] = {
 519                 "User",         /* 0 */
 520                 "Boot 1",       /* 1 */
 521                 "Boot 2",       /* 2 */
 522                 "RPMB",         /* 3 */
 523                 "GP 1",         /* 4 */
 524                 "GP 2",         /* 5 */
 525                 "GP 3",         /* 6 */
 526                 "GP 4"          /* 7 */
 527         };
 528
 529         if (partition_number >= ARRAY_SIZE(partition_name))
 530                 return "";
 531         return partition_name[partition_number];
 532 }
 533
 534 void mmc_set_early_wake_status(int32_t status)
 535 {
 536         int32_t *ms_cbmem;
 537
 538         ms_cbmem = cbmem_add(CBMEM_ID_MMC_STATUS, sizeof(status));
 539
 540         if (!ms_cbmem) {
 541                 printk(BIOS_ERR,
 542                        "%s: Failed to add early mmc wake status to cbmem!\n",
 543                        __func__);
 544                 return;
 545         }
 546
 547         *ms_cbmem = status;
 548 }
 549
 550 int mmc_send_cmd1(struct storage_media *media)
 551 {
 552         int err;
 553
 554         /* Reset emmc, send CMD0 */
 555         if (sd_mmc_go_idle(media))
 556                 goto out_err;
 557
 558         /* Send CMD1 */
 559         err = mmc_send_op_cond(media);
 560         if (err == 0) {
 561                 if (media->op_cond_response & OCR_HCS)
 562                         mmc_set_early_wake_status(MMC_STATUS_CMD1_READY_HCS);
 563                 else
 564                         mmc_set_early_wake_status(MMC_STATUS_CMD1_READY);
 565         } else if (err == CARD_IN_PROGRESS) {
 566                 mmc_set_early_wake_status(MMC_STATUS_CMD1_IN_PROGRESS);
 567         } else {
 568                 goto out_err;
 569         }
 570
 571         return 0;
 572
 573 out_err:
 574         mmc_set_early_wake_status(MMC_STATUS_NEED_RESET);
 575         return -1;
 576 }