Code Review / openocd.git / blob
? search:


c73c8d58ef148ec9b23ab3d492ff5aeb93891fe1
[openocd.git] / src / jtag / ftd2xx.c
1 /***************************************************************************
2 * Copyright (C) 2004 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #include "config.h"
21 #if IS_CYGWIN == 1
22 #include "windows.h"
23 #undef ERROR
24 #endif
25
26 /* project specific includes */
27 #include "log.h"
28 #include "types.h"
29 #include "jtag.h"
30 #include "configuration.h"
31
32 /* system includes */
33 #include <string.h>
34 #include <stdlib.h>
35 #include <unistd.h>
36 #include <ftd2xx.h>
37
38 #include <sys/time.h>
39 #include <time.h>
40
41 /* enable this to debug io latency
42 */
43 #if 0
44 #define _DEBUG_USB_IO_
45 #endif
46
47 /* enable this to debug communication
48 */
49 #if 0
50 #define _DEBUG_USB_COMMS_
51 #endif
52
53 /* enable this to work around ftd2xx deadlock
54 */
55 #if 0
56 #define _FTD2XX_QUEUE_DELAY_
57 #endif
58
59 int ftd2xx_execute_queue(void);
60
61 int ftd2xx_speed(int speed);
62 int ftd2xx_register_commands(struct command_context_s *cmd_ctx);
63 int ftd2xx_init(void);
64 int ftd2xx_quit(void);
65
66 int ftd2xx_handle_device_desc_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
67 int ftd2xx_handle_layout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
68 int ftd2xx_handle_vid_pid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
69
70 char *ftd2xx_device_desc = NULL;
71 char *ftd2xx_layout = NULL;
72 u16 ftd2xx_vid = 0x0403;
73 u16 ftd2xx_pid = 0x6010;
74
75 typedef struct ftd2xx_layout_s
76 {
77 char* name;
78 int(*init)(void);
79 void(*reset)(int trst, int srst);
80 } ftd2xx_layout_t;
81
82 int usbjtag_init(void);
83 int jtagkey_init(void);
84 void usbjtag_reset(int trst, int srst);
85 void jtagkey_reset(int trst, int srst);
86
87 ftd2xx_layout_t ftd2xx_layouts[] =
88 {
89 {"usbjtag", usbjtag_init, usbjtag_reset},
90 {"jtagkey", jtagkey_init, jtagkey_reset},
91 {"jtagkey_prototype_v1", jtagkey_init, jtagkey_reset},
92 {NULL, NULL, NULL},
93 };
94
95 static u8 nTRST, nTRSTnOE, nSRST, nSRSTnOE;
96
97 static ftd2xx_layout_t *layout;
98 static u8 low_output = 0x0;
99 static u8 low_direction = 0x0;
100 static u8 high_output = 0x0;
101 static u8 high_direction = 0x0;
102 static FT_HANDLE ftdih = NULL;
103
104 static u8 *ftd2xx_buffer = NULL;
105 static int ftd2xx_buffer_size = 0;
106 static int ftd2xx_read_pointer = 0;
107 static int ftd2xx_expect_read = 0;
108 #define FTD2XX_BUFFER_SIZE 131072
109 #define BUFFER_ADD ftd2xx_buffer[ftd2xx_buffer_size++]
110 #define BUFFER_READ ftd2xx_buffer[ftd2xx_read_pointer++]
111
112 jtag_interface_t ftd2xx_interface =
113 {
114
115 .name = "ftd2xx",
116
117 .execute_queue = ftd2xx_execute_queue,
118
119 .support_statemove = 1,
120
121 .speed = ftd2xx_speed,
122 .register_commands = ftd2xx_register_commands,
123 .init = ftd2xx_init,
124 .quit = ftd2xx_quit,
125 };
126
127 int ftd2xx_speed(int speed)
128 {
129 u8 buf[3];
130 FT_STATUS status;
131 DWORD bytes_written;
132
133 buf[0] = 0x86; /* command "set divisor" */
134 buf[1] = speed & 0xff; /* valueL (0=6MHz, 1=3MHz, 2=1.5MHz, ...*/
135 buf[2] = (speed >> 8) & 0xff; /* valueH */
136
137 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
138 if (((status = FT_Write(ftdih, buf, 3, &bytes_written)) != FT_OK) || (bytes_written != 3))
139 {
140 ERROR("couldn't write to ftdi device: %i", status);
141 return status;
142 }
143
144 return ERROR_OK;
145 }
146
147 int ftd2xx_register_commands(struct command_context_s *cmd_ctx)
148 {
149 register_command(cmd_ctx, NULL, "ftd2xx_device_desc", ftd2xx_handle_device_desc_command,
150 COMMAND_CONFIG, NULL);
151 register_command(cmd_ctx, NULL, "ftd2xx_layout", ftd2xx_handle_layout_command,
152 COMMAND_CONFIG, NULL);
153 register_command(cmd_ctx, NULL, "ftd2xx_vid_pid", ftd2xx_handle_vid_pid_command,
154 COMMAND_CONFIG, NULL);
155 return ERROR_OK;
156 }
157
158 void ftd2xx_end_state(state)
159 {
160 if (tap_move_map[state] != -1)
161 end_state = state;
162 else
163 {
164 ERROR("BUG: %i is not a valid end state", state);
165 exit(-1);
166 }
167 }
168
169 void ftd2xx_read_scan(enum scan_type type, u8* buffer, int scan_size)
170 {
171 int num_bytes = ((scan_size + 7) / 8);
172 int bits_left = scan_size;
173 int cur_byte = 0;
174
175 while(num_bytes-- > 1)
176 {
177 buffer[cur_byte] = BUFFER_READ;
178 cur_byte++;
179 bits_left -= 8;
180 }
181
182 buffer[cur_byte] = 0x0;
183
184 if (bits_left > 1)
185 {
186 buffer[cur_byte] = BUFFER_READ >> 1;
187 }
188
189 buffer[cur_byte] = (buffer[cur_byte] | ((BUFFER_READ & 0x02) << 6)) >> (8 - bits_left);
190
191 }
192
193 void ftd2xx_debug_dump_buffer(void)
194 {
195 int i;
196 char line[256];
197 char *line_p = line;
198
199 for (i = 0; i < ftd2xx_buffer_size; i++)
200 {
201 line_p += snprintf(line_p, 256 - (line_p - line), "%2.2x ", ftd2xx_buffer[i]);
202 if (i % 16 == 15)
203 {
204 DEBUG("%s", line);
205 line_p = line;
206 }
207 }
208
209 if (line_p != line)
210 DEBUG("%s", line);
211 }
212
213 int ftd2xx_send_and_recv(jtag_command_t *first, jtag_command_t *last)
214 {
215 jtag_command_t *cmd;
216 u8 *buffer;
217 int scan_size;
218 enum scan_type type;
219 FT_STATUS status;
220 DWORD bytes_written;
221 DWORD bytes_read;
222
223 #ifdef _DEBUG_USB_IO_
224 struct timeval start, inter, inter2, end;
225 #endif
226
227 #ifdef _DEBUG_USB_COMMS_
228 DEBUG("write buffer (size %i):", ftd2xx_buffer_size);
229 ftd2xx_debug_dump_buffer();
230 #endif
231
232 #ifdef _DEBUG_USB_IO_
233 gettimeofday(&start, NULL);
234 #endif
235
236 if ((status = FT_Write(ftdih, ftd2xx_buffer, ftd2xx_buffer_size, &bytes_written)) != FT_OK)
237 {
238 ERROR("couldn't write to ftdi device: %i", status);
239 exit(-1);
240 }
241
242 #ifdef _DEBUG_USB_IO_
243 gettimeofday(&inter, NULL);
244 #endif
245
246 if (ftd2xx_expect_read)
247 {
248 int timeout = 100;
249 ftd2xx_buffer_size = 0;
250
251 #ifdef _FTD2XX_QUEUE_DELAY_
252 DWORD inrxqueue = 0;
253 while (inrxqueue < ftd2xx_expect_read)
254 {
255 FT_GetQueueStatus(ftdih, &inrxqueue);
256 if (inrxqueue >= ftd2xx_expect_read)
257 break;
258 usleep(1000);
259 };
260 #endif
261
262 #ifdef _DEBUG_USB_IO_
263 gettimeofday(&inter2, NULL);
264 #endif
265
266 if ((status = FT_Read(ftdih, ftd2xx_buffer, ftd2xx_expect_read, &bytes_read)) != FT_OK)
267 {
268 ERROR("couldn't read from ftdi device: %i", status);
269 exit(-1);
270 }
271
272 #ifdef _DEBUG_USB_IO_
273 gettimeofday(&end, NULL);
274
275 INFO("inter: %i.%i, inter2: %i.%i end: %i.%i", inter.tv_sec - start.tv_sec, inter.tv_usec - start.tv_usec,
276 inter2.tv_sec - start.tv_sec, inter2.tv_usec - start.tv_usec,
277 end.tv_sec - start.tv_sec, end.tv_usec - start.tv_usec);
278 #endif
279
280
281 ftd2xx_buffer_size = bytes_read;
282
283 if (ftd2xx_expect_read != ftd2xx_buffer_size)
284 {
285 ERROR("ftd2xx_expect_read (%i) != ftd2xx_buffer_size (%i) (%i retries)", ftd2xx_expect_read, ftd2xx_buffer_size, 100 - timeout);
286 ftd2xx_debug_dump_buffer();
287
288 exit(-1);
289 }
290
291 #ifdef _DEBUG_USB_COMMS_
292 DEBUG("read buffer (%i retries): %i bytes", 100 - timeout, ftd2xx_buffer_size);
293 ftd2xx_debug_dump_buffer();
294 #endif
295 }
296
297 ftd2xx_expect_read = 0;
298 ftd2xx_read_pointer = 0;
299
300 cmd = first;
301 while (cmd != last)
302 {
303 switch (cmd->type)
304 {
305 case JTAG_SCAN:
306 type = jtag_scan_type(cmd->cmd.scan);
307 if (type != SCAN_OUT)
308 {
309 scan_size = jtag_scan_size(cmd->cmd.scan);
310 buffer = calloc(CEIL(scan_size, 8), 1);
311 ftd2xx_read_scan(type, buffer, scan_size);
312 jtag_read_buffer(buffer, cmd->cmd.scan);
313 free(buffer);
314 }
315 break;
316 default:
317 break;
318 }
319 cmd = cmd->next;
320 }
321
322 ftd2xx_buffer_size = 0;
323
324 return ERROR_OK;
325 }
326
327 void ftd2xx_add_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
328 {
329 int num_bytes = (scan_size + 7) / 8;
330 int bits_left = scan_size;
331 int cur_byte = 0;
332 int last_bit;
333
334 /* command "Clock Data to TMS/CS Pin (no Read)" */
335 BUFFER_ADD = 0x4b;
336 /* scan 7 bit */
337 BUFFER_ADD = 0x6;
338 /* TMS data bits */
339 if (ir_scan)
340 {
341 BUFFER_ADD = TAP_MOVE(cur_state, TAP_SI);
342 cur_state = TAP_SI;
343 }
344 else
345 {
346 BUFFER_ADD = TAP_MOVE(cur_state, TAP_SD);
347 cur_state = TAP_SD;
348 }
349 //DEBUG("added TMS scan (no read)");
350
351 /* add command for complete bytes */
352 if (num_bytes > 1)
353 {
354 if (type == SCAN_IO)
355 {
356 /* Clock Data Bytes In and Out LSB First */
357 BUFFER_ADD = 0x39;
358 //DEBUG("added TDI bytes (io %i)", num_bytes);
359 }
360 else if (type == SCAN_OUT)
361 {
362 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
363 BUFFER_ADD = 0x19;
364 //DEBUG("added TDI bytes (o)");
365 }
366 else if (type == SCAN_IN)
367 {
368 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
369 BUFFER_ADD = 0x28;
370 //DEBUG("added TDI bytes (i %i)", num_bytes);
371 }
372 BUFFER_ADD = (num_bytes-2) & 0xff;
373 BUFFER_ADD = (num_bytes >> 8) & 0xff;
374 }
375 if (type != SCAN_IN)
376 {
377 /* add complete bytes */
378 while(num_bytes-- > 1)
379 {
380 BUFFER_ADD = buffer[cur_byte];
381 cur_byte++;
382 bits_left -= 8;
383 }
384 }
385 if (type == SCAN_IN)
386 {
387 bits_left -= 8 * (num_bytes - 1);
388 }
389
390 /* the most signifcant bit is scanned during TAP movement */
391 if (type != SCAN_IN)
392 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
393 else
394 last_bit = 0;
395
396 /* process remaining bits but the last one */
397 if (bits_left > 1)
398 {
399 if (type == SCAN_IO)
400 {
401 /* Clock Data Bits In and Out LSB First */
402 BUFFER_ADD = 0x3b;
403 //DEBUG("added TDI bits (io) %i", bits_left - 1);
404 }
405 else if (type == SCAN_OUT)
406 {
407 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
408 BUFFER_ADD = 0x1b;
409 //DEBUG("added TDI bits (o)");
410 }
411 else if (type == SCAN_IN)
412 {
413 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
414 BUFFER_ADD = 0x2a;
415 //DEBUG("added TDI bits (i %i)", bits_left - 1);
416 }
417 BUFFER_ADD = bits_left - 2;
418 if (type != SCAN_IN)
419 BUFFER_ADD = buffer[cur_byte];
420 }
421
422 /* move from Shift-IR/DR to end state */
423 if (type != SCAN_OUT)
424 {
425 /* Clock Data to TMS/CS Pin with Read */
426 BUFFER_ADD = 0x6b;
427 //DEBUG("added TMS scan (read)");
428 }
429 else
430 {
431 /* Clock Data to TMS/CS Pin (no Read) */
432 BUFFER_ADD = 0x4b;
433 //DEBUG("added TMS scan (no read)");
434 }
435 BUFFER_ADD = 0x6;
436 BUFFER_ADD = TAP_MOVE(cur_state, end_state) | (last_bit << 7);
437 cur_state = end_state;
438
439 }
440
441 int ftd2xx_predict_scan_out(int scan_size, enum scan_type type)
442 {
443 int predicted_size = 6;
444 if (type == SCAN_IN) /* only from device to host */
445 {
446 predicted_size += (CEIL(scan_size, 8) > 1) ? 3 : 0;
447 predicted_size += ((scan_size - 1) % 8) ? 2 : 0;
448 }
449 else /* host to device, or bidirectional */
450 {
451 predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) + 3 - 1) : 0;
452 predicted_size += ((scan_size - 1) % 8) ? 3 : 0;
453 }
454
455 return predicted_size;
456 }
457
458 int ftd2xx_predict_scan_in(int scan_size, enum scan_type type)
459 {
460 int predicted_size = 0;
461
462 if (type != SCAN_OUT)
463 {
464 /* complete bytes */
465 predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) - 1) : 0;
466 /* remaining bits - 1 */
467 predicted_size += ((scan_size - 1) % 8) ? 1 : 0;
468 /* last bit (from TMS scan) */
469 predicted_size += 1;
470 }
471
472 //DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size);
473
474 return predicted_size;
475 }
476
477 void usbjtag_reset(int trst, int srst)
478 {
479 if (trst == 1)
480 {
481 cur_state = TAP_TLR;
482 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
483 low_direction |= nTRSTnOE; /* switch to output pin (output is low) */
484 else
485 low_output &= ~nTRST; /* switch output low */
486 }
487 else if (trst == 0)
488 {
489 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
490 low_direction &= ~nTRSTnOE; /* switch to input pin (high-Z + internal and external pullup) */
491 else
492 low_output |= nTRST; /* switch output high */
493 }
494
495 if (srst == 1)
496 {
497 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
498 low_output &= ~nSRST; /* switch output low */
499 else
500 low_direction |= nSRSTnOE; /* switch to output pin (output is low) */
501 }
502 else if (srst == 0)
503 {
504 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
505 low_output |= nSRST; /* switch output high */
506 else
507 low_direction &= ~nSRSTnOE; /* switch to input pin (high-Z) */
508 }
509
510 /* command "set data bits low byte" */
511 BUFFER_ADD = 0x80;
512 BUFFER_ADD = low_output;
513 BUFFER_ADD = low_direction;
514
515 }
516
517 void jtagkey_reset(int trst, int srst)
518 {
519 if (trst == 1)
520 {
521 cur_state = TAP_TLR;
522 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
523 high_output &= ~nTRSTnOE;
524 else
525 high_output &= ~nTRST;
526 }
527 else if (trst == 0)
528 {
529 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
530 high_output |= nTRSTnOE;
531 else
532 high_output |= nTRST;
533 }
534
535 if (srst == 1)
536 {
537 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
538 high_output &= ~nSRST;
539 else
540 high_output &= ~nSRSTnOE;
541 }
542 else if (srst == 0)
543 {
544 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
545 high_output |= nSRST;
546 else
547 high_output |= nSRSTnOE;
548 }
549
550 /* command "set data bits high byte" */
551 BUFFER_ADD = 0x82;
552 BUFFER_ADD = high_output;
553 BUFFER_ADD = high_direction;
554 DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
555 }
556
557 int ftd2xx_execute_queue()
558 {
559 jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
560 jtag_command_t *first_unsent = cmd; /* next command that has to be sent */
561 u8 *buffer;
562 int scan_size; /* size of IR or DR scan */
563 enum scan_type type;
564 int i;
565 int predicted_size = 0;
566 int require_send = 0;
567
568 ftd2xx_buffer_size = 0;
569 ftd2xx_expect_read = 0;
570
571 while (cmd)
572 {
573 switch(cmd->type)
574 {
575 case JTAG_END_STATE:
576 if (cmd->cmd.end_state->end_state != -1)
577 ftd2xx_end_state(cmd->cmd.end_state->end_state);
578 break;
579 case JTAG_RESET:
580 /* only send the maximum buffer size that FT2232C can handle */
581 predicted_size = 3;
582 if (ftd2xx_buffer_size + predicted_size + 1 > FTD2XX_BUFFER_SIZE)
583 {
584 ftd2xx_send_and_recv(first_unsent, cmd);
585 require_send = 0;
586 first_unsent = cmd;
587 }
588
589 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
590 require_send = 1;
591
592 break;
593 case JTAG_RUNTEST:
594 /* only send the maximum buffer size that FT2232C can handle */
595 predicted_size = 0;
596 if (cur_state != TAP_RTI)
597 predicted_size += 3;
598 predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7);
599 if ((cmd->cmd.runtest->end_state != -1) && (cmd->cmd.runtest->end_state != TAP_RTI))
600 predicted_size += 3;
601 if ((cmd->cmd.runtest->end_state == -1) && (end_state != TAP_RTI))
602 predicted_size += 3;
603 if (ftd2xx_buffer_size + predicted_size + 1 > FTD2XX_BUFFER_SIZE)
604 {
605 ftd2xx_send_and_recv(first_unsent, cmd);
606 require_send = 0;
607 first_unsent = cmd;
608 }
609 if (cur_state != TAP_RTI)
610 {
611 /* command "Clock Data to TMS/CS Pin (no Read)" */
612 BUFFER_ADD = 0x4b;
613 /* scan 7 bit */
614 BUFFER_ADD = 0x6;
615 /* TMS data bits */
616 BUFFER_ADD = TAP_MOVE(cur_state, TAP_RTI);
617 cur_state = TAP_RTI;
618 require_send = 1;
619 }
620 i = cmd->cmd.runtest->num_cycles;
621 while (i > 0)
622 {
623 /* command "Clock Data to TMS/CS Pin (no Read)" */
624 BUFFER_ADD = 0x4b;
625 /* scan 7 bit */
626 BUFFER_ADD = (i > 7) ? 6 : (i - 1);
627 /* TMS data bits */
628 BUFFER_ADD = 0x0;
629 cur_state = TAP_RTI;
630 i -= (i > 7) ? 7 : i;
631 //DEBUG("added TMS scan (no read)");
632 }
633 if (cmd->cmd.runtest->end_state != -1)
634 ftd2xx_end_state(cmd->cmd.runtest->end_state);
635 if (cur_state != end_state)
636 {
637 /* command "Clock Data to TMS/CS Pin (no Read)" */
638 BUFFER_ADD = 0x4b;
639 /* scan 7 bit */
640 BUFFER_ADD = 0x6;
641 /* TMS data bits */
642 BUFFER_ADD = TAP_MOVE(cur_state, end_state);
643 cur_state = end_state;
644 //DEBUG("added TMS scan (no read)");
645 }
646 require_send = 1;
647 break;
648 case JTAG_STATEMOVE:
649 /* only send the maximum buffer size that FT2232C can handle */
650 predicted_size = 3;
651 if (ftd2xx_buffer_size + predicted_size + 1 > FTD2XX_BUFFER_SIZE)
652 {
653 ftd2xx_send_and_recv(first_unsent, cmd);
654 require_send = 0;
655 first_unsent = cmd;
656 }
657 if (cmd->cmd.statemove->end_state != -1)
658 ftd2xx_end_state(cmd->cmd.statemove->end_state);
659 /* command "Clock Data to TMS/CS Pin (no Read)" */
660 BUFFER_ADD = 0x4b;
661 /* scan 7 bit */
662 BUFFER_ADD = 0x6;
663 /* TMS data bits */
664 BUFFER_ADD = TAP_MOVE(cur_state, end_state);
665 //DEBUG("added TMS scan (no read)");
666 cur_state = end_state;
667 require_send = 1;
668 break;
669 case JTAG_SCAN:
670 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
671 type = jtag_scan_type(cmd->cmd.scan);
672 predicted_size = ftd2xx_predict_scan_out(scan_size, type);
673 if (ftd2xx_buffer_size + predicted_size + 1 > FTD2XX_BUFFER_SIZE)
674 {
675 DEBUG("ftd2xx buffer size reached, sending queued commands (first_unsent: %x, cmd: %x)", first_unsent, cmd);
676 ftd2xx_send_and_recv(first_unsent, cmd);
677 require_send = 0;
678 first_unsent = cmd;
679 }
680 ftd2xx_expect_read += ftd2xx_predict_scan_in(scan_size, type);
681 //DEBUG("new read size: %i", ftd2xx_expect_read);
682 if (cmd->cmd.scan->end_state != -1)
683 ftd2xx_end_state(cmd->cmd.scan->end_state);
684 ftd2xx_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
685 require_send = 1;
686 if (buffer)
687 free(buffer);
688 break;
689 case JTAG_SLEEP:
690 ftd2xx_send_and_recv(first_unsent, cmd);
691 first_unsent = cmd->next;
692 jtag_sleep(cmd->cmd.sleep->us);
693 break;
694 default:
695 ERROR("BUG: unknown JTAG command type encountered");
696 exit(-1);
697 }
698 cmd = cmd->next;
699 }
700
701 if (require_send > 0)
702 ftd2xx_send_and_recv(first_unsent, cmd);
703
704 return ERROR_OK;
705 }
706
707 int ftd2xx_init(void)
708 {
709 u8 latency_timer;
710 FT_STATUS status;
711 DWORD num_devices;
712
713 ftd2xx_layout_t *cur_layout = ftd2xx_layouts;
714
715 if ((ftd2xx_layout == NULL) || (ftd2xx_layout[0] == 0))
716 {
717 ftd2xx_layout = "usbjtag";
718 WARNING("No ftd2xx layout specified, using default 'usbjtag'");
719 }
720
721 while (cur_layout->name)
722 {
723 if (strcmp(cur_layout->name, ftd2xx_layout) == 0)
724 {
725 layout = cur_layout;
726 break;
727 }
728 cur_layout++;
729 }
730
731 if (!layout)
732 {
733 ERROR("No matching layout found for %s", ftd2xx_layout);
734 return ERROR_JTAG_INIT_FAILED;
735 }
736
737 if (ftd2xx_device_desc == NULL)
738 {
739 WARNING("no ftd2xx device description specified, using default 'Dual RS232'");
740 ftd2xx_device_desc = "Dual RS232";
741 }
742
743 #if IS_CYGWIN != 1
744 /* Add JTAGkey Vid/Pid to the linux driver */
745 if ((status = FT_SetVIDPID(ftd2xx_vid, ftd2xx_pid)) != FT_OK)
746 {
747 WARNING("couldn't add %4.4x:%4.4x", ftd2xx_vid, ftd2xx_pid);
748 }
749 #endif
750
751 if ((status = FT_OpenEx(ftd2xx_device_desc, FT_OPEN_BY_DESCRIPTION, &ftdih)) != FT_OK)
752 {
753 ERROR("unable to open ftdi device: %i", status);
754 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
755 if (status == FT_OK)
756 {
757 char **desc_array = malloc(sizeof(char*) * (num_devices + 1));
758 int i;
759
760 for (i = 0; i < num_devices; i++)
761 desc_array[i] = malloc(64);
762 desc_array[num_devices] = NULL;
763
764 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | FT_OPEN_BY_DESCRIPTION);
765
766 if (status == FT_OK)
767 {
768 ERROR("ListDevices: %d\n", num_devices);
769 for (i = 0; i < num_devices; i++)
770 ERROR("%i: %s", i, desc_array[i]);
771 }
772
773 for (i = 0; i < num_devices; i++)
774 free(desc_array[i]);
775 free(desc_array);
776 }
777 else
778 {
779 printf("ListDevices: NONE\n");
780 }
781 return ERROR_JTAG_INIT_FAILED;
782 }
783
784 if ((status = FT_SetLatencyTimer(ftdih, 2)) != FT_OK)
785 {
786 ERROR("unable to set latency timer: %i", status);
787 return ERROR_JTAG_INIT_FAILED;
788 }
789
790 if ((status = FT_GetLatencyTimer(ftdih, &latency_timer)) != FT_OK)
791 {
792 ERROR("unable to get latency timer: %i", status);
793 return ERROR_JTAG_INIT_FAILED;
794 }
795 else
796 {
797 DEBUG("current latency timer: %i", latency_timer);
798 }
799
800 if ((status = FT_SetBitMode(ftdih, 0x0b, 2)) != FT_OK)
801 {
802 ERROR("unable to enable bit i/o mode: %i", status);
803 return ERROR_JTAG_INIT_FAILED;
804 }
805
806 ftd2xx_buffer_size = 0;
807 ftd2xx_buffer = malloc(FTD2XX_BUFFER_SIZE);
808
809 if (layout->init() != ERROR_OK)
810 return ERROR_JTAG_INIT_FAILED;
811
812 ftd2xx_speed(jtag_speed);
813
814 if ((status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX)) != FT_OK)
815 {
816 ERROR("error purging ftd2xx device: %i", status);
817 return ERROR_JTAG_INIT_FAILED;
818 }
819
820 return ERROR_OK;
821 }
822
823 int usbjtag_init(void)
824 {
825 u8 buf[3];
826 FT_STATUS status;
827 DWORD bytes_written;
828
829 low_output = 0x08;
830 low_direction = 0x0b;
831
832 nTRST = 0x10;
833 nTRSTnOE = 0x10;
834 nSRST = 0x40;
835 nSRSTnOE = 0x40;
836
837 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
838 {
839 low_direction &= ~nTRSTnOE; /* nTRST input */
840 low_output &= ~nTRST; /* nTRST = 0 */
841 }
842 else
843 {
844 low_direction |= nTRSTnOE; /* nTRST output */
845 low_output |= nTRST; /* nTRST = 1 */
846 }
847
848 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
849 {
850 low_direction |= nSRSTnOE; /* nSRST output */
851 low_output |= nSRST; /* nSRST = 1 */
852 }
853 else
854 {
855 low_direction &= ~nSRSTnOE; /* nSRST input */
856 low_output &= ~nSRST; /* nSRST = 0 */
857 }
858
859 /* initialize low byte for jtag */
860 buf[0] = 0x80; /* command "set data bits low byte" */
861 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
862 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
863 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
864
865 if (((FT_Write(ftdih, buf, 3, &bytes_written)) != FT_OK) || (bytes_written != 3))
866 {
867 ERROR("couldn't write to ftdi device: %i", status);
868 return ERROR_JTAG_INIT_FAILED;
869 }
870
871 return ERROR_OK;
872 }
873
874 int jtagkey_init(void)
875 {
876 u8 buf[3];
877 FT_STATUS status;
878 DWORD bytes_written;
879
880 low_output = 0x08;
881 low_direction = 0x1b;
882
883 /* initialize low byte for jtag */
884 buf[0] = 0x80; /* command "set data bits low byte" */
885 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
886 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
887 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
888
889 if (((FT_Write(ftdih, buf, 3, &bytes_written)) != FT_OK) || (bytes_written != 3))
890 {
891 ERROR("couldn't write to ftdi device: %i", status);
892 return ERROR_JTAG_INIT_FAILED;
893 }
894
895 if (strcmp(layout->name, "jtagkey") == 0)
896 {
897 nTRST = 0x01;
898 nTRSTnOE = 0x4;
899 nSRST = 0x02;
900 nSRSTnOE = 0x08;
901 }
902 else if (strcmp(layout->name, "jtagkey_prototype_v1") == 0)
903 {
904 nTRST = 0x02;
905 nTRSTnOE = 0x1;
906 nSRST = 0x08;
907 nSRSTnOE = 0x04;
908 }
909 else
910 {
911 ERROR("BUG: jtagkey_init called for non jtagkey layout");
912 exit(-1);
913 }
914
915 high_output = 0x0;
916 high_direction = 0x0f;
917
918 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
919 {
920 high_output |= nTRSTnOE;
921 high_output &= ~nTRST;
922 }
923 else
924 {
925 high_output &= ~nTRSTnOE;
926 high_output |= nTRST;
927 }
928
929 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
930 {
931 high_output &= ~nSRSTnOE;
932 high_output |= nSRST;
933 }
934 else
935 {
936 high_output |= nSRSTnOE;
937 high_output &= ~nSRST;
938 }
939
940 /* initialize high port */
941 buf[0] = 0x82; /* command "set data bits low byte" */
942 buf[1] = high_output; /* value */
943 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
944 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
945
946 if (((FT_Write(ftdih, buf, 3, &bytes_written)) != FT_OK) || (bytes_written != 3))
947 {
948 ERROR("couldn't write to ftdi device: %i", status);
949 return ERROR_JTAG_INIT_FAILED;
950 }
951
952 return ERROR_OK;
953 }
954
955 int ftd2xx_quit(void)
956 {
957 FT_STATUS status;
958
959 status = FT_Close(ftdih);
960
961 free(ftd2xx_buffer);
962
963 return ERROR_OK;
964 }
965
966 int ftd2xx_handle_device_desc_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
967 {
968 if (argc == 1)
969 {
970 ftd2xx_device_desc = strdup(args[0]);
971 }
972 else
973 {
974 ERROR("expected exactly one argument to ftd2xx_device_desc <description>");
975 }
976
977 return ERROR_OK;
978 }
979
980 int ftd2xx_handle_layout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
981 {
982 if (argc == 0)
983 return ERROR_OK;
984
985 ftd2xx_layout = malloc(strlen(args[0]));
986 strcpy(ftd2xx_layout, args[0]);
987
988 return ERROR_OK;
989 }
990
991 int ftd2xx_handle_vid_pid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
992 {
993 if (argc >= 2)
994 {
995 ftd2xx_vid = strtol(args[0], NULL, 0);
996 ftd2xx_pid = strtol(args[1], NULL, 0);
997 }
998 else
999 {
1000 WARNING("incomplete ftd2xx_vid_pid configuration directive");
1001 }
1002
1003 return ERROR_OK;
1004 }
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)