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
51 static int usbprog_execute_queue(void);
52 static int usbprog_speed(int speed
);
53 static int usbprog_register_commands(struct command_context_s
*cmd_ctx
);
54 static int usbprog_init(void);
55 static int usbprog_quit(void);
57 static void usbprog_end_state(tap_state_t state
);
58 static void usbprog_state_move(void);
59 static void usbprog_path_move(pathmove_command_t
*cmd
);
60 static void usbprog_runtest(int num_cycles
);
61 static void usbprog_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
);
63 jtag_interface_t usbprog_interface
=
66 .execute_queue
= usbprog_execute_queue
,
67 .speed
= usbprog_speed
,
68 .register_commands
= usbprog_register_commands
,
73 #define UNKOWN_COMMAND 0x00
74 #define PORT_DIRECTION 0x01
77 #define PORT_SETBIT 0x04
78 #define PORT_GETBIT 0x05
79 #define WRITE_TDI 0x06
81 #define WRITE_AND_READ 0x08
82 #define WRITE_TMS 0x09
83 #define WRITE_TMS_CHAIN 0x0A
87 struct usb_dev_handle
* usb_handle
;
90 static struct usbprog_jtag
* usbprog_jtag_handle
;
92 static struct usbprog_jtag
* usbprog_jtag_open(void);
93 //static void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag);
94 static void usbprog_jtag_init(struct usbprog_jtag
*usbprog_jtag
);
95 static unsigned char usbprog_jtag_message(struct usbprog_jtag
*usbprog_jtag
, char *msg
, int msglen
);
97 static void usbprog_jtag_read_tdo(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
);
98 static void usbprog_jtag_write_tdi(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
);
99 static void usbprog_jtag_write_and_read(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
);
100 static void usbprog_jtag_write_tms(struct usbprog_jtag
*usbprog_jtag
, char tms_scan
);
102 static char tms_chain
[64];
103 static int tms_chain_index
;
105 static void usbprog_jtag_tms_collect(char tms_scan
);
106 static void usbprog_jtag_tms_send(struct usbprog_jtag
*usbprog_jtag
);
108 static void usbprog_write(int tck
, int tms
, int tdi
);
109 static void usbprog_reset(int trst
, int srst
);
111 static void usbprog_jtag_set_direction(struct usbprog_jtag
*usbprog_jtag
, unsigned char direction
);
112 static void usbprog_jtag_write_slice(struct usbprog_jtag
*usbprog_jtag
,unsigned char value
);
113 //static unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag);
114 static void usbprog_jtag_set_bit(struct usbprog_jtag
*usbprog_jtag
,int bit
, int value
);
115 //static int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit);
117 static int usbprog_speed(int speed
)
122 static int usbprog_register_commands(struct command_context_s
*cmd_ctx
)
127 static int usbprog_execute_queue(void)
129 jtag_command_t
*cmd
= jtag_command_queue
; /* currently processed command */
139 #ifdef _DEBUG_JTAG_IO_
140 LOG_DEBUG("end_state: %i", cmd
->cmd
.end_state
->end_state
);
142 if (cmd
->cmd
.end_state
->end_state
!= TAP_INVALID
)
143 usbprog_end_state(cmd
->cmd
.end_state
->end_state
);
146 #ifdef _DEBUG_JTAG_IO_
147 LOG_DEBUG("reset trst: %i srst %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
149 if (cmd
->cmd
.reset
->trst
== 1)
151 tap_set_state(TAP_RESET
);
153 usbprog_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
156 #ifdef _DEBUG_JTAG_IO_
157 LOG_DEBUG("runtest %i cycles, end in %i", cmd
->cmd
.runtest
->num_cycles
, cmd
->cmd
.runtest
->end_state
);
159 if (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
)
160 usbprog_end_state(cmd
->cmd
.runtest
->end_state
);
161 usbprog_runtest(cmd
->cmd
.runtest
->num_cycles
);
164 #ifdef _DEBUG_JTAG_IO_
165 LOG_DEBUG("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
167 if (cmd
->cmd
.statemove
->end_state
!= TAP_INVALID
)
168 usbprog_end_state(cmd
->cmd
.statemove
->end_state
);
169 usbprog_state_move();
172 #ifdef _DEBUG_JTAG_IO_
173 LOG_DEBUG("pathmove: %i states, end in %i", cmd
->cmd
.pathmove
->num_states
,
174 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
176 usbprog_path_move(cmd
->cmd
.pathmove
);
179 #ifdef _DEBUG_JTAG_IO_
180 LOG_DEBUG("scan end in %i", cmd
->cmd
.scan
->end_state
);
182 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
183 usbprog_end_state(cmd
->cmd
.scan
->end_state
);
184 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
185 type
= jtag_scan_type(cmd
->cmd
.scan
);
186 usbprog_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
);
187 if (jtag_read_buffer(buffer
, cmd
->cmd
.scan
) != ERROR_OK
)
188 return ERROR_JTAG_QUEUE_FAILED
;
193 #ifdef _DEBUG_JTAG_IO_
194 LOG_DEBUG("sleep %i", cmd
->cmd
.sleep
->us
);
196 jtag_sleep(cmd
->cmd
.sleep
->us
);
199 LOG_ERROR("BUG: unknown JTAG command type encountered");
209 static int usbprog_init(void)
211 usbprog_jtag_handle
= usbprog_jtag_open();
214 if (usbprog_jtag_handle
== 0)
216 LOG_ERROR("Can't find USB JTAG Interface! Please check connection and permissions.");
217 return ERROR_JTAG_INIT_FAILED
;
220 LOG_INFO("USB JTAG Interface ready!");
222 usbprog_jtag_init(usbprog_jtag_handle
);
224 usbprog_write(0, 0, 0);
229 static int usbprog_quit(void)
234 /*************** jtag execute commands **********************/
235 static void usbprog_end_state(tap_state_t state
)
237 if (tap_is_state_stable(state
))
238 tap_set_end_state(state
);
241 LOG_ERROR("BUG: %i is not a valid end state", state
);
246 static void usbprog_state_move(void)
249 u8 tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
251 usbprog_jtag_write_tms(usbprog_jtag_handle
, (char)tms_scan
);
252 for (i
= 0; i
< 7; i
++)
254 tms
= (tms_scan
>> i
) & 1;
257 tap_set_state(tap_get_end_state());
260 static void usbprog_path_move(pathmove_command_t
*cmd
)
262 int num_states
= cmd
->num_states
;
265 /* There may be queued transitions, and before following a specified
266 path, we must flush those queued transitions */
267 usbprog_jtag_tms_send(usbprog_jtag_handle
);
272 if (tap_state_transition(tap_get_state(), false) == cmd
->path
[state_count
])
275 usbprog_write(0, 0, 0);
276 usbprog_write(1, 0, 0);
278 else if (tap_state_transition(tap_get_state(), true) == cmd
->path
[state_count
])
281 usbprog_write(0, 1, 0);
282 usbprog_write(1, 1, 0);
286 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd
->path
[state_count
]));
290 tap_set_state(cmd
->path
[state_count
]);
295 tap_set_end_state(tap_get_state());
298 static void usbprog_runtest(int num_cycles
)
302 /* only do a state_move when we're not already in IDLE */
303 if (tap_get_state() != TAP_IDLE
)
305 usbprog_end_state(TAP_IDLE
);
306 usbprog_state_move();
309 /* execute num_cycles */
312 usbprog_jtag_tms_send(usbprog_jtag_handle
);
313 usbprog_write(0, 0, 0);
317 usbprog_jtag_tms_send(usbprog_jtag_handle
);
318 /* LOG_INFO("NUM CYCLES %i",num_cycles); */
321 for (i
= 0; i
< num_cycles
; i
++)
323 usbprog_write(1, 0, 0);
324 usbprog_write(0, 0, 0);
327 #ifdef _DEBUG_JTAG_IO_
328 LOG_DEBUG("runtest: cur_state %s end_state %s", tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state()));
331 /* finish in end_state */
333 usbprog_end_state(saved_end_state);
334 if (tap_get_state() != tap_get_end_state())
335 usbprog_state_move();
339 static void usbprog_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
)
341 tap_state_t saved_end_state
= tap_get_end_state();
344 usbprog_end_state(TAP_IRSHIFT
);
346 usbprog_end_state(TAP_DRSHIFT
);
348 /* Only move if we're not already there */
349 if (tap_get_state() != tap_get_end_state())
350 usbprog_state_move();
352 usbprog_end_state(saved_end_state
);
354 usbprog_jtag_tms_send(usbprog_jtag_handle
);
356 void (*f
)(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
);
358 case SCAN_OUT
: f
= &usbprog_jtag_write_tdi
; break;
359 case SCAN_IN
: f
= &usbprog_jtag_read_tdo
; break;
360 case SCAN_IO
: f
= &usbprog_jtag_write_and_read
; break;
362 LOG_ERROR("unknown scan type: %i", type
);
365 f(usbprog_jtag_handle
, (char *)buffer
, scan_size
);
367 /* The adapter does the transition to PAUSE internally */
369 tap_set_state(TAP_IRPAUSE
);
371 tap_set_state(TAP_DRPAUSE
);
373 if (tap_get_state() != tap_get_end_state())
374 usbprog_state_move();
377 /*************** jtag wrapper functions *********************/
379 static void usbprog_write(int tck
, int tms
, int tdi
)
381 unsigned char output_value
=0x00;
384 output_value
|= (1<<TMS_BIT
);
386 output_value
|= (1<<TDI_BIT
);
388 output_value
|= (1<<TCK_BIT
);
390 usbprog_jtag_write_slice(usbprog_jtag_handle
,output_value
);
393 /* (1) assert or (0) deassert reset lines */
394 static void usbprog_reset(int trst
, int srst
)
396 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
399 usbprog_jtag_set_bit(usbprog_jtag_handle
, 5, 0);
401 usbprog_jtag_set_bit(usbprog_jtag_handle
, 5, 1);
404 usbprog_jtag_set_bit(usbprog_jtag_handle
, 4, 0);
406 usbprog_jtag_set_bit(usbprog_jtag_handle
, 4, 1);
409 /*************** jtag lowlevel functions ********************/
411 struct usb_bus
*busses
;
413 struct usbprog_jtag
* usbprog_jtag_open(void)
416 struct usb_device
*dev
;
418 struct usbprog_jtag
*tmp
;
420 tmp
= (struct usbprog_jtag
*)malloc(sizeof(struct usbprog_jtag
));
427 busses
= usb_get_busses();
429 /* find usbprog_jtag device in usb bus */
431 for (bus
= busses
; bus
; bus
= bus
->next
)
433 for (dev
= bus
->devices
; dev
; dev
= dev
->next
)
435 /* condition for sucessfully hit (too bad, I only check the vendor id)*/
436 if (dev
->descriptor
.idVendor
== VID
&& dev
->descriptor
.idProduct
== PID
)
438 tmp
->usb_handle
= usb_open(dev
);
439 usb_set_configuration(tmp
->usb_handle
, 1);
440 usb_claim_interface(tmp
->usb_handle
, 0);
441 usb_set_altinterface(tmp
->usb_handle
, 0);
450 static void usbprog_jtag_close(struct usbprog_jtag
*usbprog_jtag
)
452 usb_close(usbprog_jtag
->usb_handle
);
457 static unsigned char usbprog_jtag_message(struct usbprog_jtag
*usbprog_jtag
, char *msg
, int msglen
)
459 int res
= usb_bulk_write(usbprog_jtag
->usb_handle
, 3, msg
,msglen
, 100);
460 if ((msg
[0] == 2) || (msg
[0] == 1) || (msg
[0] == 4) || (msg
[0] == 0) || \
461 (msg
[0] == 6) || (msg
[0] == 0x0A) || (msg
[0] == 9))
465 /* LOG_INFO("HALLLLOOO %i",(int)msg[0]); */
466 res
= usb_bulk_read(usbprog_jtag
->usb_handle
, 0x82, msg
, 2, 100);
468 return (unsigned char)msg
[1];
477 static void usbprog_jtag_init(struct usbprog_jtag
*usbprog_jtag
)
479 usbprog_jtag_set_direction(usbprog_jtag
, 0xFE);
482 static void usbprog_jtag_write_and_read(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
)
484 char tmp
[64]; /* fastes packet size for usb controller */
485 int send_bits
, bufindex
= 0, fillindex
= 0, i
, loops
;
488 /* 61 byte can be transfered (488 bit) */
505 tmp
[0] = WRITE_AND_READ
;
506 tmp
[1] = (char)(send_bits
>> 8); /* high */
507 tmp
[2] = (char)(send_bits
); /* low */
510 for (i
= 0; i
< loops
; i
++)
512 tmp
[3 + i
] = buffer
[bufindex
];
516 if (usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, 64, 1000) == 64)
518 /* LOG_INFO("HALLLLOOO2 %i",(int)tmp[0]); */
521 while (usb_bulk_read(usbprog_jtag
->usb_handle
, 0x82, tmp
, 64, 1000) < 1)
528 for (i
= 0; i
< loops
; i
++)
531 buffer
[fillindex
++] = swap
;
537 static void usbprog_jtag_read_tdo(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
)
539 char tmp
[64]; /* fastes packet size for usb controller */
540 int send_bits
, fillindex
= 0, i
, loops
;
543 /* 61 byte can be transfered (488 bit) */
560 tmp
[0] = WRITE_AND_READ
;
561 tmp
[1] = (char)(send_bits
>> 8); /* high */
562 tmp
[2] = (char)(send_bits
); /* low */
564 usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, 3, 1000);
566 /* LOG_INFO("HALLLLOOO3 %i",(int)tmp[0]); */
569 while (usb_bulk_read(usbprog_jtag
->usb_handle
, 0x82, tmp
, 64, 10) < 1)
576 for (i
= 0; i
< loops
; i
++)
579 buffer
[fillindex
++] = swap
;
584 static void usbprog_jtag_write_tdi(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
)
586 char tmp
[64]; /* fastes packet size for usb controller */
587 int send_bits
, bufindex
= 0, i
, loops
;
589 /* 61 byte can be transfered (488 bit) */
607 tmp
[1] = (char)(send_bits
>> 8); /* high */
608 tmp
[2] = (char)(send_bits
); /* low */
611 for (i
= 0; i
< loops
; i
++)
613 tmp
[3 + i
] = buffer
[bufindex
];
616 usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, 64, 1000);
620 static void usbprog_jtag_write_tms(struct usbprog_jtag
*usbprog_jtag
, char tms_scan
)
622 usbprog_jtag_tms_collect(tms_scan
);
625 static void usbprog_jtag_set_direction(struct usbprog_jtag
*usbprog_jtag
, unsigned char direction
)
628 tmp
[0] = PORT_DIRECTION
;
629 tmp
[1] = (char)direction
;
630 usbprog_jtag_message(usbprog_jtag
, tmp
, 2);
633 static void usbprog_jtag_write_slice(struct usbprog_jtag
*usbprog_jtag
,unsigned char value
)
637 tmp
[1] = (char)value
;
638 usbprog_jtag_message(usbprog_jtag
, tmp
, 2);
642 static unsigned char usbprog_jtag_get_port(struct usbprog_jtag
*usbprog_jtag
)
647 return usbprog_jtag_message(usbprog_jtag
, tmp
, 2);
651 static void usbprog_jtag_set_bit(struct usbprog_jtag
*usbprog_jtag
,int bit
, int value
)
654 tmp
[0] = PORT_SETBIT
;
660 usbprog_jtag_message(usbprog_jtag
, tmp
, 3);
664 static int usbprog_jtag_get_bit(struct usbprog_jtag
*usbprog_jtag
, int bit
)
667 tmp
[0] = PORT_GETBIT
;
670 if (usbprog_jtag_message(usbprog_jtag
, tmp
, 2) > 0)
677 static void usbprog_jtag_tms_collect(char tms_scan
)
679 tms_chain
[tms_chain_index
] = tms_scan
;
683 static void usbprog_jtag_tms_send(struct usbprog_jtag
*usbprog_jtag
)
686 /* LOG_INFO("TMS SEND"); */
687 if (tms_chain_index
> 0)
689 char tmp
[tms_chain_index
+ 2];
690 tmp
[0] = WRITE_TMS_CHAIN
;
691 tmp
[1] = (char)(tms_chain_index
);
692 for (i
= 0; i
< tms_chain_index
+ 1; i
++)
693 tmp
[2 + i
] = tms_chain
[i
];
694 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)