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

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