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
,
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)