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