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

   1 /*******************************************************************************
   2  *   Driver for OpenJTAG Project (www.openjtag.org)                            *
   3  *   Compatible with libftdi and ftd2xx drivers.                               *
   4  *                                                                             *
   5  *   Copyright (C) 2010 by Ivan Meleca <mileca@gmail.com>                      *
   6  *                                                                             *
   7  *   Copyright (C) 2013 by Ryan Corbin, GlueLogix Inc. <corbin.ryan@gmail.com> *
   8  *   Updated to work with OpenOCD v0.7.0. Fixed libftdi read speed issue.      *
   9  *                                                                             *
  10  *   Based on usb_blaster.c                                                    *
  11  *   Copyright (C) 2009 Catalin Patulea                                        *
  12  *   Copyright (C) 2006 Kolja Waschk                                           *
  13  *                                                                             *
  14  *   And jlink.c                                                               *
  15  *   Copyright (C) 2008 by Spencer Oliver                                      *
  16  *   spen@spen-soft.co.uk                                                      *
  17  *                                                                             *
  18  *   This program is free software; you can redistribute it and/or modify      *
  19  *   it under the terms of the GNU General Public License as published by      *
  20  *   the Free Software Foundation; either version 2 of the License, or         *
  21  *   (at your option) any later version.                                       *
  22  *                                                                             *
  23  *   This program is distributed in the hope that it will be useful,           *
  24  *   but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  25  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  26  *   GNU General Public License for more details.                              *
  27  *                                                                             *
  28  *   You should have received a copy of the GNU General Public License         *
  29  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.     *
  30  ***************************************************************************/
  31
  32 /***************************************************************************
  33  * Version 1.0  Tested on a MCBSTM32 board using a Cortex-M3 (stm32f103x), *
  34  *              GDB and Eclipse under Linux (Ubuntu 10.04)                 *
  35  *                                                                         *
  36  ***************************************************************************/
  37
  38 #ifdef HAVE_CONFIG_H
  39 #include "config.h"
  40 #endif
  41
  42 #include <jtag/interface.h>
  43 #include <jtag/commands.h>
  44 #include "usb_common.h"
  45
  46 /*
  47  * OpenJTAG-OpenOCD state conversion
  48  */
  49 typedef enum openjtag_tap_state {
  50         OPENJTAG_TAP_INVALID    = -1,
  51         OPENJTAG_TAP_RESET  = 0,
  52         OPENJTAG_TAP_IDLE   = 1,
  53         OPENJTAG_TAP_SELECT_DR  = 2,
  54         OPENJTAG_TAP_CAPTURE_DR = 3,
  55         OPENJTAG_TAP_SHIFT_DR   = 4,
  56         OPENJTAG_TAP_EXIT1_DR   = 5,
  57         OPENJTAG_TAP_PAUSE_DR   = 6,
  58         OPENJTAG_TAP_EXIT2_DR   = 7,
  59         OPENJTAG_TAP_UPDATE_DR  = 8,
  60         OPENJTAG_TAP_SELECT_IR  = 9,
  61         OPENJTAG_TAP_CAPURE_IR  = 10,
  62         OPENJTAG_TAP_SHIFT_IR   = 11,
  63         OPENJTAG_TAP_EXIT1_IR   = 12,
  64         OPENJTAG_TAP_PAUSE_IR   = 13,
  65         OPENJTAG_TAP_EXIT2_IR   = 14,
  66         OPENJTAG_TAP_UPDATE_IR  = 15,
  67 } openjtag_tap_state_t;
  68
  69 #if (BUILD_OPENJTAG_FTD2XX == 1 && BUILD_OPENJTAG_LIBFTDI == 1)
  70 #error "BUILD_OPENJTAG_FTD2XX && BUILD_OPENJTAG_LIBFTDI "
  71            "are mutually exclusive"
  72 #elif (BUILD_OPENJTAG_FTD2XX != 1 && BUILD_OPENJTAG_LIBFTDI != 1)
  73 #error "BUILD_OPENJTAG_FTD2XX || BUILD_OPENJTAG_LIBFTDI must be chosen"
  74 #endif
  75
  76 /* OPENJTAG access library includes */
  77 #if BUILD_OPENJTAG_FTD2XX == 1
  78 #include <ftd2xx.h>
  79 #elif BUILD_OPENJTAG_LIBFTDI == 1
  80 #include <ftdi.h>
  81 #endif
  82
  83 /* OpenJTAG vid/pid */
  84 static uint16_t openjtag_vid = 0x0403;
  85 static uint16_t openjtag_pid = 0x6001;
  86
  87 static char *openjtag_device_desc;
  88
  89 #if BUILD_OPENJTAG_FTD2XX == 1
  90 static FT_HANDLE ftdih;
  91
  92 #elif BUILD_OPENJTAG_LIBFTDI == 1
  93 static struct ftdi_context ftdic;
  94 #endif
  95
  96 #define OPENJTAG_BUFFER_SIZE        504
  97 #define OPENJTAG_MAX_PENDING_RESULTS    256
  98
  99 struct openjtag_scan_result {
 100         uint32_t bits;          /* Length in bits*/
 101         struct scan_command *command;   /* Corresponding scan command */
 102         uint8_t *buffer;
 103 };
 104
 105 /* USB RX/TX buffers */
 106 static int usb_tx_buf_offs;
 107 static uint8_t usb_tx_buf[OPENJTAG_BUFFER_SIZE];
 108 static uint32_t usb_rx_buf_len;
 109 static uint8_t usb_rx_buf[OPENJTAG_BUFFER_SIZE];
 110
 111 /* Pending readings */
 112 static struct openjtag_scan_result openjtag_scan_result_buffer[OPENJTAG_MAX_PENDING_RESULTS];
 113 static int openjtag_scan_result_count;
 114
 115 /* Openocd usb handler */
 116 struct openocd {
 117         struct usb_dev_handle *usb_handle;
 118 };
 119
 120 #ifdef _DEBUG_USB_COMMS_
 121
 122 #define DEBUG_TYPE_READ     0
 123 #define DEBUG_TYPE_WRITE    1
 124 #define DEBUG_TYPE_OCD_READ 2
 125 #define DEBUG_TYPE_BUFFER   3
 126
 127 #define LINE_LEN  16
 128 static void openjtag_debug_buffer(uint8_t *buffer, int length, uint8_t type)
 129 {
 130         char line[128];
 131         char s[4];
 132         int i;
 133         int j;
 134
 135         switch (type) {
 136                 case DEBUG_TYPE_READ:
 137                         sprintf(line, "USB READ %d bytes", length);
 138                         break;
 139                 case DEBUG_TYPE_WRITE:
 140                         sprintf(line, "USB WRITE %d bytes", length);
 141                         break;
 142                 case DEBUG_TYPE_OCD_READ:
 143                         sprintf(line, "TO OpenOCD %d bytes", length);
 144                         break;
 145                 case DEBUG_TYPE_BUFFER:
 146                         sprintf(line, "Buffer %d bytes", length);
 147                         break;
 148         }
 149
 150         LOG_DEBUG("%s", line);
 151
 152         for (i = 0; i < length; i += LINE_LEN) {
 153                 switch (type) {
 154                         case DEBUG_TYPE_READ:
 155                                 sprintf(line, "USB READ: %04x", i);
 156                                 break;
 157                         case DEBUG_TYPE_WRITE:
 158                                 sprintf(line, "USB WRITE: %04x", i);
 159                                 break;
 160                         case DEBUG_TYPE_OCD_READ:
 161                                 sprintf(line, "TO OpenOCD: %04x", i);
 162                                 break;
 163                         case DEBUG_TYPE_BUFFER:
 164                                 sprintf(line, "BUFFER: %04x", i);
 165                                 break;
 166                 }
 167
 168                 for (j = i; j < i + LINE_LEN && j < length; j++) {
 169                         sprintf(s, " %02x", buffer[j]);
 170                         strcat(line, s);
 171                 }
 172                 LOG_DEBUG("%s", line);
 173         }
 174
 175 }
 176
 177 #endif
 178
 179 static int8_t openjtag_get_tap_state(int8_t state)
 180 {
 181
 182         switch (state) {
 183                 case TAP_DREXIT2:   return OPENJTAG_TAP_EXIT2_DR;
 184                 case TAP_DREXIT1:   return OPENJTAG_TAP_EXIT1_DR;
 185                 case TAP_DRSHIFT:   return OPENJTAG_TAP_SHIFT_DR;
 186                 case TAP_DRPAUSE:   return OPENJTAG_TAP_PAUSE_DR;
 187                 case TAP_IRSELECT:  return OPENJTAG_TAP_SELECT_IR;
 188                 case TAP_DRUPDATE:  return OPENJTAG_TAP_UPDATE_DR;
 189                 case TAP_DRCAPTURE: return OPENJTAG_TAP_CAPTURE_DR;
 190                 case TAP_DRSELECT:  return OPENJTAG_TAP_SELECT_DR;
 191                 case TAP_IREXIT2:   return OPENJTAG_TAP_EXIT2_IR;
 192                 case TAP_IREXIT1:   return OPENJTAG_TAP_EXIT1_IR;
 193                 case TAP_IRSHIFT:   return OPENJTAG_TAP_SHIFT_IR;
 194                 case TAP_IRPAUSE:   return OPENJTAG_TAP_PAUSE_IR;
 195                 case TAP_IDLE:      return OPENJTAG_TAP_IDLE;
 196                 case TAP_IRUPDATE:  return OPENJTAG_TAP_UPDATE_IR;
 197                 case TAP_IRCAPTURE: return OPENJTAG_TAP_CAPURE_IR;
 198                 case TAP_RESET:     return OPENJTAG_TAP_RESET;
 199                 case TAP_INVALID:
 200                 default:            return OPENJTAG_TAP_INVALID;
 201         }
 202 }
 203
 204 static int openjtag_buf_write(
 205         uint8_t *buf, int size, uint32_t *bytes_written)
 206 {
 207 #if BUILD_OPENJTAG_FTD2XX == 1
 208         FT_STATUS status;
 209         DWORD dw_bytes_written;
 210
 211 #ifdef _DEBUG_USB_COMMS_
 212         openjtag_debug_buffer(buf, size, DEBUG_TYPE_WRITE);
 213 #endif
 214
 215         status = FT_Write(ftdih, buf, size, &dw_bytes_written);
 216         if (status != FT_OK) {
 217                 *bytes_written = dw_bytes_written;
 218                 LOG_ERROR("FT_Write returned: %u", status);
 219                 return ERROR_JTAG_DEVICE_ERROR;
 220         }
 221         *bytes_written = dw_bytes_written;
 222         return ERROR_OK;
 223 #elif BUILD_OPENJTAG_LIBFTDI == 1
 224         int retval;
 225 #ifdef _DEBUG_USB_COMMS_
 226         openjtag_debug_buffer(buf, size, DEBUG_TYPE_WRITE);
 227 #endif
 228
 229         retval = ftdi_write_data(&ftdic, buf, size);
 230         if (retval < 0) {
 231                 *bytes_written = 0;
 232                 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic));
 233                 return ERROR_JTAG_DEVICE_ERROR;
 234         }
 235
 236         *bytes_written += retval;
 237
 238         return ERROR_OK;
 239 #endif
 240 }
 241
 242 static int openjtag_buf_read(uint8_t *buf, uint32_t qty, uint32_t *bytes_read)
 243 {
 244
 245 #if BUILD_OPENJTAG_FTD2XX == 1
 246         DWORD dw_bytes_read;
 247         FT_STATUS status;
 248         int timeout = 50;
 249
 250         *bytes_read = 0;
 251         while (qty && (*bytes_read < qty) && timeout--) {
 252
 253                 status = FT_Read(ftdih, buf + *bytes_read,
 254                                 qty - *bytes_read, &dw_bytes_read);
 255                 if (status != FT_OK) {
 256                         *bytes_read = dw_bytes_read;
 257                         LOG_ERROR("FT_Read returned: %u", status);
 258                         return ERROR_JTAG_DEVICE_ERROR;
 259                 }
 260                 *bytes_read += dw_bytes_read;
 261         }
 262
 263 #ifdef _DEBUG_USB_COMMS_
 264         openjtag_debug_buffer(buf, *bytes_read, DEBUG_TYPE_READ);
 265 #endif
 266
 267         return ERROR_OK;
 268 #elif BUILD_OPENJTAG_LIBFTDI == 1
 269         int retval;
 270         int timeout = 5;
 271
 272         *bytes_read = 0;
 273
 274         while ((*bytes_read < qty) && timeout--) {
 275                 retval = ftdi_read_data(&ftdic, buf + *bytes_read,
 276                                 qty - *bytes_read);
 277                 if (retval < 0) {
 278                         *bytes_read = 0;
 279                         DEBUG_JTAG_IO("ftdi_read_data: %s",
 280                                         ftdi_get_error_string(&ftdic));
 281                         return ERROR_JTAG_DEVICE_ERROR;
 282                 }
 283                 *bytes_read += retval;
 284         }
 285
 286 #ifdef _DEBUG_USB_COMMS_
 287         openjtag_debug_buffer(buf, *bytes_read, DEBUG_TYPE_READ);
 288 #endif
 289
 290 #endif
 291         return ERROR_OK;
 292 }
 293
 294 static int openjtag_sendcommand(uint8_t cmd)
 295 {
 296         uint32_t written;
 297         return openjtag_buf_write(&cmd, 1, &written);
 298 }
 299
 300 static int openjtag_speed(int speed)
 301 {
 302         int clockcmd;
 303         switch (speed) {
 304                 case 48000:
 305                         clockcmd = 0x00;
 306                         break;
 307                 case 24000:
 308                         clockcmd = 0x20;
 309                         break;
 310                 case 12000:
 311                         clockcmd = 0x40;
 312                         break;
 313                 case 6000:
 314                         clockcmd = 0x60;
 315                         break;
 316                 case 3000:
 317                         clockcmd = 0x80;
 318                         break;
 319                 case 1500:
 320                         clockcmd = 0xA0;
 321                         break;
 322                 case 750:
 323                         clockcmd = 0xC0;
 324                         break;
 325                 case 375:
 326                         clockcmd = 0xE0;
 327                         break;
 328                 default:
 329                         clockcmd = 0xE0;
 330                         LOG_WARNING("adapter speed not recognized, reverting to 375 kHz");
 331                         break;
 332         }
 333         openjtag_sendcommand(clockcmd);
 334
 335         return ERROR_OK;
 336 }
 337
 338 static int openjtag_init(void)
 339 {
 340         uint8_t latency_timer;
 341
 342 #if BUILD_OPENJTAG_FTD2XX == 1
 343         FT_STATUS status;
 344 #endif
 345
 346 usb_tx_buf_offs = 0;
 347 usb_rx_buf_len = 0;
 348 openjtag_scan_result_count = 0;
 349
 350 #if BUILD_OPENJTAG_FTD2XX == 1
 351         LOG_DEBUG("'openjtag' interface using FTD2XX");
 352 #elif BUILD_OPENJTAG_LIBFTDI == 1
 353         LOG_DEBUG("'openjtag' interface using libftdi");
 354 #endif
 355
 356 /* Open by device description */
 357 if (openjtag_device_desc == NULL) {
 358         LOG_WARNING("no openjtag device description specified, "
 359                                 "using default 'Open JTAG Project'");
 360         openjtag_device_desc = "Open JTAG Project";
 361 }
 362
 363 #if BUILD_OPENJTAG_FTD2XX == 1
 364
 365 #if IS_WIN32 == 0
 366         /* Add non-standard Vid/Pid to the linux driver */
 367         status = FT_SetVIDPID(openjtag_vid, openjtag_pid);
 368         if (status != FT_OK) {
 369                 LOG_WARNING("couldn't add %4.4x:%4.4x",
 370                         openjtag_vid, openjtag_pid);
 371         }
 372 #endif
 373
 374         status = FT_OpenEx(openjtag_device_desc, FT_OPEN_BY_DESCRIPTION,
 375                         &ftdih);
 376         if (status != FT_OK) {
 377                 DWORD num_devices;
 378
 379                 LOG_ERROR("unable to open ftdi device: %u", status);
 380                 status = FT_ListDevices(&num_devices, NULL,
 381                                 FT_LIST_NUMBER_ONLY);
 382                 if (status == FT_OK) {
 383                         char **desc_array = malloc(sizeof(char *)
 384                                                 * (num_devices + 1));
 385                         unsigned int i;
 386
 387                         for (i = 0; i < num_devices; i++)
 388                                 desc_array[i] = malloc(64);
 389                         desc_array[num_devices] = NULL;
 390
 391                         status = FT_ListDevices(desc_array, &num_devices,
 392                                 FT_LIST_ALL | FT_OPEN_BY_DESCRIPTION);
 393
 394                         if (status == FT_OK) {
 395                                 LOG_ERROR("ListDevices: %u\n", num_devices);
 396                                 for (i = 0; i < num_devices; i++)
 397                                         LOG_ERROR("%i: %s", i, desc_array[i]);
 398                         }
 399
 400                         for (i = 0; i < num_devices; i++)
 401                                 free(desc_array[i]);
 402                         free(desc_array);
 403                 } else {
 404                         LOG_ERROR("ListDevices: NONE\n");
 405                 }
 406                 return ERROR_JTAG_INIT_FAILED;
 407         }
 408
 409         status = FT_SetLatencyTimer(ftdih, 2);
 410         if (status != FT_OK) {
 411                 LOG_ERROR("unable to set latency timer: %u", status);
 412                 return ERROR_JTAG_INIT_FAILED;
 413         }
 414
 415         status = FT_GetLatencyTimer(ftdih, &latency_timer);
 416         if (status != FT_OK) {
 417                 LOG_ERROR("unable to get latency timer: %u", status);
 418                 return ERROR_JTAG_INIT_FAILED;
 419         }
 420         LOG_DEBUG("current latency timer: %i", latency_timer);
 421
 422         status = FT_SetBitMode(ftdih, 0x00, 0x40);
 423         if (status != FT_OK) {
 424                 LOG_ERROR("unable to disable bit i/o mode: %u", status);
 425                 return ERROR_JTAG_INIT_FAILED;
 426         }
 427
 428         status = FT_SetTimeouts(ftdih, 50, 0);
 429         if (status != FT_OK) {
 430                 LOG_ERROR("unable to set timeouts: %u", status);
 431                 return ERROR_JTAG_INIT_FAILED;
 432         }
 433
 434         status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX);
 435         if (status != FT_OK) {
 436                 LOG_ERROR("unable to FT_Purge() %u", status);
 437                 return ERROR_JTAG_INIT_FAILED;
 438         }
 439
 440 #elif BUILD_OPENJTAG_LIBFTDI == 1
 441         if (ftdi_init(&ftdic) < 0)
 442                 return ERROR_JTAG_INIT_FAILED;
 443
 444         /* context, vendor id, product id, description, serial id */
 445         if (ftdi_usb_open_desc(&ftdic, openjtag_vid, openjtag_pid, openjtag_device_desc, NULL) < 0) {
 446                 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
 447                 return ERROR_JTAG_INIT_FAILED;
 448         }
 449
 450         if (ftdi_usb_reset(&ftdic) < 0) {
 451                 LOG_ERROR("unable to reset ftdi device");
 452                 return ERROR_JTAG_INIT_FAILED;
 453         }
 454
 455         if (ftdi_set_latency_timer(&ftdic, 2) < 0) {
 456                 LOG_ERROR("unable to set latency timer");
 457                 return ERROR_JTAG_INIT_FAILED;
 458         }
 459
 460         if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0) {
 461                 LOG_ERROR("unable to get latency timer");
 462                 return ERROR_JTAG_INIT_FAILED;
 463         }
 464         LOG_DEBUG("current latency timer: %u", latency_timer);
 465
 466         ftdi_disable_bitbang(&ftdic);
 467         /* was (3000000 / 4) with a comment about a bug in libftdi when using high baudrate */
 468         if (ftdi_set_baudrate(&ftdic, 3000000) < 0) {
 469                 LOG_ERROR("Can't set baud rate to max: %s",
 470                         ftdi_get_error_string(&ftdic));
 471                 return ERROR_JTAG_DEVICE_ERROR;
 472         }
 473 #endif
 474
 475 #if BUILD_OPENJTAG_FTD2XX == 1
 476         status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX);
 477         if (status != FT_OK)
 478                 return ERROR_JTAG_INIT_FAILED;
 479 #elif BUILD_OPENJTAG_LIBFTDI == 1
 480         if (ftdi_usb_purge_buffers(&ftdic) < 0) {
 481                 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
 482                 return ERROR_JTAG_INIT_FAILED;
 483         }
 484 #endif
 485
 486         /* OpenJTAG speed */
 487         openjtag_sendcommand(0xE0); /*Start at slowest adapter speed*/
 488
 489         /* MSB */
 490         openjtag_sendcommand(0x75);
 491
 492         return ERROR_OK;
 493 }
 494
 495 static int openjtag_quit(void)
 496 {
 497 #if BUILD_OPENJTAG_FTD2XX == 1
 498         FT_Close(ftdih);
 499 #elif BUILD_OPENJTAG_LIBFTDI == 1
 500         ftdi_usb_close(&ftdic);
 501         ftdi_deinit(&ftdic);
 502 #endif
 503
 504         return ERROR_OK;
 505 }
 506
 507 static void openjtag_write_tap_buffer(void)
 508 {
 509         uint32_t written;
 510
 511         openjtag_buf_write(usb_tx_buf, usb_tx_buf_offs, &written);
 512         openjtag_buf_read(usb_rx_buf, usb_tx_buf_offs, &usb_rx_buf_len);
 513
 514         usb_tx_buf_offs = 0;
 515 }
 516
 517 static int openjtag_execute_tap_queue(void)
 518 {
 519         openjtag_write_tap_buffer();
 520
 521         int res_count = 0;
 522
 523         if (openjtag_scan_result_count && usb_rx_buf_len) {
 524
 525                 int count;
 526                 int rx_offs = 0;
 527                 int len;
 528
 529                 /* for every pending result */
 530                 while (res_count < openjtag_scan_result_count) {
 531
 532                         /* get sent bits */
 533                         len = openjtag_scan_result_buffer[res_count].bits;
 534
 535                         count = 0;
 536
 537                         uint8_t *buffer = openjtag_scan_result_buffer[res_count].buffer;
 538
 539                         while (len) {
 540                                 if (len <= 8) {
 541                                         DEBUG_JTAG_IO("bits < 8 buf = 0x%X, will be 0x%X",
 542                                                 usb_rx_buf[rx_offs], usb_rx_buf[rx_offs] >> (8 - len));
 543                                         buffer[count] = usb_rx_buf[rx_offs] >> (8 - len);
 544                                         len = 0;
 545                                 } else {
 546                                         buffer[count] = usb_rx_buf[rx_offs];
 547                                         len -= 8;
 548                                 }
 549
 550                                 rx_offs++;
 551                                 count++;
 552                         }
 553
 554 #ifdef _DEBUG_USB_COMMS_
 555                         openjtag_debug_buffer(buffer,
 556                                 DIV_ROUND_UP(openjtag_scan_result_buffer[res_count].bits, 8), DEBUG_TYPE_OCD_READ);
 557 #endif
 558                         jtag_read_buffer(buffer, openjtag_scan_result_buffer[res_count].command);
 559
 560                         if (openjtag_scan_result_buffer[res_count].buffer)
 561                                 free(openjtag_scan_result_buffer[res_count].buffer);
 562
 563                         res_count++;
 564                 }
 565         }
 566
 567         openjtag_scan_result_count = 0;
 568
 569         return ERROR_OK;
 570 }
 571
 572 static void openjtag_add_byte(char buf)
 573 {
 574
 575         if (usb_tx_buf_offs == OPENJTAG_BUFFER_SIZE) {
 576                 DEBUG_JTAG_IO("Forcing execute_tap_queue");
 577                 DEBUG_JTAG_IO("TX Buff offs=%d", usb_tx_buf_offs);
 578                 openjtag_execute_tap_queue();
 579         }
 580
 581         usb_tx_buf[usb_tx_buf_offs] = buf;
 582         usb_tx_buf_offs++;
 583 }
 584
 585 static void openjtag_add_scan(uint8_t *buffer, int length, struct scan_command *scan_cmd)
 586 {
 587
 588         /* Ensure space to send long chains */
 589         /* We add two byte for each eight (or less) bits, one for command, one for data */
 590         if (usb_tx_buf_offs + (DIV_ROUND_UP(length, 8) * 2) >= OPENJTAG_BUFFER_SIZE) {
 591                 DEBUG_JTAG_IO("Forcing execute_tap_queue from scan");
 592                 DEBUG_JTAG_IO("TX Buff offs=%d len=%d", usb_tx_buf_offs, DIV_ROUND_UP(length, 8) * 2);
 593                 openjtag_execute_tap_queue();
 594         }
 595
 596         openjtag_scan_result_buffer[openjtag_scan_result_count].bits = length;
 597         openjtag_scan_result_buffer[openjtag_scan_result_count].command = scan_cmd;
 598         openjtag_scan_result_buffer[openjtag_scan_result_count].buffer = buffer;
 599
 600         uint8_t command;
 601         uint8_t bits;
 602         int count = 0;
 603         while (length) {
 604
 605                 /* write command */
 606                 command = 6;
 607
 608                 /* last bits? */
 609                 if (length <= 8) {
 610                         /* tms high */
 611                         command |= (1 << 4);
 612
 613                         /* bits to transfer */
 614                         bits = (length - 1);
 615                         command |= bits << 5;
 616                         length = 0;
 617                 } else {
 618                         /* whole byte */
 619
 620                         /* bits to transfer */
 621                         bits = 7;
 622                         command |= (7 << 5);
 623                         length -= 8;
 624                 }
 625
 626                 openjtag_add_byte(command);
 627                 openjtag_add_byte(buffer[count]);
 628                 count++;
 629         }
 630
 631         openjtag_scan_result_count++;
 632 }
 633
 634 static void openjtag_execute_reset(struct jtag_command *cmd)
 635 {
 636
 637         DEBUG_JTAG_IO("reset trst: %i srst %i",
 638                         cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 639
 640         uint8_t buf = 0x00;
 641
 642         if (cmd->cmd.reset->trst) {
 643                 buf = 0x03;
 644         } else {
 645                 buf |= 0x04;
 646                 buf |= 0x05 << 4;
 647         }
 648
 649         openjtag_add_byte(buf);
 650 }
 651
 652 static void openjtag_execute_sleep(struct jtag_command *cmd)
 653 {
 654         jtag_sleep(cmd->cmd.sleep->us);
 655 }
 656
 657 static void openjtag_set_state(uint8_t openocd_state)
 658 {
 659         int8_t state = openjtag_get_tap_state(openocd_state);
 660
 661         uint8_t buf = 0;
 662         buf = 0x01;
 663         buf |= state << 4;
 664
 665         openjtag_add_byte(buf);
 666 }
 667
 668 static void openjtag_execute_statemove(struct jtag_command *cmd)
 669 {
 670         DEBUG_JTAG_IO("state move to %i", cmd->cmd.statemove->end_state);
 671
 672         tap_set_end_state(cmd->cmd.statemove->end_state);
 673
 674         openjtag_set_state(cmd->cmd.statemove->end_state);
 675
 676         tap_set_state(tap_get_end_state());
 677 }
 678
 679
 680 static void openjtag_execute_scan(struct jtag_command *cmd)
 681 {
 682
 683         int scan_size, old_state;
 684         uint8_t *buffer;
 685
 686         DEBUG_JTAG_IO("scan ends in %s", tap_state_name(cmd->cmd.scan->end_state));
 687
 688         /* get scan info */
 689         tap_set_end_state(cmd->cmd.scan->end_state);
 690         scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
 691
 692 #ifdef _DEBUG_USB_COMMS_
 693         openjtag_debug_buffer(buffer, (scan_size + 7) / 8, DEBUG_TYPE_BUFFER);
 694 #endif
 695         /* set state */
 696         old_state = tap_get_end_state();
 697         openjtag_set_state(cmd->cmd.scan->ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
 698         tap_set_state(cmd->cmd.scan->ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
 699         tap_set_end_state(old_state);
 700
 701         openjtag_add_scan(buffer, scan_size, cmd->cmd.scan);
 702
 703         openjtag_set_state(cmd->cmd.scan->ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
 704         tap_set_state(cmd->cmd.scan->ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
 705
 706         if (tap_get_state() != tap_get_end_state()) {
 707                 openjtag_set_state(tap_get_end_state());
 708                 tap_set_state(tap_get_end_state());
 709         }
 710 }
 711
 712 static void openjtag_execute_runtest(struct jtag_command *cmd)
 713 {
 714
 715         tap_state_t end_state = cmd->cmd.runtest->end_state;
 716         tap_set_end_state(end_state);
 717
 718         /* only do a state_move when we're not already in IDLE */
 719         if (tap_get_state() != TAP_IDLE) {
 720                 openjtag_set_state(TAP_IDLE);
 721                 tap_set_state(TAP_IDLE);
 722         }
 723
 724         if (cmd->cmd.runtest->num_cycles > 16)
 725                 LOG_WARNING("num_cycles > 16 on run test");
 726
 727         uint8_t command;
 728         command = 7;
 729         command |= ((cmd->cmd.runtest->num_cycles - 1) & 0x0F) << 4;
 730
 731         openjtag_add_byte(command);
 732
 733         tap_set_end_state(end_state);
 734         if (tap_get_end_state() != tap_get_state()) {
 735                 openjtag_set_state(end_state);
 736                 tap_set_state(end_state);
 737         }
 738 }
 739
 740 static void openjtag_execute_command(struct jtag_command *cmd)
 741 {
 742         DEBUG_JTAG_IO("openjtag_execute_command %i", cmd->type);
 743         switch (cmd->type) {
 744         case JTAG_RESET:
 745                         openjtag_execute_reset(cmd);
 746                         break;
 747         case JTAG_SLEEP:
 748                         openjtag_execute_sleep(cmd);
 749                         break;
 750         case JTAG_TLR_RESET:
 751                         openjtag_execute_statemove(cmd);
 752                         break;
 753         case JTAG_SCAN:
 754                         openjtag_execute_scan(cmd);
 755                         break;
 756         case JTAG_RUNTEST:
 757                         openjtag_execute_runtest(cmd);
 758                         break;
 759         case JTAG_PATHMOVE:
 760                 /* jlink_execute_pathmove(cmd); break; */
 761         default:
 762                 LOG_ERROR("BUG: unknown Open JTAG command type encountered");
 763                 exit(-1);
 764         }
 765 }
 766
 767 static int openjtag_execute_queue(void)
 768 {
 769         struct jtag_command *cmd = jtag_command_queue;
 770
 771         while (cmd != NULL) {
 772                 openjtag_execute_command(cmd);
 773                 cmd = cmd->next;
 774         }
 775
 776         return openjtag_execute_tap_queue();
 777 }
 778
 779 static int openjtag_speed_div(int speed, int *khz)
 780 {
 781         *khz = speed;
 782
 783         return ERROR_OK;
 784 }
 785
 786 static int openjtag_khz(int khz, int *jtag_speed)
 787 {
 788
 789         if (khz >= 48000)
 790                 *jtag_speed = 48000;
 791         else if (khz >= 24000)
 792                 *jtag_speed = 24000;
 793         else if (khz >= 12000)
 794                 *jtag_speed = 12000;
 795         else if (khz >= 6000)
 796                 *jtag_speed = 6000;
 797         else if (khz >= 3000)
 798                 *jtag_speed = 3000;
 799         else if (khz >= 1500)
 800                 *jtag_speed = 1500;
 801         else if (khz >= 750)
 802                 *jtag_speed = 750;
 803         else
 804                 *jtag_speed = 375;
 805
 806         return ERROR_OK;
 807 }
 808
 809 COMMAND_HANDLER(openjtag_handle_device_desc_command)
 810 {
 811         if (CMD_ARGC == 1)
 812                 openjtag_device_desc = strdup(CMD_ARGV[0]);
 813         else
 814                 LOG_ERROR("require exactly one argument to "
 815                                   "openjtag_device_desc <description>");
 816         return ERROR_OK;
 817 }
 818
 819
 820 static const struct command_registration openjtag_command_handlers[] = {
 821         {
 822                 .name = "openjtag_device_desc",
 823                 .handler = openjtag_handle_device_desc_command,
 824                 .mode = COMMAND_CONFIG,
 825                 .help = "set the USB device description of the OpenJTAG",
 826                 .usage = "description-string",
 827         },
 828         COMMAND_REGISTRATION_DONE
 829 };
 830
 831 struct jtag_interface openjtag_interface = {
 832         .name = "openjtag",
 833         .commands = openjtag_command_handlers,
 834
 835         .execute_queue = openjtag_execute_queue,
 836         .speed = openjtag_speed,
 837         .speed_div = openjtag_speed_div,
 838         .khz = openjtag_khz,
 839         .init = openjtag_init,
 840         .quit = openjtag_quit,
 841 };
 842
 843