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.
26 * The following information is originally from Kolja Waschk's USB-JTAG,
27 * where it was obtained by reverse engineering an Altera USB-Blaster.
28 * See http://www.ixo.de/info/usb_jtag/ for USB-Blaster block diagram and
29 * usb_jtag-20080705-1200.zip#usb_jtag/host/openocd for protocol.
31 * The same information is also on the UrJTAG mediawiki, with some additional
32 * notes on bits marked as "unknown" by usb_jtag.
33 * (http://sourceforge.net/apps/mediawiki/urjtag/index.php?
34 * title=Cable_Altera_USB-Blaster)
36 * USB-JTAG, Altera USB-Blaster and compatibles are typically implemented as
37 * an FTDIChip FT245 followed by a CPLD which handles a two-mode protocol:
43 * __|__________ _________
45 * USB__| FTDI 245BM |__| EPM7064 |__JTAG (B_TDO,B_TDI,B_TMS,B_TCK)
46 * |_____________| |_________|
47 * __|__________ _|___________
49 * | 6 MHz XTAL | | 24 MHz Osc. |
50 * |_____________| |_____________|
52 * USB-JTAG, Altera USB-Blaster II are typically implemented as a Cypress
53 * EZ-USB FX2LP followed by a CPLD.
54 * _____________ _________
56 * USB__| EZ-USB FX2 |__| EPM570 |__JTAG (B_TDO,B_TDI,B_TMS,B_TCK)
57 * |_____________| |_________|
73 /* project specific includes */
74 #include <jtag/interface.h>
75 #include <jtag/commands.h>
76 #include <helper/time_support.h>
77 #include "ublast_access.h"
86 /* Size of USB endpoint max packet size, ie. 64 bytes */
87 #define MAX_PACKET_SIZE 64
89 * Size of data buffer that holds bytes in byte-shift mode.
90 * This buffer can hold multiple USB packets aligned to
91 * MAX_PACKET_SIZE bytes boundaries.
92 * BUF_LEN must be grater than or equal MAX_PACKET_SIZE.
96 /* USB-Blaster II specific command */
97 #define CMD_COPY_TDO_BUFFER 0x5F
107 enum gpio_steer pin6
;
108 enum gpio_steer pin8
;
113 uint8_t buf
[BUF_LEN
];
117 struct ublast_lowlevel
*drv
;
118 char *ublast_device_desc
;
119 uint16_t ublast_vid
, ublast_pid
;
120 uint16_t ublast_vid_uninit
, ublast_pid_uninit
;
126 * Global device control
128 static struct ublast_info info
= {
129 .ublast_vid
= 0x09fb, /* Altera */
130 .ublast_pid
= 0x6001, /* USB-Blaster */
131 .lowlevel_name
= NULL
,
132 .srst_asserted
= false,
133 .trst_asserted
= false,
139 * Available lowlevel drivers (FTDI, FTD2xx, ...)
143 struct ublast_lowlevel
*(*drv_register
)(void);
146 static struct drvs_map lowlevel_drivers_map
[] = {
147 #if BUILD_USB_BLASTER_LIBFTDI
148 { .name
= "ftdi", .drv_register
= ublast_register_ftdi
},
150 #if BUILD_USB_BLASTER_FTD2XX
151 { .name
= "ftd2xx", .drv_register
= ublast_register_ftd2xx
},
153 #if BUILD_USB_BLASTER_2
154 { .name
= "ublast2", .drv_register
= ublast2_register_libusb
},
160 * Access functions to lowlevel driver, agnostic of libftdi/libftdxx
162 static char *hexdump(uint8_t *buf
, unsigned int size
)
165 char *str
= calloc(size
* 2 + 1, 1);
167 for (i
= 0; i
< size
; i
++)
168 sprintf(str
+ 2*i
, "%02x", buf
[i
]);
172 static int ublast_buf_read(uint8_t *buf
, unsigned size
, uint32_t *bytes_read
)
174 int ret
= info
.drv
->read(info
.drv
, buf
, size
, bytes_read
);
175 char *str
= hexdump(buf
, *bytes_read
);
177 DEBUG_JTAG_IO("(size=%d, buf=[%s]) -> %u", size
, str
,
183 static int ublast_buf_write(uint8_t *buf
, int size
, uint32_t *bytes_written
)
185 int ret
= info
.drv
->write(info
.drv
, buf
, size
, bytes_written
);
186 char *str
= hexdump(buf
, *bytes_written
);
188 DEBUG_JTAG_IO("(size=%d, buf=[%s]) -> %u", size
, str
,
194 static int nb_buf_remaining(void)
196 return BUF_LEN
- info
.bufidx
;
199 static void ublast_flush_buffer(void)
202 int nb
= info
.bufidx
, ret
= ERROR_OK
;
204 while (ret
== ERROR_OK
&& nb
> 0) {
205 ret
= ublast_buf_write(info
.buf
, nb
, &retlen
);
212 * Actually, the USB-Blaster offers a byte-shift mode to transmit up to 504 data
213 * bits (bidirectional) in a single USB packet. A header byte has to be sent as
214 * the first byte in a packet with the following meaning:
216 * Bit 7 (0x80): Must be set to indicate byte-shift mode.
217 * Bit 6 (0x40): If set, the USB-Blaster will also read data, not just write.
218 * Bit 5..0: Define the number N of following bytes
220 * All N following bytes will then be clocked out serially on TDI. If Bit 6 was
221 * set, it will afterwards return N bytes with TDO data read while clocking out
222 * the TDI data. LSB of the first byte after the header byte will appear first
226 /* Simple bit banging mode:
228 * Bit 7 (0x80): Must be zero (see byte-shift mode above)
229 * Bit 6 (0x40): If set, you will receive a byte indicating the state of TDO
231 * Bit 5 (0x20): Output Enable/LED.
232 * Bit 4 (0x10): TDI Output.
233 * Bit 3 (0x08): nCS Output (not used in JTAG mode).
234 * Bit 2 (0x04): nCE Output (not used in JTAG mode).
235 * Bit 1 (0x02): TMS Output.
236 * Bit 0 (0x01): TCK Output.
238 * For transmitting a single data bit, you need to write two bytes (one for
239 * setting up TDI/TMS/TCK=0, and one to trigger TCK high with same TDI/TMS
240 * held). Up to 64 bytes can be combined in a single USB packet.
241 * It isn't possible to read a data without transmitting data.
250 #define READ (1 << 6)
251 #define SHMODE (1 << 7)
252 #define READ_TDO (1 << 0)
255 * ublast_queue_byte - queue one 'bitbang mode' byte for USB Blaster
256 * @abyte: the byte to queue
258 * Queues one byte in 'bitbang mode' to the USB Blaster. The byte is not
259 * actually sent, but stored in a buffer. The write is performed once
260 * the buffer is filled, or if an explicit ublast_flush_buffer() is called.
262 static void ublast_queue_byte(uint8_t abyte
)
264 if (nb_buf_remaining() < 1)
265 ublast_flush_buffer();
266 info
.buf
[info
.bufidx
++] = abyte
;
267 if (nb_buf_remaining() == 0)
268 ublast_flush_buffer();
269 DEBUG_JTAG_IO("(byte=0x%02x)", abyte
);
273 * ublast_compute_pin - compute if gpio should be asserted
274 * @steer: control (ie. TRST driven, SRST driven, of fixed)
276 * Returns pin value (1 means driven high, 0 mean driven low)
278 bool ublast_compute_pin(enum gpio_steer steer
)
286 return !info
.srst_asserted
;
288 return !info
.trst_asserted
;
295 * ublast_build_out - build bitbang mode output byte
296 * @type: says if reading back TDO is required
298 * Returns the compute bitbang mode byte
300 static uint8_t ublast_build_out(enum scan_type type
)
304 abyte
|= info
.tms
? TMS
: 0;
305 abyte
|= ublast_compute_pin(info
.pin6
) ? NCE
: 0;
306 abyte
|= ublast_compute_pin(info
.pin8
) ? NCS
: 0;
307 abyte
|= info
.tdi
? TDI
: 0;
309 if (type
== SCAN_IN
|| type
== SCAN_IO
)
315 * ublast_reset - reset the JTAG device is possible
316 * @trst: 1 if TRST is to be asserted
317 * @srst: 1 if SRST is to be asserted
319 static void ublast_reset(int trst
, int srst
)
323 info
.trst_asserted
= trst
;
324 info
.srst_asserted
= srst
;
325 out_value
= ublast_build_out(SCAN_OUT
);
326 ublast_queue_byte(out_value
);
327 ublast_flush_buffer();
331 * ublast_clock_tms - clock a TMS transition
332 * @tms: the TMS to be sent
334 * Triggers a TMS transition (ie. one JTAG TAP state move).
336 static void ublast_clock_tms(int tms
)
340 DEBUG_JTAG_IO("(tms=%d)", !!tms
);
343 out
= ublast_build_out(SCAN_OUT
);
344 ublast_queue_byte(out
);
345 ublast_queue_byte(out
| TCK
);
349 * ublast_idle_clock - put back TCK to low level
351 * See ublast_queue_tdi() comment for the usage of this function.
353 static void ublast_idle_clock(void)
355 uint8_t out
= ublast_build_out(SCAN_OUT
);
358 ublast_queue_byte(out
);
362 * ublast_clock_tdi - Output a TDI with bitbang mode
363 * @tdi: the TDI bit to be shifted out
364 * @type: scan type (ie. does a readback of TDO is required)
366 * Output a TDI bit and assert clock to push it into the JTAG device :
367 * - writing out TCK=0, TMS=<old_state>=0, TDI=<tdi>
368 * - writing out TCK=1, TMS=<new_state>, TDI=<tdi> which triggers the JTAG
369 * device aquiring the data.
371 * If a TDO is to be read back, the required read is requested (bitbang mode),
372 * and the USB Blaster will send back a byte with bit0 reprensenting the TDO.
374 static void ublast_clock_tdi(int tdi
, enum scan_type type
)
378 DEBUG_JTAG_IO("(tdi=%d)", !!tdi
);
381 out
= ublast_build_out(SCAN_OUT
);
382 ublast_queue_byte(out
);
384 out
= ublast_build_out(type
);
385 ublast_queue_byte(out
| TCK
);
389 * ublast_clock_tdi_flip_tms - Output a TDI with bitbang mode, change JTAG state
390 * @tdi: the TDI bit to be shifted out
391 * @type: scan type (ie. does a readback of TDO is required)
393 * This function is the same as ublast_clock_tdi(), but it changes also the TMS
394 * while outputing the TDI. This should be the last TDI output of a TDI
395 * sequence, which will change state from :
396 * - IRSHIFT -> IREXIT1
397 * - or DRSHIFT -> DREXIT1
399 static void ublast_clock_tdi_flip_tms(int tdi
, enum scan_type type
)
403 DEBUG_JTAG_IO("(tdi=%d)", !!tdi
);
405 info
.tms
= !info
.tms
;
407 out
= ublast_build_out(SCAN_OUT
);
408 ublast_queue_byte(out
);
410 out
= ublast_build_out(type
);
411 ublast_queue_byte(out
| TCK
);
413 out
= ublast_build_out(SCAN_OUT
);
414 ublast_queue_byte(out
);
418 * ublast_queue_bytes - queue bytes for the USB Blaster
420 * @nb_bytes: number of bytes
422 * Queues bytes to be sent to the USB Blaster. The bytes are not
423 * actually sent, but stored in a buffer. The write is performed once
424 * the buffer is filled, or if an explicit ublast_flush_buffer() is called.
426 static void ublast_queue_bytes(uint8_t *bytes
, int nb_bytes
)
428 if (info
.bufidx
+ nb_bytes
> BUF_LEN
) {
429 LOG_ERROR("buggy code, should never queue more that %d bytes",
430 info
.bufidx
+ nb_bytes
);
433 DEBUG_JTAG_IO("(nb_bytes=%d, bytes=[0x%02x, ...])", nb_bytes
,
434 bytes
? bytes
[0] : 0);
436 memcpy(&info
.buf
[info
.bufidx
], bytes
, nb_bytes
);
438 memset(&info
.buf
[info
.bufidx
], 0, nb_bytes
);
439 info
.bufidx
+= nb_bytes
;
440 if (nb_buf_remaining() == 0)
441 ublast_flush_buffer();
445 * ublast_tms_seq - write a TMS sequence transition to JTAG
446 * @bits: TMS bits to be written (bit0, bit1 .. bitN)
447 * @nb_bits: number of TMS bits (between 1 and 8)
449 * Write a serie of TMS transitions, where each transition consists in :
450 * - writing out TCK=0, TMS=<new_state>, TDI=<???>
451 * - writing out TCK=1, TMS=<new_state>, TDI=<???> which triggers the transition
452 * The function ensures that at the end of the sequence, the clock (TCK) is put
455 static void ublast_tms_seq(const uint8_t *bits
, int nb_bits
)
459 DEBUG_JTAG_IO("(bits=%02x..., nb_bits=%d)", bits
[0], nb_bits
);
460 for (i
= 0; i
< nb_bits
; i
++)
461 ublast_clock_tms((bits
[i
/ 8] >> (i
% 8)) & 0x01);
466 * ublast_tms - write a tms command
469 static void ublast_tms(struct tms_command
*cmd
)
471 DEBUG_JTAG_IO("(num_bits=%d)", cmd
->num_bits
);
472 ublast_tms_seq(cmd
->bits
, cmd
->num_bits
);
476 * ublast_path_move - write a TMS sequence transition to JTAG
477 * @cmd: path transition
479 * Write a serie of TMS transitions, where each transition consists in :
480 * - writing out TCK=0, TMS=<new_state>, TDI=<???>
481 * - writing out TCK=1, TMS=<new_state>, TDI=<???> which triggers the transition
482 * The function ensures that at the end of the sequence, the clock (TCK) is put
485 static void ublast_path_move(struct pathmove_command
*cmd
)
489 DEBUG_JTAG_IO("(num_states=%d, last_state=%d)",
490 cmd
->num_states
, cmd
->path
[cmd
->num_states
- 1]);
491 for (i
= 0; i
< cmd
->num_states
; i
++) {
492 if (tap_state_transition(tap_get_state(), false) == cmd
->path
[i
])
494 if (tap_state_transition(tap_get_state(), true) == cmd
->path
[i
])
496 tap_set_state(cmd
->path
[i
]);
502 * ublast_state_move - move JTAG state to the target state
503 * @state: the target state
505 * Input the correct TMS sequence to the JTAG TAP so that we end up in the
506 * target state. This assumes the current state (tap_get_state()) is correct.
508 static void ublast_state_move(tap_state_t state
)
513 DEBUG_JTAG_IO("(from %s to %s)", tap_state_name(tap_get_state()),
514 tap_state_name(state
));
515 if (tap_get_state() == state
)
517 tms_scan
= tap_get_tms_path(tap_get_state(), state
);
518 tms_len
= tap_get_tms_path_len(tap_get_state(), state
);
519 ublast_tms_seq(&tms_scan
, tms_len
);
520 tap_set_state(state
);
524 * ublast_read_byteshifted_tdos - read TDO of byteshift writes
525 * @buf: the buffer to store the bits
526 * @nb_bits: the number of bits
528 * Reads back from USB Blaster TDO bits, triggered by a 'byteshift write', ie. eight
529 * bits per received byte from USB interface, and store them in buffer.
531 * As the USB blaster stores the TDO bits in LSB (ie. first bit in (byte0,
532 * bit0), second bit in (byte0, bit1), ...), which is what we want to return,
533 * simply read bytes from USB interface and store them.
535 * Returns ERROR_OK if OK, ERROR_xxx if a read error occured
537 static int ublast_read_byteshifted_tdos(uint8_t *buf
, int nb_bytes
)
542 DEBUG_JTAG_IO("%s(buf=%p, num_bits=%d)", __func__
, buf
, nb_bytes
* 8);
543 ublast_flush_buffer();
544 while (ret
== ERROR_OK
&& nb_bytes
> 0) {
545 ret
= ublast_buf_read(buf
, nb_bytes
, &retlen
);
552 * ublast_read_bitbang_tdos - read TDO of bitbang writes
553 * @buf: the buffer to store the bits
554 * @nb_bits: the number of bits
556 * Reads back from USB Blaster TDO bits, triggered by a 'bitbang write', ie. one
557 * bit per received byte from USB interface, and store them in buffer, where :
558 * - first bit is stored in byte0, bit0 (LSB)
559 * - second bit is stored in byte0, bit 1
561 * - eight bit is sotred in byte0, bit 7
562 * - ninth bit is sotred in byte1, bit 0
565 * Returns ERROR_OK if OK, ERROR_xxx if a read error occured
567 static int ublast_read_bitbang_tdos(uint8_t *buf
, int nb_bits
)
570 int i
, ret
= ERROR_OK
;
574 DEBUG_JTAG_IO("%s(buf=%p, num_bits=%d)", __func__
, buf
, nb_bits
);
577 * Ensure all previous bitbang writes were issued to the dongle, so that
578 * it returns back the read values.
580 ublast_flush_buffer();
582 ret
= ublast_buf_read(tmp
, nb1
, &retlen
);
583 for (i
= 0; ret
== ERROR_OK
&& i
< nb1
; i
++)
584 if (tmp
[i
] & READ_TDO
)
592 * ublast_queue_tdi - short description
593 * @bits: bits to be queued on TDI (or NULL if 0 are to be queued)
594 * @nb_bits: number of bits
595 * @scan: scan type (ie. if TDO read back is required or not)
597 * Outputs a serie of TDI bits on TDI.
598 * As a side effect, the last TDI bit is sent along a TMS=1, and triggers a JTAG
599 * TAP state shift if input bits were non NULL.
601 * In order to not saturate the USB Blaster queues, this method reads back TDO
602 * if the scan type requests it, and stores them back in bits.
604 * As a side note, the state of TCK when entering this function *must* be
605 * low. This is because byteshift mode outputs TDI on rising TCK and reads TDO
606 * on falling TCK if and only if TCK is low before queuing byteshift mode bytes.
607 * If TCK was high, the USB blaster will queue TDI on falling edge, and read TDO
610 static void ublast_queue_tdi(uint8_t *bits
, int nb_bits
, enum scan_type scan
)
612 int nb8
= nb_bits
/ 8;
613 int nb1
= nb_bits
% 8;
614 int nbfree_in_packet
, i
, trans
= 0, read_tdos
;
615 uint8_t *tdos
= calloc(1, nb_bits
/ 8 + 1);
616 static uint8_t byte0
[BUF_LEN
];
619 * As the last TDI bit should always be output in bitbang mode in order
620 * to activate the TMS=1 transition to EXIT_?R state. Therefore a
621 * situation where nb_bits is a multiple of 8 is handled as follows:
622 * - the number of TDI shifted out in "byteshift mode" is 8 less than
625 * This ensures that nb1 is never 0, and allows the TMS transition.
627 if (nb8
> 0 && nb1
== 0) {
632 read_tdos
= (scan
== SCAN_IN
|| scan
== SCAN_IO
);
633 for (i
= 0; i
< nb8
; i
+= trans
) {
635 * Calculate number of bytes to fill USB packet of size MAX_PACKET_SIZE
637 nbfree_in_packet
= (MAX_PACKET_SIZE
- (info
.bufidx
%MAX_PACKET_SIZE
));
638 trans
= MIN(nbfree_in_packet
- 1, nb8
- i
);
641 * Queue a byte-shift mode transmission, with as many bytes as
642 * is possible with regard to :
643 * - current filling level of write buffer
644 * - remaining bytes to write in byte-shift mode
647 ublast_queue_byte(SHMODE
| READ
| trans
);
649 ublast_queue_byte(SHMODE
| trans
);
651 ublast_queue_bytes(&bits
[i
], trans
);
653 ublast_queue_bytes(byte0
, trans
);
655 if (info
.flags
& COPY_TDO_BUFFER
)
656 ublast_queue_byte(CMD_COPY_TDO_BUFFER
);
657 ublast_read_byteshifted_tdos(&tdos
[i
], trans
);
662 * Queue the remaining TDI bits in bitbang mode.
664 for (i
= 0; i
< nb1
; i
++) {
665 int tdi
= bits
? bits
[nb8
+ i
/ 8] & (1 << i
) : 0;
666 if (bits
&& i
== nb1
- 1)
667 ublast_clock_tdi_flip_tms(tdi
, scan
);
669 ublast_clock_tdi(tdi
, scan
);
671 if (nb1
&& read_tdos
) {
672 if (info
.flags
& COPY_TDO_BUFFER
)
673 ublast_queue_byte(CMD_COPY_TDO_BUFFER
);
674 ublast_read_bitbang_tdos(&tdos
[nb8
], nb1
);
678 memcpy(bits
, tdos
, DIV_ROUND_UP(nb_bits
, 8));
682 * Ensure clock is in lower state
687 static void ublast_runtest(int cycles
, tap_state_t state
)
689 DEBUG_JTAG_IO("%s(cycles=%i, end_state=%d)", __func__
, cycles
, state
);
691 ublast_state_move(TAP_IDLE
);
692 ublast_queue_tdi(NULL
, cycles
, SCAN_OUT
);
693 ublast_state_move(state
);
696 static void ublast_stableclocks(int cycles
)
698 DEBUG_JTAG_IO("%s(cycles=%i)", __func__
, cycles
);
699 ublast_queue_tdi(NULL
, cycles
, SCAN_OUT
);
703 * ublast_scan - launches a DR-scan or IR-scan
704 * @cmd: the command to launch
706 * Launch a JTAG IR-scan or DR-scan
708 * Returns ERROR_OK if OK, ERROR_xxx if a read/write error occured.
710 static int ublast_scan(struct scan_command
*cmd
)
716 static const char * const type2str
[] = { "", "SCAN_IN", "SCAN_OUT", "SCAN_IO" };
717 char *log_buf
= NULL
;
719 type
= jtag_scan_type(cmd
);
720 scan_bits
= jtag_build_buffer(cmd
, &buf
);
723 ublast_state_move(TAP_IRSHIFT
);
725 ublast_state_move(TAP_DRSHIFT
);
727 log_buf
= hexdump(buf
, DIV_ROUND_UP(scan_bits
, 8));
728 DEBUG_JTAG_IO("%s(scan=%s, type=%s, bits=%d, buf=[%s], end_state=%d)", __func__
,
729 cmd
->ir_scan
? "IRSCAN" : "DRSCAN",
731 scan_bits
, log_buf
, cmd
->end_state
);
734 ublast_queue_tdi(buf
, scan_bits
, type
);
737 * As our JTAG is in an unstable state (IREXIT1 or DREXIT1), move it
738 * forward to a stable IRPAUSE or DRPAUSE.
742 tap_set_state(TAP_IRPAUSE
);
744 tap_set_state(TAP_DRPAUSE
);
746 ret
= jtag_read_buffer(buf
, cmd
);
749 ublast_state_move(cmd
->end_state
);
753 static void ublast_usleep(int us
)
755 DEBUG_JTAG_IO("%s(us=%d)", __func__
, us
);
759 static int ublast_execute_queue(void)
761 struct jtag_command
*cmd
;
764 for (cmd
= jtag_command_queue
; ret
== ERROR_OK
&& cmd
!= NULL
;
768 ublast_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
771 ublast_runtest(cmd
->cmd
.runtest
->num_cycles
,
772 cmd
->cmd
.runtest
->end_state
);
774 case JTAG_STABLECLOCKS
:
775 ublast_stableclocks(cmd
->cmd
.stableclocks
->num_cycles
);
778 ublast_state_move(cmd
->cmd
.statemove
->end_state
);
781 ublast_path_move(cmd
->cmd
.pathmove
);
784 ublast_tms(cmd
->cmd
.tms
);
787 ublast_usleep(cmd
->cmd
.sleep
->us
);
790 ret
= ublast_scan(cmd
->cmd
.scan
);
795 ublast_flush_buffer();
800 * ublast_init - Initialize the Altera device
802 * Initialize the device :
803 * - open the USB device
804 * - empty the write FIFO (128 bytes)
805 * - empty the read FIFO (384 bytes)
807 * Returns ERROR_OK if USB device found, error if not.
809 static int ublast_init(void)
811 static uint8_t tms_reset
= 0xff;
814 if (info
.lowlevel_name
) {
815 for (i
= 0; lowlevel_drivers_map
[i
].name
; i
++)
816 if (!strcmp(lowlevel_drivers_map
[i
].name
, info
.lowlevel_name
))
818 if (lowlevel_drivers_map
[i
].name
)
819 info
.drv
= lowlevel_drivers_map
[i
].drv_register();
821 LOG_ERROR("no lowlevel driver found for %s or lowlevel driver opening error",
823 return ERROR_JTAG_DEVICE_ERROR
;
826 LOG_INFO("No lowlevel driver configured, will try them all");
827 for (i
= 0; !info
.drv
&& lowlevel_drivers_map
[i
].name
; i
++)
828 info
.drv
= lowlevel_drivers_map
[i
].drv_register();
830 LOG_ERROR("no lowlevel driver found");
831 return ERROR_JTAG_DEVICE_ERROR
;
833 info
.lowlevel_name
= strdup(lowlevel_drivers_map
[i
-1].name
);
837 * Register the lowlevel driver
839 info
.drv
->ublast_vid
= info
.ublast_vid
;
840 info
.drv
->ublast_pid
= info
.ublast_pid
;
841 info
.drv
->ublast_vid_uninit
= info
.ublast_vid_uninit
;
842 info
.drv
->ublast_pid_uninit
= info
.ublast_pid_uninit
;
843 info
.drv
->ublast_device_desc
= info
.ublast_device_desc
;
844 info
.drv
->firmware_path
= info
.firmware_path
;
846 info
.flags
|= info
.drv
->flags
;
848 ret
= info
.drv
->open(info
.drv
);
849 if (ret
== ERROR_OK
) {
851 * Flush USB-Blaster queue fifos
854 ublast_buf_write(info
.buf
, BUF_LEN
, &retlen
);
856 * Put JTAG in RESET state (five 1 on TMS)
858 ublast_tms_seq(&tms_reset
, 5);
859 tap_set_state(TAP_RESET
);
865 * ublast_quit - Release the Altera device
867 * Releases the device :
868 * - put the device pins in 'high impedance' mode
869 * - close the USB device
871 * Returns always ERROR_OK
873 static int ublast_quit(void)
878 ublast_buf_write(&byte0
, 1, &retlen
);
879 return info
.drv
->close(info
.drv
);
882 COMMAND_HANDLER(ublast_handle_device_desc_command
)
885 return ERROR_COMMAND_SYNTAX_ERROR
;
887 info
.ublast_device_desc
= strdup(CMD_ARGV
[0]);
892 COMMAND_HANDLER(ublast_handle_vid_pid_command
)
895 LOG_WARNING("ignoring extra IDs in ublast_vid_pid "
896 "(maximum is 2 pairs)");
901 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[0], info
.ublast_vid
);
902 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[1], info
.ublast_pid
);
904 LOG_WARNING("incomplete ublast_vid_pid configuration");
908 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[2], info
.ublast_vid_uninit
);
909 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[3], info
.ublast_pid_uninit
);
911 LOG_WARNING("incomplete ublast_vid_pid configuration");
917 COMMAND_HANDLER(ublast_handle_pin_command
)
920 const char * const pin_name
= CMD_ARGV
[0];
921 enum gpio_steer
*steer
= NULL
;
922 static const char * const pin_val_str
[] = {
925 [SRST
] = "SRST driven",
926 [TRST
] = "TRST driven",
930 LOG_ERROR("%s takes exactly one or two arguments", CMD_NAME
);
931 return ERROR_COMMAND_SYNTAX_ERROR
;
934 if (!strcmp(pin_name
, "pin6"))
936 if (!strcmp(pin_name
, "pin8"))
939 LOG_ERROR("%s: pin name must be \"pin6\" or \"pin8\"",
941 return ERROR_COMMAND_SYNTAX_ERROR
;
945 LOG_INFO("%s: %s is set as %s\n", CMD_NAME
, pin_name
,
946 pin_val_str
[*steer
]);
950 const char * const pin_value
= CMD_ARGV
[1];
951 char val
= pin_value
[0];
953 if (strlen(pin_value
) > 1)
955 switch (tolower(val
)) {
969 LOG_ERROR("%s: pin value must be 0, 1, s (SRST) or t (TRST)",
971 return ERROR_COMMAND_SYNTAX_ERROR
;
975 out_value
= ublast_build_out(SCAN_OUT
);
976 ublast_queue_byte(out_value
);
977 ublast_flush_buffer();
983 COMMAND_HANDLER(ublast_handle_lowlevel_drv_command
)
986 return ERROR_COMMAND_SYNTAX_ERROR
;
988 info
.lowlevel_name
= strdup(CMD_ARGV
[0]);
993 COMMAND_HANDLER(ublast_firmware_command
)
996 return ERROR_COMMAND_SYNTAX_ERROR
;
998 info
.firmware_path
= strdup(CMD_ARGV
[0]);
1004 static const struct command_registration ublast_command_handlers
[] = {
1006 .name
= "usb_blaster_device_desc",
1007 .handler
= ublast_handle_device_desc_command
,
1008 .mode
= COMMAND_CONFIG
,
1009 .help
= "set the USB device description of the USB-Blaster",
1010 .usage
= "description-string",
1013 .name
= "usb_blaster_vid_pid",
1014 .handler
= ublast_handle_vid_pid_command
,
1015 .mode
= COMMAND_CONFIG
,
1016 .help
= "the vendor ID and product ID of the USB-Blaster and " \
1017 "vendor ID and product ID of the uninitialized device " \
1018 "for USB-Blaster II",
1019 .usage
= "vid pid vid_uninit pid_uninit",
1022 .name
= "usb_blaster_lowlevel_driver",
1023 .handler
= ublast_handle_lowlevel_drv_command
,
1024 .mode
= COMMAND_CONFIG
,
1025 .help
= "set the lowlevel access for the USB Blaster (ftdi, ftd2xx, ublast2)",
1026 .usage
= "(ftdi|ftd2xx|ublast2)",
1029 .name
= "usb_blaster_pin",
1030 .handler
= ublast_handle_pin_command
,
1031 .mode
= COMMAND_ANY
,
1032 .help
= "show or set pin state for the unused GPIO pins",
1033 .usage
= "(pin6|pin8) (0|1|s|t)",
1036 .name
= "usb_blaster_firmware",
1037 .handler
= &ublast_firmware_command
,
1038 .mode
= COMMAND_CONFIG
,
1039 .help
= "configure the USB-Blaster II firmware location",
1040 .usage
= "path/to/blaster_xxxx.hex",
1042 COMMAND_REGISTRATION_DONE
1045 struct jtag_interface usb_blaster_interface
= {
1046 .name
= "usb_blaster",
1047 .commands
= ublast_command_handlers
,
1048 .supported
= DEBUG_CAP_TMS_SEQ
,
1050 .execute_queue
= ublast_execute_queue
,
1051 .init
= ublast_init
,
1052 .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)