source: SVN/rincon/u-boot/board/mcc200/auto_update.c @ 55

Last change on this file since 55 was 55, checked in by Tim Harvey, 2 years ago

rincon: added latest u-boot source

restored form server backup

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

File size: 13.8 KB
Line 
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>
26#include <part.h>
27
28#ifdef CFG_HUSH_PARSER
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
43#ifndef CFG_HUSH_PARSER
44#error "must define CFG_HUSH_PARSER"
45#endif
46
47#if !defined(CONFIG_CMD_FAT)
48#error "must define CONFIG_CMD_FAT"
49#endif
50
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"
63#define AU_ROOTFS       "rootfs.img"
64
65struct flash_layout {
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
75#define AU_FL_ROOTFS_ST         0xFC1C0000
76#define AU_FL_ROOTFS_ND         0xFCFBFFFF
77
78static 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
83#define IDX_ROOTFS      2
84
85/* max. number of files which could interest us */
86#define AU_MAXFILES 3
87
88/* pointers to file names */
89char *aufile[AU_MAXFILES] = {
90        AU_FIRMWARE,
91        AU_KERNEL,
92        AU_ROOTFS
93};
94
95/* sizes of flash areas for each file */
96long ausize[AU_MAXFILES] = {
97        (AU_FL_FIRMWARE_ND + 1) - AU_FL_FIRMWARE_ST,
98        (AU_FL_KERNEL_ND   + 1) - AU_FL_KERNEL_ST,
99        (AU_FL_ROOTFS_ND   + 1) - AU_FL_ROOTFS_ST,
100};
101
102/* array of flash areas start and end addresses */
103struct flash_layout aufl_layout[AU_MAXFILES] = {
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,   },
107};
108
109ulong totsize;
110
111/* where to load files into memory */
112#define LOAD_ADDR ((unsigned char *)0x00200000)
113
114/* the root file system is the largest image */
115#define MAX_LOADSZ ausize[IDX_ROOTFS]
116
117/*i2c address of the keypad status*/
118#define I2C_PSOC_KEYPAD_ADDR    0x53
119
120/* keypad mask */
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)
125
126/* externals */
127extern int fat_register_device(block_dev_desc_t *, int);
128extern int file_fat_detectfs(void);
129extern long file_fat_read(const char *, void *, unsigned long);
130extern int i2c_read (unsigned char, unsigned int, int , unsigned char* , int);
131extern int flash_sect_erase(ulong, ulong);
132extern int flash_sect_protect (int, ulong, ulong);
133extern int flash_write (char *, ulong, ulong);
134extern int u_boot_hush_start(void);
135#ifdef CONFIG_PROGRESSBAR
136extern void show_progress(int, int);
137extern void lcd_puts (char *);
138extern void lcd_enable(void);
139#endif
140
141int au_check_cksum_valid(int idx, long nbytes)
142{
143        image_header_t *hdr;
144
145        hdr = (image_header_t *)LOAD_ADDR;
146#if defined(CONFIG_FIT)
147        if (genimg_get_format ((void *)hdr) != IMAGE_FORMAT_LEGACY) {
148                puts ("Non legacy image format not supported\n");
149                return -1;
150        }
151#endif
152
153        if (nbytes != image_get_image_size (hdr)) {
154                printf ("Image %s bad total SIZE\n", aufile[idx]);
155                return -1;
156        }
157        /* check the data CRC */
158        if (!image_check_dcrc (hdr)) {
159                printf ("Image %s bad data checksum\n", aufile[idx]);
160                return -1;
161        }
162        return 0;
163}
164
165int au_check_header_valid(int idx, long nbytes)
166{
167        image_header_t *hdr;
168        unsigned long checksum, fsize;
169
170        hdr = (image_header_t *)LOAD_ADDR;
171#if defined(CONFIG_FIT)
172        if (genimg_get_format ((void *)hdr) != IMAGE_FORMAT_LEGACY) {
173                puts ("Non legacy image format not supported\n");
174                return -1;
175        }
176#endif
177
178        /* check the easy ones first */
179#undef CHECK_VALID_DEBUG
180#ifdef CHECK_VALID_DEBUG
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);
185#endif
186        if (nbytes < image_get_header_size ()) {
187                printf ("Image %s bad header SIZE\n", aufile[idx]);
188                ausize[idx] = 0;
189                return -1;
190        }
191        if (!image_check_magic (hdr) || !image_check_arch (hdr, IH_ARCH_PPC)) {
192                printf ("Image %s bad MAGIC or ARCH\n", aufile[idx]);
193                ausize[idx] = 0;
194                return -1;
195        }
196        /* check the hdr CRC */
197        if (!image_check_hcrc (hdr)) {
198                printf ("Image %s bad header checksum\n", aufile[idx]);
199                ausize[idx] = 0;
200                return -1;
201        }
202        /* check the type - could do this all in one gigantic if() */
203        if ((idx == IDX_FIRMWARE) && !image_check_type (hdr, IH_TYPE_FIRMWARE)) {
204                printf ("Image %s wrong type\n", aufile[idx]);
205                ausize[idx] = 0;
206                return -1;
207        }
208        if ((idx == IDX_KERNEL) && !image_check_type (hdr, IH_TYPE_KERNEL)) {
209                printf ("Image %s wrong type\n", aufile[idx]);
210                ausize[idx] = 0;
211                return -1;
212        }
213        if ((idx == IDX_ROOTFS) &&
214                        (!image_check_type (hdr, IH_TYPE_RAMDISK) &&
215                        !image_check_type (hdr, IH_TYPE_FILESYSTEM))) {
216                printf ("Image %s wrong type\n", aufile[idx]);
217                ausize[idx] = 0;
218                return -1;
219        }
220        /* recycle checksum */
221        checksum = image_get_data_size (hdr);
222
223        fsize = checksum + image_get_header_size ();
224        /* for kernel and ramdisk the image header must also fit into flash */
225        if (idx == IDX_KERNEL || image_check_type (hdr, IH_TYPE_RAMDISK))
226                checksum += image_get_header_size ();
227
228        /* check the size does not exceed space in flash. HUSH scripts */
229        if ((ausize[idx] != 0) && (ausize[idx] < checksum)) {
230                printf ("Image %s is bigger than FLASH\n", aufile[idx]);
231                ausize[idx] = 0;
232                return -1;
233        }
234        /* Update with the real filesize */
235        ausize[idx] = fsize;
236
237        return checksum; /* return size to be written to flash */
238}
239
240int au_do_update(int idx, long sz)
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;
249#if defined(CONFIG_FIT)
250        if (genimg_get_format ((void *)hdr) != IMAGE_FORMAT_LEGACY) {
251                puts ("Non legacy image format not supported\n");
252                return -1;
253        }
254#endif
255
256        /* execute a script */
257        if (image_check_type (hdr, IH_TYPE_SCRIPT)) {
258                addr = (char *)((char *)hdr + image_get_header_size ());
259                /* stick a NULL at the end of the script, otherwise */
260                /* parse_string_outer() runs off the end. */
261                addr[image_get_data_size (hdr)] = 0;
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);
288#ifdef CONFIG_PROGRESSBAR
289        show_progress(end - start, totsize);
290#endif
291
292        /* strip the header - except for the kernel and ramdisk */
293        if (image_check_type (hdr, IH_TYPE_KERNEL) ||
294                        image_check_type (hdr, IH_TYPE_RAMDISK)) {
295                addr = (char *)hdr;
296                off = image_get_header_size ();
297                nbytes = image_get_image_size (hdr);
298        } else {
299                addr = (char *)((char *)hdr + image_get_header_size ());
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;
306                nbytes = image_get_data_size (hdr);
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
317#ifdef CONFIG_PROGRESSBAR
318        show_progress(nbytes, totsize);
319#endif
320
321        /* check the data CRC of the copy */
322        if (crc32 (0, (uchar *)(start + off), image_get_data_size (hdr)) !=
323            image_get_dcrc (hdr)) {
324                printf ("Image %s Bad Data Checksum after COPY\n", aufile[idx]);
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
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 */
340int do_auto_update(void)
341{
342        block_dev_desc_t *stor_dev;
343        long sz;
344        int i, res = 0, bitmap_first, cnt, old_ctrlc, got_ctrlc;
345        char *env;
346        long start, end;
347
348#if 0 /* disable key-press detection to speed up boot-up time */
349        uchar keypad_status1[2] = {0,0}, keypad_status2[2] = {0,0};
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         */
361        if ( !(keypad_status1[1] & KEYPAD_MASK_LO) ||
362              (keypad_status1[1] != keypad_status2[1])) {
363                return 0;
364        }
365
366#endif
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");
384                res = -1;
385                goto xit;
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");
391                res = -1;
392                goto xit;
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);
397                res = -1;
398                goto xit;
399        }
400        if (file_fat_detectfs() != 0) {
401                debug ("file_fat_detectfs failed\n");
402        }
403
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;
418                aufl_layout[IDX_FIRMWARE].start = start;
419                aufl_layout[IDX_FIRMWARE].end = end;
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;
431                aufl_layout[IDX_KERNEL].start = start;
432                aufl_layout[IDX_KERNEL].end = end;
433        }
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
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;
454
455        /* validate the images first */
456        for (i = 0; i < AU_MAXFILES; i++) {
457                ulong imsize;
458                /* just read the header */
459                sz = file_fat_read(aufile[i], LOAD_ADDR, image_get_header_size ());
460                debug ("read %s sz %ld hdr %d\n",
461                        aufile[i], sz, image_get_header_size ());
462                if (sz <= 0 || sz < image_get_header_size ()) {
463                        debug ("%s not found\n", aufile[i]);
464                        ausize[i] = 0;
465                        continue;
466                }
467                /* au_check_header_valid() updates ausize[] */
468                if ((imsize = au_check_header_valid(i, sz)) < 0) {
469                        debug ("%s header not valid\n", aufile[i]);
470                        continue;
471                }
472                /* totsize accounts for image size and flash erase size */
473                totsize += (imsize + (aufl_layout[i].end - aufl_layout[i].start));
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
490                debug ("read %s sz %ld hdr %d\n",
491                        aufile[i], sz, image_get_header_size ());
492
493                if (sz != ausize[i]) {
494                        printf ("%s: size %ld read %ld?\n", aufile[i], ausize[i], sz);
495                        continue;
496                }
497
498                if (sz <= 0 || sz <= image_get_header_size ()) {
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
521                } while (res < 0 && cnt < (AU_MAXFILES + 1));
522                if (cnt < (AU_MAXFILES + 1))
523#else
524                } while (res < 0);
525#endif
526        }
527
528        /* restore the old state */
529        disable_ctrlc(old_ctrlc);
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
540 xit:
541        usb_stop();
542        return res;
543}
544#endif /* CONFIG_AUTO_UPDATE */
Note: See TracBrowser for help on using the repository browser.