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, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
22 * This file is based on Dominic Rath's amt_jtagaccel.c.
24 * usbprog is a free programming adapter. You can easily install
25 * different firmware versions from an "online pool" over USB.
26 * The adapter can be used for programming and debugging AVR and ARM
27 * processors, as USB to RS232 converter, as JTAG interface or as
28 * simple I/O interface (5 lines).
30 * http://www.embedded-projects.net/usbprog
37 #define INCLUDE_JTAG_INTERFACE_H
52 static int usbprog_execute_queue(void);
53 static int usbprog_speed(int speed
);
54 static int usbprog_register_commands(struct command_context_s
*cmd_ctx
);
55 static int usbprog_init(void);
56 static int usbprog_quit(void);
58 static void usbprog_end_state(tap_state_t state
);
59 static void usbprog_state_move(void);
60 static void usbprog_path_move(pathmove_command_t
*cmd
);
61 static void usbprog_runtest(int num_cycles
);
62 static void usbprog_scan(bool ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
);
64 jtag_interface_t usbprog_interface
=
67 .execute_queue
= usbprog_execute_queue
,
68 .speed
= usbprog_speed
,
69 .register_commands
= usbprog_register_commands
,
74 #define UNKOWN_COMMAND 0x00
75 #define PORT_DIRECTION 0x01
78 #define PORT_SETBIT 0x04
79 #define PORT_GETBIT 0x05
80 #define WRITE_TDI 0x06
82 #define WRITE_AND_READ 0x08
83 #define WRITE_TMS 0x09
84 #define WRITE_TMS_CHAIN 0x0A
88 struct usb_dev_handle
* usb_handle
;
91 static struct usbprog_jtag
* usbprog_jtag_handle
;
93 static struct usbprog_jtag
* usbprog_jtag_open(void);
94 //static void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag);
95 static void usbprog_jtag_init(struct usbprog_jtag
*usbprog_jtag
);
96 static unsigned char usbprog_jtag_message(struct usbprog_jtag
*usbprog_jtag
, char *msg
, int msglen
);
98 static void usbprog_jtag_read_tdo(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
);
99 static void usbprog_jtag_write_tdi(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
);
100 static void usbprog_jtag_write_and_read(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
);
101 static void usbprog_jtag_write_tms(struct usbprog_jtag
*usbprog_jtag
, char tms_scan
);
103 static char tms_chain
[64];
104 static int tms_chain_index
;
106 static void usbprog_jtag_tms_collect(char tms_scan
);
107 static void usbprog_jtag_tms_send(struct usbprog_jtag
*usbprog_jtag
);
109 static void usbprog_write(int tck
, int tms
, int tdi
);
110 static void usbprog_reset(int trst
, int srst
);
112 static void usbprog_jtag_set_direction(struct usbprog_jtag
*usbprog_jtag
, unsigned char direction
);
113 static void usbprog_jtag_write_slice(struct usbprog_jtag
*usbprog_jtag
,unsigned char value
);
114 //static unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag);
115 static void usbprog_jtag_set_bit(struct usbprog_jtag
*usbprog_jtag
,int bit
, int value
);
116 //static int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit);
118 static int usbprog_speed(int speed
)
123 static int usbprog_register_commands(struct command_context_s
*cmd_ctx
)
128 static int usbprog_execute_queue(void)
130 jtag_command_t
*cmd
= jtag_command_queue
; /* currently processed command */
140 #ifdef _DEBUG_JTAG_IO_
141 LOG_DEBUG("reset trst: %i srst %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
143 if (cmd
->cmd
.reset
->trst
== 1)
145 tap_set_state(TAP_RESET
);
147 usbprog_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
150 #ifdef _DEBUG_JTAG_IO_
151 LOG_DEBUG("runtest %i cycles, end in %i", cmd
->cmd
.runtest
->num_cycles
, cmd
->cmd
.runtest
->end_state
);
153 if (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
)
154 usbprog_end_state(cmd
->cmd
.runtest
->end_state
);
155 usbprog_runtest(cmd
->cmd
.runtest
->num_cycles
);
158 #ifdef _DEBUG_JTAG_IO_
159 LOG_DEBUG("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
161 if (cmd
->cmd
.statemove
->end_state
!= TAP_INVALID
)
162 usbprog_end_state(cmd
->cmd
.statemove
->end_state
);
163 usbprog_state_move();
166 #ifdef _DEBUG_JTAG_IO_
167 LOG_DEBUG("pathmove: %i states, end in %i", cmd
->cmd
.pathmove
->num_states
,
168 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
170 usbprog_path_move(cmd
->cmd
.pathmove
);
173 #ifdef _DEBUG_JTAG_IO_
174 LOG_DEBUG("scan end in %i", cmd
->cmd
.scan
->end_state
);
176 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
177 usbprog_end_state(cmd
->cmd
.scan
->end_state
);
178 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
179 type
= jtag_scan_type(cmd
->cmd
.scan
);
180 usbprog_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
);
181 if (jtag_read_buffer(buffer
, cmd
->cmd
.scan
) != ERROR_OK
)
182 return ERROR_JTAG_QUEUE_FAILED
;
187 #ifdef _DEBUG_JTAG_IO_
188 LOG_DEBUG("sleep %i", cmd
->cmd
.sleep
->us
);
190 jtag_sleep(cmd
->cmd
.sleep
->us
);
193 LOG_ERROR("BUG: unknown JTAG command type encountered");
203 static int usbprog_init(void)
205 usbprog_jtag_handle
= usbprog_jtag_open();
208 if (usbprog_jtag_handle
== 0)
210 LOG_ERROR("Can't find USB JTAG Interface! Please check connection and permissions.");
211 return ERROR_JTAG_INIT_FAILED
;
214 LOG_INFO("USB JTAG Interface ready!");
216 usbprog_jtag_init(usbprog_jtag_handle
);
218 usbprog_write(0, 0, 0);
223 static int usbprog_quit(void)
228 /*************** jtag execute commands **********************/
229 static void usbprog_end_state(tap_state_t state
)
231 if (tap_is_state_stable(state
))
232 tap_set_end_state(state
);
235 LOG_ERROR("BUG: %i is not a valid end state", state
);
240 static void usbprog_state_move(void)
243 u8 tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
244 int tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
246 usbprog_jtag_write_tms(usbprog_jtag_handle
, (char)tms_scan
);
247 for (i
= 0; i
< tms_count
; i
++)
249 tms
= (tms_scan
>> i
) & 1;
252 tap_set_state(tap_get_end_state());
255 static void usbprog_path_move(pathmove_command_t
*cmd
)
257 int num_states
= cmd
->num_states
;
260 /* There may be queued transitions, and before following a specified
261 path, we must flush those queued transitions */
262 usbprog_jtag_tms_send(usbprog_jtag_handle
);
267 if (tap_state_transition(tap_get_state(), false) == cmd
->path
[state_count
])
270 usbprog_write(0, 0, 0);
271 usbprog_write(1, 0, 0);
273 else if (tap_state_transition(tap_get_state(), true) == cmd
->path
[state_count
])
276 usbprog_write(0, 1, 0);
277 usbprog_write(1, 1, 0);
281 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd
->path
[state_count
]));
285 tap_set_state(cmd
->path
[state_count
]);
290 tap_set_end_state(tap_get_state());
293 static void usbprog_runtest(int num_cycles
)
297 /* only do a state_move when we're not already in IDLE */
298 if (tap_get_state() != TAP_IDLE
)
300 usbprog_end_state(TAP_IDLE
);
301 usbprog_state_move();
304 /* execute num_cycles */
307 usbprog_jtag_tms_send(usbprog_jtag_handle
);
308 usbprog_write(0, 0, 0);
312 usbprog_jtag_tms_send(usbprog_jtag_handle
);
313 /* LOG_INFO("NUM CYCLES %i",num_cycles); */
316 for (i
= 0; i
< num_cycles
; i
++)
318 usbprog_write(1, 0, 0);
319 usbprog_write(0, 0, 0);
322 #ifdef _DEBUG_JTAG_IO_
323 LOG_DEBUG("runtest: cur_state %s end_state %s", tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state()));
326 /* finish in end_state */
328 usbprog_end_state(saved_end_state);
329 if (tap_get_state() != tap_get_end_state())
330 usbprog_state_move();
334 static void usbprog_scan(bool ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
)
336 tap_state_t saved_end_state
= tap_get_end_state();
339 usbprog_end_state(TAP_IRSHIFT
);
341 usbprog_end_state(TAP_DRSHIFT
);
343 /* Only move if we're not already there */
344 if (tap_get_state() != tap_get_end_state())
345 usbprog_state_move();
347 usbprog_end_state(saved_end_state
);
349 usbprog_jtag_tms_send(usbprog_jtag_handle
);
351 void (*f
)(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
);
353 case SCAN_OUT
: f
= &usbprog_jtag_write_tdi
; break;
354 case SCAN_IN
: f
= &usbprog_jtag_read_tdo
; break;
355 case SCAN_IO
: f
= &usbprog_jtag_write_and_read
; break;
357 LOG_ERROR("unknown scan type: %i", type
);
360 f(usbprog_jtag_handle
, (char *)buffer
, scan_size
);
362 /* The adapter does the transition to PAUSE internally */
364 tap_set_state(TAP_IRPAUSE
);
366 tap_set_state(TAP_DRPAUSE
);
368 if (tap_get_state() != tap_get_end_state())
369 usbprog_state_move();
372 /*************** jtag wrapper functions *********************/
374 static void usbprog_write(int tck
, int tms
, int tdi
)
376 unsigned char output_value
=0x00;
379 output_value
|= (1<<TMS_BIT
);
381 output_value
|= (1<<TDI_BIT
);
383 output_value
|= (1<<TCK_BIT
);
385 usbprog_jtag_write_slice(usbprog_jtag_handle
,output_value
);
388 /* (1) assert or (0) deassert reset lines */
389 static void usbprog_reset(int trst
, int srst
)
391 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
394 usbprog_jtag_set_bit(usbprog_jtag_handle
, 5, 0);
396 usbprog_jtag_set_bit(usbprog_jtag_handle
, 5, 1);
399 usbprog_jtag_set_bit(usbprog_jtag_handle
, 4, 0);
401 usbprog_jtag_set_bit(usbprog_jtag_handle
, 4, 1);
404 /*************** jtag lowlevel functions ********************/
406 struct usb_bus
*busses
;
408 struct usbprog_jtag
* usbprog_jtag_open(void)
411 struct usb_device
*dev
;
413 struct usbprog_jtag
*tmp
;
415 tmp
= (struct usbprog_jtag
*)malloc(sizeof(struct usbprog_jtag
));
422 busses
= usb_get_busses();
424 /* find usbprog_jtag device in usb bus */
426 for (bus
= busses
; bus
; bus
= bus
->next
)
428 for (dev
= bus
->devices
; dev
; dev
= dev
->next
)
430 /* condition for sucessfully hit (too bad, I only check the vendor id)*/
431 if (dev
->descriptor
.idVendor
== VID
&& dev
->descriptor
.idProduct
== PID
)
433 tmp
->usb_handle
= usb_open(dev
);
434 usb_set_configuration(tmp
->usb_handle
, 1);
435 usb_claim_interface(tmp
->usb_handle
, 0);
436 usb_set_altinterface(tmp
->usb_handle
, 0);
445 static void usbprog_jtag_close(struct usbprog_jtag
*usbprog_jtag
)
447 usb_close(usbprog_jtag
->usb_handle
);
452 static unsigned char usbprog_jtag_message(struct usbprog_jtag
*usbprog_jtag
, char *msg
, int msglen
)
454 int res
= usb_bulk_write(usbprog_jtag
->usb_handle
, 3, msg
,msglen
, 100);
455 if ((msg
[0] == 2) || (msg
[0] == 1) || (msg
[0] == 4) || (msg
[0] == 0) || \
456 (msg
[0] == 6) || (msg
[0] == 0x0A) || (msg
[0] == 9))
460 /* LOG_INFO("HALLLLOOO %i",(int)msg[0]); */
461 res
= usb_bulk_read(usbprog_jtag
->usb_handle
, 0x82, msg
, 2, 100);
463 return (unsigned char)msg
[1];
472 static void usbprog_jtag_init(struct usbprog_jtag
*usbprog_jtag
)
474 usbprog_jtag_set_direction(usbprog_jtag
, 0xFE);
477 static void usbprog_jtag_write_and_read(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
)
479 char tmp
[64]; /* fastes packet size for usb controller */
480 int send_bits
, bufindex
= 0, fillindex
= 0, i
, loops
;
483 /* 61 byte can be transfered (488 bit) */
500 tmp
[0] = WRITE_AND_READ
;
501 tmp
[1] = (char)(send_bits
>> 8); /* high */
502 tmp
[2] = (char)(send_bits
); /* low */
505 for (i
= 0; i
< loops
; i
++)
507 tmp
[3 + i
] = buffer
[bufindex
];
511 if (usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, 64, 1000) == 64)
513 /* LOG_INFO("HALLLLOOO2 %i",(int)tmp[0]); */
516 while (usb_bulk_read(usbprog_jtag
->usb_handle
, 0x82, tmp
, 64, 1000) < 1)
523 for (i
= 0; i
< loops
; i
++)
526 buffer
[fillindex
++] = swap
;
532 static void usbprog_jtag_read_tdo(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
)
534 char tmp
[64]; /* fastes packet size for usb controller */
535 int send_bits
, fillindex
= 0, i
, loops
;
538 /* 61 byte can be transfered (488 bit) */
555 tmp
[0] = WRITE_AND_READ
;
556 tmp
[1] = (char)(send_bits
>> 8); /* high */
557 tmp
[2] = (char)(send_bits
); /* low */
559 usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, 3, 1000);
561 /* LOG_INFO("HALLLLOOO3 %i",(int)tmp[0]); */
564 while (usb_bulk_read(usbprog_jtag
->usb_handle
, 0x82, tmp
, 64, 10) < 1)
571 for (i
= 0; i
< loops
; i
++)
574 buffer
[fillindex
++] = swap
;
579 static void usbprog_jtag_write_tdi(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
)
581 char tmp
[64]; /* fastes packet size for usb controller */
582 int send_bits
, bufindex
= 0, i
, loops
;
584 /* 61 byte can be transfered (488 bit) */
602 tmp
[1] = (char)(send_bits
>> 8); /* high */
603 tmp
[2] = (char)(send_bits
); /* low */
606 for (i
= 0; i
< loops
; i
++)
608 tmp
[3 + i
] = buffer
[bufindex
];
611 usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, 64, 1000);
615 static void usbprog_jtag_write_tms(struct usbprog_jtag
*usbprog_jtag
, char tms_scan
)
617 usbprog_jtag_tms_collect(tms_scan
);
620 static void usbprog_jtag_set_direction(struct usbprog_jtag
*usbprog_jtag
, unsigned char direction
)
623 tmp
[0] = PORT_DIRECTION
;
624 tmp
[1] = (char)direction
;
625 usbprog_jtag_message(usbprog_jtag
, tmp
, 2);
628 static void usbprog_jtag_write_slice(struct usbprog_jtag
*usbprog_jtag
,unsigned char value
)
632 tmp
[1] = (char)value
;
633 usbprog_jtag_message(usbprog_jtag
, tmp
, 2);
637 static unsigned char usbprog_jtag_get_port(struct usbprog_jtag
*usbprog_jtag
)
642 return usbprog_jtag_message(usbprog_jtag
, tmp
, 2);
646 static void usbprog_jtag_set_bit(struct usbprog_jtag
*usbprog_jtag
,int bit
, int value
)
649 tmp
[0] = PORT_SETBIT
;
655 usbprog_jtag_message(usbprog_jtag
, tmp
, 3);
659 static int usbprog_jtag_get_bit(struct usbprog_jtag
*usbprog_jtag
, int bit
)
662 tmp
[0] = PORT_GETBIT
;
665 if (usbprog_jtag_message(usbprog_jtag
, tmp
, 2) > 0)
672 static void usbprog_jtag_tms_collect(char tms_scan
)
674 tms_chain
[tms_chain_index
] = tms_scan
;
678 static void usbprog_jtag_tms_send(struct usbprog_jtag
*usbprog_jtag
)
681 /* LOG_INFO("TMS SEND"); */
682 if (tms_chain_index
> 0)
684 char tmp
[tms_chain_index
+ 2];
685 tmp
[0] = WRITE_TMS_CHAIN
;
686 tmp
[1] = (char)(tms_chain_index
);
687 for (i
= 0; i
< tms_chain_index
+ 1; i
++)
688 tmp
[2 + i
] = tms_chain
[i
];
689 usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, tms_chain_index
+ 2, 1000);
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)