Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
FLASH/NOR: Remove useless file lpc288x.h
[openocd.git] / src / flash / nor / cfi.c
diff --git a/src/flash/nor/cfi.c b/src/flash/nor/cfi.c
index 94ff7b9479c10e813101c2e15833caa97bf5aaa1..43e19b5f7b4d6d72d4b4eec2649b5ef319e2527b 100644 (file)
--- a/src/flash/nor/cfi.c
+++ b/src/flash/nor/cfi.c
@@ -4,6 +4,7 @@
  *   Copyright (C) 2009 Michael Schwingen                                  *
  *   michael@schwingen.org                                                 *
  *   Copyright (C) 2010 Øyvind Harboe <oyvind.harboe@zylin.com>            *
+ *   Copyright (C) 2010 by Antonio Borneo <borneo.antonio@gmail.com>       *
  *                                                                         *
  *   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  *
@@ -47,7 +48,7 @@ static struct cfi_unlock_addresses cfi_unlock_addresses[] =
 /* CFI fixups foward declarations */
 static void cfi_fixup_0002_erase_regions(struct flash_bank *flash, void *param);
 static void cfi_fixup_0002_unlock_addresses(struct flash_bank *flash, void *param);
-static void cfi_fixup_atmel_reversed_erase_regions(struct flash_bank *flash, void *param);
+static void cfi_fixup_reversed_erase_regions(struct flash_bank *flash, void *param);
 
 /* fixup after reading cmdset 0002 primary query table */
 static const struct cfi_fixup cfi_0002_fixups[] = {
@@ -56,7 +57,9 @@ static const struct cfi_fixup cfi_0002_fixups[] = {
        {CFI_MFR_SST, 0x00D6, cfi_fixup_0002_unlock_addresses, &cfi_unlock_addresses[CFI_UNLOCK_5555_2AAA]},
        {CFI_MFR_SST, 0x00D7, cfi_fixup_0002_unlock_addresses, &cfi_unlock_addresses[CFI_UNLOCK_5555_2AAA]},
        {CFI_MFR_SST, 0x2780, cfi_fixup_0002_unlock_addresses, &cfi_unlock_addresses[CFI_UNLOCK_5555_2AAA]},
-       {CFI_MFR_ATMEL, 0x00C8, cfi_fixup_atmel_reversed_erase_regions, NULL},
+       {CFI_MFR_SST, 0x236d, cfi_fixup_0002_unlock_addresses, &cfi_unlock_addresses[CFI_UNLOCK_555_2AA]},
+       {CFI_MFR_ATMEL, 0x00C8, cfi_fixup_reversed_erase_regions, NULL},
+       {CFI_MFR_ST,  0x22C4, cfi_fixup_reversed_erase_regions, NULL}, /* M29W160ET */
    {CFI_MFR_FUJITSU, 0x22ea, cfi_fixup_0002_unlock_addresses, &cfi_unlock_addresses[CFI_UNLOCK_555_2AA]},
        {CFI_MFR_FUJITSU, 0x226b, cfi_fixup_0002_unlock_addresses, &cfi_unlock_addresses[CFI_UNLOCK_5555_2AAA]},
        {CFI_MFR_AMIC, 0xb31a, cfi_fixup_0002_unlock_addresses, &cfi_unlock_addresses[CFI_UNLOCK_555_2AA]},
@@ -145,37 +148,45 @@ static int cfi_send_command(struct flash_bank *bank, uint8_t cmd, uint32_t addre
  * flash banks are expected to be made of similar chips
  * the query result should be the same for all
  */
-static uint8_t cfi_query_u8(struct flash_bank *bank, int sector, uint32_t offset)
+static int cfi_query_u8(struct flash_bank *bank, int sector, uint32_t offset, uint8_t *val)
 {
        struct target *target = bank->target;
        uint8_t data[CFI_MAX_BUS_WIDTH];
 
-       target_read_memory(target, flash_address(bank, sector, offset), bank->bus_width, 1, data);
+       int retval;
+       retval = target_read_memory(target, flash_address(bank, sector, offset), bank->bus_width, 1, data);
+       if (retval != ERROR_OK)
+               return retval;
 
        if (bank->target->endianness == TARGET_LITTLE_ENDIAN)
-               return data[0];
+               *val = data[0];
        else
-               return data[bank->bus_width - 1];
+               *val = data[bank->bus_width - 1];
+
+       return ERROR_OK;
 }
 
 /* read unsigned 8-bit value from the bank
  * in case of a bank made of multiple chips,
  * the individual values are ORed
  */
-static uint8_t cfi_get_u8(struct flash_bank *bank, int sector, uint32_t offset)
+static int cfi_get_u8(struct flash_bank *bank, int sector, uint32_t offset, uint8_t *val)
 {
        struct target *target = bank->target;
        uint8_t data[CFI_MAX_BUS_WIDTH];
        int i;
 
-       target_read_memory(target, flash_address(bank, sector, offset), bank->bus_width, 1, data);
+       int retval;
+       retval = target_read_memory(target, flash_address(bank, sector, offset), bank->bus_width, 1, data);
+       if (retval != ERROR_OK)
+               return retval;
 
        if (bank->target->endianness == TARGET_LITTLE_ENDIAN)
        {
                for (i = 0; i < bank->bus_width / bank->chip_width; i++)
                        data[0] |= data[i];
 
-               return data[0];
+               *val = data[0];
        }
        else
        {
@@ -183,53 +194,75 @@ static uint8_t cfi_get_u8(struct flash_bank *bank, int sector, uint32_t offset)
                for (i = 0; i < bank->bus_width / bank->chip_width; i++)
                        value |= data[bank->bus_width - 1 - i];
 
-               return value;
+               *val = value;
        }
+       return ERROR_OK;
 }
 
-static uint16_t cfi_query_u16(struct flash_bank *bank, int sector, uint32_t offset)
+static int cfi_query_u16(struct flash_bank *bank, int sector, uint32_t offset, uint16_t *val)
 {
        struct target *target = bank->target;
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
        uint8_t data[CFI_MAX_BUS_WIDTH * 2];
+       int retval;
 
        if (cfi_info->x16_as_x8)
        {
                uint8_t i;
                for (i = 0;i < 2;i++)
-                       target_read_memory(target, flash_address(bank, sector, offset + i), bank->bus_width, 1,
+               {
+                       retval = target_read_memory(target, flash_address(bank, sector, offset + i), bank->bus_width, 1,
                                &data[i*bank->bus_width]);
+                       if (retval != ERROR_OK)
+                               return retval;
+               }
+       } else
+       {
+               retval = target_read_memory(target, flash_address(bank, sector, offset), bank->bus_width, 2, data);
+               if (retval != ERROR_OK)
+                       return retval;
        }
-       else
-               target_read_memory(target, flash_address(bank, sector, offset), bank->bus_width, 2, data);
 
        if (bank->target->endianness == TARGET_LITTLE_ENDIAN)
-               return data[0] | data[bank->bus_width] << 8;
+               *val = data[0] | data[bank->bus_width] << 8;
        else
-               return data[bank->bus_width - 1] | data[(2 * bank->bus_width) - 1] << 8;
+               *val = data[bank->bus_width - 1] | data[(2 * bank->bus_width) - 1] << 8;
+
+       return ERROR_OK;
 }
 
-static uint32_t cfi_query_u32(struct flash_bank *bank, int sector, uint32_t offset)
+static int cfi_query_u32(struct flash_bank *bank, int sector, uint32_t offset, uint32_t *val)
 {
        struct target *target = bank->target;
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
        uint8_t data[CFI_MAX_BUS_WIDTH * 4];
+       int retval;
 
        if (cfi_info->x16_as_x8)
        {
                uint8_t i;
                for (i = 0;i < 4;i++)
-                       target_read_memory(target, flash_address(bank, sector, offset + i), bank->bus_width, 1,
+               {
+                       retval = target_read_memory(target, flash_address(bank, sector, offset + i), bank->bus_width, 1,
                                &data[i*bank->bus_width]);
+                       if (retval != ERROR_OK)
+                               return retval;
+               }
        }
        else
-               target_read_memory(target, flash_address(bank, sector, offset), bank->bus_width, 4, data);
+       {
+               retval = target_read_memory(target, flash_address(bank, sector, offset), bank->bus_width, 4, data);
+               if (retval != ERROR_OK)
+                       return retval;
+       }
 
        if (bank->target->endianness == TARGET_LITTLE_ENDIAN)
-               return data[0] | data[bank->bus_width] << 8 | data[bank->bus_width * 2] << 16 | data[bank->bus_width * 3] << 24;
+               *val = data[0] | data[bank->bus_width] << 8 | data[bank->bus_width * 2] << 16 | data[bank->bus_width * 3] << 24;
        else
-               return data[bank->bus_width - 1] | data[(2* bank->bus_width) - 1] << 8 |
+               *val = data[bank->bus_width - 1] | data[(2* bank->bus_width) - 1] << 8 |
                                data[(3 * bank->bus_width) - 1] << 16 | data[(4 * bank->bus_width) - 1] << 24;
+
+       return ERROR_OK;
 }
 
 static int cfi_reset(struct flash_bank *bank)
@@ -274,13 +307,27 @@ static void cfi_intel_clear_status_register(struct flash_bank *bank)
        cfi_send_command(bank, 0x50, flash_address(bank, 0, 0x0));
 }
 
-static uint8_t cfi_intel_wait_status_busy(struct flash_bank *bank, int timeout)
+static int cfi_intel_wait_status_busy(struct flash_bank *bank, int timeout, uint8_t *val)
 {
        uint8_t status;
 
-       while ((!((status = cfi_get_u8(bank, 0, 0x0)) & 0x80)) && (timeout-- > 0))
+       int retval = ERROR_OK;
+
+       for (;;)
        {
-               LOG_DEBUG("status: 0x%x", status);
+               if (timeout-- < 0)
+               {
+                 LOG_ERROR("timeout while waiting for WSM to become ready");
+                 return ERROR_FAIL;
+               }
+
+               retval = cfi_get_u8(bank, 0, 0x0, &status);
+               if (retval != ERROR_OK)
+                       return retval;
+
+               if (status & 0x80)
+                       break;
+
                alive_sleep(1);
        }
 
@@ -289,11 +336,7 @@ static uint8_t cfi_intel_wait_status_busy(struct flash_bank *bank, int timeout)
 
        LOG_DEBUG("status: 0x%x", status);
 
-       if ((status & 0x80) != 0x80)
-       {
-               LOG_ERROR("timeout while waiting for WSM to become ready");
-       }
-       else if (status != 0x80)
+       if (status != 0x80)
        {
                LOG_ERROR("status register: 0x%x", status);
                if (status & 0x2)
@@ -310,24 +353,38 @@ static uint8_t cfi_intel_wait_status_busy(struct flash_bank *bank, int timeout)
                        LOG_ERROR("Block Erase Suspended");
 
                cfi_intel_clear_status_register(bank);
+
+               retval = ERROR_FAIL;
        }
 
-       return status;
+       *val = status;
+       return retval;
 }
 
 static int cfi_spansion_wait_status_busy(struct flash_bank *bank, int timeout)
 {
        uint8_t status, oldstatus;
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
+       int retval;
 
-       oldstatus = cfi_get_u8(bank, 0, 0x0);
+       retval = cfi_get_u8(bank, 0, 0x0, &oldstatus);
+       if (retval != ERROR_OK)
+               return retval;
 
        do {
-               status = cfi_get_u8(bank, 0, 0x0);
+               retval = cfi_get_u8(bank, 0, 0x0, &status);
+
+               if (retval != ERROR_OK)
+                       return retval;
+
                if ((status ^ oldstatus) & 0x40) {
                        if (status & cfi_info->status_poll_mask & 0x20) {
-                               oldstatus = cfi_get_u8(bank, 0, 0x0);
-                               status = cfi_get_u8(bank, 0, 0x0);
+                               retval = cfi_get_u8(bank, 0, 0x0, &oldstatus);
+                               if (retval != ERROR_OK)
+                                       return retval;
+                               retval = cfi_get_u8(bank, 0, 0x0, &status);
+                               if (retval != ERROR_OK)
+                                       return retval;
                                if ((status ^ oldstatus) & 0x40) {
                                        LOG_ERROR("dq5 timeout, status: 0x%x", status);
                                        return(ERROR_FLASH_OPERATION_FAILED);
@@ -354,13 +411,28 @@ static int cfi_read_intel_pri_ext(struct flash_bank *bank)
 {
        int retval;
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
-       struct cfi_intel_pri_ext *pri_ext = malloc(sizeof(struct cfi_intel_pri_ext));
+       struct cfi_intel_pri_ext *pri_ext;
+
+       if (cfi_info->pri_ext)
+               free(cfi_info->pri_ext);
 
+       pri_ext = malloc(sizeof(struct cfi_intel_pri_ext));
+       if (pri_ext == NULL)
+       {
+               LOG_ERROR("Out of memory");
+               return ERROR_FAIL;
+       }
        cfi_info->pri_ext = pri_ext;
 
-       pri_ext->pri[0] = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0);
-       pri_ext->pri[1] = cfi_query_u8(bank, 0, cfi_info->pri_addr + 1);
-       pri_ext->pri[2] = cfi_query_u8(bank, 0, cfi_info->pri_addr + 2);
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0, &pri_ext->pri[0]);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 1, &pri_ext->pri[1]);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 2, &pri_ext->pri[2]);
+       if (retval != ERROR_OK)
+               return retval;
 
        if ((pri_ext->pri[0] != 'P') || (pri_ext->pri[1] != 'R') || (pri_ext->pri[2] != 'I'))
        {
@@ -372,36 +444,58 @@ static int cfi_read_intel_pri_ext(struct flash_bank *bank)
                return ERROR_FLASH_BANK_INVALID;
        }
 
-       pri_ext->major_version = cfi_query_u8(bank, 0, cfi_info->pri_addr + 3);
-       pri_ext->minor_version = cfi_query_u8(bank, 0, cfi_info->pri_addr + 4);
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 3, &pri_ext->major_version);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 4, &pri_ext->minor_version);
+       if (retval != ERROR_OK)
+               return retval;
 
        LOG_DEBUG("pri: '%c%c%c', version: %c.%c", pri_ext->pri[0], pri_ext->pri[1], pri_ext->pri[2], pri_ext->major_version, pri_ext->minor_version);
 
-       pri_ext->feature_support = cfi_query_u32(bank, 0, cfi_info->pri_addr + 5);
-       pri_ext->suspend_cmd_support = cfi_query_u8(bank, 0, cfi_info->pri_addr + 9);
-       pri_ext->blk_status_reg_mask = cfi_query_u16(bank, 0, cfi_info->pri_addr + 0xa);
+       retval = cfi_query_u32(bank, 0, cfi_info->pri_addr + 5, &pri_ext->feature_support);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 9, &pri_ext->suspend_cmd_support);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u16(bank, 0, cfi_info->pri_addr + 0xa, &pri_ext->blk_status_reg_mask);
+       if (retval != ERROR_OK)
+               return retval;
 
        LOG_DEBUG("feature_support: 0x%" PRIx32 ", suspend_cmd_support: 0x%x, blk_status_reg_mask: 0x%x",
                  pri_ext->feature_support,
                  pri_ext->suspend_cmd_support,
                  pri_ext->blk_status_reg_mask);
 
-       pri_ext->vcc_optimal = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0xc);
-       pri_ext->vpp_optimal = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0xd);
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0xc, &pri_ext->vcc_optimal);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0xd, &pri_ext->vpp_optimal);
+       if (retval != ERROR_OK)
+               return retval;
 
        LOG_DEBUG("Vcc opt: %x.%x, Vpp opt: %u.%x",
                  (pri_ext->vcc_optimal & 0xf0) >> 4, pri_ext->vcc_optimal & 0x0f,
                  (pri_ext->vpp_optimal & 0xf0) >> 4, pri_ext->vpp_optimal & 0x0f);
 
-       pri_ext->num_protection_fields = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0xe);
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0xe, &pri_ext->num_protection_fields);
+       if (retval != ERROR_OK)
+               return retval;
        if (pri_ext->num_protection_fields != 1)
        {
                LOG_WARNING("expected one protection register field, but found %i", pri_ext->num_protection_fields);
        }
 
-       pri_ext->prot_reg_addr = cfi_query_u16(bank, 0, cfi_info->pri_addr + 0xf);
-       pri_ext->fact_prot_reg_size = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0x11);
-       pri_ext->user_prot_reg_size = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0x12);
+       retval = cfi_query_u16(bank, 0, cfi_info->pri_addr + 0xf, &pri_ext->prot_reg_addr);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0x11, &pri_ext->fact_prot_reg_size);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0x12, &pri_ext->user_prot_reg_size);
+       if (retval != ERROR_OK)
+               return retval;
 
        LOG_DEBUG("protection_fields: %i, prot_reg_addr: 0x%x, factory pre-programmed: %i, user programmable: %i", pri_ext->num_protection_fields, pri_ext->prot_reg_addr, 1 << pri_ext->fact_prot_reg_size, 1 << pri_ext->user_prot_reg_size);
 
@@ -412,13 +506,28 @@ static int cfi_read_spansion_pri_ext(struct flash_bank *bank)
 {
        int retval;
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
-       struct cfi_spansion_pri_ext *pri_ext = malloc(sizeof(struct cfi_spansion_pri_ext));
+       struct cfi_spansion_pri_ext *pri_ext;
 
+       if (cfi_info->pri_ext)
+               free(cfi_info->pri_ext);
+
+       pri_ext = malloc(sizeof(struct cfi_spansion_pri_ext));
+       if (pri_ext == NULL)
+       {
+               LOG_ERROR("Out of memory");
+               return ERROR_FAIL;
+       }
        cfi_info->pri_ext = pri_ext;
 
-       pri_ext->pri[0] = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0);
-       pri_ext->pri[1] = cfi_query_u8(bank, 0, cfi_info->pri_addr + 1);
-       pri_ext->pri[2] = cfi_query_u8(bank, 0, cfi_info->pri_addr + 2);
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0, &pri_ext->pri[0]);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 1, &pri_ext->pri[1]);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 2, &pri_ext->pri[2]);
+       if (retval != ERROR_OK)
+               return retval;
 
        if ((pri_ext->pri[0] != 'P') || (pri_ext->pri[1] != 'R') || (pri_ext->pri[2] != 'I'))
        {
@@ -430,22 +539,48 @@ static int cfi_read_spansion_pri_ext(struct flash_bank *bank)
                return ERROR_FLASH_BANK_INVALID;
        }
 
-       pri_ext->major_version = cfi_query_u8(bank, 0, cfi_info->pri_addr + 3);
-       pri_ext->minor_version = cfi_query_u8(bank, 0, cfi_info->pri_addr + 4);
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 3, &pri_ext->major_version);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 4, &pri_ext->minor_version);
+       if (retval != ERROR_OK)
+               return retval;
 
        LOG_DEBUG("pri: '%c%c%c', version: %c.%c", pri_ext->pri[0], pri_ext->pri[1], pri_ext->pri[2], pri_ext->major_version, pri_ext->minor_version);
 
-       pri_ext->SiliconRevision = cfi_query_u8(bank, 0, cfi_info->pri_addr + 5);
-       pri_ext->EraseSuspend    = cfi_query_u8(bank, 0, cfi_info->pri_addr + 6);
-       pri_ext->BlkProt         = cfi_query_u8(bank, 0, cfi_info->pri_addr + 7);
-       pri_ext->TmpBlkUnprotect = cfi_query_u8(bank, 0, cfi_info->pri_addr + 8);
-       pri_ext->BlkProtUnprot   = cfi_query_u8(bank, 0, cfi_info->pri_addr + 9);
-       pri_ext->SimultaneousOps = cfi_query_u8(bank, 0, cfi_info->pri_addr + 10);
-       pri_ext->BurstMode       = cfi_query_u8(bank, 0, cfi_info->pri_addr + 11);
-       pri_ext->PageMode        = cfi_query_u8(bank, 0, cfi_info->pri_addr + 12);
-       pri_ext->VppMin          = cfi_query_u8(bank, 0, cfi_info->pri_addr + 13);
-       pri_ext->VppMax          = cfi_query_u8(bank, 0, cfi_info->pri_addr + 14);
-       pri_ext->TopBottom       = cfi_query_u8(bank, 0, cfi_info->pri_addr + 15);
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 5, &pri_ext->SiliconRevision);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 6, &pri_ext->EraseSuspend);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 7, &pri_ext->BlkProt);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 8, &pri_ext->TmpBlkUnprotect);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 9, &pri_ext->BlkProtUnprot);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 10, &pri_ext->SimultaneousOps);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 11, &pri_ext->BurstMode);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 12, &pri_ext->PageMode);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 13, &pri_ext->VppMin);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 14, &pri_ext->VppMax);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 15, &pri_ext->TopBottom);
+       if (retval != ERROR_OK)
+               return retval;
 
        LOG_DEBUG("Silicon Revision: 0x%x, Erase Suspend: 0x%x, Block protect: 0x%x", pri_ext->SiliconRevision,
              pri_ext->EraseSuspend, pri_ext->BlkProt);
@@ -475,7 +610,17 @@ static int cfi_read_atmel_pri_ext(struct flash_bank *bank)
        int retval;
        struct cfi_atmel_pri_ext atmel_pri_ext;
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
-       struct cfi_spansion_pri_ext *pri_ext = malloc(sizeof(struct cfi_spansion_pri_ext));
+       struct cfi_spansion_pri_ext *pri_ext;
+
+       if (cfi_info->pri_ext)
+               free(cfi_info->pri_ext);
+
+       pri_ext = malloc(sizeof(struct cfi_spansion_pri_ext));
+       if (pri_ext == NULL)
+       {
+               LOG_ERROR("Out of memory");
+               return ERROR_FAIL;
+       }
 
        /* ATMEL devices use the same CFI primary command set (0x2) as AMD/Spansion,
         * but a different primary extended query table.
@@ -486,9 +631,15 @@ static int cfi_read_atmel_pri_ext(struct flash_bank *bank)
 
        cfi_info->pri_ext = pri_ext;
 
-       atmel_pri_ext.pri[0] = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0);
-       atmel_pri_ext.pri[1] = cfi_query_u8(bank, 0, cfi_info->pri_addr + 1);
-       atmel_pri_ext.pri[2] = cfi_query_u8(bank, 0, cfi_info->pri_addr + 2);
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 0, &atmel_pri_ext.pri[0]);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 1, &atmel_pri_ext.pri[1]);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 2, &atmel_pri_ext.pri[2]);
+       if (retval != ERROR_OK)
+               return retval;
 
        if ((atmel_pri_ext.pri[0] != 'P') || (atmel_pri_ext.pri[1] != 'R') || (atmel_pri_ext.pri[2] != 'I'))
        {
@@ -504,18 +655,30 @@ static int cfi_read_atmel_pri_ext(struct flash_bank *bank)
        pri_ext->pri[1] = atmel_pri_ext.pri[1];
        pri_ext->pri[2] = atmel_pri_ext.pri[2];
 
-       atmel_pri_ext.major_version = cfi_query_u8(bank, 0, cfi_info->pri_addr + 3);
-       atmel_pri_ext.minor_version = cfi_query_u8(bank, 0, cfi_info->pri_addr + 4);
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 3, &atmel_pri_ext.major_version);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 4, &atmel_pri_ext.minor_version);
+       if (retval != ERROR_OK)
+               return retval;
 
        LOG_DEBUG("pri: '%c%c%c', version: %c.%c", atmel_pri_ext.pri[0], atmel_pri_ext.pri[1], atmel_pri_ext.pri[2], atmel_pri_ext.major_version, atmel_pri_ext.minor_version);
 
        pri_ext->major_version = atmel_pri_ext.major_version;
        pri_ext->minor_version = atmel_pri_ext.minor_version;
 
-       atmel_pri_ext.features = cfi_query_u8(bank, 0, cfi_info->pri_addr + 5);
-       atmel_pri_ext.bottom_boot = cfi_query_u8(bank, 0, cfi_info->pri_addr + 6);
-       atmel_pri_ext.burst_mode = cfi_query_u8(bank, 0, cfi_info->pri_addr + 7);
-       atmel_pri_ext.page_mode = cfi_query_u8(bank, 0, cfi_info->pri_addr + 8);
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 5, &atmel_pri_ext.features);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 6, &atmel_pri_ext.bottom_boot);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 7, &atmel_pri_ext.burst_mode);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, cfi_info->pri_addr + 8, &atmel_pri_ext.page_mode);
+       if (retval != ERROR_OK)
+               return retval;
 
        LOG_DEBUG("features: 0x%2.2x, bottom_boot: 0x%2.2x, burst_mode: 0x%2.2x, page_mode: 0x%2.2x",
                atmel_pri_ext.features, atmel_pri_ext.bottom_boot, atmel_pri_ext.burst_mode, atmel_pri_ext.page_mode);
@@ -643,6 +806,8 @@ FLASH_BANK_COMMAND_HANDLER(cfi_flash_bank_command)
 
        cfi_info = malloc(sizeof(struct cfi_flash_bank));
        cfi_info->probed = 0;
+       cfi_info->erase_region_info = NULL;
+       cfi_info->pri_ext = NULL;
        bank->driver_priv = cfi_info;
 
        cfi_info->write_algorithm = NULL;
@@ -666,7 +831,7 @@ FLASH_BANK_COMMAND_HANDLER(cfi_flash_bank_command)
        cfi_info->write_algorithm = NULL;
 
        /* bank wasn't probed yet */
-       cfi_info->qry[0] = -1;
+       cfi_info->qry[0] = 0xff;
 
        return ERROR_OK;
 }
@@ -691,7 +856,12 @@ static int cfi_intel_erase(struct flash_bank *bank, int first, int last)
                        return retval;
                }
 
-               if (cfi_intel_wait_status_busy(bank, 1000 * (1 << cfi_info->block_erase_timeout_typ)) == 0x80)
+               uint8_t status;
+               retval = cfi_intel_wait_status_busy(bank, 1000 * (1 << cfi_info->block_erase_timeout_typ), &status);
+               if (retval != ERROR_OK)
+                       return retval;
+
+               if (status == 0x80)
                        bank->sectors[i].is_erased = 1;
                else
                {
@@ -804,8 +974,6 @@ static int cfi_intel_protect(struct flash_bank *bank, int set, int first, int la
        int retval;
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
        struct cfi_intel_pri_ext *pri_ext = cfi_info->pri_ext;
-       struct target *target = bank->target; /* FIXME: to be removed */
-       uint8_t command[CFI_MAX_BUS_WIDTH]; /* FIXME: to be removed */
        int retry = 0;
        int i;
 
@@ -813,22 +981,21 @@ static int cfi_intel_protect(struct flash_bank *bank, int set, int first, int la
         * instant individual block locking (bit 5).
         */
        if (!(pri_ext->feature_support & 0x28))
+       {
+               LOG_ERROR("lock/unlock not supported on flash");
                return ERROR_FLASH_OPERATION_FAILED;
+       }
 
        cfi_intel_clear_status_register(bank);
 
        for (i = first; i <= last; i++)
        {
-               cfi_command(bank, 0x60, command); /* FIXME: to be removed */
-               LOG_DEBUG("address: 0x%4.4" PRIx32 ", command: 0x%4.4" PRIx32, flash_address(bank, i, 0x0), target_buffer_get_u32(target, command));
                if ((retval = cfi_send_command(bank, 0x60, flash_address(bank, i, 0x0))) != ERROR_OK)
                {
                        return retval;
                }
                if (set)
                {
-                       cfi_command(bank, 0x01, command); /* FIXME: to be removed */
-                       LOG_DEBUG("address: 0x%4.4" PRIx32 ", command: 0x%4.4" PRIx32 , flash_address(bank, i, 0x0), target_buffer_get_u32(target, command));
                        if ((retval = cfi_send_command(bank, 0x01, flash_address(bank, i, 0x0))) != ERROR_OK)
                        {
                                return retval;
@@ -837,8 +1004,6 @@ static int cfi_intel_protect(struct flash_bank *bank, int set, int first, int la
                }
                else
                {
-                       cfi_command(bank, 0xd0, command); /* FIXME: to be removed */
-                       LOG_DEBUG("address: 0x%4.4" PRIx32 ", command: 0x%4.4" PRIx32, flash_address(bank, i, 0x0), target_buffer_get_u32(target, command));
                        if ((retval = cfi_send_command(bank, 0xd0, flash_address(bank, i, 0x0))) != ERROR_OK)
                        {
                                return retval;
@@ -850,7 +1015,10 @@ static int cfi_intel_protect(struct flash_bank *bank, int set, int first, int la
                if (!(pri_ext->feature_support & 0x20))
                {
                        /* Clear lock bits operation may take up to 1.4s */
-                       cfi_intel_wait_status_busy(bank, 1400);
+                       uint8_t status;
+                       retval = cfi_intel_wait_status_busy(bank, 1400, &status);
+                       if (retval != ERROR_OK)
+                               return retval;
                }
                else
                {
@@ -860,7 +1028,9 @@ static int cfi_intel_protect(struct flash_bank *bank, int set, int first, int la
                        {
                                return retval;
                        }
-                       block_status = cfi_get_u8(bank, i, 0x2);
+                       retval = cfi_get_u8(bank, i, 0x2, &block_status);
+                       if (retval != ERROR_OK)
+                               return retval;
 
                        if ((block_status & 0x1) != set)
                        {
@@ -869,7 +1039,10 @@ static int cfi_intel_protect(struct flash_bank *bank, int set, int first, int la
                                {
                                        return retval;
                                }
-                               cfi_intel_wait_status_busy(bank, 10);
+                               uint8_t status;
+                               retval = cfi_intel_wait_status_busy(bank, 10, &status);
+                               if (retval != ERROR_OK)
+                                       return retval;
 
                                if (retry > 10)
                                        return ERROR_FLASH_OPERATION_FAILED;
@@ -914,7 +1087,10 @@ static int cfi_intel_protect(struct flash_bank *bank, int set, int first, int la
                                        return retval;
                                }
 
-                               cfi_intel_wait_status_busy(bank, 100);
+                               uint8_t status;
+                               retval = cfi_intel_wait_status_busy(bank, 100, &status);
+                               if (retval != ERROR_OK)
+                                       return retval;
                        }
                }
        }
@@ -1200,7 +1376,8 @@ static int cfi_intel_write_block(struct flash_bank *bank, uint8_t *buffer, uint3
                if (wsm_error)
                {
                        /* read status register (outputs debug inforation) */
-                       cfi_intel_wait_status_busy(bank, 100);
+                       uint8_t status;
+                       cfi_intel_wait_status_busy(bank, 100, &status);
                        cfi_intel_clear_status_register(bank);
                        retval = ERROR_FLASH_OPERATION_FAILED;
                        goto cleanup;
@@ -1209,6 +1386,8 @@ static int cfi_intel_write_block(struct flash_bank *bank, uint8_t *buffer, uint3
                buffer += thisrun_count;
                address += thisrun_count;
                count -= thisrun_count;
+
+               keep_alive();
        }
 
        /* free up resources */
@@ -1243,8 +1422,7 @@ static int cfi_spansion_write_block(struct flash_bank *bank, uint8_t *buffer, ui
        struct working_area *source;
        uint32_t buffer_size = 32768;
        uint32_t status;
-       int retval, retvaltemp;
-       int exit_code = ERROR_OK;
+       int retval = ERROR_OK;
 
        /* input parameters - */
        /*      R0 = source address */
@@ -1433,6 +1611,11 @@ static int cfi_spansion_write_block(struct flash_bank *bank, uint8_t *buffer, ui
 
                /* convert bus-width dependent algorithm code to correct endiannes */
                target_code = malloc(target_code_size);
+               if (target_code == NULL)
+               {
+                       LOG_ERROR("Out of memory");
+                       return ERROR_FAIL;
+               }
                cfi_fix_code_endian(target, target_code, target_code_src, target_code_size / 4);
 
                /* allocate working area */
@@ -1485,7 +1668,11 @@ static int cfi_spansion_write_block(struct flash_bank *bank, uint8_t *buffer, ui
        {
                uint32_t thisrun_count = (count > buffer_size) ? buffer_size : count;
 
-               retvaltemp = target_write_buffer(target, source->address, thisrun_count, buffer);
+               retval = target_write_buffer(target, source->address, thisrun_count, buffer);
+               if (retval != ERROR_OK)
+               {
+                       break;
+               }
 
                buf_set_u32(reg_params[0].value, 0, 32, source->address);
                buf_set_u32(reg_params[1].value, 0, 32, address);
@@ -1501,13 +1688,16 @@ static int cfi_spansion_write_block(struct flash_bank *bank, uint8_t *buffer, ui
                                                     cfi_info->write_algorithm->address,
                                                     cfi_info->write_algorithm->address + ((target_code_size) - 4),
                                                     10000, &armv4_5_info);
+               if (retval != ERROR_OK)
+               {
+                       break;
+               }
 
                status = buf_get_u32(reg_params[5].value, 0, 32);
-
-               if ((retval != ERROR_OK) || (retvaltemp != ERROR_OK) || status != 0x80)
+               if (status != 0x80)
                {
-                       LOG_DEBUG("status: 0x%" PRIx32 , status);
-                       exit_code = ERROR_FLASH_OPERATION_FAILED;
+                       LOG_ERROR("flash write block failed status: 0x%" PRIx32 , status);
+                       retval = ERROR_FLASH_OPERATION_FAILED;
                        break;
                }
 
@@ -1529,7 +1719,7 @@ static int cfi_spansion_write_block(struct flash_bank *bank, uint8_t *buffer, ui
        destroy_reg_param(&reg_params[8]);
        destroy_reg_param(&reg_params[9]);
 
-       return exit_code;
+       return retval;
 }
 
 static int cfi_intel_write_word(struct flash_bank *bank, uint8_t *word, uint32_t address)
@@ -1549,7 +1739,9 @@ static int cfi_intel_write_word(struct flash_bank *bank, uint8_t *word, uint32_t
                return retval;
        }
 
-       if (cfi_intel_wait_status_busy(bank, 1000 * (1 << cfi_info->word_write_timeout_max)) != 0x80)
+       uint8_t status;
+       retval = cfi_intel_wait_status_busy(bank, 1000 * (1 << cfi_info->word_write_timeout_max), &status);
+       if (retval != 0x80)
        {
                if ((retval = cfi_send_command(bank, 0xff, flash_address(bank, 0, 0x0))) != ERROR_OK)
                {
@@ -1599,7 +1791,11 @@ static int cfi_intel_write_words(struct flash_bank *bank, uint8_t *word, uint32_
        {
                return retval;
        }
-       if (cfi_intel_wait_status_busy(bank, 1000 * (1 << cfi_info->buf_write_timeout_max)) != 0x80)
+       uint8_t status;
+       retval = cfi_intel_wait_status_busy(bank, 1000 * (1 << cfi_info->buf_write_timeout_max), &status);
+       if (retval != ERROR_OK)
+               return retval;
+       if (status != 0x80)
        {
                if ((retval = cfi_send_command(bank, 0xff, flash_address(bank, 0, 0x0))) != ERROR_OK)
                {
@@ -1626,7 +1822,12 @@ static int cfi_intel_write_words(struct flash_bank *bank, uint8_t *word, uint32_
        {
                return retval;
        }
-       if (cfi_intel_wait_status_busy(bank, 1000 * (1 << cfi_info->buf_write_timeout_max)) != 0x80)
+
+       retval = cfi_intel_wait_status_busy(bank, 1000 * (1 << cfi_info->buf_write_timeout_max), &status);
+       if (retval != ERROR_OK)
+               return retval;
+
+       if (status != 0x80)
        {
                if ((retval = cfi_send_command(bank, 0xff, flash_address(bank, 0, 0x0))) != ERROR_OK)
                {
@@ -1799,6 +2000,76 @@ static int cfi_write_words(struct flash_bank *bank, uint8_t *word, uint32_t word
        return ERROR_FLASH_OPERATION_FAILED;
 }
 
+static int cfi_read(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
+{
+       struct cfi_flash_bank *cfi_info = bank->driver_priv;
+       struct target *target = bank->target;
+       uint32_t address = bank->base + offset;
+       uint32_t read_p;
+       int align;      /* number of unaligned bytes */
+       uint8_t current_word[CFI_MAX_BUS_WIDTH];
+       int i;
+       int retval;
+
+       LOG_DEBUG("reading buffer of %i byte at 0x%8.8x",
+               (int)count, (unsigned)offset);
+
+       if (bank->target->state != TARGET_HALTED)
+       {
+               LOG_ERROR("Target not halted");
+               return ERROR_TARGET_NOT_HALTED;
+       }
+
+       if (offset + count > bank->size)
+               return ERROR_FLASH_DST_OUT_OF_BANK;
+
+       if (cfi_info->qry[0] != 'Q')
+               return ERROR_FLASH_BANK_NOT_PROBED;
+
+       /* start at the first byte of the first word (bus_width size) */
+       read_p = address & ~(bank->bus_width - 1);
+       if ((align = address - read_p) != 0)
+       {
+               LOG_INFO("Fixup %d unaligned read head bytes", align);
+
+               /* read a complete word from flash */
+               if ((retval = target_read_memory(target, read_p, bank->bus_width, 1, current_word)) != ERROR_OK)
+                       return retval;
+
+               /* take only bytes we need */
+               for (i = align; (i < bank->bus_width) && (count > 0); i++, count--)
+                       *buffer++ = current_word[i];
+
+               read_p += bank->bus_width;
+       }
+
+       align = count / bank->bus_width;
+       if (align)
+       {
+               if ((retval = target_read_memory(target, read_p, bank->bus_width, align, buffer)) != ERROR_OK)
+                       return retval;
+
+               read_p += align * bank->bus_width;
+               buffer += align * bank->bus_width;
+               count -= align * bank->bus_width;
+       }
+
+       if (count)
+       {
+               LOG_INFO("Fixup %d unaligned read tail bytes", count);
+
+               /* read a complete word from flash */
+               if ((retval = target_read_memory(target, read_p, bank->bus_width, 1, current_word)) != ERROR_OK)
+                       return retval;
+
+               /* take only bytes we need */
+               for (i = 0; (i < bank->bus_width) && (count > 0); i++, count--)
+                       *buffer++ = current_word[i];
+       }
+
+       return ERROR_OK;
+}
+
 static int cfi_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
 {
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
@@ -1945,7 +2216,7 @@ static int cfi_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset,
        return cfi_reset(bank);
 }
 
-static void cfi_fixup_atmel_reversed_erase_regions(struct flash_bank *bank, void *param)
+static void cfi_fixup_reversed_erase_regions(struct flash_bank *bank, void *param)
 {
        (void) param;
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
@@ -1998,9 +2269,15 @@ static int cfi_query_string(struct flash_bank *bank, int address)
                return retval;
        }
 
-       cfi_info->qry[0] = cfi_query_u8(bank, 0, 0x10);
-       cfi_info->qry[1] = cfi_query_u8(bank, 0, 0x11);
-       cfi_info->qry[2] = cfi_query_u8(bank, 0, 0x12);
+       retval = cfi_query_u8(bank, 0, 0x10, &cfi_info->qry[0]);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, 0x11, &cfi_info->qry[1]);
+       if (retval != ERROR_OK)
+               return retval;
+       retval = cfi_query_u8(bank, 0, 0x12, &cfi_info->qry[2]);
+       if (retval != ERROR_OK)
+               return retval;
 
        LOG_DEBUG("CFI qry returned: 0x%2.2x 0x%2.2x 0x%2.2x", cfi_info->qry[0], cfi_info->qry[1], cfi_info->qry[2]);
 
@@ -2036,6 +2313,16 @@ static int cfi_probe(struct flash_bank *bank)
        }
 
        cfi_info->probed = 0;
+       if (bank->sectors)
+       {
+               free(bank->sectors);
+               bank->sectors = NULL;
+       }
+       if(cfi_info->erase_region_info)
+       {
+               free(cfi_info->erase_region_info);
+               cfi_info->erase_region_info = NULL;
+       }
 
        /* JEDEC standard JESD21C uses 0x5555 and 0x2aaa as unlock addresses,
         * while CFI compatible AMD/Spansion flashes use 0x555 and 0x2aa
@@ -2101,8 +2388,6 @@ static int cfi_probe(struct flash_bank *bank)
         */
        if (cfi_info->not_cfi == 0)
        {
-               int retval;
-
                /* enter CFI query mode
                 * according to JEDEC Standard No. 68.01,
                 * a single bus sequence with address = 0x55, data = 0x98 should put
@@ -2126,25 +2411,57 @@ static int cfi_probe(struct flash_bank *bank)
                if (retval != ERROR_OK)
                        return retval;
 
-               cfi_info->pri_id = cfi_query_u16(bank, 0, 0x13);
-               cfi_info->pri_addr = cfi_query_u16(bank, 0, 0x15);
-               cfi_info->alt_id = cfi_query_u16(bank, 0, 0x17);
-               cfi_info->alt_addr = cfi_query_u16(bank, 0, 0x19);
+               retval = cfi_query_u16(bank, 0, 0x13, &cfi_info->pri_id);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u16(bank, 0, 0x15, &cfi_info->pri_addr);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u16(bank, 0, 0x17, &cfi_info->alt_id);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u16(bank, 0, 0x19, &cfi_info->alt_addr);
+               if (retval != ERROR_OK)
+                       return retval;
 
                LOG_DEBUG("qry: '%c%c%c', pri_id: 0x%4.4x, pri_addr: 0x%4.4x, alt_id: 0x%4.4x, alt_addr: 0x%4.4x", cfi_info->qry[0], cfi_info->qry[1], cfi_info->qry[2], cfi_info->pri_id, cfi_info->pri_addr, cfi_info->alt_id, cfi_info->alt_addr);
 
-               cfi_info->vcc_min = cfi_query_u8(bank, 0, 0x1b);
-               cfi_info->vcc_max = cfi_query_u8(bank, 0, 0x1c);
-               cfi_info->vpp_min = cfi_query_u8(bank, 0, 0x1d);
-               cfi_info->vpp_max = cfi_query_u8(bank, 0, 0x1e);
-               cfi_info->word_write_timeout_typ = cfi_query_u8(bank, 0, 0x1f);
-               cfi_info->buf_write_timeout_typ = cfi_query_u8(bank, 0, 0x20);
-               cfi_info->block_erase_timeout_typ = cfi_query_u8(bank, 0, 0x21);
-               cfi_info->chip_erase_timeout_typ = cfi_query_u8(bank, 0, 0x22);
-               cfi_info->word_write_timeout_max = cfi_query_u8(bank, 0, 0x23);
-               cfi_info->buf_write_timeout_max = cfi_query_u8(bank, 0, 0x24);
-               cfi_info->block_erase_timeout_max = cfi_query_u8(bank, 0, 0x25);
-               cfi_info->chip_erase_timeout_max = cfi_query_u8(bank, 0, 0x26);
+               retval = cfi_query_u8(bank, 0, 0x1b, &cfi_info->vcc_min);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u8(bank, 0, 0x1c, &cfi_info->vcc_max);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u8(bank, 0, 0x1d, &cfi_info->vpp_min);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u8(bank, 0, 0x1e, &cfi_info->vpp_max);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u8(bank, 0, 0x1f, &cfi_info->word_write_timeout_typ);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u8(bank, 0, 0x20, &cfi_info->buf_write_timeout_typ);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u8(bank, 0, 0x21, &cfi_info->block_erase_timeout_typ);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u8(bank, 0, 0x22, &cfi_info->chip_erase_timeout_typ);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u8(bank, 0, 0x23, &cfi_info->word_write_timeout_max);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u8(bank, 0, 0x24, &cfi_info->buf_write_timeout_max);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u8(bank, 0, 0x25, &cfi_info->block_erase_timeout_max);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u8(bank, 0, 0x26, &cfi_info->chip_erase_timeout_max);
+               if (retval != ERROR_OK)
+                       return retval;
 
                LOG_DEBUG("Vcc min: %x.%x, Vcc max: %x.%x, Vpp min: %u.%x, Vpp max: %u.%x",
                        (cfi_info->vcc_min & 0xf0) >> 4, cfi_info->vcc_min & 0x0f,
@@ -2158,19 +2475,33 @@ static int cfi_probe(struct flash_bank *bank)
                        (1 << cfi_info->block_erase_timeout_max) * (1 << cfi_info->block_erase_timeout_typ),
                        (1 << cfi_info->chip_erase_timeout_max) * (1 << cfi_info->chip_erase_timeout_typ));
 
-               cfi_info->dev_size = 1 << cfi_query_u8(bank, 0, 0x27);
-               cfi_info->interface_desc = cfi_query_u16(bank, 0, 0x28);
-               cfi_info->max_buf_write_size = cfi_query_u16(bank, 0, 0x2a);
-               cfi_info->num_erase_regions = cfi_query_u8(bank, 0, 0x2c);
+               uint8_t data;
+               retval = cfi_query_u8(bank, 0, 0x27, &data);
+               if (retval != ERROR_OK)
+                       return retval;
+               cfi_info->dev_size = 1 << data;
+
+               retval = cfi_query_u16(bank, 0, 0x28, &cfi_info->interface_desc);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u16(bank, 0, 0x2a, &cfi_info->max_buf_write_size);
+               if (retval != ERROR_OK)
+                       return retval;
+               retval = cfi_query_u8(bank, 0, 0x2c, &cfi_info->num_erase_regions);
+               if (retval != ERROR_OK)
+                       return retval;
 
                LOG_DEBUG("size: 0x%" PRIx32 ", interface desc: %i, max buffer write size: %x", cfi_info->dev_size, cfi_info->interface_desc, (1 << cfi_info->max_buf_write_size));
 
                if (cfi_info->num_erase_regions)
                {
-                       cfi_info->erase_region_info = malloc(4 * cfi_info->num_erase_regions);
+                       cfi_info->erase_region_info = malloc(sizeof(*cfi_info->erase_region_info)
+                                       * cfi_info->num_erase_regions);
                        for (i = 0; i < cfi_info->num_erase_regions; i++)
                        {
-                               cfi_info->erase_region_info[i] = cfi_query_u32(bank, 0, 0x2d + (4 * i));
+                               retval = cfi_query_u32(bank, 0, 0x2d + (4 * i), &cfi_info->erase_region_info[i]);
+                               if (retval != ERROR_OK)
+                                       return retval;
                                LOG_DEBUG("erase region[%i]: %" PRIu32 " blocks of size 0x%" PRIx32 "",
                                          i,
                                          (cfi_info->erase_region_info[i] & 0xffff) + 1,
@@ -2307,7 +2638,10 @@ static int cfi_intel_protect_check(struct flash_bank *bank)
 
        for (i = 0; i < bank->num_sectors; i++)
        {
-               uint8_t block_status = cfi_get_u8(bank, i, 0x2);
+               uint8_t block_status;
+               retval = cfi_get_u8(bank, i, 0x2, &block_status);
+               if (retval != ERROR_OK)
+                       return retval;
 
                if (block_status & 1)
                        bank->sectors[i].is_protected = 1;
@@ -2342,7 +2676,10 @@ static int cfi_spansion_protect_check(struct flash_bank *bank)
 
        for (i = 0; i < bank->num_sectors; i++)
        {
-               uint8_t block_status = cfi_get_u8(bank, i, 0x2);
+               uint8_t block_status;
+               retval = cfi_get_u8(bank, i, 0x2, &block_status);
+               if (retval != ERROR_OK)
+                       return retval;
 
                if (block_status & 1)
                        bank->sectors[i].is_protected = 1;
@@ -2383,12 +2720,12 @@ static int cfi_protect_check(struct flash_bank *bank)
        return ERROR_OK;
 }
 
-static int cfi_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_cfi_info(struct flash_bank *bank, char *buf, int buf_size)
 {
        int printed;
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
 
-       if (cfi_info->qry[0] == (char)-1)
+       if (cfi_info->qry[0] == 0xff)
        {
                printed = snprintf(buf, buf_size, "\ncfi flash bank not probed yet\n");
                return ERROR_OK;
@@ -2467,10 +2804,11 @@ struct flash_driver cfi_flash = {
        .erase = cfi_erase,
        .protect = cfi_protect,
        .write = cfi_write,
+       .read = cfi_read,
        .probe = cfi_probe,
        .auto_probe = cfi_auto_probe,
        /* FIXME: access flash at bus_width size */
        .erase_check = default_flash_blank_check,
        .protect_check = cfi_protect_check,
-       .info = cfi_info,
+       .info = get_cfi_info,
 };
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)