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