This patch converts all instances of 'argc' in COMMAND_HANDLER routines
to use CMD_ARGC.
64 files changed:
default:
command_print(cmd_ctx,"Too many parameters\n");
return ERROR_COMMAND_SYNTAX_ERROR;
default:
command_print(cmd_ctx,"Too many parameters\n");
return ERROR_COMMAND_SYNTAX_ERROR;
at91sam7_info->ext_freq = 0;
at91sam7_info->flash_autodetection = 0;
at91sam7_info->ext_freq = 0;
at91sam7_info->flash_autodetection = 0;
{
at91sam7_info->flash_autodetection = 1;
return ERROR_OK;
{
at91sam7_info->flash_autodetection = 1;
return ERROR_OK;
COMMAND_PARSE_NUMBER(u16, args[11], page_size);
COMMAND_PARSE_NUMBER(u16, args[12], num_nvmbits);
COMMAND_PARSE_NUMBER(u16, args[11], page_size);
COMMAND_PARSE_NUMBER(u16, args[12], num_nvmbits);
unsigned long freq;
COMMAND_PARSE_NUMBER(ulong, args[13], freq);
ext_freq = freq * 1000;
unsigned long freq;
COMMAND_PARSE_NUMBER(ulong, args[13], freq);
ext_freq = freq * 1000;
struct at91sam7_flash_bank *at91sam7_info;
int retval;
struct at91sam7_flash_bank *at91sam7_info;
int retval;
{
command_print(cmd_ctx, "at91sam7 gpnvm <bit> <set | clear>");
return ERROR_OK;
{
command_print(cmd_ctx, "at91sam7 gpnvm <bit> <set | clear>");
return ERROR_OK;
{
struct avrf_flash_bank *avrf_info;
{
struct avrf_flash_bank *avrf_info;
{
LOG_WARNING("incomplete flash_bank avr configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank avr configuration");
return ERROR_FLASH_BANK_INVALID;
{
command_print(cmd_ctx, "avr mass_erase <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "avr mass_erase <bank>");
return ERROR_OK;
{
struct cfi_flash_bank *cfi_info;
{
struct cfi_flash_bank *cfi_info;
{
LOG_WARNING("incomplete flash_bank cfi configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank cfi configuration");
return ERROR_FLASH_BANK_INVALID;
cfi_info->jedec_probe = 0;
cfi_info->not_cfi = 0;
cfi_info->jedec_probe = 0;
cfi_info->not_cfi = 0;
- for (unsigned i = 6; i < argc; i++)
+ for (unsigned i = 6; i < CMD_ARGC; i++)
{
if (strcmp(args[i], "x16_as_x8") == 0)
{
{
if (strcmp(args[i], "x16_as_x8") == 0)
{
* - aemif address
* Plus someday, optionally, ALE and CLE masks.
*/
* - aemif address
* Plus someday, optionally, ALE and CLE masks.
*/
LOG_ERROR("parameters: %s target "
"chip_addr hwecc_mode aemif_addr",
args[0]);
LOG_ERROR("parameters: %s target "
"chip_addr hwecc_mode aemif_addr",
args[0]);
{
struct ecosflash_flash_bank *info;
{
struct ecosflash_flash_bank *info;
{
LOG_WARNING("incomplete flash_bank ecosflash configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank ecosflash configuration");
return ERROR_FLASH_BANK_INVALID;
{
struct faux_flash_bank *info;
{
struct faux_flash_bank *info;
{
LOG_WARNING("incomplete flash_bank faux configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank faux configuration");
return ERROR_FLASH_BANK_INVALID;
int found = 0;
struct target *target;
int found = 0;
struct target *target;
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned bank_nr;
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned bank_nr;
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
COMMAND_HANDLER(handle_flash_erase_check_command)
{
COMMAND_HANDLER(handle_flash_erase_check_command)
{
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
struct target *target = get_current_target(cmd_ctx);
struct target *target = get_current_target(cmd_ctx);
return ERROR_COMMAND_SYNTAX_ERROR;
COMMAND_PARSE_NUMBER(int, args[0], address);
return ERROR_COMMAND_SYNTAX_ERROR;
COMMAND_PARSE_NUMBER(int, args[0], address);
COMMAND_HANDLER(handle_flash_protect_check_command)
{
COMMAND_HANDLER(handle_flash_protect_check_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
struct flash_bank *p;
return ERROR_COMMAND_SYNTAX_ERROR;
struct flash_bank *p;
COMMAND_HANDLER(handle_flash_erase_command)
{
COMMAND_HANDLER(handle_flash_erase_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t bank_nr;
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t bank_nr;
COMMAND_HANDLER(handle_flash_protect_command)
{
COMMAND_HANDLER(handle_flash_protect_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t bank_nr;
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t bank_nr;
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
auto_erase = 1;
args++;
{
auto_erase = 1;
args++;
command_print(cmd_ctx, "auto erase enabled");
} else if (strcmp(args[0], "unlock") == 0)
{
auto_unlock = true;
args++;
command_print(cmd_ctx, "auto erase enabled");
} else if (strcmp(args[0], "unlock") == 0)
{
auto_unlock = true;
args++;
command_print(cmd_ctx, "auto unlock enabled");
} else
{
command_print(cmd_ctx, "auto unlock enabled");
} else
{
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
struct duration bench;
duration_start(&bench);
struct duration bench;
duration_start(&bench);
{
image.base_address_set = 1;
COMMAND_PARSE_NUMBER(int, args[1], image.base_address);
{
image.base_address_set = 1;
COMMAND_PARSE_NUMBER(int, args[1], image.base_address);
image.start_address_set = 0;
image.start_address_set = 0;
- retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL);
+ retval = image_open(&image, args[0], (CMD_ARGC == 3) ? args[2] : NULL);
if (retval != ERROR_OK)
{
return retval;
if (retval != ERROR_OK)
{
return retval;
uint32_t i;
uint32_t wordsize;
uint32_t i;
uint32_t wordsize;
return ERROR_COMMAND_SYNTAX_ERROR;
COMMAND_PARSE_NUMBER(u32, args[0], address);
return ERROR_COMMAND_SYNTAX_ERROR;
COMMAND_PARSE_NUMBER(u32, args[0], address);
uint8_t *buffer;
struct fileio fileio;
uint8_t *buffer;
struct fileio fileio;
return ERROR_COMMAND_SYNTAX_ERROR;
struct duration bench;
return ERROR_COMMAND_SYNTAX_ERROR;
struct duration bench;
*
* For example, args[4] = 16 bit flash, args[5] = 32bit bus.
*
*
* For example, args[4] = 16 bit flash, args[5] = 32bit bus.
*
- * If extra arguments are provided (@a argc > 6), they will
+ * If extra arguments are provided (@a CMD_ARGC > 6), they will
* start in @a args[6]. These can be used to implement
* driver-specific extensions.
*
* start in @a args[6]. These can be used to implement
* driver-specific extensions.
*
{
struct lpc2000_flash_bank *lpc2000_info;
{
struct lpc2000_flash_bank *lpc2000_info;
{
LOG_WARNING("incomplete flash_bank lpc2000 configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank lpc2000 configuration");
return ERROR_FLASH_BANK_INVALID;
lpc2000_info->calc_checksum = 0;
lpc2000_build_sector_list(bank);
lpc2000_info->calc_checksum = 0;
lpc2000_build_sector_list(bank);
{
if (strcmp(args[8], "calc_checksum") == 0)
lpc2000_info->calc_checksum = 1;
{
if (strcmp(args[8], "calc_checksum") == 0)
lpc2000_info->calc_checksum = 1;
uint32_t result_table[4];
int status_code;
uint32_t result_table[4];
int status_code;
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
struct lpc288x_flash_bank *lpc288x_info;
{
struct lpc288x_flash_bank *lpc288x_info;
{
LOG_WARNING("incomplete flash_bank LPC288x configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank LPC288x configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING( "Too few arguments. Call: lpc2900 signature <bank#>" );
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING( "Too few arguments. Call: lpc2900 signature <bank#>" );
return ERROR_FLASH_BANK_INVALID;
*/
COMMAND_HANDLER(lpc2900_handle_read_custom_command)
{
*/
COMMAND_HANDLER(lpc2900_handle_read_custom_command)
{
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
*/
COMMAND_HANDLER(lpc2900_handle_password_command)
{
*/
COMMAND_HANDLER(lpc2900_handle_password_command)
{
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
*/
COMMAND_HANDLER(lpc2900_handle_write_custom_command)
{
*/
COMMAND_HANDLER(lpc2900_handle_write_custom_command)
{
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
image.start_address_set = 0;
const char *filename = args[1];
image.start_address_set = 0;
const char *filename = args[1];
- const char *type = (argc >= 3) ? args[2] : NULL;
+ const char *type = (CMD_ARGC >= 3) ? args[2] : NULL;
retval = image_open(&image, filename, type);
if (retval != ERROR_OK)
{
retval = image_open(&image, filename, type);
if (retval != ERROR_OK)
{
*/
COMMAND_HANDLER(lpc2900_handle_secure_sector_command)
{
*/
COMMAND_HANDLER(lpc2900_handle_secure_sector_command)
{
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
*/
COMMAND_HANDLER(lpc2900_handle_secure_jtag_command)
{
*/
COMMAND_HANDLER(lpc2900_handle_secure_jtag_command)
{
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
struct lpc2900_flash_bank *lpc2900_info;
{
struct lpc2900_flash_bank *lpc2900_info;
{
LOG_WARNING("incomplete flash_bank LPC2900 configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank LPC2900 configuration");
return ERROR_FLASH_BANK_INVALID;
*/
NAND_DEVICE_COMMAND_HANDLER(lpc3180_nand_device_command)
{
*/
NAND_DEVICE_COMMAND_HANDLER(lpc3180_nand_device_command)
{
{
LOG_WARNING("incomplete 'lpc3180' nand flash configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete 'lpc3180' nand flash configuration");
return ERROR_FLASH_BANK_INVALID;
- if ((argc < 1) || (argc > 2))
+ if ((CMD_ARGC < 1) || (CMD_ARGC > 2))
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
lpc3180_info = nand->controller_priv;
lpc3180_info = nand->controller_priv;
{
if (strcmp(args[1], "mlc") == 0)
{
{
if (strcmp(args[1], "mlc") == 0)
{
struct fileio fileio;
int ret;
struct fileio fileio;
int ret;
return ERROR_COMMAND_SYNTAX_ERROR;
}
return ERROR_COMMAND_SYNTAX_ERROR;
}
struct fileio fileio;
int ret;
struct fileio fileio;
int ret;
return ERROR_COMMAND_SYNTAX_ERROR;
}
return ERROR_COMMAND_SYNTAX_ERROR;
}
if ((ret = mg_mflash_rst()) != ERROR_OK)
return ret;
if ((ret = mg_mflash_rst()) != ERROR_OK)
return ret;
case 2:
if (!strcmp(args[1], "boot"))
return mg_boot_config();
case 2:
if (!strcmp(args[1], "boot"))
return mg_boot_config();
struct target *target;
int i;
struct target *target;
int i;
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
LOG_ERROR ("target '%s' not defined", args[1]);
return ERROR_FAIL;
}
LOG_ERROR ("target '%s' not defined", args[1]);
return ERROR_FAIL;
}
{
LOG_ERROR ("use \"nand device imx31 target noecc|hwecc\"");
return ERROR_FAIL;
{
LOG_ERROR ("use \"nand device imx31 target noecc|hwecc\"");
return ERROR_FAIL;
{
LOG_WARNING("incomplete flash device nand configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash device nand configuration");
return ERROR_FLASH_BANK_INVALID;
if (ERROR_OK != retval)
return retval;
if (ERROR_OK != retval)
return retval;
default:
return ERROR_COMMAND_SYNTAX_ERROR;
case 1:
default:
return ERROR_COMMAND_SYNTAX_ERROR;
case 1:
COMMAND_HANDLER(handle_nand_probe_command)
{
COMMAND_HANDLER(handle_nand_probe_command)
{
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
COMMAND_HANDLER(handle_nand_erase_command)
{
COMMAND_HANDLER(handle_nand_erase_command)
{
- if (argc != 1 && argc != 3)
+ if (CMD_ARGC != 1 && CMD_ARGC != 3)
{
return ERROR_COMMAND_SYNTAX_ERROR;
{
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned long length;
/* erase specified part of the chip; or else everything */
unsigned long length;
/* erase specified part of the chip; or else everything */
unsigned long size = p->erase_size * p->num_blocks;
COMMAND_PARSE_NUMBER(ulong, args[1], offset);
unsigned long size = p->erase_size * p->num_blocks;
COMMAND_PARSE_NUMBER(ulong, args[1], offset);
int first = -1;
int last = -1;
int first = -1;
int last = -1;
- if ((argc < 1) || (argc > 3) || (argc == 2))
+ if ((CMD_ARGC < 1) || (CMD_ARGC > 3) || (CMD_ARGC == 2))
{
return ERROR_COMMAND_SYNTAX_ERROR;
{
return ERROR_COMMAND_SYNTAX_ERROR;
if (ERROR_OK != retval)
return retval;
if (ERROR_OK != retval)
return retval;
{
unsigned long offset;
unsigned long length;
{
unsigned long offset;
unsigned long length;
nand_fileio_init(state);
unsigned minargs = need_size ? 4 : 3;
nand_fileio_init(state);
unsigned minargs = need_size ? 4 : 3;
+ if (CMD_ARGC < minargs)
return ERROR_COMMAND_SYNTAX_ERROR;
struct nand_device *nand;
return ERROR_COMMAND_SYNTAX_ERROR;
struct nand_device *nand;
+ if (CMD_ARGC > minargs)
- for (unsigned i = minargs; i < argc; i++)
+ for (unsigned i = minargs; i < CMD_ARGC; i++)
{
if (!strcmp(args[i], "oob_raw"))
state->oob_format |= NAND_OOB_RAW;
{
if (!strcmp(args[i], "oob_raw"))
state->oob_format |= NAND_OOB_RAW;
COMMAND_HANDLER(handle_nand_raw_access_command)
{
COMMAND_HANDLER(handle_nand_raw_access_command)
{
- if ((argc < 1) || (argc > 2))
+ if ((CMD_ARGC < 1) || (CMD_ARGC > 2))
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
if (strcmp("enable", args[1]) == 0)
p->use_raw = 1;
{
if (strcmp("enable", args[1]) == 0)
p->use_raw = 1;
struct arm7_9_common *arm7_9;
struct ocl_priv *ocl;
struct arm7_9_common *arm7_9;
struct ocl_priv *ocl;
{
LOG_WARNING("incomplete flash_bank ocl configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank ocl configuration");
return ERROR_FLASH_BANK_INVALID;
uint32_t base;
uint8_t ale, cle;
uint32_t base;
uint8_t ale, cle;
LOG_ERROR("arguments must be: <target_id> <NAND_address>\n");
return ERROR_NAND_DEVICE_INVALID;
}
LOG_ERROR("arguments must be: <target_id> <NAND_address>\n");
return ERROR_NAND_DEVICE_INVALID;
}
{
struct pic32mx_flash_bank *pic32mx_info;
{
struct pic32mx_flash_bank *pic32mx_info;
{
LOG_WARNING("incomplete flash_bank pic32mx configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank pic32mx configuration");
return ERROR_FLASH_BANK_INVALID;
struct target *target = NULL;
struct pic32mx_flash_bank *pic32mx_info = NULL;
struct target *target = NULL;
struct pic32mx_flash_bank *pic32mx_info = NULL;
{
command_print(cmd_ctx, "pic32mx lock <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "pic32mx lock <bank>");
return ERROR_OK;
struct target *target = NULL;
struct pic32mx_flash_bank *pic32mx_info = NULL;
struct target *target = NULL;
struct pic32mx_flash_bank *pic32mx_info = NULL;
{
command_print(cmd_ctx, "pic32mx unlock <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "pic32mx unlock <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "pic32mx chip_erase");
return ERROR_OK;
{
command_print(cmd_ctx, "pic32mx chip_erase");
return ERROR_OK;
uint32_t address, value;
int status, res;
uint32_t address, value;
int status, res;
{
command_print(cmd_ctx, "pic32mx pgm_word <addr> <value> <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "pic32mx pgm_word <addr> <value> <bank>");
return ERROR_OK;
{
struct stellaris_flash_bank *stellaris_info;
{
struct stellaris_flash_bank *stellaris_info;
{
LOG_WARNING("incomplete flash_bank stellaris configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank stellaris configuration");
return ERROR_FLASH_BANK_INVALID;
{
command_print(cmd_ctx, "stellaris mass_erase <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "stellaris mass_erase <bank>");
return ERROR_OK;
{
struct stm32x_flash_bank *stm32x_info;
{
struct stm32x_flash_bank *stm32x_info;
{
LOG_WARNING("incomplete flash_bank stm32x configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank stm32x configuration");
return ERROR_FLASH_BANK_INVALID;
struct target *target = NULL;
struct stm32x_flash_bank *stm32x_info = NULL;
struct target *target = NULL;
struct stm32x_flash_bank *stm32x_info = NULL;
{
command_print(cmd_ctx, "stm32x lock <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "stm32x lock <bank>");
return ERROR_OK;
struct target *target = NULL;
struct stm32x_flash_bank *stm32x_info = NULL;
struct target *target = NULL;
struct stm32x_flash_bank *stm32x_info = NULL;
{
command_print(cmd_ctx, "stm32x unlock <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "stm32x unlock <bank>");
return ERROR_OK;
struct target *target = NULL;
struct stm32x_flash_bank *stm32x_info = NULL;
struct target *target = NULL;
struct stm32x_flash_bank *stm32x_info = NULL;
{
command_print(cmd_ctx, "stm32x options_read <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "stm32x options_read <bank>");
return ERROR_OK;
struct stm32x_flash_bank *stm32x_info = NULL;
uint16_t optionbyte = 0xF8;
struct stm32x_flash_bank *stm32x_info = NULL;
uint16_t optionbyte = 0xF8;
{
command_print(cmd_ctx, "stm32x options_write <bank> <SWWDG | HWWDG> <RSTSTNDBY | NORSTSTNDBY> <RSTSTOP | NORSTSTOP>");
return ERROR_OK;
{
command_print(cmd_ctx, "stm32x options_write <bank> <SWWDG | HWWDG> <RSTSTNDBY | NORSTSTNDBY> <RSTSTOP | NORSTSTOP>");
return ERROR_OK;
{
command_print(cmd_ctx, "stm32x mass_erase <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "stm32x mass_erase <bank>");
return ERROR_OK;
{
struct str7x_flash_bank *str7x_info;
{
struct str7x_flash_bank *str7x_info;
{
LOG_WARNING("incomplete flash_bank str7x configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank str7x configuration");
return ERROR_FLASH_BANK_INVALID;
uint16_t ProtectionLevel = 0;
uint16_t ProtectionRegs;
uint16_t ProtectionLevel = 0;
uint16_t ProtectionRegs;
{
command_print(cmd_ctx, "str7x disable_jtag <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "str7x disable_jtag <bank>");
return ERROR_OK;
{
struct str9x_flash_bank *str9x_info;
{
struct str9x_flash_bank *str9x_info;
{
LOG_WARNING("incomplete flash_bank str9x configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank str9x configuration");
return ERROR_FLASH_BANK_INVALID;
struct str9x_flash_bank *str9x_info;
struct target *target = NULL;
struct str9x_flash_bank *str9x_info;
struct target *target = NULL;
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
struct arm7_9_common *arm7_9 = NULL;
struct arm_jtag *jtag_info = NULL;
struct arm7_9_common *arm7_9 = NULL;
struct arm_jtag *jtag_info = NULL;
{
LOG_WARNING("incomplete flash_bank str9x configuration");
return ERROR_FLASH_BANK_INVALID;
{
LOG_WARNING("incomplete flash_bank str9x configuration");
return ERROR_FLASH_BANK_INVALID;
uint32_t idcode;
struct str9xpec_flash_controller *str9xpec_info = NULL;
uint32_t idcode;
struct str9xpec_flash_controller *str9xpec_info = NULL;
return ERROR_COMMAND_SYNTAX_ERROR;
struct flash_bank *bank;
return ERROR_COMMAND_SYNTAX_ERROR;
struct flash_bank *bank;
uint8_t status;
struct str9xpec_flash_controller *str9xpec_info = NULL;
uint8_t status;
struct str9xpec_flash_controller *str9xpec_info = NULL;
{
command_print(cmd_ctx, "str9xpec options_read <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "str9xpec options_read <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "str9xpec options_write <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "str9xpec options_write <bank>");
return ERROR_OK;
{
struct str9xpec_flash_controller *str9xpec_info = NULL;
{
struct str9xpec_flash_controller *str9xpec_info = NULL;
{
command_print(cmd_ctx, "str9xpec options_cmap <bank> <bank0 | bank1>");
return ERROR_OK;
{
command_print(cmd_ctx, "str9xpec options_cmap <bank> <bank0 | bank1>");
return ERROR_OK;
{
struct str9xpec_flash_controller *str9xpec_info = NULL;
{
struct str9xpec_flash_controller *str9xpec_info = NULL;
{
command_print(cmd_ctx, "str9xpec options_lvdthd <bank> <2.4v | 2.7v>");
return ERROR_OK;
{
command_print(cmd_ctx, "str9xpec options_lvdthd <bank> <2.4v | 2.7v>");
return ERROR_OK;
{
struct str9xpec_flash_controller *str9xpec_info = NULL;
{
struct str9xpec_flash_controller *str9xpec_info = NULL;
{
command_print(cmd_ctx, "str9xpec options_lvdsel <bank> <vdd | vdd_vddq>");
return ERROR_OK;
{
command_print(cmd_ctx, "str9xpec options_lvdsel <bank> <vdd | vdd_vddq>");
return ERROR_OK;
{
struct str9xpec_flash_controller *str9xpec_info = NULL;
{
struct str9xpec_flash_controller *str9xpec_info = NULL;
{
command_print(cmd_ctx, "str9xpec options_lvdwarn <bank> <vdd | vdd_vddq>");
return ERROR_OK;
{
command_print(cmd_ctx, "str9xpec options_lvdwarn <bank> <vdd | vdd_vddq>");
return ERROR_OK;
{
command_print(cmd_ctx, "str9xpec lock <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "str9xpec lock <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "str9xpec unlock <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "str9xpec unlock <bank>");
return ERROR_OK;
struct jtag_tap *tap2;
struct str9xpec_flash_controller *str9xpec_info = NULL;
struct jtag_tap *tap2;
struct str9xpec_flash_controller *str9xpec_info = NULL;
{
command_print(cmd_ctx, "str9xpec enable_turbo <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "str9xpec enable_turbo <bank>");
return ERROR_OK;
struct jtag_tap *tap;
struct str9xpec_flash_controller *str9xpec_info = NULL;
struct jtag_tap *tap;
struct str9xpec_flash_controller *str9xpec_info = NULL;
{
command_print(cmd_ctx, "str9xpec disable_turbo <bank>");
return ERROR_OK;
{
command_print(cmd_ctx, "str9xpec disable_turbo <bank>");
return ERROR_OK;
COMMAND_HANDLER(tms470_handle_flash_keyset_command)
{
COMMAND_HANDLER(tms470_handle_flash_keyset_command)
{
{
command_print(cmd_ctx, "tms470 flash_keyset <key0> <key1> <key2> <key3>");
return ERROR_INVALID_ARGUMENTS;
}
{
command_print(cmd_ctx, "tms470 flash_keyset <key0> <key1> <key2> <key3>");
return ERROR_INVALID_ARGUMENTS;
}
+ else if (CMD_ARGC == 4)
+ else if (CMD_ARGC != 0)
{
command_print(cmd_ctx, "tms470 flash_keyset <key0> <key1> <key2> <key3>");
return ERROR_INVALID_ARGUMENTS;
{
command_print(cmd_ctx, "tms470 flash_keyset <key0> <key1> <key2> <key3>");
return ERROR_INVALID_ARGUMENTS;
COMMAND_HANDLER(tms470_handle_osc_megahertz_command)
{
COMMAND_HANDLER(tms470_handle_osc_megahertz_command)
{
{
command_print(cmd_ctx, "tms470 osc_megahertz <MHz>");
return ERROR_INVALID_ARGUMENTS;
}
{
command_print(cmd_ctx, "tms470 osc_megahertz <MHz>");
return ERROR_INVALID_ARGUMENTS;
}
+ else if (CMD_ARGC == 1)
{
sscanf(args[0], "%d", &oscMHz);
}
{
sscanf(args[0], "%d", &oscMHz);
}
COMMAND_HANDLER(tms470_handle_plldis_command)
{
COMMAND_HANDLER(tms470_handle_plldis_command)
{
{
command_print(cmd_ctx, "tms470 plldis <0 | 1>");
return ERROR_INVALID_ARGUMENTS;
}
{
command_print(cmd_ctx, "tms470 plldis <0 | 1>");
return ERROR_INVALID_ARGUMENTS;
}
+ else if (CMD_ARGC == 1)
{
sscanf(args[0], "%d", &plldis);
plldis = plldis ? 1 : 0;
{
sscanf(args[0], "%d", &plldis);
plldis = plldis ? 1 : 0;
static COMMAND_HELPER(handle_hello_args, const char **sep, const char **name)
{
static COMMAND_HELPER(handle_hello_args, const char **sep, const char **name)
{
{
LOG_ERROR("%s: too many arguments", CMD_NAME);
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
LOG_ERROR("%s: too many arguments", CMD_NAME);
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
*sep = " ";
*name = args[0];
{
*sep = " ";
*name = args[0];
COMMAND_HANDLER(handle_sleep_command)
{
bool busy = false;
COMMAND_HANDLER(handle_sleep_command)
{
bool busy = false;
{
if (strcmp(args[1], "busy") == 0)
busy = true;
else
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
if (strcmp(args[1], "busy") == 0)
busy = true;
else
return ERROR_COMMAND_SYNTAX_ERROR;
}
- else if (argc < 1 || argc > 2)
+ else if (CMD_ARGC < 1 || CMD_ARGC > 2)
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned long duration = 0;
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned long duration = 0;
COMMAND_HANDLER(handle_fast_command)
{
COMMAND_HANDLER(handle_fast_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
fast_and_dangerous = strcmp("enable", args[0]) == 0;
return ERROR_COMMAND_SYNTAX_ERROR;
fast_and_dangerous = strcmp("enable", args[0]) == 0;
COMMAND_HANDLER(handle_rm_command)
{
COMMAND_HANDLER(handle_rm_command)
{
{
command_print(cmd_ctx, "rm <filename>");
return ERROR_INVALID_ARGUMENTS;
{
command_print(cmd_ctx, "rm <filename>");
return ERROR_INVALID_ARGUMENTS;
COMMAND_HANDLER(handle_cat_command)
{
COMMAND_HANDLER(handle_cat_command)
{
{
command_print(cmd_ctx, "cat <filename>");
return ERROR_INVALID_ARGUMENTS;
{
command_print(cmd_ctx, "cat <filename>");
return ERROR_INVALID_ARGUMENTS;
COMMAND_HANDLER(handle_trunc_command)
{
COMMAND_HANDLER(handle_trunc_command)
{
{
command_print(cmd_ctx, "trunc <filename>");
return ERROR_INVALID_ARGUMENTS;
{
command_print(cmd_ctx, "trunc <filename>");
return ERROR_INVALID_ARGUMENTS;
static int prev = 0;
struct mallinfo info;
static int prev = 0;
struct mallinfo info;
{
command_print(cmd_ctx, "meminfo");
return ERROR_INVALID_ARGUMENTS;
{
command_print(cmd_ctx, "meminfo");
return ERROR_INVALID_ARGUMENTS;
COMMAND_HANDLER(handle_append_command)
{
COMMAND_HANDLER(handle_append_command)
{
{
command_print(cmd_ctx,
"append <filename> [<string1>, [<string2>, ...]]");
{
command_print(cmd_ctx,
"append <filename> [<string1>, [<string2>, ...]]");
fseek(config_file, 0, SEEK_END);
unsigned i;
fseek(config_file, 0, SEEK_END);
unsigned i;
- for (i = 1; i < argc; i++)
+ for (i = 1; i < CMD_ARGC; i++)
{
if (fwrite(args[i], 1, strlen(args[i]), config_file) != strlen(args[i]))
break;
{
if (fwrite(args[i], 1, strlen(args[i]), config_file) != strlen(args[i]))
break;
{
if (fwrite(" ", 1, 1, config_file) != 1)
break;
}
}
{
if (fwrite(" ", 1, 1, config_file) != 1)
break;
}
}
- if ((i == argc) && (fwrite("\n", 1, 1, config_file) == 1))
+ if ((i == CMD_ARGC) && (fwrite("\n", 1, 1, config_file) == 1))
COMMAND_HANDLER(handle_cp_command)
{
COMMAND_HANDLER(handle_cp_command)
{
{
return ERROR_INVALID_ARGUMENTS;
}
{
return ERROR_INVALID_ARGUMENTS;
}
*/
COMMAND_HANDLER(handle_debug_level_command)
{
*/
COMMAND_HANDLER(handle_debug_level_command)
{
{
unsigned new_level;
COMMAND_PARSE_NUMBER(uint, args[0], new_level);
debug_level = MIN(new_level, LOG_LVL_DEBUG);
}
{
unsigned new_level;
COMMAND_PARSE_NUMBER(uint, args[0], new_level);
debug_level = MIN(new_level, LOG_LVL_DEBUG);
}
return ERROR_COMMAND_SYNTAX_ERROR;
if (debug_level >= LOG_LVL_DEBUG && server_use_pipes == 1)
return ERROR_COMMAND_SYNTAX_ERROR;
if (debug_level >= LOG_LVL_DEBUG && server_use_pipes == 1)
COMMAND_HANDLER(handle_log_output_command)
{
COMMAND_HANDLER(handle_log_output_command)
{
{
FILE* file = fopen(args[0], "w");
{
FILE* file = fopen(args[0], "w");
COMMAND_HANDLER(amt_jtagaccel_handle_parport_port_command)
{
COMMAND_HANDLER(amt_jtagaccel_handle_parport_port_command)
{
{
/* only if the port wasn't overwritten by cmdline */
if (amt_jtagaccel_port == 0)
{
/* only if the port wasn't overwritten by cmdline */
if (amt_jtagaccel_port == 0)
COMMAND_HANDLER(amt_jtagaccel_handle_rtck_command)
{
COMMAND_HANDLER(amt_jtagaccel_handle_rtck_command)
{
{
command_print(cmd_ctx, "amt_jtagaccel RTCK feature %s", (rtck_enabled) ? "enabled" : "disabled");
return ERROR_OK;
{
command_print(cmd_ctx, "amt_jtagaccel RTCK feature %s", (rtck_enabled) ? "enabled" : "disabled");
return ERROR_OK;
static int at91rm9200_handle_device_command(struct command_context *cmd_ctx, char *cmd, char **args, int argc)
{
static int at91rm9200_handle_device_command(struct command_context *cmd_ctx, char *cmd, char **args, int argc)
{
return ERROR_OK;
/* only if the device name wasn't overwritten by cmdline */
return ERROR_OK;
/* only if the device name wasn't overwritten by cmdline */
{
char *cp;
char buf[200];
{
char *cp;
char buf[200];
{
ft2232_device_desc = strdup(args[0]);
cp = strchr(ft2232_device_desc, 0);
{
ft2232_device_desc = strdup(args[0]);
cp = strchr(ft2232_device_desc, 0);
COMMAND_HANDLER(ft2232_handle_serial_command)
{
COMMAND_HANDLER(ft2232_handle_serial_command)
{
{
ft2232_serial = strdup(args[0]);
}
{
ft2232_serial = strdup(args[0]);
}
COMMAND_HANDLER(ft2232_handle_layout_command)
{
COMMAND_HANDLER(ft2232_handle_layout_command)
{
return ERROR_OK;
ft2232_layout = malloc(strlen(args[0]) + 1);
return ERROR_OK;
ft2232_layout = malloc(strlen(args[0]) + 1);
COMMAND_HANDLER(ft2232_handle_vid_pid_command)
{
COMMAND_HANDLER(ft2232_handle_vid_pid_command)
{
- if (argc > MAX_USB_IDS * 2)
+ if (CMD_ARGC > MAX_USB_IDS * 2)
{
LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
"(maximum is %d pairs)", MAX_USB_IDS);
{
LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
"(maximum is %d pairs)", MAX_USB_IDS);
- argc = MAX_USB_IDS * 2;
+ CMD_ARGC = MAX_USB_IDS * 2;
- if (argc < 2 || (argc & 1))
+ if (CMD_ARGC < 2 || (CMD_ARGC & 1))
{
LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
{
LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
return ERROR_COMMAND_SYNTAX_ERROR;
/* remove the incomplete trailing id */
return ERROR_COMMAND_SYNTAX_ERROR;
/* remove the incomplete trailing id */
- for (i = 0; i < argc; i += 2)
+ for (i = 0; i < CMD_ARGC; i += 2)
{
COMMAND_PARSE_NUMBER(u16, args[i], ft2232_vid[i >> 1]);
COMMAND_PARSE_NUMBER(u16, args[i + 1], ft2232_pid[i >> 1]);
{
COMMAND_PARSE_NUMBER(u16, args[i], ft2232_vid[i >> 1]);
COMMAND_PARSE_NUMBER(u16, args[i + 1], ft2232_pid[i >> 1]);
COMMAND_HANDLER(ft2232_handle_latency_command)
{
COMMAND_HANDLER(ft2232_handle_latency_command)
{
{
ft2232_latency = atoi(args[0]);
}
{
ft2232_latency = atoi(args[0]);
}
COMMAND_HANDLER(gw16012_handle_parport_port_command)
{
COMMAND_HANDLER(gw16012_handle_parport_port_command)
{
{
/* only if the port wasn't overwritten by cmdline */
if (gw16012_port == 0)
{
/* only if the port wasn't overwritten by cmdline */
if (gw16012_port == 0)
COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command)
{
COMMAND_HANDLER(jlink_handle_jlink_hw_jtag_command)
{
case 0:
command_print(cmd_ctx, "jlink hw jtag %i", jlink_hw_jtag_version);
break;
case 0:
command_print(cmd_ctx, "jlink hw jtag %i", jlink_hw_jtag_version);
break;
COMMAND_HANDLER(parport_handle_parport_port_command)
{
COMMAND_HANDLER(parport_handle_parport_port_command)
{
{
/* only if the port wasn't overwritten by cmdline */
if (parport_port == 0)
{
/* only if the port wasn't overwritten by cmdline */
if (parport_port == 0)
COMMAND_HANDLER(parport_handle_parport_cable_command)
{
COMMAND_HANDLER(parport_handle_parport_cable_command)
{
return ERROR_OK;
/* only if the cable name wasn't overwritten by cmdline */
return ERROR_OK;
/* only if the cable name wasn't overwritten by cmdline */
COMMAND_HANDLER(parport_handle_write_on_exit_command)
{
COMMAND_HANDLER(parport_handle_write_on_exit_command)
{
{
command_print(cmd_ctx, "usage: parport_write_on_exit <on | off>");
return ERROR_OK;
{
command_print(cmd_ctx, "usage: parport_write_on_exit <on | off>");
return ERROR_OK;
COMMAND_HANDLER(parport_handle_parport_toggling_time_command)
{
COMMAND_HANDLER(parport_handle_parport_toggling_time_command)
{
uint32_t ns;
int retval = parse_u32(args[0], &ns);
uint32_t ns;
int retval = parse_u32(args[0], &ns);
COMMAND_HANDLER(presto_handle_serial_command)
{
COMMAND_HANDLER(presto_handle_serial_command)
{
{
if (presto_serial)
free(presto_serial);
{
if (presto_serial)
free(presto_serial);
COMMAND_HANDLER(handle_interface_list_command)
{
COMMAND_HANDLER(handle_interface_list_command)
{
- if (strcmp(CMD_NAME, "interface_list") == 0 && argc > 0)
+ if (strcmp(CMD_NAME, "interface_list") == 0 && CMD_ARGC > 0)
return ERROR_COMMAND_SYNTAX_ERROR;
command_print(cmd_ctx, "The following JTAG interfaces are available:");
return ERROR_COMMAND_SYNTAX_ERROR;
command_print(cmd_ctx, "The following JTAG interfaces are available:");
}
/* interface name is a mandatory argument */
}
/* interface name is a mandatory argument */
- if (argc != 1 || args[0][0] == '\0')
+ if (CMD_ARGC != 1 || args[0][0] == '\0')
return ERROR_COMMAND_SYNTAX_ERROR;
for (unsigned i = 0; NULL != jtag_interfaces[i]; i++)
return ERROR_COMMAND_SYNTAX_ERROR;
for (unsigned i = 0; NULL != jtag_interfaces[i]; i++)
* Here we don't care about the order, and only change values
* which have been explicitly specified.
*/
* Here we don't care about the order, and only change values
* which have been explicitly specified.
*/
- for (; argc; argc--, args++) {
+ for (; CMD_ARGC; CMD_ARGC--, args++) {
COMMAND_HANDLER(handle_jtag_nsrst_delay_command)
{
COMMAND_HANDLER(handle_jtag_nsrst_delay_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
return ERROR_COMMAND_SYNTAX_ERROR;
{
unsigned delay;
COMMAND_PARSE_NUMBER(uint, args[0], delay);
{
unsigned delay;
COMMAND_PARSE_NUMBER(uint, args[0], delay);
COMMAND_HANDLER(handle_jtag_ntrst_delay_command)
{
COMMAND_HANDLER(handle_jtag_ntrst_delay_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
return ERROR_COMMAND_SYNTAX_ERROR;
{
unsigned delay;
COMMAND_PARSE_NUMBER(uint, args[0], delay);
{
unsigned delay;
COMMAND_PARSE_NUMBER(uint, args[0], delay);
COMMAND_HANDLER(handle_jtag_nsrst_assert_width_command)
{
COMMAND_HANDLER(handle_jtag_nsrst_assert_width_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
return ERROR_COMMAND_SYNTAX_ERROR;
{
unsigned delay;
COMMAND_PARSE_NUMBER(uint, args[0], delay);
{
unsigned delay;
COMMAND_PARSE_NUMBER(uint, args[0], delay);
COMMAND_HANDLER(handle_jtag_ntrst_assert_width_command)
{
COMMAND_HANDLER(handle_jtag_ntrst_assert_width_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
return ERROR_COMMAND_SYNTAX_ERROR;
{
unsigned delay;
COMMAND_PARSE_NUMBER(uint, args[0], delay);
{
unsigned delay;
COMMAND_PARSE_NUMBER(uint, args[0], delay);
COMMAND_HANDLER(handle_jtag_khz_command)
{
COMMAND_HANDLER(handle_jtag_khz_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
int retval = ERROR_OK;
return ERROR_COMMAND_SYNTAX_ERROR;
int retval = ERROR_OK;
{
unsigned khz = 0;
COMMAND_PARSE_NUMBER(uint, args[0], khz);
{
unsigned khz = 0;
COMMAND_PARSE_NUMBER(uint, args[0], khz);
COMMAND_HANDLER(handle_jtag_rclk_command)
{
COMMAND_HANDLER(handle_jtag_rclk_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
int retval = ERROR_OK;
return ERROR_COMMAND_SYNTAX_ERROR;
int retval = ERROR_OK;
{
unsigned khz = 0;
COMMAND_PARSE_NUMBER(uint, args[0], khz);
{
unsigned khz = 0;
COMMAND_PARSE_NUMBER(uint, args[0], khz);
COMMAND_HANDLER(handle_jtag_reset_command)
{
COMMAND_HANDLER(handle_jtag_reset_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
int trst = -1;
return ERROR_COMMAND_SYNTAX_ERROR;
int trst = -1;
COMMAND_HANDLER(handle_runtest_command)
{
COMMAND_HANDLER(handle_runtest_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned num_clocks;
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned num_clocks;
struct jtag_tap *tap;
tap_state_t endstate;
struct jtag_tap *tap;
tap_state_t endstate;
- if ((argc < 2) || (argc % 2))
+ if ((CMD_ARGC < 2) || (CMD_ARGC % 2))
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
/* have at least one pair of numbers. */
/* is last pair the magic text? */
/* have at least one pair of numbers. */
/* is last pair the magic text? */
- if (strcmp("-endstate", args[argc - 2]) == 0) {
- endstate = tap_state_by_name(args[argc - 1]);
+ if (strcmp("-endstate", args[CMD_ARGC - 2]) == 0) {
+ endstate = tap_state_by_name(args[CMD_ARGC - 1]);
if (endstate == TAP_INVALID)
return ERROR_COMMAND_SYNTAX_ERROR;
if (!scan_is_safe(endstate))
LOG_WARNING("unstable irscan endstate \"%s\"",
if (endstate == TAP_INVALID)
return ERROR_COMMAND_SYNTAX_ERROR;
if (!scan_is_safe(endstate))
LOG_WARNING("unstable irscan endstate \"%s\"",
- args[argc - 1]);
- argc -= 2;
+ args[CMD_ARGC - 1]);
+ CMD_ARGC -= 2;
- int num_fields = argc / 2;
+ int num_fields = CMD_ARGC / 2;
size_t fields_len = sizeof(struct scan_field) * num_fields;
fields = malloc(fields_len);
memset(fields, 0, fields_len);
size_t fields_len = sizeof(struct scan_field) * num_fields;
fields = malloc(fields_len);
memset(fields, 0, fields_len);
COMMAND_HANDLER(handle_verify_ircapture_command)
{
COMMAND_HANDLER(handle_verify_ircapture_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
return ERROR_COMMAND_SYNTAX_ERROR;
{
if (strcmp(args[0], "enable") == 0)
jtag_set_verify_capture_ir(true);
{
if (strcmp(args[0], "enable") == 0)
jtag_set_verify_capture_ir(true);
COMMAND_HANDLER(handle_verify_jtag_command)
{
COMMAND_HANDLER(handle_verify_jtag_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
return ERROR_COMMAND_SYNTAX_ERROR;
{
if (strcmp(args[0], "enable") == 0)
jtag_set_verify(true);
{
if (strcmp(args[0], "enable") == 0)
jtag_set_verify(true);
COMMAND_HANDLER(handle_tms_sequence_command)
{
COMMAND_HANDLER(handle_tms_sequence_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
return ERROR_COMMAND_SYNTAX_ERROR;
{
bool use_new_table;
if (strcmp(args[0], "short") == 0)
{
bool use_new_table;
if (strcmp(args[0], "short") == 0)
COMMAND_HANDLER(vsllink_handle_mode_command)
{
COMMAND_HANDLER(vsllink_handle_mode_command)
{
LOG_ERROR("parameter error, should be one parameter for VID");
return ERROR_FAIL;
}
LOG_ERROR("parameter error, should be one parameter for VID");
return ERROR_FAIL;
}
COMMAND_HANDLER(vsllink_handle_usb_vid_command)
{
COMMAND_HANDLER(vsllink_handle_usb_vid_command)
{
{
LOG_ERROR("parameter error, should be one parameter for VID");
return ERROR_OK;
{
LOG_ERROR("parameter error, should be one parameter for VID");
return ERROR_OK;
COMMAND_HANDLER(vsllink_handle_usb_pid_command)
{
COMMAND_HANDLER(vsllink_handle_usb_pid_command)
{
{
LOG_ERROR("parameter error, should be one parameter for PID");
return ERROR_OK;
{
LOG_ERROR("parameter error, should be one parameter for PID");
return ERROR_OK;
COMMAND_HANDLER(vsllink_handle_usb_bulkin_command)
{
COMMAND_HANDLER(vsllink_handle_usb_bulkin_command)
{
{
LOG_ERROR("parameter error, should be one parameter for BULKIN endpoint");
return ERROR_OK;
{
LOG_ERROR("parameter error, should be one parameter for BULKIN endpoint");
return ERROR_OK;
COMMAND_HANDLER(vsllink_handle_usb_bulkout_command)
{
COMMAND_HANDLER(vsllink_handle_usb_bulkout_command)
{
{
LOG_ERROR("parameter error, should be one parameter for BULKOUT endpoint");
return ERROR_OK;
{
LOG_ERROR("parameter error, should be one parameter for BULKOUT endpoint");
return ERROR_OK;
COMMAND_HANDLER(vsllink_handle_usb_interface_command)
{
COMMAND_HANDLER(vsllink_handle_usb_interface_command)
{
{
LOG_ERROR("parameter error, should be one parameter for interface number");
return ERROR_OK;
{
LOG_ERROR("parameter error, should be one parameter for interface number");
return ERROR_OK;
/* Give TELNET a way to find out what version this is */
COMMAND_HANDLER(handle_version_command)
{
/* Give TELNET a way to find out what version this is */
COMMAND_HANDLER(handle_version_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
command_print(cmd_ctx, OPENOCD_VERSION);
return ERROR_COMMAND_SYNTAX_ERROR;
command_print(cmd_ctx, OPENOCD_VERSION);
COMMAND_HANDLER(handle_init_command)
{
COMMAND_HANDLER(handle_init_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
int retval;
return ERROR_COMMAND_SYNTAX_ERROR;
int retval;
{
LOG_WARNING("incomplete 'pld device' command");
return ERROR_OK;
{
LOG_WARNING("incomplete 'pld device' command");
return ERROR_OK;
gettimeofday(&start, NULL);
gettimeofday(&start, NULL);
{
command_print(cmd_ctx, "usage: pld load <device#> <file>");
return ERROR_OK;
{
command_print(cmd_ctx, "usage: pld load <device#> <file>");
return ERROR_OK;
struct virtex2_pld_device *virtex2_info;
uint32_t status;
struct virtex2_pld_device *virtex2_info;
uint32_t status;
{
command_print(cmd_ctx, "usage: virtex2 read_stat <num>");
return ERROR_OK;
{
command_print(cmd_ctx, "usage: virtex2 read_stat <num>");
return ERROR_OK;
struct virtex2_pld_device *virtex2_info;
struct virtex2_pld_device *virtex2_info;
{
LOG_WARNING("incomplete pld device 'virtex2' configuration");
return ERROR_PLD_DEVICE_INVALID;
{
LOG_WARNING("incomplete pld device 'virtex2' configuration");
return ERROR_PLD_DEVICE_INVALID;
COMMAND_HANDLER(handle_gdb_sync_command)
{
COMMAND_HANDLER(handle_gdb_sync_command)
{
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
COMMAND_HANDLER(handle_gdb_memory_map_command)
{
COMMAND_HANDLER(handle_gdb_memory_map_command)
{
{
if (strcmp(args[0], "enable") == 0)
{
{
if (strcmp(args[0], "enable") == 0)
{
COMMAND_HANDLER(handle_gdb_flash_program_command)
{
COMMAND_HANDLER(handle_gdb_flash_program_command)
{
{
if (strcmp(args[0], "enable") == 0)
{
{
if (strcmp(args[0], "enable") == 0)
{
COMMAND_HANDLER(handle_gdb_report_data_abort_command)
{
COMMAND_HANDLER(handle_gdb_report_data_abort_command)
{
{
if (strcmp(args[0], "enable") == 0)
{
{
if (strcmp(args[0], "enable") == 0)
{
/* gdb_breakpoint_override */
COMMAND_HANDLER(handle_gdb_breakpoint_override_command)
{
/* gdb_breakpoint_override */
COMMAND_HANDLER(handle_gdb_breakpoint_override_command)
{
+ } else if (CMD_ARGC == 1)
{
gdb_breakpoint_override = 1;
if (strcmp(args[0], "hard") == 0)
{
gdb_breakpoint_override = 1;
if (strcmp(args[0], "hard") == 0)
case 0:
command_print(cmd_ctx, "%d", *out);
break;
case 0:
command_print(cmd_ctx, "%d", *out);
break;
int ret = ERROR_OK;
long long time_ago;
int ret = ERROR_OK;
long long time_ago;
- if ((argc < 1) || (argc > (1 + SVF_NUM_OF_OPTIONS)))
+ if ((CMD_ARGC < 1) || (CMD_ARGC > (1 + SVF_NUM_OF_OPTIONS)))
{
command_print(cmd_ctx, "usage: svf <file> [quiet]");
return ERROR_FAIL;
{
command_print(cmd_ctx, "usage: svf <file> [quiet]");
return ERROR_FAIL;
// parse variant
svf_quiet = 0;
// parse variant
svf_quiet = 0;
- for (unsigned i = 1; i < argc; i++)
+ for (unsigned i = 1; i < CMD_ARGC; i++)
{
if (!strcmp(args[i], "quiet"))
{
{
if (!strcmp(args[i], "quiet"))
{
static COMMAND_HELPER(arm11_handle_bool, bool *var, char *name)
{
static COMMAND_HELPER(arm11_handle_bool, bool *var, char *name)
{
{
LOG_INFO("%s is %s.", name, *var ? "enabled" : "disabled");
return ERROR_OK;
}
{
LOG_INFO("%s is %s.", name, *var ? "enabled" : "disabled");
return ERROR_OK;
}
return ERROR_COMMAND_SYNTAX_ERROR;
switch (args[0][0])
return ERROR_COMMAND_SYNTAX_ERROR;
switch (args[0][0])
COMMAND_HANDLER(arm11_handle_vcr)
{
COMMAND_HANDLER(arm11_handle_vcr)
{
}
/* one or more argument, access a single register (write if second argument is given */
}
/* one or more argument, access a single register (write if second argument is given */
{
uint32_t opcode;
COMMAND_PARSE_NUMBER(u32, args[0], opcode);
{
uint32_t opcode;
COMMAND_PARSE_NUMBER(u32, args[0], opcode);
{
uint32_t value;
if ((retval = arm720t_read_cp15(target, opcode, &value)) != ERROR_OK)
{
uint32_t value;
if ((retval = arm720t_read_cp15(target, opcode, &value)) != ERROR_OK)
command_print(cmd_ctx, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value);
}
command_print(cmd_ctx, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value);
}
+ else if (CMD_ARGC == 2)
{
uint32_t value;
COMMAND_PARSE_NUMBER(u32, args[1], value);
{
uint32_t value;
COMMAND_PARSE_NUMBER(u32, args[1], value);
{
command_print(cmd_ctx, "usage: write_xpsr <value> <not cpsr | spsr>");
return ERROR_FAIL;
{
command_print(cmd_ctx, "usage: write_xpsr <value> <not cpsr | spsr>");
return ERROR_FAIL;
{
command_print(cmd_ctx, "usage: write_xpsr_im8 <im8> <rotate> <not cpsr | spsr>");
return ERROR_FAIL;
{
command_print(cmd_ctx, "usage: write_xpsr_im8 <im8> <rotate> <not cpsr | spsr>");
return ERROR_FAIL;
{
command_print(cmd_ctx, "usage: write_core_reg <num> <mode> <value>");
return ERROR_FAIL;
{
command_print(cmd_ctx, "usage: write_core_reg <num> <mode> <value>");
return ERROR_FAIL;
return ERROR_TARGET_INVALID;
}
return ERROR_TARGET_INVALID;
}
{
if (strcmp("enable", args[0]) == 0)
{
{
if (strcmp("enable", args[0]) == 0)
{
return ERROR_TARGET_INVALID;
}
return ERROR_TARGET_INVALID;
}
{
if (strcmp("enable", args[0]) == 0)
{
{
if (strcmp("enable", args[0]) == 0)
{
return ERROR_TARGET_INVALID;
}
return ERROR_TARGET_INVALID;
}
{
if (strcmp("enable", args[0]) == 0)
{
{
if (strcmp("enable", args[0]) == 0)
{
if (retval != ERROR_OK)
return retval;
if (retval != ERROR_OK)
return retval;
{
command_print(cmd_ctx, "usage: arm920t read_cache <filename>");
return ERROR_OK;
{
command_print(cmd_ctx, "usage: arm920t read_cache <filename>");
return ERROR_OK;
if (retval != ERROR_OK)
return retval;
if (retval != ERROR_OK)
return retval;
{
command_print(cmd_ctx, "usage: arm920t read_mmu <filename>");
return ERROR_OK;
{
command_print(cmd_ctx, "usage: arm920t read_mmu <filename>");
return ERROR_OK;
}
/* one or more argument, access a single register (write if second argument is given */
}
/* one or more argument, access a single register (write if second argument is given */
{
int address;
COMMAND_PARSE_NUMBER(int, args[0], address);
{
int address;
COMMAND_PARSE_NUMBER(int, args[0], address);
{
uint32_t value;
if ((retval = arm920t_read_cp15_physical(target, address, &value)) != ERROR_OK)
{
uint32_t value;
if ((retval = arm920t_read_cp15_physical(target, address, &value)) != ERROR_OK)
command_print(cmd_ctx, "%i: %8.8" PRIx32 "", address, value);
}
command_print(cmd_ctx, "%i: %8.8" PRIx32 "", address, value);
}
+ else if (CMD_ARGC == 2)
{
uint32_t value;
COMMAND_PARSE_NUMBER(u32, args[1], value);
{
uint32_t value;
COMMAND_PARSE_NUMBER(u32, args[1], value);
}
/* one or more argument, access a single register (write if second argument is given */
}
/* one or more argument, access a single register (write if second argument is given */
{
uint32_t opcode;
COMMAND_PARSE_NUMBER(u32, args[0], opcode);
{
uint32_t opcode;
COMMAND_PARSE_NUMBER(u32, args[0], opcode);
{
uint32_t value;
if ((retval = arm920t_read_cp15_interpreted(target, opcode, 0x0, &value)) != ERROR_OK)
{
uint32_t value;
if ((retval = arm920t_read_cp15_interpreted(target, opcode, 0x0, &value)) != ERROR_OK)
command_print(cmd_ctx, "%8.8" PRIx32 ": %8.8" PRIx32 "", opcode, value);
}
command_print(cmd_ctx, "%8.8" PRIx32 ": %8.8" PRIx32 "", opcode, value);
}
+ else if (CMD_ARGC == 2)
{
uint32_t value;
COMMAND_PARSE_NUMBER(u32, args[1], value);
{
uint32_t value;
COMMAND_PARSE_NUMBER(u32, args[1], value);
}
command_print(cmd_ctx, "%8.8" PRIx32 ": %8.8" PRIx32 "", opcode, value);
}
}
command_print(cmd_ctx, "%8.8" PRIx32 ": %8.8" PRIx32 "", opcode, value);
}
+ else if (CMD_ARGC == 3)
{
uint32_t value;
COMMAND_PARSE_NUMBER(u32, args[1], value);
{
uint32_t value;
COMMAND_PARSE_NUMBER(u32, args[1], value);
- if ((argc < 4) || (argc > 5))
+ if ((CMD_ARGC < 4) || (CMD_ARGC > 5))
{
command_print(cmd_ctx, "usage: arm926ejs cp15 <opcode_1> <opcode_2> <CRn> <CRm> [value]");
return ERROR_OK;
{
command_print(cmd_ctx, "usage: arm926ejs cp15 <opcode_1> <opcode_2> <CRn> <CRm> [value]");
return ERROR_OK;
{
uint32_t value;
if ((retval = arm926ejs->read_cp15(target, opcode_1, opcode_2, CRn, CRm, &value)) != ERROR_OK)
{
uint32_t value;
if ((retval = arm926ejs->read_cp15(target, opcode_1, opcode_2, CRn, CRm, &value)) != ERROR_OK)
}
/* one or more argument, access a single register (write if second argument is given */
}
/* one or more argument, access a single register (write if second argument is given */
{
uint32_t address;
COMMAND_PARSE_NUMBER(u32, args[0], address);
{
uint32_t address;
COMMAND_PARSE_NUMBER(u32, args[0], address);
{
uint32_t value;
if ((retval = arm966e_read_cp15(target, address, &value)) != ERROR_OK)
{
uint32_t value;
if ((retval = arm966e_read_cp15(target, address, &value)) != ERROR_OK)
command_print(cmd_ctx, "%" PRIi32 ": %8.8" PRIx32,
address, value);
}
command_print(cmd_ctx, "%" PRIi32 ": %8.8" PRIx32,
address, value);
}
+ else if (CMD_ARGC == 2)
{
uint32_t value;
COMMAND_PARSE_NUMBER(u32, args[1], value);
{
uint32_t value;
COMMAND_PARSE_NUMBER(u32, args[1], value);
/* get the current setting */
vector_catch_value = buf_get_u32(vector_catch->value, 0, 8);
/* get the current setting */
vector_catch_value = buf_get_u32(vector_catch->value, 0, 8);
{
vector_catch_value = 0x0;
if (strcmp(args[0], "all") == 0)
{
vector_catch_value = 0x0;
if (strcmp(args[0], "all") == 0)
- for (unsigned i = 0; i < argc; i++)
+ for (unsigned i = 0; i < CMD_ARGC; i++)
{
/* go through list of vectors */
unsigned j;
{
/* go through list of vectors */
unsigned j;
int retval;
apselsave = swjdp->apsel;
int retval;
apselsave = swjdp->apsel;
case 0:
apsel = swjdp->apsel;
break;
case 0:
apsel = swjdp->apsel;
break;
{
uint32_t memaccess_tck;
{
uint32_t memaccess_tck;
case 0:
memaccess_tck = swjdp->memaccess_tck;
break;
case 0:
memaccess_tck = swjdp->memaccess_tck;
break;
uint32_t apsel, apid;
int retval;
uint32_t apsel, apid;
int retval;
case 0:
apsel = 0;
break;
case 0:
apsel = 0;
break;
int retval;
apselsave = swjdp->apsel;
int retval;
apselsave = swjdp->apsel;
case 0:
apsel = swjdp->apsel;
break;
case 0:
apsel = swjdp->apsel;
break;
{
if (strcmp(args[0], "arm") == 0)
{
{
if (strcmp(args[0], "arm") == 0)
{
case 3:
if (strcmp(args[2], "thumb") != 0)
goto usage;
case 3:
if (strcmp(args[2], "thumb") != 0)
goto usage;
struct swjdp_common *swjdp = &armv7a->swjdp_info;
uint32_t apsel;
struct swjdp_common *swjdp = &armv7a->swjdp_info;
uint32_t apsel;
case 0:
apsel = swjdp->apsel;
break;
case 0:
apsel = swjdp->apsel;
break;
int retval;
apselsave = swjdp->apsel;
int retval;
apselsave = swjdp->apsel;
case 0:
apsel = swjdp->apsel;
break;
case 0:
apsel = swjdp->apsel;
break;
struct swjdp_common *swjdp = &armv7m->swjdp_info;
uint32_t apsel;
struct swjdp_common *swjdp = &armv7m->swjdp_info;
uint32_t apsel;
case 0:
apsel = swjdp->apsel;
break;
case 0:
apsel = swjdp->apsel;
break;
return retval;
errno = 0;
return retval;
errno = 0;
case 2:
COMMAND_PARSE_NUMBER(ulong, args[1], count);
/* FALL THROUGH */
case 2:
COMMAND_PARSE_NUMBER(ulong, args[1], count);
/* FALL THROUGH */
mem_ap_read_atomic_u32(swjdp, DCB_DEMCR, &demcr);
mem_ap_read_atomic_u32(swjdp, DCB_DEMCR, &demcr);
if (strcmp(args[0], "all") == 0) {
catch = VC_HARDERR | VC_INTERR | VC_BUSERR
| VC_STATERR | VC_CHKERR | VC_NOCPERR
if (strcmp(args[0], "all") == 0) {
catch = VC_HARDERR | VC_INTERR | VC_BUSERR
| VC_STATERR | VC_CHKERR | VC_NOCPERR
+ while (CMD_ARGC-- > 0) {
unsigned i;
for (i = 0; i < ARRAY_SIZE(vec_ids); i++) {
unsigned i;
for (i = 0; i < ARRAY_SIZE(vec_ids); i++) {
- if (strcmp(args[argc], vec_ids[i].name) != 0)
+ if (strcmp(args[CMD_ARGC], vec_ids[i].name) != 0)
continue;
catch |= vec_ids[i].mask;
break;
}
if (i == ARRAY_SIZE(vec_ids)) {
continue;
catch |= vec_ids[i].mask;
break;
}
if (i == ARRAY_SIZE(vec_ids)) {
- LOG_ERROR("No CM3 vector '%s'", args[argc]);
+ LOG_ERROR("No CM3 vector '%s'", args[CMD_ARGC]);
return ERROR_INVALID_ARGUMENTS;
}
}
return ERROR_INVALID_ARGUMENTS;
}
}
{
if (!strcmp(args[0], "on"))
{
{
if (!strcmp(args[0], "on"))
{
struct jtag_tap *tap;
struct arm *arm;
struct jtag_tap *tap;
struct arm *arm;
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
etmv1_tracemode_t tracemode = etm->tracemode;
etmv1_tracemode_t tracemode = etm->tracemode;
struct etm_context *etm_ctx;
int i;
struct etm_context *etm_ctx;
int i;
return ERROR_COMMAND_SYNTAX_ERROR;
target = get_target(args[0]);
return ERROR_COMMAND_SYNTAX_ERROR;
target = get_target(args[0]);
struct arm *arm;
struct etm_context *etm_ctx;
struct arm *arm;
struct etm_context *etm_ctx;
{
command_print(cmd_ctx, "usage: etm image <file> [base address] [type]");
return ERROR_FAIL;
{
command_print(cmd_ctx, "usage: etm image <file> [base address] [type]");
return ERROR_FAIL;
etm_ctx->image->start_address_set = 0;
/* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
etm_ctx->image->start_address_set = 0;
/* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
{
etm_ctx->image->base_address_set = 1;
COMMAND_PARSE_NUMBER(int, args[1], etm_ctx->image->base_address);
{
etm_ctx->image->base_address_set = 1;
COMMAND_PARSE_NUMBER(int, args[1], etm_ctx->image->base_address);
etm_ctx->image->base_address_set = 0;
}
etm_ctx->image->base_address_set = 0;
}
- if (image_open(etm_ctx->image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
+ if (image_open(etm_ctx->image, args[0], (CMD_ARGC >= 3) ? args[2] : NULL) != ERROR_OK)
{
free(etm_ctx->image);
etm_ctx->image = NULL;
{
free(etm_ctx->image);
etm_ctx->image = NULL;
struct etm_context *etm_ctx;
uint32_t i;
struct etm_context *etm_ctx;
uint32_t i;
{
command_print(cmd_ctx, "usage: etm dump <file>");
return ERROR_FAIL;
{
command_print(cmd_ctx, "usage: etm dump <file>");
return ERROR_FAIL;
struct etm_context *etm_ctx;
uint32_t i;
struct etm_context *etm_ctx;
uint32_t i;
{
command_print(cmd_ctx, "usage: etm load <file>");
return ERROR_FAIL;
{
command_print(cmd_ctx, "usage: etm load <file>");
return ERROR_FAIL;
{
uint32_t new_value;
COMMAND_PARSE_NUMBER(u32, args[0], new_value);
{
uint32_t new_value;
COMMAND_PARSE_NUMBER(u32, args[0], new_value);
struct target *target;
struct arm *arm;
struct target *target;
struct arm *arm;
{
LOG_ERROR("incomplete 'oocd_trace config <target> <tty>' command");
return ERROR_FAIL;
{
LOG_ERROR("incomplete 'oocd_trace config <target> <tty>' command");
return ERROR_FAIL;
{
struct target *target = all_targets;
{
struct target *target = all_targets;
{
target = get_target(args[0]);
if (target == NULL) {
{
target = get_target(args[0]);
if (target == NULL) {
target = get_current_target(cmd_ctx);
/* list all available registers for the current target */
target = get_current_target(cmd_ctx);
/* list all available registers for the current target */
{
struct reg_cache *cache = target->reg_cache;
{
struct reg_cache *cache = target->reg_cache;
}
/* display a register */
}
/* display a register */
- if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
+ if ((CMD_ARGC == 1) || ((CMD_ARGC == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9'))))
- if ((argc == 2) && (strcmp(args[1], "force") == 0))
+ if ((CMD_ARGC == 2) && (strcmp(args[1], "force") == 0))
reg->valid = 0;
if (reg->valid == 0)
reg->valid = 0;
if (reg->valid == 0)
}
/* set register value */
}
/* set register value */
{
uint8_t *buf = malloc(DIV_ROUND_UP(reg->size, 8));
str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
{
uint8_t *buf = malloc(DIV_ROUND_UP(reg->size, 8));
str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
int retval = ERROR_OK;
struct target *target = get_current_target(cmd_ctx);
int retval = ERROR_OK;
struct target *target = get_current_target(cmd_ctx);
{
command_print(cmd_ctx, "background polling: %s",
jtag_poll_get_enabled() ? "on" : "off");
{
command_print(cmd_ctx, "background polling: %s",
jtag_poll_get_enabled() ? "on" : "off");
+ else if (CMD_ARGC == 1)
{
if (strcmp(args[0], "on") == 0)
{
{
if (strcmp(args[0], "on") == 0)
{
COMMAND_HANDLER(handle_wait_halt_command)
{
COMMAND_HANDLER(handle_wait_halt_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned ms = 5000;
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned ms = 5000;
{
int retval = parse_uint(args[0], &ms);
if (ERROR_OK != retval)
{
int retval = parse_uint(args[0], &ms);
if (ERROR_OK != retval)
if (ERROR_OK != retval)
return retval;
if (ERROR_OK != retval)
return retval;
{
unsigned wait;
retval = parse_uint(args[0], &wait);
{
unsigned wait;
retval = parse_uint(args[0], &wait);
COMMAND_HANDLER(handle_reset_command)
{
COMMAND_HANDLER(handle_reset_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
enum target_reset_mode reset_mode = RESET_RUN;
return ERROR_COMMAND_SYNTAX_ERROR;
enum target_reset_mode reset_mode = RESET_RUN;
{
const Jim_Nvp *n;
n = Jim_Nvp_name2value_simple(nvp_reset_modes, args[0]);
{
const Jim_Nvp *n;
n = Jim_Nvp_name2value_simple(nvp_reset_modes, args[0]);
COMMAND_HANDLER(handle_resume_command)
{
int current = 1;
COMMAND_HANDLER(handle_resume_command)
{
int current = 1;
return ERROR_COMMAND_SYNTAX_ERROR;
struct target *target = get_current_target(cmd_ctx);
return ERROR_COMMAND_SYNTAX_ERROR;
struct target *target = get_current_target(cmd_ctx);
* with one arguments, addr = args[0],
* handle breakpoints, not debugging */
uint32_t addr = 0;
* with one arguments, addr = args[0],
* handle breakpoints, not debugging */
uint32_t addr = 0;
{
COMMAND_PARSE_NUMBER(u32, args[0], addr);
current = 0;
{
COMMAND_PARSE_NUMBER(u32, args[0], addr);
current = 0;
COMMAND_HANDLER(handle_step_command)
{
COMMAND_HANDLER(handle_step_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
LOG_DEBUG("-");
return ERROR_COMMAND_SYNTAX_ERROR;
LOG_DEBUG("-");
* handle breakpoints, debugging */
uint32_t addr = 0;
int current_pc = 1;
* handle breakpoints, debugging */
uint32_t addr = 0;
int current_pc = 1;
{
COMMAND_PARSE_NUMBER(u32, args[0], addr);
current_pc = 0;
{
COMMAND_PARSE_NUMBER(u32, args[0], addr);
current_pc = 0;
COMMAND_HANDLER(handle_md_command)
{
COMMAND_HANDLER(handle_md_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned size = 0;
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned size = 0;
uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
if (physical)
{
uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
if (physical)
{
args++;
fn=target_read_phys_memory;
} else
{
fn=target_read_memory;
}
args++;
fn=target_read_phys_memory;
} else
{
fn=target_read_memory;
}
- if ((argc < 1) || (argc > 2))
+ if ((CMD_ARGC < 1) || (CMD_ARGC > 2))
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
COMMAND_PARSE_NUMBER(u32, args[0], address);
unsigned count = 1;
COMMAND_PARSE_NUMBER(u32, args[0], address);
unsigned count = 1;
COMMAND_PARSE_NUMBER(uint, args[1], count);
uint8_t *buffer = calloc(count, size);
COMMAND_PARSE_NUMBER(uint, args[1], count);
uint8_t *buffer = calloc(count, size);
COMMAND_HANDLER(handle_mw_command)
{
COMMAND_HANDLER(handle_mw_command)
{
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
const char *cmd_name = CMD_NAME;
if (physical)
{
const char *cmd_name = CMD_NAME;
if (physical)
{
args++;
fn=target_write_phys_memory;
} else
{
fn=target_write_memory;
}
args++;
fn=target_write_phys_memory;
} else
{
fn=target_write_memory;
}
- if ((argc < 2) || (argc > 3))
+ if ((CMD_ARGC < 2) || (CMD_ARGC > 3))
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t address;
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t address;
COMMAND_PARSE_NUMBER(u32, args[1], value);
unsigned count = 1;
COMMAND_PARSE_NUMBER(u32, args[1], value);
unsigned count = 1;
COMMAND_PARSE_NUMBER(uint, args[2], count);
struct target *target = get_current_target(cmd_ctx);
COMMAND_PARSE_NUMBER(uint, args[2], count);
struct target *target = get_current_target(cmd_ctx);
static COMMAND_HELPER(parse_load_image_command_args, struct image *image,
uint32_t *min_address, uint32_t *max_address)
{
static COMMAND_HELPER(parse_load_image_command_args, struct image *image,
uint32_t *min_address, uint32_t *max_address)
{
- if (argc < 1 || argc > 5)
+ if (CMD_ARGC < 1 || CMD_ARGC > 5)
return ERROR_COMMAND_SYNTAX_ERROR;
/* a base address isn't always necessary,
* default to 0x0 (i.e. don't relocate) */
return ERROR_COMMAND_SYNTAX_ERROR;
/* a base address isn't always necessary,
* default to 0x0 (i.e. don't relocate) */
{
uint32_t addr;
COMMAND_PARSE_NUMBER(u32, args[1], addr);
{
uint32_t addr;
COMMAND_PARSE_NUMBER(u32, args[1], addr);
image->start_address_set = 0;
image->start_address_set = 0;
{
COMMAND_PARSE_NUMBER(u32, args[3], *min_address);
}
{
COMMAND_PARSE_NUMBER(u32, args[3], *min_address);
}
{
COMMAND_PARSE_NUMBER(u32, args[4], *max_address);
// use size (given) to find max (required)
{
COMMAND_PARSE_NUMBER(u32, args[4], *max_address);
// use size (given) to find max (required)
struct duration bench;
duration_start(&bench);
struct duration bench;
duration_start(&bench);
- if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
+ if (image_open(&image, args[0], (CMD_ARGC >= 3) ? args[2] : NULL) != ERROR_OK)
struct target *target = get_current_target(cmd_ctx);
struct target *target = get_current_target(cmd_ctx);
{
command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
return ERROR_OK;
{
command_print(cmd_ctx, "usage: dump_image <filename> <address> <size>");
return ERROR_OK;
struct target *target = get_current_target(cmd_ctx);
struct target *target = get_current_target(cmd_ctx);
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
struct duration bench;
duration_start(&bench);
struct duration bench;
duration_start(&bench);
{
uint32_t addr;
COMMAND_PARSE_NUMBER(u32, args[1], addr);
{
uint32_t addr;
COMMAND_PARSE_NUMBER(u32, args[1], addr);
image.start_address_set = 0;
image.start_address_set = 0;
- if ((retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK)
+ if ((retval = image_open(&image, args[0], (CMD_ARGC == 3) ? args[2] : NULL)) != ERROR_OK)
COMMAND_HANDLER(handle_bp_command)
{
COMMAND_HANDLER(handle_bp_command)
{
return handle_bp_command_list(cmd_ctx);
return handle_bp_command_list(cmd_ctx);
- if (argc < 2 || argc > 3)
+ if (CMD_ARGC < 2 || CMD_ARGC > 3)
{
command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
return ERROR_COMMAND_SYNTAX_ERROR;
{
command_print(cmd_ctx, "usage: bp <address> <length> ['hw']");
return ERROR_COMMAND_SYNTAX_ERROR;
COMMAND_PARSE_NUMBER(u32, args[1], length);
int hw = BKPT_SOFT;
COMMAND_PARSE_NUMBER(u32, args[1], length);
int hw = BKPT_SOFT;
{
if (strcmp(args[2], "hw") == 0)
hw = BKPT_HARD;
{
if (strcmp(args[2], "hw") == 0)
hw = BKPT_HARD;
COMMAND_HANDLER(handle_rbp_command)
{
COMMAND_HANDLER(handle_rbp_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t addr;
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t addr;
{
struct target *target = get_current_target(cmd_ctx);
{
struct target *target = get_current_target(cmd_ctx);
{
struct watchpoint *watchpoint = target->watchpoints;
{
struct watchpoint *watchpoint = target->watchpoints;
uint32_t data_value = 0x0;
uint32_t data_mask = 0xffffffff;
uint32_t data_value = 0x0;
uint32_t data_mask = 0xffffffff;
{
case 5:
COMMAND_PARSE_NUMBER(u32, args[4], data_mask);
{
case 5:
COMMAND_PARSE_NUMBER(u32, args[4], data_mask);
COMMAND_HANDLER(handle_rwp_command)
{
COMMAND_HANDLER(handle_rwp_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t addr;
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t addr;
*/
COMMAND_HANDLER(handle_virt2phys_command)
{
*/
COMMAND_HANDLER(handle_virt2phys_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t va;
return ERROR_COMMAND_SYNTAX_ERROR;
uint32_t va;
struct timeval timeout, now;
gettimeofday(&timeout, NULL);
struct timeval timeout, now;
gettimeofday(&timeout, NULL);
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
struct duration bench;
duration_start(&bench);
struct duration bench;
duration_start(&bench);
- if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
+ if (image_open(&image, args[0], (CMD_ARGC >= 3) ? args[2] : NULL) != ERROR_OK)
COMMAND_HANDLER(handle_fast_load_command)
{
COMMAND_HANDLER(handle_fast_load_command)
{
return ERROR_COMMAND_SYNTAX_ERROR;
if (fastload == NULL)
{
return ERROR_COMMAND_SYNTAX_ERROR;
if (fastload == NULL)
{
if (find_debug_msg_receiver(cmd_ctx, target) != NULL)
receiving = 1;
if (find_debug_msg_receiver(cmd_ctx, target) != NULL)
receiving = 1;
{
if (!strcmp(args[0], "enable") || !strcmp(args[0], "charmsg"))
{
{
if (!strcmp(args[0], "enable") || !strcmp(args[0], "charmsg"))
{
struct target *target = get_current_target(cmd_ctx);
struct trace *trace = target->trace_info;
struct target *target = get_current_target(cmd_ctx);
struct trace *trace = target->trace_info;
struct target *target = get_current_target(cmd_ctx);
struct trace *trace = target->trace_info;
struct target *target = get_current_target(cmd_ctx);
struct trace *trace = target->trace_info;
{
trace->trace_history_pos = 0;
trace->trace_history_overflowed = 0;
{
trace->trace_history_pos = 0;
trace->trace_history_overflowed = 0;
int retval;
uint32_t handler_address;
int retval;
uint32_t handler_address;
{
LOG_ERROR("'xscale debug_handler <target#> <address>' command takes two required operands");
return ERROR_OK;
{
LOG_ERROR("'xscale debug_handler <target#> <address>' command takes two required operands");
return ERROR_OK;
int retval;
uint32_t cache_clean_address;
int retval;
uint32_t cache_clean_address;
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
{
if (strcmp("enable", args[0]) == 0)
{
{
if (strcmp("enable", args[0]) == 0)
{
else if (strcmp(CMD_NAME, "dcache") == 0)
dcache = 1;
else if (strcmp(CMD_NAME, "dcache") == 0)
dcache = 1;
{
if (strcmp("enable", args[0]) == 0)
{
{
if (strcmp("enable", args[0]) == 0)
{
if (retval != ERROR_OK)
return retval;
if (retval != ERROR_OK)
return retval;
{
command_print(cmd_ctx, "usage: xscale vector_catch [mask]");
}
{
command_print(cmd_ctx, "usage: xscale vector_catch [mask]");
}
if (retval != ERROR_OK)
return retval;
if (retval != ERROR_OK)
return retval;
- if (argc == 0) /* print current settings */
+ if (CMD_ARGC == 0) /* print current settings */
- if ((argc >= 1) && (strcmp("enable", args[0]) == 0))
+ if ((CMD_ARGC >= 1) && (strcmp("enable", args[0]) == 0))
{
struct xscale_trace_data *td, *next_td;
xscale->trace.buffer_enabled = 1;
{
struct xscale_trace_data *td, *next_td;
xscale->trace.buffer_enabled = 1;
}
xscale->trace.data = NULL;
}
}
xscale->trace.data = NULL;
}
- else if ((argc >= 1) && (strcmp("disable", args[0]) == 0))
+ else if ((CMD_ARGC >= 1) && (strcmp("disable", args[0]) == 0))
{
xscale->trace.buffer_enabled = 0;
}
{
xscale->trace.buffer_enabled = 0;
}
- if ((argc >= 2) && (strcmp("fill", args[1]) == 0))
+ if ((CMD_ARGC >= 2) && (strcmp("fill", args[1]) == 0))
COMMAND_PARSE_NUMBER(u32, args[2], fill);
xscale->trace.buffer_fill = fill;
}
COMMAND_PARSE_NUMBER(u32, args[2], fill);
xscale->trace.buffer_fill = fill;
}
- else if ((argc >= 2) && (strcmp("wrap", args[1]) == 0))
+ else if ((CMD_ARGC >= 2) && (strcmp("wrap", args[1]) == 0))
{
xscale->trace.buffer_fill = -1;
}
{
xscale->trace.buffer_fill = -1;
}
struct xscale_common *xscale = target_to_xscale(target);
int retval;
struct xscale_common *xscale = target_to_xscale(target);
int retval;
{
command_print(cmd_ctx, "usage: xscale trace_image <file> [base address] [type]");
return ERROR_OK;
{
command_print(cmd_ctx, "usage: xscale trace_image <file> [base address] [type]");
return ERROR_OK;
xscale->trace.image->start_address_set = 0;
/* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
xscale->trace.image->start_address_set = 0;
/* a base address isn't always necessary, default to 0x0 (i.e. don't relocate) */
{
xscale->trace.image->base_address_set = 1;
COMMAND_PARSE_NUMBER(int, args[1], xscale->trace.image->base_address);
{
xscale->trace.image->base_address_set = 1;
COMMAND_PARSE_NUMBER(int, args[1], xscale->trace.image->base_address);
xscale->trace.image->base_address_set = 0;
}
xscale->trace.image->base_address_set = 0;
}
- if (image_open(xscale->trace.image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK)
+ if (image_open(xscale->trace.image, args[0], (CMD_ARGC >= 3) ? args[2] : NULL) != ERROR_OK)
{
free(xscale->trace.image);
xscale->trace.image = NULL;
{
free(xscale->trace.image);
xscale->trace.image = NULL;
{
command_print(cmd_ctx, "usage: xscale dump_trace <file>");
return ERROR_OK;
{
command_print(cmd_ctx, "usage: xscale dump_trace <file>");
return ERROR_OK;
}
uint32_t reg_no = 0;
struct reg *reg = NULL;
}
uint32_t reg_no = 0;
struct reg *reg = NULL;
{
COMMAND_PARSE_NUMBER(u32, args[0], reg_no);
/*translate from xscale cp15 register no to openocd register*/
{
COMMAND_PARSE_NUMBER(u32, args[0], reg_no);
/*translate from xscale cp15 register no to openocd register*/
reg = &xscale->reg_cache->reg_list[reg_no];
}
reg = &xscale->reg_cache->reg_list[reg_no];
}
value = buf_get_u32(reg->value, 0, 32);
command_print(cmd_ctx, "%s (/%i): 0x%" PRIx32 "", reg->name, (int)(reg->size), value);
}
value = buf_get_u32(reg->value, 0, 32);
command_print(cmd_ctx, "%s (/%i): 0x%" PRIx32 "", reg->name, (int)(reg->size), value);
}
+ else if (CMD_ARGC == 2)
{
uint32_t value;
COMMAND_PARSE_NUMBER(u32, args[1], value);
{
uint32_t value;
COMMAND_PARSE_NUMBER(u32, args[1], value);
*/
struct jtag_tap *tap = NULL;
*/
struct jtag_tap *tap = NULL;
{
command_print(cmd_ctx, "usage: xsvf <device#|plain> <file> [<variant>] [quiet]");
return ERROR_FAIL;
{
command_print(cmd_ctx, "usage: xsvf <device#|plain> <file> [<variant>] [quiet]");
return ERROR_FAIL;
}
/* if this argument is present, then interpret xruntest counts as TCK cycles rather than as usecs */
}
/* if this argument is present, then interpret xruntest counts as TCK cycles rather than as usecs */
- if ((argc > 2) && (strcmp(args[2], "virt2") == 0))
+ if ((CMD_ARGC > 2) && (strcmp(args[2], "virt2") == 0))
{
runtest_requires_tck = 1;
{
runtest_requires_tck = 1;
- if ((argc > 2) && (strcmp(args[2], "quiet") == 0))
+ if ((CMD_ARGC > 2) && (strcmp(args[2], "quiet") == 0))
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)