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 ***************************************************************************/
30 /* project specific includes */
31 #include <jtag/interface.h>
32 #include <jtag/commands.h>
34 #include "rlink_st7.h"
35 #include "rlink_ep1_cmd.h"
36 #include "rlink_dtc_cmd.h"
37 #include "usb_common.h"
40 /* 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. */
41 #undef AUTOMATIC_BUSY_LED
43 /* This feature may require derating the speed due to reduced hold time. */
44 #undef USE_HARDWARE_SHIFTER_FOR_TMS
47 #define INTERFACE_NAME "RLink"
49 #define USB_IDVENDOR (0x138e)
50 #define USB_IDPRODUCT (0x9000)
52 #define USB_EP1OUT_ADDR (0x01)
53 #define USB_EP1OUT_SIZE (16)
54 #define USB_EP1IN_ADDR (USB_EP1OUT_ADDR | 0x80)
55 #define USB_EP1IN_SIZE (USB_EP1OUT_SIZE)
57 #define USB_EP2OUT_ADDR (0x02)
58 #define USB_EP2OUT_SIZE (64)
59 #define USB_EP2IN_ADDR (USB_EP2OUT_ADDR | 0x80)
60 #define USB_EP2IN_SIZE (USB_EP2OUT_SIZE)
61 #define USB_EP2BANK_SIZE (512)
63 #define USB_TIMEOUT_MS (3 * 1000)
65 #define DTC_STATUS_POLL_BYTE (ST7_USB_BUF_EP0OUT + 0xff)
68 #define ST7_PD_NBUSY_LED ST7_PD0
69 #define ST7_PD_NRUN_LED ST7_PD1
70 /* low enables VPP at adapter header, high connects it to GND instead */
71 #define ST7_PD_VPP_SEL ST7_PD6
72 /* low: VPP = 12v, high: VPP <= 5v */
73 #define ST7_PD_VPP_SHDN ST7_PD7
75 /* These pins are connected together */
76 #define ST7_PE_ADAPTER_SENSE_IN ST7_PE3
77 #define ST7_PE_ADAPTER_SENSE_OUT ST7_PE4
79 /* Symbolic mapping between port pins and numbered IO lines */
80 #define ST7_PA_IO1 ST7_PA1
81 #define ST7_PA_IO2 ST7_PA2
82 #define ST7_PA_IO4 ST7_PA4
83 #define ST7_PA_IO8 ST7_PA6
84 #define ST7_PA_IO10 ST7_PA7
85 #define ST7_PB_IO5 ST7_PB5
86 #define ST7_PC_IO9 ST7_PC1
87 #define ST7_PC_IO3 ST7_PC2
88 #define ST7_PC_IO7 ST7_PC3
89 #define ST7_PE_IO6 ST7_PE5
91 /* Symbolic mapping between numbered IO lines and adapter signals */
92 #define ST7_PA_RTCK ST7_PA_IO0
93 #define ST7_PA_NTRST ST7_PA_IO1
94 #define ST7_PC_TDI ST7_PC_IO3
95 #define ST7_PA_DBGRQ ST7_PA_IO4
96 #define ST7_PB_NSRST ST7_PB_IO5
97 #define ST7_PE_TMS ST7_PE_IO6
98 #define ST7_PC_TCK ST7_PC_IO7
99 #define ST7_PC_TDO ST7_PC_IO9
100 #define ST7_PA_DBGACK ST7_PA_IO10
102 static usb_dev_handle *pHDev;
106 * ep1 commands are up to USB_EP1OUT_SIZE bytes in length.
107 * This function takes care of zeroing the unused bytes before sending the packet.
108 * Any reply packet is not handled by this function.
112 ep1_generic_commandl(
113 usb_dev_handle *pHDev_param,
117 uint8_t usb_buffer[USB_EP1OUT_SIZE];
118 uint8_t *usb_buffer_p;
122 if (length > sizeof(usb_buffer)) {
123 length = sizeof(usb_buffer);
126 usb_buffer_p = usb_buffer;
128 va_start(ap, length);
130 *usb_buffer_p++ = va_arg(ap, int);
137 sizeof(usb_buffer) - (usb_buffer_p - usb_buffer)
140 usb_ret = usb_bulk_write(
143 (char *)usb_buffer, sizeof(usb_buffer),
156 usb_dev_handle *pHDev,
161 uint8_t usb_buffer[USB_EP1OUT_SIZE];
166 usb_buffer[0] = EP1_CMD_MEMORY_READ;
170 sizeof(usb_buffer) - 4
177 if (remain > sizeof(usb_buffer)) {
178 length = sizeof(usb_buffer);
183 usb_buffer[1] = addr >> 8;
184 usb_buffer[2] = addr;
185 usb_buffer[3] = length;
187 usb_ret = usb_bulk_write(
188 pHDev, USB_EP1OUT_ADDR,
189 usb_buffer, sizeof(usb_buffer),
193 if (usb_ret < sizeof(usb_buffer)) {
197 usb_ret = usb_bulk_read(
198 pHDev, USB_EP1IN_ADDR,
203 if (usb_ret < length) {
222 usb_dev_handle *pHDev_param,
225 uint8_t const *buffer
227 uint8_t usb_buffer[USB_EP1OUT_SIZE];
232 usb_buffer[0] = EP1_CMD_MEMORY_WRITE;
238 if (remain > (sizeof(usb_buffer) - 4)) {
239 length = (sizeof(usb_buffer) - 4);
244 usb_buffer[1] = addr >> 8;
245 usb_buffer[2] = addr;
246 usb_buffer[3] = length;
253 usb_buffer + 4 + length,
255 sizeof(usb_buffer) - 4 - length
258 usb_ret = usb_bulk_write(
259 pHDev_param, USB_EP1OUT_ADDR,
260 (char *)usb_buffer, sizeof(usb_buffer),
264 if ((size_t)usb_ret < sizeof(usb_buffer)) {
282 usb_dev_handle *pHDev,
287 uint8_t buffer[USB_EP1OUT_SIZE - 4];
292 if (length > sizeof(buffer)) {
293 length = sizeof(buffer);
299 va_start(ap, length);
301 *buffer_p++ = va_arg(ap, int);
305 return(ep1_memory_write(pHDev, addr, length, buffer));
310 #define DTCLOAD_COMMENT (0)
311 #define DTCLOAD_ENTRY (1)
312 #define DTCLOAD_LOAD (2)
313 #define DTCLOAD_RUN (3)
314 #define DTCLOAD_LUT_START (4)
315 #define DTCLOAD_LUT (5)
317 #define DTC_LOAD_BUFFER ST7_USB_BUF_EP2UIDO
319 /* This gets set by the DTC loader */
320 static uint8_t dtc_entry_download;
323 /* The buffer is specially formatted to represent a valid image to load into the DTC. */
326 dtc_load_from_buffer(
327 usb_dev_handle *pHDev_param,
328 const uint8_t *buffer,
337 struct header_s *header;
338 uint8_t lut_start = 0xc0;
340 dtc_entry_download = 0;
342 /* Stop the DTC before loading anything. */
343 usb_err = ep1_generic_commandl(
347 if (usb_err < 0) return(usb_err);
350 if (length < sizeof(*header)) {
351 LOG_ERROR("Malformed DTC image");
355 header = (struct header_s *)buffer;
356 buffer += sizeof(*header);
357 length -= sizeof(*header);
359 if (length < (size_t)header->length + 1) {
360 LOG_ERROR("Malformed DTC image");
364 switch (header->type) {
365 case DTCLOAD_COMMENT:
369 /* store entry addresses somewhere */
370 if (!strncmp("download", (char *)buffer + 1, 8)) {
371 dtc_entry_download = buffer[0];
376 /* Send the DTC program to ST7 RAM. */
377 usb_err = ep1_memory_write(
380 header->length + 1, buffer
382 if (usb_err < 0) return(usb_err);
384 /* Load it into the DTC. */
385 usb_err = ep1_generic_commandl(
388 (DTC_LOAD_BUFFER >> 8),
391 if (usb_err < 0) return(usb_err);
396 usb_err = ep1_generic_commandl(
402 if (usb_err < 0) return(usb_err);
406 case DTCLOAD_LUT_START:
407 lut_start = buffer[0];
411 usb_err = ep1_memory_write(
413 ST7_USB_BUF_EP0OUT + lut_start,
414 header->length + 1, buffer
416 if (usb_err < 0) return(usb_err);
420 LOG_ERROR("Invalid DTC image record type: 0x%02x", header->type);
425 buffer += (header->length + 1);
426 length -= (header->length + 1);
434 * Start the DTC running in download mode (waiting for 512 byte command packets on ep2).
438 dtc_start_download(void) {
442 /* set up for download mode and make sure EP2 is set up to transmit */
443 usb_err = ep1_generic_commandl(
448 EP1_CMD_SET_DOWNLOAD,
449 EP1_CMD_MEMORY_READ, /* read EP2TXR for its data toggle */
454 if (usb_err < 0) return(usb_err);
456 /* read back ep2txr */
457 usb_err = usb_bulk_read(
458 pHDev, USB_EP1IN_ADDR,
462 if (usb_err < 0) return(usb_err);
464 usb_err = ep1_generic_commandl(
467 EP1_CMD_MEMORY_WRITE, /* preinitialize poll byte */
468 DTC_STATUS_POLL_BYTE >> 8,
469 DTC_STATUS_POLL_BYTE,
472 EP1_CMD_MEMORY_WRITE, /* set EP2IN to return data */
476 (ep2txr & ST7_EP2TXR_DTOG_TX) | ST7_EP2TXR_STAT_VALID,
477 EP1_CMD_DTC_CALL, /* start running the DTC */
479 EP1_CMD_DTC_GET_CACHED_STATUS
481 if (usb_err < 0) return(usb_err);
483 /* wait for completion */
484 usb_err = usb_bulk_read(
485 pHDev, USB_EP1IN_ADDR,
497 usb_dev_handle *pHDev_param,
498 uint8_t *command_buffer,
499 int command_buffer_size,
500 uint8_t *reply_buffer,
501 int reply_buffer_size
503 uint8_t ep2_buffer[USB_EP2IN_SIZE];
507 LOG_DEBUG(": %d/%d", command_buffer_size, reply_buffer_size);
509 usb_err = usb_bulk_write(
512 (char *)command_buffer, USB_EP2BANK_SIZE,
515 if (usb_err < 0) return(usb_err);
518 /* Wait for DTC to finish running command buffer */
520 usb_err = ep1_generic_commandl(
524 DTC_STATUS_POLL_BYTE >> 8,
525 DTC_STATUS_POLL_BYTE,
528 if (usb_err < 0) return(usb_err);
530 usb_err = usb_bulk_read(
533 (char *)ep2_buffer, 1,
536 if (usb_err < 0) return(usb_err);
538 if (ep2_buffer[0] & 0x01) break;
541 LOG_ERROR("%s, %d: too many retries waiting for DTC status",
549 if (!reply_buffer) reply_buffer_size = 0;
550 if (reply_buffer_size) {
551 usb_err = usb_bulk_read(
554 (char *)ep2_buffer, sizeof(ep2_buffer),
558 if (usb_err < (int)sizeof(ep2_buffer)) {
559 LOG_ERROR("%s, %d: Read of endpoint 2 returned %d",
560 __FILE__, __LINE__, usb_err
565 memcpy(reply_buffer, ep2_buffer, reply_buffer_size);
574 * 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.
577 struct dtc_reply_queue_entry {
578 struct dtc_reply_queue_entry *next;
579 struct jtag_command *cmd; /* the command that resulted in this entry */
582 uint8_t *buffer; /* the scan buffer */
583 int size; /* size of the scan buffer in bits */
584 int offset; /* how many bits were already done before this? */
585 int length; /* how many bits are processed in this operation? */
586 enum scan_type type; /* SCAN_IN/SCAN_OUT/SCAN_IO */
592 * The dtc_queue consists of a buffer of pending commands and a reply queue.
593 * rlink_scan and tap_state_run add to the command buffer and maybe to the reply queue.
598 struct dtc_reply_queue_entry *rq_head;
599 struct dtc_reply_queue_entry *rq_tail;
601 uint32_t reply_index;
602 uint8_t cmd_buffer[USB_EP2BANK_SIZE];
607 * 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.
620 dtc_queue_init(void) {
621 dtc_queue.rq_head = NULL;
622 dtc_queue.rq_tail = NULL;
623 dtc_queue.cmd_index = 0;
624 dtc_queue.reply_index = 0;
631 struct dtc_reply_queue_entry *
632 dtc_queue_enqueue_reply(
638 struct jtag_command *cmd
640 struct dtc_reply_queue_entry *rq_entry;
642 rq_entry = malloc(sizeof(struct dtc_reply_queue_entry));
643 if (rq_entry != NULL) {
644 rq_entry->scan.type = type;
645 rq_entry->scan.buffer = buffer;
646 rq_entry->scan.size = size;
647 rq_entry->scan.offset = offset;
648 rq_entry->scan.length = length;
650 rq_entry->next = NULL;
652 if (dtc_queue.rq_head == NULL)
653 dtc_queue.rq_head = rq_entry;
655 dtc_queue.rq_tail->next = rq_entry;
657 dtc_queue.rq_tail = rq_entry;
665 * 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.
666 * The queue is automatically run by append when it is necessary to get space for the append.
671 dtc_queue_run(void) {
672 struct dtc_reply_queue_entry *rq_p, *rq_next;
677 uint8_t *dtc_p, *tdo_p;
678 uint8_t dtc_mask, tdo_mask;
679 uint8_t reply_buffer[USB_EP2IN_SIZE];
681 assert((dtc_queue.rq_head != 0) == (dtc_queue.reply_index > 0));
682 assert(dtc_queue.cmd_index < USB_EP2BANK_SIZE);
683 assert(dtc_queue.reply_index <= USB_EP2IN_SIZE);
687 if (dtc_queue.cmd_index < 1) return(retval);
689 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = DTC_CMD_STOP;
692 if (dtc_queue.rq_head == NULL) {
693 usb_err = dtc_run_download(pHDev,
694 dtc_queue.cmd_buffer, dtc_queue.cmd_index,
698 LOG_ERROR("dtc_run_download: %s", usb_strerror());
702 usb_err = dtc_run_download(pHDev,
703 dtc_queue.cmd_buffer, dtc_queue.cmd_index,
704 reply_buffer, dtc_queue.reply_index
707 LOG_ERROR("dtc_run_download: %s", usb_strerror());
711 /* process the reply, which empties the reply queue and frees its entries */
712 dtc_p = reply_buffer;
714 /* 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. */
717 rq_p = dtc_queue.rq_head;
721 tdo_p = rq_p->scan.buffer + (rq_p->scan.offset / 8);
722 tdo_mask = 1 << (rq_p->scan.offset % 8);
725 bit_cnt = rq_p->scan.length;
729 dtc_mask = 1 << (8 - 1);
736 if (*dtc_p & dtc_mask) {
745 dtc_mask = 1 << (8 - 1);
755 /* extra bits or last bit */
759 rq_p->scan.type == SCAN_IN
761 rq_p->scan.offset != rq_p->scan.size - 1
763 /* extra bits were sent as a full byte with padding on the end */
764 dtc_mask = 1 << (8 - 1);
766 dtc_mask = 1 << (bit_cnt - 1);
791 if ((rq_p->scan.offset + rq_p->scan.length) >= rq_p->scan.size) {
792 /* feed scan buffer back into openocd and free it */
793 if (jtag_read_buffer(rq_p->scan.buffer, rq_p->cmd->cmd.scan) != ERROR_OK) {
794 retval = ERROR_JTAG_QUEUE_FAILED;
796 free(rq_p->scan.buffer);
799 rq_next = rq_p->next;
802 dtc_queue.rq_head = NULL;
803 dtc_queue.rq_tail = NULL;
807 /* reset state for new appends */
808 dtc_queue.cmd_index = 0;
809 dtc_queue.reply_index = 0;
816 tap_state_queue_init(void) {
817 tap_state_queue.length = 0;
818 tap_state_queue.buffer = 0;
825 tap_state_queue_run(void) {
832 if (!tap_state_queue.length) return(retval);
835 for (i = tap_state_queue.length; i--;) {
838 if (tap_state_queue.buffer & 1) {
841 if ((bits >= 8) || !i) {
842 byte_param <<= (8 - bits);
844 /* make sure there's room for stop, byte op, and one byte */
845 if (dtc_queue.cmd_index >= (sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1))) {
846 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
851 #ifdef USE_HARDWARE_SHIFTER_FOR_TMS
853 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
854 DTC_CMD_SHIFT_TMS_BYTES(1);
857 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
858 DTC_CMD_SHIFT_TMS_BITS(bits);
859 #ifdef USE_HARDWARE_SHIFTER_FOR_TMS
863 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
872 tap_state_queue.buffer >>= 1;
874 retval = tap_state_queue_init();
881 tap_state_queue_append(
886 if (tap_state_queue.length >= sizeof(tap_state_queue.buffer) * 8) {
887 retval = tap_state_queue_run();
888 if (retval != 0) return(retval);
892 tap_state_queue.buffer |= (1 << tap_state_queue.length);
894 tap_state_queue.length++;
901 void rlink_end_state(tap_state_t state)
903 if (tap_is_state_stable(state))
904 tap_set_end_state(state);
907 LOG_ERROR("BUG: %i is not a valid end state", state);
914 void rlink_state_move(void) {
917 uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
918 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
920 for (i = 0; i < tms_count; i++)
922 tms = (tms_scan >> i) & 1;
923 tap_state_queue_append(tms);
926 tap_set_state(tap_get_end_state());
930 void rlink_path_move(struct pathmove_command *cmd)
932 int num_states = cmd->num_states;
939 if (tap_state_transition(tap_get_state(), false) == cmd->path[state_count])
943 else if (tap_state_transition(tap_get_state(), true) == cmd->path[state_count])
949 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd->path[state_count]));
953 tap_state_queue_append(tms);
955 tap_set_state(cmd->path[state_count]);
960 tap_set_end_state(tap_get_state());
965 void rlink_runtest(int num_cycles)
969 tap_state_t saved_end_state = tap_get_end_state();
971 /* only do a state_move when we're not already in RTI */
972 if (tap_get_state() != TAP_IDLE)
974 rlink_end_state(TAP_IDLE);
978 /* execute num_cycles */
979 for (i = 0; i < num_cycles; i++)
981 tap_state_queue_append(0);
984 /* finish in end_state */
985 rlink_end_state(saved_end_state);
986 if (tap_get_state() != tap_get_end_state())
991 /* (1) assert or (0) deassert reset lines */
993 void rlink_reset(int trst, int srst)
998 /* Read port A for bit op */
999 usb_err = ep1_generic_commandl(
1001 EP1_CMD_MEMORY_READ,
1007 LOG_ERROR("%s", usb_strerror());
1011 usb_err = usb_bulk_read(
1012 pHDev, USB_EP1IN_ADDR,
1017 LOG_ERROR("%s", usb_strerror());
1022 bitmap &= ~ST7_PA_NTRST;
1024 bitmap |= ST7_PA_NTRST;
1027 /* Write port A and read port B for bit op */
1028 /* port B has no OR, and we want to emulate open drain on NSRST, so we initialize DR to 0 and assert NSRST by setting DDR to 1. */
1029 usb_err = ep1_generic_commandl(
1031 EP1_CMD_MEMORY_WRITE,
1036 EP1_CMD_MEMORY_READ,
1042 LOG_ERROR("%s", usb_strerror());
1046 usb_err = usb_bulk_read(
1047 pHDev, USB_EP1IN_ADDR,
1052 LOG_ERROR("%s", usb_strerror());
1057 bitmap |= ST7_PB_NSRST;
1059 bitmap &= ~ST7_PB_NSRST;
1062 /* write port B and read dummy to ensure completion before returning */
1063 usb_err = ep1_generic_commandl(
1065 EP1_CMD_MEMORY_WRITE,
1070 EP1_CMD_DTC_GET_CACHED_STATUS
1073 LOG_ERROR("%s", usb_strerror());
1077 usb_err = usb_bulk_read(
1078 pHDev, USB_EP1IN_ADDR,
1083 LOG_ERROR("%s", usb_strerror());
1092 struct jtag_command *cmd,
1093 enum scan_type type,
1098 tap_state_t saved_end_state;
1106 uint8_t tdi_mask, *tdi_p;
1109 if (scan_size < 1) {
1110 LOG_ERROR("scan_size cannot be less than 1 bit");
1114 ir_scan = cmd->cmd.scan->ir_scan;
1116 /* Move to the proper state before starting to shift TDI/TDO. */
1118 (!ir_scan && (tap_get_state() == TAP_DRSHIFT))
1120 (ir_scan && (tap_get_state() == TAP_IRSHIFT))
1122 saved_end_state = tap_get_end_state();
1123 rlink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
1125 rlink_end_state(saved_end_state);
1128 tap_state_queue_run();
1132 printf("scan_size = %d, type = 0x%x\n", scan_size, type);
1136 /* clear unused bits in scan buffer for ease of debugging */
1137 /* (it makes diffing output easier) */
1138 buffer[scan_size / 8] &= ((1 << ((scan_size - 1) % 8) + 1) - 1);
1140 printf("before scan:");
1141 for (i = 0; i < (scan_size + 7) / 8; i++) {
1142 printf(" %02x", buffer[i]);
1148 /* The number of bits that can be shifted as complete bytes */
1149 byte_bits = (int)(scan_size - 1) / 8 * 8;
1150 /* The number of bits left over, not counting the last bit */
1151 extra_bits = (scan_size - 1) - byte_bits;
1157 if (extra_bits && (type == SCAN_OUT)) {
1158 /* Schedule any extra bits into the DTC command buffer, padding as needed */
1159 /* For SCAN_OUT, this comes before the full bytes so the (leading) padding bits will fall off the end */
1160 /* make sure there's room for stop, byte op, and one byte */
1162 (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1))
1168 dtc_mask = 1 << (extra_bits - 1);
1170 while (extra_bits--) {
1171 if (*tdi_p & tdi_mask) {
1178 if (tdi_mask == 0) {
1184 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1185 DTC_CMD_SHIFT_TDI_BYTES(1);
1187 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1190 /* Loop scheduling full bytes into the DTC command buffer */
1192 if (type == SCAN_IN) {
1193 /* make sure there's room for stop and byte op */
1194 x = (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1));
1196 /* make sure there's room for stop, byte op, and at least one byte */
1197 x = (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1));
1200 if (type != SCAN_OUT) {
1201 /* make sure there's room for at least one reply byte */
1202 x |= (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1));
1209 chunk_bits = byte_bits;
1210 /* we can only use up to 16 bytes at a time */
1211 if (chunk_bits > (16 * 8)) chunk_bits = (16 * 8);
1213 if (type != SCAN_IN) {
1214 /* how much is there room for, considering stop and byte op? */
1215 x = (sizeof(dtc_queue.cmd_buffer) - (dtc_queue.cmd_index + 1 + 1)) * 8;
1216 if (chunk_bits > x) chunk_bits = x;
1219 if (type != SCAN_OUT) {
1220 /* how much is there room for in the reply buffer? */
1221 x = (USB_EP2IN_SIZE - dtc_queue.reply_index) * 8;
1222 if (chunk_bits > x) chunk_bits = x;
1225 /* so the loop will end */
1226 byte_bits -= chunk_bits;
1228 if (type != SCAN_OUT) {
1229 if (dtc_queue_enqueue_reply(
1230 type, buffer, scan_size, tdi_bit_offset,
1234 LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno));
1237 dtc_queue.reply_index += (chunk_bits + 7) / 8;
1239 tdi_bit_offset += chunk_bits;
1242 /* chunk_bits is a multiple of 8, so there are no rounding issues. */
1243 chunk_bytes = chunk_bits / 8;
1247 x = DTC_CMD_SHIFT_TDO_BYTES(chunk_bytes);
1250 x = DTC_CMD_SHIFT_TDI_BYTES(chunk_bytes);
1253 x = DTC_CMD_SHIFT_TDIO_BYTES(chunk_bytes);
1256 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1258 if (type != SCAN_IN) {
1260 dtc_mask = 1 << (8 - 1);
1262 while (chunk_bits--) {
1263 if (*tdi_p & tdi_mask) {
1268 if (dtc_mask == 0) {
1269 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1271 dtc_mask = 1 << (8 - 1);
1275 if (tdi_mask == 0) {
1283 if (extra_bits && (type != SCAN_OUT)) {
1284 /* Schedule any extra bits into the DTC command buffer */
1285 /* make sure there's room for stop, byte op, and one byte */
1287 (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1))
1289 (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1))
1294 if (dtc_queue_enqueue_reply(
1295 type, buffer, scan_size, tdi_bit_offset,
1299 LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno));
1303 dtc_queue.reply_index++;
1305 tdi_bit_offset += extra_bits;
1307 if (type == SCAN_IN) {
1308 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1309 DTC_CMD_SHIFT_TDO_BYTES(1);
1312 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1313 DTC_CMD_SHIFT_TDIO_BITS(extra_bits);
1316 dtc_mask = 1 << (8 - 1);
1318 while (extra_bits--) {
1319 if (*tdi_p & tdi_mask) {
1326 if (tdi_mask == 0) {
1332 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1336 /* Schedule the last bit into the DTC command buffer */
1337 /* make sure there's room for stop, and bit pair command */
1339 (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1))
1341 (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1))
1346 if (type == SCAN_OUT) {
1347 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1348 DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 0);
1351 if (dtc_queue_enqueue_reply(
1352 type, buffer, scan_size, tdi_bit_offset,
1356 LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno));
1360 dtc_queue.reply_index++;
1362 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1363 DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 1);
1366 /* Move to pause state */
1367 tap_state_queue_append(0);
1368 tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
1369 if (tap_get_state() != tap_get_end_state()) rlink_state_move();
1376 int rlink_execute_queue(void)
1378 struct jtag_command *cmd = jtag_command_queue; /* currently processed command */
1380 enum scan_type type;
1382 int retval, tmp_retval;
1384 /* return ERROR_OK, unless something goes wrong */
1387 #ifndef AUTOMATIC_BUSY_LED
1389 ep1_generic_commandl(pHDev, 2,
1390 EP1_CMD_SET_PORTD_LEDS,
1400 case JTAG_TLR_RESET:
1406 /* some events, such as resets, need a queue flush to ensure consistency */
1407 tap_state_queue_run();
1415 #ifdef _DEBUG_JTAG_IO_
1416 LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1418 if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
1420 tap_set_state(TAP_RESET);
1422 rlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1425 #ifdef _DEBUG_JTAG_IO_
1426 LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
1428 if (cmd->cmd.runtest->end_state != -1)
1429 rlink_end_state(cmd->cmd.runtest->end_state);
1430 rlink_runtest(cmd->cmd.runtest->num_cycles);
1432 case JTAG_TLR_RESET:
1433 #ifdef _DEBUG_JTAG_IO_
1434 LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
1436 if (cmd->cmd.statemove->end_state != -1)
1437 rlink_end_state(cmd->cmd.statemove->end_state);
1441 #ifdef _DEBUG_JTAG_IO_
1442 LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
1444 rlink_path_move(cmd->cmd.pathmove);
1447 #ifdef _DEBUG_JTAG_IO_
1448 LOG_DEBUG("%s scan end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", cmd->cmd.scan->end_state);
1450 if (cmd->cmd.scan->end_state != -1)
1451 rlink_end_state(cmd->cmd.scan->end_state);
1452 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1453 type = jtag_scan_type(cmd->cmd.scan);
1454 if (rlink_scan(cmd, type, buffer, scan_size) != ERROR_OK) {
1455 retval = ERROR_FAIL;
1459 #ifdef _DEBUG_JTAG_IO_
1460 LOG_DEBUG("sleep %i", cmd->cmd.sleep->us);
1462 jtag_sleep(cmd->cmd.sleep->us);
1465 LOG_ERROR("BUG: unknown JTAG command type encountered");
1471 /* Flush the DTC queue to make sure any pending reads have been done before exiting this function */
1472 tap_state_queue_run();
1473 tmp_retval = dtc_queue_run();
1474 if (tmp_retval != ERROR_OK) {
1475 retval = tmp_retval;
1478 #ifndef AUTOMATIC_BUSY_LED
1480 ep1_generic_commandl(pHDev, 2,
1481 EP1_CMD_SET_PORTD_LEDS,
1490 /* 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. */
1493 int rlink_speed(int speed)
1499 speed = rlink_speed_table[rlink_speed_table_size - 1].prescaler;
1502 for (i = rlink_speed_table_size; i--;) {
1503 if (rlink_speed_table[i].prescaler == speed) {
1504 if (dtc_load_from_buffer(pHDev, rlink_speed_table[i].dtc, rlink_speed_table[i].dtc_size) != 0) {
1505 LOG_ERROR("An error occurred while trying to load DTC code for speed \"%d\".", speed);
1509 if (dtc_start_download() < 0) {
1510 LOG_ERROR("%s, %d: starting DTC: %s",
1521 LOG_ERROR("%d is not a supported speed", speed);
1527 int rlink_speed_div(
1533 for (i = rlink_speed_table_size; i--;) {
1534 if (rlink_speed_table[i].prescaler == speed) {
1535 *khz = rlink_speed_table[i].khz;
1540 LOG_ERROR("%d is not a supported speed", speed);
1553 LOG_ERROR("RCLK not supported");
1557 for (i = rlink_speed_table_size; i--;) {
1558 if (rlink_speed_table[i].khz <= khz) {
1559 *speed = rlink_speed_table[i].prescaler;
1564 LOG_WARNING("The lowest supported JTAG speed is %d KHz", rlink_speed_table[0].khz);
1565 *speed = rlink_speed_table[0].prescaler;
1571 int rlink_init(void)
1574 uint8_t reply_buffer[USB_EP1IN_SIZE];
1577 const uint16_t vids[] = { USB_IDVENDOR, 0 };
1578 const uint16_t pids[] = { USB_IDPRODUCT, 0 };
1579 if (jtag_usb_open(vids, pids, &pHDev) != ERROR_OK)
1582 struct usb_device *dev = usb_device(pHDev);
1583 if (dev->descriptor.bNumConfigurations > 1)
1585 LOG_ERROR("Whoops! NumConfigurations is not 1, don't know what to do...");
1588 if (dev->config->bNumInterfaces > 1)
1590 LOG_ERROR("Whoops! NumInterfaces is not 1, don't know what to do...");
1594 LOG_DEBUG("Opened device, pHDev = %p", pHDev);
1596 /* usb_set_configuration required under win32 */
1597 usb_set_configuration(pHDev, dev->config[0].bConfigurationValue);
1602 i = usb_claim_interface(pHDev,0);
1605 LOG_ERROR("usb_claim_interface: %s", usb_strerror());
1606 #ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
1607 j = usb_detach_kernel_driver_np(pHDev, 0);
1609 LOG_ERROR("detach kernel driver: %s", usb_strerror());
1614 LOG_DEBUG("interface claimed!");
1617 } while (--retries);
1621 LOG_ERROR("Initialisation failed.");
1624 if (usb_set_altinterface(pHDev,0) != 0)
1626 LOG_ERROR("Failed to set interface.");
1630 /* The device starts out in an unknown state on open. As such,
1631 * result reads time out, and it's not even known whether the
1632 * command was accepted. So, for this first command, we issue
1633 * it repeatedly until its response doesn't time out. Also, if
1634 * sending a command is going to time out, we find that out here.
1636 * It must be possible to open the device in such a way that
1637 * this special magic isn't needed, but, so far, it escapes us.
1639 for (i = 0; i < 5; i++) {
1640 j = ep1_generic_commandl(
1644 if (j < USB_EP1OUT_SIZE) {
1645 LOG_ERROR("USB write error: %s", usb_strerror());
1649 pHDev, USB_EP1IN_ADDR,
1650 (char *)reply_buffer, sizeof(reply_buffer),
1653 if (j != -ETIMEDOUT) break;
1656 if (j < (int)sizeof(reply_buffer)) {
1657 LOG_ERROR("USB read error: %s", usb_strerror());
1660 LOG_DEBUG(INTERFACE_NAME" firmware version: %d.%d.%d", reply_buffer[0], reply_buffer[1], reply_buffer[2]);
1662 if ((reply_buffer[0] != 0) || (reply_buffer[1] != 0) || (reply_buffer[2] != 3)) {
1663 LOG_WARNING("The rlink device is not of the version that the developers have played with. It may or may not work.");
1666 /* Probe port E for adapter presence */
1667 ep1_generic_commandl(
1669 EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 0 */
1674 ST7_PE_ADAPTER_SENSE_OUT, /* DDR */
1675 ST7_PE_ADAPTER_SENSE_OUT, /* OR */
1676 EP1_CMD_MEMORY_READ, /* Read back */
1680 EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 1 */
1684 ST7_PE_ADAPTER_SENSE_OUT
1688 pHDev, USB_EP1IN_ADDR,
1689 (char *)reply_buffer, 1,
1693 if ((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) != 0) {
1694 LOG_WARNING("target detection problem");
1697 ep1_generic_commandl(
1699 EP1_CMD_MEMORY_READ, /* Read back */
1703 EP1_CMD_MEMORY_WRITE, /* float port E */
1713 pHDev, USB_EP1IN_ADDR,
1714 (char *)reply_buffer, 1,
1719 if ((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) == 0) {
1720 LOG_WARNING("target not plugged in");
1723 /* float ports A and B */
1724 ep1_generic_commandl(
1726 EP1_CMD_MEMORY_WRITE,
1732 EP1_CMD_MEMORY_WRITE,
1739 /* make sure DTC is stopped, set VPP control, set up ports A and B */
1740 ep1_generic_commandl(
1743 EP1_CMD_SET_PORTD_VPP,
1745 EP1_CMD_MEMORY_WRITE,
1749 ((~(0)) & (ST7_PA_NTRST)),
1751 /* port B has no OR, and we want to emulate open drain on NSRST, so we set DR to 0 here and later assert NSRST by setting DDR bit to 1. */
1752 EP1_CMD_MEMORY_WRITE,
1759 /* set LED updating mode and make sure they're unlit */
1760 ep1_generic_commandl(
1762 #ifdef AUTOMATIC_BUSY_LED
1767 EP1_CMD_SET_PORTD_LEDS,
1771 tap_state_queue_init();
1780 int rlink_quit(void)
1782 /* stop DTC and make sure LEDs are off */
1783 ep1_generic_commandl(
1787 EP1_CMD_SET_PORTD_LEDS,
1789 EP1_CMD_SET_PORTD_VPP,
1793 usb_release_interface(pHDev,0);
1801 struct jtag_interface rlink_interface =
1806 .speed = rlink_speed,
1807 .speed_div = rlink_speed_div,
1809 .execute_queue = rlink_execute_queue,