target, flash: prepare infrastructure for multi-block blank check

[openocd.git] / src / flash / nor / core.c

diff --git a/src/flash/nor/core.c b/src/flash/nor/core.c
index ab69a328bd8497ed3ad41dc29d7ee2e6e9e9accd..707dcff181a21e0bfa6a48648cf3480e253a7c4b 100644 (file)
--- a/src/flash/nor/core.c
+++ b/src/flash/nor/core.c
@@ -171,6 +171,31 @@ int flash_get_bank_count(void)
        return i;
 }
 
+void default_flash_free_driver_priv(struct flash_bank *bank)
+{
+       free(bank->driver_priv);
+       bank->driver_priv = NULL;
+}
+
+void flash_free_all_banks(void)
+{
+       struct flash_bank *bank = flash_banks;
+       while (bank) {
+               struct flash_bank *next = bank->next;
+               if (bank->driver->free_driver_priv)
+                       bank->driver->free_driver_priv(bank);
+               else
+                       LOG_WARNING("Flash driver of %s does not support free_driver_priv()", bank->name);
+
+               free(bank->name);
+               free(bank->sectors);
+               free(bank->prot_blocks);
+               free(bank);
+               bank = next;
+       }
+       flash_banks = NULL;
+}
+
 struct flash_bank *get_flash_bank_by_name_noprobe(const char *name)
 {
        unsigned requested = get_flash_name_index(name);
@@ -314,36 +339,49 @@ int default_flash_blank_check(struct flash_bank *bank)
        struct target *target = bank->target;
        int i;
        int retval;
-       int fast_check = 0;
-       uint32_t blank;
 
        if (bank->target->state != TARGET_HALTED) {
                LOG_ERROR("Target not halted");
                return ERROR_TARGET_NOT_HALTED;
        }
 
+       struct target_memory_check_block *block_array;
+       block_array = malloc(bank->num_sectors * sizeof(struct target_memory_check_block));
+       if (block_array == NULL)
+               return default_flash_mem_blank_check(bank);
+
        for (i = 0; i < bank->num_sectors; i++) {
-               uint32_t address = bank->base + bank->sectors[i].offset;
-               uint32_t size = bank->sectors[i].size;
+               block_array[i].address = bank->base + bank->sectors[i].offset;
+               block_array[i].size = bank->sectors[i].size;
+               block_array[i].result = UINT32_MAX; /* erase state unknown */
+       }
 
-               retval = target_blank_check_memory(target, address, size, &blank, bank->erased_value);
-               if (retval != ERROR_OK) {
-                       fast_check = 0;
+       bool fast_check = true;
+       for (i = 0; i < bank->num_sectors; ) {
+               retval = target_blank_check_memory(target,
+                               block_array + i, bank->num_sectors - i,
+                               bank->erased_value);
+               if (retval < 1) {
+                       /* Run slow fallback if the first run gives no result
+                        * otherwise use possibly incomplete results */
+                       if (i == 0)
+                               fast_check = false;
                        break;
                }
-               if (blank == bank->erased_value)
-                       bank->sectors[i].is_erased = 1;
-               else
-                       bank->sectors[i].is_erased = 0;
-               fast_check = 1;
+               i += retval; /* add number of blocks done this round */
        }
 
-       if (!fast_check) {
+       if (fast_check) {
+               for (i = 0; i < bank->num_sectors; i++)
+                       bank->sectors[i].is_erased = block_array[i].result;
+               retval = ERROR_OK;
+       } else {
                LOG_USER("Running slow fallback erase check - add working memory");
-               return default_flash_mem_blank_check(bank);
+               retval = default_flash_mem_blank_check(bank);
        }
+       free(block_array);
 
-       return ERROR_OK;
+       return retval;
 }
 
 /* Manipulate given flash region, selecting the bank according to target
@@ -399,18 +437,21 @@ static int flash_iterate_address_range_inner(struct target *target,
                return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
        }
 
-       addr -= c->base;
-       last_addr -= c->base;
+       if (c->prot_blocks == NULL || c->num_prot_blocks == 0) {
+               /* flash driver does not define protect blocks, use sectors instead */
+               iterate_protect_blocks = false;
+       }
 
-       if (iterate_protect_blocks && c->prot_blocks && c->num_prot_blocks) {
+       if (iterate_protect_blocks) {
                block_array = c->prot_blocks;
                num_blocks = c->num_prot_blocks;
        } else {
                block_array = c->sectors;
                num_blocks = c->num_sectors;
-               iterate_protect_blocks = false;
        }
 
+       addr -= c->base;
+       last_addr -= c->base;
 
        for (i = 0; i < num_blocks; i++) {
                struct flash_sector *f = &block_array[i];
@@ -601,7 +642,7 @@ int flash_write_unlock(struct target *target, struct image *image,
                uint32_t buffer_size;
                uint8_t *buffer;
                int section_last;
-               uint32_t run_address = sections[section]->base_address + section_offset;
+               target_addr_t run_address = sections[section]->base_address + section_offset;
                uint32_t run_size = sections[section]->size - section_offset;
                int pad_bytes = 0;
 
@@ -617,7 +658,7 @@ int flash_write_unlock(struct target *target, struct image *image,
                if (retval != ERROR_OK)
                        goto done;
                if (c == NULL) {
-                       LOG_WARNING("no flash bank found for address %" PRIx32, run_address);
+                       LOG_WARNING("no flash bank found for address " TARGET_ADDR_FMT, run_address);
                        section++;      /* and skip it */
                        section_offset = 0;
                        continue;
@@ -652,7 +693,18 @@ int flash_write_unlock(struct target *target, struct image *image,
                        /* if we have multiple sections within our image,
                         * flash programming could fail due to alignment issues
                         * attempt to rebuild a consecutive buffer for the flash loader */
-                       pad_bytes = (sections[section_last + 1]->base_address) - (run_address + run_size);
+                       target_addr_t run_next_addr = run_address + run_size;
+                       if (sections[section_last + 1]->base_address < run_next_addr) {
+                               LOG_ERROR("Section at " TARGET_ADDR_FMT
+                                       " overlaps section ending at " TARGET_ADDR_FMT,
+                                       sections[section_last + 1]->base_address,
+                                       run_next_addr);
+                               LOG_ERROR("Flash write aborted.");
+                               retval = ERROR_FAIL;
+                               goto done;
+                       }
+
+                       pad_bytes = sections[section_last + 1]->base_address - run_next_addr;
                        padding[section_last] = pad_bytes;
                        run_size += sections[++section_last]->size;
                        run_size += pad_bytes;