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 <blk.h>
11 #include <dm.h>
12 #include <part.h>
13 #include <div64.h>
14 #include <linux/math64.h>
15 #include "mmc_private.h"
16
mmc_erase_t(struct mmc * mmc,ulong start,lbaint_t blkcnt,u32 args)17 static ulong mmc_erase_t(struct mmc *mmc, ulong start, lbaint_t blkcnt, u32 args)
18 {
19 struct mmc_cmd cmd;
20 ulong end;
21 int err, start_cmd, end_cmd;
22
23 if (mmc->high_capacity) {
24 end = start + blkcnt - 1;
25 } else {
26 end = (start + blkcnt - 1) * mmc->write_bl_len;
27 start *= mmc->write_bl_len;
28 }
29
30 if (IS_SD(mmc)) {
31 start_cmd = SD_CMD_ERASE_WR_BLK_START;
32 end_cmd = SD_CMD_ERASE_WR_BLK_END;
33 } else {
34 start_cmd = MMC_CMD_ERASE_GROUP_START;
35 end_cmd = MMC_CMD_ERASE_GROUP_END;
36 }
37
38 cmd.cmdidx = start_cmd;
39 cmd.cmdarg = start;
40 cmd.resp_type = MMC_RSP_R1;
41
42 err = mmc_send_cmd(mmc, &cmd, NULL);
43 if (err)
44 goto err_out;
45
46 cmd.cmdidx = end_cmd;
47 cmd.cmdarg = end;
48
49 err = mmc_send_cmd(mmc, &cmd, NULL);
50 if (err)
51 goto err_out;
52
53 cmd.cmdidx = MMC_CMD_ERASE;
54 cmd.cmdarg = args ? args : MMC_ERASE_ARG;
55 cmd.resp_type = MMC_RSP_R1b;
56
57 err = mmc_send_cmd(mmc, &cmd, NULL);
58 if (err)
59 goto err_out;
60
61 return 0;
62
63 err_out:
64 puts("mmc erase failed\n");
65 return err;
66 }
67
68 #if CONFIG_IS_ENABLED(BLK)
mmc_berase(struct udevice * dev,lbaint_t start,lbaint_t blkcnt)69 ulong mmc_berase(struct udevice *dev, lbaint_t start, lbaint_t blkcnt)
70 #else
71 ulong mmc_berase(struct blk_desc *block_dev, lbaint_t start, lbaint_t blkcnt)
72 #endif
73 {
74 #if CONFIG_IS_ENABLED(BLK)
75 struct blk_desc *block_dev = dev_get_uclass_plat(dev);
76 #endif
77 int dev_num = block_dev->devnum;
78 int err = 0;
79 u32 start_rem, blkcnt_rem, erase_args = 0;
80 struct mmc *mmc = find_mmc_device(dev_num);
81 lbaint_t blk = 0, blk_r = 0;
82 int timeout_ms = 1000;
83 u32 grpcnt;
84
85
86 if (!mmc)
87 return -1;
88
89 err = blk_select_hwpart_devnum(UCLASS_MMC, dev_num,
90 block_dev->hwpart);
91 if (err < 0)
92 return -1;
93
94 /*
95 * We want to see if the requested start or total block count are
96 * unaligned. We discard the whole numbers and only care about the
97 * remainder.
98 */
99 err = div_u64_rem(start, mmc->erase_grp_size, &start_rem);
100 err = div_u64_rem(blkcnt, mmc->erase_grp_size, &blkcnt_rem);
101 if (start_rem || blkcnt_rem) {
102 if (mmc->can_trim) {
103 /* Trim function applies the erase operation to write
104 * blocks instead of erase groups.
105 */
106 erase_args = MMC_TRIM_ARG;
107 } else {
108 /* The card ignores all LSB's below the erase group
109 * size, rounding down the addess to a erase group
110 * boundary.
111 */
112 printf("\n\nCaution! Your devices Erase group is 0x%x\n"
113 "The erase range would be change to "
114 "0x" LBAF "~0x" LBAF "\n\n",
115 mmc->erase_grp_size, start & ~(mmc->erase_grp_size - 1),
116 ((start + blkcnt + mmc->erase_grp_size - 1)
117 & ~(mmc->erase_grp_size - 1)) - 1);
118 }
119 }
120
121 while (blk < blkcnt) {
122 if (IS_SD(mmc) && mmc->ssr.au) {
123 blk_r = ((blkcnt - blk) > mmc->ssr.au) ?
124 mmc->ssr.au : (blkcnt - blk);
125 } else {
126 blk_r = ((blkcnt - blk) > mmc->erase_grp_size) ?
127 mmc->erase_grp_size : (blkcnt - blk);
128
129 grpcnt = (blkcnt - blk) / mmc->erase_grp_size;
130 /* Max 2GB per spec */
131 if ((blkcnt - blk) > 0x400000)
132 blk_r = 0x400000;
133 else if (grpcnt)
134 blk_r = grpcnt * mmc->erase_grp_size;
135 else
136 blk_r = blkcnt - blk;
137 }
138 err = mmc_erase_t(mmc, start + blk, blk_r, erase_args);
139 if (err)
140 break;
141
142 blk += blk_r;
143
144 /* Waiting for the ready status */
145 if (mmc_poll_for_busy(mmc, timeout_ms))
146 return 0;
147 }
148
149 return blk;
150 }
151
mmc_write_blocks(struct mmc * mmc,lbaint_t start,lbaint_t blkcnt,const void * src)152 static ulong mmc_write_blocks(struct mmc *mmc, lbaint_t start,
153 lbaint_t blkcnt, const void *src)
154 {
155 struct mmc_cmd cmd;
156 struct mmc_data data;
157 int timeout_ms = 1000;
158 int err;
159
160 if ((start + blkcnt) > mmc_get_blk_desc(mmc)->lba) {
161 printf("MMC: block number 0x" LBAF " exceeds max(0x" LBAF ")\n",
162 start + blkcnt, mmc_get_blk_desc(mmc)->lba);
163 return 0;
164 }
165
166 if (blkcnt == 0)
167 return 0;
168 else if (blkcnt == 1)
169 cmd.cmdidx = MMC_CMD_WRITE_SINGLE_BLOCK;
170 else
171 cmd.cmdidx = MMC_CMD_WRITE_MULTIPLE_BLOCK;
172
173 if (mmc->high_capacity)
174 cmd.cmdarg = start;
175 else
176 cmd.cmdarg = start * mmc->write_bl_len;
177
178 cmd.resp_type = MMC_RSP_R1;
179
180 data.src = src;
181 data.blocks = blkcnt;
182 data.blocksize = mmc->write_bl_len;
183 data.flags = MMC_DATA_WRITE;
184
185 err = mmc_send_cmd(mmc, &cmd, &data);
186 if (err) {
187 printf("mmc write failed\n");
188 /*
189 * Don't return 0 here since the emmc will still be in data
190 * transfer mode continue to send the STOP_TRANSMISSION command
191 */
192 }
193
194 /* SPI multiblock writes terminate using a special
195 * token, not a STOP_TRANSMISSION request.
196 */
197 if (!mmc_host_is_spi(mmc) && blkcnt > 1) {
198 cmd.cmdidx = MMC_CMD_STOP_TRANSMISSION;
199 cmd.cmdarg = 0;
200 cmd.resp_type = MMC_RSP_R1b;
201 if (mmc_send_cmd(mmc, &cmd, NULL)) {
202 printf("mmc fail to send stop cmd\n");
203 return 0;
204 }
205 }
206
207 /* Waiting for the ready status */
208 if (mmc_poll_for_busy(mmc, timeout_ms))
209 return 0;
210
211 if (err)
212 return 0;
213
214 return blkcnt;
215 }
216
217 #if CONFIG_IS_ENABLED(BLK)
mmc_bwrite(struct udevice * dev,lbaint_t start,lbaint_t blkcnt,const void * src)218 ulong mmc_bwrite(struct udevice *dev, lbaint_t start, lbaint_t blkcnt,
219 const void *src)
220 #else
221 ulong mmc_bwrite(struct blk_desc *block_dev, lbaint_t start, lbaint_t blkcnt,
222 const void *src)
223 #endif
224 {
225 #if CONFIG_IS_ENABLED(BLK)
226 struct blk_desc *block_dev = dev_get_uclass_plat(dev);
227 #endif
228 int dev_num = block_dev->devnum;
229 lbaint_t cur, blocks_todo = blkcnt;
230 int err;
231
232 struct mmc *mmc = find_mmc_device(dev_num);
233 if (!mmc)
234 return 0;
235
236 err = blk_select_hwpart_devnum(UCLASS_MMC, dev_num, block_dev->hwpart);
237 if (err < 0)
238 return 0;
239
240 if (mmc_set_blocklen(mmc, mmc->write_bl_len))
241 return 0;
242
243 do {
244 cur = (blocks_todo > mmc->cfg->b_max) ?
245 mmc->cfg->b_max : blocks_todo;
246 if (mmc_write_blocks(mmc, start, cur, src) != cur)
247 return 0;
248 blocks_todo -= cur;
249 start += cur;
250 src += cur * mmc->write_bl_len;
251 } while (blocks_todo > 0);
252
253 return blkcnt;
254 }
255