2 * Driver for USB-JTAG, Altera USB-Blaster and compatibles
4 * Inspired from original code from Kolja Waschk's USB-JTAG project
5 * (http://www.ixo.de/info/usb_jtag/), and from openocd project.
7 * Copyright (C) 2013 Franck Jullien franck.jullien@gmail.com
8 * Copyright (C) 2012 Robert Jarzmik robert.jarzmik@free.fr
9 * Copyright (C) 2011 Ali Lown ali@lown.me.uk
10 * Copyright (C) 2009 Catalin Patulea cat@vv.carleton.ca
11 * Copyright (C) 2006 Kolja Waschk usbjtag@ixo.de
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program. If not, see <http://www.gnu.org/licenses/>.
29 * The following information is originally from Kolja Waschk's USB-JTAG,
30 * where it was obtained by reverse engineering an Altera USB-Blaster.
31 * See http://www.ixo.de/info/usb_jtag/ for USB-Blaster block diagram and
32 * usb_jtag-20080705-1200.zip#usb_jtag/host/openocd for protocol.
34 * The same information is also on the UrJTAG mediawiki, with some additional
35 * notes on bits marked as "unknown" by usb_jtag.
36 * (http://sourceforge.net/apps/mediawiki/urjtag/index.php?
37 * title=Cable_Altera_USB-Blaster)
39 * USB-JTAG, Altera USB-Blaster and compatibles are typically implemented as
40 * an FTDIChip FT245 followed by a CPLD which handles a two-mode protocol:
46 * __|__________ _________
48 * USB__| FTDI 245BM |__| EPM7064 |__JTAG (B_TDO,B_TDI,B_TMS,B_TCK)
49 * |_____________| |_________|
50 * __|__________ _|___________
52 * | 6 MHz XTAL | | 24 MHz Osc. |
53 * |_____________| |_____________|
55 * USB-JTAG, Altera USB-Blaster II are typically implemented as a Cypress
56 * EZ-USB FX2LP followed by a CPLD.
57 * _____________ _________
59 * USB__| EZ-USB FX2 |__| EPM570 |__JTAG (B_TDO,B_TDI,B_TMS,B_TCK)
60 * |_____________| |_________|
76 /* project specific includes */
77 #include <jtag/interface.h>
78 #include <jtag/commands.h>
79 #include <helper/time_support.h>
80 #include "ublast_access.h"
89 /* Size of USB endpoint max packet size, ie. 64 bytes */
90 #define MAX_PACKET_SIZE 64
92 * Size of data buffer that holds bytes in byte-shift mode.
93 * This buffer can hold multiple USB packets aligned to
94 * MAX_PACKET_SIZE bytes boundaries.
95 * BUF_LEN must be grater than or equal MAX_PACKET_SIZE.
99 /* USB-Blaster II specific command */
100 #define CMD_COPY_TDO_BUFFER 0x5F
110 enum gpio_steer pin6
;
111 enum gpio_steer pin8
;
116 uint8_t buf
[BUF_LEN
];
120 struct ublast_lowlevel
*drv
;
121 char *ublast_device_desc
;
122 uint16_t ublast_vid
, ublast_pid
;
123 uint16_t ublast_vid_uninit
, ublast_pid_uninit
;
129 * Global device control
131 static struct ublast_info info
= {
132 .ublast_vid
= 0x09fb, /* Altera */
133 .ublast_pid
= 0x6001, /* USB-Blaster */
134 .lowlevel_name
= NULL
,
135 .srst_asserted
= false,
136 .trst_asserted
= false,
142 * Available lowlevel drivers (FTDI, FTD2xx, ...)
146 struct ublast_lowlevel
*(*drv_register
)(void);
149 static struct drvs_map lowlevel_drivers_map
[] = {
150 #if BUILD_USB_BLASTER_LIBFTDI
151 { .name
= "ftdi", .drv_register
= ublast_register_ftdi
},
153 #if BUILD_USB_BLASTER_FTD2XX
154 { .name
= "ftd2xx", .drv_register
= ublast_register_ftd2xx
},
156 #if BUILD_USB_BLASTER_2
157 { .name
= "ublast2", .drv_register
= ublast2_register_libusb
},
163 * Access functions to lowlevel driver, agnostic of libftdi/libftdxx
165 static char *hexdump(uint8_t *buf
, unsigned int size
)
168 char *str
= calloc(size
* 2 + 1, 1);
170 for (i
= 0; i
< size
; i
++)
171 sprintf(str
+ 2*i
, "%02x", buf
[i
]);
175 static int ublast_buf_read(uint8_t *buf
, unsigned size
, uint32_t *bytes_read
)
177 int ret
= info
.drv
->read(info
.drv
, buf
, size
, bytes_read
);
178 char *str
= hexdump(buf
, *bytes_read
);
180 DEBUG_JTAG_IO("(size=%d, buf=[%s]) -> %u", size
, str
,
186 static int ublast_buf_write(uint8_t *buf
, int size
, uint32_t *bytes_written
)
188 int ret
= info
.drv
->write(info
.drv
, buf
, size
, bytes_written
);
189 char *str
= hexdump(buf
, *bytes_written
);
191 DEBUG_JTAG_IO("(size=%d, buf=[%s]) -> %u", size
, str
,
197 static int nb_buf_remaining(void)
199 return BUF_LEN
- info
.bufidx
;
202 static void ublast_flush_buffer(void)
205 int nb
= info
.bufidx
, ret
= ERROR_OK
;
207 while (ret
== ERROR_OK
&& nb
> 0) {
208 ret
= ublast_buf_write(info
.buf
, nb
, &retlen
);
215 * Actually, the USB-Blaster offers a byte-shift mode to transmit up to 504 data
216 * bits (bidirectional) in a single USB packet. A header byte has to be sent as
217 * the first byte in a packet with the following meaning:
219 * Bit 7 (0x80): Must be set to indicate byte-shift mode.
220 * Bit 6 (0x40): If set, the USB-Blaster will also read data, not just write.
221 * Bit 5..0: Define the number N of following bytes
223 * All N following bytes will then be clocked out serially on TDI. If Bit 6 was
224 * set, it will afterwards return N bytes with TDO data read while clocking out
225 * the TDI data. LSB of the first byte after the header byte will appear first
229 /* Simple bit banging mode:
231 * Bit 7 (0x80): Must be zero (see byte-shift mode above)
232 * Bit 6 (0x40): If set, you will receive a byte indicating the state of TDO
234 * Bit 5 (0x20): Output Enable/LED.
235 * Bit 4 (0x10): TDI Output.
236 * Bit 3 (0x08): nCS Output (not used in JTAG mode).
237 * Bit 2 (0x04): nCE Output (not used in JTAG mode).
238 * Bit 1 (0x02): TMS Output.
239 * Bit 0 (0x01): TCK Output.
241 * For transmitting a single data bit, you need to write two bytes (one for
242 * setting up TDI/TMS/TCK=0, and one to trigger TCK high with same TDI/TMS
243 * held). Up to 64 bytes can be combined in a single USB packet.
244 * It isn't possible to read a data without transmitting data.
253 #define READ (1 << 6)
254 #define SHMODE (1 << 7)
255 #define READ_TDO (1 << 0)
258 * ublast_queue_byte - queue one 'bitbang mode' byte for USB Blaster
259 * @abyte: the byte to queue
261 * Queues one byte in 'bitbang mode' to the USB Blaster. The byte is not
262 * actually sent, but stored in a buffer. The write is performed once
263 * the buffer is filled, or if an explicit ublast_flush_buffer() is called.
265 static void ublast_queue_byte(uint8_t abyte
)
267 if (nb_buf_remaining() < 1)
268 ublast_flush_buffer();
269 info
.buf
[info
.bufidx
++] = abyte
;
270 if (nb_buf_remaining() == 0)
271 ublast_flush_buffer();
272 DEBUG_JTAG_IO("(byte=0x%02x)", abyte
);
276 * ublast_compute_pin - compute if gpio should be asserted
277 * @steer: control (ie. TRST driven, SRST driven, of fixed)
279 * Returns pin value (1 means driven high, 0 mean driven low)
281 bool ublast_compute_pin(enum gpio_steer steer
)
289 return !info
.srst_asserted
;
291 return !info
.trst_asserted
;
298 * ublast_build_out - build bitbang mode output byte
299 * @type: says if reading back TDO is required
301 * Returns the compute bitbang mode byte
303 static uint8_t ublast_build_out(enum scan_type type
)
307 abyte
|= info
.tms
? TMS
: 0;
308 abyte
|= ublast_compute_pin(info
.pin6
) ? NCE
: 0;
309 abyte
|= ublast_compute_pin(info
.pin8
) ? NCS
: 0;
310 abyte
|= info
.tdi
? TDI
: 0;
312 if (type
== SCAN_IN
|| type
== SCAN_IO
)
318 * ublast_reset - reset the JTAG device is possible
319 * @trst: 1 if TRST is to be asserted
320 * @srst: 1 if SRST is to be asserted
322 static void ublast_reset(int trst
, int srst
)
326 info
.trst_asserted
= trst
;
327 info
.srst_asserted
= srst
;
328 out_value
= ublast_build_out(SCAN_OUT
);
329 ublast_queue_byte(out_value
);
330 ublast_flush_buffer();
334 * ublast_clock_tms - clock a TMS transition
335 * @tms: the TMS to be sent
337 * Triggers a TMS transition (ie. one JTAG TAP state move).
339 static void ublast_clock_tms(int tms
)
343 DEBUG_JTAG_IO("(tms=%d)", !!tms
);
346 out
= ublast_build_out(SCAN_OUT
);
347 ublast_queue_byte(out
);
348 ublast_queue_byte(out
| TCK
);
352 * ublast_idle_clock - put back TCK to low level
354 * See ublast_queue_tdi() comment for the usage of this function.
356 static void ublast_idle_clock(void)
358 uint8_t out
= ublast_build_out(SCAN_OUT
);
361 ublast_queue_byte(out
);
365 * ublast_clock_tdi - Output a TDI with bitbang mode
366 * @tdi: the TDI bit to be shifted out
367 * @type: scan type (ie. does a readback of TDO is required)
369 * Output a TDI bit and assert clock to push it into the JTAG device :
370 * - writing out TCK=0, TMS=<old_state>=0, TDI=<tdi>
371 * - writing out TCK=1, TMS=<new_state>, TDI=<tdi> which triggers the JTAG
372 * device aquiring the data.
374 * If a TDO is to be read back, the required read is requested (bitbang mode),
375 * and the USB Blaster will send back a byte with bit0 reprensenting the TDO.
377 static void ublast_clock_tdi(int tdi
, enum scan_type type
)
381 DEBUG_JTAG_IO("(tdi=%d)", !!tdi
);
384 out
= ublast_build_out(SCAN_OUT
);
385 ublast_queue_byte(out
);
387 out
= ublast_build_out(type
);
388 ublast_queue_byte(out
| TCK
);
392 * ublast_clock_tdi_flip_tms - Output a TDI with bitbang mode, change JTAG state
393 * @tdi: the TDI bit to be shifted out
394 * @type: scan type (ie. does a readback of TDO is required)
396 * This function is the same as ublast_clock_tdi(), but it changes also the TMS
397 * while outputing the TDI. This should be the last TDI output of a TDI
398 * sequence, which will change state from :
399 * - IRSHIFT -> IREXIT1
400 * - or DRSHIFT -> DREXIT1
402 static void ublast_clock_tdi_flip_tms(int tdi
, enum scan_type type
)
406 DEBUG_JTAG_IO("(tdi=%d)", !!tdi
);
408 info
.tms
= !info
.tms
;
410 out
= ublast_build_out(SCAN_OUT
);
411 ublast_queue_byte(out
);
413 out
= ublast_build_out(type
);
414 ublast_queue_byte(out
| TCK
);
416 out
= ublast_build_out(SCAN_OUT
);
417 ublast_queue_byte(out
);
421 * ublast_queue_bytes - queue bytes for the USB Blaster
423 * @nb_bytes: number of bytes
425 * Queues bytes to be sent to the USB Blaster. The bytes are not
426 * actually sent, but stored in a buffer. The write is performed once
427 * the buffer is filled, or if an explicit ublast_flush_buffer() is called.
429 static void ublast_queue_bytes(uint8_t *bytes
, int nb_bytes
)
431 if (info
.bufidx
+ nb_bytes
> BUF_LEN
) {
432 LOG_ERROR("buggy code, should never queue more that %d bytes",
433 info
.bufidx
+ nb_bytes
);
436 DEBUG_JTAG_IO("(nb_bytes=%d, bytes=[0x%02x, ...])", nb_bytes
,
437 bytes
? bytes
[0] : 0);
439 memcpy(&info
.buf
[info
.bufidx
], bytes
, nb_bytes
);
441 memset(&info
.buf
[info
.bufidx
], 0, nb_bytes
);
442 info
.bufidx
+= nb_bytes
;
443 if (nb_buf_remaining() == 0)
444 ublast_flush_buffer();
448 * ublast_tms_seq - write a TMS sequence transition to JTAG
449 * @bits: TMS bits to be written (bit0, bit1 .. bitN)
450 * @nb_bits: number of TMS bits (between 1 and 8)
452 * Write a serie of TMS transitions, where each transition consists in :
453 * - writing out TCK=0, TMS=<new_state>, TDI=<???>
454 * - writing out TCK=1, TMS=<new_state>, TDI=<???> which triggers the transition
455 * The function ensures that at the end of the sequence, the clock (TCK) is put
458 static void ublast_tms_seq(const uint8_t *bits
, int nb_bits
)
462 DEBUG_JTAG_IO("(bits=%02x..., nb_bits=%d)", bits
[0], nb_bits
);
463 for (i
= 0; i
< nb_bits
; i
++)
464 ublast_clock_tms((bits
[i
/ 8] >> (i
% 8)) & 0x01);
469 * ublast_tms - write a tms command
472 static void ublast_tms(struct tms_command
*cmd
)
474 DEBUG_JTAG_IO("(num_bits=%d)", cmd
->num_bits
);
475 ublast_tms_seq(cmd
->bits
, cmd
->num_bits
);
479 * ublast_path_move - write a TMS sequence transition to JTAG
480 * @cmd: path transition
482 * Write a serie of TMS transitions, where each transition consists in :
483 * - writing out TCK=0, TMS=<new_state>, TDI=<???>
484 * - writing out TCK=1, TMS=<new_state>, TDI=<???> which triggers the transition
485 * The function ensures that at the end of the sequence, the clock (TCK) is put
488 static void ublast_path_move(struct pathmove_command
*cmd
)
492 DEBUG_JTAG_IO("(num_states=%d, last_state=%d)",
493 cmd
->num_states
, cmd
->path
[cmd
->num_states
- 1]);
494 for (i
= 0; i
< cmd
->num_states
; i
++) {
495 if (tap_state_transition(tap_get_state(), false) == cmd
->path
[i
])
497 if (tap_state_transition(tap_get_state(), true) == cmd
->path
[i
])
499 tap_set_state(cmd
->path
[i
]);
505 * ublast_state_move - move JTAG state to the target state
506 * @state: the target state
508 * Input the correct TMS sequence to the JTAG TAP so that we end up in the
509 * target state. This assumes the current state (tap_get_state()) is correct.
511 static void ublast_state_move(tap_state_t state
)
516 DEBUG_JTAG_IO("(from %s to %s)", tap_state_name(tap_get_state()),
517 tap_state_name(state
));
518 if (tap_get_state() == state
)
520 tms_scan
= tap_get_tms_path(tap_get_state(), state
);
521 tms_len
= tap_get_tms_path_len(tap_get_state(), state
);
522 ublast_tms_seq(&tms_scan
, tms_len
);
523 tap_set_state(state
);
527 * ublast_read_byteshifted_tdos - read TDO of byteshift writes
528 * @buf: the buffer to store the bits
529 * @nb_bits: the number of bits
531 * Reads back from USB Blaster TDO bits, triggered by a 'byteshift write', ie. eight
532 * bits per received byte from USB interface, and store them in buffer.
534 * As the USB blaster stores the TDO bits in LSB (ie. first bit in (byte0,
535 * bit0), second bit in (byte0, bit1), ...), which is what we want to return,
536 * simply read bytes from USB interface and store them.
538 * Returns ERROR_OK if OK, ERROR_xxx if a read error occured
540 static int ublast_read_byteshifted_tdos(uint8_t *buf
, int nb_bytes
)
545 DEBUG_JTAG_IO("%s(buf=%p, num_bits=%d)", __func__
, buf
, nb_bytes
* 8);
546 ublast_flush_buffer();
547 while (ret
== ERROR_OK
&& nb_bytes
> 0) {
548 ret
= ublast_buf_read(buf
, nb_bytes
, &retlen
);
555 * ublast_read_bitbang_tdos - read TDO of bitbang writes
556 * @buf: the buffer to store the bits
557 * @nb_bits: the number of bits
559 * Reads back from USB Blaster TDO bits, triggered by a 'bitbang write', ie. one
560 * bit per received byte from USB interface, and store them in buffer, where :
561 * - first bit is stored in byte0, bit0 (LSB)
562 * - second bit is stored in byte0, bit 1
564 * - eight bit is sotred in byte0, bit 7
565 * - ninth bit is sotred in byte1, bit 0
568 * Returns ERROR_OK if OK, ERROR_xxx if a read error occured
570 static int ublast_read_bitbang_tdos(uint8_t *buf
, int nb_bits
)
573 int i
, ret
= ERROR_OK
;
577 DEBUG_JTAG_IO("%s(buf=%p, num_bits=%d)", __func__
, buf
, nb_bits
);
580 * Ensure all previous bitbang writes were issued to the dongle, so that
581 * it returns back the read values.
583 ublast_flush_buffer();
585 ret
= ublast_buf_read(tmp
, nb1
, &retlen
);
586 for (i
= 0; ret
== ERROR_OK
&& i
< nb1
; i
++)
587 if (tmp
[i
] & READ_TDO
)
595 * ublast_queue_tdi - short description
596 * @bits: bits to be queued on TDI (or NULL if 0 are to be queued)
597 * @nb_bits: number of bits
598 * @scan: scan type (ie. if TDO read back is required or not)
600 * Outputs a serie of TDI bits on TDI.
601 * As a side effect, the last TDI bit is sent along a TMS=1, and triggers a JTAG
602 * TAP state shift if input bits were non NULL.
604 * In order to not saturate the USB Blaster queues, this method reads back TDO
605 * if the scan type requests it, and stores them back in bits.
607 * As a side note, the state of TCK when entering this function *must* be
608 * low. This is because byteshift mode outputs TDI on rising TCK and reads TDO
609 * on falling TCK if and only if TCK is low before queuing byteshift mode bytes.
610 * If TCK was high, the USB blaster will queue TDI on falling edge, and read TDO
613 static void ublast_queue_tdi(uint8_t *bits
, int nb_bits
, enum scan_type scan
)
615 int nb8
= nb_bits
/ 8;
616 int nb1
= nb_bits
% 8;
617 int nbfree_in_packet
, i
, trans
= 0, read_tdos
;
618 uint8_t *tdos
= calloc(1, nb_bits
/ 8 + 1);
619 static uint8_t byte0
[BUF_LEN
];
622 * As the last TDI bit should always be output in bitbang mode in order
623 * to activate the TMS=1 transition to EXIT_?R state. Therefore a
624 * situation where nb_bits is a multiple of 8 is handled as follows:
625 * - the number of TDI shifted out in "byteshift mode" is 8 less than
628 * This ensures that nb1 is never 0, and allows the TMS transition.
630 if (nb8
> 0 && nb1
== 0) {
635 read_tdos
= (scan
== SCAN_IN
|| scan
== SCAN_IO
);
636 for (i
= 0; i
< nb8
; i
+= trans
) {
638 * Calculate number of bytes to fill USB packet of size MAX_PACKET_SIZE
640 nbfree_in_packet
= (MAX_PACKET_SIZE
- (info
.bufidx
%MAX_PACKET_SIZE
));
641 trans
= MIN(nbfree_in_packet
- 1, nb8
- i
);
644 * Queue a byte-shift mode transmission, with as many bytes as
645 * is possible with regard to :
646 * - current filling level of write buffer
647 * - remaining bytes to write in byte-shift mode
650 ublast_queue_byte(SHMODE
| READ
| trans
);
652 ublast_queue_byte(SHMODE
| trans
);
654 ublast_queue_bytes(&bits
[i
], trans
);
656 ublast_queue_bytes(byte0
, trans
);
658 if (info
.flags
& COPY_TDO_BUFFER
)
659 ublast_queue_byte(CMD_COPY_TDO_BUFFER
);
660 ublast_read_byteshifted_tdos(&tdos
[i
], trans
);
665 * Queue the remaining TDI bits in bitbang mode.
667 for (i
= 0; i
< nb1
; i
++) {
668 int tdi
= bits
? bits
[nb8
+ i
/ 8] & (1 << i
) : 0;
669 if (bits
&& i
== nb1
- 1)
670 ublast_clock_tdi_flip_tms(tdi
, scan
);
672 ublast_clock_tdi(tdi
, scan
);
674 if (nb1
&& read_tdos
) {
675 if (info
.flags
& COPY_TDO_BUFFER
)
676 ublast_queue_byte(CMD_COPY_TDO_BUFFER
);
677 ublast_read_bitbang_tdos(&tdos
[nb8
], nb1
);
681 memcpy(bits
, tdos
, DIV_ROUND_UP(nb_bits
, 8));
685 * Ensure clock is in lower state
690 static void ublast_runtest(int cycles
, tap_state_t state
)
692 DEBUG_JTAG_IO("%s(cycles=%i, end_state=%d)", __func__
, cycles
, state
);
694 ublast_state_move(TAP_IDLE
);
695 ublast_queue_tdi(NULL
, cycles
, SCAN_OUT
);
696 ublast_state_move(state
);
699 static void ublast_stableclocks(int cycles
)
701 DEBUG_JTAG_IO("%s(cycles=%i)", __func__
, cycles
);
702 ublast_queue_tdi(NULL
, cycles
, SCAN_OUT
);
706 * ublast_scan - launches a DR-scan or IR-scan
707 * @cmd: the command to launch
709 * Launch a JTAG IR-scan or DR-scan
711 * Returns ERROR_OK if OK, ERROR_xxx if a read/write error occured.
713 static int ublast_scan(struct scan_command
*cmd
)
719 static const char * const type2str
[] = { "", "SCAN_IN", "SCAN_OUT", "SCAN_IO" };
720 char *log_buf
= NULL
;
722 type
= jtag_scan_type(cmd
);
723 scan_bits
= jtag_build_buffer(cmd
, &buf
);
726 ublast_state_move(TAP_IRSHIFT
);
728 ublast_state_move(TAP_DRSHIFT
);
730 log_buf
= hexdump(buf
, DIV_ROUND_UP(scan_bits
, 8));
731 DEBUG_JTAG_IO("%s(scan=%s, type=%s, bits=%d, buf=[%s], end_state=%d)", __func__
,
732 cmd
->ir_scan
? "IRSCAN" : "DRSCAN",
734 scan_bits
, log_buf
, cmd
->end_state
);
737 ublast_queue_tdi(buf
, scan_bits
, type
);
740 * As our JTAG is in an unstable state (IREXIT1 or DREXIT1), move it
741 * forward to a stable IRPAUSE or DRPAUSE.
745 tap_set_state(TAP_IRPAUSE
);
747 tap_set_state(TAP_DRPAUSE
);
749 ret
= jtag_read_buffer(buf
, cmd
);
752 ublast_state_move(cmd
->end_state
);
756 static void ublast_usleep(int us
)
758 DEBUG_JTAG_IO("%s(us=%d)", __func__
, us
);
762 static void ublast_initial_wipeout(void)
764 static uint8_t tms_reset
= 0xff;
769 out_value
= ublast_build_out(SCAN_OUT
);
770 for (i
= 0; i
< BUF_LEN
; i
++)
771 info
.buf
[i
] = out_value
| ((i
% 2) ? TCK
: 0);
774 * Flush USB-Blaster queue fifos
775 * - empty the write FIFO (128 bytes)
776 * - empty the read FIFO (384 bytes)
778 ublast_buf_write(info
.buf
, BUF_LEN
, &retlen
);
780 * Put JTAG in RESET state (five 1 on TMS)
782 ublast_tms_seq(&tms_reset
, 5);
783 tap_set_state(TAP_RESET
);
786 static int ublast_execute_queue(void)
788 struct jtag_command
*cmd
;
789 static int first_call
= 1;
794 ublast_initial_wipeout();
797 for (cmd
= jtag_command_queue
; ret
== ERROR_OK
&& cmd
!= NULL
;
801 ublast_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
804 ublast_runtest(cmd
->cmd
.runtest
->num_cycles
,
805 cmd
->cmd
.runtest
->end_state
);
807 case JTAG_STABLECLOCKS
:
808 ublast_stableclocks(cmd
->cmd
.stableclocks
->num_cycles
);
811 ublast_state_move(cmd
->cmd
.statemove
->end_state
);
814 ublast_path_move(cmd
->cmd
.pathmove
);
817 ublast_tms(cmd
->cmd
.tms
);
820 ublast_usleep(cmd
->cmd
.sleep
->us
);
823 ret
= ublast_scan(cmd
->cmd
.scan
);
828 ublast_flush_buffer();
833 * ublast_init - Initialize the Altera device
835 * Initialize the device :
836 * - open the USB device
837 * - pretend it's initialized while actual init is delayed until first jtag command
839 * Returns ERROR_OK if USB device found, error if not.
841 static int ublast_init(void)
845 if (info
.lowlevel_name
) {
846 for (i
= 0; lowlevel_drivers_map
[i
].name
; i
++)
847 if (!strcmp(lowlevel_drivers_map
[i
].name
, info
.lowlevel_name
))
849 if (lowlevel_drivers_map
[i
].name
)
850 info
.drv
= lowlevel_drivers_map
[i
].drv_register();
852 LOG_ERROR("no lowlevel driver found for %s or lowlevel driver opening error",
854 return ERROR_JTAG_DEVICE_ERROR
;
857 LOG_INFO("No lowlevel driver configured, will try them all");
858 for (i
= 0; !info
.drv
&& lowlevel_drivers_map
[i
].name
; i
++)
859 info
.drv
= lowlevel_drivers_map
[i
].drv_register();
861 LOG_ERROR("no lowlevel driver found");
862 return ERROR_JTAG_DEVICE_ERROR
;
864 info
.lowlevel_name
= strdup(lowlevel_drivers_map
[i
-1].name
);
868 * Register the lowlevel driver
870 info
.drv
->ublast_vid
= info
.ublast_vid
;
871 info
.drv
->ublast_pid
= info
.ublast_pid
;
872 info
.drv
->ublast_vid_uninit
= info
.ublast_vid_uninit
;
873 info
.drv
->ublast_pid_uninit
= info
.ublast_pid_uninit
;
874 info
.drv
->ublast_device_desc
= info
.ublast_device_desc
;
875 info
.drv
->firmware_path
= info
.firmware_path
;
877 info
.flags
|= info
.drv
->flags
;
879 ret
= info
.drv
->open(info
.drv
);
882 * Let lie here : the TAP is in an unknown state, but the first
883 * execute_queue() will trigger a ublast_initial_wipeout(), which will
884 * put the TAP in RESET.
886 tap_set_state(TAP_RESET
);
891 * ublast_quit - Release the Altera device
893 * Releases the device :
894 * - put the device pins in 'high impedance' mode
895 * - close the USB device
897 * Returns always ERROR_OK
899 static int ublast_quit(void)
904 ublast_buf_write(&byte0
, 1, &retlen
);
905 return info
.drv
->close(info
.drv
);
908 COMMAND_HANDLER(ublast_handle_device_desc_command
)
911 return ERROR_COMMAND_SYNTAX_ERROR
;
913 info
.ublast_device_desc
= strdup(CMD_ARGV
[0]);
918 COMMAND_HANDLER(ublast_handle_vid_pid_command
)
921 LOG_WARNING("ignoring extra IDs in ublast_vid_pid "
922 "(maximum is 2 pairs)");
927 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], info
.ublast_vid
);
928 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], info
.ublast_pid
);
930 LOG_WARNING("incomplete ublast_vid_pid configuration");
934 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[2], info
.ublast_vid_uninit
);
935 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[3], info
.ublast_pid_uninit
);
937 LOG_WARNING("incomplete ublast_vid_pid configuration");
943 COMMAND_HANDLER(ublast_handle_pin_command
)
946 const char * const pin_name
= CMD_ARGV
[0];
947 enum gpio_steer
*steer
= NULL
;
948 static const char * const pin_val_str
[] = {
951 [SRST
] = "SRST driven",
952 [TRST
] = "TRST driven",
956 LOG_ERROR("%s takes exactly one or two arguments", CMD_NAME
);
957 return ERROR_COMMAND_SYNTAX_ERROR
;
960 if (!strcmp(pin_name
, "pin6"))
962 if (!strcmp(pin_name
, "pin8"))
965 LOG_ERROR("%s: pin name must be \"pin6\" or \"pin8\"",
967 return ERROR_COMMAND_SYNTAX_ERROR
;
971 LOG_INFO("%s: %s is set as %s\n", CMD_NAME
, pin_name
,
972 pin_val_str
[*steer
]);
976 const char * const pin_value
= CMD_ARGV
[1];
977 char val
= pin_value
[0];
979 if (strlen(pin_value
) > 1)
981 switch (tolower((unsigned char)val
)) {
995 LOG_ERROR("%s: pin value must be 0, 1, s (SRST) or t (TRST)",
997 return ERROR_COMMAND_SYNTAX_ERROR
;
1001 out_value
= ublast_build_out(SCAN_OUT
);
1002 ublast_queue_byte(out_value
);
1003 ublast_flush_buffer();
1009 COMMAND_HANDLER(ublast_handle_lowlevel_drv_command
)
1012 return ERROR_COMMAND_SYNTAX_ERROR
;
1014 info
.lowlevel_name
= strdup(CMD_ARGV
[0]);
1019 COMMAND_HANDLER(ublast_firmware_command
)
1022 return ERROR_COMMAND_SYNTAX_ERROR
;
1024 info
.firmware_path
= strdup(CMD_ARGV
[0]);
1030 static const struct command_registration ublast_command_handlers
[] = {
1032 .name
= "usb_blaster_device_desc",
1033 .handler
= ublast_handle_device_desc_command
,
1034 .mode
= COMMAND_CONFIG
,
1035 .help
= "set the USB device description of the USB-Blaster",
1036 .usage
= "description-string",
1039 .name
= "usb_blaster_vid_pid",
1040 .handler
= ublast_handle_vid_pid_command
,
1041 .mode
= COMMAND_CONFIG
,
1042 .help
= "the vendor ID and product ID of the USB-Blaster and " \
1043 "vendor ID and product ID of the uninitialized device " \
1044 "for USB-Blaster II",
1045 .usage
= "vid pid vid_uninit pid_uninit",
1048 .name
= "usb_blaster_lowlevel_driver",
1049 .handler
= ublast_handle_lowlevel_drv_command
,
1050 .mode
= COMMAND_CONFIG
,
1051 .help
= "set the lowlevel access for the USB Blaster (ftdi, ftd2xx, ublast2)",
1052 .usage
= "(ftdi|ftd2xx|ublast2)",
1055 .name
= "usb_blaster_pin",
1056 .handler
= ublast_handle_pin_command
,
1057 .mode
= COMMAND_ANY
,
1058 .help
= "show or set pin state for the unused GPIO pins",
1059 .usage
= "(pin6|pin8) (0|1|s|t)",
1062 .name
= "usb_blaster_firmware",
1063 .handler
= &ublast_firmware_command
,
1064 .mode
= COMMAND_CONFIG
,
1065 .help
= "configure the USB-Blaster II firmware location",
1066 .usage
= "path/to/blaster_xxxx.hex",
1068 COMMAND_REGISTRATION_DONE
1071 struct jtag_interface usb_blaster_interface
= {
1072 .name
= "usb_blaster",
1073 .commands
= ublast_command_handlers
,
1074 .supported
= DEBUG_CAP_TMS_SEQ
,
1076 .execute_queue
= ublast_execute_queue
,
1077 .init
= ublast_init
,
1078 .quit
= ublast_quit
,
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)