stm32l0: Run clang-format across the code
This commit is contained in:
dragonmux
Piotr Esden-Tempski
parent
b84f883aeb
commit
a22d6e5056
|
|
@ -124,10 +124,8 @@
|
|||
#define STM32Lx_NVM_SR_WRPERR (1 << 8)
|
||||
#define STM32Lx_NVM_SR_EOP (1 << 1)
|
||||
#define STM32Lx_NVM_SR_BSY (1 << 0)
|
||||
#define STM32Lx_NVM_SR_ERR_M (STM32Lx_NVM_SR_WRPERR | \
|
||||
STM32Lx_NVM_SR_PGAERR | \
|
||||
STM32Lx_NVM_SR_SIZERR | \
|
||||
STM32Lx_NVM_SR_NOTZEROERR)
|
||||
#define STM32Lx_NVM_SR_ERR_M \
|
||||
(STM32Lx_NVM_SR_WRPERR | STM32Lx_NVM_SR_PGAERR | STM32Lx_NVM_SR_SIZERR | STM32Lx_NVM_SR_NOTZEROERR)
|
||||
|
||||
#define STM32L0_NVM_OPTR_BOOT1 (1 << 31)
|
||||
#define STM32Lx_NVM_OPTR_WDG_SW (1 << 20)
|
||||
|
|
@ -144,32 +142,22 @@
|
|||
#define STM32L1_NVM_OPTR_BOR_LEV_M (0xf)
|
||||
#define STM32L1_NVM_OPTR_SPRMOD (1 << 8)
|
||||
|
||||
static int stm32lx_nvm_prog_erase(struct target_flash* f,
|
||||
target_addr addr, size_t len);
|
||||
static int stm32lx_nvm_prog_write(struct target_flash* f,
|
||||
target_addr destination,
|
||||
const void* src,
|
||||
size_t size);
|
||||
static int stm32lx_nvm_prog_erase(struct target_flash *f, target_addr addr, size_t len);
|
||||
static int stm32lx_nvm_prog_write(struct target_flash *f, target_addr destination, const void *src, size_t size);
|
||||
|
||||
static int stm32lx_nvm_data_erase(struct target_flash* f,
|
||||
target_addr addr, size_t len);
|
||||
static int stm32lx_nvm_data_write(struct target_flash* f,
|
||||
target_addr destination,
|
||||
const void* source,
|
||||
size_t size);
|
||||
static int stm32lx_nvm_data_erase(struct target_flash *f, target_addr addr, size_t len);
|
||||
static int stm32lx_nvm_data_write(struct target_flash *f, target_addr destination, const void *source, size_t size);
|
||||
|
||||
static bool stm32lx_cmd_option(target *t, int argc, char **argv);
|
||||
static bool stm32lx_cmd_eeprom(target *t, int argc, char **argv);
|
||||
|
||||
static const struct command_s stm32lx_cmd_list[] = {
|
||||
{ "option", (cmd_handler) stm32lx_cmd_option,
|
||||
"Manipulate option bytes"},
|
||||
{ "eeprom", (cmd_handler) stm32lx_cmd_eeprom,
|
||||
"Manipulate EEPROM(NVM data) memory"},
|
||||
{"option", (cmd_handler)stm32lx_cmd_option, "Manipulate option bytes"},
|
||||
{"eeprom", (cmd_handler)stm32lx_cmd_eeprom, "Manipulate EEPROM(NVM data) memory"},
|
||||
{NULL, NULL, NULL},
|
||||
};
|
||||
|
||||
enum {
|
||||
enum stm32l_idcode_e {
|
||||
STM32L0_DBGMCU_IDCODE_PHYS = 0x40015800,
|
||||
STM32L1_DBGMCU_IDCODE_PHYS = 0xe0042000,
|
||||
};
|
||||
|
|
@ -229,8 +217,7 @@ static uint32_t stm32lx_nvm_option_size(target *t)
|
|||
}
|
||||
}
|
||||
|
||||
static void stm32l_add_flash(target *t,
|
||||
uint32_t addr, size_t length, size_t erasesize)
|
||||
static void stm32l_add_flash(target *t, uint32_t addr, size_t length, size_t erasesize)
|
||||
{
|
||||
struct target_flash *f = calloc(1, sizeof(*f));
|
||||
if (!f) { /* calloc failed: heap exhaustion */
|
||||
|
|
@ -297,14 +284,12 @@ bool stm32l0_probe(target* t)
|
|||
return false;
|
||||
}
|
||||
|
||||
|
||||
/** Lock the NVM control registers preventing writes or erases. */
|
||||
static void stm32lx_nvm_lock(target *t, uint32_t nvm)
|
||||
{
|
||||
target_mem_write32(t, STM32Lx_NVM_PECR(nvm), STM32Lx_NVM_PECR_PELOCK);
|
||||
}
|
||||
|
||||
|
||||
/** Unlock the NVM control registers for modifying program or
|
||||
data flash. Returns true if the unlock succeeds. */
|
||||
static bool stm32lx_nvm_prog_data_unlock(target *t, uint32_t nvm)
|
||||
|
|
@ -317,11 +302,9 @@ static bool stm32lx_nvm_prog_data_unlock(target* t, uint32_t nvm)
|
|||
target_mem_write32(t, STM32Lx_NVM_PRGKEYR(nvm), STM32Lx_NVM_PRGKEY1);
|
||||
target_mem_write32(t, STM32Lx_NVM_PRGKEYR(nvm), STM32Lx_NVM_PRGKEY2);
|
||||
|
||||
return !(target_mem_read32(t, STM32Lx_NVM_PECR(nvm))
|
||||
& STM32Lx_NVM_PECR_PRGLOCK);
|
||||
return !(target_mem_read32(t, STM32Lx_NVM_PECR(nvm)) & STM32Lx_NVM_PECR_PRGLOCK);
|
||||
}
|
||||
|
||||
|
||||
/** Unlock the NVM control registers for modifying option bytes.
|
||||
Returns true if the unlock succeeds. */
|
||||
static bool stm32lx_nvm_opt_unlock(target *t, uint32_t nvm)
|
||||
|
|
@ -334,16 +317,14 @@ static bool stm32lx_nvm_opt_unlock(target *t, uint32_t nvm)
|
|||
target_mem_write32(t, STM32Lx_NVM_OPTKEYR(nvm), STM32Lx_NVM_OPTKEY1);
|
||||
target_mem_write32(t, STM32Lx_NVM_OPTKEYR(nvm), STM32Lx_NVM_OPTKEY2);
|
||||
|
||||
return !(target_mem_read32(t, STM32Lx_NVM_PECR(nvm))
|
||||
& STM32Lx_NVM_PECR_OPTLOCK);
|
||||
return !(target_mem_read32(t, STM32Lx_NVM_PECR(nvm)) & STM32Lx_NVM_PECR_OPTLOCK);
|
||||
}
|
||||
|
||||
/** Erase a region of program flash using operations through the debug
|
||||
interface. This is slower than stubbed versions(see NOTES). The
|
||||
flash array is erased for all pages from addr to addr+len
|
||||
inclusive. NVM register file address chosen from target. */
|
||||
static int stm32lx_nvm_prog_erase(struct target_flash* f,
|
||||
target_addr addr, size_t len)
|
||||
static int stm32lx_nvm_prog_erase(struct target_flash *f, target_addr addr, size_t len)
|
||||
{
|
||||
target *t = f->t;
|
||||
const size_t page_size = f->blocksize;
|
||||
|
|
@ -353,12 +334,10 @@ static int stm32lx_nvm_prog_erase(struct target_flash* f,
|
|||
return -1;
|
||||
|
||||
/* Flash page erase instruction */
|
||||
target_mem_write32(t, STM32Lx_NVM_PECR(nvm),
|
||||
STM32Lx_NVM_PECR_ERASE | STM32Lx_NVM_PECR_PROG);
|
||||
target_mem_write32(t, STM32Lx_NVM_PECR(nvm), STM32Lx_NVM_PECR_ERASE | STM32Lx_NVM_PECR_PROG);
|
||||
|
||||
uint32_t pecr = target_mem_read32(t, STM32Lx_NVM_PECR(nvm));
|
||||
if ((pecr & (STM32Lx_NVM_PECR_PROG | STM32Lx_NVM_PECR_ERASE))
|
||||
!= (STM32Lx_NVM_PECR_PROG | STM32Lx_NVM_PECR_ERASE))
|
||||
if ((pecr & (STM32Lx_NVM_PECR_PROG | STM32Lx_NVM_PECR_ERASE)) != (STM32Lx_NVM_PECR_PROG | STM32Lx_NVM_PECR_ERASE))
|
||||
return -1;
|
||||
|
||||
/* Clear errors. Note that this only works when we wait for the NVM
|
||||
|
|
@ -384,20 +363,15 @@ static int stm32lx_nvm_prog_erase(struct target_flash* f,
|
|||
sr = target_mem_read32(t, STM32Lx_NVM_SR(nvm));
|
||||
} while (sr & STM32Lx_NVM_SR_BSY);
|
||||
|
||||
if ((sr & STM32Lx_NVM_SR_ERR_M) || !(sr & STM32Lx_NVM_SR_EOP) ||
|
||||
target_check_error(t))
|
||||
if ((sr & STM32Lx_NVM_SR_ERR_M) || !(sr & STM32Lx_NVM_SR_EOP) || target_check_error(t))
|
||||
return -1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/** Write to program flash using operations through the debug
|
||||
interface. */
|
||||
static int stm32lx_nvm_prog_write(struct target_flash *f,
|
||||
target_addr dest,
|
||||
const void* src,
|
||||
size_t size)
|
||||
static int stm32lx_nvm_prog_write(struct target_flash *f, target_addr dest, const void *src, size_t size)
|
||||
{
|
||||
target *t = f->t;
|
||||
const uint32_t nvm = stm32lx_nvm_phys(t);
|
||||
|
|
@ -407,13 +381,11 @@ static int stm32lx_nvm_prog_write(struct target_flash *f,
|
|||
|
||||
/* Wait for BSY to clear because we cannot write the PECR until
|
||||
the previous operation completes on STM32Lxxx. */
|
||||
while (target_mem_read32(t, STM32Lx_NVM_SR(nvm))
|
||||
& STM32Lx_NVM_SR_BSY)
|
||||
while (target_mem_read32(t, STM32Lx_NVM_SR(nvm)) & STM32Lx_NVM_SR_BSY)
|
||||
if (target_check_error(t))
|
||||
return -1;
|
||||
|
||||
target_mem_write32(t, STM32Lx_NVM_PECR(nvm),
|
||||
STM32Lx_NVM_PECR_PROG | STM32Lx_NVM_PECR_FPRG);
|
||||
target_mem_write32(t, STM32Lx_NVM_PECR(nvm), STM32Lx_NVM_PECR_PROG | STM32Lx_NVM_PECR_FPRG);
|
||||
target_mem_write(t, dest, src, size);
|
||||
|
||||
/* Disable further programming by locking PECR */
|
||||
|
|
@ -425,8 +397,7 @@ static int stm32lx_nvm_prog_write(struct target_flash *f,
|
|||
sr = target_mem_read32(t, STM32Lx_NVM_SR(nvm));
|
||||
} while (sr & STM32Lx_NVM_SR_BSY);
|
||||
|
||||
if ((sr & STM32Lx_NVM_SR_ERR_M) || !(sr & STM32Lx_NVM_SR_EOP) ||
|
||||
target_check_error(t))
|
||||
if ((sr & STM32Lx_NVM_SR_ERR_M) || !(sr & STM32Lx_NVM_SR_EOP) || target_check_error(t))
|
||||
return -1;
|
||||
|
||||
return 0;
|
||||
|
|
@ -436,8 +407,7 @@ static int stm32lx_nvm_prog_write(struct target_flash *f,
|
|||
interface . The flash is erased for all pages from addr to
|
||||
addr+len, inclusive, on a word boundary. NVM register file
|
||||
address chosen from target. */
|
||||
static int stm32lx_nvm_data_erase(struct target_flash *f,
|
||||
target_addr addr, size_t len)
|
||||
static int stm32lx_nvm_data_erase(struct target_flash *f, target_addr addr, size_t len)
|
||||
{
|
||||
target *t = f->t;
|
||||
const size_t page_size = f->blocksize;
|
||||
|
|
@ -451,12 +421,10 @@ static int stm32lx_nvm_data_erase(struct target_flash *f,
|
|||
return -1;
|
||||
|
||||
/* Flash data erase instruction */
|
||||
target_mem_write32(t, STM32Lx_NVM_PECR(nvm),
|
||||
STM32Lx_NVM_PECR_ERASE | STM32Lx_NVM_PECR_DATA);
|
||||
target_mem_write32(t, STM32Lx_NVM_PECR(nvm), STM32Lx_NVM_PECR_ERASE | STM32Lx_NVM_PECR_DATA);
|
||||
|
||||
uint32_t pecr = target_mem_read32(t, STM32Lx_NVM_PECR(nvm));
|
||||
if ((pecr & (STM32Lx_NVM_PECR_ERASE | STM32Lx_NVM_PECR_DATA))
|
||||
!= (STM32Lx_NVM_PECR_ERASE | STM32Lx_NVM_PECR_DATA))
|
||||
if ((pecr & (STM32Lx_NVM_PECR_ERASE | STM32Lx_NVM_PECR_DATA)) != (STM32Lx_NVM_PECR_ERASE | STM32Lx_NVM_PECR_DATA))
|
||||
return -1;
|
||||
|
||||
while (len > 0) {
|
||||
|
|
@ -479,22 +447,17 @@ static int stm32lx_nvm_data_erase(struct target_flash *f,
|
|||
sr = target_mem_read32(t, STM32Lx_NVM_SR(nvm));
|
||||
} while (sr & STM32Lx_NVM_SR_BSY);
|
||||
|
||||
if ((sr & STM32Lx_NVM_SR_ERR_M) || !(sr & STM32Lx_NVM_SR_EOP) ||
|
||||
target_check_error(t))
|
||||
if ((sr & STM32Lx_NVM_SR_ERR_M) || !(sr & STM32Lx_NVM_SR_EOP) || target_check_error(t))
|
||||
return -1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/** Write to data flash using operations through the debug interface.
|
||||
NVM register file address chosen from target. Unaligned
|
||||
destination writes are supported (though unaligned sources are
|
||||
not). */
|
||||
static int stm32lx_nvm_data_write(struct target_flash *f,
|
||||
target_addr destination,
|
||||
const void* src,
|
||||
size_t size)
|
||||
static int stm32lx_nvm_data_write(struct target_flash *f, target_addr destination, const void *src, size_t size)
|
||||
{
|
||||
target *t = f->t;
|
||||
const uint32_t nvm = stm32lx_nvm_phys(t);
|
||||
|
|
@ -504,8 +467,7 @@ static int stm32lx_nvm_data_write(struct target_flash *f,
|
|||
if (!stm32lx_nvm_prog_data_unlock(t, nvm))
|
||||
return -1;
|
||||
|
||||
target_mem_write32(t, STM32Lx_NVM_PECR(nvm),
|
||||
is_stm32l1 ? 0 : STM32Lx_NVM_PECR_DATA);
|
||||
target_mem_write32(t, STM32Lx_NVM_PECR(nvm), is_stm32l1 ? 0 : STM32Lx_NVM_PECR_DATA);
|
||||
|
||||
while (size) {
|
||||
size -= 4;
|
||||
|
|
@ -526,14 +488,12 @@ static int stm32lx_nvm_data_write(struct target_flash *f,
|
|||
sr = target_mem_read32(t, STM32Lx_NVM_SR(nvm));
|
||||
} while (sr & STM32Lx_NVM_SR_BSY);
|
||||
|
||||
if ((sr & STM32Lx_NVM_SR_ERR_M) || !(sr & STM32Lx_NVM_SR_EOP) ||
|
||||
target_check_error(t))
|
||||
if ((sr & STM32Lx_NVM_SR_ERR_M) || !(sr & STM32Lx_NVM_SR_EOP) || target_check_error(t))
|
||||
return -1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/** Write one option word. The address is the physical address of the
|
||||
word and the value is a complete word value. The caller is
|
||||
responsible for making sure that the value satisfies the proper
|
||||
|
|
@ -556,7 +516,6 @@ static bool stm32lx_option_write(target *t, uint32_t address, uint32_t value)
|
|||
return !(sr & STM32Lx_NVM_SR_ERR_M);
|
||||
}
|
||||
|
||||
|
||||
/** Write one eeprom value. This version is more flexible than that
|
||||
bulk version used for writing data from the executable file. The
|
||||
address is the physical address of the word and the value is a
|
||||
|
|
@ -564,8 +523,7 @@ static bool stm32lx_option_write(target *t, uint32_t address, uint32_t value)
|
|||
complete. The return value is true if the write succeeded.
|
||||
FWIW, byte writing isn't supported because the adiv5 layer
|
||||
doesn't support byte-level operations. */
|
||||
static bool stm32lx_eeprom_write(target *t, uint32_t address,
|
||||
size_t cb, uint32_t value)
|
||||
static bool stm32lx_eeprom_write(target *t, uint32_t address, size_t cb, uint32_t value)
|
||||
{
|
||||
const uint32_t nvm = stm32lx_nvm_phys(t);
|
||||
const bool is_stm32l1 = stm32lx_is_stm32l1(t);
|
||||
|
|
@ -574,9 +532,7 @@ static bool stm32lx_eeprom_write(target *t, uint32_t address,
|
|||
target_mem_write32(t, STM32Lx_NVM_SR(nvm), STM32Lx_NVM_SR_ERR_M);
|
||||
|
||||
/* Erase and program option in one go. */
|
||||
target_mem_write32(t, STM32Lx_NVM_PECR(nvm),
|
||||
(is_stm32l1 ? 0 : STM32Lx_NVM_PECR_DATA)
|
||||
| STM32Lx_NVM_PECR_FIX);
|
||||
target_mem_write32(t, STM32Lx_NVM_PECR(nvm), (is_stm32l1 ? 0 : STM32Lx_NVM_PECR_DATA) | STM32Lx_NVM_PECR_FIX);
|
||||
if (cb == 4)
|
||||
target_mem_write32(t, address, value);
|
||||
else if (cb == 2)
|
||||
|
|
@ -609,28 +565,21 @@ static bool stm32lx_cmd_option(target* t, int argc, char** argv)
|
|||
size_t cb = strlen(argv[1]);
|
||||
|
||||
if (argc == 2 && !strncasecmp(argv[1], "obl_launch", cb)) {
|
||||
target_mem_write32(t, STM32Lx_NVM_PECR(nvm),
|
||||
STM32Lx_NVM_PECR_OBL_LAUNCH);
|
||||
}
|
||||
else if (argc == 4 && !strncasecmp(argv[1], "raw", cb)) {
|
||||
target_mem_write32(t, STM32Lx_NVM_PECR(nvm), STM32Lx_NVM_PECR_OBL_LAUNCH);
|
||||
} else if (argc == 4 && !strncasecmp(argv[1], "raw", cb)) {
|
||||
uint32_t addr = strtoul(argv[2], NULL, 0);
|
||||
uint32_t val = strtoul(argv[3], NULL, 0);
|
||||
tc_printf(t, "raw %08x <- %08x\n", addr, val);
|
||||
if ( addr < STM32Lx_NVM_OPT_PHYS
|
||||
|| addr >= STM32Lx_NVM_OPT_PHYS + opt_size
|
||||
|| (addr & 3))
|
||||
if (addr < STM32Lx_NVM_OPT_PHYS || addr >= STM32Lx_NVM_OPT_PHYS + opt_size || (addr & 3))
|
||||
goto usage;
|
||||
if (!stm32lx_option_write(t, addr, val))
|
||||
tc_printf(t, "option write failed\n");
|
||||
}
|
||||
else if (argc == 4 && !strncasecmp(argv[1], "write", cb)) {
|
||||
} else if (argc == 4 && !strncasecmp(argv[1], "write", cb)) {
|
||||
uint32_t addr = strtoul(argv[2], NULL, 0);
|
||||
uint32_t val = strtoul(argv[3], NULL, 0);
|
||||
val = (val & 0xffff) | ((~val & 0xffff) << 16);
|
||||
tc_printf(t, "write %08x <- %08x\n", addr, val);
|
||||
if ( addr < STM32Lx_NVM_OPT_PHYS
|
||||
|| addr >= STM32Lx_NVM_OPT_PHYS + opt_size
|
||||
|| (addr & 3))
|
||||
if (addr < STM32Lx_NVM_OPT_PHYS || addr >= STM32Lx_NVM_OPT_PHYS + opt_size || (addr & 3))
|
||||
goto usage;
|
||||
if (!stm32lx_option_write(t, addr, val))
|
||||
tc_printf(t, "option write failed\n");
|
||||
|
|
@ -640,49 +589,40 @@ static bool stm32lx_cmd_option(target* t, int argc, char** argv)
|
|||
for (unsigned i = 0; i < opt_size; i += sizeof(uint32_t)) {
|
||||
uint32_t addr = STM32Lx_NVM_OPT_PHYS + i;
|
||||
uint32_t val = target_mem_read32(t, addr);
|
||||
tc_printf(t, "0x%08x: 0x%04x 0x%04x %s\n",
|
||||
addr, val & 0xffff, (val >> 16) & 0xffff,
|
||||
((val & 0xffff) == ((~val >> 16) & 0xffff))
|
||||
? "OK" : "ERR");
|
||||
tc_printf(t, "0x%08x: 0x%04x 0x%04x %s\n", addr, val & 0xffff, (val >> 16) & 0xffff,
|
||||
((val & 0xffff) == ((~val >> 16) & 0xffff)) ? "OK" : "ERR");
|
||||
}
|
||||
|
||||
if (stm32lx_is_stm32l1(t)) {
|
||||
uint32_t optr = target_mem_read32(t, STM32Lx_NVM_OPTR(nvm));
|
||||
uint8_t rdprot = (optr >> STM32Lx_NVM_OPTR_RDPROT_S)
|
||||
& STM32Lx_NVM_OPTR_RDPROT_M;
|
||||
uint8_t rdprot = (optr >> STM32Lx_NVM_OPTR_RDPROT_S) & STM32Lx_NVM_OPTR_RDPROT_M;
|
||||
if (rdprot == STM32Lx_NVM_OPTR_RDPROT_0)
|
||||
rdprot = 0;
|
||||
else if (rdprot == STM32Lx_NVM_OPTR_RDPROT_2)
|
||||
rdprot = 2;
|
||||
else
|
||||
rdprot = 1;
|
||||
tc_printf(t, "OPTR: 0x%08x, RDPRT %d, SPRMD %d, "
|
||||
tc_printf(t,
|
||||
"OPTR: 0x%08x, RDPRT %d, SPRMD %d, "
|
||||
"BOR %d, WDG_SW %d, nRST_STP %d, nRST_STBY %d, "
|
||||
"nBFB2 %d\n",
|
||||
optr, rdprot,
|
||||
(optr & STM32L1_NVM_OPTR_SPRMOD) ? 1 : 0,
|
||||
(optr >> STM32L1_NVM_OPTR_BOR_LEV_S)
|
||||
& STM32L1_NVM_OPTR_BOR_LEV_M,
|
||||
(optr & STM32Lx_NVM_OPTR_WDG_SW) ? 1 : 0,
|
||||
(optr & STM32L1_NVM_OPTR_nRST_STOP) ? 1 : 0,
|
||||
(optr & STM32L1_NVM_OPTR_nRST_STDBY) ? 1 : 0,
|
||||
optr, rdprot, (optr & STM32L1_NVM_OPTR_SPRMOD) ? 1 : 0,
|
||||
(optr >> STM32L1_NVM_OPTR_BOR_LEV_S) & STM32L1_NVM_OPTR_BOR_LEV_M, (optr & STM32Lx_NVM_OPTR_WDG_SW) ? 1 : 0,
|
||||
(optr & STM32L1_NVM_OPTR_nRST_STOP) ? 1 : 0, (optr & STM32L1_NVM_OPTR_nRST_STDBY) ? 1 : 0,
|
||||
(optr & STM32L1_NVM_OPTR_nBFB2) ? 1 : 0);
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
uint32_t optr = target_mem_read32(t, STM32Lx_NVM_OPTR(nvm));
|
||||
uint8_t rdprot = (optr >> STM32Lx_NVM_OPTR_RDPROT_S)
|
||||
& STM32Lx_NVM_OPTR_RDPROT_M;
|
||||
uint8_t rdprot = (optr >> STM32Lx_NVM_OPTR_RDPROT_S) & STM32Lx_NVM_OPTR_RDPROT_M;
|
||||
if (rdprot == STM32Lx_NVM_OPTR_RDPROT_0)
|
||||
rdprot = 0;
|
||||
else if (rdprot == STM32Lx_NVM_OPTR_RDPROT_2)
|
||||
rdprot = 2;
|
||||
else
|
||||
rdprot = 1;
|
||||
tc_printf(t, "OPTR: 0x%08x, RDPROT %d, WPRMOD %d, WDG_SW %d, "
|
||||
tc_printf(t,
|
||||
"OPTR: 0x%08x, RDPROT %d, WPRMOD %d, WDG_SW %d, "
|
||||
"BOOT1 %d\n",
|
||||
optr, rdprot,
|
||||
(optr & STM32L0_NVM_OPTR_WPRMOD) ? 1 : 0,
|
||||
(optr & STM32Lx_NVM_OPTR_WDG_SW) ? 1 : 0,
|
||||
optr, rdprot, (optr & STM32L0_NVM_OPTR_WPRMOD) ? 1 : 0, (optr & STM32Lx_NVM_OPTR_WDG_SW) ? 1 : 0,
|
||||
(optr & STM32L0_NVM_OPTR_BOOT1) ? 1 : 0);
|
||||
}
|
||||
|
||||
|
|
@ -696,17 +636,16 @@ usage:
|
|||
tc_printf(t, " write <addr> <value16> - Set option half-word; "
|
||||
"complement computed\n");
|
||||
tc_printf(t, " raw <addr> <value32> - Set option word\n");
|
||||
tc_printf(t, "The value of <addr> must be word aligned and from 0x%08x "
|
||||
tc_printf(t,
|
||||
"The value of <addr> must be word aligned and from 0x%08x "
|
||||
"to +0x%x\n",
|
||||
STM32Lx_NVM_OPT_PHYS,
|
||||
STM32Lx_NVM_OPT_PHYS + opt_size - sizeof(uint32_t));
|
||||
STM32Lx_NVM_OPT_PHYS, STM32Lx_NVM_OPT_PHYS + opt_size - sizeof(uint32_t));
|
||||
|
||||
done:
|
||||
stm32lx_nvm_lock(t, nvm);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
static bool stm32lx_cmd_eeprom(target *t, int argc, char **argv)
|
||||
{
|
||||
const uint32_t nvm = stm32lx_nvm_phys(t);
|
||||
|
|
@ -722,9 +661,7 @@ static bool stm32lx_cmd_eeprom(target* t, int argc, char** argv)
|
|||
uint32_t addr = strtoul(argv[2], NULL, 0);
|
||||
uint32_t val = strtoul(argv[3], NULL, 0);
|
||||
|
||||
if ( addr < STM32Lx_NVM_EEPROM_PHYS
|
||||
|| addr >= STM32Lx_NVM_EEPROM_PHYS
|
||||
+ stm32lx_nvm_eeprom_size(t))
|
||||
if (addr < STM32Lx_NVM_EEPROM_PHYS || addr >= STM32Lx_NVM_EEPROM_PHYS + stm32lx_nvm_eeprom_size(t))
|
||||
goto usage;
|
||||
|
||||
if (!strncasecmp(argv[1], "byte", cb)) {
|
||||
|
|
@ -733,8 +670,7 @@ static bool stm32lx_cmd_eeprom(target* t, int argc, char** argv)
|
|||
tc_printf(t, "eeprom write failed\n");
|
||||
} else if (!strncasecmp(argv[1], "halfword", cb)) {
|
||||
val &= 0xffff;
|
||||
tc_printf(t, "write halfword 0x%08x <- 0x%04x\n",
|
||||
addr, val);
|
||||
tc_printf(t, "write halfword 0x%08x <- 0x%04x\n", addr, val);
|
||||
if (addr & 1)
|
||||
goto usage;
|
||||
if (!stm32lx_eeprom_write(t, addr, 2, val))
|
||||
|
|
@ -745,11 +681,9 @@ static bool stm32lx_cmd_eeprom(target* t, int argc, char** argv)
|
|||
goto usage;
|
||||
if (!stm32lx_eeprom_write(t, addr, 4, val))
|
||||
tc_printf(t, "eeprom write failed\n");
|
||||
}
|
||||
else
|
||||
} else
|
||||
goto usage;
|
||||
}
|
||||
else
|
||||
} else
|
||||
goto usage;
|
||||
|
||||
goto done;
|
||||
|
|
@ -759,8 +693,7 @@ usage:
|
|||
tc_printf(t, " byte <addr> <value8> - Write a byte\n");
|
||||
tc_printf(t, " halfword <addr> <value16> - Write a half-word\n");
|
||||
tc_printf(t, " word <addr> <value32> - Write a word\n");
|
||||
tc_printf(t, "The value of <addr> must in the interval [0x%08x, 0x%x)\n",
|
||||
STM32Lx_NVM_EEPROM_PHYS,
|
||||
tc_printf(t, "The value of <addr> must in the interval [0x%08x, 0x%x)\n", STM32Lx_NVM_EEPROM_PHYS,
|
||||
STM32Lx_NVM_EEPROM_PHYS + stm32lx_nvm_eeprom_size(t));
|
||||
|
||||
done:
|
||||
|
|
|
|||
Loading…
Reference in New Issue