sysmo-bts
/
barebox
9
0
Fork 0
Code Releases Activity

commands: harmonize in-barebox documentation 

This patch does probably too much, but it's hard (and very
cumbersome/time consuming) to break it out. What is does is this:

* each command has one short description, e.g. "list MUX configuration"
* made sure the short descriptions start lowercase
* each command has one usage. That string contains just the
  options, e.g. "[-npn]". It's not part of the long help text.
* that is, it doesn't say "[OPTIONS]" anymore, every usable option
  is listed by character in this (short) option string (the long
  description is in the long help text, as before)
* help texts have been reworked, to make them
  - sometimes smaller
  - sometimes describe the options better
  - more often present themselves in a nicer format
* all long help texts are now created with BUSYBOX_CMD_HELP_
  macros, no more 'static const __maybe_unused char cmd_foobar_help[]'
* made sure the long help texts starts uppercase
* because cmdtp->name and cmdtp->opts together provide the new usage,
  all "Usage: foobar" texts have been removed from the long help texts
* BUSYBOX_CMD_HELP_TEXT() provides the trailing newline by itself, this
  is nicer in the source code
* BUSYBOX_CMD_HELP_OPT() provides the trailing newline by itself
* made sure no line gets longer than 77 characters
* delibertely renamed cmdtp->usage, so that we can get compile-time
  errors (e.g. in out-of-tree modules that use register_command()
* the 'help' command can now always emit the usage, even without
  compiled long help texts
* 'help -v' gives a list of commands with their short description, this
  is similar like the old "help" command before my patchset
* 'help -a' gives out help of all commands

Signed-off-by: Holger Schurig <holgerschurig@gmail.com>
Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
This commit is contained in:
Holger Schurig 2014-05-13 10:28:42 +02:00 committed by Sascha Hauer
parent ab23d0bb3f
commit f1f532084a
124 changed files with 968 additions and 913 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
arch/arm/boards/eukrea_cpuimx35/eukrea_cpuimx35.c
View File

@ -352,14 +352,9 @@ static int do_cpufreq(int argc, char *argv[])
return 0;
}
static const __maybe_unused char cmd_cpufreq_help[] =
"Usage: cpufreq 399|532\n"
"\n"
"Set CPU frequency to <freq> MHz\n";
BAREBOX_CMD_START(cpufreq)
.cmd = do_cpufreq,
.usage = "adjust CPU frequency",
BAREBOX_CMD_DESC("adjust CPU frequency")
BAREBOX_CMD_OPTS("399|532")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_cpufreq_help)
BAREBOX_CMD_END

9
arch/arm/boards/guf-cupid/board.c
View File

@ -346,14 +346,9 @@ static int do_cpufreq(int argc, char *argv[])
return 0;
}
static const __maybe_unused char cmd_cpufreq_help[] =
"Usage: cpufreq 399|532\n"
"\n"
"Set CPU frequency to <freq> MHz\n";
BAREBOX_CMD_START(cpufreq)
.cmd = do_cpufreq,
.usage = "adjust CPU frequency",
BAREBOX_CMD_DESC("adjust CPU frequency")
BAREBOX_CMD_OPTS("399|532")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_cpufreq_help)
BAREBOX_CMD_END

9
arch/arm/boards/phytec-phycore-imx35/pcm043.c
View File

@ -324,15 +324,10 @@ static int do_cpufreq(int argc, char *argv[])
return 0;
}
static const __maybe_unused char cmd_cpufreq_help[] =
"Usage: cpufreq 399|532\n"
"\n"
"Set CPU frequency to <freq> MHz\n";
BAREBOX_CMD_START(cpufreq)
.cmd = do_cpufreq,
.usage = "adjust CPU frequency",
BAREBOX_CMD_DESC("adjust CPU frequency")
BAREBOX_CMD_OPTS("399|532")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_cpufreq_help)
BAREBOX_CMD_END

2
arch/arm/cpu/cpuinfo.c
View File

@ -210,7 +210,7 @@ static int do_cpuinfo(int argc, char *argv[])
BAREBOX_CMD_START(cpuinfo)
.cmd = do_cpuinfo,
.usage = "Show info about CPU",
BAREBOX_CMD_DESC("show info about CPU")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_COMPLETE(empty_complete)
BAREBOX_CMD_END

9
arch/arm/cpu/mmuinfo.c
View File

@ -99,14 +99,9 @@ static int do_mmuinfo(int argc, char *argv[])
return 0;
}
BAREBOX_CMD_HELP_START(mmuinfo)
BAREBOX_CMD_HELP_USAGE("mmuinfo <address>\n")
BAREBOX_CMD_HELP_SHORT("Show MMU/cache information for an address.\n")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(mmuinfo)
.cmd = do_mmuinfo,
.usage = "mmuinfo <address>",
BAREBOX_CMD_DESC("show MMU/cache information of an address")
BAREBOX_CMD_OPTS("ADDRESS")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_HELP(cmd_mmuinfo_help)
BAREBOX_CMD_END

3
arch/arm/lib/bootu.c
View File

@ -36,7 +36,8 @@ static const __maybe_unused char cmd_bootu_help[] =
BAREBOX_CMD_START(bootu)
.cmd = do_bootu,
.usage = "start a raw linux image",
BAREBOX_CMD_DESC("boot into already loaded Linux kernel")
BAREBOX_CMD_OPTS("ADDRESS")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_bootu_help)
BAREBOX_CMD_END

8
arch/arm/lib/bootz.c
View File

@ -127,14 +127,10 @@ err_out:
return 1;
}
static const __maybe_unused char cmd_bootz_help[] =
"Usage: bootz [FILE]\n"
"Boot a Linux zImage\n";
BAREBOX_CMD_START(bootz)
.cmd = do_bootz,
.usage = "start a zImage",
BAREBOX_CMD_DESC("boot Linux zImage")
BAREBOX_CMD_OPTS("FILE")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_bootz_help)
BAREBOX_CMD_END

8
arch/arm/mach-at91/boot_test_cmd.c
View File

@ -84,13 +84,15 @@ err:
}
BAREBOX_CMD_HELP_START(at91_boot_test)
BAREBOX_CMD_HELP_USAGE("at91_boot_test [-j <jump addr>] [-s <sram>] file\n")
BAREBOX_CMD_HELP_SHORT("upload the binary to sram and jump as will do the romcode\n")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-j ADDR", "jump address")
BAREBOX_CMD_HELP_OPT ("-s SRAM", "SRAM device (default /dev/sram0)")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(at91_boot_test)
.cmd = do_at91_boot_test,
.usage = "upload the binary to sram and jump as will do the romcode",
BAREBOX_CMD_DESC("load and execute from SRAM")
BAREBOX_CMD_OPTS("at91_boot_test [-js] FILE")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_at91_boot_test_help)
BAREBOX_CMD_END

8
arch/arm/mach-at91/clock.c
View File

@ -881,16 +881,10 @@ static int do_at91clk(int argc, char *argv[])
return 0;
}
BAREBOX_CMD_HELP_START(at91clk)
BAREBOX_CMD_HELP_USAGE("at91clk\n")
BAREBOX_CMD_HELP_SHORT("dump current clock configuration\n");
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(at91clk)
.cmd = do_at91clk,
.usage = "dump current clock configuration",
BAREBOX_CMD_DESC("list clock configuration")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_HELP(cmd_at91clk_help)
BAREBOX_CMD_COMPLETE(empty_complete)
BAREBOX_CMD_END
#endif

11
arch/arm/mach-at91/gpio.c
View File

@ -509,13 +509,18 @@ static int do_at91mux(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(at91mux)
BAREBOX_CMD_HELP_USAGE("at91mux [-p <pin> -b <bank>]\n")
BAREBOX_CMD_HELP_SHORT("dump current mux configuration if bank/pin specified dump pin details\n");
BAREBOX_CMD_HELP_TEXT("Dump current MIX configuration. If a BANK or PIN has been")
BAREBOX_CMD_HELP_TEXT("specified dump pin details.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-p PIN", "pin number")
BAREBOX_CMD_HELP_OPT ("-b BANK", "bank number")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(at91mux)
.cmd = do_at91mux,
.usage = "dump current mux configuration",
BAREBOX_CMD_DESC("list MUX configuration")
BAREBOX_CMD_OPTS("[-pn]")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_HELP(cmd_at91mux_help)
BAREBOX_CMD_COMPLETE(empty_complete)

8
arch/arm/mach-mxs/bcb.c
View File

@ -387,14 +387,14 @@ int update_bcb(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(bcb)
BAREBOX_CMD_HELP_USAGE("bcb <first_bootstream> [second_bootstream]\n")
BAREBOX_CMD_HELP_SHORT("Write a BCB to NAND flash which an MX23/28 needs to boot.\n")
BAREBOX_CMD_HELP_TEXT ("Example: bcb nand0.bootstream\n")
BAREBOX_CMD_HELP_TEXT("Write a BCB to NAND flash which an MX23/28 needs to boot.")
BAREBOX_CMD_HELP_TEXT("Example: bcb nand0.bootstream")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(bcb)
.cmd = update_bcb,
.usage = "Writes a MX23/28 BCB data structure to flash",
BAREBOX_CMD_DESC("writes a i.MX23/28 BCB data structure to flash")
BAREBOX_CMD_OPTS("BOOTSTREAM [BOOTSTREAM]")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_bcb_help)
BAREBOX_CMD_END

3
arch/arm/mach-netx/generic.c
View File

@ -145,7 +145,6 @@ void __noreturn reset_cpu(unsigned long addr)
BAREBOX_CMD_START(loadxc)
.cmd = do_loadxc,
.usage = "load xmac/xpec engine with ethernet firmware",
BAREBOX_CMD_DESC("load XMAC/XPEC engine with ethernet firmware")
BAREBOX_CMD_GROUP(CMD_GRP_NET)
BAREBOX_CMD_END

12
arch/arm/mach-omap/boot_order.c
View File

@ -69,15 +69,15 @@ static int cmd_boot_order(int argc, char *argv[])
return 0;
}
static const __maybe_unused char cmd_boot_order_help[] =
"Usage: boot_order <device 1> [<device n>]\n"
"Set warm boot order of up to four devices.\n"
"Each device can be one of:\n"
"xip xipwait nand onenand mmc1 mmc2_1 mmc2_2 uart usb_1 usb_ulpi usb_2\n";
BAREBOX_CMD_HELP_START(boot_order)
BAREBOX_CMD_HELP_TEXT("Set warm boot order of up to four devices. Each device can be one of:")
BAREBOX_CMD_HELP_TEXT("xip xipwait nand onenand mmc1 mmc2_1 mmc2_2 uart usb_1 usb_ulpi usb_2")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(boot_order)
.cmd = cmd_boot_order,
.usage = "boot_order <device 1> [<device n>]",
BAREBOX_CMD_DESC("set warm boot order")
BAREBOX_CMD_OPTS("DEVICE...")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_boot_order_help)
BAREBOX_CMD_COMPLETE(empty_complete)

9
arch/blackfin/boards/ipe337/cmd_alternate.c
View File

@ -44,14 +44,9 @@ static int do_alternate(int argc, char *argv[])
return (bitcount & 1) ? 3 : 2;
}
static const __maybe_unused char cmd_alternate_help[] =
"Usage: alternate <file>"
"\n";
BAREBOX_CMD_START(alternate)
.cmd = do_alternate,
.usage = "count zero bits in a file",
BAREBOX_CMD_DESC("count zero bits in a file")
BAREBOX_CMD_OPTS("FILE")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_alternate_help)
BAREBOX_CMD_END

2
arch/mips/lib/cpuinfo.c
View File

@ -54,6 +54,6 @@ static int do_cpuinfo(int argc, char *argv[])
BAREBOX_CMD_START(cpuinfo)
.cmd = do_cpuinfo,
.usage = "Show info about CPU",
BAREBOX_CMD_DESC("show CPU information")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_END

2
arch/openrisc/lib/cpuinfo.c
View File

@ -148,6 +148,6 @@ static int do_cpuinfo(int argc, char *argv[])
BAREBOX_CMD_START(cpuinfo)
.cmd = do_cpuinfo,
.usage = "Show info about CPU",
BAREBOX_CMD_DESC("show CPU information")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_END

6
commands/2048.c
View File

@ -378,13 +378,13 @@ static int do_2048(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(2048)
BAREBOX_CMD_HELP_USAGE("2048\n")
BAREBOX_CMD_HELP_SHORT("The 2048 game\n")
BAREBOX_CMD_HELP_TEXT("Use your arrow keys to move the tiles. When two tiles with")
BAREBOX_CMD_HELP_TEXT("the same number touch, they merge into one!")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(2048)
.cmd = do_2048,
.usage = "Usage: 2048",
BAREBOX_CMD_DESC("the 2048 game")
BAREBOX_CMD_GROUP(CMD_GRP_MISC)
BAREBOX_CMD_HELP(cmd_2048_help)
BAREBOX_CMD_END

12
commands/automount.c
View File

@ -57,16 +57,16 @@ static int do_automount(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(automount)
BAREBOX_CMD_HELP_USAGE("automount [OPTIONS] <PATH> <cmd>\n")
BAREBOX_CMD_HELP_SHORT("execute <cmd> when <PATH> is first accessed\n")
BAREBOX_CMD_HELP_OPT("-l", "List currently registered automountpoints\n")
BAREBOX_CMD_HELP_OPT("-d", "Create the mount path\n")
BAREBOX_CMD_HELP_OPT("-r <PATH>", "remove an automountpoint\n")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-l", "list registered automount-points")
BAREBOX_CMD_HELP_OPT("-d", "create the mount directory")
BAREBOX_CMD_HELP_OPT("-r", "remove an automountpoint")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(automount)
.cmd = do_automount,
.usage = "automount [OPTIONS] <PATH> <cmd>",
BAREBOX_CMD_DESC("execute (mount) COMMAND when PATH ist first accessed")
BAREBOX_CMD_OPTS("[-ldr] PATH [COMMAND]")
BAREBOX_CMD_GROUP(CMD_GRP_PART)
BAREBOX_CMD_HELP(cmd_automount_help)
BAREBOX_CMD_END

17
commands/barebox-update.c
View File

@ -69,19 +69,18 @@ static int do_barebox_update(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(barebox_update)
BAREBOX_CMD_HELP_USAGE("barebox_update [OPTIONS] <image>\n")
BAREBOX_CMD_HELP_SHORT("Update barebox to persistent media\n")
BAREBOX_CMD_HELP_OPT("-t <target>", "\n")
BAREBOX_CMD_HELP_OPT("-d <device>", "write image to <device> instead of handler default\n")
BAREBOX_CMD_HELP_OPT(" ", "Can be used for debugging purposes (-d /tmpfile)\n")
BAREBOX_CMD_HELP_OPT("-y\t", "yes. Do not ask for confirmation\n")
BAREBOX_CMD_HELP_OPT("-f <level>", "Set force level\n")
BAREBOX_CMD_HELP_OPT("-l\t", "list registered targets\n")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-l\t", "list registered targets")
BAREBOX_CMD_HELP_OPT("-t TARGET", "specify data target handler name")
BAREBOX_CMD_HELP_OPT("-d DEVICE", "write image to DEVICE")
BAREBOX_CMD_HELP_OPT("-y\t", "autom. use 'yes' when asking confirmations")
BAREBOX_CMD_HELP_OPT("-f LEVEL", "set force level")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(barebox_update)
.cmd = do_barebox_update,
.usage = "update barebox",
BAREBOX_CMD_DESC("update barebox to persistent media")
BAREBOX_CMD_OPTS("[-ltdyf] [IMAGE]")
BAREBOX_CMD_GROUP(CMD_GRP_MISC)
BAREBOX_CMD_HELP(cmd_barebox_update_help)
BAREBOX_CMD_END

6
commands/basename.c
View File

@ -36,13 +36,13 @@ static int do_basename(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(basename)
BAREBOX_CMD_HELP_USAGE("basename NAME BASENAME\n")
BAREBOX_CMD_HELP_SHORT("strip NAME and store into $BASENAME\n")
BAREBOX_CMD_HELP_TEXT("Remove directory part from the PATH and store result into variable VAR.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(basename)
.cmd = do_basename,
.usage = "strip directory and suffix from filenames",
BAREBOX_CMD_DESC("strip directory and suffix from filenames")
BAREBOX_CMD_OPTS("PATH VAR")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_basename_help)
BAREBOX_CMD_END

44
commands/boot.c
View File

@ -456,30 +456,34 @@ out:
}
BAREBOX_CMD_HELP_START(boot)
BAREBOX_CMD_HELP_USAGE("boot [OPTIONS] [BOOTSRC...]\n")
BAREBOX_CMD_HELP_SHORT("Boot an operating system.\n")
BAREBOX_CMD_HELP_SHORT("[BOOTSRC...] can be:\n")
BAREBOX_CMD_HELP_SHORT("- a filename under /env/boot/\n")
BAREBOX_CMD_HELP_SHORT("- a full path to a boot script\n")
BAREBOX_CMD_HELP_SHORT("- a device name\n")
BAREBOX_CMD_HELP_SHORT("- a partition name under /dev/\n")
BAREBOX_CMD_HELP_SHORT("- a full path to a directory which\n")
BAREBOX_CMD_HELP_SHORT(" - contains boot scripts, or\n")
BAREBOX_CMD_HELP_SHORT(" - contains a loader/entries/ directory containing bootspec entries\n")
BAREBOX_CMD_HELP_SHORT("\n")
BAREBOX_CMD_HELP_SHORT("Multiple bootsources may be given which are probed in order until\n")
BAREBOX_CMD_HELP_SHORT("one succeeds.\n")
BAREBOX_CMD_HELP_SHORT("\nOptions:\n")
BAREBOX_CMD_HELP_OPT ("-v","Increase verbosity\n")
BAREBOX_CMD_HELP_OPT ("-d","Dryrun. See what happens but do no actually boot\n")
BAREBOX_CMD_HELP_OPT ("-l","List available boot sources\n")
BAREBOX_CMD_HELP_OPT ("-m","Show a menu with boot options\n")
BAREBOX_CMD_HELP_OPT ("-t <timeout>","specify timeout for the menu\n")
BAREBOX_CMD_HELP_TEXT("This is for booting based on scripts. Unlike the bootm command which")
BAREBOX_CMD_HELP_TEXT("can boot a single image this command offers the possibility to boot with")
BAREBOX_CMD_HELP_TEXT("scripts (by default placed under /env/boot/).")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("BOOTSRC can be:")
BAREBOX_CMD_HELP_TEXT("- a filename under /env/boot/")
BAREBOX_CMD_HELP_TEXT("- a full path to a boot script")
BAREBOX_CMD_HELP_TEXT("- a device name")
BAREBOX_CMD_HELP_TEXT("- a partition name under /dev/")
BAREBOX_CMD_HELP_TEXT("- a full path to a directory which")
BAREBOX_CMD_HELP_TEXT(" - contains boot scripts, or")
BAREBOX_CMD_HELP_TEXT(" - contains a loader/entries/ directory containing bootspec entries")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Multiple bootsources may be given which are probed in order until")
BAREBOX_CMD_HELP_TEXT("one succeeds.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-v","Increase verbosity")
BAREBOX_CMD_HELP_OPT ("-d","Dryrun. See what happens but do no actually boot")
BAREBOX_CMD_HELP_OPT ("-l","List available boot sources")
BAREBOX_CMD_HELP_OPT ("-m","Show a menu with boot options")
BAREBOX_CMD_HELP_OPT ("-t SECS","specify timeout in SECS")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(boot)
.cmd = do_boot,
.usage = "boot the machine",
BAREBOX_CMD_DESC("boot from script, device, ...")
BAREBOX_CMD_OPTS("[-vdlmt] [BOOTSRC...]")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_boot_help)
BAREBOX_CMD_END

33
commands/bootm.c
View File

@ -141,27 +141,38 @@ err_out:
}
BAREBOX_CMD_HELP_START(bootm)
BAREBOX_CMD_HELP_USAGE("bootm [OPTIONS] image\n")
BAREBOX_CMD_HELP_SHORT("Boot an application image.\n")
BAREBOX_CMD_HELP_OPT ("-c", "crc check uImage data\n")
BAREBOX_CMD_HELP_OPT ("-d", "dryrun. Check data, but do not run\n")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-c", "crc check uImage data")
BAREBOX_CMD_HELP_OPT ("-d", "dryrun. Check data, but do not run")
#ifdef CONFIG_CMD_BOOTM_INITRD
BAREBOX_CMD_HELP_OPT ("-r <initrd>","specify an initrd image\n")
BAREBOX_CMD_HELP_OPT ("-L <load addr>","specify initrd load address\n")
BAREBOX_CMD_HELP_OPT ("-r INITRD","specify an initrd image")
BAREBOX_CMD_HELP_OPT ("-L ADDR","specify initrd load address")
#endif
BAREBOX_CMD_HELP_OPT ("-a <load addr>","specify os load address\n")
BAREBOX_CMD_HELP_OPT ("-e <ofs>","entry point to the image relative to start (0)\n")
BAREBOX_CMD_HELP_OPT ("-a ADDR","specify os load address")
BAREBOX_CMD_HELP_OPT ("-e OFFS","entry point to the image relative to start (0)")
#ifdef CONFIG_OFTREE
BAREBOX_CMD_HELP_OPT ("-o <oftree>","specify oftree\n")
BAREBOX_CMD_HELP_OPT ("-o DTS","specify device tree")
#endif
#ifdef CONFIG_CMD_BOOTM_VERBOSE
BAREBOX_CMD_HELP_OPT ("-v","verbose\n")
BAREBOX_CMD_HELP_OPT ("-v\t","verbose")
#endif
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(bootm)
.cmd = do_bootm,
.usage = "boot an application image",
BAREBOX_CMD_DESC("boot an application image")
BAREBOX_CMD_OPTS("[-cd"
#ifdef CONFIG_CMD_BOOTM_INITRD
"rL"
#endif
"ae"
#ifdef CONFIG_OFTREE
"o"
#endif
#ifdef CONFIG_CMD_BOOTM_VERBOSE
"v"
#endif
"] IMAGE")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_bootm_help)
BAREBOX_CMD_END

8
commands/cat.c
View File

@ -82,15 +82,13 @@ out:
}
BAREBOX_CMD_HELP_START(cat)
BAREBOX_CMD_HELP_USAGE("cat [FILES]\n")
BAREBOX_CMD_HELP_SHORT("Concatenate files on stdout.\n")
BAREBOX_CMD_HELP_TEXT ("Currently only printable characters and \\ n and \\ t are printed,\n")
BAREBOX_CMD_HELP_TEXT ("but this should be optional.\n")
BAREBOX_CMD_HELP_TEXT("Currently only printable characters and NL, TAB are printed.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(cat)
.cmd = do_cat,
.usage = "concatenate file(s)",
BAREBOX_CMD_DESC("concatenate file(s) to stdout")
BAREBOX_CMD_OPTS("FILE...")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_cat_help)
BAREBOX_CMD_END

7
commands/cd.c
View File

@ -45,14 +45,13 @@ static int do_cd(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(cd)
BAREBOX_CMD_HELP_USAGE("cd [directory]\n")
BAREBOX_CMD_HELP_SHORT("Change to directory.\n")
BAREBOX_CMD_HELP_TEXT ("If called without an argument, change to the root directory /.\n")
BAREBOX_CMD_HELP_TEXT("If called without an argument, change to the root directory '/'.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(cd)
.cmd = do_cd,
.usage = "change working directory",
BAREBOX_CMD_DESC("change working directory")
BAREBOX_CMD_OPTS("DIRECTORY")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_cd_help)
BAREBOX_CMD_END

6
commands/clear.c
View File

@ -30,13 +30,13 @@ static int do_clear(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(clear)
BAREBOX_CMD_HELP_USAGE("clear\n")
BAREBOX_CMD_HELP_SHORT("Clear the screen.\n")
BAREBOX_CMD_HELP_TEXT("Send ANSI ESC sequence to clear the screen.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(clear)
.cmd = do_clear,
.usage = "clear screen",
BAREBOX_CMD_DESC("clear screen")
BAREBOX_CMD_GROUP(CMD_GRP_CONSOLE)
BAREBOX_CMD_COMPLETE(empty_complete)
BAREBOX_CMD_HELP(cmd_clear_help)
BAREBOX_CMD_END

40
commands/clk.c
View File

@ -18,16 +18,11 @@ static int do_clk_enable(int argc, char *argv[])
return clk_enable(clk);
}
BAREBOX_CMD_HELP_START(clk_enable)
BAREBOX_CMD_HELP_USAGE("clk_enable <clk>\n")
BAREBOX_CMD_HELP_SHORT("enable <clk>\n")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(clk_enable)
.cmd = do_clk_enable,
.usage = "enable a clock",
BAREBOX_CMD_DESC("enable a clock")
BAREBOX_CMD_OPTS("CLK")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_clk_enable_help)
BAREBOX_CMD_END
static int do_clk_disable(int argc, char *argv[])
@ -46,16 +41,11 @@ static int do_clk_disable(int argc, char *argv[])
return 0;
}
BAREBOX_CMD_HELP_START(clk_disable)
BAREBOX_CMD_HELP_USAGE("clk_disable <clk>\n")
BAREBOX_CMD_HELP_SHORT("disable <clk>\n")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(clk_disable)
.cmd = do_clk_disable,
.usage = "disable a clock",
BAREBOX_CMD_DESC("disable a clock")
BAREBOX_CMD_OPTS("CLK")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_clk_disable_help)
BAREBOX_CMD_END
static int do_clk_set_rate(int argc, char *argv[])
@ -76,13 +66,13 @@ static int do_clk_set_rate(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(clk_set_rate)
BAREBOX_CMD_HELP_USAGE("clk_set_rate <clk> <rate_hz>\n")
BAREBOX_CMD_HELP_SHORT("Set clock <clk> to <rate>\n")
BAREBOX_CMD_HELP_TEXT("Set clock CLK to RATE")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(clk_set_rate)
.cmd = do_clk_set_rate,
.usage = "set a clocks rate",
BAREBOX_CMD_DESC("set a clocks rate")
BAREBOX_CMD_OPTS("CLK HZ")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_clk_set_rate_help)
BAREBOX_CMD_END
@ -108,13 +98,14 @@ static int do_clk_dump(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(clk_dump)
BAREBOX_CMD_HELP_USAGE("clk_dump [-v]\n")
BAREBOX_CMD_HELP_OPT ("-v", "verbose\n")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-v", "verbose")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(clk_dump)
.cmd = do_clk_dump,
.usage = "show information about registered clocks",
BAREBOX_CMD_DESC("show information about registered clocks")
BAREBOX_CMD_OPTS("[-v]")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_HELP(cmd_clk_dump_help)
BAREBOX_CMD_END
@ -136,14 +127,9 @@ static int do_clk_set_parent(int argc, char *argv[])
return clk_set_parent(clk, parent);
}
BAREBOX_CMD_HELP_START(clk_set_parent)
BAREBOX_CMD_HELP_USAGE("clk_set_parent <clk> <parent>\n")
BAREBOX_CMD_HELP_SHORT("Set parent of <clk> to <parent>\n")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(clk_set_parent)
.cmd = do_clk_set_parent,
.usage = "set a parent of a clock",
BAREBOX_CMD_DESC("set parent of a clock")
BAREBOX_CMD_OPTS("CLK PARENT")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_clk_set_parent_help)
BAREBOX_CMD_END

9
commands/cp.c
View File

@ -89,8 +89,10 @@ out:
}
BAREBOX_CMD_HELP_START(cp)
BAREBOX_CMD_HELP_USAGE("cp [-v] <source> <destination>\n")
BAREBOX_CMD_HELP_SHORT("copy file from <source> to <destination>.\n")
BAREBOX_CMD_HELP_TEXT("Copy file from SRC to DEST.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-v", "verbose")
BAREBOX_CMD_HELP_END
/**
@ -104,7 +106,8 @@ If you want to copy between memory blocks, use 'memcpy'.
BAREBOX_CMD_START(cp)
.cmd = do_cp,
.usage = "copy files",
BAREBOX_CMD_DESC("copy files")
BAREBOX_CMD_OPTS("[-v] SRC DEST")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_cp_help)
BAREBOX_CMD_END

20
commands/crc.c
View File

@ -108,19 +108,25 @@ static int do_crc(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(crc)
BAREBOX_CMD_HELP_USAGE("crc32 [OPTION] [AREA]\n")
BAREBOX_CMD_HELP_SHORT("Calculate a crc32 checksum of a memory area.\n")
BAREBOX_CMD_HELP_OPT ("-f <file>", "Use file instead of memory.\n")
BAREBOX_CMD_HELP_TEXT("Calculate a CRC32 checksum of a memory area.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-f FILE", "Use file instead of memory.")
#ifdef CONFIG_CMD_CRC_CMP
BAREBOX_CMD_HELP_OPT ("-F <file>", "Use file to compare.\n")
BAREBOX_CMD_HELP_OPT ("-F FILE", "Use file to compare.")
#endif
BAREBOX_CMD_HELP_OPT ("-v <crc>", "Verify\n")
BAREBOX_CMD_HELP_OPT ("-V <file>", "Verify with crc read from <file>\n")
BAREBOX_CMD_HELP_OPT ("-v CRC", "Verify")
BAREBOX_CMD_HELP_OPT ("-V FILE", "Verify with CRC read from FILE")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(crc32)
.cmd = do_crc,
.usage = "crc32 checksum calculation",
BAREBOX_CMD_DESC("CRC32 checksum calculation")
BAREBOX_CMD_OPTS("[-f"
#ifdef CONFIG_CMD_CRC_CMP
"F"
#endif
"vV] AREA")
BAREBOX_CMD_GROUP(CMD_GRP_MEM)
BAREBOX_CMD_HELP(cmd_crc_help)
BAREBOX_CMD_END

11
commands/detect.c
View File

@ -80,15 +80,16 @@ static int do_detect(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(detect)
BAREBOX_CMD_HELP_USAGE("detect [OPTIONS] [devices]\n")
BAREBOX_CMD_HELP_OPT ("-l", "list detectable devices\n")
BAREBOX_CMD_HELP_OPT ("-e", "bail out if one device fails to detect\n")
BAREBOX_CMD_HELP_OPT ("-a", "detect all devices\n")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-l", "list detectable devices")
BAREBOX_CMD_HELP_OPT ("-e", "bail out if one device fails to detect")
BAREBOX_CMD_HELP_OPT ("-a", "detect all devices")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(detect)
.cmd = do_detect,
.usage = "detect devices",
BAREBOX_CMD_DESC("detect devices")
BAREBOX_CMD_OPTS("[-lea] [devices]")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_COMPLETE(device_complete)
BAREBOX_CMD_HELP(cmd_detect_help)

16
commands/devinfo.c
View File

@ -118,10 +118,6 @@ static int do_devinfo(int argc, char *argv[])
return 0;
}
BAREBOX_CMD_HELP_START(devinfo)
BAREBOX_CMD_HELP_USAGE("devinfo [DEVICE]\n")
BAREBOX_CMD_HELP_SHORT("Output device information.\n")
BAREBOX_CMD_HELP_END
/**
* @page devinfo_command
@ -150,9 +146,19 @@ Example from an MPC5200 based system:
@endverbatim
*/
BAREBOX_CMD_HELP_START(devinfo)
BAREBOX_CMD_HELP_TEXT("If called without arguments, devinfo shows a summary of the known")
BAREBOX_CMD_HELP_TEXT("devices and drivers.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("If called with a device path being the argument, devinfo shows more")
BAREBOX_CMD_HELP_TEXT("default information about this device and its parameters.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(devinfo)
.cmd = do_devinfo,
.usage = "Show information about devices and drivers.",
BAREBOX_CMD_DESC("show information about devices and drivers")
BAREBOX_CMD_OPTS("[DEVICE]")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_HELP(cmd_devinfo_help)
BAREBOX_CMD_COMPLETE(device_complete)

27
commands/dfu.c
View File

@ -171,17 +171,19 @@ out:
}
BAREBOX_CMD_HELP_START(dfu)
BAREBOX_CMD_HELP_USAGE("dfu [OPTIONS] <description>\n")
BAREBOX_CMD_HELP_SHORT("Start firmware update with the Device Firmware Update (DFU) protocol.\n")
BAREBOX_CMD_HELP_OPT ("-m <str>", "Manufacturer string (barebox)\n")
BAREBOX_CMD_HELP_OPT ("-p <str>", "product string\n")
BAREBOX_CMD_HELP_OPT ("-V <id>", "vendor id\n")
BAREBOX_CMD_HELP_OPT ("-P <id>", "product id\n")
BAREBOX_CMD_HELP_OPT ("<description>",
"device1(name1)[sr],device2(name2)[src]\n"
"'s' means 'safe mode' (download the complete image before flashing) and\n"
"'r' that readback of the firmware is allowed.\n"
"'c' if given, the file will be created (for use with regular files)\n")
BAREBOX_CMD_HELP_TEXT("Turn's the USB host into DFU mode (Device Firmware Mode) and accepts")
BAREBOX_CMD_HELP_TEXT("a new firmware. The destination is described by DESC in the this format:")
BAREBOX_CMD_HELP_TEXT(" DEVICE(NAME)[src]...")
BAREBOX_CMD_HELP_TEXT("Specify the '(') and ')' literal, the [] however denote this optional modes:")
BAREBOX_CMD_HELP_TEXT("- 's' safe mode (download the complete image before flashing)")
BAREBOX_CMD_HELP_TEXT("- 'r' readback of the firmware is allowed")
BAREBOX_CMD_HELP_TEXT("- 'c' the file will be created (for use with regular files)")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-m STR", "Manufacturer string (barebox)")
BAREBOX_CMD_HELP_OPT ("-p STR", "product string")
BAREBOX_CMD_HELP_OPT ("-V ID", "vendor id")
BAREBOX_CMD_HELP_OPT ("-P ID", "product id")
BAREBOX_CMD_HELP_END
/**
@ -196,7 +198,8 @@ device1(name1)[sr],device2(name2)[sr]
BAREBOX_CMD_START(dfu)
.cmd = do_dfu,
.usage = "Device firmware update",
BAREBOX_CMD_DESC("device firmware update")
BAREBOX_CMD_OPTS("[-mpVP] DESC")
BAREBOX_CMD_GROUP(CMD_GRP_MISC)
BAREBOX_CMD_HELP(cmd_dfu_help)
BAREBOX_CMD_END

24
commands/digest.c
View File

@ -83,13 +83,13 @@ static int do_md5(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(md5sum)
BAREBOX_CMD_HELP_USAGE("md5sum [[FILE] [AREA]]...\n")
BAREBOX_CMD_HELP_SHORT("Calculate a md5 checksum of a memory area.\n")
BAREBOX_CMD_HELP_TEXT("Calculate a MD5 digest over a FILE or a memory area.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(md5sum)
.cmd = do_md5,
.usage = "md5 checksum calculation",
BAREBOX_CMD_DESC("calculate MD5 checksum")
BAREBOX_CMD_OPTS("FILE|AREA...")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_md5sum_help)
BAREBOX_CMD_END
@ -104,13 +104,13 @@ static int do_sha1(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(sha1sum)
BAREBOX_CMD_HELP_USAGE("sha1sum [[FILE] [AREA]]...\n")
BAREBOX_CMD_HELP_SHORT("Calculate a sha1 checksum of a memory area.\n")
BAREBOX_CMD_HELP_TEXT("Calculate a SHA1 digest over a FILE or a memory area.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(sha1sum)
.cmd = do_sha1,
.usage = "sha1 checksum calculation",
BAREBOX_CMD_DESC("calculate SHA1 digest")
BAREBOX_CMD_OPTS("FILE|AREA")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_sha1sum_help)
BAREBOX_CMD_END
@ -125,13 +125,13 @@ static int do_sha224(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(sha224sum)
BAREBOX_CMD_HELP_USAGE("sha224sum [[FILE] [AREA]]...\n")
BAREBOX_CMD_HELP_SHORT("Calculate a sha224 checksum of a memory area.\n")
BAREBOX_CMD_HELP_TEXT("Calculate a SHA224 digest over a FILE or a memory area.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(sha224sum)
.cmd = do_sha224,
.usage = "sha224 checksum calculation",
BAREBOX_CMD_DESC("calculate SHA224 digest")
BAREBOX_CMD_OPTS("FILE|AREA")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_sha224sum_help)
BAREBOX_CMD_END
@ -146,13 +146,13 @@ static int do_sha256(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(sha256sum)
BAREBOX_CMD_HELP_USAGE("sha256sum [[FILE] [AREA]]...\n")
BAREBOX_CMD_HELP_SHORT("Calculate a sha256 checksum of a memory area.\n")
BAREBOX_CMD_HELP_TEXT("Calculate a SHA256 digest over a FILE or a memory area.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(sha256sum)
.cmd = do_sha256,
.usage = "sha256 checksum calculation",
BAREBOX_CMD_DESC("calculate SHA256 digest")
BAREBOX_CMD_OPTS("FILE|AREA")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_sha256sum_help)
BAREBOX_CMD_END

12
commands/dirname.c
View File

@ -53,14 +53,16 @@ static int do_dirname(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(dirname)
BAREBOX_CMD_HELP_USAGE("dirname [-V] NAME DIRNAME\n")
BAREBOX_CMD_HELP_SHORT("strip last componext of NAME and store into $DIRNAME\n")
BAREBOX_CMD_HELP_SHORT("-V return the path relative to the mountpoint.\n")
BAREBOX_CMD_HELP_TEXT("Strip last componext of NAME and store into $DIRNAME")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-V", "return the path relative to the mountpoint.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(dirname)
.cmd = do_dirname,
.usage = "strip last component from file name",
BAREBOX_CMD_GROUP(CMD_GRP_SCRIPT)
BAREBOX_CMD_DESC("strip last component from a path")
BAREBOX_CMD_OPTS("[-V] NAME DIRNAME")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_dirname_help)
BAREBOX_CMD_END

16
commands/echo.c
View File

@ -104,12 +104,13 @@ no_optarg_out:
}
BAREBOX_CMD_HELP_START(echo)
BAREBOX_CMD_HELP_USAGE("echo [OPTIONS] [STRING]\n")
BAREBOX_CMD_HELP_SHORT("Display a line of text.\n")
BAREBOX_CMD_HELP_OPT ("-n", "do not output the trailing newline\n")
BAREBOX_CMD_HELP_OPT ("-a <file>", "instead of outputting to stdout append to <file>\n")
BAREBOX_CMD_HELP_OPT ("-o <file>", "instead of outputting to stdout overwrite <file>\n")
BAREBOX_CMD_HELP_OPT ("-e", "recognize escape sequences\n")
BAREBOX_CMD_HELP_TEXT("Display a line of TEXT on the console.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-n", "do not output the trailing newline")
BAREBOX_CMD_HELP_OPT ("-e", "recognize escape sequences")
BAREBOX_CMD_HELP_OPT ("-a FILE", "append to FILE instead of using stdout")
BAREBOX_CMD_HELP_OPT ("-o FILE", "overwrite FILE instead of using stdout")
BAREBOX_CMD_HELP_END
/**
@ -121,7 +122,8 @@ BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(echo)
.cmd = do_echo,
.usage = "echo args to console",
BAREBOX_CMD_DESC("echo args to console")
BAREBOX_CMD_OPTS("[-neao] STRING")
BAREBOX_CMD_GROUP(CMD_GRP_CONSOLE)
BAREBOX_CMD_HELP(cmd_echo_help)
BAREBOX_CMD_END

6
commands/edit.c
View File

@ -547,8 +547,7 @@ out:
static const char *edit_aliases[] = { "sedit", NULL};
BAREBOX_CMD_HELP_START(edit)
BAREBOX_CMD_HELP_USAGE("(s)edit <file>\n")
BAREBOX_CMD_HELP_SHORT("A small editor. <ctrl-c> is exit, <ctrl-d> exit-with-save.\n")
BAREBOX_CMD_HELP_TEXT("Use cursor keys, Ctrl-C to exit and Ctrl-D to exit-with-save.")
BAREBOX_CMD_HELP_END
/**
@ -564,7 +563,8 @@ If called as sedit, the editor uses ansi codes to scroll the screen.
BAREBOX_CMD_START(edit)
.cmd = do_edit,
.aliases = edit_aliases,
.usage = "Usage: (s)edit <file>",
BAREBOX_CMD_DESC("a small full-screen editor")
BAREBOX_CMD_OPTS("FILE")
BAREBOX_CMD_GROUP(CMD_GRP_CONSOLE)
BAREBOX_CMD_HELP(cmd_edit_help)
BAREBOX_CMD_END

2
commands/exec.c
View File

@ -52,6 +52,6 @@ out:
BAREBOX_CMD_START(exec)
.cmd = do_exec,
.usage = "execute a script",
BAREBOX_CMD_DESC("execute a script")
BAREBOX_CMD_GROUP(CMD_GRP_SCRIPT)
BAREBOX_CMD_END

6
commands/export.c
View File

@ -49,13 +49,13 @@ static int do_export(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(export)
BAREBOX_CMD_HELP_USAGE("export <var>[=value]\n")
BAREBOX_CMD_HELP_SHORT("export an environment variable to subsequently executed scripts\n")
BAREBOX_CMD_HELP_TEXT("Export an environment variable to subsequently executed scripts.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(export)
.cmd = do_export,
.usage = "export environment variables",
BAREBOX_CMD_DESC("export environment variables")
BAREBOX_CMD_OPTS("VAR[=VALUE]")
BAREBOX_CMD_GROUP(CMD_GRP_ENV)
BAREBOX_CMD_HELP(cmd_export_help)
BAREBOX_CMD_END

2
commands/false.c
View File

@ -28,7 +28,7 @@ static int do_false(int argc, char *argv[])
BAREBOX_CMD_START(false)
.cmd = do_false,
.usage = "do nothing, unsuccessfully",
BAREBOX_CMD_DESC("do nothing, unsuccessfully")
BAREBOX_CMD_GROUP(CMD_GRP_SCRIPT)
BAREBOX_CMD_COMPLETE(empty_complete)
BAREBOX_CMD_END

14
commands/filetype.c
View File

@ -83,16 +83,18 @@ static int do_filetype(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(filetype)
BAREBOX_CMD_HELP_USAGE("filetype [OPTIONS] <file>\n")
BAREBOX_CMD_HELP_SHORT("detect type of a file and export result to a variable\n")
BAREBOX_CMD_HELP_OPT("-v", "verbose\n")
BAREBOX_CMD_HELP_OPT("-s <v>", "set <v> to shortname\n")
BAREBOX_CMD_HELP_OPT("-l", "list known filetypes\n")
BAREBOX_CMD_HELP_TEXT("Detect type of a file and export result to a variable.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-v", "verbose")
BAREBOX_CMD_HELP_OPT("-s VAR", "set variable VAR to shortname")
BAREBOX_CMD_HELP_OPT("-l", "list known filetypes")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(filetype)
.cmd = do_filetype,
.usage = "detect file type",
BAREBOX_CMD_DESC("detect file type")
BAREBOX_CMD_OPTS("[-vsl] FILE")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_filetype_help)
BAREBOX_CMD_END

40
commands/flash.c
View File

@ -75,13 +75,19 @@ out:
}
BAREBOX_CMD_HELP_START(erase)
BAREBOX_CMD_HELP_USAGE("erase <device> [area]\n")
BAREBOX_CMD_HELP_SHORT("Erase a flash device or parts of a device if an area specification is given.\n")
BAREBOX_CMD_HELP_TEXT("Erase the flash memory handled by DEVICE. Which AREA will be erased")
BAREBOX_CMD_HELP_TEXT("depends on the device: If the device represents the whole flash")
BAREBOX_CMD_HELP_TEXT("memory, the whole memory will be erased. If the device represents a")
BAREBOX_CMD_HELP_TEXT("partition on a main flash memory, only this partition part will be")
BAREBOX_CMD_HELP_TEXT("erased.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Use 'addpart' and 'delpart' to manage partitions.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(erase)
.cmd = do_flerase,
.usage = "erase FLASH memory",
BAREBOX_CMD_DESC("erase flash memory")
BAREBOX_CMD_OPTS("DEVICE [AREA]")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_erase_help)
BAREBOX_CMD_END
@ -150,13 +156,19 @@ out:
}
BAREBOX_CMD_HELP_START(protect)
BAREBOX_CMD_HELP_USAGE("protect <device> [area]\n")
BAREBOX_CMD_HELP_SHORT("protect a flash device (or parts of a device, if an area is specified)\n")
BAREBOX_CMD_HELP_TEXT("Protect the flash memory behind the device. It depends on the device")
BAREBOX_CMD_HELP_TEXT("given, what area will be protected. If the device represents the whole")
BAREBOX_CMD_HELP_TEXT("flash memory, the whole memory will be protected. If the device")
BAREBOX_CMD_HELP_TEXT("represents a partition on a main flash memory, only this partition part")
BAREBOX_CMD_HELP_TEXT("will be protected.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Use 'addpart' and 'delpart' to manage partitions.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(protect)
.cmd = do_protect,
.usage = "enable flash write protection",
BAREBOX_CMD_DESC("enable flash write protection")
BAREBOX_CMD_OPTS("DEVICE [AREA]")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_protect_help)
BAREBOX_CMD_END
@ -164,8 +176,8 @@ BAREBOX_CMD_END
/**
* @page protect_command
Protect the flash memory behind the device. It depends on the device
given, what area will be protected. If the device represents the whole
If the device represents the whole
flash memory the whole memory will be protected. If the device
represents a partition on a main flash memory, only this partition part
will be protected.
@ -179,13 +191,17 @@ flashes here.
*/
BAREBOX_CMD_HELP_START(unprotect)
BAREBOX_CMD_HELP_USAGE("unprotect <device> [area]\n")
BAREBOX_CMD_HELP_SHORT("unprotect a flash device (or parts of a device, if an area is specified)\n")
BAREBOX_CMD_HELP_TEXT("Unprotect the flash memory behind the device. It depends on the device")
BAREBOX_CMD_HELP_TEXT("given, what area will be unprotected. If the device represents the whole")
BAREBOX_CMD_HELP_TEXT("flash memory, the whole memory will be unprotected. If the device")
BAREBOX_CMD_HELP_TEXT("represents a partition on a main flash memory, only this partition part")
BAREBOX_CMD_HELP_TEXT("will be unprotected.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(unprotect)
.cmd = do_protect,
.usage = "disable flash write protection",
BAREBOX_CMD_DESC("disable flash write protection")
BAREBOX_CMD_OPTS("DEVICE [AREA]")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_unprotect_help)
BAREBOX_CMD_END
@ -193,7 +209,7 @@ BAREBOX_CMD_END
/**
* @page unprotect_command
Unprotect the flash memory behind the device. It depends on the device given,
It depends on the device given,
what area will be unprotected. If the device represents the whole flash memory
the whole memory will be unprotected. If the device represents a partition
on a main flash memory, only this partition part will be unprotected.

10
commands/global.c
View File

@ -61,14 +61,16 @@ static int do_global(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(global)
BAREBOX_CMD_HELP_USAGE("global [-r] <var>[=<value]\n")
BAREBOX_CMD_HELP_SHORT("add a new global variable named <var>, optionally set to <value>\n")
BAREBOX_CMD_HELP_SHORT("-r to set a value to of all globalvars beginning with 'match'")
BAREBOX_CMD_HELP_TEXT("Add a new global variable named VAR, optionally set to VALUE.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-r", "set value of all global variables beginning with 'match'")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(global)
.cmd = do_global,
.usage = "create or set global variables",
BAREBOX_CMD_DESC("create or set global variables")
BAREBOX_CMD_OPTS("[-r] VAR[=VALUE]")
BAREBOX_CMD_GROUP(CMD_GRP_ENV)
BAREBOX_CMD_HELP(cmd_global_help)
BAREBOX_CMD_END

14
commands/go.c
View File

@ -78,15 +78,17 @@ out:
return rcode;
}
static const __maybe_unused char cmd_go_help[] =
"Usage: go addr [arg ...]\n"
"Start application at address 'addr' passing 'arg' as arguments.\n"
"If addr does not start with a digit it is interpreted as a filename\n"
"in which case the file is memmapped and executed\n";
BAREBOX_CMD_HELP_START(go)
BAREBOX_CMD_HELP_TEXT("Start application at ADDR passing ARG as arguments.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("If addr does not start with a digit it is interpreted as a filename")
BAREBOX_CMD_HELP_TEXT("in which case the file is memmapped and executed")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(go)
.cmd = do_go,
.usage = "start application at address or file",
BAREBOX_CMD_DESC("start application at address or file")
BAREBOX_CMD_OPTS("ADDR [ARG...]")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_go_help)
BAREBOX_CMD_COMPLETE(command_var_complete)

36
commands/gpio.c
View File

@ -32,16 +32,11 @@ static int do_gpio_get_value(int argc, char *argv[])
return value;
}
BAREBOX_CMD_HELP_START(gpio_get_value)
BAREBOX_CMD_HELP_USAGE("gpio_get_value <gpio>\n")
BAREBOX_CMD_HELP_SHORT("get the value of an gpio input pin\n")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(gpio_get_value)
.cmd = do_gpio_get_value,
.usage = "return value of a gpio pin",
BAREBOX_CMD_DESC("return value of a GPIO pin")
BAREBOX_CMD_OPTS("GPIO")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_gpio_get_value_help)
BAREBOX_CMD_END
static int do_gpio_set_value(int argc, char *argv[])
@ -59,16 +54,11 @@ static int do_gpio_set_value(int argc, char *argv[])
return 0;
}
BAREBOX_CMD_HELP_START(gpio_set_value)
BAREBOX_CMD_HELP_USAGE("gpio_set_value <gpio> <value>\n")
BAREBOX_CMD_HELP_SHORT("set the value of an gpio output pin\n")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(gpio_set_value)
.cmd = do_gpio_set_value,
.usage = "set a gpio's output value",
BAREBOX_CMD_DESC("set a GPIO's output value")
BAREBOX_CMD_OPTS("GPIO VALUE")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_gpio_set_value_help)
BAREBOX_CMD_END
static int do_gpio_direction_input(int argc, char *argv[])
@ -87,16 +77,11 @@ static int do_gpio_direction_input(int argc, char *argv[])
return 0;
}
BAREBOX_CMD_HELP_START(gpio_direction_input)
BAREBOX_CMD_HELP_USAGE("gpio_direction_input <gpio>\n")
BAREBOX_CMD_HELP_SHORT("set direction of a gpio pin to input\n")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(gpio_direction_input)
.cmd = do_gpio_direction_input,
.usage = "set direction of a gpio pin to input",
BAREBOX_CMD_DESC("set direction of a GPIO pin to input")
BAREBOX_CMD_OPTS("GPIO")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_gpio_direction_input_help)
BAREBOX_CMD_END
static int do_gpio_direction_output(int argc, char *argv[])
@ -116,16 +101,11 @@ static int do_gpio_direction_output(int argc, char *argv[])
return 0;
}
BAREBOX_CMD_HELP_START(gpio_direction_output)
BAREBOX_CMD_HELP_USAGE("gpio_direction_output <gpio> <value>\n")
BAREBOX_CMD_HELP_SHORT("set direction of a gpio pin to output\n")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(gpio_direction_output)
.cmd = do_gpio_direction_output,
.usage = "set direction of a gpio pin to output",
BAREBOX_CMD_DESC("set direction of a GPIO pin to output")
BAREBOX_CMD_OPTS("GPIO")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_gpio_direction_output_help)
BAREBOX_CMD_END
/**

39
commands/help.c
View File

@ -42,7 +42,7 @@ static void list_group(int verbose, const char *grpname, uint32_t group)
}
}
if (verbose) {
printf(" %-21s %s\n", cmdtp->name, cmdtp->usage);
printf(" %-21s %s\n", cmdtp->name, cmdtp->desc);
continue;
}
len = strlen(cmdtp->name);
@ -67,8 +67,8 @@ static void list_commands(int verbose)
putchar('\n');
list_group(verbose, "Information", CMD_GRP_INFO);
list_group(verbose, "Boot", CMD_GRP_BOOT);
list_group(verbose, "Environment", CMD_GRP_ENV);
list_group(verbose, "Partition", CMD_GRP_PART);
list_group(verbose, "Environment", CMD_GRP_ENV);
list_group(verbose, "File", CMD_GRP_FILE);
list_group(verbose, "Scripting", CMD_GRP_SCRIPT);
list_group(verbose, "Network", CMD_GRP_NET);
@ -88,21 +88,31 @@ static void list_commands(int verbose)
static int do_help(int argc, char *argv[])
{
struct command *cmdtp;
int opt, verbose = 0;
int opt, verbose = 0, all = 0;
while ((opt = getopt(argc, argv, "v")) > 0) {
while ((opt = getopt(argc, argv, "va")) > 0) {
switch (opt) {
case 'v':
verbose = 1;
break;
case 'a':
all = 1;
break;
}
}
if (all) {
for_each_command(cmdtp)
barebox_cmd_usage(cmdtp);
return 0;
}
if (optind == argc) { /* show list of commands */
list_commands(verbose);
return 0;
}
/* command help (long version) */
if ((cmdtp = find_cmd(argv[optind])) != NULL) {
barebox_cmd_usage(cmdtp);
@ -110,25 +120,30 @@ static int do_help(int argc, char *argv[])
} else {
printf ("Unknown command '%s' - try 'help'"
" without arguments for list of all"
" known commands\n\n", argv[1]
" known commands\n\n", argv[optind]
);
return 1;
}
}
static const __maybe_unused char cmd_help_help[] =
"Show help information (for 'command')\n"
"'help' prints online help for the monitor commands.\n\n"
"Without arguments, it lists all all commands.\n\n"
"To get detailed help information for specific commands you can type\n"
"'help' with a command names as argument.\n";
BAREBOX_CMD_HELP_START(help)
BAREBOX_CMD_HELP_TEXT("Without arguments, lists all all commands. With an argument, print help")
BAREBOX_CMD_HELP_TEXT("about the specified command. If the argument is 'all', then output help")
BAREBOX_CMD_HELP_TEXT("for all commands.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-a", "output help on all commands")
BAREBOX_CMD_HELP_OPT ("-v", "verbose")
BAREBOX_CMD_HELP_END
static const char *help_aliases[] = { "?", NULL};
BAREBOX_CMD_START(help)
.cmd = do_help,
.aliases = help_aliases,
.usage = "print online help",
BAREBOX_CMD_DESC("print online help")
BAREBOX_CMD_OPTS("[-v] [COMMAND]")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_HELP(cmd_help_help)
BAREBOX_CMD_COMPLETE(command_complete)

48
commands/i2c.c
View File

@ -56,13 +56,14 @@ static int do_i2c_probe(int argc, char *argv[])
return 0;
}
static const __maybe_unused char cmd_i2c_probe_help[] =
"Usage: i2c_probe bus 0xstartaddr 0xstopaddr\n"
"probe a range of i2c addresses.\n";
BAREBOX_CMD_HELP_START(i2c_probe)
BAREBOX_CMD_HELP_TEXT("Probe the i2c bus BUS, address range from START to END for devices.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(i2c_probe)
.cmd = do_i2c_probe,
.usage = "probe for an i2c device",
BAREBOX_CMD_DESC("probe for an i2c device")
BAREBOX_CMD_OPTS("BUS START END")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_i2c_probe_help)
BAREBOX_CMD_END
@ -130,17 +131,19 @@ out:
return ret;
}
static const __maybe_unused char cmd_i2c_write_help[] =
"Usage: i2c_write [OPTION] ... hexdatas\n"
"write to i2c device.\n"
" -a 0x<addr> i2c device address\n"
" -b <bus_num> i2c bus number (default = 0)\n"
" -r 0x<reg> start register\n"
" -w use 16bit-wide address access\n";
BAREBOX_CMD_HELP_START(i2c_write)
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-b BUS\t", "i2c bus number (default 0)")
BAREBOX_CMD_HELP_OPT ("-a ADDR\t", "i2c device address")
BAREBOX_CMD_HELP_OPT ("-r START", "start register")
BAREBOX_CMD_HELP_OPT ("-w\t", "use word (16 bit) wide access")
BAREBOX_CMD_HELP_OPT ("-v\t", "verbose")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(i2c_write)
.cmd = do_i2c_write,
.usage = "write to an i2c device",
BAREBOX_CMD_DESC("write to an i2c device")
BAREBOX_CMD_OPTS("[-barwv] DATA...")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_i2c_write_help)
BAREBOX_CMD_END
@ -204,18 +207,21 @@ static int do_i2c_read(int argc, char *argv[])
return ret;
}
static const __maybe_unused char cmd_i2c_read_help[] =
"Usage: i2c_read [OPTION]\n"
"read i2c device.\n"
" -a 0x<addr> i2c device address\n"
" -b <bus_num> i2c bus number (default = 0)\n"
" -r 0x<reg> start register\n"
" -w use 16bit-wide address access\n"
" -c <count> byte count\n";
BAREBOX_CMD_HELP_START(i2c_read)
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-b BUS\t", "i2c bus number (default 0)")
BAREBOX_CMD_HELP_OPT("-a ADDR\t", "i2c device address")
BAREBOX_CMD_HELP_OPT("-r START", "start register")
BAREBOX_CMD_HELP_OPT("-w\t", "use word (16 bit) wide access")
BAREBOX_CMD_HELP_OPT("-c COUNT", "byte count")
BAREBOX_CMD_HELP_OPT("-v\t", "verbose")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(i2c_read)
.cmd = do_i2c_read,
.usage = "read from an i2c device",
BAREBOX_CMD_DESC("read from an i2c device")
BAREBOX_CMD_OPTS("[-bacrwv] DATA...")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_i2c_read_help)
BAREBOX_CMD_END

7
commands/insmod.c
View File

@ -32,12 +32,9 @@ static int do_insmod(int argc, char *argv[])
return 0;
}
static const __maybe_unused char cmd_insmod_help[] =
"Usage: insmod <module>\n";
BAREBOX_CMD_START(insmod)
.cmd = do_insmod,
.usage = "insert a module",
BAREBOX_CMD_DESC("load a barebox module")
BAREBOX_CMD_OPTS("[MODULE]")
BAREBOX_CMD_GROUP(CMD_GRP_MISC)
BAREBOX_CMD_HELP(cmd_insmod_help)
BAREBOX_CMD_END

4
commands/iomemport.c
View File

@ -49,7 +49,7 @@ static int do_iomem(int argc, char *argv[])
BAREBOX_CMD_START(iomem)
.cmd = do_iomem,
.usage = "show iomem usage",
BAREBOX_CMD_DESC("show IO memory usage")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_END
@ -63,7 +63,7 @@ static int do_ioport(int argc, char *argv[])
BAREBOX_CMD_START(ioport)
.cmd = do_ioport,
.usage = "show ioport usage",
BAREBOX_CMD_DESC("show IO port usage")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_END
#endif

11
commands/led.c
View File

@ -80,14 +80,17 @@ is allowed.
*/
BAREBOX_CMD_HELP_START(led)
BAREBOX_CMD_HELP_USAGE("led <led> <value>\n")
BAREBOX_CMD_HELP_SHORT("control the value of a LED. a value of 0 means disabled\n")
BAREBOX_CMD_HELP_SHORT("without arguments the available LEDs are listed\n")
BAREBOX_CMD_HELP_TEXT("Control the value of a LED. The exact meaning of VALUE is unspecified,")
BAREBOX_CMD_HELP_TEXT("it can be a brightness, or a color. Most often a value of '1' means on")
BAREBOX_CMD_HELP_TEXT("and '0' means off.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Without arguments the available LEDs are listed.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(led)
.cmd = do_led,
.usage = "led <led> <value>",
BAREBOX_CMD_DESC("control LEDs")
BAREBOX_CMD_OPTS("LED VALUE")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_led_help)
BAREBOX_CMD_END

43
commands/let.c
View File

@ -63,32 +63,31 @@ static int do_let(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(let)
BAREBOX_CMD_HELP_USAGE("let expr [expr ...]\n")
BAREBOX_CMD_HELP_SHORT("evaluate arithmetic expressions\n")
BAREBOX_CMD_HELP_TEXT ("supported operations are in order of decreasing precedence:\n")
BAREBOX_CMD_HELP_TEXT (" X++, X--\n")
BAREBOX_CMD_HELP_TEXT (" ++X, --X\n")
BAREBOX_CMD_HELP_TEXT (" +X, -X\n")
BAREBOX_CMD_HELP_TEXT (" !X, ~X\n")
BAREBOX_CMD_HELP_TEXT (" X**Y\n")
BAREBOX_CMD_HELP_TEXT (" X*Y, X/Y, X%Y\n")
BAREBOX_CMD_HELP_TEXT (" X+Y, X-Y\n")
BAREBOX_CMD_HELP_TEXT (" X<<Y, X>>Y\n")
BAREBOX_CMD_HELP_TEXT (" X<Y, X<=Y, X>=Y, X>Y\n")
BAREBOX_CMD_HELP_TEXT (" X==Y, X!=Y\n")
BAREBOX_CMD_HELP_TEXT (" X&Y\n")
BAREBOX_CMD_HELP_TEXT (" X^Y\n")
BAREBOX_CMD_HELP_TEXT (" X|Y\n")
BAREBOX_CMD_HELP_TEXT (" X&&Y\n")
BAREBOX_CMD_HELP_TEXT (" X||Y\n")
BAREBOX_CMD_HELP_TEXT (" X?Y:Z\n")
BAREBOX_CMD_HELP_TEXT (" X*=Y, X/=Y, X%=Y\n")
BAREBOX_CMD_HELP_TEXT (" X=Y, X&=Y, X|=Y, X^=Y, X+=Y, X-=Y, X<<=Y, X>>=Y\n")
BAREBOX_CMD_HELP_TEXT ("Supported operations are in order of decreasing precedence:")
BAREBOX_CMD_HELP_TEXT (" X++, X--")
BAREBOX_CMD_HELP_TEXT (" ++X, --X")
BAREBOX_CMD_HELP_TEXT (" +X, -X")
BAREBOX_CMD_HELP_TEXT (" !X, ~X")
BAREBOX_CMD_HELP_TEXT (" X**Y")
BAREBOX_CMD_HELP_TEXT (" X*Y, X/Y, X%Y")
BAREBOX_CMD_HELP_TEXT (" X+Y, X-Y")
BAREBOX_CMD_HELP_TEXT (" X<<Y, X>>Y")
BAREBOX_CMD_HELP_TEXT (" X<Y, X<=Y, X>=Y, X>Y")
BAREBOX_CMD_HELP_TEXT (" X==Y, X!=Y")
BAREBOX_CMD_HELP_TEXT (" X&Y")
BAREBOX_CMD_HELP_TEXT (" X^Y")
BAREBOX_CMD_HELP_TEXT (" X|Y")
BAREBOX_CMD_HELP_TEXT (" X&&Y")
BAREBOX_CMD_HELP_TEXT (" X||Y")
BAREBOX_CMD_HELP_TEXT (" X?Y:Z")
BAREBOX_CMD_HELP_TEXT (" X*=Y, X/=Y, X%=Y")
BAREBOX_CMD_HELP_TEXT (" X=Y, X&=Y, X|=Y, X^=Y, X+=Y, X-=Y, X<<=Y, X>>=Y")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(let)
.cmd = do_let,
.usage = "evaluate arithmetic expressions",
BAREBOX_CMD_DESC("evaluate arithmetic expressions")
BAREBOX_CMD_OPTS("EXPR [EXPR ...]")
BAREBOX_CMD_GROUP(CMD_GRP_SCRIPT)
BAREBOX_CMD_HELP(cmd_let_help)
BAREBOX_CMD_END

16
commands/linux16.c
View File

@ -318,9 +318,16 @@ on_error:
}
BAREBOX_CMD_HELP_START(linux16)
BAREBOX_CMD_HELP_USAGE("linux16 <file> [-v <mode>]\n")
BAREBOX_CMD_HELP_SHORT("Boot a kernel <file> on x86 via real mode code.\n")
BAREBOX_CMD_HELP_OPT ("-v <mode>", "VESA video mode number or 'ask'\n")
BAREBOX_CMD_HELP_TEXT("Load kernel from FILE and boot on x86 in real-mode.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Only kernel images in bzImage format are supported by now.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("For the video mode refer the Linux kernel documentation")
BAREBOX_CMD_HELP_TEXT("'Documentation/fb/vesafb.txt' for correct VESA mode numbers. Use 'ask'")
BAREBOX_CMD_HELP_TEXT("instead of a number to make Linux for options..")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-v VESAMODE", "set VESAMODE")
BAREBOX_CMD_HELP_END
/**
@ -337,7 +344,8 @@ x86_boot_preparation for more info about how to use this command.</p>
BAREBOX_CMD_START(linux16)
.cmd = do_linux16,
.usage = "boot a linux kernel",
BAREBOX_CMD_DESC("boot a linux kernel on x86 via real-mode code")
BAREBOX_CMD_OPTS("[-v VESAMODE] FILE")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_linux16_help)
BAREBOX_CMD_END

9
commands/linux_exec.c
View File

@ -45,14 +45,9 @@ static int do_linux_exec(int argc, char *argv[])
return 0;
}
BAREBOX_CMD_HELP_START(linux_exec)
BAREBOX_CMD_HELP_USAGE("linux_exec ...\n")
BAREBOX_CMD_HELP_SHORT("Execute a command on the host\n")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(linux_exec)
.cmd = do_linux_exec,
.usage = "Execute a command on the host",
BAREBOX_CMD_DESC("execute a command on the host")
BAREBOX_CMD_OPTS("COMMAND")
BAREBOX_CMD_GROUP(CMD_GRP_MISC)
BAREBOX_CMD_HELP(cmd_linux_exec_help)
BAREBOX_CMD_END

9
commands/ln.c
View File

@ -39,14 +39,9 @@ static int do_ln(int argc, char *argv[])
return 0;
}
BAREBOX_CMD_HELP_START(ln)
BAREBOX_CMD_HELP_USAGE("ln SRC DEST\n")
BAREBOX_CMD_HELP_SHORT("symlink - make a new name for a file\n")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(ln)
.cmd = do_ln,
.usage = "symlink - make a new name for a file",
BAREBOX_CMD_DESC("create symlink (make a new name for a file)")
BAREBOX_CMD_OPTS("SRC DEST")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_ln_help)
BAREBOX_CMD_END

19
commands/loadb.c
View File

@ -698,16 +698,19 @@ static int do_load_serial_bin(int argc, char *argv[])
return rcode;
}
static const __maybe_unused char cmd_loadb_help[] =
"[OPTIONS]\n"
" -f file - where to download to - defaults to " DEF_FILE "\n"
" -o offset - what offset to download - defaults to 0\n"
" -b baud - baudrate at which to download - defaults to "
"console baudrate\n"
" -c - Create file if it is not present - default disabled";
BAREBOX_CMD_HELP_START(loadb)
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-f FILE", "download to FILE (default " DEF_FILE ")")
BAREBOX_CMD_HELP_OPT("-o OFFS", "destination file OFFSet (default 0)")
BAREBOX_CMD_HELP_OPT("-b BAUD", "baudrate for download (default: console baudrate")
BAREBOX_CMD_HELP_OPT("-c", "create file if not present")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(loadb)
.cmd = do_load_serial_bin,
.usage = "Load binary file over serial line (kermit mode)",
BAREBOX_CMD_DESC("load binary file over serial line (Kermit)")
BAREBOX_CMD_OPTS(" FILE")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_loadb_help)
BAREBOX_CMD_END

15
commands/loadenv.c
View File

@ -103,11 +103,13 @@ static int do_loadenv(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(loadenv)
BAREBOX_CMD_HELP_USAGE("loadenv OPTIONS [ENVFS] [DIRECTORY]\n")
BAREBOX_CMD_HELP_OPT("-n", "do not overwrite existing files\n")
BAREBOX_CMD_HELP_OPT("-s", "scrub old environment\n")
BAREBOX_CMD_HELP_OPT("-d", "load default environment\n")
BAREBOX_CMD_HELP_SHORT("Load environment from ENVFS into DIRECTORY (default: /dev/env0 -> /env).\n")
BAREBOX_CMD_HELP_TEXT("Load environment from files in ENVFS (default /dev/env0) in")
BAREBOX_CMD_HELP_TEXT("DIRECTORY (default /env")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-n", "do not overwrite existing files")
BAREBOX_CMD_HELP_OPT("-s", "scrub old environment")
BAREBOX_CMD_HELP_OPT("-d", "load default environment")
BAREBOX_CMD_HELP_END
/**
@ -121,7 +123,8 @@ ENVFS can only handle files, directories are skipped silently.
BAREBOX_CMD_START(loadenv)
.cmd = do_loadenv,
.usage = "Load environment from ENVFS into DIRECTORY (default: /dev/env0 -> /env).",
BAREBOX_CMD_DESC("load environment from ENVFS")
BAREBOX_CMD_OPTS("{-nsd] [ENVFS] [DIRECTORY]")
BAREBOX_CMD_GROUP(CMD_GRP_ENV)
BAREBOX_CMD_HELP(cmd_loadenv_help)
BAREBOX_CMD_END

19
commands/loads.c
View File

@ -270,13 +270,14 @@ static int write_record(char *buf)
}
#endif /* CONFIG_CMD_SAVES */
static const __maybe_unused char cmd_loads_help[] =
"[ off ]\n"
" - load S-Record file over serial line with offset 'off'\n";
BAREBOX_CMD_HELP_START(loads)
BAREBOX_CMD_HELP_TEXT("Load S-Record file over serial line with offset OFFS.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(loads)
.cmd = do_load_serial,
.usage = "load S-Record file over serial line",
BAREBOX_CMD_DESC("load binary file over serial line (S-Records)")
BAREBOX_CMD_OPTS("OFFS")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_loads_help)
BAREBOX_CMD_END
@ -286,14 +287,14 @@ BAREBOX_CMD_END
*/
#ifdef CONFIG_CMD_SAVES
static const __maybe_unused char cmd_saves_help[] =
"[ off ] [size]\n"
" - save S-Record file over serial line with offset 'off' "
"and size 'size'\n";
BAREBOX_CMD_HELP_START(saves)
BAREBOX_CMD_HELP_TEXT("Save S-Record file to serial line with offset OFFS and length LEN.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(saves)
.cmd = do_save_serial,
.usage = "save S-Record file over serial line",
BAREBOX_CMD_DESC("save file over serial line (S-Records)")
BAREBOX_CMD_OPTS("OFFS LEN")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_saves_help)
BAREBOX_CMD_END

53
commands/loadxy.c
View File

@ -140,6 +140,22 @@ static int do_loady(int argc, char *argv[])
return rcode;
}
BAREBOX_CMD_HELP_START(loady)
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-g", "use Y-Modem/G (use on lossless tty such as USB)")
BAREBOX_CMD_HELP_OPT("-b BAUD", "baudrate for download (default: console baudrate")
BAREBOX_CMD_HELP_OPT("-t NAME", "console name to use (default: current)")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(loady)
.cmd = do_loady,
BAREBOX_CMD_DESC("load binary file over serial line (Y-Modem)")
BAREBOX_CMD_OPTS("[-gtb]")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_loady_help)
BAREBOX_CMD_END
/**
* @brief provide the loadx(X-Modem) support
*
@ -184,7 +200,7 @@ static int do_loadx(int argc, char *argv[])
else
cdev = console_get_first_active();
if (!cdev) {
printf("%s:No console device %s with STDIN and STDOUT\n",
printf("%s:No console device %s with STDIN and STDOUT",
argv[0], cname ? cname : "default");
return -ENODEV;
}
@ -224,32 +240,19 @@ static int do_loadx(int argc, char *argv[])
return rcode;
}
static const __maybe_unused char cmd_loadx_help[] =
"[OPTIONS]\n"
" -f file - where to download to - defaults to " DEF_FILE "\n"
" -o offset - what offset to download - defaults to 0\n"
" -t name - console device name to use - defaults to current console\n"
" -b baud - baudrate at which to download - defaults to console baudrate\n"
" -c - Create file if it is not present - default disabled";
BAREBOX_CMD_HELP_START(loadx)
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-f FILE", "download to FILE (default " DEF_FILE ")")
BAREBOX_CMD_HELP_OPT("-o OFFS", "destination file OFFSet (default 0)")
BAREBOX_CMD_HELP_OPT("-b BAUD", "baudrate for download (default: console baudrate")
BAREBOX_CMD_HELP_OPT("-t NAME", "console name to use (default: current)")
BAREBOX_CMD_HELP_OPT("-c", "create file if not present")
BAREBOX_CMD_HELP_END
#ifdef CONFIG_CMD_LOADY
BAREBOX_CMD_START(loadx)
.cmd = do_loadx,
.usage = "Load binary file over serial line (X-Modem)",
BAREBOX_CMD_DESC("load binary file over serial line (X-Modem)")
BAREBOX_CMD_OPTS("[-fptbc]")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_loadx_help)
BAREBOX_CMD_HELP(cmd_loadx_help)
BAREBOX_CMD_END
static const __maybe_unused char cmd_loady_help[] =
"[OPTIONS]\n"
" -g - use Y-Modem/G (only for lossless tty as USB)\n"
" -t name - console device name to use - defaults to current console\n"
" -b baud - baudrate at which to download - defaults to console baudrate\n";
BAREBOX_CMD_START(loady)
.cmd = do_loady,
.usage = "Load binary file over serial line (Y-Modem or Y-Modem/G)",
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_loady_help)
BAREBOX_CMD_END
#endif

16
commands/login.c
View File

@ -78,15 +78,19 @@ static int do_login(int argc, char *argv[])
return 0;
}
static const __maybe_unused char cmd_login_help[] =
"Usage: login [-t timeout [<command>]]\n"
"If a timeout is specified and expired the command will be executed;\n"
"\"boot\" by default\n"
;
BAREBOX_CMD_HELP_START(login)
BAREBOX_CMD_HELP_TEXT("Asks for a password from the console before script execution continues.")
BAREBOX_CMD_HELP_TEXT("The password can be set with the 'passwd' command. Instead of specifying")
BAREBOX_CMD_HELP_TEXT("a TIMEOUT the magic variable 'global.login.timeout' could be set.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-t TIMEOUT", "Execute COMMAND if no login withing TIMEOUT seconds")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(login)
.cmd = do_login,
.usage = "login",
BAREBOX_CMD_DESC("ask for a password")
BAREBOX_CMD_OPTS("[-t TIMEOUT] COMMAND")
BAREBOX_CMD_GROUP(CMD_GRP_CONSOLE)
BAREBOX_CMD_HELP(cmd_login_help)
BAREBOX_CMD_COMPLETE(empty_complete)

12
commands/ls.c
View File

@ -204,14 +204,18 @@ static int do_ls(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(ls)
BAREBOX_CMD_HELP_USAGE("ls [OPTIONS] [FILES]\n")
BAREBOX_CMD_HELP_SHORT("List information about the FILEs (the current directory by default).\n")
BAREBOX_CMD_HELP_OPT ("-R", "list subdirectories recursively\n")
BAREBOX_CMD_HELP_TEXT("List information about the specified files or directories.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-l", "long format")
BAREBOX_CMD_HELP_OPT ("-C", "column format (opposite of long format)")
BAREBOX_CMD_HELP_OPT ("-R", "list subdirectories recursively")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(ls)
.cmd = do_ls,
.usage = "list a file or directory",
BAREBOX_CMD_DESC("list a file or directory")
BAREBOX_CMD_OPTS("[-lCR] [FILEDIR...]")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_ls_help)
BAREBOX_CMD_END

2
commands/lsmod.c
View File

@ -15,7 +15,7 @@ static int do_lsmod(int argc, char *argv[])
BAREBOX_CMD_START(lsmod)
.cmd = do_lsmod,
.usage = "list modules",
BAREBOX_CMD_DESC("list loaded barebox modules")
BAREBOX_CMD_GROUP(CMD_GRP_MISC)
BAREBOX_CMD_COMPLETE(empty_complete)
BAREBOX_CMD_END

2
commands/magicvar.c
View File

@ -16,6 +16,6 @@ static int do_magicvar(int argc, char *argv[])
BAREBOX_CMD_START(magicvar)
.cmd = do_magicvar,
.usage = "List information about magic variables",
BAREBOX_CMD_DESC("list information about magic variables")
BAREBOX_CMD_GROUP(CMD_GRP_ENV)
BAREBOX_CMD_END

37
commands/md.c
View File

@ -89,29 +89,28 @@ out:
return ret ? 1 : 0;
}
static const __maybe_unused char cmd_md_help[] =
"Usage md [OPTIONS] <region>\n"
"display (hexdump) a memory region.\n"
"options:\n"
" -s <file> display file (default /dev/mem)\n"
" -b output in bytes\n"
" -w output in halfwords (16bit)\n"
" -l output in words (32bit)\n"
" -x swap bytes at output\n"
"\n"
"Memory regions:\n"
"Memory regions can be specified in two different forms: start+size\n"
"or start-end, If <start> is omitted it defaults to 0. If end is omitted it\n"
"defaults to the end of the device, except for interactive commands like md\n"
"and mw for which it defaults to 0x100.\n"
"Sizes can be specified as decimal, or if prefixed with 0x as hexadecimal.\n"
"an optional suffix of k, M or G is for kibibytes, Megabytes or Gigabytes,\n"
"respectively\n";
BAREBOX_CMD_HELP_START(md)
BAREBOX_CMD_HELP_TEXT("Display (hex dump) a memory region.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-b", "byte access")
BAREBOX_CMD_HELP_OPT ("-w", "word access (16 bit)")
BAREBOX_CMD_HELP_OPT ("-l", "long access (32 bit)")
BAREBOX_CMD_HELP_OPT ("-s FILE", "display file (default /dev/mem)")
BAREBOX_CMD_HELP_OPT ("-x", "swap bytes at output")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Memory regions can be specified in two different forms: START+SIZE")
BAREBOX_CMD_HELP_TEXT("or START-END, If START is omitted it defaults to 0x100")
BAREBOX_CMD_HELP_TEXT("Sizes can be specified as decimal, or if prefixed with 0x as hexadecimal.")
BAREBOX_CMD_HELP_TEXT("An optional suffix of k, M or G is for kbytes, Megabytes or Gigabytes.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(md)
.cmd = do_mem_md,
.usage = "memory display",
BAREBOX_CMD_DESC("memory display")
BAREBOX_CMD_OPTS("[-bwlsx] REGION")
BAREBOX_CMD_GROUP(CMD_GRP_MEM)
BAREBOX_CMD_HELP(cmd_md_help)
BAREBOX_CMD_END

28
commands/memcmp.c
View File

@ -128,22 +128,24 @@ out:
return ret;
}
static const __maybe_unused char cmd_memcmp_help[] =
"Usage: memcmp [OPTIONS] <addr1> <addr2> <count>\n"
"\n"
"options:\n"
" -b, -w, -l use byte, halfword, or word accesses\n"
" -s <file> source file (default /dev/mem)\n"
" -d <file> destination file (default /dev/mem)\n"
"\n"
"Compare memory regions specified with addr1 and addr2\n"
"of size <count> bytes. If source is a file count can\n"
"be left unspecified in which case the whole file is\n"
"compared\n";
BAREBOX_CMD_HELP_START(memcmp)
BAREBOX_CMD_HELP_TEXT("Compare memory regions specified with ADDR and ADDR2")
BAREBOX_CMD_HELP_TEXT("of size COUNT bytes. If source is a file COUNT can")
BAREBOX_CMD_HELP_TEXT("be left unspecified, in which case the whole file is")
BAREBOX_CMD_HELP_TEXT("compared.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-b", "byte access")
BAREBOX_CMD_HELP_OPT ("-w", "word access (16 bit)")
BAREBOX_CMD_HELP_OPT ("-l", "long access (32 bit)")
BAREBOX_CMD_HELP_OPT ("-s FILE", "source file (default /dev/mem)")
BAREBOX_CMD_HELP_OPT ("-d FILE", "destination file (default /dev/mem)")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(memcmp)
.cmd = do_memcmp,
.usage = "memory compare",
BAREBOX_CMD_DESC("memory compare")
BAREBOX_CMD_OPTS("[-bwlsd] ADDR1 ADDR2 COUNT")
BAREBOX_CMD_GROUP(CMD_GRP_MEM)
BAREBOX_CMD_HELP(cmd_memcmp_help)
BAREBOX_CMD_END

22
commands/memcpy.c
View File

@ -128,19 +128,21 @@ out:
return ret;
}
static const __maybe_unused char cmd_memcpy_help[] =
"Usage: memcpy [OPTIONS] <src> <dst> <count>\n"
"\n"
"options:\n"
" -b, -w, -l use byte, halfword, or word accesses\n"
" -s <file> source file (default /dev/mem)\n"
" -d <file> destination file (default /dev/mem)\n"
"\n"
"Copy memory at <src> of <count> bytes to <dst>\n";
BAREBOX_CMD_HELP_START(memcpy)
BAREBOX_CMD_HELP_TEXT("Copy memory at SRC of COUNT bytes to DEST")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-b", "byte access")
BAREBOX_CMD_HELP_OPT ("-w", "word access (16 bit)")
BAREBOX_CMD_HELP_OPT ("-l", "long access (32 bit)")
BAREBOX_CMD_HELP_OPT ("-s FILE", "source file (default /dev/mem)")
BAREBOX_CMD_HELP_OPT ("-d FILE", "write file (default /dev/mem)")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(memcpy)
.cmd = do_memcpy,
.usage = "memory copy",
BAREBOX_CMD_DESC("memory copy")
BAREBOX_CMD_OPTS("[-bwlsd] SRC DEST COUNT")
BAREBOX_CMD_GROUP(CMD_GRP_MEM)
BAREBOX_CMD_HELP(cmd_memcpy_help)
BAREBOX_CMD_END

2
commands/meminfo.c
View File

@ -30,7 +30,7 @@ static int do_meminfo(int argc, char *argv[])
BAREBOX_CMD_START(meminfo)
.cmd = do_meminfo,
.usage = "print info about memory usage",
BAREBOX_CMD_DESC("print info about memory usage")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_COMPLETE(empty_complete)
BAREBOX_CMD_END

20
commands/memset.c
View File

@ -85,18 +85,20 @@ out:
return ret;
}
static const __maybe_unused char cmd_memset_help[] =
"Usage: memset [OPTIONS] <addr> <c> <n>\n"
"\n"
"options:\n"
" -b, -w, -l use byte, halfword, or word accesses\n"
" -d <file> destination file (default /dev/mem)\n"
"\n"
"Fill the first <n> bytes at offset <addr> with byte <c>\n";
BAREBOX_CMD_HELP_START(memset)
BAREBOX_CMD_HELP_TEXT("Fills the first COUNT bytes at offset ADDR with byte DATA,")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-b", "byte access")
BAREBOX_CMD_HELP_OPT ("-w", "word access (16 bit)")
BAREBOX_CMD_HELP_OPT ("-l", "long access (32 bit)")
BAREBOX_CMD_HELP_OPT ("-d FILE", "write file (default /dev/mem)")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(memset)
.cmd = do_memset,
.usage = "memory fill",
BAREBOX_CMD_DESC("memory fill")
BAREBOX_CMD_OPTS("[-bwld] ADDR COUNT DATA")
BAREBOX_CMD_GROUP(CMD_GRP_MEM)
BAREBOX_CMD_HELP(cmd_memset_help)
BAREBOX_CMD_END

14
commands/memtest.c
View File

@ -230,15 +230,17 @@ out:
return 0;
}
static const __maybe_unused char cmd_memtest_help[] =
"Usage: memtest [OPTION]...\n"
"memtest related commands\n"
" -i <iterations> iterations [default=1, endless=0].\n"
" -b perform only a test on buslines.";
BAREBOX_CMD_HELP_START(memtest)
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-i ITERATIONS", "perform number of iterations (default 1, 0 is endless)")
BAREBOX_CMD_HELP_OPT("-b", "perform only a test on bus lines")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(memtest)
.cmd = do_memtest,
.usage = "Memory Test",
BAREBOX_CMD_DESC("extensive memory test")
BAREBOX_CMD_OPTS("[-ib]")
BAREBOX_CMD_GROUP(CMD_GRP_MEM)
BAREBOX_CMD_HELP(cmd_memtest_help)
BAREBOX_CMD_END

54
commands/menu.c
View File

@ -407,71 +407,67 @@ end:
}
static const __maybe_unused char cmd_menu_help[] =
"Usage: menu [OPTION]... \n"
"Manage Menu\n"
"Manage Menu:\n"
" -m menu\n"
" -l list\n"
" -s show\n"
#if defined(CONFIG_CMD_MENU_MANAGEMENT)
"Advanced\n"
"Advanced menu management:\n"
" -e menu entry\n"
" -a add\n"
" -r remove\n"
" -S select\n"
#endif
"\n"
"How to\n"
"\n"
"Show menu\n"
"Show menu:\n"
" (-A auto select delay)\n"
" (-d auto select description)\n"
" menu -s -m <menu> [-A delay] [-d auto_display]\n"
" menu -s -m MENU [-A delay] [-d auto_display]\n"
"\n"
"List menu\n"
"List menu:\n"
" menu -l\n"
"\n"
#if defined(CONFIG_CMD_MENU_MANAGEMENT)
"Add a menu\n"
" menu -a -m <name> -d <description>\n"
"Add a menu:\n"
" menu -a -m NAME -d DESC\n"
"\n"
"Remove a menu\n"
" menu -r -m <name>\n"
"Remove a menu:\n"
" menu -r -m NAME\n"
"\n"
"Add an entry\n"
"Add an entry:\n"
" (-R for do no exit the menu after executing the command)\n"
" (-b for box style 1 for selected)\n"
" (and optional -c for the command to run when we change the state)\n"
" menu -e -a -m <menu> -c <command> [-R] [-b 0|1] -d <description>\n"
" menu -e -a -m MENU -c COMMAND [-R] [-b 0|1] -d DESC\n"
"Add a submenu entry\n"
"Add a submenu entry:\n"
" (-R is not needed)\n"
" (-b for box style 1 for selected)\n"
" (and -c is not needed)\n"
" menu -e -a -m <menu> -u submenu -d [-b 0|1] <description>\n"
" menu -e -a -m MENU -u submenu -d [-b 0|1] DESC\n"
"\n"
"Remove an entry\n"
" menu -e -r -m <name> -n <num>\n"
"Remove an entry:\n"
" menu -e -r -m NAME -n ENTRY\n"
"\n"
"Select an entry\n"
" menu -m <menu> -S -n <entry num starting at 1>\n"
"Select an entry:\n"
" menu -m <menu> -S -n ENTRY\n"
"\n"
"List menu\n"
"List menu:\n"
" menu -e -l [menu]\n"
"\n"
"Menu example\n"
"menu -a -m boot -d \"Boot Menu\"\n"
"menu -e -a -m boot -c boot -d \"Boot\"\n"
"menu -e -a -m boot -c reset -d \"Reset\"\n"
"menu -s -m boot\n"
"Menu examples:\n"
" menu -a -m boot -d \"Boot Menu\"\n"
" menu -e -a -m boot -c boot -d \"Boot\"\n"
" menu -e -a -m boot -c reset -d \"Reset\"\n"
#else
"Menu example\n"
"menu -s -m boot\n"
"Menu example:\n"
#endif
" menu -s -m boot\n"
;
BAREBOX_CMD_START(menu)
.cmd = do_menu,
.usage = "Menu Management",
BAREBOX_CMD_DESC("create and display menus")
BAREBOX_CMD_GROUP(CMD_GRP_CONSOLE)
BAREBOX_CMD_HELP(cmd_menu_help)
BAREBOX_CMD_END

36
commands/menutree.c
View File

@ -32,30 +32,28 @@ static int do_menutree(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(menutree)
BAREBOX_CMD_HELP_USAGE("menutree [OPTIONS]\n")
"\n"
"Create a menu from a directory structure\n"
"Each menu entry is described by a subdirectory. Each subdirectory\n"
"can contain the following files which further describe the entry:\n"
"\n"
"title - A file containing the title of the entry as shown in the menu\n"
"box - If present, the entry is a 'bool' entry. The file contains a variable\n"
" name from which the current state of the bool is taken from and saved\n"
" to.\n"
"action - if present this file contains a shell script which is executed when\n"
" when the entry is selected.\n"
"If neither 'box' or 'action' are present this entry is considered a submenu\n"
"containing more entries.\n"
"\n"
"Options:\n"
" -m <dir> directory where the menu starts (/env/menu)\n"
BAREBOX_CMD_HELP_TEXT("Each menu entry is described by a subdirectory. Each subdirectory")
BAREBOX_CMD_HELP_TEXT("can contain the following files which further describe the entry:")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("title A file containing the title of the entry as shown in the menu")
BAREBOX_CMD_HELP_TEXT("box If present, the entry is a 'bool' entry. The file contains a")
BAREBOX_CMD_HELP_TEXT(" name from which the current state of the bool is taken from and saved")
BAREBOX_CMD_HELP_TEXT(" to.")
BAREBOX_CMD_HELP_TEXT("action if present this file contains a shell script which is executed when")
BAREBOX_CMD_HELP_TEXT(" when the entry is selected.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("If neither 'box' or 'action' are present, this entry is considered a submenu")
BAREBOX_CMD_HELP_TEXT("containing more entries.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-m DIR", "directory where the menu starts (Default: /env/menu)")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(menutree)
.cmd = do_menutree,
.usage = "create a menu from a directory structure",
BAREBOX_CMD_DESC("create menu from directory structure")
BAREBOX_CMD_OPTS("[-m] DIR")
BAREBOX_CMD_GROUP(CMD_GRP_CONSOLE)
BAREBOX_CMD_HELP(cmd_menutree_help)
BAREBOX_CMD_END

11
commands/miitool.c
View File

@ -285,8 +285,12 @@ static int do_miitool(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(miitool)
BAREBOX_CMD_HELP_USAGE("miitool [[[-v] -v] -v] <phy>\n")
BAREBOX_CMD_HELP_SHORT("view status for MII <phy>.\n")
BAREBOX_CMD_HELP_TEXT("This utility checks or sets the status of a network interface's")
BAREBOX_CMD_HELP_TEXT("Media Independent Interface (MII) unit. Most fast ethernet")
BAREBOX_CMD_HELP_TEXT("adapters use an MII to autonegotiate link speed and duplex setting.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-v", "increase verbosity")
BAREBOX_CMD_HELP_END
/**
@ -297,7 +301,8 @@ adapters use an MII to autonegotiate link speed and duplex setting.
*/
BAREBOX_CMD_START(miitool)
.cmd = do_miitool,
.usage = "view media-independent interface status",
BAREBOX_CMD_DESC("view media-independent interface status")
BAREBOX_CMD_OPTS("[-v] PHY")
BAREBOX_CMD_GROUP(CMD_GRP_NET)
BAREBOX_CMD_HELP(cmd_miitool_help)
BAREBOX_CMD_END

12
commands/mkdir.c
View File

@ -59,13 +59,17 @@ static int do_mkdir(int argc, char *argv[])
return 0;
}
static const __maybe_unused char cmd_mkdir_help[] =
"Usage: mkdir [directories]\n"
"Create new directories\n";
BAREBOX_CMD_HELP_START(mkdir)
BAREBOX_CMD_HELP_TEXT("Create new directories")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-p", "make parent directories as needed")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(mkdir)
.cmd = do_mkdir,
.usage = "make directories",
BAREBOX_CMD_DESC("make directories")
BAREBOX_CMD_OPTS("[DIRECTORY ...]")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_mkdir_help)
BAREBOX_CMD_END

19
commands/mm.c
View File

@ -103,16 +103,21 @@ out_write:
return 1;
}
static const __maybe_unused char cmd_mm_help[] =
"Usage: mm [OPTIONS] <adr> <val> <mask>\n"
"set/clear bits specified with <mask> in <adr> to <value>\n"
"options:\n"
" -b, -w, -l use byte, halfword, or word accesses\n"
" -d <file> write file (default /dev/mem)\n";
BAREBOX_CMD_HELP_START(mm)
BAREBOX_CMD_HELP_TEXT("Set/clear bits specified with MASK in ADDR to VALUE")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-b", "byte access")
BAREBOX_CMD_HELP_OPT ("-w", "word access (16 bit)")
BAREBOX_CMD_HELP_OPT ("-l", "long access (32 bit)")
BAREBOX_CMD_HELP_OPT ("-d FILE", "write file (default /dev/mem)")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(mm)
.cmd = do_mem_mm,
.usage = "memory modify write with mask",
BAREBOX_CMD_DESC("memory modify with mask")
BAREBOX_CMD_OPTS("[-bwld] ADDR VAL MASK")
BAREBOX_CMD_GROUP(CMD_GRP_MEM)
BAREBOX_CMD_HELP(cmd_mm_help)
BAREBOX_CMD_END

26
commands/mount.c
View File

@ -116,17 +116,18 @@ static int do_mount(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(mount)
BAREBOX_CMD_HELP_USAGE("mount [[OPTIONS] <device> [mountpoint]]\n")
BAREBOX_CMD_HELP_OPT("-t <type>", "specify filesystem type\n")
BAREBOX_CMD_HELP_OPT("-a", "Mount all blockdevices.\n")
BAREBOX_CMD_HELP_OPT("-v", "be more verbose\n")
BAREBOX_CMD_HELP_SHORT("Mount a filesystem of a given type to a mountpoint.\n")
BAREBOX_CMD_HELP_SHORT("If no fstype is specified, try to detect it automatically.\n")
BAREBOX_CMD_HELP_SHORT("If no argument is given, list mounted filesystems.\n")
BAREBOX_CMD_HELP_SHORT("With -a the mount command mounts all block devices whose filesystem\n")
BAREBOX_CMD_HELP_SHORT("can be detected automatically to /mnt/<partname>\n")
BAREBOX_CMD_HELP_SHORT("If mountpoint is not given a standard mountpoint of /mnt/devname>\n")
BAREBOX_CMD_HELP_SHORT("is used. This directoy is created automatically if necessary.\n")
BAREBOX_CMD_HELP_TEXT("If no argument is given, list mounted filesystems.")
BAREBOX_CMD_HELP_TEXT("If no FSTYPE is specified, try to detect it automatically.")
BAREBOX_CMD_HELP_TEXT("With -a the mount command mounts all block devices whose filesystem")
BAREBOX_CMD_HELP_TEXT("can be detected automatically to /mnt/PARTNAME")
BAREBOX_CMD_HELP_TEXT("If mountpoint is not given, a standard mountpoint of /mnt/DEVICE")
BAREBOX_CMD_HELP_TEXT("is used. This directoy is created automatically if necessary.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-a\t", "mount all blockdevices")
BAREBOX_CMD_HELP_OPT("-t FSTYPE", "specify filesystem type")
BAREBOX_CMD_HELP_OPT("-o OPTIONS", "set file system OPTIONS")
BAREBOX_CMD_HELP_OPT("-v\t", "verbose")
BAREBOX_CMD_HELP_END
/**
@ -162,7 +163,8 @@ the filesystem has been unmounted.
BAREBOX_CMD_START(mount)
.cmd = do_mount,
.usage = "Mount a filesystem of a given type to a mountpoint or list mounted filesystems.",
BAREBOX_CMD_DESC("mount a filesystem or list mounted filesystems")
BAREBOX_CMD_OPTS("[[-atov] [DEVICE] [MOUNTPOINT]]")
BAREBOX_CMD_GROUP(CMD_GRP_PART)
BAREBOX_CMD_HELP(cmd_mount_help)
BAREBOX_CMD_END

3
commands/msleep.c
View File

@ -36,6 +36,7 @@ static int do_msleep(int argc, char *argv[])
BAREBOX_CMD_START(msleep)
.cmd = do_msleep,
.usage = "delay execution for n milliseconds",
BAREBOX_CMD_DESC("delay execution for n milli-seconds")
BAREBOX_CMD_OPTS("MILLISECONDS")
BAREBOX_CMD_GROUP(CMD_GRP_SCRIPT)
BAREBOX_CMD_END

18
commands/mw.c
View File

@ -90,16 +90,20 @@ static int do_mem_mw(int argc, char *argv[])
return ret ? 1 : 0;
}
static const __maybe_unused char cmd_mw_help[] =
"Usage: mw [OPTIONS] <region> <value(s)>\n"
"Write value(s) to the specifies region.\n"
"options:\n"
" -b, -w, -l use byte, halfword, or word accesses\n"
" -d <file> write file (default /dev/mem)\n";
BAREBOX_CMD_HELP_START(mw)
BAREBOX_CMD_HELP_TEXT("Write DATA value(s) to the specified REGION.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-b", "byte access")
BAREBOX_CMD_HELP_OPT ("-w", "word access (16 bit)")
BAREBOX_CMD_HELP_OPT ("-l", "long access (32 bit)")
BAREBOX_CMD_HELP_OPT ("-d FILE", "write file (default /dev/mem)")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(mw)
.cmd = do_mem_mw,
.usage = "memory write (fill)",
BAREBOX_CMD_DESC("memory write")
BAREBOX_CMD_OPTS("[-bwld] REGION DATA...")
BAREBOX_CMD_GROUP(CMD_GRP_MEM)
BAREBOX_CMD_HELP(cmd_mw_help)
BAREBOX_CMD_END

15
commands/nand.c
View File

@ -100,16 +100,17 @@ static int do_nand(int argc, char *argv[])
return 0;
}
static const __maybe_unused char cmd_nand_help[] =
"Usage: nand [OPTION]...\n"
"nand related commands\n"
" -a <dev> register a bad block aware device ontop of a normal nand device\n"
" -d <dev> deregister a bad block aware device\n"
" -b <ofs> <dev> mark block at offset ofs as bad\n";
BAREBOX_CMD_HELP_START(nand)
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-a", "register a bad block aware device ontop of a normal NAND device")
BAREBOX_CMD_HELP_OPT ("-d", "deregister a bad block aware device")
BAREBOX_CMD_HELP_OPT ("-b OFFS", "mark block at OFFSet as bad")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(nand)
.cmd = do_nand,
.usage = "NAND specific handling",
BAREBOX_CMD_DESC("NAND flash handling")
BAREBOX_CMD_OPTS("[-adb] NANDDEV")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_nand_help)
BAREBOX_CMD_END

21
commands/nandtest.c
View File

@ -336,19 +336,20 @@ err:
return 1;
}
/* String for usage of nandtest */
static const __maybe_unused char cmd_nandtest_help[] =
"Usage: nandtest [OPTION] <device>\n"
" -t, Really do a nandtest on device.\n"
" -m, Mark blocks bad if they appear so.\n"
" -s <seed>, Supply random seed.\n"
" -i <iterations>, Number of iterations.\n"
" -o <offset>, Start offset on flash.\n"
" -l <length>, Length of flash to test.\n";
BAREBOX_CMD_HELP_START(nandtest)
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-t", "Really do a nandtest on device")
BAREBOX_CMD_HELP_OPT ("-m", "Mark blocks bad if they appear so")
BAREBOX_CMD_HELP_OPT ("-s SEED", "supply random seed")
BAREBOX_CMD_HELP_OPT ("-i ITERATIONS", "nNumber of iterations")
BAREBOX_CMD_HELP_OPT ("-o OFFS", "start offset on flash")
BAREBOX_CMD_HELP_OPT ("-l LEN", "length of flash to test")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(nandtest)
.cmd = do_nandtest,
.usage = "NAND Test",
BAREBOX_CMD_DESC("NAND flash memory test")
BAREBOX_CMD_OPTS("[-tmsiol] NANDDEVICE")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_nandtest_help)
BAREBOX_CMD_END

7
commands/net.c
View File

@ -57,14 +57,11 @@ static int do_ethact(int argc, char *argv[])
return 0;
}
static const __maybe_unused char cmd_ethact_help[] =
"Usage: ethact [ethx]\n";
BAREBOX_CMD_START(ethact)
.cmd = do_ethact,
.usage = "set current ethernet device",
BAREBOX_CMD_DESC("get or set current ethernet device")
BAREBOX_CMD_OPTS("[ETHX]")
BAREBOX_CMD_GROUP(CMD_GRP_NET)
BAREBOX_CMD_HELP(cmd_ethact_help)
BAREBOX_CMD_COMPLETE(eth_complete)
BAREBOX_CMD_END

9
commands/of_node.c
View File

@ -94,14 +94,15 @@ static int do_of_node(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(of_node)
BAREBOX_CMD_HELP_USAGE("of_node [OPTIONS] [NODE] [NAME]\n")
BAREBOX_CMD_HELP_OPT ("-c", "create a new node\n")
BAREBOX_CMD_HELP_OPT ("-d", "delete a node\n")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-c", "create a new node")
BAREBOX_CMD_HELP_OPT ("-d", "delete a node")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(of_node)
.cmd = do_of_node,
.usage = "handle of nodes",
BAREBOX_CMD_DESC("create/delete nodes in the device tree")
BAREBOX_CMD_OPTS("[-cd] NODE NAME")
BAREBOX_CMD_GROUP(CMD_GRP_MISC)
BAREBOX_CMD_HELP(cmd_of_node_help)
BAREBOX_CMD_END

20
commands/of_property.c
View File

@ -301,19 +301,21 @@ static int do_of_property(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(of_property)
BAREBOX_CMD_HELP_USAGE("of_property [OPTIONS] [NODE] [PROPERTY] [VALUES]\n")
BAREBOX_CMD_HELP_OPT ("-s", "set property to value\n")
BAREBOX_CMD_HELP_OPT ("-d", "delete property\n")
BAREBOX_CMD_HELP_TEXT ("\nvalid formats for values:\n")
BAREBOX_CMD_HELP_TEXT ("<0x00112233 4 05> - an array of cells. cells not beginning with a digit are\n")
BAREBOX_CMD_HELP_TEXT (" interpreted as node pathes and converted to phandles\n")
BAREBOX_CMD_HELP_TEXT ("[00 11 22 .. nn] - byte stream\n")
BAREBOX_CMD_HELP_TEXT ("If the value does not start with '<' or '[' it is interpreted as strings\n")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-s", "set property to value")
BAREBOX_CMD_HELP_OPT ("-d", "delete property")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Valid formats for values:")
BAREBOX_CMD_HELP_TEXT("<0x00112233 4 05> - an array of cells. cells not beginning with a digit are")
BAREBOX_CMD_HELP_TEXT(" interpreted as node pathes and converted to phandles")
BAREBOX_CMD_HELP_TEXT("[00 11 22 .. nn] - byte stream")
BAREBOX_CMD_HELP_TEXT("If the value does not start with '<' or '[' it is interpreted as string")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(of_property)
.cmd = do_of_property,
.usage = "handle of properties",
BAREBOX_CMD_DESC("handle device tree properties")
BAREBOX_CMD_OPTS("[-sd] NODE [PROPERTY] [VALUES]")
BAREBOX_CMD_GROUP(CMD_GRP_MISC)
BAREBOX_CMD_HELP(cmd_of_property_help)
BAREBOX_CMD_END

15
commands/oftree.c
View File

@ -193,17 +193,18 @@ out:
}
BAREBOX_CMD_HELP_START(oftree)
BAREBOX_CMD_HELP_USAGE("oftree [OPTIONS] [DTB]\n")
BAREBOX_CMD_HELP_OPT ("-l", "Load [DTB] to internal devicetree\n")
BAREBOX_CMD_HELP_OPT ("-p", "probe devices from stored devicetree\n")
BAREBOX_CMD_HELP_OPT ("-d", "dump oftree from [DTB] or the parsed tree if no dtb is given\n")
BAREBOX_CMD_HELP_OPT ("-f", "free stored devicetree\n")
BAREBOX_CMD_HELP_OPT ("-n <node>", "specify root devicenode to dump for -d\n")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-l", "Load DTB to internal device tree")
BAREBOX_CMD_HELP_OPT ("-p", "probe devices from stored device tree")
BAREBOX_CMD_HELP_OPT ("-f", "free stored device tree")
BAREBOX_CMD_HELP_OPT ("-d", "dump device tree from DTB or the parsed tree if no DTB is given")
BAREBOX_CMD_HELP_OPT ("-n NODE", "specify root device NODE to dump for -d")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(oftree)
.cmd = do_oftree,
.usage = "handle devicetrees",
BAREBOX_CMD_DESC("handle device trees")
BAREBOX_CMD_OPTS("[-lpfdn] [DTB]")
BAREBOX_CMD_GROUP(CMD_GRP_MISC)
BAREBOX_CMD_HELP(cmd_oftree_help)
BAREBOX_CMD_END

25
commands/partition.c
View File

@ -165,11 +165,17 @@ static int do_addpart(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(addpart)
BAREBOX_CMD_HELP_USAGE("addpart <device> <part_desc>\n")
BAREBOX_CMD_HELP_SHORT("Add a partition description to a device.\n")
BAREBOX_CMD_HELP_OPT ("-n", "no prefix. Do not prepend the device name as prefix before the partition name\n")
BAREBOX_CMD_HELP_OPT ("<device>", "device being worked on\n")
BAREBOX_CMD_HELP_OPT ("<part_desc>", "size1[@offset1](name1)[ro],size2[@offset2](name2)[ro],...\n")
BAREBOX_CMD_HELP_TEXT("The size and the offset can be given in decimal (without any prefix) and")
BAREBOX_CMD_HELP_TEXT("in hex (prefixed with 0x). Both can have an optional suffix K, M or G.")
BAREBOX_CMD_HELP_TEXT("The size of the last partition can be specified as '-' for the remaining")
BAREBOX_CMD_HELP_TEXT("space on the device. This format is the same as used by the Linux")
BAREBOX_CMD_HELP_TEXT("kernel or cmdline mtd partitions.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-n", "do not use the device name as prefix of the partition name")
BAREBOX_CMD_HELP_OPT ("DEVICE", "device being worked on")
BAREBOX_CMD_HELP_OPT ("PART", "SIZE1[@OFFSET1](NAME1)[RO],SIZE2[@OFFSET2](NAME2)[RO],...")
BAREBOX_CMD_HELP_END
/**
@ -186,7 +192,8 @@ kernel or cmdline mtd partitions.
BAREBOX_CMD_START(addpart)
.cmd = do_addpart,
.usage = "adds a partition table to a device",
BAREBOX_CMD_DESC("add a partition description to a device")
BAREBOX_CMD_OPTS("[-n] DEVICE PART")
BAREBOX_CMD_GROUP(CMD_GRP_PART)
BAREBOX_CMD_HELP(cmd_addpart_help)
BAREBOX_CMD_END
@ -207,8 +214,7 @@ static int do_delpart(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(delpart)
BAREBOX_CMD_HELP_USAGE("delpart <part 1> [<part n>] \n")
BAREBOX_CMD_HELP_SHORT("Delete partitions previously added to a device with addpart.\n")
BAREBOX_CMD_HELP_TEXT("Delete partitions previously added to a device with addpart.")
BAREBOX_CMD_HELP_END
/**
@ -224,7 +230,8 @@ argument list is taken as a list of partitions to be deleted.
BAREBOX_CMD_START(delpart)
.cmd = do_delpart,
.usage = "delete partition(s)",
BAREBOX_CMD_DESC("delete partition(s)")
BAREBOX_CMD_OPTS("PART...")
BAREBOX_CMD_GROUP(CMD_GRP_PART)
BAREBOX_CMD_HELP(cmd_delpart_help)
BAREBOX_CMD_COMPLETE(devfs_partition_complete)

15
commands/passwd.c
View File

@ -83,16 +83,17 @@ disable:
return ret;
}
static const __maybe_unused char cmd_passwd_help[] =
"Usage: passwd\n"
"passwd allow you to specify a password in the env\n"
"to disable it put an empty password will still use the default password if set\n"
;
BAREBOX_CMD_HELP_START(passwd)
BAREBOX_CMD_HELP_TEXT("'Interactively asks for a password. The digest of this password will be")
BAREBOX_CMD_HELP_TEXT("stored in " PASSWD_DIR "/passwd. This is then used by the 'login' command.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Entering an empty string will disable the password function.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(passwd)
.cmd = do_passwd,
.usage = "passwd",
BAREBOX_CMD_GROUP(CMD_GRP_MISC)
BAREBOX_CMD_DESC("set password")
BAREBOX_CMD_GROUP(CMD_GRP_CONSOLE)
BAREBOX_CMD_HELP(cmd_passwd_help)
BAREBOX_CMD_COMPLETE(empty_complete)
BAREBOX_CMD_END

2
commands/poweroff.c
View File

@ -33,6 +33,6 @@ static int cmd_poweroff(int argc, char *argv[])
BAREBOX_CMD_START(poweroff)
.cmd = cmd_poweroff,
.usage = "Perform POWER OFF of the board",
BAREBOX_CMD_DESC("turn the power off")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_END

8
commands/printenv.c
View File

@ -57,8 +57,9 @@ static int do_printenv(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(printenv)
BAREBOX_CMD_HELP_USAGE("printenv [variable]\n")
BAREBOX_CMD_HELP_SHORT("Print value of one or all environment variables.\n")
BAREBOX_CMD_HELP_TEXT("If an argument is given, printenv prints the content of an environment")
BAREBOX_CMD_HELP_TEXT("variable to the terminal. If no argument is specified, all variables are")
BAREBOX_CMD_HELP_TEXT("printed.")
BAREBOX_CMD_HELP_END
/**
@ -72,7 +73,8 @@ printed.</p>
BAREBOX_CMD_START(printenv)
.cmd = do_printenv,
.usage = "Print value of one or all environment variables.",
BAREBOX_CMD_DESC("print value of environment variables")
BAREBOX_CMD_OPTS("[VARIABLE]")
BAREBOX_CMD_GROUP(CMD_GRP_ENV)
BAREBOX_CMD_HELP(cmd_printenv_help)
BAREBOX_CMD_END

2
commands/pwd.c
View File

@ -29,7 +29,7 @@ static int do_pwd(int argc, char *argv[])
BAREBOX_CMD_START(pwd)
.cmd = do_pwd,
.usage = "print working directory",
BAREBOX_CMD_DESC("print working directory")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_COMPLETE(empty_complete)
BAREBOX_CMD_END

10
commands/readf.c
View File

@ -50,15 +50,15 @@ out:
}
BAREBOX_CMD_HELP_START(readf)
BAREBOX_CMD_HELP_USAGE("readf <file> <variable>\n")
BAREBOX_CMD_HELP_SHORT("Read a single line of a file into a shell variable. Leading and trailing whitespaces\n")
BAREBOX_CMD_HELP_SHORT("are removed, nonvisible characters are stripped. Input is limited to 1024\n")
BAREBOX_CMD_HELP_SHORT("characters.\n")
BAREBOX_CMD_HELP_TEXT("Read a single line from FILE into a VARiable. Leading and trailing")
BAREBOX_CMD_HELP_TEXT("whitespaces are removed, nonvisible characters are stripped. Input is")
BAREBOX_CMD_HELP_TEXT("limited to 1024 characters.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(readf)
.cmd = do_readf,
.usage = "read file into variable",
BAREBOX_CMD_DESC("read file into variable")
BAREBOX_CMD_OPTS("FILE VAR")
BAREBOX_CMD_GROUP(CMD_GRP_SCRIPT)
BAREBOX_CMD_HELP(cmd_readf_help)
BAREBOX_CMD_END

12
commands/readline.c
View File

@ -41,14 +41,16 @@ static int do_readline(int argc, char *argv[])
return 0;
}
static const __maybe_unused char cmd_readline_help[] =
"Usage: readline <prompt> VAR\n"
"readline reads a line of user input into variable VAR.\n";
BAREBOX_CMD_HELP_START(readline)
BAREBOX_CMD_HELP_TEXT("First it displays the PROMPT, then it reads a line of user input into")
BAREBOX_CMD_HELP_TEXT("variable VAR.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(readline)
.cmd = do_readline,
.usage = "prompt for user input",
BAREBOX_CMD_GROUP(CMD_GRP_SCRIPT)
BAREBOX_CMD_DESC("prompt for user input")
BAREBOX_CMD_OPTS("PROMPT VAR")
BAREBOX_CMD_GROUP(CMD_GRP_CONSOLE)
BAREBOX_CMD_HELP(cmd_readline_help)
BAREBOX_CMD_END

10
commands/readlink.c
View File

@ -68,14 +68,16 @@ err:
}
BAREBOX_CMD_HELP_START(readlink)
BAREBOX_CMD_HELP_USAGE("readlink [-f] FILE REALNAME\n")
BAREBOX_CMD_HELP_SHORT("read value of a symbolic link and store into $REALNAME\n")
BAREBOX_CMD_HELP_SHORT("-f canonicalize by following first symlink");
BAREBOX_CMD_HELP_TEXT("Read value of a symbolic link and store it into VARIABLE.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-f", "canonicalize by following first symlink");
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(readlink)
.cmd = do_readlink,
.usage = "read value of a symbolic link",
BAREBOX_CMD_DESC("read value of a symbolic link")
BAREBOX_CMD_OPTS("[-f] FILE VARIABLE")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_readlink_help)
BAREBOX_CMD_END

2
commands/reginfo.c
View File

@ -29,7 +29,7 @@ static int do_reginfo(int argc, char *argv[])
BAREBOX_CMD_START(reginfo)
.cmd = do_reginfo,
.usage = "print register information",
BAREBOX_CMD_DESC("print register information")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_COMPLETE(empty_complete)
BAREBOX_CMD_END

2
commands/regulator.c
View File

@ -29,6 +29,6 @@ static int do_regulator(int argc, char *argv[])
BAREBOX_CMD_START(regulator)
.cmd = do_regulator,
.usage = "list regulators",
BAREBOX_CMD_DESC("list regulators")
BAREBOX_CMD_GROUP(CMD_GRP_INFO)
BAREBOX_CMD_END

10
commands/reset.c
View File

@ -46,15 +46,15 @@ static int cmd_reset(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(reset)
BAREBOX_CMD_HELP_USAGE("reset [-f]\n")
BAREBOX_CMD_HELP_SHORT("Perform RESET of the CPU.\n")
BAREBOX_CMD_HELP_OPT("-f", "force RESET, don't call shutdown\n")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT("-f", "force RESET, don't call shutdown")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(reset)
.cmd = cmd_reset,
.usage = "Perform RESET of the CPU",
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_DESC("perform RESET of the CPU")
BAREBOX_CMD_OPTS("[-f]")
BAREBOX_CMD_GROUP(CMD_GRP_BOOT)
BAREBOX_CMD_HELP(cmd_reset_help)
BAREBOX_CMD_COMPLETE(empty_complete)
BAREBOX_CMD_END

11
commands/rm.c
View File

@ -58,14 +58,15 @@ static int do_rm(int argc, char *argv[])
return 0;
}
static const __maybe_unused char cmd_rm_help[] =
"Usage: rm [OPTIONS] [FILES]\n"
"Remove files\n"
"-r remove directories and their contents recursively\n";
BAREBOX_CMD_HELP_START(rm)
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-r", "remove directories and their contents recursively")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(rm)
.cmd = do_rm,
.usage = "remove files",
BAREBOX_CMD_DESC("remove files")
BAREBOX_CMD_OPTS("[-r] FILES...")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_rm_help)
BAREBOX_CMD_END

10
commands/rmdir.c
View File

@ -21,13 +21,15 @@ static int do_rmdir(int argc, char *argv[])
return 0;
}
static const __maybe_unused char cmd_rmdir_help[] =
"Usage: rmdir [directories]\n"
"Remove directories. The directories have to be empty.\n";
BAREBOX_CMD_HELP_START(rmdir)
BAREBOX_CMD_HELP_TEXT("Remove directories. The directories have to be empty.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(rmdir)
.cmd = do_rmdir,
.usage = "remove directorie(s)",
BAREBOX_CMD_DESC("remove empty directory(s)")
BAREBOX_CMD_OPTS("DIRECTORY...")
BAREBOX_CMD_GROUP(CMD_GRP_FILE)
BAREBOX_CMD_HELP(cmd_rmdir_help)
BAREBOX_CMD_END

12
commands/saveenv.c
View File

@ -48,13 +48,19 @@ static int do_saveenv(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(saveenv)
BAREBOX_CMD_HELP_USAGE("saveenv [envfs] [directory]\n")
BAREBOX_CMD_HELP_SHORT("Save the files in <directory> to the persistent storage device <envfs>.\n")
BAREBOX_CMD_HELP_TEXT("Save the files in DIRECTORY to the persistent storage device ENVFS.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("ENVFS is usually a block in flash but can be any other file. If")
BAREBOX_CMD_HELP_TEXT("omitted, DIRECTORY defaults to /env and ENVFS defaults to")
BAREBOX_CMD_HELP_TEXT("/dev/env0. Note that envfs can only handle files, directories are being")
BAREBOX_CMD_HELP_TEXT("skipped silently.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(saveenv)
.cmd = do_saveenv,
.usage = "save environment to persistent storage",
BAREBOX_CMD_DESC("save environment to persistent storage")
BAREBOX_CMD_OPTS("[ENVFS] [DIRECTORY]")
BAREBOX_CMD_GROUP(CMD_GRP_ENV)
BAREBOX_CMD_HELP(cmd_saveenv_help)
BAREBOX_CMD_END

9
commands/setenv.c
View File

@ -36,8 +36,8 @@ static int do_setenv(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(setenv)
BAREBOX_CMD_HELP_USAGE("setenv <name> [<value>]\n")
BAREBOX_CMD_HELP_SHORT("Set environment variable to a value or delete if value is avoided.\n")
BAREBOX_CMD_HELP_TEXT("Set environment variable NAME to VALUE.")
BAREBOX_CMD_HELP_TEXT("If VALUE is ommitted, then the variable is deleted.")
BAREBOX_CMD_HELP_END
/**
@ -46,13 +46,12 @@ BAREBOX_CMD_HELP_END
<p> This command is only available if the simple command line parser is
in use. Within the hush shell, \c setenv is not required.</p>
\todo Check if kconfig does this correctly.
*/
BAREBOX_CMD_START(setenv)
.cmd = do_setenv,
.usage = "set environment variables",
BAREBOX_CMD_DESC("set environment variable")
BAREBOX_CMD_OPTS("NAME [VALUE]")
BAREBOX_CMD_GROUP(CMD_GRP_ENV)
BAREBOX_CMD_HELP(cmd_setenv_help)
BAREBOX_CMD_END

3
commands/sleep.c
View File

@ -43,7 +43,8 @@ static int do_sleep(int argc, char *argv[])
BAREBOX_CMD_START(sleep)
.cmd = do_sleep,
.usage = "delay execution for n seconds",
BAREBOX_CMD_DESC("delay execution for n seconds")
BAREBOX_CMD_OPTS("SECONDS")
BAREBOX_CMD_GROUP(CMD_GRP_SCRIPT)
BAREBOX_CMD_COMPLETE(command_var_complete)
BAREBOX_CMD_END

24
commands/spi.c
View File

@ -114,20 +114,22 @@ out:
return ret;
}
static const __maybe_unused char cmd_spi_help[] =
"Usage: spi [OPTION] [data to write 0xXX]\n"
"write/read spi device.\n"
" -b <bus_num> spi bus number (default = 0)\n"
" -r <count> to read\n"
" -c <cs> chip select (default = 0)\n"
" -m <mode> spi mode (default = 0)\n"
" -f <hz> max_speed_hz (default = 1MHz)\n"
" -w <bit> bits_per_word (default = 8)\n"
" -v verbose\n";
BAREBOX_CMD_HELP_START(spi)
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-b BUS\t", "SPI bus number (default 0)")
BAREBOX_CMD_HELP_OPT ("-r COUNT", "bytes to read")
BAREBOX_CMD_HELP_OPT ("-c\t", "chip select (default 0)")
BAREBOX_CMD_HELP_OPT ("-m MODE\t", "SPI mode (default 0)")
BAREBOX_CMD_HELP_OPT ("-f HZ\t", "max speed frequency, in Hz (default 1 MHz)")
BAREBOX_CMD_HELP_OPT ("-w BIT\t", "bits per word (default 8)")
BAREBOX_CMD_HELP_OPT ("-v\t", "verbose")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(spi)
.cmd = do_spi,
.usage = "write/read spi device",
BAREBOX_CMD_DESC("write/read from SPI device")
BAREBOX_CMD_OPTS("[-brcmfwv] DATA...")
BAREBOX_CMD_GROUP(CMD_GRP_HWMANIP)
BAREBOX_CMD_HELP(cmd_spi_help)
BAREBOX_CMD_END

19
commands/splash.c
View File

@ -78,13 +78,15 @@ static int do_splash(int argc, char *argv[])
}
BAREBOX_CMD_HELP_START(splash)
BAREBOX_CMD_HELP_USAGE("splash [OPTIONS] FILE\n")
BAREBOX_CMD_HELP_SHORT("Show the bitmap FILE on the framebuffer.\n")
BAREBOX_CMD_HELP_OPT ("-f <fb>", "framebuffer device (/dev/fb0)\n")
BAREBOX_CMD_HELP_OPT ("-x <xofs>", "x offset (default center)\n")
BAREBOX_CMD_HELP_OPT ("-y <yofs>", "y offset (default center)\n")
BAREBOX_CMD_HELP_OPT ("-b <color>", "background color in 0xttrrggbb\n")
BAREBOX_CMD_HELP_OPT ("-o", "render offscreen\n")
BAREBOX_CMD_HELP_TEXT("This command displays a graphics in the bitmap (.bmp) format on the")
BAREBOX_CMD_HELP_TEXT("framebuffer. Currently images with 8 and 24 bit color depth are supported.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-f FB\t", "framebuffer device (default /dev/fb0)")
BAREBOX_CMD_HELP_OPT ("-x XOFFS", "x offset (default center)")
BAREBOX_CMD_HELP_OPT ("-y YOFFS", "y offset (default center)")
BAREBOX_CMD_HELP_OPT ("-b COLOR", "background color in 0xttrrggbb")
BAREBOX_CMD_HELP_OPT ("-o\t", "render offscreen")
BAREBOX_CMD_HELP_END
/**
@ -100,7 +102,8 @@ color depth.
BAREBOX_CMD_START(splash)
.cmd = do_splash,
.usage = "show a bmp image",
BAREBOX_CMD_DESC("display a BMP image")
BAREBOX_CMD_OPTS("[-fxyno] FILE")
BAREBOX_CMD_GROUP(CMD_GRP_CONSOLE)
BAREBOX_CMD_HELP(cmd_splash_help)
BAREBOX_CMD_END

14
commands/test.c
View File

@ -226,17 +226,17 @@ out:
static const char *test_aliases[] = { "[", NULL};
static const __maybe_unused char cmd_test_help[] =
"Usage: test [OPTIONS]\n"
"options: !, =, !=, -eq, -ne, -ge, -gt, -le, -lt, -o, -a, -z, -n, -d, -e, -f, -L\n"
"see 'man test' on your PC for more information.\n";
static const __maybe_unused char cmd_test_usage[] = "minimal test like /bin/sh";
BAREBOX_CMD_HELP_START(test)
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_TEXT("\t!, =, !=, -eq, -ne, -ge, -gt, -le, -lt, -o, -a, -z, -n, -d, -e,")
BAREBOX_CMD_HELP_TEXT("\t-f, -L; see 'man test' on your PC for more information.")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(test)
.aliases = test_aliases,
.cmd = do_test,
.usage = cmd_test_usage,
BAREBOX_CMD_DESC("minimal test command like in /bin/sh")
BAREBOX_CMD_OPTS("[EXPR]")
BAREBOX_CMD_GROUP(CMD_GRP_SCRIPT)
BAREBOX_CMD_HELP(cmd_test_help)
BAREBOX_CMD_END

9
commands/tftp.c
View File

@ -92,13 +92,16 @@ err_free:
}
BAREBOX_CMD_HELP_START(tftp)
BAREBOX_CMD_HELP_USAGE("tftp [-p] <source> [dest]\n")
BAREBOX_CMD_HELP_SHORT("Load a file from or upload to TFTP server.\n")
BAREBOX_CMD_HELP_TEXT("Load (or save) a file via TFTP.")
BAREBOX_CMD_HELP_TEXT("")
BAREBOX_CMD_HELP_TEXT("Options:")
BAREBOX_CMD_HELP_OPT ("-p", "push to TFTP server")
BAREBOX_CMD_HELP_END
BAREBOX_CMD_START(tftp)
.cmd = do_tftpb,
.usage = "(up-)Load file using tftp protocol",
BAREBOX_CMD_DESC("load (or save) a file using TFTP")
BAREBOX_CMD_OPTS("[-p] SOURCE [DEST]")
BAREBOX_CMD_GROUP(CMD_GRP_NET)
BAREBOX_CMD_HELP(cmd_tftp_help)
BAREBOX_CMD_END

Some files were not shown because too many files have changed in this diff Show More