1 // SPDX-License-Identifier: GPL-2.0-or-later
4 * Driver for USB-JTAG, Altera USB-Blaster and compatibles
6 * Inspired from original code from Kolja Waschk's USB-JTAG project
7 * (http://www.ixo.de/info/usb_jtag/), and from openocd project.
9 * Copyright (C) 2013 Franck Jullien franck.jullien@gmail.com
10 * Copyright (C) 2012 Robert Jarzmik robert.jarzmik@free.fr
11 * Copyright (C) 2011 Ali Lown ali@lown.me.uk
12 * Copyright (C) 2009 Catalin Patulea cat@vv.carleton.ca
13 * Copyright (C) 2006 Kolja Waschk usbjtag@ixo.de
18 * The following information is originally from Kolja Waschk's USB-JTAG,
19 * where it was obtained by reverse engineering an Altera USB-Blaster.
20 * See http://www.ixo.de/info/usb_jtag/ for USB-Blaster block diagram and
21 * usb_jtag-20080705-1200.zip#usb_jtag/host/openocd for protocol.
23 * The same information is also on the UrJTAG mediawiki, with some additional
24 * notes on bits marked as "unknown" by usb_jtag.
25 * (http://sourceforge.net/apps/mediawiki/urjtag/index.php?
26 * title=Cable_Altera_USB-Blaster)
28 * USB-JTAG, Altera USB-Blaster and compatibles are typically implemented as
29 * an FTDIChip FT245 followed by a CPLD which handles a two-mode protocol:
35 * __|__________ _________
37 * USB__| FTDI 245BM |__| EPM7064 |__JTAG (B_TDO,B_TDI,B_TMS,B_TCK)
38 * |_____________| |_________|
39 * __|__________ _|___________
41 * | 6 MHz XTAL | | 24 MHz Osc. |
42 * |_____________| |_____________|
44 * USB-JTAG, Altera USB-Blaster II are typically implemented as a Cypress
45 * EZ-USB FX2LP followed by a CPLD.
46 * _____________ _________
48 * USB__| EZ-USB FX2 |__| EPM570 |__JTAG (B_TDO,B_TDI,B_TMS,B_TCK)
49 * |_____________| |_________|
65 /* project specific includes */
66 #include <jtag/interface.h>
67 #include <jtag/commands.h>
68 #include <helper/time_support.h>
69 #include <helper/replacements.h>
70 #include "ublast_access.h"
79 /* Size of USB endpoint max packet size, ie. 64 bytes */
80 #define MAX_PACKET_SIZE 64
82 * Size of data buffer that holds bytes in byte-shift mode.
83 * This buffer can hold multiple USB packets aligned to
84 * MAX_PACKET_SIZE bytes boundaries.
85 * BUF_LEN must be grater than or equal MAX_PACKET_SIZE.
89 /* USB-Blaster II specific command */
90 #define CMD_COPY_TDO_BUFFER 0x5F
100 enum gpio_steer pin6
;
101 enum gpio_steer pin8
;
106 uint8_t buf
[BUF_LEN
];
110 struct ublast_lowlevel
*drv
;
111 uint16_t ublast_vid
, ublast_pid
;
112 uint16_t ublast_vid_uninit
, ublast_pid_uninit
;
118 * Global device control
120 static struct ublast_info info
= {
121 .ublast_vid
= 0x09fb, /* Altera */
122 .ublast_pid
= 0x6001, /* USB-Blaster */
123 .lowlevel_name
= NULL
,
124 .srst_asserted
= false,
125 .trst_asserted
= false,
131 * Available lowlevel drivers (FTDI, libusb, ...)
135 struct ublast_lowlevel
*(*drv_register
)(void);
138 static struct drvs_map lowlevel_drivers_map
[] = {
139 #if BUILD_USB_BLASTER
140 { .name
= "ftdi", .drv_register
= ublast_register_ftdi
},
142 #if BUILD_USB_BLASTER_2
143 { .name
= "ublast2", .drv_register
= ublast2_register_libusb
},
149 * Access functions to lowlevel driver, agnostic of libftdi/libftdxx
151 static char *hexdump(uint8_t *buf
, unsigned int size
)
154 char *str
= calloc(size
* 2 + 1, 1);
156 for (i
= 0; i
< size
; i
++)
157 sprintf(str
+ 2*i
, "%02x", buf
[i
]);
161 static int ublast_buf_read(uint8_t *buf
, unsigned size
, uint32_t *bytes_read
)
163 int ret
= info
.drv
->read(info
.drv
, buf
, size
, bytes_read
);
164 char *str
= hexdump(buf
, *bytes_read
);
166 LOG_DEBUG_IO("(size=%d, buf=[%s]) -> %" PRIu32
, size
, str
,
172 static int ublast_buf_write(uint8_t *buf
, int size
, uint32_t *bytes_written
)
174 int ret
= info
.drv
->write(info
.drv
, buf
, size
, bytes_written
);
175 char *str
= hexdump(buf
, *bytes_written
);
177 LOG_DEBUG_IO("(size=%d, buf=[%s]) -> %" PRIu32
, size
, str
,
183 static int nb_buf_remaining(void)
185 return BUF_LEN
- info
.bufidx
;
188 static void ublast_flush_buffer(void)
191 int nb
= info
.bufidx
, ret
= ERROR_OK
;
193 while (ret
== ERROR_OK
&& nb
> 0) {
194 ret
= ublast_buf_write(info
.buf
, nb
, &retlen
);
201 * Actually, the USB-Blaster offers a byte-shift mode to transmit up to 504 data
202 * bits (bidirectional) in a single USB packet. A header byte has to be sent as
203 * the first byte in a packet with the following meaning:
205 * Bit 7 (0x80): Must be set to indicate byte-shift mode.
206 * Bit 6 (0x40): If set, the USB-Blaster will also read data, not just write.
207 * Bit 5..0: Define the number N of following bytes
209 * All N following bytes will then be clocked out serially on TDI. If Bit 6 was
210 * set, it will afterwards return N bytes with TDO data read while clocking out
211 * the TDI data. LSB of the first byte after the header byte will appear first
215 /* Simple bit banging mode:
217 * Bit 7 (0x80): Must be zero (see byte-shift mode above)
218 * Bit 6 (0x40): If set, you will receive a byte indicating the state of TDO
220 * Bit 5 (0x20): Output Enable/LED.
221 * Bit 4 (0x10): TDI Output.
222 * Bit 3 (0x08): nCS Output (not used in JTAG mode).
223 * Bit 2 (0x04): nCE Output (not used in JTAG mode).
224 * Bit 1 (0x02): TMS Output.
225 * Bit 0 (0x01): TCK Output.
227 * For transmitting a single data bit, you need to write two bytes (one for
228 * setting up TDI/TMS/TCK=0, and one to trigger TCK high with same TDI/TMS
229 * held). Up to 64 bytes can be combined in a single USB packet.
230 * It isn't possible to read a data without transmitting data.
239 #define READ (1 << 6)
240 #define SHMODE (1 << 7)
241 #define READ_TDO (1 << 0)
244 * ublast_queue_byte - queue one 'bitbang mode' byte for USB Blaster
245 * @param abyte the byte to queue
247 * Queues one byte in 'bitbang mode' to the USB Blaster. The byte is not
248 * actually sent, but stored in a buffer. The write is performed once
249 * the buffer is filled, or if an explicit ublast_flush_buffer() is called.
251 static void ublast_queue_byte(uint8_t abyte
)
253 if (nb_buf_remaining() < 1)
254 ublast_flush_buffer();
255 info
.buf
[info
.bufidx
++] = abyte
;
256 if (nb_buf_remaining() == 0)
257 ublast_flush_buffer();
258 LOG_DEBUG_IO("(byte=0x%02x)", abyte
);
262 * ublast_compute_pin - compute if gpio should be asserted
263 * @param steer control (ie. TRST driven, SRST driven, of fixed)
265 * Returns pin value (1 means driven high, 0 mean driven low)
267 static bool ublast_compute_pin(enum gpio_steer steer
)
275 return !info
.srst_asserted
;
277 return !info
.trst_asserted
;
284 * ublast_build_out - build bitbang mode output byte
285 * @param type says if reading back TDO is required
287 * Returns the compute bitbang mode byte
289 static uint8_t ublast_build_out(enum scan_type type
)
293 abyte
|= info
.tms
? TMS
: 0;
294 abyte
|= ublast_compute_pin(info
.pin6
) ? NCE
: 0;
295 abyte
|= ublast_compute_pin(info
.pin8
) ? NCS
: 0;
296 abyte
|= info
.tdi
? TDI
: 0;
298 if (type
== SCAN_IN
|| type
== SCAN_IO
)
304 * ublast_reset - reset the JTAG device is possible
305 * @param trst 1 if TRST is to be asserted
306 * @param srst 1 if SRST is to be asserted
308 static void ublast_reset(int trst
, int srst
)
312 info
.trst_asserted
= trst
;
313 info
.srst_asserted
= srst
;
314 out_value
= ublast_build_out(SCAN_OUT
);
315 ublast_queue_byte(out_value
);
316 ublast_flush_buffer();
320 * ublast_clock_tms - clock a TMS transition
321 * @param tms the TMS to be sent
323 * Triggers a TMS transition (ie. one JTAG TAP state move).
325 static void ublast_clock_tms(int tms
)
329 LOG_DEBUG_IO("(tms=%d)", !!tms
);
332 out
= ublast_build_out(SCAN_OUT
);
333 ublast_queue_byte(out
);
334 ublast_queue_byte(out
| TCK
);
338 * ublast_idle_clock - put back TCK to low level
340 * See ublast_queue_tdi() comment for the usage of this function.
342 static void ublast_idle_clock(void)
344 uint8_t out
= ublast_build_out(SCAN_OUT
);
347 ublast_queue_byte(out
);
351 * ublast_clock_tdi - Output a TDI with bitbang mode
352 * @param tdi the TDI bit to be shifted out
353 * @param type scan type (ie. does a readback of TDO is required)
355 * Output a TDI bit and assert clock to push it into the JTAG device :
356 * - writing out TCK=0, TMS=\<old_state>=0, TDI=\<tdi>
357 * - writing out TCK=1, TMS=\<new_state>, TDI=\<tdi> which triggers the JTAG
358 * device acquiring the data.
360 * If a TDO is to be read back, the required read is requested (bitbang mode),
361 * and the USB Blaster will send back a byte with bit0 representing the TDO.
363 static void ublast_clock_tdi(int tdi
, enum scan_type type
)
367 LOG_DEBUG_IO("(tdi=%d)", !!tdi
);
370 out
= ublast_build_out(SCAN_OUT
);
371 ublast_queue_byte(out
);
373 out
= ublast_build_out(type
);
374 ublast_queue_byte(out
| TCK
);
378 * ublast_clock_tdi_flip_tms - Output a TDI with bitbang mode, change JTAG state
379 * @param tdi the TDI bit to be shifted out
380 * @param type scan type (ie. does a readback of TDO is required)
382 * This function is the same as ublast_clock_tdi(), but it changes also the TMS
383 * while output the TDI. This should be the last TDI output of a TDI
384 * sequence, which will change state from :
385 * - IRSHIFT -> IREXIT1
386 * - or DRSHIFT -> DREXIT1
388 static void ublast_clock_tdi_flip_tms(int tdi
, enum scan_type type
)
392 LOG_DEBUG_IO("(tdi=%d)", !!tdi
);
394 info
.tms
= !info
.tms
;
396 out
= ublast_build_out(SCAN_OUT
);
397 ublast_queue_byte(out
);
399 out
= ublast_build_out(type
);
400 ublast_queue_byte(out
| TCK
);
402 out
= ublast_build_out(SCAN_OUT
);
403 ublast_queue_byte(out
);
407 * ublast_queue_bytes - queue bytes for the USB Blaster
408 * @param bytes byte array
409 * @param nb_bytes number of bytes
411 * Queues bytes to be sent to the USB Blaster. The bytes are not
412 * actually sent, but stored in a buffer. The write is performed once
413 * the buffer is filled, or if an explicit ublast_flush_buffer() is called.
415 static void ublast_queue_bytes(uint8_t *bytes
, int nb_bytes
)
417 if (info
.bufidx
+ nb_bytes
> BUF_LEN
) {
418 LOG_ERROR("buggy code, should never queue more that %d bytes",
419 info
.bufidx
+ nb_bytes
);
422 LOG_DEBUG_IO("(nb_bytes=%d, bytes=[0x%02x, ...])", nb_bytes
,
423 bytes
? bytes
[0] : 0);
425 memcpy(&info
.buf
[info
.bufidx
], bytes
, nb_bytes
);
427 memset(&info
.buf
[info
.bufidx
], 0, nb_bytes
);
428 info
.bufidx
+= nb_bytes
;
429 if (nb_buf_remaining() == 0)
430 ublast_flush_buffer();
434 * ublast_tms_seq - write a TMS sequence transition to JTAG
435 * @param bits TMS bits to be written (bit0, bit1 .. bitN)
436 * @param nb_bits number of TMS bits (between 1 and 8)
437 * @param skip number of TMS bits to skip at the beginning of the series
439 * Write a series of TMS transitions, where each transition consists in :
440 * - writing out TCK=0, TMS=\<new_state>, TDI=\<???>
441 * - writing out TCK=1, TMS=\<new_state>, TDI=\<???> which triggers the transition
442 * The function ensures that at the end of the sequence, the clock (TCK) is put
445 static void ublast_tms_seq(const uint8_t *bits
, int nb_bits
, int skip
)
449 LOG_DEBUG_IO("(bits=%02x..., nb_bits=%d)", bits
[0], nb_bits
);
450 for (i
= skip
; i
< nb_bits
; i
++)
451 ublast_clock_tms((bits
[i
/ 8] >> (i
% 8)) & 0x01);
456 * ublast_tms - write a tms command
457 * @param cmd tms command
459 static void ublast_tms(struct tms_command
*cmd
)
461 LOG_DEBUG_IO("(num_bits=%d)", cmd
->num_bits
);
462 ublast_tms_seq(cmd
->bits
, cmd
->num_bits
, 0);
466 * ublast_path_move - write a TMS sequence transition to JTAG
467 * @param cmd path transition
469 * Write a series of TMS transitions, where each transition consists in :
470 * - writing out TCK=0, TMS=\<new_state>, TDI=\<???>
471 * - writing out TCK=1, TMS=\<new_state>, TDI=\<???> which triggers the transition
472 * The function ensures that at the end of the sequence, the clock (TCK) is put
475 static void ublast_path_move(struct pathmove_command
*cmd
)
479 LOG_DEBUG_IO("(num_states=%d, last_state=%d)",
480 cmd
->num_states
, cmd
->path
[cmd
->num_states
- 1]);
481 for (i
= 0; i
< cmd
->num_states
; i
++) {
482 if (tap_state_transition(tap_get_state(), false) == cmd
->path
[i
])
484 if (tap_state_transition(tap_get_state(), true) == cmd
->path
[i
])
486 tap_set_state(cmd
->path
[i
]);
492 * ublast_state_move - move JTAG state to the target state
493 * @param state the target state
494 * @param skip number of bits to skip at the beginning of the path
496 * Input the correct TMS sequence to the JTAG TAP so that we end up in the
497 * target state. This assumes the current state (tap_get_state()) is correct.
499 static void ublast_state_move(tap_state_t state
, int skip
)
504 LOG_DEBUG_IO("(from %s to %s)", tap_state_name(tap_get_state()),
505 tap_state_name(state
));
506 if (tap_get_state() == state
)
508 tms_scan
= tap_get_tms_path(tap_get_state(), state
);
509 tms_len
= tap_get_tms_path_len(tap_get_state(), state
);
510 ublast_tms_seq(&tms_scan
, tms_len
, skip
);
511 tap_set_state(state
);
515 * ublast_read_byteshifted_tdos - read TDO of byteshift writes
516 * @param buf the buffer to store the bits
517 * @param nb_bytes the number of bytes
519 * Reads back from USB Blaster TDO bits, triggered by a 'byteshift write', ie. eight
520 * bits per received byte from USB interface, and store them in buffer.
522 * As the USB blaster stores the TDO bits in LSB (ie. first bit in (byte0,
523 * bit0), second bit in (byte0, bit1), ...), which is what we want to return,
524 * simply read bytes from USB interface and store them.
526 * Returns ERROR_OK if OK, ERROR_xxx if a read error occurred
528 static int ublast_read_byteshifted_tdos(uint8_t *buf
, int nb_bytes
)
533 LOG_DEBUG_IO("%s(buf=%p, num_bits=%d)", __func__
, buf
, nb_bytes
* 8);
534 ublast_flush_buffer();
535 while (ret
== ERROR_OK
&& nb_bytes
> 0) {
536 ret
= ublast_buf_read(buf
, nb_bytes
, &retlen
);
543 * ublast_read_bitbang_tdos - read TDO of bitbang writes
544 * @param buf the buffer to store the bits
545 * @param nb_bits the number of bits
547 * Reads back from USB Blaster TDO bits, triggered by a 'bitbang write', ie. one
548 * bit per received byte from USB interface, and store them in buffer, where :
549 * - first bit is stored in byte0, bit0 (LSB)
550 * - second bit is stored in byte0, bit 1
552 * - eight bit is stored in byte0, bit 7
553 * - ninth bit is stored in byte1, bit 0
556 * Returns ERROR_OK if OK, ERROR_xxx if a read error occurred
558 static int ublast_read_bitbang_tdos(uint8_t *buf
, int nb_bits
)
561 int i
, ret
= ERROR_OK
;
565 LOG_DEBUG_IO("%s(buf=%p, num_bits=%d)", __func__
, buf
, nb_bits
);
568 * Ensure all previous bitbang writes were issued to the dongle, so that
569 * it returns back the read values.
571 ublast_flush_buffer();
573 ret
= ublast_buf_read(tmp
, nb1
, &retlen
);
574 for (i
= 0; ret
== ERROR_OK
&& i
< nb1
; i
++)
575 if (tmp
[i
] & READ_TDO
)
583 * ublast_queue_tdi - short description
584 * @param bits bits to be queued on TDI (or NULL if 0 are to be queued)
585 * @param nb_bits number of bits
586 * @param scan scan type (ie. if TDO read back is required or not)
588 * Outputs a series of TDI bits on TDI.
589 * As a side effect, the last TDI bit is sent along a TMS=1, and triggers a JTAG
590 * TAP state shift if input bits were non NULL.
592 * In order to not saturate the USB Blaster queues, this method reads back TDO
593 * if the scan type requests it, and stores them back in bits.
595 * As a side note, the state of TCK when entering this function *must* be
596 * low. This is because byteshift mode outputs TDI on rising TCK and reads TDO
597 * on falling TCK if and only if TCK is low before queuing byteshift mode bytes.
598 * If TCK was high, the USB blaster will queue TDI on falling edge, and read TDO
601 static void ublast_queue_tdi(uint8_t *bits
, int nb_bits
, enum scan_type scan
)
603 int nb8
= nb_bits
/ 8;
604 int nb1
= nb_bits
% 8;
605 int nbfree_in_packet
, i
, trans
= 0, read_tdos
;
606 uint8_t *tdos
= calloc(1, nb_bits
/ 8 + 1);
607 static uint8_t byte0
[BUF_LEN
];
610 * As the last TDI bit should always be output in bitbang mode in order
611 * to activate the TMS=1 transition to EXIT_?R state. Therefore a
612 * situation where nb_bits is a multiple of 8 is handled as follows:
613 * - the number of TDI shifted out in "byteshift mode" is 8 less than
616 * This ensures that nb1 is never 0, and allows the TMS transition.
618 if (nb8
> 0 && nb1
== 0) {
623 read_tdos
= (scan
== SCAN_IN
|| scan
== SCAN_IO
);
624 for (i
= 0; i
< nb8
; i
+= trans
) {
626 * Calculate number of bytes to fill USB packet of size MAX_PACKET_SIZE
628 nbfree_in_packet
= (MAX_PACKET_SIZE
- (info
.bufidx
%MAX_PACKET_SIZE
));
629 trans
= MIN(nbfree_in_packet
- 1, nb8
- i
);
632 * Queue a byte-shift mode transmission, with as many bytes as
633 * is possible with regard to :
634 * - current filling level of write buffer
635 * - remaining bytes to write in byte-shift mode
638 ublast_queue_byte(SHMODE
| READ
| trans
);
640 ublast_queue_byte(SHMODE
| trans
);
642 ublast_queue_bytes(&bits
[i
], trans
);
644 ublast_queue_bytes(byte0
, trans
);
646 if (info
.flags
& COPY_TDO_BUFFER
)
647 ublast_queue_byte(CMD_COPY_TDO_BUFFER
);
648 ublast_read_byteshifted_tdos(&tdos
[i
], trans
);
653 * Queue the remaining TDI bits in bitbang mode.
655 for (i
= 0; i
< nb1
; i
++) {
656 int tdi
= bits
? bits
[nb8
+ i
/ 8] & (1 << i
) : 0;
657 if (bits
&& i
== nb1
- 1)
658 ublast_clock_tdi_flip_tms(tdi
, scan
);
660 ublast_clock_tdi(tdi
, scan
);
662 if (nb1
&& read_tdos
) {
663 if (info
.flags
& COPY_TDO_BUFFER
)
664 ublast_queue_byte(CMD_COPY_TDO_BUFFER
);
665 ublast_read_bitbang_tdos(&tdos
[nb8
], nb1
);
669 memcpy(bits
, tdos
, DIV_ROUND_UP(nb_bits
, 8));
673 * Ensure clock is in lower state
678 static void ublast_runtest(int cycles
, tap_state_t state
)
680 LOG_DEBUG_IO("%s(cycles=%i, end_state=%d)", __func__
, cycles
, state
);
682 ublast_state_move(TAP_IDLE
, 0);
683 ublast_queue_tdi(NULL
, cycles
, SCAN_OUT
);
684 ublast_state_move(state
, 0);
687 static void ublast_stableclocks(int cycles
)
689 LOG_DEBUG_IO("%s(cycles=%i)", __func__
, cycles
);
690 ublast_queue_tdi(NULL
, cycles
, SCAN_OUT
);
694 * ublast_scan - launches a DR-scan or IR-scan
695 * @param cmd the command to launch
697 * Launch a JTAG IR-scan or DR-scan
699 * Returns ERROR_OK if OK, ERROR_xxx if a read/write error occurred.
701 static int ublast_scan(struct scan_command
*cmd
)
707 static const char * const type2str
[] = { "", "SCAN_IN", "SCAN_OUT", "SCAN_IO" };
708 char *log_buf
= NULL
;
710 type
= jtag_scan_type(cmd
);
711 scan_bits
= jtag_build_buffer(cmd
, &buf
);
714 ublast_state_move(TAP_IRSHIFT
, 0);
716 ublast_state_move(TAP_DRSHIFT
, 0);
718 log_buf
= hexdump(buf
, DIV_ROUND_UP(scan_bits
, 8));
719 LOG_DEBUG_IO("%s(scan=%s, type=%s, bits=%d, buf=[%s], end_state=%d)", __func__
,
720 cmd
->ir_scan
? "IRSCAN" : "DRSCAN",
722 scan_bits
, log_buf
, cmd
->end_state
);
725 ublast_queue_tdi(buf
, scan_bits
, type
);
727 ret
= jtag_read_buffer(buf
, cmd
);
730 * ublast_queue_tdi sends the last bit with TMS=1. We are therefore
731 * already in Exit1-DR/IR and have to skip the first step on our way
734 ublast_state_move(cmd
->end_state
, 1);
738 static void ublast_usleep(int us
)
740 LOG_DEBUG_IO("%s(us=%d)", __func__
, us
);
744 static void ublast_initial_wipeout(void)
746 static uint8_t tms_reset
= 0xff;
751 out_value
= ublast_build_out(SCAN_OUT
);
752 for (i
= 0; i
< BUF_LEN
; i
++)
753 info
.buf
[i
] = out_value
| ((i
% 2) ? TCK
: 0);
756 * Flush USB-Blaster queue fifos
757 * - empty the write FIFO (128 bytes)
758 * - empty the read FIFO (384 bytes)
760 ublast_buf_write(info
.buf
, BUF_LEN
, &retlen
);
762 * Put JTAG in RESET state (five 1 on TMS)
764 ublast_tms_seq(&tms_reset
, 5, 0);
765 tap_set_state(TAP_RESET
);
768 static int ublast_execute_queue(void)
770 struct jtag_command
*cmd
;
771 static int first_call
= 1;
776 ublast_initial_wipeout();
779 for (cmd
= jtag_command_queue
; ret
== ERROR_OK
&& cmd
;
783 ublast_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
786 ublast_runtest(cmd
->cmd
.runtest
->num_cycles
,
787 cmd
->cmd
.runtest
->end_state
);
789 case JTAG_STABLECLOCKS
:
790 ublast_stableclocks(cmd
->cmd
.stableclocks
->num_cycles
);
793 ublast_state_move(cmd
->cmd
.statemove
->end_state
, 0);
796 ublast_path_move(cmd
->cmd
.pathmove
);
799 ublast_tms(cmd
->cmd
.tms
);
802 ublast_usleep(cmd
->cmd
.sleep
->us
);
805 ret
= ublast_scan(cmd
->cmd
.scan
);
808 LOG_ERROR("BUG: unknown JTAG command type 0x%X",
815 ublast_flush_buffer();
820 * ublast_init - Initialize the Altera device
822 * Initialize the device :
823 * - open the USB device
824 * - pretend it's initialized while actual init is delayed until first jtag command
826 * Returns ERROR_OK if USB device found, error if not.
828 static int ublast_init(void)
832 for (i
= 0; lowlevel_drivers_map
[i
].name
; i
++) {
833 if (info
.lowlevel_name
) {
834 if (!strcmp(lowlevel_drivers_map
[i
].name
, info
.lowlevel_name
)) {
835 info
.drv
= lowlevel_drivers_map
[i
].drv_register();
837 LOG_ERROR("Error registering lowlevel driver \"%s\"",
839 return ERROR_JTAG_DEVICE_ERROR
;
844 info
.drv
= lowlevel_drivers_map
[i
].drv_register();
846 info
.lowlevel_name
= strdup(lowlevel_drivers_map
[i
].name
);
847 LOG_INFO("No lowlevel driver configured, using %s", info
.lowlevel_name
);
854 LOG_ERROR("No lowlevel driver available");
855 return ERROR_JTAG_DEVICE_ERROR
;
859 * Register the lowlevel driver
861 info
.drv
->ublast_vid
= info
.ublast_vid
;
862 info
.drv
->ublast_pid
= info
.ublast_pid
;
863 info
.drv
->ublast_vid_uninit
= info
.ublast_vid_uninit
;
864 info
.drv
->ublast_pid_uninit
= info
.ublast_pid_uninit
;
865 info
.drv
->firmware_path
= info
.firmware_path
;
867 info
.flags
|= info
.drv
->flags
;
869 ret
= info
.drv
->open(info
.drv
);
872 * Let lie here : the TAP is in an unknown state, but the first
873 * execute_queue() will trigger a ublast_initial_wipeout(), which will
874 * put the TAP in RESET.
876 tap_set_state(TAP_RESET
);
881 * ublast_quit - Release the Altera device
883 * Releases the device :
884 * - put the device pins in 'high impedance' mode
885 * - close the USB device
887 * Returns always ERROR_OK
889 static int ublast_quit(void)
894 ublast_buf_write(&byte0
, 1, &retlen
);
895 return info
.drv
->close(info
.drv
);
898 COMMAND_HANDLER(ublast_handle_vid_pid_command
)
901 LOG_WARNING("ignoring extra IDs in ublast_vid_pid "
902 "(maximum is 2 pairs)");
907 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], info
.ublast_vid
);
908 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], info
.ublast_pid
);
910 LOG_WARNING("incomplete ublast_vid_pid configuration");
914 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[2], info
.ublast_vid_uninit
);
915 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[3], info
.ublast_pid_uninit
);
917 LOG_WARNING("incomplete ublast_vid_pid configuration");
923 COMMAND_HANDLER(ublast_handle_pin_command
)
926 const char * const pin_name
= CMD_ARGV
[0];
927 enum gpio_steer
*steer
= NULL
;
928 static const char * const pin_val_str
[] = {
931 [SRST
] = "SRST driven",
932 [TRST
] = "TRST driven",
936 LOG_ERROR("%s takes exactly one or two arguments", CMD_NAME
);
937 return ERROR_COMMAND_SYNTAX_ERROR
;
940 if (!strcmp(pin_name
, "pin6"))
942 if (!strcmp(pin_name
, "pin8"))
945 LOG_ERROR("%s: pin name must be \"pin6\" or \"pin8\"",
947 return ERROR_COMMAND_SYNTAX_ERROR
;
951 LOG_INFO("%s: %s is set as %s\n", CMD_NAME
, pin_name
,
952 pin_val_str
[*steer
]);
956 const char * const pin_value
= CMD_ARGV
[1];
957 char val
= pin_value
[0];
959 if (strlen(pin_value
) > 1)
961 switch (tolower((unsigned char)val
)) {
975 LOG_ERROR("%s: pin value must be 0, 1, s (SRST) or t (TRST)",
977 return ERROR_COMMAND_SYNTAX_ERROR
;
981 out_value
= ublast_build_out(SCAN_OUT
);
982 ublast_queue_byte(out_value
);
983 ublast_flush_buffer();
989 COMMAND_HANDLER(ublast_handle_lowlevel_drv_command
)
992 return ERROR_COMMAND_SYNTAX_ERROR
;
994 info
.lowlevel_name
= strdup(CMD_ARGV
[0]);
999 COMMAND_HANDLER(ublast_firmware_command
)
1002 return ERROR_COMMAND_SYNTAX_ERROR
;
1004 info
.firmware_path
= strdup(CMD_ARGV
[0]);
1010 static const struct command_registration ublast_subcommand_handlers
[] = {
1013 .handler
= ublast_handle_vid_pid_command
,
1014 .mode
= COMMAND_CONFIG
,
1015 .help
= "the vendor ID and product ID of the USB-Blaster and "
1016 "vendor ID and product ID of the uninitialized device "
1017 "for USB-Blaster II",
1018 .usage
= "vid pid vid_uninit pid_uninit",
1021 .name
= "lowlevel_driver",
1022 .handler
= ublast_handle_lowlevel_drv_command
,
1023 .mode
= COMMAND_CONFIG
,
1024 .help
= "set the lowlevel access for the USB Blaster (ftdi, ublast2)",
1025 .usage
= "(ftdi|ublast2)",
1029 .handler
= ublast_handle_pin_command
,
1030 .mode
= COMMAND_ANY
,
1031 .help
= "show or set pin state for the unused GPIO pins",
1032 .usage
= "(pin6|pin8) (0|1|s|t)",
1036 .handler
= &ublast_firmware_command
,
1037 .mode
= COMMAND_CONFIG
,
1038 .help
= "configure the USB-Blaster II firmware location",
1039 .usage
= "path/to/blaster_xxxx.hex",
1041 COMMAND_REGISTRATION_DONE
1044 static const struct command_registration ublast_command_handlers
[] = {
1046 .name
= "usb_blaster",
1047 .mode
= COMMAND_ANY
,
1048 .help
= "perform usb_blaster management",
1049 .chain
= ublast_subcommand_handlers
,
1052 COMMAND_REGISTRATION_DONE
1055 static struct jtag_interface usb_blaster_interface
= {
1056 .supported
= DEBUG_CAP_TMS_SEQ
,
1057 .execute_queue
= ublast_execute_queue
,
1060 struct adapter_driver usb_blaster_adapter_driver
= {
1061 .name
= "usb_blaster",
1062 .transports
= jtag_only
,
1063 .commands
= ublast_command_handlers
,
1065 .init
= ublast_init
,
1066 .quit
= ublast_quit
,
1068 .jtag_ops
= &usb_blaster_interface
,
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)