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