Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
libusb: don't use typedef's
[openocd.git] / src / jtag / aice / aice_usb.c
diff --git a/src/jtag/aice/aice_usb.c b/src/jtag/aice/aice_usb.c
index 50b3b9a22388fd70e0767246bf896937e27fc7ac..0c219805f6246dcccbbddff28c99d4015c74b3f8 100644 (file)
--- a/src/jtag/aice/aice_usb.c
+++ b/src/jtag/aice/aice_usb.c
@@ -13,15 +13,13 @@
  *   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
 #include "config.h"
 #endif
 
-#include <jtag/drivers/libusb_common.h>
+#include <jtag/drivers/libusb_helper.h>
 #include <helper/log.h>
 #include <helper/time_support.h>
 #include <target/target.h>
@@ -42,16 +40,16 @@ static int aice_max_retry_times = 50;
 static enum aice_target_endian data_endian;
 
 /* Constants for AICE command format length */
-static const int32_t AICE_FORMAT_HTDA = 3;
-static const int32_t AICE_FORMAT_HTDC  = 7;
-static const int32_t AICE_FORMAT_HTDMA = 4;
-static const int32_t AICE_FORMAT_HTDMB = 8;
-static const int32_t AICE_FORMAT_HTDMC = 8;
-static const int32_t AICE_FORMAT_HTDMD = 12;
-static const int32_t AICE_FORMAT_DTHA  = 6;
-static const int32_t AICE_FORMAT_DTHB  = 2;
-static const int32_t AICE_FORMAT_DTHMA = 8;
-static const int32_t AICE_FORMAT_DTHMB = 4;
+#define AICE_FORMAT_HTDA        (3)
+#define AICE_FORMAT_HTDC        (7)
+#define AICE_FORMAT_HTDMA       (4)
+#define AICE_FORMAT_HTDMB       (8)
+#define AICE_FORMAT_HTDMC       (8)
+#define AICE_FORMAT_HTDMD       (12)
+#define AICE_FORMAT_DTHA        (6)
+#define AICE_FORMAT_DTHB        (2)
+#define AICE_FORMAT_DTHMA       (8)
+#define AICE_FORMAT_DTHMB       (4)
 
 /* Constants for AICE command */
 static const uint8_t AICE_CMD_SCAN_CHAIN = 0x00;
@@ -351,41 +349,53 @@ static void aice_unpack_dthmb(uint8_t *cmd_ack_code, uint8_t *target_id,
 /* calls the given usb_bulk_* function, allowing for the data to
  * trickle in with some timeouts  */
 static int usb_bulk_with_retries(
-                       int (*f)(jtag_libusb_device_handle *, int, char *, int, int),
-                       jtag_libusb_device_handle *dev, int ep,
-                       char *bytes, int size, int timeout)
+                       int (*f)(struct libusb_device_handle *, int, char *, int, int, int *),
+                       struct libusb_device_handle *dev, int ep,
+                       char *bytes, int size, int timeout, int *transferred)
 {
        int tries = 3, count = 0;
 
        while (tries && (count < size)) {
-               int result = f(dev, ep, bytes + count, size - count, timeout);
-               if (result > 0)
+               int result, ret;
+
+               ret = f(dev, ep, bytes + count, size - count, timeout, &result);
+               if (ERROR_OK == ret)
                        count += result;
-               else if ((-ETIMEDOUT != result) || !--tries)
-                       return result;
+               else if ((ERROR_TIMEOUT_REACHED != ret) || !--tries)
+                       return ret;
        }
-       return count;
+
+       *transferred = count;
+       return ERROR_OK;
 }
 
-static int wrap_usb_bulk_write(jtag_libusb_device_handle *dev, int ep,
-               char *buff, int size, int timeout)
+static int wrap_usb_bulk_write(struct libusb_device_handle *dev, int ep,
+               char *buff, int size, int timeout, int *transferred)
 {
+
        /* usb_bulk_write() takes const char *buff */
-       return jtag_libusb_bulk_write(dev, ep, buff, size, timeout);
+       jtag_libusb_bulk_write(dev, ep, buff, size, timeout, transferred);
+
+       return 0;
 }
 
-static inline int usb_bulk_write_ex(jtag_libusb_device_handle *dev, int ep,
+static inline int usb_bulk_write_ex(struct libusb_device_handle *dev, int ep,
                char *bytes, int size, int timeout)
 {
-       return usb_bulk_with_retries(&wrap_usb_bulk_write,
-                       dev, ep, bytes, size, timeout);
+       int tr = 0;
+
+       usb_bulk_with_retries(&wrap_usb_bulk_write,
+                       dev, ep, bytes, size, timeout, &tr);
+       return tr;
 }
 
-static inline int usb_bulk_read_ex(jtag_libusb_device_handle *dev, int ep,
+static inline int usb_bulk_read_ex(struct libusb_device_handle *dev, int ep,
                char *bytes, int size, int timeout)
 {
-       return usb_bulk_with_retries(&jtag_libusb_bulk_read,
-                       dev, ep, bytes, size, timeout);
+       int tr = 0;
+       usb_bulk_with_retries(&jtag_libusb_bulk_read,
+                       dev, ep, bytes, size, timeout, &tr);
+       return tr;
 }
 
 /* Write data from out_buffer to USB. */
@@ -402,7 +412,7 @@ static int aice_usb_write(uint8_t *out_buffer, int out_length)
        result = usb_bulk_write_ex(aice_handler.usb_handle, aice_handler.usb_write_ep,
                        (char *)out_buffer, out_length, AICE_USB_TIMEOUT);
 
-       DEBUG_JTAG_IO("aice_usb_write, out_length = %i, result = %i",
+       LOG_DEBUG_IO("aice_usb_write, out_length = %i, result = %i",
                        out_length, result);
 
        return result;
@@ -411,10 +421,10 @@ static int aice_usb_write(uint8_t *out_buffer, int out_length)
 /* Read data from USB into in_buffer. */
 static int aice_usb_read(uint8_t *in_buffer, int expected_size)
 {
-       int32_t result = usb_bulk_read_ex(aice_handler.usb_handle, aice_handler.usb_read_ep,
+       int result = usb_bulk_read_ex(aice_handler.usb_handle, aice_handler.usb_read_ep,
                        (char *)in_buffer, expected_size, AICE_USB_TIMEOUT);
 
-       DEBUG_JTAG_IO("aice_usb_read, result = %" PRId32, result);
+       LOG_DEBUG_IO("aice_usb_read, result = %d", result);
 
        return result;
 }
@@ -474,7 +484,9 @@ static int aice_usb_packet_flush(void)
 
                i = 0;
                while (1) {
-                       aice_read_ctrl(AICE_READ_CTRL_BATCH_STATUS, &batch_status);
+                       int retval = aice_read_ctrl(AICE_READ_CTRL_BATCH_STATUS, &batch_status);
+                       if (retval != ERROR_OK)
+                               return retval;
 
                        if (batch_status & 0x1)
                                return ERROR_OK;
@@ -542,7 +554,6 @@ static int aice_reset_box(void)
 
 static int aice_scan_chain(uint32_t *id_codes, uint8_t *num_of_ids)
 {
-       int32_t result;
        int retry_times = 0;
 
        if ((AICE_COMMAND_MODE_PACK == aice_command_mode) ||
@@ -557,9 +568,9 @@ static int aice_scan_chain(uint32_t *id_codes, uint8_t *num_of_ids)
                LOG_DEBUG("SCAN_CHAIN, length: 0x0F");
 
                /** TODO: modify receive length */
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHA);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHA);
                if (AICE_FORMAT_DTHA != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRIu32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                        AICE_FORMAT_DTHA, result);
                        return ERROR_FAIL;
                }
@@ -602,8 +613,6 @@ static int aice_scan_chain(uint32_t *id_codes, uint8_t *num_of_ids)
 
 int aice_read_ctrl(uint32_t address, uint32_t *data)
 {
-       int32_t result;
-
        if ((AICE_COMMAND_MODE_PACK == aice_command_mode) ||
                (AICE_COMMAND_MODE_BATCH == aice_command_mode))
                aice_usb_packet_flush();
@@ -614,9 +623,9 @@ int aice_read_ctrl(uint32_t address, uint32_t *data)
 
        LOG_DEBUG("READ_CTRL, address: 0x%" PRIx32, address);
 
-       result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHA);
+       int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHA);
        if (AICE_FORMAT_DTHA != result) {
-               LOG_ERROR("aice_usb_read failed (requested=%" PRIu32 ", result=%" PRId32 ")",
+               LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                AICE_FORMAT_DTHA, result);
                return ERROR_FAIL;
        }
@@ -638,8 +647,6 @@ int aice_read_ctrl(uint32_t address, uint32_t *data)
 
 int aice_write_ctrl(uint32_t address, uint32_t data)
 {
-       int32_t result;
-
        if (AICE_COMMAND_MODE_PACK == aice_command_mode) {
                aice_usb_packet_flush();
        } else if (AICE_COMMAND_MODE_BATCH == aice_command_mode) {
@@ -654,9 +661,9 @@ int aice_write_ctrl(uint32_t address, uint32_t data)
 
        LOG_DEBUG("WRITE_CTRL, address: 0x%" PRIx32 ", data: 0x%" PRIx32, address, data);
 
-       result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHB);
+       int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHB);
        if (AICE_FORMAT_DTHB != result) {
-               LOG_ERROR("aice_usb_read failed (requested=%" PRIu32 ", result=%" PRId32 ")",
+               LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                AICE_FORMAT_DTHB, result);
                return ERROR_FAIL;
        }
@@ -676,9 +683,8 @@ int aice_write_ctrl(uint32_t address, uint32_t data)
        return ERROR_OK;
 }
 
-int aice_read_dtr(uint8_t target_id, uint32_t *data)
+static int aice_read_dtr(uint8_t target_id, uint32_t *data)
 {
-       int32_t result;
        int retry_times = 0;
 
        if ((AICE_COMMAND_MODE_PACK == aice_command_mode) ||
@@ -692,9 +698,9 @@ int aice_read_dtr(uint8_t target_id, uint32_t *data)
 
                LOG_DEBUG("READ_DTR, COREID: %" PRIu8, target_id);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA);
                if (AICE_FORMAT_DTHMA != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                        AICE_FORMAT_DTHMA, result);
                        return ERROR_FAIL;
                }
@@ -727,9 +733,8 @@ int aice_read_dtr(uint8_t target_id, uint32_t *data)
        return ERROR_OK;
 }
 
-int aice_read_dtr_to_buffer(uint8_t target_id, uint32_t buffer_idx)
+static int aice_read_dtr_to_buffer(uint8_t target_id, uint32_t buffer_idx)
 {
-       int32_t result;
        int retry_times = 0;
 
        if (AICE_COMMAND_MODE_PACK == aice_command_mode) {
@@ -747,9 +752,9 @@ int aice_read_dtr_to_buffer(uint8_t target_id, uint32_t buffer_idx)
 
                LOG_DEBUG("READ_DTR_TO_BUFFER, COREID: %" PRIu8, target_id);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
                if (AICE_FORMAT_DTHMB != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")", AICE_FORMAT_DTHMB, result);
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)", AICE_FORMAT_DTHMB, result);
                        return ERROR_FAIL;
                }
 
@@ -779,9 +784,8 @@ int aice_read_dtr_to_buffer(uint8_t target_id, uint32_t buffer_idx)
        return ERROR_OK;
 }
 
-int aice_write_dtr(uint8_t target_id, uint32_t data)
+static int aice_write_dtr(uint8_t target_id, uint32_t data)
 {
-       int32_t result;
        int retry_times = 0;
 
        if (AICE_COMMAND_MODE_PACK == aice_command_mode) {
@@ -799,9 +803,9 @@ int aice_write_dtr(uint8_t target_id, uint32_t data)
 
                LOG_DEBUG("WRITE_DTR, COREID: %" PRIu8 ", data: 0x%" PRIx32, target_id, data);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
                if (AICE_FORMAT_DTHMB != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")", AICE_FORMAT_DTHMB, result);
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)", AICE_FORMAT_DTHMB, result);
                        return ERROR_FAIL;
                }
 
@@ -832,9 +836,8 @@ int aice_write_dtr(uint8_t target_id, uint32_t data)
        return ERROR_OK;
 }
 
-int aice_write_dtr_from_buffer(uint8_t target_id, uint32_t buffer_idx)
+static int aice_write_dtr_from_buffer(uint8_t target_id, uint32_t buffer_idx)
 {
-       int32_t result;
        int retry_times = 0;
 
        if (AICE_COMMAND_MODE_PACK == aice_command_mode) {
@@ -852,9 +855,9 @@ int aice_write_dtr_from_buffer(uint8_t target_id, uint32_t buffer_idx)
 
                LOG_DEBUG("WRITE_DTR_FROM_BUFFER, COREID: %" PRIu8 "", target_id);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
                if (AICE_FORMAT_DTHMB != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")", AICE_FORMAT_DTHMB, result);
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)", AICE_FORMAT_DTHMB, result);
                        return ERROR_FAIL;
                }
 
@@ -884,9 +887,8 @@ int aice_write_dtr_from_buffer(uint8_t target_id, uint32_t buffer_idx)
        return ERROR_OK;
 }
 
-int aice_read_misc(uint8_t target_id, uint32_t address, uint32_t *data)
+static int aice_read_misc(uint8_t target_id, uint32_t address, uint32_t *data)
 {
-       int32_t result;
        int retry_times = 0;
 
        if ((AICE_COMMAND_MODE_PACK == aice_command_mode) ||
@@ -900,9 +902,9 @@ int aice_read_misc(uint8_t target_id, uint32_t address, uint32_t *data)
 
                LOG_DEBUG("READ_MISC, COREID: %" PRIu8 ", address: 0x%" PRIx32, target_id, address);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA);
                if (AICE_FORMAT_DTHMA != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                        AICE_FORMAT_DTHMA, result);
                        return ERROR_AICE_DISCONNECT;
                }
@@ -934,9 +936,8 @@ int aice_read_misc(uint8_t target_id, uint32_t address, uint32_t *data)
        return ERROR_OK;
 }
 
-int aice_write_misc(uint8_t target_id, uint32_t address, uint32_t data)
+static int aice_write_misc(uint8_t target_id, uint32_t address, uint32_t data)
 {
-       int32_t result;
        int retry_times = 0;
 
        if (AICE_COMMAND_MODE_PACK == aice_command_mode) {
@@ -957,9 +958,9 @@ int aice_write_misc(uint8_t target_id, uint32_t address, uint32_t data)
                LOG_DEBUG("WRITE_MISC, COREID: %" PRIu8 ", address: 0x%" PRIx32 ", data: 0x%" PRIx32,
                                target_id, address, data);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
                if (AICE_FORMAT_DTHMB != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                        AICE_FORMAT_DTHMB, result);
                        return ERROR_FAIL;
                }
@@ -991,9 +992,8 @@ int aice_write_misc(uint8_t target_id, uint32_t address, uint32_t data)
        return ERROR_OK;
 }
 
-int aice_read_edmsr(uint8_t target_id, uint32_t address, uint32_t *data)
+static int aice_read_edmsr(uint8_t target_id, uint32_t address, uint32_t *data)
 {
-       int32_t result;
        int retry_times = 0;
 
        if ((AICE_COMMAND_MODE_PACK == aice_command_mode) ||
@@ -1007,9 +1007,9 @@ int aice_read_edmsr(uint8_t target_id, uint32_t address, uint32_t *data)
 
                LOG_DEBUG("READ_EDMSR, COREID: %" PRIu8 ", address: 0x%" PRIx32, target_id, address);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA);
                if (AICE_FORMAT_DTHMA != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                        AICE_FORMAT_DTHMA, result);
                        return ERROR_FAIL;
                }
@@ -1042,9 +1042,8 @@ int aice_read_edmsr(uint8_t target_id, uint32_t address, uint32_t *data)
        return ERROR_OK;
 }
 
-int aice_write_edmsr(uint8_t target_id, uint32_t address, uint32_t data)
+static int aice_write_edmsr(uint8_t target_id, uint32_t address, uint32_t data)
 {
-       int32_t result;
        int retry_times = 0;
 
        if (AICE_COMMAND_MODE_PACK == aice_command_mode) {
@@ -1065,9 +1064,9 @@ int aice_write_edmsr(uint8_t target_id, uint32_t address, uint32_t data)
                LOG_DEBUG("WRITE_EDMSR, COREID: %" PRIu8 ", address: 0x%" PRIx32 ", data: 0x%" PRIx32,
                                target_id, address, data);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
                if (AICE_FORMAT_DTHMB != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                        AICE_FORMAT_DTHMB, result);
                        return ERROR_FAIL;
                }
@@ -1116,7 +1115,6 @@ static int aice_switch_to_big_endian(uint32_t *word, uint8_t num_of_words)
 
 static int aice_write_dim(uint8_t target_id, uint32_t *word, uint8_t num_of_words)
 {
-       int32_t result;
        uint32_t big_endian_word[4];
        int retry_times = 0;
 
@@ -1149,9 +1147,9 @@ static int aice_write_dim(uint8_t target_id, uint32_t *word, uint8_t num_of_word
                                big_endian_word[2],
                                big_endian_word[3]);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
                if (AICE_FORMAT_DTHMB != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")", AICE_FORMAT_DTHMB, result);
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)", AICE_FORMAT_DTHMB, result);
                        return ERROR_FAIL;
                }
 
@@ -1186,7 +1184,6 @@ static int aice_write_dim(uint8_t target_id, uint32_t *word, uint8_t num_of_word
 
 static int aice_do_execute(uint8_t target_id)
 {
-       int32_t result;
        int retry_times = 0;
 
        if (AICE_COMMAND_MODE_PACK == aice_command_mode) {
@@ -1205,9 +1202,9 @@ static int aice_do_execute(uint8_t target_id)
 
                LOG_DEBUG("EXECUTE, COREID: %" PRIu8 "", target_id);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
                if (AICE_FORMAT_DTHMB != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                        AICE_FORMAT_DTHMB, result);
                        return ERROR_FAIL;
                }
@@ -1239,9 +1236,8 @@ static int aice_do_execute(uint8_t target_id)
        return ERROR_OK;
 }
 
-int aice_write_mem_b(uint8_t target_id, uint32_t address, uint32_t data)
+static int aice_write_mem_b(uint8_t target_id, uint32_t address, uint32_t data)
 {
-       int32_t result;
        int retry_times = 0;
 
        LOG_DEBUG("WRITE_MEM_B, COREID: %" PRIu8 ", ADDRESS %08" PRIx32 "  VALUE %08" PRIx32,
@@ -1261,10 +1257,9 @@ int aice_write_mem_b(uint8_t target_id, uint32_t address, uint32_t data)
                                        address, data & 0x000000FF, data_endian);
                        aice_usb_write(usb_out_buffer, AICE_FORMAT_HTDMD);
 
-                       result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
+                       int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
                        if (AICE_FORMAT_DTHMB != result) {
-                               LOG_ERROR("aice_usb_read failed (requested=%" PRId32
-                                               ", result=%" PRId32 ")", AICE_FORMAT_DTHMB, result);
+                               LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)", AICE_FORMAT_DTHMB, result);
                                return ERROR_FAIL;
                        }
 
@@ -1295,9 +1290,8 @@ int aice_write_mem_b(uint8_t target_id, uint32_t address, uint32_t data)
        return ERROR_OK;
 }
 
-int aice_write_mem_h(uint8_t target_id, uint32_t address, uint32_t data)
+static int aice_write_mem_h(uint8_t target_id, uint32_t address, uint32_t data)
 {
-       int32_t result;
        int retry_times = 0;
 
        LOG_DEBUG("WRITE_MEM_H, COREID: %" PRIu8 ", ADDRESS %08" PRIx32 "  VALUE %08" PRIx32,
@@ -1317,9 +1311,9 @@ int aice_write_mem_h(uint8_t target_id, uint32_t address, uint32_t data)
                                        (address >> 1) & 0x7FFFFFFF, data & 0x0000FFFF, data_endian);
                        aice_usb_write(usb_out_buffer, AICE_FORMAT_HTDMD);
 
-                       result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
+                       int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
                        if (AICE_FORMAT_DTHMB != result) {
-                               LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                               LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                                AICE_FORMAT_DTHMB, result);
                                return ERROR_FAIL;
                        }
@@ -1351,9 +1345,8 @@ int aice_write_mem_h(uint8_t target_id, uint32_t address, uint32_t data)
        return ERROR_OK;
 }
 
-int aice_write_mem(uint8_t target_id, uint32_t address, uint32_t data)
+static int aice_write_mem(uint8_t target_id, uint32_t address, uint32_t data)
 {
-       int32_t result;
        int retry_times = 0;
 
        LOG_DEBUG("WRITE_MEM, COREID: %" PRIu8 ", ADDRESS %08" PRIx32 "  VALUE %08" PRIx32,
@@ -1373,9 +1366,9 @@ int aice_write_mem(uint8_t target_id, uint32_t address, uint32_t data)
                                        (address >> 2) & 0x3FFFFFFF, data, data_endian);
                        aice_usb_write(usb_out_buffer, AICE_FORMAT_HTDMD);
 
-                       result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
+                       int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
                        if (AICE_FORMAT_DTHMB != result) {
-                               LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                               LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                                AICE_FORMAT_DTHMB, result);
                                return ERROR_FAIL;
                        }
@@ -1407,9 +1400,8 @@ int aice_write_mem(uint8_t target_id, uint32_t address, uint32_t data)
        return ERROR_OK;
 }
 
-int aice_fastread_mem(uint8_t target_id, uint8_t *word, uint32_t num_of_words)
+static int aice_fastread_mem(uint8_t target_id, uint8_t *word, uint32_t num_of_words)
 {
-       int32_t result;
        int retry_times = 0;
 
        if ((AICE_COMMAND_MODE_PACK == aice_command_mode) ||
@@ -1424,9 +1416,9 @@ int aice_fastread_mem(uint8_t target_id, uint8_t *word, uint32_t num_of_words)
                LOG_DEBUG("FASTREAD_MEM, COREID: %" PRIu8 ", # of DATA %08" PRIx32,
                                target_id, num_of_words);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA + (num_of_words - 1) * 4);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA + (num_of_words - 1) * 4);
                if (result < 0) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%" PRIu32 ", result=%d)",
                                        AICE_FORMAT_DTHMA + (num_of_words - 1) * 4, result);
                        return ERROR_FAIL;
                }
@@ -1458,9 +1450,8 @@ int aice_fastread_mem(uint8_t target_id, uint8_t *word, uint32_t num_of_words)
        return ERROR_OK;
 }
 
-int aice_fastwrite_mem(uint8_t target_id, const uint8_t *word, uint32_t num_of_words)
+static int aice_fastwrite_mem(uint8_t target_id, const uint8_t *word, uint32_t num_of_words)
 {
-       int32_t result;
        int retry_times = 0;
 
        if (AICE_COMMAND_MODE_PACK == aice_command_mode) {
@@ -1482,9 +1473,9 @@ int aice_fastwrite_mem(uint8_t target_id, const uint8_t *word, uint32_t num_of_w
                LOG_DEBUG("FASTWRITE_MEM, COREID: %" PRIu8 ", # of DATA %08" PRIx32,
                                target_id, num_of_words);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
                if (AICE_FORMAT_DTHMB != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                        AICE_FORMAT_DTHMB, result);
                        return ERROR_FAIL;
                }
@@ -1515,9 +1506,8 @@ int aice_fastwrite_mem(uint8_t target_id, const uint8_t *word, uint32_t num_of_w
        return ERROR_OK;
 }
 
-int aice_read_mem_b(uint8_t target_id, uint32_t address, uint32_t *data)
+static int aice_read_mem_b(uint8_t target_id, uint32_t address, uint32_t *data)
 {
-       int32_t result;
        int retry_times = 0;
 
        if ((AICE_COMMAND_MODE_PACK == aice_command_mode) ||
@@ -1531,9 +1521,9 @@ int aice_read_mem_b(uint8_t target_id, uint32_t address, uint32_t *data)
 
                LOG_DEBUG("READ_MEM_B, COREID: %" PRIu8 "", target_id);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA);
                if (AICE_FORMAT_DTHMA != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                        AICE_FORMAT_DTHMA, result);
                        return ERROR_FAIL;
                }
@@ -1566,9 +1556,8 @@ int aice_read_mem_b(uint8_t target_id, uint32_t address, uint32_t *data)
        return ERROR_OK;
 }
 
-int aice_read_mem_h(uint8_t target_id, uint32_t address, uint32_t *data)
+static int aice_read_mem_h(uint8_t target_id, uint32_t address, uint32_t *data)
 {
-       int32_t result;
        int retry_times = 0;
 
        if ((AICE_COMMAND_MODE_PACK == aice_command_mode) ||
@@ -1582,9 +1571,9 @@ int aice_read_mem_h(uint8_t target_id, uint32_t address, uint32_t *data)
 
                LOG_DEBUG("READ_MEM_H, CORE_ID: %" PRIu8 "", target_id);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA);
                if (AICE_FORMAT_DTHMA != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                        AICE_FORMAT_DTHMA, result);
                        return ERROR_FAIL;
                }
@@ -1617,9 +1606,8 @@ int aice_read_mem_h(uint8_t target_id, uint32_t address, uint32_t *data)
        return ERROR_OK;
 }
 
-int aice_read_mem(uint8_t target_id, uint32_t address, uint32_t *data)
+static int aice_read_mem(uint8_t target_id, uint32_t address, uint32_t *data)
 {
-       int32_t result;
        int retry_times = 0;
 
        if ((AICE_COMMAND_MODE_PACK == aice_command_mode) ||
@@ -1634,9 +1622,9 @@ int aice_read_mem(uint8_t target_id, uint32_t address, uint32_t *data)
 
                LOG_DEBUG("READ_MEM, COREID: %" PRIu8 "", target_id);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA);
                if (AICE_FORMAT_DTHMA != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                        AICE_FORMAT_DTHMA, result);
                        return ERROR_FAIL;
                }
@@ -1669,9 +1657,8 @@ int aice_read_mem(uint8_t target_id, uint32_t address, uint32_t *data)
        return ERROR_OK;
 }
 
-int aice_batch_buffer_read(uint8_t buf_index, uint32_t *word, uint32_t num_of_words)
+static int aice_batch_buffer_read(uint8_t buf_index, uint32_t *word, uint32_t num_of_words)
 {
-       int32_t result;
        int retry_times = 0;
 
        do {
@@ -1681,9 +1668,9 @@ int aice_batch_buffer_read(uint8_t buf_index, uint32_t *word, uint32_t num_of_wo
 
                LOG_DEBUG("BATCH_BUFFER_READ, # of DATA %08" PRIx32, num_of_words);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA + (num_of_words - 1) * 4);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMA + (num_of_words - 1) * 4);
                if (result < 0) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%" PRIu32 ", result=%d)",
                                        AICE_FORMAT_DTHMA + (num_of_words - 1) * 4, result);
                        return ERROR_FAIL;
                }
@@ -1717,7 +1704,6 @@ int aice_batch_buffer_read(uint8_t buf_index, uint32_t *word, uint32_t num_of_wo
 
 int aice_batch_buffer_write(uint8_t buf_index, const uint8_t *word, uint32_t num_of_words)
 {
-       int32_t result;
        int retry_times = 0;
 
        if (num_of_words == 0)
@@ -1735,9 +1721,9 @@ int aice_batch_buffer_write(uint8_t buf_index, const uint8_t *word, uint32_t num
 
                LOG_DEBUG("BATCH_BUFFER_WRITE, # of DATA %08" PRIx32, num_of_words);
 
-               result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
+               int result = aice_usb_read(usb_in_buffer, AICE_FORMAT_DTHMB);
                if (AICE_FORMAT_DTHMB != result) {
-                       LOG_ERROR("aice_usb_read failed (requested=%" PRId32 ", result=%" PRId32 ")",
+                       LOG_ERROR("aice_usb_read failed (requested=%d, result=%d)",
                                        AICE_FORMAT_DTHMB, result);
                        return ERROR_FAIL;
                }
@@ -1774,7 +1760,7 @@ int aice_batch_buffer_write(uint8_t buf_index, const uint8_t *word, uint32_t num
 typedef int (*read_mem_func_t)(uint32_t coreid, uint32_t address, uint32_t *data);
 typedef int (*write_mem_func_t)(uint32_t coreid, uint32_t address, uint32_t data);
 
-struct aice_nds32_info core_info[AICE_MAX_NUM_CORE];
+static struct aice_nds32_info core_info[AICE_MAX_NUM_CORE];
 static uint8_t total_num_of_core;
 
 static char *custom_srst_script;
@@ -1787,8 +1773,8 @@ static int aice_write_reg(uint32_t coreid, uint32_t num, uint32_t val);
 
 static int check_suppressed_exception(uint32_t coreid, uint32_t dbger_value)
 {
-       uint32_t ir4_value;
-       uint32_t ir6_value;
+       uint32_t ir4_value = 0;
+       uint32_t ir6_value = 0;
        /* the default value of handling_suppressed_exception is false */
        static bool handling_suppressed_exception;
 
@@ -1842,7 +1828,7 @@ static int check_privilege(uint32_t coreid, uint32_t dbger_value)
 static int aice_check_dbger(uint32_t coreid, uint32_t expect_status)
 {
        uint32_t i = 0;
-       uint32_t value_dbger;
+       uint32_t value_dbger = 0;
 
        while (1) {
                aice_read_misc(coreid, NDS_EDM_MISC_DBGER, &value_dbger);
@@ -1858,7 +1844,7 @@ static int aice_check_dbger(uint32_t coreid, uint32_t expect_status)
                if ((i % 30) == 0)
                        keep_alive();
 
-               long long then = 0;
+               int64_t then = 0;
                if (i == aice_count_to_check_dbger)
                        then = timeval_ms();
                if (i >= aice_count_to_check_dbger) {
@@ -1963,7 +1949,7 @@ static int aice_read_reg(uint32_t coreid, uint32_t num, uint32_t *val)
 
        aice_execute_dim(coreid, instructions, 4);
 
-       uint32_t value_edmsw;
+       uint32_t value_edmsw = 0;
        aice_read_edmsr(coreid, NDS_EDM_SR_EDMSW, &value_edmsw);
        if (value_edmsw & NDS_EDMSW_WDV)
                aice_read_dtr(coreid, val);
@@ -2008,7 +1994,7 @@ static int aice_write_reg(uint32_t coreid, uint32_t num, uint32_t val)
        LOG_DEBUG("aice_write_reg, reg_no: 0x%08" PRIx32 ", value: 0x%08" PRIx32, num, val);
 
        uint32_t instructions[4]; /** execute instructions in DIM */
-       uint32_t value_edmsw;
+       uint32_t value_edmsw = 0;
 
        aice_write_dtr(coreid, val);
        aice_read_edmsr(coreid, NDS_EDM_SR_EDMSW, &value_edmsw);
@@ -2097,9 +2083,9 @@ static int aice_usb_open(struct aice_port_param_s *param)
 {
        const uint16_t vids[] = { param->vid, 0 };
        const uint16_t pids[] = { param->pid, 0 };
-       struct jtag_libusb_device_handle *devh;
+       struct libusb_device_handle *devh;
 
-       if (jtag_libusb_open(vids, pids, NULL, &devh) != ERROR_OK)
+       if (jtag_libusb_open(vids, pids, NULL, &devh, NULL) != ERROR_OK)
                return ERROR_FAIL;
 
        /* BE ***VERY CAREFUL*** ABOUT MAKING CHANGES IN THIS
@@ -2115,7 +2101,7 @@ static int aice_usb_open(struct aice_port_param_s *param)
 
 #if IS_WIN32 == 0
 
-       jtag_libusb_reset_device(devh);
+       libusb_reset_device(devh);
 
 #if IS_DARWIN == 0
 
@@ -2123,7 +2109,7 @@ static int aice_usb_open(struct aice_port_param_s *param)
        /* reopen jlink after usb_reset
         * on win32 this may take a second or two to re-enumerate */
        int retval;
-       while ((retval = jtag_libusb_open(vids, pids, NULL, &devh)) != ERROR_OK) {
+       while ((retval = jtag_libusb_open(vids, pids, NULL, &devh, NULL)) != ERROR_OK) {
                usleep(1000);
                timeout--;
                if (!timeout)
@@ -2136,11 +2122,14 @@ static int aice_usb_open(struct aice_port_param_s *param)
 #endif
 
        /* usb_set_configuration required under win32 */
-       jtag_libusb_set_configuration(devh, 0);
+       libusb_set_configuration(devh, 0);
+       libusb_claim_interface(devh, 0);
 
        unsigned int aice_read_ep;
        unsigned int aice_write_ep;
-       jtag_libusb_choose_interface(devh, &aice_read_ep, &aice_write_ep, -1, -1, -1);
+
+       jtag_libusb_choose_interface(devh, &aice_read_ep, &aice_write_ep, -1, -1, -1, LIBUSB_TRANSFER_TYPE_BULK);
+       LOG_DEBUG("aice_read_ep=0x%x, aice_write_ep=0x%x", aice_read_ep, aice_write_ep);
 
        aice_handler.usb_read_ep = aice_read_ep;
        aice_handler.usb_write_ep = aice_write_ep;
@@ -2285,37 +2274,39 @@ get_delay:
 
 static int aice_usb_set_clock(int set_clock)
 {
-       if (aice_write_ctrl(AICE_WRITE_CTRL_TCK_CONTROL,
-                               AICE_TCK_CONTROL_TCK_SCAN) != ERROR_OK)
-               return ERROR_FAIL;
+       if (set_clock & AICE_TCK_CONTROL_TCK_SCAN) {
+               if (aice_write_ctrl(AICE_WRITE_CTRL_TCK_CONTROL,
+                                       AICE_TCK_CONTROL_TCK_SCAN) != ERROR_OK)
+                       return ERROR_FAIL;
 
-       /* Read out TCK_SCAN clock value */
-       uint32_t scan_clock;
-       if (aice_read_ctrl(AICE_READ_CTRL_GET_ICE_STATE, &scan_clock) != ERROR_OK)
-               return ERROR_FAIL;
+               /* Read out TCK_SCAN clock value */
+               uint32_t scan_clock;
+               if (aice_read_ctrl(AICE_READ_CTRL_GET_ICE_STATE, &scan_clock) != ERROR_OK)
+                       return ERROR_FAIL;
 
-       scan_clock &= 0x0F;
+               scan_clock &= 0x0F;
 
-       uint32_t scan_base_freq;
-       if (scan_clock & 0x8)
-               scan_base_freq = 48000; /* 48 MHz */
-       else
-               scan_base_freq = 30000; /* 30 MHz */
+               uint32_t scan_base_freq;
+               if (scan_clock & 0x8)
+                       scan_base_freq = 48000; /* 48 MHz */
+               else
+                       scan_base_freq = 30000; /* 30 MHz */
 
-       uint32_t set_base_freq;
-       if (set_clock & 0x8)
-               set_base_freq = 48000;
-       else
-               set_base_freq = 30000;
+               uint32_t set_base_freq;
+               if (set_clock & 0x8)
+                       set_base_freq = 48000;
+               else
+                       set_base_freq = 30000;
 
-       uint32_t set_freq;
-       uint32_t scan_freq;
-       set_freq = set_base_freq >> (set_clock & 0x7);
-       scan_freq = scan_base_freq >> (scan_clock & 0x7);
+               uint32_t set_freq;
+               uint32_t scan_freq;
+               set_freq = set_base_freq >> (set_clock & 0x7);
+               scan_freq = scan_base_freq >> (scan_clock & 0x7);
 
-       if (scan_freq < set_freq) {
-               LOG_ERROR("User specifies higher jtag clock than TCK_SCAN clock");
-               return ERROR_FAIL;
+               if (scan_freq < set_freq) {
+                       LOG_ERROR("User specifies higher jtag clock than TCK_SCAN clock");
+                       return ERROR_FAIL;
+               }
        }
 
        if (aice_write_ctrl(AICE_WRITE_CTRL_TCK_CONTROL, set_clock) != ERROR_OK)
@@ -2432,7 +2423,7 @@ static int aice_backup_tmp_registers(uint32_t coreid)
        LOG_DEBUG("backup_tmp_registers -");
 
        /* backup target DTR first(if the target DTR is valid) */
-       uint32_t value_edmsw;
+       uint32_t value_edmsw = 0;
        aice_read_edmsr(coreid, NDS_EDM_SR_EDMSW, &value_edmsw);
        core_info[coreid].edmsw_backup = value_edmsw;
        if (value_edmsw & 0x1) { /* EDMSW.WDV == 1 */
@@ -2546,15 +2537,9 @@ static int aice_usb_close(void)
 {
        jtag_libusb_close(aice_handler.usb_handle);
 
-       if (custom_srst_script)
-               free(custom_srst_script);
-
-       if (custom_trst_script)
-               free(custom_trst_script);
-
-       if (custom_restart_script)
-               free(custom_restart_script);
-
+       free(custom_srst_script);
+       free(custom_trst_script);
+       free(custom_restart_script);
        return ERROR_OK;
 }
 
@@ -2599,13 +2584,13 @@ static int aice_usb_halt(uint32_t coreid)
        aice_init_edm_registers(coreid, false);
 
        /** Clear EDM_CTL.DBGIM & EDM_CTL.DBGACKM */
-       uint32_t edm_ctl_value;
+       uint32_t edm_ctl_value = 0;
        aice_read_edmsr(coreid, NDS_EDM_SR_EDM_CTL, &edm_ctl_value);
        if (edm_ctl_value & 0x3)
                aice_write_edmsr(coreid, NDS_EDM_SR_EDM_CTL, edm_ctl_value & ~(0x3));
 
-       uint32_t dbger;
-       uint32_t acc_ctl_value;
+       uint32_t dbger = 0;
+       uint32_t acc_ctl_value = 0;
 
        core_info[coreid].debug_under_dex_on = false;
        aice_read_misc(coreid, NDS_EDM_MISC_DBGER, &dbger);
@@ -2646,7 +2631,7 @@ static int aice_usb_halt(uint32_t coreid)
                         * it is only for debugging 'debug exception handler' purpose.
                         * after openocd detaches from target, target behavior is
                         * undefined. */
-                       uint32_t ir0_value;
+                       uint32_t ir0_value = 0;
                        uint32_t debug_mode_ir0_value;
                        aice_read_reg(coreid, IR0, &ir0_value);
                        debug_mode_ir0_value = ir0_value | 0x408; /* turn on DEX, set POM = 1 */
@@ -2809,7 +2794,7 @@ static int aice_issue_reset_hold(uint32_t coreid)
        /* set no_dbgi_pin to 0 */
        uint32_t pin_status;
        aice_read_ctrl(AICE_READ_CTRL_GET_JTAG_PIN_STATUS, &pin_status);
-       if (pin_status | 0x4)
+       if (pin_status & 0x4)
                aice_write_ctrl(AICE_WRITE_CTRL_JTAG_PIN_STATUS, pin_status & (~0x4));
 
        /* issue restart */
@@ -2999,7 +2984,7 @@ static int aice_usb_step(uint32_t coreid)
                if (AICE_TARGET_HALTED == state)
                        break;
 
-               long long then = 0;
+               int64_t then = 0;
                if (i == 30)
                        then = timeval_ms();
 
@@ -3426,10 +3411,10 @@ static int aice_usb_memory_mode(uint32_t coreid, enum nds_memory_select mem_sele
        return ERROR_OK;
 }
 
-static int aice_usb_read_tlb(uint32_t coreid, uint32_t virtual_address,
-               uint32_t *physical_address)
+static int aice_usb_read_tlb(uint32_t coreid, target_addr_t virtual_address,
+               target_addr_t *physical_address)
 {
-       LOG_DEBUG("aice_usb_read_tlb, virtual address: 0x%08" PRIx32, virtual_address);
+       LOG_DEBUG("aice_usb_read_tlb, virtual address: 0x%08" TARGET_PRIxADDR, virtual_address);
 
        uint32_t instructions[4];
        uint32_t probe_result;
@@ -4014,7 +3999,7 @@ static int aice_usb_profiling(uint32_t coreid, uint32_t interval, uint32_t itera
 
                /* check status */
                uint32_t i;
-               uint32_t batch_status;
+               uint32_t batch_status = 0;
 
                i = 0;
                while (1) {
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)