/* Allow ports to override the default behavior */
__attribute__((weak))
-unsigned long do_go_exec (ulong (*entry)(int, char * const []), int argc, char * const argv[])
+unsigned long do_go_exec(ulong (*entry)(int, char * const []), int argc,
+ char * const argv[])
{
return entry (argc, argv);
}
-int do_go (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_go(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
ulong addr, rc;
int rcode = 0;
bootm_headers_t images; /* pointers to os/initrd/fdt images */
/* Allow for arch specific config before we boot */
-void __arch_preboot_os(void)
+static void __arch_preboot_os(void)
{
/* please define platform specific arch_preboot_os() */
}
U_BOOT_CMD_MKENT(go, 0, 1, (void *)BOOTM_STATE_OS_GO, "", ""),
};
-int do_bootm_subcommand(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_bootm_subcommand(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
int ret = 0;
return (void *)img_addr;
}
-U_BOOT_CMD(
- bootm, CONFIG_SYS_MAXARGS, 1, do_bootm,
- "boot application image from memory",
+#ifdef CONFIG_SYS_LONGHELP
+static char bootm_help_text[] =
"[addr [arg ...]]\n - boot application image stored in memory\n"
"\tpassing arguments 'arg ...'; when booting a Linux kernel,\n"
"\t'arg' can be the address of an initrd image\n"
"\tcmdline - OS specific command line processing/setup\n"
"\tbdt - OS specific bd_t processing\n"
"\tprep - OS specific prep before relocation or go\n"
- "\tgo - start OS"
+ "\tgo - start OS";
+#endif
+
+U_BOOT_CMD(
+ bootm, CONFIG_SYS_MAXARGS, 1, do_bootm,
+ "boot application image from memory", bootm_help_text
);
/*******************************************************************/
/* iminfo - print header info for a requested image */
/*******************************************************************/
#if defined(CONFIG_CMD_IMI)
-int do_iminfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_iminfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int arg;
ulong addr;
/* imls - list all images found in flash */
/*******************************************************************/
#if defined(CONFIG_CMD_IMLS)
-int do_imls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_imls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
flash_info_t *info;
int i, j;
return 1;
}
-U_BOOT_CMD(
- bootz, CONFIG_SYS_MAXARGS, 1, do_bootz,
- "boot Linux zImage image from memory",
+#ifdef CONFIG_SYS_LONGHELP
+static char bootz_help_text[] =
"[addr [initrd[:size]] [fdt]]\n"
" - boot Linux zImage stored in memory\n"
"\tThe argument 'initrd' is optional and specifies the address\n"
"\tuse a '-' for the second argument. If you do not pass a third\n"
"\ta bd_info struct will be passed instead\n"
#endif
+ "";
+#endif
+
+U_BOOT_CMD(
+ bootz, CONFIG_SYS_MAXARGS, 1, do_bootz,
+ "boot Linux zImage image from memory", bootz_help_text
);
#endif /* CONFIG_CMD_BOOTZ */
#include <stdio_dev.h>
extern void _do_coninfo (void);
-int do_coninfo (cmd_tbl_t * cmd, int flag, int argc, char * const argv[])
+static int do_coninfo(cmd_tbl_t *cmd, int flag, int argc, char * const argv[])
{
int l;
struct list_head *list = stdio_get_list();
int mk_date (const char *, struct rtc_time *);
-int do_date (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_date(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct rtc_time tm;
int rcode = 0;
#include <common.h>
#include <command.h>
-int do_echo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_echo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int i;
int putnl = 1;
#include <common.h>
#include <command.h>
-int do_exit(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_exit(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int r;
" All numeric parameters are assumed to be hex."
);
-int do_fat_ls (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_fat_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
return do_ls(cmdtp, flag, argc, argv, FS_TYPE_FAT);
}
" - list files from 'dev' on 'interface' in a 'directory'"
);
-int do_fat_fsinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_fat_fsinfo(cmd_tbl_t *cmdtp, int flag, int argc,
+ char * const argv[])
{
int dev, part;
block_dev_desc_t *dev_desc;
/*
* Flattened Device Tree command, see the help for parameter definitions.
*/
-int do_fdt (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_fdt(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
if (argc < 2)
return CMD_RET_USAGE;
cp = newp;
tmp = simple_strtoul(cp, &newp, 0);
- *(uint32_t *)data = __cpu_to_be32(tmp);
+ *(__be32 *)data = __cpu_to_be32(tmp);
data += 4;
*len += 4;
if (len > CONFIG_CMD_FDT_MAX_DUMP)
printf("* 0x%p [0x%08x]", data, len);
else {
- const u32 *p;
+ const __be32 *p;
printf("<");
for (j = 0, p = data; j < len/4; j++)
}
/********************************************************************/
-
-U_BOOT_CMD(
- fdt, 255, 0, do_fdt,
- "flattened device tree utility commands",
- "addr <addr> [<length>] - Set the fdt location to <addr>\n"
+#ifdef CONFIG_SYS_LONGHELP
+static char fdt_help_text[] =
+ "addr <addr> [<length>] - Set the fdt location to <addr>\n"
#ifdef CONFIG_OF_BOARD_SETUP
"fdt boardsetup - Do board-specific set up\n"
#endif
"fdt chosen [<start> <end>] - Add/update the /chosen branch in the tree\n"
" <start>/<end> - initrd start/end addr\n"
"NOTE: Dereference aliases by omiting the leading '/', "
- "e.g. fdt print ethernet0."
+ "e.g. fdt print ethernet0.";
+#endif
+
+U_BOOT_CMD(
+ fdt, 255, 0, do_fdt,
+ "flattened device tree utility commands", fdt_help_text
);
}
#endif /* CONFIG_SYS_NO_FLASH */
-int do_flinfo ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_flinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
#ifndef CONFIG_SYS_NO_FLASH
ulong bank;
return 0;
}
-int do_flerase (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_flerase(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
#ifndef CONFIG_SYS_NO_FLASH
flash_info_t *info = NULL;
}
#endif /* CONFIG_SYS_NO_FLASH */
-int do_protect (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_protect(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int rcode = 0;
#ifndef CONFIG_SYS_NO_FLASH
#include <common.h>
#include <command.h>
-int do_help(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_help(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
cmd_tbl_t *start = ll_entry_start(cmd_tbl_t, cmd);
const int len = ll_entry_count(cmd_tbl_t, cmd);
#define DISP_LINE_LEN 16
/* implement possible board specific board init */
-void __def_i2c_init_board(void)
+static void __def_i2c_init_board(void)
{
return;
}
__attribute__((weak, alias("__def_i2c_init_board")));
/* TODO: Implement architecture-specific get/set functions */
-unsigned int __def_i2c_get_bus_speed(void)
+static unsigned int __def_i2c_get_bus_speed(void)
{
return CONFIG_SYS_I2C_SPEED;
}
unsigned int i2c_get_bus_speed(void)
__attribute__((weak, alias("__def_i2c_get_bus_speed")));
-int __def_i2c_set_bus_speed(unsigned int speed)
+static int __def_i2c_set_bus_speed(unsigned int speed)
{
if (speed != CONFIG_SYS_I2C_SPEED)
return -1;
}
/***************************************************/
-
-U_BOOT_CMD(
- i2c, 6, 1, do_i2c,
- "I2C sub-system",
+#ifdef CONFIG_SYS_LONGHELP
+static char i2c_help_text[] =
#if defined(CONFIG_I2C_MUX)
"bus [muxtype:muxaddr:muxchannel] - add a new bus reached over muxes\ni2c "
#endif /* CONFIG_I2C_MUX */
#if defined(CONFIG_CMD_SDRAM)
"i2c sdram chip - print SDRAM configuration information\n"
#endif
- "i2c speed [speed] - show or set I2C bus speed"
+ "i2c speed [speed] - show or set I2C bus speed";
+#endif
+
+U_BOOT_CMD(
+ i2c, 6, 1, do_i2c,
+ "I2C sub-system",
+ i2c_help_text
);
#if defined(CONFIG_I2C_MUX)
#include <config.h>
#include <command.h>
-int do_interrupts(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_interrupts(cmd_tbl_t *cmdtp, int flag, int argc,
+ char * const argv[])
{
if (argc != 2)
return (0);
}
-int binary_test (char *op, char *arg1, char *arg2, int w)
+static int binary_test(char *op, char *arg1, char *arg2, int w)
{
int len, i;
const op_tbl_t *optp;
}
/* command line interface to the shell test */
-int do_itest ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[] )
+static int do_itest(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int value, w;
DECLARE_GLOBAL_DATA_PTR;
#if defined(CONFIG_CMD_LOADB)
-static ulong load_serial_ymodem (ulong offset);
+static ulong load_serial_ymodem(ulong offset);
#endif
#if defined(CONFIG_CMD_LOADS)
-static ulong load_serial (long offset);
-static int read_record (char *buf, ulong len);
+static ulong load_serial(long offset);
+static int read_record(char *buf, ulong len);
# if defined(CONFIG_CMD_SAVES)
-static int save_serial (ulong offset, ulong size);
-static int write_record (char *buf);
+static int save_serial(ulong offset, ulong size);
+static int write_record(char *buf);
#endif
static int do_echo = 1;
/* -------------------------------------------------------------------- */
#if defined(CONFIG_CMD_LOADS)
-int do_load_serial (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_load_serial(cmd_tbl_t *cmdtp, int flag, int argc,
+ char * const argv[])
{
long offset = 0;
ulong addr;
load_baudrate = current_baudrate;
}
if (load_baudrate != current_baudrate) {
- printf ("## Switch baudrate to %d bps and press ENTER ...\n",
+ printf("## Switch baudrate to %d bps and press ENTER ...\n",
load_baudrate);
udelay(50000);
gd->baudrate = load_baudrate;
- serial_setbrg ();
+ serial_setbrg();
udelay(50000);
for (;;) {
if (getc() == '\r')
}
#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
- printf ("## Ready for S-Record download ...\n");
+ printf("## Ready for S-Record download ...\n");
- addr = load_serial (offset);
+ addr = load_serial(offset);
/*
* Gather any trailing characters (for instance, the ^D which
}
if (addr == ~0) {
- printf ("## S-Record download aborted\n");
+ printf("## S-Record download aborted\n");
rcode = 1;
} else {
- printf ("## Start Addr = 0x%08lX\n", addr);
+ printf("## Start Addr = 0x%08lX\n", addr);
load_addr = addr;
}
#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
if (load_baudrate != current_baudrate) {
- printf ("## Switch baudrate to %d bps and press ESC ...\n",
+ printf("## Switch baudrate to %d bps and press ESC ...\n",
current_baudrate);
- udelay (50000);
+ udelay(50000);
gd->baudrate = current_baudrate;
- serial_setbrg ();
- udelay (50000);
+ serial_setbrg();
+ udelay(50000);
for (;;) {
if (getc() == 0x1B) /* ESC */
break;
return rcode;
}
-static ulong
-load_serial (long offset)
+static ulong load_serial(long offset)
{
char record[SREC_MAXRECLEN + 1]; /* buffer for one S-Record */
char binbuf[SREC_MAXBINLEN]; /* buffer for binary data */
int line_count = 0;
while (read_record(record, SREC_MAXRECLEN + 1) >= 0) {
- type = srec_decode (record, &binlen, &addr, binbuf);
+ type = srec_decode(record, &binlen, &addr, binbuf);
if (type < 0) {
return (~0); /* Invalid S-Record */
rc = flash_write((char *)binbuf,store_addr,binlen);
if (rc != 0) {
- flash_perror (rc);
+ flash_perror(rc);
return (~0);
}
} else
#endif
{
- memcpy ((char *)(store_addr), binbuf, binlen);
+ memcpy((char *)(store_addr), binbuf, binlen);
}
if ((store_addr) < start_addr)
start_addr = store_addr;
case SREC_END2:
case SREC_END3:
case SREC_END4:
- udelay (10000);
+ udelay(10000);
size = end_addr - start_addr + 1;
- printf ("\n"
+ printf("\n"
"## First Load Addr = 0x%08lX\n"
"## Last Load Addr = 0x%08lX\n"
"## Total Size = 0x%08lX = %ld Bytes\n",
start_addr, end_addr, size, size
);
- flush_cache (start_addr, size);
+ flush_cache(start_addr, size);
sprintf(buf, "%lX", size);
setenv("filesize", buf);
return (addr);
}
if (!do_echo) { /* print a '.' every 100 lines */
if ((++line_count % 100) == 0)
- putc ('.');
+ putc('.');
}
}
return (~0); /* Download aborted */
}
-static int
-read_record (char *buf, ulong len)
+static int read_record(char *buf, ulong len)
{
char *p;
char c;
for (p=buf; p < buf+len; ++p) {
c = getc(); /* read character */
if (do_echo)
- putc (c); /* ... and echo it */
+ putc(c); /* ... and echo it */
switch (c) {
case '\r':
save_baudrate = current_baudrate;
}
if (save_baudrate != current_baudrate) {
- printf ("## Switch baudrate to %d bps and press ENTER ...\n",
+ printf("## Switch baudrate to %d bps and press ENTER ...\n",
save_baudrate);
udelay(50000);
gd->baudrate = save_baudrate;
- serial_setbrg ();
+ serial_setbrg();
udelay(50000);
for (;;) {
if (getc() == '\r')
}
#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
- printf ("## Ready for S-Record upload, press ENTER to proceed ...\n");
+ printf("## Ready for S-Record upload, press ENTER to proceed ...\n");
for (;;) {
if (getc() == '\r')
break;
}
- if(save_serial (offset, size)) {
- printf ("## S-Record upload aborted\n");
+ if (save_serial(offset, size)) {
+ printf("## S-Record upload aborted\n");
} else {
- printf ("## S-Record upload complete\n");
+ printf("## S-Record upload complete\n");
}
#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
if (save_baudrate != current_baudrate) {
- printf ("## Switch baudrate to %d bps and press ESC ...\n",
+ printf("## Switch baudrate to %d bps and press ESC ...\n",
(int)current_baudrate);
- udelay (50000);
+ udelay(50000);
gd->baudrate = current_baudrate;
- serial_setbrg ();
- udelay (50000);
+ serial_setbrg();
+ udelay(50000);
for (;;) {
if (getc() == 0x1B) /* ESC */
break;
#define SREC3_END "S70500000000FA\n"
#define SREC_BYTES_PER_RECORD 16
-static int save_serial (ulong address, ulong count)
+static int save_serial(ulong address, ulong count)
{
int i, c, reclen, checksum, length;
char *hex = "0123456789ABCDEF";
return(0);
}
-static int
-write_record (char *buf)
+static int write_record(char *buf)
{
char c;
static void set_kerm_bin_mode(unsigned long *);
static int k_recv(void);
-static ulong load_serial_bin (ulong offset);
+static ulong load_serial_bin(ulong offset);
-char his_eol; /* character he needs at end of packet */
-int his_pad_count; /* number of pad chars he needs */
-char his_pad_char; /* pad chars he needs */
-char his_quote; /* quote chars he'll use */
+static char his_eol; /* character he needs at end of packet */
+static int his_pad_count; /* number of pad chars he needs */
+static char his_pad_char; /* pad chars he needs */
+static char his_quote; /* quote chars he'll use */
-int do_load_serial_bin (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_load_serial_bin(cmd_tbl_t *cmdtp, int flag, int argc,
+ char * const argv[])
{
ulong offset = 0;
ulong addr;
}
if (load_baudrate != current_baudrate) {
- printf ("## Switch baudrate to %d bps and press ENTER ...\n",
+ printf("## Switch baudrate to %d bps and press ENTER ...\n",
load_baudrate);
udelay(50000);
gd->baudrate = load_baudrate;
- serial_setbrg ();
+ serial_setbrg();
udelay(50000);
for (;;) {
if (getc() == '\r')
}
if (strcmp(argv[0],"loady")==0) {
- printf ("## Ready for binary (ymodem) download "
+ printf("## Ready for binary (ymodem) download "
"to 0x%08lX at %d bps...\n",
offset,
load_baudrate);
- addr = load_serial_ymodem (offset);
+ addr = load_serial_ymodem(offset);
} else {
- printf ("## Ready for binary (kermit) download "
+ printf("## Ready for binary (kermit) download "
"to 0x%08lX at %d bps...\n",
offset,
load_baudrate);
- addr = load_serial_bin (offset);
+ addr = load_serial_bin(offset);
if (addr == ~0) {
load_addr = 0;
- printf ("## Binary (kermit) download aborted\n");
+ printf("## Binary (kermit) download aborted\n");
rcode = 1;
} else {
- printf ("## Start Addr = 0x%08lX\n", addr);
+ printf("## Start Addr = 0x%08lX\n", addr);
load_addr = addr;
}
}
if (load_baudrate != current_baudrate) {
- printf ("## Switch baudrate to %d bps and press ESC ...\n",
+ printf("## Switch baudrate to %d bps and press ESC ...\n",
current_baudrate);
- udelay (50000);
+ udelay(50000);
gd->baudrate = current_baudrate;
- serial_setbrg ();
- udelay (50000);
+ serial_setbrg();
+ udelay(50000);
for (;;) {
if (getc() == 0x1B) /* ESC */
break;
}
-static ulong load_serial_bin (ulong offset)
+static ulong load_serial_bin(ulong offset)
{
int size, i;
char buf[32];
- set_kerm_bin_mode ((ulong *) offset);
- size = k_recv ();
+ set_kerm_bin_mode((ulong *) offset);
+ size = k_recv();
/*
* Gather any trailing characters (for instance, the ^D which
udelay(1000);
}
- flush_cache (offset, size);
+ flush_cache(offset, size);
printf("## Total Size = 0x%08x = %d Bytes\n", size, size);
sprintf(buf, "%X", size);
return offset;
}
-void send_pad (void)
+static void send_pad(void)
{
int count = his_pad_count;
while (count-- > 0)
- putc (his_pad_char);
+ putc(his_pad_char);
}
/* converts escaped kermit char to binary char */
-char ktrans (char in)
+static char ktrans(char in)
{
if ((in & 0x60) == 0x40) {
return (char) (in & ~0x40);
return in;
}
-int chk1 (char *buffer)
+static int chk1(char *buffer)
{
int total = 0;
return (int) ((total + ((total >> 6) & 0x03)) & 0x3f);
}
-void s1_sendpacket (char *packet)
+static void s1_sendpacket(char *packet)
{
- send_pad ();
+ send_pad();
while (*packet) {
- putc (*packet++);
+ putc(*packet++);
}
}
static char a_b[24];
-void send_ack (int n)
+static void send_ack(int n)
{
a_b[0] = START_CHAR;
- a_b[1] = tochar (3);
- a_b[2] = tochar (n);
+ a_b[1] = tochar(3);
+ a_b[2] = tochar(n);
a_b[3] = ACK_TYPE;
a_b[4] = '\0';
- a_b[4] = tochar (chk1 (&a_b[1]));
+ a_b[4] = tochar(chk1(&a_b[1]));
a_b[5] = his_eol;
a_b[6] = '\0';
- s1_sendpacket (a_b);
+ s1_sendpacket(a_b);
}
-void send_nack (int n)
+static void send_nack(int n)
{
a_b[0] = START_CHAR;
- a_b[1] = tochar (3);
- a_b[2] = tochar (n);
+ a_b[1] = tochar(3);
+ a_b[2] = tochar(n);
a_b[3] = NACK_TYPE;
a_b[4] = '\0';
- a_b[4] = tochar (chk1 (&a_b[1]));
+ a_b[4] = tochar(chk1(&a_b[1]));
a_b[5] = his_eol;
a_b[6] = '\0';
- s1_sendpacket (a_b);
+ s1_sendpacket(a_b);
}
-void (*os_data_init) (void);
-void (*os_data_char) (char new_char);
+static void (*os_data_init)(void);
+static void (*os_data_char)(char new_char);
static int os_data_state, os_data_state_saved;
static char *os_data_addr, *os_data_addr_saved;
static char *bin_start_address;
-static void bin_data_init (void)
+static void bin_data_init(void)
{
os_data_state = 0;
os_data_addr = bin_start_address;
}
-static void os_data_save (void)
+static void os_data_save(void)
{
os_data_state_saved = os_data_state;
os_data_addr_saved = os_data_addr;
}
-static void os_data_restore (void)
+static void os_data_restore(void)
{
os_data_state = os_data_state_saved;
os_data_addr = os_data_addr_saved;
}
-static void bin_data_char (char new_char)
+static void bin_data_char(char new_char)
{
switch (os_data_state) {
case 0: /* data */
}
}
-static void set_kerm_bin_mode (unsigned long *addr)
+static void set_kerm_bin_mode(unsigned long *addr)
{
bin_start_address = (char *) addr;
os_data_init = bin_data_init;
/* k_data_* simply handles the kermit escape translations */
static int k_data_escape, k_data_escape_saved;
-void k_data_init (void)
+static void k_data_init(void)
{
k_data_escape = 0;
- os_data_init ();
+ os_data_init();
}
-void k_data_save (void)
+static void k_data_save(void)
{
k_data_escape_saved = k_data_escape;
- os_data_save ();
+ os_data_save();
}
-void k_data_restore (void)
+static void k_data_restore(void)
{
k_data_escape = k_data_escape_saved;
- os_data_restore ();
+ os_data_restore();
}
-void k_data_char (char new_char)
+static void k_data_char(char new_char)
{
if (k_data_escape) {
/* last char was escape - translate this character */
- os_data_char (ktrans (new_char));
+ os_data_char(ktrans(new_char));
k_data_escape = 0;
} else {
if (new_char == his_quote) {
k_data_escape = 1;
} else {
/* otherwise send this char as-is */
- os_data_char (new_char);
+ os_data_char(new_char);
}
}
}
#define SEND_DATA_SIZE 20
-char send_parms[SEND_DATA_SIZE];
-char *send_ptr;
+static char send_parms[SEND_DATA_SIZE];
+static char *send_ptr;
/* handle_send_packet interprits the protocol info and builds and
sends an appropriate ack for what we can do */
-void handle_send_packet (int n)
+static void handle_send_packet(int n)
{
int length = 3;
int bytes;
break;
/* handle MAXL - max length */
/* ignore what he says - most I'll take (here) is 94 */
- a_b[++length] = tochar (94);
+ a_b[++length] = tochar(94);
if (bytes-- <= 0)
break;
/* handle TIME - time you should wait for my packets */
/* ignore what he says - don't wait for my ack longer than 1 second */
- a_b[++length] = tochar (1);
+ a_b[++length] = tochar(1);
if (bytes-- <= 0)
break;
/* handle NPAD - number of pad chars I need */
/* remember what he says - I need none */
- his_pad_count = untochar (send_parms[2]);
- a_b[++length] = tochar (0);
+ his_pad_count = untochar(send_parms[2]);
+ a_b[++length] = tochar(0);
if (bytes-- <= 0)
break;
/* handle PADC - pad chars I need */
/* remember what he says - I need none */
- his_pad_char = ktrans (send_parms[3]);
+ his_pad_char = ktrans(send_parms[3]);
a_b[++length] = 0x40; /* He should ignore this */
if (bytes-- <= 0)
break;
/* handle EOL - end of line he needs */
/* remember what he says - I need CR */
- his_eol = untochar (send_parms[4]);
- a_b[++length] = tochar (END_CHAR);
+ his_eol = untochar(send_parms[4]);
+ a_b[++length] = tochar(END_CHAR);
if (bytes-- <= 0)
break;
/* handle QCTL - quote control char he'll use */
break;
/* handle CAPAS - the capabilities mask */
/* ignore what he says - I only do long packets - I don't do windows */
- a_b[++length] = tochar (2); /* only long packets */
- a_b[++length] = tochar (0); /* no windows */
- a_b[++length] = tochar (94); /* large packet msb */
- a_b[++length] = tochar (94); /* large packet lsb */
+ a_b[++length] = tochar(2); /* only long packets */
+ a_b[++length] = tochar(0); /* no windows */
+ a_b[++length] = tochar(94); /* large packet msb */
+ a_b[++length] = tochar(94); /* large packet lsb */
} while (0);
a_b[0] = START_CHAR;
- a_b[1] = tochar (length);
- a_b[2] = tochar (n);
+ a_b[1] = tochar(length);
+ a_b[2] = tochar(n);
a_b[3] = ACK_TYPE;
a_b[++length] = '\0';
- a_b[length] = tochar (chk1 (&a_b[1]));
+ a_b[length] = tochar(chk1(&a_b[1]));
a_b[++length] = his_eol;
a_b[++length] = '\0';
- s1_sendpacket (a_b);
+ s1_sendpacket(a_b);
}
/* k_recv receives a OS Open image file over kermit line */
-static int k_recv (void)
+static int k_recv(void)
{
char new_char;
char k_state, k_state_saved;
/* initialize the k_recv and k_data state machine */
done = 0;
k_state = 0;
- k_data_init ();
+ k_data_init();
k_state_saved = k_state;
- k_data_save ();
+ k_data_save();
n = 0; /* just to get rid of a warning */
last_n = -1;
START:
/* get length of packet */
sum = 0;
- new_char = getc ();
+ new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
sum += new_char & 0xff;
- length = untochar (new_char);
+ length = untochar(new_char);
/* get sequence number */
- new_char = getc ();
+ new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
sum += new_char & 0xff;
- n = untochar (new_char);
+ n = untochar(new_char);
--length;
/* NEW CODE - check sequence numbers for retried packets */
if (n == last_n) {
/* same sequence number, restore the previous state */
k_state = k_state_saved;
- k_data_restore ();
+ k_data_restore();
} else {
/* new sequence number, checkpoint the download */
last_n = n;
k_state_saved = k_state;
- k_data_save ();
+ k_data_save();
}
/* END NEW CODE */
/* get packet type */
- new_char = getc ();
+ new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
sum += new_char & 0xff;
if (length == -2) {
/* (length byte was 0, decremented twice) */
/* get the two length bytes */
- new_char = getc ();
+ new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
sum += new_char & 0xff;
- len_hi = untochar (new_char);
- new_char = getc ();
+ len_hi = untochar(new_char);
+ new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
sum += new_char & 0xff;
- len_lo = untochar (new_char);
+ len_lo = untochar(new_char);
length = len_hi * 95 + len_lo;
/* check header checksum */
- new_char = getc ();
+ new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
- if (new_char != tochar ((sum + ((sum >> 6) & 0x03)) & 0x3f))
+ if (new_char != tochar((sum + ((sum >> 6) & 0x03)) & 0x3f))
goto packet_error;
sum += new_char & 0xff;
/* --length; */ /* new length includes only data and block check to come */
}
/* bring in rest of packet */
while (length > 1) {
- new_char = getc ();
+ new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
sum += new_char & 0xff;
}
}
/* get and validate checksum character */
- new_char = getc ();
+ new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
- if (new_char != tochar ((sum + ((sum >> 6) & 0x03)) & 0x3f))
+ if (new_char != tochar((sum + ((sum >> 6) & 0x03)) & 0x3f))
goto packet_error;
/* get END_CHAR */
- new_char = getc ();
+ new_char = getc();
if (new_char != END_CHAR) {
packet_error:
/* restore state machines */
k_state = k_state_saved;
- k_data_restore ();
+ k_data_restore();
/* send a negative acknowledge packet in */
- send_nack (n);
+ send_nack(n);
} else if (k_state == SEND_TYPE) {
/* crack the protocol parms, build an appropriate ack packet */
- handle_send_packet (n);
+ handle_send_packet(n);
} else {
/* send simple acknowledge packet in */
- send_ack (n);
+ send_ack(n);
/* quit if end of transmission */
if (k_state == BREAK_TYPE)
done = 1;
return (getc());
return -1;
}
-static ulong load_serial_ymodem (ulong offset)
+static ulong load_serial_ymodem(ulong offset)
{
int size;
char buf[32];
size = 0;
info.mode = xyzModem_ymodem;
- res = xyzModem_stream_open (&info, &err);
+ res = xyzModem_stream_open(&info, &err);
if (!res) {
while ((res =
- xyzModem_stream_read (ymodemBuf, 1024, &err)) > 0) {
+ xyzModem_stream_read(ymodemBuf, 1024, &err)) > 0) {
store_addr = addr + offset;
size += res;
addr += res;
#ifndef CONFIG_SYS_NO_FLASH
- if (addr2info (store_addr)) {
+ if (addr2info(store_addr)) {
int rc;
- rc = flash_write ((char *) ymodemBuf,
+ rc = flash_write((char *) ymodemBuf,
store_addr, res);
if (rc != 0) {
flash_perror (rc);
} else
#endif
{
- memcpy ((char *) (store_addr), ymodemBuf,
+ memcpy((char *)(store_addr), ymodemBuf,
res);
}
}
} else {
- printf ("%s\n", xyzModem_error (err));
+ printf("%s\n", xyzModem_error(err));
}
- xyzModem_stream_close (&err);
- xyzModem_stream_terminate (false, &getcxmodem);
+ xyzModem_stream_close(&err);
+ xyzModem_stream_terminate(false, &getcxmodem);
- flush_cache (offset, size);
+ flush_cache(offset, size);
- printf ("## Total Size = 0x%08x = %d Bytes\n", size, size);
- sprintf (buf, "%X", size);
- setenv ("filesize", buf);
+ printf("## Total Size = 0x%08x = %d Bytes\n", size, size);
+ sprintf(buf, "%X", size);
+ setenv("filesize", buf);
return offset;
}
/* -------------------------------------------------------------------- */
#if defined(CONFIG_CMD_HWFLOW)
-int do_hwflow (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_hwflow(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
extern int hwflow_onoff(int);
return 0;
}
-int mdio_write_ranges(struct mii_dev *bus, int addrlo,
- int addrhi, int devadlo, int devadhi,
- int reglo, int reghi, unsigned short data)
+static int mdio_write_ranges(struct mii_dev *bus, int addrlo,
+ int addrhi, int devadlo, int devadhi,
+ int reglo, int reghi, unsigned short data)
{
int addr, devad, reg;
int err = 0;
return err;
}
-int mdio_read_ranges(struct mii_dev *bus, int addrlo,
- int addrhi, int devadlo, int devadhi,
- int reglo, int reghi)
+static int mdio_read_ranges(struct mii_dev *bus, int addrlo,
+ int addrhi, int devadlo, int devadhi,
+ int reglo, int reghi)
{
int addr, devad, reg;
}
/* The register will be in the form [a[-b].]x[-y] */
-int extract_reg_range(char *input, int *devadlo, int *devadhi,
- int *reglo, int *reghi)
+static int extract_reg_range(char *input, int *devadlo, int *devadhi,
+ int *reglo, int *reghi)
{
char *regstr;
return extract_range(regstr, reglo, reghi);
}
-int extract_phy_range(char *const argv[], int argc, struct mii_dev **bus,
- int *addrlo, int *addrhi)
+static int extract_phy_range(char *const argv[], int argc, struct mii_dev **bus,
+ int *addrlo, int *addrhi)
{
struct phy_device *phydev;
* md{.b, .w, .l} {addr} {len}
*/
#define DISP_LINE_LEN 16
-int do_mem_md ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
ulong addr, length;
#if defined(CONFIG_HAS_DATAFLASH)
return (rc);
}
-int do_mem_mm ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_mm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
return mod_mem (cmdtp, 1, flag, argc, argv);
}
-int do_mem_nm ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_nm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
return mod_mem (cmdtp, 0, flag, argc, argv);
}
-int do_mem_mw ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_mw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
ulong addr, writeval, count;
int size;
}
#endif /* CONFIG_MX_CYCLIC */
-int do_mem_cmp (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
ulong addr1, addr2, count, ngood;
int size;
return rcode;
}
-int do_mem_cp ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
ulong addr, dest, count;
int size;
return 0;
}
-int do_mem_base (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc,
+ char * const argv[])
{
if (argc > 1) {
/* Set new base address.
return 0;
}
-int do_mem_loop (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_loop(cmd_tbl_t *cmdtp, int flag, int argc,
+ char * const argv[])
{
ulong addr, length, i;
int size;
* configured using CONFIG_SYS_ALT_MEMTEST. The complete test loops until
* interrupted by ctrl-c or by a failure of one of the sub-tests.
*/
-int do_mem_mtest (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
+ char * const argv[])
{
vu_long *addr, *start, *end;
ulong val;
#if defined(CONFIG_SYS_MEMTEST_SCRATCH)
vu_long *dummy = (vu_long*)CONFIG_SYS_MEMTEST_SCRATCH;
#else
- vu_long *dummy = 0; /* yes, this is address 0x0, not NULL */
+ vu_long *dummy = NULL; /* yes, this is address 0x0, not NULL */
#endif
int j;
#ifndef CONFIG_CRC32_VERIFY
-int do_mem_crc (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_crc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
ulong addr, length;
ulong crc;
#include <common.h>
#include <command.h>
-int do_sleep (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_sleep(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
ulong start = get_timer(0);
ulong delay;
delay = simple_strtoul(argv[1], NULL, 10) * CONFIG_SYS_HZ;
while (get_timer(start) < delay) {
- if (ctrlc ())
+ if (ctrlc())
return (-1);
- udelay (100);
+ udelay(100);
}
return 0;
printf("Bus Width: %d-bit\n", mmc->bus_width);
}
-int do_mmcinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mmcinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct mmc *mmc;
"- dislay info of the current MMC device"
);
-int do_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
enum mmc_state state;
addr = (void *)simple_strtoul(argv[idx], NULL, 16);
++idx;
} else
- addr = 0;
+ addr = NULL;
blk = simple_strtoul(argv[idx], NULL, 16);
cnt = simple_strtoul(argv[idx + 1], NULL, 16);
#include <common.h>
#include <command.h>
-int
+static int
cpu_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
unsigned long cpuid;
return 0;
}
+#ifdef CONFIG_SYS_LONGHELP
+static char cpu_help_text[] =
+ "<num> reset - Reset cpu <num>\n"
+ "cpu <num> status - Status of cpu <num>\n"
+ "cpu <num> disable - Disable cpu <num>\n"
+ "cpu <num> release <addr> [args] - Release cpu <num> at <addr> with [args]"
#ifdef CONFIG_PPC
-#define CPU_ARCH_HELP \
+ "\n"
" [args] : <pir> <r3> <r6>\n" \
" pir - processor id (if writeable)\n" \
" r3 - value for gpr 3\n" \
" When cpu <num> is released r4 and r5 = 0.\n" \
" r7 will contain the size of the initial mapped area"
#endif
+ "";
+#endif
U_BOOT_CMD(
cpu, CONFIG_SYS_MAXARGS, 1, cpu_cmd,
- "Multiprocessor CPU boot manipulation and release",
- "<num> reset - Reset cpu <num>\n"
- "cpu <num> status - Status of cpu <num>\n"
- "cpu <num> disable - Disable cpu <num>\n"
- "cpu <num> release <addr> [args] - Release cpu <num> at <addr> with [args]"
-#ifdef CPU_ARCH_HELP
- "\n"
- CPU_ARCH_HELP
-#endif
+ "Multiprocessor CPU boot manipulation and release", cpu_help_text
);
extern void jffs2_free_cache(struct part_info *part);
/* mtdids mapping list, filled by parse_ids() */
-struct list_head mtdids;
+static struct list_head mtdids;
/* device/partition list, parse_cmdline() parses into here */
-struct list_head devices;
+static struct list_head devices;
/* current active device and partition number */
struct mtd_device *current_mtd_dev = NULL;
* @param size a pointer to the size of the mtd device (output)
* @return 0 if device is valid, 1 otherwise
*/
-int mtd_device_validate(u8 type, u8 num, u32 *size)
+static int mtd_device_validate(u8 type, u8 num, u32 *size)
{
struct mtd_info *mtd = NULL;
* @param dev_num parsed device number (output)
* @return 0 on success, 1 otherwise
*/
-int mtd_id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num)
+int mtd_id_parse(const char *id, const char **ret_id, u8 *dev_type,
+ u8 *dev_num)
{
const char *p = id;
* @param argv arguments list
* @return 0 on success, 1 otherwise
*/
-int do_chpart(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_chpart(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
/* command line only */
struct mtd_device *dev;
* @param argv arguments list
* @return 0 on success, 1 otherwise
*/
-int do_mtdparts(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mtdparts(cmd_tbl_t *cmdtp, int flag, int argc,
+ char * const argv[])
{
if (argc == 2) {
if (strcmp(argv[1], "default") == 0) {
" - change active partition (e.g. part-id = nand0,1)"
);
-U_BOOT_CMD(
- mtdparts, 6, 0, do_mtdparts,
- "define flash/nand partitions",
+#ifdef CONFIG_SYS_LONGHELP
+static char mtdparts_help_text[] =
"\n"
" - list partition table\n"
"mtdparts delall\n"
"<size> := standard linux memsize OR '-' to denote all remaining space\n"
"<offset> := partition start offset within the device\n"
"<name> := '(' NAME ')'\n"
- "<ro-flag> := when set to 'ro' makes partition read-only (not used, passed to kernel)"
+ "<ro-flag> := when set to 'ro' makes partition read-only (not used, passed to kernel)";
+#endif
+
+U_BOOT_CMD(
+ mtdparts, 6, 0, do_mtdparts,
+ "define flash/nand partitions", mtdparts_help_text
);
/***************************************************/
{
nand_info_t *nand = &nand_info[idx];
struct nand_chip *chip = nand->priv;
- const int bufsz = 32;
- char buf[bufsz];
+ char buf[32];
printf("Device %d: ", idx);
if (chip->numchips > 1)
return ret;
}
-int do_nand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int i, ret = 0;
ulong addr;
return CMD_RET_USAGE;
}
-U_BOOT_CMD(
- nand, CONFIG_SYS_MAXARGS, 1, do_nand,
- "NAND sub-system",
+#ifdef CONFIG_SYS_LONGHELP
+static char nand_help_text[] =
"info - show available NAND devices\n"
"nand device [dev] - show or set current device\n"
"nand read - addr off|partition size\n"
"nand env.oob set off|partition - set enviromnent offset\n"
"nand env.oob get - get environment offset"
#endif
+ "";
+#endif
+
+U_BOOT_CMD(
+ nand, CONFIG_SYS_MAXARGS, 1, do_nand,
+ "NAND sub-system", nand_help_text
);
static int nand_load_image(cmd_tbl_t *cmdtp, nand_info_t *nand,
return bootm_maybe_autostart(cmdtp, cmd);
}
-int do_nandboot(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_nandboot(cmd_tbl_t *cmdtp, int flag, int argc,
+ char * const argv[])
{
char *boot_device = NULL;
int idx;
static int netboot_common(enum proto_t, cmd_tbl_t *, int, char * const []);
-int do_bootp (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_bootp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
- return netboot_common (BOOTP, cmdtp, argc, argv);
+ return netboot_common(BOOTP, cmdtp, argc, argv);
}
U_BOOT_CMD(
"[loadAddress] [[hostIPaddr:]bootfilename]"
);
-int do_tftpb (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_tftpb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int ret;
#ifdef CONFIG_CMD_RARP
-int do_rarpb (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_rarpb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
- return netboot_common (RARP, cmdtp, argc, argv);
+ return netboot_common(RARP, cmdtp, argc, argv);
}
U_BOOT_CMD(
#endif
#if defined(CONFIG_CMD_DHCP)
-int do_dhcp (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_dhcp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
return netboot_common(DHCP, cmdtp, argc, argv);
}
#endif
#if defined(CONFIG_CMD_NFS)
-int do_nfs (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_nfs(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
return netboot_common(NFS, cmdtp, argc, argv);
}
);
#endif
-static void netboot_update_env (void)
+static void netboot_update_env(void)
{
char tmp[22];
if (NetOurGatewayIP) {
- ip_to_string (NetOurGatewayIP, tmp);
- setenv ("gatewayip", tmp);
+ ip_to_string(NetOurGatewayIP, tmp);
+ setenv("gatewayip", tmp);
}
if (NetOurSubnetMask) {
- ip_to_string (NetOurSubnetMask, tmp);
- setenv ("netmask", tmp);
+ ip_to_string(NetOurSubnetMask, tmp);
+ setenv("netmask", tmp);
}
if (NetOurHostName[0])
- setenv ("hostname", NetOurHostName);
+ setenv("hostname", NetOurHostName);
if (NetOurRootPath[0])
- setenv ("rootpath", NetOurRootPath);
+ setenv("rootpath", NetOurRootPath);
if (NetOurIP) {
- ip_to_string (NetOurIP, tmp);
- setenv ("ipaddr", tmp);
+ ip_to_string(NetOurIP, tmp);
+ setenv("ipaddr", tmp);
}
#if !defined(CONFIG_BOOTP_SERVERIP)
/*
* could have set it
*/
if (NetServerIP) {
- ip_to_string (NetServerIP, tmp);
- setenv ("serverip", tmp);
+ ip_to_string(NetServerIP, tmp);
+ setenv("serverip", tmp);
}
#endif
if (NetOurDNSIP) {
- ip_to_string (NetOurDNSIP, tmp);
- setenv ("dnsip", tmp);
+ ip_to_string(NetOurDNSIP, tmp);
+ setenv("dnsip", tmp);
}
#if defined(CONFIG_BOOTP_DNS2)
if (NetOurDNS2IP) {
- ip_to_string (NetOurDNS2IP, tmp);
- setenv ("dnsip2", tmp);
+ ip_to_string(NetOurDNS2IP, tmp);
+ setenv("dnsip2", tmp);
}
#endif
if (NetOurNISDomain[0])
- setenv ("domain", NetOurNISDomain);
+ setenv("domain", NetOurNISDomain);
#if defined(CONFIG_CMD_SNTP) \
&& defined(CONFIG_BOOTP_TIMEOFFSET)
if (NetTimeOffset) {
- sprintf (tmp, "%d", NetTimeOffset);
- setenv ("timeoffset", tmp);
+ sprintf(tmp, "%d", NetTimeOffset);
+ setenv("timeoffset", tmp);
}
#endif
#if defined(CONFIG_CMD_SNTP) \
&& defined(CONFIG_BOOTP_NTPSERVER)
if (NetNtpServerIP) {
- ip_to_string (NetNtpServerIP, tmp);
- setenv ("ntpserverip", tmp);
+ ip_to_string(NetNtpServerIP, tmp);
+ setenv("ntpserverip", tmp);
}
#endif
}
break;
case 3: load_addr = simple_strtoul(argv[1], NULL, 16);
- copy_filename (BootFile, argv[2], sizeof(BootFile));
+ copy_filename(BootFile, argv[2], sizeof(BootFile));
break;
}
#if defined(CONFIG_CMD_PING)
-int do_ping (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_ping(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
if (argc < 2)
return -1;
}
-int do_cdp (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_cdp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int r;
#endif
#if defined(CONFIG_CMD_SNTP)
-int do_sntp (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_sntp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
char *toff;
if (argc < 2) {
- NetNtpServerIP = getenv_IPaddr ("ntpserverip");
+ NetNtpServerIP = getenv_IPaddr("ntpserverip");
if (NetNtpServerIP == 0) {
- printf ("ntpserverip not set\n");
+ printf("ntpserverip not set\n");
return (1);
}
} else {
NetNtpServerIP = string_to_ip(argv[1]);
if (NetNtpServerIP == 0) {
- printf ("Bad NTP server IP address\n");
+ printf("Bad NTP server IP address\n");
return (1);
}
}
- toff = getenv ("timeoffset");
- if (toff == NULL) NetTimeOffset = 0;
- else NetTimeOffset = simple_strtol (toff, NULL, 10);
+ toff = getenv("timeoffset");
+ if (toff == NULL)
+ NetTimeOffset = 0;
+ else
+ NetTimeOffset = simple_strtol(toff, NULL, 10);
if (NetLoop(SNTP) < 0) {
printf("SNTP failed: host %pI4 not responding\n",
return 0;
}
-int do_env_print (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_env_print(cmd_tbl_t *cmdtp, int flag, int argc,
+ char * const argv[])
{
int i;
int rcode = 0;
* Set a new environment variable,
* or replace or delete an existing one.
*/
-int _do_env_set(int flag, int argc, char * const argv[])
+static int _do_env_set(int flag, int argc, char * const argv[])
{
int i, len;
char *name, *value, *s;
}
#ifndef CONFIG_SPL_BUILD
-int do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
if (argc < 2)
return CMD_RET_USAGE;
* Interactively edit an environment variable
*/
#if defined(CONFIG_CMD_EDITENV)
-int do_env_edit(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_env_edit(cmd_tbl_t *cmdtp, int flag, int argc,
+ char * const argv[])
{
char buffer[CONFIG_SYS_CBSIZE];
char *init_val;
#ifndef CONFIG_SPL_BUILD
#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)
-int do_env_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_env_save(cmd_tbl_t *cmdtp, int flag, int argc,
+ char * const argv[])
{
printf("Saving Environment to %s...\n", env_name_spec);
return CMD_RET_USAGE;
}
-U_BOOT_CMD(
- env, CONFIG_SYS_MAXARGS, 1, do_env,
- "environment handling commands",
+#ifdef CONFIG_SYS_LONGHELP
+static char env_help_text[] =
#if defined(CONFIG_CMD_ASKENV)
"ask name [message] [size] - ask for environment variable\nenv "
#endif
#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)
"env save - save environment\n"
#endif
- "env set [-f] name [arg ...]\n"
+ "env set [-f] name [arg ...]\n";
+#endif
+
+U_BOOT_CMD(
+ env, CONFIG_SYS_MAXARGS, 1, do_env,
+ "environment handling commands", env_help_text
);
/*
#include <asm/io.h>
#include <pci.h>
-unsigned char ShortPCIListing = 1;
-
/*
* Follows routines for the output of infos about devices on PCI bus.
*/
* pci modify[.b, .w, .l] bus.device.function [addr]
* pci write[.b, .w, .l] bus.device.function addr value
*/
-int do_pci (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_pci(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
ulong addr = 0, value = 0, size = 0;
pci_dev_t bdf = 0;
/***************************************************/
-
-U_BOOT_CMD(
- pci, 5, 1, do_pci,
- "list and access PCI Configuration Space",
+#ifdef CONFIG_SYS_LONGHELP
+static char pci_help_text[] =
"[bus] [long]\n"
" - short or long list of PCI devices on bus 'bus'\n"
#ifdef CONFIG_CMD_PCI_ENUM
"pci modify[.b, .w, .l] b.d.f address\n"
" - modify, auto increment CFG address\n"
"pci write[.b, .w, .l] b.d.f address value\n"
- " - write to CFG address"
+ " - write to CFG address";
+#endif
+
+U_BOOT_CMD(
+ pci, 5, 1, do_pci,
+ "list and access PCI Configuration Space", pci_help_text
);
extern void mpc85xx_reginfo(void);
#endif
-int do_reginfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_reginfo(cmd_tbl_t *cmdtp, int flag, int argc,
+ char * const argv[])
{
#if defined(CONFIG_8xx)
volatile immap_t *immap = (immap_t *)CONFIG_SYS_IMMR;
#include <part.h>
#include <sata.h>
-int sata_curr_device = -1;
+static int sata_curr_device = -1;
block_dev_desc_t sata_dev_desc[CONFIG_SYS_SATA_MAX_DEVICE];
int __sata_initialize(void)
}
#endif
-int do_sata(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_sata(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int rc = 0;
}
}
-int do_setexpr(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_setexpr(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
ulong a, b;
char buf[16];
return rcode;
}
-U_BOOT_CMD(
- source, 2, 0, do_source,
- "run script from memory",
+#ifdef CONFIG_SYS_LONGHELP
+static char source_help_text[] =
"[addr]\n"
"\t- run script starting at addr\n"
"\t- A valid image header must be present"
"For FIT format uImage addr must include subimage\n"
"unit name in the form of addr:<subimg_uname>"
#endif
+ "";
+#endif
+
+U_BOOT_CMD(
+ source, 2, 0, do_source,
+ "run script from memory", source_help_text
);
#endif
#include <common.h>
#include <command.h>
-int do_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
char * const *ap;
int left, adv, expr, last_expr, neg, last_cmp;
"[args..]"
);
-int do_false(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_false(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
return 1;
}
NULL
);
-int do_true(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_true(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
return 0;
}
#endif
/* some display routines (info command) */
-char *usb_get_class_desc(unsigned char dclass)
+static char *usb_get_class_desc(unsigned char dclass)
{
switch (dclass) {
case USB_CLASS_PER_INTERFACE:
}
}
-void usb_display_class_sub(unsigned char dclass, unsigned char subclass,
- unsigned char proto)
+static void usb_display_class_sub(unsigned char dclass, unsigned char subclass,
+ unsigned char proto)
{
switch (dclass) {
case USB_CLASS_PER_INTERFACE:
}
}
-void usb_display_string(struct usb_device *dev, int index)
+static void usb_display_string(struct usb_device *dev, int index)
{
ALLOC_CACHE_ALIGN_BUFFER(char, buffer, 256);
}
}
-void usb_display_desc(struct usb_device *dev)
+static void usb_display_desc(struct usb_device *dev)
{
if (dev->descriptor.bDescriptorType == USB_DT_DEVICE) {
printf("%d: %s, USB Revision %x.%x\n", dev->devnum,
}
-void usb_display_conf_desc(struct usb_configuration_descriptor *config,
- struct usb_device *dev)
+static void usb_display_conf_desc(struct usb_configuration_descriptor *config,
+ struct usb_device *dev)
{
printf(" Configuration: %d\n", config->bConfigurationValue);
printf(" - Interfaces: %d %s%s%dmA\n", config->bNumInterfaces,
}
}
-void usb_display_if_desc(struct usb_interface_descriptor *ifdesc,
- struct usb_device *dev)
+static void usb_display_if_desc(struct usb_interface_descriptor *ifdesc,
+ struct usb_device *dev)
{
printf(" Interface: %d\n", ifdesc->bInterfaceNumber);
printf(" - Alternate Setting %d, Endpoints: %d\n",
}
}
-void usb_display_ep_desc(struct usb_endpoint_descriptor *epdesc)
+static void usb_display_ep_desc(struct usb_endpoint_descriptor *epdesc)
{
printf(" - Endpoint %d %s ", epdesc->bEndpointAddress & 0xf,
(epdesc->bEndpointAddress & 0x80) ? "In" : "Out");
}
/* main routine to diasplay the configs, interfaces and endpoints */
-void usb_display_config(struct usb_device *dev)
+static void usb_display_config(struct usb_device *dev)
{
struct usb_config *config;
struct usb_interface *ifdesc;
}
/* shows the device tree recursively */
-void usb_show_tree_graph(struct usb_device *dev, char *pre)
+static void usb_show_tree_graph(struct usb_device *dev, char *pre)
{
int i, index;
int has_child, last_child;
}
/* main routine for the tree command */
-void usb_show_tree(struct usb_device *dev)
+static void usb_show_tree(struct usb_device *dev)
{
char preamble[32];
* usb boot command intepreter. Derived from diskboot
*/
#ifdef CONFIG_USB_STORAGE
-int do_usbboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_usbboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
return common_diskboot(cmdtp, "usb", argc, argv);
}
/******************************************************************************
* usb command intepreter
*/
-int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int i;
const char __weak version_string[] = U_BOOT_VERSION_STRING;
-int do_version(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_version(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
printf("\n%s\n", version_string);
#ifdef CC_VERSION_STRING
#define CONFIG_SYS_XIMG_LEN 0x800000
#endif
-int
+static int
do_imgextract(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
{
ulong addr = load_addr;
return 0;
}
-U_BOOT_CMD(
- imxtract, 4, 1, do_imgextract,
- "extract a part of a multi-image",
+#ifdef CONFIG_SYS_LONGHELP
+static char imgextract_help_text[] =
"addr part [dest]\n"
" - extract <part> from legacy image at <addr> and copy to <dest>"
#if defined(CONFIG_FIT)
"addr uname [dest]\n"
" - extract <uname> subimage from FIT image at <addr> and copy to <dest>"
#endif
+ "";
+#endif
+
+U_BOOT_CMD(
+ imxtract, 4, 1, do_imgextract,
+ "extract a part of a multi-image", imgextract_help_text
);
projects / u-boot / commitdiff