git.gag.com Git - fw/openocd/blob - src/jtag/drivers/rlink.c

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