2 * Copyright 2008, Freescale Semiconductor, Inc
5 * Based vaguely on the Linux code
7 * SPDX-License-Identifier: GPL-2.0+
14 #include <linux/math64.h>
15 #include "mmc_private.h"
17 static ulong mmc_erase_t(struct mmc *mmc, ulong start, lbaint_t blkcnt)
21 int err, start_cmd, end_cmd;
23 if (mmc->high_capacity) {
24 end = start + blkcnt - 1;
26 end = (start + blkcnt - 1) * mmc->write_bl_len;
27 start *= mmc->write_bl_len;
31 start_cmd = SD_CMD_ERASE_WR_BLK_START;
32 end_cmd = SD_CMD_ERASE_WR_BLK_END;
34 start_cmd = MMC_CMD_ERASE_GROUP_START;
35 end_cmd = MMC_CMD_ERASE_GROUP_END;
38 cmd.cmdidx = start_cmd;
40 cmd.resp_type = MMC_RSP_R1;
42 err = mmc_send_cmd(mmc, &cmd, NULL);
49 err = mmc_send_cmd(mmc, &cmd, NULL);
53 cmd.cmdidx = MMC_CMD_ERASE;
54 cmd.cmdarg = MMC_ERASE_ARG;
55 cmd.resp_type = MMC_RSP_R1b;
57 err = mmc_send_cmd(mmc, &cmd, NULL);
64 puts("mmc erase failed\n");
68 unsigned long mmc_berase(int dev_num, lbaint_t start, lbaint_t blkcnt)
71 u32 start_rem, blkcnt_rem;
72 struct mmc *mmc = find_mmc_device(dev_num);
73 lbaint_t blk = 0, blk_r = 0;
80 * We want to see if the requested start or total block count are
81 * unaligned. We discard the whole numbers and only care about the
84 err = div_u64_rem(start, mmc->erase_grp_size, &start_rem);
85 err = div_u64_rem(blkcnt, mmc->erase_grp_size, &blkcnt_rem);
86 if (start_rem || blkcnt_rem)
87 printf("\n\nCaution! Your devices Erase group is 0x%x\n"
88 "The erase range would be change to "
89 "0x" LBAF "~0x" LBAF "\n\n",
90 mmc->erase_grp_size, start & ~(mmc->erase_grp_size - 1),
91 ((start + blkcnt + mmc->erase_grp_size)
92 & ~(mmc->erase_grp_size - 1)) - 1);
94 while (blk < blkcnt) {
95 blk_r = ((blkcnt - blk) > mmc->erase_grp_size) ?
96 mmc->erase_grp_size : (blkcnt - blk);
97 err = mmc_erase_t(mmc, start + blk, blk_r);
103 /* Waiting for the ready status */
104 if (mmc_send_status(mmc, timeout))
111 static ulong mmc_write_blocks(struct mmc *mmc, lbaint_t start,
112 lbaint_t blkcnt, const void *src)
115 struct mmc_data data;
118 if ((start + blkcnt) > mmc->block_dev.lba) {
119 printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n",
120 start + blkcnt, mmc->block_dev.lba);
126 else if (blkcnt == 1)
127 cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK;
129 cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;
131 if (mmc->high_capacity)
134 cmd.cmdarg = start * mmc->write_bl_len;
136 cmd.resp_type = MMC_RSP_R1;
139 data.blocks = blkcnt;
140 data.blocksize = mmc->write_bl_len;
141 data.flags = MMC_DATA_WRITE;
143 if (mmc_send_cmd(mmc, &cmd, &data)) {
144 printf("mmc write failed\n");
148 /* SPI multiblock writes terminate using a special
149 * token, not a STOP_TRANSMISSION request.
151 if (!mmc_host_is_spi(mmc) && blkcnt > 1) {
152 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
154 cmd.resp_type = MMC_RSP_R1b;
155 if (mmc_send_cmd(mmc, &cmd, NULL)) {
156 printf("mmc fail to send stop cmd\n");
161 /* Waiting for the ready status */
162 if (mmc_send_status(mmc, timeout))
168 ulong mmc_bwrite(int dev_num, lbaint_t start, lbaint_t blkcnt, const void *src)
170 lbaint_t cur, blocks_todo = blkcnt;
172 struct mmc *mmc = find_mmc_device(dev_num);
176 if (mmc_set_blocklen(mmc, mmc->write_bl_len))
180 cur = (blocks_todo > mmc->cfg->b_max) ?
181 mmc->cfg->b_max : blocks_todo;
182 if (mmc_write_blocks(mmc, start, cur, src) != cur)
186 src += cur * mmc->write_bl_len;
187 } while (blocks_todo > 0);