X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fflash%2Fnand.c;h=69b676620d0810dce9bc44a8e58a4bdf282dd834;hp=0f8e7d26a3bd00ae46c1734cb0f8e0d217584e81;hb=00228aa8398fd7dde1271af424fab1cb470c5f43;hpb=a88532bc6061ccc74ca08de161ec6fecf88a85b0 diff --git a/src/flash/nand.c b/src/flash/nand.c index 0f8e7d26a3..69b676620d 100644 --- a/src/flash/nand.c +++ b/src/flash/nand.c @@ -24,26 +24,14 @@ #include "config.h" #endif -#include "replacements.h" -#include "log.h" - -#include -#include -#include - -#include - #include "nand.h" -#include "flash.h" #include "time_support.h" #include "fileio.h" -#include "image.h" static int handle_nand_list_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); static int handle_nand_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); static int handle_nand_check_bad_blocks_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); static int handle_nand_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -static int handle_nand_copy_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); static int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); static int handle_nand_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); @@ -57,6 +45,7 @@ static int nand_write_page(struct nand_device_s *device, u32 page, u8 *data, u32 /* NAND flash controller */ +extern nand_flash_controller_t davinci_nand_controller; extern nand_flash_controller_t lpc3180_nand_controller; extern nand_flash_controller_t orion_nand_controller; extern nand_flash_controller_t s3c2410_nand_controller; @@ -68,6 +57,7 @@ extern nand_flash_controller_t s3c2443_nand_controller; static nand_flash_controller_t *nand_flash_controllers[] = { + &davinci_nand_controller, &lpc3180_nand_controller, &orion_nand_controller, &s3c2410_nand_controller, @@ -94,6 +84,7 @@ static command_t *nand_cmd; */ static nand_info_t nand_flash_ids[] = { + /* start "museum" IDs */ {"NAND 1MiB 5V 8-bit", 0x6e, 256, 1, 0x1000, 0}, {"NAND 2MiB 5V 8-bit", 0x64, 256, 2, 0x1000, 0}, {"NAND 4MiB 5V 8-bit", 0x6b, 512, 4, 0x2000, 0}, @@ -109,6 +100,7 @@ static nand_info_t nand_flash_ids[] = {"NAND 8MiB 3,3V 8-bit", 0xe6, 512, 8, 0x2000, 0}, {"NAND 8MiB 1,8V 16-bit", 0x49, 512, 8, 0x2000, NAND_BUSWIDTH_16}, {"NAND 8MiB 3,3V 16-bit", 0x59, 512, 8, 0x2000, NAND_BUSWIDTH_16}, + /* end "museum" IDs */ {"NAND 16MiB 1,8V 8-bit", 0x33, 512, 16, 0x4000, 0}, {"NAND 16MiB 3,3V 8-bit", 0x73, 512, 16, 0x4000, 0}, @@ -165,7 +157,7 @@ static nand_info_t nand_flash_ids[] = {"NAND 2GiB 1,8V 16-bit", 0xB5, 0, 2048, 0, LP_OPTIONS16}, {"NAND 2GiB 3,3V 16-bit", 0xC5, 0, 2048, 0, LP_OPTIONS16}, - {NULL, 0,} + {NULL, 0, 0, 0, 0, 0 } }; /* Manufacturer ID list @@ -180,6 +172,7 @@ static nand_manufacturer_t nand_manuf_ids[] = {NAND_MFR_RENESAS, "Renesas"}, {NAND_MFR_STMICRO, "ST Micro"}, {NAND_MFR_HYNIX, "Hynix"}, + {NAND_MFR_MICRON, "Micron"}, {0x0, NULL}, }; @@ -224,17 +217,17 @@ static int handle_nand_device_command(struct command_context_s *cmd_ctx, char *c { int i; int retval; - + if (argc < 1) { LOG_WARNING("incomplete flash device nand configuration"); return ERROR_FLASH_BANK_INVALID; } - + for (i = 0; nand_flash_controllers[i]; i++) { nand_device_t *p, *c; - + if (strcmp(args[0], nand_flash_controllers[i]->name) == 0) { /* register flash specific commands */ @@ -243,7 +236,7 @@ static int handle_nand_device_command(struct command_context_s *cmd_ctx, char *c LOG_ERROR("couldn't register '%s' commands", args[0]); return retval; } - + c = malloc(sizeof(nand_device_t)); c->controller = nand_flash_controllers[i]; @@ -262,7 +255,7 @@ static int handle_nand_device_command(struct command_context_s *cmd_ctx, char *c free(c); return ERROR_OK; } - + /* put NAND device in linked list */ if (nand_devices) { @@ -275,7 +268,7 @@ static int handle_nand_device_command(struct command_context_s *cmd_ctx, char *c { nand_devices = c; } - + return ERROR_OK; } } @@ -289,16 +282,16 @@ static int handle_nand_device_command(struct command_context_s *cmd_ctx, char *c { LOG_ERROR("%i: %s", i, nand_flash_controllers[i]->name); } - + return ERROR_OK; } int nand_register_commands(struct command_context_s *cmd_ctx) { nand_cmd = register_command(cmd_ctx, NULL, "nand", NULL, COMMAND_ANY, "NAND specific commands"); - + register_command(cmd_ctx, nand_cmd, "device", handle_nand_device_command, COMMAND_CONFIG, NULL); - + return ERROR_OK; } @@ -313,19 +306,18 @@ int nand_init(struct command_context_s *cmd_ctx) 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 [ ]"); + "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, "copy", handle_nand_copy_command, COMMAND_EXEC, - "copy from NAND flash device "); + "erase blocks on NAND flash device "); register_command(cmd_ctx, nand_cmd, "dump", handle_nand_dump_command, COMMAND_EXEC, - "dump from NAND flash device [options]"); + "dump from NAND flash device " + " [oob_raw|oob_only]"); register_command(cmd_ctx, nand_cmd, "write", handle_nand_write_command, COMMAND_EXEC, - "write to NAND flash device [oob_raw|oob_only|oob_softecc]"); + "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']"); } - + return ERROR_OK; } @@ -341,7 +333,7 @@ nand_device_t *get_nand_device_by_num(int num) return p; } } - + return NULL; } @@ -350,32 +342,32 @@ static int nand_build_bbt(struct nand_device_s *device, int first, int last) u32 page = 0x0; int i; u8 oob[6]; - + if ((first < 0) || (first >= device->num_blocks)) first = 0; - + if ((last >= device->num_blocks) || (last == -1)) last = device->num_blocks - 1; - + for (i = first; i < last; i++) { nand_read_page(device, page, NULL, 0, oob, 6); - + if (((device->device->options & NAND_BUSWIDTH_16) && ((oob[0] & oob[1]) != 0xff)) || (((device->page_size == 512) && (oob[5] != 0xff)) || ((device->page_size == 2048) && (oob[0] != 0xff)))) { - LOG_WARNING("invalid block: %i", i); + LOG_WARNING("bad block: %i", i); device->blocks[i].is_bad = 1; } else { device->blocks[i].is_bad = 0; } - + page += (device->erase_size / device->page_size); } - + return ERROR_OK; } @@ -383,12 +375,12 @@ int nand_read_status(struct nand_device_s *device, u8 *status) { if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; - + /* Send read status command */ device->controller->command(device, NAND_CMD_STATUS); - + alive_sleep(1); - + /* read status */ if (device->device->options & NAND_BUSWIDTH_16) { @@ -400,7 +392,7 @@ int nand_read_status(struct nand_device_s *device, u8 *status) { device->controller->read_data(device, status); } - + return ERROR_OK; } @@ -435,13 +427,13 @@ int nand_probe(struct nand_device_s *device) /* clear device data */ device->device = NULL; device->manufacturer = NULL; - + /* clear device parameters */ device->bus_width = 0; device->address_cycles = 0; device->page_size = 0; device->erase_size = 0; - + /* initialize controller (device parameters are zero, use controller default) */ if ((retval = device->controller->init(device) != ERROR_OK)) { @@ -458,13 +450,13 @@ int nand_probe(struct nand_device_s *device) return ERROR_NAND_OPERATION_FAILED; } } - + device->controller->command(device, NAND_CMD_RESET); device->controller->reset(device); device->controller->command(device, NAND_CMD_READID); device->controller->address(device, 0x0); - + if (device->bus_width == 8) { device->controller->read_data(device, &manufacturer_id); @@ -478,7 +470,7 @@ int nand_probe(struct nand_device_s *device) device->controller->read_data(device, &data_buf); device_id = data_buf & 0xff; } - + for (i = 0; nand_flash_ids[i].name; i++) { if (nand_flash_ids[i].id == device_id) @@ -487,7 +479,7 @@ int nand_probe(struct nand_device_s *device) break; } } - + for (i = 0; nand_manuf_ids[i].name; i++) { if (nand_manuf_ids[i].id == manufacturer_id) @@ -496,25 +488,25 @@ int nand_probe(struct nand_device_s *device) break; } } - + if (!device->manufacturer) { device->manufacturer = &nand_manuf_ids[0]; device->manufacturer->id = manufacturer_id; } - + if (!device->device) { LOG_ERROR("unknown NAND flash device found, manufacturer id: 0x%2.2x device id: 0x%2.2x", manufacturer_id, device_id); return ERROR_NAND_OPERATION_FAILED; } - + LOG_DEBUG("found %s (%s)", device->device->name, device->manufacturer->name); - + /* initialize device parameters */ - - /* bus width */ + + /* bus width */ if (device->device->options & NAND_BUSWIDTH_16) device->bus_width = 16; else @@ -544,7 +536,7 @@ int nand_probe(struct nand_device_s *device) id_buff[5] = data_buf >> 8; } } - + /* page size */ if (device->device->page_size == 0) { @@ -559,7 +551,7 @@ int nand_probe(struct nand_device_s *device) { device->page_size = device->device->page_size; } - + /* number of address cycles */ if (device->page_size <= 512) { @@ -587,7 +579,7 @@ int nand_probe(struct nand_device_s *device) device->address_cycles = 6; } } - + /* erase size */ if (device->device->erase_size == 0) { @@ -610,7 +602,7 @@ int nand_probe(struct nand_device_s *device) { device->erase_size = device->device->erase_size; } - + /* initialize controller, but leave parameters at the controllers default */ if ((retval = device->controller->init(device) != ERROR_OK)) { @@ -628,10 +620,10 @@ int nand_probe(struct nand_device_s *device) return ERROR_NAND_OPERATION_FAILED; } } - + device->num_blocks = (device->device->chip_size * 1024) / (device->erase_size / 1024); device->blocks = malloc(sizeof(nand_block_t) * device->num_blocks); - + for (i = 0; i < device->num_blocks; i++) { device->blocks[i].size = device->erase_size; @@ -639,7 +631,7 @@ int nand_probe(struct nand_device_s *device) device->blocks[i].is_erased = -1; device->blocks[i].is_bad = -1; } - + return ERROR_OK; } @@ -649,13 +641,13 @@ int nand_erase(struct nand_device_s *device, int first_block, int last_block) u32 page; u8 status; int retval; - + if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; - + if ((first_block < 0) || (last_block > device->num_blocks)) return ERROR_INVALID_ARGUMENTS; - + /* make sure we know if a block is bad before erasing it */ for (i = first_block; i <= last_block; i++) { @@ -665,25 +657,25 @@ int nand_erase(struct nand_device_s *device, int first_block, int last_block) break; } } - + for (i = first_block; i <= last_block; i++) { /* Send erase setup command */ device->controller->command(device, NAND_CMD_ERASE1); - + page = i * (device->erase_size / device->page_size); - + /* Send page address */ if (device->page_size <= 512) { /* row */ device->controller->address(device, page & 0xff); device->controller->address(device, (page >> 8) & 0xff); - + /* 3rd cycle only on devices with more than 32 MiB */ if (device->address_cycles >= 4) device->controller->address(device, (page >> 16) & 0xff); - + /* 4th cycle only on devices with more than 8 GiB */ if (device->address_cycles >= 5) device->controller->address(device, (page >> 24) & 0xff); @@ -693,12 +685,12 @@ int nand_erase(struct nand_device_s *device, int first_block, int last_block) /* row */ device->controller->address(device, page & 0xff); device->controller->address(device, (page >> 8) & 0xff); - + /* 3rd cycle only on devices with more than 128 MiB */ if (device->address_cycles >= 5) device->controller->address(device, (page >> 16) & 0xff); } - + /* Send erase confirm command */ device->controller->command(device, NAND_CMD_ERASE2); @@ -709,13 +701,13 @@ int nand_erase(struct nand_device_s *device, int first_block, int last_block) LOG_ERROR("timeout waiting for NAND flash block erase to complete"); return ERROR_NAND_OPERATION_TIMEOUT; } - + if ((retval = nand_read_status(device, &status)) != ERROR_OK) { LOG_ERROR("couldn't read status"); return ERROR_NAND_OPERATION_FAILED; } - + if (status & 0x1) { LOG_ERROR("erase operation didn't pass, status: 0x%2.2x", status); @@ -724,7 +716,7 @@ int nand_erase(struct nand_device_s *device, int first_block, int last_block) device->blocks[i].is_erased = 1; } - + return ERROR_OK; } @@ -732,74 +724,74 @@ int nand_erase(struct nand_device_s *device, int first_block, int last_block) static int nand_read_plain(struct nand_device_s *device, u32 address, u8 *data, u32 data_size) { u8 *page; - + if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; - + if (address % device->page_size) { LOG_ERROR("reads need to be page aligned"); return ERROR_NAND_OPERATION_FAILED; } - + page = malloc(device->page_size); - + while (data_size > 0 ) { u32 thisrun_size = (data_size > device->page_size) ? device->page_size : data_size; u32 page_address; - - + + page_address = address / device->page_size; - + nand_read_page(device, page_address, page, device->page_size, NULL, 0); memcpy(data, page, thisrun_size); - + address += thisrun_size; data += thisrun_size; data_size -= thisrun_size; } - + free(page); - + return ERROR_OK; } static int nand_write_plain(struct nand_device_s *device, u32 address, u8 *data, u32 data_size) { u8 *page; - + if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; - + if (address % device->page_size) { LOG_ERROR("writes need to be page aligned"); return ERROR_NAND_OPERATION_FAILED; } - + page = malloc(device->page_size); - + while (data_size > 0 ) { u32 thisrun_size = (data_size > device->page_size) ? device->page_size : data_size; u32 page_address; - + memset(page, 0xff, device->page_size); memcpy(page, data, thisrun_size); - + page_address = address / device->page_size; - + nand_write_page(device, page_address, page, device->page_size, NULL, 0); - + address += thisrun_size; data += thisrun_size; data_size -= thisrun_size; } - + free(page); - + return ERROR_OK; } #endif @@ -810,7 +802,7 @@ int nand_write_page(struct nand_device_s *device, u32 page, u8 *data, u32 data_s if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; - + block = page / (device->erase_size / device->page_size); if (device->blocks[block].is_erased == 1) device->blocks[block].is_erased = 0; @@ -825,7 +817,7 @@ static int nand_read_page(struct nand_device_s *device, u32 page, u8 *data, u32 { if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; - + if (device->use_raw || device->controller->read_page == NULL) return nand_read_page_raw(device, page, data, data_size, oob, oob_size); else @@ -835,7 +827,7 @@ static int nand_read_page(struct nand_device_s *device, u32 page, u8 *data, u32 int nand_read_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_size) { u32 i; - + if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; @@ -846,14 +838,14 @@ int nand_read_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 dat device->controller->command(device, NAND_CMD_READ0); else device->controller->command(device, NAND_CMD_READOOB); - + /* column (always 0, we start at the beginning of a page/OOB area) */ device->controller->address(device, 0x0); - + /* row */ device->controller->address(device, page & 0xff); device->controller->address(device, (page >> 8) & 0xff); - + /* 4th cycle only on devices with more than 32 MiB */ if (device->address_cycles >= 4) device->controller->address(device, (page >> 16) & 0xff); @@ -866,7 +858,7 @@ int nand_read_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 dat { /* large page device */ device->controller->command(device, NAND_CMD_READ0); - + /* column (0 when we start at the beginning of a page, * or 2048 for the beginning of OOB area) */ @@ -875,7 +867,7 @@ int nand_read_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 dat device->controller->address(device, 0x0); else device->controller->address(device, 0x8); - + /* row */ device->controller->address(device, page & 0xff); device->controller->address(device, (page >> 8) & 0xff); @@ -887,14 +879,14 @@ int nand_read_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 dat /* large page devices need a start command */ device->controller->command(device, NAND_CMD_READSTART); } - + if (device->controller->nand_ready) { if (!device->controller->nand_ready(device, 100)) return ERROR_NAND_OPERATION_TIMEOUT; } else { alive_sleep(1); } - + if (data) { if (device->controller->read_block_data != NULL) @@ -918,7 +910,7 @@ int nand_read_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 dat } } } - + if (oob) { if (device->controller->read_block_data != NULL) @@ -942,8 +934,8 @@ int nand_read_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 dat } } } - - return ERROR_OK; + + return ERROR_OK; } int nand_write_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_size) @@ -951,21 +943,21 @@ int nand_write_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 da u32 i; int retval; u8 status; - + if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; device->controller->command(device, NAND_CMD_SEQIN); - + if (device->page_size <= 512) { /* column (always 0, we start at the beginning of a page/OOB area) */ device->controller->address(device, 0x0); - + /* row */ device->controller->address(device, page & 0xff); device->controller->address(device, (page >> 8) & 0xff); - + /* 4th cycle only on devices with more than 32 MiB */ if (device->address_cycles >= 4) device->controller->address(device, (page >> 16) & 0xff); @@ -984,7 +976,7 @@ int nand_write_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 da device->controller->address(device, 0x0); else device->controller->address(device, 0x8); - + /* row */ device->controller->address(device, page & 0xff); device->controller->address(device, (page >> 8) & 0xff); @@ -993,7 +985,7 @@ int nand_write_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 da if (device->address_cycles >= 5) device->controller->address(device, (page >> 16) & 0xff); } - + if (data) { if (device->controller->write_block_data != NULL) @@ -1018,7 +1010,7 @@ int nand_write_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 da } } } - + if (oob) { if (device->controller->write_block_data != NULL) @@ -1043,50 +1035,50 @@ int nand_write_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 da } } } - + device->controller->command(device, NAND_CMD_PAGEPROG); - + retval = device->controller->nand_ready ? device->controller->nand_ready(device, 100) : nand_poll_ready(device, 100); if (!retval) return ERROR_NAND_OPERATION_TIMEOUT; - + if ((retval = nand_read_status(device, &status)) != ERROR_OK) { LOG_ERROR("couldn't read status"); return ERROR_NAND_OPERATION_FAILED; } - + if (status & NAND_STATUS_FAIL) { LOG_ERROR("write operation didn't pass, status: 0x%2.2x", status); return ERROR_NAND_OPERATION_FAILED; } - - return ERROR_OK; + + return ERROR_OK; } int handle_nand_list_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { nand_device_t *p; - int i = 0; - + int i; + if (!nand_devices) { command_print(cmd_ctx, "no NAND flash devices configured"); return ERROR_OK; } - - for (p = nand_devices; p; p = p->next) + + for (p = nand_devices, i = 0; p; p = p->next, i++) { if (p->device) command_print(cmd_ctx, "#%i: %s (%s) pagesize: %i, buswidth: %i, erasesize: %i", - i++, p->device->name, p->manufacturer->name, p->page_size, p->bus_width, p->erase_size); + i, p->device->name, p->manufacturer->name, p->page_size, p->bus_width, p->erase_size); else - command_print(cmd_ctx, "#%i: not probed"); + command_print(cmd_ctx, "#%i: not probed", i); } - + return ERROR_OK; } @@ -1097,23 +1089,23 @@ static int handle_nand_info_command(struct command_context_s *cmd_ctx, char *cmd int j = 0; int first = -1; int last = -1; - - if ((argc < 1) || (argc > 3)) - { - return ERROR_COMMAND_SYNTAX_ERROR; - } - - if (argc == 2) - { + switch (argc) { + default: + return ERROR_COMMAND_SYNTAX_ERROR; + case 1: + first = 0; + last = INT32_MAX; + break; + case 2: first = last = strtoul(args[1], NULL, 0); - } - else if (argc == 3) - { + break; + case 3: first = strtoul(args[1], NULL, 0); last = strtoul(args[2], NULL, 0); + break; } - + p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); if (p) { @@ -1121,24 +1113,24 @@ static int handle_nand_info_command(struct command_context_s *cmd_ctx, char *cmd { if (first >= p->num_blocks) first = p->num_blocks - 1; - + if (last >= p->num_blocks) last = p->num_blocks - 1; - + command_print(cmd_ctx, "#%i: %s (%s) pagesize: %i, buswidth: %i, erasesize: %i", i++, p->device->name, p->manufacturer->name, p->page_size, p->bus_width, p->erase_size); - + for (j = first; j <= last; j++) { char *erase_state, *bad_state; - + if (p->blocks[j].is_erased == 0) erase_state = "not erased"; else if (p->blocks[j].is_erased == 1) erase_state = "erased"; else erase_state = "erase state unknown"; - + if (p->blocks[j].is_bad == 0) bad_state = ""; else if (p->blocks[j].is_bad == 1) @@ -1146,17 +1138,17 @@ static int handle_nand_info_command(struct command_context_s *cmd_ctx, char *cmd else bad_state = " (block condition unknown)"; - command_print(cmd_ctx, "\t#%i: 0x%8.8x (0x%xkB) %s%s", + command_print(cmd_ctx, "\t#%i: 0x%8.8x (%dkB) %s%s", j, p->blocks[j].offset, p->blocks[j].size / 1024, erase_state, bad_state); } } else { - command_print(cmd_ctx, "#%i: not probed"); + command_print(cmd_ctx, "#%s: not probed", args[0]); } } - + return ERROR_OK; } @@ -1164,12 +1156,12 @@ static int handle_nand_probe_command(struct command_context_s *cmd_ctx, char *cm { nand_device_t *p; int retval; - + if (argc != 1) { return ERROR_COMMAND_SYNTAX_ERROR; } - + p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); if (p) { @@ -1190,7 +1182,7 @@ static int handle_nand_probe_command(struct command_context_s *cmd_ctx, char *cm { command_print(cmd_ctx, "NAND flash device '#%s' is out of bounds", args[0]); } - + return ERROR_OK; } @@ -1198,22 +1190,41 @@ static int handle_nand_erase_command(struct command_context_s *cmd_ctx, char *cm { nand_device_t *p; int retval; - + if (argc != 3) { return ERROR_COMMAND_SYNTAX_ERROR; } - + p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); if (p) { - int first = strtoul(args[1], NULL, 0); - int last = strtoul(args[2], NULL, 0); - - if ((retval = nand_erase(p, first, last)) == ERROR_OK) + char *cp; + unsigned long offset; + unsigned long length; + + offset = strtoul(args[1], &cp, 0); + if (*cp || offset == ULONG_MAX || offset % p->erase_size) { - command_print(cmd_ctx, "successfully erased blocks %i to %i on NAND flash device '%s'", first, last, p->device->name); + return ERROR_INVALID_ARGUMENTS; + } + offset /= p->erase_size; + + length = strtoul(args[2], &cp, 0); + if (*cp || length == ULONG_MAX || length % p->erase_size) + { + return ERROR_INVALID_ARGUMENTS; + } + length -= 1; + length /= p->erase_size; + + retval = nand_erase(p, offset, offset + length); + if (retval == ERROR_OK) + { + command_print(cmd_ctx, "successfully erased blocks " + "%lu to %lu on NAND flash device '%s'", + offset, offset + length, p->device->name); } else if (retval == ERROR_NAND_OPERATION_FAILED) { @@ -1228,7 +1239,7 @@ static int handle_nand_erase_command(struct command_context_s *cmd_ctx, char *cm { command_print(cmd_ctx, "NAND flash device '#%s' is out of bounds", args[0]); } - + return ERROR_OK; } @@ -1238,63 +1249,62 @@ int handle_nand_check_bad_blocks_command(struct command_context_s *cmd_ctx, char int retval; int first = -1; int last = -1; - + if ((argc < 1) || (argc > 3) || (argc == 2)) { return ERROR_COMMAND_SYNTAX_ERROR; } - - if (argc == 3) - { - first = strtoul(args[1], NULL, 0); - last = strtoul(args[2], NULL, 0); - } - + p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); - if (p) + if (!p) { + command_print(cmd_ctx, "NAND flash device '#%s' is out of bounds", + args[0]); + return ERROR_INVALID_ARGUMENTS; + } + + if (argc == 3) { - if ((retval = nand_build_bbt(p, first, last)) == ERROR_OK) - { - command_print(cmd_ctx, "checked NAND flash device for bad blocks, use \"nand info\" command to list blocks", p->device->name); - } - else if (retval == ERROR_NAND_OPERATION_FAILED) + char *cp; + unsigned long offset; + unsigned long length; + + offset = strtoul(args[1], &cp, 0); + if (*cp || offset == ULONG_MAX || offset % p->erase_size) { - command_print(cmd_ctx, "error when checking for bad blocks on NAND flash device"); + return ERROR_INVALID_ARGUMENTS; } - else + offset /= p->erase_size; + + length = strtoul(args[2], &cp, 0); + if (*cp || length == ULONG_MAX || length % p->erase_size) { - command_print(cmd_ctx, "unknown error when checking for bad blocks on NAND flash device"); + return ERROR_INVALID_ARGUMENTS; } + length -= 1; + length /= p->erase_size; + + first = offset; + last = offset + length; } - else - { - command_print(cmd_ctx, "NAND flash device '#%s' is out of bounds", args[0]); - } - - return ERROR_OK; -} -static int handle_nand_copy_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) -{ - nand_device_t *p; - - if (argc != 4) + retval = nand_build_bbt(p, first, last); + if (retval == ERROR_OK) { - return ERROR_COMMAND_SYNTAX_ERROR; - + command_print(cmd_ctx, "checked NAND flash device for bad blocks, " + "use \"nand info\" command to list blocks"); } - - p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); - if (p) + else if (retval == ERROR_NAND_OPERATION_FAILED) { - + command_print(cmd_ctx, "error when checking for bad blocks on " + "NAND flash device"); } else { - command_print(cmd_ctx, "NAND flash device '#%s' is out of bounds", args[0]); + command_print(cmd_ctx, "unknown error when checking for bad " + "blocks on NAND flash device"); } - + return ERROR_OK; } @@ -1304,20 +1314,20 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm u32 binary_size; u32 buf_cnt; enum oob_formats oob_format = NAND_OOB_NONE; - + fileio_t fileio; - + duration_t duration; char *duration_text; - + nand_device_t *p; - + if (argc < 3) { return ERROR_COMMAND_SYNTAX_ERROR; } - + p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); if (p) { @@ -1326,9 +1336,9 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm u8 *oob = NULL; u32 oob_size = 0; const int *eccpos = NULL; - + offset = strtoul(args[2], NULL, 0); - + if (argc > 3) { int i; @@ -1340,6 +1350,8 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm oob_format |= NAND_OOB_RAW | NAND_OOB_ONLY; else if (!strcmp(args[i], "oob_softecc")) oob_format |= NAND_OOB_SW_ECC; + else if (!strcmp(args[i], "oob_softecc_kw")) + oob_format |= NAND_OOB_SW_ECC_KW; else { command_print(cmd_ctx, "unknown option: %s", args[i]); @@ -1347,23 +1359,23 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm } } } - + duration_start_measure(&duration); if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK) { return ERROR_OK; } - + buf_cnt = binary_size = fileio.size; - + if (!(oob_format & NAND_OOB_ONLY)) { page_size = p->page_size; page = malloc(p->page_size); } - if (oob_format & (NAND_OOB_RAW | NAND_OOB_SW_ECC)) + if (oob_format & (NAND_OOB_RAW | NAND_OOB_SW_ECC | NAND_OOB_SW_ECC_KW)) { if (p->page_size == 512) { oob_size = 16; @@ -1374,7 +1386,7 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm } oob = malloc(oob_size); } - + if (offset % p->page_size) { command_print(cmd_ctx, "only page size aligned offsets and sizes are supported"); @@ -1383,11 +1395,11 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm free(page); return ERROR_OK; } - + while (buf_cnt > 0) { u32 size_read; - + if (NULL != page) { fileio_read(&fileio, page_size, page, &size_read); @@ -1409,6 +1421,21 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm oob[eccpos[j++]] = ecc[1]; oob[eccpos[j++]] = ecc[2]; } + } else if (oob_format & NAND_OOB_SW_ECC_KW) + { + /* + * In this case eccpos is not used as + * the ECC data is always stored contigously + * at the end of the OOB area. It consists + * of 10 bytes per 512-byte data block. + */ + u32 i; + u8 *ecc = oob + oob_size - page_size/512 * 10; + memset(oob, 0xff, oob_size); + for (i = 0; i < page_size; i += 512) { + nand_calculate_ecc_kw(p, page+i, ecc); + ecc += 10; + } } else if (NULL != oob) { @@ -1419,7 +1446,7 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm memset(oob + size_read, 0xff, oob_size - size_read); } } - + if (nand_write_page(p, offset / p->page_size, page, page_size, oob, oob_size) != ERROR_OK) { command_print(cmd_ctx, "failed writing file %s to NAND flash %s at offset 0x%8.8x", @@ -1449,19 +1476,19 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm { command_print(cmd_ctx, "NAND flash device '#%s' is out of bounds", args[0]); } - + return ERROR_OK; } static int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { nand_device_t *p; - + if (argc < 4) { return ERROR_COMMAND_SYNTAX_ERROR; } - + p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); if (p) { @@ -1471,7 +1498,7 @@ static int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd duration_t duration; char *duration_text; int retval; - + u8 *page = NULL; u32 page_size = 0; u8 *oob = NULL; @@ -1480,7 +1507,7 @@ static int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd u32 size = strtoul(args[3], NULL, 0); u32 bytes_done = 0; enum oob_formats oob_format = NAND_OOB_NONE; - + if (argc > 4) { int i; @@ -1491,16 +1518,16 @@ static int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd else if (!strcmp(args[i], "oob_only")) oob_format |= NAND_OOB_RAW | NAND_OOB_ONLY; else - command_print(cmd_ctx, "unknown option: '%s'", args[i]); + command_print(cmd_ctx, "unknown option: '%s'", args[i]); } } - + if ((address % p->page_size) || (size % p->page_size)) { command_print(cmd_ctx, "only page size aligned addresses and sizes are supported"); return ERROR_OK; } - + if (!(oob_format & NAND_OOB_ONLY)) { page_size = p->page_size; @@ -1515,14 +1542,14 @@ static int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd oob_size = 64; oob = malloc(oob_size); } - + if (fileio_open(&fileio, args[1], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK) { return ERROR_OK; } - + duration_start_measure(&duration); - + while (size > 0) { u32 size_written; @@ -1530,27 +1557,27 @@ static int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd { command_print(cmd_ctx, "reading NAND flash page failed"); free(page); - free(oob); + free(oob); fileio_close(&fileio); return ERROR_OK; } - + if (NULL != page) { fileio_write(&fileio, page_size, page, &size_written); bytes_done += page_size; } - + if (NULL != oob) { fileio_write(&fileio, oob_size, oob, &size_written); bytes_done += oob_size; } - + size -= p->page_size; address += p->page_size; } - + free(page); page = NULL; free(oob); @@ -1558,32 +1585,32 @@ static int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd fileio_close(&fileio); duration_stop_measure(&duration, &duration_text); - command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text); + command_print(cmd_ctx, "dumped %lld byte in %s", fileio.size, duration_text); free(duration_text); duration_text = NULL; } else { - command_print(cmd_ctx, "#%i: not probed"); + command_print(cmd_ctx, "#%s: not probed", args[0]); } } else { command_print(cmd_ctx, "NAND flash device '#%s' is out of bounds", args[0]); } - + return ERROR_OK; } static int handle_nand_raw_access_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { nand_device_t *p; - + if ((argc < 1) || (argc > 2)) { return ERROR_COMMAND_SYNTAX_ERROR; } - + p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); if (p) { @@ -1604,18 +1631,18 @@ static int handle_nand_raw_access_command(struct command_context_s *cmd_ctx, cha return ERROR_COMMAND_SYNTAX_ERROR; } } - + command_print(cmd_ctx, "raw access is %s", (p->use_raw) ? "enabled" : "disabled"); } else { - command_print(cmd_ctx, "#%i: not probed"); + command_print(cmd_ctx, "#%s: not probed", args[0]); } } else { command_print(cmd_ctx, "NAND flash device '#%s' is out of bounds", args[0]); } - + return ERROR_OK; }