]>
Commit | Line | Data |
---|---|---|
cdb97a66 AS |
1 | /* |
2 | * (C) Copyright 2006 | |
3 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or | |
6 | * modify it under the terms of the GNU General Public License as | |
7 | * published by the Free Software Foundation; either version 2 of | |
8 | * the License, or (at your option) any later version. | |
9 | * | |
10 | * This program is distributed in the hope that it will be useful, | |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | * GNU General Public License for more details. | |
14 | * | |
15 | * You should have received a copy of the GNU General Public License | |
16 | * along with this program; if not, write to the Free Software | |
17 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
18 | * MA 02111-1307 USA | |
19 | */ | |
20 | #include <common.h> | |
21 | #include <command.h> | |
22 | #include <malloc.h> | |
23 | #include <image.h> | |
24 | #include <asm/byteorder.h> | |
25 | #include <usb.h> | |
735dd97b | 26 | #include <part.h> |
cdb97a66 | 27 | |
6d0f6bcf | 28 | #ifdef CONFIG_SYS_HUSH_PARSER |
cdb97a66 AS |
29 | #include <hush.h> |
30 | #endif | |
31 | ||
32 | ||
33 | #ifdef CONFIG_AUTO_UPDATE | |
34 | ||
35 | #ifndef CONFIG_USB_OHCI | |
36 | #error "must define CONFIG_USB_OHCI" | |
37 | #endif | |
38 | ||
39 | #ifndef CONFIG_USB_STORAGE | |
40 | #error "must define CONFIG_USB_STORAGE" | |
41 | #endif | |
42 | ||
6d0f6bcf JCPV |
43 | #ifndef CONFIG_SYS_HUSH_PARSER |
44 | #error "must define CONFIG_SYS_HUSH_PARSER" | |
cdb97a66 AS |
45 | #endif |
46 | ||
3fe00109 | 47 | #if !defined(CONFIG_CMD_FAT) |
d39b5741 | 48 | #error "must define CONFIG_CMD_FAT" |
cdb97a66 AS |
49 | #endif |
50 | ||
cdb97a66 AS |
51 | #undef AU_DEBUG |
52 | ||
53 | #undef debug | |
54 | #ifdef AU_DEBUG | |
55 | #define debug(fmt,args...) printf (fmt ,##args) | |
56 | #else | |
57 | #define debug(fmt,args...) | |
58 | #endif /* AU_DEBUG */ | |
59 | ||
60 | /* possible names of files on the USB stick. */ | |
61 | #define AU_FIRMWARE "u-boot.img" | |
62 | #define AU_KERNEL "kernel.img" | |
489c696a | 63 | #define AU_ROOTFS "rootfs.img" |
cdb97a66 | 64 | |
82e5236a | 65 | struct flash_layout { |
cdb97a66 AS |
66 | long start; |
67 | long end; | |
68 | }; | |
69 | ||
70 | /* layout of the FLASH. ST = start address, ND = end address. */ | |
71 | #define AU_FL_FIRMWARE_ST 0xfC000000 | |
72 | #define AU_FL_FIRMWARE_ND 0xfC03FFFF | |
73 | #define AU_FL_KERNEL_ST 0xfC0C0000 | |
74 | #define AU_FL_KERNEL_ND 0xfC1BFFFF | |
489c696a SP |
75 | #define AU_FL_ROOTFS_ST 0xFC1C0000 |
76 | #define AU_FL_ROOTFS_ND 0xFCFBFFFF | |
cdb97a66 AS |
77 | |
78 | static int au_usb_stor_curr_dev; /* current device */ | |
79 | ||
80 | /* index of each file in the following arrays */ | |
81 | #define IDX_FIRMWARE 0 | |
82 | #define IDX_KERNEL 1 | |
489c696a | 83 | #define IDX_ROOTFS 2 |
cdb97a66 AS |
84 | |
85 | /* max. number of files which could interest us */ | |
489c696a | 86 | #define AU_MAXFILES 3 |
cdb97a66 AS |
87 | |
88 | /* pointers to file names */ | |
489c696a SP |
89 | char *aufile[AU_MAXFILES] = { |
90 | AU_FIRMWARE, | |
91 | AU_KERNEL, | |
92 | AU_ROOTFS | |
93 | }; | |
cdb97a66 AS |
94 | |
95 | /* sizes of flash areas for each file */ | |
489c696a SP |
96 | long ausize[AU_MAXFILES] = { |
97 | (AU_FL_FIRMWARE_ND + 1) - AU_FL_FIRMWARE_ST, | |
f5fcc3c2 WD |
98 | (AU_FL_KERNEL_ND + 1) - AU_FL_KERNEL_ST, |
99 | (AU_FL_ROOTFS_ND + 1) - AU_FL_ROOTFS_ST, | |
489c696a | 100 | }; |
cdb97a66 AS |
101 | |
102 | /* array of flash areas start and end addresses */ | |
489c696a | 103 | struct flash_layout aufl_layout[AU_MAXFILES] = { |
f5fcc3c2 WD |
104 | { AU_FL_FIRMWARE_ST, AU_FL_FIRMWARE_ND, }, |
105 | { AU_FL_KERNEL_ST, AU_FL_KERNEL_ND, }, | |
106 | { AU_FL_ROOTFS_ST, AU_FL_ROOTFS_ND, }, | |
cdb97a66 AS |
107 | }; |
108 | ||
638dd145 SP |
109 | ulong totsize; |
110 | ||
cdb97a66 AS |
111 | /* where to load files into memory */ |
112 | #define LOAD_ADDR ((unsigned char *)0x00200000) | |
113 | ||
f5fcc3c2 | 114 | /* the root file system is the largest image */ |
489c696a | 115 | #define MAX_LOADSZ ausize[IDX_ROOTFS] |
cdb97a66 AS |
116 | |
117 | /*i2c address of the keypad status*/ | |
118 | #define I2C_PSOC_KEYPAD_ADDR 0x53 | |
119 | ||
120 | /* keypad mask */ | |
787fa158 WD |
121 | #define KEYPAD_ROW 2 |
122 | #define KEYPAD_COL 2 | |
123 | #define KEYPAD_MASK_LO ((1<<(KEYPAD_COL-1+(KEYPAD_ROW*3-3)))&0xFF) | |
124 | #define KEYPAD_MASK_HI ((1<<(KEYPAD_COL-1+(KEYPAD_ROW*3-3)))>>8) | |
cdb97a66 AS |
125 | |
126 | /* externals */ | |
127 | extern int fat_register_device(block_dev_desc_t *, int); | |
128 | extern int file_fat_detectfs(void); | |
129 | extern long file_fat_read(const char *, void *, unsigned long); | |
130 | extern int i2c_read (unsigned char, unsigned int, int , unsigned char* , int); | |
131 | extern int flash_sect_erase(ulong, ulong); | |
132 | extern int flash_sect_protect (int, ulong, ulong); | |
133 | extern int flash_write (char *, ulong, ulong); | |
cdb97a66 | 134 | extern int u_boot_hush_start(void); |
638dd145 SP |
135 | #ifdef CONFIG_PROGRESSBAR |
136 | extern void show_progress(int, int); | |
137 | extern void lcd_puts (char *); | |
138 | extern void lcd_enable(void); | |
139 | #endif | |
cdb97a66 | 140 | |
82e5236a | 141 | int au_check_cksum_valid(int idx, long nbytes) |
cdb97a66 AS |
142 | { |
143 | image_header_t *hdr; | |
cdb97a66 AS |
144 | |
145 | hdr = (image_header_t *)LOAD_ADDR; | |
d5934ad7 | 146 | #if defined(CONFIG_FIT) |
9a4daad0 | 147 | if (genimg_get_format ((void *)hdr) != IMAGE_FORMAT_LEGACY) { |
d5934ad7 MB |
148 | puts ("Non legacy image format not supported\n"); |
149 | return -1; | |
150 | } | |
151 | #endif | |
cdb97a66 | 152 | |
b97a2a0a | 153 | if (nbytes != image_get_image_size (hdr)) { |
cdb97a66 AS |
154 | printf ("Image %s bad total SIZE\n", aufile[idx]); |
155 | return -1; | |
156 | } | |
157 | /* check the data CRC */ | |
b97a2a0a | 158 | if (!image_check_dcrc (hdr)) { |
cdb97a66 AS |
159 | printf ("Image %s bad data checksum\n", aufile[idx]); |
160 | return -1; | |
161 | } | |
162 | return 0; | |
163 | } | |
164 | ||
82e5236a | 165 | int au_check_header_valid(int idx, long nbytes) |
cdb97a66 AS |
166 | { |
167 | image_header_t *hdr; | |
e344568b | 168 | unsigned long checksum, fsize; |
cdb97a66 AS |
169 | |
170 | hdr = (image_header_t *)LOAD_ADDR; | |
d5934ad7 | 171 | #if defined(CONFIG_FIT) |
9a4daad0 | 172 | if (genimg_get_format ((void *)hdr) != IMAGE_FORMAT_LEGACY) { |
d5934ad7 MB |
173 | puts ("Non legacy image format not supported\n"); |
174 | return -1; | |
175 | } | |
176 | #endif | |
177 | ||
cdb97a66 AS |
178 | /* check the easy ones first */ |
179 | #undef CHECK_VALID_DEBUG | |
180 | #ifdef CHECK_VALID_DEBUG | |
b97a2a0a MB |
181 | printf("magic %#x %#x ", image_get_magic (hdr), IH_MAGIC); |
182 | printf("arch %#x %#x ", image_get_arch (hdr), IH_ARCH_ARM); | |
183 | printf("size %#x %#lx ", image_get_data_size (hdr), nbytes); | |
184 | printf("type %#x %#x ", image_get_type (hdr), IH_TYPE_KERNEL); | |
cdb97a66 | 185 | #endif |
b97a2a0a | 186 | if (nbytes < image_get_header_size ()) { |
cdb97a66 | 187 | printf ("Image %s bad header SIZE\n", aufile[idx]); |
638dd145 | 188 | ausize[idx] = 0; |
cdb97a66 AS |
189 | return -1; |
190 | } | |
b97a2a0a | 191 | if (!image_check_magic (hdr) || !image_check_arch (hdr, IH_ARCH_PPC)) { |
cdb97a66 | 192 | printf ("Image %s bad MAGIC or ARCH\n", aufile[idx]); |
638dd145 | 193 | ausize[idx] = 0; |
cdb97a66 AS |
194 | return -1; |
195 | } | |
196 | /* check the hdr CRC */ | |
b97a2a0a | 197 | if (!image_check_hcrc (hdr)) { |
cdb97a66 | 198 | printf ("Image %s bad header checksum\n", aufile[idx]); |
638dd145 | 199 | ausize[idx] = 0; |
cdb97a66 AS |
200 | return -1; |
201 | } | |
cdb97a66 | 202 | /* check the type - could do this all in one gigantic if() */ |
b97a2a0a | 203 | if ((idx == IDX_FIRMWARE) && !image_check_type (hdr, IH_TYPE_FIRMWARE)) { |
cdb97a66 | 204 | printf ("Image %s wrong type\n", aufile[idx]); |
638dd145 | 205 | ausize[idx] = 0; |
cdb97a66 AS |
206 | return -1; |
207 | } | |
b97a2a0a | 208 | if ((idx == IDX_KERNEL) && !image_check_type (hdr, IH_TYPE_KERNEL)) { |
cdb97a66 | 209 | printf ("Image %s wrong type\n", aufile[idx]); |
638dd145 | 210 | ausize[idx] = 0; |
cdb97a66 AS |
211 | return -1; |
212 | } | |
f5fcc3c2 | 213 | if ((idx == IDX_ROOTFS) && |
b97a2a0a MB |
214 | (!image_check_type (hdr, IH_TYPE_RAMDISK) && |
215 | !image_check_type (hdr, IH_TYPE_FILESYSTEM))) { | |
489c696a | 216 | printf ("Image %s wrong type\n", aufile[idx]); |
638dd145 | 217 | ausize[idx] = 0; |
489c696a SP |
218 | return -1; |
219 | } | |
cdb97a66 | 220 | /* recycle checksum */ |
b97a2a0a | 221 | checksum = image_get_data_size (hdr); |
e344568b | 222 | |
b97a2a0a | 223 | fsize = checksum + image_get_header_size (); |
e344568b | 224 | /* for kernel and ramdisk the image header must also fit into flash */ |
b97a2a0a MB |
225 | if (idx == IDX_KERNEL || image_check_type (hdr, IH_TYPE_RAMDISK)) |
226 | checksum += image_get_header_size (); | |
638dd145 | 227 | |
cdb97a66 | 228 | /* check the size does not exceed space in flash. HUSH scripts */ |
cdb97a66 AS |
229 | if ((ausize[idx] != 0) && (ausize[idx] < checksum)) { |
230 | printf ("Image %s is bigger than FLASH\n", aufile[idx]); | |
638dd145 | 231 | ausize[idx] = 0; |
cdb97a66 AS |
232 | return -1; |
233 | } | |
638dd145 | 234 | /* Update with the real filesize */ |
e344568b | 235 | ausize[idx] = fsize; |
638dd145 SP |
236 | |
237 | return checksum; /* return size to be written to flash */ | |
cdb97a66 AS |
238 | } |
239 | ||
82e5236a | 240 | int au_do_update(int idx, long sz) |
cdb97a66 AS |
241 | { |
242 | image_header_t *hdr; | |
243 | char *addr; | |
244 | long start, end; | |
245 | int off, rc; | |
246 | uint nbytes; | |
247 | ||
248 | hdr = (image_header_t *)LOAD_ADDR; | |
d5934ad7 | 249 | #if defined(CONFIG_FIT) |
9a4daad0 | 250 | if (genimg_get_format ((void *)hdr) != IMAGE_FORMAT_LEGACY) { |
d5934ad7 MB |
251 | puts ("Non legacy image format not supported\n"); |
252 | return -1; | |
253 | } | |
254 | #endif | |
cdb97a66 AS |
255 | |
256 | /* execute a script */ | |
b97a2a0a MB |
257 | if (image_check_type (hdr, IH_TYPE_SCRIPT)) { |
258 | addr = (char *)((char *)hdr + image_get_header_size ()); | |
cdb97a66 AS |
259 | /* stick a NULL at the end of the script, otherwise */ |
260 | /* parse_string_outer() runs off the end. */ | |
b97a2a0a | 261 | addr[image_get_data_size (hdr)] = 0; |
cdb97a66 AS |
262 | addr += 8; |
263 | parse_string_outer(addr, FLAG_PARSE_SEMICOLON); | |
264 | return 0; | |
265 | } | |
266 | ||
267 | start = aufl_layout[idx].start; | |
268 | end = aufl_layout[idx].end; | |
269 | ||
270 | /* unprotect the address range */ | |
271 | /* this assumes that ONLY the firmware is protected! */ | |
272 | if (idx == IDX_FIRMWARE) { | |
273 | #undef AU_UPDATE_TEST | |
274 | #ifdef AU_UPDATE_TEST | |
275 | /* erase it where Linux goes */ | |
276 | start = aufl_layout[1].start; | |
277 | end = aufl_layout[1].end; | |
278 | #endif | |
279 | flash_sect_protect(0, start, end); | |
280 | } | |
281 | ||
282 | /* | |
283 | * erase the address range. | |
284 | */ | |
285 | debug ("flash_sect_erase(%lx, %lx);\n", start, end); | |
286 | flash_sect_erase(start, end); | |
287 | wait_ms(100); | |
638dd145 SP |
288 | #ifdef CONFIG_PROGRESSBAR |
289 | show_progress(end - start, totsize); | |
290 | #endif | |
291 | ||
cdb97a66 | 292 | /* strip the header - except for the kernel and ramdisk */ |
b97a2a0a MB |
293 | if (image_check_type (hdr, IH_TYPE_KERNEL) || |
294 | image_check_type (hdr, IH_TYPE_RAMDISK)) { | |
cdb97a66 | 295 | addr = (char *)hdr; |
b97a2a0a MB |
296 | off = image_get_header_size (); |
297 | nbytes = image_get_image_size (hdr); | |
cdb97a66 | 298 | } else { |
b97a2a0a | 299 | addr = (char *)((char *)hdr + image_get_header_size ()); |
cdb97a66 AS |
300 | #ifdef AU_UPDATE_TEST |
301 | /* copy it to where Linux goes */ | |
302 | if (idx == IDX_FIRMWARE) | |
303 | start = aufl_layout[1].start; | |
304 | #endif | |
305 | off = 0; | |
b97a2a0a | 306 | nbytes = image_get_data_size (hdr); |
cdb97a66 AS |
307 | } |
308 | ||
309 | /* copy the data from RAM to FLASH */ | |
310 | debug ("flash_write(%p, %lx %x)\n", addr, start, nbytes); | |
311 | rc = flash_write(addr, start, nbytes); | |
312 | if (rc != 0) { | |
313 | printf("Flashing failed due to error %d\n", rc); | |
314 | return -1; | |
315 | } | |
316 | ||
638dd145 SP |
317 | #ifdef CONFIG_PROGRESSBAR |
318 | show_progress(nbytes, totsize); | |
319 | #endif | |
320 | ||
f5fcc3c2 | 321 | /* check the data CRC of the copy */ |
b97a2a0a MB |
322 | if (crc32 (0, (uchar *)(start + off), image_get_data_size (hdr)) != |
323 | image_get_dcrc (hdr)) { | |
f5fcc3c2 | 324 | printf ("Image %s Bad Data Checksum after COPY\n", aufile[idx]); |
cdb97a66 AS |
325 | return -1; |
326 | } | |
327 | ||
328 | /* protect the address range */ | |
329 | /* this assumes that ONLY the firmware is protected! */ | |
330 | if (idx == IDX_FIRMWARE) | |
331 | flash_sect_protect(1, start, end); | |
332 | return 0; | |
333 | } | |
334 | ||
cdb97a66 AS |
335 | /* |
336 | * this is called from board_init() after the hardware has been set up | |
337 | * and is usable. That seems like a good time to do this. | |
338 | * Right now the return value is ignored. | |
339 | */ | |
82e5236a | 340 | int do_auto_update(void) |
cdb97a66 AS |
341 | { |
342 | block_dev_desc_t *stor_dev; | |
343 | long sz; | |
638dd145 | 344 | int i, res = 0, bitmap_first, cnt, old_ctrlc, got_ctrlc; |
cdb97a66 AS |
345 | char *env; |
346 | long start, end; | |
a4d2636f WD |
347 | |
348 | #if 0 /* disable key-press detection to speed up boot-up time */ | |
489c696a | 349 | uchar keypad_status1[2] = {0,0}, keypad_status2[2] = {0,0}; |
cdb97a66 AS |
350 | |
351 | /* | |
352 | * Read keypad status | |
353 | */ | |
354 | i2c_read(I2C_PSOC_KEYPAD_ADDR, 0, 0, keypad_status1, 2); | |
355 | wait_ms(500); | |
356 | i2c_read(I2C_PSOC_KEYPAD_ADDR, 0, 0, keypad_status2, 2); | |
357 | ||
358 | /* | |
359 | * Check keypad | |
360 | */ | |
cdb97a66 AS |
361 | if ( !(keypad_status1[1] & KEYPAD_MASK_LO) || |
362 | (keypad_status1[1] != keypad_status2[1])) { | |
363 | return 0; | |
364 | } | |
638dd145 | 365 | |
a4d2636f | 366 | #endif |
cdb97a66 AS |
367 | au_usb_stor_curr_dev = -1; |
368 | /* start USB */ | |
369 | if (usb_stop() < 0) { | |
370 | debug ("usb_stop failed\n"); | |
371 | return -1; | |
372 | } | |
373 | if (usb_init() < 0) { | |
374 | debug ("usb_init failed\n"); | |
375 | return -1; | |
376 | } | |
377 | /* | |
378 | * check whether a storage device is attached (assume that it's | |
379 | * a USB memory stick, since nothing else should be attached). | |
380 | */ | |
381 | au_usb_stor_curr_dev = usb_stor_scan(0); | |
382 | if (au_usb_stor_curr_dev == -1) { | |
383 | debug ("No device found. Not initialized?\n"); | |
a4d2636f WD |
384 | res = -1; |
385 | goto xit; | |
cdb97a66 AS |
386 | } |
387 | /* check whether it has a partition table */ | |
388 | stor_dev = get_dev("usb", 0); | |
389 | if (stor_dev == NULL) { | |
390 | debug ("uknown device type\n"); | |
a4d2636f WD |
391 | res = -1; |
392 | goto xit; | |
cdb97a66 AS |
393 | } |
394 | if (fat_register_device(stor_dev, 1) != 0) { | |
395 | debug ("Unable to use USB %d:%d for fatls\n", | |
396 | au_usb_stor_curr_dev, 1); | |
a4d2636f WD |
397 | res = -1; |
398 | goto xit; | |
cdb97a66 AS |
399 | } |
400 | if (file_fat_detectfs() != 0) { | |
401 | debug ("file_fat_detectfs failed\n"); | |
402 | } | |
403 | ||
cdb97a66 AS |
404 | /* |
405 | * now check whether start and end are defined using environment | |
406 | * variables. | |
407 | */ | |
408 | start = -1; | |
409 | end = 0; | |
410 | env = getenv("firmware_st"); | |
411 | if (env != NULL) | |
412 | start = simple_strtoul(env, NULL, 16); | |
413 | env = getenv("firmware_nd"); | |
414 | if (env != NULL) | |
415 | end = simple_strtoul(env, NULL, 16); | |
416 | if (start >= 0 && end && end > start) { | |
417 | ausize[IDX_FIRMWARE] = (end + 1) - start; | |
489c696a SP |
418 | aufl_layout[IDX_FIRMWARE].start = start; |
419 | aufl_layout[IDX_FIRMWARE].end = end; | |
cdb97a66 AS |
420 | } |
421 | start = -1; | |
422 | end = 0; | |
423 | env = getenv("kernel_st"); | |
424 | if (env != NULL) | |
425 | start = simple_strtoul(env, NULL, 16); | |
426 | env = getenv("kernel_nd"); | |
427 | if (env != NULL) | |
428 | end = simple_strtoul(env, NULL, 16); | |
429 | if (start >= 0 && end && end > start) { | |
430 | ausize[IDX_KERNEL] = (end + 1) - start; | |
489c696a SP |
431 | aufl_layout[IDX_KERNEL].start = start; |
432 | aufl_layout[IDX_KERNEL].end = end; | |
cdb97a66 | 433 | } |
489c696a SP |
434 | start = -1; |
435 | end = 0; | |
436 | env = getenv("rootfs_st"); | |
437 | if (env != NULL) | |
438 | start = simple_strtoul(env, NULL, 16); | |
439 | env = getenv("rootfs_nd"); | |
440 | if (env != NULL) | |
441 | end = simple_strtoul(env, NULL, 16); | |
442 | if (start >= 0 && end && end > start) { | |
443 | ausize[IDX_ROOTFS] = (end + 1) - start; | |
444 | aufl_layout[IDX_ROOTFS].start = start; | |
445 | aufl_layout[IDX_ROOTFS].end = end; | |
446 | } | |
447 | ||
cdb97a66 AS |
448 | /* make certain that HUSH is runnable */ |
449 | u_boot_hush_start(); | |
450 | /* make sure that we see CTRL-C and save the old state */ | |
451 | old_ctrlc = disable_ctrlc(0); | |
452 | ||
453 | bitmap_first = 0; | |
638dd145 | 454 | |
74357114 | 455 | /* validate the images first */ |
cdb97a66 | 456 | for (i = 0; i < AU_MAXFILES; i++) { |
638dd145 | 457 | ulong imsize; |
cdb97a66 | 458 | /* just read the header */ |
b97a2a0a | 459 | sz = file_fat_read(aufile[i], LOAD_ADDR, image_get_header_size ()); |
cdb97a66 | 460 | debug ("read %s sz %ld hdr %d\n", |
b97a2a0a MB |
461 | aufile[i], sz, image_get_header_size ()); |
462 | if (sz <= 0 || sz < image_get_header_size ()) { | |
cdb97a66 | 463 | debug ("%s not found\n", aufile[i]); |
638dd145 | 464 | ausize[i] = 0; |
cdb97a66 AS |
465 | continue; |
466 | } | |
638dd145 SP |
467 | /* au_check_header_valid() updates ausize[] */ |
468 | if ((imsize = au_check_header_valid(i, sz)) < 0) { | |
cdb97a66 AS |
469 | debug ("%s header not valid\n", aufile[i]); |
470 | continue; | |
471 | } | |
638dd145 | 472 | /* totsize accounts for image size and flash erase size */ |
74357114 | 473 | totsize += (imsize + (aufl_layout[i].end - aufl_layout[i].start)); |
638dd145 SP |
474 | } |
475 | ||
476 | #ifdef CONFIG_PROGRESSBAR | |
477 | if (totsize) { | |
478 | lcd_puts(" Update in progress\n"); | |
479 | lcd_enable(); | |
480 | } | |
481 | #endif | |
482 | ||
483 | /* just loop thru all the possible files */ | |
484 | for (i = 0; i < AU_MAXFILES && totsize; i++) { | |
485 | if (!ausize[i]) { | |
486 | continue; | |
487 | } | |
488 | sz = file_fat_read(aufile[i], LOAD_ADDR, ausize[i]); | |
489 | ||
cdb97a66 | 490 | debug ("read %s sz %ld hdr %d\n", |
b97a2a0a | 491 | aufile[i], sz, image_get_header_size ()); |
638dd145 SP |
492 | |
493 | if (sz != ausize[i]) { | |
9b55a253 | 494 | printf ("%s: size %ld read %ld?\n", aufile[i], ausize[i], sz); |
74357114 WD |
495 | continue; |
496 | } | |
638dd145 | 497 | |
b97a2a0a | 498 | if (sz <= 0 || sz <= image_get_header_size ()) { |
cdb97a66 AS |
499 | debug ("%s not found\n", aufile[i]); |
500 | continue; | |
501 | } | |
502 | if (au_check_cksum_valid(i, sz) < 0) { | |
503 | debug ("%s checksum not valid\n", aufile[i]); | |
504 | continue; | |
505 | } | |
506 | /* this is really not a good idea, but it's what the */ | |
507 | /* customer wants. */ | |
508 | cnt = 0; | |
509 | got_ctrlc = 0; | |
510 | do { | |
511 | res = au_do_update(i, sz); | |
512 | /* let the user break out of the loop */ | |
513 | if (ctrlc() || had_ctrlc()) { | |
514 | clear_ctrlc(); | |
515 | if (res < 0) | |
516 | got_ctrlc = 1; | |
517 | break; | |
518 | } | |
519 | cnt++; | |
520 | #ifdef AU_TEST_ONLY | |
489c696a SP |
521 | } while (res < 0 && cnt < (AU_MAXFILES + 1)); |
522 | if (cnt < (AU_MAXFILES + 1)) | |
cdb97a66 AS |
523 | #else |
524 | } while (res < 0); | |
525 | #endif | |
526 | } | |
a4d2636f | 527 | |
cdb97a66 AS |
528 | /* restore the old state */ |
529 | disable_ctrlc(old_ctrlc); | |
638dd145 SP |
530 | #ifdef CONFIG_PROGRESSBAR |
531 | if (totsize) { | |
532 | if (!res) { | |
533 | lcd_puts("\n Update completed\n"); | |
534 | } else { | |
535 | lcd_puts("\n Update error\n"); | |
536 | } | |
537 | lcd_enable(); | |
538 | } | |
539 | #endif | |
a4d2636f WD |
540 | xit: |
541 | usb_stop(); | |
542 | return res; | |
cdb97a66 AS |
543 | } |
544 | #endif /* CONFIG_AUTO_UPDATE */ |