Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
jtag/swd: rename CamelCase macros
[openocd.git] / src / jtag / drivers / ftdi.c
diff --git a/src/jtag/drivers/ftdi.c b/src/jtag/drivers/ftdi.c
index 60387a98f9c6c8b379fe2121f99ce7fd695cf192..1a6ba590b8e00763baf7c72b25411654658b6fcd 100644 (file)
--- a/src/jtag/drivers/ftdi.c
+++ b/src/jtag/drivers/ftdi.c
@@ -74,6 +74,7 @@
 #include <jtag/swd.h>
 #include <transport/transport.h>
 #include <helper/time_support.h>
+#include <helper/log.h>
 
 #if IS_CYGWIN == 1
 #include <windows.h>
@@ -213,7 +214,7 @@ static int ftdi_set_signal(const struct signal *s, char value)
        return ERROR_OK;
 }
 
-static int ftdi_get_signal(const struct signal *s, uint16_t * value_out)
+static int ftdi_get_signal(const struct signal *s, uint16_t *value_out)
 {
        uint8_t data_low = 0;
        uint8_t data_high = 0;
@@ -482,7 +483,11 @@ static void ftdi_execute_scan(struct jtag_command *cmd)
                        uint8_t last_bit = 0;
                        if (field->out_value)
                                bit_copy(&last_bit, 0, field->out_value, field->num_bits - 1, 1);
-                       uint8_t tms_bits = 0x01;
+
+                       /* If endstate is TAP_IDLE, clock out 1-1-0 (->EXIT1 ->UPDATE ->IDLE)
+                        * Otherwise, clock out 1-0 (->EXIT1 ->PAUSE)
+                        */
+                       uint8_t tms_bits = 0x03;
                        mpsse_clock_tms_cs(mpsse_ctx,
                                        &tms_bits,
                                        0,
@@ -492,13 +497,24 @@ static void ftdi_execute_scan(struct jtag_command *cmd)
                                        last_bit,
                                        ftdi_jtag_mode);
                        tap_set_state(tap_state_transition(tap_get_state(), 1));
-                       mpsse_clock_tms_cs_out(mpsse_ctx,
-                                       &tms_bits,
-                                       1,
-                                       1,
-                                       last_bit,
-                                       ftdi_jtag_mode);
-                       tap_set_state(tap_state_transition(tap_get_state(), 0));
+                       if (tap_get_end_state() == TAP_IDLE) {
+                               mpsse_clock_tms_cs_out(mpsse_ctx,
+                                               &tms_bits,
+                                               1,
+                                               2,
+                                               last_bit,
+                                               ftdi_jtag_mode);
+                               tap_set_state(tap_state_transition(tap_get_state(), 1));
+                               tap_set_state(tap_state_transition(tap_get_state(), 0));
+                       } else {
+                               mpsse_clock_tms_cs_out(mpsse_ctx,
+                                               &tms_bits,
+                                               2,
+                                               1,
+                                               last_bit,
+                                               ftdi_jtag_mode);
+                               tap_set_state(tap_state_transition(tap_get_state(), 0));
+                       }
                } else
                        mpsse_clock_data(mpsse_ctx,
                                field->out_value,
@@ -517,55 +533,51 @@ static void ftdi_execute_scan(struct jtag_command *cmd)
                tap_state_name(tap_get_end_state()));
 }
 
-static void ftdi_execute_reset(struct jtag_command *cmd)
+static int ftdi_reset(int trst, int srst)
 {
-       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);
-
-       struct signal *trst = find_signal_by_name("nTRST");
-       if (cmd->cmd.reset->trst == 1) {
-               if (trst)
-                       ftdi_set_signal(trst, '0');
-               else
-                       LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
-       } else if (trst && jtag_get_reset_config() & RESET_HAS_TRST &&
-                       cmd->cmd.reset->trst == 0) {
-               if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN)
-                       ftdi_set_signal(trst, 'z');
-               else
-                       ftdi_set_signal(trst, '1');
+       struct signal *sig_ntrst = find_signal_by_name("nTRST");
+       struct signal *sig_nsrst = find_signal_by_name("nSRST");
+
+       LOG_DEBUG_IO("reset trst: %i srst %i", trst, srst);
+
+       if (!swd_mode) {
+               if (trst == 1) {
+                       if (sig_ntrst)
+                               ftdi_set_signal(sig_ntrst, '0');
+                       else
+                               LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
+               } else if (sig_ntrst && jtag_get_reset_config() & RESET_HAS_TRST &&
+                               trst == 0) {
+                       if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN)
+                               ftdi_set_signal(sig_ntrst, 'z');
+                       else
+                               ftdi_set_signal(sig_ntrst, '1');
+               }
        }
 
-       struct signal *srst = find_signal_by_name("nSRST");
-       if (cmd->cmd.reset->srst == 1) {
-               if (srst)
-                       ftdi_set_signal(srst, '0');
+       if (srst == 1) {
+               if (sig_nsrst)
+                       ftdi_set_signal(sig_nsrst, '0');
                else
                        LOG_ERROR("Can't assert SRST: nSRST signal is not defined");
-       } else if (srst && jtag_get_reset_config() & RESET_HAS_SRST &&
-                       cmd->cmd.reset->srst == 0) {
+       } else if (sig_nsrst && jtag_get_reset_config() & RESET_HAS_SRST &&
+                       srst == 0) {
                if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL)
-                       ftdi_set_signal(srst, '1');
+                       ftdi_set_signal(sig_nsrst, '1');
                else
-                       ftdi_set_signal(srst, 'z');
+                       ftdi_set_signal(sig_nsrst, 'z');
        }
 
-       LOG_DEBUG_IO("trst: %i, srst: %i",
-               cmd->cmd.reset->trst, cmd->cmd.reset->srst);
+       return mpsse_flush(mpsse_ctx);
 }
 
 static void ftdi_execute_sleep(struct jtag_command *cmd)
 {
-       LOG_DEBUG_IO("sleep %" PRIi32, cmd->cmd.sleep->us);
+       LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
 
        mpsse_flush(mpsse_ctx);
        jtag_sleep(cmd->cmd.sleep->us);
-       LOG_DEBUG_IO("sleep %" PRIi32 " usec while in %s",
+       LOG_DEBUG_IO("sleep %" PRIu32 " usec while in %s",
                cmd->cmd.sleep->us,
                tap_state_name(tap_get_state()));
 }
@@ -597,9 +609,6 @@ static void ftdi_execute_stableclocks(struct jtag_command *cmd)
 static void ftdi_execute_command(struct jtag_command *cmd)
 {
        switch (cmd->type) {
-               case JTAG_RESET:
-                       ftdi_execute_reset(cmd);
-                       break;
                case JTAG_RUNTEST:
                        ftdi_execute_runtest(cmd);
                        break;
@@ -656,6 +665,11 @@ static int ftdi_initialize(void)
        else
                LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
 
+       if (!ftdi_vid[0] && !ftdi_pid[0]) {
+               LOG_ERROR("Please specify ftdi_vid_pid");
+               return ERROR_JTAG_INIT_FAILED;
+       }
+
        for (int i = 0; ftdi_vid[i] || ftdi_pid[i]; i++) {
                mpsse_ctx = mpsse_open(&ftdi_vid[i], &ftdi_pid[i], ftdi_device_desc,
                                ftdi_serial, jtag_usb_get_location(), ftdi_channel);
@@ -713,8 +727,7 @@ static int ftdi_quit(void)
 COMMAND_HANDLER(ftdi_handle_device_desc_command)
 {
        if (CMD_ARGC == 1) {
-               if (ftdi_device_desc)
-                       free(ftdi_device_desc);
+               free(ftdi_device_desc);
                ftdi_device_desc = strdup(CMD_ARGV[0]);
        } else {
                LOG_ERROR("expected exactly one argument to ftdi_device_desc <description>");
@@ -726,8 +739,7 @@ COMMAND_HANDLER(ftdi_handle_device_desc_command)
 COMMAND_HANDLER(ftdi_handle_serial_command)
 {
        if (CMD_ARGC == 1) {
-               if (ftdi_serial)
-                       free(ftdi_serial);
+               free(ftdi_serial);
                ftdi_serial = strdup(CMD_ARGV[0]);
        } else {
                return ERROR_COMMAND_SYNTAX_ERROR;
@@ -914,22 +926,22 @@ COMMAND_HANDLER(ftdi_handle_vid_pid_command)
 
 COMMAND_HANDLER(ftdi_handle_tdo_sample_edge_command)
 {
-       Jim_Nvp *n;
-       static const Jim_Nvp nvp_ftdi_jtag_modes[] = {
+       struct jim_nvp *n;
+       static const struct jim_nvp nvp_ftdi_jtag_modes[] = {
                { .name = "rising", .value = JTAG_MODE },
                { .name = "falling", .value = JTAG_MODE_ALT },
                { .name = NULL, .value = -1 },
        };
 
        if (CMD_ARGC > 0) {
-               n = Jim_Nvp_name2value_simple(nvp_ftdi_jtag_modes, CMD_ARGV[0]);
+               n = jim_nvp_name2value_simple(nvp_ftdi_jtag_modes, CMD_ARGV[0]);
                if (n->name == NULL)
                        return ERROR_COMMAND_SYNTAX_ERROR;
                ftdi_jtag_mode = n->value;
 
        }
 
-       n = Jim_Nvp_value2name_simple(nvp_ftdi_jtag_modes, ftdi_jtag_mode);
+       n = jim_nvp_value2name_simple(nvp_ftdi_jtag_modes, ftdi_jtag_mode);
        command_print(CMD, "ftdi samples TDO on %s edge of TCK", n->name);
 
        return ERROR_OK;
@@ -992,7 +1004,7 @@ static const struct command_registration ftdi_command_handlers[] = {
                .handler = &ftdi_handle_vid_pid_command,
                .mode = COMMAND_CONFIG,
                .help = "the vendor ID and product ID of the FTDI device",
-               .usage = "(vid pid)* ",
+               .usage = "(vid pid)*",
        },
        {
                .name = "ftdi_tdo_sample_edge",
@@ -1068,7 +1080,6 @@ static void ftdi_swd_swdio_en(bool enable)
 
 /**
  * Flush the MPSSE queue and process the SWD transaction queue
- * @param dap
  * @return
  */
 static int ftdi_swd_run_queue(void)
@@ -1101,17 +1112,17 @@ static int ftdi_swd_run_queue(void)
 
                LOG_DEBUG_IO("%s %s %s reg %X = %08"PRIx32,
                                ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
-                               swd_cmd_queue[i].cmd & SWD_CMD_APnDP ? "AP" : "DP",
-                               swd_cmd_queue[i].cmd & SWD_CMD_RnW ? "read" : "write",
+                               swd_cmd_queue[i].cmd & SWD_CMD_APNDP ? "AP" : "DP",
+                               swd_cmd_queue[i].cmd & SWD_CMD_RNW ? "read" : "write",
                                (swd_cmd_queue[i].cmd & SWD_CMD_A32) >> 1,
                                buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn,
-                                               1 + 3 + (swd_cmd_queue[i].cmd & SWD_CMD_RnW ? 0 : 1), 32));
+                                               1 + 3 + (swd_cmd_queue[i].cmd & SWD_CMD_RNW ? 0 : 1), 32));
 
                if (ack != SWD_ACK_OK) {
                        queued_retval = ack == SWD_ACK_WAIT ? ERROR_WAIT : ERROR_FAIL;
                        goto skip;
 
-               } else if (swd_cmd_queue[i].cmd & SWD_CMD_RnW) {
+               } else if (swd_cmd_queue[i].cmd & SWD_CMD_RNW) {
                        uint32_t data = buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1 + 3, 32);
                        int parity = buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1 + 3 + 32, 1);
 
@@ -1161,7 +1172,7 @@ static void ftdi_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint32
 
        mpsse_clock_data_out(mpsse_ctx, &swd_cmd_queue[i].cmd, 0, 8, SWD_MODE);
 
-       if (swd_cmd_queue[i].cmd & SWD_CMD_RnW) {
+       if (swd_cmd_queue[i].cmd & SWD_CMD_RNW) {
                /* Queue a read transaction */
                swd_cmd_queue[i].dst = dst;
 
@@ -1186,31 +1197,23 @@ static void ftdi_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint32
        }
 
        /* Insert idle cycles after AP accesses to avoid WAIT */
-       if (cmd & SWD_CMD_APnDP)
+       if (cmd & SWD_CMD_APNDP)
                mpsse_clock_data_out(mpsse_ctx, NULL, 0, ap_delay_clk, SWD_MODE);
 
 }
 
 static void ftdi_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
 {
-       assert(cmd & SWD_CMD_RnW);
+       assert(cmd & SWD_CMD_RNW);
        ftdi_swd_queue_cmd(cmd, value, 0, ap_delay_clk);
 }
 
 static void ftdi_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
 {
-       assert(!(cmd & SWD_CMD_RnW));
+       assert(!(cmd & SWD_CMD_RNW));
        ftdi_swd_queue_cmd(cmd, NULL, value, ap_delay_clk);
 }
 
-static int_least32_t ftdi_swd_frequency(int_least32_t hz)
-{
-       if (hz > 0)
-               freq = mpsse_set_frequency(mpsse_ctx, hz);
-
-       return freq;
-}
-
 static int ftdi_swd_switch_seq(enum swd_special_seq seq)
 {
        switch (seq) {
@@ -1239,7 +1242,6 @@ static int ftdi_swd_switch_seq(enum swd_special_seq seq)
 
 static const struct swd_driver ftdi_swd = {
        .init = ftdi_swd_init,
-       .frequency = ftdi_swd_frequency,
        .switch_seq = ftdi_swd_switch_seq,
        .read_reg = ftdi_swd_read_reg,
        .write_reg = ftdi_swd_write_reg,
@@ -1248,17 +1250,23 @@ static const struct swd_driver ftdi_swd = {
 
 static const char * const ftdi_transports[] = { "jtag", "swd", NULL };
 
-struct jtag_interface ftdi_interface = {
-       .name = "ftdi",
+static struct jtag_interface ftdi_interface = {
        .supported = DEBUG_CAP_TMS_SEQ,
-       .commands = ftdi_command_handlers,
+       .execute_queue = ftdi_execute_queue,
+};
+
+struct adapter_driver ftdi_adapter_driver = {
+       .name = "ftdi",
        .transports = ftdi_transports,
-       .swd = &ftdi_swd,
+       .commands = ftdi_command_handlers,
 
        .init = ftdi_initialize,
        .quit = ftdi_quit,
+       .reset = ftdi_reset,
        .speed = ftdi_speed,
-       .speed_div = ftdi_speed_div,
        .khz = ftdi_khz,
-       .execute_queue = ftdi_execute_queue,
+       .speed_div = ftdi_speed_div,
+
+       .jtag_ops = &ftdi_interface,
+       .swd_ops = &ftdi_swd,
 };
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)