Eric Lee / smarc-uboot | Embedian Git Server

Browse Code »

Commit 5644369450635fa5c2967bee55b1ac41f6e988d0

Authored by Tom Rini 2013-03-31 20:43:12 +0800

2 parents 1d3dea12e2 d999398822

Exists in master and in 53 other branches

Merge branch 'agust@denx.de' of git://git.denx.de/u-boot-staging

Showing 10 changed files Inline Diff

board/ait/cam_enc_4xx/cam_enc_4xx.c
common/Makefile
common/cmd_bootmenu.c
common/cmd_pxe.c
common/menu.c
doc/README.bootmenu
doc/README.menu
include/ansi.h
include/configs/nokia_rx51.h
include/menu.h

board/ait/cam_enc_4xx/cam_enc_4xx.c

Diff comments View file @ 5644369

 /*
  * Copyright (C) 2009 Texas Instruments Incorporated
  *
  * Copyright (C) 2011
  * Heiko Schocher, DENX Software Engineering, hs@denx.de.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 #include <common.h>
 #include <errno.h>
 #include <hush.h>
 #include <linux/mtd/nand.h>
 #include <nand.h>
 #include <miiphy.h>
 #include <netdev.h>
 #include <asm/io.h>
 #include <asm/arch/hardware.h>
 #include <asm/arch/nand_defs.h>
 #include <asm/arch/davinci_misc.h>
 #ifdef CONFIG_DAVINCI_MMC
 #include <mmc.h>
 #include <asm/arch/sdmmc_defs.h>
 #endif
 DECLARE_GLOBAL_DATA_PTR;
 #ifndef CONFIG_SPL_BUILD
 static struct davinci_timer *timer =
 	(struct davinci_timer *)DAVINCI_TIMER3_BASE;
 static unsigned long get_timer_val(void)
 {
 	unsigned long now = readl(&timer->tim34);
 	return now;
 }
 static int timer_running(void)
 {
 	return readl(&timer->tcr) &
 		(DV_TIMER_TCR_ENAMODE_MASK << DV_TIMER_TCR_ENAMODE34_SHIFT);
 }
 static void stop_timer(void)
 {
 	writel(0x0, &timer->tcr);
 	return;
 }
 int checkboard(void)
 {
 	printf("Board: AIT CAM ENC 4XX\n");
 	return 0;
 }
 int board_init(void)
 {
 	gd->bd->bi_boot_params = PHYS_SDRAM_1 + 0x100;
 	return 0;
 }
 #ifdef CONFIG_DRIVER_TI_EMAC
 static int cam_enc_4xx_check_network(void)
 {
 	char *s;
 	s = getenv("ethaddr");
 	if (!s)
 		return -EINVAL;
 	if (!is_valid_ether_addr((const u8 *)s))
 		return -EINVAL;
 	s = getenv("ipaddr");
 	if (!s)
 		return -EINVAL;
 	s = getenv("netmask");
 	if (!s)
 		return -EINVAL;
 	s = getenv("serverip");
 	if (!s)
 		return -EINVAL;
 	s = getenv("gatewayip");
 	if (!s)
 		return -EINVAL;
 	return 0;
 }
 int board_eth_init(bd_t *bis)
 {
 	int ret;
 	ret = cam_enc_4xx_check_network();
 	if (ret)
 		return ret;
 	davinci_emac_initialize();
 	return 0;
 }
 #endif
 #ifdef CONFIG_NAND_DAVINCI
 static int
 davinci_std_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
 				   uint8_t *buf, int page)
 {
 	struct nand_chip *this = mtd->priv;
 	int i, eccsize = chip->ecc.size;
 	int eccbytes = chip->ecc.bytes;
 	int eccsteps = chip->ecc.steps;
 	uint8_t *p = buf;
 	uint8_t *oob = chip->oob_poi;
 	chip->cmdfunc(mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
 	chip->read_buf(mtd, oob, mtd->oobsize);
 	chip->cmdfunc(mtd, NAND_CMD_READ0, 0x0, page & this->pagemask);
 	for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
 		int stat;
 		chip->ecc.hwctl(mtd, NAND_ECC_READ);
 		chip->read_buf(mtd, p, eccsize);
 		chip->ecc.hwctl(mtd, NAND_ECC_READSYN);
 		if (chip->ecc.prepad)
 			oob += chip->ecc.prepad;
 		stat = chip->ecc.correct(mtd, p, oob, NULL);
 		if (stat == -1)
 			mtd->ecc_stats.failed++;
 		else
 			mtd->ecc_stats.corrected += stat;
 		oob += eccbytes;
 		if (chip->ecc.postpad)
 			oob += chip->ecc.postpad;
 	}
 	/* Calculate remaining oob bytes */
 	i = mtd->oobsize - (oob - chip->oob_poi);
 	if (i)
 		chip->read_buf(mtd, oob, i);
 	return 0;
 }
 static void davinci_std_write_page_syndrome(struct mtd_info *mtd,
 				    struct nand_chip *chip, const uint8_t *buf)
 {
 	unsigned char davinci_ecc_buf[NAND_MAX_OOBSIZE];
 	struct nand_chip *this = mtd->priv;
 	int i, eccsize = chip->ecc.size;
 	int eccbytes = chip->ecc.bytes;
 	int eccsteps = chip->ecc.steps;
 	int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
 	int offset = 0;
 	const uint8_t *p = buf;
 	uint8_t *oob = chip->oob_poi;
 	for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
 		chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
 		chip->write_buf(mtd, p, eccsize);
 		/* Calculate ECC without prepad */
 		chip->ecc.calculate(mtd, p, oob + chip->ecc.prepad);
 		if (chip->ecc.prepad) {
 			offset = (chip->ecc.steps - eccsteps) * chunk;
 			memcpy(&davinci_ecc_buf[offset], oob, chip->ecc.prepad);
 			oob += chip->ecc.prepad;
 		}
 		offset = ((chip->ecc.steps - eccsteps) * chunk) +
 				chip->ecc.prepad;
 		memcpy(&davinci_ecc_buf[offset], oob, eccbytes);
 		oob += eccbytes;
 		if (chip->ecc.postpad) {
 			offset = ((chip->ecc.steps - eccsteps) * chunk) +
 					chip->ecc.prepad + eccbytes;
 			memcpy(&davinci_ecc_buf[offset], oob,
 				chip->ecc.postpad);
 			oob += chip->ecc.postpad;
 		}
 	}
 	/*
 	 * Write the sparebytes into the page once
 	 * all eccsteps have been covered
 	 */
 	for (i = 0; i < mtd->oobsize; i++)
 		writeb(davinci_ecc_buf[i], this->IO_ADDR_W);
 	/* Calculate remaining oob bytes */
 	i = mtd->oobsize - (oob - chip->oob_poi);
 	if (i)
 		chip->write_buf(mtd, oob, i);
 }
 static int davinci_std_write_oob_syndrome(struct mtd_info *mtd,
 				   struct nand_chip *chip, int page)
 {
 	int pos, status = 0;
 	const uint8_t *bufpoi = chip->oob_poi;
 	pos = mtd->writesize;
 	chip->cmdfunc(mtd, NAND_CMD_SEQIN, pos, page);
 	chip->write_buf(mtd, bufpoi, mtd->oobsize);
 	chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
 	status = chip->waitfunc(mtd, chip);
 	return status & NAND_STATUS_FAIL ? -1 : 0;
 }
 static int davinci_std_read_oob_syndrome(struct mtd_info *mtd,
 	struct nand_chip *chip, int page, int sndcmd)
 {
 	struct nand_chip *this = mtd->priv;
 	uint8_t *buf = chip->oob_poi;
 	uint8_t *bufpoi = buf;
 	chip->cmdfunc(mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
 	chip->read_buf(mtd, bufpoi, mtd->oobsize);
 	return 1;
 }
 static void nand_dm365evm_select_chip(struct mtd_info *mtd, int chip)
 {
 	struct nand_chip	*this = mtd->priv;
 	unsigned long		wbase = (unsigned long) this->IO_ADDR_W;
 	unsigned long		rbase = (unsigned long) this->IO_ADDR_R;
 	if (chip == 1) {
 		__set_bit(14, &wbase);
 		__set_bit(14, &rbase);
 	} else {
 		__clear_bit(14, &wbase);
 		__clear_bit(14, &rbase);
 	}
 	this->IO_ADDR_W = (void *)wbase;
 	this->IO_ADDR_R = (void *)rbase;
 }
 int board_nand_init(struct nand_chip *nand)
 {
 	davinci_nand_init(nand);
 	nand->select_chip = nand_dm365evm_select_chip;
 	return 0;
 }
 struct nand_ecc_ctrl org_ecc;
 static int notsaved = 1;
 static int nand_switch_hw_func(int mode)
 {
 	struct nand_chip *nand;
 	struct mtd_info *mtd;
 	if (nand_curr_device < 0 ||
 	    nand_curr_device >= CONFIG_SYS_MAX_NAND_DEVICE ||
 	    !nand_info[nand_curr_device].name) {
 		printf("Error: Can't switch hw functions," \
 			" no devices available\n");
 		return -1;
 	}
 	mtd = &nand_info[nand_curr_device];
 	nand = mtd->priv;
 	if (mode == 0) {
 		if (notsaved == 0) {
 			printf("switching to uboot hw functions.\n");
 			memcpy(&nand->ecc, &org_ecc,
 				sizeof(struct nand_ecc_ctrl));
 		}
 	} else {
 		/* RBL */
 		printf("switching to RBL hw functions.\n");
 		if (notsaved == 1) {
 			memcpy(&org_ecc, &nand->ecc,
 				sizeof(struct nand_ecc_ctrl));
 			notsaved = 0;
 		}
 		nand->ecc.mode = NAND_ECC_HW_SYNDROME;
 		nand->ecc.prepad = 6;
 		nand->ecc.read_page = davinci_std_read_page_syndrome;
 		nand->ecc.write_page = davinci_std_write_page_syndrome;
 		nand->ecc.read_oob = davinci_std_read_oob_syndrome;
 		nand->ecc.write_oob = davinci_std_write_oob_syndrome;
 	}
 	return mode;
 }
 static int hwmode;
 static int do_switch_ecc(cmd_tbl_t *cmdtp, int flag, int argc,
 		char *const argv[])
 {
 	if (argc != 2)
 		goto usage;
 	if (strncmp(argv[1], "rbl", 2) == 0)
 		hwmode = nand_switch_hw_func(1);
 	else if (strncmp(argv[1], "uboot", 2) == 0)
 		hwmode = nand_switch_hw_func(0);
 	else
 		goto usage;
 	return 0;
 usage:
 	printf("Usage: nandrbl %s\n", cmdtp->usage);
 	return 1;
 }
 U_BOOT_CMD(
 	nandrbl, 2, 1,	do_switch_ecc,
 	"switch between rbl/uboot NAND ECC calculation algorithm",
 	"[rbl/uboot] - Switch between rbl/uboot NAND ECC algorithm"
 );
 #endif /* #ifdef CONFIG_NAND_DAVINCI */
 #ifdef CONFIG_DAVINCI_MMC
 static struct davinci_mmc mmc_sd0 = {
 	.reg_base	= (struct davinci_mmc_regs *)DAVINCI_MMC_SD0_BASE,
 	.input_clk	= 121500000,
 	.host_caps	= MMC_MODE_4BIT,
 	.voltages	= MMC_VDD_32_33 | MMC_VDD_33_34,
 	.version	= MMC_CTLR_VERSION_2,
 };
 int board_mmc_init(bd_t *bis)
 {
 	int err;
 	/* Add slot-0 to mmc subsystem */
 	err = davinci_mmc_init(bis, &mmc_sd0);
 	return err;
 }
 #endif
 int board_late_init(void)
 {
 	struct davinci_gpio *gpio = davinci_gpio_bank45;
 	/* 24MHz InputClock / 15 prediv -> 1.6 MHz timer running */
 	while ((get_timer_val() < CONFIG_AIT_TIMER_TIMEOUT) &&
 		timer_running())
 		;
 	/* 1 sec reached -> stop timer, clear all LED */
 	stop_timer();
 	clrbits_le32(&gpio->out_data, CONFIG_CAM_ENC_LED_MASK);
 	return 0;
 }
 void reset_phy(void)
 {
 	char *name = "GENERIC @ 0x00";
 	/* reset the phy */
 	miiphy_reset(name, 0x0);
 }
 #else /* #ifndef CONFIG_SPL_BUILD */
 static void cam_enc_4xx_set_all_led(void)
 {
 	struct davinci_gpio *gpio = davinci_gpio_bank45;
 	setbits_le32(&gpio->out_data, CONFIG_CAM_ENC_LED_MASK);
 }
 /*
  * TIMER 0 is used for tick
  */
 static struct davinci_timer *timer =
 	(struct davinci_timer *)DAVINCI_TIMER3_BASE;
 #define TIMER_LOAD_VAL	0xffffffff
 #define TIM_CLK_DIV	16
 static int cam_enc_4xx_timer_init(void)
 {
 	/* We are using timer34 in unchained 32-bit mode, full speed */
 	writel(0x0, &timer->tcr);
 	writel(0x0, &timer->tgcr);
 	writel(0x06 | ((TIM_CLK_DIV - 1) << 8), &timer->tgcr);
 	writel(0x0, &timer->tim34);
 	writel(TIMER_LOAD_VAL, &timer->prd34);
 	writel(2 << 22, &timer->tcr);
 	return 0;
 }
 void board_gpio_init(void)
 {
 	struct davinci_gpio *gpio;
 	cam_enc_4xx_set_all_led();
 	cam_enc_4xx_timer_init();
 	gpio = davinci_gpio_bank01;
 	clrbits_le32(&gpio->dir, ~0xfdfffffe);
 	/* clear LED D14 = GPIO25 */
 	clrbits_le32(&gpio->out_data, 0x02000000);
 	gpio = davinci_gpio_bank23;
 	clrbits_le32(&gpio->dir, ~0x5ff0afef);
 	/* set GPIO61 to 1 -> intern UART0 as Console */
 	setbits_le32(&gpio->out_data, 0x20000000);
 	/*
 	 * PHY out of reset GIO 50 = 1
 	 * NAND WP off GIO 51 = 1
 	 */
 	setbits_le32(&gpio->out_data, 0x000c0004);
 	gpio = davinci_gpio_bank45;
 	clrbits_le32(&gpio->dir, ~(0xdb2fffff) | CONFIG_CAM_ENC_LED_MASK);
 	/*
 	 * clear LED:
 	 * D17 = GPIO86
 	 * D11 = GPIO87
 	 * GPIO88
 	 * GPIO89
 	 * D13 = GPIO90
 	 * GPIO91
 	 */
 	clrbits_le32(&gpio->out_data, CONFIG_CAM_ENC_LED_MASK);
 	gpio = davinci_gpio_bank67;
 	clrbits_le32(&gpio->dir, ~0x000007ff);
 }
 /*
  * functions for the post memory test.
  */
 int arch_memory_test_prepare(u32 *vstart, u32 *size, phys_addr_t *phys_offset)
 {
 	*vstart = CONFIG_SYS_SDRAM_BASE;
 	*size = PHYS_SDRAM_1_SIZE;
 	*phys_offset = 0;
 	return 0;
 }
 void arch_memory_failure_handle(void)
 {
 	cam_enc_4xx_set_all_led();
 	puts("mem failure\n");
 	while (1)
 		;
 }
 #endif
 #if defined(CONFIG_MENU)
 #include "menu.h"
 #define MENU_EXIT		-1
 #define MENU_EXIT_BOOTCMD	-2
 #define MENU_STAY		0
 #define MENU_MAIN		1
 #define MENU_UPDATE		2
 #define MENU_NETWORK		3
 #define MENU_LOAD		4
 static int menu_start;
 #define FIT_SUBTYPE_UNKNOWN		0
 #define FIT_SUBTYPE_UBL_HEADER		1
 #define FIT_SUBTYPE_SPL_IMAGE		2
 #define FIT_SUBTYPE_UBOOT_IMAGE		3
 #define FIT_SUBTYPE_DF_ENV_IMAGE	4
 #define FIT_SUBTYPE_RAMDISK_IMAGE	5
 struct fit_images_info {
 	u_int8_t type;
 	int subtype;
 	char desc[200];
 	const void *data;
 	size_t size;
 };
 static struct fit_images_info imgs[10];
 struct menu_display {
 	char	title[50];
 	int	timeout; /* in sec */
 	int	id; /* MENU_* */
 	char	**menulist;
 	int (*menu_evaluate)(char *choice);
 };
 char *menu_main[] = {
 	"(1) Boot",
 	"(2) Update Software",
 	"(3) Reset to default setting and boot",
 	"(4) Enter U-Boot console",
 	NULL
 };
 char *menu_update[] = {
 	"(1) Network settings",
 	"(2) load image",
 	"(3) back to main",
 	NULL
 };
 char *menu_load[] = {
 	"(1) install image",
 	"(2) cancel",
 	NULL
 };
 char *menu_network[] = {
 	"(1) ipaddr   ",
 	"(2) netmask  ",
 	"(3) serverip ",
 	"(4) gatewayip",
 	"(5) tftp image name",
 	"(6) back to update software",
 	NULL
 };
 static void ait_menu_print(void *data)
 {
 	printf("%s\n", (char *)data);
 	return;
 }
 static char *menu_handle(struct menu_display *display)
 {
 	struct menu *m;
 	int i;
 	void *choice = NULL;
 	char key[2];
 	int ret;
 	char *s;
 	char temp[6][200];
-	m = menu_create(display->title, display->timeout, 1, ait_menu_print);
+	m = menu_create(display->title, display->timeout, 1, ait_menu_print,
+			NULL, NULL);
 	for (i = 0; display->menulist[i]; i++) {
 		sprintf(key, "%d", i + 1);
 		if (display->id == MENU_NETWORK) {
 			switch (i) {
 			case 0:
 				s = getenv("ipaddr");
 				break;
 			case 1:
 				s = getenv("netmask");
 				break;
 			case 2:
 				s = getenv("serverip");
 				break;
 			case 3:
 				s = getenv("gatewayip");
 				break;
 			case 4:
 				s = getenv("img_file");
 				break;
 			default:
 				s = NULL;
 				break;
 			}
 			if (s) {
 				sprintf(temp[i], "%s: %s",
 					display->menulist[i], s);
 				ret = menu_item_add(m, key, temp[i]);
 			} else {
 				ret = menu_item_add(m, key,
 					display->menulist[i]);
 			}
 		} else {
 			ret = menu_item_add(m, key, display->menulist[i]);
 		}
 		if (ret != 1) {
 			printf("failed to add item!");
 			menu_destroy(m);
 			return NULL;
 		}
 	}
 	sprintf(key, "%d", 1);
 	menu_default_set(m, key);
 	if (menu_get_choice(m, &choice) != 1)
 		debug("Problem picking a choice!\n");
 	menu_destroy(m);
 	return choice;
 }
 static int ait_menu_show(struct menu_display *display, int bootdelay)
 {
 	int end = MENU_STAY;
 	char *choice;
 	if ((menu_start == 0) && (display->id == MENU_MAIN))
 		display->timeout = bootdelay;
 	else
 		display->timeout = 0;
 	while (end == MENU_STAY) {
 		choice = menu_handle(display);
 		if (choice)
 			end = display->menu_evaluate(choice);
 		if (end == display->id)
 			end = MENU_STAY;
 		if (display->id == MENU_MAIN) {
 			if (menu_start == 0)
 				end = MENU_EXIT_BOOTCMD;
 			else
 				display->timeout = 0;
 		}
 	}
 	return end;
 }
 static int ait_writeublheader(void)
 {
 	char s[20];
 	unsigned long i;
 	int ret;
 	for (i = CONFIG_SYS_NAND_BLOCK_SIZE;
 		i < CONFIG_SYS_NAND_U_BOOT_OFFS;
 		i += CONFIG_SYS_NAND_BLOCK_SIZE) {
 		sprintf(s, "%lx", i);
 		ret = setenv("header_addr", s);
 		if (ret == 0)
 			ret = run_command("run img_writeheader", 0);
 		if (ret != 0)
 			break;
 	}
 	return ret;
 }
 static int ait_menu_install_images(void)
 {
 	int ret = 0;
 	int count = 0;
 	char s[100];
 	char *t;
 	/*
 	 * possible image types:
 	 * FIT_SUBTYPE_UNKNOWN
 	 * FIT_SUBTYPE_UBL_HEADER
 	 * FIT_SUBTYPE_SPL_IMAGE
 	 * FIT_SUBTYPE_UBOOT_IMAGE
 	 * FIT_SUBTYPE_DF_ENV_IMAGE
 	 * FIT_SUBTYPE_RAMDISK_IMAGE
 	 *
 	 * use Envvariables:
 	 * img_addr_r: image start addr
 	 * header_addr: addr where to write to UBL header
 	 * img_writeheader: write ubl header to nand
 	 * img_writespl: write spl to nand
 	 * img_writeuboot: write uboot to nand
 	 * img_writedfenv: write default environment to ubi volume
 	 * img_volume: which ubi volume should be updated with img_writeramdisk
 	 * filesize: size of data for updating ubi volume
 	 * img_writeramdisk: write ramdisk to ubi volume
 	 */
 	while (imgs[count].type != IH_TYPE_INVALID) {
 		printf("Installing %s\n",
 			genimg_get_type_name(imgs[count].type));
 		sprintf(s, "%p", imgs[count].data);
 		setenv("img_addr_r", s);
 		sprintf(s, "%lx", (unsigned long)imgs[count].size);
 		setenv("filesize", s);
 		switch (imgs[count].subtype) {
 		case FIT_SUBTYPE_DF_ENV_IMAGE:
 			ret = run_command("run img_writedfenv", 0);
 			break;
 		case FIT_SUBTYPE_RAMDISK_IMAGE:
 			t = getenv("img_volume");
 			if (!t) {
 				ret = setenv("img_volume", "rootfs1");
 			} else {
 				/* switch to other volume */
 				if (strncmp(t, "rootfs1", 7) == 0)
 					ret = setenv("img_volume", "rootfs2");
 				else
 					ret = setenv("img_volume", "rootfs1");
 			}
 			if (ret != 0)
 				break;
 			ret = run_command("run img_writeramdisk", 0);
 			break;
 		case FIT_SUBTYPE_SPL_IMAGE:
 			ret = run_command("run img_writespl", 0);
 			break;
 		case FIT_SUBTYPE_UBL_HEADER:
 			ret = ait_writeublheader();
 			break;
 		case FIT_SUBTYPE_UBOOT_IMAGE:
 			ret = run_command("run img_writeuboot", 0);
 			break;
 		default:
 			/* not supported type */
 			break;
 		}
 		count++;
 	}
 	/* now save dvn_* and img_volume env vars to new values */
 	if (ret == 0) {
 		t = getenv("x_dvn_boot_vers");
 		if (t)
 			setenv("dvn_boot_vers", t);
 		t = getenv("x_dvn_app_vers");
 		if (t)
 			setenv("dvn_boot_vers", t);
 		setenv("x_dvn_boot_vers", NULL);
 		setenv("x_dvn_app_vers", NULL);
 		ret = run_command("run savenewvers", 0);
 	}
 	return ret;
 }
 static int ait_menu_evaluate_load(char *choice)
 {
 	if (!choice)
 		return -1;
 	switch (choice[1]) {
 	case '1':
 		/* install image */
 		ait_menu_install_images();
 		break;
 	case '2':
 		/* cancel, back to main */
 		setenv("x_dvn_boot_vers", NULL);
 		setenv("x_dvn_app_vers", NULL);
 		break;
 	}
 	return MENU_MAIN;
 }
 struct menu_display ait_load = {
 	.title = "AIT load image",
 	.timeout = 0,
 	.id = MENU_LOAD,
 	.menulist = menu_load,
 	.menu_evaluate = ait_menu_evaluate_load,
 };
 static void ait_menu_read_env(char *name)
 {
 	char output[CONFIG_SYS_CBSIZE];
 	char cbuf[CONFIG_SYS_CBSIZE];
 	int readret;
 	int ret;
 	sprintf(output, "%s old: %s value: ", name, getenv(name));
 	memset(cbuf, 0, CONFIG_SYS_CBSIZE);
 	readret = readline_into_buffer(output, cbuf, 0);
 	if (readret >= 0) {
 		ret = setenv(name, cbuf);
 		if (ret) {
 			printf("Error setting %s\n", name);
 			return;
 		}
 	}
 	return;
 }
 static int ait_menu_evaluate_network(char *choice)
 {
 	if (!choice)
 		return MENU_MAIN;
 	switch (choice[1]) {
 	case '1':
 		ait_menu_read_env("ipaddr");
 		break;
 	case '2':
 		ait_menu_read_env("netmask");
 		break;
 	case '3':
 		ait_menu_read_env("serverip");
 		break;
 	case '4':
 		ait_menu_read_env("gatewayip");
 		break;
 	case '5':
 		ait_menu_read_env("img_file");
 		break;
 	case '6':
 		return MENU_UPDATE;
 		break;
 	}
 	return MENU_STAY;
 }
 struct menu_display ait_network = {
 	.title = "AIT network settings",
 	.timeout = 0,
 	.id = MENU_NETWORK,
 	.menulist = menu_network,
 	.menu_evaluate = ait_menu_evaluate_network,
 };
 static int fit_get_subtype(const void *fit, int noffset, char **subtype)
 {
 	int len;
 	*subtype = (char *)fdt_getprop(fit, noffset, "subtype", &len);
 	if (*subtype == NULL)
 		return -1;
 	return 0;
 }
 static int ait_subtype_nr(char *subtype)
 {
 	int ret = FIT_SUBTYPE_UNKNOWN;
 	if (!strncmp("ublheader", subtype, strlen("ublheader")))
 		return FIT_SUBTYPE_UBL_HEADER;
 	if (!strncmp("splimage", subtype, strlen("splimage")))
 		return FIT_SUBTYPE_SPL_IMAGE;
 	if (!strncmp("ubootimage", subtype, strlen("ubootimage")))
 		return FIT_SUBTYPE_UBOOT_IMAGE;
 	if (!strncmp("dfenvimage", subtype, strlen("dfenvimage")))
 		return FIT_SUBTYPE_DF_ENV_IMAGE;
 	return ret;
 }
 static int ait_menu_check_image(void)
 {
 	char *s;
 	unsigned long fit_addr;
 	void *addr;
 	int format;
 	char *desc;
 	char *subtype;
 	int images_noffset;
 	int noffset;
 	int ndepth;
 	int count = 0;
 	int ret;
 	int i;
 	int found_uboot = -1;
 	int found_ramdisk = -1;
 	memset(imgs, 0, sizeof(imgs));
 	s = getenv("fit_addr_r");
 	fit_addr = s ? (unsigned long)simple_strtol(s, NULL, 16) : \
 			CONFIG_BOARD_IMG_ADDR_R;
 	addr = (void *)fit_addr;
 	/* check if it is a FIT image */
 	format = genimg_get_format(addr);
 	if (format != IMAGE_FORMAT_FIT)
 		return -EINVAL;
 	if (!fit_check_format(addr))
 		return -EINVAL;
 	/* print the FIT description */
 	ret = fit_get_desc(addr, 0, &desc);
 	printf("FIT description: ");
 	if (ret)
 		printf("unavailable\n");
 	else
 		printf("%s\n", desc);
 	/* find images */
 	images_noffset = fdt_path_offset(addr, FIT_IMAGES_PATH);
 	if (images_noffset < 0) {
 		printf("Can't find images parent node '%s' (%s)\n",
 			FIT_IMAGES_PATH, fdt_strerror(images_noffset));
 		return -EINVAL;
 	}
 	/* Process its subnodes, print out component images details */
 	for (ndepth = 0, count = 0,
 		noffset = fdt_next_node(addr, images_noffset, &ndepth);
 		(noffset >= 0) && (ndepth > 0);
 		noffset = fdt_next_node(addr, noffset, &ndepth)) {
 		if (ndepth == 1) {
 			/*
 			 * Direct child node of the images parent node,
 			 * i.e. component image node.
 			 */
 			printf("Image %u (%s)\n", count,
 					fit_get_name(addr, noffset, NULL));
 			fit_image_print(addr, noffset, "");
 			fit_image_get_type(addr, noffset,
 				&imgs[count].type);
 			/* Mandatory properties */
 			ret = fit_get_desc(addr, noffset, &desc);
 			printf("Description:  ");
 			if (ret)
 				printf("unavailable\n");
 			else
 				printf("%s\n", desc);
 			ret = fit_get_subtype(addr, noffset, &subtype);
 			printf("Subtype:  ");
 			if (ret) {
 				printf("unavailable\n");
 			} else {
 				imgs[count].subtype = ait_subtype_nr(subtype);
 				printf("%s %d\n", subtype,
 					imgs[count].subtype);
 			}
 			sprintf(imgs[count].desc, "%s", desc);
 			ret = fit_image_get_data(addr, noffset,
 				&imgs[count].data,
 				&imgs[count].size);
 			printf("Data Size:    ");
 			if (ret)
 				printf("unavailable\n");
 			else
 				genimg_print_size(imgs[count].size);
 			printf("Data @ %p\n", imgs[count].data);
 			count++;
 		}
 	}
 	for (i = 0; i < count; i++) {
 		if (imgs[i].subtype == FIT_SUBTYPE_UBOOT_IMAGE)
 			found_uboot = i;
 		if (imgs[i].type == IH_TYPE_RAMDISK) {
 			found_ramdisk = i;
 			imgs[i].subtype = FIT_SUBTYPE_RAMDISK_IMAGE;
 		}
 	}
 	/* dvn_* env var update, if the FIT descriptors are different */
 	if (found_uboot >= 0) {
 		s = getenv("dvn_boot_vers");
 		if (s) {
 			ret = strcmp(s, imgs[found_uboot].desc);
 			if (ret != 0) {
 				setenv("x_dvn_boot_vers",
 					imgs[found_uboot].desc);
 			} else {
 				found_uboot = -1;
 				printf("no new uboot version\n");
 			}
 		} else {
 			setenv("dvn_boot_vers", imgs[found_uboot].desc);
 		}
 	}
 	if (found_ramdisk >= 0) {
 		s = getenv("dvn_app_vers");
 		if (s) {
 			ret = strcmp(s, imgs[found_ramdisk].desc);
 			if (ret != 0) {
 				setenv("x_dvn_app_vers",
 					imgs[found_ramdisk].desc);
 			} else {
 				found_ramdisk = -1;
 				printf("no new ramdisk version\n");
 			}
 		} else {
 			setenv("dvn_app_vers", imgs[found_ramdisk].desc);
 		}
 	}
 	if ((found_uboot == -1) && (found_ramdisk == -1))
 		return -EINVAL;
 	return 0;
 }
 static int ait_menu_evaluate_update(char *choice)
 {
 	int ret;
 	if (!choice)
 		return MENU_MAIN;
 	switch (choice[1]) {
 	case '1':
 		return ait_menu_show(&ait_network, 0);
 		break;
 	case '2':
 		/* load image */
 		ret = run_command("run load_img", 0);
 		printf("ret: %d\n", ret);
 		if (ret)
 			return MENU_UPDATE;
 		ret = ait_menu_check_image();
 		if (ret)
 			return MENU_UPDATE;
 		return ait_menu_show(&ait_load, 0);
 		break;
 	case '3':
 		return MENU_MAIN;
 		break;
 	}
 	return MENU_MAIN;
 }
 struct menu_display ait_update = {
 	.title = "AIT Update Software",
 	.timeout = 0,
 	.id = MENU_UPDATE,
 	.menulist = menu_update,
 	.menu_evaluate = ait_menu_evaluate_update,
 };
 static int ait_menu_evaluate_main(char *choice)
 {
 	if (!choice)
 		return MENU_STAY;
 	menu_start = 1;
 	switch (choice[1]) {
 	case '1':
 		/* run bootcmd */
 		return MENU_EXIT_BOOTCMD;
 		break;
 	case '2':
 		return ait_menu_show(&ait_update, 0);
 		break;
 	case '3':
 		/* reset to default settings */
 		setenv("app_reset", "yes");
 		return MENU_EXIT_BOOTCMD;
 		break;
 	case '4':
 		/* u-boot shell */
 		return MENU_EXIT;
 		break;
 	}
 	return MENU_EXIT;
 }
 struct menu_display ait_main = {
 	.title = "AIT Main",
 	.timeout = CONFIG_BOOTDELAY,
 	.id = MENU_MAIN,
 	.menulist = menu_main,
 	.menu_evaluate = ait_menu_evaluate_main,
 };
 int menu_show(int bootdelay)
 {
 	int ret;
 	run_command("run saveparms", 0);
 	ret = ait_menu_show(&ait_main, bootdelay);
 	run_command("run restoreparms", 0);
 	if (ret == MENU_EXIT_BOOTCMD)
 		return 0;
 	return MENU_EXIT;
 }
 void menu_display_statusline(struct menu *m)
 {
 	char *s1, *s2;
 	s1 = getenv("x_dvn_boot_vers");
 	if (!s1)
 		s1 = getenv("dvn_boot_vers");
 	s2 = getenv("x_dvn_app_vers");
 	if (!s2)
 		s2 = getenv("dvn_app_vers");
 	printf("State: dvn_boot_vers: %s dvn_app_vers: %s\n", s1, s2);
 	return;
 }
 #endif

common/Makefile

Diff comments View file @ 5644369

 #
 # (C) Copyright 2004-2006
 # Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 #
 # See file CREDITS for list of people who contributed to this
 # project.
 #
 # This program is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License as
 # published by the Free Software Foundation; either version 2 of
 # the License, or (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 # MA 02111-1307 USA
 #
 include $(TOPDIR)/config.mk
 LIB	= $(obj)libcommon.o
 # core
 ifndef CONFIG_SPL_BUILD
 COBJS-y += main.o
 COBJS-y += command.o
 COBJS-y += exports.o
 COBJS-y += hash.o
 COBJS-$(CONFIG_SYS_HUSH_PARSER) += hush.o
 COBJS-y += s_record.o
 COBJS-y += xyzModem.o
 COBJS-y += cmd_disk.o
 # boards
 COBJS-$(CONFIG_SYS_GENERIC_BOARD) += board_f.o
 COBJS-$(CONFIG_SYS_GENERIC_BOARD) += board_r.o
 # core command
 COBJS-y += cmd_boot.o
 COBJS-$(CONFIG_CMD_BOOTM) += cmd_bootm.o
 COBJS-y += cmd_help.o
 COBJS-y += cmd_nvedit.o
 COBJS-y += cmd_version.o
 # environment
 COBJS-y += env_attr.o
 COBJS-y += env_callback.o
 COBJS-y += env_common.o
 COBJS-y += env_flags.o
 COBJS-$(CONFIG_ENV_IS_IN_DATAFLASH) += env_dataflash.o
 COBJS-$(CONFIG_ENV_IS_IN_EEPROM) += env_eeprom.o
 XCOBJS-$(CONFIG_ENV_IS_EMBEDDED) += env_embedded.o
 COBJS-$(CONFIG_ENV_IS_IN_EEPROM) += env_embedded.o
 XCOBJS-$(CONFIG_ENV_IS_IN_FLASH) += env_embedded.o
 COBJS-$(CONFIG_ENV_IS_IN_NVRAM) += env_embedded.o
 COBJS-$(CONFIG_ENV_IS_IN_FLASH) += env_flash.o
 COBJS-$(CONFIG_ENV_IS_IN_MMC) += env_mmc.o
 COBJS-$(CONFIG_ENV_IS_IN_FAT) += env_fat.o
 COBJS-$(CONFIG_ENV_IS_IN_NAND) += env_nand.o
 COBJS-$(CONFIG_ENV_IS_IN_NVRAM) += env_nvram.o
 COBJS-$(CONFIG_ENV_IS_IN_ONENAND) += env_onenand.o
 COBJS-$(CONFIG_ENV_IS_IN_SPI_FLASH) += env_sf.o
 COBJS-$(CONFIG_ENV_IS_IN_REMOTE) += env_remote.o
 COBJS-$(CONFIG_ENV_IS_NOWHERE) += env_nowhere.o
 # command
 COBJS-$(CONFIG_CMD_AMBAPP) += cmd_ambapp.o
 COBJS-$(CONFIG_SOURCE) += cmd_source.o
 COBJS-$(CONFIG_CMD_SOURCE) += cmd_source.o
 COBJS-$(CONFIG_CMD_BDI) += cmd_bdinfo.o
 COBJS-$(CONFIG_CMD_BEDBUG) += bedbug.o cmd_bedbug.o
 COBJS-$(CONFIG_CMD_BMP) += cmd_bmp.o
+COBJS-$(CONFIG_CMD_BOOTMENU) += cmd_bootmenu.o
 COBJS-$(CONFIG_CMD_BOOTLDR) += cmd_bootldr.o
 COBJS-$(CONFIG_CMD_BOOTSTAGE) += cmd_bootstage.o
 COBJS-$(CONFIG_CMD_CACHE) += cmd_cache.o
 COBJS-$(CONFIG_CMD_CBFS) += cmd_cbfs.o
 COBJS-$(CONFIG_CMD_CONSOLE) += cmd_console.o
 COBJS-$(CONFIG_CMD_CPLBINFO) += cmd_cplbinfo.o
 COBJS-$(CONFIG_DATAFLASH_MMC_SELECT) += cmd_dataflash_mmc_mux.o
 COBJS-$(CONFIG_CMD_DATE) += cmd_date.o
 COBJS-$(CONFIG_CMD_SOUND) += cmd_sound.o
 ifdef CONFIG_4xx
 COBJS-$(CONFIG_CMD_SETGETDCR) += cmd_dcr.o
 endif
 ifdef CONFIG_POST
 COBJS-$(CONFIG_CMD_DIAG) += cmd_diag.o
 endif
 COBJS-$(CONFIG_CMD_DISPLAY) += cmd_display.o
 COBJS-$(CONFIG_CMD_DTT) += cmd_dtt.o
 COBJS-$(CONFIG_CMD_ECHO) += cmd_echo.o
 COBJS-$(CONFIG_ENV_IS_IN_EEPROM) += cmd_eeprom.o
 COBJS-$(CONFIG_CMD_EEPROM) += cmd_eeprom.o
 COBJS-$(CONFIG_CMD_ELF) += cmd_elf.o
 COBJS-$(CONFIG_SYS_HUSH_PARSER) += cmd_exit.o
 COBJS-$(CONFIG_CMD_EXT4) += cmd_ext4.o
 COBJS-$(CONFIG_CMD_EXT2) += cmd_ext2.o
 COBJS-$(CONFIG_CMD_FAT) += cmd_fat.o
 COBJS-$(CONFIG_CMD_FDC)$(CONFIG_CMD_FDOS) += cmd_fdc.o
 COBJS-$(CONFIG_OF_LIBFDT) += cmd_fdt.o fdt_support.o
 COBJS-$(CONFIG_CMD_FDOS) += cmd_fdos.o
 COBJS-$(CONFIG_CMD_FITUPD) += cmd_fitupd.o
 COBJS-$(CONFIG_CMD_FLASH) += cmd_flash.o
 ifdef CONFIG_FPGA
 COBJS-$(CONFIG_CMD_FPGA) += cmd_fpga.o
 endif
 COBJS-$(CONFIG_CMD_FS_GENERIC) += cmd_fs.o
 COBJS-$(CONFIG_CMD_GETTIME) += cmd_gettime.o
 COBJS-$(CONFIG_CMD_GPIO) += cmd_gpio.o
 COBJS-$(CONFIG_CMD_I2C) += cmd_i2c.o
 COBJS-$(CONFIG_CMD_HASH) += cmd_hash.o
 COBJS-$(CONFIG_CMD_IDE) += cmd_ide.o
 COBJS-$(CONFIG_CMD_IMMAP) += cmd_immap.o
 COBJS-$(CONFIG_CMD_INI) += cmd_ini.o
 COBJS-$(CONFIG_CMD_IRQ) += cmd_irq.o
 COBJS-$(CONFIG_CMD_ITEST) += cmd_itest.o
 COBJS-$(CONFIG_CMD_JFFS2) += cmd_jffs2.o
 COBJS-$(CONFIG_CMD_CRAMFS) += cmd_cramfs.o
 COBJS-$(CONFIG_CMD_LDRINFO) += cmd_ldrinfo.o
 COBJS-$(CONFIG_CMD_LED) += cmd_led.o
 COBJS-$(CONFIG_CMD_LICENSE) += cmd_license.o
 COBJS-y += cmd_load.o
 COBJS-$(CONFIG_LOGBUFFER) += cmd_log.o
 COBJS-$(CONFIG_ID_EEPROM) += cmd_mac.o
 COBJS-$(CONFIG_CMD_MD5SUM) += cmd_md5sum.o
 COBJS-$(CONFIG_CMD_MEMORY) += cmd_mem.o
 COBJS-$(CONFIG_CMD_IO) += cmd_io.o
 COBJS-$(CONFIG_CMD_MFSL) += cmd_mfsl.o
 COBJS-$(CONFIG_MII) += miiphyutil.o
 COBJS-$(CONFIG_CMD_MII) += miiphyutil.o
 COBJS-$(CONFIG_PHYLIB) += miiphyutil.o
 COBJS-$(CONFIG_CMD_MII) += cmd_mii.o
 ifdef CONFIG_PHYLIB
 COBJS-$(CONFIG_CMD_MII) += cmd_mdio.o
 endif
 COBJS-$(CONFIG_CMD_MISC) += cmd_misc.o
 COBJS-$(CONFIG_CMD_MMC) += cmd_mmc.o
 COBJS-$(CONFIG_CMD_MMC_SPI) += cmd_mmc_spi.o
 COBJS-$(CONFIG_MP) += cmd_mp.o
 COBJS-$(CONFIG_CMD_MTDPARTS) += cmd_mtdparts.o
 COBJS-$(CONFIG_CMD_NAND) += cmd_nand.o
 COBJS-$(CONFIG_CMD_NET) += cmd_net.o
 COBJS-$(CONFIG_CMD_ONENAND) += cmd_onenand.o
 COBJS-$(CONFIG_CMD_OTP) += cmd_otp.o
 COBJS-$(CONFIG_CMD_PART) += cmd_part.o
 ifdef CONFIG_PCI
 COBJS-$(CONFIG_CMD_PCI) += cmd_pci.o
 endif
 COBJS-y += cmd_pcmcia.o
 COBJS-$(CONFIG_CMD_PORTIO) += cmd_portio.o
 COBJS-$(CONFIG_CMD_PXE) += cmd_pxe.o
 COBJS-$(CONFIG_CMD_READ) += cmd_read.o
 COBJS-$(CONFIG_CMD_REGINFO) += cmd_reginfo.o
 COBJS-$(CONFIG_CMD_REISER) += cmd_reiser.o
 COBJS-$(CONFIG_SANDBOX) += cmd_sandbox.o
 COBJS-$(CONFIG_CMD_SATA) += cmd_sata.o
 COBJS-$(CONFIG_CMD_SF) += cmd_sf.o
 COBJS-$(CONFIG_CMD_SCSI) += cmd_scsi.o
 COBJS-$(CONFIG_CMD_SHA1SUM) += cmd_sha1sum.o
 COBJS-$(CONFIG_CMD_SETEXPR) += cmd_setexpr.o
 COBJS-$(CONFIG_CMD_SPI) += cmd_spi.o
 COBJS-$(CONFIG_CMD_SPIBOOTLDR) += cmd_spibootldr.o
 COBJS-$(CONFIG_CMD_STRINGS) += cmd_strings.o
 COBJS-$(CONFIG_CMD_TERMINAL) += cmd_terminal.o
 COBJS-$(CONFIG_CMD_TIME) += cmd_time.o
 COBJS-$(CONFIG_SYS_HUSH_PARSER) += cmd_test.o
 COBJS-$(CONFIG_CMD_TPM) += cmd_tpm.o
 COBJS-$(CONFIG_CMD_TSI148) += cmd_tsi148.o
 COBJS-$(CONFIG_CMD_UBI) += cmd_ubi.o
 COBJS-$(CONFIG_CMD_UBIFS) += cmd_ubifs.o
 COBJS-$(CONFIG_CMD_UNIVERSE) += cmd_universe.o
 COBJS-$(CONFIG_CMD_UNZIP) += cmd_unzip.o
 ifdef CONFIG_CMD_USB
 COBJS-y += cmd_usb.o
 COBJS-y += usb.o usb_hub.o
 COBJS-$(CONFIG_USB_STORAGE) += usb_storage.o
 endif
 COBJS-$(CONFIG_CMD_USB_MASS_STORAGE) += cmd_usb_mass_storage.o
 COBJS-$(CONFIG_CMD_XIMG) += cmd_ximg.o
 COBJS-$(CONFIG_YAFFS2) += cmd_yaffs2.o
 COBJS-$(CONFIG_CMD_SPL) += cmd_spl.o
 COBJS-$(CONFIG_CMD_ZIP) += cmd_zip.o
 COBJS-$(CONFIG_CMD_ZFS) += cmd_zfs.o
 # others
 ifdef CONFIG_DDR_SPD
 SPD := y
 endif
 ifdef CONFIG_SPD_EEPROM
 SPD := y
 endif
 COBJS-$(SPD) += ddr_spd.o
 COBJS-$(CONFIG_HWCONFIG) += hwconfig.o
 COBJS-$(CONFIG_BOOTSTAGE) += bootstage.o
 COBJS-$(CONFIG_CONSOLE_MUX) += iomux.o
 COBJS-y += flash.o
 COBJS-$(CONFIG_CMD_KGDB) += kgdb.o kgdb_stubs.o
 COBJS-$(CONFIG_I2C_EDID) += edid.o
 COBJS-$(CONFIG_KALLSYMS) += kallsyms.o
 COBJS-$(CONFIG_LCD) += lcd.o
 COBJS-$(CONFIG_LYNXKDI) += lynxkdi.o
 COBJS-$(CONFIG_MENU) += menu.o
 COBJS-$(CONFIG_MODEM_SUPPORT) += modem.o
 COBJS-$(CONFIG_UPDATE_TFTP) += update.o
 COBJS-$(CONFIG_USB_KEYBOARD) += usb_kbd.o
 COBJS-$(CONFIG_CMD_DFU) += cmd_dfu.o
 COBJS-$(CONFIG_CMD_GPT) += cmd_gpt.o
 endif
 ifdef CONFIG_SPL_BUILD
 COBJS-y += cmd_nvedit.o
 COBJS-y += env_common.o
 COBJS-$(CONFIG_ENV_IS_IN_FLASH) += env_flash.o
 COBJS-$(CONFIG_SPL_YMODEM_SUPPORT) += xyzModem.o
 COBJS-$(CONFIG_SPL_NET_SUPPORT) += cmd_nvedit.o
 COBJS-$(CONFIG_SPL_NET_SUPPORT) += env_attr.o
 COBJS-$(CONFIG_SPL_NET_SUPPORT) += env_callback.o
 COBJS-$(CONFIG_SPL_NET_SUPPORT) += env_common.o
 COBJS-$(CONFIG_SPL_NET_SUPPORT) += env_flags.o
 COBJS-$(CONFIG_SPL_NET_SUPPORT) += env_nowhere.o
 COBJS-$(CONFIG_SPL_NET_SUPPORT) += miiphyutil.o
 endif
 COBJS-$(CONFIG_BOUNCE_BUFFER) += bouncebuf.o
 COBJS-y += console.o
 COBJS-y += dlmalloc.o
 COBJS-y += image.o
 COBJS-y += memsize.o
 COBJS-y += stdio.o
 COBJS	:= $(sort $(COBJS-y))
 XCOBJS	:= $(sort $(XCOBJS-y))
 SRCS	:= $(COBJS:.o=.c) $(XCOBJS:.o=.c)
 OBJS	:= $(addprefix $(obj),$(COBJS))
 XOBJS	:= $(addprefix $(obj),$(XCOBJS))
 CPPFLAGS += -I..
 all:	$(LIB) $(XOBJS)
 $(LIB): $(obj).depend $(OBJS)
 	$(call cmd_link_o_target, $(OBJS))
 $(obj)env_embedded.o: $(src)env_embedded.c $(obj)../tools/envcrc
 	$(CC) $(AFLAGS) -Wa,--no-warn \
 		-DENV_CRC=$(shell $(obj)../tools/envcrc) \
 		-c -o $@ $(src)env_embedded.c
 $(obj)../tools/envcrc:
 	$(MAKE) -C ../tools
 # SEE README.arm-unaligned-accesses
 $(obj)hush.o: CFLAGS += $(PLATFORM_NO_UNALIGNED)
 $(obj)fdt_support.o: CFLAGS += $(PLATFORM_NO_UNALIGNED)
 #########################################################################
 # defines $(obj).depend target
 include $(SRCTREE)/rules.mk
 sinclude $(obj).depend
 #########################################################################

common/cmd_bootmenu.c

Diff comments View file @ 5644369

File was created	1	/*
	2	* (C) Copyright 2011-2013 Pali Rohár <pali.rohar@gmail.com>
	3	*
	4	* See file CREDITS for list of people who contributed to this
	5	* project.
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License as
	9	* published by the Free Software Foundation; either version 2 of
	10	* the License, or (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	20	* MA 02111-1307 USA
	21	*/
	22
	23	#include <common.h>
	24	#include <command.h>
	25	#include <ansi.h>
	26	#include <menu.h>
	27	#include <hush.h>
	28	#include <watchdog.h>
	29	#include <malloc.h>
	30	#include <linux/string.h>
	31
	32	/* maximum bootmenu entries */
	33	#define MAX_COUNT 99
	34
	35	/* maximal size of bootmenu env
	36	* 9 = strlen("bootmenu_")
	37	* 2 = strlen(MAX_COUNT)
	38	* 1 = NULL term
	39	*/
	40	#define MAX_ENV_SIZE (9 + 2 + 1)
	41
	42	struct bootmenu_entry {
	43	unsigned short int num; /* unique number 0 .. MAX_COUNT */
	44	char key[3]; /* key identifier of number */
	45	char title; / title of entry */
	46	char command; / hush command of entry */
	47	struct bootmenu_data menu; / this bootmenu */
	48	struct bootmenu_entry next; / next menu entry (num+1) */
	49	};
	50
	51	struct bootmenu_data {
	52	int delay; /* delay for autoboot */
	53	int active; /* active menu entry */
	54	int count; /* total count of menu entries */
	55	struct bootmenu_entry first; / first menu entry */
	56	};
	57
	58	enum bootmenu_key {
	59	KEY_NONE = 0,
	60	KEY_UP,
	61	KEY_DOWN,
	62	KEY_SELECT,
	63	};
	64
	65	static char *bootmenu_getoption(unsigned short int n)
	66	{
	67	char name[MAX_ENV_SIZE] = "bootmenu_";
	68
	69	if (n > MAX_COUNT)
	70	return NULL;
	71
	72	sprintf(name + 9, "%d", n);
	73	return getenv(name);
	74	}
	75
	76	static void bootmenu_print_entry(void *data)
	77	{
	78	struct bootmenu_entry *entry = data;
	79	int reverse = (entry->menu->active == entry->num);
	80
	81	/*
	82	* Move cursor to line where the entry will be drown (entry->num)
	83	* First 3 lines contain bootmenu header + 1 empty line
	84	*/
	85	printf(ANSI_CURSOR_POSITION, entry->num + 4, 1);
	86
	87	puts(" ");
	88
	89	if (reverse)
	90	puts(ANSI_COLOR_REVERSE);
	91
	92	puts(entry->title);
	93
	94	if (reverse)
	95	puts(ANSI_COLOR_RESET);
	96	}
	97
	98	static void bootmenu_autoboot_loop(struct bootmenu_data *menu,
	99	enum bootmenu_key key, int esc)
	100	{
	101	int i, c;
	102
	103	if (menu->delay > 0) {
	104	printf(ANSI_CURSOR_POSITION, menu->count + 5, 1);
	105	printf(" Hit any key to stop autoboot: %2d ", menu->delay);
	106	}
	107
	108	while (menu->delay > 0) {
	109	for (i = 0; i < 100; ++i) {
	110	if (!tstc()) {
	111	WATCHDOG_RESET();
	112	mdelay(10);
	113	continue;
	114	}
	115
	116	menu->delay = -1;
	117	c = getc();
	118
	119	switch (c) {
	120	case '\e':
	121	*esc = 1;
	122	*key = KEY_NONE;
	123	break;
	124	case '\r':
	125	*key = KEY_SELECT;
	126	break;
	127	default:
	128	*key = KEY_NONE;
	129	break;
	130	}
	131
	132	break;
	133	}
	134
	135	if (menu->delay < 0)
	136	break;
	137
	138	--menu->delay;
	139	printf("\b\b\b%2d ", menu->delay);
	140	}
	141
	142	printf(ANSI_CURSOR_POSITION, menu->count + 5, 1);
	143	puts(ANSI_CLEAR_LINE);
	144
	145	if (menu->delay == 0)
	146	*key = KEY_SELECT;
	147	}
	148
	149	static void bootmenu_loop(struct bootmenu_data *menu,
	150	enum bootmenu_key key, int esc)
	151	{
	152	int c;
	153
	154	while (!tstc()) {
	155	WATCHDOG_RESET();
	156	mdelay(10);
	157	}
	158
	159	c = getc();
	160
	161	switch (*esc) {
	162	case 0:
	163	/* First char of ANSI escape sequence '\e' */
	164	if (c == '\e') {
	165	*esc = 1;
	166	*key = KEY_NONE;
	167	}
	168	break;
	169	case 1:
	170	/* Second char of ANSI '[' */
	171	if (c == '[') {
	172	*esc = 2;
	173	*key = KEY_NONE;
	174	} else {
	175	*esc = 0;
	176	}
	177	break;
	178	case 2:
	179	case 3:
	180	/* Third char of ANSI (number '1') - optional */
	181	if (*esc == 2 && c == '1') {
	182	*esc = 3;
	183	*key = KEY_NONE;
	184	break;
	185	}
	186
	187	*esc = 0;
	188
	189	/* ANSI 'A' - key up was pressed */
	190	if (c == 'A')
	191	*key = KEY_UP;
	192	/* ANSI 'B' - key down was pressed */
	193	else if (c == 'B')
	194	*key = KEY_DOWN;
	195	/* other key was pressed */
	196	else
	197	*key = KEY_NONE;
	198
	199	break;
	200	}
	201
	202	/* enter key was pressed */
	203	if (c == '\r')
	204	*key = KEY_SELECT;
	205	}
	206
	207	static char bootmenu_choice_entry(void data)
	208	{
	209	struct bootmenu_data *menu = data;
	210	struct bootmenu_entry *iter;
	211	enum bootmenu_key key = KEY_NONE;
	212	int esc = 0;
	213	int i;
	214
	215	while (1) {
	216	if (menu->delay >= 0) {
	217	/* Autoboot was not stopped */
	218	bootmenu_autoboot_loop(menu, &key, &esc);
	219	} else {
	220	/* Some key was pressed, so autoboot was stopped */
	221	bootmenu_loop(menu, &key, &esc);
	222	}
	223
	224	switch (key) {
	225	case KEY_UP:
	226	if (menu->active > 0)
	227	--menu->active;
	228	/* no menu key selected, regenerate menu */
	229	return NULL;
	230	case KEY_DOWN:
	231	if (menu->active < menu->count - 1)
	232	++menu->active;
	233	/* no menu key selected, regenerate menu */
	234	return NULL;
	235	case KEY_SELECT:
	236	iter = menu->first;
	237	for (i = 0; i < menu->active; ++i)
	238	iter = iter->next;
	239	return iter->key;
	240	default:
	241	break;
	242	}
	243	}
	244
	245	/* never happens */
	246	debug("bootmenu: this should not happen");
	247	return NULL;
	248	}
	249
	250	static void bootmenu_destroy(struct bootmenu_data *menu)
	251	{
	252	struct bootmenu_entry *iter = menu->first;
	253	struct bootmenu_entry *next;
	254
	255	while (iter) {
	256	next = iter->next;
	257	free(iter->title);
	258	free(iter->command);
	259	free(iter);
	260	iter = next;
	261	}
	262	free(menu);
	263	}
	264
	265	static struct bootmenu_data *bootmenu_create(int delay)
	266	{
	267	unsigned short int i = 0;
	268	const char *option;
	269	struct bootmenu_data *menu;
	270	struct bootmenu_entry *iter = NULL;
	271
	272	int len;
	273	char *sep;
	274	struct bootmenu_entry *entry;
	275
	276	menu = malloc(sizeof(struct bootmenu_data));
	277	if (!menu)
	278	return NULL;
	279
	280	menu->delay = delay;
	281	menu->active = 0;
	282	menu->first = NULL;
	283
	284	while ((option = bootmenu_getoption(i))) {
	285	sep = strchr(option, '=');
	286	if (!sep) {
	287	printf("Invalid bootmenu entry: %s\n", option);
	288	break;
	289	}
	290
	291	entry = malloc(sizeof(struct bootmenu_entry));
	292	if (!entry)
	293	goto cleanup;
	294
	295	len = sep-option;
	296	entry->title = malloc(len + 1);
	297	if (!entry->title) {
	298	free(entry);
	299	goto cleanup;
	300	}
	301	memcpy(entry->title, option, len);
	302	entry->title[len] = 0;
	303
	304	len = strlen(sep + 1);
	305	entry->command = malloc(len + 1);
	306	if (!entry->command) {
	307	free(entry->title);
	308	free(entry);
	309	goto cleanup;
	310	}
	311	memcpy(entry->command, sep + 1, len);
	312	entry->command[len] = 0;
	313
	314	sprintf(entry->key, "%d", i);
	315
	316	entry->num = i;
	317	entry->menu = menu;
	318	entry->next = NULL;
	319
	320	if (!iter)
	321	menu->first = entry;
	322	else
	323	iter->next = entry;
	324
	325	iter = entry;
	326	++i;
	327
	328	if (i == MAX_COUNT - 1)
	329	break;
	330	}
	331
	332	/* Add U-Boot console entry at the end */
	333	if (i <= MAX_COUNT - 1) {
	334	entry = malloc(sizeof(struct bootmenu_entry));
	335	if (!entry)
	336	goto cleanup;
	337
	338	entry->title = strdup("U-Boot console");
	339	if (!entry->title) {
	340	free(entry);
	341	goto cleanup;
	342	}
	343
	344	entry->command = strdup("");
	345	if (!entry->command) {
	346	free(entry->title);
	347	free(entry);
	348	goto cleanup;
	349	}
	350
	351	sprintf(entry->key, "%d", i);
	352
	353	entry->num = i;
	354	entry->menu = menu;
	355	entry->next = NULL;
	356
	357	if (!iter)
	358	menu->first = entry;
	359	else
	360	iter->next = entry;
	361
	362	iter = entry;
	363	++i;
	364	}
	365
	366	menu->count = i;
	367	return menu;
	368
	369	cleanup:
	370	bootmenu_destroy(menu);
	371	return NULL;
	372	}
	373
	374	static void bootmenu_show(int delay)
	375	{
	376	int init = 0;
	377	void *choice = NULL;
	378	char *title = NULL;
	379	char *command = NULL;
	380	struct menu *menu;
	381	struct bootmenu_data *bootmenu;
	382	struct bootmenu_entry *iter;
	383	char option, sep;
	384
	385	/* If delay is 0 do not create menu, just run first entry */
	386	if (delay == 0) {
	387	option = bootmenu_getoption(0);
	388	if (!option) {
	389	puts("bootmenu option 0 was not found\n");
	390	return;
	391	}
	392	sep = strchr(option, '=');
	393	if (!sep) {
	394	puts("bootmenu option 0 is invalid\n");
	395	return;
	396	}
	397	run_command(sep+1, 0);
	398	return;
	399	}
	400
	401	bootmenu = bootmenu_create(delay);
	402	if (!bootmenu)
	403	return;
	404
	405	menu = menu_create(NULL, bootmenu->delay, 1, bootmenu_print_entry,
	406	bootmenu_choice_entry, bootmenu);
	407	if (!menu) {
	408	bootmenu_destroy(bootmenu);
	409	return;
	410	}
	411
	412	for (iter = bootmenu->first; iter; iter = iter->next) {
	413	if (!menu_item_add(menu, iter->key, iter))
	414	goto cleanup;
	415	}
	416
	417	/* Default menu entry is always first */
	418	menu_default_set(menu, "0");
	419
	420	puts(ANSI_CURSOR_HIDE);
	421	puts(ANSI_CLEAR_CONSOLE);
	422	printf(ANSI_CURSOR_POSITION, 1, 1);
	423
	424	init = 1;
	425
	426	if (menu_get_choice(menu, &choice)) {
	427	iter = choice;
	428	title = strdup(iter->title);
	429	command = strdup(iter->command);
	430	}
	431
	432	cleanup:
	433	menu_destroy(menu);
	434	bootmenu_destroy(bootmenu);
	435
	436	if (init) {
	437	puts(ANSI_CURSOR_SHOW);
	438	puts(ANSI_CLEAR_CONSOLE);
	439	printf(ANSI_CURSOR_POSITION, 1, 1);
	440	}
	441
	442	if (title && command) {
	443	debug("Starting entry '%s'\n", title);
	444	free(title);
	445	run_command(command, 0);
	446	free(command);
	447	}
	448
	449	#ifdef CONFIG_POSTBOOTMENU
	450	run_command(CONFIG_POSTBOOTMENU, 0);
	451	#endif
	452	}
	453
	454	void menu_display_statusline(struct menu *m)
	455	{
	456	struct bootmenu_entry *entry;
	457	struct bootmenu_data *menu;
	458
	459	if (menu_default_choice(m, (void *)&entry) < 0)
	460	return;
	461
	462	menu = entry->menu;
	463
	464	printf(ANSI_CURSOR_POSITION, 1, 1);
	465	puts(ANSI_CLEAR_LINE);
	466	printf(ANSI_CURSOR_POSITION, 2, 1);
	467	puts(" * U-Boot Boot Menu *");
	468	puts(ANSI_CLEAR_LINE_TO_END);
	469	printf(ANSI_CURSOR_POSITION, 3, 1);
	470	puts(ANSI_CLEAR_LINE);
	471
	472	/* First 3 lines are bootmenu header + 2 empty lines between entries */
	473	printf(ANSI_CURSOR_POSITION, menu->count + 5, 1);
	474	puts(ANSI_CLEAR_LINE);
	475	printf(ANSI_CURSOR_POSITION, menu->count + 6, 1);
	476	puts(" Press UP/DOWN to move, ENTER to select");
	477	puts(ANSI_CLEAR_LINE_TO_END);
	478	printf(ANSI_CURSOR_POSITION, menu->count + 7, 1);
	479	puts(ANSI_CLEAR_LINE);
	480	}
	481
	482	#ifdef CONFIG_MENU_SHOW
	483	int menu_show(int bootdelay)
	484	{
	485	bootmenu_show(bootdelay);
	486	return -1; /* -1 - abort boot and run monitor code */
	487	}
	488	#endif
	489
	490	int do_bootmenu(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
	491	{
	492	char *delay_str = NULL;
	493	int delay = 10;
	494
	495	#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
	496	delay = CONFIG_BOOTDELAY;
	497	#endif
	498
	499	if (argc >= 2)
	500	delay_str = argv[1];
	501
	502	if (!delay_str)
	503	delay_str = getenv("bootmenu_delay");
	504
	505	if (delay_str)
	506	delay = (int)simple_strtol(delay_str, NULL, 10);
	507
	508	bootmenu_show(delay);
	509	return 0;
	510	}
	511
	512	U_BOOT_CMD(
	513	bootmenu, 2, 1, do_bootmenu,
	514	"ANSI terminal bootmenu",
	515	"[delay]\n"
	516	" - show ANSI terminal bootmenu with autoboot delay"
	517	);
	518

common/cmd_pxe.c

Diff comments View file @ 5644369

 /*
  * Copyright 2010-2011 Calxeda, Inc.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
  * Software Foundation; either version 2 of the License, or (at your option)
  * any later version.
  *
  * This program is distributed in the hope it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  * more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <common.h>
 #include <command.h>
 #include <malloc.h>
 #include <linux/string.h>
 #include <linux/ctype.h>
 #include <errno.h>
 #include <linux/list.h>
 #include "menu.h"
 #define MAX_TFTP_PATH_LEN 127
 /*
  * Like getenv, but prints an error if envvar isn't defined in the
  * environment.  It always returns what getenv does, so it can be used in
  * place of getenv without changing error handling otherwise.
  */
 static char *from_env(char *envvar)
 {
 	char *ret;
 	ret = getenv(envvar);
 	if (!ret)
 		printf("missing environment variable: %s\n", envvar);
 	return ret;
 }
 /*
  * Convert an ethaddr from the environment to the format used by pxelinux
  * filenames based on mac addresses. Convert's ':' to '-', and adds "01-" to
  * the beginning of the ethernet address to indicate a hardware type of
  * Ethernet. Also converts uppercase hex characters into lowercase, to match
  * pxelinux's behavior.
  *
  * Returns 1 for success, -ENOENT if 'ethaddr' is undefined in the
  * environment, or some other value < 0 on error.
  */
 static int format_mac_pxe(char *outbuf, size_t outbuf_len)
 {
 	size_t ethaddr_len;
 	char *p, *ethaddr;
 	ethaddr = from_env("ethaddr");
 	if (!ethaddr)
 		return -ENOENT;
 	ethaddr_len = strlen(ethaddr);
 	/*
 	 * ethaddr_len + 4 gives room for "01-", ethaddr, and a NUL byte at
 	 * the end.
 	 */
 	if (outbuf_len < ethaddr_len + 4) {
 		printf("outbuf is too small (%d < %d)\n",
 				outbuf_len, ethaddr_len + 4);
 		return -EINVAL;
 	}
 	strcpy(outbuf, "01-");
 	for (p = outbuf + 3; *ethaddr; ethaddr++, p++) {
 		if (*ethaddr == ':')
 			*p = '-';
 		else
 			*p = tolower(*ethaddr);
 	}
 	*p = '\0';
 	return 1;
 }
 /*
  * Returns the directory the file specified in the bootfile env variable is
  * in. If bootfile isn't defined in the environment, return NULL, which should
  * be interpreted as "don't prepend anything to paths".
  */
 static int get_bootfile_path(const char *file_path, char *bootfile_path,
 			     size_t bootfile_path_size)
 {
 	char *bootfile, *last_slash;
 	size_t path_len = 0;
 	if (file_path[0] == '/')
 		goto ret;
 	bootfile = from_env("bootfile");
 	if (!bootfile)
 		goto ret;
 	last_slash = strrchr(bootfile, '/');
 	if (last_slash == NULL)
 		goto ret;
 	path_len = (last_slash - bootfile) + 1;
 	if (bootfile_path_size < path_len) {
 		printf("bootfile_path too small. (%d < %d)\n",
 				bootfile_path_size, path_len);
 		return -1;
 	}
 	strncpy(bootfile_path, bootfile, path_len);
  ret:
 	bootfile_path[path_len] = '\0';
 	return 1;
 }
 static int (*do_getfile)(char *file_path, char *file_addr);
 static int do_get_tftp(char *file_path, char *file_addr)
 {
 	char *tftp_argv[] = {"tftp", NULL, NULL, NULL};
 	tftp_argv[1] = file_addr;
 	tftp_argv[2] = file_path;
 	if (do_tftpb(NULL, 0, 3, tftp_argv))
 		return -ENOENT;
 	return 1;
 }
 static char *fs_argv[5];
 static int do_get_ext2(char *file_path, char *file_addr)
 {
 #ifdef CONFIG_CMD_EXT2
 	fs_argv[0] = "ext2load";
 	fs_argv[3] = file_addr;
 	fs_argv[4] = file_path;
 	if (!do_ext2load(NULL, 0, 5, fs_argv))
 		return 1;
 #endif
 	return -ENOENT;
 }
 static int do_get_fat(char *file_path, char *file_addr)
 {
 #ifdef CONFIG_CMD_FAT
 	fs_argv[0] = "fatload";
 	fs_argv[3] = file_addr;
 	fs_argv[4] = file_path;
 	if (!do_fat_fsload(NULL, 0, 5, fs_argv))
 		return 1;
 #endif
 	return -ENOENT;
 }
 /*
  * As in pxelinux, paths to files referenced from files we retrieve are
  * relative to the location of bootfile. get_relfile takes such a path and
  * joins it with the bootfile path to get the full path to the target file. If
  * the bootfile path is NULL, we use file_path as is.
  *
  * Returns 1 for success, or < 0 on error.
  */
 static int get_relfile(char *file_path, void *file_addr)
 {
 	size_t path_len;
 	char relfile[MAX_TFTP_PATH_LEN+1];
 	char addr_buf[10];
 	int err;
 	err = get_bootfile_path(file_path, relfile, sizeof(relfile));
 	if (err < 0)
 		return err;
 	path_len = strlen(file_path);
 	path_len += strlen(relfile);
 	if (path_len > MAX_TFTP_PATH_LEN) {
 		printf("Base path too long (%s%s)\n",
 					relfile,
 					file_path);
 		return -ENAMETOOLONG;
 	}
 	strcat(relfile, file_path);
 	printf("Retrieving file: %s\n", relfile);
 	sprintf(addr_buf, "%p", file_addr);
 	return do_getfile(relfile, addr_buf);
 }
 /*
  * Retrieve the file at 'file_path' to the locate given by 'file_addr'. If
  * 'bootfile' was specified in the environment, the path to bootfile will be
  * prepended to 'file_path' and the resulting path will be used.
  *
  * Returns 1 on success, or < 0 for error.
  */
 static int get_pxe_file(char *file_path, void *file_addr)
 {
 	unsigned long config_file_size;
 	char *tftp_filesize;
 	int err;
 	err = get_relfile(file_path, file_addr);
 	if (err < 0)
 		return err;
 	/*
 	 * the file comes without a NUL byte at the end, so find out its size
 	 * and add the NUL byte.
 	 */
 	tftp_filesize = from_env("filesize");
 	if (!tftp_filesize)
 		return -ENOENT;
 	if (strict_strtoul(tftp_filesize, 16, &config_file_size) < 0)
 		return -EINVAL;
 	*(char *)(file_addr + config_file_size) = '\0';
 	return 1;
 }
 #define PXELINUX_DIR "pxelinux.cfg/"
 /*
  * Retrieves a file in the 'pxelinux.cfg' folder. Since this uses get_pxe_file
  * to do the hard work, the location of the 'pxelinux.cfg' folder is generated
  * from the bootfile path, as described above.
  *
  * Returns 1 on success or < 0 on error.
  */
 static int get_pxelinux_path(char *file, void *pxefile_addr_r)
 {
 	size_t base_len = strlen(PXELINUX_DIR);
 	char path[MAX_TFTP_PATH_LEN+1];
 	if (base_len + strlen(file) > MAX_TFTP_PATH_LEN) {
 		printf("path (%s%s) too long, skipping\n",
 				PXELINUX_DIR, file);
 		return -ENAMETOOLONG;
 	}
 	sprintf(path, PXELINUX_DIR "%s", file);
 	return get_pxe_file(path, pxefile_addr_r);
 }
 /*
  * Looks for a pxe file with a name based on the pxeuuid environment variable.
  *
  * Returns 1 on success or < 0 on error.
  */
 static int pxe_uuid_path(void *pxefile_addr_r)
 {
 	char *uuid_str;
 	uuid_str = from_env("pxeuuid");
 	if (!uuid_str)
 		return -ENOENT;
 	return get_pxelinux_path(uuid_str, pxefile_addr_r);
 }
 /*
  * Looks for a pxe file with a name based on the 'ethaddr' environment
  * variable.
  *
  * Returns 1 on success or < 0 on error.
  */
 static int pxe_mac_path(void *pxefile_addr_r)
 {
 	char mac_str[21];
 	int err;
 	err = format_mac_pxe(mac_str, sizeof(mac_str));
 	if (err < 0)
 		return err;
 	return get_pxelinux_path(mac_str, pxefile_addr_r);
 }
 /*
  * Looks for pxe files with names based on our IP address. See pxelinux
  * documentation for details on what these file names look like.  We match
  * that exactly.
  *
  * Returns 1 on success or < 0 on error.
  */
 static int pxe_ipaddr_paths(void *pxefile_addr_r)
 {
 	char ip_addr[9];
 	int mask_pos, err;
 	sprintf(ip_addr, "%08X", ntohl(NetOurIP));
 	for (mask_pos = 7; mask_pos >= 0;  mask_pos--) {
 		err = get_pxelinux_path(ip_addr, pxefile_addr_r);
 		if (err > 0)
 			return err;
 		ip_addr[mask_pos] = '\0';
 	}
 	return -ENOENT;
 }
 /*
  * Entry point for the 'pxe get' command.
  * This Follows pxelinux's rules to download a config file from a tftp server.
  * The file is stored at the location given by the pxefile_addr_r environment
  * variable, which must be set.
  *
  * UUID comes from pxeuuid env variable, if defined
  * MAC addr comes from ethaddr env variable, if defined
  * IP
  *
  * see http://syslinux.zytor.com/wiki/index.php/PXELINUX
  *
  * Returns 0 on success or 1 on error.
  */
 static int
 do_pxe_get(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	char *pxefile_addr_str;
 	unsigned long pxefile_addr_r;
 	int err;
 	do_getfile = do_get_tftp;
 	if (argc != 1)
 		return CMD_RET_USAGE;
 	pxefile_addr_str = from_env("pxefile_addr_r");
 	if (!pxefile_addr_str)
 		return 1;
 	err = strict_strtoul(pxefile_addr_str, 16,
 				(unsigned long *)&pxefile_addr_r);
 	if (err < 0)
 		return 1;
 	/*
 	 * Keep trying paths until we successfully get a file we're looking
 	 * for.
 	 */
 	if (pxe_uuid_path((void *)pxefile_addr_r) > 0
 		|| pxe_mac_path((void *)pxefile_addr_r) > 0
 		|| pxe_ipaddr_paths((void *)pxefile_addr_r) > 0
 		|| get_pxelinux_path("default", (void *)pxefile_addr_r) > 0) {
 		printf("Config file found\n");
 		return 0;
 	}
 	printf("Config file not found\n");
 	return 1;
 }
 /*
  * Wrapper to make it easier to store the file at file_path in the location
  * specified by envaddr_name. file_path will be joined to the bootfile path,
  * if any is specified.
  *
  * Returns 1 on success or < 0 on error.
  */
 static int get_relfile_envaddr(char *file_path, char *envaddr_name)
 {
 	unsigned long file_addr;
 	char *envaddr;
 	envaddr = from_env(envaddr_name);
 	if (!envaddr)
 		return -ENOENT;
 	if (strict_strtoul(envaddr, 16, &file_addr) < 0)
 		return -EINVAL;
 	return get_relfile(file_path, (void *)file_addr);
 }
 /*
  * A note on the pxe file parser.
  *
  * We're parsing files that use syslinux grammar, which has a few quirks.
  * String literals must be recognized based on context - there is no
  * quoting or escaping support. There's also nothing to explicitly indicate
  * when a label section completes. We deal with that by ending a label
  * section whenever we see a line that doesn't include.
  *
  * As with the syslinux family, this same file format could be reused in the
  * future for non pxe purposes. The only action it takes during parsing that
  * would throw this off is handling of include files. It assumes we're using
  * pxe, and does a tftp download of a file listed as an include file in the
  * middle of the parsing operation. That could be handled by refactoring it to
  * take a 'include file getter' function.
  */
 /*
  * Describes a single label given in a pxe file.
  *
  * Create these with the 'label_create' function given below.
  *
  * name - the name of the menu as given on the 'menu label' line.
  * kernel - the path to the kernel file to use for this label.
  * append - kernel command line to use when booting this label
  * initrd - path to the initrd to use for this label.
  * attempted - 0 if we haven't tried to boot this label, 1 if we have.
  * localboot - 1 if this label specified 'localboot', 0 otherwise.
  * list - lets these form a list, which a pxe_menu struct will hold.
  */
 struct pxe_label {
 	char *name;
 	char *menu;
 	char *kernel;
 	char *append;
 	char *initrd;
 	char *fdt;
 	int attempted;
 	int localboot;
 	struct list_head list;
 };
 /*
  * Describes a pxe menu as given via pxe files.
  *
  * title - the name of the menu as given by a 'menu title' line.
  * default_label - the name of the default label, if any.
  * timeout - time in tenths of a second to wait for a user key-press before
  *           booting the default label.
  * prompt - if 0, don't prompt for a choice unless the timeout period is
  *          interrupted.  If 1, always prompt for a choice regardless of
  *          timeout.
  * labels - a list of labels defined for the menu.
  */
 struct pxe_menu {
 	char *title;
 	char *default_label;
 	int timeout;
 	int prompt;
 	struct list_head labels;
 };
 /*
  * Allocates memory for and initializes a pxe_label. This uses malloc, so the
  * result must be free()'d to reclaim the memory.
  *
  * Returns NULL if malloc fails.
  */
 static struct pxe_label *label_create(void)
 {
 	struct pxe_label *label;
 	label = malloc(sizeof(struct pxe_label));
 	if (!label)
 		return NULL;
 	memset(label, 0, sizeof(struct pxe_label));
 	return label;
 }
 /*
  * Free the memory used by a pxe_label, including that used by its name,
  * kernel, append and initrd members, if they're non NULL.
  *
  * So - be sure to only use dynamically allocated memory for the members of
  * the pxe_label struct, unless you want to clean it up first. These are
  * currently only created by the pxe file parsing code.
  */
 static void label_destroy(struct pxe_label *label)
 {
 	if (label->name)
 		free(label->name);
 	if (label->kernel)
 		free(label->kernel);
 	if (label->append)
 		free(label->append);
 	if (label->initrd)
 		free(label->initrd);
 	if (label->fdt)
 		free(label->fdt);
 	free(label);
 }
 /*
  * Print a label and its string members if they're defined.
  *
  * This is passed as a callback to the menu code for displaying each
  * menu entry.
  */
 static void label_print(void *data)
 {
 	struct pxe_label *label = data;
 	const char *c = label->menu ? label->menu : label->kernel;
 	printf("%s:\t%s\n", label->name, c);
 	if (label->kernel)
 		printf("\t\tkernel: %s\n", label->kernel);
 	if (label->append)
 		printf("\t\tappend: %s\n", label->append);
 	if (label->initrd)
 		printf("\t\tinitrd: %s\n", label->initrd);
 	if (label->fdt)
 		printf("\tfdt: %s\n", label->fdt);
 }
 /*
  * Boot a label that specified 'localboot'. This requires that the 'localcmd'
  * environment variable is defined. Its contents will be executed as U-boot
  * command.  If the label specified an 'append' line, its contents will be
  * used to overwrite the contents of the 'bootargs' environment variable prior
  * to running 'localcmd'.
  *
  * Returns 1 on success or < 0 on error.
  */
 static int label_localboot(struct pxe_label *label)
 {
 	char *localcmd;
 	localcmd = from_env("localcmd");
 	if (!localcmd)
 		return -ENOENT;
 	if (label->append)
 		setenv("bootargs", label->append);
 	debug("running: %s\n", localcmd);
 	return run_command_list(localcmd, strlen(localcmd), 0);
 }
 /*
  * Boot according to the contents of a pxe_label.
  *
  * If we can't boot for any reason, we return.  A successful boot never
  * returns.
  *
  * The kernel will be stored in the location given by the 'kernel_addr_r'
  * environment variable.
  *
  * If the label specifies an initrd file, it will be stored in the location
  * given by the 'ramdisk_addr_r' environment variable.
  *
  * If the label specifies an 'append' line, its contents will overwrite that
  * of the 'bootargs' environment variable.
  */
 static void label_boot(struct pxe_label *label)
 {
 	char *bootm_argv[] = { "bootm", NULL, NULL, NULL, NULL };
 	int bootm_argc = 3;
 	label_print(label);
 	label->attempted = 1;
 	if (label->localboot) {
 		label_localboot(label);
 		return;
 	}
 	if (label->kernel == NULL) {
 		printf("No kernel given, skipping %s\n",
 				label->name);
 		return;
 	}
 	if (label->initrd) {
 		if (get_relfile_envaddr(label->initrd, "ramdisk_addr_r") < 0) {
 			printf("Skipping %s for failure retrieving initrd\n",
 					label->name);
 			return;
 		}
 		bootm_argv[2] = getenv("ramdisk_addr_r");
 	} else {
 		bootm_argv[2] = "-";
 	}
 	if (get_relfile_envaddr(label->kernel, "kernel_addr_r") < 0) {
 		printf("Skipping %s for failure retrieving kernel\n",
 				label->name);
 		return;
 	}
 	if (label->append)
 		setenv("bootargs", label->append);
 	bootm_argv[1] = getenv("kernel_addr_r");
 	/*
 	 * fdt usage is optional:
 	 * It handles the following scenarios. All scenarios are exclusive
 	 *
 	 * Scenario 1: If fdt_addr_r specified and "fdt" label is defined in
 	 * pxe file, retrieve fdt blob from server. Pass fdt_addr_r to bootm,
 	 * and adjust argc appropriately.
 	 *
 	 * Scenario 2: If there is an fdt_addr specified, pass it along to
 	 * bootm, and adjust argc appropriately.
 	 *
 	 * Scenario 3: fdt blob is not available.
 	 */
 	bootm_argv[3] = getenv("fdt_addr_r");
 	/* if fdt label is defined then get fdt from server */
 	if (bootm_argv[3] && label->fdt) {
 		if (get_relfile_envaddr(label->fdt, "fdt_addr_r") < 0) {
 			printf("Skipping %s for failure retrieving fdt\n",
 					label->name);
 			return;
 		}
 	} else
 		bootm_argv[3] = getenv("fdt_addr");
 	if (bootm_argv[3])
 		bootm_argc = 4;
 	do_bootm(NULL, 0, bootm_argc, bootm_argv);
 }
 /*
  * Tokens for the pxe file parser.
  */
 enum token_type {
 	T_EOL,
 	T_STRING,
 	T_EOF,
 	T_MENU,
 	T_TITLE,
 	T_TIMEOUT,
 	T_LABEL,
 	T_KERNEL,
 	T_LINUX,
 	T_APPEND,
 	T_INITRD,
 	T_LOCALBOOT,
 	T_DEFAULT,
 	T_PROMPT,
 	T_INCLUDE,
 	T_FDT,
 	T_INVALID
 };
 /*
  * A token - given by a value and a type.
  */
 struct token {
 	char *val;
 	enum token_type type;
 };
 /*
  * Keywords recognized.
  */
 static const struct token keywords[] = {
 	{"menu", T_MENU},
 	{"title", T_TITLE},
 	{"timeout", T_TIMEOUT},
 	{"default", T_DEFAULT},
 	{"prompt", T_PROMPT},
 	{"label", T_LABEL},
 	{"kernel", T_KERNEL},
 	{"linux", T_LINUX},
 	{"localboot", T_LOCALBOOT},
 	{"append", T_APPEND},
 	{"initrd", T_INITRD},
 	{"include", T_INCLUDE},
 	{"fdt", T_FDT},
 	{NULL, T_INVALID}
 };
 /*
  * Since pxe(linux) files don't have a token to identify the start of a
  * literal, we have to keep track of when we're in a state where a literal is
  * expected vs when we're in a state a keyword is expected.
  */
 enum lex_state {
 	L_NORMAL = 0,
 	L_KEYWORD,
 	L_SLITERAL
 };
 /*
  * get_string retrieves a string from *p and stores it as a token in
  * *t.
  *
  * get_string used for scanning both string literals and keywords.
  *
  * Characters from *p are copied into t-val until a character equal to
  * delim is found, or a NUL byte is reached. If delim has the special value of
  * ' ', any whitespace character will be used as a delimiter.
  *
  * If lower is unequal to 0, uppercase characters will be converted to
  * lowercase in the result. This is useful to make keywords case
  * insensitive.
  *
  * The location of *p is updated to point to the first character after the end
  * of the token - the ending delimiter.
  *
  * On success, the new value of t->val is returned. Memory for t->val is
  * allocated using malloc and must be free()'d to reclaim it.  If insufficient
  * memory is available, NULL is returned.
  */
 static char *get_string(char **p, struct token *t, char delim, int lower)
 {
 	char *b, *e;
 	size_t len, i;
 	/*
 	 * b and e both start at the beginning of the input stream.
 	 *
 	 * e is incremented until we find the ending delimiter, or a NUL byte
 	 * is reached. Then, we take e - b to find the length of the token.
 	 */
 	b = e = *p;
 	while (*e) {
 		if ((delim == ' ' && isspace(*e)) || delim == *e)
 			break;
 		e++;
 	}
 	len = e - b;
 	/*
 	 * Allocate memory to hold the string, and copy it in, converting
 	 * characters to lowercase if lower is != 0.
 	 */
 	t->val = malloc(len + 1);
 	if (!t->val)
 		return NULL;
 	for (i = 0; i < len; i++, b++) {
 		if (lower)
 			t->val[i] = tolower(*b);
 		else
 			t->val[i] = *b;
 	}
 	t->val[len] = '\0';
 	/*
 	 * Update *p so the caller knows where to continue scanning.
 	 */
 	*p = e;
 	t->type = T_STRING;
 	return t->val;
 }
 /*
  * Populate a keyword token with a type and value.
  */
 static void get_keyword(struct token *t)
 {
 	int i;
 	for (i = 0; keywords[i].val; i++) {
 		if (!strcmp(t->val, keywords[i].val)) {
 			t->type = keywords[i].type;
 			break;
 		}
 	}
 }
 /*
  * Get the next token.  We have to keep track of which state we're in to know
  * if we're looking to get a string literal or a keyword.
  *
  * *p is updated to point at the first character after the current token.
  */
 static void get_token(char **p, struct token *t, enum lex_state state)
 {
 	char *c = *p;
 	t->type = T_INVALID;
 	/* eat non EOL whitespace */
 	while (isblank(*c))
 		c++;
 	/*
 	 * eat comments. note that string literals can't begin with #, but
 	 * can contain a # after their first character.
 	 */
 	if (*c == '#') {
 		while (*c && *c != '\n')
 			c++;
 	}
 	if (*c == '\n') {
 		t->type = T_EOL;
 		c++;
 	} else if (*c == '\0') {
 		t->type = T_EOF;
 		c++;
 	} else if (state == L_SLITERAL) {
 		get_string(&c, t, '\n', 0);
 	} else if (state == L_KEYWORD) {
 		/*
 		 * when we expect a keyword, we first get the next string
 		 * token delimited by whitespace, and then check if it
 		 * matches a keyword in our keyword list. if it does, it's
 		 * converted to a keyword token of the appropriate type, and
 		 * if not, it remains a string token.
 		 */
 		get_string(&c, t, ' ', 1);
 		get_keyword(t);
 	}
 	*p = c;
 }
 /*
  * Increment *c until we get to the end of the current line, or EOF.
  */
 static void eol_or_eof(char **c)
 {
 	while (**c && **c != '\n')
 		(*c)++;
 }
 /*
  * All of these parse_* functions share some common behavior.
  *
  * They finish with *c pointing after the token they parse, and return 1 on
  * success, or < 0 on error.
  */
 /*
  * Parse a string literal and store a pointer it at *dst. String literals
  * terminate at the end of the line.
  */
 static int parse_sliteral(char **c, char **dst)
 {
 	struct token t;
 	char *s = *c;
 	get_token(c, &t, L_SLITERAL);
 	if (t.type != T_STRING) {
 		printf("Expected string literal: %.*s\n", (int)(*c - s), s);
 		return -EINVAL;
 	}
 	*dst = t.val;
 	return 1;
 }
 /*
  * Parse a base 10 (unsigned) integer and store it at *dst.
  */
 static int parse_integer(char **c, int *dst)
 {
 	struct token t;
 	char *s = *c;
 	unsigned long temp;
 	get_token(c, &t, L_SLITERAL);
 	if (t.type != T_STRING) {
 		printf("Expected string: %.*s\n", (int)(*c - s), s);
 		return -EINVAL;
 	}
 	if (strict_strtoul(t.val, 10, &temp) < 0) {
 		printf("Expected unsigned integer: %s\n", t.val);
 		return -EINVAL;
 	}
 	*dst = (int)temp;
 	free(t.val);
 	return 1;
 }
 static int parse_pxefile_top(char *p, struct pxe_menu *cfg, int nest_level);
 /*
  * Parse an include statement, and retrieve and parse the file it mentions.
  *
  * base should point to a location where it's safe to store the file, and
  * nest_level should indicate how many nested includes have occurred. For this
  * include, nest_level has already been incremented and doesn't need to be
  * incremented here.
  */
 static int handle_include(char **c, char *base,
 				struct pxe_menu *cfg, int nest_level)
 {
 	char *include_path;
 	char *s = *c;
 	int err;
 	err = parse_sliteral(c, &include_path);
 	if (err < 0) {
 		printf("Expected include path: %.*s\n",
 				 (int)(*c - s), s);
 		return err;
 	}
 	err = get_pxe_file(include_path, base);
 	if (err < 0) {
 		printf("Couldn't retrieve %s\n", include_path);
 		return err;
 	}
 	return parse_pxefile_top(base, cfg, nest_level);
 }
 /*
  * Parse lines that begin with 'menu'.
  *
  * b and nest are provided to handle the 'menu include' case.
  *
  * b should be the address where the file currently being parsed is stored.
  *
  * nest_level should be 1 when parsing the top level pxe file, 2 when parsing
  * a file it includes, 3 when parsing a file included by that file, and so on.
  */
 static int parse_menu(char **c, struct pxe_menu *cfg, char *b, int nest_level)
 {
 	struct token t;
 	char *s = *c;
 	int err = 0;
 	get_token(c, &t, L_KEYWORD);
 	switch (t.type) {
 	case T_TITLE:
 		err = parse_sliteral(c, &cfg->title);
 		break;
 	case T_INCLUDE:
 		err = handle_include(c, b + strlen(b) + 1, cfg,
 						nest_level + 1);
 		break;
 	default:
 		printf("Ignoring malformed menu command: %.*s\n",
 				(int)(*c - s), s);
 	}
 	if (err < 0)
 		return err;
 	eol_or_eof(c);
 	return 1;
 }
 /*
  * Handles parsing a 'menu line' when we're parsing a label.
  */
 static int parse_label_menu(char **c, struct pxe_menu *cfg,
 				struct pxe_label *label)
 {
 	struct token t;
 	char *s;
 	s = *c;
 	get_token(c, &t, L_KEYWORD);
 	switch (t.type) {
 	case T_DEFAULT:
 		if (cfg->default_label)
 			free(cfg->default_label);
 		cfg->default_label = strdup(label->name);
 		if (!cfg->default_label)
 			return -ENOMEM;
 		break;
 	case T_LABEL:
 		parse_sliteral(c, &label->menu);
 		break;
 	default:
 		printf("Ignoring malformed menu command: %.*s\n",
 				(int)(*c - s), s);
 	}
 	eol_or_eof(c);
 	return 0;
 }
 /*
  * Parses a label and adds it to the list of labels for a menu.
  *
  * A label ends when we either get to the end of a file, or
  * get some input we otherwise don't have a handler defined
  * for.
  *
  */
 static int parse_label(char **c, struct pxe_menu *cfg)
 {
 	struct token t;
 	int len;
 	char *s = *c;
 	struct pxe_label *label;
 	int err;
 	label = label_create();
 	if (!label)
 		return -ENOMEM;
 	err = parse_sliteral(c, &label->name);
 	if (err < 0) {
 		printf("Expected label name: %.*s\n", (int)(*c - s), s);
 		label_destroy(label);
 		return -EINVAL;
 	}
 	list_add_tail(&label->list, &cfg->labels);
 	while (1) {
 		s = *c;
 		get_token(c, &t, L_KEYWORD);
 		err = 0;
 		switch (t.type) {
 		case T_MENU:
 			err = parse_label_menu(c, cfg, label);
 			break;
 		case T_KERNEL:
 		case T_LINUX:
 			err = parse_sliteral(c, &label->kernel);
 			break;
 		case T_APPEND:
 			err = parse_sliteral(c, &label->append);
 			if (label->initrd)
 				break;
 			s = strstr(label->append, "initrd=");
 			if (!s)
 				break;
 			s += 7;
 			len = (int)(strchr(s, ' ') - s);
 			label->initrd = malloc(len + 1);
 			strncpy(label->initrd, s, len);
 			label->initrd[len] = '\0';
 			break;
 		case T_INITRD:
 			if (!label->initrd)
 				err = parse_sliteral(c, &label->initrd);
 			break;
 		case T_FDT:
 			if (!label->fdt)
 				err = parse_sliteral(c, &label->fdt);
 			break;
 		case T_LOCALBOOT:
 			err = parse_integer(c, &label->localboot);
 			break;
 		case T_EOL:
 			break;
 		default:
 			/*
 			 * put the token back! we don't want it - it's the end
 			 * of a label and whatever token this is, it's
 			 * something for the menu level context to handle.
 			 */
 			*c = s;
 			return 1;
 		}
 		if (err < 0)
 			return err;
 	}
 }
 /*
  * This 16 comes from the limit pxelinux imposes on nested includes.
  *
  * There is no reason at all we couldn't do more, but some limit helps prevent
  * infinite (until crash occurs) recursion if a file tries to include itself.
  */
 #define MAX_NEST_LEVEL 16
 /*
  * Entry point for parsing a menu file. nest_level indicates how many times
  * we've nested in includes.  It will be 1 for the top level menu file.
  *
  * Returns 1 on success, < 0 on error.
  */
 static int parse_pxefile_top(char *p, struct pxe_menu *cfg, int nest_level)
 {
 	struct token t;
 	char *s, *b, *label_name;
 	int err;
 	b = p;
 	if (nest_level > MAX_NEST_LEVEL) {
 		printf("Maximum nesting (%d) exceeded\n", MAX_NEST_LEVEL);
 		return -EMLINK;
 	}
 	while (1) {
 		s = p;
 		get_token(&p, &t, L_KEYWORD);
 		err = 0;
 		switch (t.type) {
 		case T_MENU:
 			err = parse_menu(&p, cfg, b, nest_level);
 			break;
 		case T_TIMEOUT:
 			err = parse_integer(&p, &cfg->timeout);
 			break;
 		case T_LABEL:
 			err = parse_label(&p, cfg);
 			break;
 		case T_DEFAULT:
 			err = parse_sliteral(&p, &label_name);
 			if (label_name) {
 				if (cfg->default_label)
 					free(cfg->default_label);
 				cfg->default_label = label_name;
 			}
 			break;
 		case T_INCLUDE:
 			err = handle_include(&p, b + ALIGN(strlen(b), 4), cfg,
 							nest_level + 1);
 			break;
 		case T_PROMPT:
 			err = parse_integer(&p, &cfg->prompt);
 			break;
 		case T_EOL:
 			break;
 		case T_EOF:
 			return 1;
 		default:
 			printf("Ignoring unknown command: %.*s\n",
 							(int)(p - s), s);
 			eol_or_eof(&p);
 		}
 		if (err < 0)
 			return err;
 	}
 }
 /*
  * Free the memory used by a pxe_menu and its labels.
  */
 static void destroy_pxe_menu(struct pxe_menu *cfg)
 {
 	struct list_head *pos, *n;
 	struct pxe_label *label;
 	if (cfg->title)
 		free(cfg->title);
 	if (cfg->default_label)
 		free(cfg->default_label);
 	list_for_each_safe(pos, n, &cfg->labels) {
 		label = list_entry(pos, struct pxe_label, list);
 		label_destroy(label);
 	}
 	free(cfg);
 }
 /*
  * Entry point for parsing a pxe file. This is only used for the top level
  * file.
  *
  * Returns NULL if there is an error, otherwise, returns a pointer to a
  * pxe_menu struct populated with the results of parsing the pxe file (and any
  * files it includes). The resulting pxe_menu struct can be free()'d by using
  * the destroy_pxe_menu() function.
  */
 static struct pxe_menu *parse_pxefile(char *menucfg)
 {
 	struct pxe_menu *cfg;
 	cfg = malloc(sizeof(struct pxe_menu));
 	if (!cfg)
 		return NULL;
 	memset(cfg, 0, sizeof(struct pxe_menu));
 	INIT_LIST_HEAD(&cfg->labels);
 	if (parse_pxefile_top(menucfg, cfg, 1) < 0) {
 		destroy_pxe_menu(cfg);
 		return NULL;
 	}
 	return cfg;
 }
 /*
  * Converts a pxe_menu struct into a menu struct for use with U-boot's generic
  * menu code.
  */
 static struct menu *pxe_menu_to_menu(struct pxe_menu *cfg)
 {
 	struct pxe_label *label;
 	struct list_head *pos;
 	struct menu *m;
 	int err;
 	/*
 	 * Create a menu and add items for all the labels.
 	 */
-	m = menu_create(cfg->title, cfg->timeout, cfg->prompt, label_print);
+	m = menu_create(cfg->title, cfg->timeout, cfg->prompt, label_print,
+			NULL, NULL);
 	if (!m)
 		return NULL;
 	list_for_each(pos, &cfg->labels) {
 		label = list_entry(pos, struct pxe_label, list);
 		if (menu_item_add(m, label->name, label) != 1) {
 			menu_destroy(m);
 			return NULL;
 		}
 	}
 	/*
 	 * After we've created items for each label in the menu, set the
 	 * menu's default label if one was specified.
 	 */
 	if (cfg->default_label) {
 		err = menu_default_set(m, cfg->default_label);
 		if (err != 1) {
 			if (err != -ENOENT) {
 				menu_destroy(m);
 				return NULL;
 			}
 			printf("Missing default: %s\n", cfg->default_label);
 		}
 	}
 	return m;
 }
 /*
  * Try to boot any labels we have yet to attempt to boot.
  */
 static void boot_unattempted_labels(struct pxe_menu *cfg)
 {
 	struct list_head *pos;
 	struct pxe_label *label;
 	list_for_each(pos, &cfg->labels) {
 		label = list_entry(pos, struct pxe_label, list);
 		if (!label->attempted)
 			label_boot(label);
 	}
 }
 /*
  * Boot the system as prescribed by a pxe_menu.
  *
  * Use the menu system to either get the user's choice or the default, based
  * on config or user input.  If there is no default or user's choice,
  * attempted to boot labels in the order they were given in pxe files.
  * If the default or user's choice fails to boot, attempt to boot other
  * labels in the order they were given in pxe files.
  *
  * If this function returns, there weren't any labels that successfully
  * booted, or the user interrupted the menu selection via ctrl+c.
  */
 static void handle_pxe_menu(struct pxe_menu *cfg)
 {
 	void *choice;
 	struct menu *m;
 	int err;
 	m = pxe_menu_to_menu(cfg);
 	if (!m)
 		return;
 	err = menu_get_choice(m, &choice);
 	menu_destroy(m);
 	/*
 	 * err == 1 means we got a choice back from menu_get_choice.
 	 *
 	 * err == -ENOENT if the menu was setup to select the default but no
 	 * default was set. in that case, we should continue trying to boot
 	 * labels that haven't been attempted yet.
 	 *
 	 * otherwise, the user interrupted or there was some other error and
 	 * we give up.
 	 */
 	if (err == 1)
 		label_boot(choice);
 	else if (err != -ENOENT)
 		return;
 	boot_unattempted_labels(cfg);
 }
 /*
  * Boots a system using a pxe file
  *
  * Returns 0 on success, 1 on error.
  */
 static int
 do_pxe_boot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	unsigned long pxefile_addr_r;
 	struct pxe_menu *cfg;
 	char *pxefile_addr_str;
 	do_getfile = do_get_tftp;
 	if (argc == 1) {
 		pxefile_addr_str = from_env("pxefile_addr_r");
 		if (!pxefile_addr_str)
 			return 1;
 	} else if (argc == 2) {
 		pxefile_addr_str = argv[1];
 	} else {
 		return CMD_RET_USAGE;
 	}
 	if (strict_strtoul(pxefile_addr_str, 16, &pxefile_addr_r) < 0) {
 		printf("Invalid pxefile address: %s\n", pxefile_addr_str);
 		return 1;
 	}
 	cfg = parse_pxefile((char *)(pxefile_addr_r));
 	if (cfg == NULL) {
 		printf("Error parsing config file\n");
 		return 1;
 	}
 	handle_pxe_menu(cfg);
 	destroy_pxe_menu(cfg);
 	return 0;
 }
 static cmd_tbl_t cmd_pxe_sub[] = {
 	U_BOOT_CMD_MKENT(get, 1, 1, do_pxe_get, "", ""),
 	U_BOOT_CMD_MKENT(boot, 2, 1, do_pxe_boot, "", "")
 };
 int do_pxe(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	cmd_tbl_t *cp;
 	if (argc < 2)
 		return CMD_RET_USAGE;
 	/* drop initial "pxe" arg */
 	argc--;
 	argv++;
 	cp = find_cmd_tbl(argv[0], cmd_pxe_sub, ARRAY_SIZE(cmd_pxe_sub));
 	if (cp)
 		return cp->cmd(cmdtp, flag, argc, argv);
 	return CMD_RET_USAGE;
 }
 U_BOOT_CMD(
 	pxe, 3, 1, do_pxe,
 	"commands to get and boot from pxe files",
 	"get - try to retrieve a pxe file using tftp\npxe "
 	"boot [pxefile_addr_r] - boot from the pxe file at pxefile_addr_r\n"
 );
 /*
  * Boots a system using a local disk syslinux/extlinux file
  *
  * Returns 0 on success, 1 on error.
  */
 int do_sysboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	unsigned long pxefile_addr_r;
 	struct pxe_menu *cfg;
 	char *pxefile_addr_str;
 	char *filename;
 	int prompt = 0;
 	if (strstr(argv[1], "-p")) {
 		prompt = 1;
 		argc--;
 		argv++;
 	}
 	if (argc < 4)
 		return cmd_usage(cmdtp);
 	if (argc < 5) {
 		pxefile_addr_str = from_env("pxefile_addr_r");
 		if (!pxefile_addr_str)
 			return 1;
 	} else {
 		pxefile_addr_str = argv[4];
 	}
 	if (argc < 6)
 		filename = getenv("bootfile");
 	else {
 		filename = argv[5];
 		setenv("bootfile", filename);
 	}
 	if (strstr(argv[3], "ext2"))
 		do_getfile = do_get_ext2;
 	else if (strstr(argv[3], "fat"))
 		do_getfile = do_get_fat;
 	else {
 		printf("Invalid filesystem: %s\n", argv[3]);
 		return 1;
 	}
 	fs_argv[1] = argv[1];
 	fs_argv[2] = argv[2];
 	if (strict_strtoul(pxefile_addr_str, 16, &pxefile_addr_r) < 0) {
 		printf("Invalid pxefile address: %s\n", pxefile_addr_str);
 		return 1;
 	}
 	if (get_pxe_file(filename, (void *)pxefile_addr_r) < 0) {
 		printf("Error reading config file\n");
 		return 1;
 	}
 	cfg = parse_pxefile((char *)(pxefile_addr_r));
 	if (cfg == NULL) {
 		printf("Error parsing config file\n");
 		return 1;
 	}
 	if (prompt)
 		cfg->prompt = 1;
 	handle_pxe_menu(cfg);
 	destroy_pxe_menu(cfg);
 	return 0;
 }
 U_BOOT_CMD(
 	sysboot, 7, 1, do_sysboot,
 	"command to get and boot from syslinux files",
 	"[-p] <interface> <dev[:part]> <ext2|fat> [addr] [filename]\n"
 	"    - load and parse syslinux menu file 'filename' from ext2 or fat\n"
 	"      filesystem on 'dev' on 'interface' to address 'addr'"
 );

common/menu.c

Diff comments View file @ 5644369

1	/*	1	/*
2	* Copyright 2010-2011 Calxeda, Inc.	2	* Copyright 2010-2011 Calxeda, Inc.
3	*	3	*
4	* This program is free software; you can redistribute it and/or modify it	4	* This program is free software; you can redistribute it and/or modify it
5	* under the terms of the GNU General Public License as published by the Free	5	* under the terms of the GNU General Public License as published by the Free
6	* Software Foundation; either version 2 of the License, or (at your option)	6	* Software Foundation; either version 2 of the License, or (at your option)
7	* any later version.	7	* any later version.
8	*	8	*
9	* This program is distributed in the hope it will be useful, but WITHOUT	9	* This program is distributed in the hope it will be useful, but WITHOUT
10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12	* more details.	12	* more details.
13	*	13	*
14	* You should have received a copy of the GNU General Public License along with	14	* You should have received a copy of the GNU General Public License along with
15	* this program. If not, see <http://www.gnu.org/licenses/>.	15	* this program. If not, see <http://www.gnu.org/licenses/>.
16	*/	16	*/
17		17
18	#include <common.h>	18	#include <common.h>
19	#include <malloc.h>	19	#include <malloc.h>
20	#include <errno.h>	20	#include <errno.h>
21	#include <linux/list.h>	21	#include <linux/list.h>
22		22
23	#include "menu.h"	23	#include "menu.h"
24		24
25	/*	25	/*
26	* Internally, each item in a menu is represented by a struct menu_item.	26	* Internally, each item in a menu is represented by a struct menu_item.
27	*	27	*
28	* These items will be alloc'd and initialized by menu_item_add and destroyed	28	* These items will be alloc'd and initialized by menu_item_add and destroyed
29	* by menu_item_destroy, and the consumer of the interface never sees that	29	* by menu_item_destroy, and the consumer of the interface never sees that
30	* this struct is used at all.	30	* this struct is used at all.
31	*/	31	*/
32	struct menu_item {	32	struct menu_item {
33	char *key;	33	char *key;
34	void *data;	34	void *data;
35	struct list_head list;	35	struct list_head list;
36	};	36	};
37		37
38	/*	38	/*
39	* The menu is composed of a list of items along with settings and callbacks	39	* The menu is composed of a list of items along with settings and callbacks
40	* provided by the user. An incomplete definition of this struct is available	40	* provided by the user. An incomplete definition of this struct is available
41	* in menu.h, but the full definition is here to prevent consumers from	41	* in menu.h, but the full definition is here to prevent consumers from
42	* relying on its contents.	42	* relying on its contents.
43	*/	43	*/
44	struct menu {	44	struct menu {
45	struct menu_item *default_item;	45	struct menu_item *default_item;
46	int timeout;	46	int timeout;
47	char *title;	47	char *title;
48	int prompt;	48	int prompt;
49	void (item_data_print)(void );	49	void (item_data_print)(void );
		50	char (item_choice)(void *);
		51	void *item_choice_data;
50	struct list_head items;	52	struct list_head items;
51	};	53	};
52		54
53	/*	55	/*
54	* An iterator function for menu items. callback will be called for each item	56	* An iterator function for menu items. callback will be called for each item
55	* in m, with m, a pointer to the item, and extra being passed to callback. If	57	* in m, with m, a pointer to the item, and extra being passed to callback. If
56	* callback returns a value other than NULL, iteration stops and the value	58	* callback returns a value other than NULL, iteration stops and the value
57	* return by callback is returned from menu_items_iter. This allows it to be	59	* return by callback is returned from menu_items_iter. This allows it to be
58	* used for search type operations. It is also safe for callback to remove the	60	* used for search type operations. It is also safe for callback to remove the
59	* item from the list of items.	61	* item from the list of items.
60	*/	62	*/
61	static inline void menu_items_iter(struct menu m,	63	static inline void menu_items_iter(struct menu m,
62	void (callback)(struct menu , struct menu_item , void *),	64	void (callback)(struct menu , struct menu_item , void *),
63	void *extra)	65	void *extra)
64	{	66	{
65	struct list_head pos, n;	67	struct list_head pos, n;
66	struct menu_item *item;	68	struct menu_item *item;
67	void *ret;	69	void *ret;
68		70
69	list_for_each_safe(pos, n, &m->items) {	71	list_for_each_safe(pos, n, &m->items) {
70	item = list_entry(pos, struct menu_item, list);	72	item = list_entry(pos, struct menu_item, list);
71		73
72	ret = callback(m, item, extra);	74	ret = callback(m, item, extra);
73		75
74	if (ret)	76	if (ret)
75	return ret;	77	return ret;
76	}	78	}
77		79
78	return NULL;	80	return NULL;
79	}	81	}
80		82
81	/*	83	/*
82	* Print a menu_item. If the consumer provided an item_data_print function	84	* Print a menu_item. If the consumer provided an item_data_print function
83	* when creating the menu, call it with a pointer to the item's private data.	85	* when creating the menu, call it with a pointer to the item's private data.
84	* Otherwise, print the key of the item.	86	* Otherwise, print the key of the item.
85	*/	87	*/
86	static inline void menu_item_print(struct menu m,	88	static inline void menu_item_print(struct menu m,
87	struct menu_item *item,	89	struct menu_item *item,
88	void *extra)	90	void *extra)
89	{	91	{
90	if (!m->item_data_print) {	92	if (!m->item_data_print) {
91	puts(item->key);	93	puts(item->key);
92	putc('\n');	94	putc('\n');
93	} else {	95	} else {
94	m->item_data_print(item->data);	96	m->item_data_print(item->data);
95	}	97	}
96		98
97	return NULL;	99	return NULL;
98	}	100	}
99		101
100	/*	102	/*
101	* Free the memory used by a menu item. This includes the memory used by its	103	* Free the memory used by a menu item. This includes the memory used by its
102	* key.	104	* key.
103	*/	105	*/
104	static inline void menu_item_destroy(struct menu m,	106	static inline void menu_item_destroy(struct menu m,
105	struct menu_item *item,	107	struct menu_item *item,
106	void *extra)	108	void *extra)
107	{	109	{
108	if (item->key)	110	if (item->key)
109	free(item->key);	111	free(item->key);
110		112
111	free(item);	113	free(item);
112		114
113	return NULL;	115	return NULL;
114	}	116	}
115		117
116	void __menu_display_statusline(struct menu *m)	118	void __menu_display_statusline(struct menu *m)
117	{	119	{
118	return;	120	return;
119	}	121	}
120	void menu_display_statusline(struct menu *m)	122	void menu_display_statusline(struct menu *m)
121	__attribute__ ((weak, alias("__menu_display_statusline")));	123	__attribute__ ((weak, alias("__menu_display_statusline")));
122		124
123	/*	125	/*
124	* Display a menu so the user can make a choice of an item. First display its	126	* Display a menu so the user can make a choice of an item. First display its
125	* title, if any, and then each item in the menu.	127	* title, if any, and then each item in the menu.
126	*/	128	*/
127	static inline void menu_display(struct menu *m)	129	static inline void menu_display(struct menu *m)
128	{	130	{
129	if (m->title) {	131	if (m->title) {
130	puts(m->title);	132	puts(m->title);
131	putc('\n');	133	putc('\n');
132	}	134	}
133	menu_display_statusline(m);	135	menu_display_statusline(m);
134		136
135	menu_items_iter(m, menu_item_print, NULL);	137	menu_items_iter(m, menu_item_print, NULL);
136	}	138	}
137		139
138	/*	140	/*
139	* Check if an item's key matches a provided string, pointed to by extra. If	141	* Check if an item's key matches a provided string, pointed to by extra. If
140	* extra is NULL, an item with a NULL key will match. Otherwise, the item's	142	* extra is NULL, an item with a NULL key will match. Otherwise, the item's
141	* key has to match according to strcmp.	143	* key has to match according to strcmp.
142	*	144	*
143	* This is called via menu_items_iter, so it returns a pointer to the item if	145	* This is called via menu_items_iter, so it returns a pointer to the item if
144	* the key matches, and returns NULL otherwise.	146	* the key matches, and returns NULL otherwise.
145	*/	147	*/
146	static inline void menu_item_key_match(struct menu m,	148	static inline void menu_item_key_match(struct menu m,
147	struct menu_item item, void extra)	149	struct menu_item item, void extra)
148	{	150	{
149	char *item_key = extra;	151	char *item_key = extra;
150		152
151	if (!item_key \|\| !item->key) {	153	if (!item_key \|\| !item->key) {
152	if (item_key == item->key)	154	if (item_key == item->key)
153	return item;	155	return item;
154		156
155	return NULL;	157	return NULL;
156	}	158	}
157		159
158	if (strcmp(item->key, item_key) == 0)	160	if (strcmp(item->key, item_key) == 0)
159	return item;	161	return item;
160		162
161	return NULL;	163	return NULL;
162	}	164	}
163		165
164	/*	166	/*
165	* Find the first item with a key matching item_key, if any exists.	167	* Find the first item with a key matching item_key, if any exists.
166	*/	168	*/
167	static inline struct menu_item menu_item_by_key(struct menu m,	169	static inline struct menu_item menu_item_by_key(struct menu m,
168	char *item_key)	170	char *item_key)
169	{	171	{
170	return menu_items_iter(m, menu_item_key_match, item_key);	172	return menu_items_iter(m, menu_item_key_match, item_key);
171	}	173	}
172		174
173	/*	175	/*
174	* Set *choice to point to the default item's data, if any default item was	176	* Set *choice to point to the default item's data, if any default item was
175	* set, and returns 1. If no default item was set, returns -ENOENT.	177	* set, and returns 1. If no default item was set, returns -ENOENT.
176	*/	178	*/
177	static inline int menu_default_choice(struct menu m, void *choice)	179	int menu_default_choice(struct menu m, void *choice)
178	{	180	{
179	if (m->default_item) {	181	if (m->default_item) {
180	*choice = m->default_item->data;	182	*choice = m->default_item->data;
181	return 1;	183	return 1;
182	}	184	}
183		185
184	return -ENOENT;	186	return -ENOENT;
185	}	187	}
186		188
187	/*	189	/*
188	* Displays the menu and asks the user to choose an item. *choice will point	190	* Displays the menu and asks the user to choose an item. *choice will point
189	* to the private data of the item the user chooses. The user makes a choice	191	* to the private data of the item the user chooses. The user makes a choice
190	* by inputting a string matching the key of an item. Invalid choices will	192	* by inputting a string matching the key of an item. Invalid choices will
191	* cause the user to be prompted again, repeatedly, until the user makes a	193	* cause the user to be prompted again, repeatedly, until the user makes a
192	* valid choice. The user can exit the menu without making a choice via ^c.	194	* valid choice. The user can exit the menu without making a choice via ^c.
193	*	195	*
194	* Returns 1 if the user made a choice, or -EINTR if they bail via ^c.	196	* Returns 1 if the user made a choice, or -EINTR if they bail via ^c.
195	*/	197	*/
196	static inline int menu_interactive_choice(struct menu m, void *choice)	198	static inline int menu_interactive_choice(struct menu m, void *choice)
197	{	199	{
198	char cbuf[CONFIG_SYS_CBSIZE];	200	char cbuf[CONFIG_SYS_CBSIZE];
199	struct menu_item *choice_item = NULL;	201	struct menu_item *choice_item = NULL;
200	int readret;	202	int readret;
201		203
202	while (!choice_item) {	204	while (!choice_item) {
203	cbuf[0] = '\0';	205	cbuf[0] = '\0';
204		206
205	menu_display(m);	207	menu_display(m);
206		208
207	readret = readline_into_buffer("Enter choice: ", cbuf,	209	if (!m->item_choice) {
208	m->timeout / 10);	210	readret = readline_into_buffer("Enter choice: ", cbuf,
		211	m->timeout / 10);
209		212
210	if (readret >= 0) {	213	if (readret >= 0) {
211	choice_item = menu_item_by_key(m, cbuf);	214	choice_item = menu_item_by_key(m, cbuf);
212		215	if (!choice_item)
213	if (!choice_item) {	216	printf("%s not found\n", cbuf);
214	printf("%s not found\n", cbuf);	217	} else {
215	m->timeout = 0;	218	return menu_default_choice(m, choice);
216	}	219	}
217	} else	220	} else {
218	return menu_default_choice(m, choice);	221	char *key = m->item_choice(m->item_choice_data);
		222
		223	if (key)
		224	choice_item = menu_item_by_key(m, key);
		225	}
		226
		227	if (!choice_item)
		228	m->timeout = 0;
219	}	229	}
220		230
221	*choice = choice_item->data;	231	*choice = choice_item->data;
222		232
223	return 1;	233	return 1;
224	}	234	}
225		235
226	/*	236	/*
227	* menu_default_set() - Sets the default choice for the menu. This is safe to	237	* menu_default_set() - Sets the default choice for the menu. This is safe to
228	* call more than once on a menu.	238	* call more than once on a menu.
229	*	239	*
230	* m - Points to a menu created by menu_create().	240	* m - Points to a menu created by menu_create().
231	*	241	*
232	* item_key - Points to a string that, when compared using strcmp, matches the	242	* item_key - Points to a string that, when compared using strcmp, matches the
233	* key for an existing item in the menu.	243	* key for an existing item in the menu.
234	*	244	*
235	* Returns 1 if successful, -EINVAL if m is NULL, or -ENOENT if no item with a	245	* Returns 1 if successful, -EINVAL if m is NULL, or -ENOENT if no item with a
236	* key matching item_key is found.	246	* key matching item_key is found.
237	*/	247	*/
238	int menu_default_set(struct menu m, char item_key)	248	int menu_default_set(struct menu m, char item_key)
239	{	249	{
240	struct menu_item *item;	250	struct menu_item *item;
241		251
242	if (!m)	252	if (!m)
243	return -EINVAL;	253	return -EINVAL;
244		254
245	item = menu_item_by_key(m, item_key);	255	item = menu_item_by_key(m, item_key);
246		256
247	if (!item)	257	if (!item)
248	return -ENOENT;	258	return -ENOENT;
249		259
250	m->default_item = item;	260	m->default_item = item;
251		261
252	return 1;	262	return 1;
253	}	263	}
254		264
255	/*	265	/*
256	* menu_get_choice() - Returns the user's selected menu entry, or the default	266	* menu_get_choice() - Returns the user's selected menu entry, or the default
257	* if the menu is set to not prompt or the timeout expires. This is safe to	267	* if the menu is set to not prompt or the timeout expires. This is safe to
258	* call more than once.	268	* call more than once.
259	*	269	*
260	* m - Points to a menu created by menu_create().	270	* m - Points to a menu created by menu_create().
261	*	271	*
262	* choice - Points to a location that will store a pointer to the selected	272	* choice - Points to a location that will store a pointer to the selected
263	* menu item. If no item is selected or there is an error, no value will be	273	* menu item. If no item is selected or there is an error, no value will be
264	* written at the location it points to.	274	* written at the location it points to.
265	*	275	*
266	* Returns 1 if successful, -EINVAL if m or choice is NULL, -ENOENT if no	276	* Returns 1 if successful, -EINVAL if m or choice is NULL, -ENOENT if no
267	* default has been set and the menu is set to not prompt or the timeout	277	* default has been set and the menu is set to not prompt or the timeout
268	* expires, or -EINTR if the user exits the menu via ^c.	278	* expires, or -EINTR if the user exits the menu via ^c.
269	*/	279	*/
270	int menu_get_choice(struct menu m, void *choice)	280	int menu_get_choice(struct menu m, void *choice)
271	{	281	{
272	if (!m \|\| !choice)	282	if (!m \|\| !choice)
273	return -EINVAL;	283	return -EINVAL;
274		284
275	if (!m->prompt)	285	if (!m->prompt)
276	return menu_default_choice(m, choice);	286	return menu_default_choice(m, choice);
277		287
278	return menu_interactive_choice(m, choice);	288	return menu_interactive_choice(m, choice);
279	}	289	}
280		290
281	/*	291	/*
282	* menu_item_add() - Adds or replaces a menu item. Note that this replaces the	292	* menu_item_add() - Adds or replaces a menu item. Note that this replaces the
283	* data of an item if it already exists, but doesn't change the order of the	293	* data of an item if it already exists, but doesn't change the order of the
284	* item.	294	* item.
285	*	295	*
286	* m - Points to a menu created by menu_create().	296	* m - Points to a menu created by menu_create().
287	*	297	*
288	* item_key - Points to a string that will uniquely identify the item. The	298	* item_key - Points to a string that will uniquely identify the item. The
289	* string will be copied to internal storage, and is safe to discard after	299	* string will be copied to internal storage, and is safe to discard after
290	* passing to menu_item_add.	300	* passing to menu_item_add.
291	*	301	*
292	* item_data - An opaque pointer associated with an item. It is never	302	* item_data - An opaque pointer associated with an item. It is never
293	* dereferenced internally, but will be passed to the item_data_print, and	303	* dereferenced internally, but will be passed to the item_data_print, and
294	* will be returned from menu_get_choice if the menu item is selected.	304	* will be returned from menu_get_choice if the menu item is selected.
295	*	305	*
296	* Returns 1 if successful, -EINVAL if m is NULL, or -ENOMEM if there is	306	* Returns 1 if successful, -EINVAL if m is NULL, or -ENOMEM if there is
297	* insufficient memory to add the menu item.	307	* insufficient memory to add the menu item.
298	*/	308	*/
299	int menu_item_add(struct menu m, char item_key, void *item_data)	309	int menu_item_add(struct menu m, char item_key, void *item_data)
300	{	310	{
301	struct menu_item *item;	311	struct menu_item *item;
302		312
303	if (!m)	313	if (!m)
304	return -EINVAL;	314	return -EINVAL;
305		315
306	item = menu_item_by_key(m, item_key);	316	item = menu_item_by_key(m, item_key);
307		317
308	if (item) {	318	if (item) {
309	item->data = item_data;	319	item->data = item_data;
310	return 1;	320	return 1;
311	}	321	}
312		322
313	item = malloc(sizeof *item);	323	item = malloc(sizeof *item);
314	if (!item)	324	if (!item)
315	return -ENOMEM;	325	return -ENOMEM;
316		326
317	item->key = strdup(item_key);	327	item->key = strdup(item_key);
318		328
319	if (!item->key) {	329	if (!item->key) {
320	free(item);	330	free(item);
321	return -ENOMEM;	331	return -ENOMEM;
322	}	332	}
323		333
324	item->data = item_data;	334	item->data = item_data;
325		335
326	list_add_tail(&item->list, &m->items);	336	list_add_tail(&item->list, &m->items);
327		337
328	return 1;	338	return 1;
329	}	339	}
330		340
331	/*	341	/*
332	* menu_create() - Creates a menu handle with default settings	342	* menu_create() - Creates a menu handle with default settings
333	*	343	*
334	* title - If not NULL, points to a string that will be displayed before the	344	* title - If not NULL, points to a string that will be displayed before the
335	* list of menu items. It will be copied to internal storage, and is safe to	345	* list of menu items. It will be copied to internal storage, and is safe to
336	* discard after passing to menu_create().	346	* discard after passing to menu_create().
337	*	347	*
338	* timeout - A delay in seconds to wait for user input. If 0, timeout is	348	* timeout - A delay in seconds to wait for user input. If 0, timeout is
339	* disabled, and the default choice will be returned unless prompt is 1.	349	* disabled, and the default choice will be returned unless prompt is 1.
340	*	350	*
341	* prompt - If 0, don't ask for user input unless there is an interrupted	351	* prompt - If 0, don't ask for user input unless there is an interrupted
342	* timeout. If 1, the user will be prompted for input regardless of the value	352	* timeout. If 1, the user will be prompted for input regardless of the value
343	* of timeout.	353	* of timeout.
344	*	354	*
345	* item_data_print - If not NULL, will be called for each item when the menu	355	* item_data_print - If not NULL, will be called for each item when the menu
346	* is displayed, with the pointer to the item's data passed as the argument.	356	* is displayed, with the pointer to the item's data passed as the argument.
347	* If NULL, each item's key will be printed instead. Since an item's key is	357	* If NULL, each item's key will be printed instead. Since an item's key is
348	* what must be entered to select an item, the item_data_print function should	358	* what must be entered to select an item, the item_data_print function should
349	* make it obvious what the key for each entry is.	359	* make it obvious what the key for each entry is.
350	*	360	*
		361	* item_choice - If not NULL, will be called when asking the user to choose an
		362	* item. Returns a key string corresponding to the choosen item or NULL if
		363	* no item has been selected.
		364	*
		365	* item_choice_data - Will be passed as the argument to the item_choice function
		366	*
351	* Returns a pointer to the menu if successful, or NULL if there is	367	* Returns a pointer to the menu if successful, or NULL if there is
352	* insufficient memory available to create the menu.	368	* insufficient memory available to create the menu.
353	*/	369	*/
354	struct menu menu_create(char title, int timeout, int prompt,	370	struct menu menu_create(char title, int timeout, int prompt,
355	void (item_data_print)(void ))	371	void (item_data_print)(void ),
		372	char (item_choice)(void *),
		373	void *item_choice_data)
356	{	374	{
357	struct menu *m;	375	struct menu *m;
358		376
359	m = malloc(sizeof *m);	377	m = malloc(sizeof *m);
360		378
361	if (!m)	379	if (!m)
362	return NULL;	380	return NULL;
363		381
364	m->default_item = NULL;	382	m->default_item = NULL;
365	m->prompt = prompt;	383	m->prompt = prompt;
366	m->timeout = timeout;	384	m->timeout = timeout;
367	m->item_data_print = item_data_print;	385	m->item_data_print = item_data_print;
		386	m->item_choice = item_choice;
		387	m->item_choice_data = item_choice_data;
368		388
369	if (title) {	389	if (title) {
370	m->title = strdup(title);	390	m->title = strdup(title);
371	if (!m->title) {	391	if (!m->title) {
372	free(m);	392	free(m);
373	return NULL;	393	return NULL;
374	}	394	}
375	} else	395	} else
376	m->title = NULL;	396	m->title = NULL;
377		397
378		398
379	INIT_LIST_HEAD(&m->items);	399	INIT_LIST_HEAD(&m->items);
380		400
381	return m;	401	return m;
382	}	402	}
383		403
384	/*	404	/*
385	* menu_destroy() - frees the memory used by a menu and its items.	405	* menu_destroy() - frees the memory used by a menu and its items.
386	*	406	*
387	* m - Points to a menu created by menu_create().	407	* m - Points to a menu created by menu_create().
388	*	408	*
389	* Returns 1 if successful, or -EINVAL if m is NULL.	409	* Returns 1 if successful, or -EINVAL if m is NULL.
390	*/	410	*/
391	int menu_destroy(struct menu *m)	411	int menu_destroy(struct menu *m)
392	{	412	{
393	if (!m)	413	if (!m)
394	return -EINVAL;	414	return -EINVAL;
395		415
396	menu_items_iter(m, menu_item_destroy, NULL);	416	menu_items_iter(m, menu_item_destroy, NULL);
397		417
398	if (m->title)	418	if (m->title)
399	free(m->title);	419	free(m->title);
400		420
401	free(m);	421	free(m);
402		422
403	return 1;	423	return 1;
404	}	424	}
405		425

doc/README.bootmenu

Diff comments View file @ 5644369

File was created	1	/*
	2	* (C) Copyright 2011-2012 Pali Rohár <pali.rohar@gmail.com>
	3	*
	4	* See file CREDITS for list of people who contributed to this
	5	* project.
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License as
	9	* published by the Free Software Foundation; either version 2 of
	10	* the License, or (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	20	* MA 02111-1307 USA
	21	*/
	22
	23	ANSI terminal bootmenu command
	24
	25	The "bootmenu" command uses U-Boot menu interfaces and provides
	26	a simple mechanism for creating menus with different boot items.
	27	The cursor keys "Up" and "Down" are used for navigation through
	28	the items. Current active menu item is highlighted and can be
	29	selected using the "Enter" key. The selection of the highlighted
	30	menu entry invokes an U-Boot command (or a list of commands)
	31	associated with this menu entry.
	32
	33	The "bootmenu" command interprets ANSI escape sequencies, so
	34	an ANSI terminal is required for proper menu rendering and item
	35	selection.
	36
	37	The assembling of the menu is done via a set of environment variables
	38	"bootmenu_<num>" and "bootmenu_delay", i.e.:
	39
	40	bootmenu_delay=<delay>
	41	bootmenu_<num>="<title>=<commands>"
	42
	43	<delay> is the autoboot delay in seconds, after which the first
	44	menu entry will be selected automatically
	45
	46	<num> is the boot menu entry number, starting from zero
	47
	48	<title> is the text of the menu entry shown on the console
	49	or on the boot screen
	50
	51	<commands> are commands which will be executed when a menu
	52	entry is selected
	53
	54	(title and commands are separated by first appearance of '='
	55	character in the environment variable)
	56
	57	First (optional) argument of the "bootmenu" command is a delay specifier
	58	and it overrides the delay value defined by "bootmenu_delay" environment
	59	variable. If the environment variable "bootmenu_delay" is not set or if
	60	the argument of the "bootmenu" command is not specified, the default delay
	61	will be CONFIG_BOOTDELAY. If delay is 0, no menu entries will be shown on
	62	the console (or on the screen) and the command of the first menu entry will
	63	be called immediately. If delay is less then 0, bootmenu will be shown and
	64	autoboot will be disabled.
	65
	66	Bootmenu always adds menu entry "U-Boot console" at the end of all menu
	67	entries specified by environment variables. When selecting this entry
	68	the bootmenu terminates and the usual U-Boot command prompt is presented
	69	to the user.
	70
	71	Example environment:
	72
	73	setenv bootmenu_0 Boot 1. kernel=bootm 0x82000000 # Set first menu entry
	74	setenv bootmenu_1 Boot 2. kernel=bootm 0x83000000 # Set second menu entry
	75	setenv bootmenu_2 Reset board=reset # Set third menu entry
	76	setenv bootmenu_3 U-Boot boot order=boot # Set fourth menu entry
	77	bootmenu 20 # Run bootmenu with autoboot delay 20s
	78
	79
	80	The above example will be rendered as below
	81	(without decorating rectangle):
	82
	83	┌──────────────────────────────────────────┐
	84	│ │
	85	│ * U-Boot Boot Menu * │
	86	│ │
	87	│ Boot 1. kernel │
	88	│ Boot 2. kernel │
	89	│ Reset board │
	90	│ U-Boot boot order │
	91	│ U-Boot console │
	92	│ │
	93	│ Hit any key to stop autoboot: 20 │
	94	│ Press UP/DOWN to move, ENTER to select │
	95	│ │
	96	└──────────────────────────────────────────┘
	97
	98	Selected menu entry will be highlighted - it will have inverted
	99	background and text colors.
	100
	101	To enable the "bootmenu" command add following definitions to the
	102	board config file:
	103
	104	#define CONFIG_CMD_BOOTMENU
	105	#define CONFIG_MENU
	106
	107	To run the bootmenu at startup add these additional definitions:
	108
	109	#define CONFIG_AUTOBOOT_KEYED
	110	#define CONFIG_BOOTDELAY 30
	111	#define CONFIG_MENU_SHOW
	112
	113	When you intend to use the bootmenu on color frame buffer console,
	114	make sure to additionally define CONFIG_CFB_CONSOLE_ANSI in the
	115	board config file.
	116

doc/README.menu

Diff comments View file @ 5644369

 /*
  * Copyright 2010-2011 Calxeda, Inc.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
  * Software Foundation; either version 2 of the License, or (at your option)
  * any later version.
  *
  * This program is distributed in the hope it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  * more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 U-boot provides a set of interfaces for creating and using simple, text
 based menus. Menus are displayed as lists of labeled entries on the
 console, and an entry can be selected by entering its label.
 To use the menu code, enable CONFIG_MENU, and include "menu.h" where
 the interfaces should be available.
 Menus are composed of items. Each item has a key used to identify it in
 the menu, and an opaque pointer to data controlled by the consumer.
 If you want to show a menu, instead starting the shell, define
 CONFIG_MENU_SHOW. You have to code the int menu_show(int bootdelay)
 function, which handle your menu. This function returns the remaining
 bootdelay.
 Interfaces
 ----------
 #include "menu.h"
 /*
  * Consumers of the menu interfaces will use a struct menu * as the
  * handle for a menu. struct menu is only fully defined in menu.c,
  * preventing consumers of the menu interfaces from accessing its
  * contents directly.
  */
 struct menu;
 /*
  * NOTE: See comments in common/menu.c for more detailed documentation on
  * these interfaces.
  */
 /*
  * menu_create() - Creates a menu handle with default settings
  */
 struct menu *menu_create(char *title, int timeout, int prompt,
-				void (*item_data_print)(void *));
+				void (*item_data_print)(void *),
+				char *(*item_choice)(void *),
+				void *item_choice_data);
 /*
  * menu_item_add() - Adds or replaces a menu item
  */
 int menu_item_add(struct menu *m, char *item_key, void *item_data);
 /*
  * menu_default_set() - Sets the default choice for the menu
  */
 int menu_default_set(struct menu *m, char *item_key);
+/*
+ * menu_default_choice() - Set *choice to point to the default item's data
+ */
+int menu_default_choice(struct menu *m, void **choice);
 /*
  * menu_get_choice() - Returns the user's selected menu entry, or the
  * default if the menu is set to not prompt or the timeout expires.
  */
 int menu_get_choice(struct menu *m, void **choice);
 /*
  * menu_destroy() - frees the memory used by a menu and its items.
  */
 int menu_destroy(struct menu *m);
 /*
  * menu_display_statusline(struct menu *m);
  * shows a statusline for every menu_display call.
  */
 void menu_display_statusline(struct menu *m);
 Example Code
 ------------
 This example creates a menu that always prompts, and allows the user
 to pick from a list of tools.  The item key and data are the same.
 #include "menu.h"
 char *tools[] = {
 	"Hammer",
 	"Screwdriver",
 	"Nail gun",
 	NULL
 };
 char *pick_a_tool(void)
 {
 	struct menu *m;
 	int i;
 	char *tool = NULL;
 	m = menu_create("Tools", 0, 1, NULL);
 	for(i = 0; tools[i]; i++) {
 		if (menu_item_add(m, tools[i], tools[i]) != 1) {
 			printf("failed to add item!");
 			menu_destroy(m);
 			return NULL;
 		}
 	}
 	if (menu_get_choice(m, (void **)&tool) != 1)
 		printf("Problem picking tool!\n");
 	menu_destroy(m);
 	return tool;
 }
 void caller(void)
 {
 	char *tool = pick_a_tool();
 	if (tool) {
 		printf("picked a tool: %s\n", tool);
 		use_tool(tool);
 	}
 }

include/ansi.h

Diff comments View file @ 5644369

File was created	1	/*
	2	* (C) Copyright 2012
	3	* Pali Rohár <pali.rohar@gmail.com>
	4	*
	5	* See file CREDITS for list of people who contributed to this
	6	* project.
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License as
	10	* published by the Free Software Foundation; either version 2 of
	11	* the License, or (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	21	* MA 02111-1307 USA
	22	*/
	23
	24	/*
	25	* ANSI terminal
	26	*/
	27
	28	#define ANSI_CURSOR_UP "\e[%dA"
	29	#define ANSI_CURSOR_DOWN "\e[%dB"
	30	#define ANSI_CURSOR_FORWARD "\e[%dC"
	31	#define ANSI_CURSOR_BACK "\e[%dD"
	32	#define ANSI_CURSOR_NEXTLINE "\e[%dE"
	33	#define ANSI_CURSOR_PREVIOUSLINE "\e[%dF"
	34	#define ANSI_CURSOR_COLUMN "\e[%dG"
	35	#define ANSI_CURSOR_POSITION "\e[%d;%dH"
	36	#define ANSI_CURSOR_SHOW "\e[?25h"
	37	#define ANSI_CURSOR_HIDE "\e[?25l"
	38	#define ANSI_CLEAR_CONSOLE "\e[2J"
	39	#define ANSI_CLEAR_LINE_TO_END "\e[0K"
	40	#define ANSI_CLEAR_LINE "\e[2K"
	41	#define ANSI_COLOR_RESET "\e[0m"
	42	#define ANSI_COLOR_REVERSE "\e[7m"
	43

include/configs/nokia_rx51.h

Diff comments View file @ 5644369

 /*
  * (C) Copyright 2011-2012
  * Pali Rohár <pali.rohar@gmail.com>
  *
  * (C) Copyright 2010
  * Alistair Buxton <a.j.buxton@gmail.com>
  *
  * Derived from Beagle Board code:
  * (C) Copyright 2006-2008
  * Texas Instruments.
  * Richard Woodruff <r-woodruff2@ti.com>
  * Syed Mohammed Khasim <x0khasim@ti.com>
  *
  * Configuration settings for the Nokia RX-51 aka N900.
  *
  * See file CREDITS for list of people who contributed to this
  * project.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  * MA 02111-1307 USA
  */
 #ifndef __CONFIG_H
 #define __CONFIG_H
 /*
  * High Level Configuration Options
  */
 #define CONFIG_OMAP			/* in a TI OMAP core */
 #define CONFIG_OMAP34XX			/* which is a 34XX */
 #define CONFIG_OMAP3430			/* which is in a 3430 */
 #define CONFIG_OMAP3_RX51		/* working with RX51 */
 #define CONFIG_SYS_L2CACHE_OFF		/* pretend there is no L2 CACHE */
 #define CONFIG_MACH_TYPE		MACH_TYPE_NOKIA_RX51
 /*
  * Nokia X-Loader loading secondary image to address 0x80400000
  * NOLO loading boot image to random place, so it doesn't really
  * matter what we set this to. We have to copy u-boot to this address
  */
 #define CONFIG_SYS_TEXT_BASE	0x80008000
 #define CONFIG_SDRC			/* The chip has SDRC controller */
 #include <asm/arch/cpu.h>		/* get chip and board defs */
 #include <asm/arch/omap3.h>
 #include <asm/arch/mem.h>
 #include <linux/stringify.h>
 /*
  * Display CPU and Board information
  */
 #define CONFIG_DISPLAY_CPUINFO
 #define CONFIG_DISPLAY_BOARDINFO
 /* Clock Defines */
 #define V_OSCK			26000000	/* Clock output from T2 */
 #define V_SCLK			(V_OSCK >> 1)
 #undef CONFIG_USE_IRQ				/* no support for IRQs */
 #define CONFIG_MISC_INIT_R
 #define CONFIG_SKIP_LOWLEVEL_INIT		/* X-Loader set everything up */
 #define CONFIG_CMDLINE_TAG	/* enable passing kernel command line string */
 #define CONFIG_INITRD_TAG			/* enable passing initrd */
 #define CONFIG_REVISION_TAG			/* enable passing revision tag*/
 #define CONFIG_SETUP_MEMORY_TAGS		/* enable memory tag */
 /*
  * Size of malloc() pool
  */
 #define CONFIG_ENV_SIZE			(128 << 10)
 #define CONFIG_UBI_SIZE			(512 << 10)
 #define CONFIG_SYS_MALLOC_LEN		(CONFIG_ENV_SIZE + CONFIG_UBI_SIZE + \
 					(128 << 10))
 /*
  * Hardware drivers
  */
 /*
  * NS16550 Configuration
  */
 #define V_NS16550_CLK		48000000		/* 48MHz (APLL96/2) */
 #define CONFIG_SYS_NS16550
 #define CONFIG_SYS_NS16550_SERIAL
 #define CONFIG_SYS_NS16550_REG_SIZE	(-4)
 #define CONFIG_SYS_NS16550_CLK		V_NS16550_CLK
 /*
  * select serial console configuration
  */
 #define CONFIG_CONS_INDEX		3
 #define CONFIG_SYS_NS16550_COM3		OMAP34XX_UART3
 #define CONFIG_SERIAL3			3		/* UART3 on RX-51 */
 /* allow to overwrite serial and ethaddr */
 #define CONFIG_ENV_OVERWRITE
 #define CONFIG_BAUDRATE			115200
 #define CONFIG_SYS_BAUDRATE_TABLE { 4800, 9600, 19200, 38400, 57600, 115200 }
 #define CONFIG_MMC
 #define CONFIG_GENERIC_MMC
 #define CONFIG_OMAP_HSMMC
 #define CONFIG_DOS_PARTITION
 /* USB */
 #define CONFIG_MUSB_UDC
 #define CONFIG_MUSB_HDC
 #define CONFIG_USB_OMAP3
 #define CONFIG_TWL4030_USB
 /* USB device configuration */
 #define CONFIG_USB_DEVICE
 #define CONFIG_USBD_VENDORID		0x0421
 #define CONFIG_USBD_PRODUCTID		0x01c8
 #define CONFIG_USBD_MANUFACTURER	"Nokia"
 #define CONFIG_USBD_PRODUCT_NAME	"N900"
 #define CONFIG_SYS_CONSOLE_IS_IN_ENV
 #define CONFIG_SYS_NO_FLASH
 /* commands to include */
 #include <config_cmd_default.h>
 #define CONFIG_CMD_EXT2			/* EXT2 Support */
 #define CONFIG_CMD_EXT4			/* EXT4 Support */
 #define CONFIG_CMD_FAT			/* FAT support */
 #define CONFIG_CMD_I2C			/* I2C serial bus support */
 #define CONFIG_CMD_MMC			/* MMC support */
 #define CONFIG_CMD_GPIO			/* Enable gpio command */
 #define CONFIG_CMDLINE_EDITING		/* add command line history */
 #define CONFIG_AUTO_COMPLETE		/* add autocompletion support */
+#define CONFIG_CMD_BOOTMENU		/* ANSI terminal Boot Menu */
 #define CONFIG_CMD_CLEAR		/* ANSI terminal clear screen command */
 #ifdef ONENAND_SUPPORT
 #define CONFIG_CMD_ONENAND		/* ONENAND support */
 #define CONFIG_CMD_MTDPARTS		/* mtd parts support */
 #ifdef UBIFS_SUPPORT
 #define CONFIG_CMD_UBI			/* UBI Support */
 #define CONFIG_CMD_UBIFS		/* UBIFS Support */
 #endif
 #endif
 /* commands not needed from config_cmd_default.h */
 #undef CONFIG_CMD_FPGA			/* FPGA configuration Support */
 #undef CONFIG_CMD_IMI			/* iminfo */
 #undef CONFIG_CMD_NET			/* bootp, tftpboot, rarpboot */
 #undef CONFIG_CMD_NFS			/* NFS support */
 #undef CONFIG_CMD_SAVEENV		/* saveenv */
 #undef CONFIG_CMD_SETGETDCR		/* DCR support on 4xx */
 #define CONFIG_OMAP3_SPI
 #define CONFIG_HARD_I2C
 #define CONFIG_SYS_I2C_SPEED		100000
 #define CONFIG_SYS_I2C_SLAVE		1
 #define CONFIG_DRIVER_OMAP34XX_I2C
 /*
  * TWL4030
  */
 #define CONFIG_TWL4030_POWER
 #define CONFIG_TWL4030_LED
 #define CONFIG_TWL4030_KEYPAD
 #define CONFIG_OMAP_GPIO
 #define GPIO_SLIDE			71
 /*
  * Board ONENAND Info.
  */
 #define PART1_NAME			"bootloader"
 #define PART1_SIZE			128
 #define PART1_MULL			1024
 #define PART1_SUFF			"k"
 #define PART1_OFFS			0x00000000
 #define PART1_MASK			0x00000003
 #define PART2_NAME			"config"
 #define PART2_SIZE			384
 #define PART2_MULL			1024
 #define PART2_SUFF			"k"
 #define PART2_OFFS			0x00020000
 #define PART2_MASK			0x00000000
 #define PART3_NAME			"log"
 #define PART3_SIZE			256
 #define PART3_MULL			1024
 #define PART3_SUFF			"k"
 #define PART3_OFFS			0x00080000
 #define PART3_MASK			0x00000000
 #define PART4_NAME			"kernel"
 #define PART4_SIZE			2
 #define PART4_MULL			1024*1024
 #define PART4_SUFF			"m"
 #define PART4_OFFS			0x000c0000
 #define PART4_MASK			0x00000000
 #define PART5_NAME			"initfs"
 #define PART5_SIZE			2
 #define PART5_MULL			1024*1024
 #define PART5_SUFF			"m"
 #define PART5_OFFS			0x002c0000
 #define PART5_MASK			0x00000000
 #define PART6_NAME			"rootfs"
 #define PART6_SIZE			257280
 #define PART6_MULL			1024
 #define PART6_SUFF			"k"
 #define PART6_OFFS			0x004c0000
 #define PART6_MASK			0x00000000
 #ifdef ONENAND_SUPPORT
 #define PISMO1_NAND_SIZE		GPMC_SIZE_128M
 #define PISMO1_ONEN_SIZE		GPMC_SIZE_128M
 #define CONFIG_SYS_ONENAND_BASE		ONENAND_MAP
 #define CONFIG_MTD_DEVICE
 #define CONFIG_MTD_PARTITIONS
 #ifdef UBIFS_SUPPORT
 #define CONFIG_RBTREE
 #define CONFIG_LZO
 #endif
 #define MTDIDS_DEFAULT			"onenand0=onenand"
 #define MTDPARTS_DEFAULT		"mtdparts=onenand:" \
 		__stringify(PART1_SIZE) PART1_SUFF "(" PART1_NAME ")ro," \
 		__stringify(PART2_SIZE) PART2_SUFF "(" PART2_NAME ")," \
 		__stringify(PART3_SIZE) PART3_SUFF "(" PART3_NAME ")," \
 		__stringify(PART4_SIZE) PART4_SUFF "(" PART4_NAME ")," \
 		__stringify(PART5_SIZE) PART5_SUFF "(" PART5_NAME ")," \
 		"-(" PART6_NAME ")"
 #endif
 /* Watchdog support */
 #define CONFIG_HW_WATCHDOG
 /*
  * Framebuffer
  */
 /* Video console */
 #define CONFIG_VIDEO
 #define CONFIG_CFB_CONSOLE
 #define CONFIG_CFB_CONSOLE_ANSI	/* Enable ANSI escape codes in framebuffer */
 #define CONFIG_VIDEO_LOGO
 #define VIDEO_FB_16BPP_PIXEL_SWAP
 #define VIDEO_FB_16BPP_WORD_SWAP
 #define CONFIG_VIDEO_SW_CURSOR
 #define CONFIG_SPLASH_SCREEN
 /* functions for cfb_console */
 #define VIDEO_KBD_INIT_FCT		rx51_kp_init()
 #define VIDEO_TSTC_FCT			rx51_kp_tstc
 #define VIDEO_GETC_FCT			rx51_kp_getc
 #ifndef __ASSEMBLY__
 int rx51_kp_init(void);
 int rx51_kp_tstc(void);
 int rx51_kp_getc(void);
 #endif
 #ifndef MTDPARTS_DEFAULT
 #define MTDPARTS_DEFAULT
 #endif
 /* Environment information */
-#define CONFIG_BOOTDELAY		3
 #define CONFIG_EXTRA_ENV_SETTINGS \
 	"mtdparts=" MTDPARTS_DEFAULT "\0" \
 	"usbtty=cdc_acm\0" \
 	"stdin=vga\0" \
 	"stdout=vga\0" \
 	"stderr=vga\0" \
 	"setcon=setenv stdin ${con};" \
 		"setenv stdout ${con};" \
 		"setenv stderr ${con}\0" \
 	"sercon=setenv con serial; run setcon\0" \
 	"usbcon=setenv con usbtty; run setcon\0" \
 	"vgacon=setenv con vga; run setcon\0" \
 	"slide=gpio input " __stringify(GPIO_SLIDE) "\0" \
 	"switchmmc=mmc dev ${mmcnum}\0" \
 	"kernaddr=0x82008000\0" \
 	"initrdaddr=0x84008000\0" \
 	"scriptaddr=0x86008000\0" \
 	"fileload=${mmctype}load mmc ${mmcnum}:${mmcpart} " \
 		"${loadaddr} ${mmcfile}\0" \
 	"kernload=setenv loadaddr ${kernaddr};" \
 		"setenv mmcfile ${mmckernfile};" \
 		"run fileload\0" \
 	"initrdload=setenv loadaddr ${initrdaddr};" \
 		"setenv mmcfile ${mmcinitrdfile};" \
 		"run fileload\0" \
 	"scriptload=setenv loadaddr ${scriptaddr};" \
 		"setenv mmcfile ${mmcscriptfile};" \
 		"run fileload\0" \
 	"scriptboot=echo Running ${mmcscriptfile} from mmc " \
 		"${mmcnum}:${mmcpart} ...; source ${scriptaddr}\0" \
 	"kernboot=echo Booting ${mmckernfile} from mmc " \
 		"${mmcnum}:${mmcpart} ...; bootm ${kernaddr}\0" \
 	"kerninitrdboot=echo Booting ${mmckernfile} ${mmcinitrdfile} from mmc "\
 		"${mmcnum}:${mmcpart} ...; bootm ${kernaddr} ${initrdaddr}\0" \
 	"attachboot=echo Booting attached kernel image ...;" \
 		"setenv setup_omap_atag 1;" \
 		"bootm ${attkernaddr};" \
 		"setenv setup_omap_atag\0" \
 	"trymmcscriptboot=if run switchmmc; then " \
 			"if run scriptload; then " \
 				"run scriptboot;" \
 			"fi;" \
 		"fi\0" \
 	"trymmckernboot=if run switchmmc; then " \
 			"if run kernload; then " \
 				"run kernboot;" \
 			"fi;" \
 		"fi\0" \
 	"trymmckerninitrdboot=if run switchmmc; then " \
 			"if run initrdload; then " \
 				"if run kernload; then " \
 					"run kerninitrdboot;" \
 				"fi;" \
 			"fi; " \
 		"fi\0" \
 	"trymmcpartboot=setenv mmcscriptfile boot.scr; run trymmcscriptboot;" \
 		"setenv mmckernfile uImage; run trymmckernboot\0" \
 	"trymmcallpartboot=setenv mmcpart 1; run trymmcpartboot;" \
 		"setenv mmcpart 2; run trymmcpartboot;" \
 		"setenv mmcpart 3; run trymmcpartboot;" \
 		"setenv mmcpart 4; run trymmcpartboot\0" \
 	"trymmcboot=if run switchmmc; then " \
 			"setenv mmctype fat;" \
 			"run trymmcallpartboot;" \
 			"setenv mmctype ext2;" \
 			"run trymmcallpartboot;" \
 			"setenv mmctype ext4;" \
 			"run trymmcallpartboot;" \
 		"fi\0" \
 	"emmcboot=setenv mmcnum 1; run trymmcboot\0" \
 	"sdboot=setenv mmcnum 0; run trymmcboot\0" \
+	"menucmd=bootmenu\0" \
+	"bootmenu_0=Attached kernel=run attachboot\0" \
+	"bootmenu_1=Internal eMMC=run emmcboot\0" \
+	"bootmenu_2=External SD card=run sdboot\0" \
+	"bootmenu_3=U-Boot boot order=boot\0" \
+	"bootmenu_delay=30\0" \
 	""
 #define CONFIG_PREBOOT \
-	"if run slide; then true; else run attachboot; fi;" \
+	"setenv mmcnum 1; setenv mmcpart 1;" \
+	"setenv mmcscriptfile bootmenu.scr;" \
+	"if run switchmmc; then " \
+		"setenv mmcdone true;" \
+		"setenv mmctype fat;" \
+		"if run scriptload; then true; else " \
+			"setenv mmctype ext2;" \
+			"if run scriptload; then true; else " \
+				"setenv mmctype ext4;" \
+				"if run scriptload; then true; else " \
+					"setenv mmcdone false;" \
+				"fi;" \
+			"fi;" \
+		"fi;" \
+		"if ${mmcdone}; then " \
+			"run scriptboot;" \
+		"fi;" \
+	"fi;" \
+	"if run slide; then true; else " \
+		"setenv bootmenu_delay 0;" \
+		"setenv bootdelay 0;" \
+	"fi"
+#define CONFIG_POSTBOOTMENU \
+	"echo;" \
 	"echo Extra commands:;" \
 	"echo run sercon - Use serial port for control.;" \
 	"echo run usbcon - Use usbtty for control.;" \
 	"echo run vgacon - Use framebuffer/keyboard.;" \
 	"echo run sdboot - Boot from SD card slot.;" \
 	"echo run emmcboot - Boot internal eMMC memory.;" \
 	"echo run attachboot - Boot attached kernel image.;" \
 	"echo"
 #define CONFIG_BOOTCOMMAND \
 	"run sdboot;" \
 	"run emmcboot;" \
 	"run attachboot;" \
 	"echo"
+#define CONFIG_BOOTDELAY 30
+#define CONFIG_AUTOBOOT_KEYED
+#define CONFIG_MENU
+#define CONFIG_MENU_SHOW
 /*
  * Miscellaneous configurable options
  */
 #define CONFIG_SYS_LONGHELP			/* undef to save memory */
 #define CONFIG_SYS_HUSH_PARSER			/* use "hush" command parser */
 #define CONFIG_SYS_PROMPT_HUSH_PS2	"> "
 #define CONFIG_SYS_PROMPT		"Nokia RX-51 # "
 #define CONFIG_SYS_CBSIZE		256	/* Console I/O Buffer Size */
 /* Print Buffer Size */
 #define CONFIG_SYS_PBSIZE		(CONFIG_SYS_CBSIZE + \
 						sizeof(CONFIG_SYS_PROMPT) + 16)
 #define CONFIG_SYS_MAXARGS		16	/* max number of command args */
 /* Boot Argument Buffer Size */
 #define CONFIG_SYS_BARGSIZE		(CONFIG_SYS_CBSIZE)
 #define CONFIG_SYS_MEMTEST_START	(OMAP34XX_SDRC_CS0)
 #define CONFIG_SYS_MEMTEST_END		(OMAP34XX_SDRC_CS0 + 0x01F00000)/*31MB*/
 /* default load address */
 #define CONFIG_SYS_LOAD_ADDR		(OMAP34XX_SDRC_CS0)
 /*
  * OMAP3 has 12 GP timers, they can be driven by the system clock
  * (12/13/16.8/19.2/38.4MHz) or by 32KHz clock. We use 13MHz (V_SCLK).
  * This rate is divided by a local divisor.
  */
 #define CONFIG_SYS_TIMERBASE		(OMAP34XX_GPT2)
 #define CONFIG_SYS_PTV			2	/* Divisor: 2^(PTV+1) => 8 */
 #define CONFIG_SYS_HZ			1000
 /*
  * Stack sizes
  *
  * The stack sizes are set up in start.S using the settings below
  */
 #define CONFIG_STACKSIZE		(128 << 10) /* regular stack 128 KiB */
 /*
  * Physical Memory Map
  */
 #define CONFIG_NR_DRAM_BANKS		2
 #define PHYS_SDRAM_1			OMAP34XX_SDRC_CS0
 /*
  * FLASH and environment organization
  */
 #define CONFIG_ENV_IS_NOWHERE
 #define CONFIG_SYS_SDRAM_BASE		PHYS_SDRAM_1
 #define CONFIG_SYS_INIT_RAM_ADDR	0x4020f800
 #define CONFIG_SYS_INIT_RAM_SIZE	0x800
 #define CONFIG_SYS_INIT_SP_ADDR		(CONFIG_SYS_INIT_RAM_ADDR + \
 			CONFIG_SYS_INIT_RAM_SIZE - GENERATED_GBL_DATA_SIZE)
 /*
  * Attached kernel image
  */
 #define SDRAM_SIZE			0x10000000	/* 256 MB */
 #define SDRAM_END			(CONFIG_SYS_SDRAM_BASE + SDRAM_SIZE)
 #define IMAGE_MAXSIZE			0x1FF800	/* 2 MB - 2 kB */
 #define KERNEL_OFFSET			0x40000		/* 256 kB */
 #define KERNEL_MAXSIZE			(IMAGE_MAXSIZE-KERNEL_OFFSET)
 #define KERNEL_ADDRESS			(SDRAM_END-KERNEL_MAXSIZE)
 /* Reserve protected RAM for attached kernel */
 #define CONFIG_PRAM			((KERNEL_MAXSIZE >> 10)+1)

include/menu.h

Diff comments View file @ 5644369

 /*
  * Copyright 2010-2011 Calxeda, Inc.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
  * Software Foundation; either version 2 of the License, or (at your option)
  * any later version.
  *
  * This program is distributed in the hope it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  * more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #ifndef __MENU_H__
 #define __MENU_H__
 struct menu;
 struct menu *menu_create(char *title, int timeout, int prompt,
-				void (*item_data_print)(void *));
+				void (*item_data_print)(void *),
+				char *(*item_choice)(void *),
+				void *item_choice_data);
 int menu_default_set(struct menu *m, char *item_key);
 int menu_get_choice(struct menu *m, void **choice);
 int menu_item_add(struct menu *m, char *item_key, void *item_data);
 int menu_destroy(struct menu *m);
 void menu_display_statusline(struct menu *m);
+int menu_default_choice(struct menu *m, void **choice);
 #if defined(CONFIG_MENU_SHOW)
 int menu_show(int bootdelay);
 #endif
 #endif /* __MENU_H__ */