}
debug("Starting %s process...\n", __FUNCTION__);
-#if !defined(CONFIG_SYS_HUSH_PARSER)
- ret = run_command (s, 0);
-#else
- ret = parse_string_outer(s, FLAG_PARSE_SEMICOLON
- | FLAG_EXIT_FROM_LOOP);
-#endif
+ ret = run_command(s, 0);
if (ret < 0)
debug("Error.. %s failed\n", __FUNCTION__);
else
int board_eth_init(bd_t *bis)
{
- return pci_eth_init(bis);
+ int ret;
+ ret = pci_eth_init(bis);
+ if (!ret)
+ ret = mv6436x_eth_initialize(bis);
+ return ret;
}
void db64360_eth0_disable(void);
bool network_start(bd_t *bis);
+int mv6436x_eth_initialize(bd_t *);
#endif /* __EVB64360_ETH_H__ */
int board_eth_init(bd_t *bis)
{
- return pci_eth_init(bis);
+ int ret;
+ ret = pci_eth_init(bis);
+ if (!ret)
+ ret = mv6446x_eth_initialize(bis);
+ return ret;
}
void db64460_eth0_disable(void);
bool network_start(bd_t *bis);
+int mv6446x_eth_initialize(bd_t *);
+
#endif /* __EVB64460_ETH_H__ */
* Call run_cmd
*/
printf("running command at addr 0x%s ...\n", addr);
- run_command((char*)la, 0);
+ run_command((char *)la, 0);
break;
default:
pldver, 1, 1, do_pldver,
"Show PLD version",
"Show PLD version)");
+
+int board_eth_init(bd_t *bis)
+{
+ return mv6436x_eth_initialize(bis);
+}
void db64360_eth0_disable(void);
bool network_start(bd_t *bis);
+int mv6436x_eth_initialize(bd_t *);
#endif /* __EVB64360_ETH_H__ */
*d = '\0';
start = get_ticks();
- ret = run_command (cmd, 0);
+ ret = run_command(cmd, 0);
end = get_ticks();
printf("ticks=%ld\n", (ulong)(end - start));
void db64360_eth0_disable(void);
bool network_start(bd_t *bis);
+int mv6446x_eth_initialize(bd_t *);
#endif /* __EVB64360_ETH_H__ */
!= temp);
}
+
+int board_eth_init(bd_t *bis)
+{
+ return mv6446x_eth_initialize(bis);
+}
len = dis_last_len;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if ((flag & CMD_FLAG_REPEAT) == 0) {
/* New command */
int rcode = 0;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
printf ("\nEnter '.' when done\n");
mem_addr = simple_strtoul (argv[1], NULL, 16);
if (len == -1)
printf ("<INTERRUPT>\n");
else
- rc = run_command (lastcommand, flag);
+ rc = run_command(lastcommand, flag);
if (rc <= 0) {
/* invalid command or not repeatable, forget it */
addr = simple_strtoul(argv[1], NULL, 16);
break;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
return (bmp_info(addr));
y = simple_strtoul(argv[3], NULL, 10);
break;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
return (bmp_display(addr, x, y));
if (c)
return c->cmd(cmdtp, flag, argc, argv);
else
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
U_BOOT_CMD(
int rcode = 0;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
addr = simple_strtoul(argv[1], NULL, 16);
}
} else {
/* Unrecognized command */
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
if (images.state >= state) {
printf("Trying to execute a command out of order\n");
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
images.state |= state;
{
int rcode = 0;
-#ifndef CONFIG_SYS_HUSH_PARSER
if (run_command(getenv("bootcmd"), flag) < 0)
rcode = 1;
-#else
- if (parse_string_outer(getenv("bootcmd"),
- FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP) != 0)
- rcode = 1;
-#endif
return rcode;
}
icache_status() ? "ON" : "OFF");
return 0;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
return 0;
}
dcache_status() ? "ON" : "OFF");
return 0;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
return 0;
AT91F_GetMuxStatus () ? "MMC" : "SPI");
return 0;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
return 0;
}
break;
default:
- cmd_usage(cmdtp);
- rcode = 1;
+ rcode = CMD_RET_USAGE;
}
/* switch back to original I2C bus */
/* Validate arguments */
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* Get a DCR */
dcrn = (unsigned short) simple_strtoul (argv[1], NULL, 16);
/* Validate arguments */
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* Set a DCR */
dcrn = (unsigned short) simple_strtoul (argv[1], NULL, 16);
/* Validate arguments */
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* Find out whether ther is '.' (dot) symbol in the first parameter. */
strncpy (buf, argv[1], sizeof(buf)-1);
/* Validate arguments */
if (argc < 4)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* Find out whether ther is '.' (dot) symbol in the first parameter. */
strncpy (buf, argv[1], sizeof(buf)-1);
}
usage:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
U_BOOT_CMD(
}
}
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
#endif
int part_length;
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
dev = (int)simple_strtoul (argv[2], &ep, 16);
dev_desc = get_dev(argv[1],dev);
break;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
if (!filename) {
boot_drive=simple_strtoul(argv[2], NULL, 10);
break;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
/* setup FDC and scan for drives */
if(fdc_setup(boot_drive,pCMD,pFG)==FALSE) {
name = argv [2];
break;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
/* Init physical layer */
int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* Set the address of the fdt
int err;
if (argc < 4)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* Set the address and length of the fdt.
* Parameters: Node path, new node to be appended to the path.
*/
if (argc < 4)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
pathp = argv[2];
nodep = argv[3];
* Parameters: Node path, property, optional value.
*/
if (argc < 4)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
pathp = argv[2];
prop = argv[3];
}
} else {
/* Unrecognized command */
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
}
#ifdef CONFIG_OF_BOARD_SETUP
unsigned long initrd_start = 0, initrd_end = 0;
if ((argc != 2) && (argc != 4))
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if (argc == 4) {
initrd_start = simple_strtoul(argv[2], NULL, 16);
}
else {
/* Unrecognized command */
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
return 0;
ulong addr = 0UL;
if (argc > 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if (argc == 2)
addr = simple_strtoul(argv[1], NULL, 16);
int rcode = 0;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if (strcmp(argv[1], "all") == 0) {
for (bank=1; bank<=CONFIG_SYS_MAX_FLASH_BANKS; ++bank) {
#endif
if (argc != 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if (strcmp(argv[1], "bank") == 0) {
bank = simple_strtoul(argv[2], NULL, 16);
}
if (addr_first >= addr_last)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
rcode = flash_sect_erase(addr_first, addr_last);
return rcode;
#endif
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
#if !defined(CONFIG_SYS_NO_FLASH) || defined(CONFIG_HAS_DATAFLASH)
if (strcmp(argv[1], "off") == 0)
else if (strcmp(argv[1], "on") == 0)
p = 1;
else
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
#endif
#ifdef CONFIG_HAS_DATAFLASH
#endif
if (argc != 4)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if (strcmp(argv[2], "bank") == 0) {
bank = simple_strtoul(argv[3], NULL, 16);
}
if (addr_first >= addr_last)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
rcode = flash_sect_protect (p, addr_first, addr_last);
#endif /* CONFIG_SYS_NO_FLASH */
switch (op) {
case FPGA_NONE:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
case FPGA_INFO:
rc = fpga_info (dev);
default:
printf ("Unknown operation\n");
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
return (rc);
}
if (argc != 3)
show_usage:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
str_cmd = argv[1];
str_gpio = argv[2];
u_char *memaddr;
if (argc != 5)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* I2C chip address
devaddr = simple_strtoul(argv[2], NULL, 16);
alen = get_alen(argv[2]);
if (alen > 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* Length is the number of objects, not number of bytes.
length = i2c_dp_last_length;
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if ((flag & CMD_FLAG_REPEAT) == 0) {
/*
addr = simple_strtoul(argv[2], NULL, 16);
alen = get_alen(argv[2]);
if (alen > 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* If another parameter, it is the length to display.
int count;
if ((argc < 4) || (argc > 5))
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* Chip is always specified.
addr = simple_strtoul(argv[2], NULL, 16);
alen = get_alen(argv[2]);
if (alen > 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* Value to write is always specified.
ulong err;
if (argc < 4)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* Chip is always specified.
addr = simple_strtoul(argv[2], NULL, 16);
alen = get_alen(argv[2]);
if (alen > 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* Count is always specified
int nbytes;
if (argc != 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
#ifdef CONFIG_BOOT_RETRY_TIME
reset_cmd_timeout(); /* got a good command to get here */
addr = simple_strtoul(argv[2], NULL, 16);
alen = get_alen(argv[2]);
if (alen > 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
/*
int delay;
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* Chip is always specified.
addr = simple_strtoul(argv[2], NULL, 16);
alen = get_alen(argv[2]);
if (alen > 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* Length is the number of objects, not number of bytes.
};
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* Chip is always specified.
cmd_tbl_t *c;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* Strip off leading 'i2c' command argument */
argc--;
c = find_cmd_tbl(argv[0], &cmd_i2c_sub[0], ARRAY_SIZE(cmd_i2c_sub));
if (c)
- return c->cmd(cmdtp, flag, argc, argv);
+ return c->cmd(cmdtp, flag, argc, argv);
else
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
/***************************************************/
switch (argc) {
case 0:
case 1:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
case 2:
if (strncmp(argv[1], "res", 3) == 0) {
puts("\nReset IDE"
}
return rcode;
}
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
case 3:
if (strncmp(argv[1], "dev", 3) == 0) {
int dev = (int) simple_strtoul(argv[2], NULL, 10);
return rcode;
}
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
default:
/* at least 4 args */
else
return 1;
} else {
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
return rcode;
break;
default:
show_boot_progress(-42);
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
show_boot_progress(42);
{
if (argc != 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* on */
if (strncmp(argv[1], "on", 2) == 0)
/* Validate arguments */
if ((argc != 4))
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* Check for a data width specification.
* Defaults to long (4) if no specification.
/* Validate arguments */
if ((argc != 3)) {
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
cmd = get_led_cmd(argv[2]);
if (cmd < 0) {
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
for (i = 0; led_commands[i].string; i++) {
/* If we ran out of matches, print Usage */
if (!match) {
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
return 0;
if (strcmp(argv[1], "on") == 0)
hwflow_onoff(1);
else
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
printf("RTS/CTS hardware flow control: %s\n", hwflow_onoff(0) ? "on" : "off");
return 0;
}
return 0;
}
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
}
u8 output[16];
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
addr = simple_strtoul(argv[1], NULL, 16);
len = simple_strtoul(argv[2], NULL, 16);
struct mii_dev *bus;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* We use the last specified parameters, unless new ones are
length = dp_last_length;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if ((flag & CMD_FLAG_REPEAT) == 0) {
/* New command specified. Check for a size specification.
int size;
if ((argc < 3) || (argc > 4))
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* Check for size specification.
*/
ulong count;
if (argc < 4)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
count = simple_strtoul(argv[3], NULL, 10);
ulong count;
if (argc < 4)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
count = simple_strtoul(argv[3], NULL, 10);
int rcode = 0;
if (argc != 4)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* Check for size specification.
*/
int size;
if (argc != 4)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* Check for size specification.
*/
volatile u_char *cp;
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* Check for a size spefication.
* Defaults to long if no or incorrect specification.
volatile u_char *cp;
if (argc < 4)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* Check for a size spefication.
* Defaults to long if no or incorrect specification.
int nbytes, size;
if (argc != 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
#ifdef CONFIG_BOOT_RETRY_TIME
reset_cmd_timeout(); /* got a good command to get here */
ulong *ptr;
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
addr = simple_strtoul (argv[1], NULL, 16);
addr += base_address;
if (argc < 3) {
usage:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
av = argv + 1;
unsigned int blocking;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
fslnum = (unsigned int)simple_strtoul (argv[1], NULL, 16);
blocking = (unsigned int)simple_strtoul (argv[2], NULL, 16);
if (fslnum < 0 || fslnum >= XILINX_FSL_NUMBER) {
puts ("Bad number of FSL\n");
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
switch (fslnum) {
unsigned int blocking;
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
fslnum = (unsigned int)simple_strtoul (argv[1], NULL, 16);
num = (unsigned int)simple_strtoul (argv[2], NULL, 16);
blocking = (unsigned int)simple_strtoul (argv[3], NULL, 16);
if (fslnum < 0 || fslnum >= XILINX_FSL_NUMBER)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
switch (fslnum) {
#if (XILINX_FSL_NUMBER > 0)
unsigned int val = 0;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
reg = (unsigned int)simple_strtoul (argv[1], NULL, 16);
val = (unsigned int)simple_strtoul (argv[2], NULL, 16);
return 1;
break;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
return 0;
}
const char *devname;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
#if defined(CONFIG_MII_INIT)
mii_init ();
else
miiphy_set_current_dev (argv[2]);
} else {
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
/*
ulong delay;
if (argc != 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
delay = simple_strtoul(argv[1], NULL, 10) * CONFIG_SYS_HZ;
int dev;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if (strcmp(argv[1], "init") == 0) {
if (argc == 2) {
} else if (argc == 3) {
dev = (int)simple_strtoul(argv[2], NULL, 10);
} else {
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
if (mmc_legacy_init(dev) != 0) {
#endif
curr_device = dev;
} else {
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
printf("mmc%d is current device\n", curr_device);
} else {
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
return 0;
enum mmc_state state;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if (curr_device < 0) {
if (get_mmc_num() > 0)
return 1;
}
} else
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
mmc = find_mmc_device(dev);
if (!mmc) {
return (n == cnt) ? 0 : 1;
}
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
U_BOOT_CMD(
return 0;
usage:
- cmd_usage(cmdtp);
- return 1;
+ return CMD_RET_USAGE;
}
U_BOOT_CMD(
unsigned long cpuid;
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
cpuid = simple_strtoul(argv[1], NULL, 10);
if (!is_core_valid(cpuid)) {
else if (strncmp(argv[2], "disable", 7) == 0)
return cpu_disable(cpuid);
else
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
return 0;
}
/* 4 or greater, make sure its release */
if (strncmp(argv[2], "release", 7) != 0)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if (cpu_release(cpuid, argc - 3, argv + 3))
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
return 0;
}
return spread_partitions();
#endif /* CONFIG_CMD_MTDPARTS_SPREAD */
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
/***************************************************/
return ret;
usage:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
#endif
#endif
usage:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
U_BOOT_CMD(
usage:
#endif
show_boot_progress(-53);
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
show_boot_progress(53);
#endif
default:
show_boot_progress (-80);
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
show_boot_progress (80);
NetPingIP = string_to_ip(argv[1]);
if (NetPingIP == 0)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if (NetLoop(PING) < 0) {
printf("ping failed; host %s is not alive\n", argv[1]);
int do_dns(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
if (argc == 1)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* We should check for a valid hostname:
int rcode = 1, arg = 1, idx;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
memset(matched, 0, env_htab.size / 8);
int do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
return _do_env_set(flag, argc, argv);
}
/* Check the syntax */
switch (argc) {
case 1:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
case 2: /* env_ask envname */
sprintf(message, "Please enter '%s':", argv[1]);
char *init_val;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* Set read buffer to initial value or empty sting */
init_val = getenv(argv[1]);
int argc, char * const argv[])
{
if (argc != 2 || strcmp(argv[1], "-f") != 0)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
set_default_env("## Resetting to default environment\n");
return 0;
sep = '\n';
break;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
}
NXTARG: ;
}
if (argc < 1)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
addr = (char *)simple_strtoul(argv[0], NULL, 16);
del = 1;
break;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
}
}
if (argc < 1)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if (!fmt)
printf("## Warning: defaulting to text format\n");
cmd_tbl_t *cp;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* drop initial "env" arg */
argc--;
if (cp)
return cp->cmd(cmdtp, flag, argc, argv);
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
U_BOOT_CMD(
size_t retlen = 0;
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
s = strchr(argv[0], '.');
if ((s != NULL) && (!strcmp(s, ".oob")))
size_t retlen = 0;
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if (strncmp(argv[0] + 6, "yaffs", 5) == 0)
withoob = 1;
char *s;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
s = strchr(argv[0], '.');
ofs = (int)simple_strtoul(argv[1], NULL, 16);
argv += 2;
if (argc <= 0)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
while (argc > 0) {
addr = simple_strtoul(*argv, NULL, 16);
cmd_tbl_t *c;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
mtd = &onenand_mtd;
if (c)
return c->cmd(cmdtp, flag, argc, argv);
else
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
U_BOOT_CMD(
if (argc < 4) {
usage:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
prompt_user = false;
return 1;
usage:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
/***************************************************/
uint value = out_last_value;
if (argc != 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if ((flag & CMD_FLAG_REPEAT) == 0) {
/*
uint size = in_last_size;
if (argc != 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if ((flag & CMD_FLAG_REPEAT) == 0) {
/*
int err;
if (argc != 1)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
pxefile_addr_str = from_env("pxefile_addr_r");
printf("running: %s\n", dupcmd);
- ret = run_command2(dupcmd, 0);
+ ret = run_command(dupcmd, 0);
free(dupcmd);
} else if (argc == 2) {
pxefile_addr_str = argv[1];
} else {
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
if (strict_strtoul(pxefile_addr_str, 16, &pxefile_addr_r) < 0) {
cmd_tbl_t *cp;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/* drop initial "pxe" arg */
argc--;
if (cp)
return cp->cmd(cmdtp, flag, argc, argv);
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
U_BOOT_CMD(
int part_length;
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
dev = (int)simple_strtoul (argv[2], &ep, 16);
dev_desc = get_dev(argv[1],dev);
break;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
if (!filename) {
switch (argc) {
case 0:
case 1:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
case 2:
if (strncmp(argv[1],"inf", 3) == 0) {
int i;
}
return rc;
}
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
case 3:
if (strncmp(argv[1], "dev", 3) == 0) {
int dev = (int)simple_strtoul(argv[2], NULL, 10);
}
return rc;
}
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
default: /* at least 4 args */
if (strcmp(argv[1], "read") == 0) {
n, (n == cnt) ? "OK" : "ERROR");
return (n == cnt) ? 0 : 1;
} else {
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
return rc;
boot_device = argv[2];
break;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
if (!boot_device) {
int do_scsi (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
switch (argc) {
- case 0:
- case 1: return cmd_usage(cmdtp);
+ case 0:
+ case 1:
+ return CMD_RET_USAGE;
- case 2:
+ case 2:
if (strncmp(argv[1],"res",3) == 0) {
printf("\nReset SCSI\n");
scsi_bus_reset();
printf("\nno SCSI devices available\n");
return 1;
}
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
case 3:
if (strncmp(argv[1],"dev",3) == 0) {
int dev = (int)simple_strtoul(argv[2], NULL, 10);
}
return 1;
}
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
default:
/* at least 4 args */
if (strcmp(argv[1],"read") == 0) {
return 0;
}
} /* switch */
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
/****************************************************************************************
/* Validate arguments */
if ((argc != 5) || (strlen(argv[3]) != 1))
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
w = cmd_get_data_size(argv[0], 4);
return ret;
usage:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
U_BOOT_CMD(
u8 output[20];
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
addr = simple_strtoul(argv[1], NULL, 16);
len = simple_strtoul(argv[2], NULL, 16);
if (*line) {
debug ("** exec: \"%s\"\n",
line);
- if (run_command (line, 0) < 0) {
+ if (run_command(line, 0) < 0) {
rcode = 1;
break;
}
int do_strings(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
if (argc == 1)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if ((flag & CMD_FLAG_REPEAT) == 0) {
start_addr = (char *)simple_strtoul(argv[1], NULL, 16);
return 1;
}
if (argc > cmdtp->maxargs)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
/*
* TODO(clchiou): get_timer_masked() is only defined in certain ARM
int retval = 0;
if (argc == 1)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
retval = run_command_and_time_it(0, argc - 1, argv + 1, &cycles);
report_time(cycles);
int err = 0;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if (mtdparts_init() != 0) {
printf("Error initializing mtdparts!\n");
}
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
#ifdef CONFIG_CMD_UBIFS
/*
int ret;
if (argc != 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
vol_name = argv[1];
debug("Using volume %s\n", vol_name);
int do_ubifs_umount(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
if (argc != 1)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if (ubifs_initialized == 0) {
printf("No UBIFS volume mounted!\n");
}
if (argc < 3)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
addr = simple_strtoul(argv[1], &endp, 16);
if (endp == argv[1])
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
filename = argv[2];
if (argc == 4) {
size = simple_strtoul(argv[3], &endp, 16);
if (endp == argv[3])
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
debug("Loading file '%s' to address 0x%08x (size %d)\n", filename, addr, size);
dst = simple_strtoul(argv[2], NULL, 16);
break;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
if (gunzip((void *) dst, dst_len, (void *) src, &src_len) != 0)
boot_device = argv[2];
break;
default:
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
if (!boot_device) {
#endif
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
if ((strncmp(argv[1], "reset", 5) == 0) ||
(strncmp(argv[1], "start", 5) == 0)) {
return 0;
}
#endif /* CONFIG_USB_STORAGE */
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
}
#ifdef CONFIG_USB_STORAGE
}
}
#endif
+
+/**
+ * Call a command function. This should be the only route in U-Boot to call
+ * a command, so that we can track whether we are waiting for input or
+ * executing a command.
+ *
+ * @param cmdtp Pointer to the command to execute
+ * @param flag Some flags normally 0 (see CMD_FLAG_.. above)
+ * @param argc Number of arguments (arg 0 must be the command text)
+ * @param argv Arguments
+ * @return 0 if command succeeded, else non-zero (CMD_RET_...)
+ */
+static int cmd_call(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+ int result;
+
+ result = (cmdtp->cmd)(cmdtp, flag, argc, argv);
+ if (result)
+ debug("Command failed, result=%d", result);
+ return result;
+}
+
+enum command_ret_t cmd_process(int flag, int argc, char * const argv[],
+ int *repeatable)
+{
+ enum command_ret_t rc = CMD_RET_SUCCESS;
+ cmd_tbl_t *cmdtp;
+
+ /* Look up command in command table */
+ cmdtp = find_cmd(argv[0]);
+ if (cmdtp == NULL) {
+ printf("Unknown command '%s' - try 'help'\n", argv[0]);
+ return 1;
+ }
+
+ /* found - check max args */
+ if (argc > cmdtp->maxargs)
+ rc = CMD_RET_USAGE;
+
+#if defined(CONFIG_CMD_BOOTD)
+ /* avoid "bootd" recursion */
+ else if (cmdtp->cmd == do_bootd) {
+ if (flag & CMD_FLAG_BOOTD) {
+ puts("'bootd' recursion detected\n");
+ rc = CMD_RET_FAILURE;
+ } else {
+ flag |= CMD_FLAG_BOOTD;
+ }
+ }
+#endif
+
+ /* If OK so far, then do the command */
+ if (!rc) {
+ rc = cmd_call(cmdtp, flag, argc, argv);
+ *repeatable &= cmdtp->repeatable;
+ }
+ if (rc == CMD_RET_USAGE)
+ rc = cmd_usage(cmdtp);
+ return rc;
+}
int nextin;
int flag = do_repeat ? CMD_FLAG_REPEAT : 0;
struct child_prog *child;
- cmd_tbl_t *cmdtp;
char *p;
# if __GNUC__
/* Avoid longjmp clobbering */
* Is it really safe for inline use? Experimentally,
* things seem to work with glibc. */
setup_redirects(child, squirrel);
-#else
- /* check ";", because ,example , argv consist from
- * "help;flinfo" must not execute
- */
- if (strchr(child->argv[i], ';')) {
- printf ("Unknown command '%s' - try 'help' or use 'run' command\n",
- child->argv[i]);
- return -1;
- }
- /* Look up command in command table */
-
- if ((cmdtp = find_cmd(child->argv[i])) == NULL) {
- printf ("Unknown command '%s' - try 'help'\n", child->argv[i]);
- return -1; /* give up after bad command */
- } else {
- int rcode;
-#if defined(CONFIG_CMD_BOOTD)
- /* avoid "bootd" recursion */
- if (cmdtp->cmd == do_bootd) {
- if (flag & CMD_FLAG_BOOTD) {
- printf ("'bootd' recursion detected\n");
- return -1;
- }
- else
- flag |= CMD_FLAG_BOOTD;
- }
-#endif
- /* found - check max args */
- if ((child->argc - i) > cmdtp->maxargs)
- return cmd_usage(cmdtp);
-#endif
- child->argv+=i; /* XXX horrible hack */
-#ifndef __U_BOOT__
+ child->argv += i; /* XXX horrible hack */
rcode = x->function(child);
-#else
- /* OK - call function to do the command */
-
- rcode = (cmdtp->cmd)
-(cmdtp, flag,child->argc-i,&child->argv[i]);
- if ( !cmdtp->repeatable )
- flag_repeat = 0;
-
-
-#endif
- child->argv-=i; /* XXX restore hack so free() can work right */
-#ifndef __U_BOOT__
-
+ /* XXX restore hack so free() can work right */
+ child->argv -= i;
restore_redirects(squirrel);
-#endif
-
- return rcode;
}
+ return rcode;
}
-#ifndef __U_BOOT__
+#else
+ /* check ";", because ,example , argv consist from
+ * "help;flinfo" must not execute
+ */
+ if (strchr(child->argv[i], ';')) {
+ printf("Unknown command '%s' - try 'help' or use "
+ "'run' command\n", child->argv[i]);
+ return -1;
+ }
+ /* Process the command */
+ return cmd_process(flag, child->argc, child->argv,
+ &flag_repeat);
+#endif
}
+#ifndef __U_BOOT__
for (i = 0; i < pi->num_progs; i++) {
child = & (pi->progs[i]);
# endif /* CONFIG_AUTOBOOT_KEYED */
#endif /* CONFIG_BOOTDELAY >= 0 */
-/*
- * Return 0 on success, or != 0 on error.
- */
-#ifndef CONFIG_CMD_PXE
-static inline
-#endif
-int run_command2(const char *cmd, int flag)
-{
-#ifndef CONFIG_SYS_HUSH_PARSER
- /*
- * run_command can return 0 or 1 for success, so clean up its result.
- */
- if (run_command(cmd, flag) == -1)
- return 1;
-
- return 0;
-#else
- return parse_string_outer(cmd,
- FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP);
-#endif
-}
-
/****************************************************************************/
void main_loop (void)
int prev = disable_ctrlc(1); /* disable Control C checking */
# endif
- run_command2(p, 0);
+ run_command(p, 0);
# ifdef CONFIG_AUTOBOOT_KEYED
disable_ctrlc(prev); /* restore Control C checking */
int prev = disable_ctrlc(1); /* disable Control C checking */
# endif
- run_command2(s, 0);
+ run_command(s, 0);
# ifdef CONFIG_AUTOBOOT_KEYED
disable_ctrlc(prev); /* restore Control C checking */
if (menukey == CONFIG_MENUKEY) {
s = getenv("menucmd");
if (s)
- run_command2(s, 0);
+ run_command(s, 0);
}
#endif /* CONFIG_MENUKEY */
#endif /* CONFIG_BOOTDELAY */
if (len == -1)
puts ("<INTERRUPT>\n");
else
- rc = run_command (lastcommand, flag);
+ rc = run_command(lastcommand, flag);
if (rc <= 0) {
/* invalid command or not repeatable, forget it */
/****************************************************************************/
+#ifndef CONFIG_SYS_HUSH_PARSER
static void process_macros (const char *input, char *output)
{
char c, prev;
* the environment data, which may change magicly when the command we run
* creates or modifies environment variables (like "bootp" does).
*/
-
-int run_command (const char *cmd, int flag)
+static int builtin_run_command(const char *cmd, int flag)
{
- cmd_tbl_t *cmdtp;
char cmdbuf[CONFIG_SYS_CBSIZE]; /* working copy of cmd */
char *token; /* start of token in cmdbuf */
char *sep; /* end of token (separator) in cmdbuf */
continue;
}
- /* Look up command in command table */
- if ((cmdtp = find_cmd(argv[0])) == NULL) {
- printf ("Unknown command '%s' - try 'help'\n", argv[0]);
- rc = -1; /* give up after bad command */
- continue;
- }
-
- /* found - check max args */
- if (argc > cmdtp->maxargs) {
- cmd_usage(cmdtp);
- rc = -1;
- continue;
- }
-
-#if defined(CONFIG_CMD_BOOTD)
- /* avoid "bootd" recursion */
- if (cmdtp->cmd == do_bootd) {
-#ifdef DEBUG_PARSER
- printf ("[%s]\n", finaltoken);
-#endif
- if (flag & CMD_FLAG_BOOTD) {
- puts ("'bootd' recursion detected\n");
- rc = -1;
- continue;
- } else {
- flag |= CMD_FLAG_BOOTD;
- }
- }
-#endif
-
- /* OK - call function to do the command */
- if ((cmdtp->cmd) (cmdtp, flag, argc, argv) != 0) {
- rc = -1;
- }
-
- repeatable &= cmdtp->repeatable;
+ rc = cmd_process(flag, argc, argv, &repeatable);
/* Did the user stop this? */
if (had_ctrlc ())
return rc ? rc : repeatable;
}
+#endif
+
+/*
+ * Run a command using the selected parser.
+ *
+ * @param cmd Command to run
+ * @param flag Execution flags (CMD_FLAG_...)
+ * @return 0 on success, or != 0 on error.
+ */
+int run_command(const char *cmd, int flag)
+{
+#ifndef CONFIG_SYS_HUSH_PARSER
+ /*
+ * builtin_run_command can return 0 or 1 for success, so clean up
+ * its result.
+ */
+ if (builtin_run_command(cmd, flag) == -1)
+ return 1;
+
+ return 0;
+#else
+ return parse_string_outer(cmd,
+ FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP);
+#endif
+}
/****************************************************************************/
int i;
if (argc < 2)
- return cmd_usage(cmdtp);
+ return CMD_RET_USAGE;
for (i=1; i<argc; ++i) {
char *arg;
return 1;
}
- if (run_command2(arg, flag) != 0)
+ if (run_command(arg, flag) != 0)
return 1;
}
return 0;
#endif
extern int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+/*
+ * Error codes that commands return to cmd_process(). We use the standard 0
+ * and 1 for success and failure, but add one more case - failure with a
+ * request to call cmd_usage(). But the cmd_process() function handles
+ * CMD_RET_USAGE itself and after calling cmd_usage() it will return 1.
+ * This is just a convenience for commands to avoid them having to call
+ * cmd_usage() all over the place.
+ */
+enum command_ret_t {
+ CMD_RET_SUCCESS, /* 0 = Success */
+ CMD_RET_FAILURE, /* 1 = Failure */
+ CMD_RET_USAGE = -1, /* Failure, please report 'usage' error */
+};
+
+/**
+ * Process a command with arguments. We look up the command and execute it
+ * if valid. Otherwise we print a usage message.
+ *
+ * @param flag Some flags normally 0 (see CMD_FLAG_.. above)
+ * @param argc Number of arguments (arg 0 must be the command text)
+ * @param argv Arguments
+ * @param repeatable This function sets this to 0 if the command is not
+ * repeatable. If the command is repeatable, the value
+ * is left unchanged.
+ * @return 0 if the command succeeded, 1 if it failed
+ */
+int cmd_process(int flag, int argc, char * const argv[],
+ int *repeatable);
+
#endif /* __ASSEMBLY__ */
/*
#if defined(CONFIG_NEEDS_MANUAL_RELOC)
void fixup_cmdtable(cmd_tbl_t *cmdtp, int size);
#endif
+
#endif /* __COMMAND_H */
/* common/main.c */
void main_loop (void);
-int run_command (const char *cmd, int flag);
-#ifdef CONFIG_CMD_PXE
-int run_command2(const char *cmd, int flag);
-#endif
+int run_command(const char *cmd, int flag);
int readline (const char *const prompt);
int readline_into_buffer(const char *const prompt, char *buffer,
int timeout);
int cpu_eth_init(bd_t *bis) __attribute__((weak, alias("__def_eth_init")));
int board_eth_init(bd_t *bis) __attribute__((weak, alias("__def_eth_init")));
-extern int mv6436x_eth_initialize(bd_t *);
-extern int mv6446x_eth_initialize(bd_t *);
-
#ifdef CONFIG_API
extern void (*push_packet)(volatile void *, int);
} else
printf("Net Initialization Skipped\n");
-#if defined(CONFIG_DB64360) || defined(CONFIG_CPCI750)
- mv6436x_eth_initialize(bis);
-#endif
-#if defined(CONFIG_DB64460) || defined(CONFIG_P3Mx)
- mv6446x_eth_initialize(bis);
-#endif
if (!eth_devices) {
puts ("No ethernet found.\n");
show_boot_progress (-64);
projects / oweals / u-boot.git / commitdiff