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
236 #if defined(CONFIG_CMD_ERASEENV)
erase_env(struct mmc * mmc,unsigned long size,unsigned long offset)237 static inline int erase_env(struct mmc *mmc, unsigned long size,
238 unsigned long offset)
239 {
240 uint blk_start, blk_cnt, n;
241 struct blk_desc *desc = mmc_get_blk_desc(mmc);
242
243 blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
244 blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
245
246 n = blk_derase(desc, blk_start, blk_cnt);
247 printf("%d blocks erased: %s\n", n, (n == blk_cnt) ? "OK" : "ERROR");
248
249 return (n == blk_cnt) ? 0 : 1;
250 }
251
env_mmc_erase(void)252 static int env_mmc_erase(void)
253 {
254 int dev = mmc_get_env_dev();
255 struct mmc *mmc = find_mmc_device(dev);
256 int ret, copy = 0;
257 u32 offset;
258 const char *errmsg;
259
260 errmsg = init_mmc_for_env(mmc);
261 if (errmsg) {
262 printf("%s\n", errmsg);
263 return 1;
264 }
265
266 if (mmc_get_env_addr(mmc, copy, &offset))
267 return CMD_RET_FAILURE;
268
269 ret = erase_env(mmc, CONFIG_ENV_SIZE, offset);
270
271 #ifdef CONFIG_ENV_OFFSET_REDUND
272 copy = 1;
273
274 if (mmc_get_env_addr(mmc, copy, &offset))
275 return CMD_RET_FAILURE;
276
277 ret |= erase_env(mmc, CONFIG_ENV_SIZE, offset);
278 #endif
279
280 return ret;
281 }
282 #endif /* CONFIG_CMD_ERASEENV */
283 #endif /* CONFIG_CMD_SAVEENV && !CONFIG_SPL_BUILD */
284
read_env(struct mmc * mmc,unsigned long size,unsigned long offset,const void * buffer)285 static inline int read_env(struct mmc *mmc, unsigned long size,
286 unsigned long offset, const void *buffer)
287 {
288 uint blk_start, blk_cnt, n;
289 struct blk_desc *desc = mmc_get_blk_desc(mmc);
290
291 blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
292 blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
293
294 n = blk_dread(desc, blk_start, blk_cnt, (uchar *)buffer);
295
296 return (n == blk_cnt) ? 0 : -1;
297 }
298
299 #ifdef CONFIG_ENV_OFFSET_REDUND
env_mmc_load(void)300 static int env_mmc_load(void)
301 {
302 #if !defined(ENV_IS_EMBEDDED)
303 struct mmc *mmc;
304 u32 offset1, offset2;
305 int read1_fail = 0, read2_fail = 0;
306 int ret;
307 int dev = mmc_get_env_dev();
308 const char *errmsg = NULL;
309
310 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1);
311 ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1);
312
313 mmc_initialize(NULL);
314
315 mmc = find_mmc_device(dev);
316
317 errmsg = init_mmc_for_env(mmc);
318 if (errmsg) {
319 ret = -EIO;
320 goto err;
321 }
322
323 if (mmc_get_env_addr(mmc, 0, &offset1) ||
324 mmc_get_env_addr(mmc, 1, &offset2)) {
325 ret = -EIO;
326 goto fini;
327 }
328
329 read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1);
330 read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2);
331
332 ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
333 read2_fail, H_EXTERNAL);
334
335 fini:
336 fini_mmc_for_env(mmc);
337 err:
338 if (ret)
339 env_set_default(errmsg, 0);
340
341 #endif
342 return ret;
343 }
344 #else /* ! CONFIG_ENV_OFFSET_REDUND */
env_mmc_load(void)345 static int env_mmc_load(void)
346 {
347 #if !defined(ENV_IS_EMBEDDED)
348 ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
349 struct mmc *mmc;
350 u32 offset;
351 int ret;
352 int dev = mmc_get_env_dev();
353 const char *errmsg;
354 env_t *ep = NULL;
355
356 mmc = find_mmc_device(dev);
357
358 errmsg = init_mmc_for_env(mmc);
359 if (errmsg) {
360 ret = -EIO;
361 goto err;
362 }
363
364 if (mmc_get_env_addr(mmc, 0, &offset)) {
365 ret = -EIO;
366 goto fini;
367 }
368
369 if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
370 errmsg = "!read failed";
371 ret = -EIO;
372 goto fini;
373 }
374
375 ret = env_import(buf, 1, H_EXTERNAL);
376 if (!ret) {
377 ep = (env_t *)buf;
378 gd->env_addr = (ulong)&ep->data;
379 }
380
381 fini:
382 fini_mmc_for_env(mmc);
383 err:
384 if (ret)
385 env_set_default(errmsg, 0);
386 #endif
387 return ret;
388 }
389 #endif /* CONFIG_ENV_OFFSET_REDUND */
390
391 U_BOOT_ENV_LOCATION(mmc) = {
392 .location = ENVL_MMC,
393 ENV_NAME("MMC")
394 .load = env_mmc_load,
395 #ifndef CONFIG_SPL_BUILD
396 .save = env_save_ptr(env_mmc_save),
397 #if defined(CONFIG_CMD_ERASEENV)
398 .erase = env_mmc_erase,
399 #endif
400 #endif
401 };
402