Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
jtag/drivers/bitbang: use LOG_CUSTOM_LEVEL() macro for SWD
[openocd.git] / src / jtag / drivers / openjtag.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2
3 /*******************************************************************************
4 * Driver for OpenJTAG Project (www.openjtag.org) *
5 * Compatible with libftdi drivers. *
6 * *
7 * Cypress CY7C65215 support *
8 * Copyright (C) 2015 Vianney le Clément de Saint-Marcq, Essensium NV *
9 * <vianney.leclement@essensium.com> *
10 * *
11 * Copyright (C) 2010 by Ivan Meleca <mileca@gmail.com> *
12 * *
13 * Copyright (C) 2013 by Ryan Corbin, GlueLogix Inc. <corbin.ryan@gmail.com> *
14 * Updated to work with OpenOCD v0.7.0. Fixed libftdi read speed issue. *
15 * *
16 * Based on usb_blaster.c *
17 * Copyright (C) 2009 Catalin Patulea *
18 * Copyright (C) 2006 Kolja Waschk *
19 * *
20 * And jlink.c *
21 * Copyright (C) 2008 by Spencer Oliver *
22 * spen@spen-soft.co.uk *
23 ***************************************************************************/
24
25 /***************************************************************************
26 * Version 1.0 Tested on a MCBSTM32 board using a Cortex-M3 (stm32f103x), *
27 * GDB and Eclipse under Linux (Ubuntu 10.04) *
28 * *
29 ***************************************************************************/
30
31 #ifdef HAVE_CONFIG_H
32 #include "config.h"
33 #endif
34
35 #include <jtag/interface.h>
36 #include <jtag/commands.h>
37 #include "libusb_helper.h"
38
39 static enum {
40 OPENJTAG_VARIANT_STANDARD,
41 OPENJTAG_VARIANT_CY7C65215,
42 } openjtag_variant = OPENJTAG_VARIANT_STANDARD;
43
44 static const char * const openjtag_variant_names[] = {
45 "standard",
46 "cy7c65215",
47 NULL
48 };
49
50 /*
51 * OpenJTAG-OpenOCD state conversion
52 */
53 typedef enum openjtag_tap_state {
54 OPENJTAG_TAP_INVALID = -1,
55 OPENJTAG_TAP_RESET = 0,
56 OPENJTAG_TAP_IDLE = 1,
57 OPENJTAG_TAP_SELECT_DR = 2,
58 OPENJTAG_TAP_CAPTURE_DR = 3,
59 OPENJTAG_TAP_SHIFT_DR = 4,
60 OPENJTAG_TAP_EXIT1_DR = 5,
61 OPENJTAG_TAP_PAUSE_DR = 6,
62 OPENJTAG_TAP_EXIT2_DR = 7,
63 OPENJTAG_TAP_UPDATE_DR = 8,
64 OPENJTAG_TAP_SELECT_IR = 9,
65 OPENJTAG_TAP_CAPURE_IR = 10,
66 OPENJTAG_TAP_SHIFT_IR = 11,
67 OPENJTAG_TAP_EXIT1_IR = 12,
68 OPENJTAG_TAP_PAUSE_IR = 13,
69 OPENJTAG_TAP_EXIT2_IR = 14,
70 OPENJTAG_TAP_UPDATE_IR = 15,
71 } openjtag_tap_state_t;
72
73 /* OPENJTAG access library includes */
74 #include "libftdi_helper.h"
75
76 /* OpenJTAG vid/pid */
77 static uint16_t openjtag_vid = 0x0403;
78 static uint16_t openjtag_pid = 0x6001;
79
80 static char *openjtag_device_desc;
81
82 static struct ftdi_context ftdic;
83
84 #define OPENJTAG_BUFFER_SIZE 504
85 #define OPENJTAG_MAX_PENDING_RESULTS 256
86
87 struct openjtag_scan_result {
88 uint32_t bits; /* Length in bits*/
89 struct scan_command *command; /* Corresponding scan command */
90 uint8_t *buffer;
91 };
92
93 /* USB RX/TX buffers */
94 static int usb_tx_buf_offs;
95 static uint8_t usb_tx_buf[OPENJTAG_BUFFER_SIZE];
96 static uint32_t usb_rx_buf_len;
97 static uint8_t usb_rx_buf[OPENJTAG_BUFFER_SIZE];
98
99 /* Pending readings */
100 static struct openjtag_scan_result openjtag_scan_result_buffer[OPENJTAG_MAX_PENDING_RESULTS];
101 static int openjtag_scan_result_count;
102
103 static struct libusb_device_handle *usbh;
104
105 /* CY7C65215 model only */
106 #define CY7C65215_JTAG_REQUEST 0x40 /* bmRequestType: vendor host-to-device */
107 #define CY7C65215_JTAG_ENABLE 0xD0 /* bRequest: enable JTAG */
108 #define CY7C65215_JTAG_DISABLE 0xD1 /* bRequest: disable JTAG */
109 #define CY7C65215_JTAG_READ 0xD2 /* bRequest: read buffer */
110 #define CY7C65215_JTAG_WRITE 0xD3 /* bRequest: write buffer */
111
112 #define CY7C65215_USB_TIMEOUT 100
113
114 static const uint16_t cy7c65215_vids[] = {0x04b4, 0};
115 static const uint16_t cy7c65215_pids[] = {0x0007, 0};
116
117 #define CY7C65215_JTAG_CLASS 0xff
118 #define CY7C65215_JTAG_SUBCLASS 0x04
119
120 static unsigned int ep_in, ep_out;
121
122 #ifdef _DEBUG_USB_COMMS_
123
124 #define DEBUG_TYPE_READ 0
125 #define DEBUG_TYPE_WRITE 1
126 #define DEBUG_TYPE_OCD_READ 2
127 #define DEBUG_TYPE_BUFFER 3
128
129 #define LINE_LEN 16
130 static void openjtag_debug_buffer(uint8_t *buffer, int length, uint8_t type)
131 {
132 char line[128];
133 char s[4];
134 int i;
135 int j;
136
137 switch (type) {
138 case DEBUG_TYPE_READ:
139 sprintf(line, "USB READ %d bytes", length);
140 break;
141 case DEBUG_TYPE_WRITE:
142 sprintf(line, "USB WRITE %d bytes", length);
143 break;
144 case DEBUG_TYPE_OCD_READ:
145 sprintf(line, "TO OpenOCD %d bytes", length);
146 break;
147 case DEBUG_TYPE_BUFFER:
148 sprintf(line, "Buffer %d bytes", length);
149 break;
150 }
151
152 LOG_DEBUG("%s", line);
153
154 for (i = 0; i < length; i += LINE_LEN) {
155 switch (type) {
156 case DEBUG_TYPE_READ:
157 sprintf(line, "USB READ: %04x", i);
158 break;
159 case DEBUG_TYPE_WRITE:
160 sprintf(line, "USB WRITE: %04x", i);
161 break;
162 case DEBUG_TYPE_OCD_READ:
163 sprintf(line, "TO OpenOCD: %04x", i);
164 break;
165 case DEBUG_TYPE_BUFFER:
166 sprintf(line, "BUFFER: %04x", i);
167 break;
168 }
169
170 for (j = i; j < i + LINE_LEN && j < length; j++) {
171 sprintf(s, " %02x", buffer[j]);
172 strcat(line, s);
173 }
174 LOG_DEBUG("%s", line);
175 }
176
177 }
178
179 #endif
180
181 static int8_t openjtag_get_tap_state(int8_t state)
182 {
183
184 switch (state) {
185 case TAP_DREXIT2: return OPENJTAG_TAP_EXIT2_DR;
186 case TAP_DREXIT1: return OPENJTAG_TAP_EXIT1_DR;
187 case TAP_DRSHIFT: return OPENJTAG_TAP_SHIFT_DR;
188 case TAP_DRPAUSE: return OPENJTAG_TAP_PAUSE_DR;
189 case TAP_IRSELECT: return OPENJTAG_TAP_SELECT_IR;
190 case TAP_DRUPDATE: return OPENJTAG_TAP_UPDATE_DR;
191 case TAP_DRCAPTURE: return OPENJTAG_TAP_CAPTURE_DR;
192 case TAP_DRSELECT: return OPENJTAG_TAP_SELECT_DR;
193 case TAP_IREXIT2: return OPENJTAG_TAP_EXIT2_IR;
194 case TAP_IREXIT1: return OPENJTAG_TAP_EXIT1_IR;
195 case TAP_IRSHIFT: return OPENJTAG_TAP_SHIFT_IR;
196 case TAP_IRPAUSE: return OPENJTAG_TAP_PAUSE_IR;
197 case TAP_IDLE: return OPENJTAG_TAP_IDLE;
198 case TAP_IRUPDATE: return OPENJTAG_TAP_UPDATE_IR;
199 case TAP_IRCAPTURE: return OPENJTAG_TAP_CAPURE_IR;
200 case TAP_RESET: return OPENJTAG_TAP_RESET;
201 case TAP_INVALID:
202 default: return OPENJTAG_TAP_INVALID;
203 }
204 }
205
206 static int openjtag_buf_write_standard(
207 uint8_t *buf, int size, uint32_t *bytes_written)
208 {
209 int retval;
210 #ifdef _DEBUG_USB_COMMS_
211 openjtag_debug_buffer(buf, size, DEBUG_TYPE_WRITE);
212 #endif
213
214 retval = ftdi_write_data(&ftdic, buf, size);
215 if (retval < 0) {
216 *bytes_written = 0;
217 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic));
218 return ERROR_JTAG_DEVICE_ERROR;
219 }
220
221 *bytes_written = retval;
222
223 return ERROR_OK;
224 }
225
226 static int openjtag_buf_write_cy7c65215(
227 uint8_t *buf, int size, uint32_t *bytes_written)
228 {
229 int ret;
230
231 #ifdef _DEBUG_USB_COMMS_
232 openjtag_debug_buffer(buf, size, DEBUG_TYPE_WRITE);
233 #endif
234
235 if (size == 0) {
236 *bytes_written = 0;
237 return ERROR_OK;
238 }
239
240 ret = jtag_libusb_control_transfer(usbh, CY7C65215_JTAG_REQUEST,
241 CY7C65215_JTAG_WRITE, size, 0,
242 NULL, 0, CY7C65215_USB_TIMEOUT, NULL);
243 if (ret != ERROR_OK) {
244 LOG_ERROR("vendor command failed");
245 return ret;
246 }
247
248 if (jtag_libusb_bulk_write(usbh, ep_out, (char *)buf, size,
249 CY7C65215_USB_TIMEOUT, &ret)) {
250 LOG_ERROR("bulk write failed, error");
251 return ERROR_JTAG_DEVICE_ERROR;
252 }
253 *bytes_written = ret;
254
255 return ERROR_OK;
256 }
257
258 static int openjtag_buf_write(
259 uint8_t *buf, int size, uint32_t *bytes_written)
260 {
261 switch (openjtag_variant) {
262 case OPENJTAG_VARIANT_CY7C65215:
263 return openjtag_buf_write_cy7c65215(buf, size, bytes_written);
264 default:
265 return openjtag_buf_write_standard(buf, size, bytes_written);
266 }
267 }
268
269 static int openjtag_buf_read_standard(
270 uint8_t *buf, uint32_t qty, uint32_t *bytes_read)
271 {
272
273 int retval;
274 int timeout = 5;
275
276 *bytes_read = 0;
277
278 while ((*bytes_read < qty) && timeout--) {
279 retval = ftdi_read_data(&ftdic, buf + *bytes_read,
280 qty - *bytes_read);
281 if (retval < 0) {
282 *bytes_read = 0;
283 LOG_DEBUG_IO("ftdi_read_data: %s",
284 ftdi_get_error_string(&ftdic));
285 return ERROR_JTAG_DEVICE_ERROR;
286 }
287 *bytes_read += retval;
288 }
289
290 #ifdef _DEBUG_USB_COMMS_
291 openjtag_debug_buffer(buf, *bytes_read, DEBUG_TYPE_READ);
292 #endif
293
294 return ERROR_OK;
295 }
296
297 static int openjtag_buf_read_cy7c65215(
298 uint8_t *buf, uint32_t qty, uint32_t *bytes_read)
299 {
300 int ret;
301
302 if (qty == 0) {
303 *bytes_read = 0;
304 goto out;
305 }
306
307 ret = jtag_libusb_control_transfer(usbh, CY7C65215_JTAG_REQUEST,
308 CY7C65215_JTAG_READ, qty, 0,
309 NULL, 0, CY7C65215_USB_TIMEOUT, NULL);
310 if (ret != ERROR_OK) {
311 LOG_ERROR("vendor command failed");
312 return ret;
313 }
314
315 if (jtag_libusb_bulk_read(usbh, ep_in, (char *)buf, qty,
316 CY7C65215_USB_TIMEOUT, &ret)) {
317 LOG_ERROR("bulk read failed, error");
318 return ERROR_JTAG_DEVICE_ERROR;
319 }
320 *bytes_read = ret;
321
322 out:
323 #ifdef _DEBUG_USB_COMMS_
324 openjtag_debug_buffer(buf, *bytes_read, DEBUG_TYPE_READ);
325 #endif
326
327 return ERROR_OK;
328 }
329
330 static int openjtag_buf_read(uint8_t *buf, uint32_t qty, uint32_t *bytes_read)
331 {
332 switch (openjtag_variant) {
333 case OPENJTAG_VARIANT_CY7C65215:
334 return openjtag_buf_read_cy7c65215(buf, qty, bytes_read);
335 default:
336 return openjtag_buf_read_standard(buf, qty, bytes_read);
337 }
338 }
339
340 static int openjtag_sendcommand(uint8_t cmd)
341 {
342 uint32_t written;
343 return openjtag_buf_write(&cmd, 1, &written);
344 }
345
346 static int openjtag_speed(int speed)
347 {
348 int clockcmd;
349 switch (speed) {
350 case 48000:
351 clockcmd = 0x00;
352 break;
353 case 24000:
354 clockcmd = 0x20;
355 break;
356 case 12000:
357 clockcmd = 0x40;
358 break;
359 case 6000:
360 clockcmd = 0x60;
361 break;
362 case 3000:
363 clockcmd = 0x80;
364 break;
365 case 1500:
366 clockcmd = 0xA0;
367 break;
368 case 750:
369 clockcmd = 0xC0;
370 break;
371 case 375:
372 clockcmd = 0xE0;
373 break;
374 default:
375 clockcmd = 0xE0;
376 LOG_WARNING("adapter speed not recognized, reverting to 375 kHz");
377 break;
378 }
379 openjtag_sendcommand(clockcmd);
380
381 return ERROR_OK;
382 }
383
384 static int openjtag_init_standard(void)
385 {
386 uint8_t latency_timer;
387
388 /* Open by device description */
389 if (!openjtag_device_desc) {
390 LOG_WARNING("no openjtag device description specified, "
391 "using default 'Open JTAG Project'");
392 openjtag_device_desc = "Open JTAG Project";
393 }
394
395 if (ftdi_init(&ftdic) < 0)
396 return ERROR_JTAG_INIT_FAILED;
397
398 /* context, vendor id, product id, description, serial id */
399 if (ftdi_usb_open_desc(&ftdic, openjtag_vid, openjtag_pid, openjtag_device_desc, NULL) < 0) {
400 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
401 return ERROR_JTAG_INIT_FAILED;
402 }
403
404 if (ftdi_usb_reset(&ftdic) < 0) {
405 LOG_ERROR("unable to reset ftdi device");
406 return ERROR_JTAG_INIT_FAILED;
407 }
408
409 if (ftdi_set_latency_timer(&ftdic, 2) < 0) {
410 LOG_ERROR("unable to set latency timer");
411 return ERROR_JTAG_INIT_FAILED;
412 }
413
414 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0) {
415 LOG_ERROR("unable to get latency timer");
416 return ERROR_JTAG_INIT_FAILED;
417 }
418 LOG_DEBUG("current latency timer: %u", latency_timer);
419
420 ftdi_disable_bitbang(&ftdic);
421 /* was (3000000 / 4) with a comment about a bug in libftdi when using high baudrate */
422 if (ftdi_set_baudrate(&ftdic, 3000000) < 0) {
423 LOG_ERROR("Can't set baud rate to max: %s",
424 ftdi_get_error_string(&ftdic));
425 return ERROR_JTAG_DEVICE_ERROR;
426 }
427
428 if (ftdi_tcioflush(&ftdic) < 0) {
429 LOG_ERROR("ftdi flush: %s", ftdic.error_str);
430 return ERROR_JTAG_INIT_FAILED;
431 }
432
433 return ERROR_OK;
434 }
435
436 static int openjtag_init_cy7c65215(void)
437 {
438 int ret;
439
440 usbh = NULL;
441 ret = jtag_libusb_open(cy7c65215_vids, cy7c65215_pids, NULL, &usbh, NULL);
442 if (ret != ERROR_OK) {
443 LOG_ERROR("unable to open cy7c65215 device");
444 goto err;
445 }
446
447 ret = jtag_libusb_choose_interface(usbh, &ep_in, &ep_out,
448 CY7C65215_JTAG_CLASS,
449 CY7C65215_JTAG_SUBCLASS, -1, LIBUSB_TRANSFER_TYPE_BULK);
450 if (ret != ERROR_OK) {
451 LOG_ERROR("unable to claim JTAG interface");
452 goto err;
453 }
454
455 ret = jtag_libusb_control_transfer(usbh,
456 CY7C65215_JTAG_REQUEST,
457 CY7C65215_JTAG_ENABLE,
458 0, 0, NULL, 0, CY7C65215_USB_TIMEOUT, NULL);
459 if (ret != ERROR_OK) {
460 LOG_ERROR("could not enable JTAG module");
461 goto err;
462 }
463
464 return ERROR_OK;
465
466 err:
467 if (usbh)
468 jtag_libusb_close(usbh);
469 return ret;
470 }
471
472 static int openjtag_init(void)
473 {
474 int ret;
475
476 usb_tx_buf_offs = 0;
477 usb_rx_buf_len = 0;
478 openjtag_scan_result_count = 0;
479
480 switch (openjtag_variant) {
481 case OPENJTAG_VARIANT_CY7C65215:
482 ret = openjtag_init_cy7c65215();
483 break;
484 default:
485 ret = openjtag_init_standard();
486 }
487 if (ret != ERROR_OK)
488 return ret;
489
490 openjtag_speed(375); /* Start at slowest adapter speed */
491 openjtag_sendcommand(0x75); /* MSB */
492
493 return ERROR_OK;
494 }
495
496 static int openjtag_quit_standard(void)
497 {
498 ftdi_usb_close(&ftdic);
499 ftdi_deinit(&ftdic);
500
501 return ERROR_OK;
502 }
503
504 static int openjtag_quit_cy7c65215(void)
505 {
506 int ret;
507
508 ret = jtag_libusb_control_transfer(usbh,
509 CY7C65215_JTAG_REQUEST,
510 CY7C65215_JTAG_DISABLE,
511 0, 0, NULL, 0, CY7C65215_USB_TIMEOUT, NULL);
512 if (ret != ERROR_OK)
513 LOG_WARNING("could not disable JTAG module");
514
515 jtag_libusb_close(usbh);
516
517 return ERROR_OK;
518 }
519
520 static int openjtag_quit(void)
521 {
522 switch (openjtag_variant) {
523 case OPENJTAG_VARIANT_CY7C65215:
524 return openjtag_quit_cy7c65215();
525 default:
526 return openjtag_quit_standard();
527 }
528 }
529
530 static void openjtag_write_tap_buffer(void)
531 {
532 uint32_t written;
533 uint32_t rx_expected = 0;
534
535 /* calculate expected number of return bytes */
536 for (int tx_offs = 0; tx_offs < usb_tx_buf_offs; tx_offs++) {
537 if ((usb_tx_buf[tx_offs] & 0x0F) == 6) {
538 rx_expected++;
539 tx_offs++;
540 } else if ((usb_tx_buf[tx_offs] & 0x0F) == 2) {
541 rx_expected++;
542 }
543 }
544
545 openjtag_buf_write(usb_tx_buf, usb_tx_buf_offs, &written);
546 openjtag_buf_read(usb_rx_buf, rx_expected, &usb_rx_buf_len);
547
548 usb_tx_buf_offs = 0;
549 }
550
551 static int openjtag_execute_tap_queue(void)
552 {
553 openjtag_write_tap_buffer();
554
555 int res_count = 0;
556
557 if (openjtag_scan_result_count && usb_rx_buf_len) {
558
559 int count;
560 int rx_offs = 0;
561 int len;
562
563 /* for every pending result */
564 while (res_count < openjtag_scan_result_count) {
565
566 /* get sent bits */
567 len = openjtag_scan_result_buffer[res_count].bits;
568
569 count = 0;
570
571 uint8_t *buffer = openjtag_scan_result_buffer[res_count].buffer;
572
573 while (len > 0) {
574 if (len <= 8 && openjtag_variant != OPENJTAG_VARIANT_CY7C65215) {
575 LOG_DEBUG_IO("bits < 8 buf = 0x%X, will be 0x%X",
576 usb_rx_buf[rx_offs], usb_rx_buf[rx_offs] >> (8 - len));
577 buffer[count] = usb_rx_buf[rx_offs] >> (8 - len);
578 len = 0;
579 } else {
580 buffer[count] = usb_rx_buf[rx_offs];
581 len -= 8;
582 }
583
584 rx_offs++;
585 count++;
586 }
587
588 #ifdef _DEBUG_USB_COMMS_
589 openjtag_debug_buffer(buffer,
590 DIV_ROUND_UP(openjtag_scan_result_buffer[res_count].bits, 8), DEBUG_TYPE_OCD_READ);
591 #endif
592 jtag_read_buffer(buffer, openjtag_scan_result_buffer[res_count].command);
593
594 free(openjtag_scan_result_buffer[res_count].buffer);
595
596 res_count++;
597 }
598 }
599
600 openjtag_scan_result_count = 0;
601
602 return ERROR_OK;
603 }
604
605 static void openjtag_add_byte(char buf)
606 {
607
608 if (usb_tx_buf_offs == OPENJTAG_BUFFER_SIZE) {
609 LOG_DEBUG_IO("Forcing execute_tap_queue");
610 LOG_DEBUG_IO("TX Buff offs=%d", usb_tx_buf_offs);
611 openjtag_execute_tap_queue();
612 }
613
614 usb_tx_buf[usb_tx_buf_offs] = buf;
615 usb_tx_buf_offs++;
616 }
617
618 static void openjtag_add_scan(uint8_t *buffer, int length, struct scan_command *scan_cmd)
619 {
620
621 /* Ensure space to send long chains */
622 /* We add two byte for each eight (or less) bits, one for command, one for data */
623 if (usb_tx_buf_offs + (DIV_ROUND_UP(length, 8) * 2) >= OPENJTAG_BUFFER_SIZE) {
624 LOG_DEBUG_IO("Forcing execute_tap_queue from scan");
625 LOG_DEBUG_IO("TX Buff offs=%d len=%d", usb_tx_buf_offs, DIV_ROUND_UP(length, 8) * 2);
626 openjtag_execute_tap_queue();
627 }
628
629 openjtag_scan_result_buffer[openjtag_scan_result_count].bits = length;
630 openjtag_scan_result_buffer[openjtag_scan_result_count].command = scan_cmd;
631 openjtag_scan_result_buffer[openjtag_scan_result_count].buffer = buffer;
632
633 uint8_t command;
634 uint8_t bits;
635 int count = 0;
636 while (length) {
637
638 /* write command */
639 command = 6;
640
641 /* last bits? */
642 if (length <= 8) {
643 /* tms high */
644 command |= (1 << 4);
645
646 /* bits to transfer */
647 bits = (length - 1);
648 command |= bits << 5;
649 length = 0;
650 } else {
651 /* whole byte */
652
653 /* bits to transfer */
654 command |= (7 << 5);
655 length -= 8;
656 }
657
658 openjtag_add_byte(command);
659 openjtag_add_byte(buffer[count]);
660 count++;
661 }
662
663 openjtag_scan_result_count++;
664 }
665
666 static void openjtag_execute_reset(struct jtag_command *cmd)
667 {
668
669 LOG_DEBUG_IO("reset trst: %i srst %i",
670 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
671
672 uint8_t buf = 0x00;
673
674 /* Pull SRST low for 5 TCLK cycles */
675 if (cmd->cmd.reset->srst) {
676 buf |= 0x04;
677 buf |= 0x05 << 4;
678 openjtag_add_byte(buf);
679 }
680 }
681
682 static void openjtag_execute_sleep(struct jtag_command *cmd)
683 {
684 jtag_sleep(cmd->cmd.sleep->us);
685 }
686
687 static void openjtag_set_state(uint8_t openocd_state)
688 {
689 uint8_t state = openjtag_get_tap_state(openocd_state);
690
691 uint8_t buf = 0;
692
693 if (state != OPENJTAG_TAP_RESET) {
694 buf = 0x01;
695 buf |= state << 4;
696 } else {
697 /* Force software TLR */
698 buf = 0x03;
699 }
700
701 openjtag_add_byte(buf);
702 }
703
704 static void openjtag_execute_statemove(struct jtag_command *cmd)
705 {
706 LOG_DEBUG_IO("state move to %i", cmd->cmd.statemove->end_state);
707
708 tap_set_end_state(cmd->cmd.statemove->end_state);
709
710 openjtag_set_state(cmd->cmd.statemove->end_state);
711
712 tap_set_state(tap_get_end_state());
713 }
714
715
716 static void openjtag_execute_scan(struct jtag_command *cmd)
717 {
718
719 int scan_size, old_state;
720 uint8_t *buffer;
721
722 LOG_DEBUG_IO("scan ends in %s", tap_state_name(cmd->cmd.scan->end_state));
723
724 /* get scan info */
725 tap_set_end_state(cmd->cmd.scan->end_state);
726 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
727
728 #ifdef _DEBUG_USB_COMMS_
729 openjtag_debug_buffer(buffer, (scan_size + 7) / 8, DEBUG_TYPE_BUFFER);
730 #endif
731 /* set state */
732 old_state = tap_get_end_state();
733 openjtag_set_state(cmd->cmd.scan->ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
734 tap_set_state(cmd->cmd.scan->ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
735 tap_set_end_state(old_state);
736
737 openjtag_add_scan(buffer, scan_size, cmd->cmd.scan);
738
739 openjtag_set_state(cmd->cmd.scan->ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
740 tap_set_state(cmd->cmd.scan->ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
741
742 if (tap_get_state() != tap_get_end_state()) {
743 openjtag_set_state(tap_get_end_state());
744 tap_set_state(tap_get_end_state());
745 }
746 }
747
748 static void openjtag_execute_runtest(struct jtag_command *cmd)
749 {
750
751 tap_state_t end_state = cmd->cmd.runtest->end_state;
752 tap_set_end_state(end_state);
753
754 /* only do a state_move when we're not already in IDLE */
755 if (tap_get_state() != TAP_IDLE) {
756 openjtag_set_state(TAP_IDLE);
757 tap_set_state(TAP_IDLE);
758 }
759
760 if (openjtag_variant != OPENJTAG_VARIANT_CY7C65215 ||
761 cmd->cmd.runtest->num_cycles) {
762 uint8_t command;
763 int cycles = cmd->cmd.runtest->num_cycles;
764
765 do {
766 command = 7;
767 command |= (((cycles > 16 ? 16 : cycles) - 1) & 0x0F) << 4;
768
769 openjtag_add_byte(command);
770 cycles -= 16;
771 } while (cycles > 0);
772 }
773
774 tap_set_end_state(end_state);
775 if (tap_get_end_state() != tap_get_state()) {
776 openjtag_set_state(end_state);
777 tap_set_state(end_state);
778 }
779 }
780
781 static void openjtag_execute_command(struct jtag_command *cmd)
782 {
783 LOG_DEBUG_IO("openjtag_execute_command %i", cmd->type);
784 switch (cmd->type) {
785 case JTAG_RESET:
786 openjtag_execute_reset(cmd);
787 break;
788 case JTAG_SLEEP:
789 openjtag_execute_sleep(cmd);
790 break;
791 case JTAG_TLR_RESET:
792 openjtag_execute_statemove(cmd);
793 break;
794 case JTAG_SCAN:
795 openjtag_execute_scan(cmd);
796 break;
797 case JTAG_RUNTEST:
798 openjtag_execute_runtest(cmd);
799 break;
800 case JTAG_PATHMOVE:
801 /* jlink_execute_pathmove(cmd); break; */
802 default:
803 LOG_ERROR("BUG: unknown Open JTAG command type encountered");
804 exit(-1);
805 }
806 }
807
808 static int openjtag_execute_queue(struct jtag_command *cmd_queue)
809 {
810 struct jtag_command *cmd = cmd_queue;
811
812 while (cmd) {
813 openjtag_execute_command(cmd);
814 cmd = cmd->next;
815 }
816
817 return openjtag_execute_tap_queue();
818 }
819
820 static int openjtag_speed_div(int speed, int *khz)
821 {
822 *khz = speed;
823
824 return ERROR_OK;
825 }
826
827 static int openjtag_khz(int khz, int *jtag_speed)
828 {
829
830 if (khz >= 48000)
831 *jtag_speed = 48000;
832 else if (khz >= 24000)
833 *jtag_speed = 24000;
834 else if (khz >= 12000)
835 *jtag_speed = 12000;
836 else if (khz >= 6000)
837 *jtag_speed = 6000;
838 else if (khz >= 3000)
839 *jtag_speed = 3000;
840 else if (khz >= 1500)
841 *jtag_speed = 1500;
842 else if (khz >= 750)
843 *jtag_speed = 750;
844 else
845 *jtag_speed = 375;
846
847 return ERROR_OK;
848 }
849
850 COMMAND_HANDLER(openjtag_handle_device_desc_command)
851 {
852 if (CMD_ARGC == 1)
853 openjtag_device_desc = strdup(CMD_ARGV[0]);
854 else
855 LOG_ERROR("require exactly one argument to "
856 "openjtag_device_desc <description>");
857 return ERROR_OK;
858 }
859
860 COMMAND_HANDLER(openjtag_handle_variant_command)
861 {
862 if (CMD_ARGC == 1) {
863 const char * const *name = openjtag_variant_names;
864 int variant = 0;
865 for (; *name; name++, variant++) {
866 if (strcasecmp(CMD_ARGV[0], *name) == 0) {
867 openjtag_variant = variant;
868 return ERROR_OK;
869 }
870 }
871 LOG_ERROR("unknown openjtag variant '%s'", CMD_ARGV[0]);
872 } else {
873 LOG_ERROR("require exactly one argument to "
874 "openjtag_variant <variant>");
875 }
876 return ERROR_OK;
877 }
878
879 COMMAND_HANDLER(openjtag_handle_vid_pid_command)
880 {
881 if (CMD_ARGC != 2)
882 return ERROR_COMMAND_SYNTAX_ERROR;
883
884 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], openjtag_vid);
885 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[1], openjtag_pid);
886
887 return ERROR_OK;
888 }
889
890 static const struct command_registration openjtag_subcommand_handlers[] = {
891 {
892 .name = "device_desc",
893 .handler = openjtag_handle_device_desc_command,
894 .mode = COMMAND_CONFIG,
895 .help = "set the USB device description of the OpenJTAG",
896 .usage = "description-string",
897 },
898 {
899 .name = "variant",
900 .handler = openjtag_handle_variant_command,
901 .mode = COMMAND_CONFIG,
902 .help = "set the OpenJTAG variant",
903 .usage = "variant-string",
904 },
905 {
906 .name = "vid_pid",
907 .handler = openjtag_handle_vid_pid_command,
908 .mode = COMMAND_CONFIG,
909 .help = "USB VID and PID of the adapter",
910 .usage = "vid pid",
911 },
912 COMMAND_REGISTRATION_DONE
913 };
914
915 static const struct command_registration openjtag_command_handlers[] = {
916 {
917 .name = "openjtag",
918 .mode = COMMAND_ANY,
919 .help = "perform openjtag management",
920 .chain = openjtag_subcommand_handlers,
921 .usage = "",
922 },
923 COMMAND_REGISTRATION_DONE
924 };
925
926 static struct jtag_interface openjtag_interface = {
927 .execute_queue = openjtag_execute_queue,
928 };
929
930 struct adapter_driver openjtag_adapter_driver = {
931 .name = "openjtag",
932 .transports = jtag_only,
933 .commands = openjtag_command_handlers,
934
935 .init = openjtag_init,
936 .quit = openjtag_quit,
937 .speed = openjtag_speed,
938 .khz = openjtag_khz,
939 .speed_div = openjtag_speed_div,
940
941 .jtag_ops = &openjtag_interface,
942 };
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)