137 #define FLASH_ERASE_TIMEOUT 250
138 #define FLASH_WRITE_TIMEOUT 50
144 #define F_HAS_DUAL_BANK BIT(0)
147 #define F_USE_ALL_WRPXX BIT(1)
149 #define F_HAS_TZ BIT(2)
151 #define F_HAS_L5_FLASH_REGS BIT(3)
154 #define F_QUAD_WORD_PROG BIT(4)
290 { 0x1000,
"1" }, { 0x1001,
"2" }, { 0x1003,
"3" }, { 0x1007,
"4" }
294 { 0x1000,
"A" }, { 0x1001,
"Z" }, { 0x2001,
"Y" },
299 { 0x1000,
"A" }, { 0x1001,
"Z" },
303 { 0x1000,
"A" }, { 0x1001,
"Z" },
315 { 0x1000,
"A/Z" } , { 0x2000,
"B" },
319 { 0x1000,
"A" }, { 0x2000,
"B" },
323 { 0x1000,
"A" }, { 0x1001,
"Z" }, { 0x2001,
"Y" },
327 { 0x1000,
"A" }, { 0x1001,
"Z" }, { 0x2001,
"Y" },
331 { 0x1000,
"A" }, { 0x1001,
"Z" }, { 0x2000,
"B" },
343 { 0x1000,
"A" }, { 0x2000,
"B" }, { 0x2001,
"Z" },
347 { 0x1000,
"A" }, { 0x2000,
"B" }, { 0x2001,
"Z" },
351 { 0x1000,
"A" }, { 0x1001,
"Z" }, { 0x1003,
"Y" }, { 0x100F,
"W" },
360 { 0x1000,
"A" }, { 0x2000,
"B" }, { 0x2001,
"Z" },
368 { 0x1000,
"A" }, { 0x1001,
"Z" },
372 { 0x1000,
"A" }, { 0x1001,
"Z" }, { 0x1003,
"Y" }, { 0x2000,
"B" },
373 { 0x2001,
"X" }, { 0x3000,
"C" }, { 0x3001,
"W" }, { 0x3007,
"U" },
377 { 0x3001,
"X" }, { 0x3002,
"W" },
381 { 0x1000,
"A" }, { 0x1001,
"Z" },
389 { 0x1000,
"A" }, { 0x2000,
"B" },
409 .device_str =
"STM32L47/L48xx",
410 .max_flash_size_kb = 1024,
412 .flash_regs_base = 0x40022000,
413 .fsize_addr = 0x1FFF75E0,
414 .otp_base = 0x1FFF7000,
421 .device_str =
"STM32L43/L44xx",
422 .max_flash_size_kb = 256,
424 .flash_regs_base = 0x40022000,
425 .fsize_addr = 0x1FFF75E0,
426 .otp_base = 0x1FFF7000,
433 .device_str =
"STM32C01xx",
434 .max_flash_size_kb = 32,
436 .flash_regs_base = 0x40022000,
437 .fsize_addr = 0x1FFF75A0,
438 .otp_base = 0x1FFF7000,
445 .device_str =
"STM32C03xx",
446 .max_flash_size_kb = 32,
448 .flash_regs_base = 0x40022000,
449 .fsize_addr = 0x1FFF75A0,
450 .otp_base = 0x1FFF7000,
457 .device_str =
"STM32C071xx",
458 .max_flash_size_kb = 128,
460 .flash_regs_base = 0x40022000,
461 .fsize_addr = 0x1FFF75A0,
462 .otp_base = 0x1FFF7000,
469 .device_str =
"STM32U535/U545",
470 .max_flash_size_kb = 512,
472 .flash_regs_base = 0x40022000,
473 .fsize_addr = 0x0BFA07A0,
474 .otp_base = 0x0BFA0000,
481 .device_str =
"STM32G05/G06xx",
482 .max_flash_size_kb = 64,
484 .flash_regs_base = 0x40022000,
485 .fsize_addr = 0x1FFF75E0,
486 .otp_base = 0x1FFF7000,
493 .device_str =
"STM32G07/G08xx",
494 .max_flash_size_kb = 128,
496 .flash_regs_base = 0x40022000,
497 .fsize_addr = 0x1FFF75E0,
498 .otp_base = 0x1FFF7000,
505 .device_str =
"STM32L49/L4Axx",
506 .max_flash_size_kb = 1024,
508 .flash_regs_base = 0x40022000,
509 .fsize_addr = 0x1FFF75E0,
510 .otp_base = 0x1FFF7000,
517 .device_str =
"STM32L45/L46xx",
518 .max_flash_size_kb = 512,
520 .flash_regs_base = 0x40022000,
521 .fsize_addr = 0x1FFF75E0,
522 .otp_base = 0x1FFF7000,
529 .device_str =
"STM32L41/L42xx",
530 .max_flash_size_kb = 128,
532 .flash_regs_base = 0x40022000,
533 .fsize_addr = 0x1FFF75E0,
534 .otp_base = 0x1FFF7000,
541 .device_str =
"STM32G03x/G04xx",
542 .max_flash_size_kb = 64,
544 .flash_regs_base = 0x40022000,
545 .fsize_addr = 0x1FFF75E0,
546 .otp_base = 0x1FFF7000,
553 .device_str =
"STM32G0B/G0Cx",
554 .max_flash_size_kb = 512,
556 .flash_regs_base = 0x40022000,
557 .fsize_addr = 0x1FFF75E0,
558 .otp_base = 0x1FFF7000,
565 .device_str =
"STM32G43/G44xx",
566 .max_flash_size_kb = 128,
568 .flash_regs_base = 0x40022000,
569 .fsize_addr = 0x1FFF75E0,
570 .otp_base = 0x1FFF7000,
577 .device_str =
"STM32G47/G48xx",
578 .max_flash_size_kb = 512,
580 .flash_regs_base = 0x40022000,
581 .fsize_addr = 0x1FFF75E0,
582 .otp_base = 0x1FFF7000,
589 .device_str =
"STM32L4R/L4Sxx",
590 .max_flash_size_kb = 2048,
592 .flash_regs_base = 0x40022000,
593 .fsize_addr = 0x1FFF75E0,
594 .otp_base = 0x1FFF7000,
601 .device_str =
"STM32L4P/L4Qxx",
602 .max_flash_size_kb = 1024,
604 .flash_regs_base = 0x40022000,
605 .fsize_addr = 0x1FFF75E0,
606 .otp_base = 0x1FFF7000,
613 .device_str =
"STM32L55/L56xx",
614 .max_flash_size_kb = 512,
616 .flash_regs_base = 0x40022000,
617 .fsize_addr = 0x0BFA05E0,
618 .otp_base = 0x0BFA0000,
625 .device_str =
"STM32G49/G4Axx",
626 .max_flash_size_kb = 512,
628 .flash_regs_base = 0x40022000,
629 .fsize_addr = 0x1FFF75E0,
630 .otp_base = 0x1FFF7000,
637 .device_str =
"STM32U031xx",
638 .max_flash_size_kb = 64,
640 .flash_regs_base = 0x40022000,
641 .fsize_addr = 0x1FFF3EA0,
642 .otp_base = 0x1FFF6800,
649 .device_str =
"STM32U073/U083xx",
650 .max_flash_size_kb = 256,
652 .flash_regs_base = 0x40022000,
653 .fsize_addr = 0x1FFF6EA0,
654 .otp_base = 0x1FFF6800,
661 .device_str =
"STM32U59/U5Axx",
662 .max_flash_size_kb = 4096,
664 .flash_regs_base = 0x40022000,
665 .fsize_addr = 0x0BFA07A0,
666 .otp_base = 0x0BFA0000,
673 .device_str =
"STM32U57/U58xx",
674 .max_flash_size_kb = 2048,
676 .flash_regs_base = 0x40022000,
677 .fsize_addr = 0x0BFA07A0,
678 .otp_base = 0x0BFA0000,
685 .device_str =
"STM32U5F/U5Gxx",
686 .max_flash_size_kb = 4096,
688 .flash_regs_base = 0x40022000,
689 .fsize_addr = 0x0BFA07A0,
690 .otp_base = 0x0BFA0000,
697 .device_str =
"STM32WBA5x",
698 .max_flash_size_kb = 1024,
700 .flash_regs_base = 0x40022000,
701 .fsize_addr = 0x0FF907A0,
702 .otp_base = 0x0FF90000,
709 .device_str =
"STM32WB1x",
710 .max_flash_size_kb = 320,
712 .flash_regs_base = 0x58004000,
713 .fsize_addr = 0x1FFF75E0,
714 .otp_base = 0x1FFF7000,
721 .device_str =
"STM32WB5x",
722 .max_flash_size_kb = 1024,
724 .flash_regs_base = 0x58004000,
725 .fsize_addr = 0x1FFF75E0,
726 .otp_base = 0x1FFF7000,
733 .device_str =
"STM32WB3x",
734 .max_flash_size_kb = 512,
736 .flash_regs_base = 0x58004000,
737 .fsize_addr = 0x1FFF75E0,
738 .otp_base = 0x1FFF7000,
745 .device_str =
"STM32WLE/WL5x",
746 .max_flash_size_kb = 256,
748 .flash_regs_base = 0x58004000,
749 .fsize_addr = 0x1FFF75E0,
750 .otp_base = 0x1FFF7000,
770 bank->driver_priv = stm32l4_info;
772 stm32l4_info->
probed =
false;
786 struct range *ranges,
unsigned int *ranges_count)
789 bool last_bit = 0, cur_bit;
790 for (
unsigned int i = 0; i < nbits; i++) {
793 if (cur_bit && !last_bit) {
795 ranges[*ranges_count - 1].
start = i;
796 ranges[*ranges_count - 1].
end = i;
797 }
else if (cur_bit && last_bit) {
799 ranges[*ranges_count - 1].
end = i;
822 char *str = calloc(1, ranges_count * (24 *
sizeof(
char)) + 1);
825 for (
unsigned int i = 0; i < ranges_count; i++) {
828 if (i < ranges_count - 1)
850 char *op_str = enable ?
"enabled" :
"disabled";
852 LOG_INFO(
"OTP memory (bank #%d) is %s%s for write commands",
854 stm32l4_info->
otp_enabled == enable ?
"already " :
"",
949 LOG_ERROR(
"timed out waiting for flash");
991 LOG_DEBUG(
"setting secure block-based areas registers (SECBBxRy) to 0x%08x", value);
993 const uint8_t secbb_regs[] = {
999 unsigned int num_secbb_regs =
ARRAY_SIZE(secbb_regs);
1005 num_secbb_regs /= 2;
1007 for (
unsigned int i = 0; i < num_secbb_regs; i++) {
1052 LOG_ERROR(
"flash not unlocked STM32_FLASH_CR: %" PRIx32,
ctrl);
1085 LOG_ERROR(
"options not unlocked STM32_FLASH_CR: %" PRIx32,
ctrl);
1094 int retval, retval2;
1117 stm32l4_info->
probed =
false;
1130 uint32_t value, uint32_t
mask)
1133 uint32_t optiondata;
1134 int retval, retval2;
1142 const uint32_t *saved_flash_regs = stm32l4_info->
flash_regs;
1154 optiondata = (optiondata & ~
mask) | (value &
mask);
1212 int wrp2y_sectors_offset = -1;
1228 wrp2y_sectors_offset = 0;
1235 if (wrp2y_sectors_offset >= 0) {
1257 uint32_t wrp_value = (wrp_start & stm32l4_info->
wrpxxr_mask) | ((wrp_end & stm32l4_info->
wrpxxr_mask) << 16);
1266 for (
unsigned int i = 0; i < n_wrp; i++) {
1285 for (
unsigned int i = 0; i <
bank->num_sectors; i++)
1286 bank->sectors[i].is_protected = 0;
1289 for (
unsigned int i = 0; i < n_wrp; i++) {
1290 if (wrpxy[i].
used) {
1291 for (
int s = wrpxy[i].
first; s <= wrpxy[i].
last; s++)
1292 bank->sectors[s].is_protected = 1;
1303 int retval, retval2;
1305 assert((first <= last) && (last < bank->num_sectors));
1342 for (
unsigned int i = first; i <= last; i++) {
1343 uint32_t erase_flags;
1378 unsigned int first,
unsigned int last)
1383 for (i = first; i <= last; i++) {
1384 if (
bank->sectors[i].is_protected != set)
1386 else if (i == last) {
1387 LOG_INFO(
"The specified sectors are already %s", set ?
"protected" :
"unprotected");
1405 for (i = 0; i < n_wrp; i++) {
1406 if (wrpxy[i].
used) {
1407 for (
int p = wrpxy[i].
first; p <= wrpxy[i].
last; p++)
1414 struct range ranges[n_wrp + 1];
1415 unsigned int ranges_count = 0;
1420 if (ranges_count > 0) {
1422 LOG_DEBUG(
"current protected areas: %s", ranges_str);
1425 LOG_DEBUG(
"current protected areas: none");
1428 for (i = first; i <= last; i++)
1431 for (i = first; i <= last; i++)
1439 if (ranges_count > 0) {
1441 LOG_DEBUG(
"requested areas for protection: %s", ranges_str);
1444 LOG_DEBUG(
"requested areas for protection: none");
1446 if (ranges_count > n_wrp) {
1447 LOG_ERROR(
"cannot set the requested protection "
1448 "(only %u write protection areas are available)" , n_wrp);
1453 for (i = 0; i < n_wrp; i++) {
1459 for (i = 0; i < ranges_count; i++) {
1461 wrpxy[i].
last = ranges[i].
end;
1474 LOG_ERROR(
"cannot protect/unprotect OTP memory");
1515 static const uint8_t stm32l4_flash_write_code[] = {
1516 #include "../../../contrib/loaders/flash/stm32/stm32l4x.inc"
1521 LOG_WARNING(
"no working area available, can't do block memory writes");
1526 sizeof(stm32l4_flash_write_code),
1527 stm32l4_flash_write_code);
1541 LOG_WARNING(
"large enough working area not available, can't do block memory writes");
1550 LOG_ERROR(
"allocating working area failed");
1573 struct stm32l4_loader_params loader_extra_params;
1585 (uint8_t *) &loader_extra_params);
1598 LOG_ERROR(
"error executing stm32l4 flash write algorithm");
1605 LOG_ERROR(
"flash memory write protected");
1608 LOG_ERROR(
"flash write failed = %08" PRIx32, error);
1648 const uint8_t *src =
buffer;
1649 const uint32_t data_width_in_words = stm32l4_info->
data_width / 4;
1679 LOG_ERROR(
"OTP memory is disabled for write commands");
1704 while ((head < tail) && (
offset >= (head + 1)->
offset)) {
1714 LOG_DEBUG(
"data: 0x%08" PRIx32
" - 0x%08" PRIx32
", sectors: 0x%08" PRIx32
" - 0x%08" PRIx32,
1720 while (head < tail) {
1721 if (head->
offset + head->
size != (head + 1)->offset) {
1724 bank->base + (head + 1)->offset - 1);
1753 LOG_WARNING(
"RDP = 0x55, the work-area should be in non-secure RAM (check SAU partitioning)");
1761 LOG_WARNING(
"falling back to programming without a flash loader (slower)");
1791 for (
unsigned int i = 0; i <
ARRAY_SIZE(dbgmcu_idcode); i++) {
1793 if ((retval ==
ERROR_OK) && ((*
id & 0xfff) != 0) && ((*
id & 0xfff) != 0xfff))
1803 LOG_ERROR(
"Flash requires Cortex-M target");
1838 const uint16_t rev_id = stm32l4_info->
idcode >> 16;
1839 for (
unsigned int i = 0; i < part_info->
num_revs; i++) {
1840 if (rev_id == part_info->
revs[i].
rev)
1841 return part_info->
revs[i].
str;
1860 uint16_t flash_size_kb = 0xffff;
1869 LOG_ERROR(
"Flash requires Cortex-M target");
1873 stm32l4_info->
probed =
false;
1880 const uint32_t device_id = stm32l4_info->
idcode & 0xFFF;
1896 const uint16_t rev_id = stm32l4_info->
idcode >> 16;
1898 LOG_INFO(
"device idcode = 0x%08" PRIx32
" (%s - Rev %s : 0x%04x)",
1930 LOG_ERROR(
"BUG: device supported incomplete");
1936 LOG_INFO(
"TZEN = %d : TrustZone %s by option bytes",
1938 stm32l4_info->
tzen ?
"enabled" :
"disabled");
1950 free(
bank->sectors);
1951 bank->num_sectors = 1;
1954 if (!
bank->sectors) {
1955 LOG_ERROR(
"failed to allocate bank sectors");
1959 stm32l4_info->
probed =
true;
1971 if (retval !=
ERROR_OK || flash_size_kb == 0xffff || flash_size_kb == 0
1973 LOG_WARNING(
"STM32 flash size failed, probe inaccurate - assuming %dk flash",
1981 LOG_WARNING(
"overriding size register by configured bank size - MAY CAUSE TROUBLE");
1985 LOG_INFO(
"flash size = %d KiB", flash_size_kb);
1988 assert((flash_size_kb != 0xffff) && flash_size_kb);
1996 int page_size_kb = 0;
2000 switch (device_id) {
2012 num_pages = flash_size_kb / page_size_kb;
2037 num_pages = flash_size_kb / page_size_kb;
2043 num_pages = flash_size_kb / page_size_kb;
2060 num_pages = flash_size_kb / page_size_kb;
2065 num_pages = flash_size_kb / page_size_kb;
2083 num_pages = flash_size_kb / page_size_kb;
2089 num_pages = flash_size_kb / page_size_kb;
2102 num_pages = flash_size_kb / page_size_kb;
2129 num_pages = flash_size_kb / page_size_kb;
2139 num_pages = flash_size_kb / page_size_kb;
2146 num_pages = flash_size_kb / page_size_kb;
2152 num_pages = flash_size_kb / page_size_kb;
2166 if (num_pages == 0) {
2168 LOG_ERROR(
"The specified flash size is less than page size");
2170 LOG_ERROR(
"Flash pages count cannot be zero");
2176 const int gap_size_kb = stm32l4_info->
hole_sectors * page_size_kb;
2178 if (gap_size_kb != 0) {
2179 LOG_INFO(
"gap detected from 0x%08x to 0x%08x",
2181 * page_size_kb * 1024,
2183 * page_size_kb + gap_size_kb) * 1024 - 1);
2199 assert((stm32l4_info->
wrpxxr_mask & 0xFFFF0000) == 0);
2202 free(
bank->sectors);
2204 bank->size = (flash_size_kb + gap_size_kb) * 1024;
2205 bank->num_sectors = num_pages;
2207 if (!
bank->sectors) {
2208 LOG_ERROR(
"failed to allocate bank sectors");
2212 for (
unsigned int i = 0; i <
bank->num_sectors; i++) {
2213 bank->sectors[i].offset = i * page_size_kb * 1024;
2217 bank->sectors[i].offset += gap_size_kb * 1024;
2218 bank->sectors[i].size = page_size_kb * 1024;
2219 bank->sectors[i].is_erased = -1;
2220 bank->sectors[i].is_protected = 1;
2223 stm32l4_info->
probed =
true;
2230 if (stm32l4_info->
probed) {
2249 if (stm32l4_info->
optr == optr_cur)
2262 const uint16_t rev_id = stm32l4_info->
idcode >> 16;
2265 if (stm32l4_info->
probed)
2276 int retval, retval2;
2369 uint32_t reg_offset, reg_addr;
2379 command_print(
CMD,
"Option Register: <0x%" PRIx32
"> = 0x%" PRIx32
"", reg_addr, value);
2394 uint32_t reg_offset;
2396 uint32_t
mask = 0xFFFFFFFF;
2405 "INFO: a reset or power cycle is required "
2406 "for the new settings to take effect.",
bank->driver->name);
2414 if (CMD_ARGC < 1 || CMD_ARGC > 2)
2424 LOG_ERROR(
"This device does not have a TrustZone");
2436 LOG_INFO(
"Global TrustZone Security is %s", stm32l4_info->
tzen ?
"enabled" :
"disabled");
2443 if (new_tzen == stm32l4_info->
tzen) {
2444 LOG_INFO(
"The requested TZEN is already programmed");
2450 LOG_ERROR(
"TZEN can be set only when RDP level is 0");
2459 LOG_ERROR(
"Deactivation of TZEN is only possible when the RDP is changing to level 0");
2490 command_print(
CMD,
"stm32l4x option load completed. Power-on reset might be required");
2508 LOG_ERROR(
"cannot lock/unlock OTP memory");
2543 LOG_ERROR(
"cannot lock/unlock OTP memory");
2566 if (CMD_ARGC < 1 || CMD_ARGC > 2)
2575 LOG_ERROR(
"OTP memory does not have write protection areas");
2582 if (strcmp(
CMD_ARGV[1],
"bank1") == 0)
2584 else if (strcmp(
CMD_ARGV[1],
"bank2") == 0)
2592 LOG_ERROR(
"this device has no second bank");
2595 LOG_ERROR(
"this device is configured in single bank mode");
2601 unsigned int n_wrp, i;
2612 for (i = 0; i < n_wrp; i++) {
2613 if (wrpxy[i].
used) {
2614 for (
int p = wrpxy[i].
first; p <= wrpxy[i].
last; p++)
2620 struct range ranges[n_wrp];
2621 unsigned int ranges_count = 0;
2625 if (ranges_count > 0) {
2650 if (strcmp(
CMD_ARGV[1],
"enable") == 0)
2652 else if (strcmp(
CMD_ARGV[1],
"disable") == 0)
2654 else if (strcmp(
CMD_ARGV[1],
"show") == 0)
2666 .handler = stm32l4_handle_lock_command,
2669 .help =
"Lock entire flash device.",
2673 .handler = stm32l4_handle_unlock_command,
2676 .help =
"Unlock entire protected flash device.",
2679 .name =
"mass_erase",
2680 .handler = stm32l4_handle_mass_erase_command,
2683 .help =
"Erase entire flash device.",
2686 .name =
"option_read",
2687 .handler = stm32l4_handle_option_read_command,
2689 .usage =
"bank_id reg_offset",
2690 .help =
"Read & Display device option bytes.",
2693 .name =
"option_write",
2694 .handler = stm32l4_handle_option_write_command,
2696 .usage =
"bank_id reg_offset value [mask]",
2697 .help =
"Write device option bit fields with provided value.",
2700 .name =
"trustzone",
2701 .handler = stm32l4_handle_trustzone_command,
2703 .usage =
"<bank_id> [enable|disable]",
2704 .help =
"Configure TrustZone security",
2708 .handler = stm32l4_handle_wrp_info_command,
2710 .usage =
"bank_id [bank1|bank2]",
2711 .help =
"list the protected areas using WRP",
2714 .name =
"option_load",
2715 .handler = stm32l4_handle_option_load_command,
2718 .help =
"Force re-load of device options (will cause device reset).",
2722 .handler = stm32l4_handle_otp_command,
2724 .usage =
"<bank_id> <enable|disable|show>",
2725 .help =
"OTP (One Time Programmable) memory write enable/disable",
2734 .help =
"stm32l4x flash command group",
2744 .flash_bank_command = stm32l4_flash_bank_command,
void init_reg_param(struct reg_param *param, const char *reg_name, uint32_t size, enum param_direction direction)
void destroy_reg_param(struct reg_param *param)
This defines formats and data structures used to talk to ADIv5 entities.
static struct armv7m_common * target_to_armv7m_safe(struct target *target)
#define ARMV7M_COMMON_MAGIC
Support functions to access arbitrary bits in a byte array.
static void buf_set_u32(uint8_t *_buffer, unsigned int first, unsigned int num, uint32_t value)
Sets num bits in _buffer, starting at the first bit, using the bits in value.
static int test_bit(unsigned int nr, const volatile unsigned long *addr)
test_bit - Determine whether a bit is set
static void bitmap_zero(unsigned long *dst, unsigned int nbits)
bitmap_zero - Clears all the bits in memory
static void set_bit(unsigned int nr, volatile unsigned long *addr)
set_bit - Set a bit in memory
static void clear_bit(unsigned int nr, volatile unsigned long *addr)
clear_bit - Clear a bit in memory
#define DECLARE_BITMAP(name, bits)
void command_print_sameline(struct command_invocation *cmd, const char *format,...)
void command_print(struct command_invocation *cmd, const char *format,...)
#define CMD
Use this macro to access the command being handled, rather than accessing the variable directly.
#define CALL_COMMAND_HANDLER(name, extra ...)
Use this to macro to call a command helper (or a nested handler).
#define CMD_ARGV
Use this macro to access the arguments for the command being handled, rather than accessing the varia...
#define ERROR_COMMAND_SYNTAX_ERROR
#define CMD_ARGC
Use this macro to access the number of arguments for the command being handled, rather than accessing...
#define COMMAND_PARSE_ENABLE(in, out)
parses an enable/disable command argument
#define COMMAND_PARSE_NUMBER(type, in, out)
parses the string in into out as a type, or prints a command error and passes the error code to the c...
#define COMMAND_REGISTRATION_DONE
Use this as the last entry in an array of command_registration records.
#define ERROR_COMMAND_ARGUMENT_INVALID
static enum cortex_m_impl_part cortex_m_get_impl_part(struct target *target)
uint64_t buffer
Pointer to data buffer to send over SPI.
uint32_t size
Size of dw_spi_transaction::buffer.
uint32_t buffer_size
Size of dw_spi_program::buffer.
uint32_t address
Starting address. Sector aligned.
#define ERROR_FLASH_OPER_UNSUPPORTED
#define ERROR_FLASH_OPERATION_FAILED
#define ERROR_FLASH_DST_OUT_OF_BANK
struct flash_sector * alloc_block_array(uint32_t offset, uint32_t size, unsigned int num_blocks)
Allocate and fill an array of sectors or protection blocks.
int default_flash_blank_check(struct flash_bank *bank)
Provides default erased-bank check handling.
int default_flash_read(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
Provides default read implementation for flash memory.
void default_flash_free_driver_priv(struct flash_bank *bank)
Deallocates bank->driver_priv.
void alive_sleep(uint64_t ms)
#define ERROR_NOT_IMPLEMENTED
#define LOG_WARNING(expr ...)
#define LOG_ERROR(expr ...)
#define LOG_INFO(expr ...)
#define LOG_DEBUG(expr ...)
struct rtt_control ctrl
Control block.
static const struct stm32l4_rev stm32g05_g06xx_revs[]
static const struct stm32l4_rev stm32c071xx_revs[]
static int stm32l4_get_all_wrpxy(struct flash_bank *bank, enum stm32_bank_id dev_bank_id, struct stm32l4_wrp *wrpxy, unsigned int *n_wrp)
static int stm32l4_protect_check(struct flash_bank *bank)
#define FLASH_ERASE_TIMEOUT
static int stm32l4_get_one_wrpxy(struct flash_bank *bank, struct stm32l4_wrp *wrpxy, enum stm32l4_flash_reg_index reg_idx, int offset)
static const struct stm32l4_rev stm32l43_l44xx_revs[]
static const struct stm32l4_rev stm32u53_u54xx_revs[]
static const struct stm32l4_rev stm32u59_u5axx_revs[]
static const struct command_registration stm32l4_exec_command_handlers[]
static int stm32l4_write_flash_reg(struct flash_bank *bank, uint32_t reg_offset, uint32_t value)
static const uint32_t stm32l4_flash_regs[STM32_FLASH_REG_INDEX_NUM]
@ STM32_FLASH_CR_WLK_INDEX
@ STM32_FLASH_WRP1AR_INDEX
@ STM32_FLASH_WRP2BR_INDEX
@ STM32_FLASH_OPTKEYR_INDEX
@ STM32_FLASH_WRP1BR_INDEX
@ STM32_FLASH_WRP2AR_INDEX
@ STM32_FLASH_REG_INDEX_NUM
static int stm32l4_perform_obl_launch(struct flash_bank *bank)
static const struct stm32l4_part_info stm32l4_parts[]
static char * range_print_alloc(struct range *ranges, unsigned int ranges_count)
static int stm32l4_read_idcode(struct flash_bank *bank, uint32_t *id)
static const struct stm32l4_rev stm32g47_g48xx_revs[]
static int stm32l4_read_flash_reg(struct flash_bank *bank, uint32_t reg_offset, uint32_t *value)
static bool stm32l4_otp_is_enabled(struct flash_bank *bank)
#define F_HAS_L5_FLASH_REGS
static const char * get_stm32l4_bank_type_str(struct flash_bank *bank)
static bool stm32l4_is_otp(struct flash_bank *bank)
static int stm32l4_get_flash_cr_with_lock_index(struct flash_bank *bank)
static int range_print_one(struct range *range, char *str)
static const struct stm32l4_rev stm32g03_g04xx_revs[]
static const struct stm32l4_rev stm32c01xx_revs[]
static const char * device_families
static const struct stm32l4_rev stm32u57_u58xx_revs[]
static const struct command_registration stm32l4_command_handlers[]
static const struct stm32l4_rev stm32l45_l46xx_revs[]
static int stm32l4_erase(struct flash_bank *bank, unsigned int first, unsigned int last)
static const struct stm32l4_rev stm32l4p_l4qxx_revs[]
static const struct stm32l4_rev stm32l41_l42xx_revs[]
static int stm32l4_otp_enable(struct flash_bank *bank, bool enable)
static const struct stm32l4_rev stm32l47_l48xx_revs[]
static const struct stm32l4_rev stm32l4r_l4sxx_revs[]
static int stm32l4_write_option(struct flash_bank *bank, uint32_t reg_offset, uint32_t value, uint32_t mask)
static const struct stm32l4_rev stm32l55_l56xx_revs[]
static const struct stm32l4_rev stm32wb1xx_revs[]
static int stm32l4_wait_status_busy(struct flash_bank *bank, int timeout)
static const struct stm32l4_rev stm32wba5x_revs[]
static int stm32l4_mass_erase(struct flash_bank *bank)
static const char * get_stm32l4_rev_str(struct flash_bank *bank)
static int get_stm32l4_info(struct flash_bank *bank, struct command_invocation *cmd)
COMMAND_HANDLER(stm32l4_handle_mass_erase_command)
static const struct stm32l4_rev stm32_g07_g08xx_revs[]
static const struct stm32l4_rev stm32g43_g44xx_revs[]
static const struct stm32l4_rev stm32c03xx_revs[]
static uint32_t stm32l4_get_flash_reg(struct flash_bank *bank, uint32_t reg_offset)
static const struct stm32l4_rev stm32wle_wl5xx_revs[]
static int stm32l4_protect_same_bank(struct flash_bank *bank, enum stm32_bank_id bank_id, int set, unsigned int first, unsigned int last)
FLASH_BANK_COMMAND_HANDLER(stm32l4_flash_bank_command)
static int stm32l4_set_secbb(struct flash_bank *bank, uint32_t value)
set all FLASH_SECBB registers to the same value
static int stm32l4_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
static const struct stm32l4_rev stm32g49_g4axx_revs[]
const struct flash_driver stm32l4x_flash
static int stm32l4_probe(struct flash_bank *bank)
static const uint32_t stm32l5_s_flash_regs[STM32_FLASH_REG_INDEX_NUM]
static int stm32l4_write_block_without_loader(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
static int stm32l4_read_flash_reg_by_index(struct flash_bank *bank, enum stm32l4_flash_reg_index reg_index, uint32_t *value)
static const struct stm32l4_rev stm32u0xx_revs[]
static int stm32l4_unlock_option_reg(struct flash_bank *bank)
static const uint32_t stm32wl_cpu2_flash_regs[STM32_FLASH_REG_INDEX_NUM]
static int stm32l4_unlock_reg(struct flash_bank *bank)
static int stm32l4_write_all_wrpxy(struct flash_bank *bank, struct stm32l4_wrp *wrpxy, unsigned int n_wrp)
static void stm32l4_sync_rdp_tzen(struct flash_bank *bank)
static const struct stm32l4_rev stm32wb3xx_revs[]
#define FLASH_WRITE_TIMEOUT
static const struct stm32l4_rev stm32wb5xx_revs[]
static void bitmap_to_ranges(unsigned long *bitmap, unsigned int nbits, struct range *ranges, unsigned int *ranges_count)
static const struct stm32l4_rev stm32u5f_u5gxx_revs[]
static const uint32_t stm32l5_ns_flash_regs[STM32_FLASH_REG_INDEX_NUM]
static int stm32l4_write_block(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
static int stm32l4_write_flash_reg_by_index(struct flash_bank *bank, enum stm32l4_flash_reg_index reg_index, uint32_t value)
static int stm32l4_protect(struct flash_bank *bank, int set, unsigned int first, unsigned int last)
static uint32_t stm32l4_get_flash_reg_by_index(struct flash_bank *bank, enum stm32l4_flash_reg_index reg_index)
static int stm32l4_write_one_wrpxy(struct flash_bank *bank, struct stm32l4_wrp *wrpxy)
static const struct stm32l4_rev stm32l49_l4axx_revs[]
static int stm32l4_auto_probe(struct flash_bank *bank)
static const struct stm32l4_rev stm32g0b_g0cxx_revs[]
#define DEVID_STM32G03_G04XX
#define DEVID_STM32L55_L56XX
#define DEVID_STM32G0B_G0CXX
#define FLASH_SECBB_SECURE
#define FLASH_G0_DUAL_BANK
#define STM32_FLASH_S_BANK_BASE
#define DEVID_STM32G49_G4AXX
#define DEVID_STM32U53_U54XX
#define DEVID_STM32L4R_L4SXX
#define FLASH_L4_DUAL_BANK
#define DEVID_STM32G47_G48XX
#define FLASH_U5_DUALBANK
#define DEVID_STM32U5F_U5GXX
#define STM32_FLASH_BANK_BASE
#define FLASH_G4_DUAL_BANK
#define DEVID_STM32L47_L48XX
#define DEVID_STM32G07_G08XX
#define DEVID_STM32C071XX
#define DEVID_STM32U59_U5AXX
#define DEVID_STM32L49_L4AXX
#define DEVID_STM32L43_L44XX
#define DEVID_STM32L41_L42XX
#define DEVID_STM32U073_U083XX
#define DEVID_STM32WLE_WL5XX
#define DEVID_STM32G05_G06XX
#define DEVID_STM32U031XX
#define DEVID_STM32G43_G44XX
#define UID64_IDS_STM32WL
#define FLASH_SECBB_NON_SECURE
#define STM32L5_REGS_SEC_OFFSET
#define DEVID_STM32U57_U58XX
#define DBGMCU_IDCODE_L4_G4
#define DEVID_STM32L4P_L4QXX
#define DEVID_STM32L45_L46XX
uint64_t ap_num
ADIv5: Number of this AP (0~255) ADIv6: Base address of this AP (4k aligned) TODO: to be more coheren...
unsigned int common_magic
struct adiv5_ap * debug_ap
When run_command is called, a new instance will be created on the stack, filled with the proper value...
Provides details of a flash bank, available either on-chip or through a major interface.
Provides the implementation-independent structure that defines all of the callbacks required by OpenO...
const char * name
Gives a human-readable name of this flash driver, This field is used to select and initialize the dri...
Describes the geometry and status of a single flash sector within a flash bank.
uint32_t offset
Bus offset from start of the flash chip (in bytes).
uint32_t size
Number of bytes in this flash sector.
unsigned int bank1_sectors
const uint32_t * flash_regs
const struct stm32l4_part_info * part_info
const struct stm32l4_rev * revs
const uint32_t fsize_addr
const uint32_t flash_regs_base
const uint16_t max_flash_size_kb
uint8_t stack[LDR_STACK_SIZE]
enum stm32l4_flash_reg_index reg_idx
void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value)
int target_write_buffer(struct target *target, target_addr_t address, uint32_t size, const uint8_t *buffer)
int target_write_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
Write count items of size bytes to the memory of target at the address given.
uint32_t target_get_working_area_avail(struct target *target)
int target_alloc_working_area(struct target *target, uint32_t size, struct working_area **area)
int target_write_u32(struct target *target, target_addr_t address, uint32_t value)
int target_free_working_area(struct target *target, struct working_area *area)
Free a working area.
int target_alloc_working_area_try(struct target *target, uint32_t size, struct working_area **area)
int target_read_u16(struct target *target, target_addr_t address, uint16_t *value)
int target_run_flash_async_algorithm(struct target *target, const uint8_t *buffer, uint32_t count, int block_size, int num_mem_params, struct mem_param *mem_params, int num_reg_params, struct reg_param *reg_params, uint32_t buffer_start, uint32_t buffer_size, uint32_t entry_point, uint32_t exit_point, void *arch_info)
Streams data to a circular buffer on target intended for consumption by code running asynchronously o...
int target_read_u32(struct target *target, target_addr_t address, uint32_t *value)
#define ERROR_TARGET_NOT_HALTED
static bool target_was_examined(const struct target *target)
#define ERROR_TARGET_INVALID
#define ERROR_TARGET_NOT_EXAMINED
#define ERROR_TARGET_RESOURCE_NOT_AVAILABLE
#define ERROR_TARGET_FAILURE
#define ARRAY_SIZE(x)
Compute the number of elements of a variable length array.