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