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 */
41 /* 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. */
42 #undef AUTOMATIC_BUSY_LED
44 /* This feature may require derating the speed due to reduced hold time. */
45 #undef USE_HARDWARE_SHIFTER_FOR_TMS
48 #define INTERFACE_NAME "RLink"
50 #define USB_IDVENDOR (0x138e)
51 #define USB_IDPRODUCT (0x9000)
53 #define USB_EP1OUT_ADDR (0x01)
54 #define USB_EP1OUT_SIZE (16)
55 #define USB_EP1IN_ADDR (USB_EP1OUT_ADDR | 0x80)
56 #define USB_EP1IN_SIZE (USB_EP1OUT_SIZE)
58 #define USB_EP2OUT_ADDR (0x02)
59 #define USB_EP2OUT_SIZE (64)
60 #define USB_EP2IN_ADDR (USB_EP2OUT_ADDR | 0x80)
61 #define USB_EP2IN_SIZE (USB_EP2OUT_SIZE)
62 #define USB_EP2BANK_SIZE (512)
64 #define USB_TIMEOUT_MS (3 * 1000)
66 #define DTC_STATUS_POLL_BYTE (ST7_USB_BUF_EP0OUT + 0xff)
69 #define ST7_PD_NBUSY_LED ST7_PD0
70 #define ST7_PD_NRUN_LED ST7_PD1
71 /* low enables VPP at adapter header, high connects it to GND instead */
72 #define ST7_PD_VPP_SEL ST7_PD6
73 /* low: VPP = 12v, high: VPP <= 5v */
74 #define ST7_PD_VPP_SHDN ST7_PD7
76 /* These pins are connected together */
77 #define ST7_PE_ADAPTER_SENSE_IN ST7_PE3
78 #define ST7_PE_ADAPTER_SENSE_OUT ST7_PE4
80 /* Symbolic mapping between port pins and numbered IO lines */
81 #define ST7_PA_IO1 ST7_PA1
82 #define ST7_PA_IO2 ST7_PA2
83 #define ST7_PA_IO4 ST7_PA4
84 #define ST7_PA_IO8 ST7_PA6
85 #define ST7_PA_IO10 ST7_PA7
86 #define ST7_PB_IO5 ST7_PB5
87 #define ST7_PC_IO9 ST7_PC1
88 #define ST7_PC_IO3 ST7_PC2
89 #define ST7_PC_IO7 ST7_PC3
90 #define ST7_PE_IO6 ST7_PE5
92 /* Symbolic mapping between numbered IO lines and adapter signals */
93 #define ST7_PA_RTCK ST7_PA_IO0
94 #define ST7_PA_NTRST ST7_PA_IO1
95 #define ST7_PC_TDI ST7_PC_IO3
96 #define ST7_PA_DBGRQ ST7_PA_IO4
97 #define ST7_PB_NSRST ST7_PB_IO5
98 #define ST7_PE_TMS ST7_PE_IO6
99 #define ST7_PC_TCK ST7_PC_IO7
100 #define ST7_PC_TDO ST7_PC_IO9
101 #define ST7_PA_DBGACK ST7_PA_IO10
103 static usb_dev_handle *pHDev;
107 * ep1 commands are up to USB_EP1OUT_SIZE bytes in length.
108 * This function takes care of zeroing the unused bytes before sending the packet.
109 * Any reply packet is not handled by this function.
113 ep1_generic_commandl(
114 usb_dev_handle *pHDev,
118 uint8_t usb_buffer[USB_EP1OUT_SIZE];
119 uint8_t *usb_buffer_p;
123 if(length > sizeof(usb_buffer)) {
124 length = sizeof(usb_buffer);
127 usb_buffer_p = usb_buffer;
129 va_start(ap, length);
131 *usb_buffer_p++ = va_arg(ap, int);
138 sizeof(usb_buffer) - (usb_buffer_p - usb_buffer)
141 usb_ret = usb_bulk_write(
144 (char *)usb_buffer, sizeof(usb_buffer),
157 usb_dev_handle *pHDev,
162 uint8_t usb_buffer[USB_EP1OUT_SIZE];
167 usb_buffer[0] = EP1_CMD_MEMORY_READ;
171 sizeof(usb_buffer) - 4
178 if(remain > sizeof(usb_buffer)) {
179 length = sizeof(usb_buffer);
184 usb_buffer[1] = addr >> 8;
185 usb_buffer[2] = addr;
186 usb_buffer[3] = length;
188 usb_ret = usb_bulk_write(
189 pHDev, USB_EP1OUT_ADDR,
190 usb_buffer, sizeof(usb_buffer),
194 if(usb_ret < sizeof(usb_buffer)) {
198 usb_ret = usb_bulk_read(
199 pHDev, USB_EP1IN_ADDR,
204 if(usb_ret < length) {
223 usb_dev_handle *pHDev,
226 uint8_t const *buffer
228 uint8_t usb_buffer[USB_EP1OUT_SIZE];
233 usb_buffer[0] = EP1_CMD_MEMORY_WRITE;
239 if(remain > (sizeof(usb_buffer) - 4)) {
240 length = (sizeof(usb_buffer) - 4);
245 usb_buffer[1] = addr >> 8;
246 usb_buffer[2] = addr;
247 usb_buffer[3] = length;
254 usb_buffer + 4 + length,
256 sizeof(usb_buffer) - 4 - length
259 usb_ret = usb_bulk_write(
260 pHDev, USB_EP1OUT_ADDR,
261 (char *)usb_buffer, sizeof(usb_buffer),
265 if((size_t)usb_ret < sizeof(usb_buffer)) {
283 usb_dev_handle *pHDev,
288 uint8_t buffer[USB_EP1OUT_SIZE - 4];
293 if(length > sizeof(buffer)) {
294 length = sizeof(buffer);
300 va_start(ap, length);
302 *buffer_p++ = va_arg(ap, int);
306 return(ep1_memory_write(pHDev, addr, length, buffer));
311 #define DTCLOAD_COMMENT (0)
312 #define DTCLOAD_ENTRY (1)
313 #define DTCLOAD_LOAD (2)
314 #define DTCLOAD_RUN (3)
315 #define DTCLOAD_LUT_START (4)
316 #define DTCLOAD_LUT (5)
318 #define DTC_LOAD_BUFFER ST7_USB_BUF_EP2UIDO
320 /* This gets set by the DTC loader */
321 static uint8_t dtc_entry_download;
324 /* The buffer is specially formatted to represent a valid image to load into the DTC. */
327 dtc_load_from_buffer(
328 usb_dev_handle *pHDev,
338 struct header_s *header;
341 dtc_entry_download = 0;
343 /* Stop the DTC before loading anything. */
344 usb_err = ep1_generic_commandl(
348 if(usb_err < 0) return(usb_err);
351 if(length < sizeof(*header)) {
352 LOG_ERROR("Malformed DTC image\n");
356 header = (struct header_s *)buffer;
357 buffer += sizeof(*header);
358 length -= sizeof(*header);
360 if(length < (size_t)header->length + 1) {
361 LOG_ERROR("Malformed DTC image\n");
365 switch(header->type) {
366 case DTCLOAD_COMMENT:
370 /* store entry addresses somewhere */
371 if(!strncmp("download", (char *)buffer + 1, 8)) {
372 dtc_entry_download = buffer[0];
377 /* Send the DTC program to ST7 RAM. */
378 usb_err = ep1_memory_write(
381 header->length + 1, buffer
383 if(usb_err < 0) return(usb_err);
385 /* Load it into the DTC. */
386 usb_err = ep1_generic_commandl(
389 (DTC_LOAD_BUFFER >> 8),
392 if(usb_err < 0) return(usb_err);
397 usb_err = ep1_generic_commandl(
403 if(usb_err < 0) return(usb_err);
407 case DTCLOAD_LUT_START:
408 lut_start = buffer[0];
412 usb_err = ep1_memory_write(
414 ST7_USB_BUF_EP0OUT + lut_start,
415 header->length + 1, buffer
417 if(usb_err < 0) return(usb_err);
421 LOG_ERROR("Invalid DTC image record type: 0x%02x\n", header->type);
426 buffer += (header->length + 1);
427 length -= (header->length + 1);
435 * Start the DTC running in download mode (waiting for 512 byte command packets on ep2).
439 dtc_start_download(void) {
443 /* set up for download mode and make sure EP2 is set up to transmit */
444 usb_err = ep1_generic_commandl(
449 EP1_CMD_SET_DOWNLOAD,
450 EP1_CMD_MEMORY_READ, /* read EP2TXR for its data toggle */
455 if(usb_err < 0) return(usb_err);
457 /* read back ep2txr */
458 usb_err = usb_bulk_read(
459 pHDev, USB_EP1IN_ADDR,
463 if(usb_err < 0) return(usb_err);
465 usb_err = ep1_generic_commandl(
468 EP1_CMD_MEMORY_WRITE, /* preinitialize poll byte */
469 DTC_STATUS_POLL_BYTE >> 8,
470 DTC_STATUS_POLL_BYTE,
473 EP1_CMD_MEMORY_WRITE, /* set EP2IN to return data */
477 (ep2txr & ST7_EP2TXR_DTOG_TX) | ST7_EP2TXR_STAT_VALID,
478 EP1_CMD_DTC_CALL, /* start running the DTC */
480 EP1_CMD_DTC_GET_CACHED_STATUS
482 if(usb_err < 0) return(usb_err);
484 /* wait for completion */
485 usb_err = usb_bulk_read(
486 pHDev, USB_EP1IN_ADDR,
498 usb_dev_handle *pHDev,
500 int command_buffer_size,
502 int reply_buffer_size
504 u8 ep2_buffer[USB_EP2IN_SIZE];
508 LOG_DEBUG(": %d/%d\n", command_buffer_size, reply_buffer_size);
510 usb_err = usb_bulk_write(
513 (char *)command_buffer, USB_EP2BANK_SIZE,
516 if(usb_err < 0) return(usb_err);
519 /* Wait for DTC to finish running command buffer */
521 usb_err = ep1_generic_commandl(
525 DTC_STATUS_POLL_BYTE >> 8,
526 DTC_STATUS_POLL_BYTE,
529 if(usb_err < 0) return(usb_err);
531 usb_err = usb_bulk_read(
534 (char *)ep2_buffer, 1,
537 if(usb_err < 0) return(usb_err);
539 if(ep2_buffer[0] & 0x01) break;
542 LOG_ERROR("%s, %d: too many retries waiting for DTC status\n",
550 if(!reply_buffer) reply_buffer_size = 0;
551 if(reply_buffer_size) {
552 usb_err = usb_bulk_read(
555 (char *)ep2_buffer, sizeof(ep2_buffer),
559 if(usb_err < (int)sizeof(ep2_buffer)) {
560 LOG_ERROR("%s, %d: Read of endpoint 2 returned %d\n",
561 __FILE__, __LINE__, usb_err
566 memcpy(reply_buffer, ep2_buffer, reply_buffer_size);
575 * 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.
579 struct dtc_reply_queue_entry_s {
580 struct dtc_reply_queue_entry_s *next;
581 jtag_command_t *cmd; /* the command that resulted in this entry */
584 u8 *buffer; /* the scan buffer */
585 int size; /* size of the scan buffer in bits */
586 int offset; /* how many bits were already done before this? */
587 int length; /* how many bits are processed in this operation? */
588 enum scan_type type; /* SCAN_IN/SCAN_OUT/SCAN_IO */
590 } dtc_reply_queue_entry_t;
594 * The dtc_queue consists of a buffer of pending commands and a reply queue.
595 * rlink_scan and tap_state_run add to the command buffer and maybe to the reply queue.
600 dtc_reply_queue_entry_t *rq_head;
601 dtc_reply_queue_entry_t *rq_tail;
604 u8 cmd_buffer[USB_EP2BANK_SIZE];
609 * 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.
622 dtc_queue_init(void) {
623 dtc_queue.rq_head = NULL;
624 dtc_queue.rq_tail = NULL;
625 dtc_queue.cmd_index = 0;
626 dtc_queue.reply_index = 0;
633 dtc_reply_queue_entry_t *
634 dtc_queue_enqueue_reply(
642 dtc_reply_queue_entry_t *rq_entry;
644 rq_entry = malloc(sizeof(dtc_reply_queue_entry_t));
645 if(rq_entry != NULL) {
646 rq_entry->scan.type = type;
647 rq_entry->scan.buffer = buffer;
648 rq_entry->scan.size = size;
649 rq_entry->scan.offset = offset;
650 rq_entry->scan.length = length;
652 rq_entry->next = NULL;
654 if(dtc_queue.rq_head == NULL)
655 dtc_queue.rq_head = rq_entry;
657 dtc_queue.rq_tail->next = rq_entry;
659 dtc_queue.rq_tail = rq_entry;
667 * 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.
668 * The queue is automatically run by append when it is necessary to get space for the append.
673 dtc_queue_run(void) {
674 dtc_reply_queue_entry_t *rq_p, *rq_next;
680 u8 dtc_mask, tdo_mask;
681 u8 reply_buffer[USB_EP2IN_SIZE];
685 if(dtc_queue.cmd_index < 1) return(retval);
687 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = DTC_CMD_STOP;
690 if(dtc_queue.rq_head == NULL) {
691 usb_err = dtc_run_download(pHDev,
692 dtc_queue.cmd_buffer, dtc_queue.cmd_index,
696 LOG_ERROR("dtc_run_download: %s\n", usb_strerror());
700 usb_err = dtc_run_download(pHDev,
701 dtc_queue.cmd_buffer, dtc_queue.cmd_index,
702 reply_buffer, dtc_queue.reply_index
705 LOG_ERROR("dtc_run_download: %s\n", usb_strerror());
708 /* process the reply, which empties the reply queue and frees its entries */
709 dtc_p = reply_buffer;
711 /* 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. */
714 rq_p = dtc_queue.rq_head;
718 tdo_p = rq_p->scan.buffer + (rq_p->scan.offset / 8);
719 tdo_mask = 1 << (rq_p->scan.offset % 8);
722 bit_cnt = rq_p->scan.length;
726 dtc_mask = 1 << (8 - 1);
733 if(*dtc_p & dtc_mask) {
742 dtc_mask = 1 << (8 - 1);
752 /* extra bits or last bit */
756 rq_p->scan.type == SCAN_IN
758 rq_p->scan.offset != rq_p->scan.size - 1
760 /* extra bits were sent as a full byte with padding on the end */
761 dtc_mask = 1 << (8 - 1);
763 dtc_mask = 1 << (bit_cnt - 1);
788 if((rq_p->scan.offset + rq_p->scan.length) >= rq_p->scan.size) {
789 /* feed scan buffer back into openocd and free it */
790 if(jtag_read_buffer(rq_p->scan.buffer, rq_p->cmd->cmd.scan) != ERROR_OK) {
791 retval = ERROR_JTAG_QUEUE_FAILED;
793 free(rq_p->scan.buffer);
796 rq_next = rq_p->next;
799 dtc_queue.rq_head = NULL;
800 dtc_queue.rq_tail = NULL;
806 /* reset state for new appends */
807 dtc_queue.cmd_index = 0;
808 dtc_queue.reply_index = 0;
817 tap_state_queue_init(void) {
818 tap_state_queue.length = 0;
819 tap_state_queue.buffer = 0;
826 tap_state_queue_run(void) {
833 if(!tap_state_queue.length) return(retval);
836 for(i = tap_state_queue.length; i--;) {
839 if(tap_state_queue.buffer & 1) {
842 if((bits >= 8) || !i) {
845 /* make sure there's room for stop, byte op, and one byte */
846 if(dtc_queue.cmd_index >= (sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1))) {
847 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
852 #ifdef USE_HARDWARE_SHIFTER_FOR_TMS
854 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
855 DTC_CMD_SHIFT_TMS_BYTES(1);
858 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
859 DTC_CMD_SHIFT_TMS_BITS(bits);
860 #ifdef USE_HARDWARE_SHIFTER_FOR_TMS
864 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
873 tap_state_queue.buffer >>= 1;
875 retval = tap_state_queue_init();
882 tap_state_queue_append(
887 if(tap_state_queue.length >= sizeof(tap_state_queue.buffer) * 8) {
888 retval = tap_state_queue_run();
889 if(retval != 0) return(retval);
893 tap_state_queue.buffer |= (1 << tap_state_queue.length);
895 tap_state_queue.length++;
902 void rlink_end_state(tap_state_t state)
904 if (tap_is_state_stable(state))
905 tap_set_end_state(state);
908 LOG_ERROR("BUG: %i is not a valid end state", state);
915 void rlink_state_move(void) {
918 u8 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
920 for (i = 0; i < 7; 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(pathmove_command_t *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 jtag_command_t *cmd,
1093 enum scan_type type,
1098 tap_state_t saved_end_state;
1106 u8 tdi_mask, *tdi_p;
1110 LOG_ERROR("scan_size cannot be less than 1 bit\n");
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) {
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\n", strerror(errno));
1238 tdi_bit_offset += chunk_bits;
1241 /* chunk_bits is a multiple of 8, so there are no rounding issues. */
1242 chunk_bytes = chunk_bits / 8;
1246 x = DTC_CMD_SHIFT_TDO_BYTES(chunk_bytes);
1249 x = DTC_CMD_SHIFT_TDI_BYTES(chunk_bytes);
1252 x = DTC_CMD_SHIFT_TDIO_BYTES(chunk_bytes);
1255 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1257 if(type != SCAN_IN) {
1259 dtc_mask = 1 << (8 - 1);
1261 while(chunk_bits--) {
1262 if(*tdi_p & tdi_mask) {
1268 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1269 dtc_queue.reply_index++;
1271 dtc_mask = 1 << (8 - 1);
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\n", strerror(errno));
1303 tdi_bit_offset += extra_bits;
1305 if(type == SCAN_IN) {
1306 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1307 DTC_CMD_SHIFT_TDO_BYTES(1);
1310 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1311 DTC_CMD_SHIFT_TDIO_BITS(extra_bits);
1314 dtc_mask = 1 << (8 - 1);
1316 while(extra_bits--) {
1317 if(*tdi_p & tdi_mask) {
1330 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1333 dtc_queue.reply_index++;
1336 /* Schedule the last bit into the DTC command buffer */
1338 /* make sure there's room for stop, and bit pair command */
1340 (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1))
1342 (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1))
1347 if(type == SCAN_OUT) {
1348 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1349 DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 0);
1352 if(dtc_queue_enqueue_reply(
1353 type, buffer, scan_size, tdi_bit_offset,
1357 LOG_ERROR("enqueuing DTC reply entry: %s\n", strerror(errno));
1361 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1362 DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 1);
1364 dtc_queue.reply_index++;
1368 /* Move to pause state */
1369 tap_state_queue_append(0);
1370 tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
1371 if (tap_get_state() != tap_get_end_state()) rlink_state_move();
1378 int rlink_execute_queue(void)
1380 jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
1382 enum scan_type type;
1384 int retval, tmp_retval;
1386 /* return ERROR_OK, unless something goes wrong */
1389 #ifndef AUTOMATIC_BUSY_LED
1391 ep1_generic_commandl(pHDev, 2,
1392 EP1_CMD_SET_PORTD_LEDS,
1401 case JTAG_END_STATE:
1403 case JTAG_STATEMOVE:
1409 /* some events, such as resets, need a queue flush to ensure consistency */
1410 tap_state_queue_run();
1417 case JTAG_END_STATE:
1418 #ifdef _DEBUG_JTAG_IO_
1419 LOG_DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
1421 if (cmd->cmd.end_state->end_state != -1)
1422 rlink_end_state(cmd->cmd.end_state->end_state);
1425 #ifdef _DEBUG_JTAG_IO_
1426 LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1428 if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST)))
1430 tap_set_state(TAP_RESET);
1432 rlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1435 #ifdef _DEBUG_JTAG_IO_
1436 LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
1438 if (cmd->cmd.runtest->end_state != -1)
1439 rlink_end_state(cmd->cmd.runtest->end_state);
1440 rlink_runtest(cmd->cmd.runtest->num_cycles);
1442 case JTAG_STATEMOVE:
1443 #ifdef _DEBUG_JTAG_IO_
1444 LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
1446 if (cmd->cmd.statemove->end_state != -1)
1447 rlink_end_state(cmd->cmd.statemove->end_state);
1451 #ifdef _DEBUG_JTAG_IO_
1452 LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
1454 rlink_path_move(cmd->cmd.pathmove);
1457 #ifdef _DEBUG_JTAG_IO_
1458 LOG_DEBUG("%s scan end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", cmd->cmd.scan->end_state);
1460 if (cmd->cmd.scan->end_state != -1)
1461 rlink_end_state(cmd->cmd.scan->end_state);
1462 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1463 type = jtag_scan_type(cmd->cmd.scan);
1464 if(rlink_scan(cmd, type, buffer, scan_size) != ERROR_OK) {
1465 retval = ERROR_FAIL;
1469 #ifdef _DEBUG_JTAG_IO_
1470 LOG_DEBUG("sleep %i", cmd->cmd.sleep->us);
1472 jtag_sleep(cmd->cmd.sleep->us);
1475 LOG_ERROR("BUG: unknown JTAG command type encountered");
1481 /* Flush the DTC queue to make sure any pending reads have been done before exiting this function */
1482 tap_state_queue_run();
1483 tmp_retval = dtc_queue_run();
1484 if(tmp_retval != ERROR_OK) {
1485 retval = tmp_retval;
1488 #ifndef AUTOMATIC_BUSY_LED
1490 ep1_generic_commandl(pHDev, 2,
1491 EP1_CMD_SET_PORTD_LEDS,
1500 /* 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. */
1503 int rlink_speed(int speed)
1509 speed = rlink_speed_table[rlink_speed_table_size - 1].prescaler;
1512 for(i = rlink_speed_table_size; i--; ) {
1513 if(rlink_speed_table[i].prescaler == speed) {
1514 if(dtc_load_from_buffer(pHDev, rlink_speed_table[i].dtc, rlink_speed_table[i].dtc_size) != 0) {
1515 LOG_ERROR("An error occurred while trying to load DTC code for speed \"%d\".\n", speed);
1519 if(dtc_start_download() < 0) {
1520 LOG_ERROR("%s, %d: starting DTC: %s",
1531 LOG_ERROR("%d is not a supported speed", speed);
1537 int rlink_speed_div(
1543 for(i = rlink_speed_table_size; i--; ) {
1544 if(rlink_speed_table[i].prescaler == speed) {
1545 *khz = rlink_speed_table[i].khz;
1550 LOG_ERROR("%d is not a supported speed", speed);
1563 LOG_ERROR("RCLK not supported");
1567 for(i = rlink_speed_table_size; i--; ) {
1568 if(rlink_speed_table[i].khz <= khz) {
1569 *speed = rlink_speed_table[i].prescaler;
1574 LOG_WARNING("The lowest supported JTAG speed is %d KHz", rlink_speed_table[0].khz);
1575 *speed = rlink_speed_table[0].prescaler;
1583 handle_dtc_directory_command(
1584 struct command_context_s *cmd_ctx,
1590 LOG_ERROR("expected exactly one argument to rlink_dtc_directory <directory-path>");
1591 return(ERROR_INVALID_ARGUMENTS);
1594 printf("handle_dtc_directory_command called with \"%s\"\n", args[0]);
1602 int rlink_register_commands(struct command_context_s *cmd_ctx)
1605 #ifdef _DEBUG_JTAG_IO_
1606 LOG_DEBUG("rlink_register_commands called with cmd_ctx=%p\n", cmd_ctx);
1612 "rlink_dtc_directory",
1613 handle_dtc_directory_command,
1615 "The directory in which to search for DTC load images"
1624 int rlink_init(void)
1626 struct usb_bus *busses;
1627 struct usb_bus *bus;
1631 u8 reply_buffer[USB_EP1IN_SIZE];
1637 busses = usb_get_busses();
1639 for(bus = busses; bus; bus = bus->next)
1641 struct usb_device *dev;
1643 for(dev = bus->devices; dev; dev = dev->next)
1645 if( (dev->descriptor.idVendor == USB_IDVENDOR) && (dev->descriptor.idProduct == USB_IDPRODUCT) )
1648 LOG_DEBUG("Found device on bus.\n");
1652 if( dev->descriptor.bNumConfigurations > 1 )
1654 LOG_ERROR("Whoops! NumConfigurations is not 1, don't know what to do...\n");
1657 if( dev->config->bNumInterfaces > 1 )
1659 LOG_ERROR("Whoops! NumInterfaces is not 1, don't know what to do...\n");
1663 pHDev=usb_open(dev);
1665 LOG_ERROR ("Failed to open device.\n");
1668 LOG_DEBUG("Opened device, pHDev = %p\n",pHDev);
1670 /* usb_set_configuration required under win32 */
1671 usb_set_configuration(pHDev, dev->config[0].bConfigurationValue);
1676 i = usb_claim_interface(pHDev,0);
1679 LOG_ERROR("usb_claim_interface: %s", usb_strerror());
1680 #ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
1681 j = usb_detach_kernel_driver_np(pHDev, 0);
1683 LOG_ERROR("detach kernel driver: %s", usb_strerror());
1688 LOG_DEBUG("interface claimed!\n");
1695 if( usb_set_altinterface(pHDev,0) )
1697 LOG_ERROR("Failed to set interface.\n");
1711 LOG_ERROR("No device found on bus.\n");
1717 LOG_ERROR("Initialisation failed.");
1722 /* 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. */
1723 /* 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. */
1724 for(i = 0; i < 5; i++) {
1725 j = ep1_generic_commandl(
1729 if(j < USB_EP1OUT_SIZE) {
1730 LOG_ERROR("USB write error: %s", usb_strerror());
1734 pHDev, USB_EP1IN_ADDR,
1735 (char *)reply_buffer, sizeof(reply_buffer),
1738 if(j != -ETIMEDOUT) break;
1741 if(j < (int)sizeof(reply_buffer)) {
1742 LOG_ERROR("USB read error: %s", usb_strerror());
1745 LOG_DEBUG(INTERFACE_NAME" firmware version: %d.%d.%d\n", reply_buffer[0], reply_buffer[1], reply_buffer[2]);
1747 if((reply_buffer[0] != 0) || (reply_buffer[1] != 0) || (reply_buffer[2] != 3)) {
1748 LOG_WARNING("The rlink device is not of the version that the developers have played with. It may or may not work.\n");
1751 /* Probe port E for adapter presence */
1752 ep1_generic_commandl(
1754 EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 0 */
1759 ST7_PE_ADAPTER_SENSE_OUT, /* DDR */
1760 ST7_PE_ADAPTER_SENSE_OUT, /* OR */
1761 EP1_CMD_MEMORY_READ, /* Read back */
1765 EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 1 */
1769 ST7_PE_ADAPTER_SENSE_OUT
1773 pHDev, USB_EP1IN_ADDR,
1774 (char *)reply_buffer, 1,
1778 if((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) != 0) {
1779 LOG_WARNING("target detection problem\n");
1782 ep1_generic_commandl(
1784 EP1_CMD_MEMORY_READ, /* Read back */
1788 EP1_CMD_MEMORY_WRITE, /* float port E */
1798 pHDev, USB_EP1IN_ADDR,
1799 (char *)reply_buffer, 1,
1804 if((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) == 0) {
1805 LOG_WARNING("target not plugged in\n");
1808 /* float ports A and B */
1809 ep1_generic_commandl(
1811 EP1_CMD_MEMORY_WRITE,
1817 EP1_CMD_MEMORY_WRITE,
1824 /* make sure DTC is stopped, set VPP control, set up ports A and B */
1825 ep1_generic_commandl(
1828 EP1_CMD_SET_PORTD_VPP,
1830 EP1_CMD_MEMORY_WRITE,
1834 ((~(0)) & (ST7_PA_NTRST)),
1836 /* 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. */
1837 EP1_CMD_MEMORY_WRITE,
1844 /* set LED updating mode and make sure they're unlit */
1845 ep1_generic_commandl(
1847 #ifdef AUTOMATIC_BUSY_LED
1852 EP1_CMD_SET_PORTD_LEDS,
1856 tap_state_queue_init();
1858 rlink_speed(jtag_speed);
1866 int rlink_quit(void)
1868 /* stop DTC and make sure LEDs are off */
1869 ep1_generic_commandl(
1873 EP1_CMD_SET_PORTD_LEDS,
1875 EP1_CMD_SET_PORTD_VPP,
1879 usb_release_interface(pHDev,0);
1887 jtag_interface_t rlink_interface =
1892 .register_commands = rlink_register_commands,
1893 .speed = rlink_speed,
1894 .speed_div = rlink_speed_div,
1896 .execute_queue = rlink_execute_queue,