diff --git a/src/jtag/drivers/amt_jtagaccel.c b/src/jtag/drivers/amt_jtagaccel.c index d3f8bb61e..6f1718896 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 9d8c592ed..5c0e2ea94 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; + 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); + case JTAG_RESET: + LOG_DEBUG_IO("reset trst: %i srst %i", + cmd->cmd.reset->trst, + cmd->cmd.reset->srst); - armjtagew_tap_execute(); + 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; + 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; + 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); + 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 c2e763ddb..ebf38c7fa 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_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_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_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 4283616ad..7eab94bd0 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 3e1a3c5f0..e5e82d13d 100644 --- a/src/jtag/drivers/cmsis_dap.c +++ b/src/jtag/drivers/cmsis_dap.c @@ -1566,38 +1566,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 @@ -1938,32 +1938,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 c1eb5b80d..0f1b58299 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); + 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); + *data = dmem_emu_get_ap_reg(addr); - break; - case ADIV5_MEM_AP_REG_DRW: - addr = ap_info->apbap_tar; + break; + case ADIV5_MEM_AP_REG_DRW: + addr = ap_info->apbap_tar; - *data = dmem_emu_get_ap_reg(addr); + *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; + 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_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_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); + 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); + 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); + 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; + 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 8f7ae13d6..5bd934c38 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); + 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); + 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; + 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)); + 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; + 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_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)); + 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; + 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])); + 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; + 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)); + 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; + 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); + case JTAG_SLEEP: + LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us); - jtag_sleep(cmd->cmd.sleep->us); - break; + 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_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 a8f6f6015..00b3d198b 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 98f775422..f6ae684f7 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 b8716fa9a..46afa862d 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 2bb4d17da..f79e2dca7 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 04626cb1e..4b5981ab5 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); - break; + 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; - - default: - return ERROR_COMMAND_SYNTAX_ERROR; - } + 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; } 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 943ad854e..d45a1c6a9 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; + 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: %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; + 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 449c61654..71ec572b3 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 9622740c6..83c6d6853 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_COMMENT: + break; - case DTCLOAD_ENTRY: - /* store entry addresses somewhere */ - if (!strncmp("download", (char *)buffer + 1, 8)) - dtc_entry_download = buffer[0]; - 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; + 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; + /* 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; + 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; + 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; + break; - case DTCLOAD_LUT_START: - lut_start = buffer[0]; - 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; + 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; + 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; + 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; + 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 70a73eeb9..b4d21100c 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 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; } } @@ -1597,31 +1597,31 @@ static int stlink_usb_mode_enter(void *handle, enum stlink_mode type) stlink_usb_init_buffer(handle, h->rx_ep, rx_size); switch (type) { - case STLINK_MODE_DEBUG_JTAG: - h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; - if (h->version.jtag_api == STLINK_JTAG_API_V1) - h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_ENTER; - else - h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_ENTER; - h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_ENTER_JTAG_NO_RESET; - break; - case STLINK_MODE_DEBUG_SWD: - h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; - if (h->version.jtag_api == STLINK_JTAG_API_V1) - h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_ENTER; - else - h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_ENTER; - h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_ENTER_SWD_NO_RESET; - break; - case STLINK_MODE_DEBUG_SWIM: - h->cmdbuf[h->cmdidx++] = STLINK_SWIM_COMMAND; - h->cmdbuf[h->cmdidx++] = STLINK_SWIM_ENTER; - /* swim enter does not return any response or status */ - return stlink_usb_xfer_noerrcheck(handle, h->databuf, 0); - case STLINK_MODE_DFU: - case STLINK_MODE_MASS: - default: - return ERROR_FAIL; + case STLINK_MODE_DEBUG_JTAG: + h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; + if (h->version.jtag_api == STLINK_JTAG_API_V1) + h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_ENTER; + else + h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_ENTER; + h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_ENTER_JTAG_NO_RESET; + break; + case STLINK_MODE_DEBUG_SWD: + h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; + if (h->version.jtag_api == STLINK_JTAG_API_V1) + h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_ENTER; + else + h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_ENTER; + h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_ENTER_SWD_NO_RESET; + break; + case STLINK_MODE_DEBUG_SWIM: + h->cmdbuf[h->cmdidx++] = STLINK_SWIM_COMMAND; + h->cmdbuf[h->cmdidx++] = STLINK_SWIM_ENTER; + /* swim enter does not return any response or status */ + return stlink_usb_xfer_noerrcheck(handle, h->databuf, 0); + case STLINK_MODE_DFU: + case STLINK_MODE_MASS: + default: + return ERROR_FAIL; } return stlink_cmd_allow_retry(handle, h->databuf, rx_size); @@ -1639,22 +1639,22 @@ static int stlink_usb_mode_leave(void *handle, enum stlink_mode type) stlink_usb_init_buffer(handle, h->rx_ep, 0); switch (type) { - case STLINK_MODE_DEBUG_JTAG: - case STLINK_MODE_DEBUG_SWD: - h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; - h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_EXIT; - break; - case STLINK_MODE_DEBUG_SWIM: - h->cmdbuf[h->cmdidx++] = STLINK_SWIM_COMMAND; - h->cmdbuf[h->cmdidx++] = STLINK_SWIM_EXIT; - break; - case STLINK_MODE_DFU: - h->cmdbuf[h->cmdidx++] = STLINK_DFU_COMMAND; - h->cmdbuf[h->cmdidx++] = STLINK_DFU_EXIT; - break; - case STLINK_MODE_MASS: - default: - return ERROR_FAIL; + case STLINK_MODE_DEBUG_JTAG: + case STLINK_MODE_DEBUG_SWD: + h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; + h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_EXIT; + break; + case STLINK_MODE_DEBUG_SWIM: + h->cmdbuf[h->cmdidx++] = STLINK_SWIM_COMMAND; + h->cmdbuf[h->cmdidx++] = STLINK_SWIM_EXIT; + break; + case STLINK_MODE_DFU: + h->cmdbuf[h->cmdidx++] = STLINK_DFU_COMMAND; + h->cmdbuf[h->cmdidx++] = STLINK_DFU_EXIT; + break; + case STLINK_MODE_MASS: + default: + return ERROR_FAIL; } res = stlink_usb_xfer_noerrcheck(handle, h->databuf, 0); @@ -1697,20 +1697,20 @@ static int stlink_usb_exit_mode(void *handle) /* try to exit current mode */ switch (mode) { - case STLINK_DEV_DFU_MODE: - emode = STLINK_MODE_DFU; - break; - case STLINK_DEV_DEBUG_MODE: - emode = STLINK_MODE_DEBUG_SWD; - break; - case STLINK_DEV_SWIM_MODE: - emode = STLINK_MODE_DEBUG_SWIM; - break; - case STLINK_DEV_BOOTLOADER_MODE: - case STLINK_DEV_MASS_MODE: - default: - emode = STLINK_MODE_UNKNOWN; - break; + case STLINK_DEV_DFU_MODE: + emode = STLINK_MODE_DFU; + break; + case STLINK_DEV_DEBUG_MODE: + emode = STLINK_MODE_DEBUG_SWD; + break; + case STLINK_DEV_SWIM_MODE: + emode = STLINK_MODE_DEBUG_SWIM; + break; + case STLINK_DEV_BOOTLOADER_MODE: + case STLINK_DEV_MASS_MODE: + default: + emode = STLINK_MODE_UNKNOWN; + break; } if (emode != STLINK_MODE_UNKNOWN) @@ -3430,34 +3430,34 @@ static int stlink_usb_usb_open(void *handle, struct hl_interface_param *param) /* wrap version for first read */ switch (pid) { - case STLINK_V1_PID: - h->version.stlink = 1; - h->tx_ep = STLINK_TX_EP; - break; - case STLINK_V3_USBLOADER_PID: - case STLINK_V3E_PID: - case STLINK_V3S_PID: - case STLINK_V3_2VCP_PID: - case STLINK_V3E_NO_MSD_PID: - case STLINK_V3P_USBLOADER_PID: - case STLINK_V3P_PID: - h->version.stlink = 3; - h->tx_ep = STLINK_V2_1_TX_EP; - h->trace_ep = STLINK_V2_1_TRACE_EP; - break; - case STLINK_V2_1_PID: - case STLINK_V2_1_NO_MSD_PID: - h->version.stlink = 2; - h->tx_ep = STLINK_V2_1_TX_EP; - h->trace_ep = STLINK_V2_1_TRACE_EP; - break; - default: - /* fall through - we assume V2 to be the default version*/ - case STLINK_V2_PID: - h->version.stlink = 2; - h->tx_ep = STLINK_TX_EP; - h->trace_ep = STLINK_TRACE_EP; - break; + case STLINK_V1_PID: + h->version.stlink = 1; + h->tx_ep = STLINK_TX_EP; + break; + case STLINK_V3_USBLOADER_PID: + case STLINK_V3E_PID: + case STLINK_V3S_PID: + case STLINK_V3_2VCP_PID: + case STLINK_V3E_NO_MSD_PID: + case STLINK_V3P_USBLOADER_PID: + case STLINK_V3P_PID: + h->version.stlink = 3; + h->tx_ep = STLINK_V2_1_TX_EP; + h->trace_ep = STLINK_V2_1_TRACE_EP; + break; + case STLINK_V2_1_PID: + case STLINK_V2_1_NO_MSD_PID: + h->version.stlink = 2; + h->tx_ep = STLINK_V2_1_TX_EP; + h->trace_ep = STLINK_V2_1_TRACE_EP; + break; + default: + /* fall through - we assume V2 to be the default version */ + case STLINK_V2_PID: + h->version.stlink = 2; + h->tx_ep = STLINK_TX_EP; + h->trace_ep = STLINK_TRACE_EP; + break; } /* get the device version */ @@ -3758,21 +3758,21 @@ static int stlink_open(struct hl_interface_param *param, enum stlink_mode mode, int err = ERROR_OK; switch (h->st_mode) { - case STLINK_MODE_DEBUG_SWD: - if (h->version.jtag_api == STLINK_JTAG_API_V1) - err = ERROR_FAIL; - /* fall-through */ - case STLINK_MODE_DEBUG_JTAG: - if (h->version.jtag == 0) - err = ERROR_FAIL; - break; - case STLINK_MODE_DEBUG_SWIM: - if (h->version.swim == 0) - err = ERROR_FAIL; - break; - default: + case STLINK_MODE_DEBUG_SWD: + if (h->version.jtag_api == STLINK_JTAG_API_V1) err = ERROR_FAIL; - break; + /* fall-through */ + case STLINK_MODE_DEBUG_JTAG: + if (h->version.jtag == 0) + err = ERROR_FAIL; + break; + case STLINK_MODE_DEBUG_SWIM: + if (h->version.swim == 0) + err = ERROR_FAIL; + break; + default: + err = ERROR_FAIL; + break; } if (err != ERROR_OK) { diff --git a/src/jtag/drivers/ti_icdi_usb.c b/src/jtag/drivers/ti_icdi_usb.c index 0e01171ea..9f0791f3d 100644 --- a/src/jtag/drivers/ti_icdi_usb.c +++ b/src/jtag/drivers/ti_icdi_usb.c @@ -692,14 +692,14 @@ static int icdi_usb_open(struct hl_interface_param *param, void **fd) switch (param->transport) { #if 0 - /* TODO place holder as swd is not currently supported */ - case HL_TRANSPORT_SWD: + /* TODO place holder as swd is not currently supported */ + case HL_TRANSPORT_SWD: #endif - case HL_TRANSPORT_JTAG: - break; - default: - retval = ERROR_FAIL; - break; + case HL_TRANSPORT_JTAG: + break; + default: + retval = ERROR_FAIL; + break; } if (retval != ERROR_OK) { diff --git a/src/jtag/drivers/ulink.c b/src/jtag/drivers/ulink.c index 30778a1d8..93b862926 100644 --- a/src/jtag/drivers/ulink.c +++ b/src/jtag/drivers/ulink.c @@ -523,30 +523,30 @@ static int ulink_allocate_payload(struct ulink_cmd *ulink_cmd, int size, } switch (direction) { - case PAYLOAD_DIRECTION_OUT: - if (ulink_cmd->payload_out) { - LOG_ERROR("BUG: Duplicate payload allocation for OpenULINK command"); - free(payload); - return ERROR_FAIL; - } - 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; - } - ulink_cmd->payload_in_start = payload; - ulink_cmd->payload_in = payload; - ulink_cmd->payload_in_size = size; + case PAYLOAD_DIRECTION_OUT: + if (ulink_cmd->payload_out) { + LOG_ERROR("BUG: Duplicate payload allocation for OpenULINK command"); + free(payload); + return ERROR_FAIL; + } + 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; + } + 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; + /* 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; } return ERROR_OK; @@ -570,12 +570,12 @@ static int ulink_get_queue_size(struct ulink *device, while (current) { switch (direction) { - case PAYLOAD_DIRECTION_OUT: - sum += current->payload_out_size + 1; /* + 1 byte for Command ID */ - break; - case PAYLOAD_DIRECTION_IN: - sum += current->payload_in_size; - break; + case PAYLOAD_DIRECTION_OUT: + sum += current->payload_out_size + 1; /* + 1 byte for Command ID */ + break; + case PAYLOAD_DIRECTION_IN: + sum += current->payload_in_size; + break; } current = current->next; @@ -879,31 +879,31 @@ static int ulink_append_scan_cmd(struct ulink *device, enum scan_type scan_type, /* Allocate out_payload depending on scan type */ switch (scan_type) { - case SCAN_IN: - if (device->delay_scan_in < 0) - cmd->id = CMD_SCAN_IN; - else - cmd->id = CMD_SLOW_SCAN_IN; - ret = ulink_allocate_payload(cmd, 5, PAYLOAD_DIRECTION_OUT); - break; - case SCAN_OUT: - if (device->delay_scan_out < 0) - cmd->id = CMD_SCAN_OUT; - else - cmd->id = CMD_SLOW_SCAN_OUT; - ret = ulink_allocate_payload(cmd, scan_size_bytes + 5, PAYLOAD_DIRECTION_OUT); - break; - case SCAN_IO: - if (device->delay_scan_io < 0) - cmd->id = CMD_SCAN_IO; - else - cmd->id = CMD_SLOW_SCAN_IO; - ret = ulink_allocate_payload(cmd, scan_size_bytes + 5, PAYLOAD_DIRECTION_OUT); - break; - default: - LOG_ERROR("BUG: %s() encountered an unknown scan type", __func__); - ret = ERROR_FAIL; - break; + case SCAN_IN: + if (device->delay_scan_in < 0) + cmd->id = CMD_SCAN_IN; + else + cmd->id = CMD_SLOW_SCAN_IN; + ret = ulink_allocate_payload(cmd, 5, PAYLOAD_DIRECTION_OUT); + break; + case SCAN_OUT: + if (device->delay_scan_out < 0) + cmd->id = CMD_SCAN_OUT; + else + cmd->id = CMD_SLOW_SCAN_OUT; + ret = ulink_allocate_payload(cmd, scan_size_bytes + 5, PAYLOAD_DIRECTION_OUT); + break; + case SCAN_IO: + if (device->delay_scan_io < 0) + cmd->id = CMD_SCAN_IO; + else + cmd->id = CMD_SLOW_SCAN_IO; + ret = ulink_allocate_payload(cmd, scan_size_bytes + 5, PAYLOAD_DIRECTION_OUT); + break; + default: + LOG_ERROR("BUG: %s() encountered an unknown scan type", __func__); + ret = ERROR_FAIL; + break; } if (ret != ERROR_OK) { @@ -1821,18 +1821,18 @@ static int ulink_post_process_scan(struct ulink_cmd *ulink_cmd) int ret; switch (jtag_scan_type(cmd->cmd.scan)) { - case SCAN_IN: - case SCAN_IO: - ret = jtag_read_buffer(ulink_cmd->payload_in_start, cmd->cmd.scan); - break; - case SCAN_OUT: - /* Nothing to do for OUT scans */ - ret = ERROR_OK; - break; - default: - LOG_ERROR("BUG: %s() encountered an unknown JTAG scan type", __func__); - ret = ERROR_FAIL; - break; + case SCAN_IN: + case SCAN_IO: + ret = jtag_read_buffer(ulink_cmd->payload_in_start, cmd->cmd.scan); + break; + case SCAN_OUT: + /* Nothing to do for OUT scans */ + ret = ERROR_OK; + break; + default: + LOG_ERROR("BUG: %s() encountered an unknown JTAG scan type", __func__); + ret = ERROR_FAIL; + break; } return ret; @@ -1860,22 +1860,22 @@ static int ulink_post_process_queue(struct ulink *device) * OpenULINK command */ if (current->needs_postprocessing && openocd_cmd) { switch (openocd_cmd->type) { - case JTAG_SCAN: - ret = ulink_post_process_scan(current); - break; - case JTAG_TLR_RESET: - case JTAG_RUNTEST: - case JTAG_RESET: - case JTAG_PATHMOVE: - case JTAG_SLEEP: - case JTAG_STABLECLOCKS: - /* Nothing to do for these commands */ - ret = ERROR_OK; - break; - default: - ret = ERROR_FAIL; - LOG_ERROR("BUG: %s() encountered unknown JTAG command type", __func__); - break; + case JTAG_SCAN: + ret = ulink_post_process_scan(current); + break; + case JTAG_TLR_RESET: + case JTAG_RUNTEST: + case JTAG_RESET: + case JTAG_PATHMOVE: + case JTAG_SLEEP: + case JTAG_STABLECLOCKS: + /* Nothing to do for these commands */ + ret = ERROR_OK; + break; + default: + ret = ERROR_FAIL; + LOG_ERROR("BUG: %s() encountered unknown JTAG command type", __func__); + break; } if (ret != ERROR_OK) @@ -1909,31 +1909,31 @@ static int ulink_execute_queue(struct jtag_command *cmd_queue) while (cmd) { switch (cmd->type) { - case JTAG_SCAN: - ret = ulink_queue_scan(ulink_handle, cmd); - break; - case JTAG_TLR_RESET: - ret = ulink_queue_tlr_reset(ulink_handle, cmd); - break; - case JTAG_RUNTEST: - ret = ulink_queue_runtest(ulink_handle, cmd); - break; - case JTAG_RESET: - ret = ulink_queue_reset(ulink_handle, cmd); - break; - case JTAG_PATHMOVE: - ret = ulink_queue_pathmove(ulink_handle, cmd); - break; - case JTAG_SLEEP: - ret = ulink_queue_sleep(ulink_handle, cmd); - break; - case JTAG_STABLECLOCKS: - ret = ulink_queue_stableclocks(ulink_handle, cmd); - break; - default: - ret = ERROR_FAIL; - LOG_ERROR("BUG: encountered unknown JTAG command type"); - break; + case JTAG_SCAN: + ret = ulink_queue_scan(ulink_handle, cmd); + break; + case JTAG_TLR_RESET: + ret = ulink_queue_tlr_reset(ulink_handle, cmd); + break; + case JTAG_RUNTEST: + ret = ulink_queue_runtest(ulink_handle, cmd); + break; + case JTAG_RESET: + ret = ulink_queue_reset(ulink_handle, cmd); + break; + case JTAG_PATHMOVE: + ret = ulink_queue_pathmove(ulink_handle, cmd); + break; + case JTAG_SLEEP: + ret = ulink_queue_sleep(ulink_handle, cmd); + break; + case JTAG_STABLECLOCKS: + ret = ulink_queue_stableclocks(ulink_handle, cmd); + break; + default: + ret = ERROR_FAIL; + LOG_ERROR("BUG: encountered unknown JTAG command type"); + break; } if (ret != ERROR_OK) diff --git a/src/jtag/drivers/usbprog.c b/src/jtag/drivers/usbprog.c index 264b45f72..4783e7569 100644 --- a/src/jtag/drivers/usbprog.c +++ b/src/jtag/drivers/usbprog.c @@ -274,18 +274,18 @@ static void usbprog_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int void (*f)(struct usbprog_jtag *usbprog_jtag, char *buffer_local, int size); switch (type) { - case SCAN_OUT: - f = &usbprog_jtag_write_tdi; - break; - case SCAN_IN: - f = &usbprog_jtag_read_tdo; - break; - case SCAN_IO: - f = &usbprog_jtag_write_and_read; - break; - default: - LOG_ERROR("unknown scan type: %i", type); - exit(-1); + case SCAN_OUT: + f = &usbprog_jtag_write_tdi; + break; + case SCAN_IN: + f = &usbprog_jtag_read_tdo; + break; + case SCAN_IO: + f = &usbprog_jtag_write_and_read; + break; + default: + LOG_ERROR("unknown scan type: %i", type); + exit(-1); } f(usbprog_jtag_handle, (char *)buffer, scan_size); diff --git a/src/jtag/drivers/xds110.c b/src/jtag/drivers/xds110.c index 6b3ca5cfb..a2b0dd213 100644 --- a/src/jtag/drivers/xds110.c +++ b/src/jtag/drivers/xds110.c @@ -1551,42 +1551,42 @@ static void xds110_flush(void) while (xds110.txn_requests[request] != 0) { command = xds110.txn_requests[request++]; switch (command) { - case CMD_IR_SCAN: - case CMD_DR_SCAN: - if (command == CMD_IR_SCAN) - shift_state = XDS_JTAG_STATE_SHIFT_IR; - else - shift_state = XDS_JTAG_STATE_SHIFT_DR; - end_state = (uint32_t)(xds110.txn_requests[request++]); - bits = (uint32_t)(xds110.txn_requests[request++]) << 0; - bits |= (uint32_t)(xds110.txn_requests[request++]) << 8; - data_out = &xds110.txn_requests[request]; - bytes = DIV_ROUND_UP(bits, 8); - xds110_legacy_scan(shift_state, bits, end_state, data_out, - &data_in[result]); - result += bytes; - request += bytes; - break; - case CMD_RUNTEST: - clocks = (uint32_t)(xds110.txn_requests[request++]) << 0; - clocks |= (uint32_t)(xds110.txn_requests[request++]) << 8; - clocks |= (uint32_t)(xds110.txn_requests[request++]) << 16; - clocks |= (uint32_t)(xds110.txn_requests[request++]) << 24; - end_state = (uint32_t)xds110.txn_requests[request++]; - xds110_legacy_runtest(clocks, end_state); - break; - case CMD_STABLECLOCKS: - clocks = (uint32_t)(xds110.txn_requests[request++]) << 0; - clocks |= (uint32_t)(xds110.txn_requests[request++]) << 8; - clocks |= (uint32_t)(xds110.txn_requests[request++]) << 16; - clocks |= (uint32_t)(xds110.txn_requests[request++]) << 24; - xds110_legacy_stableclocks(clocks); - break; - default: - LOG_ERROR("BUG: unknown JTAG command type 0x%x encountered", - command); - exit(-1); - break; + case CMD_IR_SCAN: + case CMD_DR_SCAN: + if (command == CMD_IR_SCAN) + shift_state = XDS_JTAG_STATE_SHIFT_IR; + else + shift_state = XDS_JTAG_STATE_SHIFT_DR; + end_state = (uint32_t)(xds110.txn_requests[request++]); + bits = (uint32_t)(xds110.txn_requests[request++]) << 0; + bits |= (uint32_t)(xds110.txn_requests[request++]) << 8; + data_out = &xds110.txn_requests[request]; + bytes = DIV_ROUND_UP(bits, 8); + xds110_legacy_scan(shift_state, bits, end_state, data_out, + &data_in[result]); + result += bytes; + request += bytes; + break; + case CMD_RUNTEST: + clocks = (uint32_t)(xds110.txn_requests[request++]) << 0; + clocks |= (uint32_t)(xds110.txn_requests[request++]) << 8; + clocks |= (uint32_t)(xds110.txn_requests[request++]) << 16; + clocks |= (uint32_t)(xds110.txn_requests[request++]) << 24; + end_state = (uint32_t)xds110.txn_requests[request++]; + xds110_legacy_runtest(clocks, end_state); + break; + case CMD_STABLECLOCKS: + clocks = (uint32_t)(xds110.txn_requests[request++]) << 0; + clocks |= (uint32_t)(xds110.txn_requests[request++]) << 8; + clocks |= (uint32_t)(xds110.txn_requests[request++]) << 16; + clocks |= (uint32_t)(xds110.txn_requests[request++]) << 24; + xds110_legacy_stableclocks(clocks); + break; + default: + LOG_ERROR("BUG: unknown JTAG command type 0x%x encountered", + command); + exit(-1); + break; } } } @@ -1809,32 +1809,32 @@ static void xds110_queue_stableclocks(struct jtag_command *cmd) static void xds110_execute_command(struct jtag_command *cmd) { switch (cmd->type) { - case JTAG_SLEEP: - xds110_flush(); - xds110_execute_sleep(cmd); - break; - case JTAG_TLR_RESET: - xds110_flush(); - xds110_execute_tlr_reset(cmd); - break; - case JTAG_PATHMOVE: - xds110_flush(); - xds110_execute_pathmove(cmd); - break; - case JTAG_SCAN: - xds110_queue_scan(cmd); - break; - case JTAG_RUNTEST: - xds110_queue_runtest(cmd); - break; - case JTAG_STABLECLOCKS: - xds110_queue_stableclocks(cmd); - break; - case JTAG_TMS: - default: - LOG_ERROR("BUG: unknown JTAG command type 0x%x encountered", - cmd->type); - exit(-1); + case JTAG_SLEEP: + xds110_flush(); + xds110_execute_sleep(cmd); + break; + case JTAG_TLR_RESET: + xds110_flush(); + xds110_execute_tlr_reset(cmd); + break; + case JTAG_PATHMOVE: + xds110_flush(); + xds110_execute_pathmove(cmd); + break; + case JTAG_SCAN: + xds110_queue_scan(cmd); + break; + case JTAG_RUNTEST: + xds110_queue_runtest(cmd); + break; + case JTAG_STABLECLOCKS: + xds110_queue_stableclocks(cmd); + break; + case JTAG_TMS: + default: + LOG_ERROR("BUG: unknown JTAG command type 0x%x encountered", + cmd->type); + exit(-1); } }