src/jtag/drivers/usbprog.c

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Benedikt Sauter                                 *
   3  *   sauter@ixbat.de                                                       *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 /*
  22  * This file is based on Dominic Rath's amt_jtagaccel.c.
  23  *
  24  * usbprog is a free programming adapter. You can easily install
  25  * different firmware versions from an "online pool" over USB.
  26  * The adapter can be used for programming and debugging AVR and ARM
  27  * processors, as USB to RS232 converter, as JTAG interface or as
  28  * simple I/O interface (5 lines).
  29  *
  30  * http://www.embedded-projects.net/usbprog
  31  */
  32
  33 #ifdef HAVE_CONFIG_H
  34 #include "config.h"
  35 #endif
  36
  37 #include <jtag/interface.h>
  38 #include <jtag/commands.h>
  39 #include "usb_common.h"
  40
  41
  42 #define VID 0x1781
  43 #define PID 0x0c63
  44
  45 /* Pins at usbprog */
  46 #define TDO_BIT                 0
  47 #define TDI_BIT                 3
  48 #define TCK_BIT                 2
  49 #define TMS_BIT                 1
  50
  51 static void usbprog_end_state(tap_state_t state);
  52 static void usbprog_state_move(void);
  53 static void usbprog_path_move(struct pathmove_command *cmd);
  54 static void usbprog_runtest(int num_cycles);
  55 static void usbprog_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size);
  56
  57 #define UNKNOWN_COMMAND 0x00
  58 #define PORT_DIRECTION  0x01
  59 #define PORT_SET                0x02
  60 #define PORT_GET                0x03
  61 #define PORT_SETBIT             0x04
  62 #define PORT_GETBIT             0x05
  63 #define WRITE_TDI               0x06
  64 #define READ_TDO                0x07
  65 #define WRITE_AND_READ  0x08
  66 #define WRITE_TMS               0x09
  67 #define WRITE_TMS_CHAIN 0x0A
  68
  69 struct usbprog_jtag
  70 {
  71         struct usb_dev_handle* usb_handle;
  72 };
  73
  74 static struct usbprog_jtag * usbprog_jtag_handle;
  75
  76 static struct usbprog_jtag* usbprog_jtag_open(void);
  77 //static void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag);
  78 static void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag);
  79 static unsigned char usbprog_jtag_message(struct usbprog_jtag *usbprog_jtag, char *msg, int msglen);
  80
  81 static void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
  82 static void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
  83 static void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
  84 static void usbprog_jtag_write_tms(struct usbprog_jtag *usbprog_jtag, char tms_scan);
  85
  86 static char tms_chain[64];
  87 static int tms_chain_index;
  88
  89 static void usbprog_jtag_tms_collect(char tms_scan);
  90 static void usbprog_jtag_tms_send(struct usbprog_jtag *usbprog_jtag);
  91
  92 static void usbprog_write(int tck, int tms, int tdi);
  93 static void usbprog_reset(int trst, int srst);
  94
  95 static void usbprog_jtag_set_direction(struct usbprog_jtag *usbprog_jtag, unsigned char direction);
  96 static void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char value);
  97 //static unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag);
  98 static void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag,int bit, int value);
  99 //static int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit);
 100
 101 static int usbprog_speed(int speed)
 102 {
 103         return ERROR_OK;
 104 }
 105
 106 static int usbprog_execute_queue(void)
 107 {
 108         struct jtag_command *cmd = jtag_command_queue; /* currently processed command */
 109         int scan_size;
 110         enum scan_type type;
 111         uint8_t *buffer;
 112
 113         while (cmd)
 114         {
 115                 switch (cmd->type)
 116                 {
 117                         case JTAG_RESET:
 118 #ifdef _DEBUG_JTAG_IO_
 119                                 LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 120 #endif
 121                                 if (cmd->cmd.reset->trst == 1)
 122                                 {
 123                                         tap_set_state(TAP_RESET);
 124                                 }
 125                                 usbprog_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 126                                 break;
 127                         case JTAG_RUNTEST:
 128 #ifdef _DEBUG_JTAG_IO_
 129                                 LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
 130 #endif
 131                                 usbprog_end_state(cmd->cmd.runtest->end_state);
 132                                 usbprog_runtest(cmd->cmd.runtest->num_cycles);
 133                                 break;
 134                         case JTAG_TLR_RESET:
 135 #ifdef _DEBUG_JTAG_IO_
 136                                 LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
 137 #endif
 138                                 usbprog_end_state(cmd->cmd.statemove->end_state);
 139                                 usbprog_state_move();
 140                                 break;
 141                         case JTAG_PATHMOVE:
 142 #ifdef _DEBUG_JTAG_IO_
 143                                 LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states,
 144                                         cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
 145 #endif
 146                                 usbprog_path_move(cmd->cmd.pathmove);
 147                                 break;
 148                         case JTAG_SCAN:
 149 #ifdef _DEBUG_JTAG_IO_
 150                                 LOG_DEBUG("scan end in %i", cmd->cmd.scan->end_state);
 151 #endif
 152                                 usbprog_end_state(cmd->cmd.scan->end_state);
 153                                 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
 154                                 type = jtag_scan_type(cmd->cmd.scan);
 155                                 usbprog_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
 156                                 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
 157                                         return ERROR_JTAG_QUEUE_FAILED;
 158                                 if (buffer)
 159                                         free(buffer);
 160                                 break;
 161                         case JTAG_SLEEP:
 162 #ifdef _DEBUG_JTAG_IO_
 163                                 LOG_DEBUG("sleep %i", cmd->cmd.sleep->us);
 164 #endif
 165                                 jtag_sleep(cmd->cmd.sleep->us);
 166                                         break;
 167                         default:
 168                                 LOG_ERROR("BUG: unknown JTAG command type encountered");
 169                                 exit(-1);
 170                 }
 171
 172                 cmd = cmd->next;
 173         }
 174
 175         return ERROR_OK;
 176 }
 177
 178 static int usbprog_init(void)
 179 {
 180         usbprog_jtag_handle = usbprog_jtag_open();
 181
 182         tms_chain_index = 0;
 183         if (usbprog_jtag_handle == 0)
 184         {
 185                 LOG_ERROR("Can't find USB JTAG Interface! Please check connection and permissions.");
 186                 return ERROR_JTAG_INIT_FAILED;
 187         }
 188
 189         LOG_INFO("USB JTAG Interface ready!");
 190
 191         usbprog_jtag_init(usbprog_jtag_handle);
 192         usbprog_reset(0, 0);
 193         usbprog_write(0, 0, 0);
 194
 195         return ERROR_OK;
 196 }
 197
 198 static int usbprog_quit(void)
 199 {
 200         return ERROR_OK;
 201 }
 202
 203 /*************** jtag execute commands **********************/
 204 static void usbprog_end_state(tap_state_t state)
 205 {
 206         if (tap_is_state_stable(state))
 207                 tap_set_end_state(state);
 208         else
 209         {
 210                 LOG_ERROR("BUG: %i is not a valid end state", state);
 211                 exit(-1);
 212         }
 213 }
 214
 215 static void usbprog_state_move(void)
 216 {
 217         uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
 218
 219         usbprog_jtag_write_tms(usbprog_jtag_handle, (char)tms_scan);
 220
 221         tap_set_state(tap_get_end_state());
 222 }
 223
 224 static void usbprog_path_move(struct pathmove_command *cmd)
 225 {
 226         int num_states = cmd->num_states;
 227         int state_count;
 228
 229         /* There may be queued transitions, and before following a specified
 230            path, we must flush those queued transitions */
 231         usbprog_jtag_tms_send(usbprog_jtag_handle);
 232
 233         state_count = 0;
 234         while (num_states)
 235         {
 236                 if (tap_state_transition(tap_get_state(), false) == cmd->path[state_count])
 237                 {
 238                         /* LOG_INFO("1"); */
 239                         usbprog_write(0, 0, 0);
 240                         usbprog_write(1, 0, 0);
 241                 }
 242                 else if (tap_state_transition(tap_get_state(), true) == cmd->path[state_count])
 243                 {
 244                         /* LOG_INFO("2"); */
 245                         usbprog_write(0, 1, 0);
 246                         usbprog_write(1, 1, 0);
 247                 }
 248                 else
 249                 {
 250                         LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd->path[state_count]));
 251                         exit(-1);
 252                 }
 253
 254                 tap_set_state(cmd->path[state_count]);
 255                 state_count++;
 256                 num_states--;
 257         }
 258
 259         tap_set_end_state(tap_get_state());
 260 }
 261
 262 static void usbprog_runtest(int num_cycles)
 263 {
 264         int i;
 265
 266         /* only do a state_move when we're not already in IDLE */
 267         if (tap_get_state() != TAP_IDLE)
 268         {
 269                 usbprog_end_state(TAP_IDLE);
 270                 usbprog_state_move();
 271         }
 272
 273         /* execute num_cycles */
 274         if (num_cycles > 0)
 275         {
 276                 usbprog_jtag_tms_send(usbprog_jtag_handle);
 277                 usbprog_write(0, 0, 0);
 278         }
 279         else
 280         {
 281                 usbprog_jtag_tms_send(usbprog_jtag_handle);
 282                 /* LOG_INFO("NUM CYCLES %i",num_cycles); */
 283         }
 284
 285         for (i = 0; i < num_cycles; i++)
 286         {
 287                 usbprog_write(1, 0, 0);
 288                 usbprog_write(0, 0, 0);
 289         }
 290
 291 #ifdef _DEBUG_JTAG_IO_
 292         LOG_DEBUG("runtest: cur_state %s end_state %s", tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state()));
 293 #endif
 294
 295         /* finish in end_state */
 296         /*
 297         usbprog_end_state(saved_end_state);
 298         if (tap_get_state() != tap_get_end_state())
 299                 usbprog_state_move();
 300         */
 301 }
 302
 303 static void usbprog_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size)
 304 {
 305         tap_state_t saved_end_state = tap_get_end_state();
 306
 307         if (ir_scan)
 308                 usbprog_end_state(TAP_IRSHIFT);
 309         else
 310                 usbprog_end_state(TAP_DRSHIFT);
 311
 312         /* Only move if we're not already there */
 313         if (tap_get_state() != tap_get_end_state())
 314                 usbprog_state_move();
 315
 316         usbprog_end_state(saved_end_state);
 317
 318         usbprog_jtag_tms_send(usbprog_jtag_handle);
 319
 320         void (*f)(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
 321         switch (type) {
 322         case SCAN_OUT: f = &usbprog_jtag_write_tdi; break;
 323         case SCAN_IN: f = &usbprog_jtag_read_tdo; break;
 324         case SCAN_IO: f = &usbprog_jtag_write_and_read; break;
 325         default:
 326                 LOG_ERROR("unknown scan type: %i", type);
 327                 exit(-1);
 328         }
 329         f(usbprog_jtag_handle, (char *)buffer, scan_size);
 330
 331         /* The adapter does the transition to PAUSE internally */
 332         if (ir_scan)
 333                 tap_set_state(TAP_IRPAUSE);
 334         else
 335                 tap_set_state(TAP_DRPAUSE);
 336
 337         if (tap_get_state() != tap_get_end_state())
 338                 usbprog_state_move();
 339 }
 340
 341 /*************** jtag wrapper functions *********************/
 342
 343 static void usbprog_write(int tck, int tms, int tdi)
 344 {
 345         unsigned char output_value = 0x00;
 346
 347         if (tms)
 348                 output_value |= (1 << TMS_BIT);
 349         if (tdi)
 350                 output_value |= (1 << TDI_BIT);
 351         if (tck)
 352                 output_value |= (1 << TCK_BIT);
 353
 354         usbprog_jtag_write_slice(usbprog_jtag_handle,output_value);
 355 }
 356
 357 /* (1) assert or (0) deassert reset lines */
 358 static void usbprog_reset(int trst, int srst)
 359 {
 360         LOG_DEBUG("trst: %i, srst: %i", trst, srst);
 361
 362         if (trst)
 363                 usbprog_jtag_set_bit(usbprog_jtag_handle, 5, 0);
 364         else
 365                 usbprog_jtag_set_bit(usbprog_jtag_handle, 5, 1);
 366
 367         if (srst)
 368                 usbprog_jtag_set_bit(usbprog_jtag_handle, 4, 0);
 369         else
 370                 usbprog_jtag_set_bit(usbprog_jtag_handle, 4, 1);
 371 }
 372
 373 /*************** jtag lowlevel functions ********************/
 374
 375 struct usb_bus *busses;
 376
 377 struct usbprog_jtag* usbprog_jtag_open(void)
 378 {
 379         usb_set_debug(10);
 380         usb_init();
 381
 382         const uint16_t vids[] = { VID, 0 };
 383         const uint16_t pids[] = { PID, 0 };
 384         struct usb_dev_handle *dev;
 385         if (jtag_usb_open(vids, pids, &dev) != ERROR_OK)
 386                 return NULL;
 387
 388         struct usbprog_jtag *tmp = malloc(sizeof(struct usbprog_jtag));
 389         tmp->usb_handle = dev;
 390
 391         usb_set_configuration(dev, 1);
 392         usb_claim_interface(dev, 0);
 393         usb_set_altinterface(dev, 0);
 394
 395         return tmp;
 396 }
 397
 398 #if 0
 399 static void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag)
 400 {
 401         usb_close(usbprog_jtag->usb_handle);
 402         free(usbprog_jtag);
 403 }
 404 #endif
 405
 406 static unsigned char usbprog_jtag_message(struct usbprog_jtag *usbprog_jtag, char *msg, int msglen)
 407 {
 408         int res = usb_bulk_write(usbprog_jtag->usb_handle, 3, msg,msglen, 100);
 409         if ((msg[0] == 2) || (msg[0] == 1) || (msg[0] == 4) || (msg[0] == 0) || \
 410                         (msg[0] == 6) || (msg[0] == 0x0A) || (msg[0] == 9))
 411                 return 1;
 412         if (res == msglen)
 413         {
 414                 /* LOG_INFO("HALLLLOOO %i",(int)msg[0]); */
 415                 res =  usb_bulk_read(usbprog_jtag->usb_handle, 0x82, msg, 2, 100);
 416                 if (res > 0)
 417                         return (unsigned char)msg[1];
 418                 else
 419                         return -1;
 420         }
 421         else
 422                 return -1;
 423         return 0;
 424 }
 425
 426 static void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag)
 427 {
 428         usbprog_jtag_set_direction(usbprog_jtag, 0xFE);
 429 }
 430
 431 static void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
 432 {
 433         char tmp[64];   /* fastes packet size for usb controller */
 434         int send_bits, bufindex = 0, fillindex = 0, i, loops;
 435
 436         char swap;
 437         /* 61 byte can be transfered (488 bit) */
 438
 439         while (size > 0)
 440         {
 441                 if (size > 488)
 442                 {
 443                         send_bits = 488;
 444                         size = size - 488;
 445                         loops = 61;
 446                 }
 447                 else
 448                 {
 449                         send_bits = size;
 450                         loops = size / 8;
 451                         loops++;
 452                         size = 0;
 453                 }
 454                 tmp[0] = WRITE_AND_READ;
 455                 tmp[1] = (char)(send_bits >> 8);        /* high */
 456                 tmp[2] = (char)(send_bits);                     /* low */
 457                 i = 0;
 458
 459                 for (i = 0; i < loops; i++)
 460                 {
 461                         tmp[3 + i] = buffer[bufindex];
 462                         bufindex++;
 463                 }
 464
 465                 if (usb_bulk_write(usbprog_jtag->usb_handle, 3, tmp, 64, 1000) == 64)
 466                 {
 467                         /* LOG_INFO("HALLLLOOO2 %i",(int)tmp[0]); */
 468                         usleep(1);
 469                         int timeout = 0;
 470                         while (usb_bulk_read(usbprog_jtag->usb_handle, 0x82, tmp, 64, 1000) < 1)
 471                         {
 472                                 timeout++;
 473                                 if (timeout > 10)
 474                                         break;
 475                         }
 476
 477                         for (i = 0; i < loops; i++)
 478                         {
 479                                 swap =  tmp[3 + i];
 480                                 buffer[fillindex++] = swap;
 481                         }
 482                 }
 483         }
 484 }
 485
 486 static void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
 487 {
 488         char tmp[64];   /* fastes packet size for usb controller */
 489         int send_bits, fillindex = 0, i, loops;
 490
 491         char swap;
 492         /* 61 byte can be transfered (488 bit) */
 493
 494         while (size > 0)
 495         {
 496                 if (size > 488)
 497                 {
 498                         send_bits = 488;
 499                         size = size - 488;
 500                         loops = 61;
 501                 }
 502                 else
 503                 {
 504                         send_bits = size;
 505                         loops = size / 8;
 506                         loops++;
 507                         size = 0;
 508                 }
 509                 tmp[0] = WRITE_AND_READ;
 510                 tmp[1] = (char)(send_bits >> 8);        /* high */
 511                 tmp[2] = (char)(send_bits);                     /* low */
 512
 513                 usb_bulk_write(usbprog_jtag->usb_handle, 3, tmp, 3, 1000);
 514
 515                 /* LOG_INFO("HALLLLOOO3 %i",(int)tmp[0]); */
 516                 int timeout = 0;
 517                 usleep(1);
 518                 while (usb_bulk_read(usbprog_jtag->usb_handle, 0x82, tmp, 64, 10) < 1)
 519                 {
 520                         timeout++;
 521                         if (timeout > 10)
 522                                 break;
 523                 }
 524
 525                 for (i = 0; i < loops; i++)
 526                 {
 527                         swap = tmp[3 + i];
 528                         buffer[fillindex++] = swap;
 529                 }
 530         }
 531 }
 532
 533 static void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
 534 {
 535         char tmp[64];   /* fastes packet size for usb controller */
 536         int send_bits, bufindex = 0, i, loops;
 537
 538         /* 61 byte can be transfered (488 bit) */
 539         while (size > 0)
 540         {
 541                 if (size > 488)
 542                 {
 543                         send_bits = 488;
 544                         size = size - 488;
 545                         loops = 61;
 546                 }
 547                 else
 548                 {
 549                         send_bits = size;
 550                         loops = size/8;
 551                         /* if (loops == 0) */
 552                         loops++;
 553                         size = 0;
 554                 }
 555                 tmp[0] = WRITE_TDI;
 556                 tmp[1] = (char)(send_bits >> 8);        /* high */
 557                 tmp[2] = (char)(send_bits);                     /* low */
 558                 i = 0;
 559
 560                 for (i = 0; i < loops; i++)
 561                 {
 562                         tmp[3 + i] = buffer[bufindex];
 563                         bufindex++;
 564                 }
 565                 usb_bulk_write(usbprog_jtag->usb_handle, 3, tmp, 64, 1000);
 566         }
 567 }
 568
 569 static void usbprog_jtag_write_tms(struct usbprog_jtag *usbprog_jtag, char tms_scan)
 570 {
 571         usbprog_jtag_tms_collect(tms_scan);
 572 }
 573
 574 static void usbprog_jtag_set_direction(struct usbprog_jtag *usbprog_jtag, unsigned char direction)
 575 {
 576         char tmp[2];
 577         tmp[0] = PORT_DIRECTION;
 578         tmp[1] = (char)direction;
 579         usbprog_jtag_message(usbprog_jtag, tmp, 2);
 580 }
 581
 582 static void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char value)
 583 {
 584         char tmp[2];
 585         tmp[0] = PORT_SET;
 586         tmp[1] = (char)value;
 587         usbprog_jtag_message(usbprog_jtag, tmp, 2);
 588 }
 589
 590 #if 0
 591 static unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag)
 592 {
 593         char tmp[2];
 594         tmp[0] = PORT_GET;
 595         tmp[1] = 0x00;
 596         return usbprog_jtag_message(usbprog_jtag, tmp, 2);
 597 }
 598 #endif
 599
 600 static void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag,int bit, int value)
 601 {
 602         char tmp[3];
 603         tmp[0] = PORT_SETBIT;
 604         tmp[1] = (char)bit;
 605         if (value == 1)
 606                 tmp[2] = 0x01;
 607         else
 608                 tmp[2] = 0x00;
 609         usbprog_jtag_message(usbprog_jtag, tmp, 3);
 610 }
 611
 612 #if 0
 613 static int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit)
 614 {
 615         char tmp[2];
 616         tmp[0] = PORT_GETBIT;
 617         tmp[1] = (char)bit;
 618
 619         if (usbprog_jtag_message(usbprog_jtag, tmp, 2) > 0)
 620                 return 1;
 621         else
 622                 return 0;
 623 }
 624 #endif
 625
 626 static void usbprog_jtag_tms_collect(char tms_scan)
 627 {
 628         tms_chain[tms_chain_index] = tms_scan;
 629         tms_chain_index++;
 630 }
 631
 632 static void usbprog_jtag_tms_send(struct usbprog_jtag *usbprog_jtag)
 633 {
 634         int i;
 635         /* LOG_INFO("TMS SEND"); */
 636         if (tms_chain_index > 0)
 637         {
 638                 char tmp[tms_chain_index + 2];
 639                 tmp[0] = WRITE_TMS_CHAIN;
 640                 tmp[1] = (char)(tms_chain_index);
 641                 for (i = 0; i < tms_chain_index + 1; i++)
 642                         tmp[2 + i] = tms_chain[i];
 643                 usb_bulk_write(usbprog_jtag->usb_handle, 3, tmp, tms_chain_index + 2, 1000);
 644                 tms_chain_index = 0;
 645         }
 646 }
 647
 648 struct jtag_interface usbprog_interface = {
 649         .name = "usbprog",
 650
 651         .execute_queue = usbprog_execute_queue,
 652         .speed = usbprog_speed,
 653         .init = usbprog_init,
 654         .quit = usbprog_quit
 655 };