drivers/mmc/mmc_write.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2008, Freescale Semiconductor, Inc
   4  * Andy Fleming
   5  *
   6  * Based vaguely on the Linux code
   7  */
   8
   9 #include <config.h>
  10 #include <common.h>
  11 #include <blk.h>
  12 #include <dm.h>
  13 #include <part.h>
  14 #include <div64.h>
  15 #include <linux/math64.h>
  16 #include "mmc_private.h"
  17
  18 static ulong mmc_erase_t(struct mmc *mmc, ulong start, lbaint_t blkcnt)
  19 {
  20         struct mmc_cmd cmd;
  21         ulong end;
  22         int err, start_cmd, end_cmd;
  23
  24         if (mmc->high_capacity) {
  25                 end = start + blkcnt - 1;
  26         } else {
  27                 end = (start + blkcnt - 1) * mmc->write_bl_len;
  28                 start *= mmc->write_bl_len;
  29         }
  30
  31         if (IS_SD(mmc)) {
  32                 start_cmd = SD_CMD_ERASE_WR_BLK_START;
  33                 end_cmd = SD_CMD_ERASE_WR_BLK_END;
  34         } else {
  35                 start_cmd = MMC_CMD_ERASE_GROUP_START;
  36                 end_cmd = MMC_CMD_ERASE_GROUP_END;
  37         }
  38
  39         cmd.cmdidx = start_cmd;
  40         cmd.cmdarg = start;
  41         cmd.resp_type = MMC_RSP_R1;
  42
  43         err = mmc_send_cmd(mmc, &cmd, NULL);
  44         if (err)
  45                 goto err_out;
  46
  47         cmd.cmdidx = end_cmd;
  48         cmd.cmdarg = end;
  49
  50         err = mmc_send_cmd(mmc, &cmd, NULL);
  51         if (err)
  52                 goto err_out;
  53
  54         cmd.cmdidx = MMC_CMD_ERASE;
  55         cmd.cmdarg = MMC_ERASE_ARG;
  56         cmd.resp_type = MMC_RSP_R1b;
  57
  58         err = mmc_send_cmd(mmc, &cmd, NULL);
  59         if (err)
  60                 goto err_out;
  61
  62         return 0;
  63
  64 err_out:
  65         puts("mmc erase failed\n");
  66         return err;
  67 }
  68
  69 #if CONFIG_IS_ENABLED(BLK)
  70 ulong mmc_berase(struct udevice *dev, lbaint_t start, lbaint_t blkcnt)
  71 #else
  72 ulong mmc_berase(struct blk_desc *block_dev, lbaint_t start, lbaint_t blkcnt)
  73 #endif
  74 {
  75 #if CONFIG_IS_ENABLED(BLK)
  76         struct blk_desc *block_dev = dev_get_uclass_plat(dev);
  77 #endif
  78         int dev_num = block_dev->devnum;
  79         int err = 0;
  80         u32 start_rem, blkcnt_rem;
  81         struct mmc *mmc = find_mmc_device(dev_num);
  82         lbaint_t blk = 0, blk_r = 0;
  83         int timeout_ms = 1000;
  84
  85         if (!mmc)
  86                 return -1;
  87
  88         err = blk_select_hwpart_devnum(UCLASS_MMC, dev_num,
  89                                        block_dev->hwpart);
  90         if (err < 0)
  91                 return -1;
  92
  93         /*
  94          * We want to see if the requested start or total block count are
  95          * unaligned.  We discard the whole numbers and only care about the
  96          * remainder.
  97          */
  98         err = div_u64_rem(start, mmc->erase_grp_size, &start_rem);
  99         err = div_u64_rem(blkcnt, mmc->erase_grp_size, &blkcnt_rem);
 100         if (start_rem || blkcnt_rem)
 101                 printf("\n\nCaution! Your devices Erase group is 0x%x\n"
 102                        "The erase range would be change to "
 103                        "0x" LBAF "~0x" LBAF "\n\n",
 104                        mmc->erase_grp_size, start & ~(mmc->erase_grp_size - 1),
 105                        ((start + blkcnt + mmc->erase_grp_size - 1)
 106                        & ~(mmc->erase_grp_size - 1)) - 1);
 107
 108         while (blk < blkcnt) {
 109                 if (IS_SD(mmc) && mmc->ssr.au) {
 110                         blk_r = ((blkcnt - blk) > mmc->ssr.au) ?
 111                                 mmc->ssr.au : (blkcnt - blk);
 112                 } else {
 113                         blk_r = ((blkcnt - blk) > mmc->erase_grp_size) ?
 114                                 mmc->erase_grp_size : (blkcnt - blk);
 115                 }
 116                 err = mmc_erase_t(mmc, start + blk, blk_r);
 117                 if (err)
 118                         break;
 119
 120                 blk += blk_r;
 121
 122                 /* Waiting for the ready status */
 123                 if (mmc_poll_for_busy(mmc, timeout_ms))
 124                         return 0;
 125         }
 126
 127         return blk;
 128 }
 129
 130 static ulong mmc_write_blocks(struct mmc *mmc, lbaint_t start,
 131                 lbaint_t blkcnt, const void *src)
 132 {
 133         struct mmc_cmd cmd;
 134         struct mmc_data data;
 135         int timeout_ms = 1000;
 136
 137         if ((start + blkcnt) > mmc_get_blk_desc(mmc)->lba) {
 138                 printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n",
 139                        start + blkcnt, mmc_get_blk_desc(mmc)->lba);
 140                 return 0;
 141         }
 142
 143         if (blkcnt == 0)
 144                 return 0;
 145         else if (blkcnt == 1)
 146                 cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK;
 147         else
 148                 cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;
 149
 150         if (mmc->high_capacity)
 151                 cmd.cmdarg = start;
 152         else
 153                 cmd.cmdarg = start * mmc->write_bl_len;
 154
 155         cmd.resp_type = MMC_RSP_R1;
 156
 157         data.src = src;
 158         data.blocks = blkcnt;
 159         data.blocksize = mmc->write_bl_len;
 160         data.flags = MMC_DATA_WRITE;
 161
 162         if (mmc_send_cmd(mmc, &cmd, &data)) {
 163                 printf("mmc write failed\n");
 164                 return 0;
 165         }
 166
 167         /* SPI multiblock writes terminate using a special
 168          * token, not a STOP_TRANSMISSION request.
 169          */
 170         if (!mmc_host_is_spi(mmc) && blkcnt > 1) {
 171                 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
 172                 cmd.cmdarg = 0;
 173                 cmd.resp_type = MMC_RSP_R1b;
 174                 if (mmc_send_cmd(mmc, &cmd, NULL)) {
 175                         printf("mmc fail to send stop cmd\n");
 176                         return 0;
 177                 }
 178         }
 179
 180         /* Waiting for the ready status */
 181         if (mmc_poll_for_busy(mmc, timeout_ms))
 182                 return 0;
 183
 184         return blkcnt;
 185 }
 186
 187 #if CONFIG_IS_ENABLED(BLK)
 188 ulong mmc_bwrite(struct udevice *dev, lbaint_t start, lbaint_t blkcnt,
 189                  const void *src)
 190 #else
 191 ulong mmc_bwrite(struct blk_desc *block_dev, lbaint_t start, lbaint_t blkcnt,
 192                  const void *src)
 193 #endif
 194 {
 195 #if CONFIG_IS_ENABLED(BLK)
 196         struct blk_desc *block_dev = dev_get_uclass_plat(dev);
 197 #endif
 198         int dev_num = block_dev->devnum;
 199         lbaint_t cur, blocks_todo = blkcnt;
 200         int err;
 201
 202         struct mmc *mmc = find_mmc_device(dev_num);
 203         if (!mmc)
 204                 return 0;
 205
 206         err = blk_select_hwpart_devnum(UCLASS_MMC, dev_num, block_dev->hwpart);
 207         if (err < 0)
 208                 return 0;
 209
 210         if (mmc_set_blocklen(mmc, mmc->write_bl_len))
 211                 return 0;
 212
 213         do {
 214                 cur = (blocks_todo > mmc->cfg->b_max) ?
 215                         mmc->cfg->b_max : blocks_todo;
 216                 if (mmc_write_blocks(mmc, start, cur, src) != cur)
 217                         return 0;
 218                 blocks_todo -= cur;
 219                 start += cur;
 220                 src += cur * mmc->write_bl_len;
 221         } while (blocks_todo > 0);
 222
 223         return blkcnt;
 224 }