Merge branch 'u-boot-ti/master' into 'u-boot-arm/master'
[karo-tx-uboot.git] / board / ait / cam_enc_4xx / cam_enc_4xx.c
1 /*
2  * Copyright (C) 2009 Texas Instruments Incorporated
3  *
4  * Copyright (C) 2011
5  * Heiko Schocher, DENX Software Engineering, hs@denx.de.
6  *
7  * SPDX-License-Identifier:     GPL-2.0+
8  */
9
10 #include <common.h>
11 #include <cli.h>
12 #include <errno.h>
13 #include <linux/mtd/nand.h>
14 #include <nand.h>
15 #include <miiphy.h>
16 #include <netdev.h>
17 #include <asm/io.h>
18 #include <asm/arch/hardware.h>
19 #include <asm/ti-common/davinci_nand.h>
20 #include <asm/arch/davinci_misc.h>
21 #ifdef CONFIG_DAVINCI_MMC
22 #include <mmc.h>
23 #include <asm/arch/sdmmc_defs.h>
24 #endif
25
26 DECLARE_GLOBAL_DATA_PTR;
27
28 #ifndef CONFIG_SPL_BUILD
29 static struct davinci_timer *timer =
30         (struct davinci_timer *)DAVINCI_TIMER3_BASE;
31
32 static unsigned long get_timer_val(void)
33 {
34         unsigned long now = readl(&timer->tim34);
35
36         return now;
37 }
38
39 static int timer_running(void)
40 {
41         return readl(&timer->tcr) &
42                 (DV_TIMER_TCR_ENAMODE_MASK << DV_TIMER_TCR_ENAMODE34_SHIFT);
43 }
44
45 static void stop_timer(void)
46 {
47         writel(0x0, &timer->tcr);
48         return;
49 }
50
51 int checkboard(void)
52 {
53         printf("Board: AIT CAM ENC 4XX\n");
54         return 0;
55 }
56
57 int board_init(void)
58 {
59         gd->bd->bi_boot_params = PHYS_SDRAM_1 + 0x100;
60
61         return 0;
62 }
63
64 #ifdef CONFIG_DRIVER_TI_EMAC
65 static int cam_enc_4xx_check_network(void)
66 {
67         char *s;
68
69         s = getenv("ethaddr");
70         if (!s)
71                 return -EINVAL;
72
73         if (!is_valid_ether_addr((const u8 *)s))
74                 return -EINVAL;
75
76         s = getenv("ipaddr");
77         if (!s)
78                 return -EINVAL;
79
80         s = getenv("netmask");
81         if (!s)
82                 return -EINVAL;
83
84         s = getenv("serverip");
85         if (!s)
86                 return -EINVAL;
87
88         s = getenv("gatewayip");
89         if (!s)
90                 return -EINVAL;
91
92         return 0;
93 }
94 int board_eth_init(bd_t *bis)
95 {
96         int ret;
97
98         ret = cam_enc_4xx_check_network();
99         if (ret)
100                 return ret;
101
102         davinci_emac_initialize();
103
104         return 0;
105 }
106 #endif
107
108 #ifdef CONFIG_NAND_DAVINCI
109 static int
110 davinci_std_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
111                                    uint8_t *buf, int oob_required, int page)
112 {
113         struct nand_chip *this = mtd->priv;
114         int i, eccsize = chip->ecc.size;
115         int eccbytes = chip->ecc.bytes;
116         int eccsteps = chip->ecc.steps;
117         uint8_t *p = buf;
118         uint8_t *oob = chip->oob_poi;
119
120         chip->cmdfunc(mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
121
122         chip->read_buf(mtd, oob, mtd->oobsize);
123
124         chip->cmdfunc(mtd, NAND_CMD_READ0, 0x0, page & this->pagemask);
125
126
127         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
128                 int stat;
129
130                 chip->ecc.hwctl(mtd, NAND_ECC_READ);
131                 chip->read_buf(mtd, p, eccsize);
132                 chip->ecc.hwctl(mtd, NAND_ECC_READSYN);
133
134                 if (chip->ecc.prepad)
135                         oob += chip->ecc.prepad;
136
137                 stat = chip->ecc.correct(mtd, p, oob, NULL);
138
139                 if (stat == -1)
140                         mtd->ecc_stats.failed++;
141                 else
142                         mtd->ecc_stats.corrected += stat;
143
144                 oob += eccbytes;
145
146                 if (chip->ecc.postpad)
147                         oob += chip->ecc.postpad;
148         }
149
150         /* Calculate remaining oob bytes */
151         i = mtd->oobsize - (oob - chip->oob_poi);
152         if (i)
153                 chip->read_buf(mtd, oob, i);
154
155         return 0;
156 }
157
158 static int davinci_std_write_page_syndrome(struct mtd_info *mtd,
159                                     struct nand_chip *chip, const uint8_t *buf,
160                                     int oob_required)
161 {
162         unsigned char davinci_ecc_buf[NAND_MAX_OOBSIZE];
163         struct nand_chip *this = mtd->priv;
164         int i, eccsize = chip->ecc.size;
165         int eccbytes = chip->ecc.bytes;
166         int eccsteps = chip->ecc.steps;
167         int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
168         int offset = 0;
169         const uint8_t *p = buf;
170         uint8_t *oob = chip->oob_poi;
171
172         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
173                 chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
174                 chip->write_buf(mtd, p, eccsize);
175
176                 /* Calculate ECC without prepad */
177                 chip->ecc.calculate(mtd, p, oob + chip->ecc.prepad);
178
179                 if (chip->ecc.prepad) {
180                         offset = (chip->ecc.steps - eccsteps) * chunk;
181                         memcpy(&davinci_ecc_buf[offset], oob, chip->ecc.prepad);
182                         oob += chip->ecc.prepad;
183                 }
184
185                 offset = ((chip->ecc.steps - eccsteps) * chunk) +
186                                 chip->ecc.prepad;
187                 memcpy(&davinci_ecc_buf[offset], oob, eccbytes);
188                 oob += eccbytes;
189
190                 if (chip->ecc.postpad) {
191                         offset = ((chip->ecc.steps - eccsteps) * chunk) +
192                                         chip->ecc.prepad + eccbytes;
193                         memcpy(&davinci_ecc_buf[offset], oob,
194                                 chip->ecc.postpad);
195                         oob += chip->ecc.postpad;
196                 }
197         }
198
199         /*
200          * Write the sparebytes into the page once
201          * all eccsteps have been covered
202          */
203         for (i = 0; i < mtd->oobsize; i++)
204                 writeb(davinci_ecc_buf[i], this->IO_ADDR_W);
205
206         /* Calculate remaining oob bytes */
207         i = mtd->oobsize - (oob - chip->oob_poi);
208         if (i)
209                 chip->write_buf(mtd, oob, i);
210         return 0;
211 }
212
213 static int davinci_std_write_oob_syndrome(struct mtd_info *mtd,
214                                    struct nand_chip *chip, int page)
215 {
216         int pos, status = 0;
217         const uint8_t *bufpoi = chip->oob_poi;
218
219         pos = mtd->writesize;
220
221         chip->cmdfunc(mtd, NAND_CMD_SEQIN, pos, page);
222
223         chip->write_buf(mtd, bufpoi, mtd->oobsize);
224
225         chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
226         status = chip->waitfunc(mtd, chip);
227
228         return status & NAND_STATUS_FAIL ? -1 : 0;
229 }
230
231 static int davinci_std_read_oob_syndrome(struct mtd_info *mtd,
232         struct nand_chip *chip, int page)
233 {
234         struct nand_chip *this = mtd->priv;
235         uint8_t *buf = chip->oob_poi;
236         uint8_t *bufpoi = buf;
237
238         chip->cmdfunc(mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
239
240         chip->read_buf(mtd, bufpoi, mtd->oobsize);
241
242         return 0;
243 }
244
245 static void nand_dm365evm_select_chip(struct mtd_info *mtd, int chip)
246 {
247         struct nand_chip        *this = mtd->priv;
248         unsigned long           wbase = (unsigned long) this->IO_ADDR_W;
249         unsigned long           rbase = (unsigned long) this->IO_ADDR_R;
250
251         if (chip == 1) {
252                 __set_bit(14, &wbase);
253                 __set_bit(14, &rbase);
254         } else {
255                 __clear_bit(14, &wbase);
256                 __clear_bit(14, &rbase);
257         }
258         this->IO_ADDR_W = (void *)wbase;
259         this->IO_ADDR_R = (void *)rbase;
260 }
261
262 int board_nand_init(struct nand_chip *nand)
263 {
264         davinci_nand_init(nand);
265         nand->select_chip = nand_dm365evm_select_chip;
266
267         return 0;
268 }
269
270 struct nand_ecc_ctrl org_ecc;
271 static int notsaved = 1;
272
273 static int nand_switch_hw_func(int mode)
274 {
275         struct nand_chip *nand;
276         struct mtd_info *mtd;
277
278         if (nand_curr_device < 0 ||
279             nand_curr_device >= CONFIG_SYS_MAX_NAND_DEVICE ||
280             !nand_info[nand_curr_device].name) {
281                 printf("Error: Can't switch hw functions," \
282                         " no devices available\n");
283                 return -1;
284         }
285
286         mtd = &nand_info[nand_curr_device];
287         nand = mtd->priv;
288
289         if (mode == 0) {
290                 if (notsaved == 0) {
291                         printf("switching to uboot hw functions.\n");
292                         memcpy(&nand->ecc, &org_ecc,
293                                 sizeof(struct nand_ecc_ctrl));
294                 }
295         } else {
296                 /* RBL */
297                 printf("switching to RBL hw functions.\n");
298                 if (notsaved == 1) {
299                         memcpy(&org_ecc, &nand->ecc,
300                                 sizeof(struct nand_ecc_ctrl));
301                         notsaved = 0;
302                 }
303                 nand->ecc.mode = NAND_ECC_HW_SYNDROME;
304                 nand->ecc.prepad = 6;
305                 nand->ecc.read_page = davinci_std_read_page_syndrome;
306                 nand->ecc.write_page = davinci_std_write_page_syndrome;
307                 nand->ecc.read_oob = davinci_std_read_oob_syndrome;
308                 nand->ecc.write_oob = davinci_std_write_oob_syndrome;
309         }
310         return mode;
311 }
312
313 static int hwmode;
314
315 static int do_switch_ecc(cmd_tbl_t *cmdtp, int flag, int argc,
316                 char *const argv[])
317 {
318         if (argc != 2)
319                 goto usage;
320         if (strncmp(argv[1], "rbl", 2) == 0)
321                 hwmode = nand_switch_hw_func(1);
322         else if (strncmp(argv[1], "uboot", 2) == 0)
323                 hwmode = nand_switch_hw_func(0);
324         else
325                 goto usage;
326
327         return 0;
328
329 usage:
330         printf("Usage: nandrbl %s\n", cmdtp->usage);
331         return 1;
332 }
333
334 U_BOOT_CMD(
335         nandrbl, 2, 1,  do_switch_ecc,
336         "switch between rbl/uboot NAND ECC calculation algorithm",
337         "[rbl/uboot] - Switch between rbl/uboot NAND ECC algorithm"
338 );
339
340
341 #endif /* #ifdef CONFIG_NAND_DAVINCI */
342
343 #ifdef CONFIG_DAVINCI_MMC
344 static struct davinci_mmc mmc_sd0 = {
345         .reg_base       = (struct davinci_mmc_regs *)DAVINCI_MMC_SD0_BASE,
346         .input_clk      = 121500000,
347         .host_caps      = MMC_MODE_4BIT,
348         .voltages       = MMC_VDD_32_33 | MMC_VDD_33_34,
349         .version        = MMC_CTLR_VERSION_2,
350 };
351
352 int board_mmc_init(bd_t *bis)
353 {
354         int err;
355
356         /* Add slot-0 to mmc subsystem */
357         err = davinci_mmc_init(bis, &mmc_sd0);
358
359         return err;
360 }
361 #endif
362
363 int board_late_init(void)
364 {
365         struct davinci_gpio *gpio = davinci_gpio_bank45;
366
367         /* 24MHz InputClock / 15 prediv -> 1.6 MHz timer running */
368         while ((get_timer_val() < CONFIG_AIT_TIMER_TIMEOUT) &&
369                 timer_running())
370                 ;
371
372         /* 1 sec reached -> stop timer, clear all LED */
373         stop_timer();
374         clrbits_le32(&gpio->out_data, CONFIG_CAM_ENC_LED_MASK);
375         return 0;
376 }
377
378 void reset_phy(void)
379 {
380         char *name = "GENERIC @ 0x00";
381
382         /* reset the phy */
383         miiphy_reset(name, 0x0);
384 }
385
386 #else /* #ifndef CONFIG_SPL_BUILD */
387 static void cam_enc_4xx_set_all_led(void)
388 {
389         struct davinci_gpio *gpio = davinci_gpio_bank45;
390
391         setbits_le32(&gpio->out_data, CONFIG_CAM_ENC_LED_MASK);
392 }
393
394 /*
395  * TIMER 0 is used for tick
396  */
397 static struct davinci_timer *timer =
398         (struct davinci_timer *)DAVINCI_TIMER3_BASE;
399
400 #define TIMER_LOAD_VAL  0xffffffff
401 #define TIM_CLK_DIV     16
402
403 static int cam_enc_4xx_timer_init(void)
404 {
405         /* We are using timer34 in unchained 32-bit mode, full speed */
406         writel(0x0, &timer->tcr);
407         writel(0x0, &timer->tgcr);
408         writel(0x06 | ((TIM_CLK_DIV - 1) << 8), &timer->tgcr);
409         writel(0x0, &timer->tim34);
410         writel(TIMER_LOAD_VAL, &timer->prd34);
411         writel(2 << 22, &timer->tcr);
412         return 0;
413 }
414
415 void board_gpio_init(void)
416 {
417         struct davinci_gpio *gpio;
418
419         cam_enc_4xx_set_all_led();
420         cam_enc_4xx_timer_init();
421         gpio = davinci_gpio_bank01;
422         clrbits_le32(&gpio->dir, ~0xfdfffffe);
423         /* clear LED D14 = GPIO25 */
424         clrbits_le32(&gpio->out_data, 0x02000000);
425         gpio = davinci_gpio_bank23;
426         clrbits_le32(&gpio->dir, ~0x5ff0afef);
427         /* set GPIO61 to 1 -> intern UART0 as Console */
428         setbits_le32(&gpio->out_data, 0x20000000);
429         /*
430          * PHY out of reset GIO 50 = 1
431          * NAND WP off GIO 51 = 1
432          */
433         setbits_le32(&gpio->out_data, 0x000c0004);
434         gpio = davinci_gpio_bank45;
435         clrbits_le32(&gpio->dir, ~(0xdb2fffff) | CONFIG_CAM_ENC_LED_MASK);
436         /*
437          * clear LED:
438          * D17 = GPIO86
439          * D11 = GPIO87
440          * GPIO88
441          * GPIO89
442          * D13 = GPIO90
443          * GPIO91
444          */
445         clrbits_le32(&gpio->out_data, CONFIG_CAM_ENC_LED_MASK);
446         gpio = davinci_gpio_bank67;
447         clrbits_le32(&gpio->dir, ~0x000007ff);
448 }
449
450 /*
451  * functions for the post memory test.
452  */
453 int arch_memory_test_prepare(u32 *vstart, u32 *size, phys_addr_t *phys_offset)
454 {
455         *vstart = CONFIG_SYS_SDRAM_BASE;
456         *size = PHYS_SDRAM_1_SIZE;
457         *phys_offset = 0;
458         return 0;
459 }
460
461 void arch_memory_failure_handle(void)
462 {
463         cam_enc_4xx_set_all_led();
464         puts("mem failure\n");
465         while (1)
466                 ;
467 }
468 #endif
469 #if defined(CONFIG_MENU)
470 #include "menu.h"
471
472 #define MENU_EXIT               -1
473 #define MENU_EXIT_BOOTCMD       -2
474 #define MENU_STAY               0
475 #define MENU_MAIN               1
476 #define MENU_UPDATE             2
477 #define MENU_NETWORK            3
478 #define MENU_LOAD               4
479
480 static int menu_start;
481
482 #define FIT_SUBTYPE_UNKNOWN             0
483 #define FIT_SUBTYPE_UBL_HEADER          1
484 #define FIT_SUBTYPE_SPL_IMAGE           2
485 #define FIT_SUBTYPE_UBOOT_IMAGE         3
486 #define FIT_SUBTYPE_DF_ENV_IMAGE        4
487 #define FIT_SUBTYPE_RAMDISK_IMAGE       5
488
489 struct fit_images_info {
490         u_int8_t type;
491         int subtype;
492         char desc[200];
493         const void *data;
494         size_t size;
495 };
496
497 static struct fit_images_info imgs[10];
498
499 struct menu_display {
500         char    title[50];
501         int     timeout; /* in sec */
502         int     id; /* MENU_* */
503         char    **menulist;
504         int (*menu_evaluate)(char *choice);
505 };
506
507 char *menu_main[] = {
508         "(1) Boot",
509         "(2) Update Software",
510         "(3) Reset to default setting and boot",
511         "(4) Enter U-Boot console",
512         NULL
513 };
514
515 char *menu_update[] = {
516         "(1) Network settings",
517         "(2) load image",
518         "(3) back to main",
519         NULL
520 };
521
522 char *menu_load[] = {
523         "(1) install image",
524         "(2) cancel",
525         NULL
526 };
527
528 char *menu_network[] = {
529         "(1) ipaddr   ",
530         "(2) netmask  ",
531         "(3) serverip ",
532         "(4) gatewayip",
533         "(5) tftp image name",
534         "(6) back to update software",
535         NULL
536 };
537
538 static void ait_menu_print(void *data)
539 {
540         printf("%s\n", (char *)data);
541         return;
542 }
543
544 static char *menu_handle(struct menu_display *display)
545 {
546         struct menu *m;
547         int i;
548         void *choice = NULL;
549         char key[2];
550         int ret;
551         char *s;
552         char temp[6][200];
553
554         m = menu_create(display->title, display->timeout, 1, ait_menu_print,
555                         NULL, NULL);
556
557         for (i = 0; display->menulist[i]; i++) {
558                 sprintf(key, "%d", i + 1);
559                 if (display->id == MENU_NETWORK) {
560                         switch (i) {
561                         case 0:
562                                 s = getenv("ipaddr");
563                                 break;
564                         case 1:
565                                 s = getenv("netmask");
566                                 break;
567                         case 2:
568                                 s = getenv("serverip");
569                                 break;
570                         case 3:
571                                 s = getenv("gatewayip");
572                                 break;
573                         case 4:
574                                 s = getenv("img_file");
575                                 break;
576                         default:
577                                 s = NULL;
578                                 break;
579                         }
580                         if (s) {
581                                 sprintf(temp[i], "%s: %s",
582                                         display->menulist[i], s);
583                                 ret = menu_item_add(m, key, temp[i]);
584                         } else {
585                                 ret = menu_item_add(m, key,
586                                         display->menulist[i]);
587                         }
588                 } else {
589                         ret = menu_item_add(m, key, display->menulist[i]);
590                 }
591
592                 if (ret != 1) {
593                         printf("failed to add item!");
594                         menu_destroy(m);
595                         return NULL;
596                 }
597         }
598         sprintf(key, "%d", 1);
599         menu_default_set(m, key);
600
601         if (menu_get_choice(m, &choice) != 1)
602                 debug("Problem picking a choice!\n");
603
604         menu_destroy(m);
605
606         return choice;
607 }
608
609 static int ait_menu_show(struct menu_display *display, int bootdelay)
610 {
611         int end = MENU_STAY;
612         char *choice;
613
614         if ((menu_start == 0) && (display->id == MENU_MAIN))
615                 display->timeout = bootdelay;
616         else
617                 display->timeout = 0;
618
619         while (end == MENU_STAY) {
620                 choice = menu_handle(display);
621                 if (choice)
622                         end = display->menu_evaluate(choice);
623
624                 if (end == display->id)
625                         end = MENU_STAY;
626                 if (display->id == MENU_MAIN) {
627                         if (menu_start == 0)
628                                 end = MENU_EXIT_BOOTCMD;
629                         else
630                                 display->timeout = 0;
631                 }
632         }
633         return end;
634 }
635
636 static int ait_writeublheader(void)
637 {
638         char s[20];
639         unsigned long i;
640         int ret;
641
642         for (i = CONFIG_SYS_NAND_BLOCK_SIZE;
643                 i < CONFIG_SYS_NAND_U_BOOT_OFFS;
644                 i += CONFIG_SYS_NAND_BLOCK_SIZE) {
645                 sprintf(s, "%lx", i);
646                 ret = setenv("header_addr", s);
647                 if (ret == 0)
648                         ret = run_command("run img_writeheader", 0);
649                 if (ret != 0)
650                         break;
651         }
652         return ret;
653 }
654
655 static int ait_menu_install_images(void)
656 {
657         int ret = 0;
658         int count = 0;
659         char s[100];
660         char *t;
661
662         /*
663          * possible image types:
664          * FIT_SUBTYPE_UNKNOWN
665          * FIT_SUBTYPE_UBL_HEADER
666          * FIT_SUBTYPE_SPL_IMAGE
667          * FIT_SUBTYPE_UBOOT_IMAGE
668          * FIT_SUBTYPE_DF_ENV_IMAGE
669          * FIT_SUBTYPE_RAMDISK_IMAGE
670          *
671          * use Envvariables:
672          * img_addr_r: image start addr
673          * header_addr: addr where to write to UBL header
674          * img_writeheader: write ubl header to nand
675          * img_writespl: write spl to nand
676          * img_writeuboot: write uboot to nand
677          * img_writedfenv: write default environment to ubi volume
678          * img_volume: which ubi volume should be updated with img_writeramdisk
679          * filesize: size of data for updating ubi volume
680          * img_writeramdisk: write ramdisk to ubi volume
681          */
682
683         while (imgs[count].type != IH_TYPE_INVALID) {
684                 printf("Installing %s\n",
685                         genimg_get_type_name(imgs[count].type));
686                 sprintf(s, "%p", imgs[count].data);
687                 setenv("img_addr_r", s);
688                 sprintf(s, "%lx", (unsigned long)imgs[count].size);
689                 setenv("filesize", s);
690                 switch (imgs[count].subtype) {
691                 case FIT_SUBTYPE_DF_ENV_IMAGE:
692                         ret = run_command("run img_writedfenv", 0);
693                         break;
694                 case FIT_SUBTYPE_RAMDISK_IMAGE:
695                         t = getenv("img_volume");
696                         if (!t) {
697                                 ret = setenv("img_volume", "rootfs1");
698                         } else {
699                                 /* switch to other volume */
700                                 if (strncmp(t, "rootfs1", 7) == 0)
701                                         ret = setenv("img_volume", "rootfs2");
702                                 else
703                                         ret = setenv("img_volume", "rootfs1");
704                         }
705                         if (ret != 0)
706                                 break;
707
708                         ret = run_command("run img_writeramdisk", 0);
709                         break;
710                 case FIT_SUBTYPE_SPL_IMAGE:
711                         ret = run_command("run img_writespl", 0);
712                         break;
713                 case FIT_SUBTYPE_UBL_HEADER:
714                         ret = ait_writeublheader();
715                         break;
716                 case FIT_SUBTYPE_UBOOT_IMAGE:
717                         ret = run_command("run img_writeuboot", 0);
718                         break;
719                 default:
720                         /* not supported type */
721                         break;
722                 }
723                 count++;
724         }
725         /* now save dvn_* and img_volume env vars to new values */
726         if (ret == 0) {
727                 t = getenv("x_dvn_boot_vers");
728                 if (t)
729                         setenv("dvn_boot_vers", t);
730
731                 t = getenv("x_dvn_app_vers");
732                 if (t)
733                         setenv("dvn_boot_vers", t);
734
735                 setenv("x_dvn_boot_vers", NULL);
736                 setenv("x_dvn_app_vers", NULL);
737                 ret = run_command("run savenewvers", 0);
738         }
739
740         return ret;
741 }
742
743 static int ait_menu_evaluate_load(char *choice)
744 {
745         if (!choice)
746                 return -1;
747
748         switch (choice[1]) {
749         case '1':
750                 /* install image */
751                 ait_menu_install_images();
752                 break;
753         case '2':
754                 /* cancel, back to main */
755                 setenv("x_dvn_boot_vers", NULL);
756                 setenv("x_dvn_app_vers", NULL);
757                 break;
758         }
759
760         return MENU_MAIN;
761 }
762
763 struct menu_display ait_load = {
764         .title = "AIT load image",
765         .timeout = 0,
766         .id = MENU_LOAD,
767         .menulist = menu_load,
768         .menu_evaluate = ait_menu_evaluate_load,
769 };
770
771 static void ait_menu_read_env(char *name)
772 {
773         char output[CONFIG_SYS_CBSIZE];
774         char cbuf[CONFIG_SYS_CBSIZE];
775         int readret;
776         int ret;
777
778         sprintf(output, "%s old: %s value: ", name, getenv(name));
779         memset(cbuf, 0, CONFIG_SYS_CBSIZE);
780         readret = cli_readline_into_buffer(output, cbuf, 0);
781
782         if (readret >= 0) {
783                 ret = setenv(name, cbuf);
784                 if (ret) {
785                         printf("Error setting %s\n", name);
786                         return;
787                 }
788         }
789         return;
790 }
791
792 static int ait_menu_evaluate_network(char *choice)
793 {
794         if (!choice)
795                 return MENU_MAIN;
796
797         switch (choice[1]) {
798         case '1':
799                 ait_menu_read_env("ipaddr");
800                 break;
801         case '2':
802                 ait_menu_read_env("netmask");
803                 break;
804         case '3':
805                 ait_menu_read_env("serverip");
806                 break;
807         case '4':
808                 ait_menu_read_env("gatewayip");
809                 break;
810         case '5':
811                 ait_menu_read_env("img_file");
812                 break;
813         case '6':
814                 return MENU_UPDATE;
815                 break;
816         }
817
818         return MENU_STAY;
819 }
820
821 struct menu_display ait_network = {
822         .title = "AIT network settings",
823         .timeout = 0,
824         .id = MENU_NETWORK,
825         .menulist = menu_network,
826         .menu_evaluate = ait_menu_evaluate_network,
827 };
828
829 static int fit_get_subtype(const void *fit, int noffset, char **subtype)
830 {
831         int len;
832
833         *subtype = (char *)fdt_getprop(fit, noffset, "subtype", &len);
834         if (*subtype == NULL)
835                 return -1;
836
837         return 0;
838 }
839
840 static int ait_subtype_nr(char *subtype)
841 {
842         int ret = FIT_SUBTYPE_UNKNOWN;
843
844         if (!strncmp("ublheader", subtype, strlen("ublheader")))
845                 return FIT_SUBTYPE_UBL_HEADER;
846         if (!strncmp("splimage", subtype, strlen("splimage")))
847                 return FIT_SUBTYPE_SPL_IMAGE;
848         if (!strncmp("ubootimage", subtype, strlen("ubootimage")))
849                 return FIT_SUBTYPE_UBOOT_IMAGE;
850         if (!strncmp("dfenvimage", subtype, strlen("dfenvimage")))
851                 return FIT_SUBTYPE_DF_ENV_IMAGE;
852
853         return ret;
854 }
855
856 static int ait_menu_check_image(void)
857 {
858         char *s;
859         unsigned long fit_addr;
860         void *addr;
861         int format;
862         char *desc;
863         char *subtype;
864         int images_noffset;
865         int noffset;
866         int ndepth;
867         int count = 0;
868         int ret;
869         int i;
870         int found_uboot = -1;
871         int found_ramdisk = -1;
872
873         memset(imgs, 0, sizeof(imgs));
874         s = getenv("fit_addr_r");
875         fit_addr = s ? (unsigned long)simple_strtol(s, NULL, 16) : \
876                         CONFIG_BOARD_IMG_ADDR_R;
877
878         addr = (void *)fit_addr;
879         /* check if it is a FIT image */
880         format = genimg_get_format(addr);
881         if (format != IMAGE_FORMAT_FIT)
882                 return -EINVAL;
883
884         if (!fit_check_format(addr))
885                 return -EINVAL;
886
887         /* print the FIT description */
888         ret = fit_get_desc(addr, 0, &desc);
889         printf("FIT description: ");
890         if (ret)
891                 printf("unavailable\n");
892         else
893                 printf("%s\n", desc);
894
895         /* find images */
896         images_noffset = fdt_path_offset(addr, FIT_IMAGES_PATH);
897         if (images_noffset < 0) {
898                 printf("Can't find images parent node '%s' (%s)\n",
899                         FIT_IMAGES_PATH, fdt_strerror(images_noffset));
900                 return -EINVAL;
901         }
902
903         /* Process its subnodes, print out component images details */
904         for (ndepth = 0, count = 0,
905                 noffset = fdt_next_node(addr, images_noffset, &ndepth);
906                 (noffset >= 0) && (ndepth > 0);
907                 noffset = fdt_next_node(addr, noffset, &ndepth)) {
908                 if (ndepth == 1) {
909                         /*
910                          * Direct child node of the images parent node,
911                          * i.e. component image node.
912                          */
913                         printf("Image %u (%s)\n", count,
914                                         fit_get_name(addr, noffset, NULL));
915
916                         fit_image_print(addr, noffset, "");
917
918                         fit_image_get_type(addr, noffset,
919                                 &imgs[count].type);
920                         /* Mandatory properties */
921                         ret = fit_get_desc(addr, noffset, &desc);
922                         printf("Description:  ");
923                         if (ret)
924                                 printf("unavailable\n");
925                         else
926                                 printf("%s\n", desc);
927
928                         ret = fit_get_subtype(addr, noffset, &subtype);
929                         printf("Subtype:  ");
930                         if (ret) {
931                                 printf("unavailable\n");
932                         } else {
933                                 imgs[count].subtype = ait_subtype_nr(subtype);
934                                 printf("%s %d\n", subtype,
935                                         imgs[count].subtype);
936                         }
937
938                         sprintf(imgs[count].desc, "%s", desc);
939
940                         ret = fit_image_get_data(addr, noffset,
941                                 &imgs[count].data,
942                                 &imgs[count].size);
943
944                         printf("Data Size:    ");
945                         if (ret)
946                                 printf("unavailable\n");
947                         else
948                                 genimg_print_size(imgs[count].size);
949                         printf("Data @ %p\n", imgs[count].data);
950                         count++;
951                 }
952         }
953
954         for (i = 0; i < count; i++) {
955                 if (imgs[i].subtype == FIT_SUBTYPE_UBOOT_IMAGE)
956                         found_uboot = i;
957                 if (imgs[i].type == IH_TYPE_RAMDISK) {
958                         found_ramdisk = i;
959                         imgs[i].subtype = FIT_SUBTYPE_RAMDISK_IMAGE;
960                 }
961         }
962
963         /* dvn_* env var update, if the FIT descriptors are different */
964         if (found_uboot >= 0) {
965                 s = getenv("dvn_boot_vers");
966                 if (s) {
967                         ret = strcmp(s, imgs[found_uboot].desc);
968                         if (ret != 0) {
969                                 setenv("x_dvn_boot_vers",
970                                         imgs[found_uboot].desc);
971                         } else {
972                                 found_uboot = -1;
973                                 printf("no new uboot version\n");
974                         }
975                 } else {
976                         setenv("dvn_boot_vers", imgs[found_uboot].desc);
977                 }
978         }
979         if (found_ramdisk >= 0) {
980                 s = getenv("dvn_app_vers");
981                 if (s) {
982                         ret = strcmp(s, imgs[found_ramdisk].desc);
983                         if (ret != 0) {
984                                 setenv("x_dvn_app_vers",
985                                         imgs[found_ramdisk].desc);
986                         } else {
987                                 found_ramdisk = -1;
988                                 printf("no new ramdisk version\n");
989                         }
990                 } else {
991                         setenv("dvn_app_vers", imgs[found_ramdisk].desc);
992                 }
993         }
994         if ((found_uboot == -1) && (found_ramdisk == -1))
995                 return -EINVAL;
996
997         return 0;
998 }
999
1000 static int ait_menu_evaluate_update(char *choice)
1001 {
1002         int ret;
1003
1004         if (!choice)
1005                 return MENU_MAIN;
1006
1007         switch (choice[1]) {
1008         case '1':
1009                 return ait_menu_show(&ait_network, 0);
1010                 break;
1011         case '2':
1012                 /* load image */
1013                 ret = run_command("run load_img", 0);
1014                 printf("ret: %d\n", ret);
1015                 if (ret)
1016                         return MENU_UPDATE;
1017
1018                 ret = ait_menu_check_image();
1019                 if (ret)
1020                         return MENU_UPDATE;
1021
1022                 return ait_menu_show(&ait_load, 0);
1023                 break;
1024         case '3':
1025                 return MENU_MAIN;
1026                 break;
1027
1028         }
1029
1030         return MENU_MAIN;
1031 }
1032
1033 struct menu_display ait_update = {
1034         .title = "AIT Update Software",
1035         .timeout = 0,
1036         .id = MENU_UPDATE,
1037         .menulist = menu_update,
1038         .menu_evaluate = ait_menu_evaluate_update,
1039 };
1040
1041 static int ait_menu_evaluate_main(char *choice)
1042 {
1043         if (!choice)
1044                 return MENU_STAY;
1045
1046         menu_start = 1;
1047         switch (choice[1]) {
1048         case '1':
1049                 /* run bootcmd */
1050                 return MENU_EXIT_BOOTCMD;
1051                 break;
1052         case '2':
1053                 return ait_menu_show(&ait_update, 0);
1054                 break;
1055         case '3':
1056                 /* reset to default settings */
1057                 setenv("app_reset", "yes");
1058                 return MENU_EXIT_BOOTCMD;
1059                 break;
1060         case '4':
1061                 /* u-boot shell */
1062                 return MENU_EXIT;
1063                 break;
1064         }
1065
1066         return MENU_EXIT;
1067 }
1068
1069 struct menu_display ait_main = {
1070         .title = "AIT Main",
1071         .timeout = CONFIG_BOOTDELAY,
1072         .id = MENU_MAIN,
1073         .menulist = menu_main,
1074         .menu_evaluate = ait_menu_evaluate_main,
1075 };
1076
1077 int menu_show(int bootdelay)
1078 {
1079         int ret;
1080
1081         run_command("run saveparms", 0);
1082         ret = ait_menu_show(&ait_main, bootdelay);
1083         run_command("run restoreparms", 0);
1084
1085         if (ret == MENU_EXIT_BOOTCMD)
1086                 return 0;
1087
1088         return MENU_EXIT;
1089 }
1090
1091 void menu_display_statusline(struct menu *m)
1092 {
1093         char *s1, *s2;
1094
1095         s1 = getenv("x_dvn_boot_vers");
1096         if (!s1)
1097                 s1 = getenv("dvn_boot_vers");
1098
1099         s2 = getenv("x_dvn_app_vers");
1100         if (!s2)
1101                 s2 = getenv("dvn_app_vers");
1102
1103         printf("State: dvn_boot_vers: %s dvn_app_vers: %s\n", s1, s2);
1104         return;
1105 }
1106 #endif