X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fflash%2Fflash.c;h=d16949da4cb5e28b9a5f5ff320e06703aeef7c15;hb=450ceda9aec12a0b67cca8dfbaf0384824cbd6c2;hp=329ade6364d0cb39378d4e2ba6baaceea5bcbc7d;hpb=ff61e6a37ce79f00957fc5aeb304291e5fa06323;p=openocd.git diff --git a/src/flash/flash.c b/src/flash/flash.c index 329ade6364..d16949da4c 100644 --- a/src/flash/flash.c +++ b/src/flash/flash.c @@ -28,45 +28,34 @@ #endif #include "flash.h" -#include "image.h" -#include "time_support.h" - -/* command handlers */ -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); -static int flash_write_unlock(target_t *target, image_t *image, uint32_t *written, int erase, bool unlock); +#include "common.h" +#include +#include + +static int flash_write_unlock(struct target *target, struct image *image, uint32_t *written, int erase, bool unlock); /* flash drivers */ -extern flash_driver_t lpc2000_flash; -extern flash_driver_t lpc288x_flash; -extern flash_driver_t lpc2900_flash; -extern flash_driver_t cfi_flash; -extern flash_driver_t at91sam3_flash; -extern flash_driver_t at91sam7_flash; -extern flash_driver_t str7x_flash; -extern flash_driver_t str9x_flash; -extern flash_driver_t aduc702x_flash; -extern flash_driver_t stellaris_flash; -extern flash_driver_t str9xpec_flash; -extern flash_driver_t stm32x_flash; -extern flash_driver_t tms470_flash; -extern flash_driver_t ecosflash_flash; -extern flash_driver_t ocl_flash; -extern flash_driver_t pic32mx_flash; -extern flash_driver_t avr_flash; -extern flash_driver_t faux_flash; - -flash_driver_t *flash_drivers[] = { +extern struct flash_driver lpc2000_flash; +extern struct flash_driver lpc288x_flash; +extern struct flash_driver lpc2900_flash; +extern struct flash_driver cfi_flash; +extern struct flash_driver at91sam3_flash; +extern struct flash_driver at91sam7_flash; +extern struct flash_driver str7x_flash; +extern struct flash_driver str9x_flash; +extern struct flash_driver aduc702x_flash; +extern struct flash_driver stellaris_flash; +extern struct flash_driver str9xpec_flash; +extern struct flash_driver stm32x_flash; +extern struct flash_driver tms470_flash; +extern struct flash_driver ecosflash_flash; +extern struct flash_driver ocl_flash; +extern struct flash_driver pic32mx_flash; +extern struct flash_driver avr_flash; +extern struct flash_driver faux_flash; + +struct flash_driver *flash_drivers[] = { &lpc2000_flash, &lpc288x_flash, &lpc2900_flash, @@ -88,11 +77,10 @@ flash_driver_t *flash_drivers[] = { NULL, }; -flash_bank_t *flash_banks; -static command_t *flash_cmd; +struct flash_bank *flash_banks; /* wafer thin wrapper for invoking the flash driver */ -static int flash_driver_write(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count) +static int flash_driver_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count) { int retval; @@ -106,7 +94,7 @@ static int flash_driver_write(struct flash_bank_s *bank, uint8_t *buffer, uint32 return retval; } -static int flash_driver_erase(struct flash_bank_s *bank, int first, int last) +static int flash_driver_erase(struct flash_bank *bank, int first, int last) { int retval; @@ -119,7 +107,7 @@ static int flash_driver_erase(struct flash_bank_s *bank, int first, int last) return retval; } -int flash_driver_protect(struct flash_bank_s *bank, int set, int first, int last) +int flash_driver_protect(struct flash_bank *bank, int set, int first, int last) { int retval; @@ -132,17 +120,9 @@ int flash_driver_protect(struct flash_bank_s *bank, int set, int first, int last return retval; } -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_options ...]"); - return ERROR_OK; -} - static int jim_flash_banks(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { - flash_bank_t *p; + struct flash_bank *p; if (argc != 1) { Jim_WrongNumArgs(interp, 1, argv, "no arguments to flash_banks command"); @@ -173,46 +153,9 @@ static int jim_flash_banks(Jim_Interp *interp, int argc, Jim_Obj *const *argv) return JIM_OK; } -int flash_init_drivers(struct command_context_s *cmd_ctx) +struct flash_bank *get_flash_bank_by_num_noprobe(int num) { - register_jim(cmd_ctx, "ocd_flash_banks", jim_flash_banks, "return information about the flash banks"); - - if (!flash_banks) - return ERROR_OK; - - register_command(cmd_ctx, flash_cmd, "info", handle_flash_info_command, COMMAND_EXEC, - "print info about flash bank "); - register_command(cmd_ctx, flash_cmd, "probe", handle_flash_probe_command, COMMAND_EXEC, - "identify flash bank "); - register_command(cmd_ctx, flash_cmd, "erase_check", handle_flash_erase_check_command, COMMAND_EXEC, - "check erase state of sectors in flash bank "); - register_command(cmd_ctx, flash_cmd, "protect_check", handle_flash_protect_check_command, COMMAND_EXEC, - "check protection state of sectors in flash bank "); - register_command(cmd_ctx, flash_cmd, "erase_sector", handle_flash_erase_command, COMMAND_EXEC, - "erase sectors at "); - register_command(cmd_ctx, flash_cmd, "erase_address", handle_flash_erase_address_command, COMMAND_EXEC, - "erase address range
"); - - register_command(cmd_ctx, flash_cmd, "fillw", handle_flash_fill_command, COMMAND_EXEC, - "fill with pattern (no autoerase)
"); - register_command(cmd_ctx, flash_cmd, "fillh", handle_flash_fill_command, COMMAND_EXEC, - "fill with pattern
"); - register_command(cmd_ctx, flash_cmd, "fillb", handle_flash_fill_command, COMMAND_EXEC, - "fill with pattern
"); - - register_command(cmd_ctx, flash_cmd, "write_bank", handle_flash_write_bank_command, COMMAND_EXEC, - "write binary data to "); - register_command(cmd_ctx, flash_cmd, "write_image", handle_flash_write_image_command, COMMAND_EXEC, - "write_image [erase] [unlock] [offset] [type]"); - register_command(cmd_ctx, flash_cmd, "protect", handle_flash_protect_command, COMMAND_EXEC, - "set protection of sectors at "); - - return ERROR_OK; -} - -flash_bank_t *get_flash_bank_by_num_noprobe(int num) -{ - flash_bank_t *p; + struct flash_bank *p; int i = 0; for (p = flash_banks; p; p = p->next) @@ -228,7 +171,7 @@ flash_bank_t *get_flash_bank_by_num_noprobe(int num) int flash_get_bank_count(void) { - flash_bank_t *p; + struct flash_bank *p; int i = 0; for (p = flash_banks; p; p = p->next) { @@ -237,9 +180,28 @@ int flash_get_bank_count(void) return i; } -flash_bank_t *get_flash_bank_by_num(int num) +struct flash_bank *get_flash_bank_by_name(const char *name) +{ + unsigned requested = get_flash_name_index(name); + unsigned found = 0; + + struct flash_bank *bank; + for (bank = flash_banks; NULL != bank; bank = bank->next) + { + if (strcmp(bank->name, name) == 0) + return bank; + if (!flash_driver_name_matches(bank->driver->name, name)) + continue; + if (++found < requested) + continue; + return bank; + } + return NULL; +} + +struct flash_bank *get_flash_bank_by_num(int num) { - flash_bank_t *p = get_flash_bank_by_num_noprobe(num); + struct flash_bank *p = get_flash_bank_by_num_noprobe(num); int retval; if (p == NULL) @@ -255,70 +217,85 @@ flash_bank_t *get_flash_bank_by_num(int num) return p; } -int flash_command_get_bank_by_num( - struct command_context_s *cmd_ctx, char *str, flash_bank_t **bank) +COMMAND_HELPER(flash_command_get_bank, unsigned name_index, + struct flash_bank **bank) { + const char *name = CMD_ARGV[name_index]; + *bank = get_flash_bank_by_name(name); + if (*bank) + return ERROR_OK; + unsigned bank_num; - COMMAND_PARSE_NUMBER(uint, str, bank_num); + COMMAND_PARSE_NUMBER(uint, name, bank_num); *bank = get_flash_bank_by_num(bank_num); if (!*bank) { - command_print(cmd_ctx, - "flash bank '#%u' not found", bank_num); + command_print(CMD_CTX, "flash bank '%s' not found", name); return ERROR_INVALID_ARGUMENTS; } return ERROR_OK; } -static int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_flash_bank_command) { - int retval; - int i; - int found = 0; - target_t *target; - - if (argc < 6) + if (CMD_ARGC < 7) { + LOG_ERROR("usage: flash bank " + " "); return ERROR_COMMAND_SYNTAX_ERROR; } + // save bank name and advance arguments for compatibility + const char *bank_name = *CMD_ARGV++; + CMD_ARGC--; - if ((target = get_target(args[5])) == NULL) + struct target *target; + if ((target = get_target(CMD_ARGV[5])) == NULL) { - LOG_ERROR("target '%s' not defined", args[5]); + LOG_ERROR("target '%s' not defined", CMD_ARGV[5]); return ERROR_FAIL; } - for (i = 0; flash_drivers[i]; i++) + const char *driver_name = CMD_ARGV[0]; + for (unsigned i = 0; flash_drivers[i]; i++) { - if (strcmp(args[0], flash_drivers[i]->name) != 0) + if (strcmp(driver_name, flash_drivers[i]->name) != 0) continue; - flash_bank_t *p, *c; - /* register flash specific commands */ - if (flash_drivers[i]->register_commands(cmd_ctx) != ERROR_OK) + if (NULL != flash_drivers[i]->commands) { - LOG_ERROR("couldn't register '%s' commands", args[0]); - return ERROR_FAIL; + int retval = register_commands(CMD_CTX, NULL, + flash_drivers[i]->commands); + if (ERROR_OK != retval) + { + LOG_ERROR("couldn't register '%s' commands", + driver_name); + return ERROR_FAIL; + } } - c = malloc(sizeof(flash_bank_t)); + struct flash_bank *p, *c; + c = malloc(sizeof(struct flash_bank)); + c->name = strdup(bank_name); c->target = target; c->driver = flash_drivers[i]; c->driver_priv = NULL; - COMMAND_PARSE_NUMBER(u32, args[1], c->base); - COMMAND_PARSE_NUMBER(u32, args[2], c->size); - COMMAND_PARSE_NUMBER(int, args[3], c->chip_width); - COMMAND_PARSE_NUMBER(int, args[4], c->bus_width); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], c->base); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], c->size); + COMMAND_PARSE_NUMBER(int, CMD_ARGV[3], c->chip_width); + COMMAND_PARSE_NUMBER(int, CMD_ARGV[4], c->bus_width); c->num_sectors = 0; c->sectors = NULL; c->next = NULL; - if ((retval = flash_drivers[i]->flash_bank_command(cmd_ctx, cmd, args, argc, c)) != ERROR_OK) + int retval; + retval = CALL_COMMAND_HANDLER(flash_drivers[i]->flash_bank_command, c); + if (ERROR_OK != retval) { - LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32 , args[0], c->base); + LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32, + driver_name, c->base); free(c); return retval; } @@ -339,31 +316,26 @@ static int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cm c->bank_number = 0; } - found = 1; + return ERROR_OK; } /* no matching flash driver found */ - if (!found) - { - LOG_ERROR("flash driver '%s' not found", args[0]); - return ERROR_FAIL; - } - - return ERROR_OK; + LOG_ERROR("flash driver '%s' not found", driver_name); + return ERROR_FAIL; } -static int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_flash_info_command) { - flash_bank_t *p; + struct flash_bank *p; uint32_t i = 0; int j = 0; int retval; - if (argc != 1) + if (CMD_ARGC != 1) return ERROR_COMMAND_SYNTAX_ERROR; unsigned bank_nr; - COMMAND_PARSE_NUMBER(uint, args[0], bank_nr); + COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], bank_nr); for (p = flash_banks; p; p = p->next, i++) { @@ -376,7 +348,7 @@ static int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cm if ((retval = p->driver->auto_probe(p)) != ERROR_OK) return retval; - command_print(cmd_ctx, + command_print(CMD_CTX, "#%" PRIi32 " : %s at 0x%8.8" PRIx32 ", size 0x%8.8" PRIx32 ", buswidth %i, chipwidth %i", i, p->driver->name, @@ -395,7 +367,7 @@ static int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cm else protect_state = "protection state unknown"; - command_print(cmd_ctx, + command_print(CMD_CTX, "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s", j, p->sectors[j].offset, @@ -406,7 +378,7 @@ static int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cm *buf = '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */ retval = p->driver->info(p, buf, sizeof(buf)); - command_print(cmd_ctx, "%s", buf); + command_print(CMD_CTX, "%s", buf); if (retval != ERROR_OK) LOG_ERROR("error retrieving flash info (%d)", retval); } @@ -414,64 +386,64 @@ static int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cm return ERROR_OK; } -static int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_flash_probe_command) { int retval; - if (argc != 1) + if (CMD_ARGC != 1) { return ERROR_COMMAND_SYNTAX_ERROR; } unsigned bank_nr; - COMMAND_PARSE_NUMBER(uint, args[0], bank_nr); - flash_bank_t *p = get_flash_bank_by_num_noprobe(bank_nr); + COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], bank_nr); + struct flash_bank *p = get_flash_bank_by_num_noprobe(bank_nr); if (p) { if ((retval = p->driver->probe(p)) == ERROR_OK) { - command_print(cmd_ctx, "flash '%s' found at 0x%8.8" PRIx32, 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.8" PRIx32, - args[0], p->base); + command_print(CMD_CTX, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32, + CMD_ARGV[0], p->base); } else { - command_print(cmd_ctx, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32, - args[0], p->base); + command_print(CMD_CTX, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32, + CMD_ARGV[0], p->base); } } else { - command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]); + command_print(CMD_CTX, "flash bank '#%s' is out of bounds", CMD_ARGV[0]); } return ERROR_OK; } -static int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_flash_erase_check_command) { - if (argc != 1) + if (CMD_ARGC != 1) { return ERROR_COMMAND_SYNTAX_ERROR; } - flash_bank_t *p; - int retval = flash_command_get_bank_by_num(cmd_ctx, args[0], &p); + struct flash_bank *p; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p); if (ERROR_OK != retval) return retval; int j; if ((retval = p->driver->erase_check(p)) == ERROR_OK) { - command_print(cmd_ctx, "successfully checked erase state"); + 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.8" PRIx32, - args[0], p->base); + command_print(CMD_CTX, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32, + CMD_ARGV[0], p->base); } for (j = 0; j < p->num_sectors; j++) @@ -485,7 +457,7 @@ static int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, c else erase_state = "erase state unknown"; - command_print(cmd_ctx, + command_print(CMD_CTX, "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s", j, p->sectors[j].offset, @@ -497,25 +469,23 @@ static int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, c return ERROR_OK; } -static int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_flash_erase_address_command) { - flash_bank_t *p; + struct flash_bank *p; int retval; int address; int length; - duration_t duration; - char *duration_text; - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); - if (argc != 2) + if (CMD_ARGC != 2) return ERROR_COMMAND_SYNTAX_ERROR; - COMMAND_PARSE_NUMBER(int, args[0], address); - COMMAND_PARSE_NUMBER(int, args[1], length); + COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], address); + COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], length); if (length <= 0) { - command_print(cmd_ctx, "Length must be >0"); + command_print(CMD_CTX, "Length must be >0"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -528,48 +498,48 @@ static int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, /* We can't know if we did a resume + halt, in which case we no longer know the erased state */ flash_set_dirty(); - duration_start_measure(&duration); + struct duration bench; + duration_start(&bench); + + retval = flash_erase_address_range(target, address, length); - if ((retval = flash_erase_address_range(target, address, length)) == ERROR_OK) + if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - if ((retval = duration_stop_measure(&duration, &duration_text)) != ERROR_OK) - { - return retval; - } - command_print(cmd_ctx, "erased address 0x%8.8x length %i in %s", address, length, duration_text); - free(duration_text); + command_print(CMD_CTX, "erased address 0x%8.8x (length %i)" + " in %fs (%0.3f kb/s)", address, length, + duration_elapsed(&bench), duration_kbps(&bench, length)); } return retval; } -static int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_flash_protect_check_command) { - if (argc != 1) + if (CMD_ARGC != 1) return ERROR_COMMAND_SYNTAX_ERROR; - flash_bank_t *p; - int retval = flash_command_get_bank_by_num(cmd_ctx, args[0], &p); + struct flash_bank *p; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p); if (ERROR_OK != retval) return retval; if ((retval = p->driver->protect_check(p)) == ERROR_OK) { - command_print(cmd_ctx, "successfully checked protect state"); + command_print(CMD_CTX, "successfully checked protect state"); } else if (retval == ERROR_FLASH_OPERATION_FAILED) { - command_print(cmd_ctx, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32, args[0], p->base); + command_print(CMD_CTX, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32, CMD_ARGV[0], p->base); } else { - command_print(cmd_ctx, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32, args[0], p->base); + command_print(CMD_CTX, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32, CMD_ARGV[0], p->base); } return ERROR_OK; } -static int flash_check_sector_parameters(struct command_context_s *cmd_ctx, +static int flash_check_sector_parameters(struct command_context *cmd_ctx, uint32_t first, uint32_t last, uint32_t num_sectors) { if (!(first <= last)) { @@ -587,87 +557,77 @@ static int flash_check_sector_parameters(struct command_context_s *cmd_ctx, return ERROR_OK; } -static int handle_flash_erase_command(struct command_context_s *cmd_ctx, - char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_flash_erase_command) { - if (argc != 2) + if (CMD_ARGC != 3) return ERROR_COMMAND_SYNTAX_ERROR; uint32_t bank_nr; uint32_t first; uint32_t last; - COMMAND_PARSE_NUMBER(u32, args[0], bank_nr); - flash_bank_t *p = get_flash_bank_by_num(bank_nr); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], bank_nr); + struct flash_bank *p = get_flash_bank_by_num(bank_nr); if (!p) return ERROR_OK; - COMMAND_PARSE_NUMBER(u32, args[1], first); - if (strcmp(args[2], "last") == 0) + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first); + if (strcmp(CMD_ARGV[2], "last") == 0) last = p->num_sectors - 1; else - COMMAND_PARSE_NUMBER(u32, args[2], last); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last); int retval; - if ((retval = flash_check_sector_parameters(cmd_ctx, + if ((retval = flash_check_sector_parameters(CMD_CTX, first, last, p->num_sectors)) != ERROR_OK) return retval; - duration_t duration; - char *duration_text; - duration_start_measure(&duration); + struct duration bench; + duration_start(&bench); - if ((retval = flash_driver_erase(p, first, last)) == ERROR_OK) { - if ((retval = duration_stop_measure(&duration, - &duration_text)) != ERROR_OK) - return retval; - command_print(cmd_ctx, "erased sectors %i through %i " - "on flash bank %i in %s", - (int) first, (int) last, (int) bank_nr, - duration_text); - free(duration_text); + retval = flash_driver_erase(p, first, last); + + if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) + { + command_print(CMD_CTX, "erased sectors %" PRIu32 " " + "through %" PRIu32" on flash bank %" PRIu32 " " + "in %fs", first, last, bank_nr, duration_elapsed(&bench)); } return ERROR_OK; } -static int handle_flash_protect_command(struct command_context_s *cmd_ctx, - char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_flash_protect_command) { - if (argc != 3) + if (CMD_ARGC != 4) return ERROR_COMMAND_SYNTAX_ERROR; uint32_t bank_nr; uint32_t first; uint32_t last; - int set; - COMMAND_PARSE_NUMBER(u32, args[0], bank_nr); - flash_bank_t *p = get_flash_bank_by_num(bank_nr); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], bank_nr); + struct flash_bank *p = get_flash_bank_by_num(bank_nr); if (!p) return ERROR_OK; - COMMAND_PARSE_NUMBER(u32, args[1], first); - if (strcmp(args[2], "last") == 0) + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first); + if (strcmp(CMD_ARGV[2], "last") == 0) last = p->num_sectors - 1; else - COMMAND_PARSE_NUMBER(u32, args[2], last); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last); - if (strcmp(args[3], "on") == 0) - set = 1; - else if (strcmp(args[3], "off") == 0) - set = 0; - else - return ERROR_COMMAND_SYNTAX_ERROR; + bool set; + COMMAND_PARSE_ON_OFF(CMD_ARGV[3], set); int retval; - if ((retval = flash_check_sector_parameters(cmd_ctx, + if ((retval = flash_check_sector_parameters(CMD_CTX, first, last, p->num_sectors)) != ERROR_OK) return retval; retval = flash_driver_protect(p, set, first, last); if (retval == ERROR_OK) { - command_print(cmd_ctx, "%s protection for sectors %i " + command_print(CMD_CTX, "%s protection for sectors %i " "through %i on flash bank %i", (set) ? "set" : "cleared", (int) first, (int) last, (int) bank_nr); @@ -676,19 +636,16 @@ static int handle_flash_protect_command(struct command_context_s *cmd_ctx, return ERROR_OK; } -static int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_flash_write_image_command) { - target_t *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); - image_t image; + struct image image; uint32_t written; - duration_t duration; - char *duration_text; - - int retval, retvaltemp; + int retval; - if (argc < 1) + if (CMD_ARGC < 1) { return ERROR_COMMAND_SYNTAX_ERROR; } @@ -699,25 +656,25 @@ static int handle_flash_write_image_command(struct command_context_s *cmd_ctx, c for (;;) { - if (strcmp(args[0], "erase") == 0) + if (strcmp(CMD_ARGV[0], "erase") == 0) { auto_erase = 1; - args++; - argc--; - command_print(cmd_ctx, "auto erase enabled"); - } else if (strcmp(args[0], "unlock") == 0) + CMD_ARGV++; + CMD_ARGC--; + command_print(CMD_CTX, "auto erase enabled"); + } else if (strcmp(CMD_ARGV[0], "unlock") == 0) { auto_unlock = true; - args++; - argc--; - command_print(cmd_ctx, "auto unlock enabled"); + CMD_ARGV++; + CMD_ARGC--; + command_print(CMD_CTX, "auto unlock enabled"); } else { break; } } - if (argc < 1) + if (CMD_ARGC < 1) { return ERROR_COMMAND_SYNTAX_ERROR; } @@ -728,12 +685,13 @@ static int handle_flash_write_image_command(struct command_context_s *cmd_ctx, c return ERROR_FAIL; } - duration_start_measure(&duration); + struct duration bench; + duration_start(&bench); - if (argc >= 2) + if (CMD_ARGC >= 2) { image.base_address_set = 1; - COMMAND_PARSE_NUMBER(int, args[1], image.base_address); + COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], image.base_address); } else { @@ -743,7 +701,7 @@ static int handle_flash_write_image_command(struct command_context_s *cmd_ctx, c image.start_address_set = 0; - retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL); + retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL); if (retval != ERROR_OK) { return retval; @@ -756,56 +714,60 @@ static int handle_flash_write_image_command(struct command_context_s *cmd_ctx, c return retval; } - if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK) + if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - image_close(&image); - return retvaltemp; + command_print(CMD_CTX, "wrote %" PRIu32 " byte from file %s " + "in %fs (%0.3f kb/s)", written, CMD_ARGV[0], + duration_elapsed(&bench), duration_kbps(&bench, written)); } - float speed; - - speed = written / 1024.0; - speed /= ((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, speed); - - free(duration_text); - image_close(&image); return retval; } -static int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_flash_fill_command) { - int err = ERROR_OK, retval; + int err = ERROR_OK; 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); + struct target *target = get_current_target(CMD_CTX); uint32_t i; uint32_t wordsize; + int retval = ERROR_OK; + + static size_t const chunksize = 1024; + uint8_t *chunk = malloc(chunksize); + if (chunk == NULL) + return ERROR_FAIL; + + uint8_t *readback = malloc(chunksize); + if (readback == NULL) + { + free(chunk); + return ERROR_FAIL; + } + + + if (CMD_ARGC != 3) + { + retval = ERROR_COMMAND_SYNTAX_ERROR; + goto done; + } - if (argc != 3) - return ERROR_COMMAND_SYNTAX_ERROR; - COMMAND_PARSE_NUMBER(u32, args[0], address); - COMMAND_PARSE_NUMBER(u32, args[1], pattern); - COMMAND_PARSE_NUMBER(u32, args[2], count); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], pattern); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], count); if (count == 0) - return ERROR_OK; + goto done; - switch (cmd[4]) + switch (CMD_NAME[4]) { case 'w': wordsize = 4; @@ -817,10 +779,11 @@ static int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cm wordsize = 1; break; default: - return ERROR_COMMAND_SYNTAX_ERROR; + retval = ERROR_COMMAND_SYNTAX_ERROR; + goto done; } - chunk_count = MIN(count, (1024 / wordsize)); + chunk_count = MIN(count, (chunksize / wordsize)); switch (wordsize) { case 4: @@ -843,24 +806,32 @@ static int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cm exit(-1); } - duration_start_measure(&duration); + struct duration bench; + duration_start(&bench); for (wrote = 0; wrote < (count*wordsize); wrote += cur_size) { cur_size = MIN((count*wordsize - wrote), sizeof(chunk)); - flash_bank_t *bank; + struct flash_bank *bank; bank = get_flash_bank_by_addr(target, address); if (bank == NULL) { - return ERROR_FAIL; + retval = ERROR_FAIL; + goto done; } err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size); if (err != ERROR_OK) - return err; + { + retval = err; + goto done; + } err = target_read_buffer(target, address + wrote, cur_size, readback); if (err != ERROR_OK) - return err; + { + retval = err; + goto done; + } unsigned i; for (i = 0; i < cur_size; i++) @@ -869,60 +840,52 @@ static int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cm { 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; + retval = ERROR_FAIL; + goto done; } } - } - if ((retval = duration_stop_measure(&duration, &duration_text)) != ERROR_OK) + if (duration_measure(&bench) == ERROR_OK) { - return retval; + command_print(CMD_CTX, "wrote %" PRIu32 " bytes to 0x%8.8" PRIx32 + " in %fs (%0.3f kb/s)", wrote, address, + duration_elapsed(&bench), duration_kbps(&bench, wrote)); } - float speed; + done: + free(readback); + free(chunk); - speed = wrote / 1024.0; - speed /= ((float)duration.duration.tv_sec - + ((float)duration.duration.tv_usec / 1000000.0)); - command_print(cmd_ctx, - "wrote %" PRIu32 " bytes to 0x%8.8" PRIx32 " in %s (%f kb/s)", - wrote, address, duration_text, speed); - - free(duration_text); - return ERROR_OK; + return retval; } -static int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(handle_flash_write_bank_command) { uint32_t offset; uint8_t *buffer; - uint32_t buf_cnt; - - fileio_t fileio; + struct fileio fileio; - duration_t duration; - char *duration_text; - - - if (argc != 3) + if (CMD_ARGC != 3) return ERROR_COMMAND_SYNTAX_ERROR; - duration_start_measure(&duration); + struct duration bench; + duration_start(&bench); - flash_bank_t *p; - int retval = flash_command_get_bank_by_num(cmd_ctx, args[0], &p); + struct flash_bank *p; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p); if (ERROR_OK != retval) return retval; - COMMAND_PARSE_NUMBER(u32, args[2], offset); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], offset); - if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK) + if (fileio_open(&fileio, CMD_ARGV[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK) { return ERROR_OK; } buffer = malloc(fileio.size); + size_t buf_cnt; if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK) { free(buffer); @@ -935,24 +898,13 @@ static int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, ch free(buffer); buffer = NULL; - int retvaltemp; - if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK) + if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - fileio_close(&fileio); - return retvaltemp; - } - if (retval == ERROR_OK) - { - float elapsed = (float)duration.duration.tv_sec; - elapsed += (float)duration.duration.tv_usec / 1000000.0; - float speed = (float)fileio.size / elapsed; - command_print(cmd_ctx, - "wrote %lld byte from file %s to flash bank %u " - "at offset 0x%8.8" PRIx32 " in %s (%f kb/s)", - fileio.size, args[1], p->bank_number, offset, - duration_text, speed / 1024); + command_print(CMD_CTX, "wrote %zu byte from file %s to flash bank %u" + " at offset 0x%8.8" PRIx32 " in %fs (%0.3f kb/s)", + fileio.size, CMD_ARGV[1], p->bank_number, offset, + duration_elapsed(&bench), duration_kbps(&bench, fileio.size)); } - free(duration_text); fileio_close(&fileio); @@ -961,7 +913,7 @@ static int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, ch void flash_set_dirty(void) { - flash_bank_t *c; + struct flash_bank *c; int i; /* set all flash to require erasing */ @@ -975,9 +927,9 @@ void flash_set_dirty(void) } /* lookup flash bank by address */ -flash_bank_t *get_flash_bank_by_addr(target_t *target, uint32_t addr) +struct flash_bank *get_flash_bank_by_addr(struct target *target, uint32_t addr) { - flash_bank_t *c; + struct flash_bank *c; /* cycle through bank list */ for (c = flash_banks; c; c = c->next) @@ -999,10 +951,10 @@ flash_bank_t *get_flash_bank_by_addr(target_t *target, uint32_t addr) } /* erase given flash region, selects proper bank according to target and address */ -static int flash_iterate_address_range(target_t *target, uint32_t addr, uint32_t length, - int (*callback)(struct flash_bank_s *bank, int first, int last)) +static int flash_iterate_address_range(struct target *target, uint32_t addr, uint32_t length, + int (*callback)(struct flash_bank *bank, int first, int last)) { - flash_bank_t *c; + struct flash_bank *c; int first = -1; int last = -1; int i; @@ -1050,30 +1002,30 @@ static int flash_iterate_address_range(target_t *target, uint32_t addr, uint32_t -int flash_erase_address_range(target_t *target, uint32_t addr, uint32_t length) +int flash_erase_address_range(struct target *target, uint32_t addr, uint32_t length) { return flash_iterate_address_range(target, addr, length, &flash_driver_erase); } -static int flash_driver_unprotect(struct flash_bank_s *bank, int first, int last) +static int flash_driver_unprotect(struct flash_bank *bank, int first, int last) { return flash_driver_protect(bank, 0, first, last); } -static int flash_unlock_address_range(target_t *target, uint32_t addr, uint32_t length) +static int flash_unlock_address_range(struct target *target, uint32_t addr, uint32_t length) { return flash_iterate_address_range(target, addr, length, &flash_driver_unprotect); } /* write (optional verify) an image to flash memory of the given target */ -static int flash_write_unlock(target_t *target, image_t *image, uint32_t *written, int erase, bool unlock) +static int flash_write_unlock(struct target *target, struct image *image, uint32_t *written, int erase, bool unlock) { int retval = ERROR_OK; int section; uint32_t section_offset; - flash_bank_t *c; + struct flash_bank *c; int *padding; section = 0; @@ -1160,7 +1112,7 @@ static int flash_write_unlock(target_t *target, image_t *image, uint32_t *writte /* read sections to the buffer */ while (buffer_size < run_size) { - uint32_t size_read; + size_t size_read; size_read = run_size - buffer_size; if (size_read > image->sections[section].size - section_offset) @@ -1226,18 +1178,18 @@ static int flash_write_unlock(target_t *target, image_t *image, uint32_t *writte return retval; } -int flash_write(target_t *target, image_t *image, uint32_t *written, int erase) +int flash_write(struct target *target, struct image *image, uint32_t *written, int erase) { return flash_write_unlock(target, image, written, erase, false); } -int default_flash_mem_blank_check(struct flash_bank_s *bank) +int default_flash_mem_blank_check(struct flash_bank *bank) { - target_t *target = bank->target; - uint8_t buffer[1024]; - int buffer_size = sizeof(buffer); + struct target *target = bank->target; + const int buffer_size = 1024; int i; uint32_t nBytes; + int retval = ERROR_OK; if (bank->target->state != TARGET_HALTED) { @@ -1245,6 +1197,8 @@ int default_flash_mem_blank_check(struct flash_bank_s *bank) return ERROR_TARGET_NOT_HALTED; } + uint8_t *buffer = malloc(buffer_size); + for (i = 0; i < bank->num_sectors; i++) { uint32_t j; @@ -1253,7 +1207,6 @@ int default_flash_mem_blank_check(struct flash_bank_s *bank) for (j = 0; j < bank->sectors[i].size; j += buffer_size) { uint32_t chunk; - int retval; chunk = buffer_size; if (chunk > (j - bank->sectors[i].size)) { @@ -1262,7 +1215,9 @@ int default_flash_mem_blank_check(struct flash_bank_s *bank) retval = target_read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer); if (retval != ERROR_OK) - return retval; + { + goto done; + } for (nBytes = 0; nBytes < chunk; nBytes++) { @@ -1275,12 +1230,15 @@ int default_flash_mem_blank_check(struct flash_bank_s *bank) } } - return ERROR_OK; + done: + free(buffer); + + return retval; } -int default_flash_blank_check(struct flash_bank_s *bank) +int default_flash_blank_check(struct flash_bank *bank) { - target_t *target = bank->target; + struct target *target = bank->target; int i; int retval; int fast_check = 0; @@ -1317,3 +1275,159 @@ int default_flash_blank_check(struct flash_bank_s *bank) return ERROR_OK; } + +static const struct command_registration flash_exec_command_handlers[] = { + { + .name = "probe", + .handler = &handle_flash_probe_command, + .mode = COMMAND_EXEC, + .usage = "", + .help = "identify flash bank", + }, + { + .name = "info", + .handler = &handle_flash_info_command, + .mode = COMMAND_EXEC, + .usage = "", + .help = "print bank information", + }, + { + .name = "erase_check", + .handler = &handle_flash_erase_check_command, + .mode = COMMAND_EXEC, + .usage = "", + .help = "check erase state of sectors", + }, + { + .name = "protect_check", + .handler = &handle_flash_protect_check_command, + .mode = COMMAND_EXEC, + .usage = "", + .help = "check protection state of sectors", + }, + { + .name = "erase_sector", + .handler = &handle_flash_erase_command, + .mode = COMMAND_EXEC, + .usage = " ", + .help = "erase sectors", + }, + { + .name = "erase_address", + .handler = &handle_flash_erase_address_command, + .mode = COMMAND_EXEC, + .usage = "
", + .help = "erase address range", + + }, + { + .name = "fillw", + .handler = &handle_flash_fill_command, + .mode = COMMAND_EXEC, + .usage = "
", + .help = "fill with pattern (no autoerase)", + }, + { + .name = "fillh", + .handler = &handle_flash_fill_command, + .mode = COMMAND_EXEC, + .usage = "
", + .help = "fill with pattern", + }, + { + .name = "fillb", + .handler = &handle_flash_fill_command, + .mode = COMMAND_EXEC, + .usage = "
", + .help = "fill with pattern", + + }, + { + .name = "write_bank", + .handler = &handle_flash_write_bank_command, + .mode = COMMAND_EXEC, + .usage = " ", + .help = "write binary data", + }, + { + .name = "write_image", + .handler = &handle_flash_write_image_command, + .mode = COMMAND_EXEC, + .usage = " [erase] [unlock] [offset] [type]", + .help = "write an image to flash" + }, + { + .name = "protect", + .handler = &handle_flash_protect_command, + .mode = COMMAND_EXEC, + .usage = " ", + .help = "set protection of sectors", + }, + COMMAND_REGISTRATION_DONE +}; + +int flash_init_drivers(struct command_context *cmd_ctx) +{ + if (!flash_banks) + return ERROR_OK; + + struct command *parent = command_find_in_context(cmd_ctx, "flash"); + return register_commands(cmd_ctx, parent, flash_exec_command_handlers); +} + +COMMAND_HANDLER(handle_flash_init_command) +{ + if (CMD_ARGC != 0) + return ERROR_COMMAND_SYNTAX_ERROR; + + static bool flash_initialized = false; + if (flash_initialized) + { + LOG_INFO("'flash init' has already been called"); + return ERROR_OK; + } + flash_initialized = true; + + LOG_DEBUG("Initializing flash devices..."); + return flash_init_drivers(CMD_CTX); +} + +static const struct command_registration flash_config_command_handlers[] = { + { + .name = "bank", + .handler = &handle_flash_bank_command, + .mode = COMMAND_CONFIG, + .usage = " " + " " + "[driver_options ...]", + .help = "Define a new bank with the given name, " + "using the specified NOR flash driver.", + }, + { + .name = "init", + .mode = COMMAND_CONFIG, + .handler = &handle_flash_init_command, + .help = "initialize flash devices", + }, + { + .name = "banks", + .mode = COMMAND_ANY, + .jim_handler = &jim_flash_banks, + .help = "return information about the flash banks", + }, + COMMAND_REGISTRATION_DONE +}; +static const struct command_registration flash_command_handlers[] = { + { + .name = "flash", + .mode = COMMAND_ANY, + .help = "NOR flash command group", + .chain = flash_config_command_handlers, + }, + COMMAND_REGISTRATION_DONE +}; + +int flash_register_commands(struct command_context *cmd_ctx) +{ + return register_commands(cmd_ctx, NULL, flash_command_handlers); +}