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