sys64738
/
blackmagic
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

target_flash: change return types to bool

This commit is contained in:
Rafael Silva 2022-08-24 11:49:09 +01:00 committed by Rachel Mant
parent aec7460426
commit 1a1f4b76ff
7 changed files with 77 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/gdb_main.c
View File

@ -630,7 +630,7 @@ static void handle_v_packet(char *packet, const size_t plen)
return; return;
} }
if (target_flash_erase(cur_target, addr, len) == 0) if (target_flash_erase(cur_target, addr, len))
gdb_putpacketz("OK"); gdb_putpacketz("OK");
else { else {
target_flash_complete(cur_target); target_flash_complete(cur_target);
@ -641,7 +641,7 @@ static void handle_v_packet(char *packet, const size_t plen)
/* Write Flash Memory */ /* Write Flash Memory */
const uint32_t count = plen - bin; const uint32_t count = plen - bin;
DEBUG_GDB("Flash Write %08" PRIX32 " %08" PRIX32 "\n", addr, count); DEBUG_GDB("Flash Write %08" PRIX32 " %08" PRIX32 "\n", addr, count);
if (cur_target && target_flash_write(cur_target, addr, (void*)packet + bin, count) == 0) if (cur_target && target_flash_write(cur_target, addr, (void*)packet + bin, count))
gdb_putpacketz("OK"); gdb_putpacketz("OK");
else { else {
target_flash_complete(cur_target); target_flash_complete(cur_target);
@ -650,7 +650,7 @@ static void handle_v_packet(char *packet, const size_t plen)
} else if (!strcmp(packet, "vFlashDone")) { } else if (!strcmp(packet, "vFlashDone")) {
/* Commit flash operations. */ /* Commit flash operations. */
if (target_flash_complete(cur_target) == 0) if (target_flash_complete(cur_target))
gdb_putpacketz("OK"); gdb_putpacketz("OK");
else else
gdb_putpacketz("EFF"); gdb_putpacketz("EFF");

6
src/include/target.h
View File

@ -59,9 +59,9 @@ bool target_mem_map(target *t, char *buf, size_t len);
int target_mem_read(target *t, void *dest, target_addr_t src, size_t len); int target_mem_read(target *t, void *dest, target_addr_t src, size_t len);
int target_mem_write(target *t, target_addr_t dest, const void *src, size_t len); int target_mem_write(target *t, target_addr_t dest, const void *src, size_t len);
/* Flash memory access functions */ /* Flash memory access functions */
int target_flash_erase(target *t, target_addr_t addr, size_t len); bool target_flash_erase(target *t, target_addr_t addr, size_t len);
int target_flash_write(target *t, target_addr_t dest, const void *src, size_t len); bool target_flash_write(target *t, target_addr_t dest, const void *src, size_t len);
int target_flash_complete(target *t); bool target_flash_complete(target *t);
/* Register access functions */ /* Register access functions */
size_t target_regs_size(target *t); size_t target_regs_size(target *t);

26
src/platforms/hosted/cli.c
View File

@ -549,36 +549,24 @@ found_targets:
if (opt->opt_mode == BMP_MODE_RESET) { if (opt->opt_mode == BMP_MODE_RESET) {
target_reset(t); target_reset(t);
} else if (opt->opt_mode == BMP_MODE_FLASH_ERASE) { } else if (opt->opt_mode == BMP_MODE_FLASH_ERASE) {
DEBUG_INFO("Erase %zu bytes at 0x%08" PRIx32 "\n", opt->opt_flash_size, DEBUG_INFO("Erase %zu bytes at 0x%08" PRIx32 "\n", opt->opt_flash_size, opt->opt_flash_start);
opt->opt_flash_start); if (!target_flash_erase(t, opt->opt_flash_start, opt->opt_flash_size)) {
unsigned int erased = target_flash_erase(t, opt->opt_flash_start,
opt->opt_flash_size);
if (erased) {
DEBUG_WARN("Erasure failed!\n"); DEBUG_WARN("Erasure failed!\n");
res = -1; res = -1;
goto free_map; goto free_map;
} }
target_reset(t); target_reset(t);
} else if ((opt->opt_mode == BMP_MODE_FLASH_WRITE) || } else if ((opt->opt_mode == BMP_MODE_FLASH_WRITE) || (opt->opt_mode == BMP_MODE_FLASH_WRITE_VERIFY)) {
(opt->opt_mode == BMP_MODE_FLASH_WRITE_VERIFY)) { DEBUG_INFO("Erase %zu bytes at 0x%08" PRIx32 "\n", map.size, opt->opt_flash_start);
DEBUG_INFO("Erase %zu bytes at 0x%08" PRIx32 "\n", map.size,
opt->opt_flash_start);
uint32_t start_time = platform_time_ms(); uint32_t start_time = platform_time_ms();
unsigned int erased = target_flash_erase(t, opt->opt_flash_start, if (!target_flash_erase(t, opt->opt_flash_start, map.size)) {
map.size);
if (erased) {
DEBUG_WARN("Erasure failed!\n"); DEBUG_WARN("Erasure failed!\n");
res = -1; res = -1;
goto free_map; goto free_map;
} else { } else {
DEBUG_INFO("Flashing %zu bytes at 0x%08" PRIx32 "\n", DEBUG_INFO("Flashing %zu bytes at 0x%08" PRIx32 "\n", map.size, opt->opt_flash_start);
map.size, opt->opt_flash_start);
unsigned int flashed = target_flash_write(t, opt->opt_flash_start,
map.data, map.size);
/* Buffered write cares for padding*/ /* Buffered write cares for padding*/
if (!flashed) if (!target_flash_write(t, opt->opt_flash_start, map.data, map.size) || !target_flash_complete(t)) {
flashed = target_flash_complete(t);
if (flashed) {
DEBUG_WARN("Flashing failed!\n"); DEBUG_WARN("Flashing failed!\n");
res = -1; res = -1;
goto free_map; goto free_map;

10
src/target/kinetis.c
View File

@ -113,7 +113,7 @@ static bool kinetis_cmd_unsafe(target *t, int argc, char **argv)
static int kinetis_flash_cmd_erase(target_flash_s *f, target_addr_t addr, size_t len); static int kinetis_flash_cmd_erase(target_flash_s *f, target_addr_t addr, size_t len);
static int kinetis_flash_cmd_write(target_flash_s *f, target_addr_t dest, const void *src, size_t len); static int kinetis_flash_cmd_write(target_flash_s *f, target_addr_t dest, const void *src, size_t len);
static int kinetis_flash_done(target_flash_s *f); static bool kinetis_flash_done(target_flash_s *f);
struct kinetis_flash { struct kinetis_flash {
target_flash_s f; target_flash_s f;
@ -479,15 +479,15 @@ static int kinetis_flash_cmd_write(target_flash_s *f, target_addr_t dest, const
return 0; return 0;
} }
static int kinetis_flash_done(target_flash_s *const f) static bool kinetis_flash_done(target_flash_s *const f)
{ {
struct kinetis_flash *const kf = (struct kinetis_flash *)f; struct kinetis_flash *const kf = (struct kinetis_flash *)f;
if (f->t->unsafe_enabled) if (f->t->unsafe_enabled)
return 0; return true;
if (target_mem_read8(f->t, FLASH_SECURITY_BYTE_ADDRESS) == FLASH_SECURITY_BYTE_UNSECURED) if (target_mem_read8(f->t, FLASH_SECURITY_BYTE_ADDRESS) == FLASH_SECURITY_BYTE_UNSECURED)
return 0; return true;
/* Load the security byte based on the alignment (determine 8 byte phrases /* Load the security byte based on the alignment (determine 8 byte phrases
* vs 4 byte phrases). * vs 4 byte phrases).
@ -505,7 +505,7 @@ static int kinetis_flash_done(target_flash_s *const f)
kinetis_fccob_cmd(f->t, FTFx_CMD_PROGRAM_LONGWORD, FLASH_SECURITY_BYTE_ADDRESS, &val, 1); kinetis_fccob_cmd(f->t, FTFx_CMD_PROGRAM_LONGWORD, FLASH_SECURITY_BYTE_ADDRESS, &val, 1);
} }
return 0; return true;
} }
/*** Kinetis recovery mode using the MDM-AP ***/ /*** Kinetis recovery mode using the MDM-AP ***/

16
src/target/nxpke04.c
View File

@ -118,7 +118,7 @@ static const uint8_t cmdLen[] = {
static bool ke04_command(target *t, uint8_t cmd, uint32_t addr, const uint8_t data[8]); static bool ke04_command(target *t, uint8_t cmd, uint32_t addr, const uint8_t data[8]);
static int ke04_flash_erase(target_flash_s *f, target_addr_t addr, size_t len); static int ke04_flash_erase(target_flash_s *f, target_addr_t addr, size_t len);
static int ke04_flash_write(target_flash_s *f, target_addr_t dest, const void *src, size_t len); static int ke04_flash_write(target_flash_s *f, target_addr_t dest, const void *src, size_t len);
static int ke04_flash_done(target_flash_s *f); static bool ke04_flash_done(target_flash_s *f);
static bool ke04_mass_erase(target *t); static bool ke04_mass_erase(target *t);
/* Target specific commands */ /* Target specific commands */
@ -359,22 +359,20 @@ static int ke04_flash_write(target_flash_s *f, target_addr_t dest, const void *s
return 0; return 0;
} }
static int ke04_flash_done(target_flash_s *f) static bool ke04_flash_done(target_flash_s *f)
{ {
target *t = f->t; target *t = f->t;
if (t->unsafe_enabled) if (t->unsafe_enabled)
return 0; return true;
if (target_mem_read8(f->t, FLASH_SECURITY_BYTE_ADDRESS) == if (target_mem_read8(f->t, FLASH_SECURITY_BYTE_ADDRESS) == FLASH_SECURITY_BYTE_UNSECURED)
FLASH_SECURITY_BYTE_UNSECURED) return true;
return 0;
/* Load the security byte from its field */ /* Load the security byte from its field */
/* Note: Cumulative programming is not allowed according to the RM */ /* Note: Cumulative programming is not allowed according to the RM */
uint32_t vals[2] = {target_mem_read32(f->t, FLASH_SECURITY_WORD_ADDRESS), 0}; uint32_t vals[2] = {target_mem_read32(f->t, FLASH_SECURITY_WORD_ADDRESS), 0};
vals[0] = (vals[0] & 0xff00ffff) | (FLASH_SECURITY_BYTE_UNSECURED << 16); vals[0] = (vals[0] & 0xff00ffff) | (FLASH_SECURITY_BYTE_UNSECURED << 16);
ke04_command(f->t, CMD_PROGRAM_FLASH_32, ke04_command(f->t, CMD_PROGRAM_FLASH_32, FLASH_SECURITY_WORD_ADDRESS, (uint8_t *)&vals);
FLASH_SECURITY_WORD_ADDRESS, (uint8_t *)&vals);
return 0; return true;
} }

100
src/target/target_flash.c
View File

@ -38,8 +38,8 @@
#include "general.h" #include "general.h"
#include "target_internal.h" #include "target_internal.h"
static int flash_buffered_write(target_flash_s *f, target_addr_t dest, const void *src, size_t len); static bool flash_buffered_write(target_flash_s *f, target_addr_t dest, const void *src, size_t len);
static int flash_buffered_flush(target_flash_s *f); static bool flash_buffered_flush(target_flash_s *f);
target_flash_s *target_flash_for_addr(target *t, uint32_t addr) target_flash_s *target_flash_for_addr(target *t, uint32_t addr)
{ {
@ -49,12 +49,12 @@ target_flash_s *target_flash_for_addr(target *t, uint32_t addr)
return NULL; return NULL;
} }
static int target_enter_flash_mode(target *t) static bool target_enter_flash_mode(target *t)
{ {
if (t->flash_mode) if (t->flash_mode)
return 0; return true;
int ret = 0; bool ret = true;
if (t->enter_flash_mode) if (t->enter_flash_mode)
ret = t->enter_flash_mode(t); ret = t->enter_flash_mode(t);
else else
@ -62,18 +62,18 @@ static int target_enter_flash_mode(target *t)
/* This saves us if we're interrupted in IRQ context */ /* This saves us if we're interrupted in IRQ context */
target_reset(t); target_reset(t);
if (ret == 0) if (ret == true)
t->flash_mode = true; t->flash_mode = true;
return ret; return ret;
} }
static int target_exit_flash_mode(target *t) static bool target_exit_flash_mode(target *t)
{ {
if (!t->flash_mode) if (!t->flash_mode)
return 0; return true;
int ret = 0; bool ret = true;
if (t->exit_flash_mode) if (t->exit_flash_mode)
ret = t->exit_flash_mode(t); ret = t->exit_flash_mode(t);
else else
@ -85,27 +85,27 @@ static int target_exit_flash_mode(target *t)
return ret; return ret;
} }
static int flash_prepare(target_flash_s *f) static bool flash_prepare(target_flash_s *f)
{ {
if (f->ready) if (f->ready)
return 0; return true;
int ret = 0; bool ret = true;
if (f->prepare) if (f->prepare)
ret = f->prepare(f); ret = f->prepare(f);
if (ret == 0) if (ret == true)
f->ready = true; f->ready = true;
return ret; return ret;
} }
static int flash_done(target_flash_s *f) static bool flash_done(target_flash_s *f)
{ {
if (!f->ready) if (!f->ready)
return 0; return true;
int ret = 0; bool ret = true;
if (f->done) if (f->done)
ret = f->done(f); ret = f->done(f);
@ -119,65 +119,65 @@ static int flash_done(target_flash_s *f)
return ret; return ret;
} }
int target_flash_erase(target *t, target_addr_t addr, size_t len) bool target_flash_erase(target *t, target_addr_t addr, size_t len)
{ {
if (target_enter_flash_mode(t) != 0) if (!target_enter_flash_mode(t))
return 1; return false;
int ret = 0; bool ret = true; /* catch false returns with &= */
while (len) { while (len) {
target_flash_s *f = target_flash_for_addr(t, addr); target_flash_s *f = target_flash_for_addr(t, addr);
if (!f) { if (!f) {
DEBUG_WARN("Requested address is outside the valid range 0x%06" PRIx32 "\n", addr); DEBUG_WARN("Requested address is outside the valid range 0x%06" PRIx32 "\n", addr);
return 1; return false;
} }
/* terminate flash operations if we're not in the same target flash */ /* terminate flash operations if we're not in the same target flash */
for (target_flash_s *target_f = t->flash; target_f; target_f = target_f->next) for (target_flash_s *target_f = t->flash; target_f; target_f = target_f->next)
if (target_f != f) if (target_f != f)
ret |= flash_done(target_f); ret &= flash_done(target_f);
const target_addr_t local_start_addr = addr & ~(f->blocksize - 1U); const target_addr_t local_start_addr = addr & ~(f->blocksize - 1U);
const target_addr_t local_end_addr = local_start_addr + f->blocksize; const target_addr_t local_end_addr = local_start_addr + f->blocksize;
if (flash_prepare(f) != 0) if (!flash_prepare(f))
return -1; return false;
ret |= f->erase(f, local_start_addr, f->blocksize); ret &= f->erase(f, local_start_addr, f->blocksize) == 0;
len -= MIN(local_end_addr - addr, len); len -= MIN(local_end_addr - addr, len);
addr = local_end_addr; addr = local_end_addr;
/* Issue flash done on last operation */ /* Issue flash done on last operation */
if (len == 0) if (len == 0)
ret |= flash_done(f); ret &= flash_done(f);
} }
return ret; return ret;
} }
int target_flash_write(target *t, target_addr_t dest, const void *src, size_t len) bool target_flash_write(target *t, target_addr_t dest, const void *src, size_t len)
{ {
if (target_enter_flash_mode(t) != 0) if (!target_enter_flash_mode(t))
return 1; return false;
int ret = 0; bool ret = true; /* catch false returns with &= */
while (len) { while (len) {
target_flash_s *f = target_flash_for_addr(t, dest); target_flash_s *f = target_flash_for_addr(t, dest);
if (!f) if (!f)
return 1; return false;
/* terminate flash operations if we're not in the same target flash */ /* terminate flash operations if we're not in the same target flash */
for (target_flash_s *target_f = t->flash; target_f; target_f = target_f->next) { for (target_flash_s *target_f = t->flash; target_f; target_f = target_f->next) {
if (target_f != f) { if (target_f != f) {
ret |= flash_buffered_flush(target_f); ret &= flash_buffered_flush(target_f);
ret |= flash_done(target_f); ret &= flash_done(target_f);
} }
} }
const target_addr_t local_end_addr = MIN(dest + len, f->start + f->length); const target_addr_t local_end_addr = MIN(dest + len, f->start + f->length);
const target_addr_t local_length = local_end_addr - dest; const target_addr_t local_length = local_end_addr - dest;
ret |= flash_buffered_write(f, dest, src, local_length); ret &= flash_buffered_write(f, dest, src, local_length);
dest = local_end_addr; dest = local_end_addr;
src += local_length; src += local_length;
@ -185,49 +185,49 @@ int target_flash_write(target *t, target_addr_t dest, const void *src, size_t le
/* Flush operations if we reached the end of Flash */ /* Flush operations if we reached the end of Flash */
if (dest == f->start + f->length) { if (dest == f->start + f->length) {
ret |= flash_buffered_flush(f); ret &= flash_buffered_flush(f);
ret |= flash_done(f); ret &= flash_done(f);
} }
} }
return ret; return ret;
} }
int target_flash_complete(target *t) bool target_flash_complete(target *t)
{ {
if (!t->flash_mode) if (!t->flash_mode)
return -1; return false;
int ret = 0; bool ret = true; /* catch false returns with &= */
for (target_flash_s *f = t->flash; f; f = f->next) { for (target_flash_s *f = t->flash; f; f = f->next) {
ret |= flash_buffered_flush(f); ret &= flash_buffered_flush(f);
ret |= flash_done(f); ret &= flash_done(f);
} }
target_exit_flash_mode(t); target_exit_flash_mode(t);
return ret; return ret;
} }
static int flash_buffered_write(target_flash_s *f, target_addr_t dest, const void *src, size_t len) static bool flash_buffered_write(target_flash_s *f, target_addr_t dest, const void *src, size_t len)
{ {
if (f->buf == NULL) { if (f->buf == NULL) {
/* Allocate buffer */ /* Allocate buffer */
f->buf = malloc(f->writebufsize); f->buf = malloc(f->writebufsize);
if (!f->buf) { /* malloc failed: heap exhaustion */ if (!f->buf) { /* malloc failed: heap exhaustion */
DEBUG_WARN("malloc: failed in %s\n", __func__); DEBUG_WARN("malloc: failed in %s\n", __func__);
return -1; return false;
} }
f->buf_addr_base = UINT32_MAX; f->buf_addr_base = UINT32_MAX;
f->buf_addr_low = UINT32_MAX; f->buf_addr_low = UINT32_MAX;
f->buf_addr_high = 0; f->buf_addr_high = 0;
} }
int ret = 0; bool ret = true; /* catch false returns with &= */
while (len) { while (len) {
const target_addr_t base_addr = dest & ~(f->writebufsize - 1U); const target_addr_t base_addr = dest & ~(f->writebufsize - 1U);
/* check for base address change */ /* check for base address change */
if (base_addr != f->buf_addr_base) { if (base_addr != f->buf_addr_base) {
ret |= flash_buffered_flush(f); ret &= flash_buffered_flush(f);
/* Setup buffer */ /* Setup buffer */
f->buf_addr_base = base_addr; f->buf_addr_base = base_addr;
@ -251,15 +251,15 @@ static int flash_buffered_write(target_flash_s *f, target_addr_t dest, const voi
return ret; return ret;
} }
static int flash_buffered_flush(target_flash_s *f) static bool flash_buffered_flush(target_flash_s *f)
{ {
int ret = 0; bool ret = true; /* catch false returns with &= */
if (f->buf && f->buf_addr_base != UINT32_MAX && f->buf_addr_low != UINT32_MAX && if (f->buf && f->buf_addr_base != UINT32_MAX && f->buf_addr_low != UINT32_MAX &&
f->buf_addr_low < f->buf_addr_high) { f->buf_addr_low < f->buf_addr_high) {
/* Write buffer to flash */ /* Write buffer to flash */
if (flash_prepare(f) != 0) if (!flash_prepare(f))
return -1; return false;
target_addr_t aligned_addr = f->buf_addr_low & ~(f->writesize - 1U); target_addr_t aligned_addr = f->buf_addr_low & ~(f->writesize - 1U);
@ -267,7 +267,7 @@ static int flash_buffered_flush(target_flash_s *f)
uint32_t len = f->buf_addr_high - aligned_addr; uint32_t len = f->buf_addr_high - aligned_addr;
while (len) { while (len) {
ret = f->write(f, aligned_addr, src, f->writesize); ret &= f->write(f, aligned_addr, src, f->writesize) == 0;
aligned_addr += f->writesize; aligned_addr += f->writesize;
src += f->writesize; src += f->writesize;

4
src/target/target_internal.h
View File

@ -34,10 +34,10 @@ struct target_ram {
typedef struct target_flash target_flash_s; typedef struct target_flash target_flash_s;
typedef int (*flash_prepare_func)(target_flash_s *f); typedef bool (*flash_prepare_func)(target_flash_s *f);
typedef int (*flash_erase_func)(target_flash_s *f, target_addr_t addr, size_t len); typedef int (*flash_erase_func)(target_flash_s *f, target_addr_t addr, size_t len);
typedef int (*flash_write_func)(target_flash_s *f, target_addr_t dest, const void *src, size_t len); typedef int (*flash_write_func)(target_flash_s *f, target_addr_t dest, const void *src, size_t len);
typedef int (*flash_done_func)(target_flash_s *f); typedef bool (*flash_done_func)(target_flash_s *f);
struct target_flash { struct target_flash {
target *t; /* Target this flash is attached to */ target *t; /* Target this flash is attached to */