const char *sep, *name;
int retval = CALL_COMMAND_HANDLER(handle_hello_args);
if (ERROR_OK == retval)
- command_print(CMD_CTX, "Greetings%s%s!", sep, name);
+ command_print(CMD, "Greetings%s%s!", sep, name);
return retval;
}
@endcode
ret = mg_mflash_probe();
if (ret == ERROR_OK) {
- command_print(CMD_CTX,
+ command_print(CMD,
"mflash (total %" PRIu32 " sectors) found at 0x%8.8" PRIx32 "",
mflash_bank->drv_info->tot_sects,
mflash_bank->base);
}
if (duration_measure(&bench) == ERROR_OK) {
- command_print(CMD_CTX, "wrote %zu bytes from file %s "
+ command_print(CMD, "wrote %zu bytes from file %s "
"in %fs (%0.3f kB/s)", filesize, CMD_ARGV[1],
duration_elapsed(&bench), duration_kbps(&bench, filesize));
}
}
if (duration_measure(&bench) == ERROR_OK) {
- command_print(CMD_CTX, "dump image (address 0x%8.8" PRIx32 " "
+ command_print(CMD, "dump image (address 0x%8.8" PRIx32 " "
"size %" PRIu32 ") to file %s in %fs (%0.3f kB/s)",
address, size, CMD_ARGV[1],
duration_elapsed(&bench), duration_kbps(&bench, size));
unsigned num, address_line;
if (CMD_ARGC != 2) {
- command_print(CMD_CTX, "incorrect number of arguments for 'at91sam9 cle' command");
+ command_print(CMD, "incorrect number of arguments for 'at91sam9 cle' command");
return ERROR_OK;
}
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
nand = get_nand_device_by_num(num);
if (!nand) {
- command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]);
+ command_print(CMD, "invalid nand device number: %s", CMD_ARGV[0]);
return ERROR_OK;
}
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
nand = get_nand_device_by_num(num);
if (!nand) {
- command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]);
+ command_print(CMD, "invalid nand device number: %s", CMD_ARGV[0]);
return ERROR_COMMAND_ARGUMENT_INVALID;
}
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
nand = get_nand_device_by_num(num);
if (!nand) {
- command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]);
+ command_print(CMD, "invalid nand device number: %s", CMD_ARGV[0]);
return ERROR_COMMAND_ARGUMENT_INVALID;
}
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
nand = get_nand_device_by_num(num);
if (!nand) {
- command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]);
+ command_print(CMD, "invalid nand device number: %s", CMD_ARGV[0]);
return ERROR_COMMAND_ARGUMENT_INVALID;
}
COMMAND_PARSE_NUMBER(uint, str, num);
*nand = get_nand_device_by_num(num);
if (!*nand) {
- command_print(CMD_CTX, "NAND flash device '%s' not found", str);
+ command_print(CMD, "NAND flash device '%s' not found", str);
return ERROR_COMMAND_SYNTAX_ERROR;
}
return ERROR_OK;
struct nand_fileio_state *state)
{
if (state->address % nand->page_size) {
- command_print(cmd->ctx, "only page-aligned addresses are supported");
+ command_print(cmd, "only page-aligned addresses are supported");
return ERROR_COMMAND_SYNTAX_ERROR;
}
int retval = fileio_open(&state->fileio, filename, filemode, FILEIO_BINARY);
if (ERROR_OK != retval) {
const char *msg = (FILEIO_READ == filemode) ? "read" : "write";
- command_print(cmd->ctx, "failed to open '%s' for %s access",
+ command_print(cmd, "failed to open '%s' for %s access",
filename, msg);
return retval;
}
return retval;
if (NULL == nand->device) {
- command_print(CMD_CTX, "#%s: not probed", CMD_ARGV[0]);
+ command_print(CMD, "#%s: not probed", CMD_ARGV[0]);
return ERROR_NAND_DEVICE_NOT_PROBED;
}
if (need_size) {
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], state->size);
if (state->size % nand->page_size) {
- command_print(CMD_CTX, "only page-aligned sizes are supported");
+ command_print(CMD, "only page-aligned sizes are supported");
return ERROR_COMMAND_SYNTAX_ERROR;
}
}
else if (sw_ecc && !strcmp(CMD_ARGV[i], "oob_softecc_kw"))
state->oob_format |= NAND_OOB_SW_ECC_KW;
else {
- command_print(CMD_CTX, "unknown option: %s", CMD_ARGV[i]);
+ command_print(CMD, "unknown option: %s", CMD_ARGV[i]);
return ERROR_COMMAND_SYNTAX_ERROR;
}
}
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
struct nand_device *nand = get_nand_device_by_num(num);
if (!nand) {
- command_print(CMD_CTX, "nand device '#%s' is out of bounds", CMD_ARGV[0]);
+ command_print(CMD, "nand device '#%s' is out of bounds", CMD_ARGV[0]);
return ERROR_OK;
}
}
if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER)
- command_print(CMD_CTX, "%s controller selected",
+ command_print(CMD, "%s controller selected",
selected[lpc3180_info->selected_controller]);
else
- command_print(CMD_CTX,
+ command_print(CMD,
lpc3180_info->is_bulk ? "%s controller selected bulk mode is available" :
"%s controller selected bulk mode is not available",
selected[lpc3180_info->selected_controller]);
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
struct nand_device *nand = get_nand_device_by_num(num);
if (!nand) {
- command_print(CMD_CTX, "nand device '#%s' is out of bounds",
+ command_print(CMD, "nand device '#%s' is out of bounds",
CMD_ARGV[0]);
return ERROR_OK;
}
return ERROR_COMMAND_SYNTAX_ERROR;
}
- command_print(CMD_CTX, "%s controller selected",
+ command_print(CMD, "%s controller selected",
selected[lpc32xx_info->selected_controller]);
return ERROR_OK;
int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &nand);
if (retval != ERROR_OK) {
- command_print(CMD_CTX, "invalid nand device number or name: %s", CMD_ARGV[0]);
+ command_print(CMD, "invalid nand device number or name: %s", CMD_ARGV[0]);
return ERROR_COMMAND_ARGUMENT_INVALID;
}
mxc_nf_info->flags.biswap_enabled = false;
}
if (mxc_nf_info->flags.biswap_enabled)
- command_print(CMD_CTX, "BI-swapping enabled on %s", nand->name);
+ command_print(CMD, "BI-swapping enabled on %s", nand->name);
else
- command_print(CMD_CTX, "BI-swapping disabled on %s", nand->name);
+ command_print(CMD, "BI-swapping disabled on %s", nand->name);
return ERROR_OK;
}
int i;
if (!nand_devices) {
- command_print(CMD_CTX, "no NAND flash devices configured");
+ command_print(CMD, "no NAND flash devices configured");
return ERROR_OK;
}
for (p = nand_devices, i = 0; p; p = p->next, i++) {
if (p->device)
- command_print(CMD_CTX, "#%i: %s (%s) "
+ command_print(CMD, "#%i: %s (%s) "
"pagesize: %i, buswidth: %i,\n\t"
"blocksize: %i, blocks: %i",
i, p->device->name, p->manufacturer->name,
p->page_size, p->bus_width,
p->erase_size, p->num_blocks);
else
- command_print(CMD_CTX, "#%i: not probed", i);
+ command_print(CMD, "#%i: not probed", i);
}
return ERROR_OK;
return retval;
if (NULL == p->device) {
- command_print(CMD_CTX, "#%s: not probed", CMD_ARGV[0]);
+ command_print(CMD, "#%s: not probed", CMD_ARGV[0]);
return ERROR_OK;
}
if (last >= p->num_blocks)
last = p->num_blocks - 1;
- command_print(CMD_CTX,
+ command_print(CMD,
"#%i: %s (%s) pagesize: %i, buswidth: %i, erasesize: %i",
i++,
p->device->name,
else
bad_state = " (block condition unknown)";
- command_print(CMD_CTX,
+ command_print(CMD,
"\t#%i: 0x%8.8" PRIx32 " (%" PRId32 "kB) %s%s",
j,
p->blocks[j].offset,
retval = nand_probe(p);
if (retval == ERROR_OK) {
- command_print(CMD_CTX, "NAND flash device '%s (%s)' found",
+ command_print(CMD, "NAND flash device '%s (%s)' found",
p->device->name, p->manufacturer->name);
}
retval = nand_erase(p, offset, offset + length - 1);
if (retval == ERROR_OK) {
- command_print(CMD_CTX, "erased blocks %lu to %lu "
+ command_print(CMD, "erased blocks %lu to %lu "
"on NAND flash device #%s '%s'",
offset, offset + length - 1,
CMD_ARGV[0], p->device->name);
retval = nand_build_bbt(p, first, last);
if (retval == ERROR_OK) {
- command_print(CMD_CTX, "checked NAND flash device for bad blocks, "
+ command_print(CMD, "checked NAND flash device for bad blocks, "
"use \"nand info\" command to list blocks");
}
while (s.size > 0) {
int bytes_read = nand_fileio_read(nand, &s);
if (bytes_read <= 0) {
- command_print(CMD_CTX, "error while reading file");
+ command_print(CMD, "error while reading file");
nand_fileio_cleanup(&s);
return ERROR_FAIL;
}
retval = nand_write_page(nand, s.address / nand->page_size,
s.page, s.page_size, s.oob, s.oob_size);
if (ERROR_OK != retval) {
- command_print(CMD_CTX, "failed writing file %s "
+ command_print(CMD, "failed writing file %s "
"to NAND flash %s at offset 0x%8.8" PRIx32,
CMD_ARGV[1], CMD_ARGV[0], s.address);
nand_fileio_cleanup(&s);
}
if (nand_fileio_finish(&s) == ERROR_OK) {
- command_print(CMD_CTX, "wrote file %s to NAND flash %s up to "
+ command_print(CMD, "wrote file %s to NAND flash %s up to "
"offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
CMD_ARGV[1], CMD_ARGV[0], s.address, duration_elapsed(&s.bench),
duration_kbps(&s.bench, total_bytes));
retval = nand_read_page(nand, dev.address / dev.page_size,
dev.page, dev.page_size, dev.oob, dev.oob_size);
if (ERROR_OK != retval) {
- command_print(CMD_CTX, "reading NAND flash page failed");
+ command_print(CMD, "reading NAND flash page failed");
nand_fileio_cleanup(&dev);
nand_fileio_cleanup(&file);
return retval;
int bytes_read = nand_fileio_read(nand, &file);
if (bytes_read <= 0) {
- command_print(CMD_CTX, "error while reading file");
+ command_print(CMD, "error while reading file");
nand_fileio_cleanup(&dev);
nand_fileio_cleanup(&file);
return ERROR_FAIL;
if ((dev.page && memcmp(dev.page, file.page, dev.page_size)) ||
(dev.oob && memcmp(dev.oob, file.oob, dev.oob_size))) {
- command_print(CMD_CTX, "NAND flash contents differ "
+ command_print(CMD, "NAND flash contents differ "
"at 0x%8.8" PRIx32, dev.address);
nand_fileio_cleanup(&dev);
nand_fileio_cleanup(&file);
}
if (nand_fileio_finish(&file) == ERROR_OK) {
- command_print(CMD_CTX, "verified file %s in NAND flash %s "
+ command_print(CMD, "verified file %s in NAND flash %s "
"up to offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
CMD_ARGV[1], CMD_ARGV[0], dev.address, duration_elapsed(&file.bench),
duration_kbps(&file.bench, dev.size));
retval = nand_read_page(nand, s.address / nand->page_size,
s.page, s.page_size, s.oob, s.oob_size);
if (ERROR_OK != retval) {
- command_print(CMD_CTX, "reading NAND flash page failed");
+ command_print(CMD, "reading NAND flash page failed");
nand_fileio_cleanup(&s);
return retval;
}
return retval;
if (nand_fileio_finish(&s) == ERROR_OK) {
- command_print(CMD_CTX, "dumped %zu bytes in %fs (%0.3f KiB/s)",
+ command_print(CMD, "dumped %zu bytes in %fs (%0.3f KiB/s)",
filesize, duration_elapsed(&s.bench),
duration_kbps(&s.bench, filesize));
}
return retval;
if (NULL == p->device) {
- command_print(CMD_CTX, "#%s: not probed", CMD_ARGV[0]);
+ command_print(CMD, "#%s: not probed", CMD_ARGV[0]);
return ERROR_OK;
}
COMMAND_PARSE_ENABLE(CMD_ARGV[1], p->use_raw);
const char *msg = p->use_raw ? "enabled" : "disabled";
- command_print(CMD_CTX, "raw access is %s", msg);
+ command_print(CMD, "raw access is %s", msg);
return ERROR_OK;
}
static int nand_list_walker(struct nand_flash_controller *c, void *x)
{
struct command_invocation *cmd = x;
- command_print(cmd->ctx, " %s", c->name);
+ command_print(cmd, " %s", c->name);
return ERROR_OK;
}
COMMAND_HANDLER(handle_nand_list_drivers)
{
- command_print(CMD_CTX, "Available NAND flash controller drivers:");
+ command_print(CMD, "Available NAND flash controller drivers:");
return nand_driver_walk(&nand_list_walker, CMD);
}
for (i = 0; i < bank->num_sectors; i++)
bank->sectors[i].is_erased = 1;
- command_print(CMD_CTX, "ambiqmicro mass erase complete");
+ command_print(CMD, "ambiqmicro mass erase complete");
} else
- command_print(CMD_CTX, "ambiqmicro mass erase failed");
+ command_print(CMD, "ambiqmicro mass erase failed");
return ERROR_OK;
}
return retval;
if (ambiqmicro_erase(bank, first, last) == ERROR_OK)
- command_print(CMD_CTX, "ambiqmicro page erase complete");
+ command_print(CMD, "ambiqmicro page erase complete");
else
- command_print(CMD_CTX, "ambiqmicro page erase failed");
+ command_print(CMD, "ambiqmicro page erase failed");
return ERROR_OK;
}
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], offset);
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], count);
- command_print(CMD_CTX, "offset=0x%08x count=%d", offset, count);
+ command_print(CMD, "offset=0x%08x count=%d", offset, count);
CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
t = get_current_target(cmd->ctx);
if (!t) {
- command_print(cmd->ctx, "No current target?");
+ command_print(cmd, "No current target?");
return NULL;
}
if (!p) {
/* this should not happen */
/* the command is not registered until the chip is created? */
- command_print(cmd->ctx, "No SAM3 chips exist?");
+ command_print(cmd, "No SAM3 chips exist?");
return NULL;
}
return p;
p = p->next;
}
- command_print(cmd->ctx, "Cannot find SAM3 chip?");
+ command_print(cmd, "Cannot find SAM3 chip?");
return NULL;
}
if (pChip->details.bank[0].pBank == NULL) {
x = 0;
need_define:
- command_print(CMD_CTX,
+ command_print(CMD,
"Please define bank %d via command: flash bank %s ... ",
x,
at91sam3_flash.name);
}
if (pChip->details.bank[0].pBank == NULL) {
- command_print(CMD_CTX, "Bank0 must be defined first via: flash bank %s ...",
+ command_print(CMD, "Bank0 must be defined first via: flash bank %s ...",
at91sam3_flash.name);
return ERROR_FAIL;
}
r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), x, &v);
if (r != ERROR_OK)
break;
- command_print(CMD_CTX, "sam3-gpnvm%u: %u", x, v);
+ command_print(CMD, "sam3-gpnvm%u: %u", x, v);
}
return r;
}
if ((who >= 0) && (((unsigned)(who)) < pChip->details.n_gpnvms)) {
r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), who, &v);
- command_print(CMD_CTX, "sam3-gpnvm%u: %u", who, v);
+ command_print(CMD, "sam3-gpnvm%u: %u", who, v);
return r;
} else {
- command_print(CMD_CTX, "sam3-gpnvm invalid GPNVM: %u", who);
+ command_print(CMD, "sam3-gpnvm invalid GPNVM: %u", who);
return ERROR_COMMAND_SYNTAX_ERROR;
}
}
if (who == -1) {
- command_print(CMD_CTX, "Missing GPNVM number");
+ command_print(CMD, "Missing GPNVM number");
return ERROR_COMMAND_SYNTAX_ERROR;
}
(0 == strcmp("clear", CMD_ARGV[0]))) /* quietly accept both */
r = FLASHD_ClrGPNVM(&(pChip->details.bank[0]), who);
else {
- command_print(CMD_CTX, "Unknown command: %s", CMD_ARGV[0]);
+ command_print(CMD, "Unknown command: %s", CMD_ARGV[0]);
r = ERROR_COMMAND_SYNTAX_ERROR;
}
return r;
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], v);
if (v > 200000) {
/* absurd slow clock of 200Khz? */
- command_print(CMD_CTX, "Absurd/illegal slow clock freq: %d\n", (int)(v));
+ command_print(CMD, "Absurd/illegal slow clock freq: %d\n", (int)(v));
return ERROR_COMMAND_SYNTAX_ERROR;
}
pChip->cfg.slow_freq = v;
}
default:
/* error */
- command_print(CMD_CTX, "Too many parameters");
+ command_print(CMD, "Too many parameters");
return ERROR_COMMAND_SYNTAX_ERROR;
break;
}
- command_print(CMD_CTX, "Slowclk freq: %d.%03dkhz",
+ command_print(CMD, "Slowclk freq: %d.%03dkhz",
(int)(pChip->cfg.slow_freq / 1000),
(int)(pChip->cfg.slow_freq % 1000));
return ERROR_OK;
t = get_current_target(cmd->ctx);
if (!t) {
- command_print(cmd->ctx, "No current target?");
+ command_print(cmd, "No current target?");
return NULL;
}
if (!p) {
/* this should not happen */
/* the command is not registered until the chip is created? */
- command_print(cmd->ctx, "No SAM4 chips exist?");
+ command_print(cmd, "No SAM4 chips exist?");
return NULL;
}
return p;
p = p->next;
}
- command_print(cmd->ctx, "Cannot find SAM4 chip?");
+ command_print(cmd, "Cannot find SAM4 chip?");
return NULL;
}
if (pChip->details.bank[0].pBank == NULL) {
x = 0;
need_define:
- command_print(CMD_CTX,
+ command_print(CMD,
"Please define bank %d via command: flash bank %s ... ",
x,
at91sam4_flash.name);
}
if (pChip->details.bank[0].pBank == NULL) {
- command_print(CMD_CTX, "Bank0 must be defined first via: flash bank %s ...",
+ command_print(CMD, "Bank0 must be defined first via: flash bank %s ...",
at91sam4_flash.name);
return ERROR_FAIL;
}
r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), x, &v);
if (r != ERROR_OK)
break;
- command_print(CMD_CTX, "sam4-gpnvm%u: %u", x, v);
+ command_print(CMD, "sam4-gpnvm%u: %u", x, v);
}
return r;
}
if ((who >= 0) && (((unsigned)(who)) < pChip->details.n_gpnvms)) {
r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), who, &v);
if (r == ERROR_OK)
- command_print(CMD_CTX, "sam4-gpnvm%u: %u", who, v);
+ command_print(CMD, "sam4-gpnvm%u: %u", who, v);
return r;
} else {
- command_print(CMD_CTX, "sam4-gpnvm invalid GPNVM: %u", who);
+ command_print(CMD, "sam4-gpnvm invalid GPNVM: %u", who);
return ERROR_COMMAND_SYNTAX_ERROR;
}
}
if (who == -1) {
- command_print(CMD_CTX, "Missing GPNVM number");
+ command_print(CMD, "Missing GPNVM number");
return ERROR_COMMAND_SYNTAX_ERROR;
}
(0 == strcmp("clear", CMD_ARGV[0]))) /* quietly accept both */
r = FLASHD_ClrGPNVM(&(pChip->details.bank[0]), who);
else {
- command_print(CMD_CTX, "Unknown command: %s", CMD_ARGV[0]);
+ command_print(CMD, "Unknown command: %s", CMD_ARGV[0]);
r = ERROR_COMMAND_SYNTAX_ERROR;
}
return r;
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], v);
if (v > 200000) {
/* absurd slow clock of 200Khz? */
- command_print(CMD_CTX, "Absurd/illegal slow clock freq: %d\n", (int)(v));
+ command_print(CMD, "Absurd/illegal slow clock freq: %d\n", (int)(v));
return ERROR_COMMAND_SYNTAX_ERROR;
}
pChip->cfg.slow_freq = v;
}
default:
/* error */
- command_print(CMD_CTX, "Too many parameters");
+ command_print(CMD, "Too many parameters");
return ERROR_COMMAND_SYNTAX_ERROR;
break;
}
- command_print(CMD_CTX, "Slowclk freq: %d.%03dkhz",
+ command_print(CMD, "Slowclk freq: %d.%03dkhz",
(int)(pChip->cfg.slow_freq / 1000),
(int)(pChip->cfg.slow_freq % 1000));
return ERROR_OK;
if (bank == NULL)
return ERROR_FLASH_BANK_INVALID;
if (strcmp(bank->driver->name, "at91sam7")) {
- command_print(CMD_CTX, "not an at91sam7 flash bank '%s'", CMD_ARGV[0]);
+ command_print(CMD, "not an at91sam7 flash bank '%s'", CMD_ARGV[0]);
return ERROR_FLASH_BANK_INVALID;
}
if (bank->target->state != TARGET_HALTED) {
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], bit);
if ((bit < 0) || (bit >= at91sam7_info->num_nvmbits)) {
- command_print(CMD_CTX,
+ command_print(CMD,
"gpnvm bit '#%s' is out of bounds for target %s",
CMD_ARGV[0],
at91sam7_info->target_name);
* perform the erase. */
res = target_write_u8(target, SAMD_DSU + SAMD_DSU_CTRL_EXT, (1<<4));
if (res == ERROR_OK)
- command_print(CMD_CTX, "chip erase started");
+ command_print(CMD, "chip erase started");
else
- command_print(CMD_CTX, "write to DSU CTRL failed");
+ command_print(CMD, "write to DSU CTRL failed");
}
return res;
struct target *target = get_current_target(CMD_CTX);
if (CMD_ARGC < 1 || (CMD_ARGC >= 1 && (strcmp(CMD_ARGV[0], "enable")))) {
- command_print(CMD_CTX, "supply the \"enable\" argument to proceed.");
+ command_print(CMD, "supply the \"enable\" argument to proceed.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
/* Check (and clear) error conditions */
if (res == ERROR_OK)
- command_print(CMD_CTX, "chip secured on next power-cycle");
+ command_print(CMD, "chip secured on next power-cycle");
else
- command_print(CMD_CTX, "failed to secure chip");
+ command_print(CMD, "failed to secure chip");
}
return res;
}
if (code > 6) {
- command_print(CMD_CTX, "Invalid EEPROM size. Please see "
+ command_print(CMD, "Invalid EEPROM size. Please see "
"datasheet for a list valid sizes.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
uint32_t size = ((val >> 4) & 0x7); /* grab size code */
if (size == 0x7)
- command_print(CMD_CTX, "EEPROM is disabled");
+ command_print(CMD, "EEPROM is disabled");
else {
/* Otherwise, 6 is 256B, 0 is 16KB */
- command_print(CMD_CTX, "EEPROM size is %u bytes",
+ command_print(CMD, "EEPROM size is %u bytes",
(2 << (13 - size)));
}
}
static COMMAND_HELPER(get_u64_from_hexarg, unsigned int num, uint64_t *value)
{
if (num >= CMD_ARGC) {
- command_print(CMD_CTX, "Too few Arguments.");
+ command_print(CMD, "Too few Arguments.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
*value = strtoull(&(CMD_ARGV[num][2]), &check, 16);
if ((value == 0 && errno == ERANGE) ||
check == NULL || *check != 0) {
- command_print(CMD_CTX, "Invalid 64-bit hex value in argument %d.",
+ command_print(CMD, "Invalid 64-bit hex value in argument %d.",
num + 1);
return ERROR_COMMAND_SYNTAX_ERROR;
}
} else {
- command_print(CMD_CTX, "Argument %d needs to be a hex value.", num + 1);
+ command_print(CMD, "Argument %d needs to be a hex value.", num + 1);
return ERROR_COMMAND_SYNTAX_ERROR;
}
return ERROR_OK;
if (target) {
if (CMD_ARGC > 2) {
- command_print(CMD_CTX, "Too much Arguments given.");
+ command_print(CMD, "Too much Arguments given.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
uint64_t value;
res = read_userrow(target, &value);
if (res == ERROR_OK)
- command_print(CMD_CTX, "NVMUSERROW: 0x%016"PRIX64, value);
+ command_print(CMD, "NVMUSERROW: 0x%016"PRIX64, value);
else
LOG_ERROR("NVMUSERROW could not be read.");
}
}
if (code > 6) {
- command_print(CMD_CTX, "Invalid bootloader size. Please "
+ command_print(CMD, "Invalid bootloader size. Please "
"see datasheet for a list valid sizes.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
nb = (2 << (8 - size)) * page_size;
/* There are 4 pages per row */
- command_print(CMD_CTX, "Bootloader size is %" PRIu32 " bytes (%" PRIu32 " rows)",
+ command_print(CMD, "Bootloader size is %" PRIu32 " bytes (%" PRIu32 " rows)",
nb, (uint32_t)(nb / (page_size * 4)));
}
}
* perform the erase. */
int res = target_write_u8(target, SAMD_DSU + SAMD_DSU_CTRL_EXT, (1<<4));
if (res == ERROR_OK)
- command_print(CMD_CTX, "chip erase started");
+ command_print(CMD, "chip erase started");
else
- command_print(CMD_CTX, "write to DSU CTRL failed");
+ command_print(CMD, "write to DSU CTRL failed");
return res;
}
return ERROR_FAIL;
if (CMD_ARGC > 2) {
- command_print(CMD_CTX, "Too much Arguments given.");
+ command_print(CMD, "Too much Arguments given.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
int res2 = target_read_memory(target, SAMD_USER_ROW, 4, 2, buffer);
if (res2 == ERROR_OK) {
uint64_t value = target_buffer_get_u64(target, buffer);
- command_print(CMD_CTX, "USER PAGE: 0x%016"PRIX64, value);
+ command_print(CMD, "USER PAGE: 0x%016"PRIX64, value);
} else {
LOG_ERROR("USER PAGE could not be read.");
}
unsigned long size = strtoul(CMD_ARGV[0], NULL, 0);
uint32_t code = (size + 8191) / 8192;
if (code > 15) {
- command_print(CMD_CTX, "Invalid bootloader size. Please "
+ command_print(CMD, "Invalid bootloader size. Please "
"see datasheet for a list valid sizes.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
if (res2 == ERROR_OK) {
uint32_t code = (val >> 26) & 0xf; /* grab size code */
uint32_t size = (15 - code) * 8192;
- command_print(CMD_CTX, "Bootloader protected in the first %"
+ command_print(CMD, "Bootloader protected in the first %"
PRIu32 " bytes", size);
}
r = samv_get_gpnvm(target, x, &v);
if (r != ERROR_OK)
break;
- command_print(CMD_CTX, "samv-gpnvm%u: %u", x, v);
+ command_print(CMD, "samv-gpnvm%u: %u", x, v);
}
return r;
}
if ((who >= 0) && (((unsigned)who) < SAMV_NUM_GPNVM_BITS)) {
r = samv_get_gpnvm(target, who, &v);
- command_print(CMD_CTX, "samv-gpnvm%u: %u", who, v);
+ command_print(CMD, "samv-gpnvm%u: %u", who, v);
return r;
} else {
- command_print(CMD_CTX, "invalid gpnvm: %u", who);
+ command_print(CMD, "invalid gpnvm: %u", who);
return ERROR_COMMAND_SYNTAX_ERROR;
}
}
if (who == -1) {
- command_print(CMD_CTX, "missing gpnvm number");
+ command_print(CMD, "missing gpnvm number");
return ERROR_COMMAND_SYNTAX_ERROR;
}
else if (!strcmp("clr", CMD_ARGV[0]) || !strcmp("clear", CMD_ARGV[0]))
r = samv_clear_gpnvm(target, who);
else {
- command_print(CMD_CTX, "unknown command: %s", CMD_ARGV[0]);
+ command_print(CMD, "unknown command: %s", CMD_ARGV[0]);
r = ERROR_COMMAND_SYNTAX_ERROR;
}
return r;
for (i = 0; i < bank->num_sectors; i++)
bank->sectors[i].is_erased = 1;
- command_print(CMD_CTX, "avr mass erase complete");
+ command_print(CMD, "avr mass erase complete");
} else
- command_print(CMD_CTX, "avr mass erase failed");
+ command_print(CMD, "avr mass erase failed");
LOG_DEBUG("%s", __func__);
return ERROR_OK;
return retval;
}
- command_print(CMD_CTX, "efm32x debug interface locked, reset the device to apply");
+ command_print(CMD, "efm32x debug interface locked, reset the device to apply");
return ERROR_OK;
}
}
if (em357_erase_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "em357 failed to erase options");
+ command_print(CMD, "em357 failed to erase options");
return ERROR_OK;
}
em357_info->option_bytes.RDP = 0;
if (em357_write_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "em357 failed to lock device");
+ command_print(CMD, "em357 failed to lock device");
return ERROR_OK;
}
- command_print(CMD_CTX, "em357 locked");
+ command_print(CMD, "em357 locked");
return ERROR_OK;
}
}
if (em357_erase_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "em357 failed to unlock device");
+ command_print(CMD, "em357 failed to unlock device");
return ERROR_OK;
}
if (em357_write_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "em357 failed to lock device");
+ command_print(CMD, "em357 failed to lock device");
return ERROR_OK;
}
- command_print(CMD_CTX, "em357 unlocked.\n"
+ command_print(CMD, "em357 unlocked.\n"
"INFO: a reset or power cycle is required "
"for the new settings to take effect.");
for (i = 0; i < bank->num_sectors; i++)
bank->sectors[i].is_erased = 1;
- command_print(CMD_CTX, "em357 mass erase complete");
+ command_print(CMD, "em357 mass erase complete");
} else
- command_print(CMD_CTX, "em357 mass erase failed");
+ command_print(CMD, "em357 mass erase failed");
return retval;
}
retval = esirisc_flash_mass_erase(bank);
- command_print(CMD_CTX, "mass erase %s",
+ command_print(CMD, "mass erase %s",
(retval == ERROR_OK) ? "successful" : "failed");
return retval;
retval = esirisc_flash_ref_erase(bank);
- command_print(CMD_CTX, "erase reference cell %s",
+ command_print(CMD, "erase reference cell %s",
(retval == ERROR_OK) ? "successful" : "failed");
return retval;
for (i = 0; i < bank->num_sectors; i++)
bank->sectors[i].is_erased = 1;
- command_print(CMD_CTX, "fm3 chip erase complete");
+ command_print(CMD, "fm3 chip erase complete");
} else {
- command_print(CMD_CTX, "fm3 chip erase failed");
+ command_print(CMD, "fm3 chip erase failed");
}
return ERROR_OK;
flex_nvm_partition_code = (uint8_t)((sim_fcfg1 >> 8) & 0x0f);
switch (flex_nvm_partition_code) {
case 0:
- command_print(CMD_CTX, "No EEPROM backup, data flash only");
+ command_print(CMD, "No EEPROM backup, data flash only");
break;
case 1:
case 2:
case 4:
case 5:
case 6:
- command_print(CMD_CTX, "EEPROM backup %d KB", 4 << flex_nvm_partition_code);
+ command_print(CMD, "EEPROM backup %d KB", 4 << flex_nvm_partition_code);
break;
case 8:
- command_print(CMD_CTX, "No data flash, EEPROM backup only");
+ command_print(CMD, "No data flash, EEPROM backup only");
break;
case 0x9:
case 0xA:
case 0xC:
case 0xD:
case 0xE:
- command_print(CMD_CTX, "data flash %d KB", 4 << (flex_nvm_partition_code & 7));
+ command_print(CMD, "data flash %d KB", 4 << (flex_nvm_partition_code & 7));
break;
case 0xf:
- command_print(CMD_CTX, "No EEPROM backup, data flash only (DEPART not set)");
+ command_print(CMD, "No EEPROM backup, data flash only (DEPART not set)");
break;
default:
- command_print(CMD_CTX, "Unsupported EEPROM backup size code 0x%02" PRIx8, flex_nvm_partition_code);
+ command_print(CMD, "Unsupported EEPROM backup size code 0x%02" PRIx8, flex_nvm_partition_code);
}
return ERROR_OK;
if (result != ERROR_OK)
return result;
- command_print(CMD_CTX, "FlexNVM partition set. Please reset MCU.");
+ command_print(CMD, "FlexNVM partition set. Please reset MCU.");
if (k_chip) {
first_nvm_bank = k_chip->num_pflash_blocks;
k_chip->probed = false;
}
- command_print(CMD_CTX, "FlexNVM banks will be re-probed to set new data flash size.");
+ command_print(CMD, "FlexNVM banks will be re-probed to set new data flash size.");
return ERROR_OK;
}
}
if (allow_fcf_writes) {
- command_print(CMD_CTX, "Arbitrary Flash Configuration Field writes enabled.");
- command_print(CMD_CTX, "Protection info writes to FCF disabled.");
+ command_print(CMD, "Arbitrary Flash Configuration Field writes enabled.");
+ command_print(CMD, "Protection info writes to FCF disabled.");
LOG_WARNING("BEWARE: incorrect flash configuration may permanently lock the device.");
} else {
- command_print(CMD_CTX, "Protection info writes to Flash Configuration Field enabled.");
- command_print(CMD_CTX, "Arbitrary FCF writes disabled. Mode safe from unwanted locking of the device.");
+ command_print(CMD, "Protection info writes to Flash Configuration Field enabled.");
+ command_print(CMD, "Arbitrary FCF writes disabled. Mode safe from unwanted locking of the device.");
}
return ERROR_OK;
fcf_fopt = (uint8_t)strtoul(CMD_ARGV[0], NULL, 0);
fcf_fopt_configured = true;
} else {
- command_print(CMD_CTX, "FCF_FOPT 0x%02" PRIx8, fcf_fopt);
+ command_print(CMD, "FCF_FOPT 0x%02" PRIx8, fcf_fopt);
}
return ERROR_OK;
int status_code = get_lpc2000_part_id(bank, &part_id);
if (status_code != 0x0) {
if (status_code == ERROR_FLASH_OPERATION_FAILED) {
- command_print(CMD_CTX, "no sufficient working area specified, can't access LPC2000 IAP interface");
+ command_print(CMD, "no sufficient working area specified, can't access LPC2000 IAP interface");
} else
- command_print(CMD_CTX, "lpc2000 IAP returned status code %i", status_code);
+ command_print(CMD, "lpc2000 IAP returned status code %i", status_code);
} else
- command_print(CMD_CTX, "lpc2000 part id: 0x%8.8" PRIx32, part_id);
+ command_print(CMD, "lpc2000 part id: 0x%8.8" PRIx32, part_id);
return retval;
}
if (status != ERROR_OK)
return status;
- command_print(CMD_CTX, "signature: 0x%8.8" PRIx32
+ command_print(CMD, "signature: 0x%8.8" PRIx32
":0x%8.8" PRIx32
":0x%8.8" PRIx32
":0x%8.8" PRIx32,
lpc2900_info->risky = !strcmp(CMD_ARGV[1], ISS_PASSWORD);
if (!lpc2900_info->risky) {
- command_print(CMD_CTX, "Wrong password (use '%s')", ISS_PASSWORD);
+ command_print(CMD, "Wrong password (use '%s')", ISS_PASSWORD);
return ERROR_COMMAND_ARGUMENT_INVALID;
}
- command_print(CMD_CTX,
+ command_print(CMD,
"Potentially dangerous operation allowed in next command!");
return ERROR_OK;
/* Check if command execution is allowed. */
if (!lpc2900_info->risky) {
- command_print(CMD_CTX, "Command execution not allowed!");
+ command_print(CMD, "Command execution not allowed!");
return ERROR_COMMAND_ARGUMENT_INVALID;
}
lpc2900_info->risky = 0;
/* Check if command execution is allowed. */
if (!lpc2900_info->risky) {
- command_print(CMD_CTX, "Command execution not allowed! "
+ command_print(CMD, "Command execution not allowed! "
"(use 'password' command first)");
return ERROR_COMMAND_ARGUMENT_INVALID;
}
if ((first >= bank->num_sectors) ||
(last >= bank->num_sectors) ||
(first > last)) {
- command_print(CMD_CTX, "Illegal sector range");
+ command_print(CMD, "Illegal sector range");
return ERROR_COMMAND_ARGUMENT_INVALID;
}
}
}
- command_print(CMD_CTX,
+ command_print(CMD,
"Sectors security will become effective after next power cycle");
/* Update the sector security status */
/* Check if command execution is allowed. */
if (!lpc2900_info->risky) {
- command_print(CMD_CTX, "Command execution not allowed! "
+ command_print(CMD, "Command execution not allowed! "
"(use 'password' command first)");
return ERROR_COMMAND_ARGUMENT_INVALID;
}
int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
if (CMD_ARGC < 1) {
- command_print(CMD_CTX, "max32xxx mass_erase <bank>");
+ command_print(CMD, "max32xxx mass_erase <bank>");
return ERROR_OK;
}
for (i = 0; i < bank->num_sectors; i++)
bank->sectors[i].is_erased = 1;
- command_print(CMD_CTX, "max32xxx mass erase complete");
+ command_print(CMD, "max32xxx mass erase complete");
} else
- command_print(CMD_CTX, "max32xxx mass erase failed");
+ command_print(CMD, "max32xxx mass erase failed");
return ERROR_OK;
}
uint32_t addr, len;
if (CMD_ARGC != 3) {
- command_print(CMD
_CTX, "max32xxx protection_set <bank> <addr> <size>");
+ command_print(CMD, "max32xxx protection_set <bank> <addr> <size>");
return ERROR_OK;
}
/* Convert the range to the page numbers */
if (1 != sscanf(CMD_ARGV[1], "0x%"SCNx32, &addr)) {
LOG_WARNING("Error parsing address");
- command_print(CMD
_CTX, "max32xxx protection_set <bank> <addr> <size>");
+ command_print(CMD, "max32xxx protection_set <bank> <addr> <size>");
return ERROR_FAIL;
}
/* Mask off the top portion on the address */
if (1 != sscanf(CMD_ARGV[2], "0x%"SCNx32, &len)) {
LOG_WARNING("Error parsing length");
- command_print(CMD
_CTX, "max32xxx protection_set <bank> <addr> <size>");
+ command_print(CMD, "max32xxx protection_set <bank> <addr> <size>");
return ERROR_FAIL;
}
len = addr + (len / info->sector_size) - 1;
if (max32xxx_protect(bank, 1, addr, len) == ERROR_OK)
- command_print(CMD_CTX, "max32xxx protection set complete");
+ command_print(CMD, "max32xxx protection set complete");
else
- command_print(CMD_CTX, "max32xxx protection set failed");
+ command_print(CMD, "max32xxx protection set failed");
return ERROR_OK;
}
uint32_t addr, len;
if (CMD_ARGC != 3) {
- command_print(CMD
_CTX, "max32xxx protection_clr <bank> <addr> <size>");
+ command_print(CMD, "max32xxx protection_clr <bank> <addr> <size>");
return ERROR_OK;
}
/* Convert the range to the page numbers */
if (1 != sscanf(CMD_ARGV[1], "0x%"SCNx32, &addr)) {
LOG_WARNING("Error parsing address");
- command_print(CMD
_CTX, "max32xxx protection_clr <bank> <addr> <size>");
+ command_print(CMD, "max32xxx protection_clr <bank> <addr> <size>");
return ERROR_FAIL;
}
/* Mask off the top portion on the address */
if (1 != sscanf(CMD_ARGV[2], "0x%"SCNx32, &len)) {
LOG_WARNING("Error parsing length");
- command_print(CMD
_CTX, "max32xxx protection_clr <bank> <addr> <size>");
+ command_print(CMD, "max32xxx protection_clr <bank> <addr> <size>");
return ERROR_FAIL;
}
len = addr + (len / info->sector_size) - 1;
if (max32xxx_protect(bank, 0, addr, len) == ERROR_OK)
- command_print(CMD_CTX, "max32xxx protection clear complete");
+ command_print(CMD, "max32xxx protection clear complete");
else
- command_print(CMD_CTX, "max32xxx protection clear failed");
+ command_print(CMD, "max32xxx protection clear failed");
return ERROR_OK;
}
int i;
if (CMD_ARGC < 1) {
- command_print(CMD_CTX, "max32xxx protection_check <bank>");
+ command_print(CMD, "max32xxx protection_check <bank>");
return ERROR_OK;
}
retval = target_read_u32(target, UFMD, &uflash_data);
if (retval != ERROR_OK)
return retval;
- command_print(CMD_CTX, "Read userflash %s region:\n"
+ command_print(CMD, "Read userflash %s region:\n"
"address = 0x%04x,\n"
"value = 0x%02x.", CMD_ARGV[0], uflash_addr, uflash_data);
return retval;
int page_num = uflash_addr/USERFLASH_PAGE_SIZE;
- command_print(CMD_CTX, "Write userflash %s region:\n"
+ command_print(CMD, "Write userflash %s region:\n"
"address = 0x%04x,\n"
"value = 0x%02x.\n"
"Please wait ... ", CMD_ARGV[0], uflash_addr, uflash_data);
/* write dump to userflash */
niietcm4_load_uflash_page(bank, uflash_dump, page_num, mem_type);
- command_print(CMD_CTX, "done!");
+ command_print(CMD, "done!");
return retval;
}
retval = niietcm4_uopstatus_check(bank);
if (retval != ERROR_OK)
return retval;
- command_print(CMD_CTX, "Userflash full erase done!");
+ command_print(CMD, "Userflash full erase done!");
return retval;
}
return retval;
}
- command_print(CMD_CTX, "Erase %s userflash pages %d through %d done!", CMD_ARGV[0], first, last);
+ command_print(CMD, "Erase %s userflash pages %d through %d done!", CMD_ARGV[0], first, last);
return retval;
}
return retval;
if (uflash_data & INFOWORD3_LOCK_IFB_UF)
- command_print(CMD_CTX, "All sectors of info userflash are not protected!");
+ command_print(CMD, "All sectors of info userflash are not protected!");
else
- command_print(CMD_CTX, "All sectors of info userflash are protected!");
+ command_print(CMD, "All sectors of info userflash are protected!");
} else {
uflash_addr = UF_LOCK_ADDR;
uflash_cmd = UFMC_MAGIC_KEY | UFMC_READ_IFB;
for (j = 0; j < 8; j++) {
if (uflash_data & 0x1)
- command_print(CMD_CTX, "Userflash sector #%03d: 0x%04x (0x100) is not protected!",
+ command_print(CMD, "Userflash sector #%03d: 0x%04x (0x100) is not protected!",
i*8+j, (i*8+j)*USERFLASH_PAGE_SIZE);
else
- command_print(CMD_CTX, "Userflash sector #%03d: 0x%04x (0x100) is protected!",
+ command_print(CMD, "Userflash sector #%03d: 0x%04x (0x100) is protected!",
i*8+j, (i*8+j)*USERFLASH_PAGE_SIZE);
uflash_data = uflash_data >> 1;
}
int set;
if (strcmp("on", CMD_ARGV[3]) == 0) {
- command_print(CMD_CTX, "Try to enable %s userflash sectors %d through %d protection. Please wait ... ",
+ command_print(CMD, "Try to enable %s userflash sectors %d through %d protection. Please wait ... ",
CMD_ARGV[0], first, last);
set = 1;
} else if (strcmp("off", CMD_ARGV[3]) == 0) {
- command_print(CMD_CTX, "Try to disable %s userflash sectors %d through %d protection. Please wait ... ",
+ command_print(CMD, "Try to disable %s userflash sectors %d through %d protection. Please wait ... ",
CMD_ARGV[0], first, last);
set = 0;
} else
if (retval != ERROR_OK)
return retval;
- command_print(CMD_CTX, "done!");
+ command_print(CMD, "done!");
return retval;
}
int set;
if (strcmp("on", CMD_ARGV[0]) == 0) {
- command_print(CMD_CTX, "Try to enable bootflash info region remap. Please wait ...");
+ command_print(CMD, "Try to enable bootflash info region remap. Please wait ...");
set = 1;
} else if (strcmp("off", CMD_ARGV[0]) == 0) {
- command_print(CMD_CTX, "Try to disable bootflash info region remap. Please wait ...");
+ command_print(CMD, "Try to disable bootflash info region remap. Please wait ...");
set = 0;
} else
return ERROR_COMMAND_SYNTAX_ERROR;
/* write dump to userflash */
niietcm4_load_uflash_page(bank, uflash_dump, 0, 1);
- command_print(CMD_CTX, "done!");
+ command_print(CMD, "done!");
return retval;
}
else
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX, "Try to configure external memory boot interface:\n"
+ command_print(CMD, "Try to configure external memory boot interface:\n"
"port = %s\n"
"pin = %s\n"
"func = %s\n"
/* write dump to userflash */
niietcm4_load_uflash_page(bank, uflash_dump, 0, 1);
- command_print(CMD_CTX, "done!");
+ command_print(CMD, "done!");
return retval;
}
int set;
if (strcmp("on", CMD_ARGV[0]) == 0) {
- command_print(CMD_CTX, "Try to enable boot from external memory. Please wait ...");
+ command_print(CMD, "Try to enable boot from external memory. Please wait ...");
set = 1;
} else if (strcmp("off", CMD_ARGV[0]) == 0) {
- command_print(CMD_CTX, "Try to disable boot from external memory. Please wait ...");
+ command_print(CMD, "Try to disable boot from external memory. Please wait ...");
set = 0;
} else
return ERROR_COMMAND_SYNTAX_ERROR;
/* write dump to userflash */
niietcm4_load_uflash_page(bank, uflash_dump, 0, 1);
- command_print(CMD_CTX, "done!");
+ command_print(CMD, "done!");
return retval;
}
return retval;
struct target *target = bank->target;
- command_print(CMD_CTX, "Try to perform service mode erase. Please wait ...");
+ command_print(CMD, "Try to perform service mode erase. Please wait ...");
retval = target_write_u32(target, SERVICE_MODE_ERASE_ADDR, 1);
if (retval != ERROR_OK)
}
busy_sleep(1); /* can use busy sleep for short times. */
}
- command_print(CMD_CTX, "done! All data erased.");
+ command_print(CMD, "done! All data erased.");
return retval;
}
if (retval != ERROR_OK)
return retval;
- command_print(CMD_CTX, "niietcm4 flash driver\n"
+ command_print(CMD, "niietcm4 flash driver\n"
"version: %d.%d\n"
"author: Bogdan Kolbov\n"
"mail: kolbov@niiet.ru",
retval = numicro_fmc_cmd(target, ISPCMD_CHIPERASE, 0, 0, &rdat);
if (retval != ERROR_OK) {
- command_print(CMD_CTX, "numicro chip_erase failed");
+ command_print(CMD, "numicro chip_erase failed");
return retval;
}
- command_print(CMD_CTX, "numicro chip_erase complete");
+ command_print(CMD, "numicro chip_erase complete");
return ERROR_OK;
}
return retval;
if (address < bank->base || address >= (bank->base + bank->size)) {
- command_print(CMD_CTX, "flash address '%s' is out of bounds", CMD_ARGV[0]);
+ command_print(CMD, "flash address '%s' is out of bounds", CMD_ARGV[0]);
return ERROR_OK;
}
res = ERROR_FLASH_OPERATION_FAILED;
if (res == ERROR_OK)
- command_print(CMD_CTX, "pic32mx pgm word complete");
+ command_print(CMD, "pic32mx pgm word complete");
else
- command_print(CMD_CTX, "pic32mx pgm word failed (status = 0x%x)", status);
+ command_print(CMD, "pic32mx pgm word failed (status = 0x%x)", status);
return ERROR_OK;
}
int timeout = 10;
if (CMD_ARGC < 1) {
- command_print(CMD_CTX, "pic32mx unlock <bank>");
+ command_print(CMD, "pic32mx unlock <bank>");
return ERROR_COMMAND_SYNTAX_ERROR;
}
mips_ejtag_drscan_8(ejtag_info, &mchip_cmd);
if (mchip_cmd & (1 << 7)) {
/* device is not locked */
- command_print(CMD_CTX, "pic32mx is already unlocked, erasing anyway");
+ command_print(CMD, "pic32mx is already unlocked, erasing anyway");
}
/* unlock/erase device */
/* select ejtag tap */
mips_ejtag_set_instr(ejtag_info, MTAP_SW_ETAP);
- command_print(CMD_CTX, "pic32mx unlocked.\n"
+ command_print(CMD, "pic32mx unlocked.\n"
"INFO: a reset or power cycle is required "
"for the new settings to take effect.");
retval = psoc4_mass_erase(bank);
if (retval == ERROR_OK)
- command_print(CMD_CTX, "psoc mass erase complete");
+ command_print(CMD, "psoc mass erase complete");
else
- command_print(CMD_CTX, "psoc mass erase failed");
+ command_print(CMD, "psoc mass erase failed");
return retval;
}
retval = psoc5lp_spc_erase_all(bank->target);
if (retval == ERROR_OK)
- command_print(CMD_CTX, "PSoC 5LP erase succeeded");
+ command_print(CMD, "PSoC 5LP erase succeeded");
else
- command_print(CMD_CTX, "PSoC 5LP erase failed");
+ command_print(CMD, "PSoC 5LP erase failed");
return retval;
}
for (i = 0; i < bank->num_sectors; i++)
bank->sectors[i].is_erased = 1;
- command_print(CMD_CTX, "stellaris mass erase complete");
+ command_print(CMD, "stellaris mass erase complete");
} else
- command_print(CMD_CTX, "stellaris mass erase failed");
+ command_print(CMD, "stellaris mass erase failed");
return ERROR_OK;
}
return retval;
if (stm32x_erase_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "stm32x failed to erase options");
+ command_print(CMD, "stm32x failed to erase options");
return ERROR_OK;
}
stm32x_info->option_bytes.rdp = 0;
if (stm32x_write_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "stm32x failed to lock device");
+ command_print(CMD, "stm32x failed to lock device");
return ERROR_OK;
}
- command_print(CMD_CTX, "stm32x locked");
+ command_print(CMD, "stm32x locked");
return ERROR_OK;
}
return retval;
if (stm32x_erase_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "stm32x failed to erase options");
+ command_print(CMD, "stm32x failed to erase options");
return ERROR_OK;
}
if (stm32x_write_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "stm32x failed to unlock device");
+ command_print(CMD, "stm32x failed to unlock device");
return ERROR_OK;
}
- command_print(CMD_CTX, "stm32x unlocked.\n"
+ command_print(CMD, "stm32x unlocked.\n"
"INFO: a reset or power cycle is required "
"for the new settings to take effect.");
return retval;
if (optionbyte & (1 << OPT_ERROR))
- command_print(CMD_CTX, "option byte complement error");
+ command_print(CMD, "option byte complement error");
- command_print(CMD_CTX, "option byte register = 0x%" PRIx32 "", optionbyte);
- command_print(CMD_CTX, "write protection register = 0x%" PRIx32 "", protection);
+ command_print(CMD, "option byte register = 0x%" PRIx32 "", optionbyte);
+ command_print(CMD, "write protection register = 0x%" PRIx32 "", protection);
- command_print(CMD_CTX, "read protection: %s",
+ command_print(CMD, "read protection: %s",
(optionbyte & (1 << OPT_READOUT)) ? "on" : "off");
/* user option bytes are offset depending on variant */
optionbyte >>= stm32x_info->option_offset;
- command_print(CMD_CTX, "watchdog: %sware",
+ command_print(CMD, "watchdog: %sware",
(optionbyte & (1 << OPT_RDWDGSW)) ? "soft" : "hard");
- command_print(CMD_CTX, "stop mode: %sreset generated upon entry",
+ command_print(CMD, "stop mode: %sreset generated upon entry",
(optionbyte & (1 << OPT_RDRSTSTOP)) ? "no " : "");
- command_print(CMD_CTX, "standby mode: %sreset generated upon entry",
+ command_print(CMD, "standby mode: %sreset generated upon entry",
(optionbyte & (1 << OPT_RDRSTSTDBY)) ? "no " : "");
if (stm32x_info->has_dual_banks)
- command_print(CMD_CTX, "boot: bank %d", (optionbyte & (1 << OPT_BFB2)) ? 0 : 1);
+ command_print(CMD, "boot: bank %d", (optionbyte & (1 << OPT_BFB2)) ? 0 : 1);
- command_print(CMD_CTX, "user data = 0x%02" PRIx16 "", user_data);
+ command_print(CMD, "user data = 0x%02" PRIx16 "", user_data);
return ERROR_OK;
}
}
if (stm32x_erase_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "stm32x failed to erase options");
+ command_print(CMD, "stm32x failed to erase options");
return ERROR_OK;
}
stm32x_info->option_bytes.data = useropt;
if (stm32x_write_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "stm32x failed to write options");
+ command_print(CMD, "stm32x failed to write options");
return ERROR_OK;
}
- command_print(CMD_CTX, "stm32x write options complete.\n"
+ command_print(CMD, "stm32x write options complete.\n"
"INFO: %spower cycle is required "
"for the new settings to take effect.",
stm32x_info->can_load_options
for (i = 0; i < bank->num_sectors; i++)
bank->sectors[i].is_erased = 1;
- command_print(CMD_CTX, "stm32x mass erase complete");
+ command_print(CMD, "stm32x mass erase complete");
} else
- command_print(CMD_CTX, "stm32x mass erase failed");
+ command_print(CMD, "stm32x mass erase failed");
return retval;
}
}
if (stm32x_read_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "%s failed to read options", bank->driver->name);
+ command_print(CMD, "%s failed to read options", bank->driver->name);
return ERROR_OK;
}
stm32x_info->option_bytes.RDP = 0;
if (stm32x_write_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "%s failed to lock device", bank->driver->name);
+ command_print(CMD, "%s failed to lock device", bank->driver->name);
return ERROR_OK;
}
- command_print(CMD_CTX, "%s locked", bank->driver->name);
+ command_print(CMD, "%s locked", bank->driver->name);
return ERROR_OK;
}
}
if (stm32x_read_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "%s failed to read options", bank->driver->name);
+ command_print(CMD, "%s failed to read options", bank->driver->name);
return ERROR_OK;
}
}
if (stm32x_write_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "%s failed to unlock device", bank->driver->name);
+ command_print(CMD, "%s failed to unlock device", bank->driver->name);
return ERROR_OK;
}
- command_print(CMD_CTX, "%s unlocked.\n"
+ command_print(CMD, "%s unlocked.\n"
"INFO: a reset or power cycle is required "
"for the new settings to take effect.", bank->driver->name);
int i;
if (CMD_ARGC < 1) {
- command_print(CMD_CTX, "stm32x mass_erase <bank>");
+ command_print(CMD, "stm32x mass_erase <bank>");
return ERROR_COMMAND_SYNTAX_ERROR;
}
for (i = 0; i < bank->num_sectors; i++)
bank->sectors[i].is_erased = 1;
- command_print(CMD_CTX, "stm32x mass erase complete");
+ command_print(CMD, "stm32x mass erase complete");
} else {
- command_print(CMD_CTX, "stm32x mass erase failed");
+ command_print(CMD, "stm32x mass erase failed");
}
return retval;
struct stm32x_flash_bank *stm32x_info = NULL;
if (CMD_ARGC != 1) {
- command_print(CMD_CTX, "stm32f2x options_read <bank>");
+ command_print(CMD, "stm32f2x options_read <bank>");
return ERROR_COMMAND_SYNTAX_ERROR;
}
if (stm32x_info->has_boot_addr) {
uint32_t boot_addr = stm32x_info->option_bytes.boot_addr;
- command_print(CMD_CTX, "stm32f2x user_options 0x%03X,"
+ command_print(CMD, "stm32f2x user_options 0x%03X,"
" boot_add0 0x%04X, boot_add1 0x%04X",
stm32x_info->option_bytes.user_options,
boot_addr & 0xffff, (boot_addr & 0xffff0000) >> 16);
if (stm32x_info->has_optcr2_pcrop) {
- command_print(CMD_CTX, "stm32f2x optcr2_pcrop 0x%08X",
+ command_print(CMD, "stm32f2x optcr2_pcrop 0x%08X",
stm32x_info->option_bytes.optcr2_pcrop);
}
} else {
- command_print(CMD_CTX, "stm32f2x user_options 0x%03X",
+ command_print(CMD, "stm32f2x user_options 0x%03X",
stm32x_info->option_bytes.user_options);
}
} else {
- command_print(CMD_CTX, "stm32f2x user_options 0x%02X",
+ command_print(CMD, "stm32f2x user_options 0x%02X",
stm32x_info->option_bytes.user_options);
}
uint16_t user_options, boot_addr0, boot_addr1, options_mask;
if (CMD_ARGC < 1) {
- command_print(CMD_CTX, "stm32f2x options_write <bank> ...");
+ command_print(CMD, "stm32f2x options_write <bank> ...");
return ERROR_COMMAND_SYNTAX_ERROR;
}
stm32x_info = bank->driver_priv;
if (stm32x_info->has_boot_addr) {
if (CMD_ARGC != 4) {
- command_print(CMD_CTX, "stm32f2x options_write <bank> <user_options>"
+ command_print(CMD, "stm32f2x options_write <bank> <user_options>"
" <boot_addr0> <boot_addr1>");
return ERROR_COMMAND_SYNTAX_ERROR;
}
stm32x_info->option_bytes.boot_addr = boot_addr0 | (((uint32_t) boot_addr1) << 16);
} else {
if (CMD_ARGC != 2) {
- command_print(CMD_CTX, "stm32f2x options_write <bank> <user_options>");
+ command_print(CMD, "stm32f2x options_write <bank> <user_options>");
return ERROR_COMMAND_SYNTAX_ERROR;
}
}
options_mask = !stm32x_info->has_extra_options ? ~0xfc :
~(((0xf00 << (stm32x_info->protection_bits - 12)) | 0xff) & 0xffc);
if (user_options & options_mask) {
- command_print(CMD_CTX, "stm32f2x invalid user_options");
+ command_print(CMD, "stm32f2x invalid user_options");
return ERROR_COMMAND_ARGUMENT_INVALID;
}
stm32x_info->option_bytes.user_options = user_options;
if (stm32x_write_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "stm32f2x failed to write options");
+ command_print(CMD, "stm32f2x failed to write options");
return ERROR_OK;
}
/* ... and reprogramming of whole flash */
stm32x_info->probed = false;
- command_print(CMD_CTX, "stm32f2x write options complete.\n"
+ command_print(CMD, "stm32f2x write options complete.\n"
"INFO: a reset or power cycle is required "
"for the new settings to take effect.");
return retval;
uint32_t optcr2_pcrop;
if (CMD_ARGC != 2) {
- command_print(CMD_CTX, "stm32f2x optcr2_write <bank> <optcr2_value>");
+ command_print(CMD, "stm32f2x optcr2_write <bank> <optcr2_value>");
return ERROR_COMMAND_SYNTAX_ERROR;
}
stm32x_info = bank->driver_priv;
if (!stm32x_info->has_optcr2_pcrop) {
- command_print(CMD_CTX, "no optcr2 register");
+ command_print(CMD, "no optcr2 register");
return ERROR_COMMAND_ARGUMENT_INVALID;
}
- command_print(CMD_CTX, "INFO: To disable PCROP, set PCROP_RDP"
+ command_print(CMD, "INFO: To disable PCROP, set PCROP_RDP"
" with PCROPi bits STILL SET, then\nlock device and"
" finally unlock it. Clears PCROP and mass erases flash.");
stm32x_info->option_bytes.optcr2_pcrop = optcr2_pcrop;
if (stm32x_write_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "stm32f2x failed to write options");
+ command_print(CMD, "stm32f2x failed to write options");
return ERROR_OK;
}
- command_print(CMD_CTX, "stm32f2x optcr2_write complete.");
+ command_print(CMD, "stm32f2x optcr2_write complete.");
return retval;
}
COMMAND_HANDLER(stm32x_handle_otp_command)
{
if (CMD_ARGC < 2) {
- command_print(CMD_CTX, "stm32x otp <bank> (enable|disable|show)");
+ command_print(CMD, "stm32x otp <bank> (enable|disable|show)");
return ERROR_COMMAND_SYNTAX_ERROR;
}
} else if (strcmp(CMD_ARGV[1], "disable") == 0) {
stm32x_otp_disable(bank);
} else if (strcmp(CMD_ARGV[1], "show") == 0) {
- command_print(CMD_CTX,
+ command_print(CMD,
"OTP memory bank #%d is %s for write commands.",
bank->bank_number,
stm32x_is_otp_unlocked(bank) ? "enabled" : "disabled");
return ERROR_COMMAND_SYNTAX_ERROR;
}
} else {
- command_print(CMD_CTX, "Failed: not an OTP bank.");
+ command_print(CMD, "Failed: not an OTP bank.");
}
return retval;
}
if (stm32x_read_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "%s failed to read options",
+ command_print(CMD, "%s failed to read options",
bank->driver->name);
return ERROR_OK;
}
stm32x_info->option_bytes.RDP = 0;
if (stm32x_write_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "%s failed to lock device",
+ command_print(CMD, "%s failed to lock device",
bank->driver->name);
return ERROR_OK;
}
- command_print(CMD_CTX, "%s locked", bank->driver->name);
+ command_print(CMD, "%s locked", bank->driver->name);
return ERROR_OK;
}
}
if (stm32x_read_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "%s failed to read options", bank->driver->name);
+ command_print(CMD, "%s failed to read options", bank->driver->name);
return ERROR_OK;
}
stm32x_info->option_bytes.RDP = 0xAA;
if (stm32x_write_options(bank) != ERROR_OK) {
- command_print(CMD_CTX, "%s failed to unlock device", bank->driver->name);
+ command_print(CMD, "%s failed to unlock device", bank->driver->name);
return ERROR_OK;
}
- command_print(CMD_CTX, "%s unlocked.\n", bank->driver->name);
+ command_print(CMD, "%s unlocked.\n", bank->driver->name);
return ERROR_OK;
}
int i;
if (CMD_ARGC < 1) {
- command_print(CMD_CTX, "stm32h7x mass_erase <bank>");
+ command_print(CMD, "stm32h7x mass_erase <bank>");
return ERROR_COMMAND_SYNTAX_ERROR;
}
for (i = 0; i < bank->num_sectors; i++)
bank->sectors[i].is_erased = 1;
- command_print(CMD_CTX, "stm32h7x mass erase complete");
+ command_print(CMD, "stm32h7x mass erase complete");
} else {
- command_print(CMD_CTX, "stm32h7x mass erase failed");
+ command_print(CMD, "stm32h7x mass erase failed");
}
return retval;
uint32_t action;
if (CMD_ARGC < 1) {
- command_print(CMD_CTX, "stm32l4x mass_erase <STM32L4 bank>");
+ command_print(CMD, "stm32l4x mass_erase <STM32L4 bank>");
return ERROR_COMMAND_SYNTAX_ERROR;
}
for (i = 0; i < bank->num_sectors; i++)
bank->sectors[i].is_erased = 1;
- command_print(CMD_CTX, "stm32l4x mass erase complete");
+ command_print(CMD, "stm32l4x mass erase complete");
} else {
- command_print(CMD_CTX, "stm32l4x mass erase failed");
+ command_print(CMD, "stm32l4x mass erase failed");
}
return retval;
COMMAND_HANDLER(stm32l4_handle_option_read_command)
{
if (CMD_ARGC < 2) {
- command_print(CMD_CTX, "stm32l4x option_read <STM32L4 bank> <option_reg offset>");
+ command_print(CMD, "stm32l4x option_read <STM32L4 bank> <option_reg offset>");
return ERROR_COMMAND_SYNTAX_ERROR;
}
if (ERROR_OK != retval)
return retval;
- command_print(CMD_CTX, "Option Register: <0x%" PRIx32 "> = 0x%" PRIx32 "", reg_addr, value);
+ command_print(CMD, "Option Register: <0x%" PRIx32 "> = 0x%" PRIx32 "", reg_addr, value);
return retval;
}
COMMAND_HANDLER(stm32l4_handle_option_write_command)
{
if (CMD_ARGC < 3) {
- command_print(CMD_CTX, "stm32l4x option_write <STM32L4 bank> <option_reg offset> <value> [mask]");
+ command_print(CMD, "stm32l4x option_write <STM32L4 bank> <option_reg offset> <value> [mask]");
return ERROR_COMMAND_SYNTAX_ERROR;
}
if (CMD_ARGC > 3)
mask = strtoul(CMD_ARGV[3], NULL, 16);
- command_print(CMD_CTX, "%s Option written.\n"
+ command_print(CMD, "%s Option written.\n"
"INFO: a reset or power cycle is required "
"for the new settings to take effect.", bank->driver->name);
/* Write the OBLLAUNCH bit in CR -> Cause device "POR" and option bytes reload */
retval = target_write_u32(target, stm32l4_get_flash_reg(bank, STM32_FLASH_CR), FLASH_OBLLAUNCH);
- command_print(CMD_CTX, "stm32l4x option load (POR) completed.");
+ command_print(CMD, "stm32l4x option load (POR) completed.");
return retval;
}
/* set readout protection level 1 by erasing the RDP option byte */
if (stm32l4_write_option(bank, STM32_FLASH_OPTR, 0, 0x000000FF) != ERROR_OK) {
- command_print(CMD_CTX, "%s failed to lock device", bank->driver->name);
+ command_print(CMD, "%s failed to lock device", bank->driver->name);
return ERROR_OK;
}
}
if (stm32l4_write_option(bank, STM32_FLASH_OPTR, RDP_LEVEL_0, 0x000000FF) != ERROR_OK) {
- command_print(CMD_CTX, "%s failed to unlock device", bank->driver->name);
+ command_print(CMD, "%s failed to unlock device", bank->driver->name);
return ERROR_OK;
}
for (i = 0; i < bank->num_sectors; i++)
bank->sectors[i].is_erased = 1;
- command_print(CMD_CTX, "stm32lx mass erase complete");
+ command_print(CMD, "stm32lx mass erase complete");
} else {
- command_print(CMD_CTX, "stm32lx mass erase failed");
+ command_print(CMD, "stm32lx mass erase failed");
}
return retval;
retval = stm32lx_lock(bank);
if (retval == ERROR_OK)
- command_print(CMD_CTX, "STM32Lx locked, takes effect after power cycle.");
+ command_print(CMD, "STM32Lx locked, takes effect after power cycle.");
else
- command_print(CMD_CTX, "STM32Lx lock failed");
+ command_print(CMD, "STM32Lx lock failed");
return retval;
}
retval = stm32lx_unlock(bank);
if (retval == ERROR_OK)
- command_print(CMD_CTX, "STM32Lx unlocked, takes effect after power cycle.");
+ command_print(CMD, "STM32Lx unlocked, takes effect after power cycle.");
else
- command_print(CMD_CTX, "STM32Lx unlock failed");
+ command_print(CMD, "STM32Lx unlock failed");
return retval;
}
idcode = buf_get_u32(buffer, 0, 32);
- command_print(CMD_CTX, "str9xpec part id: 0x%8.8" PRIx32 "", idcode);
+ command_print(CMD, "str9xpec part id: 0x%8.8" PRIx32 "", idcode);
free(buffer);
/* boot bank */
if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_CSMAPBIT, 1))
- command_print(CMD_CTX, "CS Map: bank1");
+ command_print(CMD, "CS Map: bank1");
else
- command_print(CMD_CTX, "CS Map: bank0");
+ command_print(CMD, "CS Map: bank0");
/* OTP lock */
if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_OTPBIT, 1))
- command_print(CMD_CTX, "OTP Lock: OTP Locked");
+ command_print(CMD, "OTP Lock: OTP Locked");
else
- command_print(CMD_CTX, "OTP Lock: OTP Unlocked");
+ command_print(CMD, "OTP Lock: OTP Unlocked");
/* LVD Threshold */
if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_LVDTHRESBIT, 1))
- command_print(CMD_CTX, "LVD Threshold: 2.7v");
+ command_print(CMD, "LVD Threshold: 2.7v");
else
- command_print(CMD_CTX, "LVD Threshold: 2.4v");
+ command_print(CMD, "LVD Threshold: 2.4v");
/* LVD reset warning */
if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_LVDWARNBIT, 1))
- command_print(CMD_CTX, "LVD Reset Warning: VDD or VDDQ Inputs");
+ command_print(CMD, "LVD Reset Warning: VDD or VDDQ Inputs");
else
- command_print(CMD_CTX, "LVD Reset Warning: VDD Input Only");
+ command_print(CMD, "LVD Reset Warning: VDD Input Only");
/* LVD reset select */
if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_LVDSELBIT, 1))
- command_print(CMD_CTX, "LVD Reset Selection: VDD or VDDQ Inputs");
+ command_print(CMD, "LVD Reset Selection: VDD or VDDQ Inputs");
else
- command_print(CMD_CTX, "LVD Reset Selection: VDD Input Only");
+ command_print(CMD, "LVD Reset Selection: VDD Input Only");
return ERROR_OK;
}
if ((status & ISC_STATUS_ERROR) != STR9XPEC_ISC_SUCCESS)
return ERROR_FLASH_OPERATION_FAILED;
- command_print(CMD_CTX, "str9xpec write options complete.\n"
+ command_print(CMD, "str9xpec write options complete.\n"
"INFO: a reset or power cycle is required "
"for the new settings to take effect.");
if ((status & ISC_STATUS_ERROR) != STR9XPEC_ISC_SUCCESS)
return ERROR_FLASH_OPERATION_FAILED;
- command_print(CMD_CTX, "str9xpec unlocked.\n"
+ command_print(CMD, "str9xpec unlocked.\n"
"INFO: a reset or power cycle is required "
"for the new settings to take effect.");
tap0 = str9xpec_info->tap;
if (tap0 == NULL) {
/* things are *WRONG* */
- command_print(CMD_CTX, "**STR9FLASH** (tap0) invalid chain?");
+ command_print(CMD, "**STR9FLASH** (tap0) invalid chain?");
return ERROR_FAIL;
}
tap1 = tap0->next_tap;
if (tap1 == NULL) {
/* things are *WRONG* */
- command_print(CMD_CTX, "**STR9FLASH** (tap1) invalid chain?");
+ command_print(CMD, "**STR9FLASH** (tap1) invalid chain?");
return ERROR_FAIL;
}
tap2 = tap1->next_tap;
if (tap2 == NULL) {
/* things are *WRONG* */
- command_print(CMD_CTX, "**STR9FLASH** (tap2) invalid chain?");
+ command_print(CMD, "**STR9FLASH** (tap2) invalid chain?");
return ERROR_FAIL;
}
if (retval == ERROR_FLASH_OPER_UNSUPPORTED)
LOG_WARNING("Flash protection check is not implemented.");
- command_print(CMD_CTX,
+ command_print(CMD,
"#%d : %s at " TARGET_ADDR_FMT ", size 0x%8.8" PRIx32
", buswidth %i, chipwidth %i",
p->bank_number,
else if (!show_sectors || !prot_block_available)
protect_state = "protection state unknown";
- command_print(CMD_CTX,
+ command_print(CMD,
"\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
j,
block_array[j].offset,
if (p->driver->info != NULL) {
retval = p->driver->info(p, buf, sizeof(buf));
if (retval == ERROR_OK)
- command_print(CMD_CTX, "%s", buf);
+ command_print(CMD, "%s", buf);
else
LOG_ERROR("error retrieving flash info");
}
if (p) {
retval = p->driver->probe(p);
if (retval == ERROR_OK)
- command_print(CMD_CTX,
+ command_print(CMD,
"flash '%s' found at " TARGET_ADDR_FMT,
p->driver->name,
p->base);
} else {
- command_print(CMD_CTX, "flash bank '#%s' is out of bounds", CMD_ARGV[0]);
+ command_print(CMD, "flash bank '#%s' is out of bounds", CMD_ARGV[0]);
retval = ERROR_FAIL;
}
int j;
retval = p->driver->erase_check(p);
if (retval == ERROR_OK)
- command_print(CMD_CTX, "successfully checked erase state");
+ command_print(CMD, "successfully checked erase state");
else {
- command_print(CMD_CTX,
+ command_print(CMD,
"unknown error when checking erase state of flash bank #%s at "
TARGET_ADDR_FMT,
CMD_ARGV[0],
erase_state = "erase state unknown";
blank = false;
- command_print(CMD_CTX,
+ command_print(CMD,
"\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
j,
p->sectors[j].offset,
}
if (blank)
- command_print(CMD_CTX, "\tBank is erased");
+ command_print(CMD, "\tBank is erased");
return retval;
}
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
if (length <= 0) {
- command_print(CMD_CTX, "Length must be >0");
+ command_print(CMD, "Length must be >0");
return ERROR_COMMAND_SYNTAX_ERROR;
}
retval = flash_erase_address_range(target, do_pad, address, length);
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
- command_print(CMD_CTX, "erased address " TARGET_ADDR_FMT " (length %"
+ command_print(CMD, "erased address " TARGET_ADDR_FMT " (length %"
PRIi32 ")"
" in %fs (%0.3f KiB/s)", address, length,
duration_elapsed(&bench), duration_kbps(&bench, length));
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
if (!(first <= last)) {
- command_print(CMD_CTX, "ERROR: "
+ command_print(CMD, "ERROR: "
"first sector must be <= last");
return ERROR_FAIL;
}
if (!(last <= (uint32_t)(p->num_sectors - 1))) {
- command_print(CMD_CTX, "ERROR: "
+ command_print(CMD, "ERROR: "
"last sector must be <= %" PRIu32,
p->num_sectors - 1);
return ERROR_FAIL;
retval = flash_driver_erase(p, first, last);
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
- command_print(CMD_CTX, "erased sectors %" PRIu32 " "
+ command_print(CMD, "erased sectors %" PRIu32 " "
"through %" PRIu32 " on flash bank %d "
"in %fs", first, last, p->bank_number, duration_elapsed(&bench));
}
COMMAND_PARSE_ON_OFF(CMD_ARGV[3], set);
if (!(first <= last)) {
- command_print(CMD_CTX, "ERROR: "
+ command_print(CMD, "ERROR: "
"first %s must be <= last",
(p->num_prot_blocks) ? "block" : "sector");
return ERROR_FAIL;
}
if (!(last <= (uint32_t)(num_blocks - 1))) {
- command_print(CMD_CTX, "ERROR: "
+ command_print(CMD, "ERROR: "
"last %s must be <= %" PRIu32,
(p->num_prot_blocks) ? "block" : "sector",
num_blocks - 1);
retval = flash_driver_protect(p, set, first, last);
if (retval == ERROR_OK) {
- command_print(CMD_CTX, "%s protection for %s %" PRIu32
+ command_print(CMD, "%s protection for %s %" PRIu32
" through %" PRIu32 " on flash bank %d",
(set) ? "set" : "cleared",
(p->num_prot_blocks) ? "blocks" : "sectors",
auto_erase = 1;
CMD_ARGV++;
CMD_ARGC--;
- command_print(CMD_CTX, "auto erase enabled");
+ command_print(CMD, "auto erase enabled");
} else if (strcmp(CMD_ARGV[0], "unlock") == 0) {
auto_unlock = true;
CMD_ARGV++;
CMD_ARGC--;
- command_print(CMD_CTX, "auto unlock enabled");
+ command_print(CMD, "auto unlock enabled");
} else
break;
}
}
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
- command_print(CMD_CTX, "wrote %" PRIu32 " bytes from file %s "
+ command_print(CMD, "wrote %" PRIu32 " bytes from file %s "
"in %fs (%0.3f KiB/s)", written, CMD_ARGV[0],
duration_elapsed(&bench), duration_kbps(&bench, written));
}
}
if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
- command_print(CMD_CTX, "wrote %" PRIu32 " bytes to " TARGET_ADDR_FMT
+ command_print(CMD, "wrote %" PRIu32 " bytes to " TARGET_ADDR_FMT
" in %fs (%0.3f KiB/s)", size_bytes, address,
duration_elapsed(&bench), duration_kbps(&bench, size_bytes));
}
free(buffer);
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
- command_print(CMD_CTX, "wrote %zu bytes from file %s to flash bank %u"
+ command_print(CMD, "wrote %zu bytes from file %s to flash bank %u"
" at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
length, CMD_ARGV[1], bank->bank_number, offset,
duration_elapsed(&bench), duration_kbps(&bench, length));
}
if (duration_measure(&bench) == ERROR_OK)
- command_print(CMD_CTX, "wrote %zd bytes to file %s from flash bank %u"
+ command_print(CMD, "wrote %zd bytes to file %s from flash bank %u"
" at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
written, CMD_ARGV[1], p->bank_number, offset,
duration_elapsed(&bench), duration_kbps(&bench, written));
}
if (duration_measure(&bench) == ERROR_OK)
- command_print(CMD_CTX, "read %zd bytes from file %s and flash bank %u"
+ command_print(CMD, "read %zd bytes from file %s and flash bank %u"
" at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
length, CMD_ARGV[1], p->bank_number, offset,
duration_elapsed(&bench), duration_kbps(&bench, length));
differ = memcmp(buffer_file, buffer_flash, length);
- command_print(CMD_CTX, "contents %s", differ ? "differ" : "match");
+ command_print(CMD, "contents %s", differ ? "differ" : "match");
if (differ) {
uint32_t t;
int diffs = 0;
for (t = 0; t < length; t++) {
if (buffer_flash[t] == buffer_file[t])
continue;
- command_print(CMD_CTX, "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
+ command_print(CMD, "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
diffs, t + offset, buffer_flash[t], buffer_file[t]);
if (diffs++ >= 127) {
- command_print(CMD_CTX, "More than 128 errors, the rest are not printed.");
+ command_print(CMD, "More than 128 errors, the rest are not printed.");
break;
}
keep_alive();
COMMAND_PARSE_NUMBER(u8, CMD_ARGV[1], p->default_padded_value);
- command_print(CMD_CTX, "Default padded value set to 0x%" PRIx8 " for flash bank %u", \
+ command_print(CMD, "Default padded value set to 0x%" PRIx8 " for flash bank %u", \
p->default_padded_value, p->bank_number);
return retval;
int start = (0 == strncmp(CMD_ARGV[i], "0x", 2)) ? 2 : 0;
if (1 != sscanf(&CMD_ARGV[i][start], "%" SCNx32 "", &flashKeys[i])) {
- command_print(CMD_CTX, "could not process flash key %s",
+ command_print(CMD, "could not process flash key %s",
CMD_ARGV[i]);
LOG_ERROR("could not process flash key %s", CMD_ARGV[i]);
return ERROR_COMMAND_SYNTAX_ERROR;
keysSet = 1;
} else if (CMD_ARGC != 0) {
- command_print(CMD_CTX, "tms470 flash_keyset <key0> <key1> <key2> <key3>");
+ command_print(CMD, "tms470 flash_keyset <key0> <key1> <key2> <key3>");
return ERROR_COMMAND_SYNTAX_ERROR;
}
if (keysSet) {
- command_print(CMD_CTX,
+ command_print(CMD,
"using flash keys 0x%08" PRIx32 ", 0x%08" PRIx32 ", 0x%08" PRIx32 ", 0x%08" PRIx32 "",
flashKeys[0],
flashKeys[1],
flashKeys[2],
flashKeys[3]);
} else
- command_print(CMD_CTX, "flash keys not set");
+ command_print(CMD, "flash keys not set");
return ERROR_OK;
}
if (oscMHz <= 0) {
LOG_ERROR("osc_megahertz must be positive and non-zero!");
- command_print(CMD_CTX, "osc_megahertz must be positive and non-zero!");
+ command_print(CMD, "osc_megahertz must be positive and non-zero!");
oscMHz = 12;
return ERROR_COMMAND_SYNTAX_ERROR;
}
- command_print(CMD_CTX, "osc_megahertz=%d", oscMHz);
+ command_print(CMD, "osc_megahertz=%d", oscMHz);
return ERROR_OK;
}
plldis = plldis ? 1 : 0;
}
- command_print(CMD_CTX, "plldis=%d", plldis);
+ command_print(CMD, "plldis=%d", plldis);
return ERROR_OK;
}
fb->pw_set = true;
- command_print(CMD_CTX, "XMC4xxx flash passwords set to:\n");
- command_print(CMD_CTX, "-0x%08"PRIx32"\n", fb->pw1);
- command_print(CMD_CTX, "-0x%08"PRIx32"\n", fb->pw2);
+ command_print(CMD, "XMC4xxx flash passwords set to:\n");
+ command_print(CMD, "-0x%08"PRIx32"\n", fb->pw1);
+ command_print(CMD, "-0x%08"PRIx32"\n", fb->pw2);
return ERROR_OK;
}
const char *sep, *name;
int retval = CALL_COMMAND_HANDLER(handle_hello_args, &sep, &name);
if (ERROR_OK == retval)
- command_print(CMD_CTX, "Greetings%s%s!", sep, name);
+ command_print(CMD, "Greetings%s%s!", sep, name);
return retval;
}
context->output_handler(context, data);
}
-void command_print_sameline(struct command_context *context, const char *format, ...)
+void command_print_sameline(struct command_invocation *cmd, const char *format, ...)
{
char *string;
va_end(ap);
}
-void command_print(struct command_context *context, const char *format, ...)
+void command_print(struct command_invocation *cmd, const char *format, ...)
{
char *string;
*/
void command_done(struct command_context *context);
-void command_print(struct command_context *context, const char *format, ...)
+void command_print(struct command_invocation *cmd, const char *format, ...)
__attribute__ ((format (PRINTF_ATTRIBUTE_FORMAT, 2, 3)));
-void command_print_sameline(struct command_context *context, const char *format, ...)
+void command_print_sameline(struct command_invocation *cmd, const char *format, ...)
__attribute__ ((format (PRINTF_ATTRIBUTE_FORMAT, 2, 3)));
int command_run_line(struct command_context *context, char *line);
int command_run_linef(struct command_context *context, const char *format, ...)
do { \
int retval_macro_tmp = parse_ ## type(in, &(out)); \
if (ERROR_OK != retval_macro_tmp) { \
- command_print(CMD_CTX, stringify(out) \
+ command_print(CMD, stringify(out) \
" option value ('%s') is not valid", in); \
return retval_macro_tmp; \
} \
bool value; \
int retval_macro_tmp = command_parse_bool_arg(in, &value); \
if (ERROR_OK != retval_macro_tmp) { \
- command_print(CMD_CTX, stringify(out) \
+ command_print(CMD, stringify(out) \
" option value ('%s') is not valid", in); \
- command_print(CMD_CTX, " choices are '%s' or '%s'", \
+ command_print(CMD, " choices are '%s' or '%s'", \
on, off); \
return retval_macro_tmp; \
} \
int retval = load_file(CMD_ARGV[0], &data, &len);
if (retval == ERROR_OK) {
- command_print(CMD_CTX, "%s", data);
+ command_print(CMD, "%s", data);
free(data);
} else
- command_print(CMD_CTX, "%s not found", CMD_ARGV[0]);
+ command_print(CMD, "%s not found", CMD_ARGV[0]);
return ERROR_OK;
}
info = mallinfo();
if (prev > 0)
- command_print(CMD_CTX, "Diff: %d", prev - info.fordblks);
+ command_print(CMD, "Diff: %d", prev - info.fordblks);
prev = info.fordblks;
- command_print(CMD_CTX, "Available ram: %d", info.fordblks);
+ command_print(CMD, "Available ram: %d", info.fordblks);
return ERROR_OK;
}
if (retval != ERROR_OK)
break;
- command_print(CMD_CTX, "%zu", len - pos);
+ command_print(CMD, "%zu", len - pos);
pos += chunk;
}
if (retval == ERROR_OK)
- command_print(CMD_CTX, "Copied %s to %s", CMD_ARGV[0], CMD_ARGV[1]);
+ command_print(CMD, "Copied %s to %s", CMD_ARGV[0], CMD_ARGV[1]);
else
- command_print(CMD_CTX, "copy failed");
+ command_print(CMD, "copy failed");
if (data != NULL)
free(data);
} else if (CMD_ARGC > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX, "debug_level: %i", debug_level);
+ command_print(CMD, "debug_level: %i", debug_level);
return ERROR_OK;
}
if (strcmp(CMD_NAME, "interface_list") == 0 && CMD_ARGC > 0)
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX, "The following debug interfaces are available:");
+ command_print(CMD, "The following debug interfaces are available:");
for (unsigned i = 0; NULL != jtag_interfaces[i]; i++) {
const char *name = jtag_interfaces[i]->name;
- command_print(CMD_CTX, "%u: %s", i + 1, name);
+ command_print(CMD, "%u: %s", i + 1, name);
}
return ERROR_OK;
modes[5] = "";
}
- command_print(CMD_CTX, "%s %s%s%s%s%s",
+ command_print(CMD, "%s %s%s%s%s%s",
modes[0], modes[1],
modes[2], modes[3], modes[4], modes[5]);
jtag_set_nsrst_delay(delay);
}
- command_print(CMD_CTX, "adapter_nsrst_delay: %u", jtag_get_nsrst_delay());
+ command_print(CMD, "adapter_nsrst_delay: %u", jtag_get_nsrst_delay());
return ERROR_OK;
}
jtag_set_nsrst_assert_width(width);
}
- command_print(CMD_CTX, "adapter_nsrst_assert_width: %u", jtag_get_nsrst_assert_width());
+ command_print(CMD, "adapter_nsrst_assert_width: %u", jtag_get_nsrst_assert_width());
return ERROR_OK;
}
return retval;
if (cur_speed)
- command_print(CMD_CTX, "adapter speed: %d kHz", cur_speed);
+ command_print(CMD, "adapter speed: %d kHz", cur_speed);
else
- command_print(CMD_CTX, "adapter speed: RCLK - adaptive");
+ command_print(CMD, "adapter speed: RCLK - adaptive");
return retval;
}
if (CMD_ARGC == 1)
jtag_usb_set_location(CMD_ARGV[0]);
- command_print(CMD_CTX, "adapter usb location: %s", jtag_usb_get_location());
+ command_print(CMD, "adapter usb location: %s", jtag_usb_get_location());
return ERROR_OK;
}
{
LOG_DEBUG("aice_handle_aice_info_command");
- command_print(CMD_CTX, "Description: %s", param.device_desc);
- command_print(CMD_CTX, "Serial number: %s", param.serial);
+ command_print(CMD, "Description: %s", param.device_desc);
+ command_print(CMD, "Serial number: %s", param.serial);
if (strncmp(aice_port->name, "aice_pipe", 9) == 0)
- command_print(CMD_CTX, "Adapter: %s", param.adapter_name);
+ command_print(CMD, "Adapter: %s", param.adapter_name);
return ERROR_OK;
}
aice_scan_jtag_chain();
tap = jtag_all_taps();
- command_print(CMD_CTX,
+ command_print(CMD,
" TapName Enabled IdCode Expected IrLen IrCap IrMask");
- command_print(CMD_CTX,
+ command_print(CMD,
"-- ------------------- -------- ---------- ---------- ----- ----- ------");
while (tap) {
expected = buf_get_u32(tap->expected, 0, tap->ir_length);
expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
- command_print(CMD_CTX,
+ command_print(CMD,
"%2d %-18s %c 0x%08x %s %5d 0x%02x 0x%02x",
tap->abs_chain_position,
tap->dotted_name,
if (tap->ignore_version)
expected_id[2] = '*';
- command_print(CMD_CTX,
+ command_print(CMD,
" %s",
expected_id);
}
}
}
- command_print(CMD_CTX, "parport port = %u", amt_jtagaccel_port);
+ command_print(CMD, "parport port = %u", amt_jtagaccel_port);
return ERROR_OK;
}
COMMAND_HANDLER(amt_jtagaccel_handle_rtck_command)
{
if (CMD_ARGC == 0) {
- command_print(CMD_CTX,
+ command_print(CMD,
"amt_jtagaccel RTCK feature %s",
(rtck_enabled) ? "enabled" : "disabled");
return ERROR_OK;
return ERROR_COMMAND_SYNTAX_ERROR;
}
- command_print(CMD_CTX,
+ command_print(CMD,
"BCM2835 GPIO config: tck = %d, tms = %d, tdi = %d, tdo = %d",
tck_gpio, tms_gpio, tdi_gpio, tdo_gpio);
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tck_gpio);
- command_print(CMD_CTX, "BCM2835 GPIO config: tck = %d", tck_gpio);
+ command_print(CMD, "BCM2835 GPIO config: tck = %d", tck_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tms_gpio);
- command_print(CMD_CTX, "BCM2835 GPIO config: tms = %d", tms_gpio);
+ command_print(CMD, "BCM2835 GPIO config: tms = %d", tms_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdo_gpio);
- command_print(CMD_CTX, "BCM2835 GPIO config: tdo = %d", tdo_gpio);
+ command_print(CMD, "BCM2835 GPIO config: tdo = %d", tdo_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdi_gpio);
- command_print(CMD_CTX, "BCM2835 GPIO config: tdi = %d", tdi_gpio);
+ command_print(CMD, "BCM2835 GPIO config: tdi = %d", tdi_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], srst_gpio);
- command_print(CMD_CTX, "BCM2835 GPIO config: srst = %d", srst_gpio);
+ command_print(CMD, "BCM2835 GPIO config: srst = %d", srst_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], trst_gpio);
- command_print(CMD_CTX, "BCM2835 GPIO config: trst = %d", trst_gpio);
+ command_print(CMD, "BCM2835 GPIO config: trst = %d", trst_gpio);
return ERROR_OK;
}
return ERROR_COMMAND_SYNTAX_ERROR;
}
- command_print(CMD_CTX,
+ command_print(CMD,
"BCM2835 GPIO nums: swclk = %d, swdio = %d",
swclk_gpio, swdio_gpio);
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swclk_gpio);
- command_print(CMD_CTX, "BCM2835 num: swclk = %d", swclk_gpio);
+ command_print(CMD, "BCM2835 num: swclk = %d", swclk_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swdio_gpio);
- command_print(CMD_CTX, "BCM2835 num: swdio = %d", swdio_gpio);
+ command_print(CMD, "BCM2835 num: swdio = %d", swdio_gpio);
return ERROR_OK;
}
if (tdo_gpio < 0)
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX,
+ command_print(CMD,
"FT232R nums: TCK = %d %s, TMS = %d %s, TDI = %d %s, TDO = %d %s",
tck_gpio, ft232r_bit_number_to_name(tck_gpio),
tms_gpio, ft232r_bit_number_to_name(tms_gpio),
if (tck_gpio < 0)
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX,
+ command_print(CMD,
"FT232R num: TCK = %d %s", tck_gpio, ft232r_bit_number_to_name(tck_gpio));
return ERROR_OK;
if (tms_gpio < 0)
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX,
+ command_print(CMD,
"FT232R num: TMS = %d %s", tms_gpio, ft232r_bit_number_to_name(tms_gpio));
return ERROR_OK;
if (tdo_gpio < 0)
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX,
+ command_print(CMD,
"FT232R num: TDO = %d %s", tdo_gpio, ft232r_bit_number_to_name(tdo_gpio));
return ERROR_OK;
if (tdi_gpio < 0)
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX,
+ command_print(CMD,
"FT232R num: TDI = %d %s", tdi_gpio, ft232r_bit_number_to_name(tdi_gpio));
return ERROR_OK;
if (ntrst_gpio < 0)
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX,
+ command_print(CMD,
"FT232R num: TRST = %d %s", ntrst_gpio, ft232r_bit_number_to_name(ntrst_gpio));
return ERROR_OK;
if (nsysrst_gpio < 0)
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX,
+ command_print(CMD,
"FT232R num: SRST = %d %s", nsysrst_gpio, ft232r_bit_number_to_name(nsysrst_gpio));
return ERROR_OK;
else if (CMD_ARGC != 0)
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX,
+ command_print(CMD,
"FT232R restore serial: 0x%04X (%s)",
ft232r_restore_bitmode, ft232r_restore_bitmode == 0xFFFF ? "disabled" : "enabled");
}
n = Jim_Nvp_value2name_simple(nvp_ftdi_jtag_modes, ftdi_jtag_mode);
- command_print(CMD_CTX, "ftdi samples TDO on %s edge of TCK", n->name);
+ command_print(CMD, "ftdi samples TDO on %s edge of TCK", n->name);
return ERROR_OK;
}
}
}
- command_print(CMD_CTX, "parport port = %u", gw16012_port);
+ command_print(CMD, "parport port = %u", gw16012_port);
return ERROR_OK;
}
return ERROR_COMMAND_SYNTAX_ERROR;
}
- command_print(CMD_CTX,
+ command_print(CMD,
"imx_gpio GPIO config: tck = %d, tms = %d, tdi = %d, tdo = %d",
tck_gpio, tms_gpio, tdi_gpio, tdo_gpio);
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tck_gpio);
- command_print(CMD_CTX, "imx_gpio GPIO config: tck = %d", tck_gpio);
+ command_print(CMD, "imx_gpio GPIO config: tck = %d", tck_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tms_gpio);
- command_print(CMD_CTX, "imx_gpio GPIO config: tms = %d", tms_gpio);
+ command_print(CMD, "imx_gpio GPIO config: tms = %d", tms_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdo_gpio);
- command_print(CMD_CTX, "imx_gpio GPIO config: tdo = %d", tdo_gpio);
+ command_print(CMD, "imx_gpio GPIO config: tdo = %d", tdo_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdi_gpio);
- command_print(CMD_CTX, "imx_gpio GPIO config: tdi = %d", tdi_gpio);
+ command_print(CMD, "imx_gpio GPIO config: tdi = %d", tdi_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], srst_gpio);
- command_print(CMD_CTX, "imx_gpio GPIO config: srst = %d", srst_gpio);
+ command_print(CMD, "imx_gpio GPIO config: srst = %d", srst_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], trst_gpio);
- command_print(CMD_CTX, "imx_gpio GPIO config: trst = %d", trst_gpio);
+ command_print(CMD, "imx_gpio GPIO config: trst = %d", trst_gpio);
return ERROR_OK;
}
return ERROR_COMMAND_SYNTAX_ERROR;
}
- command_print(CMD_CTX,
+ command_print(CMD,
"imx_gpio GPIO nums: swclk = %d, swdio = %d",
swclk_gpio, swdio_gpio);
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swclk_gpio);
- command_print(CMD_CTX, "imx_gpio num: swclk = %d", swclk_gpio);
+ command_print(CMD, "imx_gpio num: swclk = %d", swclk_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swdio_gpio);
- command_print(CMD_CTX, "imx_gpio num: swdio = %d", swdio_gpio);
+ command_print(CMD, "imx_gpio num: swdio = %d", swdio_gpio);
return ERROR_OK;
}
int tmp;
if (CMD_ARGC != 1) {
- command_print(CMD_CTX, "Need exactly one argument for jlink usb.");
+ command_print(CMD, "Need exactly one argument for jlink usb.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
if (sscanf(CMD_ARGV[0], "%i", &tmp) != 1) {
- command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]);
+ command_print(CMD, "Invalid USB address: %s.", CMD_ARGV[0]);
return ERROR_FAIL;
}
if (tmp < JAYLINK_USB_ADDRESS_0 || tmp > JAYLINK_USB_ADDRESS_3) {
- command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]);
+ command_print(CMD, "Invalid USB address: %s.", CMD_ARGV[0]);
return ERROR_FAIL;
}
int ret;
if (CMD_ARGC != 1) {
- command_print(CMD_CTX, "Need exactly one argument for jlink serial.");
+ command_print(CMD, "Need exactly one argument for jlink serial.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
ret = jaylink_parse_serial_number(CMD_ARGV[0], &serial_number);
if (ret == JAYLINK_ERR) {
- command_print(CMD_CTX, "Invalid serial number: %s.", CMD_ARGV[0]);
+ command_print(CMD, "Invalid serial number: %s.", CMD_ARGV[0]);
return ERROR_FAIL;
} else if (ret != JAYLINK_OK) {
- command_print(CMD_CTX, "jaylink_parse_serial_number() failed: %s.",
+ command_print(CMD, "jaylink_parse_serial_number() failed: %s.",
jaylink_strerror(ret));
return ERROR_FAIL;
}
ret = jaylink_get_hardware_status(devh, &status);
if (ret != JAYLINK_OK) {
- command_print(CMD_CTX, "jaylink_get_hardware_status() failed: %s.",
+ command_print(CMD, "jaylink_get_hardware_status() failed: %s.",
jaylink_strerror(ret));
return ERROR_FAIL;
}
- command_print(CMD_CTX, "VTarget = %u.%03u V",
+ command_print(CMD, "VTarget = %u.%03u V",
status.target_voltage / 1000, status.target_voltage % 1000);
- command_print(CMD_CTX, "TCK = %u TDI = %u TDO = %u TMS = %u SRST = %u "
+ command_print(CMD, "TCK = %u TDI = %u TDO = %u TMS = %u SRST = %u "
"TRST = %u", status.tck, status.tdi, status.tdo, status.tms,
status.tres, status.trst);
if (status.target_voltage < 1500)
- command_print(CMD_CTX, "Target voltage too low. Check target power.");
+ command_print(CMD, "Target voltage too low. Check target power.");
return ERROR_OK;
}
uint32_t tmp;
if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_FREE_MEMORY)) {
- command_print(CMD_CTX, "Retrieval of free memory is not supported by "
+ command_print(CMD, "Retrieval of free memory is not supported by "
"the device.");
return ERROR_OK;
}
ret = jaylink_get_free_memory(devh, &tmp);
if (ret != JAYLINK_OK) {
- command_print(CMD_CTX, "jaylink_get_free_memory() failed: %s.",
+ command_print(CMD, "jaylink_get_free_memory() failed: %s.",
jaylink_strerror(ret));
return ERROR_FAIL;
}
- command_print(CMD_CTX, "Device has %u bytes of free memory.", tmp);
+ command_print(CMD, "Device has %u bytes of free memory.", tmp);
return ERROR_OK;
}
return ERROR_FAIL;
}
- command_print(CMD_CTX, "JTAG command version: %i", version);
+ command_print(CMD, "JTAG command version: %i", version);
} else if (CMD_ARGC == 1) {
if (sscanf(CMD_ARGV[0], "%i", &tmp) != 1) {
- command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
+ command_print(CMD, "Invalid argument: %s.", CMD_ARGV[0]);
return ERROR_COMMAND_SYNTAX_ERROR;
}
jtag_command_version = JAYLINK_JTAG_VERSION_3;
break;
default:
- command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
+ command_print(CMD, "Invalid argument: %s.", CMD_ARGV[0]);
return ERROR_COMMAND_SYNTAX_ERROR;
}
} else {
- command_print(CMD_CTX, "Need exactly one argument for jlink jtag.");
+ command_print(CMD, "Need exactly one argument for jlink jtag.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
int enable;
if (CMD_ARGC != 1) {
- command_print(CMD_CTX, "Need exactly one argument for jlink "
+ command_print(CMD, "Need exactly one argument for jlink "
"targetpower.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER)) {
- command_print(CMD_CTX, "Target power supply is not supported by the "
+ command_print(CMD, "Target power supply is not supported by the "
"device.");
return ERROR_OK;
}
} else if (!strcmp(CMD_ARGV[0], "off")) {
enable = false;
} else {
- command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
+ command_print(CMD, "Invalid argument: %s.", CMD_ARGV[0]);
return ERROR_FAIL;
}
ret = jaylink_set_target_power(devh, enable);
if (ret != JAYLINK_OK) {
- command_print(CMD_CTX, "jaylink_set_target_power() failed: %s.",
+ command_print(CMD, "jaylink_set_target_power() failed: %s.",
jaylink_strerror(ret));
return ERROR_FAIL;
}
static void show_config_usb_address(struct command_invocation *cmd)
{
if (config.usb_address != tmp_config.usb_address)
- command_print(cmd->ctx, "USB address: %u [%u]", config.usb_address,
+ command_print(cmd, "USB address: %u [%u]", config.usb_address,
tmp_config.usb_address);
else
- command_print(cmd->ctx, "USB address: %u", config.usb_address);
+ command_print(cmd, "USB address: %u", config.usb_address);
}
static void show_config_ip_address(struct command_invocation *cmd)
{
if (!memcmp(config.ip_address, tmp_config.ip_address, 4))
- command_print(cmd->ctx, "IP address: %d.%d.%d.%d",
+ command_print(cmd, "IP address: %d.%d.%d.%d",
config.ip_address[3], config.ip_address[2],
config.ip_address[1], config.ip_address[0]);
else
- command_print(cmd->ctx, "IP address: %d.%d.%d.%d [%d.%d.%d.%d]",
+ command_print(cmd, "IP address: %d.%d.%d.%d [%d.%d.%d.%d]",
config.ip_address[3], config.ip_address[2],
config.ip_address[1], config.ip_address[0],
tmp_config.ip_address[3], tmp_config.ip_address[2],
tmp_config.ip_address[1], tmp_config.ip_address[0]);
if (!memcmp(config.subnet_mask, tmp_config.subnet_mask, 4))
- command_print(cmd->ctx, "Subnet mask: %d.%d.%d.%d",
+ command_print(cmd, "Subnet mask: %d.%d.%d.%d",
config.subnet_mask[3], config.subnet_mask[2],
config.subnet_mask[1], config.subnet_mask[0]);
else
- command_print(cmd->ctx, "Subnet mask: %d.%d.%d.%d [%d.%d.%d.%d]",
+ command_print(cmd, "Subnet mask: %d.%d.%d.%d [%d.%d.%d.%d]",
config.subnet_mask[3], config.subnet_mask[2],
config.subnet_mask[1], config.subnet_mask[0],
tmp_config.subnet_mask[3], tmp_config.subnet_mask[2],
static void show_config_mac_address(struct command_invocation *cmd)
{
if (!memcmp(config.mac_address, tmp_config.mac_address, 6))
- command_print(cmd->ctx, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x",
+ command_print(cmd, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x",
config.mac_address[5], config.mac_address[4],
config.mac_address[3], config.mac_address[2],
config.mac_address[1], config.mac_address[0]);
else
- command_print(cmd->ctx, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x "
+ command_print(cmd, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x "
"[%.02x:%.02x:%.02x:%.02x:%.02x:%.02x]",
config.mac_address[5], config.mac_address[4],
config.mac_address[3], config.mac_address[2],
current_target_power = "on";
if (config.target_power != tmp_config.target_power)
- command_print(cmd->ctx, "Target power supply: %s [%s]", target_power,
+ command_print(cmd, "Target power supply: %s [%s]", target_power,
current_target_power);
else
- command_print(cmd->ctx, "Target power supply: %s", target_power);
+ command_print(cmd, "Target power supply: %s", target_power);
}
static void show_config(struct command_invocation *cmd)
{
- command_print(cmd->ctx, "J-Link device configuration:");
+ command_print(cmd, "J-Link device configuration:");
show_config_usb_address(cmd);
uint8_t tmp;
if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
- command_print(CMD_CTX, "Reading configuration is not supported by the "
+ command_print(CMD, "Reading configuration is not supported by the "
"device.");
return ERROR_OK;
}
show_config_usb_address(CMD);
} else if (CMD_ARGC == 1) {
if (sscanf(CMD_ARGV[0], "%" SCNd8, &tmp) != 1) {
- command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]);
+ command_print(CMD, "Invalid USB address: %s.", CMD_ARGV[0]);
return ERROR_FAIL;
}
if (tmp > JAYLINK_USB_ADDRESS_3) {
- command_print(CMD_CTX, "Invalid USB address: %u.", tmp);
+ command_print(CMD, "Invalid USB address: %u.", tmp);
return ERROR_FAIL;
}
tmp_config.usb_address = tmp;
} else {
- command_print(CMD_CTX, "Need exactly one argument for jlink config "
+ command_print(CMD, "Need exactly one argument for jlink config "
"usb.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
int enable;
if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
- command_print(CMD_CTX, "Reading configuration is not supported by the "
+ command_print(CMD, "Reading configuration is not supported by the "
"device.");
return ERROR_OK;
}
if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER)) {
- command_print(CMD_CTX, "Target power supply is not supported by the "
+ command_print(CMD, "Target power supply is not supported by the "
"device.");
return ERROR_OK;
}
} else if (!strcmp(CMD_ARGV[0], "off")) {
enable = false;
} else {
- command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
+ command_print(CMD, "Invalid argument: %s.", CMD_ARGV[0]);
return ERROR_FAIL;
}
tmp_config.target_power = enable;
} else {
- command_print(CMD_CTX, "Need exactly one argument for jlink config "
+ command_print(CMD, "Need exactly one argument for jlink config "
"targetpower.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
const char *str;
if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
- command_print(CMD_CTX, "Reading configuration is not supported by the "
+ command_print(CMD, "Reading configuration is not supported by the "
"device.");
return ERROR_OK;
}
if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) {
- command_print(CMD_CTX, "Ethernet connectivity is not supported by the "
+ command_print(CMD, "Ethernet connectivity is not supported by the "
"device.");
return ERROR_OK;
}
if ((strlen(str) != 17) || (str[2] != ':' || str[5] != ':' || \
str[8] != ':' || str[11] != ':' || str[14] != ':')) {
- command_print(CMD_CTX, "Invalid MAC address format.");
+ command_print(CMD, "Invalid MAC address format.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
}
if (!(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5])) {
- command_print(CMD_CTX, "Invalid MAC address: zero address.");
+ command_print(CMD, "Invalid MAC address: zero address.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
if (!(0x01 & addr[0])) {
- command_print(CMD_CTX, "Invalid MAC address: multicast address.");
+ command_print(CMD, "Invalid MAC address: multicast address.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
memcpy(tmp_config.mac_address, addr, sizeof(addr));
} else {
- command_print(CMD_CTX, "Need exactly one argument for jlink config "
+ command_print(CMD, "Need exactly one argument for jlink config "
" mac.");
return ERROR_COMMAND_SYNTAX_ERROR;
}
uint8_t subnet_bits = 24;
if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
- command_print(CMD_CTX, "Reading configuration is not supported by the "
+ command_print(CMD, "Reading configuration is not supported by the "
"device.");
return ERROR_OK;
}
if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) {
- command_print(CMD_CTX, "Ethernet connectivity is not supported by the "
+ command_print(CMD, "Ethernet connectivity is not supported by the "
"device.");
return ERROR_OK;
}
int ret;
if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
- command_print(CMD_CTX, "Reading configuration is not supported by the "
+ command_print(CMD, "Reading configuration is not supported by the "
"device.");
return ERROR_OK;
}
if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_WRITE_CONFIG)) {
- command_print(CMD_CTX, "Writing configuration is not supported by the "
+ command_print(CMD, "Writing configuration is not supported by the "
"device.");
return ERROR_OK;
}
if (!memcmp(&config, &tmp_config, sizeof(struct device_config))) {
- command_print(CMD_CTX, "Operation not performed due to no changes in "
+ command_print(CMD, "Operation not performed due to no changes in "
"the configuration.");
return ERROR_OK;
}
}
memcpy(&tmp_config, &config, sizeof(struct device_config));
- command_print(CMD_CTX, "The new device configuration applies after power "
+ command_print(CMD, "The new device configuration applies after power "
"cycling the J-Link device.");
return ERROR_OK;
COMMAND_HANDLER(jlink_handle_config_command)
{
if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
- command_print(CMD_CTX, "Device doesn't support reading configuration.");
+ command_print(CMD, "Device doesn't support reading configuration.");
return ERROR_OK;
}
return ERROR_FAIL;
}
- command_print(CMD_CTX, "%s", buf + length);
+ command_print(CMD, "%s", buf + length);
free(buf);
return ERROR_OK;
{
switch (CMD_ARGC) {
case 0:
- command_print(CMD_CTX, "opendous hw jtag %i", opendous_hw_jtag_version);
+ command_print(CMD, "opendous hw jtag %i", opendous_hw_jtag_version);
break;
case 1: {
}
}
- command_print(CMD_CTX, "parport port = 0x%" PRIx16 "", parport_port);
+ command_print(CMD, "parport port = 0x%" PRIx16 "", parport_port);
return ERROR_OK;
}
}
}
- command_print(CMD_CTX, "parport toggling time = %" PRIu32 " ns",
+ command_print(CMD, "parport toggling time = %" PRIu32 " ns",
parport_toggling_time_ns);
return ERROR_OK;
return ERROR_COMMAND_SYNTAX_ERROR;
}
- command_print(CMD_CTX,
+ command_print(CMD,
"SysfsGPIO nums: tck = %d, tms = %d, tdi = %d, tdo = %d",
tck_gpio, tms_gpio, tdi_gpio, tdo_gpio);
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tck_gpio);
- command_print(CMD_CTX, "SysfsGPIO num: tck = %d", tck_gpio);
+ command_print(CMD, "SysfsGPIO num: tck = %d", tck_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tms_gpio);
- command_print(CMD_CTX, "SysfsGPIO num: tms = %d", tms_gpio);
+ command_print(CMD, "SysfsGPIO num: tms = %d", tms_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdo_gpio);
- command_print(CMD_CTX, "SysfsGPIO num: tdo = %d", tdo_gpio);
+ command_print(CMD, "SysfsGPIO num: tdo = %d", tdo_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdi_gpio);
- command_print(CMD_CTX, "SysfsGPIO num: tdi = %d", tdi_gpio);
+ command_print(CMD, "SysfsGPIO num: tdi = %d", tdi_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], srst_gpio);
- command_print(CMD_CTX, "SysfsGPIO num: srst = %d", srst_gpio);
+ command_print(CMD, "SysfsGPIO num: srst = %d", srst_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], trst_gpio);
- command_print(CMD_CTX, "SysfsGPIO num: trst = %d", trst_gpio);
+ command_print(CMD, "SysfsGPIO num: trst = %d", trst_gpio);
return ERROR_OK;
}
return ERROR_COMMAND_SYNTAX_ERROR;
}
- command_print(CMD_CTX,
+ command_print(CMD,
"SysfsGPIO nums: swclk = %d, swdio = %d",
swclk_gpio, swdio_gpio);
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swclk_gpio);
- command_print(CMD_CTX, "SysfsGPIO num: swclk = %d", swclk_gpio);
+ command_print(CMD, "SysfsGPIO num: swclk = %d", swclk_gpio);
return ERROR_OK;
}
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swdio_gpio);
- command_print(CMD_CTX, "SysfsGPIO num: swdio = %d", swdio_gpio);
+ command_print(CMD, "SysfsGPIO num: swdio = %d", swdio_gpio);
return ERROR_OK;
}
char expected_id[12];
tap = jtag_all_taps();
- command_print(CMD_CTX,
+ command_print(CMD,
" TapName Enabled IdCode Expected IrLen IrCap IrMask");
- command_print(CMD_CTX,
+ command_print(CMD,
"-- ------------------- -------- ---------- ---------- ----- ----- ------");
while (tap) {
expected = buf_get_u32(tap->expected, 0, tap->ir_length);
expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
- command_print(CMD_CTX,
+ command_print(CMD,
"%2d %-18s %c 0x%08x %s %5d 0x%02x 0x%02x",
tap->abs_chain_position,
tap->dotted_name,
if (tap->ignore_version)
expected_id[2] = '*';
- command_print(CMD_CTX,
+ command_print(CMD,
" %s",
expected_id);
}
jtag_set_ntrst_delay(delay);
}
- command_print(CMD_CTX, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
+ command_print(CMD, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
return ERROR_OK;
}
jtag_set_ntrst_assert_width(delay);
}
- command_print(CMD_CTX, "jtag_ntrst_assert_width: %u", jtag_get_ntrst_assert_width());
+ command_print(CMD, "jtag_ntrst_assert_width: %u", jtag_get_ntrst_assert_width());
return ERROR_OK;
}
return retval;
if (cur_khz)
- command_print(CMD_CTX, "RCLK not supported - fallback to %d kHz", cur_khz);
+ command_print(CMD, "RCLK not supported - fallback to %d kHz", cur_khz);
else
- command_print(CMD_CTX, "RCLK - adaptive");
+ command_print(CMD, "RCLK - adaptive");
return retval;
}
tap = jtag_tap_by_string(CMD_ARGV[i*2]);
if (tap == NULL) {
free(fields);
- command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[i*2]);
+ command_print(CMD, "Tap: %s unknown", CMD_ARGV[i*2]);
return ERROR_FAIL;
}
}
const char *status = jtag_will_verify_capture_ir() ? "enabled" : "disabled";
- command_print(CMD_CTX, "verify Capture-IR is %s", status);
+ command_print(CMD, "verify Capture-IR is %s", status);
return ERROR_OK;
}
}
const char *status = jtag_will_verify() ? "enabled" : "disabled";
- command_print(CMD_CTX, "verify jtag capture is %s", status);
+ command_print(CMD, "verify jtag capture is %s", status);
return ERROR_OK;
}
tap_use_new_tms_table(use_new_table);
}
- command_print(CMD_CTX, "tms sequence is %s",
+ command_print(CMD, "tms sequence is %s",
tap_uses_new_tms_table() ? "short" : "long");
return ERROR_OK;
int i = 0;
if (!pld_devices) {
- command_print(CMD_CTX, "no pld devices configured");
+ command_print(CMD, "no pld devices configured");
return ERROR_OK;
}
for (p = pld_devices; p; p = p->next)
- command_print(CMD_CTX, "#%i: %s", i++, p->driver->name);
+ command_print(CMD, "#%i: %s", i++, p->driver->name);
return ERROR_OK;
}
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], dev_id);
p = get_pld_device_by_num(dev_id);
if (!p) {
- command_print(CMD_CTX, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+ command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
return ERROR_OK;
}
retval = p->driver->load(p, CMD_ARGV[1]);
if (retval != ERROR_OK) {
- command_print(CMD_CTX, "failed loading file %s to pld device %u",
+ command_print(CMD, "failed loading file %s to pld device %u",
CMD_ARGV[1], dev_id);
switch (retval) {
}
gettimeofday(&end, NULL);
timeval_subtract(&duration, &end, &start);
- command_print(CMD_CTX, "loaded file %s to pld device %u in %jis %jius",
+ command_print(CMD, "loaded file %s to pld device %u in %jis %jius",
CMD_ARGV[1], dev_id,
(intmax_t)duration.tv_sec, (intmax_t)duration.tv_usec);
}
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], dev_id);
device = get_pld_device_by_num(dev_id);
if (!device) {
- command_print(CMD_CTX, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
+ command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]);
return ERROR_OK;
}
virtex2_read_stat(device, &status);
- command_print(CMD_CTX, "virtex2 status register: 0x%8.8" PRIx32 "", status);
+ command_print(CMD, "virtex2 status register: 0x%8.8" PRIx32 "", status);
return ERROR_OK;
}
tap = jtag_tap_by_string(CMD_ARGV[1]);
if (tap == NULL) {
- command_print(CMD_CTX, "Tap: %s does not exist", CMD_ARGV[1]);
+ command_print(CMD, "Tap: %s does not exist", CMD_ARGV[1]);
return ERROR_OK;
}
return ERROR_COMMAND_SYNTAX_ERROR;
if (current_gdb_connection == NULL) {
- command_print(CMD_CTX,
+ command_print(CMD,
"gdb_sync command can only be run from within gdb using \"monitor gdb_sync\"");
return ERROR_FAIL;
}
{
switch (CMD_ARGC) {
case 0:
- command_print(CMD_CTX, "bindto name: %s", bindto_name);
+ command_print(CMD, "bindto name: %s", bindto_name);
break;
case 1:
free(bindto_name);
{
switch (CMD_ARGC) {
case 0:
- command_print(CMD_CTX, "%d", *out);
+ command_print(CMD, "%d", *out);
break;
case 1:
{
{
switch (CMD_ARGC) {
case 0:
- command_print(CMD_CTX, "%s", *out);
+ command_print(CMD, "%s", *out);
break;
case 1:
{
if (strcmp(CMD_ARGV[i], "-tap") == 0) {
tap = jtag_tap_by_string(CMD_ARGV[i+1]);
if (!tap) {
- command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[i+1]);
+ command_print(CMD, "Tap: %s unknown", CMD_ARGV[i+1]);
return ERROR_FAIL;
}
i++;
svf_fd = fopen(CMD_ARGV[i], "r");
if (svf_fd == NULL) {
int err = errno;
- command_print(CMD_CTX, "open(\"%s\"): %s", CMD_ARGV[i], strerror(err));
+ command_print(CMD, "open(\"%s\"): %s", CMD_ARGV[i], strerror(err));
/* no need to free anything now */
return ERROR_COMMAND_SYNTAX_ERROR;
} else
time_measure_m = time_measure_s / 60;
time_measure_s %= 60;
if (time_measure_ms < 1000)
- command_print(CMD_CTX,
+ command_print(CMD,
"\r\nTime used: %dm%ds%" PRId64 "ms ",
time_measure_m,
time_measure_s,
svf_free_xxd_para(&svf_para.sir_para);
if (ERROR_OK == ret)
- command_print(CMD_CTX,
+ command_print(CMD,
"svf file programmed %s for %d commands with %d errors",
(svf_ignore_error > 1) ? "unsuccessfully" : "successfully",
command_num,
(svf_ignore_error > 1) ? (svf_ignore_error - 1) : 0);
else
- command_print(CMD_CTX, "svf file programmed failed");
+ command_print(CMD, "svf file programmed failed");
svf_ignore_error = 0;
return ret;
}
n = Jim_Nvp_value2name_simple(nvp_maskisr_modes, aarch64->isrmasking_mode);
- command_print(CMD_CTX, "aarch64 interrupt mask %s", n->name);
+ command_print(CMD, "aarch64 interrupt mask %s", n->name);
return ERROR_OK;
}
struct arm720t_common *arm720t)
{
if (arm720t->common_magic != ARM720T_COMMON_MAGIC) {
- command_print(cmd->ctx, "target is not an ARM720");
+ command_print(cmd, "target is not an ARM720");
return ERROR_TARGET_INVALID;
}
return ERROR_OK;
return retval;
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+ command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
return ERROR_OK;
}
uint32_t value;
retval = arm720t_read_cp15(target, opcode, &value);
if (retval != ERROR_OK) {
- command_print(CMD_CTX, "couldn't access cp15 with opcode 0x%8.8" PRIx32 "", opcode);
+ command_print(CMD, "couldn't access cp15 with opcode 0x%8.8" PRIx32 "", opcode);
return ERROR_OK;
}
if (retval != ERROR_OK)
return retval;
- command_print(CMD_CTX, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value);
+ command_print(CMD, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value);
} else if (CMD_ARGC == 2) {
uint32_t value;
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
retval = arm720t_write_cp15(target, opcode, value);
if (retval != ERROR_OK) {
- command_print(CMD_CTX, "couldn't access cp15 with opcode 0x%8.8" PRIx32 "", opcode);
+ command_print(CMD, "couldn't access cp15 with opcode 0x%8.8" PRIx32 "", opcode);
return ERROR_OK;
}
- command_print(CMD_CTX, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value);
+ command_print(CMD, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value);
}
}
struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
if (!is_arm7_9(arm7_9)) {
- command_print(CMD_CTX, "current target isn't an ARM7/ARM9 target");
+ command_print(CMD, "current target isn't an ARM7/ARM9 target");
return ERROR_TARGET_INVALID;
}
if (CMD_ARGC > 0)
COMMAND_PARSE_ENABLE(CMD_ARGV[0], arm7_9->use_dbgrq);
- command_print(CMD_CTX,
+ command_print(CMD,
"use of EmbeddedICE dbgrq instead of breakpoint for target halt %s",
(arm7_9->use_dbgrq) ? "enabled" : "disabled");
struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
if (!is_arm7_9(arm7_9)) {
- command_print(CMD_CTX, "current target isn't an ARM7/ARM9 target");
+ command_print(CMD, "current target isn't an ARM7/ARM9 target");
return ERROR_TARGET_INVALID;
}
if (CMD_ARGC > 0)
COMMAND_PARSE_ENABLE(CMD_ARGV[0], arm7_9->fast_memory_access);
- command_print(CMD_CTX,
+ command_print(CMD,
"fast memory access is %s",
(arm7_9->fast_memory_access) ? "enabled" : "disabled");
struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
if (!is_arm7_9(arm7_9)) {
- command_print(CMD_CTX, "current target isn't an ARM7/ARM9 target");
+ command_print(CMD, "current target isn't an ARM7/ARM9 target");
return ERROR_TARGET_INVALID;
}
if (CMD_ARGC > 0)
COMMAND_PARSE_ENABLE(CMD_ARGV[0], arm7_9->dcc_downloads);
- command_print(CMD_CTX,
+ command_print(CMD,
"dcc downloads are %s",
(arm7_9->dcc_downloads) ? "enabled" : "disabled");
struct arm920t_common *arm920t)
{
if (arm920t->common_magic != ARM920T_COMMON_MAGIC) {
- command_print(cmd->ctx, arm920_not);
+ command_print(cmd, arm920_not);
return ERROR_TARGET_INVALID;
}
/* restore CP15 MMU and Cache settings */
arm920t_write_cp15_physical(target, CP15PHYS_CTRL, cp15_ctrl_saved);
- command_print(CMD_CTX, "cache content successfully output to %s",
+ command_print(CMD, "cache content successfully output to %s",
CMD_ARGV[0]);
fclose(output);
(i_tlb[i].cam & 0x20) ? "(valid)" : "(invalid)");
}
- command_print(CMD_CTX, "mmu content successfully output to %s",
+ command_print(CMD, "mmu content successfully output to %s",
CMD_ARGV[0]);
fclose(output);
return retval;
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for "
+ command_print(CMD, "target must be stopped for "
"\"%s\" command", CMD_NAME);
return ERROR_OK;
}
uint32_t value;
retval = arm920t_read_cp15_physical(target, address, &value);
if (retval != ERROR_OK) {
- command_print(CMD_CTX,
+ command_print(CMD,
"couldn't access reg %i", address);
return ERROR_OK;
}
if (retval != ERROR_OK)
return retval;
- command_print(CMD_CTX, "%i: %8.8" PRIx32,
+ command_print(CMD, "%i: %8.8" PRIx32,
address, value);
} else if (CMD_ARGC == 2) {
uint32_t value;
retval = arm920t_write_cp15_physical(target,
address, value);
if (retval != ERROR_OK) {
- command_print(CMD_CTX,
+ command_print(CMD,
"couldn't access reg %i", address);
/* REVISIT why lie? "return retval"? */
return ERROR_OK;
}
- command_print(CMD_CTX, "%i: %8.8" PRIx32,
+ command_print(CMD, "%i: %8.8" PRIx32,
address, value);
}
}
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for "
+ command_print(CMD, "target must be stopped for "
"\"%s\" command", CMD_NAME);
return ERROR_OK;
}
retval = arm920t_read_cp15_interpreted(target,
opcode, 0x0, &value);
if (retval != ERROR_OK) {
- command_print(CMD_CTX,
+ command_print(CMD,
"couldn't execute %8.8" PRIx32,
opcode);
/* REVISIT why lie? "return retval"? */
return ERROR_OK;
}
- command_print(CMD_CTX, "%8.8" PRIx32 ": %8.8" PRIx32,
+ command_print(CMD, "%8.8" PRIx32 ": %8.8" PRIx32,
opcode, value);
} else if (CMD_ARGC == 2) {
uint32_t value;
retval = arm920t_write_cp15_interpreted(target,
opcode, value, 0);
if (retval != ERROR_OK) {
- command_print(CMD_CTX,
+ command_print(CMD,
"couldn't execute %8.8" PRIx32,
opcode);
/* REVISIT why lie? "return retval"? */
return ERROR_OK;
}
- command_print(CMD_CTX, "%8.8" PRIx32 ": %8.8" PRIx32,
+ command_print(CMD, "%8.8" PRIx32 ": %8.8" PRIx32,
opcode, value);
} else if (CMD_ARGC == 3) {
uint32_t value;
retval = arm920t_write_cp15_interpreted(target,
opcode, value, address);
if (retval != ERROR_OK) {
- command_print(CMD_CTX,
+ command_print(CMD,
"couldn't execute %8.8" PRIx32, opcode);
/* REVISIT why lie? "return retval"? */
return ERROR_OK;
}
- command_print(CMD_CTX, "%8.8" PRIx32 ": %8.8" PRIx32
+ command_print(CMD, "%8.8" PRIx32 ": %8.8" PRIx32
" %8.8" PRIx32, opcode, value, address);
}
} else
struct arm926ejs_common *arm926)
{
if (arm926->common_magic != ARM926EJS_COMMON_MAGIC) {
- command_print(cmd->ctx, arm926_not);
+ command_print(cmd, arm926_not);
return ERROR_TARGET_INVALID;
}
return ERROR_OK;
struct arm946e_common *arm946e)
{
if (arm946e->common_magic != ARM946E_COMMON_MAGIC) {
- command_print(cmd->ctx, "target is not an ARM946");
+ command_print(cmd, "target is not an ARM946");
return ERROR_TARGET_INVALID;
}
return ERROR_OK;
return retval;
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+ command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
return ERROR_TARGET_NOT_HALTED;
}
uint32_t value;
retval = arm946e_read_cp15(target, address, &value);
if (retval != ERROR_OK) {
- command_print(CMD_CTX, "%s cp15 reg %" PRIi32 " access failed", target_name(target), address);
+ command_print(CMD, "%s cp15 reg %" PRIi32 " access failed", target_name(target), address);
return retval;
}
retval = jtag_execute_queue();
return retval;
/* Return value in hex format */
- command_print(CMD_CTX, "0x%08" PRIx32, value);
+ command_print(CMD, "0x%08" PRIx32, value);
} else if (CMD_ARGC == 2) {
uint32_t value;
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
retval = arm946e_write_cp15(target, address, value);
if (retval != ERROR_OK) {
- command_print(CMD_CTX, "%s cp15 reg %" PRIi32 " access failed", target_name(target), address);
+ command_print(CMD, "%s cp15 reg %" PRIi32 " access failed", target_name(target), address);
return retval;
}
if (address == CP15_CTL)
return retval;
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+ command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
return ERROR_TARGET_NOT_HALTED;
}
bool bena = ((arm946e->cp15_control_reg & (icache ? CP15_CTL_ICACHE : CP15_CTL_DCACHE)) != 0)
&& (arm946e->cp15_control_reg & 0x1);
if (csize == 0)
- command_print(CMD_CTX, "%s-cache absent", icache ? "I" : "D");
+ command_print(CMD, "%s-cache absent", icache ? "I" : "D");
else
- command_print(CMD_CTX, "%s-cache size: %" PRIu32 "K, %s",
+ command_print(CMD, "%s-cache size: %" PRIu32 "K, %s",
icache ? "I" : "D", csize, bena ? "enabled" : "disabled");
return ERROR_OK;
}
/* Do not invalidate or change state, if cache is absent */
if (csize == 0) {
- command_print(CMD_CTX, "%s-cache absent, '%s' operation undefined", icache ? "I" : "D", CMD_ARGV[0]);
+ command_print(CMD, "%s-cache absent, '%s' operation undefined", icache ? "I" : "D", CMD_ARGV[0]);
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
}
struct arm966e_common *arm966e)
{
if (arm966e->common_magic != ARM966E_COMMON_MAGIC) {
- command_print(cmd->ctx, "target is not an ARM966");
+ command_print(cmd, "target is not an ARM966");
return ERROR_TARGET_INVALID;
}
return ERROR_OK;
return retval;
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+ command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
return ERROR_OK;
}
uint32_t value;
retval = arm966e_read_cp15(target, address, &value);
if (retval != ERROR_OK) {
- command_print(CMD_CTX,
+ command_print(CMD,
"couldn't access reg %" PRIi32,
address);
return ERROR_OK;
if (retval != ERROR_OK)
return retval;
- command_print(CMD_CTX, "%" PRIi32 ": %8.8" PRIx32,
+ command_print(CMD, "%" PRIi32 ": %8.8" PRIx32,
address, value);
} else if (CMD_ARGC == 2) {
uint32_t value;
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
retval = arm966e_write_cp15(target, address, value);
if (retval != ERROR_OK) {
- command_print(CMD_CTX,
+ command_print(CMD,
"couldn't access reg %" PRIi32,
address);
return ERROR_OK;
}
- command_print(CMD_CTX, "%" PRIi32 ": %8.8" PRIx32,
+ command_print(CMD, "%" PRIi32 ": %8.8" PRIx32,
address, value);
}
}
/* it's uncommon, but some ARM7 chips can support this */
if (arm7_9->common_magic != ARM7_9_COMMON_MAGIC
|| !arm7_9->has_vector_catch) {
- command_print(CMD_CTX, "target doesn't have EmbeddedICE "
+ command_print(CMD, "target doesn't have EmbeddedICE "
"with vector_catch");
return ERROR_TARGET_INVALID;
}
/* complain if vector wasn't found */
if (!arm9tdmi_vectors[j].name) {
- command_print(CMD_CTX, "vector '%s' not found, leaving current setting unchanged", CMD_ARGV[i]);
+ command_print(CMD, "vector '%s' not found, leaving current setting unchanged", CMD_ARGV[i]);
/* reread current setting */
vector_catch_value = buf_get_u32(
/* output current settings */
for (unsigned i = 0; arm9tdmi_vectors[i].name; i++) {
- command_print(CMD_CTX, "%s: %s", arm9tdmi_vectors[i].name,
+ command_print(CMD, "%s: %s", arm9tdmi_vectors[i].name,
(vector_catch_value & arm9tdmi_vectors[i].value)
? "catch" : "don't catch");
}
char tabs[16] = "";
if (depth > 16) {
- command_print(cmd->ctx, "\tTables too deep");
+ command_print(cmd, "\tTables too deep");
return ERROR_FAIL;
}
snprintf(tabs, sizeof(tabs), "[L%02d] ", depth);
uint32_t base_addr = dbgbase & 0xFFFFF000;
- command_print(cmd->ctx, "\t\tComponent base address 0x%08" PRIx32, base_addr);
+ command_print(cmd, "\t\tComponent base address 0x%08" PRIx32, base_addr);
retval = dap_read_part_id(ap, base_addr, &cid, &pid);
if (retval != ERROR_OK) {
- command_print(cmd->ctx, "\t\tCan't read component, the corresponding core might be turned off");
+ command_print(cmd, "\t\tCan't read component, the corresponding core might be turned off");
return ERROR_OK; /* Don't abort recursion */
}
if (!is_dap_cid_ok(cid)) {
- command_print(cmd->ctx, "\t\tInvalid CID 0x%08" PRIx32, cid);
+ command_print(cmd, "\t\tInvalid CID 0x%08" PRIx32, cid);
return ERROR_OK; /* Don't abort recursion */
}
/* component may take multiple 4K pages */
uint32_t size = (pid >> 36) & 0xf;
if (size > 0)
- command_print(cmd->ctx, "\t\tStart address 0x%08" PRIx32, (uint32_t)(base_addr - 0x1000 * size));
+ command_print(cmd, "\t\tStart address 0x%08" PRIx32, (uint32_t)(base_addr - 0x1000 * size));
- command_print(cmd->ctx, "\t\tPeripheral ID 0x%010" PRIx64, pid);
+ command_print(cmd, "\t\tPeripheral ID 0x%010" PRIx64, pid);
uint8_t class = (cid >> 12) & 0xf;
uint16_t part_num = pid & 0xfff;
if (designer_id & 0x80) {
/* JEP106 code */
- command_print(cmd->ctx, "\t\tDesigner is 0x%03" PRIx16 ", %s",
+ command_print(cmd, "\t\tDesigner is 0x%03" PRIx16 ", %s",
designer_id, jep106_manufacturer(designer_id >> 8, designer_id & 0x7f));
} else {
/* Legacy ASCII ID, clear invalid bits */
designer_id &= 0x7f;
- command_print(cmd->ctx, "\t\tDesigner ASCII code 0x%02" PRIx16 ", %s",
+ command_print(cmd, "\t\tDesigner ASCII code 0x%02" PRIx16 ", %s",
designer_id, designer_id == 0x41 ? "ARM" : "<unknown>");
}
break;
}
- command_print(cmd->ctx, "\t\tPart is 0x%" PRIx16", %s %s", part_num, type, full);
- command_print(cmd->ctx, "\t\tComponent class is 0x%" PRIx8 ", %s", class, class_description[class]);
+ command_print(cmd, "\t\tPart is 0x%" PRIx16", %s %s", part_num, type, full);
+ command_print(cmd, "\t\tComponent class is 0x%" PRIx8 ", %s", class, class_description[class]);
if (class == 1) { /* ROM Table */
uint32_t memtype;
return retval;
if (memtype & 0x01)
- command_print(cmd->ctx, "\t\tMEMTYPE system memory present on bus");
+ command_print(cmd, "\t\tMEMTYPE system memory present on bus");
else
- command_print(cmd->ctx, "\t\tMEMTYPE system memory not present: dedicated debug bus");
+ command_print(cmd, "\t\tMEMTYPE system memory not present: dedicated debug bus");
/* Read ROM table entries from base address until we get 0x00000000 or reach the reserved area */
for (uint16_t entry_offset = 0; entry_offset < 0xF00; entry_offset += 4) {
retval = mem_ap_read_atomic_u32(ap, base_addr | entry_offset, &romentry);
if (retval != ERROR_OK)
return retval;
- command_print(cmd->ctx, "\t%sROMTABLE[0x%x] = 0x%" PRIx32 "",
+ command_print(cmd, "\t%sROMTABLE[0x%x] = 0x%" PRIx32 "",
tabs, entry_offset, romentry);
if (romentry & 0x01) {
/* Recurse */
if (retval != ERROR_OK)
return retval;
} else if (romentry != 0) {
- command_print(cmd->ctx, "\t\tComponent not present");
+ command_print(cmd, "\t\tComponent not present");
} else {
- command_print(cmd->ctx, "\t%s\tEnd of ROM table", tabs);
+ command_print(cmd, "\t%s\tEnd of ROM table", tabs);
break;
}
}
}
break;
}
- command_print(cmd->ctx, "\t\tType is 0x%02" PRIx8 ", %s, %s",
+ command_print(cmd, "\t\tType is 0x%02" PRIx8 ", %s, %s",
(uint8_t)(devtype & 0xff),
major, subtype);
/* REVISIT also show 0xfc8 DevId */
if (retval != ERROR_OK)
return retval;
- command_print(cmd->ctx, "AP ID register 0x%8.8" PRIx32, apid);
+ command_print(cmd, "AP ID register 0x%8.8" PRIx32, apid);
if (apid == 0) {
- command_print(cmd->ctx, "No AP found at this ap 0x%x", ap->ap_num);
+ command_print(cmd, "No AP found at this ap 0x%x", ap->ap_num);
return ERROR_FAIL;
}
switch (apid & (IDR_JEP106 | IDR_TYPE)) {
case IDR_JEP106_ARM | AP_TYPE_JTAG_AP:
- command_print(cmd->ctx, "\tType is JTAG-AP");
+ command_print(cmd, "\tType is JTAG-AP");
break;
case IDR_JEP106_ARM | AP_TYPE_AHB_AP:
- command_print(cmd->ctx, "\tType is MEM-AP AHB");
+ command_print(cmd, "\tType is MEM-AP AHB");
break;
case IDR_JEP106_ARM | AP_TYPE_APB_AP:
- command_print(cmd->ctx, "\tType is MEM-AP APB");
+ command_print(cmd, "\tType is MEM-AP APB");
break;
case IDR_JEP106_ARM | AP_TYPE_AXI_AP:
- command_print(cmd->ctx, "\tType is MEM-AP AXI");
+ command_print(cmd, "\tType is MEM-AP AXI");
break;
default:
- command_print(cmd->ctx, "\tUnknown AP type");
+ command_print(cmd, "\tUnknown AP type");
break;
}
*/
mem_ap = (apid & IDR_CLASS) == AP_CLASS_MEM_AP;
if (mem_ap) {
- command_print(cmd->ctx, "MEM-AP BASE 0x%8.8" PRIx32, dbgbase);
+ command_print(cmd, "MEM-AP BASE 0x%8.8" PRIx32, dbgbase);
if (dbgbase == 0xFFFFFFFF || (dbgbase & 0x3) == 0x2) {
- command_print(cmd->ctx, "\tNo ROM table present");
+ command_print(cmd, "\tNo ROM table present");
} else {
if (dbgbase & 0x01)
- command_print(cmd->ctx, "\tValid ROM table present");
+ command_print(cmd, "\tValid ROM table present");
else
- command_print(cmd->ctx, "\tROM table in legacy format");
+ command_print(cmd, "\tROM table in legacy format");
dap_rom_display(cmd, ap, dbgbase & 0xFFFFF000, 0);
}
if (retval != ERROR_OK)
return retval;
- command_print(CMD_CTX, "0x%8.8" PRIx32, baseaddr);
+ command_print(CMD, "0x%8.8" PRIx32, baseaddr);
return retval;
}
}
dap->ap[dap->apsel].memaccess_tck = memaccess_tck;
- command_print(CMD_CTX, "memory bus access delay set to %" PRIi32 " tck",
+ command_print(CMD, "memory bus access delay set to %" PRIi32 " tck",
dap->ap[dap->apsel].memaccess_tck);
return ERROR_OK;
switch (CMD_ARGC) {
case 0:
- command_print(CMD_CTX, "%" PRIi32, dap->apsel);
+ command_print(CMD, "%" PRIi32, dap->apsel);
return ERROR_OK;
case 1:
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
switch (CMD_ARGC) {
case 0:
- command_print(CMD_CTX, "ap %" PRIi32 " selected, csw 0x%8.8" PRIx32,
+ command_print(CMD, "ap %" PRIi32 " selected, csw 0x%8.8" PRIx32,
dap->apsel, apcsw);
return ERROR_OK;
case 1:
if (retval != ERROR_OK)
return retval;
- command_print(CMD_CTX, "0x%8.8" PRIx32, apid);
+ command_print(CMD, "0x%8.8" PRIx32, apid);
return retval;
}
return retval;
if (CMD_ARGC == 2)
- command_print(CMD_CTX, "0x%08" PRIx32, value);
+ command_print(CMD, "0x%08" PRIx32, value);
return retval;
}
return retval;
if (CMD_ARGC == 1)
- command_print(CMD_CTX, "0x%08" PRIx32, value);
+ command_print(CMD, "0x%08" PRIx32, value);
return retval;
}
return ERROR_COMMAND_SYNTAX_ERROR;
}
dap->ti_be_32_quirks = enable;
- command_print(CMD_CTX, "TI BE-32 quirks mode %s",
+ command_print(CMD, "TI BE-32 quirks mode %s",
enable ? "enabled" : "disabled");
return 0;
return JIM_ERR;
for (int i = 0; i < (int)ARRAY_SIZE(cti_names); i++)
- command_print(CMD_CTX, "%8.8s (0x%04"PRIx32") 0x%08"PRIx32,
+ command_print(CMD, "%8.8s (0x%04"PRIx32") 0x%08"PRIx32,
cti_names[i].label, cti_names[i].offset, *cti_names[i].p_val);
return JIM_OK;
if (retval != ERROR_OK)
return retval;
- command_print(CMD_CTX, "0x%08"PRIx32, value);
+ command_print(CMD, "0x%08"PRIx32, value);
return ERROR_OK;
}
struct reg *regs;
if (!is_arm(arm)) {
- command_print(CMD_CTX, "current target isn't an ARM");
+ command_print(CMD, "current target isn't an ARM");
return ERROR_FAIL;
}
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "error: target must be halted for register accesses");
+ command_print(CMD, "error: target must be halted for register accesses");
return ERROR_FAIL;
}
if (arm->core_type != ARM_MODE_ANY) {
- command_print(CMD_CTX,
+ command_print(CMD,
"Microcontroller Profile not supported - use standard reg cmd");
return ERROR_OK;
}
}
if (!arm->full_context) {
- command_print(CMD_CTX, "error: target doesn't support %s",
+ command_print(CMD, "error: target doesn't support %s",
CMD_NAME);
return ERROR_FAIL;
}
shadow = "shadow ";
break;
}
- command_print(CMD_CTX, "%s%s mode %sregisters",
+ command_print(CMD, "%s%s mode %sregisters",
sep, name, shadow);
/* display N rows of up to 4 registers each */
"%8s: %8.8" PRIx32 " ",
reg->name, value);
}
- command_print(CMD_CTX, "%s", output);
+ command_print(CMD, "%s", output);
}
}
struct arm *arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "current target isn't an ARM");
+ command_print(CMD, "current target isn't an ARM");
return ERROR_FAIL;
}
if (arm->core_type == ARM_MODE_THREAD) {
/* armv7m not supported */
- command_print(CMD_CTX, "Unsupported Command");
+ command_print(CMD, "Unsupported Command");
return ERROR_OK;
}
arm->core_state = ARM_STATE_THUMB;
}
- command_print(CMD_CTX, "core state: %s", arm_state_strings[arm->core_state]);
+ command_print(CMD, "core state: %s", arm_state_strings[arm->core_state]);
return ERROR_OK;
}
int thumb = 0;
if (!is_arm(arm)) {
- command_print(CMD_CTX, "current target isn't an ARM");
+ command_print(CMD, "current target isn't an ARM");
return ERROR_FAIL;
}
COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);
if (address & 0x01) {
if (!thumb) {
- command_print(CMD_CTX, "Disassemble as Thumb");
+ command_print(CMD, "Disassemble as Thumb");
thumb = 1;
}
address &= ~1;
if (retval != ERROR_OK)
break;
}
- command_print(CMD_CTX, "%s", cur_instruction.text);
+ command_print(CMD, "%s", cur_instruction.text);
address += cur_instruction.instruction_size;
}
int armv4_5_handle_cache_info_command(struct command_invocation *cmd, struct armv4_5_cache_common *armv4_5_cache)
{
if (armv4_5_cache->ctype == -1) {
- command_print(cmd->ctx, "cache not yet identified");
+ command_print(cmd, "cache not yet identified");
return ERROR_OK;
}
- command_print(cmd->ctx, "cache type: 0x%1.1x, %s", armv4_5_cache->ctype,
+ command_print(cmd, "cache type: 0x%1.1x, %s", armv4_5_cache->ctype,
(armv4_5_cache->separate) ? "separate caches" : "unified cache");
- command_print(cmd->ctx, "D-Cache: linelen %i, associativity %i, nsets %i, cachesize 0x%x",
+ command_print(cmd, "D-Cache: linelen %i, associativity %i, nsets %i, cachesize 0x%x",
armv4_5_cache->d_u_size.linelen,
armv4_5_cache->d_u_size.associativity,
armv4_5_cache->d_u_size.nsets,
armv4_5_cache->d_u_size.cachesize);
- command_print(cmd->ctx, "I-Cache: linelen %i, associativity %i, nsets %i, cachesize 0x%x",
+ command_print(cmd, "I-Cache: linelen %i, associativity %i, nsets %i, cachesize 0x%x",
armv4_5_cache->i_size.linelen,
armv4_5_cache->i_size.associativity,
armv4_5_cache->i_size.nsets,
if (CMD_ARGC != 2)
return ERROR_COMMAND_SYNTAX_ERROR;
- /* command_print(CMD_CTX, "%s %s", CMD_ARGV[0], CMD_ARGV[1]); */
+ /* command_print(CMD, "%s %s", CMD_ARGV[0], CMD_ARGV[1]); */
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], base);
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], way);
int cl;
if (armv7a_cache->info == -1) {
- command_print(cmd->ctx, "cache not yet identified");
+ command_print(cmd, "cache not yet identified");
return ERROR_OK;
}
struct armv7a_arch_cache *arch = &(armv7a_cache->arch[cl]);
if (arch->ctype & 1) {
- command_print(cmd->ctx,
+ command_print(cmd,
"L%d I-Cache: linelen %" PRIi32
", associativity %" PRIi32
", nsets %" PRIi32
}
if (arch->ctype >= 2) {
- command_print(cmd->ctx,
+ command_print(cmd,
"L%d D-Cache: linelen %" PRIi32
", associativity %" PRIi32
", nsets %" PRIi32
}
if (l2x_cache != NULL)
- command_print(cmd->ctx, "Outer unified cache Base Address 0x%" PRIx32 ", %" PRId32 " ways",
+ command_print(cmd, "Outer unified cache Base Address 0x%" PRIx32 ", %" PRId32 " ways",
l2x_cache->base, l2x_cache->way);
return ERROR_OK;
struct armv7a_common *armv7a = target_to_armv7a(target);
if (CMD_ARGC == 0) {
- command_print(CMD_CTX, "auto cache is %s",
+ command_print(CMD, "auto cache is %s",
armv7a->armv7a_mmu.armv7a_cache.auto_cache_enabled ? "enabled" : "disabled");
return ERROR_OK;
}
(armv7a_cache->outer_cache);
if (armv7a_cache->info == -1) {
- command_print(cmd->ctx, "cache not yet identified");
+ command_print(cmd, "cache not yet identified");
return ERROR_OK;
}
- command_print(cmd->ctx,
+ command_print(cmd,
"L2 unified cache Base Address 0x%" PRIx32 ", %" PRId32 " ways",
l2x_cache->base, l2x_cache->way);
if (CMD_ARGC != 2)
return ERROR_COMMAND_SYNTAX_ERROR;
- /* command_print(CMD_CTX, "%s %s", CMD_ARGV[0], CMD_ARGV[1]); */
+ /* command_print(CMD, "%s %s", CMD_ARGV[0], CMD_ARGV[1]); */
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], base);
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], way);
return ERROR_FAIL;
}
- command_print(CMD_CTX, "Exception Catch: Secure: %s, Non-Secure: %s", sec, nsec);
+ command_print(CMD, "Exception Catch: Secure: %s, Non-Secure: %s", sec, nsec);
return ERROR_OK;
}
struct armv8_cache_common *armv8_cache)
{
if (armv8_cache->info == -1) {
- command_print(cmd->ctx, "cache not yet identified");
+ command_print(cmd, "cache not yet identified");
return ERROR_OK;
}
int cl;
if (armv8_cache->info == -1) {
- command_print(cmd->ctx, "cache not yet identified");
+ command_print(cmd, "cache not yet identified");
return ERROR_OK;
}
struct armv8_arch_cache *arch = &(armv8_cache->arch[cl]);
if (arch->ctype & 1) {
- command_print(cmd->ctx,
+ command_print(cmd,
"L%d I-Cache: linelen %" PRIi32
", associativity %" PRIi32
", nsets %" PRIi32
}
if (arch->ctype >= 2) {
- command_print(cmd->ctx,
+ command_print(cmd,
"L%d D-Cache: linelen %" PRIi32
", associativity %" PRIi32
", nsets %" PRIi32
}
n = Jim_Nvp_value2name_simple(nvp_maskisr_modes, cortex_a->isrmasking_mode);
- command_print(CMD_CTX, "cortex_a interrupt mask %s", n->name);
+ command_print(CMD, "cortex_a interrupt mask %s", n->name);
return ERROR_OK;
}
}
n = Jim_Nvp_value2name_simple(nvp_dacrfixup_modes, cortex_a->dacrfixup_mode);
- command_print(CMD_CTX, "cortex_a domain access control fixup %s", n->name);
+ command_print(CMD, "cortex_a domain access control fixup %s", n->name);
return ERROR_OK;
}
struct cortex_m_common *cm)
{
if (cm->common_magic != CORTEX_M_COMMON_MAGIC) {
- command_print(cmd->ctx, "target is not a Cortex-M");
+ command_print(cmd, "target is not a Cortex-M");
return ERROR_TARGET_INVALID;
}
return ERROR_OK;
}
for (unsigned i = 0; i < ARRAY_SIZE(vec_ids); i++) {
- command_print(CMD_CTX, "%9s: %s", vec_ids[i].name,
+ command_print(CMD, "%9s: %s", vec_ids[i].name,
(demcr & vec_ids[i].mask) ? "catch" : "ignore");
}
return retval;
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+ command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
return ERROR_OK;
}
}
n = Jim_Nvp_value2name_simple(nvp_maskisr_modes, cortex_m->isrmasking_mode);
- command_print(CMD_CTX, "cortex_m interrupt mask %s", n->name);
+ command_print(CMD, "cortex_m interrupt mask %s", n->name);
return ERROR_OK;
}
break;
}
- command_print(CMD_CTX, "cortex_m reset_config %s", reset_config);
+ command_print(CMD, "cortex_m reset_config %s", reset_config);
return ERROR_OK;
}
value);
if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) {
- command_print(cmd->ctx, "%s", output);
+ command_print(cmd, "%s", output);
output_len = 0;
}
}
}
}
- command_print(CMD_CTX, "esirisc cache_arch %s", esirisc_cache_arch_name(esirisc));
+ command_print(CMD, "esirisc cache_arch %s", esirisc_cache_arch_name(esirisc));
return ERROR_OK;
}
retval = esirisc_flush_caches(target);
- command_print(CMD_CTX, "cache flush %s",
+ command_print(CMD, "cache flush %s",
(retval == ERROR_OK) ? "successful" : "failed");
return retval;
}
for (size_t i = 0; i < ARRAY_SIZE(esirisc_hwdc_masks); ++i)
- command_print(CMD_CTX, "%9s: %s", esirisc_hwdc_masks[i].name,
+ command_print(CMD, "%9s: %s", esirisc_hwdc_masks[i].name,
(esirisc->hwdc_save & esirisc_hwdc_masks[i].mask) ? "enabled" : "disabled");
return ERROR_OK;
case ESIRISC_TRACE_ID_EXECUTE:
case ESIRISC_TRACE_ID_STALL:
case ESIRISC_TRACE_ID_BRANCH:
- command_print(cmd->ctx, "%s", esirisc_trace_id_strings[id]);
+ command_print(cmd, "%s", esirisc_trace_id_strings[id]);
break;
case ESIRISC_TRACE_ID_EXTENDED: {
case ESIRISC_TRACE_EXT_ID_STOP:
case ESIRISC_TRACE_EXT_ID_WAIT:
case ESIRISC_TRACE_EXT_ID_MULTICYCLE:
- command_print(cmd->ctx, "%s", esirisc_trace_ext_id_strings[ext_id]);
+ command_print(cmd, "%s", esirisc_trace_ext_id_strings[ext_id]);
break;
case ESIRISC_TRACE_EXT_ID_ERET:
if (retval != ERROR_OK)
goto fail;
- command_print(cmd->ctx, "%s PC: 0x%" PRIx32,
+ command_print(cmd, "%s PC: 0x%" PRIx32,
esirisc_trace_ext_id_strings[ext_id], pc);
if (ext_id == ESIRISC_TRACE_EXT_ID_END_PC) {
- command_print(cmd->ctx, "--- end of trace ---");
+ command_print(cmd, "--- end of trace ---");
return ERROR_OK;
}
break;
if (retval != ERROR_OK)
goto fail;
- command_print(cmd->ctx, "%s EID: 0x%" PRIx32 ", EPC: 0x%" PRIx32,
+ command_print(cmd, "%s EID: 0x%" PRIx32 ", EPC: 0x%" PRIx32,
esirisc_trace_ext_id_strings[ext_id], eid, epc);
break;
}
if (retval != ERROR_OK)
goto fail;
- command_print(cmd->ctx, "repeats %" PRId32 " %s", count,
+ command_print(cmd, "repeats %" PRId32 " %s", count,
(count == 1) ? "time" : "times");
break;
}
case ESIRISC_TRACE_EXT_ID_END:
- command_print(cmd->ctx, "--- end of trace ---");
+ command_print(cmd, "--- end of trace ---");
return ERROR_OK;
default:
- command_print(cmd->ctx, "invalid extended trace ID: %" PRId32, ext_id);
+ command_print(cmd, "invalid extended trace ID: %" PRId32, ext_id);
return ERROR_FAIL;
}
break;
}
default:
- command_print(cmd->ctx, "invalid trace ID: %" PRId32, id);
+ command_print(cmd, "invalid trace ID: %" PRId32, id);
return ERROR_FAIL;
}
}
fail:
- command_print(cmd->ctx, "trace buffer too small");
+ command_print(cmd, "trace buffer too small");
return ERROR_BUF_TOO_SMALL;
}
break;
if (pc == end_of_trace) {
- command_print(cmd->ctx, "--- end of trace ---");
+ command_print(cmd, "--- end of trace ---");
return ERROR_OK;
}
- command_print(cmd->ctx, "PC: 0x%" PRIx32, pc);
+ command_print(cmd, "PC: 0x%" PRIx32, pc);
}
- command_print(cmd->ctx, "trace buffer too small");
+ command_print(cmd, "trace buffer too small");
return ERROR_BUF_TOO_SMALL;
}
switch (trace_info->format) {
case ESIRISC_TRACE_FORMAT_FULL:
- command_print(cmd->ctx, "--- full pipeline ---");
+ command_print(cmd, "--- full pipeline ---");
return esirisc_trace_analyze_full(cmd, buffer, size);
case ESIRISC_TRACE_FORMAT_BRANCH:
- command_print(cmd->ctx, "--- branches taken ---");
+ command_print(cmd, "--- branches taken ---");
return esirisc_trace_analyze_full(cmd, buffer, size);
case ESIRISC_TRACE_FORMAT_ICACHE:
- command_print(cmd->ctx, "--- icache misses ---");
+ command_print(cmd, "--- icache misses ---");
return esirisc_trace_analyze_simple(cmd, buffer, size);
default:
- command_print(cmd->ctx, "invalid trace format: %i", trace_info->format);
+ command_print(cmd, "invalid trace format: %i", trace_info->format);
return ERROR_FAIL;
}
}
size = esirisc_trace_buffer_size(trace_info);
buffer = calloc(1, size);
if (buffer == NULL) {
- command_print(cmd->ctx, "out of memory");
+ command_print(cmd, "out of memory");
return ERROR_FAIL;
}
buffer = calloc(1, size);
if (buffer == NULL) {
- command_print(cmd->ctx, "out of memory");
+ command_print(cmd, "out of memory");
return ERROR_FAIL;
}
retval = fileio_open(&fileio, filename, FILEIO_WRITE, FILEIO_BINARY);
if (retval != ERROR_OK) {
- command_print(cmd->ctx, "could not open dump file: %s", filename);
+ command_print(cmd, "could not open dump file: %s", filename);
return retval;
}
retval = fileio_write(fileio, size, buffer, &size_written);
if (retval == ERROR_OK)
- command_print(cmd->ctx, "trace data dumped to: %s", filename);
+ command_print(cmd, "trace data dumped to: %s", filename);
else
- command_print(cmd->ctx, "could not write dump file: %s", filename);
+ command_print(cmd, "could not write dump file: %s", filename);
fileio_close(fileio);
size = esirisc_trace_buffer_size(trace_info);
buffer = calloc(1, size);
if (buffer == NULL) {
- command_print(cmd->ctx, "out of memory");
+ command_print(cmd, "out of memory");
return ERROR_FAIL;
}
buffer = calloc(1, size);
if (buffer == NULL) {
- command_print(cmd->ctx, "out of memory");
+ command_print(cmd, "out of memory");
return ERROR_FAIL;
}
struct esirisc_common *esirisc = target_to_esirisc(target);
if (!esirisc->has_trace) {
- command_print(CMD_CTX, "target does not support trace");
+ command_print(CMD, "target does not support trace");
return ERROR_FAIL;
}
int retval = esirisc_trace_init(target);
if (retval == ERROR_OK)
- command_print(CMD_CTX, "trace initialized");
+ command_print(CMD, "trace initialized");
return retval;
}
struct esirisc_trace *trace_info = &esirisc->trace_info;
if (!esirisc->has_trace) {
- command_print(CMD_CTX, "target does not support trace");
+ command_print(CMD, "target does not support trace");
return ERROR_FAIL;
}
if (esirisc_trace_is_fifo(trace_info))
- command_print(CMD_CTX, "trace FIFO address: 0x%" TARGET_PRIxADDR,
+ command_print(CMD, "trace FIFO address: 0x%" TARGET_PRIxADDR,
trace_info->buffer_start);
else {
- command_print(CMD_CTX, "trace buffer start: 0x%" TARGET_PRIxADDR,
+ command_print(CMD, "trace buffer start: 0x%" TARGET_PRIxADDR,
trace_info->buffer_start);
- command_print(CMD_CTX, "trace buffer end: 0x%" TARGET_PRIxADDR,
+ command_print(CMD, "trace buffer end: 0x%" TARGET_PRIxADDR,
trace_info->buffer_end);
- command_print(CMD_CTX, "trace buffer will %swrap",
+ command_print(CMD, "trace buffer will %swrap",
trace_info->buffer_wrap ? "" : "not ");
}
- command_print(CMD_CTX, "flow control: %s",
+ command_print(CMD, "flow control: %s",
trace_info->flow_control ? "enabled" : "disabled");
- command_print(CMD_CTX, "trace format: %s",
+ command_print(CMD, "trace format: %s",
esirisc_trace_format_strings[trace_info->format]);
- command_print(CMD_CTX, "number of PC bits: %i", trace_info->pc_bits);
+ command_print(CMD, "number of PC bits: %i", trace_info->pc_bits);
- command_print(CMD_CTX, "start trigger: %s",
+ command_print(CMD, "start trigger: %s",
esirisc_trace_trigger_strings[trace_info->start_trigger]);
- command_print(CMD_CTX, "start data: 0x%" PRIx32, trace_info->start_data);
- command_print(CMD_CTX, "start mask: 0x%" PRIx32, trace_info->start_mask);
+ command_print(CMD, "start data: 0x%" PRIx32, trace_info->start_data);
+ command_print(CMD, "start mask: 0x%" PRIx32, trace_info->start_mask);
- command_print(CMD_CTX, "stop trigger: %s",
+ command_print(CMD, "stop trigger: %s",
esirisc_trace_trigger_strings[trace_info->stop_trigger]);
- command_print(CMD_CTX, "stop data: 0x%" PRIx32, trace_info->stop_data);
- command_print(CMD_CTX, "stop mask: 0x%" PRIx32, trace_info->stop_mask);
+ command_print(CMD, "stop data: 0x%" PRIx32, trace_info->stop_data);
+ command_print(CMD, "stop mask: 0x%" PRIx32, trace_info->stop_mask);
- command_print(CMD_CTX, "trigger delay: %s",
+ command_print(CMD, "trigger delay: %s",
esirisc_trace_delay_strings[trace_info->delay]);
- command_print(CMD_CTX, "trigger delay cycles: %i", trace_info->delay_cycles);
+ command_print(CMD, "trigger delay cycles: %i", trace_info->delay_cycles);
return ERROR_OK;
}
uint32_t status;
if (!esirisc->has_trace) {
- command_print(CMD_CTX, "target does not support trace");
+ command_print(CMD, "target does not support trace");
return ERROR_FAIL;
}
if (retval != ERROR_OK)
return retval;
- command_print(CMD_CTX, "trace is %s%s%s%s",
+ command_print(CMD, "trace is %s%s%s%s",
(status & STATUS_T) ? "started" : "stopped",
(status & STATUS_TD) ? ", disabled" : "",
(status & STATUS_W) ? ", wrapped" : "",
struct esirisc_common *esirisc = target_to_esirisc(target);
if (!esirisc->has_trace) {
- command_print(CMD_CTX, "target does not support trace");
+ command_print(CMD, "target does not support trace");
return ERROR_FAIL;
}
int retval = esirisc_trace_start(target);
if (retval == ERROR_OK)
- command_print(CMD_CTX, "trace started");
+ command_print(CMD, "trace started");
return retval;
}
struct esirisc_common *esirisc = target_to_esirisc(target);
if (!esirisc->has_trace) {
- command_print(CMD_CTX, "target does not support trace");
+ command_print(CMD, "target does not support trace");
return ERROR_FAIL;
}
int retval = esirisc_trace_stop(target);
if (retval == ERROR_OK)
- command_print(CMD_CTX, "trace stopped");
+ command_print(CMD, "trace stopped");
return retval;
}
uint32_t size;
if (!esirisc->has_trace) {
- command_print(CMD_CTX, "target does not support trace");
+ command_print(CMD, "target does not support trace");
return ERROR_FAIL;
}
* as arguments as a workaround.
*/
if (esirisc_trace_is_fifo(trace_info)) {
- command_print(CMD_CTX, "analyze from FIFO not supported");
+ command_print(CMD, "analyze from FIFO not supported");
return ERROR_FAIL;
}
uint32_t size;
if (!esirisc->has_trace) {
- command_print(CMD_CTX, "target does not support trace");
+ command_print(CMD, "target does not support trace");
return ERROR_FAIL;
}
if (CMD_ARGC == 1) {
/* also see: handle_esirisc_trace_analyze_command() */
if (esirisc_trace_is_fifo(trace_info)) {
- command_print(CMD_CTX, "dump from FIFO not supported");
+ command_print(CMD, "dump from FIFO not supported");
return ERROR_FAIL;
}
COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], pc_bits);
if (pc_bits < 1 || pc_bits > 31) {
- command_print(CMD_CTX, "invalid pc_bits: %i; must be 1..31", pc_bits);
+ command_print(CMD, "invalid pc_bits: %i; must be 1..31", pc_bits);
return ERROR_COMMAND_SYNTAX_ERROR;
}
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "ETB: '%s' isn't an ARM", CMD_ARGV[0]);
+ command_print(CMD, "ETB: '%s' isn't an ARM", CMD_ARGV[0]);
return ERROR_FAIL;
}
tap = jtag_tap_by_string(CMD_ARGV[1]);
if (tap == NULL) {
- command_print(CMD_CTX, "ETB: TAP %s does not exist", CMD_ARGV[1]);
+ command_print(CMD, "ETB: TAP %s does not exist", CMD_ARGV[1]);
return ERROR_FAIL;
}
target = get_current_target(CMD_CTX);
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "ETB: current target isn't an ARM");
+ command_print(CMD, "ETB: current target isn't an ARM");
return ERROR_FAIL;
}
etm = arm->etm;
if (!etm) {
- command_print(CMD_CTX, "ETB: target has no ETM configured");
+ command_print(CMD, "ETB: target has no ETM configured");
return ERROR_FAIL;
}
if (etm->capture_driver != &etb_capture_driver) {
- command_print(CMD_CTX, "ETB: target not using ETB");
+ command_print(CMD, "ETB: target not using ETB");
return ERROR_FAIL;
}
etb = arm->etm->capture_driver_priv;
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], new_value);
if ((new_value < 2) || (new_value > 100))
- command_print(CMD_CTX,
+ command_print(CMD,
"valid percentages are 2%% to 100%%");
else
etb->trigger_percent = (unsigned) new_value;
}
- command_print(CMD_CTX, "%d percent of tracebuffer fills after trigger",
+ command_print(CMD, "%d percent of tracebuffer fills after trigger",
etb->trigger_percent);
return ERROR_OK;
ctx->capture_driver->read_trace(ctx);
if (ctx->trace_depth == 0) {
- command_print(cmd->ctx, "Trace is empty.");
+ command_print(cmd, "Trace is empty.");
return ERROR_OK;
}
int current_pc_ok = ctx->pc_ok;
if (ctx->trace_data[ctx->pipe_index].flags & ETMV1_TRIGGER_CYCLE)
- command_print(cmd->ctx, "--- trigger ---");
+ command_print(cmd, "--- trigger ---");
/* instructions execute in IE/D or BE/D cycles */
if ((pipestat == STAT_IE) || (pipestat == STAT_ID))
next_pc = ctx->last_branch;
break;
case 0x1: /* tracing enabled */
- command_print(cmd->ctx,
+ command_print(cmd,
"--- tracing enabled at 0x%8.8" PRIx32 " ---",
ctx->last_branch);
ctx->current_pc = ctx->last_branch;
continue;
break;
case 0x2: /* trace restarted after FIFO overflow */
- command_print(cmd->ctx,
+ command_print(cmd,
"--- trace restarted after FIFO overflow at 0x%8.8" PRIx32 " ---",
ctx->last_branch);
ctx->current_pc = ctx->last_branch;
continue;
break;
case 0x3: /* exit from debug state */
- command_print(cmd->ctx,
+ command_print(cmd,
"--- exit from debug state at 0x%8.8" PRIx32 " ---",
ctx->last_branch);
ctx->current_pc = ctx->last_branch;
* we have to move on with the next trace cycle
*/
if (!current_pc_ok) {
- command_print(cmd->ctx,
+ command_print(cmd,
"--- periodic synchronization point at 0x%8.8" PRIx32 " ---",
next_pc);
ctx->current_pc = next_pc;
|| ((ctx->last_branch >= 0xffff0000) &&
(ctx->last_branch <= 0xffff0020))) {
if ((ctx->last_branch & 0xff) == 0x10)
- command_print(cmd->ctx, "data abort");
+ command_print(cmd, "data abort");
else {
- command_print(cmd->ctx,
+ command_print(cmd,
"exception vector 0x%2.2" PRIx32 "",
ctx->last_branch);
ctx->current_pc = ctx->last_branch;
ctx->ptr_ok = 1;
if (ctx->ptr_ok)
- command_print(cmd->ctx,
+ command_print(cmd,
"address: 0x%8.8" PRIx32 "",
ctx->last_ptr);
}
uint32_t data;
if (etmv1_data(ctx, 4, &data) != 0)
return ERROR_ETM_ANALYSIS_FAILED;
- command_print(cmd->ctx,
+ command_print(cmd,
"data: 0x%8.8" PRIx32 "",
data);
}
if (etmv1_data(ctx, arm_access_size(&instruction),
&data) != 0)
return ERROR_ETM_ANALYSIS_FAILED;
- command_print(cmd->ctx, "data: 0x%8.8" PRIx32 "", data);
+ command_print(cmd, "data: 0x%8.8" PRIx32 "", data);
}
}
(cycles == 1) ? "cycle" : "cycles");
}
- command_print(cmd->ctx, "%s%s%s",
+ command_print(cmd, "%s%s%s",
instruction.text,
(pipestat == STAT_IN) ? " (not executed)" : "",
cycles_text);
else if (strcmp(CMD_ARGV[0], "all") == 0)
tracemode = ETM_CTRL_TRACE_DATA | ETM_CTRL_TRACE_ADDR;
else {
- command_print(CMD_CTX, "invalid option '%s'", CMD_ARGV[0]);
+ command_print(CMD, "invalid option '%s'", CMD_ARGV[0]);
return ERROR_COMMAND_SYNTAX_ERROR;
}
tracemode |= ETM_CTRL_CONTEXTID_32;
break;
default:
- command_print(CMD_CTX, "invalid option '%s'", CMD_ARGV[1]);
+ command_print(CMD, "invalid option '%s'", CMD_ARGV[1]);
return ERROR_COMMAND_SYNTAX_ERROR;
}
struct etm_context *etm;
if (!is_arm(arm)) {
- command_print(CMD_CTX, "ETM: current target isn't an ARM");
+ command_print(CMD, "ETM: current target isn't an ARM");
return ERROR_FAIL;
}
etm = arm->etm;
if (!etm) {
- command_print(CMD_CTX, "current target doesn't have an ETM configured");
+ command_print(CMD, "current target doesn't have an ETM configured");
return ERROR_FAIL;
}
* or couldn't be written; display actual hardware state...
*/
- command_print(CMD_CTX, "current tracemode configuration:");
+ command_print(CMD, "current tracemode configuration:");
switch (tracemode & ETM_CTRL_TRACE_MASK) {
default:
- command_print(CMD_CTX, "data tracing: none");
+ command_print(CMD, "data tracing: none");
break;
case ETM_CTRL_TRACE_DATA:
- command_print(CMD_CTX, "data tracing: data only");
+ command_print(CMD, "data tracing: data only");
break;
case ETM_CTRL_TRACE_ADDR:
- command_print(CMD_CTX, "data tracing: address only");
+ command_print(CMD, "data tracing: address only");
break;
case ETM_CTRL_TRACE_DATA | ETM_CTRL_TRACE_ADDR:
- command_print(CMD_CTX, "data tracing: address and data");
+ command_print(CMD, "data tracing: address and data");
break;
}
switch (tracemode & ETM_CTRL_CONTEXTID_MASK) {
case ETM_CTRL_CONTEXTID_NONE:
- command_print(CMD_CTX, "contextid tracing: none");
+ command_print(CMD, "contextid tracing: none");
break;
case ETM_CTRL_CONTEXTID_8:
- command_print(CMD_CTX, "contextid tracing: 8 bit");
+ command_print(CMD, "contextid tracing: 8 bit");
break;
case ETM_CTRL_CONTEXTID_16:
- command_print(CMD_CTX, "contextid tracing: 16 bit");
+ command_print(CMD, "contextid tracing: 16 bit");
break;
case ETM_CTRL_CONTEXTID_32:
- command_print(CMD_CTX, "contextid tracing: 32 bit");
+ command_print(CMD, "contextid tracing: 32 bit");
break;
}
if (tracemode & ETM_CTRL_CYCLE_ACCURATE)
- command_print(CMD_CTX, "cycle-accurate tracing enabled");
+ command_print(CMD, "cycle-accurate tracing enabled");
else
- command_print(CMD_CTX, "cycle-accurate tracing disabled");
+ command_print(CMD, "cycle-accurate tracing disabled");
if (tracemode & ETM_CTRL_BRANCH_OUTPUT)
- command_print(CMD_CTX, "full branch address output enabled");
+ command_print(CMD, "full branch address output enabled");
else
- command_print(CMD_CTX, "full branch address output disabled");
+ command_print(CMD, "full branch address output disabled");
#define TRACEMODE_MASK ( \
ETM_CTRL_CONTEXTID_MASK \
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "target '%s' is '%s'; not an ARM",
+ command_print(CMD, "target '%s' is '%s'; not an ARM",
target_name(target),
target_type_name(target));
return ERROR_FAIL;
portmode |= ETM_PORT_2BIT;
break;
default:
- command_print(CMD_CTX,
+ command_print(CMD,
"unsupported ETM port width '%s'", CMD_ARGV[1]);
return ERROR_FAIL;
}
else if (strcmp("demultiplexed", CMD_ARGV[2]) == 0)
portmode |= ETM_PORT_DEMUXED;
else {
- command_print(CMD_CTX,
+ command_print(CMD,
"unsupported ETM port mode '%s', must be 'normal', 'multiplexed' or 'demultiplexed'",
CMD_ARGV[2]);
return ERROR_FAIL;
else if (strcmp("full", CMD_ARGV[3]) == 0)
portmode |= ETM_PORT_FULL_CLOCK;
else {
- command_print(CMD_CTX,
+ command_print(CMD,
"unsupported ETM port clocking '%s', must be 'full' or 'half'",
CMD_ARGV[3]);
return ERROR_FAIL;
target = get_current_target(CMD_CTX);
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "ETM: current target isn't an ARM");
+ command_print(CMD, "ETM: current target isn't an ARM");
return ERROR_FAIL;
}
etm = arm->etm;
if (!etm) {
- command_print(CMD_CTX, "current target doesn't have an ETM configured");
+ command_print(CMD, "current target doesn't have an ETM configured");
return ERROR_FAIL;
}
- command_print(CMD_CTX, "ETM v%d.%d",
+ command_print(CMD, "ETM v%d.%d",
etm->bcd_vers >> 4, etm->bcd_vers & 0xf);
- command_print(CMD_CTX, "pairs of address comparators: %i",
+ command_print(CMD, "pairs of address comparators: %i",
(int) (etm->config >> 0) & 0x0f);
- command_print(CMD_CTX, "data comparators: %i",
+ command_print(CMD, "data comparators: %i",
(int) (etm->config >> 4) & 0x0f);
- command_print(CMD_CTX, "memory map decoders: %i",
+ command_print(CMD, "memory map decoders: %i",
(int) (etm->config >> 8) & 0x1f);
- command_print(CMD_CTX, "number of counters: %i",
+ command_print(CMD, "number of counters: %i",
(int) (etm->config >> 13) & 0x07);
- command_print(CMD_CTX, "sequencer %spresent",
+ command_print(CMD, "sequencer %spresent",
(int) (etm->config & (1 << 16)) ? "" : "not ");
- command_print(CMD_CTX, "number of ext. inputs: %i",
+ command_print(CMD, "number of ext. inputs: %i",
(int) (etm->config >> 17) & 0x07);
- command_print(CMD_CTX, "number of ext. outputs: %i",
+ command_print(CMD, "number of ext. outputs: %i",
(int) (etm->config >> 20) & 0x07);
- command_print(CMD_CTX, "FIFO full %spresent",
+ command_print(CMD, "FIFO full %spresent",
(int) (etm->config & (1 << 23)) ? "" : "not ");
if (etm->bcd_vers < 0x20)
- command_print(CMD_CTX, "protocol version: %i",
+ command_print(CMD, "protocol version: %i",
(int) (etm->config >> 28) & 0x07);
else {
- command_print(CMD_CTX,
+ command_print(CMD,
"coprocessor and memory access %ssupported",
(etm->config & (1 << 26)) ? "" : "not ");
- command_print(CMD_CTX, "trace start/stop %spresent",
+ command_print(CMD, "trace start/stop %spresent",
(etm->config & (1 << 26)) ? "" : "not ");
- command_print(CMD_CTX, "number of context comparators: %i",
+ command_print(CMD, "number of context comparators: %i",
(int) (etm->config >> 24) & 0x03);
}
LOG_ERROR("Illegal max_port_size");
return ERROR_FAIL;
}
- command_print(CMD_CTX, "max. port size: %i", max_port_size);
+ command_print(CMD, "max. port size: %i", max_port_size);
if (etm->bcd_vers < 0x30) {
- command_print(CMD_CTX, "half-rate clocking %ssupported",
+ command_print(CMD, "half-rate clocking %ssupported",
(config & (1 << 3)) ? "" : "not ");
- command_print(CMD_CTX, "full-rate clocking %ssupported",
+ command_print(CMD, "full-rate clocking %ssupported",
(config & (1 << 4)) ? "" : "not ");
- command_print(CMD_CTX, "normal trace format %ssupported",
+ command_print(CMD, "normal trace format %ssupported",
(config & (1 << 5)) ? "" : "not ");
- command_print(CMD_CTX, "multiplex trace format %ssupported",
+ command_print(CMD, "multiplex trace format %ssupported",
(config & (1 << 6)) ? "" : "not ");
- command_print(CMD_CTX, "demultiplex trace format %ssupported",
+ command_print(CMD, "demultiplex trace format %ssupported",
(config & (1 << 7)) ? "" : "not ");
} else {
/* REVISIT show which size and format are selected ... */
- command_print(CMD_CTX, "current port size %ssupported",
+ command_print(CMD, "current port size %ssupported",
(config & (1 << 10)) ? "" : "not ");
- command_print(CMD_CTX, "current trace format %ssupported",
+ command_print(CMD, "current trace format %ssupported",
(config & (1 << 11)) ? "" : "not ");
}
if (etm->bcd_vers >= 0x21)
- command_print(CMD_CTX, "fetch comparisons %ssupported",
+ command_print(CMD, "fetch comparisons %ssupported",
(config & (1 << 17)) ? "not " : "");
- command_print(CMD_CTX, "FIFO full %ssupported",
+ command_print(CMD, "FIFO full %ssupported",
(config & (1 << 8)) ? "" : "not ");
return ERROR_OK;
target = get_current_target(CMD_CTX);
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "ETM: current target isn't an ARM");
+ command_print(CMD, "ETM: current target isn't an ARM");
return ERROR_FAIL;
}
etm = arm->etm;
if (!etm) {
- command_print(CMD_CTX, "current target doesn't have an ETM configured");
+ command_print(CMD, "current target doesn't have an ETM configured");
return ERROR_FAIL;
}
if (etm_get_reg(reg) == ERROR_OK) {
unsigned s = buf_get_u32(reg->value, 0, reg->size);
- command_print(CMD_CTX, "etm: %s%s%s%s",
+ command_print(CMD, "etm: %s%s%s%s",
/* bit(1) == progbit */
(etm->bcd_vers >= 0x12)
? ((s & (1 << 1))
/* Trace Port Driver status */
trace_status = etm->capture_driver->status(etm);
if (trace_status == TRACE_IDLE)
- command_print(CMD_CTX, "%s: idle", etm->capture_driver->name);
+ command_print(CMD, "%s: idle", etm->capture_driver->name);
else {
static char *completed = " completed";
static char *running = " is running";
static char *overflowed = ", overflowed";
static char *triggered = ", triggered";
- command_print(CMD_CTX, "%s: trace collection%s%s%s",
+ command_print(CMD, "%s: trace collection%s%s%s",
etm->capture_driver->name,
(trace_status & TRACE_RUNNING) ? running : completed,
(trace_status & TRACE_OVERFLOWED) ? overflowed : "",
(trace_status & TRACE_TRIGGERED) ? triggered : "");
if (etm->trace_depth > 0) {
- command_print(CMD_CTX, "%i frames of trace data read",
+ command_print(CMD, "%i frames of trace data read",
(int)(etm->trace_depth));
}
}
target = get_current_target(CMD_CTX);
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "ETM: current target isn't an ARM");
+ command_print(CMD, "ETM: current target isn't an ARM");
return ERROR_FAIL;
}
etm_ctx = arm->etm;
if (!etm_ctx) {
- command_print(CMD_CTX, "current target doesn't have an ETM configured");
+ command_print(CMD, "current target doesn't have an ETM configured");
return ERROR_FAIL;
}
if (etm_ctx->image) {
image_close(etm_ctx->image);
free(etm_ctx->image);
- command_print(CMD_CTX, "previously loaded image found and closed");
+ command_print(CMD, "previously loaded image found and closed");
}
etm_ctx->image = malloc(sizeof(struct image));
target = get_current_target(CMD_CTX);
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "ETM: current target isn't an ARM");
+ command_print(CMD, "ETM: current target isn't an ARM");
return ERROR_FAIL;
}
etm_ctx = arm->etm;
if (!etm_ctx) {
- command_print(CMD_CTX, "current target doesn't have an ETM configured");
+ command_print(CMD, "current target doesn't have an ETM configured");
return ERROR_FAIL;
}
if (etm_ctx->capture_driver->status == TRACE_IDLE) {
- command_print(CMD_CTX, "trace capture wasn't enabled, no trace data captured");
+ command_print(CMD, "trace capture wasn't enabled, no trace data captured");
return ERROR_OK;
}
if (etm_ctx->capture_driver->status(etm_ctx) & TRACE_RUNNING) {
/* TODO: if on-the-fly capture is to be supported, this needs to be changed */
- command_print(CMD_CTX, "trace capture not completed");
+ command_print(CMD, "trace capture not completed");
return ERROR_FAIL;
}
target = get_current_target(CMD_CTX);
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "ETM: current target isn't an ARM");
+ command_print(CMD, "ETM: current target isn't an ARM");
return ERROR_FAIL;
}
etm_ctx = arm->etm;
if (!etm_ctx) {
- command_print(CMD_CTX, "current target doesn't have an ETM configured");
+ command_print(CMD, "current target doesn't have an ETM configured");
return ERROR_FAIL;
}
if (etm_ctx->capture_driver->status(etm_ctx) & TRACE_RUNNING) {
- command_print(CMD_CTX, "trace capture running, stop first");
+ command_print(CMD, "trace capture running, stop first");
return ERROR_FAIL;
}
}
if (filesize % 4) {
- command_print(CMD_CTX, "size isn't a multiple of 4, no valid trace data");
+ command_print(CMD, "size isn't a multiple of 4, no valid trace data");
fileio_close(file);
return ERROR_FAIL;
}
}
etm_ctx->trace_data = malloc(sizeof(struct etmv1_trace_data) * etm_ctx->trace_depth);
if (etm_ctx->trace_data == NULL) {
- command_print(CMD_CTX, "not enough memory to perform operation");
+ command_print(CMD, "not enough memory to perform operation");
fileio_close(file);
return ERROR_FAIL;
}
target = get_current_target(CMD_CTX);
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "ETM: current target isn't an ARM");
+ command_print(CMD, "ETM: current target isn't an ARM");
return ERROR_FAIL;
}
etm_ctx = arm->etm;
if (!etm_ctx) {
- command_print(CMD_CTX, "current target doesn't have an ETM configured");
+ command_print(CMD, "current target doesn't have an ETM configured");
return ERROR_FAIL;
}
target = get_current_target(CMD_CTX);
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "ETM: current target isn't an ARM");
+ command_print(CMD, "ETM: current target isn't an ARM");
return ERROR_FAIL;
}
etm_ctx = arm->etm;
if (!etm_ctx) {
- command_print(CMD_CTX, "current target doesn't have an ETM configured");
+ command_print(CMD, "current target doesn't have an ETM configured");
return ERROR_FAIL;
}
target = get_current_target(CMD_CTX);
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "ETM: %s isn't an ARM",
+ command_print(CMD, "ETM: %s isn't an ARM",
target_name(target));
return ERROR_FAIL;
}
etm = arm->etm;
if (!etm) {
- command_print(CMD_CTX, "ETM: no ETM configured for %s",
+ command_print(CMD, "ETM: no ETM configured for %s",
target_name(target));
return ERROR_FAIL;
}
buf_set_u32(etm_ctrl_reg->value, 0, 32, etm->control);
}
- command_print(CMD_CTX, "ETM: %s debug halt",
+ command_print(CMD, "ETM: %s debug halt",
(etm->control & ETM_CTRL_DBGRQ)
? "triggers"
: "does not trigger");
target = get_current_target(CMD_CTX);
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "ETM: current target isn't an ARM");
+ command_print(CMD, "ETM: current target isn't an ARM");
return ERROR_FAIL;
}
etm_ctx = arm->etm;
if (!etm_ctx) {
- command_print(CMD_CTX, "current target doesn't have an ETM configured");
+ command_print(CMD, "current target doesn't have an ETM configured");
return ERROR_FAIL;
}
/* FIX! error should be reported inside etmv1_analyze_trace() */
switch (retval) {
case ERROR_ETM_ANALYSIS_FAILED:
- command_print(CMD_CTX,
+ command_print(CMD,
"further analysis failed (corrupted trace data or just end of data");
break;
case ERROR_TRACE_INSTRUCTION_UNAVAILABLE:
- command_print(CMD_CTX,
+ command_print(CMD,
"no instruction for current address available, analysis aborted");
break;
case ERROR_TRACE_IMAGE_UNAVAILABLE:
- command_print(CMD_CTX, "no image available for trace analysis");
+ command_print(CMD, "no image available for trace analysis");
break;
default:
- command_print(CMD_CTX, "unknown error");
+ command_print(CMD, "unknown error");
}
}
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "target '%s' isn't an ARM", CMD_ARGV[0]);
+ command_print(CMD, "target '%s' isn't an ARM", CMD_ARGV[0]);
return ERROR_FAIL;
}
struct mips32_common *mips32)
{
if (mips32->common_magic != MIPS32_COMMON_MAGIC) {
- command_print(cmd->ctx, "target is not an MIPS32");
+ command_print(cmd, "target is not an MIPS32");
return ERROR_TARGET_INVALID;
}
return ERROR_OK;
return retval;
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+ command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
return ERROR_OK;
}
retval = mips32_cp0_read(ejtag_info, &value, cp0_reg, cp0_sel);
if (retval != ERROR_OK) {
- command_print(CMD_CTX,
+ command_print(CMD,
"couldn't access reg %" PRIi32,
cp0_reg);
return ERROR_OK;
}
- command_print(CMD_CTX, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
+ command_print(CMD, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
cp0_reg, cp0_sel, value);
} else if (CMD_ARGC == 3) {
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], value);
retval = mips32_cp0_write(ejtag_info, value, cp0_reg, cp0_sel);
if (retval != ERROR_OK) {
- command_print(CMD_CTX,
+ command_print(CMD,
"couldn't access cp0 reg %" PRIi32 ", select %" PRIi32,
cp0_reg, cp0_sel);
return ERROR_OK;
}
- command_print(CMD_CTX, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
+ command_print(CMD, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
cp0_reg, cp0_sel, value);
}
}
else if (CMD_ARGC > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX, "scan delay: %d nsec", ejtag_info->scan_delay);
+ command_print(CMD, "scan delay: %d nsec", ejtag_info->scan_delay);
if (ejtag_info->scan_delay >= MIPS32_SCAN_DELAY_LEGACY_MODE) {
ejtag_info->mode = 0;
- command_print(CMD_CTX, "running in legacy mode");
+ command_print(CMD, "running in legacy mode");
} else {
ejtag_info->mode = 1;
- command_print(CMD_CTX, "running in fast queued mode");
+ command_print(CMD, "running in fast queued mode");
}
return ERROR_OK;
struct mips_m4k_common *mips_m4k)
{
if (mips_m4k->common_magic != MIPSM4K_COMMON_MAGIC) {
- command_print(cmd->ctx, "target is not an MIPS_M4K");
+ command_print(cmd, "target is not an MIPS_M4K");
return ERROR_TARGET_INVALID;
}
return ERROR_OK;
return retval;
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+ command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
return ERROR_OK;
}
uint32_t value;
retval = mips32_cp0_read(ejtag_info, &value, cp0_reg, cp0_sel);
if (retval != ERROR_OK) {
- command_print(CMD_CTX,
+ command_print(CMD,
"couldn't access reg %" PRIi32,
cp0_reg);
return ERROR_OK;
}
- command_print(CMD_CTX, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
+ command_print(CMD, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
cp0_reg, cp0_sel, value);
} else if (CMD_ARGC == 3) {
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], value);
retval = mips32_cp0_write(ejtag_info, value, cp0_reg, cp0_sel);
if (retval != ERROR_OK) {
- command_print(CMD_CTX,
+ command_print(CMD,
"couldn't access cp0 reg %" PRIi32 ", select %" PRIi32,
cp0_reg, cp0_sel);
return ERROR_OK;
}
- command_print(CMD_CTX, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
+ command_print(CMD, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32,
cp0_reg, cp0_sel, value);
}
}
else if (CMD_ARGC > 1)
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX, "scan delay: %d nsec", ejtag_info->scan_delay);
+ command_print(CMD, "scan delay: %d nsec", ejtag_info->scan_delay);
if (ejtag_info->scan_delay >= MIPS32_SCAN_DELAY_LEGACY_MODE) {
ejtag_info->mode = 0;
- command_print(CMD_CTX, "running in legacy mode");
+ command_print(CMD, "running in legacy mode");
} else {
ejtag_info->mode = 1;
- command_print(CMD_CTX, "running in fast queued mode");
+ command_print(CMD, "running in fast queued mode");
}
return ERROR_OK;
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
nds32->step_isr_enable = false;
}
- command_print(CMD_CTX, "%s: $INT_MASK.DSSIM: %d", target_name(target),
+ command_print(CMD, "%s: $INT_MASK.DSSIM: %d", target_name(target),
nds32->step_isr_enable);
return ERROR_OK;
struct nds32_memory *memory = &(nds32->memory);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
aice_memory_access(aice, memory->access_channel);
} else {
- command_print(CMD_CTX, "%s: memory access channel: %s",
+ command_print(CMD, "%s: memory access channel: %s",
target_name(target),
NDS_MEMORY_ACCESS_NAME[memory->access_channel]);
}
struct aice_port_s *aice = target_to_aice(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
if (CMD_ARGC > 0) {
if (nds32->edm.access_control == false) {
- command_print(CMD_CTX, "%s does not support ACC_CTL. "
+ command_print(CMD, "%s does not support ACC_CTL. "
"Set memory mode to MEMORY", target_name(target));
nds32->memory.mode = NDS_MEMORY_SELECT_MEM;
} else if (nds32->edm.direct_access_local_memory == false) {
- command_print(CMD_CTX, "%s does not support direct access "
+ command_print(CMD, "%s does not support direct access "
"local memory. Set memory mode to MEMORY",
target_name(target));
nds32->memory.mode = NDS_MEMORY_SELECT_MEM;
nds32->memory.mode = NDS_MEMORY_SELECT_MEM;
} else if (strcmp(CMD_ARGV[0], "ilm") == 0) {
if (nds32->memory.ilm_base == 0)
- command_print(CMD_CTX, "%s does not support ILM",
+ command_print(CMD, "%s does not support ILM",
target_name(target));
else
nds32->memory.mode = NDS_MEMORY_SELECT_ILM;
} else if (strcmp(CMD_ARGV[0], "dlm") == 0) {
if (nds32->memory.dlm_base == 0)
- command_print(CMD_CTX, "%s does not support DLM",
+ command_print(CMD, "%s does not support DLM",
target_name(target));
else
nds32->memory.mode = NDS_MEMORY_SELECT_DLM;
}
}
- command_print(CMD_CTX, "%s: memory mode: %s",
+ command_print(CMD, "%s: memory mode: %s",
target_name(target),
NDS_MEMORY_SELECT_NAME[nds32->memory.mode]);
int result;
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
/* D$ write back */
result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1D_WBALL, 0);
if (result != ERROR_OK) {
- command_print(CMD_CTX, "%s: Write back data cache...failed",
+ command_print(CMD, "%s: Write back data cache...failed",
target_name(target));
return result;
}
- command_print(CMD_CTX, "%s: Write back data cache...done",
+ command_print(CMD, "%s: Write back data cache...done",
target_name(target));
/* D$ invalidate */
result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1D_INVALALL, 0);
if (result != ERROR_OK) {
- command_print(CMD_CTX, "%s: Invalidate data cache...failed",
+ command_print(CMD, "%s: Invalidate data cache...failed",
target_name(target));
return result;
}
- command_print(CMD_CTX, "%s: Invalidate data cache...done",
+ command_print(CMD, "%s: Invalidate data cache...done",
target_name(target));
} else {
if (dcache->line_size == 0)
- command_print(CMD_CTX, "%s: No data cache",
+ command_print(CMD, "%s: No data cache",
target_name(target));
else
- command_print(CMD_CTX, "%s: Data cache disabled",
+ command_print(CMD, "%s: Data cache disabled",
target_name(target));
}
/* I$ invalidate */
result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1I_INVALALL, 0);
if (result != ERROR_OK) {
- command_print(CMD_CTX, "%s: Invalidate instruction cache...failed",
+ command_print(CMD, "%s: Invalidate instruction cache...failed",
target_name(target));
return result;
}
- command_print(CMD_CTX, "%s: Invalidate instruction cache...done",
+ command_print(CMD, "%s: Invalidate instruction cache...done",
target_name(target));
} else {
if (icache->line_size == 0)
- command_print(CMD_CTX, "%s: No instruction cache",
+ command_print(CMD, "%s: No instruction cache",
target_name(target));
else
- command_print(CMD_CTX, "%s: Instruction cache disabled",
+ command_print(CMD, "%s: Instruction cache disabled",
target_name(target));
}
} else
- command_print(CMD_CTX, "No valid parameter");
+ command_print(CMD, "No valid parameter");
}
return ERROR_OK;
int result;
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
if (CMD_ARGC > 0) {
if (icache->line_size == 0) {
- command_print(CMD_CTX, "%s: No instruction cache",
+ command_print(CMD, "%s: No instruction cache",
target_name(target));
return ERROR_OK;
}
/* I$ invalidate */
result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1I_INVALALL, 0);
if (result != ERROR_OK) {
- command_print(CMD_CTX, "%s: Invalidate instruction cache...failed",
+ command_print(CMD, "%s: Invalidate instruction cache...failed",
target_name(target));
return result;
}
- command_print(CMD_CTX, "%s: Invalidate instruction cache...done",
+ command_print(CMD, "%s: Invalidate instruction cache...done",
target_name(target));
} else {
- command_print(CMD_CTX, "%s: Instruction cache disabled",
+ command_print(CMD, "%s: Instruction cache disabled",
target_name(target));
}
} else if (strcmp(CMD_ARGV[0], "enable") == 0) {
} else if (strcmp(CMD_ARGV[0], "dump") == 0) {
/* TODO: dump cache content */
} else {
- command_print(CMD_CTX, "%s: No valid parameter", target_name(target));
+ command_print(CMD, "%s: No valid parameter", target_name(target));
}
}
int result;
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
if (CMD_ARGC > 0) {
if (dcache->line_size == 0) {
- command_print(CMD_CTX, "%s: No data cache", target_name(target));
+ command_print(CMD, "%s: No data cache", target_name(target));
return ERROR_OK;
}
/* D$ write back */
result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1D_WBALL, 0);
if (result != ERROR_OK) {
- command_print(CMD_CTX, "%s: Write back data cache...failed",
+ command_print(CMD, "%s: Write back data cache...failed",
target_name(target));
return result;
}
- command_print(CMD_CTX, "%s: Write back data cache...done",
+ command_print(CMD, "%s: Write back data cache...done",
target_name(target));
/* D$ invalidate */
result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1D_INVALALL, 0);
if (result != ERROR_OK) {
- command_print(CMD_CTX, "%s: Invalidate data cache...failed",
+ command_print(CMD, "%s: Invalidate data cache...failed",
target_name(target));
return result;
}
- command_print(CMD_CTX, "%s: Invalidate data cache...done",
+ command_print(CMD, "%s: Invalidate data cache...done",
target_name(target));
} else {
- command_print(CMD_CTX, "%s: Data cache disabled",
+ command_print(CMD, "%s: Data cache disabled",
target_name(target));
}
} else if (strcmp(CMD_ARGV[0], "enable") == 0) {
} else if (strcmp(CMD_ARGV[0], "dump") == 0) {
/* TODO: dump cache content */
} else {
- command_print(CMD_CTX, "%s: No valid parameter", target_name(target));
+ command_print(CMD, "%s: No valid parameter", target_name(target));
}
}
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
}
if (nds32->auto_convert_hw_bp)
- command_print(CMD_CTX, "%s: convert sw break to hw break on ROM: on",
+ command_print(CMD, "%s: convert sw break to hw break on ROM: on",
target_name(target));
else
- command_print(CMD_CTX, "%s: convert sw break to hw break on ROM: off",
+ command_print(CMD, "%s: convert sw break to hw break on ROM: off",
target_name(target));
return ERROR_OK;
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
}
if (nds32->virtual_hosting)
- command_print(CMD_CTX, "%s: virtual hosting: on", target_name(target));
+ command_print(CMD, "%s: virtual hosting: on", target_name(target));
else
- command_print(CMD_CTX, "%s: virtual hosting: off", target_name(target));
+ command_print(CMD, "%s: virtual hosting: off", target_name(target));
return ERROR_OK;
}
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
read_addr, &instruction))
return ERROR_FAIL;
- command_print(CMD_CTX, "%s", instruction.text);
+ command_print(CMD, "%s", instruction.text);
read_addr += instruction.instruction_size;
i++;
if (ERROR_OK != nds32_evaluate_opcode(nds32, opcode, addr, &instruction))
return ERROR_FAIL;
- command_print(CMD_CTX, "%s", instruction.text);
+ command_print(CMD, "%s", instruction.text);
} else
return ERROR_FAIL;
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
- command_print(CMD_CTX, "OCD");
+ command_print(CMD, "OCD");
return ERROR_OK;
}
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
nds32_get_mapped_reg(nds32, IR0, &value_psw);
if (value_psw & 0x20)
- command_print(CMD_CTX, "%s: BE", target_name(target));
+ command_print(CMD, "%s: BE", target_name(target));
else
- command_print(CMD_CTX, "%s: LE", target_name(target));
+ command_print(CMD, "%s: LE", target_name(target));
return ERROR_OK;
}
struct nds32 *nds32 = target_to_nds32(target);
if (!is_nds32(nds32)) {
- command_print(CMD_CTX, "current target isn't an Andes core");
+ command_print(CMD, "current target isn't an Andes core");
return ERROR_FAIL;
}
- command_print(CMD_CTX, "CPUID: %s", target_name(target));
+ command_print(CMD, "CPUID: %s", target_name(target));
return ERROR_OK;
}
target = get_current_target(CMD_CTX);
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "current target isn't an ARM");
+ command_print(CMD, "current target isn't an ARM");
return ERROR_FAIL;
}
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "current target isn't an ARM");
+ command_print(CMD, "current target isn't an ARM");
return ERROR_FAIL;
}
if (!arm->etm) {
- command_print(CMD_CTX, "current target doesn't have an ETM configured");
+ command_print(CMD, "current target doesn't have an ETM configured");
return ERROR_FAIL;
}
if (strcmp(arm->etm->capture_driver->name, "oocd_trace") != 0) {
- command_print(CMD_CTX, "current target's ETM capture driver isn't 'oocd_trace'");
+ command_print(CMD, "current target's ETM capture driver isn't 'oocd_trace'");
return ERROR_FAIL;
}
oocd_trace_read_reg(oocd_trace, OOCD_TRACE_STATUS, &status);
if (status & 0x8)
- command_print(CMD_CTX, "trace clock locked");
+ command_print(CMD, "trace clock locked");
else
- command_print(CMD_CTX, "no trace clock");
+ command_print(CMD, "no trace clock");
return ERROR_OK;
}
arm = target_to_arm(target);
if (!is_arm(arm)) {
- command_print(CMD_CTX, "current target isn't an ARM");
+ command_print(CMD, "current target isn't an ARM");
return ERROR_FAIL;
}
if (!arm->etm) {
- command_print(CMD_CTX, "current target doesn't have an ETM configured");
+ command_print(CMD, "current target doesn't have an ETM configured");
return ERROR_FAIL;
}
if (strcmp(arm->etm->capture_driver->name, "oocd_trace") != 0) {
- command_print(CMD_CTX, "current target's ETM capture driver isn't 'oocd_trace'");
+ command_print(CMD, "current target's ETM capture driver isn't 'oocd_trace'");
return ERROR_FAIL;
}
if (bytes_written < 1)
return ERROR_FAIL;
- command_print(CMD_CTX, "requesting traceclock resync");
+ command_print(CMD, "requesting traceclock resync");
LOG_DEBUG("resyncing traceclk pll");
return ERROR_OK;
list_for_each_entry(or1k_tap, &tap_list, list) {
if (or1k_tap->name)
- command_print(CMD_CTX, "%s", or1k_tap->name);
+ command_print(CMD, "%s", or1k_tap->name);
}
return ERROR_OK;
list_for_each_entry(or1k_du, &du_list, list) {
if (or1k_du->name)
- command_print(CMD_CTX, "%s", or1k_du->name);
+ command_print(CMD, "%s", or1k_du->name);
}
return ERROR_OK;
uint32_t value;
if (r->authdata_read(target, &value) != ERROR_OK)
return ERROR_FAIL;
- command_print(CMD_CTX, "0x%" PRIx32, value);
+ command_print(CMD, "0x%" PRIx32, value);
return ERROR_OK;
} else {
LOG_ERROR("authdata_read is not implemented for this target.");
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
if (r->dmi_read(target, &value, address) != ERROR_OK)
return ERROR_FAIL;
- command_print(CMD_CTX, "0x%" PRIx32, value);
+ command_print(CMD, "0x%" PRIx32, value);
return ERROR_OK;
} else {
LOG_ERROR("dmi_read is not implemented for this target.");
struct semihosting *semihosting = target->semihosting;
if (!semihosting) {
- command_print(CMD_CTX, "semihosting not supported for current target");
+ command_print(CMD, "semihosting not supported for current target");
return ERROR_FAIL;
}
semihosting->is_active = is_active;
}
- command_print(CMD_CTX, "semihosting is %s",
+ command_print(CMD, "semihosting is %s",
semihosting->is_active
? "enabled" : "disabled");
struct semihosting *semihosting = target->semihosting;
if (!semihosting) {
- command_print(CMD_CTX, "semihosting not supported for current target");
+ command_print(CMD, "semihosting not supported for current target");
return ERROR_FAIL;
}
if (!semihosting->is_active) {
- command_print(CMD_CTX, "semihosting not yet enabled for current target");
+ command_print(CMD, "semihosting not yet enabled for current target");
return ERROR_FAIL;
}
if (CMD_ARGC > 0)
COMMAND_PARSE_ENABLE(CMD_ARGV[0], semihosting->is_fileio);
- command_print(CMD_CTX, "semihosting fileio is %s",
+ command_print(CMD, "semihosting fileio is %s",
semihosting->is_fileio
? "enabled" : "disabled");
struct semihosting *semihosting = target->semihosting;
if (!semihosting) {
- command_print(CMD_CTX, "semihosting not supported for current target");
+ command_print(CMD, "semihosting not supported for current target");
return ERROR_FAIL;
}
semihosting->cmdline = cmdline;
}
- command_print(CMD_CTX, "semihosting command line is [%s]",
+ command_print(CMD, "semihosting command line is [%s]",
semihosting->cmdline);
return ERROR_OK;
struct semihosting *semihosting = target->semihosting;
if (!semihosting) {
- command_print(CMD_CTX, "semihosting not supported for current target");
+ command_print(CMD, "semihosting not supported for current target");
return ERROR_FAIL;
}
if (!semihosting->is_active) {
- command_print(CMD_CTX, "semihosting not yet enabled for current target");
+ command_print(CMD, "semihosting not yet enabled for current target");
return ERROR_FAIL;
}
if (CMD_ARGC > 0)
COMMAND_PARSE_ENABLE(CMD_ARGV[0], semihosting->has_resumable_exit);
- command_print(CMD_CTX, "semihosting resumable exit is %s",
+ command_print(CMD, "semihosting resumable exit is %s",
semihosting->has_resumable_exit
? "enabled" : "disabled");
return ERROR_COMMAND_SYNTAX_ERROR;
if (!CMD_ARGC) {
- command_print(CMD_CTX, "%s", target->smp ? "on" : "off");
+ command_print(CMD, "%s", target->smp ? "on" : "off");
return ERROR_OK;
}
target->gdb_service->core[1] = coreid;
}
- command_print(CMD_CTX, "gdb coreid %" PRId32 " -> %" PRId32, target->gdb_service->core[0]
+ command_print(CMD, "gdb coreid %" PRId32 " -> %" PRId32, target->gdb_service->core[0]
, target->gdb_service->core[1]);
}
return ERROR_OK;
stm8->enable_step_irq = enable;
}
msg = stm8->enable_step_irq ? "enabled" : "disabled";
- command_print(CMD_CTX, "enable_step_irq = %s", msg);
+ command_print(CMD, "enable_step_irq = %s", msg);
return ERROR_OK;
}
stm8->enable_stm8l = enable;
}
msg = stm8->enable_stm8l ? "enabled" : "disabled";
- command_print(CMD_CTX, "enable_stm8l = %s", msg);
+ command_print(CMD, "enable_stm8l = %s", msg);
stm8_init_flash_regs(stm8->enable_stm8l, stm8);
return ERROR_OK;
}
if (retval != JIM_OK) {
Jim_MakeErrorMessage(cmd->ctx->interp);
- command_print(cmd->ctx, "%s", Jim_GetString(Jim_GetResult(cmd->ctx->interp), NULL));
+ command_print(cmd, "%s", Jim_GetString(Jim_GetResult(cmd->ctx->interp), NULL));
return ERROR_FAIL;
}
}
struct target *target = all_targets;
- command_print(CMD_CTX, " TargetName Type Endian TapName State ");
- command_print(CMD_CTX, "-- ------------------ ---------- ------ ------------------ ------------");
+ command_print(CMD, " TargetName Type Endian TapName State ");
+ command_print(CMD, "-- ------------------ ---------- ------ ------------------ ------------");
while (target) {
const char *state;
char marker = ' ';
marker = '*';
/* keep columns lined up to match the headers above */
- command_print(CMD_CTX,
+ command_print(CMD,
"%2d%c %-18s %-10s %-6s %-18s %s",
target->target_number,
marker,
while (cache) {
unsigned i;
- command_print(CMD_CTX, "===== %s", cache->name);
+ command_print(CMD, "===== %s", cache->name);
for (i = 0, reg = cache->reg_list;
i < cache->num_regs;
if (reg->valid) {
value = buf_to_str(reg->value,
reg->size, 16);
- command_print(CMD_CTX,
+ command_print(CMD,
"(%i) %s (/%" PRIu32 "): 0x%s%s",
count, reg->name,
reg->size, value,
: "");
free(value);
} else {
- command_print(CMD_CTX, "(%i) %s (/%" PRIu32 ")",
+ command_print(CMD, "(%i) %s (/%" PRIu32 ")",
count, reg->name,
reg->size) ;
}
}
if (!reg) {
- command_print(CMD_CTX, "%i is out of bounds, the current target "
+ command_print(CMD, "%i is out of bounds, the current target "
"has only %i registers (0 - %i)", num, count, count - 1);
return ERROR_OK;
}
if (reg->valid == 0)
reg->type->get(reg);
value = buf_to_str(reg->value, reg->size, 16);
- command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
+ command_print(CMD, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
free(value);
return ERROR_OK;
}
reg->type->set(reg, buf);
value = buf_to_str(reg->value, reg->size, 16);
- command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
+ command_print(CMD, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value);
free(value);
free(buf);
return ERROR_COMMAND_SYNTAX_ERROR;
not_found:
- command_print(CMD_CTX, "register %s not found in current target", CMD_ARGV[0]);
+ command_print(CMD, "register %s not found in current target", CMD_ARGV[0]);
return ERROR_OK;
}
struct target *target = get_current_target(CMD_CTX);
if (CMD_ARGC == 0) {
- command_print(CMD_CTX, "background polling: %s",
+ command_print(CMD, "background polling: %s",
jtag_poll_get_enabled() ? "on" : "off");
- command_print(CMD_CTX, "TAP: %s (%s)",
+ command_print(CMD, "TAP: %s (%s)",
target->tap->dotted_name,
target->tap->enabled ? "enabled" : "disabled");
if (!target->tap->enabled)
value_fmt, value);
if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) {
- command_print(cmd->ctx, "%s", output);
+ command_print(cmd, "%s", output);
output_len = 0;
}
}
for (i = 0; i < image.num_sections; i++) {
buffer = malloc(image.sections[i].size);
if (buffer == NULL) {
- command_print(CMD_CTX,
+ command_print(CMD,
"error allocating buffer for section (%d bytes)",
(int)(image.sections[i].size));
retval = ERROR_FAIL;
break;
}
image_size += length;
- command_print(CMD_CTX, "%u bytes written at address " TARGET_ADDR_FMT "",
+ command_print(CMD, "%u bytes written at address " TARGET_ADDR_FMT "",
(unsigned int)length,
image.sections[i].base_address + offset);
}
}
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
- command_print(CMD_CTX, "downloaded %" PRIu32 " bytes "
+ command_print(CMD, "downloaded %" PRIu32 " bytes "
"in %fs (%0.3f KiB/s)", image_size,
duration_elapsed(&bench), duration_kbps(&bench, image_size));
}
retval = fileio_size(fileio, &filesize);
if (retval != ERROR_OK)
return retval;
- command_print(CMD_CTX,
+ command_print(CMD,
"dumped %zu bytes in %fs (%0.3f KiB/s)", filesize,
duration_elapsed(&bench), duration_kbps(&bench, filesize));
}
for (i = 0; i < image.num_sections; i++) {
buffer = malloc(image.sections[i].size);
if (buffer == NULL) {
- command_print(CMD_CTX,
+ command_print(CMD,
"error allocating buffer for section (%d bytes)",
(int)(image.sections[i].size));
break;
uint32_t t;
for (t = 0; t < buf_cnt; t++) {
if (data[t] != buffer[t]) {
- command_print(CMD_CTX,
+ command_print(CMD,
"diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
diffs,
(unsigned)(t + image.sections[i].base_address),
data[t],
buffer[t]);
if (diffs++ >= 127) {
- command_print(CMD_CTX, "More than 128 errors, the rest are not printed.");
+ command_print(CMD, "More than 128 errors, the rest are not printed.");
free(data);
free(buffer);
goto done;
free(data);
}
} else {
- command_print(CMD_CTX, "address " TARGET_ADDR_FMT " length 0x%08zx",
+ command_print(CMD, "address " TARGET_ADDR_FMT " length 0x%08zx",
image.sections[i].base_address,
buf_cnt);
}
image_size += buf_cnt;
}
if (diffs > 0)
- command_print(CMD_CTX, "No more differences found.");
+ command_print(CMD, "No more differences found.");
done:
if (diffs > 0)
retval = ERROR_FAIL;
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
- command_print(CMD_CTX, "verified %" PRIu32 " bytes "
+ command_print(CMD, "verified %" PRIu32 " bytes "
"in %fs (%0.3f KiB/s)", image_size,
duration_elapsed(&bench), duration_kbps(&bench, image_size));
}
if (breakpoint->type == BKPT_SOFT) {
char *buf = buf_to_str(breakpoint->orig_instr,
breakpoint->length, 16);
- command_print(cmd->ctx, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, %i, 0x%s",
+ command_print(cmd, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, %i, 0x%s",
breakpoint->address,
breakpoint->length,
breakpoint->set, buf);
free(buf);
} else {
if ((breakpoint->address == 0) && (breakpoint->asid != 0))
- command_print(cmd->ctx, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i",
+ command_print(cmd, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i",
breakpoint->asid,
breakpoint->length, breakpoint->set);
else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {
- command_print(cmd->ctx, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
+ command_print(cmd, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
breakpoint->address,
breakpoint->length, breakpoint->set);
- command_print(cmd->ctx, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
+ command_print(cmd, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
breakpoint->asid);
} else
- command_print(cmd->ctx, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
+ command_print(cmd, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",
breakpoint->address,
breakpoint->length, breakpoint->set);
}
retval = breakpoint_add(target, addr, length, hw);
/* error is always logged in breakpoint_add(), do not print it again */
if (ERROR_OK == retval)
- command_print(cmd->ctx, "breakpoint set at " TARGET_ADDR_FMT "", addr);
+ command_print(cmd, "breakpoint set at " TARGET_ADDR_FMT "", addr);
} else if (addr == 0) {
if (target->type->add_context_breakpoint == NULL) {
retval = context_breakpoint_add(target, asid, length, hw);
/* error is always logged in context_breakpoint_add(), do not print it again */
if (ERROR_OK == retval)
- command_print(cmd->ctx, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
+ command_print(cmd, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
} else {
if (target->type->add_hybrid_breakpoint == NULL) {
retval = hybrid_breakpoint_add(target, addr, asid, length, hw);
/* error is always logged in hybrid_breakpoint_add(), do not print it again */
if (ERROR_OK == retval)
- command_print(cmd->ctx, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
+ command_print(cmd, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
}
return retval;
}
struct watchpoint *watchpoint = target->watchpoints;
while (watchpoint) {
- command_print(CMD_CTX, "address: " TARGET_ADDR_FMT
+ command_print(CMD, "address: " TARGET_ADDR_FMT
", len: 0x%8.8" PRIx32
", r/w/a: %i, value: 0x%8.8" PRIx32
", mask: 0x%8.8" PRIx32,
struct target *target = get_current_target(CMD_CTX);
int retval = target->type->virt2phys(target, va, &pa);
if (retval == ERROR_OK)
- command_print(CMD_CTX, "Physical address " TARGET_ADDR_FMT "", pa);
+ command_print(CMD, "Physical address " TARGET_ADDR_FMT "", pa);
return retval;
}
write_gmon(samples, num_of_samples, CMD_ARGV[1],
with_range, start_address, end_address, target, duration_ms);
- command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]);
+ command_print(CMD, "Wrote %s", CMD_ARGV[1]);
free(samples);
return retval;
struct target *target = get_current_target(CMD_CTX);
struct target_event_action *teap = target->event_action;
- command_print(CMD_CTX, "Event actions for target (%d) %s\n",
+ command_print(CMD, "Event actions for target (%d) %s\n",
target->target_number,
target_name(target));
- command_print(CMD_CTX, "%-25s | Body", "Event");
- command_print(CMD_CTX, "------------------------- | "
+ command_print(CMD, "%-25s | Body", "Event");
+ command_print(CMD, "------------------------- | "
"----------------------------------------");
while (teap) {
Jim_Nvp *opt = Jim_Nvp_value2name_simple(nvp_target_event, teap->event);
- command_print(CMD_CTX, "%-25s | %s",
+ command_print(CMD, "%-25s | %s",
opt->name, Jim_GetString(teap->body, NULL));
teap = teap->next;
}
- command_print(CMD_CTX, "***END***");
+ command_print(CMD, "***END***");
return ERROR_OK;
}
static int jim_target_current_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
fastload_num = image.num_sections;
fastload = malloc(sizeof(struct FastLoad)*image.num_sections);
if (fastload == NULL) {
- command_print(CMD_CTX, "out of memory");
+ command_print(CMD, "out of memory");
image_close(&image);
return ERROR_FAIL;
}
for (i = 0; i < image.num_sections; i++) {
buffer = malloc(image.sections[i].size);
if (buffer == NULL) {
- command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
+ command_print(CMD, "error allocating buffer for section (%d bytes)",
(int)(image.sections[i].size));
retval = ERROR_FAIL;
break;
fastload[i].data = malloc(length);
if (fastload[i].data == NULL) {
free(buffer);
- command_print(CMD_CTX, "error allocating buffer for section (%" PRIu32 " bytes)",
+ command_print(CMD, "error allocating buffer for section (%" PRIu32 " bytes)",
length);
retval = ERROR_FAIL;
break;
fastload[i].length = length;
image_size += length;
- command_print(CMD_CTX, "%u bytes written at address 0x%8.8x",
+ command_print(CMD, "%u bytes written at address 0x%8.8x",
(unsigned int)length,
((unsigned int)(image.sections[i].base_address + offset)));
}
}
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
- command_print(CMD_CTX, "Loaded %" PRIu32 " bytes "
+ command_print(CMD, "Loaded %" PRIu32 " bytes "
"in %fs (%0.3f KiB/s)", image_size,
duration_elapsed(&bench), duration_kbps(&bench, image_size));
- command_print(CMD_CTX,
+ command_print(CMD,
"WARNING: image has not been loaded to target!"
"You can issue a 'fast_load' to finish loading.");
}
int retval = ERROR_OK;
for (i = 0; i < fastload_num; i++) {
struct target *target = get_current_target(CMD_CTX);
- command_print(CMD_CTX, "Write to 0x%08x, length 0x%08x",
+ command_print(CMD, "Write to 0x%08x, length 0x%08x",
(unsigned int)(fastload[i].address),
(unsigned int)(fastload[i].length));
retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data);
}
if (retval == ERROR_OK) {
int64_t after = timeval_ms();
- command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
+ command_print(CMD, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0));
}
return retval;
}
if ((target->rtos) && (target->rtos->type)
&& (target->rtos->type->ps_command)) {
display = target->rtos->type->ps_command(target);
- command_print(CMD_CTX, "%s", display);
+ command_print(CMD, "%s", display);
free(display);
return ERROR_OK;
} else {
static void binprint(struct command_invocation *cmd, const char *text, const uint8_t *buf, int size)
{
if (text != NULL)
- command_print_sameline(cmd->ctx, "%s", text);
+ command_print_sameline(cmd, "%s", text);
for (int i = 0; i < size; i++)
- command_print_sameline(cmd->ctx, " %02x", buf[i]);
- command_print(cmd->ctx, " ");
+ command_print_sameline(cmd, " %02x", buf[i]);
+ command_print(cmd, " ");
}
COMMAND_HANDLER(handle_test_mem_access_command)
read_ref[i] = rand();
read_buf[i] = read_ref[i];
}
- command_print_sameline(CMD_CTX,
+ command_print_sameline(CMD,
"Test read %" PRIu32 " x %d @ %d to %saligned buffer: ", count,
size, offset, host_offset ? "un" : "");
duration_measure(&bench);
if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
- command_print(CMD_CTX, "Unsupported alignment");
+ command_print(CMD, "Unsupported alignment");
goto next;
} else if (retval != ERROR_OK) {
- command_print(CMD_CTX, "Memory read failed");
+ command_print(CMD, "Memory read failed");
goto next;
}
/* check result */
int result = memcmp(read_ref, read_buf, host_bufsiz);
if (result == 0) {
- command_print(CMD_CTX, "Pass in %fs (%0.3f KiB/s)",
+ command_print(CMD, "Pass in %fs (%0.3f KiB/s)",
duration_elapsed(&bench),
duration_kbps(&bench, count * size));
} else {
- command_print(CMD_CTX, "Compare failed");
+ command_print(CMD, "Compare failed");
binprint(CMD, "ref:", read_ref, host_bufsiz);
binprint(CMD, "buf:", read_buf, host_bufsiz);
}
for (size_t i = 0; i < host_bufsiz; i++)
write_buf[i] = rand();
- command_print_sameline(CMD_CTX,
+ command_print_sameline(CMD,
"Test write %" PRIu32 " x %d @ %d from %saligned buffer: ", count,
size, offset, host_offset ? "un" : "");
retval = target_write_memory(target, wa->address, 1, num_bytes, test_pattern);
if (retval != ERROR_OK) {
- command_print(CMD_CTX, "Test pattern write failed");
+ command_print(CMD, "Test pattern write failed");
goto nextw;
}
duration_measure(&bench);
if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
- command_print(CMD_CTX, "Unsupported alignment");
+ command_print(CMD, "Unsupported alignment");
goto nextw;
} else if (retval != ERROR_OK) {
- command_print(CMD_CTX, "Memory write failed");
+ command_print(CMD, "Memory write failed");
goto nextw;
}
/* read back */
retval = target_read_memory(target, wa->address, 1, num_bytes, read_buf);
if (retval != ERROR_OK) {
- command_print(CMD_CTX, "Test pattern write failed");
+ command_print(CMD, "Test pattern write failed");
goto nextw;
}
/* check result */
int result = memcmp(read_ref, read_buf, num_bytes);
if (result == 0) {
- command_print(CMD_CTX, "Pass in %fs (%0.3f KiB/s)",
+ command_print(CMD, "Pass in %fs (%0.3f KiB/s)",
duration_elapsed(&bench),
duration_kbps(&bench, count * size));
} else {
- command_print(CMD_CTX, "Compare failed");
+ command_print(CMD, "Compare failed");
binprint(CMD, "ref:", read_ref, num_bytes);
binprint(CMD, "buf:", read_buf, num_bytes);
}
return ERROR_COMMAND_SYNTAX_ERROR;
}
- command_print(CMD_CTX, "receiving debug messages from current target %s",
+ command_print(CMD, "receiving debug messages from current target %s",
(receiving) ? (charmsg_mode ? "charmsg" : "enabled") : "disabled");
return ERROR_OK;
}
uint32_t i;
for (i = 0; i < trace->num_trace_points; i++) {
- command_print(CMD_CTX, "trace point 0x%8.8" PRIx32 " (%lld times hit)",
+ command_print(CMD, "trace point 0x%8.8" PRIx32 " (%lld times hit)",
trace->trace_points[i].address,
(long long)trace->trace_points[i].hit_counter);
}
COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], trace->trace_history_size);
trace->trace_history = malloc(sizeof(uint32_t) * trace->trace_history_size);
- command_print(CMD_CTX, "new trace history size: %i", (int)(trace->trace_history_size));
+ command_print(CMD, "new trace history size: %i", (int)(trace->trace_history_size));
} else {
uint32_t i;
uint32_t first = 0;
uint32_t last = trace->trace_history_pos;
if (!trace->trace_history_size) {
- command_print(CMD_CTX, "trace history buffer is not allocated");
+ command_print(CMD, "trace history buffer is not allocated");
return ERROR_OK;
}
if (trace->trace_history[i % trace->trace_history_size] < trace->num_trace_points) {
uint32_t address;
address = trace->trace_points[trace->trace_history[i % trace->trace_history_size]].address;
- command_print(CMD_CTX, "trace point %i: 0x%8.8" PRIx32 "",
+ command_print(CMD, "trace point %i: 0x%8.8" PRIx32 "",
(int)(trace->trace_history[i % trace->trace_history_size]),
address);
} else
- command_print(CMD_CTX, "trace point %i: -not defined-",
+ command_print(CMD, "trace point %i: -not defined-",
(int)(trace->trace_history[i % trace->trace_history_size]));
}
}
value_fmt, value);
if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) {
- command_print(cmd->ctx, "%s", output);
+ command_print(cmd, "%s", output);
output_len = 0;
}
}
struct xscale_common *xscale)
{
if (xscale->common_magic != XSCALE_COMMON_MAGIC) {
- command_print(cmd->ctx, xscale_not);
+ command_print(cmd, xscale_not);
return ERROR_TARGET_INVALID;
}
return ERROR_OK;
{
int retval = xscale_read_instruction(target, pc, instruction);
if (retval == ERROR_OK)
- command_print(cmd->ctx, "%s", instruction->text);
+ command_print(cmd, "%s", instruction->text);
else
- command_print(cmd->ctx, "0x%8.8" PRIx32 "\t<not found in image>", pc);
+ command_print(cmd, "0x%8.8" PRIx32 "\t<not found in image>", pc);
}
static int xscale_analyze_trace(struct target *target, struct command_invocation *cmd)
continue;
if (exception) {
- command_print(cmd->ctx, "--- exception %i ---", exception);
+ command_print(cmd, "--- exception %i ---", exception);
continue;
}
}
if (current_pc == 0)
- command_print(cmd->ctx, "address unknown");
+ command_print(cmd, "address unknown");
continue;
}
return retval;
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+ command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
return ERROR_OK;
}
xscale->armv4_5_mmu.mmu_enabled = enable;
}
- command_print(CMD_CTX, "mmu %s",
+ command_print(CMD, "mmu %s",
(xscale->armv4_5_mmu.mmu_enabled) ? "enabled" : "disabled");
return ERROR_OK;
return retval;
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+ command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
return ERROR_OK;
}
xscale->armv4_5_mmu.armv4_5_cache.i_cache_enabled :
xscale->armv4_5_mmu.armv4_5_cache.d_u_cache_enabled;
const char *msg = enabled ? "enabled" : "disabled";
- command_print(CMD_CTX, "%s %s", CMD_NAME, msg);
+ command_print(CMD, "%s %s", CMD_NAME, msg);
return ERROR_OK;
}
dcsr_value = buf_get_u32(dcsr_reg->value, 0, 32);
for (unsigned i = 0; i < ARRAY_SIZE(vec_ids); i++) {
- command_print(CMD_CTX, "%15s: %s", vec_ids[i].name,
+ command_print(CMD, "%15s: %s", vec_ids[i].name,
(dcsr_value & vec_ids[i].mask) ? "catch" : "ignore");
}
if (CMD_ARGC == 0) { /* print current settings */
int idx;
- command_print(CMD_CTX, "active user-set static vectors:");
+ command_print(CMD, "active user-set static vectors:");
for (idx = 1; idx < 8; idx++)
if (xscale->static_low_vectors_set & (1 << idx))
- command_print(CMD_CTX,
+ command_print(CMD,
"low %d: 0x%" PRIx32,
idx,
xscale->static_low_vectors[idx]);
for (idx = 1; idx < 8; idx++)
if (xscale->static_high_vectors_set & (1 << idx))
- command_print(CMD_CTX,
+ command_print(CMD,
"high %d: 0x%" PRIx32,
idx,
xscale->static_high_vectors[idx]);
return retval;
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+ command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
return ERROR_OK;
}
if (CMD_ARGC >= 3)
COMMAND_PARSE_NUMBER(int, CMD_ARGV[2], buffcount);
if (buffcount < 1) { /* invalid */
- command_print(CMD_CTX, "fill buffer count must be > 0");
+ command_print(CMD, "fill buffer count must be > 0");
xscale->trace.mode = XSCALE_TRACE_DISABLED;
return ERROR_COMMAND_SYNTAX_ERROR;
}
if (xscale->trace.mode != XSCALE_TRACE_DISABLED) {
char fill_string[12];
sprintf(fill_string, "fill %d", xscale->trace.buffer_fill);
- command_print(CMD_CTX, "trace buffer enabled (%s)",
+ command_print(CMD, "trace buffer enabled (%s)",
(xscale->trace.mode == XSCALE_TRACE_FILL)
? fill_string : "wrap");
} else
- command_print(CMD_CTX, "trace buffer disabled");
+ command_print(CMD, "trace buffer disabled");
dcsr_value = buf_get_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 0, 32);
if (xscale->trace.mode == XSCALE_TRACE_FILL)
if (xscale->trace.image) {
image_close(xscale->trace.image);
free(xscale->trace.image);
- command_print(CMD_CTX, "previously loaded image found and closed");
+ command_print(CMD, "previously loaded image found and closed");
}
xscale->trace.image = malloc(sizeof(struct image));
return retval;
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+ command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
return ERROR_OK;
}
trace_data = xscale->trace.data;
if (!trace_data) {
- command_print(CMD_CTX, "no trace data collected");
+ command_print(CMD, "no trace data collected");
return ERROR_OK;
}
return retval;
if (target->state != TARGET_HALTED) {
- command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME);
+ command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME);
return ERROR_OK;
}
uint32_t reg_no = 0;
reg_no = XSCALE_CPACCESS;
break;
default:
- command_print(CMD_CTX, "invalid register number");
+ command_print(CMD, "invalid register number");
return ERROR_COMMAND_SYNTAX_ERROR;
}
reg = &xscale->reg_cache->reg_list[reg_no];
/* read cp15 control register */
xscale_get_reg(reg);
value = buf_get_u32(reg->value, 0, 32);
- command_print(CMD_CTX, "%s (/%i): 0x%" PRIx32 "", reg->name, (int)(reg->size),
+ command_print(CMD, "%s (/%i): 0x%" PRIx32 "", reg->name, (int)(reg->size),
value);
} else if (CMD_ARGC == 2) {
uint32_t value;
if (CMD_ARGC != 0)
return ERROR_COMMAND_SYNTAX_ERROR;
- command_print(CMD_CTX, "The following transports are available:");
+ command_print(CMD, "The following transports are available:");
for (struct transport *t = transport_list; t; t = t->next)
- command_print(CMD_CTX, "\t%s", t->name);
+ command_print(CMD, "\t%s", t->name);
return ERROR_OK;
}
if (strcmp(CMD_ARGV[0], "plain") != 0) {
tap = jtag_tap_by_string(CMD_ARGV[0]);
if (!tap) {
- command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[0]);
+ command_print(CMD, "Tap: %s unknown", CMD_ARGV[0]);
return ERROR_FAIL;
}
}
xsvf_fd = open(filename, O_RDONLY);
if (xsvf_fd < 0) {
- command_print(CMD_CTX, "file \"%s\" not found", filename);
+ command_print(CMD, "file \"%s\" not found", filename);
return ERROR_FAIL;
}
}
if (tdo_mismatch) {
- command_print(CMD_CTX,
+ command_print(CMD,
"TDO mismatch, somewhere near offset %lu in xsvf file, aborting",
file_offset);
if (unsupported) {
off_t offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1;
- command_print(CMD_CTX,
+ command_print(CMD,
"unsupported xsvf command (0x%02X) at offset %jd, aborting",
uc, (intmax_t)offset);
return ERROR_FAIL;
}
if (do_abort) {
- command_print(CMD_CTX, "premature end of xsvf file detected, aborting");
+ command_print(CMD, "premature end of xsvf file detected, aborting");
return ERROR_FAIL;
}
close(xsvf_fd);
- command_print(CMD_CTX, "XSVF file programmed successfully");
+ command_print(CMD, "XSVF file programmed successfully");
return ERROR_OK;
}
Code Review / openocd.git / commitdiff