X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fflash%2Fnand.c;h=8efed037c6073153fea0a4edf8ab0ee8340b8fbe;hb=7d81ab69e192e0f89f67007e70e878e5987d598a;hp=d06a232cc948339ba1ad51b654da0ebd101794de;hpb=4b97f3cbb9603c13f69f8d3b5371c12045593126;p=openocd.git diff --git a/src/flash/nand.c b/src/flash/nand.c index d06a232cc9..8efed037c6 100644 --- a/src/flash/nand.c +++ b/src/flash/nand.c @@ -2,10 +2,8 @@ * Copyright (C) 2007 by Dominic Rath * * Dominic.Rath@gmx.de * * * - * partially based on * - * drivers/mtd/nand_ids.c * - * * - * Copyright (C) 2002 Thomas Gleixner (tglx@linutronix.de) * + * Partially based on drivers/mtd/nand_ids.c from Linux. * + * Copyright (C) 2002 Thomas Gleixner * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * @@ -26,56 +24,54 @@ #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" -int nand_register_commands(struct command_context_s *cmd_ctx); -int handle_nand_list_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_nand_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_nand_check_bad_blocks_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_nand_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_nand_copy_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_nand_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +#include + -int handle_nand_raw_access_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +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); -int nand_read_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_size); -int nand_read_page(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_size); -int nand_read_plain(struct nand_device_s *device, u32 address, u8 *data, u32 data_size); +static int handle_nand_raw_access_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int nand_write_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_size); -int nand_write_page(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_size); +static int nand_read_page(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_size); +//static int nand_read_plain(struct nand_device_s *device, u32 address, u8 *data, u32 data_size); + +static int nand_write_page(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_size); /* NAND flash controller */ extern nand_flash_controller_t lpc3180_nand_controller; -/* extern nand_flash_controller_t s3c2410_nand_controller; */ +extern nand_flash_controller_t orion_nand_controller; +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 boundary_scan_nand_controller; */ -nand_flash_controller_t *nand_flash_controllers[] = +static nand_flash_controller_t *nand_flash_controllers[] = { &lpc3180_nand_controller, -/* &s3c2410_nand_controller, */ + &orion_nand_controller, + &s3c2410_nand_controller, + &s3c2412_nand_controller, + &s3c2440_nand_controller, + &s3c2443_nand_controller, /* &boundary_scan_nand_controller, */ NULL }; /* configured NAND devices and NAND Flash command handler */ -nand_device_t *nand_devices = NULL; +static nand_device_t *nand_devices = NULL; static command_t *nand_cmd; /* Chip ID list @@ -88,7 +84,7 @@ static command_t *nand_cmd; * 256 256 Byte page size * 512 512 Byte page size */ -nand_info_t nand_flash_ids[] = +static nand_info_t nand_flash_ids[] = { {"NAND 1MiB 5V 8-bit", 0x6e, 256, 1, 0x1000, 0}, {"NAND 2MiB 5V 8-bit", 0x64, 256, 2, 0x1000, 0}, @@ -161,12 +157,12 @@ 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 */ -nand_manufacturer_t nand_manuf_ids[] = +static nand_manufacturer_t nand_manuf_ids[] = { {0x0, "unknown"}, {NAND_MFR_TOSHIBA, "Toshiba"}, @@ -179,16 +175,51 @@ nand_manufacturer_t nand_manuf_ids[] = {0x0, NULL}, }; +/* + * Define default oob placement schemes for large and small page devices + */ + +#if 0 +static nand_ecclayout_t nand_oob_8 = { + .eccbytes = 3, + .eccpos = {0, 1, 2}, + .oobfree = { + {.offset = 3, + .length = 2}, + {.offset = 6, + .length = 2}} +}; +#endif + +static nand_ecclayout_t nand_oob_16 = { + .eccbytes = 6, + .eccpos = {0, 1, 2, 3, 6, 7}, + .oobfree = { + {.offset = 8, + . length = 8}} +}; + +static nand_ecclayout_t nand_oob_64 = { + .eccbytes = 24, + .eccpos = { + 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63}, + .oobfree = { + {.offset = 2, + .length = 38}} +}; + /* nand device [controller options] */ -int handle_nand_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static int handle_nand_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { int i; int retval; if (argc < 1) { - WARNING("incomplete flash device nand configuration"); + LOG_WARNING("incomplete flash device nand configuration"); return ERROR_FLASH_BANK_INVALID; } @@ -199,10 +230,10 @@ int handle_nand_device_command(struct command_context_s *cmd_ctx, char *cmd, cha if (strcmp(args[0], nand_flash_controllers[i]->name) == 0) { /* register flash specific commands */ - if (nand_flash_controllers[i]->register_commands(cmd_ctx) != ERROR_OK) + if ((retval = nand_flash_controllers[i]->register_commands(cmd_ctx)) != ERROR_OK) { - ERROR("couldn't register '%s' commands", args[0]); - exit(-1); + LOG_ERROR("couldn't register '%s' commands", args[0]); + return retval; } c = malloc(sizeof(nand_device_t)); @@ -219,7 +250,7 @@ int handle_nand_device_command(struct command_context_s *cmd_ctx, char *cmd, cha if ((retval = nand_flash_controllers[i]->nand_device_command(cmd_ctx, cmd, args, argc, c)) != ERROR_OK) { - ERROR("'%s' driver rejected nand flash", c->controller->name); + LOG_ERROR("'%s' driver rejected nand flash", c->controller->name); free(c); return ERROR_OK; } @@ -244,11 +275,11 @@ int handle_nand_device_command(struct command_context_s *cmd_ctx, char *cmd, cha /* no valid NAND controller was found (i.e. the configuration option, * didn't match one of the compiled-in controllers) */ - ERROR("No valid NAND flash controller found (%s)", args[0]); - ERROR("compiled-in NAND flash controllers:"); + LOG_ERROR("No valid NAND flash controller found (%s)", args[0]); + LOG_ERROR("compiled-in NAND flash controllers:"); for (i = 0; nand_flash_controllers[i]; i++) { - ERROR("%i: %s", i, nand_flash_controllers[i]->name); + LOG_ERROR("%i: %s", i, nand_flash_controllers[i]->name); } return ERROR_OK; @@ -256,7 +287,7 @@ int handle_nand_device_command(struct command_context_s *cmd_ctx, char *cmd, cha int nand_register_commands(struct command_context_s *cmd_ctx) { - nand_cmd = register_command(cmd_ctx, NULL, "nand", NULL, COMMAND_ANY, NULL); + 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); @@ -282,7 +313,7 @@ int nand_init(struct command_context_s *cmd_ctx) register_command(cmd_ctx, nand_cmd, "dump", handle_nand_dump_command, COMMAND_EXEC, "dump from NAND flash device [options]"); register_command(cmd_ctx, nand_cmd, "write", handle_nand_write_command, COMMAND_EXEC, - "write to NAND flash device [options]"); + "write to NAND flash device [oob_raw|oob_only|oob_softecc]"); register_command(cmd_ctx, nand_cmd, "raw_access", handle_nand_raw_access_command, COMMAND_EXEC, "raw access to NAND flash device ['enable'|'disable']"); } @@ -306,13 +337,11 @@ nand_device_t *get_nand_device_by_num(int num) return NULL; } -int nand_build_bbt(struct nand_device_s *device, int first, int last) +static int nand_build_bbt(struct nand_device_s *device, int first, int last) { u32 page = 0x0; int i; - u8 *oob; - - oob = malloc(6); + u8 oob[6]; if ((first < 0) || (first >= device->num_blocks)) first = 0; @@ -328,7 +357,7 @@ int nand_build_bbt(struct nand_device_s *device, int first, int last) || (((device->page_size == 512) && (oob[5] != 0xff)) || ((device->page_size == 2048) && (oob[0] != 0xff)))) { - WARNING("invalid block: %i", i); + LOG_WARNING("invalid block: %i", i); device->blocks[i].is_bad = 1; } else @@ -350,7 +379,7 @@ int nand_read_status(struct nand_device_s *device, u8 *status) /* Send read status command */ device->controller->command(device, NAND_CMD_STATUS); - usleep(1000); + alive_sleep(1); /* read status */ if (device->device->options & NAND_BUSWIDTH_16) @@ -367,9 +396,31 @@ int nand_read_status(struct nand_device_s *device, u8 *status) return ERROR_OK; } +static int nand_poll_ready(struct nand_device_s *device, int timeout) +{ + u8 status; + + device->controller->command(device, NAND_CMD_STATUS); + do { + if (device->device->options & NAND_BUSWIDTH_16) { + u16 data; + device->controller->read_data(device, &data); + status = data & 0xff; + } else { + device->controller->read_data(device, &status); + } + if (status & NAND_STATUS_READY) + break; + alive_sleep(1); + } while (timeout--); + + return (status & NAND_STATUS_READY) != 0; +} + int nand_probe(struct nand_device_s *device) { u8 manufacturer_id, device_id; + u8 id_buff[6]; int retval; int i; @@ -389,13 +440,13 @@ int nand_probe(struct nand_device_s *device) switch (retval) { case ERROR_NAND_OPERATION_FAILED: - DEBUG("controller initialization failed"); + LOG_DEBUG("controller initialization failed"); return ERROR_NAND_OPERATION_FAILED; case ERROR_NAND_OPERATION_NOT_SUPPORTED: - ERROR("BUG: controller reported that it doesn't support default parameters"); + LOG_ERROR("BUG: controller reported that it doesn't support default parameters"); return ERROR_NAND_OPERATION_FAILED; default: - ERROR("BUG: unknown controller initialization failure"); + LOG_ERROR("BUG: unknown controller initialization failure"); return ERROR_NAND_OPERATION_FAILED; } } @@ -446,12 +497,12 @@ int nand_probe(struct nand_device_s *device) if (!device->device) { - ERROR("unknown NAND flash device found, manufacturer id: 0x%2.2x device id: 0x%2.2x", + 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; } - DEBUG("found %s (%s)", device->device->name, device->manufacturer->name); + LOG_DEBUG("found %s (%s)", device->device->name, device->manufacturer->name); /* initialize device parameters */ @@ -460,16 +511,40 @@ int nand_probe(struct nand_device_s *device) device->bus_width = 16; else device->bus_width = 8; + + /* Do we need extended device probe information? */ + if (device->device->page_size == 0 || + device->device->erase_size == 0) + { + 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); + } + else + { + u16 data_buf; + + device->controller->read_data(device, &data_buf); + id_buff[3] = data_buf; + + device->controller->read_data(device, &data_buf); + id_buff[4] = data_buf; + + device->controller->read_data(device, &data_buf); + id_buff[5] = data_buf >> 8; + } + } /* page size */ if (device->device->page_size == 0) { - /* TODO: support reading extended chip id to determine page size */ - return ERROR_NAND_OPERATION_FAILED; + device->page_size = 1 << (10 + (id_buff[4] & 3)); } else if (device->device->page_size == 256) { - ERROR("NAND flashes with 256 byte pagesize are not supported"); + LOG_ERROR("NAND flashes with 256 byte pagesize are not supported"); return ERROR_NAND_OPERATION_FAILED; } else @@ -487,7 +562,7 @@ int nand_probe(struct nand_device_s *device) device->address_cycles = 4; else { - ERROR("BUG: small page NAND device with more than 8 GiB encountered"); + LOG_ERROR("BUG: small page NAND device with more than 8 GiB encountered"); device->address_cycles = 5; } } @@ -500,7 +575,7 @@ int nand_probe(struct nand_device_s *device) device->address_cycles = 5; else { - ERROR("BUG: small page NAND device with more than 32 GiB encountered"); + LOG_ERROR("BUG: large page NAND device with more than 32 GiB encountered"); device->address_cycles = 6; } } @@ -508,7 +583,20 @@ int nand_probe(struct nand_device_s *device) /* erase size */ if (device->device->erase_size == 0) { - /* TODO: support reading extended chip id to determine erase size */ + switch ((id_buff[4] >> 4) & 3) { + case 0: + device->erase_size = 64 << 10; + break; + case 1: + device->erase_size = 128 << 10; + break; + case 2: + device->erase_size = 256 << 10; + break; + case 3: + device->erase_size =512 << 10; + break; + } } else { @@ -521,14 +609,14 @@ int nand_probe(struct nand_device_s *device) switch (retval) { case ERROR_NAND_OPERATION_FAILED: - DEBUG("controller initialization failed"); + LOG_DEBUG("controller initialization failed"); return ERROR_NAND_OPERATION_FAILED; case ERROR_NAND_OPERATION_NOT_SUPPORTED: - ERROR("controller doesn't support requested parameters (buswidth: %i, address cycles: %i, page size: %i)", + LOG_ERROR("controller doesn't support requested parameters (buswidth: %i, address cycles: %i, page size: %i)", device->bus_width, device->address_cycles, device->page_size); return ERROR_NAND_OPERATION_FAILED; default: - ERROR("BUG: unknown controller initialization failure"); + LOG_ERROR("BUG: unknown controller initialization failure"); return ERROR_NAND_OPERATION_FAILED; } } @@ -605,30 +693,35 @@ int nand_erase(struct nand_device_s *device, int first_block, int last_block) /* Send erase confirm command */ device->controller->command(device, NAND_CMD_ERASE2); - - if (!device->controller->nand_ready(device, 1000)) - { - ERROR("timeout waiting for NAND flash block erase to complete"); + + retval = device->controller->nand_ready ? + device->controller->nand_ready(device, 1000) : + nand_poll_ready(device, 1000); + if (!retval) { + 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) { - ERROR("couldn't read status"); + LOG_ERROR("couldn't read status"); return ERROR_NAND_OPERATION_FAILED; } if (status & 0x1) { - ERROR("erase operation didn't pass, status: 0x%2.2x", status); + LOG_ERROR("erase operation didn't pass, status: 0x%2.2x", status); return ERROR_NAND_OPERATION_FAILED; } + + device->blocks[i].is_erased = 1; } return ERROR_OK; } -int nand_read_plain(struct nand_device_s *device, u32 address, u8 *data, u32 data_size) +#if 0 +static int nand_read_plain(struct nand_device_s *device, u32 address, u8 *data, u32 data_size) { u8 *page; @@ -637,7 +730,7 @@ int nand_read_plain(struct nand_device_s *device, u32 address, u8 *data, u32 dat if (address % device->page_size) { - ERROR("reads need to be page aligned"); + LOG_ERROR("reads need to be page aligned"); return ERROR_NAND_OPERATION_FAILED; } @@ -665,7 +758,7 @@ int nand_read_plain(struct nand_device_s *device, u32 address, u8 *data, u32 dat return ERROR_OK; } -int nand_write_plain(struct nand_device_s *device, u32 address, u8 *data, u32 data_size) +static int nand_write_plain(struct nand_device_s *device, u32 address, u8 *data, u32 data_size) { u8 *page; @@ -674,7 +767,7 @@ int nand_write_plain(struct nand_device_s *device, u32 address, u8 *data, u32 da if (address % device->page_size) { - ERROR("writes need to be page aligned"); + LOG_ERROR("writes need to be page aligned"); return ERROR_NAND_OPERATION_FAILED; } @@ -701,24 +794,31 @@ int nand_write_plain(struct nand_device_s *device, u32 address, u8 *data, u32 da return ERROR_OK; } +#endif int nand_write_page(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_size) { + u32 block; + if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; - if (device->use_raw) + block = page / (device->erase_size / device->page_size); + if (device->blocks[block].is_erased == 1) + device->blocks[block].is_erased = 0; + + if (device->use_raw || device->controller->write_page == NULL) return nand_write_page_raw(device, page, data, data_size, oob, oob_size); else return device->controller->write_page(device, page, data, data_size, oob, oob_size); } -int nand_read_page(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_size) +static int nand_read_page(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_size) { if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; - if (device->use_raw) + if (device->use_raw || device->controller->read_page == NULL) return nand_read_page_raw(device, page, data, data_size, oob, oob_size); else return device->controller->read_page(device, page, data, data_size, oob, oob_size); @@ -726,7 +826,7 @@ int nand_read_page(struct nand_device_s *device, u32 page, u8 *data, u32 data_si int nand_read_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_size) { - int i; + u32 i; if (!device->device) return ERROR_NAND_DEVICE_NOT_PROBED; @@ -763,7 +863,10 @@ int nand_read_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 dat * or 2048 for the beginning of OOB area) */ device->controller->address(device, 0x0); - device->controller->address(device, 0x8); + if (data) + device->controller->address(device, 0x0); + else + device->controller->address(device, 0x8); /* row */ device->controller->address(device, page & 0xff); @@ -777,43 +880,57 @@ int nand_read_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 dat device->controller->command(device, NAND_CMD_READSTART); } - if (!device->controller->nand_ready(device, 100)) - return ERROR_NAND_OPERATION_TIMEOUT; + if (device->controller->nand_ready) { + if (!device->controller->nand_ready(device, 100)) + return ERROR_NAND_OPERATION_TIMEOUT; + } else { + alive_sleep(1); + } if (data) { - for (i = 0; i < data_size;) + if (device->controller->read_block_data != NULL) + (device->controller->read_block_data)(device, data, data_size); + else { - if (device->device->options & NAND_BUSWIDTH_16) - { - device->controller->read_data(device, data); - data += 2; - i += 2; - } - else + for (i = 0; i < data_size;) { - device->controller->read_data(device, data); - data += 1; - i += 1; + if (device->device->options & NAND_BUSWIDTH_16) + { + device->controller->read_data(device, data); + data += 2; + i += 2; + } + else + { + device->controller->read_data(device, data); + data += 1; + i += 1; + } } } } if (oob) { - for (i = 0; i < oob_size;) + if (device->controller->read_block_data != NULL) + (device->controller->read_block_data)(device, oob, oob_size); + else { - if (device->device->options & NAND_BUSWIDTH_16) + for (i = 0; i < oob_size;) { - device->controller->read_data(device, oob); - oob += 2; - i += 2; - } - else - { - device->controller->read_data(device, oob); - oob += 1; - i += 1; + if (device->device->options & NAND_BUSWIDTH_16) + { + device->controller->read_data(device, oob); + oob += 2; + i += 2; + } + else + { + device->controller->read_data(device, oob); + oob += 1; + i += 1; + } } } } @@ -823,7 +940,7 @@ int nand_read_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 dat int nand_write_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_size) { - int i; + u32 i; int retval; u8 status; @@ -855,7 +972,10 @@ int nand_write_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 da * or 2048 for the beginning of OOB area) */ device->controller->address(device, 0x0); - device->controller->address(device, 0x8); + if (data) + device->controller->address(device, 0x0); + else + device->controller->address(device, 0x8); /* row */ device->controller->address(device, page & 0xff); @@ -868,58 +988,71 @@ int nand_write_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 da if (data) { - for (i = 0; i < data_size;) + if (device->controller->write_block_data != NULL) + (device->controller->write_block_data)(device, data, data_size); + else { - if (device->device->options & NAND_BUSWIDTH_16) + for (i = 0; i < data_size;) { - u16 data_buf = le_to_h_u16(data); - device->controller->write_data(device, data_buf); - data += 2; - i += 2; - } - else - { - device->controller->write_data(device, *data); - data += 1; - i += 1; + if (device->device->options & NAND_BUSWIDTH_16) + { + u16 data_buf = le_to_h_u16(data); + device->controller->write_data(device, data_buf); + data += 2; + i += 2; + } + else + { + device->controller->write_data(device, *data); + data += 1; + i += 1; + } } } } if (oob) { - for (i = 0; i < oob_size;) + if (device->controller->write_block_data != NULL) + (device->controller->write_block_data)(device, oob, oob_size); + else { - if (device->device->options & NAND_BUSWIDTH_16) - { - u16 oob_buf = le_to_h_u16(data); - device->controller->write_data(device, oob_buf); - oob += 2; - i += 2; - } - else + for (i = 0; i < oob_size;) { - device->controller->write_data(device, *oob); - oob += 1; - i += 1; + if (device->device->options & NAND_BUSWIDTH_16) + { + u16 oob_buf = le_to_h_u16(data); + device->controller->write_data(device, oob_buf); + oob += 2; + i += 2; + } + else + { + device->controller->write_data(device, *oob); + oob += 1; + i += 1; + } } } } device->controller->command(device, NAND_CMD_PAGEPROG); - if (!device->controller->nand_ready(device, 100)) + 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) { - ERROR("couldn't read status"); + LOG_ERROR("couldn't read status"); return ERROR_NAND_OPERATION_FAILED; } if (status & NAND_STATUS_FAIL) { - ERROR("write operation didn't pass, status: 0x%2.2x", status); + LOG_ERROR("write operation didn't pass, status: 0x%2.2x", status); return ERROR_NAND_OPERATION_FAILED; } @@ -949,7 +1082,7 @@ int handle_nand_list_command(struct command_context_s *cmd_ctx, char *cmd, char return ERROR_OK; } -int handle_nand_info_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) { nand_device_t *p; int i = 0; @@ -959,8 +1092,8 @@ int handle_nand_info_command(struct command_context_s *cmd_ctx, char *cmd, char if ((argc < 1) || (argc > 3)) { - command_print(cmd_ctx, "usage: nand info [ ]"); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; + } if (argc == 2) @@ -1019,15 +1152,14 @@ int handle_nand_info_command(struct command_context_s *cmd_ctx, char *cmd, char return ERROR_OK; } -int handle_nand_probe_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) { nand_device_t *p; int retval; if (argc != 1) { - command_print(cmd_ctx, "usage: nand probe "); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); @@ -1054,15 +1186,15 @@ int handle_nand_probe_command(struct command_context_s *cmd_ctx, char *cmd, char return ERROR_OK; } -int handle_nand_erase_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) { nand_device_t *p; int retval; if (argc != 3) { - command_print(cmd_ctx, "usage: nand erase "); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; + } p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); @@ -1101,8 +1233,8 @@ int handle_nand_check_bad_blocks_command(struct command_context_s *cmd_ctx, char if ((argc < 1) || (argc > 3) || (argc == 2)) { - command_print(cmd_ctx, "usage: nand check_bad_blocks [ ]"); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; + } if (argc == 3) @@ -1135,14 +1267,14 @@ int handle_nand_check_bad_blocks_command(struct command_context_s *cmd_ctx, char return ERROR_OK; } -int handle_nand_copy_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) { nand_device_t *p; if (argc != 4) { - command_print(cmd_ctx, "usage: nand copy "); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; + } p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); @@ -1158,7 +1290,7 @@ int handle_nand_copy_command(struct command_context_s *cmd_ctx, char *cmd, char return ERROR_OK; } -int handle_nand_write_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) { u32 offset; u32 binary_size; @@ -1174,8 +1306,8 @@ int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cmd, char if (argc < 3) { - command_print(cmd_ctx, "usage: nand write [options]"); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; + } p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); @@ -1185,8 +1317,8 @@ int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cmd, char u32 page_size = 0; u8 *oob = NULL; u32 oob_size = 0; + const int *eccpos = NULL; - duration_start_measure(&duration); offset = strtoul(args[2], NULL, 0); if (argc > 3) @@ -1198,16 +1330,20 @@ int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cmd, char oob_format |= NAND_OOB_RAW; else if (!strcmp(args[i], "oob_only")) oob_format |= NAND_OOB_RAW | NAND_OOB_ONLY; + else if (!strcmp(args[i], "oob_softecc")) + oob_format |= NAND_OOB_SW_ECC; else { command_print(cmd_ctx, "unknown option: %s", args[i]); + return ERROR_COMMAND_SYNTAX_ERROR; } } } + duration_start_measure(&duration); + if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK) { - command_print(cmd_ctx, "file open error: %s", fileio.error_str); return ERROR_OK; } @@ -1219,18 +1355,24 @@ int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cmd, char page = malloc(p->page_size); } - if (oob_format & NAND_OOB_RAW) + if (oob_format & (NAND_OOB_RAW | NAND_OOB_SW_ECC)) { - if (p->page_size == 512) + if (p->page_size == 512) { oob_size = 16; - else if (p->page_size == 2048) + eccpos = nand_oob_16.eccpos; + } else if (p->page_size == 2048) { oob_size = 64; + eccpos = nand_oob_64.eccpos; + } oob = malloc(oob_size); } if (offset % p->page_size) { command_print(cmd_ctx, "only page size aligned offsets and sizes are supported"); + fileio_close(&fileio); + free(oob); + free(page); return ERROR_OK; } @@ -1238,7 +1380,7 @@ int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cmd, char { u32 size_read; - if (page) + if (NULL != page) { fileio_read(&fileio, page_size, page, &size_read); buf_cnt -= size_read; @@ -1247,8 +1389,20 @@ int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cmd, char memset(page + size_read, 0xff, page_size - size_read); } } - - if (oob) + + if (oob_format & NAND_OOB_SW_ECC) + { + u32 i, j; + u8 ecc[3]; + memset(oob, 0xff, oob_size); + for (i = 0, j = 0; i < page_size; i += 256) { + nand_calculate_ecc(p, page+i, ecc); + oob[eccpos[j++]] = ecc[0]; + oob[eccpos[j++]] = ecc[1]; + oob[eccpos[j++]] = ecc[2]; + } + } + else if (NULL != oob) { fileio_read(&fileio, oob_size, oob, &size_read); buf_cnt -= size_read; @@ -1262,17 +1416,26 @@ int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cmd, char { command_print(cmd_ctx, "failed writing file %s to NAND flash %s at offset 0x%8.8x", args[1], args[0], offset); + + fileio_close(&fileio); + free(oob); + free(page); + return ERROR_OK; } offset += page_size; } fileio_close(&fileio); - + free(oob); + free(page); + oob = NULL; + page = NULL; duration_stop_measure(&duration, &duration_text); - command_print(cmd_ctx, "wrote file %s to NAND flash %s at offset 0x%8.8x in %s", + command_print(cmd_ctx, "wrote file %s to NAND flash %s up to offset 0x%8.8x in %s", args[1], args[0], offset, duration_text); free(duration_text); + duration_text = NULL; } else { @@ -1282,14 +1445,13 @@ int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cmd, char return ERROR_OK; } -int handle_nand_dump_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) { nand_device_t *p; if (argc < 4) { - command_print(cmd_ctx, "usage: nand dump
[options]"); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); @@ -1348,7 +1510,6 @@ int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd, char if (fileio_open(&fileio, args[1], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK) { - command_print(cmd_ctx, "dump_image error: %s", fileio.error_str); return ERROR_OK; } @@ -1360,16 +1521,19 @@ int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd, char 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"); + free(page); + free(oob); + fileio_close(&fileio); return ERROR_OK; } - if (page) + if (NULL != page) { fileio_write(&fileio, page_size, page, &size_written); bytes_done += page_size; } - if (oob) + if (NULL != oob) { fileio_write(&fileio, oob_size, oob, &size_written); bytes_done += oob_size; @@ -1379,17 +1543,16 @@ int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd, char address += p->page_size; } - if (page) - free(page); - - if (oob) - free(oob); - + free(page); + page = NULL; + free(oob); + oob = NULL; fileio_close(&fileio); duration_stop_measure(&duration, &duration_text); command_print(cmd_ctx, "dumped %"PRIi64" byte in %s", fileio.size, duration_text); free(duration_text); + duration_text = NULL; } else { @@ -1404,14 +1567,13 @@ int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd, char return ERROR_OK; } -int handle_nand_raw_access_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +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)) { - command_print(cmd_ctx, "usage: nand raw_access ['enable'|'disable']"); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } p = get_nand_device_by_num(strtoul(args[0], NULL, 0)); @@ -1431,7 +1593,7 @@ int handle_nand_raw_access_command(struct command_context_s *cmd_ctx, char *cmd, } else { - command_print(cmd_ctx, "usage: nand raw_access ['enable'|disable']"); + return ERROR_COMMAND_SYNTAX_ERROR; } } @@ -1449,4 +1611,3 @@ int handle_nand_raw_access_command(struct command_context_s *cmd_ctx, char *cmd, return ERROR_OK; } -