fix 'flash protect' and 'flash erase_sector'

[fw/openocd] / src / flash / davinci_nand.c

diff --git a/src/flash/davinci_nand.c b/src/flash/davinci_nand.c
index cc144206a8389a36e1c4a10edaeebbc090f7b6c7..72cd378a4da7fbd1b9bf331d77bc923a4a586d0c 100644 (file)
--- a/src/flash/davinci_nand.c
+++ b/src/flash/davinci_nand.c
@@ -55,9 +55,9 @@ struct davinci_nand {
        struct arm_nand_data    io;
 
        /* page i/o for the relevant flavor of hardware ECC */
-       int (*read_page)(struct nand_device_s *nand, uint32_t page,
+       int (*read_page)(struct nand_device *nand, uint32_t page,
                        uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size);
-       int (*write_page)(struct nand_device_s *nand, uint32_t page,
+       int (*write_page)(struct nand_device *nand, uint32_t page,
                        uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size);
 };
 
@@ -78,12 +78,7 @@ static int halted(struct target *target, const char *label)
        return false;
 }
 
-static int davinci_register_commands(struct command_context_s *cmd_ctx)
-{
-       return ERROR_OK;
-}
-
-static int davinci_init(struct nand_device_s *nand)
+static int davinci_init(struct nand_device *nand)
 {
        struct davinci_nand *info = nand->controller_priv;
        struct target *target = info->target;
@@ -108,12 +103,12 @@ static int davinci_init(struct nand_device_s *nand)
        return ERROR_OK;
 }
 
-static int davinci_reset(struct nand_device_s *nand)
+static int davinci_reset(struct nand_device *nand)
 {
        return ERROR_OK;
 }
 
-static int davinci_nand_ready(struct nand_device_s *nand, int timeout)
+static int davinci_nand_ready(struct nand_device *nand, int timeout)
 {
        struct davinci_nand *info = nand->controller_priv;
        struct target *target = info->target;
@@ -136,7 +131,7 @@ static int davinci_nand_ready(struct nand_device_s *nand, int timeout)
        return 0;
 }
 
-static int davinci_command(struct nand_device_s *nand, uint8_t command)
+static int davinci_command(struct nand_device *nand, uint8_t command)
 {
        struct davinci_nand *info = nand->controller_priv;
        struct target *target = info->target;
@@ -148,7 +143,7 @@ static int davinci_command(struct nand_device_s *nand, uint8_t command)
        return ERROR_OK;
 }
 
-static int davinci_address(struct nand_device_s *nand, uint8_t address)
+static int davinci_address(struct nand_device *nand, uint8_t address)
 {
        struct davinci_nand *info = nand->controller_priv;
        struct target *target = info->target;
@@ -160,7 +155,7 @@ static int davinci_address(struct nand_device_s *nand, uint8_t address)
        return ERROR_OK;
 }
 
-static int davinci_write_data(struct nand_device_s *nand, uint16_t data)
+static int davinci_write_data(struct nand_device *nand, uint16_t data)
 {
        struct davinci_nand *info = nand->controller_priv;
        struct target *target = info->target;
@@ -172,7 +167,7 @@ static int davinci_write_data(struct nand_device_s *nand, uint16_t data)
        return ERROR_OK;
 }
 
-static int davinci_read_data(struct nand_device_s *nand, void *data)
+static int davinci_read_data(struct nand_device *nand, void *data)
 {
        struct davinci_nand *info = nand->controller_priv;
        struct target *target = info->target;
@@ -186,7 +181,7 @@ static int davinci_read_data(struct nand_device_s *nand, void *data)
 
 /* REVISIT a bit of native code should let block reads be MUCH faster */
 
-static int davinci_read_block_data(struct nand_device_s *nand,
+static int davinci_read_block_data(struct nand_device *nand,
                uint8_t *data, int data_size)
 {
        struct davinci_nand *info = nand->controller_priv;
@@ -219,7 +214,7 @@ static int davinci_read_block_data(struct nand_device_s *nand,
        return ERROR_OK;
 }
 
-static int davinci_write_block_data(struct nand_device_s *nand,
+static int davinci_write_block_data(struct nand_device *nand,
                uint8_t *data, int data_size)
 {
        struct davinci_nand *info = nand->controller_priv;
@@ -255,7 +250,7 @@ static int davinci_write_block_data(struct nand_device_s *nand,
        return ERROR_OK;
 }
 
-static int davinci_write_page(struct nand_device_s *nand, uint32_t page,
+static int davinci_write_page(struct nand_device *nand, uint32_t page,
                uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
 {
        struct davinci_nand *info = nand->controller_priv;
@@ -306,7 +301,7 @@ static int davinci_write_page(struct nand_device_s *nand, uint32_t page,
        return status;
 }
 
-static int davinci_read_page(struct nand_device_s *nand, uint32_t page,
+static int davinci_read_page(struct nand_device *nand, uint32_t page,
                uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
 {
        struct davinci_nand *info = nand->controller_priv;
@@ -319,7 +314,7 @@ static int davinci_read_page(struct nand_device_s *nand, uint32_t page,
        return info->read_page(nand, page, data, data_size, oob, oob_size);
 }
 
-static void davinci_write_pagecmd(struct nand_device_s *nand, uint8_t cmd, uint32_t page)
+static void davinci_write_pagecmd(struct nand_device *nand, uint8_t cmd, uint32_t page)
 {
        struct davinci_nand *info = nand->controller_priv;
        struct target *target = info->target;
@@ -342,7 +337,7 @@ static void davinci_write_pagecmd(struct nand_device_s *nand, uint8_t cmd, uint3
                target_write_u8(target, info->addr, page >> 24);
 }
 
-static int davinci_writepage_tail(struct nand_device_s *nand,
+static int davinci_writepage_tail(struct nand_device *nand,
                uint8_t *oob, uint32_t oob_size)
 {
        struct davinci_nand *info = nand->controller_priv;
@@ -374,7 +369,7 @@ static int davinci_writepage_tail(struct nand_device_s *nand,
 /*
  * All DaVinci family chips support 1-bit ECC on a per-chipselect basis.
  */
-static int davinci_write_page_ecc1(struct nand_device_s *nand, uint32_t page,
+static int davinci_write_page_ecc1(struct nand_device *nand, uint32_t page,
                uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
 {
        unsigned oob_offset;
@@ -441,7 +436,7 @@ static int davinci_write_page_ecc1(struct nand_device_s *nand, uint32_t page,
  * is read first, so its ECC data can be used incrementally), but the
  * manufacturer bad block markers are safe.  Contrast:  old "infix" style.
  */
-static int davinci_write_page_ecc4(struct nand_device_s *nand, uint32_t page,
+static int davinci_write_page_ecc4(struct nand_device *nand, uint32_t page,
                uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
 {
        static const uint8_t ecc512[] = {
@@ -543,7 +538,7 @@ static int davinci_write_page_ecc4(struct nand_device_s *nand, uint32_t page,
  * older second stage loaders (ABL/U-Boot, etc) or other system software
  * (MVL 4.x/5.x kernels, filesystems, etc) may need it more generally.
  */
-static int davinci_write_page_ecc4infix(struct nand_device_s *nand, uint32_t page,
+static int davinci_write_page_ecc4infix(struct nand_device *nand, uint32_t page,
                uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
 {
        struct davinci_nand *info = nand->controller_priv;
@@ -600,7 +595,7 @@ static int davinci_write_page_ecc4infix(struct nand_device_s *nand, uint32_t pag
        return davinci_writepage_tail(nand, NULL, 0);
 }
 
-static int davinci_read_page_ecc4infix(struct nand_device_s *nand, uint32_t page,
+static int davinci_read_page_ecc4infix(struct nand_device *nand, uint32_t page,
                uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
 {
        davinci_write_pagecmd(nand, NAND_CMD_READ0, page);
@@ -645,39 +640,39 @@ NAND_DEVICE_COMMAND_HANDLER(davinci_nand_device_command)
         *  - aemif address
         * Plus someday, optionally, ALE and CLE masks.
         */
-       if (argc < 5) {
+       if (CMD_ARGC < 5) {
                LOG_ERROR("parameters: %s target "
                                "chip_addr hwecc_mode aemif_addr",
-                               args[0]);
+                               CMD_ARGV[0]);
                goto fail;
        }
 
-       target = get_target(args[1]);
+       target = get_target(CMD_ARGV[1]);
        if (!target) {
-               LOG_ERROR("invalid target %s", args[1]);
+               LOG_ERROR("invalid target %s", CMD_ARGV[1]);
                goto fail;
        }
 
-       COMMAND_PARSE_NUMBER(ulong, args[2], chip);
+       COMMAND_PARSE_NUMBER(ulong, CMD_ARGV[2], chip);
        if (chip == 0) {
-               LOG_ERROR("Invalid NAND chip address %s", args[2]);
+               LOG_ERROR("Invalid NAND chip address %s", CMD_ARGV[2]);
                goto fail;
        }
 
-       if (strcmp(args[3], "hwecc1") == 0)
+       if (strcmp(CMD_ARGV[3], "hwecc1") == 0)
                eccmode = HWECC1;
-       else if (strcmp(args[3], "hwecc4") == 0)
+       else if (strcmp(CMD_ARGV[3], "hwecc4") == 0)
                eccmode = HWECC4;
-       else if (strcmp(args[3], "hwecc4_infix") == 0)
+       else if (strcmp(CMD_ARGV[3], "hwecc4_infix") == 0)
                eccmode = HWECC4_INFIX;
        else {
-               LOG_ERROR("Invalid ecc mode %s", args[3]);
+               LOG_ERROR("Invalid ecc mode %s", CMD_ARGV[3]);
                goto fail;
        }
 
-       COMMAND_PARSE_NUMBER(ulong, args[4], aemif);
+       COMMAND_PARSE_NUMBER(ulong, CMD_ARGV[4], aemif);
        if (aemif == 0) {
-               LOG_ERROR("Invalid AEMIF controller address %s", args[4]);
+               LOG_ERROR("Invalid AEMIF controller address %s", CMD_ARGV[4]);
                goto fail;
        }
 
@@ -747,7 +742,6 @@ fail:
 struct nand_flash_controller davinci_nand_controller = {
        .name                   = "davinci",
        .nand_device_command    = davinci_nand_device_command,
-       .register_commands      = davinci_register_commands,
        .init                   = davinci_init,
        .reset                  = davinci_reset,
        .command                = davinci_command,