X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fflash%2Fnand.c;h=7fb7c99e7ae8e9dd42e661d922f2ad297d8c9783;hp=192565f7e35395f949850c1cd1b610ccdf47a216;hb=93ab9ce8885cd45f5f9beba7d7e55536655eb5bf;hpb=f876d5e9c769a288faa7fd14b7bf373363542aab diff --git a/src/flash/nand.c b/src/flash/nand.c index 192565f7e3..7fb7c99e7a 100644 --- a/src/flash/nand.c +++ b/src/flash/nand.c @@ -38,10 +38,10 @@ static int handle_nand_erase_command(struct command_context_s *cmd_ctx, char *cm static int handle_nand_raw_access_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -static int nand_read_page(struct nand_device_s *device, u32 page, uint8_t *data, u32 data_size, uint8_t *oob, u32 oob_size); -//static int nand_read_plain(struct nand_device_s *device, u32 address, uint8_t *data, u32 data_size); +static int nand_read_page(struct nand_device_s *device, 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_s *device, uint32_t address, uint8_t *data, uint32_t data_size); -static int nand_write_page(struct nand_device_s *device, u32 page, uint8_t *data, u32 data_size, uint8_t *oob, u32 oob_size); +static int nand_write_page(struct nand_device_s *device, uint32_t page, uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size); /* NAND flash controller */ @@ -52,6 +52,7 @@ extern nand_flash_controller_t s3c2410_nand_controller; extern nand_flash_controller_t s3c2412_nand_controller; extern nand_flash_controller_t s3c2440_nand_controller; extern nand_flash_controller_t s3c2443_nand_controller; +extern nand_flash_controller_t imx31_nand_flash_controller; /* extern nand_flash_controller_t boundary_scan_nand_controller; */ @@ -64,6 +65,7 @@ static nand_flash_controller_t *nand_flash_controllers[] = &s3c2412_nand_controller, &s3c2440_nand_controller, &s3c2443_nand_controller, + &imx31_nand_flash_controller, /* &boundary_scan_nand_controller, */ NULL }; @@ -307,13 +309,14 @@ int nand_init(struct command_context_s *cmd_ctx) "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, "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]"); + " [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|oob_softecc_kw]"); + "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']"); } @@ -337,9 +340,22 @@ nand_device_t *get_nand_device_by_num(int num) return NULL; } +int nand_command_get_device_by_num(struct command_context_s *cmd_ctx, + char *str, nand_device_t **device) +{ + unsigned num; + COMMAND_PARSE_NUMBER(uint, str, num); + *device = get_nand_device_by_num(num); + if (!*device) { + command_print(cmd_ctx, "NAND flash device '#%s' is out of bounds", str); + return ERROR_INVALID_ARGUMENTS; + } + return ERROR_OK; +} + static int nand_build_bbt(struct nand_device_s *device, int first, int last) { - u32 page = 0x0; + uint32_t page = 0x0; int i; uint8_t oob[6]; @@ -518,9 +534,9 @@ int nand_probe(struct nand_device_s *device) { if (device->bus_width == 8) { - device->controller->read_data(device, id_buff+3); - device->controller->read_data(device, id_buff+4); - device->controller->read_data(device, id_buff+5); + device->controller->read_data(device, id_buff + 3); + device->controller->read_data(device, id_buff + 4); + device->controller->read_data(device, id_buff + 5); } else { @@ -635,10 +651,10 @@ int nand_probe(struct nand_device_s *device) return ERROR_OK; } -int nand_erase(struct nand_device_s *device, int first_block, int last_block) +static int nand_erase(struct nand_device_s *device, int first_block, int last_block) { int i; - u32 page; + uint32_t page; uint8_t status; int retval; @@ -710,8 +726,11 @@ int nand_erase(struct nand_device_s *device, int first_block, int last_block) if (status & 0x1) { - LOG_ERROR("erase operation didn't pass, status: 0x%2.2x", status); - return ERROR_NAND_OPERATION_FAILED; + LOG_ERROR("didn't erase %sblock %d; status: 0x%2.2x", + (device->blocks[i].is_bad == 1) + ? "bad " : "", + i, status); + /* continue; other blocks might still be erasable */ } device->blocks[i].is_erased = 1; @@ -721,7 +740,7 @@ int nand_erase(struct nand_device_s *device, int first_block, int last_block) } #if 0 -static int nand_read_plain(struct nand_device_s *device, u32 address, uint8_t *data, u32 data_size) +static int nand_read_plain(struct nand_device_s *device, uint32_t address, uint8_t *data, uint32_t data_size) { uint8_t *page; @@ -736,10 +755,10 @@ static int nand_read_plain(struct nand_device_s *device, u32 address, uint8_t *d page = malloc(device->page_size); - while (data_size > 0 ) + while (data_size > 0) { - u32 thisrun_size = (data_size > device->page_size) ? device->page_size : data_size; - u32 page_address; + uint32_t thisrun_size = (data_size > device->page_size) ? device->page_size : data_size; + uint32_t page_address; page_address = address / device->page_size; @@ -758,7 +777,7 @@ static int nand_read_plain(struct nand_device_s *device, u32 address, uint8_t *d return ERROR_OK; } -static int nand_write_plain(struct nand_device_s *device, u32 address, uint8_t *data, u32 data_size) +static int nand_write_plain(struct nand_device_s *device, uint32_t address, uint8_t *data, uint32_t data_size) { uint8_t *page; @@ -773,10 +792,10 @@ static int nand_write_plain(struct nand_device_s *device, u32 address, uint8_t * page = malloc(device->page_size); - while (data_size > 0 ) + while (data_size > 0) { - u32 thisrun_size = (data_size > device->page_size) ? device->page_size : data_size; - u32 page_address; + uint32_t thisrun_size = (data_size > device->page_size) ? device->page_size : data_size; + uint32_t page_address; memset(page, 0xff, device->page_size); memcpy(page, data, thisrun_size); @@ -796,9 +815,9 @@ static int nand_write_plain(struct nand_device_s *device, u32 address, uint8_t * } #endif -int nand_write_page(struct nand_device_s *device, u32 page, uint8_t *data, u32 data_size, uint8_t *oob, u32 oob_size) +int nand_write_page(struct nand_device_s *device, uint32_t page, uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size) { - u32 block; + uint32_t block; if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; @@ -813,7 +832,7 @@ int nand_write_page(struct nand_device_s *device, u32 page, uint8_t *data, u32 d return device->controller->write_page(device, page, data, data_size, oob, oob_size); } -static int nand_read_page(struct nand_device_s *device, u32 page, uint8_t *data, u32 data_size, uint8_t *oob, u32 oob_size) +static int nand_read_page(struct nand_device_s *device, uint32_t page, uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size) { if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; @@ -824,9 +843,9 @@ static int nand_read_page(struct nand_device_s *device, u32 page, uint8_t *data, return device->controller->read_page(device, page, data, data_size, oob, oob_size); } -int nand_read_page_raw(struct nand_device_s *device, u32 page, uint8_t *data, u32 data_size, uint8_t *oob, u32 oob_size) +int nand_read_page_raw(struct nand_device_s *device, uint32_t page, uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size) { - u32 i; + uint32_t i; if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; @@ -938,9 +957,9 @@ int nand_read_page_raw(struct nand_device_s *device, u32 page, uint8_t *data, u3 return ERROR_OK; } -int nand_write_page_raw(struct nand_device_s *device, u32 page, uint8_t *data, u32 data_size, uint8_t *oob, u32 oob_size) +int nand_write_page_raw(struct nand_device_s *device, uint32_t page, uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size) { - u32 i; + uint32_t i; int retval; uint8_t status; @@ -1073,8 +1092,12 @@ int handle_nand_list_command(struct command_context_s *cmd_ctx, char *cmd, char 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); + command_print(cmd_ctx, "#%i: %s (%s) " + "pagesize: %i, buswidth: %i,\n\t" + "blocksize: %i, blocks: %i", + i, p->device->name, p->manufacturer->name, + p->page_size, p->bus_width, + p->erase_size, p->num_blocks); else command_print(cmd_ctx, "#%i: not probed", i); } @@ -1084,12 +1107,16 @@ int handle_nand_list_command(struct command_context_s *cmd_ctx, char *cmd, char static int handle_nand_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - nand_device_t *p; int i = 0; int j = 0; int first = -1; int last = -1; + nand_device_t *p; + int retval = nand_command_get_device_by_num(cmd_ctx, args[0], &p); + if (ERROR_OK != retval) + return retval; + switch (argc) { default: return ERROR_COMMAND_SYNTAX_ERROR; @@ -1098,15 +1125,16 @@ static int handle_nand_info_command(struct command_context_s *cmd_ctx, char *cmd last = INT32_MAX; break; case 2: - first = last = strtoul(args[1], NULL, 0); + COMMAND_PARSE_NUMBER(int, args[1], i); + first = last = i; + i = 0; break; case 3: - first = strtoul(args[1], NULL, 0); - last = strtoul(args[2], NULL, 0); + COMMAND_PARSE_NUMBER(int, args[1], first); + COMMAND_PARSE_NUMBER(int, args[2], last); break; } - p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); if (p) { if (p->device) @@ -1138,9 +1166,13 @@ 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 (%dkB) %s%s", - j, p->blocks[j].offset, p->blocks[j].size / 1024, - erase_state, bad_state); + command_print(cmd_ctx, + "\t#%i: 0x%8.8" PRIx32 " (%" PRId32 "kB) %s%s", + j, + p->blocks[j].offset, + p->blocks[j].size / 1024, + erase_state, + bad_state); } } else @@ -1154,15 +1186,16 @@ static int handle_nand_info_command(struct command_context_s *cmd_ctx, char *cmd static int handle_nand_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - 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)); + nand_device_t *p; + int retval = nand_command_get_device_by_num(cmd_ctx, args[0], &p); + if (ERROR_OK != retval) + return retval; + if (p) { if ((retval = nand_probe(p)) == ERROR_OK) @@ -1178,53 +1211,55 @@ static int handle_nand_probe_command(struct command_context_s *cmd_ctx, char *cm command_print(cmd_ctx, "unknown error when probing NAND flash device"); } } - else - { - command_print(cmd_ctx, "NAND flash device '#%s' is out of bounds", args[0]); - } return ERROR_OK; } static int handle_nand_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - nand_device_t *p; - int retval; - - if (argc != 3) + if (argc != 1 && argc != 3) { return ERROR_COMMAND_SYNTAX_ERROR; } - p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); + nand_device_t *p; + int retval = nand_command_get_device_by_num(cmd_ctx, args[0], &p); + if (ERROR_OK != retval) + return retval; + if (p) { - char *cp; unsigned long offset; unsigned long length; - offset = strtoul(args[1], &cp, 0); - if (*cp || offset == ULONG_MAX || offset % p->erase_size) - { - return ERROR_INVALID_ARGUMENTS; - } - offset /= p->erase_size; + /* erase specified part of the chip; or else everything */ + if (argc == 3) { + unsigned long size = p->erase_size * p->num_blocks; - length = strtoul(args[2], &cp, 0); - if (*cp || length == ULONG_MAX || length % p->erase_size) - { - return ERROR_INVALID_ARGUMENTS; + COMMAND_PARSE_NUMBER(ulong, args[1], offset); + if ((offset % p->erase_size) != 0 || offset >= size) + return ERROR_INVALID_ARGUMENTS; + + COMMAND_PARSE_NUMBER(ulong, args[2], length); + if ((length == 0) || (length % p->erase_size) != 0 + || (length + offset) > size) + return ERROR_INVALID_ARGUMENTS; + + offset /= p->erase_size; + length /= p->erase_size; + } else { + offset = 0; + length = p->num_blocks; } - length -= 1; - length /= p->erase_size; - retval = nand_erase(p, offset, offset + length); + retval = nand_erase(p, offset, offset + length - 1); 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); + command_print(cmd_ctx, "erased blocks %lu to %lu " + "on NAND flash device #%s '%s'", + offset, offset + length, + args[0], p->device->name); } else if (retval == ERROR_NAND_OPERATION_FAILED) { @@ -1235,18 +1270,12 @@ static int handle_nand_erase_command(struct command_context_s *cmd_ctx, char *cm command_print(cmd_ctx, "unknown error when erasing NAND flash device"); } } - else - { - command_print(cmd_ctx, "NAND flash device '#%s' is out of bounds", args[0]); - } return ERROR_OK; } int handle_nand_check_bad_blocks_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - nand_device_t *p; - int retval; int first = -1; int last = -1; @@ -1256,31 +1285,25 @@ int handle_nand_check_bad_blocks_command(struct command_context_s *cmd_ctx, char } - p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); - if (!p) { - command_print(cmd_ctx, "NAND flash device '#%s' is out of bounds", - args[0]); - return ERROR_INVALID_ARGUMENTS; - } + nand_device_t *p; + int retval = nand_command_get_device_by_num(cmd_ctx, args[0], &p); + if (ERROR_OK != retval) + return retval; if (argc == 3) { - char *cp; unsigned long offset; unsigned long length; - offset = strtoul(args[1], &cp, 0); - if (*cp || offset == ULONG_MAX || offset % p->erase_size) - { + COMMAND_PARSE_NUMBER(ulong, args[1], offset); + if (offset % p->erase_size) return ERROR_INVALID_ARGUMENTS; - } offset /= p->erase_size; - length = strtoul(args[2], &cp, 0); - if (*cp || length == ULONG_MAX || length % p->erase_size) - { + COMMAND_PARSE_NUMBER(ulong, args[2], length); + if (length % p->erase_size) return ERROR_INVALID_ARGUMENTS; - } + length -= 1; length /= p->erase_size; @@ -1310,9 +1333,9 @@ int handle_nand_check_bad_blocks_command(struct command_context_s *cmd_ctx, char static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - u32 offset; - u32 binary_size; - u32 buf_cnt; + uint32_t offset; + uint32_t binary_size; + uint32_t buf_cnt; enum oob_formats oob_format = NAND_OOB_NONE; fileio_t fileio; @@ -1320,24 +1343,25 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm 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)); + nand_device_t *p; + int retval = nand_command_get_device_by_num(cmd_ctx, args[0], &p); + if (ERROR_OK != retval) + return retval; + if (p) { uint8_t *page = NULL; - u32 page_size = 0; + uint32_t page_size = 0; uint8_t *oob = NULL; - u32 oob_size = 0; + uint32_t oob_size = 0; const int *eccpos = NULL; - offset = strtoul(args[2], NULL, 0); + COMMAND_PARSE_NUMBER(u32, args[2], offset); if (argc > 3) { @@ -1398,7 +1422,7 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm while (buf_cnt > 0) { - u32 size_read; + uint32_t size_read; if (NULL != page) { @@ -1412,11 +1436,11 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm if (oob_format & NAND_OOB_SW_ECC) { - u32 i, j; + uint32_t i, j; uint8_t ecc[3]; memset(oob, 0xff, oob_size); for (i = 0, j = 0; i < page_size; i += 256) { - nand_calculate_ecc(p, page+i, ecc); + nand_calculate_ecc(p, page + i, ecc); oob[eccpos[j++]] = ecc[0]; oob[eccpos[j++]] = ecc[1]; oob[eccpos[j++]] = ecc[2]; @@ -1429,11 +1453,11 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm * at the end of the OOB area. It consists * of 10 bytes per 512-byte data block. */ - u32 i; + uint32_t i; uint8_t *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); + nand_calculate_ecc_kw(p, page + i, ecc); ecc += 10; } } @@ -1449,7 +1473,7 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm 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", + command_print(cmd_ctx, "failed writing file %s to NAND flash %s at offset 0x%8.8" PRIx32 "", args[1], args[0], offset); fileio_close(&fileio); @@ -1467,29 +1491,27 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm oob = NULL; page = NULL; duration_stop_measure(&duration, &duration_text); - command_print(cmd_ctx, "wrote file %s to NAND flash %s up to offset 0x%8.8x in %s", + command_print(cmd_ctx, "wrote file %s to NAND flash %s up to offset 0x%8.8" PRIx32 " in %s", args[1], args[0], offset, duration_text); free(duration_text); duration_text = NULL; } - else - { - 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)); + nand_device_t *p; + int retval = nand_command_get_device_by_num(cmd_ctx, args[0], &p); + if (ERROR_OK != retval) + return retval; + if (p) { if (p->device) @@ -1500,12 +1522,14 @@ static int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd int retval; uint8_t *page = NULL; - u32 page_size = 0; + uint32_t page_size = 0; uint8_t *oob = NULL; - u32 oob_size = 0; - u32 address = strtoul(args[2], NULL, 0); - u32 size = strtoul(args[3], NULL, 0); - u32 bytes_done = 0; + uint32_t oob_size = 0; + uint32_t address; + COMMAND_PARSE_NUMBER(u32, args[2], address); + uint32_t size; + COMMAND_PARSE_NUMBER(u32, args[3], size); + uint32_t bytes_done = 0; enum oob_formats oob_format = NAND_OOB_NONE; if (argc > 4) @@ -1552,7 +1576,7 @@ static int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd while (size > 0) { - u32 size_written; + uint32_t size_written; if ((retval = nand_read_page(p, address / p->page_size, page, page_size, oob, oob_size)) != ERROR_OK) { command_print(cmd_ctx, "reading NAND flash page failed"); @@ -1594,24 +1618,22 @@ static int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd 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)); + nand_device_t *p; + int retval = nand_command_get_device_by_num(cmd_ctx, args[0], &p); + if (ERROR_OK != retval) + return retval; + if (p) { if (p->device) @@ -1639,10 +1661,6 @@ static int handle_nand_raw_access_command(struct command_context_s *cmd_ctx, cha 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; }