ARM: dts: add QorIQ DPAA 1 FMan v3 for LS1046A
[oweals/u-boot.git] / env / mmc.c
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)
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
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
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
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
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
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
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
144 static inline int mmc_set_env_part(struct mmc *mmc) {return 0; };
145 #endif
146
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
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)
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
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)
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
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
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
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 */
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         env_t *ep = NULL;
357
358         mmc = find_mmc_device(dev);
359
360         errmsg = init_mmc_for_env(mmc);
361         if (errmsg) {
362                 ret = -EIO;
363                 goto err;
364         }
365
366         if (mmc_get_env_addr(mmc, 0, &offset)) {
367                 ret = -EIO;
368                 goto fini;
369         }
370
371         if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
372                 errmsg = "!read failed";
373                 ret = -EIO;
374                 goto fini;
375         }
376
377         ret = env_import(buf, 1);
378         if (!ret) {
379                 ep = (env_t *)buf;
380                 gd->env_addr = (ulong)&ep->data;
381         }
382
383 fini:
384         fini_mmc_for_env(mmc);
385 err:
386         if (ret)
387                 env_set_default(errmsg, 0);
388 #endif
389         return ret;
390 }
391 #endif /* CONFIG_ENV_OFFSET_REDUND */
392
393 U_BOOT_ENV_LOCATION(mmc) = {
394         .location       = ENVL_MMC,
395         ENV_NAME("MMC")
396         .load           = env_mmc_load,
397 #ifndef CONFIG_SPL_BUILD
398         .save           = env_save_ptr(env_mmc_save),
399 #if defined(CONFIG_CMD_ERASEENV)
400         .erase          = env_mmc_erase,
401 #endif
402 #endif
403 };