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