Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Signalyzer: H2 and H4 support
[openocd.git] / src / jtag / ft2232.c
1 /***************************************************************************
2 * Copyright (C) 2009 by Øyvind Harboe *
3 * Øyvind Harboe <oyvind.harboe@zylin.com> *
4 * *
5 * Copyright (C) 2009 by SoftPLC Corporation. http://softplc.com *
6 * Dick Hollenbeck <dick@softplc.com> *
7 * *
8 * Copyright (C) 2004, 2006 by Dominic Rath *
9 * Dominic.Rath@gmx.de *
10 * *
11 * Copyright (C) 2008 by Spencer Oliver *
12 * spen@spen-soft.co.uk *
13 * *
14 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
18 * *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program; if not, write to the *
26 * Free Software Foundation, Inc., *
27 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
28 ***************************************************************************/
29
30 /* This code uses information contained in the MPSSE specification which was
31 * found here:
32 * http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
33 * Hereafter this is called the "MPSSE Spec".
34 *
35 * The datasheet for the ftdichip.com's FT2232D part is here:
36 * http://www.ftdichip.com/Documents/DataSheets/DS_FT2232D.pdf
37 */
38
39 #ifdef HAVE_CONFIG_H
40 #include "config.h"
41 #endif
42
43 /* project specific includes */
44 #include "interface.h"
45 #include "commands.h"
46 #include "time_support.h"
47
48 #if IS_CYGWIN == 1
49 #include <windows.h>
50 #endif
51
52 #include <assert.h>
53
54 #if (BUILD_FT2232_FTD2XX == 1 && BUILD_FT2232_LIBFTDI == 1)
55 #error "BUILD_FT2232_FTD2XX && BUILD_FT2232_LIBFTDI are mutually exclusive"
56 #elif (BUILD_FT2232_FTD2XX != 1 && BUILD_FT2232_LIBFTDI != 1)
57 #error "BUILD_FT2232_FTD2XX || BUILD_FT2232_LIBFTDI must be chosen"
58 #endif
59
60 /* FT2232 access library includes */
61 #if BUILD_FT2232_FTD2XX == 1
62 #include <ftd2xx.h>
63 #elif BUILD_FT2232_LIBFTDI == 1
64 #include <ftdi.h>
65 #endif
66
67 /* max TCK for the high speed devices 30000 kHz */
68 #define FTDI_2232H_4232H_MAX_TCK 30000
69 /* max TCK for the full speed devices 6000 kHz */
70 #define FTDI_2232C_MAX_TCK 6000
71 /* this speed value tells that RTCK is requested */
72 #define RTCK_SPEED -1
73
74 #ifndef BUILD_FT2232_HIGHSPEED
75 #if BUILD_FT2232_FTD2XX == 1
76 enum { FT_DEVICE_2232H = 6, FT_DEVICE_4232H };
77 #elif BUILD_FT2232_LIBFTDI == 1
78 enum { TYPE_2232H = 4, TYPE_4232H = 5 };
79 #endif
80 #endif
81
82 static int ft2232_execute_queue(void);
83 static int ft2232_speed(int speed);
84 static int ft2232_speed_div(int speed, int* khz);
85 static int ft2232_khz(int khz, int* jtag_speed);
86 static int ft2232_register_commands(struct command_context_s* cmd_ctx);
87 static int ft2232_init(void);
88 static int ft2232_quit(void);
89
90 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
91 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
92 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
93 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
94 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
95
96 /**
97 * Send out \a num_cycles on the TCK line while the TAP(s) are in a
98 * stable state. Calling code must ensure that current state is stable,
99 * that verification is not done in here.
100 *
101 * @param num_cycles The number of clocks cycles to send.
102 * @param cmd The command to send.
103 *
104 * @returns ERROR_OK on success, or ERROR_JTAG_QUEUE_FAILED on failure.
105 */
106 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd);
107
108 static char * ft2232_device_desc_A = NULL;
109 static char* ft2232_device_desc = NULL;
110 static char* ft2232_serial = NULL;
111 static char* ft2232_layout = NULL;
112 static uint8_t ft2232_latency = 2;
113 static unsigned ft2232_max_tck = FTDI_2232C_MAX_TCK;
114
115 #define MAX_USB_IDS 8
116 /* vid = pid = 0 marks the end of the list */
117 static uint16_t ft2232_vid[MAX_USB_IDS + 1] = { 0x0403, 0 };
118 static uint16_t ft2232_pid[MAX_USB_IDS + 1] = { 0x6010, 0 };
119
120 typedef struct ft2232_layout_s
121 {
122 char* name;
123 int (*init)(void);
124 void (*reset)(int trst, int srst);
125 void (*blink)(void);
126 } ft2232_layout_t;
127
128 /* init procedures for supported layouts */
129 static int usbjtag_init(void);
130 static int jtagkey_init(void);
131 static int olimex_jtag_init(void);
132 static int flyswatter_init(void);
133 static int turtle_init(void);
134 static int comstick_init(void);
135 static int stm32stick_init(void);
136 static int axm0432_jtag_init(void);
137 static int sheevaplug_init(void);
138 static int icebear_jtag_init(void);
139 static int cortino_jtag_init(void);
140 static int signalyzer_h_init(void);
141
142 /* reset procedures for supported layouts */
143 static void usbjtag_reset(int trst, int srst);
144 static void jtagkey_reset(int trst, int srst);
145 static void olimex_jtag_reset(int trst, int srst);
146 static void flyswatter_reset(int trst, int srst);
147 static void turtle_reset(int trst, int srst);
148 static void comstick_reset(int trst, int srst);
149 static void stm32stick_reset(int trst, int srst);
150 static void axm0432_jtag_reset(int trst, int srst);
151 static void sheevaplug_reset(int trst, int srst);
152 static void icebear_jtag_reset(int trst, int srst);
153 static void signalyzer_h_reset(int trst, int srst);
154
155 /* blink procedures for layouts that support a blinking led */
156 static void olimex_jtag_blink(void);
157 static void flyswatter_jtag_blink(void);
158 static void turtle_jtag_blink(void);
159 static void signalyzer_h_blink(void);
160
161 static const ft2232_layout_t ft2232_layouts[] =
162 {
163 { "usbjtag", usbjtag_init, usbjtag_reset, NULL },
164 { "jtagkey", jtagkey_init, jtagkey_reset, NULL },
165 { "jtagkey_prototype_v1", jtagkey_init, jtagkey_reset, NULL },
166 { "oocdlink", jtagkey_init, jtagkey_reset, NULL },
167 { "signalyzer", usbjtag_init, usbjtag_reset, NULL },
168 { "evb_lm3s811", usbjtag_init, usbjtag_reset, NULL },
169 { "luminary_icdi", usbjtag_init, usbjtag_reset, NULL },
170 { "olimex-jtag", olimex_jtag_init, olimex_jtag_reset, olimex_jtag_blink },
171 { "flyswatter", flyswatter_init, flyswatter_reset, flyswatter_jtag_blink },
172 { "turtelizer2", turtle_init, turtle_reset, turtle_jtag_blink },
173 { "comstick", comstick_init, comstick_reset, NULL },
174 { "stm32stick", stm32stick_init, stm32stick_reset, NULL },
175 { "axm0432_jtag", axm0432_jtag_init, axm0432_jtag_reset, NULL },
176 { "sheevaplug", sheevaplug_init, sheevaplug_reset, NULL },
177 { "icebear", icebear_jtag_init, icebear_jtag_reset, NULL },
178 { "cortino", cortino_jtag_init, comstick_reset, NULL },
179 { "signalyzer-h", signalyzer_h_init, signalyzer_h_reset, signalyzer_h_blink },
180 { NULL, NULL, NULL, NULL },
181 };
182
183 static uint8_t nTRST, nTRSTnOE, nSRST, nSRSTnOE;
184
185 static const ft2232_layout_t *layout;
186 static uint8_t low_output = 0x0;
187 static uint8_t low_direction = 0x0;
188 static uint8_t high_output = 0x0;
189 static uint8_t high_direction = 0x0;
190
191 #if BUILD_FT2232_FTD2XX == 1
192 static FT_HANDLE ftdih = NULL;
193 static FT_DEVICE ftdi_device = 0;
194 #elif BUILD_FT2232_LIBFTDI == 1
195 static struct ftdi_context ftdic;
196 static enum ftdi_chip_type ftdi_device;
197 #endif
198
199 static jtag_command_t* first_unsent; /* next command that has to be sent */
200 static int require_send;
201
202 /* http://urjtag.wiki.sourceforge.net/Cable + FT2232 says:
203
204 "There is a significant difference between libftdi and libftd2xx. The latter
205 one allows to schedule up to 64*64 bytes of result data while libftdi fails
206 with more than 4*64. As a consequence, the FT2232 driver is forced to
207 perform around 16x more USB transactions for long command streams with TDO
208 capture when running with libftdi."
209
210 No idea how we get
211 #define FT2232_BUFFER_SIZE 131072
212 a comment would have been nice.
213 */
214
215 #define FT2232_BUFFER_SIZE 131072
216
217 static uint8_t* ft2232_buffer = NULL;
218 static int ft2232_buffer_size = 0;
219 static int ft2232_read_pointer = 0;
220 static int ft2232_expect_read = 0;
221
222 /**
223 * Function buffer_write
224 * writes a byte into the byte buffer, "ft2232_buffer", which must be sent later.
225 * @param val is the byte to send.
226 */
227 static inline void buffer_write(uint8_t val)
228 {
229 assert(ft2232_buffer);
230 assert((unsigned) ft2232_buffer_size < (unsigned) FT2232_BUFFER_SIZE);
231 ft2232_buffer[ft2232_buffer_size++] = val;
232 }
233
234 /**
235 * Function buffer_read
236 * returns a byte from the byte buffer.
237 */
238 static inline uint8_t buffer_read(void)
239 {
240 assert(ft2232_buffer);
241 assert(ft2232_read_pointer < ft2232_buffer_size);
242 return ft2232_buffer[ft2232_read_pointer++];
243 }
244
245 /**
246 * Clocks out \a bit_count bits on the TMS line, starting with the least
247 * significant bit of tms_bits and progressing to more significant bits.
248 * Rigorous state transition logging is done here via tap_set_state().
249 *
250 * @param mpsse_cmd One of the MPSSE TMS oriented commands such as
251 * 0x4b or 0x6b. See the MPSSE spec referenced above for their
252 * functionality. The MPSSE command "Clock Data to TMS/CS Pin (no Read)"
253 * is often used for this, 0x4b.
254 *
255 * @param tms_bits Holds the sequence of bits to send.
256 * @param tms_count Tells how many bits in the sequence.
257 * @param tdi_bit A single bit to pass on to TDI before the first TCK
258 * cycle and held static for the duration of TMS clocking.
259 *
260 * See the MPSSE spec referenced above.
261 */
262 static void clock_tms(uint8_t mpsse_cmd, int tms_bits, int tms_count, bool tdi_bit)
263 {
264 uint8_t tms_byte;
265 int i;
266 int tms_ndx; /* bit index into tms_byte */
267
268 assert(tms_count > 0);
269
270 DEBUG_JTAG_IO("mpsse cmd=%02x, tms_bits = 0x%08x, bit_count=%d",
271 mpsse_cmd, tms_bits, tms_count);
272
273 for (tms_byte = tms_ndx = i = 0; i < tms_count; ++i, tms_bits>>=1)
274 {
275 bool bit = tms_bits & 1;
276
277 if (bit)
278 tms_byte |= (1 << tms_ndx);
279
280 /* always do state transitions in public view */
281 tap_set_state(tap_state_transition(tap_get_state(), bit));
282
283 /* we wrote a bit to tms_byte just above, increment bit index. if bit was zero
284 also increment.
285 */
286 ++tms_ndx;
287
288 if (tms_ndx == 7 || i == tms_count-1)
289 {
290 buffer_write(mpsse_cmd);
291 buffer_write(tms_ndx - 1);
292
293 /* Bit 7 of the byte is passed on to TDI/DO before the first TCK/SK of
294 TMS/CS and is held static for the duration of TMS/CS clocking.
295 */
296 buffer_write(tms_byte | (tdi_bit << 7));
297 }
298 }
299 }
300
301 /**
302 * Function get_tms_buffer_requirements
303 * returns what clock_tms() will consume if called with
304 * same \a bit_count.
305 */
306 static inline int get_tms_buffer_requirements(int bit_count)
307 {
308 return ((bit_count + 6)/7) * 3;
309 }
310
311 /**
312 * Function move_to_state
313 * moves the TAP controller from the current state to a
314 * \a goal_state through a path given by tap_get_tms_path(). State transition
315 * logging is performed by delegation to clock_tms().
316 *
317 * @param goal_state is the destination state for the move.
318 */
319 static void move_to_state(tap_state_t goal_state)
320 {
321 tap_state_t start_state = tap_get_state();
322
323 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
324 lookup of the required TMS pattern to move to this state from the
325 start state.
326 */
327
328 /* do the 2 lookups */
329 int tms_bits = tap_get_tms_path(start_state, goal_state);
330 int tms_count = tap_get_tms_path_len(start_state, goal_state);
331
332 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state), tap_state_name(goal_state));
333
334 clock_tms(0x4b, tms_bits, tms_count, 0);
335 }
336
337 jtag_interface_t ft2232_interface =
338 {
339 .name = "ft2232",
340 .execute_queue = ft2232_execute_queue,
341 .speed = ft2232_speed,
342 .speed_div = ft2232_speed_div,
343 .khz = ft2232_khz,
344 .register_commands = ft2232_register_commands,
345 .init = ft2232_init,
346 .quit = ft2232_quit,
347 };
348
349 static int ft2232_write(uint8_t* buf, int size, uint32_t* bytes_written)
350 {
351 #if BUILD_FT2232_FTD2XX == 1
352 FT_STATUS status;
353 DWORD dw_bytes_written;
354 if ((status = FT_Write(ftdih, buf, size, &dw_bytes_written)) != FT_OK)
355 {
356 *bytes_written = dw_bytes_written;
357 LOG_ERROR("FT_Write returned: %lu", status);
358 return ERROR_JTAG_DEVICE_ERROR;
359 }
360 else
361 {
362 *bytes_written = dw_bytes_written;
363 return ERROR_OK;
364 }
365 #elif BUILD_FT2232_LIBFTDI == 1
366 int retval;
367 if ((retval = ftdi_write_data(&ftdic, buf, size)) < 0)
368 {
369 *bytes_written = 0;
370 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic));
371 return ERROR_JTAG_DEVICE_ERROR;
372 }
373 else
374 {
375 *bytes_written = retval;
376 return ERROR_OK;
377 }
378 #endif
379 }
380
381 static int ft2232_read(uint8_t* buf, uint32_t size, uint32_t* bytes_read)
382 {
383 #if BUILD_FT2232_FTD2XX == 1
384 DWORD dw_bytes_read;
385 FT_STATUS status;
386 int timeout = 5;
387 *bytes_read = 0;
388
389 while ((*bytes_read < size) && timeout--)
390 {
391 if ((status = FT_Read(ftdih, buf + *bytes_read, size -
392 *bytes_read, &dw_bytes_read)) != FT_OK)
393 {
394 *bytes_read = 0;
395 LOG_ERROR("FT_Read returned: %lu", status);
396 return ERROR_JTAG_DEVICE_ERROR;
397 }
398 *bytes_read += dw_bytes_read;
399 }
400
401 #elif BUILD_FT2232_LIBFTDI == 1
402 int retval;
403 int timeout = 100;
404 *bytes_read = 0;
405
406 while ((*bytes_read < size) && timeout--)
407 {
408 if ((retval = ftdi_read_data(&ftdic, buf + *bytes_read, size - *bytes_read)) < 0)
409 {
410 *bytes_read = 0;
411 LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&ftdic));
412 return ERROR_JTAG_DEVICE_ERROR;
413 }
414 *bytes_read += retval;
415 }
416
417 #endif
418
419 if (*bytes_read < size)
420 {
421 LOG_ERROR("couldn't read the requested number of bytes from FT2232 device (%i < %i)",
422 (unsigned int)(*bytes_read),
423 (unsigned int)size);
424 return ERROR_JTAG_DEVICE_ERROR;
425 }
426
427 return ERROR_OK;
428 }
429
430 static bool ft2232_device_is_highspeed(void)
431 {
432 #if BUILD_FT2232_FTD2XX == 1
433 return (ftdi_device == FT_DEVICE_2232H) || (ftdi_device == FT_DEVICE_4232H);
434 #elif BUILD_FT2232_LIBFTDI == 1
435 return (ftdi_device == TYPE_2232H || ftdi_device == TYPE_4232H);
436 #endif
437 }
438
439 /*
440 * Commands that only apply to the FT2232H and FT4232H devices.
441 * See chapter 6 in http://www.ftdichip.com/Documents/AppNotes/
442 * AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf
443 */
444
445 static int ft2232h_ft4232h_adaptive_clocking(bool enable)
446 {
447 uint8_t buf = enable ? 0x96 : 0x97;
448 LOG_DEBUG("%2.2x", buf);
449
450 uint32_t bytes_written;
451 int retval = ft2232_write(&buf, 1, &bytes_written);
452 if ((ERROR_OK != retval) || (bytes_written != 1))
453 {
454 LOG_ERROR("couldn't write command to %s adaptive clocking"
455 , enable ? "enable" : "disable");
456 return retval;
457 }
458
459 return ERROR_OK;
460 }
461
462 /**
463 * Enable/disable the clk divide by 5 of the 60MHz master clock.
464 * This result in a JTAG clock speed range of 91.553Hz-6MHz
465 * respective 457.763Hz-30MHz.
466 */
467 static int ft2232h_ft4232h_clk_divide_by_5(bool enable)
468 {
469 uint32_t bytes_written;
470 uint8_t buf = enable ? 0x8b : 0x8a;
471 int retval = ft2232_write(&buf, 1, &bytes_written);
472 if ((ERROR_OK != retval) || (bytes_written != 1))
473 {
474 LOG_ERROR("couldn't write command to %s clk divide by 5"
475 , enable ? "enable" : "disable");
476 return ERROR_JTAG_INIT_FAILED;
477 }
478 ft2232_max_tck = enable ? FTDI_2232C_MAX_TCK : FTDI_2232H_4232H_MAX_TCK;
479 LOG_INFO("max TCK change to: %u kHz", ft2232_max_tck);
480
481 return ERROR_OK;
482 }
483
484 static int ft2232_speed(int speed)
485 {
486 uint8_t buf[3];
487 int retval;
488 uint32_t bytes_written;
489
490 retval = ERROR_OK;
491 bool enable_adaptive_clocking = (RTCK_SPEED == speed);
492 if (ft2232_device_is_highspeed())
493 retval = ft2232h_ft4232h_adaptive_clocking(enable_adaptive_clocking);
494 else if (enable_adaptive_clocking)
495 {
496 LOG_ERROR("ft2232 device %lu does not support RTCK"
497 , (long unsigned int)ftdi_device);
498 return ERROR_FAIL;
499 }
500
501 if ((enable_adaptive_clocking) || (ERROR_OK != retval))
502 return retval;
503
504 buf[0] = 0x86; /* command "set divisor" */
505 buf[1] = speed & 0xff; /* valueL (0 = 6MHz, 1 = 3MHz, 2 = 2.0MHz, ...*/
506 buf[2] = (speed >> 8) & 0xff; /* valueH */
507
508 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
509 if (((retval = ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
510 {
511 LOG_ERROR("couldn't set FT2232 TCK speed");
512 return retval;
513 }
514
515 return ERROR_OK;
516 }
517
518 static int ft2232_speed_div(int speed, int* khz)
519 {
520 /* Take a look in the FT2232 manual,
521 * AN2232C-01 Command Processor for
522 * MPSSE and MCU Host Bus. Chapter 3.8 */
523
524 *khz = (RTCK_SPEED == speed) ? 0 : ft2232_max_tck / (1 + speed);
525
526 return ERROR_OK;
527 }
528
529 static int ft2232_khz(int khz, int* jtag_speed)
530 {
531 if (khz == 0)
532 {
533 if (ft2232_device_is_highspeed())
534 {
535 *jtag_speed = RTCK_SPEED;
536 return ERROR_OK;
537 }
538 else
539 {
540 LOG_DEBUG("RCLK not supported");
541 return ERROR_FAIL;
542 }
543 }
544
545 /* Take a look in the FT2232 manual,
546 * AN2232C-01 Command Processor for
547 * MPSSE and MCU Host Bus. Chapter 3.8
548 *
549 * We will calc here with a multiplier
550 * of 10 for better rounding later. */
551
552 /* Calc speed, (ft2232_max_tck / khz) - 1 */
553 /* Use 65000 for better rounding */
554 *jtag_speed = ((ft2232_max_tck*10) / khz) - 10;
555
556 /* Add 0.9 for rounding */
557 *jtag_speed += 9;
558
559 /* Calc real speed */
560 *jtag_speed = *jtag_speed / 10;
561
562 /* Check if speed is greater than 0 */
563 if (*jtag_speed < 0)
564 {
565 *jtag_speed = 0;
566 }
567
568 /* Check max value */
569 if (*jtag_speed > 0xFFFF)
570 {
571 *jtag_speed = 0xFFFF;
572 }
573
574 return ERROR_OK;
575 }
576
577 static int ft2232_register_commands(struct command_context_s* cmd_ctx)
578 {
579 register_command(cmd_ctx, NULL, "ft2232_device_desc", ft2232_handle_device_desc_command,
580 COMMAND_CONFIG, "the USB device description of the FTDI FT2232 device");
581 register_command(cmd_ctx, NULL, "ft2232_serial", ft2232_handle_serial_command,
582 COMMAND_CONFIG, "the serial number of the FTDI FT2232 device");
583 register_command(cmd_ctx, NULL, "ft2232_layout", ft2232_handle_layout_command,
584 COMMAND_CONFIG, "the layout of the FT2232 GPIO signals used to control output-enables and reset signals");
585 register_command(cmd_ctx, NULL, "ft2232_vid_pid", ft2232_handle_vid_pid_command,
586 COMMAND_CONFIG, "the vendor ID and product ID of the FTDI FT2232 device");
587 register_command(cmd_ctx, NULL, "ft2232_latency", ft2232_handle_latency_command,
588 COMMAND_CONFIG, "set the FT2232 latency timer to a new value");
589 return ERROR_OK;
590 }
591
592 static void ft2232_end_state(tap_state_t state)
593 {
594 if (tap_is_state_stable(state))
595 tap_set_end_state(state);
596 else
597 {
598 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state));
599 exit(-1);
600 }
601 }
602
603 static void ft2232_read_scan(enum scan_type type, uint8_t* buffer, int scan_size)
604 {
605 int num_bytes = (scan_size + 7) / 8;
606 int bits_left = scan_size;
607 int cur_byte = 0;
608
609 while (num_bytes-- > 1)
610 {
611 buffer[cur_byte++] = buffer_read();
612 bits_left -= 8;
613 }
614
615 buffer[cur_byte] = 0x0;
616
617 /* There is one more partial byte left from the clock data in/out instructions */
618 if (bits_left > 1)
619 {
620 buffer[cur_byte] = buffer_read() >> 1;
621 }
622 /* This shift depends on the length of the clock data to tms instruction, insterted at end of the scan, now fixed to a two step transition in ft2232_add_scan */
623 buffer[cur_byte] = (buffer[cur_byte] | (((buffer_read()) << 1) & 0x80)) >> (8 - bits_left);
624 }
625
626 static void ft2232_debug_dump_buffer(void)
627 {
628 int i;
629 char line[256];
630 char* line_p = line;
631
632 for (i = 0; i < ft2232_buffer_size; i++)
633 {
634 line_p += snprintf(line_p, 256 - (line_p - line), "%2.2x ", ft2232_buffer[i]);
635 if (i % 16 == 15)
636 {
637 LOG_DEBUG("%s", line);
638 line_p = line;
639 }
640 }
641
642 if (line_p != line)
643 LOG_DEBUG("%s", line);
644 }
645
646 static int ft2232_send_and_recv(jtag_command_t* first, jtag_command_t* last)
647 {
648 jtag_command_t* cmd;
649 uint8_t* buffer;
650 int scan_size;
651 enum scan_type type;
652 int retval;
653 uint32_t bytes_written = 0;
654 uint32_t bytes_read = 0;
655
656 #ifdef _DEBUG_USB_IO_
657 struct timeval start, inter, inter2, end;
658 struct timeval d_inter, d_inter2, d_end;
659 #endif
660
661 #ifdef _DEBUG_USB_COMMS_
662 LOG_DEBUG("write buffer (size %i):", ft2232_buffer_size);
663 ft2232_debug_dump_buffer();
664 #endif
665
666 #ifdef _DEBUG_USB_IO_
667 gettimeofday(&start, NULL);
668 #endif
669
670 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
671 {
672 LOG_ERROR("couldn't write MPSSE commands to FT2232");
673 return retval;
674 }
675
676 #ifdef _DEBUG_USB_IO_
677 gettimeofday(&inter, NULL);
678 #endif
679
680 if (ft2232_expect_read)
681 {
682 int timeout = 100;
683 ft2232_buffer_size = 0;
684
685 #ifdef _DEBUG_USB_IO_
686 gettimeofday(&inter2, NULL);
687 #endif
688
689 if ((retval = ft2232_read(ft2232_buffer, ft2232_expect_read, &bytes_read)) != ERROR_OK)
690 {
691 LOG_ERROR("couldn't read from FT2232");
692 return retval;
693 }
694
695 #ifdef _DEBUG_USB_IO_
696 gettimeofday(&end, NULL);
697
698 timeval_subtract(&d_inter, &inter, &start);
699 timeval_subtract(&d_inter2, &inter2, &start);
700 timeval_subtract(&d_end, &end, &start);
701
702 LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u",
703 (unsigned)d_inter.tv_sec, (unsigned)d_inter.tv_usec,
704 (unsigned)d_inter2.tv_sec, (unsigned)d_inter2.tv_usec,
705 (unsigned)d_end.tv_sec, (unsigned)d_end.tv_usec);
706 #endif
707
708 ft2232_buffer_size = bytes_read;
709
710 if (ft2232_expect_read != ft2232_buffer_size)
711 {
712 LOG_ERROR("ft2232_expect_read (%i) != ft2232_buffer_size (%i) (%i retries)", ft2232_expect_read,
713 ft2232_buffer_size,
714 100 - timeout);
715 ft2232_debug_dump_buffer();
716
717 exit(-1);
718 }
719
720 #ifdef _DEBUG_USB_COMMS_
721 LOG_DEBUG("read buffer (%i retries): %i bytes", 100 - timeout, ft2232_buffer_size);
722 ft2232_debug_dump_buffer();
723 #endif
724 }
725
726 ft2232_expect_read = 0;
727 ft2232_read_pointer = 0;
728
729 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
730 * that wasn't handled by a caller-provided error handler
731 */
732 retval = ERROR_OK;
733
734 cmd = first;
735 while (cmd != last)
736 {
737 switch (cmd->type)
738 {
739 case JTAG_SCAN:
740 type = jtag_scan_type(cmd->cmd.scan);
741 if (type != SCAN_OUT)
742 {
743 scan_size = jtag_scan_size(cmd->cmd.scan);
744 buffer = calloc(CEIL(scan_size, 8), 1);
745 ft2232_read_scan(type, buffer, scan_size);
746 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
747 retval = ERROR_JTAG_QUEUE_FAILED;
748 free(buffer);
749 }
750 break;
751
752 default:
753 break;
754 }
755
756 cmd = cmd->next;
757 }
758
759 ft2232_buffer_size = 0;
760
761 return retval;
762 }
763
764 /**
765 * Function ft2232_add_pathmove
766 * moves the TAP controller from the current state to a new state through the
767 * given path, where path is an array of tap_state_t's.
768 *
769 * @param path is an array of tap_stat_t which gives the states to traverse through
770 * ending with the last state at path[num_states-1]
771 * @param num_states is the count of state steps to move through
772 */
773 static void ft2232_add_pathmove(tap_state_t* path, int num_states)
774 {
775 int state_count = 0;
776
777 assert((unsigned) num_states <= 32u); /* tms_bits only holds 32 bits */
778
779 DEBUG_JTAG_IO("-");
780
781 /* this loop verifies that the path is legal and logs each state in the path */
782 while (num_states)
783 {
784 unsigned char tms_byte = 0; /* zero this on each MPSSE batch */
785 int bit_count = 0;
786 int num_states_batch = num_states > 7 ? 7 : num_states;
787
788 /* command "Clock Data to TMS/CS Pin (no Read)" */
789 buffer_write(0x4b);
790
791 /* number of states remaining */
792 buffer_write(num_states_batch - 1);
793
794 while (num_states_batch--) {
795 /* either TMS=0 or TMS=1 must work ... */
796 if (tap_state_transition(tap_get_state(), false)
797 == path[state_count])
798 buf_set_u32(&tms_byte, bit_count++, 1, 0x0);
799 else if (tap_state_transition(tap_get_state(), true)
800 == path[state_count])
801 buf_set_u32(&tms_byte, bit_count++, 1, 0x1);
802
803 /* ... or else the caller goofed BADLY */
804 else {
805 LOG_ERROR("BUG: %s -> %s isn't a valid "
806 "TAP state transition",
807 tap_state_name(tap_get_state()),
808 tap_state_name(path[state_count]));
809 exit(-1);
810 }
811
812 tap_set_state(path[state_count]);
813 state_count++;
814 num_states--;
815 }
816
817 buffer_write(tms_byte);
818 }
819 tap_set_end_state(tap_get_state());
820 }
821
822 static void ft2232_add_scan(bool ir_scan, enum scan_type type, uint8_t* buffer, int scan_size)
823 {
824 int num_bytes = (scan_size + 7) / 8;
825 int bits_left = scan_size;
826 int cur_byte = 0;
827 int last_bit;
828
829 if (!ir_scan)
830 {
831 if (tap_get_state() != TAP_DRSHIFT)
832 {
833 move_to_state(TAP_DRSHIFT);
834 }
835 }
836 else
837 {
838 if (tap_get_state() != TAP_IRSHIFT)
839 {
840 move_to_state(TAP_IRSHIFT);
841 }
842 }
843
844 /* add command for complete bytes */
845 while (num_bytes > 1)
846 {
847 int thisrun_bytes;
848 if (type == SCAN_IO)
849 {
850 /* Clock Data Bytes In and Out LSB First */
851 buffer_write(0x39);
852 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
853 }
854 else if (type == SCAN_OUT)
855 {
856 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
857 buffer_write(0x19);
858 /* LOG_DEBUG("added TDI bytes (o)"); */
859 }
860 else if (type == SCAN_IN)
861 {
862 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
863 buffer_write(0x28);
864 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
865 }
866
867 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
868 num_bytes -= thisrun_bytes;
869
870 buffer_write((uint8_t) (thisrun_bytes - 1));
871 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
872
873 if (type != SCAN_IN)
874 {
875 /* add complete bytes */
876 while (thisrun_bytes-- > 0)
877 {
878 buffer_write(buffer[cur_byte++]);
879 bits_left -= 8;
880 }
881 }
882 else /* (type == SCAN_IN) */
883 {
884 bits_left -= 8 * (thisrun_bytes);
885 }
886 }
887
888 /* the most signifcant bit is scanned during TAP movement */
889 if (type != SCAN_IN)
890 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
891 else
892 last_bit = 0;
893
894 /* process remaining bits but the last one */
895 if (bits_left > 1)
896 {
897 if (type == SCAN_IO)
898 {
899 /* Clock Data Bits In and Out LSB First */
900 buffer_write(0x3b);
901 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
902 }
903 else if (type == SCAN_OUT)
904 {
905 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
906 buffer_write(0x1b);
907 /* LOG_DEBUG("added TDI bits (o)"); */
908 }
909 else if (type == SCAN_IN)
910 {
911 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
912 buffer_write(0x2a);
913 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
914 }
915
916 buffer_write(bits_left - 2);
917 if (type != SCAN_IN)
918 buffer_write(buffer[cur_byte]);
919 }
920
921 if ((ir_scan && (tap_get_end_state() == TAP_IRSHIFT))
922 || (!ir_scan && (tap_get_end_state() == TAP_DRSHIFT)))
923 {
924 if (type == SCAN_IO)
925 {
926 /* Clock Data Bits In and Out LSB First */
927 buffer_write(0x3b);
928 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
929 }
930 else if (type == SCAN_OUT)
931 {
932 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
933 buffer_write(0x1b);
934 /* LOG_DEBUG("added TDI bits (o)"); */
935 }
936 else if (type == SCAN_IN)
937 {
938 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
939 buffer_write(0x2a);
940 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
941 }
942 buffer_write(0x0);
943 buffer_write(last_bit);
944 }
945 else
946 {
947 int tms_bits;
948 int tms_count;
949 uint8_t mpsse_cmd;
950
951 /* move from Shift-IR/DR to end state */
952 if (type != SCAN_OUT)
953 {
954 /* We always go to the PAUSE state in two step at the end of an IN or IO scan */
955 /* This must be coordinated with the bit shifts in ft2232_read_scan */
956 tms_bits = 0x01;
957 tms_count = 2;
958 /* Clock Data to TMS/CS Pin with Read */
959 mpsse_cmd = 0x6b;
960 }
961 else
962 {
963 tms_bits = tap_get_tms_path(tap_get_state(), tap_get_end_state());
964 tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
965 /* Clock Data to TMS/CS Pin (no Read) */
966 mpsse_cmd = 0x4b;
967 }
968
969 DEBUG_JTAG_IO("finish %s", (type == SCAN_OUT) ? "without read" : "via PAUSE");
970 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
971 }
972
973 if (tap_get_state() != tap_get_end_state())
974 {
975 move_to_state(tap_get_end_state());
976 }
977 }
978
979 static int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, uint8_t* buffer, int scan_size)
980 {
981 int num_bytes = (scan_size + 7) / 8;
982 int bits_left = scan_size;
983 int cur_byte = 0;
984 int last_bit;
985 uint8_t* receive_buffer = malloc(CEIL(scan_size, 8));
986 uint8_t* receive_pointer = receive_buffer;
987 uint32_t bytes_written;
988 uint32_t bytes_read;
989 int retval;
990 int thisrun_read = 0;
991
992 if (cmd->ir_scan)
993 {
994 LOG_ERROR("BUG: large IR scans are not supported");
995 exit(-1);
996 }
997
998 if (tap_get_state() != TAP_DRSHIFT)
999 {
1000 move_to_state(TAP_DRSHIFT);
1001 }
1002
1003 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
1004 {
1005 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1006 exit(-1);
1007 }
1008 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1009 ft2232_buffer_size, (int)bytes_written);
1010 ft2232_buffer_size = 0;
1011
1012 /* add command for complete bytes */
1013 while (num_bytes > 1)
1014 {
1015 int thisrun_bytes;
1016
1017 if (type == SCAN_IO)
1018 {
1019 /* Clock Data Bytes In and Out LSB First */
1020 buffer_write(0x39);
1021 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
1022 }
1023 else if (type == SCAN_OUT)
1024 {
1025 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
1026 buffer_write(0x19);
1027 /* LOG_DEBUG("added TDI bytes (o)"); */
1028 }
1029 else if (type == SCAN_IN)
1030 {
1031 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
1032 buffer_write(0x28);
1033 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
1034 }
1035
1036 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
1037 thisrun_read = thisrun_bytes;
1038 num_bytes -= thisrun_bytes;
1039 buffer_write((uint8_t) (thisrun_bytes - 1));
1040 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
1041
1042 if (type != SCAN_IN)
1043 {
1044 /* add complete bytes */
1045 while (thisrun_bytes-- > 0)
1046 {
1047 buffer_write(buffer[cur_byte]);
1048 cur_byte++;
1049 bits_left -= 8;
1050 }
1051 }
1052 else /* (type == SCAN_IN) */
1053 {
1054 bits_left -= 8 * (thisrun_bytes);
1055 }
1056
1057 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
1058 {
1059 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1060 exit(-1);
1061 }
1062 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1063 ft2232_buffer_size,
1064 (int)bytes_written);
1065 ft2232_buffer_size = 0;
1066
1067 if (type != SCAN_OUT)
1068 {
1069 if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK)
1070 {
1071 LOG_ERROR("couldn't read from FT2232");
1072 exit(-1);
1073 }
1074 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1075 thisrun_read,
1076 (int)bytes_read);
1077 receive_pointer += bytes_read;
1078 }
1079 }
1080
1081 thisrun_read = 0;
1082
1083 /* the most signifcant bit is scanned during TAP movement */
1084 if (type != SCAN_IN)
1085 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
1086 else
1087 last_bit = 0;
1088
1089 /* process remaining bits but the last one */
1090 if (bits_left > 1)
1091 {
1092 if (type == SCAN_IO)
1093 {
1094 /* Clock Data Bits In and Out LSB First */
1095 buffer_write(0x3b);
1096 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1097 }
1098 else if (type == SCAN_OUT)
1099 {
1100 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1101 buffer_write(0x1b);
1102 /* LOG_DEBUG("added TDI bits (o)"); */
1103 }
1104 else if (type == SCAN_IN)
1105 {
1106 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1107 buffer_write(0x2a);
1108 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1109 }
1110 buffer_write(bits_left - 2);
1111 if (type != SCAN_IN)
1112 buffer_write(buffer[cur_byte]);
1113
1114 if (type != SCAN_OUT)
1115 thisrun_read += 2;
1116 }
1117
1118 if (tap_get_end_state() == TAP_DRSHIFT)
1119 {
1120 if (type == SCAN_IO)
1121 {
1122 /* Clock Data Bits In and Out LSB First */
1123 buffer_write(0x3b);
1124 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1125 }
1126 else if (type == SCAN_OUT)
1127 {
1128 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1129 buffer_write(0x1b);
1130 /* LOG_DEBUG("added TDI bits (o)"); */
1131 }
1132 else if (type == SCAN_IN)
1133 {
1134 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1135 buffer_write(0x2a);
1136 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1137 }
1138 buffer_write(0x0);
1139 buffer_write(last_bit);
1140 }
1141 else
1142 {
1143 int tms_bits = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1144 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1145 uint8_t mpsse_cmd;
1146
1147 /* move from Shift-IR/DR to end state */
1148 if (type != SCAN_OUT)
1149 {
1150 /* Clock Data to TMS/CS Pin with Read */
1151 mpsse_cmd = 0x6b;
1152 /* LOG_DEBUG("added TMS scan (read)"); */
1153 }
1154 else
1155 {
1156 /* Clock Data to TMS/CS Pin (no Read) */
1157 mpsse_cmd = 0x4b;
1158 /* LOG_DEBUG("added TMS scan (no read)"); */
1159 }
1160
1161 DEBUG_JTAG_IO("finish, %s", (type == SCAN_OUT) ? "no read" : "read");
1162 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
1163 }
1164
1165 if (type != SCAN_OUT)
1166 thisrun_read += 1;
1167
1168 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
1169 {
1170 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1171 exit(-1);
1172 }
1173 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1174 ft2232_buffer_size,
1175 (int)bytes_written);
1176 ft2232_buffer_size = 0;
1177
1178 if (type != SCAN_OUT)
1179 {
1180 if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK)
1181 {
1182 LOG_ERROR("couldn't read from FT2232");
1183 exit(-1);
1184 }
1185 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1186 thisrun_read,
1187 (int)bytes_read);
1188 receive_pointer += bytes_read;
1189 }
1190
1191 return ERROR_OK;
1192 }
1193
1194 static int ft2232_predict_scan_out(int scan_size, enum scan_type type)
1195 {
1196 int predicted_size = 3;
1197 int num_bytes = (scan_size - 1) / 8;
1198
1199 if (tap_get_state() != TAP_DRSHIFT)
1200 predicted_size += get_tms_buffer_requirements(tap_get_tms_path_len(tap_get_state(), TAP_DRSHIFT));
1201
1202 if (type == SCAN_IN) /* only from device to host */
1203 {
1204 /* complete bytes */
1205 predicted_size += CEIL(num_bytes, 65536) * 3;
1206
1207 /* remaining bits - 1 (up to 7) */
1208 predicted_size += ((scan_size - 1) % 8) ? 2 : 0;
1209 }
1210 else /* host to device, or bidirectional */
1211 {
1212 /* complete bytes */
1213 predicted_size += num_bytes + CEIL(num_bytes, 65536) * 3;
1214
1215 /* remaining bits -1 (up to 7) */
1216 predicted_size += ((scan_size - 1) % 8) ? 3 : 0;
1217 }
1218
1219 return predicted_size;
1220 }
1221
1222 static int ft2232_predict_scan_in(int scan_size, enum scan_type type)
1223 {
1224 int predicted_size = 0;
1225
1226 if (type != SCAN_OUT)
1227 {
1228 /* complete bytes */
1229 predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) - 1) : 0;
1230
1231 /* remaining bits - 1 */
1232 predicted_size += ((scan_size - 1) % 8) ? 1 : 0;
1233
1234 /* last bit (from TMS scan) */
1235 predicted_size += 1;
1236 }
1237
1238 /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
1239
1240 return predicted_size;
1241 }
1242
1243 static void usbjtag_reset(int trst, int srst)
1244 {
1245 enum reset_types jtag_reset_config = jtag_get_reset_config();
1246 if (trst == 1)
1247 {
1248 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1249 low_direction |= nTRSTnOE; /* switch to output pin (output is low) */
1250 else
1251 low_output &= ~nTRST; /* switch output low */
1252 }
1253 else if (trst == 0)
1254 {
1255 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1256 low_direction &= ~nTRSTnOE; /* switch to input pin (high-Z + internal and external pullup) */
1257 else
1258 low_output |= nTRST; /* switch output high */
1259 }
1260
1261 if (srst == 1)
1262 {
1263 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1264 low_output &= ~nSRST; /* switch output low */
1265 else
1266 low_direction |= nSRSTnOE; /* switch to output pin (output is low) */
1267 }
1268 else if (srst == 0)
1269 {
1270 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1271 low_output |= nSRST; /* switch output high */
1272 else
1273 low_direction &= ~nSRSTnOE; /* switch to input pin (high-Z) */
1274 }
1275
1276 /* command "set data bits low byte" */
1277 buffer_write(0x80);
1278 buffer_write(low_output);
1279 buffer_write(low_direction);
1280 }
1281
1282 static void jtagkey_reset(int trst, int srst)
1283 {
1284 enum reset_types jtag_reset_config = jtag_get_reset_config();
1285 if (trst == 1)
1286 {
1287 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1288 high_output &= ~nTRSTnOE;
1289 else
1290 high_output &= ~nTRST;
1291 }
1292 else if (trst == 0)
1293 {
1294 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1295 high_output |= nTRSTnOE;
1296 else
1297 high_output |= nTRST;
1298 }
1299
1300 if (srst == 1)
1301 {
1302 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1303 high_output &= ~nSRST;
1304 else
1305 high_output &= ~nSRSTnOE;
1306 }
1307 else if (srst == 0)
1308 {
1309 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1310 high_output |= nSRST;
1311 else
1312 high_output |= nSRSTnOE;
1313 }
1314
1315 /* command "set data bits high byte" */
1316 buffer_write(0x82);
1317 buffer_write(high_output);
1318 buffer_write(high_direction);
1319 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1320 high_direction);
1321 }
1322
1323 static void olimex_jtag_reset(int trst, int srst)
1324 {
1325 enum reset_types jtag_reset_config = jtag_get_reset_config();
1326 if (trst == 1)
1327 {
1328 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1329 high_output &= ~nTRSTnOE;
1330 else
1331 high_output &= ~nTRST;
1332 }
1333 else if (trst == 0)
1334 {
1335 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1336 high_output |= nTRSTnOE;
1337 else
1338 high_output |= nTRST;
1339 }
1340
1341 if (srst == 1)
1342 {
1343 high_output |= nSRST;
1344 }
1345 else if (srst == 0)
1346 {
1347 high_output &= ~nSRST;
1348 }
1349
1350 /* command "set data bits high byte" */
1351 buffer_write(0x82);
1352 buffer_write(high_output);
1353 buffer_write(high_direction);
1354 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1355 high_direction);
1356 }
1357
1358 static void axm0432_jtag_reset(int trst, int srst)
1359 {
1360 if (trst == 1)
1361 {
1362 tap_set_state(TAP_RESET);
1363 high_output &= ~nTRST;
1364 }
1365 else if (trst == 0)
1366 {
1367 high_output |= nTRST;
1368 }
1369
1370 if (srst == 1)
1371 {
1372 high_output &= ~nSRST;
1373 }
1374 else if (srst == 0)
1375 {
1376 high_output |= nSRST;
1377 }
1378
1379 /* command "set data bits low byte" */
1380 buffer_write(0x82);
1381 buffer_write(high_output);
1382 buffer_write(high_direction);
1383 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1384 high_direction);
1385 }
1386
1387 static void flyswatter_reset(int trst, int srst)
1388 {
1389 if (trst == 1)
1390 {
1391 low_output &= ~nTRST;
1392 }
1393 else if (trst == 0)
1394 {
1395 low_output |= nTRST;
1396 }
1397
1398 if (srst == 1)
1399 {
1400 low_output |= nSRST;
1401 }
1402 else if (srst == 0)
1403 {
1404 low_output &= ~nSRST;
1405 }
1406
1407 /* command "set data bits low byte" */
1408 buffer_write(0x80);
1409 buffer_write(low_output);
1410 buffer_write(low_direction);
1411 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
1412 }
1413
1414 static void turtle_reset(int trst, int srst)
1415 {
1416 trst = trst;
1417
1418 if (srst == 1)
1419 {
1420 low_output |= nSRST;
1421 }
1422 else if (srst == 0)
1423 {
1424 low_output &= ~nSRST;
1425 }
1426
1427 /* command "set data bits low byte" */
1428 buffer_write(0x80);
1429 buffer_write(low_output);
1430 buffer_write(low_direction);
1431 LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst, low_output, low_direction);
1432 }
1433
1434 static void comstick_reset(int trst, int srst)
1435 {
1436 if (trst == 1)
1437 {
1438 high_output &= ~nTRST;
1439 }
1440 else if (trst == 0)
1441 {
1442 high_output |= nTRST;
1443 }
1444
1445 if (srst == 1)
1446 {
1447 high_output &= ~nSRST;
1448 }
1449 else if (srst == 0)
1450 {
1451 high_output |= nSRST;
1452 }
1453
1454 /* command "set data bits high byte" */
1455 buffer_write(0x82);
1456 buffer_write(high_output);
1457 buffer_write(high_direction);
1458 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1459 high_direction);
1460 }
1461
1462 static void stm32stick_reset(int trst, int srst)
1463 {
1464 if (trst == 1)
1465 {
1466 high_output &= ~nTRST;
1467 }
1468 else if (trst == 0)
1469 {
1470 high_output |= nTRST;
1471 }
1472
1473 if (srst == 1)
1474 {
1475 low_output &= ~nSRST;
1476 }
1477 else if (srst == 0)
1478 {
1479 low_output |= nSRST;
1480 }
1481
1482 /* command "set data bits low byte" */
1483 buffer_write(0x80);
1484 buffer_write(low_output);
1485 buffer_write(low_direction);
1486
1487 /* command "set data bits high byte" */
1488 buffer_write(0x82);
1489 buffer_write(high_output);
1490 buffer_write(high_direction);
1491 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1492 high_direction);
1493 }
1494
1495 static void sheevaplug_reset(int trst, int srst)
1496 {
1497 if (trst == 1)
1498 high_output &= ~nTRST;
1499 else if (trst == 0)
1500 high_output |= nTRST;
1501
1502 if (srst == 1)
1503 high_output &= ~nSRSTnOE;
1504 else if (srst == 0)
1505 high_output |= nSRSTnOE;
1506
1507 /* command "set data bits high byte" */
1508 buffer_write(0x82);
1509 buffer_write(high_output);
1510 buffer_write(high_direction);
1511 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
1512 }
1513
1514 static int ft2232_execute_runtest(jtag_command_t *cmd)
1515 {
1516 int retval;
1517 int i;
1518 int predicted_size = 0;
1519 retval = ERROR_OK;
1520
1521 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1522 cmd->cmd.runtest->num_cycles,
1523 tap_state_name(cmd->cmd.runtest->end_state));
1524
1525 /* only send the maximum buffer size that FT2232C can handle */
1526 predicted_size = 0;
1527 if (tap_get_state() != TAP_IDLE)
1528 predicted_size += 3;
1529 predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7);
1530 if (cmd->cmd.runtest->end_state != TAP_IDLE)
1531 predicted_size += 3;
1532 if (tap_get_end_state() != TAP_IDLE)
1533 predicted_size += 3;
1534 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1535 {
1536 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1537 retval = ERROR_JTAG_QUEUE_FAILED;
1538 require_send = 0;
1539 first_unsent = cmd;
1540 }
1541 if (tap_get_state() != TAP_IDLE)
1542 {
1543 move_to_state(TAP_IDLE);
1544 require_send = 1;
1545 }
1546 i = cmd->cmd.runtest->num_cycles;
1547 while (i > 0)
1548 {
1549 /* there are no state transitions in this code, so omit state tracking */
1550
1551 /* command "Clock Data to TMS/CS Pin (no Read)" */
1552 buffer_write(0x4b);
1553
1554 /* scan 7 bits */
1555 buffer_write((i > 7) ? 6 : (i - 1));
1556
1557 /* TMS data bits */
1558 buffer_write(0x0);
1559
1560 i -= (i > 7) ? 7 : i;
1561 /* LOG_DEBUG("added TMS scan (no read)"); */
1562 }
1563
1564 ft2232_end_state(cmd->cmd.runtest->end_state);
1565
1566 if (tap_get_state() != tap_get_end_state())
1567 {
1568 move_to_state(tap_get_end_state());
1569 }
1570
1571 require_send = 1;
1572 DEBUG_JTAG_IO("runtest: %i, end in %s",
1573 cmd->cmd.runtest->num_cycles,
1574 tap_state_name(tap_get_end_state()));
1575 return retval;
1576 }
1577
1578 static int ft2232_execute_statemove(jtag_command_t *cmd)
1579 {
1580 int predicted_size = 0;
1581 int retval = ERROR_OK;
1582
1583 DEBUG_JTAG_IO("statemove end in %s",
1584 tap_state_name(cmd->cmd.statemove->end_state));
1585
1586 /* only send the maximum buffer size that FT2232C can handle */
1587 predicted_size = 3;
1588 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1589 {
1590 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1591 retval = ERROR_JTAG_QUEUE_FAILED;
1592 require_send = 0;
1593 first_unsent = cmd;
1594 }
1595 ft2232_end_state(cmd->cmd.statemove->end_state);
1596
1597 /* For TAP_RESET, ignore the current recorded state. It's often
1598 * wrong at server startup, and this transation is critical whenever
1599 * it's requested.
1600 */
1601 if (tap_get_end_state() == TAP_RESET) {
1602 clock_tms(0x4b, 0xff, 5, 0);
1603 require_send = 1;
1604
1605 /* shortest-path move to desired end state */
1606 } else if (tap_get_state() != tap_get_end_state())
1607 {
1608 move_to_state(tap_get_end_state());
1609 require_send = 1;
1610 }
1611
1612 return retval;
1613 }
1614
1615 static int ft2232_execute_pathmove(jtag_command_t *cmd)
1616 {
1617 int predicted_size = 0;
1618 int retval = ERROR_OK;
1619
1620 tap_state_t* path = cmd->cmd.pathmove->path;
1621 int num_states = cmd->cmd.pathmove->num_states;
1622
1623 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states,
1624 tap_state_name(tap_get_state()),
1625 tap_state_name(path[num_states-1]));
1626
1627 /* only send the maximum buffer size that FT2232C can handle */
1628 predicted_size = 3 * CEIL(num_states, 7);
1629 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1630 {
1631 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1632 retval = ERROR_JTAG_QUEUE_FAILED;
1633
1634 require_send = 0;
1635 first_unsent = cmd;
1636 }
1637
1638 ft2232_add_pathmove(path, num_states);
1639 require_send = 1;
1640
1641 return retval;
1642 }
1643
1644 static int ft2232_execute_scan(jtag_command_t *cmd)
1645 {
1646 uint8_t* buffer;
1647 int scan_size; /* size of IR or DR scan */
1648 int predicted_size = 0;
1649 int retval = ERROR_OK;
1650
1651 enum scan_type type = jtag_scan_type(cmd->cmd.scan);
1652
1653 DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", type);
1654
1655 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1656
1657 predicted_size = ft2232_predict_scan_out(scan_size, type);
1658 if ((predicted_size + 1) > FT2232_BUFFER_SIZE)
1659 {
1660 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1661 /* unsent commands before this */
1662 if (first_unsent != cmd)
1663 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1664 retval = ERROR_JTAG_QUEUE_FAILED;
1665
1666 /* current command */
1667 ft2232_end_state(cmd->cmd.scan->end_state);
1668 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1669 require_send = 0;
1670 first_unsent = cmd->next;
1671 if (buffer)
1672 free(buffer);
1673 return retval;
1674 }
1675 else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1676 {
1677 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1678 first_unsent,
1679 cmd);
1680 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1681 retval = ERROR_JTAG_QUEUE_FAILED;
1682 require_send = 0;
1683 first_unsent = cmd;
1684 }
1685 ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1686 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1687 ft2232_end_state(cmd->cmd.scan->end_state);
1688 ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1689 require_send = 1;
1690 if (buffer)
1691 free(buffer);
1692 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
1693 (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1694 tap_state_name(tap_get_end_state()));
1695 return retval;
1696
1697 }
1698
1699 static int ft2232_execute_reset(jtag_command_t *cmd)
1700 {
1701 int retval;
1702 int predicted_size = 0;
1703 retval = ERROR_OK;
1704
1705 DEBUG_JTAG_IO("reset trst: %i srst %i",
1706 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1707
1708 /* only send the maximum buffer size that FT2232C can handle */
1709 predicted_size = 3;
1710 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1711 {
1712 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1713 retval = ERROR_JTAG_QUEUE_FAILED;
1714 require_send = 0;
1715 first_unsent = cmd;
1716 }
1717
1718 if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
1719 {
1720 tap_set_state(TAP_RESET);
1721 }
1722
1723 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1724 require_send = 1;
1725
1726 DEBUG_JTAG_IO("trst: %i, srst: %i",
1727 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1728 return retval;
1729 }
1730
1731 static int ft2232_execute_sleep(jtag_command_t *cmd)
1732 {
1733 int retval;
1734 retval = ERROR_OK;
1735
1736 DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
1737
1738 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1739 retval = ERROR_JTAG_QUEUE_FAILED;
1740 first_unsent = cmd->next;
1741 jtag_sleep(cmd->cmd.sleep->us);
1742 DEBUG_JTAG_IO("sleep %i usec while in %s",
1743 cmd->cmd.sleep->us,
1744 tap_state_name(tap_get_state()));
1745 return retval;
1746 }
1747
1748 static int ft2232_execute_stableclocks(jtag_command_t *cmd)
1749 {
1750 int retval;
1751 retval = ERROR_OK;
1752
1753 /* this is only allowed while in a stable state. A check for a stable
1754 * state was done in jtag_add_clocks()
1755 */
1756 if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1757 retval = ERROR_JTAG_QUEUE_FAILED;
1758 DEBUG_JTAG_IO("clocks %i while in %s",
1759 cmd->cmd.stableclocks->num_cycles,
1760 tap_state_name(tap_get_state()));
1761 return retval;
1762 }
1763
1764 static int ft2232_execute_command(jtag_command_t *cmd)
1765 {
1766 int retval;
1767 retval = ERROR_OK;
1768
1769 switch (cmd->type)
1770 {
1771 case JTAG_RESET: retval = ft2232_execute_reset(cmd); break;
1772 case JTAG_RUNTEST: retval = ft2232_execute_runtest(cmd); break;
1773 case JTAG_STATEMOVE: retval = ft2232_execute_statemove(cmd); break;
1774 case JTAG_PATHMOVE: retval = ft2232_execute_pathmove(cmd); break;
1775 case JTAG_SCAN: retval = ft2232_execute_scan(cmd); break;
1776 case JTAG_SLEEP: retval = ft2232_execute_sleep(cmd); break;
1777 case JTAG_STABLECLOCKS: retval = ft2232_execute_stableclocks(cmd); break;
1778 default:
1779 LOG_ERROR("BUG: unknown JTAG command type encountered");
1780 exit(-1);
1781 }
1782 return retval;
1783 }
1784
1785 static int ft2232_execute_queue()
1786 {
1787 jtag_command_t* cmd = jtag_command_queue; /* currently processed command */
1788 int retval;
1789
1790 first_unsent = cmd; /* next command that has to be sent */
1791 require_send = 0;
1792
1793 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1794 * that wasn't handled by a caller-provided error handler
1795 */
1796 retval = ERROR_OK;
1797
1798 ft2232_buffer_size = 0;
1799 ft2232_expect_read = 0;
1800
1801 /* blink, if the current layout has that feature */
1802 if (layout->blink)
1803 layout->blink();
1804
1805 while (cmd)
1806 {
1807 if (ft2232_execute_command(cmd) != ERROR_OK)
1808 retval = ERROR_JTAG_QUEUE_FAILED;
1809 /* Start reading input before FT2232 TX buffer fills up */
1810 cmd = cmd->next;
1811 if (ft2232_expect_read > 256)
1812 {
1813 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1814 retval = ERROR_JTAG_QUEUE_FAILED;
1815 first_unsent = cmd;
1816 }
1817 }
1818
1819 if (require_send > 0)
1820 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1821 retval = ERROR_JTAG_QUEUE_FAILED;
1822
1823 return retval;
1824 }
1825
1826 #if BUILD_FT2232_FTD2XX == 1
1827 static int ft2232_init_ftd2xx(uint16_t vid, uint16_t pid, int more, int* try_more)
1828 {
1829 FT_STATUS status;
1830 DWORD deviceID;
1831 char SerialNumber[16];
1832 char Description[64];
1833 DWORD openex_flags = 0;
1834 char* openex_string = NULL;
1835 uint8_t latency_timer;
1836
1837 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout, vid, pid);
1838
1839 #if IS_WIN32 == 0
1840 /* Add non-standard Vid/Pid to the linux driver */
1841 if ((status = FT_SetVIDPID(vid, pid)) != FT_OK)
1842 {
1843 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
1844 }
1845 #endif
1846
1847 if (ft2232_device_desc && ft2232_serial)
1848 {
1849 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1850 ft2232_device_desc = NULL;
1851 }
1852
1853 if (ft2232_device_desc)
1854 {
1855 openex_string = ft2232_device_desc;
1856 openex_flags = FT_OPEN_BY_DESCRIPTION;
1857 }
1858 else if (ft2232_serial)
1859 {
1860 openex_string = ft2232_serial;
1861 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
1862 }
1863 else
1864 {
1865 LOG_ERROR("neither device description nor serial number specified");
1866 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1867
1868 return ERROR_JTAG_INIT_FAILED;
1869 }
1870
1871 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1872 if (status != FT_OK) {
1873 /* under Win32, the FTD2XX driver appends an "A" to the end
1874 * of the description, if we tried by the desc, then
1875 * try by the alternate "A" description. */
1876 if (openex_string == ft2232_device_desc) {
1877 /* Try the alternate method. */
1878 openex_string = ft2232_device_desc_A;
1879 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1880 if (status == FT_OK) {
1881 /* yea, the "alternate" method worked! */
1882 } else {
1883 /* drat, give the user a meaningfull message.
1884 * telling the use we tried *BOTH* methods. */
1885 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1886 ft2232_device_desc,
1887 ft2232_device_desc_A);
1888 }
1889 }
1890 }
1891
1892 if (status != FT_OK)
1893 {
1894 DWORD num_devices;
1895
1896 if (more)
1897 {
1898 LOG_WARNING("unable to open ftdi device (trying more): %lu", status);
1899 *try_more = 1;
1900 return ERROR_JTAG_INIT_FAILED;
1901 }
1902 LOG_ERROR("unable to open ftdi device: %lu", status);
1903 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
1904 if (status == FT_OK)
1905 {
1906 char** desc_array = malloc(sizeof(char*) * (num_devices + 1));
1907 uint32_t i;
1908
1909 for (i = 0; i < num_devices; i++)
1910 desc_array[i] = malloc(64);
1911
1912 desc_array[num_devices] = NULL;
1913
1914 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
1915
1916 if (status == FT_OK)
1917 {
1918 LOG_ERROR("ListDevices: %lu\n", num_devices);
1919 for (i = 0; i < num_devices; i++)
1920 LOG_ERROR("%" PRIu32 ": \"%s\"", i, desc_array[i]);
1921 }
1922
1923 for (i = 0; i < num_devices; i++)
1924 free(desc_array[i]);
1925
1926 free(desc_array);
1927 }
1928 else
1929 {
1930 LOG_ERROR("ListDevices: NONE\n");
1931 }
1932 return ERROR_JTAG_INIT_FAILED;
1933 }
1934
1935 if ((status = FT_SetLatencyTimer(ftdih, ft2232_latency)) != FT_OK)
1936 {
1937 LOG_ERROR("unable to set latency timer: %lu", status);
1938 return ERROR_JTAG_INIT_FAILED;
1939 }
1940
1941 if ((status = FT_GetLatencyTimer(ftdih, &latency_timer)) != FT_OK)
1942 {
1943 LOG_ERROR("unable to get latency timer: %lu", status);
1944 return ERROR_JTAG_INIT_FAILED;
1945 }
1946 else
1947 {
1948 LOG_DEBUG("current latency timer: %i", latency_timer);
1949 }
1950
1951 if ((status = FT_SetTimeouts(ftdih, 5000, 5000)) != FT_OK)
1952 {
1953 LOG_ERROR("unable to set timeouts: %lu", status);
1954 return ERROR_JTAG_INIT_FAILED;
1955 }
1956
1957 if ((status = FT_SetBitMode(ftdih, 0x0b, 2)) != FT_OK)
1958 {
1959 LOG_ERROR("unable to enable bit i/o mode: %lu", status);
1960 return ERROR_JTAG_INIT_FAILED;
1961 }
1962
1963 if ((status = FT_GetDeviceInfo(ftdih, &ftdi_device, &deviceID, SerialNumber, Description, NULL)) != FT_OK)
1964 {
1965 LOG_ERROR("unable to get FT_GetDeviceInfo: %lu", status);
1966 return ERROR_JTAG_INIT_FAILED;
1967 }
1968 else
1969 {
1970 static const char* type_str[] =
1971 {"BM", "AM", "100AX", "UNKNOWN", "2232C", "232R", "2232H", "4232H"};
1972 unsigned no_of_known_types = sizeof(type_str) / sizeof(type_str[0]) - 1;
1973 unsigned type_index = ((unsigned)ftdi_device <= no_of_known_types)
1974 ? ftdi_device : FT_DEVICE_UNKNOWN;
1975 LOG_INFO("device: %lu \"%s\"", ftdi_device, type_str[type_index]);
1976 LOG_INFO("deviceID: %lu", deviceID);
1977 LOG_INFO("SerialNumber: %s", SerialNumber);
1978 LOG_INFO("Description: %s", Description);
1979 }
1980
1981 return ERROR_OK;
1982 }
1983
1984 static int ft2232_purge_ftd2xx(void)
1985 {
1986 FT_STATUS status;
1987
1988 if ((status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX)) != FT_OK)
1989 {
1990 LOG_ERROR("error purging ftd2xx device: %lu", status);
1991 return ERROR_JTAG_INIT_FAILED;
1992 }
1993
1994 return ERROR_OK;
1995 }
1996
1997 #endif /* BUILD_FT2232_FTD2XX == 1 */
1998
1999 #if BUILD_FT2232_LIBFTDI == 1
2000 static int ft2232_init_libftdi(uint16_t vid, uint16_t pid, int more, int* try_more)
2001 {
2002 uint8_t latency_timer;
2003
2004 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
2005 ft2232_layout, vid, pid);
2006
2007 if (ftdi_init(&ftdic) < 0)
2008 return ERROR_JTAG_INIT_FAILED;
2009
2010 if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
2011 {
2012 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
2013 return ERROR_JTAG_INIT_FAILED;
2014 }
2015
2016 /* context, vendor id, product id */
2017 if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc,
2018 ft2232_serial) < 0)
2019 {
2020 if (more)
2021 LOG_WARNING("unable to open ftdi device (trying more): %s",
2022 ftdic.error_str);
2023 else
2024 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
2025 *try_more = 1;
2026 return ERROR_JTAG_INIT_FAILED;
2027 }
2028
2029 /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
2030 if (ftdi_usb_reset(&ftdic) < 0)
2031 {
2032 LOG_ERROR("unable to reset ftdi device");
2033 return ERROR_JTAG_INIT_FAILED;
2034 }
2035
2036 if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0)
2037 {
2038 LOG_ERROR("unable to set latency timer");
2039 return ERROR_JTAG_INIT_FAILED;
2040 }
2041
2042 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
2043 {
2044 LOG_ERROR("unable to get latency timer");
2045 return ERROR_JTAG_INIT_FAILED;
2046 }
2047 else
2048 {
2049 LOG_DEBUG("current latency timer: %i", latency_timer);
2050 }
2051
2052 ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
2053
2054 ftdi_device = ftdic.type;
2055 static const char* type_str[] =
2056 {"AM", "BM", "2232C", "R", "2232H", "4232H", "Unknown"};
2057 unsigned no_of_known_types = sizeof(type_str) / sizeof(type_str[0]) - 1;
2058 unsigned type_index = ((unsigned)ftdi_device < no_of_known_types)
2059 ? ftdi_device : no_of_known_types;
2060 LOG_DEBUG("FTDI chip type: %i \"%s\"", (int)ftdi_device, type_str[type_index]);
2061 return ERROR_OK;
2062 }
2063
2064 static int ft2232_purge_libftdi(void)
2065 {
2066 if (ftdi_usb_purge_buffers(&ftdic) < 0)
2067 {
2068 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
2069 return ERROR_JTAG_INIT_FAILED;
2070 }
2071
2072 return ERROR_OK;
2073 }
2074
2075 #endif /* BUILD_FT2232_LIBFTDI == 1 */
2076
2077 static int ft2232_init(void)
2078 {
2079 uint8_t buf[1];
2080 int retval;
2081 uint32_t bytes_written;
2082 const ft2232_layout_t* cur_layout = ft2232_layouts;
2083 int i;
2084
2085 if (tap_get_tms_path_len(TAP_IRPAUSE,TAP_IRPAUSE) == 7)
2086 {
2087 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
2088 }
2089 else
2090 {
2091 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
2092
2093 }
2094 if ((ft2232_layout == NULL) || (ft2232_layout[0] == 0))
2095 {
2096 ft2232_layout = "usbjtag";
2097 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
2098 }
2099
2100 while (cur_layout->name)
2101 {
2102 if (strcmp(cur_layout->name, ft2232_layout) == 0)
2103 {
2104 layout = cur_layout;
2105 break;
2106 }
2107 cur_layout++;
2108 }
2109
2110 if (!layout)
2111 {
2112 LOG_ERROR("No matching layout found for %s", ft2232_layout);
2113 return ERROR_JTAG_INIT_FAILED;
2114 }
2115
2116 for (i = 0; 1; i++)
2117 {
2118 /*
2119 * "more indicates that there are more IDs to try, so we should
2120 * not print an error for an ID mismatch (but for anything
2121 * else, we should).
2122 *
2123 * try_more indicates that the error code returned indicates an
2124 * ID mismatch (and nothing else) and that we should proceeed
2125 * with the next ID pair.
2126 */
2127 int more = ft2232_vid[i + 1] || ft2232_pid[i + 1];
2128 int try_more = 0;
2129
2130 #if BUILD_FT2232_FTD2XX == 1
2131 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
2132 more, &try_more);
2133 #elif BUILD_FT2232_LIBFTDI == 1
2134 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
2135 more, &try_more);
2136 #endif
2137 if (retval >= 0)
2138 break;
2139 if (!more || !try_more)
2140 return retval;
2141 }
2142
2143 ft2232_buffer_size = 0;
2144 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
2145
2146 if (layout->init() != ERROR_OK)
2147 return ERROR_JTAG_INIT_FAILED;
2148
2149 if (ft2232_device_is_highspeed())
2150 {
2151 #ifndef BUILD_FT2232_HIGHSPEED
2152 #if BUILD_FT2232_FTD2XX == 1
2153 LOG_WARNING("High Speed device found - You need a newer FTD2XX driver (version 2.04.16 or later)");
2154 #elif BUILD_FT2232_LIBFTDI == 1
2155 LOG_WARNING("High Speed device found - You need a newer libftdi version (0.16 or later)");
2156 #endif
2157 #endif
2158 /* make sure the legacy mode is disabled */
2159 if (ft2232h_ft4232h_clk_divide_by_5(false) != ERROR_OK)
2160 return ERROR_JTAG_INIT_FAILED;
2161 }
2162
2163 ft2232_speed(jtag_get_speed());
2164
2165 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2166 if (((retval = ft2232_write(buf, 1, &bytes_written)) != ERROR_OK) || (bytes_written != 1))
2167 {
2168 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2169 return ERROR_JTAG_INIT_FAILED;
2170 }
2171
2172 #if BUILD_FT2232_FTD2XX == 1
2173 return ft2232_purge_ftd2xx();
2174 #elif BUILD_FT2232_LIBFTDI == 1
2175 return ft2232_purge_libftdi();
2176 #endif
2177
2178 return ERROR_OK;
2179 }
2180
2181 static int usbjtag_init(void)
2182 {
2183 uint8_t buf[3];
2184 uint32_t bytes_written;
2185
2186 low_output = 0x08;
2187 low_direction = 0x0b;
2188
2189 if (strcmp(ft2232_layout, "usbjtag") == 0)
2190 {
2191 nTRST = 0x10;
2192 nTRSTnOE = 0x10;
2193 nSRST = 0x40;
2194 nSRSTnOE = 0x40;
2195 }
2196 else if (strcmp(ft2232_layout, "signalyzer") == 0)
2197 {
2198 nTRST = 0x10;
2199 nTRSTnOE = 0x10;
2200 nSRST = 0x20;
2201 nSRSTnOE = 0x20;
2202 }
2203 else if (strcmp(ft2232_layout, "evb_lm3s811") == 0)
2204 {
2205 nTRST = 0x0;
2206 nTRSTnOE = 0x00;
2207 nSRST = 0x20;
2208 nSRSTnOE = 0x20;
2209 low_output = 0x88;
2210 low_direction = 0x8b;
2211 }
2212 else if (strcmp(ft2232_layout, "luminary_icdi") == 0)
2213 {
2214 nTRST = 0x0;
2215 nTRSTnOE = 0x00;
2216 nSRST = 0x20;
2217 nSRSTnOE = 0x20;
2218 low_output = 0x88;
2219 low_direction = 0xcb;
2220 }
2221 else
2222 {
2223 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout);
2224 return ERROR_JTAG_INIT_FAILED;
2225 }
2226
2227 enum reset_types jtag_reset_config = jtag_get_reset_config();
2228 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2229 {
2230 low_direction &= ~nTRSTnOE; /* nTRST input */
2231 low_output &= ~nTRST; /* nTRST = 0 */
2232 }
2233 else
2234 {
2235 low_direction |= nTRSTnOE; /* nTRST output */
2236 low_output |= nTRST; /* nTRST = 1 */
2237 }
2238
2239 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2240 {
2241 low_direction |= nSRSTnOE; /* nSRST output */
2242 low_output |= nSRST; /* nSRST = 1 */
2243 }
2244 else
2245 {
2246 low_direction &= ~nSRSTnOE; /* nSRST input */
2247 low_output &= ~nSRST; /* nSRST = 0 */
2248 }
2249
2250 /* initialize low byte for jtag */
2251 buf[0] = 0x80; /* command "set data bits low byte" */
2252 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, xRST high) */
2253 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
2254 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2255
2256 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2257 {
2258 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
2259 return ERROR_JTAG_INIT_FAILED;
2260 }
2261
2262 return ERROR_OK;
2263 }
2264
2265 static int axm0432_jtag_init(void)
2266 {
2267 uint8_t buf[3];
2268 uint32_t bytes_written;
2269
2270 low_output = 0x08;
2271 low_direction = 0x2b;
2272
2273 /* initialize low byte for jtag */
2274 buf[0] = 0x80; /* command "set data bits low byte" */
2275 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2276 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2277 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2278
2279 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2280 {
2281 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2282 return ERROR_JTAG_INIT_FAILED;
2283 }
2284
2285 if (strcmp(layout->name, "axm0432_jtag") == 0)
2286 {
2287 nTRST = 0x08;
2288 nTRSTnOE = 0x0; /* No output enable for TRST*/
2289 nSRST = 0x04;
2290 nSRSTnOE = 0x0; /* No output enable for SRST*/
2291 }
2292 else
2293 {
2294 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2295 exit(-1);
2296 }
2297
2298 high_output = 0x0;
2299 high_direction = 0x0c;
2300
2301 enum reset_types jtag_reset_config = jtag_get_reset_config();
2302 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2303 {
2304 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2305 }
2306 else
2307 {
2308 high_output |= nTRST;
2309 }
2310
2311 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2312 {
2313 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2314 }
2315 else
2316 {
2317 high_output |= nSRST;
2318 }
2319
2320 /* initialize high port */
2321 buf[0] = 0x82; /* command "set data bits high byte" */
2322 buf[1] = high_output; /* value */
2323 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2324 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2325
2326 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2327 {
2328 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2329 return ERROR_JTAG_INIT_FAILED;
2330 }
2331
2332 return ERROR_OK;
2333 }
2334
2335 static int jtagkey_init(void)
2336 {
2337 uint8_t buf[3];
2338 uint32_t bytes_written;
2339
2340 low_output = 0x08;
2341 low_direction = 0x1b;
2342
2343 /* initialize low byte for jtag */
2344 buf[0] = 0x80; /* command "set data bits low byte" */
2345 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2346 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2347 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2348
2349 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2350 {
2351 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2352 return ERROR_JTAG_INIT_FAILED;
2353 }
2354
2355 if (strcmp(layout->name, "jtagkey") == 0)
2356 {
2357 nTRST = 0x01;
2358 nTRSTnOE = 0x4;
2359 nSRST = 0x02;
2360 nSRSTnOE = 0x08;
2361 }
2362 else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2363 || (strcmp(layout->name, "oocdlink") == 0))
2364 {
2365 nTRST = 0x02;
2366 nTRSTnOE = 0x1;
2367 nSRST = 0x08;
2368 nSRSTnOE = 0x04;
2369 }
2370 else
2371 {
2372 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2373 exit(-1);
2374 }
2375
2376 high_output = 0x0;
2377 high_direction = 0x0f;
2378
2379 enum reset_types jtag_reset_config = jtag_get_reset_config();
2380 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2381 {
2382 high_output |= nTRSTnOE;
2383 high_output &= ~nTRST;
2384 }
2385 else
2386 {
2387 high_output &= ~nTRSTnOE;
2388 high_output |= nTRST;
2389 }
2390
2391 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2392 {
2393 high_output &= ~nSRSTnOE;
2394 high_output |= nSRST;
2395 }
2396 else
2397 {
2398 high_output |= nSRSTnOE;
2399 high_output &= ~nSRST;
2400 }
2401
2402 /* initialize high port */
2403 buf[0] = 0x82; /* command "set data bits high byte" */
2404 buf[1] = high_output; /* value */
2405 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2406 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2407
2408 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2409 {
2410 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2411 return ERROR_JTAG_INIT_FAILED;
2412 }
2413
2414 return ERROR_OK;
2415 }
2416
2417 static int olimex_jtag_init(void)
2418 {
2419 uint8_t buf[3];
2420 uint32_t bytes_written;
2421
2422 low_output = 0x08;
2423 low_direction = 0x1b;
2424
2425 /* initialize low byte for jtag */
2426 buf[0] = 0x80; /* command "set data bits low byte" */
2427 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2428 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2429 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2430
2431 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2432 {
2433 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2434 return ERROR_JTAG_INIT_FAILED;
2435 }
2436
2437 nTRST = 0x01;
2438 nTRSTnOE = 0x4;
2439 nSRST = 0x02;
2440 nSRSTnOE = 0x00; /* no output enable for nSRST */
2441
2442 high_output = 0x0;
2443 high_direction = 0x0f;
2444
2445 enum reset_types jtag_reset_config = jtag_get_reset_config();
2446 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2447 {
2448 high_output |= nTRSTnOE;
2449 high_output &= ~nTRST;
2450 }
2451 else
2452 {
2453 high_output &= ~nTRSTnOE;
2454 high_output |= nTRST;
2455 }
2456
2457 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2458 {
2459 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2460 }
2461 else
2462 {
2463 high_output &= ~nSRST;
2464 }
2465
2466 /* turn red LED on */
2467 high_output |= 0x08;
2468
2469 /* initialize high port */
2470 buf[0] = 0x82; /* command "set data bits high byte" */
2471 buf[1] = high_output; /* value */
2472 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2473 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2474
2475 if ((ft2232_write(buf, 3, &bytes_written) != ERROR_OK) || (bytes_written != 3))
2476 {
2477 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2478 return ERROR_JTAG_INIT_FAILED;
2479 }
2480
2481 return ERROR_OK;
2482 }
2483
2484 static int flyswatter_init(void)
2485 {
2486 uint8_t buf[3];
2487 uint32_t bytes_written;
2488
2489 low_output = 0x18;
2490 low_direction = 0xfb;
2491
2492 /* initialize low byte for jtag */
2493 buf[0] = 0x80; /* command "set data bits low byte" */
2494 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2495 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE[12]=out, n[ST]srst = out */
2496 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2497
2498 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2499 {
2500 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2501 return ERROR_JTAG_INIT_FAILED;
2502 }
2503
2504 nTRST = 0x10;
2505 nTRSTnOE = 0x0; /* not output enable for nTRST */
2506 nSRST = 0x20;
2507 nSRSTnOE = 0x00; /* no output enable for nSRST */
2508
2509 high_output = 0x00;
2510 high_direction = 0x0c;
2511
2512 /* turn red LED3 on, LED2 off */
2513 high_output |= 0x08;
2514
2515 /* initialize high port */
2516 buf[0] = 0x82; /* command "set data bits high byte" */
2517 buf[1] = high_output; /* value */
2518 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2519 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2520
2521 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2522 {
2523 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2524 return ERROR_JTAG_INIT_FAILED;
2525 }
2526
2527 return ERROR_OK;
2528 }
2529
2530 static int turtle_init(void)
2531 {
2532 uint8_t buf[3];
2533 uint32_t bytes_written;
2534
2535 low_output = 0x08;
2536 low_direction = 0x5b;
2537
2538 /* initialize low byte for jtag */
2539 buf[0] = 0x80; /* command "set data bits low byte" */
2540 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2541 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2542 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2543
2544 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2545 {
2546 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2547 return ERROR_JTAG_INIT_FAILED;
2548 }
2549
2550 nSRST = 0x40;
2551
2552 high_output = 0x00;
2553 high_direction = 0x0C;
2554
2555 /* initialize high port */
2556 buf[0] = 0x82; /* command "set data bits high byte" */
2557 buf[1] = high_output;
2558 buf[2] = high_direction;
2559 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2560
2561 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2562 {
2563 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2564 return ERROR_JTAG_INIT_FAILED;
2565 }
2566
2567 return ERROR_OK;
2568 }
2569
2570 static int comstick_init(void)
2571 {
2572 uint8_t buf[3];
2573 uint32_t bytes_written;
2574
2575 low_output = 0x08;
2576 low_direction = 0x0b;
2577
2578 /* initialize low byte for jtag */
2579 buf[0] = 0x80; /* command "set data bits low byte" */
2580 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2581 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2582 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2583
2584 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2585 {
2586 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2587 return ERROR_JTAG_INIT_FAILED;
2588 }
2589
2590 nTRST = 0x01;
2591 nTRSTnOE = 0x00; /* no output enable for nTRST */
2592 nSRST = 0x02;
2593 nSRSTnOE = 0x00; /* no output enable for nSRST */
2594
2595 high_output = 0x03;
2596 high_direction = 0x03;
2597
2598 /* initialize high port */
2599 buf[0] = 0x82; /* command "set data bits high byte" */
2600 buf[1] = high_output;
2601 buf[2] = high_direction;
2602 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2603
2604 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2605 {
2606 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2607 return ERROR_JTAG_INIT_FAILED;
2608 }
2609
2610 return ERROR_OK;
2611 }
2612
2613 static int stm32stick_init(void)
2614 {
2615 uint8_t buf[3];
2616 uint32_t bytes_written;
2617
2618 low_output = 0x88;
2619 low_direction = 0x8b;
2620
2621 /* initialize low byte for jtag */
2622 buf[0] = 0x80; /* command "set data bits low byte" */
2623 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2624 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2625 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2626
2627 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2628 {
2629 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2630 return ERROR_JTAG_INIT_FAILED;
2631 }
2632
2633 nTRST = 0x01;
2634 nTRSTnOE = 0x00; /* no output enable for nTRST */
2635 nSRST = 0x80;
2636 nSRSTnOE = 0x00; /* no output enable for nSRST */
2637
2638 high_output = 0x01;
2639 high_direction = 0x03;
2640
2641 /* initialize high port */
2642 buf[0] = 0x82; /* command "set data bits high byte" */
2643 buf[1] = high_output;
2644 buf[2] = high_direction;
2645 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2646
2647 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2648 {
2649 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2650 return ERROR_JTAG_INIT_FAILED;
2651 }
2652
2653 return ERROR_OK;
2654 }
2655
2656 static int sheevaplug_init(void)
2657 {
2658 uint8_t buf[3];
2659 uint32_t bytes_written;
2660
2661 low_output = 0x08;
2662 low_direction = 0x1b;
2663
2664 /* initialize low byte for jtag */
2665 buf[0] = 0x80; /* command "set data bits low byte" */
2666 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2667 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
2668 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2669
2670 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2671 {
2672 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2673 return ERROR_JTAG_INIT_FAILED;
2674 }
2675
2676 nTRSTnOE = 0x1;
2677 nTRST = 0x02;
2678 nSRSTnOE = 0x4;
2679 nSRST = 0x08;
2680
2681 high_output = 0x0;
2682 high_direction = 0x0f;
2683
2684 /* nTRST is always push-pull */
2685 high_output &= ~nTRSTnOE;
2686 high_output |= nTRST;
2687
2688 /* nSRST is always open-drain */
2689 high_output |= nSRSTnOE;
2690 high_output &= ~nSRST;
2691
2692 /* initialize high port */
2693 buf[0] = 0x82; /* command "set data bits high byte" */
2694 buf[1] = high_output; /* value */
2695 buf[2] = high_direction; /* all outputs - xRST */
2696 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2697
2698 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2699 {
2700 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2701 return ERROR_JTAG_INIT_FAILED;
2702 }
2703
2704 return ERROR_OK;
2705 }
2706
2707 static int cortino_jtag_init(void)
2708 {
2709 uint8_t buf[3];
2710 uint32_t bytes_written;
2711
2712 low_output = 0x08;
2713 low_direction = 0x1b;
2714
2715 /* initialize low byte for jtag */
2716 buf[0] = 0x80; /* command "set data bits low byte" */
2717 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2718 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2719 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2720
2721 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2722 {
2723 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2724 return ERROR_JTAG_INIT_FAILED;
2725 }
2726
2727 nTRST = 0x01;
2728 nTRSTnOE = 0x00; /* no output enable for nTRST */
2729 nSRST = 0x02;
2730 nSRSTnOE = 0x00; /* no output enable for nSRST */
2731
2732 high_output = 0x03;
2733 high_direction = 0x03;
2734
2735 /* initialize high port */
2736 buf[0] = 0x82; /* command "set data bits high byte" */
2737 buf[1] = high_output;
2738 buf[2] = high_direction;
2739 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2740
2741 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2742 {
2743 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2744 return ERROR_JTAG_INIT_FAILED;
2745 }
2746
2747 return ERROR_OK;
2748 }
2749
2750 static void olimex_jtag_blink(void)
2751 {
2752 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2753 * ACBUS3 is bit 3 of the GPIOH port
2754 */
2755 if (high_output & 0x08)
2756 {
2757 /* set port pin high */
2758 high_output &= 0x07;
2759 }
2760 else
2761 {
2762 /* set port pin low */
2763 high_output |= 0x08;
2764 }
2765
2766 buffer_write(0x82);
2767 buffer_write(high_output);
2768 buffer_write(high_direction);
2769 }
2770
2771 static void flyswatter_jtag_blink(void)
2772 {
2773 /*
2774 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2775 */
2776 high_output ^= 0x0c;
2777
2778 buffer_write(0x82);
2779 buffer_write(high_output);
2780 buffer_write(high_direction);
2781 }
2782
2783 static void turtle_jtag_blink(void)
2784 {
2785 /*
2786 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2787 */
2788 if (high_output & 0x08)
2789 {
2790 high_output = 0x04;
2791 }
2792 else
2793 {
2794 high_output = 0x08;
2795 }
2796
2797 buffer_write(0x82);
2798 buffer_write(high_output);
2799 buffer_write(high_direction);
2800 }
2801
2802 static int ft2232_quit(void)
2803 {
2804 #if BUILD_FT2232_FTD2XX == 1
2805 FT_STATUS status;
2806
2807 status = FT_Close(ftdih);
2808 #elif BUILD_FT2232_LIBFTDI == 1
2809 ftdi_usb_close(&ftdic);
2810
2811 ftdi_deinit(&ftdic);
2812 #endif
2813
2814 free(ft2232_buffer);
2815 ft2232_buffer = NULL;
2816
2817 return ERROR_OK;
2818 }
2819
2820 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2821 {
2822 char *cp;
2823 char buf[200];
2824 if (argc == 1)
2825 {
2826 ft2232_device_desc = strdup(args[0]);
2827 cp = strchr(ft2232_device_desc, 0);
2828 /* under Win32, the FTD2XX driver appends an "A" to the end
2829 * of the description, this examines the given desc
2830 * and creates the 'missing' _A or non_A variable. */
2831 if ((cp[-1] == 'A') && (cp[-2]==' ')) {
2832 /* it was, so make this the "A" version. */
2833 ft2232_device_desc_A = ft2232_device_desc;
2834 /* and *CREATE* the non-A version. */
2835 strcpy(buf, ft2232_device_desc);
2836 cp = strchr(buf, 0);
2837 cp[-2] = 0;
2838 ft2232_device_desc = strdup(buf);
2839 } else {
2840 /* <space > A not defined
2841 * so create it */
2842 sprintf(buf, "%s A", ft2232_device_desc);
2843 ft2232_device_desc_A = strdup(buf);
2844 }
2845 }
2846 else
2847 {
2848 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2849 }
2850
2851 return ERROR_OK;
2852 }
2853
2854 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2855 {
2856 if (argc == 1)
2857 {
2858 ft2232_serial = strdup(args[0]);
2859 }
2860 else
2861 {
2862 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2863 }
2864
2865 return ERROR_OK;
2866 }
2867
2868 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2869 {
2870 if (argc == 0)
2871 return ERROR_OK;
2872
2873 ft2232_layout = malloc(strlen(args[0]) + 1);
2874 strcpy(ft2232_layout, args[0]);
2875
2876 return ERROR_OK;
2877 }
2878
2879 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2880 {
2881 if (argc > MAX_USB_IDS * 2)
2882 {
2883 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2884 "(maximum is %d pairs)", MAX_USB_IDS);
2885 argc = MAX_USB_IDS * 2;
2886 }
2887 if (argc < 2 || (argc & 1))
2888 {
2889 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2890 if (argc < 2)
2891 return ERROR_COMMAND_SYNTAX_ERROR;
2892 /* remove the incomplete trailing id */
2893 argc -= 1;
2894 }
2895
2896 int i;
2897 int retval = ERROR_OK;
2898 for (i = 0; i < argc; i += 2)
2899 {
2900 retval = parse_u16(args[i], &ft2232_vid[i >> 1]);
2901 if (ERROR_OK != retval)
2902 break;
2903 retval = parse_u16(args[i + 1], &ft2232_pid[i >> 1]);
2904 if (ERROR_OK != retval)
2905 break;
2906 }
2907
2908 /*
2909 * Explicitly terminate, in case there are multiples instances of
2910 * ft2232_vid_pid.
2911 */
2912 ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
2913
2914 return retval;
2915 }
2916
2917 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2918 {
2919 if (argc == 1)
2920 {
2921 ft2232_latency = atoi(args[0]);
2922 }
2923 else
2924 {
2925 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2926 }
2927
2928 return ERROR_OK;
2929 }
2930
2931 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd)
2932 {
2933 int retval = 0;
2934
2935 /* 7 bits of either ones or zeros. */
2936 uint8_t tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
2937
2938 while (num_cycles > 0)
2939 {
2940 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2941 * at most 7 bits per invocation. Here we invoke it potentially
2942 * several times.
2943 */
2944 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
2945
2946 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE)
2947 {
2948 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2949 retval = ERROR_JTAG_QUEUE_FAILED;
2950
2951 first_unsent = cmd;
2952 }
2953
2954 /* there are no state transitions in this code, so omit state tracking */
2955
2956 /* command "Clock Data to TMS/CS Pin (no Read)" */
2957 buffer_write(0x4b);
2958
2959 /* scan 7 bit */
2960 buffer_write(bitcount_per_command - 1);
2961
2962 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2963 buffer_write(tms);
2964
2965 require_send = 1;
2966
2967 num_cycles -= bitcount_per_command;
2968 }
2969
2970 return retval;
2971 }
2972
2973 /* ---------------------------------------------------------------------
2974 * Support for IceBear JTAG adapter from Section5:
2975 * http://section5.ch/icebear
2976 *
2977 * Author: Sten, debian@sansys-electronic.com
2978 */
2979
2980 /* Icebear pin layout
2981 *
2982 * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC)
2983 * GND GND | 4 3| n.c.
2984 * ADBUS3 TMS | 6 5| ADBUS6 VCC
2985 * ADBUS0 TCK | 8 7| ADBUS7 (GND)
2986 * ADBUS4 nTRST |10 9| ACBUS0 (GND)
2987 * ADBUS1 TDI |12 11| ACBUS1 (GND)
2988 * ADBUS2 TDO |14 13| GND GND
2989 *
2990 * ADBUS0 O L TCK ACBUS0 GND
2991 * ADBUS1 O L TDI ACBUS1 GND
2992 * ADBUS2 I TDO ACBUS2 n.c.
2993 * ADBUS3 O H TMS ACBUS3 n.c.
2994 * ADBUS4 O H nTRST
2995 * ADBUS5 O H nSRST
2996 * ADBUS6 - VCC
2997 * ADBUS7 - GND
2998 */
2999 static int icebear_jtag_init(void) {
3000 uint8_t buf[3];
3001 uint32_t bytes_written;
3002
3003 low_direction = 0x0b; /* output: TCK TDI TMS; input: TDO */
3004 low_output = 0x08; /* high: TMS; low: TCK TDI */
3005 nTRST = 0x10;
3006 nSRST = 0x20;
3007
3008 enum reset_types jtag_reset_config = jtag_get_reset_config();
3009 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0) {
3010 low_direction &= ~nTRST; /* nTRST high impedance */
3011 }
3012 else {
3013 low_direction |= nTRST;
3014 low_output |= nTRST;
3015 }
3016
3017 low_direction |= nSRST;
3018 low_output |= nSRST;
3019
3020 /* initialize low byte for jtag */
3021 buf[0] = 0x80; /* command "set data bits low byte" */
3022 buf[1] = low_output;
3023 buf[2] = low_direction;
3024 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
3025
3026 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) {
3027 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
3028 return ERROR_JTAG_INIT_FAILED;
3029 }
3030
3031 high_output = 0x0;
3032 high_direction = 0x00;
3033
3034
3035 /* initialize high port */
3036 buf[0] = 0x82; /* command "set data bits high byte" */
3037 buf[1] = high_output; /* value */
3038 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
3039 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
3040
3041 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) {
3042 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
3043 return ERROR_JTAG_INIT_FAILED;
3044 }
3045
3046 return ERROR_OK;
3047 }
3048
3049 static void icebear_jtag_reset(int trst, int srst) {
3050
3051 if (trst == 1) {
3052 low_direction |= nTRST;
3053 low_output &= ~nTRST;
3054 }
3055 else if (trst == 0) {
3056 enum reset_types jtag_reset_config = jtag_get_reset_config();
3057 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
3058 low_direction &= ~nTRST;
3059 else
3060 low_output |= nTRST;
3061 }
3062
3063 if (srst == 1) {
3064 low_output &= ~nSRST;
3065 }
3066 else if (srst == 0) {
3067 low_output |= nSRST;
3068 }
3069
3070 /* command "set data bits low byte" */
3071 buffer_write(0x80);
3072 buffer_write(low_output);
3073 buffer_write(low_direction);
3074
3075 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
3076 }
3077
3078 /* ---------------------------------------------------------------------
3079 * Support for Signalyzer H2 and Signalyzer H4
3080 * JTAG adapter from Xverve Technologies Inc.
3081 * http://www.signalyzer.com or http://www.xverve.com
3082 *
3083 * Author: Oleg Seiljus, oleg@signalyzer.com
3084 */
3085 static unsigned char signalyzer_h_side;
3086 static unsigned int signalyzer_h_adapter_type;
3087
3088 static int signalyzer_h_ctrl_write(int address, unsigned short value);
3089
3090 #if BUILD_FT2232_FTD2XX == 1
3091 static int signalyzer_h_ctrl_read(int address, unsigned short *value);
3092 #endif
3093
3094 #define SIGNALYZER_COMMAND_ADDR 128
3095 #define SIGNALYZER_DATA_BUFFER_ADDR 129
3096
3097 #define SIGNALYZER_COMMAND_VERSION 0x41
3098 #define SIGNALYZER_COMMAND_RESET 0x42
3099 #define SIGNALYZER_COMMAND_POWERCONTROL_GET 0x50
3100 #define SIGNALYZER_COMMAND_POWERCONTROL_SET 0x51
3101 #define SIGNALYZER_COMMAND_PWM_SET 0x52
3102 #define SIGNALYZER_COMMAND_LED_SET 0x53
3103 #define SIGNALYZER_COMMAND_ADC 0x54
3104 #define SIGNALYZER_COMMAND_GPIO_STATE 0x55
3105 #define SIGNALYZER_COMMAND_GPIO_MODE 0x56
3106 #define SIGNALYZER_COMMAND_GPIO_PORT 0x57
3107 #define SIGNALYZER_COMMAND_I2C 0x58
3108
3109 #define SIGNALYZER_CHAN_A 1
3110 #define SIGNALYZER_CHAN_B 2
3111 /* LEDS use channel C */
3112 #define SIGNALYZER_CHAN_C 4
3113
3114 #define SIGNALYZER_LED_GREEN 1
3115 #define SIGNALYZER_LED_RED 2
3116
3117 #define SIGNALYZER_MODULE_TYPE_EM_LT16_A 0x0301
3118 #define SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG 0x0302
3119 #define SIGNALYZER_MODULE_TYPE_EM_JTAG 0x0303
3120 #define SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P 0x0304
3121 #define SIGNALYZER_MODULE_TYPE_EM_JTAG_P 0x0305
3122
3123
3124 static int signalyzer_h_ctrl_write(int address, unsigned short value)
3125 {
3126 #if BUILD_FT2232_FTD2XX == 1
3127 return FT_WriteEE(ftdih, address, value);
3128 #elif BUILD_FT2232_LIBFTDI == 1
3129 return 0;
3130 #endif
3131 }
3132
3133 #if BUILD_FT2232_FTD2XX == 1
3134 static int signalyzer_h_ctrl_read(int address, unsigned short *value)
3135 {
3136 return FT_ReadEE(ftdih, address, value);
3137 }
3138 #endif
3139
3140 static int signalyzer_h_led_set(unsigned char channel, unsigned char led,
3141 int on_time_ms, int off_time_ms, unsigned char cycles)
3142 {
3143 unsigned char on_time;
3144 unsigned char off_time;
3145
3146 if (on_time_ms < 0xFFFF)
3147 on_time = (unsigned char)(on_time_ms / 62);
3148 else
3149 on_time = 0xFF;
3150
3151 off_time = (unsigned char)(off_time_ms / 62);
3152
3153 #if BUILD_FT2232_FTD2XX == 1
3154 FT_STATUS status;
3155
3156 if ((status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3157 ((uint32_t)(channel << 8) | led))) != FT_OK)
3158 {
3159 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
3160 return ERROR_JTAG_DEVICE_ERROR;
3161 }
3162
3163 if ((status = signalyzer_h_ctrl_write(
3164 (SIGNALYZER_DATA_BUFFER_ADDR + 1),
3165 ((uint32_t)(on_time << 8) | off_time))) != FT_OK)
3166 {
3167 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
3168 return ERROR_JTAG_DEVICE_ERROR;
3169 }
3170
3171 if ((status = signalyzer_h_ctrl_write(
3172 (SIGNALYZER_DATA_BUFFER_ADDR + 2),
3173 ((uint32_t)cycles))) != FT_OK)
3174 {
3175 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
3176 return ERROR_JTAG_DEVICE_ERROR;
3177 }
3178
3179 if ((status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3180 SIGNALYZER_COMMAND_LED_SET)) != FT_OK)
3181 {
3182 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
3183 return ERROR_JTAG_DEVICE_ERROR;
3184 }
3185
3186 return ERROR_OK;
3187 #elif BUILD_FT2232_LIBFTDI == 1
3188 int retval;
3189
3190 if ((retval = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3191 ((uint32_t)(channel << 8) | led))) < 0)
3192 {
3193 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3194 ftdi_get_error_string(&ftdic));
3195 return ERROR_JTAG_DEVICE_ERROR;
3196 }
3197
3198 if ((retval = signalyzer_h_ctrl_write(
3199 (SIGNALYZER_DATA_BUFFER_ADDR + 1),
3200 ((uint32_t)(on_time << 8) | off_time))) < 0)
3201 {
3202 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3203 ftdi_get_error_string(&ftdic));
3204 return ERROR_JTAG_DEVICE_ERROR;
3205 }
3206
3207 if ((retval = signalyzer_h_ctrl_write(
3208 (SIGNALYZER_DATA_BUFFER_ADDR + 2),
3209 (uint32_t)cycles)) < 0)
3210 {
3211 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3212 ftdi_get_error_string(&ftdic));
3213 return ERROR_JTAG_DEVICE_ERROR;
3214 }
3215
3216 if ((retval = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3217 SIGNALYZER_COMMAND_LED_SET)) < 0)
3218 {
3219 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3220 ftdi_get_error_string(&ftdic));
3221 return ERROR_JTAG_DEVICE_ERROR;
3222 }
3223
3224 return ERROR_OK;
3225 #endif
3226 }
3227
3228 static int signalyzer_h_init(void)
3229 {
3230 #if BUILD_FT2232_FTD2XX == 1
3231 FT_STATUS status;
3232 int i;
3233 #endif
3234
3235 char *end_of_desc;
3236
3237 uint16_t read_buf[12];
3238 uint8_t buf[3];
3239 uint32_t bytes_written;
3240
3241 /* turn on center green led */
3242 signalyzer_h_led_set(SIGNALYZER_CHAN_C, SIGNALYZER_LED_GREEN,
3243 0xFFFF, 0x00, 0x00);
3244
3245 /* determine what channel config wants to open
3246 * TODO: change me... current implementation is made to work
3247 * with openocd description parsing.
3248 */
3249 end_of_desc = strrchr(ft2232_device_desc, 0x00);
3250
3251 if (end_of_desc)
3252 {
3253 signalyzer_h_side = *(end_of_desc - 1);
3254 if (signalyzer_h_side == 'B')
3255 signalyzer_h_side = SIGNALYZER_CHAN_B;
3256 else
3257 signalyzer_h_side = SIGNALYZER_CHAN_A;
3258 }
3259 else
3260 {
3261 LOG_ERROR("No Channel was specified");
3262 return ERROR_FAIL;
3263 }
3264
3265 signalyzer_h_led_set(signalyzer_h_side, SIGNALYZER_LED_GREEN,
3266 1000, 1000, 0xFF);
3267
3268 #if BUILD_FT2232_FTD2XX == 1
3269 /* read signalyzer versionining information */
3270 if ((status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3271 SIGNALYZER_COMMAND_VERSION)) != FT_OK)
3272 {
3273 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
3274 return ERROR_JTAG_DEVICE_ERROR;
3275 }
3276
3277 for (i = 0; i < 10; i++)
3278 {
3279 if ((status = signalyzer_h_ctrl_read(
3280 (SIGNALYZER_DATA_BUFFER_ADDR + i),
3281 &read_buf[i])) != FT_OK)
3282 {
3283 LOG_ERROR("signalyzer_h_ctrl_read returned: %lu",
3284 status);
3285 return ERROR_JTAG_DEVICE_ERROR;
3286 }
3287 }
3288
3289 LOG_INFO("Signalyzer: ID info: { %.4x %.4x %.4x %.4x %.4x %.4x %.4x }",
3290 read_buf[0], read_buf[1], read_buf[2], read_buf[3],
3291 read_buf[4], read_buf[5], read_buf[6]);
3292
3293 /* set gpio register */
3294 if ((status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3295 (uint32_t)(signalyzer_h_side << 8))) != FT_OK)
3296 {
3297 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
3298 return ERROR_JTAG_DEVICE_ERROR;
3299 }
3300
3301 if ((status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1,
3302 0x0404)) != FT_OK)
3303 {
3304 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
3305 return ERROR_JTAG_DEVICE_ERROR;
3306 }
3307
3308 if ((status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3309 SIGNALYZER_COMMAND_GPIO_STATE)) != FT_OK)
3310 {
3311 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
3312 return ERROR_JTAG_DEVICE_ERROR;
3313 }
3314
3315 /* read adapter type information */
3316 if ((status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3317 ((uint32_t)(signalyzer_h_side << 8) | 0x01))) != FT_OK)
3318 {
3319 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
3320 return ERROR_JTAG_DEVICE_ERROR;
3321 }
3322
3323 if ((status = signalyzer_h_ctrl_write(
3324 (SIGNALYZER_DATA_BUFFER_ADDR + 1), 0xA000)) != FT_OK)
3325 {
3326 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
3327 return ERROR_JTAG_DEVICE_ERROR;
3328 }
3329
3330 if ((status = signalyzer_h_ctrl_write(
3331 (SIGNALYZER_DATA_BUFFER_ADDR + 2), 0x0008)) != FT_OK)
3332 {
3333 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
3334 return ERROR_JTAG_DEVICE_ERROR;
3335 }
3336
3337 if ((status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3338 SIGNALYZER_COMMAND_I2C)) != FT_OK)
3339 {
3340 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu", status);
3341 return ERROR_JTAG_DEVICE_ERROR;
3342 }
3343
3344 usleep(100000);
3345
3346 if ((status = signalyzer_h_ctrl_read(SIGNALYZER_COMMAND_ADDR,
3347 &read_buf[0])) != FT_OK)
3348 {
3349 LOG_ERROR("signalyzer_h_ctrl_read returned: %lu", status);
3350 return ERROR_JTAG_DEVICE_ERROR;
3351 }
3352
3353 if (read_buf[0] != 0x0498)
3354 signalyzer_h_adapter_type = 0x0000;
3355 else
3356 {
3357 for (i = 0; i < 4; i++)
3358 {
3359 if ((status = signalyzer_h_ctrl_read(
3360 (SIGNALYZER_DATA_BUFFER_ADDR + i),
3361 &read_buf[i])) != FT_OK)
3362 {
3363 LOG_ERROR("signalyzer_h_ctrl_read returned: %lu",
3364 status);
3365 return ERROR_JTAG_DEVICE_ERROR;
3366 }
3367 }
3368
3369 signalyzer_h_adapter_type = read_buf[0];
3370 }
3371
3372 #elif BUILD_FT2232_LIBFTDI == 1
3373 /* currently libftdi does not allow reading individual eeprom
3374 * locations, therefore adapter type cannot be detected.
3375 * override with most common type
3376 */
3377 signalyzer_h_adapter_type = SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG;
3378 #endif
3379
3380 enum reset_types jtag_reset_config = jtag_get_reset_config();
3381
3382 /* ADAPTOR: EM_LT16_A */
3383 if (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_LT16_A)
3384 {
3385 LOG_INFO("Signalyzer: EM-LT (16-channel level translator) "
3386 "detected. (HW: %2x).", (read_buf[1] >> 8));
3387
3388 nTRST = 0x10;
3389 nTRSTnOE = 0x10;
3390 nSRST = 0x20;
3391 nSRSTnOE = 0x20;
3392
3393 low_output = 0x08;
3394 low_direction = 0x1b;
3395
3396 high_output = 0x0;
3397 high_direction = 0x0;
3398
3399 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
3400 {
3401 low_direction &= ~nTRSTnOE; /* nTRST input */
3402 low_output &= ~nTRST; /* nTRST = 0 */
3403 }
3404 else
3405 {
3406 low_direction |= nTRSTnOE; /* nTRST output */
3407 low_output |= nTRST; /* nTRST = 1 */
3408 }
3409
3410 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
3411 {
3412 low_direction |= nSRSTnOE; /* nSRST output */
3413 low_output |= nSRST; /* nSRST = 1 */
3414 }
3415 else
3416 {
3417 low_direction &= ~nSRSTnOE; /* nSRST input */
3418 low_output &= ~nSRST; /* nSRST = 0 */
3419 }
3420
3421 #if BUILD_FT2232_FTD2XX == 1
3422 /* enable power to the module */
3423 if ((status = signalyzer_h_ctrl_write(
3424 SIGNALYZER_DATA_BUFFER_ADDR,
3425 ((uint32_t)(signalyzer_h_side << 8) | 0x01)))
3426 != FT_OK)
3427 {
3428 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3429 status);
3430 return ERROR_JTAG_DEVICE_ERROR;
3431 }
3432
3433 if ((status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3434 SIGNALYZER_COMMAND_POWERCONTROL_SET)) != FT_OK)
3435 {
3436 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3437 status);
3438 return ERROR_JTAG_DEVICE_ERROR;
3439 }
3440
3441 /* set gpio mode register */
3442 if ((status = signalyzer_h_ctrl_write(
3443 SIGNALYZER_DATA_BUFFER_ADDR,
3444 (uint32_t)(signalyzer_h_side << 8))) != FT_OK)
3445 {
3446 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3447 status);
3448 return ERROR_JTAG_DEVICE_ERROR;
3449 }
3450
3451 if ((status = signalyzer_h_ctrl_write(
3452 SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0000))
3453 != FT_OK)
3454 {
3455 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3456 status);
3457 return ERROR_JTAG_DEVICE_ERROR;
3458 }
3459
3460 if ((status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3461 SIGNALYZER_COMMAND_GPIO_MODE)) != FT_OK)
3462 {
3463 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3464 status);
3465 return ERROR_JTAG_DEVICE_ERROR;
3466 }
3467
3468 /* set gpio register */
3469 if ((status = signalyzer_h_ctrl_write(
3470 SIGNALYZER_DATA_BUFFER_ADDR,
3471 (uint32_t)(signalyzer_h_side << 8))) != FT_OK)
3472 {
3473 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3474 status);
3475 return ERROR_JTAG_DEVICE_ERROR;
3476 }
3477
3478 if ((status = signalyzer_h_ctrl_write(
3479 SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x4040))
3480 != FT_OK)
3481 {
3482 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3483 status);
3484 return ERROR_JTAG_DEVICE_ERROR;
3485 }
3486
3487 if ((status = signalyzer_h_ctrl_write(
3488 SIGNALYZER_COMMAND_ADDR,
3489 SIGNALYZER_COMMAND_GPIO_STATE)) != FT_OK)
3490 {
3491 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3492 status);
3493 return ERROR_JTAG_DEVICE_ERROR;
3494 }
3495 #endif
3496 }
3497
3498 /* ADAPTOR: EM_ARM_JTAG, EM_ARM_JTAG_P, EM_JTAG, EM_JTAG_P */
3499 else if ((signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG) ||
3500 (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P) ||
3501 (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG) ||
3502 (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG_P))
3503 {
3504 if (signalyzer_h_adapter_type
3505 == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG)
3506 LOG_INFO("Signalyzer: EM-ARM-JTAG (ARM JTAG) "
3507 "detected. (HW: %2x).", (read_buf[1] >> 8));
3508 else if (signalyzer_h_adapter_type
3509 == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P)
3510 LOG_INFO("Signalyzer: EM-ARM-JTAG_P "
3511 "(ARM JTAG with PSU) detected. (HW: %2x).",
3512 (read_buf[1] >> 8));
3513 else if (signalyzer_h_adapter_type
3514 == SIGNALYZER_MODULE_TYPE_EM_JTAG)
3515 LOG_INFO("Signalyzer: EM-JTAG (Generic JTAG) "
3516 "detected. (HW: %2x).", (read_buf[1] >> 8));
3517 else if (signalyzer_h_adapter_type
3518 == SIGNALYZER_MODULE_TYPE_EM_JTAG_P)
3519 LOG_INFO("Signalyzer: EM-JTAG-P "
3520 "(Generic JTAG with PSU) detected. (HW: %2x).",
3521 (read_buf[1] >> 8));
3522
3523 nTRST = 0x02;
3524 nTRSTnOE = 0x04;
3525 nSRST = 0x08;
3526 nSRSTnOE = 0x10;
3527
3528 low_output = 0x08;
3529 low_direction = 0x1b;
3530
3531 high_output = 0x0;
3532 high_direction = 0x1f;
3533
3534 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
3535 {
3536 high_output |= nTRSTnOE;
3537 high_output &= ~nTRST;
3538 }
3539 else
3540 {
3541 high_output &= ~nTRSTnOE;
3542 high_output |= nTRST;
3543 }
3544
3545 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
3546 {
3547 high_output &= ~nSRSTnOE;
3548 high_output |= nSRST;
3549 }
3550 else
3551 {
3552 high_output |= nSRSTnOE;
3553 high_output &= ~nSRST;
3554 }
3555
3556 #if BUILD_FT2232_FTD2XX == 1
3557 /* enable power to the module */
3558 if ((status = signalyzer_h_ctrl_write(
3559 SIGNALYZER_DATA_BUFFER_ADDR,
3560 ((uint32_t)(signalyzer_h_side << 8) | 0x01)))
3561 != FT_OK)
3562 {
3563 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3564 status);
3565 return ERROR_JTAG_DEVICE_ERROR;
3566 }
3567
3568 if ((status = signalyzer_h_ctrl_write(
3569 SIGNALYZER_COMMAND_ADDR,
3570 SIGNALYZER_COMMAND_POWERCONTROL_SET)) != FT_OK)
3571 {
3572 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3573 status);
3574 return ERROR_JTAG_DEVICE_ERROR;
3575 }
3576
3577 /* set gpio mode register (IO_16 and IO_17 set as analog
3578 * inputs, other is gpio)
3579 */
3580 if ((status = signalyzer_h_ctrl_write(
3581 SIGNALYZER_DATA_BUFFER_ADDR,
3582 (uint32_t)(signalyzer_h_side << 8))) != FT_OK)
3583 {
3584 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3585 status);
3586 return ERROR_JTAG_DEVICE_ERROR;
3587 }
3588
3589 if ((status = signalyzer_h_ctrl_write(
3590 SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0060))
3591 != FT_OK)
3592 {
3593 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3594 status);
3595 return ERROR_JTAG_DEVICE_ERROR;
3596 }
3597
3598 if ((status = signalyzer_h_ctrl_write(
3599 SIGNALYZER_COMMAND_ADDR,
3600 SIGNALYZER_COMMAND_GPIO_MODE)) != FT_OK)
3601 {
3602 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3603 status);
3604 return ERROR_JTAG_DEVICE_ERROR;
3605 }
3606
3607 /* set gpio register (all inputs, for -P modules,
3608 * PSU will be turned off)
3609 */
3610 if ((status = signalyzer_h_ctrl_write(
3611 SIGNALYZER_DATA_BUFFER_ADDR,
3612 (uint32_t)(signalyzer_h_side << 8))) != FT_OK)
3613 {
3614 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3615 status);
3616 return ERROR_JTAG_DEVICE_ERROR;
3617 }
3618
3619 if ((status = signalyzer_h_ctrl_write(
3620 SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0000))
3621 != FT_OK)
3622 {
3623 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3624 status);
3625 return ERROR_JTAG_DEVICE_ERROR;
3626 }
3627
3628 if ((status = signalyzer_h_ctrl_write(
3629 SIGNALYZER_COMMAND_ADDR,
3630 SIGNALYZER_COMMAND_GPIO_STATE)) != FT_OK)
3631 {
3632 LOG_ERROR("signalyzer_h_ctrl_write returned: %lu",
3633 status);
3634 return ERROR_JTAG_DEVICE_ERROR;
3635 }
3636 #endif
3637 }
3638
3639 else if (signalyzer_h_adapter_type == 0x0000)
3640 {
3641 LOG_INFO("Signalyzer: No external modules were detected.");
3642
3643 nTRST = 0x10;
3644 nTRSTnOE = 0x10;
3645 nSRST = 0x20;
3646 nSRSTnOE = 0x20;
3647
3648 low_output = 0x08;
3649 low_direction = 0x1b;
3650
3651 high_output = 0x0;
3652 high_direction = 0x0;
3653
3654 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
3655 {
3656 low_direction &= ~nTRSTnOE; /* nTRST input */
3657 low_output &= ~nTRST; /* nTRST = 0 */
3658 }
3659 else
3660 {
3661 low_direction |= nTRSTnOE; /* nTRST output */
3662 low_output |= nTRST; /* nTRST = 1 */
3663 }
3664
3665 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
3666 {
3667 low_direction |= nSRSTnOE; /* nSRST output */
3668 low_output |= nSRST; /* nSRST = 1 */
3669 }
3670 else
3671 {
3672 low_direction &= ~nSRSTnOE; /* nSRST input */
3673 low_output &= ~nSRST; /* nSRST = 0 */
3674 }
3675 }
3676 else
3677 {
3678 LOG_ERROR("Unknown module type is detected: %.4x",
3679 signalyzer_h_adapter_type);
3680 return ERROR_JTAG_DEVICE_ERROR;
3681 }
3682
3683 /* initialize low byte of controller for jtag operation */
3684 buf[0] = 0x80;
3685 buf[1] = low_output;
3686 buf[2] = low_direction;
3687
3688 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK)
3689 || (bytes_written != 3))
3690 {
3691 LOG_ERROR("couldn't initialize Signalyzer-H layout");
3692 return ERROR_JTAG_INIT_FAILED;
3693 }
3694
3695 #if BUILD_FT2232_FTD2XX == 1
3696 if (ftdi_device == FT_DEVICE_2232H)
3697 {
3698 /* initialize high byte of controller for jtag operation */
3699 buf[0] = 0x82;
3700 buf[1] = high_output;
3701 buf[2] = high_direction;
3702
3703 if ((ft2232_write(buf, 3, &bytes_written) != ERROR_OK)
3704 || (bytes_written != 3))
3705 {
3706 LOG_ERROR("couldn't initialize Signalyzer-H layout");
3707 return ERROR_JTAG_INIT_FAILED;
3708 }
3709 }
3710 #elif BUILD_FT2232_LIBFTDI == 1
3711 if (ftdi_device == TYPE_2232H)
3712 {
3713 /* initialize high byte of controller for jtag operation */
3714 buf[0] = 0x82;
3715 buf[1] = high_output;
3716 buf[2] = high_direction;
3717
3718 if ((ft2232_write(buf, 3, &bytes_written) != ERROR_OK)
3719 || (bytes_written != 3))
3720 {
3721 LOG_ERROR("couldn't initialize Signalyzer-H layout");
3722 return ERROR_JTAG_INIT_FAILED;
3723 }
3724 }
3725 #endif
3726 return ERROR_OK;
3727 }
3728
3729 static void signalyzer_h_reset(int trst, int srst)
3730 {
3731 enum reset_types jtag_reset_config = jtag_get_reset_config();
3732
3733 /* ADAPTOR: EM_LT16_A */
3734 if (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_LT16_A)
3735 {
3736 if (trst == 1)
3737 {
3738 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
3739 /* switch to output pin (output is low) */
3740 low_direction |= nTRSTnOE;
3741 else
3742 /* switch output low */
3743 low_output &= ~nTRST;
3744 }
3745 else if (trst == 0)
3746 {
3747 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
3748 /* switch to input pin (high-Z + internal
3749 * and external pullup) */
3750 low_direction &= ~nTRSTnOE;
3751 else
3752 /* switch output high */
3753 low_output |= nTRST;
3754 }
3755
3756 if (srst == 1)
3757 {
3758 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
3759 /* switch output low */
3760 low_output &= ~nSRST;
3761 else
3762 /* switch to output pin (output is low) */
3763 low_direction |= nSRSTnOE;
3764 }
3765 else if (srst == 0)
3766 {
3767 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
3768 /* switch output high */
3769 low_output |= nSRST;
3770 else
3771 /* switch to input pin (high-Z) */
3772 low_direction &= ~nSRSTnOE;
3773 }
3774
3775 /* command "set data bits low byte" */
3776 buffer_write(0x80);
3777 buffer_write(low_output);
3778 buffer_write(low_direction);
3779 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, "
3780 "low_direction: 0x%2.2x",
3781 trst, srst, low_output, low_direction);
3782 }
3783 /* ADAPTOR: EM_ARM_JTAG, EM_ARM_JTAG_P, EM_JTAG, EM_JTAG_P */
3784 else if ((signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG) ||
3785 (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P) ||
3786 (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG) ||
3787 (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG_P))
3788 {
3789 if (trst == 1)
3790 {
3791 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
3792 high_output &= ~nTRSTnOE;
3793 else
3794 high_output &= ~nTRST;
3795 }
3796 else if (trst == 0)
3797 {
3798 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
3799 high_output |= nTRSTnOE;
3800 else
3801 high_output |= nTRST;
3802 }
3803
3804 if (srst == 1)
3805 {
3806 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
3807 high_output &= ~nSRST;
3808 else
3809 high_output &= ~nSRSTnOE;
3810 }
3811 else if (srst == 0)
3812 {
3813 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
3814 high_output |= nSRST;
3815 else
3816 high_output |= nSRSTnOE;
3817 }
3818
3819 /* command "set data bits high byte" */
3820 buffer_write(0x82);
3821 buffer_write(high_output);
3822 buffer_write(high_direction);
3823 LOG_INFO("trst: %i, srst: %i, high_output: 0x%2.2x, "
3824 "high_direction: 0x%2.2x",
3825 trst, srst, high_output, high_direction);
3826 }
3827 else if (signalyzer_h_adapter_type == 0x0000)
3828 {
3829 if (trst == 1)
3830 {
3831 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
3832 /* switch to output pin (output is low) */
3833 low_direction |= nTRSTnOE;
3834 else
3835 /* switch output low */
3836 low_output &= ~nTRST;
3837 }
3838 else if (trst == 0)
3839 {
3840 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
3841 /* switch to input pin (high-Z + internal
3842 * and external pullup) */
3843 low_direction &= ~nTRSTnOE;
3844 else
3845 /* switch output high */
3846 low_output |= nTRST;
3847 }
3848
3849 if (srst == 1)
3850 {
3851 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
3852 /* switch output low */
3853 low_output &= ~nSRST;
3854 else
3855 /* switch to output pin (output is low) */
3856 low_direction |= nSRSTnOE;
3857 }
3858 else if (srst == 0)
3859 {
3860 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
3861 /* switch output high */
3862 low_output |= nSRST;
3863 else
3864 /* switch to input pin (high-Z) */
3865 low_direction &= ~nSRSTnOE;
3866 }
3867
3868 /* command "set data bits low byte" */
3869 buffer_write(0x80);
3870 buffer_write(low_output);
3871 buffer_write(low_direction);
3872 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, "
3873 "low_direction: 0x%2.2x",
3874 trst, srst, low_output, low_direction);
3875 }
3876 }
3877
3878 static void signalyzer_h_blink(void)
3879 {
3880 signalyzer_h_led_set(signalyzer_h_side, SIGNALYZER_LED_RED, 100, 0, 1);
3881 }
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)