X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fflash%2Fnand.c;h=9cc08022783801e04f8b91e59fc34c1b5befedc7;hp=48f65206aae7caefb262064cad49ea9e83b2770c;hb=23cc85b307de80be089dcb0048dbb6168e59651a;hpb=2f6e56e38320350bb300b363d0b3737fa8d1f3ea diff --git a/src/flash/nand.c b/src/flash/nand.c index 48f65206aa..9cc0802278 100644 --- a/src/flash/nand.c +++ b/src/flash/nand.c @@ -62,7 +62,7 @@ static struct nand_flash_controller *nand_flash_controllers[] = /* configured NAND devices and NAND Flash command handler */ static struct nand_device *nand_devices = NULL; -static command_t *nand_cmd; +static struct command *nand_cmd; /* Chip ID list * @@ -279,7 +279,7 @@ COMMAND_HANDLER(handle_nand_device_command) return ERROR_OK; } -int nand_register_commands(struct command_context_s *cmd_ctx) +int nand_register_commands(struct command_context *cmd_ctx) { nand_cmd = register_command(cmd_ctx, NULL, "nand", NULL, COMMAND_ANY, "NAND specific commands"); @@ -304,7 +304,7 @@ struct nand_device *get_nand_device_by_num(int num) return NULL; } -int nand_command_get_device_by_num(struct command_context_s *cmd_ctx, +int nand_command_get_device_by_num(struct command_context *cmd_ctx, const char *str, struct nand_device **nand) { unsigned num; @@ -1285,6 +1285,222 @@ COMMAND_HANDLER(handle_nand_check_bad_blocks_command) return ERROR_OK; } +struct nand_fileio_state { + uint32_t address; + uint32_t size; + + uint8_t *page; + uint32_t page_size; + + enum oob_formats oob_format; + uint8_t *oob; + uint32_t oob_size; + + const int *eccpos; + + bool file_opened; + struct fileio fileio; + + struct duration bench; +}; + +static void nand_fileio_init(struct nand_fileio_state *state) +{ + memset(state, 0, sizeof(*state)); + state->oob_format = NAND_OOB_NONE; +} + +static int nand_fileio_start(struct command_context *cmd_ctx, + struct nand_device *nand, const char *filename, int filemode, + struct nand_fileio_state *state) +{ + if (state->address % nand->page_size) + { + command_print(cmd_ctx, "only page-aligned addresses are supported"); + return ERROR_COMMAND_SYNTAX_ERROR; + } + + duration_start(&state->bench); + + if (NULL != filename) + { + int retval = fileio_open(&state->fileio, filename, filemode, FILEIO_BINARY); + if (ERROR_OK != retval) + { + const char *msg = (FILEIO_READ == filemode) ? "read" : "write"; + command_print(cmd_ctx, "failed to open '%s' for %s access", + filename, msg); + return retval; + } + state->file_opened = true; + } + + if (!(state->oob_format & NAND_OOB_ONLY)) + { + state->page_size = nand->page_size; + state->page = malloc(nand->page_size); + } + + if (state->oob_format & (NAND_OOB_RAW | NAND_OOB_SW_ECC | NAND_OOB_SW_ECC_KW)) + { + if (nand->page_size == 512) + { + state->oob_size = 16; + state->eccpos = nand_oob_16.eccpos; + } + else if (nand->page_size == 2048) + { + state->oob_size = 64; + state->eccpos = nand_oob_64.eccpos; + } + state->oob = malloc(state->oob_size); + } + + return ERROR_OK; +} +static int nand_fileio_cleanup(struct nand_fileio_state *state) +{ + if (state->file_opened) + fileio_close(&state->fileio); + + if (state->oob) + { + free(state->oob); + state->oob = NULL; + } + if (state->page) + { + free(state->page); + state->page = NULL; + } + return ERROR_OK; +} +int nand_fileio_finish(struct nand_fileio_state *state) +{ + nand_fileio_cleanup(state); + return duration_measure(&state->bench); +} + +COMMAND_HELPER(nand_fileio_parse_args, struct nand_fileio_state *state, + struct nand_device **dev, enum fileio_access filemode, + bool need_size, bool sw_ecc) +{ + nand_fileio_init(state); + + unsigned minargs = need_size ? 4 : 3; + if (argc < minargs) + return ERROR_COMMAND_SYNTAX_ERROR; + + struct nand_device *nand; + int retval = nand_command_get_device_by_num(cmd_ctx, args[0], &nand); + if (ERROR_OK != retval) + return retval; + + if (NULL == nand->device) + { + command_print(cmd_ctx, "#%s: not probed", args[0]); + return ERROR_OK; + } + + COMMAND_PARSE_NUMBER(u32, args[2], state->address); + if (need_size) + { + COMMAND_PARSE_NUMBER(u32, args[2], state->size); + if (state->size % nand->page_size) + { + command_print(cmd_ctx, "only page-aligned sizes are supported"); + return ERROR_COMMAND_SYNTAX_ERROR; + } + } + + if (argc > minargs) + { + for (unsigned i = minargs; i < argc; i++) + { + if (!strcmp(args[i], "oob_raw")) + state->oob_format |= NAND_OOB_RAW; + else if (!strcmp(args[i], "oob_only")) + state->oob_format |= NAND_OOB_RAW | NAND_OOB_ONLY; + else if (sw_ecc && !strcmp(args[i], "oob_softecc")) + state->oob_format |= NAND_OOB_SW_ECC; + else if (sw_ecc && !strcmp(args[i], "oob_softecc_kw")) + state->oob_format |= NAND_OOB_SW_ECC_KW; + else + { + command_print(cmd_ctx, "unknown option: %s", args[i]); + return ERROR_COMMAND_SYNTAX_ERROR; + } + } + } + + retval = nand_fileio_start(cmd_ctx, nand, args[1], filemode, state); + if (ERROR_OK != retval) + return retval; + + if (!need_size) + state->size = state->fileio.size; + + *dev = nand; + + return ERROR_OK; +} + +/** + * @returns If no error occurred, returns number of bytes consumed; + * otherwise, returns a negative error code.) + */ +int nand_fileio_read(struct nand_device *nand, + struct nand_fileio_state *s) +{ + uint32_t total_read = 0; + uint32_t one_read; + + if (NULL != s->page) + { + fileio_read(&s->fileio, s->page_size, s->page, &one_read); + if (one_read < s->page_size) + memset(s->page + one_read, 0xff, s->page_size - one_read); + total_read += one_read; + } + + if (s->oob_format & NAND_OOB_SW_ECC) + { + uint8_t ecc[3]; + memset(s->oob, 0xff, s->oob_size); + for (uint32_t i = 0, j = 0; i < s->page_size; i += 256) + { + nand_calculate_ecc(nand, s->page + i, ecc); + s->oob[s->eccpos[j++]] = ecc[0]; + s->oob[s->eccpos[j++]] = ecc[1]; + s->oob[s->eccpos[j++]] = ecc[2]; + } + } + else if (s->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. + */ + uint8_t *ecc = s->oob + s->oob_size - s->page_size / 512 * 10; + memset(s->oob, 0xff, s->oob_size); + for (uint32_t i = 0; i < s->page_size; i += 512) + { + nand_calculate_ecc_kw(nand, s->page + i, ecc); + ecc += 10; + } + } + else if (NULL != s->oob) + { + fileio_read(&s->fileio, s->oob_size, s->oob, &one_read); + if (one_read < s->oob_size) + memset(s->oob + one_read, 0xff, s->oob_size - one_read); + total_read += one_read; + } + return total_read; +} + COMMAND_HANDLER(handle_nand_write_command) { uint32_t offset; @@ -1602,7 +1818,7 @@ COMMAND_HANDLER(handle_nand_raw_access_command) return ERROR_OK; } -int nand_init(struct command_context_s *cmd_ctx) +int nand_init(struct command_context *cmd_ctx) { if (!nand_devices) return ERROR_OK;