1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * (C) Copyright 2008-2011 Freescale Semiconductor, Inc.
4 */
5
6 /* #define DEBUG */
7
8 #include <common.h>
9 #include <asm/global_data.h>
10
11 #include <command.h>
12 #include <env.h>
13 #include <env_internal.h>
14 #include <fdtdec.h>
15 #include <linux/stddef.h>
16 #include <malloc.h>
17 #include <memalign.h>
18 #include <mmc.h>
19 #include <part.h>
20 #include <search.h>
21 #include <errno.h>
22
23 #define __STR(X) #X
24 #define STR(X) __STR(X)
25
26 DECLARE_GLOBAL_DATA_PTR;
27
28 #if CONFIG_IS_ENABLED(OF_CONTROL)
mmc_offset_try_partition(const char * str,int copy,s64 * val)29 static inline int mmc_offset_try_partition(const char *str, int copy, s64 *val)
30 {
31 struct disk_partition info;
32 struct blk_desc *desc;
33 int len, i, ret;
34 char dev_str[4];
35
36 snprintf(dev_str, sizeof(dev_str), "%d", mmc_get_env_dev());
37 ret = blk_get_device_by_str("mmc", dev_str, &desc);
38 if (ret < 0)
39 return (ret);
40
41 for (i = 1;;i++) {
42 ret = part_get_info(desc, i, &info);
43 if (ret < 0)
44 return ret;
45
46 if (!strncmp((const char *)info.name, str, sizeof(info.name)))
47 break;
48 }
49
50 /* round up to info.blksz */
51 len = DIV_ROUND_UP(CONFIG_ENV_SIZE, info.blksz);
52
53 /* use the top of the partion for the environment */
54 *val = (info.start + info.size - (1 + copy) * len) * info.blksz;
55
56 return 0;
57 }
58
mmc_offset(int copy)59 static inline s64 mmc_offset(int copy)
60 {
61 const struct {
62 const char *offset_redund;
63 const char *partition;
64 const char *offset;
65 } dt_prop = {
66 .offset_redund = "u-boot,mmc-env-offset-redundant",
67 .partition = "u-boot,mmc-env-partition",
68 .offset = "u-boot,mmc-env-offset",
69 };
70 s64 val = 0, defvalue;
71 const char *propname;
72 const char *str;
73 int err;
74
75 /* look for the partition in mmc CONFIG_SYS_MMC_ENV_DEV */
76 str = fdtdec_get_config_string(gd->fdt_blob, dt_prop.partition);
77 if (str) {
78 /* try to place the environment at end of the partition */
79 err = mmc_offset_try_partition(str, copy, &val);
80 if (!err)
81 return val;
82 }
83
84 defvalue = CONFIG_ENV_OFFSET;
85 propname = dt_prop.offset;
86
87 #if defined(CONFIG_ENV_OFFSET_REDUND)
88 if (copy) {
89 defvalue = CONFIG_ENV_OFFSET_REDUND;
90 propname = dt_prop.offset_redund;
91 }
92 #endif
93 return fdtdec_get_config_int(gd->fdt_blob, propname, defvalue);
94 }
95 #else
mmc_offset(int copy)96 static inline s64 mmc_offset(int copy)
97 {
98 s64 offset = CONFIG_ENV_OFFSET;
99
100 #if defined(CONFIG_ENV_OFFSET_REDUND)
101 if (copy)
102 offset = CONFIG_ENV_OFFSET_REDUND;
103 #endif
104 return offset;
105 }
106 #endif
107
mmc_get_env_addr(struct mmc * mmc,int copy,u32 * env_addr)108 __weak int mmc_get_env_addr(struct mmc *mmc, int copy, u32 *env_addr)
109 {
110 s64 offset = mmc_offset(copy);
111
112 if (offset < 0)
113 offset += mmc->capacity;
114
115 *env_addr = offset;
116
117 return 0;
118 }
119
120 #ifdef CONFIG_SYS_MMC_ENV_PART
mmc_get_env_part(struct mmc * mmc)121 __weak uint mmc_get_env_part(struct mmc *mmc)
122 {
123 return CONFIG_SYS_MMC_ENV_PART;
124 }
125
126 static unsigned char env_mmc_orig_hwpart;
127
mmc_set_env_part(struct mmc * mmc)128 static int mmc_set_env_part(struct mmc *mmc)
129 {
130 uint part = mmc_get_env_part(mmc);
131 int dev = mmc_get_env_dev();
132 int ret = 0;
133
134 env_mmc_orig_hwpart = mmc_get_blk_desc(mmc)->hwpart;
135 ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part);
136 if (ret)
137 puts("MMC partition switch failed\n");
138
139 return ret;
140 }
141 #else
mmc_set_env_part(struct mmc * mmc)142 static inline int mmc_set_env_part(struct mmc *mmc) {return 0; };
143 #endif
144
init_mmc_for_env(struct mmc * mmc)145 static const char *init_mmc_for_env(struct mmc *mmc)
146 {
147 if (!mmc)
148 return "No MMC card found";
149
150 #if CONFIG_IS_ENABLED(BLK)
151 struct udevice *dev;
152
153 if (blk_get_from_parent(mmc->dev, &dev))
154 return "No block device";
155 #else
156 if (mmc_init(mmc))
157 return "MMC init failed";
158 #endif
159 if (mmc_set_env_part(mmc))
160 return "MMC partition switch failed";
161
162 return NULL;
163 }
164
fini_mmc_for_env(struct mmc * mmc)165 static void fini_mmc_for_env(struct mmc *mmc)
166 {
167 #ifdef CONFIG_SYS_MMC_ENV_PART
168 int dev = mmc_get_env_dev();
169
170 blk_select_hwpart_devnum(IF_TYPE_MMC, dev, env_mmc_orig_hwpart);
171 #endif
172 }
173
174 #if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_SPL_BUILD)
write_env(struct mmc * mmc,unsigned long size,unsigned long offset,const void * buffer)175 static inline int write_env(struct mmc *mmc, unsigned long size,
176 unsigned long offset, const void *buffer)
177 {
178 uint blk_start, blk_cnt, n;
179 struct blk_desc *desc = mmc_get_blk_desc(mmc);
180
181 blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
182 blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
183
184 n = blk_dwrite(desc, blk_start, blk_cnt, (u_char *)buffer);
185
186 return (n == blk_cnt) ? 0 : -1;
187 }
188
env_mmc_save(void)189 static int env_mmc_save(void)
190 {
191 ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1);
192 int dev = mmc_get_env_dev();
193 struct mmc *mmc = find_mmc_device(dev);
194 u32 offset;
195 int ret, copy = 0;
196 const char *errmsg;
197
198 errmsg = init_mmc_for_env(mmc);
199 if (errmsg) {
200 printf("%s\n", errmsg);
201 return 1;
202 }
203
204 ret = env_export(env_new);
205 if (ret)
206 goto fini;
207
208 #ifdef CONFIG_ENV_OFFSET_REDUND
209 if (gd->env_valid == ENV_VALID)
210 copy = 1;
211 #endif
212
213 if (mmc_get_env_addr(mmc, copy, &offset)) {
214 ret = 1;
215 goto fini;
216 }
217
218 printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "", dev);
219 if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) {
220 puts("failed\n");
221 ret = 1;
222 goto fini;
223 }
224
225 ret = 0;
226
227 #ifdef CONFIG_ENV_OFFSET_REDUND
228 gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
229 #endif
230
231 fini:
232 fini_mmc_for_env(mmc);
233 return ret;
234 }
235
erase_env(struct mmc * mmc,unsigned long size,unsigned long offset)236 static inline int erase_env(struct mmc *mmc, unsigned long size,
237 unsigned long offset)
238 {
239 uint blk_start, blk_cnt, n;
240 struct blk_desc *desc = mmc_get_blk_desc(mmc);
241
242 blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
243 blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
244
245 n = blk_derase(desc, blk_start, blk_cnt);
246 printf("%d blocks erased: %s\n", n, (n == blk_cnt) ? "OK" : "ERROR");
247
248 return (n == blk_cnt) ? 0 : 1;
249 }
250
env_mmc_erase(void)251 static int env_mmc_erase(void)
252 {
253 int dev = mmc_get_env_dev();
254 struct mmc *mmc = find_mmc_device(dev);
255 int ret, copy = 0;
256 u32 offset;
257 const char *errmsg;
258
259 errmsg = init_mmc_for_env(mmc);
260 if (errmsg) {
261 printf("%s\n", errmsg);
262 return 1;
263 }
264
265 if (mmc_get_env_addr(mmc, copy, &offset))
266 return CMD_RET_FAILURE;
267
268 ret = erase_env(mmc, CONFIG_ENV_SIZE, offset);
269
270 #ifdef CONFIG_ENV_OFFSET_REDUND
271 copy = 1;
272
273 if (mmc_get_env_addr(mmc, copy, &offset))
274 return CMD_RET_FAILURE;
275
276 ret |= erase_env(mmc, CONFIG_ENV_SIZE, offset);
277 #endif
278
279 return ret;
280 }
281 #endif /* CONFIG_CMD_SAVEENV && !CONFIG_SPL_BUILD */
282
read_env(struct mmc * mmc,unsigned long size,unsigned long offset,const void * buffer)283 static inline int read_env(struct mmc *mmc, unsigned long size,
284 unsigned long offset, const void *buffer)
285 {
286 uint blk_start, blk_cnt, n;
287 struct blk_desc *desc = mmc_get_blk_desc(mmc);
288
289 blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
290 blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
291
292 n = blk_dread(desc, blk_start, blk_cnt, (uchar *)buffer);
293
294 return (n == blk_cnt) ? 0 : -1;
295 }
296
297 #ifdef CONFIG_ENV_OFFSET_REDUND
env_mmc_load(void)298 static int env_mmc_load(void)
299 {
300 #if !defined(ENV_IS_EMBEDDED)
301 struct mmc *mmc;
302 u32 offset1, offset2;
303 int read1_fail = 0, read2_fail = 0;
304 int ret;
305 int dev = mmc_get_env_dev();
306 const char *errmsg = NULL;
307
308 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1);
309 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1);
310
311 mmc_initialize(NULL);
312
313 mmc = find_mmc_device(dev);
314
315 errmsg = init_mmc_for_env(mmc);
316 if (errmsg) {
317 ret = -EIO;
318 goto err;
319 }
320
321 if (mmc_get_env_addr(mmc, 0, &offset1) ||
322 mmc_get_env_addr(mmc, 1, &offset2)) {
323 ret = -EIO;
324 goto fini;
325 }
326
327 read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1);
328 read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2);
329
330 ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
331 read2_fail, H_EXTERNAL);
332
333 fini:
334 fini_mmc_for_env(mmc);
335 err:
336 if (ret)
337 env_set_default(errmsg, 0);
338
339 #endif
340 return ret;
341 }
342 #else /* ! CONFIG_ENV_OFFSET_REDUND */
env_mmc_load(void)343 static int env_mmc_load(void)
344 {
345 #if !defined(ENV_IS_EMBEDDED)
346 ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
347 struct mmc *mmc;
348 u32 offset;
349 int ret;
350 int dev = mmc_get_env_dev();
351 const char *errmsg;
352 env_t *ep = NULL;
353
354 mmc = find_mmc_device(dev);
355
356 errmsg = init_mmc_for_env(mmc);
357 if (errmsg) {
358 ret = -EIO;
359 goto err;
360 }
361
362 if (mmc_get_env_addr(mmc, 0, &offset)) {
363 ret = -EIO;
364 goto fini;
365 }
366
367 if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
368 errmsg = "!read failed";
369 ret = -EIO;
370 goto fini;
371 }
372
373 ret = env_import(buf, 1, H_EXTERNAL);
374 if (!ret) {
375 ep = (env_t *)buf;
376 gd->env_addr = (ulong)&ep->data;
377 }
378
379 fini:
380 fini_mmc_for_env(mmc);
381 err:
382 if (ret)
383 env_set_default(errmsg, 0);
384 #endif
385 return ret;
386 }
387 #endif /* CONFIG_ENV_OFFSET_REDUND */
388
389 U_BOOT_ENV_LOCATION(mmc) = {
390 .location = ENVL_MMC,
391 ENV_NAME("MMC")
392 .load = env_mmc_load,
393 #ifndef CONFIG_SPL_BUILD
394 .save = env_save_ptr(env_mmc_save),
395 .erase = ENV_ERASE_PTR(env_mmc_erase)
396 #endif
397 };
398