imi415
/
openocd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

flash/nor: improved API of flash_driver.info & fixed buffer overruns 

1) The API of "info" callback in "struct flash_driver" has been
improved. Fixed buffers for strings

2) Removed the calls to snprintf() from the flash_driver.info
implementations. Many of them were used in an unsafe manner
(buffer overruns were possible).

Change-Id: I42ab8a8018d01f9af43c5ba49f650c3cb5d31dcb
Signed-off-by: Jan Matyas <matyas@codasip.com>
Reviewed-on: http://openocd.zylin.com/6182
Tested-by: jenkins
Reviewed-by: Antonio Borneo <borneo.antonio@gmail.com>
Reviewed-by: Tomas Vanek <vanekt@fbl.cz>
This commit is contained in:
Jan Matyas 2021-04-23 10:47:17 +02:00 committed by Antonio Borneo
parent f2958fc04b
commit 64c2e03b23
51 changed files with 290 additions and 442 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/flash/nor/ambiqmicro.c
View File

@ -161,10 +161,9 @@ FLASH_BANK_COMMAND_HANDLER(ambiqmicro_flash_bank_command)
return ERROR_OK; 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; struct ambiqmicro_flash_bank *ambiqmicro_info = bank->driver_priv;
int printed;
char *classname; char *classname;
if (!ambiqmicro_info->probed) { if (!ambiqmicro_info->probed) {
@ -178,16 +177,12 @@ static int get_ambiqmicro_info(struct flash_bank *bank, char *buf, int buf_size)
else else
classname = ambiqmicroClassname[0]; classname = ambiqmicroClassname[0];
printed = snprintf(buf, command_print_sameline(cmd, "\nAmbiq Micro information: Chip is "
buf_size,
"\nAmbiq Micro information: Chip is "
"class %d (%s) %s\n", "class %d (%s) %s\n",
ambiqmicro_info->target_class, ambiqmicro_info->target_class,
classname, classname,
ambiqmicro_info->target_name); ambiqmicro_info->target_name);
if ((printed < 0))
return ERROR_BUF_TOO_SMALL;
return ERROR_OK; return ERROR_OK;
} }

6
src/flash/nor/at91sam3.c
View File

@ -256,7 +256,7 @@ static struct sam3_chip *get_current_sam3(struct command_invocation *cmd)
t = get_current_target(cmd->ctx); t = get_current_target(cmd->ctx);
if (!t) { if (!t) {
command_print(cmd, "No current target?"); command_print_sameline(cmd, "No current target?\n");
return NULL; return NULL;
} }
@ -264,7 +264,7 @@ static struct sam3_chip *get_current_sam3(struct command_invocation *cmd)
if (!p) { if (!p) {
/* this should not happen */ /* this should not happen */
/* the command is not registered until the chip is created? */ /* 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 NULL;
} }
@ -273,7 +273,7 @@ static struct sam3_chip *get_current_sam3(struct command_invocation *cmd)
return p; return p;
p = p->next; p = p->next;
} }
command_print(cmd, "Cannot find SAM3 chip?"); command_print_sameline(cmd, "Cannot find SAM3 chip?\n");
return NULL; return NULL;
} }

15
src/flash/nor/at91sam4.c
View File

@ -235,7 +235,7 @@ static struct sam4_chip *get_current_sam4(struct command_invocation *cmd)
t = get_current_target(cmd->ctx); t = get_current_target(cmd->ctx);
if (!t) { if (!t) {
command_print(cmd, "No current target?"); command_print_sameline(cmd, "No current target?\n");
return NULL; return NULL;
} }
@ -243,7 +243,7 @@ static struct sam4_chip *get_current_sam4(struct command_invocation *cmd)
if (!p) { if (!p) {
/* this should not happen */ /* this should not happen */
/* the command is not registered until the chip is created? */ /* 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 NULL;
} }
@ -252,7 +252,7 @@ static struct sam4_chip *get_current_sam4(struct command_invocation *cmd)
return p; return p;
p = p->next; p = p->next;
} }
command_print(cmd, "Cannot find SAM4 chip?"); command_print_sameline(cmd, "Cannot find SAM4 chip?\n");
return NULL; return NULL;
} }
@ -2656,19 +2656,16 @@ static int sam4_GetDetails(struct sam4_bank_private *pPrivate)
return ERROR_OK; 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; struct sam4_bank_private *pPrivate;
int k = bank->size / 1024; int k = bank->size / 1024;
pPrivate = get_sam4_bank_private(bank); pPrivate = get_sam4_bank_private(bank);
if (pPrivate == NULL) { if (pPrivate == NULL)
buf[0] = '\0';
return ERROR_FAIL; return ERROR_FAIL;
}
snprintf(buf, buf_size, command_print_sameline(cmd, "%s bank %d: %d kB at " TARGET_ADDR_FMT,
"%s bank %d: %d kB at " TARGET_ADDR_FMT,
pPrivate->pChip->details.name, pPrivate->pChip->details.name,
pPrivate->bank_number, pPrivate->bank_number,
k, k,

33
src/flash/nor/at91sam7.c
View File

@ -978,23 +978,17 @@ static int at91sam7_probe(struct flash_bank *bank)
return ERROR_OK; 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; struct at91sam7_flash_bank *at91sam7_info = bank->driver_priv;
if (at91sam7_info->cidr == 0) if (at91sam7_info->cidr == 0)
return ERROR_FLASH_BANK_NOT_PROBED; return ERROR_FLASH_BANK_NOT_PROBED;
printed = snprintf(buf, buf_size, command_print_sameline(cmd, "\n at91sam7 driver information: Chip is %s\n",
"\n at91sam7 driver information: Chip is %s\n",
at91sam7_info->target_name); at91sam7_info->target_name);
buf += printed; command_print_sameline(cmd,
buf_size -= printed;
printed = snprintf(buf,
buf_size,
" Cidr: 0x%8.8" PRIx32 " | Arch: 0x%4.4x | Eproc: %s | Version: 0x%3.3x | " " Cidr: 0x%8.8" PRIx32 " | Arch: 0x%4.4x | Eproc: %s | Version: 0x%3.3x | "
"Flashsize: 0x%8.8" PRIx32 "\n", "Flashsize: 0x%8.8" PRIx32 "\n",
at91sam7_info->cidr, at91sam7_info->cidr,
@ -1003,31 +997,20 @@ static int get_at91sam7_info(struct flash_bank *bank, char *buf, int buf_size)
at91sam7_info->cidr_version, at91sam7_info->cidr_version,
bank->size); bank->size);
buf += printed; command_print_sameline(cmd,
buf_size -= printed; " Master clock (estimated): %u kHz | External clock: %u kHz\n",
printed = snprintf(buf, buf_size,
" Master clock (estimated): %u KHz | External clock: %u KHz\n",
(unsigned)(at91sam7_info->mck_freq / 1000), (unsigned)(at91sam7_info->mck_freq / 1000),
(unsigned)(at91sam7_info->ext_freq / 1000)); (unsigned)(at91sam7_info->ext_freq / 1000));
buf += printed; command_print_sameline(cmd,
buf_size -= printed;
printed = snprintf(buf,
buf_size,
" Pagesize: %i bytes | Lockbits(%u): %i 0x%4.4x | Pages in lock region: %i\n", " Pagesize: %i bytes | Lockbits(%u): %i 0x%4.4x | Pages in lock region: %i\n",
at91sam7_info->pagesize, at91sam7_info->pagesize,
bank->num_sectors, bank->num_sectors,
at91sam7_info->num_lockbits_on, at91sam7_info->num_lockbits_on,
at91sam7_info->lockbits, at91sam7_info->lockbits,
at91sam7_info->pages_per_sector*at91sam7_info->num_lockbits_on); at91sam7_info->pages_per_sector * at91sam7_info->num_lockbits_on);
buf += printed; command_print_sameline(cmd, " Securitybit: %i | Nvmbits(%i): %i 0x%1.1x\n",
buf_size -= printed;
snprintf(buf, buf_size,
" Securitybit: %i | Nvmbits(%i): %i 0x%1.1x\n",
at91sam7_info->securitybit, at91sam7_info->num_nvmbits, at91sam7_info->securitybit, at91sam7_info->num_nvmbits,
at91sam7_info->num_nvmbits_on, at91sam7_info->nvmbits); at91sam7_info->num_nvmbits_on, at91sam7_info->nvmbits);

7
src/flash/nor/ath79.c
View File

@ -875,17 +875,16 @@ static int ath79_protect_check(struct flash_bank *bank)
return ERROR_OK; 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; struct ath79_flash_bank *ath79_info = bank->driver_priv;
if (!ath79_info->probed) { if (!ath79_info->probed) {
snprintf(buf, buf_size, command_print_sameline(cmd, "\nATH79 flash bank not probed yet\n");
"\nATH79 flash bank not probed yet\n");
return ERROR_OK; 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", " Device \'%s\' (ID 0x%08" PRIx32 ")\n",
ath79_info->dev->name, ath79_info->dev->device_id); ath79_info->dev->name, ath79_info->dev->device_id);

4
src/flash/nor/atsamv.c
View File

@ -607,7 +607,7 @@ static int samv_write(struct flash_bank *bank, const uint8_t *buffer,
return ERROR_OK; 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; struct samv_flash_bank *samv_info = bank->driver_priv;
if (!samv_info->probed) { if (!samv_info->probed) {
@ -615,7 +615,7 @@ static int samv_get_info(struct flash_bank *bank, char *buf, int buf_size)
if (ERROR_OK != r) if (ERROR_OK != r)
return 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); bank->size / 1024);
return ERROR_OK; return ERROR_OK;
} }

6
src/flash/nor/avrf.c
View File

@ -367,7 +367,7 @@ static int avrf_auto_probe(struct flash_bank *bank)
return avrf_probe(bank); 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 target *target = bank->target;
struct avr_common *avr = target->arch_info; struct avr_common *avr = target->arch_info;
@ -400,12 +400,12 @@ static int avrf_info(struct flash_bank *bank, char *buf, int buf_size)
if (avr_info != NULL) { if (avr_info != NULL) {
/* chip found */ /* 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)); EXTRACT_VER(device_id));
return ERROR_OK; return ERROR_OK;
} else { } else {
/* chip not supported */ /* 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; return ERROR_FLASH_OPERATION_FAILED;
} }
} }

9
src/flash/nor/bluenrg-x.c
View File

@ -429,7 +429,7 @@ static int bluenrgx_auto_probe(struct flash_bank *bank)
} }
/* This method must return a string displaying information about the bank */ /* 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; struct bluenrgx_flash_bank *bluenrgx_info = bank->driver_priv;
int mask_number, cut_number; int mask_number, cut_number;
@ -437,8 +437,7 @@ static int bluenrgx_get_info(struct flash_bank *bank, char *buf, int buf_size)
if (!bluenrgx_info->probed) { if (!bluenrgx_info->probed) {
int retval = bluenrgx_probe(bank); int retval = bluenrgx_probe(bank);
if (retval != ERROR_OK) { if (retval != ERROR_OK) {
snprintf(buf, buf_size, command_print_sameline(cmd, "Unable to find bank information.");
"Unable to find bank information.");
return retval; return retval;
} }
} }
@ -446,8 +445,8 @@ static int bluenrgx_get_info(struct flash_bank *bank, char *buf, int buf_size)
mask_number = (bluenrgx_info->die_id >> 4) & 0xF; mask_number = (bluenrgx_info->die_id >> 4) & 0xF;
cut_number = bluenrgx_info->die_id & 0xF; cut_number = bluenrgx_info->die_id & 0xF;
snprintf(buf, buf_size, command_print_sameline(cmd, "%s - Rev: %d.%d",
"%s - Rev: %d.%d", bluenrgx_info->flash_ptr->part_name, mask_number, cut_number); bluenrgx_info->flash_ptr->part_name, mask_number, cut_number);
return ERROR_OK; return ERROR_OK;
} }

8
src/flash/nor/cc26xx.c
View File

@ -498,10 +498,9 @@ static int cc26xx_auto_probe(struct flash_bank *bank)
return retval; 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; struct cc26xx_bank *cc26xx_bank = bank->driver_priv;
int printed = 0;
const char *device; const char *device;
switch (cc26xx_bank->device_type) { switch (cc26xx_bank->device_type) {
@ -526,13 +525,10 @@ static int cc26xx_info(struct flash_bank *bank, char *buf, int buf_size)
break; break;
} }
printed = snprintf(buf, buf_size, command_print_sameline(cmd,
"%s device: ICEPick ID 0x%08" PRIx32 ", USER ID 0x%08" PRIx32 "\n", "%s device: ICEPick ID 0x%08" PRIx32 ", USER ID 0x%08" PRIx32 "\n",
device, cc26xx_bank->icepick_id, cc26xx_bank->user_id); device, cc26xx_bank->icepick_id, cc26xx_bank->user_id);
if (printed >= buf_size)
return ERROR_BUF_TOO_SMALL;
return ERROR_OK; return ERROR_OK;
} }

10
src/flash/nor/cc3220sf.c
View File

@ -477,15 +477,9 @@ static int cc3220sf_auto_probe(struct flash_bank *bank)
return retval; 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; command_print_sameline(cmd, "CC3220SF with 1MB internal flash\n");
printed = snprintf(buf, buf_size, "CC3220SF with 1MB internal flash\n");
if (printed >= buf_size)
return ERROR_BUF_TOO_SMALL;
return ERROR_OK; return ERROR_OK;
} }

89
src/flash/nor/cfi.c
View File

@ -728,79 +728,57 @@ static int cfi_read_0002_pri_ext(struct flash_bank *bank)
return cfi_read_spansion_pri_ext(bank); 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_flash_bank *cfi_info = bank->driver_priv;
struct cfi_spansion_pri_ext *pri_ext = cfi_info->pri_ext; struct cfi_spansion_pri_ext *pri_ext = cfi_info->pri_ext;
printed = snprintf(buf, buf_size, "\nSpansion primary algorithm extend information:\n"); command_print_sameline(cmd, "\nSpansion primary algorithm extend information:\n");
buf += printed;
buf_size -= printed;
printed = snprintf(buf, buf_size, "pri: '%c%c%c', version: %c.%c\n", pri_ext->pri[0], command_print_sameline(cmd, "pri: '%c%c%c', version: %c.%c\n",
pri_ext->pri[1], pri_ext->pri[2], pri_ext->pri[0], pri_ext->pri[1], pri_ext->pri[2],
pri_ext->major_version, pri_ext->minor_version); 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) >> 2,
(pri_ext->SiliconRevision) & 0x03); (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->EraseSuspend,
pri_ext->BlkProt); 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->VppMin & 0xf0) >> 4, pri_ext->VppMin & 0x0f,
(pri_ext->VppMax & 0xf0) >> 4, pri_ext->VppMax & 0x0f); (pri_ext->VppMax & 0xf0) >> 4, pri_ext->VppMax & 0x0f);
return ERROR_OK; 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_flash_bank *cfi_info = bank->driver_priv;
struct cfi_intel_pri_ext *pri_ext = cfi_info->pri_ext; struct cfi_intel_pri_ext *pri_ext = cfi_info->pri_ext;
printed = snprintf(buf, buf_size, "\nintel primary algorithm extend information:\n"); command_print_sameline(cmd, "\nintel primary algorithm extend information:\n");
buf += printed;
buf_size -= printed;
printed = snprintf(buf, command_print_sameline(cmd, "pri: '%c%c%c', version: %c.%c\n",
buf_size,
"pri: '%c%c%c', version: %c.%c\n",
pri_ext->pri[0], pri_ext->pri[0],
pri_ext->pri[1], pri_ext->pri[1],
pri_ext->pri[2], pri_ext->pri[2],
pri_ext->major_version, pri_ext->major_version,
pri_ext->minor_version); pri_ext->minor_version);
buf += printed;
buf_size -= printed;
printed = snprintf(buf, command_print_sameline(cmd, "feature_support: 0x%" PRIx32 ", "
buf_size,
"feature_support: 0x%" PRIx32 ", "
"suspend_cmd_support: 0x%x, blk_status_reg_mask: 0x%x\n", "suspend_cmd_support: 0x%x, blk_status_reg_mask: 0x%x\n",
pri_ext->feature_support, pri_ext->feature_support,
pri_ext->suspend_cmd_support, pri_ext->suspend_cmd_support,
pri_ext->blk_status_reg_mask); 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->vcc_optimal & 0xf0) >> 4, pri_ext->vcc_optimal & 0x0f,
(pri_ext->vpp_optimal & 0xf0) >> 4, pri_ext->vpp_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", "factory pre-programmed: %i, user programmable: %i\n",
pri_ext->num_protection_fields, pri_ext->prot_reg_addr, pri_ext->num_protection_fields, pri_ext->prot_reg_addr,
1 << pri_ext->fact_prot_reg_size, 1 << pri_ext->user_prot_reg_size); 1 << pri_ext->fact_prot_reg_size, 1 << pri_ext->user_prot_reg_size);
@ -2992,45 +2970,36 @@ int cfi_protect_check(struct flash_bank *bank)
return ERROR_OK; 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; struct cfi_flash_bank *cfi_info = bank->driver_priv;
if (cfi_info->qry[0] == 0xff) { 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; return ERROR_OK;
} }
if (!cfi_info->not_cfi) if (!cfi_info->not_cfi)
printed = snprintf(buf, buf_size, "\nCFI flash: "); command_print_sameline(cmd, "\nCFI flash: ");
else else
printed = snprintf(buf, buf_size, "\nnon-CFI flash: "); command_print_sameline(cmd, "\nnon-CFI flash: ");
buf += printed;
buf_size -= printed;
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); 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", "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->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); 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", "Vpp min: %u.%x, Vpp max: %u.%x\n",
(cfi_info->vcc_min & 0xf0) >> 4, cfi_info->vcc_min & 0x0f, (cfi_info->vcc_min & 0xf0) >> 4, cfi_info->vcc_min & 0x0f,
(cfi_info->vcc_max & 0xf0) >> 4, cfi_info->vcc_max & 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_min & 0xf0) >> 4, cfi_info->vpp_min & 0x0f,
(cfi_info->vpp_max & 0xf0) >> 4, cfi_info->vpp_max & 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. buf write timeout: %u us, "
"typ. block erase timeout: %u ms, " "typ. block erase timeout: %u ms, "
"typ. chip erase timeout: %u ms\n", "typ. chip erase timeout: %u ms\n",
@ -3038,12 +3007,8 @@ int cfi_get_info(struct flash_bank *bank, char *buf, int buf_size)
1 << cfi_info->buf_write_timeout_typ, 1 << cfi_info->buf_write_timeout_typ,
1 << cfi_info->block_erase_timeout_typ, 1 << cfi_info->block_erase_timeout_typ,
1 << cfi_info->chip_erase_timeout_typ); 1 << cfi_info->chip_erase_timeout_typ);
buf += printed;
buf_size -= printed;
printed = snprintf(buf, command_print_sameline(cmd, "max. word write timeout: %u us, "
buf_size,
"max. word write timeout: %u us, "
"max. buf write timeout: %u us, max. " "max. buf write timeout: %u us, max. "
"block erase timeout: %u ms, max. chip erase timeout: %u ms\n", "block erase timeout: %u ms, max. chip erase timeout: %u ms\n",
(1 << (1 <<
@ -3056,24 +3021,20 @@ int cfi_get_info(struct flash_bank *bank, char *buf, int buf_size)
(1 << (1 <<
cfi_info->chip_erase_timeout_max) * cfi_info->chip_erase_timeout_max) *
(1 << cfi_info->chip_erase_timeout_typ)); (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", "max buffer write size: 0x%x\n",
cfi_info->dev_size, cfi_info->dev_size,
cfi_info->interface_desc, cfi_info->interface_desc,
1 << cfi_info->max_buf_write_size); 1 << cfi_info->max_buf_write_size);
buf += printed;
buf_size -= printed;
switch (cfi_info->pri_id) { switch (cfi_info->pri_id) {
case 1: case 1:
case 3: case 3:
cfi_intel_info(bank, buf, buf_size); cfi_intel_info(bank, cmd);
break; break;
case 2: case 2:
cfi_spansion_info(bank, buf, buf_size); cfi_spansion_info(bank, cmd);
break; break;
default: default:
LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id); LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);

2
src/flash/nor/cfi.h
View File

@ -160,7 +160,7 @@ int cfi_protect(struct flash_bank *bank, int set, unsigned int first,
int cfi_probe(struct flash_bank *bank); int cfi_probe(struct flash_bank *bank);
int cfi_auto_probe(struct flash_bank *bank); int cfi_auto_probe(struct flash_bank *bank);
int cfi_protect_check(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); 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); uint32_t cfi_flash_address(struct flash_bank *bank, int sector, uint32_t offset);

9
src/flash/nor/driver.h
View File

@ -205,15 +205,14 @@ struct flash_driver {
/** /**
* Display human-readable information about the flash * Display human-readable information about the flash
* bank into the given buffer. Drivers must be careful to avoid * bank.
* overflowing the buffer.
* *
* @param bank - the bank to get info about * @param bank - the bank to get info about
* @param char - where to put the text for the human to read * @param cmd - command invocation instance for which to generate
* @param buf_size - the size of the human buffer. * the textual output
* @returns ERROR_OK if successful; otherwise, an error code. * @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 * A more gentle flavor of flash_driver_s::probe, performing

33
src/flash/nor/efm32.c
View File

@ -324,23 +324,7 @@ static int efm32x_read_info(struct flash_bank *bank,
return ERROR_OK; return ERROR_OK;
} }
/* /* flash bank efm32 <base> <size> 0 0 <target#> */
* 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_COMMAND_HANDLER(efm32x_flash_bank_command) FLASH_BANK_COMMAND_HANDLER(efm32x_flash_bank_command)
{ {
struct efm32x_flash_bank *efm32x_info; struct efm32x_flash_bank *efm32x_info;
@ -961,7 +945,6 @@ static int efm32x_probe(struct flash_bank *bank)
struct efm32_info efm32_mcu_info; struct efm32_info efm32_mcu_info;
int ret; int ret;
uint32_t base_address = 0x00000000; uint32_t base_address = 0x00000000;
char buf[256];
efm32x_info->probed = false; efm32x_info->probed = false;
memset(efm32x_info->lb_page, 0xff, LOCKBITS_PAGE_SZ); memset(efm32x_info->lb_page, 0xff, LOCKBITS_PAGE_SZ);
@ -970,11 +953,8 @@ static int efm32x_probe(struct flash_bank *bank)
if (ERROR_OK != ret) if (ERROR_OK != ret)
return ret; return ret;
ret = efm32x_decode_info(&efm32_mcu_info, buf, sizeof(buf)); LOG_INFO("detected part: %s Gecko, rev %d",
if (ERROR_OK != ret) efm32_mcu_info.family_data->name, efm32_mcu_info.prod_rev);
return ret;
LOG_INFO("detected part: %s", buf);
LOG_INFO("flash size = %dkbytes", efm32_mcu_info.flash_sz_kib); LOG_INFO("flash size = %dkbytes", efm32_mcu_info.flash_sz_kib);
LOG_INFO("flash page size = %dbytes", efm32_mcu_info.page_size); LOG_INFO("flash page size = %dbytes", efm32_mcu_info.page_size);
@ -1044,10 +1024,10 @@ static int efm32x_protect_check(struct flash_bank *bank)
return ERROR_OK; 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; struct efm32_info info;
int ret = 0; int ret;
ret = efm32x_read_info(bank, &info); ret = efm32x_read_info(bank, &info);
if (ERROR_OK != ret) { if (ERROR_OK != ret) {
@ -1055,7 +1035,8 @@ static int get_efm32x_info(struct flash_bank *bank, char *buf, int buf_size)
return 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) COMMAND_HANDLER(efm32x_handle_debuglock_command)

4
src/flash/nor/esirisc_flash.c
View File

@ -487,11 +487,11 @@ static int esirisc_flash_auto_probe(struct flash_bank *bank)
return esirisc_flash_probe(bank); 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; 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, "%4s cfg at 0x%" PRIx32 ", clock %" PRIu32 ", wait_states %" PRIu32,
"", /* align with first line */ "", /* align with first line */
esirisc_info->cfg, esirisc_info->cfg,

4
src/flash/nor/faux.c
View File

@ -92,9 +92,9 @@ static int faux_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t o
return ERROR_OK; 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;
} }

7
src/flash/nor/fespi.c
View File

@ -1017,17 +1017,16 @@ static int fespi_protect_check(struct flash_bank *bank)
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; struct fespi_flash_bank *fespi_info = bank->driver_priv;
if (!(fespi_info->probed)) { if (!(fespi_info->probed)) {
snprintf(buf, buf_size, command_print_sameline(cmd, "\nFESPI flash bank not probed yet\n");
"\nFESPI flash bank not probed yet\n");
return ERROR_OK; 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", " Device \'%s\' (ID 0x%08" PRIx32 ")\n",
fespi_info->dev->name, fespi_info->dev->device_id); fespi_info->dev->name, fespi_info->dev->device_id);

7
src/flash/nor/fm4.c
View File

@ -539,7 +539,7 @@ static int fm4_auto_probe(struct flash_bank *bank)
return fm4_probe(bank); 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; struct fm4_flash_bank *fm4_bank = bank->driver_priv;
const char *name; const char *name;
@ -586,11 +586,10 @@ static int fm4_get_info_command(struct flash_bank *bank, char *buf, int buf_size
case s6e2cx8: case s6e2cx8:
case s6e2cx9: case s6e2cx9:
case s6e2cxa: case s6e2cxa:
snprintf(buf, buf_size, "%s MainFlash Macro #%i", command_print_sameline(cmd, "%s MainFlash Macro #%i", name, fm4_bank->macro_nr);
name, fm4_bank->macro_nr);
break; break;
default: default:
snprintf(buf, buf_size, "%s MainFlash", name); command_print_sameline(cmd, "%s MainFlash", name);
break; break;
} }

6
src/flash/nor/jtagspi.c
View File

@ -421,16 +421,16 @@ static int jtagspi_write(struct flash_bank *bank, const uint8_t *buffer, uint32_
return ERROR_OK; 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; struct jtagspi_flash_bank *info = bank->driver_priv;
if (!(info->probed)) { 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; 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", " Device \'%s\' (ID 0x%08" PRIx32 ")\n",
info->dev->name, info->dev->device_id); info->dev->name, info->dev->device_id);

4
src/flash/nor/kinetis.c
View File

@ -2778,7 +2778,7 @@ static int kinetis_auto_probe(struct flash_bank *bank)
return kinetis_probe(bank); 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[] = { const char *bank_class_names[] = {
"(ANY)", "PFlash", "FlexNVM", "FlexRAM" "(ANY)", "PFlash", "FlexNVM", "FlexRAM"
@ -2788,7 +2788,7 @@ static int kinetis_info(struct flash_bank *bank, char *buf, int buf_size)
struct kinetis_chip *k_chip = k_bank->k_chip; struct kinetis_chip *k_chip = k_bank->k_chip;
uint32_t size_k = bank->size / 1024; 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, "%s %s: %" PRIu32 "k %s bank %s at " TARGET_ADDR_FMT,
bank->driver->name, k_chip->name, bank->driver->name, k_chip->name,
size_k, bank_class_names[k_bank->flash_class], size_k, bank_class_names[k_bank->flash_class],

5
src/flash/nor/kinetis_ke.c
View File

@ -1171,10 +1171,9 @@ static int kinetis_ke_auto_probe(struct flash_bank *bank)
return kinetis_ke_probe(bank); 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, command_print_sameline(cmd, "%s driver for flash bank %s at " TARGET_ADDR_FMT,
"%s driver for flash bank %s at " TARGET_ADDR_FMT,
bank->driver->name, bank->name, bank->base); bank->driver->name, bank->name, bank->base);
return ERROR_OK; return ERROR_OK;

6
src/flash/nor/lpc2000.c
View File

@ -1552,12 +1552,12 @@ static int lpc2000_erase_check(struct flash_bank *bank)
return lpc2000_iap_blank_check(bank, 0, bank->num_sectors - 1); 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; struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
snprintf(buf, buf_size, "lpc2000 flash driver variant: %i, clk: %" PRIu32 "kHz", lpc2000_info->variant, command_print_sameline(cmd, "lpc2000 flash driver variant: %i, clk: %" PRIu32 "kHz",
lpc2000_info->cclk); lpc2000_info->variant, lpc2000_info->cclk);
return ERROR_OK; return ERROR_OK;
} }

7
src/flash/nor/lpcspifi.c
View File

@ -926,17 +926,16 @@ static int lpcspifi_protect_check(struct flash_bank *bank)
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; struct lpcspifi_flash_bank *lpcspifi_info = bank->driver_priv;
if (!(lpcspifi_info->probed)) { if (!(lpcspifi_info->probed)) {
snprintf(buf, buf_size, command_print_sameline(cmd, "\nSPIFI flash bank not probed yet\n");
"\nSPIFI flash bank not probed yet\n");
return ERROR_OK; 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", " Device \'%s\' (ID 0x%08" PRIx32 ")\n",
lpcspifi_info->dev->name, lpcspifi_info->dev->device_id); lpcspifi_info->dev->name, lpcspifi_info->dev->device_id);

7
src/flash/nor/max32xxx.c
View File

@ -113,17 +113,14 @@ FLASH_BANK_COMMAND_HANDLER(max32xxx_flash_bank_command)
return ERROR_OK; 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; struct max32xxx_flash_bank *info = bank->driver_priv;
if (!info->probed) if (!info->probed)
return ERROR_FLASH_BANK_NOT_PROBED; return ERROR_FLASH_BANK_NOT_PROBED;
printed = snprintf(buf, buf_size, "\nMaxim Integrated max32xxx flash driver\n"); command_print_sameline(cmd, "\nMaxim Integrated max32xxx flash driver\n");
buf += printed;
buf_size -= printed;
return ERROR_OK; return ERROR_OK;
} }

6
src/flash/nor/mdr.c
View File

@ -597,11 +597,11 @@ static int mdr_auto_probe(struct flash_bank *bank)
return mdr_probe(bank); 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; struct mdr_flash_bank *mdr_info = bank->driver_priv;
snprintf(buf, buf_size, "MDR32Fx - %s", command_print_sameline(cmd, "MDR32Fx - %s",
mdr_info->mem_type ? "info memory" : "main memory"); mdr_info->mem_type ? "info memory" : "main memory");
return ERROR_OK; return ERROR_OK;
} }

7
src/flash/nor/mrvlqspi.c
View File

@ -914,17 +914,16 @@ static int mrvlqspi_flash_erase_check(struct flash_bank *bank)
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; struct mrvlqspi_flash_bank *mrvlqspi_info = bank->driver_priv;
if (!(mrvlqspi_info->probed)) { if (!(mrvlqspi_info->probed)) {
snprintf(buf, buf_size, command_print_sameline(cmd, "\nQSPI flash bank not probed yet\n");
"\nQSPI flash bank not probed yet\n");
return ERROR_OK; 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", " Device \'%s\' ID 0x%08" PRIx32 "\n",
mrvlqspi_info->dev->name, mrvlqspi_info->dev->device_id); mrvlqspi_info->dev->name, mrvlqspi_info->dev->device_id);

28
src/flash/nor/msp432.c
View File

@ -975,60 +975,50 @@ static int msp432_auto_probe(struct flash_bank *bank)
return retval; 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; struct msp432_bank *msp432_bank = bank->driver_priv;
int printed = 0;
switch (msp432_bank->device_type) { switch (msp432_bank->device_type) {
case MSP432P401X_DEPR: case MSP432P401X_DEPR:
if (0xFFFF == msp432_bank->device_id) { if (0xFFFF == msp432_bank->device_id) {
/* Very early pre-production silicon currently deprecated */ /* Very early pre-production silicon currently deprecated */
printed = snprintf(buf, buf_size, command_print_sameline(cmd, "MSP432P401x pre-production device (deprecated silicon)\n"
"MSP432P401x pre-production device (deprecated silicon)\n"
SUPPORT_MESSAGE); SUPPORT_MESSAGE);
} else { } else {
/* Revision A or B silicon, also deprecated */ /* Revision A or B silicon, also deprecated */
printed = snprintf(buf, buf_size, command_print_sameline(cmd, "MSP432P401x Device Rev %c (deprecated silicon)\n"
"MSP432P401x Device Rev %c (deprecated silicon)\n"
SUPPORT_MESSAGE, (char)msp432_bank->hardware_rev); SUPPORT_MESSAGE, (char)msp432_bank->hardware_rev);
} }
break; break;
case MSP432P401X: case MSP432P401X:
printed = snprintf(buf, buf_size, command_print_sameline(cmd, "MSP432P401x Device Rev %c\n",
"MSP432P401x Device Rev %c\n",
(char)msp432_bank->hardware_rev); (char)msp432_bank->hardware_rev);
break; break;
case MSP432P411X: case MSP432P411X:
printed = snprintf(buf, buf_size, command_print_sameline(cmd, "MSP432P411x Device Rev %c\n",
"MSP432P411x Device Rev %c\n",
(char)msp432_bank->hardware_rev); (char)msp432_bank->hardware_rev);
break; break;
case MSP432E401Y: case MSP432E401Y:
printed = snprintf(buf, buf_size, "MSP432E401Y Device\n"); command_print_sameline(cmd, "MSP432E401Y Device\n");
break; break;
case MSP432E411Y: case MSP432E411Y:
printed = snprintf(buf, buf_size, "MSP432E411Y Device\n"); command_print_sameline(cmd, "MSP432E411Y Device\n");
break; break;
case MSP432E4X_GUESS: case MSP432E4X_GUESS:
printed = snprintf(buf, buf_size, command_print_sameline(cmd,
"Unrecognized MSP432E4 DID0 and DID1 IDs (%08" PRIX32 ", %08" PRIX32 ")", "Unrecognized MSP432E4 DID0 and DID1 IDs (%08" PRIX32 ", %08" PRIX32 ")",
msp432_bank->device_id, msp432_bank->hardware_rev); msp432_bank->device_id, msp432_bank->hardware_rev);
break; break;
case MSP432P401X_GUESS: case MSP432P401X_GUESS:
case MSP432P411X_GUESS: case MSP432P411X_GUESS:
default: default:
printed = snprintf(buf, buf_size, command_print_sameline(cmd,
"Unrecognized MSP432P4 Device ID and Hardware Rev (%04" PRIX32 ", %02" PRIX32 ")", "Unrecognized MSP432P4 Device ID and Hardware Rev (%04" PRIX32 ", %02" PRIX32 ")",
msp432_bank->device_id, msp432_bank->hardware_rev); msp432_bank->device_id, msp432_bank->hardware_rev);
break; break;
} }
buf_size -= printed;
if (0 > buf_size)
return ERROR_BUF_TOO_SMALL;
return ERROR_OK; return ERROR_OK;
} }

7
src/flash/nor/niietcm4.c
View File

@ -1719,12 +1719,11 @@ static int niietcm4_auto_probe(struct flash_bank *bank)
return niietcm4_probe(bank); 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; 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); command_print_sameline(cmd, "\nNIIET Cortex-M4F %s\n%s",
snprintf(buf, buf_size, " "); niietcm4_info->chip_name, niietcm4_info->chip_brief);
return ERROR_OK; return ERROR_OK;
} }

53
src/flash/nor/nrf5.c
View File

@ -624,35 +624,42 @@ static const char *nrf5_decode_info_package(uint32_t package)
return "xx"; 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; int res;
if (chip->spec) { if (chip->spec) {
res = snprintf(buf, buf_size, res = snprintf(buf, buf_size, "nRF%s-%s(build code: %s)",
"nRF%s-%s(build code: %s)",
chip->spec->part, chip->spec->variant, chip->spec->build_code); chip->spec->part, chip->spec->variant, chip->spec->build_code);
} else if (chip->ficr_info_valid) { } else if (chip->ficr_info_valid) {
char variant[5]; char variant[5];
nrf5_info_variant_to_str(chip->ficr_info.variant, variant); nrf5_info_variant_to_str(chip->ficr_info.variant, variant);
res = snprintf(buf, buf_size, res = snprintf(buf, buf_size, "nRF%" PRIx32 "-%s%.2s(build code: %s)",
"nRF%" PRIx32 "-%s%.2s(build code: %s)",
chip->ficr_info.part, chip->ficr_info.part,
nrf5_decode_info_package(chip->ficr_info.package), nrf5_decode_info_package(chip->ficr_info.package),
variant, &variant[2]); variant, &variant[2]);
} else { } else {
res = snprintf(buf, buf_size, "nRF51xxx (HWID 0x%04" PRIx16 ")", res = snprintf(buf, buf_size, "nRF51xxx (HWID 0x%04" PRIx16 ")", chip->hwid);
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;
}
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; return ERROR_FAIL;
snprintf(buf + res, buf_size - res, " %ukB Flash, %ukB RAM", command_print_sameline(cmd, "%s %ukB Flash, %ukB RAM",
chip->flash_size_kb, chip->ram_size_kb); chip_type_str, chip->flash_size_kb, chip->ram_size_kb);
return ERROR_OK; return ERROR_OK;
} }
@ -824,13 +831,15 @@ static int nrf5_probe(struct flash_bank *bank)
chip->flash_size_kb = num_sectors * flash_page_size / 1024; chip->flash_size_kb = num_sectors * flash_page_size / 1024;
if (!chip->bank[0].probed && !chip->bank[1].probed) { if (!chip->bank[0].probed && !chip->bank[1].probed) {
char buf[80]; char chip_type_str[256];
nrf5_info(bank, buf, sizeof(buf)); if (get_nrf5_chip_type_str(chip, chip_type_str, sizeof(chip_type_str)) != ERROR_OK)
if (!chip->spec && !chip->ficr_info_valid) { return ERROR_FAIL;
LOG_INFO("Unknown device: %s", buf); const bool device_is_unknown = (!chip->spec && !chip->ficr_info_valid);
} else { LOG_INFO("%s%s %ukB Flash, %ukB RAM",
LOG_INFO("%s", buf); device_is_unknown ? "Unknown device: " : "",
} chip_type_str,
chip->flash_size_kb,
chip->ram_size_kb);
} }
free(bank->sectors); free(bank->sectors);

20
src/flash/nor/pic32mx.c
View File

@ -801,37 +801,35 @@ static int pic32mx_auto_probe(struct flash_bank *bank)
return pic32mx_probe(bank); 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 target *target = bank->target;
struct mips32_common *mips32 = target->arch_info; struct mips32_common *mips32 = target->arch_info;
struct mips_ejtag *ejtag_info = &mips32->ejtag_info; struct mips_ejtag *ejtag_info = &mips32->ejtag_info;
uint32_t device_id; uint32_t device_id;
int printed = 0, i;
device_id = ejtag_info->idcode; device_id = ejtag_info->idcode;
if (((device_id >> 1) & 0x7ff) != PIC32MX_MANUF_ID) { if (((device_id >> 1) & 0x7ff) != PIC32MX_MANUF_ID) {
snprintf(buf, buf_size, command_print_sameline(cmd,
"Cannot identify target as a PIC32MX family (manufacturer 0x%03x != 0x%03x)\n", "Cannot identify target as a PIC32MX family (manufacturer 0x%03x != 0x%03x)\n",
(unsigned)((device_id >> 1) & 0x7ff), (unsigned)((device_id >> 1) & 0x7ff),
PIC32MX_MANUF_ID); PIC32MX_MANUF_ID);
return ERROR_FLASH_OPERATION_FAILED; return ERROR_FLASH_OPERATION_FAILED;
} }
int i;
for (i = 0; pic32mx_devs[i].name != NULL; i++) { for (i = 0; pic32mx_devs[i].name != NULL; i++) {
if (pic32mx_devs[i].devid == (device_id & 0x0fffffff)) { 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; break;
} }
} }
if (pic32mx_devs[i].name == NULL) if (pic32mx_devs[i].name == NULL)
printed = snprintf(buf, buf_size, "Unknown"); command_print_sameline(cmd, "Unknown");
buf += printed; command_print_sameline(cmd, " Ver: 0x%02x",
buf_size -= printed;
snprintf(buf, buf_size, " Ver: 0x%02x",
(unsigned)((device_id >> 28) & 0xf)); (unsigned)((device_id >> 28) & 0xf));
return ERROR_OK; return ERROR_OK;

17
src/flash/nor/psoc4.c
View File

@ -851,7 +851,7 @@ static int psoc4_auto_probe(struct flash_bank *bank)
} }
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 target *target = bank->target;
struct psoc4_flash_bank *psoc4_info = bank->driver_priv; struct psoc4_flash_bank *psoc4_info = bank->driver_priv;
@ -863,35 +863,30 @@ static int get_psoc4_info(struct flash_bank *bank, char *buf, int buf_size)
uint32_t size_in_kb = bank->size / 1024; uint32_t size_in_kb = bank->size / 1024;
if (target->state != TARGET_HALTED) { 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); " (halt target to see details)", family->name, size_in_kb);
return ERROR_OK; return ERROR_OK;
} }
int retval;
int printed = 0;
uint32_t silicon_id; uint32_t silicon_id;
uint16_t family_id; uint16_t family_id;
uint8_t protection; 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) if (retval != ERROR_OK)
return retval; return retval;
if (family_id != psoc4_info->family_id) 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, "/0x%02" PRIx16 ", silicon id 0x%08" PRIx32,
psoc4_info->family_id, family_id, silicon_id); psoc4_info->family_id, family_id, silicon_id);
else { 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); family->name, silicon_id);
} }
buf += printed;
buf_size -= printed;
const char *prot_txt = psoc4_decode_chip_protection(protection); 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; return ERROR_OK;
} }

12
src/flash/nor/psoc5lp.c
View File

@ -753,14 +753,14 @@ static int psoc5lp_nvl_write(struct flash_bank *bank,
} }
static int psoc5lp_nvl_get_info_command(struct flash_bank *bank, 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; struct psoc5lp_nvl_flash_bank *psoc_nvl_bank = bank->driver_priv;
char part_number[PART_NUMBER_LEN]; char part_number[PART_NUMBER_LEN];
psoc5lp_get_part_number(psoc_nvl_bank->device, part_number); 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;
} }
@ -934,14 +934,14 @@ static int psoc5lp_eeprom_write(struct flash_bank *bank,
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; struct psoc5lp_eeprom_flash_bank *psoc_eeprom_bank = bank->driver_priv;
char part_number[PART_NUMBER_LEN]; char part_number[PART_NUMBER_LEN];
psoc5lp_get_part_number(psoc_eeprom_bank->device, part_number); 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;
} }
@ -1397,7 +1397,7 @@ static int psoc5lp_protect_check(struct flash_bank *bank)
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; struct psoc5lp_flash_bank *psoc_bank = bank->driver_priv;
char part_number[PART_NUMBER_LEN]; char part_number[PART_NUMBER_LEN];
@ -1406,7 +1406,7 @@ static int psoc5lp_get_info_command(struct flash_bank *bank, char *buf, int buf_
psoc5lp_get_part_number(psoc_bank->device, part_number); psoc5lp_get_part_number(psoc_bank->device, part_number);
ecc = psoc_bank->ecc_enabled ? "ECC enabled" : "ECC disabled"; 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; return ERROR_OK;
} }

4
src/flash/nor/psoc6.c
View File

@ -495,7 +495,7 @@ static const char *protection_to_str(uint8_t protection)
* @param buf_size size of the buffer * @param buf_size size of the buffer
* @return ERROR_OK in case of success, ERROR_XXX code otherwise * @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; struct psoc6_target_info *psoc6_info = bank->driver_priv;
@ -506,7 +506,7 @@ static int psoc6_get_info(struct flash_bank *bank, char *buf, int buf_size)
if (hr != ERROR_OK) if (hr != ERROR_OK)
return hr; return hr;
snprintf(buf, buf_size, command_print_sameline(cmd,
"PSoC6 Silicon ID: 0x%08" PRIX32 "\n" "PSoC6 Silicon ID: 0x%08" PRIX32 "\n"
"Protection: %s\n" "Protection: %s\n"
"Main Flash size: %" PRIu32 " kB\n" "Main Flash size: %" PRIu32 " kB\n"

7
src/flash/nor/sh_qspi.c
View File

@ -851,17 +851,16 @@ static int sh_qspi_protect_check(struct flash_bank *bank)
return ERROR_OK; 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; struct sh_qspi_flash_bank *info = bank->driver_priv;
if (!info->probed) { if (!info->probed) {
snprintf(buf, buf_size, command_print_sameline(cmd, "\nSH QSPI flash bank not probed yet\n");
"\nSH QSPI flash bank not probed yet\n");
return ERROR_OK; 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", " Device \'%s\' (ID 0x%08" PRIx32 ")\n",
info->dev->name, info->dev->device_id); info->dev->name, info->dev->device_id);

33
src/flash/nor/sim3x.c
View File

@ -834,53 +834,32 @@ static int sim3x_auto_probe(struct flash_bank *bank)
} }
} }
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; struct sim3x_info *sim3x_info;
sim3x_info = bank->driver_priv; sim3x_info = bank->driver_priv;
/* Read info about chip */ /* Read info about chip */
ret = sim3x_read_info(bank); int ret = sim3x_read_info(bank);
if (ret != ERROR_OK) if (ret != ERROR_OK)
return ret; return ret;
/* Part */ /* Part */
if (sim3x_info->part_family && sim3x_info->part_number) { 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); command_print_sameline(cmd, "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;
/* Revision */ /* Revision */
if (sim3x_info->device_revision && sim3x_info->device_revision <= 'Z' - 'A') { if (sim3x_info->device_revision && sim3x_info->device_revision <= 'Z' - 'A') {
printed = snprintf(buf, buf_size, "-%c", sim3x_info->device_revision + 'A'); command_print_sameline(cmd, "-%c", sim3x_info->device_revision + 'A');
buf += printed;
buf_size -= printed;
if (buf_size <= 0)
return ERROR_BUF_TOO_SMALL;
/* Package */ /* Package */
printed = snprintf(buf, buf_size, "-G%s", sim3x_info->device_package); command_print_sameline(cmd, "-G%s", sim3x_info->device_package);
buf += printed;
buf_size -= printed;
if (buf_size <= 0)
return ERROR_BUF_TOO_SMALL;
} }
} }
/* Print flash size */ /* Print flash size */
printed = snprintf(buf, buf_size, " flash_size = %dKB", sim3x_info->flash_size_kb); command_print_sameline(cmd, " flash_size = %dKB", sim3x_info->flash_size_kb);
buf_size -= printed;
if (buf_size <= 0)
return ERROR_BUF_TOO_SMALL;
return ERROR_OK; return ERROR_OK;
} }

62
src/flash/nor/stellaris.c
View File

@ -479,9 +479,8 @@ FLASH_BANK_COMMAND_HANDLER(stellaris_flash_bank_command)
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; struct stellaris_flash_bank *stellaris_info = bank->driver_priv;
if (stellaris_info->did1 == 0) if (stellaris_info->did1 == 0)
@ -490,41 +489,34 @@ static int get_stellaris_info(struct flash_bank *bank, char *buf, int buf_size)
/* Read main and master clock frequency register */ /* Read main and master clock frequency register */
stellaris_read_clock_info(bank); stellaris_read_clock_info(bank);
printed = snprintf(buf, command_print_sameline(cmd,
buf_size, "\nTI/LMI Stellaris information: Chip is "
"\nTI/LMI Stellaris information: Chip is " "class %i (%s) %s rev %c%i\n",
"class %i (%s) %s rev %c%i\n", stellaris_info->target_class,
stellaris_info->target_class, StellarisClassname[stellaris_info->target_class],
StellarisClassname[stellaris_info->target_class], stellaris_info->target_name,
stellaris_info->target_name, (int)('A' + ((stellaris_info->did0 >> 8) & 0xFF)),
(int)('A' + ((stellaris_info->did0 >> 8) & 0xFF)), (int)((stellaris_info->did0) & 0xFF));
(int)((stellaris_info->did0) & 0xFF));
buf += printed;
buf_size -= printed;
printed = snprintf(buf, command_print_sameline(cmd,
buf_size, "did1: 0x%8.8" PRIx32 ", arch: 0x%4.4" PRIx32
"did1: 0x%8.8" PRIx32 ", arch: 0x%4.4" PRIx32 ", eproc: %s, ramsize: %" PRIu32 "k, flashsize: %" PRIu32 "k\n",
", eproc: %s, ramsize: %" PRIu32 "k, flashsize: %" PRIu32 "k\n", stellaris_info->did1,
stellaris_info->did1, stellaris_info->did1,
stellaris_info->did1, "ARMv7M",
"ARMv7M", stellaris_info->sramsiz,
stellaris_info->sramsiz, (uint32_t)(stellaris_info->num_pages * stellaris_info->pagesize / 1024));
(uint32_t)(stellaris_info->num_pages * stellaris_info->pagesize / 1024));
buf += printed;
buf_size -= printed;
snprintf(buf, command_print_sameline(cmd,
buf_size, "master clock: %ikHz%s, "
"master clock: %ikHz%s, " "rcc is 0x%" PRIx32 ", rcc2 is 0x%" PRIx32 ", "
"rcc is 0x%" PRIx32 ", rcc2 is 0x%" PRIx32 ", " "pagesize: %" PRIu32 ", pages: %" PRIu32,
"pagesize: %" PRIu32 ", pages: %" PRIu32, (int)(stellaris_info->mck_freq / 1000),
(int)(stellaris_info->mck_freq / 1000), stellaris_info->mck_desc,
stellaris_info->mck_desc, stellaris_info->rcc,
stellaris_info->rcc, stellaris_info->rcc2,
stellaris_info->rcc2, stellaris_info->pagesize,
stellaris_info->pagesize, stellaris_info->num_pages);
stellaris_info->num_pages);
return ERROR_OK; return ERROR_OK;
} }

10
src/flash/nor/stm32f1x.c
View File

@ -954,11 +954,11 @@ static const char *get_stm32f0_revision(uint16_t rev_id)
return rev_str; 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; uint32_t dbgmcu_idcode;
/* read stm32 device id register */ /* read stm32 device id register */
int retval = stm32x_get_device_id(bank, &dbgmcu_idcode); int retval = stm32x_get_device_id(bank, &dbgmcu_idcode);
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
@ -1174,14 +1174,14 @@ static int get_stm32x_info(struct flash_bank *bank, char *buf, int buf_size)
break; break;
default: 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; return ERROR_FAIL;
} }
if (rev_str != NULL) 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 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 ERROR_OK;
} }

8
src/flash/nor/stm32f2x.c
View File

@ -1251,7 +1251,7 @@ static int stm32x_auto_probe(struct flash_bank *bank)
return stm32x_probe(bank); 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; uint32_t dbgmcu_idcode;
@ -1416,14 +1416,14 @@ static int get_stm32x_info(struct flash_bank *bank, char *buf, int buf_size)
break; break;
default: 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; return ERROR_FAIL;
} }
if (rev_str != NULL) 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 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; return ERROR_OK;
} }

12
src/flash/nor/stm32h7x.c
View File

@ -916,7 +916,7 @@ static int stm32x_auto_probe(struct flash_bank *bank)
} }
/* This method must return a string displaying information about the bank */ /* 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; struct stm32h7x_flash_bank *stm32x_info = bank->driver_priv;
const struct stm32h7x_part_info *info = stm32x_info->part_info; const struct stm32h7x_part_info *info = stm32x_info->part_info;
@ -924,7 +924,7 @@ static int stm32x_get_info(struct flash_bank *bank, char *buf, int buf_size)
if (!stm32x_info->probed) { if (!stm32x_info->probed) {
int retval = stm32x_probe(bank); int retval = stm32x_probe(bank);
if (retval != ERROR_OK) { if (retval != ERROR_OK) {
snprintf(buf, buf_size, "Unable to find bank information."); command_print_sameline(cmd, "Unable to find bank information.");
return retval; return retval;
} }
} }
@ -938,16 +938,16 @@ static int stm32x_get_info(struct flash_bank *bank, char *buf, int buf_size)
rev_str = info->revs[i].str; rev_str = info->revs[i].str;
if (rev_str != NULL) { 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); stm32x_info->part_info->device_str, rev_str);
} else { } else {
snprintf(buf, buf_size, command_print_sameline(cmd,
"%s - Rev: unknown (0x%04" PRIx16 ")", "%s - Rev: unknown (0x%04" PRIx16 ")",
stm32x_info->part_info->device_str, rev_id); stm32x_info->part_info->device_str, rev_id);
} }
} else { } else {
snprintf(buf, buf_size, "Cannot identify target as a STM32H7x"); command_print_sameline(cmd, "Cannot identify target as a STM32H7x");
return ERROR_FAIL; return ERROR_FAIL;
} }
return ERROR_OK; return ERROR_OK;
} }

64
src/flash/nor/stm32l4x.c
View File

@ -1332,13 +1332,36 @@ static int stm32l4_read_idcode(struct flash_bank *bank, uint32_t *id)
return (retval == ERROR_OK) ? ERROR_FAIL : retval; 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) static int stm32l4_probe(struct flash_bank *bank)
{ {
struct target *target = bank->target; struct target *target = bank->target;
struct stm32l4_flash_bank *stm32l4_info = bank->driver_priv; struct stm32l4_flash_bank *stm32l4_info = bank->driver_priv;
const struct stm32l4_part_info *part_info; const struct stm32l4_part_info *part_info;
uint16_t flash_size_kb = 0xffff; uint16_t flash_size_kb = 0xffff;
uint32_t device_id;
uint32_t options; uint32_t options;
stm32l4_info->probed = false; stm32l4_info->probed = false;
@ -1348,7 +1371,9 @@ static int stm32l4_probe(struct flash_bank *bank)
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; 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++) { for (unsigned int n = 0; n < ARRAY_SIZE(stm32l4_parts); n++) {
if (device_id == stm32l4_parts[n].id) { if (device_id == stm32l4_parts[n].id) {
@ -1365,12 +1390,9 @@ static int stm32l4_probe(struct flash_bank *bank)
part_info = stm32l4_info->part_info; part_info = stm32l4_info->part_info;
stm32l4_info->flash_regs = stm32l4_info->part_info->default_flash_regs; stm32l4_info->flash_regs = stm32l4_info->part_info->default_flash_regs;
char device_info[1024]; LOG_INFO("device idcode = 0x%08" PRIx32 " (%s - Rev %s : 0x%04x - %s-bank)",
retval = bank->driver->info(bank, device_info, sizeof(device_info)); stm32l4_info->idcode, part_info->device_str, rev_str, rev_id,
if (retval != ERROR_OK) get_stm32l4_bank_type_str(bank));
return retval;
LOG_INFO("device idcode = 0x%08" PRIx32 " (%s)", stm32l4_info->idcode, device_info);
/* read flash option register */ /* read flash option register */
retval = stm32l4_read_flash_reg_by_index(bank, STM32_FLASH_OPTR_INDEX, &options); retval = stm32l4_read_flash_reg_by_index(bank, STM32_FLASH_OPTR_INDEX, &options);
@ -1610,33 +1632,19 @@ static int stm32l4_auto_probe(struct flash_bank *bank)
return stm32l4_probe(bank); 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; struct stm32l4_flash_bank *stm32l4_info = bank->driver_priv;
const struct stm32l4_part_info *part_info = stm32l4_info->part_info; const struct stm32l4_part_info *part_info = stm32l4_info->part_info;
if (part_info) { if (part_info) {
const char *rev_str = NULL; const uint16_t rev_id = stm32l4_info->idcode >> 16;
uint16_t rev_id = stm32l4_info->idcode >> 16; command_print_sameline(cmd, "%s - Rev %s : 0x%04x", part_info->device_str,
for (unsigned int i = 0; i < part_info->num_revs; i++) { get_stm32l4_rev_str(bank), rev_id);
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);
if (stm32l4_info->probed) if (stm32l4_info->probed)
snprintf(buf + buf_len, buf_size - buf_len, " - %s-bank", command_print_sameline(cmd, " - %s-bank", get_stm32l4_bank_type_str(bank));
stm32l4_is_otp(bank) ? "OTP" :
stm32l4_info->dual_bank_mode ? "Flash dual" : "Flash single");
return ERROR_OK;
} else { } else {
snprintf(buf, buf_size, "Cannot identify target as an %s device", device_families); command_print_sameline(cmd, "Cannot identify target as an %s device", device_families);
return ERROR_FAIL;
} }
return ERROR_OK; return ERROR_OK;

13
src/flash/nor/stm32lx.c
View File

@ -870,7 +870,7 @@ static int stm32lx_auto_probe(struct flash_bank *bank)
} }
/* This method must return a string displaying information about the bank */ /* 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; struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv;
const struct stm32lx_part_info *info = &stm32lx_info->part_info; const struct stm32lx_part_info *info = &stm32lx_info->part_info;
@ -880,8 +880,7 @@ static int stm32lx_get_info(struct flash_bank *bank, char *buf, int buf_size)
if (!stm32lx_info->probed) { if (!stm32lx_info->probed) {
int retval = stm32lx_probe(bank); int retval = stm32lx_probe(bank);
if (retval != ERROR_OK) { if (retval != ERROR_OK) {
snprintf(buf, buf_size, command_print_sameline(cmd, "Unable to find bank information.");
"Unable to find bank information.");
return retval; return retval;
} }
} }
@ -891,13 +890,9 @@ static int stm32lx_get_info(struct flash_bank *bank, char *buf, int buf_size)
rev_str = info->revs[i].str; rev_str = info->revs[i].str;
if (rev_str != NULL) { if (rev_str != NULL) {
snprintf(buf, buf_size, command_print_sameline(cmd, "%s - Rev: %s", info->device_str, rev_str);
"%s - Rev: %s",
info->device_str, rev_str);
} else { } else {
snprintf(buf, buf_size, command_print_sameline(cmd, "%s - Rev: unknown (0x%04x)", info->device_str, rev_id);
"%s - Rev: unknown (0x%04x)",
info->device_str, rev_id);
} }
return ERROR_OK; return ERROR_OK;

7
src/flash/nor/stmqspi.c
View File

@ -2397,17 +2397,16 @@ static int stmqspi_protect_check(struct flash_bank *bank)
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; struct stmqspi_flash_bank *stmqspi_info = bank->driver_priv;
if (!(stmqspi_info->probed)) { if (!(stmqspi_info->probed)) {
snprintf(buf, buf_size, command_print_sameline(cmd, "\nQSPI flash bank not probed yet\n");
"\nQSPI flash bank not probed yet\n");
return ERROR_FLASH_BANK_NOT_PROBED; 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 ", flash size = %" PRIu32 "%sbytes\n(page size = %" PRIu32
", read = 0x%02" PRIx8 ", qread = 0x%02" PRIx8 ", read = 0x%02" PRIx8 ", qread = 0x%02" PRIx8
", pprog = 0x%02" PRIx8 ", mass_erase = 0x%02" PRIx8 ", pprog = 0x%02" PRIx8 ", mass_erase = 0x%02" PRIx8

7
src/flash/nor/stmsmi.c
View File

@ -631,17 +631,16 @@ static int stmsmi_protect_check(struct flash_bank *bank)
return ERROR_OK; 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; struct stmsmi_flash_bank *stmsmi_info = bank->driver_priv;
if (!(stmsmi_info->probed)) { if (!(stmsmi_info->probed)) {
snprintf(buf, buf_size, command_print_sameline(cmd, "\nSMI flash bank not probed yet\n");
"\nSMI flash bank not probed yet\n");
return ERROR_OK; 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", " Device \'%s\' (ID 0x%08" PRIx32 ")\n",
stmsmi_info->dev->name, stmsmi_info->dev->device_id); stmsmi_info->dev->name, stmsmi_info->dev->device_id);

4
src/flash/nor/str7x.c
View File

@ -702,13 +702,13 @@ COMMAND_HANDLER(str7x_handle_part_id_command)
} }
#endif #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 /* Setting the write protection on a sector is a permanent change but it
* can be disabled temporarily. FLASH_NVWPAR reflects the permanent * can be disabled temporarily. FLASH_NVWPAR reflects the permanent
* protection state of the sectors, not the temporary. * 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 " "clearing the protection is only temporary and may not be reflected in the current "
"info returned."); "info returned.");
return ERROR_OK; return ERROR_OK;

9
src/flash/nor/tcl.c
View File

@ -89,7 +89,6 @@ COMMAND_HANDLER(handle_flash_info_command)
return retval; return retval;
if (p != NULL) { if (p != NULL) {
char buf[1024];
int num_blocks; int num_blocks;
struct flash_sector *block_array; struct flash_sector *block_array;
@ -150,10 +149,10 @@ COMMAND_HANDLER(handle_flash_info_command)
} }
if (p->driver->info != NULL) { if (p->driver->info != NULL) {
retval = p->driver->info(p, buf, sizeof(buf)); /* Let the flash driver print extra custom info */
if (retval == ERROR_OK) retval = p->driver->info(p, CMD);
command_print(CMD, "%s", buf); command_print_sameline(CMD, "\n");
else if (retval != ERROR_OK)
LOG_ERROR("error retrieving flash info"); LOG_ERROR("error retrieving flash info");
} }
} }

14
src/flash/nor/tms470.c
View File

@ -1118,26 +1118,20 @@ static int tms470_protect_check(struct flash_bank *bank)
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
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; struct tms470_flash_bank *tms470_info = bank->driver_priv;
if (!tms470_info->device_ident_reg) if (!tms470_info->device_ident_reg)
tms470_read_part_info(bank); tms470_read_part_info(bank);
if (!tms470_info->device_ident_reg) { 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; return ERROR_FLASH_OPERATION_FAILED;
} }
used = command_print_sameline(cmd, "\ntms470 information: Chip is %s\n", tms470_info->part_name);
snprintf(buf, buf_size, "\ntms470 information: Chip is %s\n", command_print_sameline(cmd, "Flash protection level 2 is %s\n",
tms470_info->part_name);
buf += used;
buf_size -= used;
snprintf(buf, buf_size, "Flash protection level 2 is %s\n",
tms470_check_flash_unlocked(bank->target) == ERROR_OK ? "disabled" : "enabled"); tms470_check_flash_unlocked(bank->target) == ERROR_OK ? "disabled" : "enabled");
return ERROR_OK; return ERROR_OK;

4
src/flash/nor/virtual.c
View File

@ -172,14 +172,14 @@ static int virtual_auto_probe(struct flash_bank *bank)
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); struct flash_bank *master_bank = virtual_get_master_bank(bank);
if (master_bank == NULL) if (master_bank == NULL)
return ERROR_FLASH_OPERATION_FAILED; 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); bank->driver->name, master_bank->name, master_bank->base);
return ERROR_OK; return ERROR_OK;

4
src/flash/nor/w600.c
View File

@ -362,7 +362,7 @@ static int w600_auto_probe(struct flash_bank *bank)
return w600_probe(bank); 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; uint32_t flash_id;
@ -371,7 +371,7 @@ static int get_w600_info(struct flash_bank *bank, char *buf, int buf_size)
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; 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;
} }

6
src/flash/nor/xcf.c
View File

@ -581,15 +581,15 @@ FLASH_BANK_COMMAND_HANDLER(xcf_flash_bank_command)
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; const struct xcf_priv *priv = bank->driver_priv;
if (!priv->probed) { 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; 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;
} }

5
src/flash/nor/xmc1xxx.c
View File

@ -403,7 +403,7 @@ static int xmc1xxx_protect_check(struct flash_bank *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]; uint32_t chipid[8];
int i, retval; int i, retval;
@ -429,7 +429,8 @@ static int xmc1xxx_get_info_command(struct flash_bank *bank, char *buf, int buf_
} }
LOG_DEBUG("ID[7] = %08" PRIX32, chipid[7]); 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, (chipid[0] >> 12) & 0xff,
0xAA + (chipid[7] >> 28) - 1, 0xAA + (chipid[7] >> 28) - 1,
(((chipid[6] >> 12) & 0x3f) - 1) * 4, (((chipid[6] >> 12) & 0x3f) - 1) * 4,

12
src/flash/nor/xmc4xxx.c
View File

@ -805,7 +805,7 @@ abort_write_and_exit:
} }
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; struct xmc4xxx_flash_bank *fb = bank->driver_priv;
uint32_t scu_idcode; uint32_t scu_idcode;
@ -914,9 +914,7 @@ static int xmc4xxx_get_info_command(struct flash_bank *bank, char *buf, int buf_
break; break;
default: default:
snprintf(buf, buf_size, command_print_sameline(cmd, "Cannot identify target as an XMC4xxx. SCU_ID: %"PRIx32 "\n", scu_idcode);
"Cannot identify target as an XMC4xxx. SCU_ID: %"PRIx32"\n",
scu_idcode);
return ERROR_OK; return ERROR_OK;
} }
@ -944,11 +942,9 @@ static int xmc4xxx_get_info_command(struct flash_bank *bank, char *buf, int buf_
} }
if (rev_str != NULL) if (rev_str != NULL)
snprintf(buf, buf_size, "%s - Rev: %s%s", command_print_sameline(cmd, "%s - Rev: %s%s", dev_str, rev_str, prot_str);
dev_str, rev_str, prot_str);
else else
snprintf(buf, buf_size, "%s - Rev: unknown (0x%01x)%s", command_print_sameline(cmd, "%s - Rev: unknown (0x%01x)%s", dev_str, rev_id, prot_str);
dev_str, rev_id, prot_str);
return ERROR_OK; return ERROR_OK;
} }