rlink: more indentation fixes
[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 retval = ERROR_OK;
682
683 if (dtc_queue.cmd_index < 1) return(retval);
684
685 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = DTC_CMD_STOP;
686
687 /* run the cmd */
688 if (dtc_queue.rq_head == NULL) {
689 usb_err = dtc_run_download(pHDev,
690 dtc_queue.cmd_buffer, dtc_queue.cmd_index,
691 NULL, 0
692 );
693 if (usb_err < 0) {
694 LOG_ERROR("dtc_run_download: %s", usb_strerror());
695 exit(1);
696 }
697 } else {
698 usb_err = dtc_run_download(pHDev,
699 dtc_queue.cmd_buffer, dtc_queue.cmd_index,
700 reply_buffer, dtc_queue.reply_index
701 );
702 if (usb_err < 0) {
703 LOG_ERROR("dtc_run_download: %s", usb_strerror());
704 exit(1);
705 }
706
707 /* process the reply, which empties the reply queue and frees its entries */
708 dtc_p = reply_buffer;
709
710 /* 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. */
711
712 for (
713 rq_p = dtc_queue.rq_head;
714 rq_p != NULL;
715 rq_p = rq_next
716 ) {
717 tdo_p = rq_p->scan.buffer + (rq_p->scan.offset / 8);
718 tdo_mask = 1 << (rq_p->scan.offset % 8);
719
720
721 bit_cnt = rq_p->scan.length;
722 if (bit_cnt >= 8) {
723 /* bytes */
724
725 dtc_mask = 1 << (8 - 1);
726
727 for (
728 ;
729 bit_cnt;
730 bit_cnt--
731 ) {
732 if (*dtc_p & dtc_mask) {
733 *tdo_p |= tdo_mask;
734 } else {
735 *tdo_p &=~ tdo_mask;
736 }
737
738 dtc_mask >>= 1;
739 if (dtc_mask == 0) {
740 dtc_p++;
741 dtc_mask = 1 << (8 - 1);
742 }
743
744 tdo_mask <<= 1;
745 if (tdo_mask == 0) {
746 tdo_p++;
747 tdo_mask = 1;
748 }
749 }
750 } else {
751 /* extra bits or last bit */
752
753 x = *dtc_p++;
754 if ((
755 rq_p->scan.type == SCAN_IN
756 ) && (
757 rq_p->scan.offset != rq_p->scan.size - 1
758 )) {
759 /* extra bits were sent as a full byte with padding on the end */
760 dtc_mask = 1 << (8 - 1);
761 } else {
762 dtc_mask = 1 << (bit_cnt - 1);
763 }
764
765 for (
766 ;
767 bit_cnt;
768 bit_cnt--
769 ) {
770 if (x & dtc_mask) {
771 *tdo_p |= tdo_mask;
772 } else {
773 *tdo_p &=~ tdo_mask;
774 }
775
776 dtc_mask >>= 1;
777
778 tdo_mask <<= 1;
779 if (tdo_mask == 0) {
780 tdo_p++;
781 tdo_mask = 1;
782 }
783
784 }
785 }
786
787 if ((rq_p->scan.offset + rq_p->scan.length) >= rq_p->scan.size) {
788 /* feed scan buffer back into openocd and free it */
789 if (jtag_read_buffer(rq_p->scan.buffer, rq_p->cmd->cmd.scan) != ERROR_OK) {
790 retval = ERROR_JTAG_QUEUE_FAILED;
791 }
792 free(rq_p->scan.buffer);
793 }
794
795 rq_next = rq_p->next;
796 free(rq_p);
797 }
798 dtc_queue.rq_head = NULL;
799 dtc_queue.rq_tail = NULL;
800 }
801
802
803 /* reset state for new appends */
804 dtc_queue.cmd_index = 0;
805 dtc_queue.reply_index = 0;
806
807 return(retval);
808 }
809
810
811
812 static
813 int
814 tap_state_queue_init(void) {
815 tap_state_queue.length = 0;
816 tap_state_queue.buffer = 0;
817 return(0);
818 }
819
820
821 static
822 int
823 tap_state_queue_run(void) {
824 int i;
825 int bits;
826 uint8_t byte_param;
827 int retval;
828
829 retval = 0;
830 if (!tap_state_queue.length) return(retval);
831 bits = 1;
832 byte_param = 0;
833 for (i = tap_state_queue.length; i--;) {
834
835 byte_param <<= 1;
836 if (tap_state_queue.buffer & 1) {
837 byte_param |= 1;
838 }
839 if ((bits >= 8) || !i) {
840 byte_param <<= (8 - bits);
841
842 /* make sure there's room for stop, byte op, and one byte */
843 if (dtc_queue.cmd_index >= (sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1))) {
844 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
845 DTC_CMD_STOP;
846 dtc_queue_run();
847 }
848
849 #ifdef USE_HARDWARE_SHIFTER_FOR_TMS
850 if (bits == 8) {
851 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
852 DTC_CMD_SHIFT_TMS_BYTES(1);
853 } else {
854 #endif
855 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
856 DTC_CMD_SHIFT_TMS_BITS(bits);
857 #ifdef USE_HARDWARE_SHIFTER_FOR_TMS
858 }
859 #endif
860
861 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
862 byte_param;
863
864 byte_param = 0;
865 bits = 1;
866 } else {
867 bits++;
868 }
869
870 tap_state_queue.buffer >>= 1;
871 }
872 retval = tap_state_queue_init();
873 return(retval);
874 }
875
876
877 static
878 int
879 tap_state_queue_append(
880 uint8_t tms
881 ) {
882 int retval;
883
884 if (tap_state_queue.length >= sizeof(tap_state_queue.buffer) * 8) {
885 retval = tap_state_queue_run();
886 if (retval != 0) return(retval);
887 }
888
889 if (tms) {
890 tap_state_queue.buffer |= (1 << tap_state_queue.length);
891 }
892 tap_state_queue.length++;
893
894 return(0);
895 }
896
897
898 static
899 void rlink_end_state(tap_state_t state)
900 {
901 if (tap_is_state_stable(state))
902 tap_set_end_state(state);
903 else
904 {
905 LOG_ERROR("BUG: %i is not a valid end state", state);
906 exit(-1);
907 }
908 }
909
910
911 static
912 void rlink_state_move(void) {
913
914 int i = 0, tms = 0;
915 uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
916 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
917
918 for (i = 0; i < tms_count; i++)
919 {
920 tms = (tms_scan >> i) & 1;
921 tap_state_queue_append(tms);
922 }
923
924 tap_set_state(tap_get_end_state());
925 }
926
927 static
928 void rlink_path_move(struct pathmove_command *cmd)
929 {
930 int num_states = cmd->num_states;
931 int state_count;
932 int tms = 0;
933
934 state_count = 0;
935 while (num_states)
936 {
937 if (tap_state_transition(tap_get_state(), false) == cmd->path[state_count])
938 {
939 tms = 0;
940 }
941 else if (tap_state_transition(tap_get_state(), true) == cmd->path[state_count])
942 {
943 tms = 1;
944 }
945 else
946 {
947 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd->path[state_count]));
948 exit(-1);
949 }
950
951 tap_state_queue_append(tms);
952
953 tap_set_state(cmd->path[state_count]);
954 state_count++;
955 num_states--;
956 }
957
958 tap_set_end_state(tap_get_state());
959 }
960
961
962 static
963 void rlink_runtest(int num_cycles)
964 {
965 int i;
966
967 tap_state_t saved_end_state = tap_get_end_state();
968
969 /* only do a state_move when we're not already in RTI */
970 if (tap_get_state() != TAP_IDLE)
971 {
972 rlink_end_state(TAP_IDLE);
973 rlink_state_move();
974 }
975
976 /* execute num_cycles */
977 for (i = 0; i < num_cycles; i++)
978 {
979 tap_state_queue_append(0);
980 }
981
982 /* finish in end_state */
983 rlink_end_state(saved_end_state);
984 if (tap_get_state() != tap_get_end_state())
985 rlink_state_move();
986 }
987
988
989 /* (1) assert or (0) deassert reset lines */
990 static
991 void rlink_reset(int trst, int srst)
992 {
993 uint8_t bitmap;
994 int usb_err;
995
996 /* Read port A for bit op */
997 usb_err = ep1_generic_commandl(
998 pHDev, 4,
999 EP1_CMD_MEMORY_READ,
1000 ST7_PADR >> 8,
1001 ST7_PADR,
1002 1
1003 );
1004 if (usb_err < 0) {
1005 LOG_ERROR("%s", usb_strerror());
1006 exit(1);
1007 }
1008
1009 usb_err = usb_bulk_read(
1010 pHDev, USB_EP1IN_ADDR,
1011 (char *)&bitmap, 1,
1012 USB_TIMEOUT_MS
1013 );
1014 if (usb_err < 1) {
1015 LOG_ERROR("%s", usb_strerror());
1016 exit(1);
1017 }
1018
1019 if (trst) {
1020 bitmap &= ~ST7_PA_NTRST;
1021 } else {
1022 bitmap |= ST7_PA_NTRST;
1023 }
1024
1025 /* Write port A and read port B for bit op */
1026 /* 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. */
1027 usb_err = ep1_generic_commandl(
1028 pHDev, 9,
1029 EP1_CMD_MEMORY_WRITE,
1030 ST7_PADR >> 8,
1031 ST7_PADR,
1032 1,
1033 bitmap,
1034 EP1_CMD_MEMORY_READ,
1035 ST7_PBDDR >> 8,
1036 ST7_PBDDR,
1037 1
1038 );
1039 if (usb_err < 0) {
1040 LOG_ERROR("%s", usb_strerror());
1041 exit(1);
1042 }
1043
1044 usb_err = usb_bulk_read(
1045 pHDev, USB_EP1IN_ADDR,
1046 (char *)&bitmap, 1,
1047 USB_TIMEOUT_MS
1048 );
1049 if (usb_err < 1) {
1050 LOG_ERROR("%s", usb_strerror());
1051 exit(1);
1052 }
1053
1054 if (srst) {
1055 bitmap |= ST7_PB_NSRST;
1056 } else {
1057 bitmap &= ~ST7_PB_NSRST;
1058 }
1059
1060 /* write port B and read dummy to ensure completion before returning */
1061 usb_err = ep1_generic_commandl(
1062 pHDev, 6,
1063 EP1_CMD_MEMORY_WRITE,
1064 ST7_PBDDR >> 8,
1065 ST7_PBDDR,
1066 1,
1067 bitmap,
1068 EP1_CMD_DTC_GET_CACHED_STATUS
1069 );
1070 if (usb_err < 0) {
1071 LOG_ERROR("%s", usb_strerror());
1072 exit(1);
1073 }
1074
1075 usb_err = usb_bulk_read(
1076 pHDev, USB_EP1IN_ADDR,
1077 (char *)&bitmap, 1,
1078 USB_TIMEOUT_MS
1079 );
1080 if (usb_err < 1) {
1081 LOG_ERROR("%s", usb_strerror());
1082 exit(1);
1083 }
1084 }
1085
1086
1087 static
1088 int
1089 rlink_scan(
1090 struct jtag_command *cmd,
1091 enum scan_type type,
1092 uint8_t *buffer,
1093 int scan_size
1094 ) {
1095 bool ir_scan;
1096 tap_state_t saved_end_state;
1097 int byte_bits;
1098 int extra_bits;
1099 int chunk_bits;
1100 int chunk_bytes;
1101 int x;
1102
1103 int tdi_bit_offset;
1104 uint8_t tdi_mask, *tdi_p;
1105 uint8_t dtc_mask;
1106
1107 if (scan_size < 1) {
1108 LOG_ERROR("scan_size cannot be less than 1 bit");
1109 exit(1);
1110 }
1111
1112 ir_scan = cmd->cmd.scan->ir_scan;
1113
1114 /* Move to the proper state before starting to shift TDI/TDO. */
1115 if (!(
1116 (!ir_scan && (tap_get_state() == TAP_DRSHIFT))
1117 ||
1118 (ir_scan && (tap_get_state() == TAP_IRSHIFT))
1119 )) {
1120 saved_end_state = tap_get_end_state();
1121 rlink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
1122 rlink_state_move();
1123 rlink_end_state(saved_end_state);
1124 }
1125
1126 tap_state_queue_run();
1127
1128
1129 #if 0
1130 printf("scan_size = %d, type = 0x%x\n", scan_size, type);
1131 {
1132 int i;
1133
1134 /* clear unused bits in scan buffer for ease of debugging */
1135 /* (it makes diffing output easier) */
1136 buffer[scan_size / 8] &= ((1 << ((scan_size - 1) % 8) + 1) - 1);
1137
1138 printf("before scan:");
1139 for (i = 0; i < (scan_size + 7) / 8; i++) {
1140 printf(" %02x", buffer[i]);
1141 }
1142 printf("\n");
1143 }
1144 #endif
1145
1146 /* The number of bits that can be shifted as complete bytes */
1147 byte_bits = (int)(scan_size - 1) / 8 * 8;
1148 /* The number of bits left over, not counting the last bit */
1149 extra_bits = (scan_size - 1) - byte_bits;
1150
1151 tdi_bit_offset = 0;
1152 tdi_p = buffer;
1153 tdi_mask = 1;
1154
1155 if (extra_bits && (type == SCAN_OUT)) {
1156 /* Schedule any extra bits into the DTC command buffer, padding as needed */
1157 /* For SCAN_OUT, this comes before the full bytes so the (leading) padding bits will fall off the end */
1158 /* make sure there's room for stop, byte op, and one byte */
1159 if (
1160 (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1))
1161 ) {
1162 dtc_queue_run();
1163 }
1164
1165 x = 0;
1166 dtc_mask = 1 << (extra_bits - 1);
1167
1168 while (extra_bits--) {
1169 if (*tdi_p & tdi_mask) {
1170 x |= dtc_mask;
1171 }
1172
1173 dtc_mask >>= 1;
1174
1175 tdi_mask <<= 1;
1176 if (tdi_mask == 0) {
1177 tdi_p++;
1178 tdi_mask = 1;
1179 }
1180 }
1181
1182 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1183 DTC_CMD_SHIFT_TDI_BYTES(1);
1184
1185 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1186 }
1187
1188 /* Loop scheduling full bytes into the DTC command buffer */
1189 while (byte_bits) {
1190 if (type == SCAN_IN) {
1191 /* make sure there's room for stop and byte op */
1192 x = (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1));
1193 } else {
1194 /* make sure there's room for stop, byte op, and at least one byte */
1195 x = (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1));
1196 }
1197
1198 if (type != SCAN_OUT) {
1199 /* make sure there's room for at least one reply byte */
1200 x |= (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1));
1201 }
1202
1203 if (x) {
1204 dtc_queue_run();
1205 }
1206
1207 chunk_bits = byte_bits;
1208 /* we can only use up to 16 bytes at a time */
1209 if (chunk_bits > (16 * 8)) chunk_bits = (16 * 8);
1210
1211 if (type != SCAN_IN) {
1212 /* how much is there room for, considering stop and byte op? */
1213 x = (sizeof(dtc_queue.cmd_buffer) - (dtc_queue.cmd_index + 1 + 1)) * 8;
1214 if (chunk_bits > x) chunk_bits = x;
1215 }
1216
1217 if (type != SCAN_OUT) {
1218 /* how much is there room for in the reply buffer? */
1219 x = (USB_EP2IN_SIZE - dtc_queue.reply_index) * 8;
1220 if (chunk_bits > x) chunk_bits = x;
1221 }
1222
1223 /* so the loop will end */
1224 byte_bits -= chunk_bits;
1225
1226 if (type != SCAN_OUT) {
1227 if (dtc_queue_enqueue_reply(
1228 type, buffer, scan_size, tdi_bit_offset,
1229 chunk_bits,
1230 cmd
1231 ) == NULL) {
1232 LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno));
1233 exit(1);
1234 }
1235
1236 tdi_bit_offset += chunk_bits;
1237 }
1238
1239 /* chunk_bits is a multiple of 8, so there are no rounding issues. */
1240 chunk_bytes = chunk_bits / 8;
1241
1242 switch (type) {
1243 case SCAN_IN:
1244 x = DTC_CMD_SHIFT_TDO_BYTES(chunk_bytes);
1245 break;
1246 case SCAN_OUT:
1247 x = DTC_CMD_SHIFT_TDI_BYTES(chunk_bytes);
1248 break;
1249 default:
1250 x = DTC_CMD_SHIFT_TDIO_BYTES(chunk_bytes);
1251 break;
1252 }
1253 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1254
1255 if (type != SCAN_IN) {
1256 x = 0;
1257 dtc_mask = 1 << (8 - 1);
1258
1259 while (chunk_bits--) {
1260 if (*tdi_p & tdi_mask) {
1261 x |= dtc_mask;
1262 }
1263
1264 dtc_mask >>= 1;
1265 if (dtc_mask == 0) {
1266 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1267 dtc_queue.reply_index++;
1268 x = 0;
1269 dtc_mask = 1 << (8 - 1);
1270 }
1271
1272 tdi_mask <<= 1;
1273 if (tdi_mask == 0) {
1274 tdi_p++;
1275 tdi_mask = 1;
1276 }
1277 }
1278 }
1279 }
1280
1281 if (extra_bits && (type != SCAN_OUT)) {
1282 /* Schedule any extra bits into the DTC command buffer */
1283 /* make sure there's room for stop, byte op, and one byte */
1284 if (
1285 (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1 + 1))
1286 ||
1287 (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1))
1288 ) {
1289 dtc_queue_run();
1290 }
1291
1292 if (dtc_queue_enqueue_reply(
1293 type, buffer, scan_size, tdi_bit_offset,
1294 extra_bits,
1295 cmd
1296 ) == NULL) {
1297 LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno));
1298 exit(1);
1299 }
1300
1301 tdi_bit_offset += extra_bits;
1302
1303 if (type == SCAN_IN) {
1304 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1305 DTC_CMD_SHIFT_TDO_BYTES(1);
1306
1307 } else {
1308 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1309 DTC_CMD_SHIFT_TDIO_BITS(extra_bits);
1310
1311 x = 0;
1312 dtc_mask = 1 << (8 - 1);
1313
1314 while (extra_bits--) {
1315 if (*tdi_p & tdi_mask) {
1316 x |= dtc_mask;
1317 }
1318
1319 dtc_mask >>= 1;
1320
1321 tdi_mask <<= 1;
1322 if (tdi_mask == 0) {
1323 tdi_p++;
1324 tdi_mask = 1;
1325 }
1326 }
1327
1328 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1329 }
1330
1331 dtc_queue.reply_index++;
1332 }
1333
1334 /* Schedule the last bit into the DTC command buffer */
1335 /* make sure there's room for stop, and bit pair command */
1336 if (
1337 (dtc_queue.cmd_index >= sizeof(dtc_queue.cmd_buffer) - (1 + 1))
1338 ||
1339 (dtc_queue.reply_index >= USB_EP2IN_SIZE - (1))
1340 ) {
1341 dtc_queue_run();
1342 }
1343
1344 if (type == SCAN_OUT) {
1345 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1346 DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 0);
1347
1348 } else {
1349 if (dtc_queue_enqueue_reply(
1350 type, buffer, scan_size, tdi_bit_offset,
1351 1,
1352 cmd
1353 ) == NULL) {
1354 LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno));
1355 exit(1);
1356 }
1357
1358 dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1359 DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 1);
1360
1361 dtc_queue.reply_index++;
1362 }
1363
1364 /* Move to pause state */
1365 tap_state_queue_append(0);
1366 tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
1367 if (tap_get_state() != tap_get_end_state()) rlink_state_move();
1368
1369 return(0);
1370 }
1371
1372
1373 static
1374 int rlink_execute_queue(void)
1375 {
1376 struct jtag_command *cmd = jtag_command_queue; /* currently processed command */
1377 int scan_size;
1378 enum scan_type type;
1379 uint8_t *buffer;
1380 int retval, tmp_retval;
1381
1382 /* return ERROR_OK, unless something goes wrong */
1383 retval = ERROR_OK;
1384
1385 #ifndef AUTOMATIC_BUSY_LED
1386 /* turn LED on */
1387 ep1_generic_commandl(pHDev, 2,
1388 EP1_CMD_SET_PORTD_LEDS,
1389 ~(ST7_PD_NBUSY_LED)
1390 );
1391 #endif
1392
1393 while (cmd)
1394 {
1395 switch (cmd->type)
1396 {
1397 case JTAG_RUNTEST:
1398 case JTAG_TLR_RESET:
1399 case JTAG_PATHMOVE:
1400 case JTAG_SCAN:
1401 break;
1402
1403 default:
1404 /* some events, such as resets, need a queue flush to ensure consistency */
1405 tap_state_queue_run();
1406 dtc_queue_run();
1407 break;
1408 }
1409
1410 switch (cmd->type)
1411 {
1412 case JTAG_RESET:
1413 #ifdef _DEBUG_JTAG_IO_
1414 LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1415 #endif
1416 if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
1417 {
1418 tap_set_state(TAP_RESET);
1419 }
1420 rlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1421 break;
1422 case JTAG_RUNTEST:
1423 #ifdef _DEBUG_JTAG_IO_
1424 LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
1425 #endif
1426 if (cmd->cmd.runtest->end_state != -1)
1427 rlink_end_state(cmd->cmd.runtest->end_state);
1428 rlink_runtest(cmd->cmd.runtest->num_cycles);
1429 break;
1430 case JTAG_TLR_RESET:
1431 #ifdef _DEBUG_JTAG_IO_
1432 LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
1433 #endif
1434 if (cmd->cmd.statemove->end_state != -1)
1435 rlink_end_state(cmd->cmd.statemove->end_state);
1436 rlink_state_move();
1437 break;
1438 case JTAG_PATHMOVE:
1439 #ifdef _DEBUG_JTAG_IO_
1440 LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
1441 #endif
1442 rlink_path_move(cmd->cmd.pathmove);
1443 break;
1444 case JTAG_SCAN:
1445 #ifdef _DEBUG_JTAG_IO_
1446 LOG_DEBUG("%s scan end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", cmd->cmd.scan->end_state);
1447 #endif
1448 if (cmd->cmd.scan->end_state != -1)
1449 rlink_end_state(cmd->cmd.scan->end_state);
1450 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1451 type = jtag_scan_type(cmd->cmd.scan);
1452 if (rlink_scan(cmd, type, buffer, scan_size) != ERROR_OK) {
1453 retval = ERROR_FAIL;
1454 }
1455 break;
1456 case JTAG_SLEEP:
1457 #ifdef _DEBUG_JTAG_IO_
1458 LOG_DEBUG("sleep %i", cmd->cmd.sleep->us);
1459 #endif
1460 jtag_sleep(cmd->cmd.sleep->us);
1461 break;
1462 default:
1463 LOG_ERROR("BUG: unknown JTAG command type encountered");
1464 exit(-1);
1465 }
1466 cmd = cmd->next;
1467 }
1468
1469 /* Flush the DTC queue to make sure any pending reads have been done before exiting this function */
1470 tap_state_queue_run();
1471 tmp_retval = dtc_queue_run();
1472 if (tmp_retval != ERROR_OK) {
1473 retval = tmp_retval;
1474 }
1475
1476 #ifndef AUTOMATIC_BUSY_LED
1477 /* turn LED onff */
1478 ep1_generic_commandl(pHDev, 2,
1479 EP1_CMD_SET_PORTD_LEDS,
1480 ~0
1481 );
1482 #endif
1483
1484 return retval;
1485 }
1486
1487
1488 /* 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. */
1489
1490 static
1491 int rlink_speed(int speed)
1492 {
1493 int i;
1494
1495 if (speed == 0) {
1496 /* fastest speed */
1497 speed = rlink_speed_table[rlink_speed_table_size - 1].prescaler;
1498 }
1499
1500 for (i = rlink_speed_table_size; i--;) {
1501 if (rlink_speed_table[i].prescaler == speed) {
1502 if (dtc_load_from_buffer(pHDev, rlink_speed_table[i].dtc, rlink_speed_table[i].dtc_size) != 0) {
1503 LOG_ERROR("An error occurred while trying to load DTC code for speed \"%d\".", speed);
1504 exit(1);
1505 }
1506
1507 if (dtc_start_download() < 0) {
1508 LOG_ERROR("%s, %d: starting DTC: %s",
1509 __FILE__, __LINE__,
1510 usb_strerror()
1511 );
1512 exit(1);
1513 }
1514
1515 return ERROR_OK;
1516 }
1517 }
1518
1519 LOG_ERROR("%d is not a supported speed", speed);
1520 return(ERROR_FAIL);
1521 }
1522
1523
1524 static
1525 int rlink_speed_div(
1526 int speed,
1527 int *khz
1528 ) {
1529 int i;
1530
1531 for (i = rlink_speed_table_size; i--;) {
1532 if (rlink_speed_table[i].prescaler == speed) {
1533 *khz = rlink_speed_table[i].khz;
1534 return(ERROR_OK);
1535 }
1536 }
1537
1538 LOG_ERROR("%d is not a supported speed", speed);
1539 return(ERROR_FAIL);
1540 }
1541
1542
1543 static
1544 int rlink_khz(
1545 int khz,
1546 int *speed
1547 ) {
1548 int i;
1549
1550 if (khz == 0) {
1551 LOG_ERROR("RCLK not supported");
1552 return ERROR_FAIL;
1553 }
1554
1555 for (i = rlink_speed_table_size; i--;) {
1556 if (rlink_speed_table[i].khz <= khz) {
1557 *speed = rlink_speed_table[i].prescaler;
1558 return(ERROR_OK);
1559 }
1560 }
1561
1562 LOG_WARNING("The lowest supported JTAG speed is %d KHz", rlink_speed_table[0].khz);
1563 *speed = rlink_speed_table[0].prescaler;
1564 return(ERROR_OK);
1565 }
1566
1567
1568 static
1569 int rlink_init(void)
1570 {
1571 int i, j, retries;
1572 uint8_t reply_buffer[USB_EP1IN_SIZE];
1573
1574 usb_init();
1575 const uint16_t vids[] = { USB_IDVENDOR, 0 };
1576 const uint16_t pids[] = { USB_IDPRODUCT, 0 };
1577 if (jtag_usb_open(vids, pids, &pHDev) != ERROR_OK)
1578 return ERROR_FAIL;
1579
1580 struct usb_device *dev = usb_device(pHDev);
1581 if (dev->descriptor.bNumConfigurations > 1)
1582 {
1583 LOG_ERROR("Whoops! NumConfigurations is not 1, don't know what to do...");
1584 return ERROR_FAIL;
1585 }
1586 if (dev->config->bNumInterfaces > 1)
1587 {
1588 LOG_ERROR("Whoops! NumInterfaces is not 1, don't know what to do...");
1589 return ERROR_FAIL;
1590 }
1591
1592 LOG_DEBUG("Opened device, pHDev = %p", pHDev);
1593
1594 /* usb_set_configuration required under win32 */
1595 usb_set_configuration(pHDev, dev->config[0].bConfigurationValue);
1596
1597 retries = 3;
1598 do
1599 {
1600 i = usb_claim_interface(pHDev,0);
1601 if (i)
1602 {
1603 LOG_ERROR("usb_claim_interface: %s", usb_strerror());
1604 #ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
1605 j = usb_detach_kernel_driver_np(pHDev, 0);
1606 if (j)
1607 LOG_ERROR("detach kernel driver: %s", usb_strerror());
1608 #endif
1609 }
1610 else
1611 {
1612 LOG_DEBUG("interface claimed!");
1613 break;
1614 }
1615 } while (--retries);
1616
1617 if (i)
1618 {
1619 LOG_ERROR("Initialisation failed.");
1620 return ERROR_FAIL;
1621 }
1622 if (usb_set_altinterface(pHDev,0) != 0)
1623 {
1624 LOG_ERROR("Failed to set interface.");
1625 return ERROR_FAIL;
1626 }
1627
1628 /* The device starts out in an unknown state on open. As such,
1629 * result reads time out, and it's not even known whether the
1630 * command was accepted. So, for this first command, we issue
1631 * it repeatedly until its response doesn't time out. Also, if
1632 * sending a command is going to time out, we find that out here.
1633 *
1634 * It must be possible to open the device in such a way that
1635 * this special magic isn't needed, but, so far, it escapes us.
1636 */
1637 for (i = 0; i < 5; i++) {
1638 j = ep1_generic_commandl(
1639 pHDev, 1,
1640 EP1_CMD_GET_FWREV
1641 );
1642 if (j < USB_EP1OUT_SIZE) {
1643 LOG_ERROR("USB write error: %s", usb_strerror());
1644 return(ERROR_FAIL);
1645 }
1646 j = usb_bulk_read(
1647 pHDev, USB_EP1IN_ADDR,
1648 (char *)reply_buffer, sizeof(reply_buffer),
1649 200
1650 );
1651 if (j != -ETIMEDOUT) break;
1652 }
1653
1654 if (j < (int)sizeof(reply_buffer)) {
1655 LOG_ERROR("USB read error: %s", usb_strerror());
1656 return(ERROR_FAIL);
1657 }
1658 LOG_DEBUG(INTERFACE_NAME" firmware version: %d.%d.%d", reply_buffer[0], reply_buffer[1], reply_buffer[2]);
1659
1660 if ((reply_buffer[0] != 0) || (reply_buffer[1] != 0) || (reply_buffer[2] != 3)) {
1661 LOG_WARNING("The rlink device is not of the version that the developers have played with. It may or may not work.");
1662 }
1663
1664 /* Probe port E for adapter presence */
1665 ep1_generic_commandl(
1666 pHDev, 16,
1667 EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 0 */
1668 ST7_PEDR >> 8,
1669 ST7_PEDR,
1670 3,
1671 0x00, /* DR */
1672 ST7_PE_ADAPTER_SENSE_OUT, /* DDR */
1673 ST7_PE_ADAPTER_SENSE_OUT, /* OR */
1674 EP1_CMD_MEMORY_READ, /* Read back */
1675 ST7_PEDR >> 8,
1676 ST7_PEDR,
1677 1,
1678 EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 1 */
1679 ST7_PEDR >> 8,
1680 ST7_PEDR,
1681 1,
1682 ST7_PE_ADAPTER_SENSE_OUT
1683 );
1684
1685 usb_bulk_read(
1686 pHDev, USB_EP1IN_ADDR,
1687 (char *)reply_buffer, 1,
1688 USB_TIMEOUT_MS
1689 );
1690
1691 if ((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) != 0) {
1692 LOG_WARNING("target detection problem");
1693 }
1694
1695 ep1_generic_commandl(
1696 pHDev, 11,
1697 EP1_CMD_MEMORY_READ, /* Read back */
1698 ST7_PEDR >> 8,
1699 ST7_PEDR,
1700 1,
1701 EP1_CMD_MEMORY_WRITE, /* float port E */
1702 ST7_PEDR >> 8,
1703 ST7_PEDR,
1704 3,
1705 0x00, /* DR */
1706 0x00, /* DDR */
1707 0x00 /* OR */
1708 );
1709
1710 usb_bulk_read(
1711 pHDev, USB_EP1IN_ADDR,
1712 (char *)reply_buffer, 1,
1713 USB_TIMEOUT_MS
1714 );
1715
1716
1717 if ((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) == 0) {
1718 LOG_WARNING("target not plugged in");
1719 }
1720
1721 /* float ports A and B */
1722 ep1_generic_commandl(
1723 pHDev, 11,
1724 EP1_CMD_MEMORY_WRITE,
1725 ST7_PADDR >> 8,
1726 ST7_PADDR,
1727 2,
1728 0x00,
1729 0x00,
1730 EP1_CMD_MEMORY_WRITE,
1731 ST7_PBDDR >> 8,
1732 ST7_PBDDR,
1733 1,
1734 0x00
1735 );
1736
1737 /* make sure DTC is stopped, set VPP control, set up ports A and B */
1738 ep1_generic_commandl(
1739 pHDev, 14,
1740 EP1_CMD_DTC_STOP,
1741 EP1_CMD_SET_PORTD_VPP,
1742 ~(ST7_PD_VPP_SHDN),
1743 EP1_CMD_MEMORY_WRITE,
1744 ST7_PADR >> 8,
1745 ST7_PADR,
1746 2,
1747 ((~(0)) & (ST7_PA_NTRST)),
1748 (ST7_PA_NTRST),
1749 /* 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. */
1750 EP1_CMD_MEMORY_WRITE,
1751 ST7_PBDR >> 8,
1752 ST7_PBDR,
1753 1,
1754 0x00
1755 );
1756
1757 /* set LED updating mode and make sure they're unlit */
1758 ep1_generic_commandl(
1759 pHDev, 3,
1760 #ifdef AUTOMATIC_BUSY_LED
1761 EP1_CMD_LEDUE_BUSY,
1762 #else
1763 EP1_CMD_LEDUE_NONE,
1764 #endif
1765 EP1_CMD_SET_PORTD_LEDS,
1766 ~0
1767 );
1768
1769 tap_state_queue_init();
1770 dtc_queue_init();
1771 rlink_reset(0, 0);
1772
1773 return ERROR_OK;
1774 }
1775
1776
1777 static
1778 int rlink_quit(void)
1779 {
1780 /* stop DTC and make sure LEDs are off */
1781 ep1_generic_commandl(
1782 pHDev, 6,
1783 EP1_CMD_DTC_STOP,
1784 EP1_CMD_LEDUE_NONE,
1785 EP1_CMD_SET_PORTD_LEDS,
1786 ~0,
1787 EP1_CMD_SET_PORTD_VPP,
1788 ~0
1789 );
1790
1791 usb_release_interface(pHDev,0);
1792 usb_close(pHDev);
1793
1794
1795 return ERROR_OK;
1796 }
1797
1798
1799 struct jtag_interface rlink_interface =
1800 {
1801 .name = "rlink",
1802 .init = rlink_init,
1803 .quit = rlink_quit,
1804 .speed = rlink_speed,
1805 .speed_div = rlink_speed_div,
1806 .khz = rlink_khz,
1807 .execute_queue = rlink_execute_queue,
1808 };