Merge branch 'u-boot-imx/master' into 'u-boot-arm/master'
[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  * SPDX-License-Identifier:     GPL-2.0+
11  */
12 #include <common.h>
13 #include <environment.h>
14 #include <malloc.h>
15 #include <spi_flash.h>
16 #include <search.h>
17 #include <errno.h>
18
19 #ifndef CONFIG_ENV_SPI_BUS
20 # define CONFIG_ENV_SPI_BUS     0
21 #endif
22 #ifndef CONFIG_ENV_SPI_CS
23 # define CONFIG_ENV_SPI_CS      0
24 #endif
25 #ifndef CONFIG_ENV_SPI_MAX_HZ
26 # define CONFIG_ENV_SPI_MAX_HZ  1000000
27 #endif
28 #ifndef CONFIG_ENV_SPI_MODE
29 # define CONFIG_ENV_SPI_MODE    SPI_MODE_3
30 #endif
31
32 #ifdef CONFIG_ENV_OFFSET_REDUND
33 static ulong env_offset         = CONFIG_ENV_OFFSET;
34 static ulong env_new_offset     = CONFIG_ENV_OFFSET_REDUND;
35
36 #define ACTIVE_FLAG     1
37 #define OBSOLETE_FLAG   0
38 #endif /* CONFIG_ENV_OFFSET_REDUND */
39
40 DECLARE_GLOBAL_DATA_PTR;
41
42 char *env_name_spec = "SPI Flash";
43
44 static struct spi_flash *env_flash;
45
46 #if defined(CONFIG_ENV_OFFSET_REDUND)
47 int saveenv(void)
48 {
49         env_t   env_new;
50         ssize_t len;
51         char    *res, *saved_buffer = NULL, flag = OBSOLETE_FLAG;
52         u32     saved_size, saved_offset, sector = 1;
53         int     ret;
54
55         if (!env_flash) {
56                 env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS,
57                         CONFIG_ENV_SPI_CS,
58                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
59                 if (!env_flash) {
60                         set_default_env("!spi_flash_probe() failed");
61                         return 1;
62                 }
63         }
64
65         res = (char *)&env_new.data;
66         len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
67         if (len < 0) {
68                 error("Cannot export environment: errno = %d\n", errno);
69                 return 1;
70         }
71         env_new.crc     = crc32(0, env_new.data, ENV_SIZE);
72         env_new.flags   = ACTIVE_FLAG;
73
74         if (gd->env_valid == 1) {
75                 env_new_offset = CONFIG_ENV_OFFSET_REDUND;
76                 env_offset = CONFIG_ENV_OFFSET;
77         } else {
78                 env_new_offset = CONFIG_ENV_OFFSET;
79                 env_offset = CONFIG_ENV_OFFSET_REDUND;
80         }
81
82         /* Is the sector larger than the env (i.e. embedded) */
83         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
84                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
85                 saved_offset = env_new_offset + CONFIG_ENV_SIZE;
86                 saved_buffer = malloc(saved_size);
87                 if (!saved_buffer) {
88                         ret = 1;
89                         goto done;
90                 }
91                 ret = spi_flash_read(env_flash, saved_offset,
92                                         saved_size, saved_buffer);
93                 if (ret)
94                         goto done;
95         }
96
97         if (CONFIG_ENV_SIZE > CONFIG_ENV_SECT_SIZE) {
98                 sector = CONFIG_ENV_SIZE / CONFIG_ENV_SECT_SIZE;
99                 if (CONFIG_ENV_SIZE % CONFIG_ENV_SECT_SIZE)
100                         sector++;
101         }
102
103         puts("Erasing SPI flash...");
104         ret = spi_flash_erase(env_flash, env_new_offset,
105                                 sector * CONFIG_ENV_SECT_SIZE);
106         if (ret)
107                 goto done;
108
109         puts("Writing to SPI flash...");
110
111         ret = spi_flash_write(env_flash, env_new_offset,
112                 CONFIG_ENV_SIZE, &env_new);
113         if (ret)
114                 goto done;
115
116         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
117                 ret = spi_flash_write(env_flash, saved_offset,
118                                         saved_size, saved_buffer);
119                 if (ret)
120                         goto done;
121         }
122
123         ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags),
124                                 sizeof(env_new.flags), &flag);
125         if (ret)
126                 goto done;
127
128         puts("done\n");
129
130         gd->env_valid = gd->env_valid == 2 ? 1 : 2;
131
132         printf("Valid environment: %d\n", (int)gd->env_valid);
133
134  done:
135         if (saved_buffer)
136                 free(saved_buffer);
137
138         return ret;
139 }
140
141 void env_relocate_spec(void)
142 {
143         int ret;
144         int crc1_ok = 0, crc2_ok = 0;
145         env_t *tmp_env1 = NULL;
146         env_t *tmp_env2 = NULL;
147         env_t *ep = NULL;
148
149         tmp_env1 = (env_t *)malloc(CONFIG_ENV_SIZE);
150         tmp_env2 = (env_t *)malloc(CONFIG_ENV_SIZE);
151
152         if (!tmp_env1 || !tmp_env2) {
153                 set_default_env("!malloc() failed");
154                 goto out;
155         }
156
157         env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
158                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
159         if (!env_flash) {
160                 set_default_env("!spi_flash_probe() failed");
161                 goto out;
162         }
163
164         ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
165                                 CONFIG_ENV_SIZE, tmp_env1);
166         if (ret) {
167                 set_default_env("!spi_flash_read() failed");
168                 goto err_read;
169         }
170
171         if (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc)
172                 crc1_ok = 1;
173
174         ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND,
175                                 CONFIG_ENV_SIZE, tmp_env2);
176         if (!ret) {
177                 if (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc)
178                         crc2_ok = 1;
179         }
180
181         if (!crc1_ok && !crc2_ok) {
182                 set_default_env("!bad CRC");
183                 goto err_read;
184         } else if (crc1_ok && !crc2_ok) {
185                 gd->env_valid = 1;
186         } else if (!crc1_ok && crc2_ok) {
187                 gd->env_valid = 2;
188         } else if (tmp_env1->flags == ACTIVE_FLAG &&
189                    tmp_env2->flags == OBSOLETE_FLAG) {
190                 gd->env_valid = 1;
191         } else if (tmp_env1->flags == OBSOLETE_FLAG &&
192                    tmp_env2->flags == ACTIVE_FLAG) {
193                 gd->env_valid = 2;
194         } else if (tmp_env1->flags == tmp_env2->flags) {
195                 gd->env_valid = 2;
196         } else if (tmp_env1->flags == 0xFF) {
197                 gd->env_valid = 2;
198         } else {
199                 /*
200                  * this differs from code in env_flash.c, but I think a sane
201                  * default path is desirable.
202                  */
203                 gd->env_valid = 2;
204         }
205
206         if (gd->env_valid == 1)
207                 ep = tmp_env1;
208         else
209                 ep = tmp_env2;
210
211         ret = env_import((char *)ep, 0);
212         if (!ret) {
213                 error("Cannot import environment: errno = %d\n", errno);
214                 set_default_env("env_import failed");
215         }
216
217 err_read:
218         spi_flash_free(env_flash);
219         env_flash = NULL;
220 out:
221         free(tmp_env1);
222         free(tmp_env2);
223 }
224 #else
225 int saveenv(void)
226 {
227         u32     saved_size, saved_offset, sector = 1;
228         char    *res, *saved_buffer = NULL;
229         int     ret = 1;
230         env_t   env_new;
231         ssize_t len;
232
233         if (!env_flash) {
234                 env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS,
235                         CONFIG_ENV_SPI_CS,
236                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
237                 if (!env_flash) {
238                         set_default_env("!spi_flash_probe() failed");
239                         return 1;
240                 }
241         }
242
243         /* Is the sector larger than the env (i.e. embedded) */
244         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
245                 saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
246                 saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
247                 saved_buffer = malloc(saved_size);
248                 if (!saved_buffer)
249                         goto done;
250
251                 ret = spi_flash_read(env_flash, saved_offset,
252                         saved_size, saved_buffer);
253                 if (ret)
254                         goto done;
255         }
256
257         if (CONFIG_ENV_SIZE > CONFIG_ENV_SECT_SIZE) {
258                 sector = CONFIG_ENV_SIZE / CONFIG_ENV_SECT_SIZE;
259                 if (CONFIG_ENV_SIZE % CONFIG_ENV_SECT_SIZE)
260                         sector++;
261         }
262
263         res = (char *)&env_new.data;
264         len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
265         if (len < 0) {
266                 error("Cannot export environment: errno = %d\n", errno);
267                 goto done;
268         }
269         env_new.crc = crc32(0, env_new.data, ENV_SIZE);
270
271         puts("Erasing SPI flash...");
272         ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
273                 sector * CONFIG_ENV_SECT_SIZE);
274         if (ret)
275                 goto done;
276
277         puts("Writing to SPI flash...");
278         ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
279                 CONFIG_ENV_SIZE, &env_new);
280         if (ret)
281                 goto done;
282
283         if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
284                 ret = spi_flash_write(env_flash, saved_offset,
285                         saved_size, saved_buffer);
286                 if (ret)
287                         goto done;
288         }
289
290         ret = 0;
291         puts("done\n");
292
293  done:
294         if (saved_buffer)
295                 free(saved_buffer);
296
297         return ret;
298 }
299
300 void env_relocate_spec(void)
301 {
302         char buf[CONFIG_ENV_SIZE];
303         int ret;
304
305         env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
306                         CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
307         if (!env_flash) {
308                 set_default_env("!spi_flash_probe() failed");
309                 return;
310         }
311
312         ret = spi_flash_read(env_flash,
313                 CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
314         if (ret) {
315                 set_default_env("!spi_flash_read() failed");
316                 goto out;
317         }
318
319         ret = env_import(buf, 1);
320         if (ret)
321                 gd->env_valid = 1;
322 out:
323         spi_flash_free(env_flash);
324         env_flash = NULL;
325 }
326 #endif
327
328 int env_init(void)
329 {
330         /* SPI flash isn't usable before relocation */
331         gd->env_addr = (ulong)&default_environment[0];
332         gd->env_valid = 1;
333
334         return 0;
335 }