Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Transform 'u16' to 'uint16_t'
[openocd.git] / src / flash / nand.c
diff --git a/src/flash/nand.c b/src/flash/nand.c
index bc15f42a4dc0db6f49d38a279a52f6eb1436b2a3..192565f7e35395f949850c1cd1b610ccdf47a216 100644 (file)
--- a/src/flash/nand.c
+++ b/src/flash/nand.c
@@ -28,9 +28,6 @@
 #include "time_support.h"
 #include "fileio.h"
 
-#include <inttypes.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);
@@ -41,13 +38,14 @@ 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, 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_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_write_page(struct nand_device_s *device, u32 page, u8 *data, u32 data_size, u8 *oob, u32 oob_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);
 
 /* 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;
@@ -59,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,
@@ -307,12 +306,12 @@ 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 <num>");
                register_command(cmd_ctx, nand_cmd, "check_bad_blocks", handle_nand_check_bad_blocks_command, COMMAND_EXEC,
-                                                "check NAND flash device <num> for bad blocks [<first> <last>]");
+                                                "check NAND flash device <num> for bad blocks [<offset> <length>]");
                register_command(cmd_ctx, nand_cmd, "erase", handle_nand_erase_command, COMMAND_EXEC,
-                                                "erase blocks on NAND flash device <num> <first> <last>");
+                                                "erase blocks on NAND flash device <num> <offset> <length>");
                register_command(cmd_ctx, nand_cmd, "dump", handle_nand_dump_command, COMMAND_EXEC,
                                                 "dump from NAND flash device <num> <filename> "
-                                                "<offset> <size> [oob_raw|oob_only]");
+                                                "<offset> <length> [oob_raw|oob_only]");
                register_command(cmd_ctx, nand_cmd, "write", handle_nand_write_command, COMMAND_EXEC,
                                                 "write to NAND flash device <num> <filename> <offset> [oob_raw|oob_only|oob_softecc|oob_softecc_kw]");
                register_command(cmd_ctx, nand_cmd, "raw_access", handle_nand_raw_access_command, COMMAND_EXEC,
@@ -342,7 +341,7 @@ static int nand_build_bbt(struct nand_device_s *device, int first, int last)
 {
        u32 page = 0x0;
        int i;
-       u8 oob[6];
+       uint8_t oob[6];
 
        if ((first < 0) || (first >= device->num_blocks))
                first = 0;
@@ -358,7 +357,7 @@ static 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))))
                {
-                       LOG_WARNING("invalid block: %i", i);
+                       LOG_WARNING("bad block: %i", i);
                        device->blocks[i].is_bad = 1;
                }
                else
@@ -372,7 +371,7 @@ static int nand_build_bbt(struct nand_device_s *device, int first, int last)
        return ERROR_OK;
 }
 
-int nand_read_status(struct nand_device_s *device, u8 *status)
+int nand_read_status(struct nand_device_s *device, uint8_t *status)
 {
        if (!device->device)
                return ERROR_NAND_DEVICE_NOT_PROBED;
@@ -385,7 +384,7 @@ int nand_read_status(struct nand_device_s *device, u8 *status)
        /* read status */
        if (device->device->options & NAND_BUSWIDTH_16)
        {
-               u16 data;
+               uint16_t data;
                device->controller->read_data(device, &data);
                *status = data & 0xff;
        }
@@ -399,12 +398,12 @@ int nand_read_status(struct nand_device_s *device, u8 *status)
 
 static int nand_poll_ready(struct nand_device_s *device, int timeout)
 {
-       u8 status;
+       uint8_t status;
 
        device->controller->command(device, NAND_CMD_STATUS);
        do {
                if (device->device->options & NAND_BUSWIDTH_16) {
-                       u16 data;
+                       uint16_t data;
                        device->controller->read_data(device, &data);
                        status = data & 0xff;
                } else {
@@ -420,8 +419,8 @@ static int nand_poll_ready(struct nand_device_s *device, int timeout)
 
 int nand_probe(struct nand_device_s *device)
 {
-       u8 manufacturer_id, device_id;
-       u8 id_buff[6];
+       uint8_t manufacturer_id, device_id;
+       uint8_t id_buff[6];
        int retval;
        int i;
 
@@ -465,7 +464,7 @@ int nand_probe(struct nand_device_s *device)
        }
        else
        {
-               u16 data_buf;
+               uint16_t data_buf;
                device->controller->read_data(device, &data_buf);
                manufacturer_id = data_buf & 0xff;
                device->controller->read_data(device, &data_buf);
@@ -525,7 +524,7 @@ int nand_probe(struct nand_device_s *device)
                }
                else
                {
-                       u16 data_buf;
+                       uint16_t data_buf;
 
                        device->controller->read_data(device, &data_buf);
                        id_buff[3] = data_buf;
@@ -640,7 +639,7 @@ int nand_erase(struct nand_device_s *device, int first_block, int last_block)
 {
        int i;
        u32 page;
-       u8 status;
+       uint8_t status;
        int retval;
 
        if (!device->device)
@@ -722,9 +721,9 @@ 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, u8 *data, u32 data_size)
+static int nand_read_plain(struct nand_device_s *device, u32 address, uint8_t *data, u32 data_size)
 {
-       u8 *page;
+       uint8_t *page;
 
        if (!device->device)
                return ERROR_NAND_DEVICE_NOT_PROBED;
@@ -759,9 +758,9 @@ static int nand_read_plain(struct nand_device_s *device, u32 address, u8 *data,
        return ERROR_OK;
 }
 
-static 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, uint8_t *data, u32 data_size)
 {
-       u8 *page;
+       uint8_t *page;
 
        if (!device->device)
                return ERROR_NAND_DEVICE_NOT_PROBED;
@@ -797,7 +796,7 @@ static int nand_write_plain(struct nand_device_s *device, u32 address, u8 *data,
 }
 #endif
 
-int nand_write_page(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, uint8_t *data, u32 data_size, uint8_t *oob, u32 oob_size)
 {
        u32 block;
 
@@ -814,7 +813,7 @@ int nand_write_page(struct nand_device_s *device, u32 page, u8 *data, u32 data_s
                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, u8 *data, u32 data_size, u8 *oob, u32 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)
 {
        if (!device->device)
                return ERROR_NAND_DEVICE_NOT_PROBED;
@@ -825,7 +824,7 @@ static int nand_read_page(struct nand_device_s *device, u32 page, u8 *data, u32
                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, u8 *data, u32 data_size, u8 *oob, u32 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)
 {
        u32 i;
 
@@ -939,11 +938,11 @@ int nand_read_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 dat
        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)
+int nand_write_page_raw(struct nand_device_s *device, u32 page, uint8_t *data, u32 data_size, uint8_t *oob, u32 oob_size)
 {
        u32 i;
        int retval;
-       u8 status;
+       uint8_t status;
 
        if (!device->device)
                return ERROR_NAND_DEVICE_NOT_PROBED;
@@ -997,7 +996,7 @@ int nand_write_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 da
                        {
                                if (device->device->options & NAND_BUSWIDTH_16)
                                {
-                                       u16 data_buf = le_to_h_u16(data);
+                                       uint16_t data_buf = le_to_h_u16(data);
                                        device->controller->write_data(device, data_buf);
                                        data += 2;
                                        i += 2;
@@ -1022,7 +1021,7 @@ int nand_write_page_raw(struct nand_device_s *device, u32 page, u8 *data, u32 da
                        {
                                if (device->device->options & NAND_BUSWIDTH_16)
                                {
-                                       u16 oob_buf = le_to_h_u16(data);
+                                       uint16_t oob_buf = le_to_h_u16(data);
                                        device->controller->write_data(device, oob_buf);
                                        oob += 2;
                                        i += 2;
@@ -1091,20 +1090,20 @@ static int handle_nand_info_command(struct command_context_s *cmd_ctx, char *cmd
        int first = -1;
        int last = -1;
 
-       if ((argc < 1) || (argc > 3))
-       {
+       switch (argc) {
+       default:
                return ERROR_COMMAND_SYNTAX_ERROR;
-
-       }
-
-       if (argc == 2)
-       {
+       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));
@@ -1139,7 +1138,7 @@ 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);
                        }
@@ -1201,12 +1200,31 @@ static int handle_nand_erase_command(struct command_context_s *cmd_ctx, char *cm
        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);
+               char *cp;
+               unsigned long offset;
+               unsigned long length;
 
-               if ((retval = nand_erase(p, first, last)) == ERROR_OK)
+               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)
                {
@@ -1238,31 +1256,53 @@ int handle_nand_check_bad_blocks_command(struct command_context_s *cmd_ctx, char
 
        }
 
-       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) {
+               command_print(cmd_ctx, "NAND flash device '#%s' is out of bounds",
+                               args[0]);
+               return ERROR_INVALID_ARGUMENTS;
        }
 
-       p = get_nand_device_by_num(strtoul(args[0], NULL, 0));
-       if (p)
+       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");
-               }
-               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;
+       }
+
+       retval = nand_build_bbt(p, first, last);
+       if (retval == ERROR_OK)
+       {
+               command_print(cmd_ctx, "checked NAND flash device for bad blocks, "
+                               "use \"nand info\" command to list blocks");
+       }
+       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;
@@ -1291,9 +1331,9 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm
        p = get_nand_device_by_num(strtoul(args[0], NULL, 0));
        if (p)
        {
-               u8 *page = NULL;
+               uint8_t *page = NULL;
                u32 page_size = 0;
-               u8 *oob = NULL;
+               uint8_t *oob = NULL;
                u32 oob_size = 0;
                const int *eccpos = NULL;
 
@@ -1373,7 +1413,7 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm
                        if (oob_format & NAND_OOB_SW_ECC)
                        {
                                u32 i, j;
-                               u8 ecc[3];
+                               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);
@@ -1390,7 +1430,7 @@ static int handle_nand_write_command(struct command_context_s *cmd_ctx, char *cm
                                 * of 10 bytes per 512-byte data block.
                                 */
                                u32 i;
-                               u8 *ecc = oob + oob_size - page_size/512 * 10;
+                               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);
@@ -1459,9 +1499,9 @@ static int handle_nand_dump_command(struct command_context_s *cmd_ctx, char *cmd
                        char *duration_text;
                        int retval;
 
-                       u8 *page = NULL;
+                       uint8_t *page = NULL;
                        u32 page_size = 0;
-                       u8 *oob = NULL;
+                       uint8_t *oob = NULL;
                        u32 oob_size = 0;
                        u32 address = strtoul(args[2], NULL, 0);
                        u32 size = strtoul(args[3], NULL, 0);
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)