git.sur5r.net Git - 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 0x0c62
  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         /*
 305         enum tap_state saved_end_state = end_state;
 306         */
 307
 308         /* only do a state_move when we're not already in RTI */
 309         if (cur_state != TAP_RTI)
 310         {
 311                 usbprog_end_state(TAP_RTI);
 312                 usbprog_state_move();
 313         }
 314
 315         /* execute num_cycles */
 316         if(num_cycles>0)
 317         {
 318                 usbprog_write(0, 0, 0);
 319         }
 320         else {
 321                 usbprog_jtag_tms_send(usbprog_jtag_handle);
 322         }
 323
 324         for (i = 0; i < num_cycles; i++)
 325         {
 326                 usbprog_write(1, 0, 0);
 327                 usbprog_write(0, 0, 0);
 328         }
 329
 330         /* finish in end_state */
 331         /*
 332         usbprog_end_state(saved_end_state);
 333         if (cur_state != end_state)
 334                 usbprog_state_move();
 335          */
 336 }
 337
 338
 339
 340 void usbprog_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
 341 {
 342         enum tap_state saved_end_state = end_state;
 343
 344         if (ir_scan)
 345                 usbprog_end_state(TAP_SI);
 346         else
 347                 usbprog_end_state(TAP_SD);
 348
 349         usbprog_state_move();
 350         usbprog_end_state(saved_end_state);
 351
 352         usbprog_jtag_tms_send(usbprog_jtag_handle);
 353
 354         if (type == SCAN_OUT) {
 355                 usbprog_jtag_write_tdi(usbprog_jtag_handle, (char*)buffer, scan_size);
 356         }
 357         if (type == SCAN_IN) {
 358                 usbprog_jtag_read_tdo(usbprog_jtag_handle, (char*)buffer, scan_size);
 359         }
 360         if (type == SCAN_IO) {
 361                 usbprog_jtag_write_and_read(usbprog_jtag_handle, (char*)buffer, scan_size);
 362         }
 363
 364         if (ir_scan)
 365                 cur_state = TAP_PI;
 366         else
 367                 cur_state = TAP_PD;
 368
 369         if (cur_state != end_state)
 370                 usbprog_state_move();
 371 }
 372
 373 /*************** jtag wrapper functions *********************/
 374
 375 void usbprog_write(int tck, int tms, int tdi)
 376 {
 377         unsigned char output_value=0x00;
 378
 379         if (tms)
 380                 output_value |= (1<<TMS_BIT);
 381         if (tdi)
 382                 output_value |= (1<<TDI_BIT);
 383         if (tck)
 384                 output_value |= (1<<TCK_BIT);
 385
 386         usbprog_jtag_write_slice(usbprog_jtag_handle,output_value);
 387 }
 388
 389 /* (1) assert or (0) deassert reset lines */
 390 void usbprog_reset(int trst, int srst)
 391 {
 392         DEBUG("trst: %i, srst: %i", trst, srst);
 393
 394         if(trst)
 395                 usbprog_jtag_set_bit(usbprog_jtag_handle,5,0);
 396         else
 397                 usbprog_jtag_set_bit(usbprog_jtag_handle,5,1);
 398
 399         if(srst)
 400                 usbprog_jtag_set_bit(usbprog_jtag_handle,4,0);
 401         else
 402                 usbprog_jtag_set_bit(usbprog_jtag_handle,4,1);
 403 }
 404
 405
 406
 407 /*************** jtag lowlevel functions ********************/
 408
 409
 410 struct usbprog_jtag* usbprog_jtag_open()
 411 {
 412         struct usb_bus *busses;
 413         struct usb_bus *bus;
 414         struct usb_device *dev;
 415
 416         struct usbprog_jtag * tmp;
 417
 418         tmp = (struct usbprog_jtag*)malloc(sizeof(struct usbprog_jtag));
 419
 420
 421         usb_init();
 422         usb_find_busses();
 423         usb_find_devices();
 424
 425         busses = usb_get_busses();
 426
 427         /* find usbprog_jtag device in usb bus */
 428
 429         for (bus = busses; bus; bus = bus->next){
 430                 for (dev = bus->devices; dev; dev = dev->next){
 431                         /* condition for sucessfully hit (too bad, I only check the vendor id)*/
 432                         if (dev->descriptor.idVendor == VID && dev->descriptor.idProduct == PID) {
 433                                 tmp->usb_handle = usb_open(dev);
 434                                 usb_set_configuration (tmp->usb_handle,dev->config[0].bConfigurationValue);
 435                                 usb_claim_interface(tmp->usb_handle, 0);
 436                                 usb_set_altinterface(tmp->usb_handle,0);
 437                                 return tmp;
 438                         }
 439                 }
 440         }
 441         return 0;
 442 }
 443
 444
 445 void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag)
 446 {
 447         usb_close(usbprog_jtag->usb_handle);
 448         free(usbprog_jtag);
 449 }
 450
 451
 452 unsigned char usbprog_jtag_message(struct usbprog_jtag *usbprog_jtag, char *msg, int msglen)
 453 {
 454         int res = usb_bulk_write(usbprog_jtag->usb_handle,3,msg,msglen,100);
 455         if(msg[0]==2)
 456                 return 1;
 457         if(res == msglen) {
 458                 res =  usb_bulk_read(usbprog_jtag->usb_handle,0x82, msg, 2, 100);
 459                 if (res > 0)
 460                         return (unsigned char)msg[1];
 461                 else
 462                         return -1;
 463         }
 464         else
 465                 return -1;
 466         return 0;
 467 }
 468
 469 void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag)
 470 {
 471         usbprog_jtag_set_direction(usbprog_jtag, 0xFE);
 472 }
 473
 474
 475 void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
 476 {
 477         char tmp[64];   // fastes packet size for usb controller
 478         int send_bits, bufindex = 0, fillindex = 0, i, loops;
 479
 480         char swap;
 481         // 61 byte can be transfered (488 bit)
 482
 483         while(size > 0) {
 484                 if(size > 488) {
 485                         send_bits = 488;
 486                         size = size - 488;
 487                         loops = 61;
 488                 } else {
 489                         send_bits = size;
 490                         loops = size/8;
 491                         loops++;
 492                         size = 0;
 493                 }
 494                 tmp[0] = WRITE_AND_READ;
 495                 tmp[1] = (char)(send_bits>>8); // high
 496                 tmp[2] = (char)(send_bits);    // low
 497                 i=0;
 498
 499                 for(i=0;i < loops ;i++) {
 500                         tmp[3+i]=buffer[bufindex];
 501                         bufindex++;
 502                 }
 503
 504                 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,64,1000);
 505
 506                 while(usb_bulk_read(usbprog_jtag->usb_handle,0x82, tmp, 64, 1000) < 1);
 507
 508                 for(i=0;i<loops ;i++) {
 509                         swap =  tmp[3+i];
 510                         buffer[fillindex++] = swap;
 511                 }
 512         }
 513 }
 514
 515
 516 void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
 517 {
 518         char tmp[64];   // fastes packet size for usb controller
 519         int send_bits, fillindex = 0, i, loops;
 520
 521         char swap;
 522         // 61 byte can be transfered (488 bit)
 523
 524         while(size > 0) {
 525                 if(size > 488) {
 526                         send_bits = 488;
 527                         size = size - 488;
 528                         loops = 61;
 529                 } else {
 530                         send_bits = size;
 531                         loops = size/8;
 532                         loops++;
 533                         size = 0;
 534                 }
 535                 tmp[0] = WRITE_AND_READ;
 536                 tmp[1] = (char)(send_bits>>8); // high
 537                 tmp[2] = (char)(send_bits);    // low
 538
 539                 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,3,1000);
 540
 541                 while(usb_bulk_read(usbprog_jtag->usb_handle,0x82, tmp, 64, 10) < 1);
 542
 543                 for(i=0;i<loops ;i++) {
 544                         swap =  tmp[3+i];
 545                         buffer[fillindex++] = swap;
 546                 }
 547         }
 548 }
 549
 550 void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
 551 {
 552         char tmp[64];   /* fastes packet size for usb controller */
 553         int send_bits, bufindex = 0, i, loops;
 554
 555         /* 61 byte can be transfered (488 bit) */
 556         while(size > 0) {
 557                 if(size > 488) {
 558                         send_bits = 488;
 559                         size = size - 488;
 560                         loops = 61;
 561                 } else {
 562                         send_bits = size;
 563                         loops = size/8;
 564                         /*if(loops==0)*/
 565                         loops++;
 566                         size = 0;
 567                 }
 568                 tmp[0] = WRITE_TDI;
 569                 tmp[1] = (char)(send_bits>>8); /* high */
 570                 tmp[2] = (char)(send_bits);    /* low */
 571                 i=0;
 572
 573                 for(i=0;i < loops ;i++) {
 574                         tmp[3+i]=buffer[bufindex];
 575                         bufindex++;
 576                 }
 577                 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,64,1000);
 578         }
 579 }
 580
 581
 582 void usbprog_jtag_write_tms(struct usbprog_jtag *usbprog_jtag, char tms_scan)
 583 {
 584         usbprog_jtag_tms_collect(tms_scan);
 585 }
 586
 587
 588 void usbprog_jtag_set_direction(struct usbprog_jtag *usbprog_jtag, unsigned char direction)
 589 {
 590         char tmp[2];
 591         tmp[0] = PORT_DIRECTION;
 592         tmp[1] = (char)direction;
 593         usbprog_jtag_message(usbprog_jtag,tmp,2);
 594 }
 595
 596 void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char value)
 597 {
 598         char tmp[2];
 599         tmp[0] = PORT_SET;
 600         tmp[1] = (char)value;
 601         usbprog_jtag_message(usbprog_jtag,tmp,2);
 602 }
 603
 604 unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag)
 605 {
 606         char tmp[2];
 607         tmp[0] = PORT_GET;
 608         tmp[1] = 0x00;
 609         return usbprog_jtag_message(usbprog_jtag,tmp,2);
 610 }
 611
 612
 613 void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag,int bit, int value)
 614 {
 615         char tmp[3];
 616         tmp[0] = PORT_SETBIT;
 617         tmp[1] = (char)bit;
 618         if(value==1)
 619                 tmp[2] = 0x01;
 620         else
 621                 tmp[2] = 0x00;
 622         usbprog_jtag_message(usbprog_jtag,tmp,3);
 623 }
 624
 625 int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit)
 626 {
 627         char tmp[2];
 628         tmp[0] = PORT_GETBIT;
 629         tmp[1] = (char)bit;
 630
 631         if(usbprog_jtag_message(usbprog_jtag,tmp,2)>0)
 632                 return 1;
 633         else
 634                 return 0;
 635 }
 636
 637 void usbprog_jtag_tms_collect(char tms_scan){
 638         tms_chain[tms_chain_index]=tms_scan;
 639         tms_chain_index++;
 640 }
 641
 642 void usbprog_jtag_tms_send(struct usbprog_jtag *usbprog_jtag){
 643         int i;
 644         if(tms_chain_index>0) {
 645                 char tmp[tms_chain_index+2];
 646                 tmp[0] = WRITE_TMS_CHAIN;
 647                 tmp[1] = (char)(tms_chain_index);
 648                 for(i=0;i<tms_chain_index+1;i++)
 649                         tmp[2+i] = tms_chain[i];
 650                 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,tms_chain_index+2,1000);
 651                 tms_chain_index=0;
 652         }
 653 }
 654