Merge branch 'master' of git://git.denx.de/u-boot-mpc83xx
[platform/kernel/u-boot.git] / common / env_sf.c
1 /*
2  * (C) Copyright 2000-2010
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
6  * Andreas Heppel <aheppel@sysgo.de>
7  *
8  * (C) Copyright 2008 Atmel Corporation
9  *
10  * See file CREDITS for list of people who contributed to this
11  * project.
12  *
13  * This program is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU General Public License as
15  * published by the Free Software Foundation; either version 2 of
16  * the License, or (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
26  * MA 02111-1307 USA
27  */
28 #include <common.h>
29 #include <environment.h>
30 #include <malloc.h>
31 #include <spi_flash.h>
32 #include <search.h>
33 #include <errno.h>
34
35 #ifndef CONFIG_ENV_SPI_BUS
36 # define CONFIG_ENV_SPI_BUS     0
37 #endif
38 #ifndef CONFIG_ENV_SPI_CS
39 # define CONFIG_ENV_SPI_CS              0
40 #endif
41 #ifndef CONFIG_ENV_SPI_MAX_HZ
42 # define CONFIG_ENV_SPI_MAX_HZ  1000000
43 #endif
44 #ifndef CONFIG_ENV_SPI_MODE
45 # define CONFIG_ENV_SPI_MODE    SPI_MODE_3
46 #endif
47
48 #ifdef CONFIG_ENV_OFFSET_REDUND
49 static ulong env_offset = CONFIG_ENV_OFFSET;
50 static ulong env_new_offset = CONFIG_ENV_OFFSET_REDUND;
51
52 #define ACTIVE_FLAG   1
53 #define OBSOLETE_FLAG 0
54 #endif /* CONFIG_ENV_OFFSET_REDUND */
55
56 DECLARE_GLOBAL_DATA_PTR;
57
58 /* references to names in env_common.c */
59 extern uchar default_environment[];
60
61 char * env_name_spec = "SPI Flash";
62
63 static struct spi_flash *env_flash;
64
65 uchar env_get_char_spec(int index)
66 {
67         return *((uchar *)(gd->env_addr + index));
68 }
69
70 #if defined(CONFIG_ENV_OFFSET_REDUND)
71
72 int saveenv(void)
73 {
74         env_t   env_new;
75         ssize_t len;
76         char    *res;
77         u32     saved_size, saved_offset;
78         char    *saved_buffer = NULL;
79         u32     sector = 1;
80         int     ret;
81         char    flag = OBSOLETE_FLAG;
82
83         if (!env_flash) {
84                 env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS,
85                         CONFIG_ENV_SPI_CS,
86                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
87                 if (!env_flash) {
88                         set_default_env("!spi_flash_probe() failed");
89                         return 1;
90                 }
91         }
92
93         res = (char *)&env_new.data;
94         len = hexport_r(&env_htab, '\0', &res, ENV_SIZE);
95         if (len < 0) {
96                 error("Cannot export environment: errno = %d\n", errno);
97                 return 1;
98         }
99         env_new.crc   = crc32(0, env_new.data, ENV_SIZE);
100         env_new.flags = ACTIVE_FLAG;
101
102         if (gd->env_valid == 1) {
103                 env_new_offset = CONFIG_ENV_OFFSET_REDUND;
104                 env_offset = CONFIG_ENV_OFFSET;
105         } else {
106                 env_new_offset = CONFIG_ENV_OFFSET;
107                 env_offset = CONFIG_ENV_OFFSET_REDUND;
108         }
109
110         /* Is the sector larger than the env (i.e. embedded) */
111         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
112                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
113                 saved_offset = env_new_offset + CONFIG_ENV_SIZE;
114                 saved_buffer = malloc(saved_size);
115                 if (!saved_buffer) {
116                         ret = 1;
117                         goto done;
118                 }
119                 ret = spi_flash_read(env_flash, saved_offset,
120                                         saved_size, saved_buffer);
121                 if (ret)
122                         goto done;
123         }
124
125         if (CONFIG_ENV_SIZE > CONFIG_ENV_SECT_SIZE) {
126                 sector = CONFIG_ENV_SIZE / CONFIG_ENV_SECT_SIZE;
127                 if (CONFIG_ENV_SIZE % CONFIG_ENV_SECT_SIZE)
128                         sector++;
129         }
130
131         puts("Erasing SPI flash...");
132         ret = spi_flash_erase(env_flash, env_new_offset,
133                                 sector * CONFIG_ENV_SECT_SIZE);
134         if (ret)
135                 goto done;
136
137         puts("Writing to SPI flash...");
138
139         ret = spi_flash_write(env_flash, env_new_offset,
140                 CONFIG_ENV_SIZE, &env_new);
141         if (ret)
142                 goto done;
143
144         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
145                 ret = spi_flash_write(env_flash, saved_offset,
146                                         saved_size, saved_buffer);
147                 if (ret)
148                         goto done;
149         }
150
151         ret = spi_flash_write(env_flash,
152                 env_offset + offsetof(env_t, flags),
153                 sizeof(env_new.flags), &flag);
154         if (ret)
155                 goto done;
156
157         puts("done\n");
158
159         gd->env_valid = (gd->env_valid == 2 ? 1 : 2);
160
161         printf("Valid environment: %d\n", (int)gd->env_valid);
162
163  done:
164         if (saved_buffer)
165                 free(saved_buffer);
166         return ret;
167 }
168
169 void env_relocate_spec(void)
170 {
171         int ret;
172         int crc1_ok = 0, crc2_ok = 0;
173         env_t *tmp_env1 = NULL;
174         env_t *tmp_env2 = NULL;
175         env_t *ep = NULL;
176
177         tmp_env1 = (env_t *)malloc(CONFIG_ENV_SIZE);
178         tmp_env2 = (env_t *)malloc(CONFIG_ENV_SIZE);
179
180         if (!tmp_env1 || !tmp_env2) {
181                 set_default_env("!malloc() failed");
182                 goto out;
183         }
184
185         env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
186                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
187         if (!env_flash) {
188                 set_default_env("!spi_flash_probe() failed");
189                 goto out;
190         }
191
192         ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
193                                 CONFIG_ENV_SIZE, tmp_env1);
194         if (ret) {
195                 set_default_env("!spi_flash_read() failed");
196                 goto err_read;
197         }
198
199         if (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc)
200                 crc1_ok = 1;
201
202         ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND,
203                                 CONFIG_ENV_SIZE, tmp_env2);
204         if (!ret) {
205                 if (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc)
206                         crc2_ok = 1;
207         }
208
209         if (!crc1_ok && !crc2_ok) {
210                 set_default_env("!bad CRC");
211                 goto err_read;
212         } else if (crc1_ok && !crc2_ok) {
213                 gd->env_valid = 1;
214         } else if (!crc1_ok && crc2_ok) {
215                 gd->env_valid = 2;
216         } else if (tmp_env1->flags == ACTIVE_FLAG &&
217                    tmp_env2->flags == OBSOLETE_FLAG) {
218                 gd->env_valid = 1;
219         } else if (tmp_env1->flags == OBSOLETE_FLAG &&
220                    tmp_env2->flags == ACTIVE_FLAG) {
221                 gd->env_valid = 2;
222         } else if (tmp_env1->flags == tmp_env2->flags) {
223                 gd->env_valid = 2;
224         } else if (tmp_env1->flags == 0xFF) {
225                 gd->env_valid = 2;
226         } else {
227                 /*
228                  * this differs from code in env_flash.c, but I think a sane
229                  * default path is desirable.
230                  */
231                 gd->env_valid = 2;
232         }
233
234         if (gd->env_valid == 1)
235                 ep = tmp_env1;
236         else
237                 ep = tmp_env2;
238
239         ret = env_import((char *)ep, 0);
240         if (!ret) {
241                 error("Cannot import environment: errno = %d\n", errno);
242                 set_default_env("env_import failed");
243         }
244
245 err_read:
246         spi_flash_free(env_flash);
247         env_flash = NULL;
248 out:
249         free(tmp_env1);
250         free(tmp_env2);
251
252         return;
253 }
254 #else
255 int saveenv(void)
256 {
257         u32 saved_size, saved_offset;
258         char *saved_buffer = NULL;
259         u32 sector = 1;
260         int ret = 1;
261         env_t   env_new;
262         char    *res;
263         ssize_t len;
264
265         if (!env_flash) {
266                 env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS,
267                         CONFIG_ENV_SPI_CS,
268                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
269                 if (!env_flash) {
270                         set_default_env("!spi_flash_probe() failed");
271                         return 1;
272                 }
273         }
274
275         /* Is the sector larger than the env (i.e. embedded) */
276         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
277                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
278                 saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
279                 saved_buffer = malloc(saved_size);
280                 if (!saved_buffer) {
281                         goto done;
282                 }
283                 ret = spi_flash_read(env_flash, saved_offset,
284                         saved_size, saved_buffer);
285                 if (ret)
286                         goto done;
287         }
288
289         if (CONFIG_ENV_SIZE > CONFIG_ENV_SECT_SIZE) {
290                 sector = CONFIG_ENV_SIZE / CONFIG_ENV_SECT_SIZE;
291                 if (CONFIG_ENV_SIZE % CONFIG_ENV_SECT_SIZE)
292                         sector++;
293         }
294
295         res = (char *)&env_new.data;
296         len = hexport_r(&env_htab, '\0', &res, ENV_SIZE);
297         if (len < 0) {
298                 error("Cannot export environment: errno = %d\n", errno);
299                 goto done;
300         }
301         env_new.crc = crc32(0, env_new.data, ENV_SIZE);
302
303         puts("Erasing SPI flash...");
304         ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
305                 sector * CONFIG_ENV_SECT_SIZE);
306         if (ret)
307                 goto done;
308
309         puts("Writing to SPI flash...");
310         ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
311                 CONFIG_ENV_SIZE, &env_new);
312         if (ret)
313                 goto done;
314
315         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
316                 ret = spi_flash_write(env_flash, saved_offset,
317                         saved_size, saved_buffer);
318                 if (ret)
319                         goto done;
320         }
321
322         ret = 0;
323         puts("done\n");
324
325  done:
326         if (saved_buffer)
327                 free(saved_buffer);
328         return ret;
329 }
330
331 void env_relocate_spec(void)
332 {
333         char buf[CONFIG_ENV_SIZE];
334         int ret;
335
336         env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
337                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
338         if (!env_flash) {
339                 set_default_env("!spi_flash_probe() failed");
340                 return;
341         }
342
343         ret = spi_flash_read(env_flash,
344                 CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
345         if (ret) {
346                 set_default_env("!spi_flash_read() failed");
347                 goto out;
348         }
349
350         ret = env_import(buf, 1);
351
352         if (ret)
353                 gd->env_valid = 1;
354 out:
355         spi_flash_free(env_flash);
356         env_flash = NULL;
357 }
358 #endif
359
360 int env_init(void)
361 {
362         /* SPI flash isn't usable before relocation */
363         gd->env_addr = (ulong)&default_environment[0];
364         gd->env_valid = 1;
365
366         return 0;
367 }