return ERROR_OK;
}
-static int get_ambiqmicro_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_ambiqmicro_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct ambiqmicro_flash_bank *ambiqmicro_info = bank->driver_priv;
- int printed;
char *classname;
if (!ambiqmicro_info->probed) {
else
classname = ambiqmicroClassname[0];
- printed = snprintf(buf,
- buf_size,
- "\nAmbiq Micro information: Chip is "
+ command_print_sameline(cmd, "\nAmbiq Micro information: Chip is "
"class %d (%s) %s\n",
ambiqmicro_info->target_class,
classname,
ambiqmicro_info->target_name);
- if ((printed < 0))
- return ERROR_BUF_TOO_SMALL;
return ERROR_OK;
}
t = get_current_target(cmd->ctx);
if (!t) {
- command_print(cmd, "No current target?");
+ command_print_sameline(cmd, "No current target?\n");
return NULL;
}
if (!p) {
/* this should not happen */
/* the command is not registered until the chip is created? */
- command_print(cmd, "No SAM3 chips exist?");
+ command_print_sameline(cmd, "No SAM3 chips exist?\n");
return NULL;
}
return p;
p = p->next;
}
- command_print(cmd, "Cannot find SAM3 chip?");
+ command_print_sameline(cmd, "Cannot find SAM3 chip?\n");
return NULL;
}
t = get_current_target(cmd->ctx);
if (!t) {
- command_print(cmd, "No current target?");
+ command_print_sameline(cmd, "No current target?\n");
return NULL;
}
if (!p) {
/* this should not happen */
/* the command is not registered until the chip is created? */
- command_print(cmd, "No SAM4 chips exist?");
+ command_print_sameline(cmd, "No SAM4 chips exist?\n");
return NULL;
}
return p;
p = p->next;
}
- command_print(cmd, "Cannot find SAM4 chip?");
+ command_print_sameline(cmd, "Cannot find SAM4 chip?\n");
return NULL;
}
return ERROR_OK;
}
-static int sam4_info(struct flash_bank *bank, char *buf, int buf_size)
+static int sam4_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct sam4_bank_private *pPrivate;
int k = bank->size / 1024;
pPrivate = get_sam4_bank_private(bank);
- if (pPrivate == NULL) {
- buf[0] = '\0';
+ if (pPrivate == NULL)
return ERROR_FAIL;
- }
- snprintf(buf, buf_size,
- "%s bank %d: %d kB at " TARGET_ADDR_FMT,
+ command_print_sameline(cmd, "%s bank %d: %d kB at " TARGET_ADDR_FMT,
pPrivate->pChip->details.name,
pPrivate->bank_number,
k,
return ERROR_OK;
}
-static int get_at91sam7_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_at91sam7_info(struct flash_bank *bank, struct command_invocation *cmd)
{
- int printed;
struct at91sam7_flash_bank *at91sam7_info = bank->driver_priv;
if (at91sam7_info->cidr == 0)
return ERROR_FLASH_BANK_NOT_PROBED;
- printed = snprintf(buf, buf_size,
- "\n at91sam7 driver information: Chip is %s\n",
+ command_print_sameline(cmd, "\n at91sam7 driver information: Chip is %s\n",
at91sam7_info->target_name);
- buf += printed;
- buf_size -= printed;
-
- printed = snprintf(buf,
- buf_size,
+ command_print_sameline(cmd,
" Cidr: 0x%8.8" PRIx32 " | Arch: 0x%4.4x | Eproc: %s | Version: 0x%3.3x | "
"Flashsize: 0x%8.8" PRIx32 "\n",
at91sam7_info->cidr,
at91sam7_info->cidr_version,
bank->size);
- buf += printed;
- buf_size -= printed;
-
- printed = snprintf(buf, buf_size,
- " Master clock (estimated): %u KHz | External clock: %u KHz\n",
+ command_print_sameline(cmd,
+ " Master clock (estimated): %u kHz | External clock: %u kHz\n",
(unsigned)(at91sam7_info->mck_freq / 1000),
(unsigned)(at91sam7_info->ext_freq / 1000));
- buf += printed;
- buf_size -= printed;
-
- printed = snprintf(buf,
- buf_size,
+ command_print_sameline(cmd,
" Pagesize: %i bytes | Lockbits(%u): %i 0x%4.4x | Pages in lock region: %i\n",
at91sam7_info->pagesize,
bank->num_sectors,
at91sam7_info->num_lockbits_on,
at91sam7_info->lockbits,
- at91sam7_info->pages_per_sector*at91sam7_info->num_lockbits_on);
-
- buf += printed;
- buf_size -= printed;
+ at91sam7_info->pages_per_sector * at91sam7_info->num_lockbits_on);
- snprintf(buf, buf_size,
- " Securitybit: %i | Nvmbits(%i): %i 0x%1.1x\n",
+ command_print_sameline(cmd, " Securitybit: %i | Nvmbits(%i): %i 0x%1.1x\n",
at91sam7_info->securitybit, at91sam7_info->num_nvmbits,
at91sam7_info->num_nvmbits_on, at91sam7_info->nvmbits);
return ERROR_OK;
}
-static int get_ath79_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_ath79_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct ath79_flash_bank *ath79_info = bank->driver_priv;
if (!ath79_info->probed) {
- snprintf(buf, buf_size,
- "\nATH79 flash bank not probed yet\n");
+ command_print_sameline(cmd, "\nATH79 flash bank not probed yet\n");
return ERROR_OK;
}
- snprintf(buf, buf_size, "\nATH79 flash information:\n"
+ command_print_sameline(cmd, "\nATH79 flash information:\n"
" Device \'%s\' (ID 0x%08" PRIx32 ")\n",
ath79_info->dev->name, ath79_info->dev->device_id);
return ERROR_OK;
}
-static int samv_get_info(struct flash_bank *bank, char *buf, int buf_size)
+static int samv_get_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct samv_flash_bank *samv_info = bank->driver_priv;
if (!samv_info->probed) {
if (ERROR_OK != r)
return r;
}
- snprintf(buf, buf_size, "Cortex-M7 detected with %" PRIu32 " kB flash",
+ command_print_sameline(cmd, "Cortex-M7 detected with %" PRIu32 " kB flash\n",
bank->size / 1024);
return ERROR_OK;
}
return avrf_probe(bank);
}
-static int avrf_info(struct flash_bank *bank, char *buf, int buf_size)
+static int avrf_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct target *target = bank->target;
struct avr_common *avr = target->arch_info;
if (avr_info != NULL) {
/* chip found */
- snprintf(buf, buf_size, "%s - Rev: 0x%" PRIx32 "", avr_info->name,
+ command_print_sameline(cmd, "%s - Rev: 0x%" PRIx32 "", avr_info->name,
EXTRACT_VER(device_id));
return ERROR_OK;
} else {
/* chip not supported */
- snprintf(buf, buf_size, "Cannot identify target as a avr\n");
+ command_print_sameline(cmd, "Cannot identify target as a avr\n");
return ERROR_FLASH_OPERATION_FAILED;
}
}
}
/* This method must return a string displaying information about the bank */
-static int bluenrgx_get_info(struct flash_bank *bank, char *buf, int buf_size)
+static int bluenrgx_get_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct bluenrgx_flash_bank *bluenrgx_info = bank->driver_priv;
int mask_number, cut_number;
if (!bluenrgx_info->probed) {
int retval = bluenrgx_probe(bank);
if (retval != ERROR_OK) {
- snprintf(buf, buf_size,
- "Unable to find bank information.");
+ command_print_sameline(cmd, "Unable to find bank information.");
return retval;
}
}
mask_number = (bluenrgx_info->die_id >> 4) & 0xF;
cut_number = bluenrgx_info->die_id & 0xF;
- snprintf(buf, buf_size,
- "%s - Rev: %d.%d", bluenrgx_info->flash_ptr->part_name, mask_number, cut_number);
+ command_print_sameline(cmd, "%s - Rev: %d.%d",
+ bluenrgx_info->flash_ptr->part_name, mask_number, cut_number);
return ERROR_OK;
}
return retval;
}
-static int cc26xx_info(struct flash_bank *bank, char *buf, int buf_size)
+static int cc26xx_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct cc26xx_bank *cc26xx_bank = bank->driver_priv;
- int printed = 0;
const char *device;
switch (cc26xx_bank->device_type) {
break;
}
- printed = snprintf(buf, buf_size,
+ command_print_sameline(cmd,
"%s device: ICEPick ID 0x%08" PRIx32 ", USER ID 0x%08" PRIx32 "\n",
device, cc26xx_bank->icepick_id, cc26xx_bank->user_id);
- if (printed >= buf_size)
- return ERROR_BUF_TOO_SMALL;
-
return ERROR_OK;
}
return retval;
}
-static int cc3220sf_info(struct flash_bank *bank, char *buf, int buf_size)
+static int cc3220sf_info(struct flash_bank *bank, struct command_invocation *cmd)
{
- int printed;
-
- printed = snprintf(buf, buf_size, "CC3220SF with 1MB internal flash\n");
-
- if (printed >= buf_size)
- return ERROR_BUF_TOO_SMALL;
-
+ command_print_sameline(cmd, "CC3220SF with 1MB internal flash\n");
return ERROR_OK;
}
return cfi_read_spansion_pri_ext(bank);
}
-static int cfi_spansion_info(struct flash_bank *bank, char *buf, int buf_size)
+static int cfi_spansion_info(struct flash_bank *bank, struct command_invocation *cmd)
{
- int printed;
struct cfi_flash_bank *cfi_info = bank->driver_priv;
struct cfi_spansion_pri_ext *pri_ext = cfi_info->pri_ext;
- printed = snprintf(buf, buf_size, "\nSpansion primary algorithm extend information:\n");
- buf += printed;
- buf_size -= printed;
+ command_print_sameline(cmd, "\nSpansion primary algorithm extend information:\n");
- printed = snprintf(buf, buf_size, "pri: '%c%c%c', version: %c.%c\n", pri_ext->pri[0],
- pri_ext->pri[1], pri_ext->pri[2],
+ command_print_sameline(cmd, "pri: '%c%c%c', version: %c.%c\n",
+ pri_ext->pri[0], pri_ext->pri[1], pri_ext->pri[2],
pri_ext->major_version, pri_ext->minor_version);
- buf += printed;
- buf_size -= printed;
- printed = snprintf(buf, buf_size, "Silicon Rev.: 0x%x, Address Sensitive unlock: 0x%x\n",
+ command_print_sameline(cmd, "Silicon Rev.: 0x%x, Address Sensitive unlock: 0x%x\n",
(pri_ext->SiliconRevision) >> 2,
(pri_ext->SiliconRevision) & 0x03);
- buf += printed;
- buf_size -= printed;
- printed = snprintf(buf, buf_size, "Erase Suspend: 0x%x, Sector Protect: 0x%x\n",
+ command_print_sameline(cmd, "Erase Suspend: 0x%x, Sector Protect: 0x%x\n",
pri_ext->EraseSuspend,
pri_ext->BlkProt);
- buf += printed;
- buf_size -= printed;
- snprintf(buf, buf_size, "VppMin: %u.%x, VppMax: %u.%x\n",
+ command_print_sameline(cmd, "VppMin: %u.%x, VppMax: %u.%x\n",
(pri_ext->VppMin & 0xf0) >> 4, pri_ext->VppMin & 0x0f,
(pri_ext->VppMax & 0xf0) >> 4, pri_ext->VppMax & 0x0f);
return ERROR_OK;
}
-static int cfi_intel_info(struct flash_bank *bank, char *buf, int buf_size)
+static int cfi_intel_info(struct flash_bank *bank, struct command_invocation *cmd)
{
- int printed;
struct cfi_flash_bank *cfi_info = bank->driver_priv;
struct cfi_intel_pri_ext *pri_ext = cfi_info->pri_ext;
- printed = snprintf(buf, buf_size, "\nintel primary algorithm extend information:\n");
- buf += printed;
- buf_size -= printed;
+ command_print_sameline(cmd, "\nintel primary algorithm extend information:\n");
- printed = snprintf(buf,
- buf_size,
- "pri: '%c%c%c', version: %c.%c\n",
+ command_print_sameline(cmd, "pri: '%c%c%c', version: %c.%c\n",
pri_ext->pri[0],
pri_ext->pri[1],
pri_ext->pri[2],
pri_ext->major_version,
pri_ext->minor_version);
- buf += printed;
- buf_size -= printed;
- printed = snprintf(buf,
- buf_size,
- "feature_support: 0x%" PRIx32 ", "
+ command_print_sameline(cmd, "feature_support: 0x%" PRIx32 ", "
"suspend_cmd_support: 0x%x, blk_status_reg_mask: 0x%x\n",
pri_ext->feature_support,
pri_ext->suspend_cmd_support,
pri_ext->blk_status_reg_mask);
- buf += printed;
- buf_size -= printed;
- printed = snprintf(buf, buf_size, "Vcc opt: %x.%x, Vpp opt: %u.%x\n",
+ command_print_sameline(cmd, "Vcc opt: %x.%x, Vpp opt: %u.%x\n",
(pri_ext->vcc_optimal & 0xf0) >> 4, pri_ext->vcc_optimal & 0x0f,
(pri_ext->vpp_optimal & 0xf0) >> 4, pri_ext->vpp_optimal & 0x0f);
- buf += printed;
- buf_size -= printed;
- snprintf(buf, buf_size, "protection_fields: %i, prot_reg_addr: 0x%x, "
+ command_print_sameline(cmd, "protection_fields: %i, prot_reg_addr: 0x%x, "
"factory pre-programmed: %i, user programmable: %i\n",
pri_ext->num_protection_fields, pri_ext->prot_reg_addr,
1 << pri_ext->fact_prot_reg_size, 1 << pri_ext->user_prot_reg_size);
return ERROR_OK;
}
-int cfi_get_info(struct flash_bank *bank, char *buf, int buf_size)
+int cfi_get_info(struct flash_bank *bank, struct command_invocation *cmd)
{
- int printed;
struct cfi_flash_bank *cfi_info = bank->driver_priv;
if (cfi_info->qry[0] == 0xff) {
- snprintf(buf, buf_size, "\ncfi flash bank not probed yet\n");
+ command_print_sameline(cmd, "\ncfi flash bank not probed yet\n");
return ERROR_OK;
}
if (!cfi_info->not_cfi)
- printed = snprintf(buf, buf_size, "\nCFI flash: ");
+ command_print_sameline(cmd, "\nCFI flash: ");
else
- printed = snprintf(buf, buf_size, "\nnon-CFI flash: ");
- buf += printed;
- buf_size -= printed;
+ command_print_sameline(cmd, "\nnon-CFI flash: ");
- printed = snprintf(buf, buf_size, "mfr: 0x%4.4x, id:0x%4.4x\n\n",
+ command_print_sameline(cmd, "mfr: 0x%4.4x, id:0x%4.4x\n",
cfi_info->manufacturer, cfi_info->device_id);
- buf += printed;
- buf_size -= printed;
- printed = snprintf(buf, buf_size, "qry: '%c%c%c', pri_id: 0x%4.4x, pri_addr: "
+ command_print_sameline(cmd, "qry: '%c%c%c', pri_id: 0x%4.4x, pri_addr: "
"0x%4.4x, alt_id: 0x%4.4x, alt_addr: 0x%4.4x\n",
cfi_info->qry[0], cfi_info->qry[1], cfi_info->qry[2],
cfi_info->pri_id, cfi_info->pri_addr, cfi_info->alt_id, cfi_info->alt_addr);
- buf += printed;
- buf_size -= printed;
- printed = snprintf(buf, buf_size, "Vcc min: %x.%x, Vcc max: %x.%x, "
+ command_print_sameline(cmd, "Vcc min: %x.%x, Vcc max: %x.%x, "
"Vpp min: %u.%x, Vpp max: %u.%x\n",
(cfi_info->vcc_min & 0xf0) >> 4, cfi_info->vcc_min & 0x0f,
(cfi_info->vcc_max & 0xf0) >> 4, cfi_info->vcc_max & 0x0f,
(cfi_info->vpp_min & 0xf0) >> 4, cfi_info->vpp_min & 0x0f,
(cfi_info->vpp_max & 0xf0) >> 4, cfi_info->vpp_max & 0x0f);
- buf += printed;
- buf_size -= printed;
- printed = snprintf(buf, buf_size, "typ. word write timeout: %u us, "
+ command_print_sameline(cmd, "typ. word write timeout: %u us, "
"typ. buf write timeout: %u us, "
"typ. block erase timeout: %u ms, "
"typ. chip erase timeout: %u ms\n",
1 << cfi_info->buf_write_timeout_typ,
1 << cfi_info->block_erase_timeout_typ,
1 << cfi_info->chip_erase_timeout_typ);
- buf += printed;
- buf_size -= printed;
- printed = snprintf(buf,
- buf_size,
- "max. word write timeout: %u us, "
+ command_print_sameline(cmd, "max. word write timeout: %u us, "
"max. buf write timeout: %u us, max. "
"block erase timeout: %u ms, max. chip erase timeout: %u ms\n",
(1 <<
(1 <<
cfi_info->chip_erase_timeout_max) *
(1 << cfi_info->chip_erase_timeout_typ));
- buf += printed;
- buf_size -= printed;
- printed = snprintf(buf, buf_size, "size: 0x%" PRIx32 ", interface desc: %i, "
+ command_print_sameline(cmd, "size: 0x%" PRIx32 ", interface desc: %i, "
"max buffer write size: 0x%x\n",
cfi_info->dev_size,
cfi_info->interface_desc,
1 << cfi_info->max_buf_write_size);
- buf += printed;
- buf_size -= printed;
switch (cfi_info->pri_id) {
case 1:
case 3:
- cfi_intel_info(bank, buf, buf_size);
+ cfi_intel_info(bank, cmd);
break;
case 2:
- cfi_spansion_info(bank, buf, buf_size);
+ cfi_spansion_info(bank, cmd);
break;
default:
LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
int cfi_probe(struct flash_bank *bank);
int cfi_auto_probe(struct flash_bank *bank);
int cfi_protect_check(struct flash_bank *bank);
-int cfi_get_info(struct flash_bank *bank, char *buf, int buf_size);
+int cfi_get_info(struct flash_bank *bank, struct command_invocation *cmd);
int cfi_flash_bank_cmd(struct flash_bank *bank, unsigned int argc, const char **argv);
uint32_t cfi_flash_address(struct flash_bank *bank, int sector, uint32_t offset);
/**
* Display human-readable information about the flash
- * bank into the given buffer. Drivers must be careful to avoid
- * overflowing the buffer.
+ * bank.
*
* @param bank - the bank to get info about
- * @param char - where to put the text for the human to read
- * @param buf_size - the size of the human buffer.
+ * @param cmd - command invocation instance for which to generate
+ * the textual output
* @returns ERROR_OK if successful; otherwise, an error code.
*/
- int (*info)(struct flash_bank *bank, char *buf, int buf_size);
+ int (*info)(struct flash_bank *bank, struct command_invocation *cmd);
/**
* A more gentle flavor of flash_driver_s::probe, performing
return ERROR_OK;
}
-/*
- * Helper to create a human friendly string describing a part
- */
-static int efm32x_decode_info(struct efm32_info *info, char *buf, int buf_size)
-{
- int printed = 0;
- printed = snprintf(buf, buf_size, "%s Gecko, rev %d",
- info->family_data->name, info->prod_rev);
-
- if (printed >= buf_size)
- return ERROR_BUF_TOO_SMALL;
-
- return ERROR_OK;
-}
-
-/* flash bank efm32 <base> <size> 0 0 <target#>
- */
+/* flash bank efm32 <base> <size> 0 0 <target#> */
FLASH_BANK_COMMAND_HANDLER(efm32x_flash_bank_command)
{
struct efm32x_flash_bank *efm32x_info;
struct efm32_info efm32_mcu_info;
int ret;
uint32_t base_address = 0x00000000;
- char buf[256];
efm32x_info->probed = false;
memset(efm32x_info->lb_page, 0xff, LOCKBITS_PAGE_SZ);
if (ERROR_OK != ret)
return ret;
- ret = efm32x_decode_info(&efm32_mcu_info, buf, sizeof(buf));
- if (ERROR_OK != ret)
- return ret;
-
- LOG_INFO("detected part: %s", buf);
+ LOG_INFO("detected part: %s Gecko, rev %d",
+ efm32_mcu_info.family_data->name, efm32_mcu_info.prod_rev);
LOG_INFO("flash size = %dkbytes", efm32_mcu_info.flash_sz_kib);
LOG_INFO("flash page size = %dbytes", efm32_mcu_info.page_size);
return ERROR_OK;
}
-static int get_efm32x_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_efm32x_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct efm32_info info;
- int ret = 0;
+ int ret;
ret = efm32x_read_info(bank, &info);
if (ERROR_OK != ret) {
return ret;
}
- return efm32x_decode_info(&info, buf, buf_size);
+ command_print_sameline(cmd, "%s Gecko, rev %d", info.family_data->name, info.prod_rev);
+ return ERROR_OK;
}
COMMAND_HANDLER(efm32x_handle_debuglock_command)
return esirisc_flash_probe(bank);
}
-static int esirisc_flash_info(struct flash_bank *bank, char *buf, int buf_size)
+static int esirisc_flash_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct esirisc_flash_bank *esirisc_info = bank->driver_priv;
- snprintf(buf, buf_size,
+ command_print_sameline(cmd,
"%4s cfg at 0x%" PRIx32 ", clock %" PRIu32 ", wait_states %" PRIu32,
"", /* align with first line */
esirisc_info->cfg,
return ERROR_OK;
}
-static int faux_info(struct flash_bank *bank, char *buf, int buf_size)
+static int faux_info(struct flash_bank *bank, struct command_invocation *cmd)
{
- snprintf(buf, buf_size, "faux flash driver");
+ command_print_sameline(cmd, "faux flash driver");
return ERROR_OK;
}
return ERROR_OK;
}
-static int get_fespi_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_fespi_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct fespi_flash_bank *fespi_info = bank->driver_priv;
if (!(fespi_info->probed)) {
- snprintf(buf, buf_size,
- "\nFESPI flash bank not probed yet\n");
+ command_print_sameline(cmd, "\nFESPI flash bank not probed yet\n");
return ERROR_OK;
}
- snprintf(buf, buf_size, "\nFESPI flash information:\n"
+ command_print_sameline(cmd, "\nFESPI flash information:\n"
" Device \'%s\' (ID 0x%08" PRIx32 ")\n",
fespi_info->dev->name, fespi_info->dev->device_id);
return fm4_probe(bank);
}
-static int fm4_get_info_command(struct flash_bank *bank, char *buf, int buf_size)
+static int fm4_get_info_command(struct flash_bank *bank, struct command_invocation *cmd)
{
struct fm4_flash_bank *fm4_bank = bank->driver_priv;
const char *name;
case s6e2cx8:
case s6e2cx9:
case s6e2cxa:
- snprintf(buf, buf_size, "%s MainFlash Macro #%i",
- name, fm4_bank->macro_nr);
+ command_print_sameline(cmd, "%s MainFlash Macro #%i", name, fm4_bank->macro_nr);
break;
default:
- snprintf(buf, buf_size, "%s MainFlash", name);
+ command_print_sameline(cmd, "%s MainFlash", name);
break;
}
return ERROR_OK;
}
-static int jtagspi_info(struct flash_bank *bank, char *buf, int buf_size)
+static int jtagspi_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct jtagspi_flash_bank *info = bank->driver_priv;
if (!(info->probed)) {
- snprintf(buf, buf_size, "\nJTAGSPI flash bank not probed yet\n");
+ command_print_sameline(cmd, "\nJTAGSPI flash bank not probed yet\n");
return ERROR_OK;
}
- snprintf(buf, buf_size, "\nSPIFI flash information:\n"
+ command_print_sameline(cmd, "\nSPIFI flash information:\n"
" Device \'%s\' (ID 0x%08" PRIx32 ")\n",
info->dev->name, info->dev->device_id);
return kinetis_probe(bank);
}
-static int kinetis_info(struct flash_bank *bank, char *buf, int buf_size)
+static int kinetis_info(struct flash_bank *bank, struct command_invocation *cmd)
{
const char *bank_class_names[] = {
"(ANY)", "PFlash", "FlexNVM", "FlexRAM"
struct kinetis_chip *k_chip = k_bank->k_chip;
uint32_t size_k = bank->size / 1024;
- snprintf(buf, buf_size,
+ command_print_sameline(cmd,
"%s %s: %" PRIu32 "k %s bank %s at " TARGET_ADDR_FMT,
bank->driver->name, k_chip->name,
size_k, bank_class_names[k_bank->flash_class],
return kinetis_ke_probe(bank);
}
-static int kinetis_ke_info(struct flash_bank *bank, char *buf, int buf_size)
+static int kinetis_ke_info(struct flash_bank *bank, struct command_invocation *cmd)
{
- (void) snprintf(buf, buf_size,
- "%s driver for flash bank %s at " TARGET_ADDR_FMT,
+ command_print_sameline(cmd, "%s driver for flash bank %s at " TARGET_ADDR_FMT,
bank->driver->name, bank->name, bank->base);
return ERROR_OK;
return lpc2000_iap_blank_check(bank, 0, bank->num_sectors - 1);
}
-static int get_lpc2000_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_lpc2000_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
- snprintf(buf, buf_size, "lpc2000 flash driver variant: %i, clk: %" PRIu32 "kHz", lpc2000_info->variant,
- lpc2000_info->cclk);
+ command_print_sameline(cmd, "lpc2000 flash driver variant: %i, clk: %" PRIu32 "kHz",
+ lpc2000_info->variant, lpc2000_info->cclk);
return ERROR_OK;
}
return ERROR_OK;
}
-static int get_lpcspifi_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_lpcspifi_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct lpcspifi_flash_bank *lpcspifi_info = bank->driver_priv;
if (!(lpcspifi_info->probed)) {
- snprintf(buf, buf_size,
- "\nSPIFI flash bank not probed yet\n");
+ command_print_sameline(cmd, "\nSPIFI flash bank not probed yet\n");
return ERROR_OK;
}
- snprintf(buf, buf_size, "\nSPIFI flash information:\n"
+ command_print_sameline(cmd, "\nSPIFI flash information:\n"
" Device \'%s\' (ID 0x%08" PRIx32 ")\n",
lpcspifi_info->dev->name, lpcspifi_info->dev->device_id);
return ERROR_OK;
}
-static int get_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_info(struct flash_bank *bank, struct command_invocation *cmd)
{
- int printed;
struct max32xxx_flash_bank *info = bank->driver_priv;
if (!info->probed)
return ERROR_FLASH_BANK_NOT_PROBED;
- printed = snprintf(buf, buf_size, "\nMaxim Integrated max32xxx flash driver\n");
- buf += printed;
- buf_size -= printed;
+ command_print_sameline(cmd, "\nMaxim Integrated max32xxx flash driver\n");
return ERROR_OK;
}
return mdr_probe(bank);
}
-static int get_mdr_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_mdr_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct mdr_flash_bank *mdr_info = bank->driver_priv;
- snprintf(buf, buf_size, "MDR32Fx - %s",
- mdr_info->mem_type ? "info memory" : "main memory");
+ command_print_sameline(cmd, "MDR32Fx - %s",
+ mdr_info->mem_type ? "info memory" : "main memory");
return ERROR_OK;
}
return ERROR_OK;
}
-static int mrvlqspi_get_info(struct flash_bank *bank, char *buf, int buf_size)
+static int mrvlqspi_get_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct mrvlqspi_flash_bank *mrvlqspi_info = bank->driver_priv;
if (!(mrvlqspi_info->probed)) {
- snprintf(buf, buf_size,
- "\nQSPI flash bank not probed yet\n");
+ command_print_sameline(cmd, "\nQSPI flash bank not probed yet\n");
return ERROR_OK;
}
- snprintf(buf, buf_size, "\nQSPI flash information:\n"
+ command_print_sameline(cmd, "\nQSPI flash information:\n"
" Device \'%s\' ID 0x%08" PRIx32 "\n",
mrvlqspi_info->dev->name, mrvlqspi_info->dev->device_id);
return retval;
}
-static int msp432_info(struct flash_bank *bank, char *buf, int buf_size)
+static int msp432_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct msp432_bank *msp432_bank = bank->driver_priv;
- int printed = 0;
switch (msp432_bank->device_type) {
case MSP432P401X_DEPR:
if (0xFFFF == msp432_bank->device_id) {
/* Very early pre-production silicon currently deprecated */
- printed = snprintf(buf, buf_size,
- "MSP432P401x pre-production device (deprecated silicon)\n"
+ command_print_sameline(cmd, "MSP432P401x pre-production device (deprecated silicon)\n"
SUPPORT_MESSAGE);
} else {
/* Revision A or B silicon, also deprecated */
- printed = snprintf(buf, buf_size,
- "MSP432P401x Device Rev %c (deprecated silicon)\n"
+ command_print_sameline(cmd, "MSP432P401x Device Rev %c (deprecated silicon)\n"
SUPPORT_MESSAGE, (char)msp432_bank->hardware_rev);
}
break;
case MSP432P401X:
- printed = snprintf(buf, buf_size,
- "MSP432P401x Device Rev %c\n",
+ command_print_sameline(cmd, "MSP432P401x Device Rev %c\n",
(char)msp432_bank->hardware_rev);
break;
case MSP432P411X:
- printed = snprintf(buf, buf_size,
- "MSP432P411x Device Rev %c\n",
+ command_print_sameline(cmd, "MSP432P411x Device Rev %c\n",
(char)msp432_bank->hardware_rev);
break;
case MSP432E401Y:
- printed = snprintf(buf, buf_size, "MSP432E401Y Device\n");
+ command_print_sameline(cmd, "MSP432E401Y Device\n");
break;
case MSP432E411Y:
- printed = snprintf(buf, buf_size, "MSP432E411Y Device\n");
+ command_print_sameline(cmd, "MSP432E411Y Device\n");
break;
case MSP432E4X_GUESS:
- printed = snprintf(buf, buf_size,
+ command_print_sameline(cmd,
"Unrecognized MSP432E4 DID0 and DID1 IDs (%08" PRIX32 ", %08" PRIX32 ")",
msp432_bank->device_id, msp432_bank->hardware_rev);
break;
case MSP432P401X_GUESS:
case MSP432P411X_GUESS:
default:
- printed = snprintf(buf, buf_size,
+ command_print_sameline(cmd,
"Unrecognized MSP432P4 Device ID and Hardware Rev (%04" PRIX32 ", %02" PRIX32 ")",
msp432_bank->device_id, msp432_bank->hardware_rev);
break;
}
- buf_size -= printed;
-
- if (0 > buf_size)
- return ERROR_BUF_TOO_SMALL;
-
return ERROR_OK;
}
return niietcm4_probe(bank);
}
-static int get_niietcm4_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_niietcm4_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct niietcm4_flash_bank *niietcm4_info = bank->driver_priv;
- LOG_INFO("\nNIIET Cortex-M4F %s\n%s", niietcm4_info->chip_name, niietcm4_info->chip_brief);
- snprintf(buf, buf_size, " ");
-
+ command_print_sameline(cmd, "\nNIIET Cortex-M4F %s\n%s",
+ niietcm4_info->chip_name, niietcm4_info->chip_brief);
return ERROR_OK;
}
return "xx";
}
-static int nrf5_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_nrf5_chip_type_str(const struct nrf5_info *chip, char *buf, unsigned int buf_size)
{
- struct nrf5_bank *nbank = bank->driver_priv;
- struct nrf5_info *chip = nbank->chip;
int res;
-
if (chip->spec) {
- res = snprintf(buf, buf_size,
- "nRF%s-%s(build code: %s)",
+ res = snprintf(buf, buf_size, "nRF%s-%s(build code: %s)",
chip->spec->part, chip->spec->variant, chip->spec->build_code);
-
} else if (chip->ficr_info_valid) {
char variant[5];
nrf5_info_variant_to_str(chip->ficr_info.variant, variant);
- res = snprintf(buf, buf_size,
- "nRF%" PRIx32 "-%s%.2s(build code: %s)",
+ res = snprintf(buf, buf_size, "nRF%" PRIx32 "-%s%.2s(build code: %s)",
chip->ficr_info.part,
nrf5_decode_info_package(chip->ficr_info.package),
variant, &variant[2]);
-
} else {
- res = snprintf(buf, buf_size, "nRF51xxx (HWID 0x%04" PRIx16 ")",
- chip->hwid);
+ res = snprintf(buf, buf_size, "nRF51xxx (HWID 0x%04" PRIx16 ")", chip->hwid);
}
- if (res <= 0)
+
+ /* safety: */
+ if (res <= 0 || (unsigned int)res >= buf_size) {
+ LOG_ERROR("BUG: buffer problem in %s", __func__);
return ERROR_FAIL;
+ }
+ return ERROR_OK;
+}
- snprintf(buf + res, buf_size - res, " %ukB Flash, %ukB RAM",
- chip->flash_size_kb, chip->ram_size_kb);
+static int nrf5_info(struct flash_bank *bank, struct command_invocation *cmd)
+{
+ struct nrf5_bank *nbank = bank->driver_priv;
+ struct nrf5_info *chip = nbank->chip;
+
+ char chip_type_str[256];
+ if (get_nrf5_chip_type_str(chip, chip_type_str, sizeof(chip_type_str)) != ERROR_OK)
+ return ERROR_FAIL;
+
+ command_print_sameline(cmd, "%s %ukB Flash, %ukB RAM",
+ chip_type_str, chip->flash_size_kb, chip->ram_size_kb);
return ERROR_OK;
}
chip->flash_size_kb = num_sectors * flash_page_size / 1024;
if (!chip->bank[0].probed && !chip->bank[1].probed) {
- char buf[80];
- nrf5_info(bank, buf, sizeof(buf));
- if (!chip->spec && !chip->ficr_info_valid) {
- LOG_INFO("Unknown device: %s", buf);
- } else {
- LOG_INFO("%s", buf);
- }
+ char chip_type_str[256];
+ if (get_nrf5_chip_type_str(chip, chip_type_str, sizeof(chip_type_str)) != ERROR_OK)
+ return ERROR_FAIL;
+ const bool device_is_unknown = (!chip->spec && !chip->ficr_info_valid);
+ LOG_INFO("%s%s %ukB Flash, %ukB RAM",
+ device_is_unknown ? "Unknown device: " : "",
+ chip_type_str,
+ chip->flash_size_kb,
+ chip->ram_size_kb);
}
free(bank->sectors);
return pic32mx_probe(bank);
}
-static int pic32mx_info(struct flash_bank *bank, char *buf, int buf_size)
+static int pic32mx_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct target *target = bank->target;
struct mips32_common *mips32 = target->arch_info;
struct mips_ejtag *ejtag_info = &mips32->ejtag_info;
uint32_t device_id;
- int printed = 0, i;
device_id = ejtag_info->idcode;
if (((device_id >> 1) & 0x7ff) != PIC32MX_MANUF_ID) {
- snprintf(buf, buf_size,
- "Cannot identify target as a PIC32MX family (manufacturer 0x%03x != 0x%03x)\n",
- (unsigned)((device_id >> 1) & 0x7ff),
- PIC32MX_MANUF_ID);
+ command_print_sameline(cmd,
+ "Cannot identify target as a PIC32MX family (manufacturer 0x%03x != 0x%03x)\n",
+ (unsigned)((device_id >> 1) & 0x7ff),
+ PIC32MX_MANUF_ID);
return ERROR_FLASH_OPERATION_FAILED;
}
+ int i;
for (i = 0; pic32mx_devs[i].name != NULL; i++) {
if (pic32mx_devs[i].devid == (device_id & 0x0fffffff)) {
- printed = snprintf(buf, buf_size, "PIC32MX%s", pic32mx_devs[i].name);
+ command_print_sameline(cmd, "PIC32MX%s", pic32mx_devs[i].name);
break;
}
}
if (pic32mx_devs[i].name == NULL)
- printed = snprintf(buf, buf_size, "Unknown");
+ command_print_sameline(cmd, "Unknown");
- buf += printed;
- buf_size -= printed;
- snprintf(buf, buf_size, " Ver: 0x%02x",
+ command_print_sameline(cmd, " Ver: 0x%02x",
(unsigned)((device_id >> 28) & 0xf));
return ERROR_OK;
}
-static int get_psoc4_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_psoc4_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct target *target = bank->target;
struct psoc4_flash_bank *psoc4_info = bank->driver_priv;
uint32_t size_in_kb = bank->size / 1024;
if (target->state != TARGET_HALTED) {
- snprintf(buf, buf_size, "%s, flash %" PRIu32 " kb"
+ command_print_sameline(cmd, "%s, flash %" PRIu32 " kb"
" (halt target to see details)", family->name, size_in_kb);
return ERROR_OK;
}
- int retval;
- int printed = 0;
uint32_t silicon_id;
uint16_t family_id;
uint8_t protection;
- retval = psoc4_get_silicon_id(bank, &silicon_id, &family_id, &protection);
+ int retval = psoc4_get_silicon_id(bank, &silicon_id, &family_id, &protection);
if (retval != ERROR_OK)
return retval;
if (family_id != psoc4_info->family_id)
- printed = snprintf(buf, buf_size, "Family id mismatch 0x%02" PRIx16
+ command_print_sameline(cmd, "Family id mismatch 0x%02" PRIx16
"/0x%02" PRIx16 ", silicon id 0x%08" PRIx32,
psoc4_info->family_id, family_id, silicon_id);
else {
- printed = snprintf(buf, buf_size, "%s silicon id 0x%08" PRIx32 "",
+ command_print_sameline(cmd, "%s silicon id 0x%08" PRIx32 "",
family->name, silicon_id);
}
- buf += printed;
- buf_size -= printed;
-
const char *prot_txt = psoc4_decode_chip_protection(protection);
- snprintf(buf, buf_size, ", flash %" PRIu32 " kb %s", size_in_kb, prot_txt);
+ command_print_sameline(cmd, ", flash %" PRIu32 " kb %s", size_in_kb, prot_txt);
return ERROR_OK;
}
}
static int psoc5lp_nvl_get_info_command(struct flash_bank *bank,
- char *buf, int buf_size)
+ struct command_invocation *cmd)
{
struct psoc5lp_nvl_flash_bank *psoc_nvl_bank = bank->driver_priv;
char part_number[PART_NUMBER_LEN];
psoc5lp_get_part_number(psoc_nvl_bank->device, part_number);
- snprintf(buf, buf_size, "%s", part_number);
+ command_print_sameline(cmd, "%s", part_number);
return ERROR_OK;
}
return ERROR_OK;
}
-static int psoc5lp_eeprom_get_info_command(struct flash_bank *bank, char *buf, int buf_size)
+static int psoc5lp_eeprom_get_info_command(struct flash_bank *bank, struct command_invocation *cmd)
{
struct psoc5lp_eeprom_flash_bank *psoc_eeprom_bank = bank->driver_priv;
char part_number[PART_NUMBER_LEN];
psoc5lp_get_part_number(psoc_eeprom_bank->device, part_number);
- snprintf(buf, buf_size, "%s", part_number);
+ command_print_sameline(cmd, "%s", part_number);
return ERROR_OK;
}
return ERROR_OK;
}
-static int psoc5lp_get_info_command(struct flash_bank *bank, char *buf, int buf_size)
+static int psoc5lp_get_info_command(struct flash_bank *bank, struct command_invocation *cmd)
{
struct psoc5lp_flash_bank *psoc_bank = bank->driver_priv;
char part_number[PART_NUMBER_LEN];
psoc5lp_get_part_number(psoc_bank->device, part_number);
ecc = psoc_bank->ecc_enabled ? "ECC enabled" : "ECC disabled";
- snprintf(buf, buf_size, "%s %s", part_number, ecc);
+ command_print_sameline(cmd, "%s %s", part_number, ecc);
return ERROR_OK;
}
* @param buf_size size of the buffer
* @return ERROR_OK in case of success, ERROR_XXX code otherwise
*************************************************************************************************/
-static int psoc6_get_info(struct flash_bank *bank, char *buf, int buf_size)
+static int psoc6_get_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct psoc6_target_info *psoc6_info = bank->driver_priv;
if (hr != ERROR_OK)
return hr;
- snprintf(buf, buf_size,
+ command_print_sameline(cmd,
"PSoC6 Silicon ID: 0x%08" PRIX32 "\n"
"Protection: %s\n"
"Main Flash size: %" PRIu32 " kB\n"
return ERROR_OK;
}
-static int sh_qspi_get_info(struct flash_bank *bank, char *buf, int buf_size)
+static int sh_qspi_get_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct sh_qspi_flash_bank *info = bank->driver_priv;
if (!info->probed) {
- snprintf(buf, buf_size,
- "\nSH QSPI flash bank not probed yet\n");
+ command_print_sameline(cmd, "\nSH QSPI flash bank not probed yet\n");
return ERROR_OK;
}
- snprintf(buf, buf_size, "\nSH QSPI flash information:\n"
+ command_print_sameline(cmd, "\nSH QSPI flash information:\n"
" Device \'%s\' (ID 0x%08" PRIx32 ")\n",
info->dev->name, info->dev->device_id);
}
}
-static int sim3x_flash_info(struct flash_bank *bank, char *buf, int buf_size)
+static int sim3x_flash_info(struct flash_bank *bank, struct command_invocation *cmd)
{
- int ret;
- int printed = 0;
struct sim3x_info *sim3x_info;
sim3x_info = bank->driver_priv;
/* Read info about chip */
- ret = sim3x_read_info(bank);
+ int ret = sim3x_read_info(bank);
if (ret != ERROR_OK)
return ret;
/* Part */
if (sim3x_info->part_family && sim3x_info->part_number) {
- printed = snprintf(buf, buf_size, "SiM3%c%d", sim3x_info->part_family, sim3x_info->part_number);
- buf += printed;
- buf_size -= printed;
-
- if (buf_size <= 0)
- return ERROR_BUF_TOO_SMALL;
+ command_print_sameline(cmd, "SiM3%c%d", sim3x_info->part_family, sim3x_info->part_number);
/* Revision */
if (sim3x_info->device_revision && sim3x_info->device_revision <= 'Z' - 'A') {
- printed = snprintf(buf, buf_size, "-%c", sim3x_info->device_revision + 'A');
- buf += printed;
- buf_size -= printed;
-
- if (buf_size <= 0)
- return ERROR_BUF_TOO_SMALL;
+ command_print_sameline(cmd, "-%c", sim3x_info->device_revision + 'A');
/* Package */
- printed = snprintf(buf, buf_size, "-G%s", sim3x_info->device_package);
- buf += printed;
- buf_size -= printed;
-
- if (buf_size <= 0)
- return ERROR_BUF_TOO_SMALL;
+ command_print_sameline(cmd, "-G%s", sim3x_info->device_package);
}
}
/* Print flash size */
- printed = snprintf(buf, buf_size, " flash_size = %dKB", sim3x_info->flash_size_kb);
- buf_size -= printed;
-
- if (buf_size <= 0)
- return ERROR_BUF_TOO_SMALL;
+ command_print_sameline(cmd, " flash_size = %dKB", sim3x_info->flash_size_kb);
return ERROR_OK;
}
return ERROR_OK;
}
-static int get_stellaris_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_stellaris_info(struct flash_bank *bank, struct command_invocation *cmd)
{
- int printed;
struct stellaris_flash_bank *stellaris_info = bank->driver_priv;
if (stellaris_info->did1 == 0)
/* Read main and master clock frequency register */
stellaris_read_clock_info(bank);
- printed = snprintf(buf,
- buf_size,
- "\nTI/LMI Stellaris information: Chip is "
- "class %i (%s) %s rev %c%i\n",
- stellaris_info->target_class,
- StellarisClassname[stellaris_info->target_class],
- stellaris_info->target_name,
- (int)('A' + ((stellaris_info->did0 >> 8) & 0xFF)),
- (int)((stellaris_info->did0) & 0xFF));
- buf += printed;
- buf_size -= printed;
-
- printed = snprintf(buf,
- buf_size,
- "did1: 0x%8.8" PRIx32 ", arch: 0x%4.4" PRIx32
- ", eproc: %s, ramsize: %" PRIu32 "k, flashsize: %" PRIu32 "k\n",
- stellaris_info->did1,
- stellaris_info->did1,
- "ARMv7M",
- stellaris_info->sramsiz,
- (uint32_t)(stellaris_info->num_pages * stellaris_info->pagesize / 1024));
- buf += printed;
- buf_size -= printed;
-
- snprintf(buf,
- buf_size,
- "master clock: %ikHz%s, "
- "rcc is 0x%" PRIx32 ", rcc2 is 0x%" PRIx32 ", "
- "pagesize: %" PRIu32 ", pages: %" PRIu32,
- (int)(stellaris_info->mck_freq / 1000),
- stellaris_info->mck_desc,
- stellaris_info->rcc,
- stellaris_info->rcc2,
- stellaris_info->pagesize,
- stellaris_info->num_pages);
+ command_print_sameline(cmd,
+ "\nTI/LMI Stellaris information: Chip is "
+ "class %i (%s) %s rev %c%i\n",
+ stellaris_info->target_class,
+ StellarisClassname[stellaris_info->target_class],
+ stellaris_info->target_name,
+ (int)('A' + ((stellaris_info->did0 >> 8) & 0xFF)),
+ (int)((stellaris_info->did0) & 0xFF));
+
+ command_print_sameline(cmd,
+ "did1: 0x%8.8" PRIx32 ", arch: 0x%4.4" PRIx32
+ ", eproc: %s, ramsize: %" PRIu32 "k, flashsize: %" PRIu32 "k\n",
+ stellaris_info->did1,
+ stellaris_info->did1,
+ "ARMv7M",
+ stellaris_info->sramsiz,
+ (uint32_t)(stellaris_info->num_pages * stellaris_info->pagesize / 1024));
+
+ command_print_sameline(cmd,
+ "master clock: %ikHz%s, "
+ "rcc is 0x%" PRIx32 ", rcc2 is 0x%" PRIx32 ", "
+ "pagesize: %" PRIu32 ", pages: %" PRIu32,
+ (int)(stellaris_info->mck_freq / 1000),
+ stellaris_info->mck_desc,
+ stellaris_info->rcc,
+ stellaris_info->rcc2,
+ stellaris_info->pagesize,
+ stellaris_info->num_pages);
return ERROR_OK;
}
return rev_str;
}
-static int get_stm32x_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_stm32x_info(struct flash_bank *bank, struct command_invocation *cmd)
{
uint32_t dbgmcu_idcode;
- /* read stm32 device id register */
+ /* read stm32 device id register */
int retval = stm32x_get_device_id(bank, &dbgmcu_idcode);
if (retval != ERROR_OK)
return retval;
break;
default:
- snprintf(buf, buf_size, "Cannot identify target as a STM32F0/1/3\n");
+ command_print_sameline(cmd, "Cannot identify target as a STM32F0/1/3\n");
return ERROR_FAIL;
}
if (rev_str != NULL)
- snprintf(buf, buf_size, "%s - Rev: %s", device_str, rev_str);
+ command_print_sameline(cmd, "%s - Rev: %s", device_str, rev_str);
else
- snprintf(buf, buf_size, "%s - Rev: unknown (0x%04x)", device_str, rev_id);
+ command_print_sameline(cmd, "%s - Rev: unknown (0x%04x)", device_str, rev_id);
return ERROR_OK;
}
return stm32x_probe(bank);
}
-static int get_stm32x_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_stm32x_info(struct flash_bank *bank, struct command_invocation *cmd)
{
uint32_t dbgmcu_idcode;
break;
default:
- snprintf(buf, buf_size, "Cannot identify target as a STM32F2/4/7\n");
+ command_print_sameline(cmd, "Cannot identify target as a STM32F2/4/7\n");
return ERROR_FAIL;
}
if (rev_str != NULL)
- snprintf(buf, buf_size, "%s - Rev: %s", device_str, rev_str);
+ command_print_sameline(cmd, "%s - Rev: %s", device_str, rev_str);
else
- snprintf(buf, buf_size, "%s - Rev: unknown (0x%04" PRIx16 ")", device_str, rev_id);
+ command_print_sameline(cmd, "%s - Rev: unknown (0x%04" PRIx16 ")", device_str, rev_id);
return ERROR_OK;
}
}
/* This method must return a string displaying information about the bank */
-static int stm32x_get_info(struct flash_bank *bank, char *buf, int buf_size)
+static int stm32x_get_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct stm32h7x_flash_bank *stm32x_info = bank->driver_priv;
const struct stm32h7x_part_info *info = stm32x_info->part_info;
if (!stm32x_info->probed) {
int retval = stm32x_probe(bank);
if (retval != ERROR_OK) {
- snprintf(buf, buf_size, "Unable to find bank information.");
+ command_print_sameline(cmd, "Unable to find bank information.");
return retval;
}
}
rev_str = info->revs[i].str;
if (rev_str != NULL) {
- snprintf(buf, buf_size, "%s - Rev: %s",
+ command_print_sameline(cmd, "%s - Rev: %s",
stm32x_info->part_info->device_str, rev_str);
} else {
- snprintf(buf, buf_size,
+ command_print_sameline(cmd,
"%s - Rev: unknown (0x%04" PRIx16 ")",
stm32x_info->part_info->device_str, rev_id);
}
} else {
- snprintf(buf, buf_size, "Cannot identify target as a STM32H7x");
- return ERROR_FAIL;
+ command_print_sameline(cmd, "Cannot identify target as a STM32H7x");
+ return ERROR_FAIL;
}
return ERROR_OK;
}
return (retval == ERROR_OK) ? ERROR_FAIL : retval;
}
+static const char *get_stm32l4_rev_str(struct flash_bank *bank)
+{
+ struct stm32l4_flash_bank *stm32l4_info = bank->driver_priv;
+ const struct stm32l4_part_info *part_info = stm32l4_info->part_info;
+ assert(part_info);
+
+ const uint16_t rev_id = stm32l4_info->idcode >> 16;
+ for (unsigned int i = 0; i < part_info->num_revs; i++) {
+ if (rev_id == part_info->revs[i].rev)
+ return part_info->revs[i].str;
+ }
+ return "'unknown'";
+}
+
+static const char *get_stm32l4_bank_type_str(struct flash_bank *bank)
+{
+ struct stm32l4_flash_bank *stm32l4_info = bank->driver_priv;
+ assert(stm32l4_info->part_info);
+ assert(stm32l4_info->probed);
+ return stm32l4_is_otp(bank) ? "OTP" :
+ stm32l4_info->dual_bank_mode ? "Flash dual" :
+ "Flash single";
+}
+
static int stm32l4_probe(struct flash_bank *bank)
{
struct target *target = bank->target;
struct stm32l4_flash_bank *stm32l4_info = bank->driver_priv;
const struct stm32l4_part_info *part_info;
uint16_t flash_size_kb = 0xffff;
- uint32_t device_id;
uint32_t options;
stm32l4_info->probed = false;
if (retval != ERROR_OK)
return retval;
- device_id = stm32l4_info->idcode & 0xFFF;
+ const uint32_t device_id = stm32l4_info->idcode & 0xFFF;
+ const uint16_t rev_id = stm32l4_info->idcode >> 16;
+ const char *rev_str = get_stm32l4_rev_str(bank);
for (unsigned int n = 0; n < ARRAY_SIZE(stm32l4_parts); n++) {
if (device_id == stm32l4_parts[n].id) {
part_info = stm32l4_info->part_info;
stm32l4_info->flash_regs = stm32l4_info->part_info->default_flash_regs;
- char device_info[1024];
- retval = bank->driver->info(bank, device_info, sizeof(device_info));
- if (retval != ERROR_OK)
- return retval;
-
- LOG_INFO("device idcode = 0x%08" PRIx32 " (%s)", stm32l4_info->idcode, device_info);
+ LOG_INFO("device idcode = 0x%08" PRIx32 " (%s - Rev %s : 0x%04x - %s-bank)",
+ stm32l4_info->idcode, part_info->device_str, rev_str, rev_id,
+ get_stm32l4_bank_type_str(bank));
/* read flash option register */
retval = stm32l4_read_flash_reg_by_index(bank, STM32_FLASH_OPTR_INDEX, &options);
return stm32l4_probe(bank);
}
-static int get_stm32l4_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_stm32l4_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct stm32l4_flash_bank *stm32l4_info = bank->driver_priv;
const struct stm32l4_part_info *part_info = stm32l4_info->part_info;
if (part_info) {
- const char *rev_str = NULL;
- uint16_t rev_id = stm32l4_info->idcode >> 16;
- for (unsigned int i = 0; i < part_info->num_revs; i++) {
- if (rev_id == part_info->revs[i].rev) {
- rev_str = part_info->revs[i].str;
- break;
- }
- }
-
- int buf_len = snprintf(buf, buf_size, "%s - Rev %s : 0x%04x",
- part_info->device_str, rev_str ? rev_str : "'unknown'", rev_id);
-
+ const uint16_t rev_id = stm32l4_info->idcode >> 16;
+ command_print_sameline(cmd, "%s - Rev %s : 0x%04x", part_info->device_str,
+ get_stm32l4_rev_str(bank), rev_id);
if (stm32l4_info->probed)
- snprintf(buf + buf_len, buf_size - buf_len, " - %s-bank",
- stm32l4_is_otp(bank) ? "OTP" :
- stm32l4_info->dual_bank_mode ? "Flash dual" : "Flash single");
-
- return ERROR_OK;
+ command_print_sameline(cmd, " - %s-bank", get_stm32l4_bank_type_str(bank));
} else {
- snprintf(buf, buf_size, "Cannot identify target as an %s device", device_families);
- return ERROR_FAIL;
+ command_print_sameline(cmd, "Cannot identify target as an %s device", device_families);
}
return ERROR_OK;
}
/* This method must return a string displaying information about the bank */
-static int stm32lx_get_info(struct flash_bank *bank, char *buf, int buf_size)
+static int stm32lx_get_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv;
const struct stm32lx_part_info *info = &stm32lx_info->part_info;
if (!stm32lx_info->probed) {
int retval = stm32lx_probe(bank);
if (retval != ERROR_OK) {
- snprintf(buf, buf_size,
- "Unable to find bank information.");
+ command_print_sameline(cmd, "Unable to find bank information.");
return retval;
}
}
rev_str = info->revs[i].str;
if (rev_str != NULL) {
- snprintf(buf, buf_size,
- "%s - Rev: %s",
- info->device_str, rev_str);
+ command_print_sameline(cmd, "%s - Rev: %s", info->device_str, rev_str);
} else {
- snprintf(buf, buf_size,
- "%s - Rev: unknown (0x%04x)",
- info->device_str, rev_id);
+ command_print_sameline(cmd, "%s - Rev: unknown (0x%04x)", info->device_str, rev_id);
}
return ERROR_OK;
return ERROR_OK;
}
-static int get_stmqspi_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_stmqspi_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
if (!(stmqspi_info->probed)) {
- snprintf(buf, buf_size,
- "\nQSPI flash bank not probed yet\n");
+ command_print_sameline(cmd, "\nQSPI flash bank not probed yet\n");
return ERROR_FLASH_BANK_NOT_PROBED;
}
- snprintf(buf, buf_size, "flash%s%s \'%s\', device id = 0x%06" PRIx32
+ command_print_sameline(cmd, "flash%s%s \'%s\', device id = 0x%06" PRIx32
", flash size = %" PRIu32 "%sbytes\n(page size = %" PRIu32
", read = 0x%02" PRIx8 ", qread = 0x%02" PRIx8
", pprog = 0x%02" PRIx8 ", mass_erase = 0x%02" PRIx8
return ERROR_OK;
}
-static int get_stmsmi_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_stmsmi_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct stmsmi_flash_bank *stmsmi_info = bank->driver_priv;
if (!(stmsmi_info->probed)) {
- snprintf(buf, buf_size,
- "\nSMI flash bank not probed yet\n");
+ command_print_sameline(cmd, "\nSMI flash bank not probed yet\n");
return ERROR_OK;
}
- snprintf(buf, buf_size, "\nSMI flash information:\n"
+ command_print_sameline(cmd, "\nSMI flash information:\n"
" Device \'%s\' (ID 0x%08" PRIx32 ")\n",
stmsmi_info->dev->name, stmsmi_info->dev->device_id);
}
#endif
-static int get_str7x_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_str7x_info(struct flash_bank *bank, struct command_invocation *cmd)
{
/* Setting the write protection on a sector is a permanent change but it
* can be disabled temporarily. FLASH_NVWPAR reflects the permanent
* protection state of the sectors, not the temporary.
*/
- snprintf(buf, buf_size, "STR7x flash protection info is only valid after a power cycle, "
+ command_print_sameline(cmd, "STR7x flash protection info is only valid after a power cycle, "
"clearing the protection is only temporary and may not be reflected in the current "
"info returned.");
return ERROR_OK;
return retval;
if (p != NULL) {
- char buf[1024];
int num_blocks;
struct flash_sector *block_array;
}
if (p->driver->info != NULL) {
- retval = p->driver->info(p, buf, sizeof(buf));
- if (retval == ERROR_OK)
- command_print(CMD, "%s", buf);
- else
+ /* Let the flash driver print extra custom info */
+ retval = p->driver->info(p, CMD);
+ command_print_sameline(CMD, "\n");
+ if (retval != ERROR_OK)
LOG_ERROR("error retrieving flash info");
}
}
/* ---------------------------------------------------------------------- */
-static int get_tms470_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_tms470_info(struct flash_bank *bank, struct command_invocation *cmd)
{
- int used = 0;
struct tms470_flash_bank *tms470_info = bank->driver_priv;
if (!tms470_info->device_ident_reg)
tms470_read_part_info(bank);
if (!tms470_info->device_ident_reg) {
- (void)snprintf(buf, buf_size, "Cannot identify target as a TMS470\n");
+ command_print_sameline(cmd, "Cannot identify target as a TMS470\n");
return ERROR_FLASH_OPERATION_FAILED;
}
- used =
- snprintf(buf, buf_size, "\ntms470 information: Chip is %s\n",
- tms470_info->part_name);
- buf += used;
- buf_size -= used;
-
- snprintf(buf, buf_size, "Flash protection level 2 is %s\n",
+ command_print_sameline(cmd, "\ntms470 information: Chip is %s\n", tms470_info->part_name);
+ command_print_sameline(cmd, "Flash protection level 2 is %s\n",
tms470_check_flash_unlocked(bank->target) == ERROR_OK ? "disabled" : "enabled");
return ERROR_OK;
return ERROR_OK;
}
-static int virtual_info(struct flash_bank *bank, char *buf, int buf_size)
+static int virtual_info(struct flash_bank *bank, struct command_invocation *cmd)
{
struct flash_bank *master_bank = virtual_get_master_bank(bank);
if (master_bank == NULL)
return ERROR_FLASH_OPERATION_FAILED;
- snprintf(buf, buf_size, "%s driver for flash bank %s at " TARGET_ADDR_FMT,
+ command_print_sameline(cmd, "%s driver for flash bank %s at " TARGET_ADDR_FMT,
bank->driver->name, master_bank->name, master_bank->base);
return ERROR_OK;
return w600_probe(bank);
}
-static int get_w600_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_w600_info(struct flash_bank *bank, struct command_invocation *cmd)
{
uint32_t flash_id;
if (retval != ERROR_OK)
return retval;
- snprintf(buf, buf_size, "w600 : 0x%08" PRIx32 "", flash_id);
+ command_print_sameline(cmd, "w600 : 0x%08" PRIx32 "", flash_id);
return ERROR_OK;
}
return ERROR_OK;
}
-static int xcf_info(struct flash_bank *bank, char *buf, int buf_size)
+static int xcf_info(struct flash_bank *bank, struct command_invocation *cmd)
{
const struct xcf_priv *priv = bank->driver_priv;
if (!priv->probed) {
- snprintf(buf, buf_size, "\nXCF flash bank not probed yet\n");
+ command_print_sameline(cmd, "\nXCF flash bank not probed yet\n");
return ERROR_OK;
}
- snprintf(buf, buf_size, "%s", product_name(bank));
+ command_print_sameline(cmd, "%s", product_name(bank));
return ERROR_OK;
}
return ERROR_OK;
}
-static int xmc1xxx_get_info_command(struct flash_bank *bank, char *buf, int buf_size)
+static int xmc1xxx_get_info_command(struct flash_bank *bank, struct command_invocation *cmd)
{
uint32_t chipid[8];
int i, retval;
}
LOG_DEBUG("ID[7] = %08" PRIX32, chipid[7]);
- snprintf(buf, buf_size, "XMC%" PRIx32 "00 %" PRIX32 " flash %" PRIu32 "KB ROM %" PRIu32 "KB SRAM %" PRIu32 "KB",
+ command_print_sameline(cmd,
+ "XMC%" PRIx32 "00 %" PRIX32 " flash %" PRIu32 "KB ROM %" PRIu32 "KB SRAM %" PRIu32 "KB",
(chipid[0] >> 12) & 0xff,
0xAA + (chipid[7] >> 28) - 1,
(((chipid[6] >> 12) & 0x3f) - 1) * 4,
}
-static int xmc4xxx_get_info_command(struct flash_bank *bank, char *buf, int buf_size)
+static int xmc4xxx_get_info_command(struct flash_bank *bank, struct command_invocation *cmd)
{
struct xmc4xxx_flash_bank *fb = bank->driver_priv;
uint32_t scu_idcode;
break;
default:
- snprintf(buf, buf_size,
- "Cannot identify target as an XMC4xxx. SCU_ID: %"PRIx32"\n",
- scu_idcode);
+ command_print_sameline(cmd, "Cannot identify target as an XMC4xxx. SCU_ID: %"PRIx32 "\n", scu_idcode);
return ERROR_OK;
}
}
if (rev_str != NULL)
- snprintf(buf, buf_size, "%s - Rev: %s%s",
- dev_str, rev_str, prot_str);
+ command_print_sameline(cmd, "%s - Rev: %s%s", dev_str, rev_str, prot_str);
else
- snprintf(buf, buf_size, "%s - Rev: unknown (0x%01x)%s",
- dev_str, rev_id, prot_str);
+ command_print_sameline(cmd, "%s - Rev: unknown (0x%01x)%s", dev_str, rev_id, prot_str);
return ERROR_OK;
}
Code Review / openocd.git / commitdiff