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 <helper/replacements.h>
81 #include "ublast_access.h"
90 /* Size of USB endpoint max packet size, ie. 64 bytes */
91 #define MAX_PACKET_SIZE 64
93 * Size of data buffer that holds bytes in byte-shift mode.
94 * This buffer can hold multiple USB packets aligned to
95 * MAX_PACKET_SIZE bytes boundaries.
96 * BUF_LEN must be grater than or equal MAX_PACKET_SIZE.
100 /* USB-Blaster II specific command */
101 #define CMD_COPY_TDO_BUFFER 0x5F
111 enum gpio_steer pin6
;
112 enum gpio_steer pin8
;
117 uint8_t buf
[BUF_LEN
];
121 struct ublast_lowlevel
*drv
;
122 char *ublast_device_desc
;
123 uint16_t ublast_vid
, ublast_pid
;
124 uint16_t ublast_vid_uninit
, ublast_pid_uninit
;
130 * Global device control
132 static struct ublast_info info
= {
133 .ublast_vid
= 0x09fb, /* Altera */
134 .ublast_pid
= 0x6001, /* USB-Blaster */
135 .lowlevel_name
= NULL
,
136 .srst_asserted
= false,
137 .trst_asserted
= false,
143 * Available lowlevel drivers (FTDI, FTD2xx, ...)
147 struct ublast_lowlevel
*(*drv_register
)(void);
150 static struct drvs_map lowlevel_drivers_map
[] = {
151 #if BUILD_USB_BLASTER
152 { .name
= "ftdi", .drv_register
= ublast_register_ftdi
},
154 #if BUILD_USB_BLASTER_2
155 { .name
= "ublast2", .drv_register
= ublast2_register_libusb
},
161 * Access functions to lowlevel driver, agnostic of libftdi/libftdxx
163 static char *hexdump(uint8_t *buf
, unsigned int size
)
166 char *str
= calloc(size
* 2 + 1, 1);
168 for (i
= 0; i
< size
; i
++)
169 sprintf(str
+ 2*i
, "%02x", buf
[i
]);
173 static int ublast_buf_read(uint8_t *buf
, unsigned size
, uint32_t *bytes_read
)
175 int ret
= info
.drv
->read(info
.drv
, buf
, size
, bytes_read
);
176 char *str
= hexdump(buf
, *bytes_read
);
178 LOG_DEBUG_IO("(size=%d, buf=[%s]) -> %" PRIu32
, size
, str
,
184 static int ublast_buf_write(uint8_t *buf
, int size
, uint32_t *bytes_written
)
186 int ret
= info
.drv
->write(info
.drv
, buf
, size
, bytes_written
);
187 char *str
= hexdump(buf
, *bytes_written
);
189 LOG_DEBUG_IO("(size=%d, buf=[%s]) -> %" PRIu32
, size
, str
,
195 static int nb_buf_remaining(void)
197 return BUF_LEN
- info
.bufidx
;
200 static void ublast_flush_buffer(void)
203 int nb
= info
.bufidx
, ret
= ERROR_OK
;
205 while (ret
== ERROR_OK
&& nb
> 0) {
206 ret
= ublast_buf_write(info
.buf
, nb
, &retlen
);
213 * Actually, the USB-Blaster offers a byte-shift mode to transmit up to 504 data
214 * bits (bidirectional) in a single USB packet. A header byte has to be sent as
215 * the first byte in a packet with the following meaning:
217 * Bit 7 (0x80): Must be set to indicate byte-shift mode.
218 * Bit 6 (0x40): If set, the USB-Blaster will also read data, not just write.
219 * Bit 5..0: Define the number N of following bytes
221 * All N following bytes will then be clocked out serially on TDI. If Bit 6 was
222 * set, it will afterwards return N bytes with TDO data read while clocking out
223 * the TDI data. LSB of the first byte after the header byte will appear first
227 /* Simple bit banging mode:
229 * Bit 7 (0x80): Must be zero (see byte-shift mode above)
230 * Bit 6 (0x40): If set, you will receive a byte indicating the state of TDO
232 * Bit 5 (0x20): Output Enable/LED.
233 * Bit 4 (0x10): TDI Output.
234 * Bit 3 (0x08): nCS Output (not used in JTAG mode).
235 * Bit 2 (0x04): nCE Output (not used in JTAG mode).
236 * Bit 1 (0x02): TMS Output.
237 * Bit 0 (0x01): TCK Output.
239 * For transmitting a single data bit, you need to write two bytes (one for
240 * setting up TDI/TMS/TCK=0, and one to trigger TCK high with same TDI/TMS
241 * held). Up to 64 bytes can be combined in a single USB packet.
242 * It isn't possible to read a data without transmitting data.
251 #define READ (1 << 6)
252 #define SHMODE (1 << 7)
253 #define READ_TDO (1 << 0)
256 * ublast_queue_byte - queue one 'bitbang mode' byte for USB Blaster
257 * @param abyte the byte to queue
259 * Queues one byte in 'bitbang mode' to the USB Blaster. The byte is not
260 * actually sent, but stored in a buffer. The write is performed once
261 * the buffer is filled, or if an explicit ublast_flush_buffer() is called.
263 static void ublast_queue_byte(uint8_t abyte
)
265 if (nb_buf_remaining() < 1)
266 ublast_flush_buffer();
267 info
.buf
[info
.bufidx
++] = abyte
;
268 if (nb_buf_remaining() == 0)
269 ublast_flush_buffer();
270 LOG_DEBUG_IO("(byte=0x%02x)", abyte
);
274 * ublast_compute_pin - compute if gpio should be asserted
275 * @param steer control (ie. TRST driven, SRST driven, of fixed)
277 * Returns pin value (1 means driven high, 0 mean driven low)
279 static bool ublast_compute_pin(enum gpio_steer steer
)
287 return !info
.srst_asserted
;
289 return !info
.trst_asserted
;
296 * ublast_build_out - build bitbang mode output byte
297 * @param type says if reading back TDO is required
299 * Returns the compute bitbang mode byte
301 static uint8_t ublast_build_out(enum scan_type type
)
305 abyte
|= info
.tms
? TMS
: 0;
306 abyte
|= ublast_compute_pin(info
.pin6
) ? NCE
: 0;
307 abyte
|= ublast_compute_pin(info
.pin8
) ? NCS
: 0;
308 abyte
|= info
.tdi
? TDI
: 0;
310 if (type
== SCAN_IN
|| type
== SCAN_IO
)
316 * ublast_reset - reset the JTAG device is possible
317 * @param trst 1 if TRST is to be asserted
318 * @param srst 1 if SRST is to be asserted
320 static void ublast_reset(int trst
, int srst
)
324 info
.trst_asserted
= trst
;
325 info
.srst_asserted
= srst
;
326 out_value
= ublast_build_out(SCAN_OUT
);
327 ublast_queue_byte(out_value
);
328 ublast_flush_buffer();
332 * ublast_clock_tms - clock a TMS transition
333 * @param tms the TMS to be sent
335 * Triggers a TMS transition (ie. one JTAG TAP state move).
337 static void ublast_clock_tms(int tms
)
341 LOG_DEBUG_IO("(tms=%d)", !!tms
);
344 out
= ublast_build_out(SCAN_OUT
);
345 ublast_queue_byte(out
);
346 ublast_queue_byte(out
| TCK
);
350 * ublast_idle_clock - put back TCK to low level
352 * See ublast_queue_tdi() comment for the usage of this function.
354 static void ublast_idle_clock(void)
356 uint8_t out
= ublast_build_out(SCAN_OUT
);
359 ublast_queue_byte(out
);
363 * ublast_clock_tdi - Output a TDI with bitbang mode
364 * @param tdi the TDI bit to be shifted out
365 * @param type scan type (ie. does a readback of TDO is required)
367 * Output a TDI bit and assert clock to push it into the JTAG device :
368 * - writing out TCK=0, TMS=\<old_state>=0, TDI=\<tdi>
369 * - writing out TCK=1, TMS=\<new_state>, TDI=\<tdi> which triggers the JTAG
370 * device acquiring the data.
372 * If a TDO is to be read back, the required read is requested (bitbang mode),
373 * and the USB Blaster will send back a byte with bit0 representing the TDO.
375 static void ublast_clock_tdi(int tdi
, enum scan_type type
)
379 LOG_DEBUG_IO("(tdi=%d)", !!tdi
);
382 out
= ublast_build_out(SCAN_OUT
);
383 ublast_queue_byte(out
);
385 out
= ublast_build_out(type
);
386 ublast_queue_byte(out
| TCK
);
390 * ublast_clock_tdi_flip_tms - Output a TDI with bitbang mode, change JTAG state
391 * @param tdi the TDI bit to be shifted out
392 * @param type scan type (ie. does a readback of TDO is required)
394 * This function is the same as ublast_clock_tdi(), but it changes also the TMS
395 * while output the TDI. This should be the last TDI output of a TDI
396 * sequence, which will change state from :
397 * - IRSHIFT -> IREXIT1
398 * - or DRSHIFT -> DREXIT1
400 static void ublast_clock_tdi_flip_tms(int tdi
, enum scan_type type
)
404 LOG_DEBUG_IO("(tdi=%d)", !!tdi
);
406 info
.tms
= !info
.tms
;
408 out
= ublast_build_out(SCAN_OUT
);
409 ublast_queue_byte(out
);
411 out
= ublast_build_out(type
);
412 ublast_queue_byte(out
| TCK
);
414 out
= ublast_build_out(SCAN_OUT
);
415 ublast_queue_byte(out
);
419 * ublast_queue_bytes - queue bytes for the USB Blaster
420 * @param bytes byte array
421 * @param nb_bytes number of bytes
423 * Queues bytes to be sent to the USB Blaster. The bytes are not
424 * actually sent, but stored in a buffer. The write is performed once
425 * the buffer is filled, or if an explicit ublast_flush_buffer() is called.
427 static void ublast_queue_bytes(uint8_t *bytes
, int nb_bytes
)
429 if (info
.bufidx
+ nb_bytes
> BUF_LEN
) {
430 LOG_ERROR("buggy code, should never queue more that %d bytes",
431 info
.bufidx
+ nb_bytes
);
434 LOG_DEBUG_IO("(nb_bytes=%d, bytes=[0x%02x, ...])", nb_bytes
,
435 bytes
? bytes
[0] : 0);
437 memcpy(&info
.buf
[info
.bufidx
], bytes
, nb_bytes
);
439 memset(&info
.buf
[info
.bufidx
], 0, nb_bytes
);
440 info
.bufidx
+= nb_bytes
;
441 if (nb_buf_remaining() == 0)
442 ublast_flush_buffer();
446 * ublast_tms_seq - write a TMS sequence transition to JTAG
447 * @param bits TMS bits to be written (bit0, bit1 .. bitN)
448 * @param nb_bits number of TMS bits (between 1 and 8)
449 * @param skip number of TMS bits to skip at the beginning of the series
451 * Write a series of TMS transitions, where each transition consists in :
452 * - writing out TCK=0, TMS=\<new_state>, TDI=\<???>
453 * - writing out TCK=1, TMS=\<new_state>, TDI=\<???> which triggers the transition
454 * The function ensures that at the end of the sequence, the clock (TCK) is put
457 static void ublast_tms_seq(const uint8_t *bits
, int nb_bits
, int skip
)
461 LOG_DEBUG_IO("(bits=%02x..., nb_bits=%d)", bits
[0], nb_bits
);
462 for (i
= skip
; i
< nb_bits
; i
++)
463 ublast_clock_tms((bits
[i
/ 8] >> (i
% 8)) & 0x01);
468 * ublast_tms - write a tms command
469 * @param cmd tms command
471 static void ublast_tms(struct tms_command
*cmd
)
473 LOG_DEBUG_IO("(num_bits=%d)", cmd
->num_bits
);
474 ublast_tms_seq(cmd
->bits
, cmd
->num_bits
, 0);
478 * ublast_path_move - write a TMS sequence transition to JTAG
479 * @param cmd path transition
481 * Write a series of TMS transitions, where each transition consists in :
482 * - writing out TCK=0, TMS=\<new_state>, TDI=\<???>
483 * - writing out TCK=1, TMS=\<new_state>, TDI=\<???> which triggers the transition
484 * The function ensures that at the end of the sequence, the clock (TCK) is put
487 static void ublast_path_move(struct pathmove_command
*cmd
)
491 LOG_DEBUG_IO("(num_states=%d, last_state=%d)",
492 cmd
->num_states
, cmd
->path
[cmd
->num_states
- 1]);
493 for (i
= 0; i
< cmd
->num_states
; i
++) {
494 if (tap_state_transition(tap_get_state(), false) == cmd
->path
[i
])
496 if (tap_state_transition(tap_get_state(), true) == cmd
->path
[i
])
498 tap_set_state(cmd
->path
[i
]);
504 * ublast_state_move - move JTAG state to the target state
505 * @param state the target state
506 * @param skip number of bits to skip at the beginning of the path
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
, int skip
)
516 LOG_DEBUG_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
, skip
);
523 tap_set_state(state
);
527 * ublast_read_byteshifted_tdos - read TDO of byteshift writes
528 * @param buf the buffer to store the bits
529 * @param nb_bytes the number of bytes
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 occurred
540 static int ublast_read_byteshifted_tdos(uint8_t *buf
, int nb_bytes
)
545 LOG_DEBUG_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 * @param buf the buffer to store the bits
557 * @param 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 stored in byte0, bit 7
565 * - ninth bit is stored in byte1, bit 0
568 * Returns ERROR_OK if OK, ERROR_xxx if a read error occurred
570 static int ublast_read_bitbang_tdos(uint8_t *buf
, int nb_bits
)
573 int i
, ret
= ERROR_OK
;
577 LOG_DEBUG_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 * @param bits bits to be queued on TDI (or NULL if 0 are to be queued)
597 * @param nb_bits number of bits
598 * @param scan scan type (ie. if TDO read back is required or not)
600 * Outputs a series 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 LOG_DEBUG_IO("%s(cycles=%i, end_state=%d)", __func__
, cycles
, state
);
694 ublast_state_move(TAP_IDLE
, 0);
695 ublast_queue_tdi(NULL
, cycles
, SCAN_OUT
);
696 ublast_state_move(state
, 0);
699 static void ublast_stableclocks(int cycles
)
701 LOG_DEBUG_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 * @param 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 occurred.
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
, 0);
728 ublast_state_move(TAP_DRSHIFT
, 0);
730 log_buf
= hexdump(buf
, DIV_ROUND_UP(scan_bits
, 8));
731 LOG_DEBUG_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
);
739 ret
= jtag_read_buffer(buf
, cmd
);
742 * ublast_queue_tdi sends the last bit with TMS=1. We are therefore
743 * already in Exit1-DR/IR and have to skip the first step on our way
746 ublast_state_move(cmd
->end_state
, 1);
750 static void ublast_usleep(int us
)
752 LOG_DEBUG_IO("%s(us=%d)", __func__
, us
);
756 static void ublast_initial_wipeout(void)
758 static uint8_t tms_reset
= 0xff;
763 out_value
= ublast_build_out(SCAN_OUT
);
764 for (i
= 0; i
< BUF_LEN
; i
++)
765 info
.buf
[i
] = out_value
| ((i
% 2) ? TCK
: 0);
768 * Flush USB-Blaster queue fifos
769 * - empty the write FIFO (128 bytes)
770 * - empty the read FIFO (384 bytes)
772 ublast_buf_write(info
.buf
, BUF_LEN
, &retlen
);
774 * Put JTAG in RESET state (five 1 on TMS)
776 ublast_tms_seq(&tms_reset
, 5, 0);
777 tap_set_state(TAP_RESET
);
780 static int ublast_execute_queue(void)
782 struct jtag_command
*cmd
;
783 static int first_call
= 1;
788 ublast_initial_wipeout();
791 for (cmd
= jtag_command_queue
; ret
== ERROR_OK
&& cmd
;
795 ublast_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
798 ublast_runtest(cmd
->cmd
.runtest
->num_cycles
,
799 cmd
->cmd
.runtest
->end_state
);
801 case JTAG_STABLECLOCKS
:
802 ublast_stableclocks(cmd
->cmd
.stableclocks
->num_cycles
);
805 ublast_state_move(cmd
->cmd
.statemove
->end_state
, 0);
808 ublast_path_move(cmd
->cmd
.pathmove
);
811 ublast_tms(cmd
->cmd
.tms
);
814 ublast_usleep(cmd
->cmd
.sleep
->us
);
817 ret
= ublast_scan(cmd
->cmd
.scan
);
820 LOG_ERROR("BUG: unknown JTAG command type 0x%X",
827 ublast_flush_buffer();
832 * ublast_init - Initialize the Altera device
834 * Initialize the device :
835 * - open the USB device
836 * - pretend it's initialized while actual init is delayed until first jtag command
838 * Returns ERROR_OK if USB device found, error if not.
840 static int ublast_init(void)
844 for (i
= 0; lowlevel_drivers_map
[i
].name
; i
++) {
845 if (info
.lowlevel_name
) {
846 if (!strcmp(lowlevel_drivers_map
[i
].name
, info
.lowlevel_name
)) {
847 info
.drv
= lowlevel_drivers_map
[i
].drv_register();
849 LOG_ERROR("Error registering lowlevel driver \"%s\"",
851 return ERROR_JTAG_DEVICE_ERROR
;
856 info
.drv
= lowlevel_drivers_map
[i
].drv_register();
858 info
.lowlevel_name
= strdup(lowlevel_drivers_map
[i
].name
);
859 LOG_INFO("No lowlevel driver configured, using %s", info
.lowlevel_name
);
866 LOG_ERROR("No lowlevel driver available");
867 return ERROR_JTAG_DEVICE_ERROR
;
871 * Register the lowlevel driver
873 info
.drv
->ublast_vid
= info
.ublast_vid
;
874 info
.drv
->ublast_pid
= info
.ublast_pid
;
875 info
.drv
->ublast_vid_uninit
= info
.ublast_vid_uninit
;
876 info
.drv
->ublast_pid_uninit
= info
.ublast_pid_uninit
;
877 info
.drv
->ublast_device_desc
= info
.ublast_device_desc
;
878 info
.drv
->firmware_path
= info
.firmware_path
;
880 info
.flags
|= info
.drv
->flags
;
882 ret
= info
.drv
->open(info
.drv
);
885 * Let lie here : the TAP is in an unknown state, but the first
886 * execute_queue() will trigger a ublast_initial_wipeout(), which will
887 * put the TAP in RESET.
889 tap_set_state(TAP_RESET
);
894 * ublast_quit - Release the Altera device
896 * Releases the device :
897 * - put the device pins in 'high impedance' mode
898 * - close the USB device
900 * Returns always ERROR_OK
902 static int ublast_quit(void)
907 ublast_buf_write(&byte0
, 1, &retlen
);
908 return info
.drv
->close(info
.drv
);
911 COMMAND_HANDLER(ublast_handle_device_desc_command
)
914 return ERROR_COMMAND_SYNTAX_ERROR
;
916 info
.ublast_device_desc
= strdup(CMD_ARGV
[0]);
921 COMMAND_HANDLER(ublast_handle_vid_pid_command
)
924 LOG_WARNING("ignoring extra IDs in ublast_vid_pid "
925 "(maximum is 2 pairs)");
930 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], info
.ublast_vid
);
931 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], info
.ublast_pid
);
933 LOG_WARNING("incomplete ublast_vid_pid configuration");
937 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[2], info
.ublast_vid_uninit
);
938 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[3], info
.ublast_pid_uninit
);
940 LOG_WARNING("incomplete ublast_vid_pid configuration");
946 COMMAND_HANDLER(ublast_handle_pin_command
)
949 const char * const pin_name
= CMD_ARGV
[0];
950 enum gpio_steer
*steer
= NULL
;
951 static const char * const pin_val_str
[] = {
954 [SRST
] = "SRST driven",
955 [TRST
] = "TRST driven",
959 LOG_ERROR("%s takes exactly one or two arguments", CMD_NAME
);
960 return ERROR_COMMAND_SYNTAX_ERROR
;
963 if (!strcmp(pin_name
, "pin6"))
965 if (!strcmp(pin_name
, "pin8"))
968 LOG_ERROR("%s: pin name must be \"pin6\" or \"pin8\"",
970 return ERROR_COMMAND_SYNTAX_ERROR
;
974 LOG_INFO("%s: %s is set as %s\n", CMD_NAME
, pin_name
,
975 pin_val_str
[*steer
]);
979 const char * const pin_value
= CMD_ARGV
[1];
980 char val
= pin_value
[0];
982 if (strlen(pin_value
) > 1)
984 switch (tolower((unsigned char)val
)) {
998 LOG_ERROR("%s: pin value must be 0, 1, s (SRST) or t (TRST)",
1000 return ERROR_COMMAND_SYNTAX_ERROR
;
1004 out_value
= ublast_build_out(SCAN_OUT
);
1005 ublast_queue_byte(out_value
);
1006 ublast_flush_buffer();
1012 COMMAND_HANDLER(ublast_handle_lowlevel_drv_command
)
1015 return ERROR_COMMAND_SYNTAX_ERROR
;
1017 info
.lowlevel_name
= strdup(CMD_ARGV
[0]);
1022 COMMAND_HANDLER(ublast_firmware_command
)
1025 return ERROR_COMMAND_SYNTAX_ERROR
;
1027 info
.firmware_path
= strdup(CMD_ARGV
[0]);
1033 static const struct command_registration ublast_subcommand_handlers
[] = {
1035 .name
= "device_desc",
1036 .handler
= ublast_handle_device_desc_command
,
1037 .mode
= COMMAND_CONFIG
,
1038 .help
= "set the USB device description of the USB-Blaster",
1039 .usage
= "description-string",
1043 .handler
= ublast_handle_vid_pid_command
,
1044 .mode
= COMMAND_CONFIG
,
1045 .help
= "the vendor ID and product ID of the USB-Blaster and "
1046 "vendor ID and product ID of the uninitialized device "
1047 "for USB-Blaster II",
1048 .usage
= "vid pid vid_uninit pid_uninit",
1051 .name
= "lowlevel_driver",
1052 .handler
= ublast_handle_lowlevel_drv_command
,
1053 .mode
= COMMAND_CONFIG
,
1054 .help
= "set the lowlevel access for the USB Blaster (ftdi, ublast2)",
1055 .usage
= "(ftdi|ublast2)",
1059 .handler
= ublast_handle_pin_command
,
1060 .mode
= COMMAND_ANY
,
1061 .help
= "show or set pin state for the unused GPIO pins",
1062 .usage
= "(pin6|pin8) (0|1|s|t)",
1066 .handler
= &ublast_firmware_command
,
1067 .mode
= COMMAND_CONFIG
,
1068 .help
= "configure the USB-Blaster II firmware location",
1069 .usage
= "path/to/blaster_xxxx.hex",
1071 COMMAND_REGISTRATION_DONE
1074 static const struct command_registration ublast_command_handlers
[] = {
1076 .name
= "usb_blaster",
1077 .mode
= COMMAND_ANY
,
1078 .help
= "perform usb_blaster management",
1079 .chain
= ublast_subcommand_handlers
,
1082 COMMAND_REGISTRATION_DONE
1085 static struct jtag_interface usb_blaster_interface
= {
1086 .supported
= DEBUG_CAP_TMS_SEQ
,
1087 .execute_queue
= ublast_execute_queue
,
1090 struct adapter_driver usb_blaster_adapter_driver
= {
1091 .name
= "usb_blaster",
1092 .transports
= jtag_only
,
1093 .commands
= ublast_command_handlers
,
1095 .init
= ublast_init
,
1096 .quit
= ublast_quit
,
1098 .jtag_ops
= &usb_blaster_interface
,