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 #include "replacements.h"
55 static int usbprog_execute_queue(void);
56 static int usbprog_speed(int speed
);
57 static int usbprog_register_commands(struct command_context_s
*cmd_ctx
);
58 static int usbprog_init(void);
59 static int usbprog_quit(void);
61 static void usbprog_end_state(tap_state_t state
);
62 static void usbprog_state_move(void);
63 static void usbprog_path_move(pathmove_command_t
*cmd
);
64 static void usbprog_runtest(int num_cycles
);
65 static void usbprog_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
);
67 jtag_interface_t usbprog_interface
=
70 .execute_queue
= usbprog_execute_queue
,
71 .speed
= usbprog_speed
,
72 .register_commands
= usbprog_register_commands
,
77 #define UNKOWN_COMMAND 0x00
78 #define PORT_DIRECTION 0x01
81 #define PORT_SETBIT 0x04
82 #define PORT_GETBIT 0x05
83 #define WRITE_TDI 0x06
85 #define WRITE_AND_READ 0x08
86 #define WRITE_TMS 0x09
87 #define WRITE_TMS_CHAIN 0x0A
91 struct usb_dev_handle
* usb_handle
;
94 static struct usbprog_jtag
* usbprog_jtag_handle
;
96 static struct usbprog_jtag
* usbprog_jtag_open(void);
97 //static void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag);
98 static void usbprog_jtag_init(struct usbprog_jtag
*usbprog_jtag
);
99 static unsigned char usbprog_jtag_message(struct usbprog_jtag
*usbprog_jtag
, char *msg
, int msglen
);
101 static void usbprog_jtag_read_tdo(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
);
102 static void usbprog_jtag_write_tdi(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
);
103 static void usbprog_jtag_write_and_read(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
);
104 static void usbprog_jtag_write_tms(struct usbprog_jtag
*usbprog_jtag
, char tms_scan
);
106 static char tms_chain
[64];
107 static int tms_chain_index
;
109 static void usbprog_jtag_tms_collect(char tms_scan
);
110 static void usbprog_jtag_tms_send(struct usbprog_jtag
*usbprog_jtag
);
112 static void usbprog_write(int tck
, int tms
, int tdi
);
113 static void usbprog_reset(int trst
, int srst
);
115 static void usbprog_jtag_set_direction(struct usbprog_jtag
*usbprog_jtag
, unsigned char direction
);
116 static void usbprog_jtag_write_slice(struct usbprog_jtag
*usbprog_jtag
,unsigned char value
);
117 //static unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag);
118 static void usbprog_jtag_set_bit(struct usbprog_jtag
*usbprog_jtag
,int bit
, int value
);
119 //static int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit);
121 static int usbprog_speed(int speed
)
126 static int usbprog_register_commands(struct command_context_s
*cmd_ctx
)
131 static int usbprog_execute_queue(void)
133 jtag_command_t
*cmd
= jtag_command_queue
; /* currently processed command */
143 #ifdef _DEBUG_JTAG_IO_
144 LOG_DEBUG("end_state: %i", cmd
->cmd
.end_state
->end_state
);
146 if (cmd
->cmd
.end_state
->end_state
!= TAP_INVALID
)
147 usbprog_end_state(cmd
->cmd
.end_state
->end_state
);
150 #ifdef _DEBUG_JTAG_IO_
151 LOG_DEBUG("reset trst: %i srst %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
153 if (cmd
->cmd
.reset
->trst
== 1)
155 tap_set_state(TAP_RESET
);
157 usbprog_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
160 #ifdef _DEBUG_JTAG_IO_
161 LOG_DEBUG("runtest %i cycles, end in %i", cmd
->cmd
.runtest
->num_cycles
, cmd
->cmd
.runtest
->end_state
);
163 if (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
)
164 usbprog_end_state(cmd
->cmd
.runtest
->end_state
);
165 usbprog_runtest(cmd
->cmd
.runtest
->num_cycles
);
168 #ifdef _DEBUG_JTAG_IO_
169 LOG_DEBUG("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
171 if (cmd
->cmd
.statemove
->end_state
!= TAP_INVALID
)
172 usbprog_end_state(cmd
->cmd
.statemove
->end_state
);
173 usbprog_state_move();
176 #ifdef _DEBUG_JTAG_IO_
177 LOG_DEBUG("pathmove: %i states, end in %i", cmd
->cmd
.pathmove
->num_states
,
178 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
180 usbprog_path_move(cmd
->cmd
.pathmove
);
183 #ifdef _DEBUG_JTAG_IO_
184 LOG_DEBUG("scan end in %i", cmd
->cmd
.scan
->end_state
);
186 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
187 usbprog_end_state(cmd
->cmd
.scan
->end_state
);
188 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
189 type
= jtag_scan_type(cmd
->cmd
.scan
);
190 usbprog_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
);
191 if (jtag_read_buffer(buffer
, cmd
->cmd
.scan
) != ERROR_OK
)
192 return ERROR_JTAG_QUEUE_FAILED
;
197 #ifdef _DEBUG_JTAG_IO_
198 LOG_DEBUG("sleep %i", cmd
->cmd
.sleep
->us
);
200 jtag_sleep(cmd
->cmd
.sleep
->us
);
203 LOG_ERROR("BUG: unknown JTAG command type encountered");
213 static int usbprog_init(void)
215 usbprog_jtag_handle
= usbprog_jtag_open();
218 if (usbprog_jtag_handle
== 0)
220 LOG_ERROR("Can't find USB JTAG Interface! Please check connection and permissions.");
221 return ERROR_JTAG_INIT_FAILED
;
224 LOG_INFO("USB JTAG Interface ready!");
226 usbprog_jtag_init(usbprog_jtag_handle
);
228 usbprog_write(0, 0, 0);
233 static int usbprog_quit(void)
238 /*************** jtag execute commands **********************/
239 static void usbprog_end_state(tap_state_t state
)
241 if (tap_is_state_stable(state
))
242 tap_set_end_state(state
);
245 LOG_ERROR("BUG: %i is not a valid end state", state
);
250 static void usbprog_state_move(void)
253 u8 tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
255 usbprog_jtag_write_tms(usbprog_jtag_handle
, (char)tms_scan
);
256 for (i
= 0; i
< 7; i
++)
258 tms
= (tms_scan
>> i
) & 1;
261 tap_set_state(tap_get_end_state());
264 static void usbprog_path_move(pathmove_command_t
*cmd
)
266 int num_states
= cmd
->num_states
;
269 /* There may be queued transitions, and before following a specified
270 path, we must flush those queued transitions */
271 usbprog_jtag_tms_send(usbprog_jtag_handle
);
276 if (tap_state_transition(tap_get_state(), false) == cmd
->path
[state_count
])
279 usbprog_write(0, 0, 0);
280 usbprog_write(1, 0, 0);
282 else if (tap_state_transition(tap_get_state(), true) == cmd
->path
[state_count
])
285 usbprog_write(0, 1, 0);
286 usbprog_write(1, 1, 0);
290 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd
->path
[state_count
]));
294 tap_set_state(cmd
->path
[state_count
]);
299 tap_set_end_state(tap_get_state());
302 static void usbprog_runtest(int num_cycles
)
306 /* only do a state_move when we're not already in IDLE */
307 if (tap_get_state() != TAP_IDLE
)
309 usbprog_end_state(TAP_IDLE
);
310 usbprog_state_move();
313 /* execute num_cycles */
316 usbprog_jtag_tms_send(usbprog_jtag_handle
);
317 usbprog_write(0, 0, 0);
321 usbprog_jtag_tms_send(usbprog_jtag_handle
);
322 /* LOG_INFO("NUM CYCLES %i",num_cycles); */
325 for (i
= 0; i
< num_cycles
; i
++)
327 usbprog_write(1, 0, 0);
328 usbprog_write(0, 0, 0);
331 #ifdef _DEBUG_JTAG_IO_
332 LOG_DEBUG("runtest: cur_state %s end_state %s", tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state()));
335 /* finish in end_state */
337 usbprog_end_state(saved_end_state);
338 if (tap_get_state() != tap_get_end_state())
339 usbprog_state_move();
343 static void usbprog_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
)
345 tap_state_t saved_end_state
= tap_get_end_state();
348 usbprog_end_state(TAP_IRSHIFT
);
350 usbprog_end_state(TAP_DRSHIFT
);
352 /* Only move if we're not already there */
353 if (tap_get_state() != tap_get_end_state())
354 usbprog_state_move();
356 usbprog_end_state(saved_end_state
);
358 usbprog_jtag_tms_send(usbprog_jtag_handle
);
360 void (*f
)(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
);
362 case SCAN_OUT
: f
= &usbprog_jtag_write_tdi
; break;
363 case SCAN_IN
: f
= &usbprog_jtag_read_tdo
; break;
364 case SCAN_IO
: f
= &usbprog_jtag_write_and_read
; break;
366 LOG_ERROR("unknown scan type: %i", type
);
369 f(usbprog_jtag_handle
, (char *)buffer
, scan_size
);
371 /* The adapter does the transition to PAUSE internally */
373 tap_set_state(TAP_IRPAUSE
);
375 tap_set_state(TAP_DRPAUSE
);
377 if (tap_get_state() != tap_get_end_state())
378 usbprog_state_move();
381 /*************** jtag wrapper functions *********************/
383 static void usbprog_write(int tck
, int tms
, int tdi
)
385 unsigned char output_value
=0x00;
388 output_value
|= (1<<TMS_BIT
);
390 output_value
|= (1<<TDI_BIT
);
392 output_value
|= (1<<TCK_BIT
);
394 usbprog_jtag_write_slice(usbprog_jtag_handle
,output_value
);
397 /* (1) assert or (0) deassert reset lines */
398 static void usbprog_reset(int trst
, int srst
)
400 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
403 usbprog_jtag_set_bit(usbprog_jtag_handle
, 5, 0);
405 usbprog_jtag_set_bit(usbprog_jtag_handle
, 5, 1);
408 usbprog_jtag_set_bit(usbprog_jtag_handle
, 4, 0);
410 usbprog_jtag_set_bit(usbprog_jtag_handle
, 4, 1);
413 /*************** jtag lowlevel functions ********************/
415 struct usb_bus
*busses
;
417 struct usbprog_jtag
* usbprog_jtag_open(void)
420 struct usb_device
*dev
;
422 struct usbprog_jtag
*tmp
;
424 tmp
= (struct usbprog_jtag
*)malloc(sizeof(struct usbprog_jtag
));
431 busses
= usb_get_busses();
433 /* find usbprog_jtag device in usb bus */
435 for (bus
= busses
; bus
; bus
= bus
->next
)
437 for (dev
= bus
->devices
; dev
; dev
= dev
->next
)
439 /* condition for sucessfully hit (too bad, I only check the vendor id)*/
440 if (dev
->descriptor
.idVendor
== VID
&& dev
->descriptor
.idProduct
== PID
)
442 tmp
->usb_handle
= usb_open(dev
);
443 usb_set_configuration(tmp
->usb_handle
, 1);
444 usb_claim_interface(tmp
->usb_handle
, 0);
445 usb_set_altinterface(tmp
->usb_handle
, 0);
454 static void usbprog_jtag_close(struct usbprog_jtag
*usbprog_jtag
)
456 usb_close(usbprog_jtag
->usb_handle
);
461 static unsigned char usbprog_jtag_message(struct usbprog_jtag
*usbprog_jtag
, char *msg
, int msglen
)
463 int res
= usb_bulk_write(usbprog_jtag
->usb_handle
, 3, msg
,msglen
, 100);
464 if ((msg
[0] == 2) || (msg
[0] == 1) || (msg
[0] == 4) || (msg
[0] == 0) || \
465 (msg
[0] == 6) || (msg
[0] == 0x0A) || (msg
[0] == 9))
469 /* LOG_INFO("HALLLLOOO %i",(int)msg[0]); */
470 res
= usb_bulk_read(usbprog_jtag
->usb_handle
, 0x82, msg
, 2, 100);
472 return (unsigned char)msg
[1];
481 static void usbprog_jtag_init(struct usbprog_jtag
*usbprog_jtag
)
483 usbprog_jtag_set_direction(usbprog_jtag
, 0xFE);
486 static void usbprog_jtag_write_and_read(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
)
488 char tmp
[64]; /* fastes packet size for usb controller */
489 int send_bits
, bufindex
= 0, fillindex
= 0, i
, loops
;
492 /* 61 byte can be transfered (488 bit) */
509 tmp
[0] = WRITE_AND_READ
;
510 tmp
[1] = (char)(send_bits
>> 8); /* high */
511 tmp
[2] = (char)(send_bits
); /* low */
514 for (i
= 0; i
< loops
; i
++)
516 tmp
[3 + i
] = buffer
[bufindex
];
520 if (usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, 64, 1000) == 64)
522 /* LOG_INFO("HALLLLOOO2 %i",(int)tmp[0]); */
525 while (usb_bulk_read(usbprog_jtag
->usb_handle
, 0x82, tmp
, 64, 1000) < 1)
532 for (i
= 0; i
< loops
; i
++)
535 buffer
[fillindex
++] = swap
;
541 static void usbprog_jtag_read_tdo(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
)
543 char tmp
[64]; /* fastes packet size for usb controller */
544 int send_bits
, fillindex
= 0, i
, loops
;
547 /* 61 byte can be transfered (488 bit) */
564 tmp
[0] = WRITE_AND_READ
;
565 tmp
[1] = (char)(send_bits
>> 8); /* high */
566 tmp
[2] = (char)(send_bits
); /* low */
568 usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, 3, 1000);
570 /* LOG_INFO("HALLLLOOO3 %i",(int)tmp[0]); */
573 while (usb_bulk_read(usbprog_jtag
->usb_handle
, 0x82, tmp
, 64, 10) < 1)
580 for (i
= 0; i
< loops
; i
++)
583 buffer
[fillindex
++] = swap
;
588 static void usbprog_jtag_write_tdi(struct usbprog_jtag
*usbprog_jtag
, char * buffer
, int size
)
590 char tmp
[64]; /* fastes packet size for usb controller */
591 int send_bits
, bufindex
= 0, i
, loops
;
593 /* 61 byte can be transfered (488 bit) */
611 tmp
[1] = (char)(send_bits
>> 8); /* high */
612 tmp
[2] = (char)(send_bits
); /* low */
615 for (i
= 0; i
< loops
; i
++)
617 tmp
[3 + i
] = buffer
[bufindex
];
620 usb_bulk_write(usbprog_jtag
->usb_handle
, 3, tmp
, 64, 1000);
624 static void usbprog_jtag_write_tms(struct usbprog_jtag
*usbprog_jtag
, char tms_scan
)
626 usbprog_jtag_tms_collect(tms_scan
);
629 static void usbprog_jtag_set_direction(struct usbprog_jtag
*usbprog_jtag
, unsigned char direction
)
632 tmp
[0] = PORT_DIRECTION
;
633 tmp
[1] = (char)direction
;
634 usbprog_jtag_message(usbprog_jtag
, tmp
, 2);
637 static void usbprog_jtag_write_slice(struct usbprog_jtag
*usbprog_jtag
,unsigned char value
)
641 tmp
[1] = (char)value
;
642 usbprog_jtag_message(usbprog_jtag
, tmp
, 2);
646 static unsigned char usbprog_jtag_get_port(struct usbprog_jtag
*usbprog_jtag
)
651 return usbprog_jtag_message(usbprog_jtag
, tmp
, 2);
655 static void usbprog_jtag_set_bit(struct usbprog_jtag
*usbprog_jtag
,int bit
, int value
)
658 tmp
[0] = PORT_SETBIT
;
664 usbprog_jtag_message(usbprog_jtag
, tmp
, 3);
668 static int usbprog_jtag_get_bit(struct usbprog_jtag
*usbprog_jtag
, int bit
)
671 tmp
[0] = PORT_GETBIT
;
674 if (usbprog_jtag_message(usbprog_jtag
, tmp
, 2) > 0)
681 static void usbprog_jtag_tms_collect(char tms_scan
)
683 tms_chain
[tms_chain_index
] = tms_scan
;
687 static void usbprog_jtag_tms_send(struct usbprog_jtag
*usbprog_jtag
)
690 /* LOG_INFO("TMS SEND"); */
691 if (tms_chain_index
> 0)
693 char tmp
[tms_chain_index
+ 2];
694 tmp
[0] = WRITE_TMS_CHAIN
;
695 tmp
[1] = (char)(tms_chain_index
);
696 for (i
= 0; i
< tms_chain_index
+ 1; i
++)
697 tmp
[2 + i
] = tms_chain
[i
];
698 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)