OpenOCD
rlink.c
Go to the documentation of this file.
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, see <http://www.gnu.org/licenses/>. *
23  ***************************************************************************/
24 
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28 
29 /* project specific includes */
30 #include <jtag/interface.h>
31 #include <jtag/commands.h>
32 #include "rlink.h"
33 #include "rlink_st7.h"
34 #include "rlink_ep1_cmd.h"
35 #include "rlink_dtc_cmd.h"
36 #include "usb_common.h"
37 
38 /* This feature is made useless by running the DTC all the time. When automatic, the LED is on
39  *whenever the DTC is running. Otherwise, USB messages are sent to turn it on and off. */
40 #undef AUTOMATIC_BUSY_LED
41 
42 /* This feature may require derating the speed due to reduced hold time. */
43 #undef USE_HARDWARE_SHIFTER_FOR_TMS
44 
45 #define INTERFACE_NAME "RLink"
46 
47 #define USB_IDVENDOR (0x138e)
48 #define USB_IDPRODUCT (0x9000)
49 
50 #define USB_EP1OUT_ADDR (0x01)
51 #define USB_EP1OUT_SIZE (16)
52 #define USB_EP1IN_ADDR (USB_EP1OUT_ADDR | 0x80)
53 #define USB_EP1IN_SIZE (USB_EP1OUT_SIZE)
54 
55 #define USB_EP2OUT_ADDR (0x02)
56 #define USB_EP2OUT_SIZE (64)
57 #define USB_EP2IN_ADDR (USB_EP2OUT_ADDR | 0x80)
58 #define USB_EP2IN_SIZE (USB_EP2OUT_SIZE)
59 #define USB_EP2BANK_SIZE (512)
60 
61 #define USB_TIMEOUT_MS (3 * 1000)
62 
63 #define DTC_STATUS_POLL_BYTE (ST7_USB_BUF_EP0OUT + 0xff)
64 
65 #define ST7_PD_NBUSY_LED ST7_PD0
66 #define ST7_PD_NRUN_LED ST7_PD1
67 /* low enables VPP at adapter header, high connects it to GND instead */
68 #define ST7_PD_VPP_SEL ST7_PD6
69 /* low: VPP = 12v, high: VPP <= 5v */
70 #define ST7_PD_VPP_SHDN ST7_PD7
71 
72 /* These pins are connected together */
73 #define ST7_PE_ADAPTER_SENSE_IN ST7_PE3
74 #define ST7_PE_ADAPTER_SENSE_OUT ST7_PE4
75 
76 /* Symbolic mapping between port pins and numbered IO lines */
77 #define ST7_PA_IO1 ST7_PA1
78 #define ST7_PA_IO2 ST7_PA2
79 #define ST7_PA_IO4 ST7_PA4
80 #define ST7_PA_IO8 ST7_PA6
81 #define ST7_PA_IO10 ST7_PA7
82 #define ST7_PB_IO5 ST7_PB5
83 #define ST7_PC_IO9 ST7_PC1
84 #define ST7_PC_IO3 ST7_PC2
85 #define ST7_PC_IO7 ST7_PC3
86 #define ST7_PE_IO6 ST7_PE5
87 
88 /* Symbolic mapping between numbered IO lines and adapter signals */
89 #define ST7_PA_RTCK ST7_PA_IO0
90 #define ST7_PA_NTRST ST7_PA_IO1
91 #define ST7_PC_TDI ST7_PC_IO3
92 #define ST7_PA_DBGRQ ST7_PA_IO4
93 #define ST7_PB_NSRST ST7_PB_IO5
94 #define ST7_PE_TMS ST7_PE_IO6
95 #define ST7_PC_TCK ST7_PC_IO7
96 #define ST7_PC_TDO ST7_PC_IO9
97 #define ST7_PA_DBGACK ST7_PA_IO10
98 
99 static usb_dev_handle *pHDev;
100 
101 /*
102  * ep1 commands are up to USB_EP1OUT_SIZE bytes in length.
103  * This function takes care of zeroing the unused bytes before sending the packet.
104  * Any reply packet is not handled by this function.
105  */
106 static int ep1_generic_commandl(usb_dev_handle *pHDev_param, size_t length, ...)
107 {
108  uint8_t usb_buffer[USB_EP1OUT_SIZE];
109  uint8_t *usb_buffer_p;
110  va_list ap;
111  int usb_ret;
112 
113  if (length > sizeof(usb_buffer))
114  length = sizeof(usb_buffer);
115 
116  usb_buffer_p = usb_buffer;
117 
118  va_start(ap, length);
119  while (length > 0) {
120  *usb_buffer_p++ = va_arg(ap, int);
121  length--;
122  }
123 
124  memset(
125  usb_buffer_p,
126  0,
127  sizeof(usb_buffer) - (usb_buffer_p - usb_buffer)
128  );
129 
130  usb_ret = usb_bulk_write(
131  pHDev_param,
133  (char *)usb_buffer, sizeof(usb_buffer),
135  );
136 
137  return usb_ret;
138 }
139 
140 #if 0
141 static ssize_t ep1_memory_read(
142  usb_dev_handle *pHDev, uint16_t addr,
143  size_t length, uint8_t *buffer)
144 {
145  uint8_t usb_buffer[USB_EP1OUT_SIZE];
146  int usb_ret;
147  size_t remain;
148  ssize_t count;
149 
150  usb_buffer[0] = EP1_CMD_MEMORY_READ;
151  memset(
152  usb_buffer + 4,
153  0,
154  sizeof(usb_buffer) - 4
155  );
156 
157  remain = length;
158  count = 0;
159 
160  while (remain) {
161  if (remain > sizeof(usb_buffer))
162  length = sizeof(usb_buffer);
163  else
164  length = remain;
165 
166  usb_buffer[1] = addr >> 8;
167  usb_buffer[2] = addr;
168  usb_buffer[3] = length;
169 
170  usb_ret = usb_bulk_write(
171  pHDev, USB_EP1OUT_ADDR,
172  usb_buffer, sizeof(usb_buffer),
174  );
175 
176  if (usb_ret < sizeof(usb_buffer))
177  break;
178 
179  usb_ret = usb_bulk_read(
180  pHDev, USB_EP1IN_ADDR,
181  buffer, length,
183  );
184 
185  if (usb_ret < length)
186  break;
187 
188  addr += length;
189  buffer += length;
190  count += length;
191  remain -= length;
192  }
193 
194  return count;
195 }
196 #endif
197 
198 static ssize_t ep1_memory_write(usb_dev_handle *pHDev_param, uint16_t addr,
199  size_t length, uint8_t const *buffer)
200 {
201  uint8_t usb_buffer[USB_EP1OUT_SIZE];
202  int usb_ret;
203  size_t remain;
204  ssize_t count;
205 
206  usb_buffer[0] = EP1_CMD_MEMORY_WRITE;
207 
208  remain = length;
209  count = 0;
210 
211  while (remain) {
212  if (remain > (sizeof(usb_buffer) - 4))
213  length = (sizeof(usb_buffer) - 4);
214  else
215  length = remain;
216 
217  usb_buffer[1] = addr >> 8;
218  usb_buffer[2] = addr;
219  usb_buffer[3] = length;
220  memcpy(
221  usb_buffer + 4,
222  buffer,
223  length
224  );
225  memset(
226  usb_buffer + 4 + length,
227  0,
228  sizeof(usb_buffer) - 4 - length
229  );
230 
231  usb_ret = usb_bulk_write(
232  pHDev_param, USB_EP1OUT_ADDR,
233  (char *)usb_buffer, sizeof(usb_buffer),
235  );
236 
237  if ((size_t)usb_ret < sizeof(usb_buffer))
238  break;
239 
240  addr += length;
241  buffer += length;
242  count += length;
243  remain -= length;
244  }
245 
246  return count;
247 }
248 
249 
250 #if 0
251 static ssize_t ep1_memory_writel(usb_dev_handle *pHDev, uint16_t addr,
252  size_t length, ...)
253 {
254  uint8_t buffer[USB_EP1OUT_SIZE - 4];
255  uint8_t *buffer_p;
256  va_list ap;
257  size_t remain;
258 
259  if (length > sizeof(buffer))
260  length = sizeof(buffer);
261 
262  remain = length;
263  buffer_p = buffer;
264 
265  va_start(ap, length);
266  while (remain > 0) {
267  *buffer_p++ = va_arg(ap, int);
268  remain--;
269  }
270 
271  return ep1_memory_write(pHDev, addr, length, buffer);
272 }
273 #endif
274 
275 #define DTCLOAD_COMMENT (0)
276 #define DTCLOAD_ENTRY (1)
277 #define DTCLOAD_LOAD (2)
278 #define DTCLOAD_RUN (3)
279 #define DTCLOAD_LUT_START (4)
280 #define DTCLOAD_LUT (5)
281 
282 #define DTC_LOAD_BUFFER ST7_USB_BUF_EP2UIDO
283 
284 /* This gets set by the DTC loader */
285 static uint8_t dtc_entry_download;
286 
287 /* The buffer is specially formatted to represent a valid image to load into the DTC. */
288 static int dtc_load_from_buffer(usb_dev_handle *pHDev_param, const uint8_t *buffer,
289  size_t length)
290 {
291  struct header_s {
292  uint8_t type;
293  uint8_t length;
294  };
295 
296  int usb_err;
297  struct header_s *header;
298  uint8_t lut_start = 0xc0;
299 
300  dtc_entry_download = 0;
301 
302  /* Stop the DTC before loading anything. */
303  usb_err = ep1_generic_commandl(
304  pHDev_param, 1,
306  );
307  if (usb_err < 0)
308  return usb_err;
309 
310  while (length) {
311  if (length < sizeof(*header)) {
312  LOG_ERROR("Malformed DTC image");
313  exit(1);
314  }
315 
316  header = (struct header_s *)buffer;
317  buffer += sizeof(*header);
318  length -= sizeof(*header);
319 
320  if (length < (size_t)header->length + 1) {
321  LOG_ERROR("Malformed DTC image");
322  exit(1);
323  }
324 
325  switch (header->type) {
326  case DTCLOAD_COMMENT:
327  break;
328 
329  case DTCLOAD_ENTRY:
330  /* store entry addresses somewhere */
331  if (!strncmp("download", (char *)buffer + 1, 8))
332  dtc_entry_download = buffer[0];
333  break;
334 
335  case DTCLOAD_LOAD:
336  /* Send the DTC program to ST7 RAM. */
337  usb_err = ep1_memory_write(
338  pHDev_param,
340  header->length + 1, buffer
341  );
342  if (usb_err < 0)
343  return usb_err;
344 
345  /* Load it into the DTC. */
346  usb_err = ep1_generic_commandl(
347  pHDev_param, 3,
349  (DTC_LOAD_BUFFER >> 8),
351  );
352  if (usb_err < 0)
353  return usb_err;
354 
355  break;
356 
357  case DTCLOAD_RUN:
358  usb_err = ep1_generic_commandl(
359  pHDev_param, 3,
361  buffer[0],
363  );
364  if (usb_err < 0)
365  return usb_err;
366 
367  break;
368 
369  case DTCLOAD_LUT_START:
370  lut_start = buffer[0];
371  break;
372 
373  case DTCLOAD_LUT:
374  usb_err = ep1_memory_write(
375  pHDev_param,
376  ST7_USB_BUF_EP0OUT + lut_start,
377  header->length + 1, buffer
378  );
379  if (usb_err < 0)
380  return usb_err;
381  break;
382 
383  default:
384  LOG_ERROR("Invalid DTC image record type: 0x%02x", header->type);
385  exit(1);
386  break;
387  }
388 
389  buffer += (header->length + 1);
390  length -= (header->length + 1);
391  }
392 
393  return 0;
394 }
395 
396 /*
397  * Start the DTC running in download mode (waiting for 512 byte command packets on ep2).
398  */
399 static int dtc_start_download(void)
400 {
401  int usb_err;
402  uint8_t ep2txr;
403 
404  /* set up for download mode and make sure EP2 is set up to transmit */
405  usb_err = ep1_generic_commandl(
406  pHDev, 7,
407 
411  EP1_CMD_MEMORY_READ, /* read EP2TXR for its data toggle */
412  ST7_EP2TXR >> 8,
413  ST7_EP2TXR,
414  1
415  );
416  if (usb_err < 0)
417  return usb_err;
418 
419  /* read back ep2txr */
420  usb_err = usb_bulk_read(
421  pHDev, USB_EP1IN_ADDR,
422  (char *)&ep2txr, 1,
424  );
425  if (usb_err < 0)
426  return usb_err;
427 
428  usb_err = ep1_generic_commandl(
429  pHDev, 13,
430 
431  EP1_CMD_MEMORY_WRITE, /* preinitialize poll byte */
434  1,
435  0x00,
436  EP1_CMD_MEMORY_WRITE, /* set EP2IN to return data */
437  ST7_EP2TXR >> 8,
438  ST7_EP2TXR,
439  1,
441  EP1_CMD_DTC_CALL, /* start running the DTC */
442  dtc_entry_download,
444  );
445  if (usb_err < 0)
446  return usb_err;
447 
448  /* wait for completion */
449  usb_err = usb_bulk_read(
450  pHDev, USB_EP1IN_ADDR,
451  (char *)&ep2txr, 1,
453  );
454 
455  return usb_err;
456 }
457 
458 static int dtc_run_download(
459  usb_dev_handle *pHDev_param,
460  uint8_t *command_buffer,
461  int command_buffer_size,
462  uint8_t *reply_buffer,
463  int reply_buffer_size
464  )
465 {
466  char dtc_status;
467  int usb_err;
468  int i;
469 
470  LOG_DEBUG("%d/%d", command_buffer_size, reply_buffer_size);
471 
472  usb_err = usb_bulk_write(
473  pHDev_param,
475  (char *)command_buffer, USB_EP2BANK_SIZE,
477  );
478  if (usb_err < 0)
479  return usb_err;
480 
481 
482  /* Wait for DTC to finish running command buffer */
483  for (i = 50;; ) {
484  usb_err = ep1_generic_commandl(
485  pHDev_param, 4,
486 
490  1
491  );
492  if (usb_err < 0)
493  return usb_err;
494 
495  usb_err = usb_bulk_read(
496  pHDev_param,
498  &dtc_status, 1,
500  );
501  if (usb_err < 0)
502  return usb_err;
503 
504  if (dtc_status & 0x01)
505  break;
506 
507  if (!--i) {
508  LOG_ERROR("too many retries waiting for DTC status");
509  return -ETIMEDOUT;
510  }
511  }
512 
513 
514  if (reply_buffer && reply_buffer_size) {
515  usb_err = usb_bulk_read(
516  pHDev_param,
518  (char *)reply_buffer, reply_buffer_size,
520  );
521 
522  if (usb_err < reply_buffer_size) {
523  LOG_ERROR("Read of endpoint 2 returned %d, expected %d",
524  usb_err, reply_buffer_size
525  );
526  return usb_err;
527  }
528  }
529 
530  return usb_err;
531 }
532 
533 /*
534  * The dtc reply queue is a singly linked list that describes what to do
535  * with the reply packet that comes from the DTC. Only SCAN_IN and SCAN_IO generate
536  * these entries.
537  */
538 
541  struct jtag_command *cmd; /* the command that resulted in this entry */
542 
543  struct {
544  uint8_t *buffer; /* the scan buffer */
545  int size; /* size of the scan buffer in bits */
546  int offset; /* how many bits were already done before this? */
547  int length; /* how many bits are processed in this operation? */
548  enum scan_type type; /* SCAN_IN/SCAN_OUT/SCAN_IO */
549  } scan;
550 };
551 
552 
553 /*
554  * The dtc_queue consists of a buffer of pending commands and a reply queue.
555  * rlink_scan and tap_state_run add to the command buffer and maybe to the reply queue.
556  */
557 
558 static struct {
561  uint32_t cmd_index;
562  uint32_t reply_index;
564 } dtc_queue;
565 
566 /*
567  * The tap state queue is for accumulating TAP state changes wiithout needlessly
568  * flushing the dtc_queue. When it fills or is run, it adds the accumulated bytes to
569  * the dtc_queue.
570  */
571 
572 static struct {
573  uint32_t length;
574  uint32_t buffer;
576 
577 static int dtc_queue_init(void)
578 {
579  dtc_queue.rq_head = NULL;
580  dtc_queue.rq_tail = NULL;
581  dtc_queue.cmd_index = 0;
582  dtc_queue.reply_index = 0;
583  return 0;
584 }
585 
587  enum scan_type type, uint8_t *buffer, int size, int offset,
588  int length, struct jtag_command *cmd)
589 {
590  struct dtc_reply_queue_entry *rq_entry;
591 
592  rq_entry = malloc(sizeof(struct dtc_reply_queue_entry));
593  if (rq_entry != NULL) {
594  rq_entry->scan.type = type;
595  rq_entry->scan.buffer = buffer;
596  rq_entry->scan.size = size;
597  rq_entry->scan.offset = offset;
598  rq_entry->scan.length = length;
599  rq_entry->cmd = cmd;
600  rq_entry->next = NULL;
601 
602  if (dtc_queue.rq_head == NULL)
603  dtc_queue.rq_head = rq_entry;
604  else
605  dtc_queue.rq_tail->next = rq_entry;
606 
607  dtc_queue.rq_tail = rq_entry;
608  }
609 
610  return rq_entry;
611 }
612 
613 /*
614  * Running the queue means that any pending command buffer is run
615  * and any reply data dealt with. The command buffer is then cleared for subsequent processing.
616  * The queue is automatically run by append when it is necessary to get space for the append.
617  */
618 
619 static int dtc_queue_run(void)
620 {
621  struct dtc_reply_queue_entry *rq_p, *rq_next;
622  int retval;
623  int usb_err;
624  int bit_cnt;
625  int x;
626  uint8_t *dtc_p, *tdo_p;
627  uint8_t dtc_mask, tdo_mask;
628  uint8_t reply_buffer[USB_EP2IN_SIZE];
629 
630  assert((dtc_queue.rq_head != 0) == (dtc_queue.reply_index > 0));
631  assert(dtc_queue.cmd_index < USB_EP2BANK_SIZE);
632  assert(dtc_queue.reply_index <= USB_EP2IN_SIZE);
633 
634  retval = ERROR_OK;
635 
636  if (dtc_queue.cmd_index < 1)
637  return retval;
638 
639  dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = DTC_CMD_STOP;
640 
641  usb_err = dtc_run_download(pHDev,
642  dtc_queue.cmd_buffer, dtc_queue.cmd_index,
643  reply_buffer, sizeof(reply_buffer)
644  );
645  if (usb_err < 0) {
646  LOG_ERROR("dtc_run_download: %s", usb_strerror());
647  exit(1);
648  }
649 
650  if (dtc_queue.rq_head != NULL) {
651  /* process the reply, which empties the reply queue and frees its entries */
652  dtc_p = reply_buffer;
653 
654  /* The rigamarole with the masks and doing it bit-by-bit is due to the fact that the
655  *scan buffer is LSb-first and the DTC code is MSb-first for hardware reasons. It
656  *was that or craft a function to do the reversal, and that wouldn't work with
657  *bit-stuffing (supplying extra bits to use mostly byte operations), or any other
658  *scheme which would throw the byte alignment off. */
659 
660  for (
661  rq_p = dtc_queue.rq_head;
662  rq_p != NULL;
663  rq_p = rq_next
664  ) {
665  tdo_p = rq_p->scan.buffer + (rq_p->scan.offset / 8);
666  tdo_mask = 1 << (rq_p->scan.offset % 8);
667 
668 
669  bit_cnt = rq_p->scan.length;
670  if (bit_cnt >= 8) {
671  /* bytes */
672 
673  dtc_mask = 1 << (8 - 1);
674 
675  for (
676  ;
677  bit_cnt;
678  bit_cnt--
679  ) {
680  if (*dtc_p & dtc_mask)
681  *tdo_p |= tdo_mask;
682  else
683  *tdo_p &= ~tdo_mask;
684 
685  dtc_mask >>= 1;
686  if (dtc_mask == 0) {
687  dtc_p++;
688  dtc_mask = 1 << (8 - 1);
689  }
690 
691  tdo_mask <<= 1;
692  if (tdo_mask == 0) {
693  tdo_p++;
694  tdo_mask = 1;
695  }
696  }
697  } else {
698  /* extra bits or last bit */
699 
700  x = *dtc_p++;
701  if ((rq_p->scan.type == SCAN_IN) && (
702  rq_p->scan.offset != rq_p->scan.size - 1
703  )) {
704  /* extra bits were sent as a full byte with padding on the
705  *end */
706  dtc_mask = 1 << (8 - 1);
707  } else
708  dtc_mask = 1 << (bit_cnt - 1);
709 
710  for (
711  ;
712  bit_cnt;
713  bit_cnt--
714  ) {
715  if (x & dtc_mask)
716  *tdo_p |= tdo_mask;
717  else
718  *tdo_p &= ~tdo_mask;
719 
720  dtc_mask >>= 1;
721 
722  tdo_mask <<= 1;
723  if (tdo_mask == 0) {
724  tdo_p++;
725  tdo_mask = 1;
726  }
727 
728  }
729  }
730 
731  if ((rq_p->scan.offset + rq_p->scan.length) >= rq_p->scan.size) {
732  /* feed scan buffer back into openocd and free it */
733  if (jtag_read_buffer(rq_p->scan.buffer,
734  rq_p->cmd->cmd.scan) != ERROR_OK)
735  retval = ERROR_JTAG_QUEUE_FAILED;
736  free(rq_p->scan.buffer);
737  }
738 
739  rq_next = rq_p->next;
740  free(rq_p);
741  }
742  dtc_queue.rq_head = NULL;
743  dtc_queue.rq_tail = NULL;
744  }
745 
746  /* reset state for new appends */
747  dtc_queue.cmd_index = 0;
748  dtc_queue.reply_index = 0;
749 
750  return retval;
751 }
752 
753 /* runs the queue if it cannot take reserved_cmd bytes of command data
754  * or reserved_reply bytes of reply data */
755 static int dtc_queue_run_if_full(int reserved_cmd, int reserved_reply)
756 {
757  /* reserve one additional byte for the STOP cmd appended during run */
758  if (dtc_queue.cmd_index + reserved_cmd + 1 > USB_EP2BANK_SIZE)
759  return dtc_queue_run();
760 
761  if (dtc_queue.reply_index + reserved_reply > USB_EP2IN_SIZE)
762  return dtc_queue_run();
763 
764  return ERROR_OK;
765 }
766 
767 static int tap_state_queue_init(void)
768 {
769  tap_state_queue.length = 0;
770  tap_state_queue.buffer = 0;
771  return 0;
772 }
773 
774 static int tap_state_queue_run(void)
775 {
776  int i;
777  int bits;
778  uint8_t byte_param;
779  int retval;
780 
781  retval = 0;
782  if (!tap_state_queue.length)
783  return retval;
784  bits = 1;
785  byte_param = 0;
786  for (i = tap_state_queue.length; i--; ) {
787 
788  byte_param <<= 1;
789  if (tap_state_queue.buffer & 1)
790  byte_param |= 1;
791  if ((bits >= 8) || !i) {
792  byte_param <<= (8 - bits);
793 
794  /* make sure there's room for two cmd bytes */
795  dtc_queue_run_if_full(2, 0);
796 
797 #ifdef USE_HARDWARE_SHIFTER_FOR_TMS
798  if (bits == 8) {
799  dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
801  } else {
802 #endif
803  dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
805 #ifdef USE_HARDWARE_SHIFTER_FOR_TMS
806  }
807 #endif
808 
809  dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
810  byte_param;
811 
812  byte_param = 0;
813  bits = 1;
814  } else
815  bits++;
816 
817  tap_state_queue.buffer >>= 1;
818  }
819  retval = tap_state_queue_init();
820  return retval;
821 }
822 
823 static int tap_state_queue_append(uint8_t tms)
824 {
825  int retval;
826 
827  if (tap_state_queue.length >= sizeof(tap_state_queue.buffer) * 8) {
828  retval = tap_state_queue_run();
829  if (retval != 0)
830  return retval;
831  }
832 
833  if (tms)
834  tap_state_queue.buffer |= (1 << tap_state_queue.length);
835  tap_state_queue.length++;
836 
837  return 0;
838 }
839 
840 static void rlink_end_state(tap_state_t state)
841 {
842  if (tap_is_state_stable(state))
843  tap_set_end_state(state);
844  else {
845  LOG_ERROR("BUG: %i is not a valid end state", state);
846  exit(-1);
847  }
848 }
849 
850 static void rlink_state_move(void)
851 {
852 
853  int i = 0, tms = 0;
854  uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
856 
857  for (i = 0; i < tms_count; i++) {
858  tms = (tms_scan >> i) & 1;
860  }
861 
863 }
864 
866 {
867  int num_states = cmd->num_states;
868  int state_count;
869  int tms = 0;
870 
871  state_count = 0;
872  while (num_states) {
873  if (tap_state_transition(tap_get_state(), false) == cmd->path[state_count])
874  tms = 0;
875  else if (tap_state_transition(tap_get_state(), true) == cmd->path[state_count])
876  tms = 1;
877  else {
878  LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
880  tap_state_name(cmd->path[state_count]));
881  exit(-1);
882  }
883 
885 
886  tap_set_state(cmd->path[state_count]);
887  state_count++;
888  num_states--;
889  }
890 
892 }
893 
894 static void rlink_runtest(int num_cycles)
895 {
896  int i;
897 
898  tap_state_t saved_end_state = tap_get_end_state();
899 
900  /* only do a state_move when we're not already in RTI */
901  if (tap_get_state() != TAP_IDLE) {
904  }
905 
906  /* execute num_cycles */
907  for (i = 0; i < num_cycles; i++)
909 
910  /* finish in end_state */
911  rlink_end_state(saved_end_state);
912  if (tap_get_state() != tap_get_end_state())
914 }
915 
916 /* (1) assert or (0) deassert reset lines */
917 static void rlink_reset(int trst, int srst)
918 {
919  uint8_t bitmap;
920  int usb_err;
921 
922  /* Read port A for bit op */
923  usb_err = ep1_generic_commandl(
924  pHDev, 4,
926  ST7_PADR >> 8,
927  ST7_PADR,
928  1
929  );
930  if (usb_err < 0) {
931  LOG_ERROR("%s", usb_strerror());
932  exit(1);
933  }
934 
935  usb_err = usb_bulk_read(
936  pHDev, USB_EP1IN_ADDR,
937  (char *)&bitmap, 1,
939  );
940  if (usb_err < 1) {
941  LOG_ERROR("%s", usb_strerror());
942  exit(1);
943  }
944 
945  if (trst)
946  bitmap &= ~ST7_PA_NTRST;
947  else
948  bitmap |= ST7_PA_NTRST;
949 
950  /* Write port A and read port B for bit op
951  * port B has no OR, and we want to emulate open drain on NSRST, so we initialize DR to 0
952  *and assert NSRST by setting DDR to 1. */
953  usb_err = ep1_generic_commandl(
954  pHDev, 9,
956  ST7_PADR >> 8,
957  ST7_PADR,
958  1,
959  bitmap,
961  ST7_PBDDR >> 8,
962  ST7_PBDDR,
963  1
964  );
965  if (usb_err < 0) {
966  LOG_ERROR("%s", usb_strerror());
967  exit(1);
968  }
969 
970  usb_err = usb_bulk_read(
971  pHDev, USB_EP1IN_ADDR,
972  (char *)&bitmap, 1,
974  );
975  if (usb_err < 1) {
976  LOG_ERROR("%s", usb_strerror());
977  exit(1);
978  }
979 
980  if (srst)
981  bitmap |= ST7_PB_NSRST;
982  else
983  bitmap &= ~ST7_PB_NSRST;
984 
985  /* write port B and read dummy to ensure completion before returning */
986  usb_err = ep1_generic_commandl(
987  pHDev, 6,
989  ST7_PBDDR >> 8,
990  ST7_PBDDR,
991  1,
992  bitmap,
994  );
995  if (usb_err < 0) {
996  LOG_ERROR("%s", usb_strerror());
997  exit(1);
998  }
999 
1000  usb_err = usb_bulk_read(
1001  pHDev, USB_EP1IN_ADDR,
1002  (char *)&bitmap, 1,
1004  );
1005  if (usb_err < 1) {
1006  LOG_ERROR("%s", usb_strerror());
1007  exit(1);
1008  }
1009 }
1010 
1011 static int rlink_scan(struct jtag_command *cmd, enum scan_type type,
1012  uint8_t *buffer, int scan_size)
1013 {
1014  bool ir_scan;
1015  tap_state_t saved_end_state;
1016  int byte_bits;
1017  int extra_bits;
1018  int chunk_bits;
1019  int chunk_bytes;
1020  int x;
1021 
1022  int tdi_bit_offset;
1023  uint8_t tdi_mask, *tdi_p;
1024  uint8_t dtc_mask;
1025 
1026  if (scan_size < 1) {
1027  LOG_ERROR("scan_size cannot be less than 1 bit");
1028  exit(1);
1029  }
1030 
1031  ir_scan = cmd->cmd.scan->ir_scan;
1032 
1033  /* Move to the proper state before starting to shift TDI/TDO. */
1034  if (!((!ir_scan && (tap_get_state() == TAP_DRSHIFT)) ||
1035  (ir_scan && (tap_get_state() == TAP_IRSHIFT)))) {
1036  saved_end_state = tap_get_end_state();
1038  rlink_state_move();
1039  rlink_end_state(saved_end_state);
1040  }
1041 
1043 
1044 
1045 #if 0
1046  printf("scan_size = %d, type = 0x%x\n", scan_size, type);
1047  {
1048  int i;
1049 
1050  /* clear unused bits in scan buffer for ease of debugging
1051  * (it makes diffing output easier) */
1052  buffer[scan_size / 8] &= ((1 << ((scan_size - 1) % 8) + 1) - 1);
1053 
1054  printf("before scan:");
1055  for (i = 0; i < (scan_size + 7) / 8; i++)
1056  printf(" %02x", buffer[i]);
1057  printf("\n");
1058  }
1059 #endif
1060 
1061  /* The number of bits that can be shifted as complete bytes */
1062  byte_bits = (int)(scan_size - 1) / 8 * 8;
1063  /* The number of bits left over, not counting the last bit */
1064  extra_bits = (scan_size - 1) - byte_bits;
1065 
1066  tdi_bit_offset = 0;
1067  tdi_p = buffer;
1068  tdi_mask = 1;
1069 
1070  if (extra_bits && (type == SCAN_OUT)) {
1071  /* Schedule any extra bits into the DTC command buffer, padding as needed
1072  * For SCAN_OUT, this comes before the full bytes so the (leading) padding bits will
1073  *fall off the end */
1074 
1075  /* make sure there's room for two cmd bytes */
1076  dtc_queue_run_if_full(2, 0);
1077 
1078  x = 0;
1079  dtc_mask = 1 << (extra_bits - 1);
1080 
1081  while (extra_bits--) {
1082  if (*tdi_p & tdi_mask)
1083  x |= dtc_mask;
1084 
1085  dtc_mask >>= 1;
1086 
1087  tdi_mask <<= 1;
1088  if (tdi_mask == 0) {
1089  tdi_p++;
1090  tdi_mask = 1;
1091  }
1092  }
1093 
1094  dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1096 
1097  dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1098  }
1099 
1100  /* Loop scheduling full bytes into the DTC command buffer */
1101  while (byte_bits) {
1102  /* make sure there's room for one (for in scans) or two cmd bytes and
1103  * at least one reply byte for in or inout scans*/
1104  dtc_queue_run_if_full(type == SCAN_IN ? 1 : 2, type != SCAN_OUT ? 1 : 0);
1105 
1106  chunk_bits = byte_bits;
1107  /* we can only use up to 16 bytes at a time */
1108  if (chunk_bits > (16 * 8))
1109  chunk_bits = (16 * 8);
1110 
1111  if (type != SCAN_IN) {
1112  /* how much is there room for, considering stop and byte op? */
1113  x = (sizeof(dtc_queue.cmd_buffer) - (dtc_queue.cmd_index + 1 + 1)) * 8;
1114  if (chunk_bits > x)
1115  chunk_bits = x;
1116  }
1117 
1118  if (type != SCAN_OUT) {
1119  /* how much is there room for in the reply buffer? */
1120  x = (USB_EP2IN_SIZE - dtc_queue.reply_index) * 8;
1121  if (chunk_bits > x)
1122  chunk_bits = x;
1123  }
1124 
1125  /* so the loop will end */
1126  byte_bits -= chunk_bits;
1127 
1128  if (type != SCAN_OUT) {
1130  type, buffer, scan_size, tdi_bit_offset,
1131  chunk_bits,
1132  cmd
1133  ) == NULL) {
1134  LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno));
1135  exit(1);
1136  }
1137  dtc_queue.reply_index += (chunk_bits + 7) / 8;
1138 
1139  tdi_bit_offset += chunk_bits;
1140  }
1141 
1142  /* chunk_bits is a multiple of 8, so there are no rounding issues. */
1143  chunk_bytes = chunk_bits / 8;
1144 
1145  switch (type) {
1146  case SCAN_IN:
1147  x = DTC_CMD_SHIFT_TDO_BYTES(chunk_bytes);
1148  break;
1149  case SCAN_OUT:
1150  x = DTC_CMD_SHIFT_TDI_BYTES(chunk_bytes);
1151  break;
1152  default:
1153  x = DTC_CMD_SHIFT_TDIO_BYTES(chunk_bytes);
1154  break;
1155  }
1156  dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1157 
1158  if (type != SCAN_IN) {
1159  x = 0;
1160  dtc_mask = 1 << (8 - 1);
1161 
1162  while (chunk_bits--) {
1163  if (*tdi_p & tdi_mask)
1164  x |= dtc_mask;
1165 
1166  dtc_mask >>= 1;
1167  if (dtc_mask == 0) {
1168  dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1169  x = 0;
1170  dtc_mask = 1 << (8 - 1);
1171  }
1172 
1173  tdi_mask <<= 1;
1174  if (tdi_mask == 0) {
1175  tdi_p++;
1176  tdi_mask = 1;
1177  }
1178  }
1179  }
1180  }
1181 
1182  if (extra_bits && (type != SCAN_OUT)) {
1183  /* Schedule any extra bits into the DTC command buffer */
1184 
1185  /* make sure there's room for one (for in scans) or two cmd bytes
1186  * and one reply byte */
1187  dtc_queue_run_if_full(type == SCAN_IN ? 1 : 2, 1);
1188 
1190  type, buffer, scan_size, tdi_bit_offset,
1191  extra_bits,
1192  cmd
1193  ) == NULL) {
1194  LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno));
1195  exit(1);
1196  }
1197 
1198  dtc_queue.reply_index++;
1199 
1200  tdi_bit_offset += extra_bits;
1201 
1202  if (type == SCAN_IN) {
1203  dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1205 
1206  } else {
1207  dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1208  DTC_CMD_SHIFT_TDIO_BITS(extra_bits);
1209 
1210  x = 0;
1211  dtc_mask = 1 << (8 - 1);
1212 
1213  while (extra_bits--) {
1214  if (*tdi_p & tdi_mask)
1215  x |= dtc_mask;
1216 
1217  dtc_mask >>= 1;
1218 
1219  tdi_mask <<= 1;
1220  if (tdi_mask == 0) {
1221  tdi_p++;
1222  tdi_mask = 1;
1223  }
1224  }
1225 
1226  dtc_queue.cmd_buffer[dtc_queue.cmd_index++] = x;
1227  }
1228  }
1229 
1230  /* Schedule the last bit into the DTC command buffer */
1231 
1232  /* make sure there's room for one cmd byte and one reply byte
1233  * for in or inout scans*/
1234  dtc_queue_run_if_full(1, type == SCAN_OUT ? 0 : 1);
1235 
1236  if (type == SCAN_OUT) {
1237  dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1238  DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 0);
1239 
1240  } else {
1242  type, buffer, scan_size, tdi_bit_offset,
1243  1,
1244  cmd
1245  ) == NULL) {
1246  LOG_ERROR("enqueuing DTC reply entry: %s", strerror(errno));
1247  exit(1);
1248  }
1249 
1250  dtc_queue.reply_index++;
1251 
1252  dtc_queue.cmd_buffer[dtc_queue.cmd_index++] =
1253  DTC_CMD_SHIFT_TMS_TDI_BIT_PAIR(1, (*tdi_p & tdi_mask), 1);
1254  }
1255 
1256  /* Move to pause state */
1258  tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
1259  if (tap_get_state() != tap_get_end_state())
1260  rlink_state_move();
1261 
1262  return 0;
1263 }
1264 
1265 static int rlink_execute_queue(void)
1266 {
1267  struct jtag_command *cmd = jtag_command_queue; /* currently processed command */
1268  int scan_size;
1269  enum scan_type type;
1270  uint8_t *buffer;
1271  int retval, tmp_retval;
1272 
1273  /* return ERROR_OK, unless something goes wrong */
1274  retval = ERROR_OK;
1275 
1276 #ifndef AUTOMATIC_BUSY_LED
1277  /* turn LED on */
1278  ep1_generic_commandl(pHDev, 2,
1280  ~(ST7_PD_NBUSY_LED)
1281  );
1282 #endif
1283 
1284  while (cmd) {
1285  switch (cmd->type) {
1286  case JTAG_RUNTEST:
1287  case JTAG_TLR_RESET:
1288  case JTAG_PATHMOVE:
1289  case JTAG_SCAN:
1290  break;
1291 
1292  default:
1293  /* some events, such as resets, need a queue flush to ensure
1294  *consistency */
1296  dtc_queue_run();
1297  break;
1298  }
1299 
1300  switch (cmd->type) {
1301  case JTAG_RESET:
1302 #ifdef _DEBUG_JTAG_IO_
1303  LOG_DEBUG("reset trst: %i srst %i",
1304  cmd->cmd.reset->trst,
1305  cmd->cmd.reset->srst);
1306 #endif
1307  if ((cmd->cmd.reset->trst == 1) ||
1308  (cmd->cmd.reset->srst &&
1311  rlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1312  break;
1313  case JTAG_RUNTEST:
1314 #ifdef _DEBUG_JTAG_IO_
1315  LOG_DEBUG("runtest %i cycles, end in %i",
1316  cmd->cmd.runtest->num_cycles,
1317  cmd->cmd.runtest->end_state);
1318 #endif
1319  if (cmd->cmd.runtest->end_state != -1)
1322  break;
1323  case JTAG_TLR_RESET:
1324 #ifdef _DEBUG_JTAG_IO_
1325  LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
1326 #endif
1327  if (cmd->cmd.statemove->end_state != -1)
1329  rlink_state_move();
1330  break;
1331  case JTAG_PATHMOVE:
1332 #ifdef _DEBUG_JTAG_IO_
1333  LOG_DEBUG("pathmove: %i states, end in %i",
1334  cmd->cmd.pathmove->num_states,
1335  cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
1336 #endif
1338  break;
1339  case JTAG_SCAN:
1340 #ifdef _DEBUG_JTAG_IO_
1341  LOG_DEBUG("%s scan end in %i",
1342  (cmd->cmd.scan->ir_scan) ? "IR" : "DR",
1343  cmd->cmd.scan->end_state);
1344 #endif
1345  if (cmd->cmd.scan->end_state != -1)
1347  scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1348  type = jtag_scan_type(cmd->cmd.scan);
1349  if (rlink_scan(cmd, type, buffer, scan_size) != ERROR_OK)
1350  retval = ERROR_FAIL;
1351  break;
1352  case JTAG_SLEEP:
1353 #ifdef _DEBUG_JTAG_IO_
1354  LOG_DEBUG("sleep %i", cmd->cmd.sleep->us);
1355 #endif
1356  jtag_sleep(cmd->cmd.sleep->us);
1357  break;
1358  default:
1359  LOG_ERROR("BUG: unknown JTAG command type encountered");
1360  exit(-1);
1361  }
1362  cmd = cmd->next;
1363  }
1364 
1365  /* Flush the DTC queue to make sure any pending reads have been done before exiting this
1366  *function */
1368  tmp_retval = dtc_queue_run();
1369  if (tmp_retval != ERROR_OK)
1370  retval = tmp_retval;
1371 
1372 #ifndef AUTOMATIC_BUSY_LED
1373  /* turn LED onff */
1374  ep1_generic_commandl(pHDev, 2,
1376  ~0
1377  );
1378 #endif
1379 
1380  return retval;
1381 }
1382 
1383 /* Using an unindexed table because it is infrequently accessed and it is short. The table must be
1384  *in order of ascending speed (and descending prescaler), as it is scanned in reverse. */
1385 
1386 static int rlink_speed(int speed)
1387 {
1388  int i;
1389 
1390  if (speed == 0) {
1391  /* fastest speed */
1393  }
1394 
1395  for (i = rlink_speed_table_size; i--; ) {
1396  if (rlink_speed_table[i].prescaler == speed) {
1397  if (dtc_load_from_buffer(pHDev, rlink_speed_table[i].dtc,
1398  rlink_speed_table[i].dtc_size) != 0) {
1399  LOG_ERROR(
1400  "An error occurred while trying to load DTC code for speed \"%d\".",
1401  speed);
1402  exit(1);
1403  }
1404 
1405  if (dtc_start_download() < 0) {
1406  LOG_ERROR("starting DTC: %s", usb_strerror());
1407  exit(1);
1408  }
1409 
1410  return ERROR_OK;
1411  }
1412  }
1413 
1414  LOG_ERROR("%d is not a supported speed", speed);
1415  return ERROR_FAIL;
1416 }
1417 
1418 static int rlink_speed_div(int speed, int *khz)
1419 {
1420  int i;
1421 
1422  for (i = rlink_speed_table_size; i--; ) {
1423  if (rlink_speed_table[i].prescaler == speed) {
1424  *khz = rlink_speed_table[i].khz;
1425  return ERROR_OK;
1426  }
1427  }
1428 
1429  LOG_ERROR("%d is not a supported speed", speed);
1430  return ERROR_FAIL;
1431 }
1432 
1433 static int rlink_khz(int khz, int *speed)
1434 {
1435  int i;
1436 
1437  if (khz == 0) {
1438  LOG_ERROR("RCLK not supported");
1439  return ERROR_FAIL;
1440  }
1441 
1442  for (i = rlink_speed_table_size; i--; ) {
1443  if (rlink_speed_table[i].khz <= khz) {
1444  *speed = rlink_speed_table[i].prescaler;
1445  return ERROR_OK;
1446  }
1447  }
1448 
1449  LOG_WARNING("The lowest supported JTAG speed is %d KHz", rlink_speed_table[0].khz);
1450  *speed = rlink_speed_table[0].prescaler;
1451  return ERROR_OK;
1452 }
1453 
1454 static int rlink_init(void)
1455 {
1456  int i, j, retries;
1457  uint8_t reply_buffer[USB_EP1IN_SIZE];
1458 
1459  usb_init();
1460  const uint16_t vids[] = { USB_IDVENDOR, 0 };
1461  const uint16_t pids[] = { USB_IDPRODUCT, 0 };
1462  if (jtag_usb_open(vids, pids, &pHDev) != ERROR_OK)
1463  return ERROR_FAIL;
1464 
1465  struct usb_device *dev = usb_device(pHDev);
1466  if (dev->descriptor.bNumConfigurations > 1) {
1467  LOG_ERROR("Whoops! NumConfigurations is not 1, don't know what to do...");
1468  return ERROR_FAIL;
1469  }
1470  if (dev->config->bNumInterfaces > 1) {
1471  LOG_ERROR("Whoops! NumInterfaces is not 1, don't know what to do...");
1472  return ERROR_FAIL;
1473  }
1474 
1475  LOG_DEBUG("Opened device, pHDev = %p", pHDev);
1476 
1477  /* usb_set_configuration required under win32 */
1478  usb_set_configuration(pHDev, dev->config[0].bConfigurationValue);
1479 
1480  retries = 3;
1481  do {
1482  i = usb_claim_interface(pHDev, 0);
1483  if (i) {
1484  LOG_ERROR("usb_claim_interface: %s", usb_strerror());
1485 #ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
1486  j = usb_detach_kernel_driver_np(pHDev, 0);
1487  if (j)
1488  LOG_ERROR("detach kernel driver: %s", usb_strerror());
1489 #endif
1490  } else {
1491  LOG_DEBUG("interface claimed!");
1492  break;
1493  }
1494  } while (--retries);
1495 
1496  if (i) {
1497  LOG_ERROR("Initialisation failed.");
1498  return ERROR_FAIL;
1499  }
1500  if (usb_set_altinterface(pHDev, 0) != 0) {
1501  LOG_ERROR("Failed to set interface.");
1502  return ERROR_FAIL;
1503  }
1504 
1505  /* The device starts out in an unknown state on open. As such,
1506  * result reads time out, and it's not even known whether the
1507  * command was accepted. So, for this first command, we issue
1508  * it repeatedly until its response doesn't time out. Also, if
1509  * sending a command is going to time out, we find that out here.
1510  *
1511  * It must be possible to open the device in such a way that
1512  * this special magic isn't needed, but, so far, it escapes us.
1513  */
1514  for (i = 0; i < 5; i++) {
1516  pHDev, 1,
1518  );
1519  if (j < USB_EP1OUT_SIZE) {
1520  LOG_ERROR("USB write error: %s", usb_strerror());
1521  return ERROR_FAIL;
1522  }
1523  j = usb_bulk_read(
1524  pHDev, USB_EP1IN_ADDR,
1525  (char *)reply_buffer, sizeof(reply_buffer),
1526  200
1527  );
1528  if (j != -ETIMEDOUT)
1529  break;
1530  }
1531 
1532  if (j < (int)sizeof(reply_buffer)) {
1533  LOG_ERROR("USB read error: %s", usb_strerror());
1534  return ERROR_FAIL;
1535  }
1536  LOG_DEBUG(INTERFACE_NAME " firmware version: %d.%d.%d",
1537  reply_buffer[0],
1538  reply_buffer[1],
1539  reply_buffer[2]);
1540 
1541  if ((reply_buffer[0] != 0) || (reply_buffer[1] != 0) || (reply_buffer[2] != 3))
1542  LOG_WARNING(
1543  "The rlink device is not of the version that the developers have played with. It may or may not work.");
1544 
1545  /* Probe port E for adapter presence */
1547  pHDev, 16,
1548  EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 0 */
1549  ST7_PEDR >> 8,
1550  ST7_PEDR,
1551  3,
1552  0x00, /* DR */
1553  ST7_PE_ADAPTER_SENSE_OUT, /* DDR */
1554  ST7_PE_ADAPTER_SENSE_OUT, /* OR */
1555  EP1_CMD_MEMORY_READ, /* Read back */
1556  ST7_PEDR >> 8,
1557  ST7_PEDR,
1558  1,
1559  EP1_CMD_MEMORY_WRITE, /* Drive sense pin with 1 */
1560  ST7_PEDR >> 8,
1561  ST7_PEDR,
1562  1,
1564  );
1565 
1566  usb_bulk_read(
1567  pHDev, USB_EP1IN_ADDR,
1568  (char *)reply_buffer, 1,
1570  );
1571 
1572  if ((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) != 0)
1573  LOG_WARNING("target detection problem");
1574 
1576  pHDev, 11,
1577  EP1_CMD_MEMORY_READ, /* Read back */
1578  ST7_PEDR >> 8,
1579  ST7_PEDR,
1580  1,
1581  EP1_CMD_MEMORY_WRITE, /* float port E */
1582  ST7_PEDR >> 8,
1583  ST7_PEDR,
1584  3,
1585  0x00, /* DR */
1586  0x00, /* DDR */
1587  0x00 /* OR */
1588  );
1589 
1590  usb_bulk_read(
1591  pHDev, USB_EP1IN_ADDR,
1592  (char *)reply_buffer, 1,
1594  );
1595 
1596 
1597  if ((reply_buffer[0] & ST7_PE_ADAPTER_SENSE_IN) == 0)
1598  LOG_WARNING("target not plugged in");
1599 
1600  /* float ports A and B */
1602  pHDev, 11,
1604  ST7_PADDR >> 8,
1605  ST7_PADDR,
1606  2,
1607  0x00,
1608  0x00,
1610  ST7_PBDDR >> 8,
1611  ST7_PBDDR,
1612  1,
1613  0x00
1614  );
1615 
1616  /* make sure DTC is stopped, set VPP control, set up ports A and B */
1618  pHDev, 14,
1621  ~(ST7_PD_VPP_SHDN),
1623  ST7_PADR >> 8,
1624  ST7_PADR,
1625  2,
1626  ((~(0)) & (ST7_PA_NTRST)),
1627  (ST7_PA_NTRST),
1628  /* port B has no OR, and we want to emulate open drain on NSRST, so we set DR to 0
1629  *here and later assert NSRST by setting DDR bit to 1. */
1631  ST7_PBDR >> 8,
1632  ST7_PBDR,
1633  1,
1634  0x00
1635  );
1636 
1637  /* set LED updating mode and make sure they're unlit */
1639  pHDev, 3,
1640 #ifdef AUTOMATIC_BUSY_LED
1642 #else
1644 #endif
1646  ~0
1647  );
1648 
1650  dtc_queue_init();
1651  rlink_reset(0, 0);
1652 
1653  return ERROR_OK;
1654 }
1655 
1656 static int rlink_quit(void)
1657 {
1658  /* stop DTC and make sure LEDs are off */
1660  pHDev, 6,
1664  ~0,
1666  ~0
1667  );
1668 
1669  usb_release_interface(pHDev, 0);
1670  usb_close(pHDev);
1671 
1672  return ERROR_OK;
1673 }
1674 
1676  .name = "rlink",
1677  .init = rlink_init,
1678  .quit = rlink_quit,
1679  .speed = rlink_speed,
1680  .speed_div = rlink_speed_div,
1681  .khz = rlink_khz,
1682  .execute_queue = rlink_execute_queue,
1683 };
struct pathmove_command * pathmove
Definition: commands.h:126
static void tap_set_state(tap_state_t new_state)
This function sets the state of a "state follower" which tracks the state of the TAPs connected to th...
Definition: interface.h:66
#define LOG_DEBUG(expr...)
Definition: log.h:103
Represents a driver for a debugging interface.
Definition: interface.h:198
int srst
Set SRST output: 0 = deassert, 1 = assert, -1 = no change.
Definition: commands.h:87
uint32_t us
number of microseconds to sleep
Definition: commands.h:97
bool ir_scan
instruction/not data scan
Definition: commands.h:48
unsigned short addr
Definition: embeddedice.c:56
From device to host,.
Definition: commands.h:35
scan_type
The inferred type of a scan_command_s structure, indicating whether the command has the host scan in ...
Definition: commands.h:33
const char * type
Definition: arm_adi_v5.c:960
int tap_get_tms_path_len(tap_state_t from, tap_state_t to)
Function int tap_get_tms_path_len returns the total number of bits that represents a TMS path transit...
Definition: interface.c:206
struct jtag_command * cmd
Definition: rlink.c:541
bool tap_is_state_stable(tap_state_t astate)
Function tap_is_state_stable returns true if the astate is stable.
Definition: interface.c:211
int length
Definition: rlink.c:547
#define ERROR_FAIL
Definition: log.h:138
tap_state_t tap_get_state()
This function gets the state of the "state follower" which tracks the state of the TAPs connected to ...
Definition: interface.c:48
union jtag_command_container cmd
Definition: commands.h:158
Definition: jtag.h:79
int num_states
number of states in *path
Definition: commands.h:64
const char * tap_state_name(tap_state_t state)
Function tap_state_name Returns a string suitable for display representing the JTAG tap_state...
Definition: interface.c:355
struct statemove_command * statemove
Definition: commands.h:125
struct dtc_reply_queue_entry * next
Definition: rlink.c:540
const char *const name
The name of the JTAG interface driver.
Definition: interface.h:200
void usb_init(void)
USB initialization.
Definition: usb.c:531
int bits
Definition: zy1000.c:962
int tap_get_tms_path(tap_state_t from, tap_state_t to)
This function provides a "bit sequence" indicating what has to be done with TMS during a sequence of ...
Definition: interface.c:201
#define LOG_ERROR(expr...)
Definition: log.h:117
enum scan_type jtag_scan_type(const struct scan_command *cmd)
Definition: commands.c:147
int size
Definition: rlink.c:545
tap_state_t tap_get_end_state()
For more information,.
Definition: interface.c:67
enum reset_types jtag_get_reset_config(void)
Definition: jtag/core.c:1709
int offset
Definition: rlink.c:546
From host to device,.
Definition: commands.h:37
int jtag_read_buffer(uint8_t *buffer, const struct scan_command *cmd)
Definition: commands.c:215
tap_state_t tap_state_transition(tap_state_t cur_state, bool tms)
Function tap_state_transition takes a current TAP state and returns the next state according to the t...
Definition: interface.c:234
tap_state_t end_state
state in which JTAG commands should finish
Definition: commands.h:54
enum tap_state tap_state_t
Defines JTAG Test Access Port states.
static const uint16_t pids[][2]
Definition: discovery.c:41
Definition: jtag.h:82
enum jtag_command_type type
Definition: commands.h:159
int jtag_usb_open(const uint16_t vids[], const uint16_t pids[], struct usb_dev_handle **out)
Definition: usb_common.c:35
tap_state_t end_state
state in which JTAG commands should finish
Definition: commands.h:59
void tap_set_end_state(tap_state_t new_end_state)
This function sets the state of an "end state follower" which tracks the state that any cable driver ...
Definition: interface.c:59
struct runtest_command * runtest
Definition: commands.h:127
return ERROR_OK
Definition: presto.c:490
int jtag_build_buffer(const struct scan_command *cmd, uint8_t **buffer)
Definition: commands.c:174
uint8_t * buffer
Definition: rlink.c:544
struct scan_command * scan
Definition: commands.h:124
tap_state_t end_state
state in which JTAG commands should finish
Definition: commands.h:73
struct jtag_command * next
Definition: commands.h:160
static int count
Definition: helper/log.c:61
void jtag_sleep(uint32_t us)
Definition: jtag/core.c:886
#define ERROR_JTAG_QUEUE_FAILED
Definition: jtag.h:603
struct dtc_reply_queue_entry::@18 scan
enum scan_type type
Definition: rlink.c:548
#define NULL
Definition: usb.h:27
tap_state_t * path
states that have to be passed
Definition: commands.h:66
struct reset_command * reset
Definition: commands.h:129
int num_cycles
number of cycles to spend in Run-Test/Idle state
Definition: commands.h:71
Definition: rlink.c:539
struct sleep_command * sleep
Definition: commands.h:131
int trst
Set TRST output: 0 = deassert, 1 = assert, -1 = no change.
Definition: commands.h:85
#define LOG_WARNING(expr...)
Definition: log.h:114
struct jtag_command * jtag_command_queue
The current queue of jtag_command_s structures.
Definition: commands.c:46