Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
target/xtensa: avoid IHI for writes to non-executable memory
[openocd.git] / src / flash / nor / lpc2000.c
diff --git a/src/flash/nor/lpc2000.c b/src/flash/nor/lpc2000.c
index 3ad62d669d872b7e27a7ba8a28bc607f75601ab6..f12eef7e4ce68fc8830773f6c57da57dfb87d6b8 100644 (file)
--- a/src/flash/nor/lpc2000.c
+++ b/src/flash/nor/lpc2000.c
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
 /***************************************************************************
  *   Copyright (C) 2005 by Dominic Rath                                    *
  *   Dominic.Rath@gmx.de                                                   *
@@ -14,19 +16,6 @@
  *                                                                         *
  *   LPC8N04/HNS31xx support Copyright (C) 2018                            *
  *   by Jean-Christian de Rivaz jcdr [at] innodelec [dot] ch               *
- *                                                                         *
- *   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  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- *   This program is distributed in the hope that it will be useful,       *
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
- *   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, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifdef HAVE_CONFIG_H
@@ -281,18 +270,18 @@
 
 #define IAP_CODE_LEN 0x34
 
-#define LPC11xx_REG_SECTORS    24
+#define LPC11XX_REG_SECTORS    24
 
 typedef enum {
-       lpc2000_v1,
-       lpc2000_v2,
-       lpc1700,
-       lpc4300,
-       lpc800,
-       lpc1100,
-       lpc1500,
-       lpc54100,
-       lpc_auto,
+       LPC2000_V1,
+       LPC2000_V2,
+       LPC1700,
+       LPC4300,
+       LPC800,
+       LPC1100,
+       LPC1500,
+       LPC54100,
+       LPC_AUTO,
 } lpc2000_variant;
 
 struct lpc2000_flash_bank {
@@ -342,7 +331,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
        /* default to a 4096 write buffer */
        lpc2000_info->cmd51_max_buffer = 4096;
 
-       if (lpc2000_info->variant == lpc2000_v1) {
+       if (lpc2000_info->variant == LPC2000_V1) {
                lpc2000_info->cmd51_dst_boundary = 512;
                lpc2000_info->checksum_vector = 5;
                lpc2000_info->iap_max_stack = 128;
@@ -387,7 +376,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                        LOG_ERROR("BUG: unknown bank->size encountered");
                        exit(-1);
                }
-       } else if (lpc2000_info->variant == lpc2000_v2) {
+       } else if (lpc2000_info->variant == LPC2000_V2) {
                lpc2000_info->cmd51_dst_boundary = 256;
                lpc2000_info->checksum_vector = 5;
                lpc2000_info->iap_max_stack = 128;
@@ -453,7 +442,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                                bank->sectors[i].is_protected = 1;
                        }
                }
-       } else if (lpc2000_info->variant == lpc1700) {
+       } else if (lpc2000_info->variant == LPC1700) {
                lpc2000_info->cmd51_dst_boundary = 256;
                lpc2000_info->checksum_vector = 7;
                lpc2000_info->iap_max_stack = 128;
@@ -502,7 +491,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                        bank->sectors[i].is_erased = -1;
                        bank->sectors[i].is_protected = 1;
                }
-       } else if (lpc2000_info->variant == lpc4300) {
+       } else if (lpc2000_info->variant == LPC4300) {
                lpc2000_info->cmd51_dst_boundary = 512;
                lpc2000_info->checksum_vector = 7;
                lpc2000_info->iap_max_stack = 208;
@@ -533,7 +522,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                        bank->sectors[i].is_protected = 1;
                }
 
-       } else if (lpc2000_info->variant == lpc800) {
+       } else if (lpc2000_info->variant == LPC800) {
                lpc2000_info->cmd51_dst_boundary = 64;
                lpc2000_info->checksum_vector = 7;
                lpc2000_info->iap_max_stack = 208;              /* 148byte for LPC81x,208byte for LPC82x. */
@@ -577,7 +566,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                        bank->sectors[i].is_protected = 1;
                }
 
-       } else if (lpc2000_info->variant == lpc1100) {
+       } else if (lpc2000_info->variant == LPC1100) {
                lpc2000_info->cmd51_dst_boundary = 256;
                lpc2000_info->checksum_vector = 7;
                lpc2000_info->iap_max_stack = 128;
@@ -590,9 +579,9 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                unsigned int large_sectors = 0;
                unsigned int normal_sectors = bank->size / 4096;
 
-               if (normal_sectors > LPC11xx_REG_SECTORS) {
-                       large_sectors = (normal_sectors - LPC11xx_REG_SECTORS) / 8;
-                       normal_sectors = LPC11xx_REG_SECTORS;
+               if (normal_sectors > LPC11XX_REG_SECTORS) {
+                       large_sectors = (normal_sectors - LPC11XX_REG_SECTORS) / 8;
+                       normal_sectors = LPC11XX_REG_SECTORS;
                }
 
                bank->num_sectors = normal_sectors + large_sectors;
@@ -601,13 +590,13 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
 
                for (unsigned int i = 0; i < bank->num_sectors; i++) {
                        bank->sectors[i].offset = offset;
-                       bank->sectors[i].size = (i < LPC11xx_REG_SECTORS ? 4 : 32) * 1024;
+                       bank->sectors[i].size = (i < LPC11XX_REG_SECTORS ? 4 : 32) * 1024;
                        offset += bank->sectors[i].size;
                        bank->sectors[i].is_erased = -1;
                        bank->sectors[i].is_protected = 1;
                }
 
-       } else if (lpc2000_info->variant == lpc1500) {
+       } else if (lpc2000_info->variant == LPC1500) {
                lpc2000_info->cmd51_dst_boundary = 256;
                lpc2000_info->checksum_vector = 7;
                lpc2000_info->iap_max_stack = 128;
@@ -638,7 +627,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                        bank->sectors[i].is_protected = 1;
                }
 
-       } else if (lpc2000_info->variant == lpc54100) {
+       } else if (lpc2000_info->variant == LPC54100) {
                lpc2000_info->cmd51_dst_boundary = 256;
                lpc2000_info->checksum_vector = 7;
                lpc2000_info->iap_max_stack = 128;
@@ -697,18 +686,18 @@ static int lpc2000_iap_working_area_init(struct flash_bank *bank, struct working
 
        /* write IAP code to working area */
        switch (lpc2000_info->variant) {
-               case lpc800:
-               case lpc1100:
-               case lpc1500:
-               case lpc1700:
-               case lpc4300:
-               case lpc54100:
-               case lpc_auto:
+               case LPC800:
+               case LPC1100:
+               case LPC1500:
+               case LPC1700:
+               case LPC4300:
+               case LPC54100:
+               case LPC_AUTO:
                        target_buffer_set_u32(target, jump_gate, ARMV4_5_T_BX(12));
                        target_buffer_set_u32(target, jump_gate + 4, ARMV5_T_BKPT(0));
                        break;
-               case lpc2000_v1:
-               case lpc2000_v2:
+               case LPC2000_V1:
+               case LPC2000_V2:
                        target_buffer_set_u32(target, jump_gate, ARMV4_5_BX(12));
                        target_buffer_set_u32(target, jump_gate + 4, ARMV4_5_B(0xfffffe, 0));
                        break;
@@ -740,28 +729,28 @@ static int lpc2000_iap_call(struct flash_bank *bank, struct working_area *iap_wo
        uint32_t iap_entry_point = 0;   /* to make compiler happier */
 
        switch (lpc2000_info->variant) {
-               case lpc800:
-               case lpc1100:
-               case lpc1700:
-               case lpc_auto:
+               case LPC800:
+               case LPC1100:
+               case LPC1700:
+               case LPC_AUTO:
                        armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
                        armv7m_info.core_mode = ARM_MODE_THREAD;
                        iap_entry_point = 0x1fff1ff1;
                        break;
-               case lpc1500:
-               case lpc54100:
+               case LPC1500:
+               case LPC54100:
                        armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
                        armv7m_info.core_mode = ARM_MODE_THREAD;
                        iap_entry_point = 0x03000205;
                        break;
-               case lpc2000_v1:
-               case lpc2000_v2:
+               case LPC2000_V1:
+               case LPC2000_V2:
                        arm_algo.common_magic = ARM_COMMON_MAGIC;
                        arm_algo.core_mode = ARM_MODE_SVC;
                        arm_algo.core_state = ARM_STATE_ARM;
                        iap_entry_point = 0x7ffffff1;
                        break;
-               case lpc4300:
+               case LPC4300:
                        armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
                        armv7m_info.core_mode = ARM_MODE_THREAD;
                        /* read out IAP entry point from ROM driver table at 0x10400100 */
@@ -802,13 +791,13 @@ static int lpc2000_iap_call(struct flash_bank *bank, struct working_area *iap_wo
        buf_set_u32(reg_params[2].value, 0, 32, iap_entry_point);
 
        switch (lpc2000_info->variant) {
-               case lpc800:
-               case lpc1100:
-               case lpc1500:
-               case lpc1700:
-               case lpc4300:
-               case lpc54100:
-               case lpc_auto:
+               case LPC800:
+               case LPC1100:
+               case LPC1500:
+               case LPC1700:
+               case LPC4300:
+               case LPC54100:
+               case LPC_AUTO:
                        /* IAP stack */
                        init_reg_param(&reg_params[3], "sp", 32, PARAM_OUT);
                        buf_set_u32(reg_params[3].value, 0, 32,
@@ -822,8 +811,8 @@ static int lpc2000_iap_call(struct flash_bank *bank, struct working_area *iap_wo
                        target_run_algorithm(target, 2, mem_params, 5, reg_params, iap_working_area->address, 0, 10000,
                                        &armv7m_info);
                        break;
-               case lpc2000_v1:
-               case lpc2000_v2:
+               case LPC2000_V1:
+               case LPC2000_V2:
                        /* IAP stack */
                        init_reg_param(&reg_params[3], "sp_svc", 32, PARAM_OUT);
                        buf_set_u32(reg_params[3].value, 0, 32,
@@ -879,7 +868,7 @@ static int lpc2000_iap_blank_check(struct flash_bank *bank, unsigned int first,
                return retval;
 
        struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
-       if (lpc2000_info->variant == lpc4300)
+       if (lpc2000_info->variant == LPC4300)
                param_table[2] = lpc2000_info->lpc4300_bank;
 
        for (unsigned int i = first; i <= last && retval == ERROR_OK; i++) {
@@ -929,23 +918,23 @@ FLASH_BANK_COMMAND_HANDLER(lpc2000_flash_bank_command)
        bank->driver_priv = lpc2000_info;
 
        if (strcmp(CMD_ARGV[6], "lpc2000_v1") == 0) {
-               lpc2000_info->variant = lpc2000_v1;
+               lpc2000_info->variant = LPC2000_V1;
        } else if (strcmp(CMD_ARGV[6], "lpc2000_v2") == 0) {
-               lpc2000_info->variant = lpc2000_v2;
+               lpc2000_info->variant = LPC2000_V2;
        } else if (strcmp(CMD_ARGV[6], "lpc1700") == 0 || strcmp(CMD_ARGV[6], "lpc4000") == 0) {
-               lpc2000_info->variant = lpc1700;
+               lpc2000_info->variant = LPC1700;
        } else if (strcmp(CMD_ARGV[6], "lpc1800") == 0 || strcmp(CMD_ARGV[6], "lpc4300") == 0) {
-               lpc2000_info->variant = lpc4300;
+               lpc2000_info->variant = LPC4300;
        } else if (strcmp(CMD_ARGV[6], "lpc800") == 0) {
-               lpc2000_info->variant = lpc800;
+               lpc2000_info->variant = LPC800;
        } else if (strcmp(CMD_ARGV[6], "lpc1100") == 0) {
-               lpc2000_info->variant = lpc1100;
+               lpc2000_info->variant = LPC1100;
        } else if (strcmp(CMD_ARGV[6], "lpc1500") == 0) {
-               lpc2000_info->variant = lpc1500;
+               lpc2000_info->variant = LPC1500;
        } else if (strcmp(CMD_ARGV[6], "lpc54100") == 0) {
-               lpc2000_info->variant = lpc54100;
+               lpc2000_info->variant = LPC54100;
        } else if (strcmp(CMD_ARGV[6], "auto") == 0) {
-               lpc2000_info->variant = lpc_auto;
+               lpc2000_info->variant = LPC_AUTO;
        } else {
                LOG_ERROR("unknown LPC2000 variant: %s", CMD_ARGV[6]);
                free(lpc2000_info);
@@ -993,7 +982,7 @@ static int lpc2000_erase(struct flash_bank *bank, unsigned int first,
        param_table[0] = first;
        param_table[1] = last;
 
-       if (lpc2000_info->variant == lpc4300)
+       if (lpc2000_info->variant == LPC4300)
                param_table[2] = lpc2000_info->lpc4300_bank;
        else
                param_table[2] = lpc2000_info->cclk;
@@ -1006,7 +995,7 @@ static int lpc2000_erase(struct flash_bank *bank, unsigned int first,
        if (retval != ERROR_OK)
                return retval;
 
-       if (lpc2000_info->variant == lpc4300)
+       if (lpc2000_info->variant == LPC4300)
                /* Init IAP Anyway */
                lpc2000_iap_call(bank, iap_working_area, 49, param_table, result_table);
 
@@ -1030,7 +1019,7 @@ static int lpc2000_erase(struct flash_bank *bank, unsigned int first,
        if (retval == ERROR_OK) {
                /* Erase sectors */
                param_table[2] = lpc2000_info->cclk;
-               if (lpc2000_info->variant == lpc4300)
+               if (lpc2000_info->variant == LPC4300)
                        param_table[3] = lpc2000_info->lpc4300_bank;
 
                status_code = lpc2000_iap_call(bank, iap_working_area, 52, param_table, result_table);
@@ -1134,7 +1123,7 @@ static int lpc2000_write(struct flash_bank *bank, const uint8_t *buffer, uint32_
        uint32_t param_table[5] = {0};
        uint32_t result_table[4];
 
-       if (lpc2000_info->variant == lpc4300)
+       if (lpc2000_info->variant == LPC4300)
                /* Init IAP Anyway */
                lpc2000_iap_call(bank, iap_working_area, 49, param_table, result_table);
 
@@ -1149,7 +1138,7 @@ static int lpc2000_write(struct flash_bank *bank, const uint8_t *buffer, uint32_
                param_table[0] = first_sector;
                param_table[1] = last_sector;
 
-               if (lpc2000_info->variant == lpc4300)
+               if (lpc2000_info->variant == LPC4300)
                        param_table[2] = lpc2000_info->lpc4300_bank;
                else
                        param_table[2] = lpc2000_info->cclk;
@@ -1280,7 +1269,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
        switch (part_id) {
                case LPC1110_1:
                case LPC1110_2:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 4 * 1024;
                        break;
 
@@ -1296,7 +1285,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC11E11_101:
                case LPC1311:
                case LPC1311_1:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 8 * 1024;
                        break;
 
@@ -1316,7 +1305,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC11U12_201_1:
                case LPC11U12_201_2:
                case LPC1342:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 16 * 1024;
                        break;
 
@@ -1331,7 +1320,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC11U13_201_1:
                case LPC11U13_201_2:
                case LPC11U23_301:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 24 * 1024;
                        break;
 
@@ -1359,18 +1348,18 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC1343:
                case LPC1343_1:
                case LPC1345:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 32 * 1024;
                        break;
 
                case LPC1751_1:
                case LPC1751_2:
-                       lpc2000_info->variant = lpc1700;
+                       lpc2000_info->variant = LPC1700;
                        bank->size = 32 * 1024;
                        break;
 
                case LPC11U34_311:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 40 * 1024;
                        break;
 
@@ -1378,12 +1367,12 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC11U34_421:
                case LPC1316:
                case LPC1346:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 48 * 1024;
                        break;
 
                case LPC1114_333_1:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 56 * 1024;
                        break;
 
@@ -1394,19 +1383,19 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC11U66:
                case LPC1317:
                case LPC1347:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 64 * 1024;
                        break;
 
                case LPC1752:
                case LPC4072:
-                       lpc2000_info->variant = lpc1700;
+                       lpc2000_info->variant = LPC1700;
                        bank->size = 64 * 1024;
                        break;
 
                case LPC11E36_501:
                case LPC11U36_401:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 96 * 1024;
                        break;
 
@@ -1419,7 +1408,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC11E68:
                case LPC11U67_1:
                case LPC11U67_2:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 128 * 1024;
                        break;
 
@@ -1427,13 +1416,13 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC1764:
                case LPC1774:
                case LPC4074:
-                       lpc2000_info->variant = lpc1700;
+                       lpc2000_info->variant = LPC1700;
                        bank->size = 128 * 1024;
                        break;
 
                case LPC11U68_1:
                case LPC11U68_2:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 256 * 1024;
                        break;
 
@@ -1445,7 +1434,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC1785:
                case LPC1786:
                case LPC4076:
-                       lpc2000_info->variant = lpc1700;
+                       lpc2000_info->variant = LPC1700;
                        bank->size = 256 * 1024;
                        break;
 
@@ -1460,17 +1449,17 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC1788:
                case LPC4078:
                case LPC4088:
-                       lpc2000_info->variant = lpc1700;
+                       lpc2000_info->variant = LPC1700;
                        bank->size = 512 * 1024;
                        break;
 
                case LPC810_021:
-                       lpc2000_info->variant = lpc800;
+                       lpc2000_info->variant = LPC800;
                        bank->size = 4 * 1024;
                        break;
 
                case LPC811_001:
-                       lpc2000_info->variant = lpc800;
+                       lpc2000_info->variant = LPC800;
                        bank->size = 8 * 1024;
                        break;
 
@@ -1480,13 +1469,13 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC812_101_3:
                case LPC822_101:
                case LPC822_101_1:
-                       lpc2000_info->variant = lpc800;
+                       lpc2000_info->variant = LPC800;
                        bank->size = 16 * 1024;
                        break;
 
                case LPC824_201:
                case LPC824_201_1:
-                       lpc2000_info->variant = lpc800;
+                       lpc2000_info->variant = LPC800;
                        bank->size = 32 * 1024;
                        break;
 
@@ -1494,7 +1483,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case NHS3100:
                case NHS3152:
                case NHS3153:
-                       lpc2000_info->variant = lpc800;
+                       lpc2000_info->variant = LPC800;
                        bank->size = 30 * 1024;
                        break;
 
@@ -1505,7 +1494,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC845_301_1:
                case LPC845_301_2:
                case LPC845_301_3:
-                       lpc2000_info->variant = lpc800;
+                       lpc2000_info->variant = LPC800;
                        bank->size = 64 * 1024;
                        break;
 
@@ -1524,11 +1513,11 @@ static int lpc2000_probe(struct flash_bank *bank)
        struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
 
        if (!lpc2000_info->probed) {
-               if (lpc2000_info->variant == lpc_auto) {
+               if (lpc2000_info->variant == LPC_AUTO) {
                        status = lpc2000_auto_probe_flash(bank);
                        if (status != ERROR_OK)
                                return status;
-               } else if (lpc2000_info->variant == lpc1100 || lpc2000_info->variant == lpc1700) {
+               } else if (lpc2000_info->variant == LPC1100 || lpc2000_info->variant == LPC1700) {
                        status = get_lpc2000_part_id(bank, &part_id);
                        if (status == LPC2000_CMD_SUCCESS)
                                LOG_INFO("If auto-detection fails for this part, please email "
@@ -1552,12 +1541,12 @@ static int lpc2000_erase_check(struct flash_bank *bank)
        return lpc2000_iap_blank_check(bank, 0, bank->num_sectors - 1);
 }
 
-static int get_lpc2000_info(struct flash_bank *bank, char *buf, int buf_size)
+static int get_lpc2000_info(struct flash_bank *bank, struct command_invocation *cmd)
 {
        struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
 
-       snprintf(buf, buf_size, "lpc2000 flash driver variant: %i, clk: %" PRIu32 "kHz", lpc2000_info->variant,
-                       lpc2000_info->cclk);
+       command_print_sameline(cmd, "lpc2000 flash driver variant: %i, clk: %" PRIu32 "kHz",
+                       lpc2000_info->variant, lpc2000_info->cclk);
 
        return ERROR_OK;
 }
@@ -1569,7 +1558,7 @@ COMMAND_HANDLER(lpc2000_handle_part_id_command)
 
        struct flash_bank *bank;
        int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
-       if (ERROR_OK != retval)
+       if (retval != ERROR_OK)
                return retval;
 
        if (bank->target->state != TARGET_HALTED) {
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)