2 * Copyright (C) 2009 Texas Instruments Incorporated
5 * Heiko Schocher, DENX Software Engineering, hs@denx.de.
7 * SPDX-License-Identifier: GPL-2.0+
13 #include <linux/mtd/nand.h>
18 #include <asm/arch/hardware.h>
19 #include <asm/arch/nand_defs.h>
20 #include <asm/arch/davinci_misc.h>
21 #ifdef CONFIG_DAVINCI_MMC
23 #include <asm/arch/sdmmc_defs.h>
26 DECLARE_GLOBAL_DATA_PTR
;
28 #ifndef CONFIG_SPL_BUILD
29 static struct davinci_timer
*timer
=
30 (struct davinci_timer
*)DAVINCI_TIMER3_BASE
;
32 static unsigned long get_timer_val(void)
34 unsigned long now
= readl(&timer
->tim34
);
39 static int timer_running(void)
41 return readl(&timer
->tcr
) &
42 (DV_TIMER_TCR_ENAMODE_MASK
<< DV_TIMER_TCR_ENAMODE34_SHIFT
);
45 static void stop_timer(void)
47 writel(0x0, &timer
->tcr
);
53 printf("Board: AIT CAM ENC 4XX\n");
59 gd
->bd
->bi_boot_params
= PHYS_SDRAM_1
+ 0x100;
64 #ifdef CONFIG_DRIVER_TI_EMAC
65 static int cam_enc_4xx_check_network(void)
69 s
= getenv("ethaddr");
73 if (!is_valid_ether_addr((const u8
*)s
))
80 s
= getenv("netmask");
84 s
= getenv("serverip");
88 s
= getenv("gatewayip");
94 int board_eth_init(bd_t
*bis
)
98 ret
= cam_enc_4xx_check_network();
102 davinci_emac_initialize();
108 #ifdef CONFIG_NAND_DAVINCI
110 davinci_std_read_page_syndrome(struct mtd_info
*mtd
, struct nand_chip
*chip
,
111 uint8_t *buf
, int oob_required
, int page
)
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
;
118 uint8_t *oob
= chip
->oob_poi
;
120 chip
->cmdfunc(mtd
, NAND_CMD_READOOB
, 0x0, page
& this->pagemask
);
122 chip
->read_buf(mtd
, oob
, mtd
->oobsize
);
124 chip
->cmdfunc(mtd
, NAND_CMD_READ0
, 0x0, page
& this->pagemask
);
127 for (i
= 0; eccsteps
; eccsteps
--, i
+= eccbytes
, p
+= eccsize
) {
130 chip
->ecc
.hwctl(mtd
, NAND_ECC_READ
);
131 chip
->read_buf(mtd
, p
, eccsize
);
132 chip
->ecc
.hwctl(mtd
, NAND_ECC_READSYN
);
134 if (chip
->ecc
.prepad
)
135 oob
+= chip
->ecc
.prepad
;
137 stat
= chip
->ecc
.correct(mtd
, p
, oob
, NULL
);
140 mtd
->ecc_stats
.failed
++;
142 mtd
->ecc_stats
.corrected
+= stat
;
146 if (chip
->ecc
.postpad
)
147 oob
+= chip
->ecc
.postpad
;
150 /* Calculate remaining oob bytes */
151 i
= mtd
->oobsize
- (oob
- chip
->oob_poi
);
153 chip
->read_buf(mtd
, oob
, i
);
158 static int davinci_std_write_page_syndrome(struct mtd_info
*mtd
,
159 struct nand_chip
*chip
, const uint8_t *buf
,
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
;
169 const uint8_t *p
= buf
;
170 uint8_t *oob
= chip
->oob_poi
;
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
);
176 /* Calculate ECC without prepad */
177 chip
->ecc
.calculate(mtd
, p
, oob
+ chip
->ecc
.prepad
);
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
;
185 offset
= ((chip
->ecc
.steps
- eccsteps
) * chunk
) +
187 memcpy(&davinci_ecc_buf
[offset
], oob
, eccbytes
);
190 if (chip
->ecc
.postpad
) {
191 offset
= ((chip
->ecc
.steps
- eccsteps
) * chunk
) +
192 chip
->ecc
.prepad
+ eccbytes
;
193 memcpy(&davinci_ecc_buf
[offset
], oob
,
195 oob
+= chip
->ecc
.postpad
;
200 * Write the sparebytes into the page once
201 * all eccsteps have been covered
203 for (i
= 0; i
< mtd
->oobsize
; i
++)
204 writeb(davinci_ecc_buf
[i
], this->IO_ADDR_W
);
206 /* Calculate remaining oob bytes */
207 i
= mtd
->oobsize
- (oob
- chip
->oob_poi
);
209 chip
->write_buf(mtd
, oob
, i
);
213 static int davinci_std_write_oob_syndrome(struct mtd_info
*mtd
,
214 struct nand_chip
*chip
, int page
)
217 const uint8_t *bufpoi
= chip
->oob_poi
;
219 pos
= mtd
->writesize
;
221 chip
->cmdfunc(mtd
, NAND_CMD_SEQIN
, pos
, page
);
223 chip
->write_buf(mtd
, bufpoi
, mtd
->oobsize
);
225 chip
->cmdfunc(mtd
, NAND_CMD_PAGEPROG
, -1, -1);
226 status
= chip
->waitfunc(mtd
, chip
);
228 return status
& NAND_STATUS_FAIL
? -1 : 0;
231 static int davinci_std_read_oob_syndrome(struct mtd_info
*mtd
,
232 struct nand_chip
*chip
, int page
)
234 struct nand_chip
*this = mtd
->priv
;
235 uint8_t *buf
= chip
->oob_poi
;
236 uint8_t *bufpoi
= buf
;
238 chip
->cmdfunc(mtd
, NAND_CMD_READOOB
, 0x0, page
& this->pagemask
);
240 chip
->read_buf(mtd
, bufpoi
, mtd
->oobsize
);
245 static void nand_dm365evm_select_chip(struct mtd_info
*mtd
, int chip
)
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
;
252 __set_bit(14, &wbase
);
253 __set_bit(14, &rbase
);
255 __clear_bit(14, &wbase
);
256 __clear_bit(14, &rbase
);
258 this->IO_ADDR_W
= (void *)wbase
;
259 this->IO_ADDR_R
= (void *)rbase
;
262 int board_nand_init(struct nand_chip
*nand
)
264 davinci_nand_init(nand
);
265 nand
->select_chip
= nand_dm365evm_select_chip
;
270 struct nand_ecc_ctrl org_ecc
;
271 static int notsaved
= 1;
273 static int nand_switch_hw_func(int mode
)
275 struct nand_chip
*nand
;
276 struct mtd_info
*mtd
;
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");
286 mtd
= &nand_info
[nand_curr_device
];
291 printf("switching to uboot hw functions.\n");
292 memcpy(&nand
->ecc
, &org_ecc
,
293 sizeof(struct nand_ecc_ctrl
));
297 printf("switching to RBL hw functions.\n");
299 memcpy(&org_ecc
, &nand
->ecc
,
300 sizeof(struct nand_ecc_ctrl
));
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
;
315 static int do_switch_ecc(cmd_tbl_t
*cmdtp
, int flag
, int argc
,
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);
330 printf("Usage: nandrbl %s\n", cmdtp
->usage
);
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"
341 #endif /* #ifdef CONFIG_NAND_DAVINCI */
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
,
352 int board_mmc_init(bd_t
*bis
)
356 /* Add slot-0 to mmc subsystem */
357 err
= davinci_mmc_init(bis
, &mmc_sd0
);
363 int board_late_init(void)
365 struct davinci_gpio
*gpio
= davinci_gpio_bank45
;
367 /* 24MHz InputClock / 15 prediv -> 1.6 MHz timer running */
368 while ((get_timer_val() < CONFIG_AIT_TIMER_TIMEOUT
) &&
372 /* 1 sec reached -> stop timer, clear all LED */
374 clrbits_le32(&gpio
->out_data
, CONFIG_CAM_ENC_LED_MASK
);
380 char *name
= "GENERIC @ 0x00";
383 miiphy_reset(name
, 0x0);
386 #else /* #ifndef CONFIG_SPL_BUILD */
387 static void cam_enc_4xx_set_all_led(void)
389 struct davinci_gpio
*gpio
= davinci_gpio_bank45
;
391 setbits_le32(&gpio
->out_data
, CONFIG_CAM_ENC_LED_MASK
);
395 * TIMER 0 is used for tick
397 static struct davinci_timer
*timer
=
398 (struct davinci_timer
*)DAVINCI_TIMER3_BASE
;
400 #define TIMER_LOAD_VAL 0xffffffff
401 #define TIM_CLK_DIV 16
403 static int cam_enc_4xx_timer_init(void)
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
);
415 void board_gpio_init(void)
417 struct davinci_gpio
*gpio
;
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);
430 * PHY out of reset GIO 50 = 1
431 * NAND WP off GIO 51 = 1
433 setbits_le32(&gpio
->out_data
, 0x000c0004);
434 gpio
= davinci_gpio_bank45
;
435 clrbits_le32(&gpio
->dir
, ~(0xdb2fffff) | CONFIG_CAM_ENC_LED_MASK
);
445 clrbits_le32(&gpio
->out_data
, CONFIG_CAM_ENC_LED_MASK
);
446 gpio
= davinci_gpio_bank67
;
447 clrbits_le32(&gpio
->dir
, ~0x000007ff);
451 * functions for the post memory test.
453 int arch_memory_test_prepare(u32
*vstart
, u32
*size
, phys_addr_t
*phys_offset
)
455 *vstart
= CONFIG_SYS_SDRAM_BASE
;
456 *size
= PHYS_SDRAM_1_SIZE
;
461 void arch_memory_failure_handle(void)
463 cam_enc_4xx_set_all_led();
464 puts("mem failure\n");
469 #if defined(CONFIG_MENU)
473 #define MENU_EXIT_BOOTCMD -2
476 #define MENU_UPDATE 2
477 #define MENU_NETWORK 3
480 static int menu_start
;
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
489 struct fit_images_info
{
497 static struct fit_images_info imgs
[10];
499 struct menu_display
{
501 int timeout
; /* in sec */
504 int (*menu_evaluate
)(char *choice
);
507 char *menu_main
[] = {
509 "(2) Update Software",
510 "(3) Reset to default setting and boot",
511 "(4) Enter U-Boot console",
515 char *menu_update
[] = {
516 "(1) Network settings",
522 char *menu_load
[] = {
528 char *menu_network
[] = {
533 "(5) tftp image name",
534 "(6) back to update software",
538 static void ait_menu_print(void *data
)
540 printf("%s\n", (char *)data
);
544 static char *menu_handle(struct menu_display
*display
)
554 m
= menu_create(display
->title
, display
->timeout
, 1, ait_menu_print
,
557 for (i
= 0; display
->menulist
[i
]; i
++) {
558 sprintf(key
, "%d", i
+ 1);
559 if (display
->id
== MENU_NETWORK
) {
562 s
= getenv("ipaddr");
565 s
= getenv("netmask");
568 s
= getenv("serverip");
571 s
= getenv("gatewayip");
574 s
= getenv("img_file");
581 sprintf(temp
[i
], "%s: %s",
582 display
->menulist
[i
], s
);
583 ret
= menu_item_add(m
, key
, temp
[i
]);
585 ret
= menu_item_add(m
, key
,
586 display
->menulist
[i
]);
589 ret
= menu_item_add(m
, key
, display
->menulist
[i
]);
593 printf("failed to add item!");
598 sprintf(key
, "%d", 1);
599 menu_default_set(m
, key
);
601 if (menu_get_choice(m
, &choice
) != 1)
602 debug("Problem picking a choice!\n");
609 static int ait_menu_show(struct menu_display
*display
, int bootdelay
)
614 if ((menu_start
== 0) && (display
->id
== MENU_MAIN
))
615 display
->timeout
= bootdelay
;
617 display
->timeout
= 0;
619 while (end
== MENU_STAY
) {
620 choice
= menu_handle(display
);
622 end
= display
->menu_evaluate(choice
);
624 if (end
== display
->id
)
626 if (display
->id
== MENU_MAIN
) {
628 end
= MENU_EXIT_BOOTCMD
;
630 display
->timeout
= 0;
636 static int ait_writeublheader(void)
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
);
648 ret
= run_command("run img_writeheader", 0);
655 static int ait_menu_install_images(void)
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
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
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);
694 case FIT_SUBTYPE_RAMDISK_IMAGE
:
695 t
= getenv("img_volume");
697 ret
= setenv("img_volume", "rootfs1");
699 /* switch to other volume */
700 if (strncmp(t
, "rootfs1", 7) == 0)
701 ret
= setenv("img_volume", "rootfs2");
703 ret
= setenv("img_volume", "rootfs1");
708 ret
= run_command("run img_writeramdisk", 0);
710 case FIT_SUBTYPE_SPL_IMAGE
:
711 ret
= run_command("run img_writespl", 0);
713 case FIT_SUBTYPE_UBL_HEADER
:
714 ret
= ait_writeublheader();
716 case FIT_SUBTYPE_UBOOT_IMAGE
:
717 ret
= run_command("run img_writeuboot", 0);
720 /* not supported type */
725 /* now save dvn_* and img_volume env vars to new values */
727 t
= getenv("x_dvn_boot_vers");
729 setenv("dvn_boot_vers", t
);
731 t
= getenv("x_dvn_app_vers");
733 setenv("dvn_boot_vers", t
);
735 setenv("x_dvn_boot_vers", NULL
);
736 setenv("x_dvn_app_vers", NULL
);
737 ret
= run_command("run savenewvers", 0);
743 static int ait_menu_evaluate_load(char *choice
)
751 ait_menu_install_images();
754 /* cancel, back to main */
755 setenv("x_dvn_boot_vers", NULL
);
756 setenv("x_dvn_app_vers", NULL
);
763 struct menu_display ait_load
= {
764 .title
= "AIT load image",
767 .menulist
= menu_load
,
768 .menu_evaluate
= ait_menu_evaluate_load
,
771 static void ait_menu_read_env(char *name
)
773 char output
[CONFIG_SYS_CBSIZE
];
774 char cbuf
[CONFIG_SYS_CBSIZE
];
778 sprintf(output
, "%s old: %s value: ", name
, getenv(name
));
779 memset(cbuf
, 0, CONFIG_SYS_CBSIZE
);
780 readret
= readline_into_buffer(output
, cbuf
, 0);
783 ret
= setenv(name
, cbuf
);
785 printf("Error setting %s\n", name
);
792 static int ait_menu_evaluate_network(char *choice
)
799 ait_menu_read_env("ipaddr");
802 ait_menu_read_env("netmask");
805 ait_menu_read_env("serverip");
808 ait_menu_read_env("gatewayip");
811 ait_menu_read_env("img_file");
821 struct menu_display ait_network
= {
822 .title
= "AIT network settings",
825 .menulist
= menu_network
,
826 .menu_evaluate
= ait_menu_evaluate_network
,
829 static int fit_get_subtype(const void *fit
, int noffset
, char **subtype
)
833 *subtype
= (char *)fdt_getprop(fit
, noffset
, "subtype", &len
);
834 if (*subtype
== NULL
)
840 static int ait_subtype_nr(char *subtype
)
842 int ret
= FIT_SUBTYPE_UNKNOWN
;
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
;
856 static int ait_menu_check_image(void)
859 unsigned long fit_addr
;
870 int found_uboot
= -1;
871 int found_ramdisk
= -1;
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
;
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
)
884 if (!fit_check_format(addr
))
887 /* print the FIT description */
888 ret
= fit_get_desc(addr
, 0, &desc
);
889 printf("FIT description: ");
891 printf("unavailable\n");
893 printf("%s\n", desc
);
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
));
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
)) {
910 * Direct child node of the images parent node,
911 * i.e. component image node.
913 printf("Image %u (%s)\n", count
,
914 fit_get_name(addr
, noffset
, NULL
));
916 fit_image_print(addr
, noffset
, "");
918 fit_image_get_type(addr
, noffset
,
920 /* Mandatory properties */
921 ret
= fit_get_desc(addr
, noffset
, &desc
);
922 printf("Description: ");
924 printf("unavailable\n");
926 printf("%s\n", desc
);
928 ret
= fit_get_subtype(addr
, noffset
, &subtype
);
931 printf("unavailable\n");
933 imgs
[count
].subtype
= ait_subtype_nr(subtype
);
934 printf("%s %d\n", subtype
,
935 imgs
[count
].subtype
);
938 sprintf(imgs
[count
].desc
, "%s", desc
);
940 ret
= fit_image_get_data(addr
, noffset
,
944 printf("Data Size: ");
946 printf("unavailable\n");
948 genimg_print_size(imgs
[count
].size
);
949 printf("Data @ %p\n", imgs
[count
].data
);
954 for (i
= 0; i
< count
; i
++) {
955 if (imgs
[i
].subtype
== FIT_SUBTYPE_UBOOT_IMAGE
)
957 if (imgs
[i
].type
== IH_TYPE_RAMDISK
) {
959 imgs
[i
].subtype
= FIT_SUBTYPE_RAMDISK_IMAGE
;
963 /* dvn_* env var update, if the FIT descriptors are different */
964 if (found_uboot
>= 0) {
965 s
= getenv("dvn_boot_vers");
967 ret
= strcmp(s
, imgs
[found_uboot
].desc
);
969 setenv("x_dvn_boot_vers",
970 imgs
[found_uboot
].desc
);
973 printf("no new uboot version\n");
976 setenv("dvn_boot_vers", imgs
[found_uboot
].desc
);
979 if (found_ramdisk
>= 0) {
980 s
= getenv("dvn_app_vers");
982 ret
= strcmp(s
, imgs
[found_ramdisk
].desc
);
984 setenv("x_dvn_app_vers",
985 imgs
[found_ramdisk
].desc
);
988 printf("no new ramdisk version\n");
991 setenv("dvn_app_vers", imgs
[found_ramdisk
].desc
);
994 if ((found_uboot
== -1) && (found_ramdisk
== -1))
1000 static int ait_menu_evaluate_update(char *choice
)
1007 switch (choice
[1]) {
1009 return ait_menu_show(&ait_network
, 0);
1013 ret
= run_command("run load_img", 0);
1014 printf("ret: %d\n", ret
);
1018 ret
= ait_menu_check_image();
1022 return ait_menu_show(&ait_load
, 0);
1033 struct menu_display ait_update
= {
1034 .title
= "AIT Update Software",
1037 .menulist
= menu_update
,
1038 .menu_evaluate
= ait_menu_evaluate_update
,
1041 static int ait_menu_evaluate_main(char *choice
)
1047 switch (choice
[1]) {
1050 return MENU_EXIT_BOOTCMD
;
1053 return ait_menu_show(&ait_update
, 0);
1056 /* reset to default settings */
1057 setenv("app_reset", "yes");
1058 return MENU_EXIT_BOOTCMD
;
1069 struct menu_display ait_main
= {
1070 .title
= "AIT Main",
1071 .timeout
= CONFIG_BOOTDELAY
,
1073 .menulist
= menu_main
,
1074 .menu_evaluate
= ait_menu_evaluate_main
,
1077 int menu_show(int bootdelay
)
1081 run_command("run saveparms", 0);
1082 ret
= ait_menu_show(&ait_main
, bootdelay
);
1083 run_command("run restoreparms", 0);
1085 if (ret
== MENU_EXIT_BOOTCMD
)
1091 void menu_display_statusline(struct menu
*m
)
1095 s1
= getenv("x_dvn_boot_vers");
1097 s1
= getenv("dvn_boot_vers");
1099 s2
= getenv("x_dvn_app_vers");
1101 s2
= getenv("dvn_app_vers");
1103 printf("State: dvn_boot_vers: %s dvn_app_vers: %s\n", s1
, s2
);