Merge branch 'master' of git://git.denx.de/u-boot-nand-flash
[platform/kernel/u-boot.git] / common / env_nand.c
1 /*
2  * (C) Copyright 2008
3  * Stuart Wood, Lab X Technologies <stuart.wood@labxtechnologies.com>
4  *
5  * (C) Copyright 2004
6  * Jian Zhang, Texas Instruments, jzhang@ti.com.
7
8  * (C) Copyright 2000-2006
9  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
10  *
11  * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
12  * Andreas Heppel <aheppel@sysgo.de>
13
14  * See file CREDITS for list of people who contributed to this
15  * project.
16  *
17  * This program is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU General Public License as
19  * published by the Free Software Foundation; either version 2 of
20  * the License, or (at your option) any later version.
21  *
22  * This program is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, write to the Free Software
29  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
30  * MA 02111-1307 USA
31  */
32
33 /* #define DEBUG */
34
35 #include <common.h>
36 #include <command.h>
37 #include <environment.h>
38 #include <linux/stddef.h>
39 #include <malloc.h>
40 #include <nand.h>
41
42 #if defined(CONFIG_CMD_SAVEENV) && defined(CONFIG_CMD_NAND)
43 #define CMD_SAVEENV
44 #elif defined(CONFIG_ENV_OFFSET_REDUND)
45 #error Cannot use CONFIG_ENV_OFFSET_REDUND without CONFIG_CMD_SAVEENV & CONFIG_CMD_NAND
46 #endif
47
48 #if defined(CONFIG_ENV_SIZE_REDUND) && (CONFIG_ENV_SIZE_REDUND != CONFIG_ENV_SIZE)
49 #error CONFIG_ENV_SIZE_REDUND should be the same as CONFIG_ENV_SIZE
50 #endif
51
52 #ifdef CONFIG_INFERNO
53 #error CONFIG_INFERNO not supported yet
54 #endif
55
56 #ifndef CONFIG_ENV_RANGE
57 #define CONFIG_ENV_RANGE        CONFIG_ENV_SIZE
58 #endif
59
60 /* references to names in env_common.c */
61 extern uchar default_environment[];
62 extern int default_environment_size;
63
64 char * env_name_spec = "NAND";
65
66
67 #if defined(ENV_IS_EMBEDDED)
68 extern uchar environment[];
69 env_t *env_ptr = (env_t *)(&environment[0]);
70 #elif defined(CONFIG_NAND_ENV_DST)
71 env_t *env_ptr = (env_t *)CONFIG_NAND_ENV_DST;
72 #else /* ! ENV_IS_EMBEDDED */
73 env_t *env_ptr = 0;
74 #endif /* ENV_IS_EMBEDDED */
75
76
77 /* local functions */
78 #if !defined(ENV_IS_EMBEDDED)
79 static void use_default(void);
80 #endif
81
82 DECLARE_GLOBAL_DATA_PTR;
83
84 uchar env_get_char_spec (int index)
85 {
86         return ( *((uchar *)(gd->env_addr + index)) );
87 }
88
89
90 /* this is called before nand_init()
91  * so we can't read Nand to validate env data.
92  * Mark it OK for now. env_relocate() in env_common.c
93  * will call our relocate function which does the real
94  * validation.
95  *
96  * When using a NAND boot image (like sequoia_nand), the environment
97  * can be embedded or attached to the U-Boot image in NAND flash. This way
98  * the SPL loads not only the U-Boot image from NAND but also the
99  * environment.
100  */
101 int env_init(void)
102 {
103 #if defined(ENV_IS_EMBEDDED) || defined(CONFIG_NAND_ENV_DST)
104         int crc1_ok = 0, crc2_ok = 0;
105         env_t *tmp_env1;
106
107 #ifdef CONFIG_ENV_OFFSET_REDUND
108         env_t *tmp_env2;
109
110         tmp_env2 = (env_t *)((ulong)env_ptr + CONFIG_ENV_SIZE);
111         crc2_ok = (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc);
112 #endif
113
114         tmp_env1 = env_ptr;
115
116         crc1_ok = (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc);
117
118         if (!crc1_ok && !crc2_ok) {
119                 gd->env_addr  = 0;
120                 gd->env_valid = 0;
121
122                 return 0;
123         } else if (crc1_ok && !crc2_ok) {
124                 gd->env_valid = 1;
125         }
126 #ifdef CONFIG_ENV_OFFSET_REDUND
127         else if (!crc1_ok && crc2_ok) {
128                 gd->env_valid = 2;
129         } else {
130                 /* both ok - check serial */
131                 if(tmp_env1->flags == 255 && tmp_env2->flags == 0)
132                         gd->env_valid = 2;
133                 else if(tmp_env2->flags == 255 && tmp_env1->flags == 0)
134                         gd->env_valid = 1;
135                 else if(tmp_env1->flags > tmp_env2->flags)
136                         gd->env_valid = 1;
137                 else if(tmp_env2->flags > tmp_env1->flags)
138                         gd->env_valid = 2;
139                 else /* flags are equal - almost impossible */
140                         gd->env_valid = 1;
141         }
142
143         if (gd->env_valid == 2)
144                 env_ptr = tmp_env2;
145         else
146 #endif
147         if (gd->env_valid == 1)
148                 env_ptr = tmp_env1;
149
150         gd->env_addr = (ulong)env_ptr->data;
151
152 #else /* ENV_IS_EMBEDDED || CONFIG_NAND_ENV_DST */
153         gd->env_addr  = (ulong)&default_environment[0];
154         gd->env_valid = 1;
155 #endif /* ENV_IS_EMBEDDED || CONFIG_NAND_ENV_DST */
156
157         return (0);
158 }
159
160 #ifdef CMD_SAVEENV
161 /*
162  * The legacy NAND code saved the environment in the first NAND device i.e.,
163  * nand_dev_desc + 0. This is also the behaviour using the new NAND code.
164  */
165 int writeenv(size_t offset, u_char *buf)
166 {
167         size_t end = offset + CONFIG_ENV_RANGE;
168         size_t amount_saved = 0;
169         size_t blocksize, len;
170
171         u_char *char_ptr;
172
173         blocksize = nand_info[0].erasesize;
174         len = min(blocksize, CONFIG_ENV_SIZE);
175
176         while (amount_saved < CONFIG_ENV_SIZE && offset < end) {
177                 if (nand_block_isbad(&nand_info[0], offset)) {
178                         offset += blocksize;
179                 } else {
180                         char_ptr = &buf[amount_saved];
181                         if (nand_write(&nand_info[0], offset, &len,
182                                         char_ptr))
183                                 return 1;
184                         offset += blocksize;
185                         amount_saved += len;
186                 }
187         }
188         if (amount_saved != CONFIG_ENV_SIZE)
189                 return 1;
190
191         return 0;
192 }
193 #ifdef CONFIG_ENV_OFFSET_REDUND
194 int saveenv(void)
195 {
196         int ret = 0;
197         nand_erase_options_t nand_erase_options;
198
199         env_ptr->flags++;
200
201         nand_erase_options.length = CONFIG_ENV_RANGE;
202         nand_erase_options.quiet = 0;
203         nand_erase_options.jffs2 = 0;
204         nand_erase_options.scrub = 0;
205
206         if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE)
207                 return 1;
208         if(gd->env_valid == 1) {
209                 puts ("Erasing redundant Nand...\n");
210                 nand_erase_options.offset = CONFIG_ENV_OFFSET_REDUND;
211                 if (nand_erase_opts(&nand_info[0], &nand_erase_options))
212                         return 1;
213
214                 puts ("Writing to redundant Nand... ");
215                 ret = writeenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) env_ptr);
216         } else {
217                 puts ("Erasing Nand...\n");
218                 nand_erase_options.offset = CONFIG_ENV_OFFSET;
219                 if (nand_erase_opts(&nand_info[0], &nand_erase_options))
220                         return 1;
221
222                 puts ("Writing to Nand... ");
223                 ret = writeenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr);
224         }
225         if (ret) {
226                 puts("FAILED!\n");
227                 return 1;
228         }
229
230         puts ("done\n");
231         gd->env_valid = (gd->env_valid == 2 ? 1 : 2);
232         return ret;
233 }
234 #else /* ! CONFIG_ENV_OFFSET_REDUND */
235 int saveenv(void)
236 {
237         int ret = 0;
238         nand_erase_options_t nand_erase_options;
239
240         nand_erase_options.length = CONFIG_ENV_RANGE;
241         nand_erase_options.quiet = 0;
242         nand_erase_options.jffs2 = 0;
243         nand_erase_options.scrub = 0;
244         nand_erase_options.offset = CONFIG_ENV_OFFSET;
245
246         if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE)
247                 return 1;
248         puts ("Erasing Nand...\n");
249         if (nand_erase_opts(&nand_info[0], &nand_erase_options))
250                 return 1;
251
252         puts ("Writing to Nand... ");
253         if (writeenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr)) {
254                 puts("FAILED!\n");
255                 return 1;
256         }
257
258         puts ("done\n");
259         return ret;
260 }
261 #endif /* CONFIG_ENV_OFFSET_REDUND */
262 #endif /* CMD_SAVEENV */
263
264 int readenv (size_t offset, u_char * buf)
265 {
266         size_t end = offset + CONFIG_ENV_RANGE;
267         size_t amount_loaded = 0;
268         size_t blocksize, len;
269
270         u_char *char_ptr;
271
272         blocksize = nand_info[0].erasesize;
273         len = min(blocksize, CONFIG_ENV_SIZE);
274
275         while (amount_loaded < CONFIG_ENV_SIZE && offset < end) {
276                 if (nand_block_isbad(&nand_info[0], offset)) {
277                         offset += blocksize;
278                 } else {
279                         char_ptr = &buf[amount_loaded];
280                         if (nand_read(&nand_info[0], offset, &len, char_ptr))
281                                 return 1;
282                         offset += blocksize;
283                         amount_loaded += len;
284                 }
285         }
286         if (amount_loaded != CONFIG_ENV_SIZE)
287                 return 1;
288
289         return 0;
290 }
291
292 #ifdef CONFIG_ENV_OFFSET_REDUND
293 void env_relocate_spec (void)
294 {
295 #if !defined(ENV_IS_EMBEDDED)
296         int crc1_ok = 0, crc2_ok = 0;
297         env_t *tmp_env1, *tmp_env2;
298
299         tmp_env1 = (env_t *) malloc(CONFIG_ENV_SIZE);
300         tmp_env2 = (env_t *) malloc(CONFIG_ENV_SIZE);
301
302         if (readenv(CONFIG_ENV_OFFSET, (u_char *) tmp_env1))
303                 puts("No Valid Environment Area Found\n");
304         if (readenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) tmp_env2))
305                 puts("No Valid Reundant Environment Area Found\n");
306
307         crc1_ok = (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc);
308         crc2_ok = (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc);
309
310         if(!crc1_ok && !crc2_ok) {
311                 free(tmp_env1);
312                 free(tmp_env2);
313                 return use_default();
314         } else if(crc1_ok && !crc2_ok)
315                 gd->env_valid = 1;
316         else if(!crc1_ok && crc2_ok)
317                 gd->env_valid = 2;
318         else {
319                 /* both ok - check serial */
320                 if(tmp_env1->flags == 255 && tmp_env2->flags == 0)
321                         gd->env_valid = 2;
322                 else if(tmp_env2->flags == 255 && tmp_env1->flags == 0)
323                         gd->env_valid = 1;
324                 else if(tmp_env1->flags > tmp_env2->flags)
325                         gd->env_valid = 1;
326                 else if(tmp_env2->flags > tmp_env1->flags)
327                         gd->env_valid = 2;
328                 else /* flags are equal - almost impossible */
329                         gd->env_valid = 1;
330
331         }
332
333         free(env_ptr);
334         if(gd->env_valid == 1) {
335                 env_ptr = tmp_env1;
336                 free(tmp_env2);
337         } else {
338                 env_ptr = tmp_env2;
339                 free(tmp_env1);
340         }
341
342 #endif /* ! ENV_IS_EMBEDDED */
343 }
344 #else /* ! CONFIG_ENV_OFFSET_REDUND */
345 /*
346  * The legacy NAND code saved the environment in the first NAND device i.e.,
347  * nand_dev_desc + 0. This is also the behaviour using the new NAND code.
348  */
349 void env_relocate_spec (void)
350 {
351 #if !defined(ENV_IS_EMBEDDED)
352         int ret;
353
354         ret = readenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr);
355         if (ret)
356                 return use_default();
357
358         if (crc32(0, env_ptr->data, ENV_SIZE) != env_ptr->crc)
359                 return use_default();
360 #endif /* ! ENV_IS_EMBEDDED */
361 }
362 #endif /* CONFIG_ENV_OFFSET_REDUND */
363
364 #if !defined(ENV_IS_EMBEDDED)
365 static void use_default()
366 {
367         puts ("*** Warning - bad CRC or NAND, using default environment\n\n");
368         set_default_env();
369 }
370 #endif