src/jtag/drivers/usbprog.c

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