Doxygen file comments

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

diff --git a/src/flash/nor/core.c b/src/flash/nor/core.c
index 67fd78bf74fe45016e596334b3c07ed1fa2ebecd..9083ed15ef92a95dda02aa4f0d9362922c2b4905 100644 (file)
--- a/src/flash/nor/core.c
+++ b/src/flash/nor/core.c
@@ -29,6 +29,13 @@
 #include <target/image.h>
 
 
+/**
+ * @file
+ * Upper level of NOR flash framework.
+ * The lower level interfaces are to drivers.  These upper level ones
+ * primarily support access from Tcl scripts or from GDB.
+ */
+
 struct flash_bank *flash_banks;
 
 int flash_driver_erase(struct flash_bank *bank, int first, int last)
@@ -316,6 +323,7 @@ static int flash_iterate_address_range(struct target *target,
        /** @todo: handle erasures that cross into adjacent banks */
 
        addr -= c->base;
+       last_addr -= c->base;
 
        for (i = 0; i < c->num_sectors; i++)
        {
@@ -401,7 +409,7 @@ int flash_write_unlock(struct target *target, struct image *image,
        }
 
        /* allocate padding array */
-       padding = malloc(image->num_sections * sizeof(padding));
+       padding = calloc(image->num_sections, sizeof(*padding));
 
        /* loop until we reach end of the image */
        while (section < image->num_sections)
@@ -439,9 +447,29 @@ int flash_write_unlock(struct target *target, struct image *image,
                {
                        if (image->sections[section_last + 1].base_address < (run_address + run_size))
                        {
-                               LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
+                               LOG_DEBUG("section %d out of order "
+                                               "(surprising, but supported)",
+                                               section_last + 1);
+                               /* REVISIT this can break with autoerase ...
+                                * clobbering data after it's written.
+                                */
                                break;
                        }
+
+                       /* FIXME This needlessly touches sectors BETWEEN the
+                        * sections it's writing.  Without auto erase, it just
+                        * writes ones.  That WILL INVALIDATE data in cases
+                        * like Stellaris Tempest chips, corrupting internal
+                        * ECC codes; and at least FreeScale suggests issues
+                        * with that approach (in HC11 documentation).
+                        *
+                        * With auto erase enabled, data in those sectors will
+                        * be needlessly destroyed; and some of the limited
+                        * number of flash erase cycles will be wasted...
+                        *
+                        * In both cases, the extra writes slow things down.
+                        */
+
                        /* 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 = (image->sections[section_last + 1].base_address) - (run_address + run_size);
@@ -450,7 +478,6 @@ int flash_write_unlock(struct target *target, struct image *image,
                        padding[section_last] = pad_bytes;
                        run_size += image->sections[++section_last].size;
                        run_size += pad_bytes;
-                       padding[section_last] = 0;
 
                        LOG_INFO("Padding image section %d with %d bytes", section_last-1, pad_bytes);
                }
@@ -458,11 +485,35 @@ int flash_write_unlock(struct target *target, struct image *image,
                /* fit the run into bank constraints */
                if (run_address + run_size - 1 > c->base + c->size - 1)
                {
+                       /* REVISIT isn't this superfluous, given the while()
+                        * loop conditions above??
+                        */
                        LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
                                    (int)(c->base + c->size - run_address), (int)(run_size), (int)(c->size));
                        run_size = c->base + c->size - run_address;
                }
 
+               /* If we're applying any sector automagic, then pad this
+                * (maybe-combined) segment to the end of its last sector.
+                */
+               if (unlock || erase) {
+                       int sector;
+                       uint32_t offset_start = run_address - c->base;
+                       uint32_t offset_end = offset_start + run_size;
+                       uint32_t end = offset_end, delta;
+
+                       for (sector = 0; sector < c->num_sectors; sector++) {
+                               end = c->sectors[sector].offset
+                                               + c->sectors[sector].size;
+                               if (offset_end <= end)
+                                       break;
+                       }
+
+                       delta = end - offset_end;
+                       padding[section_last] += delta;
+                       run_size += delta;
+               }
+
                /* allocate buffer */
                buffer = malloc(run_size);
                buffer_size = 0;