?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target/xtensa: avoid IHI for writes to non-executable memory
[openocd.git] / src / jtag / drivers / ft232r.c
blob766f6ddb5d84f76e1eeb9d84fc1c43926021c2b1
1 // SPDX-License-Identifier: GPL-2.0-or-later
2
3 /***************************************************************************
4 * Copyright (C) 2010 Serge Vakulenko *
5 * serge@vak.ru *
6 ***************************************************************************/
7
8 #ifdef HAVE_CONFIG_H
9 #include "config.h"
10 #endif
11
12 #if IS_CYGWIN == 1
13 #include "windows.h"
14 #undef LOG_ERROR
15 #endif
16
17 /* project specific includes */
18 #include <jtag/adapter.h>
19 #include <jtag/interface.h>
20 #include <jtag/commands.h>
21 #include <helper/time_support.h>
22 #include "libusb_helper.h"
23
24 /* system includes */
25 #include <string.h>
26 #include <stdlib.h>
27 #include <unistd.h>
28 #include <sys/time.h>
29 #include <time.h>
30
31 /*
32 * Sync bit bang mode is implemented as described in FTDI Application
33 * Note AN232R-01: "Bit Bang Modes for the FT232R and FT245R".
34 */
35
36 /*
37 * USB endpoints.
38 */
39 #define IN_EP 0x02
40 #define OUT_EP 0x81
41
42 /* Requests */
43 #define SIO_RESET 0 /* Reset the port */
44 #define SIO_MODEM_CTRL 1 /* Set the modem control register */
45 #define SIO_SET_FLOW_CTRL 2 /* Set flow control register */
46 #define SIO_SET_BAUD_RATE 3 /* Set baud rate */
47 #define SIO_SET_DATA 4 /* Set the data characteristics of the port */
48 #define SIO_POLL_MODEM_STATUS 5
49 #define SIO_SET_EVENT_CHAR 6
50 #define SIO_SET_ERROR_CHAR 7
51 #define SIO_SET_LATENCY_TIMER 9
52 #define SIO_GET_LATENCY_TIMER 10
53 #define SIO_SET_BITMODE 11
54 #define SIO_READ_PINS 12
55 #define SIO_READ_EEPROM 0x90
56 #define SIO_WRITE_EEPROM 0x91
57 #define SIO_ERASE_EEPROM 0x92
58
59 #define FT232R_BUF_SIZE_EXTRA 4096
60
61 static uint16_t ft232r_vid = 0x0403; /* FTDI */
62 static uint16_t ft232r_pid = 0x6001; /* FT232R */
63 static struct libusb_device_handle *adapter;
64
65 static uint8_t *ft232r_output;
66 static size_t ft232r_output_len;
67
68 /**
69 * FT232R GPIO bit number to RS232 name
70 */
71 #define FT232R_BIT_COUNT 8
72 static char *ft232r_bit_name_array[FT232R_BIT_COUNT] = {
73 "TXD", /* 0: pin 1 TCK output */
74 "RXD", /* 1: pin 5 TDI output */
75 "RTS", /* 2: pin 3 TDO input */
76 "CTS", /* 3: pin 11 TMS output */
77 "DTR", /* 4: pin 2 /TRST output */
78 "DSR", /* 5: pin 9 unused */
79 "DCD", /* 6: pin 10 /SYSRST output */
80 "RI" /* 7: pin 6 unused */
81 };
82
83 static int tck_gpio; /* initialized to 0 by default */
84 static int tdi_gpio = 1;
85 static int tdo_gpio = 2;
86 static int tms_gpio = 3;
87 static int ntrst_gpio = 4;
88 static int nsysrst_gpio = 6;
89 static size_t ft232r_buf_size = FT232R_BUF_SIZE_EXTRA;
90 /** 0xFFFF disables restore by default, after exit serial port will not work.
91 * 0x15 sets TXD RTS DTR as outputs, after exit serial port will continue to work.
92 */
93 static uint16_t ft232r_restore_bitmode = 0xFFFF;
94
95 /**
96 * Perform sync bitbang output/input transaction.
97 * Before call, an array ft232r_output[] should be filled with data to send.
98 * Counter ft232r_output_len contains the number of bytes to send.
99 * On return, received data is put back to array ft232r_output[].
100 */
101 static int ft232r_send_recv(void)
102 {
103 /* FIFO TX buffer has 128 bytes.
104 * FIFO RX buffer has 256 bytes.
105 * First two bytes of received packet contain contain modem
106 * and line status and are ignored.
107 * Unfortunately, transfer sizes bigger than 64 bytes
108 * frequently cause hang ups. */
109 assert(ft232r_output_len > 0);
110
111 size_t total_written = 0;
112 size_t total_read = 0;
113 int rxfifo_free = 128;
114
115 while (total_read < ft232r_output_len) {
116 /* Write */
117 int bytes_to_write = ft232r_output_len - total_written;
118 if (bytes_to_write > 64)
119 bytes_to_write = 64;
120 if (bytes_to_write > rxfifo_free)
121 bytes_to_write = rxfifo_free;
122
123 if (bytes_to_write) {
124 int n;
125
126 if (jtag_libusb_bulk_write(adapter, IN_EP,
127 (char *) ft232r_output + total_written,
128 bytes_to_write, 1000, &n) != ERROR_OK) {
129 LOG_ERROR("usb bulk write failed");
130 return ERROR_JTAG_DEVICE_ERROR;
131 }
132
133 total_written += n;
134 rxfifo_free -= n;
135 }
136
137 /* Read */
138 uint8_t reply[64];
139 int n;
140
141 if (jtag_libusb_bulk_read(adapter, OUT_EP, (char *) reply,
142 sizeof(reply), 1000, &n) != ERROR_OK) {
143 LOG_ERROR("usb bulk read failed");
144 return ERROR_JTAG_DEVICE_ERROR;
145 }
146 if (n > 2) {
147 /* Copy data, ignoring first 2 bytes. */
148 memcpy(ft232r_output + total_read, reply + 2, n - 2);
149 int bytes_read = n - 2;
150 total_read += bytes_read;
151 rxfifo_free += bytes_read;
152 if (total_read > total_written) {
153 LOG_ERROR("read more bytes than wrote");
154 return ERROR_JTAG_DEVICE_ERROR;
155 }
156 }
157 }
158 ft232r_output_len = 0;
159 return ERROR_OK;
160 }
161
162 static void ft232r_increase_buf_size(size_t new_buf_size)
163 {
164 uint8_t *new_buf_ptr;
165 if (new_buf_size >= ft232r_buf_size) {
166 new_buf_size += FT232R_BUF_SIZE_EXTRA;
167 new_buf_ptr = realloc(ft232r_output, new_buf_size);
168 if (new_buf_ptr) {
169 ft232r_output = new_buf_ptr;
170 ft232r_buf_size = new_buf_size;
171 }
172 }
173 }
174
175 /**
176 * Add one TCK/TMS/TDI sample to send buffer.
177 */
178 static void ft232r_write(int tck, int tms, int tdi)
179 {
180 unsigned out_value = (1<<ntrst_gpio) | (1<<nsysrst_gpio);
181 if (tck)
182 out_value |= (1<<tck_gpio);
183 if (tms)
184 out_value |= (1<<tms_gpio);
185 if (tdi)
186 out_value |= (1<<tdi_gpio);
187
188 ft232r_increase_buf_size(ft232r_output_len);
189
190 if (ft232r_output_len >= ft232r_buf_size) {
191 /* FIXME: should we just execute queue here? */
192 LOG_ERROR("ft232r_write: buffer overflow");
193 return;
194 }
195 ft232r_output[ft232r_output_len++] = out_value;
196 }
197
198 /**
199 * Control /TRST and /SYSRST pins.
200 * Perform immediate bitbang transaction.
201 */
202 static void ft232r_reset(int trst, int srst)
203 {
204 unsigned out_value = (1<<ntrst_gpio) | (1<<nsysrst_gpio);
205 LOG_DEBUG("ft232r_reset(%d,%d)", trst, srst);
206
207 if (trst == 1)
208 out_value &= ~(1<<ntrst_gpio); /* switch /TRST low */
209 else if (trst == 0)
210 out_value |= (1<<ntrst_gpio); /* switch /TRST high */
211
212 if (srst == 1)
213 out_value &= ~(1<<nsysrst_gpio); /* switch /SYSRST low */
214 else if (srst == 0)
215 out_value |= (1<<nsysrst_gpio); /* switch /SYSRST high */
216
217 ft232r_increase_buf_size(ft232r_output_len);
218
219 if (ft232r_output_len >= ft232r_buf_size) {
220 /* FIXME: should we just execute queue here? */
221 LOG_ERROR("ft232r_write: buffer overflow");
222 return;
223 }
224
225 ft232r_output[ft232r_output_len++] = out_value;
226 ft232r_send_recv();
227 }
228
229 static int ft232r_speed(int divisor)
230 {
231 int baud = (divisor == 0) ? 3000000 :
232 (divisor == 1) ? 2000000 :
233 3000000 / divisor;
234 LOG_DEBUG("ft232r_speed(%d) rate %d bits/sec", divisor, baud);
235
236 if (jtag_libusb_control_transfer(adapter,
237 LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT,
238 SIO_SET_BAUD_RATE, divisor, 0, NULL, 0, 1000, NULL) != ERROR_OK) {
239 LOG_ERROR("cannot set baud rate");
240 return ERROR_JTAG_DEVICE_ERROR;
241 }
242 return ERROR_OK;
243 }
244
245 static int ft232r_init(void)
246 {
247 uint16_t avids[] = {ft232r_vid, 0};
248 uint16_t apids[] = {ft232r_pid, 0};
249 if (jtag_libusb_open(avids, apids, NULL, &adapter, NULL)) {
250 const char *ft232r_serial_desc = adapter_get_required_serial();
251 LOG_ERROR("ft232r not found: vid=%04x, pid=%04x, serial=%s\n",
252 ft232r_vid, ft232r_pid, (!ft232r_serial_desc) ? "[any]" : ft232r_serial_desc);
253 return ERROR_JTAG_INIT_FAILED;
254 }
255
256 if (ft232r_restore_bitmode == 0xFFFF) /* serial port will not be restored after jtag: */
257 libusb_detach_kernel_driver(adapter, 0);
258 else /* serial port will be restored after jtag: */
259 libusb_set_auto_detach_kernel_driver(adapter, 1); /* 1: DONT_DETACH_SIO_MODULE */
260
261 if (libusb_claim_interface(adapter, 0)) {
262 LOG_ERROR("unable to claim interface");
263 return ERROR_JTAG_INIT_FAILED;
264 }
265
266 /* Reset the device. */
267 if (jtag_libusb_control_transfer(adapter,
268 LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT,
269 SIO_RESET, 0, 0, NULL, 0, 1000, NULL) != ERROR_OK) {
270 LOG_ERROR("unable to reset device");
271 return ERROR_JTAG_INIT_FAILED;
272 }
273
274 /* Sync bit bang mode. */
275 if (jtag_libusb_control_transfer(adapter,
276 LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT,
277 SIO_SET_BITMODE, (1<<tck_gpio) | (1<<tdi_gpio) | (1<<tms_gpio) | (1<<ntrst_gpio) | (1<<nsysrst_gpio) | 0x400,
278 0, NULL, 0, 1000, NULL) != ERROR_OK) {
279 LOG_ERROR("cannot set sync bitbang mode");
280 return ERROR_JTAG_INIT_FAILED;
281 }
282
283 /* Exactly 500 nsec between updates. */
284 unsigned divisor = 1;
285 unsigned char latency_timer = 1;
286
287 /* Frequency divisor is 14-bit non-zero value. */
288 if (jtag_libusb_control_transfer(adapter,
289 LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT,
290 SIO_SET_BAUD_RATE, divisor,
291 0, NULL, 0, 1000, NULL) != ERROR_OK) {
292 LOG_ERROR("cannot set baud rate");
293 return ERROR_JTAG_INIT_FAILED;
294 }
295 if (jtag_libusb_control_transfer(adapter,
296 LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT,
297 SIO_SET_LATENCY_TIMER, latency_timer, 0, NULL, 0, 1000, NULL) != ERROR_OK) {
298 LOG_ERROR("unable to set latency timer");
299 return ERROR_JTAG_INIT_FAILED;
300 }
301
302 ft232r_output = malloc(ft232r_buf_size);
303 if (!ft232r_output) {
304 LOG_ERROR("Unable to allocate memory for the buffer");
305 return ERROR_JTAG_INIT_FAILED;
306 }
307
308 return ERROR_OK;
309 }
310
311 static int ft232r_quit(void)
312 {
313 /* to restore serial port: set TXD RTS DTR as outputs, others as inputs, disable sync bit bang mode. */
314 if (ft232r_restore_bitmode != 0xFFFF) {
315 if (jtag_libusb_control_transfer(adapter,
316 LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT,
317 SIO_SET_BITMODE, ft232r_restore_bitmode,
318 0, NULL, 0, 1000, NULL) != ERROR_OK) {
319 LOG_ERROR("cannot set bitmode to restore serial port");
320 }
321 }
322
323 if (libusb_release_interface(adapter, 0) != 0)
324 LOG_ERROR("usb release interface failed");
325
326 jtag_libusb_close(adapter);
327
328 free(ft232r_output); /* free used memory */
329 ft232r_output = NULL; /* reset pointer to memory */
330 ft232r_buf_size = FT232R_BUF_SIZE_EXTRA; /* reset next initial buffer size */
331
332 return ERROR_OK;
333 }
334
335 static int ft232r_speed_div(int divisor, int *khz)
336 {
337 /* Maximum 3 Mbaud for bit bang mode. */
338 if (divisor == 0)
339 *khz = 3000;
340 else if (divisor == 1)
341 *khz = 2000;
342 else
343 *khz = 3000 / divisor;
344 return ERROR_OK;
345 }
346
347 static int ft232r_khz(int khz, int *divisor)
348 {
349 if (khz == 0) {
350 LOG_DEBUG("RCLK not supported");
351 return ERROR_FAIL;
352 }
353
354 /* Calculate frequency divisor. */
355 if (khz > 2500)
356 *divisor = 0; /* Special case: 3 MHz */
357 else if (khz > 1700)
358 *divisor = 1; /* Special case: 2 MHz */
359 else {
360 *divisor = (2*3000 / khz + 1) / 2;
361 if (*divisor > 0x3FFF)
362 *divisor = 0x3FFF;
363 }
364 return ERROR_OK;
365 }
366
367 static char *ft232r_bit_number_to_name(int bit)
368 {
369 if (bit >= 0 && bit < FT232R_BIT_COUNT)
370 return ft232r_bit_name_array[bit];
371 return "?";
372 }
373
374 static int ft232r_bit_name_to_number(const char *name)
375 {
376 int i;
377 if (name[0] >= '0' && name[0] <= '9' && name[1] == '\0') {
378 i = atoi(name);
379 if (i >= 0 && i < FT232R_BIT_COUNT)
380 return i;
381 }
382 for (i = 0; i < FT232R_BIT_COUNT; i++)
383 if (strcasecmp(name, ft232r_bit_name_array[i]) == 0)
384 return i;
385 return -1;
386 }
387
388 COMMAND_HANDLER(ft232r_handle_vid_pid_command)
389 {
390 if (CMD_ARGC > 2) {
391 LOG_WARNING("ignoring extra IDs in ft232r_vid_pid "
392 "(maximum is 1 pair)");
393 CMD_ARGC = 2;
394 }
395 if (CMD_ARGC == 2) {
396 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], ft232r_vid);
397 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[1], ft232r_pid);
398 } else
399 LOG_WARNING("incomplete ft232r_vid_pid configuration");
400
401 return ERROR_OK;
402 }
403
404 COMMAND_HANDLER(ft232r_handle_jtag_nums_command)
405 {
406 if (CMD_ARGC == 4) {
407 tck_gpio = ft232r_bit_name_to_number(CMD_ARGV[0]);
408 tms_gpio = ft232r_bit_name_to_number(CMD_ARGV[1]);
409 tdi_gpio = ft232r_bit_name_to_number(CMD_ARGV[2]);
410 tdo_gpio = ft232r_bit_name_to_number(CMD_ARGV[3]);
411 } else if (CMD_ARGC != 0)
412 return ERROR_COMMAND_SYNTAX_ERROR;
413
414 if (tck_gpio < 0)
415 return ERROR_COMMAND_SYNTAX_ERROR;
416 if (tms_gpio < 0)
417 return ERROR_COMMAND_SYNTAX_ERROR;
418 if (tdi_gpio < 0)
419 return ERROR_COMMAND_SYNTAX_ERROR;
420 if (tdo_gpio < 0)
421 return ERROR_COMMAND_SYNTAX_ERROR;
422
423 command_print(CMD,
424 "FT232R nums: TCK = %d %s, TMS = %d %s, TDI = %d %s, TDO = %d %s",
425 tck_gpio, ft232r_bit_number_to_name(tck_gpio),
426 tms_gpio, ft232r_bit_number_to_name(tms_gpio),
427 tdi_gpio, ft232r_bit_number_to_name(tdi_gpio),
428 tdo_gpio, ft232r_bit_number_to_name(tdo_gpio));
429
430 return ERROR_OK;
431 }
432
433 COMMAND_HANDLER(ft232r_handle_tck_num_command)
434 {
435 if (CMD_ARGC == 1)
436 tck_gpio = ft232r_bit_name_to_number(CMD_ARGV[0]);
437 else if (CMD_ARGC != 0)
438 return ERROR_COMMAND_SYNTAX_ERROR;
439
440 if (tck_gpio < 0)
441 return ERROR_COMMAND_SYNTAX_ERROR;
442
443 command_print(CMD,
444 "FT232R num: TCK = %d %s", tck_gpio, ft232r_bit_number_to_name(tck_gpio));
445
446 return ERROR_OK;
447 }
448
449 COMMAND_HANDLER(ft232r_handle_tms_num_command)
450 {
451 if (CMD_ARGC == 1)
452 tms_gpio = ft232r_bit_name_to_number(CMD_ARGV[0]);
453 else if (CMD_ARGC != 0)
454 return ERROR_COMMAND_SYNTAX_ERROR;
455
456 if (tms_gpio < 0)
457 return ERROR_COMMAND_SYNTAX_ERROR;
458
459 command_print(CMD,
460 "FT232R num: TMS = %d %s", tms_gpio, ft232r_bit_number_to_name(tms_gpio));
461
462 return ERROR_OK;
463 }
464
465 COMMAND_HANDLER(ft232r_handle_tdo_num_command)
466 {
467 if (CMD_ARGC == 1)
468 tdo_gpio = ft232r_bit_name_to_number(CMD_ARGV[0]);
469 else if (CMD_ARGC != 0)
470 return ERROR_COMMAND_SYNTAX_ERROR;
471
472 if (tdo_gpio < 0)
473 return ERROR_COMMAND_SYNTAX_ERROR;
474
475 command_print(CMD,
476 "FT232R num: TDO = %d %s", tdo_gpio, ft232r_bit_number_to_name(tdo_gpio));
477
478 return ERROR_OK;
479 }
480
481 COMMAND_HANDLER(ft232r_handle_tdi_num_command)
482 {
483 if (CMD_ARGC == 1)
484 tdi_gpio = ft232r_bit_name_to_number(CMD_ARGV[0]);
485 else if (CMD_ARGC != 0)
486 return ERROR_COMMAND_SYNTAX_ERROR;
487
488 if (tdi_gpio < 0)
489 return ERROR_COMMAND_SYNTAX_ERROR;
490
491 command_print(CMD,
492 "FT232R num: TDI = %d %s", tdi_gpio, ft232r_bit_number_to_name(tdi_gpio));
493
494 return ERROR_OK;
495 }
496
497 COMMAND_HANDLER(ft232r_handle_trst_num_command)
498 {
499 if (CMD_ARGC == 1)
500 ntrst_gpio = ft232r_bit_name_to_number(CMD_ARGV[0]);
501 else if (CMD_ARGC != 0)
502 return ERROR_COMMAND_SYNTAX_ERROR;
503
504 if (ntrst_gpio < 0)
505 return ERROR_COMMAND_SYNTAX_ERROR;
506
507 command_print(CMD,
508 "FT232R num: TRST = %d %s", ntrst_gpio, ft232r_bit_number_to_name(ntrst_gpio));
509
510 return ERROR_OK;
511 }
512
513 COMMAND_HANDLER(ft232r_handle_srst_num_command)
514 {
515 if (CMD_ARGC == 1)
516 nsysrst_gpio = ft232r_bit_name_to_number(CMD_ARGV[0]);
517 else if (CMD_ARGC != 0)
518 return ERROR_COMMAND_SYNTAX_ERROR;
519
520 if (nsysrst_gpio < 0)
521 return ERROR_COMMAND_SYNTAX_ERROR;
522
523 command_print(CMD,
524 "FT232R num: SRST = %d %s", nsysrst_gpio, ft232r_bit_number_to_name(nsysrst_gpio));
525
526 return ERROR_OK;
527 }
528
529 COMMAND_HANDLER(ft232r_handle_restore_serial_command)
530 {
531 if (CMD_ARGC == 1)
532 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], ft232r_restore_bitmode);
533 else if (CMD_ARGC != 0)
534 return ERROR_COMMAND_SYNTAX_ERROR;
535
536 command_print(CMD,
537 "FT232R restore serial: 0x%04X (%s)",
538 ft232r_restore_bitmode, ft232r_restore_bitmode == 0xFFFF ? "disabled" : "enabled");
539
540 return ERROR_OK;
541 }
542
543 static const struct command_registration ft232r_subcommand_handlers[] = {
544 {
545 .name = "vid_pid",
546 .handler = ft232r_handle_vid_pid_command,
547 .mode = COMMAND_CONFIG,
548 .help = "USB VID and PID of the adapter",
549 .usage = "vid pid",
550 },
551 {
552 .name = "jtag_nums",
553 .handler = ft232r_handle_jtag_nums_command,
554 .mode = COMMAND_CONFIG,
555 .help = "gpio numbers for tck, tms, tdi, tdo. (in that order)",
556 .usage = "<0-7|TXD-RI> <0-7|TXD-RI> <0-7|TXD-RI> <0-7|TXD-RI>",
557 },
558 {
559 .name = "tck_num",
560 .handler = ft232r_handle_tck_num_command,
561 .mode = COMMAND_CONFIG,
562 .help = "gpio number for tck.",
563 .usage = "<0-7|TXD|RXD|RTS|CTS|DTR|DSR|DCD|RI>",
564 },
565 {
566 .name = "tms_num",
567 .handler = ft232r_handle_tms_num_command,
568 .mode = COMMAND_CONFIG,
569 .help = "gpio number for tms.",
570 .usage = "<0-7|TXD|RXD|RTS|CTS|DTR|DSR|DCD|RI>",
571 },
572 {
573 .name = "tdo_num",
574 .handler = ft232r_handle_tdo_num_command,
575 .mode = COMMAND_CONFIG,
576 .help = "gpio number for tdo.",
577 .usage = "<0-7|TXD|RXD|RTS|CTS|DTR|DSR|DCD|RI>",
578 },
579 {
580 .name = "tdi_num",
581 .handler = ft232r_handle_tdi_num_command,
582 .mode = COMMAND_CONFIG,
583 .help = "gpio number for tdi.",
584 .usage = "<0-7|TXD|RXD|RTS|CTS|DTR|DSR|DCD|RI>",
585 },
586 {
587 .name = "srst_num",
588 .handler = ft232r_handle_srst_num_command,
589 .mode = COMMAND_CONFIG,
590 .help = "gpio number for srst.",
591 .usage = "<0-7|TXD|RXD|RTS|CTS|DTR|DSR|DCD|RI>",
592 },
593 {
594 .name = "trst_num",
595 .handler = ft232r_handle_trst_num_command,
596 .mode = COMMAND_CONFIG,
597 .help = "gpio number for trst.",
598 .usage = "<0-7|TXD|RXD|RTS|CTS|DTR|DSR|DCD|RI>",
599 },
600 {
601 .name = "restore_serial",
602 .handler = ft232r_handle_restore_serial_command,
603 .mode = COMMAND_CONFIG,
604 .help = "bitmode control word that restores serial port.",
605 .usage = "bitmode_control_word",
606 },
607 COMMAND_REGISTRATION_DONE
608 };
609
610 static const struct command_registration ft232r_command_handlers[] = {
611 {
612 .name = "ft232r",
613 .mode = COMMAND_ANY,
614 .help = "perform ft232r management",
615 .chain = ft232r_subcommand_handlers,
616 .usage = "",
617 },
618 COMMAND_REGISTRATION_DONE
619 };
620
621 /*
622 * Synchronous bitbang protocol implementation.
623 */
624
625 static void syncbb_end_state(tap_state_t state)
626 {
627 if (tap_is_state_stable(state))
628 tap_set_end_state(state);
629 else {
630 LOG_ERROR("BUG: %i is not a valid end state", state);
631 exit(-1);
632 }
633 }
634
635 static void syncbb_state_move(int skip)
636 {
637 int i = 0, tms = 0;
638 uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
639 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
640
641 for (i = skip; i < tms_count; i++) {
642 tms = (tms_scan >> i) & 1;
643 ft232r_write(0, tms, 0);
644 ft232r_write(1, tms, 0);
645 }
646 ft232r_write(0, tms, 0);
647
648 tap_set_state(tap_get_end_state());
649 }
650
651 /**
652 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
653 * (or SWD) state machine.
654 */
655 static int syncbb_execute_tms(struct jtag_command *cmd)
656 {
657 unsigned num_bits = cmd->cmd.tms->num_bits;
658 const uint8_t *bits = cmd->cmd.tms->bits;
659
660 LOG_DEBUG_IO("TMS: %d bits", num_bits);
661
662 int tms = 0;
663 for (unsigned i = 0; i < num_bits; i++) {
664 tms = ((bits[i/8] >> (i % 8)) & 1);
665 ft232r_write(0, tms, 0);
666 ft232r_write(1, tms, 0);
667 }
668 ft232r_write(0, tms, 0);
669
670 return ERROR_OK;
671 }
672
673 static void syncbb_path_move(struct pathmove_command *cmd)
674 {
675 int num_states = cmd->num_states;
676 int state_count;
677 int tms = 0;
678
679 state_count = 0;
680 while (num_states) {
681 if (tap_state_transition(tap_get_state(), false) == cmd->path[state_count]) {
682 tms = 0;
683 } else if (tap_state_transition(tap_get_state(), true) == cmd->path[state_count]) {
684 tms = 1;
685 } else {
686 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
687 tap_state_name(tap_get_state()),
688 tap_state_name(cmd->path[state_count]));
689 exit(-1);
690 }
691
692 ft232r_write(0, tms, 0);
693 ft232r_write(1, tms, 0);
694
695 tap_set_state(cmd->path[state_count]);
696 state_count++;
697 num_states--;
698 }
699
700 ft232r_write(0, tms, 0);
701
702 tap_set_end_state(tap_get_state());
703 }
704
705 static void syncbb_runtest(int num_cycles)
706 {
707 int i;
708
709 tap_state_t saved_end_state = tap_get_end_state();
710
711 /* only do a state_move when we're not already in IDLE */
712 if (tap_get_state() != TAP_IDLE) {
713 syncbb_end_state(TAP_IDLE);
714 syncbb_state_move(0);
715 }
716
717 /* execute num_cycles */
718 for (i = 0; i < num_cycles; i++) {
719 ft232r_write(0, 0, 0);
720 ft232r_write(1, 0, 0);
721 }
722 ft232r_write(0, 0, 0);
723
724 /* finish in end_state */
725 syncbb_end_state(saved_end_state);
726 if (tap_get_state() != tap_get_end_state())
727 syncbb_state_move(0);
728 }
729
730 /**
731 * Function syncbb_stableclocks
732 * issues a number of clock cycles while staying in a stable state.
733 * Because the TMS value required to stay in the RESET state is a 1, whereas
734 * the TMS value required to stay in any of the other stable states is a 0,
735 * this function checks the current stable state to decide on the value of TMS
736 * to use.
737 */
738 static void syncbb_stableclocks(int num_cycles)
739 {
740 int tms = (tap_get_state() == TAP_RESET ? 1 : 0);
741 int i;
742
743 /* send num_cycles clocks onto the cable */
744 for (i = 0; i < num_cycles; i++) {
745 ft232r_write(1, tms, 0);
746 ft232r_write(0, tms, 0);
747 }
748 }
749
750 static void syncbb_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size)
751 {
752 tap_state_t saved_end_state = tap_get_end_state();
753 int bit_cnt, bit0_index;
754
755 if (!((!ir_scan && (tap_get_state() == TAP_DRSHIFT)) || (ir_scan && (tap_get_state() == TAP_IRSHIFT)))) {
756 if (ir_scan)
757 syncbb_end_state(TAP_IRSHIFT);
758 else
759 syncbb_end_state(TAP_DRSHIFT);
760
761 syncbb_state_move(0);
762 syncbb_end_state(saved_end_state);
763 }
764
765 bit0_index = ft232r_output_len;
766 for (bit_cnt = 0; bit_cnt < scan_size; bit_cnt++) {
767 int tms = (bit_cnt == scan_size-1) ? 1 : 0;
768 int tdi;
769 int bytec = bit_cnt/8;
770 int bcval = 1 << (bit_cnt % 8);
771
772 /* if we're just reading the scan, but don't care about the output
773 * default to outputting 'low', this also makes valgrind traces more readable,
774 * as it removes the dependency on an uninitialised value
775 */
776 tdi = 0;
777 if ((type != SCAN_IN) && (buffer[bytec] & bcval))
778 tdi = 1;
779
780 ft232r_write(0, tms, tdi);
781 ft232r_write(1, tms, tdi);
782 }
783
784 if (tap_get_state() != tap_get_end_state()) {
785 /* we *KNOW* the above loop transitioned out of
786 * the shift state, so we skip the first state
787 * and move directly to the end state.
788 */
789 syncbb_state_move(1);
790 }
791 ft232r_send_recv();
792
793 if (type != SCAN_OUT)
794 for (bit_cnt = 0; bit_cnt < scan_size; bit_cnt++) {
795 int bytec = bit_cnt/8;
796 int bcval = 1 << (bit_cnt % 8);
797 int val = ft232r_output[bit0_index + bit_cnt*2 + 1];
798
799 if (val & (1<<tdo_gpio))
800 buffer[bytec] |= bcval;
801 else
802 buffer[bytec] &= ~bcval;
803 }
804 }
805
806 static int syncbb_execute_queue(struct jtag_command *cmd_queue)
807 {
808 struct jtag_command *cmd = cmd_queue; /* currently processed command */
809 int scan_size;
810 enum scan_type type;
811 uint8_t *buffer;
812 int retval;
813
814 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
815 * that wasn't handled by a caller-provided error handler
816 */
817 retval = ERROR_OK;
818
819 /* ft232r_blink(1);*/
820
821 while (cmd) {
822 switch (cmd->type) {
823 case JTAG_RESET:
824 LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
825
826 if ((cmd->cmd.reset->trst == 1) ||
827 (cmd->cmd.reset->srst &&
828 (jtag_get_reset_config() & RESET_SRST_PULLS_TRST))) {
829 tap_set_state(TAP_RESET);
830 }
831 ft232r_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
832 break;
833
834 case JTAG_RUNTEST:
835 LOG_DEBUG_IO("runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles,
836 tap_state_name(cmd->cmd.runtest->end_state));
837
838 syncbb_end_state(cmd->cmd.runtest->end_state);
839 syncbb_runtest(cmd->cmd.runtest->num_cycles);
840 break;
841
842 case JTAG_STABLECLOCKS:
843 /* this is only allowed while in a stable state. A check for a stable
844 * state was done in jtag_add_clocks()
845 */
846 syncbb_stableclocks(cmd->cmd.stableclocks->num_cycles);
847 break;
848
849 case JTAG_TLR_RESET: /* renamed from JTAG_STATEMOVE */
850 LOG_DEBUG_IO("statemove end in %s", tap_state_name(cmd->cmd.statemove->end_state));
851
852 syncbb_end_state(cmd->cmd.statemove->end_state);
853 syncbb_state_move(0);
854 break;
855
856 case JTAG_PATHMOVE:
857 LOG_DEBUG_IO("pathmove: %i states, end in %s", cmd->cmd.pathmove->num_states,
858 tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]));
859
860 syncbb_path_move(cmd->cmd.pathmove);
861 break;
862
863 case JTAG_SCAN:
864 LOG_DEBUG_IO("%s scan end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR",
865 tap_state_name(cmd->cmd.scan->end_state));
866
867 syncbb_end_state(cmd->cmd.scan->end_state);
868 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
869 type = jtag_scan_type(cmd->cmd.scan);
870 syncbb_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
871 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
872 retval = ERROR_JTAG_QUEUE_FAILED;
873 free(buffer);
874 break;
875
876 case JTAG_SLEEP:
877 LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
878
879 jtag_sleep(cmd->cmd.sleep->us);
880 break;
881
882 case JTAG_TMS:
883 retval = syncbb_execute_tms(cmd);
884 break;
885 default:
886 LOG_ERROR("BUG: unknown JTAG command type encountered");
887 exit(-1);
888 }
889 if (ft232r_output_len > 0)
890 ft232r_send_recv();
891 cmd = cmd->next;
892 }
893 /* ft232r_blink(0);*/
894
895 return retval;
896 }
897
898 static struct jtag_interface ft232r_interface = {
899 .supported = DEBUG_CAP_TMS_SEQ,
900 .execute_queue = syncbb_execute_queue,
901 };
902
903 struct adapter_driver ft232r_adapter_driver = {
904 .name = "ft232r",
905 .transports = jtag_only,
906 .commands = ft232r_command_handlers,
907
908 .init = ft232r_init,
909 .quit = ft232r_quit,
910 .speed = ft232r_speed,
911 .khz = ft232r_khz,
912 .speed_div = ft232r_speed_div,
913
914 .jtag_ops = &ft232r_interface,
915 };
Official OpenOCD Mirror