]> git.sur5r.net Git - openocd/blobdiff - src/flash/nor/cfi.c
atsamv: Support for ATSAMS70N19 Memory Configuration
[openocd] / src / flash / nor / cfi.c
index c443de2dd666669cb1e497ce2c2ced3842fd03c5..f7d8a90f181303e76873746bd4c56b7882e24936 100644 (file)
@@ -17,9 +17,7 @@
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifdef HAVE_CONFIG_H
@@ -136,6 +134,7 @@ static inline uint32_t flash_address(struct flash_bank *bank, int sector, uint32
 static void cfi_command(struct flash_bank *bank, uint8_t cmd, uint8_t *cmd_buf)
 {
        int i;
+       struct cfi_flash_bank *cfi_info = bank->driver_priv;
 
        /* clear whole buffer, to ensure bits that exceed the bus_width
         * are set to zero
@@ -143,7 +142,7 @@ static void cfi_command(struct flash_bank *bank, uint8_t cmd, uint8_t *cmd_buf)
        for (i = 0; i < CFI_MAX_BUS_WIDTH; i++)
                cmd_buf[i] = 0;
 
-       if (bank->target->endianness == TARGET_LITTLE_ENDIAN) {
+       if (cfi_info->endianness == TARGET_LITTLE_ENDIAN) {
                for (i = bank->bus_width; i > 0; i--)
                        *cmd_buf++ = (i & (bank->chip_width - 1)) ? 0x0 : cmd;
        } else {
@@ -167,6 +166,7 @@ static int cfi_send_command(struct flash_bank *bank, uint8_t cmd, uint32_t addre
 static int cfi_query_u8(struct flash_bank *bank, int sector, uint32_t offset, uint8_t *val)
 {
        struct target *target = bank->target;
+       struct cfi_flash_bank *cfi_info = bank->driver_priv;
        uint8_t data[CFI_MAX_BUS_WIDTH];
 
        int retval;
@@ -175,7 +175,7 @@ static int cfi_query_u8(struct flash_bank *bank, int sector, uint32_t offset, ui
        if (retval != ERROR_OK)
                return retval;
 
-       if (bank->target->endianness == TARGET_LITTLE_ENDIAN)
+       if (cfi_info->endianness == TARGET_LITTLE_ENDIAN)
                *val = data[0];
        else
                *val = data[bank->bus_width - 1];
@@ -190,6 +190,7 @@ static int cfi_query_u8(struct flash_bank *bank, int sector, uint32_t offset, ui
 static int cfi_get_u8(struct flash_bank *bank, int sector, uint32_t offset, uint8_t *val)
 {
        struct target *target = bank->target;
+       struct cfi_flash_bank *cfi_info = bank->driver_priv;
        uint8_t data[CFI_MAX_BUS_WIDTH];
        int i;
 
@@ -199,7 +200,7 @@ static int cfi_get_u8(struct flash_bank *bank, int sector, uint32_t offset, uint
        if (retval != ERROR_OK)
                return retval;
 
-       if (bank->target->endianness == TARGET_LITTLE_ENDIAN) {
+       if (cfi_info->endianness == TARGET_LITTLE_ENDIAN) {
                for (i = 0; i < bank->bus_width / bank->chip_width; i++)
                        data[0] |= data[i];
 
@@ -236,7 +237,7 @@ static int cfi_query_u16(struct flash_bank *bank, int sector, uint32_t offset, u
                        return retval;
        }
 
-       if (bank->target->endianness == TARGET_LITTLE_ENDIAN)
+       if (cfi_info->endianness == TARGET_LITTLE_ENDIAN)
                *val = data[0] | data[bank->bus_width] << 8;
        else
                *val = data[bank->bus_width - 1] | data[(2 * bank->bus_width) - 1] << 8;
@@ -266,7 +267,7 @@ static int cfi_query_u32(struct flash_bank *bank, int sector, uint32_t offset, u
                        return retval;
        }
 
-       if (bank->target->endianness == TARGET_LITTLE_ENDIAN)
+       if (cfi_info->endianness == TARGET_LITTLE_ENDIAN)
                *val = data[0] | data[bank->bus_width] << 8 |
                        data[bank->bus_width * 2] << 16 | data[bank->bus_width * 3] << 24;
        else
@@ -803,6 +804,7 @@ static int cfi_intel_info(struct flash_bank *bank, char *buf, int buf_size)
 FLASH_BANK_COMMAND_HANDLER(cfi_flash_bank_command)
 {
        struct cfi_flash_bank *cfi_info;
+       int bus_swap = 0;
 
        if (CMD_ARGC < 6)
                return ERROR_COMMAND_SYNTAX_ERROR;
@@ -832,14 +834,26 @@ FLASH_BANK_COMMAND_HANDLER(cfi_flash_bank_command)
        cfi_info->x16_as_x8 = 0;
        cfi_info->jedec_probe = 0;
        cfi_info->not_cfi = 0;
+       cfi_info->data_swap = 0;
 
        for (unsigned i = 6; i < CMD_ARGC; i++) {
                if (strcmp(CMD_ARGV[i], "x16_as_x8") == 0)
                        cfi_info->x16_as_x8 = 1;
+               else if (strcmp(CMD_ARGV[i], "data_swap") == 0)
+                       cfi_info->data_swap = 1;
+               else if (strcmp(CMD_ARGV[i], "bus_swap") == 0)
+                       bus_swap = 1;
                else if (strcmp(CMD_ARGV[i], "jedec_probe") == 0)
                        cfi_info->jedec_probe = 1;
        }
 
+       if (bus_swap)
+               cfi_info->endianness =
+                       bank->target->endianness == TARGET_LITTLE_ENDIAN ?
+                       TARGET_BIG_ENDIAN : TARGET_LITTLE_ENDIAN;
+       else
+               cfi_info->endianness = bank->target->endianness;
+
        /* bank wasn't probed yet */
        cfi_info->qry[0] = 0xff;
 
@@ -1103,19 +1117,6 @@ static int cfi_protect(struct flash_bank *bank, int set, int first, int last)
        }
 }
 
-/* Convert code image to target endian
- * FIXME create general block conversion fcts in target.c?) */
-static void cfi_fix_code_endian(struct target *target, uint8_t *dest,
-       const uint32_t *src, uint32_t count)
-{
-       uint32_t i;
-       for (i = 0; i < count; i++) {
-               target_buffer_set_u32(target, dest, *src);
-               dest += 4;
-               src++;
-       }
-}
-
 static uint32_t cfi_command_val(struct flash_bank *bank, uint8_t cmd)
 {
        struct target *target = bank->target;
@@ -1139,7 +1140,7 @@ static uint32_t cfi_command_val(struct flash_bank *bank, uint8_t cmd)
        }
 }
 
-static int cfi_intel_write_block(struct flash_bank *bank, uint8_t *buffer,
+static int cfi_intel_write_block(struct flash_bank *bank, const uint8_t *buffer,
        uint32_t address, uint32_t count)
 {
        struct target *target = bank->target;
@@ -1226,7 +1227,7 @@ static int cfi_intel_write_block(struct flash_bank *bank, uint8_t *buffer,
                arm_algo.core_state = ARM_STATE_ARM;
        } else {
                LOG_ERROR("Unknown architecture");
-               return ERROR_FAIL;
+               return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
        }
 
        cfi_intel_clear_status_register(bank);
@@ -1264,7 +1265,8 @@ static int cfi_intel_write_block(struct flash_bank *bank, uint8_t *buffer,
                                "Increase CFI_MAX_INTEL_CODESIZE and recompile.");
                return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
        }
-       cfi_fix_code_endian(target, target_code, target_code_src, target_code_size / 4);
+
+       target_buffer_set_u32_array(target, target_code, target_code_size / 4, target_code_src);
 
        /* Get memory for block write handler */
        retval = target_alloc_working_area(target,
@@ -1274,7 +1276,6 @@ static int cfi_intel_write_block(struct flash_bank *bank, uint8_t *buffer,
                LOG_WARNING("No working area available, can't do block memory writes");
                return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
        }
-       ;
 
        /* write algorithm code to working area */
        retval = target_write_buffer(target, write_algorithm->address,
@@ -1296,7 +1297,6 @@ static int cfi_intel_write_block(struct flash_bank *bank, uint8_t *buffer,
                        goto cleanup;
                }
        }
-       ;
 
        /* setup algo registers */
        init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
@@ -1391,7 +1391,7 @@ cleanup:
        return retval;
 }
 
-static int cfi_spansion_write_block_mips(struct flash_bank *bank, uint8_t *buffer,
+static int cfi_spansion_write_block_mips(struct flash_bank *bank, const uint8_t *buffer,
        uint32_t address, uint32_t count)
 {
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
@@ -1504,7 +1504,8 @@ static int cfi_spansion_write_block_mips(struct flash_bank *bank, uint8_t *buffe
                LOG_ERROR("Out of memory");
                return ERROR_FAIL;
        }
-       cfi_fix_code_endian(target, target_code, target_code_src, target_code_size / 4);
+
+       target_buffer_set_u32_array(target, target_code, target_code_size / 4, target_code_src);
 
        /* allocate working area */
        retval = target_alloc_working_area(target, target_code_size,
@@ -1538,18 +1539,17 @@ static int cfi_spansion_write_block_mips(struct flash_bank *bank, uint8_t *buffe
                        return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
                }
        }
-       ;
 
-       init_reg_param(&reg_params[0], "a0", 32, PARAM_OUT);
-       init_reg_param(&reg_params[1], "a1", 32, PARAM_OUT);
-       init_reg_param(&reg_params[2], "a2", 32, PARAM_OUT);
-       init_reg_param(&reg_params[3], "a3", 32, PARAM_OUT);
-       init_reg_param(&reg_params[4], "t0", 32, PARAM_OUT);
-       init_reg_param(&reg_params[5], "t1", 32, PARAM_IN);
-       init_reg_param(&reg_params[6], "t4", 32, PARAM_OUT);
-       init_reg_param(&reg_params[7], "t5", 32, PARAM_OUT);
-       init_reg_param(&reg_params[8], "t6", 32, PARAM_OUT);
-       init_reg_param(&reg_params[9], "t7", 32, PARAM_OUT);
+       init_reg_param(&reg_params[0], "r4", 32, PARAM_OUT);
+       init_reg_param(&reg_params[1], "r5", 32, PARAM_OUT);
+       init_reg_param(&reg_params[2], "r6", 32, PARAM_OUT);
+       init_reg_param(&reg_params[3], "r7", 32, PARAM_OUT);
+       init_reg_param(&reg_params[4], "r8", 32, PARAM_OUT);
+       init_reg_param(&reg_params[5], "r9", 32, PARAM_IN);
+       init_reg_param(&reg_params[6], "r12", 32, PARAM_OUT);
+       init_reg_param(&reg_params[7], "r13", 32, PARAM_OUT);
+       init_reg_param(&reg_params[8], "r14", 32, PARAM_OUT);
+       init_reg_param(&reg_params[9], "r15", 32, PARAM_OUT);
 
        while (count > 0) {
                uint32_t thisrun_count = (count > buffer_size) ? buffer_size : count;
@@ -1603,7 +1603,7 @@ static int cfi_spansion_write_block_mips(struct flash_bank *bank, uint8_t *buffe
        return retval;
 }
 
-static int cfi_spansion_write_block(struct flash_bank *bank, uint8_t *buffer,
+static int cfi_spansion_write_block(struct flash_bank *bank, const uint8_t *buffer,
        uint32_t address, uint32_t count)
 {
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
@@ -1822,7 +1822,7 @@ static int cfi_spansion_write_block(struct flash_bank *bank, uint8_t *buffer,
                arm_algo = &armv4_5_algo;
        } else {
                LOG_ERROR("Unknown architecture");
-               return ERROR_FAIL;
+               return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
        }
 
        int target_code_size = 0;
@@ -1883,7 +1883,8 @@ static int cfi_spansion_write_block(struct flash_bank *bank, uint8_t *buffer,
                LOG_ERROR("Out of memory");
                return ERROR_FAIL;
        }
-       cfi_fix_code_endian(target, target_code, target_code_src, target_code_size / 4);
+
+       target_buffer_set_u32_array(target, target_code, target_code_size / 4, target_code_src);
 
        /* allocate working area */
        retval = target_alloc_working_area(target, target_code_size,
@@ -1917,7 +1918,6 @@ static int cfi_spansion_write_block(struct flash_bank *bank, uint8_t *buffer,
                        return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
                }
        }
-       ;
 
        init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
        init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
@@ -1999,7 +1999,9 @@ static int cfi_intel_write_word(struct flash_bank *bank, uint8_t *word, uint32_t
 
        uint8_t status;
        retval = cfi_intel_wait_status_busy(bank, cfi_info->word_write_timeout, &status);
-       if (retval != 0x80) {
+       if (retval != ERROR_OK)
+               return retval;
+       if (status != 0x80) {
                retval = cfi_send_command(bank, 0xff, flash_address(bank, 0, 0x0));
                if (retval != ERROR_OK)
                        return retval;
@@ -2012,7 +2014,7 @@ static int cfi_intel_write_word(struct flash_bank *bank, uint8_t *word, uint32_t
        return ERROR_OK;
 }
 
-static int cfi_intel_write_words(struct flash_bank *bank, uint8_t *word,
+static int cfi_intel_write_words(struct flash_bank *bank, const uint8_t *word,
        uint32_t wordcount, uint32_t address)
 {
        int retval;
@@ -2132,7 +2134,7 @@ static int cfi_spansion_write_word(struct flash_bank *bank, uint8_t *word, uint3
        return ERROR_OK;
 }
 
-static int cfi_spansion_write_words(struct flash_bank *bank, uint8_t *word,
+static int cfi_spansion_write_words(struct flash_bank *bank, const uint8_t *word,
        uint32_t wordcount, uint32_t address)
 {
        int retval;
@@ -2225,7 +2227,7 @@ static int cfi_write_word(struct flash_bank *bank, uint8_t *word, uint32_t addre
        return ERROR_FLASH_OPERATION_FAILED;
 }
 
-static int cfi_write_words(struct flash_bank *bank, uint8_t *word,
+static int cfi_write_words(struct flash_bank *bank, const uint8_t *word,
        uint32_t wordcount, uint32_t address)
 {
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
@@ -2307,7 +2309,7 @@ static int cfi_read(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, u
        }
 
        if (count) {
-               LOG_INFO("Fixup %d unaligned read tail bytes", count);
+               LOG_INFO("Fixup %" PRIu32 " unaligned read tail bytes", count);
 
                /* read a complete word from flash */
                retval = target_read_memory(target, read_p, bank->bus_width, 1, current_word);
@@ -2322,7 +2324,7 @@ static int cfi_read(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, u
        return ERROR_OK;
 }
 
-static int cfi_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
+static int cfi_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
 {
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
        struct target *target = bank->target;
@@ -2332,6 +2334,8 @@ static int cfi_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset,
        int blk_count;  /* number of bus_width bytes for block copy */
        uint8_t current_word[CFI_MAX_BUS_WIDTH * 4];    /* word (bus_width size) currently being
                                                         *programmed */
+       uint8_t *swapped_buffer = NULL;
+       const uint8_t *real_buffer = NULL;
        int i;
        int retval;
 
@@ -2358,8 +2362,14 @@ static int cfi_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset,
                        return retval;
 
                /* replace only bytes that must be written */
-               for (i = align; (i < bank->bus_width) && (count > 0); i++, count--)
-                       current_word[i] = *buffer++;
+               for (i = align;
+                    (i < bank->bus_width) && (count > 0);
+                    i++, count--)
+                       if (cfi_info->data_swap)
+                               /* data bytes are swapped (reverse endianness) */
+                               current_word[bank->bus_width - i] = *buffer++;
+                       else
+                               current_word[i] = *buffer++;
 
                retval = cfi_write_word(bank, current_word, write_p);
                if (retval != ERROR_OK)
@@ -2367,6 +2377,22 @@ static int cfi_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset,
                write_p += bank->bus_width;
        }
 
+       if (cfi_info->data_swap && count) {
+               swapped_buffer = malloc(count & ~(bank->bus_width - 1));
+               switch (bank->bus_width) {
+               case 2:
+                       buf_bswap16(swapped_buffer, buffer,
+                                   count & ~(bank->bus_width - 1));
+                       break;
+               case 4:
+                       buf_bswap32(swapped_buffer, buffer,
+                                   count & ~(bank->bus_width - 1));
+                       break;
+               }
+               real_buffer = buffer;
+               buffer = swapped_buffer;
+       }
+
        /* handle blocks of bus_size aligned bytes */
        blk_count = count & ~(bank->bus_width - 1);     /* round down, leave tail bytes */
        switch (cfi_info->pri_id) {
@@ -2436,6 +2462,11 @@ static int cfi_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset,
                        return retval;
        }
 
+       if (swapped_buffer) {
+               buffer = real_buffer + (buffer - swapped_buffer);
+               free(swapped_buffer);
+       }
+
        /* return to read array mode, so we can read from flash again for padding */
        retval = cfi_reset(bank);
        if (retval != ERROR_OK)
@@ -2452,7 +2483,11 @@ static int cfi_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset,
 
                /* replace only bytes that must be written */
                for (i = 0; (i < bank->bus_width) && (count > 0); i++, count--)
-                       current_word[i] = *buffer++;
+                       if (cfi_info->data_swap)
+                               /* data bytes are swapped (reverse endianness) */
+                               current_word[bank->bus_width - i] = *buffer++;
+                       else
+                               current_word[i] = *buffer++;
 
                retval = cfi_write_word(bank, current_word, write_p);
                if (retval != ERROR_OK)
@@ -2506,9 +2541,9 @@ static void cfi_fixup_0002_unlock_addresses(struct flash_bank *bank, const void
 static void cfi_fixup_0002_polling_bits(struct flash_bank *bank, const void *param)
 {
        struct cfi_flash_bank *cfi_info = bank->driver_priv;
-       const int status_poll_mask = *(const int *)param;
+       const int *status_poll_mask = param;
 
-       cfi_info->status_poll_mask = status_poll_mask;
+       cfi_info->status_poll_mask = *status_poll_mask;
 }