openocd-devel — Discuss development of OpenOCD

[PATCH]: e1b7624233 checkpatch: enable check for switch/case alignment

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9057

-- gerrit

commit e1b762423368f10c9bee2e07d6381e2587d92133
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jul 26 19:32:43 2025 +0200

    checkpatch: enable check for switch/case alignment
    
    Now that the whole code is aligned with the coding style, enforce
    the check through checkpatch.
    
    Change-Id: Ie74ed98c5dfa61978d5551b60eb90acf746a3cc5
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/.checkpatch.conf b/.checkpatch.conf
index f432503e1a..01be7a9098 100644
--- a/.checkpatch.conf
+++ b/.checkpatch.conf
@@ -23,6 +23,5 @@
 --ignore PREFER_KERNEL_TYPES
 --ignore SPLIT_STRING
 --ignore SSCANF_TO_KSTRTO
---ignore SWITCH_CASE_INDENT_LEVEL
 --ignore TRACING_LOGGING
 --ignore VOLATILE

-- 

[PATCH]: dfa8a13864 jtag: drivers: prepare for aligning switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9054

-- gerrit

commit dfa8a13864b3ab25afff431395585848aa308dd0
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jul 26 18:20:57 2025 +0200

    jtag: drivers: prepare for aligning switch and case statements
    
    To prepare for aligning switch and case statements, fix in advance
    some checkpatch error due to existing code:
    - remove 'else' after return and break;
    - use '__func__' in place of hardcoded function name;
    - remove useless parenthesis;
    - don't end line with an open parenthesis.
    
    Change-Id: I6a9905e5a30c90456de562e727dd2dfe2fda10c4
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/jtag/drivers/ft232r.c b/src/jtag/drivers/ft232r.c
index f88e4b9408..8f7ae13d6c 100644
--- a/src/jtag/drivers/ft232r.c
+++ b/src/jtag/drivers/ft232r.c
@@ -821,11 +821,11 @@ static int syncbb_execute_queue(struct jtag_command *cmd_queue)
 			case JTAG_RESET:
 				LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 
-				if ((cmd->cmd.reset->trst == 1) ||
-					(cmd->cmd.reset->srst &&
-					(jtag_get_reset_config() & RESET_SRST_PULLS_TRST))) {
+				if (cmd->cmd.reset->trst == 1 ||
+						(cmd->cmd.reset->srst &&
+						 (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
 					tap_set_state(TAP_RESET);
-				}
+
 				ft232r_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 				break;
 
diff --git a/src/jtag/drivers/kitprog.c b/src/jtag/drivers/kitprog.c
index 88e301cebc..2bb4d17da2 100644
--- a/src/jtag/drivers/kitprog.c
+++ b/src/jtag/drivers/kitprog.c
@@ -652,10 +652,9 @@ static int kitprog_swd_switch_seq(enum swd_special_seq seq)
 				if (kitprog_swd_seq(SEQUENCE_JTAG_TO_SWD) != ERROR_OK)
 					return ERROR_FAIL;
 				break;
-			} else {
-				LOG_DEBUG("JTAG to SWD not supported");
-				/* Fall through to fix target reset issue */
 			}
+			LOG_DEBUG("JTAG to SWD not supported");
+			/* Fall through to fix target reset issue */
 			/* fallthrough */
 		case LINE_RESET:
 			LOG_DEBUG("SWD line reset");
diff --git a/src/jtag/drivers/rlink.c b/src/jtag/drivers/rlink.c
index a818996255..9622740c6b 100644
--- a/src/jtag/drivers/rlink.c
+++ b/src/jtag/drivers/rlink.c
@@ -332,33 +332,22 @@ static int dtc_load_from_buffer(struct libusb_device_handle *hdev_param, const u
 
 			case DTCLOAD_LOAD:
 				/* Send the DTC program to ST7 RAM. */
-				usb_err = ep1_memory_write(
-						hdev_param,
-						DTC_LOAD_BUFFER,
-						header->length + 1, buffer
-					);
+				usb_err = ep1_memory_write(hdev_param, DTC_LOAD_BUFFER,
+					header->length + 1, buffer);
 				if (usb_err < 0)
 					return usb_err;
 
 				/* Load it into the DTC. */
-				usb_err = ep1_generic_commandl(
-						hdev_param, 3,
-						EP1_CMD_DTC_LOAD,
-						(DTC_LOAD_BUFFER >> 8),
-						DTC_LOAD_BUFFER
-					);
+				usb_err = ep1_generic_commandl(hdev_param, 3, EP1_CMD_DTC_LOAD,
+					(DTC_LOAD_BUFFER >> 8),	DTC_LOAD_BUFFER);
 				if (usb_err < 0)
 					return usb_err;
 
 				break;
 
 			case DTCLOAD_RUN:
-				usb_err = ep1_generic_commandl(
-						hdev_param, 3,
-						EP1_CMD_DTC_CALL,
-						buffer[0],
-						EP1_CMD_DTC_WAIT
-					);
+				usb_err = ep1_generic_commandl(hdev_param, 3, EP1_CMD_DTC_CALL,
+					buffer[0], EP1_CMD_DTC_WAIT);
 				if (usb_err < 0)
 					return usb_err;
 
@@ -369,11 +358,8 @@ static int dtc_load_from_buffer(struct libusb_device_handle *hdev_param, const u
 				break;
 
 			case DTCLOAD_LUT:
-				usb_err = ep1_memory_write(
-						hdev_param,
-						ST7_USB_BUF_EP0OUT + lut_start,
-						header->length + 1, buffer
-					);
+				usb_err = ep1_memory_write(hdev_param,
+					ST7_USB_BUF_EP0OUT + lut_start, header->length + 1, buffer);
 				if (usb_err < 0)
 					return usb_err;
 				break;
@@ -1300,7 +1286,7 @@ static int rlink_execute_queue(struct jtag_command *cmd_queue)
 				LOG_DEBUG_IO("reset trst: %i srst %i",
 						cmd->cmd.reset->trst,
 						cmd->cmd.reset->srst);
-				if ((cmd->cmd.reset->trst == 1) ||
+				if (cmd->cmd.reset->trst == 1 ||
 						(cmd->cmd.reset->srst &&
 								(jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
 					tap_set_state(TAP_RESET);
diff --git a/src/jtag/drivers/ulink.c b/src/jtag/drivers/ulink.c
index 417d560cde..30778a1d8b 100644
--- a/src/jtag/drivers/ulink.c
+++ b/src/jtag/drivers/ulink.c
@@ -528,26 +528,24 @@ static int ulink_allocate_payload(struct ulink_cmd *ulink_cmd, int size,
 			    LOG_ERROR("BUG: Duplicate payload allocation for OpenULINK command");
 			    free(payload);
 			    return ERROR_FAIL;
-		    } else {
-			    ulink_cmd->payload_out = payload;
-			    ulink_cmd->payload_out_size = size;
 		    }
+			ulink_cmd->payload_out = payload;
+			ulink_cmd->payload_out_size = size;
 		    break;
 	    case PAYLOAD_DIRECTION_IN:
 		    if (ulink_cmd->payload_in_start) {
 			    LOG_ERROR("BUG: Duplicate payload allocation for OpenULINK command");
 			    free(payload);
 			    return ERROR_FAIL;
-		    } else {
-			    ulink_cmd->payload_in_start = payload;
-			    ulink_cmd->payload_in = payload;
-			    ulink_cmd->payload_in_size = size;
-
-				/* By default, free payload_in_start in ulink_clear_queue(). Commands
-				 * that do not want this behavior (e. g. split scans) must turn it off
-				 * separately! */
-			    ulink_cmd->free_payload_in_start = true;
 		    }
+			ulink_cmd->payload_in_start = payload;
+			ulink_cmd->payload_in = payload;
+			ulink_cmd->payload_in_size = size;
+
+			/* By default, free payload_in_start in ulink_clear_queue(). Commands
+			 * that do not want this behavior (e. g. split scans) must turn it off
+			 * separately! */
+			ulink_cmd->free_payload_in_start = true;
 		    break;
 	}
 
@@ -903,7 +901,7 @@ static int ulink_append_scan_cmd(struct ulink *device, enum scan_type scan_type,
 		    ret = ulink_allocate_payload(cmd, scan_size_bytes + 5, PAYLOAD_DIRECTION_OUT);
 		    break;
 	    default:
-		    LOG_ERROR("BUG: ulink_append_scan_cmd() encountered an unknown scan type");
+		    LOG_ERROR("BUG: %s() encountered an unknown scan type", __func__);
 		    ret = ERROR_FAIL;
 		    break;
 	}
@@ -1832,8 +1830,7 @@ static int ulink_post_process_scan(struct ulink_cmd *ulink_cmd)
 		    ret = ERROR_OK;
 		    break;
 	    default:
-		    LOG_ERROR("BUG: ulink_post_process_scan() encountered an unknown"
-			" JTAG scan type");
+		    LOG_ERROR("BUG: %s() encountered an unknown JTAG scan type", __func__);
 		    ret = ERROR_FAIL;
 		    break;
 	}
@@ -1877,8 +1874,7 @@ static int ulink_post_process_queue(struct ulink *device)
 				    break;
 			    default:
 				    ret = ERROR_FAIL;
-				    LOG_ERROR("BUG: ulink_post_process_queue() encountered unknown JTAG "
-					"command type");
+				    LOG_ERROR("BUG: %s() encountered unknown JTAG command type", __func__);
 				    break;
 			}
 

-- 

[PATCH]: dd92ce3b2e jtag: drivers: align switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9055

-- gerrit

commit dd92ce3b2eaa872eae18b05c4c81a71cd1f90bef
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jul 26 18:18:15 2025 +0200

    jtag: drivers: align switch and case statements
    
    The coding style requires the 'case' to be at the same indentation
    level of its 'switch' statement.
    
    Align the code accordingly.
    
    Skip the driver angie that is going to be updated soon with a new
    commit and skip the folder OpenULINK that contains a firmware for
    the dongle.
    
    No changes are reported by
            git log -p -w --ignore-blank-lines --patience
    
    Change-Id: I960a89a45bc9956f98676a019f0d1a652601155f
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/jtag/drivers/amt_jtagaccel.c b/src/jtag/drivers/amt_jtagaccel.c
index d3f8bb61eb..6f1718896e 100644
--- a/src/jtag/drivers/amt_jtagaccel.c
+++ b/src/jtag/drivers/amt_jtagaccel.c
@@ -332,43 +332,43 @@ static int amt_jtagaccel_execute_queue(struct jtag_command *cmd_queue)
 
 	while (cmd) {
 		switch (cmd->type) {
-			case JTAG_RESET:
-				LOG_DEBUG_IO("reset trst: %i srst %i",
-						cmd->cmd.reset->trst,
-						cmd->cmd.reset->srst);
-				if (cmd->cmd.reset->trst == 1)
-					tap_set_state(TAP_RESET);
-				amt_jtagaccel_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
-				break;
-			case JTAG_RUNTEST:
-				LOG_DEBUG_IO("runtest %i cycles, end in %i",
-						cmd->cmd.runtest->num_cycles,
-						cmd->cmd.runtest->end_state);
-				amt_jtagaccel_end_state(cmd->cmd.runtest->end_state);
-				amt_jtagaccel_runtest(cmd->cmd.runtest->num_cycles);
-				break;
-			case JTAG_TLR_RESET:
-				LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
-				amt_jtagaccel_end_state(cmd->cmd.statemove->end_state);
-				amt_jtagaccel_state_move();
-				break;
-			case JTAG_SCAN:
-				LOG_DEBUG_IO("scan end in %i", cmd->cmd.scan->end_state);
-				amt_jtagaccel_end_state(cmd->cmd.scan->end_state);
-				scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
-				type = jtag_scan_type(cmd->cmd.scan);
-				amt_jtagaccel_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
-				if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
-					retval = ERROR_JTAG_QUEUE_FAILED;
-				free(buffer);
-				break;
-			case JTAG_SLEEP:
-				LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
-				jtag_sleep(cmd->cmd.sleep->us);
-				break;
-			default:
-				LOG_ERROR("BUG: unknown JTAG command type encountered");
-				exit(-1);
+		case JTAG_RESET:
+			LOG_DEBUG_IO("reset trst: %i srst %i",
+					cmd->cmd.reset->trst,
+					cmd->cmd.reset->srst);
+			if (cmd->cmd.reset->trst == 1)
+				tap_set_state(TAP_RESET);
+			amt_jtagaccel_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
+			break;
+		case JTAG_RUNTEST:
+			LOG_DEBUG_IO("runtest %i cycles, end in %i",
+					cmd->cmd.runtest->num_cycles,
+					cmd->cmd.runtest->end_state);
+			amt_jtagaccel_end_state(cmd->cmd.runtest->end_state);
+			amt_jtagaccel_runtest(cmd->cmd.runtest->num_cycles);
+			break;
+		case JTAG_TLR_RESET:
+			LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
+			amt_jtagaccel_end_state(cmd->cmd.statemove->end_state);
+			amt_jtagaccel_state_move();
+			break;
+		case JTAG_SCAN:
+			LOG_DEBUG_IO("scan end in %i", cmd->cmd.scan->end_state);
+			amt_jtagaccel_end_state(cmd->cmd.scan->end_state);
+			scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
+			type = jtag_scan_type(cmd->cmd.scan);
+			amt_jtagaccel_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
+			if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
+				retval = ERROR_JTAG_QUEUE_FAILED;
+			free(buffer);
+			break;
+		case JTAG_SLEEP:
+			LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
+			jtag_sleep(cmd->cmd.sleep->us);
+			break;
+		default:
+			LOG_ERROR("BUG: unknown JTAG command type encountered");
+			exit(-1);
 		}
 		cmd = cmd->next;
 	}
diff --git a/src/jtag/drivers/arm-jtag-ew.c b/src/jtag/drivers/arm-jtag-ew.c
index 9d8c592edb..5c0e2ea948 100644
--- a/src/jtag/drivers/arm-jtag-ew.c
+++ b/src/jtag/drivers/arm-jtag-ew.c
@@ -94,69 +94,69 @@ static int armjtagew_execute_queue(struct jtag_command *cmd_queue)
 
 	while (cmd) {
 		switch (cmd->type) {
-			case JTAG_RUNTEST:
-				LOG_DEBUG_IO("runtest %u cycles, end in %i",
-						cmd->cmd.runtest->num_cycles,
-						cmd->cmd.runtest->end_state);
+		case JTAG_RUNTEST:
+			LOG_DEBUG_IO("runtest %u cycles, end in %i",
+					cmd->cmd.runtest->num_cycles,
+					cmd->cmd.runtest->end_state);
 
-				armjtagew_end_state(cmd->cmd.runtest->end_state);
-				armjtagew_runtest(cmd->cmd.runtest->num_cycles);
-				break;
+			armjtagew_end_state(cmd->cmd.runtest->end_state);
+			armjtagew_runtest(cmd->cmd.runtest->num_cycles);
+			break;
 
-			case JTAG_TLR_RESET:
-				LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
+		case JTAG_TLR_RESET:
+			LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
 
-				armjtagew_end_state(cmd->cmd.statemove->end_state);
-				armjtagew_state_move();
-				break;
+			armjtagew_end_state(cmd->cmd.statemove->end_state);
+			armjtagew_state_move();
+			break;
 
-			case JTAG_PATHMOVE:
-				LOG_DEBUG_IO("pathmove: %u states, end in %i",
-						cmd->cmd.pathmove->num_states,
-						cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
+		case JTAG_PATHMOVE:
+			LOG_DEBUG_IO("pathmove: %u states, end in %i",
+					cmd->cmd.pathmove->num_states,
+					cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
 
-				armjtagew_path_move(cmd->cmd.pathmove->num_states,
-						cmd->cmd.pathmove->path);
-				break;
+			armjtagew_path_move(cmd->cmd.pathmove->num_states,
+					cmd->cmd.pathmove->path);
+			break;
 
-			case JTAG_SCAN:
-				LOG_DEBUG_IO("scan end in %i", cmd->cmd.scan->end_state);
+		case JTAG_SCAN:
+			LOG_DEBUG_IO("scan end in %i", cmd->cmd.scan->end_state);
 
-				armjtagew_end_state(cmd->cmd.scan->end_state);
+			armjtagew_end_state(cmd->cmd.scan->end_state);
 
-				scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
-				LOG_DEBUG_IO("scan input, length = %d", scan_size);
+			scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
+			LOG_DEBUG_IO("scan input, length = %d", scan_size);
 
 #ifdef _DEBUG_USB_COMMS_
-				armjtagew_debug_buffer(buffer, (scan_size + 7) / 8);
+			armjtagew_debug_buffer(buffer, (scan_size + 7) / 8);
 #endif
-				type = jtag_scan_type(cmd->cmd.scan);
-				armjtagew_scan(cmd->cmd.scan->ir_scan,
-						type, buffer,
-						scan_size, cmd->cmd.scan);
-				break;
-
-			case JTAG_RESET:
-				LOG_DEBUG_IO("reset trst: %i srst %i",
-						cmd->cmd.reset->trst,
-						cmd->cmd.reset->srst);
-
-				armjtagew_tap_execute();
-
-				if (cmd->cmd.reset->trst == 1)
-					tap_set_state(TAP_RESET);
-				armjtagew_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
-				break;
-
-			case JTAG_SLEEP:
-				LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
-				armjtagew_tap_execute();
-				jtag_sleep(cmd->cmd.sleep->us);
-				break;
-
-			default:
-				LOG_ERROR("BUG: unknown JTAG command type encountered");
-				exit(-1);
+			type = jtag_scan_type(cmd->cmd.scan);
+			armjtagew_scan(cmd->cmd.scan->ir_scan,
+					type, buffer,
+					scan_size, cmd->cmd.scan);
+			break;
+
+		case JTAG_RESET:
+			LOG_DEBUG_IO("reset trst: %i srst %i",
+					cmd->cmd.reset->trst,
+					cmd->cmd.reset->srst);
+
+			armjtagew_tap_execute();
+
+			if (cmd->cmd.reset->trst == 1)
+				tap_set_state(TAP_RESET);
+			armjtagew_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
+			break;
+
+		case JTAG_SLEEP:
+			LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
+			armjtagew_tap_execute();
+			jtag_sleep(cmd->cmd.sleep->us);
+			break;
+
+		default:
+			LOG_ERROR("BUG: unknown JTAG command type encountered");
+			exit(-1);
 		}
 		cmd = cmd->next;
 	}
diff --git a/src/jtag/drivers/bitbang.c b/src/jtag/drivers/bitbang.c
index c2e763ddb3..ebf38c7fa6 100644
--- a/src/jtag/drivers/bitbang.c
+++ b/src/jtag/drivers/bitbang.c
@@ -236,14 +236,14 @@ static int bitbang_scan(bool ir_scan, enum scan_type type, uint8_t *buffer,
 				buffered++;
 			} else {
 				switch (bitbang_interface->read()) {
-					case BB_LOW:
-						buffer[bytec] &= ~bcval;
-						break;
-					case BB_HIGH:
-						buffer[bytec] |= bcval;
-						break;
-					default:
-						return ERROR_FAIL;
+				case BB_LOW:
+					buffer[bytec] &= ~bcval;
+					break;
+				case BB_HIGH:
+					buffer[bytec] |= bcval;
+					break;
+				default:
+					return ERROR_FAIL;
 				}
 			}
 		}
@@ -256,14 +256,14 @@ static int bitbang_scan(bool ir_scan, enum scan_type type, uint8_t *buffer,
 				 bit_cnt == scan_size - 1)) {
 			for (unsigned int i = bit_cnt + 1 - buffered; i <= bit_cnt; i++) {
 				switch (bitbang_interface->read_sample()) {
-					case BB_LOW:
-						buffer[i/8] &= ~(1 << (i % 8));
-						break;
-					case BB_HIGH:
-						buffer[i/8] |= 1 << (i % 8);
-						break;
-					default:
-						return ERROR_FAIL;
+				case BB_LOW:
+					buffer[i / 8] &= ~(1 << (i % 8));
+					break;
+				case BB_HIGH:
+					buffer[i / 8] |= 1 << (i % 8);
+					break;
+				default:
+					return ERROR_FAIL;
 				}
 			}
 			buffered = 0;
@@ -315,64 +315,64 @@ int bitbang_execute_queue(struct jtag_command *cmd_queue)
 
 	while (cmd) {
 		switch (cmd->type) {
-			case JTAG_RUNTEST:
-				LOG_DEBUG_IO("runtest %u cycles, end in %s",
-						cmd->cmd.runtest->num_cycles,
-						tap_state_name(cmd->cmd.runtest->end_state));
-				bitbang_end_state(cmd->cmd.runtest->end_state);
-				if (bitbang_runtest(cmd->cmd.runtest->num_cycles) != ERROR_OK)
-					return ERROR_FAIL;
-				break;
-
-			case JTAG_STABLECLOCKS:
-				/* this is only allowed while in a stable state.  A check for a stable
-				 * state was done in jtag_add_clocks()
-				 */
-				if (bitbang_stableclocks(cmd->cmd.stableclocks->num_cycles) != ERROR_OK)
-					return ERROR_FAIL;
-				break;
-
-			case JTAG_TLR_RESET:
-				LOG_DEBUG_IO("statemove end in %s",
-						tap_state_name(cmd->cmd.statemove->end_state));
-				bitbang_end_state(cmd->cmd.statemove->end_state);
-				if (bitbang_state_move(0) != ERROR_OK)
-					return ERROR_FAIL;
-				break;
-			case JTAG_PATHMOVE:
-				LOG_DEBUG_IO("pathmove: %u states, end in %s",
-						cmd->cmd.pathmove->num_states,
-						tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]));
-				if (bitbang_path_move(cmd->cmd.pathmove) != ERROR_OK)
-					return ERROR_FAIL;
-				break;
-			case JTAG_SCAN:
-				bitbang_end_state(cmd->cmd.scan->end_state);
-				scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
-				LOG_DEBUG_IO("%s scan %d bits; end in %s",
-						(cmd->cmd.scan->ir_scan) ? "IR" : "DR",
-						scan_size,
-					tap_state_name(cmd->cmd.scan->end_state));
-				type = jtag_scan_type(cmd->cmd.scan);
-				if (bitbang_scan(cmd->cmd.scan->ir_scan, type, buffer,
-							scan_size) != ERROR_OK)
-					return ERROR_FAIL;
-				if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
-					retval = ERROR_JTAG_QUEUE_FAILED;
-				free(buffer);
-				break;
-			case JTAG_SLEEP:
-				LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
-				if (bitbang_interface->flush && (bitbang_interface->flush() != ERROR_OK))
-					return ERROR_FAIL;
-				bitbang_sleep(cmd->cmd.sleep->us);
-				break;
-			case JTAG_TMS:
-				retval = bitbang_execute_tms(cmd);
-				break;
-			default:
-				LOG_ERROR("BUG: unknown JTAG command type encountered");
-				exit(-1);
+		case JTAG_RUNTEST:
+			LOG_DEBUG_IO("runtest %u cycles, end in %s",
+					cmd->cmd.runtest->num_cycles,
+					tap_state_name(cmd->cmd.runtest->end_state));
+			bitbang_end_state(cmd->cmd.runtest->end_state);
+			if (bitbang_runtest(cmd->cmd.runtest->num_cycles) != ERROR_OK)
+				return ERROR_FAIL;
+			break;
+
+		case JTAG_STABLECLOCKS:
+			/* this is only allowed while in a stable state.  A check for a stable
+			 * state was done in jtag_add_clocks()
+			 */
+			if (bitbang_stableclocks(cmd->cmd.stableclocks->num_cycles) != ERROR_OK)
+				return ERROR_FAIL;
+			break;
+
+		case JTAG_TLR_RESET:
+			LOG_DEBUG_IO("statemove end in %s",
+					tap_state_name(cmd->cmd.statemove->end_state));
+			bitbang_end_state(cmd->cmd.statemove->end_state);
+			if (bitbang_state_move(0) != ERROR_OK)
+				return ERROR_FAIL;
+			break;
+		case JTAG_PATHMOVE:
+			LOG_DEBUG_IO("pathmove: %u states, end in %s",
+					cmd->cmd.pathmove->num_states,
+					tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]));
+			if (bitbang_path_move(cmd->cmd.pathmove) != ERROR_OK)
+				return ERROR_FAIL;
+			break;
+		case JTAG_SCAN:
+			bitbang_end_state(cmd->cmd.scan->end_state);
+			scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
+			LOG_DEBUG_IO("%s scan %d bits; end in %s",
+					(cmd->cmd.scan->ir_scan) ? "IR" : "DR",
+					scan_size,
+				tap_state_name(cmd->cmd.scan->end_state));
+			type = jtag_scan_type(cmd->cmd.scan);
+			if (bitbang_scan(cmd->cmd.scan->ir_scan, type, buffer,
+						scan_size) != ERROR_OK)
+				return ERROR_FAIL;
+			if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
+				retval = ERROR_JTAG_QUEUE_FAILED;
+			free(buffer);
+			break;
+		case JTAG_SLEEP:
+			LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
+			if (bitbang_interface->flush && (bitbang_interface->flush() != ERROR_OK))
+				return ERROR_FAIL;
+			bitbang_sleep(cmd->cmd.sleep->us);
+			break;
+		case JTAG_TMS:
+			retval = bitbang_execute_tms(cmd);
+			break;
+		default:
+			LOG_ERROR("BUG: unknown JTAG command type encountered");
+			exit(-1);
 		}
 		cmd = cmd->next;
 	}
diff --git a/src/jtag/drivers/buspirate.c b/src/jtag/drivers/buspirate.c
index 4283616adc..7eab94bd0a 100644
--- a/src/jtag/drivers/buspirate.c
+++ b/src/jtag/drivers/buspirate.c
@@ -941,24 +941,24 @@ static void buspirate_swd_set_feature(int fd, char feat, char action)
 	uint8_t tmp[1];
 
 	switch (feat) {
-		case FEATURE_TRST:
-			LOG_DEBUG("Buspirate TRST feature not available in SWD mode");
-			return;
-		case FEATURE_LED:
-			LOG_ERROR("Buspirate LED feature not available in SWD mode");
-			return;
-		case FEATURE_SRST:
-			swd_features = (action == ACTION_ENABLE) ? swd_features | 0x02 : swd_features & 0x0D;
-			break;
-		case FEATURE_PULLUP:
-			swd_features = (action == ACTION_ENABLE) ? swd_features | 0x04 : swd_features & 0x0B;
-			break;
-		case FEATURE_VREG:
-			swd_features = (action == ACTION_ENABLE) ? swd_features | 0x08 : swd_features & 0x07;
-			break;
-		default:
-			LOG_DEBUG("Buspirate unknown feature %d", feat);
-			return;
+	case FEATURE_TRST:
+		LOG_DEBUG("Buspirate TRST feature not available in SWD mode");
+		return;
+	case FEATURE_LED:
+		LOG_ERROR("Buspirate LED feature not available in SWD mode");
+		return;
+	case FEATURE_SRST:
+		swd_features = (action == ACTION_ENABLE) ? swd_features | 0x02 : swd_features & 0x0D;
+		break;
+	case FEATURE_PULLUP:
+		swd_features = (action == ACTION_ENABLE) ? swd_features | 0x04 : swd_features & 0x0B;
+		break;
+	case FEATURE_VREG:
+		swd_features = (action == ACTION_ENABLE) ? swd_features | 0x08 : swd_features & 0x07;
+		break;
+	default:
+		LOG_DEBUG("Buspirate unknown feature %d", feat);
+		return;
 	}
 
 	tmp[0] = CMD_RAW_PERIPH | swd_features;
diff --git a/src/jtag/drivers/cmsis_dap.c b/src/jtag/drivers/cmsis_dap.c
index 2bfcfcc2b0..36d2084e2a 100644
--- a/src/jtag/drivers/cmsis_dap.c
+++ b/src/jtag/drivers/cmsis_dap.c
@@ -1558,38 +1558,38 @@ static void debug_parse_cmsis_buf(const uint8_t *cmd, int cmdlen)
 		printf(" %02x", cmd[i]);
 	printf("\n");
 	switch (cmd[0]) {
-		case CMD_DAP_JTAG_SEQ: {
-			printf("cmsis-dap jtag sequence command %02x (n=%d)\n", cmd[0], cmd[1]);
-			/*
-			 * #1 = number of sequences
-			 * #2 = sequence info 1
-			 * #3...4+n_bytes-1 = sequence 1
-			 * #4+n_bytes = sequence info 2
-			 * #5+n_bytes = sequence 2 (single bit)
-			 */
-			int pos = 2;
-			for (int seq = 0; seq < cmd[1]; ++seq) {
-				uint8_t info = cmd[pos++];
-				int len = info & DAP_JTAG_SEQ_TCK;
-				if (len == 0)
-					len = 64;
-				printf("  sequence %d starting %d: info %02x (len=%d tms=%d read_tdo=%d): ",
-					seq, pos, info, len, info & DAP_JTAG_SEQ_TMS, info & DAP_JTAG_SEQ_TDO);
-				for (int i = 0; i < DIV_ROUND_UP(len, 8); ++i)
-					printf(" %02x", cmd[pos+i]);
-				pos += DIV_ROUND_UP(len, 8);
-				printf("\n");
-			}
-			if (pos != cmdlen) {
-				printf("BUFFER LENGTH MISMATCH looks like %d but %d specified", pos, cmdlen);
-				exit(-1);
-			}
-
-			break;
+	case CMD_DAP_JTAG_SEQ: {
+		printf("cmsis-dap jtag sequence command %02x (n=%d)\n", cmd[0], cmd[1]);
+		/*
+		 * #1 = number of sequences
+		 * #2 = sequence info 1
+		 * #3...4+n_bytes-1 = sequence 1
+		 * #4+n_bytes = sequence info 2
+		 * #5+n_bytes = sequence 2 (single bit)
+		 */
+		int pos = 2;
+		for (int seq = 0; seq < cmd[1]; ++seq) {
+			uint8_t info = cmd[pos++];
+			int len = info & DAP_JTAG_SEQ_TCK;
+			if (len == 0)
+				len = 64;
+			printf("  sequence %d starting %d: info %02x (len=%d tms=%d read_tdo=%d): ",
+				seq, pos, info, len, info & DAP_JTAG_SEQ_TMS, info & DAP_JTAG_SEQ_TDO);
+			for (int i = 0; i < DIV_ROUND_UP(len, 8); ++i)
+				printf(" %02x", cmd[pos + i]);
+			pos += DIV_ROUND_UP(len, 8);
+			printf("\n");
 		}
-		default:
-			LOG_DEBUG("unknown cmsis-dap command %02x", cmd[1]);
-			break;
+		if (pos != cmdlen) {
+			printf("BUFFER LENGTH MISMATCH looks like %d but %d specified", pos, cmdlen);
+			exit(-1);
+		}
+
+		break;
+	}
+	default:
+		LOG_DEBUG("unknown cmsis-dap command %02x", cmd[1]);
+		break;
 	}
 }
 #endif
@@ -1930,32 +1930,32 @@ static void cmsis_dap_execute_tms(struct jtag_command *cmd)
 static void cmsis_dap_execute_command(struct jtag_command *cmd)
 {
 	switch (cmd->type) {
-		case JTAG_SLEEP:
-			cmsis_dap_flush();
-			cmsis_dap_execute_sleep(cmd);
-			break;
-		case JTAG_TLR_RESET:
-			cmsis_dap_flush();
-			cmsis_dap_execute_tlr_reset(cmd);
-			break;
-		case JTAG_SCAN:
-			cmsis_dap_execute_scan(cmd);
-			break;
-		case JTAG_PATHMOVE:
-			cmsis_dap_execute_pathmove(cmd);
-			break;
-		case JTAG_RUNTEST:
-			cmsis_dap_execute_runtest(cmd);
-			break;
-		case JTAG_STABLECLOCKS:
-			cmsis_dap_execute_stableclocks(cmd);
-			break;
-		case JTAG_TMS:
-			cmsis_dap_execute_tms(cmd);
-			break;
-		default:
-			LOG_ERROR("BUG: unknown JTAG command type 0x%X encountered", cmd->type);
-			exit(-1);
+	case JTAG_SLEEP:
+		cmsis_dap_flush();
+		cmsis_dap_execute_sleep(cmd);
+		break;
+	case JTAG_TLR_RESET:
+		cmsis_dap_flush();
+		cmsis_dap_execute_tlr_reset(cmd);
+		break;
+	case JTAG_SCAN:
+		cmsis_dap_execute_scan(cmd);
+		break;
+	case JTAG_PATHMOVE:
+		cmsis_dap_execute_pathmove(cmd);
+		break;
+	case JTAG_RUNTEST:
+		cmsis_dap_execute_runtest(cmd);
+		break;
+	case JTAG_STABLECLOCKS:
+		cmsis_dap_execute_stableclocks(cmd);
+		break;
+	case JTAG_TMS:
+		cmsis_dap_execute_tms(cmd);
+		break;
+	default:
+		LOG_ERROR("BUG: unknown JTAG command type 0x%X encountered", cmd->type);
+		exit(-1);
 	}
 }
 
diff --git a/src/jtag/drivers/dmem.c b/src/jtag/drivers/dmem.c
index c1eb5b80dd..0f1b582990 100644
--- a/src/jtag/drivers/dmem.c
+++ b/src/jtag/drivers/dmem.c
@@ -118,41 +118,41 @@ static int dmem_emu_ap_q_read(unsigned int ap_idx, unsigned int reg, uint32_t *d
 	struct dmem_emu_ap_info *ap_info = &dmem_emu_ap_list[ap_idx];
 
 	switch (reg) {
-		case ADIV5_MEM_AP_REG_CSW:
-			*data = ap_info->apbap_csw;
-			break;
-		case ADIV5_MEM_AP_REG_TAR:
-			*data = ap_info->apbap_tar;
-			break;
-		case ADIV5_MEM_AP_REG_CFG:
-			*data = 0;
-			break;
-		case ADIV5_MEM_AP_REG_BASE:
-			*data = 0;
-			break;
-		case ADIV5_AP_REG_IDR:
-			*data = 0;
-			break;
-		case ADIV5_MEM_AP_REG_BD0:
-		case ADIV5_MEM_AP_REG_BD1:
-		case ADIV5_MEM_AP_REG_BD2:
-		case ADIV5_MEM_AP_REG_BD3:
-			addr = (ap_info->apbap_tar & ~0xf) + (reg & 0x0C);
-
-			*data = dmem_emu_get_ap_reg(addr);
-
-			break;
-		case ADIV5_MEM_AP_REG_DRW:
-			addr = ap_info->apbap_tar;
-
-			*data = dmem_emu_get_ap_reg(addr);
-
-			ap_info->apbap_tar += dmem_memap_tar_inc(ap_info->apbap_csw);
-			break;
-		default:
-			LOG_INFO("%s: Unknown reg: 0x%02x", __func__, reg);
-			ret = ERROR_FAIL;
-			break;
+	case ADIV5_MEM_AP_REG_CSW:
+		*data = ap_info->apbap_csw;
+		break;
+	case ADIV5_MEM_AP_REG_TAR:
+		*data = ap_info->apbap_tar;
+		break;
+	case ADIV5_MEM_AP_REG_CFG:
+		*data = 0;
+		break;
+	case ADIV5_MEM_AP_REG_BASE:
+		*data = 0;
+		break;
+	case ADIV5_AP_REG_IDR:
+		*data = 0;
+		break;
+	case ADIV5_MEM_AP_REG_BD0:
+	case ADIV5_MEM_AP_REG_BD1:
+	case ADIV5_MEM_AP_REG_BD2:
+	case ADIV5_MEM_AP_REG_BD3:
+		addr = (ap_info->apbap_tar & ~0xf) + (reg & 0x0C);
+
+		*data = dmem_emu_get_ap_reg(addr);
+
+		break;
+	case ADIV5_MEM_AP_REG_DRW:
+		addr = ap_info->apbap_tar;
+
+		*data = dmem_emu_get_ap_reg(addr);
+
+		ap_info->apbap_tar += dmem_memap_tar_inc(ap_info->apbap_csw);
+		break;
+	default:
+		LOG_INFO("%s: Unknown reg: 0x%02x", __func__, reg);
+		ret = ERROR_FAIL;
+		break;
 	}
 
 	/* Track the last error code. */
@@ -169,46 +169,46 @@ static int dmem_emu_ap_q_write(unsigned int ap_idx, unsigned int reg, uint32_t d
 	struct dmem_emu_ap_info *ap_info = &dmem_emu_ap_list[ap_idx];
 
 	switch (reg) {
-		case ADIV5_MEM_AP_REG_CSW:
-			/*
-			 * This implementation only supports 32-bit accesses.
-			 * Force this by ensuring CSW_SIZE field indicates 32-BIT.
-			 */
-			ap_info->apbap_csw = ((data & ~CSW_SIZE_MASK) | CSW_32BIT);
-			break;
-		case ADIV5_MEM_AP_REG_TAR:
-			/*
-			 * This implementation only supports 32-bit accesses.
-			 * Force LS 2-bits of TAR to 00b
-			 */
-			ap_info->apbap_tar = (data & ~0x3);
-			break;
-
-		case ADIV5_MEM_AP_REG_CFG:
-		case ADIV5_MEM_AP_REG_BASE:
-		case ADIV5_AP_REG_IDR:
-			/* We don't use this, so we don't need to store */
-			break;
-
-		case ADIV5_MEM_AP_REG_BD0:
-		case ADIV5_MEM_AP_REG_BD1:
-		case ADIV5_MEM_AP_REG_BD2:
-		case ADIV5_MEM_AP_REG_BD3:
-			addr = (ap_info->apbap_tar & ~0xf) + (reg & 0x0C);
-
-			dmem_emu_set_ap_reg(addr, data);
-
-			break;
-		case ADIV5_MEM_AP_REG_DRW:
-			addr = ap_info->apbap_tar;
-			dmem_emu_set_ap_reg(addr, data);
-
-			ap_info->apbap_tar += dmem_memap_tar_inc(ap_info->apbap_csw);
-			break;
-		default:
-			LOG_INFO("%s: Unknown reg: 0x%02x", __func__, reg);
-			ret = EINVAL;
-			break;
+	case ADIV5_MEM_AP_REG_CSW:
+		/*
+		 * This implementation only supports 32-bit accesses.
+		 * Force this by ensuring CSW_SIZE field indicates 32-BIT.
+		 */
+		ap_info->apbap_csw = ((data & ~CSW_SIZE_MASK) | CSW_32BIT);
+		break;
+	case ADIV5_MEM_AP_REG_TAR:
+		/*
+		 * This implementation only supports 32-bit accesses.
+		 * Force LS 2-bits of TAR to 00b
+		 */
+		ap_info->apbap_tar = (data & ~0x3);
+		break;
+
+	case ADIV5_MEM_AP_REG_CFG:
+	case ADIV5_MEM_AP_REG_BASE:
+	case ADIV5_AP_REG_IDR:
+		/* We don't use this, so we don't need to store */
+		break;
+
+	case ADIV5_MEM_AP_REG_BD0:
+	case ADIV5_MEM_AP_REG_BD1:
+	case ADIV5_MEM_AP_REG_BD2:
+	case ADIV5_MEM_AP_REG_BD3:
+		addr = (ap_info->apbap_tar & ~0xf) + (reg & 0x0C);
+
+		dmem_emu_set_ap_reg(addr, data);
+
+		break;
+	case ADIV5_MEM_AP_REG_DRW:
+		addr = ap_info->apbap_tar;
+		dmem_emu_set_ap_reg(addr, data);
+
+		ap_info->apbap_tar += dmem_memap_tar_inc(ap_info->apbap_csw);
+		break;
+	default:
+		LOG_INFO("%s: Unknown reg: 0x%02x", __func__, reg);
+		ret = EINVAL;
+		break;
 	}
 
 	/* Track the last error code. */
@@ -242,13 +242,13 @@ static int dmem_dp_q_read(struct adiv5_dap *dap, unsigned int reg, uint32_t *dat
 		return ERROR_OK;
 
 	switch (reg) {
-		case DP_CTRL_STAT:
-			*data = CDBGPWRUPACK | CSYSPWRUPACK;
-			break;
+	case DP_CTRL_STAT:
+		*data = CDBGPWRUPACK | CSYSPWRUPACK;
+		break;
 
-		default:
-			*data = 0;
-			break;
+	default:
+		*data = 0;
+		break;
 	}
 
 	return ERROR_OK;
diff --git a/src/jtag/drivers/ft232r.c b/src/jtag/drivers/ft232r.c
index 8f7ae13d6c..5bd934c386 100644
--- a/src/jtag/drivers/ft232r.c
+++ b/src/jtag/drivers/ft232r.c
@@ -818,71 +818,71 @@ static int syncbb_execute_queue(struct jtag_command *cmd_queue)
 
 	while (cmd) {
 		switch (cmd->type) {
-			case JTAG_RESET:
-				LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
-
-				if (cmd->cmd.reset->trst == 1 ||
-						(cmd->cmd.reset->srst &&
-						 (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
-					tap_set_state(TAP_RESET);
-
-				ft232r_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
-				break;
-
-			case JTAG_RUNTEST:
-				LOG_DEBUG_IO("runtest %u cycles, end in %s", cmd->cmd.runtest->num_cycles,
-					tap_state_name(cmd->cmd.runtest->end_state));
-
-				syncbb_end_state(cmd->cmd.runtest->end_state);
-				syncbb_runtest(cmd->cmd.runtest->num_cycles);
-				break;
-
-			case JTAG_STABLECLOCKS:
-				/* this is only allowed while in a stable state.  A check for a stable
-				 * state was done in jtag_add_clocks()
-				 */
-				syncbb_stableclocks(cmd->cmd.stableclocks->num_cycles);
-				break;
-
-			case JTAG_TLR_RESET: /* renamed from JTAG_STATEMOVE */
-				LOG_DEBUG_IO("statemove end in %s", tap_state_name(cmd->cmd.statemove->end_state));
-
-				syncbb_end_state(cmd->cmd.statemove->end_state);
-				syncbb_state_move(0);
-				break;
-
-			case JTAG_PATHMOVE:
-				LOG_DEBUG_IO("pathmove: %u states, end in %s", cmd->cmd.pathmove->num_states,
-					tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]));
-
-				syncbb_path_move(cmd->cmd.pathmove);
-				break;
-
-			case JTAG_SCAN:
-				LOG_DEBUG_IO("%s scan end in %s",  (cmd->cmd.scan->ir_scan) ? "IR" : "DR",
-					tap_state_name(cmd->cmd.scan->end_state));
-
-				syncbb_end_state(cmd->cmd.scan->end_state);
-				scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
-				type = jtag_scan_type(cmd->cmd.scan);
-				syncbb_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
-				if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
-					retval = ERROR_JTAG_QUEUE_FAILED;
-				free(buffer);
-				break;
-
-			case JTAG_SLEEP:
-				LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
-
-				jtag_sleep(cmd->cmd.sleep->us);
-				break;
-
-			case JTAG_TMS:
-				retval = syncbb_execute_tms(cmd);
-				break;
-			default:
-				LOG_ERROR("BUG: unknown JTAG command type encountered");
-				exit(-1);
+		case JTAG_RESET:
+			LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
+
+			if (cmd->cmd.reset->trst == 1 ||
+					(cmd->cmd.reset->srst &&
+					 (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
+				tap_set_state(TAP_RESET);
+
+			ft232r_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
+			break;
+
+		case JTAG_RUNTEST:
+			LOG_DEBUG_IO("runtest %u cycles, end in %s", cmd->cmd.runtest->num_cycles,
+				tap_state_name(cmd->cmd.runtest->end_state));
+
+			syncbb_end_state(cmd->cmd.runtest->end_state);
+			syncbb_runtest(cmd->cmd.runtest->num_cycles);
+			break;
+
+		case JTAG_STABLECLOCKS:
+			/* this is only allowed while in a stable state.  A check for a stable
+			 * state was done in jtag_add_clocks()
+			 */
+			syncbb_stableclocks(cmd->cmd.stableclocks->num_cycles);
+			break;
+
+		case JTAG_TLR_RESET: /* renamed from JTAG_STATEMOVE */
+			LOG_DEBUG_IO("statemove end in %s", tap_state_name(cmd->cmd.statemove->end_state));
+
+			syncbb_end_state(cmd->cmd.statemove->end_state);
+			syncbb_state_move(0);
+			break;
+
+		case JTAG_PATHMOVE:
+			LOG_DEBUG_IO("pathmove: %u states, end in %s", cmd->cmd.pathmove->num_states,
+				tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]));
+
+			syncbb_path_move(cmd->cmd.pathmove);
+			break;
+
+		case JTAG_SCAN:
+			LOG_DEBUG_IO("%s scan end in %s",  (cmd->cmd.scan->ir_scan) ? "IR" : "DR",
+				tap_state_name(cmd->cmd.scan->end_state));
+
+			syncbb_end_state(cmd->cmd.scan->end_state);
+			scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
+			type = jtag_scan_type(cmd->cmd.scan);
+			syncbb_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
+			if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
+				retval = ERROR_JTAG_QUEUE_FAILED;
+			free(buffer);
+			break;
+
+		case JTAG_SLEEP:
+			LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
+
+			jtag_sleep(cmd->cmd.sleep->us);
+			break;
+
+		case JTAG_TMS:
+			retval = syncbb_execute_tms(cmd);
+			break;
+		default:
+			LOG_ERROR("BUG: unknown JTAG command type encountered");
+			exit(-1);
 		}
 		if (ft232r_output_len > 0)
 			ft232r_send_recv();
diff --git a/src/jtag/drivers/ftdi.c b/src/jtag/drivers/ftdi.c
index a8f6f60159..00b3d198b6 100644
--- a/src/jtag/drivers/ftdi.c
+++ b/src/jtag/drivers/ftdi.c
@@ -597,30 +597,30 @@ static void ftdi_execute_stableclocks(struct jtag_command *cmd)
 static void ftdi_execute_command(struct jtag_command *cmd)
 {
 	switch (cmd->type) {
-		case JTAG_RUNTEST:
-			ftdi_execute_runtest(cmd);
-			break;
-		case JTAG_TLR_RESET:
-			ftdi_execute_statemove(cmd);
-			break;
-		case JTAG_PATHMOVE:
-			ftdi_execute_pathmove(cmd);
-			break;
-		case JTAG_SCAN:
-			ftdi_execute_scan(cmd);
-			break;
-		case JTAG_SLEEP:
-			ftdi_execute_sleep(cmd);
-			break;
-		case JTAG_STABLECLOCKS:
-			ftdi_execute_stableclocks(cmd);
-			break;
-		case JTAG_TMS:
-			ftdi_execute_tms(cmd);
-			break;
-		default:
-			LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd->type);
-			break;
+	case JTAG_RUNTEST:
+		ftdi_execute_runtest(cmd);
+		break;
+	case JTAG_TLR_RESET:
+		ftdi_execute_statemove(cmd);
+		break;
+	case JTAG_PATHMOVE:
+		ftdi_execute_pathmove(cmd);
+		break;
+	case JTAG_SCAN:
+		ftdi_execute_scan(cmd);
+		break;
+	case JTAG_SLEEP:
+		ftdi_execute_sleep(cmd);
+		break;
+	case JTAG_STABLECLOCKS:
+		ftdi_execute_stableclocks(cmd);
+		break;
+	case JTAG_TMS:
+		ftdi_execute_tms(cmd);
+		break;
+	default:
+		LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd->type);
+		break;
 	}
 }
 
diff --git a/src/jtag/drivers/gw16012.c b/src/jtag/drivers/gw16012.c
index 98f7754223..f6ae684f77 100644
--- a/src/jtag/drivers/gw16012.c
+++ b/src/jtag/drivers/gw16012.c
@@ -284,46 +284,46 @@ static int gw16012_execute_queue(struct jtag_command *cmd_queue)
 
 	while (cmd) {
 		switch (cmd->type) {
-			case JTAG_RESET:
-				LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
-				if (cmd->cmd.reset->trst == 1)
-					tap_set_state(TAP_RESET);
-				gw16012_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
-				break;
-			case JTAG_RUNTEST:
-				LOG_DEBUG_IO("runtest %u cycles, end in %i", cmd->cmd.runtest->num_cycles,
-						cmd->cmd.runtest->end_state);
-				gw16012_end_state(cmd->cmd.runtest->end_state);
-				gw16012_runtest(cmd->cmd.runtest->num_cycles);
-				break;
-			case JTAG_TLR_RESET:
-				LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
-				gw16012_end_state(cmd->cmd.statemove->end_state);
-				gw16012_state_move();
-				break;
-			case JTAG_PATHMOVE:
-				LOG_DEBUG_IO("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states,
-						cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
-				gw16012_path_move(cmd->cmd.pathmove);
-				break;
-			case JTAG_SCAN:
-				gw16012_end_state(cmd->cmd.scan->end_state);
-				scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
-				type = jtag_scan_type(cmd->cmd.scan);
-				LOG_DEBUG_IO("%s scan (%i) %i bit end in %i", (cmd->cmd.scan->ir_scan) ? "ir" : "dr",
-					type, scan_size, cmd->cmd.scan->end_state);
-				gw16012_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
-				if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
-					retval = ERROR_JTAG_QUEUE_FAILED;
-				free(buffer);
-				break;
-			case JTAG_SLEEP:
-				LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
-				jtag_sleep(cmd->cmd.sleep->us);
-				break;
-			default:
-				LOG_ERROR("BUG: unknown JTAG command type encountered");
-				exit(-1);
+		case JTAG_RESET:
+			LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
+			if (cmd->cmd.reset->trst == 1)
+				tap_set_state(TAP_RESET);
+			gw16012_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
+			break;
+		case JTAG_RUNTEST:
+			LOG_DEBUG_IO("runtest %u cycles, end in %i", cmd->cmd.runtest->num_cycles,
+					cmd->cmd.runtest->end_state);
+			gw16012_end_state(cmd->cmd.runtest->end_state);
+			gw16012_runtest(cmd->cmd.runtest->num_cycles);
+			break;
+		case JTAG_TLR_RESET:
+			LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
+			gw16012_end_state(cmd->cmd.statemove->end_state);
+			gw16012_state_move();
+			break;
+		case JTAG_PATHMOVE:
+			LOG_DEBUG_IO("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states,
+					cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
+			gw16012_path_move(cmd->cmd.pathmove);
+			break;
+		case JTAG_SCAN:
+			gw16012_end_state(cmd->cmd.scan->end_state);
+			scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
+			type = jtag_scan_type(cmd->cmd.scan);
+			LOG_DEBUG_IO("%s scan (%i) %i bit end in %i", (cmd->cmd.scan->ir_scan) ? "ir" : "dr",
+				type, scan_size, cmd->cmd.scan->end_state);
+			gw16012_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
+			if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
+				retval = ERROR_JTAG_QUEUE_FAILED;
+			free(buffer);
+			break;
+		case JTAG_SLEEP:
+			LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
+			jtag_sleep(cmd->cmd.sleep->us);
+			break;
+		default:
+			LOG_ERROR("BUG: unknown JTAG command type encountered");
+			exit(-1);
 		}
 		cmd = cmd->next;
 	}
diff --git a/src/jtag/drivers/jlink.c b/src/jtag/drivers/jlink.c
index f6bb3099d6..3c66f9a169 100644
--- a/src/jtag/drivers/jlink.c
+++ b/src/jtag/drivers/jlink.c
@@ -249,27 +249,27 @@ static void jlink_execute_sleep(struct jtag_command *cmd)
 static int jlink_execute_command(struct jtag_command *cmd)
 {
 	switch (cmd->type) {
-		case JTAG_STABLECLOCKS:
-			jlink_execute_stableclocks(cmd);
-			break;
-		case JTAG_RUNTEST:
-			jlink_execute_runtest(cmd);
-			break;
-		case JTAG_TLR_RESET:
-			jlink_execute_statemove(cmd);
-			break;
-		case JTAG_PATHMOVE:
-			jlink_execute_pathmove(cmd);
-			break;
-		case JTAG_SCAN:
-			jlink_execute_scan(cmd);
-			break;
-		case JTAG_SLEEP:
-			jlink_execute_sleep(cmd);
-			break;
-		default:
-			LOG_ERROR("BUG: Unknown JTAG command type encountered");
-			return ERROR_JTAG_QUEUE_FAILED;
+	case JTAG_STABLECLOCKS:
+		jlink_execute_stableclocks(cmd);
+		break;
+	case JTAG_RUNTEST:
+		jlink_execute_runtest(cmd);
+		break;
+	case JTAG_TLR_RESET:
+		jlink_execute_statemove(cmd);
+		break;
+	case JTAG_PATHMOVE:
+		jlink_execute_pathmove(cmd);
+		break;
+	case JTAG_SCAN:
+		jlink_execute_scan(cmd);
+		break;
+	case JTAG_SLEEP:
+		jlink_execute_sleep(cmd);
+		break;
+	default:
+		LOG_ERROR("BUG: Unknown JTAG command type encountered");
+		return ERROR_JTAG_QUEUE_FAILED;
 	}
 
 	return ERROR_OK;
@@ -2118,44 +2118,44 @@ static int jlink_swd_switch_seq(enum swd_special_seq seq)
 	unsigned int s_len;
 
 	switch (seq) {
-		case LINE_RESET:
-			LOG_DEBUG_IO("SWD line reset");
-			s = swd_seq_line_reset;
-			s_len = swd_seq_line_reset_len;
-			break;
-		case JTAG_TO_SWD:
-			LOG_DEBUG("JTAG-to-SWD");
-			s = swd_seq_jtag_to_swd;
-			s_len = swd_seq_jtag_to_swd_len;
-			break;
-		case JTAG_TO_DORMANT:
-			LOG_DEBUG("JTAG-to-DORMANT");
-			s = swd_seq_jtag_to_dormant;
-			s_len = swd_seq_jtag_to_dormant_len;
-			break;
-		case SWD_TO_JTAG:
-			LOG_DEBUG("SWD-to-JTAG");
-			s = swd_seq_swd_to_jtag;
-			s_len = swd_seq_swd_to_jtag_len;
-			break;
-		case SWD_TO_DORMANT:
-			LOG_DEBUG("SWD-to-DORMANT");
-			s = swd_seq_swd_to_dormant;
-			s_len = swd_seq_swd_to_dormant_len;
-			break;
-		case DORMANT_TO_SWD:
-			LOG_DEBUG("DORMANT-to-SWD");
-			s = swd_seq_dormant_to_swd;
-			s_len = swd_seq_dormant_to_swd_len;
-			break;
-		case DORMANT_TO_JTAG:
-			LOG_DEBUG("DORMANT-to-JTAG");
-			s = swd_seq_dormant_to_jtag;
-			s_len = swd_seq_dormant_to_jtag_len;
-			break;
-		default:
-			LOG_ERROR("Sequence %d not supported", seq);
-			return ERROR_FAIL;
+	case LINE_RESET:
+		LOG_DEBUG_IO("SWD line reset");
+		s = swd_seq_line_reset;
+		s_len = swd_seq_line_reset_len;
+		break;
+	case JTAG_TO_SWD:
+		LOG_DEBUG("JTAG-to-SWD");
+		s = swd_seq_jtag_to_swd;
+		s_len = swd_seq_jtag_to_swd_len;
+		break;
+	case JTAG_TO_DORMANT:
+		LOG_DEBUG("JTAG-to-DORMANT");
+		s = swd_seq_jtag_to_dormant;
+		s_len = swd_seq_jtag_to_dormant_len;
+		break;
+	case SWD_TO_JTAG:
+		LOG_DEBUG("SWD-to-JTAG");
+		s = swd_seq_swd_to_jtag;
+		s_len = swd_seq_swd_to_jtag_len;
+		break;
+	case SWD_TO_DORMANT:
+		LOG_DEBUG("SWD-to-DORMANT");
+		s = swd_seq_swd_to_dormant;
+		s_len = swd_seq_swd_to_dormant_len;
+		break;
+	case DORMANT_TO_SWD:
+		LOG_DEBUG("DORMANT-to-SWD");
+		s = swd_seq_dormant_to_swd;
+		s_len = swd_seq_dormant_to_swd_len;
+		break;
+	case DORMANT_TO_JTAG:
+		LOG_DEBUG("DORMANT-to-JTAG");
+		s = swd_seq_dormant_to_jtag;
+		s_len = swd_seq_dormant_to_jtag_len;
+		break;
+	default:
+		LOG_ERROR("Sequence %d not supported", seq);
+		return ERROR_FAIL;
 	}
 
 	jlink_queue_data_out(s, s_len);
diff --git a/src/jtag/drivers/kitprog.c b/src/jtag/drivers/kitprog.c
index 2bb4d17da2..f79e2dca70 100644
--- a/src/jtag/drivers/kitprog.c
+++ b/src/jtag/drivers/kitprog.c
@@ -646,24 +646,24 @@ static void kitprog_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay
 static int kitprog_swd_switch_seq(enum swd_special_seq seq)
 {
 	switch (seq) {
-		case JTAG_TO_SWD:
-			if (kitprog_handle->supports_jtag_to_swd) {
-				LOG_DEBUG("JTAG to SWD");
-				if (kitprog_swd_seq(SEQUENCE_JTAG_TO_SWD) != ERROR_OK)
-					return ERROR_FAIL;
-				break;
-			}
-			LOG_DEBUG("JTAG to SWD not supported");
-			/* Fall through to fix target reset issue */
-			/* fallthrough */
-		case LINE_RESET:
-			LOG_DEBUG("SWD line reset");
-			if (kitprog_swd_seq(SEQUENCE_LINE_RESET) != ERROR_OK)
+	case JTAG_TO_SWD:
+		if (kitprog_handle->supports_jtag_to_swd) {
+			LOG_DEBUG("JTAG to SWD");
+			if (kitprog_swd_seq(SEQUENCE_JTAG_TO_SWD) != ERROR_OK)
 				return ERROR_FAIL;
 			break;
-		default:
-			LOG_ERROR("Sequence %d not supported.", seq);
+		}
+		LOG_DEBUG("JTAG to SWD not supported");
+		/* Fall through to fix target reset issue */
+		/* fallthrough */
+	case LINE_RESET:
+		LOG_DEBUG("SWD line reset");
+		if (kitprog_swd_seq(SEQUENCE_LINE_RESET) != ERROR_OK)
 			return ERROR_FAIL;
+		break;
+	default:
+		LOG_ERROR("Sequence %d not supported.", seq);
+		return ERROR_FAIL;
 	}
 
 	return ERROR_OK;
diff --git a/src/jtag/drivers/opendous.c b/src/jtag/drivers/opendous.c
index 04626cb1e5..4b5981ab5d 100644
--- a/src/jtag/drivers/opendous.c
+++ b/src/jtag/drivers/opendous.c
@@ -173,26 +173,26 @@ COMMAND_HANDLER(opendous_handle_opendous_info_command)
 COMMAND_HANDLER(opendous_handle_opendous_hw_jtag_command)
 {
 	switch (CMD_ARGC) {
-		case 0:
-			command_print(CMD, "opendous hw jtag  %i", opendous_hw_jtag_version);
+	case 0:
+		command_print(CMD, "opendous hw jtag  %i", opendous_hw_jtag_version);
+		break;
+
+	case 1: {
+		int request_version = atoi(CMD_ARGV[0]);
+		switch (request_version) {
+		case 2:
+		case 3:
+			opendous_hw_jtag_version = request_version;
 			break;
 
-		case 1: {
-			int request_version = atoi(CMD_ARGV[0]);
-			switch (request_version) {
-				case 2:
-				case 3:
-					opendous_hw_jtag_version = request_version;
-					break;
-
-			default:
-				return ERROR_COMMAND_SYNTAX_ERROR;
-			}
-			break;
-		}
-
 		default:
 			return ERROR_COMMAND_SYNTAX_ERROR;
+		}
+		break;
+	}
+
+	default:
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
 	return ERROR_OK;
@@ -248,66 +248,66 @@ static int opendous_execute_queue(struct jtag_command *cmd_queue)
 
 	while (cmd) {
 		switch (cmd->type) {
-			case JTAG_RUNTEST:
-				LOG_DEBUG_IO("runtest %u cycles, end in %i", cmd->cmd.runtest->num_cycles,
-					cmd->cmd.runtest->end_state);
+		case JTAG_RUNTEST:
+			LOG_DEBUG_IO("runtest %u cycles, end in %i", cmd->cmd.runtest->num_cycles,
+				cmd->cmd.runtest->end_state);
 
-				if (cmd->cmd.runtest->end_state != -1)
-					opendous_end_state(cmd->cmd.runtest->end_state);
-				opendous_runtest(cmd->cmd.runtest->num_cycles);
-				break;
+			if (cmd->cmd.runtest->end_state != -1)
+				opendous_end_state(cmd->cmd.runtest->end_state);
+			opendous_runtest(cmd->cmd.runtest->num_cycles);
+			break;
 
-			case JTAG_TLR_RESET:
-				LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
+		case JTAG_TLR_RESET:
+			LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
 
-				if (cmd->cmd.statemove->end_state != -1)
-					opendous_end_state(cmd->cmd.statemove->end_state);
-				opendous_state_move();
-				break;
+			if (cmd->cmd.statemove->end_state != -1)
+				opendous_end_state(cmd->cmd.statemove->end_state);
+			opendous_state_move();
+			break;
 
-			case JTAG_PATHMOVE:
-				LOG_DEBUG_IO("pathmove: %u states, end in %i",
-					cmd->cmd.pathmove->num_states,
-					cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
+		case JTAG_PATHMOVE:
+			LOG_DEBUG_IO("pathmove: %u states, end in %i",
+				cmd->cmd.pathmove->num_states,
+				cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
 
-				opendous_path_move(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path);
-				break;
+			opendous_path_move(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path);
+			break;
 
-			case JTAG_SCAN:
-				LOG_DEBUG_IO("scan end in %i", cmd->cmd.scan->end_state);
+		case JTAG_SCAN:
+			LOG_DEBUG_IO("scan end in %i", cmd->cmd.scan->end_state);
 
-				if (cmd->cmd.scan->end_state != -1)
-					opendous_end_state(cmd->cmd.scan->end_state);
+			if (cmd->cmd.scan->end_state != -1)
+				opendous_end_state(cmd->cmd.scan->end_state);
 
-				scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
-				LOG_DEBUG_IO("scan input, length = %d", scan_size);
+			scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
+			LOG_DEBUG_IO("scan input, length = %d", scan_size);
 
 #ifdef _DEBUG_USB_COMMS_
-				opendous_debug_buffer(buffer, (scan_size + 7) / 8);
+			opendous_debug_buffer(buffer, (scan_size + 7) / 8);
 #endif
-				type = jtag_scan_type(cmd->cmd.scan);
-				opendous_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size, cmd->cmd.scan);
-				break;
+			type = jtag_scan_type(cmd->cmd.scan);
+			opendous_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size, cmd->cmd.scan);
+			break;
 
-			case JTAG_RESET:
-				LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
+		case JTAG_RESET:
+			LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 
-				opendous_tap_execute();
+			opendous_tap_execute();
 
-				if (cmd->cmd.reset->trst == 1)
-					tap_set_state(TAP_RESET);
-				opendous_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
-				break;
+			if (cmd->cmd.reset->trst == 1)
+				tap_set_state(TAP_RESET);
+			opendous_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
+			break;
 
-			case JTAG_SLEEP:
-				LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
-				opendous_tap_execute();
-				jtag_sleep(cmd->cmd.sleep->us);
-				break;
+		case JTAG_SLEEP:
+			LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
+			opendous_tap_execute();
+			jtag_sleep(cmd->cmd.sleep->us);
+			break;
 
-			default:
-				LOG_ERROR("BUG: unknown JTAG command type encountered");
-				exit(-1);
+		default:
+			LOG_ERROR("BUG: unknown JTAG command type encountered");
+			exit(-1);
 		}
 		cmd = cmd->next;
 	}
diff --git a/src/jtag/drivers/openjtag.c b/src/jtag/drivers/openjtag.c
index 943ad854e8..d45a1c6a97 100644
--- a/src/jtag/drivers/openjtag.c
+++ b/src/jtag/drivers/openjtag.c
@@ -135,36 +135,36 @@ static void openjtag_debug_buffer(uint8_t *buffer, int length, uint8_t type)
 	int j;
 
 	switch (type) {
+	case DEBUG_TYPE_READ:
+		sprintf(line, "USB READ %d bytes", length);
+		break;
+	case DEBUG_TYPE_WRITE:
+		sprintf(line, "USB WRITE %d bytes", length);
+		break;
+	case DEBUG_TYPE_OCD_READ:
+		sprintf(line, "TO OpenOCD %d bytes", length);
+		break;
+	case DEBUG_TYPE_BUFFER:
+		sprintf(line, "Buffer %d bytes", length);
+		break;
+	}
+
+	LOG_DEBUG("%s", line);
+
+	for (i = 0; i < length; i += LINE_LEN) {
+		switch (type) {
 		case DEBUG_TYPE_READ:
-			sprintf(line, "USB READ %d bytes", length);
+			sprintf(line, "USB READ: %04x", i);
 			break;
 		case DEBUG_TYPE_WRITE:
-			sprintf(line, "USB WRITE %d bytes", length);
+			sprintf(line, "USB WRITE: %04x", i);
 			break;
 		case DEBUG_TYPE_OCD_READ:
-			sprintf(line, "TO OpenOCD %d bytes", length);
+			sprintf(line, "TO OpenOCD: %04x", i);
 			break;
 		case DEBUG_TYPE_BUFFER:
-			sprintf(line, "Buffer %d bytes", length);
+			sprintf(line, "BUFFER: %04x", i);
 			break;
-	}
-
-	LOG_DEBUG("%s", line);
-
-	for (i = 0; i < length; i += LINE_LEN) {
-		switch (type) {
-			case DEBUG_TYPE_READ:
-				sprintf(line, "USB READ: %04x", i);
-				break;
-			case DEBUG_TYPE_WRITE:
-				sprintf(line, "USB WRITE: %04x", i);
-				break;
-			case DEBUG_TYPE_OCD_READ:
-				sprintf(line, "TO OpenOCD: %04x", i);
-				break;
-			case DEBUG_TYPE_BUFFER:
-				sprintf(line, "BUFFER: %04x", i);
-				break;
 		}
 
 		for (j = i; j < i + LINE_LEN && j < length; j++) {
@@ -182,24 +182,24 @@ static int8_t openjtag_get_tap_state(int8_t state)
 {
 
 	switch (state) {
-		case TAP_DREXIT2:   return OPENJTAG_TAP_EXIT2_DR;
-		case TAP_DREXIT1:   return OPENJTAG_TAP_EXIT1_DR;
-		case TAP_DRSHIFT:   return OPENJTAG_TAP_SHIFT_DR;
-		case TAP_DRPAUSE:   return OPENJTAG_TAP_PAUSE_DR;
-		case TAP_IRSELECT:  return OPENJTAG_TAP_SELECT_IR;
-		case TAP_DRUPDATE:  return OPENJTAG_TAP_UPDATE_DR;
-		case TAP_DRCAPTURE: return OPENJTAG_TAP_CAPTURE_DR;
-		case TAP_DRSELECT:  return OPENJTAG_TAP_SELECT_DR;
-		case TAP_IREXIT2:   return OPENJTAG_TAP_EXIT2_IR;
-		case TAP_IREXIT1:   return OPENJTAG_TAP_EXIT1_IR;
-		case TAP_IRSHIFT:   return OPENJTAG_TAP_SHIFT_IR;
-		case TAP_IRPAUSE:   return OPENJTAG_TAP_PAUSE_IR;
-		case TAP_IDLE:      return OPENJTAG_TAP_IDLE;
-		case TAP_IRUPDATE:  return OPENJTAG_TAP_UPDATE_IR;
-		case TAP_IRCAPTURE: return OPENJTAG_TAP_CAPURE_IR;
-		case TAP_RESET:     return OPENJTAG_TAP_RESET;
-		case TAP_INVALID:
-		default:            return OPENJTAG_TAP_INVALID;
+	case TAP_DREXIT2:   return OPENJTAG_TAP_EXIT2_DR;
+	case TAP_DREXIT1:   return OPENJTAG_TAP_EXIT1_DR;
+	case TAP_DRSHIFT:   return OPENJTAG_TAP_SHIFT_DR;
+	case TAP_DRPAUSE:   return OPENJTAG_TAP_PAUSE_DR;
+	case TAP_IRSELECT:  return OPENJTAG_TAP_SELECT_IR;
+	case TAP_DRUPDATE:  return OPENJTAG_TAP_UPDATE_DR;
+	case TAP_DRCAPTURE: return OPENJTAG_TAP_CAPTURE_DR;
+	case TAP_DRSELECT:  return OPENJTAG_TAP_SELECT_DR;
+	case TAP_IREXIT2:   return OPENJTAG_TAP_EXIT2_IR;
+	case TAP_IREXIT1:   return OPENJTAG_TAP_EXIT1_IR;
+	case TAP_IRSHIFT:   return OPENJTAG_TAP_SHIFT_IR;
+	case TAP_IRPAUSE:   return OPENJTAG_TAP_PAUSE_IR;
+	case TAP_IDLE:      return OPENJTAG_TAP_IDLE;
+	case TAP_IRUPDATE:  return OPENJTAG_TAP_UPDATE_IR;
+	case TAP_IRCAPTURE: return OPENJTAG_TAP_CAPURE_IR;
+	case TAP_RESET:     return OPENJTAG_TAP_RESET;
+	case TAP_INVALID:
+	default:            return OPENJTAG_TAP_INVALID;
 	}
 }
 
@@ -347,34 +347,34 @@ static int openjtag_speed(int speed)
 {
 	int clockcmd;
 	switch (speed) {
-		case 48000:
-			clockcmd = 0x00;
-			break;
-		case 24000:
-			clockcmd = 0x20;
-			break;
-		case 12000:
-			clockcmd = 0x40;
-			break;
-		case 6000:
-			clockcmd = 0x60;
-			break;
-		case 3000:
-			clockcmd = 0x80;
-			break;
-		case 1500:
-			clockcmd = 0xA0;
-			break;
-		case 750:
-			clockcmd = 0xC0;
-			break;
-		case 375:
-			clockcmd = 0xE0;
-			break;
-		default:
-			clockcmd = 0xE0;
-			LOG_WARNING("adapter speed not recognized, reverting to 375 kHz");
-			break;
+	case 48000:
+		clockcmd = 0x00;
+		break;
+	case 24000:
+		clockcmd = 0x20;
+		break;
+	case 12000:
+		clockcmd = 0x40;
+		break;
+	case 6000:
+		clockcmd = 0x60;
+		break;
+	case 3000:
+		clockcmd = 0x80;
+		break;
+	case 1500:
+		clockcmd = 0xA0;
+		break;
+	case 750:
+		clockcmd = 0xC0;
+		break;
+	case 375:
+		clockcmd = 0xE0;
+		break;
+	default:
+		clockcmd = 0xE0;
+		LOG_WARNING("adapter speed not recognized, reverting to 375 kHz");
+		break;
 	}
 	openjtag_sendcommand(clockcmd);
 
diff --git a/src/jtag/drivers/remote_bitbang.c b/src/jtag/drivers/remote_bitbang.c
index 449c616545..71ec572b3c 100644
--- a/src/jtag/drivers/remote_bitbang.c
+++ b/src/jtag/drivers/remote_bitbang.c
@@ -179,14 +179,14 @@ static int remote_bitbang_quit(void)
 static enum bb_value char_to_int(int c)
 {
 	switch (c) {
-		case '0':
-			return BB_LOW;
-		case '1':
-			return BB_HIGH;
-		default:
-			remote_bitbang_quit();
-			LOG_ERROR("remote_bitbang: invalid read response: %c(%i)", c, c);
-			return BB_ERROR;
+	case '0':
+		return BB_LOW;
+	case '1':
+		return BB_HIGH;
+	default:
+		remote_bitbang_quit();
+		LOG_ERROR("remote_bitbang: invalid read response: %c(%i)", c, c);
+		return BB_ERROR;
 	}
 }
 
diff --git a/src/jtag/drivers/rlink.c b/src/jtag/drivers/rlink.c
index 9622740c6b..83c6d68530 100644
--- a/src/jtag/drivers/rlink.c
+++ b/src/jtag/drivers/rlink.c
@@ -321,53 +321,53 @@ static int dtc_load_from_buffer(struct libusb_device_handle *hdev_param, const u
 		}
 
 		switch (header->type) {
-			case DTCLOAD_COMMENT:
-				break;
-
-			case DTCLOAD_ENTRY:
-				/* store entry addresses somewhere */
-				if (!strncmp("download", (char *)buffer + 1, 8))
-					dtc_entry_download = buffer[0];
-				break;
-
-			case DTCLOAD_LOAD:
-				/* Send the DTC program to ST7 RAM. */
-				usb_err = ep1_memory_write(hdev_param, DTC_LOAD_BUFFER,
-					header->length + 1, buffer);
-				if (usb_err < 0)
-					return usb_err;
-
-				/* Load it into the DTC. */
-				usb_err = ep1_generic_commandl(hdev_param, 3, EP1_CMD_DTC_LOAD,
-					(DTC_LOAD_BUFFER >> 8),	DTC_LOAD_BUFFER);
-				if (usb_err < 0)
-					return usb_err;
-
-				break;
-
-			case DTCLOAD_RUN:
-				usb_err = ep1_generic_commandl(hdev_param, 3, EP1_CMD_DTC_CALL,
-					buffer[0], EP1_CMD_DTC_WAIT);
-				if (usb_err < 0)
-					return usb_err;
-
-				break;
-
-			case DTCLOAD_LUT_START:
-				lut_start = buffer[0];
-				break;
-
-			case DTCLOAD_LUT:
-				usb_err = ep1_memory_write(hdev_param,
-					ST7_USB_BUF_EP0OUT + lut_start, header->length + 1, buffer);
-				if (usb_err < 0)
-					return usb_err;
-				break;
-
-			default:
-				LOG_ERROR("Invalid DTC image record type: 0x%02x", header->type);
-				exit(1);
-				break;
+		case DTCLOAD_COMMENT:
+			break;
+
+		case DTCLOAD_ENTRY:
+			/* store entry addresses somewhere */
+			if (!strncmp("download", (char *)buffer + 1, 8))
+				dtc_entry_download = buffer[0];
+			break;
+
+		case DTCLOAD_LOAD:
+			/* Send the DTC program to ST7 RAM. */
+			usb_err = ep1_memory_write(hdev_param, DTC_LOAD_BUFFER,
+				header->length + 1, buffer);
+			if (usb_err < 0)
+				return usb_err;
+
+			/* Load it into the DTC. */
+			usb_err = ep1_generic_commandl(hdev_param, 3, EP1_CMD_DTC_LOAD,
+				(DTC_LOAD_BUFFER >> 8),	DTC_LOAD_BUFFER);
+			if (usb_err < 0)
+				return usb_err;
+
+			break;
+
+		case DTCLOAD_RUN:
+			usb_err = ep1_generic_commandl(hdev_param, 3, EP1_CMD_DTC_CALL,
+				buffer[0], EP1_CMD_DTC_WAIT);
+			if (usb_err < 0)
+				return usb_err;
+
+			break;
+
+		case DTCLOAD_LUT_START:
+			lut_start = buffer[0];
+			break;
+
+		case DTCLOAD_LUT:
+			usb_err = ep1_memory_write(hdev_param,
+				ST7_USB_BUF_EP0OUT + lut_start, header->length + 1, buffer);
+			if (usb_err < 0)
+				return usb_err;
+			break;
+
+		default:
+			LOG_ERROR("Invalid DTC image record type: 0x%02x", header->type);
+			exit(1);
+			break;
 		}
 
 		buffer += (header->length + 1);
@@ -1133,15 +1133,15 @@ static int rlink_scan(struct jtag_command *cmd, enum scan_type type,
 		chunk_bytes = chunk_bits / 8;
 
 		switch (type) {
-			case SCAN_IN:
-				x = DTC_CMD_SHIFT_TDO_BYTES(chunk_bytes);
-				break;
-			case SCAN_OUT:
-				x = DTC_CMD_SHIFT_TDI_BYTES(chunk_bytes);
-				break;
-			default:
-				x = DTC_CMD_SHIFT_TDIO_BYTES(chunk_bytes);
-				break;
+		case SCAN_IN:
+			x = DTC_CMD_SHIFT_TDO_BYTES(chunk_bytes);
+			break;
+		case SCAN_OUT:
+			x = DTC_CMD_SHIFT_TDI_BYTES(chunk_bytes);
+			break;
+		default:
+			x = DTC_CMD_SHIFT_TDIO_BYTES(chunk_bytes);
+			break;
 		}
 		dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
 
@@ -1267,69 +1267,69 @@ static int rlink_execute_queue(struct jtag_command *cmd_queue)
 
 	while (cmd) {
 		switch (cmd->type) {
-			case JTAG_RUNTEST:
-			case JTAG_TLR_RESET:
-			case JTAG_PATHMOVE:
-			case JTAG_SCAN:
-				break;
-
-			default:
-				/* some events, such as resets, need a queue flush to ensure
-				 *consistency */
-				tap_state_queue_run();
-				dtc_queue_run();
-				break;
+		case JTAG_RUNTEST:
+		case JTAG_TLR_RESET:
+		case JTAG_PATHMOVE:
+		case JTAG_SCAN:
+			break;
+
+		default:
+			/* some events, such as resets, need a queue flush to ensure
+			 *consistency */
+			tap_state_queue_run();
+			dtc_queue_run();
+			break;
 		}
 
 		switch (cmd->type) {
-			case JTAG_RESET:
-				LOG_DEBUG_IO("reset trst: %i srst %i",
-						cmd->cmd.reset->trst,
-						cmd->cmd.reset->srst);
-				if (cmd->cmd.reset->trst == 1 ||
-						(cmd->cmd.reset->srst &&
-								(jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
-					tap_set_state(TAP_RESET);
-				rlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
-				break;
-			case JTAG_RUNTEST:
-				LOG_DEBUG_IO("runtest %i cycles, end in %i",
-						cmd->cmd.runtest->num_cycles,
-						cmd->cmd.runtest->end_state);
-				if (cmd->cmd.runtest->end_state != -1)
-					rlink_end_state(cmd->cmd.runtest->end_state);
-				rlink_runtest(cmd->cmd.runtest->num_cycles);
-				break;
-			case JTAG_TLR_RESET:
-				LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
-				if (cmd->cmd.statemove->end_state != -1)
-					rlink_end_state(cmd->cmd.statemove->end_state);
-				rlink_state_move();
-				break;
-			case JTAG_PATHMOVE:
-				LOG_DEBUG_IO("pathmove: %u states, end in %i",
-						cmd->cmd.pathmove->num_states,
-						cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
-				rlink_path_move(cmd->cmd.pathmove);
-				break;
-			case JTAG_SCAN:
-				LOG_DEBUG_IO("%s scan end in %i",
-						(cmd->cmd.scan->ir_scan) ? "IR" : "DR",
-								cmd->cmd.scan->end_state);
-				if (cmd->cmd.scan->end_state != -1)
-					rlink_end_state(cmd->cmd.scan->end_state);
-				scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
-				type = jtag_scan_type(cmd->cmd.scan);
-				if (rlink_scan(cmd, type, buffer, scan_size) != ERROR_OK)
-					retval = ERROR_FAIL;
-				break;
-			case JTAG_SLEEP:
-				LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
-				jtag_sleep(cmd->cmd.sleep->us);
-				break;
-			default:
-				LOG_ERROR("BUG: unknown JTAG command type encountered");
-				exit(-1);
+		case JTAG_RESET:
+			LOG_DEBUG_IO("reset trst: %i srst %i",
+					cmd->cmd.reset->trst,
+					cmd->cmd.reset->srst);
+			if (cmd->cmd.reset->trst == 1 ||
+					(cmd->cmd.reset->srst &&
+							(jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
+				tap_set_state(TAP_RESET);
+			rlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
+			break;
+		case JTAG_RUNTEST:
+			LOG_DEBUG_IO("runtest %i cycles, end in %i",
+					cmd->cmd.runtest->num_cycles,
+					cmd->cmd.runtest->end_state);
+			if (cmd->cmd.runtest->end_state != -1)
+				rlink_end_state(cmd->cmd.runtest->end_state);
+			rlink_runtest(cmd->cmd.runtest->num_cycles);
+			break;
+		case JTAG_TLR_RESET:
+			LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
+			if (cmd->cmd.statemove->end_state != -1)
+				rlink_end_state(cmd->cmd.statemove->end_state);
+			rlink_state_move();
+			break;
+		case JTAG_PATHMOVE:
+			LOG_DEBUG_IO("pathmove: %u states, end in %i",
+					cmd->cmd.pathmove->num_states,
+					cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
+			rlink_path_move(cmd->cmd.pathmove);
+			break;
+		case JTAG_SCAN:
+			LOG_DEBUG_IO("%s scan end in %i",
+					(cmd->cmd.scan->ir_scan) ? "IR" : "DR",
+							cmd->cmd.scan->end_state);
+			if (cmd->cmd.scan->end_state != -1)
+				rlink_end_state(cmd->cmd.scan->end_state);
+			scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
+			type = jtag_scan_type(cmd->cmd.scan);
+			if (rlink_scan(cmd, type, buffer, scan_size) != ERROR_OK)
+				retval = ERROR_FAIL;
+			break;
+		case JTAG_SLEEP:
+			LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
+			jtag_sleep(cmd->cmd.sleep->us);
+			break;
+		default:
+			LOG_ERROR("BUG: unknown JTAG command type encountered");
+			exit(-1);
 		}
 		cmd = cmd->next;
 	}
diff --git a/src/jtag/drivers/stlink_usb.c b/src/jtag/drivers/stlink_usb.c
index 5ee1f85261..6941aaf07e 100644
--- a/src/jtag/drivers/stlink_usb.c
+++ b/src/jtag/drivers/stlink_usb.c
@@ -608,28 +608,28 @@ static int transfer_error_status(const struct libusb_transfer *transfer)
 	int r = 0;
 
 	switch (transfer->status) {
-		case LIBUSB_TRANSFER_COMPLETED:
-			r = 0;
-			break;
-		case LIBUSB_TRANSFER_TIMED_OUT:
-			r = LIBUSB_ERROR_TIMEOUT;
-			break;
-		case LIBUSB_TRANSFER_STALL:
-			r = LIBUSB_ERROR_PIPE;
-			break;
-		case LIBUSB_TRANSFER_OVERFLOW:
-			r = LIBUSB_ERROR_OVERFLOW;
-			break;
-		case LIBUSB_TRANSFER_NO_DEVICE:
-			r = LIBUSB_ERROR_NO_DEVICE;
-			break;
-		case LIBUSB_TRANSFER_ERROR:
-		case LIBUSB_TRANSFER_CANCELLED:
-			r = LIBUSB_ERROR_IO;
-			break;
-		default:
-			r = LIBUSB_ERROR_OTHER;
-			break;
+	case LIBUSB_TRANSFER_COMPLETED:
+		r = 0;
+		break;
+	case LIBUSB_TRANSFER_TIMED_OUT:
+		r = LIBUSB_ERROR_TIMEOUT;
+		break;
+	case LIBUSB_TRANSFER_STALL:
+		r = LIBUSB_ERROR_PIPE;
+		break;
+	case LIBUSB_TRANSFER_OVERFLOW:
+		r = LIBUSB_ERROR_OVERFLOW;
+		break;
+	case LIBUSB_TRANSFER_NO_DEVICE:
+		r = LIBUSB_ERROR_NO_DEVICE;
+		break;
+	case LIBUSB_TRANSFER_ERROR:
+	case LIBUSB_TRANSFER_CANCELLED:
+		r = LIBUSB_ERROR_IO;
+		break;
+	default:
+		r = LIBUSB_ERROR_OTHER;
+		break;
 	}
 
 	return r;
@@ -1058,13 +1058,13 @@ static int stlink_usb_error_check(void *handle)
 
 	if (h->st_mode == STLINK_MODE_DEBUG_SWIM) {
 		switch (h->databuf[0]) {
-			case STLINK_SWIM_ERR_OK:
-				return ERROR_OK;
-			case STLINK_SWIM_BUSY:
-				return ERROR_WAIT;
-			default:
-				LOG_DEBUG("unknown/unexpected STLINK status code 0x%x", h->databuf[0]);
-				return ERROR_FAIL;
+		case STLINK_SWIM_ERR_OK:
+			return ERROR_OK;
+		case STLINK_SWIM_BUSY:
+			return ERROR_WAIT;
+		default:
+			LOG_DEBUG("unknown/unexpected STLINK status code 0x%x", h->databuf[0]);
+			return ERROR_FAIL;
 		}
 	}
 
@@ -1073,64 +1073,64 @@ static int stlink_usb_error_check(void *handle)
 		h->databuf[0] = STLINK_DEBUG_ERR_OK;
 
 	switch (h->databuf[0]) {
-		case STLINK_DEBUG_ERR_OK:
-			return ERROR_OK;
-		case STLINK_DEBUG_ERR_FAULT:
-			LOG_DEBUG("SWD fault response (0x%x)", STLINK_DEBUG_ERR_FAULT);
-			return ERROR_FAIL;
-		case STLINK_SWD_AP_WAIT:
-			LOG_DEBUG("wait status SWD_AP_WAIT (0x%x)", STLINK_SWD_AP_WAIT);
-			return ERROR_WAIT;
-		case STLINK_SWD_DP_WAIT:
-			LOG_DEBUG("wait status SWD_DP_WAIT (0x%x)", STLINK_SWD_DP_WAIT);
-			return ERROR_WAIT;
-		case STLINK_JTAG_GET_IDCODE_ERROR:
-			LOG_DEBUG("STLINK_JTAG_GET_IDCODE_ERROR");
-			return ERROR_FAIL;
-		case STLINK_JTAG_WRITE_ERROR:
-			LOG_DEBUG("Write error");
-			return ERROR_FAIL;
-		case STLINK_JTAG_WRITE_VERIF_ERROR:
-			LOG_DEBUG("Write verify error, ignoring");
-			return ERROR_OK;
-		case STLINK_SWD_AP_FAULT:
-			/* git://git.ac6.fr/openocd commit 657e3e885b9ee10
-			 * returns ERROR_OK with the comment:
-			 * Change in error status when reading outside RAM.
-			 * This fix allows CDT plugin to visualize memory.
-			 */
-			LOG_DEBUG("STLINK_SWD_AP_FAULT");
-			return ERROR_FAIL;
-		case STLINK_SWD_AP_ERROR:
-			LOG_DEBUG("STLINK_SWD_AP_ERROR");
-			return ERROR_FAIL;
-		case STLINK_SWD_AP_PARITY_ERROR:
-			LOG_DEBUG("STLINK_SWD_AP_PARITY_ERROR");
-			return ERROR_FAIL;
-		case STLINK_SWD_DP_FAULT:
-			LOG_DEBUG("STLINK_SWD_DP_FAULT");
-			return ERROR_FAIL;
-		case STLINK_SWD_DP_ERROR:
-			LOG_DEBUG("STLINK_SWD_DP_ERROR");
-			return ERROR_FAIL;
-		case STLINK_SWD_DP_PARITY_ERROR:
-			LOG_DEBUG("STLINK_SWD_DP_PARITY_ERROR");
-			return ERROR_FAIL;
-		case STLINK_SWD_AP_WDATA_ERROR:
-			LOG_DEBUG("STLINK_SWD_AP_WDATA_ERROR");
-			return ERROR_FAIL;
-		case STLINK_SWD_AP_STICKY_ERROR:
-			LOG_DEBUG("STLINK_SWD_AP_STICKY_ERROR");
-			return ERROR_FAIL;
-		case STLINK_SWD_AP_STICKYORUN_ERROR:
-			LOG_DEBUG("STLINK_SWD_AP_STICKYORUN_ERROR");
-			return ERROR_FAIL;
-		case STLINK_BAD_AP_ERROR:
-			LOG_DEBUG("STLINK_BAD_AP_ERROR");
-			return ERROR_FAIL;
-		default:
-			LOG_DEBUG("unknown/unexpected STLINK status code 0x%x", h->databuf[0]);
-			return ERROR_FAIL;
+	case STLINK_DEBUG_ERR_OK:
+		return ERROR_OK;
+	case STLINK_DEBUG_ERR_FAULT:
+		LOG_DEBUG("SWD fault response (0x%x)", STLINK_DEBUG_ERR_FAULT);
+		return ERROR_FAIL;
+	case STLINK_SWD_AP_WAIT:
+		LOG_DEBUG("wait status SWD_AP_WAIT (0x%x)", STLINK_SWD_AP_WAIT);
+		return ERROR_WAIT;
+	case STLINK_SWD_DP_WAIT:
+		LOG_DEBUG("wait st...
 
[truncated message content]

[PATCH]: b62412effd jtag: align switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9053

-- gerrit

commit b62412effdf02480937acbc5082362a51d171b1c
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jul 26 18:00:20 2025 +0200

    jtag: align switch and case statements
    
    The coding style requires the 'case' to be at the same indentation
    level of its 'switch' statement.
    
    Align the code accordingly.
    
    No changes are reported by
            git log -p -w --ignore-blank-lines --patience
    
    Change-Id: Iaf368b0bdd7c797b0e4cfb91e838696d706fdcce
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/jtag/adapter.c b/src/jtag/adapter.c
index 6785a74ef1..97c89024b4 100644
--- a/src/jtag/adapter.c
+++ b/src/jtag/adapter.c
@@ -269,15 +269,15 @@ int adapter_config_rclk(unsigned int fallback_speed_khz)
 int adapter_get_speed(int *speed)
 {
 	switch (adapter_config.clock_mode) {
-		case CLOCK_MODE_KHZ:
-			adapter_khz_to_speed(adapter_get_speed_khz(), speed);
-			break;
-		case CLOCK_MODE_RCLK:
-			adapter_rclk_to_speed(adapter_config.rclk_fallback_speed_khz, speed);
-			break;
-		default:
-			LOG_ERROR("BUG: unknown adapter clock mode");
-			return ERROR_FAIL;
+	case CLOCK_MODE_KHZ:
+		adapter_khz_to_speed(adapter_get_speed_khz(), speed);
+		break;
+	case CLOCK_MODE_RCLK:
+		adapter_rclk_to_speed(adapter_config.rclk_fallback_speed_khz, speed);
+		break;
+	default:
+		LOG_ERROR("BUG: unknown adapter clock mode");
+		return ERROR_FAIL;
 	}
 	return ERROR_OK;
 }
@@ -613,34 +613,34 @@ next:
 
 	/* minimal JTAG has neither SRST nor TRST (so that's the default) */
 	switch (new_cfg & (RESET_HAS_TRST | RESET_HAS_SRST)) {
-		case RESET_HAS_SRST:
-			modes[0] = "srst_only";
-			break;
-		case RESET_HAS_TRST:
-			modes[0] = "trst_only";
-			break;
-		case RESET_TRST_AND_SRST:
-			modes[0] = "trst_and_srst";
-			break;
-		default:
-			modes[0] = "none";
-			break;
+	case RESET_HAS_SRST:
+		modes[0] = "srst_only";
+		break;
+	case RESET_HAS_TRST:
+		modes[0] = "trst_only";
+		break;
+	case RESET_TRST_AND_SRST:
+		modes[0] = "trst_and_srst";
+		break;
+	default:
+		modes[0] = "none";
+		break;
 	}
 
 	/* normally SRST and TRST are decoupled; but bugs happen ... */
 	switch (new_cfg & (RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST)) {
-		case RESET_SRST_PULLS_TRST:
-			modes[1] = "srst_pulls_trst";
-			break;
-		case RESET_TRST_PULLS_SRST:
-			modes[1] = "trst_pulls_srst";
-			break;
-		case RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST:
-			modes[1] = "combined";
-			break;
-		default:
-			modes[1] = "separate";
-			break;
+	case RESET_SRST_PULLS_TRST:
+		modes[1] = "srst_pulls_trst";
+		break;
+	case RESET_TRST_PULLS_SRST:
+		modes[1] = "trst_pulls_srst";
+		break;
+	case RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST:
+		modes[1] = "combined";
+		break;
+	default:
+		modes[1] = "separate";
+		break;
 	}
 
 	/* TRST-less connectors include Altera, Xilinx, and minimal JTAG */
diff --git a/src/jtag/core.c b/src/jtag/core.c
index 6dd2144c63..479d2efe52 100644
--- a/src/jtag/core.c
+++ b/src/jtag/core.c
@@ -969,58 +969,58 @@ int default_interface_jtag_execute_queue(void)
 
 	while (debug_level >= LOG_LVL_DEBUG_IO && cmd) {
 		switch (cmd->type) {
-			case JTAG_SCAN:
-				LOG_DEBUG_IO("JTAG %s SCAN to %s",
-						cmd->cmd.scan->ir_scan ? "IR" : "DR",
-						tap_state_name(cmd->cmd.scan->end_state));
-				for (unsigned int i = 0; i < cmd->cmd.scan->num_fields; i++) {
-					struct scan_field *field = cmd->cmd.scan->fields + i;
-					if (field->out_value) {
-						char *str = buf_to_hex_str(field->out_value, field->num_bits);
-						LOG_DEBUG_IO("  %ub out: %s", field->num_bits, str);
-						free(str);
-					}
-					if (field->in_value) {
-						char *str = buf_to_hex_str(field->in_value, field->num_bits);
-						LOG_DEBUG_IO("  %ub  in: %s", field->num_bits, str);
-						free(str);
-					}
+		case JTAG_SCAN:
+			LOG_DEBUG_IO("JTAG %s SCAN to %s",
+					cmd->cmd.scan->ir_scan ? "IR" : "DR",
+					tap_state_name(cmd->cmd.scan->end_state));
+			for (unsigned int i = 0; i < cmd->cmd.scan->num_fields; i++) {
+				struct scan_field *field = cmd->cmd.scan->fields + i;
+				if (field->out_value) {
+					char *str = buf_to_hex_str(field->out_value, field->num_bits);
+					LOG_DEBUG_IO("  %ub out: %s", field->num_bits, str);
+					free(str);
 				}
-				break;
-			case JTAG_TLR_RESET:
-				LOG_DEBUG_IO("JTAG TLR RESET to %s",
-						tap_state_name(cmd->cmd.statemove->end_state));
-				break;
-			case JTAG_RUNTEST:
-				LOG_DEBUG_IO("JTAG RUNTEST %d cycles to %s",
-						cmd->cmd.runtest->num_cycles,
-						tap_state_name(cmd->cmd.runtest->end_state));
-				break;
-			case JTAG_RESET:
-				{
-					const char *reset_str[3] = {
-						"leave", "deassert", "assert"
-					};
-					LOG_DEBUG_IO("JTAG RESET %s TRST, %s SRST",
-							reset_str[cmd->cmd.reset->trst + 1],
-							reset_str[cmd->cmd.reset->srst + 1]);
+				if (field->in_value) {
+					char *str = buf_to_hex_str(field->in_value, field->num_bits);
+					LOG_DEBUG_IO("  %ub  in: %s", field->num_bits, str);
+					free(str);
 				}
-				break;
-			case JTAG_PATHMOVE:
-				LOG_DEBUG_IO("JTAG PATHMOVE (TODO)");
-				break;
-			case JTAG_SLEEP:
-				LOG_DEBUG_IO("JTAG SLEEP (TODO)");
-				break;
-			case JTAG_STABLECLOCKS:
-				LOG_DEBUG_IO("JTAG STABLECLOCKS (TODO)");
-				break;
-			case JTAG_TMS:
-				LOG_DEBUG_IO("JTAG TMS (TODO)");
-				break;
-			default:
-				LOG_ERROR("Unknown JTAG command: %d", cmd->type);
-				break;
+			}
+			break;
+		case JTAG_TLR_RESET:
+			LOG_DEBUG_IO("JTAG TLR RESET to %s",
+					tap_state_name(cmd->cmd.statemove->end_state));
+			break;
+		case JTAG_RUNTEST:
+			LOG_DEBUG_IO("JTAG RUNTEST %d cycles to %s",
+					cmd->cmd.runtest->num_cycles,
+					tap_state_name(cmd->cmd.runtest->end_state));
+			break;
+		case JTAG_RESET:
+			{
+				const char *reset_str[3] = {
+					"leave", "deassert", "assert"
+				};
+				LOG_DEBUG_IO("JTAG RESET %s TRST, %s SRST",
+						reset_str[cmd->cmd.reset->trst + 1],
+						reset_str[cmd->cmd.reset->srst + 1]);
+			}
+			break;
+		case JTAG_PATHMOVE:
+			LOG_DEBUG_IO("JTAG PATHMOVE (TODO)");
+			break;
+		case JTAG_SLEEP:
+			LOG_DEBUG_IO("JTAG SLEEP (TODO)");
+			break;
+		case JTAG_STABLECLOCKS:
+			LOG_DEBUG_IO("JTAG STABLECLOCKS (TODO)");
+			break;
+		case JTAG_TMS:
+			LOG_DEBUG_IO("JTAG TMS (TODO)");
+			break;
+		default:
+			LOG_ERROR("Unknown JTAG command: %d", cmd->type);
+			break;
 		}
 		cmd = cmd->next;
 	}
@@ -1551,22 +1551,22 @@ int jtag_init_inner(struct command_context *cmd_ctx)
 	 */
 	retval = jtag_examine_chain();
 	switch (retval) {
-		case ERROR_OK:
-			/* complete success */
-			break;
-		default:
-			/* For backward compatibility reasons, try coping with
-			 * configuration errors involving only ID mismatches.
-			 * We might be able to talk to the devices.
-			 *
-			 * Also the device might be powered down during startup.
-			 *
-			 * After OpenOCD starts, we can try to power on the device
-			 * and run a reset.
-			 */
-			LOG_ERROR("Trying to use configured scan chain anyway...");
-			issue_setup = false;
-			break;
+	case ERROR_OK:
+		/* complete success */
+		break;
+	default:
+		/* For backward compatibility reasons, try coping with
+		 * configuration errors involving only ID mismatches.
+		 * We might be able to talk to the devices.
+		 *
+		 * Also the device might be powered down during startup.
+		 *
+		 * After OpenOCD starts, we can try to power on the device
+		 * and run a reset.
+		 */
+		LOG_ERROR("Trying to use configured scan chain anyway...");
+		issue_setup = false;
+		break;
 	}
 
 	/* Now look at IR values.  Problems here will prevent real
diff --git a/src/jtag/interface.c b/src/jtag/interface.c
index 0473a87535..23b5bcf4f1 100644
--- a/src/jtag/interface.c
+++ b/src/jtag/interface.c
@@ -67,28 +67,28 @@ int tap_move_ndx(enum tap_state astate)
 	int ndx;
 
 	switch (astate) {
-		case TAP_RESET:
-			ndx = 0;
-			break;
-		case TAP_IDLE:
-			ndx = 1;
-			break;
-		case TAP_DRSHIFT:
-			ndx = 2;
-			break;
-		case TAP_DRPAUSE:
-			ndx = 3;
-			break;
-		case TAP_IRSHIFT:
-			ndx = 4;
-			break;
-		case TAP_IRPAUSE:
-			ndx = 5;
-			break;
-		default:
-			LOG_ERROR("FATAL: unstable state \"%s\" in %s()",
-					tap_state_name(astate), __func__);
-			exit(1);
+	case TAP_RESET:
+		ndx = 0;
+		break;
+	case TAP_IDLE:
+		ndx = 1;
+		break;
+	case TAP_DRSHIFT:
+		ndx = 2;
+		break;
+	case TAP_DRPAUSE:
+		ndx = 3;
+		break;
+	case TAP_IRSHIFT:
+		ndx = 4;
+		break;
+	case TAP_IRPAUSE:
+		ndx = 5;
+		break;
+	default:
+		LOG_ERROR("FATAL: unstable state \"%s\" in %s()",
+				tap_state_name(astate), __func__);
+		exit(1);
 	}
 
 	return ndx;
@@ -205,16 +205,16 @@ bool tap_is_state_stable(enum tap_state astate)
 	 * (not value dependent like an array), and can also check bounds.
 	*/
 	switch (astate) {
-		case TAP_RESET:
-		case TAP_IDLE:
-		case TAP_DRSHIFT:
-		case TAP_DRPAUSE:
-		case TAP_IRSHIFT:
-		case TAP_IRPAUSE:
-			is_stable = true;
-			break;
-		default:
-			is_stable = false;
+	case TAP_RESET:
+	case TAP_IDLE:
+	case TAP_DRSHIFT:
+	case TAP_DRPAUSE:
+	case TAP_IRSHIFT:
+	case TAP_IRPAUSE:
+		is_stable = true;
+		break;
+	default:
+		is_stable = false;
 	}
 
 	return is_stable;
@@ -230,83 +230,83 @@ enum tap_state tap_state_transition(enum tap_state cur_state, bool tms)
 
 	if (tms) {
 		switch (cur_state) {
-			case TAP_RESET:
-				new_state = cur_state;
-				break;
-			case TAP_IDLE:
-			case TAP_DRUPDATE:
-			case TAP_IRUPDATE:
-				new_state = TAP_DRSELECT;
-				break;
-			case TAP_DRSELECT:
-				new_state = TAP_IRSELECT;
-				break;
-			case TAP_DRCAPTURE:
-			case TAP_DRSHIFT:
-				new_state = TAP_DREXIT1;
-				break;
-			case TAP_DREXIT1:
-			case TAP_DREXIT2:
-				new_state = TAP_DRUPDATE;
-				break;
-			case TAP_DRPAUSE:
-				new_state = TAP_DREXIT2;
-				break;
-			case TAP_IRSELECT:
-				new_state = TAP_RESET;
-				break;
-			case TAP_IRCAPTURE:
-			case TAP_IRSHIFT:
-				new_state = TAP_IREXIT1;
-				break;
-			case TAP_IREXIT1:
-			case TAP_IREXIT2:
-				new_state = TAP_IRUPDATE;
-				break;
-			case TAP_IRPAUSE:
-				new_state = TAP_IREXIT2;
-				break;
-			default:
-				LOG_ERROR("fatal: invalid argument cur_state=%d", cur_state);
-				exit(1);
-				break;
+		case TAP_RESET:
+			new_state = cur_state;
+			break;
+		case TAP_IDLE:
+		case TAP_DRUPDATE:
+		case TAP_IRUPDATE:
+			new_state = TAP_DRSELECT;
+			break;
+		case TAP_DRSELECT:
+			new_state = TAP_IRSELECT;
+			break;
+		case TAP_DRCAPTURE:
+		case TAP_DRSHIFT:
+			new_state = TAP_DREXIT1;
+			break;
+		case TAP_DREXIT1:
+		case TAP_DREXIT2:
+			new_state = TAP_DRUPDATE;
+			break;
+		case TAP_DRPAUSE:
+			new_state = TAP_DREXIT2;
+			break;
+		case TAP_IRSELECT:
+			new_state = TAP_RESET;
+			break;
+		case TAP_IRCAPTURE:
+		case TAP_IRSHIFT:
+			new_state = TAP_IREXIT1;
+			break;
+		case TAP_IREXIT1:
+		case TAP_IREXIT2:
+			new_state = TAP_IRUPDATE;
+			break;
+		case TAP_IRPAUSE:
+			new_state = TAP_IREXIT2;
+			break;
+		default:
+			LOG_ERROR("fatal: invalid argument cur_state=%d", cur_state);
+			exit(1);
+			break;
 		}
 	} else {
 		switch (cur_state) {
-			case TAP_RESET:
-			case TAP_IDLE:
-			case TAP_DRUPDATE:
-			case TAP_IRUPDATE:
-				new_state = TAP_IDLE;
-				break;
-			case TAP_DRSELECT:
-				new_state = TAP_DRCAPTURE;
-				break;
-			case TAP_DRCAPTURE:
-			case TAP_DRSHIFT:
-			case TAP_DREXIT2:
-				new_state = TAP_DRSHIFT;
-				break;
-			case TAP_DREXIT1:
-			case TAP_DRPAUSE:
-				new_state = TAP_DRPAUSE;
-				break;
-			case TAP_IRSELECT:
-				new_state = TAP_IRCAPTURE;
-				break;
-			case TAP_IRCAPTURE:
-			case TAP_IRSHIFT:
-			case TAP_IREXIT2:
-				new_state = TAP_IRSHIFT;
-				break;
-			case TAP_IREXIT1:
-			case TAP_IRPAUSE:
-				new_state = TAP_IRPAUSE;
-				break;
-			default:
-				LOG_ERROR("fatal: invalid argument cur_state=%d", cur_state);
-				exit(1);
-				break;
+		case TAP_RESET:
+		case TAP_IDLE:
+		case TAP_DRUPDATE:
+		case TAP_IRUPDATE:
+			new_state = TAP_IDLE;
+			break;
+		case TAP_DRSELECT:
+			new_state = TAP_DRCAPTURE;
+			break;
+		case TAP_DRCAPTURE:
+		case TAP_DRSHIFT:
+		case TAP_DREXIT2:
+			new_state = TAP_DRSHIFT;
+			break;
+		case TAP_DREXIT1:
+		case TAP_DRPAUSE:
+			new_state = TAP_DRPAUSE;
+			break;
+		case TAP_IRSELECT:
+			new_state = TAP_IRCAPTURE;
+			break;
+		case TAP_IRCAPTURE:
+		case TAP_IRSHIFT:
+		case TAP_IREXIT2:
+			new_state = TAP_IRSHIFT;
+			break;
+		case TAP_IREXIT1:
+		case TAP_IRPAUSE:
+			new_state = TAP_IRPAUSE;
+			break;
+		default:
+			LOG_ERROR("fatal: invalid argument cur_state=%d", cur_state);
+			exit(1);
+			break;
 		}
 	}
 
diff --git a/src/jtag/tcl.c b/src/jtag/tcl.c
index 8b0bc7affb..9cffd6b5d1 100644
--- a/src/jtag/tcl.c
+++ b/src/jtag/tcl.c
@@ -64,13 +64,13 @@ struct jtag_tap *jtag_tap_by_jim_obj(Jim_Interp *interp, Jim_Obj *o)
 static bool scan_is_safe(enum tap_state state)
 {
 	switch (state) {
-	    case TAP_RESET:
-	    case TAP_IDLE:
-	    case TAP_DRPAUSE:
-	    case TAP_IRPAUSE:
-		    return true;
-	    default:
-		    return false;
+	case TAP_RESET:
+	case TAP_IDLE:
+	case TAP_DRPAUSE:
+	case TAP_IRPAUSE:
+	    return true;
+	default:
+	    return false;
 	}
 }
 
@@ -558,18 +558,18 @@ static void jtag_tap_handle_event(struct jtag_tap *tap, enum jtag_event e)
 		}
 
 		switch (e) {
-		    case JTAG_TAP_EVENT_ENABLE:
-		    case JTAG_TAP_EVENT_DISABLE:
-				/* NOTE:  we currently assume the handlers
-				 * can't fail.  Right here is where we should
-				 * really be verifying the scan chains ...
-				 */
-			    tap->enabled = (e == JTAG_TAP_EVENT_ENABLE);
-			    LOG_INFO("JTAG tap: %s %s", tap->dotted_name,
+		case JTAG_TAP_EVENT_ENABLE:
+		case JTAG_TAP_EVENT_DISABLE:
+			/* NOTE:  we currently assume the handlers
+			 * can't fail.  Right here is where we should
+			 * really be verifying the scan chains ...
+			 */
+		    tap->enabled = (e == JTAG_TAP_EVENT_ENABLE);
+		    LOG_INFO("JTAG tap: %s %s", tap->dotted_name,
 				tap->enabled ? "enabled" : "disabled");
-			    break;
-		    default:
-			    break;
+		    break;
+		default:
+		    break;
 		}
 	}
 }

-- 

[PATCH]: 98be3049a5 target: prepare for aligning switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9050

-- gerrit

commit 98be3049a5e4ca4927770ee3cba2be97bf3cd1d3
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jul 26 13:41:04 2025 +0200

    target: prepare for aligning switch and case statements
    
    To prepare for aligning switch and case statements, fix in advance
    some checkpatch error due to existing code:
    - remove useless parenthesis;
    - remove useless 'break';
    - join spit lines;
    - add space around operators;
    - remove 'else' after exit() and return.
    
    Change-Id: I8a87a0ea104205d087dcb8cbf4c67ff13a47742f
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/target/arm11.c b/src/target/arm11.c
index 583830f948..8ba0812d8d 100644
--- a/src/target/arm11.c
+++ b/src/target/arm11.c
@@ -838,7 +838,6 @@ static int arm11_read_memory_inner(struct target *target,
 			break;
 
 		case 2:
-		{
 			arm11->arm.core_cache->reg_list[1].dirty = true;
 
 			for (size_t i = 0; i < count; i++) {
@@ -856,7 +855,6 @@ static int arm11_read_memory_inner(struct target *target,
 			}
 
 			break;
-		}
 
 		case 4:
 		{
@@ -928,7 +926,6 @@ static int arm11_write_memory_inner(struct target *target,
 
 	switch (size) {
 		case 1:
-		{
 			arm11->arm.core_cache->reg_list[1].dirty = true;
 
 			for (size_t i = 0; i < count; i++) {
@@ -948,10 +945,8 @@ static int arm11_write_memory_inner(struct target *target,
 			}
 
 			break;
-		}
 
 		case 2:
-		{
 			arm11->arm.core_cache->reg_list[1].dirty = true;
 
 			for (size_t i = 0; i < count; i++) {
@@ -974,9 +969,9 @@ static int arm11_write_memory_inner(struct target *target,
 			}
 
 			break;
-		}
 
-		case 4: {
+		case 4:
+		{
 			/* stream word data through DCC directly to memory */
 			/* increment:		STC p14,c5,[R0],#4 */
 			/* no increment:	STC p14,c5,[R0]*/
diff --git a/src/target/arm7_9_common.c b/src/target/arm7_9_common.c
index 5550fb1e24..f67e02bdbd 100644
--- a/src/target/arm7_9_common.c
+++ b/src/target/arm7_9_common.c
@@ -2334,9 +2334,9 @@ int arm7_9_write_memory(struct target *target,
 				/* fast memory writes are only safe when the target is running
 				 * from a sufficiently high clock (32 kHz is usually too slow)
 				 */
-				if (arm7_9->fast_memory_access)
+				if (arm7_9->fast_memory_access) {
 					retval = arm7_9_execute_fast_sys_speed(target);
-				else {
+				} else {
 					retval = arm7_9_execute_sys_speed(target);
 
 					/*
@@ -2378,9 +2378,9 @@ int arm7_9_write_memory(struct target *target,
 					/* fast memory writes are only safe when the target is running
 					 * from a sufficiently high clock (32 kHz is usually too slow)
 					 */
-					if (arm7_9->fast_memory_access)
+					if (arm7_9->fast_memory_access) {
 						retval = arm7_9_execute_fast_sys_speed(target);
-					else {
+					} else {
 						retval = arm7_9_execute_sys_speed(target);
 
 						/*
@@ -2421,9 +2421,9 @@ int arm7_9_write_memory(struct target *target,
 					/* fast memory writes are only safe when the target is running
 					 * from a sufficiently high clock (32 kHz is usually too slow)
 					 */
-					if (arm7_9->fast_memory_access)
+					if (arm7_9->fast_memory_access) {
 						retval = arm7_9_execute_fast_sys_speed(target);
-					else {
+					} else {
 						retval = arm7_9_execute_sys_speed(target);
 
 						/*
diff --git a/src/target/dsp563xx.c b/src/target/dsp563xx.c
index dc85a21800..ae1c99dfbb 100644
--- a/src/target/dsp563xx.c
+++ b/src/target/dsp563xx.c
@@ -816,11 +816,9 @@ static int dsp563xx_write_register(struct target *target, int num, int force)
 					arch_info->instr_mask,
 					dsp563xx->core_regs[num]);
 
-				if ((err == ERROR_OK) && (arch_info->num == DSP563XX_REG_IDX_SP)) {
-					dsp563xx->core_cache->reg_list[DSP563XX_REG_IDX_SSH].valid =
-						0;
-					dsp563xx->core_cache->reg_list[DSP563XX_REG_IDX_SSL].valid =
-						0;
+				if (err == ERROR_OK && arch_info->num == DSP563XX_REG_IDX_SP) {
+					dsp563xx->core_cache->reg_list[DSP563XX_REG_IDX_SSH].valid = 0;
+					dsp563xx->core_cache->reg_list[DSP563XX_REG_IDX_SSL].valid = 0;
 				}
 
 				break;
diff --git a/src/target/etm.c b/src/target/etm.c
index d9a3cdc5e5..dd9ed97d5c 100644
--- a/src/target/etm.c
+++ b/src/target/etm.c
@@ -933,7 +933,6 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 					ctx->current_pc = ctx->last_branch;
 					ctx->pipe_index++;
 					continue;
-					break;
 				case 0x2:	/* trace restarted after FIFO overflow */
 					command_print(cmd,
 						"--- trace restarted after FIFO overflow at 0x%8.8" PRIx32 " ---",
@@ -941,7 +940,6 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 					ctx->current_pc = ctx->last_branch;
 					ctx->pipe_index++;
 					continue;
-					break;
 				case 0x3:	/* exit from debug state */
 					command_print(cmd,
 						"--- exit from debug state at 0x%8.8" PRIx32 " ---",
@@ -949,7 +947,6 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 					ctx->current_pc = ctx->last_branch;
 					ctx->pipe_index++;
 					continue;
-					break;
 				case 0x4:	/* periodic synchronization point */
 					next_pc = ctx->last_branch;
 					/* if we had no valid PC prior to this synchronization point,
@@ -965,8 +962,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocatio
 					}
 					break;
 				default:	/* reserved */
-					LOG_ERROR(
-						"BUG: branch reason code 0x%" PRIx32 " is reserved",
+					LOG_ERROR("BUG: branch reason code 0x%" PRIx32 " is reserved",
 						ctx->last_branch_reason);
 					return ERROR_FAIL;
 			}
diff --git a/src/target/openrisc/jsp_server.c b/src/target/openrisc/jsp_server.c
index 185a506c45..917b872002 100644
--- a/src/target/openrisc/jsp_server.c
+++ b/src/target/openrisc/jsp_server.c
@@ -119,9 +119,9 @@ static int jsp_input(struct connection *connection)
 	while (bytes_read) {
 		switch (t_con->state) {
 			case TELNET_STATE_DATA:
-				if (*buf_p == 0xff)
+				if (*buf_p == 0xff) {
 					t_con->state = TELNET_STATE_IAC;
-				else {
+				} else {
 					int out_len = 1;
 					int in_len;
 					unsigned char in_buffer[10];
@@ -129,8 +129,7 @@ static int jsp_input(struct connection *connection)
 							       &out_len, buf_p, &in_len,
 							       in_buffer);
 					if (in_len)
-						telnet_write(connection,
-							     in_buffer, in_len);
+						telnet_write(connection, in_buffer, in_len);
 				}
 				break;
 			case TELNET_STATE_IAC:
diff --git a/src/target/semihosting_common.c b/src/target/semihosting_common.c
index ffcd3aafde..93016c66f8 100644
--- a/src/target/semihosting_common.c
+++ b/src/target/semihosting_common.c
@@ -452,7 +452,8 @@ int semihosting_common(struct target *target)
 			retval = semihosting_read_fields(target, 1, fields);
 			if (retval != ERROR_OK)
 				return retval;
-			else {
+
+			{
 				int fd = semihosting_get_field(target, 0, fields);
 				/* Do not allow to close OpenOCD's own standard streams */
 				if (fd == 0 || fd == 1 || fd == 2) {
@@ -554,49 +555,43 @@ int semihosting_common(struct target *target)
 				retval = semihosting_read_fields(target, 2, fields);
 				if (retval != ERROR_OK)
 					return retval;
-				else {
-					int type = semihosting_get_field(target, 0, fields);
-					int code = semihosting_get_field(target, 1, fields);
-
-					if (type == ADP_STOPPED_APPLICATION_EXIT) {
-						if (!gdb_get_actual_connections())
-							exit(code);
-						else {
-							fprintf(stderr,
-								"semihosting: *** application exited with %d ***\n",
-								code);
-						}
-					} else {
-						fprintf(stderr,
-							"semihosting: application exception %#x\n",
-							type);
-					}
+
+				int type = semihosting_get_field(target, 0, fields);
+				int code = semihosting_get_field(target, 1, fields);
+
+				if (type == ADP_STOPPED_APPLICATION_EXIT) {
+					if (!gdb_get_actual_connections())
+						exit(code);
+
+					fprintf(stderr,
+						"semihosting: *** application exited with %d ***\n",
+						code);
+				} else {
+					fprintf(stderr,
+						"semihosting: application exception %#x\n", type);
 				}
 			} else {
 				if (semihosting->param == ADP_STOPPED_APPLICATION_EXIT) {
 					if (!gdb_get_actual_connections())
 						exit(0);
-					else {
-						fprintf(stderr,
-							"semihosting: *** application exited normally ***\n");
-					}
+
+					fprintf(stderr,
+						"semihosting: *** application exited normally ***\n");
 				} else if (semihosting->param == ADP_STOPPED_RUN_TIME_ERROR) {
 					/* Chosen more or less arbitrarily to have a nicer message,
 					 * otherwise all other return the same exit code 1. */
 					if (!gdb_get_actual_connections())
 						exit(1);
-					else {
-						fprintf(stderr,
-							"semihosting: *** application exited with error ***\n");
-					}
+
+					fprintf(stderr,
+						"semihosting: *** application exited with error ***\n");
 				} else {
 					if (!gdb_get_actual_connections())
 						exit(1);
-					else {
-						fprintf(stderr,
-							"semihosting: application exception %#x\n",
-							(unsigned) semihosting->param);
-					}
+
+					fprintf(stderr,
+						"semihosting: application exception %#x\n",
+						(unsigned int)semihosting->param);
 				}
 			}
 			if (!semihosting->has_resumable_exit) {
@@ -645,21 +640,20 @@ int semihosting_common(struct target *target)
 			retval = semihosting_read_fields(target, 2, fields);
 			if (retval != ERROR_OK)
 				return retval;
-			else {
+
+			{
 				int type = semihosting_get_field(target, 0, fields);
 				int code = semihosting_get_field(target, 1, fields);
 
 				if (type == ADP_STOPPED_APPLICATION_EXIT) {
 					if (!gdb_get_actual_connections())
 						exit(code);
-					else {
-						fprintf(stderr,
-							"semihosting: *** application exited with %d ***\n",
-							code);
-					}
+
+					fprintf(stderr,
+						"semihosting: *** application exited with %d ***\n",
+						code);
 				} else {
-					fprintf(stderr, "semihosting: exception %#x\n",
-						type);
+					fprintf(stderr, "semihosting: exception %#x\n", type);
 				}
 			}
 			if (!semihosting->has_resumable_exit) {
@@ -691,7 +685,8 @@ int semihosting_common(struct target *target)
 			retval = semihosting_read_fields(target, 1, fields);
 			if (retval != ERROR_OK)
 				return retval;
-			else {
+
+			{
 				int fd = semihosting_get_field(target, 0, fields);
 				struct stat buf;
 				semihosting->result = fstat(fd, &buf);
@@ -736,16 +731,16 @@ int semihosting_common(struct target *target)
 			retval = semihosting_read_fields(target, 2, fields);
 			if (retval != ERROR_OK)
 				return retval;
-			else {
+
+			{
 				uint64_t addr = semihosting_get_field(target, 0, fields);
 				size_t size = semihosting_get_field(target, 1, fields);
 
-				char *arg = semihosting->cmdline ?
-					semihosting->cmdline : "";
+				char *arg = semihosting->cmdline ? semihosting->cmdline : "";
 				uint32_t len = strlen(arg) + 1;
-				if (len > size)
+				if (len > size) {
 					semihosting->result = -1;
-				else {
+				} else {
 					semihosting_set_field(target, len, 1, fields);
 					retval = target_write_buffer(target, addr, len,
 							(uint8_t *)arg);
@@ -784,7 +779,8 @@ int semihosting_common(struct target *target)
 			retval = semihosting_read_fields(target, 1, fields);
 			if (retval != ERROR_OK)
 				return retval;
-			else {
+
+			{
 				uint64_t addr = semihosting_get_field(target, 0, fields);
 				/* tell the remote we have no idea */
 				memset(fields, 0, 4 * semihosting->word_size_bytes);
@@ -908,7 +904,8 @@ int semihosting_common(struct target *target)
 			retval = semihosting_read_fields(target, 3, fields);
 			if (retval != ERROR_OK)
 				return retval;
-			else {
+
+			{
 				uint64_t addr = semihosting_get_field(target, 0, fields);
 				uint32_t mode = semihosting_get_field(target, 1, fields);
 				size_t len = semihosting_get_field(target, 2, fields);
@@ -1038,7 +1035,8 @@ int semihosting_common(struct target *target)
 			retval = semihosting_read_fields(target, 3, fields);
 			if (retval != ERROR_OK)
 				return retval;
-			else {
+
+			{
 				int fd = semihosting_get_field(target, 0, fields);
 				uint64_t addr = semihosting_get_field(target, 1, fields);
 				size_t len = semihosting_get_field(target, 2, fields);
@@ -1117,7 +1115,8 @@ int semihosting_common(struct target *target)
 			retval = semihosting_read_fields(target, 2, fields);
 			if (retval != ERROR_OK)
 				return retval;
-			else {
+
+			{
 				uint64_t addr = semihosting_get_field(target, 0, fields);
 				size_t len = semihosting_get_field(target, 1, fields);
 				if (semihosting->is_fileio) {
@@ -1131,9 +1130,7 @@ int semihosting_common(struct target *target)
 						semihosting->result = -1;
 						semihosting->sys_errno = ENOMEM;
 					} else {
-						retval =
-							target_read_memory(target, addr, 1, len,
-								fn);
+						retval = target_read_memory(target, addr, 1, len, fn);
 						if (retval != ERROR_OK) {
 							free(fn);
 							return retval;
@@ -1171,7 +1168,8 @@ int semihosting_common(struct target *target)
 			retval = semihosting_read_fields(target, 4, fields);
 			if (retval != ERROR_OK)
 				return retval;
-			else {
+
+			{
 				uint64_t addr1 = semihosting_get_field(target, 0, fields);
 				size_t len1 = semihosting_get_field(target, 1, fields);
 				uint64_t addr2 = semihosting_get_field(target, 2, fields);
@@ -1192,15 +1190,13 @@ int semihosting_common(struct target *target)
 						semihosting->result = -1;
 						semihosting->sys_errno = ENOMEM;
 					} else {
-						retval = target_read_memory(target, addr1, 1, len1,
-								fn1);
+						retval = target_read_memory(target, addr1, 1, len1, fn1);
 						if (retval != ERROR_OK) {
 							free(fn1);
 							free(fn2);
 							return retval;
 						}
-						retval = target_read_memory(target, addr2, 1, len2,
-								fn2);
+						retval = target_read_memory(target, addr2, 1, len2, fn2);
 						if (retval != ERROR_OK) {
 							free(fn1);
 							free(fn2);
@@ -1208,8 +1204,7 @@ int semihosting_common(struct target *target)
 						}
 						fn1[len1] = 0;
 						fn2[len2] = 0;
-						semihosting->result = rename((char *)fn1,
-								(char *)fn2);
+						semihosting->result = rename((char *)fn1, (char *)fn2);
 						// rename() on Windows returns nonzero on error
 						if (semihosting->result != 0)
 							semihosting->sys_errno = errno;
@@ -1246,7 +1241,8 @@ int semihosting_common(struct target *target)
 			retval = semihosting_read_fields(target, 2, fields);
 			if (retval != ERROR_OK)
 				return retval;
-			else {
+
+			{
 				int fd = semihosting_get_field(target, 0, fields);
 				off_t pos = semihosting_get_field(target, 1, fields);
 				if (semihosting->is_fileio) {
@@ -1292,7 +1288,8 @@ int semihosting_common(struct target *target)
 			retval = semihosting_read_fields(target, 2, fields);
 			if (retval != ERROR_OK)
 				return retval;
-			else {
+
+			{
 				uint64_t addr = semihosting_get_field(target, 0, fields);
 				size_t len = semihosting_get_field(target, 1, fields);
 				if (semihosting->is_fileio) {
@@ -1314,12 +1311,10 @@ int semihosting_common(struct target *target)
 						if (retval != ERROR_OK) {
 							free(cmd);
 							return retval;
-						} else {
-							cmd[len] = 0;
-							semihosting->result = system(
-									(const char *)cmd);
-							LOG_DEBUG("system('%s')=%" PRId64, cmd, semihosting->result);
 						}
+						cmd[len] = 0;
+						semihosting->result = system((const char *)cmd);
+						LOG_DEBUG("system('%s')=%" PRId64, cmd, semihosting->result);
 
 						free(cmd);
 					}
@@ -1374,7 +1369,8 @@ int semihosting_common(struct target *target)
 			retval = semihosting_read_fields(target, 3, fields);
 			if (retval != ERROR_OK)
 				return retval;
-			else {
+
+			{
 				int fd = semihosting_get_field(target, 0, fields);
 				uint64_t addr = semihosting_get_field(target, 1, fields);
 				size_t len = semihosting_get_field(target, 2, fields);
@@ -1634,7 +1630,7 @@ int semihosting_common(struct target *target)
 
 		default:
 			fprintf(stderr, "semihosting: unsupported call %#x\n",
-				(unsigned) semihosting->op);
+				(unsigned int)semihosting->op);
 			semihosting->result = -1;
 			semihosting->sys_errno = ENOTSUP;
 	}
diff --git a/src/target/x86_32_common.c b/src/target/x86_32_common.c
index 8cca9a5e91..e3a76d28ba 100644
--- a/src/target/x86_32_common.c
+++ b/src/target/x86_32_common.c
@@ -1208,15 +1208,13 @@ static int set_watchpoint(struct target *t, struct watchpoint *wp)
 	switch (wp->rw) {
 		case WPT_WRITE:
 			if (set_debug_regs(t, wp->address, wp_num,
-						DR7_BP_WRITE, wp->length) != ERROR_OK) {
+						DR7_BP_WRITE, wp->length) != ERROR_OK)
 				return ERROR_FAIL;
-			}
 			break;
 		case WPT_ACCESS:
 			if (set_debug_regs(t, wp->address, wp_num, DR7_BP_READWRITE,
-						wp->length) != ERROR_OK) {
+						wp->length) != ERROR_OK)
 				return ERROR_FAIL;
-			}
 			break;
 		default:
 			LOG_ERROR("%s only 'access' or 'write' watchpoints are supported", __func__);
diff --git a/src/target/xscale.c b/src/target/xscale.c
index 84318a905f..f3feb50cc9 100644
--- a/src/target/xscale.c
+++ b/src/target/xscale.c
@@ -2711,7 +2711,7 @@ static int xscale_analyze_trace(struct target *target, struct command_invocation
 
 				case 13:	/* Checkpointed Indirect Branch */
 					xscale_branch_address(trace_data, i, &branch_target);
-					if ((trace_data->num_checkpoints == 2) && (chkpt == 0))
+					if (trace_data->num_checkpoints == 2 && chkpt == 0)
 						chkpt_reg = trace_data->chkpt1;	/* 2 chkpts, this is
 										 *oldest */
 					else
@@ -2722,7 +2722,7 @@ static int xscale_analyze_trace(struct target *target, struct command_invocation
 					break;
 
 				case 12:	/* Checkpointed Direct Branch */
-					if ((trace_data->num_checkpoints == 2) && (chkpt == 0))
+					if (trace_data->num_checkpoints == 2 && chkpt == 0)
 						chkpt_reg = trace_data->chkpt1;	/* 2 chkpts, this is
 										 *oldest */
 					else

-- 

[PATCH]: e23ccfa70b jtag: drivers: ulink: special align switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9056

-- gerrit

commit e23ccfa70bffa89baa2e2eabced24b2c60d6dbde
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jul 26 18:39:07 2025 +0200

    jtag: drivers: ulink: special align switch and case statements
    
    The coding style requires the 'case' to be at the same indentation
    level of its 'switch' statement.
    
    Checkpatch is not able to detect numbers in exponential format,
    like 6E-5, and complains about missing space around the operator
    minus.
    
    To complete the alignment of switch and case statements in this
    file, use a separate commit with the special checkpatch ignore tag
    in the commit message.
    
    Align the code accordingly.
    
    No changes are reported by
            git log -p -w --ignore-blank-lines --patience
    
    Checkpatch-ignore: SPACING
    Change-Id: Ibe70c4a4d3f0bb44c03007103910b778944bb90e
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/jtag/drivers/ulink.c b/src/jtag/drivers/ulink.c
index 93b8629261..1f14b1a047 100644
--- a/src/jtag/drivers/ulink.c
+++ b/src/jtag/drivers/ulink.c
@@ -1285,24 +1285,24 @@ static int ulink_calculate_delay(enum ulink_delay_type type, long f, int *delay)
 	t = 1.0 / (float)(f);
 
 	switch (type) {
-	    case DELAY_CLOCK_TCK:
-		    x = (t - (float)(6E-6)) / (float)(4E-6);
-		    break;
-	    case DELAY_CLOCK_TMS:
-		    x = (t - (float)(8.5E-6)) / (float)(4E-6);
-		    break;
-	    case DELAY_SCAN_IN:
-		    x = (t - (float)(8.8308E-6)) / (float)(4E-6);
-		    break;
-	    case DELAY_SCAN_OUT:
-		    x = (t - (float)(1.0527E-5)) / (float)(4E-6);
-		    break;
-	    case DELAY_SCAN_IO:
-		    x = (t - (float)(1.3132E-5)) / (float)(4E-6);
-		    break;
-	    default:
-		    return ERROR_FAIL;
-		    break;
+	case DELAY_CLOCK_TCK:
+	    x = (t - (float)(6E-6)) / (float)(4E-6);
+	    break;
+	case DELAY_CLOCK_TMS:
+	    x = (t - (float)(8.5E-6)) / (float)(4E-6);
+	    break;
+	case DELAY_SCAN_IN:
+	    x = (t - (float)(8.8308E-6)) / (float)(4E-6);
+	    break;
+	case DELAY_SCAN_OUT:
+	    x = (t - (float)(1.0527E-5)) / (float)(4E-6);
+	    break;
+	case DELAY_SCAN_IO:
+	    x = (t - (float)(1.3132E-5)) / (float)(4E-6);
+	    break;
+	default:
+	    return ERROR_FAIL;
+	    break;
 	}
 
 	/* Check if the delay value is negative. This happens when a frequency is
@@ -1345,38 +1345,38 @@ static long ulink_calculate_frequency(enum ulink_delay_type type, int delay)
 		return 0;
 
 	switch (type) {
-	    case DELAY_CLOCK_TCK:
-		    if (delay < 0)
-			    t = (float)(2.666E-6);
-		    else
-			    t = (float)(4E-6) * (float)(delay) + (float)(6E-6);
-		    break;
-	    case DELAY_CLOCK_TMS:
-		    if (delay < 0)
-			    t = (float)(5.666E-6);
-		    else
-			    t = (float)(4E-6) * (float)(delay) + (float)(8.5E-6);
-		    break;
-	    case DELAY_SCAN_IN:
-		    if (delay < 0)
-			    t = (float)(5.5E-6);
-		    else
-			    t = (float)(4E-6) * (float)(delay) + (float)(8.8308E-6);
-		    break;
-	    case DELAY_SCAN_OUT:
-		    if (delay < 0)
-			    t = (float)(7.0E-6);
-		    else
-			    t = (float)(4E-6) * (float)(delay) + (float)(1.0527E-5);
-		    break;
-	    case DELAY_SCAN_IO:
-		    if (delay < 0)
-			    t = (float)(9.926E-6);
-		    else
-			    t = (float)(4E-6) * (float)(delay) + (float)(1.3132E-5);
-		    break;
-	    default:
-		    return 0;
+	case DELAY_CLOCK_TCK:
+	    if (delay < 0)
+		    t = (float)(2.666E-6);
+	    else
+		    t = (float)(4E-6) * (float)(delay) + (float)(6E-6);
+	    break;
+	case DELAY_CLOCK_TMS:
+	    if (delay < 0)
+		    t = (float)(5.666E-6);
+	    else
+		    t = (float)(4E-6) * (float)(delay) + (float)(8.5E-6);
+	    break;
+	case DELAY_SCAN_IN:
+	    if (delay < 0)
+		    t = (float)(5.5E-6);
+	    else
+		    t = (float)(4E-6) * (float)(delay) + (float)(8.8308E-6);
+	    break;
+	case DELAY_SCAN_OUT:
+	    if (delay < 0)
+		    t = (float)(7.0E-6);
+	    else
+		    t = (float)(4E-6) * (float)(delay) + (float)(1.0527E-5);
+	    break;
+	case DELAY_SCAN_IO:
+	    if (delay < 0)
+		    t = (float)(9.926E-6);
+	    else
+		    t = (float)(4E-6) * (float)(delay) + (float)(1.3132E-5);
+	    break;
+	default:
+	    return 0;
 	}
 
 	f_float = 1.0 / t;

-- 

[PATCH]: cd0ac18f12 target: align switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9051

-- gerrit

commit cd0ac18f12123df6f627f25031e69fe6faed9717
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jul 26 15:46:26 2025 +0200

    target: align switch and case statements
    
    The coding style requires the 'case' to be at the same indentation
    level of its 'switch' statement.
    
    Align the code accordingly.
    
    While there:
    - add space around the operators;
    - drop useless empty line.
    
    Skip all riscv code, as it is going to be updated soon from the
    external fork.
    
    No changes are reported by
            git log -p -w --ignore-blank-lines --patience
    
    Change-Id: I2691dfdd2b6734143e14160b46183623e9773539
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/target/aarch64.c b/src/target/aarch64.c
index 101cb14408..87b02fea32 100644
--- a/src/target/aarch64.c
+++ b/src/target/aarch64.c
@@ -613,22 +613,22 @@ static int aarch64_restore_one(struct target *target, bool current,
 	 * kill the return address
 	 */
 	switch (arm->core_state) {
-		case ARM_STATE_ARM:
-			resume_pc &= 0xFFFFFFFC;
-			break;
-		case ARM_STATE_AARCH64:
-			resume_pc &= 0xFFFFFFFFFFFFFFFCULL;
-			break;
-		case ARM_STATE_THUMB:
-		case ARM_STATE_THUMB_EE:
-			/* When the return address is loaded into PC
-			 * bit 0 must be 1 to stay in Thumb state
-			 */
-			resume_pc |= 0x1;
-			break;
-		case ARM_STATE_JAZELLE:
-			LOG_ERROR("How do I resume into Jazelle state??");
-			return ERROR_FAIL;
+	case ARM_STATE_ARM:
+		resume_pc &= 0xFFFFFFFC;
+		break;
+	case ARM_STATE_AARCH64:
+		resume_pc &= 0xFFFFFFFFFFFFFFFCULL;
+		break;
+	case ARM_STATE_THUMB:
+	case ARM_STATE_THUMB_EE:
+		/* When the return address is loaded into PC
+		 * bit 0 must be 1 to stay in Thumb state
+		 */
+		resume_pc |= 0x1;
+		break;
+	case ARM_STATE_JAZELLE:
+		LOG_ERROR("How do I resume into Jazelle state??");
+		return ERROR_FAIL;
 	}
 	LOG_DEBUG("resume pc = 0x%016" PRIx64, resume_pc);
 	buf_set_u64(arm->pc->value, 0, 64, resume_pc);
@@ -3027,14 +3027,14 @@ COMMAND_HANDLER(aarch64_handle_disassemble_command)
 	target_addr_t address;
 
 	switch (CMD_ARGC) {
-		case 2:
-			COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], count);
-		/* FALL THROUGH */
-		case 1:
-			COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);
-			break;
-		default:
-			return ERROR_COMMAND_SYNTAX_ERROR;
+	case 2:
+		COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], count);
+	/* FALL THROUGH */
+	case 1:
+		COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);
+		break;
+	default:
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
 	return a64_disassemble(CMD, target, address, count);
diff --git a/src/target/arc.c b/src/target/arc.c
index f2482c25ef..638e22099e 100644
--- a/src/target/arc.c
+++ b/src/target/arc.c
@@ -1892,18 +1892,18 @@ static int arc_set_watchpoint(struct target *target,
 
 	int enable = AP_AC_TT_DISABLE;
 	switch (watchpoint->rw) {
-		case WPT_READ:
-			enable = AP_AC_TT_READ;
-			break;
-		case WPT_WRITE:
-			enable = AP_AC_TT_WRITE;
-			break;
-		case WPT_ACCESS:
-			enable = AP_AC_TT_READWRITE;
-			break;
-		default:
-			LOG_TARGET_ERROR(target, "BUG: watchpoint->rw neither read, write nor access");
-			return ERROR_FAIL;
+	case WPT_READ:
+		enable = AP_AC_TT_READ;
+		break;
+	case WPT_WRITE:
+		enable = AP_AC_TT_WRITE;
+		break;
+	case WPT_ACCESS:
+		enable = AP_AC_TT_READWRITE;
+		break;
+	default:
+		LOG_TARGET_ERROR(target, "BUG: watchpoint->rw neither read, write nor access");
+		return ERROR_FAIL;
 	}
 
 	int retval =  arc_configure_actionpoint(target, wp_num,
diff --git a/src/target/arc_cmd.c b/src/target/arc_cmd.c
index bf8a8aa28b..2e42398d28 100644
--- a/src/target/arc_cmd.c
+++ b/src/target/arc_cmd.c
@@ -709,29 +709,29 @@ COMMAND_HANDLER(arc_handle_get_reg_field)
 	int retval = arc_reg_get_field(target, reg_name, field_name, &value);
 
 	switch (retval) {
-		case ERROR_OK:
-			break;
-		case ERROR_ARC_REGISTER_NOT_FOUND:
-			command_print(CMD,
-				"Register `%s' has not been found.", reg_name);
-			return ERROR_COMMAND_ARGUMENT_INVALID;
-		case ERROR_ARC_REGISTER_IS_NOT_STRUCT:
-			command_print(CMD,
-				"Register `%s' must have 'struct' type.", reg_name);
-			return ERROR_COMMAND_ARGUMENT_INVALID;
-		case ERROR_ARC_REGISTER_FIELD_NOT_FOUND:
-			command_print(CMD,
-				"Field `%s' has not been found in register `%s'.",
-				field_name, reg_name);
-			return ERROR_COMMAND_ARGUMENT_INVALID;
-		case ERROR_ARC_FIELD_IS_NOT_BITFIELD:
-			command_print(CMD,
-				"Field `%s' is not a 'bitfield' field in a structure.",
-				field_name);
-			return ERROR_COMMAND_ARGUMENT_INVALID;
-		default:
-			/* Pass through other errors. */
-			return retval;
+	case ERROR_OK:
+		break;
+	case ERROR_ARC_REGISTER_NOT_FOUND:
+		command_print(CMD,
+			"Register `%s' has not been found.", reg_name);
+		return ERROR_COMMAND_ARGUMENT_INVALID;
+	case ERROR_ARC_REGISTER_IS_NOT_STRUCT:
+		command_print(CMD,
+			"Register `%s' must have 'struct' type.", reg_name);
+		return ERROR_COMMAND_ARGUMENT_INVALID;
+	case ERROR_ARC_REGISTER_FIELD_NOT_FOUND:
+		command_print(CMD,
+			"Field `%s' has not been found in register `%s'.",
+			field_name, reg_name);
+		return ERROR_COMMAND_ARGUMENT_INVALID;
+	case ERROR_ARC_FIELD_IS_NOT_BITFIELD:
+		command_print(CMD,
+			"Field `%s' is not a 'bitfield' field in a structure.",
+			field_name);
+		return ERROR_COMMAND_ARGUMENT_INVALID;
+	default:
+		/* Pass through other errors. */
+		return retval;
 	}
 
 	command_print(CMD, "0x%" PRIx32, value);
diff --git a/src/target/arm11.c b/src/target/arm11.c
index 8ba0812d8d..6b88e69c44 100644
--- a/src/target/arm11.c
+++ b/src/target/arm11.c
@@ -414,19 +414,19 @@ static uint32_t arm11_nextpc(struct arm11_common *arm11, bool current,
 	 * kill the return address
 	 */
 	switch (arm11->arm.core_state) {
-		case ARM_STATE_ARM:
-			address &= 0xFFFFFFFC;
-			break;
-		case ARM_STATE_THUMB:
-			/* When the return address is loaded into PC
-			 * bit 0 must be 1 to stay in Thumb state
-			 */
-			address |= 0x1;
-			break;
-
-		/* catch-all for JAZELLE and THUMB_EE */
-		default:
-			break;
+	case ARM_STATE_ARM:
+		address &= 0xFFFFFFFC;
+		break;
+	case ARM_STATE_THUMB:
+		/* When the return address is loaded into PC
+		 * bit 0 must be 1 to stay in Thumb state
+		 */
+		address |= 0x1;
+		break;
+
+	/* catch-all for JAZELLE and THUMB_EE */
+	default:
+		break;
 	}
 
 	buf_set_u32(value, 0, 32, address);
@@ -819,44 +819,44 @@ static int arm11_read_memory_inner(struct target *target,
 		return retval;
 
 	switch (size) {
-		case 1:
-			arm11->arm.core_cache->reg_list[1].dirty = true;
+	case 1:
+		arm11->arm.core_cache->reg_list[1].dirty = true;
 
-			for (size_t i = 0; i < count; i++) {
-				/* ldrb    r1, [r0], #1 */
-				/* ldrb    r1, [r0] */
-				CHECK_RETVAL(arm11_run_instr_no_data1(arm11,
-						!arm11_config_memrw_no_increment ? 0xe4d01001 : 0xe5d01000));
+		for (size_t i = 0; i < count; i++) {
+			/* ldrb    r1, [r0], #1 */
+			/* ldrb    r1, [r0] */
+			CHECK_RETVAL(arm11_run_instr_no_data1(arm11,
+					!arm11_config_memrw_no_increment ? 0xe4d01001 : 0xe5d01000));
 
-				uint32_t res;
-				/* MCR p14,0,R1,c0,c5,0 */
-				CHECK_RETVAL(arm11_run_instr_data_from_core(arm11, 0xEE001E15, &res, 1));
+			uint32_t res;
+			/* MCR p14,0,R1,c0,c5,0 */
+			CHECK_RETVAL(arm11_run_instr_data_from_core(arm11, 0xEE001E15, &res, 1));
 
-				*buffer++ = res;
-			}
+			*buffer++ = res;
+		}
 
-			break;
+		break;
 
-		case 2:
-			arm11->arm.core_cache->reg_list[1].dirty = true;
+	case 2:
+		arm11->arm.core_cache->reg_list[1].dirty = true;
 
-			for (size_t i = 0; i < count; i++) {
-				/* ldrh    r1, [r0], #2 */
-				CHECK_RETVAL(arm11_run_instr_no_data1(arm11,
-						!arm11_config_memrw_no_increment ? 0xe0d010b2 : 0xe1d010b0));
+		for (size_t i = 0; i < count; i++) {
+			/* ldrh    r1, [r0], #2 */
+			CHECK_RETVAL(arm11_run_instr_no_data1(arm11,
+					!arm11_config_memrw_no_increment ? 0xe0d010b2 : 0xe1d010b0));
 
-				uint32_t res;
+			uint32_t res;
 
-				/* MCR p14,0,R1,c0,c5,0 */
-				CHECK_RETVAL(arm11_run_instr_data_from_core(arm11, 0xEE001E15, &res, 1));
+			/* MCR p14,0,R1,c0,c5,0 */
+			CHECK_RETVAL(arm11_run_instr_data_from_core(arm11, 0xEE001E15, &res, 1));
 
-				uint16_t svalue = res;
-				memcpy(buffer + i * sizeof(uint16_t), &svalue, sizeof(uint16_t));
-			}
+			uint16_t svalue = res;
+			memcpy(buffer + i * sizeof(uint16_t), &svalue, sizeof(uint16_t));
+		}
 
-			break;
+		break;
 
-		case 4:
+	case 4:
 		{
 			uint32_t instr = !arm11_config_memrw_no_increment ? 0xecb05e01 : 0xed905e00;
 			/** \todo TODO: buffer cast to uint32_t* causes alignment warnings */
@@ -925,52 +925,52 @@ static int arm11_write_memory_inner(struct target *target,
 	bool burst = arm11->memwrite_burst && (count > 1);
 
 	switch (size) {
-		case 1:
-			arm11->arm.core_cache->reg_list[1].dirty = true;
-
-			for (size_t i = 0; i < count; i++) {
-				/* load r1 from DCC with byte data */
-				/* MRC p14,0,r1,c0,c5,0 */
-				retval = arm11_run_instr_data_to_core1(arm11, 0xee101e15, *buffer++);
-				if (retval != ERROR_OK)
-					return retval;
-
-				/* write r1 to memory */
-				/* strb    r1, [r0], #1 */
-				/* strb    r1, [r0] */
-				retval = arm11_run_instr_no_data1(arm11,
-						!no_increment ? 0xe4c01001 : 0xe5c01000);
-				if (retval != ERROR_OK)
-					return retval;
-			}
+	case 1:
+		arm11->arm.core_cache->reg_list[1].dirty = true;
 
-			break;
+		for (size_t i = 0; i < count; i++) {
+			/* load r1 from DCC with byte data */
+			/* MRC p14,0,r1,c0,c5,0 */
+			retval = arm11_run_instr_data_to_core1(arm11, 0xee101e15, *buffer++);
+			if (retval != ERROR_OK)
+				return retval;
 
-		case 2:
-			arm11->arm.core_cache->reg_list[1].dirty = true;
-
-			for (size_t i = 0; i < count; i++) {
-				uint16_t value;
-				memcpy(&value, buffer + i * sizeof(uint16_t), sizeof(uint16_t));
-
-				/* load r1 from DCC with halfword data */
-				/* MRC p14,0,r1,c0,c5,0 */
-				retval = arm11_run_instr_data_to_core1(arm11, 0xee101e15, value);
-				if (retval != ERROR_OK)
-					return retval;
-
-				/* write r1 to memory */
-				/* strh    r1, [r0], #2 */
-				/* strh    r1, [r0] */
-				retval = arm11_run_instr_no_data1(arm11,
-						!no_increment ? 0xe0c010b2 : 0xe1c010b0);
-				if (retval != ERROR_OK)
-					return retval;
-			}
+			/* write r1 to memory */
+			/* strb    r1, [r0], #1 */
+			/* strb    r1, [r0] */
+			retval = arm11_run_instr_no_data1(arm11,
+					!no_increment ? 0xe4c01001 : 0xe5c01000);
+			if (retval != ERROR_OK)
+				return retval;
+		}
 
-			break;
+		break;
+
+	case 2:
+		arm11->arm.core_cache->reg_list[1].dirty = true;
 
-		case 4:
+		for (size_t i = 0; i < count; i++) {
+			uint16_t value;
+			memcpy(&value, buffer + i * sizeof(uint16_t), sizeof(uint16_t));
+
+			/* load r1 from DCC with halfword data */
+			/* MRC p14,0,r1,c0,c5,0 */
+			retval = arm11_run_instr_data_to_core1(arm11, 0xee101e15, value);
+			if (retval != ERROR_OK)
+				return retval;
+
+			/* write r1 to memory */
+			/* strh    r1, [r0], #2 */
+			/* strh    r1, [r0] */
+			retval = arm11_run_instr_no_data1(arm11,
+					!no_increment ? 0xe0c010b2 : 0xe1c010b0);
+			if (retval != ERROR_OK)
+				return retval;
+		}
+
+		break;
+
+	case 4:
 		{
 			/* stream word data through DCC directly to memory */
 			/* increment:		STC p14,c5,[R0],#4 */
@@ -1159,34 +1159,34 @@ static int arm11_examine(struct target *target)
 
 	/* assume the manufacturer id is ok; check the part # */
 	switch ((device_id >> 12) & 0xFFFF) {
-		case 0x7B36:
-			type = "ARM1136";
-			break;
-		case 0x7B37:
-			type = "ARM11 MPCore";
-			break;
-		case 0x7B56:
-			type = "ARM1156";
-			break;
-		case 0x7B76:
-			arm11->arm.core_type = ARM_CORE_TYPE_SEC_EXT;
-			/* NOTE: could default arm11->hardware_step to true */
-			type = "ARM1176";
-			break;
-		default:
-			LOG_ERROR("unexpected ARM11 ID code");
-			return ERROR_FAIL;
+	case 0x7B36:
+		type = "ARM1136";
+		break;
+	case 0x7B37:
+		type = "ARM11 MPCore";
+		break;
+	case 0x7B56:
+		type = "ARM1156";
+		break;
+	case 0x7B76:
+		arm11->arm.core_type = ARM_CORE_TYPE_SEC_EXT;
+		/* NOTE: could default arm11->hardware_step to true */
+		type = "ARM1176";
+		break;
+	default:
+		LOG_ERROR("unexpected ARM11 ID code");
+		return ERROR_FAIL;
 	}
 	LOG_INFO("found %s", type);
 
 	/* unlikely this could ever fail, but ... */
 	switch ((didr >> 16) & 0x0F) {
-		case ARM11_DEBUG_V6:
-		case ARM11_DEBUG_V61:	/* supports security extensions */
-			break;
-		default:
-			LOG_ERROR("Only ARM v6 and v6.1 debug supported.");
-			return ERROR_FAIL;
+	case ARM11_DEBUG_V6:
+	case ARM11_DEBUG_V61:	/* supports security extensions */
+		break;
+	default:
+		LOG_ERROR("Only ARM v6 and v6.1 debug supported.");
+		return ERROR_FAIL;
 	}
 
 	arm11->brp = ((didr >> 24) & 0x0F) + 1;
@@ -1250,13 +1250,13 @@ COMMAND_HANDLER(arm11_handle_vcr)
 	struct arm11_common *arm11 = target_to_arm11(target);
 
 	switch (CMD_ARGC) {
-		case 0:
-			break;
-		case 1:
-			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], arm11->vcr);
-			break;
-		default:
-			return ERROR_COMMAND_SYNTAX_ERROR;
+	case 0:
+		break;
+	case 1:
+		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], arm11->vcr);
+		break;
+	default:
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
 	LOG_INFO("VCR 0x%08" PRIx32 "", arm11->vcr);
diff --git a/src/target/arm11_dbgtap.c b/src/target/arm11_dbgtap.c
index 4c7211365b..4c2fedaeb2 100644
--- a/src/target/arm11_dbgtap.c
+++ b/src/target/arm11_dbgtap.c
@@ -85,30 +85,30 @@ static const char *arm11_ir_to_string(uint8_t ir)
 	const char *s = "unknown";
 
 	switch (ir) {
-		case ARM11_EXTEST:
-			s = "EXTEST";
-			break;
-		case ARM11_SCAN_N:
-			s = "SCAN_N";
-			break;
-		case ARM11_RESTART:
-			s = "RESTART";
-			break;
-		case ARM11_HALT:
-			s = "HALT";
-			break;
-		case ARM11_INTEST:
-			s = "INTEST";
-			break;
-		case ARM11_ITRSEL:
-			s = "ITRSEL";
-			break;
-		case ARM11_IDCODE:
-			s = "IDCODE";
-			break;
-		case ARM11_BYPASS:
-			s = "BYPASS";
-			break;
+	case ARM11_EXTEST:
+		s = "EXTEST";
+		break;
+	case ARM11_SCAN_N:
+		s = "SCAN_N";
+		break;
+	case ARM11_RESTART:
+		s = "RESTART";
+		break;
+	case ARM11_HALT:
+		s = "HALT";
+		break;
+	case ARM11_INTEST:
+		s = "INTEST";
+		break;
+	case ARM11_ITRSEL:
+		s = "ITRSEL";
+		break;
+	case ARM11_IDCODE:
+		s = "IDCODE";
+		break;
+	case ARM11_BYPASS:
+		s = "BYPASS";
+		break;
 	}
 	return s;
 }
@@ -1061,17 +1061,17 @@ static int arm11_bpwp_enable(struct arm_dpm *dpm, unsigned int index_t,
 	action[1].value = control;
 
 	switch (index_t) {
-	    case 0 ... 15:
-		    action[0].address = ARM11_SC7_BVR0 + index_t;
-		    action[1].address = ARM11_SC7_BCR0 + index_t;
-		    break;
-	    case 16 ... 32:
-		    index_t -= 16;
-		    action[0].address = ARM11_SC7_WVR0 + index_t;
-		    action[1].address = ARM11_SC7_WCR0 + index_t;
-		    break;
-	    default:
-		    return ERROR_FAIL;
+	case 0 ... 15:
+	    action[0].address = ARM11_SC7_BVR0 + index_t;
+	    action[1].address = ARM11_SC7_BCR0 + index_t;
+	    break;
+	case 16 ... 32:
+	    index_t -= 16;
+	    action[0].address = ARM11_SC7_WVR0 + index_t;
+	    action[1].address = ARM11_SC7_WCR0 + index_t;
+	    break;
+	default:
+	    return ERROR_FAIL;
 	}
 
 	arm11->bpwp_n += 2;
@@ -1090,15 +1090,15 @@ static int arm11_bpwp_disable(struct arm_dpm *dpm, unsigned int index_t)
 	action[0].value = 0;
 
 	switch (index_t) {
-	    case 0 ... 15:
-		    action[0].address = ARM11_SC7_BCR0 + index_t;
-		    break;
-	    case 16 ... 32:
-		    index_t -= 16;
-		    action[0].address = ARM11_SC7_WCR0 + index_t;
-		    break;
-	    default:
-		    return ERROR_FAIL;
+	case 0 ... 15:
+	    action[0].address = ARM11_SC7_BCR0 + index_t;
+	    break;
+	case 16 ... 32:
+	    index_t -= 16;
+	    action[0].address = ARM11_SC7_WCR0 + index_t;
+	    break;
+	default:
+	    return ERROR_FAIL;
 	}
 
 	arm11->bpwp_n += 1;
diff --git a/src/target/arm7_9_common.c b/src/target/arm7_9_common.c
index f67e02bdbd..06041f8432 100644
--- a/src/target/arm7_9_common.c
+++ b/src/target/arm7_9_common.c
@@ -2138,18 +2138,49 @@ int arm7_9_read_memory(struct target *target,
 	int j = 0;
 
 	switch (size) {
-		case 4:
-			while (num_accesses < count) {
-				uint32_t reg_list;
-				thisrun_accesses =
-						((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
-				reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
+	case 4:
+		while (num_accesses < count) {
+			uint32_t reg_list;
+			thisrun_accesses =
+					((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
+			reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
+
+			if (last_reg <= thisrun_accesses)
+				last_reg = thisrun_accesses;
+
+			arm7_9->load_word_regs(target, reg_list);
+
+			/* fast memory reads are only safe when the target is running
+			 * from a sufficiently high clock (32 kHz is usually too slow)
+			 */
+			if (arm7_9->fast_memory_access)
+				retval = arm7_9_execute_fast_sys_speed(target);
+			else
+				retval = arm7_9_execute_sys_speed(target);
+			if (retval != ERROR_OK)
+				return retval;
 
-				if (last_reg <= thisrun_accesses)
-					last_reg = thisrun_accesses;
+			arm7_9->read_core_regs_target_buffer(target, reg_list, buffer, 4);
 
-				arm7_9->load_word_regs(target, reg_list);
+			/* advance buffer, count number of accesses */
+			buffer += thisrun_accesses * 4;
+			num_accesses += thisrun_accesses;
 
+			if ((j++ % 1024) == 0)
+				keep_alive();
+		}
+		break;
+	case 2:
+		while (num_accesses < count) {
+			uint32_t reg_list;
+			thisrun_accesses =
+					((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
+			reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
+
+			for (i = 1; i <= thisrun_accesses; i++) {
+				if (i > last_reg)
+				    last_reg = i;
+				arm7_9->load_hword_reg(target, i);
 				/* fast memory reads are only safe when the target is running
 				 * from a sufficiently high clock (32 kHz is usually too slow)
 				 */
@@ -2160,81 +2191,50 @@ int arm7_9_read_memory(struct target *target,
 				if (retval != ERROR_OK)
 					return retval;
 
-				arm7_9->read_core_regs_target_buffer(target, reg_list, buffer, 4);
-
-				/* advance buffer, count number of accesses */
-				buffer += thisrun_accesses * 4;
-				num_accesses += thisrun_accesses;
-
-				if ((j++%1024) == 0)
-					keep_alive();
 			}
-			break;
-		case 2:
-			while (num_accesses < count) {
-				uint32_t reg_list;
-				thisrun_accesses =
-						((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
-				reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
-
-				for (i = 1; i <= thisrun_accesses; i++) {
-					if (i > last_reg)
-					    last_reg = i;
-					arm7_9->load_hword_reg(target, i);
-					/* fast memory reads are only safe when the target is running
-					 * from a sufficiently high clock (32 kHz is usually too slow)
-					 */
-					if (arm7_9->fast_memory_access)
-						retval = arm7_9_execute_fast_sys_speed(target);
-					else
-						retval = arm7_9_execute_sys_speed(target);
-					if (retval != ERROR_OK)
-						return retval;
 
-				}
-
-				arm7_9->read_core_regs_target_buffer(target, reg_list, buffer, 2);
+			arm7_9->read_core_regs_target_buffer(target, reg_list, buffer, 2);
 
-				/* advance buffer, count number of accesses */
-				buffer += thisrun_accesses * 2;
-				num_accesses += thisrun_accesses;
+			/* advance buffer, count number of accesses */
+			buffer += thisrun_accesses * 2;
+			num_accesses += thisrun_accesses;
 
-				if ((j++%1024) == 0)
-					keep_alive();
+			if ((j++ % 1024) == 0)
+				keep_alive();
+		}
+		break;
+	case 1:
+		while (num_accesses < count) {
+			uint32_t reg_list;
+			thisrun_accesses =
+					((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
+			reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
+
+			for (i = 1; i <= thisrun_accesses; i++) {
+				if (i > last_reg)
+					last_reg = i;
+				arm7_9->load_byte_reg(target, i);
+				/* fast memory reads are only safe when the target is running
+				 * from a sufficiently high clock (32 kHz is usually too slow)
+				 */
+				if (arm7_9->fast_memory_access)
+					retval = arm7_9_execute_fast_sys_speed(target);
+				else
+					retval = arm7_9_execute_sys_speed(target);
+				if (retval != ERROR_OK)
+					return retval;
 			}
-			break;
-		case 1:
-			while (num_accesses < count) {
-				uint32_t reg_list;
-				thisrun_accesses =
-						((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
-				reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
-
-				for (i = 1; i <= thisrun_accesses; i++) {
-					if (i > last_reg)
-						last_reg = i;
-					arm7_9->load_byte_reg(target, i);
-					/* fast memory reads are only safe when the target is running
-					 * from a sufficiently high clock (32 kHz is usually too slow)
-					 */
-					if (arm7_9->fast_memory_access)
-						retval = arm7_9_execute_fast_sys_speed(target);
-					else
-						retval = arm7_9_execute_sys_speed(target);
-					if (retval != ERROR_OK)
-						return retval;
-				}
 
-				arm7_9->read_core_regs_target_buffer(target, reg_list, buffer, 1);
+			arm7_9->read_core_regs_target_buffer(target, reg_list, buffer, 1);
 
-				/* advance buffer, count number of accesses */
-				buffer += thisrun_accesses * 1;
-				num_accesses += thisrun_accesses;
+			/* advance buffer, count number of accesses */
+			buffer += thisrun_accesses * 1;
+			num_accesses += thisrun_accesses;
 
-				if ((j++%1024) == 0)
-					keep_alive();
-			}
-			break;
+			if ((j++ % 1024) == 0)
+				keep_alive();
+		}
+		break;
 	}
 
 	if (!is_arm_mode(arm->core_mode))
@@ -2313,23 +2313,67 @@ int arm7_9_write_memory(struct target *target,
 	embeddedice_store_reg(dbg_ctrl);
 
 	switch (size) {
-		case 4:
-			while (num_accesses < count) {
-				uint32_t reg_list;
-				thisrun_accesses =
-						((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
-				reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
-
-				for (i = 1; i <= thisrun_accesses; i++) {
-					if (i > last_reg)
-						last_reg = i;
-					reg[i] = target_buffer_get_u32(target, buffer);
-					buffer += 4;
-				}
+	case 4:
+		while (num_accesses < count) {
+			uint32_t reg_list;
+			thisrun_accesses =
+					((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
+			reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
+
+			for (i = 1; i <= thisrun_accesses; i++) {
+				if (i > last_reg)
+					last_reg = i;
+				reg[i] = target_buffer_get_u32(target, buffer);
+				buffer += 4;
+			}
 
-				arm7_9->write_core_regs(target, reg_list, reg);
+			arm7_9->write_core_regs(target, reg_list, reg);
 
-				arm7_9->store_word_regs(target, reg_list);
+			arm7_9->store_word_regs(target, reg_list);
+
+			/* fast memory writes are only safe when the target is running
+			 * from a sufficiently high clock (32 kHz is usually too slow)
+			 */
+			if (arm7_9->fast_memory_access) {
+				retval = arm7_9_execute_fast_sys_speed(target);
+			} else {
+				retval = arm7_9_execute_sys_speed(target);
+
+				/*
+				 * if memory writes are made when the clock is running slow
+				 * (i.e. 32 kHz) which is necessary in some scripts to reconfigure
+				 * processor operations after a "reset halt" or "reset init",
+				 * need to immediately stroke the keep alive or will end up with
+				 * gdb "keep alive not sent error message" problem.
+				 */
+
+				keep_alive();
+			}
+
+			if (retval != ERROR_OK)
+				return retval;
+
+			num_accesses += thisrun_accesses;
+		}
+		break;
+	case 2:
+		while (num_accesses < count) {
+			uint32_t reg_list;
+			thisrun_accesses =
+					((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
+			reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
+
+			for (i = 1; i <= thisrun_accesses; i++) {
+				if (i > last_reg)
+					last_reg = i;
+				reg[i] = target_buffer_get_u16(target, buffer) & 0xffff;
+				buffer += 2;
+			}
+
+			arm7_9->write_core_regs(target, reg_list, reg);
+
+			for (i = 1; i <= thisrun_accesses; i++) {
+				arm7_9->store_hword_reg(target, i);
 
 				/* fast memory writes are only safe when the target is running
 				 * from a sufficiently high clock (32 kHz is usually too slow)
@@ -2352,99 +2396,55 @@ int arm7_9_write_memory(struct target *target,
 
 				if (retval != ERROR_OK)
 					return retval;
+			}
 
-				num_accesses += thisrun_accesses;
+			num_accesses += thisrun_accesses;
+		}
+		break;
+	case 1:
+		while (num_accesses < count) {
+			uint32_t reg_list;
+			thisrun_accesses =
+					((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
+			reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
+
+			for (i = 1; i <= thisrun_accesses; i++) {
+				if (i > last_reg)
+					last_reg = i;
+				reg[i] = *buffer++ & 0xff;
 			}
-			break;
-		case 2:
-			while (num_accesses < count) {
-				uint32_t reg_list;
-				thisrun_accesses =
-						((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
-				reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
-
-				for (i = 1; i <= thisrun_accesses; i++) {
-					if (i > last_reg)
-						last_reg = i;
-					reg[i] = target_buffer_get_u16(target, buffer) & 0xffff;
-					buffer += 2;
-				}
 
-				arm7_9->write_core_regs(target, reg_list, reg);
+			arm7_9->write_core_regs(target, reg_list, reg);
 
-				for (i = 1; i <= thisrun_accesses; i++) {
-					arm7_9->store_hword_reg(target, i);
+			for (i = 1; i <= thisrun_accesses; i++) {
+				arm7_9->store_byte_reg(target, i);
+				/* fast memory writes are only safe when the target is running
+				 * from a sufficiently high clock (32 kHz is usually too slow)
+				 */
+				if (arm7_9->fast_memory_access) {
+					retval = arm7_9_execute_fast_sys_speed(target);
+				} else {
+					retval = arm7_9_execute_sys_speed(target);
 
-					/* fast memory writes are only safe when the target is running
-					 * from a sufficiently high clock (32 kHz is usually too slow)
+					/*
+					 * if memory writes are made when the clock is running slow
+					 * (i.e. 32 kHz) which is necessary in some scripts to reconfigure
+					 * processor operations after a "reset halt" or "reset init",
+					 * need to immediately stroke the keep alive or will end up with
+					 * gdb "keep alive not sent error message" problem.
 					 */
-					if (arm7_9->fast_memory_access) {
-						retval = arm7_9_execute_fast_sys_speed(target);
-					} else {
-						retval = arm7_9_execute_sys_speed(target);
-
-						/*
-						 * if memory writes are made when the clock is running slow
-						 * (i.e. 32 kHz) which is necessary in some scripts to reconfigure
-						 * processor operations after a "reset halt" or "reset init",
-						 * need to immediately stroke the keep alive or will end up with
-						 * gdb "keep alive not sent error message" problem.
-						 */
-
-						keep_alive();
-					}
 
-					if (retval != ERROR_OK)
-						return retval;
-				}
-
-				num_accesses += thisrun_accesses;
-			}
-			break;
-		case 1:
-			while (num_accesses < count) {
-				uint32_t reg_list;
-				thisrun_accesses =
-						((count - num_accesses) >= 14) ? 14 : (count - num_accesses);
-				reg_list = (0xffff >> (15 - thisrun_accesses)) & 0xfffe;
-
-				for (i = 1; i <= thisrun_accesses; i++) {
-					if (i > last_reg)
-						last_reg = i;
-					reg[i] = *buffer++ & 0xff;
+					keep_alive();
 				}
 
-				arm7_9->write_core_regs(target, reg_list, reg);
-
-				for (i = 1; i <= thisrun_accesses; i++) {
-					arm7_9->store_byte_reg(target, i);
-					/* fast memory writes are only safe when the target is running
-					 * from a sufficiently high clock (32 kHz is usually too slow)
-					 */
-					if (arm7_9->fast_memory_access) {
-						retval = arm7_9_execute_fast_sys_speed(target);
-					} else {
-						retval = arm7_9_execute_sys_speed(target);
-
-						/*
-						 * if memory writes are made when the clock is running slow
-						 * (i.e. 32 kHz) which is necessary in some scripts to reconfigure
-						 * processor operations after a "reset halt" or "reset init",
-						 * need to immediately stroke the keep alive or will end up with
-						 * gdb "keep alive not sent error message" problem.
-						 */
-
-						keep_alive();
-					}
-
-					if (retval != ERROR_OK)
-						return retval;
-
-				}
+				if (retval != ERROR_OK)
+					return retval;
 
-				num_accesses += thisrun_accesses;
 			}
-			break;
+
+			num_accesses += thisrun_accesses;
+		}
+		break;
 	}
 
 	/* Re-Set DBGACK */
diff --git a/src/target/arm7tdmi.c b/src/target/arm7tdmi.c
index 2f59254afd..fea6a3ff2a 100644
--- a/src/target/arm7tdmi.c
+++ b/src/target/arm7tdmi.c
@@ -327,15 +327,15 @@ static void arm7tdmi_read_core_regs_target_buffer(struct target *target,
 		/* nothing fetched, STM still in EXECUTE (1 + i cycle), read databus */
 		if (mask & (1 << i)) {
 			switch (size) {
-				case 4:
-					arm7tdmi_clock_data_in_endianness(jtag_info, buf_u32++, 4, be);
-					break;
-				case 2:
-					arm7tdmi_clock_data_in_endianness(jtag_info, buf_u16++, 2, be);
-					break;
-				case 1:
-					arm7tdmi_clock_data_in_endianness(jtag_info, buf_u8++, 1, be);
-					break;
+			case 4:
+				arm7tdmi_clock_data_in_endianness(jtag_info, buf_u32++, 4, be);
+				break;
+			case 2:
+				arm7tdmi_clock_data_in_endianness(jtag_info, buf_u16++, 2, be);
+				break;
+			case 1:
+				arm7tdmi_clock_data_in_endianness(jtag_info, buf_u8++, 1, be);
+				break;
 			}
 		}
 	}
diff --git a/src/target/arm926ejs.c b/src/target/arm926ejs.c
index 0531106562..5f759f2162 100644
--- a/src/target/arm926ejs.c
+++ b/src/target/arm926ejs.c
@@ -220,88 +220,88 @@ static int arm926ejs_examine_debug_reason(struct target *target)
 	debug_reason = buf_get_u32(dbg_stat->value, 6, 4);
 
 	switch (debug_reason) {
-		case 0:
-			LOG_DEBUG("no *NEW* debug entry (?missed one?)");
-			/* ... since last restart or debug reset ... */
-			target->debug_reason = DBG_REASON_DBGRQ;
-			break;
-		case 1:
-			LOG_DEBUG("breakpoint from EICE unit 0");
-			target->debug_reason = DBG_REASON_BREAKPOINT;
-			break;
-		case 2:
-			LOG_DEBUG("breakpoint from EICE unit 1");
-			target->debug_reason = DBG_REASON_BREAKPOINT;
-			break;
-		case 3:
-			LOG_DEBUG("soft breakpoint (BKPT instruction)");
-			target->debug_reason = DBG_REASON_BREAKPOINT;
-			break;
-		case 4:
-			LOG_DEBUG("vector catch breakpoint");
-			target->debug_reason = DBG_REASON_BREAKPOINT;
-			break;
-		case 5:
-			LOG_DEBUG("external breakpoint");
-			target->debug_reason = DBG_REASON_BREAKPOINT;
-			break;
-		case 6:
-			LOG_DEBUG("watchpoint from EICE unit 0");
-			target->debug_reason = DBG_REASON_WATCHPOINT;
-			break;
-		case 7:
-			LOG_DEBUG("watchpoint from EICE unit 1");
-			target->debug_reason = DBG_REASON_WATCHPOINT;
-			break;
-		case 8:
-			LOG_DEBUG("external watchpoint");
-			target->debug_reason = DBG_REASON_WATCHPOINT;
-			break;
-		case 9:
-			LOG_DEBUG("internal debug request");
-			target->debug_reason = DBG_REASON_DBGRQ;
-			break;
-		case 10:
-			LOG_DEBUG("external debug request");
-			target->debug_reason = DBG_REASON_DBGRQ;
-			break;
-		case 11:
-			LOG_DEBUG("debug re-entry from system speed access");
-			/* This is normal when connecting to something that's
-			 * already halted, or in some related code paths, but
-			 * otherwise is surprising (and presumably wrong).
-			 */
-			switch (target->debug_reason) {
-			case DBG_REASON_DBGRQ:
-				break;
-			default:
-				LOG_ERROR("unexpected -- debug re-entry");
-				/* FALLTHROUGH */
-			case DBG_REASON_UNDEFINED:
-				target->debug_reason = DBG_REASON_DBGRQ;
-				break;
-			}
-			break;
-		case 12:
-			/* FIX!!!! here be dragons!!! We need to fail here so
-			 * the target will interpreted as halted but we won't
-			 * try to talk to it right now... a resume + halt seems
-			 * to sync things up again. Please send an email to
-			 * openocd development mailing list if you have hardware
-			 * to donate to look into this problem....
-			 */
-			LOG_WARNING("WARNING: mystery debug reason MOE = 0xc. Try issuing a resume + halt.");
-			target->debug_reason = DBG_REASON_DBGRQ;
+	case 0:
+		LOG_DEBUG("no *NEW* debug entry (?missed one?)");
+		/* ... since last restart or debug reset ... */
+		target->debug_reason = DBG_REASON_DBGRQ;
+		break;
+	case 1:
+		LOG_DEBUG("breakpoint from EICE unit 0");
+		target->debug_reason = DBG_REASON_BREAKPOINT;
+		break;
+	case 2:
+		LOG_DEBUG("breakpoint from EICE unit 1");
+		target->debug_reason = DBG_REASON_BREAKPOINT;
+		break;
+	case 3:
+		LOG_DEBUG("soft breakpoint (BKPT instruction)");
+		target->debug_reason = DBG_REASON_BREAKPOINT;
+		break;
+	case 4:
+		LOG_DEBUG("vector catch breakpoint");
+		target->debug_reason = DBG_REASON_BREAKPOINT;
+		break;
+	case 5:
+		LOG_DEBUG("external breakpoint");
+		target->debug_reason = DBG_REASON_BREAKPOINT;
+		break;
+	case 6:
+		LOG_DEBUG("watchpoint from EICE unit 0");
+		target->debug_reason = DBG_REASON_WATCHPOINT;
+		break;
+	case 7:
+		LOG_DEBUG("watchpoint from EICE unit 1");
+		target->debug_reason = DBG_REASON_WATCHPOINT;
+		break;
+	case 8:
+		LOG_DEBUG("external watchpoint");
+		target->debug_reason = DBG_REASON_WATCHPOINT;
+		break;
+	case 9:
+		LOG_DEBUG("internal debug request");
+		target->debug_reason = DBG_REASON_DBGRQ;
+		break;
+	case 10:
+		LOG_DEBUG("external debug request");
+		target->debug_reason = DBG_REASON_DBGRQ;
+		break;
+	case 11:
+		LOG_DEBUG("debug re-entry from system speed access");
+		/* This is normal when connecting to something that's
+		 * already halted, or in some related code paths, but
+		 * otherwise is surprising (and presumably wrong).
+		 */
+		switch (target->debug_reason) {
+		case DBG_REASON_DBGRQ:
 			break;
 		default:
-			LOG_WARNING("WARNING: unknown debug reason: 0x%x", debug_reason);
-			/* Oh agony! should we interpret this as a halt request or
-			 * that the target stopped on it's own accord?
-			 */
+			LOG_ERROR("unexpected -- debug re-entry");
+			/* FALLTHROUGH */
+		case DBG_REASON_UNDEFINED:
 			target->debug_reason = DBG_REASON_DBGRQ;
-			/* if we fail here, we won't talk to the target and it will
-			 * be reported to be in the halted state */
 			break;
+		}
+		break;
+	case 12:
+		/* FIX!!!! here be dragons!!! We need to fail here so
+		 * the target will interpreted as halted but we won't
+		 * try to talk to it right now... a resume + halt seems
+		 * to sync things up again. Please send an email to
+		 * openocd development mailing list if you have hardware
+		 * to donate to look into this problem....
+		 */
+		LOG_WARNING("WARNING: mystery debug reason MOE = 0xc. Try issuing a resume + halt.");
+		target->debug_reason = DBG_REASON_DBGRQ;
+		break;
+	default:
+		LOG_WARNING("WARNING: unknown debug reason: 0x%x", debug_reason);
+		/* Oh agony! should we interpret this as a halt request or
+		 * that the target stopped on it's own accord?
+		 */
+		target->debug_reason = DBG_REASON_DBGRQ;
+		/* if we fail here, we won't talk to the target and it will
+		 * be reported to be in the halted state */
+		break;
 	}
 
 	return ERROR_OK;
diff --git a/src/target/arm9tdmi.c b/src/target/arm9tdmi.c
index 8ab12de320..34b4ba2cea 100644
--- a/src/target/arm9tdmi.c
+++ b/src/target/arm9tdmi.c
@@ -398,15 +398,15 @@ static void arm9tdmi_read_core_regs_target_buffer(struct target *target,
 		if (mask & (1 << i))
 			/* nothing fetched, STM in MEMORY (i'th cycle) */
 			switch (size) {
-				case 4:
-					arm9tdmi_clock_data_in_endianness(jtag_info, buf_u32++, 4, be);
-					break;
-				case 2:
-					arm9tdmi_clock_data_in_endianness(jtag_info, buf_u16++, 2, be);
-					break;
-				case 1:
-					arm9tdmi_clock_data_in_endianness(jtag_info, buf_u8++, 1, be);
-					break;
+			case 4:
+				arm9tdmi_clock_data_in_endianness(jtag_info, buf_u32++, 4, be);
+				break;
+			case 2:
+				arm9tdmi_clock_data_in_endianness(jtag_info, buf_u16++, 2, be);
+				break;
+			case 1:
+				arm9tdmi_clock_data_in_endianness(jtag_info, buf_u8++, 1, be);
+				break;
 			}
 	}
 }
diff --git a/src/target/arm_dap.c b/src/target/arm_dap.c
index be5e63c7ca..5ba5e1c387 100644
--- a/src/target/arm_dap.c
+++ b/src/target/arm_dap.c
@@ -442,28 +442,28 @@ COMMAND_HANDLER(handle_dap_info_command)
 	}
 
 	switch (CMD_ARGC) {
-		case 0:
-			apsel = dap->apsel;
-			break;
-		case 1:
-			if (!strcmp(CMD_ARGV[0], "root")) {
-				if (!is_adiv6(dap)) {
-					command_print(CMD, "Option \"root\" not allowed with ADIv5 DAP");
-					return ERROR_COMMAND_ARGUMENT_INVALID;
-				}
-				int retval = adiv6_dap_read_baseptr(CMD, dap, &apsel);
-				if (retval != ERROR_OK) {
-					command_print(CMD, "Failed reading DAP baseptr");
-					return retval;
-				}
-				break;
+	case 0:
+		apsel = dap->apsel;
+		break;
+	case 1:
+		if (!strcmp(CMD_ARGV[0], "root")) {
+			if (!is_adiv6(dap)) {
+				command_print(CMD, "Option \"root\" not allowed with ADIv5 DAP");
+				return ERROR_COMMAND_ARGUMENT_INVALID;
+			}
+			int retval = adiv6_dap_read_baseptr(CMD, dap, &apsel);
+			if (retval != ERROR_OK) {
+				command_print(CMD, "Failed reading DAP baseptr");
+				return retval;
 			}
-			COMMAND_PARSE_NUMBER(u64, CMD_ARGV[0], apsel);
-			if (!is_ap_num_valid(dap, apsel))
-				return ERROR_COMMAND_SYNTAX_ERROR;
 			break;
-		default:
+		}
+		COMMAND_PARSE_NUMBER(u64, CMD_ARGV[0], apsel);
+		if (!is_ap_num_valid(dap, apsel))
 			return ERROR_COMMAND_SYNTAX_ERROR;
+		break;
+	default:
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
 	struct adiv5_ap *ap = dap_get_ap(dap, apsel);
diff --git a/src/target/arm_disassembler.c b/src/target/arm_disassembler.c
index 8619f8f82e..5b8ecc91a0 100644
--- a/src/target/arm_disassembler.c
+++ b/src/target/arm_disassembler.c
@@ -248,39 +248,39 @@ static int evaluate_srs(uint32_t opcode,
 	const char *mode = "";
 
 	switch ((opcode >> 23) & 0x3) {
-		case 0:
-			mode = "DA";
-			break;
-		case 1:
-			/* "IA" is default */
-			break;
-		case 2:
-			mode = "DB";
-			break;
-		case 3:
-			mode = "IB";
-			break;
+	case 0:
+		mode = "DA";
+		break;
+	case 1:
+		/* "IA" is default */
+		break;
+	case 2:
+		mode = "DB";
+		break;
+	case 3:
+		mode = "IB";
+		break;
 	}
 
 	switch (opcode & 0x0e500000) {
-		case 0x08400000:
-			snprintf(instruction->text, 128, "0x%8.8" PRIx32
-				"\t0x%8.8" PRIx32
-				"\tSRS%s\tSP%s, #%" PRIu32,
-				address, opcode,
-				mode, wback,
-				opcode & 0x1f);
-			break;
-		case 0x08100000:
-			snprintf(instruction->text, 128, "0x%8.8" PRIx32
-				"\t0x%8.8" PRIx32
-				"\tRFE%s\tr%" PRIu32 "%s",
-				address, opcode,
-				mode,
-				(opcode >> 16) & 0xf, wback);
-			break;
-		default:
-			return evaluate_unknown(opcode, address, instruction);
+	case 0x08400000:
+		snprintf(instruction->text, 128, "0x%8.8" PRIx32
+			"\t0x%8.8" PRIx32
+			"\tSRS%s\tSP%s, #%" PRIu32,
+			address, opcode,
+			mode, wback,
+			opcode & 0x1f);
+		break;
+	case 0x08100000:
+		snprintf(instruction->text, 128, "0x%8.8" PRIx32
+			"\t0x%8.8" PRIx32
+			"\tRFE%s\tr%" PRIu32 "%s",
+			address, opcode,
+			mode,
+			(opcode >> 16) & 0xf, wback);
+		break;
+	default:
+		return evaluate_unknown(opcode, address, instruction);
 	}
 	return ERROR_OK;
 }
@@ -631,21 +631,21 @@ static int evaluate_load_store(uint32_t opcode,
 			snprintf(offset, 32, ", %sr%i", (u) ? "" : "-", rm);
 		else {	/* +-<Rm>, <Shift>, #<shift_imm> */
 			switch (shift) {
-				case 0x0:		/* LSL */
-					snprintf(offset, 32, ", %sr%i, LSL #0x%x", (u) ? "" : "-", rm, shift_imm);
-					break;
-				case 0x1:		/* LSR */
-					snprintf(offset, 32, ", %sr%i, LSR #0x%x", (u) ? "" : "-", rm, shift_imm);
-					break;
-				case 0x2:		/* ASR */
-					snprintf(offset, 32, ", %sr%i, ASR #0x%x", (u) ? "" : "-", rm, shift_imm);
-					break;
-				case 0x3:		/* ROR */
-					snprintf(offset, 32, ", %sr%i, ROR #0x%x", (u) ? "" : "-", rm, shift_imm);
-					break;
-				case 0x4:		/* RRX */
-					snprintf(offset, 32, ", %sr%i, RRX", (u) ? "" : "-", rm);
-					break;
+			case 0x0:		/* LSL */
+				snprintf(offset, 32, ", %sr%i, LSL #0x%x", (u) ? "" : "-", rm, shift_imm);
+				break;
+			case 0x1:		/* LSR */
+				snprintf(offset, 32, ", %sr%i, LSR #0x%x", (u) ? "" : "-", rm, shift_imm);
+				break;
+			case 0x2:		/* ASR */
+				snprintf(offset, 32, ", %sr%i, ASR #0x%x", (u) ? "" : "-", rm, shift_imm);
+				break;
+			case 0x3:		/* ROR */
+				snprintf(offset, 32, ", %sr%i, ROR #0x%x", (u) ? "" : "-", rm, shift_imm);
+				break;
+			case 0x4:		/* RRX */
+				snprintf(offset, 32, ", %sr%i, RRX", (u) ? "" : "-", rm);
+				break;
 			}
 		}
 	}
@@ -707,33 +707,33 @@ static int evaluate_extend(uint32_t opcode, uint32_t address, char *cp)
 	char *type, *rot;
 
 	switch ((opcode >> 24) & 0x3) {
-		case 0:
-			type = "B16";
-			break;
-		case 1:
-			sprintf(cp, "UNDEFINED");
-			return ARM_UNDEFINED_INSTRUCTION;
-		case 2:
-			type = "B";
-			break;
-		default:
-			type = "H";
-			break;
+	case 0:
+		type = "B16";
+		break;
+	case 1:
+		sprintf(cp, "UNDEFINED");
+		return ARM_UNDEFINED_INSTRUCTION;
+	case 2:
+		type = "B";
+		break;
+	default:
+		type = "H";
+		break;
 	}
 
 	switch ((opcode >> 10) & 0x3) {
-		case 0:
-			rot = "";
-			break;
-		case 1:
-			rot = ", ROR #8";
-			break;
-		case 2:
-			rot = ", ROR #16";
-			break;
-		default:
-			rot = ", ROR #24";
-			break;
+	case 0:
+		rot = "";
+		break;
+	case 1:
+		rot = ", ROR #8";
+		break;
+	case 2:
+		rot = ", ROR #16";
+		break;
+	default:
+		rot = ", ROR #24";
+		break;
 	}
 
 	if (rn == 0xf) {
@@ -758,55 +758,55 @@ static int evaluate_p_add_sub(uint32_t opcode, uint32_t address, char *cp)
 	int type;
 
 	switch ((opcode >> 20) & 0x7) {
-		case 1:
-			prefix = "S";
-			break;
-		case 2:
-			prefix = "Q";
-			break;
-		case 3:
-			prefix = "SH";
-			break;
-		case 5:
-			prefix = "U";
-			break;
-		case 6:
-			prefix = "UQ";
-			break;
-		case 7:
-			prefix = "UH";
-			break;
-		default:
-			goto undef;
+	case 1:
+		prefix = "S";
+		break;
+	case 2:
+		prefix = "Q";
+		break;
+	case 3:
+		prefix = "SH";
+		break;
+	case 5:
+		prefix = "U";
+		break;
+	case 6:
+		prefix = "UQ";
+		break;
+	case 7:
+		prefix = "UH";
+		break;
+	default:
+		goto undef;
 	}
 
 	switch ((opcode >> 5) & 0x7) {
-		case 0:
-			op = "ADD16";
-			type = ARM_ADD;
-			break;
-		case 1:
-			op = "ADDSUBX";
-			type = ARM_ADD;
-			break;
-		case 2:
-			op = "SUBADDX";
-			type = ARM_SUB;
-			break;
-		case 3:
-			op = "SUB16";
-			type = ARM_SUB;
-			break;
-		case 4:
-			op = "ADD8";
-			type = ARM_ADD;
-			break;
-		case 7:
-			op = "SUB8";
-			type = ARM_SUB;
-			break;
-		default:
-			goto undef;
+	case 0:
+		op = "ADD16";
+		type = ARM_ADD;
+		break;
+	case 1:
+		op = "ADDSUBX";
+		type = ARM_ADD;
+		break;
+	case 2:
+		op = "SUBADDX";
+		type = ARM_SUB;
+		break;
+	case 3:
+		op = "SUB16";
+		type = ARM_SUB;
+		break;
+	case 4:
+		op = "ADD8";
+		type = ARM_ADD;
+		break;
+	case 7:
+		op = "SUB8";
+		type = ARM_SUB;
+		break;
+	default:
+		goto undef;
 	}
 
 	sprintf(cp, "%s%s%s\tr%d, r%d, r%d", prefix, op, COND(opcode),
@@ -928,14 +928,14 @@ static int evaluate_media(uint32_t opcode, uint32_t address,
 		unsigned int rn = (opcode >> 12) & 0xf;
 
 		switch (opcode & 0xc0) {
-			case 3:
-				if (rn == 0xf)
-					goto undef;
-			/* FALL THROUGH */
-			case 0:
-				break;
-			default:
+		case 3:
+			if (rn == 0xf)
 				goto undef;
+		/* FALL THROUGH */
+		case 0:
+			break;
+		default:
+			goto undef;
 		}
 
 		if (rn != 0xf)
@@ -959,46 +959,46 @@ static int evaluate_media(uint32_t opcode, uint32_t address,
 
 	/* simple matches against the remaining decode bits */
 	switch (opcode & 0x01f000f0) {
-		case 0x00a00030:
-		case 0x00e00030:
-			/* parallel halfword saturate */
-			sprintf(cp, "%cSAT16%s\tr%d, #%d, r%d",
-				(opcode & (1 << 22)) ? 'U' : 'S',
-				COND(opcode),
-				(int) (opcode >> 12) & 0xf,
-				(int) (opcode >> 16) & 0xf,
-				(int) (opcode >> 0) & 0xf);
-			return ERROR_OK;
-		case 0x00b00030:
-			mnemonic = "REV";
-			break;
-		case 0x00b000b0:
-			mnemonic = "REV16";
-			break;
-		case 0x00f000b0:
-			mnemonic = "REVSH";
-			break;
-		case 0x008000b0:
-			/* select bytes */
-			sprintf(cp, "SEL%s\tr%d, r%d, r%d", COND(opcode),
-				(int) (opcode >> 12) & 0xf,
-				(int) (opcode >> 16) & 0xf,
-				(int) (opcode >> 0) & 0xf);
-			return ERROR_OK;
-		case 0x01800010:
-			/* unsigned sum of absolute differences */
-			if (((opcode >> 12) & 0xf) == 0xf)
-				sprintf(cp, "USAD8%s\tr%d, r%d, r%d", COND(opcode),
-						(int) (opcode >> 16) & 0xf,
-						(int) (opcode >> 0) & 0xf,
-						(int) (opcode >> 8) & 0xf);
-			else
-				sprintf(cp, "USADA8%s\tr%d, r%d, r%d, r%d", COND(opcode),
-						(int) (opcode >> 16) & 0xf,
-						(int) (opcode >> 0) & 0xf,
-						(int) (opcode >> 8) & 0xf,
-						(int) (opcode >> 12) & 0xf);
-			return ERROR_OK;
+	case 0x00a00030:
+	case 0x00e00030:
+		/* parallel halfword saturate */
+		sprintf(cp, "%cSAT16%s\tr%d, #%d, r%d",
+			(opcode & (1 << 22)) ? 'U' : 'S',
+			COND(opcode),
+			(int)(opcode >> 12) & 0xf,
+			(int)(opcode >> 16) & 0xf,
+			(int)(opcode >> 0) & 0xf);
+		return ERROR_OK;
+	case 0x00b00030:
+		mnemonic = "REV";
+		break;
+	case 0x00b000b0:
+		mnemonic = "REV16";
+		break;
+	case 0x00f000b0:
+		mnemonic = "REVSH";
+		break;
+	case 0x008000b0:
+		/* select bytes */
+		sprintf(cp, "SEL%s\tr%d, r%d, r%d", COND(opcode),
+			(int)(opcode >> 12) & 0xf,
+			(int)(opcode >> 16) & 0xf,
+			(int)(opcode >> 0) & 0xf);
+		return ERROR_OK;
+	case 0x01800010:
+		/* unsigned sum of absolute differences */
+		if (((opcode >> 12) & 0xf) == 0xf)
+			sprintf(cp, "USAD8%s\tr%d, r%d, r%d", COND(opcode),
+					(int)(opcode >> 16) & 0xf,
+					(int)(opcode >> 0) & 0xf,
+					(int)(opcode >> 8) & 0xf);
+		else
+			sprintf(cp, "USADA8%s\tr%d, r%d, r%d, r%d", COND(opcode),
+					(int)(opcode >> 16) & 0xf,
+					(int)(opcode >> 0) & 0xf,
+					(int)(opcode >> 8) & 0xf,
+					(int)(opcode >> 12) & 0xf);
+		return ERROR_OK;
 	}
 	if (mnemonic) {
 		unsigned int rm = (opcode >> 0) & 0xf;
@@ -1280,22 +1280,22 @@ static int evaluate_mul_and_extra_ld_st(uint32_t opcode,
 			s = (opcode & 0x00100000) >> 20;
 
 			switch ((opcode & 0x00600000) >> 21) {
-				case 0x0:
-					instruction->type = ARM_UMULL;
-					mnemonic = "UMULL";
-					break;
-				case 0x1:
-					instruction->type = ARM_UMLAL;
-					mnemonic = "UMLAL";
-					break;
-				case 0x2:
-					instruction->type = ARM_SMULL;
-					mnemonic = "SMULL";
-					break;
-				case 0x3:
-					instruction->type = ARM_SMLAL;
-					mnemonic = "SMLAL";
-					break;
+			case 0x0:
+				instruction->type = ARM_UMULL;
+				mnemonic = "UMULL";
+				break;
+			case 0x1:
+				instruction->type = ARM_UMLAL;
+				mnemonic = "UMLAL";
+				break;
+			case 0x2:
+				instruction->type = ARM_SMULL;
+				mnemonic = "SMULL";
+				break;
+			case 0x3:
+				instruction->type = ARM_SMLAL;
+				mnemonic = "SMLAL";
+				break;
 			}
 
 			snprintf(instruction->text,
@@ -1480,22 +1480,22 @@ static int evaluate_misc_instr(uint32_t opcode,
 		rn = (opcode & 0xf0000) >> 16;
 
 		switch ((opcode & 0x00600000) >> 21) {
-			case 0x0:
-				instruction->type = ARM_QADD;
-				mnemonic = "QADD";
-				break;
-			case 0x1:
-				instruction->type = ARM_QSUB;
-				mnemonic = "QSUB";
-				break;
-			case 0x2:
-				instruction->type = ARM_QDADD;
-				mnemonic = "QDADD";
-				break;
-			case 0x3:
-				instruction->type = ARM_QDSUB;
-				mnemonic = "QDSUB";
-				break;
+		case 0x0:
+			instruction->type = ARM_QADD;
+			mnemonic = "QADD";
+			break;
+		case 0x1:
+			instruction->type = ARM_QSUB;
+			mnemonic = "QSUB";
+			break;
+		case 0x2:
+			instruction->type = ARM_QDADD;
+			mnemonic = "QDADD";
+			break;
+		case 0x3:
+			instruction->type = ARM_QDSUB;
+			mnemonic = "QDSUB";
+			break;
 		}
 
 		snprintf(instruction->text,
@@ -1527,21 +1527,21 @@ static int evaluate_misc_instr(uint32_t opcode,
 		char *mnemonic = NULL;
 
 		switch ((opcode & 0x600000) >> 21) {
-			case 0x1:
-				instruction->type = ARM_BKPT;
-				mnemonic = "BRKT";
-				immediate = ((opcode & 0x000fff00) >> 4) | (opcode & 0xf);
-				break;
-			case 0x2:
-				instruction->type = ARM_HVC;
-				mnemonic = "HVC";
-				immediate = ((opcode & 0x000fff00) >> 4) | (opcode & 0xf);
-				break;
-			case 0x3:
-				instruction->type = ARM_SMC;
-				mnemonic = "SMC";
-				immediate = (opcode & 0xf);
-				break;
+		case 0x1:
+			instruction->type = ARM_BKPT;
+			mnemonic = "BRKT";
+			immediate = ((opcode & 0x000fff00) >> 4) | (opcode & 0xf);
+			break;
+		case 0x2:
+			instruction->type = ARM_HVC;
+			mnemonic = "HVC";
+			immediate = ((opcode & 0x000fff00) >> 4) | (opcode & 0xf);
+			break;
+		case 0x3:
+			instruction->type = ARM_SMC;
+			mnemonic = "SMC";
+			immediate = (opcode & 0xf);
+			break;
 		}
 
 		snprintf(instruction->text,
@@ -1717,70 +1717,70 @@ static int evaluate_data_proc(uint32_t opcode,
 	instruction->info.data_proc.s = s;
 
 	switch (op) {
-		case 0x0:
-			instruction->type = ARM_AND;
-			mnemonic = "AND";
-			break;
-		case 0x1:
-			instruction->type = ARM_EOR;
-			mnemonic = "EOR";
-			break;
-		case 0x2:
-			instruction->type = ARM_SUB;
-			mnemonic = "SUB";
-			break;
-		case 0x3:
-			instruction->type = ARM_RSB;
-			mnemonic = "RSB";
-			break;
-		case 0x4:
-			instruction->type = ARM_ADD;
-			mnemonic = "ADD";
-			break;
-		case 0x5:
-			instruction->type = ARM_ADC;
-			mnemonic = "ADC";
-			break;
-		case 0x6:
-			instruction->type = ARM_SBC;
-			mnemonic = "SBC";
-			break;
-		case 0x7:
-			instruction->type = ARM_RSC;
-			mnemonic = "RSC";
-			break;
-		case 0x8:
-			instruction->type = ARM_TST;
-			mnemonic = "TST";
-			break;
-		case 0x9:
-			instruction->type = ARM_TEQ;
-			mnemonic = "TEQ";
-			break;
-		case 0xa:
-			instruction->type = ARM_CMP;
-			mnemonic = "CMP";
-			break;
-		case 0xb:
-			instruction->type = ARM_CMN;
-			mnemonic = "CMN";
-			break;
-		case 0xc:
-			instruction->type = ARM_ORR;
-			mnemonic = "ORR";
-			break;
-		case 0xd:
-			instruction->type = ARM_MOV;
-			mnemonic = "MOV";
-			break;
-		case 0xe:
-			instruction->type = ARM_BIC;
-			mnemonic = "BIC";
-			break;
-		case 0xf:
-			instruction->type = ARM_MVN;
-			mnemonic = "MVN";
-			break;
+	case 0x0:
+		instruction->type = ARM_AND;
+		mnemonic = "AND";
+		break;
+	case 0x1:
+		instruction->type = ARM_EOR;
+		mnemonic = "EOR";
+		break;
+	case 0x2:
+		instruction->type = ARM_SUB;
+		mnemonic = "SUB";
+		break;
+	case 0x3:
+		instruction->type = ARM_RSB;
+		mnemonic = "RSB";
+		break;
+	case 0x4:
+		instruction->type = ARM_ADD;
+		mnemonic = "ADD";
+		break;
+	case 0x5:
+		instruction->type = ARM_ADC;
+		mnemonic = "ADC";
+		break;
+	case 0x6:
+		instruction->type = ARM_SBC;
+		mnemonic = "SBC";
+		break;
+	case 0x7:
+		instruction->type = ARM_RSC;
+		mnemonic = "RSC";
+		break;
+	case 0x8:
+		instruction->type = ARM_TST;
+		mnemonic = "TST";
+		break;
+	case 0x9:
+		instruction->type = ARM_TEQ;
+		mnemonic = "TEQ";
+		break;
+	case 0xa:
+		instruction->type = ARM_CMP;
+		mnemonic = "CMP";
+		break;
+	case 0xb:
+		instruction->type = ARM_CMN;
+		mnemonic = "CMN";
+		break;
+	case 0xc:
+		instruction->type = ARM_ORR;
+		mnemonic = "ORR";
+		break;
+	case 0xd:
+		instruction->type = ARM_MOV;
+		mnemonic = "MOV";
+		break;
+	case 0xe:
+		instruction->type = ARM_BIC;
+		mnemonic = "BIC";
+		break;
+	case 0xf:
+		instruction->type = ARM_MVN;
+		mnemonic = "MVN";
+		break;
 	}
 
 	if (i) {/* immediate shifter operand (#<immediate>)*/
@@ -2065,28 +2065,28 @@ static int evaluate_b_bl_blx_thumb(uint16_t opcode,
 	target_address = address + 4 + (offset << 1);
 
 	switch (opc) {
-		/* unconditional branch */
-		case 0:
-			instruction->type = ARM_B;
-			mnemonic = "B";
-			break;
-		/* BLX suffix */
-		case 1:
-			instruction->type = ARM_BLX;
-			mnemonic = "BLX";
-			target_address &= 0xfffffffc;
-			break;
-		/* BL/BLX prefix */
-		case 2:
-			instruction->type = ARM_UNKNOWN_INSTRUCTION;
-			mnemonic = "prefix";
-			target_address = offset << 12;
-			break;
-		/* BL suffix */
-		case 3:
-			instruction->type = ARM_BL;
-			mnemonic = "BL";
-			break;
+	/* unconditional branch */
+	case 0:
+		instruction->type = ARM_B;
+		mnemonic = "B";
+		break;
+	/* BLX suffix */
+	case 1:
+		instruction->type = ARM_BLX;
+		mnemonic = "BLX";
+		target_address &= 0xfffffffc;
+		break;
+	/* BL/BLX prefix */
+	case 2:
+		instruction->type = ARM_UNKNOWN_INSTRUCTION;
+		mnemonic = "prefix";
+		target_address = offset << 12;
+		break;
+	/* BL suffix */
+	case 3:
+		instruction->type = ARM_BL;
+		mnemonic = "BL";
+		break;
 	}
 
 	/* TODO: deal correctly with dual opcode (prefixed) BL/BLX;
@@ -2158,21 +2158,21 @@ static int evaluate_shift_imm_thumb(uint16_t opcode,
 	char *mnemonic = NULL;
 
 	switch (opc) {
-		case 0:
-			instruction->type = ARM_MOV;
-			mnemonic = "LSLS";
-			instruction->info.data_proc.shifter_operand.immediate_shift.shift = 0;
-			break;
-		case 1:
-			instruction->type = ARM_MOV;
-			mnemonic = "LSRS";
-			instruction->info.data_proc.shifter_operand.immediate_shift.shift = 1;
-			break;
-		case 2:
-			instruction->type = ARM_MOV;
-			mnemonic = "ASRS";
-			instruction->info.data_proc.shifter_operand.immediate_shift.shift = 2;
-			break;
+	case 0:
+		instruction->type = ARM_MOV;
+		mnemonic = "LSLS";
+		instruction->info.data_proc.shifter_operand.immediate_shift.shift = 0;
+		break;
+	case 1:
+		instruction->type = ARM_MOV;
+		mnemonic = "LSRS";
+		instruction->info.data_proc.shifter_operand.immediate_shift.shift = 1;
+		break;
+	case 2:
+		instruction->type = ARM_MOV;
+		mnemonic = "ASRS";
+		instruction->info.data_proc.shifter_operand.immediate_shift.shift = 2;
+		break;
 	}
 
 	if ((imm == 0) && (opc != 0))
@@ -2208,24 +2208,24 @@ static int evaluate_data_proc_imm_thumb(uint16_t opcode,
 	instruction->info.data_proc.shifter_operand.immediate.immediate = imm;
 
 	switch (opc) {
-		case 0:
-			instruction->type = ARM_MOV;
-			mnemonic = "MOVS";
-			instruction->info.data_proc.rn = -1;
-			break;
-		case 1:
-			instruction->type = ARM_CMP;
-			mnemonic = "CMP";
-			instruction->info.data_proc.rd = -1;
-			break;
-		case 2:
-			instruction->type = ARM_ADD;
-			mnemonic = "ADDS";
-			break;
-		case 3:
-			instruction->type = ARM_SUB;
-			mnemonic = "SUBS";
-			break;
+	case 0:
+		instruction->type = ARM_MOV;
+		mnemonic = "MOVS";
+		instruction->info.data_proc.rn = -1;
+		break;
+	case 1:
+		instruction->type = ARM_CMP;
+		mnemonic = "CMP";
+		instruction->info.data_proc.rd = -1;
+		break;
+	case 2:
+		instruction->type = ARM_ADD;
+		mnemonic = "ADDS";
+		break;
+	case 3:
+		instruction->type = ARM_SUB;
+		mnemonic = "SUBS";
+		break;
 	}
 
 	snprintf(instruction->text, 128,
@@ -2262,131 +2262,131 @@ static int evaluate_data_proc_thumb(uint16_t opcode,
 		op >>= 2;
 
 		switch (op) {
-			case 0x0:
-				instruction->type = ARM_ADD;
-				mnemonic = "ADD";
-				break;
-			case 0x1:
-				instruction->type = ARM_CMP;
-				mnemonic = "CMP";
-				break;
-			case 0x2:
-				instruction->type = ARM_MOV;
-				mnemonic = "MOV";
-				if (rd == rm)
-					nop = true;
-				break;
-			case 0x3:
-				if ((opcode & 0x7) == 0x0) {
-					instruction->info.b_bl_bx_blx.reg_operand = rm;
-					if (h1) {
-						instruction->type = ARM_BLX;
-						snprintf(instruction->text, 128,
-								"0x%8.8" PRIx32
-								"  0x%4.4x    \tBLX\tr%i",
-								address, opcode, rm);
-					} else {
-						instruction->type = ARM_BX;
-						snprintf(instruction->text, 128,
-								"0x%8.8" PRIx32
-								"  0x%4.4x    \tBX\tr%i",
-								address, opcode, rm);
-					}
+		case 0x0:
+			instruction->type = ARM_ADD;
+			mnemonic = "ADD";
+			break;
+		case 0x1:
+			instruction->type = ARM_CMP;
+			mnemonic = "CMP";
+			break;
+		case 0x2:
+			instruction->type = ARM_MOV;
+			mnemonic = "MOV";
+			if (rd == rm)
+				nop = true;
+			break;
+		case 0x3:
+			if ((opcode & 0x7) == 0x0) {
+				instruction->info.b_bl_bx_blx.reg_operand = rm;
+				if (h1) {
+					instruction->type = ARM_BLX;
+					snprintf(instruction->text, 128,
+							"0x%8.8" PRIx32
+							"  0x%4.4x    \tBLX\tr%i",
+							address, opcode, rm);
 				} else {
-					instruction->type = ARM_UNDEFINED_INSTRUCTION;
+					instruction->type = ARM_BX;
 					snprintf(instruction->text, 128,
 							"0x%8.8" PRIx32
-							"  0x%4.4x    \t"
-							"UNDEFINED INSTRUCTION",
-							address, opcode);
+							"  0x%4.4x    \tBX\tr%i",
+							address, opcode, rm);
 				}
-				return ERROR_OK;
+			} else {
+				instruction->type = ARM_UNDEFINED_INSTRUCTION;
+				snprintf(instruction->text, 128,
+						"0x%8.8" PRIx32
+						"  0x%4.4x    \t"
+						"UNDEFINED INSTRUCTION",
+						address, opcode);
+			}
+			return ERROR_OK;
 		}
 	} else {
 		switch (op) {
-			case 0x0:
-				instruction->type = ARM_AND;
-				mnemonic = "ANDS";
-				break;
-			case 0x1:
-				instruction->type = ARM_EOR;
-				mnemonic = "EORS";
-				break;
-			case 0x2:
-				instruction->type = ARM_MOV;
-				mnemonic = "LSLS";
-				instruction->info.data_proc.variant = 2	/*register shift*/;
-				instruction->info.data_proc.shifter_operand.register_shift.shift = 0;
-				instruction->info.data_proc.shifter_operand.register_shift.rm = rd;
-				instruction->info.data_proc.shifter_operand.register_shift.rs = rm;
-				break;
-			case 0x3:
-				instruction->type = ARM_MOV;
-				mnemonic = "LSRS";
-				instruction->info.data_proc.variant = 2	/*register shift*/;
-				instruction->info.data_proc.shifter_operand.register_shift.shift = 1;
-				instruction->info.data_proc.shifter_operand.register_shift.rm = rd;
-				instruction->info.data_proc.shifter_operand.register_shift.rs = rm;
-				break;
-			case 0x4:
-				instruction->type = ARM_MOV;
-				mnemonic = "ASRS";
-				instruction->info.data_proc.variant = 2	/*register shift*/;
-				instruction->info.data_proc.shifter_operand.register_shift.shift = 2;
-				instruction->info.data_proc.shifter_operand.register_shift.rm = rd;
-				instruction->info.data_proc.shifter_operand.register_shift.rs = rm;
-				break;
-			case 0x5:
-				instruction->type = ARM_ADC;
-				mnemonic = "ADCS";
-				break;
-			case 0x6:
-				instruction->type = ARM_SBC;
-				mnemonic = "SBCS";
-				break;
-			case 0x7:
-				instruction->type = ARM_MOV;
-				mnemonic = "RORS";
-				instruction->info.data_proc.variant = 2	/*register shift*/;
-				instruction->info.data_proc.shifter_operand.register_shift.shift = 3;
-				instruction->info.data_proc.shifter_operand.register_shift.rm = rd;
-				instruction->info.data_proc.shifter_operand.register_shift.rs = rm;
-				break;
-			case 0x8:
-				instruction->type = ARM_TST;
-				mnemonic = "TST";
-				break;
-			case 0x9:
-				instruction->type = ARM_RSB;
-				mnemonic = "RSBS";
-				instruction->info.data_proc.variant = 0	/*immediate*/;
-				instruction->info.data_proc.shifter_operand.immediate.immediate = 0;
-				instruction->info.data_proc.rn = rm;
-				break;
-			case 0xA:
-				instruction->type = ARM_CMP;
-				mnemonic = "CMP";
-				break;
-			case 0xB:
-				instruction->type = ARM_CMN;
-				mnemonic = "CMN";
-				break;
-			case 0xC:
-				instruction->type = ARM_ORR;
-				mnemonic = "ORRS";
-				break;
-			case 0xD:
-				instruction->type = ARM_MUL;
-				mnemonic = "MULS";
-				break;
-			case 0xE:
-				instruction->type = ARM_BIC;
-				mnemonic = "BICS";
-				break;
-			case 0xF:
-				instruction->type = ARM_MVN;
-				mnemonic = "MVNS";
-				break;
+		case 0x0:
+			instruction->type = ARM_AND;
+			mnemonic = "ANDS";
+			break;
+		case 0x1:
+			instruction->type = ARM_EOR;
+			mnemonic = "EORS";
+			break;
+		case 0x2:
+			instruction->type = ARM_MOV;
+			mnemonic = "LSLS";
+			instruction->info.data_proc.variant = 2	/*register shift*/;
+			instruction->info.data_proc.shifter_operand.register_shift.shift = 0;
+			instruction->info.data_proc.shifter_operand.register_shift.rm = rd;
+			instruction->info.data_proc.shifter_operand.register_shift.rs = rm;
+			break;
+		case 0x3:
+			instruction->type = ARM_MOV;
+			mnemonic = "LSRS";
+			instruction->info.data_proc.variant = 2	/*register shift*/;
+			instruction->info.data_proc.shifter_operand.register_shift.shift = 1;
+			instruction->info.data_proc.shifter_operand.register_shift.rm = rd;
+			instruction->info.data_proc.shifter_operand.register_shift.rs = rm;
+			break;
+		case 0x4:
+			instruction->type = ARM_MOV;
+			mnemonic = "ASRS";
+			instruction->info.data_proc.variant = 2	/*register shift*/;
+			instruction->info.data_proc.shifter_operand.register_shift.shift = 2;
+			instruction->info.data_proc.shifter_operand.register_shift.rm = rd;
+			instruction->info.data_proc.shifter_operand.register_shift.rs = rm;
+			break;
+		case 0x5:
+			instruction->type = ARM_ADC;
+			mnemonic = "ADCS";
+			break;
+		case 0x6:
+			instruction->type = ARM_SBC;
+			mnemonic = "SBCS";
+			break;
+		case 0x7:
+			instruction->type = ARM_MOV;
+			mnemonic = "RORS";
+			instruction->info.data_proc.variant = 2	/*register shift*/;
+			instruction->info.data_proc.shifter_operand.register_shift.shift = 3;
+			instructi...
 
[truncated message content]

[PATCH]: 4809cf146c jtag: prepare for aligning switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9052

-- gerrit

commit 4809cf146c62443fd7f750388b0c2ac8b47f6932
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jul 26 18:01:41 2025 +0200

    jtag: prepare for aligning switch and case statements
    
    To prepare for aligning switch and case statements, fix in advance
    some checkpatch error due to existing code:
    - use '__func__' in place of hardcoded function name.
    
    Change-Id: Ib90811c7fffa15702fb710345c5ca3c7331d5ad6
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/jtag/interface.c b/src/jtag/interface.c
index 92c88ca934..0473a87535 100644
--- a/src/jtag/interface.c
+++ b/src/jtag/interface.c
@@ -86,8 +86,8 @@ int tap_move_ndx(enum tap_state astate)
 			ndx = 5;
 			break;
 		default:
-			LOG_ERROR("FATAL: unstable state \"%s\" in tap_move_ndx()",
-					tap_state_name(astate));
+			LOG_ERROR("FATAL: unstable state \"%s\" in %s()",
+					tap_state_name(astate), __func__);
 			exit(1);
 	}
 

-- 

[PATCH]: d1ea3b264a xsvf: align switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9048

-- gerrit

commit d1ea3b264a1ad82250e379e15da781057ddf10fc
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jul 26 13:13:32 2025 +0200

    xsvf: align switch and case statements
    
    The coding style requires the 'case' to be at the same indentation
    level of its 'switch' statement.
    
    Align the code accordingly.
    
    No changes are reported by
            git log -p -w --ignore-blank-lines --patience
    
    Change-Id: I24762505cdac22058e0a2a1f4e9235c9006e543d
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/xsvf/xsvf.c b/src/xsvf/xsvf.c
index e1cbca41ea..5f5bf8d094 100644
--- a/src/xsvf/xsvf.c
+++ b/src/xsvf/xsvf.c
@@ -117,57 +117,57 @@ static enum tap_state xsvf_to_tap(int xsvf_state)
 	enum tap_state ret;
 
 	switch (xsvf_state) {
-		case XSV_RESET:
-			ret = TAP_RESET;
-			break;
-		case XSV_IDLE:
-			ret = TAP_IDLE;
-			break;
-		case XSV_DRSELECT:
-			ret = TAP_DRSELECT;
-			break;
-		case XSV_DRCAPTURE:
-			ret = TAP_DRCAPTURE;
-			break;
-		case XSV_DRSHIFT:
-			ret = TAP_DRSHIFT;
-			break;
-		case XSV_DREXIT1:
-			ret = TAP_DREXIT1;
-			break;
-		case XSV_DRPAUSE:
-			ret = TAP_DRPAUSE;
-			break;
-		case XSV_DREXIT2:
-			ret = TAP_DREXIT2;
-			break;
-		case XSV_DRUPDATE:
-			ret = TAP_DRUPDATE;
-			break;
-		case XSV_IRSELECT:
-			ret = TAP_IRSELECT;
-			break;
-		case XSV_IRCAPTURE:
-			ret = TAP_IRCAPTURE;
-			break;
-		case XSV_IRSHIFT:
-			ret = TAP_IRSHIFT;
-			break;
-		case XSV_IREXIT1:
-			ret = TAP_IREXIT1;
-			break;
-		case XSV_IRPAUSE:
-			ret = TAP_IRPAUSE;
-			break;
-		case XSV_IREXIT2:
-			ret = TAP_IREXIT2;
-			break;
-		case XSV_IRUPDATE:
-			ret = TAP_IRUPDATE;
-			break;
-		default:
-			LOG_ERROR("UNKNOWN XSVF STATE 0x%02X", xsvf_state);
-			exit(1);
+	case XSV_RESET:
+		ret = TAP_RESET;
+		break;
+	case XSV_IDLE:
+		ret = TAP_IDLE;
+		break;
+	case XSV_DRSELECT:
+		ret = TAP_DRSELECT;
+		break;
+	case XSV_DRCAPTURE:
+		ret = TAP_DRCAPTURE;
+		break;
+	case XSV_DRSHIFT:
+		ret = TAP_DRSHIFT;
+		break;
+	case XSV_DREXIT1:
+		ret = TAP_DREXIT1;
+		break;
+	case XSV_DRPAUSE:
+		ret = TAP_DRPAUSE;
+		break;
+	case XSV_DREXIT2:
+		ret = TAP_DREXIT2;
+		break;
+	case XSV_DRUPDATE:
+		ret = TAP_DRUPDATE;
+		break;
+	case XSV_IRSELECT:
+		ret = TAP_IRSELECT;
+		break;
+	case XSV_IRCAPTURE:
+		ret = TAP_IRCAPTURE;
+		break;
+	case XSV_IRSHIFT:
+		ret = TAP_IRSHIFT;
+		break;
+	case XSV_IREXIT1:
+		ret = TAP_IREXIT1;
+		break;
+	case XSV_IRPAUSE:
+		ret = TAP_IRPAUSE;
+		break;
+	case XSV_IREXIT2:
+		ret = TAP_IREXIT2;
+		break;
+	case XSV_IRUPDATE:
+		ret = TAP_IRUPDATE;
+		break;
+	default:
+		LOG_ERROR("UNKNOWN XSVF STATE 0x%02X", xsvf_state);
+		exit(1);
 	}
 
 	return ret;
@@ -275,92 +275,91 @@ COMMAND_HANDLER(handle_xsvf_command)
 			enum tap_state mystate;
 
 			switch (opcode) {
-				case XCOMMENT:
-					/* ignore/show comments between XSTATE ops */
+			case XCOMMENT:
+				/* ignore/show comments between XSTATE ops */
+				break;
+			case XSTATE:
+				/* try to collect another transition */
+				if (pathlen == XSTATE_MAX_PATH) {
+					LOG_ERROR("XSVF: path too long");
+					do_abort = 1;
 					break;
-				case XSTATE:
-					/* try to collect another transition */
-					if (pathlen == XSTATE_MAX_PATH) {
-						LOG_ERROR("XSVF: path too long");
-						do_abort = 1;
-						break;
-					}
-
-					if (read(xsvf_fd, &uc, 1) < 0) {
-						do_abort = 1;
-						break;
-					}
+				}
 
-					mystate = xsvf_to_tap(uc);
-					path[pathlen++] = mystate;
-
-					LOG_DEBUG("XSTATE 0x%02X %s", uc,
-					tap_state_name(mystate));
-
-					/* If path is incomplete, collect more */
-					if (!svf_tap_state_is_stable(mystate))
-						continue;
-
-					/* Else execute the path transitions we've
-					 * collected so far.
-					 *
-					 * NOTE:  Punting on the saved path is not
-					 * strictly correct, but we must to do this
-					 * unless jtag_add_pathmove() stops rejecting
-					 * paths containing RESET.  This is probably
-					 * harmless, since there aren't many options
-					 * for going from a stable state to reset;
-					 * at the worst, we may issue extra clocks
-					 * once we get to RESET.
-					 */
-					if (mystate == TAP_RESET) {
-						LOG_WARNING("XSVF: dodgey RESET");
-						path[0] = mystate;
-					}
+				if (read(xsvf_fd, &uc, 1) < 0) {
+					do_abort = 1;
+					break;
+				}
 
-				/* FALL THROUGH */
-				default:
-					/* Execute the path we collected
-					 *
-					 * NOTE: OpenOCD requires something that XSVF
-					 * doesn't:  the last TAP state in the path
-					 * must be stable.  In practice, tools that
-					 * create XSVF seem to follow that rule too.
-					 */
-					collecting_path = false;
+				mystate = xsvf_to_tap(uc);
+				path[pathlen++] = mystate;
 
-					if (path[0] == TAP_RESET)
-						jtag_add_tlr();
-					else
-						jtag_add_pathmove(pathlen, path);
+				LOG_DEBUG("XSTATE 0x%02X %s", uc,
+				tap_state_name(mystate));
 
-					result = jtag_execute_queue();
-					if (result != ERROR_OK) {
-						LOG_ERROR("XSVF: pathmove error %d", result);
-						do_abort = 1;
-						break;
-					}
+				/* If path is incomplete, collect more */
+				if (!svf_tap_state_is_stable(mystate))
 					continue;
+
+				/* Else execute the path transitions we've
+				 * collected so far.
+				 *
+				 * NOTE:  Punting on the saved path is not
+				 * strictly correct, but we must to do this
+				 * unless jtag_add_pathmove() stops rejecting
+				 * paths containing RESET.  This is probably
+				 * harmless, since there aren't many options
+				 * for going from a stable state to reset;
+				 * at the worst, we may issue extra clocks
+				 * once we get to RESET.
+				 */
+				if (mystate == TAP_RESET) {
+					LOG_WARNING("XSVF: dodgey RESET");
+					path[0] = mystate;
+				}
+
+			/* FALL THROUGH */
+			default:
+				/* Execute the path we collected
+				 *
+				 * NOTE: OpenOCD requires something that XSVF
+				 * doesn't:  the last TAP state in the path
+				 * must be stable.  In practice, tools that
+				 * create XSVF seem to follow that rule too.
+				 */
+				collecting_path = false;
+
+				if (path[0] == TAP_RESET)
+					jtag_add_tlr();
+				else
+					jtag_add_pathmove(pathlen, path);
+
+				result = jtag_execute_queue();
+				if (result != ERROR_OK) {
+					LOG_ERROR("XSVF: pathmove error %d", result);
+					do_abort = 1;
+					break;
+				}
+				continue;
 			}
 		}
 
 		switch (opcode) {
-			case XCOMPLETE:
-				LOG_DEBUG("XCOMPLETE");
-
-				result = jtag_execute_queue();
-				if (result != ERROR_OK)
-					tdo_mismatch = 1;
-				break;
+		case XCOMPLETE:
+			LOG_DEBUG("XCOMPLETE");
+			result = jtag_execute_queue();
+			if (result != ERROR_OK)
+				tdo_mismatch = 1;
+			break;
 
-			case XTDOMASK:
-				LOG_DEBUG("XTDOMASK");
-				if (dr_in_mask &&
-						(xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_mask) != ERROR_OK))
-					do_abort = 1;
-				break;
+		case XTDOMASK:
+			LOG_DEBUG("XTDOMASK");
+			if (dr_in_mask &&
+					(xsvf_read_buffer(xsdrsize, xsvf_fd, dr_in_mask) != ERROR_OK))
+				do_abort = 1;
+			break;
 
-			case XRUNTEST:
+		case XRUNTEST:
 			{
 				uint8_t xruntest_buf[4];
 
@@ -374,7 +373,7 @@ COMMAND_HANDLER(handle_xsvf_command)
 			}
 			break;
 
-			case XREPEAT:
+		case XREPEAT:
 			{
 				uint8_t myrepeat;
 
@@ -387,7 +386,7 @@ COMMAND_HANDLER(handle_xsvf_command)
 			}
 			break;
 
-			case XSDRSIZE:
+		case XSDRSIZE:
 			{
 				uint8_t xsdrsize_buf[4];
 
@@ -409,8 +408,8 @@ COMMAND_HANDLER(handle_xsvf_command)
 			}
 			break;
 
-			case XSDR:		/* these two are identical except for the dr_in_buf */
-			case XSDRTDO:
+		case XSDR:		/* these two are identical except for the dr_in_buf */
+		case XSDRTDO:
 			{
 				int limit = xrepeat;
 				int matched = 0;
@@ -519,47 +518,47 @@ COMMAND_HANDLER(handle_xsvf_command)
 			}
 			break;
 
-			case XSETSDRMASKS:
-				LOG_ERROR("unsupported XSETSDRMASKS");
-				unsupported = 1;
-				break;
+		case XSETSDRMASKS:
+			LOG_ERROR("unsupported XSETSDRMASKS");
+			unsupported = 1;
+			break;
 
-			case XSDRINC:
-				LOG_ERROR("unsupported XSDRINC");
-				unsupported = 1;
-				break;
+		case XSDRINC:
+			LOG_ERROR("unsupported XSDRINC");
+			unsupported = 1;
+			break;
 
-			case XSDRB:
-				LOG_ERROR("unsupported XSDRB");
-				unsupported = 1;
-				break;
+		case XSDRB:
+			LOG_ERROR("unsupported XSDRB");
+			unsupported = 1;
+			break;
 
-			case XSDRC:
-				LOG_ERROR("unsupported XSDRC");
-				unsupported = 1;
-				break;
+		case XSDRC:
+			LOG_ERROR("unsupported XSDRC");
+			unsupported = 1;
+			break;
 
-			case XSDRE:
-				LOG_ERROR("unsupported XSDRE");
-				unsupported = 1;
-				break;
+		case XSDRE:
+			LOG_ERROR("unsupported XSDRE");
+			unsupported = 1;
+			break;
 
-			case XSDRTDOB:
-				LOG_ERROR("unsupported XSDRTDOB");
-				unsupported = 1;
-				break;
+		case XSDRTDOB:
+			LOG_ERROR("unsupported XSDRTDOB");
+			unsupported = 1;
+			break;
 
-			case XSDRTDOC:
-				LOG_ERROR("unsupported XSDRTDOC");
-				unsupported = 1;
-				break;
+		case XSDRTDOC:
+			LOG_ERROR("unsupported XSDRTDOC");
+			unsupported = 1;
+			break;
 
-			case XSDRTDOE:
-				LOG_ERROR("unsupported XSDRTDOE");
-				unsupported = 1;
-				break;
+		case XSDRTDOE:
+			LOG_ERROR("unsupported XSDRTDOE");
+			unsupported = 1;
+			break;
 
-			case XSTATE:
+		case XSTATE:
 			{
 				enum tap_state mystate;
 
@@ -604,50 +603,48 @@ COMMAND_HANDLER(handle_xsvf_command)
 			}
 			break;
 
-			case XENDIR:
-
-				if (read(xsvf_fd, &uc, 1) < 0) {
-					do_abort = 1;
-					break;
-				}
-
-				/* see page 22 of XSVF spec */
-				if (uc == 0) {
-					xendir = TAP_IDLE;
-				} else if (uc == 1) {
-					xendir = TAP_IRPAUSE;
-				} else {
-					LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
-					unsupported = 1;
-					break;
-				}
-
-				LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(xendir));
+		case XENDIR:
+			if (read(xsvf_fd, &uc, 1) < 0) {
+				do_abort = 1;
 				break;
+			}
 
-			case XENDDR:
+			/* see page 22 of XSVF spec */
+			if (uc == 0) {
+				xendir = TAP_IDLE;
+			} else if (uc == 1) {
+				xendir = TAP_IRPAUSE;
+			} else {
+				LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
+				unsupported = 1;
+				break;
+			}
 
-				if (read(xsvf_fd, &uc, 1) < 0) {
-					do_abort = 1;
-					break;
-				}
+			LOG_DEBUG("XENDIR 0x%02X %s", uc, tap_state_name(xendir));
+			break;
 
-				/* see page 22 of XSVF spec */
-				if (uc == 0) {
-					xenddr = TAP_IDLE;
-				} else if (uc == 1) {
-					xenddr = TAP_DRPAUSE;
-				} else {
-					LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
-					unsupported = 1;
-					break;
-				}
+		case XENDDR:
+			if (read(xsvf_fd, &uc, 1) < 0) {
+				do_abort = 1;
+				break;
+			}
 
-				LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(xenddr));
+			/* see page 22 of XSVF spec */
+			if (uc == 0) {
+				xenddr = TAP_IDLE;
+			} else if (uc == 1) {
+				xenddr = TAP_DRPAUSE;
+			} else {
+				LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
+				unsupported = 1;
 				break;
+			}
+
+			LOG_DEBUG("XENDDR %02X %s", uc, tap_state_name(xenddr));
+			break;
 
-			case XSIR:
-			case XSIR2:
+		case XSIR:
+		case XSIR2:
 			{
 				uint8_t short_buf[2];
 				uint8_t *ir_buf;
@@ -710,7 +707,7 @@ COMMAND_HANDLER(handle_xsvf_command)
 			}
 			break;
 
-			case XCOMMENT:
+		case XCOMMENT:
 			{
 				unsigned int ndx = 0;
 				char comment[128];
@@ -732,7 +729,7 @@ COMMAND_HANDLER(handle_xsvf_command)
 			}
 			break;
 
-			case XWAIT:
+		case XWAIT:
 			{
 				/* expected in stream:
 				   XWAIT <uint8_t wait_state> <uint8_t end_state> <uint32_t usecs>
@@ -775,7 +772,7 @@ COMMAND_HANDLER(handle_xsvf_command)
 			}
 			break;
 
-			case XWAITSTATE:
+		case XWAITSTATE:
 			{
 				/* expected in stream:
 				 * XWAITSTATE <uint8_t wait_state> <uint8_t end_state> <uint32_t clock_count>
@@ -836,7 +833,7 @@ COMMAND_HANDLER(handle_xsvf_command)
 			}
 			break;
 
-			case LCOUNT:
+		case LCOUNT:
 			{
 				/* expected in stream:
 				 * LCOUNT <uint32_t loop_count>
@@ -853,7 +850,7 @@ COMMAND_HANDLER(handle_xsvf_command)
 			}
 			break;
 
-			case LDELAY:
+		case LDELAY:
 			{
 				/* expected in stream:
 				 * LDELAY <uint8_t wait_state> <uint32_t clock_count> <uint32_t usecs_to_sleep>
@@ -879,10 +876,10 @@ COMMAND_HANDLER(handle_xsvf_command)
 			}
 			break;
 
-			/* LSDR is more like XSDRTDO than it is like XSDR.  It uses LDELAY which
-			 * comes with clocks !AND! sleep requirements.
-			 */
-			case LSDR:
+		/* LSDR is more like XSDRTDO than it is like XSDR.  It uses LDELAY which
+		 * comes with clocks !AND! sleep requirements.
+		 */
+		case LSDR:
 			{
 				int limit = loop_count;
 				int matched = 0;
@@ -946,7 +943,7 @@ COMMAND_HANDLER(handle_xsvf_command)
 			}
 			break;
 
-			case XTRST:
+		case XTRST:
 			{
 				uint8_t trst_mode;
 
@@ -972,9 +969,9 @@ COMMAND_HANDLER(handle_xsvf_command)
 			}
 			break;
 
-			default:
-				LOG_ERROR("unknown xsvf command (0x%02X)", uc);
-				unsupported = 1;
+		default:
+			LOG_ERROR("unknown xsvf command (0x%02X)", uc);
+			unsupported = 1;
 		}
 
 		if (do_abort || unsupported || tdo_mismatch) {

-- 

[PATCH]: cee91144f4 xsvf: prepare for aligning switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9047

-- gerrit

commit cee91144f4c93729325b7d364f49d479c5d2fee6
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jul 26 13:21:52 2025 +0200

    xsvf: prepare for aligning switch and case statements
    
    To prepare for aligning switch and case statements, fix in advance
    some checkpatch error due to existing code:
    - uniform braces around if/else statements.
    
    While there:
    - drop useless break.
    
    Change-Id: Ic0ce0a9877dbf17c625cf80009a52922176a162d
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/xsvf/xsvf.c b/src/xsvf/xsvf.c
index 617c2f423e..e1cbca41ea 100644
--- a/src/xsvf/xsvf.c
+++ b/src/xsvf/xsvf.c
@@ -349,10 +349,8 @@ COMMAND_HANDLER(handle_xsvf_command)
 				LOG_DEBUG("XCOMPLETE");
 
 				result = jtag_execute_queue();
-				if (result != ERROR_OK) {
+				if (result != ERROR_OK)
 					tdo_mismatch = 1;
-					break;
-				}
 				break;
 
 			case XTDOMASK:
@@ -380,9 +378,9 @@ COMMAND_HANDLER(handle_xsvf_command)
 			{
 				uint8_t myrepeat;
 
-				if (read(xsvf_fd, &myrepeat, 1) < 0)
+				if (read(xsvf_fd, &myrepeat, 1) < 0) {
 					do_abort = 1;
-				else {
+				} else {
 					xrepeat = myrepeat;
 					LOG_DEBUG("XREPEAT %d", xrepeat);
 				}
@@ -614,11 +612,11 @@ COMMAND_HANDLER(handle_xsvf_command)
 				}
 
 				/* see page 22 of XSVF spec */
-				if (uc == 0)
+				if (uc == 0) {
 					xendir = TAP_IDLE;
-				else if (uc == 1)
+				} else if (uc == 1) {
 					xendir = TAP_IRPAUSE;
-				else {
+				} else {
 					LOG_ERROR("illegial XENDIR argument: 0x%02X", uc);
 					unsupported = 1;
 					break;
@@ -635,11 +633,11 @@ COMMAND_HANDLER(handle_xsvf_command)
 				}
 
 				/* see page 22 of XSVF spec */
-				if (uc == 0)
+				if (uc == 0) {
 					xenddr = TAP_IDLE;
-				else if (uc == 1)
+				} else if (uc == 1) {
 					xenddr = TAP_DRPAUSE;
-				else {
+				} else {
 					LOG_ERROR("illegial XENDDR argument: 0x%02X", uc);
 					unsupported = 1;
 					break;
@@ -675,9 +673,9 @@ COMMAND_HANDLER(handle_xsvf_command)
 
 				ir_buf = malloc((bitcount + 7) / 8);
 
-				if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK)
+				if (xsvf_read_buffer(bitcount, xsvf_fd, ir_buf) != ERROR_OK) {
 					do_abort = 1;
-				else {
+				} else {
 					struct scan_field field;
 
 					field.num_bits = bitcount;
@@ -762,9 +760,9 @@ COMMAND_HANDLER(handle_xsvf_command)
 				LOG_DEBUG("XWAIT %s %s usecs:%d", tap_state_name(
 						wait_state), tap_state_name(end_state), delay);
 
-				if (runtest_requires_tck && wait_state == TAP_IDLE)
+				if (runtest_requires_tck && wait_state == TAP_IDLE) {
 					jtag_add_runtest(delay, end_state);
-				else {
+				} else {
 					/* FIXME handle statemove errors ... */
 					result = svf_add_statemove(wait_state);
 					if (result != ERROR_OK)

-- 

[PATCH]: 279dfefb9a contrib: loader: prepare for aligning switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9045

-- gerrit

commit 279dfefb9aca33899dedfdb5a0cafc604a2ddba2
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jul 26 10:39:28 2025 +0200

    contrib: loader: prepare for aligning switch and case statements
    
    To prepare for aligning switch and case statements, fix in advance
    some checkpatch error due to existing code:
    - uniform braces around if/else statements;
    - don't end line with an open parenthesis.
    
    While there:
    - move the default case as last in the list.
    
    Change-Id: Idb9603e9a59c7f2e1a7346d5bdd3bde384d2f75f
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/contrib/loaders/flash/cc26xx/main.c b/contrib/loaders/flash/cc26xx/main.c
index 6b626a3b84..4fa34dc3fa 100644
--- a/contrib/loaders/flash/cc26xx/main.c
+++ b/contrib/loaders/flash/cc26xx/main.c
@@ -103,20 +103,17 @@ int main(void)
 				break;
 			case CMD_PROGRAM:
 				status =
-					flashloader_program(
-						(uint8_t *)g_cfg[g_curr_buf].buf_addr,
+					flashloader_program((uint8_t *)g_cfg[g_curr_buf].buf_addr,
 						g_cfg[g_curr_buf].dest, g_cfg[g_curr_buf].len);
 				break;
 			case CMD_ERASE_AND_PROGRAM:
 				status =
-					flashloader_erase_and_program(
-						(uint8_t *)g_cfg[g_curr_buf].buf_addr,
+					flashloader_erase_and_program((uint8_t *)g_cfg[g_curr_buf].buf_addr,
 						g_cfg[g_curr_buf].dest, g_cfg[g_curr_buf].len);
 				break;
 			case CMD_ERASE_AND_PROGRAM_WITH_RETAIN:
 				status =
-					flashloader_program_with_retain(
-						(uint8_t *)g_cfg[g_curr_buf].buf_addr,
+					flashloader_program_with_retain((uint8_t *)g_cfg[g_curr_buf].buf_addr,
 						g_cfg[g_curr_buf].dest, g_cfg[g_curr_buf].len);
 				break;
 			case CMD_ERASE_SECTORS:
diff --git a/contrib/loaders/flash/msp432/driverlib.c b/contrib/loaders/flash/msp432/driverlib.c
index 6f483b83da..f04d80a278 100644
--- a/contrib/loaders/flash/msp432/driverlib.c
+++ b/contrib/loaders/flash/msp432/driverlib.c
@@ -117,12 +117,6 @@ uint8_t pcm_get_power_mode(void)
 	current_power_state = pcm_get_power_state();
 
 	switch (current_power_state) {
-		case PCM_AM_LDO_VCORE0:
-		case PCM_AM_LDO_VCORE1:
-		case PCM_LPM0_LDO_VCORE0:
-		case PCM_LPM0_LDO_VCORE1:
-		default:
-			return PCM_LDO_MODE;
 		case PCM_AM_DCDC_VCORE0:
 		case PCM_AM_DCDC_VCORE1:
 		case PCM_LPM0_DCDC_VCORE0:
@@ -133,6 +127,12 @@ uint8_t pcm_get_power_mode(void)
 		case PCM_AM_LF_VCORE1:
 		case PCM_AM_LF_VCORE0:
 			return PCM_LF_MODE;
+		case PCM_AM_LDO_VCORE0:
+		case PCM_AM_LDO_VCORE1:
+		case PCM_LPM0_LDO_VCORE0:
+		case PCM_LPM0_LDO_VCORE1:
+		default:
+			return PCM_LDO_MODE;
 	}
 }
 
@@ -141,14 +141,6 @@ uint8_t pcm_get_core_voltage_level(void)
 	uint8_t current_power_state = pcm_get_power_state();
 
 	switch (current_power_state) {
-		case PCM_AM_LDO_VCORE0:
-		case PCM_AM_DCDC_VCORE0:
-		case PCM_AM_LF_VCORE0:
-		case PCM_LPM0_LDO_VCORE0:
-		case PCM_LPM0_DCDC_VCORE0:
-		case PCM_LPM0_LF_VCORE0:
-		default:
-			return PCM_VCORE0;
 		case PCM_AM_LDO_VCORE1:
 		case PCM_AM_DCDC_VCORE1:
 		case PCM_AM_LF_VCORE1:
@@ -158,6 +150,14 @@ uint8_t pcm_get_core_voltage_level(void)
 			return PCM_VCORE1;
 		case PCM_LPM3:
 			return PCM_VCORELPM3;
+		case PCM_AM_LDO_VCORE0:
+		case PCM_AM_DCDC_VCORE0:
+		case PCM_AM_LF_VCORE0:
+		case PCM_LPM0_LDO_VCORE0:
+		case PCM_LPM0_DCDC_VCORE0:
+		case PCM_LPM0_LF_VCORE0:
+		default:
+			return PCM_VCORE0;
 	}
 }
 
@@ -196,7 +196,7 @@ static bool __pcm_set_power_mode_advanced(uint_fast8_t power_mode,
 				PCM->CTL0 = (PCM_KEY | PCM_AM_LDO_VCORE1
 					| (reg_value & ~(PCM_CTL0_KEY_MASK | PCM_CTL0_AMR_MASK)));
 				break;
-			case PCM_AM_LDO_VCORE1: {
+			case PCM_AM_LDO_VCORE1:
 				if (power_mode == PCM_DCDC_MODE) {
 					PCM->CTL0 = (PCM_KEY | PCM_AM_DCDC_VCORE1
 						| (reg_value & ~(PCM_CTL0_KEY_MASK
@@ -205,11 +205,11 @@ static bool __pcm_set_power_mode_advanced(uint_fast8_t power_mode,
 					PCM->CTL0 = (PCM_KEY | PCM_AM_LF_VCORE1
 						| (reg_value & ~(PCM_CTL0_KEY_MASK
 						| PCM_CTL0_AMR_MASK)));
-				} else
+				} else {
 					return false;
+				}
 				break;
-			}
-			case PCM_AM_LDO_VCORE0: {
+			case PCM_AM_LDO_VCORE0:
 				if (power_mode == PCM_DCDC_MODE) {
 					PCM->CTL0 = (PCM_KEY | PCM_AM_DCDC_VCORE0
 						| (reg_value & ~(PCM_CTL0_KEY_MASK
@@ -218,10 +218,10 @@ static bool __pcm_set_power_mode_advanced(uint_fast8_t power_mode,
 					PCM->CTL0 = (PCM_KEY | PCM_AM_LF_VCORE0
 						| (reg_value & ~(PCM_CTL0_KEY_MASK
 						| PCM_CTL0_AMR_MASK)));
-				} else
+				} else {
 					return false;
+				}
 				break;
-			}
 			default:
 				break;
 		}
@@ -231,8 +231,9 @@ static bool __pcm_set_power_mode_advanced(uint_fast8_t power_mode,
 				if (bool_timeout && !(--time_out))
 					return false;
 			}
-		} else
+		} else {
 			return true;
+		}
 
 		current_power_mode = pcm_get_power_mode();
 		current_power_state = pcm_get_power_state();

-- 

[PATCH]: 8f6b680978 contrib: loaders: align switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9046

-- gerrit

commit 8f6b680978f4b201bedd6d2a069e6fdff8eca672
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jul 26 10:36:26 2025 +0200

    contrib: loaders: align switch and case statements
    
    The coding style requires the 'case' to be at the same indentation
    level of its 'switch' statement.
    
    Align the code accordingly.
    
    While there:
    - add space around operators;
    - remove space after cast.
    
    Skip the file
            contrib/firmware/angie/c/src/usb.c
    as it's going to be modified by a patch already pending in gerrit.
    
    No changes are reported by
            git log -p -w --ignore-blank-lines --patience
    
    Change-Id: I0bebd6d0cc95ddecd5794cc4c12c8412b38691e9
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/contrib/loaders/flash/at91sam7x/main.c b/contrib/loaders/flash/at91sam7x/main.c
index a29c6e605b..e988e1848b 100644
--- a/contrib/loaders/flash/at91sam7x/main.c
+++ b/contrib/loaders/flash/at91sam7x/main.c
@@ -70,23 +70,23 @@ int main (void)
 	for (;;) {
 		cmd = dcc_rd();
 		switch (cmd&OCL_CMD_MASK) {
-			case OCL_PROBE:
-				dcc_wr(OCL_CMD_DONE | flash_init());
-				dcc_wr(0x100000); /* base */
-				dcc_wr(flash_page_count*flash_page_size); /* size */
-				dcc_wr(1); /* num_sectors */
-				dcc_wr(4096 | ((unsigned long) flash_page_size << 16)); /* buflen and bufalign */
-				break;
-			case OCL_ERASE_ALL:
-				dcc_wr(OCL_CMD_DONE | flash_erase_all());
-				break;
-			case OCL_FLASH_BLOCK:
-				cmd_flash(cmd);
-				break;
-			default:
-				/* unknown command */
-				dcc_wr(OCL_CMD_ERR);
-				break;
+		case OCL_PROBE:
+			dcc_wr(OCL_CMD_DONE | flash_init());
+			dcc_wr(0x100000); /* base */
+			dcc_wr(flash_page_count * flash_page_size); /* size */
+			dcc_wr(1); /* num_sectors */
+			dcc_wr(4096 | ((unsigned long)flash_page_size << 16)); /* buflen and bufalign */
+			break;
+		case OCL_ERASE_ALL:
+			dcc_wr(OCL_CMD_DONE | flash_erase_all());
+			break;
+		case OCL_FLASH_BLOCK:
+			cmd_flash(cmd);
+			break;
+		default:
+			/* unknown command */
+			dcc_wr(OCL_CMD_ERR);
+			break;
 		}
 	}
 
diff --git a/contrib/loaders/flash/at91sam7x/samflash.c b/contrib/loaders/flash/at91sam7x/samflash.c
index fcb76fbf98..8be0bdbb84 100644
--- a/contrib/loaders/flash/at91sam7x/samflash.c
+++ b/contrib/loaders/flash/at91sam7x/samflash.c
@@ -22,38 +22,38 @@ int flash_init(void)
 	nvpsiz = (inr(DBGU_CIDR) >> 8)&0xf;
 
 	switch (nvpsiz) {
-		case 3:
-			/* AT91SAM7x32 */
-			flash_page_count = 256;
-			flash_page_size = 128;
-			flash_lock_pages = 256/8;
-			break;
-		case 5:
-			/* AT91SAM7x64 */
-			flash_page_count = 512;
-			flash_page_size = 128;
-			flash_lock_pages = 512/16;
-			break;
-		case 7:
-			/* AT91SAM7x128*/
-			flash_page_count = 512;
-			flash_page_size = 256;
-			flash_lock_pages = 512/8;
-			break;
-		case 9:
-			/* AT91SAM7x256 */
-			flash_page_count = 1024;
-			flash_page_size = 256;
-			flash_lock_pages = 1024/16;
-			break;
-		case 10:
-			/* AT91SAM7x512 */
-			flash_page_count = 2048;
-			flash_page_size = 256;
-			flash_lock_pages = 2048/32;
-			break;
-		default:
-			return FLASH_STAT_INITE;
+	case 3:
+		/* AT91SAM7x32 */
+		flash_page_count = 256;
+		flash_page_size = 128;
+		flash_lock_pages = 256 / 8;
+		break;
+	case 5:
+		/* AT91SAM7x64 */
+		flash_page_count = 512;
+		flash_page_size = 128;
+		flash_lock_pages = 512 / 16;
+		break;
+	case 7:
+		/* AT91SAM7x128*/
+		flash_page_count = 512;
+		flash_page_size = 256;
+		flash_lock_pages = 512 / 8;
+		break;
+	case 9:
+		/* AT91SAM7x256 */
+		flash_page_count = 1024;
+		flash_page_size = 256;
+		flash_lock_pages = 1024 / 16;
+		break;
+	case 10:
+		/* AT91SAM7x512 */
+		flash_page_count = 2048;
+		flash_page_size = 256;
+		flash_lock_pages = 2048 / 32;
+		break;
+	default:
+		return FLASH_STAT_INITE;
 	}
 	return FLASH_STAT_OK;
 }
diff --git a/contrib/loaders/flash/cc26xx/main.c b/contrib/loaders/flash/cc26xx/main.c
index 4fa34dc3fa..bd5eaf3354 100644
--- a/contrib/loaders/flash/cc26xx/main.c
+++ b/contrib/loaders/flash/cc26xx/main.c
@@ -98,32 +98,32 @@ int main(void)
 
 		/* Perform requested task */
 		switch (g_cfg[g_curr_buf].cmd) {
-			case CMD_ERASE_ALL:
-				status = flashloader_erase_all();
-				break;
-			case CMD_PROGRAM:
-				status =
-					flashloader_program((uint8_t *)g_cfg[g_curr_buf].buf_addr,
-						g_cfg[g_curr_buf].dest, g_cfg[g_curr_buf].len);
-				break;
-			case CMD_ERASE_AND_PROGRAM:
-				status =
-					flashloader_erase_and_program((uint8_t *)g_cfg[g_curr_buf].buf_addr,
-						g_cfg[g_curr_buf].dest, g_cfg[g_curr_buf].len);
-				break;
-			case CMD_ERASE_AND_PROGRAM_WITH_RETAIN:
-				status =
-					flashloader_program_with_retain((uint8_t *)g_cfg[g_curr_buf].buf_addr,
-						g_cfg[g_curr_buf].dest, g_cfg[g_curr_buf].len);
-				break;
-			case CMD_ERASE_SECTORS:
-				status =
-					flashloader_erase_sectors(g_cfg[g_curr_buf].dest,
-						g_cfg[g_curr_buf].len);
-				break;
-			default:
-				status = STATUS_FAILED_UNKNOWN_COMMAND;
-				break;
+		case CMD_ERASE_ALL:
+			status = flashloader_erase_all();
+			break;
+		case CMD_PROGRAM:
+			status =
+				flashloader_program((uint8_t *)g_cfg[g_curr_buf].buf_addr,
+					g_cfg[g_curr_buf].dest, g_cfg[g_curr_buf].len);
+			break;
+		case CMD_ERASE_AND_PROGRAM:
+			status =
+				flashloader_erase_and_program((uint8_t *)g_cfg[g_curr_buf].buf_addr,
+					g_cfg[g_curr_buf].dest, g_cfg[g_curr_buf].len);
+			break;
+		case CMD_ERASE_AND_PROGRAM_WITH_RETAIN:
+			status =
+				flashloader_program_with_retain((uint8_t *)g_cfg[g_curr_buf].buf_addr,
+					g_cfg[g_curr_buf].dest, g_cfg[g_curr_buf].len);
+			break;
+		case CMD_ERASE_SECTORS:
+			status =
+				flashloader_erase_sectors(g_cfg[g_curr_buf].dest,
+					g_cfg[g_curr_buf].len);
+			break;
+		default:
+			status = STATUS_FAILED_UNKNOWN_COMMAND;
+			break;
 		}
 
 		restore_cache_state();
diff --git a/contrib/loaders/flash/msp432/driverlib.c b/contrib/loaders/flash/msp432/driverlib.c
index f04d80a278..b897755d16 100644
--- a/contrib/loaders/flash/msp432/driverlib.c
+++ b/contrib/loaders/flash/msp432/driverlib.c
@@ -67,20 +67,20 @@ static bool __pcm_set_core_voltage_level_advanced(uint_fast8_t voltage_level,
 		reg_value = PCM->CTL0;
 
 		switch (pcm_get_power_state()) {
-			case PCM_AM_LF_VCORE1:
-			case PCM_AM_DCDC_VCORE1:
-			case PCM_AM_LDO_VCORE0:
-				PCM->CTL0 = (PCM_KEY | (PCM_AM_LDO_VCORE1)
-					| (reg_value & ~(PCM_CTL0_KEY_MASK | PCM_CTL0_AMR_MASK)));
-				break;
-			case PCM_AM_LF_VCORE0:
-			case PCM_AM_DCDC_VCORE0:
-			case PCM_AM_LDO_VCORE1:
-				PCM->CTL0 = (PCM_KEY | (PCM_AM_LDO_VCORE0)
-					| (reg_value & ~(PCM_CTL0_KEY_MASK | PCM_CTL0_AMR_MASK)));
-				break;
-			default:
-				break;
+		case PCM_AM_LF_VCORE1:
+		case PCM_AM_DCDC_VCORE1:
+		case PCM_AM_LDO_VCORE0:
+			PCM->CTL0 = (PCM_KEY | (PCM_AM_LDO_VCORE1)
+				| (reg_value & ~(PCM_CTL0_KEY_MASK | PCM_CTL0_AMR_MASK)));
+			break;
+		case PCM_AM_LF_VCORE0:
+		case PCM_AM_DCDC_VCORE0:
+		case PCM_AM_LDO_VCORE1:
+			PCM->CTL0 = (PCM_KEY | (PCM_AM_LDO_VCORE0)
+				| (reg_value & ~(PCM_CTL0_KEY_MASK | PCM_CTL0_AMR_MASK)));
+			break;
+		default:
+			break;
 		}
 
 		if (blocking) {
@@ -117,22 +117,22 @@ uint8_t pcm_get_power_mode(void)
 	current_power_state = pcm_get_power_state();
 
 	switch (current_power_state) {
-		case PCM_AM_DCDC_VCORE0:
-		case PCM_AM_DCDC_VCORE1:
-		case PCM_LPM0_DCDC_VCORE0:
-		case PCM_LPM0_DCDC_VCORE1:
-			return PCM_DCDC_MODE;
-		case PCM_LPM0_LF_VCORE0:
-		case PCM_LPM0_LF_VCORE1:
-		case PCM_AM_LF_VCORE1:
-		case PCM_AM_LF_VCORE0:
-			return PCM_LF_MODE;
-		case PCM_AM_LDO_VCORE0:
-		case PCM_AM_LDO_VCORE1:
-		case PCM_LPM0_LDO_VCORE0:
-		case PCM_LPM0_LDO_VCORE1:
-		default:
-			return PCM_LDO_MODE;
+	case PCM_AM_DCDC_VCORE0:
+	case PCM_AM_DCDC_VCORE1:
+	case PCM_LPM0_DCDC_VCORE0:
+	case PCM_LPM0_DCDC_VCORE1:
+		return PCM_DCDC_MODE;
+	case PCM_LPM0_LF_VCORE0:
+	case PCM_LPM0_LF_VCORE1:
+	case PCM_AM_LF_VCORE1:
+	case PCM_AM_LF_VCORE0:
+		return PCM_LF_MODE;
+	case PCM_AM_LDO_VCORE0:
+	case PCM_AM_LDO_VCORE1:
+	case PCM_LPM0_LDO_VCORE0:
+	case PCM_LPM0_LDO_VCORE1:
+	default:
+		return PCM_LDO_MODE;
 	}
 }
 
@@ -141,23 +141,23 @@ uint8_t pcm_get_core_voltage_level(void)
 	uint8_t current_power_state = pcm_get_power_state();
 
 	switch (current_power_state) {
-		case PCM_AM_LDO_VCORE1:
-		case PCM_AM_DCDC_VCORE1:
-		case PCM_AM_LF_VCORE1:
-		case PCM_LPM0_LDO_VCORE1:
-		case PCM_LPM0_DCDC_VCORE1:
-		case PCM_LPM0_LF_VCORE1:
-			return PCM_VCORE1;
-		case PCM_LPM3:
-			return PCM_VCORELPM3;
-		case PCM_AM_LDO_VCORE0:
-		case PCM_AM_DCDC_VCORE0:
-		case PCM_AM_LF_VCORE0:
-		case PCM_LPM0_LDO_VCORE0:
-		case PCM_LPM0_DCDC_VCORE0:
-		case PCM_LPM0_LF_VCORE0:
-		default:
-			return PCM_VCORE0;
+	case PCM_AM_LDO_VCORE1:
+	case PCM_AM_DCDC_VCORE1:
+	case PCM_AM_LF_VCORE1:
+	case PCM_LPM0_LDO_VCORE1:
+	case PCM_LPM0_DCDC_VCORE1:
+	case PCM_LPM0_LF_VCORE1:
+		return PCM_VCORE1;
+	case PCM_LPM3:
+		return PCM_VCORELPM3;
+	case PCM_AM_LDO_VCORE0:
+	case PCM_AM_DCDC_VCORE0:
+	case PCM_AM_LF_VCORE0:
+	case PCM_LPM0_LDO_VCORE0:
+	case PCM_LPM0_DCDC_VCORE0:
+	case PCM_LPM0_LF_VCORE0:
+	default:
+		return PCM_VCORE0;
 	}
 }
 
@@ -186,44 +186,44 @@ static bool __pcm_set_power_mode_advanced(uint_fast8_t power_mode,
 		reg_value = PCM->CTL0;
 
 		switch (current_power_state) {
-			case PCM_AM_DCDC_VCORE0:
-			case PCM_AM_LF_VCORE0:
-				PCM->CTL0 = (PCM_KEY | PCM_AM_LDO_VCORE0
-					| (reg_value & ~(PCM_CTL0_KEY_MASK | PCM_CTL0_AMR_MASK)));
-				break;
-			case PCM_AM_LF_VCORE1:
-			case PCM_AM_DCDC_VCORE1:
-				PCM->CTL0 = (PCM_KEY | PCM_AM_LDO_VCORE1
-					| (reg_value & ~(PCM_CTL0_KEY_MASK | PCM_CTL0_AMR_MASK)));
-				break;
-			case PCM_AM_LDO_VCORE1:
-				if (power_mode == PCM_DCDC_MODE) {
-					PCM->CTL0 = (PCM_KEY | PCM_AM_DCDC_VCORE1
-						| (reg_value & ~(PCM_CTL0_KEY_MASK
-						| PCM_CTL0_AMR_MASK)));
-				} else if (power_mode == PCM_LF_MODE) {
-					PCM->CTL0 = (PCM_KEY | PCM_AM_LF_VCORE1
-						| (reg_value & ~(PCM_CTL0_KEY_MASK
-						| PCM_CTL0_AMR_MASK)));
-				} else {
-					return false;
-				}
-				break;
-			case PCM_AM_LDO_VCORE0:
-				if (power_mode == PCM_DCDC_MODE) {
-					PCM->CTL0 = (PCM_KEY | PCM_AM_DCDC_VCORE0
-						| (reg_value & ~(PCM_CTL0_KEY_MASK
-						| PCM_CTL0_AMR_MASK)));
-				} else if (power_mode == PCM_LF_MODE) {
-					PCM->CTL0 = (PCM_KEY | PCM_AM_LF_VCORE0
-						| (reg_value & ~(PCM_CTL0_KEY_MASK
-						| PCM_CTL0_AMR_MASK)));
-				} else {
-					return false;
-				}
-				break;
-			default:
-				break;
+		case PCM_AM_DCDC_VCORE0:
+		case PCM_AM_LF_VCORE0:
+			PCM->CTL0 = (PCM_KEY | PCM_AM_LDO_VCORE0
+				| (reg_value & ~(PCM_CTL0_KEY_MASK | PCM_CTL0_AMR_MASK)));
+			break;
+		case PCM_AM_LF_VCORE1:
+		case PCM_AM_DCDC_VCORE1:
+			PCM->CTL0 = (PCM_KEY | PCM_AM_LDO_VCORE1
+				| (reg_value & ~(PCM_CTL0_KEY_MASK | PCM_CTL0_AMR_MASK)));
+			break;
+		case PCM_AM_LDO_VCORE1:
+			if (power_mode == PCM_DCDC_MODE) {
+				PCM->CTL0 = (PCM_KEY | PCM_AM_DCDC_VCORE1
+					| (reg_value & ~(PCM_CTL0_KEY_MASK
+					| PCM_CTL0_AMR_MASK)));
+			} else if (power_mode == PCM_LF_MODE) {
+				PCM->CTL0 = (PCM_KEY | PCM_AM_LF_VCORE1
+					| (reg_value & ~(PCM_CTL0_KEY_MASK
+					| PCM_CTL0_AMR_MASK)));
+			} else {
+				return false;
+			}
+			break;
+		case PCM_AM_LDO_VCORE0:
+			if (power_mode == PCM_DCDC_MODE) {
+				PCM->CTL0 = (PCM_KEY | PCM_AM_DCDC_VCORE0
+					| (reg_value & ~(PCM_CTL0_KEY_MASK
+					| PCM_CTL0_AMR_MASK)));
+			} else if (power_mode == PCM_LF_MODE) {
+				PCM->CTL0 = (PCM_KEY | PCM_AM_LF_VCORE0
+					| (reg_value & ~(PCM_CTL0_KEY_MASK
+					| PCM_CTL0_AMR_MASK)));
+			} else {
+				return false;
+			}
+			break;
+		default:
+			break;
 		}
 
 		if (blocking) {
@@ -257,76 +257,76 @@ static bool __pcm_set_power_state_advanced(uint_fast8_t power_state,
 		return true;
 
 	switch (power_state) {
-		case PCM_AM_LDO_VCORE0:
-			return __pcm_set_core_voltage_level_advanced(PCM_VCORE0, timeout,
-					blocking) && __pcm_set_power_mode_advanced(PCM_LDO_MODE,
-					timeout, blocking);
-		case PCM_AM_LDO_VCORE1:
-			return __pcm_set_core_voltage_level_advanced(PCM_VCORE1, timeout,
-					blocking) && __pcm_set_power_mode_advanced(PCM_LDO_MODE,
-					timeout, blocking);
-		case PCM_AM_DCDC_VCORE0:
-			return __pcm_set_core_voltage_level_advanced(PCM_VCORE0, timeout,
-					blocking) && __pcm_set_power_mode_advanced(PCM_DCDC_MODE,
-					timeout, blocking);
-		case PCM_AM_DCDC_VCORE1:
-			return __pcm_set_core_voltage_level_advanced(PCM_VCORE1, timeout,
-					blocking) && __pcm_set_power_mode_advanced(PCM_DCDC_MODE,
-					timeout, blocking);
-		case PCM_AM_LF_VCORE0:
-			return __pcm_set_core_voltage_level_advanced(PCM_VCORE0, timeout,
-					blocking) && __pcm_set_power_mode_advanced(PCM_LF_MODE,
-					timeout, blocking);
-		case PCM_AM_LF_VCORE1:
-			return __pcm_set_core_voltage_level_advanced(PCM_VCORE1, timeout,
-					blocking) && __pcm_set_power_mode_advanced(PCM_LF_MODE,
-					timeout, blocking);
-		case PCM_LPM0_LDO_VCORE0:
-			if (!__pcm_set_core_voltage_level_advanced(PCM_VCORE0, timeout,
-				blocking) || !__pcm_set_power_mode_advanced(PCM_LDO_MODE,
-				timeout, blocking))
-				break;
-			return pcm_goto_lpm0();
-		case PCM_LPM0_LDO_VCORE1:
-			if (!__pcm_set_core_voltage_level_advanced(PCM_VCORE1, timeout,
-				blocking) || !__pcm_set_power_mode_advanced(PCM_LDO_MODE,
-				timeout, blocking))
-				break;
-			return pcm_goto_lpm0();
-		case PCM_LPM0_DCDC_VCORE0:
-			if (!__pcm_set_core_voltage_level_advanced(PCM_VCORE0, timeout,
-				blocking) || !__pcm_set_power_mode_advanced(PCM_DCDC_MODE,
-				timeout, blocking))
-				break;
-			return pcm_goto_lpm0();
-		case PCM_LPM0_DCDC_VCORE1:
-			if (!__pcm_set_core_voltage_level_advanced(PCM_VCORE1, timeout,
-				blocking) || !__pcm_set_power_mode_advanced(PCM_DCDC_MODE,
-				timeout, blocking))
-				break;
-			return pcm_goto_lpm0();
-		case PCM_LPM0_LF_VCORE0:
-			if (!__pcm_set_core_voltage_level_advanced(PCM_VCORE0, timeout,
-				blocking) || !__pcm_set_power_mode_advanced(PCM_LF_MODE,
-				timeout, blocking))
-				break;
-			return pcm_goto_lpm0();
-		case PCM_LPM0_LF_VCORE1:
-			if (!__pcm_set_core_voltage_level_advanced(PCM_VCORE1, timeout,
-				blocking) || !__pcm_set_power_mode_advanced(PCM_LF_MODE,
-				timeout, blocking))
-				break;
-			return pcm_goto_lpm0();
-		case PCM_LPM3:
-			return pcm_goto_lpm3();
-		case PCM_LPM4:
-			return pcm_goto_lpm4();
-		case PCM_LPM45:
-			return pcm_shutdown_device(PCM_LPM45);
-		case PCM_LPM35_VCORE0:
-			return pcm_shutdown_device(PCM_LPM35_VCORE0);
-		default:
-			return false;
+	case PCM_AM_LDO_VCORE0:
+		return __pcm_set_core_voltage_level_advanced(PCM_VCORE0, timeout,
+				blocking) && __pcm_set_power_mode_advanced(PCM_LDO_MODE,
+				timeout, blocking);
+	case PCM_AM_LDO_VCORE1:
+		return __pcm_set_core_voltage_level_advanced(PCM_VCORE1, timeout,
+				blocking) && __pcm_set_power_mode_advanced(PCM_LDO_MODE,
+				timeout, blocking);
+	case PCM_AM_DCDC_VCORE0:
+		return __pcm_set_core_voltage_level_advanced(PCM_VCORE0, timeout,
+				blocking) && __pcm_set_power_mode_advanced(PCM_DCDC_MODE,
+				timeout, blocking);
+	case PCM_AM_DCDC_VCORE1:
+		return __pcm_set_core_voltage_level_advanced(PCM_VCORE1, timeout,
+				blocking) && __pcm_set_power_mode_advanced(PCM_DCDC_MODE,
+				timeout, blocking);
+	case PCM_AM_LF_VCORE0:
+		return __pcm_set_core_voltage_level_advanced(PCM_VCORE0, timeout,
+				blocking) && __pcm_set_power_mode_advanced(PCM_LF_MODE,
+				timeout, blocking);
+	case PCM_AM_LF_VCORE1:
+		return __pcm_set_core_voltage_level_advanced(PCM_VCORE1, timeout,
+				blocking) && __pcm_set_power_mode_advanced(PCM_LF_MODE,
+				timeout, blocking);
+	case PCM_LPM0_LDO_VCORE0:
+		if (!__pcm_set_core_voltage_level_advanced(PCM_VCORE0, timeout,
+			blocking) || !__pcm_set_power_mode_advanced(PCM_LDO_MODE,
+			timeout, blocking))
+			break;
+		return pcm_goto_lpm0();
+	case PCM_LPM0_LDO_VCORE1:
+		if (!__pcm_set_core_voltage_level_advanced(PCM_VCORE1, timeout,
+			blocking) || !__pcm_set_power_mode_advanced(PCM_LDO_MODE,
+			timeout, blocking))
+			break;
+		return pcm_goto_lpm0();
+	case PCM_LPM0_DCDC_VCORE0:
+		if (!__pcm_set_core_voltage_level_advanced(PCM_VCORE0, timeout,
+			blocking) || !__pcm_set_power_mode_advanced(PCM_DCDC_MODE,
+			timeout, blocking))
+			break;
+		return pcm_goto_lpm0();
+	case PCM_LPM0_DCDC_VCORE1:
+		if (!__pcm_set_core_voltage_level_advanced(PCM_VCORE1, timeout,
+			blocking) || !__pcm_set_power_mode_advanced(PCM_DCDC_MODE,
+			timeout, blocking))
+			break;
+		return pcm_goto_lpm0();
+	case PCM_LPM0_LF_VCORE0:
+		if (!__pcm_set_core_voltage_level_advanced(PCM_VCORE0, timeout,
+			blocking) || !__pcm_set_power_mode_advanced(PCM_LF_MODE,
+			timeout, blocking))
+			break;
+		return pcm_goto_lpm0();
+	case PCM_LPM0_LF_VCORE1:
+		if (!__pcm_set_core_voltage_level_advanced(PCM_VCORE1, timeout,
+			blocking) || !__pcm_set_power_mode_advanced(PCM_LF_MODE,
+			timeout, blocking))
+			break;
+		return pcm_goto_lpm0();
+	case PCM_LPM3:
+		return pcm_goto_lpm3();
+	case PCM_LPM4:
+		return pcm_goto_lpm4();
+	case PCM_LPM45:
+		return pcm_shutdown_device(PCM_LPM45);
+	case PCM_LPM35_VCORE0:
+		return pcm_shutdown_device(PCM_LPM35_VCORE0);
+	default:
+		return false;
 	}
 
 	return false;
diff --git a/contrib/loaders/flash/msp432/main_msp432e4x.c b/contrib/loaders/flash/msp432/main_msp432e4x.c
index 7974f48c77..7c9cf468df 100644
--- a/contrib/loaders/flash/msp432/main_msp432e4x.c
+++ b/contrib/loaders/flash/msp432/main_msp432e4x.c
@@ -30,37 +30,37 @@ int main(void)
 
 	while (1) {
 		switch (FLASH_LOADER->FLASH_FUNCTION) {
-			case FLASH_INIT:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_init();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_MASS_ERASE:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_mass_erase();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_SECTOR_ERASE:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_sector_erase();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_PROGRAM:
-			case FLASH_CONTINUOUS_PROGRAM:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_continous_write();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_EXIT:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_exit();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_NO_COMMAND:
-				break;
-			default:
-				FLASH_LOADER->RETURN_CODE = FLASH_WRONG_COMMAND;
-				break;
+		case FLASH_INIT:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_init();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_MASS_ERASE:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_mass_erase();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_SECTOR_ERASE:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_sector_erase();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_PROGRAM:
+		case FLASH_CONTINUOUS_PROGRAM:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_continous_write();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_EXIT:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_exit();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_NO_COMMAND:
+			break;
+		default:
+			FLASH_LOADER->RETURN_CODE = FLASH_WRONG_COMMAND;
+			break;
 		}
 	}
 }
diff --git a/contrib/loaders/flash/msp432/main_msp432p401x.c b/contrib/loaders/flash/msp432/main_msp432p401x.c
index 47fb7fa476..024d047224 100644
--- a/contrib/loaders/flash/msp432/main_msp432p401x.c
+++ b/contrib/loaders/flash/msp432/main_msp432p401x.c
@@ -49,41 +49,41 @@ int main(void)
 
 	while (1) {
 		switch (FLASH_LOADER->FLASH_FUNCTION) {
-			case FLASH_INIT:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_init();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_MASS_ERASE:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_mass_erase();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_SECTOR_ERASE:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_sector_erase();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_PROGRAM:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_write();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_CONTINUOUS_PROGRAM:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_continous_write();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_EXIT:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_exit();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_NO_COMMAND:
-				break;
-			default:
-				FLASH_LOADER->RETURN_CODE = FLASH_WRONG_COMMAND;
-				break;
+		case FLASH_INIT:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_init();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_MASS_ERASE:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_mass_erase();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_SECTOR_ERASE:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_sector_erase();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_PROGRAM:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_write();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_CONTINUOUS_PROGRAM:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_continous_write();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_EXIT:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_exit();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_NO_COMMAND:
+			break;
+		default:
+			FLASH_LOADER->RETURN_CODE = FLASH_WRONG_COMMAND;
+			break;
 		}
 	}
 }
diff --git a/contrib/loaders/flash/msp432/main_msp432p411x.c b/contrib/loaders/flash/msp432/main_msp432p411x.c
index efc05a3b78..391057f2e5 100644
--- a/contrib/loaders/flash/msp432/main_msp432p411x.c
+++ b/contrib/loaders/flash/msp432/main_msp432p411x.c
@@ -52,41 +52,41 @@ int main(void)
 
 	while (1) {
 		switch (FLASH_LOADER->FLASH_FUNCTION) {
-			case FLASH_INIT:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_init();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_MASS_ERASE:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_mass_erase();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_SECTOR_ERASE:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_sector_erase();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_PROGRAM:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_write();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_CONTINUOUS_PROGRAM:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_continous_write();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_EXIT:
-				FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
-				msp432_flash_exit();
-				FLASH_LOADER->FLASH_FUNCTION = 0;
-				break;
-			case FLASH_NO_COMMAND:
-				break;
-			default:
-				FLASH_LOADER->RETURN_CODE = FLASH_WRONG_COMMAND;
-				break;
+		case FLASH_INIT:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_init();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_MASS_ERASE:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_mass_erase();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_SECTOR_ERASE:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_sector_erase();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_PROGRAM:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_write();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_CONTINUOUS_PROGRAM:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_continous_write();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_EXIT:
+			FLASH_LOADER->RETURN_CODE = FLASH_BUSY;
+			msp432_flash_exit();
+			FLASH_LOADER->FLASH_FUNCTION = 0;
+			break;
+		case FLASH_NO_COMMAND:
+			break;
+		default:
+			FLASH_LOADER->RETURN_CODE = FLASH_WRONG_COMMAND;
+			break;
 		}
 	}
 }

-- 

[PATCH]: 959cc48f0e target: cortex_a: add break in switch/case

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9049

-- gerrit

commit 959cc48f0e8d1da179e815dc41d142d9e220b5f0
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jul 26 17:44:30 2025 +0200

    target: cortex_a: add break in switch/case
    
    The code falls-through in the default case, making it not easy to
    read.
    
    Add the explicit break to improve the readability.
    
    Change-Id: I4784b883e0e82258de17018dfdfb59b4042ac743
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/target/cortex_a.c b/src/target/cortex_a.c
index 2ebbf65774..dca8da0061 100644
--- a/src/target/cortex_a.c
+++ b/src/target/cortex_a.c
@@ -2361,6 +2361,7 @@ static int cortex_a_write_cpu_memory(struct target *target,
 					count *= 2;
 					size = 2;
 				}
+				break;
 			case 0:
 			default:
 				break;

-- 

[openocd:tickets] Re: #439 OpenOCD failed with code (-1073741819)

[Tommy M. <tm...@us...>]

What do you mean by "vendor packed version etc"?


---

**[tickets:#439] OpenOCD failed with code (-1073741819)**

**Status:** new
**Milestone:** 0.10.0
**Labels:** OpenOCD 
**Created:** Fri Oct 11, 2024 02:23 PM UTC by Alex
**Last Updated:** Fri Jul 25, 2025 06:32 PM UTC
**Owner:** nobody
**Attachments:**

- [image_2024_10_11T13_44_15_984Z.png](https://sourceforge.net/p/openocd/tickets/439/attachment/image_2024_10_11T13_44_15_984Z.png) (44.5 kB; image/png)


Trying to use Microchip SoftConsole 2022 on PolarFire SoC Icicle Kit to debug example application, but OpenOCD failing with message:  **OpenOCD failed with code (-1073741819).** We tried to Google but nothing comes up.  Could you tell us what that error code means?
It is a new DELL laptop running Windows 11. We use SoftConsole on other 4 PCs and no problems. The interesting part that OpenOCD detects two Embedded FlashPro6 as shown on attached image and we did not see that before.
Thank you


---

Sent from sourceforge.net because ope...@li... is subscribed to https://sourceforge.net/p/openocd/tickets/

To unsubscribe from further messages, a project admin can change settings at https://sourceforge.net/p/openocd/admin/tickets/options.  Or, if this is a mailing list, you can unsubscribe from the mailing list.

[openocd:tickets] Re: #439 OpenOCD failed with code (-1073741819)

[Jindrich F. <fu...@us...>]

Hi, I can answer 2nd part. I posted it to this thread as I have same exit code and similar symptoms (vendor packed version etc). 


---

**[tickets:#439] OpenOCD failed with code (-1073741819)**

**Status:** new
**Milestone:** 0.10.0
**Labels:** OpenOCD 
**Created:** Fri Oct 11, 2024 02:23 PM UTC by Alex
**Last Updated:** Fri Jul 25, 2025 06:21 PM UTC
**Owner:** nobody
**Attachments:**

- [image_2024_10_11T13_44_15_984Z.png](https://sourceforge.net/p/openocd/tickets/439/attachment/image_2024_10_11T13_44_15_984Z.png) (44.5 kB; image/png)


Trying to use Microchip SoftConsole 2022 on PolarFire SoC Icicle Kit to debug example application, but OpenOCD failing with message:  **OpenOCD failed with code (-1073741819).** We tried to Google but nothing comes up.  Could you tell us what that error code means?
It is a new DELL laptop running Windows 11. We use SoftConsole on other 4 PCs and no problems. The interesting part that OpenOCD detects two Embedded FlashPro6 as shown on attached image and we did not see that before.
Thank you


---

Sent from sourceforge.net because ope...@li... is subscribed to https://sourceforge.net/p/openocd/tickets/

To unsubscribe from further messages, a project admin can change settings at https://sourceforge.net/p/openocd/admin/tickets/options.  Or, if this is a mailing list, you can unsubscribe from the mailing list.

[PATCH]: 075f629558 svf: rework the tests in svf_xxr_common()

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9043

-- gerrit

commit 075f62955811e1ce8690a07319af796274a70a50
Author: Antonio Borneo <bor...@gm...>
Date:   Fri Jul 25 20:09:43 2025 +0200

    svf: rework the tests in svf_xxr_common()
    
    Check the variable value against the constant.
    
    Change-Id: I353bbada2180d6df789cc225ddb15f22c7deb00d
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/svf/svf.c b/src/svf/svf.c
index 7ef6df4769..6a4639ce83 100644
--- a/src/svf/svf.c
+++ b/src/svf/svf.c
@@ -1037,9 +1037,8 @@ static int svf_xxr_common(char **argus, int num_of_argu, char command, struct sv
 			LOG_ERROR("unknown parameter: %s", argus[i]);
 			return ERROR_FAIL;
 		}
-		if (ERROR_OK !=
-		svf_copy_hexstring_to_binary(&argus[i + 1][1], pbuffer_tmp, i_tmp,
-			xxr_para_tmp->len)) {
+		if (svf_copy_hexstring_to_binary(&argus[i + 1][1], pbuffer_tmp, i_tmp,
+				xxr_para_tmp->len) != ERROR_OK) {
 			LOG_ERROR("fail to parse hex value");
 			return ERROR_FAIL;
 		}
@@ -1050,9 +1049,8 @@ static int svf_xxr_common(char **argus, int num_of_argu, char command, struct sv
 	/* the mask pattern used is all cares */
 	if (!(xxr_para_tmp->data_mask & XXR_MASK) && i_tmp != xxr_para_tmp->len) {
 		/* MASK not defined and length changed */
-		if (ERROR_OK !=
-		svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp,
-			xxr_para_tmp->len)) {
+		if (svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp, xxr_para_tmp->len)
+				!= ERROR_OK) {
 			LOG_ERROR("fail to adjust length of array");
 			return ERROR_FAIL;
 		}
@@ -1061,17 +1059,15 @@ static int svf_xxr_common(char **argus, int num_of_argu, char command, struct sv
 	/* If TDO is absent, no comparison is needed, set the mask to 0 */
 	if (!(xxr_para_tmp->data_mask & XXR_TDO)) {
 		if (!xxr_para_tmp->tdo) {
-			if (ERROR_OK !=
-			svf_adjust_array_length(&xxr_para_tmp->tdo, i_tmp,
-				xxr_para_tmp->len)) {
+			if (svf_adjust_array_length(&xxr_para_tmp->tdo, i_tmp, xxr_para_tmp->len)
+					!= ERROR_OK) {
 				LOG_ERROR("fail to adjust length of array");
 				return ERROR_FAIL;
 			}
 		}
 		if (!xxr_para_tmp->mask) {
-			if (ERROR_OK !=
-			svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp,
-				xxr_para_tmp->len)) {
+			if (svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp, xxr_para_tmp->len)
+					!= ERROR_OK) {
 				LOG_ERROR("fail to adjust length of array");
 				return ERROR_FAIL;
 			}

-- 

[PATCH]: d301ed1d70 svf: prepare for aligning switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9039

-- gerrit

commit d301ed1d70e767bd397793390a5b99d047a7a58a
Author: Antonio Borneo <bor...@gm...>
Date:   Sun Jun 29 23:21:57 2025 +0200

    svf: prepare for aligning switch and case statements
    
    To prepare for aligning switch and case statements, fix in advance
    some checkpatch error due to existing code:
    - remove unnecessary parenthesis;
    - uniform braces around if/else statements.
    
    Change-Id: I851032e1b126462a325f73bdf236fd2dbc938ff3
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/svf/svf.c b/src/svf/svf.c
index ce994686f1..802e2326a2 100644
--- a/src/svf/svf.c
+++ b/src/svf/svf.c
@@ -1035,7 +1035,7 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 			}
 			break;
 		case FREQUENCY:
-			if ((num_of_argu != 1) && (num_of_argu != 3)) {
+			if (num_of_argu != 1 && num_of_argu != 3) {
 				LOG_ERROR("invalid parameter of %s", argus[0]);
 				return ERROR_FAIL;
 			}
@@ -1095,7 +1095,7 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 			goto xxr_common;
 xxr_common:
 			/* XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)] */
-			if ((num_of_argu > 10) || (num_of_argu % 2)) {
+			if (num_of_argu > 10 || (num_of_argu % 2)) {
 				LOG_ERROR("invalid parameter of %s", argus[0]);
 				return ERROR_FAIL;
 			}
@@ -1118,7 +1118,7 @@ xxr_common:
 			xxr_para_tmp->data_mask = 0;
 			for (i = 2; i < num_of_argu; i += 2) {
 				if ((strlen(argus[i + 1]) < 3) || (argus[i + 1][0] != '(') ||
-				(argus[i + 1][strlen(argus[i + 1]) - 1] != ')')) {
+						argus[i + 1][strlen(argus[i + 1]) - 1] != ')') {
 					LOG_ERROR("data section error");
 					return ERROR_FAIL;
 				}
@@ -1155,7 +1155,7 @@ xxr_common:
 			/* If a command changes the length of the last scan of the same type and the
 			 * MASK parameter is absent, */
 			/* the mask pattern used is all cares */
-			if (!(xxr_para_tmp->data_mask & XXR_MASK) && (i_tmp != xxr_para_tmp->len)) {
+			if (!(xxr_para_tmp->data_mask & XXR_MASK) && i_tmp != xxr_para_tmp->len) {
 				/* MASK not defined and length changed */
 				if (ERROR_OK !=
 				svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp,
@@ -1263,8 +1263,9 @@ xxr_common:
 					i += svf_para.tdr_para.len;
 
 					svf_add_check_para(1, svf_buffer_index, i);
-				} else
+				} else {
 					svf_add_check_para(0, svf_buffer_index, i);
+				}
 				field.num_bits = i;
 				field.out_value = &svf_tdi_buffer[svf_buffer_index];
 				field.in_value = (xxr_para_tmp->data_mask & XXR_TDO) ? &svf_tdi_buffer[svf_buffer_index] : NULL;
@@ -1356,8 +1357,9 @@ xxr_common:
 					i += svf_para.tir_para.len;
 
 					svf_add_check_para(1, svf_buffer_index, i);
-				} else
+				} else {
 					svf_add_check_para(0, svf_buffer_index, i);
+				}
 				field.num_bits = i;
 				field.out_value = &svf_tdi_buffer[svf_buffer_index];
 				field.in_value = (xxr_para_tmp->data_mask & XXR_TDO) ? &svf_tdi_buffer[svf_buffer_index] : NULL;
@@ -1381,7 +1383,7 @@ xxr_common:
 			 * SEC]] [ENDSTATE end_state] */
 			/* RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE
 			 * end_state] */
-			if ((num_of_argu < 3) || (num_of_argu > 11)) {
+			if (num_of_argu < 3 || num_of_argu > 11) {
 				LOG_ERROR("invalid parameter of %s", argus[0]);
 				return ERROR_FAIL;
 			}

-- 

[PATCH]: f3b839ae7b svf: align switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9044

-- gerrit

commit f3b839ae7b543ada72171b55c11d550f7058e333
Author: Antonio Borneo <bor...@gm...>
Date:   Sun Jun 29 23:25:21 2025 +0200

    svf: align switch and case statements
    
    The coding style requires the 'case' to be at the same indentation
    level of its 'switch' statement.
    
    Align the code accordingly.
    
    No changes are reported by
            git log -p -w --ignore-blank-lines --patience
    
    Change-Id: I1369294af64c2830cc7fcc2814eac073c2413ff5
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/svf/svf.c b/src/svf/svf.c
index 6a4639ce83..001ffa2631 100644
--- a/src/svf/svf.c
+++ b/src/svf/svf.c
@@ -702,71 +702,71 @@ static int svf_read_command_from_file(FILE *fd)
 	ch = svf_read_line[0];
 	while (!cmd_ok && (ch != 0)) {
 		switch (ch) {
-			case '!':
+		case '!':
+			slash = 0;
+			if (svf_getline(&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
+				return ERROR_FAIL;
+			svf_line_number++;
+			i = -1;
+			break;
+		case '/':
+			if (++slash == 2) {
 				slash = 0;
-				if (svf_getline(&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
+				if (svf_getline(&svf_read_line, &svf_read_line_size,
+					svf_fd) <= 0)
 					return ERROR_FAIL;
 				svf_line_number++;
 				i = -1;
+			}
+			break;
+		case ';':
+			slash = 0;
+			cmd_ok = 1;
+			break;
+		case '\n':
+			svf_line_number++;
+			if (svf_getline(&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
+				return ERROR_FAIL;
+			i = -1;
+			/* fallthrough */
+		case '\r':
+			slash = 0;
+			/* Don't save '\r' and '\n' if no data is parsed */
+			if (!cmd_pos)
 				break;
-			case '/':
-				if (++slash == 2) {
-					slash = 0;
-					if (svf_getline(&svf_read_line, &svf_read_line_size,
-						svf_fd) <= 0)
-						return ERROR_FAIL;
-					svf_line_number++;
-					i = -1;
-				}
-				break;
-			case ';':
-				slash = 0;
-				cmd_ok = 1;
-				break;
-			case '\n':
-				svf_line_number++;
-				if (svf_getline(&svf_read_line, &svf_read_line_size, svf_fd) <= 0)
+			/* fallthrough */
+		default:
+			/* The parsing code currently expects a space
+			 * before parentheses -- "TDI (123)".  Also a
+			 * space afterwards -- "TDI (123) TDO(456)".
+			 * But such spaces are optional... instead of
+			 * parser updates, cope with that by adding the
+			 * spaces as needed.
+			 *
+			 * Ensure there are 3 bytes available, for:
+			 *  - current character
+			 *  - added space.
+			 *  - terminating NUL ('\0')
+			 */
+			if (cmd_pos + 3 > svf_command_buffer_size) {
+				svf_command_buffer = realloc(svf_command_buffer, cmd_pos + 3);
+				svf_command_buffer_size = cmd_pos + 3;
+				if (!svf_command_buffer) {
+					LOG_ERROR("not enough memory");
 					return ERROR_FAIL;
-				i = -1;
-				/* fallthrough */
-			case '\r':
-				slash = 0;
-				/* Don't save '\r' and '\n' if no data is parsed */
-				if (!cmd_pos)
-					break;
-				/* fallthrough */
-			default:
-				/* The parsing code currently expects a space
-				 * before parentheses -- "TDI (123)".  Also a
-				 * space afterwards -- "TDI (123) TDO(456)".
-				 * But such spaces are optional... instead of
-				 * parser updates, cope with that by adding the
-				 * spaces as needed.
-				 *
-				 * Ensure there are 3 bytes available, for:
-				 *  - current character
-				 *  - added space.
-				 *  - terminating NUL ('\0')
-				 */
-				if (cmd_pos + 3 > svf_command_buffer_size) {
-					svf_command_buffer = realloc(svf_command_buffer, cmd_pos + 3);
-					svf_command_buffer_size = cmd_pos + 3;
-					if (!svf_command_buffer) {
-						LOG_ERROR("not enough memory");
-						return ERROR_FAIL;
-					}
 				}
+			}
 
-				/* insert a space before '(' */
-				if ('(' == ch)
-					svf_command_buffer[cmd_pos++] = ' ';
+			/* insert a space before '(' */
+			if ('(' == ch)
+				svf_command_buffer[cmd_pos++] = ' ';
 
-				svf_command_buffer[cmd_pos++] = (char)toupper(ch);
+			svf_command_buffer[cmd_pos++] = (char)toupper(ch);
 
-				/* insert a space after ')' */
-				if (')' == ch)
-					svf_command_buffer[cmd_pos++] = ' ';
-				break;
+			/* insert a space after ')' */
+			if (')' == ch)
+				svf_command_buffer[cmd_pos++] = ' ';
+			break;
 		}
 		ch = svf_read_line[++i];
 	}
@@ -785,18 +785,18 @@ static int svf_parse_cmd_string(char *str, int len, char **argus, int *num_of_ar
 
 	while (pos < len) {
 		switch (str[pos]) {
-			case '!':
-			case '/':
-				LOG_ERROR("fail to parse svf command");
-				return ERROR_FAIL;
-			case '(':
-				in_bracket = true;
-				break;
-			case ')':
-				in_bracket = false;
-				break;
-			default:
-				break;
+		case '!':
+		case '/':
+			LOG_ERROR("fail to parse svf command");
+			return ERROR_FAIL;
+		case '(':
+			in_bracket = true;
+			break;
+		case ')':
+			in_bracket = false;
+			break;
+		default:
+			break;
 		}
 
 		if (!in_bracket && isspace((int)str[pos])) {
@@ -1292,327 +1292,327 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 	command = svf_find_string_in_array(argus[0],
 			(char **)svf_command_name, ARRAY_SIZE(svf_command_name));
 	switch (command) {
-		case ENDDR:
-		case ENDIR:
-			if (num_of_argu != 2) {
-				LOG_ERROR("invalid parameter of %s", argus[0]);
-				return ERROR_FAIL;
-			}
+	case ENDDR:
+	case ENDIR:
+		if (num_of_argu != 2) {
+			LOG_ERROR("invalid parameter of %s", argus[0]);
+			return ERROR_FAIL;
+		}
 
-			i_tmp = tap_state_by_name(argus[1]);
+		i_tmp = tap_state_by_name(argus[1]);
 
-			if (svf_tap_state_is_stable(i_tmp)) {
-				if (command == ENDIR) {
-					svf_para.ir_end_state = i_tmp;
-					LOG_DEBUG("\tIR end_state = %s",
-							tap_state_name(i_tmp));
-				} else {
-					svf_para.dr_end_state = i_tmp;
-					LOG_DEBUG("\tDR end_state = %s",
-							tap_state_name(i_tmp));
-				}
+		if (svf_tap_state_is_stable(i_tmp)) {
+			if (command == ENDIR) {
+				svf_para.ir_end_state = i_tmp;
+				LOG_DEBUG("\tIR end_state = %s",
+						tap_state_name(i_tmp));
 			} else {
-				LOG_ERROR("%s: %s is not a stable state",
-						argus[0], argus[1]);
-				return ERROR_FAIL;
+				svf_para.dr_end_state = i_tmp;
+				LOG_DEBUG("\tDR end_state = %s",
+						tap_state_name(i_tmp));
 			}
-			break;
-		case FREQUENCY:
-			if (num_of_argu != 1 && num_of_argu != 3) {
-				LOG_ERROR("invalid parameter of %s", argus[0]);
+		} else {
+			LOG_ERROR("%s: %s is not a stable state",
+					argus[0], argus[1]);
+			return ERROR_FAIL;
+		}
+		break;
+	case FREQUENCY:
+		if (num_of_argu != 1 && num_of_argu != 3) {
+			LOG_ERROR("invalid parameter of %s", argus[0]);
+			return ERROR_FAIL;
+		}
+		if (num_of_argu == 1) {
+			/* TODO: set jtag speed to full speed */
+			svf_para.frequency = 0;
+		} else {
+			if (strcmp(argus[2], "HZ")) {
+				LOG_ERROR("HZ not found in FREQUENCY command");
 				return ERROR_FAIL;
 			}
-			if (num_of_argu == 1) {
-				/* TODO: set jtag speed to full speed */
-				svf_para.frequency = 0;
-			} else {
-				if (strcmp(argus[2], "HZ")) {
-					LOG_ERROR("HZ not found in FREQUENCY command");
-					return ERROR_FAIL;
-				}
-				if (svf_execute_tap() != ERROR_OK)
-					return ERROR_FAIL;
-				svf_para.frequency = atof(argus[1]);
-				/* TODO: set jtag speed to */
-				if (svf_para.frequency > 0) {
-					command_run_linef(cmd_ctx,
-							"adapter speed %d",
-							(int)svf_para.frequency / 1000);
-					LOG_DEBUG("\tfrequency = %f", svf_para.frequency);
-				}
-			}
-			break;
-		case HDR:
-			if (svf_tap_is_specified) {
-				padding_command_skipped = 1;
-				break;
-			}
-			retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.hdr_para);
-			if (retval != ERROR_OK)
-				return retval;
-			break;
-		case HIR:
-			if (svf_tap_is_specified) {
-				padding_command_skipped = 1;
-				break;
-			}
-			retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.hir_para);
-			if (retval != ERROR_OK)
-				return retval;
-			break;
-		case TDR:
-			if (svf_tap_is_specified) {
-				padding_command_skipped = 1;
-				break;
+			if (svf_execute_tap() != ERROR_OK)
+				return ERROR_FAIL;
+			svf_para.frequency = atof(argus[1]);
+			/* TODO: set jtag speed to */
+			if (svf_para.frequency > 0) {
+				command_run_linef(cmd_ctx,
+						"adapter speed %d",
+						(int)svf_para.frequency / 1000);
+				LOG_DEBUG("\tfrequency = %f", svf_para.frequency);
 			}
-			retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.tdr_para);
-			if (retval != ERROR_OK)
-				return retval;
+		}
+		break;
+	case HDR:
+		if (svf_tap_is_specified) {
+			padding_command_skipped = 1;
 			break;
-		case TIR:
-			if (svf_tap_is_specified) {
-				padding_command_skipped = 1;
-				break;
-			}
-			retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.tir_para);
-			if (retval != ERROR_OK)
-				return retval;
+		}
+		retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.hdr_para);
+		if (retval != ERROR_OK)
+			return retval;
+		break;
+	case HIR:
+		if (svf_tap_is_specified) {
+			padding_command_skipped = 1;
 			break;
-		case SDR:
-			retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.sdr_para);
-			if (retval != ERROR_OK)
-				return retval;
+		}
+		retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.hir_para);
+		if (retval != ERROR_OK)
+			return retval;
+		break;
+	case TDR:
+		if (svf_tap_is_specified) {
+			padding_command_skipped = 1;
 			break;
-		case SIR:
-			retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.sir_para);
-			if (retval != ERROR_OK)
-				return retval;
+		}
+		retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.tdr_para);
+		if (retval != ERROR_OK)
+			return retval;
+		break;
+	case TIR:
+		if (svf_tap_is_specified) {
+			padding_command_skipped = 1;
 			break;
-		case PIO:
-		case PIOMAP:
-			LOG_ERROR("PIO and PIOMAP are not supported");
+		}
+		retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.tir_para);
+		if (retval != ERROR_OK)
+			return retval;
+		break;
+	case SDR:
+		retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.sdr_para);
+		if (retval != ERROR_OK)
+			return retval;
+		break;
+	case SIR:
+		retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.sir_para);
+		if (retval != ERROR_OK)
+			return retval;
+		break;
+	case PIO:
+	case PIOMAP:
+		LOG_ERROR("PIO and PIOMAP are not supported");
+		return ERROR_FAIL;
+	case RUNTEST:
+		/* RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time
+		 * SEC]] [ENDSTATE end_state] */
+		/* RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE
+		 * end_state] */
+		if (num_of_argu < 3 || num_of_argu > 11) {
+			LOG_ERROR("invalid parameter of %s", argus[0]);
 			return ERROR_FAIL;
-		case RUNTEST:
-			/* RUNTEST [run_state] run_count run_clk [min_time SEC [MAXIMUM max_time
-			 * SEC]] [ENDSTATE end_state] */
-			/* RUNTEST [run_state] min_time SEC [MAXIMUM max_time SEC] [ENDSTATE
-			 * end_state] */
-			if (num_of_argu < 3 || num_of_argu > 11) {
-				LOG_ERROR("invalid parameter of %s", argus[0]);
+		}
+		/* init */
+		run_count = 0;
+		min_time = 0;
+		i = 1;
+
+		/* run_state */
+		i_tmp = tap_state_by_name(argus[i]);
+		if (i_tmp != TAP_INVALID) {
+			if (svf_tap_state_is_stable(i_tmp)) {
+				svf_para.runtest_run_state = i_tmp;
+
+				/* When a run_state is specified, the new
+				 * run_state becomes the default end_state.
+				 */
+				svf_para.runtest_end_state = i_tmp;
+				LOG_DEBUG("\trun_state = %s", tap_state_name(i_tmp));
+				i++;
+			} else {
+				LOG_ERROR("%s: %s is not a stable state", argus[0], tap_state_name(i_tmp));
 				return ERROR_FAIL;
 			}
-			/* init */
-			run_count = 0;
-			min_time = 0;
-			i = 1;
-
-			/* run_state */
-			i_tmp = tap_state_by_name(argus[i]);
-			if (i_tmp != TAP_INVALID) {
-				if (svf_tap_state_is_stable(i_tmp)) {
-					svf_para.runtest_run_state = i_tmp;
-
-					/* When a run_state is specified, the new
-					 * run_state becomes the default end_state.
-					 */
-					svf_para.runtest_end_state = i_tmp;
-					LOG_DEBUG("\trun_state = %s", tap_state_name(i_tmp));
-					i++;
-				} else {
-					LOG_ERROR("%s: %s is not a stable state", argus[0], tap_state_name(i_tmp));
-					return ERROR_FAIL;
-				}
-			}
+		}
 
-			/* run_count run_clk */
-			if (((i + 2) <= num_of_argu) && strcmp(argus[i + 1], "SEC")) {
-				if (!strcmp(argus[i + 1], "TCK")) {
-					/* clock source is TCK */
-					run_count = atoi(argus[i]);
-					LOG_DEBUG("\trun_count@TCK = %d", run_count);
-				} else {
-					LOG_ERROR("%s not supported for clock", argus[i + 1]);
-					return ERROR_FAIL;
-				}
-				i += 2;
-			}
-			/* min_time SEC */
-			if (((i + 2) <= num_of_argu) && !strcmp(argus[i + 1], "SEC")) {
-				min_time = atof(argus[i]);
-				LOG_DEBUG("\tmin_time = %fs", min_time);
-				i += 2;
-			}
-			/* MAXIMUM max_time SEC */
-			if (((i + 3) <= num_of_argu) &&
-			!strcmp(argus[i], "MAXIMUM") && !strcmp(argus[i + 2], "SEC")) {
-				float max_time = 0;
-				max_time = atof(argus[i + 1]);
-				LOG_DEBUG("\tmax_time = %fs", max_time);
-				i += 3;
+		/* run_count run_clk */
+		if (((i + 2) <= num_of_argu) && strcmp(argus[i + 1], "SEC")) {
+			if (!strcmp(argus[i + 1], "TCK")) {
+				/* clock source is TCK */
+				run_count = atoi(argus[i]);
+				LOG_DEBUG("\trun_count@TCK = %d", run_count);
+			} else {
+				LOG_ERROR("%s not supported for clock", argus[i + 1]);
+				return ERROR_FAIL;
 			}
-			/* ENDSTATE end_state */
-			if (((i + 2) <= num_of_argu) && !strcmp(argus[i], "ENDSTATE")) {
-				i_tmp = tap_state_by_name(argus[i + 1]);
+			i += 2;
+		}
+		/* min_time SEC */
+		if (((i + 2) <= num_of_argu) && !strcmp(argus[i + 1], "SEC")) {
+			min_time = atof(argus[i]);
+			LOG_DEBUG("\tmin_time = %fs", min_time);
+			i += 2;
+		}
+		/* MAXIMUM max_time SEC */
+		if (((i + 3) <= num_of_argu) &&
+		!strcmp(argus[i], "MAXIMUM") && !strcmp(argus[i + 2], "SEC")) {
+			float max_time = 0;
+			max_time = atof(argus[i + 1]);
+			LOG_DEBUG("\tmax_time = %fs", max_time);
+			i += 3;
+		}
+		/* ENDSTATE end_state */
+		if (((i + 2) <= num_of_argu) && !strcmp(argus[i], "ENDSTATE")) {
+			i_tmp = tap_state_by_name(argus[i + 1]);
 
-				if (svf_tap_state_is_stable(i_tmp)) {
-					svf_para.runtest_end_state = i_tmp;
-					LOG_DEBUG("\tend_state = %s", tap_state_name(i_tmp));
-				} else {
-					LOG_ERROR("%s: %s is not a stable state", argus[0], tap_state_name(i_tmp));
-					return ERROR_FAIL;
-				}
-				i += 2;
+			if (svf_tap_state_is_stable(i_tmp)) {
+				svf_para.runtest_end_state = i_tmp;
+				LOG_DEBUG("\tend_state = %s", tap_state_name(i_tmp));
+			} else {
+				LOG_ERROR("%s: %s is not a stable state", argus[0], tap_state_name(i_tmp));
+				return ERROR_FAIL;
 			}
+			i += 2;
+		}
 
-			/* all parameter should be parsed */
-			if (i == num_of_argu) {
+		/* all parameter should be parsed */
+		if (i == num_of_argu) {
 #if 1
-				/* FIXME handle statemove failures */
-				uint32_t min_usec = 1000000 * min_time;
+			/* FIXME handle statemove failures */
+			uint32_t min_usec = 1000000 * min_time;
 
-				/* enter into run_state if necessary */
-				if (cmd_queue_cur_state != svf_para.runtest_run_state)
-					svf_add_statemove(svf_para.runtest_run_state);
+			/* enter into run_state if necessary */
+			if (cmd_queue_cur_state != svf_para.runtest_run_state)
+				svf_add_statemove(svf_para.runtest_run_state);
 
-				/* add clocks and/or min wait */
-				if (run_count > 0) {
-					if (!svf_nil)
-						jtag_add_clocks(run_count);
-				}
+			/* add clocks and/or min wait */
+			if (run_count > 0) {
+				if (!svf_nil)
+					jtag_add_clocks(run_count);
+			}
 
-				if (min_usec > 0) {
-					if (!svf_nil)
-						jtag_add_sleep(min_usec);
-				}
+			if (min_usec > 0) {
+				if (!svf_nil)
+					jtag_add_sleep(min_usec);
+			}
 
-				/* move to end_state if necessary */
-				if (svf_para.runtest_end_state != svf_para.runtest_run_state)
-					svf_add_statemove(svf_para.runtest_end_state);
+			/* move to end_state if necessary */
+			if (svf_para.runtest_end_state != svf_para.runtest_run_state)
+				svf_add_statemove(svf_para.runtest_end_state);
 
 #else
-				if (svf_para.runtest_run_state != TAP_IDLE) {
-					LOG_ERROR("cannot runtest in %s state",
-							tap_state_name(svf_para.runtest_run_state));
-					return ERROR_FAIL;
-				}
-
-				if (!svf_nil)
-					jtag_add_runtest(run_count, svf_para.runtest_end_state);
-#endif
-			} else {
-				LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed",
-						i,
-						num_of_argu);
+			if (svf_para.runtest_run_state != TAP_IDLE) {
+				LOG_ERROR("cannot runtest in %s state",
+						tap_state_name(svf_para.runtest_run_state));
 				return ERROR_FAIL;
 			}
-			break;
-		case STATE:
-			/* STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state */
-			if (num_of_argu < 2) {
-				LOG_ERROR("invalid parameter of %s", argus[0]);
+
+			if (!svf_nil)
+				jtag_add_runtest(run_count, svf_para.runtest_end_state);
+#endif
+		} else {
+			LOG_ERROR("fail to parse parameter of RUNTEST, %d out of %d is parsed",
+					i,
+					num_of_argu);
+			return ERROR_FAIL;
+		}
+		break;
+	case STATE:
+		/* STATE [pathstate1 [pathstate2 ...[pathstaten]]] stable_state */
+		if (num_of_argu < 2) {
+			LOG_ERROR("invalid parameter of %s", argus[0]);
+			return ERROR_FAIL;
+		}
+		if (num_of_argu > 2) {
+			/* STATE pathstate1 ... stable_state */
+			path = malloc((num_of_argu - 1) * sizeof(enum tap_state));
+			if (!path) {
+				LOG_ERROR("not enough memory");
 				return ERROR_FAIL;
 			}
-			if (num_of_argu > 2) {
-				/* STATE pathstate1 ... stable_state */
-				path = malloc((num_of_argu - 1) * sizeof(enum tap_state));
-				if (!path) {
-					LOG_ERROR("not enough memory");
+			num_of_argu--;	/* num of path */
+			i_tmp = 1;		/* path is from parameter 1 */
+			for (i = 0; i < num_of_argu; i++, i_tmp++) {
+				path[i] = tap_state_by_name(argus[i_tmp]);
+				if (path[i] == TAP_INVALID) {
+					LOG_ERROR("%s: %s is not a valid state", argus[0], argus[i_tmp]);
+					free(path);
 					return ERROR_FAIL;
 				}
-				num_of_argu--;	/* num of path */
-				i_tmp = 1;		/* path is from parameter 1 */
-				for (i = 0; i < num_of_argu; i++, i_tmp++) {
-					path[i] = tap_state_by_name(argus[i_tmp]);
-					if (path[i] == TAP_INVALID) {
-						LOG_ERROR("%s: %s is not a valid state", argus[0], argus[i_tmp]);
-						free(path);
-						return ERROR_FAIL;
-					}
-					/* OpenOCD refuses paths containing TAP_RESET */
-					if (path[i] == TAP_RESET) {
-						/* FIXME last state MUST be stable! */
-						if (i > 0) {
-							if (!svf_nil)
-								jtag_add_pathmove(i, path);
-						}
-						if (!svf_nil)
-							jtag_add_tlr();
-						num_of_argu -= i + 1;
-						i = -1;
-					}
-				}
-				if (num_of_argu > 0) {
-					/* execute last path if necessary */
-					if (svf_tap_state_is_stable(path[num_of_argu - 1])) {
-						/* last state MUST be stable state */
+				/* OpenOCD refuses paths containing TAP_RESET */
+				if (path[i] == TAP_RESET) {
+					/* FIXME last state MUST be stable! */
+					if (i > 0) {
 						if (!svf_nil)
-							jtag_add_pathmove(num_of_argu, path);
-						LOG_DEBUG("\tmove to %s by path_move",
-								tap_state_name(path[num_of_argu - 1]));
-					} else {
-						LOG_ERROR("%s: %s is not a stable state",
-								argus[0],
-								tap_state_name(path[num_of_argu - 1]));
-						free(path);
-						return ERROR_FAIL;
+							jtag_add_pathmove(i, path);
 					}
+					if (!svf_nil)
+						jtag_add_tlr();
+					num_of_argu -= i + 1;
+					i = -1;
 				}
-
-				free(path);
-				path = NULL;
-			} else {
-				/* STATE stable_state */
-				state = tap_state_by_name(argus[1]);
-				if (svf_tap_state_is_stable(state)) {
-					LOG_DEBUG("\tmove to %s by svf_add_statemove",
-							tap_state_name(state));
-					/* FIXME handle statemove failures */
-					svf_add_statemove(state);
+			}
+			if (num_of_argu > 0) {
+				/* execute last path if necessary */
+				if (svf_tap_state_is_stable(path[num_of_argu - 1])) {
+					/* last state MUST be stable state */
+					if (!svf_nil)
+						jtag_add_pathmove(num_of_argu, path);
+					LOG_DEBUG("\tmove to %s by path_move",
+							tap_state_name(path[num_of_argu - 1]));
 				} else {
 					LOG_ERROR("%s: %s is not a stable state",
-							argus[0], tap_state_name(state));
+							argus[0],
+							tap_state_name(path[num_of_argu - 1]));
+					free(path);
 					return ERROR_FAIL;
 				}
 			}
-			break;
-		case TRST:
-			/* TRST trst_mode */
-			if (num_of_argu != 2) {
-				LOG_ERROR("invalid parameter of %s", argus[0]);
+
+			free(path);
+			path = NULL;
+		} else {
+			/* STATE stable_state */
+			state = tap_state_by_name(argus[1]);
+			if (svf_tap_state_is_stable(state)) {
+				LOG_DEBUG("\tmove to %s by svf_add_statemove",
+						tap_state_name(state));
+				/* FIXME handle statemove failures */
+				svf_add_statemove(state);
+			} else {
+				LOG_ERROR("%s: %s is not a stable state",
+						argus[0], tap_state_name(state));
 				return ERROR_FAIL;
 			}
-			if (svf_para.trst_mode != TRST_ABSENT) {
-				if (svf_execute_tap() != ERROR_OK)
-					return ERROR_FAIL;
-				i_tmp = svf_find_string_in_array(argus[1],
-						(char **)svf_trst_mode_name,
-						ARRAY_SIZE(svf_trst_mode_name));
-				switch (i_tmp) {
-				case TRST_ON:
-					if (!svf_nil)
-						jtag_add_reset(1, 0);
-					break;
-				case TRST_Z:
-				case TRST_OFF:
-					if (!svf_nil)
-						jtag_add_reset(0, 0);
-					break;
-				case TRST_ABSENT:
-					break;
-				default:
-					LOG_ERROR("unknown TRST mode: %s", argus[1]);
-					return ERROR_FAIL;
-				}
-				svf_para.trst_mode = i_tmp;
-				LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name[svf_para.trst_mode]);
-			} else {
-				LOG_ERROR("can not accept TRST command if trst_mode is ABSENT");
+		}
+		break;
+	case TRST:
+		/* TRST trst_mode */
+		if (num_of_argu != 2) {
+			LOG_ERROR("invalid parameter of %s", argus[0]);
+			return ERROR_FAIL;
+		}
+		if (svf_para.trst_mode != TRST_ABSENT) {
+			if (svf_execute_tap() != ERROR_OK)
+				return ERROR_FAIL;
+			i_tmp = svf_find_string_in_array(argus[1],
+					(char **)svf_trst_mode_name,
+					ARRAY_SIZE(svf_trst_mode_name));
+			switch (i_tmp) {
+			case TRST_ON:
+				if (!svf_nil)
+					jtag_add_reset(1, 0);
+				break;
+			case TRST_Z:
+			case TRST_OFF:
+				if (!svf_nil)
+					jtag_add_reset(0, 0);
+				break;
+			case TRST_ABSENT:
+				break;
+			default:
+				LOG_ERROR("unknown TRST mode: %s", argus[1]);
 				return ERROR_FAIL;
 			}
-			break;
-		default:
-			LOG_ERROR("invalid svf command: %s", argus[0]);
+			svf_para.trst_mode = i_tmp;
+			LOG_DEBUG("\ttrst_mode = %s", svf_trst_mode_name[svf_para.trst_mode]);
+		} else {
+			LOG_ERROR("can not accept TRST command if trst_mode is ABSENT");
 			return ERROR_FAIL;
+		}
+		break;
+	default:
+		LOG_ERROR("invalid svf command: %s", argus[0]);
+		return ERROR_FAIL;
 	}
 
 	if (!svf_quiet) {

-- 

[PATCH]: b194adaad1 flash: nor: align switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9034

-- gerrit

commit b194adaad1b020119852659ff2dd3526e57d3235
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jun 28 11:21:26 2025 +0200

    flash: nor: align switch and case statements
    
    The coding style requires the 'case' to be at the same indentation
    level of its 'switch' statement.
    
    Align the code accordingly.
    
    No changes are reported by
            git log -p -w --ignore-blank-lines --patience
    
    Change-Id: I6be44efd5189b671caabcf6753bb82ef44521440
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/flash/nor/ambiqmicro.c b/src/flash/nor/ambiqmicro.c
index 67cc6b68a7..cb9fa5ed77 100644
--- a/src/flash/nor/ambiqmicro.c
+++ b/src/flash/nor/ambiqmicro.c
@@ -190,37 +190,36 @@ static int ambiqmicro_read_part_info(struct flash_bank *bank)
 	ambiqmicro_info->target_class = (part_num & 0xFF000000) >> 24;
 
 	switch (ambiqmicro_info->target_class) {
-		case 1:		/* 1 - Apollo */
-		case 5:		/* 5 - Apollo Bootloader */
-			bank->base = bank->bank_number * 0x40000;
-			ambiqmicro_info->pagesize = 2048;
-			ambiqmicro_info->flshsiz =
+	case 1:		/* 1 - Apollo */
+	case 5:		/* 5 - Apollo Bootloader */
+		bank->base = bank->bank_number * 0x40000;
+		ambiqmicro_info->pagesize = 2048;
+		ambiqmicro_info->flshsiz =
 			apollo_flash_size[(part_num & 0x00F00000) >> 20];
-			ambiqmicro_info->sramsiz =
+		ambiqmicro_info->sramsiz =
 			apollo_sram_size[(part_num & 0x000F0000) >> 16];
-			ambiqmicro_info->num_pages = ambiqmicro_info->flshsiz /
-			ambiqmicro_info->pagesize;
-			if (ambiqmicro_info->num_pages > 128) {
-				ambiqmicro_info->num_pages = 128;
-				ambiqmicro_info->flshsiz = 1024 * 256;
-			}
-			break;
+		ambiqmicro_info->num_pages = ambiqmicro_info->flshsiz /
+		ambiqmicro_info->pagesize;
+		if (ambiqmicro_info->num_pages > 128) {
+			ambiqmicro_info->num_pages = 128;
+			ambiqmicro_info->flshsiz = 1024 * 256;
+		}
+		break;
 
-		default:
-			LOG_INFO("Unknown Class. Using Apollo-64 as default.");
+	default:
+		LOG_INFO("Unknown Class. Using Apollo-64 as default.");
 
-			bank->base = bank->bank_number * 0x40000;
-			ambiqmicro_info->pagesize = 2048;
-			ambiqmicro_info->flshsiz = apollo_flash_size[1];
-			ambiqmicro_info->sramsiz = apollo_sram_size[0];
-			ambiqmicro_info->num_pages = ambiqmicro_info->flshsiz /
+		bank->base = bank->bank_number * 0x40000;
+		ambiqmicro_info->pagesize = 2048;
+		ambiqmicro_info->flshsiz = apollo_flash_size[1];
+		ambiqmicro_info->sramsiz = apollo_sram_size[0];
+		ambiqmicro_info->num_pages = ambiqmicro_info->flshsiz /
 			ambiqmicro_info->pagesize;
-			if (ambiqmicro_info->num_pages > 128) {
-				ambiqmicro_info->num_pages = 128;
-				ambiqmicro_info->flshsiz = 1024 * 256;
-			}
-			break;
-
+		if (ambiqmicro_info->num_pages > 128) {
+			ambiqmicro_info->num_pages = 128;
+			ambiqmicro_info->flshsiz = 1024 * 256;
+		}
+		break;
 	}
 
 	if (ambiqmicro_info->target_class < ARRAY_SIZE(ambiqmicro_parts))
diff --git a/src/flash/nor/at91sam3.c b/src/flash/nor/at91sam3.c
index 4042d32dec..5f551681d5 100644
--- a/src/flash/nor/at91sam3.c
+++ b/src/flash/nor/at91sam3.c
@@ -2040,40 +2040,39 @@ do_retry:
 
 	/* Check command & argument */
 	switch (command) {
-
-		case AT91C_EFC_FCMD_WP:
-		case AT91C_EFC_FCMD_WPL:
-		case AT91C_EFC_FCMD_EWP:
-		case AT91C_EFC_FCMD_EWPL:
-		/* case AT91C_EFC_FCMD_EPL: */
-		/* case AT91C_EFC_FCMD_EPA: */
-		case AT91C_EFC_FCMD_SLB:
-		case AT91C_EFC_FCMD_CLB:
-			n = (private->size_bytes / private->page_size);
-			if (argument >= n)
-				LOG_ERROR("*BUG*: Embedded flash has only %" PRIu32 " pages", n);
-			break;
-
-		case AT91C_EFC_FCMD_SFB:
-		case AT91C_EFC_FCMD_CFB:
-			if (argument >= private->chip->details.n_gpnvms) {
-				LOG_ERROR("*BUG*: Embedded flash has only %d GPNVMs",
-						private->chip->details.n_gpnvms);
-			}
-			break;
-
-		case AT91C_EFC_FCMD_GETD:
-		case AT91C_EFC_FCMD_EA:
-		case AT91C_EFC_FCMD_GLB:
-		case AT91C_EFC_FCMD_GFB:
-		case AT91C_EFC_FCMD_STUI:
-		case AT91C_EFC_FCMD_SPUI:
-			if (argument != 0)
-				LOG_ERROR("Argument is meaningless for cmd: %d", command);
-			break;
-		default:
-			LOG_ERROR("Unknown command %d", command);
-			break;
+	case AT91C_EFC_FCMD_WP:
+	case AT91C_EFC_FCMD_WPL:
+	case AT91C_EFC_FCMD_EWP:
+	case AT91C_EFC_FCMD_EWPL:
+	/* case AT91C_EFC_FCMD_EPL: */
+	/* case AT91C_EFC_FCMD_EPA: */
+	case AT91C_EFC_FCMD_SLB:
+	case AT91C_EFC_FCMD_CLB:
+		n = (private->size_bytes / private->page_size);
+		if (argument >= n)
+			LOG_ERROR("*BUG*: Embedded flash has only %" PRIu32 " pages", n);
+		break;
+
+	case AT91C_EFC_FCMD_SFB:
+	case AT91C_EFC_FCMD_CFB:
+		if (argument >= private->chip->details.n_gpnvms) {
+			LOG_ERROR("*BUG*: Embedded flash has only %d GPNVMs",
+					private->chip->details.n_gpnvms);
+		}
+		break;
+
+	case AT91C_EFC_FCMD_GETD:
+	case AT91C_EFC_FCMD_EA:
+	case AT91C_EFC_FCMD_GLB:
+	case AT91C_EFC_FCMD_GFB:
+	case AT91C_EFC_FCMD_STUI:
+	case AT91C_EFC_FCMD_SPUI:
+		if (argument != 0)
+			LOG_ERROR("Argument is meaningless for cmd: %d", command);
+		break;
+	default:
+		LOG_ERROR("Unknown command %d", command);
+		break;
 	}
 
 	if (command == AT91C_EFC_FCMD_SPUI) {
@@ -2571,18 +2570,18 @@ static void sam3_explain_ckgr_mor(struct sam3_chip *chip)
 	chip->cfg.rc_freq = 0;
 	if (rcen) {
 		switch (v) {
-			case 0:
-				chip->cfg.rc_freq = 4 * 1000 * 1000;
-				break;
-			case 1:
-				chip->cfg.rc_freq = 8 * 1000 * 1000;
-				break;
-			case 2:
-				chip->cfg.rc_freq = 12 * 1000 * 1000;
-				break;
-			default:
-				chip->cfg.rc_freq = 0;
-				break;
+		case 0:
+			chip->cfg.rc_freq = 4 * 1000 * 1000;
+			break;
+		case 1:
+			chip->cfg.rc_freq = 8 * 1000 * 1000;
+			break;
+		case 2:
+			chip->cfg.rc_freq = 12 * 1000 * 1000;
+			break;
+		default:
+			chip->cfg.rc_freq = 0;
+			break;
 		}
 	}
 
@@ -2683,30 +2682,30 @@ static void sam3_explain_mckr(struct sam3_chip *chip)
 
 	css = sam3_reg_fieldname(chip, "CSS", chip->cfg.PMC_MCKR, 0, 2);
 	switch (css & 3) {
-		case 0:
-			fin = chip->cfg.slow_freq;
-			cp = "slowclk";
-			break;
-		case 1:
-			fin = chip->cfg.mainosc_freq;
-			cp  = "mainosc";
-			break;
-		case 2:
-			fin = chip->cfg.plla_freq;
-			cp  = "plla";
-			break;
-		case 3:
-			if (chip->cfg.CKGR_UCKR & (1 << 16)) {
-				fin = 480 * 1000 * 1000;
-				cp = "upll";
-			} else {
-				fin = 0;
-				cp  = "upll (*ERROR* UPLL is disabled)";
-			}
-			break;
-		default:
-			assert(0);
-			break;
+	case 0:
+		fin = chip->cfg.slow_freq;
+		cp = "slowclk";
+		break;
+	case 1:
+		fin = chip->cfg.mainosc_freq;
+		cp  = "mainosc";
+		break;
+	case 2:
+		fin = chip->cfg.plla_freq;
+		cp  = "plla";
+		break;
+	case 3:
+		if (chip->cfg.CKGR_UCKR & (1 << 16)) {
+			fin = 480 * 1000 * 1000;
+			cp = "upll";
+		} else {
+			fin = 0;
+			cp  = "upll (*ERROR* UPLL is disabled)";
+		}
+		break;
+	default:
+		assert(0);
+		break;
 	}
 
 	LOG_USER("%s (%3.03f Mhz)",
@@ -2714,41 +2713,41 @@ static void sam3_explain_mckr(struct sam3_chip *chip)
 		_tomhz(fin));
 	pres = sam3_reg_fieldname(chip, "PRES", chip->cfg.PMC_MCKR, 4, 3);
 	switch (pres & 0x07) {
-		case 0:
-			pdiv = 1;
-			cp = "selected clock";
-			break;
-		case 1:
-			pdiv = 2;
-			cp = "clock/2";
-			break;
-		case 2:
-			pdiv = 4;
-			cp = "clock/4";
-			break;
-		case 3:
-			pdiv = 8;
-			cp = "clock/8";
-			break;
-		case 4:
-			pdiv = 16;
-			cp = "clock/16";
-			break;
-		case 5:
-			pdiv = 32;
-			cp = "clock/32";
-			break;
-		case 6:
-			pdiv = 64;
-			cp = "clock/64";
-			break;
-		case 7:
-			pdiv = 6;
-			cp = "clock/6";
-			break;
-		default:
-			assert(0);
-			break;
+	case 0:
+		pdiv = 1;
+		cp = "selected clock";
+		break;
+	case 1:
+		pdiv = 2;
+		cp = "clock/2";
+		break;
+	case 2:
+		pdiv = 4;
+		cp = "clock/4";
+		break;
+	case 3:
+		pdiv = 8;
+		cp = "clock/8";
+		break;
+	case 4:
+		pdiv = 16;
+		cp = "clock/16";
+		break;
+	case 5:
+		pdiv = 32;
+		cp = "clock/32";
+		break;
+	case 6:
+		pdiv = 64;
+		cp = "clock/64";
+		break;
+	case 7:
+		pdiv = 6;
+		cp = "clock/6";
+		break;
+	default:
+		assert(0);
+		break;
 	}
 	LOG_USER("(%s)", cp);
 	fin = fin / pdiv;
@@ -3011,39 +3010,39 @@ FLASH_BANK_COMMAND_HANDLER(sam3_flash_bank_command)
 	}
 
 	switch (bank->base) {
-		/* at91sam3s and at91sam3n series only has bank 0*/
-		/* at91sam3u and at91sam3ax series has the same address for bank 0*/
-		case FLASH_BANK_BASE_S:
-		case FLASH_BANK0_BASE_U:
-			bank->driver_priv = &chip->details.bank[0];
-			bank->bank_number = 0;
-			chip->details.bank[0].chip = chip;
-			chip->details.bank[0].bank = bank;
-			break;
-
-		/* Bank 1 of at91sam3u or at91sam3ax series */
-		case FLASH_BANK1_BASE_U:
-		case FLASH_BANK1_BASE_256K_AX:
-		case FLASH_BANK1_BASE_512K_AX:
-			bank->driver_priv = &chip->details.bank[1];
-			bank->bank_number = 1;
-			chip->details.bank[1].chip = chip;
-			chip->details.bank[1].bank = bank;
-			break;
-
-		default:
-			LOG_ERROR("Address " TARGET_ADDR_FMT " invalid bank address (try 0x%08x or 0x%08x "
-				"[at91sam3u series] or 0x%08x [at91sam3s series] or "
-				"0x%08x [at91sam3n series] or 0x%08x or 0x%08x or 0x%08x[at91sam3ax series] )",
-				bank->base,
-				FLASH_BANK0_BASE_U,
-				FLASH_BANK1_BASE_U,
-				FLASH_BANK_BASE_S,
-				FLASH_BANK_BASE_N,
-				FLASH_BANK0_BASE_AX,
-				FLASH_BANK1_BASE_256K_AX,
-				FLASH_BANK1_BASE_512K_AX);
-			return ERROR_FAIL;
+	/* at91sam3s and at91sam3n series only has bank 0*/
+	/* at91sam3u and at91sam3ax series has the same address for bank 0*/
+	case FLASH_BANK_BASE_S:
+	case FLASH_BANK0_BASE_U:
+		bank->driver_priv = &chip->details.bank[0];
+		bank->bank_number = 0;
+		chip->details.bank[0].chip = chip;
+		chip->details.bank[0].bank = bank;
+		break;
+
+	/* Bank 1 of at91sam3u or at91sam3ax series */
+	case FLASH_BANK1_BASE_U:
+	case FLASH_BANK1_BASE_256K_AX:
+	case FLASH_BANK1_BASE_512K_AX:
+		bank->driver_priv = &chip->details.bank[1];
+		bank->bank_number = 1;
+		chip->details.bank[1].chip = chip;
+		chip->details.bank[1].bank = bank;
+		break;
+
+	default:
+		LOG_ERROR("Address " TARGET_ADDR_FMT " invalid bank address (try 0x%08x or 0x%08x "
+		"[at91sam3u series] or 0x%08x [at91sam3s series] or "
+		"0x%08x [at91sam3n series] or 0x%08x or 0x%08x or 0x%08x[at91sam3ax series] )",
+		bank->base,
+		FLASH_BANK0_BASE_U,
+		FLASH_BANK1_BASE_U,
+		FLASH_BANK_BASE_S,
+		FLASH_BANK_BASE_N,
+		FLASH_BANK0_BASE_AX,
+		FLASH_BANK1_BASE_256K_AX,
+		FLASH_BANK1_BASE_512K_AX);
+		return ERROR_FAIL;
 	}
 
 	/* we initialize after probing. */
@@ -3574,22 +3573,22 @@ COMMAND_HANDLER(sam3_handle_gpnvm_command)
 	}
 
 	switch (CMD_ARGC) {
-		case 0:
-			goto showall;
-		case 1:
+	case 0:
+		goto showall;
+	case 1:
+		who = -1;
+		break;
+	case 2:
+		if ((strcmp(CMD_ARGV[0], "show") == 0) && (strcmp(CMD_ARGV[1], "all") == 0)) {
 			who = -1;
-			break;
-		case 2:
-			if ((strcmp(CMD_ARGV[0], "show") == 0) && (strcmp(CMD_ARGV[1], "all") == 0)) {
-				who = -1;
-			} else {
-				uint32_t v32;
-				COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], v32);
-				who = v32;
-			}
-			break;
-		default:
-			return ERROR_COMMAND_SYNTAX_ERROR;
+		} else {
+			uint32_t v32;
+			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], v32);
+			who = v32;
+		}
+		break;
+	default:
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
 	if (strcmp("show", CMD_ARGV[0]) == 0) {
@@ -3641,26 +3640,26 @@ COMMAND_HANDLER(sam3_handle_slowclk_command)
 		return ERROR_OK;
 
 	switch (CMD_ARGC) {
-		case 0:
-			/* show */
-			break;
-		case 1:
-		{
-			/* set */
-			uint32_t v;
-			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], v);
-			if (v > 200000) {
-				/* absurd slow clock of 200Khz? */
-				command_print(CMD, "Absurd/illegal slow clock freq: %d\n", (int)(v));
-				return ERROR_COMMAND_SYNTAX_ERROR;
-			}
-			chip->cfg.slow_freq = v;
-			break;
-		}
-		default:
-			/* error */
-			command_print(CMD, "Too many parameters");
+	case 0:
+		/* show */
+		break;
+	case 1:
+	{
+		/* set */
+		uint32_t v;
+		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], v);
+		if (v > 200000) {
+			/* absurd slow clock of 200Khz? */
+			command_print(CMD, "Absurd/illegal slow clock freq: %d\n", (int)(v));
 			return ERROR_COMMAND_SYNTAX_ERROR;
+		}
+		chip->cfg.slow_freq = v;
+		break;
+	}
+	default:
+		/* error */
+		command_print(CMD, "Too many parameters");
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 	command_print(CMD, "Slowclk freq: %d.%03dkhz",
 		(int)(chip->cfg.slow_freq / 1000),
diff --git a/src/flash/nor/at91sam4.c b/src/flash/nor/at91sam4.c
index 08f1955778..dd3a1ca3f0 100644
--- a/src/flash/nor/at91sam4.c
+++ b/src/flash/nor/at91sam4.c
@@ -1490,40 +1490,39 @@ do_retry:
 
 	/* Check command & argument */
 	switch (command) {
-
-		case AT91C_EFC_FCMD_WP:
-		case AT91C_EFC_FCMD_WPL:
-		case AT91C_EFC_FCMD_EWP:
-		case AT91C_EFC_FCMD_EWPL:
-		/* case AT91C_EFC_FCMD_EPL: */
-		case AT91C_EFC_FCMD_EPA:
-		case AT91C_EFC_FCMD_SLB:
-		case AT91C_EFC_FCMD_CLB:
-			n = (private->size_bytes / private->page_size);
-			if (argument >= n)
-				LOG_ERROR("*BUG*: Embedded flash has only %" PRIu32 " pages", n);
-			break;
-
-		case AT91C_EFC_FCMD_SFB:
-		case AT91C_EFC_FCMD_CFB:
-			if (argument >= private->chip->details.n_gpnvms) {
-				LOG_ERROR("*BUG*: Embedded flash has only %d GPNVMs",
-						private->chip->details.n_gpnvms);
-			}
-			break;
-
-		case AT91C_EFC_FCMD_GETD:
-		case AT91C_EFC_FCMD_EA:
-		case AT91C_EFC_FCMD_GLB:
-		case AT91C_EFC_FCMD_GFB:
-		case AT91C_EFC_FCMD_STUI:
-		case AT91C_EFC_FCMD_SPUI:
-			if (argument != 0)
-				LOG_ERROR("Argument is meaningless for cmd: %d", command);
-			break;
-		default:
-			LOG_ERROR("Unknown command %d", command);
-			break;
+	case AT91C_EFC_FCMD_WP:
+	case AT91C_EFC_FCMD_WPL:
+	case AT91C_EFC_FCMD_EWP:
+	case AT91C_EFC_FCMD_EWPL:
+	/* case AT91C_EFC_FCMD_EPL: */
+	case AT91C_EFC_FCMD_EPA:
+	case AT91C_EFC_FCMD_SLB:
+	case AT91C_EFC_FCMD_CLB:
+		n = (private->size_bytes / private->page_size);
+		if (argument >= n)
+			LOG_ERROR("*BUG*: Embedded flash has only %" PRIu32 " pages", n);
+		break;
+
+	case AT91C_EFC_FCMD_SFB:
+	case AT91C_EFC_FCMD_CFB:
+		if (argument >= private->chip->details.n_gpnvms) {
+			LOG_ERROR("*BUG*: Embedded flash has only %d GPNVMs",
+					private->chip->details.n_gpnvms);
+		}
+		break;
+
+	case AT91C_EFC_FCMD_GETD:
+	case AT91C_EFC_FCMD_EA:
+	case AT91C_EFC_FCMD_GLB:
+	case AT91C_EFC_FCMD_GFB:
+	case AT91C_EFC_FCMD_STUI:
+	case AT91C_EFC_FCMD_SPUI:
+		if (argument != 0)
+			LOG_ERROR("Argument is meaningless for cmd: %d", command);
+		break;
+	default:
+		LOG_ERROR("Unknown command %d", command);
+		break;
 	}
 
 	if (command == AT91C_EFC_FCMD_SPUI) {
@@ -1678,21 +1677,21 @@ static int flashd_erase_pages(struct sam4_bank_private *private,
 	LOG_DEBUG("Here");
 	uint8_t erase_pages;
 	switch (num_pages)	{
-		case 4:
-			erase_pages = 0x00;
-			break;
-		case 8:
-			erase_pages = 0x01;
-			break;
-		case 16:
-			erase_pages = 0x02;
-			break;
-		case 32:
-			erase_pages = 0x03;
-			break;
-		default:
-			erase_pages = 0x00;
-			break;
+	case 4:
+		erase_pages = 0x00;
+		break;
+	case 8:
+		erase_pages = 0x01;
+		break;
+	case 16:
+		erase_pages = 0x02;
+		break;
+	case 32:
+		erase_pages = 0x03;
+		break;
+	default:
+		erase_pages = 0x00;
+		break;
 	}
 
 	/* AT91C_EFC_FCMD_EPA
@@ -2080,18 +2079,18 @@ static void sam4_explain_ckgr_mor(struct sam4_chip *chip)
 	chip->cfg.rc_freq = 0;
 	if (rcen) {
 		switch (v) {
-			case 0:
-				chip->cfg.rc_freq = 4 * 1000 * 1000;
-				break;
-			case 1:
-				chip->cfg.rc_freq = 8 * 1000 * 1000;
-				break;
-			case 2:
-				chip->cfg.rc_freq = 12 * 1000 * 1000;
-				break;
-			default:
-				chip->cfg.rc_freq = 0;
-				break;
+		case 0:
+			chip->cfg.rc_freq = 4 * 1000 * 1000;
+			break;
+		case 1:
+			chip->cfg.rc_freq = 8 * 1000 * 1000;
+			break;
+		case 2:
+			chip->cfg.rc_freq = 12 * 1000 * 1000;
+			break;
+		default:
+			chip->cfg.rc_freq = 0;
+			break;
 		}
 	}
 
@@ -2192,30 +2191,30 @@ static void sam4_explain_mckr(struct sam4_chip *chip)
 
 	css = sam4_reg_fieldname(chip, "CSS", chip->cfg.PMC_MCKR, 0, 2);
 	switch (css & 3) {
-		case 0:
-			fin = chip->cfg.slow_freq;
-			cp = "slowclk";
-			break;
-		case 1:
-			fin = chip->cfg.mainosc_freq;
-			cp  = "mainosc";
-			break;
-		case 2:
-			fin = chip->cfg.plla_freq;
-			cp  = "plla";
-			break;
-		case 3:
-			if (chip->cfg.CKGR_UCKR & (1 << 16)) {
-				fin = 480 * 1000 * 1000;
-				cp = "upll";
-			} else {
-				fin = 0;
-				cp  = "upll (*ERROR* UPLL is disabled)";
-			}
-			break;
-		default:
-			assert(0);
-			break;
+	case 0:
+		fin = chip->cfg.slow_freq;
+		cp = "slowclk";
+		break;
+	case 1:
+		fin = chip->cfg.mainosc_freq;
+		cp  = "mainosc";
+		break;
+	case 2:
+		fin = chip->cfg.plla_freq;
+		cp  = "plla";
+		break;
+	case 3:
+		if (chip->cfg.CKGR_UCKR & (1 << 16)) {
+			fin = 480 * 1000 * 1000;
+			cp = "upll";
+		} else {
+			fin = 0;
+			cp  = "upll (*ERROR* UPLL is disabled)";
+		}
+		break;
+	default:
+		assert(0);
+		break;
 	}
 
 	LOG_USER("%s (%3.03f Mhz)",
@@ -2223,41 +2222,41 @@ static void sam4_explain_mckr(struct sam4_chip *chip)
 		_tomhz(fin));
 	pres = sam4_reg_fieldname(chip, "PRES", chip->cfg.PMC_MCKR, 4, 3);
 	switch (pres & 0x07) {
-		case 0:
-			pdiv = 1;
-			cp = "selected clock";
-			break;
-		case 1:
-			pdiv = 2;
-			cp = "clock/2";
-			break;
-		case 2:
-			pdiv = 4;
-			cp = "clock/4";
-			break;
-		case 3:
-			pdiv = 8;
-			cp = "clock/8";
-			break;
-		case 4:
-			pdiv = 16;
-			cp = "clock/16";
-			break;
-		case 5:
-			pdiv = 32;
-			cp = "clock/32";
-			break;
-		case 6:
-			pdiv = 64;
-			cp = "clock/64";
-			break;
-		case 7:
-			pdiv = 6;
-			cp = "clock/6";
-			break;
-		default:
-			assert(0);
-			break;
+	case 0:
+		pdiv = 1;
+		cp = "selected clock";
+		break;
+	case 1:
+		pdiv = 2;
+		cp = "clock/2";
+		break;
+	case 2:
+		pdiv = 4;
+		cp = "clock/4";
+		break;
+	case 3:
+		pdiv = 8;
+		cp = "clock/8";
+		break;
+	case 4:
+		pdiv = 16;
+		cp = "clock/16";
+		break;
+	case 5:
+		pdiv = 32;
+		cp = "clock/32";
+		break;
+	case 6:
+		pdiv = 64;
+		cp = "clock/64";
+		break;
+	case 7:
+		pdiv = 6;
+		cp = "clock/6";
+		break;
+	default:
+		assert(0);
+		break;
 	}
 	LOG_USER("(%s)", cp);
 	fin = fin / pdiv;
@@ -2504,32 +2503,32 @@ FLASH_BANK_COMMAND_HANDLER(sam4_flash_bank_command)
 	}
 
 	switch (bank->base) {
-		/* at91sam4s series only has bank 0*/
-		/* at91sam4sd series has the same address for bank 0 (FLASH_BANK0_BASE_SD)*/
-		case FLASH_BANK_BASE_S:
-		case FLASH_BANK_BASE_C:
-			bank->driver_priv = &chip->details.bank[0];
-			bank->bank_number = 0;
-			chip->details.bank[0].chip = chip;
-			chip->details.bank[0].bank = bank;
-			break;
-
-		/* Bank 1 of at91sam4sd/at91sam4c32 series */
-		case FLASH_BANK1_BASE_1024K_SD:
-		case FLASH_BANK1_BASE_2048K_SD:
-		case FLASH_BANK1_BASE_C32:
-			bank->driver_priv = &chip->details.bank[1];
-			bank->bank_number = 1;
-			chip->details.bank[1].chip = chip;
-			chip->details.bank[1].bank = bank;
-			break;
-
-		default:
-			LOG_ERROR("Address " TARGET_ADDR_FMT " invalid bank address (try 0x%08x"
-				"[at91sam4s series] )",
-				bank->base,
-				FLASH_BANK_BASE_S);
-			return ERROR_FAIL;
+	/* at91sam4s series only has bank 0*/
+	/* at91sam4sd series has the same address for bank 0 (FLASH_BANK0_BASE_SD)*/
+	case FLASH_BANK_BASE_S:
+	case FLASH_BANK_BASE_C:
+		bank->driver_priv = &chip->details.bank[0];
+		bank->bank_number = 0;
+		chip->details.bank[0].chip = chip;
+		chip->details.bank[0].bank = bank;
+		break;
+
+	/* Bank 1 of at91sam4sd/at91sam4c32 series */
+	case FLASH_BANK1_BASE_1024K_SD:
+	case FLASH_BANK1_BASE_2048K_SD:
+	case FLASH_BANK1_BASE_C32:
+		bank->driver_priv = &chip->details.bank[1];
+		bank->bank_number = 1;
+		chip->details.bank[1].chip = chip;
+		chip->details.bank[1].bank = bank;
+		break;
+
+	default:
+		LOG_ERROR("Address " TARGET_ADDR_FMT " invalid bank address (try 0x%08x"
+			"[at91sam4s series] )",
+			bank->base,
+			FLASH_BANK_BASE_S);
+		return ERROR_FAIL;
 	}
 
 	/* we initialize after probing. */
@@ -3122,22 +3121,22 @@ COMMAND_HANDLER(sam4_handle_gpnvm_command)
 	}
 
 	switch (CMD_ARGC) {
-		case 0:
-			goto showall;
-		case 1:
+	case 0:
+		goto showall;
+	case 1:
+		who = -1;
+		break;
+	case 2:
+		if ((strcmp(CMD_ARGV[0], "show") == 0) && (strcmp(CMD_ARGV[1], "all") == 0)) {
 			who = -1;
-			break;
-		case 2:
-			if ((strcmp(CMD_ARGV[0], "show") == 0) && (strcmp(CMD_ARGV[1], "all") == 0)) {
-				who = -1;
-			} else {
-				uint32_t v32;
-				COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], v32);
-				who = v32;
-			}
-			break;
-		default:
-			return ERROR_COMMAND_SYNTAX_ERROR;
+		} else {
+			uint32_t v32;
+			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], v32);
+			who = v32;
+		}
+		break;
+	default:
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
 	if (strcmp("show", CMD_ARGV[0]) == 0) {
@@ -3189,26 +3188,26 @@ COMMAND_HANDLER(sam4_handle_slowclk_command)
 		return ERROR_OK;
 
 	switch (CMD_ARGC) {
-		case 0:
-			/* show */
-			break;
-		case 1:
-		{
-			/* set */
-			uint32_t v;
-			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], v);
-			if (v > 200000) {
-				/* absurd slow clock of 200Khz? */
-				command_print(CMD, "Absurd/illegal slow clock freq: %d\n", (int)(v));
-				return ERROR_COMMAND_SYNTAX_ERROR;
-			}
-			chip->cfg.slow_freq = v;
-			break;
-		}
-		default:
-			/* error */
-			command_print(CMD, "Too many parameters");
+	case 0:
+		/* show */
+		break;
+	case 1:
+	{
+		/* set */
+		uint32_t v;
+		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], v);
+		if (v > 200000) {
+			/* absurd slow clock of 200Khz? */
+			command_print(CMD, "Absurd/illegal slow clock freq: %d\n", (int)(v));
 			return ERROR_COMMAND_SYNTAX_ERROR;
+		}
+		chip->cfg.slow_freq = v;
+		break;
+	}
+	default:
+		/* error */
+		command_print(CMD, "Too many parameters");
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 	command_print(CMD, "Slowclk freq: %d.%03dkhz",
 		(int)(chip->cfg.slow_freq / 1000),
diff --git a/src/flash/nor/at91sam4l.c b/src/flash/nor/at91sam4l.c
index ddf42a8c5f..1db15377eb 100644
--- a/src/flash/nor/at91sam4l.c
+++ b/src/flash/nor/at91sam4l.c
@@ -282,19 +282,19 @@ static int sam4l_probe(struct flash_bank *bank)
 	chip->ram_kb = sam4l_ram_sizes[0xF & (id >> 16)];
 
 	switch (0xF & (id >> 8)) {
-		case 0x07:
-			chip->flash_kb = 128;
-			break;
-		case 0x09:
-			chip->flash_kb = 256;
-			break;
-		case 0x0A:
-			chip->flash_kb = 512;
-			break;
-		default:
-			LOG_ERROR("Unknown flash size (chip ID is %08" PRIx32 "), assuming 128K", id);
-			chip->flash_kb = 128;
-			break;
+	case 0x07:
+		chip->flash_kb = 128;
+		break;
+	case 0x09:
+		chip->flash_kb = 256;
+		break;
+	case 0x0A:
+		chip->flash_kb = 512;
+		break;
+	default:
+		LOG_ERROR("Unknown flash size (chip ID is %08" PRIx32 "), assuming 128K", id);
+		chip->flash_kb = 128;
+		break;
 	}
 
 	/* Retrieve the Flash parameters */
diff --git a/src/flash/nor/at91sam7.c b/src/flash/nor/at91sam7.c
index d06c9451ce..316596e6e2 100644
--- a/src/flash/nor/at91sam7.c
+++ b/src/flash/nor/at91sam7.c
@@ -193,41 +193,41 @@ static void at91sam7_read_clock_info(struct flash_bank *bank)
 	at91sam7_info->mck_valid = 0;
 	at91sam7_info->mck_freq = 0;
 	switch (mckr & PMC_MCKR_CSS) {
-		case 0:			/* Slow Clock */
+	case 0:			/* Slow Clock */
+		at91sam7_info->mck_valid = 1;
+		tmp = RC_FREQ;
+		break;
+
+	case 1:			/* Main Clock */
+		if ((mcfr & CKGR_MCFR_MAINRDY) && at91sam7_info->ext_freq == 0) {
 			at91sam7_info->mck_valid = 1;
-			tmp = RC_FREQ;
-			break;
-
-		case 1:			/* Main Clock */
-			if ((mcfr & CKGR_MCFR_MAINRDY) && at91sam7_info->ext_freq == 0) {
-				at91sam7_info->mck_valid = 1;
-				tmp = RC_FREQ / 16ul * (mcfr & 0xffff);
-			} else if (at91sam7_info->ext_freq != 0) {
-				at91sam7_info->mck_valid = 1;
-				tmp = at91sam7_info->ext_freq;
-			}
-			break;
-
-		case 2:			/* Reserved */
-			break;
-
-		case 3:			/* PLL Clock */
-			if ((mcfr & CKGR_MCFR_MAINRDY) && at91sam7_info->ext_freq == 0) {
-				target_read_u32(target, CKGR_PLLR, &pllr);
-				if (!(pllr & CKGR_PLLR_DIV))
-					break;	/* 0 Hz */
-				at91sam7_info->mck_valid = 1;
-				mainfreq = RC_FREQ / 16ul * (mcfr & 0xffff);
-				/* Integer arithmetic should have sufficient precision
-				 * as long as PLL is properly configured. */
-				tmp = mainfreq / (pllr & CKGR_PLLR_DIV)*
-						(((pllr & CKGR_PLLR_MUL) >> 16) + 1);
-			} else if ((at91sam7_info->ext_freq != 0) && ((pllr & CKGR_PLLR_DIV) != 0)) {
-				at91sam7_info->mck_valid = 1;
-				tmp = at91sam7_info->ext_freq / (pllr&CKGR_PLLR_DIV)*
-						(((pllr & CKGR_PLLR_MUL) >> 16) + 1);
-			}
-			break;
+			tmp = RC_FREQ / 16ul * (mcfr & 0xffff);
+		} else if (at91sam7_info->ext_freq != 0) {
+			at91sam7_info->mck_valid = 1;
+			tmp = at91sam7_info->ext_freq;
+		}
+		break;
+
+	case 2:			/* Reserved */
+		break;
+
+	case 3:			/* PLL Clock */
+		if ((mcfr & CKGR_MCFR_MAINRDY) && at91sam7_info->ext_freq == 0) {
+			target_read_u32(target, CKGR_PLLR, &pllr);
+			if (!(pllr & CKGR_PLLR_DIV))
+				break;	/* 0 Hz */
+			at91sam7_info->mck_valid = 1;
+			mainfreq = RC_FREQ / 16ul * (mcfr & 0xffff);
+			/* Integer arithmetic should have sufficient precision
+			 * as long as PLL is properly configured. */
+			tmp = mainfreq / (pllr & CKGR_PLLR_DIV) *
+					(((pllr & CKGR_PLLR_MUL) >> 16) + 1);
+		} else if ((at91sam7_info->ext_freq != 0) && ((pllr & CKGR_PLLR_DIV) != 0)) {
+			at91sam7_info->mck_valid = 1;
+			tmp = at91sam7_info->ext_freq / (pllr & CKGR_PLLR_DIV) *
+					(((pllr & CKGR_PLLR_MUL) >> 16) + 1);
+		}
+		break;
 	}
 
 	/* Prescaler adjust */
@@ -415,130 +415,130 @@ static int at91sam7_read_part_info(struct flash_bank *bank)
 
 	/* check flash size */
 	switch ((cidr >> 8)&0x000F) {
-		case FLASH_SIZE_8KB:
-			break;
-
-		case FLASH_SIZE_16KB:
-			banks_num = 1;
-			sectors_num = 8;
-			pages_per_sector = 32;
-			page_size  = 64;
-			base_address = 0x00100000;
-			if (arch == 0x70) {
-				num_nvmbits = 2;
-				target_name_t = "AT91SAM7S161/16";
-			}
-			break;
-
-		case FLASH_SIZE_32KB:
-			banks_num = 1;
-			sectors_num = 8;
-			pages_per_sector = 32;
-			page_size  = 128;
-			base_address = 0x00100000;
-			if (arch == 0x70) {
-				num_nvmbits = 2;
-				target_name_t = "AT91SAM7S321/32";
-			}
-			if (arch == 0x72) {
-				num_nvmbits = 3;
-				target_name_t = "AT91SAM7SE32";
-			}
-			break;
-
-		case FLASH_SIZE_64KB:
-			banks_num = 1;
-			sectors_num = 16;
-			pages_per_sector = 32;
-			page_size  = 128;
-			base_address = 0x00100000;
-			if (arch == 0x70) {
-				num_nvmbits = 2;
-				target_name_t = "AT91SAM7S64";
-			}
-			break;
-
-		case FLASH_SIZE_128KB:
-			banks_num = 1;
-			sectors_num = 8;
-			pages_per_sector = 64;
-			page_size  = 256;
-			base_address = 0x00100000;
-			if (arch == 0x70) {
-				num_nvmbits = 2;
-				target_name_t = "AT91SAM7S128";
-			}
-			if (arch == 0x71) {
-				num_nvmbits = 3;
-				target_name_t = "AT91SAM7XC128";
-			}
-			if (arch == 0x72) {
-				num_nvmbits = 3;
-				target_name_t = "AT91SAM7SE128";
-			}
-			if (arch == 0x75) {
-				num_nvmbits = 3;
-				target_name_t = "AT91SAM7X128";
-			}
-			break;
-
-		case FLASH_SIZE_256KB:
-			banks_num = 1;
-			sectors_num = 16;
-			pages_per_sector = 64;
-			page_size  = 256;
-			base_address = 0x00100000;
-			if (arch == 0x60) {
-				num_nvmbits = 3;
-				target_name_t = "AT91SAM7A3";
-			}
-			if (arch == 0x70) {
-				num_nvmbits = 2;
-				target_name_t = "AT91SAM7S256";
-			}
-			if (arch == 0x71) {
-				num_nvmbits = 3;
-				target_name_t = "AT91SAM7XC256";
-			}
-			if (arch == 0x72) {
-				num_nvmbits = 3;
-				target_name_t = "AT91SAM7SE256";
-			}
-			if (arch == 0x75) {
-				num_nvmbits = 3;
-				target_name_t = "AT91SAM7X256";
-			}
-			break;
-
-		case FLASH_SIZE_512KB:
-			banks_num = 2;
-			sectors_num = 16;
-			pages_per_sector = 64;
-			page_size  = 256;
-			base_address = 0x00100000;
-			if (arch == 0x70) {
-				num_nvmbits = 2;
-				target_name_t = "AT91SAM7S512";
-			}
-			if (arch == 0x71) {
-				num_nvmbits = 3;
-				target_name_t = "AT91SAM7XC512";
-			}
-			if (arch == 0x72) {
-				num_nvmbits = 3;
-				target_name_t = "AT91SAM7SE512";
-			}
-			if (arch == 0x75) {
-				num_nvmbits = 3;
-				target_name_t = "AT91SAM7X512";
-			}
-			break;
+	case FLASH_SIZE_8KB:
+		break;
+
+	case FLASH_SIZE_16KB:
+		banks_num = 1;
+		sectors_num = 8;
+		pages_per_sector = 32;
+		page_size  = 64;
+		base_address = 0x00100000;
+		if (arch == 0x70) {
+			num_nvmbits = 2;
+			target_name_t = "AT91SAM7S161/16";
+		}
+		break;
+
+	case FLASH_SIZE_32KB:
+		banks_num = 1;
+		sectors_num = 8;
+		pages_per_sector = 32;
+		page_size  = 128;
+		base_address = 0x00100000;
+		if (arch == 0x70) {
+			num_nvmbits = 2;
+			target_name_t = "AT91SAM7S321/32";
+		}
+		if (arch == 0x72) {
+			num_nvmbits = 3;
+			target_name_t = "AT91SAM7SE32";
+		}
+		break;
+
+	case FLASH_SIZE_64KB:
+		banks_num = 1;
+		sectors_num = 16;
+		pages_per_sector = 32;
+		page_size  = 128;
+		base_address = 0x00100000;
+		if (arch == 0x70) {
+			num_nvmbits = 2;
+			target_name_t = "AT91SAM7S64";
+		}
+		break;
+
+	case FLASH_SIZE_128KB:
+		banks_num = 1;
+		sectors_num = 8;
+		pages_per_sector = 64;
+		page_size  = 256;
+		base_address = 0x00100000;
+		if (arch == 0x70) {
+			num_nvmbits = 2;
+			target_name_t = "AT91SAM7S128";
+		}
+		if (arch == 0x71) {
+			num_nvmbits = 3;
+			target_name_t = "AT91SAM7XC128";
+		}
+		if (arch == 0x72) {
+			num_nvmbits = 3;
+			target_name_t = "AT91SAM7SE128";
+		}
+		if (arch == 0x75) {
+			num_nvmbits = 3;
+			target_name_t = "AT91SAM7X128";
+		}
+		break;
+
+	case FLASH_SIZE_256KB:
+		banks_num = 1;
+		sectors_num = 16;
+		pages_per_sector = 64;
+		page_size  = 256;
+		base_address = 0x00100000;
+		if (arch == 0x60) {
+			num_nvmbits = 3;
+			target_name_t = "AT91SAM7A3";
+		}
+		if (arch == 0x70) {
+			num_nvmbits = 2;
+			target_name_t = "AT91SAM7S256";
+		}
+		if (arch == 0x71) {
+			num_nvmbits = 3;
+			target_name_t = "AT91SAM7XC256";
+		}
+		if (arch == 0x72) {
+			num_nvmbits = 3;
+			target_name_t = "AT91SAM7SE256";
+		}
+		if (arch == 0x75) {
+			num_nvmbits = 3;
+			target_name_t = "AT91SAM7X256";
+		}
+		break;
+
+	case FLASH_SIZE_512KB:
+		banks_num = 2;
+		sectors_num = 16;
+		pages_per_sector = 64;
+		page_size  = 256;
+		base_address = 0x00100000;
+		if (arch == 0x70) {
+			num_nvmbits = 2;
+			target_name_t = "AT91SAM7S512";
+		}
+		if (arch == 0x71) {
+			num_nvmbits = 3;
+			target_name_t = "AT91SAM7XC512";
+		}
+		if (arch == 0x72) {
+			num_nvmbits = 3;
+			target_name_t = "AT91SAM7SE512";
+		}
+		if (arch == 0x75) {
+			num_nvmbits = 3;
+			target_name_t = "AT91SAM7X512";
+		}
+		break;
 
-		case FLASH_SIZE_1024KB:
-			break;
+	case FLASH_SIZE_1024KB:
+		break;
 
-		case FLASH_SIZE_2048KB:
-			break;
+	case FLASH_SIZE_2048KB:
+		break;
 	}
 
 	if (strcmp(target_name_t, "Unknown") == 0) {
diff --git a/src/flash/nor/atsamv.c b/src/flash/nor/atsamv.c
index 85a4384200..782c9e8e8e 100644
--- a/src/flash/nor/atsamv.c
+++ b/src/flash/nor/atsamv.c
@@ -138,21 +138,21 @@ static int samv_erase_pages(struct target *target,
 {
 	uint8_t erase_pages;
 	switch (num_pages) {
-		case 4:
-			erase_pages = 0x00;
-			break;
-		case 8:
-			erase_pages = 0x01;
-			break;
-		case 16:
-			erase_pages = 0x02;
-			break;
-		case 32:
-			erase_pages = 0x03;
-			break;
-		default:
-			erase_pages = 0x00;
-			break;
+	case 4:
+		erase_pages = 0x00;
+		break;
+	case 8:
+		erase_pages = 0x01;
+		break;
+	case 16:
+		erase_pages = 0x02;
+		break;
+	case 32:
+		erase_pages = 0x03;
+		break;
+	default:
+		erase_pages = 0x00;
+		break;
 	}
 
 	/* SAMV_EFC_FCMD_EPA
@@ -320,18 +320,18 @@ static int samv_probe(struct flash_bank *bank)
 
 	uint8_t nvm_size_code = (device_id >> 8) & 0xf;
 	switch (nvm_size_code) {
-		case 10:
-			bank->size = 512 * 1024;
-			break;
-		case 12:
-			bank->size = 1024 * 1024;
-			break;
-		case 14:
-			bank->size = 2048 * 1024;
-			break;
-		default:
-			LOG_ERROR("unrecognized flash size code: %d", nvm_size_code);
-			return ERROR_FAIL;
+	case 10:
+		bank->size = 512 * 1024;
+		break;
+	case 12:
+		bank->size = 1024 * 1024;
+		break;
+	case 14:
+		bank->size = 2048 * 1024;
+		break;
+	default:
+		LOG_ERROR("unrecognized flash size code: %d", nvm_size_code);
+		return ERROR_FAIL;
 	}
 
 	struct samv_flash_bank *samv_info = bank->driver_priv;
@@ -600,22 +600,22 @@ COMMAND_HANDLER(samv_handle_gpnvm_command)
 	int who = 0;
 
 	switch (CMD_ARGC) {
-		case 0:
-			goto showall;
-		case 1:
+	case 0:
+		goto showall;
+	case 1:
+		who = -1;
+		break;
+	case 2:
+		if (!strcmp(CMD_ARGV[0], "show") && !strcmp(CMD_ARGV[1], "all")) {
 			who = -1;
-			break;
-		case 2:
-			if (!strcmp(CMD_ARGV[0], "show") && !strcmp(CMD_ARGV[1], "all")) {
-				who = -1;
-			} else {
-				uint32_t v32;
-				COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], v32);
-				who = v32;
-			}
-			break;
-		default:
-			return ERROR_COMMAND_SYNTAX_ERROR;
+		} else {
+			uint32_t v32;
+			COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], v32);
+			who = v32;
+		}
+		break;
+	default:
+		return ERROR_COMMAND_SYNTAX_ERROR;
 	}
 
 	unsigned int v = 0;
diff --git a/src/flash/nor/cc26xx.c b/src/flash/nor/cc26xx.c
index 54d61421ce..e97f1ba137 100644
--- a/src/flash/nor/cc26xx.c
+++ b/src/flash/nor/cc26xx.c
@@ -51,22 +51,22 @@ static uint32_t cc26xx_device_type(uint32_t icepick_id, uint32_t user_id)
 	uint32_t device_type = 0;
 
 	switch (icepick_id & ICEPICK_ID_MASK) {
-		case CC26X0_ICEPICK_ID:
-			device_type = CC26X0_TYPE;
-			break;
-		case CC26X1_ICEPICK_ID:
-			device_type = CC26X1_TYPE;
-			break;
-		case CC13X0_ICEPICK_ID:
-			device_type = CC13X0_TYPE;
-			break;
-		case CC13X2_CC26X2_ICEPICK_ID:
-		default:
-			if ((user_id & USER_ID_CC13_MASK) != 0)
-				device_type = CC13X2_TYPE;
-			else
-				device_type = CC26X2_TYPE;
-			break;
+	case CC26X0_ICEPICK_ID:
+		device_type = CC26X0_TYPE;
+		break;
+	case CC26X1_ICEPICK_ID:
+		device_type = CC26X1_TYPE;
+		break;
+	case CC13X0_ICEPICK_ID:
+		device_type = CC13X0_TYPE;
+		break;
+	case CC13X2_CC26X2_ICEPICK_ID:
+	default:
+		if ((user_id & USER_ID_CC13_MASK) != 0)
+			device_type = CC13X2_TYPE;
+		else
+			device_type = CC26X2_TYPE;
+		break;
 	}
 
 	return device_type;
@@ -77,17 +77,17 @@ static uint32_t cc26xx_sector_length(uint32_t icepick_id)
 	uint32_t sector_length;
 
 	switch (icepick_id & ICEPICK_ID_MASK) {
-		case CC26X0_ICEPICK_ID:
-		case CC26X1_ICEPICK_ID:
-		case CC13X0_ICEPICK_ID:
-			/* Chameleon family device */
-			sector_length = CC26X0_SECTOR_LENGTH;
-			break;
-		case CC13X2_CC26X2_ICEPICK_ID:
-		default:
-			/* Agama family device */
-			sector_length = CC26X2_SECTOR_LENGTH;
-			break;
+	case CC26X0_ICEPICK_ID:
+	case CC26X1_ICEPICK_ID:
+	case CC13X0_ICEPICK_ID:
+		/* Chameleon family device */
+		sector_length = CC26X0_SECTOR_LENGTH;
+		break;
+	case CC13X2_CC26X2_ICEPICK_ID:
+	default:
+		/* Agama family device */
+		sector_length = CC26X2_SECTOR_LENGTH;
+		break;
 	}
 
 	return sector_length;
@@ -427,31 +427,31 @@ static int cc26xx_probe(struct flash_bank *bank)
 
 	/* Set up appropriate flash helper algorithm */
 	switch (cc26xx_bank->icepick_id & ICEPICK_ID_MASK) {
-		case CC26X0_ICEPICK_ID:
-		case CC26X1_ICEPICK_ID:
-		case CC13X0_ICEPICK_ID:
-			/* Chameleon family device */
-			cc26xx_bank->algo_code = cc26x0_algo;
-			cc26xx_bank->algo_size = sizeof(cc26x0_algo);
-			cc26xx_bank->algo_working_size = CC26X0_WORKING_SIZE;
-			cc26xx_bank->buffer_addr[0] = CC26X0_ALGO_BUFFER_0;
-			cc26xx_bank->buffer_addr[1] = CC26X0_ALGO_BUFFER_1;
-			cc26xx_bank->params_addr[0] = CC26X0_ALGO_PARAMS_0;
-			cc26xx_bank->params_addr[1] = CC26X0_ALGO_PARAMS_1;
-			max_sectors = CC26X0_MAX_SECTORS;
-			break;
-		case CC13X2_CC26X2_ICEPICK_ID:
-		default:
-			/* Agama family device */
-			cc26xx_bank->algo_code = cc26x2_algo;
-			cc26xx_bank->algo_size = sizeof(cc26x2_algo);
-			cc26xx_bank->algo_working_size = CC26X2_WORKING_SIZE;
-			cc26xx_bank->buffer_addr[0] = CC26X2_ALGO_BUFFER_0;
-			cc26xx_bank->buffer_addr[1] = CC26X2_ALGO_BUFFER_1;
-			cc26xx_bank->params_addr[0] = CC26X2_ALGO_PARAMS_0;
-			cc26xx_bank->params_addr[1] = CC26X2_ALGO_PARAMS_1;
-			max_sectors = CC26X2_MAX_SECTORS;
-			break;
+	case CC26X0_ICEPICK_ID:
+	case CC26X1_ICEPICK_ID:
+	case CC13X0_ICEPICK_ID:
+		/* Chameleon family device */
+		cc26xx_bank->algo_code = cc26x0_algo;
+		cc26xx_bank->algo_size = sizeof(cc26x0_algo);
+		cc26xx_bank->algo_working_size = CC26X0_WORKING_SIZE;
+		cc26xx_bank->buffer_addr[0] = CC26X0_ALGO_BUFFER_0;
+		cc26xx_bank->buffer_addr[1] = CC26X0_ALGO_BUFFER_1;
+		cc26xx_bank->params_addr[0] = CC26X0_ALGO_PARAMS_0;
+		cc26xx_bank->params_addr[1] = CC26X0_ALGO_PARAMS_1;
+		max_sectors = CC26X0_MAX_SECTORS;
+		break;
+	case CC13X2_CC26X2_ICEPICK_ID:
+	default:
+		/* Agama family device */
+		cc26xx_bank->algo_code = cc26x2_algo;
+		cc26xx_bank->algo_size = sizeof(cc26x2_algo);
+		cc26xx_bank->algo_working_size = CC26X2_WORKING_SIZE;
+		cc26xx_bank->buffer_addr[0] = CC26X2_ALGO_BUFFER_0;
+		cc26xx_bank->buffer_addr[1] = CC26X2_ALGO_BUFFER_1;
+		cc26xx_bank->params_addr[0] = CC26X2_ALGO_PARAMS_0;
+		cc26xx_bank->params_addr[1] = CC26X2_ALGO_PARAMS_1;
+		max_sectors = CC26X2_MAX_SECTORS;
+		break;
 	}
 
 	retval = target_read_u32(target, CC26XX_FLASH_SIZE_INFO, &value);
@@ -505,25 +505,25 @@ static int cc26xx_info(struct flash_bank *bank, struct command_invocation *cmd)
 	const char *device;
 
 	switch (cc26xx_bank->device_type) {
-		case CC26X0_TYPE:
-			device = "CC26x0";
-			break;
-		case CC26X1_TYPE:
-			device = "CC26x1";
-			break;
-		case CC13X0_TYPE:
-			device = "CC13x0";
-			break;
-		case CC13X2_TYPE:
-			device = "CC13x2";
-			break;
-		case CC26X2_TYPE:
-			device = "CC26x2";
-			break;
-		case CC26XX_NO_TYPE:
-		default:
-			device = "Unrecognized";
-			break;
+	case CC26X0_TYPE:
+		device = "CC26x0";
+		break;
+	case CC26X1_TYPE:
+		device = "CC26x1";
+		break;
+	case CC13X0_TYPE:
+		device = "CC13x0";
+		break;
+	case CC13X2_TYPE:
+		device = "CC13x2";
+		break;
+	case CC26X2_TYPE:
+		device = "CC26x2";
+		break;
+	case CC26XX_NO_TYPE:
+	default:
+		device = "Unrecognized";
+		break;
 	}
 
 	command_print_sameline(cmd,
diff --git a/src/flash/nor/cfi.c b/src/flash/nor/cfi.c
index 2a15e49132..be10d5b2a2 100644
--- a/src/flash/nor/cfi.c
+++ b/src/flash/nor/cfi.c
@@ -945,14 +945,14 @@ int cfi_erase(struct flash_bank *bank, unsigned int first,
 		return ERROR_FLASH_BANK_NOT_PROBED;
 
 	switch (cfi_info->pri_id) {
-		case 1:
-		case 3:
-			return cfi_intel_erase(bank, first, last);
-		case 2:
-			return cfi_spansion_erase(bank, first, last);
-		default:
-			LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
-			break;
+	case 1:
+	case 3:
+		return cfi_intel_erase(bank, first, last);
+	case 2:
+		return cfi_spansion_erase(bank, first, last);
+	default:
+		LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
+		break;
 	}
 
 	return ERROR_OK;
@@ -1084,12 +1084,12 @@ int cfi_protect(struct flash_bank *bank, int set, unsigned int first,
 		return ERROR_FLASH_BANK_NOT_PROBED;
 
 	switch (cfi_info->pri_id) {
-		case 1:
-		case 3:
-			return cfi_intel_protect(bank, set, first, last);
-		default:
-			LOG_WARNING("protect: cfi primary command set %i unsupported", cfi_info->pri_id);
-			return ERROR_OK;
+	case 1:
+	case 3:
+		return cfi_intel_protect(bank, set, first, last);
+	default:
+		LOG_WARNING("protect: cfi primary command set %i unsupported", cfi_info->pri_id);
+		return ERROR_OK;
 	}
 }
 
@@ -1100,16 +1100,16 @@ static uint32_t cfi_command_val(struct flash_bank *bank, uint8_t cmd)
 	uint8_t buf[CFI_MAX_BUS_WIDTH];
 	cfi_command(bank, cmd, buf);
 	switch (bank->bus_width) {
-		case 1:
-			return buf[0];
-		case 2:
-			return target_buffer_get_u16(target, buf);
-		case 4:
-			return target_buffer_get_u32(target, buf);
-		default:
-			LOG_ERROR("Unsupported bank buswidth %u, can't do block memory writes",
-					bank->bus_width);
-			return 0;
+	case 1:
+		return buf[0];
+	case 2:
+		return target_buffer_get_u16(target, buf);
+	case 4:
+		return target_buffer_get_u32(target, buf);
+	default:
+		LOG_ERROR("Unsupported bank buswidth %u, can't do block memory writes",
+				bank->bus_width);
+		return 0;
 	}
 }
 
@@ -1214,22 +1214,22 @@ static int cfi_intel_write_block(struct flash_bank *bank, const uint8_t *buffer,
 
 	/* prepare algorithm code for target endian */
 	switch (bank->bus_width) {
-		case 1:
-			target_code_src = word_8_code;
-			target_code_size = sizeof(word_8_code);
-			break;
-		case 2:
-			target_code_src = word_16_code;
-			target_code_size = sizeof(word_16_code);
-			break;
-		case 4:
-			target_code_src = word_32_code;
-			target_code_size = sizeof(word_32_code);
-			break;
-		default:
-			LOG_ERROR("Unsupported bank buswidth %u, can't do block memory writes",
-					bank->bus_width);
-			return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
+	case 1:
+		target_code_src = word_8_code;
+		target_code_size = sizeof(word_8_code);
+		break;
+	case 2:
+		target_code_src = word_16_code;
+		target_code_size = sizeof(word_16_code);
+		break;
+	case 4:
+		target_code_src = word_32_code;
+		target_code_size = sizeof(word_32_code);
+		break;
+	default:
+		LOG_ERROR("Unsupported bank buswidth %u, can't do block memory writes",
+				bank->bus_width);
+		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 	}
 
 	/* flash write code */
@@ -1448,22 +1448,22 @@ static int cfi_spansion_write_block_mips(struct flash_bank *bank, const uint8_t
 	const uint32_t *target_code_src = NULL;
 
 	switch (bank->bus_width) {
-		case 2:
-			/* Check for DQ5 support */
-			if (cfi_info->status_poll_mask & (1 << 5)) {
-				target_code_src = mips_word_16_code;
-				target_code_size = sizeof(mips_word_16_code);
-			} else {
-				LOG_ERROR("Need DQ5 support");
-				return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
-				/* target_code_src = mips_word_16_code_dq7only; */
-				/* target_code_size = sizeof(mips_word_16_code_dq7only); */
-			}
-			break;
-		default:
-			LOG_ERROR("Unsupported bank buswidth %u, can't do block memory writes",
-					bank->bus_width);
+	case 2:
+		/* Check for DQ5 support */
+		if (cfi_info->status_poll_mask & (1 << 5)) {
+			target_code_src = mips_word_16_code;
+			target_code_size = sizeof(mips_word_16_code);
+		} else {
+			LOG_ERROR("Need DQ5 support");
 			return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
+			/* target_code_src = mips_word_16_code_dq7only; */
+			/* target_code_size = sizeof(mips_word_16_code_dq7only); */
+		}
+		break;
+	default:
+		LOG_ERROR("Unsupported bank buswidth %u, can't do block memory writes",
+				bank->bus_width);
+		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 	}
 
 	/* flash write code */
@@ -1800,49 +1800,49 @@ static int cfi_spansion_write_block(struct flash_bank *bank, const uint8_t *buff
 	const uint32_t *target_code_src = NULL;
 
 	switch (bank->bus_width) {
-		case 1:
+	case 1:
+		if (is_armv7m(target_to_armv7m(target))) {
+			LOG_ERROR("Unknown ARM architecture");
+			return ERROR_FAIL;
+		}
+		target_code_src = armv4_5_word_8_code;
+		target_code_size = sizeof(armv4_5_word_8_code);
+		break;
+	case 2:
+		/* Check for DQ5 support */
+		if (cfi_info->status_poll_mask & (1 << 5)) {
 			if (is_armv7m(target_to_armv7m(target))) {
-				LOG_ERROR("Unknown ARM architecture");
-				return ERROR_FAIL;
+				/* armv7m target */
+				target_code_src = armv7m_word_16_code;
+				target_code_size = sizeof(armv7m_word_16_code);
+			} else { /* armv4_5 target */
+				target_code_src = armv4_5_word_16_code;
+				target_code_size = sizeof(armv4_5_word_16_code);
 			}
-			target_code_src = armv4_5_word_8_code;
-			target_code_size = sizeof(armv4_5_word_8_code);
-			break;
-		case 2:
-			/* Check for DQ5 support */
-			if (cfi_info->status_poll_mask & (1 << 5)) {
-				if (is_armv7m(target_to_armv7m(target))) {
-					/* armv7m target */
-					target_code_src = armv7m_word_16_code;
-					target_code_size = sizeof(armv7m_word_16_code);
-				} else { /* armv4_5 target */
-					target_code_src = armv4_5_word_16_code;
-					target_code_size = sizeof(armv4_5_word_16_code);
-				}
-			} else {
-				/* No DQ5 support. Use DQ7 DATA# polling only. */
-				if (is_armv7m(target_to_armv7m(target))) {
-					/* armv7m target */
-					target_code_src = armv7m_word_16_code_dq7only;
-					target_code_size = sizeof(armv7m_word_16_code_dq7only);
-				} else { /* armv4_5 target */
-					target_code_src = armv4_5_word_16_code_dq7only;
-					target_code_size = sizeof(armv4_5_word_16_code_dq7only);
-				}
-			}
-			break;
-		case 4:
+		} else {
+			/* No DQ5 support. Use DQ7 DATA# polling only. */
 			if (is_armv7m(target_to_armv7m(target))) {
-				LOG_ERROR("Unknown ARM architecture");
-				return ERROR_FAIL;
+				/* armv7m target */
+				target_code_src = armv7m_word_16_code_dq7only;
+				target_code_size = sizeof(armv7m_word_16_code_dq7only);
+			} else { /* armv4_5 target */
+				target_code_src = armv4_5_word_16_code_dq7only;
+				target_code_size = sizeof(armv4_5_word_16_code_dq7only);
 			}
-			target_code_src = armv4_5_word_32_code;
-			target_code_size = sizeof(armv4_5_word_32_code);
-			break;
-		default:
-			LOG_ERROR("Unsupported bank buswidth %u, can't do block memory writes",
-					bank->bus_width);
-			return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
+		}
+		break;
+	case 4:
+		if (is_armv7m(target_to_armv7m(target))) {
+			LOG_ERROR("Unknown ARM architecture");
+			return ERROR_FAIL;
+		}
+		target_code_src = armv4_5_word_32_code;
+		target_code_size = sizeof(armv4_5_word_32_code);
+		break;
+	default:
+		LOG_ERROR("Unsupported bank buswidth %u, can't do block memory writes",
+				bank->bus_width);
+		return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
 	}
 
 	/* flash write code */
@@ -2172,14 +2172,14 @@ int cfi_write_word(struct flash_bank *bank, uint8_t *word, uint32_t address)
 	struct cfi_flash_bank *cfi_info = bank->driver_priv;
 
 	switch (cfi_info->pri_id) {
-		case 1:
-		case 3:
-			return cfi_intel_write_word(bank, word, address);
-		case 2:
-			return cfi_spansion_write_word(bank, word, address);
-		default:
-			LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
-			break;
+	case 1:
+	case 3:
+		return cfi_intel_write_word(bank, word, address);
+	case 2:
+		return cfi_spansion_write_word(bank, word, address);
+	default:
+		LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
+		break;
 	}
 
 	return ERROR_FLASH_OPERATION_FAILED;
@@ -2197,14 +2197,14 @@ static int cfi_write_words(struct flash_bank *bank, const uint8_t *word,
 	}
 
 	switch (cfi_info->pri_id) {
-		case 1:
-		case 3:
-			return cfi_intel_write_words(bank, word, wordcount, address);
-		case 2:
-			return cfi_spansion_write_words(bank, word, wordcount, address);
-		default:
-			LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
-			break;
+	case 1:
+	case 3:
+		return cfi_intel_write_words(bank, word, wordcount, address);
+	case 2:
+		return cfi_spansion_write_words(bank, word, wordcount, address);
+	default:
+		LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
+		break;
 	}
 
 	return ERROR_FLASH_OPERATION_FAILED;
@@ -2345,18 +2345,18 @@ static int cfi_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t of
 	/* handle blocks of bus_size aligned bytes */
 	blk_count = count & ~(bank->bus_width - 1);	/* round down, leave tail bytes */
 	switch (cfi_info->pri_id) {
-		/* try block writes (fails without working area) */
-		case 1:
-		case 3:
-			retval = cfi_intel_write_block(bank, buffer, write_p, blk_count);
-			break;
-		case 2:
-			retval = cfi_spansion_write_block(bank, buffer, write_p, blk_count);
-			break;
-		default:
-			LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
-			retval = ERROR_FLASH_OPERATION_FAILED;
-			break;
+	/* try block writes (fails without working area) */
+	case 1:
+	case 3:
+		retval = cfi_intel_write_block(bank, buffer, write_p, blk_count);
+		break;
+	case 2:
+		retval = cfi_spansion_write_block(bank, buffer, write_p, blk_count);
+		break;
+	default:
+		LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
+		retval = ERROR_FLASH_OPERATION_FAILED;
+		break;
 	}
 	if (retval == ERROR_OK) {
 		/* Increment pointers and decrease count on successful block write */
@@ -2581,22 +2581,22 @@ int cfi_probe(struct flash_bank *bank)
 	if (retval != ERROR_OK)
 		return retval;
 	switch (bank->chip_width) {
-		case 1:
-			cfi_info->manufacturer = *value_buf0;
-			cfi_info->device_id = *value_buf1;
-			break;
-		case 2:
-			cfi_info->manufacturer = target_buffer_get_u16(target, value_buf0);
-			cfi_info->device_id = target_buffer_get_u16(target, value_buf1);
-			break;
-		case 4:
-			cfi_info->manufacturer = target_buffer_get_u32(target, value_buf0);
-			cfi_info->device_id = target_buffer_get_u32(target, value_buf1);
-			break;
-		default:
-			LOG_ERROR("Unsupported bank chipwidth %u, can't probe memory",
-					bank->chip_width);
-			return ERROR_FLASH_OPERATION_FAILED;
+	case 1:
+		cfi_info->manufacturer = *value_buf0;
+		cfi_info->device_id = *value_buf1;
+		break;
+	case 2:
+		cfi_info->manufacturer = target_buffer_get_u16(target, value_buf0);
+		cfi_info->device_id = target_buffer_get_u16(target, value_buf1);
+		break;
+	case 4:
+		cfi_info->manufacturer = target_buffer_get_u32(target, value_buf0);
+		cfi_info->device_id = target_buffer_get_u32(target, value_buf1);
+		break;
+	default:
+		LOG_ERROR("Unsupported bank chipwidth %u, can't probe memory",
+				bank->chip_width);
+		return ERROR_FLASH_OPERATION_FAILED;
 	}
 
 	LOG_INFO("Flash Manufacturer/Device: 0x%04x 0x%04x",
@@ -2734,25 +2734,25 @@ int cfi_probe(struct flash_bank *bank)
 		 * the sector layout to be able to apply fixups
 		 */
 		switch (cfi_info->pri_id) {
-			/* Intel command set (standard and extended) */
-			case 0x0001:
-			case 0x0003:
-				cfi_read_intel_pri_ext(bank);
-				break;
-			/* AMD/Spansion, Atmel, ... command set */
-			case 0x0002:
-				cfi_info->status_poll_mask = CFI_STATUS_POLL_MASK_DQ5_DQ6_DQ7;	/*
-												 *default
-												 *for
-												 *all
-												 *CFI
-												 *flashes
-												 **/
-				cfi_read_0002_pri_ext(bank);
-				break;
-			default:
-				LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
-				break;
+		/* Intel command set (standard and extended) */
+		case 0x0001:
+		case 0x0003:
+			cfi_read_intel_pri_ext(bank);
+			break;
+		/* AMD/Spansion, Atmel, ... command set */
+		case 0x0002:
+			cfi_info->status_poll_mask = CFI_STATUS_POLL_MASK_DQ5_DQ6_DQ7;	/*
+											 *default
+											 *for
+											 *all
+											 *CFI
+											 *flashes
+											 **/
+			cfi_read_0002_pri_ext(bank);
+			break;
+		default:
+			LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
+			break;
 		}
 
 		/* return to read array mode
@@ -2798,18 +2798,18 @@ int cfi_probe(struct flash_bank *bank)
 
 	/* apply fixups depending on the primary command set */
 	switch (cfi_info->pri_id) {
-		/* Intel command set (standard and extended) */
-		case 0x0001:
-		case 0x0003:
-			cfi_fixup(bank, cfi_0001_fixups);
-			break;
-		/* AMD/Spansion, Atmel, ... command set */
-		case 0x0002:
-			cfi_fixup(bank, cfi_0002_fixups);
-			break;
-		default:
-			LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
-			break;
+	/* Intel command set (standard and extended) */
+	case 0x0001:
+	case 0x0003:
+		cfi_fixup(bank, cfi_0001_fixups);
+		break;
+	/* AMD/Spansion, Atmel, ... command set */
+	case 0x0002:
+		cfi_fixup(bank, cfi_0002_fixups);
+		break;
+	default:
+		LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
+		break;
 	}
 
 	if ((cfi_info->dev_size * bank->bus_width / bank->chip_width) != bank->size) {
@@ -2939,14 +2939,14 @@ int cfi_protect_check(struct flash_bank *bank)
 		return ERROR_FLASH_BANK_NOT_PROBED;
 
 	switch (cfi_info->pri_id) {
-		case 1:
-		case 3:
-			return cfi_intel_protect_check(bank);
-		case 2:
-			return cfi_spansion_protect_check(bank);
-		default:
-			LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
-			break;
+	case 1:
+	case 3:
+		return cfi_intel_protect_check(bank);
+	case 2:
+		return cfi_spansion_protect_check(bank);
+	default:
+		LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
+		break;
 	}
 
 	return ERROR_OK;
@@ -3011,16 +3011,16 @@ int cfi_get_info(struct flash_bank *bank, struct command_invocation *cmd)
 			1 << cfi_info->max_buf_write_size);
 
 	switch (cfi_info->pri_id) {
-	    case 1:
-	    case 3:
-		    cfi_intel_info(bank, cmd);
-		    break;
-	    case 2:
-		    cfi_spansion_info(bank, cmd);
-		    break;
-	    default:
-		    LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
-		    break;
+	case 1:
+	case 3:
+	    cfi_intel_info(bank, cmd);
+	    break;
+	case 2:
+	    cfi_spansion_info(bank, cmd);
+	    break;
+	default:
+	    LOG_ERROR("cfi primary command set %i unsupported", cfi_info->pri_id);
+	    break;
 	}
 
 	return ERROR_OK;
diff --git a/src/flash/nor/efm32.c b/src/flash/nor/efm32.c
index f8e0886570..2dac45e79a 100644
--- a/src/flash/nor/efm32.c
+++ b/src/flash/nor/efm32.c
@@ -88,14 +88,14 @@ enum efm32_bank_index {
 static int efm32x_get_bank_index(target_addr_t base)
 {
 	switch (base) {
-		case EFM32_FLASH_BASE:
-			return EFM32_BANK_INDEX_MAIN;
-		case EFM32_MSC_USER_DATA:
-			return EFM32_BANK_INDEX_USER_DATA;
-		case EFM32_MSC_LOCK_BITS:
-			return EFM32_BANK_INDEX_LOCK_BITS;
-		default:
-			return ERROR_FAIL;
+	case EFM32_FLASH_BASE:
+		return EFM32_BANK_INDEX_MAIN;
+	case EFM32_MSC_USER_DATA:
+		return EFM32_BANK_INDEX_USER_DATA;
+	case EFM32_MSC_LOCK_BITS:
+		return EFM32_BANK_INDEX_LOCK_BITS;
+	default:
+		return ERROR_FAIL;
 	}
 }
 
@@ -282,14 +282,14 @@ static int efm32x_read_info(struct flash_bank *bank)
 	}
 
 	switch (efm32_info->family_data->series) {
-		case 0:
-			efm32x_info->reg_base = EFM32_MSC_REGBASE;
-			efm32x_info->reg_lock = EFM32_MSC_REG_LOCK;
-			break;
-		case 1:
-			efm32x_info->reg_base = EFM32_MSC_REGBASE_SERIES1;
-			efm32x_info->reg_lock = EFM32_MSC_REG_LOCK_SERIES1;
-			break;
+	case 0:
+		efm32x_info->reg_base = EFM32_MSC_REGBASE;
+		efm32x_info->reg_lock = EFM32_MSC_REG_LOCK;
+		break;
+	case 1:
+		efm32x_info->reg_base = EFM32_MSC_REGBASE_SERIES1;
+		efm32x_info->reg_lock = EFM32_MSC_REG_LOCK_SERIES1;
+		break;
 	}
 
 	if (efm32_info->family_data->msc_regbase != 0)
@@ -662,18 +662,18 @@ static int efm32x_get_page_lock(struct flash_bank *bank, size_t page)
 	uint32_t mask = 0;
 
 	switch (bank->base) {
-		case EFM32_FLASH_BASE:
-			dw = efm32x_info->lb_page[page >> 5];
-			mask = 1 << (page & 0x1f);
-			break;
-		case EFM32_MSC_USER_DATA:
-			dw = efm32x_info->lb_page[126];
-			mask = 0x1;
-			break;
-		case EFM32_MSC_LOCK_BITS:
-			dw = efm32x_info->lb_page[126];
-			mask = 0x2;
-			break;
+	case EFM32_FLASH_BASE:
+		dw = efm32x_info->lb_page[page >> 5];
+		mask = 1 << (page & 0x1f);
+		break;
+	case EFM32_MSC_USER_DATA:
+		dw = efm32x_info->lb_page[126];
+		mask = 0x1;
+		break;
+	case EFM32_MSC_LOCK_BITS:
+		dw = efm32x_info->lb_page[126];
+		mask = 0x2;
+		break;
 	}
 
 	return (dw & mask) ? 0 : 1;
diff --git a/src/flash/nor/em357.c b/src/flash/nor/em357.c
index 207346f10d..0ac5d81dbd 100644
--- a/src/flash/nor/em357.c
+++ b/src/flash/nor/em357.c
@@ -670,36 +670,36 @@ static int em357_probe(struct flash_bank *bank)
 	em357_info->probed = false;
 
 	switch (bank->size) {
-		case 0x10000:
-			/* 64k -- 64 1k pages */
-			num_pages = 64;
-			page_size = 1024;
-			break;
-		case 0x20000:
-			/* 128k -- 128 1k pages */
-			num_pages = 128;
-			page_size = 1024;
-			break;
-		case 0x30000:
-			/* 192k -- 96 2k pages */
-			num_pages = 96;
-			page_size = 2048;
-			break;
-		case 0x40000:
-			/* 256k -- 128 2k pages */
-			num_pages = 128;
-			page_size = 2048;
-			break;
-		case 0x80000:
-			/* 512k -- 256 2k pages */
-			num_pages = 256;
-			page_size = 2048;
-			break;
-		default:
-			LOG_WARNING("No size specified for em357 flash driver, assuming 192k!");
-			num_pages = 96;
-			page_size = 2048;
-			break;
+	case 0x10000:
+		/* 64k -- 64 1k pages */
+		num_pages = 64;
+		page_size = 1024;
+		break;
+	case 0x20000:
+		/* 128k -- 128 1k pages */
+		num_pages = 128;
+		page_size = 1024;
+		break;
+	case 0x30000:
+		/* 192k -- 96 2k pages */
+		num_pages = 96;
+		page_size = 2048;
+		break;
+	case 0x40000:
+		/* 256k -- 128 2k pages */
+		num_pages = 128;
+		page_size = 2048;
+		break;
+	case 0x80000:
+		/* 512k -- 256 2k pages */
+		num_pages = 256;
+		page_size = 2048;
+		break;
+	default:
+		LOG_WARNING("No size specified for em357 flash driver, assuming 192k!");
+		num_pages = 96;
+		page_size = 2048;
+		break;
 	}
 
 	/* Enable FPEC CLK */
diff --git a/src/flash/nor/kinetis.c b/src/flash/nor/kinetis.c
index 85c306bd44..82e68de3fb 100644
--- a/src/flash/nor/kinetis.c
+++ b/src/flash/nor/kinetis.c
@@ -2145,24 +2145,24 @@ static int kinetis_probe_chip_s32k(struct kinetis_chip *k_chip)
 		k_chip->max_flash_prog_size = 512;
 
 		switch (k_chip->sim_sdid & KINETIS_SDID_S32K_DERIVATE_MASK) {
-			case KINETIS_SDID_S32K_DERIVATE_KXX6:
-				/* S32K116 CPU 48Mhz Flash 128KB RAM 17KB+2KB */
-				/* Non-Interleaved */
-				k_chip->pflash_size = 128 << 10;
-				k_chip->pflash_sector_size = 2 << 10;
-				/* Non-Interleaved */
-				k_chip->nvm_size = 32 << 10;
-				k_chip->nvm_sector_size = 2 << 10;
-				break;
-			case KINETIS_SDID_S32K_DERIVATE_KXX8:
-				/* S32K118 CPU 80Mhz Flash 256KB+32KB RAM 32KB+4KB */
-				/* Non-Interleaved */
-				k_chip->pflash_size = 256 << 10;
-				k_chip->pflash_sector_size = 2 << 10;
-				/* Non-Interleaved */
-				k_chip->nvm_size = 32 << 10;
-				k_chip->nvm_sector_size = 2 << 10;
-				break;
+		case KINETIS_SDID_S32K_DERIVATE_KXX6:
+			/* S32K116 CPU 48Mhz Flash 128KB RAM 17KB+2KB */
+			/* Non-Interleaved */
+			k_chip->pflash_size = 128 << 10;
+			k_chip->pflash_sector_size = 2 << 10;
+			/* Non-Interleaved */
+			k_chip->nvm_size = 32 << 10;
+			k_chip->nvm_sector_size = 2 << 10;
+			break;
+		case KINETIS_SDID_S32K_DERIVATE_KXX8:
+			/* S32K118 CPU 80Mhz Flash 256KB+32KB RAM 32KB+4KB */
+			/* Non-Interleaved */
+			k_chip->pflash_size = 256 << 10;
+			k_chip->pflash_sector_size = 2 << 10;
+			/* Non-Interleaved */
+			k_chip->nvm_size = 32 << 10;
+			k_chip->nvm_sector_size = 2 << 10;
+			break;
 		}
 		break;
 
diff --git a/src/flash/nor/kinetis_ke.c b/src/flash/nor/kinetis_ke.c
index 8207504b5f..51d5cb504b 100644
--- a/src/flash/nor/kinetis_ke.c
+++ b/src/flash/nor/kinetis_ke.c
@@ -238,19 +238,18 @@ static int kinetis_ke_prepare_flash(struct flash_bank *bank)
 	 * Trim internal clock
 	 */
 	switch (KINETIS_KE_SRSID_SUBFAMID(kinfo->sim_srsid)) {
-
-		case KINETIS_KE_SRSID_KEX2:
-			/* Both KE02_20 and KE02_40 should get the same trim value */
-			trim_value = 0x4C;
-			break;
-
-		case KINETIS_KE_SRSID_KEX4:
-			trim_value = 0x54;
-			break;
-
-		case KINETIS_KE_SRSID_KEX6:
-			trim_value = 0x58;
-			break;
+	case KINETIS_KE_SRSID_KEX2:
+		/* Both KE02_20 and KE02_40 should get the same trim value */
+		trim_value = 0x4C;
+		break;
+
+	case KINETIS_KE_SRSID_KEX4:
+		trim_value = 0x54;
+		break;
+
+	case KINETIS_KE_SRSID_KEX6:
+		trim_value = 0x58;
+		break;
 	}
 
 	result = target_read_u8(target, ICS_C4, &c4);
@@ -293,54 +292,52 @@ static int kinetis_ke_prepare_flash(struct flash_bank *bank)
 	 * Configure SIM (bus clock)
 	 */
 	switch (KINETIS_KE_SRSID_SUBFAMID(kinfo->sim_srsid)) {
+	/* KE02 sub-family operates on SIM_BUSDIV */
+	case KINETIS_KE_SRSID_KEX2:
+		bus_reg_val = 0;
+		bus_reg_addr = SIM_BUSDIV;
+		bus_clock = 20000000;
+		break;
+
+	/* KE04 and KE06 sub-family operates on SIM_CLKDIV
+	 * Clocks are divided by:
+	 * DIV1 = core clock = 48MHz
+	 * DIV2 = bus clock = 24Mhz
+	 * DIV3 = timer clocks
+	 * So we need to configure SIM_CLKDIV, DIV1 and DIV2 value
+	 */
+	case KINETIS_KE_SRSID_KEX4:
+		/* KE04 devices have the SIM_CLKDIV register at a different offset
+		 * depending on the pin count. */
+		switch (KINETIS_KE_SRSID_PINCOUNT(kinfo->sim_srsid)) {
+		/* 16, 20 and 24 pins */
+		case 1:
+		case 2:
+		case 3:
+			bus_reg_addr = SIM_CLKDIV_KE04_16_20_24;
+			break;
 
-		/* KE02 sub-family operates on SIM_BUSDIV */
-		case KINETIS_KE_SRSID_KEX2:
-			bus_reg_val = 0;
-			bus_reg_addr = SIM_BUSDIV;
-			bus_clock = 20000000;
+		/* 44, 64 and 80 pins */
+		case 5:
+		case 7:
+		case 8:
+			bus_reg_addr = SIM_CLKDIV_KE04_44_64_80;
 			break;
 
-		/* KE04 and KE06 sub-family operates on SIM_CLKDIV
-		 * Clocks are divided by:
-		 * DIV1 = core clock = 48MHz
-		 * DIV2 = bus clock = 24Mhz
-		 * DIV3 = timer clocks
-		 * So we need to configure SIM_CLKDIV, DIV1 and DIV2 value
-		 */
-		case KINETIS_KE_SRSID_KEX4:
-			/* KE04 devices have the SIM_CLKDIV register at a different offset
-			 * depending on the pin count. */
-			switch (...
 
[truncated message content]

[PATCH]: 31fcda3333 svf: factorize big switch case

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9040

-- gerrit

commit 31fcda3333748ce31b755393d0ac2d2693d7ce2f
Author: Antonio Borneo <bor...@gm...>
Date:   Sun Jun 29 23:43:11 2025 +0200

    svf: factorize big switch case
    
    Factorize function svf_run_command() by moving out of the 'case'
    the common code related to the label 'xxr_common'.
    
    The target is to drop later on the ugly label 'xxr_common' inside
    the switch.
    
    Apart for:
    - the function and local variables declaration,
    - the added function call in place of original code,
    - the reduced indentation in the new function,
    this change is a dummy copy/paste with no code modification.
    
    Change-Id: I8149cf25f460326ba6666a9287c5c309e5d99488
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/svf/svf.c b/src/svf/svf.c
index 802e2326a2..d0a8563dd2 100644
--- a/src/svf/svf.c
+++ b/src/svf/svf.c
@@ -979,6 +979,295 @@ static int svf_execute_tap(void)
 	return ERROR_OK;
 }
 
+static int svf_xxr_common(char **argus, int num_of_argu, char command, struct svf_xxr_para *xxr_para_tmp)
+{
+	int i, i_tmp;
+	uint8_t **pbuffer_tmp;
+	struct scan_field field;
+
+	/* XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)] */
+	if (num_of_argu > 10 || (num_of_argu % 2)) {
+		LOG_ERROR("invalid parameter of %s", argus[0]);
+		return ERROR_FAIL;
+	}
+	i_tmp = xxr_para_tmp->len;
+	xxr_para_tmp->len = atoi(argus[1]);
+	/* If we are to enlarge the buffers, all parts of xxr_para_tmp
+	 * need to be freed */
+	if (i_tmp < xxr_para_tmp->len) {
+		free(xxr_para_tmp->tdi);
+		xxr_para_tmp->tdi = NULL;
+		free(xxr_para_tmp->tdo);
+		xxr_para_tmp->tdo = NULL;
+		free(xxr_para_tmp->mask);
+		xxr_para_tmp->mask = NULL;
+		free(xxr_para_tmp->smask);
+		xxr_para_tmp->smask = NULL;
+	}
+
+	LOG_DEBUG("\tlength = %d", xxr_para_tmp->len);
+	xxr_para_tmp->data_mask = 0;
+	for (i = 2; i < num_of_argu; i += 2) {
+		if ((strlen(argus[i + 1]) < 3) || (argus[i + 1][0] != '(') ||
+				argus[i + 1][strlen(argus[i + 1]) - 1] != ')') {
+			LOG_ERROR("data section error");
+			return ERROR_FAIL;
+		}
+		argus[i + 1][strlen(argus[i + 1]) - 1] = '\0';
+		/* TDI, TDO, MASK, SMASK */
+		if (!strcmp(argus[i], "TDI")) {
+			/* TDI */
+			pbuffer_tmp = &xxr_para_tmp->tdi;
+			xxr_para_tmp->data_mask |= XXR_TDI;
+		} else if (!strcmp(argus[i], "TDO")) {
+			/* TDO */
+			pbuffer_tmp = &xxr_para_tmp->tdo;
+			xxr_para_tmp->data_mask |= XXR_TDO;
+		} else if (!strcmp(argus[i], "MASK")) {
+			/* MASK */
+			pbuffer_tmp = &xxr_para_tmp->mask;
+			xxr_para_tmp->data_mask |= XXR_MASK;
+		} else if (!strcmp(argus[i], "SMASK")) {
+			/* SMASK */
+			pbuffer_tmp = &xxr_para_tmp->smask;
+			xxr_para_tmp->data_mask |= XXR_SMASK;
+		} else {
+			LOG_ERROR("unknown parameter: %s", argus[i]);
+			return ERROR_FAIL;
+		}
+		if (ERROR_OK !=
+		svf_copy_hexstring_to_binary(&argus[i + 1][1], pbuffer_tmp, i_tmp,
+			xxr_para_tmp->len)) {
+			LOG_ERROR("fail to parse hex value");
+			return ERROR_FAIL;
+		}
+		SVF_BUF_LOG(DEBUG, *pbuffer_tmp, xxr_para_tmp->len, argus[i]);
+	}
+	/* If a command changes the length of the last scan of the same type and the
+	 * MASK parameter is absent, */
+	/* the mask pattern used is all cares */
+	if (!(xxr_para_tmp->data_mask & XXR_MASK) && i_tmp != xxr_para_tmp->len) {
+		/* MASK not defined and length changed */
+		if (ERROR_OK !=
+		svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp,
+			xxr_para_tmp->len)) {
+			LOG_ERROR("fail to adjust length of array");
+			return ERROR_FAIL;
+		}
+		buf_set_ones(xxr_para_tmp->mask, xxr_para_tmp->len);
+	}
+	/* If TDO is absent, no comparison is needed, set the mask to 0 */
+	if (!(xxr_para_tmp->data_mask & XXR_TDO)) {
+		if (!xxr_para_tmp->tdo) {
+			if (ERROR_OK !=
+			svf_adjust_array_length(&xxr_para_tmp->tdo, i_tmp,
+				xxr_para_tmp->len)) {
+				LOG_ERROR("fail to adjust length of array");
+				return ERROR_FAIL;
+			}
+		}
+		if (!xxr_para_tmp->mask) {
+			if (ERROR_OK !=
+			svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp,
+				xxr_para_tmp->len)) {
+				LOG_ERROR("fail to adjust length of array");
+				return ERROR_FAIL;
+			}
+		}
+		memset(xxr_para_tmp->mask, 0, (xxr_para_tmp->len + 7) >> 3);
+	}
+	/* do scan if necessary */
+	if (command == SDR) {
+		/* check buffer size first, reallocate if necessary */
+		i = svf_para.hdr_para.len + svf_para.sdr_para.len +
+				svf_para.tdr_para.len;
+		if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3)) {
+			/* reallocate buffer */
+			if (svf_realloc_buffers(svf_buffer_index + ((i + 7) >> 3)) != ERROR_OK) {
+				LOG_ERROR("not enough memory");
+				return ERROR_FAIL;
+			}
+		}
+
+		/* assemble dr data */
+		i = 0;
+		buf_set_buf(svf_para.hdr_para.tdi,
+				0,
+				&svf_tdi_buffer[svf_buffer_index],
+				i,
+				svf_para.hdr_para.len);
+		i += svf_para.hdr_para.len;
+		buf_set_buf(svf_para.sdr_para.tdi,
+				0,
+				&svf_tdi_buffer[svf_buffer_index],
+				i,
+				svf_para.sdr_para.len);
+		i += svf_para.sdr_para.len;
+		buf_set_buf(svf_para.tdr_para.tdi,
+				0,
+				&svf_tdi_buffer[svf_buffer_index],
+				i,
+				svf_para.tdr_para.len);
+		i += svf_para.tdr_para.len;
+
+		/* add check data */
+		if (svf_para.sdr_para.data_mask & XXR_TDO) {
+			/* assemble dr mask data */
+			i = 0;
+			buf_set_buf(svf_para.hdr_para.mask,
+					0,
+					&svf_mask_buffer[svf_buffer_index],
+					i,
+					svf_para.hdr_para.len);
+			i += svf_para.hdr_para.len;
+			buf_set_buf(svf_para.sdr_para.mask,
+					0,
+					&svf_mask_buffer[svf_buffer_index],
+					i,
+					svf_para.sdr_para.len);
+			i += svf_para.sdr_para.len;
+			buf_set_buf(svf_para.tdr_para.mask,
+					0,
+					&svf_mask_buffer[svf_buffer_index],
+					i,
+					svf_para.tdr_para.len);
+
+			/* assemble dr check data */
+			i = 0;
+			buf_set_buf(svf_para.hdr_para.tdo,
+					0,
+					&svf_tdo_buffer[svf_buffer_index],
+					i,
+					svf_para.hdr_para.len);
+			i += svf_para.hdr_para.len;
+			buf_set_buf(svf_para.sdr_para.tdo,
+					0,
+					&svf_tdo_buffer[svf_buffer_index],
+					i,
+					svf_para.sdr_para.len);
+			i += svf_para.sdr_para.len;
+			buf_set_buf(svf_para.tdr_para.tdo,
+					0,
+					&svf_tdo_buffer[svf_buffer_index],
+					i,
+					svf_para.tdr_para.len);
+			i += svf_para.tdr_para.len;
+
+			svf_add_check_para(1, svf_buffer_index, i);
+		} else {
+			svf_add_check_para(0, svf_buffer_index, i);
+		}
+		field.num_bits = i;
+		field.out_value = &svf_tdi_buffer[svf_buffer_index];
+		field.in_value = (xxr_para_tmp->data_mask & XXR_TDO) ? &svf_tdi_buffer[svf_buffer_index] : NULL;
+		if (!svf_nil) {
+			/* NOTE:  doesn't use SVF-specified state paths */
+			jtag_add_plain_dr_scan(field.num_bits,
+					field.out_value,
+					field.in_value,
+					svf_para.dr_end_state);
+		}
+
+		if (svf_addcycles)
+			jtag_add_clocks(svf_addcycles);
+
+		svf_buffer_index += (i + 7) >> 3;
+	} else if (command == SIR) {
+		/* check buffer size first, reallocate if necessary */
+		i = svf_para.hir_para.len + svf_para.sir_para.len +
+				svf_para.tir_para.len;
+		if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3)) {
+			if (svf_realloc_buffers(svf_buffer_index + ((i + 7) >> 3)) != ERROR_OK) {
+				LOG_ERROR("not enough memory");
+				return ERROR_FAIL;
+			}
+		}
+
+		/* assemble ir data */
+		i = 0;
+		buf_set_buf(svf_para.hir_para.tdi,
+				0,
+				&svf_tdi_buffer[svf_buffer_index],
+				i,
+				svf_para.hir_para.len);
+		i += svf_para.hir_para.len;
+		buf_set_buf(svf_para.sir_para.tdi,
+				0,
+				&svf_tdi_buffer[svf_buffer_index],
+				i,
+				svf_para.sir_para.len);
+		i += svf_para.sir_para.len;
+		buf_set_buf(svf_para.tir_para.tdi,
+				0,
+				&svf_tdi_buffer[svf_buffer_index],
+				i,
+				svf_para.tir_para.len);
+		i += svf_para.tir_para.len;
+
+		/* add check data */
+		if (svf_para.sir_para.data_mask & XXR_TDO) {
+			/* assemble dr mask data */
+			i = 0;
+			buf_set_buf(svf_para.hir_para.mask,
+					0,
+					&svf_mask_buffer[svf_buffer_index],
+					i,
+					svf_para.hir_para.len);
+			i += svf_para.hir_para.len;
+			buf_set_buf(svf_para.sir_para.mask,
+					0,
+					&svf_mask_buffer[svf_buffer_index],
+					i,
+					svf_para.sir_para.len);
+			i += svf_para.sir_para.len;
+			buf_set_buf(svf_para.tir_para.mask,
+					0,
+					&svf_mask_buffer[svf_buffer_index],
+					i,
+					svf_para.tir_para.len);
+
+			/* assemble dr check data */
+			i = 0;
+			buf_set_buf(svf_para.hir_para.tdo,
+					0,
+					&svf_tdo_buffer[svf_buffer_index],
+					i,
+					svf_para.hir_para.len);
+			i += svf_para.hir_para.len;
+			buf_set_buf(svf_para.sir_para.tdo,
+					0,
+					&svf_tdo_buffer[svf_buffer_index],
+					i,
+					svf_para.sir_para.len);
+			i += svf_para.sir_para.len;
+			buf_set_buf(svf_para.tir_para.tdo,
+					0,
+					&svf_tdo_buffer[svf_buffer_index],
+					i,
+					svf_para.tir_para.len);
+			i += svf_para.tir_para.len;
+
+			svf_add_check_para(1, svf_buffer_index, i);
+		} else {
+			svf_add_check_para(0, svf_buffer_index, i);
+		}
+		field.num_bits = i;
+		field.out_value = &svf_tdi_buffer[svf_buffer_index];
+		field.in_value = (xxr_para_tmp->data_mask & XXR_TDO) ? &svf_tdi_buffer[svf_buffer_index] : NULL;
+		if (!svf_nil) {
+			/* NOTE:  doesn't use SVF-specified state paths */
+			jtag_add_plain_ir_scan(field.num_bits,
+					field.out_value,
+					field.in_value,
+					svf_para.ir_end_state);
+		}
+
+		svf_buffer_index += (i + 7) >> 3;
+	}
+
+	return ERROR_OK;
+}
+
 static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 {
 	char *argus[256], command;
@@ -992,8 +1281,6 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 	float min_time;
 	/* for XXR */
 	struct svf_xxr_para *xxr_para_tmp;
-	uint8_t **pbuffer_tmp;
-	struct scan_field field;
 	/* for STATE */
 	enum tap_state *path = NULL, state;
 	/* flag padding commands skipped due to -tap command */
@@ -1094,285 +1381,9 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 			xxr_para_tmp = &svf_para.sir_para;
 			goto xxr_common;
 xxr_common:
-			/* XXR length [TDI (tdi)] [TDO (tdo)][MASK (mask)] [SMASK (smask)] */
-			if (num_of_argu > 10 || (num_of_argu % 2)) {
-				LOG_ERROR("invalid parameter of %s", argus[0]);
-				return ERROR_FAIL;
-			}
-			i_tmp = xxr_para_tmp->len;
-			xxr_para_tmp->len = atoi(argus[1]);
-			/* If we are to enlarge the buffers, all parts of xxr_para_tmp
-			 * need to be freed */
-			if (i_tmp < xxr_para_tmp->len) {
-				free(xxr_para_tmp->tdi);
-				xxr_para_tmp->tdi = NULL;
-				free(xxr_para_tmp->tdo);
-				xxr_para_tmp->tdo = NULL;
-				free(xxr_para_tmp->mask);
-				xxr_para_tmp->mask = NULL;
-				free(xxr_para_tmp->smask);
-				xxr_para_tmp->smask = NULL;
-			}
-
-			LOG_DEBUG("\tlength = %d", xxr_para_tmp->len);
-			xxr_para_tmp->data_mask = 0;
-			for (i = 2; i < num_of_argu; i += 2) {
-				if ((strlen(argus[i + 1]) < 3) || (argus[i + 1][0] != '(') ||
-						argus[i + 1][strlen(argus[i + 1]) - 1] != ')') {
-					LOG_ERROR("data section error");
-					return ERROR_FAIL;
-				}
-				argus[i + 1][strlen(argus[i + 1]) - 1] = '\0';
-				/* TDI, TDO, MASK, SMASK */
-				if (!strcmp(argus[i], "TDI")) {
-					/* TDI */
-					pbuffer_tmp = &xxr_para_tmp->tdi;
-					xxr_para_tmp->data_mask |= XXR_TDI;
-				} else if (!strcmp(argus[i], "TDO")) {
-					/* TDO */
-					pbuffer_tmp = &xxr_para_tmp->tdo;
-					xxr_para_tmp->data_mask |= XXR_TDO;
-				} else if (!strcmp(argus[i], "MASK")) {
-					/* MASK */
-					pbuffer_tmp = &xxr_para_tmp->mask;
-					xxr_para_tmp->data_mask |= XXR_MASK;
-				} else if (!strcmp(argus[i], "SMASK")) {
-					/* SMASK */
-					pbuffer_tmp = &xxr_para_tmp->smask;
-					xxr_para_tmp->data_mask |= XXR_SMASK;
-				} else {
-					LOG_ERROR("unknown parameter: %s", argus[i]);
-					return ERROR_FAIL;
-				}
-				if (ERROR_OK !=
-				svf_copy_hexstring_to_binary(&argus[i + 1][1], pbuffer_tmp, i_tmp,
-					xxr_para_tmp->len)) {
-					LOG_ERROR("fail to parse hex value");
-					return ERROR_FAIL;
-				}
-				SVF_BUF_LOG(DEBUG, *pbuffer_tmp, xxr_para_tmp->len, argus[i]);
-			}
-			/* If a command changes the length of the last scan of the same type and the
-			 * MASK parameter is absent, */
-			/* the mask pattern used is all cares */
-			if (!(xxr_para_tmp->data_mask & XXR_MASK) && i_tmp != xxr_para_tmp->len) {
-				/* MASK not defined and length changed */
-				if (ERROR_OK !=
-				svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp,
-					xxr_para_tmp->len)) {
-					LOG_ERROR("fail to adjust length of array");
-					return ERROR_FAIL;
-				}
-				buf_set_ones(xxr_para_tmp->mask, xxr_para_tmp->len);
-			}
-			/* If TDO is absent, no comparison is needed, set the mask to 0 */
-			if (!(xxr_para_tmp->data_mask & XXR_TDO)) {
-				if (!xxr_para_tmp->tdo) {
-					if (ERROR_OK !=
-					svf_adjust_array_length(&xxr_para_tmp->tdo, i_tmp,
-						xxr_para_tmp->len)) {
-						LOG_ERROR("fail to adjust length of array");
-						return ERROR_FAIL;
-					}
-				}
-				if (!xxr_para_tmp->mask) {
-					if (ERROR_OK !=
-					svf_adjust_array_length(&xxr_para_tmp->mask, i_tmp,
-						xxr_para_tmp->len)) {
-						LOG_ERROR("fail to adjust length of array");
-						return ERROR_FAIL;
-					}
-				}
-				memset(xxr_para_tmp->mask, 0, (xxr_para_tmp->len + 7) >> 3);
-			}
-			/* do scan if necessary */
-			if (command == SDR) {
-				/* check buffer size first, reallocate if necessary */
-				i = svf_para.hdr_para.len + svf_para.sdr_para.len +
-						svf_para.tdr_para.len;
-				if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3)) {
-					/* reallocate buffer */
-					if (svf_realloc_buffers(svf_buffer_index + ((i + 7) >> 3)) != ERROR_OK) {
-						LOG_ERROR("not enough memory");
-						return ERROR_FAIL;
-					}
-				}
-
-				/* assemble dr data */
-				i = 0;
-				buf_set_buf(svf_para.hdr_para.tdi,
-						0,
-						&svf_tdi_buffer[svf_buffer_index],
-						i,
-						svf_para.hdr_para.len);
-				i += svf_para.hdr_para.len;
-				buf_set_buf(svf_para.sdr_para.tdi,
-						0,
-						&svf_tdi_buffer[svf_buffer_index],
-						i,
-						svf_para.sdr_para.len);
-				i += svf_para.sdr_para.len;
-				buf_set_buf(svf_para.tdr_para.tdi,
-						0,
-						&svf_tdi_buffer[svf_buffer_index],
-						i,
-						svf_para.tdr_para.len);
-				i += svf_para.tdr_para.len;
-
-				/* add check data */
-				if (svf_para.sdr_para.data_mask & XXR_TDO) {
-					/* assemble dr mask data */
-					i = 0;
-					buf_set_buf(svf_para.hdr_para.mask,
-							0,
-							&svf_mask_buffer[svf_buffer_index],
-							i,
-							svf_para.hdr_para.len);
-					i += svf_para.hdr_para.len;
-					buf_set_buf(svf_para.sdr_para.mask,
-							0,
-							&svf_mask_buffer[svf_buffer_index],
-							i,
-							svf_para.sdr_para.len);
-					i += svf_para.sdr_para.len;
-					buf_set_buf(svf_para.tdr_para.mask,
-							0,
-							&svf_mask_buffer[svf_buffer_index],
-							i,
-							svf_para.tdr_para.len);
-
-					/* assemble dr check data */
-					i = 0;
-					buf_set_buf(svf_para.hdr_para.tdo,
-							0,
-							&svf_tdo_buffer[svf_buffer_index],
-							i,
-							svf_para.hdr_para.len);
-					i += svf_para.hdr_para.len;
-					buf_set_buf(svf_para.sdr_para.tdo,
-							0,
-							&svf_tdo_buffer[svf_buffer_index],
-							i,
-							svf_para.sdr_para.len);
-					i += svf_para.sdr_para.len;
-					buf_set_buf(svf_para.tdr_para.tdo,
-							0,
-							&svf_tdo_buffer[svf_buffer_index],
-							i,
-							svf_para.tdr_para.len);
-					i += svf_para.tdr_para.len;
-
-					svf_add_check_para(1, svf_buffer_index, i);
-				} else {
-					svf_add_check_para(0, svf_buffer_index, i);
-				}
-				field.num_bits = i;
-				field.out_value = &svf_tdi_buffer[svf_buffer_index];
-				field.in_value = (xxr_para_tmp->data_mask & XXR_TDO) ? &svf_tdi_buffer[svf_buffer_index] : NULL;
-				if (!svf_nil) {
-					/* NOTE:  doesn't use SVF-specified state paths */
-					jtag_add_plain_dr_scan(field.num_bits,
-							field.out_value,
-							field.in_value,
-							svf_para.dr_end_state);
-				}
-
-				if (svf_addcycles)
-					jtag_add_clocks(svf_addcycles);
-
-				svf_buffer_index += (i + 7) >> 3;
-			} else if (command == SIR) {
-				/* check buffer size first, reallocate if necessary */
-				i = svf_para.hir_para.len + svf_para.sir_para.len +
-						svf_para.tir_para.len;
-				if ((svf_buffer_size - svf_buffer_index) < ((i + 7) >> 3)) {
-					if (svf_realloc_buffers(svf_buffer_index + ((i + 7) >> 3)) != ERROR_OK) {
-						LOG_ERROR("not enough memory");
-						return ERROR_FAIL;
-					}
-				}
-
-				/* assemble ir data */
-				i = 0;
-				buf_set_buf(svf_para.hir_para.tdi,
-						0,
-						&svf_tdi_buffer[svf_buffer_index],
-						i,
-						svf_para.hir_para.len);
-				i += svf_para.hir_para.len;
-				buf_set_buf(svf_para.sir_para.tdi,
-						0,
-						&svf_tdi_buffer[svf_buffer_index],
-						i,
-						svf_para.sir_para.len);
-				i += svf_para.sir_para.len;
-				buf_set_buf(svf_para.tir_para.tdi,
-						0,
-						&svf_tdi_buffer[svf_buffer_index],
-						i,
-						svf_para.tir_para.len);
-				i += svf_para.tir_para.len;
-
-				/* add check data */
-				if (svf_para.sir_para.data_mask & XXR_TDO) {
-					/* assemble dr mask data */
-					i = 0;
-					buf_set_buf(svf_para.hir_para.mask,
-							0,
-							&svf_mask_buffer[svf_buffer_index],
-							i,
-							svf_para.hir_para.len);
-					i += svf_para.hir_para.len;
-					buf_set_buf(svf_para.sir_para.mask,
-							0,
-							&svf_mask_buffer[svf_buffer_index],
-							i,
-							svf_para.sir_para.len);
-					i += svf_para.sir_para.len;
-					buf_set_buf(svf_para.tir_para.mask,
-							0,
-							&svf_mask_buffer[svf_buffer_index],
-							i,
-							svf_para.tir_para.len);
-
-					/* assemble dr check data */
-					i = 0;
-					buf_set_buf(svf_para.hir_para.tdo,
-							0,
-							&svf_tdo_buffer[svf_buffer_index],
-							i,
-							svf_para.hir_para.len);
-					i += svf_para.hir_para.len;
-					buf_set_buf(svf_para.sir_para.tdo,
-							0,
-							&svf_tdo_buffer[svf_buffer_index],
-							i,
-							svf_para.sir_para.len);
-					i += svf_para.sir_para.len;
-					buf_set_buf(svf_para.tir_para.tdo,
-							0,
-							&svf_tdo_buffer[svf_buffer_index],
-							i,
-							svf_para.tir_para.len);
-					i += svf_para.tir_para.len;
-
-					svf_add_check_para(1, svf_buffer_index, i);
-				} else {
-					svf_add_check_para(0, svf_buffer_index, i);
-				}
-				field.num_bits = i;
-				field.out_value = &svf_tdi_buffer[svf_buffer_index];
-				field.in_value = (xxr_para_tmp->data_mask & XXR_TDO) ? &svf_tdi_buffer[svf_buffer_index] : NULL;
-				if (!svf_nil) {
-					/* NOTE:  doesn't use SVF-specified state paths */
-					jtag_add_plain_ir_scan(field.num_bits,
-							field.out_value,
-							field.in_value,
-							svf_para.ir_end_state);
-				}
-
-				svf_buffer_index += (i + 7) >> 3;
-			}
+			int retval = svf_xxr_common(argus, num_of_argu, command, xxr_para_tmp);
+			if (retval != ERROR_OK)
+				return retval;
 			break;
 		case PIO:
 		case PIOMAP:

-- 

[PATCH]: fa757d9fc3 svf: rework svf_parse_cmd_string()

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9042

-- gerrit

commit fa757d9fc31af99c2b4a5183a9a3b73efd2a75ff
Author: Antonio Borneo <bor...@gm...>
Date:   Mon Jun 30 00:22:28 2025 +0200

    svf: rework svf_parse_cmd_string()
    
    Rework the function to drop the goto in the switch statement.
    While there, change some variable to boolean.
    
    Change-Id: I37cbc8aafaeb8aef7f083ee6f5afa9eae71e0cd9
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/svf/svf.c b/src/svf/svf.c
index 5c87f895a0..7ef6df4769 100644
--- a/src/svf/svf.c
+++ b/src/svf/svf.c
@@ -780,7 +780,8 @@ static int svf_read_command_from_file(FILE *fd)
 
 static int svf_parse_cmd_string(char *str, int len, char **argus, int *num_of_argu)
 {
-	int pos = 0, num = 0, space_found = 1, in_bracket = 0;
+	bool space_found = true, in_bracket = false;
+	int pos = 0, num = 0;
 
 	while (pos < len) {
 		switch (str[pos]) {
@@ -789,22 +790,23 @@ static int svf_parse_cmd_string(char *str, int len, char **argus, int *num_of_ar
 				LOG_ERROR("fail to parse svf command");
 				return ERROR_FAIL;
 			case '(':
-				in_bracket = 1;
-				goto parse_char;
+				in_bracket = true;
+				break;
 			case ')':
-				in_bracket = 0;
-				goto parse_char;
+				in_bracket = false;
+				break;
 			default:
-parse_char:
-				if (!in_bracket && isspace((int) str[pos])) {
-					space_found = 1;
-					str[pos] = '\0';
-				} else if (space_found) {
-					argus[num++] = &str[pos];
-					space_found = 0;
-				}
 				break;
 		}
+
+		if (!in_bracket && isspace((int)str[pos])) {
+			space_found = true;
+			str[pos] = '\0';
+		} else if (space_found) {
+			argus[num++] = &str[pos];
+			space_found = false;
+		}
+
 		pos++;
 	}
 

-- 

[PATCH]: 37ff68cc3e rtos: linux: align switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9038

-- gerrit

commit 37ff68cc3ea859ff0b65e64de4caa6423251be33
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jun 28 01:21:00 2025 +0200

    rtos: linux: align switch and case statements
    
    The coding style requires the 'case' to be at the same indentation
    level of its 'switch' statement.
    
    Align the code accordingly.
    
    No changes are reported by
            git log -p -w --ignore-blank-lines --patience
    
    Change-Id: Ic4070571d322776b638a15a40af85cd31fdae7ce
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/rtos/linux.c b/src/rtos/linux.c
index 785be13fd8..5f59dc883a 100644
--- a/src/rtos/linux.c
+++ b/src/rtos/linux.c
@@ -1282,76 +1282,77 @@ static int linux_thread_packet(struct connection *connection, char const *packet
 		target->rtos->rtos_specific_params;
 
 	switch (packet[0]) {
-		case 'T':		/* Is thread alive?*/
-
-			linux_gdb_t_packet(connection, target, packet, packet_size);
-			break;
-		case 'H':		/* Set current thread */
-			/*  ( 'c' for step and continue, 'g' for all other operations )*/
-			/*LOG_INFO(" H packet received '%s'", packet);*/
-			linux_gdb_h_packet(connection, target, packet, packet_size);
-			break;
-		case 'q':
-
-			if (!strncmp(packet, "qSymbol", 7)) {
-				if (rtos_qsymbol(connection, packet, packet_size) == 1) {
-					linux_compute_virt2phys(target,
-							target->rtos->symbols[INIT_TASK].address);
-				}
-			} else if (!strncmp(packet, "qfThreadInfo", 12)) {
-				if (!linux_os->thread_list) {
-					retval = linux_gdb_thread_packet(target,
-							connection,
-							packet,
-							packet_size);
-				} else {
-					retval = linux_gdb_thread_update(target,
-							connection,
-							packet,
-							packet_size);
-				}
-			} else if (!strncmp(packet, "qsThreadInfo", 12)) {
-				gdb_put_packet(connection, "l", 1);
-			} else if (!strncmp(packet, "qThreadExtraInfo,", 17)) {
-				linux_thread_extra_info(target, connection, packet,
+	case 'T':		/* Is thread alive?*/
+		linux_gdb_t_packet(connection, target, packet, packet_size);
+		break;
+
+	case 'H':		/* Set current thread */
+		/*  ( 'c' for step and continue, 'g' for all other operations )*/
+		/*LOG_INFO(" H packet received '%s'", packet);*/
+		linux_gdb_h_packet(connection, target, packet, packet_size);
+		break;
+
+	case 'q':
+		if (!strncmp(packet, "qSymbol", 7)) {
+			if (rtos_qsymbol(connection, packet, packet_size) == 1) {
+				linux_compute_virt2phys(target,
+						target->rtos->symbols[INIT_TASK].address);
+			}
+		} else if (!strncmp(packet, "qfThreadInfo", 12)) {
+			if (!linux_os->thread_list) {
+				retval = linux_gdb_thread_packet(target,
+						connection,
+						packet,
 						packet_size);
 			} else {
-				retval = GDB_THREAD_PACKET_NOT_CONSUMED;
+				retval = linux_gdb_thread_update(target,
+						connection,
+						packet,
+						packet_size);
 			}
-			break;
-
-		case 'Q':
-			/* previously response was : thread not found
-			 * gdb_put_packet(connection, "E01", 3); */
+		} else if (!strncmp(packet, "qsThreadInfo", 12)) {
+			gdb_put_packet(connection, "l", 1);
+		} else if (!strncmp(packet, "qThreadExtraInfo,", 17)) {
+			linux_thread_extra_info(target, connection, packet,
+					packet_size);
+		} else {
 			retval = GDB_THREAD_PACKET_NOT_CONSUMED;
-			break;
-		case 'c':
-		case 's':
-			if (linux_os->threads_lookup == 1) {
-				ct = linux_os->current_threads;
+		}
+		break;
 
-				while ((ct) && (ct->core_id) != target->coreid)
-					ct = ct->next;
+	case 'Q':
+		/* previously response was : thread not found
+		 * gdb_put_packet(connection, "E01", 3); */
+		retval = GDB_THREAD_PACKET_NOT_CONSUMED;
+		break;
 
-				if ((ct) && (ct->threadid == -1)) {
-					ct = linux_os->current_threads;
+	case 'c':
+	case 's':
+		if (linux_os->threads_lookup == 1) {
+			ct = linux_os->current_threads;
 
-					while ((ct) && (ct->threadid == -1))
-						ct = ct->next;
-				}
+			while ((ct) && (ct->core_id) != target->coreid)
+				ct = ct->next;
 
-				if ((ct) && (ct->threadid !=
-						 target->rtos->current_threadid)
-				&& (target->rtos->current_threadid != -1))
-					LOG_WARNING("WARNING! current GDB thread do not match "
-							"current thread running. "
-							"Switch thread in GDB to threadid %d",
-							(int)ct->threadid);
+			if ((ct) && (ct->threadid == -1)) {
+				ct = linux_os->current_threads;
 
-				LOG_INFO("threads_needs_update = 1");
-				linux_os->threads_needs_update = 1;
+				while ((ct) && (ct->threadid == -1))
+					ct = ct->next;
 			}
-			break;
+
+			if ((ct) && (ct->threadid !=
+					 target->rtos->current_threadid)
+			&& (target->rtos->current_threadid != -1))
+				LOG_WARNING("WARNING! current GDB thread do not match "
+						"current thread running. "
+						"Switch thread in GDB to threadid %d",
+						(int)ct->threadid);
+
+			LOG_INFO("threads_needs_update = 1");
+			linux_os->threads_needs_update = 1;
+		}
+		break;
 	}
 
 	return retval;

-- 

[PATCH]: f541252c18 rtos: linux: prepare for aligning switch and case statements

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9037

-- gerrit

commit f541252c184adc60b452d8fd078ee7fba5dee79a
Author: Antonio Borneo <bor...@gm...>
Date:   Sat Jun 28 14:02:50 2025 +0200

    rtos: linux: prepare for aligning switch and case statements
    
    To prepare for aligning switch and case statements, fix in advance
    some checkpatch error due to existing code:
    - fix useless 'else' after 'break', by moving the 'break'
      statement.
    
    While there:
    - modify the checks on strncmp().
    
    Change-Id: I123f3c0e3999669440845c946e4839d7288e8d91
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/rtos/linux.c b/src/rtos/linux.c
index 7ee97668ef..785be13fd8 100644
--- a/src/rtos/linux.c
+++ b/src/rtos/linux.c
@@ -1293,38 +1293,32 @@ static int linux_thread_packet(struct connection *connection, char const *packet
 			break;
 		case 'q':
 
-			if (strncmp(packet, "qSymbol", 7) == 0) {
+			if (!strncmp(packet, "qSymbol", 7)) {
 				if (rtos_qsymbol(connection, packet, packet_size) == 1) {
 					linux_compute_virt2phys(target,
 							target->rtos->symbols[INIT_TASK].address);
 				}
-
-				break;
-			} else if (strncmp(packet, "qfThreadInfo", 12) == 0) {
+			} else if (!strncmp(packet, "qfThreadInfo", 12)) {
 				if (!linux_os->thread_list) {
 					retval = linux_gdb_thread_packet(target,
 							connection,
 							packet,
 							packet_size);
-					break;
 				} else {
 					retval = linux_gdb_thread_update(target,
 							connection,
 							packet,
 							packet_size);
-					break;
 				}
-			} else if (strncmp(packet, "qsThreadInfo", 12) == 0) {
+			} else if (!strncmp(packet, "qsThreadInfo", 12)) {
 				gdb_put_packet(connection, "l", 1);
-				break;
-			} else if (strncmp(packet, "qThreadExtraInfo,", 17) == 0) {
+			} else if (!strncmp(packet, "qThreadExtraInfo,", 17)) {
 				linux_thread_extra_info(target, connection, packet,
 						packet_size);
-				break;
 			} else {
 				retval = GDB_THREAD_PACKET_NOT_CONSUMED;
-				break;
 			}
+			break;
 
 		case 'Q':
 			/* previously response was : thread not found

-- 

[PATCH]: 19a08b49ea svf: drop goto and label in switch statement

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9041

-- gerrit

commit 19a08b49ea6816f0a8080bc17d8fceb055e8245f
Author: Antonio Borneo <bor...@gm...>
Date:   Sun Jun 29 23:15:54 2025 +0200

    svf: drop goto and label in switch statement
    
    Drop the jumps to the label thanks to the factorized code.
    Drop the now unused label.
    
    Change-Id: I7e61ecee5a883a6ed6b77bfbff54a615d1b4d61c
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/svf/svf.c b/src/svf/svf.c
index d0a8563dd2..5c87f895a0 100644
--- a/src/svf/svf.c
+++ b/src/svf/svf.c
@@ -1271,7 +1271,7 @@ static int svf_xxr_common(char **argus, int num_of_argu, char command, struct sv
 static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 {
 	char *argus[256], command;
-	int num_of_argu = 0, i;
+	int num_of_argu = 0, i, retval;
 
 	/* tmp variable */
 	int i_tmp;
@@ -1279,8 +1279,6 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 	/* for RUNTEST */
 	int run_count;
 	float min_time;
-	/* for XXR */
-	struct svf_xxr_para *xxr_para_tmp;
 	/* for STATE */
 	enum tap_state *path = NULL, state;
 	/* flag padding commands skipped due to -tap command */
@@ -1351,37 +1349,44 @@ static int svf_run_command(struct command_context *cmd_ctx, char *cmd_str)
 				padding_command_skipped = 1;
 				break;
 			}
-			xxr_para_tmp = &svf_para.hdr_para;
-			goto xxr_common;
+			retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.hdr_para);
+			if (retval != ERROR_OK)
+				return retval;
+			break;
 		case HIR:
 			if (svf_tap_is_specified) {
 				padding_command_skipped = 1;
 				break;
 			}
-			xxr_para_tmp = &svf_para.hir_para;
-			goto xxr_common;
+			retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.hir_para);
+			if (retval != ERROR_OK)
+				return retval;
+			break;
 		case TDR:
 			if (svf_tap_is_specified) {
 				padding_command_skipped = 1;
 				break;
 			}
-			xxr_para_tmp = &svf_para.tdr_para;
-			goto xxr_common;
+			retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.tdr_para);
+			if (retval != ERROR_OK)
+				return retval;
+			break;
 		case TIR:
 			if (svf_tap_is_specified) {
 				padding_command_skipped = 1;
 				break;
 			}
-			xxr_para_tmp = &svf_para.tir_para;
-			goto xxr_common;
+			retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.tir_para);
+			if (retval != ERROR_OK)
+				return retval;
+			break;
 		case SDR:
-			xxr_para_tmp = &svf_para.sdr_para;
-			goto xxr_common;
+			retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.sdr_para);
+			if (retval != ERROR_OK)
+				return retval;
+			break;
 		case SIR:
-			xxr_para_tmp = &svf_para.sir_para;
-			goto xxr_common;
-xxr_common:
-			int retval = svf_xxr_common(argus, num_of_argu, command, xxr_para_tmp);
+			retval = svf_xxr_common(argus, num_of_argu, command, &svf_para.sir_para);
 			if (retval != ERROR_OK)
 				return retval;
 			break;

-- 

[PATCH]: c3cddf1bc4 flash: nor: jtagspi: invert the operands in check

[<ge...@op...>]

This is an automated email from Gerrit.

"Antonio Borneo <bor...@gm...>" just uploaded a new patch set to Gerrit, which you can find at https://review.openocd.org/c/openocd/+/9035

-- gerrit

commit c3cddf1bc443b7c4cee4eaa376f50b9dbc773859
Author: Antonio Borneo <bor...@gm...>
Date:   Fri Jul 25 20:07:27 2025 +0200

    flash: nor: jtagspi: invert the operands in check
    
    Check the variable against the constant.
    No functional change.
    
    Change-Id: Ie3138e516f4b81bf544780981863e856f8ffc528
    Signed-off-by: Antonio Borneo <bor...@gm...>

diff --git a/src/flash/nor/jtagspi.c b/src/flash/nor/jtagspi.c
index 4b975390be..e1bb17ab1f 100644
--- a/src/flash/nor/jtagspi.c
+++ b/src/flash/nor/jtagspi.c
@@ -230,7 +230,7 @@ COMMAND_HANDLER(jtagspi_handle_set)
 	*/
 	retval = CALL_COMMAND_HANDLER(flash_command_get_bank_probe_optional, 0,
 		&bank, false);
-	if (ERROR_OK != retval)
+	if (retval != ERROR_OK)
 		return retval;
 	info = bank->driver_priv;
 
@@ -420,7 +420,7 @@ COMMAND_HANDLER(jtagspi_handle_always_4byte)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
 	retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
-	if (ERROR_OK != retval)
+	if (retval != ERROR_OK)
 		return retval;
 
 	jtagspi_info = bank->driver_priv;

--