This is an automated email from Gerrit.
"ZhiYuanNJ <871238...@qq.com>" just uploaded a new patch set to Gerrit, which
you can find at https://review.openocd.org/c/openocd/+/8612
-- gerrit
commit 27b3defa48d1bb52103fe9322c113caec7b9b92b
Author: Henrik Mau <henrik....@analog.com>
Date: Wed Nov 13 15:43:23 2024 +0000
jtag/drivers: Add support for WCH CH347T/F interfaces
CH347 is a high-speed USB bus converter chip.
Can provides JTAG/SWD/UART/SPI/I2C interface through USB bus.
This driver comes from:
https://github.com/WCHSoftGroup/ch347
Change-Id: Id19b6ba270f8bd19943dde3bbd986c99553b82c8
Signed-off-by: ZhiYuanNJ <871238...@qq.com>
diff --git a/configure.ac b/configure.ac
index 567152b0a6..8feec92b06 100644
--- a/configure.ac
+++ b/configure.ac
@@ -121,6 +121,7 @@ m4_define([ADAPTER_OPT], [m4_translit(ADAPTER_ARG($1), [_],
[-])])
m4_define([USB1_ADAPTERS],
[[[ftdi], [MPSSE mode of FTDI based devices], [FTDI]],
+ [[ch347], [Mode 3 of CH347 based devices], [CH347]],
[[stlink], [ST-Link Programmer], [HLADAPTER_STLINK]],
[[ti_icdi], [TI ICDI JTAG Programmer], [HLADAPTER_ICDI]],
[[ulink], [Keil ULINK JTAG Programmer], [ULINK]],
@@ -405,6 +406,10 @@ AC_ARG_ENABLE([remote-bitbang],
AS_HELP_STRING([--enable-remote-bitbang], [Enable building support for the
Remote Bitbang driver]),
[build_remote_bitbang=$enableval], [build_remote_bitbang=no])
+AC_ARG_ENABLE([ch347],
+ AS_HELP_STRING([--enable-ch347], [Enable building support for CH347]),
+ [build_ch347=$enableval], [build_ch347=no])
+
AS_CASE(["${host_cpu}"],
[i?86|x86*], [],
[
@@ -632,6 +637,12 @@ AS_IF([test "x$build_sysfsgpio" = "xyes"], [
AC_DEFINE([BUILD_SYSFSGPIO], [0], [0 if you don't want SysfsGPIO driver.])
])
+AS_IF([test "x$build_ch347" = "xyes"], [
+ AC_DEFINE([BUILD_CH347], [1], [1 if you want CH347.])
+], [
+ AC_DEFINE([BUILD_CH347], [0], [0 if you don't want CH347.])
+])
+
PKG_CHECK_MODULES([LIBUSB1], [libusb-1.0], [
use_libusb1=yes
AC_DEFINE([HAVE_LIBUSB1], [1], [Define if you have libusb-1.x])
@@ -795,6 +806,7 @@ AM_CONDITIONAL([USE_LIBJAYLINK], [test "x$use_libjaylink" =
"xyes"])
AM_CONDITIONAL([RSHIM], [test "x$build_rshim" = "xyes"])
AM_CONDITIONAL([DMEM], [test "x$build_dmem" = "xyes"])
AM_CONDITIONAL([HAVE_CAPSTONE], [test "x$enable_capstone" != "xno"])
+AM_CONDITIONAL([BUILD_CH347], [test "x$build_ch347" = "xyes"])
AM_CONDITIONAL([INTERNAL_JIMTCL], [test "x$use_internal_jimtcl" = "xyes"])
AM_CONDITIONAL([HAVE_JIMTCL_PKG_CONFIG], [test "x$have_jimtcl_pkg_config" =
"xyes"])
diff --git a/contrib/60-openocd.rules b/contrib/60-openocd.rules
index 29f8d7a6d4..5ff0dc22be 100644
--- a/contrib/60-openocd.rules
+++ b/contrib/60-openocd.rules
@@ -216,6 +216,10 @@ ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="06ad",
MODE="660", GROUP="plugdev",
# USBprog with OpenOCD firmware
ATTRS{idVendor}=="1781", ATTRS{idProduct}=="0c63", MODE="660",
GROUP="plugdev", TAG+="uaccess"
+# WCH CH347 chip
+ATTRS{idVendor}=="1a86", ATTRS{idProduct}=="55dd", MODE="660",
GROUP="plugdev", TAG+="uaccess"
+ATTRS{idVendor}=="1a86", ATTRS{idProduct}=="55de", MODE="660",
GROUP="plugdev", TAG+="uaccess"
+
# TI/Luminary Stellaris In-Circuit Debug Interface (ICDI) Board
ATTRS{idVendor}=="1cbe", ATTRS{idProduct}=="00fd", MODE="660",
GROUP="plugdev", TAG+="uaccess"
diff --git a/doc/openocd.texi b/doc/openocd.texi
index 9b5cfbb83e..a3bed045c3 100644
--- a/doc/openocd.texi
+++ b/doc/openocd.texi
@@ -624,6 +624,9 @@ This is deprecated from Linux v5.3; prefer using
@b{linuxgpiod}.
@item @b{esp_usb_jtag}
@* A JTAG driver to communicate with builtin debug modules of Espressif
ESP32-C3 and ESP32-S3 chips using OpenOCD.
+@item @b{ch347T/F}
+@* A JTAG driver which uses the WCH CH347T/F JTAG chip.
+
@end itemize
@node About Jim-Tcl
diff --git a/src/jtag/drivers/ch347.c b/src/jtag/drivers/ch347.c
new file mode 100644
index 0000000000..eb003fa711
--- /dev/null
+++ b/src/jtag/drivers/ch347.c
@@ -0,0 +1,1515 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+/***************************************************************************
+ * Driver for CH347-JTAG interface V1.1 *
+ * *
+ * Copyright (C) 2024 by oidcat <oidcat...@163.com> *
+ * *
+ * CH347 is a high-speed USB bus converter chip that provides UART, I2C *
+ * and SPI synchronous serial ports and JTAG interface through USB bus. *
+ * *
+ * The Jtag interface by CH347 can supports transmission frequency *
+ * configuration up to 60MHz. *
+ * *
+ * The USB2.0 to JTAG scheme based on CH347 can be used to build *
+ * customized USB high-speed JTAG debugger and other products. *
+ * *
+ * 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. *
+ * *
+ * _____________ *
+ * | |____JTAG/SWD (TDO,TDI,TMS,TCK,TRST) *
+ * USB__| CH347T/F | *
+ * |_____________|____UART(TXD1,RXD1,RTS1,CTS1,DTR1) *
+ * ______|______ *
+ * | | *
+ * | 8 MHz XTAL | *
+ * |_____________| *
+ * *
+ * 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
+#include "config.h"
+#endif
+#if IS_CYGWIN == 1
+#include "windows.h"
+#undef LOG_ERROR
+#endif
+/* project specific includes */
+#include <jtag/interface.h>
+#include <jtag/commands.h>
+#include <jtag/swd.h>
+#include <helper/time_support.h>
+#include <helper/replacements.h>
+#include <helper/list.h>
+#include <helper/binarybuffer.h>
+#include "libusb_helper.h"
+/* system includes */
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <time.h>
+#include <unistd.h>
+#define JTAGIO_STA_OUT_TDI (0x10)
+#define JTAGIO_STA_OUT_TMS (0x02)
+#define JTAGIO_STA_OUT_TCK (0x01)
+#define JTAGIO_STA_OUT_TRST (0x20)
+#define TDI_H JTAGIO_STA_OUT_TDI
+#define TDI_L 0
+#define TMS_H JTAGIO_STA_OUT_TMS
+#define TMS_L 0
+#define TCK_H JTAGIO_STA_OUT_TCK
+#define TCK_L 0
+#define TRST_H JTAGIO_STA_OUT_TRST
+#define TRST_L 0
+#define KHZ(n) ((n) * UINT64_C(1000))
+#define MHZ(n) ((n) * UINT64_C(1000000))
+#define GHZ(n) ((n) * UINT64_C(1000000000))
+#define CH347T_MPHSI_INTERFACE 2 // the JTAG interface is
number 2
+#define CH347F_MPHSI_INTERFACE 4 // the JTAG interface is
number 4
+#define DEFAULT_VENDOR_ID 0x1a86 // if no vendor
id is set use this CH347 default
+#define DEFAULT_PRODUCT_ID 0x55dd // if no product
id is set use this CH347 default
+#define HW_TDO_BUF_SIZE 4096
+#define SF_PACKET_BUF_SIZE 51200 /* Command packet length */
+#define UCMDPKT_DATA_MAX_BYTES_USBHS 507 /* The data length contained in each
+ command packet during USB
+ high-speed operation */
+#define USBC_PACKET_USBHS 512 /* Maximum data length per packet at
+ USB high speed */
+#define USBC_PACKET_USBHS_SINGLE 510 /* usb high speed max
+ package length */
+#define CH347_CMD_HEADER 3 /* Protocol header length */
+/* Protocol transmission format: CMD (1 byte)+Length (2 bytes)+Data */
+#define CH347_CMD_INFO_RD 0xCA /* Parameter acquisition, used to
+ obtain firmware version,
+ JTAG interface related parameters,
+ etc */
+#define CH347_CMD_JTAG_INIT 0xD0 /* JTAG Interface Initialization
+ Command */
+#define CH347_CMD_JTAG_BIT_OP 0xD1 /* JTAG interface pin bit control
+ command */
+#define CH347_CMD_JTAG_BIT_OP_RD 0xD2 /* JTAG interface pin bit control and
+ read commands */
+#define CH347_CMD_JTAG_DATA_SHIFT 0xD3 /* JTAG interface data shift
+ command */
+#define CH347_CMD_JTAG_DATA_SHIFT_RD 0xD4 /* JTAG interface data shift and read
+ command */
+/* SWD */
+#define CH347_CMD_SWD_INIT 0xE5 /* SWD Interface Initialization Command */
+#define CH347_CMD_SWD 0xE8
+#define CH347_CMD_SWD_REG_W 0xA0 /* SWD Interface write reg */
+#define CH347_CMD_SWD_SEQ_W 0xA1 /* SWD Interface write spec seq */
+#define CH347_CMD_SWD_REG_R 0xA2 /* SWD Interface read reg */
+#define CH347_MAX_SEND_CMD 0X20 /* max send cmd number */
+#define CH347_MAX_SEND_BUF 0X200
+#define CH347_MAX_RECV_BUF 0X200
+#define BUILD_UINT16(lo_byte, hi_byte) \
+ ((unsigned short)(((lo_byte) & 0x00FF) + (((hi_byte) & 0x00FF) << 8)))
+#pragma pack(1)
+enum pack_size {
+ STANDARD_PACK = 0,
+ LARGER_PACK = 1,
+};
+struct ch347_info /* Record the CH347 pin status */
+{
+ int TMS;
+ int TDI;
+ int TCK;
+ int TRST;
+ int buffer_idx;
+ unsigned char buffer[SF_PACKET_BUF_SIZE];
+ int len_idx;
+ int len_value;
+ unsigned char last_cmd;
+ unsigned char read_buffer[SF_PACKET_BUF_SIZE];
+ unsigned int read_idx;
+ unsigned int read_count;
+ struct bit_copy_queue read_queue;
+ enum pack_size pack_size;
+};
+typedef struct _CH347_SWD_IO {
+ unsigned char usbcmd; /* 0xA0、0xA1、0xA2 */
+ unsigned char cmd;
+ unsigned int *dst;
+ unsigned int value;
+ struct list_head list_entry;
+} CH347_SWD_IO, *PCH347_SWD_IO;
+typedef struct _CH347_SWD_CONTEXT {
+ unsigned char send_buf[CH347_MAX_SEND_BUF];
+ unsigned char recv_buf[CH347_MAX_RECV_BUF];
+ unsigned int send_len;
+ unsigned int recv_len;
+ unsigned int need_recv_len;
+ int queued_retval;
+ unsigned char sent_cmd_count;
+ struct list_head send_cmd_head;
+ struct list_head free_cmd_head;
+ unsigned char *ch347_cmd_buf;
+} CH347_SWD_CONTEXT;
+#pragma pack()
+int dev_is_opened; /* Whether the device is turned on */
+unsigned long USBC_PACKET;
+static CH347_SWD_CONTEXT ch347_swd_context;
+static bool swd_mode;
+#include <jtag/drivers/libusb_helper.h>
+#define CH347_EPOUT 0x06u
+#define CH347_EPIN 0x86u
+struct libusb_device_handle *ch347_handle;
+static char *ch347_device_desc;
+static unsigned short ch347_vids[] = {DEFAULT_VENDOR_ID, 0};
+static unsigned short ch347_pids[] = {DEFAULT_PRODUCT_ID, 0};
+static unsigned int ch347_open_device(void)
+{
+ if (jtag_libusb_open(ch347_vids, ch347_pids, ch347_device_desc,
&ch347_handle, NULL) != ERROR_OK)
+ return false;
+ else
+ return true;
+}
+static bool ch347_write_data(unsigned char *data, unsigned long *length)
+{
+ int ret, tmp = 0;
+ ret = jtag_libusb_bulk_write(ch347_handle,
+ CH347_EPOUT,
+ (char *)data,
+ *length,
+ 1000, &tmp);
+ *length = tmp;
+ if (!ret)
+ return true;
+ else
+ return false;
+}
+static bool ch347_read_data(unsigned char *data, unsigned long *length)
+{
+ int ret, tmp = 0;
+ int size = *length;
+ ret = jtag_libusb_bulk_read(ch347_handle,
+ CH347_EPIN,
+ (char *)data,
+ size,
+ 1000, &tmp);
+ *length = tmp;
+ if (!ret)
+ return true;
+ else
+ return false;
+}
+static bool ch347_close_device(void)
+{
+ jtag_libusb_close(ch347_handle);
+ return true;
+}
+struct ch347_info ch347;
+static int ch347_swd_run_queue(void);
+/* swd init func */
+static bool ch347swd_init(unsigned char clock_rate)
+{
+ unsigned char cmd_buf[128] = "";
+ unsigned long i = 0;
+ cmd_buf[i++] = CH347_CMD_SWD_INIT;
+ cmd_buf[i++] = 8; /* Data length is 6 */
+ cmd_buf[i++] = 0;
+ cmd_buf[i++] = 0x40;
+ cmd_buf[i++] = 0x42;
+ cmd_buf[i++] = 0x0f; /* Reserved Bytes */
+ cmd_buf[i++] = 0x00; /* Reserved Bytes */
+ cmd_buf[i++] = clock_rate; /* JTAG clock speed */
+ i += 3; /* Reserved Bytes */
+ unsigned long length = i;
+ if (!ch347_write_data(cmd_buf, &length) || length != i)
+ return false;
+ length = 4;
+ memset(cmd_buf, 0, sizeof(cmd_buf));
+ if (!ch347_read_data(cmd_buf, &length) || length != 4)
+ return false;
+ return true;
+}
+/**
+ * hex_to_string - Hex Conversion String Function
+ * @param buf Point to a buffer to place the Hex data to be converted
+ * @param size Pointing to the length unit where data needs to be converted
+ *
+ * @return Returns a converted string
+ */
+static char *hex_to_string(unsigned char *buf, unsigned int size)
+{
+ unsigned int i;
+ if (!buf)
+ return "NULL";
+ char *str = calloc(size * 2 + 1, 1);
+ for (i = 0; i < size; i++)
+ sprintf(str + 2 * i, "%02x ", buf[i]);
+ return str;
+}
+/**
+ * ch347_write - CH347 Write
+ * @param out_buffer Point to a buffer to place the data to be written out
+ * @param out_length Pointing to the length unit, the input is the length
to be
+ * written out, and the return is the actual written length
+ *
+ * @return Write success returns 1, failure returns 0
+ */
+static int ch347_write(void *out_buffer, unsigned long *out_length)
+{
+ int ret = -1;
+ unsigned long length = *out_length, WI;
+ if (*out_length >= HW_TDO_BUF_SIZE)
+ length = HW_TDO_BUF_SIZE;
+ WI = 0;
+ while (1) {
+ ret = ch347_write_data((unsigned char *)out_buffer + WI,
+ &length);
+ if (!ret) {
+ *out_length = 0;
+ return false;
+ }
+ LOG_DEBUG_IO("(size=%lu, buf=[%s]) -> %" PRIu32, length,
+ hex_to_string((unsigned char *)out_buffer, length),
+ (unsigned int)length);
+ WI += length;
+ if (*out_length <= WI)
+ break;
+ if ((*out_length - WI) > HW_TDO_BUF_SIZE)
+ length = HW_TDO_BUF_SIZE;
+ else
+ length = *out_length - WI;
+ }
+ *out_length = WI;
+ return true;
+}
+/**
+ * ch347_read - CH347 Read
+ * @param out_buffer Point to a buffer to place the data to be read in
+ * @param out_length Pointing to the length unit, the input is the length to
+ * be read, and the return is the actual read length
+ *
+ * @return Write success returns 1, failure returns 0
+ */
+static int ch347_read(void *out_buffer, unsigned long *out_length)
+{
+ unsigned long rlength = *out_length, WI;
+ /* The maximum allowable reading for a single read is 4096B of data.
+ If it exceeds the allowable reading limit, it will be calculated as
+ 4096B */
+ if (rlength > HW_TDO_BUF_SIZE)
+ rlength = HW_TDO_BUF_SIZE;
+ WI = 0;
+ while (1) {
+ if (!ch347_read_data((unsigned char *)out_buffer + WI,
+ &rlength)) {
+ LOG_ERROR("read data failure.");
+ return false;
+ }
+ WI += rlength;
+ if (*out_length <= WI)
+ break;
+ if ((*out_length - WI) > HW_TDO_BUF_SIZE)
+ rlength = HW_TDO_BUF_SIZE;
+ else
+ rlength = *out_length - WI;
+ }
+ LOG_DEBUG_IO("(size=%lu, buf=[%s]) -> %" PRIu32, WI,
+ hex_to_string((unsigned char *)out_buffer, WI), (unsigned
int)WI);
+ *out_length = WI;
+ return true;
+}
+static void ch347_read_scan(unsigned char *buffer_ptr, unsigned int length)
+{
+ unsigned long read_size = 0;
+ unsigned long rx_len = 0;
+ unsigned long index = 0;
+ unsigned long read_buf_index = 0;
+ unsigned char *read_buf = NULL;
+ int data_len = 0, i = 0; /*, this_bits = 0; */
+ read_size = length;
+ rx_len = read_size;
+ index = 0;
+ read_buf_index = 0;
+ read_buf = calloc(sizeof(unsigned char), read_size);
+ if (!ch347_read(read_buf, &rx_len)) {
+ LOG_ERROR("ch347_read read data failure.");
+ return;
+ }
+ while (index < read_size) { /* deal with the CH347_CMD_JTAG_BIT_OP_RD
or CH347_CMD_JTAG_DATA_SHIFT_RD */
+ if (read_buf[index] == CH347_CMD_JTAG_DATA_SHIFT_RD) {
+ data_len = read_buf[++index] & 0xFF;
+ data_len += (read_buf[++index] & 0xFF) << 8;
+ memcpy(buffer_ptr + read_buf_index, &read_buf[index +
1],
+ data_len);
+ read_buf_index += data_len;
+ index += data_len + 1;
+ } else if (read_buf[index] == CH347_CMD_JTAG_BIT_OP_RD) {
+ data_len = read_buf[++index] & 0xFF;
+ data_len += (read_buf[++index] & 0xFF) << 8;
+ for (i = 0; i < data_len; i++) {
+ if (read_buf[index + 1 + i] == 0x01)
+ *(buffer_ptr + read_buf_index) |= (1 <<
i);
+ else
+ *(buffer_ptr + read_buf_index) &= ~(1
<< i);
+ }
+ read_buf_index += 1;
+ index += data_len + 1;
+ } else {
+ // LOG_ERROR("readbuf read_commend error");
+ *(buffer_ptr + read_buf_index) = read_buf[index];
+ read_buf_index++;
+ index++;
+ }
+ }
+ if (read_buf) {
+ free(read_buf);
+ read_buf = NULL;
+ }
+}
+static void ch347_flush_buffer(void)
+{
+ unsigned long retlen = ch347.buffer_idx;
+ int nb = ch347.buffer_idx, ret = ERROR_OK;
+ while (ret == ERROR_OK && nb > 0) {
+ ret = ch347_write(ch347.buffer, &retlen);
+ nb -= retlen;
+ }
+ memset(&ch347.buffer, 0, sizeof(ch347.buffer));
+ ch347.buffer_idx = 0;
+ ch347.last_cmd = 0;
+ ch347.len_idx = 0;
+ ch347.len_value = 0;
+ if (ch347.read_count == 0)
+ return;
+ if (ch347.pack_size == LARGER_PACK) {
+ ch347_read_scan(&ch347.read_buffer[0], ch347.read_count);
+ bit_copy_execute(&ch347.read_queue);
+ memset(ch347.read_buffer, 0, SF_PACKET_BUF_SIZE);
+ ch347.read_count = 0;
+ ch347.read_idx = 0;
+ }
+}
+static void ch347_in_buffer(unsigned char byte)
+{
+ if ((SF_PACKET_BUF_SIZE - ch347.buffer_idx) < 1)
+ ch347_flush_buffer();
+ ch347.buffer[ch347.buffer_idx] = byte;
+ ch347.buffer_idx++;
+ if ((SF_PACKET_BUF_SIZE - ch347.buffer_idx) == 0)
+ ch347_flush_buffer();
+}
+static void ch347_in_buffer_bytes(unsigned char *bytes, unsigned long
bytes_length)
+{
+ if ((ch347.buffer_idx + bytes_length) > SF_PACKET_BUF_SIZE)
+ ch347_flush_buffer();
+ memcpy(&ch347.buffer[ch347.buffer_idx], bytes, bytes_length);
+ ch347.buffer_idx += bytes_length;
+ if ((SF_PACKET_BUF_SIZE - ch347.buffer_idx) < 1)
+ ch347_flush_buffer();
+}
+static void combine_packets(unsigned char cmd, int cur_idx, unsigned long len)
+{
+ if (cmd != ch347.last_cmd) {
+ ch347.buffer[cur_idx] = cmd;
+ ch347.buffer[cur_idx + 1] =
+ (unsigned char)(((len - CH347_CMD_HEADER) >> 0) & 0xFF);
+ ch347.buffer[cur_idx + 2] =
+ (unsigned char)(((len - CH347_CMD_HEADER) >> 8) & 0xFF);
+ /* update the ch347 struct */
+ ch347.last_cmd = cmd;
+ ch347.len_idx = cur_idx + 1;
+ ch347.len_value = (len - CH347_CMD_HEADER);
+ } else {
+ /* update the ch347 struct cmd data leng */
+ ch347.len_value += (len - CH347_CMD_HEADER);
+ /* update the cmd packet valid leng */
+ ch347.buffer[ch347.len_idx] = (unsigned char)((ch347.len_value
>> 0) & 0xFF);
+ ch347.buffer[ch347.len_idx + 1] = (unsigned
char)((ch347.len_value >> 8) & 0xFF);
+ /* update the buffer data leng */
+ memcpy(&ch347.buffer[cur_idx],
+ &ch347.buffer[cur_idx + CH347_CMD_HEADER],
+ (len - CH347_CMD_HEADER));
+ /* update the ch347 buffer index */
+ ch347.buffer_idx -= CH347_CMD_HEADER;
+ }
+}
+/**
+ * ch347_clock_tims - Function used to change the TMS value at the
+ * rising edge of TCK to switch its Tap state
+ * @param bit_bangPkt Protocol package
+ * @param tms TMS value to be changed
+ * @param BI Protocol packet length
+ *
+ * @return Return protocol packet length
+ */
+static unsigned long ch347_clock_tims(int tms, unsigned long BI)
+{
+ unsigned char data = 0;
+ unsigned char cmd = 0;
+ if (tms == 1)
+ cmd = TMS_H;
+ else
+ cmd = TMS_L;
+ BI += 2;
+ data = cmd | TDI_L | TCK_L | TRST_H;
+ ch347_in_buffer(data);
+ data = cmd | TDI_L | TCK_H | TRST_H;
+ ch347_in_buffer(data);
+ ch347.TMS = cmd;
+ ch347.TDI = TDI_L;
+ ch347.TCK = TCK_H;
+ ch347.TRST = TRST_H;
+ return BI;
+}
+/**
+ * ch347_idle_clock - Function to ensure that the clock is in a low state
+ * @param bit_bangPkt Protocol package
+ * @param BI Protocol packet length
+ *
+ * @return Return protocol packet length
+ */
+static unsigned long ch347_idle_clock(unsigned long BI)
+{
+ unsigned char byte = 0;
+ byte |= ch347.TMS ? TMS_H : TMS_L;
+ byte |= ch347.TDI ? TDI_H : TDI_L;
+ byte |= ch347.TRST ? TRST_H : TRST_L;
+ BI++;
+ ch347_in_buffer(byte);
+ return BI;
+}
+/**
+ * ch347_tms_change - Function that performs state switching by changing the
value of TMS
+ * @param tms_value The TMS values that need to be switched form one byte of
data in the switching order
+ * @param step The number of bit values that need to be read from the
tms_value value
+ * @param skip Count from the skip bit of tms_value to step
+ *
+ */
+static void ch347_tms_change(const unsigned char *tms_value, int step, int
skip)
+{
+ int i;
+ int index = ch347.buffer_idx;
+ unsigned long BI, retlen, cmdlen;
+ BI = CH347_CMD_HEADER;
+ retlen = CH347_CMD_HEADER;
+ LOG_DEBUG_IO("(TMS Value: %02x..., step = %d, skip = %d)", tms_value[0],
+ step, skip);
+ for (i = 0; i < 3; i++)
+ ch347_in_buffer(0);
+ for (i = skip; i < step; i++) {
+ retlen = ch347_clock_tims((tms_value[i / 8] >> (i % 8)) & 0x01,
BI);
+ BI = retlen;
+ }
+ cmdlen = ch347_idle_clock(BI);
+ combine_packets(CH347_CMD_JTAG_BIT_OP, index, cmdlen);
+}
+/**
+ * ch347_tms - By ch347_ execute_ Queue call
+ * @param cmd Upper layer transfer command parameters
+ *
+ */
+static void ch347_tms(struct tms_command *cmd)
+{
+ LOG_DEBUG_IO("(step: %d)", cmd->num_bits);
+ ch347_tms_change(cmd->bits, cmd->num_bits, 0);
+}
+/**
+ * CH347_Reset - CH347 Reset Tap Status Function
+ * @brief If there are more than six consecutive TCKs and TMS is high, the
state
+ * machine can be set to a Test-Logic-Reset state
+ *
+ */
+static int ch347_reset(int trst, int srst)
+{
+ LOG_DEBUG_IO("reset trst: %i srst %i", trst, srst);
+ unsigned char bit_bang[512] = "", BII, i;
+ unsigned long tx_len;
+ if (!swd_mode) {
+ BII = CH347_CMD_HEADER;
+ for (i = 0; i < 7; i++) {
+ bit_bang[BII++] = TMS_H | TDI_L | TCK_L;
+ bit_bang[BII++] = TMS_H | TDI_L | TCK_H;
+ }
+ bit_bang[BII++] = TMS_H | TDI_L | TCK_L;
+ ch347.TCK = TCK_L;
+ ch347.TDI = TDI_L;
+ ch347.TMS = 0;
+ bit_bang[0] = CH347_CMD_JTAG_BIT_OP;
+ bit_bang[1] = BII - CH347_CMD_HEADER;
+ bit_bang[2] = 0;
+ tx_len = BII;
+ if (!ch347_write(bit_bang, &tx_len) && tx_len != BII) {
+ LOG_ERROR("JTAG_Init send usb data failure.");
+ return false;
+ }
+ }
+ return ERROR_OK;
+}
+/**
+ * ch347_movepath - Obtain the current Tap status and switch to the status TMS
+ * value passed down by cmd
+ * @param cmd Upper layer transfer command parameters
+ *
+ */
+static void ch347_movepath(struct pathmove_command *cmd)
+{
+ int i;
+ int index = ch347.buffer_idx;
+ unsigned long BI, retlen = 0, cmdlen;
+ BI = CH347_CMD_HEADER;
+ for (i = 0; i < 3; i++)
+ ch347_in_buffer(0);
+ LOG_DEBUG_IO("(num_states=%d, last_state=%d)",
+ cmd->num_states, cmd->path[cmd->num_states - 1]);
+ for (i = 0; i < cmd->num_states; i++) {
+ if (tap_state_transition(tap_get_state(), false) ==
+ cmd->path[i])
+ retlen = ch347_clock_tims(0, BI);
+ BI = retlen;
+ if (tap_state_transition(tap_get_state(), true) == cmd->path[i])
+ retlen = ch347_clock_tims(1, BI);
+ BI = retlen;
+ tap_set_state(cmd->path[i]);
+ }
+ cmdlen = ch347_idle_clock(BI);
+ combine_packets(CH347_CMD_JTAG_BIT_OP, index, cmdlen);
+}
+/**
+ * ch347_movestate - Toggle the Tap state to the Target state stat
+ * @param stat Pre switch target path
+ * @param skip Number of digits to skip
+ *
+ */
+static void ch347_movestate(tap_state_t state, int skip)
+{
+ unsigned char tms_scan;
+ int tms_len;
+ LOG_DEBUG_IO("(from %s to %s)", tap_state_name(tap_get_state()),
+ tap_state_name(state));
+ if (tap_get_state() == state)
+ return;
+ tms_scan = tap_get_tms_path(tap_get_state(), state);
+ tms_len = tap_get_tms_path_len(tap_get_state(), state);
+ ch347_tms_change(&tms_scan, tms_len, skip);
+ tap_set_state(state);
+}
+/**
+ * ch347_writeread - CH347 Batch read/write function
+ * @param bits Read and write data this time
+ * @param nb_bits Incoming data length
+ * @param scan The transmission method of incoming data to determine
whether
+ * to perform data reading
+ */
+static void ch347_writeread(struct scan_command *cmd, unsigned char *bits,
+ int nb_bits, enum scan_type scan)
+{
+ int nb8 = nb_bits / 8;
+ int nb1 = nb_bits % 8;
+ int i, num_bits = 0;
+ bool is_read = false; /*, isLastByte = false */
+ unsigned char tms_bit = 0, tdi_bit = 0, cmd_bit;
+ static unsigned char byte0[SF_PACKET_BUF_SIZE];
+ unsigned char *read_data = calloc(SF_PACKET_BUF_SIZE, 1);
+ unsigned long read_len = 0;
+ unsigned long BI = 0, DI, DII, pkt_data_len, data_len = 0, temp_index,
+ total_read_length = 0, temp_length = 0;
+ if (ch347.pack_size == LARGER_PACK) {
+ if ((ch347.read_count >= (510 * 1)))
+ ch347_flush_buffer();
+ } else {
+ ch347_flush_buffer();
+ }
+ if (nb8 > 0 && nb1 == 0) {
+ nb8--;
+ nb1 = 8;
+ }
+ is_read = (scan == SCAN_IN || scan == SCAN_IO);
+ DI = 0;
+ BI = 0;
+ while (DI < (unsigned long)nb8) {
+ if ((nb8 - DI) > UCMDPKT_DATA_MAX_BYTES_USBHS)
+ pkt_data_len = UCMDPKT_DATA_MAX_BYTES_USBHS;
+ else
+ pkt_data_len = nb8 - DI;
+ DII = pkt_data_len;
+ if (is_read)
+ ch347_in_buffer(CH347_CMD_JTAG_DATA_SHIFT_RD);
+ else
+ ch347_in_buffer(CH347_CMD_JTAG_DATA_SHIFT);
+ /* packet data don't deal D3 & D4 */
+ if (ch347.last_cmd != CH347_CMD_JTAG_DATA_SHIFT_RD ||
+ ch347.last_cmd != CH347_CMD_JTAG_DATA_SHIFT) {
+ /* update the ch347 struct */
+ ch347.last_cmd = 0;
+ ch347.len_idx = 0;
+ ch347.len_value = 0;
+ }
+ ch347_in_buffer((unsigned char)(pkt_data_len >> 0) & 0xFF);
+ ch347_in_buffer((unsigned char)(pkt_data_len >> 8) & 0xFF);
+ if (bits)
+ ch347_in_buffer_bytes(&bits[DI], pkt_data_len);
+ else
+ ch347_in_buffer_bytes(byte0, pkt_data_len);
+ DI += DII;
+ temp_length += (DII + CH347_CMD_HEADER);
+ }
+ total_read_length += temp_length;
+ if (is_read) {
+ ch347.read_count += temp_length;
+ read_len += temp_length;
+ }
+ if (bits) {
+ cmd_bit = is_read ? CH347_CMD_JTAG_BIT_OP_RD :
CH347_CMD_JTAG_BIT_OP;
+ data_len = (nb1 * 2) + 1;
+ if (cmd_bit != ch347.last_cmd) {
+ ch347_in_buffer(cmd_bit);
+ ch347_in_buffer((unsigned char)(data_len >> 0) & 0xFF);
+ ch347_in_buffer((unsigned char)(data_len >> 8) & 0xFF);
+ ch347.last_cmd = cmd_bit;
+ ch347.len_idx = ch347.buffer_idx - 2;
+ ch347.len_value = data_len;
+ } else {
+ /* update the ch347 struct cmd data leng */
+ ch347.len_value += data_len;
+ /* update the cmd packet valid leng */
+ ch347.buffer[ch347.len_idx] =
+ (unsigned char)(ch347.len_value >> 0) & 0xFF;
+ ch347.buffer[ch347.len_idx + 1] =
+ (unsigned char)(ch347.len_value >> 8) & 0xFF;
+ }
+ tms_bit = TMS_L;
+ for (i = 0; i < nb1; i++) {
+ if ((bits[nb8] >> i) & 0x01)
+ tdi_bit = TDI_H;
+ else
+ tdi_bit = TDI_L;
+ if ((i + 1) == nb1)
+ tms_bit = TMS_H;
+ ch347_in_buffer(tms_bit | tdi_bit | TCK_L | TRST_H);
+ ch347_in_buffer(tms_bit | tdi_bit | TCK_H | TRST_H);
+ }
+ ch347_in_buffer(tms_bit | tdi_bit | TCK_L | TRST_H);
+ }
+ ch347.TMS = tms_bit;
+ ch347.TDI = tdi_bit;
+ ch347.TCK = TCK_L;
+ if (is_read) {
+ temp_length = ((data_len / 2) + CH347_CMD_HEADER);
+ total_read_length += temp_length;
+ ch347.read_count += temp_length;
+ read_len += temp_length;
+ DI = 0;
+ BI = 0;
+ }
+ int offset = 0, bit_count = 0;
+ if (is_read && total_read_length > 0) {
+ if (ch347.pack_size == STANDARD_PACK && bits && cmd) {
+ ch347_flush_buffer();
+ ch347_read_scan(read_data, read_len);
+ }
+ for (i = 0; i < cmd->num_fields; i++) {
+ /* if neither in_value nor in_handler
+ * are specified we don't have to examine this field
+ */
+ LOG_DEBUG("fields[%i].in_value[%i], offset: %d",
+ i, cmd->fields[i].num_bits, offset);
+ num_bits = cmd->fields[i].num_bits;
+ if (ch347.pack_size == LARGER_PACK)
+ bit_count += num_bits;
+ if (cmd->fields[i].in_value) {
+ if (ch347.pack_size == LARGER_PACK) {
+ bit_copy_queued(&ch347.read_queue,
+ cmd->fields[i].in_value,
+ 0,
+
&ch347.read_buffer[ch347.read_idx],
+ offset, num_bits);
+ if (num_bits > 7)
+ ch347.read_idx +=
DIV_ROUND_UP(bit_count, 8);
+ } else {
+ num_bits = cmd->fields[i].num_bits;
+ unsigned char *captured =
buf_set_buf(read_data, bit_count,
+ malloc(DIV_ROUND_UP(num_bits,
+ 8)), 0,
+ num_bits);
+ if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO)) {
+ char *char_buf =
+ buf_to_hex_str(captured,
+ (num_bits >
+ DEBUG_JTAG_IOZ)
+ ? DEBUG_JTAG_IOZ
+ : num_bits);
+ free(char_buf);
+ }
+ buf_cpy(captured,
+ cmd->fields[i].in_value,
+ num_bits);
+ free(captured);
+ }
+ } else {
+ LOG_DEBUG_IO("cmd->fields with no data");
+ }
+ if (ch347.pack_size == LARGER_PACK)
+ offset += num_bits;
+ else
+ bit_count += cmd->fields[i].num_bits;
+ }
+ }
+ temp_index = ch347.buffer_idx;
+ for (i = 0; i < CH347_CMD_HEADER; i++)
+ ch347_in_buffer(0);
+ BI = CH347_CMD_HEADER;
+ BI = ch347_idle_clock(BI);
+ combine_packets(CH347_CMD_JTAG_BIT_OP, temp_index, BI);
+ if (read_data) {
+ free(read_data);
+ read_data = NULL;
+ }
+}
+static void ch347_runtest(int cycles, tap_state_t state)
+{
+ LOG_DEBUG_IO("%s(cycles=%i, end_state=%d)", __func__, cycles, state);
+ if (tap_get_state() != TAP_IDLE)
+ ch347_movestate(TAP_IDLE, 0);
+ unsigned char tms_value = 0;
+ ch347_tms_change(&tms_value, 7, 1);
+ ch347_writeread(NULL, NULL, cycles, SCAN_OUT);
+ ch347_movestate(state, 0);
+}
+static void ch347_tableclocks(int cycles)
+{
+ LOG_DEBUG_IO("%s(cycles=%i)", __func__, cycles);
+ ch347_writeread(NULL, NULL, cycles, SCAN_OUT);
+}
+/**
+ * ch347_scan - Switch to SHIFT-DR or SHIFT-IR status for scanning
+ * @param cmd Upper layer transfer command parameters
+ *
+ * @return Success returns ERROR_OK
+ */
+static int ch347_scan(struct scan_command *cmd)
+{
+ int scan_bits;
+ unsigned char *buf = NULL;
+ enum scan_type type;
+ int ret = ERROR_OK;
+ static const char *const type2str[] = {
+ "", "SCAN_IN", "SCAN_OUT", "SCAN_IO"
+ };
+ char *log_buf = NULL;
+ type = jtag_scan_type(cmd);
+ scan_bits = jtag_build_buffer(cmd, &buf);
+ if (cmd->ir_scan)
+ ch347_movestate(TAP_IRSHIFT, 0);
+ else
+ ch347_movestate(TAP_DRSHIFT, 0);
+ log_buf = hex_to_string(buf, DIV_ROUND_UP(scan_bits, 8));
+ LOG_DEBUG_IO("Scan");
+ LOG_DEBUG_IO("%s(scan=%s, type=%s, bits=%d, buf=[%s], end_state=%d)",
+ __func__,
+ cmd->ir_scan ? "IRSCAN" : "DRSCAN",
+ type2str[type],
+ scan_bits, log_buf, cmd->end_state);
+ free(log_buf);
+ ch347_writeread(cmd, buf, scan_bits, type);
+ free(buf);
+ ch347_movestate(cmd->end_state, 1);
+ return ret;
+}
+static void ch347_sleep(int us)
+{
+ LOG_DEBUG_IO("%s(us=%d)", __func__, us);
+ jtag_sleep(us);
+}
+static int ch347_execute_queue(struct jtag_command *cmd)
+{
+ int ret = ERROR_OK;
+ for (cmd = jtag_command_queue_get(); ret == ERROR_OK && cmd;
+ cmd = cmd->next) {
+ switch (cmd->type) {
+ case JTAG_RESET:
+ LOG_DEBUG_IO("JTAG_RESET : %d %d.\n",
+ cmd->cmd.reset->trst,
+ cmd->cmd.reset->srst);
+ ch347_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
+ break;
+ case JTAG_RUNTEST:
+ ch347_runtest(cmd->cmd.runtest->num_cycles,
+ cmd->cmd.runtest->end_state);
+ break;
+ case JTAG_STABLECLOCKS:
+ ch347_tableclocks(cmd->cmd.stableclocks->num_cycles);
+ break;
+ case JTAG_TLR_RESET:
+ ch347_movestate(cmd->cmd.statemove->end_state, 0);
+ break;
+ case JTAG_PATHMOVE:
+ ch347_movepath(cmd->cmd.pathmove);
+ break;
+ case JTAG_TMS:
+ ch347_tms(cmd->cmd.tms);
+ break;
+ case JTAG_SLEEP:
+ ch347_sleep(cmd->cmd.sleep->us);
+ break;
+ case JTAG_SCAN:
+ ret = ch347_scan(cmd->cmd.scan);
+ break;
+ default:
+ LOG_ERROR("BUG: unknown JTAG command type 0x%X",
+ cmd->type);
+ ret = ERROR_FAIL;
+ break;
+ }
+ }
+ ch347_flush_buffer();
+ return ret;
+}
+/**
+ * ch347_init - CH347 Initialization function
+ *
+ * Todo:
+ * Initialize dynamic library functions
+ * Open Device
+ * @return Success returns 0, failure returns ERROR_FAIL
+ */
+static int ch347_init(void)
+{
+ int retval;
+ dev_is_opened = ch347_open_device();
+ if (dev_is_opened) {
+ LOG_INFO("CH347 Open Succ.");
+ } else {
+ LOG_ERROR("CH347 Open Error.");
+ return ERROR_FAIL;
+ }
+ if (ch347_pids[0] == DEFAULT_PRODUCT_ID)
+ retval = libusb_claim_interface(ch347_handle,
CH347T_MPHSI_INTERFACE);
+ else
+ retval = libusb_claim_interface(ch347_handle,
CH347F_MPHSI_INTERFACE);
+ if (retval != ERROR_OK) {
+ LOG_ERROR("CH347 unable to claim interface: %s",
libusb_error_name(retval));
+ jtag_libusb_close(ch347_handle);
+ return retval;
+ }
+ if (!swd_mode) {
+ USBC_PACKET = USBC_PACKET_USBHS;
+ /* ch347 init */
+ ch347.TCK = TCK_L;
+ ch347.TMS = TMS_H;
+ ch347.TDI = TDI_L;
+ ch347.TRST = TRST_H;
+ ch347.buffer_idx = 0;
+ memset(&ch347.buffer, 0, SF_PACKET_BUF_SIZE);
+ ch347.len_idx = 0;
+ ch347.len_value = 0;
+ ch347.last_cmd = 0;
+ memset(&ch347.read_buffer, 0, SF_PACKET_BUF_SIZE);
+ ch347.read_count = 0;
+ ch347.read_idx = 0;
+ bit_copy_queue_init(&ch347.read_queue);
+ tap_set_state(TAP_RESET);
+ } else { /* swd init */
+ ch347swd_init(1);
+ }
+ return 0;
+}
+/**
+ * ch347_quit - CH347 Device Release Function
+ *
+ * Todo:
+ * Reset JTAG pin signal
+ * Close
+ * @return always returns 0
+ */
+static int ch347_quit(void)
+{
+ unsigned long retlen = 4;
+ unsigned char byte[4] = {CH347_CMD_JTAG_BIT_OP, 0x01, 0x00, ch347.TRST};
+ if (!swd_mode) {
+ ch347_write(byte, &retlen);
+ bit_copy_discard(&ch347.read_queue);
+ }
+ if (dev_is_opened) {
+ ch347_close_device();
+ LOG_INFO("Close the CH347.");
+ dev_is_opened = false;
+ }
+ return 0;
+}
+static bool check_speed(unsigned char clock_rate)
+{
+ unsigned long i = 0, j;
+ bool ret;
+ unsigned char cmd_buf[32] = "";
+ cmd_buf[i++] = CH347_CMD_JTAG_INIT;
+ cmd_buf[i++] = 6;
+ cmd_buf[i++] = 0;
+ cmd_buf[i++] = 0;
+ cmd_buf[i++] = clock_rate;
+ for (j = 0; j < 4; j++)
+ cmd_buf[i++] = ch347.TCK | ch347.TDI | ch347.TMS | ch347.TRST;
+ unsigned long length = i;
+ if (!ch347_write_data(cmd_buf, &length) || length != i)
+ return false;
+ length = 4;
+ memset(cmd_buf, 0, sizeof(cmd_buf));
+ if (!ch347_read_data(cmd_buf, &length) || length != 4) {
+ LOG_ERROR("LINE == %d FALSE", __LINE__);
+ return false;
+ }
+ ret = ((cmd_buf[0] == CH347_CMD_JTAG_INIT) &&
(cmd_buf[CH347_CMD_HEADER] == 0));
+ return ret;
+}
+static bool ch347_jtag_init(unsigned char clock_rate)
+{
+ ch347.pack_size = (check_speed(0x09) == true) ? STANDARD_PACK :
LARGER_PACK;
+ if (ch347.pack_size == STANDARD_PACK) {
+ if (clock_rate - 2 < 0)
+ return check_speed(0);
+ else
+ return check_speed(clock_rate - 2);
+ }
+ return check_speed(clock_rate);
+}
+/**
+ * ch347_speed - CH347 TCK frequency setting
+ * @param speed Frequency size set
+ * @return Success returns ERROR_OK，failed returns FALSE
+ */
+static int ch347_speed(int speed)
+{
+ unsigned long i = 0;
+ unsigned char clock_rate;
+ int ret = -1;
+ int speed_clock[8] = {
+ KHZ(468.75), KHZ(937.5), MHZ(1.875),
+ MHZ(3.75), MHZ(7.5), MHZ(15), MHZ(30), MHZ(60)
+ };
+ if (!swd_mode) {
+ for (i = 0; i < ARRAY_SIZE(speed_clock); i++) {
+ if (speed >= speed_clock[i] &&
+ speed <= speed_clock[i + 1]) {
+ clock_rate = i + 1;
+ ret = ch347_jtag_init(clock_rate);
+ if (!ret)
+ LOG_ERROR("Couldn't set CH347 TCK
speed");
+ return ERROR_OK;
+ } else if (speed < speed_clock[0]) {
+ ret = ch347_jtag_init(0);
+ if (!ret) {
+ LOG_ERROR("Couldn't set CH347 TCK
speed");
+ return ret;
+ } else {
+ return ERROR_OK;
+ }
+ }
+ }
+ }
+ return ERROR_OK;
+}
+static int ch347_speed_div(int speed, int *khz)
+{
+ *khz = speed / 1000;
+ return ERROR_OK;
+}
+static int ch347_khz(int khz, int *jtag_speed)
+{
+ if (khz == 0) {
+ LOG_ERROR("Couldn't support the adapter speed");
+ return ERROR_FAIL;
+ }
+ *jtag_speed = khz * 1000;
+ return ERROR_OK;
+}
+static int ch347_trst_out(unsigned char status)
+{
+ unsigned long BI = 0;
+ unsigned char byte = 0;
+ unsigned char cmd_packet[4] = "";
+ cmd_packet[BI++] = CH347_CMD_JTAG_BIT_OP;
+ cmd_packet[BI++] = 0x01;
+ cmd_packet[BI++] = 0;
+ byte = ch347.TCK | ch347.TDI | ch347.TMS | (ch347.TRST =
+ (status ? TRST_H : TRST_L));
+ cmd_packet[BI++] = byte;
+ if (!ch347_write(cmd_packet, &BI)) {
+ LOG_ERROR("TRST set failure.");
+ return ERROR_FAIL;
+ }
+ return ERROR_OK;
+}
+COMMAND_HANDLER(ch347_handle_vid_pid_command)
+{
+ if (CMD_ARGC != 2)
+ return ERROR_COMMAND_SYNTAX_ERROR;
+ COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], ch347_vids[0]);
+ COMMAND_PARSE_NUMBER(u16, CMD_ARGV[1], ch347_pids[0]);
+ return ERROR_OK;
+}
+COMMAND_HANDLER(ch347_trst)
+{
+ ch347_trst_out(TRST_L);
+ jtag_sleep(atoi(CMD_ARGV[0]) * 1000);
+ ch347_trst_out(TRST_H);
+ return ERROR_OK;
+}
+static const struct command_registration ch347_subcommand_handlers[] = {
+ {
+ .name = "vid_pid",
+ .handler = &ch347_handle_vid_pid_command,
+ .mode = COMMAND_CONFIG,
+ .help = "",
+ .usage = "",
+ },
+ {
+ .name = "jtag_ntrst_delay",
+ .handler = &ch347_trst,
+ .mode = COMMAND_ANY,
+ .help = "set the trst of the CH347 device that is used as JTAG",
+ .usage = "[milliseconds]",
+ },
+ COMMAND_REGISTRATION_DONE};
+static const struct command_registration ch347_command_handlers[] = {
+ {
+ .name = "ch347",
+ .mode = COMMAND_ANY,
+ .help = "perform ch347 management",
+ .chain = ch347_subcommand_handlers,
+ .usage = "",
+ },
+ COMMAND_REGISTRATION_DONE};
+static int ch347_swd_init(void)
+{
+ PCH347_SWD_IO pswd_io;
+ LOG_INFO("CH347 SWD mode enabled");
+ swd_mode = true;
+ memset(&ch347_swd_context, 0, sizeof(ch347_swd_context));
+ INIT_LIST_HEAD(&ch347_swd_context.send_cmd_head);
+ INIT_LIST_HEAD(&ch347_swd_context.free_cmd_head);
+ ch347_swd_context.queued_retval = ERROR_OK;
+ /* 0XE8 + 2byte len + N byte cmds */
+ ch347_swd_context.send_len = CH347_CMD_HEADER;
+ /* 0XE8 + 2byte len + N byte ack + data */
+ ch347_swd_context.need_recv_len = CH347_CMD_HEADER;
+ ch347_swd_context.ch347_cmd_buf = malloc(128 * sizeof(CH347_SWD_IO));
+ if (ch347_swd_context.ch347_cmd_buf) {
+ pswd_io = (PCH347_SWD_IO)ch347_swd_context.ch347_cmd_buf;
+ for (int i = 0; i < 128; i++, pswd_io++) {
+ INIT_LIST_HEAD(&pswd_io->list_entry);
+ list_add_tail(&pswd_io->list_entry,
+ &ch347_swd_context.free_cmd_head);
+ }
+ }
+ return ch347_swd_context.ch347_cmd_buf ? ERROR_OK : ERROR_FAIL;
+}
+static PCH347_SWD_IO ch347_get_one_swd_io(void)
+{
+ PCH347_SWD_IO pswd_io;
+ if (list_empty(&ch347_swd_context.free_cmd_head))
+ return NULL;
+ pswd_io = list_first_entry(&ch347_swd_context.free_cmd_head,
CH347_SWD_IO, list_entry);
+ list_del_init(&pswd_io->list_entry);
+ pswd_io->cmd = 0;
+ pswd_io->usbcmd = CH347_CMD_SWD_SEQ_W;
+ pswd_io->dst = NULL;
+ return pswd_io;
+}
+static void ch347_swd_queue_flush(void)
+{
+ unsigned long length = ch347_swd_context.send_len;
+ ch347_swd_context.send_buf[0] = (unsigned char)CH347_CMD_SWD;
+ ch347_swd_context.send_buf[1] = (unsigned
char)(ch347_swd_context.send_len -
+ CH347_CMD_HEADER);
+ ch347_swd_context.send_buf[2] = (unsigned
char)((ch347_swd_context.send_len -
+ CH347_CMD_HEADER) >> 8);
+ if (!ch347_write_data(ch347_swd_context.send_buf, &length) ||
+ length != ch347_swd_context.send_len) {
+ ch347_swd_context.queued_retval = ERROR_FAIL;
+ LOG_DEBUG("ch347_write_data error ");
+ return;
+ }
+ ch347_swd_context.recv_len = 0;
+ do {
+ length = CH347_MAX_RECV_BUF - ch347_swd_context.recv_len;
+ if
(!ch347_read_data(&ch347_swd_context.recv_buf[ch347_swd_context.recv_len],
+ &length)) {
+ ch347_swd_context.queued_retval = ERROR_FAIL;
+ LOG_DEBUG("ch347_read_data error ");
+ return;
+ }
+ ch347_swd_context.recv_len += length;
+ } while (ch347_swd_context.recv_len < ch347_swd_context.need_recv_len);
+ if (ch347_swd_context.need_recv_len > ch347_swd_context.recv_len) {
+ LOG_ERROR("%d : write/read failed %d %d",
+ __LINE__,
+ ch347_swd_context.recv_len,
+ ch347_swd_context.need_recv_len);
+ }
+}
+static void ch347_wrtie_swd_reg(unsigned char cmd, const unsigned char *out,
unsigned char parity)
+{
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] =
+ CH347_CMD_SWD_REG_W;
+ /* 8bit + 32bit +1bit */
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] = 0x29;
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] = 0x00;
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] = cmd;
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] = out[0];
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] = out[1];
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] = out[2];
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] = out[3];
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] = parity;
+ /* 0xA0 + 1 byte(3bit ACK) */
+ ch347_swd_context.need_recv_len += (1 + 1);
+}
+static void ch347_wrtie_spec_seq(const unsigned char *out, unsigned char
out_len)
+{
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] =
+ CH347_CMD_SWD_SEQ_W;
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] = out_len;
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] = 0x00;
+ for (unsigned char i = 0; i < DIV_ROUND_UP(out_len, 8); i++) {
+ if (out)
+
ch347_swd_context.send_buf[ch347_swd_context.send_len++] = out[i];
+ else
+
ch347_swd_context.send_buf[ch347_swd_context.send_len++] = 0x00;
+ }
+ ch347_swd_context.need_recv_len += 1; /* 0xA1 */
+}
+static void ch347_read_swd_reg(unsigned char cmd)
+{
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] =
+ CH347_CMD_SWD_REG_R;
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] = 0x22;
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] = 0x00;
+ ch347_swd_context.send_buf[ch347_swd_context.send_len++] = cmd;
+ /* 0xA2 + 1 byte(3bit ACK) + 4 byte(data) +
+ 1 byte(1bit parity+1bit trn) */
+ ch347_swd_context.need_recv_len += 1 + 1 + 4 + 1;
+}
+static int ch347_swd_switch_out(enum swd_special_seq seq, const unsigned char
*out,
+ unsigned int out_len)
+{
+ PCH347_SWD_IO pswd_io;
+ if ((ch347_swd_context.send_len +
+ (1 + 2 + DIV_ROUND_UP(out_len, 8))) > CH347_MAX_SEND_BUF) {
+ return ERROR_FAIL;
+ }
+ if ((ch347_swd_context.need_recv_len + 2) > CH347_MAX_RECV_BUF)
+ return ERROR_FAIL;
+ pswd_io = ch347_get_one_swd_io();
+ if (pswd_io) {
+ ch347_wrtie_spec_seq(out, out_len);
+ list_add_tail(&pswd_io->list_entry,
+ &ch347_swd_context.send_cmd_head);
+ return ERROR_OK;
+ } else {
+ return ERROR_FAIL;
+ }
+}
+/* check read/write REG can fill in remaining buff */
+static bool ch347_chk_buf_size(unsigned char cmd, unsigned int ap_delay_clk)
+{
+ bool bflush;
+ unsigned int send_len, recv_len, len;
+ bflush = false;
+ send_len = ch347_swd_context.send_len;
+ recv_len = ch347_swd_context.need_recv_len;
+ do {
+ if (cmd & SWD_CMD_RNW) {
+ len = 1 + 1 + 1 + 1; /* 0xA2 + len + rev + cmd */
+ if (send_len + len > CH347_MAX_SEND_BUF)
+ break;
+ send_len += len;
+ len = 1 + 1 + 4 + 1;
+ /* 0xA2 + 1byte(3bit ack) + 4byte(data) +
+ 1byte(1bit parity+1bit trn) */
+ if (recv_len + len > CH347_MAX_RECV_BUF)
+ break;
+ recv_len += len;
+ } else { /* write reg */
+ len = 1 + 1 + 1 + 1 + 4 + 1;
+ /* 0xA0 + len + rev + cmd +data + parity */
+ if (send_len + len > CH347_MAX_SEND_BUF)
+ break;
+ send_len += len;
+ len = 1 + 1; /* 0xA0 + 1byte(3bit ack) */
+ if (recv_len + len > CH347_MAX_RECV_BUF)
+ break;
+ recv_len += len;
+ }
+ if (cmd & SWD_CMD_APNDP) {
+ len = 1 + 1 + 1 + DIV_ROUND_UP(ap_delay_clk, 8);
+ /* 0xA1 + Len + rev + n byte(delay) */
+ if (send_len + len > CH347_MAX_SEND_BUF)
+ break;
+ len = 1; /* 0xA1 */
+ if ((recv_len + len) > CH347_MAX_RECV_BUF)
+ break;
+ }
+ /* swd packet requests */
+ bflush = true;
+ } while (false);
+ return bflush;
+}
+static void ch347_swd_send_idle(unsigned int ap_delay_clk)
+{
+ PCH347_SWD_IO pswd_io;
+ pswd_io = ch347_get_one_swd_io();
+ if (!pswd_io) {
+ ch347_swd_run_queue();
+ pswd_io = ch347_get_one_swd_io();
+ if (!pswd_io) {
+ LOG_DEBUG("ch347_swd_queue_cmd error ");
+ ch347_swd_context.queued_retval = ERROR_FAIL;
+ return;
+ }
+ }
+ ch347_wrtie_spec_seq(NULL, ap_delay_clk);
+ list_add_tail(&pswd_io->list_entry, &ch347_swd_context.send_cmd_head);
+}
+static void ch347_swd_queue_cmd(unsigned char cmd, unsigned int *dst, unsigned
int data,
+ unsigned int ap_delay_clk)
+{
+ PCH347_SWD_IO pswd_io;
+ if (ap_delay_clk > 255)
+ printf("%s ap_delay_clk = %d\r\n", "ch347_swd_queue_cmd",
ap_delay_clk);
+ if (ch347_swd_context.sent_cmd_count >= CH347_MAX_SEND_CMD)
+ ch347_swd_run_queue();
+ if (!ch347_chk_buf_size(cmd, ap_delay_clk))
+ ch347_swd_run_queue();
+ pswd_io = ch347_get_one_swd_io();
+ if (!pswd_io) {
+ ch347_swd_run_queue();
+ pswd_io = ch347_get_one_swd_io();
+ if (!pswd_io) {
+ LOG_DEBUG("%s error ", "ch347_swd_queue_cmd");
+ ch347_swd_context.queued_retval = ERROR_FAIL;
+ return;
+ }
+ }
+ pswd_io->cmd = cmd | SWD_CMD_START | SWD_CMD_PARK;
+ if (pswd_io->cmd & SWD_CMD_RNW) {
+ pswd_io->usbcmd = CH347_CMD_SWD_REG_R;
+ pswd_io->dst = dst;
+ ch347_read_swd_reg(pswd_io->cmd);
+ } else {
+ pswd_io->usbcmd = CH347_CMD_SWD_REG_W;
+ pswd_io->value = data;
+ ch347_wrtie_swd_reg(pswd_io->cmd, (unsigned char *)&data,
+ parity_u32(data));
+ }
+ ch347_swd_context.sent_cmd_count++;
+ list_add_tail(&pswd_io->list_entry, &ch347_swd_context.send_cmd_head);
+ /* Insert idle cycles after AP accesses to avoid WAIT */
+ if (cmd & SWD_CMD_APNDP) {
+ if (ap_delay_clk == 0)
+ printf("ap_delay_clk == 0");
+ ch347_swd_send_idle(ap_delay_clk);
+ }
+}
+static int ch347_swd_switch_seq(enum swd_special_seq seq)
+{
+ printf("%s %d \r\n", "ch347_swd_switch_seq", seq);
+ switch (seq) {
+ case LINE_RESET:
+ LOG_DEBUG("SWD line reset");
+ return ch347_swd_switch_out(seq, swd_seq_line_reset,
+ swd_seq_line_reset_len);
+ case JTAG_TO_SWD:
+ LOG_DEBUG("JTAG-to-SWD");
+ return ch347_swd_switch_out(seq, swd_seq_jtag_to_swd,
+ swd_seq_jtag_to_swd_len);
+ case JTAG_TO_DORMANT:
+ LOG_DEBUG("JTAG-to-DORMANT");
+ return ch347_swd_switch_out(seq, swd_seq_jtag_to_dormant,
+ swd_seq_jtag_to_dormant_len);
+ case SWD_TO_JTAG:
+ LOG_DEBUG("SWD-to-JTAG");
+ return ch347_swd_switch_out(seq, swd_seq_swd_to_jtag,
+ swd_seq_swd_to_jtag_len);
+ case SWD_TO_DORMANT:
+ LOG_DEBUG("SWD-to-DORMANT");
+ return ch347_swd_switch_out(seq, swd_seq_swd_to_dormant,
+ swd_seq_swd_to_dormant_len);
+ case DORMANT_TO_SWD:
+ LOG_DEBUG("DORMANT-to-SWD");
+ return ch347_swd_switch_out(seq, swd_seq_dormant_to_swd,
+ swd_seq_dormant_to_swd_len);
+ case DORMANT_TO_JTAG:
+ LOG_DEBUG("DORMANT-to-JTAG");
+ return ch347_swd_switch_out(seq, swd_seq_dormant_to_jtag,
+ swd_seq_dormant_to_jtag_len);
+ default:
+ LOG_ERROR("Sequence %d not supported", seq);
+ return ERROR_FAIL;
+ }
+}
+static void ch347_swd_read_reg(unsigned char cmd, unsigned int *value,
+ unsigned int ap_delay_clk)
+{
+ assert(cmd & SWD_CMD_RNW);
+ ch347_swd_queue_cmd(cmd, value, 0, ap_delay_clk);
+}
+static void ch347_swd_write_reg(unsigned char cmd, unsigned int value,
+ unsigned int ap_delay_clk)
+{
+ assert(!(cmd & SWD_CMD_RNW));
+ ch347_swd_queue_cmd(cmd, NULL, value, ap_delay_clk);
+}
+static int ch347_swd_run_queue(void)
+{
+ LOG_DEBUG_IO("Executing %u queued transactions",
+ ch347_swd_context.sent_cmd_count);
+ int retval, parity;
+ struct list_head *tmp, *pos;
+ unsigned char *recv_buf;
+ unsigned int recv_len, cmds_len, data;
+ PCH347_SWD_IO pswd_io;
+ if (ch347_swd_context.queued_retval != ERROR_OK) {
+ LOG_DEBUG_IO("Skipping due to previous errors: %d",
+ ch347_swd_context.queued_retval);
+ goto skip;
+ }
+ /* A transaction must be followed by another transaction or at least 8
+ idle cycles to ensure that data is clocked through the AP. */
+ if ((ch347_swd_context.send_len + (1 + 2 + 1)) > CH347_MAX_SEND_BUF)
+ goto skip_idle;
+ if ((ch347_swd_context.need_recv_len + 1) > CH347_MAX_RECV_BUF)
+ goto skip_idle;
+ ch347_swd_send_idle(8);
+skip_idle:
+ ch347_swd_queue_flush();
+ if (ch347_swd_context.queued_retval != ERROR_OK) {
+ LOG_ERROR("CH347 usb write/read failed %d", __LINE__);
+ goto skip;
+ }
+ recv_buf = ch347_swd_context.recv_buf;
+ recv_len = 0;
+ if (recv_buf[recv_len++] != CH347_CMD_SWD) { /* 0XE8 */
+ ch347_swd_context.queued_retval = ERROR_FAIL;
+ LOG_ERROR("CH347 usb write/read failed %d", __LINE__);
+ goto skip;
+ }
+ cmds_len = BUILD_UINT16(recv_buf[recv_len], recv_buf[recv_len + 1]);
+ recv_len += 2; /* cmds_len */
+ if ((cmds_len + CH347_CMD_HEADER) > ch347_swd_context.recv_len) {
+ ch347_swd_context.queued_retval = ERROR_FAIL;
+ LOG_ERROR("CH347 usb write/read failed %d", __LINE__);
+ goto skip;
+ }
+ list_for_each_safe(pos, tmp, &ch347_swd_context.send_cmd_head) {
+ pswd_io = list_entry(pos, CH347_SWD_IO, list_entry);
+ if (pswd_io->usbcmd == CH347_CMD_SWD_SEQ_W) {
+ if (recv_buf[recv_len++] != CH347_CMD_SWD_SEQ_W) {
+ ch347_swd_context.queued_retval = ERROR_FAIL;
+ LOG_ERROR("CH347 usb write/read failed %d",
+ __LINE__);
+ goto skip;
+ }
+ } else { /* read/write Reg */
+ int ack;
+ bool check_ack;
+ /* read Reg */
+ if (recv_buf[recv_len] == CH347_CMD_SWD_REG_R) {
+ recv_len++;
+ ack = buf_get_u32(&recv_buf[recv_len++], 0, 3);
+ /* Devices do not reply to DP_TARGETSEL write
+ cmd, ignore received ack */
+ check_ack = swd_cmd_returns_ack(pswd_io->cmd);
+ if (ack != SWD_ACK_OK && check_ack) {
+ ch347_swd_context.queued_retval =
+ swd_ack_to_error_code(ack);
+ LOG_ERROR("ack != SWD_ACK_OK %d",
+ __LINE__);
+ goto skip;
+ }
+ if (pswd_io->cmd & SWD_CMD_RNW) {
+ data = buf_get_u32(&recv_buf[recv_len],
+ 0, 32);
+ parity =
buf_get_u32(&recv_buf[recv_len], 32, 1);
+ if (parity != parity_u32(data)) {
+ LOG_ERROR("SWD Read data parity
mismatch %d",
+ __LINE__);
+ ch347_swd_context.queued_retval
= ERROR_FAIL;
+ goto skip;
+ }
+ if (pswd_io->dst)
+ *pswd_io->dst = data;
+ } else {
+ ch347_swd_context.queued_retval =
+ ERROR_FAIL;
+ LOG_ERROR("CH347 usb write/read failed
%d", __LINE__);
+ goto skip;
+ }
+ recv_len += 5;
+ } else if (recv_buf[recv_len] == CH347_CMD_SWD_REG_W) {
+ recv_len++;
+ ack = buf_get_u32(&recv_buf[recv_len++], 0, 3);
+ /* Devices do not reply to DP_TARGETSEL write
+ cmd, ignore received ack */
+ check_ack = swd_cmd_returns_ack(pswd_io->cmd);
+ if (ack != SWD_ACK_OK && check_ack) {
+ ch347_swd_context.queued_retval =
+ swd_ack_to_error_code(ack);
+ LOG_ERROR("SWD Read data parity
mismatch%d", __LINE__);
+ goto skip;
+ }
+ } else {
+ ch347_swd_context.queued_retval = ERROR_FAIL;
+ LOG_ERROR("CH347 usb write/read failed %d
recv_len = %d",
+ __LINE__, recv_len);
+ goto skip;
+ }
+ }
+ list_del_init(&pswd_io->list_entry);
+ list_add_tail(&pswd_io->list_entry,
+ &ch347_swd_context.free_cmd_head);
+ }
+skip:
+ if (!list_empty(&ch347_swd_context.send_cmd_head)) {
+ list_for_each_safe(pos, tmp, &ch347_swd_context.send_cmd_head) {
+ pswd_io = list_entry(pos, CH347_SWD_IO, list_entry);
+ list_del_init(&pswd_io->list_entry);
+ list_add_tail(&pswd_io->list_entry,
+ &ch347_swd_context.free_cmd_head);
+ }
+ }
+ /* 0xE8 + 2byte len */
+ ch347_swd_context.send_len = CH347_CMD_HEADER;
+ /* 0xE8 + 2byte len */
+ ch347_swd_context.need_recv_len = CH347_CMD_HEADER;
+ ch347_swd_context.recv_len = 0;
+ ch347_swd_context.sent_cmd_count = 0;
+ retval = ch347_swd_context.queued_retval;
+ ch347_swd_context.queued_retval = ERROR_OK;
+ return retval;
+}
+static const struct swd_driver ch347_swd = {
+ .init = ch347_swd_init,
+ .switch_seq = ch347_swd_switch_seq,
+ .read_reg = ch347_swd_read_reg,
+ .write_reg = ch347_swd_write_reg,
+ .run = ch347_swd_run_queue,
+};
+static const char *const ch347_transports[] = {"jtag", "swd", NULL};
+static struct jtag_interface ch347_interface = {
+ .supported = DEBUG_CAP_TMS_SEQ,
+ .execute_queue = ch347_execute_queue,
+};
+struct adapter_driver ch347_adapter_driver = {
+ .name = "ch347",
+ .transports = ch347_transports,
+ .commands = ch347_command_handlers,
+ .init = ch347_init,
+ .quit = ch347_quit,
+ .reset = ch347_reset,
+ .speed = ch347_speed,
+ .khz = ch347_khz,
+ .speed_div = ch347_speed_div,
+ .jtag_ops = &ch347_interface,
+ .swd_ops = &ch347_swd,
+};
diff --git a/src/jtag/interface.h b/src/jtag/interface.h
index b448851dc4..ba5c5eb2db 100644
--- a/src/jtag/interface.h
+++ b/src/jtag/interface.h
@@ -378,6 +378,7 @@ extern struct adapter_driver ep93xx_adapter_driver;
extern struct adapter_driver esp_usb_adapter_driver;
extern struct adapter_driver ft232r_adapter_driver;
extern struct adapter_driver ftdi_adapter_driver;
+extern struct adapter_driver ch347_adapter_driver;
extern struct adapter_driver gw16012_adapter_driver;
extern struct adapter_driver hl_adapter_driver;
extern struct adapter_driver imx_gpio_adapter_driver;
diff --git a/src/jtag/interfaces.c b/src/jtag/interfaces.c
index 67f0838e39..e0cfd660cf 100644
--- a/src/jtag/interfaces.c
+++ b/src/jtag/interfaces.c
@@ -152,6 +152,9 @@ struct adapter_driver *adapter_drivers[] = {
#endif
#if BUILD_AM335XGPIO == 1
&am335xgpio_adapter_driver,
+#endif
+#if BUILD_CH347 == 1
+ &ch347_adapter_driver,
#endif
NULL,
};
diff --git a/src/target/xtensa/xtensa.c b/src/target/xtensa/xtensa.c
index 284bfc9c62..fe1b83bc3e 100644
--- a/src/target/xtensa/xtensa.c
+++ b/src/target/xtensa/xtensa.c
@@ -1727,7 +1727,7 @@ int xtensa_do_step(struct target *target, int current,
target_addr_t address, in
xtensa_reg_val_t dbreakc[XT_WATCHPOINTS_NUM_MAX];
xtensa_reg_val_t icountlvl, cause;
xtensa_reg_val_t oldps, oldpc, cur_pc;
- bool ps_lowered = false;
+ bool ps_modified = false;
LOG_TARGET_DEBUG(target, "current=%d, address=" TARGET_ADDR_FMT ",
handle_breakpoints=%i",
current, address, handle_breakpoints);
@@ -1783,14 +1783,23 @@ int xtensa_do_step(struct target *target, int current,
target_addr_t address, in
* RFI >= DBGLEVEL.
*/
if (xtensa->stepping_isr_mode == XT_STEPPING_ISR_OFF) {
- if (!xtensa->core_config->high_irq.enabled) {
- LOG_TARGET_WARNING(
- target,
- "disabling IRQs while stepping is not
implemented w/o high prio IRQs option!");
- return ERROR_FAIL;
+ if (xtensa->core_config->core_type == XT_LX) {
+ if (!xtensa->core_config->high_irq.enabled) {
+ LOG_TARGET_WARNING(target,
+ "disabling IRQs while stepping
is not implemented w/o high prio IRQs option!");
+ return ERROR_FAIL;
+ }
+ /* Update ICOUNTLEVEL accordingly */
+ icountlvl = MIN((oldps & 0xF) + 1,
xtensa->core_config->debug.irq_level);
+ } else {
+ /* Xtensa NX does not have the ICOUNTLEVEL feature
present in Xtensa LX
+ * and instead disable interrupts while stepping. This
could change
+ * the timing of the system while under debug */
+ xtensa_reg_val_t newps = oldps | XT_PS_DI_MSK;
+ xtensa_reg_set(target, XT_REG_IDX_PS, newps);
+ icountlvl = xtensa->core_config->debug.irq_level;
+ ps_modified = true;
}
- /* Update ICOUNTLEVEL accordingly */
- icountlvl = MIN((oldps & 0xF) + 1,
xtensa->core_config->debug.irq_level);
} else {
icountlvl = xtensa->core_config->debug.irq_level;
}
@@ -1815,7 +1824,7 @@ int xtensa_do_step(struct target *target, int current,
target_addr_t address, in
xtensa_cause_clear(target); /* so we don't recurse into the
same routine */
if (xtensa->core_config->core_type == XT_LX && ((oldps & 0xf) >=
icountlvl)) {
/* Lower interrupt level to allow stepping, but flag
eps[dbglvl] to be restored */
- ps_lowered = true;
+ ps_modified = true;
uint32_t newps = (oldps & ~0xf) | (icountlvl - 1);
xtensa_reg_set(target, xtensa->eps_dbglevel_idx, newps);
LOG_TARGET_DEBUG(target,
@@ -1916,11 +1925,12 @@ int xtensa_do_step(struct target *target, int current,
target_addr_t address, in
}
/* Restore int level */
- if (ps_lowered) {
+ if (ps_modified) {
LOG_DEBUG("Restoring %s after stepping: 0x%08" PRIx32,
-
xtensa->core_cache->reg_list[xtensa->eps_dbglevel_idx].name,
- oldps);
- xtensa_reg_set(target, xtensa->eps_dbglevel_idx, oldps);
+
xtensa->core_cache->reg_list[(xtensa->core_config->core_type == XT_LX) ?
+ xtensa->eps_dbglevel_idx : XT_REG_IDX_PS].name,
oldps);
+ xtensa_reg_set(target, (xtensa->core_config->core_type ==
XT_LX) ?
+ xtensa->eps_dbglevel_idx : XT_REG_IDX_PS, oldps);
}
/* write ICOUNTLEVEL back to zero */
@@ -4191,11 +4201,6 @@ COMMAND_HELPER(xtensa_cmd_mask_interrupts_do, struct
xtensa *xtensa)
return ERROR_OK;
}
- if (xtensa->core_config->core_type == XT_NX) {
- command_print(CMD, "ERROR: ISR step mode only supported on
Xtensa LX");
- return ERROR_FAIL;
- }
-
/* Masking is ON -> interrupts during stepping are OFF, and vice versa
*/
if (!strcasecmp(CMD_ARGV[0], "off"))
state = XT_STEPPING_ISR_ON;
diff --git a/src/target/xtensa/xtensa.h b/src/target/xtensa/xtensa.h
index 1d56f83682..419277675c 100644
--- a/src/target/xtensa/xtensa.h
+++ b/src/target/xtensa/xtensa.h
@@ -45,6 +45,7 @@
/* PS register bits (NX) */
#define XT_PS_DIEXC_MSK BIT(2)
+#define XT_PS_DI_MSK BIT(3)
/* MS register bits (NX) */
#define XT_MS_DE_MSK BIT(5)
--
