Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Fix ft2232 for CygWin, provided by Michael Bruck <mbruck@digenius.de>.
[openocd.git] / src / jtag / ft2232.c
1 /***************************************************************************
2 * Copyright (C) 2004, 2006 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
23
24
25 /* This code uses information contained in the MPSSE specification which was
26 * found here:
27 * http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
28 * Hereafter this is called the "MPSSE Spec".
29 */
30
31
32 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 /* project specific includes */
37 #include "jtag.h"
38 #include "time_support.h"
39
40 #if IS_CYGWIN == 1
41 #include <windows.h>
42 #endif
43
44
45 /* FT2232 access library includes */
46 #if BUILD_FT2232_FTD2XX == 1
47 #include <ftd2xx.h>
48 #elif BUILD_FT2232_LIBFTDI == 1
49 #include <ftdi.h>
50 #endif
51
52 static int ft2232_execute_queue(void);
53
54 static int ft2232_speed(int speed);
55 static int ft2232_speed_div(int speed, int* khz);
56 static int ft2232_khz(int khz, int* jtag_speed);
57 static int ft2232_register_commands(struct command_context_s* cmd_ctx);
58 static int ft2232_init(void);
59 static int ft2232_quit(void);
60
61 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
62 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
63 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
64 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
65 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
66
67
68 /**
69 * Function ft2232_stableclocks
70 * will send out \a num_cycles on the TCK line while the TAP(s)
71 * are in a stable state. Calling code must ensure that current state is
72 * stable, that verification is not done in here.
73 * @param num_cycles is the count of clocks cycles to send.
74 * @return int - ERROR_OK or ERROR_JTAG_QUEUE_FAILED
75 */
76 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd);
77
78
79 static char * ft2232_device_desc_A = NULL;
80 static char* ft2232_device_desc = NULL;
81 static char* ft2232_serial = NULL;
82 static char* ft2232_layout = NULL;
83 static unsigned char ft2232_latency = 2;
84
85 #define MAX_USB_IDS 8
86 /* vid = pid = 0 marks the end of the list */
87 static u16 ft2232_vid[MAX_USB_IDS + 1] = { 0x0403, 0 };
88 static u16 ft2232_pid[MAX_USB_IDS + 1] = { 0x6010, 0 };
89
90 typedef struct ft2232_layout_s
91 {
92 char* name;
93 int (*init)(void);
94 void (*reset)(int trst, int srst);
95 void (*blink)(void);
96 } ft2232_layout_t;
97
98 /* init procedures for supported layouts */
99 static int usbjtag_init(void);
100 static int jtagkey_init(void);
101 static int olimex_jtag_init(void);
102 static int flyswatter_init(void);
103 static int turtle_init(void);
104 static int comstick_init(void);
105 static int stm32stick_init(void);
106 static int axm0432_jtag_init(void);
107 static int sheevaplug_init(void);
108 static int icebear_jtag_init(void);
109
110 /* reset procedures for supported layouts */
111 static void usbjtag_reset(int trst, int srst);
112 static void jtagkey_reset(int trst, int srst);
113 static void olimex_jtag_reset(int trst, int srst);
114 static void flyswatter_reset(int trst, int srst);
115 static void turtle_reset(int trst, int srst);
116 static void comstick_reset(int trst, int srst);
117 static void stm32stick_reset(int trst, int srst);
118 static void axm0432_jtag_reset(int trst, int srst);
119 static void sheevaplug_reset(int trst, int srst);
120 static void icebear_jtag_reset(int trst, int srst);
121
122 /* blink procedures for layouts that support a blinking led */
123 static void olimex_jtag_blink(void);
124 static void flyswatter_jtag_blink(void);
125 static void turtle_jtag_blink(void);
126
127 ft2232_layout_t ft2232_layouts[] =
128 {
129 { "usbjtag", usbjtag_init, usbjtag_reset, NULL },
130 { "jtagkey", jtagkey_init, jtagkey_reset, NULL },
131 { "jtagkey_prototype_v1", jtagkey_init, jtagkey_reset, NULL },
132 { "oocdlink", jtagkey_init, jtagkey_reset, NULL },
133 { "signalyzer", usbjtag_init, usbjtag_reset, NULL },
134 { "evb_lm3s811", usbjtag_init, usbjtag_reset, NULL },
135 { "olimex-jtag", olimex_jtag_init, olimex_jtag_reset, olimex_jtag_blink },
136 { "flyswatter", flyswatter_init, flyswatter_reset, flyswatter_jtag_blink },
137 { "turtelizer2", turtle_init, turtle_reset, turtle_jtag_blink },
138 { "comstick", comstick_init, comstick_reset, NULL },
139 { "stm32stick", stm32stick_init, stm32stick_reset, NULL },
140 { "axm0432_jtag", axm0432_jtag_init, axm0432_jtag_reset, NULL },
141 {"sheevaplug", sheevaplug_init, sheevaplug_reset, NULL },
142 { "icebear", icebear_jtag_init, icebear_jtag_reset, NULL },
143 { NULL, NULL, NULL, NULL },
144 };
145
146 static u8 nTRST, nTRSTnOE, nSRST, nSRSTnOE;
147
148 static ft2232_layout_t* layout;
149 static u8 low_output = 0x0;
150 static u8 low_direction = 0x0;
151 static u8 high_output = 0x0;
152 static u8 high_direction = 0x0;
153
154 #if BUILD_FT2232_FTD2XX == 1
155 static FT_HANDLE ftdih = NULL;
156 #elif BUILD_FT2232_LIBFTDI == 1
157 static struct ftdi_context ftdic;
158 #endif
159
160
161 static jtag_command_t* first_unsent; /* next command that has to be sent */
162 static int require_send;
163
164 static u8* ft2232_buffer = NULL;
165 static int ft2232_buffer_size = 0;
166 static int ft2232_read_pointer = 0;
167 static int ft2232_expect_read = 0;
168
169 #define FT2232_BUFFER_SIZE 131072
170 #define BUFFER_ADD ft2232_buffer[ft2232_buffer_size++]
171 #define BUFFER_READ ft2232_buffer[ft2232_read_pointer++]
172
173 jtag_interface_t ft2232_interface =
174 {
175 .name = "ft2232",
176 .execute_queue = ft2232_execute_queue,
177 .speed = ft2232_speed,
178 .speed_div = ft2232_speed_div,
179 .khz = ft2232_khz,
180 .register_commands = ft2232_register_commands,
181 .init = ft2232_init,
182 .quit = ft2232_quit,
183 };
184
185 static int ft2232_write(u8* buf, int size, u32* bytes_written)
186 {
187 #if BUILD_FT2232_FTD2XX == 1
188 FT_STATUS status;
189 DWORD dw_bytes_written;
190 if ( ( status = FT_Write(ftdih, buf, size, &dw_bytes_written) ) != FT_OK )
191 {
192 *bytes_written = dw_bytes_written;
193 LOG_ERROR("FT_Write returned: %lu", status);
194 return ERROR_JTAG_DEVICE_ERROR;
195 }
196 else
197 {
198 *bytes_written = dw_bytes_written;
199 return ERROR_OK;
200 }
201 #elif BUILD_FT2232_LIBFTDI == 1
202 int retval;
203 if ( ( retval = ftdi_write_data(&ftdic, buf, size) ) < 0 )
204 {
205 *bytes_written = 0;
206 LOG_ERROR( "ftdi_write_data: %s", ftdi_get_error_string(&ftdic) );
207 return ERROR_JTAG_DEVICE_ERROR;
208 }
209 else
210 {
211 *bytes_written = retval;
212 return ERROR_OK;
213 }
214 #endif
215 }
216
217
218 static int ft2232_read(u8* buf, u32 size, u32* bytes_read)
219 {
220 #if BUILD_FT2232_FTD2XX == 1
221 DWORD dw_bytes_read;
222 FT_STATUS status;
223 int timeout = 5;
224 *bytes_read = 0;
225
226 while ( (*bytes_read < size) && timeout-- )
227 {
228 if ( ( status = FT_Read(ftdih, buf + *bytes_read, size -
229 *bytes_read, &dw_bytes_read) ) != FT_OK )
230 {
231 *bytes_read = 0;
232 LOG_ERROR("FT_Read returned: %lu", status);
233 return ERROR_JTAG_DEVICE_ERROR;
234 }
235 *bytes_read += dw_bytes_read;
236 }
237
238 #elif BUILD_FT2232_LIBFTDI == 1
239 int retval;
240 int timeout = 100;
241 *bytes_read = 0;
242
243 while ( (*bytes_read < size) && timeout-- )
244 {
245 if ( ( retval = ftdi_read_data(&ftdic, buf + *bytes_read, size - *bytes_read) ) < 0 )
246 {
247 *bytes_read = 0;
248 LOG_ERROR( "ftdi_read_data: %s", ftdi_get_error_string(&ftdic) );
249 return ERROR_JTAG_DEVICE_ERROR;
250 }
251 *bytes_read += retval;
252 }
253
254 #endif
255
256 if (*bytes_read < size)
257 {
258 LOG_ERROR("couldn't read the requested number of bytes from FT2232 device (%i < %i)", *bytes_read, size);
259 return ERROR_JTAG_DEVICE_ERROR;
260 }
261
262 return ERROR_OK;
263 }
264
265
266 static int ft2232_speed(int speed)
267 {
268 u8 buf[3];
269 int retval;
270 u32 bytes_written;
271
272 buf[0] = 0x86; /* command "set divisor" */
273 buf[1] = speed & 0xff; /* valueL (0=6MHz, 1=3MHz, 2=2.0MHz, ...*/
274 buf[2] = (speed >> 8) & 0xff; /* valueH */
275
276 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
277 if ( ( ( retval = ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
278 {
279 LOG_ERROR("couldn't set FT2232 TCK speed");
280 return retval;
281 }
282
283 return ERROR_OK;
284 }
285
286
287 static int ft2232_speed_div(int speed, int* khz)
288 {
289 /* Take a look in the FT2232 manual,
290 * AN2232C-01 Command Processor for
291 * MPSSE and MCU Host Bus. Chapter 3.8 */
292
293 *khz = 6000 / (1 + speed);
294
295 return ERROR_OK;
296 }
297
298
299 static int ft2232_khz(int khz, int* jtag_speed)
300 {
301 if (khz==0)
302 {
303 LOG_ERROR("RCLK not supported");
304 return ERROR_FAIL;
305 }
306
307 /* Take a look in the FT2232 manual,
308 * AN2232C-01 Command Processor for
309 * MPSSE and MCU Host Bus. Chapter 3.8
310 *
311 * We will calc here with a multiplier
312 * of 10 for better rounding later. */
313
314 /* Calc speed, (6000 / khz) - 1 */
315 /* Use 65000 for better rounding */
316 *jtag_speed = (60000 / khz) - 10;
317
318 /* Add 0.9 for rounding */
319 *jtag_speed += 9;
320
321 /* Calc real speed */
322 *jtag_speed = *jtag_speed / 10;
323
324 /* Check if speed is greater than 0 */
325 if (*jtag_speed < 0)
326 {
327 *jtag_speed = 0;
328 }
329
330 /* Check max value */
331 if (*jtag_speed > 0xFFFF)
332 {
333 *jtag_speed = 0xFFFF;
334 }
335
336 return ERROR_OK;
337 }
338
339
340 static int ft2232_register_commands(struct command_context_s* cmd_ctx)
341 {
342 register_command(cmd_ctx, NULL, "ft2232_device_desc", ft2232_handle_device_desc_command,
343 COMMAND_CONFIG, "the USB device description of the FTDI FT2232 device");
344 register_command(cmd_ctx, NULL, "ft2232_serial", ft2232_handle_serial_command,
345 COMMAND_CONFIG, "the serial number of the FTDI FT2232 device");
346 register_command(cmd_ctx, NULL, "ft2232_layout", ft2232_handle_layout_command,
347 COMMAND_CONFIG, "the layout of the FT2232 GPIO signals used to control output-enables and reset signals");
348 register_command(cmd_ctx, NULL, "ft2232_vid_pid", ft2232_handle_vid_pid_command,
349 COMMAND_CONFIG, "the vendor ID and product ID of the FTDI FT2232 device");
350 register_command(cmd_ctx, NULL, "ft2232_latency", ft2232_handle_latency_command,
351 COMMAND_CONFIG, "set the FT2232 latency timer to a new value");
352 return ERROR_OK;
353 }
354
355
356 void ft2232_end_state(tap_state_t state)
357 {
358 if (tap_is_state_stable(state))
359 tap_set_end_state(state);
360 else
361 {
362 LOG_ERROR("BUG: %i is not a valid end state", state);
363 exit(-1);
364 }
365 }
366
367
368 static void ft2232_read_scan(enum scan_type type, u8* buffer, int scan_size)
369 {
370 int num_bytes = (scan_size + 7) / 8;
371 int bits_left = scan_size;
372 int cur_byte = 0;
373
374 while (num_bytes-- > 1)
375 {
376 buffer[cur_byte] = BUFFER_READ;
377 cur_byte++;
378 bits_left -= 8;
379 }
380
381 buffer[cur_byte] = 0x0;
382
383 if (bits_left > 1)
384 {
385 buffer[cur_byte] = BUFFER_READ >> 1;
386 }
387
388 buffer[cur_byte] = ( buffer[cur_byte] | ( (BUFFER_READ & 0x02) << 6 ) ) >> (8 - bits_left);
389 }
390
391
392 static void ft2232_debug_dump_buffer(void)
393 {
394 int i;
395 char line[256];
396 char* line_p = line;
397
398 for (i = 0; i < ft2232_buffer_size; i++)
399 {
400 line_p += snprintf(line_p, 256 - (line_p - line), "%2.2x ", ft2232_buffer[i]);
401 if (i % 16 == 15)
402 {
403 LOG_DEBUG("%s", line);
404 line_p = line;
405 }
406 }
407
408 if (line_p != line)
409 LOG_DEBUG("%s", line);
410 }
411
412
413 static int ft2232_send_and_recv(jtag_command_t* first, jtag_command_t* last)
414 {
415 jtag_command_t* cmd;
416 u8* buffer;
417 int scan_size;
418 enum scan_type type;
419 int retval;
420 u32 bytes_written=0;
421 u32 bytes_read=0;
422
423 #ifdef _DEBUG_USB_IO_
424 struct timeval start, inter, inter2, end;
425 struct timeval d_inter, d_inter2, d_end;
426 #endif
427
428 #ifdef _DEBUG_USB_COMMS_
429 LOG_DEBUG("write buffer (size %i):", ft2232_buffer_size);
430 ft2232_debug_dump_buffer();
431 #endif
432
433 #ifdef _DEBUG_USB_IO_
434 gettimeofday(&start, NULL);
435 #endif
436
437 if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK )
438 {
439 LOG_ERROR("couldn't write MPSSE commands to FT2232");
440 return retval;
441 }
442
443 #ifdef _DEBUG_USB_IO_
444 gettimeofday(&inter, NULL);
445 #endif
446
447 if (ft2232_expect_read)
448 {
449 int timeout = 100;
450 ft2232_buffer_size = 0;
451
452 #ifdef _DEBUG_USB_IO_
453 gettimeofday(&inter2, NULL);
454 #endif
455
456 if ( ( retval = ft2232_read(ft2232_buffer, ft2232_expect_read, &bytes_read) ) != ERROR_OK )
457 {
458 LOG_ERROR("couldn't read from FT2232");
459 return retval;
460 }
461
462 #ifdef _DEBUG_USB_IO_
463 gettimeofday(&end, NULL);
464
465 timeval_subtract(&d_inter, &inter, &start);
466 timeval_subtract(&d_inter2, &inter2, &start);
467 timeval_subtract(&d_end, &end, &start);
468
469 LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u",
470 (unsigned)d_inter.tv_sec, (unsigned)d_inter.tv_usec,
471 (unsigned)d_inter2.tv_sec, (unsigned)d_inter2.tv_usec,
472 (unsigned)d_end.tv_sec, (unsigned)d_end.tv_usec);
473 #endif
474
475 ft2232_buffer_size = bytes_read;
476
477 if (ft2232_expect_read != ft2232_buffer_size)
478 {
479 LOG_ERROR("ft2232_expect_read (%i) != ft2232_buffer_size (%i) (%i retries)", ft2232_expect_read,
480 ft2232_buffer_size,
481 100 - timeout);
482 ft2232_debug_dump_buffer();
483
484 exit(-1);
485 }
486
487 #ifdef _DEBUG_USB_COMMS_
488 LOG_DEBUG("read buffer (%i retries): %i bytes", 100 - timeout, ft2232_buffer_size);
489 ft2232_debug_dump_buffer();
490 #endif
491 }
492
493 ft2232_expect_read = 0;
494 ft2232_read_pointer = 0;
495
496 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
497 * that wasn't handled by a caller-provided error handler
498 */
499 retval = ERROR_OK;
500
501 cmd = first;
502 while (cmd != last)
503 {
504 switch (cmd->type)
505 {
506 case JTAG_SCAN:
507 type = jtag_scan_type(cmd->cmd.scan);
508 if (type != SCAN_OUT)
509 {
510 scan_size = jtag_scan_size(cmd->cmd.scan);
511 buffer = calloc(CEIL(scan_size, 8), 1);
512 ft2232_read_scan(type, buffer, scan_size);
513 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
514 retval = ERROR_JTAG_QUEUE_FAILED;
515 free(buffer);
516 }
517 break;
518
519 default:
520 break;
521 }
522
523 cmd = cmd->next;
524 }
525
526 ft2232_buffer_size = 0;
527
528 return retval;
529 }
530
531
532 static void ft2232_add_pathmove(pathmove_command_t* cmd)
533 {
534 int num_states = cmd->num_states;
535 int state_count = 0;
536
537 while (num_states)
538 {
539 u8 tms_byte = 0; /* zero this on each MPSSE batch */
540
541 int bit_count = 0;
542
543 int num_states_batch = num_states > 7 ? 7 : num_states;
544
545 /* command "Clock Data to TMS/CS Pin (no Read)" */
546 BUFFER_ADD = 0x4b;
547
548 /* number of states remaining */
549 BUFFER_ADD = num_states_batch - 1;
550
551 while (num_states_batch--)
552 {
553 if (tap_state_transition(tap_get_state(), false) == cmd->path[state_count])
554 buf_set_u32(&tms_byte, bit_count++, 1, 0x0);
555 else if (tap_state_transition(tap_get_state(), true) == cmd->path[state_count])
556 buf_set_u32(&tms_byte, bit_count++, 1, 0x1);
557 else
558 {
559 LOG_ERROR( "BUG: %s -> %s isn't a valid TAP transition", tap_state_name(
560 tap_get_state() ), tap_state_name(cmd->path[state_count]) );
561 exit(-1);
562 }
563
564 tap_set_state(cmd->path[state_count]);
565 state_count++;
566 num_states--;
567 }
568
569 BUFFER_ADD = tms_byte;
570 }
571
572 tap_set_end_state(tap_get_state());
573 }
574
575
576 void ft2232_add_scan(int ir_scan, enum scan_type type, u8* buffer, int scan_size)
577 {
578 int num_bytes = (scan_size + 7) / 8;
579 int bits_left = scan_size;
580 int cur_byte = 0;
581 int last_bit;
582
583 if ( !( ( !ir_scan && (tap_get_state() == TAP_DRSHIFT) )
584 || ( ir_scan && (tap_get_state() == TAP_IRSHIFT) ) ) )
585 {
586 /* command "Clock Data to TMS/CS Pin (no Read)" */
587 BUFFER_ADD = 0x4b;
588
589 BUFFER_ADD = 0x6; /* scan 7 bits */
590
591 /* TMS data bits */
592 if (ir_scan)
593 {
594 BUFFER_ADD = tap_get_tms_path(tap_get_state(), TAP_IRSHIFT);
595 tap_set_state(TAP_IRSHIFT);
596 }
597 else
598 {
599 BUFFER_ADD = tap_get_tms_path(tap_get_state(), TAP_DRSHIFT);
600 tap_set_state(TAP_DRSHIFT);
601 }
602 /* LOG_DEBUG("added TMS scan (no read)"); */
603 }
604
605 /* add command for complete bytes */
606 while (num_bytes > 1)
607 {
608 int thisrun_bytes;
609 if (type == SCAN_IO)
610 {
611 /* Clock Data Bytes In and Out LSB First */
612 BUFFER_ADD = 0x39;
613 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
614 }
615 else if (type == SCAN_OUT)
616 {
617 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
618 BUFFER_ADD = 0x19;
619 /* LOG_DEBUG("added TDI bytes (o)"); */
620 }
621 else if (type == SCAN_IN)
622 {
623 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
624 BUFFER_ADD = 0x28;
625 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
626 }
627
628 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
629 num_bytes -= thisrun_bytes;
630 BUFFER_ADD = (thisrun_bytes - 1) & 0xff;
631 BUFFER_ADD = ( (thisrun_bytes - 1) >> 8 ) & 0xff;
632
633 if (type != SCAN_IN)
634 {
635 /* add complete bytes */
636 while (thisrun_bytes-- > 0)
637 {
638 BUFFER_ADD = buffer[cur_byte];
639 cur_byte++;
640 bits_left -= 8;
641 }
642 }
643 else /* (type == SCAN_IN) */
644 {
645 bits_left -= 8 * (thisrun_bytes);
646 }
647 }
648
649 /* the most signifcant bit is scanned during TAP movement */
650 if (type != SCAN_IN)
651 last_bit = ( buffer[cur_byte] >> (bits_left - 1) ) & 0x1;
652 else
653 last_bit = 0;
654
655 /* process remaining bits but the last one */
656 if (bits_left > 1)
657 {
658 if (type == SCAN_IO)
659 {
660 /* Clock Data Bits In and Out LSB First */
661 BUFFER_ADD = 0x3b;
662 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
663 }
664 else if (type == SCAN_OUT)
665 {
666 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
667 BUFFER_ADD = 0x1b;
668 /* LOG_DEBUG("added TDI bits (o)"); */
669 }
670 else if (type == SCAN_IN)
671 {
672 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
673 BUFFER_ADD = 0x2a;
674 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
675 }
676 BUFFER_ADD = bits_left - 2;
677 if (type != SCAN_IN)
678 BUFFER_ADD = buffer[cur_byte];
679 }
680
681 if ( ( ir_scan && (tap_get_end_state() == TAP_IRSHIFT) )
682 || ( !ir_scan && (tap_get_end_state() == TAP_DRSHIFT) ) )
683 {
684 if (type == SCAN_IO)
685 {
686 /* Clock Data Bits In and Out LSB First */
687 BUFFER_ADD = 0x3b;
688 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
689 }
690 else if (type == SCAN_OUT)
691 {
692 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
693 BUFFER_ADD = 0x1b;
694 /* LOG_DEBUG("added TDI bits (o)"); */
695 }
696 else if (type == SCAN_IN)
697 {
698 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
699 BUFFER_ADD = 0x2a;
700 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
701 }
702 BUFFER_ADD = 0x0;
703 BUFFER_ADD = last_bit;
704 }
705 else
706 {
707 /* move from Shift-IR/DR to end state */
708 if (type != SCAN_OUT)
709 {
710 /* Clock Data to TMS/CS Pin with Read */
711 BUFFER_ADD = 0x6b;
712 /* LOG_DEBUG("added TMS scan (read)"); */
713 }
714 else
715 {
716 /* Clock Data to TMS/CS Pin (no Read) */
717 BUFFER_ADD = 0x4b;
718 /* LOG_DEBUG("added TMS scan (no read)"); */
719 }
720 BUFFER_ADD = 0x6; /* scan 7 bits */
721
722 BUFFER_ADD = tap_get_tms_path( tap_get_state(), tap_get_end_state() ) | (last_bit << 7);
723 tap_set_state( tap_get_end_state() );
724 }
725 }
726
727
728 static int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, u8* buffer, int scan_size)
729 {
730 int num_bytes = (scan_size + 7) / 8;
731 int bits_left = scan_size;
732 int cur_byte = 0;
733 int last_bit;
734 u8* receive_buffer = malloc( CEIL(scan_size, 8) );
735 u8* receive_pointer = receive_buffer;
736 u32 bytes_written;
737 u32 bytes_read;
738 int retval;
739 int thisrun_read = 0;
740
741 if (cmd->ir_scan)
742 {
743 LOG_ERROR("BUG: large IR scans are not supported");
744 exit(-1);
745 }
746
747 if (tap_get_state() != TAP_DRSHIFT)
748 {
749 /* command "Clock Data to TMS/CS Pin (no Read)" */
750 BUFFER_ADD = 0x4b;
751
752 BUFFER_ADD = 0x6; /* scan 7 bits */
753
754 /* TMS data bits */
755 BUFFER_ADD = tap_get_tms_path(tap_get_state(), TAP_DRSHIFT);
756 tap_set_state(TAP_DRSHIFT);
757 }
758
759 if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK )
760 {
761 LOG_ERROR("couldn't write MPSSE commands to FT2232");
762 exit(-1);
763 }
764 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
765 ft2232_buffer_size = 0;
766
767 /* add command for complete bytes */
768 while (num_bytes > 1)
769 {
770 int thisrun_bytes;
771
772 if (type == SCAN_IO)
773 {
774 /* Clock Data Bytes In and Out LSB First */
775 BUFFER_ADD = 0x39;
776 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
777 }
778 else if (type == SCAN_OUT)
779 {
780 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
781 BUFFER_ADD = 0x19;
782 /* LOG_DEBUG("added TDI bytes (o)"); */
783 }
784 else if (type == SCAN_IN)
785 {
786 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
787 BUFFER_ADD = 0x28;
788 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
789 }
790
791 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
792 thisrun_read = thisrun_bytes;
793 num_bytes -= thisrun_bytes;
794 BUFFER_ADD = (thisrun_bytes - 1) & 0xff;
795 BUFFER_ADD = ( (thisrun_bytes - 1) >> 8 ) & 0xff;
796
797 if (type != SCAN_IN)
798 {
799 /* add complete bytes */
800 while (thisrun_bytes-- > 0)
801 {
802 BUFFER_ADD = buffer[cur_byte];
803 cur_byte++;
804 bits_left -= 8;
805 }
806 }
807 else /* (type == SCAN_IN) */
808 {
809 bits_left -= 8 * (thisrun_bytes);
810 }
811
812 if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK )
813 {
814 LOG_ERROR("couldn't write MPSSE commands to FT2232");
815 exit(-1);
816 }
817 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
818 ft2232_buffer_size = 0;
819
820 if (type != SCAN_OUT)
821 {
822 if ( ( retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read) ) != ERROR_OK )
823 {
824 LOG_ERROR("couldn't read from FT2232");
825 exit(-1);
826 }
827 LOG_DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read, bytes_read);
828 receive_pointer += bytes_read;
829 }
830 }
831
832 thisrun_read = 0;
833
834 /* the most signifcant bit is scanned during TAP movement */
835 if (type != SCAN_IN)
836 last_bit = ( buffer[cur_byte] >> (bits_left - 1) ) & 0x1;
837 else
838 last_bit = 0;
839
840 /* process remaining bits but the last one */
841 if (bits_left > 1)
842 {
843 if (type == SCAN_IO)
844 {
845 /* Clock Data Bits In and Out LSB First */
846 BUFFER_ADD = 0x3b;
847 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
848 }
849 else if (type == SCAN_OUT)
850 {
851 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
852 BUFFER_ADD = 0x1b;
853 /* LOG_DEBUG("added TDI bits (o)"); */
854 }
855 else if (type == SCAN_IN)
856 {
857 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
858 BUFFER_ADD = 0x2a;
859 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
860 }
861 BUFFER_ADD = bits_left - 2;
862 if (type != SCAN_IN)
863 BUFFER_ADD = buffer[cur_byte];
864
865 if (type != SCAN_OUT)
866 thisrun_read += 2;
867 }
868
869 if (tap_get_end_state() == TAP_DRSHIFT)
870 {
871 if (type == SCAN_IO)
872 {
873 /* Clock Data Bits In and Out LSB First */
874 BUFFER_ADD = 0x3b;
875 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
876 }
877 else if (type == SCAN_OUT)
878 {
879 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
880 BUFFER_ADD = 0x1b;
881 /* LOG_DEBUG("added TDI bits (o)"); */
882 }
883 else if (type == SCAN_IN)
884 {
885 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
886 BUFFER_ADD = 0x2a;
887 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
888 }
889 BUFFER_ADD = 0x0;
890 BUFFER_ADD = last_bit;
891 }
892 else
893 {
894 /* move from Shift-IR/DR to end state */
895 if (type != SCAN_OUT)
896 {
897 /* Clock Data to TMS/CS Pin with Read */
898 BUFFER_ADD = 0x6b;
899 /* LOG_DEBUG("added TMS scan (read)"); */
900 }
901 else
902 {
903 /* Clock Data to TMS/CS Pin (no Read) */
904 BUFFER_ADD = 0x4b;
905 /* LOG_DEBUG("added TMS scan (no read)"); */
906 }
907 BUFFER_ADD = 0x6;
908 BUFFER_ADD = tap_get_tms_path( tap_get_state(), tap_get_end_state() ) | (last_bit << 7);
909 tap_set_state( tap_get_end_state() );
910 }
911
912 if (type != SCAN_OUT)
913 thisrun_read += 1;
914
915 if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK )
916 {
917 LOG_ERROR("couldn't write MPSSE commands to FT2232");
918 exit(-1);
919 }
920 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
921 ft2232_buffer_size = 0;
922
923 if (type != SCAN_OUT)
924 {
925 if ( ( retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read) ) != ERROR_OK )
926 {
927 LOG_ERROR("couldn't read from FT2232");
928 exit(-1);
929 }
930 LOG_DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read, bytes_read);
931 receive_pointer += bytes_read;
932 }
933
934 return ERROR_OK;
935 }
936
937
938 static int ft2232_predict_scan_out(int scan_size, enum scan_type type)
939 {
940 int predicted_size = 3;
941 int num_bytes = (scan_size - 1) / 8;
942
943 if (tap_get_state() != TAP_DRSHIFT)
944 predicted_size += 3;
945
946 if (type == SCAN_IN) /* only from device to host */
947 {
948 /* complete bytes */
949 predicted_size += CEIL(num_bytes, 65536) * 3;
950 /* remaining bits - 1 (up to 7) */
951 predicted_size += ( (scan_size - 1) % 8 ) ? 2 : 0;
952 }
953 else /* host to device, or bidirectional */
954 {
955 /* complete bytes */
956 predicted_size += num_bytes + CEIL(num_bytes, 65536) * 3;
957 /* remaining bits -1 (up to 7) */
958 predicted_size += ( (scan_size - 1) % 8 ) ? 3 : 0;
959 }
960
961 return predicted_size;
962 }
963
964
965 static int ft2232_predict_scan_in(int scan_size, enum scan_type type)
966 {
967 int predicted_size = 0;
968
969 if (type != SCAN_OUT)
970 {
971 /* complete bytes */
972 predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) - 1) : 0;
973
974 /* remaining bits - 1 */
975 predicted_size += ( (scan_size - 1) % 8 ) ? 1 : 0;
976
977 /* last bit (from TMS scan) */
978 predicted_size += 1;
979 }
980
981 /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
982
983 return predicted_size;
984 }
985
986
987 static void usbjtag_reset(int trst, int srst)
988 {
989 if (trst == 1)
990 {
991 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
992 low_direction |= nTRSTnOE; /* switch to output pin (output is low) */
993 else
994 low_output &= ~nTRST; /* switch output low */
995 }
996 else if (trst == 0)
997 {
998 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
999 low_direction &= ~nTRSTnOE; /* switch to input pin (high-Z + internal and external pullup) */
1000 else
1001 low_output |= nTRST; /* switch output high */
1002 }
1003
1004 if (srst == 1)
1005 {
1006 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1007 low_output &= ~nSRST; /* switch output low */
1008 else
1009 low_direction |= nSRSTnOE; /* switch to output pin (output is low) */
1010 }
1011 else if (srst == 0)
1012 {
1013 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1014 low_output |= nSRST; /* switch output high */
1015 else
1016 low_direction &= ~nSRSTnOE; /* switch to input pin (high-Z) */
1017 }
1018
1019 /* command "set data bits low byte" */
1020 BUFFER_ADD = 0x80;
1021 BUFFER_ADD = low_output;
1022 BUFFER_ADD = low_direction;
1023 }
1024
1025
1026 static void jtagkey_reset(int trst, int srst)
1027 {
1028 if (trst == 1)
1029 {
1030 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1031 high_output &= ~nTRSTnOE;
1032 else
1033 high_output &= ~nTRST;
1034 }
1035 else if (trst == 0)
1036 {
1037 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1038 high_output |= nTRSTnOE;
1039 else
1040 high_output |= nTRST;
1041 }
1042
1043 if (srst == 1)
1044 {
1045 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1046 high_output &= ~nSRST;
1047 else
1048 high_output &= ~nSRSTnOE;
1049 }
1050 else if (srst == 0)
1051 {
1052 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1053 high_output |= nSRST;
1054 else
1055 high_output |= nSRSTnOE;
1056 }
1057
1058 /* command "set data bits high byte" */
1059 BUFFER_ADD = 0x82;
1060 BUFFER_ADD = high_output;
1061 BUFFER_ADD = high_direction;
1062 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1063 high_direction);
1064 }
1065
1066
1067 static void olimex_jtag_reset(int trst, int srst)
1068 {
1069 if (trst == 1)
1070 {
1071 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1072 high_output &= ~nTRSTnOE;
1073 else
1074 high_output &= ~nTRST;
1075 }
1076 else if (trst == 0)
1077 {
1078 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1079 high_output |= nTRSTnOE;
1080 else
1081 high_output |= nTRST;
1082 }
1083
1084 if (srst == 1)
1085 {
1086 high_output |= nSRST;
1087 }
1088 else if (srst == 0)
1089 {
1090 high_output &= ~nSRST;
1091 }
1092
1093 /* command "set data bits high byte" */
1094 BUFFER_ADD = 0x82;
1095 BUFFER_ADD = high_output;
1096 BUFFER_ADD = high_direction;
1097 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1098 high_direction);
1099 }
1100
1101
1102 static void axm0432_jtag_reset(int trst, int srst)
1103 {
1104 if (trst == 1)
1105 {
1106 tap_set_state(TAP_RESET);
1107 high_output &= ~nTRST;
1108 }
1109 else if (trst == 0)
1110 {
1111 high_output |= nTRST;
1112 }
1113
1114 if (srst == 1)
1115 {
1116 high_output &= ~nSRST;
1117 }
1118 else if (srst == 0)
1119 {
1120 high_output |= nSRST;
1121 }
1122
1123 /* command "set data bits low byte" */
1124 BUFFER_ADD = 0x82;
1125 BUFFER_ADD = high_output;
1126 BUFFER_ADD = high_direction;
1127 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1128 high_direction);
1129 }
1130
1131
1132 static void flyswatter_reset(int trst, int srst)
1133 {
1134 if (trst == 1)
1135 {
1136 low_output &= ~nTRST;
1137 }
1138 else if (trst == 0)
1139 {
1140 low_output |= nTRST;
1141 }
1142
1143 if (srst == 1)
1144 {
1145 low_output |= nSRST;
1146 }
1147 else if (srst == 0)
1148 {
1149 low_output &= ~nSRST;
1150 }
1151
1152 /* command "set data bits low byte" */
1153 BUFFER_ADD = 0x80;
1154 BUFFER_ADD = low_output;
1155 BUFFER_ADD = low_direction;
1156 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
1157 }
1158
1159
1160 static void turtle_reset(int trst, int srst)
1161 {
1162 trst = trst;
1163
1164 if (srst == 1)
1165 {
1166 low_output |= nSRST;
1167 }
1168 else if (srst == 0)
1169 {
1170 low_output &= ~nSRST;
1171 }
1172
1173 /* command "set data bits low byte" */
1174 BUFFER_ADD = 0x80;
1175 BUFFER_ADD = low_output;
1176 BUFFER_ADD = low_direction;
1177 LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst, low_output, low_direction);
1178 }
1179
1180
1181 static void comstick_reset(int trst, int srst)
1182 {
1183 if (trst == 1)
1184 {
1185 high_output &= ~nTRST;
1186 }
1187 else if (trst == 0)
1188 {
1189 high_output |= nTRST;
1190 }
1191
1192 if (srst == 1)
1193 {
1194 high_output &= ~nSRST;
1195 }
1196 else if (srst == 0)
1197 {
1198 high_output |= nSRST;
1199 }
1200
1201 /* command "set data bits high byte" */
1202 BUFFER_ADD = 0x82;
1203 BUFFER_ADD = high_output;
1204 BUFFER_ADD = high_direction;
1205 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1206 high_direction);
1207 }
1208
1209
1210 static void stm32stick_reset(int trst, int srst)
1211 {
1212 if (trst == 1)
1213 {
1214 high_output &= ~nTRST;
1215 }
1216 else if (trst == 0)
1217 {
1218 high_output |= nTRST;
1219 }
1220
1221 if (srst == 1)
1222 {
1223 low_output &= ~nSRST;
1224 }
1225 else if (srst == 0)
1226 {
1227 low_output |= nSRST;
1228 }
1229
1230 /* command "set data bits low byte" */
1231 BUFFER_ADD = 0x80;
1232 BUFFER_ADD = low_output;
1233 BUFFER_ADD = low_direction;
1234
1235 /* command "set data bits high byte" */
1236 BUFFER_ADD = 0x82;
1237 BUFFER_ADD = high_output;
1238 BUFFER_ADD = high_direction;
1239 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1240 high_direction);
1241 }
1242
1243
1244
1245 static void sheevaplug_reset(int trst, int srst)
1246 {
1247 if (trst == 1)
1248 high_output &= ~nTRST;
1249 else if (trst == 0)
1250 high_output |= nTRST;
1251
1252 if (srst == 1)
1253 high_output &= ~nSRSTnOE;
1254 else if (srst == 0)
1255 high_output |= nSRSTnOE;
1256
1257 /* command "set data bits high byte" */
1258 BUFFER_ADD = 0x82;
1259 BUFFER_ADD = high_output;
1260 BUFFER_ADD = high_direction;
1261 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
1262 }
1263
1264 static int ft2232_execute_end_state(jtag_command_t *cmd)
1265 {
1266 int retval;
1267 retval = ERROR_OK;
1268
1269 DEBUG_JTAG_IO("end_state: %i", cmd->cmd.end_state->end_state);
1270
1271 if (cmd->cmd.end_state->end_state != TAP_INVALID)
1272 ft2232_end_state(cmd->cmd.end_state->end_state);
1273
1274 return retval;
1275 }
1276
1277
1278 static int ft2232_execute_runtest(jtag_command_t *cmd)
1279 {
1280 int retval;
1281 int i;
1282 int predicted_size = 0;
1283 retval = ERROR_OK;
1284
1285 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
1286 cmd->cmd.runtest->num_cycles,
1287 cmd->cmd.runtest->end_state);
1288 /* only send the maximum buffer size that FT2232C can handle */
1289 predicted_size = 0;
1290 if (tap_get_state() != TAP_IDLE)
1291 predicted_size += 3;
1292 predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7);
1293 if ( (cmd->cmd.runtest->end_state != TAP_INVALID) && (cmd->cmd.runtest->end_state != TAP_IDLE) )
1294 predicted_size += 3;
1295 if ( (cmd->cmd.runtest->end_state == TAP_INVALID) && (tap_get_end_state() != TAP_IDLE) )
1296 predicted_size += 3;
1297 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1298 {
1299 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1300 retval = ERROR_JTAG_QUEUE_FAILED;
1301 require_send = 0;
1302 first_unsent = cmd;
1303 }
1304 if (tap_get_state() != TAP_IDLE)
1305 {
1306 /* command "Clock Data to TMS/CS Pin (no Read)" */
1307 BUFFER_ADD = 0x4b;
1308 BUFFER_ADD = 0x6; /* scan 7 bits */
1309
1310 /* TMS data bits */
1311 BUFFER_ADD = tap_get_tms_path(tap_get_state(), TAP_IDLE);
1312 tap_set_state(TAP_IDLE);
1313 require_send = 1;
1314 }
1315 i = cmd->cmd.runtest->num_cycles;
1316 while (i > 0)
1317 {
1318 /* command "Clock Data to TMS/CS Pin (no Read)" */
1319 BUFFER_ADD = 0x4b;
1320
1321 /* scan 7 bits */
1322 BUFFER_ADD = (i > 7) ? 6 : (i - 1);
1323
1324 /* TMS data bits */
1325 BUFFER_ADD = 0x0;
1326 tap_set_state(TAP_IDLE);
1327 i -= (i > 7) ? 7 : i;
1328 /* LOG_DEBUG("added TMS scan (no read)"); */
1329 }
1330
1331 if (cmd->cmd.runtest->end_state != TAP_INVALID)
1332 ft2232_end_state(cmd->cmd.runtest->end_state);
1333
1334 if ( tap_get_state() != tap_get_end_state() )
1335 {
1336 /* command "Clock Data to TMS/CS Pin (no Read)" */
1337 BUFFER_ADD = 0x4b;
1338 /* scan 7 bit */
1339 BUFFER_ADD = 0x6;
1340 /* TMS data bits */
1341 BUFFER_ADD = tap_get_tms_path( tap_get_state(), tap_get_end_state() );
1342 tap_set_state( tap_get_end_state() );
1343 /* LOG_DEBUG("added TMS scan (no read)"); */
1344 }
1345 require_send = 1;
1346 #ifdef _DEBUG_JTAG_IO_
1347 LOG_DEBUG( "runtest: %i, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name( tap_get_end_state() ) );
1348 #endif
1349
1350 return retval;
1351 }
1352
1353 static int ft2232_execute_statemove(jtag_command_t *cmd)
1354 {
1355 int retval;
1356 int predicted_size = 0;
1357 retval = ERROR_OK;
1358
1359 DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
1360
1361 /* only send the maximum buffer size that FT2232C can handle */
1362 predicted_size = 3;
1363 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1364 {
1365 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1366 retval = ERROR_JTAG_QUEUE_FAILED;
1367 require_send = 0;
1368 first_unsent = cmd;
1369 }
1370 if (cmd->cmd.statemove->end_state != TAP_INVALID)
1371 ft2232_end_state(cmd->cmd.statemove->end_state);
1372
1373 /* command "Clock Data to TMS/CS Pin (no Read)" */
1374 BUFFER_ADD = 0x4b;
1375
1376 BUFFER_ADD = 0x6; /* scan 7 bits */
1377
1378 /* TMS data bits */
1379 BUFFER_ADD = tap_get_tms_path( tap_get_state(), tap_get_end_state() );
1380 /* LOG_DEBUG("added TMS scan (no read)"); */
1381 tap_set_state( tap_get_end_state() );
1382 require_send = 1;
1383 #ifdef _DEBUG_JTAG_IO_
1384 LOG_DEBUG( "statemove: %s", tap_state_name( tap_get_end_state() ) );
1385 #endif
1386
1387 return retval;
1388 }
1389
1390 static int ft2232_execute_pathmove(jtag_command_t *cmd)
1391 {
1392 int retval;
1393 int predicted_size = 0;
1394 retval = ERROR_OK;
1395
1396 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
1397 cmd->cmd.pathmove->num_states,
1398 cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
1399 /* only send the maximum buffer size that FT2232C can handle */
1400 predicted_size = 3 * CEIL(cmd->cmd.pathmove->num_states, 7);
1401 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1402 {
1403 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1404 retval = ERROR_JTAG_QUEUE_FAILED;
1405 require_send = 0;
1406 first_unsent = cmd;
1407 }
1408 ft2232_add_pathmove(cmd->cmd.pathmove);
1409 require_send = 1;
1410 #ifdef _DEBUG_JTAG_IO_
1411 LOG_DEBUG( "pathmove: %i states, end in %s", cmd->cmd.pathmove->num_states,
1412 tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]) );
1413 #endif
1414 return retval;
1415 }
1416
1417 static int ft2232_execute_scan(jtag_command_t *cmd)
1418 {
1419 int retval;
1420 u8* buffer;
1421 int scan_size; /* size of IR or DR scan */
1422 enum scan_type type;
1423 int predicted_size = 0;
1424 retval = ERROR_OK;
1425
1426 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1427 type = jtag_scan_type(cmd->cmd.scan);
1428 predicted_size = ft2232_predict_scan_out(scan_size, type);
1429 if ( (predicted_size + 1) > FT2232_BUFFER_SIZE )
1430 {
1431 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1432 /* unsent commands before this */
1433 if (first_unsent != cmd)
1434 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1435 retval = ERROR_JTAG_QUEUE_FAILED;
1436
1437 /* current command */
1438 if (cmd->cmd.scan->end_state != TAP_INVALID)
1439 ft2232_end_state(cmd->cmd.scan->end_state);
1440 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1441 require_send = 0;
1442 first_unsent = cmd->next;
1443 if (buffer)
1444 free(buffer);
1445 return retval;
1446 }
1447 else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1448 {
1449 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1450 first_unsent,
1451 cmd);
1452 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1453 retval = ERROR_JTAG_QUEUE_FAILED;
1454 require_send = 0;
1455 first_unsent = cmd;
1456 }
1457 ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1458 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1459 if (cmd->cmd.scan->end_state != TAP_INVALID)
1460 ft2232_end_state(cmd->cmd.scan->end_state);
1461 ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1462 require_send = 1;
1463 if (buffer)
1464 free(buffer);
1465 #ifdef _DEBUG_JTAG_IO_
1466 LOG_DEBUG( "%s scan, %i bits, end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1467 tap_state_name( tap_get_end_state() ) );
1468 #endif
1469 return retval;
1470
1471 }
1472
1473 static int ft2232_execute_reset(jtag_command_t *cmd)
1474 {
1475 int retval;
1476 int predicted_size = 0;
1477 retval = ERROR_OK;
1478
1479 DEBUG_JTAG_IO("reset trst: %i srst %i",
1480 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1481
1482 /* only send the maximum buffer size that FT2232C can handle */
1483 predicted_size = 3;
1484 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1485 {
1486 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1487 retval = ERROR_JTAG_QUEUE_FAILED;
1488 require_send = 0;
1489 first_unsent = cmd;
1490 }
1491
1492 if ( (cmd->cmd.reset->trst == 1) || ( cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST) ) )
1493 {
1494 tap_set_state(TAP_RESET);
1495 }
1496 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1497 require_send = 1;
1498
1499 #ifdef _DEBUG_JTAG_IO_
1500 LOG_DEBUG("trst: %i, srst: %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1501 #endif
1502 return retval;
1503 }
1504
1505 static int ft2232_execute_sleep(jtag_command_t *cmd)
1506 {
1507 int retval;
1508 retval = ERROR_OK;
1509
1510 DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
1511
1512 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1513 retval = ERROR_JTAG_QUEUE_FAILED;
1514 first_unsent = cmd->next;
1515 jtag_sleep(cmd->cmd.sleep->us);
1516 #ifdef _DEBUG_JTAG_IO_
1517 LOG_DEBUG( "sleep %i usec while in %s", cmd->cmd.sleep->us, tap_state_name( tap_get_state() ) );
1518 #endif
1519
1520 return retval;
1521 }
1522
1523 static int ft2232_execute_stableclocks(jtag_command_t *cmd)
1524 {
1525 int retval;
1526 retval = ERROR_OK;
1527
1528 /* this is only allowed while in a stable state. A check for a stable
1529 * state was done in jtag_add_clocks()
1530 */
1531 if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1532 retval = ERROR_JTAG_QUEUE_FAILED;
1533 #ifdef _DEBUG_JTAG_IO_
1534 LOG_DEBUG( "clocks %i while in %s", cmd->cmd.stableclocks->num_cycles, tap_state_name( tap_get_state() ) );
1535 #endif
1536
1537 return retval;
1538 }
1539
1540 static int ft2232_execute_command(jtag_command_t *cmd)
1541 {
1542 int retval;
1543 retval = ERROR_OK;
1544
1545 switch (cmd->type)
1546 {
1547 case JTAG_END_STATE: retval = ft2232_execute_end_state(cmd); break;
1548 case JTAG_RESET: retval = ft2232_execute_reset(cmd); break;
1549 case JTAG_RUNTEST: retval = ft2232_execute_runtest(cmd); break;
1550 case JTAG_STATEMOVE: retval = ft2232_execute_statemove(cmd); break;
1551 case JTAG_PATHMOVE: retval = ft2232_execute_pathmove(cmd); break;
1552 case JTAG_SCAN: retval = ft2232_execute_scan(cmd); break;
1553 case JTAG_SLEEP: retval = ft2232_execute_sleep(cmd); break;
1554 case JTAG_STABLECLOCKS: retval = ft2232_execute_stableclocks(cmd); break;
1555 default:
1556 LOG_ERROR("BUG: unknown JTAG command type encountered");
1557 exit(-1);
1558 }
1559 return retval;
1560 }
1561
1562 static int ft2232_execute_queue()
1563 {
1564 jtag_command_t* cmd = jtag_command_queue; /* currently processed command */
1565 int retval;
1566
1567 first_unsent = cmd; /* next command that has to be sent */
1568 require_send = 0;
1569
1570 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1571 * that wasn't handled by a caller-provided error handler
1572 */
1573 retval = ERROR_OK;
1574
1575 ft2232_buffer_size = 0;
1576 ft2232_expect_read = 0;
1577
1578 /* blink, if the current layout has that feature */
1579 if (layout->blink)
1580 layout->blink();
1581
1582 while (cmd)
1583 {
1584 if (ft2232_execute_command(cmd) != ERROR_OK)
1585 retval = ERROR_JTAG_QUEUE_FAILED;
1586 /* Start reading input before FT2232 TX buffer fills up */
1587 cmd = cmd->next;
1588 if (ft2232_expect_read > 256)
1589 {
1590 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1591 retval = ERROR_JTAG_QUEUE_FAILED;
1592 first_unsent = cmd;
1593 }
1594 }
1595
1596 if (require_send > 0)
1597 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1598 retval = ERROR_JTAG_QUEUE_FAILED;
1599
1600 return retval;
1601 }
1602
1603
1604 #if BUILD_FT2232_FTD2XX == 1
1605 static int ft2232_init_ftd2xx(u16 vid, u16 pid, int more, int* try_more)
1606 {
1607 FT_STATUS status;
1608 DWORD openex_flags = 0;
1609 char* openex_string = NULL;
1610 u8 latency_timer;
1611
1612 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout, vid, pid);
1613
1614 #if IS_WIN32 == 0
1615 /* Add non-standard Vid/Pid to the linux driver */
1616 if ( ( status = FT_SetVIDPID(vid, pid) ) != FT_OK )
1617 {
1618 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
1619 }
1620 #endif
1621
1622 if (ft2232_device_desc && ft2232_serial)
1623 {
1624 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1625 ft2232_device_desc = NULL;
1626 }
1627
1628 if (ft2232_device_desc)
1629 {
1630 openex_string = ft2232_device_desc;
1631 openex_flags = FT_OPEN_BY_DESCRIPTION;
1632 }
1633 else if (ft2232_serial)
1634 {
1635 openex_string = ft2232_serial;
1636 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
1637 }
1638 else
1639 {
1640 LOG_ERROR("neither device description nor serial number specified");
1641 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1642
1643 return ERROR_JTAG_INIT_FAILED;
1644 }
1645
1646 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1647 if( status != FT_OK ){
1648 // under Win32, the FTD2XX driver appends an "A" to the end
1649 // of the description, if we tried by the desc, then
1650 // try by the alternate "A" description.
1651 if( openex_string == ft2232_device_desc ){
1652 // Try the alternate method.
1653 openex_string = ft2232_device_desc_A;
1654 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1655 if( status == FT_OK ){
1656 // yea, the "alternate" method worked!
1657 } else {
1658 // drat, give the user a meaningfull message.
1659 // telling the use we tried *BOTH* methods.
1660 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1661 ft2232_device_desc,
1662 ft2232_device_desc_A );
1663 }
1664 }
1665 }
1666
1667 if ( status != FT_OK )
1668 {
1669 DWORD num_devices;
1670
1671 if (more)
1672 {
1673 LOG_WARNING("unable to open ftdi device (trying more): %lu", status);
1674 *try_more = 1;
1675 return ERROR_JTAG_INIT_FAILED;
1676 }
1677 LOG_ERROR("unable to open ftdi device: %lu", status);
1678 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
1679 if (status == FT_OK)
1680 {
1681 char** desc_array = malloc( sizeof(char*) * (num_devices + 1) );
1682 u32 i;
1683
1684 for (i = 0; i < num_devices; i++)
1685 desc_array[i] = malloc(64);
1686
1687 desc_array[num_devices] = NULL;
1688
1689 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
1690
1691 if (status == FT_OK)
1692 {
1693 LOG_ERROR("ListDevices: %lu\n", num_devices);
1694 for (i = 0; i < num_devices; i++)
1695 LOG_ERROR("%i: \"%s\"", i, desc_array[i]);
1696 }
1697
1698 for (i = 0; i < num_devices; i++)
1699 free(desc_array[i]);
1700
1701 free(desc_array);
1702 }
1703 else
1704 {
1705 LOG_ERROR("ListDevices: NONE\n");
1706 }
1707 return ERROR_JTAG_INIT_FAILED;
1708 }
1709
1710 if ( ( status = FT_SetLatencyTimer(ftdih, ft2232_latency) ) != FT_OK )
1711 {
1712 LOG_ERROR("unable to set latency timer: %lu", status);
1713 return ERROR_JTAG_INIT_FAILED;
1714 }
1715
1716 if ( ( status = FT_GetLatencyTimer(ftdih, &latency_timer) ) != FT_OK )
1717 {
1718 LOG_ERROR("unable to get latency timer: %lu", status);
1719 return ERROR_JTAG_INIT_FAILED;
1720 }
1721 else
1722 {
1723 LOG_DEBUG("current latency timer: %i", latency_timer);
1724 }
1725
1726 if ( ( status = FT_SetTimeouts(ftdih, 5000, 5000) ) != FT_OK )
1727 {
1728 LOG_ERROR("unable to set timeouts: %lu", status);
1729 return ERROR_JTAG_INIT_FAILED;
1730 }
1731
1732 if ( ( status = FT_SetBitMode(ftdih, 0x0b, 2) ) != FT_OK )
1733 {
1734 LOG_ERROR("unable to enable bit i/o mode: %lu", status);
1735 return ERROR_JTAG_INIT_FAILED;
1736 }
1737
1738 return ERROR_OK;
1739 }
1740
1741
1742 static int ft2232_purge_ftd2xx(void)
1743 {
1744 FT_STATUS status;
1745
1746 if ( ( status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX) ) != FT_OK )
1747 {
1748 LOG_ERROR("error purging ftd2xx device: %lu", status);
1749 return ERROR_JTAG_INIT_FAILED;
1750 }
1751
1752 return ERROR_OK;
1753 }
1754
1755
1756 #endif /* BUILD_FT2232_FTD2XX == 1 */
1757
1758 #if BUILD_FT2232_LIBFTDI == 1
1759 static int ft2232_init_libftdi(u16 vid, u16 pid, int more, int* try_more)
1760 {
1761 u8 latency_timer;
1762
1763 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1764 ft2232_layout, vid, pid);
1765
1766 if (ftdi_init(&ftdic) < 0)
1767 return ERROR_JTAG_INIT_FAILED;
1768
1769 /* context, vendor id, product id */
1770 if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc,
1771 ft2232_serial) < 0)
1772 {
1773 if (more)
1774 LOG_WARNING("unable to open ftdi device (trying more): %s",
1775 ftdic.error_str);
1776 else
1777 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
1778 *try_more = 1;
1779 return ERROR_JTAG_INIT_FAILED;
1780 }
1781
1782 if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
1783 {
1784 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
1785 return ERROR_JTAG_INIT_FAILED;
1786 }
1787
1788 if (ftdi_usb_reset(&ftdic) < 0)
1789 {
1790 LOG_ERROR("unable to reset ftdi device");
1791 return ERROR_JTAG_INIT_FAILED;
1792 }
1793
1794 if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0)
1795 {
1796 LOG_ERROR("unable to set latency timer");
1797 return ERROR_JTAG_INIT_FAILED;
1798 }
1799
1800 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
1801 {
1802 LOG_ERROR("unable to get latency timer");
1803 return ERROR_JTAG_INIT_FAILED;
1804 }
1805 else
1806 {
1807 LOG_DEBUG("current latency timer: %i", latency_timer);
1808 }
1809
1810 ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
1811
1812 return ERROR_OK;
1813 }
1814
1815
1816 static int ft2232_purge_libftdi(void)
1817 {
1818 if (ftdi_usb_purge_buffers(&ftdic) < 0)
1819 {
1820 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
1821 return ERROR_JTAG_INIT_FAILED;
1822 }
1823
1824 return ERROR_OK;
1825 }
1826
1827
1828 #endif /* BUILD_FT2232_LIBFTDI == 1 */
1829
1830 static int ft2232_init(void)
1831 {
1832 u8 buf[1];
1833 int retval;
1834 u32 bytes_written;
1835 ft2232_layout_t* cur_layout = ft2232_layouts;
1836 int i;
1837
1838 if ( (ft2232_layout == NULL) || (ft2232_layout[0] == 0) )
1839 {
1840 ft2232_layout = "usbjtag";
1841 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
1842 }
1843
1844 while (cur_layout->name)
1845 {
1846 if (strcmp(cur_layout->name, ft2232_layout) == 0)
1847 {
1848 layout = cur_layout;
1849 break;
1850 }
1851 cur_layout++;
1852 }
1853
1854 if (!layout)
1855 {
1856 LOG_ERROR("No matching layout found for %s", ft2232_layout);
1857 return ERROR_JTAG_INIT_FAILED;
1858 }
1859
1860 for (i = 0; 1; i++)
1861 {
1862 /*
1863 * "more indicates that there are more IDs to try, so we should
1864 * not print an error for an ID mismatch (but for anything
1865 * else, we should).
1866 *
1867 * try_more indicates that the error code returned indicates an
1868 * ID mismatch (and nothing else) and that we should proceeed
1869 * with the next ID pair.
1870 */
1871 int more = ft2232_vid[i + 1] || ft2232_pid[i + 1];
1872 int try_more = 0;
1873
1874 #if BUILD_FT2232_FTD2XX == 1
1875 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
1876 more, &try_more);
1877 #elif BUILD_FT2232_LIBFTDI == 1
1878 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
1879 more, &try_more);
1880 #endif
1881 if (retval >= 0)
1882 break;
1883 if (!more || !try_more)
1884 return retval;
1885 }
1886
1887 ft2232_buffer_size = 0;
1888 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
1889
1890 if (layout->init() != ERROR_OK)
1891 return ERROR_JTAG_INIT_FAILED;
1892
1893 ft2232_speed(jtag_speed);
1894
1895 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
1896 if ( ( ( retval = ft2232_write(buf, 1, &bytes_written) ) != ERROR_OK ) || (bytes_written != 1) )
1897 {
1898 LOG_ERROR("couldn't write to FT2232 to disable loopback");
1899 return ERROR_JTAG_INIT_FAILED;
1900 }
1901
1902 #if BUILD_FT2232_FTD2XX == 1
1903 return ft2232_purge_ftd2xx();
1904 #elif BUILD_FT2232_LIBFTDI == 1
1905 return ft2232_purge_libftdi();
1906 #endif
1907
1908 return ERROR_OK;
1909 }
1910
1911
1912 static int usbjtag_init(void)
1913 {
1914 u8 buf[3];
1915 u32 bytes_written;
1916
1917 low_output = 0x08;
1918 low_direction = 0x0b;
1919
1920 if (strcmp(ft2232_layout, "usbjtag") == 0)
1921 {
1922 nTRST = 0x10;
1923 nTRSTnOE = 0x10;
1924 nSRST = 0x40;
1925 nSRSTnOE = 0x40;
1926 }
1927 else if (strcmp(ft2232_layout, "signalyzer") == 0)
1928 {
1929 nTRST = 0x10;
1930 nTRSTnOE = 0x10;
1931 nSRST = 0x20;
1932 nSRSTnOE = 0x20;
1933 }
1934 else if (strcmp(ft2232_layout, "evb_lm3s811") == 0)
1935 {
1936 nTRST = 0x0;
1937 nTRSTnOE = 0x00;
1938 nSRST = 0x20;
1939 nSRSTnOE = 0x20;
1940 low_output = 0x88;
1941 low_direction = 0x8b;
1942 }
1943 else
1944 {
1945 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout);
1946 return ERROR_JTAG_INIT_FAILED;
1947 }
1948
1949 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1950 {
1951 low_direction &= ~nTRSTnOE; /* nTRST input */
1952 low_output &= ~nTRST; /* nTRST = 0 */
1953 }
1954 else
1955 {
1956 low_direction |= nTRSTnOE; /* nTRST output */
1957 low_output |= nTRST; /* nTRST = 1 */
1958 }
1959
1960 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1961 {
1962 low_direction |= nSRSTnOE; /* nSRST output */
1963 low_output |= nSRST; /* nSRST = 1 */
1964 }
1965 else
1966 {
1967 low_direction &= ~nSRSTnOE; /* nSRST input */
1968 low_output &= ~nSRST; /* nSRST = 0 */
1969 }
1970
1971 /* initialize low byte for jtag */
1972 buf[0] = 0x80; /* command "set data bits low byte" */
1973 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
1974 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
1975 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1976
1977 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
1978 {
1979 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
1980 return ERROR_JTAG_INIT_FAILED;
1981 }
1982
1983 return ERROR_OK;
1984 }
1985
1986
1987 static int axm0432_jtag_init(void)
1988 {
1989 u8 buf[3];
1990 u32 bytes_written;
1991
1992 low_output = 0x08;
1993 low_direction = 0x2b;
1994
1995 /* initialize low byte for jtag */
1996 buf[0] = 0x80; /* command "set data bits low byte" */
1997 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1998 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
1999 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2000
2001 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2002 {
2003 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2004 return ERROR_JTAG_INIT_FAILED;
2005 }
2006
2007 if (strcmp(layout->name, "axm0432_jtag") == 0)
2008 {
2009 nTRST = 0x08;
2010 nTRSTnOE = 0x0; /* No output enable for TRST*/
2011 nSRST = 0x04;
2012 nSRSTnOE = 0x0; /* No output enable for SRST*/
2013 }
2014 else
2015 {
2016 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2017 exit(-1);
2018 }
2019
2020 high_output = 0x0;
2021 high_direction = 0x0c;
2022
2023 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2024 {
2025 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2026 }
2027 else
2028 {
2029 high_output |= nTRST;
2030 }
2031
2032 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2033 {
2034 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2035 }
2036 else
2037 {
2038 high_output |= nSRST;
2039 }
2040
2041 /* initialize high port */
2042 buf[0] = 0x82; /* command "set data bits high byte" */
2043 buf[1] = high_output; /* value */
2044 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2045 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2046
2047 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2048 {
2049 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2050 return ERROR_JTAG_INIT_FAILED;
2051 }
2052
2053 return ERROR_OK;
2054 }
2055
2056
2057 static int jtagkey_init(void)
2058 {
2059 u8 buf[3];
2060 u32 bytes_written;
2061
2062 low_output = 0x08;
2063 low_direction = 0x1b;
2064
2065 /* initialize low byte for jtag */
2066 buf[0] = 0x80; /* command "set data bits low byte" */
2067 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2068 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2069 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2070
2071 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2072 {
2073 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2074 return ERROR_JTAG_INIT_FAILED;
2075 }
2076
2077 if (strcmp(layout->name, "jtagkey") == 0)
2078 {
2079 nTRST = 0x01;
2080 nTRSTnOE = 0x4;
2081 nSRST = 0x02;
2082 nSRSTnOE = 0x08;
2083 }
2084 else if ( (strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2085 || (strcmp(layout->name, "oocdlink") == 0) )
2086 {
2087 nTRST = 0x02;
2088 nTRSTnOE = 0x1;
2089 nSRST = 0x08;
2090 nSRSTnOE = 0x04;
2091 }
2092 else
2093 {
2094 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2095 exit(-1);
2096 }
2097
2098 high_output = 0x0;
2099 high_direction = 0x0f;
2100
2101 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2102 {
2103 high_output |= nTRSTnOE;
2104 high_output &= ~nTRST;
2105 }
2106 else
2107 {
2108 high_output &= ~nTRSTnOE;
2109 high_output |= nTRST;
2110 }
2111
2112 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2113 {
2114 high_output &= ~nSRSTnOE;
2115 high_output |= nSRST;
2116 }
2117 else
2118 {
2119 high_output |= nSRSTnOE;
2120 high_output &= ~nSRST;
2121 }
2122
2123 /* initialize high port */
2124 buf[0] = 0x82; /* command "set data bits high byte" */
2125 buf[1] = high_output; /* value */
2126 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2127 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2128
2129 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2130 {
2131 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2132 return ERROR_JTAG_INIT_FAILED;
2133 }
2134
2135 return ERROR_OK;
2136 }
2137
2138
2139 static int olimex_jtag_init(void)
2140 {
2141 u8 buf[3];
2142 u32 bytes_written;
2143
2144 low_output = 0x08;
2145 low_direction = 0x1b;
2146
2147 /* initialize low byte for jtag */
2148 buf[0] = 0x80; /* command "set data bits low byte" */
2149 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2150 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2151 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2152
2153 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2154 {
2155 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2156 return ERROR_JTAG_INIT_FAILED;
2157 }
2158
2159 nTRST = 0x01;
2160 nTRSTnOE = 0x4;
2161 nSRST = 0x02;
2162 nSRSTnOE = 0x00; /* no output enable for nSRST */
2163
2164 high_output = 0x0;
2165 high_direction = 0x0f;
2166
2167 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2168 {
2169 high_output |= nTRSTnOE;
2170 high_output &= ~nTRST;
2171 }
2172 else
2173 {
2174 high_output &= ~nTRSTnOE;
2175 high_output |= nTRST;
2176 }
2177
2178 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2179 {
2180 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2181 }
2182 else
2183 {
2184 high_output &= ~nSRST;
2185 }
2186
2187 /* turn red LED on */
2188 high_output |= 0x08;
2189
2190 /* initialize high port */
2191 buf[0] = 0x82; /* command "set data bits high byte" */
2192 buf[1] = high_output; /* value */
2193 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2194 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2195
2196 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2197 {
2198 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2199 return ERROR_JTAG_INIT_FAILED;
2200 }
2201
2202 return ERROR_OK;
2203 }
2204
2205
2206 static int flyswatter_init(void)
2207 {
2208 u8 buf[3];
2209 u32 bytes_written;
2210
2211 low_output = 0x18;
2212 low_direction = 0xfb;
2213
2214 /* initialize low byte for jtag */
2215 buf[0] = 0x80; /* command "set data bits low byte" */
2216 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2217 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
2218 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2219
2220 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2221 {
2222 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2223 return ERROR_JTAG_INIT_FAILED;
2224 }
2225
2226 nTRST = 0x10;
2227 nTRSTnOE = 0x0; /* not output enable for nTRST */
2228 nSRST = 0x20;
2229 nSRSTnOE = 0x00; /* no output enable for nSRST */
2230
2231 high_output = 0x00;
2232 high_direction = 0x0c;
2233
2234 /* turn red LED3 on, LED2 off */
2235 high_output |= 0x08;
2236
2237 /* initialize high port */
2238 buf[0] = 0x82; /* command "set data bits high byte" */
2239 buf[1] = high_output; /* value */
2240 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2241 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2242
2243 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2244 {
2245 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2246 return ERROR_JTAG_INIT_FAILED;
2247 }
2248
2249 return ERROR_OK;
2250 }
2251
2252
2253 static int turtle_init(void)
2254 {
2255 u8 buf[3];
2256 u32 bytes_written;
2257
2258 low_output = 0x08;
2259 low_direction = 0x5b;
2260
2261 /* initialize low byte for jtag */
2262 buf[0] = 0x80; /* command "set data bits low byte" */
2263 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2264 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2265 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2266
2267 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2268 {
2269 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2270 return ERROR_JTAG_INIT_FAILED;
2271 }
2272
2273 nSRST = 0x40;
2274
2275 high_output = 0x00;
2276 high_direction = 0x0C;
2277
2278 /* initialize high port */
2279 buf[0] = 0x82; /* command "set data bits high byte" */
2280 buf[1] = high_output;
2281 buf[2] = high_direction;
2282 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2283
2284 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2285 {
2286 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2287 return ERROR_JTAG_INIT_FAILED;
2288 }
2289
2290 return ERROR_OK;
2291 }
2292
2293
2294 static int comstick_init(void)
2295 {
2296 u8 buf[3];
2297 u32 bytes_written;
2298
2299 low_output = 0x08;
2300 low_direction = 0x0b;
2301
2302 /* initialize low byte for jtag */
2303 buf[0] = 0x80; /* command "set data bits low byte" */
2304 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2305 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2306 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2307
2308 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2309 {
2310 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2311 return ERROR_JTAG_INIT_FAILED;
2312 }
2313
2314 nTRST = 0x01;
2315 nTRSTnOE = 0x00; /* no output enable for nTRST */
2316 nSRST = 0x02;
2317 nSRSTnOE = 0x00; /* no output enable for nSRST */
2318
2319 high_output = 0x03;
2320 high_direction = 0x03;
2321
2322 /* initialize high port */
2323 buf[0] = 0x82; /* command "set data bits high byte" */
2324 buf[1] = high_output;
2325 buf[2] = high_direction;
2326 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2327
2328 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2329 {
2330 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2331 return ERROR_JTAG_INIT_FAILED;
2332 }
2333
2334 return ERROR_OK;
2335 }
2336
2337
2338 static int stm32stick_init(void)
2339 {
2340 u8 buf[3];
2341 u32 bytes_written;
2342
2343 low_output = 0x88;
2344 low_direction = 0x8b;
2345
2346 /* initialize low byte for jtag */
2347 buf[0] = 0x80; /* command "set data bits low byte" */
2348 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2349 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2350 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2351
2352 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2353 {
2354 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2355 return ERROR_JTAG_INIT_FAILED;
2356 }
2357
2358 nTRST = 0x01;
2359 nTRSTnOE = 0x00; /* no output enable for nTRST */
2360 nSRST = 0x80;
2361 nSRSTnOE = 0x00; /* no output enable for nSRST */
2362
2363 high_output = 0x01;
2364 high_direction = 0x03;
2365
2366 /* initialize high port */
2367 buf[0] = 0x82; /* command "set data bits high byte" */
2368 buf[1] = high_output;
2369 buf[2] = high_direction;
2370 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2371
2372 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2373 {
2374 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2375 return ERROR_JTAG_INIT_FAILED;
2376 }
2377
2378 return ERROR_OK;
2379 }
2380
2381
2382 static int sheevaplug_init(void)
2383 {
2384 u8 buf[3];
2385 u32 bytes_written;
2386
2387 low_output = 0x08;
2388 low_direction = 0x1b;
2389
2390 /* initialize low byte for jtag */
2391 buf[0] = 0x80; /* command "set data bits low byte" */
2392 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2393 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2394 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2395
2396 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2397 {
2398 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2399 return ERROR_JTAG_INIT_FAILED;
2400 }
2401
2402 nTRSTnOE = 0x1;
2403 nTRST = 0x02;
2404 nSRSTnOE = 0x4;
2405 nSRST = 0x08;
2406
2407 high_output = 0x0;
2408 high_direction = 0x0f;
2409
2410 /* nTRST is always push-pull */
2411 high_output &= ~nTRSTnOE;
2412 high_output |= nTRST;
2413
2414 /* nSRST is always open-drain */
2415 high_output |= nSRSTnOE;
2416 high_output &= ~nSRST;
2417
2418 /* initialize high port */
2419 buf[0] = 0x82; /* command "set data bits high byte" */
2420 buf[1] = high_output; /* value */
2421 buf[2] = high_direction; /* all outputs - xRST */
2422 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2423
2424 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2425 {
2426 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2427 return ERROR_JTAG_INIT_FAILED;
2428 }
2429
2430 return ERROR_OK;
2431 }
2432
2433 static void olimex_jtag_blink(void)
2434 {
2435 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2436 * ACBUS3 is bit 3 of the GPIOH port
2437 */
2438 if (high_output & 0x08)
2439 {
2440 /* set port pin high */
2441 high_output &= 0x07;
2442 }
2443 else
2444 {
2445 /* set port pin low */
2446 high_output |= 0x08;
2447 }
2448
2449 BUFFER_ADD = 0x82;
2450 BUFFER_ADD = high_output;
2451 BUFFER_ADD = high_direction;
2452 }
2453
2454
2455 static void flyswatter_jtag_blink(void)
2456 {
2457 /*
2458 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2459 */
2460 high_output ^= 0x0c;
2461
2462 BUFFER_ADD = 0x82;
2463 BUFFER_ADD = high_output;
2464 BUFFER_ADD = high_direction;
2465 }
2466
2467
2468 static void turtle_jtag_blink(void)
2469 {
2470 /*
2471 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2472 */
2473 if (high_output & 0x08)
2474 {
2475 high_output = 0x04;
2476 }
2477 else
2478 {
2479 high_output = 0x08;
2480 }
2481
2482 BUFFER_ADD = 0x82;
2483 BUFFER_ADD = high_output;
2484 BUFFER_ADD = high_direction;
2485 }
2486
2487
2488 static int ft2232_quit(void)
2489 {
2490 #if BUILD_FT2232_FTD2XX == 1
2491 FT_STATUS status;
2492
2493 status = FT_Close(ftdih);
2494 #elif BUILD_FT2232_LIBFTDI == 1
2495 ftdi_disable_bitbang(&ftdic);
2496
2497 ftdi_usb_close(&ftdic);
2498
2499 ftdi_deinit(&ftdic);
2500 #endif
2501
2502 free(ft2232_buffer);
2503 ft2232_buffer = NULL;
2504
2505 return ERROR_OK;
2506 }
2507
2508
2509 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2510 {
2511 char *cp;
2512 char buf[200];
2513 if (argc == 1)
2514 {
2515 ft2232_device_desc = strdup(args[0]);
2516 cp = strchr( ft2232_device_desc, 0 );
2517 // under Win32, the FTD2XX driver appends an "A" to the end
2518 // of the description, this examines the given desc
2519 // and creates the 'missing' _A or non_A variable.
2520 if( (cp[-1] == 'A') && (cp[-2]==' ') ){
2521 // it was, so make this the "A" version.
2522 ft2232_device_desc_A = ft2232_device_desc;
2523 // and *CREATE* the non-A version.
2524 strcpy( buf, ft2232_device_desc );
2525 cp = strchr( buf, 0 );
2526 cp[-2] = 0;
2527 ft2232_device_desc = strdup( buf );
2528 } else {
2529 // <space>A not defined
2530 // so create it
2531 sprintf( buf, "%s A", ft2232_device_desc );
2532 ft2232_device_desc_A = strdup( buf );
2533 }
2534 }
2535 else
2536 {
2537 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2538 }
2539
2540 return ERROR_OK;
2541 }
2542
2543
2544 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2545 {
2546 if (argc == 1)
2547 {
2548 ft2232_serial = strdup(args[0]);
2549 }
2550 else
2551 {
2552 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2553 }
2554
2555 return ERROR_OK;
2556 }
2557
2558
2559 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2560 {
2561 if (argc == 0)
2562 return ERROR_OK;
2563
2564 ft2232_layout = malloc(strlen(args[0]) + 1);
2565 strcpy(ft2232_layout, args[0]);
2566
2567 return ERROR_OK;
2568 }
2569
2570
2571 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2572 {
2573 int i;
2574
2575 if (argc > MAX_USB_IDS * 2)
2576 {
2577 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2578 "(maximum is %d pairs)", MAX_USB_IDS);
2579 argc = MAX_USB_IDS * 2;
2580 }
2581 if ( argc < 2 || (argc & 1) )
2582 {
2583 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2584 if (argc < 2)
2585 return ERROR_OK;
2586 }
2587
2588 for (i = 0; i + 1 < argc; i += 2)
2589 {
2590 ft2232_vid[i >> 1] = strtol(args[i], NULL, 0);
2591 ft2232_pid[i >> 1] = strtol(args[i + 1], NULL, 0);
2592 }
2593
2594 /*
2595 * Explicitly terminate, in case there are multiples instances of
2596 * ft2232_vid_pid.
2597 */
2598 ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
2599
2600 return ERROR_OK;
2601 }
2602
2603
2604 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2605 {
2606 if (argc == 1)
2607 {
2608 ft2232_latency = atoi(args[0]);
2609 }
2610 else
2611 {
2612 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2613 }
2614
2615 return ERROR_OK;
2616 }
2617
2618
2619 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd)
2620 {
2621 int retval = 0;
2622
2623 /* 7 bits of either ones or zeros. */
2624 u8 tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
2625
2626 while (num_cycles > 0)
2627 {
2628 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2629 * at most 7 bits per invocation. Here we invoke it potentially
2630 * several times.
2631 */
2632 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
2633
2634 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE)
2635 {
2636 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2637 retval = ERROR_JTAG_QUEUE_FAILED;
2638
2639 first_unsent = cmd;
2640 }
2641
2642 /* command "Clock Data to TMS/CS Pin (no Read)" */
2643 BUFFER_ADD = 0x4b;
2644
2645 /* scan 7 bit */
2646 BUFFER_ADD = bitcount_per_command - 1;
2647
2648 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2649 BUFFER_ADD = tms;
2650
2651 require_send = 1;
2652
2653 num_cycles -= bitcount_per_command;
2654 }
2655
2656 return retval;
2657 }
2658
2659 /* ---------------------------------------------------------------------
2660 * Support for IceBear JTAG adapter from Section5:
2661 * http://section5.ch/icebear
2662 *
2663 * Author: Sten, debian@sansys-electronic.com
2664 */
2665
2666 /* Icebear pin layout
2667 *
2668 * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC)
2669 * GND GND | 4 3| n.c.
2670 * ADBUS3 TMS | 6 5| ADBUS6 VCC
2671 * ADBUS0 TCK | 8 7| ADBUS7 (GND)
2672 * ADBUS4 nTRST |10 9| ACBUS0 (GND)
2673 * ADBUS1 TDI |12 11| ACBUS1 (GND)
2674 * ADBUS2 TDO |14 13| GND GND
2675 *
2676 * ADBUS0 O L TCK ACBUS0 GND
2677 * ADBUS1 O L TDI ACBUS1 GND
2678 * ADBUS2 I TDO ACBUS2 n.c.
2679 * ADBUS3 O H TMS ACBUS3 n.c.
2680 * ADBUS4 O H nTRST
2681 * ADBUS5 O H nSRST
2682 * ADBUS6 - VCC
2683 * ADBUS7 - GND
2684 */
2685 static int icebear_jtag_init(void) {
2686 u8 buf[3];
2687 u32 bytes_written;
2688
2689 low_direction = 0x0b; /* output: TCK TDI TMS; input: TDO */
2690 low_output = 0x08; /* high: TMS; low: TCK TDI */
2691 nTRST = 0x10;
2692 nSRST = 0x20;
2693
2694 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0) {
2695 low_direction &= ~nTRST; /* nTRST high impedance */
2696 }
2697 else {
2698 low_direction |= nTRST;
2699 low_output |= nTRST;
2700 }
2701
2702 low_direction |= nSRST;
2703 low_output |= nSRST;
2704
2705 /* initialize low byte for jtag */
2706 buf[0] = 0x80; /* command "set data bits low byte" */
2707 buf[1] = low_output;
2708 buf[2] = low_direction;
2709 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2710
2711 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) {
2712 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
2713 return ERROR_JTAG_INIT_FAILED;
2714 }
2715
2716 high_output = 0x0;
2717 high_direction = 0x00;
2718
2719
2720 /* initialize high port */
2721 buf[0] = 0x82; /* command "set data bits high byte" */
2722 buf[1] = high_output; /* value */
2723 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2724 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2725
2726 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) {
2727 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
2728 return ERROR_JTAG_INIT_FAILED;
2729 }
2730
2731 return ERROR_OK;
2732 }
2733
2734 static void icebear_jtag_reset(int trst, int srst) {
2735
2736 if (trst == 1) {
2737 low_direction |= nTRST;
2738 low_output &= ~nTRST;
2739 }
2740 else if (trst == 0) {
2741 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
2742 low_direction &= ~nTRST;
2743 else
2744 low_output |= nTRST;
2745 }
2746
2747 if (srst == 1) {
2748 low_output &= ~nSRST;
2749 }
2750 else if (srst == 0) {
2751 low_output |= nSRST;
2752 }
2753
2754 /* command "set data bits low byte" */
2755 BUFFER_ADD = 0x80;
2756 BUFFER_ADD = low_output;
2757 BUFFER_ADD = low_direction;
2758 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
2759 }
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)