src/jtag/usbprog.c

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