git.sur5r.net Git - openocd/blob - src/jtag/usbprog.c

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