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) 2012 Robert Jarzmik robert.jarzmik@free.fr
8 * Copyright (C) 2011 Ali Lown ali@lown.me.uk
9 * Copyright (C) 2009 Catalin Patulea cat@vv.carleton.ca
10 * Copyright (C) 2006 Kolja Waschk usbjtag@ixo.de
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
25 * The following information is originally from Kolja Waschk's USB-JTAG,
26 * where it was obtained by reverse engineering an Altera USB-Blaster.
27 * See http://www.ixo.de/info/usb_jtag/ for USB-Blaster block diagram and
28 * usb_jtag-20080705-1200.zip#usb_jtag/host/openocd for protocol.
30 * The same information is also on the UrJTAG mediawiki, with some additional
31 * notes on bits marked as "unknown" by usb_jtag.
32 * (http://sourceforge.net/apps/mediawiki/urjtag/index.php?
33 * title=Cable_Altera_USB-Blaster)
35 * USB-JTAG, Altera USB-Blaster and compatibles are typically implemented as
36 * an FTDIChip FT245 followed by a CPLD which handles a two-mode protocol:
42 * __|__________ _________
44 * USB__| FTDI 245BM |__| EPM7064 |__JTAG (B_TDO,B_TDI,B_TMS,B_TCK)
45 * |_____________| |_________|
46 * __|__________ _|___________
48 * | 6 MHz XTAL | | 24 MHz Osc. |
49 * |_____________| |_____________|
62 /* project specific includes */
63 #include <jtag/interface.h>
64 #include <jtag/commands.h>
65 #include <helper/time_support.h>
66 #include "ublast_access.h"
75 /* Size of USB endpoint max packet size, ie. 64 bytes */
76 #define MAX_PACKET_SIZE 64
78 * Size of data buffer that holds bytes in byte-shift mode.
79 * This buffer can hold multiple USB packets aligned to
80 * MAX_PACKET_SIZE bytes boundaries.
81 * BUF_LEN must be grater than or equal MAX_PACKET_SIZE.
94 struct ublast_lowlevel
*drv
;
95 char *ublast_device_desc
;
96 uint16_t ublast_vid
, ublast_pid
;
100 * Global device control
102 static struct ublast_info info
= {
103 .ublast_vid
= 0x09fb, /* Altera */
104 .ublast_pid
= 0x6001, /* USB-Blaster */
105 .lowlevel_name
= NULL
,
109 * Available lowlevel drivers (FTDI, FTD2xx, ...)
113 struct ublast_lowlevel
*(*drv_register
)(void);
116 static struct drvs_map lowlevel_drivers_map
[] = {
117 #if BUILD_USB_BLASTER_LIBFTDI
118 { .name
= "ftdi", .drv_register
= ublast_register_ftdi
},
120 #if BUILD_USB_BLASTER_FTD2XX
121 { .name
= "ftd2xx", .drv_register
= ublast_register_ftd2xx
},
127 * Access functions to lowlevel driver, agnostic of libftdi/libftdxx
129 static char *hexdump(uint8_t *buf
, unsigned int size
)
132 char *str
= calloc(size
* 2 + 1, 1);
134 for (i
= 0; i
< size
; i
++)
135 sprintf(str
+ 2*i
, "%02x", buf
[i
]);
139 static int ublast_buf_read(uint8_t *buf
, unsigned size
, uint32_t *bytes_read
)
141 int ret
= info
.drv
->read(info
.drv
, buf
, size
, bytes_read
);
142 char *str
= hexdump(buf
, *bytes_read
);
144 DEBUG_JTAG_IO("(size=%d, buf=[%s]) -> %u", size
, str
,
150 static int ublast_buf_write(uint8_t *buf
, int size
, uint32_t *bytes_written
)
152 int ret
= info
.drv
->write(info
.drv
, buf
, size
, bytes_written
);
153 char *str
= hexdump(buf
, *bytes_written
);
155 DEBUG_JTAG_IO("(size=%d, buf=[%s]) -> %u", size
, str
,
161 static int nb_buf_remaining(void)
163 return BUF_LEN
- info
.bufidx
;
166 static void ublast_flush_buffer(void)
169 int nb
= info
.bufidx
, ret
= ERROR_OK
;
171 while (ret
== ERROR_OK
&& nb
> 0) {
172 ret
= ublast_buf_write(info
.buf
, nb
, &retlen
);
179 * Actually, the USB-Blaster offers a byte-shift mode to transmit up to 504 data
180 * bits (bidirectional) in a single USB packet. A header byte has to be sent as
181 * the first byte in a packet with the following meaning:
183 * Bit 7 (0x80): Must be set to indicate byte-shift mode.
184 * Bit 6 (0x40): If set, the USB-Blaster will also read data, not just write.
185 * Bit 5..0: Define the number N of following bytes
187 * All N following bytes will then be clocked out serially on TDI. If Bit 6 was
188 * set, it will afterwards return N bytes with TDO data read while clocking out
189 * the TDI data. LSB of the first byte after the header byte will appear first
193 /* Simple bit banging mode:
195 * Bit 7 (0x80): Must be zero (see byte-shift mode above)
196 * Bit 6 (0x40): If set, you will receive a byte indicating the state of TDO
198 * Bit 5 (0x20): Output Enable/LED.
199 * Bit 4 (0x10): TDI Output.
200 * Bit 3 (0x08): nCS Output (not used in JTAG mode).
201 * Bit 2 (0x04): nCE Output (not used in JTAG mode).
202 * Bit 1 (0x02): TMS Output.
203 * Bit 0 (0x01): TCK Output.
205 * For transmitting a single data bit, you need to write two bytes (one for
206 * setting up TDI/TMS/TCK=0, and one to trigger TCK high with same TDI/TMS
207 * held). Up to 64 bytes can be combined in a single USB packet.
208 * It isn't possible to read a data without transmitting data.
217 #define READ (1 << 6)
218 #define SHMODE (1 << 7)
219 #define READ_TDO (1 << 0)
222 * ublast_reset - reset the JTAG device is possible
223 * @trst: 1 if TRST is to be asserted
224 * @srst: 1 if SRST is to be asserted
226 * This is not implemented yet. If pin6 or pin8 controlls the TRST/SRST, code
227 * should be added so that this function makes use of it.
229 static void ublast_reset(int trst
, int srst
)
231 DEBUG_JTAG_IO("TODO: ublast_reset(%d,%d) isn't implemented!",
236 * ublast_queue_byte - queue one 'bitbang mode' byte for USB Blaster
237 * @abyte: the byte to queue
239 * Queues one byte in 'bitbang mode' to the USB Blaster. The byte is not
240 * actually sent, but stored in a buffer. The write is performed once
241 * the buffer is filled, or if an explicit ublast_flush_buffer() is called.
243 static void ublast_queue_byte(uint8_t abyte
)
245 if (nb_buf_remaining() < 1)
246 ublast_flush_buffer();
247 info
.buf
[info
.bufidx
++] = abyte
;
248 if (nb_buf_remaining() == 0)
249 ublast_flush_buffer();
250 DEBUG_JTAG_IO("(byte=0x%02x)", abyte
);
254 * ublast_build_out - build bitbang mode output byte
255 * @type: says if reading back TDO is required
257 * Returns the compute bitbang mode byte
259 static uint8_t ublast_build_out(enum scan_type type
)
263 abyte
|= info
.tms
? TMS
: 0;
264 abyte
|= info
.pin6
? NCE
: 0;
265 abyte
|= info
.pin8
? NCS
: 0;
266 abyte
|= info
.tdi
? TDI
: 0;
268 if (type
== SCAN_IN
|| type
== SCAN_IO
)
274 * ublast_clock_tms - clock a TMS transition
275 * @tms: the TMS to be sent
277 * Triggers a TMS transition (ie. one JTAG TAP state move).
279 static void ublast_clock_tms(int tms
)
283 DEBUG_JTAG_IO("(tms=%d)", !!tms
);
286 out
= ublast_build_out(SCAN_OUT
);
287 ublast_queue_byte(out
);
288 ublast_queue_byte(out
| TCK
);
292 * ublast_idle_clock - put back TCK to low level
294 * See ublast_queue_tdi() comment for the usage of this function.
296 static void ublast_idle_clock(void)
298 uint8_t out
= ublast_build_out(SCAN_OUT
);
301 ublast_queue_byte(out
);
305 * ublast_clock_tdi - Output a TDI with bitbang mode
306 * @tdi: the TDI bit to be shifted out
307 * @type: scan type (ie. does a readback of TDO is required)
309 * Output a TDI bit and assert clock to push it into the JTAG device :
310 * - writing out TCK=0, TMS=<old_state>=0, TDI=<tdi>
311 * - writing out TCK=1, TMS=<new_state>, TDI=<tdi> which triggers the JTAG
312 * device aquiring the data.
314 * If a TDO is to be read back, the required read is requested (bitbang mode),
315 * and the USB Blaster will send back a byte with bit0 reprensenting the TDO.
317 static void ublast_clock_tdi(int tdi
, enum scan_type type
)
321 DEBUG_JTAG_IO("(tdi=%d)", !!tdi
);
324 out
= ublast_build_out(SCAN_OUT
);
325 ublast_queue_byte(out
);
327 out
= ublast_build_out(type
);
328 ublast_queue_byte(out
| TCK
);
332 * ublast_clock_tdi_flip_tms - Output a TDI with bitbang mode, change JTAG state
333 * @tdi: the TDI bit to be shifted out
334 * @type: scan type (ie. does a readback of TDO is required)
336 * This function is the same as ublast_clock_tdi(), but it changes also the TMS
337 * while outputing the TDI. This should be the last TDI output of a TDI
338 * sequence, which will change state from :
339 * - IRSHIFT -> IREXIT1
340 * - or DRSHIFT -> DREXIT1
342 static void ublast_clock_tdi_flip_tms(int tdi
, enum scan_type type
)
346 DEBUG_JTAG_IO("(tdi=%d)", !!tdi
);
348 info
.tms
= !info
.tms
;
350 out
= ublast_build_out(SCAN_OUT
);
351 ublast_queue_byte(out
);
353 out
= ublast_build_out(type
);
354 ublast_queue_byte(out
| TCK
);
356 out
= ublast_build_out(SCAN_OUT
);
357 ublast_queue_byte(out
);
361 * ublast_queue_bytes - queue bytes for the USB Blaster
363 * @nb_bytes: number of bytes
365 * Queues bytes to be sent to the USB Blaster. The bytes are not
366 * actually sent, but stored in a buffer. The write is performed once
367 * the buffer is filled, or if an explicit ublast_flush_buffer() is called.
369 static void ublast_queue_bytes(uint8_t *bytes
, int nb_bytes
)
371 if (info
.bufidx
+ nb_bytes
> BUF_LEN
) {
372 LOG_ERROR("buggy code, should never queue more that %d bytes",
373 info
.bufidx
+ nb_bytes
);
376 DEBUG_JTAG_IO("(nb_bytes=%d, bytes=[0x%02x, ...])", nb_bytes
,
377 bytes
? bytes
[0] : 0);
379 memcpy(&info
.buf
[info
.bufidx
], bytes
, nb_bytes
);
381 memset(&info
.buf
[info
.bufidx
], 0, nb_bytes
);
382 info
.bufidx
+= nb_bytes
;
383 if (nb_buf_remaining() == 0)
384 ublast_flush_buffer();
388 * ublast_tms_seq - write a TMS sequence transition to JTAG
389 * @bits: TMS bits to be written (bit0, bit1 .. bitN)
390 * @nb_bits: number of TMS bits (between 1 and 8)
392 * Write a serie of TMS transitions, where each transition consists in :
393 * - writing out TCK=0, TMS=<new_state>, TDI=<???>
394 * - writing out TCK=1, TMS=<new_state>, TDI=<???> which triggers the transition
395 * The function ensures that at the end of the sequence, the clock (TCK) is put
398 static void ublast_tms_seq(const uint8_t *bits
, int nb_bits
)
402 DEBUG_JTAG_IO("(bits=%02x..., nb_bits=%d)", bits
[0], nb_bits
);
403 for (i
= 0; i
< nb_bits
; i
++)
404 ublast_clock_tms((bits
[i
/ 8] >> (i
% 8)) & 0x01);
409 * ublast_tms - write a tms command
412 static void ublast_tms(struct tms_command
*cmd
)
414 DEBUG_JTAG_IO("(num_bits=%d)", cmd
->num_bits
);
415 ublast_tms_seq(cmd
->bits
, cmd
->num_bits
);
419 * ublast_path_move - write a TMS sequence transition to JTAG
420 * @cmd: path transition
422 * Write a serie of TMS transitions, where each transition consists in :
423 * - writing out TCK=0, TMS=<new_state>, TDI=<???>
424 * - writing out TCK=1, TMS=<new_state>, TDI=<???> which triggers the transition
425 * The function ensures that at the end of the sequence, the clock (TCK) is put
428 static void ublast_path_move(struct pathmove_command
*cmd
)
432 DEBUG_JTAG_IO("(num_states=%d, last_state=%d)",
433 cmd
->num_states
, cmd
->path
[cmd
->num_states
- 1]);
434 for (i
= 0; i
< cmd
->num_states
; i
++) {
435 if (tap_state_transition(tap_get_state(), false) == cmd
->path
[i
])
437 if (tap_state_transition(tap_get_state(), true) == cmd
->path
[i
])
439 tap_set_state(cmd
->path
[i
]);
445 * ublast_state_move - move JTAG state to the target state
446 * @state: the target state
448 * Input the correct TMS sequence to the JTAG TAP so that we end up in the
449 * target state. This assumes the current state (tap_get_state()) is correct.
451 static void ublast_state_move(tap_state_t state
)
456 DEBUG_JTAG_IO("(from %s to %s)", tap_state_name(tap_get_state()),
457 tap_state_name(state
));
458 if (tap_get_state() == state
)
460 tms_scan
= tap_get_tms_path(tap_get_state(), state
);
461 tms_len
= tap_get_tms_path_len(tap_get_state(), state
);
462 ublast_tms_seq(&tms_scan
, tms_len
);
463 tap_set_state(state
);
467 * ublast_read_byteshifted_tdos - read TDO of byteshift writes
468 * @buf: the buffer to store the bits
469 * @nb_bits: the number of bits
471 * Reads back from USB Blaster TDO bits, triggered by a 'byteshift write', ie. eight
472 * bits per received byte from USB interface, and store them in buffer.
474 * As the USB blaster stores the TDO bits in LSB (ie. first bit in (byte0,
475 * bit0), second bit in (byte0, bit1), ...), which is what we want to return,
476 * simply read bytes from USB interface and store them.
478 * Returns ERROR_OK if OK, ERROR_xxx if a read error occured
480 static int ublast_read_byteshifted_tdos(uint8_t *buf
, int nb_bytes
)
485 DEBUG_JTAG_IO("%s(buf=%p, num_bits=%d)", __func__
, buf
, nb_bytes
* 8);
486 ublast_flush_buffer();
487 while (ret
== ERROR_OK
&& nb_bytes
> 0) {
488 ret
= ublast_buf_read(buf
, nb_bytes
, &retlen
);
495 * ublast_read_bitbang_tdos - read TDO of bitbang writes
496 * @buf: the buffer to store the bits
497 * @nb_bits: the number of bits
499 * Reads back from USB Blaster TDO bits, triggered by a 'bitbang write', ie. one
500 * bit per received byte from USB interface, and store them in buffer, where :
501 * - first bit is stored in byte0, bit0 (LSB)
502 * - second bit is stored in byte0, bit 1
504 * - eight bit is sotred in byte0, bit 7
505 * - ninth bit is sotred in byte1, bit 0
508 * Returns ERROR_OK if OK, ERROR_xxx if a read error occured
510 static int ublast_read_bitbang_tdos(uint8_t *buf
, int nb_bits
)
513 int i
, ret
= ERROR_OK
;
517 DEBUG_JTAG_IO("%s(buf=%p, num_bits=%d)", __func__
, buf
, nb_bits
);
520 * Ensure all previous bitbang writes were issued to the dongle, so that
521 * it returns back the read values.
523 ublast_flush_buffer();
525 ret
= ublast_buf_read(tmp
, nb1
, &retlen
);
526 for (i
= 0; ret
== ERROR_OK
&& i
< nb1
; i
++)
527 if (tmp
[i
] & READ_TDO
)
535 * ublast_queue_tdi - short description
536 * @bits: bits to be queued on TDI (or NULL if 0 are to be queued)
537 * @nb_bits: number of bits
538 * @scan: scan type (ie. if TDO read back is required or not)
540 * Outputs a serie of TDI bits on TDI.
541 * As a side effect, the last TDI bit is sent along a TMS=1, and triggers a JTAG
542 * TAP state shift if input bits were non NULL.
544 * In order to not saturate the USB Blaster queues, this method reads back TDO
545 * if the scan type requests it, and stores them back in bits.
547 * As a side note, the state of TCK when entering this function *must* be
548 * low. This is because byteshift mode outputs TDI on rising TCK and reads TDO
549 * on falling TCK if and only if TCK is low before queuing byteshift mode bytes.
550 * If TCK was high, the USB blaster will queue TDI on falling edge, and read TDO
553 static void ublast_queue_tdi(uint8_t *bits
, int nb_bits
, enum scan_type scan
)
555 int nb8
= nb_bits
/ 8;
556 int nb1
= nb_bits
% 8;
557 int nbfree_in_packet
, i
, trans
= 0, read_tdos
;
558 uint8_t *tdos
= calloc(1, nb_bits
/ 8 + 1);
559 static uint8_t byte0
[BUF_LEN
];
562 * As the last TDI bit should always be output in bitbang mode in order
563 * to activate the TMS=1 transition to EXIT_?R state. Therefore a
564 * situation where nb_bits is a multiple of 8 is handled as follows:
565 * - the number of TDI shifted out in "byteshift mode" is 8 less than
568 * This ensures that nb1 is never 0, and allows the TMS transition.
570 if (nb8
> 0 && nb1
== 0) {
575 read_tdos
= (scan
== SCAN_IN
|| scan
== SCAN_IO
);
576 for (i
= 0; i
< nb8
; i
+= trans
) {
578 * Calculate number of bytes to fill USB packet of size MAX_PACKET_SIZE
580 nbfree_in_packet
= (MAX_PACKET_SIZE
- (info
.bufidx
%MAX_PACKET_SIZE
));
581 trans
= MIN(nbfree_in_packet
- 1, nb8
- i
);
584 * Queue a byte-shift mode transmission, with as many bytes as
585 * is possible with regard to :
586 * - current filling level of write buffer
587 * - remaining bytes to write in byte-shift mode
590 ublast_queue_byte(SHMODE
| READ
| trans
);
592 ublast_queue_byte(SHMODE
| trans
);
594 ublast_queue_bytes(&bits
[i
], trans
);
596 ublast_queue_bytes(byte0
, trans
);
598 ublast_read_byteshifted_tdos(&tdos
[i
], trans
);
602 * Queue the remaining TDI bits in bitbang mode.
604 for (i
= 0; i
< nb1
; i
++) {
605 int tdi
= bits
? bits
[nb8
+ i
/ 8] & (1 << i
) : 0;
606 if (bits
&& i
== nb1
- 1)
607 ublast_clock_tdi_flip_tms(tdi
, scan
);
609 ublast_clock_tdi(tdi
, scan
);
611 if (nb1
&& read_tdos
)
612 ublast_read_bitbang_tdos(&tdos
[nb8
], nb1
);
615 memcpy(bits
, tdos
, DIV_ROUND_UP(nb_bits
, 8));
619 * Ensure clock is in lower state
624 static void ublast_runtest(int cycles
, tap_state_t state
)
626 DEBUG_JTAG_IO("%s(cycles=%i, end_state=%d)", __func__
, cycles
, state
);
628 ublast_state_move(TAP_IDLE
);
629 ublast_queue_tdi(NULL
, cycles
, SCAN_OUT
);
630 ublast_state_move(state
);
633 static void ublast_stableclocks(int cycles
)
635 DEBUG_JTAG_IO("%s(cycles=%i)", __func__
, cycles
);
636 ublast_queue_tdi(NULL
, cycles
, SCAN_OUT
);
640 * ublast_scan - launches a DR-scan or IR-scan
641 * @cmd: the command to launch
643 * Launch a JTAG IR-scan or DR-scan
645 * Returns ERROR_OK if OK, ERROR_xxx if a read/write error occured.
647 static int ublast_scan(struct scan_command
*cmd
)
653 static const char * const type2str
[] = { "", "SCAN_IN", "SCAN_OUT", "SCAN_IO" };
654 char *log_buf
= NULL
;
656 type
= jtag_scan_type(cmd
);
657 scan_bits
= jtag_build_buffer(cmd
, &buf
);
660 ublast_state_move(TAP_IRSHIFT
);
662 ublast_state_move(TAP_DRSHIFT
);
664 log_buf
= hexdump(buf
, DIV_ROUND_UP(scan_bits
, 8));
665 DEBUG_JTAG_IO("%s(scan=%s, type=%s, bits=%d, buf=[%s], end_state=%d)", __func__
,
666 cmd
->ir_scan
? "IRSCAN" : "DRSCAN",
668 scan_bits
, log_buf
, cmd
->end_state
);
671 ublast_queue_tdi(buf
, scan_bits
, type
);
674 * As our JTAG is in an unstable state (IREXIT1 or DREXIT1), move it
675 * forward to a stable IRPAUSE or DRPAUSE.
679 tap_set_state(TAP_IRPAUSE
);
681 tap_set_state(TAP_DRPAUSE
);
683 ret
= jtag_read_buffer(buf
, cmd
);
686 ublast_state_move(cmd
->end_state
);
690 static void ublast_msleep(int ms
)
692 DEBUG_JTAG_IO("%s(ms=%d)", __func__
, ms
);
696 static int ublast_execute_queue(void)
698 struct jtag_command
*cmd
;
701 for (cmd
= jtag_command_queue
; ret
== ERROR_OK
&& cmd
!= NULL
;
705 ublast_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
708 ublast_runtest(cmd
->cmd
.runtest
->num_cycles
,
709 cmd
->cmd
.runtest
->end_state
);
711 case JTAG_STABLECLOCKS
:
712 ublast_stableclocks(cmd
->cmd
.stableclocks
->num_cycles
);
715 ublast_state_move(cmd
->cmd
.statemove
->end_state
);
718 ublast_path_move(cmd
->cmd
.pathmove
);
721 ublast_tms(cmd
->cmd
.tms
);
724 ublast_msleep(cmd
->cmd
.sleep
->us
);
727 ret
= ublast_scan(cmd
->cmd
.scan
);
732 ublast_flush_buffer();
737 * ublast_init - Initialize the Altera device
739 * Initialize the device :
740 * - open the USB device
741 * - empty the write FIFO (128 bytes)
742 * - empty the read FIFO (384 bytes)
744 * Returns ERROR_OK if USB device found, error if not.
746 static int ublast_init(void)
748 static uint8_t tms_reset
= 0xff;
751 if (info
.lowlevel_name
) {
752 for (i
= 0; lowlevel_drivers_map
[i
].name
; i
++)
753 if (!strcmp(lowlevel_drivers_map
[i
].name
, info
.lowlevel_name
))
755 if (lowlevel_drivers_map
[i
].name
)
756 info
.drv
= lowlevel_drivers_map
[i
].drv_register();
758 LOG_ERROR("no lowlevel driver found for %s or lowlevel driver opening error",
760 return ERROR_JTAG_DEVICE_ERROR
;
763 LOG_INFO("No lowlevel driver configured, will try them all");
764 for (i
= 0; !info
.drv
&& lowlevel_drivers_map
[i
].name
; i
++)
765 info
.drv
= lowlevel_drivers_map
[i
].drv_register();
767 LOG_ERROR("no lowlevel driver found");
768 return ERROR_JTAG_DEVICE_ERROR
;
773 * Register the lowlevel driver
775 info
.drv
->ublast_vid
= info
.ublast_vid
;
776 info
.drv
->ublast_pid
= info
.ublast_pid
;
777 info
.drv
->ublast_device_desc
= info
.ublast_device_desc
;
779 ret
= info
.drv
->open(info
.drv
);
780 if (ret
== ERROR_OK
) {
782 * Flush USB-Blaster queue fifos
785 ublast_buf_write(info
.buf
, BUF_LEN
, &retlen
);
787 * Put JTAG in RESET state (five 1 on TMS)
789 ublast_tms_seq(&tms_reset
, 5);
790 tap_set_state(TAP_RESET
);
796 * ublast_quit - Release the Altera device
798 * Releases the device :
799 * - put the device pins in 'high impedance' mode
800 * - close the USB device
802 * Returns always ERROR_OK
804 static int ublast_quit(void)
809 ublast_buf_write(&byte0
, 1, &retlen
);
810 return info
.drv
->close(info
.drv
);
813 COMMAND_HANDLER(ublast_handle_device_desc_command
)
816 info
.ublast_device_desc
= strdup(CMD_ARGV
[0]);
818 LOG_ERROR("require exactly one argument to "
819 "ublast_device_desc <description>");
824 COMMAND_HANDLER(ublast_handle_vid_pid_command
)
827 LOG_WARNING("ignoring extra IDs in ublast_vid_pid "
828 "(maximum is 1 pair)");
832 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], info
.ublast_vid
);
833 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], info
.ublast_pid
);
835 LOG_WARNING("incomplete ublast_vid_pid configuration");
841 COMMAND_HANDLER(ublast_handle_pin_command
)
846 const char * const pin_name
= CMD_ARGV
[0];
849 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[1], state
);
850 if ((state
!= 0) && (state
!= 1)) {
851 LOG_ERROR("%s: pin state must be 0 or 1", CMD_NAME
);
852 return ERROR_COMMAND_SYNTAX_ERROR
;
855 if (!strcmp(pin_name
, "pin6")) {
857 } else if (!strcmp(pin_name
, "pin8")) {
860 LOG_ERROR("%s: pin name must be \"pin6\" or \"pin8\"",
862 return ERROR_COMMAND_SYNTAX_ERROR
;
866 out_value
= ublast_build_out(SCAN_OUT
);
867 ublast_queue_byte(out_value
);
868 ublast_flush_buffer();
872 LOG_ERROR("%s takes exactly two arguments", CMD_NAME
);
873 return ERROR_COMMAND_SYNTAX_ERROR
;
877 COMMAND_HANDLER(ublast_handle_lowlevel_drv_command
)
880 info
.lowlevel_name
= strdup(CMD_ARGV
[0]);
882 LOG_ERROR("require exactly one argument to "
883 "usb_blaster_lowlevel_driver (ftdi|ftd2xx)");
887 static const struct command_registration ublast_command_handlers
[] = {
889 .name
= "usb_blaster_device_desc",
890 .handler
= ublast_handle_device_desc_command
,
891 .mode
= COMMAND_CONFIG
,
892 .help
= "set the USB device description of the USB-Blaster",
893 .usage
= "description-string",
896 .name
= "usb_blaster_vid_pid",
897 .handler
= ublast_handle_vid_pid_command
,
898 .mode
= COMMAND_CONFIG
,
899 .help
= "the vendor ID and product ID of the USB-Blaster",
903 .name
= "usb_blaster_lowlevel_driver",
904 .handler
= ublast_handle_lowlevel_drv_command
,
905 .mode
= COMMAND_CONFIG
,
906 .help
= "set the lowlevel access for the USB Blaster (ftdi, ftd2xx)",
907 .usage
= "(ftdi|ftd2xx)",
910 .name
= "usb_blaster",
911 .handler
= ublast_handle_pin_command
,
913 .help
= "set pin state for the unused GPIO pins",
914 .usage
= "(pin6|pin8) (0|1)",
916 COMMAND_REGISTRATION_DONE
919 struct jtag_interface usb_blaster_interface
= {
920 .name
= "usb_blaster",
921 .commands
= ublast_command_handlers
,
922 .supported
= DEBUG_CAP_TMS_SEQ
,
924 .execute_queue
= ublast_execute_queue
,