Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Remove FSF address from GPL notices
[openocd.git] / src / jtag / drivers / openjtag.c
1 /*******************************************************************************
2 * Driver for OpenJTAG Project (www.openjtag.org) *
3 * Compatible with libftdi and ftd2xx drivers. *
4 * *
5 * Copyright (C) 2010 by Ivan Meleca <mileca@gmail.com> *
6 * *
7 * Copyright (C) 2013 by Ryan Corbin, GlueLogix Inc. <corbin.ryan@gmail.com> *
8 * Updated to work with OpenOCD v0.7.0. Fixed libftdi read speed issue. *
9 * *
10 * Based on usb_blaster.c *
11 * Copyright (C) 2009 Catalin Patulea *
12 * Copyright (C) 2006 Kolja Waschk *
13 * *
14 * And jlink.c *
15 * Copyright (C) 2008 by Spencer Oliver *
16 * spen@spen-soft.co.uk *
17 * *
18 * This program is free software; you can redistribute it and/or modify *
19 * it under the terms of the GNU General Public License as published by *
20 * the Free Software Foundation; either version 2 of the License, or *
21 * (at your option) any later version. *
22 * *
23 * This program is distributed in the hope that it will be useful, *
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
26 * GNU General Public License for more details. *
27 * *
28 * You should have received a copy of the GNU General Public License *
29 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
30 ***************************************************************************/
31
32 /***************************************************************************
33 * Version 1.0 Tested on a MCBSTM32 board using a Cortex-M3 (stm32f103x), *
34 * GDB and Eclipse under Linux (Ubuntu 10.04) *
35 * *
36 ***************************************************************************/
37
38 #ifdef HAVE_CONFIG_H
39 #include "config.h"
40 #endif
41
42 #include <jtag/interface.h>
43 #include <jtag/commands.h>
44 #include "usb_common.h"
45
46 /*
47 * OpenJTAG-OpenOCD state conversion
48 */
49 typedef enum openjtag_tap_state {
50 OPENJTAG_TAP_INVALID = -1,
51 OPENJTAG_TAP_RESET = 0,
52 OPENJTAG_TAP_IDLE = 1,
53 OPENJTAG_TAP_SELECT_DR = 2,
54 OPENJTAG_TAP_CAPTURE_DR = 3,
55 OPENJTAG_TAP_SHIFT_DR = 4,
56 OPENJTAG_TAP_EXIT1_DR = 5,
57 OPENJTAG_TAP_PAUSE_DR = 6,
58 OPENJTAG_TAP_EXIT2_DR = 7,
59 OPENJTAG_TAP_UPDATE_DR = 8,
60 OPENJTAG_TAP_SELECT_IR = 9,
61 OPENJTAG_TAP_CAPURE_IR = 10,
62 OPENJTAG_TAP_SHIFT_IR = 11,
63 OPENJTAG_TAP_EXIT1_IR = 12,
64 OPENJTAG_TAP_PAUSE_IR = 13,
65 OPENJTAG_TAP_EXIT2_IR = 14,
66 OPENJTAG_TAP_UPDATE_IR = 15,
67 } openjtag_tap_state_t;
68
69 #if (BUILD_OPENJTAG_FTD2XX == 1 && BUILD_OPENJTAG_LIBFTDI == 1)
70 #error "BUILD_OPENJTAG_FTD2XX && BUILD_OPENJTAG_LIBFTDI "
71 "are mutually exclusive"
72 #elif (BUILD_OPENJTAG_FTD2XX != 1 && BUILD_OPENJTAG_LIBFTDI != 1)
73 #error "BUILD_OPENJTAG_FTD2XX || BUILD_OPENJTAG_LIBFTDI must be chosen"
74 #endif
75
76 /* OPENJTAG access library includes */
77 #if BUILD_OPENJTAG_FTD2XX == 1
78 #include <ftd2xx.h>
79 #elif BUILD_OPENJTAG_LIBFTDI == 1
80 #include <ftdi.h>
81 #endif
82
83 /* OpenJTAG vid/pid */
84 static uint16_t openjtag_vid = 0x0403;
85 static uint16_t openjtag_pid = 0x6001;
86
87 static char *openjtag_device_desc;
88
89 #if BUILD_OPENJTAG_FTD2XX == 1
90 static FT_HANDLE ftdih;
91
92 #elif BUILD_OPENJTAG_LIBFTDI == 1
93 static struct ftdi_context ftdic;
94 #endif
95
96 #define OPENJTAG_BUFFER_SIZE 504
97 #define OPENJTAG_MAX_PENDING_RESULTS 256
98
99 struct openjtag_scan_result {
100 uint32_t bits; /* Length in bits*/
101 struct scan_command *command; /* Corresponding scan command */
102 uint8_t *buffer;
103 };
104
105 /* USB RX/TX buffers */
106 static int usb_tx_buf_offs;
107 static uint8_t usb_tx_buf[OPENJTAG_BUFFER_SIZE];
108 static uint32_t usb_rx_buf_len;
109 static uint8_t usb_rx_buf[OPENJTAG_BUFFER_SIZE];
110
111 /* Pending readings */
112 static struct openjtag_scan_result openjtag_scan_result_buffer[OPENJTAG_MAX_PENDING_RESULTS];
113 static int openjtag_scan_result_count;
114
115 /* Openocd usb handler */
116 struct openocd {
117 struct usb_dev_handle *usb_handle;
118 };
119
120 #ifdef _DEBUG_USB_COMMS_
121
122 #define DEBUG_TYPE_READ 0
123 #define DEBUG_TYPE_WRITE 1
124 #define DEBUG_TYPE_OCD_READ 2
125 #define DEBUG_TYPE_BUFFER 3
126
127 #define LINE_LEN 16
128 static void openjtag_debug_buffer(uint8_t *buffer, int length, uint8_t type)
129 {
130 char line[128];
131 char s[4];
132 int i;
133 int j;
134
135 switch (type) {
136 case DEBUG_TYPE_READ:
137 sprintf(line, "USB READ %d bytes", length);
138 break;
139 case DEBUG_TYPE_WRITE:
140 sprintf(line, "USB WRITE %d bytes", length);
141 break;
142 case DEBUG_TYPE_OCD_READ:
143 sprintf(line, "TO OpenOCD %d bytes", length);
144 break;
145 case DEBUG_TYPE_BUFFER:
146 sprintf(line, "Buffer %d bytes", length);
147 break;
148 }
149
150 LOG_DEBUG("%s", line);
151
152 for (i = 0; i < length; i += LINE_LEN) {
153 switch (type) {
154 case DEBUG_TYPE_READ:
155 sprintf(line, "USB READ: %04x", i);
156 break;
157 case DEBUG_TYPE_WRITE:
158 sprintf(line, "USB WRITE: %04x", i);
159 break;
160 case DEBUG_TYPE_OCD_READ:
161 sprintf(line, "TO OpenOCD: %04x", i);
162 break;
163 case DEBUG_TYPE_BUFFER:
164 sprintf(line, "BUFFER: %04x", i);
165 break;
166 }
167
168 for (j = i; j < i + LINE_LEN && j < length; j++) {
169 sprintf(s, " %02x", buffer[j]);
170 strcat(line, s);
171 }
172 LOG_DEBUG("%s", line);
173 }
174
175 }
176
177 #endif
178
179 static int8_t openjtag_get_tap_state(int8_t state)
180 {
181
182 switch (state) {
183 case TAP_DREXIT2: return OPENJTAG_TAP_EXIT2_DR;
184 case TAP_DREXIT1: return OPENJTAG_TAP_EXIT1_DR;
185 case TAP_DRSHIFT: return OPENJTAG_TAP_SHIFT_DR;
186 case TAP_DRPAUSE: return OPENJTAG_TAP_PAUSE_DR;
187 case TAP_IRSELECT: return OPENJTAG_TAP_SELECT_IR;
188 case TAP_DRUPDATE: return OPENJTAG_TAP_UPDATE_DR;
189 case TAP_DRCAPTURE: return OPENJTAG_TAP_CAPTURE_DR;
190 case TAP_DRSELECT: return OPENJTAG_TAP_SELECT_DR;
191 case TAP_IREXIT2: return OPENJTAG_TAP_EXIT2_IR;
192 case TAP_IREXIT1: return OPENJTAG_TAP_EXIT1_IR;
193 case TAP_IRSHIFT: return OPENJTAG_TAP_SHIFT_IR;
194 case TAP_IRPAUSE: return OPENJTAG_TAP_PAUSE_IR;
195 case TAP_IDLE: return OPENJTAG_TAP_IDLE;
196 case TAP_IRUPDATE: return OPENJTAG_TAP_UPDATE_IR;
197 case TAP_IRCAPTURE: return OPENJTAG_TAP_CAPURE_IR;
198 case TAP_RESET: return OPENJTAG_TAP_RESET;
199 case TAP_INVALID:
200 default: return OPENJTAG_TAP_INVALID;
201 }
202 }
203
204 static int openjtag_buf_write(
205 uint8_t *buf, int size, uint32_t *bytes_written)
206 {
207 #if BUILD_OPENJTAG_FTD2XX == 1
208 FT_STATUS status;
209 DWORD dw_bytes_written;
210
211 #ifdef _DEBUG_USB_COMMS_
212 openjtag_debug_buffer(buf, size, DEBUG_TYPE_WRITE);
213 #endif
214
215 status = FT_Write(ftdih, buf, size, &dw_bytes_written);
216 if (status != FT_OK) {
217 *bytes_written = dw_bytes_written;
218 LOG_ERROR("FT_Write returned: %u", status);
219 return ERROR_JTAG_DEVICE_ERROR;
220 }
221 *bytes_written = dw_bytes_written;
222 return ERROR_OK;
223 #elif BUILD_OPENJTAG_LIBFTDI == 1
224 int retval;
225 #ifdef _DEBUG_USB_COMMS_
226 openjtag_debug_buffer(buf, size, DEBUG_TYPE_WRITE);
227 #endif
228
229 retval = ftdi_write_data(&ftdic, buf, size);
230 if (retval < 0) {
231 *bytes_written = 0;
232 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic));
233 return ERROR_JTAG_DEVICE_ERROR;
234 }
235
236 *bytes_written += retval;
237
238 return ERROR_OK;
239 #endif
240 }
241
242 static int openjtag_buf_read(uint8_t *buf, uint32_t qty, uint32_t *bytes_read)
243 {
244
245 #if BUILD_OPENJTAG_FTD2XX == 1
246 DWORD dw_bytes_read;
247 FT_STATUS status;
248 int timeout = 50;
249
250 *bytes_read = 0;
251 while (qty && (*bytes_read < qty) && timeout--) {
252
253 status = FT_Read(ftdih, buf + *bytes_read,
254 qty - *bytes_read, &dw_bytes_read);
255 if (status != FT_OK) {
256 *bytes_read = dw_bytes_read;
257 LOG_ERROR("FT_Read returned: %u", status);
258 return ERROR_JTAG_DEVICE_ERROR;
259 }
260 *bytes_read += dw_bytes_read;
261 }
262
263 #ifdef _DEBUG_USB_COMMS_
264 openjtag_debug_buffer(buf, *bytes_read, DEBUG_TYPE_READ);
265 #endif
266
267 return ERROR_OK;
268 #elif BUILD_OPENJTAG_LIBFTDI == 1
269 int retval;
270 int timeout = 5;
271
272 *bytes_read = 0;
273
274 while ((*bytes_read < qty) && timeout--) {
275 retval = ftdi_read_data(&ftdic, buf + *bytes_read,
276 qty - *bytes_read);
277 if (retval < 0) {
278 *bytes_read = 0;
279 DEBUG_JTAG_IO("ftdi_read_data: %s",
280 ftdi_get_error_string(&ftdic));
281 return ERROR_JTAG_DEVICE_ERROR;
282 }
283 *bytes_read += retval;
284 }
285
286 #ifdef _DEBUG_USB_COMMS_
287 openjtag_debug_buffer(buf, *bytes_read, DEBUG_TYPE_READ);
288 #endif
289
290 #endif
291 return ERROR_OK;
292 }
293
294 static int openjtag_sendcommand(uint8_t cmd)
295 {
296 uint32_t written;
297 return openjtag_buf_write(&cmd, 1, &written);
298 }
299
300 static int openjtag_speed(int speed)
301 {
302 int clockcmd;
303 switch (speed) {
304 case 48000:
305 clockcmd = 0x00;
306 break;
307 case 24000:
308 clockcmd = 0x20;
309 break;
310 case 12000:
311 clockcmd = 0x40;
312 break;
313 case 6000:
314 clockcmd = 0x60;
315 break;
316 case 3000:
317 clockcmd = 0x80;
318 break;
319 case 1500:
320 clockcmd = 0xA0;
321 break;
322 case 750:
323 clockcmd = 0xC0;
324 break;
325 case 375:
326 clockcmd = 0xE0;
327 break;
328 default:
329 clockcmd = 0xE0;
330 LOG_WARNING("adapter speed not recognized, reverting to 375 kHz");
331 break;
332 }
333 openjtag_sendcommand(clockcmd);
334
335 return ERROR_OK;
336 }
337
338 static int openjtag_init(void)
339 {
340 uint8_t latency_timer;
341
342 #if BUILD_OPENJTAG_FTD2XX == 1
343 FT_STATUS status;
344 #endif
345
346 usb_tx_buf_offs = 0;
347 usb_rx_buf_len = 0;
348 openjtag_scan_result_count = 0;
349
350 #if BUILD_OPENJTAG_FTD2XX == 1
351 LOG_DEBUG("'openjtag' interface using FTD2XX");
352 #elif BUILD_OPENJTAG_LIBFTDI == 1
353 LOG_DEBUG("'openjtag' interface using libftdi");
354 #endif
355
356 /* Open by device description */
357 if (openjtag_device_desc == NULL) {
358 LOG_WARNING("no openjtag device description specified, "
359 "using default 'Open JTAG Project'");
360 openjtag_device_desc = "Open JTAG Project";
361 }
362
363 #if BUILD_OPENJTAG_FTD2XX == 1
364
365 #if IS_WIN32 == 0
366 /* Add non-standard Vid/Pid to the linux driver */
367 status = FT_SetVIDPID(openjtag_vid, openjtag_pid);
368 if (status != FT_OK) {
369 LOG_WARNING("couldn't add %4.4x:%4.4x",
370 openjtag_vid, openjtag_pid);
371 }
372 #endif
373
374 status = FT_OpenEx(openjtag_device_desc, FT_OPEN_BY_DESCRIPTION,
375 &ftdih);
376 if (status != FT_OK) {
377 DWORD num_devices;
378
379 LOG_ERROR("unable to open ftdi device: %u", status);
380 status = FT_ListDevices(&num_devices, NULL,
381 FT_LIST_NUMBER_ONLY);
382 if (status == FT_OK) {
383 char **desc_array = malloc(sizeof(char *)
384 * (num_devices + 1));
385 unsigned int i;
386
387 for (i = 0; i < num_devices; i++)
388 desc_array[i] = malloc(64);
389 desc_array[num_devices] = NULL;
390
391 status = FT_ListDevices(desc_array, &num_devices,
392 FT_LIST_ALL | FT_OPEN_BY_DESCRIPTION);
393
394 if (status == FT_OK) {
395 LOG_ERROR("ListDevices: %u\n", num_devices);
396 for (i = 0; i < num_devices; i++)
397 LOG_ERROR("%i: %s", i, desc_array[i]);
398 }
399
400 for (i = 0; i < num_devices; i++)
401 free(desc_array[i]);
402 free(desc_array);
403 } else {
404 LOG_ERROR("ListDevices: NONE\n");
405 }
406 return ERROR_JTAG_INIT_FAILED;
407 }
408
409 status = FT_SetLatencyTimer(ftdih, 2);
410 if (status != FT_OK) {
411 LOG_ERROR("unable to set latency timer: %u", status);
412 return ERROR_JTAG_INIT_FAILED;
413 }
414
415 status = FT_GetLatencyTimer(ftdih, &latency_timer);
416 if (status != FT_OK) {
417 LOG_ERROR("unable to get latency timer: %u", status);
418 return ERROR_JTAG_INIT_FAILED;
419 }
420 LOG_DEBUG("current latency timer: %i", latency_timer);
421
422 status = FT_SetBitMode(ftdih, 0x00, 0x40);
423 if (status != FT_OK) {
424 LOG_ERROR("unable to disable bit i/o mode: %u", status);
425 return ERROR_JTAG_INIT_FAILED;
426 }
427
428 status = FT_SetTimeouts(ftdih, 50, 0);
429 if (status != FT_OK) {
430 LOG_ERROR("unable to set timeouts: %u", status);
431 return ERROR_JTAG_INIT_FAILED;
432 }
433
434 status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX);
435 if (status != FT_OK) {
436 LOG_ERROR("unable to FT_Purge() %u", status);
437 return ERROR_JTAG_INIT_FAILED;
438 }
439
440 #elif BUILD_OPENJTAG_LIBFTDI == 1
441 if (ftdi_init(&ftdic) < 0)
442 return ERROR_JTAG_INIT_FAILED;
443
444 /* context, vendor id, product id, description, serial id */
445 if (ftdi_usb_open_desc(&ftdic, openjtag_vid, openjtag_pid, openjtag_device_desc, NULL) < 0) {
446 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
447 return ERROR_JTAG_INIT_FAILED;
448 }
449
450 if (ftdi_usb_reset(&ftdic) < 0) {
451 LOG_ERROR("unable to reset ftdi device");
452 return ERROR_JTAG_INIT_FAILED;
453 }
454
455 if (ftdi_set_latency_timer(&ftdic, 2) < 0) {
456 LOG_ERROR("unable to set latency timer");
457 return ERROR_JTAG_INIT_FAILED;
458 }
459
460 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0) {
461 LOG_ERROR("unable to get latency timer");
462 return ERROR_JTAG_INIT_FAILED;
463 }
464 LOG_DEBUG("current latency timer: %u", latency_timer);
465
466 ftdi_disable_bitbang(&ftdic);
467 /* was (3000000 / 4) with a comment about a bug in libftdi when using high baudrate */
468 if (ftdi_set_baudrate(&ftdic, 3000000) < 0) {
469 LOG_ERROR("Can't set baud rate to max: %s",
470 ftdi_get_error_string(&ftdic));
471 return ERROR_JTAG_DEVICE_ERROR;
472 }
473 #endif
474
475 #if BUILD_OPENJTAG_FTD2XX == 1
476 status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX);
477 if (status != FT_OK)
478 return ERROR_JTAG_INIT_FAILED;
479 #elif BUILD_OPENJTAG_LIBFTDI == 1
480 if (ftdi_usb_purge_buffers(&ftdic) < 0) {
481 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
482 return ERROR_JTAG_INIT_FAILED;
483 }
484 #endif
485
486 /* OpenJTAG speed */
487 openjtag_sendcommand(0xE0); /*Start at slowest adapter speed*/
488
489 /* MSB */
490 openjtag_sendcommand(0x75);
491
492 return ERROR_OK;
493 }
494
495 static int openjtag_quit(void)
496 {
497 #if BUILD_OPENJTAG_FTD2XX == 1
498 FT_Close(ftdih);
499 #elif BUILD_OPENJTAG_LIBFTDI == 1
500 ftdi_usb_close(&ftdic);
501 ftdi_deinit(&ftdic);
502 #endif
503
504 return ERROR_OK;
505 }
506
507 static void openjtag_write_tap_buffer(void)
508 {
509 uint32_t written;
510
511 openjtag_buf_write(usb_tx_buf, usb_tx_buf_offs, &written);
512 openjtag_buf_read(usb_rx_buf, usb_tx_buf_offs, &usb_rx_buf_len);
513
514 usb_tx_buf_offs = 0;
515 }
516
517 static int openjtag_execute_tap_queue(void)
518 {
519 openjtag_write_tap_buffer();
520
521 int res_count = 0;
522
523 if (openjtag_scan_result_count && usb_rx_buf_len) {
524
525 int count;
526 int rx_offs = 0;
527 int len;
528
529 /* for every pending result */
530 while (res_count < openjtag_scan_result_count) {
531
532 /* get sent bits */
533 len = openjtag_scan_result_buffer[res_count].bits;
534
535 count = 0;
536
537 uint8_t *buffer = openjtag_scan_result_buffer[res_count].buffer;
538
539 while (len) {
540 if (len <= 8) {
541 DEBUG_JTAG_IO("bits < 8 buf = 0x%X, will be 0x%X",
542 usb_rx_buf[rx_offs], usb_rx_buf[rx_offs] >> (8 - len));
543 buffer[count] = usb_rx_buf[rx_offs] >> (8 - len);
544 len = 0;
545 } else {
546 buffer[count] = usb_rx_buf[rx_offs];
547 len -= 8;
548 }
549
550 rx_offs++;
551 count++;
552 }
553
554 #ifdef _DEBUG_USB_COMMS_
555 openjtag_debug_buffer(buffer,
556 DIV_ROUND_UP(openjtag_scan_result_buffer[res_count].bits, 8), DEBUG_TYPE_OCD_READ);
557 #endif
558 jtag_read_buffer(buffer, openjtag_scan_result_buffer[res_count].command);
559
560 if (openjtag_scan_result_buffer[res_count].buffer)
561 free(openjtag_scan_result_buffer[res_count].buffer);
562
563 res_count++;
564 }
565 }
566
567 openjtag_scan_result_count = 0;
568
569 return ERROR_OK;
570 }
571
572 static void openjtag_add_byte(char buf)
573 {
574
575 if (usb_tx_buf_offs == OPENJTAG_BUFFER_SIZE) {
576 DEBUG_JTAG_IO("Forcing execute_tap_queue");
577 DEBUG_JTAG_IO("TX Buff offs=%d", usb_tx_buf_offs);
578 openjtag_execute_tap_queue();
579 }
580
581 usb_tx_buf[usb_tx_buf_offs] = buf;
582 usb_tx_buf_offs++;
583 }
584
585 static void openjtag_add_scan(uint8_t *buffer, int length, struct scan_command *scan_cmd)
586 {
587
588 /* Ensure space to send long chains */
589 /* We add two byte for each eight (or less) bits, one for command, one for data */
590 if (usb_tx_buf_offs + (DIV_ROUND_UP(length, 8) * 2) >= OPENJTAG_BUFFER_SIZE) {
591 DEBUG_JTAG_IO("Forcing execute_tap_queue from scan");
592 DEBUG_JTAG_IO("TX Buff offs=%d len=%d", usb_tx_buf_offs, DIV_ROUND_UP(length, 8) * 2);
593 openjtag_execute_tap_queue();
594 }
595
596 openjtag_scan_result_buffer[openjtag_scan_result_count].bits = length;
597 openjtag_scan_result_buffer[openjtag_scan_result_count].command = scan_cmd;
598 openjtag_scan_result_buffer[openjtag_scan_result_count].buffer = buffer;
599
600 uint8_t command;
601 uint8_t bits;
602 int count = 0;
603 while (length) {
604
605 /* write command */
606 command = 6;
607
608 /* last bits? */
609 if (length <= 8) {
610 /* tms high */
611 command |= (1 << 4);
612
613 /* bits to transfer */
614 bits = (length - 1);
615 command |= bits << 5;
616 length = 0;
617 } else {
618 /* whole byte */
619
620 /* bits to transfer */
621 bits = 7;
622 command |= (7 << 5);
623 length -= 8;
624 }
625
626 openjtag_add_byte(command);
627 openjtag_add_byte(buffer[count]);
628 count++;
629 }
630
631 openjtag_scan_result_count++;
632 }
633
634 static void openjtag_execute_reset(struct jtag_command *cmd)
635 {
636
637 DEBUG_JTAG_IO("reset trst: %i srst %i",
638 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
639
640 uint8_t buf = 0x00;
641
642 if (cmd->cmd.reset->trst) {
643 buf = 0x03;
644 } else {
645 buf |= 0x04;
646 buf |= 0x05 << 4;
647 }
648
649 openjtag_add_byte(buf);
650 }
651
652 static void openjtag_execute_sleep(struct jtag_command *cmd)
653 {
654 jtag_sleep(cmd->cmd.sleep->us);
655 }
656
657 static void openjtag_set_state(uint8_t openocd_state)
658 {
659 int8_t state = openjtag_get_tap_state(openocd_state);
660
661 uint8_t buf = 0;
662 buf = 0x01;
663 buf |= state << 4;
664
665 openjtag_add_byte(buf);
666 }
667
668 static void openjtag_execute_statemove(struct jtag_command *cmd)
669 {
670 DEBUG_JTAG_IO("state move to %i", cmd->cmd.statemove->end_state);
671
672 tap_set_end_state(cmd->cmd.statemove->end_state);
673
674 openjtag_set_state(cmd->cmd.statemove->end_state);
675
676 tap_set_state(tap_get_end_state());
677 }
678
679
680 static void openjtag_execute_scan(struct jtag_command *cmd)
681 {
682
683 int scan_size, old_state;
684 uint8_t *buffer;
685
686 DEBUG_JTAG_IO("scan ends in %s", tap_state_name(cmd->cmd.scan->end_state));
687
688 /* get scan info */
689 tap_set_end_state(cmd->cmd.scan->end_state);
690 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
691
692 #ifdef _DEBUG_USB_COMMS_
693 openjtag_debug_buffer(buffer, (scan_size + 7) / 8, DEBUG_TYPE_BUFFER);
694 #endif
695 /* set state */
696 old_state = tap_get_end_state();
697 openjtag_set_state(cmd->cmd.scan->ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
698 tap_set_state(cmd->cmd.scan->ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
699 tap_set_end_state(old_state);
700
701 openjtag_add_scan(buffer, scan_size, cmd->cmd.scan);
702
703 openjtag_set_state(cmd->cmd.scan->ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
704 tap_set_state(cmd->cmd.scan->ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
705
706 if (tap_get_state() != tap_get_end_state()) {
707 openjtag_set_state(tap_get_end_state());
708 tap_set_state(tap_get_end_state());
709 }
710 }
711
712 static void openjtag_execute_runtest(struct jtag_command *cmd)
713 {
714
715 tap_state_t end_state = cmd->cmd.runtest->end_state;
716 tap_set_end_state(end_state);
717
718 /* only do a state_move when we're not already in IDLE */
719 if (tap_get_state() != TAP_IDLE) {
720 openjtag_set_state(TAP_IDLE);
721 tap_set_state(TAP_IDLE);
722 }
723
724 if (cmd->cmd.runtest->num_cycles > 16)
725 LOG_WARNING("num_cycles > 16 on run test");
726
727 uint8_t command;
728 command = 7;
729 command |= ((cmd->cmd.runtest->num_cycles - 1) & 0x0F) << 4;
730
731 openjtag_add_byte(command);
732
733 tap_set_end_state(end_state);
734 if (tap_get_end_state() != tap_get_state()) {
735 openjtag_set_state(end_state);
736 tap_set_state(end_state);
737 }
738 }
739
740 static void openjtag_execute_command(struct jtag_command *cmd)
741 {
742 DEBUG_JTAG_IO("openjtag_execute_command %i", cmd->type);
743 switch (cmd->type) {
744 case JTAG_RESET:
745 openjtag_execute_reset(cmd);
746 break;
747 case JTAG_SLEEP:
748 openjtag_execute_sleep(cmd);
749 break;
750 case JTAG_TLR_RESET:
751 openjtag_execute_statemove(cmd);
752 break;
753 case JTAG_SCAN:
754 openjtag_execute_scan(cmd);
755 break;
756 case JTAG_RUNTEST:
757 openjtag_execute_runtest(cmd);
758 break;
759 case JTAG_PATHMOVE:
760 /* jlink_execute_pathmove(cmd); break; */
761 default:
762 LOG_ERROR("BUG: unknown Open JTAG command type encountered");
763 exit(-1);
764 }
765 }
766
767 static int openjtag_execute_queue(void)
768 {
769 struct jtag_command *cmd = jtag_command_queue;
770
771 while (cmd != NULL) {
772 openjtag_execute_command(cmd);
773 cmd = cmd->next;
774 }
775
776 return openjtag_execute_tap_queue();
777 }
778
779 static int openjtag_speed_div(int speed, int *khz)
780 {
781 *khz = speed;
782
783 return ERROR_OK;
784 }
785
786 static int openjtag_khz(int khz, int *jtag_speed)
787 {
788
789 if (khz >= 48000)
790 *jtag_speed = 48000;
791 else if (khz >= 24000)
792 *jtag_speed = 24000;
793 else if (khz >= 12000)
794 *jtag_speed = 12000;
795 else if (khz >= 6000)
796 *jtag_speed = 6000;
797 else if (khz >= 3000)
798 *jtag_speed = 3000;
799 else if (khz >= 1500)
800 *jtag_speed = 1500;
801 else if (khz >= 750)
802 *jtag_speed = 750;
803 else
804 *jtag_speed = 375;
805
806 return ERROR_OK;
807 }
808
809 COMMAND_HANDLER(openjtag_handle_device_desc_command)
810 {
811 if (CMD_ARGC == 1)
812 openjtag_device_desc = strdup(CMD_ARGV[0]);
813 else
814 LOG_ERROR("require exactly one argument to "
815 "openjtag_device_desc <description>");
816 return ERROR_OK;
817 }
818
819
820 static const struct command_registration openjtag_command_handlers[] = {
821 {
822 .name = "openjtag_device_desc",
823 .handler = openjtag_handle_device_desc_command,
824 .mode = COMMAND_CONFIG,
825 .help = "set the USB device description of the OpenJTAG",
826 .usage = "description-string",
827 },
828 COMMAND_REGISTRATION_DONE
829 };
830
831 struct jtag_interface openjtag_interface = {
832 .name = "openjtag",
833 .commands = openjtag_command_handlers,
834
835 .execute_queue = openjtag_execute_queue,
836 .speed = openjtag_speed,
837 .speed_div = openjtag_speed_div,
838 .khz = openjtag_khz,
839 .init = openjtag_init,
840 .quit = openjtag_quit,
841 };
842
843
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)