Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
- Fixes '[|]' whitespace
[openocd.git] / src / flash / flash.c
diff --git a/src/flash/flash.c b/src/flash/flash.c
index fb9fa698b0b72d25015e86b2139e42777b57f8c9..a850ced94fa5f2ae163c0d48577d46573eae937e 100644 (file)
--- a/src/flash/flash.c
+++ b/src/flash/flash.c
@@ -28,46 +28,27 @@
 #endif
 
 #include "flash.h"
-#include "command.h"
-#include "target.h"
-#include "time_support.h"
-#include "fileio.h"
 #include "image.h"
-#include "log.h"
-#include "armv4_5.h"
-#include "algorithm.h"
-#include "binarybuffer.h"
-#include "armv7m.h"
-
-#include <string.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <errno.h>
-#include <inttypes.h>
+#include "time_support.h"
 
 /* command handlers */
-int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_flash_write_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr);
+static int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 
 /* flash drivers
  */
 extern flash_driver_t lpc2000_flash;
 extern flash_driver_t cfi_flash;
 extern flash_driver_t at91sam7_flash;
-extern flash_driver_t at91sam7_old_flash;
 extern flash_driver_t str7x_flash;
 extern flash_driver_t str9x_flash;
 extern flash_driver_t aduc702x_flash;
@@ -78,12 +59,13 @@ extern flash_driver_t tms470_flash;
 extern flash_driver_t ecosflash_flash;
 extern flash_driver_t lpc288x_flash;
 extern flash_driver_t ocl_flash;
+extern flash_driver_t pic32mx_flash;
+extern flash_driver_t avr_flash;
 
 flash_driver_t *flash_drivers[] = {
        &lpc2000_flash,
        &cfi_flash,
        &at91sam7_flash,
-       &at91sam7_old_flash,
        &str7x_flash,
        &str9x_flash,
        &aduc702x_flash,
@@ -94,6 +76,8 @@ flash_driver_t *flash_drivers[] = {
        &ecosflash_flash,
        &lpc288x_flash,
        &ocl_flash,
+       &pic32mx_flash,
+       &avr_flash,
        NULL,
 };
 
@@ -101,14 +85,15 @@ flash_bank_t *flash_banks;
 static         command_t *flash_cmd;
 
 /* wafer thin wrapper for invoking the flash driver */
-static int flash_driver_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
+static int flash_driver_write(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
 {
        int retval;
 
-       retval=bank->driver->write(bank, buffer, offset, count);
-       if (retval!=ERROR_OK)
+       retval = bank->driver->write(bank, buffer, offset, count);
+       if (retval != ERROR_OK)
        {
-               LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank->base, offset, retval);
+               LOG_ERROR("error writing to flash at address 0x%08" PRIx32 " at offset 0x%8.8" PRIx32 " (%d)", 
+                         bank->base, offset, retval);
        }
 
        return retval;
@@ -118,8 +103,8 @@ static int flash_driver_erase(struct flash_bank_s *bank, int first, int last)
 {
        int retval;
 
-       retval=bank->driver->erase(bank, first, last);
-       if (retval!=ERROR_OK)
+       retval = bank->driver->erase(bank, first, last);
+       if (retval != ERROR_OK)
        {
                LOG_ERROR("failed erasing sectors %d to %d (%d)", first, last, retval);
        }
@@ -131,8 +116,8 @@ int flash_driver_protect(struct flash_bank_s *bank, int set, int first, int last
 {
        int retval;
 
-       retval=bank->driver->protect(bank, set, first, last);
-       if (retval!=ERROR_OK)
+       retval = bank->driver->protect(bank, set, first, last);
+       if (retval != ERROR_OK)
        {
                LOG_ERROR("failed setting protection for areas %d to %d (%d)", first, last, retval);
        }
@@ -144,7 +129,7 @@ int flash_register_commands(struct command_context_s *cmd_ctx)
 {
        flash_cmd = register_command(cmd_ctx, NULL, "flash", NULL, COMMAND_ANY, NULL);
 
-       register_command(cmd_ctx, flash_cmd, "bank", handle_flash_bank_command, COMMAND_CONFIG, "flash_bank <driver> <base> <size> <chip_width> <bus_width> <target> [driver_options ...]");
+       register_command(cmd_ctx, flash_cmd, "bank", handle_flash_bank_command, COMMAND_CONFIG, "flash bank <driver> <base> <size> <chip_width> <bus_width> <target> [driver_options ...]");
        return ERROR_OK;
 }
 
@@ -157,15 +142,10 @@ static int jim_flash_banks(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
                return JIM_ERR;
        }
 
-       if (!flash_banks)
-       {
-               return JIM_ERR;
-       }
-
-       Jim_Obj *list=Jim_NewListObj(interp, NULL, 0);
+       Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
        for (p = flash_banks; p; p = p->next)
        {
-               Jim_Obj *elem=Jim_NewListObj(interp, NULL, 0);
+               Jim_Obj *elem = Jim_NewListObj(interp, NULL, 0);
 
                Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "name", -1));
                Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, p->driver->name, -1));
@@ -188,10 +168,10 @@ static int jim_flash_banks(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 
 int flash_init_drivers(struct command_context_s *cmd_ctx)
 {
+       register_jim(cmd_ctx, "ocd_flash_banks", jim_flash_banks, "return information about the flash banks");
+
        if (flash_banks)
        {
-               register_jim(cmd_ctx, "ocd_flash_banks", jim_flash_banks, "return information about the flash banks");
-
                register_command(cmd_ctx, flash_cmd, "info", handle_flash_info_command, COMMAND_EXEC,
                                                 "print info about flash bank <num>");
                register_command(cmd_ctx, flash_cmd, "probe", handle_flash_probe_command, COMMAND_EXEC,
@@ -217,7 +197,7 @@ int flash_init_drivers(struct command_context_s *cmd_ctx)
                register_command(cmd_ctx, flash_cmd, "write_image", handle_flash_write_image_command, COMMAND_EXEC,
                                                 "write_image [erase] <file> [offset] [type]");
                register_command(cmd_ctx, flash_cmd, "protect", handle_flash_protect_command, COMMAND_EXEC,
-                                                "set protection of sectors at <bank> <first> <last> <on|off>");
+                                                "set protection of sectors at <bank> <first> <last> <on | off>");
        }
 
        return ERROR_OK;
@@ -268,7 +248,7 @@ flash_bank_t *get_flash_bank_by_num(int num)
        return p;
 }
 
-int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        int retval;
        int i;
@@ -280,9 +260,9 @@ int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
-       if ((target = get_target_by_num(strtoul(args[5], NULL, 0))) == NULL)
+       if ((target = get_target(args[5])) == NULL)
        {
-               LOG_ERROR("target %lu not defined", strtoul(args[5], NULL, 0));
+               LOG_ERROR("target '%s' not defined", args[5]);
                return ERROR_FAIL;
        }
 
@@ -311,9 +291,9 @@ int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char
                        c->sectors = NULL;
                        c->next = NULL;
 
-                       if ((retval=flash_drivers[i]->flash_bank_command(cmd_ctx, cmd, args, argc, c)) != ERROR_OK)
+                       if ((retval = flash_drivers[i]->flash_bank_command(cmd_ctx, cmd, args, argc, c)) != ERROR_OK)
                        {
-                               LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args[0], c->base);
+                               LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32 , args[0], c->base);
                                free(c);
                                return retval;
                        }
@@ -321,14 +301,17 @@ int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char
                        /* put flash bank in linked list */
                        if (flash_banks)
                        {
+                               int     bank_num = 0;
                                /* find last flash bank */
-                               for (p = flash_banks; p && p->next; p = p->next);
+                               for (p = flash_banks; p && p->next; p = p->next) bank_num++;
                                if (p)
                                        p->next = c;
+                               c->bank_number = bank_num + 1;
                        }
                        else
                        {
                                flash_banks = c;
+                               c->bank_number = 0;
                        }
 
                        found = 1;
@@ -345,10 +328,10 @@ int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char
        return ERROR_OK;
 }
 
-int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        flash_bank_t *p;
-       int i = 0;
+       uint32_t i = 0;
        int j = 0;
        int retval;
 
@@ -367,8 +350,14 @@ int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char
                        if ((retval = p->driver->auto_probe(p)) != ERROR_OK)
                                return retval;
 
-                       command_print(cmd_ctx, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
-                                               i, p->driver->name, p->base, p->size, p->bus_width, p->chip_width);
+                       command_print(cmd_ctx, 
+                                     "#%" PRIi32 " : %s at 0x%8.8" PRIx32 ", size 0x%8.8" PRIx32 ", buswidth %i, chipwidth %i",
+                                     i,
+                                     p->driver->name, 
+                                     p->base, 
+                                     p->size, 
+                                     p->bus_width, 
+                                     p->chip_width);
                        for (j = 0; j < p->num_sectors; j++)
                        {
                                char *protect_state;
@@ -380,9 +369,13 @@ int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char
                                else
                                        protect_state = "protection state unknown";
 
-                               command_print(cmd_ctx, "\t#%3i: 0x%8.8x (0x%x %ikB) %s",
-                                                       j, p->sectors[j].offset, p->sectors[j].size, p->sectors[j].size>>10,
-                                                       protect_state);
+                               command_print(cmd_ctx, 
+                                             "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
+                                             j,
+                                             p->sectors[j].offset, 
+                                             p->sectors[j].size, 
+                                             p->sectors[j].size >> 10,
+                                             protect_state);
                        }
 
                        *buf = '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
@@ -396,7 +389,7 @@ int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char
        return ERROR_OK;
 }
 
-int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        flash_bank_t *p;
        int retval;
@@ -411,16 +404,16 @@ int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, cha
        {
                if ((retval = p->driver->probe(p)) == ERROR_OK)
                {
-                       command_print(cmd_ctx, "flash '%s' found at 0x%8.8x", p->driver->name, p->base);
+                       command_print(cmd_ctx, "flash '%s' found at 0x%8.8" PRIx32, p->driver->name, p->base);
                }
                else if (retval == ERROR_FLASH_BANK_INVALID)
                {
-                       command_print(cmd_ctx, "probing failed for flash bank '#%s' at 0x%8.8x",
+                       command_print(cmd_ctx, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32,
                                                  args[0], p->base);
                }
                else
                {
-                       command_print(cmd_ctx, "unknown error when probing flash bank '#%s' at 0x%8.8x",
+                       command_print(cmd_ctx, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32,
                                                  args[0], p->base);
                }
        }
@@ -432,7 +425,7 @@ int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, cha
        return ERROR_OK;
 }
 
-int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        flash_bank_t *p;
        int retval;
@@ -448,11 +441,11 @@ int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cm
                int j;
                if ((retval = p->driver->erase_check(p)) == ERROR_OK)
                {
-                       command_print(cmd_ctx, "successfully checked erase state", p->driver->name, p->base);
+                       command_print(cmd_ctx, "successfully checked erase state");
                }
                else
                {
-                       command_print(cmd_ctx, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
+                       command_print(cmd_ctx, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32,
                                args[0], p->base);
                }
 
@@ -467,17 +460,20 @@ int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cm
                        else
                                erase_state = "erase state unknown";
 
-                       command_print(cmd_ctx, "\t#%3i: 0x%8.8x (0x%x %ikB) %s",
-                                               j, p->sectors[j].offset, p->sectors[j].size, p->sectors[j].size>>10,
-                                               erase_state);
+                       command_print(cmd_ctx,
+                                     "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
+                                     j, 
+                                     p->sectors[j].offset, 
+                                     p->sectors[j].size, 
+                                     p->sectors[j].size >> 10,
+                                     erase_state);
                }
-
        }
 
        return ERROR_OK;
 }
 
-int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        flash_bank_t *p;
        int retval;
@@ -525,7 +521,7 @@ int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *
        return retval;
 }
 
-int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        flash_bank_t *p;
        int retval;
@@ -544,11 +540,11 @@ int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *
                }
                else if (retval == ERROR_FLASH_OPERATION_FAILED)
                {
-                       command_print(cmd_ctx, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args[0], p->base);
+                       command_print(cmd_ctx, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32, args[0], p->base);
                }
                else
                {
-                       command_print(cmd_ctx, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args[0], p->base);
+                       command_print(cmd_ctx, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32, args[0], p->base);
                }
        }
        else
@@ -559,7 +555,7 @@ int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *
        return ERROR_OK;
 }
 
-int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        if (argc > 2)
        {
@@ -584,7 +580,8 @@ int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, cha
                                return retval;
                        }
 
-                       command_print(cmd_ctx, "erased sectors %i through %i on flash bank %i in %s", first, last, strtoul(args[0], 0, 0), duration_text);
+                       command_print(cmd_ctx, "erased sectors %i through %i on flash bank %li in %s",
+                               first, last, strtoul(args[0], 0, 0), duration_text);
                        free(duration_text);
                }
        }
@@ -596,7 +593,7 @@ int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, cha
        return ERROR_OK;
 }
 
-int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        if (argc > 3)
        {
@@ -623,7 +620,9 @@ int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, c
                retval = flash_driver_protect(p, set, first, last);
                if (retval == ERROR_OK)
                {
-                       command_print(cmd_ctx, "%s protection for sectors %i through %i on flash bank %i", (set) ? "set" : "cleared", first, last, strtoul(args[0], 0, 0));
+                       command_print(cmd_ctx, "%s protection for sectors %i through %i on flash bank %li",
+                               (set) ? "set" : "cleared", first,
+                               last, strtoul(args[0], 0, 0));
                }
        }
        else
@@ -635,12 +634,12 @@ int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, c
        return ERROR_OK;
 }
 
-int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        target_t *target = get_current_target(cmd_ctx);
 
        image_t image;
-       u32 written;
+       uint32_t written;
 
        duration_t duration;
        char *duration_text;
@@ -655,7 +654,7 @@ int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cm
        /* flash auto-erase is disabled by default*/
        int auto_erase = 0;
 
-       if (strcmp(args[0], "erase")==0)
+       if (strcmp(args[0], "erase") == 0)
        {
                auto_erase = 1;
                args++;
@@ -663,7 +662,6 @@ int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cm
                command_print(cmd_ctx, "auto erase enabled");
        }
 
-
        if (argc < 1)
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
@@ -710,9 +708,12 @@ int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cm
        }
        if (retval == ERROR_OK)
        {
-               command_print(cmd_ctx, "wrote %u byte from file %s in %s (%f kb/s)",
-                               written, args[0], duration_text,
-                               (float)written / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
+               command_print(cmd_ctx, 
+                                         "wrote %" PRIu32 " byte from file %s in %s (%f kb/s)",
+                                         written,
+                                         args[0], 
+                                         duration_text,
+                                         (float)written / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
        }
        free(duration_text);
 
@@ -721,20 +722,22 @@ int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cm
        return retval;
 }
 
-int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        int err = ERROR_OK, retval;
-       u32 address;
-       u32 pattern;
-       u32 count;
-       u8 chunk[1024];
-       u32 wrote = 0;
-       int chunk_count;
+       uint32_t address;
+       uint32_t pattern;
+       uint32_t count;
+       uint8_t chunk[1024];
+       uint8_t readback[1024];
+       uint32_t wrote = 0;
+       uint32_t cur_size = 0;
+       uint32_t chunk_count;
        char *duration_text;
        duration_t duration;
        target_t *target = get_current_target(cmd_ctx);
-       u32 i;
-       int wordsize;
+       uint32_t i;
+       uint32_t wordsize;
 
        if (argc != 3)
        {
@@ -745,36 +748,35 @@ int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char
        pattern = strtoul(args[1], NULL, 0);
        count   = strtoul(args[2], NULL, 0);
 
-       if(count == 0)
+       if (count == 0)
                return ERROR_OK;
 
-
-       switch(cmd[4])
+       switch (cmd[4])
        {
        case 'w':
-               wordsize=4;
+               wordsize = 4;
                break;
        case 'h':
-               wordsize=2;
+               wordsize = 2;
                break;
        case 'b':
-               wordsize=1;
+               wordsize = 1;
                break;
        default:
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
 
        chunk_count = MIN(count, (1024 / wordsize));
-       switch(wordsize)
+       switch (wordsize)
        {
        case 4:
-               for(i = 0; i < chunk_count; i++)
+               for (i = 0; i < chunk_count; i++)
                {
                        target_buffer_set_u32(target, chunk + i * wordsize, pattern);
                }
                break;
        case 2:
-               for(i = 0; i < chunk_count; i++)
+               for (i = 0; i < chunk_count; i++)
                {
                        target_buffer_set_u16(target, chunk + i * wordsize, pattern);
                }
@@ -789,23 +791,34 @@ int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char
 
        duration_start_measure(&duration);
 
-       for (wrote=0; wrote<(count*wordsize); wrote+=sizeof(chunk))
+       for (wrote = 0; wrote<(count*wordsize); wrote += cur_size)
        {
-               int cur_size = MIN( (count*wordsize - wrote) , 1024 );
-               if (err == ERROR_OK)
+               cur_size = MIN( (count*wordsize - wrote), sizeof(chunk) );
+               flash_bank_t *bank;
+               bank = get_flash_bank_by_addr(target, address);
+               if (bank == NULL)
                {
-                       flash_bank_t *bank;
-                       bank = get_flash_bank_by_addr(target, address);
-                       if(bank == NULL)
+                       return ERROR_FAIL;
+               }
+               err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
+               if (err != ERROR_OK)
+                       return err;
+
+               err = target_read_buffer(target, address + wrote, cur_size, readback);
+               if (err != ERROR_OK)
+                       return err;
+
+               unsigned i;
+               for (i = 0; i<cur_size; i++)
+               {
+                       if (readback[i]!=chunk[i])
                        {
-                               err = ERROR_FAIL;
-                               break;
+                               LOG_ERROR("Verfication error address 0x%08" PRIx32 ", read back 0x%02x, expected 0x%02x", 
+                                                 address + wrote + i, readback[i], chunk[i]);
+                               return ERROR_FAIL;
                        }
-                       err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
-                       wrote += cur_size;
                }
-               if (err!=ERROR_OK)
-                       break;
+
        }
 
        if ((retval = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
@@ -813,25 +826,27 @@ int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char
                return retval;
        }
 
-
-       if(err == ERROR_OK)
+       if (err == ERROR_OK)
        {
                float speed;
-               speed=wrote / 1024.0;
+               speed = wrote / 1024.0;
                speed/=((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0));
-               command_print(cmd_ctx, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
-                       count*wordsize, address, duration_text,
-                       speed);
+               command_print(cmd_ctx, 
+                                         "wrote %" PRId32 " bytes to 0x%8.8" PRIx32 " in %s (%f kb/s)",
+                                         count*wordsize, 
+                                         address, 
+                                         duration_text,
+                                         speed);
        }
        free(duration_text);
        return ERROR_OK;
 }
 
-int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
-       u32 offset;
-       u8 *buffer;
-       u32 buf_cnt;
+       uint32_t offset;
+       uint8_t *buffer;
+       uint32_t buf_cnt;
 
        fileio_t fileio;
 
@@ -879,11 +894,16 @@ int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd
                fileio_close(&fileio);
                return retvaltemp;
        }
-       if (retval!=ERROR_OK)
+       if (retval == ERROR_OK)
        {
-       command_print(cmd_ctx, "wrote  %"PRIi64" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
-               fileio.size, args[1], strtoul(args[0], NULL, 0), offset, duration_text,
-               (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
+       command_print(cmd_ctx, 
+                                 "wrote  %lld byte from file %s to flash bank %li at offset 0x%8.8" PRIx32 " in %s (%f kb/s)",
+                                 fileio.size, 
+                                 args[1], 
+                                 strtoul(args[0], NULL, 0), 
+                                 offset, 
+                                 duration_text,
+                                 (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
        }
        free(duration_text);
 
@@ -908,7 +928,7 @@ void flash_set_dirty(void)
 }
 
 /* lookup flash bank by address */
-flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
+flash_bank_t *get_flash_bank_by_addr(target_t *target, uint32_t addr)
 {
        flash_bank_t *c;
 
@@ -927,12 +947,12 @@ flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
                if ((addr >= c->base) && (addr <= c->base + (c->size - 1)) && target == c->target)
                        return c;
        }
-       LOG_ERROR("No flash at address 0x%08x\n", addr);
+       LOG_ERROR("No flash at address 0x%08" PRIx32 "\n", addr);
        return NULL;
 }
 
 /* erase given flash region, selects proper bank according to target and address */
-int flash_erase_address_range(target_t *target, u32 addr, u32 length)
+int flash_erase_address_range(target_t *target, uint32_t addr, uint32_t length)
 {
        flash_bank_t *c;
        int first = -1;
@@ -958,7 +978,7 @@ int flash_erase_address_range(target_t *target, u32 addr, u32 length)
        }
 
        /* check whether it fits */
-       if (addr + length > c->base + c->size)
+       if (addr + length - 1 > c->base + c->size - 1)
                return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
 
        addr -= c->base;
@@ -974,19 +994,19 @@ int flash_erase_address_range(target_t *target, u32 addr, u32 length)
                }
        }
 
-       if( first == -1 || last == -1 )
+       if ( first == -1 || last == -1 )
                return ERROR_OK;
 
        return flash_driver_erase(c, first, last);
 }
 
 /* write (optional verify) an image to flash memory of the given target */
-int flash_write(target_t *target, image_t *image, u32 *written, int erase)
+int flash_write(target_t *target, image_t *image, uint32_t *written, int erase)
 {
-       int retval=ERROR_OK;
+       int retval = ERROR_OK;
 
        int section;
-       u32 section_offset;
+       uint32_t section_offset;
        flash_bank_t *c;
        int *padding;
 
@@ -1010,12 +1030,12 @@ int flash_write(target_t *target, image_t *image, u32 *written, int erase)
        /* loop until we reach end of the image */
        while (section < image->num_sections)
        {
-               u32 buffer_size;
-               u8 *buffer;
+               uint32_t buffer_size;
+               uint8_t *buffer;
                int section_first;
                int section_last;
-               u32 run_address = image->sections[section].base_address + section_offset;
-               u32 run_size = image->sections[section].size - section_offset;
+               uint32_t run_address = image->sections[section].base_address + section_offset;
+               uint32_t run_size = image->sections[section].size - section_offset;
                int pad_bytes = 0;
 
                if (image->sections[section].size ==  0)
@@ -1038,7 +1058,7 @@ int flash_write(target_t *target, image_t *image, u32 *written, int erase)
                section_first = section;
                section_last = section;
                padding[section] = 0;
-               while ((run_address + run_size < c->base + c->size)
+               while ((run_address + run_size - 1 < c->base + c->size - 1)
                                && (section_last + 1 < image->num_sections))
                {
                        if (image->sections[section_last + 1].base_address < (run_address + run_size))
@@ -1060,8 +1080,12 @@ int flash_write(target_t *target, image_t *image, u32 *written, int erase)
                }
 
                /* fit the run into bank constraints */
-               if (run_address + run_size > c->base + c->size)
+               if (run_address + run_size - 1 > c->base + c->size - 1)
+               {
+                       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;
+               }
 
                /* allocate buffer */
                buffer = malloc(run_size);
@@ -1070,7 +1094,7 @@ int flash_write(target_t *target, image_t *image, u32 *written, int erase)
                /* read sections to the buffer */
                while (buffer_size < run_size)
                {
-                       u32 size_read;
+                       uint32_t size_read;
 
                        size_read = run_size - buffer_size;
                        if (size_read > image->sections[section].size - section_offset)
@@ -1086,7 +1110,7 @@ int flash_write(target_t *target, image_t *image, u32 *written, int erase)
 
                        /* see if we need to pad the section */
                        while (padding[section]--)
-                                (buffer+buffer_size)[size_read++] = 0xff;
+                                (buffer + buffer_size)[size_read++] = 0xff;
 
                        buffer_size += size_read;
                        section_offset += size_read;
@@ -1132,10 +1156,10 @@ int flash_write(target_t *target, image_t *image, u32 *written, int erase)
 int default_flash_mem_blank_check(struct flash_bank_s *bank)
 {
        target_t *target = bank->target;
-       u8 buffer[1024];
+       uint8_t buffer[1024];
        int buffer_size = sizeof(buffer);
        int i;
-       int nBytes;
+       uint32_t nBytes;
 
        if (bank->target->state != TARGET_HALTED)
        {
@@ -1145,12 +1169,12 @@ int default_flash_mem_blank_check(struct flash_bank_s *bank)
 
        for (i = 0; i < bank->num_sectors; i++)
        {
-               int j;
+               uint32_t j;
                bank->sectors[i].is_erased = 1;
 
                for (j = 0; j < bank->sectors[i].size; j += buffer_size)
                {
-                       int chunk;
+                       uint32_t chunk;
                        int retval;
                        chunk = buffer_size;
                        if (chunk > (j - bank->sectors[i].size))
@@ -1158,7 +1182,7 @@ int default_flash_mem_blank_check(struct flash_bank_s *bank)
                                chunk = (j - bank->sectors[i].size);
                        }
 
-                       retval = target->type->read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
+                       retval = target_read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
                        if (retval != ERROR_OK)
                                return retval;
 
@@ -1182,7 +1206,7 @@ int default_flash_blank_check(struct flash_bank_s *bank)
        int i;
        int retval;
        int fast_check = 0;
-       int blank;
+       uint32_t blank;
 
        if (bank->target->state != TARGET_HALTED)
        {
@@ -1192,8 +1216,8 @@ int default_flash_blank_check(struct flash_bank_s *bank)
 
        for (i = 0; i < bank->num_sectors; i++)
        {
-               u32 address = bank->base + bank->sectors[i].offset;
-               u32 size = bank->sectors[i].size;
+               uint32_t address = bank->base + bank->sectors[i].offset;
+               uint32_t size = bank->sectors[i].size;
 
                if ((retval = target_blank_check_memory(target, address, size, &blank)) != ERROR_OK)
                {
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)