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