1 /***************************************************************************
2 * Copyright (C) 2007 by Benedikt Sauter *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
20 * This file is based on Dominic Rath's amt_jtagaccel.c.
22 * usbprog is a free programming adapter. You can easily install
23 * different firmware versions from an "online pool" over USB.
24 * The adapter can be used for programming and debugging AVR and ARM
25 * processors, as USB to RS232 converter, as JTAG interface or as
26 * simple I/O interface (5 lines).
28 * http://www.embedded-projects.net/usbprog
35 #include <jtag/interface.h>
36 #include <jtag/commands.h>
37 #include "usb_common.h"
48 static void usbprog_end_state(tap_state_t state
);
49 static void usbprog_state_move(void);
50 static void usbprog_path_move(struct pathmove_command
*cmd
);
51 static void usbprog_runtest(int num_cycles
);
52 static void usbprog_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
);
54 #define UNKNOWN_COMMAND 0x00
55 #define PORT_DIRECTION 0x01
58 #define PORT_SETBIT 0x04
59 #define PORT_GETBIT 0x05
60 #define WRITE_TDI 0x06
62 #define WRITE_AND_READ 0x08
63 #define WRITE_TMS 0x09
64 #define WRITE_TMS_CHAIN 0x0A
67 struct usb_dev_handle
*usb_handle
;
70 static struct usbprog_jtag
*usbprog_jtag_handle
;
72 static struct usbprog_jtag
*usbprog_jtag_open(void);
73 /* static void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag); */
74 static void usbprog_jtag_init(struct usbprog_jtag
*usbprog_jtag
);
75 static unsigned char usbprog_jtag_message(struct usbprog_jtag
*usbprog_jtag
, char *msg
, int msglen
);
77 static void usbprog_jtag_read_tdo(struct usbprog_jtag
*usbprog_jtag
, char *buffer
, int size
);
78 static void usbprog_jtag_write_tdi(struct usbprog_jtag
*usbprog_jtag
, char *buffer
, int size
);
79 static void usbprog_jtag_write_and_read(struct usbprog_jtag
*usbprog_jtag
, char *buffer
, int size
);
80 static void usbprog_jtag_write_tms(struct usbprog_jtag
*usbprog_jtag
, char tms_scan
);
82 static char tms_chain
[64];
83 static int tms_chain_index
;
85 static void usbprog_jtag_tms_collect(char tms_scan
);
86 static void usbprog_jtag_tms_send(struct usbprog_jtag
*usbprog_jtag
);
88 static void usbprog_write(int tck
, int tms
, int tdi
);
89 static void usbprog_reset(int trst
, int srst
);
91 static void usbprog_jtag_set_direction(struct usbprog_jtag
*usbprog_jtag
, unsigned char direction
);
92 static void usbprog_jtag_write_slice(struct usbprog_jtag
*usbprog_jtag
, unsigned char value
);
93 /* static unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag); */
94 static void usbprog_jtag_set_bit(struct usbprog_jtag
*usbprog_jtag
, int bit
, int value
);
95 /* static int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit); */
97 static int usbprog_execute_queue(void)
99 struct jtag_command
*cmd
= jtag_command_queue
; /* currently processed command */
107 LOG_DEBUG_IO("reset trst: %i srst %i",
108 cmd
->cmd
.reset
->trst
,
109 cmd
->cmd
.reset
->srst
);
110 if (cmd
->cmd
.reset
->trst
== 1)
111 tap_set_state(TAP_RESET
);
112 usbprog_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
115 LOG_DEBUG_IO("runtest %i cycles, end in %i",
116 cmd
->cmd
.runtest
->num_cycles
,
117 cmd
->cmd
.runtest
->end_state
);
118 usbprog_end_state(cmd
->cmd
.runtest
->end_state
);
119 usbprog_runtest(cmd
->cmd
.runtest
->num_cycles
);
122 LOG_DEBUG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
123 usbprog_end_state(cmd
->cmd
.statemove
->end_state
);
124 usbprog_state_move();
127 LOG_DEBUG_IO("pathmove: %i states, end in %i",
128 cmd
->cmd
.pathmove
->num_states
,
129 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
130 usbprog_path_move(cmd
->cmd
.pathmove
);
133 LOG_DEBUG_IO("scan end in %i", cmd
->cmd
.scan
->end_state
);
134 usbprog_end_state(cmd
->cmd
.scan
->end_state
);
135 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
136 type
= jtag_scan_type(cmd
->cmd
.scan
);
137 usbprog_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
);
138 if (jtag_read_buffer(buffer
, cmd
->cmd
.scan
) != ERROR_OK
)
139 return ERROR_JTAG_QUEUE_FAILED
;
144 LOG_DEBUG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
145 jtag_sleep(cmd
->cmd
.sleep
->us
);
148 LOG_ERROR("BUG: unknown JTAG command type encountered");
158 static int usbprog_init(void)
160 usbprog_jtag_handle
= usbprog_jtag_open();
163 if (usbprog_jtag_handle
== 0) {
164 LOG_ERROR("Can't find USB JTAG Interface! Please check connection and permissions.");
165 return ERROR_JTAG_INIT_FAILED
;
168 LOG_INFO("USB JTAG Interface ready!");
170 usbprog_jtag_init(usbprog_jtag_handle
);
172 usbprog_write(0, 0, 0);
177 static int usbprog_quit(void)
182 /*************** jtag execute commands **********************/
183 static void usbprog_end_state(tap_state_t state
)
185 if (tap_is_state_stable(state
))
186 tap_set_end_state(state
);
188 LOG_ERROR("BUG: %i is not a valid end state", state
);
193 static void usbprog_state_move(void)
195 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
197 usbprog_jtag_write_tms(usbprog_jtag_handle
, (char)tms_scan
);
199 tap_set_state(tap_get_end_state());
202 static void usbprog_path_move(struct pathmove_command
*cmd
)
204 int num_states
= cmd
->num_states
;
207 /* There may be queued transitions, and before following a specified
208 path, we must flush those queued transitions */
209 usbprog_jtag_tms_send(usbprog_jtag_handle
);
213 if (tap_state_transition(tap_get_state(), false) == cmd
->path
[state_count
]) {
215 usbprog_write(0, 0, 0);
216 usbprog_write(1, 0, 0);
217 } else if (tap_state_transition(tap_get_state(),
218 true) == cmd
->path
[state_count
]) {
220 usbprog_write(0, 1, 0);
221 usbprog_write(1, 1, 0);
223 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
224 tap_state_name(tap_get_state()),
225 tap_state_name(cmd
->path
[state_count
]));
229 tap_set_state(cmd
->path
[state_count
]);
234 tap_set_end_state(tap_get_state());
237 static void usbprog_runtest(int num_cycles
)
241 /* only do a state_move when we're not already in IDLE */
242 if (tap_get_state() != TAP_IDLE
) {
243 usbprog_end_state(TAP_IDLE
);
244 usbprog_state_move();
247 /* execute num_cycles */
248 if (num_cycles
> 0) {
249 usbprog_jtag_tms_send(usbprog_jtag_handle
);
250 usbprog_write(0, 0, 0);
252 usbprog_jtag_tms_send(usbprog_jtag_handle
);
253 /* LOG_INFO("NUM CYCLES %i",num_cycles); */
256 for (i
= 0; i
< num_cycles
; i
++) {
257 usbprog_write(1, 0, 0);
258 usbprog_write(0, 0, 0);
261 LOG_DEBUG_IO("runtest: cur_state %s end_state %s", tap_state_name(
262 tap_get_state()), tap_state_name(tap_get_end_state()));
264 /* finish in end_state */
266 usbprog_end_state(saved_end_state);
267 if (tap_get_state() != tap_get_end_state())
268 usbprog_state_move();
272 static void usbprog_scan(bool ir_scan
, enum scan_type type
, uint8_t *buffer
, int scan_size
)
274 tap_state_t saved_end_state
= tap_get_end_state();
277 usbprog_end_state(TAP_IRSHIFT
);
279 usbprog_end_state(TAP_DRSHIFT
);
281 /* Only move if we're not already there */
282 if (tap_get_state() != tap_get_end_state())
283 usbprog_state_move();
285 usbprog_end_state(saved_end_state
);
287 usbprog_jtag_tms_send(usbprog_jtag_handle
);
289 void (*f
)(struct usbprog_jtag
*usbprog_jtag
, char *buffer_local
, int size
);
292 f
= &usbprog_jtag_write_tdi
;
295 f
= &usbprog_jtag_read_tdo
;
298 f
= &usbprog_jtag_write_and_read
;
301 LOG_ERROR("unknown scan type: %i", type
);
304 f(usbprog_jtag_handle
, (char *)buffer
, scan_size
);
306 /* The adapter does the transition to PAUSE internally */
308 tap_set_state(TAP_IRPAUSE
);
310 tap_set_state(TAP_DRPAUSE
);
312 if (tap_get_state() != tap_get_end_state())
313 usbprog_state_move();
316 /*************** jtag wrapper functions *********************/
318 static void usbprog_write(int tck
, int tms
, int tdi
)
320 unsigned char output_value
= 0x00;
323 output_value
|= (1 << TMS_BIT
);
325 output_value
|= (1 << TDI_BIT
);
327 output_value
|= (1 << TCK_BIT
);
329 usbprog_jtag_write_slice(usbprog_jtag_handle
, output_value
);
332 /* (1) assert or (0) deassert reset lines */
333 static void usbprog_reset(int trst
, int srst
)
335 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
338 usbprog_jtag_set_bit(usbprog_jtag_handle
, 5, 0);
340 usbprog_jtag_set_bit(usbprog_jtag_handle
, 5, 1);
343 usbprog_jtag_set_bit(usbprog_jtag_handle
, 4, 0);
345 usbprog_jtag_set_bit(usbprog_jtag_handle
, 4, 1);
348 /*************** jtag lowlevel functions ********************/
350 struct usb_bus
*busses
;
352 struct usbprog_jtag
*usbprog_jtag_open(void)
357 const uint16_t vids
[] = { VID
, 0 };
358 const uint16_t pids
[] = { PID
, 0 };
359 struct usb_dev_handle
*dev
;
360 if (jtag_usb_open(vids
, pids
, &dev
) != ERROR_OK
)
363 struct usbprog_jtag
*tmp
= malloc(sizeof(struct usbprog_jtag
));
364 tmp
->usb_handle
= dev
;
366 usb_set_configuration(dev
, 1);
367 usb_claim_interface(dev
, 0);
368 usb_set_altinterface(dev
, 0);
374 static void usbprog_jtag_close(struct usbprog_jtag
*usbprog_jtag
)
376 usb_close(usbprog_jtag
->usb_handle
);
381 static unsigned char usbprog_jtag_message(struct usbprog_jtag
*usbprog_jtag
, char *msg
, int msglen
)
383 int res
= usb_bulk_write(usbprog_jtag
->usb_handle
, 3, msg
, msglen
, 100);
384 if ((msg
[0] == 2) || (msg
[0] == 1) || (msg
[0] == 4) || (msg
[0] == 0) ||
385 (msg
[0] == 6) || (msg
[0] == 0x0A) || (msg
[0] == 9))
388 /* LOG_INFO("HALLLLOOO %i",(int)msg[0]); */
389 res
= usb_bulk_read(usbprog_jtag
->usb_handle
, 0x82, msg
, 2, 100);
391 return (unsigned char)msg
[1];
399 static void usbprog_jtag_init(struct usbprog_jtag
*usbprog_jtag
)
401 usbprog_jtag_set_direction(usbprog_jtag
, 0xFE);
404 static void usbprog_jtag_write_and_read(struct usbprog_jtag
*usbprog_jtag
, char *buffer
, int size
)
406 char tmp
[64]; /* fastes packet size for usb controller */
407 int send_bits
, bufindex
= 0, fillindex
= 0, i
, loops
;
410 /* 61 byte can be transfered (488 bit) */
423 tmp
[0] = WRITE_AND_READ
;
424 tmp
[1] = (char)(send_bits
>> 8); /* high */
425 tmp
[2] = (char)(send_bits
); /* low */
427 for (i
= 0; i
< loops
; i
++) {
428 tmp
[3 + i
] = buffer
[bufindex
];
432 if (usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, 64, 1000) == 64) {
433 /* LOG_INFO("HALLLLOOO2 %i",(int)tmp[0]); */
436 while (usb_bulk_read(usbprog_jtag
->usb_handle
, 0x82, tmp
, 64, 1000) < 1) {
442 for (i
= 0; i
< loops
; i
++) {
444 buffer
[fillindex
++] = swap
;
450 static void usbprog_jtag_read_tdo(struct usbprog_jtag
*usbprog_jtag
, char *buffer
, int size
)
452 char tmp
[64]; /* fastes packet size for usb controller */
453 int send_bits
, fillindex
= 0, i
, loops
;
456 /* 61 byte can be transfered (488 bit) */
469 tmp
[0] = WRITE_AND_READ
;
470 tmp
[1] = (char)(send_bits
>> 8); /* high */
471 tmp
[2] = (char)(send_bits
); /* low */
473 usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, 3, 1000);
475 /* LOG_INFO("HALLLLOOO3 %i",(int)tmp[0]); */
478 while (usb_bulk_read(usbprog_jtag
->usb_handle
, 0x82, tmp
, 64, 10) < 1) {
484 for (i
= 0; i
< loops
; i
++) {
486 buffer
[fillindex
++] = swap
;
491 static void usbprog_jtag_write_tdi(struct usbprog_jtag
*usbprog_jtag
, char *buffer
, int size
)
493 char tmp
[64]; /* fastes packet size for usb controller */
494 int send_bits
, bufindex
= 0, i
, loops
;
496 /* 61 byte can be transfered (488 bit) */
505 /* if (loops == 0) */
510 tmp
[1] = (char)(send_bits
>> 8); /* high */
511 tmp
[2] = (char)(send_bits
); /* low */
513 for (i
= 0; i
< loops
; i
++) {
514 tmp
[3 + i
] = buffer
[bufindex
];
517 usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, 64, 1000);
521 static void usbprog_jtag_write_tms(struct usbprog_jtag
*usbprog_jtag
, char tms_scan
)
523 usbprog_jtag_tms_collect(tms_scan
);
526 static void usbprog_jtag_set_direction(struct usbprog_jtag
*usbprog_jtag
, unsigned char direction
)
529 tmp
[0] = PORT_DIRECTION
;
530 tmp
[1] = (char)direction
;
531 usbprog_jtag_message(usbprog_jtag
, tmp
, 2);
534 static void usbprog_jtag_write_slice(struct usbprog_jtag
*usbprog_jtag
, unsigned char value
)
538 tmp
[1] = (char)value
;
539 usbprog_jtag_message(usbprog_jtag
, tmp
, 2);
543 static unsigned char usbprog_jtag_get_port(struct usbprog_jtag
*usbprog_jtag
)
548 return usbprog_jtag_message(usbprog_jtag
, tmp
, 2);
552 static void usbprog_jtag_set_bit(struct usbprog_jtag
*usbprog_jtag
, int bit
, int value
)
555 tmp
[0] = PORT_SETBIT
;
561 usbprog_jtag_message(usbprog_jtag
, tmp
, 3);
565 static int usbprog_jtag_get_bit(struct usbprog_jtag
*usbprog_jtag
, int bit
)
568 tmp
[0] = PORT_GETBIT
;
571 if (usbprog_jtag_message(usbprog_jtag
, tmp
, 2) > 0)
578 static void usbprog_jtag_tms_collect(char tms_scan
)
580 tms_chain
[tms_chain_index
] = tms_scan
;
584 static void usbprog_jtag_tms_send(struct usbprog_jtag
*usbprog_jtag
)
587 /* LOG_INFO("TMS SEND"); */
588 if (tms_chain_index
> 0) {
589 char tmp
[tms_chain_index
+ 2];
590 tmp
[0] = WRITE_TMS_CHAIN
;
591 tmp
[1] = (char)(tms_chain_index
);
592 for (i
= 0; i
< tms_chain_index
+ 1; i
++)
593 tmp
[2 + i
] = tms_chain
[i
];
594 usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, tms_chain_index
+ 2, 1000);
599 static struct jtag_interface usbprog_interface
= {
600 .execute_queue
= usbprog_execute_queue
,
603 struct adapter_driver usbprog_adapter_driver
= {
605 .transports
= jtag_only
,
607 .init
= usbprog_init
,
608 .quit
= usbprog_quit
,
610 .jtag_ops
= &usbprog_interface
,
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)