#include <common.h>
#include <bootstage.h>
+#include <env.h>
#include <image.h>
#include <irq_func.h>
#include <lmb.h>
__builtin_arc_brk();
}
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
printf("Resetting the board...\n");
#include <common.h>
#include <clock_legacy.h>
+#include <command.h>
#include <div64.h>
#include <init.h>
#include <net.h>
}
#endif
-int do_mx35_showclocks(cmd_tbl_t *cmdtp,
- int flag, int argc, char * const argv[])
+int do_mx35_showclocks(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 cpufreq = get_mcu_main_clk();
printf("mx35 cpu clock: %dMHz\n", cpufreq / 1000000);
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <hang.h>
#include <init.h>
}
#endif
-int do_mx28_showclocks(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_mx28_showclocks(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
printf("CPU: %3d MHz\n", mxc_get_clock(MXC_ARM_CLK) / 1000000);
printf("BUS: %3d MHz\n", mxc_get_clock(MXC_AHB_CLK) / 1000000);
*/
#include <common.h>
+#include <command.h>
#include <init.h>
#include <asm/io.h>
#include <asm/arch/hardware.h>
#endif
#if !defined(CONFIG_SPL_BUILD) && defined(CONFIG_NAND_ECC_BCH) && defined(CONFIG_NAND_FSMC)
-static int do_switch_ecc(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_switch_ecc(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
if (argc != 2)
}
#endif
-int do_chip_config(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_chip_config(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
void (*sram_setfreq) (unsigned int, unsigned int);
unsigned int frequency;
#include <common.h>
#include <clock_legacy.h>
+#include <command.h>
#include <cpu_func.h>
#include <init.h>
#include <net.h>
}
/* Dump some core clocks */
-int do_vf610_showclocks(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+int do_vf610_showclocks(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
printf("\n");
printf("cpu clock : %8d MHz\n", mxc_get_clock(MXC_ARM_CLK) / 1000000);
*/
#include <common.h>
+#include <env.h>
#include <asm/io.h>
#include <linux/errno.h>
#include <asm/arch/fsl_serdes.h>
return 0;
}
-int cpu_release(u32 nr, int argc, char * const argv[])
+int cpu_release(u32 nr, int argc, char *const argv[])
{
u64 boot_addr;
u64 *table = (u64 *)get_spin_tbl_addr();
#define MXC_CLK32 32768
#endif
-struct cmd_tbl_s;
+struct cmd_tbl;
enum mxc_clock {
MXC_ARM_CLK = 0,
void mxs_set_lcdclk(u32 base_addr, u32 freq);
void select_ldb_di_clock_source(enum ldb_di_clock clk);
void enable_eim_clk(unsigned char enable);
-int do_mx6_showclocks(struct cmd_tbl_s *cmdtp, int flag, int argc,
+int do_mx6_showclocks(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[]);
#endif /* __ASM_ARCH_CLOCK_H */
* DIFFERENCE: Instead of calling prep and go at the end
* they are called if subcommand is equal 0.
*/
-int do_bootm_linux(int flag, int argc, char * const argv[],
+int do_bootm_linux(int flag, int argc, char *const argv[],
bootm_headers_t *images)
{
/* No need for those on ARM */
* instructions, otherwise a fault occurs."
*/
unsigned long do_go_exec(ulong (*entry)(int, char * const []),
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
ulong addr = (ulong)entry | 1;
entry = (void *)addr;
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <irq_func.h>
{
}
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
puts ("resetting ...\n");
- udelay (50000); /* wait 50 ms */
+ mdelay(50); /* wait 50 ms */
disable_interrupts();
*/
#include <common.h>
#include <command.h>
+#include <env.h>
#define SYSOPEN 0x01
#define SYSCLOSE 0x02
return 0;
}
-static int do_smhload(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_smhload(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc == 3 || argc == 4) {
ulong load_addr;
return size;
}
-static int do_boot_mode(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_boot_mode(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const struct boot_mode *p;
int reset_requested = 1;
int size;
char *dest;
- cmd_tbl_t *entry = ll_entry_get(cmd_tbl_t, bmode, cmd);
+ struct cmd_tbl *entry = ll_entry_get(struct cmd_tbl, bmode, cmd);
if (entry->usage) {
free(entry->usage);
* Returns zero on success, CMD_RET_USAGE in case of misuse and negative
* on error.
*/
-static int do_dek_blob(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_dek_blob(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
uint32_t src_addr, dst_addr, len;
uint8_t *src_ptr, *dst_ptr;
* Copyright (C) 2012 Boundary Devices Inc.
*/
#include <common.h>
+#include <command.h>
#include <asm/arch/imx-regs.h>
#include <asm/arch/mxc_hdmi.h>
#include <asm/io.h>
-static int do_hdmidet(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_hdmidet(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct hdmi_regs *hdmi = (struct hdmi_regs *)HDMI_ARB_BASE_ADDR;
return (readb(&hdmi->phy_stat0) & HDMI_DVI_STAT) ? 0 : 1;
*/
#include <common.h>
+#include <command.h>
#include <malloc.h>
#include <nand.h>
#include <dm/devres.h>
return ret;
}
-static int do_nandbcb_bcbonly(int argc, char * const argv[])
+static int do_nandbcb_bcbonly(int argc, char *const argv[])
{
struct fcb_block *fcb;
struct dbbt_block *dbbt;
return ret == 0 ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
}
-static int do_nandbcb(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_nandbcb(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *cmd;
int ret = 0;
*/
#include <common.h>
+#include <command.h>
#include <config.h>
#include <fuse.h>
#include <mapmem.h>
return 0;
}
-static int do_hab_status(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_hab_status(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if ((argc != 1)) {
cmd_usage(cmdtp);
}
}
-static int do_authenticate_image(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_authenticate_image(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr, length, ivt_offset;
int rcode = 0;
return rcode;
}
-static int do_hab_failsafe(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_hab_failsafe(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
hab_rvt_failsafe_t *hab_rvt_failsafe;
return 0;
}
-static int do_hab_version(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_hab_version(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct hab_hdr *hdr = (struct hab_hdr *)HAB_RVT_BASE;
return 0;
}
-static int do_authenticate_image_or_failover(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_authenticate_image_or_failover(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
int ret = CMD_RET_FAILURE;
*/
#include <common.h>
+#include <command.h>
#include <errno.h>
#include <asm/io.h>
#include <asm/arch/sci/sci.h>
return ret;
}
-static int do_authenticate(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_authenticate(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr;
}
}
-static int do_ahab_status(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_ahab_status(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int err;
u8 idx = 0U;
return 0;
}
-static int do_ahab_close(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_ahab_close(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int err;
u16 lc;
"ALL values should be in hexadecimal format";
#define NB_REGISTERS 18
-static int do_snvs_cfg(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_snvs_cfg(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int err = 0;
u32 idx = 0;
"\n"
"ALL values should be in hexadecimal format";
-static int do_snvs_dgo_cfg(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_snvs_dgo_cfg(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int err = 0;
"\n"
"ALL values should be in hexadecimal format";
-static int do_tamper_pin_cfg(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_tamper_pin_cfg(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int err = 0;
"Write the status registers with the value provided,"
" clearing the status";
-static int do_snvs_clear_status(cmd_tbl_t *cmdtp, int flag, int argc,
- char *const argv[])
+static int do_snvs_clear_status(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int scierr = 0;
u32 idx = 0;
"snvs_sec_status\n"
"Display information about the security related to tamper and secvio";
-static int do_snvs_sec_status(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_snvs_sec_status(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int scierr;
*/
#include <common.h>
+#include <command.h>
#include <asm/arch/clock.h>
#include <asm/arch/imx-regs.h>
#include <asm/io.h>
* Dump some clockes.
*/
#ifndef CONFIG_SPL_BUILD
-static int do_imx8m_showclocks(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_imx8m_showclocks(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 freq;
* The TCMUL is mapped to (M4_BOOTROM_BASE_ADDR) at A core side for
* accessing the M4 TCMUL.
*/
-static int do_bootaux(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_bootaux(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr;
int ret, up;
*/
#include <common.h>
+#include <command.h>
#include <asm/io.h>
#include <linux/errno.h>
#include <asm/arch/imx-regs.h>
/*
* Dump some core clockes.
*/
-static int do_mx5_showclocks(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mx5_showclocks(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 freq;
*/
#include <common.h>
+#include <command.h>
#include <div64.h>
#include <asm/io.h>
#include <linux/errno.h>
/*
* Dump some core clockes.
*/
-int do_mx6_showclocks(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_mx6_showclocks(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 freq;
freq = decode_pll(PLL_SYS, MXC_HCLK);
#include <common.h>
#include <clock_legacy.h>
+#include <command.h>
#include <div64.h>
#include <asm/io.h>
#include <linux/errno.h>
/*
* Dump some core clockes.
*/
-int do_mx7_showclocks(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_mx7_showclocks(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 freq;
freq = decode_pll(PLL_CORE, MXC_HCLK);
#include <common.h>
#include <clock_legacy.h>
+#include <command.h>
#include <div64.h>
#include <asm/io.h>
#include <errno.h>
/*
* Dump some core clockes.
*/
-int do_mx7_showclocks(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_mx7_showclocks(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 addr = 0;
u32 freq;
.pll_od = 2,
};
-int do_pll_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_pll_cmd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
if (argc != 5)
goto pll_cmd_usage;
PLLSET_CMD_LIST " <mult> <div> <OD>\n"
);
-int do_getclk_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_getclk_cmd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned int clk;
unsigned long freq;
CLOCK_INDEXES_LIST
);
-int do_psc_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_psc_cmd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int psc_module;
int res;
#include <mach/mon.h>
asm(".arch_extension sec\n\t");
-static int do_mon_install(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_mon_install(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 addr, dpsc_base = 0x1E80000, freq, load_addr, size;
int rcode = 0;
}
}
-int do_mon_power(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+int do_mon_power(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int rcode = 0, core_id, on;
void (*fn)(void);
#include <asm/arch/psc_defs.h>
#include <asm/arch/hardware.h>
-int do_poweroff(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_poweroff(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
mon_power_off(0);
*/
#include <cpu_func.h>
+#include <env.h>
#include <asm/io.h>
#include <common.h>
#include <asm/arch/msmc.h>
*/
#include <common.h>
+#include <env.h>
#include <init.h>
#include <asm/io.h>
#include <asm/arch/psc_defs.h>
*/
#include <common.h>
+#include <command.h>
+#include <env.h>
#include <asm/arch/sm.h>
#include <asm/cache.h>
#include <linux/err.h>
return FIELD_GET(REBOOT_REASON_MASK, reason);
}
-static int do_sm_serial(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_sm_serial(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
ulong address;
[REBOOT_REASON_WATCHDOG_REBOOT] = "watchdog_reboot",
};
-static int do_sm_reboot_reason(cmd_tbl_t *cmdtp, int flag, int argc,
- char *const argv[])
+static int do_sm_reboot_reason(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *reason_str;
char *destarg = NULL;
return CMD_RET_SUCCESS;
}
-static cmd_tbl_t cmd_sm_sub[] = {
+static struct cmd_tbl cmd_sm_sub[] = {
U_BOOT_CMD_MKENT(serial, 2, 1, do_sm_serial, "", ""),
U_BOOT_CMD_MKENT(reboot_reason, 1, 1, do_sm_reboot_reason, "", ""),
};
-static int do_sm(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_sm(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
if (argc < 2)
return CMD_RET_USAGE;
*
*/
#include <common.h>
+#include <command.h>
#include <dm.h>
#include <init.h>
#include <spl.h>
/******************************************************************************
* OMAP3 specific command to switch between NAND HW and SW ecc
*****************************************************************************/
-static int do_switch_ecc(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_switch_ecc(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int hw, strength = 1;
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <hang.h>
#include <init.h>
#include <common.h>
#include <adc.h>
+#include <command.h>
+#include <env.h>
#include <asm/io.h>
#include <asm/arch-rockchip/boot_mode.h>
#include <dm/device.h>
*/
#include <common.h>
+#include <env.h>
#include <init.h>
#include <asm/io.h>
#include <asm/arch-rockchip/clock.h>
* Copyright (c) 2016 Rockchip Electronics Co., Ltd
*/
#include <common.h>
+#include <command.h>
#include <dm.h>
#include <env.h>
#include <clk.h>
return rk3288_board_late_init();
}
-static int do_clock(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_clock(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
static const struct {
char *name;
*/
#include <common.h>
+#include <command.h>
#include <init.h>
#include <wait_bit.h>
#include <asm/io.h>
}
#ifndef CONFIG_SPL_BUILD
-static int do_showclocks(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_showclocks(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
cm_print_clock_quick_summary();
return 0;
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <hang.h>
#include <asm/cache.h>
}
#ifndef CONFIG_SPL_BUILD
-static int do_bridge(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_bridge(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned int mask = ~0;
return 0;
}
-static int do_stm32key(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_stm32key(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 addr;
const char *op = argc >= 2 ? argv[1] : NULL;
#endif
}
-static int do_stm32prog(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_stm32prog(struct cmd_tbl *cmdtp, int flag, int argc,
char * const argv[])
{
ulong addr, size;
* Copyright (C) 2020, STMicroelectronics - All Rights Reserved
*/
-#include <common.h>
+#include <command.h>
#include <console.h>
#include <dfu.h>
#include <malloc.h>
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <irq_func.h>
#include <asm/arch/tegra.h>
#include <asm/arch-tegra/pmc.h>
-static int do_enterrcm(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_enterrcm(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
puts("Entering RCM...\n");
udelay(50000);
*/
#include <common.h>
+#include <command.h>
#include <spl.h>
#include <stdio.h>
#include <linux/io.h>
#ifndef CONFIG_SPL_BUILD
-static int do_pinmon(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_pinmon(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const struct uniphier_boot_device_info *info;
u32 pinmon;
*/
#include <common.h>
+#include <command.h>
#include <stdio.h>
#include <linux/io.h>
#include <linux/printk.h>
}
}
-static int do_ddrm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_ddrm(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const struct uniphier_ddrmphy_param *param;
char *cmd;
*/
#include <common.h>
+#include <command.h>
#include <stdio.h>
#include <linux/io.h>
#include <linux/printk.h>
}
}
-static int do_ddr(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_ddr(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const struct uniphier_ddrphy_param *param;
char *cmd;
*/
#include <common.h>
+#include <command.h>
#include <env.h>
#include <mmc.h>
#include <linux/errno.h>
return find_first_mmc_device(false);
}
-static int do_mmcsetn(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mmcsetn(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int dev;
""
);
-static int do_sdsetn(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_sdsetn(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int dev;
}
}
-int cpu_release(u32 nr, int argc, char * const argv[])
+int cpu_release(u32 nr, int argc, char *const argv[])
{
if (nr >= ZYNQMP_CORE_APU0 && nr <= ZYNQMP_CORE_APU3) {
u64 boot_addr = simple_strtoull(argv[0], NULL, 16);
DECLARE_GLOBAL_DATA_PTR;
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
rcm_t *rcm = (rcm_t *) (MMAP_RCM);
udelay(1000);
DECLARE_GLOBAL_DATA_PTR;
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ccm_t *ccm = (ccm_t *) MMAP_CCM;
DECLARE_GLOBAL_DATA_PTR;
#ifdef CONFIG_M5208
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
rcm_t *rcm = (rcm_t *)(MMAP_RCM);
}
#endif /* CONFIG_DISPLAY_CPUINFO */
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
/* Call the board specific reset actions first. */
if(board_reset) {
#endif
#ifdef CONFIG_M5272
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
wdog_t *wdp = (wdog_t *) (MMAP_WDOG);
#endif /* #ifdef CONFIG_M5272 */
#ifdef CONFIG_M5275
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
rcm_t *rcm = (rcm_t *)(MMAP_RCM);
}
#endif /* CONFIG_DISPLAY_CPUINFO */
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
MCFRESET_RCR = MCFRESET_RCR_SOFTRST;
return 0;
}
#endif /* CONFIG_DISPLAY_CPUINFO */
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
/* enable watchdog, set timeout to 0 and wait */
mbar_writeByte(MCFSIM_SYPCR, 0xc0);
}
#endif /* CONFIG_DISPLAY_CPUINFO */
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
/* enable watchdog, set timeout to 0 and wait */
mbar_writeByte(SIM_SYPCR, 0xc0);
*/
#include <common.h>
+#include <command.h>
#include <init.h>
#include <vsprintf.h>
#include <asm/immap.h>
#include <asm/io.h>
#ifdef CONFIG_M5307
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
sim_t *sim = (sim_t *)(MMAP_SIM);
DECLARE_GLOBAL_DATA_PTR;
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
rcm_t *rcm = (rcm_t *) (MMAP_RCM);
DECLARE_GLOBAL_DATA_PTR;
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
rcm_t *rcm = (rcm_t *) (MMAP_RCM);
udelay(1000);
DECLARE_GLOBAL_DATA_PTR;
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
gptmr_t *gptmr = (gptmr_t *) (MMAP_GPTMR);
lmb_reserve(lmb, sp, (CONFIG_SYS_SDRAM_BASE + gd->ram_size - sp));
}
-int do_bootm_linux(int flag, int argc, char * const argv[], bootm_headers_t *images)
+int do_bootm_linux(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
int ret;
bd_t *kbd;
}
#if defined(CONFIG_CMD_IRQ)
-int do_irqinfo(cmd_tbl_t *cmdtp, int flag, int argc, const char *argv[])
+int do_irqinfo(struct cmd_tbl *cmdtp, int flag, int argc, const char *argv[])
{
int i;
struct irq_action *act = vecs;
*/
#include <common.h>
+#include <command.h>
#include <image.h>
#include <spl.h>
#include <asm/io.h>
return 1;
}
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
__asm__ __volatile__ ("mts rmsr, r0;" \
"bra r0");
}
}
-int do_bootm_linux(int flag, int argc, char * const argv[],
+int do_bootm_linux(int flag, int argc, char *const argv[],
bootm_headers_t *images)
{
images->cmdline_start = (ulong)env_get("bootargs");
/* NOP */;
}
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
_machine_restart();
linux_extra);
}
-int do_bootm_linux(int flag, int argc, char * const argv[],
- bootm_headers_t *images)
+int do_bootm_linux(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
/* No need for those on MIPS */
if (flag & BOOTM_STATE_OS_BD_T)
#include <common.h>
#include <clock_legacy.h>
+#include <command.h>
#include <hang.h>
#include <asm/io.h>
#include <asm/addrspace.h>
return gd->mem_clk;
}
-int do_ar934x_showclk(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ar934x_showclk(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ar934x_update_clock();
printf("CPU: %8ld MHz\n", gd->cpu_clk / 1000000);
return 0;
}
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
disable_interrupts();
panic("AE3XX wdt not support yet.\n");
return 0;
}
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
disable_interrupts();
#include <command.h>
unsigned long do_go_exec(ulong (*entry)(int, char * const []),
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
cleanup_before_linux();
*/
#include <common.h>
+#include <command.h>
#include <cpu.h>
#include <cpu_func.h>
#include <dm.h>
}
#endif
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
disable_interrupts();
/* indirect call to go beyond 256MB limitation of toolchain */
/*************************************************************************/
#if defined(CONFIG_CMD_IRQ)
-int do_irqinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_irqinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int i;
struct irq_action *act = vecs;
#include <common.h>
#include <cpu_func.h>
+#include <env.h>
#include <image.h>
#include <irq_func.h>
#define NIOS_MAGIC 0x534f494e /* enable command line and initrd passing */
-int do_bootm_linux(int flag, int argc, char * const argv[], bootm_headers_t *images)
+int do_bootm_linux(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
void (*kernel)(int, int, int, char *) = (void *)images->ep;
char *commandline = env_get("bootargs");
#endif
#ifndef CONFIG_SYSRESET
-int
-do_reset (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ulong msr;
#ifndef MPC83xx_RESET
ddr->capture_attributes & ECC_CAPT_ATTR_VLD);
}
-int do_ecc(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_ecc(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
#ifdef CONFIG_SYS_FSL_DDR2
* irqinfo - print information about PCI devices
*/
-void
-do_irqinfo(cmd_tbl_t *cmdtp, bd_t *bd, int flag, int argc, char * const argv[])
+void do_irqinfo(struct cmd_tbl *cmdtp, bd_t *bd, int flag, int argc,
+ char *const argv[])
{
}
return get_bus_freq(0);
}
-static int do_clocks(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_clocks(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char buf[32];
}
#endif
-static int do_errata(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_errata(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
#ifdef CONFIG_SYS_FSL_ERRATUM_NMG_CPU_A011
extern int enable_cpu_a011_workaround;
/* ------------------------------------------------------------------------- */
-int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
/* Everything after the first generation of PQ3 parts has RSTCR */
#if defined(CONFIG_ARCH_MPC8540) || defined(CONFIG_ARCH_MPC8541) || \
#if defined(CONFIG_CMD_IRQ)
/* irqinfo - print information about PCI devices,not implemented. */
-int do_irqinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_irqinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
return 0;
}
BOOT_ENTRY_R3_LOWER,
};
-int cpu_release(u32 nr, int argc, char * const argv[])
+int cpu_release(u32 nr, int argc, char *const argv[])
{
u32 i, val, *table = (u32 *)&__spin_table + nr * NUM_BOOT_ENTRY;
u64 boot_addr;
}
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
volatile immap_t *immap = (immap_t *)CONFIG_SYS_IMMR;
volatile ccsr_gur_t *gur = &immap->im_gur;
/*
* irqinfo - print information about PCI devices,not implemented.
*/
-int do_irqinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_irqinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
return 0;
}
return 0;
}
-int cpu_release(u32 nr, int argc, char * const argv[])
+int cpu_release(u32 nr, int argc, char *const argv[])
{
/* dummy function so common/cmd_mp.c will build
* should be implemented in the future */
/* ------------------------------------------------------------------------- */
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ulong msr, addr;
DECLARE_GLOBAL_DATA_PTR;
-static int do_siuinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_siuinfo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
sysconf8xx_t __iomem *sc = &immap->im_siu_conf;
return 0;
}
-static int do_memcinfo(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_memcinfo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
memctl8xx_t __iomem *memctl = &immap->im_memctl;
return 0;
}
-static int do_carinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_carinfo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
car8xx_t __iomem *car = &immap->im_clkrst;
#define PC_NBITS 12
#define PD_NBITS 13
-static int do_iopinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_iopinfo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
iop8xx_t __iomem *iop = &immap->im_ioport;
* this needs a clean up for smaller tighter code
* use *uint and set the address based on cmd + port
*/
-static int do_iopset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_iopset(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
uint rcode = 0;
iopin_t iopin;
putc('\n');
}
-static int do_brginfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_brginfo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
immap_t __iomem *immap = (immap_t __iomem *)CONFIG_SYS_IMMR;
cpm8xx_t __iomem *cp = &immap->im_cpm;
return 0;
}
-noinline
-int do_bootm_linux(int flag, int argc, char * const argv[], bootm_headers_t *images)
+noinline int do_bootm_linux(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
int ret;
the debugger. */
void
-kgdb_breakpoint(int argc, char * const argv[])
+kgdb_breakpoint(int argc, char *const argv[])
{
asm(" .globl breakinst\n\
breakinst: .long 0x7d821008\n\
#include <command.h>
unsigned long do_go_exec(ulong (*entry)(int, char * const []),
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
cleanup_before_linux();
}
}
-int do_bootm_linux(int flag, int argc, char * const argv[],
+int do_bootm_linux(int flag, int argc, char *const argv[],
bootm_headers_t *images)
{
/* No need for those on RISC-V */
return 0;
}
-int do_bootm_vxworks(int flag, int argc, char * const argv[],
+int do_bootm_vxworks(int flag, int argc, char *const argv[],
bootm_headers_t *images)
{
return do_bootm_linux(flag, argc, argv, images);
#include <command.h>
#include <hang.h>
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
printf("resetting ...\n");
return 0;
}
-int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
disable_interrupts();
reset_cpu(0);
#include <common.h>
#include <command.h>
+#include <env.h>
#include <image.h>
#include <asm/byteorder.h>
#include <asm/zimage.h>
return val;
}
-int do_bootm_linux(int flag, int argc, char * const argv[], bootm_headers_t *images)
+int do_bootm_linux(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
/* Linux kernel load address */
void (*kernel) (void) = (void (*)(void))images->ep;
*/
#include <common.h>
+#include <command.h>
+#include <env.h>
#include <irq_func.h>
#include <asm/io.h>
#include <asm/zimage.h>
-int do_sh_zimageboot (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_sh_zimageboot(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong (*zboot_entry)(int, char * const []) = NULL;
char *s0, *s1;
#ifndef __FSP_VPD_H__
#define __FSP_VPD_H__
+#include <stddef.h>
+
struct __packed memory_upd {
u64 signature; /* Offset 0x0020 */
u8 revision; /* Offset 0x0028 */
images->os.arch == IH_ARCH_X86_64);
}
-int do_bootm_linux(int flag, int argc, char * const argv[],
- bootm_headers_t *images)
+int do_bootm_linux(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
/* No need for those on x86 */
if (flag & BOOTM_STATE_OS_BD_T || flag & BOOTM_STATE_OS_CMDLINE)
DECLARE_GLOBAL_DATA_PTR;
unsigned long do_go_exec(ulong (*entry)(int, char * const []),
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
unsigned long ret = 0;
char **argv_tmp;
#endif
#if defined(CONFIG_CMD_IRQ)
-int do_irqinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_irqinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
#if !CONFIG_IS_ENABLED(X86_64)
int irq;
*/
#include <common.h>
+#include <command.h>
#include <env.h>
#include <irq_func.h>
#include <malloc.h>
{
}
-int do_zboot(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_zboot(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct boot_params *base_ptr;
void *bzImage_addr = NULL;
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <div64.h>
#include <env.h>
do_get_arc_info();
}
-static int do_arc_cmd(cmd_tbl_t * cmdtp, int flag, int argc, char *const argv[])
+static int do_arc_cmd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *cmd;
int ret = -1;
/*---------------------------------------------------------------------------*/
#ifdef CONFIG_VIDEO
-int do_brightness(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_brightness(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int rcode = 0;
ulong side;
#if defined(CONFIG_KIRKWOOD_GPIO)
/* Return GPIO push button status */
static int
-do_read_push_button(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+do_read_push_button(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return !kw_gpio_get_value(NET2BIG_V2_GPIO_PUSH_BUTTON);
}
#if defined(CONFIG_KIRKWOOD_GPIO)
/* Return GPIO button status */
static int
-do_read_button(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+do_read_button(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
return kw_gpio_get_value(NETSPACE_V2_GPIO_BUTTON);
}
*/
#include <common.h>
+#include <command.h>
#include <div64.h>
#include <env.h>
#include <net.h>
#define SYNO_CHKSUM_TAG "CHK="
-static int do_syno_populate(int argc, char * const argv[])
+static int do_syno_populate(int argc, char *const argv[])
{
unsigned int bus = CONFIG_SF_DEFAULT_BUS;
unsigned int cs = CONFIG_SF_DEFAULT_CS;
NULL,
};
-static int do_syno_clk_gate(int argc, char * const argv[])
+static int do_syno_clk_gate(int argc, char *const argv[])
{
u32 pwr_mng_ctrl_reg = reg_read(POWER_MNG_CTRL_REG);
const char *func, *state;
return 0;
}
-static int do_syno(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_syno(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *cmd;
int ret = 0;
#include <common.h>
#include <cpu_func.h>
+#include <env.h>
#include <errno.h>
#include <init.h>
#include <linux/libfdt.h>
#include <common.h>
#include <dm.h>
+#include <env.h>
#include <env_internal.h>
#include <init.h>
#include <net.h>
#include <common.h>
#include <dm.h>
+#include <env.h>
#include <env_internal.h>
#include <init.h>
#include <net.h>
* Author: Fabio Estevam <fabio.estevam@freescale.com>
*/
+#include <command.h>
#include <image.h>
#include <init.h>
#include <asm/arch/clock.h>
#include <common.h>
#include <cpsw.h>
#include <dm.h>
+#include <env.h>
#include <env_internal.h>
#include <errno.h>
#include <i2c.h>
*/
#include <common.h>
+#include <command.h>
#include <env.h>
#include <init.h>
#include <net.h>
return numpressed;
}
-static int do_kbd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_kbd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char envvalue[ARRAY_SIZE(buttons)+1];
int numpressed = read_keys(envvalue);
#include <common.h>
#include <bootstage.h>
+#include <command.h>
#include <env.h>
#include <env_internal.h>
#include <flash.h>
**/
#include <common.h>
+#include <command.h>
#include <asm/cache.h>
#include <asm/io.h>
}
}
-int do_atf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_atf(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ssize_t ret;
size_t size, offset;
* Andreas Bießmann <andreas.biessmann@corscience.de>
*/
#include <common.h>
+#include <command.h>
#include <eeprom.h>
#include <i2c.h>
#include <u-boot/crc.h>
return ret;
}
-int do_tricorder_eeprom(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
+int do_tricorder_eeprom(struct cmd_tbl *cmdtp, int flag, int argc, char *argv[])
{
if (argc == 3) {
ulong dev_addr = simple_strtoul(argv[2], NULL, 16);
* http://www.ethernut.de/
*/
#include <common.h>
+#include <command.h>
#include <asm/arch/at91sam9260.h>
#include <asm/arch/at91_common.h>
#include <asm/arch/gpio.h>
/*
* Process the board specific 'pwrman' command.
*/
-int do_pwrman(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_pwrman(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
u8 val;
int i;
*/
#include <common.h>
+#include <command.h>
#include <console.h>
#include <ioports.h>
#include <mpc83xx.h>
caddy_interface->answer_in = ptr;
}
-int do_caddy(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_caddy(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned long base_addr;
uint32_t ptr;
#endif
#ifndef CONFIG_SPL_BUILD
-int cpld_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int cpld_cmd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int rc = 0;
unsigned char value;
#include <env.h>
#include <fsl_validate.h>
-int do_esbc_halt(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+int do_esbc_halt(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (fsl_check_boot_mode_secure() == 0) {
printf("Boot Mode is Non-Secure. Not entering spin loop.\n");
}
#ifndef CONFIG_SPL_BUILD
-static int do_esbc_validate(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_esbc_validate(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *hash_str = NULL;
uintptr_t haddr;
PIXIS_WRITE(sclk[2], sclk2);
}
-int pixis_reset_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int pixis_reset_cmd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned int i;
unsigned long sysclk;
/* Disable the watchdog
*
*/
-static int pixis_disable_watchdog_cmd(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int pixis_disable_watchdog_cmd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
/* Disable the VELA sequencer and the watchdog */
clrbits_8(pixis_base + PIXIS_VCTL, 9);
/* Enable or disable SGMII mode for a TSEC
*/
-static int pixis_set_sgmii(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int pixis_set_sgmii(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int which_tsec = -1;
unsigned char mask;
return intval + decval;
}
-static int pixis_reset_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int pixis_reset_cmd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned int i;
char *p_cf = NULL;
puts("Reverse engineering switch is not implemented for this board\n");
}
-static int qixis_reset_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int qixis_reset_cmd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int i;
update_crc();
}
-int do_mac(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_mac(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char cmd;
}
-static int do_vdd_override(cmd_tbl_t *cmdtp,
+static int do_vdd_override(struct cmd_tbl *cmdtp,
int flag, int argc,
- char * const argv[])
+ char *const argv[])
{
ulong override;
return 0;
}
-static int do_vdd_read(cmd_tbl_t *cmdtp,
- int flag, int argc,
- char * const argv[])
+static int do_vdd_read(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc < 1)
return CMD_RET_USAGE;
*/
#include <common.h>
+#include <env.h>
#include <init.h>
#include <miiphy.h>
#include <netdev.h>
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <hang.h>
#include <image.h>
*/
#include <common.h>
+#include <env.h>
#include <init.h>
DECLARE_GLOBAL_DATA_PTR;
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <hang.h>
#include <image.h>
*/
#include <common.h>
+#include <env.h>
#include <errno.h>
#include <init.h>
#include <asm/mach-imx/iomux-v3.h>
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <hang.h>
#include <image.h>
#include <common.h>
#include <dm.h>
+#include <init.h>
#include <ram.h>
#include <spl.h>
#include <asm/io.h>
*/
#include <common.h>
+#include <command.h>
#include <fdt_support.h>
#include <hang.h>
#include <i2c.h>
return ret;
}
-static int flash_bank_cmd(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int flash_bank_cmd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc != 2)
return CMD_RET_USAGE;
#include <common.h>
#include <clock_legacy.h>
+#include <command.h>
#include <fdt_support.h>
#include <i2c.h>
#include <init.h>
cpld_data->system_rst = CONFIG_RESET;
}
-static int flash_bank_cmd(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int flash_bank_cmd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc != 2)
return CMD_RET_USAGE;
"bank[0-upper bank/1-lower bank] (e.g. boot_bank 0)"
);
-static int cpld_reset_cmd(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int cpld_reset_cmd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct cpld_data *cpld_data = (void *)(CONFIG_SYS_CPLD_BASE);
printf("B.\n");
}
-static int serdes_mux_cmd(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int serdes_mux_cmd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc != 2)
return CMD_RET_USAGE;
*value = rev_val;
}
-int do_cpld(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_cpld(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int rc = 0;
*value = rev_val;
}
-int do_cpld(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_cpld(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int rc = 0;
*/
#include <common.h>
+#include <command.h>
#include <image.h>
#include <init.h>
#include <net.h>
}
#ifndef CONFIG_SPL_BUILD
-static int pin_mux_cmd(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int pin_mux_cmd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc < 2)
return CMD_RET_USAGE;
}
#endif
-int cpld_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int cpld_cmd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int rc = 0;
putc('\n');
}
-int do_cpld(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_cpld(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int rc = 0;
return 0;
}
-static int switch_cmd(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int switch_cmd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc < 2)
return CMD_RET_USAGE;
}
#endif
-int do_cpld(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_cpld(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int rc = 0;
CPLD_WRITE(reset_ctl, CPLD_LBMAP_RESET);
}
-int do_cpld(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_cpld(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int rc = 0;
}
}
-static int do_vdd_adjust(cmd_tbl_t *cmdtp,
+static int do_vdd_adjust(struct cmd_tbl *cmdtp,
int flag, int argc,
- char * const argv[])
+ char *const argv[])
{
ulong override;
#endif
#ifndef CONFIG_SPL_BUILD
-int do_cpld(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_cpld(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int rc = 0;
*/
#include <common.h>
+#include <command.h>
#include <env.h>
#include <env_internal.h>
#include <flash.h>
* Helper function to provide some sane factory-data values for testing
* purpose, when these values are not programmed correctly
*/
-int do_fd_write(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_fd_write(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct factory_data_values *fd;
struct spi_flash *sf;
*/
#include <common.h>
+#include <command.h>
#include <errno.h>
#include <hexdump.h>
#include <i2c.h>
static u8 econfig_bytes[sizeof(ventana_info.config)];
static int econfig_init = -1;
-static int do_econfig(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_econfig(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct ventana_eeprom_config *cfg;
struct ventana_board_info *info = &ventana_info;
* Author: Tim Harvey <tharvey@gateworks.com>
*/
+#include <command.h>
#include <linux/errno.h>
#include <common.h>
#include <i2c.h>
}
#if defined(CONFIG_CMD_GSC) && !defined(CONFIG_SPL_BUILD)
-static int do_gsc_sleep(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_gsc_sleep(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned char reg;
unsigned long secs = 0;
return CMD_RET_FAILURE;
}
-static int do_gsc_wd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_gsc_wd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned char reg;
return CMD_RET_SUCCESS;
}
-static int do_gsc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_gsc(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
if (argc < 2)
return gsc_info(1);
*/
#include <common.h>
+#include <command.h>
#include <dm.h>
#include <init.h>
#include <miiphy.h>
#include <common.h>
+#include <command.h>
#include <console.h> /* ctrlc */
#include <asm/io.h>
#define REFL_PATTERN (0xdededede)
#define REFL_PATTERN_INV (~REFL_PATTERN)
-int do_hydrate(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_hydrate(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
uint k = 0;
void __iomem *pcie2_base = (void __iomem *)(MVEBU_REG_PCIE_BASE +
* Syntax:
* ioreflect {fpga} {reportrate}
*/
-int do_ioreflect(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ioreflect(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
uint fpga;
uint rate = 0;
* Syntax:
* ioreflect {reportrate}
*/
-int do_ioreflect(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ioreflect(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct udevice *fpga;
struct regmap *map;
* Syntax:
* ioloop {fpga} {size} {rate}
*/
-int do_ioloop(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ioloop(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
uint fpga;
uint size;
* Syntax:
* ioloop {size} {rate}
*/
-int do_ioloop(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ioloop(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
uint size;
uint rate = 0;
#endif /* CONFIG_GDSYS_LEGACY_DRIVERS */
#ifndef CONFIG_GDSYS_LEGACY_DRIVERS
-int do_iodev(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_iodev(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct udevice *ioep = NULL;
struct udevice *board;
#ifdef CONFIG_GDSYS_LEGACY_DRIVERS
#include <common.h>
+#include <command.h>
#include <i2c.h>
#include <malloc.h>
return charcount;
}
-static int osd_print(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int osd_print(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned screen;
return 0;
}
-int osd_write(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int osd_write(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned screen;
return 0;
}
-int osd_size(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int osd_size(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned screen;
unsigned x;
") size_y(max. " __stringify(MAX_Y_CHARS) ")\n"
);
-#endif /* CONFIG_GDSYS_LEGACY_DRIVERS */
\ No newline at end of file
+#endif /* CONFIG_GDSYS_LEGACY_DRIVERS */
*/
#include <common.h>
+#include <command.h>
#include <dm.h>
#include <hexdump.h>
#include <video_osd.h>
#include <malloc.h>
-static int do_osd_write(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_osd_write(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
uint x, y;
return CMD_RET_SUCCESS;
}
-static int do_osd_print(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_osd_print(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
uint x, y;
return CMD_RET_SUCCESS;
}
-static int do_osd_size(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_osd_size(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
uint x, y;
#include <common.h>
#include <board.h>
+#include <command.h>
#include <dm.h>
#include <env.h>
#include <fdt_support.h>
}
#ifdef CONFIG_TRAILBLAZER
-int do_bootd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bootd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
return run_command(env_get("bootcmd"), flag);
}
*/
#include <common.h>
+#include <command.h>
int arch_misc_init(void)
{
* read out the board id and the hw key from the intventory EEPROM and set
* this values as environment variables.
*/
-static int do_setboardid(cmd_tbl_t *cmdtp, int flag, int argc,
- char *const argv[])
+static int do_setboardid(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned char buf[32];
char *p;
* application and in the init scripts (?)
* return 0 in case of match, 1 if not match or error
*/
-static int do_checkboardidhwk(cmd_tbl_t *cmdtp, int flag, int argc,
- char *const argv[])
+static int do_checkboardidhwk(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned long ivmbid = 0, ivmhwkey = 0;
unsigned long envbid = 0, envhwkey = 0;
* if the testpin of the board is asserted, return 1
* * else return 0
*/
-static int do_checktestboot(cmd_tbl_t *cmdtp, int flag, int argc,
- char *const argv[])
+static int do_checktestboot(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int testpin = 0;
char *s = NULL;
#include <common.h>
#include <config.h>
+#include <env.h>
#include <init.h>
DECLARE_GLOBAL_DATA_PTR;
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <init.h>
#include <asm/armv8/mmu.h>
*/
#include <common.h>
+#include <command.h>
#include <env.h>
#include <flash.h>
#include <init.h>
}
#ifdef CONFIG_DEPRECATED
-int do_write_mac(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_write_mac(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int i, ret;
char mac_string[256];
*/
#include <common.h>
+#include <command.h>
#include <env.h>
#include <flash.h>
#include <init.h>
}
#ifdef CONFIG_DEPRECATED
-int do_write_mac(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_write_mac(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int i, ret;
char mac_string[256];
*/
#include <common.h>
+#include <command.h>
#include <env.h>
#include <flash.h>
#include <init.h>
return 0;
}
-int do_sh_g200(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_sh_g200(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct gctrl_regs *gctrl = GCTRL_BASE;
unsigned long graofst;
);
#ifdef CONFIG_DEPRECATED
-int do_write_mac(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_write_mac(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int i, ret;
char mac_string[256];
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <asm/io.h>
#include <asm/gpio.h>
#endif
}
-static int do_cpld(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_cpld(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 addr, val;
*/
#include <common.h>
+#include <command.h>
#include <asm/gpio.h>
#include <asm/io.h>
#include <dm.h>
dm_gpio_set_value(&priv->sstbz, 1);
}
-static int do_cpld(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_cpld(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
u32 addr, val;
#include <common.h>
#include <dm.h>
+#include <env.h>
#include <init.h>
#include <asm/io.h>
#include <asm/arch-rockchip/uart.h>
#include <common.h>
#include <cros_ec.h>
+#include <env.h>
#include <errno.h>
#include <fdtdec.h>
#include <hang.h>
char *exit_option;
char *exit_reset = "reset";
char *exit_back = "back";
- cmd_tbl_t *cmd;
+ struct cmd_tbl *cmd;
int cmd_result;
int leave;
*
*/
#include <common.h>
+#include <command.h>
#include <dm.h>
+#include <env.h>
#include <errno.h>
#include <init.h>
#include <netdev.h>
* 0 if button is not held down
*/
static int
-do_userbutton(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+do_userbutton(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int button = 0;
#define ERST IMX_GPIO_NR(0, 3)
static int
-do_eth_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+do_eth_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
gpio_request(ERST, "ERST");
gpio_direction_output(ERST, 0);
*/
#include <common.h>
+#include <command.h>
#include <env.h>
#include <errno.h>
#include <init.h>
* 0 if button is not held down
*/
static int
-do_userbutton(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+do_userbutton(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int button = 0;
button = get_button_state("button_dfu0", BOARD_DFU_BUTTON_GPIO);
#endif
static int
-do_usertestwdt(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+do_usertestwdt(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
printf("\n\n\n Go into infinite loop\n\n\n");
while (1)
} /* loop through defined led in environment */
}
-static int do_board_led(cmd_tbl_t *cmdtp, int flag, int argc,
- char *const argv[])
+static int do_board_led(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc != 2)
return CMD_RET_USAGE;
*/
#include <common.h>
+#include <command.h>
#include <env.h>
#include <errno.h>
#include <init.h>
return n;
}
-static int do_switch_reset(cmd_tbl_t *cmdtp, int flag, int argc,
- char *const argv[])
+static int do_switch_reset(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
/* Reset SMSC LAN9303 switch for default configuration */
gpio_request(GPIO_LAN9303_NRST, "nRST");
return 0;
}
-static int do_upgrade_available(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_upgrade_available(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned long upgrade_available = 0;
unsigned long boot_retry = 0;
#include <common.h>
#include <dm.h>
+#include <env.h>
#include <init.h>
#include <linux/delay.h>
#include <linux/io.h>
*/
#include <common.h>
+#include <command.h>
#include <init.h>
#include <net.h>
#include <asm/arch/clock.h>
*/
#include <common.h>
+#include <env.h>
#include <i2c.h>
#include <init.h>
#include <miiphy.h>
#ifndef CONFIG_SPL_BUILD
#include <common.h>
+#include <command.h>
#include <console.h>
#include <misc.h>
#include <dm/device.h>
otp & 0xF);
}
-static int do_stboard(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_stboard(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret;
u32 otp, lock;
#include <common.h>
#include <dm.h>
+#include <env.h>
#include <init.h>
#include <asm/io.h>
#include <common.h>
#include <dm.h>
+#include <env.h>
#include <init.h>
#include <asm/io.h>
#include <common.h>
#include <dm.h>
+#include <env.h>
#include <init.h>
#include <asm/io.h>
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <dwmmc.h>
#include <init.h>
; /* loop forever till reset */
}
-static int do_emsdp_rom(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_emsdp_rom(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 creg_boot = readl(CREG_BOOT);
return CMD_RET_SUCCESS;
}
-cmd_tbl_t cmd_emsdp[] = {
+struct cmd_tbl cmd_emsdp[] = {
U_BOOT_CMD_MKENT(rom, 2, 0, do_emsdp_rom, "", ""),
};
-static int do_emsdp(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_emsdp(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
c = find_cmd_tbl(argv[1], cmd_emsdp, ARRAY_SIZE(cmd_emsdp));
*/
#include <common.h>
+#include <command.h>
#include <config.h>
#include <cpu_func.h>
#include <env.h>
return hsdk_go_run(reg);
}
-static int do_hsdk_go(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_hsdk_go(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret;
writel(~INIT_MARKER_PENDING, INIT_MARKER_REGISTER);
}
-static int do_hsdk_init(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_hsdk_init(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret;
"- Init HSDK HW\n"
);
-static int do_hsdk_clock_set(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_hsdk_clock_set(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int ret = 0;
return CMD_RET_SUCCESS;
}
-static int do_hsdk_clock_get(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_hsdk_clock_get(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
ulong rate;
return CMD_RET_SUCCESS;
}
-static int do_hsdk_clock_print(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_hsdk_clock_print(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
/* Main clocks */
return CMD_RET_SUCCESS;
}
-static int do_hsdk_clock_print_all(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_hsdk_clock_print_all(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
/*
return CMD_RET_SUCCESS;
}
-cmd_tbl_t cmd_hsdk_clock[] = {
+struct cmd_tbl cmd_hsdk_clock[] = {
U_BOOT_CMD_MKENT(set, 3, 0, do_hsdk_clock_set, "", ""),
U_BOOT_CMD_MKENT(get, 3, 0, do_hsdk_clock_get, "", ""),
U_BOOT_CMD_MKENT(print, 4, 0, do_hsdk_clock_print, "", ""),
U_BOOT_CMD_MKENT(print_all, 4, 0, do_hsdk_clock_print_all, "", ""),
};
-static int do_hsdk_clock(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_hsdk_clock(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
if (argc < 2)
return CMD_RET_USAGE;
*/
#include <common.h>
#include <cpu_func.h>
+#include <env.h>
#include <init.h>
#include <asm/gpio.h>
#include <asm/io.h>
* Author: Fabio Estevam <festevam@gmail.com>
*/
+#include <env.h>
#include <init.h>
#include <net.h>
#include <asm/arch/clock.h>
*/
#include <common.h>
+#include <command.h>
#include <console.h>
#include <i2c.h>
#include <init.h>
#endif
#if !defined(CONFIG_SPL_BUILD) && defined(CONFIG_PCI)
-int do_pcie_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_pcie_test(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
pci_dev_t bdf;
u16 ven_id, dev_id;
*/
#include <common.h>
+#include <env.h>
#include <fdt_support.h>
#include <image.h>
#include <init.h>
#ifdef CONFIG_CMD_BAT
#include <twl6030.h>
-int do_vbat(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_vbat(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
if (argc == 2) {
if (strncmp(argv[1], "startcharge", 12) == 0)
#include <common.h>
#include <dm.h>
+#include <env.h>
#include <init.h>
#include <asm/arch-tegra/ap.h>
#include <asm/gpio.h>
#include <common.h>
#ifndef CONFIG_SPL_BUILD
+#include <command.h>
#include <console.h>
#include <fuse.h>
return CMD_RET_SUCCESS;
}
-int do_mfgr_fuse(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+int do_mfgr_fuse(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret;
puts("Fusing...\n");
return ret;
}
-int do_updt_fuse(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+int do_updt_fuse(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned val;
int ret;
*/
#include <common.h>
+#include <command.h>
#include <i2c.h>
#include <asm/arch/imx-regs.h>
#include <asm/arch/iomux.h>
return CMD_RET_SUCCESS;
}
-static int do_pf0100_prog(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_pf0100_prog(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret;
puts("Programming PMIC OTP...");
#include <common.h>
#ifndef CONFIG_SPL_BUILD
+#include <command.h>
#include <console.h>
#include <fuse.h>
return CMD_RET_SUCCESS;
}
-int do_mfgr_fuse(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+int do_mfgr_fuse(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret;
puts("Fusing...\n");
return ret;
}
-int do_updt_fuse(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+int do_updt_fuse(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned val;
int ret;
*/
#include <common.h>
+#include <command.h>
#include <i2c.h>
#include <asm/arch/imx-regs.h>
#include <asm/arch/iomux.h>
return CMD_RET_SUCCESS;
}
-static int do_pf0100_prog(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_pf0100_prog(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret;
puts("Programming PMIC OTP...");
#include <common.h>
#include "tdx-cfg-block.h"
+#include <command.h>
#include <asm/cache.h>
#if defined(CONFIG_TARGET_APALIS_IMX6) || \
return 0;
}
-static int do_cfgblock_create(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_cfgblock_create(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u8 *config_block;
struct toradex_tag *tag;
return ret;
}
-static int do_cfgblock(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_cfgblock(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret;
*/
#include <common.h>
+#include <command.h>
#include <image.h>
#include <init.h>
#include <asm/arch/clock.h>
update_crc();
}
-int do_mac(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_mac(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char cmd;
*/
#include <common.h>
+#include <command.h>
#include <asm/arch/sys_proto.h>
#include <asm/arch/cpu.h>
#include <asm/arch/emc.h>
#ifdef CONFIG_CMD_MAX6957
-static int do_max6957aax(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_max6957aax(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int reg, val;
#error CONFIG_CMD_HD44760 requires CONFIG_HUSH_PARSER
#endif
-static int do_hd44780(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_hd44780(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *cmd;
*/
#include <common.h>
+#include <env.h>
#include <asm/sections.h>
#include <dm/uclass.h>
#include <i2c.h>
#include <common.h>
#include <config.h>
+#include <env.h>
#include <init.h>
#include <dm/lists.h>
#include <fdtdec.h>
#include <common.h>
#include <cpu_func.h>
+#include <env.h>
#include <fdtdec.h>
#include <init.h>
#include <malloc.h>
*/
#include <common.h>
+#include <command.h>
#include <asm/io.h>
#include <asm/arch/hardware.h>
#include <asm/arch/sys_proto.h>
return 0;
}
-static int do_zynq_rsa(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_zynq_rsa(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 src_ptr;
char *endp;
#endif
#ifdef CONFIG_CMD_ZYNQ_AES
-static int zynq_decrypt_image(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int zynq_decrypt_image(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *endp;
u32 srcaddr, srclen, dstaddr, dstlen;
}
#endif
-static cmd_tbl_t zynq_commands[] = {
+static struct cmd_tbl zynq_commands[] = {
#ifdef CONFIG_CMD_ZYNQ_RSA
U_BOOT_CMD_MKENT(rsa, 3, 1, do_zynq_rsa, "", ""),
#endif
#endif
};
-static int do_zynq(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_zynq(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *zynq_cmd;
+ struct cmd_tbl *zynq_cmd;
int ret;
if (!ARRAY_SIZE(zynq_commands)) {
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <env.h>
#include <malloc.h>
#include <asm/arch/sys_proto.h>
#include <asm/io.h>
-static int do_zynqmp_verify_secure(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_zynqmp_verify_secure(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u64 src_addr, addr;
u32 len, src_lo, src_hi;
return ret;
}
-static int do_zynqmp_mmio_read(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_zynqmp_mmio_read(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 read_val, addr;
int ret;
return ret;
}
-static int do_zynqmp_mmio_write(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_zynqmp_mmio_write(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 addr, mask, val;
int ret;
}
#ifdef CONFIG_DEFINE_TCM_OCM_MMAP
-static int do_zynqmp_tcm_init(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_zynqmp_tcm_init(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u8 mode;
}
#endif
-static cmd_tbl_t cmd_zynqmp_sub[] = {
+static struct cmd_tbl cmd_zynqmp_sub[] = {
U_BOOT_CMD_MKENT(secure, 5, 0, do_zynqmp_verify_secure, "", ""),
U_BOOT_CMD_MKENT(mmio_read, 3, 0, do_zynqmp_mmio_read, "", ""),
U_BOOT_CMD_MKENT(mmio_write, 5, 0, do_zynqmp_mmio_write, "", ""),
*
* Return: return 0 on success and CMD_RET_USAGE incase of misuse and error
*/
-static int do_zynqmp(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_zynqmp(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
if (argc < 2)
return CMD_RET_USAGE;
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <debug_uart.h>
#include <env.h>
}
unsigned long do_go_exec(ulong (*entry)(int, char * const []), int argc,
- char * const argv[])
+ char *const argv[])
{
int ret = 0;
#include <common.h>
#include <android_ab.h>
#include <command.h>
+#include <env.h>
#include <part.h>
-static int do_ab_select(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_ab_select(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret;
struct blk_desc *dev_desc;
#include <android_image.h>
#include <common.h>
+#include <command.h>
#include <image.h>
#include <mapmem.h>
/* Please use abootimg_addr() macro to obtain the boot image address */
static ulong _abootimg_addr = -1;
-static int abootimg_get_ver(int argc, char * const argv[])
+static int abootimg_get_ver(int argc, char *const argv[])
{
const struct andr_img_hdr *hdr;
int res = CMD_RET_SUCCESS;
return res;
}
-static int abootimg_get_recovery_dtbo(int argc, char * const argv[])
+static int abootimg_get_recovery_dtbo(int argc, char *const argv[])
{
ulong addr;
u32 size;
return CMD_RET_SUCCESS;
}
-static int abootimg_get_dtb_load_addr(int argc, char * const argv[])
+static int abootimg_get_dtb_load_addr(int argc, char *const argv[])
{
const struct andr_img_hdr *hdr;
int res = CMD_RET_SUCCESS;
return res;
}
-static int abootimg_get_dtb_by_index(int argc, char * const argv[])
+static int abootimg_get_dtb_by_index(int argc, char *const argv[])
{
const char *index_str;
u32 num;
return CMD_RET_SUCCESS;
}
-static int abootimg_get_dtb(int argc, char * const argv[])
+static int abootimg_get_dtb(int argc, char *const argv[])
{
if (argc < 1)
return CMD_RET_USAGE;
return CMD_RET_USAGE;
}
-static int do_abootimg_addr(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_abootimg_addr(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *endp;
ulong img_addr;
return CMD_RET_SUCCESS;
}
-static int do_abootimg_get(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_abootimg_get(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *param;
return CMD_RET_USAGE;
}
-static int do_abootimg_dump(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_abootimg_dump(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc != 2)
return CMD_RET_USAGE;
return CMD_RET_SUCCESS;
}
-static cmd_tbl_t cmd_abootimg_sub[] = {
+static struct cmd_tbl cmd_abootimg_sub[] = {
U_BOOT_CMD_MKENT(addr, 2, 1, do_abootimg_addr, "", ""),
U_BOOT_CMD_MKENT(dump, 2, 1, do_abootimg_dump, "", ""),
U_BOOT_CMD_MKENT(get, 5, 1, do_abootimg_get, "", ""),
};
-static int do_abootimg(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_abootimg(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
cp = find_cmd_tbl(argv[1], cmd_abootimg_sub,
ARRAY_SIZE(cmd_abootimg_sub));
return 0;
}
-static int do_acpi_list(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_acpi_list(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct acpi_rsdp *rsdp;
return 0;
}
-static int do_acpi_dump(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_acpi_dump(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const char *name;
#include <dm.h>
#include <adc.h>
-static int do_adc_list(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_adc_list(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct udevice *dev;
return CMD_RET_SUCCESS;
}
-static int do_adc_info(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_adc_info(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct udevice *dev;
return CMD_RET_SUCCESS;
}
-static int do_adc_single(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_adc_single(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct udevice *dev;
return CMD_RET_SUCCESS;
}
-static int do_adc_scan(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_adc_scan(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct adc_channel ch[ADC_MAX_CHANNEL];
* Eugeniu Rosca <rosca.eugeniu@gmail.com>
*/
+#include <command.h>
#include <env.h>
#include <image-android-dt.h>
#include <common.h>
*/
static ulong working_img;
-static int do_adtimg_addr(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_adtimg_addr(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *endp;
ulong hdr_addr;
return CMD_RET_SUCCESS;
}
-static int do_adtimg_dump(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_adtimg_dump(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc != 1)
return CMD_RET_USAGE;
return CMD_RET_SUCCESS;
}
-static int adtimg_getopt_index(int argc, char * const argv[], u32 *index,
+static int adtimg_getopt_index(int argc, char *const argv[], u32 *index,
char **avar, char **svar)
{
int ret;
return CMD_RET_SUCCESS;
}
-static int adtimg_get_dt_by_index(int argc, char * const argv[])
+static int adtimg_get_dt_by_index(int argc, char *const argv[])
{
ulong addr;
u32 index, size;
return CMD_RET_SUCCESS;
}
-static int adtimg_get_dt(int argc, char * const argv[])
+static int adtimg_get_dt(int argc, char *const argv[])
{
if (argc < 2) {
printf("Error: No options passed to '%s'\n", argv[0]);
return CMD_RET_FAILURE;
}
-static int do_adtimg_get(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_adtimg_get(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc < 2) {
printf("Error: No arguments passed to '%s'\n", argv[0]);
return CMD_RET_FAILURE;
}
-static cmd_tbl_t cmd_adtimg_sub[] = {
+static struct cmd_tbl cmd_adtimg_sub[] = {
U_BOOT_CMD_MKENT(addr, CONFIG_SYS_MAXARGS, 1, do_adtimg_addr, "", ""),
U_BOOT_CMD_MKENT(dump, CONFIG_SYS_MAXARGS, 1, do_adtimg_dump, "", ""),
U_BOOT_CMD_MKENT(get, CONFIG_SYS_MAXARGS, 1, do_adtimg_get, "", ""),
};
-static int do_adtimg(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_adtimg(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
cp = find_cmd_tbl(argv[1], cmd_adtimg_sub, ARRAY_SIZE(cmd_adtimg_sub));
* Returns zero on success, CMD_RET_USAGE in case of misuse and negative
* on error.
*/
-static int do_aes(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_aes(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
uint32_t key_addr, iv_addr, src_addr, dst_addr, len;
uint8_t *key_ptr, *iv_ptr, *src_ptr, *dst_ptr;
#include <common.h>
#include <command.h>
-static int do_unaligned(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_unaligned(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
/*
* The LDRD instruction requires the data source to be four byte aligned
return CMD_RET_FAILURE;
}
-static int do_breakpoint(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_breakpoint(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
asm volatile ("BKPT #123\n");
return CMD_RET_FAILURE;
}
-static int do_undefined(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_undefined(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
/*
* 0xe7f...f. is undefined in ARM mode
return CMD_RET_FAILURE;
}
-static cmd_tbl_t cmd_sub[] = {
+static struct cmd_tbl cmd_sub[] = {
U_BOOT_CMD_MKENT(breakpoint, CONFIG_SYS_MAXARGS, 1, do_breakpoint,
"", ""),
U_BOOT_CMD_MKENT(unaligned, CONFIG_SYS_MAXARGS, 1, do_unaligned,
#include <common.h>
#include <command.h>
-static int do_undefined(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_undefined(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
/*
* 0xe7f...f. is undefined in ARM mode
return CMD_RET_FAILURE;
}
-static cmd_tbl_t cmd_sub[] = {
+static struct cmd_tbl cmd_sub[] = {
U_BOOT_CMD_MKENT(undefined, CONFIG_SYS_MAXARGS, 1, do_undefined,
"", ""),
};
return CMD_RET_FAILURE;
}
-static int do_afs(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_afs(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int ret = CMD_RET_SUCCESS;
#define AVB_BOOTARGS "avb_bootargs"
static struct AvbOps *avb_ops;
-int do_avb_init(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_avb_init(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned long mmc_dev;
return CMD_RET_FAILURE;
}
-int do_avb_read_part(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_avb_read_part(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *part;
s64 offset;
return CMD_RET_FAILURE;
}
-int do_avb_read_part_hex(cmd_tbl_t *cmdtp, int flag, int argc,
+int do_avb_read_part_hex(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const char *part;
return CMD_RET_FAILURE;
}
-int do_avb_write_part(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_avb_write_part(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *part;
s64 offset;
return CMD_RET_FAILURE;
}
-int do_avb_read_rb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_avb_read_rb(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
size_t index;
u64 rb_idx;
return CMD_RET_FAILURE;
}
-int do_avb_write_rb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_avb_write_rb(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
size_t index;
u64 rb_idx;
return CMD_RET_FAILURE;
}
-int do_avb_get_uuid(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+int do_avb_get_uuid(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
const char *part;
char buffer[UUID_STR_LEN + 1];
return CMD_RET_FAILURE;
}
-int do_avb_verify_part(cmd_tbl_t *cmdtp, int flag,
+int do_avb_verify_part(struct cmd_tbl *cmdtp, int flag,
int argc, char *const argv[])
{
const char * const requested_partitions[] = {"boot", NULL};
return res;
}
-int do_avb_is_unlocked(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+int do_avb_is_unlocked(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
bool unlock;
return CMD_RET_FAILURE;
}
-int do_avb_read_pvalue(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+int do_avb_read_pvalue(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *name;
size_t bytes;
return CMD_RET_FAILURE;
}
-int do_avb_write_pvalue(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+int do_avb_write_pvalue(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *name;
const char *value;
return CMD_RET_FAILURE;
}
-static cmd_tbl_t cmd_avb[] = {
+static struct cmd_tbl cmd_avb[] = {
U_BOOT_CMD_MKENT(init, 2, 0, do_avb_init, "", ""),
U_BOOT_CMD_MKENT(read_rb, 2, 0, do_avb_read_rb, "", ""),
U_BOOT_CMD_MKENT(write_rb, 3, 0, do_avb_write_rb, "", ""),
#endif
};
-static int do_avb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_avb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
cp = find_cmd_tbl(argv[1], cmd_avb, ARRAY_SIZE(cmd_avb));
* Command handlers
*/
-static int do_axi_show_bus(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_axi_show_bus(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dummy;
return 0;
}
-static int do_axi_bus_num(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_axi_bus_num(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret = 0;
int bus_no;
return ret ? CMD_RET_FAILURE : 0;
}
-static int do_axi_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_axi_md(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
/* Print that many bytes per line */
const uint DISP_LINE_LEN = 16;
return 0;
}
-static int do_axi_mw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_axi_mw(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 writeval;
ulong addr, count, size;
return 0;
}
-static cmd_tbl_t cmd_axi_sub[] = {
+static struct cmd_tbl cmd_axi_sub[] = {
U_BOOT_CMD_MKENT(bus, 1, 1, do_axi_show_bus, "", ""),
U_BOOT_CMD_MKENT(dev, 1, 1, do_axi_bus_num, "", ""),
U_BOOT_CMD_MKENT(md, 4, 1, do_axi_md, "", ""),
U_BOOT_CMD_MKENT(mw, 5, 1, do_axi_mw, "", ""),
};
-static int do_ihs_axi(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_ihs_axi(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
if (argc < 2)
return CMD_RET_USAGE;
return 0;
}
-static int do_bcb_load(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bcb_load(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct blk_desc *desc;
struct disk_partition info;
return CMD_RET_FAILURE;
}
-static int do_bcb_set(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bcb_set(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int size, len;
char *field, *str, *found;
return CMD_RET_SUCCESS;
}
-static int do_bcb_clear(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bcb_clear(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int size;
char *field;
return CMD_RET_SUCCESS;
}
-static int do_bcb_test(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bcb_test(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int size;
char *field;
return CMD_RET_FAILURE;
}
-static int do_bcb_dump(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bcb_dump(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int size;
char *field;
return CMD_RET_SUCCESS;
}
-static int do_bcb_store(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bcb_store(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct blk_desc *desc;
struct disk_partition info;
return CMD_RET_FAILURE;
}
-static cmd_tbl_t cmd_bcb_sub[] = {
+static struct cmd_tbl cmd_bcb_sub[] = {
U_BOOT_CMD_MKENT(load, CONFIG_SYS_MAXARGS, 1, do_bcb_load, "", ""),
U_BOOT_CMD_MKENT(set, CONFIG_SYS_MAXARGS, 1, do_bcb_set, "", ""),
U_BOOT_CMD_MKENT(clear, CONFIG_SYS_MAXARGS, 1, do_bcb_clear, "", ""),
U_BOOT_CMD_MKENT(store, CONFIG_SYS_MAXARGS, 1, do_bcb_store, "", ""),
};
-static int do_bcb(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_bcb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
if (argc < 2)
return CMD_RET_USAGE;
/* Please define board_detail() for your platform */
}
-int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
bd_t *bd = gd->bd;
#elif defined(CONFIG_NIOS2)
-int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
bd_t *bd = gd->bd;
#elif defined(CONFIG_MICROBLAZE)
-int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
bd_t *bd = gd->bd;
#elif defined(CONFIG_M68K)
-int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
bd_t *bd = gd->bd;
#elif defined(CONFIG_MIPS)
-int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
print_std_bdinfo(gd->bd);
print_num("relocaddr", gd->relocaddr);
#elif defined(CONFIG_ARM)
-static int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
bd_t *bd = gd->bd;
#elif defined(CONFIG_SH)
-int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
bd_t *bd = gd->bd;
#elif defined(CONFIG_X86)
-int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
bd_t *bd = gd->bd;
#elif defined(CONFIG_SANDBOX)
-int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
bd_t *bd = gd->bd;
#elif defined(CONFIG_NDS32)
-int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
bd_t *bd = gd->bd;
#elif defined(CONFIG_RISCV)
-int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
bd_t *bd = gd->bd;
#elif defined(CONFIG_ARC)
-int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
bd_t *bd = gd->bd;
#elif defined(CONFIG_XTENSA)
-int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
print_std_bdinfo(gd->bd);
return 0;
* Entry point from the interpreter to the disassembler. Repeated calls
* will resume from the last disassembled address.
* ====================================================================== */
-int do_bedbug_dis (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_bedbug_dis(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr; /* Address to start disassembly from */
ulong len; /* # of instructions to disassemble */
* instructions in consecutive memory locations until a '.' (period) is
* entered on a line by itself.
* ====================================================================== */
-int do_bedbug_asm (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_bedbug_asm(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
long mem_addr; /* Address to assemble into */
unsigned long instr; /* Machine code for text */
* CPU-specific break point set routine.
* ====================================================================== */
-int do_bedbug_break (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_bedbug_break(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
/* -------------------------------------------------- */
if (bug_ctx.do_break)
* stopped flag in the context so that the breakpoint routine will
* return.
* ====================================================================== */
-int do_bedbug_continue (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_bedbug_continue(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
/* -------------------------------------------------- */
* the address passes control to the CPU-specific set breakpoint routine
* for the current breakpoint number.
* ====================================================================== */
-int do_bedbug_step (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_bedbug_step(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned long addr; /* Address to stop at */
* the address passes control to the CPU-specific set breakpoint routine
* for the current breakpoint number.
* ====================================================================== */
-int do_bedbug_next (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_bedbug_next(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned long addr; /* Address to stop at */
* Interpreter command to print the current stack. This assumes an EABI
* architecture, so it starts with GPR R1 and works back up the stack.
* ====================================================================== */
-int do_bedbug_stack (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_bedbug_stack(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned long sp; /* Stack pointer */
unsigned long func; /* LR from stack */
* Interpreter command to dump the registers. Calls the CPU-specific
* show registers routine.
* ====================================================================== */
-int do_bedbug_rdump (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_bedbug_rdump(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
/* -------------------------------------------------- */
*/
#include <common.h>
+#include <command.h>
#include <dm.h>
#include <dm/device-internal.h>
#include <dm/lists.h>
return 0;
}
-static int do_bind_unbind(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bind_unbind(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret = 0;
bool bind;
unmap_sysmem(buf);
}
-static int do_binop(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_binop(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong len;
u8 *result, *src1, *src2;
#include <common.h>
#include <blk.h>
+#include <command.h>
-int blk_common_cmd(int argc, char * const argv[], enum if_type if_type,
+int blk_common_cmd(int argc, char *const argv[], enum if_type if_type,
int *cur_devnump)
{
const char *if_name = blk_get_if_type_name(if_type);
* Author: Eric Nelson<eric@nelint.com>
*
*/
+#include <command.h>
#include <config.h>
#include <common.h>
#include <malloc.h>
#include <part.h>
-static int blkc_show(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int blkc_show(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
struct block_cache_stats stats;
blkcache_stats(&stats);
return 0;
}
-static int blkc_configure(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int blkc_configure(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
unsigned blocks_per_entry, max_entries;
if (argc != 3)
return 0;
}
-static cmd_tbl_t cmd_blkc_sub[] = {
+static struct cmd_tbl cmd_blkc_sub[] = {
U_BOOT_CMD_MKENT(show, 0, 0, blkc_show, "", ""),
U_BOOT_CMD_MKENT(configure, 3, 0, blkc_configure, "", ""),
};
};
}
-static int do_blkcache(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_blkcache(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
#ifdef CONFIG_NEEDS_MANUAL_RELOC
blkc_reloc();
* Returns zero on success, CMD_RET_USAGE in case of misuse and negative
* on error.
*/
-static int do_blob(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_blob(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong key_addr, src_addr, dst_addr, len;
uint8_t *km_ptr, *src_ptr, *dst_ptr;
}
#endif
-static int do_bmp_info(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_bmp_info(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr;
return (bmp_info(addr));
}
-static int do_bmp_display(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_bmp_display(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr;
int x = 0, y = 0;
return (bmp_display(addr, x, y));
}
-static cmd_tbl_t cmd_bmp_sub[] = {
+static struct cmd_tbl cmd_bmp_sub[] = {
U_BOOT_CMD_MKENT(info, 3, 0, do_bmp_info, "", ""),
U_BOOT_CMD_MKENT(display, 5, 0, do_bmp_display, "", ""),
};
* Return: None
*
*/
-static int do_bmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_bmp(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
/* Strip off leading 'bmp' command argument */
argc--;
/* Allow ports to override the default behavior */
__attribute__((weak))
unsigned long do_go_exec(ulong (*entry)(int, char * const []), int argc,
- char * const argv[])
+ char *const argv[])
{
return entry (argc, argv);
}
-static int do_go(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_go(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ulong addr, rc;
int rcode = 0;
#include <command.h>
#include <bootcount.h>
-static int do_bootcount_print(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bootcount_print(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
printf("%lu\n", bootcount_load());
return CMD_RET_SUCCESS;
}
-static int do_bootcount_reset(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bootcount_reset(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
/*
* note that we're explicitly not resetting the environment
return CMD_RET_SUCCESS;
}
-static cmd_tbl_t bootcount_sub[] = {
+static struct cmd_tbl bootcount_sub[] = {
U_BOOT_CMD_MKENT(print, 1, 1, do_bootcount_print, "", ""),
U_BOOT_CMD_MKENT(reset, 1, 1, do_bootcount_reset, "", ""),
};
-static int do_bootcount(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bootcount(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
if (argc < 2)
return CMD_RET_USAGE;
* @argv: command line arguments
* Return: status code
*/
-static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_bootefi(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
efi_status_t ret;
void *fdt;
/*
* Image booting support
*/
-static int booti_start(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[], bootm_headers_t *images)
+static int booti_start(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[], bootm_headers_t *images)
{
int ret;
ulong ld;
return 0;
}
-int do_booti(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_booti(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int ret;
#endif
#if defined(CONFIG_CMD_IMLS) || defined(CONFIG_CMD_IMLS_NAND)
-static int do_imls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+static int do_imls(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
#endif
/* we overload the cmd field with our state machine info instead of a
* function pointer */
-static cmd_tbl_t cmd_bootm_sub[] = {
+static struct cmd_tbl cmd_bootm_sub[] = {
U_BOOT_CMD_MKENT(start, 0, 1, (void *)BOOTM_STATE_START, "", ""),
U_BOOT_CMD_MKENT(loados, 0, 1, (void *)BOOTM_STATE_LOADOS, "", ""),
#ifdef CONFIG_SYS_BOOT_RAMDISK_HIGH
U_BOOT_CMD_MKENT(go, 0, 1, (void *)BOOTM_STATE_OS_GO, "", ""),
};
-static int do_bootm_subcommand(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bootm_subcommand(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret = 0;
long state;
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
c = find_cmd_tbl(argv[0], &cmd_bootm_sub[0], ARRAY_SIZE(cmd_bootm_sub));
argc--; argv++;
/* bootm - boot application image from image in memory */
/*******************************************************************/
-int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bootm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
#ifdef CONFIG_NEEDS_MANUAL_RELOC
static int relocated = 0;
BOOTM_STATE_OS_GO, &images, 1);
}
-int bootm_maybe_autostart(cmd_tbl_t *cmdtp, const char *cmd)
+int bootm_maybe_autostart(struct cmd_tbl *cmdtp, const char *cmd)
{
const char *ep = env_get("autostart");
/* bootd - boot default image */
/*******************************************************************/
#if defined(CONFIG_CMD_BOOTD)
-int do_bootd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bootd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
return run_command(env_get("bootcmd"), flag);
}
/* iminfo - print header info for a requested image */
/*******************************************************************/
#if defined(CONFIG_CMD_IMI)
-static int do_iminfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_iminfo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int arg;
ulong addr;
#endif
#if defined(CONFIG_CMD_IMLS) || defined(CONFIG_CMD_IMLS_NAND)
-static int do_imls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_imls(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret_nor = 0, ret_nand = 0;
}
#endif
-int do_bootmenu(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_bootmenu(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *delay_str = NULL;
int delay = 10;
#include <common.h>
#include <bootstage.h>
+#include <command.h>
-static int do_bootstage_report(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bootstage_report(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
bootstage_report();
return 0;
}
-static int get_base_size(int argc, char * const argv[], ulong *basep,
+static int get_base_size(int argc, char *const argv[], ulong *basep,
ulong *sizep)
{
char *endp;
return 0;
}
-static int do_bootstage_stash(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_bootstage_stash(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong base, size;
int ret;
return 0;
}
-static cmd_tbl_t cmd_bootstage_sub[] = {
+static struct cmd_tbl cmd_bootstage_sub[] = {
U_BOOT_CMD_MKENT(report, 2, 1, do_bootstage_report, "", ""),
U_BOOT_CMD_MKENT(stash, 4, 0, do_bootstage_stash, "", ""),
U_BOOT_CMD_MKENT(unstash, 4, 0, do_bootstage_stash, "", ""),
/*
* Process a bootstage sub-command
*/
-static int do_boostage(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_boostage(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
/* Strip off leading 'bootstage' command argument */
argc--;
/*
* zImage booting support
*/
-static int bootz_start(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[], bootm_headers_t *images)
+static int bootz_start(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[], bootm_headers_t *images)
{
int ret;
ulong zi_start, zi_end;
return 0;
}
-int do_bootz(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bootz(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int ret;
#include <btrfs.h>
#include <fs.h>
-int do_btrsubvol(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_btrsubvol(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
if (argc != 3)
return CMD_RET_USAGE;
{
}
-static int do_icache(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_icache(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
switch (argc) {
case 2: /* on / off / flush */
/* please define arch specific flush_dcache_all */
}
-static int do_dcache(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_dcache(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
switch (argc) {
case 2: /* on / off / flush */
#include <env.h>
#include <cbfs.h>
-static int do_cbfs_init(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_cbfs_init(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
uintptr_t end_of_rom = 0xffffffff;
" CBFS is in. It defaults to 0xFFFFFFFF\n"
);
-static int do_cbfs_fsload(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_cbfs_fsload(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const struct cbfs_cachenode *file;
" - load binary file 'filename' from the cbfs to address 'addr'\n"
);
-static int do_cbfs_ls(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_cbfs_ls(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const struct cbfs_cachenode *file = file_cbfs_get_first();
" - list the files in the cbfs\n"
);
-static int do_cbfs_fsinfo(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_cbfs_fsinfo(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const struct cbfs_header *header = file_cbfs_get_header();
}
#endif
-static int do_clk_dump(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_clk_dump(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int ret;
return ret;
}
-static cmd_tbl_t cmd_clk_sub[] = {
+static struct cmd_tbl cmd_clk_sub[] = {
U_BOOT_CMD_MKENT(dump, 1, 1, do_clk_dump, "", ""),
};
-static int do_clk(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_clk(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
if (argc < 2)
return CMD_RET_USAGE;
#include <lcd.h>
#include <video.h>
-static int do_video_clear(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_video_clear(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
#if defined(CONFIG_DM_VIDEO)
#include "config_data_gz.h"
#include "config_data_size.h"
-static int do_config(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_config(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *dst;
unsigned long len = data_size;
#include <common.h>
#include <command.h>
-static int do_conitrace(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_conitrace(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
bool first = true;
#include <stdio_dev.h>
extern void _do_coninfo (void);
-static int do_coninfo(cmd_tbl_t *cmd, int flag, int argc, char * const argv[])
+static int do_coninfo(struct cmd_tbl *cmd, int flag, int argc,
+ char *const argv[])
{
int l;
struct list_head *list = stdio_get_list();
return 0;
}
-static int do_cpu_list(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_cpu_list(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
if (print_cpu_list(false))
return 0;
}
-static int do_cpu_detail(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_cpu_detail(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
if (print_cpu_list(true))
return 0;
}
-static cmd_tbl_t cmd_cpu_sub[] = {
+static struct cmd_tbl cmd_cpu_sub[] = {
U_BOOT_CMD_MKENT(list, 2, 1, do_cpu_list, "", ""),
U_BOOT_CMD_MKENT(detail, 4, 0, do_cpu_detail, "", ""),
};
/*
* Process a cpu sub-command
*/
-static int do_cpu(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_cpu(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *c = NULL;
+ struct cmd_tbl *c = NULL;
/* Strip off leading 'cpu' command argument */
argc--;
* @param argv arguments list
* @return 0 on success, 1 otherwise
*/
-int do_cramfs_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_cramfs_load(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *filename;
int size;
* @param argv arguments list
* @return 0 on success, 1 otherwise
*/
-int do_cramfs_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_cramfs_ls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *filename = "/";
int ret;
* @param argv List of remaining parameters
* @return flash region (EC_FLASH_REGION_...) or -1 on error
*/
-static int cros_ec_decode_region(int argc, char * const argv[])
+static int cros_ec_decode_region(int argc, char *const argv[])
{
if (argc > 0) {
if (0 == strcmp(*argv, "rw"))
* (negative EC_RES_...)
*/
static int do_read_write(struct udevice *dev, int is_write, int argc,
- char * const argv[])
+ char *const argv[])
{
uint32_t offset, size = -1U, region_size;
unsigned long addr;
return 0;
}
-static int do_cros_ec(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_cros_ec(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
const char *cmd;
static int mmc_nspi (const char *);
-int do_dataflash_mmc_mux (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_dataflash_mmc_mux(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
switch (argc) {
case 2: /* on / off */
static struct rtc_time default_tm = { 0, 0, 0, 1, 1, 2000, 6, 0, 0 };
-static int do_date(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_date(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct rtc_time tm;
int rcode = 0;
*/
#include <common.h>
+#include <command.h>
#include <dm-demo.h>
#include <mapmem.h>
#include <asm/io.h>
struct udevice *demo_dev;
-static int do_demo_hello(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_demo_hello(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ch = 0;
return demo_hello(demo_dev, ch);
}
-static int do_demo_status(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_demo_status(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int status;
int ret;
return 0;
}
-static int do_demo_light(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_demo_light(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int light;
int ret;
return ret;
}
-int do_demo_list(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_demo_list(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct udevice *dev;
int i, ret;
return cmd_process_error(cmdtp, ret);
}
-static cmd_tbl_t demo_commands[] = {
+static struct cmd_tbl demo_commands[] = {
U_BOOT_CMD_MKENT(list, 0, 1, do_demo_list, "", ""),
U_BOOT_CMD_MKENT(hello, 2, 1, do_demo_hello, "", ""),
U_BOOT_CMD_MKENT(light, 2, 1, do_demo_light, "", ""),
U_BOOT_CMD_MKENT(status, 1, 1, do_demo_status, "", ""),
};
-static int do_demo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_demo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *demo_cmd;
+ struct cmd_tbl *demo_cmd;
int devnum = 0;
int ret;
*/
#include <common.h>
+#include <command.h>
#include <watchdog.h>
#include <dfu.h>
#include <console.h>
#include <usb.h>
#include <net.h>
-static int do_dfu(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_dfu(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
if (argc < 2)
#include <command.h>
#include <post.h>
-int do_diag (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_diag(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned int i;
#include <image.h>
#include <part.h>
-int common_diskboot(cmd_tbl_t *cmdtp, const char *intf, int argc,
+int common_diskboot(struct cmd_tbl *cmdtp, const char *intf, int argc,
char *const argv[])
{
__maybe_unused int dev;
#include <dm/root.h>
#include <dm/util.h>
-static int do_dm_dump_all(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_dm_dump_all(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
dm_dump_all();
return 0;
}
-static int do_dm_dump_uclass(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_dm_dump_uclass(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
dm_dump_uclass();
return 0;
}
-static int do_dm_dump_devres(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_dm_dump_devres(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
dm_dump_devres();
return 0;
}
-static int do_dm_dump_drivers(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_dm_dump_drivers(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
dm_dump_drivers();
return 0;
}
-static cmd_tbl_t test_commands[] = {
+static struct cmd_tbl test_commands[] = {
U_BOOT_CMD_MKENT(tree, 0, 1, do_dm_dump_all, "", ""),
U_BOOT_CMD_MKENT(uclass, 1, 1, do_dm_dump_uclass, "", ""),
U_BOOT_CMD_MKENT(devres, 1, 1, do_dm_dump_devres, "", ""),
}
}
-static int do_dm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_dm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *test_cmd;
+ struct cmd_tbl *test_cmd;
int ret;
#ifdef CONFIG_NEEDS_MANUAL_RELOC
#include <common.h>
#include <command.h>
-static int do_echo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_echo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int i;
int putnl = 1;
* @returns: number of arguments parsed or CMD_RET_USAGE if error
*/
static int parse_i2c_bus_addr(int *i2c_bus, ulong *i2c_addr, int argc,
- char * const argv[], int argc_no_bus_addr)
+ char *const argv[], int argc_no_bus_addr)
{
int argc_no_bus = argc_no_bus_addr + 1;
int argc_bus_addr = argc_no_bus_addr + 2;
}
#define NEXT_PARAM(argc, index) { (argc)--; (index)++; }
-int do_eeprom(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_eeprom(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int layout_ver = LAYOUT_VERSION_AUTODETECT;
enum eeprom_action action = EEPROM_ACTION_INVALID;
printf("*Some areas are merged (use 'all' to see)\n");
}
-static int do_efi_mem(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_efi_mem(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct efi_mem_desc *desc;
struct efi_entry_memmap *map;
return ret ? CMD_RET_FAILURE : 0;
}
-static cmd_tbl_t efi_commands[] = {
+static struct cmd_tbl efi_commands[] = {
U_BOOT_CMD_MKENT(mem, 1, 1, do_efi_mem, "", ""),
};
-static int do_efi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_efi(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *efi_cmd;
+ struct cmd_tbl *efi_cmd;
int ret;
if (argc < 2)
* Implement efidebug "devices" sub-command.
* Show all UEFI devices and their information.
*/
-static int do_efi_show_devices(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_efi_show_devices(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
efi_handle_t *handles;
efi_uintn_t num, i;
* Implement efidebug "drivers" sub-command.
* Show all UEFI drivers and their information.
*/
-static int do_efi_show_drivers(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_efi_show_drivers(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
efi_handle_t *handles;
efi_uintn_t num, i;
* Show all UEFI handles and their information, currently all protocols
* added to handle.
*/
-static int do_efi_show_handles(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_efi_show_handles(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
efi_handle_t *handles;
efi_guid_t **guid;
* Implement efidebug "images" sub-command.
* Show all UEFI loaded images and their information.
*/
-static int do_efi_show_images(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_efi_show_images(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
efi_print_image_infos(NULL);
* Implement efidebug "memmap" sub-command.
* Show UEFI memory map.
*/
-static int do_efi_show_memmap(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_efi_show_memmap(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
struct efi_mem_desc *memmap = NULL, *map;
efi_uintn_t map_size = 0;
* Implement efidebug "tables" sub-command.
* Show UEFI configuration tables.
*/
-static int do_efi_show_tables(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_efi_show_tables(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
efi_uintn_t i;
const char *guid_str;
*
* efidebug boot add <id> <label> <interface> <devnum>[:<part>] <file> <options>
*/
-static int do_efi_boot_add(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_efi_boot_add(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
int id;
char *endp;
*
* efidebug boot rm <id> ...
*/
-static int do_efi_boot_rm(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_efi_boot_rm(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
efi_guid_t guid;
int id, i;
*
* efidebug boot dump
*/
-static int do_efi_boot_dump(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_efi_boot_dump(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
u16 *var_name16, *p;
efi_uintn_t buf_size, size;
*
* efidebug boot next <id>
*/
-static int do_efi_boot_next(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_efi_boot_next(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
u16 bootnext;
efi_uintn_t size;
*
* efidebug boot order [<id> ...]
*/
-static int do_efi_boot_order(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_efi_boot_order(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
u16 *bootorder = NULL;
efi_uintn_t size;
return r;
}
-static cmd_tbl_t cmd_efidebug_boot_sub[] = {
+static struct cmd_tbl cmd_efidebug_boot_sub[] = {
U_BOOT_CMD_MKENT(add, CONFIG_SYS_MAXARGS, 1, do_efi_boot_add, "", ""),
U_BOOT_CMD_MKENT(rm, CONFIG_SYS_MAXARGS, 1, do_efi_boot_rm, "", ""),
U_BOOT_CMD_MKENT(dump, CONFIG_SYS_MAXARGS, 1, do_efi_boot_dump, "", ""),
*
* Implement efidebug "boot" sub-command.
*/
-static int do_efi_boot_opt(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_efi_boot_opt(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
if (argc < 2)
return CMD_RET_USAGE;
*
* efidebug test bootmgr
*/
-static int do_efi_test_bootmgr(cmd_tbl_t *cmdtp, int flag,
+static int do_efi_test_bootmgr(struct cmd_tbl *cmdtp, int flag,
int argc, char * const argv[])
{
efi_handle_t image;
return CMD_RET_SUCCESS;
}
-static cmd_tbl_t cmd_efidebug_test_sub[] = {
+static struct cmd_tbl cmd_efidebug_test_sub[] = {
U_BOOT_CMD_MKENT(bootmgr, CONFIG_SYS_MAXARGS, 1, do_efi_test_bootmgr,
"", ""),
};
*
* Implement efidebug "test" sub-command.
*/
-static int do_efi_test(cmd_tbl_t *cmdtp, int flag,
+static int do_efi_test(struct cmd_tbl *cmdtp, int flag,
int argc, char * const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
if (argc < 2)
return CMD_RET_USAGE;
* Implement efidebug "test" sub-command.
*/
-static int do_efi_query_info(cmd_tbl_t *cmdtp, int flag,
+static int do_efi_query_info(struct cmd_tbl *cmdtp, int flag,
int argc, char * const argv[])
{
efi_status_t ret;
return CMD_RET_SUCCESS;
}
-static cmd_tbl_t cmd_efidebug_sub[] = {
+static struct cmd_tbl cmd_efidebug_sub[] = {
U_BOOT_CMD_MKENT(boot, CONFIG_SYS_MAXARGS, 1, do_efi_boot_opt, "", ""),
U_BOOT_CMD_MKENT(devices, CONFIG_SYS_MAXARGS, 1, do_efi_show_devices,
"", ""),
* Implement efidebug command which allows us to display and
* configure UEFI environment.
*/
-static int do_efidebug(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_efidebug(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
efi_status_t r;
if (argc < 2)
/* Allow ports to override the default behavior */
static unsigned long do_bootelf_exec(ulong (*entry)(int, char * const[]),
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
unsigned long ret;
}
/* Interpreter command to boot an arbitrary ELF image from memory */
-int do_bootelf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bootelf(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned long addr; /* Address of the ELF image */
unsigned long rc; /* Return value from user code */
* be either an ELF image or a raw binary. Will attempt to setup the
* bootline and other parameters correctly.
*/
-int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bootvx(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned long addr; /* Address of image */
unsigned long bootaddr = 0; /* Address to put the bootline */
}
/* find all the keywords in the command */
-static int keywords_find(int argc, char * const argv[],
+static int keywords_find(int argc, char *const argv[],
struct ethsw_command_def *parsed_cmd)
{
int i;
}
/* function to interpret commands starting with "ethsw " */
-static int do_ethsw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_ethsw(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct ethsw_command_def parsed_cmd;
int rc = CMD_RET_SUCCESS;
#include <common.h>
#include <command.h>
-static int do_exit(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_exit(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int r;
/*
* Ext2fs support
*/
+#include <common.h>
+#include <command.h>
#include <fs.h>
-static int do_ext2ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_ext2ls(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_ls(cmdtp, flag, argc, argv, FS_TYPE_EXT);
}
/******************************************************************************
* Ext2fs boot command intepreter. Derived from diskboot
*/
-int do_ext2load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ext2load(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
return do_load(cmdtp, flag, argc, argv, FS_TYPE_EXT);
}
#include <usb.h>
#endif
-int do_ext4_size(cmd_tbl_t *cmdtp, int flag, int argc,
- char *const argv[])
+int do_ext4_size(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
return do_size(cmdtp, flag, argc, argv, FS_TYPE_EXT);
}
-int do_ext4_load(cmd_tbl_t *cmdtp, int flag, int argc,
- char *const argv[])
+int do_ext4_load(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
return do_load(cmdtp, flag, argc, argv, FS_TYPE_EXT);
}
-int do_ext4_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_ext4_ls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
return do_ls(cmdtp, flag, argc, argv, FS_TYPE_EXT);
}
#if defined(CONFIG_CMD_EXT4_WRITE)
-int do_ext4_write(cmd_tbl_t *cmdtp, int flag, int argc,
+int do_ext4_write(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
return do_save(cmdtp, flag, argc, argv, FS_TYPE_EXT);
#endif
}
-static int do_fastboot(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_fastboot(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
uintptr_t buf_addr = (uintptr_t)NULL;
size_t buf_size = 0;
* Boot support
*/
#include <common.h>
+#include <command.h>
#include <mapmem.h>
#include <fat.h>
#include <fs.h>
#include <part.h>
#include <asm/cache.h>
-int do_fat_size(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_fat_size(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
return do_size(cmdtp, flag, argc, argv, FS_TYPE_FAT);
}
" and determine its size."
);
-int do_fat_fsload(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_fat_fsload(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
return do_load(cmdtp, flag, argc, argv, FS_TYPE_FAT);
}
" be printed and performance will suffer for the load."
);
-static int do_fat_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_fat_ls(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_ls(cmdtp, flag, argc, argv, FS_TYPE_FAT);
}
" - list files from 'dev' on 'interface' in a 'directory'"
);
-static int do_fat_fsinfo(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_fat_fsinfo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int dev, part;
struct blk_desc *dev_desc;
);
#ifdef CONFIG_FAT_WRITE
-static int do_fat_fswrite(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_fat_fswrite(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
loff_t size;
int ret;
" to 'dev' on 'interface'"
);
-static int do_fat_rm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_fat_rm(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_rm(cmdtp, flag, argc, argv, FS_TYPE_FAT);
}
" - delete a file from 'dev' on 'interface'"
);
-static int do_fat_mkdir(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_fat_mkdir(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_mkdir(cmdtp, flag, argc, argv, FS_TYPE_FAT);
}
"size_dt_struct",
};
-static int fdt_get_header_value(int argc, char * const argv[])
+static int fdt_get_header_value(int argc, char *const argv[])
{
fdt32_t *fdtp = (fdt32_t *)working_fdt;
ulong val;
/*
* Flattened Device Tree command, see the help for parameter definitions.
*/
-static int do_fdt(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_fdt(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
if (argc < 2)
return CMD_RET_USAGE;
#error "CONFIG_UPDATE_TFTP required"
#endif
-static int do_fitupd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_fitupd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr = 0UL;
}
#endif /* CONFIG_MTD_NOR_FLASH */
-static int do_flinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_flinfo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
#ifdef CONFIG_MTD_NOR_FLASH
ulong bank;
return 0;
}
-static int do_flerase(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_flerase(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
#ifdef CONFIG_MTD_NOR_FLASH
flash_info_t *info = NULL;
}
#endif /* CONFIG_MTD_NOR_FLASH */
-static int do_protect(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_protect(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int rcode = 0;
#ifdef CONFIG_MTD_NOR_FLASH
}
static int do_fpga_check_params(long *dev, long *fpga_data, size_t *data_size,
- cmd_tbl_t *cmdtp, int argc, char *const argv[])
+ struct cmd_tbl *cmdtp, int argc,
+ char *const argv[])
{
size_t local_data_size;
long local_fpga_data;
}
#if defined(CONFIG_CMD_FPGA_LOAD_SECURE)
-int do_fpga_loads(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_fpga_loads(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
size_t data_size = 0;
long fpga_data, dev;
#endif
#if defined(CONFIG_CMD_FPGA_LOADFS)
-static int do_fpga_loadfs(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_fpga_loadfs(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
size_t data_size = 0;
}
#endif
-static int do_fpga_info(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_fpga_info(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
long dev = do_fpga_get_device(argv[0]);
return fpga_info(dev);
}
-static int do_fpga_dump(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_fpga_dump(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
size_t data_size = 0;
long fpga_data, dev;
return fpga_dump(dev, (void *)fpga_data, data_size);
}
-static int do_fpga_load(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_fpga_load(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
size_t data_size = 0;
long fpga_data, dev;
return fpga_load(dev, (void *)fpga_data, data_size, BIT_FULL);
}
-static int do_fpga_loadb(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_fpga_loadb(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
size_t data_size = 0;
long fpga_data, dev;
}
#if defined(CONFIG_CMD_FPGA_LOADP)
-static int do_fpga_loadp(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_fpga_loadp(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
size_t data_size = 0;
long fpga_data, dev;
#endif
#if defined(CONFIG_CMD_FPGA_LOADBP)
-static int do_fpga_loadbp(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_fpga_loadbp(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
size_t data_size = 0;
long fpga_data, dev;
#endif
#if defined(CONFIG_CMD_FPGA_LOADMK)
-static int do_fpga_loadmk(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_fpga_loadmk(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
size_t data_size = 0;
void *fpga_data = NULL;
}
#endif
-static cmd_tbl_t fpga_commands[] = {
+static struct cmd_tbl fpga_commands[] = {
U_BOOT_CMD_MKENT(info, 1, 1, do_fpga_info, "", ""),
U_BOOT_CMD_MKENT(dump, 3, 1, do_fpga_dump, "", ""),
U_BOOT_CMD_MKENT(load, 3, 1, do_fpga_load, "", ""),
#endif
};
-static int do_fpga_wrapper(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_fpga_wrapper(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
- cmd_tbl_t *fpga_cmd;
+ struct cmd_tbl *fpga_cmd;
int ret;
if (argc < 2)
* fpgad {fpga} {addr} {len}
*/
#define DISP_LINE_LEN 16
-int do_fpga_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_fpga_md(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned int k;
unsigned int fpga;
#include <command.h>
#include <fs.h>
-static int do_size_wrapper(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_size_wrapper(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_size(cmdtp, flag, argc, argv, FS_TYPE_ANY);
}
" and determine its size."
);
-static int do_load_wrapper(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_load_wrapper(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_load(cmdtp, flag, argc, argv, FS_TYPE_ANY);
}
" If 'pos' is 0 or omitted, the file is read from the start."
)
-static int do_save_wrapper(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_save_wrapper(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_save(cmdtp, flag, argc, argv, FS_TYPE_ANY);
}
" If 'pos' is 0 or omitted, the file is written from the start."
)
-static int do_ls_wrapper(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_ls_wrapper(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_ls(cmdtp, flag, argc, argv, FS_TYPE_ANY);
}
" device type 'interface' instance 'dev'."
)
-static int do_ln_wrapper(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_ln_wrapper(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_ln(cmdtp, flag, argc, argv, FS_TYPE_ANY);
}
" device type 'interface' instance 'dev'."
)
-static int do_fstype_wrapper(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_fstype_wrapper(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_fs_type(cmdtp, flag, argc, argv);
}
#include <command.h>
#include <fs.h>
-static int do_fs_uuid_wrapper(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_fs_uuid_wrapper(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_fs_uuid(cmdtp, flag, argc, argv, FS_TYPE_ANY);
}
return 0;
}
-static int do_fuse(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_fuse(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *op = argc >= 2 ? argv[1] : NULL;
int confirmed = argc >= 3 && !strcmp(argv[2], "-y");
#include <common.h>
#include <command.h>
-static int do_gettime(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_gettime(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned long int val = get_timer(0);
}
#endif
-static int do_gpio(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_gpio(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned int gpio;
enum gpio_cmd sub_cmd;
*
* @return zero on success; otherwise error
*/
-static int do_gpt(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_gpt(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int ret = CMD_RET_SUCCESS;
int dev = 0;
#include <hash.h>
#include <linux/ctype.h>
-static int do_hash(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_hash(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *s;
int flags = HASH_FLAG_ENV;
#include <common.h>
#include <command.h>
-static int do_help(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_help(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
#ifdef CONFIG_CMDLINE
- cmd_tbl_t *start = ll_entry_start(cmd_tbl_t, cmd);
- const int len = ll_entry_count(cmd_tbl_t, cmd);
+ struct cmd_tbl *start = ll_entry_start(struct cmd_tbl, cmd);
+ const int len = ll_entry_count(struct cmd_tbl, cmd);
return _do_help(start, len, cmdtp, flag, argc, argv);
#else
return 0;
#ifdef CONFIG_CMDLINE
/* This does not use the U_BOOT_CMD macro as ? can't be used in symbol names */
-ll_entry_declare(cmd_tbl_t, question_mark, cmd) = {
+ll_entry_declare(struct cmd_tbl, question_mark, cmd) = {
"?", CONFIG_SYS_MAXARGS, cmd_always_repeatable, do_help,
"alias for 'help'",
#ifdef CONFIG_SYS_LONGHELP
*/
#include <common.h>
+#include <command.h>
#include <dm.h>
#include <fs.h>
#include <part.h>
static int host_curr_device = -1;
-static int do_host_load(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_host_load(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_load(cmdtp, flag, argc, argv, FS_TYPE_SANDBOX);
}
-static int do_host_ls(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_host_ls(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_ls(cmdtp, flag, argc, argv, FS_TYPE_SANDBOX);
}
-static int do_host_size(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_host_size(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_size(cmdtp, flag, argc, argv, FS_TYPE_SANDBOX);
}
-static int do_host_save(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_host_save(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return do_save(cmdtp, flag, argc, argv, FS_TYPE_SANDBOX);
}
-static int do_host_bind(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_host_bind(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc < 2 || argc > 3)
return CMD_RET_USAGE;
return host_dev_bind(dev, file);
}
-static int do_host_info(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_host_info(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc < 1 || argc > 2)
return CMD_RET_USAGE;
return 0;
}
-static int do_host_dev(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_host_dev(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int dev;
char *ep;
return 0;
}
-static cmd_tbl_t cmd_host_sub[] = {
+static struct cmd_tbl cmd_host_sub[] = {
U_BOOT_CMD_MKENT(load, 7, 0, do_host_load, "", ""),
U_BOOT_CMD_MKENT(ls, 3, 0, do_host_ls, "", ""),
U_BOOT_CMD_MKENT(save, 6, 0, do_host_save, "", ""),
U_BOOT_CMD_MKENT(dev, 0, 1, do_host_dev, "", ""),
};
-static int do_host(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_host(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
/* Skip past 'host' */
argc--;
* Syntax:
* i2c read {i2c_chip} {devaddr}{.0, .1, .2} {len} {memaddr}
*/
-static int do_i2c_read ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_i2c_read(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
uint chip;
uint devaddr, length;
return 0;
}
-static int do_i2c_write(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_i2c_write(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
uint chip;
uint devaddr, length;
}
#ifdef CONFIG_DM_I2C
-static int do_i2c_flags(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_i2c_flags(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct udevice *dev;
return 0;
}
-static int do_i2c_olen(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_i2c_olen(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
uint olen;
* Syntax:
* i2c md {i2c_chip} {addr}{.0, .1, .2} {len}
*/
-static int do_i2c_md ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_i2c_md(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
uint chip;
uint addr, length;
* Syntax:
* i2c mw {i2c_chip} {addr}{.0, .1, .2} {data} [{count}]
*/
-static int do_i2c_mw ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_i2c_mw(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
uint chip;
ulong addr;
* Syntax:
* i2c crc32 {i2c_chip} {addr}{.0, .1, .2} {count}
*/
-static int do_i2c_crc (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_i2c_crc(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
uint chip;
ulong addr;
* i2c mm{.b, .w, .l} {i2c_chip} {addr}{.0, .1, .2}
* i2c nm{.b, .w, .l} {i2c_chip} {addr}{.0, .1, .2}
*/
-static int
-mod_i2c_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
+static int mod_i2c_mem(struct cmd_tbl *cmdtp, int incrflag, int flag, int argc,
+ char *const argv[])
{
uint chip;
ulong addr;
*
* Returns zero (success) if one or more I2C devices was found
*/
-static int do_i2c_probe (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_i2c_probe(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int j;
int addr = -1;
* {length} - Number of bytes to read
* {delay} - A DECIMAL number and defaults to 1000 uSec
*/
-static int do_i2c_loop(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_i2c_loop(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
uint chip;
int alen;
* Syntax:
* i2c sdram {i2c_chip}
*/
-static int do_sdram (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_sdram(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
enum { unknown, EDO, SDRAM, DDR, DDR2, DDR3, DDR4 } type;
* i2c edid {i2c_chip}
*/
#if defined(CONFIG_I2C_EDID)
-int do_edid(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_edid(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
uint chip;
struct edid1_info edid;
* Returns zero always.
*/
#if defined(CONFIG_SYS_I2C) || defined(CONFIG_DM_I2C)
-static int do_i2c_show_bus(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_i2c_show_bus(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc == 1) {
/* show all busses */
*/
#if defined(CONFIG_SYS_I2C) || defined(CONFIG_I2C_MULTI_BUS) || \
defined(CONFIG_DM_I2C)
-static int do_i2c_bus_num(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_i2c_bus_num(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret = 0;
int bus_no;
* Returns zero on success, CMD_RET_USAGE in case of misuse and negative
* on error.
*/
-static int do_i2c_bus_speed(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_i2c_bus_speed(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int speed, ret=0;
* Returns zero on success, CMD_RET_USAGE in case of misuse and negative
* on error.
*/
-static int do_i2c_mm(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_i2c_mm(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return mod_i2c_mem (cmdtp, 1, flag, argc, argv);
}
* Returns zero on success, CMD_RET_USAGE in case of misuse and negative
* on error.
*/
-static int do_i2c_nm(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_i2c_nm(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return mod_i2c_mem (cmdtp, 0, flag, argc, argv);
}
*
* Returns zero always.
*/
-static int do_i2c_reset(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_i2c_reset(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
#if defined(CONFIG_DM_I2C)
struct udevice *bus;
return 0;
}
-static cmd_tbl_t cmd_i2c_sub[] = {
+static struct cmd_tbl cmd_i2c_sub[] = {
#if defined(CONFIG_SYS_I2C) || defined(CONFIG_DM_I2C)
U_BOOT_CMD_MKENT(bus, 1, 1, do_i2c_show_bus, "", ""),
#endif
* Returns zero on success, CMD_RET_USAGE in case of misuse and negative
* on error.
*/
-static int do_i2c(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_i2c(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
#ifdef CONFIG_NEEDS_MANUAL_RELOC
i2c_reloc();
/* Current I/O Device */
static int curr_device;
-int do_ide(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_ide(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
if (argc == 2) {
if (strncmp(argv[1], "res", 3) == 0) {
return blk_common_cmd(argc, argv, IF_TYPE_IDE, &curr_device);
}
-int do_diskboot(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_diskboot(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
return common_diskboot(cmdtp, "ide", argc, argv);
}
return 1;
}
-static int do_ini(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_ini(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
const char *section;
char *file_address;
* Syntax:
* iod{.b, .w, .l} {addr}
*/
-int do_io_iod(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_io_iod(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ulong addr, length, bytes;
u8 buf[DISP_LINE_LEN];
return 0;
}
-int do_io_iow(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_io_iow(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ulong addr, val;
int size;
}
}
-static int do_set_buffer(int argc, char * const argv[])
+static int do_set_buffer(int argc, char *const argv[])
{
ulong addr = 0, size = 0;
return 0;
}
-static int do_set_region(int argc, char * const argv[])
+static int do_set_region(int argc, char *const argv[])
{
ulong addr = 0, size = 0;
return 0;
}
-int do_iotrace(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_iotrace(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
const char *cmd = argc < 2 ? NULL : argv[1];
#include <command.h>
#include <irq_func.h>
-static int do_interrupts(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_interrupts(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc != 2)
);
/* Implemented in $(CPU)/interrupts.c */
-int do_irqinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+int do_irqinfo(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
U_BOOT_CMD(
irqinfo, 1, 1, do_irqinfo,
}
/* command line interface to the shell test */
-static int do_itest(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_itest(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int value, w;
* @param argv arguments list
* @return 0 on success, 1 otherwise
*/
-int do_jffs2_fsload(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_jffs2_fsload(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *fsname;
char *filename;
* @param argv arguments list
* @return 0 on success, 1 otherwise
*/
-int do_jffs2_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_jffs2_ls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *filename = "/";
int ret;
* @param argv arguments list
* @return 0 on success, 1 otherwise
*/
-int do_jffs2_fsinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_jffs2_fsinfo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct part_info *part;
char *fsname;
return 0;
}
-int do_led(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_led(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
enum led_state_t cmd;
const char *led_label;
{
}
-int do_legacy_led(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_legacy_led(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int i, match = 0;
enum led_cmd cmd;
#include "license_data_gz.h"
#include "license_data_size.h"
-static int do_license(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_license(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *dst;
unsigned long len = data_size;
/* -------------------------------------------------------------------- */
#if defined(CONFIG_CMD_LOADS)
-static int do_load_serial(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_load_serial(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
long offset = 0;
ulong addr;
#if defined(CONFIG_CMD_SAVES)
-int do_save_serial (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_save_serial(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong offset = 0;
ulong size = 0;
static char his_pad_char; /* pad chars he needs */
static char his_quote; /* quote chars he'll use */
-static int do_load_serial_bin(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_load_serial_bin(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong offset = 0;
ulong addr;
static char log_fmt_chars[LOGF_COUNT] = "clFLfm";
-static int do_log_level(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_log_level(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc > 1)
gd->default_log_level = simple_strtol(argv[1], NULL, 10);
return 0;
}
-static int do_log_format(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_log_format(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int i;
return 0;
}
-static int do_log_rec(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_log_rec(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
enum log_category_t cat;
enum log_level_t level;
return 0;
}
-static cmd_tbl_t log_sub[] = {
+static struct cmd_tbl log_sub[] = {
U_BOOT_CMD_MKENT(level, CONFIG_SYS_MAXARGS, 1, do_log_level, "", ""),
#ifdef CONFIG_LOG_TEST
U_BOOT_CMD_MKENT(test, 2, 1, do_log_test, "", ""),
U_BOOT_CMD_MKENT(rec, CONFIG_SYS_MAXARGS, 1, do_log_rec, "", ""),
};
-static int do_log(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_log(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
if (argc < 2)
return CMD_RET_USAGE;
#include <lzma/LzmaTools.h>
-static int do_lzmadec(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_lzmadec(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned long src, dst;
SizeT src_len = ~0UL, dst_len = ~0UL;
#include <common.h>
#include <command.h>
-extern int do_mac(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+extern int do_mac(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
U_BOOT_CMD(
mac, 3, 1, do_mac,
return 0;
}
-int do_md5sum(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_md5sum(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ulong addr, len;
unsigned int i;
return 0;
}
#else
-static int do_md5sum(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_md5sum(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned long addr, len;
unsigned int i;
}
/* ---------------------------------------------------------------- */
-static int do_mdio(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mdio(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char op[2];
int addrlo, addrhi, reglo, reghi, devadlo, devadhi;
DECLARE_GLOBAL_DATA_PTR;
-static int mod_mem(cmd_tbl_t *, int, int, int, char * const []);
+#ifndef CONFIG_SYS_MEMTEST_SCRATCH
+#define CONFIG_SYS_MEMTEST_SCRATCH 0
+#endif
+
+static int mod_mem(struct cmd_tbl *, int, int, int, char * const []);
/* Display values from last command.
* Memory modify remembered values are different from display memory.
* md{.b, .w, .l, .q} {addr} {len}
*/
#define DISP_LINE_LEN 16
-static int do_mem_md(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_md(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr, length, bytes;
const void *buf;
return (rc);
}
-static int do_mem_mm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_mm(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return mod_mem (cmdtp, 1, flag, argc, argv);
}
-static int do_mem_nm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+
+static int do_mem_nm(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return mod_mem (cmdtp, 0, flag, argc, argv);
}
-static int do_mem_mw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_mw(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
#ifdef MEM_SUPPORT_64BIT_DATA
u64 writeval;
}
#ifdef CONFIG_CMD_MX_CYCLIC
-static int do_mem_mdc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_mdc(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int i;
ulong count;
return 0;
}
-static int do_mem_mwc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_mwc(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int i;
ulong count;
}
#endif /* CONFIG_CMD_MX_CYCLIC */
-static int do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_cmp(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr1, addr2, count, ngood, bytes;
int size;
return rcode;
}
-static int do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_cp(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr, dest, count;
void *src, *dst;
return 0;
}
-static int do_mem_base(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_mem_base(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc > 1) {
/* Set new base address.
return 0;
}
-static int do_mem_loop(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_mem_loop(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr, length, i, bytes;
int size;
}
#ifdef CONFIG_LOOPW
-static int do_mem_loopw(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_mem_loopw(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr, length, i, bytes;
int size;
* configured using CONFIG_SYS_ALT_MEMTEST. The complete test loops until
* interrupted by ctrl-c or by a failure of one of the sub-tests.
*/
-static int do_mem_mtest(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_mem_mtest(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong start, end;
vu_long scratch_space;
* nm{.b, .w, .l, .q} {addr}
*/
static int
-mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
+mod_mem(struct cmd_tbl *cmdtp, int incrflag, int flag, int argc,
+ char *const argv[])
{
ulong addr;
#ifdef MEM_SUPPORT_64BIT_DATA
#ifdef CONFIG_CMD_CRC32
-static int do_mem_crc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mem_crc(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int flags = 0;
int ac;
#endif
#ifdef CONFIG_CMD_RANDOM
-static int do_random(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_random(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned long addr, len;
unsigned long seed; // NOT INITIALIZED ON PURPOSE
#endif
#ifdef CONFIG_CMD_MEMINFO
-static int do_mem_info(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_mem_info(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
puts("DRAM: ");
print_size(gd->ram_size, "\n");
#include <command.h>
#include <asm/asm.h>
-int do_frd (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_frd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned int fslnum;
unsigned int num;
return 0;
}
-int do_fwr (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_fwr(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned int fslnum;
unsigned int num;
}
-int do_rspr (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+int do_rspr(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned int reg = 0;
unsigned int val = 0;
}
/* ---------------------------------------------------------------- */
-static int do_mii(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mii(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char op[2];
unsigned char addrlo, addrhi, reglo, reghi;
#include <command.h>
#include <console.h>
-static int do_sleep(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_sleep(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong start = get_timer(0);
ulong mdelay = 0;
);
#ifdef CONFIG_CMD_TIMER
-static int do_timer(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_timer(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
static ulong start;
return mmc;
}
-static int do_mmcinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+
+static int do_mmcinfo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct mmc *mmc;
puts("Authentication key programming aborted\n");
return 0;
}
-static int do_mmcrpmb_key(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+
+static int do_mmcrpmb_key(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
void *key_addr;
struct mmc *mmc = find_mmc_device(curr_device);
}
return CMD_RET_SUCCESS;
}
-static int do_mmcrpmb_read(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+
+static int do_mmcrpmb_read(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
u16 blk, cnt;
void *addr;
return CMD_RET_FAILURE;
return CMD_RET_SUCCESS;
}
-static int do_mmcrpmb_write(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+
+static int do_mmcrpmb_write(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
u16 blk, cnt;
void *addr;
return CMD_RET_FAILURE;
return CMD_RET_SUCCESS;
}
-static int do_mmcrpmb_counter(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+
+static int do_mmcrpmb_counter(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
unsigned long counter;
struct mmc *mmc = find_mmc_device(curr_device);
return CMD_RET_SUCCESS;
}
-static cmd_tbl_t cmd_rpmb[] = {
+static struct cmd_tbl cmd_rpmb[] = {
U_BOOT_CMD_MKENT(key, 2, 0, do_mmcrpmb_key, "", ""),
U_BOOT_CMD_MKENT(read, 5, 1, do_mmcrpmb_read, "", ""),
U_BOOT_CMD_MKENT(write, 5, 0, do_mmcrpmb_write, "", ""),
U_BOOT_CMD_MKENT(counter, 1, 1, do_mmcrpmb_counter, "", ""),
};
-static int do_mmcrpmb(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_mmcrpmb(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
struct mmc *mmc;
char original_part;
int ret;
}
#endif
-static int do_mmc_read(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_mmc_read(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
struct mmc *mmc;
u32 blk, cnt, n;
return blkcnt;
}
-static int do_mmc_sparse_write(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_mmc_sparse_write(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
struct sparse_storage sparse;
struct blk_desc *dev_desc;
#endif
#if CONFIG_IS_ENABLED(MMC_WRITE)
-static int do_mmc_write(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_mmc_write(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
struct mmc *mmc;
u32 blk, cnt, n;
return (n == cnt) ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
}
-static int do_mmc_erase(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+
+static int do_mmc_erase(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
struct mmc *mmc;
u32 blk, cnt, n;
}
#endif
-static int do_mmc_rescan(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_mmc_rescan(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
struct mmc *mmc;
return CMD_RET_SUCCESS;
}
-static int do_mmc_part(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+
+static int do_mmc_part(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
struct blk_desc *mmc_dev;
struct mmc *mmc;
puts("get mmc type error!\n");
return CMD_RET_FAILURE;
}
-static int do_mmc_dev(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+
+static int do_mmc_dev(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
int dev, part = 0, ret;
struct mmc *mmc;
return CMD_RET_SUCCESS;
}
-static int do_mmc_list(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+
+static int do_mmc_list(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
print_mmc_devices('\n');
return CMD_RET_SUCCESS;
#if CONFIG_IS_ENABLED(MMC_HW_PARTITIONING)
static int parse_hwpart_user(struct mmc_hwpart_conf *pconf,
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
int i = 0;
}
static int parse_hwpart_gp(struct mmc_hwpart_conf *pconf, int pidx,
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
int i;
return i;
}
-static int do_mmc_hwpartition(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_mmc_hwpartition(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
struct mmc *mmc;
struct mmc_hwpart_conf pconf = { };
#endif
#ifdef CONFIG_SUPPORT_EMMC_BOOT
-static int do_mmc_bootbus(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_mmc_bootbus(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
int dev;
struct mmc *mmc;
/* acknowledge to be sent during boot operation */
return mmc_set_boot_bus_width(mmc, width, reset, mode);
}
-static int do_mmc_boot_resize(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+
+static int do_mmc_boot_resize(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
int dev;
struct mmc *mmc;
return CMD_RET_SUCCESS;
}
-static int do_mmc_partconf(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_mmc_partconf(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
int dev;
struct mmc *mmc;
/* acknowledge to be sent during boot operation */
return mmc_set_part_conf(mmc, ack, part_num, access);
}
-static int do_mmc_rst_func(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+
+static int do_mmc_rst_func(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
int dev;
struct mmc *mmc;
return mmc_set_rst_n_function(mmc, enable);
}
#endif
-static int do_mmc_setdsr(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_mmc_setdsr(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
struct mmc *mmc;
u32 val;
}
#ifdef CONFIG_CMD_BKOPS_ENABLE
-static int do_mmc_bkops_enable(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_mmc_bkops_enable(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
int dev;
struct mmc *mmc;
}
#endif
-static int do_mmc_boot_wp(cmd_tbl_t *cmdtp, int flag,
+static int do_mmc_boot_wp(struct cmd_tbl *cmdtp, int flag,
int argc, char * const argv[])
{
int err;
return CMD_RET_SUCCESS;
}
-static cmd_tbl_t cmd_mmc[] = {
+static struct cmd_tbl cmd_mmc[] = {
U_BOOT_CMD_MKENT(info, 1, 0, do_mmcinfo, "", ""),
U_BOOT_CMD_MKENT(read, 4, 1, do_mmc_read, "", ""),
U_BOOT_CMD_MKENT(wp, 1, 0, do_mmc_boot_wp, "", ""),
#endif
};
-static int do_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mmcops(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
cp = find_cmd_tbl(argv[1], cmd_mmc, ARRAY_SIZE(cmd_mmc));
}
static int
-cpu_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+cpu_cmd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned long cpuid;
return true;
}
-static int do_mtd_list(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_mtd_list(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct mtd_info *mtd;
int dev_nb = 0;
return ret;
}
-static int do_mtd_io(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mtd_io(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
bool dump, read, raw, woob, write_empty_pages, has_pages = false;
u64 start_off, off, len, remaining, default_len;
return ret;
}
-static int do_mtd_erase(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_mtd_erase(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct erase_info erase_op = {};
struct mtd_info *mtd;
return ret;
}
-static int do_mtd_bad(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_mtd_bad(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct mtd_info *mtd;
loff_t off;
}
#ifdef CONFIG_AUTO_COMPLETE
-static int mtd_name_complete(int argc, char * const argv[], char last_char,
+static int mtd_name_complete(int argc, char *const argv[], char last_char,
int maxv, char *cmdv[])
{
int len = 0, n_found = 0;
* @param argv arguments list
* @return 0 on success, 1 otherwise
*/
-static int do_chpart(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_chpart(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
/* command line only */
struct mtd_device *dev;
* @param argv arguments list
* @return 0 on success, 1 otherwise
*/
-static int do_mtdparts(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_mtdparts(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc == 2) {
if (strcmp(argv[1], "default") == 0) {
#endif
#endif /* DEFAULT_BUBT_DST */
-int do_bubt_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_bubt_cmd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct bubt_dev *src, *dst;
size_t image_size;
#ifdef CONFIG_ENV_OFFSET_OOB
unsigned long nand_env_oob_offset;
-int do_nand_env_oob(cmd_tbl_t *cmdtp, int argc, char *const argv[])
+int do_nand_env_oob(struct cmd_tbl *cmdtp, int argc, char *const argv[])
{
int ret;
uint32_t oob_buf[ENV_OFFSET_SIZE/sizeof(uint32_t)];
}
}
-static int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_nand(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int i, ret = 0;
ulong addr;
"NAND sub-system", nand_help_text
);
-static int nand_load_image(cmd_tbl_t *cmdtp, struct mtd_info *mtd,
+static int nand_load_image(struct cmd_tbl *cmdtp, struct mtd_info *mtd,
ulong offset, ulong addr, char *cmd)
{
int r;
return bootm_maybe_autostart(cmdtp, cmd);
}
-static int do_nandboot(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_nandboot(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *boot_device = NULL;
int idx;
#include <image.h>
#include <net.h>
-static int netboot_common(enum proto_t, cmd_tbl_t *, int, char * const []);
+static int netboot_common(enum proto_t, struct cmd_tbl *, int, char * const []);
#ifdef CONFIG_CMD_BOOTP
-static int do_bootp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_bootp(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return netboot_common(BOOTP, cmdtp, argc, argv);
}
#endif
#ifdef CONFIG_CMD_TFTPBOOT
-int do_tftpb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_tftpb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int ret;
#endif
#ifdef CONFIG_CMD_TFTPPUT
-static int do_tftpput(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_tftpput(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return netboot_common(TFTPPUT, cmdtp, argc, argv);
}
#endif
#ifdef CONFIG_CMD_TFTPSRV
-static int do_tftpsrv(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_tftpsrv(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return netboot_common(TFTPSRV, cmdtp, argc, argv);
}
#ifdef CONFIG_CMD_RARP
-int do_rarpb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_rarpb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
return netboot_common(RARP, cmdtp, argc, argv);
}
#endif
#if defined(CONFIG_CMD_DHCP)
-static int do_dhcp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_dhcp(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return netboot_common(DHCP, cmdtp, argc, argv);
}
#endif
#if defined(CONFIG_CMD_NFS)
-static int do_nfs(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_nfs(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return netboot_common(NFS, cmdtp, argc, argv);
}
#endif
}
-static int netboot_common(enum proto_t proto, cmd_tbl_t *cmdtp, int argc,
- char * const argv[])
+static int netboot_common(enum proto_t proto, struct cmd_tbl *cmdtp, int argc,
+ char *const argv[])
{
char *s;
char *end;
}
#if defined(CONFIG_CMD_PING)
-static int do_ping(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_ping(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc < 2)
return CMD_RET_USAGE;
}
}
-int do_cdp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_cdp(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int r;
#endif
#if defined(CONFIG_CMD_SNTP)
-int do_sntp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_sntp(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *toff;
#endif
#if defined(CONFIG_CMD_DNS)
-int do_dns(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_dns(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
if (argc == 1)
return CMD_RET_USAGE;
#endif /* CONFIG_CMD_DNS */
#if defined(CONFIG_CMD_LINK_LOCAL)
-static int do_link_local(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_link_local(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char tmp[22];
return 0;
}
-static int do_env_print(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_env_print(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int i;
int rcode = 0;
}
#ifdef CONFIG_CMD_GREPENV
-static int do_env_grep(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_env_grep(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
char *res = NULL;
int len, grep_how, grep_what;
* Set a new environment variable,
* or replace or delete an existing one.
*/
-static int _do_env_set(int flag, int argc, char * const argv[], int env_flag)
+static int _do_env_set(int flag, int argc, char *const argv[], int env_flag)
{
int i, len;
char *name, *value, *s;
}
#ifndef CONFIG_SPL_BUILD
-static int do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_env_set(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc < 2)
return CMD_RET_USAGE;
* Prompt for environment variable
*/
#if defined(CONFIG_CMD_ASKENV)
-int do_env_ask(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_env_ask(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char message[CONFIG_SYS_CBSIZE];
int i, len, pos, size;
/*
* Print the callbacks available and what they are bound to
*/
-int do_env_callback(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_env_callback(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct env_clbk_tbl *clbkp;
int i;
/*
* Print the flags available and what variables have flags
*/
-int do_env_flags(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_env_flags(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
/* Print the available variable types */
printf("Available variable type flags (position %d):\n",
* Interactively edit an environment variable
*/
#if defined(CONFIG_CMD_EDITENV)
-static int do_env_edit(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_env_edit(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char buffer[CONFIG_SYS_CBSIZE];
char *init_val;
#ifndef CONFIG_SPL_BUILD
#if defined(CONFIG_CMD_SAVEENV) && defined(ENV_IS_IN_DEVICE)
-static int do_env_save(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_env_save(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return env_save() ? 1 : 0;
}
);
#if defined(CONFIG_CMD_ERASEENV)
-static int do_env_erase(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_env_erase(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return env_erase() ? 1 : 0;
}
}
#ifndef CONFIG_SPL_BUILD
-static int do_env_default(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_env_default(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
int all = 0, env_flag = H_INTERACTIVE;
return cmd_usage(cmdtp);
}
-static int do_env_delete(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_env_delete(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
int env_flag = H_INTERACTIVE;
int ret = 0;
*
* => env import -d -t ${backup_addr}
*/
-static int do_env_export(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_env_export(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
char buf[32];
ulong addr;
* the environment at address 'addr'. Without arguments, the whole
* environment gets imported.
*/
-static int do_env_import(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_env_import(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
ulong addr;
char *cmd, *ptr;
* env info [-d] - evaluate whether default environment is used
* env info [-p] - evaluate whether environment can be persisted
*/
-static int do_env_info(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_env_info(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
int eval_flags = 0;
int eval_results = 0;
#endif
#if defined(CONFIG_CMD_ENV_EXISTS)
-static int do_env_exists(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_env_exists(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct env_entry e, *ep;
/*
* New command line interface: "env" command with subcommands
*/
-static cmd_tbl_t cmd_env_sub[] = {
+static struct cmd_tbl cmd_env_sub[] = {
#if defined(CONFIG_CMD_ASKENV)
U_BOOT_CMD_MKENT(ask, CONFIG_SYS_MAXARGS, 1, do_env_ask, "", ""),
#endif
}
#endif
-static int do_env(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_env(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
if (argc < 2)
return CMD_RET_USAGE;
*
* Show information encoded in named UEFI variables
*/
-static int efi_dump_vars(int argc, char * const argv[],
+static int efi_dump_vars(int argc, char *const argv[],
const efi_guid_t *guid, bool verbose)
{
u16 *var_name16, *p;
return CMD_RET_SUCCESS;
}
-static bool match_name(int argc, char * const argv[], u16 *var_name16)
+static bool match_name(int argc, char *const argv[], u16 *var_name16)
{
char *buf, *p;
size_t buflen;
*
* Show information encoded in all the UEFI variables
*/
-static int efi_dump_var_all(int argc, char * const argv[],
+static int efi_dump_var_all(int argc, char *const argv[],
const efi_guid_t *guid_p, bool verbose)
{
u16 *var_name16, *p;
* If one or more variable names are specified, show information
* named UEFI variables, otherwise show all the UEFI variables.
*/
-int do_env_print_efi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_env_print_efi(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
efi_guid_t guid;
const efi_guid_t *guid_p;
* Encode values specified and set given UEFI variable.
* If no value is specified, delete the variable.
*/
-int do_env_set_efi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_env_set_efi(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *var_name, *value, *ep;
ulong addr;
static int nvme_curr_dev;
-static int do_nvme(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_nvme(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret;
static loff_t next_ofs;
static loff_t skip_ofs;
-static int arg_off_size_onenand(int argc, char * const argv[], ulong *off,
+static int arg_off_size_onenand(int argc, char *const argv[], ulong *off,
size_t *size)
{
if (argc >= 1) {
return 0;
}
-static int do_onenand_info(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_onenand_info(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
printf("%s\n", mtd->name);
return 0;
}
-static int do_onenand_bad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_onenand_bad(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong ofs;
return 0;
}
-static int do_onenand_read(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_onenand_read(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *s;
int oob = 0;
return ret == 0 ? 0 : 1;
}
-static int do_onenand_write(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_onenand_write(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr, ofs;
size_t len;
return ret == 0 ? 0 : 1;
}
-static int do_onenand_erase(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_onenand_erase(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong ofs;
int ret = 0;
return ret == 0 ? 0 : 1;
}
-static int do_onenand_test(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_onenand_test(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong ofs;
int ret = 0;
return ret == 0 ? 0 : 1;
}
-static int do_onenand_dump(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_onenand_dump(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong ofs;
int ret = 0;
return ret == 0 ? 1 : 0;
}
-static int do_onenand_markbad(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_onenand_markbad(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret = 0;
ulong addr;
return ret;
}
-static cmd_tbl_t cmd_onenand_sub[] = {
+static struct cmd_tbl cmd_onenand_sub[] = {
U_BOOT_CMD_MKENT(info, 1, 0, do_onenand_info, "", ""),
U_BOOT_CMD_MKENT(bad, 1, 0, do_onenand_bad, "", ""),
U_BOOT_CMD_MKENT(read, 4, 0, do_onenand_read, "", ""),
}
#endif
-static int do_onenand(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+static int do_onenand(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
if (argc < 2)
return CMD_RET_USAGE;
*/
#include <common.h>
+#include <command.h>
#include <dm.h>
#include <hexdump.h>
#include <video_osd.h>
printf("\n");
}
-static int do_osd_write(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_osd_write(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
uint x, y;
uint count;
return CMD_RET_SUCCESS;
}
-static int do_osd_print(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_osd_print(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
uint x, y;
u8 color;
return CMD_RET_SUCCESS;
}
-static int do_osd_size(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_osd_size(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
uint x, y;
int res;
return CMD_RET_SUCCESS;
}
-static int do_show_osd(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_show_osd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *osd;
return CMD_RET_SUCCESS;
}
-static int do_osd_num(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_osd_num(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int osd_no;
int res = 0;
return res ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
}
-static cmd_tbl_t cmd_osd_sub[] = {
+static struct cmd_tbl cmd_osd_sub[] = {
U_BOOT_CMD_MKENT(show, 1, 1, do_show_osd, "", ""),
U_BOOT_CMD_MKENT(dev, 1, 1, do_osd_num, "", ""),
U_BOOT_CMD_MKENT(write, 4, 1, do_osd_write, "", ""),
U_BOOT_CMD_MKENT(size, 2, 1, do_osd_size, "", ""),
};
-static int do_osd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_osd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
if (argc < 2)
return CMD_RET_USAGE;
CMD_PART_INFO_NUMBER
};
-static int do_part_uuid(int argc, char * const argv[])
+static int do_part_uuid(int argc, char *const argv[])
{
int part;
struct blk_desc *dev_desc;
return 0;
}
-static int do_part_list(int argc, char * const argv[])
+static int do_part_list(int argc, char *const argv[])
{
int ret;
struct blk_desc *desc;
return 0;
}
-static int do_part_info(int argc, char * const argv[], enum cmd_part_info param)
+static int do_part_info(int argc, char *const argv[], enum cmd_part_info param)
{
struct blk_desc *desc;
struct disk_partition info;
return 0;
}
-static int do_part_start(int argc, char * const argv[])
+static int do_part_start(int argc, char *const argv[])
{
return do_part_info(argc, argv, CMD_PART_INFO_START);
}
-static int do_part_size(int argc, char * const argv[])
+static int do_part_size(int argc, char *const argv[])
{
return do_part_info(argc, argv, CMD_PART_INFO_SIZE);
}
-static int do_part_number(int argc, char * const argv[])
+static int do_part_number(int argc, char *const argv[])
{
return do_part_info(argc, argv, CMD_PART_INFO_NUMBER);
}
-static int do_part(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_part(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc < 2)
return CMD_RET_USAGE;
#include <net.h>
#include <net/pcap.h>
-static int do_pcap_init(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_pcap_init(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
phys_addr_t addr;
unsigned int size;
return pcap_init(addr, size) ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
}
-static int do_pcap_start(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_pcap_start(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return pcap_start_stop(true) ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
}
-static int do_pcap_stop(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_pcap_stop(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return pcap_start_stop(false) ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
}
-static int do_pcap_status(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_pcap_status(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return pcap_print_status() ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
}
-static int do_pcap_clear(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_pcap_clear(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return pcap_clear() ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
}
* pci modify[.b, .w, .l] bus.device.function [addr]
* pci write[.b, .w, .l] bus.device.function addr value
*/
-static int do_pci(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_pci(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ulong addr = 0, value = 0, cmd_size = 0;
enum pci_size_t size = PCI_SIZE_32;
static struct udevice *currdev;
-static int do_dev(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_dev(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *name;
int ret;
return 0;
}
-static int do_status(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_status(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
int ret = CMD_RET_USAGE;
return ret;
}
-static int do_list(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_list(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
return CMD_RET_SUCCESS;
}
-static cmd_tbl_t pinmux_subcmd[] = {
+static struct cmd_tbl pinmux_subcmd[] = {
U_BOOT_CMD_MKENT(dev, 2, 1, do_dev, "", ""),
U_BOOT_CMD_MKENT(list, 1, 1, do_list, "", ""),
U_BOOT_CMD_MKENT(status, 2, 1, do_status, "", ""),
};
-static int do_pinmux(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_pinmux(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *cmd;
+ struct cmd_tbl *cmd;
argc--;
argv++;
return 0;
}
-static int do_pmc_init(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_pmc_init(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
int ret;
return 0;
}
-static int do_pmc_info(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_pmc_info(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
int ret;
return 0;
}
-static cmd_tbl_t cmd_pmc_sub[] = {
+static struct cmd_tbl cmd_pmc_sub[] = {
U_BOOT_CMD_MKENT(init, 0, 1, do_pmc_init, "", ""),
U_BOOT_CMD_MKENT(info, 0, 1, do_pmc_info, "", ""),
};
-static int do_pmc(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_pmc(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- const cmd_tbl_t *cp;
+ const struct cmd_tbl *cp;
if (argc < 2) /* no subcommand */
return cmd_usage(cmdtp);
* Przemyslaw Marczak <p.marczak@samsung.com>
*/
#include <common.h>
+#include <command.h>
#include <errno.h>
#include <dm.h>
#include <dm/uclass-internal.h>
return CMD_RET_FAILURE;
}
-static int do_dev(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_dev(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *name;
int ret = -ENODEV;
return CMD_RET_SUCCESS;
}
-static int do_list(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_list(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
int ret;
return CMD_RET_SUCCESS;
}
-static int do_dump(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_dump(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct uc_pmic_priv *priv;
struct udevice *dev;
return CMD_RET_SUCCESS;
}
-static int do_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_read(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct uc_pmic_priv *priv;
struct udevice *dev;
return CMD_RET_SUCCESS;
}
-static int do_write(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_write(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
uint reg, value;
return CMD_RET_SUCCESS;
}
-static cmd_tbl_t subcmd[] = {
+static struct cmd_tbl subcmd[] = {
U_BOOT_CMD_MKENT(dev, 2, 1, do_dev, "", ""),
U_BOOT_CMD_MKENT(list, 1, 1, do_list, "", ""),
U_BOOT_CMD_MKENT(dump, 1, 1, do_dump, "", ""),
U_BOOT_CMD_MKENT(write, 3, 1, do_write, "", ""),
};
-static int do_pmic(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_pmic(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *cmd;
+ struct cmd_tbl *cmd;
argc--;
argv++;
NULL
};
-static int do_get_tftp(cmd_tbl_t *cmdtp, const char *file_path, char *file_addr)
+static int do_get_tftp(struct cmd_tbl *cmdtp, const char *file_path,
+ char *file_addr)
{
char *tftp_argv[] = {"tftp", NULL, NULL, NULL};
*
* Returns 1 on success or < 0 on error.
*/
-static int pxe_uuid_path(cmd_tbl_t *cmdtp, unsigned long pxefile_addr_r)
+static int pxe_uuid_path(struct cmd_tbl *cmdtp, unsigned long pxefile_addr_r)
{
char *uuid_str;
*
* Returns 1 on success or < 0 on error.
*/
-static int pxe_mac_path(cmd_tbl_t *cmdtp, unsigned long pxefile_addr_r)
+static int pxe_mac_path(struct cmd_tbl *cmdtp, unsigned long pxefile_addr_r)
{
char mac_str[21];
int err;
*
* Returns 1 on success or < 0 on error.
*/
-static int pxe_ipaddr_paths(cmd_tbl_t *cmdtp, unsigned long pxefile_addr_r)
+static int pxe_ipaddr_paths(struct cmd_tbl *cmdtp, unsigned long pxefile_addr_r)
{
char ip_addr[9];
int mask_pos, err;
* Returns 0 on success or 1 on error.
*/
static int
-do_pxe_get(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+do_pxe_get(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *pxefile_addr_str;
unsigned long pxefile_addr_r;
* Returns 0 on success, 1 on error.
*/
static int
-do_pxe_boot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+do_pxe_boot(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned long pxefile_addr_r;
struct pxe_menu *cfg;
return 0;
}
-static cmd_tbl_t cmd_pxe_sub[] = {
+static struct cmd_tbl cmd_pxe_sub[] = {
U_BOOT_CMD_MKENT(get, 1, 1, do_pxe_get, "", ""),
U_BOOT_CMD_MKENT(boot, 2, 1, do_pxe_boot, "", "")
};
-static int do_pxe(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_pxe(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
if (argc < 2)
return CMD_RET_USAGE;
*/
#include <common.h>
+#include <command.h>
#include <env.h>
#include <image.h>
#include <malloc.h>
return 1;
}
-int (*do_getfile)(cmd_tbl_t *cmdtp, const char *file_path, char *file_addr);
+int (*do_getfile)(struct cmd_tbl *cmdtp, const char *file_path,
+ char *file_addr);
/*
* As in pxelinux, paths to files referenced from files we retrieve are
*
* Returns 1 for success, or < 0 on error.
*/
-static int get_relfile(cmd_tbl_t *cmdtp, const char *file_path,
+static int get_relfile(struct cmd_tbl *cmdtp, const char *file_path,
unsigned long file_addr)
{
size_t path_len;
*
* Returns 1 on success, or < 0 for error.
*/
-int get_pxe_file(cmd_tbl_t *cmdtp, const char *file_path,
+int get_pxe_file(struct cmd_tbl *cmdtp, const char *file_path,
unsigned long file_addr)
{
unsigned long config_file_size;
*
* Returns 1 on success or < 0 on error.
*/
-int get_pxelinux_path(cmd_tbl_t *cmdtp, const char *file,
+int get_pxelinux_path(struct cmd_tbl *cmdtp, const char *file,
unsigned long pxefile_addr_r)
{
size_t base_len = strlen(PXELINUX_DIR);
*
* Returns 1 on success or < 0 on error.
*/
-static int get_relfile_envaddr(cmd_tbl_t *cmdtp, const char *file_path,
+static int get_relfile_envaddr(struct cmd_tbl *cmdtp, const char *file_path,
const char *envaddr_name)
{
unsigned long file_addr;
* If the label specifies an 'append' line, its contents will overwrite that
* of the 'bootargs' environment variable.
*/
-static int label_boot(cmd_tbl_t *cmdtp, struct pxe_label *label)
+static int label_boot(struct cmd_tbl *cmdtp, struct pxe_label *label)
{
char *bootm_argv[] = { "bootm", NULL, NULL, NULL, NULL };
char initrd_str[28];
return 1;
}
-static int parse_pxefile_top(cmd_tbl_t *cmdtp, char *p, unsigned long base,
+static int parse_pxefile_top(struct cmd_tbl *cmdtp, char *p, unsigned long base,
struct pxe_menu *cfg, int nest_level);
/*
* include, nest_level has already been incremented and doesn't need to be
* incremented here.
*/
-static int handle_include(cmd_tbl_t *cmdtp, char **c, unsigned long base,
+static int handle_include(struct cmd_tbl *cmdtp, char **c, unsigned long base,
struct pxe_menu *cfg, int nest_level)
{
char *include_path;
* nest_level should be 1 when parsing the top level pxe file, 2 when parsing
* a file it includes, 3 when parsing a file included by that file, and so on.
*/
-static int parse_menu(cmd_tbl_t *cmdtp, char **c, struct pxe_menu *cfg,
+static int parse_menu(struct cmd_tbl *cmdtp, char **c, struct pxe_menu *cfg,
unsigned long base, int nest_level)
{
struct token t;
*
* Returns 1 on success, < 0 on error.
*/
-static int parse_pxefile_top(cmd_tbl_t *cmdtp, char *p, unsigned long base,
+static int parse_pxefile_top(struct cmd_tbl *cmdtp, char *p, unsigned long base,
struct pxe_menu *cfg, int nest_level)
{
struct token t;
* files it includes). The resulting pxe_menu struct can be free()'d by using
* the destroy_pxe_menu() function.
*/
-struct pxe_menu *parse_pxefile(cmd_tbl_t *cmdtp, unsigned long menucfg)
+struct pxe_menu *parse_pxefile(struct cmd_tbl *cmdtp, unsigned long menucfg)
{
struct pxe_menu *cfg;
char *buf;
/*
* Try to boot any labels we have yet to attempt to boot.
*/
-static void boot_unattempted_labels(cmd_tbl_t *cmdtp, struct pxe_menu *cfg)
+static void boot_unattempted_labels(struct cmd_tbl *cmdtp, struct pxe_menu *cfg)
{
struct list_head *pos;
struct pxe_label *label;
* If this function returns, there weren't any labels that successfully
* booted, or the user interrupted the menu selection via ctrl+c.
*/
-void handle_pxe_menu(cmd_tbl_t *cmdtp, struct pxe_menu *cfg)
+void handle_pxe_menu(struct cmd_tbl *cmdtp, struct pxe_menu *cfg)
{
void *choice;
struct menu *m;
extern bool is_pxe;
-extern int (*do_getfile)(cmd_tbl_t *cmdtp, const char *file_path,
+extern int (*do_getfile)(struct cmd_tbl *cmdtp, const char *file_path,
char *file_addr);
void destroy_pxe_menu(struct pxe_menu *cfg);
-int get_pxe_file(cmd_tbl_t *cmdtp, const char *file_path,
+int get_pxe_file(struct cmd_tbl *cmdtp, const char *file_path,
unsigned long file_addr);
-int get_pxelinux_path(cmd_tbl_t *cmdtp, const char *file,
+int get_pxelinux_path(struct cmd_tbl *cmdtp, const char *file,
unsigned long pxefile_addr_r);
-void handle_pxe_menu(cmd_tbl_t *cmdtp, struct pxe_menu *cfg);
-struct pxe_menu *parse_pxefile(cmd_tbl_t *cmdtp, unsigned long menucfg);
+void handle_pxe_menu(struct cmd_tbl *cmdtp, struct pxe_menu *cfg);
+struct pxe_menu *parse_pxefile(struct cmd_tbl *cmdtp, unsigned long menucfg);
int format_mac_pxe(char *outbuf, size_t outbuf_len);
#endif /* __PXE_UTILS_H */
return 0;
}
-static int qemu_fwcfg_do_list(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int qemu_fwcfg_do_list(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
if (qemu_fwcfg_list_firmware() < 0)
return CMD_RET_FAILURE;
return 0;
}
-static int qemu_fwcfg_do_cpus(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int qemu_fwcfg_do_cpus(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
int ret = qemu_fwcfg_online_cpus();
if (ret < 0) {
return 0;
}
-static int qemu_fwcfg_do_load(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int qemu_fwcfg_do_load(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
char *env;
void *load_addr;
return qemu_fwcfg_setup_kernel(load_addr, initrd_addr);
}
-static cmd_tbl_t fwcfg_commands[] = {
+static struct cmd_tbl fwcfg_commands[] = {
U_BOOT_CMD_MKENT(list, 0, 1, qemu_fwcfg_do_list, "", ""),
U_BOOT_CMD_MKENT(cpus, 0, 1, qemu_fwcfg_do_cpus, "", ""),
U_BOOT_CMD_MKENT(load, 2, 1, qemu_fwcfg_do_load, "", ""),
};
-static int do_qemu_fw(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_qemu_fw(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret;
- cmd_tbl_t *fwcfg_cmd;
+ struct cmd_tbl *fwcfg_cmd;
if (!qemu_fwcfg_present()) {
printf("QEMU fw_cfg interface not found\n");
#include <command.h>
#include <part.h>
-int do_read(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_read(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *ep;
struct blk_desc *dev_desc = NULL;
#include <command.h>
#include <asm/ppc.h>
-static int do_reginfo(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_reginfo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
print_reginfo();
* Przemyslaw Marczak <p.marczak@samsung.com>
*/
#include <common.h>
+#include <command.h>
#include <errno.h>
#include <dm.h>
#include <dm/uclass-internal.h>
return CMD_RET_FAILURE;
}
-static int do_dev(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_dev(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct dm_regulator_uclass_platdata *uc_pdata;
const char *name;
return CMD_RET_SUCCESS;
}
-static int do_list(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_list(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct dm_regulator_uclass_platdata *uc_pdata;
struct udevice *dev;
return NULL;
}
-static int do_info(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_info(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
struct dm_regulator_uclass_platdata *uc_pdata;
printf("\n");
}
-static int do_status(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_status(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct dm_regulator_uclass_platdata *uc_pdata;
struct udevice *dev;
return CMD_RET_SUCCESS;
}
-static int do_value(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_value(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
struct dm_regulator_uclass_platdata *uc_pdata;
return CMD_RET_SUCCESS;
}
-static int do_current(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_current(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
struct dm_regulator_uclass_platdata *uc_pdata;
return CMD_RET_SUCCESS;
}
-static int do_mode(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mode(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
struct dm_regulator_uclass_platdata *uc_pdata;
return CMD_RET_SUCCESS;
}
-static int do_enable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_enable(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
struct dm_regulator_uclass_platdata *uc_pdata;
return CMD_RET_SUCCESS;
}
-static int do_disable(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_disable(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
struct dm_regulator_uclass_platdata *uc_pdata;
return CMD_RET_SUCCESS;
}
-static cmd_tbl_t subcmd[] = {
+static struct cmd_tbl subcmd[] = {
U_BOOT_CMD_MKENT(dev, 2, 1, do_dev, "", ""),
U_BOOT_CMD_MKENT(list, 1, 1, do_list, "", ""),
U_BOOT_CMD_MKENT(info, 2, 1, do_info, "", ""),
U_BOOT_CMD_MKENT(disable, 1, 1, do_disable, "", ""),
};
-static int do_regulator(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_regulator(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *cmd;
+ struct cmd_tbl *cmd;
argc--;
argv++;
#define PRINTF(fmt,args...)
#endif
-int do_reiserls (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reiserls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *filename = "/";
int dev, part;
/******************************************************************************
* Reiserfs boot command intepreter. Derived from diskboot
*/
-int do_reiserload (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reiserload(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *filename = NULL;
int dev, part;
*
* Return: 0 if no error, else returns appropriate error value.
*/
-static int do_rproc_init(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_rproc_init(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int id;
*
* Return: 0 if no error, else returns appropriate error value.
*/
-static int do_remoteproc_list(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_remoteproc_list(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
if (print_remoteproc_list())
*
* Return: 0 if no error, else returns appropriate error value.
*/
-static int do_remoteproc_load(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_remoteproc_load(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
ulong addr, size;
*
* Return: 0 if no error, else returns appropriate error value.
*/
-static int do_remoteproc_wrapper(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_remoteproc_wrapper(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int id, ret = CMD_RET_USAGE;
return ret ? CMD_RET_FAILURE : 0;
}
-static cmd_tbl_t cmd_remoteproc_sub[] = {
+static struct cmd_tbl cmd_remoteproc_sub[] = {
U_BOOT_CMD_MKENT(init, 1, 1, do_rproc_init,
"Enumerate and initialize the remote processor(s)",
"id - ID of the remote processor\n"
*
* Return: 0 if no error, else returns appropriate error value.
*/
-static int do_remoteproc(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_remoteproc(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
- cmd_tbl_t *c = NULL;
+ struct cmd_tbl *c = NULL;
/* Strip off leading 'rproc' command argument */
argc--;
#include <common.h>
#include <command.h>
-static int do_undefined(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_undefined(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
asm volatile (".word 0xffffffff\n");
return CMD_RET_FAILURE;
}
-static cmd_tbl_t cmd_sub[] = {
+static struct cmd_tbl cmd_sub[] = {
U_BOOT_CMD_MKENT(undefined, CONFIG_SYS_MAXARGS, 1, do_undefined,
"", ""),
};
#include <malloc.h>
#include <rng.h>
-static int do_rng(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_rng(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
size_t n = 0x40;
struct udevice *dev;
#include <usb.h>
#include <asm/arch-rockchip/f_rockusb.h>
-static int do_rockusb(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_rockusb(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int controller_index, dev_index;
char *usb_controller;
#endif
}
-static int do_sata(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_sata(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int rc = 0;
*/
#include <common.h>
+#include <command.h>
#include <dm.h>
#include <spl.h>
#include <asm/state.h>
-static int do_sb_handoff(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_sb_handoff(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
#if CONFIG_IS_ENABLED(HANDOFF)
#endif
}
-static int do_sb_state(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_sb_state(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct sandbox_state *state;
return 0;
}
-static cmd_tbl_t cmd_sb_sub[] = {
+static struct cmd_tbl cmd_sb_sub[] = {
U_BOOT_CMD_MKENT(handoff, 1, 0, do_sb_handoff, "", ""),
U_BOOT_CMD_MKENT(state, 1, 0, do_sb_state, "", ""),
};
-static int do_sb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_sb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
/* Skip past 'sb' */
argc--;
/*
* scsi boot command intepreter. Derived from diskboot
*/
-static int do_scsiboot(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_scsiboot(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return common_diskboot(cmdtp, "scsi", argc, argv);
}
/*
* scsi command intepreter
*/
-static int do_scsi(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_scsi(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int ret;
}
#endif
-static int do_setexpr(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_setexpr(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong a, b;
ulong value;
*/
#include <common.h>
+#include <command.h>
#include <div64.h>
#include <dm.h>
#include <flash.h>
return 1024 * len / max(get_timer(start_ms), 1UL);
}
-static int do_spi_flash_probe(int argc, char * const argv[])
+static int do_spi_flash_probe(int argc, char *const argv[])
{
unsigned int bus = CONFIG_SF_DEFAULT_BUS;
unsigned int cs = CONFIG_SF_DEFAULT_CS;
return 0;
}
-static int do_spi_flash_read_write(int argc, char * const argv[])
+static int do_spi_flash_read_write(int argc, char *const argv[])
{
unsigned long addr;
void *buf;
return ret == 0 ? 0 : 1;
}
-static int do_spi_flash_erase(int argc, char * const argv[])
+static int do_spi_flash_erase(int argc, char *const argv[])
{
int ret;
int dev = 0;
return ret == 0 ? 0 : 1;
}
-static int do_spi_protect(int argc, char * const argv[])
+static int do_spi_protect(int argc, char *const argv[])
{
int ret = 0;
loff_t start, len;
return 0;
}
-static int do_spi_flash_test(int argc, char * const argv[])
+static int do_spi_flash_test(int argc, char *const argv[])
{
unsigned long offset;
unsigned long len;
}
#endif /* CONFIG_CMD_SF_TEST */
-static int do_spi_flash(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_spi_flash(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *cmd;
int ret;
#include <hash.h>
#include <u-boot/sha1.h>
-int do_sha1sum(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_sha1sum(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int flags = HASH_FLAG_ENV;
int ac;
#include <linux/compiler.h>
#include <linux/psci.h>
-static int do_call(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_call(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct arm_smccc_res res;
DECLARE_GLOBAL_DATA_PTR;
/* Initilaise sound subsystem */
-static int do_init(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_init(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
int ret;
}
/* play sound from buffer */
-static int do_play(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_play(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
int ret = 0;
return 0;
}
-static cmd_tbl_t cmd_sound_sub[] = {
+static struct cmd_tbl cmd_sound_sub[] = {
U_BOOT_CMD_MKENT(init, 0, 1, do_init, "", ""),
U_BOOT_CMD_MKENT(play, 2, 1, do_play, "", ""),
};
/* process sound command */
-static int do_sound(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+static int do_sound(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
if (argc < 1)
return CMD_RET_USAGE;
/**************************************************/
#if defined(CONFIG_CMD_SOURCE)
-static int do_source(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_source(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong addr;
int rcode;
* The command prints out the hexadecimal string received via SPI.
*/
-int do_spi (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_spi(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *cp = 0;
uchar tmp;
};
/* Calls bootm with the parameters given */
-static int call_bootm(int argc, char * const argv[], const char *subcommand[])
+static int call_bootm(int argc, char *const argv[], const char *subcommand[])
{
char *bootm_argv[5];
return 0;
}
-static cmd_tbl_t cmd_spl_export_sub[] = {
+static struct cmd_tbl cmd_spl_export_sub[] = {
U_BOOT_CMD_MKENT(fdt, 0, 1, (void *)SPL_EXPORT_FDT, "", ""),
U_BOOT_CMD_MKENT(atags, 0, 1, (void *)SPL_EXPORT_ATAGS, "", ""),
};
-static int spl_export(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int spl_export(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- const cmd_tbl_t *c;
+ const struct cmd_tbl *c;
if (argc < 2) /* no subcommand */
return cmd_usage(cmdtp);
return 0;
}
-static cmd_tbl_t cmd_spl_sub[] = {
+static struct cmd_tbl cmd_spl_sub[] = {
U_BOOT_CMD_MKENT(export, 0, 1, (void *)SPL_EXPORT, "", ""),
};
-static int do_spl(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_spl(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- const cmd_tbl_t *c;
+ const struct cmd_tbl *c;
int cmd;
if (argc < 2) /* no subcommand */
static char *start_addr, *last_addr;
-int do_strings(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_strings(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
if (argc == 1)
return CMD_RET_USAGE;
static char *fs_argv[5];
-static int do_get_ext2(cmd_tbl_t *cmdtp, const char *file_path, char *file_addr)
+static int do_get_ext2(struct cmd_tbl *cmdtp, const char *file_path,
+ char *file_addr)
{
#ifdef CONFIG_CMD_EXT2
fs_argv[0] = "ext2load";
return -ENOENT;
}
-static int do_get_fat(cmd_tbl_t *cmdtp, const char *file_path, char *file_addr)
+static int do_get_fat(struct cmd_tbl *cmdtp, const char *file_path,
+ char *file_addr)
{
#ifdef CONFIG_CMD_FAT
fs_argv[0] = "fatload";
return -ENOENT;
}
-static int do_get_any(cmd_tbl_t *cmdtp, const char *file_path, char *file_addr)
+static int do_get_any(struct cmd_tbl *cmdtp, const char *file_path,
+ char *file_addr)
{
#ifdef CONFIG_CMD_FS_GENERIC
fs_argv[0] = "load";
*
* Returns 0 on success, 1 on error.
*/
-static int do_sysboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_sysboot(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned long pxefile_addr_r;
struct pxe_menu *cfg;
#include <stdio_dev.h>
#include <serial.h>
-int do_terminal(cmd_tbl_t * cmd, int flag, int argc, char * const argv[])
+int do_terminal(struct cmd_tbl *cmd, int flag, int argc, char *const argv[])
{
int last_tilde = 0;
struct stdio_dev *dev = NULL;
{0, "-e", OP_FILE_EXISTS, 4},
};
-static int do_test(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_test(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char * const *ap;
int i, op, left, adv, expr, last_expr, last_unop, last_binop;
"[args..]"
);
-static int do_false(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_false(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return 1;
}
NULL
);
-static int do_true(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_true(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return 0;
}
*/
#include <common.h>
+#include <command.h>
#include <thor.h>
#include <dfu.h>
#include <g_dnl.h>
#include <usb.h>
-int do_thor_down(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_thor_down(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
if (argc < 4)
return CMD_RET_USAGE;
*/
#include <cpu_func.h>
+#include <env.h>
#include <init.h>
#include <asm/arch/hardware.h>
#include <asm/cache.h>
(ecc_ctrl & EMIF_ECC_REG_RMW_EN_MASK);
}
-static int do_ddr_test(cmd_tbl_t *cmdtp,
- int flag, int argc, char * const argv[])
+static int do_ddr_test(struct cmd_tbl *cmdtp,
+ int flag, int argc, char *const argv[])
{
u32 start_addr, end_addr, size, ecc_err;
printf(" %lu.%03lu seconds\n", seconds, milliseconds);
}
-static int do_time(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_time(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong cycles = 0;
int retval = 0;
*
* This function implements the tlv_eeprom command.
*/
-int do_tlv_eeprom(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_tlv_eeprom(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char cmd;
struct tlvinfo_header *eeprom_hdr = to_header(eeprom);
return 0;
}
-int do_tpm_device(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_tpm_device(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned long num;
int rc;
return rc;
}
-int do_tpm_info(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_tpm_info(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct udevice *dev;
char buf[80];
return 0;
}
-int do_tpm_init(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_tpm_init(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct udevice *dev;
int rc;
return report_return_code(tpm_init(dev));
}
-int do_tpm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_tpm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *tpm_commands, *cmd;
+ struct cmd_tbl *tpm_commands, *cmd;
struct tpm_chip_priv *priv;
struct udevice *dev;
unsigned int size;
int type_string_write_vars(const char *type_str, u8 *data, char * const vars[]);
int get_tpm(struct udevice **devp);
-int do_tpm_device(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]);
-int do_tpm_init(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]);
-int do_tpm_info(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]);
-int do_tpm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+int do_tpm_device(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
+int do_tpm_init(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
+int do_tpm_info(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
+int do_tpm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
#endif /* __TPM_USER_UTILS_H */
*/
#include <common.h>
+#include <command.h>
#include <env.h>
#include <malloc.h>
#include <asm/unaligned.h>
#include <tpm-v1.h>
#include "tpm-user-utils.h"
-static int do_tpm_startup(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_startup(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
enum tpm_startup_type mode;
struct udevice *dev;
return report_return_code(tpm_startup(dev, mode));
}
-static int do_tpm_nv_define_space(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_nv_define_space(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 index, perm, size;
struct udevice *dev;
return report_return_code(tpm_nv_define_space(dev, index, perm, size));
}
-static int do_tpm_nv_read_value(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_nv_read_value(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 index, count, rc;
struct udevice *dev;
return report_return_code(rc);
}
-static int do_tpm_nv_write_value(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_nv_write_value(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
u32 index, rc;
return report_return_code(rc);
}
-static int do_tpm_extend(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_extend(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u8 in_digest[20], out_digest[20];
struct udevice *dev;
return report_return_code(rc);
}
-static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_pcr_read(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 index, count, rc;
struct udevice *dev;
return report_return_code(rc);
}
-static int do_tpm_tsc_physical_presence(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_tsc_physical_presence(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
struct udevice *dev;
u16 presence;
return report_return_code(tpm_tsc_physical_presence(dev, presence));
}
-static int do_tpm_read_pubek(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_read_pubek(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
u32 count, rc;
return report_return_code(rc);
}
-static int do_tpm_physical_set_deactivated(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_physical_set_deactivated(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
struct udevice *dev;
u8 state;
return report_return_code(tpm_physical_set_deactivated(dev, state));
}
-static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_get_capability(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 cap_area, sub_cap, rc;
void *cap;
return report_return_code(rc);
}
-static int do_tpm_raw_transfer(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_raw_transfer(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
void *command;
return report_return_code(rc);
}
-static int do_tpm_nv_define(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_nv_define(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 index, perm, size;
struct udevice *dev;
return report_return_code(tpm_nv_define_space(dev, index, perm, size));
}
-static int do_tpm_nv_read(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_nv_read(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 index, count, err;
struct udevice *dev;
return report_return_code(err);
}
-static int do_tpm_nv_write(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_nv_write(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 index, count, err;
struct udevice *dev;
#ifdef CONFIG_TPM_AUTH_SESSIONS
-static int do_tpm_oiap(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_oiap(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 auth_handle, err;
struct udevice *dev;
}
#ifdef CONFIG_TPM_LOAD_KEY_BY_SHA1
-static int do_tpm_load_key_by_sha1(cmd_tbl_t *cmdtp, int flag, int argc, char *
- const argv[])
+static int do_tpm_load_key_by_sha1(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 parent_handle = 0;
u32 key_len, key_handle, err;
}
#endif /* CONFIG_TPM_LOAD_KEY_BY_SHA1 */
-static int do_tpm_load_key2_oiap(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_load_key2_oiap(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 parent_handle, key_len, key_handle, err;
u8 usage_auth[DIGEST_LENGTH];
return report_return_code(err);
}
-static int do_tpm_get_pub_key_oiap(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_get_pub_key_oiap(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 key_handle, err;
u8 usage_auth[DIGEST_LENGTH];
#endif /* CONFIG_TPM_AUTH_SESSIONS */
#ifdef CONFIG_TPM_FLUSH_RESOURCES
-static int do_tpm_flush(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_flush(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
int type = 0;
#endif /* CONFIG_TPM_FLUSH_RESOURCES */
#ifdef CONFIG_TPM_LIST_RESOURCES
-static int do_tpm_list(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_list(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int type = 0;
u16 res_count;
TPM_COMMAND_NO_ARG(tpm_physical_enable)
TPM_COMMAND_NO_ARG(tpm_physical_disable)
-static cmd_tbl_t tpm1_commands[] = {
+static struct cmd_tbl tpm1_commands[] = {
U_BOOT_CMD_MKENT(device, 0, 1, do_tpm_device, "", ""),
U_BOOT_CMD_MKENT(info, 0, 1, do_tpm_info, "", ""),
U_BOOT_CMD_MKENT(init, 0, 1, do_tpm_init, "", ""),
#endif /* CONFIG_TPM_LIST_RESOURCES */
};
-cmd_tbl_t *get_tpm1_commands(unsigned int *size)
+struct cmd_tbl *get_tpm1_commands(unsigned int *size)
{
*size = ARRAY_SIZE(tpm1_commands);
*/
#include <common.h>
+#include <command.h>
#include <dm.h>
#include <log.h>
#include <mapmem.h>
#include <tpm-v2.h>
#include "tpm-user-utils.h"
-static int do_tpm2_startup(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm2_startup(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
enum tpm2_startup_types mode;
struct udevice *dev;
return report_return_code(tpm2_startup(dev, mode));
}
-static int do_tpm2_self_test(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm2_self_test(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
enum tpm2_yes_no full_test;
struct udevice *dev;
return report_return_code(tpm2_self_test(dev, full_test));
}
-static int do_tpm2_clear(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm2_clear(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 handle = 0;
const char *pw = (argc < 3) ? NULL : argv[2];
return report_return_code(tpm2_clear(dev, handle, pw, pw_sz));
}
-static int do_tpm2_pcr_extend(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm2_pcr_extend(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
struct tpm_chip_priv *priv;
return report_return_code(rc);
}
-static int do_tpm_pcr_read(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_pcr_read(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct udevice *dev;
struct tpm_chip_priv *priv;
return report_return_code(rc);
}
-static int do_tpm_get_capability(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_get_capability(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 capability, property, rc;
u8 *data;
return report_return_code(rc);
}
-static int do_tpm_dam_reset(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_tpm_dam_reset(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const char *pw = (argc < 2) ? NULL : argv[1];
return report_return_code(tpm2_dam_reset(dev, pw, pw_sz));
}
-static int do_tpm_dam_parameters(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_tpm_dam_parameters(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
const char *pw = (argc < 5) ? NULL : argv[4];
lockout_recovery));
}
-static int do_tpm_change_auth(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_tpm_change_auth(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
u32 handle;
oldpw, oldpw_sz));
}
-static int do_tpm_pcr_setauthpolicy(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_tpm_pcr_setauthpolicy(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 index = simple_strtoul(argv[1], NULL, 0);
char *key = argv[2];
key));
}
-static int do_tpm_pcr_setauthvalue(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_tpm_pcr_setauthvalue(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
u32 index = simple_strtoul(argv[1], NULL, 0);
char *key = argv[2];
key, key_sz));
}
-static cmd_tbl_t tpm2_commands[] = {
+static struct cmd_tbl tpm2_commands[] = {
U_BOOT_CMD_MKENT(device, 0, 1, do_tpm_device, "", ""),
U_BOOT_CMD_MKENT(info, 0, 1, do_tpm_info, "", ""),
U_BOOT_CMD_MKENT(init, 0, 1, do_tpm_init, "", ""),
do_tpm_pcr_setauthvalue, "", ""),
};
-cmd_tbl_t *get_tpm2_commands(unsigned int *size)
+struct cmd_tbl *get_tpm2_commands(unsigned int *size)
{
*size = ARRAY_SIZE(tpm2_commands);
}
#define VOIDTEST(XFUNC) \
- int do_test_##XFUNC(cmd_tbl_t *cmd_tbl, int flag, int argc, \
- char * const argv[]) \
+ int do_test_##XFUNC(struct cmd_tbl *cmd_tbl, int flag, int argc, \
+ char *const argv[]) \
{ \
struct udevice *dev; \
int ret; \
VOIDTEST(write_limit)
VOIDTEST(timer)
-static cmd_tbl_t cmd_cros_tpm_sub[] = {
+static struct cmd_tbl cmd_cros_tpm_sub[] = {
VOIDENT(early_extend)
VOIDENT(early_nvram)
VOIDENT(early_nvram2)
VOIDENT(timer)
};
-static int do_tpmtest(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_tpmtest(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
int i;
printf("argc = %d, argv = ", argc);
#include <trace.h>
#include <asm/io.h>
-static int get_args(int argc, char * const argv[], char **buff,
+static int get_args(int argc, char *const argv[], char **buff,
size_t *buff_ptr, size_t *buff_size)
{
if (argc < 2)
return 0;
}
-static int create_func_list(int argc, char * const argv[])
+static int create_func_list(int argc, char *const argv[])
{
size_t buff_size, avail, buff_ptr, needed, used;
char *buff;
return 0;
}
-static int create_call_list(int argc, char * const argv[])
+static int create_call_list(int argc, char *const argv[])
{
size_t buff_size, avail, buff_ptr, needed, used;
char *buff;
return 0;
}
-int do_trace(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_trace(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
const char *cmd = argc < 2 ? NULL : argv[1];
/*
* Tundra Tsi148 configuration
*/
-int do_tsi148(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_tsi148(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ulong addr1 = 0, addr2 = 0, size = 0, vam = 0, vdw = 0;
char cmd = 'x';
return 0;
}
-static int do_ubi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_ubi(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int64_t size = 0;
ulong addr = 0;
return ret;
}
-static int do_ubifs_mount(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+
+static int do_ubifs_mount(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *vol_name;
return 0;
}
-static int do_ubifs_umount(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_ubifs_umount(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc != 1)
return CMD_RET_USAGE;
return cmd_ubifs_umount();
}
-static int do_ubifs_ls(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_ubifs_ls(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *filename = "/";
int ret;
return ret;
}
-static int do_ubifs_load(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_ubifs_load(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *filename;
char *endp;
#include <command.h>
#include <ufs.h>
-static int do_ufs(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_ufs(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int dev, ret;
/*
* Tundra Universe configuration
*/
-int do_universe(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_universe(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ulong addr1 = 0, addr2 = 0, size = 0, vam = 0, pms = 0, vdw = 0;
char cmd = 'x';
#include <env.h>
#include <lz4.h>
-static int do_unlz4(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_unlz4(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned long src, dst;
size_t src_len = ~0UL, dst_len = ~0UL;
#include <gzip.h>
#include <part.h>
-static int do_unzip(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_unzip(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned long src, dst;
unsigned long src_len = ~0UL, dst_len = ~0UL;
"srcaddr dstaddr [dstsize]"
);
-static int do_gzwrite(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_gzwrite(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
struct blk_desc *bdev;
int ret;
* usb boot command intepreter. Derived from diskboot
*/
#ifdef CONFIG_USB_STORAGE
-static int do_usbboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_usbboot(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
return common_diskboot(cmdtp, "usb", argc, argv);
}
/******************************************************************************
* usb command intepreter
*/
-static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_usb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct usb_device *udev = NULL;
int i;
*/
#include <common.h>
+#include <command.h>
#include <g_dnl.h>
#include <sdp.h>
#include <usb.h>
-static int do_sdp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_sdp(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int ret;
return ret;
}
-static int do_usb_mass_storage(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_usb_mass_storage(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
const char *usb_controller;
const char *devtype;
const char __weak version_string[] = U_BOOT_VERSION_STRING;
-static int do_version(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_version(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char buf[DISPLAY_OPTIONS_BANNER_LENGTH];
static int virtio_curr_dev;
-static int do_virtio(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_virtio(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc == 2 && !strcmp(argv[1], "scan")) {
/* make sure all virtio devices are enumerated */
return CMD_RET_SUCCESS;
}
-int do_w1(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_w1(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
if (argc < 2)
return CMD_RET_USAGE;
static struct udevice *currdev;
-static int do_wdt_list(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_wdt_list(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct udevice *dev;
return CMD_RET_SUCCESS;
}
-static int do_wdt_dev(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_wdt_dev(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int ret;
return 0;
}
-static int do_wdt_start(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_wdt_start(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int ret;
return CMD_RET_SUCCESS;
}
-static int do_wdt_stop(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_wdt_stop(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int ret;
return CMD_RET_SUCCESS;
}
-static int do_wdt_reset(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_wdt_reset(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int ret;
return CMD_RET_SUCCESS;
}
-static int do_wdt_expire(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_wdt_expire(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
int ret;
#if defined(CONFIG_CMD_WOL)
void wol_set_timeout(ulong);
-int do_wol(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_wol(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
/* Validate arguments */
if (argc < 2)
#include <common.h>
#include <command.h>
-static int do_undefined(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_undefined(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
asm volatile (".word 0xffff\n");
return CMD_RET_FAILURE;
}
-static cmd_tbl_t cmd_sub[] = {
+static struct cmd_tbl cmd_sub[] = {
U_BOOT_CMD_MKENT(undefined, CONFIG_SYS_MAXARGS, 1, do_undefined,
"", ""),
};
DECLARE_GLOBAL_DATA_PTR;
-static int do_hdr(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_hdr(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct fsp_header *hdr;
u32 img_addr;
return 0;
}
-static cmd_tbl_t fsp_commands[] = {
+static struct cmd_tbl fsp_commands[] = {
U_BOOT_CMD_MKENT(hdr, 0, 1, do_hdr, "", ""),
};
-static int do_fsp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_fsp(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *fsp_cmd;
+ struct cmd_tbl *fsp_cmd;
int ret;
if (argc < 2)
"Capsule",
};
-static int do_hob(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_hob(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
const struct hob_header *hdr;
uint type;
*/
#include <common.h>
+#include <command.h>
#include <asm/msr.h>
#include <asm/mtrr.h>
return 0;
}
-static int do_mtrr_set(uint reg, int argc, char * const argv[])
+static int do_mtrr_set(uint reg, int argc, char *const argv[])
{
const char *typename = argv[0];
struct mtrr_state state;
return 0;
}
-static int do_mtrr(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_mtrr(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *cmd;
uint reg;
#endif
static int
-do_imgextract(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+do_imgextract(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ulong addr = image_load_addr;
ulong dest = 0;
extern int yaffs_dump_dev(const char *path);
/* ytrace - show/set yaffs trace mask */
-int do_ytrace(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_ytrace(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
if (argc > 1)
cmd_yaffs_tracemask(1, simple_strtol(argv[1], NULL, 16));
}
/* ydevls - lists yaffs mount points. */
-int do_ydevls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_ydevls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
cmd_yaffs_dev_ls();
}
/* ydevconfig mount_pt mtd_dev_num start_block end_block */
-int do_ydevconfig(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_ydevconfig(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *mtpoint;
int mtd_dev;
return 0;
}
-int do_ymount(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_ymount(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *mtpoint;
return 0;
}
-int do_yumount(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_yumount(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *mtpoint;
return 0;
}
-int do_yls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_yls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *dirname;
return 0;
}
-int do_yrd(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_yrd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *filename;
return 0;
}
-int do_ywr(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_ywr(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *filename;
ulong value;
return 0;
}
-int do_yrdm(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_yrdm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *filename;
ulong addr;
return 0;
}
-int do_ywrm(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_ywrm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *filename;
ulong addr;
return 0;
}
-int do_ymkdir(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_ymkdir(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *dirname;
return 0;
}
-int do_yrmdir(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_yrmdir(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *dirname;
return 0;
}
-int do_yrm(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_yrm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *name;
return 0;
}
-int do_ymv(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_ymv(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char *oldPath;
char *newPath;
#define DOS_FS_TYPE_OFFSET 0x36
#define DOS_FS32_TYPE_OFFSET 0x52
-static int do_zfs_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_zfs_load(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
char *filename = NULL;
int dev;
}
-
-static int do_zfs_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_zfs_ls(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const char *filename = "/";
int part;
#include <command.h>
#include <env.h>
-static int do_zip(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_zip(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
unsigned long src, dst;
unsigned long src_len, dst_len = ~0UL;
#ifdef CONFIG_NEEDS_MANUAL_RELOC
static int initr_manual_reloc_cmdtable(void)
{
- fixup_cmdtable(ll_entry_start(cmd_tbl_t, cmd),
- ll_entry_count(cmd_tbl_t, cmd));
+ fixup_cmdtable(ll_entry_start(struct cmd_tbl, cmd),
+ ll_entry_count(struct cmd_tbl, cmd));
return 0;
}
#endif
bootm_headers_t images; /* pointers to os/initrd/fdt images */
-static const void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[], bootm_headers_t *images,
+static const void *boot_get_kernel(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[], bootm_headers_t *images,
ulong *os_data, ulong *os_len);
__weak void board_quiesce_devices(void)
static inline void boot_start_lmb(bootm_headers_t *images) { }
#endif
-static int bootm_start(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int bootm_start(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
memset((void *)&images, 0, sizeof(images));
images.verify = env_get_yesno("verify");
return 0;
}
-static int bootm_find_os(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int bootm_find_os(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
const void *os_hdr;
bool ep_found = false;
* 0, if all existing images were loaded correctly
* 1, if an image is found but corrupted, or invalid
*/
-int bootm_find_images(int flag, int argc, char * const argv[])
+int bootm_find_images(int flag, int argc, char *const argv[])
{
int ret;
return 0;
}
-static int bootm_find_other(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int bootm_find_other(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (((images.os.type == IH_TYPE_KERNEL) ||
(images.os.type == IH_TYPE_KERNEL_NOLOAD) ||
* then the intent is to boot an OS, so this function will not return
* unless the image type is standalone.
*/
-int do_bootm_states(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int states, bootm_headers_t *images, int boot_progress)
+int do_bootm_states(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[], int states, bootm_headers_t *images,
+ int boot_progress)
{
boot_os_fn *boot_fn;
ulong iflag = 0;
* pointer to image header if valid image was found, plus kernel start
* address and length, otherwise NULL
*/
-static const void *boot_get_kernel(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[], bootm_headers_t *images,
+static const void *boot_get_kernel(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[], bootm_headers_t *images,
ulong *os_data, ulong *os_len)
{
#if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
DECLARE_GLOBAL_DATA_PTR;
-static int do_bootm_standalone(int flag, int argc, char * const argv[],
+static int do_bootm_standalone(int flag, int argc, char *const argv[],
bootm_headers_t *images)
{
char *s;
/*******************************************************************/
#if defined(CONFIG_BOOTM_NETBSD) || defined(CONFIG_BOOTM_PLAN9)
-static void copy_args(char *dest, int argc, char * const argv[], char delim)
+static void copy_args(char *dest, int argc, char *const argv[], char delim)
{
int i;
#endif
#ifdef CONFIG_BOOTM_NETBSD
-static int do_bootm_netbsd(int flag, int argc, char * const argv[],
- bootm_headers_t *images)
+static int do_bootm_netbsd(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
void (*loader)(bd_t *, image_header_t *, char *, char *);
image_header_t *os_hdr, *hdr;
#endif /* CONFIG_BOOTM_NETBSD*/
#ifdef CONFIG_LYNXKDI
-static int do_bootm_lynxkdi(int flag, int argc, char * const argv[],
- bootm_headers_t *images)
+static int do_bootm_lynxkdi(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
image_header_t *hdr = &images->legacy_hdr_os_copy;
#endif /* CONFIG_LYNXKDI */
#ifdef CONFIG_BOOTM_RTEMS
-static int do_bootm_rtems(int flag, int argc, char * const argv[],
- bootm_headers_t *images)
+static int do_bootm_rtems(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
void (*entry_point)(bd_t *);
#endif /* CONFIG_BOOTM_RTEMS */
#if defined(CONFIG_BOOTM_OSE)
-static int do_bootm_ose(int flag, int argc, char * const argv[],
- bootm_headers_t *images)
+static int do_bootm_ose(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
void (*entry_point)(void);
#endif /* CONFIG_BOOTM_OSE */
#if defined(CONFIG_BOOTM_PLAN9)
-static int do_bootm_plan9(int flag, int argc, char * const argv[],
- bootm_headers_t *images)
+static int do_bootm_plan9(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
void (*entry_point)(void);
char *s;
puts("## vxWorks terminated\n");
}
-static int do_bootm_vxworks_legacy(int flag, int argc, char * const argv[],
+static int do_bootm_vxworks_legacy(int flag, int argc, char *const argv[],
bootm_headers_t *images)
{
if (flag != BOOTM_STATE_OS_GO)
return 1;
}
-int do_bootm_vxworks(int flag, int argc, char * const argv[],
+int do_bootm_vxworks(int flag, int argc, char *const argv[],
bootm_headers_t *images)
{
char *bootargs;
#endif
#if defined(CONFIG_CMD_ELF)
-static int do_bootm_qnxelf(int flag, int argc, char * const argv[],
- bootm_headers_t *images)
+static int do_bootm_qnxelf(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
char *local_args[2];
char str[16];
#endif
#ifdef CONFIG_INTEGRITY
-static int do_bootm_integrity(int flag, int argc, char * const argv[],
- bootm_headers_t *images)
+static int do_bootm_integrity(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
void (*entry_point)(void);
#endif
#ifdef CONFIG_BOOTM_OPENRTOS
-static int do_bootm_openrtos(int flag, int argc, char * const argv[],
- bootm_headers_t *images)
+static int do_bootm_openrtos(int flag, int argc, char *const argv[],
+ bootm_headers_t *images)
{
void (*entry_point)(void);
#endif
#ifdef CONFIG_BOOTM_OPTEE
-static int do_bootm_tee(int flag, int argc, char * const argv[],
+static int do_bootm_tee(int flag, int argc, char *const argv[],
bootm_headers_t *images)
{
int ret;
#endif
#ifdef CONFIG_BOOTM_EFI
-static int do_bootm_efi(int flag, int argc, char * const argv[],
+static int do_bootm_efi(int flag, int argc, char *const argv[],
bootm_headers_t *images)
{
int ret;
/* please define board specific board_preboot_os() */
}
-int boot_selected_os(int argc, char * const argv[], int state,
+int boot_selected_os(int argc, char *const argv[], int state,
bootm_headers_t *images, boot_os_fn *boot_fn)
{
arch_preboot_os();
/****************************************************************************/
#if defined(CONFIG_CMD_RUN)
-int do_run(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_run(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int i;
void cli_secure_boot_cmd(const char *cmd)
{
#ifdef CONFIG_CMDLINE
- cmd_tbl_t *cmdtp;
+ struct cmd_tbl *cmdtp;
#endif
int rc;
}
#ifdef __U_BOOT__
-static int do_showvar(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_showvar(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int i, k;
int rcode = 0;
#include <common.h>
#include <bootretry.h>
#include <cli.h>
+#include <command.h>
#include <time.h>
#include <watchdog.h>
* for long help messages
*/
-int _do_help(cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+int _do_help(struct cmd_tbl *cmd_start, int cmd_items, struct cmd_tbl *cmdtp,
+ int flag, int argc, char *const argv[])
{
int i;
int rcode = 0;
if (argc == 1) { /* show list of commands */
- cmd_tbl_t *cmd_array[cmd_items];
+ struct cmd_tbl *cmd_array[cmd_items];
int i, j, swaps;
/* Make array of commands from .uboot_cmd section */
for (j = 0; j < i; ++j) {
if (strcmp(cmd_array[j]->name,
cmd_array[j + 1]->name) > 0) {
- cmd_tbl_t *tmp;
+ struct cmd_tbl *tmp;
tmp = cmd_array[j];
cmd_array[j] = cmd_array[j + 1];
cmd_array[j + 1] = tmp;
}
/* find command table entry for a command */
-cmd_tbl_t *find_cmd_tbl(const char *cmd, cmd_tbl_t *table, int table_len)
+struct cmd_tbl *find_cmd_tbl(const char *cmd, struct cmd_tbl *table,
+ int table_len)
{
#ifdef CONFIG_CMDLINE
- cmd_tbl_t *cmdtp;
- cmd_tbl_t *cmdtp_temp = table; /* Init value */
+ struct cmd_tbl *cmdtp;
+ struct cmd_tbl *cmdtp_temp = table; /* Init value */
const char *p;
int len;
int n_found = 0;
return NULL; /* not found or ambiguous command */
}
-cmd_tbl_t *find_cmd(const char *cmd)
+struct cmd_tbl *find_cmd(const char *cmd)
{
- cmd_tbl_t *start = ll_entry_start(cmd_tbl_t, cmd);
- const int len = ll_entry_count(cmd_tbl_t, cmd);
+ struct cmd_tbl *start = ll_entry_start(struct cmd_tbl, cmd);
+ const int len = ll_entry_count(struct cmd_tbl, cmd);
return find_cmd_tbl(cmd, start, len);
}
-int cmd_usage(const cmd_tbl_t *cmdtp)
+int cmd_usage(const struct cmd_tbl *cmdtp)
{
printf("%s - %s\n\n", cmdtp->name, cmdtp->usage);
#ifdef CONFIG_AUTO_COMPLETE
static char env_complete_buf[512];
-int var_complete(int argc, char * const argv[], char last_char, int maxv, char *cmdv[])
+int var_complete(int argc, char *const argv[], char last_char, int maxv,
+ char *cmdv[])
{
int space;
return 0;
}
-static int dollar_complete(int argc, char * const argv[], char last_char,
+static int dollar_complete(int argc, char *const argv[], char last_char,
int maxv, char *cmdv[])
{
/* Make sure the last argument starts with a $. */
/*************************************************************************************/
-int complete_subcmdv(cmd_tbl_t *cmdtp, int count, int argc,
- char * const argv[], char last_char,
+int complete_subcmdv(struct cmd_tbl *cmdtp, int count, int argc,
+ char *const argv[], char last_char,
int maxv, char *cmdv[])
{
#ifdef CONFIG_CMDLINE
- const cmd_tbl_t *cmdend = cmdtp + count;
+ const struct cmd_tbl *cmdend = cmdtp + count;
const char *p;
int len, clen;
int n_found = 0;
#endif
}
-static int complete_cmdv(int argc, char * const argv[], char last_char,
+static int complete_cmdv(int argc, char *const argv[], char last_char,
int maxv, char *cmdv[])
{
#ifdef CONFIG_CMDLINE
- return complete_subcmdv(ll_entry_start(cmd_tbl_t, cmd),
- ll_entry_count(cmd_tbl_t, cmd), argc, argv,
+ return complete_subcmdv(ll_entry_start(struct cmd_tbl, cmd),
+ ll_entry_count(struct cmd_tbl, cmd), argc, argv,
last_char, maxv, cmdv);
#else
return 0;
return argc;
}
-static void print_argv(const char *banner, const char *leader, const char *sep, int linemax, char * const argv[])
+static void print_argv(const char *banner, const char *leader, const char *sep,
+ int linemax, char *const argv[])
{
int ll = leader != NULL ? strlen(leader) : 0;
int sl = sep != NULL ? strlen(sep) : 0;
printf("\n");
}
-static int find_common_prefix(char * const argv[])
+static int find_common_prefix(char *const argv[])
{
int i, len;
char *anchor, *s, *t;
#if defined(CONFIG_NEEDS_MANUAL_RELOC)
DECLARE_GLOBAL_DATA_PTR;
-void fixup_cmdtable(cmd_tbl_t *cmdtp, int size)
+void fixup_cmdtable(struct cmd_tbl *cmdtp, int size)
{
int i;
addr = (ulong)(cmdtp->cmd_rep) + gd->reloc_off;
cmdtp->cmd_rep =
- (int (*)(struct cmd_tbl_s *, int, int,
+ (int (*)(struct cmd_tbl *, int, int,
char * const [], int *))addr;
addr = (ulong)(cmdtp->cmd) + gd->reloc_off;
printf("Command \"%s\": 0x%08lx => 0x%08lx\n",
cmdtp->name, (ulong)(cmdtp->cmd), addr);
#endif
- cmdtp->cmd =
- (int (*)(struct cmd_tbl_s *, int, int, char * const []))addr;
+ cmdtp->cmd = (int (*)(struct cmd_tbl *, int, int,
+ char *const []))addr;
addr = (ulong)(cmdtp->name) + gd->reloc_off;
cmdtp->name = (char *)addr;
if (cmdtp->usage) {
}
#endif
-int cmd_always_repeatable(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[], int *repeatable)
+int cmd_always_repeatable(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[], int *repeatable)
{
*repeatable = 1;
return cmdtp->cmd(cmdtp, flag, argc, argv);
}
-int cmd_never_repeatable(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[], int *repeatable)
+int cmd_never_repeatable(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[], int *repeatable)
{
*repeatable = 0;
return cmdtp->cmd(cmdtp, flag, argc, argv);
}
-int cmd_discard_repeatable(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+int cmd_discard_repeatable(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int repeatable;
* @param repeatable Can the command be repeated
* @return 0 if command succeeded, else non-zero (CMD_RET_...)
*/
-static int cmd_call(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int *repeatable)
+static int cmd_call(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[], int *repeatable)
{
int result;
return result;
}
-enum command_ret_t cmd_process(int flag, int argc, char * const argv[],
+enum command_ret_t cmd_process(int flag, int argc, char *const argv[],
int *repeatable, ulong *ticks)
{
enum command_ret_t rc = CMD_RET_SUCCESS;
- cmd_tbl_t *cmdtp;
+ struct cmd_tbl *cmdtp;
#if defined(CONFIG_SYS_XTRACE)
char *xtrace;
return rc;
}
-int cmd_process_error(cmd_tbl_t *cmdtp, int err)
+int cmd_process_error(struct cmd_tbl *cmdtp, int err)
{
if (err == CMD_RET_USAGE)
return CMD_RET_USAGE;
*/
#include <common.h>
+#include <command.h>
#include <watchdog.h>
#include <dfu.h>
#include <console.h>
#include <common.h>
+#include <command.h>
#include <exports.h>
#include <malloc.h>
#include <spi.h>
s_end = info->sector_count - 1; /* index of last sector */
b_end = info->start[0] + info->size - 1; /* bank end address */
- debug ("flash_protect %s: from 0x%08lX to 0x%08lX\n",
- (flag & FLAG_PROTECT_SET) ? "ON" :
- (flag & FLAG_PROTECT_CLEAR) ? "OFF" : "???",
- from, to);
+ debug("%s %s: from 0x%08lX to 0x%08lX\n", __func__,
+ (flag & FLAG_PROTECT_SET) ? "ON" :
+ (flag & FLAG_PROTECT_CLEAR) ? "OFF" : "???",
+ from, to);
/* There is nothing to do if we have no data about the flash
* or the protect range and flash range don't overlap.
printf("%02x", output[i]);
}
-int hash_command(const char *algo_name, int flags, cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+int hash_command(const char *algo_name, int flags, struct cmd_tbl *cmdtp,
+ int flag, int argc, char *const argv[])
{
ulong addr, len;
* 1, if fdt image is found but corrupted
* of_flat_tree and of_size are set to 0 if no fdt exists
*/
-int boot_get_fdt(int flag, int argc, char * const argv[], uint8_t arch,
- bootm_headers_t *images, char **of_flat_tree, ulong *of_size)
+int boot_get_fdt(int flag, int argc, char *const argv[], uint8_t arch,
+ bootm_headers_t *images, char **of_flat_tree, ulong *of_size)
{
#if CONFIG_IS_ENABLED(LEGACY_IMAGE_FORMAT)
const image_header_t *fdt_hdr;
#include <lzma/LzmaTools.h>
#ifdef CONFIG_CMD_BDI
-extern int do_bdinfo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+extern int do_bdinfo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
#endif
DECLARE_GLOBAL_DATA_PTR;
* 1, if ramdisk image is found but corrupted, or invalid
* rd_start and rd_end are set to 0 if no ramdisk exists
*/
-int boot_get_ramdisk(int argc, char * const argv[], bootm_headers_t *images,
- uint8_t arch, ulong *rd_start, ulong *rd_end)
+int boot_get_ramdisk(int argc, char *const argv[], bootm_headers_t *images,
+ uint8_t arch, ulong *rd_start, ulong *rd_end)
{
ulong rd_addr, rd_load;
ulong rd_data, rd_len;
#if IMAGE_ENABLE_FIT
#if defined(CONFIG_FPGA)
-int boot_get_fpga(int argc, char * const argv[], bootm_headers_t *images,
+int boot_get_fpga(int argc, char *const argv[], bootm_headers_t *images,
uint8_t arch, const ulong *ld_start, ulong * const ld_len)
{
ulong tmp_img_addr, img_data, img_len;
fit_loadable_handler->handler(img_data, img_len);
}
-int boot_get_loadable(int argc, char * const argv[], bootm_headers_t *images,
- uint8_t arch, const ulong *ld_start, ulong * const ld_len)
+int boot_get_loadable(int argc, char *const argv[], bootm_headers_t *images,
+ uint8_t arch, const ulong *ld_start, ulong * const ld_len)
{
/*
* These variables are used to hold the current image location
}
int
-do_kgdb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+do_kgdb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
printf("Entering KGDB mode via exception handler...\n\n");
kgdb_breakpoint(argc - 1, argv + 1);
*/
#include <common.h>
+#include <command.h>
#include <lcd.h>
#include <serial.h>
#include <video_font.h> /* Get font data, width and height */
lcd_puts(buf);
}
-static int do_lcd_setcursor(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_lcd_setcursor(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
unsigned int col, row;
return 0;
}
-static int do_lcd_puts(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_lcd_puts(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
if (argc != 2)
Commands are added to U-Boot by creating a new command structure.
This is done by first including command.h, then using the U_BOOT_CMD() or the
-U_BOOT_CMD_COMPLETE macro to fill in a cmd_tbl_t struct.
+U_BOOT_CMD_COMPLETE macro to fill in a struct cmd_tbl struct.
U_BOOT_CMD(name, maxargs, repeatable, command, "usage", "help")
U_BOOT_CMD_COMPLETE(name, maxargs, repeatable, command, "usage, "help", comp)
Sub-command definition
----------------------
-Likewise an array of cmd_tbl_t holding sub-commands can be created using either
+Likewise an array of struct cmd_tbl holding sub-commands can be created using either
of the following macros:
* U_BOOT_CMD_MKENT(name, maxargs, repeatable, command, "usage", "help")
This table has to be evaluated in the command function of the main command, e.g.
- static cmd_tbl_t cmd_sub[] = {
+ static struct cmd_tbl cmd_sub[] = {
U_BOOT_CMD_MKENT(foo, CONFIG_SYS_MAXARGS, 1, do_foo, "", ""),
U_BOOT_CMD_MKENT(bar, CONFIG_SYS_MAXARGS, 1, do_bar, "", ""),
};
- static int do_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+ static int do_cmd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
if (argc < 2)
return CMD_RET_USAGE;
----------------
The command function pointer has to be of type
-int (*cmd)(struct cmd_tbl_s *cmdtp, int flag, int argc, const char *argv[]);
+int (*cmd)(struct cmd_tbl *cmdtp, int flag, int argc, const char *argv[]);
cmdtp: Table entry describing the command (see above).
that returns the ABI version of the running U-Boot. I.e., a
typical application startup may look like this:
- int my_app (int argc, char * const argv[])
+ int my_app (int argc, char *const argv[])
{
app_startup (argv);
if (get_version () != XF_VERSION)
#include <common.h>
#include <clk-uclass.h>
#include <clock_legacy.h>
+#include <command.h>
#include <dm.h>
#include <vsprintf.h>
#include <dm/lists.h>
.bind = mpc83xx_clk_bind,
};
-static int do_clocks(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_clocks(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int i;
char buf[32];
#include <common.h>
#include <cli.h>
+#include <command.h>
#include <env.h>
#include <linux/ctype.h>
#include <asm/types.h>
*/
#include <common.h>
+#include <command.h>
#include <dm.h>
#include <irq_func.h>
#include <dm/lists.h>
#endif /* CONFIG_PSCI_RESET */
#ifdef CONFIG_CMD_POWEROFF
-int do_poweroff(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_poweroff(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
do_psci_probe();
*/
#include <common.h>
+#include <command.h>
#include <i2c.h>
#include <pca953x.h>
return 0;
}
-static cmd_tbl_t cmd_pca953x[] = {
+static struct cmd_tbl cmd_pca953x[] = {
U_BOOT_CMD_MKENT(device, 3, 0, (void *)PCA953X_CMD_DEVICE, "", ""),
U_BOOT_CMD_MKENT(output, 4, 0, (void *)PCA953X_CMD_OUTPUT, "", ""),
U_BOOT_CMD_MKENT(input, 3, 0, (void *)PCA953X_CMD_INPUT, "", ""),
U_BOOT_CMD_MKENT(info, 2, 0, (void *)PCA953X_CMD_INFO, "", ""),
};
-static int do_pca953x(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_pca953x(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
static uint8_t chip = CONFIG_SYS_I2C_PCA953X_ADDR;
int ret = CMD_RET_USAGE, val;
ulong ul_arg2 = 0;
ulong ul_arg3 = 0;
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
c = find_cmd_tbl(argv[1], cmd_pca953x, ARRAY_SIZE(cmd_pca953x));
*/
#include <common.h>
+#include <command.h>
#include <i2c.h>
#include <tca642x.h>
return 0;
}
-static cmd_tbl_t cmd_tca642x[] = {
+static struct cmd_tbl cmd_tca642x[] = {
U_BOOT_CMD_MKENT(device, 3, 0, (void *)TCA642X_CMD_DEVICE, "", ""),
U_BOOT_CMD_MKENT(output, 4, 0, (void *)TCA642X_CMD_OUTPUT, "", ""),
U_BOOT_CMD_MKENT(input, 3, 0, (void *)TCA642X_CMD_INPUT, "", ""),
U_BOOT_CMD_MKENT(info, 2, 0, (void *)TCA642X_CMD_INFO, "", ""),
};
-static int do_tca642x(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_tca642x(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
static uchar chip = CONFIG_SYS_I2C_TCA642X_ADDR;
int ret = CMD_RET_USAGE, val;
uint8_t bank_shift;
ulong ul_arg2 = 0;
ulong ul_arg3 = 0;
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
c = find_cmd_tbl(argv[1], cmd_tca642x, ARRAY_SIZE(cmd_tca642x));
printf("SYSID: %08x, %s", sysid[0], asc);
}
-int do_sysid(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_sysid(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
display_sysid();
return 0;
return 0;
}
-cmd_tbl_t cmd_ds4510[] = {
+struct cmd_tbl cmd_ds4510[] = {
U_BOOT_CMD_MKENT(device, 3, 0, (void *)DS4510_CMD_DEVICE, "", ""),
U_BOOT_CMD_MKENT(nv, 3, 0, (void *)DS4510_CMD_NV, "", ""),
U_BOOT_CMD_MKENT(output, 4, 0, (void *)DS4510_CMD_OUTPUT, "", ""),
U_BOOT_CMD_MKENT(sram, 6, 0, (void *)DS4510_CMD_SRAM, "", ""),
};
-int do_ds4510(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ds4510(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
static uint8_t chip = 0x51;
- cmd_tbl_t *c;
+ struct cmd_tbl *c;
ulong ul_arg2 = 0;
ulong ul_arg3 = 0;
int tmp;
};
#if defined(DEBUG)
-static int dump_efuses(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int dump_efuses(struct cmd_tbl *cmdtp, int flag,
+ int argc, char *const argv[])
{
/*
* N.B.: This function is tailored towards the RK3399 and assumes that
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <dm.h>
#include <errno.h>
#endif /* !CONFIG_DM_ETH */
#ifdef CONFIG_CMD_E1000
-static int do_e1000(cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[])
+static int do_e1000(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
unsigned char *mac = NULL;
#ifdef CONFIG_DM_ETH
#endif
#ifdef CONFIG_E1000_SPI
-int do_e1000_spi(cmd_tbl_t *cmdtp, struct e1000_hw *hw,
- int argc, char * const argv[]);
+int do_e1000_spi(struct cmd_tbl *cmdtp, struct e1000_hw *hw,
+ int argc, char *const argv[]);
#endif
/* Enumerated types specific to the e1000 hardware */
#include <common.h>
+#include <command.h>
#include <console.h>
#include "e1000.h"
#include <malloc.h>
return 0;
}
-static int do_e1000_spi_show(cmd_tbl_t *cmdtp, struct e1000_hw *hw,
- int argc, char * const argv[])
+static int do_e1000_spi_show(struct cmd_tbl *cmdtp, struct e1000_hw *hw,
+ int argc, char *const argv[])
{
unsigned int length = 0;
u16 i, offset = 0;
return 0;
}
-static int do_e1000_spi_dump(cmd_tbl_t *cmdtp, struct e1000_hw *hw,
- int argc, char * const argv[])
+static int do_e1000_spi_dump(struct cmd_tbl *cmdtp, struct e1000_hw *hw,
+ int argc, char *const argv[])
{
unsigned int length;
u16 offset;
return 0;
}
-static int do_e1000_spi_program(cmd_tbl_t *cmdtp, struct e1000_hw *hw,
- int argc, char * const argv[])
+static int do_e1000_spi_program(struct cmd_tbl *cmdtp, struct e1000_hw *hw,
+ int argc, char *const argv[])
{
unsigned int length;
const void *source;
return 0;
}
-static int do_e1000_spi_checksum(cmd_tbl_t *cmdtp, struct e1000_hw *hw,
- int argc, char * const argv[])
+static int do_e1000_spi_checksum(struct cmd_tbl *cmdtp, struct e1000_hw *hw,
+ int argc, char *const argv[])
{
uint16_t i, length, checksum = 0, checksum_reg;
uint16_t *buffer;
return 0;
}
-int do_e1000_spi(cmd_tbl_t *cmdtp, struct e1000_hw *hw,
- int argc, char * const argv[])
+int do_e1000_spi(struct cmd_tbl *cmdtp, struct e1000_hw *hw,
+ int argc, char *const argv[])
{
if (argc < 1) {
cmd_usage(cmdtp);
return err;
}
-static int do_fsl_mc(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_fsl_mc(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int err = 0;
if (argc < 3)
* @brief PFE utility commands
*/
+#include <command.h>
#include <net/pfe_eth/pfe_eth.h>
static inline void pfe_command_help(void)
printf("Usage: pfe [pe | status | expt ] <options>\n");
}
-static void pfe_command_pe(int argc, char * const argv[])
+static void pfe_command_pe(int argc, char *const argv[])
{
if (argc >= 3 && strcmp(argv[2], "pmem") == 0) {
if (argc >= 4 && strcmp(argv[3], "read") == 0) {
#define PEMBOX_ADDR_TMU 0x290
#define PESTATUS_ADDR_UTIL 0x0
-static void pfe_pe_status(int argc, char * const argv[])
+static void pfe_pe_status(int argc, char *const argv[])
{
int do_clear = 0;
u32 id;
}
}
-static void pfe_command_status(int argc, char * const argv[])
+static void pfe_command_status(int argc, char *const argv[])
{
if (argc >= 3 && strcmp(argv[2], "pe") == 0) {
pfe_pe_status(argc, argv);
" r12", " r13", " r14", " r15"
};
-static void pfe_command_expt(int argc, char * const argv[])
+static void pfe_command_expt(int argc, char *const argv[])
{
unsigned int id, i, val, addr;
writel(buf, TMU_PHY_INQ_PKTINFO);
}
-static void pfe_command_stop(int argc, char * const argv[])
+static void pfe_command_stop(int argc, char *const argv[])
{
int pfe_pe_id, hif_stop_loop = 10;
u32 rx_status;
}
#endif
-static int pfe_command(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int pfe_command(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc == 1 || strcmp(argv[1], "help") == 0) {
pfe_command_help();
*/
#include <common.h>
+#include <command.h>
#include <errno.h>
#include <malloc.h>
return 0;
}
-int do_b53_reg_read(const char *name, int argc, char * const argv[])
+int do_b53_reg_read(const char *name, int argc, char *const argv[])
{
u8 page, offset, width;
struct mii_dev *bus;
return ret;
}
-int do_b53_reg_write(const char *name, int argc, char * const argv[])
+int do_b53_reg_write(const char *name, int argc, char *const argv[])
{
u8 page, offset, width;
struct mii_dev *bus;
return ret;
}
-int do_b53_reg(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_b53_reg(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
const char *cmd, *mdioname;
int ret = 0;
*/
#include <common.h>
+#include <command.h>
#include <miiphy.h>
#include <linux/errno.h>
#include <mv88e6352.h>
return -ETIMEDOUT;
}
-int do_mvsw_reg_read(const char *name, int argc, char * const argv[])
+int do_mvsw_reg_read(const char *name, int argc, char *const argv[])
{
u16 value = 0, phyaddr, reg, port;
int ret;
return ret;
}
-int do_mvsw_reg_write(const char *name, int argc, char * const argv[])
+int do_mvsw_reg_write(const char *name, int argc, char *const argv[])
{
u16 value = 0, phyaddr, reg, port;
int ret;
}
-int do_mvsw_reg(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_mvsw_reg(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int ret;
const char *cmd, *ethname;
* Driver for the Vitesse VSC9953 L2 Switch
*/
+#include <command.h>
#include <asm/io.h>
#include <asm/fsl_serdes.h>
#include <fm_eth.h>
return 0;
}
-int do_poweroff(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_poweroff(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
pmic_bus_write(AXP152_SHUTDOWN, AXP152_POWEROFF);
return 0;
}
-int do_poweroff(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_poweroff(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
pmic_bus_write(AXP209_SHUTDOWN, AXP209_POWEROFF);
return 0;
}
-int do_poweroff(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_poweroff(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
pmic_bus_write(AXP221_SHUTDOWN, AXP221_SHUTDOWN_POWEROFF);
*/
#include <common.h>
+#include <command.h>
#include <errno.h>
#include <asm/arch/gpio.h>
#include <asm/arch/pmic_bus.h>
return pmic_bus_init();
}
-int do_poweroff(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_poweroff(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
pmic_bus_write(AXP809_SHUTDOWN, AXP809_SHUTDOWN_POWEROFF);
*/
#include <common.h>
+#include <command.h>
#include <errno.h>
#include <asm/arch/gpio.h>
#include <asm/arch/pmic_bus.h>
return 0;
}
-int do_poweroff(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_poweroff(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
pmic_bus_write(AXP818_SHUTDOWN, AXP818_SHUTDOWN_POWEROFF);
#define RTC_BBPU_KEY (0x43 << 8)
#define RTC_WRTGR 0x003c
-int do_poweroff(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_poweroff(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
u32 addr, val;
*/
#include <common.h>
+#include <command.h>
#include <malloc.h>
#include <linux/types.h>
#include <linux/list.h>
}
}
-static int do_pmic(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_pmic(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
u32 ret, reg, val;
char *cmd, *name;
* Syed Mohammed Khasim <khasim at ti.com>
*/
+#include <command.h>
#include <twl4030.h>
/*
}
#ifdef CONFIG_CMD_POWEROFF
-int do_poweroff(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_poweroff(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
twl4030_power_off();
return qe_firmware_uploaded ? &qe_firmware_info : NULL;
}
-static int qe_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int qe_cmd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ulong addr;
*/
#include <common.h>
+#include <command.h>
#include <console.h>
#include <cli.h>
#include <clk.h>
static void stm32mp1_do_info(struct ddr_info *priv,
struct stm32mp1_ddr_config *config,
enum stm32mp1_ddr_interact_step step,
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
unsigned long value;
static char *ddr_name;
}
static bool stm32mp1_do_freq(struct ddr_info *priv,
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
unsigned long ddrphy_clk;
static void stm32mp1_do_param(enum stm32mp1_ddr_interact_step step,
const struct stm32mp1_ddr_config *config,
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
switch (argc) {
case 1:
}
static void stm32mp1_do_print(struct ddr_info *priv,
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
switch (argc) {
case 1:
}
static int stm32mp1_do_step(enum stm32mp1_ddr_interact_step step,
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
int i;
unsigned long value;
#define LOG_CATEGORY UCLASS_SYSRESET
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <hang.h>
#include <sysreset.h>
}
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
printf("resetting ...\n");
}
#if IS_ENABLED(CONFIG_SYSRESET_CMD_POWEROFF)
-int do_poweroff(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_poweroff(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int ret;
*/
#include <common.h>
+#include <command.h>
#include <dm.h>
#include <sysreset.h>
#include <wait_bit.h>
* Copyright 2014 Linaro, Ltd.
* Rob Herring <robh@kernel.org>
*/
+#include <command.h>
#include <config.h>
#include <common.h>
#include <env.h>
*
* Eddie Cai <eddie.cai.linux@gmail.com>
*/
+#include <command.h>
#include <config.h>
#include <common.h>
#include <env.h>
*/
#include <common.h>
+#include <command.h>
#include <cpu_func.h>
#include <env.h>
#include <fdtdec.h>
1);
}
-static int do_clrlogo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_clrlogo(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
if (argc != 1)
return cmd_usage(cmdtp);
*/
#include <common.h>
#include <backlight.h>
+#include <command.h>
#include <display.h>
#include <dm.h>
#include <dm/read.h>
return 0;
}
-static int do_lgset(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_lgset(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct spi_slave *slave;
struct udevice *dev;
*/
#include <common.h>
+#include <command.h>
#include <linux/ctype.h>
#include <dm.h>
#include <video.h>
priv->ycur = min_t(short, row, vid_priv->ysize - 1);
}
-static int do_video_setcursor(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_video_setcursor(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
unsigned int col, row;
return 0;
}
-static int do_video_puts(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_video_puts(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
struct udevice *dev;
static char buf[BUF_SZ];
-int main(int argc, char * const argv[])
+int main(int argc, char *const argv[])
{
int rv = 0, h, i, j, devs_no;
struct api_signature *sig = NULL;
*/
#include <common.h>
+#include <command.h>
#include <hang.h>
#include <linux/types.h>
#include <api_public.h>
ub_udelay(usec);
}
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
ub_reset();
return 0;
}
}
-int atmel_df_pow2(int argc, char * const argv[])
+int atmel_df_pow2(int argc, char *const argv[])
{
/* Print the ABI version */
app_startup(argv);
#include <common.h>
#include <exports.h>
-int hello_world (int argc, char * const argv[])
+int hello_world(int argc, char *const argv[])
{
int i;
int read_eeprom_reg (struct eth_device *dev, int reg);
void print_macaddr (struct eth_device *dev);
-int smc91111_eeprom (int argc, char * const argv[])
+int smc91111_eeprom(int argc, char *const argv[])
{
int c, i, j, done, line, reg, value, start, what;
char input[50];
/**
* smc911x_eeprom - our application's main() function
*/
-int smc911x_eeprom(int argc, char * const argv[])
+int smc911x_eeprom(int argc, char *const argv[])
{
/* Avoid initializing on stack as gcc likes to call memset() */
struct eth_device dev;
#include <exports.h>
#include <linux/compiler.h>
+struct cmd_tbl;
+
#define FO(x) offsetof(struct jt_funcs, x)
#if defined(CONFIG_X86)
* Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
*/
+#include <command.h>
#include <config.h>
#include <errno.h>
#include <common.h>
return ret;
}
-int do_size(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype)
+int do_size(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype)
{
loff_t size;
return 0;
}
-int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype)
+int do_load(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype)
{
unsigned long addr;
const char *addr_str;
return 0;
}
-int do_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype)
+int do_ls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype)
{
if (argc < 2)
return CMD_RET_USAGE;
return fs_exists(file);
}
-int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype)
+int do_save(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype)
{
unsigned long addr;
const char *filename;
return 0;
}
-int do_fs_uuid(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype)
+int do_fs_uuid(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype)
{
int ret;
char uuid[37];
return CMD_RET_SUCCESS;
}
-int do_fs_type(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_fs_type(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct fstype_info *info;
return CMD_RET_SUCCESS;
}
-int do_rm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
+int do_rm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
int fstype)
{
if (argc != 4)
return 0;
}
-int do_mkdir(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
+int do_mkdir(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
int fstype)
{
int ret;
return 0;
}
-int do_ln(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
+int do_ln(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
int fstype)
{
if (argc != 5)
EXPORT_FUNC(udelay, void, udelay, unsigned long)
EXPORT_FUNC(get_timer, unsigned long, get_timer, unsigned long)
EXPORT_FUNC(vprintf, int, vprintf, const char *, va_list)
- EXPORT_FUNC(do_reset, int, do_reset, cmd_tbl_t *,
+ EXPORT_FUNC(do_reset, int, do_reset, struct cmd_tbl *,
int , int , char * const [])
EXPORT_FUNC(env_get, char *, env_get, const char*)
EXPORT_FUNC(env_set, int, env_set, const char *, const char *)
#ifndef _TYPE_BEDBUG_H
#define _TYPE_BEDBUG_H
+struct cmd_tbl;
+
/* Supporting routines */
int bedbug_puts (const char *);
int bedbug_init(void);
int current_bp;
struct pt_regs *regs;
- void (*do_break) (cmd_tbl_t *, int, int, char * const []);
+ void (*do_break)(struct cmd_tbl *cmd, int flags, int argc,
+ char *const argv[]);
void (*break_isr) (struct pt_regs *);
int (*find_empty) (void);
int (*set) (int, unsigned long);
* @cur_devnump: Current device number for this interface type
* @return 0 if OK, CMD_RET_ERROR on error
*/
-int blk_common_cmd(int argc, char * const argv[], enum if_type if_type,
+int blk_common_cmd(int argc, char *const argv[], enum if_type if_type,
int *cur_devnump);
#endif
#ifndef _BOOTM_H
#define _BOOTM_H
-#include <command.h>
#include <image.h>
+struct cmd_tbl;
+
#define BOOTM_ERR_RESET (-1)
#define BOOTM_ERR_OVERLAP (-2)
#define BOOTM_ERR_UNIMPLEMENTED (-3)
* @return 1 on error. On success the OS boots so this function does
* not return.
*/
-typedef int boot_os_fn(int flag, int argc, char * const argv[],
+typedef int boot_os_fn(int flag, int argc, char *const argv[],
bootm_headers_t *images);
extern boot_os_fn do_bootm_linux;
extern boot_os_fn do_bootm_vxworks;
-int do_bootelf(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+int do_bootelf(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
void lynxkdi_boot(image_header_t *hdr);
boot_os_fn *bootm_os_get_boot_func(int os);
int bootm_host_load_images(const void *fit, int cfg_noffset);
#endif
-int boot_selected_os(int argc, char * const argv[], int state,
+int boot_selected_os(int argc, char *const argv[], int state,
bootm_headers_t *images, boot_os_fn *boot_fn);
ulong bootm_disable_interrupts(void);
/* This is a special function used by booti/bootz */
-int bootm_find_images(int flag, int argc, char * const argv[]);
+int bootm_find_images(int flag, int argc, char *const argv[]);
-int do_bootm_states(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int states, bootm_headers_t *images, int boot_progress);
+int do_bootm_states(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[], int states, bootm_headers_t *images,
+ int boot_progress);
void arch_preboot_os(void);
* Monitor Command Table
*/
-struct cmd_tbl_s {
+struct cmd_tbl {
char *name; /* Command Name */
int maxargs; /* maximum number of arguments */
/*
* repeatable property different for
* the main command and sub-commands.
*/
- int (*cmd_rep)(struct cmd_tbl_s *cmd, int flags, int argc,
- char * const argv[], int *repeatable);
+ int (*cmd_rep)(struct cmd_tbl *cmd, int flags, int argc,
+ char *const argv[], int *repeatable);
/* Implementation function */
- int (*cmd)(struct cmd_tbl_s *, int, int, char * const []);
+ int (*cmd)(struct cmd_tbl *cmd, int flags, int argc,
+ char *const argv[]);
char *usage; /* Usage message (short) */
#ifdef CONFIG_SYS_LONGHELP
char *help; /* Help message (long) */
#endif
#ifdef CONFIG_AUTO_COMPLETE
/* do auto completion on the arguments */
- int (*complete)(int argc, char * const argv[], char last_char, int maxv, char *cmdv[]);
+ int (*complete)(int argc, char *const argv[],
+ char last_char, int maxv, char *cmdv[]);
#endif
};
-typedef struct cmd_tbl_s cmd_tbl_t;
-
-
#if defined(CONFIG_CMD_RUN)
-extern int do_run(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+extern int do_run(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
#endif
/* common/command.c */
-int _do_help (cmd_tbl_t *cmd_start, int cmd_items, cmd_tbl_t * cmdtp, int
- flag, int argc, char * const argv[]);
-cmd_tbl_t *find_cmd(const char *cmd);
-cmd_tbl_t *find_cmd_tbl (const char *cmd, cmd_tbl_t *table, int table_len);
-int complete_subcmdv(cmd_tbl_t *cmdtp, int count, int argc,
- char * const argv[], char last_char, int maxv,
+int _do_help(struct cmd_tbl *cmd_start, int cmd_items, struct cmd_tbl *cmdtp,
+ int flag, int argc, char *const argv[]);
+struct cmd_tbl *find_cmd(const char *cmd);
+struct cmd_tbl *find_cmd_tbl(const char *cmd, struct cmd_tbl *table,
+ int table_len);
+int complete_subcmdv(struct cmd_tbl *cmdtp, int count, int argc,
+ char *const argv[], char last_char, int maxv,
char *cmdv[]);
-extern int cmd_usage(const cmd_tbl_t *cmdtp);
+extern int cmd_usage(const struct cmd_tbl *cmdtp);
/* Dummy ->cmd and ->cmd_rep wrappers. */
-int cmd_always_repeatable(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[], int *repeatable);
-int cmd_never_repeatable(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[], int *repeatable);
-int cmd_discard_repeatable(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[]);
-
-static inline bool cmd_is_repeatable(cmd_tbl_t *cmdtp)
+int cmd_always_repeatable(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[], int *repeatable);
+int cmd_never_repeatable(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[], int *repeatable);
+int cmd_discard_repeatable(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
+
+static inline bool cmd_is_repeatable(struct cmd_tbl *cmdtp)
{
return cmdtp->cmd_rep == cmd_always_repeatable;
}
#ifdef CONFIG_AUTO_COMPLETE
-extern int var_complete(int argc, char * const argv[], char last_char, int maxv, char *cmdv[]);
-extern int cmd_auto_complete(const char *const prompt, char *buf, int *np, int *colp);
+extern int var_complete(int argc, char *const argv[], char last_char, int maxv,
+ char *cmdv[]);
+extern int cmd_auto_complete(const char *const prompt, char *buf, int *np,
+ int *colp);
#endif
/**
* 1 (CMD_RET_FAILURE) if an error is found
* -1 (CMD_RET_USAGE) if 'usage' error is found
*/
-int cmd_process_error(cmd_tbl_t *cmdtp, int err);
+int cmd_process_error(struct cmd_tbl *cmdtp, int err);
/*
* Monitor Command
*
* All commands use a common argument format:
*
- * void function (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+ * void function(struct cmd_tbl *cmdtp, int flag, int argc,
+ * char *const argv[]);
*/
#if defined(CONFIG_CMD_MEMORY) || \
#endif
#ifdef CONFIG_CMD_BOOTD
-extern int do_bootd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+extern int do_bootd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
#endif
#ifdef CONFIG_CMD_BOOTM
-extern int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
-extern int bootm_maybe_autostart(cmd_tbl_t *cmdtp, const char *cmd);
+extern int do_bootm(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
+extern int bootm_maybe_autostart(struct cmd_tbl *cmdtp, const char *cmd);
#else
-static inline int bootm_maybe_autostart(cmd_tbl_t *cmdtp, const char *cmd)
+static inline int bootm_maybe_autostart(struct cmd_tbl *cmdtp, const char *cmd)
{
return 0;
}
#endif
-extern int do_bootz(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+extern int do_bootz(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
-extern int do_booti(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+extern int do_booti(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
-extern int common_diskboot(cmd_tbl_t *cmdtp, const char *intf, int argc,
+extern int common_diskboot(struct cmd_tbl *cmdtp, const char *intf, int argc,
char *const argv[]);
-extern int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
-extern int do_poweroff(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+extern int do_reset(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
+extern int do_poweroff(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
extern unsigned long do_go_exec(ulong (*entry)(int, char * const []), int argc,
- char * const argv[]);
+ char *const argv[]);
#if defined(CONFIG_CMD_NVEDIT_EFI)
-extern int do_env_print_efi(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[]);
-extern int do_env_set_efi(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[]);
+extern int do_env_print_efi(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
+extern int do_env_set_efi(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
#endif
/*
* number of ticks the command took to complete.
* @return 0 if the command succeeded, 1 if it failed
*/
-int cmd_process(int flag, int argc, char * const argv[],
- int *repeatable, unsigned long *ticks);
+int cmd_process(int flag, int argc, char *const argv[], int *repeatable,
+ unsigned long *ticks);
-void fixup_cmdtable(cmd_tbl_t *cmdtp, int size);
+void fixup_cmdtable(struct cmd_tbl *cmdtp, int size);
/**
* board_run_command() - Fallback function to execute a command
#endif
#define U_BOOT_SUBCMDS_DO_CMD(_cmdname) \
- static int do_##_cmdname(cmd_tbl_t *cmdtp, int flag, int argc, \
- char * const argv[], int *repeatable) \
+ static int do_##_cmdname(struct cmd_tbl *cmdtp, int flag, \
+ int argc, char *const argv[], \
+ int *repeatable) \
{ \
- cmd_tbl_t *subcmd; \
+ struct cmd_tbl *subcmd; \
\
_cmdname##_subcmds_reloc(); \
\
#ifdef CONFIG_AUTO_COMPLETE
#define U_BOOT_SUBCMDS_COMPLETE(_cmdname) \
- static int complete_##_cmdname(int argc, char * const argv[], \
+ static int complete_##_cmdname(int argc, char *const argv[], \
char last_char, int maxv, \
char *cmdv[]) \
{ \
#endif
#define U_BOOT_SUBCMDS(_cmdname, ...) \
- static cmd_tbl_t _cmdname##_subcmds[] = { __VA_ARGS__ }; \
+ static struct cmd_tbl _cmdname##_subcmds[] = { __VA_ARGS__ }; \
U_BOOT_SUBCMDS_RELOC(_cmdname) \
U_BOOT_SUBCMDS_DO_CMD(_cmdname) \
U_BOOT_SUBCMDS_COMPLETE(_cmdname)
_cmd, _usage, _CMD_HELP(_help) _CMD_COMPLETE(_comp) }
#define U_BOOT_CMD_COMPLETE(_name, _maxargs, _rep, _cmd, _usage, _help, _comp) \
- ll_entry_declare(cmd_tbl_t, _name, cmd) = \
+ ll_entry_declare(struct cmd_tbl, _name, cmd) = \
U_BOOT_CMD_MKENT_COMPLETE(_name, _maxargs, _rep, _cmd, \
_usage, _help, _comp);
#define U_BOOT_CMDREP_COMPLETE(_name, _maxargs, _cmd_rep, _usage, \
_help, _comp) \
- ll_entry_declare(cmd_tbl_t, _name, cmd) = \
+ ll_entry_declare(struct cmd_tbl, _name, cmd) = \
U_BOOT_CMDREP_MKENT_COMPLETE(_name, _maxargs, _cmd_rep, \
_usage, _help, _comp)
#else
-#define U_BOOT_SUBCMD_START(name) static cmd_tbl_t name[] = {};
+#define U_BOOT_SUBCMD_START(name) static struct cmd_tbl name[] = {};
#define U_BOOT_SUBCMD_END
#define _CMD_REMOVE(_name, _cmd) \
int cpu_status(u32 nr);
int cpu_reset(u32 nr);
int cpu_disable(u32 nr);
-int cpu_release(u32 nr, int argc, char * const argv[]);
+int cpu_release(u32 nr, int argc, char *const argv[]);
static inline int cpumask_next(int cpu, unsigned int mask)
{
* Copyright (c) 2018, Heinrich Schuchardt <xypron.glpk@gmx.de>
*/
-static int do_exception(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+#include <command.h>
+
+static int do_exception(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
if (argc != 2)
return CMD_RET_USAGE;
return CMD_RET_USAGE;
}
-static int exception_complete(int argc, char * const argv[], char last_char,
+static int exception_complete(int argc, char *const argv[], char last_char,
int maxv, char *cmdv[])
{
int len = 0;
int i = 0;
- cmd_tbl_t *cmdtp;
+ struct cmd_tbl *cmdtp;
switch (argc) {
case 1:
#include <irq_func.h>
+struct cmd_tbl;
struct spi_slave;
/* Set up the jump table for use by the API */
#ifndef __EXT_COMMON__
#define __EXT_COMMON__
-#include <command.h>
+
+struct cmd_tbl;
+
#define SECTOR_SIZE 0x200
#define LOG2_SECTOR_SIZE 9
extern lbaint_t part_offset;
-int do_ext2ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
-int do_ext2load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
-int do_ext4_load(cmd_tbl_t *cmdtp, int flag, int argc,
- char *const argv[]);
-int do_ext4_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]);
-int do_ext4_write(cmd_tbl_t *cmdtp, int flag, int argc,
- char *const argv[]);
+int do_ext2ls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
+int do_ext2load(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
+int do_ext4_load(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
+int do_ext4_ls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
+int do_ext4_write(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
#endif
#include <common.h>
+struct cmd_tbl;
+
#define FS_TYPE_ANY 0
#define FS_TYPE_FAT 1
#define FS_TYPE_EXT 2
* @argv: List of arguments
* @return result (see enum command_ret_t)
*/
-int do_fat_fsload(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]);
+int do_fat_fsload(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
/**
* do_ext2load - Run the ext2load command
* @argv: List of arguments
* @return result (see enum command_ret_t)
*/
-int do_ext2load(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]);
+int do_ext2load(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
/*
* Tell the fs layer which block device an partition to use for future
* Common implementation for various filesystem commands, optionally limited
* to a specific filesystem type via the fstype parameter.
*/
-int do_size(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype);
-int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype);
-int do_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype);
+int do_size(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype);
+int do_load(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype);
+int do_ls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype);
int file_exists(const char *dev_type, const char *dev_part, const char *file,
int fstype);
-int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype);
-int do_rm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype);
-int do_mkdir(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype);
-int do_ln(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
+int do_save(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype);
+int do_rm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype);
+int do_mkdir(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype);
+int do_ln(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
int fstype);
/*
* Determine the UUID of the specified filesystem and print it. Optionally it is
* possible to store the UUID directly in env.
*/
-int do_fs_uuid(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
- int fstype);
+int do_fs_uuid(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
+ int fstype);
/*
* Determine the type of the specified filesystem and print it. Optionally it is
* possible to store the type directly in env.
*/
-int do_fs_type(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+int do_fs_type(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
#endif /* _FS_H */
#include <common_timing_params.h>
+struct cmd_tbl;
+
#ifndef CONFIG_SYS_FSL_DDR_MAIN_NUM_CTRLS
/* All controllers are for main memory */
#define CONFIG_SYS_FSL_DDR_MAIN_NUM_CTRLS CONFIG_SYS_NUM_DDR_CTLRS
void fsl_ddr_get_spd(generic_spd_eeprom_t *ctrl_dimms_spd,
unsigned int ctrl_num, unsigned int dimm_slots_per_ctrl);
-int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
unsigned int check_fsl_memctl_config_regs(const fsl_ddr_cfg_regs_t *ddr);
void board_add_ram_info(int use_default);
#include <fsl_sec.h>
#include <fsl_sec_mon.h>
-#include <command.h>
#include <linux/types.h>
+struct cmd_tbl;
+
#define WORD_SIZE 4
/* Minimum and maximum size of RSA signature length in bits */
uint32_t img_size; /* ESBC Image Size */
};
-int do_esbc_halt(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[]);
+int do_esbc_halt(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
int fsl_secboot_validate(uintptr_t haddr, char *arg_hash_str,
uintptr_t *img_addr_ptr);
-int fsl_secboot_blob_encap(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[]);
-int fsl_secboot_blob_decap(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[]);
+int fsl_secboot_blob_encap(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
+int fsl_secboot_blob_decap(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
int fsl_check_boot_mode_secure(void);
int fsl_setenv_chain_of_trust(void);
#ifndef _HASH_H
#define _HASH_H
+struct cmd_tbl;
+
/*
* Maximum digest size for all algorithms we support. Having this value
* avoids a malloc() or C99 local declaration in common/cmd_hash.c.
* @argc: Number of arguments (arg 0 must be the command text)
* @argv: Arguments
*/
-int hash_command(const char *algo_name, int flags, cmd_tbl_t *cmdtp, int flag,
- int argc, char * const argv[]);
+int hash_command(const char *algo_name, int flags, struct cmd_tbl *cmdtp,
+ int flag, int argc, char *const argv[]);
/**
* hash_block() - Hash a block according to the requested algorithm
int genimg_get_format(const void *img_addr);
int genimg_has_config(bootm_headers_t *images);
-int boot_get_fpga(int argc, char * const argv[], bootm_headers_t *images,
- uint8_t arch, const ulong *ld_start, ulong * const ld_len);
-int boot_get_ramdisk(int argc, char * const argv[], bootm_headers_t *images,
- uint8_t arch, ulong *rd_start, ulong *rd_end);
+int boot_get_fpga(int argc, char *const argv[], bootm_headers_t *images,
+ uint8_t arch, const ulong *ld_start, ulong * const ld_len);
+int boot_get_ramdisk(int argc, char *const argv[], bootm_headers_t *images,
+ uint8_t arch, ulong *rd_start, ulong *rd_end);
/**
* boot_get_loadable - routine to load a list of binaries to memory
* 0, if only valid images or no images are found
* error code, if an error occurs during fit_image_load
*/
-int boot_get_loadable(int argc, char * const argv[], bootm_headers_t *images,
- uint8_t arch, const ulong *ld_start, ulong * const ld_len);
+int boot_get_loadable(int argc, char *const argv[], bootm_headers_t *images,
+ uint8_t arch, const ulong *ld_start, ulong *const ld_len);
#endif /* !USE_HOSTCC */
int boot_get_setup_fit(bootm_headers_t *images, uint8_t arch,
int fit_get_node_from_config(bootm_headers_t *images, const char *prop_name,
ulong addr);
-int boot_get_fdt(int flag, int argc, char * const argv[], uint8_t arch,
+int boot_get_fdt(int flag, int argc, char *const argv[], uint8_t arch,
bootm_headers_t *images,
char **of_flat_tree, ulong *of_size);
void boot_fdt_add_mem_rsv_regions(struct lmb *lmb, void *fdt_blob);
extern void kgdb_putreg(struct pt_regs *, int, char *, int);
extern void kgdb_putregs(struct pt_regs *, char *, int);
extern int kgdb_trap(struct pt_regs *);
-extern void kgdb_breakpoint(int argc, char * const argv[]);
+void kgdb_breakpoint(int argc, char *const argv[]);
/* these functions are provided by the platform serial driver */
extern void kgdb_serial_init(void);
#define __LOG_H
#include <stdio.h>
-#include <command.h>
+#include <linker_lists.h>
#include <dm/uclass-id.h>
#include <linux/list.h>
+struct cmd_tbl;
+
/** Log levels supported, ranging from most to least important */
enum log_level_t {
LOGL_EMERG = 0, /* U-Boot is unstable */
};
/* Handle the 'log test' command */
-int do_log_test(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]);
+int do_log_test(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
/**
* log_add_filter() - Add a new filter to a log device
#include <rand.h>
struct bd_info;
-struct cmd_tbl_s;
+struct cmd_tbl;
struct udevice;
#define DEBUG_LL_STATE 0 /* Link local state machine changes */
* @argv: List of arguments
* @return result (see enum command_ret_t)
*/
-int do_tftpb(struct cmd_tbl_s *cmdtp, int flag, int argc, char *const argv[]);
+int do_tftpb(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
/**
* An incoming packet handler.
int hdelete_r(const char *key, struct hsearch_data *htab, int flag);
ssize_t hexport_r(struct hsearch_data *htab, const char sep, int flag,
- char **resp, size_t size, int argc, char * const argv[]);
+ char **resp, size_t size, int argc, char *const argv[]);
/*
* nvars: length of vars array
#ifndef __TEST_SUITES_H__
#define __TEST_SUITES_H__
+struct cmd_tbl;
struct unit_test;
/**
*/
int cmd_ut_category(const char *name, const char *prefix,
struct unit_test *tests, int n_ents,
- int argc, char * const argv[]);
+ int argc, char *const argv[]);
-int do_ut_bloblist(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]);
-int do_ut_compression(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]);
-int do_ut_dm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
-int do_ut_env(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
-int do_ut_lib(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
-int do_ut_log(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
-int do_ut_optee(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
-int do_ut_overlay(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
-int do_ut_str(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]);
-int do_ut_time(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
-int do_ut_unicode(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+int do_ut_bloblist(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
+int do_ut_compression(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
+int do_ut_dm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
+int do_ut_env(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
+int do_ut_lib(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
+int do_ut_log(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[]);
+int do_ut_optee(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
+int do_ut_overlay(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
+int do_ut_str(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
+int do_ut_time(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
+int do_ut_unicode(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
#endif /* __TEST_SUITES_H__ */
#ifndef __TEST_UT_H
#define __TEST_UT_H
+#include <command.h>
#include <hexdump.h>
#include <linux/err.h>
#ifndef __TPM_COMMON_H
#define __TPM_COMMON_H
+#include <command.h>
+
enum tpm_duration {
TPM_SHORT = 0,
TPM_MEDIUM = 1,
U_BOOT_CMD_MKENT(cmd, 0, 1, do_tpm_ ## cmd, "", "")
#define TPM_COMMAND_NO_ARG(cmd) \
-int do_##cmd(cmd_tbl_t *cmdtp, int flag, \
- int argc, char * const argv[]) \
+int do_##cmd(struct cmd_tbl *cmdtp, int flag, \
+ int argc, char *const argv[]) \
{ \
struct udevice *dev; \
int rc; \
/**
* Retrieve the array containing all the v1 (resp. v2) commands.
*
- * @return a cmd_tbl_t array.
+ * @return a struct cmd_tbl array.
*/
#if defined(CONFIG_TPM_V1)
-cmd_tbl_t *get_tpm1_commands(unsigned int *size);
+struct cmd_tbl *get_tpm1_commands(unsigned int *size);
#else
-static inline cmd_tbl_t *get_tpm1_commands(unsigned int *size)
+static inline struct cmd_tbl *get_tpm1_commands(unsigned int *size)
{
return NULL;
}
#endif
#if defined(CONFIG_TPM_V2)
-cmd_tbl_t *get_tpm2_commands(unsigned int *size);
+struct cmd_tbl *get_tpm2_commands(unsigned int *size);
#else
-static inline cmd_tbl_t *get_tpm2_commands(unsigned int *size)
+static inline struct cmd_tbl *get_tpm2_commands(unsigned int *size)
{
return NULL;
}
#include <efi_api.h>
struct bootm_headers;
+struct cmd_tbl;
/* Use Linux compatible standard DTB */
#define VXWORKS_SYSFLG_STD_DTB 0x1
u32 fb_size; /* framebuffer size */
};
-int do_bootvx(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+int do_bootvx(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]);
void boot_prep_vxworks(struct bootm_headers *images);
void boot_jump_vxworks(struct bootm_headers *images);
#include <div64.h>
#include "dhry.h"
-static int do_dhry(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_dhry(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
ulong start, duration, vax_mips;
u64 dhry_per_sec;
#include <common.h>
#include <efi_loader.h>
+#include <env.h>
#include <env_internal.h>
#include <hexdump.h>
#include <malloc.h>
*/
#include <common.h>
+#include <command.h>
#include <fdtdec.h>
#include <linux/libfdt.h>
#include <malloc.h>
return 0;
}
-static int do_test_fdtdec(cmd_tbl_t *cmdtp, int flag, int argc,
- char * const argv[])
+static int do_test_fdtdec(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
/* basic tests */
CHECKOK(run_test("", "", ""));
ssize_t hexport_r(struct hsearch_data *htab, const char sep, int flag,
char **resp, size_t size,
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
struct env_entry *list[htab->size];
char *res, *p;
*/
#include <common.h>
+#include <command.h>
#include <env.h>
#include <rand.h>
#include <time.h>
}
#if !defined(CONFIG_SPL_BUILD) && defined(CONFIG_CMD_UUID)
-int do_uuid(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_uuid(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
char uuid[UUID_STR_LEN + 1];
int str_format;
*/
#include <common.h>
+#include <env.h>
#include <net.h>
#include "arp.h"
*/
#include <common.h>
+#include <command.h>
#include <fastboot.h>
#include <net.h>
#include <net/fastboot.h>
BLOBLIST_TEST(bloblist_test_checksum, 0);
-int do_ut_bloblist(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_ut_bloblist(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct unit_test *tests = ll_entry_start(struct unit_test,
bloblist_test);
#include <test/suites.h>
#include <test/test.h>
-static int do_ut_all(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+static int do_ut_all(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[]);
int cmd_ut_category(const char *name, const char *prefix,
struct unit_test *tests, int n_ents,
- int argc, char * const argv[])
+ int argc, char *const argv[])
{
struct unit_test_state uts = { .fail_count = 0 };
struct unit_test *test;
return uts.fail_count ? CMD_RET_FAILURE : 0;
}
-static cmd_tbl_t cmd_ut_sub[] = {
+static struct cmd_tbl cmd_ut_sub[] = {
U_BOOT_CMD_MKENT(all, CONFIG_SYS_MAXARGS, 1, do_ut_all, "", ""),
#if defined(CONFIG_UT_DM)
U_BOOT_CMD_MKENT(dm, CONFIG_SYS_MAXARGS, 1, do_ut_dm, "", ""),
#endif
};
-static int do_ut_all(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_ut_all(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
int i;
int retval;
return any_fail;
}
-static int do_ut(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_ut(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
- cmd_tbl_t *cp;
+ struct cmd_tbl *cp;
if (argc < 2)
return CMD_RET_USAGE;
#include <common.h>
#include <command.h>
+#include <env.h>
static const char test_cmd[] = "setenv list 1\n setenv list ${list}2; "
"setenv list ${list}3\0"
"setenv list ${list}4";
-static int do_ut_cmd(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+static int do_ut_cmd(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
printf("%s: Testing commands\n", __func__);
run_command("env default -f -a", 0);
}
COMPRESSION_TEST(compression_test_bootm_none, 0);
-int do_ut_compression(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ut_compression(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
{
struct unit_test *tests = ll_entry_start(struct unit_test,
compression_test);
return uts->fail_count ? CMD_RET_FAILURE : 0;
}
-int do_ut_dm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ut_dm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
const char *test_name = NULL;
#include <test/suites.h>
#include <test/ut.h>
-int do_ut_env(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ut_env(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct unit_test *tests = ll_entry_start(struct unit_test, env_test);
const int n_ents = ll_entry_count(struct unit_test, env_test);
#include <test/suites.h>
#include <test/ut.h>
-int do_ut_lib(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ut_lib(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct unit_test *tests = ll_entry_start(struct unit_test, lib_test);
const int n_ents = ll_entry_count(struct unit_test, lib_test);
*/
#include <common.h>
+#include <command.h>
/* emit some sample log records in different ways, for testing */
static int log_run(enum uclass_id cat, const char *file)
}
#ifdef CONFIG_LOG_TEST
-int do_log_test(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_log_test(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int testnum = 0;
int ret;
#include <test/log.h>
#include <test/suites.h>
-int do_ut_log(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ut_log(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[])
{
struct unit_test *tests = ll_entry_start(struct unit_test, log_test);
const int n_ents = ll_entry_count(struct unit_test, log_test);
}
OPTEE_TEST(optee_fdt_protected_memory, 0);
-int do_ut_optee(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ut_optee(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct unit_test *tests = ll_entry_start(struct unit_test,
optee_test);
}
OVERLAY_TEST(fdt_overlay_stacked, 0);
-int do_ut_overlay(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ut_overlay(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct unit_test *tests = ll_entry_start(struct unit_test,
overlay_test);
#include <common.h>
#if CONFIG_IS_ENABLED(EFI_LOADER) && !defined(API_BUILD)
+#include <command.h>
#include <efi_api.h>
#endif
#include <display_options.h>
#endif
}
-static int do_ut_print(cmd_tbl_t *cmdtp, int flag, int argc,
+static int do_ut_print(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
char big_str[400];
}
STR_TEST(str_simple_strtoul, 0);
-int do_ut_str(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
+int do_ut_str(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct unit_test *tests = ll_entry_start(struct unit_test,
str_test);
return 0;
}
-int do_ut_time(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ut_time(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
int ret = 0;
}
UNICODE_TEST(unicode_test_u16_strsize);
-int do_ut_unicode(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_ut_unicode(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
{
struct unit_test *tests = ll_entry_start(struct unit_test, unicode_test);
const int n_ents = ll_entry_count(struct unit_test, unicode_test);
return 0;
}
-static int prof_tool(int argc, char * const argv[],
+static int prof_tool(int argc, char *const argv[],
const char *prof_fname, const char *map_fname,
const char *trace_config_fname)
{
projects / platform / kernel / u-boot.git / commitdiff