source: SVN/rincon/u-boot/common/env_nand.c @ 55

Last change on this file since 55 was 55, checked in by Tim Harvey, 22 months ago

rincon: added latest u-boot source

restored form server backup

Signed-off-by: Tim Harvey <tharvey@…>

File size: 9.1 KB
Line 
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_ENV) && 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_ENV & 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
60int nand_legacy_rw (struct nand_chip* nand, int cmd,
61            size_t start, size_t len,
62            size_t * retlen, u_char * buf);
63
64/* references to names in env_common.c */
65extern uchar default_environment[];
66extern int default_environment_size;
67
68char * env_name_spec = "NAND";
69
70
71#ifdef ENV_IS_EMBEDDED
72extern uchar environment[];
73env_t *env_ptr = (env_t *)(&environment[0]);
74#else /* ! ENV_IS_EMBEDDED */
75env_t *env_ptr = 0;
76#endif /* ENV_IS_EMBEDDED */
77
78
79/* local functions */
80#if !defined(ENV_IS_EMBEDDED)
81static void use_default(void);
82#endif
83
84DECLARE_GLOBAL_DATA_PTR;
85
86uchar env_get_char_spec (int index)
87{
88        return ( *((uchar *)(gd->env_addr + index)) );
89}
90
91
92/* this is called before nand_init()
93 * so we can't read Nand to validate env data.
94 * Mark it OK for now. env_relocate() in env_common.c
95 * will call our relocate function which does the real
96 * validation.
97 *
98 * When using a NAND boot image (like sequoia_nand), the environment
99 * can be embedded or attached to the U-Boot image in NAND flash. This way
100 * the SPL loads not only the U-Boot image from NAND but also the
101 * environment.
102 */
103int env_init(void)
104{
105#if defined(ENV_IS_EMBEDDED)
106        size_t total;
107        int crc1_ok = 0, crc2_ok = 0;
108        env_t *tmp_env1, *tmp_env2;
109
110        total = CONFIG_ENV_SIZE;
111
112        tmp_env1 = env_ptr;
113        tmp_env2 = (env_t *)((ulong)env_ptr + CONFIG_ENV_SIZE);
114
115        crc1_ok = (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc);
116        crc2_ok = (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc);
117
118        if (!crc1_ok && !crc2_ok)
119                gd->env_valid = 0;
120        else if(crc1_ok && !crc2_ok)
121                gd->env_valid = 1;
122        else if(!crc1_ok && crc2_ok)
123                gd->env_valid = 2;
124        else {
125                /* both ok - check serial */
126                if(tmp_env1->flags == 255 && tmp_env2->flags == 0)
127                        gd->env_valid = 2;
128                else if(tmp_env2->flags == 255 && tmp_env1->flags == 0)
129                        gd->env_valid = 1;
130                else if(tmp_env1->flags > tmp_env2->flags)
131                        gd->env_valid = 1;
132                else if(tmp_env2->flags > tmp_env1->flags)
133                        gd->env_valid = 2;
134                else /* flags are equal - almost impossible */
135                        gd->env_valid = 1;
136        }
137
138        if (gd->env_valid == 1)
139                env_ptr = tmp_env1;
140        else if (gd->env_valid == 2)
141                env_ptr = tmp_env2;
142#else /* ENV_IS_EMBEDDED */
143        gd->env_addr  = (ulong)&default_environment[0];
144        gd->env_valid = 1;
145#endif /* ENV_IS_EMBEDDED */
146
147        return (0);
148}
149
150#ifdef CMD_SAVEENV
151/*
152 * The legacy NAND code saved the environment in the first NAND device i.e.,
153 * nand_dev_desc + 0. This is also the behaviour using the new NAND code.
154 */
155int writeenv(size_t offset, u_char *buf)
156{
157        size_t end = offset + CONFIG_ENV_RANGE;
158        size_t amount_saved = 0;
159        size_t blocksize, len;
160
161        u_char *char_ptr;
162
163        blocksize = nand_info[0].erasesize;
164        len = min(blocksize, CONFIG_ENV_SIZE);
165
166        while (amount_saved < CONFIG_ENV_SIZE && offset < end) {
167                if (nand_block_isbad(&nand_info[0], offset)) {
168                        offset += blocksize;
169                } else {
170                        char_ptr = &buf[amount_saved];
171                        if (nand_write(&nand_info[0], offset, &len,
172                                        char_ptr))
173                                return 1;
174                        offset += blocksize;
175                        amount_saved += len;
176                }
177        }
178        if (amount_saved != CONFIG_ENV_SIZE)
179                return 1;
180
181        return 0;
182}
183#ifdef CONFIG_ENV_OFFSET_REDUND
184int saveenv(void)
185{
186        size_t total;
187        int ret = 0;
188        nand_erase_options_t nand_erase_options;
189
190        env_ptr->flags++;
191        total = CONFIG_ENV_SIZE;
192
193        nand_erase_options.length = CONFIG_ENV_RANGE;
194        nand_erase_options.quiet = 0;
195        nand_erase_options.jffs2 = 0;
196        nand_erase_options.scrub = 0;
197
198        if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE)
199                return 1;
200        if(gd->env_valid == 1) {
201                puts ("Erasing redundant Nand...\n");
202                nand_erase_options.offset = CONFIG_ENV_OFFSET_REDUND;
203                if (nand_erase_opts(&nand_info[0], &nand_erase_options))
204                        return 1;
205
206                puts ("Writing to redundant Nand... ");
207                ret = writeenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) env_ptr);
208        } else {
209                puts ("Erasing Nand...\n");
210                nand_erase_options.offset = CONFIG_ENV_OFFSET;
211                if (nand_erase_opts(&nand_info[0], &nand_erase_options))
212                        return 1;
213
214                puts ("Writing to Nand... ");
215                ret = writeenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr);
216        }
217        if (ret) {
218                puts("FAILED!\n");
219                return 1;
220        }
221
222        puts ("done\n");
223        gd->env_valid = (gd->env_valid == 2 ? 1 : 2);
224        return ret;
225}
226#else /* ! CONFIG_ENV_OFFSET_REDUND */
227int saveenv(void)
228{
229        size_t total;
230        int ret = 0;
231        nand_erase_options_t nand_erase_options;
232
233        nand_erase_options.length = CONFIG_ENV_RANGE;
234        nand_erase_options.quiet = 0;
235        nand_erase_options.jffs2 = 0;
236        nand_erase_options.scrub = 0;
237        nand_erase_options.offset = CONFIG_ENV_OFFSET;
238
239        if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE)
240                return 1;
241        puts ("Erasing Nand...\n");
242        if (nand_erase_opts(&nand_info[0], &nand_erase_options))
243                return 1;
244
245        puts ("Writing to Nand... ");
246        total = CONFIG_ENV_SIZE;
247        if (writeenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr)) {
248                puts("FAILED!\n");
249                return 1;
250        }
251
252        puts ("done\n");
253        return ret;
254}
255#endif /* CONFIG_ENV_OFFSET_REDUND */
256#endif /* CMD_SAVEENV */
257
258int readenv (size_t offset, u_char * buf)
259{
260        size_t end = offset + CONFIG_ENV_RANGE;
261        size_t amount_loaded = 0;
262        size_t blocksize, len;
263
264        u_char *char_ptr;
265
266        blocksize = nand_info[0].erasesize;
267        len = min(blocksize, CONFIG_ENV_SIZE);
268
269        while (amount_loaded < CONFIG_ENV_SIZE && offset < end) {
270                if (nand_block_isbad(&nand_info[0], offset)) {
271                        offset += blocksize;
272                } else {
273                        char_ptr = &buf[amount_loaded];
274                        if (nand_read(&nand_info[0], offset, &len, char_ptr))
275                                return 1;
276                        offset += blocksize;
277                        amount_loaded += len;
278                }
279        }
280        if (amount_loaded != CONFIG_ENV_SIZE)
281                return 1;
282
283        return 0;
284}
285
286#ifdef CONFIG_ENV_OFFSET_REDUND
287void env_relocate_spec (void)
288{
289#if !defined(ENV_IS_EMBEDDED)
290        size_t total;
291        int crc1_ok = 0, crc2_ok = 0;
292        env_t *tmp_env1, *tmp_env2;
293
294        total = CONFIG_ENV_SIZE;
295
296        tmp_env1 = (env_t *) malloc(CONFIG_ENV_SIZE);
297        tmp_env2 = (env_t *) malloc(CONFIG_ENV_SIZE);
298
299        if (readenv(CONFIG_ENV_OFFSET, (u_char *) tmp_env1))
300                puts("No Valid Environment Area Found\n");
301        if (readenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) tmp_env2))
302                puts("No Valid Reundant Environment Area Found\n");
303
304        crc1_ok = (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc);
305        crc2_ok = (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc);
306
307        if(!crc1_ok && !crc2_ok)
308                return use_default();
309        else if(crc1_ok && !crc2_ok)
310                gd->env_valid = 1;
311        else if(!crc1_ok && crc2_ok)
312                gd->env_valid = 2;
313        else {
314                /* both ok - check serial */
315                if(tmp_env1->flags == 255 && tmp_env2->flags == 0)
316                        gd->env_valid = 2;
317                else if(tmp_env2->flags == 255 && tmp_env1->flags == 0)
318                        gd->env_valid = 1;
319                else if(tmp_env1->flags > tmp_env2->flags)
320                        gd->env_valid = 1;
321                else if(tmp_env2->flags > tmp_env1->flags)
322                        gd->env_valid = 2;
323                else /* flags are equal - almost impossible */
324                        gd->env_valid = 1;
325
326        }
327
328        free(env_ptr);
329        if(gd->env_valid == 1) {
330                env_ptr = tmp_env1;
331                free(tmp_env2);
332        } else {
333                env_ptr = tmp_env2;
334                free(tmp_env1);
335        }
336
337#endif /* ! ENV_IS_EMBEDDED */
338}
339#else /* ! CONFIG_ENV_OFFSET_REDUND */
340/*
341 * The legacy NAND code saved the environment in the first NAND device i.e.,
342 * nand_dev_desc + 0. This is also the behaviour using the new NAND code.
343 */
344void env_relocate_spec (void)
345{
346#if !defined(ENV_IS_EMBEDDED)
347        int ret;
348
349        ret = readenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr);
350        if (ret)
351                return use_default();
352
353        if (crc32(0, env_ptr->data, ENV_SIZE) != env_ptr->crc)
354                return use_default();
355#endif /* ! ENV_IS_EMBEDDED */
356}
357#endif /* CONFIG_ENV_OFFSET_REDUND */
358
359#if !defined(ENV_IS_EMBEDDED)
360static void use_default()
361{
362        puts ("*** Warning - bad CRC or NAND, using default environment\n\n");
363        set_default_env();
364}
365#endif
Note: See TracBrowser for help on using the repository browser.