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

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)