block: pass block dev not num to read/write/erase()
[platform/kernel/u-boot.git] / common / env_mmc.c
1 /*
2  * (C) Copyright 2008-2011 Freescale Semiconductor, Inc.
3  *
4  * SPDX-License-Identifier:     GPL-2.0+
5  */
6
7 /* #define DEBUG */
8
9 #include <common.h>
10
11 #include <command.h>
12 #include <environment.h>
13 #include <linux/stddef.h>
14 #include <malloc.h>
15 #include <memalign.h>
16 #include <mmc.h>
17 #include <search.h>
18 #include <errno.h>
19
20 #if defined(CONFIG_ENV_SIZE_REDUND) &&  \
21         (CONFIG_ENV_SIZE_REDUND != CONFIG_ENV_SIZE)
22 #error CONFIG_ENV_SIZE_REDUND should be the same as CONFIG_ENV_SIZE
23 #endif
24
25 char *env_name_spec = "MMC";
26
27 #ifdef ENV_IS_EMBEDDED
28 env_t *env_ptr = &environment;
29 #else /* ! ENV_IS_EMBEDDED */
30 env_t *env_ptr;
31 #endif /* ENV_IS_EMBEDDED */
32
33 DECLARE_GLOBAL_DATA_PTR;
34
35 #if !defined(CONFIG_ENV_OFFSET)
36 #define CONFIG_ENV_OFFSET 0
37 #endif
38
39 __weak int mmc_get_env_addr(struct mmc *mmc, int copy, u32 *env_addr)
40 {
41         s64 offset;
42
43         offset = CONFIG_ENV_OFFSET;
44 #ifdef CONFIG_ENV_OFFSET_REDUND
45         if (copy)
46                 offset = CONFIG_ENV_OFFSET_REDUND;
47 #endif
48
49         if (offset < 0)
50                 offset += mmc->capacity;
51
52         *env_addr = offset;
53
54         return 0;
55 }
56
57 int env_init(void)
58 {
59         /* use default */
60         gd->env_addr    = (ulong)&default_environment[0];
61         gd->env_valid   = 1;
62
63         return 0;
64 }
65
66 #ifdef CONFIG_SYS_MMC_ENV_PART
67 __weak uint mmc_get_env_part(struct mmc *mmc)
68 {
69         return CONFIG_SYS_MMC_ENV_PART;
70 }
71
72 static int mmc_set_env_part(struct mmc *mmc)
73 {
74         uint part = mmc_get_env_part(mmc);
75         int dev = CONFIG_SYS_MMC_ENV_DEV;
76         int ret = 0;
77
78 #ifdef CONFIG_SPL_BUILD
79         dev = 0;
80 #endif
81
82         if (part != mmc->part_num) {
83                 ret = mmc_switch_part(dev, part);
84                 if (ret)
85                         puts("MMC partition switch failed\n");
86         }
87
88         return ret;
89 }
90 #else
91 static inline int mmc_set_env_part(struct mmc *mmc) {return 0; };
92 #endif
93
94 static const char *init_mmc_for_env(struct mmc *mmc)
95 {
96         if (!mmc)
97                 return "!No MMC card found";
98
99         if (mmc_init(mmc))
100                 return "!MMC init failed";
101
102         if (mmc_set_env_part(mmc))
103                 return "!MMC partition switch failed";
104
105         return NULL;
106 }
107
108 static void fini_mmc_for_env(struct mmc *mmc)
109 {
110 #ifdef CONFIG_SYS_MMC_ENV_PART
111         int dev = CONFIG_SYS_MMC_ENV_DEV;
112
113 #ifdef CONFIG_SPL_BUILD
114         dev = 0;
115 #endif
116         if (mmc_get_env_part(mmc) != mmc->part_num)
117                 mmc_switch_part(dev, mmc->part_num);
118 #endif
119 }
120
121 #ifdef CONFIG_CMD_SAVEENV
122 static inline int write_env(struct mmc *mmc, unsigned long size,
123                             unsigned long offset, const void *buffer)
124 {
125         uint blk_start, blk_cnt, n;
126
127         blk_start       = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
128         blk_cnt         = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
129
130         n = mmc->block_dev.block_write(&mmc->block_dev, blk_start,
131                                         blk_cnt, (u_char *)buffer);
132
133         return (n == blk_cnt) ? 0 : -1;
134 }
135
136 #ifdef CONFIG_ENV_OFFSET_REDUND
137 static unsigned char env_flags;
138 #endif
139
140 int saveenv(void)
141 {
142         ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1);
143         struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
144         u32     offset;
145         int     ret, copy = 0;
146         const char *errmsg;
147
148         errmsg = init_mmc_for_env(mmc);
149         if (errmsg) {
150                 printf("%s\n", errmsg);
151                 return 1;
152         }
153
154         ret = env_export(env_new);
155         if (ret)
156                 goto fini;
157
158 #ifdef CONFIG_ENV_OFFSET_REDUND
159         env_new->flags  = ++env_flags; /* increase the serial */
160
161         if (gd->env_valid == 1)
162                 copy = 1;
163 #endif
164
165         if (mmc_get_env_addr(mmc, copy, &offset)) {
166                 ret = 1;
167                 goto fini;
168         }
169
170         printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "",
171                CONFIG_SYS_MMC_ENV_DEV);
172         if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) {
173                 puts("failed\n");
174                 ret = 1;
175                 goto fini;
176         }
177
178         puts("done\n");
179         ret = 0;
180
181 #ifdef CONFIG_ENV_OFFSET_REDUND
182         gd->env_valid = gd->env_valid == 2 ? 1 : 2;
183 #endif
184
185 fini:
186         fini_mmc_for_env(mmc);
187         return ret;
188 }
189 #endif /* CONFIG_CMD_SAVEENV */
190
191 static inline int read_env(struct mmc *mmc, unsigned long size,
192                            unsigned long offset, const void *buffer)
193 {
194         uint blk_start, blk_cnt, n;
195
196         blk_start       = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
197         blk_cnt         = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
198
199         n = mmc->block_dev.block_read(&mmc->block_dev, blk_start, blk_cnt,
200                                       (uchar *)buffer);
201
202         return (n == blk_cnt) ? 0 : -1;
203 }
204
205 #ifdef CONFIG_ENV_OFFSET_REDUND
206 void env_relocate_spec(void)
207 {
208 #if !defined(ENV_IS_EMBEDDED)
209         struct mmc *mmc;
210         u32 offset1, offset2;
211         int read1_fail = 0, read2_fail = 0;
212         int crc1_ok = 0, crc2_ok = 0;
213         env_t *ep;
214         int ret;
215         int dev = CONFIG_SYS_MMC_ENV_DEV;
216         const char *errmsg = NULL;
217
218         ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1);
219         ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1);
220
221 #ifdef CONFIG_SPL_BUILD
222         dev = 0;
223 #endif
224
225         mmc = find_mmc_device(dev);
226
227         errmsg = init_mmc_for_env(mmc);
228         if (errmsg) {
229                 ret = 1;
230                 goto err;
231         }
232
233         if (mmc_get_env_addr(mmc, 0, &offset1) ||
234             mmc_get_env_addr(mmc, 1, &offset2)) {
235                 ret = 1;
236                 goto fini;
237         }
238
239         read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1);
240         read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2);
241
242         if (read1_fail && read2_fail)
243                 puts("*** Error - No Valid Environment Area found\n");
244         else if (read1_fail || read2_fail)
245                 puts("*** Warning - some problems detected "
246                      "reading environment; recovered successfully\n");
247
248         crc1_ok = !read1_fail &&
249                 (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc);
250         crc2_ok = !read2_fail &&
251                 (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc);
252
253         if (!crc1_ok && !crc2_ok) {
254                 errmsg = "!bad CRC";
255                 ret = 1;
256                 goto fini;
257         } else if (crc1_ok && !crc2_ok) {
258                 gd->env_valid = 1;
259         } else if (!crc1_ok && crc2_ok) {
260                 gd->env_valid = 2;
261         } else {
262                 /* both ok - check serial */
263                 if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
264                         gd->env_valid = 2;
265                 else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
266                         gd->env_valid = 1;
267                 else if (tmp_env1->flags > tmp_env2->flags)
268                         gd->env_valid = 1;
269                 else if (tmp_env2->flags > tmp_env1->flags)
270                         gd->env_valid = 2;
271                 else /* flags are equal - almost impossible */
272                         gd->env_valid = 1;
273         }
274
275         free(env_ptr);
276
277         if (gd->env_valid == 1)
278                 ep = tmp_env1;
279         else
280                 ep = tmp_env2;
281
282         env_flags = ep->flags;
283         env_import((char *)ep, 0);
284         ret = 0;
285
286 fini:
287         fini_mmc_for_env(mmc);
288 err:
289         if (ret)
290                 set_default_env(errmsg);
291 #endif
292 }
293 #else /* ! CONFIG_ENV_OFFSET_REDUND */
294 void env_relocate_spec(void)
295 {
296 #if !defined(ENV_IS_EMBEDDED)
297         ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
298         struct mmc *mmc;
299         u32 offset;
300         int ret;
301         int dev = CONFIG_SYS_MMC_ENV_DEV;
302         const char *errmsg;
303
304 #ifdef CONFIG_SPL_BUILD
305         dev = 0;
306 #endif
307
308         mmc = find_mmc_device(dev);
309
310         errmsg = init_mmc_for_env(mmc);
311         if (errmsg) {
312                 ret = 1;
313                 goto err;
314         }
315
316         if (mmc_get_env_addr(mmc, 0, &offset)) {
317                 ret = 1;
318                 goto fini;
319         }
320
321         if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
322                 errmsg = "!read failed";
323                 ret = 1;
324                 goto fini;
325         }
326
327         env_import(buf, 1);
328         ret = 0;
329
330 fini:
331         fini_mmc_for_env(mmc);
332 err:
333         if (ret)
334                 set_default_env(errmsg);
335 #endif
336 }
337 #endif /* CONFIG_ENV_OFFSET_REDUND */