rlink: remove duplicated code
[openocd.git] / src / jtag / drivers / rlink.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 √ėyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008 Rob Brown, Lou Deluxe *
9 * rob@cobbleware.com, lou.openocd012@fixit.nospammail.net *
10 * *
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. *
15 * *
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. *
20 * *
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 ***************************************************************************/
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29
30 /* project specific includes */
31 #include <jtag/interface.h>
32 #include <jtag/commands.h>
33 #include "rlink.h"
34 #include "rlink_st7.h"
35 #include "rlink_ep1_cmd.h"
36 #include "rlink_dtc_cmd.h"
37 #include "usb_common.h"
38
39
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
42
43 /* This feature may require derating the speed due to reduced hold time. */
44 #undef USE_HARDWARE_SHIFTER_FOR_TMS
45
46
47 #define INTERFACE_NAME "RLink"
48
49 #define USB_IDVENDOR (0x138e)
50 #define USB_IDPRODUCT (0x9000)
51
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)
56
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)
62
63 #define USB_TIMEOUT_MS (3 * 1000)
64
65 #define DTC_STATUS_POLL_BYTE (ST7_USB_BUF_EP0OUT + 0xff)
66
67
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
74
75 /* These pins are connected together */
76 #define ST7_PE_ADAPTER_SENSE_IN ST7_PE3
77 #define ST7_PE_ADAPTER_SENSE_OUT ST7_PE4
78
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
90
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
101
102 static usb_dev_handle *pHDev;
103
104
105 /*
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.
109 */
110 static
111 int
112 ep1_generic_commandl(
113 usb_dev_handle *pHDev_param,
114 size_t length,
115 ...
116 ) {
117 uint8_t usb_buffer[USB_EP1OUT_SIZE];
118 uint8_t *usb_buffer_p;
119 va_list ap;
120 int usb_ret;
121
122 if (length > sizeof(usb_buffer)) {
123 length = sizeof(usb_buffer);
124 }
125
126 usb_buffer_p = usb_buffer;
127
128 va_start(ap, length);
129 while (length > 0) {
130 *usb_buffer_p++ = va_arg(ap, int);
131 length--;
132 }
133
134 memset(
135 usb_buffer_p,
136 0,
137 sizeof(usb_buffer) - (usb_buffer_p - usb_buffer)
138 );
139
140 usb_ret = usb_bulk_write(
141 pHDev_param,
142 USB_EP1OUT_ADDR,
143 (char *)usb_buffer, sizeof(usb_buffer),
144 USB_TIMEOUT_MS
145 );
146
147 return(usb_ret);
148 }
149
150
151
152 #if 0
153 static
154 ssize_t
155 ep1_memory_read(
156 usb_dev_handle *pHDev,
157 uint16_t addr,
158 size_t length,
159 uint8_t *buffer
160 ) {
161 uint8_t usb_buffer[USB_EP1OUT_SIZE];
162 int usb_ret;
163 size_t remain;
164 ssize_t count;
165
166 usb_buffer[0] = EP1_CMD_MEMORY_READ;
167 memset(
168 usb_buffer + 4,
169 0,
170 sizeof(usb_buffer) - 4
171 );
172
173 remain = length;
174 count = 0;
175
176 while (remain) {
177 if (remain > sizeof(usb_buffer)) {
178 length = sizeof(usb_buffer);
179 } else {
180 length = remain;
181 }
182
183 usb_buffer[1] = addr >> 8;
184 usb_buffer[2] = addr;
185 usb_buffer[3] = length;
186
187 usb_ret = usb_bulk_write(
188 pHDev, USB_EP1OUT_ADDR,
189 usb_buffer, sizeof(usb_buffer),
190 USB_TIMEOUT_MS
191 );
192
193 if (usb_ret < sizeof(usb_buffer)) {
194 break;
195 }
196
197 usb_ret = usb_bulk_read(
198 pHDev, USB_EP1IN_ADDR,
199 buffer, length,
200 USB_TIMEOUT_MS
201 );
202
203 if (usb_ret < length) {
204 break;
205 }
206
207 addr += length;
208 buffer += length;
209 count += length;
210 remain -= length;
211 }
212
213 return(count);
214 }
215 #endif
216
217
218
219 static
220 ssize_t
221 ep1_memory_write(
222 usb_dev_handle *pHDev_param,
223 uint16_t addr,
224 size_t length,
225 uint8_t const *buffer
226 ) {
227 uint8_t usb_buffer[USB_EP1OUT_SIZE];
228 int usb_ret;
229 size_t remain;
230 ssize_t count;
231
232 usb_buffer[0] = EP1_CMD_MEMORY_WRITE;
233
234 remain = length;
235 count = 0;
236
237 while (remain) {
238 if (remain > (sizeof(usb_buffer) - 4)) {
239 length = (sizeof(usb_buffer) - 4);
240 } else {
241 length = remain;
242 }
243
244 usb_buffer[1] = addr >> 8;
245 usb_buffer[2] = addr;
246 usb_buffer[3] = length;
247 memcpy(
248 usb_buffer + 4,
249 buffer,
250 length
251 );
252 memset(
253 usb_buffer + 4 + length,
254 0,
255 sizeof(usb_buffer) - 4 - length
256 );
257
258 usb_ret = usb_bulk_write(
259 pHDev_param, USB_EP1OUT_ADDR,
260 (char *)usb_buffer, sizeof(usb_buffer),
261 USB_TIMEOUT_MS
262 );
263
264 if ((size_t)usb_ret < sizeof(usb_buffer)) {
265 break;
266 }
267
268 addr += length;
269 buffer += length;
270 count += length;
271 remain -= length;
272 }
273
274 return(count);
275 }
276
277
278 #if 0
279 static
280 ssize_t
281 ep1_memory_writel(
282 usb_dev_handle *pHDev,
283 uint16_t addr,
284 size_t length,
285 ...
286 ) {
287 uint8_t buffer[USB_EP1OUT_SIZE - 4];
288 uint8_t *buffer_p;
289 va_list ap;
290 size_t remain;
291
292 if (length > sizeof(buffer)) {
293 length = sizeof(buffer);
294 }
295
296 remain = length;
297 buffer_p = buffer;
298
299 va_start(ap, length);
300 while (remain > 0) {
301 *buffer_p++ = va_arg(ap, int);
302 remain--;
303 }
304
305 return(ep1_memory_write(pHDev, addr, length, buffer));
306 }
307 #endif
308
309
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)
316
317 #define DTC_LOAD_BUFFER ST7_USB_BUF_EP2UIDO
318
319 /* This gets set by the DTC loader */
320 static uint8_t dtc_entry_download;
321
322
323 /* The buffer is specially formatted to represent a valid image to load into the DTC. */
324 static
325 int
326 dtc_load_from_buffer(
327 usb_dev_handle *pHDev_param,
328 const uint8_t *buffer,
329 size_t length
330 ) {
331 struct header_s {
332 uint8_t type;
333 uint8_t length;
334 };
335
336 int usb_err;
337 struct header_s *header;
338 uint8_t lut_start = 0xc0;
339
340 dtc_entry_download = 0;
341
342 /* Stop the DTC before loading anything. */
343 usb_err = ep1_generic_commandl(
344 pHDev_param, 1,
345 EP1_CMD_DTC_STOP
346 );
347 if (usb_err < 0) return(usb_err);
348
349 while (length) {
350 if (length < sizeof(*header)) {
351 LOG_ERROR("Malformed DTC image");
352 exit(1);
353 }
354
355 header = (struct header_s *)buffer;
356 buffer += sizeof(*header);
357 length -= sizeof(*header);
358
359 if (length < (size_t)header->length + 1) {
360 LOG_ERROR("Malformed DTC image");
361 exit(1);
362 }
363
364 switch (header->type) {
365 case DTCLOAD_COMMENT:
366 break;
367
368 case DTCLOAD_ENTRY:
369 /* store entry addresses somewhere */
370 if (!strncmp("download", (char *)buffer + 1, 8)) {
371 dtc_entry_download = buffer[0];
372 }
373 break;
374
375 case DTCLOAD_LOAD:
376 /* Send the DTC program to ST7 RAM. */
377 usb_err = ep1_memory_write(
378 pHDev_param,
379 DTC_LOAD_BUFFER,
380 header->length + 1, buffer
381 );
382 if (usb_err < 0) return(usb_err);
383
384 /* Load it into the DTC. */
385 usb_err = ep1_generic_commandl(
386 pHDev_param, 3,
387 EP1_CMD_DTC_LOAD,
388 (DTC_LOAD_BUFFER >> 8),
389 DTC_LOAD_BUFFER
390 );
391 if (usb_err < 0) return(usb_err);
392
393 break;
394
395 case DTCLOAD_RUN:
396 usb_err = ep1_generic_commandl(
397 pHDev_param, 3,
398 EP1_CMD_DTC_CALL,
399 buffer[0],
400 EP1_CMD_DTC_WAIT
401 );
402 if (usb_err < 0) return(usb_err);
403
404 break;
405
406 case DTCLOAD_LUT_START:
407 lut_start = buffer[0];
408 break;
409
410 case DTCLOAD_LUT:
411 usb_err = ep1_memory_write(
412 pHDev_param,
413 ST7_USB_BUF_EP0OUT + lut_start,
414 header->length + 1, buffer
415 );
416 if (usb_err < 0) return(usb_err);
417 break;
418
419 default:
420 LOG_ERROR("Invalid DTC image record type: 0x%02x", header->type);
421 exit(1);
422 break;
423 }
424
425 buffer += (header->length + 1);
426 length -= (header->length + 1);
427 }
428
429 return(0);
430 }
431
432
433 /*
434 * Start the DTC running in download mode (waiting for 512 byte command packets on ep2).
435 */
436 static
437 int
438 dtc_start_download(void) {
439 int usb_err;
440 uint8_t ep2txr;
441
442 /* set up for download mode and make sure EP2 is set up to transmit */
443 usb_err = ep1_generic_commandl(
444 pHDev, 7,
445
446 EP1_CMD_DTC_STOP,
447 EP1_CMD_SET_UPLOAD,
448 EP1_CMD_SET_DOWNLOAD,
449 EP1_CMD_MEMORY_READ, /* read EP2TXR for its data toggle */
450 ST7_EP2TXR >> 8,
451 ST7_EP2TXR,
452 1
453 );
454 if (usb_err < 0) return(usb_err);
455
456 /* read back ep2txr */
457 usb_err = usb_bulk_read(
458 pHDev, USB_EP1IN_ADDR,
459 (char *)&ep2txr, 1,
460 USB_TIMEOUT_MS
461 );
462 if (usb_err < 0) return(usb_err);
463
464 usb_err = ep1_generic_commandl(
465 pHDev, 13,
466
467 EP1_CMD_MEMORY_WRITE, /* preinitialize poll byte */
468 DTC_STATUS_POLL_BYTE >> 8,
469 DTC_STATUS_POLL_BYTE,
470 1,
471 0x00,
472 EP1_CMD_MEMORY_WRITE, /* set EP2IN to return data */
473 ST7_EP2TXR >> 8,
474 ST7_EP2TXR,
475 1,
476 (ep2txr & ST7_EP2TXR_DTOG_TX) | ST7_EP2TXR_STAT_VALID,
477 EP1_CMD_DTC_CALL, /* start running the DTC */
478 dtc_entry_download,
479 EP1_CMD_DTC_GET_CACHED_STATUS
480 );
481 if (usb_err < 0) return(usb_err);
482
483 /* wait for completion */
484 usb_err = usb_bulk_read(
485 pHDev, USB_EP1IN_ADDR,
486 (char *)&ep2txr, 1,
487 USB_TIMEOUT_MS
488 );
489
490 return(usb_err);
491 }
492
493
494 static
495 int
496 dtc_run_download(
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
502 ) {
503 uint8_t ep2_buffer[USB_EP2IN_SIZE];
504 int usb_err;
505 int i;
506
507 LOG_DEBUG(": %d/%d", command_buffer_size, reply_buffer_size);
508
509 usb_err = usb_bulk_write(
510 pHDev_param,
511 USB_EP2OUT_ADDR,
512 (char *)command_buffer, USB_EP2BANK_SIZE,
513 USB_TIMEOUT_MS
514 );
515 if (usb_err < 0) return(usb_err);
516
517
518 /* Wait for DTC to finish running command buffer */
519 for (i = 10;;) {
520 usb_err = ep1_generic_commandl(
521 pHDev_param, 4,
522
523 EP1_CMD_MEMORY_READ,
524 DTC_STATUS_POLL_BYTE >> 8,
525 DTC_STATUS_POLL_BYTE,
526 1
527 );
528 if (usb_err < 0) return(usb_err);
529
530 usb_err = usb_bulk_read(
531 pHDev_param,
532 USB_EP1IN_ADDR,
533 (char *)ep2_buffer, 1,
534 USB_TIMEOUT_MS
535 );
536 if (usb_err < 0) return(usb_err);
537
538 if (ep2_buffer[0] & 0x01) break;
539
540 if (!--i) {
541 LOG_ERROR("%s, %d: too many retries waiting for DTC status",
542 __FILE__, __LINE__
543 );
544 return(-ETIMEDOUT);
545 }
546 }
547
548
549 if (!reply_buffer) reply_buffer_size = 0;
550 if (reply_buffer_size) {
551 usb_err = usb_bulk_read(
552 pHDev_param,
553 USB_EP2IN_ADDR,
554 (char *)ep2_buffer, sizeof(ep2_buffer),
555 USB_TIMEOUT_MS
556 );
557
558 if (usb_err < (int)sizeof(ep2_buffer)) {
559 LOG_ERROR("%s, %d: Read of endpoint 2 returned %d",
560 __FILE__, __LINE__, usb_err
561 );
562 return(usb_err);
563 }
564
565 memcpy(reply_buffer, ep2_buffer, reply_buffer_size);
566
567 }
568
569 return(usb_err);
570 }
571
572
573 /*
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.
575 */
576
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 */
580
581 struct {
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 */
587 } scan;
588 };
589
590
591 /*
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.
594 */
595
596 static
597 struct {
598 struct dtc_reply_queue_entry *rq_head;
599 struct dtc_reply_queue_entry *rq_tail;
600 uint32_t cmd_index;
601 uint32_t reply_index;
602 uint8_t cmd_buffer[USB_EP2BANK_SIZE];
603 } dtc_queue;
604
605
606 /*
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.
608 */
609
610 static
611 struct {
612 uint32_t length;
613 uint32_t buffer;
614 } tap_state_queue;
615
616
617
618 static
619 int
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;
625 return(0);
626 }
627
628
629 static
630 inline
631 struct dtc_reply_queue_entry *
632 dtc_queue_enqueue_reply(
633 enum scan_type type,
634 uint8_t *buffer,
635 int size,
636 int offset,
637 int length,
638 struct jtag_command *cmd
639 ) {
640 struct dtc_reply_queue_entry *rq_entry;
641
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;
649 rq_entry->cmd = cmd;
650 rq_entry->next = NULL;
651
652 if (dtc_queue.rq_head == NULL)
653 dtc_queue.rq_head = rq_entry;
654 else
655 dtc_queue.rq_tail->next = rq_entry;
656
657 dtc_queue.rq_tail = rq_entry;
658 }
659
660 return(rq_entry);
661 }
662
663
664 /*
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.
667 */
668
669 static
670 int
671 dtc_queue_run(void) {
672 struct dtc_reply_queue_entry *rq_p, *rq_next;
673 int retval;
674 int usb_err;
675 int bit_cnt;
676 int x;
677 uint8_t *dtc_p, *tdo_p;
678 uint8_t dtc_mask, tdo_mask;
679 uint8_t reply_buffer[USB_EP2IN_SIZE];
680
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);
684
685 retval = ERROR_OK;
686
687 if (dtc_queue.cmd_index < 1) return(retval);
688
689 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = DTC_CMD_STOP;
690
691 usb_err = dtc_run_download(pHDev,
692 dtc_queue.cmd_buffer, dtc_queue.cmd_index,
693 reply_buffer, dtc_queue.reply_index
694 );
695 if (usb_err < 0) {
696 LOG_ERROR("dtc_run_download: %s", usb_strerror());
697 exit(1);
698 }
699
700 if (dtc_queue.rq_head != NULL) {
701 /* process the reply, which empties the reply queue and frees its entries */
702 dtc_p = reply_buffer;
703
704 /* 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
706 for (
707 rq_p = dtc_queue.rq_head;
708 rq_p != NULL;
709 rq_p = rq_next
710 ) {
711 tdo_p = rq_p->scan.buffer + (rq_p->scan.offset / 8);
712 tdo_mask = 1 << (rq_p->scan.offset % 8);
713
714
715 bit_cnt = rq_p->scan.length;
716 if (bit_cnt >= 8) {
717 /* bytes */
718
719 dtc_mask = 1 << (8 - 1);
720
721 for (
722 ;
723 bit_cnt;
724 bit_cnt--
725 ) {
726 if (*dtc_p & dtc_mask) {
727 *tdo_p |= tdo_mask;
728 } else {
729 *tdo_p &=~ tdo_mask;
730 }
731
732 dtc_mask >>= 1;
733 if (dtc_mask == 0) {
734 dtc_p++;
735 dtc_mask = 1 << (8 - 1);
736 }
737
738 tdo_mask <<= 1;
739 if (tdo_mask == 0) {
740 tdo_p++;
741 tdo_mask = 1;
742 }
743 }
744 } else {
745 /* extra bits or last bit */
746
747 x = *dtc_p++;
748 if ((
749 rq_p->scan.type == SCAN_IN
750 ) && (
751 rq_p->scan.offset != rq_p->scan.size - 1
752 )) {
753 /* extra bits were sent as a full byte with padding on the end */
754 dtc_mask = 1 << (8 - 1);
755 } else {
756 dtc_mask = 1 << (bit_cnt - 1);
757 }
758
759 for (
760 ;
761 bit_cnt;
762 bit_cnt--
763 ) {
764 if (x & dtc_mask) {
765 *tdo_p |= tdo_mask;
766 } else {
767 *tdo_p &=~ tdo_mask;
768 }
769
770 dtc_mask >>= 1;
771
772 tdo_mask <<= 1;
773 if (tdo_mask == 0) {
774 tdo_p++;
775 tdo_mask = 1;
776 }
777
778 }
779 }
780
781 if ((rq_p->scan.offset + rq_p->scan.length) >= rq_p->scan.size) {
782 /* feed scan buffer back into openocd and free it */
783 if (jtag_read_buffer(rq_p->scan.buffer, rq_p->cmd->cmd.scan) != ERROR_OK) {
784 retval = ERROR_JTAG_QUEUE_FAILED;
785 }
786 free(rq_p->scan.buffer);
787 }
788
789 rq_next = rq_p->next;
790 free(rq_p);
791 }
792 dtc_queue.rq_head = NULL;
793 dtc_queue.rq_tail = NULL;
794 }
795
796
797 /* reset state for new appends */
798 dtc_queue.cmd_index = 0;
799 dtc_queue.reply_index = 0;
800
801 return(retval);
802 }
803
804 static
805 int
806 tap_state_queue_init(void) {
807 tap_state_queue.length = 0;
808 tap_state_queue.buffer = 0;
809 return(0);
810 }
811
812
813 static
814 int
815 tap_state_queue_run(void) {
816 int i;
817 int bits;
818 uint8_t byte_param;
819 int retval;
820
821 retval = 0;
822 if (!tap_state_queue.length) return(retval);
823 bits = 1;
824 byte_param = 0;
825 for (i = tap_state_queue.length; i--;) {
826
827 byte_param <<= 1;
828 if (tap_state_queue.buffer & 1) {
829 byte_param |= 1;
830 }
831 if ((bits >= 8) || !i) {
832 byte_param <<= (8 - bits);
833
834 /* make sure there's room for stop, byte op, and one byte */
835 if (dtc_queue.cmd_index >= (sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1))) {
836 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
837 DTC_CMD_STOP;
838 dtc_queue_run();
839 }
840
841 #ifdef USE_HARDWARE_SHIFTER_FOR_TMS
842 if (bits == 8) {
843 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
844 DTC_CMD_SHIFT_TMS_BYTES(1);
845 } else {
846 #endif
847 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
848 DTC_CMD_SHIFT_TMS_BITS(bits);
849 #ifdef USE_HARDWARE_SHIFTER_FOR_TMS
850 }
851 #endif
852
853 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
854 byte_param;
855
856 byte_param = 0;
857 bits = 1;
858 } else {
859 bits++;
860 }
861
862 tap_state_queue.buffer >>= 1;
863 }
864 retval = tap_state_queue_init();
865 return(retval);
866 }
867
868
869 static
870 int
871 tap_state_queue_append(
872 uint8_t tms
873 ) {
874 int retval;
875
876 if (tap_state_queue.length >= sizeof(tap_state_queue.buffer) * 8) {
877 retval = tap_state_queue_run();
878 if (retval != 0) return(retval);
879 }
880
881 if (tms) {
882 tap_state_queue.buffer |= (1 << tap_state_queue.length);
883 }
884 tap_state_queue.length++;
885
886 return(0);
887 }
888
889
890 static
891 void rlink_end_state(tap_state_t state)
892 {
893 if (tap_is_state_stable(state))
894 tap_set_end_state(state);
895 else
896 {
897 LOG_ERROR("BUG: %i is not a valid end state", state);
898 exit(-1);
899 }
900 }
901
902
903 static
904 void rlink_state_move(void) {
905
906 int i = 0, tms = 0;
907 uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
908 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
909
910 for (i = 0; i < tms_count; i++)
911 {
912 tms = (tms_scan >> i) & 1;
913 tap_state_queue_append(tms);
914 }
915
916 tap_set_state(tap_get_end_state());
917 }
918
919 static
920 void rlink_path_move(struct pathmove_command *cmd)
921 {
922 int num_states = cmd->num_states;
923 int state_count;
924 int tms = 0;
925
926 state_count = 0;
927 while (num_states)
928 {
929 if (tap_state_transition(tap_get_state(), false) == cmd->path[state_count])
930 {
931 tms = 0;
932 }
933 else if (tap_state_transition(tap_get_state(), true) == cmd->path[state_count])
934 {
935 tms = 1;
936 }
937 else
938 {
939 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd->path[state_count]));
940 exit(-1);
941 }
942
943 tap_state_queue_append(tms);
944
945 tap_set_state(cmd->path[state_count]);
946 state_count++;
947 num_states--;
948 }
949
950 tap_set_end_state(tap_get_state());
951 }
952
953
954 static
955 void rlink_runtest(int num_cycles)
956 {
957 int i;
958
959 tap_state_t saved_end_state = tap_get_end_state();
960
961 /* only do a state_move when we're not already in RTI */
962 if (tap_get_state() != TAP_IDLE)
963 {
964 rlink_end_state(TAP_IDLE);
965 rlink_state_move();
966 }
967
968 /* execute num_cycles */
969 for (i = 0; i < num_cycles; i++)
970 {
971 tap_state_queue_append(0);
972 }
973
974 /* finish in end_state */
975 rlink_end_state(saved_end_state);
976 if (tap_get_state() != tap_get_end_state())
977 rlink_state_move();
978 }
979
980
981 /* (1) assert or (0) deassert reset lines */
982 static
983 void rlink_reset(int trst, int srst)
984 {
985 uint8_t bitmap;
986 int usb_err;
987
988 /* Read port A for bit op */
989 usb_err = ep1_generic_commandl(
990 pHDev, 4,
991 EP1_CMD_MEMORY_READ,
992 ST7_PADR >> 8,
993 ST7_PADR,
994 1
995 );
996 if (usb_err < 0) {
997 LOG_ERROR("%s", usb_strerror());
998 exit(1);
999 }
1000
1001 usb_err = usb_bulk_read(
1002 pHDev, USB_EP1IN_ADDR,
1003 (char *)&bitmap, 1,
1004 USB_TIMEOUT_MS
1005 );
1006 if (usb_err < 1) {
1007 LOG_ERROR("%s", usb_strerror());
1008 exit(1);
1009 }
1010
1011 if (trst) {
1012 bitmap &= ~ST7_PA_NTRST;
1013 } else {
1014 bitmap |= ST7_PA_NTRST;
1015 }
1016
1017 /* Write port A and read port B for bit op */
1018 /* 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. */
1019 usb_err = ep1_generic_commandl(
1020 pHDev, 9,
1021 EP1_CMD_MEMORY_WRITE,
1022 ST7_PADR >> 8,
1023 ST7_PADR,
1024 1,
1025 bitmap,
1026 EP1_CMD_MEMORY_READ,
1027 ST7_PBDDR >> 8,
1028 ST7_PBDDR,
1029 1
1030 );
1031 if (usb_err < 0) {
1032 LOG_ERROR("%s", usb_strerror());
1033 exit(1);
1034 }
1035
1036 usb_err = usb_bulk_read(
1037 pHDev, USB_EP1IN_ADDR,
1038 (char *)&bitmap, 1,
1039 USB_TIMEOUT_MS
1040 );
1041 if (usb_err < 1) {
1042 LOG_ERROR("%s", usb_strerror());
1043 exit(1);
1044 }
1045
1046 if (srst) {
1047 bitmap |= ST7_PB_NSRST;
1048 } else {
1049 bitmap &= ~ST7_PB_NSRST;
1050 }
1051
1052 /* write port B and read dummy to ensure completion before returning */
1053 usb_err = ep1_generic_commandl(
1054 pHDev, 6,
1055 EP1_CMD_MEMORY_WRITE,
1056 ST7_PBDDR >> 8,
1057 ST7_PBDDR,
1058 1,
1059 bitmap,
1060 EP1_CMD_DTC_GET_CACHED_STATUS
1061 );
1062 if (usb_err < 0) {
1063 LOG_ERROR("%s", usb_strerror());
1064 exit(1);
1065 }
1066
1067 usb_err = usb_bulk_read(
1068 pHDev, USB_EP1IN_ADDR,
1069 (char *)&bitmap, 1,
1070 USB_TIMEOUT_MS
1071 );
1072 if (usb_err < 1) {
1073 LOG_ERROR("%s", usb_strerror());
1074 exit(1);
1075 }
1076 }
1077
1078
1079 static
1080 int
1081 rlink_scan(
1082 struct jtag_command *cmd,
1083 enum scan_type type,
1084 uint8_t *buffer,
1085 int scan_size
1086 ) {
1087 bool ir_scan;
1088 tap_state_t saved_end_state;
1089 int byte_bits;
1090 int extra_bits;
1091 int chunk_bits;
1092 int chunk_bytes;
1093 int x;
1094
1095 int tdi_bit_offset;
1096 uint8_t tdi_mask, *tdi_p;
1097 uint8_t dtc_mask;
1098
1099 if (scan_size < 1) {
1100 LOG_ERROR("scan_size cannot be less than 1 bit");
1101 exit(1);
1102 }
1103
1104 ir_scan = cmd->cmd.scan->ir_scan;
1105
1106 /* Move to the proper state before starting to shift TDI/TDO. */
1107 if (!(
1108 (!ir_scan && (tap_get_state() == TAP_DRSHIFT))
1109 ||
1110 (ir_scan && (tap_get_state() == TAP_IRSHIFT))
1111 )) {
1112 saved_end_state = tap_get_end_state();
1113 rlink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
1114 rlink_state_move();
1115 rlink_end_state(saved_end_state);
1116 }
1117
1118 tap_state_queue_run();
1119
1120
1121 #if 0
1122 printf("scan_size = %d, type = 0x%x\n", scan_size, type);
1123 {
1124 int i;
1125
1126 /* clear unused bits in scan buffer for ease of debugging */
1127 /* (it makes diffing output easier) */
1128 buffer[scan_size / 8] &= ((1 << ((scan_size - 1) % 8) + 1) - 1);
1129
1130 printf("before scan:");
1131 for (i = 0; i < (scan_size + 7) / 8; i++) {
1132 printf(" %02x", buffer[i]);
1133 }
1134 printf("\n");
1135 }
1136 #endif
1137
1138 /* The number of bits that can be shifted as complete bytes */
1139 byte_bits = (int)(scan_size - 1) / 8 * 8;
1140 /* The number of bits left over, not counting the last bit */
1141 extra_bits = (scan_size - 1) - byte_bits;
1142
1143 tdi_bit_offset = 0;
1144 tdi_p = buffer;
1145 tdi_mask = 1;
1146
1147 if (extra_bits && (type == SCAN_OUT)) {
1148 /* Schedule any extra bits into the DTC command buffer, padding as needed */
1149 /* For SCAN_OUT, this comes before the full bytes so the (leading) padding bits will fall off the end */
1150 /* make sure there's room for stop, byte op, and one byte */
1151 if (
1152 (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1))
1153 ) {
1154 dtc_queue_run();
1155 }
1156
1157 x = 0;
1158 dtc_mask = 1 << (extra_bits - 1);
1159
1160 while (extra_bits--) {
1161 if (*tdi_p & tdi_mask) {
1162 x |= dtc_mask;
1163 }
1164
1165 dtc_mask >>= 1;
1166
1167 tdi_mask <<= 1;
1168 if (tdi_mask == 0) {
1169 tdi_p++;
1170 tdi_mask = 1;
1171 }
1172 }
1173
1174 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1175 DTC_CMD_SHIFT_TDI_BYTES(1);
1176
1177 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1178 }
1179
1180 /* Loop scheduling full bytes into the DTC command buffer */
1181 while (byte_bits) {
1182 if (type == SCAN_IN) {
1183 /* make sure there's room for stop and byte op */
1184 x = (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1));
1185 } else {
1186 /* make sure there's room for stop, byte op, and at least one byte */
1187 x = (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1));
1188 }
1189
1190 if (type != SCAN_OUT) {
1191 /* make sure there's room for at least one reply byte */
1192 x |= (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1));
1193 }
1194
1195 if (x) {
1196 dtc_queue_run();
1197 }
1198
1199 chunk_bits = byte_bits;
1200 /* we can only use up to 16 bytes at a time */
1201 if (chunk_bits > (16 * 8)) chunk_bits = (16 * 8);
1202
1203 if (type != SCAN_IN) {
1204 /* how much is there room for, considering stop and byte op? */
1205 x = (sizeof(dtc_queue.cmd_buffer) - (dtc_queue.cmd_index + 1 + 1)) * 8;
1206 if (chunk_bits > x) chunk_bits = x;
1207 }
1208
1209 if (type != SCAN_OUT) {
1210 /* how much is there room for in the reply buffer? */
1211 x = (USB_EP2IN_SIZE - dtc_queue.reply_index) * 8;
1212 if (chunk_bits > x) chunk_bits = x;
1213 }
1214
1215 /* so the loop will end */
1216 byte_bits -= chunk_bits;
1217
1218 if (type != SCAN_OUT) {
1219 if (dtc_queue_enqueue_reply(
1220 type, buffer, scan_size, tdi_bit_offset,
1221 chunk_bits,
1222 cmd
1223 ) == NULL) {
1224 LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno));
1225 exit(1);
1226 }
1227 dtc_queue.reply_index += (chunk_bits + 7) / 8;
1228
1229 tdi_bit_offset += chunk_bits;
1230 }
1231
1232 /* chunk_bits is a multiple of 8, so there are no rounding issues. */
1233 chunk_bytes = chunk_bits / 8;
1234
1235 switch (type) {
1236 case SCAN_IN:
1237 x = DTC_CMD_SHIFT_TDO_BYTES(chunk_bytes);
1238 break;
1239 case SCAN_OUT:
1240 x = DTC_CMD_SHIFT_TDI_BYTES(chunk_bytes);
1241 break;
1242 default:
1243 x = DTC_CMD_SHIFT_TDIO_BYTES(chunk_bytes);
1244 break;
1245 }
1246 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1247
1248 if (type != SCAN_IN) {
1249 x = 0;
1250 dtc_mask = 1 << (8 - 1);
1251
1252 while (chunk_bits--) {
1253 if (*tdi_p & tdi_mask) {
1254 x |= dtc_mask;
1255 }
1256
1257 dtc_mask >>= 1;
1258 if (dtc_mask == 0) {
1259 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1260 x = 0;
1261 dtc_mask = 1 << (8 - 1);
1262 }
1263
1264 tdi_mask <<= 1;
1265 if (tdi_mask == 0) {
1266 tdi_p++;
1267 tdi_mask = 1;
1268 }
1269 }
1270 }
1271 }
1272
1273 if (extra_bits && (type != SCAN_OUT)) {
1274 /* Schedule any extra bits into the DTC command buffer */
1275 /* make sure there's room for stop, byte op, and one byte */
1276 if (
1277 (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1))
1278 ||
1279 (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1))
1280 ) {
1281 dtc_queue_run();
1282 }
1283
1284 if (dtc_queue_enqueue_reply(
1285 type, buffer, scan_size, tdi_bit_offset,
1286 extra_bits,
1287 cmd
1288 ) == NULL) {
1289 LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno));
1290 exit(1);
1291 }
1292
1293 dtc_queue.reply_index++;
1294
1295 tdi_bit_offset += extra_bits;
1296
1297 if (type == SCAN_IN) {
1298 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1299 DTC_CMD_SHIFT_TDO_BYTES(1);
1300
1301 } else {
1302 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1303 DTC_CMD_SHIFT_TDIO_BITS(extra_bits);
1304
1305 x = 0;
1306 dtc_mask = 1 << (8 - 1);
1307
1308 while (extra_bits--) {
1309 if (*tdi_p & tdi_mask) {
1310 x |= dtc_mask;
1311 }
1312
1313 dtc_mask >>= 1;
1314
1315 tdi_mask <<= 1;
1316 if (tdi_mask == 0) {
1317 tdi_p++;
1318 tdi_mask = 1;
1319 }
1320 }
1321
1322 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1323 }
1324 }
1325
1326 /* Schedule the last bit into the DTC command buffer */
1327 /* make sure there's room for stop, and bit pair command */
1328 if (
1329 (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1))
1330 ||
1331 (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1))
1332 ) {
1333 dtc_queue_run();
1334 }
1335
1336 if (type == SCAN_OUT) {
1337 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1338 DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 0);
1339
1340 } else {
1341 if (dtc_queue_enqueue_reply(
1342 type, buffer, scan_size, tdi_bit_offset,
1343 1,
1344 cmd
1345 ) == NULL) {
1346 LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno));
1347 exit(1);
1348 }
1349
1350 dtc_queue.reply_index++;
1351
1352 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1353 DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 1);
1354 }
1355
1356 /* Move to pause state */
1357 tap_state_queue_append(0);
1358 tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
1359 if (tap_get_state() != tap_get_end_state()) rlink_state_move();
1360
1361 return(0);
1362 }
1363
1364
1365 static
1366 int rlink_execute_queue(void)
1367 {
1368 struct jtag_command *cmd = jtag_command_queue; /* currently processed command */
1369 int scan_size;
1370 enum scan_type type;
1371 uint8_t *buffer;
1372 int retval, tmp_retval;
1373
1374 /* return ERROR_OK, unless something goes wrong */
1375 retval = ERROR_OK;
1376
1377 #ifndef AUTOMATIC_BUSY_LED
1378 /* turn LED on */
1379 ep1_generic_commandl(pHDev, 2,
1380 EP1_CMD_SET_PORTD_LEDS,
1381 ~(ST7_PD_NBUSY_LED)
1382 );
1383 #endif
1384
1385 while (cmd)
1386 {
1387 switch (cmd->type)
1388 {
1389 case JTAG_RUNTEST:
1390 case JTAG_TLR_RESET:
1391 case JTAG_PATHMOVE:
1392 case JTAG_SCAN:
1393 break;
1394
1395 default:
1396 /* some events, such as resets, need a queue flush to ensure consistency */
1397 tap_state_queue_run();
1398 dtc_queue_run();
1399 break;
1400 }
1401
1402 switch (cmd->type)
1403 {
1404 case JTAG_RESET:
1405 #ifdef _DEBUG_JTAG_IO_
1406 LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1407 #endif
1408 if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
1409 {
1410 tap_set_state(TAP_RESET);
1411 }
1412 rlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1413 break;
1414 case JTAG_RUNTEST:
1415 #ifdef _DEBUG_JTAG_IO_
1416 LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
1417 #endif
1418 if (cmd->cmd.runtest->end_state != -1)
1419 rlink_end_state(cmd->cmd.runtest->end_state);
1420 rlink_runtest(cmd->cmd.runtest->num_cycles);
1421 break;
1422 case JTAG_TLR_RESET:
1423 #ifdef _DEBUG_JTAG_IO_
1424 LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
1425 #endif
1426 if (cmd->cmd.statemove->end_state != -1)
1427 rlink_end_state(cmd->cmd.statemove->end_state);
1428 rlink_state_move();
1429 break;
1430 case JTAG_PATHMOVE:
1431 #ifdef _DEBUG_JTAG_IO_
1432 LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
1433 #endif
1434 rlink_path_move(cmd->cmd.pathmove);
1435 break;
1436 case JTAG_SCAN:
1437 #ifdef _DEBUG_JTAG_IO_
1438 LOG_DEBUG("%s scan end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", cmd->cmd.scan->end_state);
1439 #endif
1440 if (cmd->cmd.scan->end_state != -1)
1441 rlink_end_state(cmd->cmd.scan->end_state);
1442 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1443 type = jtag_scan_type(cmd->cmd.scan);
1444 if (rlink_scan(cmd, type, buffer, scan_size) != ERROR_OK) {
1445 retval = ERROR_FAIL;
1446 }
1447 break;
1448 case JTAG_SLEEP:
1449 #ifdef _DEBUG_JTAG_IO_
1450 LOG_DEBUG("sleep %i", cmd->cmd.sleep->us);
1451 #endif
1452 jtag_sleep(cmd->cmd.sleep->us);
1453 break;
1454 default:
1455 LOG_ERROR("BUG: unknown JTAG command type encountered");
1456 exit(-1);
1457 }
1458 cmd = cmd->next;
1459 }
1460
1461 /* Flush the DTC queue to make sure any pending reads have been done before exiting this function */
1462 tap_state_queue_run();
1463 tmp_retval = dtc_queue_run();
1464 if (tmp_retval != ERROR_OK) {
1465 retval = tmp_retval;
1466 }
1467
1468 #ifndef AUTOMATIC_BUSY_LED
1469 /* turn LED onff */
1470 ep1_generic_commandl(pHDev, 2,
1471 EP1_CMD_SET_PORTD_LEDS,
1472 ~0
1473 );
1474 #endif
1475
1476 return retval;
1477 }
1478
1479
1480 /* 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. */
1481
1482 static
1483 int rlink_speed(int speed)
1484 {
1485 int i;
1486
1487 if (speed == 0) {
1488 /* fastest speed */
1489 speed = rlink_speed_table[rlink_speed_table_size - 1].prescaler;
1490 }
1491
1492 for (i = rlink_speed_table_size; i--;) {
1493 if (rlink_speed_table[i].prescaler == speed) {
1494 if (dtc_load_from_buffer(pHDev, rlink_speed_table[i].dtc, rlink_speed_table[i].dtc_size) != 0) {
1495 LOG_ERROR("An error occurred while trying to load DTC code for speed \"%d\".", speed);
1496 exit(1);
1497 }
1498
1499 if (dtc_start_download() < 0) {
1500 LOG_ERROR("%s, %d: starting DTC: %s",
1501 __FILE__, __LINE__,
1502 usb_strerror()
1503 );
1504 exit(1);
1505 }
1506
1507 return ERROR_OK;
1508 }
1509 }
1510
1511 LOG_ERROR("%d is not a supported speed", speed);
1512 return(ERROR_FAIL);
1513 }
1514
1515
1516 static
1517 int rlink_speed_div(
1518 int speed,
1519 int *khz
1520 ) {
1521 int i;
1522
1523 for (i = rlink_speed_table_size; i--;) {
1524 if (rlink_speed_table[i].prescaler == speed) {
1525 *khz = rlink_speed_table[i].khz;
1526 return(ERROR_OK);
1527 }
1528 }
1529
1530 LOG_ERROR("%d is not a supported speed", speed);
1531 return(ERROR_FAIL);
1532 }
1533
1534
1535 static
1536 int rlink_khz(
1537 int khz,
1538 int *speed
1539 ) {
1540 int i;
1541
1542 if (khz == 0) {
1543 LOG_ERROR("RCLK not supported");
1544 return ERROR_FAIL;
1545 }
1546
1547 for (i = rlink_speed_table_size; i--;) {
1548 if (rlink_speed_table[i].khz <= khz) {
1549 *speed = rlink_speed_table[i].prescaler;
1550 return(ERROR_OK);
1551 }
1552 }
1553
1554 LOG_WARNING("The lowest supported JTAG speed is %d KHz", rlink_speed_table[0].khz);
1555 *speed = rlink_speed_table[0].prescaler;
1556 return(ERROR_OK);
1557 }
1558
1559
1560 static
1561 int rlink_init(void)
1562 {
1563 int i, j, retries;
1564 uint8_t reply_buffer[USB_EP1IN_SIZE];
1565
1566 usb_init();
1567 const uint16_t vids[] = { USB_IDVENDOR, 0 };
1568 const uint16_t pids[] = { USB_IDPRODUCT, 0 };
1569 if (jtag_usb_open(vids, pids, &pHDev) != ERROR_OK)
1570 return ERROR_FAIL;
1571
1572 struct usb_device *dev = usb_device(pHDev);
1573 if (dev->descriptor.bNumConfigurations > 1)
1574 {
1575 LOG_ERROR("Whoops! NumConfigurations is not 1, don't know what to do...");
1576 return ERROR_FAIL;
1577 }
1578 if (dev->config->bNumInterfaces > 1)
1579 {
1580 LOG_ERROR("Whoops! NumInterfaces is not 1, don't know what to do...");
1581 return ERROR_FAIL;
1582 }
1583
1584 LOG_DEBUG("Opened device, pHDev = %p", pHDev);
1585
1586 /* usb_set_configuration required under win32 */
1587 usb_set_configuration(pHDev, dev->config[0].bConfigurationValue);
1588
1589 retries = 3;
1590 do
1591 {
1592 i = usb_claim_interface(pHDev,0);
1593 if (i)
1594 {
1595 LOG_ERROR("usb_claim_interface: %s", usb_strerror());
1596 #ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
1597 j = usb_detach_kernel_driver_np(pHDev, 0);
1598 if (j)
1599 LOG_ERROR("detach kernel driver: %s", usb_strerror());
1600 #endif
1601 }
1602 else
1603 {
1604 LOG_DEBUG("interface claimed!");
1605 break;
1606 }
1607 } while (--retries);
1608
1609 if (i)
1610 {
1611 LOG_ERROR("Initialisation failed.");
1612 return ERROR_FAIL;
1613 }
1614 if (usb_set_altinterface(pHDev,0) != 0)
1615 {
1616 LOG_ERROR("Failed to set interface.");
1617 return ERROR_FAIL;
1618 }
1619
1620 /* The device starts out in an unknown state on open. As such,
1621 * result reads time out, and it's not even known whether the
1622 * command was accepted. So, for this first command, we issue
1623 * it repeatedly until its response doesn't time out. Also, if
1624 * sending a command is going to time out, we find that out here.
1625 *
1626 * It must be possible to open the device in such a way that
1627 * this special magic isn't needed, but, so far, it escapes us.
1628 */
1629 for (i = 0; i < 5; i++) {
1630 j = ep1_generic_commandl(
1631 pHDev, 1,
1632 EP1_CMD_GET_FWREV
1633 );
1634 if (j < USB_EP1OUT_SIZE) {
1635 LOG_ERROR("USB write error: %s", usb_strerror());
1636 return(ERROR_FAIL);
1637 }
1638 j = usb_bulk_read(
1639 pHDev, USB_EP1IN_ADDR,
1640 (char *)reply_buffer, sizeof(reply_buffer),
1641 200
1642 );
1643 if (j != -ETIMEDOUT) break;
1644 }
1645
1646 if (j < (int)sizeof(reply_buffer)) {
1647 LOG_ERROR("USB read error: %s", usb_strerror());
1648 return(ERROR_FAIL);
1649 }
1650 LOG_DEBUG(INTERFACE_NAME" firmware version: %d.%d.%d", reply_buffer[0], reply_buffer[1], reply_buffer[2]);
1651
1652 if ((reply_buffer[0] != 0) || (reply_buffer[1] != 0) || (reply_buffer[2] != 3)) {
1653 LOG_WARNING("The rlink device is not of the version that the developers have played with. It may or may not work.");
1654 }
1655
1656 /* Probe port E for adapter presence */
1657 ep1_generic_commandl(
1658 pHDev, 16,
1659 EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 0 */
1660 ST7_PEDR >> 8,
1661 ST7_PEDR,
1662 3,
1663 0x00, /* DR */
1664 ST7_PE_ADAPTER_SENSE_OUT, /* DDR */
1665 ST7_PE_ADAPTER_SENSE_OUT, /* OR */
1666 EP1_CMD_MEMORY_READ, /* Read back */
1667 ST7_PEDR >> 8,
1668 ST7_PEDR,
1669 1,
1670 EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 1 */
1671 ST7_PEDR >> 8,
1672 ST7_PEDR,
1673 1,
1674 ST7_PE_ADAPTER_SENSE_OUT
1675 );
1676
1677 usb_bulk_read(
1678 pHDev, USB_EP1IN_ADDR,
1679 (char *)reply_buffer, 1,
1680 USB_TIMEOUT_MS
1681 );
1682
1683 if ((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) != 0) {
1684 LOG_WARNING("target detection problem");
1685 }
1686
1687 ep1_generic_commandl(
1688 pHDev, 11,
1689 EP1_CMD_MEMORY_READ, /* Read back */
1690 ST7_PEDR >> 8,
1691 ST7_PEDR,
1692 1,
1693 EP1_CMD_MEMORY_WRITE, /* float port E */
1694 ST7_PEDR >> 8,
1695 ST7_PEDR,
1696 3,
1697 0x00, /* DR */
1698 0x00, /* DDR */
1699 0x00 /* OR */
1700 );
1701
1702 usb_bulk_read(
1703 pHDev, USB_EP1IN_ADDR,
1704 (char *)reply_buffer, 1,
1705 USB_TIMEOUT_MS
1706 );
1707
1708
1709 if ((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) == 0) {
1710 LOG_WARNING("target not plugged in");
1711 }
1712
1713 /* float ports A and B */
1714 ep1_generic_commandl(
1715 pHDev, 11,
1716 EP1_CMD_MEMORY_WRITE,
1717 ST7_PADDR >> 8,
1718 ST7_PADDR,
1719 2,
1720 0x00,
1721 0x00,
1722 EP1_CMD_MEMORY_WRITE,
1723 ST7_PBDDR >> 8,
1724 ST7_PBDDR,
1725 1,
1726 0x00
1727 );
1728
1729 /* make sure DTC is stopped, set VPP control, set up ports A and B */
1730 ep1_generic_commandl(
1731 pHDev, 14,
1732 EP1_CMD_DTC_STOP,
1733 EP1_CMD_SET_PORTD_VPP,
1734 ~(ST7_PD_VPP_SHDN),
1735 EP1_CMD_MEMORY_WRITE,
1736 ST7_PADR >> 8,
1737 ST7_PADR,
1738 2,
1739 ((~(0)) & (ST7_PA_NTRST)),
1740 (ST7_PA_NTRST),
1741 /* 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. */
1742 EP1_CMD_MEMORY_WRITE,
1743 ST7_PBDR >> 8,
1744 ST7_PBDR,
1745 1,
1746 0x00
1747 );
1748
1749 /* set LED updating mode and make sure they're unlit */
1750 ep1_generic_commandl(
1751 pHDev, 3,
1752 #ifdef AUTOMATIC_BUSY_LED
1753 EP1_CMD_LEDUE_BUSY,
1754 #else
1755 EP1_CMD_LEDUE_NONE,
1756 #endif
1757 EP1_CMD_SET_PORTD_LEDS,
1758 ~0
1759 );
1760
1761 tap_state_queue_init();
1762 dtc_queue_init();
1763 rlink_reset(0, 0);
1764
1765 return ERROR_OK;
1766 }
1767
1768
1769 static
1770 int rlink_quit(void)
1771 {
1772 /* stop DTC and make sure LEDs are off */
1773 ep1_generic_commandl(
1774 pHDev, 6,
1775 EP1_CMD_DTC_STOP,
1776 EP1_CMD_LEDUE_NONE,
1777 EP1_CMD_SET_PORTD_LEDS,
1778 ~0,
1779 EP1_CMD_SET_PORTD_VPP,
1780 ~0
1781 );
1782
1783 usb_release_interface(pHDev,0);
1784 usb_close(pHDev);
1785
1786
1787 return ERROR_OK;
1788 }
1789
1790
1791 struct jtag_interface rlink_interface =
1792 {
1793 .name = "rlink",
1794 .init = rlink_init,
1795 .quit = rlink_quit,
1796 .speed = rlink_speed,
1797 .speed_div = rlink_speed_div,
1798 .khz = rlink_khz,
1799 .execute_queue = rlink_execute_queue,
1800 };