X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fflash%2Fnand.c;h=5bcbea47ba35ac220be7451382e2d576b45dee8a;hb=7da02a8330d48f05f1ea9af93adb572f083aa728;hp=23caed0d383e42d01df2f2962c143e3557e77cd4;hpb=410fab9ea8c6632da2e4967d960f66eecc7821ec;p=openocd.git diff --git a/src/flash/nand.c b/src/flash/nand.c index 23caed0d38..5bcbea47ba 100644 --- a/src/flash/nand.c +++ b/src/flash/nand.c @@ -25,8 +25,9 @@ #endif #include "nand.h" -#include "time_support.h" -#include "fileio.h" +#include "common.h" +#include +#include static int nand_read_page(struct nand_device *nand, uint32_t page, uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size); //static int nand_read_plain(struct nand_device *nand, uint32_t address, uint8_t *data, uint32_t data_size); @@ -35,6 +36,7 @@ static int nand_write_page(struct nand_device *nand, uint32_t page, uint8_t *dat /* NAND flash controller */ +extern struct nand_flash_controller nonce_nand_controller; extern struct nand_flash_controller davinci_nand_controller; extern struct nand_flash_controller lpc3180_nand_controller; extern struct nand_flash_controller orion_nand_controller; @@ -48,6 +50,7 @@ extern struct nand_flash_controller imx31_nand_flash_controller; static struct nand_flash_controller *nand_flash_controllers[] = { + &nonce_nand_controller, &davinci_nand_controller, &lpc3180_nand_controller, &orion_nand_controller, @@ -62,7 +65,6 @@ static struct nand_flash_controller *nand_flash_controllers[] = /* configured NAND devices and NAND Flash command handler */ static struct nand_device *nand_devices = NULL; -static struct command *nand_cmd; /* Chip ID list * @@ -203,89 +205,138 @@ static struct nand_ecclayout nand_oob_64 = { .length = 38}} }; -/* nand device [controller options] - */ -COMMAND_HANDLER(handle_nand_device_command) +COMMAND_HANDLER(handle_nand_list_drivers) { - int i; - int retval; + command_print(CMD_CTX, "Available NAND flash controller drivers:"); + for (unsigned i = 0; nand_flash_controllers[i]; i++) + command_print(CMD_CTX, " %s", nand_flash_controllers[i]->name); + return ERROR_OK; +} - if (CMD_ARGC < 1) +static COMMAND_HELPER(create_nand_device, const char *bank_name, + struct nand_flash_controller *controller) +{ + if (NULL != controller->commands) { - LOG_WARNING("incomplete flash device nand configuration"); - return ERROR_FLASH_BANK_INVALID; + int retval = register_commands(CMD_CTX, NULL, + controller->commands); + if (ERROR_OK != retval) + return retval; } + struct nand_device *c = malloc(sizeof(struct nand_device)); - for (i = 0; nand_flash_controllers[i]; i++) - { - struct nand_device *p, *c; + c->name = strdup(bank_name); + c->controller = controller; + c->controller_priv = NULL; + c->manufacturer = NULL; + c->device = NULL; + c->bus_width = 0; + c->address_cycles = 0; + c->page_size = 0; + c->use_raw = 0; + c->next = NULL; - if (strcmp(CMD_ARGV[0], nand_flash_controllers[i]->name) == 0) - { - /* register flash specific commands */ - if ((retval = nand_flash_controllers[i]->register_commands(CMD_CTX)) != ERROR_OK) - { - LOG_ERROR("couldn't register '%s' commands", CMD_ARGV[0]); - return retval; - } - - c = malloc(sizeof(struct nand_device)); - - c->controller = nand_flash_controllers[i]; - c->controller_priv = NULL; - c->manufacturer = NULL; - c->device = NULL; - c->bus_width = 0; - c->address_cycles = 0; - c->page_size = 0; - c->use_raw = 0; - c->next = NULL; + int retval = CALL_COMMAND_HANDLER(controller->nand_device_command, c); + if (ERROR_OK != retval) + { + LOG_ERROR("'%s' driver rejected nand flash", controller->name); + free(c); + return ERROR_OK; + } - retval = CALL_COMMAND_HANDLER(nand_flash_controllers[i]->nand_device_command, c); - if (ERROR_OK != retval) - { - LOG_ERROR("'%s' driver rejected nand flash", c->controller->name); - free(c); - return ERROR_OK; - } + if (nand_devices) { + struct nand_device *p = nand_devices; + while (p && p->next) p = p->next; + p->next = c; + } else + nand_devices = c; - /* put NAND device in linked list */ - if (nand_devices) - { - /* find last flash device */ - for (p = nand_devices; p && p->next; p = p->next); - if (p) - p->next = c; - } - else - { - nand_devices = c; - } + return ERROR_OK; +} - return ERROR_OK; - } +COMMAND_HANDLER(handle_nand_device_command) +{ + if (CMD_ARGC < 1) + { + LOG_ERROR("incomplete nand device configuration"); + return ERROR_FLASH_BANK_INVALID; } - /* no valid NAND controller was found (i.e. the configuration option, - * didn't match one of the compiled-in controllers) - */ - LOG_ERROR("No valid NAND flash controller found (%s)", CMD_ARGV[0]); - LOG_ERROR("compiled-in NAND flash controllers:"); - for (i = 0; nand_flash_controllers[i]; i++) + // save name and increment (for compatibility) with drivers + const char *bank_name = *CMD_ARGV++; + CMD_ARGC--; + + const char *driver_name = CMD_ARGV[0]; + for (unsigned i = 0; nand_flash_controllers[i]; i++) { - LOG_ERROR("%i: %s", i, nand_flash_controllers[i]->name); + struct nand_flash_controller *controller = nand_flash_controllers[i]; + if (strcmp(driver_name, controller->name) != 0) + continue; + + return CALL_COMMAND_HANDLER(create_nand_device, + bank_name, controller); } - return ERROR_OK; + LOG_ERROR("No valid NAND flash driver found (%s)", driver_name); + return CALL_COMMAND_HANDLER(handle_nand_list_drivers); } + +COMMAND_HANDLER(handle_nand_init_command); + +static const struct command_registration nand_config_command_handlers[] = { + { + .name = "device", + .handler = &handle_nand_device_command, + .mode = COMMAND_CONFIG, + .help = "defines a new NAND bank", + }, + { + .name = "drivers", + .handler = &handle_nand_list_drivers, + .mode = COMMAND_ANY, + .help = "lists available NAND drivers", + }, + { + .name = "init", + .mode = COMMAND_CONFIG, + .handler = &handle_nand_init_command, + .help = "initialize NAND devices", + }, + COMMAND_REGISTRATION_DONE +}; +static const struct command_registration nand_command_handlers[] = { + { + .name = "nand", + .mode = COMMAND_ANY, + .help = "NAND flash command group", + .chain = nand_config_command_handlers, + }, + COMMAND_REGISTRATION_DONE +}; + int nand_register_commands(struct command_context *cmd_ctx) { - nand_cmd = register_command(cmd_ctx, NULL, "nand", NULL, COMMAND_ANY, "NAND specific commands"); + return register_commands(cmd_ctx, NULL, nand_command_handlers); +} - register_command(cmd_ctx, nand_cmd, "device", handle_nand_device_command, COMMAND_CONFIG, NULL); +struct nand_device *get_nand_device_by_name(const char *name) +{ + unsigned requested = get_flash_name_index(name); + unsigned found = 0; - return ERROR_OK; + struct nand_device *nand; + for (nand = nand_devices; NULL != nand; nand = nand->next) + { + if (strcmp(nand->name, name) == 0) + return nand; + if (!flash_driver_name_matches(nand->controller->name, name)) + continue; + if (++found < requested) + continue; + return nand; + } + return NULL; } struct nand_device *get_nand_device_by_num(int num) @@ -304,15 +355,19 @@ struct nand_device *get_nand_device_by_num(int num) return NULL; } -COMMAND_HELPER(nand_command_get_device_by_num, unsigned name_index, +COMMAND_HELPER(nand_command_get_device, unsigned name_index, struct nand_device **nand) { const char *str = CMD_ARGV[name_index]; + *nand = get_nand_device_by_name(str); + if (*nand) + return ERROR_OK; + unsigned num; COMMAND_PARSE_NUMBER(uint, str, num); *nand = get_nand_device_by_num(num); if (!*nand) { - command_print(CMD_CTX, "NAND flash device '#%s' is out of bounds", str); + command_print(CMD_CTX, "NAND flash device '%s' not found", str); return ERROR_INVALID_ARGUMENTS; } return ERROR_OK; @@ -1077,11 +1132,6 @@ COMMAND_HANDLER(handle_nand_info_command) int first = -1; int last = -1; - struct nand_device *p; - int retval = CALL_COMMAND_HANDLER(nand_command_get_device_by_num, 0, &p); - if (ERROR_OK != retval) - return retval; - switch (CMD_ARGC) { default: return ERROR_COMMAND_SYNTAX_ERROR; @@ -1100,6 +1150,11 @@ COMMAND_HANDLER(handle_nand_info_command) break; } + struct nand_device *p; + int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &p); + if (ERROR_OK != retval) + return retval; + if (NULL == p->device) { command_print(CMD_CTX, "#%s: not probed", CMD_ARGV[0]); @@ -1153,7 +1208,7 @@ COMMAND_HANDLER(handle_nand_probe_command) } struct nand_device *p; - int retval = CALL_COMMAND_HANDLER(nand_command_get_device_by_num, 0, &p); + int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &p); if (ERROR_OK != retval) return retval; @@ -1182,7 +1237,7 @@ COMMAND_HANDLER(handle_nand_erase_command) } struct nand_device *p; - int retval = CALL_COMMAND_HANDLER(nand_command_get_device_by_num, 0, &p); + int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &p); if (ERROR_OK != retval) return retval; @@ -1241,7 +1296,7 @@ COMMAND_HANDLER(handle_nand_check_bad_blocks_command) } struct nand_device *p; - int retval = CALL_COMMAND_HANDLER(nand_command_get_device_by_num, 0, &p); + int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &p); if (ERROR_OK != retval) return retval; @@ -1393,7 +1448,7 @@ static COMMAND_HELPER(nand_fileio_parse_args, struct nand_fileio_state *state, return ERROR_COMMAND_SYNTAX_ERROR; struct nand_device *nand; - int retval = CALL_COMMAND_HANDLER(nand_command_get_device_by_num, 0, &nand); + int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &nand); if (ERROR_OK != retval) return retval; @@ -1406,7 +1461,7 @@ static COMMAND_HELPER(nand_fileio_parse_args, struct nand_fileio_state *state, COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], state->address); if (need_size) { - COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], state->size); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], state->size); if (state->size % nand->page_size) { command_print(CMD_CTX, "only page-aligned sizes are supported"); @@ -1591,7 +1646,7 @@ COMMAND_HANDLER(handle_nand_verify_command) } file.size -= bytes_read; - file.address += nand->page_size; + dev.address += nand->page_size; } if (nand_fileio_finish(&file) == ERROR_OK) @@ -1652,7 +1707,7 @@ COMMAND_HANDLER(handle_nand_raw_access_command) } struct nand_device *p; - int retval = CALL_COMMAND_HANDLER(nand_command_get_device_by_num, 0, &p); + int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &p); if (ERROR_OK != retval) return retval; @@ -1671,43 +1726,97 @@ COMMAND_HANDLER(handle_nand_raw_access_command) return ERROR_OK; } +static const struct command_registration nand_exec_command_handlers[] = { + { + .name = "list", + .handler = &handle_nand_list_command, + .mode = COMMAND_EXEC, + .help = "list configured NAND flash devices", + }, + { + .name = "info", + .handler = &handle_nand_info_command, + .mode = COMMAND_EXEC, + .usage = "", + .help = "print info about a NAND flash device", + }, + { + .name = "probe", + .handler = &handle_nand_probe_command, + .mode = COMMAND_EXEC, + .usage = "", + .help = "identify NAND flash device ", + + }, + { + .name = "check_bad_blocks", + .handler = &handle_nand_check_bad_blocks_command, + .mode = COMMAND_EXEC, + .usage = " [ ]", + .help = "check NAND flash device for bad blocks", + }, + { + .name = "erase", + .handler = &handle_nand_erase_command, + .mode = COMMAND_EXEC, + .usage = " [ ]", + .help = "erase blocks on NAND flash device", + }, + { + .name = "dump", + .handler = &handle_nand_dump_command, + .mode = COMMAND_EXEC, + .usage = " " + "[oob_raw | oob_only]", + .help = "dump from NAND flash device", + }, + { + .name = "verify", + .handler = &handle_nand_verify_command, + .mode = COMMAND_EXEC, + .usage = " " + "[oob_raw | oob_only | oob_softecc | oob_softecc_kw]", + .help = "verify NAND flash device", + }, + { + .name = "write", + .handler = &handle_nand_write_command, + .mode = COMMAND_EXEC, + .usage = " " + "[oob_raw | oob_only | oob_softecc | oob_softecc_kw]", + .help = "write to NAND flash device", + }, + { + .name = "raw_access", + .handler = &handle_nand_raw_access_command, + .mode = COMMAND_EXEC, + .usage = " ['enable'|'disable']", + .help = "raw access to NAND flash device", + }, + COMMAND_REGISTRATION_DONE +}; + int nand_init(struct command_context *cmd_ctx) { if (!nand_devices) return ERROR_OK; + struct command *parent = command_find_in_context(cmd_ctx, "nand"); + return register_commands(cmd_ctx, parent, nand_exec_command_handlers); +} - register_command(cmd_ctx, nand_cmd, "list", - handle_nand_list_command, COMMAND_EXEC, - "list configured NAND flash devices"); - register_command(cmd_ctx, nand_cmd, "info", - handle_nand_info_command, COMMAND_EXEC, - "print info about NAND flash device "); - register_command(cmd_ctx, nand_cmd, "probe", - handle_nand_probe_command, COMMAND_EXEC, - "identify NAND flash device "); - - register_command(cmd_ctx, nand_cmd, "check_bad_blocks", - handle_nand_check_bad_blocks_command, COMMAND_EXEC, - "check NAND flash device for bad blocks [ ]"); - register_command(cmd_ctx, nand_cmd, "erase", - handle_nand_erase_command, COMMAND_EXEC, - "erase blocks on NAND flash device [ ]"); - register_command(cmd_ctx, nand_cmd, "dump", - handle_nand_dump_command, COMMAND_EXEC, - "dump from NAND flash device " - " [oob_raw | oob_only]"); - register_command(cmd_ctx, nand_cmd, "verify", - &handle_nand_verify_command, COMMAND_EXEC, - "verify NAND flash device " - "[oob_raw | oob_only | oob_softecc | oob_softecc_kw]"); - register_command(cmd_ctx, nand_cmd, "write", - handle_nand_write_command, COMMAND_EXEC, - "write to NAND flash device " - "[oob_raw | oob_only | oob_softecc | oob_softecc_kw]"); - - register_command(cmd_ctx, nand_cmd, "raw_access", - handle_nand_raw_access_command, COMMAND_EXEC, - "raw access to NAND flash device ['enable'|'disable']"); +COMMAND_HANDLER(handle_nand_init_command) +{ + if (CMD_ARGC != 0) + return ERROR_COMMAND_SYNTAX_ERROR; - return ERROR_OK; + static bool nand_initialized = false; + if (nand_initialized) + { + LOG_INFO("'nand init' has already been called"); + return ERROR_OK; + } + nand_initialized = true; + + LOG_DEBUG("Initializing NAND devices..."); + return nand_init(CMD_CTX); }