static int stm32lx_wait_until_bsy_clear(struct flash_bank *bank);
struct stm32lx_flash_bank {
- struct working_area *write_algorithm;
int probed;
};
bank->driver_priv = stm32lx_info;
- stm32lx_info->write_algorithm = NULL;
stm32lx_info->probed = 0;
return ERROR_OK;
static int stm32lx_write_half_pages(struct flash_bank *bank, uint8_t *buffer,
uint32_t offset, uint32_t count)
{
- struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv;
struct target *target = bank->target;
uint32_t buffer_size = 4096 * 4;
+ struct working_area *write_algorithm;
struct working_area *source;
uint32_t address = bank->base + offset;
/* Add bytes to make 4byte aligned */
reg32 += (4 - (reg32 % 4)) % 4;
retval = target_alloc_working_area(target, reg32,
- &stm32lx_info->write_algorithm);
+ &write_algorithm);
if (retval != ERROR_OK)
return retval;
/* Write the flashing code */
retval = target_write_buffer(target,
- stm32lx_info->write_algorithm->address,
+ write_algorithm->address,
sizeof(stm32lx_flash_write_code),
(uint8_t *)stm32lx_flash_write_code);
if (retval != ERROR_OK) {
- target_free_working_area(target, stm32lx_info->write_algorithm);
+ target_free_working_area(target, write_algorithm);
return retval;
}
buffer_size /= 2;
if (buffer_size <= 256) {
- /* if we already allocated the writing code, but failed to get a
+ /* we already allocated the writing code, but failed to get a
* buffer, free the algorithm */
- if (stm32lx_info->write_algorithm)
- target_free_working_area(target, stm32lx_info->write_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;
retval = stm32lx_enable_write_half_page(bank);
if (retval != ERROR_OK) {
target_free_working_area(target, source);
- target_free_working_area(target, stm32lx_info->write_algorithm);
+ target_free_working_area(target, write_algorithm);
destroy_reg_param(®_params[0]);
destroy_reg_param(®_params[1]);
/* 5: Execute the bunch of code */
retval = target_run_algorithm(target, 0, NULL, sizeof(reg_params)
/ sizeof(*reg_params), reg_params,
- stm32lx_info->write_algorithm->address, 0, 20000, &armv7m_info);
+ write_algorithm->address, 0, 20000, &armv7m_info);
if (retval != ERROR_OK)
break;
retval = stm32lx_lock_program_memory(bank);
target_free_working_area(target, source);
- target_free_working_area(target, stm32lx_info->write_algorithm);
+ target_free_working_area(target, write_algorithm);
destroy_reg_param(®_params[0]);
destroy_reg_param(®_params[1]);
uint32_t bytes_written = 0;
int retval;
+ uint8_t *start = buffer;
+ uint32_t start_address = address;
+ uint32_t start_count = count;
+ uint8_t *validate;
+ uint32_t check;
+
if (bank->target->state != TARGET_HALTED) {
LOG_ERROR("Target not halted");
return ERROR_TARGET_NOT_HALTED;
if (retval != ERROR_OK)
return retval;
- return ERROR_OK;
+ validate = malloc (start_count);
+
+ retval = target_read_buffer(target, start_address, start_count, validate);
+ if (retval != ERROR_OK) {
+ free (validate);
+ return retval;
+ }
+
+ for (check = 0; check < start_count; check++) {
+ if (validate[check] != start[check]) {
+ LOG_ERROR ("flash corrupted at 0x%08x (%02x != %02x)\n",
+ start_address + check, start[check], validate[check]);
+ retval = ERROR_FAIL;
+ break;
+ }
+ }
+
+ free (validate);
+
+ return retval;
}
static int stm32lx_probe(struct flash_bank *bank)
struct stm32lx_flash_bank *stm32lx_info = bank->driver_priv;
int i;
uint16_t flash_size_in_kb;
+ uint16_t max_flash_size_in_kb;
uint32_t device_id;
stm32lx_info->probed = 0;
LOG_DEBUG("device id = 0x%08" PRIx32 "", device_id);
- /* get flash size from target. */
- retval = target_read_u16(target, F_SIZE, &flash_size_in_kb);
- if (retval != ERROR_OK) {
- LOG_WARNING("failed reading flash size, default to max target family");
- /* failed reading flash size, default to max target family */
- flash_size_in_kb = 0xffff;
+ /* set max flash size depending on family */
+ switch (device_id & 0xfff) {
+ case 0x416:
+ max_flash_size_in_kb = 128;
+ break;
+ case 0x436:
+ max_flash_size_in_kb = 384;
+ break;
+ default:
+ LOG_WARNING("Cannot identify target as a STM32L family.");
+ return ERROR_FAIL;
}
- /* some variants read 0 for flash size register
- * use a max flash size as a default */
- if (flash_size_in_kb == 0)
- flash_size_in_kb = 0xffff;
+ /* get flash size from target. */
+ retval = target_read_u16(target, F_SIZE, &flash_size_in_kb);
- if ((device_id & 0xfff) == 0x416) {
- /* check for early silicon */
- if (flash_size_in_kb == 0xffff) {
- /* number of sectors may be incorrrect on early silicon */
- LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 128k flash");
- flash_size_in_kb = 128;
- }
- } else if ((device_id & 0xfff) == 0x436) {
- /* check for early silicon */
- if (flash_size_in_kb == 0xffff) {
- /* number of sectors may be incorrrect on early silicon */
- LOG_WARNING("STM32 flash size failed, probe inaccurate - assuming 384k flash");
- flash_size_in_kb = 384;
- }
- } else {
- LOG_WARNING("Cannot identify target as a STM32L family.");
- return ERROR_FAIL;
+ /* 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("STM32 flash size failed, probe inaccurate - assuming %dk flash",
+ max_flash_size_in_kb);
+ flash_size_in_kb = max_flash_size_in_kb;
}
/* STM32L - we have 32 sectors, 16 pages per sector -> 512 pages
projects / fw / openocd / blobdiff