This is an automated email from Gerrit. Rémi PRUD'HOMME ([email protected]) just uploaded a new patch set to Gerrit, which you can find at http://openocd.zylin.com/2319
-- gerrit commit c7245db0c41eb5644f871097a32a514bf39f9f2c Author: Rémi PRUD'HOMME <[email protected]> Date: Thu Sep 25 20:33:16 2014 +0200 add new feature for STM32L : mass erase The mass erase for STM32L was lack because the procedure is more complexe than the procedure for the STM32F4xx. The reference manual RM0038 (L100 subfamily ) page 79 is more accurate than the reference manual for the STM32L0xx. On the L0, the mass-erase erase also the EEPROM. This is a limit to mass erase on L0 The mass erase procedure is a command of telnet interface. Tested on Discovery L053 and Discovery L100. Change-Id: I6a1d7a3669789aea89c59a006ab2d883f3d827ca Signed-off-by: Rémi PRUD'HOMME <[email protected]> diff --git a/src/flash/nor/stm32lx.c b/src/flash/nor/stm32lx.c old mode 100644 new mode 100755 index dc1a0c4..a8fec6e --- a/src/flash/nor/stm32lx.c +++ b/src/flash/nor/stm32lx.c @@ -36,15 +36,15 @@ /* stm32lx flash register locations */ -#define FLASH_ACR 0x00 -#define FLASH_PECR 0x04 +#define FLASH_ACR 0x00 +#define FLASH_PECR 0x04 #define FLASH_PDKEYR 0x08 #define FLASH_PEKEYR 0x0C #define FLASH_PRGKEYR 0x10 #define FLASH_OPTKEYR 0x14 -#define FLASH_SR 0x18 -#define FLASH_OBR 0x1C -#define FLASH_WRPR 0x20 +#define FLASH_SR 0x18 +#define FLASH_OBR 0x1C +#define FLASH_WRPR 0x20 /* FLASH_ACR bites */ #define FLASH_ACR__LATENCY (1<<0) @@ -92,11 +92,20 @@ #define FLASH_SECTOR_SIZE 4096 #define FLASH_BANK0_ADDRESS 0x08000000 +/* option bytes */ +#define OPTION_BYTES_ADDRESS 0x1FF80000 + +#define OPTION_BYTE_0_PR1 0x015500AA +#define OPTION_BYTE_0_PR0 0x01FF0011 + + static int stm32lx_unlock_program_memory(struct flash_bank *bank); static int stm32lx_lock_program_memory(struct flash_bank *bank); static int stm32lx_enable_write_half_page(struct flash_bank *bank); static int stm32lx_erase_sector(struct flash_bank *bank, int sector); static int stm32lx_wait_until_bsy_clear(struct flash_bank *bank); +static int stm32lx_mass_erase(struct flash_bank *bank); +static int stm32lx_wait_status_busy(struct flash_bank *bank, int timeout); struct stm32lx_rev { uint16_t rev; @@ -143,83 +152,83 @@ static const struct stm32lx_rev stm32_436_revs[] = { static const struct stm32lx_part_info stm32lx_parts[] = { { - .id = 0x416, - .revs = stm32_416_revs, - .num_revs = ARRAY_SIZE(stm32_416_revs), - .device_str = "STM32L1xx (Low/Medium Density)", - .page_size = 256, - .pages_per_sector = 16, - .max_flash_size_kb = 128, - .has_dual_banks = false, - .flash_base = 0x40023C00, - .fsize_base = 0x1FF8004C, + .id = 0x416, + .revs = stm32_416_revs, + .num_revs = ARRAY_SIZE(stm32_416_revs), + .device_str = "STM32L1xx (Low/Medium Density)", + .page_size = 256, + .pages_per_sector = 16, + .max_flash_size_kb = 128, + .has_dual_banks = false, + .flash_base = 0x40023C00, + .fsize_base = 0x1FF8004C, }, { - .id = 0x417, - .revs = stm32_417_revs, - .num_revs = ARRAY_SIZE(stm32_417_revs), - .device_str = "STM32L0xx", - .page_size = 128, - .pages_per_sector = 32, - .max_flash_size_kb = 64, - .has_dual_banks = false, - .flash_base = 0x40022000, - .fsize_base = 0x1FF8007C, + .id = 0x417, + .revs = stm32_417_revs, + .num_revs = ARRAY_SIZE(stm32_417_revs), + .device_str = "STM32L0xx", + .page_size = 128, + .pages_per_sector = 32, + .max_flash_size_kb = 64, + .has_dual_banks = false, + .flash_base = 0x40022000, + .fsize_base = 0x1FF8007C, }, { - .id = 0x427, - .revs = stm32_427_revs, - .num_revs = ARRAY_SIZE(stm32_427_revs), - .device_str = "STM32L1xx (Medium+ Density)", - .page_size = 256, - .pages_per_sector = 16, - .max_flash_size_kb = 256, - .first_bank_size_kb = 192, - .has_dual_banks = true, - .flash_base = 0x40023C00, - .fsize_base = 0x1FF800CC, + .id = 0x427, + .revs = stm32_427_revs, + .num_revs = ARRAY_SIZE(stm32_427_revs), + .device_str = "STM32L1xx (Medium+ Density)", + .page_size = 256, + .pages_per_sector = 16, + .max_flash_size_kb = 256, + .first_bank_size_kb = 192, + .has_dual_banks = true, + .flash_base = 0x40023C00, + .fsize_base = 0x1FF800CC, }, { - .id = 0x436, - .revs = stm32_436_revs, - .num_revs = ARRAY_SIZE(stm32_436_revs), - .device_str = "STM32L1xx (Medium+/High Density)", - .page_size = 256, - .pages_per_sector = 16, - .max_flash_size_kb = 384, - .first_bank_size_kb = 192, - .has_dual_banks = true, - .flash_base = 0x40023C00, - .fsize_base = 0x1FF800CC, + .id = 0x436, + .revs = stm32_436_revs, + .num_revs = ARRAY_SIZE(stm32_436_revs), + .device_str = "STM32L1xx (Medium+/High Density)", + .page_size = 256, + .pages_per_sector = 16, + .max_flash_size_kb = 384, + .first_bank_size_kb = 192, + .has_dual_banks = true, + .flash_base = 0x40023C00, + .fsize_base = 0x1FF800CC, }, { - .id = 0x437, - .device_str = "STM32L1xx (Medium+/High Density)", - .page_size = 256, - .pages_per_sector = 16, - .max_flash_size_kb = 512, - .first_bank_size_kb = 256, - .has_dual_banks = true, - .flash_base = 0x40023C00, - .fsize_base = 0x1FF800CC, + .id = 0x437, + .device_str = "STM32L1xx (Medium+/High Density)", + .page_size = 256, + .pages_per_sector = 16, + .max_flash_size_kb = 512, + .first_bank_size_kb = 256, + .has_dual_banks = true, + .flash_base = 0x40023C00, + .fsize_base = 0x1FF800CC, }, }; /* flash bank stm32lx <base> <size> 0 0 <target#> - */ + */ FLASH_BANK_COMMAND_HANDLER(stm32lx_flash_bank_command) { struct stm32lx_flash_bank *stm32lx_info; if (CMD_ARGC < 6) - return ERROR_COMMAND_SYNTAX_ERROR; + return ERROR_COMMAND_SYNTAX_ERROR; /* Create the bank structure */ - stm32lx_info = calloc(1, sizeof(*stm32lx_info)); + stm32lx_info = malloc(sizeof(struct stm32lx_flash_bank)); /* Check allocation */ if (stm32lx_info == NULL) { - LOG_ERROR("failed to allocate bank structure"); - return ERROR_FAIL; + LOG_ERROR("failed to allocate bank structure"); + return ERROR_FAIL; } bank->driver_priv = stm32lx_info; @@ -233,6 +242,35 @@ FLASH_BANK_COMMAND_HANDLER(stm32lx_flash_bank_command) return ERROR_OK; } + +COMMAND_HANDLER(stm32lx_handle_mass_erase_command) +{ + int i; + + if (CMD_ARGC < 1) { + command_print(CMD_CTX, "stm32lx mass_erase <bank>"); + return ERROR_COMMAND_SYNTAX_ERROR; + } + + struct flash_bank *bank; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); + if (ERROR_OK != retval) + return retval; + + retval = stm32lx_mass_erase(bank); + if (retval == ERROR_OK) { + /* set all sectors as erased */ + for (i = 0; i < bank->num_sectors; i++) + bank->sectors[i].is_erased = 1; + + command_print(CMD_CTX, "stm32lx mass erase complete"); + } else { + command_print(CMD_CTX, "stm32lx mass erase failed"); + } + + return retval; +} + static int stm32lx_protect_check(struct flash_bank *bank) { int retval; @@ -246,15 +284,15 @@ static int stm32lx_protect_check(struct flash_bank *bank) * flash sector */ retval = target_read_u32(target, stm32lx_info->flash_base + FLASH_WRPR, - &wrpr); + &wrpr); if (retval != ERROR_OK) - return retval; + return retval; for (int i = 0; i < bank->num_sectors; i++) { - if (wrpr & (1 << i)) - bank->sectors[i].is_protected = 1; - else - bank->sectors[i].is_protected = 0; + if (wrpr & (1 << i)) + bank->sectors[i].is_protected = 1; + else + bank->sectors[i].is_protected = 0; } return ERROR_OK; } @@ -269,31 +307,31 @@ static int stm32lx_erase(struct flash_bank *bank, int first, int last) */ if (bank->target->state != TARGET_HALTED) { - LOG_ERROR("Target not halted"); - return ERROR_TARGET_NOT_HALTED; + LOG_ERROR("Target not halted"); + return ERROR_TARGET_NOT_HALTED; } /* * Loop over the selected sectors and erase them */ for (int i = first; i <= last; i++) { - retval = stm32lx_erase_sector(bank, i); - if (retval != ERROR_OK) - return retval; - bank->sectors[i].is_erased = 1; + retval = stm32lx_erase_sector(bank, i); + if (retval != ERROR_OK) + return retval; + bank->sectors[i].is_erased = 1; } return ERROR_OK; } static int stm32lx_protect(struct flash_bank *bank, int set, int first, - int last) + int last) { LOG_WARNING("protection of the STM32L flash is not implemented"); return ERROR_OK; } static int stm32lx_write_half_pages(struct flash_bank *bank, const uint8_t *buffer, - uint32_t offset, uint32_t count) + uint32_t offset, uint32_t count) { struct target *target = bank->target; struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv; @@ -312,60 +350,60 @@ static int stm32lx_write_half_pages(struct flash_bank *bank, const uint8_t *buff /* see contib/loaders/flash/stm32lx.S for src */ static const uint8_t stm32lx_flash_write_code[] = { - /* write_word: */ - 0x00, 0x23, /* movs r3, #0 */ - 0x04, 0xe0, /* b test_done */ + /* write_word: */ + 0x00, 0x23, /* movs r3, #0 */ + 0x04, 0xe0, /* b test_done */ - /* write_word: */ - 0x51, 0xf8, 0x04, 0xcb, /* ldr ip, [r1], #4 */ - 0x40, 0xf8, 0x04, 0xcb, /* str ip, [r0], #4 */ - 0x01, 0x33, /* adds r3, #1 */ + /* write_word: */ + 0x51, 0xf8, 0x04, 0xcb, /* ldr ip, [r1], #4 */ + 0x40, 0xf8, 0x04, 0xcb, /* str ip, [r0], #4 */ + 0x01, 0x33, /* adds r3, #1 */ - /* test_done: */ - 0x93, 0x42, /* cmp r3, r2 */ - 0xf8, 0xd3, /* bcc write_word */ - 0x00, 0xbe, /* bkpt 0 */ + /* test_done: */ + 0x93, 0x42, /* cmp r3, r2 */ + 0xf8, 0xd3, /* bcc write_word */ + 0x00, 0xbe, /* bkpt 0 */ }; /* Make sure we're performing a half-page aligned write. */ if (count % hp_nb) { - LOG_ERROR("The byte count must be %" PRIu32 "B-aligned but count is %" PRIi32 "B)", hp_nb, count); - return ERROR_FAIL; + LOG_ERROR("The byte count must be %" PRIu32 "B-aligned but count is %" PRIi32 "B)", hp_nb, count); + return ERROR_FAIL; } /* flash write code */ if (target_alloc_working_area(target, sizeof(stm32lx_flash_write_code), - &write_algorithm) != ERROR_OK) { - LOG_DEBUG("no working area for block memory writes"); - return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; + &write_algorithm) != ERROR_OK) { + LOG_DEBUG("no working area for block memory writes"); + return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; }; /* Write the flashing code */ retval = target_write_buffer(target, - write_algorithm->address, - sizeof(stm32lx_flash_write_code), - stm32lx_flash_write_code); + write_algorithm->address, + sizeof(stm32lx_flash_write_code), + stm32lx_flash_write_code); if (retval != ERROR_OK) { - target_free_working_area(target, write_algorithm); - return retval; + target_free_working_area(target, write_algorithm); + return retval; } /* Allocate half pages memory */ while (target_alloc_working_area_try(target, buffer_size, &source) != ERROR_OK) { - if (buffer_size > 1024) - buffer_size -= 1024; - else - buffer_size /= 2; - - if (buffer_size <= stm32lx_info->part_info->page_size) { - /* we already allocated the writing code, but failed to get a - * buffer, free the algorithm */ - target_free_working_area(target, write_algorithm); - - LOG_WARNING("no large enough working area available, can't do block memory writes"); - return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; - } + if (buffer_size > 1024) + buffer_size -= 1024; + else + buffer_size /= 2; + + if (buffer_size <= stm32lx_info->part_info->page_size) { + /* we already allocated the writing code, but failed to get a + * buffer, free the algorithm */ + target_free_working_area(target, write_algorithm); + + LOG_WARNING("no large enough working area available, can't do block memory writes"); + return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; + } } armv7m_info.common_magic = ARMV7M_COMMON_MAGIC; @@ -377,21 +415,21 @@ static int stm32lx_write_half_pages(struct flash_bank *bank, const uint8_t *buff /* Enable half-page write */ retval = stm32lx_enable_write_half_page(bank); if (retval != ERROR_OK) { - target_free_working_area(target, source); - target_free_working_area(target, write_algorithm); + target_free_working_area(target, source); + target_free_working_area(target, write_algorithm); - destroy_reg_param(®_params[0]); - destroy_reg_param(®_params[1]); - destroy_reg_param(®_params[2]); - return retval; + destroy_reg_param(®_params[0]); + destroy_reg_param(®_params[1]); + destroy_reg_param(®_params[2]); + return retval; } struct armv7m_common *armv7m = target_to_armv7m(target); if (armv7m == NULL) { - /* something is very wrong if armv7m is NULL */ - LOG_ERROR("unable to get armv7m target"); - return retval; + /* something is very wrong if armv7m is NULL */ + LOG_ERROR("unable to get armv7m target"); + return retval; } /* save any DEMCR flags and configure target to catch any Hard Faults */ @@ -400,41 +438,41 @@ static int stm32lx_write_half_pages(struct flash_bank *bank, const uint8_t *buff /* Loop while there are bytes to write */ while (count > 0) { - uint32_t this_count; - this_count = (count > buffer_size) ? buffer_size : count; - - /* Write the next half pages */ - retval = target_write_buffer(target, source->address, this_count, buffer); - if (retval != ERROR_OK) - break; - - /* 4: Store useful information in the registers */ - /* the destination address of the copy (R0) */ - buf_set_u32(reg_params[0].value, 0, 32, address); - /* The source address of the copy (R1) */ - buf_set_u32(reg_params[1].value, 0, 32, source->address); - /* The length of the copy (R2) */ - buf_set_u32(reg_params[2].value, 0, 32, this_count / 4); - - /* 5: Execute the bunch of code */ - retval = target_run_algorithm(target, 0, NULL, sizeof(reg_params) - / sizeof(*reg_params), reg_params, - write_algorithm->address, 0, 10000, &armv7m_info); - if (retval != ERROR_OK) - break; - - /* check for Hard Fault */ - if (armv7m->exception_number == 3) - break; - - /* 6: Wait while busy */ - retval = stm32lx_wait_until_bsy_clear(bank); - if (retval != ERROR_OK) - break; - - buffer += this_count; - address += this_count; - count -= this_count; + uint32_t this_count; + this_count = (count > buffer_size) ? buffer_size : count; + + /* Write the next half pages */ + retval = target_write_buffer(target, source->address, this_count, buffer); + if (retval != ERROR_OK) + break; + + /* 4: Store useful information in the registers */ + /* the destination address of the copy (R0) */ + buf_set_u32(reg_params[0].value, 0, 32, address); + /* The source address of the copy (R1) */ + buf_set_u32(reg_params[1].value, 0, 32, source->address); + /* The length of the copy (R2) */ + buf_set_u32(reg_params[2].value, 0, 32, this_count / 4); + + /* 5: Execute the bunch of code */ + retval = target_run_algorithm(target, 0, NULL, sizeof(reg_params) + / sizeof(*reg_params), reg_params, + write_algorithm->address, 0, 10000, &armv7m_info); + if (retval != ERROR_OK) + break; + + /* check for Hard Fault */ + if (armv7m->exception_number == 3) + break; + + /* 6: Wait while busy */ + retval = stm32lx_wait_until_bsy_clear(bank); + if (retval != ERROR_OK) + break; + + buffer += this_count; + address += this_count; + count -= this_count; } /* restore previous flags */ @@ -442,39 +480,39 @@ static int stm32lx_write_half_pages(struct flash_bank *bank, const uint8_t *buff if (armv7m->exception_number == 3) { - /* the stm32l15x devices seem to have an issue when blank. - * if a ram loader is executed on a blank device it will - * Hard Fault, this issue does not happen for a already programmed device. - * A related issue is described in the stm32l151xx errata (Doc ID 17721 Rev 6 - 2.1.3). - * The workaround of handling the Hard Fault exception does work, but makes the - * loader more complicated, as a compromise we manually write the pages, programming time - * is reduced by 50% using this slower method. - */ - - LOG_WARNING("couldn't use loader, falling back to page memory writes"); - - while (count > 0) { - uint32_t this_count; - this_count = (count > hp_nb) ? hp_nb : count; - - /* Write the next half pages */ - retval = target_write_buffer(target, address, this_count, buffer); - if (retval != ERROR_OK) - break; - - /* Wait while busy */ - retval = stm32lx_wait_until_bsy_clear(bank); - if (retval != ERROR_OK) - break; - - buffer += this_count; - address += this_count; - count -= this_count; - } + /* the stm32l15x devices seem to have an issue when blank. + * if a ram loader is executed on a blank device it will + * Hard Fault, this issue does not happen for a already programmed device. + * A related issue is described in the stm32l151xx errata (Doc ID 17721 Rev 6 - 2.1.3). + * The workaround of handling the Hard Fault exception does work, but makes the + * loader more complicated, as a compromise we manually write the pages, programming time + * is reduced by 50% using this slower method. + */ + + LOG_WARNING("couldn't use loader, falling back to page memory writes"); + + while (count > 0) { + uint32_t this_count; + this_count = (count > hp_nb) ? hp_nb : count; + + /* Write the next half pages */ + retval = target_write_buffer(target, address, this_count, buffer); + if (retval != ERROR_OK) + break; + + /* Wait while busy */ + retval = stm32lx_wait_until_bsy_clear(bank); + if (retval != ERROR_OK) + break; + + buffer += this_count; + address += this_count; + count -= this_count; + } } if (retval == ERROR_OK) - retval = stm32lx_lock_program_memory(bank); + retval = stm32lx_lock_program_memory(bank); target_free_working_area(target, source); target_free_working_area(target, write_algorithm); @@ -487,7 +525,7 @@ static int stm32lx_write_half_pages(struct flash_bank *bank, const uint8_t *buff } static int stm32lx_write(struct flash_bank *bank, const uint8_t *buffer, - uint32_t offset, uint32_t count) + uint32_t offset, uint32_t count) { struct target *target = bank->target; struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv; @@ -500,43 +538,43 @@ static int stm32lx_write(struct flash_bank *bank, const uint8_t *buffer, int retval, retval2; if (bank->target->state != TARGET_HALTED) { - LOG_ERROR("Target not halted"); - return ERROR_TARGET_NOT_HALTED; + LOG_ERROR("Target not halted"); + return ERROR_TARGET_NOT_HALTED; } if (offset & 0x3) { - LOG_ERROR("offset 0x%" PRIx32 " breaks required 4-byte alignment", offset); - return ERROR_FLASH_DST_BREAKS_ALIGNMENT; + LOG_ERROR("offset 0x%" PRIx32 " breaks required 4-byte alignment", offset); + return ERROR_FLASH_DST_BREAKS_ALIGNMENT; } retval = stm32lx_unlock_program_memory(bank); if (retval != ERROR_OK) - return retval; + return retval; /* first we need to write any unaligned head bytes upto * the next 128 byte page */ if (offset % hp_nb) - bytes_remaining = MIN(count, hp_nb - (offset % hp_nb)); + bytes_remaining = MIN(count, hp_nb - (offset % hp_nb)); while (bytes_remaining > 0) { - uint8_t value[4] = {0xff, 0xff, 0xff, 0xff}; + uint8_t value[4] = {0xff, 0xff, 0xff, 0xff}; - /* copy remaining bytes into the write buffer */ - uint32_t bytes_to_write = MIN(4, bytes_remaining); - memcpy(value, buffer + bytes_written, bytes_to_write); + /* copy remaining bytes into the write buffer */ + uint32_t bytes_to_write = MIN(4, bytes_remaining); + memcpy(value, buffer + bytes_written, bytes_to_write); - retval = target_write_buffer(target, address, 4, value); - if (retval != ERROR_OK) - goto reset_pg_and_lock; + retval = target_write_buffer(target, address, 4, value); + if (retval != ERROR_OK) + goto reset_pg_and_lock; - bytes_written += bytes_to_write; - bytes_remaining -= bytes_to_write; - address += 4; + bytes_written += bytes_to_write; + bytes_remaining -= bytes_to_write; + address += 4; - retval = stm32lx_wait_until_bsy_clear(bank); - if (retval != ERROR_OK) - goto reset_pg_and_lock; + retval = stm32lx_wait_until_bsy_clear(bank); + if (retval != ERROR_OK) + goto reset_pg_and_lock; } offset += bytes_written; @@ -549,15 +587,15 @@ static int stm32lx_write(struct flash_bank *bank, const uint8_t *buffer, halfpages_number = count / hp_nb; if (halfpages_number) { - retval = stm32lx_write_half_pages(bank, buffer + bytes_written, offset, hp_nb * halfpages_number); - if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE) { - /* attempt slow memory writes */ - LOG_WARNING("couldn't use block writes, falling back to single memory accesses"); - halfpages_number = 0; - } else { - if (retval != ERROR_OK) - return ERROR_FAIL; - } + retval = stm32lx_write_half_pages(bank, buffer + bytes_written, offset, hp_nb * halfpages_number); + if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE) { + /* attempt slow memory writes */ + LOG_WARNING("couldn't use block writes, falling back to single memory accesses"); + halfpages_number = 0; + } else { + if (retval != ERROR_OK) + return ERROR_FAIL; + } } /* write any remaining bytes */ @@ -568,32 +606,32 @@ static int stm32lx_write(struct flash_bank *bank, const uint8_t *buffer, retval = stm32lx_unlock_program_memory(bank); if (retval != ERROR_OK) - return retval; + return retval; while (bytes_remaining > 0) { - uint8_t value[4] = {0xff, 0xff, 0xff, 0xff}; + uint8_t value[4] = {0xff, 0xff, 0xff, 0xff}; - /* copy remaining bytes into the write buffer */ - uint32_t bytes_to_write = MIN(4, bytes_remaining); - memcpy(value, buffer + bytes_written, bytes_to_write); + /* copy remaining bytes into the write buffer */ + uint32_t bytes_to_write = MIN(4, bytes_remaining); + memcpy(value, buffer + bytes_written, bytes_to_write); - retval = target_write_buffer(target, address, 4, value); - if (retval != ERROR_OK) - goto reset_pg_and_lock; + retval = target_write_buffer(target, address, 4, value); + if (retval != ERROR_OK) + goto reset_pg_and_lock; - bytes_written += bytes_to_write; - bytes_remaining -= bytes_to_write; - address += 4; + bytes_written += bytes_to_write; + bytes_remaining -= bytes_to_write; + address += 4; - retval = stm32lx_wait_until_bsy_clear(bank); - if (retval != ERROR_OK) - goto reset_pg_and_lock; + retval = stm32lx_wait_until_bsy_clear(bank); + if (retval != ERROR_OK) + goto reset_pg_and_lock; } -reset_pg_and_lock: + reset_pg_and_lock: retval2 = stm32lx_lock_program_memory(bank); if (retval == ERROR_OK) - retval = retval2; + retval = retval2; return retval; } @@ -603,12 +641,12 @@ static int stm32lx_read_id_code(struct target *target, uint32_t *id) /* read stm32 device id register */ int retval = target_read_u32(target, DBGMCU_IDCODE, id); if (retval != ERROR_OK) - return retval; + return retval; /* STM32L0 parts will have 0 there, try reading the L0's location for * DBG_IDCODE in case this is an L0 part. */ if (*id == 0) - retval = target_read_u32(target, DBGMCU_IDCODE_L0, id); + retval = target_read_u32(target, DBGMCU_IDCODE_L0, id); return retval; } @@ -624,94 +662,93 @@ static int stm32lx_probe(struct flash_bank *bank) uint32_t second_bank_base; stm32lx_info->probed = 0; - stm32lx_info->part_info = NULL; int retval = stm32lx_read_id_code(bank->target, &device_id); if (retval != ERROR_OK) - return retval; + return retval; stm32lx_info->idcode = device_id; LOG_DEBUG("device id = 0x%08" PRIx32 "", device_id); for (unsigned int n = 0; n < ARRAY_SIZE(stm32lx_parts); n++) { - if ((device_id & 0xfff) == stm32lx_parts[n].id) - stm32lx_info->part_info = &stm32lx_parts[n]; + if ((device_id & 0xfff) == stm32lx_parts[n].id) + stm32lx_info->part_info = &stm32lx_parts[n]; } if (!stm32lx_info->part_info) { - LOG_WARNING("Cannot identify target as a STM32L family."); - return ERROR_FAIL; + LOG_WARNING("Cannot identify target as a STM32L family."); + return ERROR_FAIL; } stm32lx_info->flash_base = stm32lx_info->part_info->flash_base; /* Get the flash size from target. */ retval = target_read_u16(target, stm32lx_info->part_info->fsize_base, - &flash_size_in_kb); + &flash_size_in_kb); /* 0x436 devices report their flash size as a 0 or 1 code indicating 384K * or 256K, respectively. Please see RM0038 r8 or newer and refer to * section 30.1.1. */ if (retval == ERROR_OK && (device_id & 0xfff) == 0x436) { - if (flash_size_in_kb == 0) - flash_size_in_kb = 384; - else if (flash_size_in_kb == 1) - flash_size_in_kb = 256; + if (flash_size_in_kb == 0) + flash_size_in_kb = 384; + else if (flash_size_in_kb == 1) + flash_size_in_kb = 256; } /* Failed reading flash size or flash size invalid (early silicon), * default to max target family */ if (retval != ERROR_OK || flash_size_in_kb == 0xffff || flash_size_in_kb == 0) { - LOG_WARNING("STM32L flash size failed, probe inaccurate - assuming %dk flash", - stm32lx_info->part_info->max_flash_size_kb); - flash_size_in_kb = stm32lx_info->part_info->max_flash_size_kb; + LOG_WARNING("STM32L flash size failed, probe inaccurate - assuming %dk flash", + stm32lx_info->part_info->max_flash_size_kb); + flash_size_in_kb = stm32lx_info->part_info->max_flash_size_kb; } else if (flash_size_in_kb > stm32lx_info->part_info->max_flash_size_kb) { - LOG_WARNING("STM32L probed flash size assumed incorrect since FLASH_SIZE=%dk > %dk, - assuming %dk flash", - flash_size_in_kb, stm32lx_info->part_info->max_flash_size_kb, - stm32lx_info->part_info->max_flash_size_kb); - flash_size_in_kb = stm32lx_info->part_info->max_flash_size_kb; + LOG_WARNING("STM32L probed flash size assumed incorrect since FLASH_SIZE=%dk > %dk, - assuming %dk flash", + flash_size_in_kb, stm32lx_info->part_info->max_flash_size_kb, + stm32lx_info->part_info->max_flash_size_kb); + flash_size_in_kb = stm32lx_info->part_info->max_flash_size_kb; } if (stm32lx_info->part_info->has_dual_banks) { - /* Use the configured base address to determine if this is the first or second flash bank. - * Verify that the base address is reasonably correct and determine the flash bank size - */ - second_bank_base = base_address + - stm32lx_info->part_info->first_bank_size_kb * 1024; - if (bank->base == second_bank_base) { - /* This is the second bank */ - base_address = second_bank_base; - flash_size_in_kb = flash_size_in_kb - - stm32lx_info->part_info->first_bank_size_kb; - } else if (bank->base == 0 || bank->base == base_address) { - /* This is the first bank */ - flash_size_in_kb = stm32lx_info->part_info->first_bank_size_kb; - } else { - LOG_WARNING("STM32L flash bank base address config is incorrect." - " 0x%" PRIx32 " but should rather be 0x%" PRIx32 " or 0x%" PRIx32, - bank->base, base_address, second_bank_base); - return ERROR_FAIL; - } - LOG_INFO("STM32L flash has dual banks. Bank (%d) size is %dkb, base address is 0x%" PRIx32, - bank->bank_number, flash_size_in_kb, base_address); + /* Use the configured base address to determine if this is the first or second flash bank. + * Verify that the base address is reasonably correct and determine the flash bank size + */ + second_bank_base = base_address + + stm32lx_info->part_info->first_bank_size_kb * 1024; + if (bank->base == second_bank_base) { + /* This is the second bank */ + base_address = second_bank_base; + flash_size_in_kb = flash_size_in_kb - + stm32lx_info->part_info->first_bank_size_kb; + } else if (bank->base == 0 || bank->base == base_address) { + /* This is the first bank */ + flash_size_in_kb = stm32lx_info->part_info->first_bank_size_kb; + } else { + LOG_WARNING("STM32L flash bank base address config is incorrect." + " 0x%" PRIx32 " but should rather be 0x%" PRIx32 " or 0x%" PRIx32, + bank->base, base_address, second_bank_base); + return ERROR_FAIL; + } + LOG_INFO("STM32L flash has dual banks. Bank (%d) size is %dkb, base address is 0x%" PRIx32, + bank->bank_number, flash_size_in_kb, base_address); } else { - LOG_INFO("STM32L flash size is %dkb, base address is 0x%" PRIx32, flash_size_in_kb, base_address); + LOG_INFO("STM32L flash size is %dkb, base address is 0x%" PRIx32, flash_size_in_kb, base_address); } /* if the user sets the size manually then ignore the probed value * this allows us to work around devices that have a invalid flash size register value */ if (stm32lx_info->user_bank_size) { - flash_size_in_kb = stm32lx_info->user_bank_size / 1024; - LOG_INFO("ignoring flash probed value, using configured bank size: %dkbytes", flash_size_in_kb); + flash_size_in_kb = stm32lx_info->user_bank_size / 1024; + LOG_INFO("ignoring flash probed value, using configured bank size: %dkbytes", flash_size_in_kb); } /* calculate numbers of sectors (4kB per sector) */ int num_sectors = (flash_size_in_kb * 1024) / FLASH_SECTOR_SIZE; if (bank->sectors) { - free(bank->sectors); - bank->sectors = NULL; + free(bank->sectors); + bank->sectors = NULL; } bank->size = flash_size_in_kb * 1024; @@ -719,15 +756,15 @@ static int stm32lx_probe(struct flash_bank *bank) bank->num_sectors = num_sectors; bank->sectors = malloc(sizeof(struct flash_sector) * num_sectors); if (bank->sectors == NULL) { - LOG_ERROR("failed to allocate bank sectors"); - return ERROR_FAIL; + LOG_ERROR("failed to allocate bank sectors"); + return ERROR_FAIL; } for (i = 0; i < num_sectors; i++) { - bank->sectors[i].offset = i * FLASH_SECTOR_SIZE; - bank->sectors[i].size = FLASH_SECTOR_SIZE; - bank->sectors[i].is_erased = -1; - bank->sectors[i].is_protected = 1; + bank->sectors[i].offset = i * FLASH_SECTOR_SIZE; + bank->sectors[i].size = FLASH_SECTOR_SIZE; + bank->sectors[i].is_erased = -1; + bank->sectors[i].is_protected = 1; } stm32lx_info->probed = 1; @@ -740,7 +777,7 @@ static int stm32lx_auto_probe(struct flash_bank *bank) struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv; if (stm32lx_info->probed) - return ERROR_OK; + return ERROR_OK; return stm32lx_probe(bank); } @@ -754,41 +791,41 @@ static int stm32lx_erase_check(struct flash_bank *bank) int retval = ERROR_OK; if (bank->target->state != TARGET_HALTED) { - LOG_ERROR("Target not halted"); - return ERROR_TARGET_NOT_HALTED; + LOG_ERROR("Target not halted"); + return ERROR_TARGET_NOT_HALTED; } uint8_t *buffer = malloc(buffer_size); if (buffer == NULL) { - LOG_ERROR("failed to allocate read buffer"); - return ERROR_FAIL; + LOG_ERROR("failed to allocate read buffer"); + return ERROR_FAIL; } for (i = 0; i < bank->num_sectors; i++) { - uint32_t j; - bank->sectors[i].is_erased = 1; - - /* Loop chunk by chunk over the sector */ - for (j = 0; j < bank->sectors[i].size; j += buffer_size) { - uint32_t chunk; - chunk = buffer_size; - if (chunk > (j - bank->sectors[i].size)) - chunk = (j - bank->sectors[i].size); - - retval = target_read_memory(target, bank->base - + bank->sectors[i].offset + j, 4, chunk / 4, buffer); - if (retval != ERROR_OK) - break; - - for (nBytes = 0; nBytes < chunk; nBytes++) { - if (buffer[nBytes] != 0x00) { - bank->sectors[i].is_erased = 0; - break; - } - } - } - if (retval != ERROR_OK) - break; + uint32_t j; + bank->sectors[i].is_erased = 1; + + /* Loop chunk by chunk over the sector */ + for (j = 0; j < bank->sectors[i].size; j += buffer_size) { + uint32_t chunk; + chunk = buffer_size; + if (chunk > (j - bank->sectors[i].size)) + chunk = (j - bank->sectors[i].size); + + retval = target_read_memory(target, bank->base + + bank->sectors[i].offset + j, 4, chunk / 4, buffer); + if (retval != ERROR_OK) + break; + + for (nBytes = 0; nBytes < chunk; nBytes++) { + if (buffer[nBytes] != 0x00) { + bank->sectors[i].is_erased = 0; + break; + } + } + } + if (retval != ERROR_OK) + break; } free(buffer); @@ -801,71 +838,78 @@ static int stm32lx_get_info(struct flash_bank *bank, char *buf, int buf_size) struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv; if (!stm32lx_info->probed) { - int retval = stm32lx_probe(bank); - if (retval != ERROR_OK) { - snprintf(buf, buf_size, - "Unable to find bank information."); - return retval; - } + int retval = stm32lx_probe(bank); + if (retval != ERROR_OK) { + snprintf(buf, buf_size, + "Unable to find bank information."); + return retval; + } } const struct stm32lx_part_info *info = stm32lx_info->part_info; if (info) { - const char *rev_str = NULL; - uint16_t rev_id = stm32lx_info->idcode >> 16; - - for (unsigned int i = 0; i < info->num_revs; i++) - if (rev_id == info->revs[i].rev) - rev_str = info->revs[i].str; - - if (rev_str != NULL) { - snprintf(buf, buf_size, - "%s - Rev: %s", - stm32lx_info->part_info->device_str, rev_str); - } else { - snprintf(buf, buf_size, - "%s - Rev: unknown (0x%04x)", - stm32lx_info->part_info->device_str, rev_id); - } - - return ERROR_OK; + const char *rev_str = NULL; + uint16_t rev_id = stm32lx_info->idcode >> 16; + + for (unsigned int i = 0; i < info->num_revs; i++) + if (rev_id == info->revs[i].rev) + rev_str = info->revs[i].str; + + if (rev_str != NULL) { + snprintf(buf, buf_size, + "%s - Rev: %s", + stm32lx_info->part_info->device_str, rev_str); + } else { + snprintf(buf, buf_size, + "%s - Rev: unknown (0x%04x)", + stm32lx_info->part_info->device_str, rev_id); + } + + return ERROR_OK; } else { - snprintf(buf, buf_size, "Cannot identify target as a STM32Lx"); + snprintf(buf, buf_size, "Cannot identify target as a STM32Lx"); - return ERROR_FAIL; + return ERROR_FAIL; } } static const struct command_registration stm32lx_exec_command_handlers[] = { + { + .name = "mass_erase", + .handler = stm32lx_handle_mass_erase_command, + .mode = COMMAND_EXEC, + .usage = "bank_id", + .help = "Erase entire flash device. Erase also the EEPROM", + }, COMMAND_REGISTRATION_DONE }; static const struct command_registration stm32lx_command_handlers[] = { { - .name = "stm32lx", - .mode = COMMAND_ANY, - .help = "stm32lx flash command group", - .usage = "", - .chain = stm32lx_exec_command_handlers, + .name = "stm32lx", + .mode = COMMAND_ANY, + .help = "stm32lx flash command group", + .usage = "", + .chain = stm32lx_exec_command_handlers, }, COMMAND_REGISTRATION_DONE }; struct flash_driver stm32lx_flash = { - .name = "stm32lx", - .commands = stm32lx_command_handlers, - .flash_bank_command = stm32lx_flash_bank_command, - .erase = stm32lx_erase, - .protect = stm32lx_protect, - .write = stm32lx_write, - .read = default_flash_read, - .probe = stm32lx_probe, - .auto_probe = stm32lx_auto_probe, - .erase_check = stm32lx_erase_check, - .protect_check = stm32lx_protect_check, - .info = stm32lx_get_info, + .name = "stm32lx", + .commands = stm32lx_command_handlers, + .flash_bank_command = stm32lx_flash_bank_command, + .erase = stm32lx_erase, + .protect = stm32lx_protect, + .write = stm32lx_write, + .read = default_flash_read, + .probe = stm32lx_probe, + .auto_probe = stm32lx_auto_probe, + .erase_check = stm32lx_erase_check, + .protect_check = stm32lx_protect_check, + .info = stm32lx_get_info, }; /* Static methods implementation */ @@ -883,53 +927,53 @@ static int stm32lx_unlock_program_memory(struct flash_bank *bank) /* check flash is not already unlocked */ retval = target_read_u32(target, stm32lx_info->flash_base + FLASH_PECR, - ®32); + ®32); if (retval != ERROR_OK) - return retval; + return retval; if ((reg32 & FLASH_PECR__PRGLOCK) == 0) - return ERROR_OK; + return ERROR_OK; /* To unlock the PECR write the 2 PEKEY to the PEKEYR register */ retval = target_write_u32(target, stm32lx_info->flash_base + FLASH_PEKEYR, - PEKEY1); + PEKEY1); if (retval != ERROR_OK) - return retval; + return retval; retval = target_write_u32(target, stm32lx_info->flash_base + FLASH_PEKEYR, - PEKEY2); + PEKEY2); if (retval != ERROR_OK) - return retval; + return retval; /* Make sure it worked */ retval = target_read_u32(target, stm32lx_info->flash_base + FLASH_PECR, - ®32); + ®32); if (retval != ERROR_OK) - return retval; + return retval; if (reg32 & FLASH_PECR__PELOCK) { - LOG_ERROR("PELOCK is not cleared :("); - return ERROR_FLASH_OPERATION_FAILED; + LOG_ERROR("PELOCK is not cleared :("); + return ERROR_FLASH_OPERATION_FAILED; } retval = target_write_u32(target, stm32lx_info->flash_base + FLASH_PRGKEYR, - PRGKEY1); + PRGKEY1); if (retval != ERROR_OK) - return retval; + return retval; retval = target_write_u32(target, stm32lx_info->flash_base + FLASH_PRGKEYR, - PRGKEY2); + PRGKEY2); if (retval != ERROR_OK) - return retval; + return retval; /* Make sure it worked */ retval = target_read_u32(target, stm32lx_info->flash_base + FLASH_PECR, - ®32); + ®32); if (retval != ERROR_OK) - return retval; + return retval; if (reg32 & FLASH_PECR__PRGLOCK) { - LOG_ERROR("PRGLOCK is not cleared :("); - return ERROR_FLASH_OPERATION_FAILED; + LOG_ERROR("PRGLOCK is not cleared :("); + return ERROR_FLASH_OPERATION_FAILED; } return ERROR_OK; @@ -947,27 +991,27 @@ static int stm32lx_enable_write_half_page(struct flash_bank *bank) */ retval = stm32lx_unlock_program_memory(bank); if (retval != ERROR_OK) - return retval; + return retval; retval = target_read_u32(target, stm32lx_info->flash_base + FLASH_PECR, - ®32); + ®32); if (retval != ERROR_OK) - return retval; + return retval; reg32 |= FLASH_PECR__FPRG; retval = target_write_u32(target, stm32lx_info->flash_base + FLASH_PECR, - reg32); + reg32); if (retval != ERROR_OK) - return retval; + return retval; retval = target_read_u32(target, stm32lx_info->flash_base + FLASH_PECR, - ®32); + ®32); if (retval != ERROR_OK) - return retval; + return retval; reg32 |= FLASH_PECR__PROG; retval = target_write_u32(target, stm32lx_info->flash_base + FLASH_PECR, - reg32); + reg32); return retval; } @@ -982,26 +1026,26 @@ static int stm32lx_lock_program_memory(struct flash_bank *bank) /* To lock the program memory, simply set the lock bit and lock PECR */ retval = target_read_u32(target, stm32lx_info->flash_base + FLASH_PECR, - ®32); + ®32); if (retval != ERROR_OK) - return retval; + return retval; reg32 |= FLASH_PECR__PRGLOCK; retval = target_write_u32(target, stm32lx_info->flash_base + FLASH_PECR, - reg32); + reg32); if (retval != ERROR_OK) - return retval; + return retval; retval = target_read_u32(target, stm32lx_info->flash_base + FLASH_PECR, - ®32); + ®32); if (retval != ERROR_OK) - return retval; + return retval; reg32 |= FLASH_PECR__PELOCK; retval = target_write_u32(target, stm32lx_info->flash_base + FLASH_PECR, - reg32); + reg32); if (retval != ERROR_OK) - return retval; + return retval; return ERROR_OK; } @@ -1021,38 +1065,47 @@ static int stm32lx_erase_sector(struct flash_bank *bank, int sector) retval = stm32lx_unlock_program_memory(bank); if (retval != ERROR_OK) - return retval; + return retval; for (int page = 0; page < (int)stm32lx_info->part_info->pages_per_sector; - page++) { - reg32 = FLASH_PECR__PROG | FLASH_PECR__ERASE; - retval = target_write_u32(target, - stm32lx_info->flash_base + FLASH_PECR, reg32); - if (retval != ERROR_OK) - return retval; - - retval = stm32lx_wait_until_bsy_clear(bank); - if (retval != ERROR_OK) - return retval; - - uint32_t addr = bank->base + bank->sectors[sector].offset + (page - * stm32lx_info->part_info->page_size); - retval = target_write_u32(target, addr, 0x0); - if (retval != ERROR_OK) - return retval; - - retval = stm32lx_wait_until_bsy_clear(bank); - if (retval != ERROR_OK) - return retval; + page++) { + reg32 = FLASH_PECR__PROG | FLASH_PECR__ERASE; + retval = target_write_u32(target, + stm32lx_info->flash_base + FLASH_PECR, reg32); + if (retval != ERROR_OK) + return retval; + + retval = stm32lx_wait_until_bsy_clear(bank); + if (retval != ERROR_OK) + return retval; + + uint32_t addr = bank->base + bank->sectors[sector].offset + (page + * stm32lx_info->part_info->page_size); + retval = target_write_u32(target, addr, 0x0); + if (retval != ERROR_OK) + return retval; + + retval = stm32lx_wait_until_bsy_clear(bank); + if (retval != ERROR_OK) + return retval; } retval = stm32lx_lock_program_memory(bank); if (retval != ERROR_OK) - return retval; + return retval; return ERROR_OK; } +static inline int stm32lx_get_flash_status(struct flash_bank *bank, uint32_t *status) +{ + struct target *target = bank->target; + struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv; + + return target_read_u32(target, stm32lx_info->flash_base + FLASH_SR, status); +} + + static int stm32lx_wait_until_bsy_clear(struct flash_bank *bank) { struct target *target = bank->target; @@ -1063,29 +1116,163 @@ static int stm32lx_wait_until_bsy_clear(struct flash_bank *bank) /* wait for busy to clear */ for (;;) { - retval = target_read_u32(target, stm32lx_info->flash_base + FLASH_SR, - &status); - if (retval != ERROR_OK) - return retval; - - if ((status & FLASH_SR__BSY) == 0) - break; - if (timeout-- <= 0) { - LOG_ERROR("timed out waiting for flash"); - return ERROR_FAIL; - } - alive_sleep(1); + retval = target_read_u32(target, stm32lx_info->flash_base + FLASH_SR, + &status); + if (retval != ERROR_OK) + return retval; + + if ((status & FLASH_SR__BSY) == 0) + break; + if (timeout-- <= 0) { + LOG_ERROR("timed out waiting for flash"); + return ERROR_FAIL; + } + alive_sleep(1); } if (status & FLASH_SR__WRPERR) { - LOG_ERROR("access denied / write protected"); - retval = ERROR_FAIL; + LOG_ERROR("access denied / write protected"); + retval = ERROR_FAIL; } if (status & FLASH_SR__PGAERR) { - LOG_ERROR("invalid program address"); - retval = ERROR_FAIL; + LOG_ERROR("invalid program address"); + retval = ERROR_FAIL; } return retval; } + +/* Static methods for mass erase stuff implementation */ +static int stm32lx_unlock_options_bytes(struct flash_bank *bank) +{ + struct target *target = bank->target; + struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv; + int retval; + uint32_t reg32; + + /* + * Unlocking the options bytes is done by unlocking the PECR, + * then by writing the 2 FLASH_PEKEYR to the FLASH_OPTKEYR register + */ + + /* check flash is not already unlocked */ + retval = target_read_u32(target, stm32lx_info->flash_base + FLASH_PECR, + ®32); + if (retval != ERROR_OK) + return retval; + + if ((reg32 & FLASH_PECR__OPTLOCK) == 0) + return ERROR_OK; + + if ((reg32 & FLASH_PECR__PELOCK) != 0) { + + retval = target_write_u32(target, stm32lx_info->flash_base + FLASH_PEKEYR, + PEKEY1); + if (retval != ERROR_OK) + return retval; + + retval = target_write_u32(target, stm32lx_info->flash_base + FLASH_PEKEYR, + PEKEY2); + if (retval != ERROR_OK) + return retval; + } + + /* To unlock the PECR write the 2 OPTKEY to the FLASH_OPTKEYR register */ + retval = target_write_u32(target, stm32lx_info->flash_base + FLASH_OPTKEYR, + OPTKEY1); + if (retval != ERROR_OK) + return retval; + + retval = target_write_u32(target, stm32lx_info->flash_base + FLASH_OPTKEYR, + OPTKEY2); + if (retval != ERROR_OK) + return retval; + + return ERROR_OK; +} + + +static int stm32lx_wait_status_busy(struct flash_bank *bank, int timeout) +{ + struct target *target = bank->target; + uint32_t status; + + int retval = ERROR_OK; + struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv; + + /* wait for busy to clear */ + for (;;) { + + retval = stm32lx_get_flash_status(bank, &status); + if (retval != ERROR_OK) + return retval; + + LOG_DEBUG("status: 0x%" PRIx32 "", status); + if ((status & FLASH_SR__BSY) == 0) + break; + + if (timeout-- <= 0) { + LOG_ERROR("timed out waiting for flash"); + return ERROR_FAIL; + } + alive_sleep(1); + } + + if (status & FLASH_SR__WRPERR) { + LOG_ERROR("stm32lx device protected"); + retval = ERROR_FAIL; + } + + /* Clear but report errors */ + if (status & FLASH_SR__OPTVERR) { + /* If this operation fails, we ignore it and report the original + * retval + */ + target_write_u32(target, stm32lx_info->flash_base + FLASH_SR, status & FLASH_SR__OPTVERR); + } + return retval; +} + + +static int stm32lx_mass_erase(struct flash_bank *bank) +{ + int retval; + struct target *target = bank->target; + struct stm32lx_flash_bank *stm32lx_info = NULL; + uint32_t reg32; + + if (target->state != TARGET_HALTED) { + LOG_ERROR("Target not halted"); + return ERROR_TARGET_NOT_HALTED; + } + + stm32lx_info = bank->driver_priv; + + retval = stm32lx_unlock_options_bytes(bank); + if (retval != ERROR_OK) + return retval; + + /* mass erase flash memory , write 0x015500AA option byte address 0*/ + /* pass the RDP privilege to 1 */ + retval = target_write_u32(target, OPTION_BYTES_ADDRESS, OPTION_BYTE_0_PR1); + + /* restore the RDP privilege to 0 */ + retval = target_write_u32(target, OPTION_BYTES_ADDRESS, 0x01FF0011); + + /* the mass erase occur when the privilege go back to 0 */ + retval = stm32lx_wait_status_busy(bank, 30000); + if (retval != ERROR_OK) + return retval; + + retval = target_read_u32(target, stm32lx_info->flash_base + FLASH_PECR, + ®32); + if (retval != ERROR_OK) + return retval; + + retval = target_write_u32(target, stm32lx_info->flash_base + FLASH_PECR, reg32 | FLASH_PECR__OPTLOCK); + if (retval != ERROR_OK) + return retval; + + return ERROR_OK; +} -- ------------------------------------------------------------------------------ Meet PCI DSS 3.0 Compliance Requirements with EventLog Analyzer Achieve PCI DSS 3.0 Compliant Status with Out-of-the-box PCI DSS Reports Are you Audit-Ready for PCI DSS 3.0 Compliance? Download White paper Comply to PCI DSS 3.0 Requirement 10 and 11.5 with EventLog Analyzer http://pubads.g.doubleclick.net/gampad/clk?id=154622311&iu=/4140/ostg.clktrk _______________________________________________ OpenOCD-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/openocd-devel
