From 68937cadfb42026b4c8b2c9e43acaf3fb409c4db Mon Sep 17 00:00:00 2001
From: Nicolas Pitre <nico@fluxnic.net>
Date: Tue, 27 Oct 2009 01:14:34 -0400
Subject: [PATCH 01/16] ARM: fix Thumb mode handling when single-stepping
 register based branch insns

Currently, OpenOCD is always caching the PC value without the T bit.
This means that assignment to the PC register must clear that bit and set
the processor state to Thumb when it is set.  And when the PC register
value is transferred to another register or stored into memory then
the T bit must be restored.

Discussion: It is arguable if OpenOCd should have preserved the original
PC value which would have greatly simplified this code.  The processor
state could then be obtained simply by getting at bit 0 of the PC.  This
however would require special handling elsewhere instead since the T bit
is not always relevant (like when PC is used with ALU insns or as an index
with some addressing modes).  It is unclear which way would be simpler in
the end.

Signed-off-by: Nicolas Pitre <nico@marvell.com>
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
---
 src/target/arm_simulator.c | 55 +++++++++++++++++++++++++++-------------------
 1 file changed, 33 insertions(+), 22 deletions(-)

diff --git a/src/target/arm_simulator.c b/src/target/arm_simulator.c
index 5af2c129b..c50a52cd9 100644
--- a/src/target/arm_simulator.c
+++ b/src/target/arm_simulator.c
@@ -380,7 +380,8 @@ int arm_simulate_step_core(target_t *target, uint32_t *dry_run_pc, struct arm_si
 			else if (instruction.type == ARM_BL)
 			{
 				uint32_t old_pc = sim->get_reg(sim, 15);
-				sim->set_reg_mode(sim, 14, old_pc + 4);
+				int T = (sim->get_state(sim) == ARMV4_5_STATE_THUMB);
+				sim->set_reg_mode(sim, 14, old_pc + 4 + T);
 				sim->set_reg(sim, 15, target);
 			}
 			else if (instruction.type == ARM_BX)
@@ -398,7 +399,8 @@ int arm_simulate_step_core(target_t *target, uint32_t *dry_run_pc, struct arm_si
 			else if (instruction.type == ARM_BLX)
 			{
 				uint32_t old_pc = sim->get_reg(sim, 15);
-				sim->set_reg_mode(sim, 14, old_pc + 4);
+				int T = (sim->get_state(sim) == ARMV4_5_STATE_THUMB);
+				sim->set_reg_mode(sim, 14, old_pc + 4 + T);
 
 				if (target & 0x1)
 				{
@@ -465,24 +467,24 @@ int arm_simulate_step_core(target_t *target, uint32_t *dry_run_pc, struct arm_si
 		if (dry_run_pc)
 		{
 			if (instruction.info.data_proc.Rd == 15)
-			{
-				*dry_run_pc = Rd;
-				return ERROR_OK;
-			}
+				*dry_run_pc = Rd & ~1;
 			else
-			{
 				*dry_run_pc = current_pc + instruction_size;
-			}
 
 			return ERROR_OK;
 		}
 		else
 		{
+			if (instruction.info.data_proc.Rd == 15) {
+				sim->set_reg_mode(sim, 15, Rd & ~1);
+				if (Rd & 1)
+					sim->set_state(sim, ARMV4_5_STATE_THUMB);
+				else
+					sim->set_state(sim, ARMV4_5_STATE_ARM);
+				return ERROR_OK;
+			}
 			sim->set_reg_mode(sim, instruction.info.data_proc.Rd, Rd);
 			LOG_WARNING("no updating of flags yet");
-
-			if (instruction.info.data_proc.Rd == 15)
-				return ERROR_OK;
 		}
 	}
 	/* compare instructions (CMP, CMN, TST, TEQ) */
@@ -566,15 +568,9 @@ int arm_simulate_step_core(target_t *target, uint32_t *dry_run_pc, struct arm_si
 		if (dry_run_pc)
 		{
 			if (instruction.info.load_store.Rd == 15)
-			{
-				*dry_run_pc = load_value;
-				return ERROR_OK;
-			}
+				*dry_run_pc = load_value & ~1;
 			else
-			{
 				*dry_run_pc = current_pc + instruction_size;
-			}
-
 			return ERROR_OK;
 		}
 		else
@@ -584,10 +580,16 @@ int arm_simulate_step_core(target_t *target, uint32_t *dry_run_pc, struct arm_si
 			{
 				sim->set_reg_mode(sim, instruction.info.load_store.Rn, modified_address);
 			}
-			sim->set_reg_mode(sim, instruction.info.load_store.Rd, load_value);
 
-			if (instruction.info.load_store.Rd == 15)
+			if (instruction.info.load_store.Rd == 15) {
+				sim->set_reg_mode(sim, 15, load_value & ~1);
+				if (load_value & 1)
+					sim->set_state(sim, ARMV4_5_STATE_THUMB);
+				else
+					sim->set_state(sim, ARMV4_5_STATE_ARM);
 				return ERROR_OK;
+			}
+			sim->set_reg_mode(sim, instruction.info.load_store.Rd, load_value);
 		}
 	}
 	/* load multiple instruction */
@@ -636,7 +638,7 @@ int arm_simulate_step_core(target_t *target, uint32_t *dry_run_pc, struct arm_si
 		{
 			if (instruction.info.load_store_multiple.register_list & 0x8000)
 			{
-				*dry_run_pc = load_values[15];
+				*dry_run_pc = load_values[15] & ~1;
 				return ERROR_OK;
 			}
 		}
@@ -657,7 +659,16 @@ int arm_simulate_step_core(target_t *target, uint32_t *dry_run_pc, struct arm_si
 			{
 				if (instruction.info.load_store_multiple.register_list & (1 << i))
 				{
-					sim->set_reg_mode(sim, i, load_values[i]);
+					if (i == 15) {
+						uint32_t val = load_values[i];
+					sim->set_reg_mode(sim, i, val & ~1);
+					if (val & 1)
+						sim->set_state(sim, ARMV4_5_STATE_THUMB);
+					else
+						sim->set_state(sim, ARMV4_5_STATE_ARM);
+					} else {
+						sim->set_reg_mode(sim, i, load_values[i]);
+					}
 				}
 			}
 
-- 
2.11.4.GIT


From ad5192a2b948669aeeb9ccf5da81fa59ec21c346 Mon Sep 17 00:00:00 2001
From: Oleg Seiljus <oleg@signalyzer.com>
Date: Tue, 27 Oct 2009 11:56:04 -0700
Subject: [PATCH 02/16] Signalyzer: new config files

Add configs for H2, H4, LITE.

Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
---
 tcl/interface/signalyzer-h2.cfg   | 11 +++++++++++
 tcl/interface/signalyzer-h4.cfg   | 11 +++++++++++
 tcl/interface/signalyzer-lite.cfg | 11 +++++++++++
 3 files changed, 33 insertions(+)
 create mode 100644 tcl/interface/signalyzer-h2.cfg
 create mode 100644 tcl/interface/signalyzer-h4.cfg
 create mode 100644 tcl/interface/signalyzer-lite.cfg

diff --git a/tcl/interface/signalyzer-h2.cfg b/tcl/interface/signalyzer-h2.cfg
new file mode 100644
index 000000000..24288acba
--- /dev/null
+++ b/tcl/interface/signalyzer-h2.cfg
@@ -0,0 +1,11 @@
+#
+# Xverve Signalyzer H2 (DT-USB-SH2)
+#
+# http://www.signalyzer.com
+#
+
+interface ft2232
+ft2232_device_desc "Signalyzer H2"
+ft2232_layout signalyzer-h
+ft2232_vid_pid 0x0403 0xbca2
+
diff --git a/tcl/interface/signalyzer-h4.cfg b/tcl/interface/signalyzer-h4.cfg
new file mode 100644
index 000000000..d2b260b82
--- /dev/null
+++ b/tcl/interface/signalyzer-h4.cfg
@@ -0,0 +1,11 @@
+#
+# Xverve Signalyzer H4 (DT-USB-SH4)
+#
+# http://www.signalyzer.com
+#
+
+interface ft2232
+ft2232_device_desc "Signalyzer H4"
+ft2232_layout signalyzer-h
+ft2232_vid_pid 0x0403 0xbca4
+
diff --git a/tcl/interface/signalyzer-lite.cfg b/tcl/interface/signalyzer-lite.cfg
new file mode 100644
index 000000000..834bc0c59
--- /dev/null
+++ b/tcl/interface/signalyzer-lite.cfg
@@ -0,0 +1,11 @@
+#
+# Xverve Signalyzer LITE (DT-USB-SLITE)
+#
+# http://www.signalyzer.com
+#
+
+interface ft2232
+ft2232_device_desc "Signalyzer LITE"
+ft2232_layout signalyzer
+ft2232_vid_pid 0x0403 0xbca1
+
-- 
2.11.4.GIT


From 993fe4ab633eff4f04dd63e4751ccc2a6ea2d52e Mon Sep 17 00:00:00 2001
From: Oleg Seiljus <oleg@signalyzer.com>
Date: Tue, 27 Oct 2009 12:40:24 -0700
Subject: [PATCH 03/16] Signalyzer: H2 and H4 support

This patch includes partial support for these new JTAG adapters.
More complete support will require updates to the libftdi code,
for EEPROM access.

[dbrownell@users.sourceforge.net: fix whitespace, linelen, etc ]

Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
---
 src/jtag/ft2232.c            | 809 +++++++++++++++++++++++++++++++++++++++++++
 tcl/interface/signalyzer.cfg |   2 +-
 2 files changed, 810 insertions(+), 1 deletion(-)

diff --git a/src/jtag/ft2232.c b/src/jtag/ft2232.c
index fad07dcef..cf3fc0126 100644
--- a/src/jtag/ft2232.c
+++ b/src/jtag/ft2232.c
@@ -137,6 +137,7 @@ static int axm0432_jtag_init(void);
 static int sheevaplug_init(void);
 static int icebear_jtag_init(void);
 static int cortino_jtag_init(void);
+static int signalyzer_h_init(void);
 
 /* reset procedures for supported layouts */
 static void usbjtag_reset(int trst, int srst);
@@ -149,11 +150,13 @@ static void stm32stick_reset(int trst, int srst);
 static void axm0432_jtag_reset(int trst, int srst);
 static void sheevaplug_reset(int trst, int srst);
 static void icebear_jtag_reset(int trst, int srst);
+static void signalyzer_h_reset(int trst, int srst);
 
 /* blink procedures for layouts that support a blinking led */
 static void olimex_jtag_blink(void);
 static void flyswatter_jtag_blink(void);
 static void turtle_jtag_blink(void);
+static void signalyzer_h_blink(void);
 
 static const ft2232_layout_t  ft2232_layouts[] =
 {
@@ -173,6 +176,7 @@ static const ft2232_layout_t  ft2232_layouts[] =
 	{ "sheevaplug",           sheevaplug_init,           sheevaplug_reset,   NULL                    },
 	{ "icebear",              icebear_jtag_init,         icebear_jtag_reset, NULL                    },
 	{ "cortino",              cortino_jtag_init,         comstick_reset, NULL                        },
+	{ "signalyzer-h",         signalyzer_h_init,         signalyzer_h_reset, signalyzer_h_blink      },
 	{ NULL,                   NULL,                      NULL,               NULL                    },
 };
 
@@ -3070,3 +3074,808 @@ static void icebear_jtag_reset(int trst, int srst) {
 
 	LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
 }
+
+/* ---------------------------------------------------------------------
+ * Support for Signalyzer H2 and Signalyzer H4
+ * JTAG adapter from Xverve Technologies Inc.
+ * http://www.signalyzer.com or http://www.xverve.com
+ *
+ * Author: Oleg Seiljus, oleg@signalyzer.com
+ */
+static unsigned char signalyzer_h_side;
+static unsigned int signalyzer_h_adapter_type;
+
+static int signalyzer_h_ctrl_write(int address, unsigned short value);
+
+#if BUILD_FT2232_FTD2XX == 1
+static int signalyzer_h_ctrl_read(int address, unsigned short *value);
+#endif
+
+#define SIGNALYZER_COMMAND_ADDR					128
+#define SIGNALYZER_DATA_BUFFER_ADDR				129
+
+#define SIGNALYZER_COMMAND_VERSION				0x41
+#define SIGNALYZER_COMMAND_RESET				0x42
+#define SIGNALYZER_COMMAND_POWERCONTROL_GET		0x50
+#define SIGNALYZER_COMMAND_POWERCONTROL_SET		0x51
+#define SIGNALYZER_COMMAND_PWM_SET				0x52
+#define SIGNALYZER_COMMAND_LED_SET				0x53
+#define SIGNALYZER_COMMAND_ADC					0x54
+#define SIGNALYZER_COMMAND_GPIO_STATE			0x55
+#define SIGNALYZER_COMMAND_GPIO_MODE			0x56
+#define SIGNALYZER_COMMAND_GPIO_PORT			0x57
+#define SIGNALYZER_COMMAND_I2C					0x58
+
+#define SIGNALYZER_CHAN_A						1
+#define SIGNALYZER_CHAN_B						2
+/* LEDS use channel C */
+#define SIGNALYZER_CHAN_C						4
+
+#define SIGNALYZER_LED_GREEN					1
+#define SIGNALYZER_LED_RED						2
+
+#define SIGNALYZER_MODULE_TYPE_EM_LT16_A		0x0301
+#define SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG		0x0302
+#define SIGNALYZER_MODULE_TYPE_EM_JTAG			0x0303
+#define SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P	0x0304
+#define SIGNALYZER_MODULE_TYPE_EM_JTAG_P		0x0305
+
+
+static int signalyzer_h_ctrl_write(int address, unsigned short value)
+{
+#if BUILD_FT2232_FTD2XX == 1
+	return FT_WriteEE(ftdih, address, value);
+#elif BUILD_FT2232_LIBFTDI == 1
+	return 0;
+#endif
+}
+
+#if BUILD_FT2232_FTD2XX == 1
+static int signalyzer_h_ctrl_read(int address, unsigned short *value)
+{
+	return FT_ReadEE(ftdih, address, value);
+}
+#endif
+
+static int signalyzer_h_led_set(unsigned char channel, unsigned char led,
+	int on_time_ms, int off_time_ms, unsigned char cycles)
+{
+	unsigned char on_time;
+	unsigned char off_time;
+
+	if (on_time_ms < 0xFFFF)
+		on_time = (unsigned char)(on_time_ms / 62);
+	else
+		on_time = 0xFF;
+
+	off_time = (unsigned char)(off_time_ms / 62);
+
+#if BUILD_FT2232_FTD2XX == 1
+	FT_STATUS status;
+
+	if ((status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
+			((uint32_t)(channel << 8) | led))) != FT_OK)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write  returned: %lu", status);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	if ((status = signalyzer_h_ctrl_write(
+			(SIGNALYZER_DATA_BUFFER_ADDR + 1),
+			((uint32_t)(on_time << 8) | off_time))) != FT_OK)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write  returned: %lu", status);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	if ((status = signalyzer_h_ctrl_write(
+			(SIGNALYZER_DATA_BUFFER_ADDR + 2),
+			((uint32_t)cycles))) != FT_OK)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write  returned: %lu", status);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	if ((status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
+			SIGNALYZER_COMMAND_LED_SET)) != FT_OK)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write  returned: %lu", status);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	return ERROR_OK;
+#elif BUILD_FT2232_LIBFTDI == 1
+	int retval;
+
+	if ((retval = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
+			((uint32_t)(channel << 8) | led))) < 0)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
+				ftdi_get_error_string(&ftdic));
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	if ((retval = signalyzer_h_ctrl_write(
+			(SIGNALYZER_DATA_BUFFER_ADDR + 1),
+			((uint32_t)(on_time << 8) | off_time))) < 0)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
+				ftdi_get_error_string(&ftdic));
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	if ((retval = signalyzer_h_ctrl_write(
+			(SIGNALYZER_DATA_BUFFER_ADDR + 2),
+			(uint32_t)cycles)) < 0)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
+				ftdi_get_error_string(&ftdic));
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	if ((retval = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
+			SIGNALYZER_COMMAND_LED_SET)) < 0)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
+				ftdi_get_error_string(&ftdic));
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	return ERROR_OK;
+#endif
+}
+
+static int signalyzer_h_init(void)
+{
+#if BUILD_FT2232_FTD2XX == 1
+	FT_STATUS status;
+	int i;
+#endif
+
+	char *end_of_desc;
+
+	uint16_t read_buf[12];
+	uint8_t  buf[3];
+	uint32_t bytes_written;
+
+	/* turn on center green led */
+	signalyzer_h_led_set(SIGNALYZER_CHAN_C, SIGNALYZER_LED_GREEN,
+			0xFFFF, 0x00, 0x00);
+
+	/* determine what channel config wants to open
+	 * TODO: change me... current implementation is made to work
+	 * with openocd description parsing.
+	 */
+	end_of_desc = strrchr(ft2232_device_desc, 0x00);
+
+	if (end_of_desc)
+	{
+		signalyzer_h_side = *(end_of_desc - 1);
+		if (signalyzer_h_side == 'B')
+			signalyzer_h_side = SIGNALYZER_CHAN_B;
+		else
+			signalyzer_h_side = SIGNALYZER_CHAN_A;
+	}
+	else
+	{
+		LOG_ERROR("No Channel was specified");
+		return ERROR_FAIL;
+	}
+
+	signalyzer_h_led_set(signalyzer_h_side, SIGNALYZER_LED_GREEN,
+			1000, 1000, 0xFF);
+
+#if BUILD_FT2232_FTD2XX == 1
+	/* read signalyzer versionining information */
+	if ((status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
+			SIGNALYZER_COMMAND_VERSION)) != FT_OK)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	for (i = 0; i < 10; i++)
+	{
+		if ((status = signalyzer_h_ctrl_read(
+			(SIGNALYZER_DATA_BUFFER_ADDR + i),
+			&read_buf[i])) != FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_read returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+	}
+
+	LOG_INFO("Signalyzer: ID info: { %.4x %.4x %.4x %.4x %.4x %.4x %.4x }",
+			read_buf[0], read_buf[1], read_buf[2], read_buf[3],
+			read_buf[4], read_buf[5], read_buf[6]);
+
+	/* set gpio register */
+	if ((status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
+			(uint32_t)(signalyzer_h_side << 8))) != FT_OK)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	if ((status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1,
+			0x0404)) != FT_OK)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	if ((status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
+			SIGNALYZER_COMMAND_GPIO_STATE)) != FT_OK)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	/* read adapter type information */
+	if ((status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
+			((uint32_t)(signalyzer_h_side << 8) | 0x01))) != FT_OK)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	if ((status = signalyzer_h_ctrl_write(
+			(SIGNALYZER_DATA_BUFFER_ADDR + 1), 0xA000)) != FT_OK)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	if ((status = signalyzer_h_ctrl_write(
+			(SIGNALYZER_DATA_BUFFER_ADDR + 2), 0x0008)) != FT_OK)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	if ((status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
+			SIGNALYZER_COMMAND_I2C)) != FT_OK)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	usleep(100000);
+
+	if ((status = signalyzer_h_ctrl_read(SIGNALYZER_COMMAND_ADDR,
+			&read_buf[0])) != FT_OK)
+	{
+		LOG_ERROR("signalyzer_h_ctrl_read returned: %lu", status);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	if (read_buf[0] != 0x0498)
+		signalyzer_h_adapter_type = 0x0000;
+	else
+	{
+		for (i = 0; i < 4; i++)
+		{
+			if ((status = signalyzer_h_ctrl_read(
+					(SIGNALYZER_DATA_BUFFER_ADDR + i),
+					&read_buf[i])) != FT_OK)
+			{
+				LOG_ERROR("signalyzer_h_ctrl_read returned: %lu",
+					status);
+				return ERROR_JTAG_DEVICE_ERROR;
+			}
+		}
+
+		signalyzer_h_adapter_type = read_buf[0];
+	}
+
+#elif BUILD_FT2232_LIBFTDI == 1
+	/* currently libftdi does not allow reading individual eeprom
+	 * locations, therefore adapter type cannot be detected.
+	 * override with most common type
+	 */
+	signalyzer_h_adapter_type = SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG;
+#endif
+
+	enum reset_types jtag_reset_config = jtag_get_reset_config();
+
+	/* ADAPTOR: EM_LT16_A */
+	if (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_LT16_A)
+	{
+		LOG_INFO("Signalyzer: EM-LT (16-channel level translator) "
+			"detected. (HW: %2x).", (read_buf[1] >> 8));
+
+		nTRST    = 0x10;
+		nTRSTnOE = 0x10;
+		nSRST    = 0x20;
+		nSRSTnOE = 0x20;
+
+		low_output     = 0x08;
+		low_direction  = 0x1b;
+
+		high_output    = 0x0;
+		high_direction = 0x0;
+
+		if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
+		{
+			low_direction &= ~nTRSTnOE; /* nTRST input */
+			low_output    &= ~nTRST;    /* nTRST = 0 */
+		}
+		else
+		{
+			low_direction |= nTRSTnOE;  /* nTRST output */
+			low_output    |= nTRST;     /* nTRST = 1 */
+		}
+
+		if (jtag_reset_config & RESET_SRST_PUSH_PULL)
+		{
+			low_direction |= nSRSTnOE;  /* nSRST output */
+			low_output    |= nSRST;     /* nSRST = 1 */
+		}
+		else
+		{
+			low_direction &= ~nSRSTnOE; /* nSRST input */
+			low_output    &= ~nSRST;    /* nSRST = 0 */
+		}
+
+#if BUILD_FT2232_FTD2XX == 1
+		/* enable power to the module */
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_DATA_BUFFER_ADDR,
+				((uint32_t)(signalyzer_h_side << 8) | 0x01)))
+			!= FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+				status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		if ((status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
+				SIGNALYZER_COMMAND_POWERCONTROL_SET)) != FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		/* set gpio mode register */
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_DATA_BUFFER_ADDR,
+				(uint32_t)(signalyzer_h_side << 8))) != FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0000))
+			!= FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		if ((status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
+				SIGNALYZER_COMMAND_GPIO_MODE)) != FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		/* set gpio register */
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_DATA_BUFFER_ADDR,
+				(uint32_t)(signalyzer_h_side << 8))) != FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x4040))
+			!= FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_COMMAND_ADDR,
+				SIGNALYZER_COMMAND_GPIO_STATE)) != FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+#endif
+	}
+
+	/* ADAPTOR: EM_ARM_JTAG, EM_ARM_JTAG_P, EM_JTAG, EM_JTAG_P */
+	else if ((signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG) ||
+				(signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P) ||
+				(signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG)  ||
+				(signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG_P))
+	{
+		if (signalyzer_h_adapter_type
+				== SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG)
+			LOG_INFO("Signalyzer: EM-ARM-JTAG (ARM JTAG) "
+				"detected. (HW: %2x).", (read_buf[1] >> 8));
+		else if (signalyzer_h_adapter_type
+				== SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P)
+			LOG_INFO("Signalyzer: EM-ARM-JTAG_P "
+				"(ARM JTAG with PSU) detected. (HW: %2x).",
+				(read_buf[1] >> 8));
+		else if (signalyzer_h_adapter_type
+				== SIGNALYZER_MODULE_TYPE_EM_JTAG)
+			LOG_INFO("Signalyzer: EM-JTAG (Generic JTAG) "
+				"detected. (HW: %2x).", (read_buf[1] >> 8));
+		else if (signalyzer_h_adapter_type
+				== SIGNALYZER_MODULE_TYPE_EM_JTAG_P)
+			LOG_INFO("Signalyzer: EM-JTAG-P "
+				"(Generic JTAG with PSU) detected. (HW: %2x).",
+				(read_buf[1] >> 8));
+
+		nTRST          = 0x02;
+		nTRSTnOE       = 0x04;
+		nSRST          = 0x08;
+		nSRSTnOE       = 0x10;
+
+		low_output     = 0x08;
+		low_direction  = 0x1b;
+
+		high_output    = 0x0;
+		high_direction = 0x1f;
+
+		if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
+		{
+			high_output |= nTRSTnOE;
+			high_output &= ~nTRST;
+		}
+		else
+		{
+			high_output &= ~nTRSTnOE;
+			high_output |= nTRST;
+		}
+
+		if (jtag_reset_config & RESET_SRST_PUSH_PULL)
+		{
+			high_output &= ~nSRSTnOE;
+			high_output |= nSRST;
+		}
+		else
+		{
+			high_output |= nSRSTnOE;
+			high_output &= ~nSRST;
+		}
+
+#if BUILD_FT2232_FTD2XX == 1
+		/* enable power to the module */
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_DATA_BUFFER_ADDR,
+				((uint32_t)(signalyzer_h_side << 8) | 0x01)))
+			!= FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_COMMAND_ADDR,
+				SIGNALYZER_COMMAND_POWERCONTROL_SET)) != FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		/* set gpio mode register (IO_16 and IO_17 set as analog
+		 * inputs, other is gpio)
+		 */
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_DATA_BUFFER_ADDR,
+				(uint32_t)(signalyzer_h_side << 8))) != FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0060))
+			!= FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_COMMAND_ADDR,
+				SIGNALYZER_COMMAND_GPIO_MODE)) != FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		/* set gpio register (all inputs, for -P modules,
+		 * PSU will be turned off)
+		 */
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_DATA_BUFFER_ADDR,
+				(uint32_t)(signalyzer_h_side << 8))) != FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0000))
+			!= FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+
+		if ((status = signalyzer_h_ctrl_write(
+				SIGNALYZER_COMMAND_ADDR,
+				SIGNALYZER_COMMAND_GPIO_STATE)) != FT_OK)
+		{
+			LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
+					status);
+			return ERROR_JTAG_DEVICE_ERROR;
+		}
+#endif
+	}
+
+	else if (signalyzer_h_adapter_type == 0x0000)
+	{
+		LOG_INFO("Signalyzer: No external modules were detected.");
+
+		nTRST    = 0x10;
+		nTRSTnOE = 0x10;
+		nSRST    = 0x20;
+		nSRSTnOE = 0x20;
+
+		low_output     = 0x08;
+		low_direction  = 0x1b;
+
+		high_output    = 0x0;
+		high_direction = 0x0;
+
+		if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
+		{
+			low_direction &= ~nTRSTnOE; /* nTRST input */
+			low_output    &= ~nTRST;    /* nTRST = 0 */
+		}
+		else
+		{
+			low_direction |= nTRSTnOE;  /* nTRST output */
+			low_output    |= nTRST;     /* nTRST = 1 */
+		}
+
+		if (jtag_reset_config & RESET_SRST_PUSH_PULL)
+		{
+			low_direction |= nSRSTnOE;  /* nSRST output */
+			low_output    |= nSRST;     /* nSRST = 1 */
+		}
+		else
+		{
+			low_direction &= ~nSRSTnOE; /* nSRST input */
+			low_output    &= ~nSRST;    /* nSRST = 0 */
+		}
+	}
+	else
+	{
+		LOG_ERROR("Unknown module type is detected: %.4x",
+				signalyzer_h_adapter_type);
+		return ERROR_JTAG_DEVICE_ERROR;
+	}
+
+	/* initialize low byte of controller for jtag operation */
+	buf[0] = 0x80;
+	buf[1] = low_output;
+	buf[2] = low_direction;
+
+	if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK)
+			|| (bytes_written != 3))
+	{
+		LOG_ERROR("couldn't initialize Signalyzer-H layout");
+		return ERROR_JTAG_INIT_FAILED;
+	}
+
+#if BUILD_FT2232_FTD2XX == 1
+	if (ftdi_device == FT_DEVICE_2232H)
+	{
+		/* initialize high byte of controller for jtag operation */
+		buf[0] = 0x82;
+		buf[1] = high_output;
+		buf[2] = high_direction;
+
+		if ((ft2232_write(buf, 3, &bytes_written) != ERROR_OK)
+				|| (bytes_written != 3))
+		{
+			LOG_ERROR("couldn't initialize Signalyzer-H layout");
+			return ERROR_JTAG_INIT_FAILED;
+		}
+	}
+#elif BUILD_FT2232_LIBFTDI == 1
+	if (ftdi_device == TYPE_2232H)
+	{
+		/* initialize high byte of controller for jtag operation */
+		buf[0] = 0x82;
+		buf[1] = high_output;
+		buf[2] = high_direction;
+
+		if ((ft2232_write(buf, 3, &bytes_written) != ERROR_OK)
+				|| (bytes_written != 3))
+		{
+			LOG_ERROR("couldn't initialize Signalyzer-H layout");
+			return ERROR_JTAG_INIT_FAILED;
+		}
+	}
+#endif
+	return ERROR_OK;
+}
+
+static void signalyzer_h_reset(int trst, int srst)
+{
+	enum reset_types jtag_reset_config = jtag_get_reset_config();
+
+	/* ADAPTOR: EM_LT16_A */
+	if (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_LT16_A)
+	{
+		if (trst == 1)
+		{
+			if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
+				/* switch to output pin (output is low) */
+				low_direction |= nTRSTnOE;
+			else
+				/* switch output low */
+				low_output &= ~nTRST;
+		}
+		else if (trst == 0)
+		{
+			if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
+				/* switch to input pin (high-Z + internal
+				 * and external pullup) */
+				low_direction &= ~nTRSTnOE;
+			else
+				/* switch output high */
+				low_output |= nTRST;
+		}
+
+		if (srst == 1)
+		{
+			if (jtag_reset_config & RESET_SRST_PUSH_PULL)
+				/* switch output low */
+				low_output &= ~nSRST;
+			else
+				/* switch to output pin (output is low) */
+				low_direction |= nSRSTnOE;
+		}
+		else if (srst == 0)
+		{
+			if (jtag_reset_config & RESET_SRST_PUSH_PULL)
+				/* switch output high */
+				low_output |= nSRST;
+			else
+				/* switch to input pin (high-Z) */
+				low_direction &= ~nSRSTnOE;
+		}
+
+		/* command "set data bits low byte" */
+		buffer_write(0x80);
+		buffer_write(low_output);
+		buffer_write(low_direction);
+		LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, "
+				"low_direction: 0x%2.2x",
+				trst, srst, low_output, low_direction);
+	}
+	/* ADAPTOR: EM_ARM_JTAG,  EM_ARM_JTAG_P, EM_JTAG, EM_JTAG_P */
+	else if ((signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG) ||
+				(signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P) ||
+				(signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG)  ||
+				(signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG_P))
+	{
+		if (trst == 1)
+		{
+			if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
+				high_output &= ~nTRSTnOE;
+			else
+				high_output &= ~nTRST;
+		}
+		else if (trst == 0)
+		{
+			if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
+				high_output |= nTRSTnOE;
+			else
+				high_output |= nTRST;
+		}
+
+		if (srst == 1)
+		{
+			if (jtag_reset_config & RESET_SRST_PUSH_PULL)
+				high_output &= ~nSRST;
+			else
+				high_output &= ~nSRSTnOE;
+		}
+		else if (srst == 0)
+		{
+			if (jtag_reset_config & RESET_SRST_PUSH_PULL)
+				high_output |= nSRST;
+			else
+				high_output |= nSRSTnOE;
+		}
+
+		/* command "set data bits high byte" */
+		buffer_write(0x82);
+		buffer_write(high_output);
+		buffer_write(high_direction);
+		LOG_INFO("trst: %i, srst: %i, high_output: 0x%2.2x, "
+				"high_direction: 0x%2.2x",
+				trst, srst, high_output, high_direction);
+	}
+	else if (signalyzer_h_adapter_type == 0x0000)
+	{
+		if (trst == 1)
+		{
+			if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
+				/* switch to output pin (output is low) */
+				low_direction |= nTRSTnOE;
+			else
+				/* switch output low */
+				low_output &= ~nTRST;
+		}
+		else if (trst == 0)
+		{
+			if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
+				/* switch to input pin (high-Z + internal
+				 * and external pullup) */
+				low_direction &= ~nTRSTnOE;
+			else
+				/* switch output high */
+				low_output |= nTRST;
+		}
+
+		if (srst == 1)
+		{
+			if (jtag_reset_config & RESET_SRST_PUSH_PULL)
+				/* switch output low */
+				low_output &= ~nSRST;
+			else
+				/* switch to output pin (output is low) */
+				low_direction |= nSRSTnOE;
+		}
+		else if (srst == 0)
+		{
+			if (jtag_reset_config & RESET_SRST_PUSH_PULL)
+				/* switch output high */
+				low_output |= nSRST;
+			else
+				/* switch to input pin (high-Z) */
+				low_direction &= ~nSRSTnOE;
+		}
+
+		/* command "set data bits low byte" */
+		buffer_write(0x80);
+		buffer_write(low_output);
+		buffer_write(low_direction);
+		LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, "
+				"low_direction: 0x%2.2x",
+				trst, srst, low_output, low_direction);
+	}
+}
+
+static void signalyzer_h_blink(void)
+{
+	signalyzer_h_led_set(signalyzer_h_side, SIGNALYZER_LED_RED, 100, 0, 1);
+}
diff --git a/tcl/interface/signalyzer.cfg b/tcl/interface/signalyzer.cfg
index ff5f1251c..b0581c5c3 100644
--- a/tcl/interface/signalyzer.cfg
+++ b/tcl/interface/signalyzer.cfg
@@ -1,7 +1,7 @@
 #
 # Xverve Signalyzer Tool (DT-USB-ST)
 #
-# http://www.signalyzer.com/products/development-tools/signalyzer-tool-dt-usb-st.html
+# http://www.signalyzer.com
 #
 
 interface ft2232
-- 
2.11.4.GIT


From 39dd68bca649e9275c602fa212f448ae8497f306 Mon Sep 17 00:00:00 2001
From: Nicolas Pitre <nico@fluxnic.net>
Date: Tue, 27 Oct 2009 21:19:42 -0400
Subject: [PATCH 04/16] ARM: fix target address when disassembling Thumb BLX

A Thumb BLX instruction is branching to ARM code, and therefore the
first 2 bits of the target address must be cleared.

Signed-off-by: Nicolas Pitre <nico@marvell.com>
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
---
 src/target/arm_disassembler.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/target/arm_disassembler.c b/src/target/arm_disassembler.c
index 5b0046b7d..ee087b121 100644
--- a/src/target/arm_disassembler.c
+++ b/src/target/arm_disassembler.c
@@ -1768,6 +1768,7 @@ static int evaluate_b_bl_blx_thumb(uint16_t opcode,
 		case 1:
 			instruction->type = ARM_BLX;
 			mnemonic = "BLX";
+			target_address &= 0xfffffffc;
 			break;
 		/* BL/BLX prefix */
 		case 2:
-- 
2.11.4.GIT


From 76afa936ba4bfa5a5780dbad562c6637c252524b Mon Sep 17 00:00:00 2001
From: Nicolas Pitre <nico@fluxnic.net>
Date: Tue, 27 Oct 2009 21:19:43 -0400
Subject: [PATCH 05/16] ARM: fix single-step of Thumb unconditional branch

Only type 1 branch instruction has a condition code, not type 2.
Currently they're both tagged with ARM_B which doesn't allow for the
distinction.

Signed-off-by: Nicolas Pitre <nico@marvell.com>
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
---
 src/target/arm_simulator.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/target/arm_simulator.c b/src/target/arm_simulator.c
index c50a52cd9..27957b2f6 100644
--- a/src/target/arm_simulator.c
+++ b/src/target/arm_simulator.c
@@ -317,8 +317,8 @@ int arm_simulate_step_core(target_t *target, uint32_t *dry_run_pc, struct arm_si
 			return retval;
 		instruction_size = 2;
 
-		/* check condition code (only for branch instructions) */
-		if (instruction.type == ARM_B &&
+		/* check condition code (only for branch (1) instructions) */
+		if ((opcode & 0xf000) == 0xd000 &&
 		    !thumb_pass_branch_condition(sim->get_cpsr(sim, 0, 32), opcode))
 		{
 			if (dry_run_pc)
-- 
2.11.4.GIT


From 89c1bea9310c5ecfe09ba3b544240556160cfbec Mon Sep 17 00:00:00 2001
From: Zachary T Welch <zw@superlucidity.net>
Date: Sat, 24 Oct 2009 03:05:41 -0700
Subject: [PATCH 06/16] Improve .gitignore rules.

A '.*' rule prevents the 'git submodule add' from correctly adding the
first submodule, because it creates the .gitmodule file.  This file will
not be added (without -f) result in incomplete submodule commits.
The new rules mask the specific files present in my own build tree, but
additional rules may be needed to hide other types of temporary files.
---
 .gitignore | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index c0aba19e7..2c1c536ad 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,13 +1,17 @@
 # stuff "git status" should ignore
 
 # build output
-.*
+.libs
+.deps
 *.o
 *.a
 *.lo
 *.la
 *.in
 
+# editor files
+*.swp
+
 startup_tcl.c
 xscale_debug.h
 
-- 
2.11.4.GIT


From eb9790dc91bd2d46c480277b1f275ba2d6e1ca3f Mon Sep 17 00:00:00 2001
From: Zachary T Welch <zw@superlucidity.net>
Date: Sat, 24 Oct 2009 03:04:28 -0700
Subject: [PATCH 07/16] Add git2cl from repo.or.cz as a submodule in
 tools/git2cl.

---
 .gitmodules  | 3 +++
 tools/git2cl | 1 +
 2 files changed, 4 insertions(+)
 create mode 100644 .gitmodules
 create mode 160000 tools/git2cl

diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 000000000..2fcecfd7d
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "tools/git2cl"]
+	path = tools/git2cl
+	url = git://repo.or.cz/git2cl.git
diff --git a/tools/git2cl b/tools/git2cl
new file mode 160000
index 000000000..8373c9f74
--- /dev/null
+++ b/tools/git2cl
@@ -0,0 +1 @@
+Subproject commit 8373c9f74993e218a08819cbcdbab3f3564bbeba
-- 
2.11.4.GIT


From c970d03ddb7084713533c935864df18a6828d21a Mon Sep 17 00:00:00 2001
From: Zachary T Welch <zw@superlucidity.net>
Date: Thu, 22 Oct 2009 01:38:22 -0700
Subject: [PATCH 08/16] Factor release version functions into new script.

---
 tools/release/helpers.sh | 60 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 tools/release/helpers.sh

diff --git a/tools/release/helpers.sh b/tools/release/helpers.sh
new file mode 100644
index 000000000..2dd5bae15
--- /dev/null
+++ b/tools/release/helpers.sh
@@ -0,0 +1,60 @@
+#!/bin/sh -e
+
+die() {
+	echo "$@" >&2
+	exit 1
+}
+
+package_info_load_name() {
+	grep AC_INIT configure.in | perl -ne 's/^.+\(\[([-\w]*)\],.+$/$1/ and print'
+}
+package_info_load_version() {
+	grep AC_INIT configure.in | perl -ne 's/^.+\[([-\w\.]*)\],$/$1/ and print'
+}
+
+package_info_load() {
+	[ -f "configure.in" ] || \
+		die "package_info_load: configure.in is missing"
+
+	PACKAGE_NAME="$(package_info_load_name)"
+	# todo: fix this
+	PACKAGE_TARNAME="${PACKAGE_NAME}"
+
+	PACKAGE_VERSION="$(package_info_load_version)"
+
+	[ "${PACKAGE_NAME}" -a "${PACKAGE_VERSION}" ] || \
+		die "package information is missing from configure script"
+
+	PACKAGE_VERSION_TAGS=
+	[ "${PACKAGE_VERSION/-/}" = "${PACKAGE_VERSION}" ] || \
+		PACKAGE_VERSION_TAGS="-${PACKAGE_VERSION#*-}"
+	PACKAGE_VERSION_BASE="${PACKAGE_VERSION%%-*}"
+	PACKAGE_MICRO="${PACKAGE_VERSION_BASE##*.}"
+	PACKAGE_MAJOR_AND_MINOR="${PACKAGE_VERSION_BASE%.*}"
+	PACKAGE_MAJOR="${PACKAGE_MAJOR_AND_MINOR%.*}"
+	PACKAGE_MINOR="${PACKAGE_MAJOR_AND_MINOR#*.}"
+
+	[ "${RELEASE_FINAL}" ] \
+		&& RELEASE_VERSION="${PACKAGE_VERSION_BASE}" \
+		|| RELEASE_VERSION="${PACKAGE_VERSION/-dev/}"
+	PACKAGE_RELEASE="${PACKAGE_TARNAME}-${RELEASE_VERSION}"
+	PACKAGE_STRING="${PACKAGE_NAME} ${PACKAGE_VERSION}"
+}
+
+package_info_show() {
+	cat <<INFO
+Name: ${PACKAGE_TARNAME}
+Version: ${PACKAGE_VERSION}
+Release: ${RELEASE_VERSION}
+   Number: ${PACKAGE_VERSION_BASE}
+   Series: ${PACKAGE_MAJOR_AND_MINOR}
+    Major: ${PACKAGE_MAJOR}
+    Minor: ${PACKAGE_MINOR}
+    Micro: ${PACKAGE_MICRO}
+     Tags: ${PACKAGE_VERSION_TAGS}
+   Full: ${PACKAGE_TARNAME}-${PACKAGE_VERSION_BASE}${PACKAGE_VERSION_TAGS}
+Release: ${PACKAGE_RELEASE}
+   Type: ${RELEASE_TYPE}
+INFO
+}
+
-- 
2.11.4.GIT


From 07c85e41a47b418d7c6647041542764861105231 Mon Sep 17 00:00:00 2001
From: Zachary T Welch <zw@superlucidity.net>
Date: Tue, 20 Oct 2009 17:12:17 -0700
Subject: [PATCH 09/16] Factor version munging capabilities out of release.sh.

---
 tools/release/version.sh | 137 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 137 insertions(+)
 create mode 100755 tools/release/version.sh

diff --git a/tools/release/version.sh b/tools/release/version.sh
new file mode 100755
index 000000000..bef79d0e2
--- /dev/null
+++ b/tools/release/version.sh
@@ -0,0 +1,137 @@
+#!/bin/sh -e
+# version.sh: openocd version process automation
+# Copyright (C) 2009 by Zachary T Welch <zw@superlucidity.net>
+# Release under the GNU GPL v2 (or later versions).
+
+source "tools/release/helpers.sh"
+
+do_version_usage() {
+	cat << USAGE
+usage: $0 <command>
+Version Commands:
+  tag {add|remove} <label>     Add or remove the specified tag.
+  bump {major|minor|micro|rc}  Bump the specified version number, and
+                               reset less-significant numbers to zero.
+  bump tag <label>             Add or bump a versioned tag (e.g. -rcN).
+  bump final <label>           Remove a versioned tag (e.g. -rcN).
+USAGE
+}
+
+do_version_sed() {
+	local OLD_VERSION="${PACKAGE_VERSION}"
+	local NEW_VERSION="$1"
+	local MSG="$2"
+
+	sed -i -e "/AC_INIT/ s|${OLD_VERSION}|${NEW_VERSION}|" configure.in
+	package_info_load
+	echo "${MSG}: ${OLD_VERSION} -> ${NEW_VERSION}"
+}
+do_version_bump_sed() {
+	local NEW_VERSION="$1"
+	[ -z "${PACKAGE_VERSION_TAGS}" ] || \
+		NEW_VERSION="${NEW_VERSION}${PACKAGE_VERSION_TAGS}"
+
+	do_version_sed "${NEW_VERSION}" \
+		"Bump ${CMD} package version number"
+}
+do_version_bump_major() {
+	do_version_bump_sed "$((PACKAGE_MAJOR + 1)).0.0"
+}
+do_version_bump_minor() {
+	do_version_bump_sed "${PACKAGE_MAJOR}.$((PACKAGE_MINOR + 1)).0"
+}
+do_version_bump_micro() {
+	do_version_bump_sed "${PACKAGE_MAJOR_AND_MINOR}.$((PACKAGE_MICRO + 1))"
+}
+do_version_bump_tag() {
+	local TAG="$1"
+	[ "${TAG}" ] || die "TAG argument is missing"
+	local TAGS="${PACKAGE_VERSION_TAGS}"
+	if has_version_tag "${TAG}"; then
+		local RC=$(do_version_tag_value "${TAG}")
+		RC=$((${RC} + 1))
+		TAGS=$(echo ${TAGS} | perl -npe "s/-${TAG}[\\d]*/-${TAG}${RC}/")
+	else
+		TAGS="-${TAG}0${PACKAGE_VERSION_TAGS}"
+	fi
+	PACKAGE_VERSION_TAGS="${TAGS}"
+	do_version_bump_sed "${PACKAGE_VERSION_BASE}"
+}
+do_version_bump_final() {
+	local TAG="$1"
+	[ "${TAG}" ] || die "TAG argument is missing"
+	has_version_tag "${TAG}" || die "-${TAG} tag is missing"
+	do_version_tag_remove "${TAG}$(do_version_tag_value "${TAG}")"
+}
+do_version_bump() {
+	CMD="$1"
+	shift
+	case "${CMD}" in
+	major|minor|micro|final|tag)
+		"do_version_bump_${CMD}" "$@"
+		;;
+	rc)
+		do_version_bump_tag "rc"
+		;;
+	*)
+		do_version_usage
+		;;
+	esac
+}
+
+has_version_tag() {
+	test "${PACKAGE_VERSION/-${1}/}" != "${PACKAGE_VERSION}"
+}
+do_version_tag_value() {
+	local TAG="$1"
+	echo ${PACKAGE_VERSION_TAGS} | perl -ne "/-${TAG}"'(\d+)/ && print $1'
+}
+do_version_tag_add() {
+	local TAG="$1"
+	has_version_tag "${TAG}" && \
+		die "error: tag '-${TAG}' exists in '${PACKAGE_VERSION}'"
+	do_version_sed "${PACKAGE_VERSION}-${TAG}" \
+		"Add '-${TAG}' version tag"
+}
+do_version_tag_remove() {
+	local TAG="$1"
+	has_version_tag "${TAG}" || \
+		die "error: tag '-${TAG}' missing from '${PACKAGE_VERSION}'"
+	do_version_sed "${PACKAGE_VERSION/-${TAG}/}" \
+		"Remove '-${TAG}' version tag"
+}
+do_version_tag() {
+	CMD="$1"
+	shift
+	case "${CMD}" in
+	add|remove)
+		local i=
+		for i in "$@"; do
+			"do_version_tag_${CMD}" "${i}"
+		done
+		;;
+	*)
+		do_version_usage
+		;;
+	esac
+}
+
+do_version() {
+	CMD="$1"
+	shift
+	case "${CMD}" in
+	tag|bump)
+		"do_version_${CMD}" "$@"
+		;;
+	commit)
+		do_version_commit "$@"
+		;;
+	*)
+		do_version_usage
+		;;
+	esac
+}
+
+package_info_load
+do_version "$@"
+
-- 
2.11.4.GIT


From e8dc384be9d4bf2b7ed61178c02154dffdb15a9e Mon Sep 17 00:00:00 2001
From: Zachary T Welch <zw@superlucidity.net>
Date: Tue, 20 Oct 2009 17:11:33 -0700
Subject: [PATCH 10/16] Rewrite release script to use GIT.

Update documentation to reflect GIT methodology.  Rewrite release.sh
script to use appropriate process.  With this update, tools/release.sh
can be used for producing private release tags on local branches.
The documentation still needs work, but their use for v0.3.x should
help rectify the deficiences.
---
 doc/manual/release.txt | 198 ++++------
 tools/release.sh       | 976 +++++++++++++++++++------------------------------
 2 files changed, 436 insertions(+), 738 deletions(-)
 rewrite tools/release.sh (65%)

diff --git a/doc/manual/release.txt b/doc/manual/release.txt
index 64dcb8116..00e987e41 100644
--- a/doc/manual/release.txt
+++ b/doc/manual/release.txt
@@ -212,46 +212,47 @@ Even with the release script, some steps require clear user intervention
 
 The following steps should be followed to produce each release:
 
--# Produce final patches to mainline (or release branch):
+-# Produce final manual patches to mainline (or release branch):
   -# Finalize @c NEWS file to describe the changes in the release
     - This file is Used to automatically post "blurbs" about the project.
     - This material should be produced during the development cycle.
     - Add a new item for each @c NEWS-worthy contribution, when committed.
-  -# bump library version if our API changed (not yet required)
-  -# Remove -dev tag from package version in configure.in:
-    - For major/minor releases, remove version tag from mainline, @a or
-    - For bug-fix releases, remove version tag from release branch.
--# Branch or tag the required tree in the git repository:
-  - Tags and branches for releases must be named consistently: @par
-    "${PACKAGE_TARNAME}-${PACKAGE_VERSION}"
-  - For a major/minor release from the mainline, the code should be
-    tagged in the repository:
+  -# Bump library version if our API changed (not yet required)
+-# Produce and tag the final revision in the git repository:
+  - Update and commit the final package version in @c configure.in :
+  -# Remove @c -dev tag.
+  -# Remove @c -rc tag, if producing the final release from an -rc series.
+  - Tags must be named consistently:
 @verbatim
-svn cp .../trunk .../branches/${RELEASE_BRANCH}
-svn cp .../branches/${RELEASE_BRANCH} .../tags/${RELEASE_TAG}
 @endverbatim
-  - For bug-fix releases produced in their respective branch, a tag
-    should be created in the repository:
+  - Tag the final commit with a consistent GIT tag name and message:
 @verbatim
-svn cp .../branches/${RELEASE_BRANCH} .../tags/${RELEASE_TAG}
+PACKAGE_VERSION="x.y.z"
+PACKAGE_TAG="v${PACKAGE_VERSION}"
+git tag -m "The openocd-${PACKAGE_VERSION} release." "${PACKAGE_TAG}"
 @endverbatim
--# Prepare to resume normal development activities:
-  - Archive @c NEWS file as <code>doc/news/NEWS-${PACKAGE_VERSION}</code>.
-  - Create a new @c NEWS file for the next release
-  - For major/minor release from the mainline:
-    -# Bump major or minor package version in mainline.
-    -# Restore version tag to mainline.
-  - For bug-fix releases from a release branch:
-    -# Bump bug-fix version in release branch.
-    -# Restore version tag to release branch.
+-# Prepare to resume normal development on the branch:
+  - Restore @c -dev and -@c -rc0 version tags.
+  - To start a new major (or minor) release cycle on the @c master branch:
+    - Bump major (or minor) package version, zeroing sub-components.
+    - Add -rc0 version tag:
+      - This insures casual releases from GIT always increase monotonically.
+      - For example, a major increment after releasing 1.2.3 starts 2.0.0-rc0-dev.
+    - Archive @c NEWS file as "<code>doc/news/NEWS-${PACKAGE_VERSION}</code>".
+    - Create a new @c NEWS file for the next release
+  - To start a bug-fix release on a non-master branch:
+    -# Bump bug-fix version.
+  - To start another release candidate on a major or minor branch:
+    -# Bump rc tag.
 -# Produce the package source archives:
   -# Start with a clean working copy, used for producing releases only.
-  -# Switch to release tag branch: svn switch .../${RELEASE_TAG}
-  -# Produce a ChangeLog for the release (using svn2cl).
+  -# Checkout the appropriate tag:
+<code>git checkout $(git tag ) "${PACKAGE_VERSION}"</code>
+  -# Produce a ChangeLog for the release (using @c git2cl).
   -# @c bootstrap, @c configure, and @c make the package.
   -# Run <code>make distcheck</code> to produce the distribution archives.
   -# Run <code>make maintainer-clean</code> verify the repository is empty.
-  -# Create signature files using md5sum, sha1sum, etc.
+  -# Create signature files using @c md5sum, @c sha1sum, etc.
 -# Publish documentation for the release:
   - Allow users to access the documentation for each of our releases.
   - Place static copies of the following files on the project website:
@@ -259,12 +260,21 @@ svn cp .../branches/${RELEASE_BRANCH} .../tags/${RELEASE_TAG}
     - @c ChangeLog: to show exactly what has been changed
     - User Guide, Developer Manual: to allow easy on-line viewing
 -# Upload packages and post announcements of their availability:
-  -# Release packages into files section of berliOS project site:
+  -# Release packages into files section of project sites:
+    - SF.net:
+     -# Create a new folder named "${PACKAGE_VERSION}"
+     -# Select new folder as the target for uploads.
+     -# Upload files via Web interface into new
+     -# Set platform types for each archive:
+       - .tar.bz2: Linux, Mac
+       - .tar.gz: BSD, Solaris, Others
+       - .zip: Windows
+    - Berlios:
      -# Create the new release for the new version.
      -# Provide @c NEWS and ChangeLog files, as requested.
      -# Upload files via FTP to ftp://ftp.berlios.de/incoming/
      -# Edit descriptions for each file.
-     -# Send E-mail Release Notice
+     -# Click button to send E-mail Release Notice.
   -# Post announcement e-mail to the openocd-development list.
   -# Announce updates on freshmeat.net and other trackers.
   -# Submit big updates to news feeds (e.g. Digg, Reddit, etc.).
@@ -275,7 +285,7 @@ Many of the processes described in the last section are no longer
 entrusted to humans.  Instead, the @c release.sh script provides
 automation of the mechanical steps.
 
-Presently, the @c release.sh script automates steps 1(c) through 4,
+Presently, the @c release.sh script automates steps 2 through 4,
 allowing the Release Manager from perform these tasks in easy steps.
 
 The following task still need to be automated:
@@ -285,61 +295,34 @@ The following task still need to be automated:
 - Step 6(b): package announcement e-mail process.
 - Step 6(c): post files and announce them using releaseforge.
 
-In addition, support for '-rc' releases needs to be added.
-
 @subsection releasescriptcmds Release Script Commands
 
-The following output was taken from the release script:
-@verbatim
-usage: tools/release.sh [options] <command>
-
-Main Commands:
-  info          Show a summary of the next pending release.
-  release       Release the current tree as an archive.
-  upload        Upload archives to berliOS project site
-
-Build Commands:
-  bootstrap     Prepare the working copy for configuration and building.
-  configure     Configures the package; runs bootstrap, if needed.
-  build         Compiles the project; runs configure, if needed.
-
-Packaging Commands:
-  changelog     Generate a new ChangeLog using svn2cl.
-  package       Produce new distributable source archives.
-  stage         Move archives to staging area for upload.
-
-Repository Commands:
-  commit        Perform branch and tag, as appropriate for the version.
-  branch        Create a release branch from project mainline.
-  tag           Create a tag for the current release branch.
-
-Other Commands:
-  version ...   Perform version number and tag manipulations.
-  clean         Forces regeneration of results.
-  clean_all     Removes all traces of the release process.
-  help          Provides this list of commands.
-
-For more information about this script, see the Release Processes page
-in the OpenOCD Developer's Manual (doc/manual/release.txt).
-
-WARNING: This script should be used by the Release Manager ONLY.
-@endverbatim
+The release script can be used for two tasks:
+- Creating releases and starting a new release cycle:
+@code
+git checkout master
+tools/release.sh --type=minor --final --start-rc release
+@endcode
+- Creating a development branch from a tagged release:
+@code
+git checkout 'v0.2.0'
+tools/release.sh --type=micro branch
+@endcode
 
-Run <code>tools/release.sh help</code> for current command support.
+Both of these variations make automatic commits and tags in your
+repository, so you should be sure to run it on a cloned copy before
+proceding with a live release.
 
 @subsection releasescriptopts Release Script Options
 
 The @c release.sh script recognizes some command-line options that
 affect its behavior:
 
-- @c --live : Use this option to perform a live release.
-  When this option has been given, the release commands will affect
-  the repository; otherwise, the script reports the actions to take,
-  and it produces archives that are unsuitable for public release.
-
-@note Only the Release Manager should use the @c --live option, as
-it will make permanent changes to the git repository that
-cannot be undone.
+- The @c --start-rc indicates that the new development release cycle
+  should start with @c -rc0.  Without this, the @c -rc tag will be omitted,
+  leading to non-monotonic versioning of the in-tree version numbers.
+- The @c --final indicates that the release should drop the @c -rc tag,
+  to going from @c x.y.z-rcN-dev to x.y.z.
 
 @subsection releasescriptenv Release Script Environment
 
@@ -351,66 +334,9 @@ affect its behavior:
 
 @section releasetutorial Release Tutorials
 
-This section provides tutorials for using the Release Script to perform
-common release tasks.
-
-@subsection releasetutorialsetup Release Tutorial Setup
-
-The tutorials in this section assume the following environment
-variables have been set properly:
-@verbatim
-SVN_USER="maintainer"
-SVN_URL="https://${SVN_USER}@svn.berlios.de/svnroot/repos/openocd"
-@endverbatim
-
-@subsection releasetutorialminor Minor Release Tutorial
-
-This section provides a step-by-step tutorial for a Release Manager to
-use to run the @c release.sh script to produce a minor release.
-
-If the proper environment has been set, the following steps will produce
-a new minor release:
-
--# Check out (or update) mainline from the repository:
-@code
-svn checkout "${SVN_URL}/trunk" openocd-trunk
-@endcode
--# Change to the new working copy directory:
-@code
-cd openocd-trunk
-@endcode
--# Run @c release.sh to produce the minor release:
-@code
-tools/release.sh all
-@endcode
-
-@subsection releasetutorialmicro Bug-Fix Release Tutorial
-
-This section provides a step-by-step tutorial for a Release Manager to
-use to run the @c release.sh script to produce a bug-fix release.
-
-In addition to the environment variables described in the introduction
-to these tutorials, the following variables are also used in the
-instructions for this section:
-@verbatim
-PACKAGE_BRANCH_VERSION="x.y.z"
-PACKAGE_BRANCH="openocd-${PACKAGE_BRANCH_VERSION}"
-@endverbatim
-
-If the proper environment has been set, the following steps will produce
-a new bug-fix release:
-
--# Check out (or update) the release branch from the project repository:
-@code
-svn checkout "${SVN_URL}/branches/${PACKAGE_BRANCH}" "${PACKAGE_BRANCH}"
-@endcode
-@code
-cd "${PACKAGE_BRANCH}"
-@endcode
--# Run @c release.sh to produce the bug-fix release:
-@code
-tools/release.sh all
-@endcode
+This section should contain a brief tutorial for using the Release 
+Script to perform release tasks, but the new script needs to be
+used for 0.3.0.
 
 @section releasetodo Release Script Shortcomings
 
diff --git a/tools/release.sh b/tools/release.sh
dissimilarity index 65%
index f1ed4a73a..26be15118 100755
--- a/tools/release.sh
+++ b/tools/release.sh
@@ -1,602 +1,374 @@
-#!/bin/sh -e
-# release.sh: openocd release process automation
-# Copyright (C) 2009 by Zachary T Welch <zw@superlucidity.net>
-# Release under the GNU GPL v2 (or later versions).
-
-## set these to control the build process
-#CONFIG_OPTS=""
-#MAKE_OPTS=""
-
-## DO NOT PERFORM LIVE RELEASES UNLESS YOU ARE THE RELEASE MANAGER!!!
-RELEASE_DRY_RUN=1
-## set this to perform individual steps on past releases
-RELEASE_VERSION=
-
-die() {
-	echo "$@" >&2
-	exit 1
-}
-
-svn_info_get() {
-	svn info | grep "$1" | cut -d':' -f2- | cut -c2-
-}
-
-svn_setup_load() {
-	SVN_ROOT="$(svn_info_get 'Repository Root')"
-	SVN_URL="$(svn_info_get 'URL')"
-
-	SVN_TRUNK="${SVN_ROOT}/trunk"
-
-	SVN_BRANCHES="${SVN_ROOT}/branches"
-	PACKAGE_BRANCH="${SVN_BRANCHES}/${PACKAGE_RELEASE}"
-
-	SVN_TAGS="${SVN_ROOT}/tags"
-	PACKAGE_TAG="${SVN_TAGS}/${PACKAGE_RELEASE}"
-
-	if [ "${SVN_URL}" = "${SVN_TRUNK}" ]; then
-		RELEASE_TYPE=minor
-	elif [ "${SVN_URL/${SVN_BRANCHES}/}" != "${SVN_URL}" ]; then
-		RELEASE_TYPE=micro
-	else
-		echo "error: bad URL: ${SVN_URL}" >&2
-		die "unable to branch from the current location"
-	fi
-}
-svn_setup_show() {
-	cat <<INFO
-Release Type: ${RELEASE_TYPE}
-  Branch URL: ${PACKAGE_BRANCH}
-     Tag URL: ${PACKAGE_TAG}
-INFO
-}
-
-do_svn_echo_msg() { echo "svn: $1: $3"; }
-do_svn_echo() {
-	case "$1" in
-	commit)
-		do_svn_echo_msg "$@"
-		shift 3
-		[ "$*" ] && echo "Files: $@"
-		;;
-	copy|move)
-		do_svn_echo_msg "$@"
-		echo "From: ${4:-$2}"
-		echo "  To: ${5:-$3}"
-		;;
-	*)
-		local ACTION="$1"
-		shift
-		echo "svn: ${ACTION}: $@"
-		;;
-	esac
-}
-do_svn() {
-	do_svn_echo "$@"
-	[ "${RELEASE_DRY_RUN}" ] || svn "$@"
-}
-do_svn_switch() {
-	do_svn switch "$@"
-	package_info_load
-}
-
-
-package_info_load_name() {
-	grep AC_INIT configure.in | perl -ne 's/^.+\(\[([-\w]*)\],.+$/$1/ and print'
-}
-package_info_load_version() {
-	grep AC_INIT configure.in | perl -ne 's/^.+\[([-\w\.]*)\],$/$1/ and print'
-}
-
-package_info_load() {
-	[ -f "configure.in" ] || \
-		die "package_info_load: configure.in is missing"
-
-	PACKAGE_NAME="$(package_info_load_name)"
-	# todo: fix this
-	PACKAGE_TARNAME="${PACKAGE_NAME}"
-
-	PACKAGE_VERSION="$(package_info_load_version)"
-	[ "${RELEASE_VERSION}" ] || \
-		RELEASE_VERSION=${PACKAGE_VERSION/-dev/}
-
-	[ "${PACKAGE_NAME}" -a "${PACKAGE_VERSION}" ] || \
-		die "package information is missing from configure script"
-
-	PACKAGE_VERSION_TAGS=
-	[ "${PACKAGE_VERSION/-/}" = "${PACKAGE_VERSION}" ] || \
-		PACKAGE_VERSION_TAGS="-${PACKAGE_VERSION#*-}"
-	PACKAGE_VERSION_BASE="${PACKAGE_VERSION%%-*}"
-	PACKAGE_MICRO="${PACKAGE_VERSION_BASE##*.}"
-	PACKAGE_MAJOR_AND_MINOR="${PACKAGE_VERSION_BASE%.*}"
-	PACKAGE_MAJOR="${PACKAGE_MAJOR_AND_MINOR%.*}"
-	PACKAGE_MINOR="${PACKAGE_MAJOR_AND_MINOR#*.}"
-
-	PACKAGE_STRING="${PACKAGE_NAME} ${PACKAGE_VERSION}"
-	if [ "${RELEASE_DRY_RUN}" ]; then
-		PACKAGE_RELEASE="${PACKAGE_TARNAME}-${PACKAGE_VERSION}"
-	else
-		PACKAGE_RELEASE="${PACKAGE_TARNAME}-${RELEASE_VERSION}"
-	fi
-}
-
-package_info_show() {
-	cat <<INFO
-Name: ${PACKAGE_TARNAME}
-Release: ${RELEASE_VERSION}
-Version: ${PACKAGE_VERSION}
-   Number: ${PACKAGE_VERSION_BASE}
-   Series: ${PACKAGE_MAJOR_AND_MINOR}
-    Major: ${PACKAGE_MAJOR}
-    Minor: ${PACKAGE_MINOR}
-    Micro: ${PACKAGE_MICRO}
-     Tags: ${PACKAGE_VERSION_TAGS}
- Branch: ${PACKAGE_RELEASE}
-Release: ${PACKAGE_TARNAME}-${PACKAGE_VERSION_BASE}${PACKAGE_VERSION_TAGS}
-INFO
-}
-
-usage() {
-	cat << USAGE
-usage: $0 <command>
-
-Main Commands:
-  info          Show a summary of the next pending release.
-  release       Release the current tree as an archive.
-  upload        Upload archives to berliOS project site
-
-Build Commands:
-  bootstrap     Prepare the working copy for configuration and building.
-  configure     Configures the package; runs bootstrap, if needed.
-  build         Compiles the project; runs configure, if needed.
-
-Packaging Commands:
-  changelog     Generate a new ChangeLog using svn2cl.
-  package       Produce new distributable source archives.
-  stage         Move archives to staging area for upload.
-
-Repository Commands:
-  commit        Perform branch and tag, as appropriate for the version.
-  branch        Create a release branch from the project trunk.
-  tag           Create a tag for the current release branch.
-
-Other Commands:
-  version ...   Perform version number and tag manipulations.
-  maryslamb     Mary had a little lamb, but no one noticed.
-  clean         Forces regeneration of results.
-  clean_all     Removes all traces of the release process.
-  help          Provides this list of commands.
-  
-For more information about this script, see the Release Processes page
-in the OpenOCD Developer's Manual (doc/manual/release.txt).
-
-WARNING: This script should be used by the Release Manager ONLY.
-USAGE
-	exit 0
-}
-do_usage() { usage; }
-do_help()  { usage; }
-
-do_info_show() {
-	echo "Current Release Analysis:"
-	package_info_show
-	svn_setup_show
-}
-
-do_info() {
-	package_info_load
-	svn_setup_load
-	do_info_show
-}
-
-do_bootstrap() {
-	echo -n "Bootstrapping..."
-	./bootstrap 2>&1 | perl tools/logger.pl > "release-bootstrap.log"
-}
-maybe_bootstrap() { [ -f "configure" ] || do_bootstrap; }
-
-do_configure() {
-	maybe_bootstrap
-	echo -n "Configuring..."
-	./configure ${CONFIG_OPTS} 2>&1 | perl tools/logger.pl > "release-config.log"
-}
-maybe_configure() { [ -f "Makefile" ] || do_configure; }
-
-do_build() {
-	maybe_configure
-	echo -n "Compiling OpenOCD ${PACKAGE_VERSION}"
-	make ${MAKE_OPTS} -C doc stamp-vti 2>&1 \
-		| perl tools/logger.pl > "release-version.log"
-	make ${MAKE_OPTS} 2>&1 \
-		| perl tools/logger.pl > "release-make.log"
-}
-maybe_build() { [ -f "src/openocd" ] || do_build; }
-do_build_clean() { [ -f Makefile ] && make maintainer-clean >/dev/null; }
-
-do_changelog() {
-	echo "Updating working copy to HEAD..."
-	do_svn update
-	echo "Creating ChangeLog..."
-	svn2cl -i --authors AUTHORS.ChangeLog
-}
-maybe_changelog() {
-	if [ -z "${RELEASE_DRY_RUN}" ] \
-		|| [ ! -f ChangeLog ] \
-		|| [ "$(cat ChangeLog | wc -l)" -lt 2 ]
-	then
-		do_changelog
-	fi
-}
-do_changelog_clean() {
-	do_svn revert ChangeLog
-}
-
-do_package() {
-	package_info_load
-	maybe_changelog
-	maybe_build
-	echo "Building distribution packages..."
-	make ${MAKE_OPTS} distcheck 2>&1 | perl tools/logger.pl > "release-pkg.log"
-}
-maybe_package() { [ -f "${PACKAGE_RELEASE}.zip" ] || do_package; }
-do_package_clean() {
-	for EXT in tar.gz tar.bz2 zip; do
-		rm -v -f *.${EXT}
-	done
-}
-
-do_stage() {
-	maybe_package
-	echo "Staging package archives:"
-	mkdir -p archives
-	for EXT in tar.gz tar.bz2 zip; do
-		local FILE="${PACKAGE_RELEASE}.${EXT}"
-		# create archive signatures
-		for HASH in md5 sha1; do
-			echo "sign: ${FILE}.${HASH}"
-			${HASH}sum "${FILE}" > "archives/${FILE}.${HASH}"
-		done
-		# save archive
-		mv -v "${FILE}" archives/
-	done
-	cp -a NEWS archives/
-	cp -a ChangeLog archives/
-}
-do_stage_clean() { rm -v -f -r archives; }
-
-do_clean() {
-	do_build_clean
-	do_package_clean
-	rm -v -f configure
-
-	svn revert configure.in
-	rm -v -f release-*.log
-}
-do_clean_all() {
-	do_clean
-	do_changelog_clean
-	do_stage_clean
-}
-
-do_version_usage() {
-	cat << USAGE
-usage: $0 version <command>
-Version Commands:
-  tag {add|remove} <label>     Add or remove the specified tag.
-  bump {major|minor|micro}     Bump the specified version number, and
-                               reset less-significant numbers to zero.
-  bump tag <label>             Add or bump a versioned tag (e.g. -rcN).
-  bump final <label>           Remove a versioned tag (e.g. -rcN).
-USAGE
-}
-
-do_version_sed() {
-	local OLD_VERSION="${PACKAGE_VERSION}"
-	local NEW_VERSION="$1"
-	local MSG="$2"
-
-	sed -i -e "/AC_INIT/ s|${OLD_VERSION}|${NEW_VERSION}|" configure.in
-	package_info_load
-	echo "${MSG}: ${OLD_VERSION} -> ${NEW_VERSION}"
-}
-do_version_bump_sed() {
-	local NEW_VERSION="$1"
-	[ -z "${PACKAGE_VERSION_TAGS}" ] || \
-		NEW_VERSION="${NEW_VERSION}${PACKAGE_VERSION_TAGS}"
-
-	do_version_sed "${NEW_VERSION}" \
-		"Bump ${CMD} package version number"
-}
-do_version_bump_major() {
-	do_version_bump_sed "$((PACKAGE_MAJOR + 1)).0.0"
-}
-do_version_bump_minor() {
-	do_version_bump_sed "${PACKAGE_MAJOR}.$((PACKAGE_MINOR + 1)).0"
-}
-do_version_bump_micro() {
-	do_version_bump_sed "${PACKAGE_MAJOR_AND_MINOR}.$((PACKAGE_MICRO + 1))"
-}
-do_version_bump_tag() {
-	local TAG="$1"
-	[ "${TAG}" ] || die "TAG argument is missing"
-	local TAGS="${PACKAGE_VERSION_TAGS}"
-	if has_version_tag "${TAG}"; then
-		local RC=$(do_version_tag_value "${TAG}")
-		RC=$((${RC} + 1))
-		TAGS=$(echo ${TAGS} | perl -npe "s/-${TAG}[\\d]*/-${TAG}${RC}/")
-	else
-		TAGS="-${TAG}1${PACKAGE_VERSION_TAGS}"
-	fi
-	PACKAGE_VERSION_TAGS="${TAGS}"
-	do_version_bump_sed "${PACKAGE_VERSION_BASE}"
-}
-do_version_bump_final() {
-	local TAG="$1"
-	[ "${TAG}" ] || die "TAG argument is missing"
-	has_version_tag "${TAG}" || die "-${TAG} tag is missing"
-	do_version_tag_remove "${TAG}$(do_version_tag_value "${TAG}")"
-}
-do_version_bump() {
-	CMD="$1"
-	shift
-	case "${CMD}" in
-	major|minor|micro|final|tag)
-		eval "do_version_bump_${CMD}" "$@"
-		;;
-	*)
-		do_version_usage
-		;;
-	esac
-}
-
-has_version_tag() {
-	test "${PACKAGE_VERSION/-${1}/}" != "${PACKAGE_VERSION}"
-}
-do_version_tag_value() {
-	local TAG="$1"
-	echo ${PACKAGE_VERSION_TAGS} | perl -ne "/-${TAG}"'(\d+)/ && print $1'
-}
-do_version_tag_add() {
-	local TAG="$1"
-	has_version_tag "${TAG}" && \
-		die "error: tag '-${TAG}' exists in '${PACKAGE_VERSION}'"
-	do_version_sed "${PACKAGE_VERSION}-${TAG}" \
-		"Add '-${TAG}' version tag"
-}
-do_version_tag_remove() {
-	local TAG="$1"
-	has_version_tag "${TAG}" || \
-		die "error: tag '-${TAG}' missing from '${PACKAGE_VERSION}'"
-	do_version_sed "${PACKAGE_VERSION/-${TAG}/}" \
-		"Remove '-${TAG}' version tag"
-}
-do_version_tag() {
-	CMD="$1"
-	shift
-	case "${CMD}" in
-	add|remove)
-		local i=
-		for i in "$@"; do 
-			eval "do_version_tag_${CMD}" "${i}"
-		done
-		;;
-	*)
-		do_version_usage
-		;;
-	esac
-}
-
-do_version_commit() {
-	[ "$(svn diff configure.in | wc -l)" -gt 0 ] || \
-		die "error: no version changes to commit"
-	do_svn commit -m "$1" configure.in
-}
-
-do_version() {
-	package_info_load
-	CMD="$1"
-	shift
-	case "${CMD}" in
-	tag|bump)
-		do_version_commit "$(eval "do_version_${CMD}" "$@")"
-		;;
-	commit)
-		local MSG="$1"
-		[ "${MSG}" ] || die "usage: $0 version commit <message>"
-		do_version_commit "${MSG}"
-		;;
-	*)
-		do_version_usage
-		;;
-	esac
-}
-
-
-do_branch() {
-	package_info_load
-	svn_setup_load
-	do_svn copy -m "Branching version ${PACKAGE_VERSION}" \
-		"${SVN_TRUNK}" "${PACKAGE_BRANCH}"
-}
-do_tag() {
-	package_info_load
-	svn_setup_load
-	do_svn copy -m "Tagging version ${PACKAGE_VERSION}" \
-		"${PACKAGE_BRANCH}" "${PACKAGE_TAG}"
-}
-do_commit() {
-	package_info_load
-	svn_setup_load
-
-	[ "${PACKAGE_VERSION/dev/}" = "${PACKAGE_VERSION}" ] || \
-		die "'${PACKAGE_NAME}-${PACKAGE_VERSION}' cannot be released"
-
-	[ "${PACKAGE_VERSION%.0}" = "${PACKAGE_VERSION}" ] || \
-		do_branch
-	do_tag
-}
-
-
-do_release_step_prep() {
-	do_version tag remove dev
-	# reset RELEASE_VERSION now to allow release version to be detected
-	export RELEASE_VERSION=
-}
-do_release_step_commit() { do_commit; }
-
-do_release_step_branch_bump() {
-	local TYPE="$1"
-	echo "Bump ${TYPE} version and add tag:"
-	do_version_bump ${TYPE}
-	do_version_tag_add dev
-}
-do_release_step_branch() {
-	do_svn_switch "${PACKAGE_BRANCH}"
-	do_version_commit "$(do_release_step_branch_bump micro)"
-	do_svn_switch "${SVN_URL}"
-}
-do_release_step_news_msg() {
-	cat <<MSG
-Archive released NEWS file: NEWS -> NEWS-${RELEASE_VERSION}
-Create new NEWS file from relesse script template.
-MSG
-}
-do_release_step_news() {
-	# archive NEWS and create new one from template
-	do_svn move "NEWS" "NEWS-${RELEASE_VERSION}"
-
-	[ "${RELEASE_DRY_RUN}" ] || cat >NEWS <<NEWS
-This file should include items worth mentioning in the
-OpenOCD ${PACKAGE_RELEASE} source archive release.
-
-The following areas of OpenOCD functionality changed in this release:
-
-JTAG Layer:
-Target Layer:
-Flash Layer:
-Board, Target, and Interface Configuration Scripts:
-Documentation:
-Build and Release:
-
-For more details about what has changed since the last release,
-see the ChangeLog associated with this source archive.  For older NEWS,
-see the NEWS files associated with each release (i.e. NEWS-<version>).
-
-For more information about contributing test reports, bug fixes, or new
-features and device support, please read the new Developer Manual (or
-the BUGS and PATCHES files in the source archive).
-NEWS
-	do_svn add NEWS
-
-	local MSG="$(do_release_step_news_msg)"
-	do_svn commit -m "${MSG}" NEWS NEWS-${RELEASE_VERSION}
-}
-do_release_step_bump() {
-	# major and minor releases require branch version update too
-	[ "${RELEASE_TYPE}" = "micro" ] || do_release_step_branch
-	# bump the current tree version as required.
-	do_version_commit "$(do_release_step_branch_bump "${RELEASE_TYPE}")"
-
-	[ "${RELEASE_TYPE}" = "micro" ] || do_release_step_news
-}
-do_release_step_package() {
-	local A=${PACKAGE_TAG}
-	local B=${A/https/http}
-	local PACKAGE_BUILD=${B/${USER}@/}
-
-	do_svn_switch "${PACKAGE_TAG}"
-	do_svn_switch --relocate "${PACKAGE_TAG}" "${PACKAGE_BUILD}"
-
-	# required to force SVN to update the in-source URL keyword
-	[ "${RELEASE_DRY_RUN}" ] || rm -v -f src/openocd.c
-	do_svn revert src/openocd.c
-
-	do_stage
-	do_clean
-
-	do_svn_switch --relocate "${PACKAGE_BUILD}" "${PACKAGE_TAG}"
-	do_svn_switch "${SVN_URL}"
-}
-
-do_release_step_1() { do_release_step_prep; }
-do_release_step_2() { do_release_step_commit; }
-do_release_step_3() { do_release_step_bump; }
-do_release_step_4() { do_release_step_package; }
-
-do_release_check() {
-	echo -n "Are you sure you want to release '${PACKAGE_RELEASE}'?"
-	read ANSWER
-	if [ "${ANSWER}" != 'y' ]; then
-		echo "Live release aborted!"
-		exit 0
-	fi
-}
-do_countdown() {
-	echo -n "$1 in "
-	for i in $(seq 5 -1 1); do
-		echo -n "$i, "
-	done
-	echo "go!"
-}
-
-do_release() {
-	package_info_load
-	package_info_show
-
-	if [ -z "${RELEASE_DRY_RUN}" ]; then
-		do_release_check
-		do_countdown "Starting live release"
-	fi
-
-	local i=
-	for i in $(seq 1 4); do
-		eval "do_release_step_${i}"
-	done
-}
-do_all() { do_release "$@"; }
-
-do_reset() {
-	maybe_bootstrap
-	maybe_configure
-	do_clean_all
-	svn revert configure.in
-}
-
-OPTIONS=$(getopt -o V --long live -n $0 -- "$@")
-if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi
-eval set -- "${OPTIONS}"
-while true; do
-	case "$1" in
-	--live)
-		export RELEASE_DRY_RUN=
-		shift
-		;;
-	-V)
-		exec $0 info
-		;;
-	--)
-		shift
-		break
-		;;
-	*)
-		echo "Internal error"
-		exit 1
-		;;
-	esac
-done
-
-CMD=$1
-[ "${CMD}" ] || usage
-shift
-
-ACTION_CMDS="bootstrap|configure|build|changelog|package|stage|clean"
-MISC_CMDS="all|info|version|tag|branch|commit|release|reset|help|usage"
-CLEAN_CMDS="build_clean|changelog_clean|package_clean|stage_clean|clean_all"
-CMDS="|${ACTION_CMDS}|${CLEAN_CMDS}|${MISC_CMDS}|"
-is_command() { echo "${CMDS}" | grep "|$1|" >/dev/null; }
-
-if is_command "${CMD}"; then
-	eval "do_${CMD}" "$@"
-else
-	echo "error: unknown command: '${CMD}'"
-	usage
-fi
+#!/bin/sh -e
+# release.sh: openocd release process automation
+# Copyright (C) 2009 by Zachary T Welch <zw@superlucidity.net>
+# Release under the GNU GPL v2 (or later versions).
+
+## set these to control the build process
+#CONFIG_OPTS=""
+#MAKE_OPTS=""
+
+## specifies the --next release type: major, minor, micro, rc, tag
+#RELEASE_TYPE=tag
+## For tag release type, specifies the name of the tag (e.g. "foo").
+## The default is the current user name, as found by the 'id' command.
+#RELEASE_TAG="$(id -un)"
+
+source "tools/release/helpers.sh"
+
+VERSION_SH="tools/release/version.sh"
+
+usage() {
+	cat << USAGE
+usage: $0 <command> ...
+Command Options:
+  --next name   The branch's next release type: major, minor, micro, rc, tag.
+  --next-tag name   The name for the package version tag.
+  --live        Perform the actions in the repository.
+
+Main Commands:
+  info          Show a summary of the next pending release.
+  release       Release the current tree as an archive.
+
+Build Commands:
+  bootstrap     Prepare the working copy for configuration and building.
+  configure     Configures the package; runs bootstrap, if needed.
+  build         Compiles the project; runs configure, if needed.
+
+Packaging Commands:
+  changelog     Generate a new ChangeLog using ${SCM}2cl.
+  package       Produce new distributable source archives.
+  stage         Move archives to staging area for upload.
+
+Other Commands:
+  clean         Forces regeneration of results.
+  clean_all     Removes all traces of the release process.
+  help          Provides this list of commands.
+
+For more information about this script, see the Release Processes page
+in the OpenOCD Developer's Manual (doc/manual/release.txt).
+USAGE
+	exit 0
+}
+do_usage() { usage; }
+do_help()  { usage; }
+
+do_info() {
+	echo "Current Release Analysis:"
+	package_info_show
+}
+
+do_bootstrap() {
+	echo -n "Bootstrapping..."
+	./bootstrap 2>&1 | perl tools/logger.pl > "release-bootstrap.log"
+}
+maybe_bootstrap() { [ -f "configure" ] || do_bootstrap; }
+
+do_configure() {
+	maybe_bootstrap
+	echo -n "Configuring..."
+	./configure ${CONFIG_OPTS} 2>&1 | perl tools/logger.pl > "release-config.log"
+}
+maybe_configure() { [ -f "Makefile" ] || do_configure; }
+
+do_build() {
+	maybe_configure
+	echo -n "Compiling OpenOCD ${PACKAGE_VERSION}"
+	make ${MAKE_OPTS} -C doc stamp-vti 2>&1 \
+		| perl tools/logger.pl > "release-version.log"
+	make ${MAKE_OPTS} 2>&1 \
+		| perl tools/logger.pl > "release-make.log"
+}
+maybe_build() { [ -f "src/openocd" ] || do_build; }
+do_build_clean() { [ -f Makefile ] && make maintainer-clean >/dev/null; }
+
+do_changelog() {
+	echo "Creating ChangeLog..."
+	local CMD=tools/git2cl/git2cl
+	eval ${CMD} ${OPTS} > ChangeLog
+}
+do_changelog_clean() {
+	git checkout ChangeLog
+}
+
+do_package() {
+	do_changelog
+	maybe_build
+	echo "Building distribution packages..."
+	make ${MAKE_OPTS} distcheck 2>&1 | perl tools/logger.pl > "release-pkg.log"
+}
+maybe_package() { [ -f "${PACKAGE_RELEASE}.zip" ] || do_package; }
+do_package_clean() {
+	for EXT in tar.gz tar.bz2 zip; do
+		rm -v -f *.${EXT}
+	done
+}
+
+do_stage() {
+	maybe_package
+	echo "Staging package archives:"
+	mkdir -p archives
+	for EXT in tar.gz tar.bz2 zip; do
+		local FILE="${PACKAGE_RELEASE}.${EXT}"
+		# create archive signatures
+		for HASH in md5 sha1; do
+			echo "sign: ${FILE}.${HASH}"
+			${HASH}sum "${FILE}" > "archives/${FILE}.${HASH}"
+		done
+		# save archive
+		mv -v "${FILE}" archives/
+	done
+	cp -a NEWS archives/
+	cp -a ChangeLog archives/
+}
+do_stage_clean() { rm -v -f -r archives; }
+
+do_clean() {
+	do_build_clean
+	do_package_clean
+	do_changelog_clean
+	rm -v -f release-*.log
+}
+do_clean_all() {
+	do_clean
+	do_stage_clean
+}
+
+do_version_commit() {
+	[ "$*" ] || die "usage: $0 commit <message>"
+	git add configure.in || die "error: no version changes to commit"
+	git commit -q -m "$*" configure.in
+}
+
+do_version_finalize() {
+	echo "The ${PACKAGE_NAME} ${RELEASE_VERSION} release."
+	echo
+	${VERSION_SH} tag remove dev
+	[ -z "${RELEASE_FINAL}" ] || ${VERSION_SH} bump final rc
+}
+has_dev_tag() {
+	[ "${PACKAGE_VERSION/dev/}" != "${PACKAGE_VERSION}" ]
+}
+do_release_step_branch() {
+	git checkout -b "v${RELEASE_VERSION}-release"
+}
+
+do_release_step_tag() {
+	do_version_commit "$(do_version_finalize)"
+	package_info_load
+	[ "${PACKAGE_VERSION/dev/}" = "${PACKAGE_VERSION}" ] || \
+		die "'${PACKAGE_NAME}-${PACKAGE_VERSION}' should not be tagged"
+	local MSG="The ${PACKAGE_STRING} release."
+	git tag -m "${MSG}" "v${PACKAGE_VERSION}"
+}
+
+do_bump_version() {
+	echo -n "Bump ${RELEASE_TYPE} "
+	[ -z "${RELEASE_TAG}" ] || echo -n "-${RELEASE_TAG} "
+	echo -n "version and add "
+	[ -z "${RELEASE_START_RC}" ] || echo -n "-rc0"
+	echo "-dev tag."
+	echo
+	${VERSION_SH} bump "${RELEASE_TYPE}" "${RELEASE_TAG}"
+	[ -z "${RELEASE_START_RC}" ] || ${VERSION_SH} bump tag rc
+	${VERSION_SH} tag add dev
+}
+do_release_step_bump() {
+	# bump the version number
+	do_version_commit "$(do_bump_version)"
+}
+
+do_release_step_news_msg() {
+	cat <<MSG
+Archive and recreate NEWS file.
+
+Archive released NEWS file as NEWS-${RELEASE_VERSION}.
+Create new NEWS file from release script template.
+MSG
+}
+do_release_step_news() {
+	# only archive the NEWS file for major/minor releases
+	[ "${RELEASE_TYPE}" = "major" -o "${RELEASE_TYPE}" = "minor" ] || \
+		return 0
+	# archive NEWS and create new one from template
+	git mv "NEWS" "NEWS-${RELEASE_VERSION}"
+
+	cat >NEWS <<NEWS
+This file should include items worth mentioning in the
+OpenOCD ${NEXT_RELEASE_VERSION} source archive release.
+
+The following areas of OpenOCD functionality changed in this release:
+
+JTAG Layer:
+Target Layer:
+Flash Layer:
+Board, Target, and Interface Configuration Scripts:
+Documentation:
+Build and Release:
+
+For more details about what has changed since the last release,
+see the ChangeLog associated with this source archive.  For older NEWS,
+see the NEWS files associated with each release (i.e. NEWS-<version>).
+
+For more information about contributing test reports, bug fixes, or new
+features and device support, please read the new Developer Manual (or
+the BUGS and PATCHES files in the source archive).
+NEWS
+	git add NEWS
+
+	local MSG="$(do_release_step_news_msg)"
+	git commit -q -m "${MSG}" NEWS "NEWS-${RELEASE_VERSION}"
+}
+
+do_release_step_package() {
+	[ -z "${RELEASE_FAST}" ] || return 0
+
+	git checkout -q "v${RELEASE_VERSION}"
+	do_stage
+	do_clean
+}
+
+do_release_step_rebranch() {
+	# return to the new development head
+	local OLD_BRANCH="v${RELEASE_VERSION}-release"
+	git checkout "${OLD_BRANCH}"
+
+	# create new branch with new version information
+	package_info_load
+	git checkout -b "v${PACKAGE_VERSION}"
+	git branch -d "${OLD_BRANCH}"
+}
+
+do_release_step_0() { do_release_step_branch; }
+do_release_step_1() { do_release_step_tag; }
+do_release_step_2() { do_release_step_bump; }
+do_release_step_3() { do_release_step_news; }
+do_release_step_4() { do_release_step_package; }
+do_release_step_5() { do_release_step_rebranch; }
+
+do_release_setup() {
+	echo "Starting $CMD for ${RELEASE_VERSION}..."
+	[ "${RELEASE_TYPE}" ] || \
+		die "The --next release type must be provided.  See --help."
+}
+
+do_release_check() {
+	[ -z "${RELEASE_FAST}" ] || return 0
+	echo "Are you sure you want to ${CMD} '${PACKAGE_RELEASE}', "
+	echo -n "   to start a new  ${RELEASE_TYPE}  development cycle? (y/N) "
+	read ANSWER
+	if [ "${ANSWER}" != 'y' ]; then
+		echo "Live release aborted!"
+		exit 0
+	fi
+	do_countdown "Starting live release"
+}
+do_countdown() {
+	echo -n "$1 in "
+	for i in $(seq 5 -1 1); do
+		echo -n "$i, "
+		sleep 1
+	done
+	echo "go!"
+}
+
+do_branch() {
+	do_release_setup
+	local i=
+	for i in 0 2 5; do
+		"do_release_step_${i}"
+	done
+}
+
+do_release() {
+	local CMD='release'
+	do_release_setup
+	do_release_check
+	local i=
+	for i in $(seq 0 5); do
+		"do_release_step_${i}"
+	done
+}
+do_all() { do_release "$@"; }
+
+do_reset() {
+	maybe_bootstrap
+	maybe_configure
+	do_clean_all
+	git checkout configure.in
+}
+
+LONGOPTS="fast,final,start-rc,next-tag:,next:,help"
+OPTIONS=$(getopt -o 'V,n:' --long "${LONGOPTS}" -n $0 -- "$@")
+if [ $? != 0 ] ; then echo "Terminating..." >&2 ; exit 1 ; fi
+eval set -- "${OPTIONS}"
+while true; do
+	case "$1" in
+	--fast)
+		RELEASE_FAST=yes
+		shift
+		;;
+	--final)
+		RELEASE_FINAL=yes
+		shift
+		;;
+	--start-rc)
+		RELEASE_START_RC=yes
+		shift
+		;;
+	-n|--next)
+		export RELEASE_TYPE="$2"
+		shift 2
+		;;
+	--next-tag)
+		export RELEASE_TAG="$2"
+		shift 2
+		;;
+	-V)
+		exec $0 info
+		;;
+	--)
+		shift
+		break
+		;;
+	--help)
+		usage
+		shift
+		;;
+	*)
+		echo "Internal error"
+		exit 1
+		;;
+	esac
+done
+
+case "${RELEASE_TYPE}" in
+major|minor|micro|rc)
+	;;
+tag)
+	[ "${RELEASE_TAG}" ] || RELEASE_TAG="$(id -u -n)"
+	;;
+'')
+	;;
+*)
+	die "Unknown release type '${RELEASE_TYPE}'"
+	;;
+esac
+
+CMD=$1
+[ "${CMD}" ] || usage
+shift
+
+ACTION_CMDS="bootstrap|configure|build|changelog|package|stage|clean"
+MISC_CMDS="all|info|release|branch|reset|help|usage"
+CLEAN_CMDS="build_clean|changelog_clean|package_clean|stage_clean|clean_all"
+CMDS="|${ACTION_CMDS}|${CLEAN_CMDS}|${MISC_CMDS}|"
+is_command() { echo "${CMDS}" | grep "|$1|" >/dev/null; }
+
+package_info_load
+if is_command "${CMD}"; then
+	"do_${CMD}" "$@"
+	echo "Done with '${CMD}'." >&2
+else
+	echo "error: unknown command: '${CMD}'"
+	usage
+fi
-- 
2.11.4.GIT


From 0b882951b7f2d2bb25a2d78db4bb84134a86216c Mon Sep 17 00:00:00 2001
From: Zachary T Welch <zw@superlucidity.net>
Date: Thu, 22 Oct 2009 03:04:08 -0700
Subject: [PATCH 11/16] Add script to test the release process.

Runs the release.sh script in a freshly cloned repository, charting
one hypothetical future of OpenOCD's lineage.
---
 tools/release/test.sh | 121 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 121 insertions(+)
 create mode 100755 tools/release/test.sh

diff --git a/tools/release/test.sh b/tools/release/test.sh
new file mode 100755
index 000000000..1f321e0f5
--- /dev/null
+++ b/tools/release/test.sh
@@ -0,0 +1,121 @@
+#!/bin/sh -e
+
+SRC="$1"
+if [ "${SRC}" ]; then
+	shift
+else
+	SRC="${0%%/*}"
+fi
+if [ ! -d "${SRC}/.git" ]; then
+	echo "'${SRC}' is not a git repository"
+	exit 1
+fi
+
+DST="$1"
+[ "${DST}" ] || DST="release-${SRC}"
+
+export RELEASE_FAST=yes
+
+cat <<EOF
+Starting test release clone process:
+   from: '${SRC}'
+     to: '${DST}'
+This will destroy any contents in '${DST}'.
+EOF
+echo -n "Press Control-C to abort in "
+for i in $(seq 5 -1 1); do echo -n "$i "; sleep 1; done
+echo "go!"
+
+rm -rf "${DST}"
+git clone "${SRC}" "${DST}"
+
+cd "${DST}"
+#     TAG+RELEASE     NEW BRANCH (w/ -dev)
+# 	0.3.0 		0.4.0-rc0
+tools/release.sh release --next='minor' --start-rc
+
+git checkout -q "v0.3.0"
+# 	<none>		0.3.1
+tools/release.sh branch --next='micro'
+# 	0.3.1 		0.3.2
+tools/release.sh release --next='micro'
+
+git checkout "v0.4.0-rc0-dev"
+# 	0.4.0-rc0	0.4.0-rc1
+tools/release.sh release --next='rc'
+# 	0.4.0		1.0.0-rc0
+tools/release.sh release --next='major' --final --start-rc
+
+git checkout -q "v0.4.0"
+# 	<none>		0.4.1
+tools/release.sh branch --next='micro'
+# 	0.4.1 		0.4.2
+tools/release.sh release --next='micro'
+
+git checkout "v1.0.0-rc0-dev"
+# 	1.0.0-rc0	1.0.0-rc1
+tools/release.sh release --next='rc'
+# 	1.0.0		1.1.0-rc0
+tools/release.sh release --next='minor' --final --start-rc
+
+git checkout -q "v1.0.0"
+# 	<none>		1.0.1
+tools/release.sh branch --next='micro'
+# 	1.0.1 		1.0.2
+tools/release.sh release --next='micro'
+
+git checkout "v1.1.0-rc0-dev"
+# 	1.1.0-rc0	1.1.0-rc1
+tools/release.sh release --next='rc'
+# 	1.1.0		1.2.0
+tools/release.sh release --next='minor' --final --start-rc
+
+git checkout -q "v1.0.0"
+tools/release.sh branch --next='major' --start-rc
+
+# 	<none>		2.0.0-rc0
+git checkout "v2.0.0-rc0-dev"
+# 	2.0.0-rc0	2.0.0-rc1
+tools/release.sh release --next='rc'
+# 	2.0.0-rc1	2.0.0-rc2
+tools/release.sh release --next='rc'
+# 	2.0.0		2.1.0-rc0
+tools/release.sh release --next='minor' --final --start-rc
+
+git checkout -q "v1.1.0"
+# 	<none>		1.1.1
+tools/release.sh branch --next='micro'
+# 	1.1.1 		1.1.2
+tools/release.sh release --next='micro'
+
+git checkout -q "v2.0.0"
+# 	<none>		2.0.0
+tools/release.sh branch --next='micro'
+# 	2.0.1		2.0.2
+tools/release.sh release --next='micro'
+
+git checkout "v1.2.0-rc0-dev"
+# 	1.2.0-rc0	1.2.0-rc1
+tools/release.sh release --next='rc'
+# 	1.2.0		1.3.0-rc0
+tools/release.sh release --next='micro' --final
+
+git checkout "v2.1.0-rc0-dev"
+# 	2.1.0-rc0	2.1.0-rc1
+tools/release.sh release --next='rc'
+# 	2.1.0-rc1	2.1.0-rc2
+tools/release.sh release --next='rc'
+# 	2.1.0		2.2.0-rc0
+tools/release.sh release --next='minor' --final --start-rc
+
+git checkout -q "v2.1.0"
+# 	<none>		2.1.1
+tools/release.sh branch --next='micro'
+# 	2.1.1		2.1.2
+tools/release.sh release --next='micro'
+
+git checkout "v2.2.0-rc0-dev"
+# 	2.2.0-rc0	2.2.0-rc1
+tools/release.sh release --next='rc'
+
+gitk --all
-- 
2.11.4.GIT


From 053a763aa61a801ac2259ee87aaed4cd140557d9 Mon Sep 17 00:00:00 2001
From: =?utf8?q?Franck=20H=C3=89R=C3=89SON?= <franck.hereson@secad.fr>
Date: Wed, 28 Oct 2009 10:24:55 -0700
Subject: [PATCH 12/16] bugfix: stack corruption loading IHex images

The Hex parser uses a fixed number of sections.  When the
number of sections in the file is greater than that, the
stack get corrupted and a CHECKSUM ERROR is detected
which is very confusing.

This checks the number of sections read, and increases
IMAGE_MAX_SECTIONS so it works on my file.

Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
---
 src/target/image.c | 21 +++++++++++++++++++++
 src/target/image.h |  2 +-
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/target/image.c b/src/target/image.c
index d51e8743b..b9e641b33 100644
--- a/src/target/image.c
+++ b/src/target/image.c
@@ -8,6 +8,9 @@
  *   Copyright (C) 2008 by Spencer Oliver                                  *
  *   spen@spen-soft.co.uk                                                  *
  *                                                                         *
+ *   Copyright (C) 2009 by Franck Hereson                                  *
+ *   franck.hereson@secad.fr                                               *
+ *                                                                         *
  *   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     *
@@ -196,6 +199,12 @@ static int image_ihex_buffer_complete(image_t *image)
 				if (section[image->num_sections].size != 0)
 				{
 					image->num_sections++;
+					if (image->num_sections >= IMAGE_MAX_SECTIONS)
+					{
+						/* too many sections */
+						LOG_ERROR("Too many sections found in IHEX file");
+						return ERROR_IMAGE_FORMAT_ERROR;
+					}
 					section[image->num_sections].size = 0x0;
 					section[image->num_sections].flags = 0;
 					section[image->num_sections].private = &ihex->buffer[cooked_bytes];
@@ -252,6 +261,12 @@ static int image_ihex_buffer_complete(image_t *image)
 				if (section[image->num_sections].size != 0)
 				{
 					image->num_sections++;
+					if (image->num_sections >= IMAGE_MAX_SECTIONS)
+					{
+						/* too many sections */
+						LOG_ERROR("Too many sections found in IHEX file");
+						return ERROR_IMAGE_FORMAT_ERROR;
+					}
 					section[image->num_sections].size = 0x0;
 					section[image->num_sections].flags = 0;
 					section[image->num_sections].private = &ihex->buffer[cooked_bytes];
@@ -292,6 +307,12 @@ static int image_ihex_buffer_complete(image_t *image)
 				if (section[image->num_sections].size != 0)
 				{
 					image->num_sections++;
+					if (image->num_sections >= IMAGE_MAX_SECTIONS)
+					{
+						/* too many sections */
+						LOG_ERROR("Too many sections found in IHEX file");
+						return ERROR_IMAGE_FORMAT_ERROR;
+					}
 					section[image->num_sections].size = 0x0;
 					section[image->num_sections].flags = 0;
 					section[image->num_sections].private = &ihex->buffer[cooked_bytes];
diff --git a/src/target/image.h b/src/target/image.h
index d90b544a4..551524e30 100644
--- a/src/target/image.h
+++ b/src/target/image.h
@@ -33,7 +33,7 @@
 #endif
 
 #define IMAGE_MAX_ERROR_STRING		(256)
-#define IMAGE_MAX_SECTIONS			(128)
+#define IMAGE_MAX_SECTIONS			(512)
 
 #define IMAGE_MEMORY_CACHE_SIZE		(2048)
 
-- 
2.11.4.GIT


From 4d17541a2c46fe75fbdcdfdaa647c4a4327c6561 Mon Sep 17 00:00:00 2001
From: David Brownell <dbrownell@users.sourceforge.net>
Date: Wed, 28 Oct 2009 10:42:23 -0700
Subject: [PATCH 13/16] ARM926: remove exports and forward decls

Unneeded exports cause confusion about the module interfaces.
Only the Feroceon code builds on this, so only routines it
reuses should be public..  Make most remaining functions
static, and fix some of the line-too-long issues.

The forward decls are just code clutter; move their references
later, after the normal declarations.  Turns out we don't need
even one forward declaration in this file.

Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
---
 src/target/arm926ejs.c | 249 +++++++++++++++++++++++++------------------------
 1 file changed, 127 insertions(+), 122 deletions(-)

diff --git a/src/target/arm926ejs.c b/src/target/arm926ejs.c
index ef9a49413..53f798099 100644
--- a/src/target/arm926ejs.c
+++ b/src/target/arm926ejs.c
@@ -33,94 +33,8 @@
 #define _DEBUG_INSTRUCTION_EXECUTION_
 #endif
 
-/* cli handling */
-int arm926ejs_handle_cp15_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int arm926ejs_handle_cache_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-
-int arm926ejs_handle_read_cache_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int arm926ejs_handle_read_mmu_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-
-/* forward declarations */
-int arm926ejs_target_create(struct target_s *target, Jim_Interp *interp);
-int arm926ejs_init_target(struct command_context_s *cmd_ctx, struct target_s *target);
-int arm926ejs_quit(void);
-
-int arm926ejs_read_phys_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
-int arm926ejs_write_phys_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
-
-static int arm926ejs_virt2phys(struct target_s *target, uint32_t virtual, uint32_t *physical);
-static int arm926ejs_mmu(struct target_s *target, int *enabled);
-
-int arm926ejs_cp15_read(target_t *target, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value);
-int arm926ejs_cp15_write(target_t *target, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value);
-
-static int arm926ejs_mrc(target_t *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value)
-{
-	if (cpnum!=15)
-	{
-		LOG_ERROR("Only cp15 is supported");
-		return ERROR_FAIL;
-	}
-	return arm926ejs_cp15_read(target, op1, op2, CRn, CRm, value);
-}
-
-static int arm926ejs_mcr(target_t *target, int cpnum, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value)
-{
-	if (cpnum!=15)
-	{
-		LOG_ERROR("Only cp15 is supported");
-		return ERROR_FAIL;
-	}
-	return arm926ejs_cp15_write(target, op1, op2, CRn, CRm, value);
-}
-
-target_type_t arm926ejs_target =
-{
-	.name = "arm926ejs",
-
-	.poll = arm7_9_poll,
-	.arch_state = arm926ejs_arch_state,
-
-	.target_request_data = arm7_9_target_request_data,
-
-	.halt = arm7_9_halt,
-	.resume = arm7_9_resume,
-	.step = arm7_9_step,
-
-	.assert_reset = arm7_9_assert_reset,
-	.deassert_reset = arm7_9_deassert_reset,
-	.soft_reset_halt = arm926ejs_soft_reset_halt,
-
-	.get_gdb_reg_list = armv4_5_get_gdb_reg_list,
-
-	.read_memory = arm7_9_read_memory,
-	.write_memory = arm926ejs_write_memory,
-	.bulk_write_memory = arm7_9_bulk_write_memory,
-	.checksum_memory = arm7_9_checksum_memory,
-	.blank_check_memory = arm7_9_blank_check_memory,
-
-	.run_algorithm = armv4_5_run_algorithm,
-
-	.add_breakpoint = arm7_9_add_breakpoint,
-	.remove_breakpoint = arm7_9_remove_breakpoint,
-	.add_watchpoint = arm7_9_add_watchpoint,
-	.remove_watchpoint = arm7_9_remove_watchpoint,
-
-	.register_commands = arm926ejs_register_commands,
-	.target_create = arm926ejs_target_create,
-	.init_target = arm926ejs_init_target,
-	.examine = arm9tdmi_examine,
-	.quit = arm926ejs_quit,
-	.virt2phys = arm926ejs_virt2phys,
-	.mmu = arm926ejs_mmu,
-
-	.read_phys_memory = arm926ejs_read_phys_memory,
-	.write_phys_memory = arm926ejs_write_phys_memory,
-	.mrc = arm926ejs_mrc,
-	.mcr = arm926ejs_mcr,
-};
-
-int arm926ejs_catch_broken_irscan(uint8_t *captured, void *priv, scan_field_t *field)
+static int arm926ejs_catch_broken_irscan(uint8_t *captured, void *priv,
+		scan_field_t *field)
 {
 	/* FIX!!!! this code should be reenabled. For now it does not check
 	 * the queue...*/
@@ -144,7 +58,8 @@ int arm926ejs_catch_broken_irscan(uint8_t *captured, void *priv, scan_field_t *f
 
 #define ARM926EJS_CP15_ADDR(opcode_1, opcode_2, CRn, CRm) ((opcode_1 << 11) | (opcode_2 << 8) | (CRn << 4) | (CRm << 0))
 
-int arm926ejs_cp15_read(target_t *target, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value)
+static int arm926ejs_cp15_read(target_t *target, uint32_t op1, uint32_t op2,
+		uint32_t CRn, uint32_t CRm, uint32_t *value)
 {
 	int retval = ERROR_OK;
 	armv4_5_common_t *armv4_5 = target->arch_info;
@@ -226,7 +141,18 @@ int arm926ejs_cp15_read(target_t *target, uint32_t op1, uint32_t op2, uint32_t C
 	return ERROR_OK;
 }
 
-int arm926ejs_cp15_write(target_t *target, uint32_t op1, uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value)
+static int arm926ejs_mrc(target_t *target, int cpnum, uint32_t op1,
+		uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t *value)
+{
+	if (cpnum != 15) {
+		LOG_ERROR("Only cp15 is supported");
+		return ERROR_FAIL;
+	}
+	return arm926ejs_cp15_read(target, op1, op2, CRn, CRm, value);
+}
+
+static int arm926ejs_cp15_write(target_t *target, uint32_t op1, uint32_t op2,
+		uint32_t CRn, uint32_t CRm, uint32_t value)
 {
 	int retval = ERROR_OK;
 	armv4_5_common_t *armv4_5 = target->arch_info;
@@ -306,6 +232,16 @@ int arm926ejs_cp15_write(target_t *target, uint32_t op1, uint32_t op2, uint32_t
 	return ERROR_OK;
 }
 
+static int arm926ejs_mcr(target_t *target, int cpnum, uint32_t op1,
+		uint32_t op2, uint32_t CRn, uint32_t CRm, uint32_t value)
+{
+	if (cpnum != 15) {
+		LOG_ERROR("Only cp15 is supported");
+		return ERROR_FAIL;
+	}
+	return arm926ejs_cp15_write(target, op1, op2, CRn, CRm, value);
+}
+
 static int arm926ejs_examine_debug_reason(target_t *target)
 {
 	armv4_5_common_t *armv4_5 = target->arch_info;
@@ -410,7 +346,7 @@ static int arm926ejs_examine_debug_reason(target_t *target)
 	return ERROR_OK;
 }
 
-uint32_t arm926ejs_get_ttb(target_t *target)
+static uint32_t arm926ejs_get_ttb(target_t *target)
 {
 	armv4_5_common_t *armv4_5 = target->arch_info;
 	arm7_9_common_t *arm7_9 = armv4_5->arch_info;
@@ -425,7 +361,8 @@ uint32_t arm926ejs_get_ttb(target_t *target)
 	return ttb;
 }
 
-void arm926ejs_disable_mmu_caches(target_t *target, int mmu, int d_u_cache, int i_cache)
+static void arm926ejs_disable_mmu_caches(target_t *target, int mmu,
+		int d_u_cache, int i_cache)
 {
 	armv4_5_common_t *armv4_5 = target->arch_info;
 	arm7_9_common_t *arm7_9 = armv4_5->arch_info;
@@ -476,7 +413,8 @@ void arm926ejs_disable_mmu_caches(target_t *target, int mmu, int d_u_cache, int
 	arm926ejs->write_cp15(target, 0, 0, 1, 0, cp15_control);
 }
 
-void arm926ejs_enable_mmu_caches(target_t *target, int mmu, int d_u_cache, int i_cache)
+static void arm926ejs_enable_mmu_caches(target_t *target, int mmu,
+		int d_u_cache, int i_cache)
 {
 	armv4_5_common_t *armv4_5 = target->arch_info;
 	arm7_9_common_t *arm7_9 = armv4_5->arch_info;
@@ -500,7 +438,7 @@ void arm926ejs_enable_mmu_caches(target_t *target, int mmu, int d_u_cache, int i
 	arm926ejs->write_cp15(target, 0, 0, 1, 0, cp15_control);
 }
 
-void arm926ejs_post_debug_entry(target_t *target)
+static void arm926ejs_post_debug_entry(target_t *target)
 {
 	armv4_5_common_t *armv4_5 = target->arch_info;
 	arm7_9_common_t *arm7_9 = armv4_5->arch_info;
@@ -542,7 +480,7 @@ void arm926ejs_post_debug_entry(target_t *target)
 	arm926ejs->write_cp15(target, 7, 0, 15, 0, cache_dbg_ctrl);
 }
 
-void arm926ejs_pre_restore_context(target_t *target)
+static void arm926ejs_pre_restore_context(target_t *target)
 {
 	armv4_5_common_t *armv4_5 = target->arch_info;
 	arm7_9_common_t *arm7_9 = armv4_5->arch_info;
@@ -563,7 +501,11 @@ void arm926ejs_pre_restore_context(target_t *target)
 	arm926ejs->write_cp15(target, 7, 0, 15, 0, cache_dbg_ctrl);
 }
 
-int arm926ejs_get_arch_pointers(target_t *target, armv4_5_common_t **armv4_5_p, arm7_9_common_t **arm7_9_p, arm9tdmi_common_t **arm9tdmi_p, arm926ejs_common_t **arm926ejs_p)
+static int arm926ejs_get_arch_pointers(target_t *target,
+		armv4_5_common_t **armv4_5_p,
+		arm7_9_common_t **arm7_9_p,
+		arm9tdmi_common_t **arm9tdmi_p,
+		arm926ejs_common_t **arm926ejs_p)
 {
 	armv4_5_common_t *armv4_5 = target->arch_info;
 	arm7_9_common_t *arm7_9;
@@ -702,7 +644,8 @@ int arm926ejs_soft_reset_halt(struct target_s *target)
 	return target_call_event_callbacks(target, TARGET_EVENT_HALTED);
 }
 
-int arm926ejs_write_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+int arm926ejs_write_memory(struct target_s *target, uint32_t address,
+		uint32_t size, uint32_t count, uint8_t *buffer)
 {
 	int retval;
 	armv4_5_common_t *armv4_5 = target->arch_info;
@@ -765,7 +708,9 @@ int arm926ejs_write_memory(struct target_s *target, uint32_t address, uint32_t s
 	return retval;
 }
 
-int arm926ejs_write_phys_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+static int arm926ejs_write_phys_memory(struct target_s *target,
+		uint32_t address, uint32_t size,
+		uint32_t count, uint8_t *buffer)
 {
 	armv4_5_common_t *armv4_5 = target->arch_info;
 	arm7_9_common_t *arm7_9 = armv4_5->arch_info;
@@ -775,7 +720,9 @@ int arm926ejs_write_phys_memory(struct target_s *target, uint32_t address, uint3
 	return armv4_5_mmu_write_physical(target, &arm926ejs->armv4_5_mmu, address, size, count, buffer);
 }
 
-int arm926ejs_read_phys_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+static int arm926ejs_read_phys_memory(struct target_s *target,
+		uint32_t address, uint32_t size,
+		uint32_t count, uint8_t *buffer)
 {
 	armv4_5_common_t *armv4_5 = target->arch_info;
 	arm7_9_common_t *arm7_9 = armv4_5->arch_info;
@@ -785,19 +732,21 @@ int arm926ejs_read_phys_memory(struct target_s *target, uint32_t address, uint32
 	return armv4_5_mmu_read_physical(target, &arm926ejs->armv4_5_mmu, address, size, count, buffer);
 }
 
-int arm926ejs_init_target(struct command_context_s *cmd_ctx, struct target_s *target)
+static int arm926ejs_init_target(struct command_context_s *cmd_ctx,
+		struct target_s *target)
 {
 	arm9tdmi_init_target(cmd_ctx, target);
 
 	return ERROR_OK;
 }
 
-int arm926ejs_quit(void)
+static int arm926ejs_quit(void)
 {
 	return ERROR_OK;
 }
 
-int arm926ejs_init_arch_info(target_t *target, arm926ejs_common_t *arm926ejs, jtag_tap_t *tap)
+int arm926ejs_init_arch_info(target_t *target, arm926ejs_common_t *arm926ejs,
+		jtag_tap_t *tap)
 {
 	arm9tdmi_common_t *arm9tdmi = &arm926ejs->arm9tdmi_common;
 	arm7_9_common_t *arm7_9 = &arm9tdmi->arm7_9_common;
@@ -834,7 +783,7 @@ int arm926ejs_init_arch_info(target_t *target, arm926ejs_common_t *arm926ejs, jt
 	return ERROR_OK;
 }
 
-int arm926ejs_target_create(struct target_s *target, Jim_Interp *interp)
+static int arm926ejs_target_create(struct target_s *target, Jim_Interp *interp)
 {
 	arm926ejs_common_t *arm926ejs = calloc(1,sizeof(arm926ejs_common_t));
 
@@ -843,24 +792,8 @@ int arm926ejs_target_create(struct target_s *target, Jim_Interp *interp)
 	return ERROR_OK;
 }
 
-int arm926ejs_register_commands(struct command_context_s *cmd_ctx)
-{
-	int retval;
-	command_t *arm926ejs_cmd;
-
-
-	retval = arm9tdmi_register_commands(cmd_ctx);
-
-	arm926ejs_cmd = register_command(cmd_ctx, NULL, "arm926ejs", NULL, COMMAND_ANY, "arm926ejs specific commands");
-
-	register_command(cmd_ctx, arm926ejs_cmd, "cp15", arm926ejs_handle_cp15_command, COMMAND_EXEC, "display/modify cp15 register <opcode_1> <opcode_2> <CRn> <CRm> [value]");
-
-	register_command(cmd_ctx, arm926ejs_cmd, "cache_info", arm926ejs_handle_cache_info_command, COMMAND_EXEC, "display information about target caches");
-
-	return retval;
-}
-
-int arm926ejs_handle_cp15_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int arm926ejs_handle_cp15_command(struct command_context_s *cmd_ctx,
+		char *cmd, char **args, int argc)
 {
 	int retval;
 	target_t *target = get_current_target(cmd_ctx);
@@ -925,7 +858,9 @@ int arm926ejs_handle_cp15_command(struct command_context_s *cmd_ctx, char *cmd,
 	return ERROR_OK;
 }
 
-int arm926ejs_handle_cache_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int
+arm926ejs_handle_cache_info_command(struct command_context_s *cmd_ctx,
+		char *cmd, char **args, int argc)
 {
 	target_t *target = get_current_target(cmd_ctx);
 	armv4_5_common_t *armv4_5;
@@ -981,3 +916,73 @@ static int arm926ejs_mmu(struct target_s *target, int *enabled)
 	*enabled = arm926ejs->armv4_5_mmu.mmu_enabled;
 	return ERROR_OK;
 }
+
+int arm926ejs_register_commands(struct command_context_s *cmd_ctx)
+{
+	int retval;
+	command_t *arm926ejs_cmd;
+
+	retval = arm9tdmi_register_commands(cmd_ctx);
+
+	arm926ejs_cmd = register_command(cmd_ctx, NULL, "arm926ejs",
+		NULL, COMMAND_ANY,
+		"arm926ejs specific commands");
+
+	register_command(cmd_ctx, arm926ejs_cmd, "cp15",
+		arm926ejs_handle_cp15_command, COMMAND_EXEC,
+		"display/modify cp15 register "
+		"<opcode_1> <opcode_2> <CRn> <CRm> [value]");
+
+	register_command(cmd_ctx, arm926ejs_cmd, "cache_info",
+		arm926ejs_handle_cache_info_command, COMMAND_EXEC,
+		"display information about target caches");
+
+	return retval;
+}
+
+target_type_t arm926ejs_target =
+{
+	.name = "arm926ejs",
+
+	.poll = arm7_9_poll,
+	.arch_state = arm926ejs_arch_state,
+
+	.target_request_data = arm7_9_target_request_data,
+
+	.halt = arm7_9_halt,
+	.resume = arm7_9_resume,
+	.step = arm7_9_step,
+
+	.assert_reset = arm7_9_assert_reset,
+	.deassert_reset = arm7_9_deassert_reset,
+	.soft_reset_halt = arm926ejs_soft_reset_halt,
+
+	.get_gdb_reg_list = armv4_5_get_gdb_reg_list,
+
+	.read_memory = arm7_9_read_memory,
+	.write_memory = arm926ejs_write_memory,
+	.bulk_write_memory = arm7_9_bulk_write_memory,
+	.checksum_memory = arm7_9_checksum_memory,
+	.blank_check_memory = arm7_9_blank_check_memory,
+
+	.run_algorithm = armv4_5_run_algorithm,
+
+	.add_breakpoint = arm7_9_add_breakpoint,
+	.remove_breakpoint = arm7_9_remove_breakpoint,
+	.add_watchpoint = arm7_9_add_watchpoint,
+	.remove_watchpoint = arm7_9_remove_watchpoint,
+
+	.register_commands = arm926ejs_register_commands,
+	.target_create = arm926ejs_target_create,
+	.init_target = arm926ejs_init_target,
+	.examine = arm9tdmi_examine,
+	.quit = arm926ejs_quit,
+	.virt2phys = arm926ejs_virt2phys,
+	.mmu = arm926ejs_mmu,
+
+	.read_phys_memory = arm926ejs_read_phys_memory,
+	.write_phys_memory = arm926ejs_write_phys_memory,
+	.mrc = arm926ejs_mrc,
+	.mcr = arm926ejs_mcr,
+};
+
-- 
2.11.4.GIT


From ce88e8adf7de87b0f2e5904c1f620e47774a0458 Mon Sep 17 00:00:00 2001
From: David Brownell <dbrownell@users.sourceforge.net>
Date: Wed, 28 Oct 2009 10:53:11 -0700
Subject: [PATCH 14/16] Cortex-M3: remove exports and forward decls

Unneeded exports cause confusion about the module interfaces.
Make most functions static, and fix some line-too-long issues.
Delete some now-obviously-unused code.

The forward decls are just code clutter; move their references
later, after the normal declarations.  (Or vice versa.)

Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
---
 src/target/cortex_m3.c | 305 +++++++++++++++++++++++--------------------------
 src/target/cortex_m3.h |  28 -----
 2 files changed, 144 insertions(+), 189 deletions(-)

diff --git a/src/target/cortex_m3.c b/src/target/cortex_m3.c
index 5f5287ade..1c59f028a 100644
--- a/src/target/cortex_m3.c
+++ b/src/target/cortex_m3.c
@@ -40,66 +40,20 @@
 #define ARRAY_SIZE(x)	((int)(sizeof(x)/sizeof((x)[0])))
 
 
-/* cli handling */
-int cortex_m3_register_commands(struct command_context_s *cmd_ctx);
-int handle_cortex_m3_mask_interrupts_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-
 /* forward declarations */
-void cortex_m3_enable_breakpoints(struct target_s *target);
-void cortex_m3_enable_watchpoints(struct target_s *target);
-int cortex_m3_target_create(struct target_s *target, Jim_Interp *interp);
-int cortex_m3_init_target(struct command_context_s *cmd_ctx, struct target_s *target);
-int cortex_m3_quit(void);
-int cortex_m3_load_core_reg_u32(target_t *target, enum armv7m_regtype type, uint32_t num, uint32_t *value);
-int cortex_m3_store_core_reg_u32(target_t *target, enum armv7m_regtype type, uint32_t num, uint32_t value);
-int cortex_m3_target_request_data(target_t *target, uint32_t size, uint8_t *buffer);
-int cortex_m3_examine(struct target_s *target);
+static int cortex_m3_set_breakpoint(struct target_s *target, breakpoint_t *breakpoint);
+static int cortex_m3_unset_breakpoint(struct target_s *target, breakpoint_t *breakpoint);
+static void cortex_m3_enable_watchpoints(struct target_s *target);
+static int cortex_m3_store_core_reg_u32(target_t *target,
+		enum armv7m_regtype type, uint32_t num, uint32_t value);
 
 #ifdef ARMV7_GDB_HACKS
 extern uint8_t armv7m_gdb_dummy_cpsr_value[];
 extern reg_t armv7m_gdb_dummy_cpsr_reg;
 #endif
 
-target_type_t cortexm3_target =
-{
-	.name = "cortex_m3",
-
-	.poll = cortex_m3_poll,
-	.arch_state = armv7m_arch_state,
-
-	.target_request_data = cortex_m3_target_request_data,
-
-	.halt = cortex_m3_halt,
-	.resume = cortex_m3_resume,
-	.step = cortex_m3_step,
-
-	.assert_reset = cortex_m3_assert_reset,
-	.deassert_reset = cortex_m3_deassert_reset,
-	.soft_reset_halt = cortex_m3_soft_reset_halt,
-
-	.get_gdb_reg_list = armv7m_get_gdb_reg_list,
-
-	.read_memory = cortex_m3_read_memory,
-	.write_memory = cortex_m3_write_memory,
-	.bulk_write_memory = cortex_m3_bulk_write_memory,
-	.checksum_memory = armv7m_checksum_memory,
-	.blank_check_memory = armv7m_blank_check_memory,
-
-	.run_algorithm = armv7m_run_algorithm,
-
-	.add_breakpoint = cortex_m3_add_breakpoint,
-	.remove_breakpoint = cortex_m3_remove_breakpoint,
-	.add_watchpoint = cortex_m3_add_watchpoint,
-	.remove_watchpoint = cortex_m3_remove_watchpoint,
-
-	.register_commands = cortex_m3_register_commands,
-	.target_create = cortex_m3_target_create,
-	.init_target = cortex_m3_init_target,
-	.examine = cortex_m3_examine,
-	.quit = cortex_m3_quit
-};
-
-int cortexm3_dap_read_coreregister_u32(swjdp_common_t *swjdp, uint32_t *value, int regnum)
+static int cortexm3_dap_read_coreregister_u32(swjdp_common_t *swjdp,
+		uint32_t *value, int regnum)
 {
 	int retval;
 	uint32_t dcrdr;
@@ -129,7 +83,8 @@ int cortexm3_dap_read_coreregister_u32(swjdp_common_t *swjdp, uint32_t *value, i
 	return retval;
 }
 
-int cortexm3_dap_write_coreregister_u32(swjdp_common_t *swjdp, uint32_t value, int regnum)
+static int cortexm3_dap_write_coreregister_u32(swjdp_common_t *swjdp,
+		uint32_t value, int regnum)
 {
 	int retval;
 	uint32_t dcrdr;
@@ -159,7 +114,8 @@ int cortexm3_dap_write_coreregister_u32(swjdp_common_t *swjdp, uint32_t value, i
 	return retval;
 }
 
-int cortex_m3_write_debug_halt_mask(target_t *target, uint32_t mask_on, uint32_t mask_off)
+static int cortex_m3_write_debug_halt_mask(target_t *target,
+		uint32_t mask_on, uint32_t mask_off)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -174,7 +130,7 @@ int cortex_m3_write_debug_halt_mask(target_t *target, uint32_t mask_on, uint32_t
 	return mem_ap_write_atomic_u32(swjdp, DCB_DHCSR, cortex_m3->dcb_dhcsr);
 }
 
-int cortex_m3_clear_halt(target_t *target)
+static int cortex_m3_clear_halt(target_t *target)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -193,7 +149,7 @@ int cortex_m3_clear_halt(target_t *target)
 	return ERROR_OK;
 }
 
-int cortex_m3_single_step_core(target_t *target)
+static int cortex_m3_single_step_core(target_t *target)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -217,39 +173,7 @@ int cortex_m3_single_step_core(target_t *target)
 	return ERROR_OK;
 }
 
-int cortex_m3_exec_opcode(target_t *target,uint32_t opcode, int len /* MODE, r0_invalue, &r0_outvalue */)
-{
-	/* get pointers to arch-specific information */
-	armv7m_common_t *armv7m = target->arch_info;
-	swjdp_common_t *swjdp = &armv7m->swjdp_info;
-	uint32_t savedram;
-	int retvalue;
-
-	mem_ap_read_u32(swjdp, 0x20000000, &savedram);
-	mem_ap_write_u32(swjdp, 0x20000000, opcode);
-	cortexm3_dap_write_coreregister_u32(swjdp, 0x20000000, 15);
-	cortex_m3_single_step_core(target);
-	armv7m->core_cache->reg_list[15].dirty = armv7m->core_cache->reg_list[15].valid;
-	retvalue = mem_ap_write_atomic_u32(swjdp, 0x20000000, savedram);
-
-	return retvalue;
-}
-
-#if 0
-/* Enable interrupts */
-int cortex_m3_cpsie(target_t *target, uint32_t IF)
-{
-	return cortex_m3_exec_opcode(target, ARMV7M_T_CPSIE(IF), 2);
-}
-
-/* Disable interrupts */
-int cortex_m3_cpsid(target_t *target, uint32_t IF)
-{
-	return cortex_m3_exec_opcode(target, ARMV7M_T_CPSID(IF), 2);
-}
-#endif
-
-int cortex_m3_endreset_event(target_t *target)
+static int cortex_m3_endreset_event(target_t *target)
 {
 	int i;
 	uint32_t dcb_demcr;
@@ -307,7 +231,7 @@ int cortex_m3_endreset_event(target_t *target)
 	return ERROR_OK;
 }
 
-int cortex_m3_examine_debug_reason(target_t *target)
+static int cortex_m3_examine_debug_reason(target_t *target)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -336,7 +260,7 @@ int cortex_m3_examine_debug_reason(target_t *target)
 	return ERROR_OK;
 }
 
-int cortex_m3_examine_exception_reason(target_t *target)
+static int cortex_m3_examine_exception_reason(target_t *target)
 {
 	uint32_t shcsr, except_sr, cfsr = -1, except_ar = -1;
 
@@ -386,7 +310,7 @@ int cortex_m3_examine_exception_reason(target_t *target)
 	return ERROR_OK;
 }
 
-int cortex_m3_debug_entry(target_t *target)
+static int cortex_m3_debug_entry(target_t *target)
 {
 	int i;
 	uint32_t xPSR;
@@ -462,7 +386,7 @@ int cortex_m3_debug_entry(target_t *target)
 	return ERROR_OK;
 }
 
-int cortex_m3_poll(target_t *target)
+static int cortex_m3_poll(target_t *target)
 {
 	int retval;
 	enum target_state prev_target_state = target->state;
@@ -539,7 +463,7 @@ int cortex_m3_poll(target_t *target)
 	return ERROR_OK;
 }
 
-int cortex_m3_halt(target_t *target)
+static int cortex_m3_halt(target_t *target)
 {
 	LOG_DEBUG("target->state: %s",
 		target_state_name(target));
@@ -581,7 +505,7 @@ int cortex_m3_halt(target_t *target)
 	return ERROR_OK;
 }
 
-int cortex_m3_soft_reset_halt(struct target_s *target)
+static int cortex_m3_soft_reset_halt(struct target_s *target)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -622,7 +546,21 @@ int cortex_m3_soft_reset_halt(struct target_s *target)
 	return ERROR_OK;
 }
 
-int cortex_m3_resume(struct target_s *target, int current, uint32_t address, int handle_breakpoints, int debug_execution)
+static void cortex_m3_enable_breakpoints(struct target_s *target)
+{
+	breakpoint_t *breakpoint = target->breakpoints;
+
+	/* set any pending breakpoints */
+	while (breakpoint)
+	{
+		if (breakpoint->set == 0)
+			cortex_m3_set_breakpoint(target, breakpoint);
+		breakpoint = breakpoint->next;
+	}
+}
+
+static int cortex_m3_resume(struct target_s *target, int current,
+		uint32_t address, int handle_breakpoints, int debug_execution)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -710,7 +648,8 @@ int cortex_m3_resume(struct target_s *target, int current, uint32_t address, int
 }
 
 /* int irqstepcount = 0; */
-int cortex_m3_step(struct target_s *target, int current, uint32_t address, int handle_breakpoints)
+static int cortex_m3_step(struct target_s *target, int current,
+		uint32_t address, int handle_breakpoints)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -758,7 +697,7 @@ int cortex_m3_step(struct target_s *target, int current, uint32_t address, int h
 	return ERROR_OK;
 }
 
-int cortex_m3_assert_reset(target_t *target)
+static int cortex_m3_assert_reset(target_t *target)
 {
 	armv7m_common_t *armv7m = target->arch_info;
 	cortex_m3_common_t *cortex_m3 = armv7m->arch_info;
@@ -896,7 +835,7 @@ int cortex_m3_assert_reset(target_t *target)
 	return ERROR_OK;
 }
 
-int cortex_m3_deassert_reset(target_t *target)
+static int cortex_m3_deassert_reset(target_t *target)
 {
 	LOG_DEBUG("target->state: %s",
 		target_state_name(target));
@@ -907,20 +846,8 @@ int cortex_m3_deassert_reset(target_t *target)
 	return ERROR_OK;
 }
 
-void cortex_m3_enable_breakpoints(struct target_s *target)
-{
-	breakpoint_t *breakpoint = target->breakpoints;
-
-	/* set any pending breakpoints */
-	while (breakpoint)
-	{
-		if (breakpoint->set == 0)
-			cortex_m3_set_breakpoint(target, breakpoint);
-		breakpoint = breakpoint->next;
-	}
-}
-
-int cortex_m3_set_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
+static int
+cortex_m3_set_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
 {
 	int retval;
 	int fp_num = 0;
@@ -990,7 +917,8 @@ int cortex_m3_set_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
 	return ERROR_OK;
 }
 
-int cortex_m3_unset_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
+static int
+cortex_m3_unset_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
 {
 	int retval;
 	/* get pointers to arch-specific information */
@@ -1046,7 +974,8 @@ int cortex_m3_unset_breakpoint(struct target_s *target, breakpoint_t *breakpoint
 	return ERROR_OK;
 }
 
-int cortex_m3_add_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
+static int
+cortex_m3_add_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -1096,7 +1025,8 @@ int cortex_m3_add_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
 	return ERROR_OK;
 }
 
-int cortex_m3_remove_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
+static int
+cortex_m3_remove_breakpoint(struct target_s *target, breakpoint_t *breakpoint)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -1124,7 +1054,8 @@ int cortex_m3_remove_breakpoint(struct target_s *target, breakpoint_t *breakpoin
 	return ERROR_OK;
 }
 
-int cortex_m3_set_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
+static int
+cortex_m3_set_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
 {
 	int dwt_num = 0;
 	uint32_t mask, temp;
@@ -1180,7 +1111,8 @@ int cortex_m3_set_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
 
 }
 
-int cortex_m3_unset_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
+static int
+cortex_m3_unset_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -1213,7 +1145,8 @@ int cortex_m3_unset_watchpoint(struct target_s *target, watchpoint_t *watchpoint
 	return ERROR_OK;
 }
 
-int cortex_m3_add_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
+static int
+cortex_m3_add_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -1241,7 +1174,8 @@ int cortex_m3_add_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
 	return ERROR_OK;
 }
 
-int cortex_m3_remove_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
+static int
+cortex_m3_remove_watchpoint(struct target_s *target, watchpoint_t *watchpoint)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -1264,7 +1198,7 @@ int cortex_m3_remove_watchpoint(struct target_s *target, watchpoint_t *watchpoin
 	return ERROR_OK;
 }
 
-void cortex_m3_enable_watchpoints(struct target_s *target)
+static void cortex_m3_enable_watchpoints(struct target_s *target)
 {
 	watchpoint_t *watchpoint = target->watchpoints;
 
@@ -1277,7 +1211,8 @@ void cortex_m3_enable_watchpoints(struct target_s *target)
 	}
 }
 
-int cortex_m3_load_core_reg_u32(struct target_s *target, enum armv7m_regtype type, uint32_t num, uint32_t * value)
+static int cortex_m3_load_core_reg_u32(struct target_s *target,
+		enum armv7m_regtype type, uint32_t num, uint32_t * value)
 {
 	int retval;
 	/* get pointers to arch-specific information */
@@ -1340,7 +1275,8 @@ int cortex_m3_load_core_reg_u32(struct target_s *target, enum armv7m_regtype typ
 	return ERROR_OK;
 }
 
-int cortex_m3_store_core_reg_u32(struct target_s *target, enum armv7m_regtype type, uint32_t num, uint32_t value)
+static int cortex_m3_store_core_reg_u32(struct target_s *target,
+		enum armv7m_regtype type, uint32_t num, uint32_t value)
 {
 	int retval;
 	uint32_t reg;
@@ -1418,7 +1354,8 @@ int cortex_m3_store_core_reg_u32(struct target_s *target, enum armv7m_regtype ty
 	return ERROR_OK;
 }
 
-int cortex_m3_read_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+static int cortex_m3_read_memory(struct target_s *target, uint32_t address,
+		uint32_t size, uint32_t count, uint8_t *buffer)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -1450,7 +1387,8 @@ int cortex_m3_read_memory(struct target_s *target, uint32_t address, uint32_t si
 	return retval;
 }
 
-int cortex_m3_write_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+static int cortex_m3_write_memory(struct target_s *target, uint32_t address,
+		uint32_t size, uint32_t count, uint8_t *buffer)
 {
 	/* get pointers to arch-specific information */
 	armv7m_common_t *armv7m = target->arch_info;
@@ -1480,23 +1418,25 @@ int cortex_m3_write_memory(struct target_s *target, uint32_t address, uint32_t s
 	return retval;
 }
 
-int cortex_m3_bulk_write_memory(target_t *target, uint32_t address, uint32_t count, uint8_t *buffer)
+static int cortex_m3_bulk_write_memory(target_t *target, uint32_t address,
+		uint32_t count, uint8_t *buffer)
 {
 	return cortex_m3_write_memory(target, address, 4, count, buffer);
 }
 
-void cortex_m3_build_reg_cache(target_t *target)
+static void cortex_m3_build_reg_cache(target_t *target)
 {
 	armv7m_build_reg_cache(target);
 }
 
-int cortex_m3_init_target(struct command_context_s *cmd_ctx, struct target_s *target)
+static int cortex_m3_init_target(struct command_context_s *cmd_ctx,
+		struct target_s *target)
 {
 	cortex_m3_build_reg_cache(target);
 	return ERROR_OK;
 }
 
-int cortex_m3_examine(struct target_s *target)
+static int cortex_m3_examine(struct target_s *target)
 {
 	int retval;
 	uint32_t cpuid, fpcr, dwtcr, ictr;
@@ -1560,13 +1500,12 @@ int cortex_m3_examine(struct target_s *target)
 	return ERROR_OK;
 }
 
-int cortex_m3_quit(void)
+static int cortex_m3_quit(void)
 {
-
 	return ERROR_OK;
 }
 
-int cortex_m3_dcc_read(swjdp_common_t *swjdp, uint8_t *value, uint8_t *ctrl)
+static int cortex_m3_dcc_read(swjdp_common_t *swjdp, uint8_t *value, uint8_t *ctrl)
 {
 	uint16_t dcrdr;
 
@@ -1587,7 +1526,8 @@ int cortex_m3_dcc_read(swjdp_common_t *swjdp, uint8_t *value, uint8_t *ctrl)
 	return ERROR_OK;
 }
 
-int cortex_m3_target_request_data(target_t *target, uint32_t size, uint8_t *buffer)
+static int cortex_m3_target_request_data(target_t *target,
+		uint32_t size, uint8_t *buffer)
 {
 	armv7m_common_t *armv7m = target->arch_info;
 	swjdp_common_t *swjdp = &armv7m->swjdp_info;
@@ -1604,7 +1544,7 @@ int cortex_m3_target_request_data(target_t *target, uint32_t size, uint8_t *buff
 	return ERROR_OK;
 }
 
-int cortex_m3_handle_target_request(void *priv)
+static int cortex_m3_handle_target_request(void *priv)
 {
 	target_t *target = priv;
 	if (!target_was_examined(target))
@@ -1642,7 +1582,8 @@ int cortex_m3_handle_target_request(void *priv)
 	return ERROR_OK;
 }
 
-int cortex_m3_init_arch_info(target_t *target, cortex_m3_common_t *cortex_m3, jtag_tap_t *tap)
+static int cortex_m3_init_arch_info(target_t *target,
+		cortex_m3_common_t *cortex_m3, jtag_tap_t *tap)
 {
 	int retval;
 	armv7m_common_t *armv7m;
@@ -1689,7 +1630,7 @@ int cortex_m3_init_arch_info(target_t *target, cortex_m3_common_t *cortex_m3, jt
 	return ERROR_OK;
 }
 
-int cortex_m3_target_create(struct target_s *target, Jim_Interp *interp)
+static int cortex_m3_target_create(struct target_s *target, Jim_Interp *interp)
 {
 	cortex_m3_common_t *cortex_m3 = calloc(1,sizeof(cortex_m3_common_t));
 
@@ -1810,30 +1751,9 @@ write:
 	return ERROR_OK;
 }
 
-int cortex_m3_register_commands(struct command_context_s *cmd_ctx)
-{
-	int retval;
-	command_t *cortex_m3_cmd;
-
-	retval = armv7m_register_commands(cmd_ctx);
-
-	cortex_m3_cmd = register_command(cmd_ctx, NULL, "cortex_m3",
-			NULL, COMMAND_ANY, "cortex_m3 specific commands");
-
-	register_command(cmd_ctx, cortex_m3_cmd, "disassemble",
-			handle_cortex_m3_disassemble_command, COMMAND_EXEC,
-			"disassemble Thumb2 instructions <address> [<count>]");
-	register_command(cmd_ctx, cortex_m3_cmd, "maskisr",
-			handle_cortex_m3_mask_interrupts_command, COMMAND_EXEC,
-			"mask cortex_m3 interrupts ['on'|'off']");
-	register_command(cmd_ctx, cortex_m3_cmd, "vector_catch",
-			handle_cortex_m3_vector_catch_command, COMMAND_EXEC,
-			"catch hardware vectors ['all'|'none'|<list>]");
-
-	return retval;
-}
-
-int handle_cortex_m3_mask_interrupts_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int
+handle_cortex_m3_mask_interrupts_command(struct command_context_s *cmd_ctx,
+		char *cmd, char **args, int argc)
 {
 	target_t *target = get_current_target(cmd_ctx);
 	armv7m_common_t *armv7m = target->arch_info;
@@ -1866,3 +1786,66 @@ int handle_cortex_m3_mask_interrupts_command(struct command_context_s *cmd_ctx,
 
 	return ERROR_OK;
 }
+
+static int cortex_m3_register_commands(struct command_context_s *cmd_ctx)
+{
+	int retval;
+	command_t *cortex_m3_cmd;
+
+	retval = armv7m_register_commands(cmd_ctx);
+
+	cortex_m3_cmd = register_command(cmd_ctx, NULL, "cortex_m3",
+			NULL, COMMAND_ANY, "cortex_m3 specific commands");
+
+	register_command(cmd_ctx, cortex_m3_cmd, "disassemble",
+			handle_cortex_m3_disassemble_command, COMMAND_EXEC,
+			"disassemble Thumb2 instructions <address> [<count>]");
+	register_command(cmd_ctx, cortex_m3_cmd, "maskisr",
+			handle_cortex_m3_mask_interrupts_command, COMMAND_EXEC,
+			"mask cortex_m3 interrupts ['on'|'off']");
+	register_command(cmd_ctx, cortex_m3_cmd, "vector_catch",
+			handle_cortex_m3_vector_catch_command, COMMAND_EXEC,
+			"catch hardware vectors ['all'|'none'|<list>]");
+
+	return retval;
+}
+
+target_type_t cortexm3_target =
+{
+	.name = "cortex_m3",
+
+	.poll = cortex_m3_poll,
+	.arch_state = armv7m_arch_state,
+
+	.target_request_data = cortex_m3_target_request_data,
+
+	.halt = cortex_m3_halt,
+	.resume = cortex_m3_resume,
+	.step = cortex_m3_step,
+
+	.assert_reset = cortex_m3_assert_reset,
+	.deassert_reset = cortex_m3_deassert_reset,
+	.soft_reset_halt = cortex_m3_soft_reset_halt,
+
+	.get_gdb_reg_list = armv7m_get_gdb_reg_list,
+
+	.read_memory = cortex_m3_read_memory,
+	.write_memory = cortex_m3_write_memory,
+	.bulk_write_memory = cortex_m3_bulk_write_memory,
+	.checksum_memory = armv7m_checksum_memory,
+	.blank_check_memory = armv7m_blank_check_memory,
+
+	.run_algorithm = armv7m_run_algorithm,
+
+	.add_breakpoint = cortex_m3_add_breakpoint,
+	.remove_breakpoint = cortex_m3_remove_breakpoint,
+	.add_watchpoint = cortex_m3_add_watchpoint,
+	.remove_watchpoint = cortex_m3_remove_watchpoint,
+
+	.register_commands = cortex_m3_register_commands,
+	.target_create = cortex_m3_target_create,
+	.init_target = cortex_m3_init_target,
+	.examine = cortex_m3_examine,
+	.quit = cortex_m3_quit
+};
+
diff --git a/src/target/cortex_m3.h b/src/target/cortex_m3.h
index 4e8cd1116..f4cefa780 100644
--- a/src/target/cortex_m3.h
+++ b/src/target/cortex_m3.h
@@ -29,9 +29,7 @@
 #include "register.h"
 #include "target.h"
 #include "armv7m.h"
-//#include "arm_adi_v5.h"
 
-extern char* cortex_m3_state_strings[];
 
 #define CORTEX_M3_COMMON_MAGIC 0x1A451A45
 
@@ -167,33 +165,7 @@ typedef struct cortex_m3_common_s
 	uint32_t *intsetenable;
 
 	armv7m_common_t armv7m;
-//	swjdp_common_t swjdp_info;
 	void *arch_info;
 } cortex_m3_common_t;
 
-extern void cortex_m3_build_reg_cache(target_t *target);
-
-int cortex_m3_poll(target_t *target);
-int cortex_m3_halt(target_t *target);
-int cortex_m3_resume(struct target_s *target, int current, uint32_t address, int handle_breakpoints, int debug_execution);
-int cortex_m3_step(struct target_s *target, int current, uint32_t address, int handle_breakpoints);
-
-int cortex_m3_assert_reset(target_t *target);
-int cortex_m3_deassert_reset(target_t *target);
-int cortex_m3_soft_reset_halt(struct target_s *target);
-
-int cortex_m3_read_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
-int cortex_m3_write_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
-int cortex_m3_bulk_write_memory(target_t *target, uint32_t address, uint32_t count, uint8_t *buffer);
-
-int cortex_m3_set_breakpoint(struct target_s *target, breakpoint_t *breakpoint);
-int cortex_m3_unset_breakpoint(struct target_s *target, breakpoint_t *breakpoint);
-int cortex_m3_add_breakpoint(struct target_s *target, breakpoint_t *breakpoint);
-int cortex_m3_remove_breakpoint(struct target_s *target, breakpoint_t *breakpoint);
-int cortex_m3_add_watchpoint(struct target_s *target, watchpoint_t *watchpoint);
-int cortex_m3_remove_watchpoint(struct target_s *target, watchpoint_t *watchpoint);
-
-//extern int cortex_m3_register_commands(struct command_context_s *cmd_ctx);
-extern int cortex_m3_init_arch_info(target_t *target, cortex_m3_common_t *cortex_m3, jtag_tap_t *tap);
-
 #endif /* CORTEX_M3_H */
-- 
2.11.4.GIT


From 70f735007d7b0f7ec9d269c4529d9f62c0eb779d Mon Sep 17 00:00:00 2001
From: Zachary T Welch <zw@superlucidity.net>
Date: Wed, 28 Oct 2009 21:23:17 -0700
Subject: [PATCH 15/16] The openocd 0.3.0-rc0 release.

Remove '-dev' version tag: 0.3.0-rc0-dev -> 0.3.0-rc0
---
 configure.in | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/configure.in b/configure.in
index 99f97da48..6cdf2a498 100644
--- a/configure.in
+++ b/configure.in
@@ -1,5 +1,5 @@
 AC_PREREQ(2.60)
-AC_INIT([openocd], [0.3.0-dev],
+AC_INIT([openocd], [0.3.0-rc0],
   [OpenOCD Mailing List <openocd-development@lists.berlios.de>])
 AC_CONFIG_SRCDIR([src/openocd.c])
 
-- 
2.11.4.GIT


From 55d483f6205d3ee4b3eac8180617ab60a33ab089 Mon Sep 17 00:00:00 2001
From: SimonQian <SimonQian@SimonQian.com>
Date: Sat, 31 Oct 2009 16:42:04 +0800
Subject: [PATCH 16/16] first implementation

---
 src/jtag/commands.h     |  21 +++-
 src/jtag/core.c         |  29 ++++-
 src/jtag/driver.c       |  79 ++++++++++++++
 src/jtag/interface.c    |   2 +
 src/jtag/interface.h    |   1 +
 src/jtag/jtag.h         |   7 ++
 src/jtag/minidriver.h   |   6 ++
 src/jtag/tcl.c          |  30 +++++-
 src/jtag/vsllink.c      | 276 ++++++++++++++++++++++++++++++++++++++++++++----
 src/target/arm_adi_v5.c | 217 ++++++++++++++++++++++++++++---------
 src/target/arm_adi_v5.h |   9 ++
 11 files changed, 603 insertions(+), 74 deletions(-)

diff --git a/src/jtag/commands.h b/src/jtag/commands.h
index 5a76a8fb0..e6f4d2aa2 100644
--- a/src/jtag/commands.h
+++ b/src/jtag/commands.h
@@ -108,6 +108,19 @@ typedef struct sleep_command_s
 	uint32_t us;
 } sleep_command_t;
 
+typedef struct swj_seq_command_s
+{
+	uint16_t num_bits;
+	uint8_t* seq;
+} swj_seq_command_t;
+
+typedef struct swj_transact_command_s
+{
+	uint8_t request;
+	uint32_t* data;
+	uint8_t* ack;
+} swj_transact_command_t;
+
 /**
  * Defines a container type that hold a pointer to a JTAG command
  * structure of any defined type.
@@ -121,7 +134,9 @@ typedef union jtag_command_container_u
 	stableclocks_command_t* stableclocks;
 	reset_command_t*        reset;
 	end_state_command_t*    end_state;
-	sleep_command_t* sleep;
+	sleep_command_t*        sleep;
+	swj_seq_command_t*      swj_seq;
+	swj_transact_command_t* swj_transact;
 } jtag_command_container_t;
 
 /**
@@ -135,7 +150,9 @@ enum jtag_command_type {
 	JTAG_RESET        = 4,
 	JTAG_PATHMOVE     = 6,
 	JTAG_SLEEP        = 7,
-	JTAG_STABLECLOCKS = 8
+	JTAG_STABLECLOCKS = 8,
+	SWJ_SEQ           = 9,
+	SWJ_TRANSACT      = 10
 };
 
 typedef struct jtag_command_s
diff --git a/src/jtag/core.c b/src/jtag/core.c
index 8bb45bcdf..3590adba8 100644
--- a/src/jtag/core.c
+++ b/src/jtag/core.c
@@ -39,7 +39,6 @@
 #include <strings.h>
 #endif
 
-
 /// The number of JTAG queue flushes (for profiling and debugging purposes).
 static int jtag_flush_queue_count;
 
@@ -120,6 +119,30 @@ static struct jtag_interface_s *jtag = NULL;
 /* configuration */
 jtag_interface_t *jtag_interface = NULL;
 
+/********SWJ*********/
+void swj_add_sequence(uint8_t *seq, uint16_t len)
+{
+	int retval;
+	retval = interface_swj_add_sequence(seq, len);
+	jtag_set_error(retval);
+}
+
+void swj_add_transact_out(uint8_t apndp, uint8_t rnw, uint8_t reg, uint32_t out_value, uint8_t* ack)
+{
+	int retval;
+	retval = interface_swj_add_transact_out(apndp, rnw, reg, out_value, ack);
+	jtag_set_error(retval);
+}
+
+void swj_add_transact_in(uint8_t apndp, uint8_t rnw, uint8_t reg, uint32_t * in_value, uint8_t* ack)
+{
+	int retval;
+	retval = interface_swj_add_transact_in(apndp, rnw, reg, in_value, ack);
+	jtag_set_error(retval);
+}
+
+/************/
+
 void jtag_set_error(int error)
 {
 	if ((error == ERROR_OK) || (jtag_error != ERROR_OK))
@@ -1499,6 +1522,10 @@ int jtag_init_reset(struct command_context_s *cmd_ctx)
 	if ((retval = jtag_execute_queue()) != ERROR_OK)
 		return retval;
 
+	if (swj_mode)
+	{
+		return ERROR_OK;
+	}
 	/* Check that we can communication on the JTAG chain + eventually we want to
 	 * be able to perform enumeration only after OpenOCD has started
 	 * telnet and GDB server
diff --git a/src/jtag/driver.c b/src/jtag/driver.c
index 3bce5d575..f3eb98a96 100644
--- a/src/jtag/driver.c
+++ b/src/jtag/driver.c
@@ -68,6 +68,85 @@ static void cmd_queue_scan_field_clone(scan_field_t * dst, const scan_field_t *
 	dst->in_value	= src->in_value;
 }
 
+/**
+ * see swj_add_sequence()
+ *
+ */
+int interface_swj_add_sequence(uint8_t * seq, uint16_t len)
+{
+	jtag_command_t * cmd		= cmd_queue_alloc(sizeof(jtag_command_t));
+	swj_seq_command_t * s		= cmd_queue_alloc(sizeof(scan_command_t));
+
+	LOG_DEBUG(" ");
+
+	jtag_queue_command(cmd);
+	cmd->type				= SWJ_SEQ;
+	cmd->cmd.swj_seq		= s;
+	s->num_bits				= len;
+	s->seq					= buf_cpy(seq, cmd_queue_alloc(CEIL(len, 8)), len);
+
+	return ERROR_OK;
+}
+
+/**
+ * see swj_add_transact_out()
+ *
+ */
+int interface_swj_add_transact_out(uint8_t apndp, uint8_t rnw, uint8_t reg, uint32_t out_value, uint8_t* ack)
+{
+	uint8_t parity = 0, request;
+	jtag_command_t * cmd		= cmd_queue_alloc(sizeof(jtag_command_t));
+	swj_transact_command_t * t	= cmd_queue_alloc(sizeof(scan_command_t));
+
+	request = ((apndp & 1) << 1) | ((rnw & 1) << 2) | ((reg & 0x0C) << 1);
+
+	if (request & 0x02) parity++;
+	if (request & 0x04) parity++;
+	if (request & 0x08) parity++;
+	if (request & 0x10) parity++;
+	request |= 0x81 | ((parity & 0x01) << 5);
+
+	LOG_DEBUG(" 0x%02X, 0x%08X", request, out_value);
+
+	jtag_queue_command(cmd);
+	cmd->type				= SWJ_TRANSACT;
+	cmd->cmd.swj_transact	= t;
+	t->request				= request;
+	t->data					= (uint32_t*)buf_cpy((uint8_t*)&out_value, cmd_queue_alloc(4), 32);
+	t->ack					= ack;
+
+	return ERROR_OK;
+}
+ 
+ /**
+ * see swj_add_transact_in()
+ *
+ */
+int interface_swj_add_transact_in(uint8_t apndp, uint8_t rnw, uint8_t reg, uint32_t* in_value, uint8_t* ack)
+{
+	uint8_t parity = 0, request;
+	jtag_command_t * cmd		= cmd_queue_alloc(sizeof(jtag_command_t));
+	swj_transact_command_t * t	= cmd_queue_alloc(sizeof(scan_command_t));
+
+	request = ((apndp & 1) << 1) | ((rnw & 1) << 2) | ((reg & 0x0C) << 1);
+
+	if (request & 0x02) parity++;
+	if (request & 0x04) parity++;
+	if (request & 0x08) parity++;
+	if (request & 0x10) parity++;
+	request |= 0x81 | ((parity & 0x01) << 5);
+
+	LOG_DEBUG(" 0x%02X", request);
+
+	jtag_queue_command(cmd);
+	cmd->type				= SWJ_TRANSACT;
+	cmd->cmd.swj_transact	= t;
+	t->request				= request;
+	t->data					= in_value;
+	t->ack					= ack;
+
+	return ERROR_OK;
+}
 
 /**
  * see jtag_add_ir_scan()
diff --git a/src/jtag/interface.c b/src/jtag/interface.c
index e475b482d..d81a9b608 100644
--- a/src/jtag/interface.c
+++ b/src/jtag/interface.c
@@ -34,6 +34,8 @@
 #include "jtag.h"
 #include "interface.h"
 
+int swj_mode = 0;
+
 /**
  * @see tap_set_state() and tap_get_state() accessors.
  * Actual name is not important since accessors hide it.
diff --git a/src/jtag/interface.h b/src/jtag/interface.h
index afe21086c..c6b3a1e56 100644
--- a/src/jtag/interface.h
+++ b/src/jtag/interface.h
@@ -36,6 +36,7 @@
  * cable.
  */
 
+extern int swj_mode;
 
 /** implementation of wrapper function tap_set_state() */
 void tap_set_state_impl(tap_state_t new_state);
diff --git a/src/jtag/jtag.h b/src/jtag/jtag.h
index ca09f923e..4d994743f 100644
--- a/src/jtag/jtag.h
+++ b/src/jtag/jtag.h
@@ -735,4 +735,11 @@ bool jtag_poll_get_enabled(void);
  */
 void jtag_poll_set_enabled(bool value);
 
+/**
+ * swj
+ */
+extern void swj_add_sequence(uint8_t *seq, uint16_t len);
+extern void swj_add_transact_out(uint8_t apndp, uint8_t rnw, uint8_t reg, uint32_t out_value, uint8_t* ack);
+extern void swj_add_transact_in(uint8_t apndp, uint8_t rnw, uint8_t reg, uint32_t* in_value, uint8_t* ack);
+
 #endif /* JTAG_H */
diff --git a/src/jtag/minidriver.h b/src/jtag/minidriver.h
index b7c01abc8..73c680d6b 100644
--- a/src/jtag/minidriver.h
+++ b/src/jtag/minidriver.h
@@ -93,6 +93,12 @@ extern void interface_jtag_add_callback4(jtag_callback_t f, jtag_callback_data_t
 
 #endif
 
+extern int interface_swj_add_sequence(uint8_t* seq, uint16_t len);
+extern int interface_swj_add_transact_out(uint8_t apndp, uint8_t rnw, 
+		uint8_t reg, uint32_t out_value, uint8_t* ack);
+extern int interface_swj_add_transact_in(uint8_t apndp, uint8_t rnw, 
+		uint8_t reg, uint32_t* in_value, uint8_t* ack);
+
 extern int interface_jtag_add_ir_scan(
 		int num_fields, const scan_field_t* fields,
 		tap_state_t endstate);
diff --git a/src/jtag/tcl.c b/src/jtag/tcl.c
index 5056a5c5d..b42d6591a 100644
--- a/src/jtag/tcl.c
+++ b/src/jtag/tcl.c
@@ -57,6 +57,7 @@ static int handle_interface_list_command(struct command_context_s *cmd_ctx,
 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_swj_mode_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 static int handle_jtag_rclk_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
@@ -457,10 +458,13 @@ static int jim_jtag_command(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 			Jim_WrongNumArgs(goi.interp, 1, goi.argv-1, "(no params)");
 			return JIM_ERR;
 		}
-		e = jtag_init_inner(context);
-		if (e != ERROR_OK) {
-			Jim_SetResult_sprintf(goi.interp, "error: %d", e);
-			return JIM_ERR;
+		if (!swj_mode)
+		{
+			e = jtag_init_inner(context);
+			if (e != ERROR_OK) {
+				Jim_SetResult_sprintf(goi.interp, "error: %d", e);
+				return JIM_ERR;
+			}
 		}
 		return JIM_OK;
 	case JTAG_CMD_INIT_RESET:
@@ -620,6 +624,8 @@ int jtag_register_commands(struct command_context_s *cmd_ctx)
 	register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
 		COMMAND_ANY, "set maximum jtag speed (if supported); "
 		"parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
+	register_command(cmd_ctx, NULL, "swj_mode", handle_swj_mode_command, 
+		COMMAND_ANY, "use swj instead of jtag");
 	register_command(cmd_ctx, NULL, "jtag_rclk", handle_jtag_rclk_command,
 		COMMAND_ANY, "fallback_speed_khz - set JTAG speed to RCLK or use fallback speed");
 	register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
@@ -1135,6 +1141,22 @@ static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cm
 	return retval;
 }
 
+static int handle_swj_mode_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+{
+	if (argc != 1)
+		return ERROR_COMMAND_SYNTAX_ERROR;
+
+	unsigned swj_trn = 0;
+	int retval = parse_uint(args[0], &swj_trn);
+	if (ERROR_OK != retval)
+		return retval;
+
+	swj_mode = (uint8_t)swj_trn;
+	LOG_INFO("OpenOCD runs in SWJ mode");
+
+	return ERROR_OK;
+}
+
 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
 	if (argc > 1)
diff --git a/src/jtag/vsllink.c b/src/jtag/vsllink.c
index ab55a1901..ceaf98f03 100644
--- a/src/jtag/vsllink.c
+++ b/src/jtag/vsllink.c
@@ -36,6 +36,7 @@
 
 #define VSLLINK_MODE_NORMAL			0
 #define VSLLINK_MODE_DMA			1
+#define VSLLINK_MODE_SWJ			0x80
 
 static uint16_t vsllink_usb_vid;
 static uint16_t vsllink_usb_pid;
@@ -62,7 +63,7 @@ static uint8_t* vsllink_usb_out_buffer = NULL;
 #define VSLLINK_CMD_SET_PORTDIR		0x92
 #define VSLLINK_CMD_HW_JTAGSEQCMD	0xA0
 #define VSLLINK_CMD_HW_JTAGHLCMD	0xA1
-#define VSLLINK_CMD_HW_SWDCMD		0xA2
+#define VSLLINK_CMD_HW_SWJCMD		0xA2
 #define VSLLINK_CMD_HW_JTAGRAWCMD	0xA3
 
 #define VSLLINK_CMDJTAGSEQ_TMSBYTE	0x00
@@ -72,6 +73,14 @@ static uint8_t* vsllink_usb_out_buffer = NULL;
 #define VSLLINK_CMDJTAGSEQ_CMDMSK	0xC0
 #define VSLLINK_CMDJTAGSEQ_LENMSK	0x3F
 
+#define VSLLINK_CMDSWJ_SEQOUT		0x00
+#define VSLLINK_CMDSWJ_SEQIN		0x40
+#define VSLLINK_CMDSWJ_TRANS		0x80
+#define VSLLINK_CMDSWJ_PARA			0xC0
+
+#define VSLLINK_CMDSWJ_CMDMSK		0xC0
+#define VSLLINK_CMDSWJ_LENMSK		0x3F
+
 #define JTAG_PINMSK_SRST			(1 << 0)
 #define JTAG_PINMSK_TRST			(1 << 1)
 #define JTAG_PINMSK_USR1			(1 << 2)
@@ -167,7 +176,12 @@ typedef struct
 {
 	int offset;
 	int length; /* Number of bits to read */
-	scan_command_t *command; /* Corresponding scan command */
+	union
+	{
+		scan_command_t *scan_cmd; /* Corresponding scan command */
+		uint32_t swj_cmd;
+	}cmd;
+	uint8_t *ack;
 	uint8_t *buffer;
 } pending_scan_result_t;
 
@@ -194,6 +208,9 @@ static int vsllink_handle_usb_interface_command(struct command_context_s *cmd_ct
 static int vsllink_handle_mode_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 
 /* Queue command functions */
+static void vsllink_swj_seq(uint8_t *seq, uint16_t len);
+static void vsllink_swj_transact(uint8_t request, uint32_t *value, uint8_t *ack);
+
 static void vsllink_end_state(tap_state_t state);
 static void vsllink_state_move_dma(void);
 static void vsllink_state_move_normal(void);
@@ -210,7 +227,7 @@ static void vsllink_scan_normal(bool ir_scan, enum scan_type type, uint8_t *buff
 static void (*vsllink_scan)(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command);
 static void vsllink_reset(int trst, int srst);
 static void vsllink_simple_command(uint8_t command);
-static int vsllink_connect(void);
+static int vsllink_connect(uint8_t mode);
 static int vsllink_disconnect(void);
 
 /* VSLLink tap buffer functions */
@@ -221,9 +238,11 @@ static void (*vsllink_tap_init)(void);
 static int vsllink_tap_execute_dma(void);
 static int vsllink_tap_execute_normal(void);
 static int (*vsllink_tap_execute)(void);
+static int vsllink_swj_execute(void);
 static void vsllink_tap_ensure_space_dma(int scans, int length);
 static void vsllink_tap_ensure_space_normal(int scans, int length);
 static void (*vsllink_tap_ensure_space)(int scans, int length);
+static void vsllink_swj_ensure_space(int scans, int length);
 static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, scan_command_t *command);
 static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, scan_command_t *command, int offset);
 
@@ -272,12 +291,11 @@ jtag_interface_t vsllink_interface =
 
 static void reset_command_pointer(void)
 {
-	if (vsllink_mode == VSLLINK_MODE_NORMAL)
+	if ((vsllink_mode == VSLLINK_MODE_NORMAL) || (vsllink_mode == VSLLINK_MODE_SWJ))
 	{
-		vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGSEQCMD;
 		vsllink_usb_out_buffer_idx = 3;
 	}
-	else
+	else if (vsllink_mode == VSLLINK_MODE_DMA)
 	{
 		tap_length = 0;
 	}
@@ -384,6 +402,31 @@ static int vsllink_execute_queue(void)
 				vsllink_stableclocks(cmd->cmd.stableclocks->num_cycles, scan_size);
 				break;
 
+			case SWJ_SEQ:
+				DEBUG_JTAG_IO("add %d swj sequence", cmd->cmd.swj_seq->num_bits);
+#ifdef _DEBUG_JTAG_IO_
+				vsllink_debug_buffer(cmd->cmd.swj_seq->seq, (cmd->cmd.swj_seq->num_bits + 7) >> 3);
+#endif
+
+				vsllink_swj_seq(cmd->cmd.swj_seq->seq, cmd->cmd.swj_seq->num_bits);
+				break;
+
+			case SWJ_TRANSACT:
+				if (cmd->cmd.swj_transact->request & 0x04)
+				{
+					DEBUG_JTAG_IO("add swj in transact, request=0x%02X", 
+								cmd->cmd.swj_transact->request);
+				}
+				else
+				{
+					DEBUG_JTAG_IO("add swj out transact, request=0x%02X, data=0x%08X", 
+								cmd->cmd.swj_transact->request, *cmd->cmd.swj_transact->data);
+				}
+
+				vsllink_swj_transact(cmd->cmd.swj_transact->request, cmd->cmd.swj_transact->data, 
+								cmd->cmd.swj_transact->ack);
+				break;
+
 			default:
 				LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd->type);
 				exit(-1);
@@ -454,6 +497,11 @@ static int vsllink_init(void)
 	}
 	LOG_DEBUG("vsllink found on %04X:%04X", vsllink_usb_vid, vsllink_usb_pid);
 
+	if (swj_mode)
+	{
+		vsllink_mode = VSLLINK_MODE_SWJ;
+	}
+
 	to_tmp = VSLLINK_USB_TIMEOUT;
 	VSLLINK_USB_TIMEOUT = 100;
 	check_cnt = 0;
@@ -514,7 +562,8 @@ static int vsllink_init(void)
 	VSLLINK_USB_TIMEOUT = to_tmp;
 
 	// connect to vsllink
-	vsllink_connect();
+	vsllink_connect(vsllink_mode);
+
 	// initialize function pointers
 	if (vsllink_mode == VSLLINK_MODE_NORMAL)
 	{
@@ -530,7 +579,7 @@ static int vsllink_init(void)
 
 		LOG_INFO("vsllink run in NORMAL mode");
 	}
-	else
+	else if (vsllink_mode == VSLLINK_MODE_DMA)
 	{
 		// dma mode
 		vsllink_state_move = vsllink_state_move_dma;
@@ -544,6 +593,12 @@ static int vsllink_init(void)
 
 		LOG_INFO("vsllink run in DMA mode");
 	}
+	else if (vsllink_mode == VSLLINK_MODE_SWJ)
+	{
+		vsllink_tap_init = vsllink_tap_init_normal;
+		vsllink_tap_execute = vsllink_swj_execute;
+		vsllink_tap_ensure_space = vsllink_swj_ensure_space;
+	}
 
 	// Set SRST and TRST to output, Set USR1 and USR2 to input
 	vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_PORTDIR;
@@ -557,10 +612,36 @@ static int vsllink_init(void)
 
 	vsllink_reset(0, 0);
 
-	LOG_INFO("VSLLink JTAG Interface ready");
+	if (vsllink_mode == VSLLINK_MODE_SWJ)
+	{
+		LOG_INFO("VSLLink SWJ Interface ready");
+	}
+	else
+	{
+		LOG_INFO("VSLLink JTAG Interface ready");
+	}
 
 	vsllink_tap_init();
 
+	// set swj parameters
+	if (vsllink_mode == VSLLINK_MODE_SWJ)
+	{
+		vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_SWJCMD;
+		vsllink_usb_out_buffer[1] = 9;
+		vsllink_usb_out_buffer[2] = 0;
+		vsllink_usb_out_buffer[3] = VSLLINK_CMDSWJ_PARA;
+		vsllink_usb_out_buffer[4] = swj_mode;
+		vsllink_usb_out_buffer[5] = 0;
+		vsllink_usb_out_buffer[6] = 0;
+		vsllink_usb_out_buffer[7] = 0;
+		vsllink_usb_out_buffer[8] = 0;
+		if (vsllink_usb_write(vsllink_jtag_handle, 9) != 9)
+		{
+			LOG_ERROR("VSLLink USB send data error");
+			exit(-1);
+		}
+	}
+
 	return ERROR_OK;
 }
 
@@ -606,12 +687,12 @@ static int vsllink_disconnect(void)
 	return ERROR_OK;
 }
 
-static int vsllink_connect(void)
+static int vsllink_connect(uint8_t mode)
 {
 	char vsllink_str[100];
 
 	vsllink_usb_out_buffer[0] = VSLLINK_CMD_CONN;
-	vsllink_usb_out_buffer[1] = vsllink_mode;
+	vsllink_usb_out_buffer[1] = mode;
 	vsllink_usb_message(vsllink_jtag_handle, 2, 0);
 	if (vsllink_usb_read(vsllink_jtag_handle) > 2)
 	{
@@ -622,6 +703,79 @@ static int vsllink_connect(void)
 	return ERROR_OK;
 }
 
+static void vsllink_swj_seq(uint8_t *seq, uint16_t len)
+{
+	pending_scan_result_t *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
+	uint8_t cmd = VSLLINK_CMDSWJ_SEQOUT;
+	uint16_t byte_len = (len + 7) >> 3;
+
+	if ((NULL == seq) || (0 == len))
+	{
+		LOG_ERROR("invalid parameter for swj_sequence");
+		return;
+	}
+
+	vsllink_tap_ensure_space(1, 3 + byte_len);
+	vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = cmd;
+	vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (len >> 0) & 0xFF;
+	vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (len >> 8) & 0xFF;
+	memcpy(vsllink_usb_out_buffer + vsllink_usb_out_buffer_idx, seq, byte_len);
+	vsllink_usb_out_buffer_idx += byte_len;
+
+	vsllink_usb_in_want_length += 1;
+
+	pending_scan_result->length = 1;
+	pending_scan_result->offset = 0;
+	pending_scan_result->cmd.swj_cmd = cmd;
+	pending_scan_result->buffer = seq;
+	pending_scan_results_length++;
+}
+
+static void vsllink_swj_transact(uint8_t request, uint32_t *value, uint8_t *ack)
+{
+	pending_scan_result_t *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
+	uint8_t cmd = VSLLINK_CMDSWJ_TRANS;
+
+/*
+	if (request & 0x04)
+	{
+		LOG_DEBUG(" 0x%02X", request);
+	}
+	else
+	{
+		LOG_DEBUG(" 0x%02X, 0x%08X", request, *value);
+	}
+*/
+
+	vsllink_tap_ensure_space(1, 6);
+
+	vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = cmd;
+	vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = request;
+	if (NULL == value)
+	{
+		vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0;
+		vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0;
+		vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0;
+		vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0;
+	}
+	else
+	{
+		vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((*value) >> 0) & 0xFF;
+		vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((*value) >> 8) & 0xFF;
+		vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((*value) >> 16) & 0xFF;
+		vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((*value) >> 24) & 0xFF;
+	}
+
+	vsllink_usb_in_want_length += 5;
+
+	pending_scan_result->length = 5;
+	pending_scan_result->offset = 1;
+	pending_scan_result->cmd.swj_cmd = cmd | ((request & 0x04) >> 2);
+	pending_scan_result->buffer = (uint8_t*)value;
+	pending_scan_result->ack = ack;
+	pending_scan_results_length++;
+}
+
 // when vsllink_tms_data_len > 0, vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] is the byte that need to be appended.
 // length of VSLLINK_CMDJTAGSEQ_TMSBYTE has been set, no need to set it here.
 static void vsllink_append_tms(void)
@@ -1476,6 +1630,17 @@ static void vsllink_tap_init_dma(void)
 	pending_scan_results_length = 0;
 }
 
+static void vsllink_swj_ensure_space(int scans, int length)
+{
+	int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length;
+	int available_bytes = VSLLINK_BufferSize - vsllink_usb_out_buffer_idx;
+
+	if (scans > available_scans || length > available_bytes)
+	{
+		vsllink_tap_execute();
+	}	
+}
+
 static void vsllink_tap_ensure_space_normal(int scans, int length)
 {
 	int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length;
@@ -1548,7 +1713,7 @@ static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, scan_com
 	}
 	pending_scan_result->length = length;
 	pending_scan_result->offset = offset;
-	pending_scan_result->command = command;
+	pending_scan_result->cmd.scan_cmd = command;
 	pending_scan_result->buffer = buffer;
 
 	for (i = 0; i < ((length + 7) >> 3); i++)
@@ -1580,7 +1745,7 @@ static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, scan_comman
 		pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
 		pending_scan_result->offset = tap_length;
 		pending_scan_result->length = len_tmp;
-		pending_scan_result->command = command;
+		pending_scan_result->cmd.scan_cmd = command;
 		pending_scan_result->buffer = buffer + len_all / 8;
 
 		for (i = 0; i < len_tmp; i++)
@@ -1593,6 +1758,79 @@ static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, scan_comman
 	}
 }
 
+static int vsllink_swj_execute(void)
+{
+	int i;
+	int result, cur_pos = 0;
+
+	if (vsllink_usb_out_buffer_idx > 3)
+	{
+		vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_SWJCMD;
+		vsllink_usb_out_buffer[1] = (vsllink_usb_out_buffer_idx >> 0) & 0xff;
+		vsllink_usb_out_buffer[2] = (vsllink_usb_out_buffer_idx >> 8) & 0xff;
+
+		result = vsllink_usb_message(vsllink_jtag_handle, vsllink_usb_out_buffer_idx, vsllink_usb_in_want_length);
+
+		if (result == vsllink_usb_in_want_length)
+		{
+			for (i = 0; i < pending_scan_results_length; i++)
+			{
+				pending_scan_result_t *pending_scan_result = &pending_scan_results_buffer[i];
+				uint8_t *buffer = pending_scan_result->buffer;
+				uint8_t *ack = pending_scan_result->ack;
+				int length = pending_scan_result->length;
+				uint32_t command = pending_scan_result->cmd.swj_cmd;
+
+				switch (command & VSLLINK_CMDSWJ_CMDMSK)
+				{
+					case VSLLINK_CMDSWJ_SEQOUT:
+					case VSLLINK_CMDSWJ_SEQIN:
+						if (vsllink_usb_in_buffer[cur_pos] != 0x00)
+						{
+							LOG_ERROR("fail to do swj_sequence");
+							return ERROR_FAIL;
+						}
+						break;
+					case VSLLINK_CMDSWJ_TRANS:
+						if (ack != NULL)
+						{
+							*ack = vsllink_usb_in_buffer[cur_pos] & 0x07;
+						}
+
+						if (buffer != NULL)
+						{
+							buf_set_buf(vsllink_usb_in_buffer + cur_pos + 1, 0, buffer, 0, 32);
+						}
+
+#ifdef _DEBUG_JTAG_IO_
+						if (command & 1)
+						{
+							DEBUG_JTAG_IO("SWJ transact read:");
+							vsllink_debug_buffer(vsllink_usb_in_buffer + cur_pos + 1, 4);
+						}
+#endif
+						break;
+					default:
+						LOG_ERROR("unknown command: 0x%02X", command);
+						exit(-1);
+						break;
+				}
+				cur_pos += length;
+			}
+		}
+		else
+		{
+			LOG_ERROR("vsllink_swj_execute, wrong result %d, expected %d", result, vsllink_usb_in_want_length);
+			return ERROR_JTAG_QUEUE_FAILED;
+		}
+
+		vsllink_tap_init_normal();
+	}
+	reset_command_pointer();
+
+	return ERROR_OK;
+}
+
 /* Pad and send a tap sequence to the device, and receive the answer.
  * For the purpose of padding we assume that we are in reset or idle or pause state. */
 static int vsllink_tap_execute_normal(void)
@@ -1626,11 +1864,9 @@ static int vsllink_tap_execute_normal(void)
 
 	if (vsllink_usb_out_buffer_idx > 3)
 	{
-		if (vsllink_usb_out_buffer[0] == VSLLINK_CMD_HW_JTAGSEQCMD)
-		{
-			vsllink_usb_out_buffer[1] = (vsllink_usb_out_buffer_idx >> 0) & 0xff;
-			vsllink_usb_out_buffer[2] = (vsllink_usb_out_buffer_idx >> 8) & 0xff;
-		}
+		vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGSEQCMD;
+		vsllink_usb_out_buffer[1] = (vsllink_usb_out_buffer_idx >> 0) & 0xff;
+		vsllink_usb_out_buffer[2] = (vsllink_usb_out_buffer_idx >> 8) & 0xff;
 
 		result = vsllink_usb_message(vsllink_jtag_handle, vsllink_usb_out_buffer_idx, vsllink_usb_in_want_length);
 
@@ -1642,7 +1878,7 @@ static int vsllink_tap_execute_normal(void)
 				uint8_t *buffer = pending_scan_result->buffer;
 				int length = pending_scan_result->length;
 				int offset = pending_scan_result->offset;
-				scan_command_t *command = pending_scan_result->command;
+				scan_command_t *command = pending_scan_result->cmd.scan_cmd;
 
 				if (buffer != NULL)
 				{
@@ -1716,7 +1952,7 @@ static int vsllink_tap_execute_dma(void)
 				int length = pending_scan_result->length;
 				int first = pending_scan_result->offset;
 
-				scan_command_t *command = pending_scan_result->command;
+				scan_command_t *command = pending_scan_result->cmd.scan_cmd;
 				buf_set_buf(vsllink_usb_in_buffer, first, buffer, 0, length);
 
 				DEBUG_JTAG_IO("JTAG scan read(%d bits, from %d bits):", length, first);
diff --git a/src/target/arm_adi_v5.c b/src/target/arm_adi_v5.c
index 336413206..01fabc31d 100644
--- a/src/target/arm_adi_v5.c
+++ b/src/target/arm_adi_v5.c
@@ -77,25 +77,55 @@ int adi_jtag_dp_scan(swjdp_common_t *swjdp, uint8_t instr, uint8_t reg_addr, uin
 	scan_field_t fields[2];
 	uint8_t out_addr_buf;
 
-	jtag_set_end_state(TAP_IDLE);
-	arm_jtag_set_instr(jtag_info, instr, NULL);
+	if (swj_mode)
+	{
+		switch (instr)
+		{
+			case DAP_IR_APACC:
+				instr = 1;
+				break;
+			case DAP_IR_DPACC:
+				instr = 0;
+				break;
+			default:
+				LOG_ERROR("%d is inalid for swj instruction", instr);
+				return ERROR_FAIL;
+				break;
+		}
+
+		if (RnW == DPAP_READ)
+		{
+			RnW = 1;
+			swj_add_transact_in(instr, RnW, reg_addr, (uint32_t *)invalue, ack);
+		}
+		else
+		{
+			RnW = 0;
+			swj_add_transact_out(instr, RnW, reg_addr, *(uint32_t *)outvalue, ack);
+		}
+	}
+	else
+	{
+		jtag_set_end_state(TAP_IDLE);
+		arm_jtag_set_instr(jtag_info, instr, NULL);
 
-	/* Add specified number of tck clocks before accessing memory bus */
-	if ((instr == DAP_IR_APACC) && ((reg_addr == AP_REG_DRW)||((reg_addr&0xF0) == AP_REG_BD0))&& (swjdp->memaccess_tck != 0))
-		jtag_add_runtest(swjdp->memaccess_tck, jtag_set_end_state(TAP_IDLE));
+		/* Add specified number of tck clocks before accessing memory bus */
+		if ((instr == DAP_IR_APACC) && ((reg_addr == AP_REG_DRW)||((reg_addr&0xF0) == AP_REG_BD0))&& (swjdp->memaccess_tck != 0))
+			jtag_add_runtest(swjdp->memaccess_tck, jtag_set_end_state(TAP_IDLE));
 
-	fields[0].tap = jtag_info->tap;
-	fields[0].num_bits = 3;
-	buf_set_u32(&out_addr_buf, 0, 3, ((reg_addr >> 1) & 0x6) | (RnW & 0x1));
-	fields[0].out_value = &out_addr_buf;
-	fields[0].in_value = ack;
+		fields[0].tap = jtag_info->tap;
+		fields[0].num_bits = 3;
+		buf_set_u32(&out_addr_buf, 0, 3, ((reg_addr >> 1) & 0x6) | (RnW & 0x1));
+		fields[0].out_value = &out_addr_buf;
+		fields[0].in_value = ack;
 
-	fields[1].tap = jtag_info->tap;
-	fields[1].num_bits = 32;
-	fields[1].out_value = outvalue;
-	fields[1].in_value = invalue;
+		fields[1].tap = jtag_info->tap;
+		fields[1].num_bits = 32;
+		fields[1].out_value = outvalue;
+		fields[1].in_value = invalue;
 
-	jtag_add_dr_scan(2, fields, jtag_get_end_state());
+		jtag_add_dr_scan(2, fields, jtag_get_end_state());
+	}
 
 	return ERROR_OK;
 }
@@ -108,35 +138,64 @@ int adi_jtag_dp_scan_u32(swjdp_common_t *swjdp, uint8_t instr, uint8_t reg_addr,
 	uint8_t out_value_buf[4];
 	uint8_t out_addr_buf;
 
-	jtag_set_end_state(TAP_IDLE);
-	arm_jtag_set_instr(jtag_info, instr, NULL);
-
-	/* Add specified number of tck clocks before accessing memory bus */
-	if ((instr == DAP_IR_APACC) && ((reg_addr == AP_REG_DRW)||((reg_addr&0xF0) == AP_REG_BD0))&& (swjdp->memaccess_tck != 0))
-		jtag_add_runtest(swjdp->memaccess_tck, jtag_set_end_state(TAP_IDLE));
-
-	fields[0].tap = jtag_info->tap;
-	fields[0].num_bits = 3;
-	buf_set_u32(&out_addr_buf, 0, 3, ((reg_addr >> 1) & 0x6) | (RnW & 0x1));
-	fields[0].out_value = &out_addr_buf;
-	fields[0].in_value = ack;
-
-	fields[1].tap = jtag_info->tap;
-	fields[1].num_bits = 32;
-	buf_set_u32(out_value_buf, 0, 32, outvalue);
-	fields[1].out_value = out_value_buf;
-	fields[1].in_value = NULL;
-
-	if (invalue)
+	if (swj_mode)
 	{
-		fields[1].in_value = (uint8_t *)invalue;
-		jtag_add_dr_scan(2, fields, jtag_get_end_state());
+		switch (instr)
+		{
+			case DAP_IR_APACC:
+				instr = 1;
+				break;
+			case DAP_IR_DPACC:
+				instr = 0;
+				break;
+			default:
+				LOG_ERROR("%d is inalid for swj instruction", instr);
+				return ERROR_FAIL;
+				break;
+		}
 
-		jtag_add_callback(arm_le_to_h_u32, (jtag_callback_data_t) invalue);
-	} else
+		if (RnW == DPAP_READ)
+		{
+			RnW = 1;
+			swj_add_transact_in(instr, RnW, reg_addr, invalue, ack);
+		}
+		else
+		{
+			RnW = 0;
+			swj_add_transact_out(instr, RnW, reg_addr, outvalue, ack);
+		}
+	}
+	else
 	{
+		jtag_set_end_state(TAP_IDLE);
+		arm_jtag_set_instr(jtag_info, instr, NULL);
+
+		/* Add specified number of tck clocks before accessing memory bus */
+		if ((instr == DAP_IR_APACC) && ((reg_addr == AP_REG_DRW)||((reg_addr&0xF0) == AP_REG_BD0))&& (swjdp->memaccess_tck != 0))
+			jtag_add_runtest(swjdp->memaccess_tck, jtag_set_end_state(TAP_IDLE));
+
+		fields[0].tap = jtag_info->tap;
+		fields[0].num_bits = 3;
+		buf_set_u32(&out_addr_buf, 0, 3, ((reg_addr >> 1) & 0x6) | (RnW & 0x1));
+		fields[0].out_value = &out_addr_buf;
+		fields[0].in_value = ack;
+
+		fields[1].tap = jtag_info->tap;
+		fields[1].num_bits = 32;
+		buf_set_u32(out_value_buf, 0, 32, outvalue);
+		fields[1].out_value = out_value_buf;
+		fields[1].in_value = NULL;
+
+		if (invalue)
+		{
+			fields[1].in_value = (uint8_t *)invalue;
+			jtag_add_dr_scan(2, fields, jtag_get_end_state());
 
-		jtag_add_dr_scan(2, fields, jtag_get_end_state());
+			jtag_add_callback(arm_le_to_h_u32, (jtag_callback_data_t) invalue);
+		} else
+		{
+			jtag_add_dr_scan(2, fields, jtag_get_end_state());
+		}
 	}
 
 	return ERROR_OK;
@@ -145,9 +204,16 @@ int adi_jtag_dp_scan_u32(swjdp_common_t *swjdp, uint8_t instr, uint8_t reg_addr,
 /* scan_inout_check adds one extra inscan for DPAP_READ commands to read variables */
 int scan_inout_check(swjdp_common_t *swjdp, uint8_t instr, uint8_t reg_addr, uint8_t RnW, uint8_t *outvalue, uint8_t *invalue)
 {
-	adi_jtag_dp_scan(swjdp, instr, reg_addr, RnW, outvalue, NULL, NULL);
+	if (swj_mode)
+	{
+		adi_jtag_dp_scan_u32(swjdp, instr, reg_addr, RnW, *(uint32_t*)outvalue, (uint32_t*)invalue, NULL);
+	}
+	else
+	{
+		adi_jtag_dp_scan_u32(swjdp, instr, reg_addr, RnW, *(uint32_t*)outvalue, NULL, NULL);
+	}
 
-	if ((RnW == DPAP_READ) && (invalue != NULL))
+	if ((RnW == DPAP_READ) && (invalue != NULL) && ((!swj_mode) || (instr == DAP_IR_APACC)))
 	{
 		adi_jtag_dp_scan(swjdp, DAP_IR_DPACC, DP_RDBUFF, DPAP_READ, 0, invalue, &swjdp->ack);
 	}
@@ -163,9 +229,16 @@ int scan_inout_check(swjdp_common_t *swjdp, uint8_t instr, uint8_t reg_addr, uin
 
 int scan_inout_check_u32(swjdp_common_t *swjdp, uint8_t instr, uint8_t reg_addr, uint8_t RnW, uint32_t outvalue, uint32_t *invalue)
 {
-	adi_jtag_dp_scan_u32(swjdp, instr, reg_addr, RnW, outvalue, NULL, NULL);
+	if (swj_mode)
+	{
+		adi_jtag_dp_scan_u32(swjdp, instr, reg_addr, RnW, outvalue, invalue, NULL);
+	}
+	else
+	{
+		adi_jtag_dp_scan_u32(swjdp, instr, reg_addr, RnW, outvalue, NULL, NULL);
+	}
 
-	if ((RnW == DPAP_READ) && (invalue != NULL))
+	if ((RnW == DPAP_READ) && (invalue != NULL) && ((!swj_mode) || (instr == DAP_IR_APACC)))
 	{
 		adi_jtag_dp_scan_u32(swjdp, DAP_IR_DPACC, DP_RDBUFF, DPAP_READ, 0, invalue, &swjdp->ack);
 	}
@@ -208,7 +281,8 @@ int swjdp_transaction_endcheck(swjdp_common_t *swjdp)
 
 	swjdp->ack = swjdp->ack & 0x7;
 
-	if (swjdp->ack != 2)
+	if (((swj_mode) && (swjdp->ack != 1)) || 
+		((!swj_mode) && (swjdp->ack != 2)))
 	{
 		long long then = timeval_ms();
 		while (swjdp->ack != 2)
@@ -259,7 +333,14 @@ int swjdp_transaction_endcheck(swjdp_common_t *swjdp)
 				LOG_ERROR("SWJ-DP STICKY ERROR");
 
 			/* Clear Sticky Error Bits */
-			scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_WRITE, swjdp->dp_ctrl_stat | SSTICKYORUN | SSTICKYERR, NULL);
+			if (swj_mode)
+			{
+				scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_ABORT, DPAP_WRITE, ORUNERRCLR | STKERRCLR, NULL);
+			}
+			else
+			{
+				scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_WRITE, swjdp->dp_ctrl_stat | SSTICKYORUN | SSTICKYERR, NULL);
+			}
 			scan_inout_check_u32(swjdp, DAP_IR_DPACC, DP_CTRL_STAT, DPAP_READ, 0, &ctrlstat);
 			if ((retval = jtag_execute_queue()) != ERROR_OK)
 				return retval;
@@ -349,6 +430,7 @@ int dap_ap_write_reg_u32(swjdp_common_t *swjdp, uint32_t reg_addr, uint32_t valu
 
 	buf_set_u32(out_value_buf, 0, 32, value);
 	dap_dp_bankselect(swjdp, reg_addr);
+
 	scan_inout_check(swjdp, DAP_IR_APACC, reg_addr, DPAP_WRITE, out_value_buf, NULL);
 
 	return ERROR_OK;
@@ -957,14 +1039,55 @@ int ahbap_debugport_init(swjdp_common_t *swjdp)
 	int cnt = 0;
 	int retval;
 
+const uint8_t jtag_to_swj_seq[] = 
+{
+	// at least 50-bit '1'
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
+	// 16-bit JTAG-to-SWD sequence
+	0x9E, 0xE7, 
+	// at least 50-bit '1'
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F
+};
+/*
+const uint8_t swj_to_jtag_seq[] = 
+{
+	// at least 50-bit '1'
+	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
+	// 16-bit JTAG-to-SWD sequence
+	0x3C, 0xE7, 
+	// at least 5-bit '1'
+	0xFF
+};
+*/
 	LOG_DEBUG(" ");
 
 	swjdp->apsel = 0;
 	swjdp->ap_csw_value = -1;
 	swjdp->ap_tar_value = -1;
 	swjdp->trans_mode = TRANS_MODE_ATOMIC;
+
+	if (swj_mode)
+	{
+		swj_add_sequence((uint8_t*)jtag_to_swj_seq, sizeof(jtag_to_swj_seq) * 8);
+		dap_dp_read_reg(swjdp, &dummy, DP_DPIDR);
+		if ((retval = jtag_execute_queue()) != ERROR_OK)
+			return retval;
+		LOG_DEBUG("swj_id is 0x%08X", dummy);
+	}
+	else
+	{
+		
+	}
+
 	dap_dp_read_reg(swjdp, &dummy, DP_CTRL_STAT);
-	dap_dp_write_reg(swjdp, SSTICKYERR, DP_CTRL_STAT);
+	if (swj_mode)
+	{
+		dap_dp_write_reg(swjdp, DAPABORT | STKERRCLR | WDERRCLR | ORUNERRCLR, DP_ABORT);
+	}
+	else
+	{
+		dap_dp_write_reg(swjdp, SSTICKYERR, DP_CTRL_STAT);
+	}
 	dap_dp_read_reg(swjdp, &dummy, DP_CTRL_STAT);
 
 	swjdp->dp_ctrl_stat = CDBGPWRUPREQ | CSYSPWRUPREQ;
diff --git a/src/target/arm_adi_v5.h b/src/target/arm_adi_v5.h
index 3ff883af7..893e88152 100644
--- a/src/target/arm_adi_v5.h
+++ b/src/target/arm_adi_v5.h
@@ -26,6 +26,7 @@
 #include "target.h"
 #include "register.h"
 #include "arm_jtag.h"
+#include "interface.h"
 
 #define DAP_IR_DPACC	0xA
 #define DAP_IR_APACC	0xB
@@ -33,10 +34,18 @@
 #define DPAP_WRITE		0
 #define DPAP_READ		1
 #define DP_ZERO			0
+#define DP_DPIDR		0x0
+#define DP_ABORT		0x0
 #define DP_CTRL_STAT	0x4
 #define DP_SELECT		0x8
 #define DP_RDBUFF		0xC
 
+#define DAPABORT		(1<<0)
+#define STKCMPCLR		(1<<1)
+#define STKERRCLR		(1<<2)
+#define WDERRCLR		(1<<3)
+#define ORUNERRCLR		(1<<4)
+
 #define CORUNDETECT		(1 << 0)
 #define SSTICKYORUN		(1 << 1)
 #define SSTICKYERR		(1 << 5)
-- 
2.11.4.GIT