1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 Rob Brown, Lou Deluxe *
9 * rob@cobbleware.com, lou.openocd012@fixit.nospammail.net *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
36 /* project specific includes */
40 #include "configuration.h"
47 /* This feature is made useless by running the DTC all the time. When automatic, the LED is on whenever the DTC is running. Otherwise, USB messages are sent to turn it on and off. */
48 #undef AUTOMATIC_BUSY_LED
50 /* This feature may require derating the speed due to reduced hold time. */
51 #undef USE_HARDWARE_SHIFTER_FOR_TMS
54 #define INTERFACE_NAME "RLink"
56 #define USB_IDVENDOR (0x138e)
57 #define USB_IDPRODUCT (0x9000)
59 #define USB_EP1OUT_ADDR (0x01)
60 #define USB_EP1OUT_SIZE (16)
61 #define USB_EP1IN_ADDR (USB_EP1OUT_ADDR | 0x80)
62 #define USB_EP1IN_SIZE (USB_EP1OUT_SIZE)
64 #define USB_EP2OUT_ADDR (0x02)
65 #define USB_EP2OUT_SIZE (64)
66 #define USB_EP2IN_ADDR (USB_EP2OUT_ADDR | 0x80)
67 #define USB_EP2IN_SIZE (USB_EP2OUT_SIZE)
68 #define USB_EP2BANK_SIZE (512)
70 #define USB_TIMEOUT_MS (3 * 1000)
72 #define DTC_STATUS_POLL_BYTE (ST7_USB_BUF_EP0OUT + 0xff)
75 /* Symbolic names for some pins */
76 #define ST7_PA_NJTAG_TRST ST7_PA1
77 #define ST7_PA_NRLINK_RST ST7_PA3
78 #define ST7_PA_NLINE_DRIVER_ENABLE ST7_PA5
80 /* mask for negative-logic pins */
81 #define ST7_PA_NUNASSERTED (0 \
84 | ST7_PA_NLINE_DRIVER_ENABLE \
87 #define ST7_PD_NBUSY_LED ST7_PD0
88 #define ST7_PD_NERROR_LED ST7_PD1
89 #define ST7_PD_NRUN_LED ST7_PD7
91 #define ST7_PE_ADAPTER_SENSE_IN ST7_PE3
92 #define ST7_PE_ADAPTER_SENSE_OUT ST7_PE4
94 static usb_dev_handle
*pHDev
;
98 * ep1 commands are up to USB_EP1OUT_SIZE bytes in length.
99 * This function takes care of zeroing the unused bytes before sending the packet.
100 * Any reply packet is not handled by this function.
104 ep1_generic_commandl(
105 usb_dev_handle
*pHDev
,
109 uint8_t usb_buffer
[USB_EP1OUT_SIZE
];
110 uint8_t *usb_buffer_p
;
114 if(length
> sizeof(usb_buffer
)) {
115 length
= sizeof(usb_buffer
);
118 usb_buffer_p
= usb_buffer
;
120 va_start(ap
, length
);
122 *usb_buffer_p
++ = va_arg(ap
, int);
129 sizeof(usb_buffer
) - (usb_buffer_p
- usb_buffer
)
132 usb_ret
= usb_bulk_write(
135 (char *)usb_buffer
, sizeof(usb_buffer
),
148 usb_dev_handle
*pHDev
,
153 uint8_t usb_buffer
[USB_EP1OUT_SIZE
];
158 usb_buffer
[0] = EP1_CMD_MEMORY_READ
;
162 sizeof(usb_buffer
) - 4
169 if(remain
> sizeof(usb_buffer
)) {
170 length
= sizeof(usb_buffer
);
175 usb_buffer
[1] = addr
>> 8;
176 usb_buffer
[2] = addr
;
177 usb_buffer
[3] = length
;
179 usb_ret
= usb_bulk_write(
180 pHDev
, USB_EP1OUT_ADDR
,
181 usb_buffer
, sizeof(usb_buffer
),
185 if(usb_ret
< sizeof(usb_buffer
)) {
189 usb_ret
= usb_bulk_read(
190 pHDev
, USB_EP1IN_ADDR
,
195 if(usb_ret
< length
) {
214 usb_dev_handle
*pHDev
,
217 uint8_t const *buffer
219 uint8_t usb_buffer
[USB_EP1OUT_SIZE
];
224 usb_buffer
[0] = EP1_CMD_MEMORY_WRITE
;
230 if(remain
> (sizeof(usb_buffer
) - 4)) {
231 length
= (sizeof(usb_buffer
) - 4);
236 usb_buffer
[1] = addr
>> 8;
237 usb_buffer
[2] = addr
;
238 usb_buffer
[3] = length
;
245 usb_buffer
+ 4 + length
,
247 sizeof(usb_buffer
) - 4 - length
250 usb_ret
= usb_bulk_write(
251 pHDev
, USB_EP1OUT_ADDR
,
252 (char *)usb_buffer
, sizeof(usb_buffer
),
256 if(usb_ret
< sizeof(usb_buffer
)) {
274 usb_dev_handle
*pHDev
,
279 uint8_t buffer
[USB_EP1OUT_SIZE
- 4];
284 if(length
> sizeof(buffer
)) {
285 length
= sizeof(buffer
);
291 va_start(ap
, length
);
293 *buffer_p
++ = va_arg(ap
, int);
297 return(ep1_memory_write(pHDev
, addr
, length
, buffer
));
302 #define DTCLOAD_COMMENT (0)
303 #define DTCLOAD_ENTRY (1)
304 #define DTCLOAD_LOAD (2)
305 #define DTCLOAD_RUN (3)
306 #define DTCLOAD_LUT_START (4)
307 #define DTCLOAD_LUT (5)
309 #define DTC_LOAD_BUFFER ST7_USB_BUF_EP2UIDO
311 /* This gets set by the DTC loader */
312 static uint8_t dtc_entry_download
;
315 /* The buffer is specially formatted to represent a valid image to load into the DTC. */
318 dtc_load_from_buffer(
319 usb_dev_handle
*pHDev
,
329 struct header_s
*header
;
332 dtc_entry_download
= 0;
334 /* Stop the DTC before loading anything. */
335 usb_err
= ep1_generic_commandl(
339 if(usb_err
< 0) return(usb_err
);
342 if(length
< sizeof(*header
)) {
343 LOG_ERROR("Malformed DTC image\n");
347 header
= (struct header_s
*)buffer
;
348 buffer
+= sizeof(*header
);
349 length
-= sizeof(*header
);
351 if(length
< header
->length
+ 1) {
352 LOG_ERROR("Malformed DTC image\n");
356 switch(header
->type
) {
357 case DTCLOAD_COMMENT
:
361 /* store entry addresses somewhere */
362 if(!strncmp("download", (char *)buffer
+ 1, 8)) {
363 dtc_entry_download
= buffer
[0];
368 /* Send the DTC program to ST7 RAM. */
369 usb_err
= ep1_memory_write(
372 header
->length
+ 1, buffer
374 if(usb_err
< 0) return(usb_err
);
376 /* Load it into the DTC. */
377 usb_err
= ep1_generic_commandl(
380 (DTC_LOAD_BUFFER
>> 8),
383 if(usb_err
< 0) return(usb_err
);
388 usb_err
= ep1_generic_commandl(
394 if(usb_err
< 0) return(usb_err
);
398 case DTCLOAD_LUT_START
:
399 lut_start
= buffer
[0];
403 usb_err
= ep1_memory_write(
405 ST7_USB_BUF_EP0OUT
+ lut_start
,
406 header
->length
+ 1, buffer
408 if(usb_err
< 0) return(usb_err
);
412 LOG_ERROR("Invalid DTC image record type: 0x%02x\n", header
->type
);
417 buffer
+= (header
->length
+ 1);
418 length
-= (header
->length
+ 1);
426 * Start the DTC running in download mode (waiting for 512 byte command packets on ep2).
430 dtc_start_download(void) {
434 /* set up for download mode and make sure EP2 is set up to transmit */
435 usb_err
= ep1_generic_commandl(
440 EP1_CMD_SET_DOWNLOAD
,
441 EP1_CMD_MEMORY_READ
, /* read EP2TXR for its data toggle */
446 if(usb_err
< 0) return(usb_err
);
448 /* read back ep2txr */
449 usb_err
= usb_bulk_read(
450 pHDev
, USB_EP1IN_ADDR
,
454 if(usb_err
< 0) return(usb_err
);
456 usb_err
= ep1_generic_commandl(
459 EP1_CMD_MEMORY_WRITE
, /* preinitialize poll byte */
460 DTC_STATUS_POLL_BYTE
>> 8,
461 DTC_STATUS_POLL_BYTE
,
464 EP1_CMD_MEMORY_WRITE
, /* set EP2IN to return data */
468 (ep2txr
& ST7_EP2TXR_DTOG_TX
) | ST7_EP2TXR_STAT_VALID
,
469 EP1_CMD_DTC_CALL
, /* start running the DTC */
471 EP1_CMD_DTC_GET_CACHED_STATUS
473 if(usb_err
< 0) return(usb_err
);
475 /* wait for completion */
476 usb_err
= usb_bulk_read(
477 pHDev
, USB_EP1IN_ADDR
,
489 usb_dev_handle
*pHDev
,
491 int command_buffer_size
,
493 int reply_buffer_size
495 u8 ep2_buffer
[USB_EP2IN_SIZE
];
499 LOG_DEBUG(": %d/%d\n", command_buffer_size
, reply_buffer_size
);
501 usb_err
= usb_bulk_write(
504 (char *)command_buffer
, USB_EP2BANK_SIZE
,
507 if(usb_err
< 0) return(usb_err
);
510 /* Wait for DTC to finish running command buffer */
512 usb_err
= ep1_generic_commandl(
516 DTC_STATUS_POLL_BYTE
>> 8,
517 DTC_STATUS_POLL_BYTE
,
520 if(usb_err
< 0) return(usb_err
);
522 usb_err
= usb_bulk_read(
525 (char *)ep2_buffer
, 1,
528 if(usb_err
< 0) return(usb_err
);
530 if(ep2_buffer
[0] & 0x01) break;
533 LOG_ERROR("%s, %d: too many retries waiting for DTC status\n",
541 if(!reply_buffer
) reply_buffer_size
= 0;
542 if(reply_buffer_size
) {
543 usb_err
= usb_bulk_read(
546 (char *)ep2_buffer
, sizeof(ep2_buffer
),
550 if(usb_err
< (int)sizeof(ep2_buffer
)) {
551 LOG_ERROR("%s, %d: Read of endpoint 2 returned %d\n",
552 __FILE__
, __LINE__
, usb_err
557 memcpy(reply_buffer
, ep2_buffer
, reply_buffer_size
);
566 * The dtc reply queue is a singly linked list that describes what to do with the reply packet that comes from the DTC. Only SCAN_IN and SCAN_IO generate these entries.
570 struct dtc_reply_queue_entry_s
{
571 struct dtc_reply_queue_entry_s
*next
;
572 jtag_command_t
*cmd
; /* the command that resulted in this entry */
575 u8
*buffer
; /* the scan buffer */
576 int size
; /* size of the scan buffer in bits */
577 int offset
; /* how many bits were already done before this? */
578 int length
; /* how many bits are processed in this operation? */
579 enum scan_type type
; /* SCAN_IN/SCAN_OUT/SCAN_IO */
581 } dtc_reply_queue_entry_t
;
585 * The dtc_queue consists of a buffer of pending commands and a reply queue.
586 * rlink_scan and tap_state_run add to the command buffer and maybe to the reply queue.
591 dtc_reply_queue_entry_t
*rq_head
;
592 dtc_reply_queue_entry_t
*rq_tail
;
595 u8 cmd_buffer
[USB_EP2BANK_SIZE
];
600 * The tap state queue is for accumulating TAP state changes wiithout needlessly flushing the dtc_queue. When it fills or is run, it adds the accumulated bytes to the dtc_queue.
613 dtc_queue_init(void) {
614 dtc_queue
.rq_head
= NULL
;
615 dtc_queue
.rq_tail
= NULL
;
616 dtc_queue
.cmd_index
= 0;
617 dtc_queue
.reply_index
= 0;
624 dtc_reply_queue_entry_t
*
625 dtc_queue_enqueue_reply(
633 dtc_reply_queue_entry_t
*rq_entry
;
635 rq_entry
= malloc(sizeof(dtc_reply_queue_entry_t
));
636 if(rq_entry
!= NULL
) {
637 rq_entry
->scan
.type
= type
;
638 rq_entry
->scan
.buffer
= buffer
;
639 rq_entry
->scan
.size
= size
;
640 rq_entry
->scan
.offset
= offset
;
641 rq_entry
->scan
.length
= length
;
643 rq_entry
->next
= NULL
;
645 if(dtc_queue
.rq_head
== NULL
)
646 dtc_queue
.rq_head
= rq_entry
;
648 dtc_queue
.rq_tail
->next
= rq_entry
;
650 dtc_queue
.rq_tail
= rq_entry
;
658 * Running the queue means that any pending command buffer is run and any reply data dealt with. The command buffer is then cleared for subsequent processing.
659 * The queue is automatically run by append when it is necessary to get space for the append.
664 dtc_queue_run(void) {
665 dtc_reply_queue_entry_t
*rq_p
, *rq_next
;
671 u8 dtc_mask
, tdo_mask
;
672 u8 reply_buffer
[USB_EP2IN_SIZE
];
676 if(dtc_queue
.cmd_index
< 1) return(retval
);
678 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] = DTC_CMD_STOP
;
681 if(dtc_queue
.rq_head
== NULL
) {
682 usb_err
= dtc_run_download(pHDev
,
683 dtc_queue
.cmd_buffer
, dtc_queue
.cmd_index
,
687 LOG_ERROR("dtc_run_download: %s\n", usb_strerror());
691 usb_err
= dtc_run_download(pHDev
,
692 dtc_queue
.cmd_buffer
, dtc_queue
.cmd_index
,
693 reply_buffer
, dtc_queue
.reply_index
696 LOG_ERROR("dtc_run_download: %s\n", usb_strerror());
699 /* process the reply, which empties the reply queue and frees its entries */
700 dtc_p
= reply_buffer
;
702 /* The rigamarole with the masks and doing it bit-by-bit is due to the fact that the scan buffer is LSb-first and the DTC code is MSb-first for hardware reasons. It was that or craft a function to do the reversal, and that wouldn't work with bit-stuffing (supplying extra bits to use mostly byte operations), or any other scheme which would throw the byte alignment off. */
705 rq_p
= dtc_queue
.rq_head
;
709 tdo_p
= rq_p
->scan
.buffer
+ (rq_p
->scan
.offset
/ 8);
710 tdo_mask
= 1 << (rq_p
->scan
.offset
% 8);
713 bit_cnt
= rq_p
->scan
.length
;
717 dtc_mask
= 1 << (8 - 1);
724 if(*dtc_p
& dtc_mask
) {
733 dtc_mask
= 1 << (8 - 1);
743 /* extra bits or last bit */
747 rq_p
->scan
.type
== SCAN_IN
749 rq_p
->scan
.offset
!= rq_p
->scan
.size
- 1
751 /* extra bits were sent as a full byte with padding on the end */
752 dtc_mask
= 1 << (8 - 1);
754 dtc_mask
= 1 << (bit_cnt
- 1);
779 if((rq_p
->scan
.offset
+ rq_p
->scan
.length
) >= rq_p
->scan
.size
) {
780 /* feed scan buffer back into openocd and free it */
781 if(jtag_read_buffer(rq_p
->scan
.buffer
, rq_p
->cmd
->cmd
.scan
) != ERROR_OK
) {
782 retval
= ERROR_JTAG_QUEUE_FAILED
;
784 free(rq_p
->scan
.buffer
);
787 rq_next
= rq_p
->next
;
790 dtc_queue
.rq_head
= NULL
;
791 dtc_queue
.rq_tail
= NULL
;
797 /* reset state for new appends */
798 dtc_queue
.cmd_index
= 0;
799 dtc_queue
.reply_index
= 0;
808 tap_state_queue_init(void) {
809 tap_state_queue
.length
= 0;
810 tap_state_queue
.buffer
= 0;
817 tap_state_queue_run(void) {
824 if(!tap_state_queue
.length
) return(retval
);
827 for(i
= tap_state_queue
.length
; i
--;) {
830 if(tap_state_queue
.buffer
& 1) {
833 if((bits
>= 8) || !i
) {
836 /* make sure there's room for stop, byte op, and one byte */
837 if(dtc_queue
.cmd_index
>= (sizeof(dtc_queue
.cmd_buffer
) - (1 + 1 + 1))) {
838 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] =
843 #ifdef USE_HARDWARE_SHIFTER_FOR_TMS
845 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] =
846 DTC_CMD_SHIFT_TMS_BYTES(1);
849 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] =
850 DTC_CMD_SHIFT_TMS_BITS(bits
);
851 #ifdef USE_HARDWARE_SHIFTER_FOR_TMS
855 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] =
864 tap_state_queue
.buffer
>>= 1;
866 retval
= tap_state_queue_init();
873 tap_state_queue_append(
878 if(tap_state_queue
.length
>= sizeof(tap_state_queue
.buffer
) * 8) {
879 retval
= tap_state_queue_run();
880 if(retval
!= 0) return(retval
);
884 tap_state_queue
.buffer
|= (1 << tap_state_queue
.length
);
886 tap_state_queue
.length
++;
893 void rlink_end_state(tap_state_t state
)
895 if (tap_is_state_stable(state
))
896 tap_set_end_state(state
);
899 LOG_ERROR("BUG: %i is not a valid end state", state
);
906 void rlink_state_move(void) {
909 u8 tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
911 for (i
= 0; i
< 7; i
++)
913 tms
= (tms_scan
>> i
) & 1;
914 tap_state_queue_append(tms
);
917 tap_set_state(tap_get_end_state());
921 void rlink_path_move(pathmove_command_t
*cmd
)
923 int num_states
= cmd
->num_states
;
930 if (tap_state_transition(tap_get_state(), false) == cmd
->path
[state_count
])
934 else if (tap_state_transition(tap_get_state(), true) == cmd
->path
[state_count
])
940 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd
->path
[state_count
]));
944 tap_state_queue_append(tms
);
946 tap_set_state(cmd
->path
[state_count
]);
951 tap_set_end_state(tap_get_state());
956 void rlink_runtest(int num_cycles
)
960 tap_state_t saved_end_state
= tap_get_end_state();
962 /* only do a state_move when we're not already in RTI */
963 if (tap_get_state() != TAP_IDLE
)
965 rlink_end_state(TAP_IDLE
);
969 /* execute num_cycles */
970 for (i
= 0; i
< num_cycles
; i
++)
972 tap_state_queue_append(0);
975 /* finish in end_state */
976 rlink_end_state(saved_end_state
);
977 if (tap_get_state() != tap_get_end_state())
982 /* (1) assert or (0) deassert reset lines */
984 void rlink_reset(int trst
, int srst
)
989 bitmap
= ((~(ST7_PA_NLINE_DRIVER_ENABLE
)) & ST7_PA_NUNASSERTED
);
992 bitmap
&= ~ST7_PA_NJTAG_TRST
;
995 bitmap
&= ~ST7_PA_NRLINK_RST
;
998 usb_err
= ep1_generic_commandl(
1001 EP1_CMD_MEMORY_WRITE
,
1006 EP1_CMD_DTC_GET_CACHED_STATUS
1009 LOG_ERROR("%s: %s\n", __func__
, usb_strerror());
1013 usb_err
= usb_bulk_read(
1014 pHDev
, USB_EP1IN_ADDR
,
1019 LOG_ERROR("%s: %s\n", __func__
, usb_strerror());
1028 jtag_command_t
*cmd
,
1029 enum scan_type type
,
1034 tap_state_t saved_end_state
;
1042 u8 tdi_mask
, *tdi_p
;
1046 LOG_ERROR("scan_size cannot be less than 1 bit\n");
1050 ir_scan
= cmd
->cmd
.scan
->ir_scan
;
1052 /* Move to the proper state before starting to shift TDI/TDO. */
1054 (!ir_scan
&& (tap_get_state() == TAP_DRSHIFT
))
1056 (ir_scan
&& (tap_get_state() == TAP_IRSHIFT
))
1058 saved_end_state
= tap_get_end_state();
1059 rlink_end_state(ir_scan
? TAP_IRSHIFT
: TAP_DRSHIFT
);
1061 rlink_end_state(saved_end_state
);
1064 tap_state_queue_run();
1068 printf("scan_size = %d, type=0x%x\n", scan_size
, type
);
1072 /* clear unused bits in scan buffer for ease of debugging */
1073 /* (it makes diffing output easier) */
1074 buffer
[scan_size
/ 8] &= ((1 << ((scan_size
- 1) % 8) + 1) - 1);
1076 printf("before scan:");
1077 for(i
= 0; i
< (scan_size
+ 7) / 8; i
++) {
1078 printf(" %02x", buffer
[i
]);
1084 /* The number of bits that can be shifted as complete bytes */
1085 byte_bits
= (int)(scan_size
- 1) / 8 * 8;
1086 /* The number of bits left over, not counting the last bit */
1087 extra_bits
= (scan_size
- 1) - byte_bits
;
1093 if(extra_bits
&& (type
== SCAN_OUT
)) {
1094 /* Schedule any extra bits into the DTC command buffer, padding as needed */
1095 /* For SCAN_OUT, this comes before the full bytes so the (leading) padding bits will fall off the end */
1096 /* make sure there's room for stop, byte op, and one byte */
1098 (dtc_queue
.cmd_index
>= sizeof(dtc_queue
.cmd_buffer
) - (1 + 1 + 1))
1104 dtc_mask
= 1 << (extra_bits
- 1);
1106 while(extra_bits
--) {
1107 if(*tdi_p
& tdi_mask
) {
1120 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] =
1121 DTC_CMD_SHIFT_TDI_BYTES(1);
1123 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] = x
;
1126 /* Loop scheduling full bytes into the DTC command buffer */
1128 if(type
== SCAN_IN
) {
1129 /* make sure there's room for stop and byte op */
1130 x
= (dtc_queue
.cmd_index
>= sizeof(dtc_queue
.cmd_buffer
) - (1 + 1));
1132 /* make sure there's room for stop, byte op, and at least one byte */
1133 x
= (dtc_queue
.cmd_index
>= sizeof(dtc_queue
.cmd_buffer
) - (1 + 1 + 1));
1136 if(type
!= SCAN_OUT
) {
1137 /* make sure there's room for at least one reply byte */
1138 x
|= (dtc_queue
.reply_index
>= USB_EP2IN_SIZE
- (1));
1145 chunk_bits
= byte_bits
;
1146 /* we can only use up to 16 bytes at a time */
1147 if(chunk_bits
> (16 * 8)) chunk_bits
= (16 * 8);
1149 if(type
!= SCAN_IN
) {
1150 /* how much is there room for, considering stop and byte op? */
1151 x
= (sizeof(dtc_queue
.cmd_buffer
) - (dtc_queue
.cmd_index
+ 1 + 1)) * 8;
1152 if(chunk_bits
> x
) chunk_bits
= x
;
1155 if(type
!= SCAN_OUT
) {
1156 /* how much is there room for in the reply buffer? */
1157 x
= (USB_EP2IN_SIZE
- dtc_queue
.reply_index
) * 8;
1158 if(chunk_bits
> x
) chunk_bits
= x
;
1161 /* so the loop will end */
1162 byte_bits
-= chunk_bits
;
1164 if(type
!= SCAN_OUT
) {
1165 if(dtc_queue_enqueue_reply(
1166 type
, buffer
, scan_size
, tdi_bit_offset
,
1170 LOG_ERROR("enqueuing DTC reply entry: %s\n", strerror(errno
));
1174 tdi_bit_offset
+= chunk_bits
;
1177 /* chunk_bits is a multiple of 8, so there are no rounding issues. */
1178 chunk_bytes
= chunk_bits
/ 8;
1182 x
= DTC_CMD_SHIFT_TDO_BYTES(chunk_bytes
);
1185 x
= DTC_CMD_SHIFT_TDI_BYTES(chunk_bytes
);
1188 x
= DTC_CMD_SHIFT_TDIO_BYTES(chunk_bytes
);
1191 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] = x
;
1193 if(type
!= SCAN_IN
) {
1195 dtc_mask
= 1 << (8 - 1);
1197 while(chunk_bits
--) {
1198 if(*tdi_p
& tdi_mask
) {
1204 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] = x
;
1205 dtc_queue
.reply_index
++;
1207 dtc_mask
= 1 << (8 - 1);
1219 if(extra_bits
&& (type
!= SCAN_OUT
)) {
1220 /* Schedule any extra bits into the DTC command buffer */
1221 /* make sure there's room for stop, byte op, and one byte */
1223 (dtc_queue
.cmd_index
>= sizeof(dtc_queue
.cmd_buffer
) - (1 + 1 + 1))
1225 (dtc_queue
.reply_index
>= USB_EP2IN_SIZE
- (1))
1230 if(dtc_queue_enqueue_reply(
1231 type
, buffer
, scan_size
, tdi_bit_offset
,
1235 LOG_ERROR("enqueuing DTC reply entry: %s\n", strerror(errno
));
1239 tdi_bit_offset
+= extra_bits
;
1241 if(type
== SCAN_IN
) {
1242 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] =
1243 DTC_CMD_SHIFT_TDO_BYTES(1);
1246 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] =
1247 DTC_CMD_SHIFT_TDIO_BITS(extra_bits
);
1250 dtc_mask
= 1 << (8 - 1);
1252 while(extra_bits
--) {
1253 if(*tdi_p
& tdi_mask
) {
1266 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] = x
;
1269 dtc_queue
.reply_index
++;
1272 /* Schedule the last bit into the DTC command buffer */
1274 /* make sure there's room for stop, and bit pair command */
1276 (dtc_queue
.cmd_index
>= sizeof(dtc_queue
.cmd_buffer
) - (1 + 1))
1278 (dtc_queue
.reply_index
>= USB_EP2IN_SIZE
- (1))
1283 if(type
== SCAN_OUT
) {
1284 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] =
1285 DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p
& tdi_mask
), 0);
1288 if(dtc_queue_enqueue_reply(
1289 type
, buffer
, scan_size
, tdi_bit_offset
,
1293 LOG_ERROR("enqueuing DTC reply entry: %s\n", strerror(errno
));
1297 dtc_queue
.cmd_buffer
[dtc_queue
.cmd_index
++] =
1298 DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p
& tdi_mask
), 1);
1300 dtc_queue
.reply_index
++;
1304 /* Move to pause state */
1305 tap_state_queue_append(0);
1306 tap_set_state(ir_scan
? TAP_IRPAUSE
: TAP_DRPAUSE
);
1307 if (tap_get_state() != tap_get_end_state()) rlink_state_move();
1314 int rlink_execute_queue(void)
1316 jtag_command_t
*cmd
= jtag_command_queue
; /* currently processed command */
1318 enum scan_type type
;
1320 int retval
, tmp_retval
;
1322 /* return ERROR_OK, unless something goes wrong */
1325 #ifndef AUTOMATIC_BUSY_LED
1327 ep1_generic_commandl(pHDev
, 2,
1328 EP1_CMD_SET_PORTD_LEDS
,
1337 case JTAG_END_STATE
:
1339 case JTAG_STATEMOVE
:
1345 /* some events, such as resets, need a queue flush to ensure consistency */
1346 tap_state_queue_run();
1353 case JTAG_END_STATE
:
1354 #ifdef _DEBUG_JTAG_IO_
1355 LOG_DEBUG("end_state: %i", cmd
->cmd
.end_state
->end_state
);
1357 if (cmd
->cmd
.end_state
->end_state
!= -1)
1358 rlink_end_state(cmd
->cmd
.end_state
->end_state
);
1361 #ifdef _DEBUG_JTAG_IO_
1362 LOG_DEBUG("reset trst: %i srst %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1364 if ((cmd
->cmd
.reset
->trst
== 1) || (cmd
->cmd
.reset
->srst
&& (jtag_reset_config
& RESET_SRST_PULLS_TRST
)))
1366 tap_set_state(TAP_RESET
);
1368 rlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1371 #ifdef _DEBUG_JTAG_IO_
1372 LOG_DEBUG("runtest %i cycles, end in %i", cmd
->cmd
.runtest
->num_cycles
, cmd
->cmd
.runtest
->end_state
);
1374 if (cmd
->cmd
.runtest
->end_state
!= -1)
1375 rlink_end_state(cmd
->cmd
.runtest
->end_state
);
1376 rlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
1378 case JTAG_STATEMOVE
:
1379 #ifdef _DEBUG_JTAG_IO_
1380 LOG_DEBUG("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
1382 if (cmd
->cmd
.statemove
->end_state
!= -1)
1383 rlink_end_state(cmd
->cmd
.statemove
->end_state
);
1387 #ifdef _DEBUG_JTAG_IO_
1388 LOG_DEBUG("pathmove: %i states, end in %i", cmd
->cmd
.pathmove
->num_states
, cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
1390 rlink_path_move(cmd
->cmd
.pathmove
);
1393 #ifdef _DEBUG_JTAG_IO_
1394 LOG_DEBUG("%s scan end in %i", (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", cmd
->cmd
.scan
->end_state
);
1396 if (cmd
->cmd
.scan
->end_state
!= -1)
1397 rlink_end_state(cmd
->cmd
.scan
->end_state
);
1398 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
1399 type
= jtag_scan_type(cmd
->cmd
.scan
);
1400 if(rlink_scan(cmd
, type
, buffer
, scan_size
) != ERROR_OK
) {
1401 retval
= ERROR_FAIL
;
1405 #ifdef _DEBUG_JTAG_IO_
1406 LOG_DEBUG("sleep %i", cmd
->cmd
.sleep
->us
);
1408 jtag_sleep(cmd
->cmd
.sleep
->us
);
1411 LOG_ERROR("BUG: unknown JTAG command type encountered");
1417 /* Flush the DTC queue to make sure any pending reads have been done before exiting this function */
1418 tap_state_queue_run();
1419 tmp_retval
= dtc_queue_run();
1420 if(tmp_retval
!= ERROR_OK
) {
1421 retval
= tmp_retval
;
1424 #ifndef AUTOMATIC_BUSY_LED
1426 ep1_generic_commandl(pHDev
, 2,
1427 EP1_CMD_SET_PORTD_LEDS
,
1436 /* Using an unindexed table because it is infrequently accessed and it is short. The table must be in order of ascending speed (and descending prescaler), as it is scanned in reverse. */
1439 int rlink_speed(int speed
)
1445 speed
= rlink_speed_table
[rlink_speed_table_size
- 1].prescaler
;
1448 for(i
= rlink_speed_table_size
; i
--; ) {
1449 if(rlink_speed_table
[i
].prescaler
== speed
) {
1450 if(dtc_load_from_buffer(pHDev
, rlink_speed_table
[i
].dtc
, rlink_speed_table
[i
].dtc_size
) != 0) {
1451 LOG_ERROR("An error occurred while trying to load DTC code for speed \"%d\".\n", speed
);
1455 if(dtc_start_download() < 0) {
1456 LOG_ERROR("%s, %d: starting DTC: %s",
1467 LOG_ERROR("%d is not a supported speed", speed
);
1473 int rlink_speed_div(
1479 for(i
= rlink_speed_table_size
; i
--; ) {
1480 if(rlink_speed_table
[i
].prescaler
== speed
) {
1481 *khz
= rlink_speed_table
[i
].khz
;
1486 LOG_ERROR("%d is not a supported speed", speed
);
1499 LOG_ERROR("RCLK not supported");
1503 for(i
= rlink_speed_table_size
; i
--; ) {
1504 if(rlink_speed_table
[i
].khz
<= khz
) {
1505 *speed
= rlink_speed_table
[i
].prescaler
;
1510 LOG_WARNING("The lowest supported JTAG speed is %d KHz", rlink_speed_table
[0].khz
);
1511 *speed
= rlink_speed_table
[0].prescaler
;
1519 handle_dtc_directory_command(
1520 struct command_context_s
*cmd_ctx
,
1526 LOG_ERROR("expected exactly one argument to rlink_dtc_directory <directory-path>");
1527 return(ERROR_INVALID_ARGUMENTS
);
1530 printf("handle_dtc_directory_command called with \"%s\"\n", args
[0]);
1538 int rlink_register_commands(struct command_context_s
*cmd_ctx
)
1541 #ifdef _DEBUG_JTAG_IO_
1542 LOG_DEBUG("rlink_register_commands called with cmd_ctx=%p\n", cmd_ctx
);
1548 "rlink_dtc_directory",
1549 handle_dtc_directory_command
,
1551 "The directory in which to search for DTC load images"
1560 int rlink_init(void)
1562 struct usb_bus
*busses
;
1563 struct usb_bus
*bus
;
1567 u8 reply_buffer
[USB_EP1IN_SIZE
];
1573 busses
= usb_get_busses();
1575 for(bus
= busses
; bus
; bus
= bus
->next
)
1577 struct usb_device
*dev
;
1579 for(dev
= bus
->devices
; dev
; dev
= dev
->next
)
1581 if( (dev
->descriptor
.idVendor
== USB_IDVENDOR
) && (dev
->descriptor
.idProduct
== USB_IDPRODUCT
) )
1584 LOG_DEBUG("Found device on bus.\n");
1588 if( dev
->descriptor
.bNumConfigurations
> 1 )
1590 LOG_ERROR("Whoops! NumConfigurations is not 1, don't know what to do...\n");
1593 if( dev
->config
->bNumInterfaces
> 1 )
1595 LOG_ERROR("Whoops! NumInterfaces is not 1, don't know what to do...\n");
1599 pHDev
=usb_open(dev
);
1601 LOG_ERROR ("Failed to open device.\n");
1604 LOG_DEBUG("Opened device, pHDev = %p\n",pHDev
);
1606 /* usb_set_configuration required under win32 */
1607 usb_set_configuration(pHDev
, dev
->config
[0].bConfigurationValue
);
1612 i
= usb_claim_interface(pHDev
,0);
1615 LOG_ERROR("usb_claim_interface: %s", usb_strerror());
1616 #ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
1617 j
= usb_detach_kernel_driver_np(pHDev
, 0);
1619 LOG_ERROR("detach kernel driver: %s", usb_strerror());
1624 LOG_DEBUG("interface claimed!\n");
1631 if( usb_set_altinterface(pHDev
,0) )
1633 LOG_ERROR("Failed to set interface.\n");
1647 LOG_ERROR("No device found on bus.\n");
1653 LOG_ERROR("Initialisation failed.");
1658 /* The device starts out in an unknown state on open. As such, result reads time out, and it's not even known whether the command was accepted. So, for this first command, we issue it repeatedly until its response doesn't time out. Also, if sending a command is going to time out, we'll find that out here. */
1659 /* It must be possible to open the device in such a way that this special magic isn't needed, but, so far, it escapes us. */
1660 for(i
= 0; i
< 5; i
++) {
1661 j
= ep1_generic_commandl(
1665 if(j
< USB_EP1OUT_SIZE
) {
1666 LOG_ERROR("USB write error: %s", usb_strerror());
1670 pHDev
, USB_EP1IN_ADDR
,
1671 (char *)reply_buffer
, sizeof(reply_buffer
),
1674 if(j
!= -ETIMEDOUT
) break;
1677 if(j
< (int)sizeof(reply_buffer
)) {
1678 LOG_ERROR("USB read error: %s", usb_strerror());
1681 LOG_DEBUG(INTERFACE_NAME
" firmware version: %d.%d.%d\n", reply_buffer
[0], reply_buffer
[1], reply_buffer
[2]);
1683 if((reply_buffer
[0] != 0) || (reply_buffer
[1] != 0) || (reply_buffer
[2] != 3)) {
1684 LOG_WARNING("The rlink device is not of the version that the developers have played with. It may or may not work.\n");
1687 /* Probe port E for adapter presence */
1688 ep1_generic_commandl(
1690 EP1_CMD_MEMORY_WRITE
, /* Drive sense pin with 0 */
1695 ST7_PE_ADAPTER_SENSE_OUT
,
1696 ST7_PE_ADAPTER_SENSE_OUT
,
1697 EP1_CMD_MEMORY_READ
, /* Read back */
1701 EP1_CMD_MEMORY_WRITE
, /* Drive sense pin with 1 */
1705 ST7_PE_ADAPTER_SENSE_OUT
1709 pHDev
, USB_EP1IN_ADDR
,
1710 (char *)reply_buffer
, 1,
1714 if((reply_buffer
[0] & ST7_PE_ADAPTER_SENSE_IN
) != 0) {
1715 LOG_WARNING("target detection problem\n");
1718 ep1_generic_commandl(
1720 EP1_CMD_MEMORY_READ
, /* Read back */
1724 EP1_CMD_MEMORY_WRITE
, /* float port E */
1734 pHDev
, USB_EP1IN_ADDR
,
1735 (char *)reply_buffer
, 1,
1740 if((reply_buffer
[0] & ST7_PE_ADAPTER_SENSE_IN
) == 0) {
1741 LOG_WARNING("target not plugged in\n");
1744 /* float port A, make sure DTC is stopped, set upper 2 bits of port D, and set up port A */
1745 ep1_generic_commandl(
1747 EP1_CMD_MEMORY_WRITE
,
1754 EP1_CMD_SET_PORTD_UPPER
,
1756 EP1_CMD_MEMORY_WRITE
,
1760 ((~(ST7_PA_NLINE_DRIVER_ENABLE
)) & ST7_PA_NUNASSERTED
),
1761 (ST7_PA_NLINE_DRIVER_ENABLE
| ST7_PA_NRLINK_RST
| ST7_PA_NJTAG_TRST
)
1764 /* set LED updating mode and make sure they're unlit */
1765 ep1_generic_commandl(
1767 #ifdef AUTOMATIC_BUSY_LED
1772 EP1_CMD_SET_PORTD_LEDS
,
1776 tap_state_queue_init();
1778 rlink_speed(jtag_speed
);
1786 int rlink_quit(void)
1788 /* stop DTC and make sure LEDs are off */
1789 ep1_generic_commandl(
1793 EP1_CMD_SET_PORTD_LEDS
,
1795 EP1_CMD_SET_PORTD_UPPER
,
1799 usb_release_interface(pHDev
,0);
1807 jtag_interface_t rlink_interface
=
1812 .register_commands
= rlink_register_commands
,
1813 .speed
= rlink_speed
,
1814 .speed_div
= rlink_speed_div
,
1816 .execute_queue
= rlink_execute_queue
,
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)