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         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_write(0, 0, 0);
 318         }
 319         else {
 320                 usbprog_jtag_tms_send(usbprog_jtag_handle);
 321         }
 322
 323         for (i = 0; i < num_cycles; i++)
 324         {
 325                 usbprog_write(1, 0, 0);
 326                 usbprog_write(0, 0, 0);
 327         }
 328
 329         /* finish in end_state */
 330         /*
 331         usbprog_end_state(saved_end_state);
 332         if (cur_state != end_state)
 333                 usbprog_state_move();
 334         */
 335 }
 336
 337
 338
 339 void usbprog_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
 340 {
 341         enum tap_state saved_end_state = end_state;
 342         int bit_cnt;
 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,buffer, scan_size);
 356         }
 357         if (type == SCAN_IN) {
 358                 usbprog_jtag_read_tdo(usbprog_jtag_handle,buffer, scan_size);
 359         }
 360         if (type == SCAN_IO) {
 361                 usbprog_jtag_write_and_read(usbprog_jtag_handle,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_dev_handle* usb_handle;
 414         struct usb_bus *bus;
 415         struct usb_device *dev;
 416
 417         struct usbprog_jtag * tmp;
 418
 419         tmp = (struct usbprog_jtag*)malloc(sizeof(struct usbprog_jtag));
 420
 421
 422         usb_init();
 423         usb_find_busses();
 424         usb_find_devices();
 425
 426         busses = usb_get_busses();
 427
 428         /* find usbprog_jtag device in usb bus */
 429
 430         for (bus = busses; bus; bus = bus->next){
 431                 for (dev = bus->devices; dev; dev = dev->next){
 432                         /* condition for sucessfully hit (too bad, I only check the vendor id)*/
 433                         if (dev->descriptor.idVendor == VID && dev->descriptor.idProduct == PID) {
 434                                 tmp->usb_handle = usb_open(dev);
 435                                 usb_set_configuration (tmp->usb_handle,dev->config[0].bConfigurationValue);
 436                                 usb_claim_interface(tmp->usb_handle, 0);
 437                                 usb_set_altinterface(tmp->usb_handle,0);
 438                                 return tmp;
 439                         }
 440                 }
 441         }
 442         return 0;
 443 }
 444
 445
 446 void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag)
 447 {
 448         usb_close(usbprog_jtag->usb_handle);
 449         free(usbprog_jtag);
 450 }
 451
 452
 453 unsigned char usbprog_jtag_message(struct usbprog_jtag *usbprog_jtag, char *msg, int msglen)
 454 {
 455         int res = usb_bulk_write(usbprog_jtag->usb_handle,3,msg,msglen,100);
 456         if(msg[0]==2)
 457                 return 1;
 458         if(res == msglen) {
 459                 res =  usb_bulk_read(usbprog_jtag->usb_handle,0x82, msg, 2, 100);
 460                 if (res > 0)
 461                         return (unsigned char)msg[1];
 462                 else
 463                         return -1;
 464         }
 465         else
 466                 return -1;
 467         return 0;
 468 }
 469
 470 void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag)
 471 {
 472         usbprog_jtag_set_direction(usbprog_jtag, 0xFE);
 473 }
 474
 475
 476 void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
 477 {
 478         char tmp[64];   // fastes packet size for usb controller
 479         int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
 480
 481         char swap;
 482         // 61 byte can be transfered (488 bit)
 483
 484         while(size > 0) {
 485                 if(size > 488) {
 486                         send_bits = 488;
 487                         size = size - 488;
 488                         loops = 61;
 489                 } else {
 490                         send_bits = size;
 491                         loops = size/8;
 492                         loops++;
 493                         size = 0;
 494                 }
 495                 tmp[0] = WRITE_AND_READ;
 496                 tmp[1] = (char)(send_bits>>8); // high
 497                 tmp[2] = (char)(send_bits);    // low
 498                 i=0;
 499
 500                 for(i=0;i < loops ;i++) {
 501                         tmp[3+i]=buffer[bufindex];
 502                         bufindex++;
 503                 }
 504
 505                 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,64,1000);
 506
 507                 while(usb_bulk_read(usbprog_jtag->usb_handle,0x82, tmp, 64, 1000) < 1);
 508
 509                 for(i=0;i<loops ;i++) {
 510                         swap =  tmp[3+i];
 511                         buffer[fillindex++] = swap;
 512                 }
 513         }
 514 }
 515
 516
 517 void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
 518 {
 519         char tmp[64];   // fastes packet size for usb controller
 520         int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
 521
 522         char swap;
 523         // 61 byte can be transfered (488 bit)
 524
 525         while(size > 0) {
 526                 if(size > 488) {
 527                         send_bits = 488;
 528                         size = size - 488;
 529                         loops = 61;
 530                 } else {
 531                         send_bits = size;
 532                         loops = size/8;
 533                         loops++;
 534                         size = 0;
 535                 }
 536                 tmp[0] = WRITE_AND_READ;
 537                 tmp[1] = (char)(send_bits>>8); // high
 538                 tmp[2] = (char)(send_bits);    // low
 539
 540                 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,3,1000);
 541
 542                 while(usb_bulk_read(usbprog_jtag->usb_handle,0x82, tmp, 64, 10) < 1);
 543
 544                 for(i=0;i<loops ;i++) {
 545                         swap =  tmp[3+i];
 546                         buffer[fillindex++] = swap;
 547                 }
 548         }
 549 }
 550
 551 void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
 552 {
 553         char tmp[64];   // fastes packet size for usb controller
 554         int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
 555         char swap;
 556         // 61 byte can be transfered (488 bit)
 557         while(size > 0) {
 558                 if(size > 488) {
 559                         send_bits = 488;
 560                         size = size - 488;
 561                         loops = 61;
 562                 } else {
 563                         send_bits = size;
 564                         loops = size/8;
 565                         //if(loops==0)
 566                         loops++;
 567                         size = 0;
 568                 }
 569                 tmp[0] = WRITE_TDI;
 570                 tmp[1] = (char)(send_bits>>8); // high
 571                 tmp[2] = (char)(send_bits);    // low
 572                 i=0;
 573
 574                 for(i=0;i < loops ;i++) {
 575                         tmp[3+i]=buffer[bufindex];
 576                         bufindex++;
 577                 }
 578                 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,64,1000);
 579         }
 580 }
 581
 582
 583 void usbprog_jtag_write_tms(struct usbprog_jtag *usbprog_jtag, char tms_scan)
 584 {
 585         usbprog_jtag_tms_collect(tms_scan);
 586 }
 587
 588
 589 void usbprog_jtag_set_direction(struct usbprog_jtag *usbprog_jtag, unsigned char direction)
 590 {
 591         char tmp[2];
 592         tmp[0] = PORT_DIRECTION;
 593         tmp[1] = (char)direction;
 594         usbprog_jtag_message(usbprog_jtag,tmp,2);
 595 }
 596
 597 void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char value)
 598 {
 599         char tmp[2];
 600         tmp[0] = PORT_SET;
 601         tmp[1] = (char)value;
 602         usbprog_jtag_message(usbprog_jtag,tmp,2);
 603 }
 604
 605 unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag)
 606 {
 607         char tmp[2];
 608         tmp[0] = PORT_GET;
 609         tmp[1] = 0x00;
 610         return usbprog_jtag_message(usbprog_jtag,tmp,2);
 611 }
 612
 613
 614 void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag,int bit, int value)
 615 {
 616         char tmp[3];
 617         tmp[0] = PORT_SETBIT;
 618         tmp[1] = (char)bit;
 619         if(value==1)
 620                 tmp[2] = 0x01;
 621         else
 622                 tmp[2] = 0x00;
 623         usbprog_jtag_message(usbprog_jtag,tmp,3);
 624 }
 625
 626 int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit)
 627 {
 628         char tmp[2];
 629         tmp[0] = PORT_GETBIT;
 630         tmp[1] = (char)bit;
 631
 632         if(usbprog_jtag_message(usbprog_jtag,tmp,2)>0)
 633                 return 1;
 634         else
 635                 return 0;
 636 }
 637
 638 void usbprog_jtag_tms_collect(char tms_scan){
 639         tms_chain[tms_chain_index]=tms_scan;
 640         tms_chain_index++;
 641 }
 642
 643 void usbprog_jtag_tms_send(struct usbprog_jtag *usbprog_jtag){
 644         int i;
 645         if(tms_chain_index>0) {
 646                 char tmp[tms_chain_index+2];
 647                 tmp[0] = WRITE_TMS_CHAIN;
 648                 tmp[1] = (char)(tms_chain_index);
 649                 for(i=0;i<tms_chain_index+1;i++)
 650                         tmp[2+i] = tms_chain[i];
 651                 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,tms_chain_index+2,1000);
 652                 tms_chain_index=0;
 653         }
 654 }
 655