git.gag.com Git - fw/openocd/blob - src/jtag/drivers/osbdm.c

   1 /***************************************************************************
   2  *   Copyright (C) 2012 by Jan Dakinevich                                  *
   3  *   jan.dakinevich@gmail.com                                              *
   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 #ifdef HAVE_CONFIG_H
  19 #       include "config.h"
  20 #endif
  21
  22 #include <helper/log.h>
  23 #include <helper/binarybuffer.h>
  24 #include <helper/command.h>
  25 #include <jtag/interface.h>
  26 #include "libusb_common.h"
  27
  28 struct sequence {
  29         int len;
  30         void *tms;
  31         void *tdo;
  32         const void *tdi;
  33         struct sequence *next;
  34 };
  35
  36 struct queue {
  37         struct sequence *head;
  38         struct sequence *tail;
  39 };
  40
  41 static struct sequence *queue_add_tail(struct queue *queue, int len)
  42 {
  43         if (len <= 0) {
  44                 LOG_ERROR("BUG: sequences with zero length are not allowed");
  45                 return NULL;
  46         }
  47
  48         struct sequence *next;
  49         next = malloc(sizeof(*next));
  50         if (next) {
  51                 next->tms = calloc(1, DIV_ROUND_UP(len, 8));
  52                 if (next->tms) {
  53                         next->len = len;
  54                         next->tdo = NULL;
  55                         next->tdi = NULL;
  56                         next->next = NULL;
  57
  58                         if (!queue->head) {
  59                                 /* Queue is empty at the moment */
  60                                 queue->head = next;
  61                         } else {
  62                                 /* Queue already contains at least one sequence */
  63                                 queue->tail->next = next;
  64                         }
  65
  66                         queue->tail = next;
  67                 } else {
  68                         free(next);
  69                         next = NULL;
  70                 }
  71         }
  72
  73         if (!next)
  74                 LOG_ERROR("Not enough memory");
  75
  76         return next;
  77 }
  78
  79 static void queue_drop_head(struct queue *queue)
  80 {
  81         struct sequence *head = queue->head->next; /* New head */
  82         free(queue->head->tms);
  83         free(queue->head);
  84         queue->head = head;
  85 }
  86
  87 static void queue_free(struct queue *queue)
  88 {
  89         if (queue) {
  90                 while (queue->head)
  91                         queue_drop_head(queue);
  92
  93                 free(queue);
  94         }
  95 }
  96
  97 static struct queue *queue_alloc(void)
  98 {
  99         struct queue *queue = malloc(sizeof(*queue));
 100         if (queue)
 101                 queue->head = NULL;
 102         else
 103                 LOG_ERROR("Not enough memory");
 104
 105         return queue;
 106 }
 107
 108 /* Size of usb communication buffer */
 109 #define OSBDM_USB_BUFSIZE 64
 110 /* Timeout for USB transfer, ms */
 111 #define OSBDM_USB_TIMEOUT 1000
 112 /* Write end point */
 113 #define OSBDM_USB_EP_WRITE 0x01
 114 /* Read end point */
 115 #define OSBDM_USB_EP_READ 0x82
 116
 117 /* Initialize OSBDM device */
 118 #define OSBDM_CMD_INIT 0x11
 119 /* Execute special, not-BDM command. But only this
 120  * command is used for JTAG operation */
 121 #define OSBDM_CMD_SPECIAL 0x27
 122 /* Execute JTAG swap (tms/tdi -> tdo) */
 123 #define OSBDM_CMD_SPECIAL_SWAP 0x05
 124 /* Reset control */
 125 #define OSBDM_CMD_SPECIAL_SRST 0x01
 126 /* Maximum bit-length in one swap */
 127 #define OSBDM_SWAP_MAX (((OSBDM_USB_BUFSIZE - 6) / 5) * 16)
 128
 129 /* Lists of valid VID/PID pairs
 130  */
 131 static const uint16_t osbdm_vid[] = { 0x15a2, 0x15a2, 0x15a2, 0 };
 132 static const uint16_t osbdm_pid[] = { 0x0042, 0x0058, 0x005e, 0 };
 133
 134 struct osbdm {
 135         struct jtag_libusb_device_handle *devh; /* USB handle */
 136         uint8_t buffer[OSBDM_USB_BUFSIZE]; /* Data to send and receive */
 137         int count; /* Count data to send and to read */
 138 };
 139
 140 /* osbdm instance
 141  */
 142 static struct osbdm osbdm_context;
 143
 144 static int osbdm_send_and_recv(struct osbdm *osbdm)
 145 {
 146         /* Send request */
 147         int count = jtag_libusb_bulk_write(osbdm->devh, OSBDM_USB_EP_WRITE,
 148                 (char *)osbdm->buffer, osbdm->count, OSBDM_USB_TIMEOUT);
 149
 150         if (count != osbdm->count) {
 151                 LOG_ERROR("OSBDM communication error: can't write");
 152                 return ERROR_FAIL;
 153         }
 154
 155         /* Save command code for next checking */
 156         uint8_t cmd_saved = osbdm->buffer[0];
 157
 158         /* Reading answer */
 159         osbdm->count = jtag_libusb_bulk_read(osbdm->devh, OSBDM_USB_EP_READ,
 160                 (char *)osbdm->buffer, OSBDM_USB_BUFSIZE, OSBDM_USB_TIMEOUT);
 161
 162         /* Now perform basic checks for data sent by BDM device
 163          */
 164
 165         if (osbdm->count < 0) {
 166                 LOG_ERROR("OSBDM communication error: can't read");
 167                 return ERROR_FAIL;
 168         }
 169
 170         if (osbdm->count < 2) {
 171                 LOG_ERROR("OSBDM communication error: reply too small");
 172                 return ERROR_FAIL;
 173         }
 174
 175         if (osbdm->count != osbdm->buffer[1])  {
 176                 LOG_ERROR("OSBDM communication error: reply size mismatch");
 177                 return ERROR_FAIL;
 178         }
 179
 180         if (cmd_saved != osbdm->buffer[0]) {
 181                 LOG_ERROR("OSBDM communication error: reply command mismatch");
 182                 return ERROR_FAIL;
 183         }
 184
 185         return ERROR_OK;
 186 }
 187
 188 static int osbdm_srst(struct osbdm *osbdm, int srst)
 189 {
 190         osbdm->count = 0;
 191         (void)memset(osbdm->buffer, 0, OSBDM_USB_BUFSIZE);
 192
 193         /* Composing request
 194          */
 195         osbdm->buffer[osbdm->count++] = OSBDM_CMD_SPECIAL; /* Command */
 196         osbdm->buffer[osbdm->count++] = OSBDM_CMD_SPECIAL_SRST; /* Subcommand */
 197         /* Length in bytes - not used */
 198         osbdm->buffer[osbdm->count++] = 0;
 199         osbdm->buffer[osbdm->count++] = 0;
 200         /* SRST state */
 201         osbdm->buffer[osbdm->count++] = (srst ? 0 : 0x08);
 202
 203         /* Sending data
 204          */
 205         if (osbdm_send_and_recv(osbdm) != ERROR_OK)
 206                 return ERROR_FAIL;
 207
 208         return ERROR_OK;
 209 }
 210
 211 static int osbdm_swap(struct osbdm *osbdm, void *tms, void *tdi,
 212         void *tdo, int length)
 213 {
 214         if (length > OSBDM_SWAP_MAX) {
 215                 LOG_ERROR("BUG: bit sequence too long");
 216                 return ERROR_FAIL;
 217         }
 218
 219         if (length <= 0) {
 220                 LOG_ERROR("BUG: bit sequence equal or less than 0");
 221                 return ERROR_FAIL;
 222         }
 223
 224         int swap_count = DIV_ROUND_UP(length, 16);
 225
 226         /* cleanup */
 227         osbdm->count = 0;
 228         (void)memset(osbdm->buffer, 0, OSBDM_USB_BUFSIZE);
 229
 230         /* Composing request
 231          */
 232
 233         osbdm->buffer[osbdm->count++] = OSBDM_CMD_SPECIAL; /* Command */
 234         osbdm->buffer[osbdm->count++] = OSBDM_CMD_SPECIAL_SWAP; /* Subcommand */
 235         /* Length in bytes - not used */
 236         osbdm->buffer[osbdm->count++] = 0;
 237         osbdm->buffer[osbdm->count++] = 0;
 238         /* Swap count */
 239         osbdm->buffer[osbdm->count++] = 0;
 240         osbdm->buffer[osbdm->count++] = (uint8_t)swap_count;
 241
 242         for (int bit_idx = 0; bit_idx < length; ) {
 243                 /* Bit count in swap */
 244                 int bit_count = length - bit_idx;
 245                 if (bit_count > 16)
 246                         bit_count = 16;
 247
 248                 osbdm->buffer[osbdm->count++] = (uint8_t)bit_count;
 249
 250                 /* Copying TMS and TDI data to output buffer */
 251                 uint32_t tms_data = buf_get_u32(tms, bit_idx, bit_count);
 252                 uint32_t tdi_data = buf_get_u32(tdi, bit_idx, bit_count);
 253                 osbdm->buffer[osbdm->count++] = (uint8_t)(tdi_data >> 8);
 254                 osbdm->buffer[osbdm->count++] = (uint8_t)tdi_data;
 255                 osbdm->buffer[osbdm->count++] = (uint8_t)(tms_data >> 8);
 256                 osbdm->buffer[osbdm->count++] = (uint8_t)tms_data;
 257
 258                 /* Next bit offset */
 259                 bit_idx += bit_count;
 260         }
 261
 262         assert(osbdm->count <= OSBDM_USB_BUFSIZE);
 263
 264         /* Sending data
 265          */
 266         if (osbdm_send_and_recv(osbdm) != ERROR_OK)
 267                 return ERROR_FAIL;
 268
 269         /*      Extra check
 270          */
 271         if (((osbdm->buffer[2] << 8) | osbdm->buffer[3]) != 2 * swap_count) {
 272                 LOG_ERROR("OSBDM communication error: invalid swap command reply");
 273                 return ERROR_FAIL;
 274         }
 275
 276         /* Copy TDO responce
 277          */
 278         uint8_t *buffer = osbdm->buffer + 4;
 279         for (int bit_idx = 0; bit_idx < length; ) {
 280                 int bit_count = length - bit_idx;
 281                 if (bit_count > 16)
 282                         bit_count = 16;
 283
 284                 /* Prepare data */
 285                 uint32_t tdo_data = 0;
 286                 tdo_data |= (*buffer++) << 8;
 287                 tdo_data |= (*buffer++);
 288                 tdo_data >>= (16 - bit_count);
 289
 290                 /* Copy TDO to return */
 291                 buf_set_u32(tdo, bit_idx, bit_count, tdo_data);
 292
 293                 bit_idx += bit_count;
 294         }
 295
 296         return ERROR_OK;
 297 }
 298
 299 static int osbdm_flush(struct osbdm *osbdm, struct queue* queue)
 300 {
 301         uint8_t tms[DIV_ROUND_UP(OSBDM_SWAP_MAX, 8)];
 302         uint8_t tdi[DIV_ROUND_UP(OSBDM_SWAP_MAX, 8)];
 303         uint8_t tdo[DIV_ROUND_UP(OSBDM_SWAP_MAX, 8)];
 304
 305         int seq_back_len = 0;
 306
 307         while (queue->head) {
 308                 (void)memset(tms, 0, sizeof(tms));
 309                 (void)memset(tdi, 0, sizeof(tdi));
 310                 (void)memset(tdo, 0, sizeof(tdo));
 311
 312                 int seq_len;
 313                 int swap_len;
 314                 struct sequence *seq;
 315
 316                 /* Copy from queue to tms/tdi streams
 317                  */
 318                 seq = queue->head;
 319                 seq_len = seq_back_len;
 320                 swap_len = 0;
 321
 322                 while (seq && swap_len != OSBDM_SWAP_MAX) {
 323                         /* Count bit for copy at this iteration.
 324                          * len should fit into remaining space
 325                          * in tms/tdo bitstreams
 326                          */
 327                         int len = seq->len - seq_len;
 328                         if (len > OSBDM_SWAP_MAX - swap_len)
 329                                 len = OSBDM_SWAP_MAX - swap_len;
 330
 331                         /* Set tms data */
 332                         buf_set_buf(seq->tms, seq_len, tms, swap_len, len);
 333
 334                         /* Set tdi data if they exists */
 335                         if (seq->tdi)
 336                                 buf_set_buf(seq->tdi, seq_len, tdi, swap_len, len);
 337
 338                         swap_len += len;
 339                         seq_len += len;
 340                         if (seq_len == seq->len) {
 341                                 seq = seq->next; /* Move to next sequence */
 342                                 seq_len = 0;
 343                         }
 344                 }
 345
 346                 if (osbdm_swap(osbdm, tms, tdi, tdo, swap_len))
 347                         return ERROR_FAIL;
 348
 349                 /* Copy from tdo stream to queue
 350                  */
 351
 352                 for (int swap_back_len = 0; swap_back_len < swap_len; ) {
 353                         int len = queue->head->len - seq_back_len;
 354                         if (len > swap_len - swap_back_len)
 355                                 len = swap_len - swap_back_len;
 356
 357                         if (queue->head->tdo)
 358                                 buf_set_buf(tdo, swap_back_len, queue->head->tdo, seq_back_len, len);
 359
 360                         swap_back_len += len;
 361                         seq_back_len += len;
 362                         if (seq_back_len == queue->head->len) {
 363                                 queue_drop_head(queue);
 364                                 seq_back_len = 0;
 365                         }
 366                 }
 367         }
 368
 369         return ERROR_OK;
 370 }
 371
 372 /*      Basic operation for opening USB device */
 373 static int osbdm_open(struct osbdm *osbdm)
 374 {
 375         (void)memset(osbdm, 0, sizeof(*osbdm));
 376         if (jtag_libusb_open(osbdm_vid, osbdm_pid, NULL, &osbdm->devh) != ERROR_OK)
 377                 return ERROR_FAIL;
 378
 379         if (jtag_libusb_claim_interface(osbdm->devh, 0) != ERROR_OK)
 380                 return ERROR_FAIL;
 381
 382         return ERROR_OK;
 383 }
 384
 385 static int osbdm_quit(void)
 386 {
 387         jtag_libusb_close(osbdm_context.devh);
 388         return ERROR_OK;
 389 }
 390
 391 static int osbdm_add_pathmove(
 392         struct queue *queue,
 393         tap_state_t *path,
 394         int num_states)
 395 {
 396         assert(num_states <= 32);
 397
 398         struct sequence *next = queue_add_tail(queue, num_states);
 399         if (!next) {
 400                 LOG_ERROR("BUG: can't allocate bit sequence");
 401                 return ERROR_FAIL;
 402         }
 403
 404         uint32_t tms = 0;
 405         for (int i = 0; i < num_states; i++) {
 406                 if (tap_state_transition(tap_get_state(), 1) == path[i]) {
 407                         tms |= (1 << i);
 408                 } else if (tap_state_transition(tap_get_state(), 0) == path[i]) {
 409                         tms &= ~(1 << i); /* This line not so needed */
 410                 } else {
 411                         LOG_ERROR("BUG: %s -> %s isn't a valid TAP state transition",
 412                                 tap_state_name(tap_get_state()),
 413                                 tap_state_name(path[i]));
 414                         return ERROR_FAIL;
 415                 }
 416
 417                 tap_set_state(path[i]);
 418         }
 419
 420         buf_set_u32(next->tms, 0, num_states, tms);
 421         tap_set_end_state(tap_get_state());
 422
 423         return ERROR_OK;
 424 }
 425
 426 static int osbdm_add_statemove(
 427         struct queue *queue,
 428         tap_state_t new_state,
 429         int skip_first)
 430 {
 431         int len = 0;
 432         int tms = 0;
 433
 434         tap_set_end_state(new_state);
 435         if (tap_get_end_state() == TAP_RESET) {
 436                 /* Ignore current state */
 437                 tms = 0xff;
 438                 len = 5;
 439         } else if (tap_get_state() != tap_get_end_state()) {
 440                 tms = tap_get_tms_path(tap_get_state(), new_state);
 441                 len = tap_get_tms_path_len(tap_get_state(), new_state);
 442         }
 443
 444         if (len && skip_first) {
 445                 len--;
 446                 tms >>= 1;
 447         }
 448
 449         if (len) {
 450                 struct sequence *next = queue_add_tail(queue, len);
 451                 if (!next) {
 452                         LOG_ERROR("BUG: can't allocate bit sequence");
 453                         return ERROR_FAIL;
 454                 }
 455                 buf_set_u32(next->tms, 0, len, tms);
 456         }
 457
 458         tap_set_state(tap_get_end_state());
 459         return ERROR_OK;
 460 }
 461
 462 static int osbdm_add_stableclocks(
 463         struct queue *queue,
 464         int count)
 465 {
 466         if (!tap_is_state_stable(tap_get_state())) {
 467                 LOG_ERROR("BUG: current state (%s) is not stable",
 468                         tap_state_name(tap_get_state()));
 469                 return ERROR_FAIL;
 470         }
 471
 472         struct sequence *next = queue_add_tail(queue, count);
 473         if (!next) {
 474                 LOG_ERROR("BUG: can't allocate bit sequence");
 475                 return ERROR_FAIL;
 476         }
 477
 478         if (tap_get_state() == TAP_RESET)
 479                 (void)memset(next->tms, 0xff, DIV_ROUND_UP(count, 8));
 480
 481         return ERROR_OK;
 482 }
 483
 484 static int osbdm_add_tms(
 485         struct queue *queue,
 486         const uint8_t *tms,
 487         int num_bits)
 488 {
 489         struct sequence *next = queue_add_tail(queue, num_bits);
 490         if (!next) {
 491                 LOG_ERROR("BUG: can't allocate bit sequence");
 492                 return ERROR_FAIL;
 493         }
 494         buf_set_buf(tms, 0, next->tms, 0, num_bits);
 495
 496         return ERROR_OK;
 497 }
 498
 499 static int osbdm_add_scan(
 500         struct queue *queue,
 501         struct scan_field *fields,
 502         int num_fields,
 503         tap_state_t end_state,
 504         bool ir_scan)
 505 {
 506         /* Move to desired shift state */
 507         if (ir_scan) {
 508                 if (tap_get_state() != TAP_IRSHIFT) {
 509                         if (osbdm_add_statemove(queue, TAP_IRSHIFT, 0) != ERROR_OK)
 510                                 return ERROR_FAIL;
 511                 }
 512         } else {
 513                 if (tap_get_state() != TAP_DRSHIFT) {
 514                         if (osbdm_add_statemove(queue, TAP_DRSHIFT, 0) != ERROR_OK)
 515                                 return ERROR_FAIL;
 516                 }
 517         }
 518
 519         /* Add scan */
 520         tap_set_end_state(end_state);
 521         for (int idx = 0; idx < num_fields; idx++) {
 522                 struct sequence *next = queue_add_tail(queue, fields[idx].num_bits);
 523                 if (!next) {
 524                         LOG_ERROR("Can't allocate bit sequence");
 525                         return ERROR_FAIL;
 526                 }
 527
 528                 (void)memset(next->tms, 0, DIV_ROUND_UP(fields[idx].num_bits, 8));
 529                 next->tdi = fields[idx].out_value;
 530                 next->tdo = fields[idx].in_value;
 531         }
 532
 533         /* Move to end state
 534          */
 535         if (tap_get_state() != tap_get_end_state()) {
 536                 /* Exit from IRSHIFT/DRSHIFT */
 537                 buf_set_u32(queue->tail->tms, queue->tail->len - 1, 1, 1);
 538
 539                 /* Move with skip_first flag */
 540                 if (osbdm_add_statemove(queue, tap_get_end_state(), 1) != ERROR_OK)
 541                         return ERROR_FAIL;
 542         }
 543
 544         return ERROR_OK;
 545 }
 546
 547 static int osbdm_add_runtest(
 548         struct queue *queue,
 549         int num_cycles,
 550         tap_state_t end_state)
 551 {
 552         if (osbdm_add_statemove(queue, TAP_IDLE, 0) != ERROR_OK)
 553                 return ERROR_FAIL;
 554
 555         if (osbdm_add_stableclocks(queue, num_cycles) != ERROR_OK)
 556                 return ERROR_FAIL;
 557
 558         if (osbdm_add_statemove(queue, end_state, 0) != ERROR_OK)
 559                 return ERROR_FAIL;
 560
 561         return ERROR_OK;
 562 }
 563
 564 static int osbdm_execute_command(
 565         struct osbdm *osbdm,
 566         struct queue *queue,
 567         struct jtag_command *cmd)
 568 {
 569         int retval = ERROR_OK;
 570
 571         switch (cmd->type) {
 572         case JTAG_RESET:
 573                 if (cmd->cmd.reset->trst) {
 574                         LOG_ERROR("BUG: nTRST signal is not supported");
 575                         retval = ERROR_FAIL;
 576                 } else {
 577                         retval = osbdm_flush(osbdm, queue);
 578                         if (retval == ERROR_OK)
 579                                 retval = osbdm_srst(osbdm, cmd->cmd.reset->srst);
 580                 }
 581                 break;
 582
 583         case JTAG_PATHMOVE:
 584                 retval = osbdm_add_pathmove(
 585                         queue,
 586                         cmd->cmd.pathmove->path,
 587                         cmd->cmd.pathmove->num_states);
 588                 break;
 589
 590         case JTAG_TLR_RESET:
 591                 retval = osbdm_add_statemove(
 592                         queue,
 593                         cmd->cmd.statemove->end_state,
 594                         0);
 595                 break;
 596
 597         case JTAG_STABLECLOCKS:
 598                 retval = osbdm_add_stableclocks(
 599                         queue,
 600                         cmd->cmd.stableclocks->num_cycles);
 601                 break;
 602
 603         case JTAG_TMS:
 604                 retval = osbdm_add_tms(
 605                         queue,
 606                         cmd->cmd.tms->bits,
 607                         cmd->cmd.tms->num_bits);
 608                 break;
 609
 610         case JTAG_SCAN:
 611                 retval = osbdm_add_scan(
 612                         queue,
 613                         cmd->cmd.scan->fields,
 614                         cmd->cmd.scan->num_fields,
 615                         cmd->cmd.scan->end_state,
 616                         cmd->cmd.scan->ir_scan);
 617                 break;
 618
 619         case JTAG_SLEEP:
 620                 retval = osbdm_flush(osbdm, queue);
 621                 if (retval == ERROR_OK)
 622                         jtag_sleep(cmd->cmd.sleep->us);
 623                 break;
 624
 625         case JTAG_RUNTEST:
 626                 retval = osbdm_add_runtest(
 627                         queue,
 628                         cmd->cmd.runtest->num_cycles,
 629                         cmd->cmd.runtest->end_state);
 630                 break;
 631
 632         default:
 633                 LOG_ERROR("BUG: unknown JTAG command type encountered");
 634                 retval = ERROR_FAIL;
 635                 break;
 636         }
 637
 638         return retval;
 639 }
 640
 641 static int osbdm_execute_queue(void)
 642 {
 643         int retval = ERROR_OK;
 644
 645         struct queue *queue = queue_alloc();
 646         if (!queue) {
 647                 LOG_ERROR("BUG: can't allocate bit queue");
 648                 retval = ERROR_FAIL;
 649         } else {
 650                 struct jtag_command *cmd = jtag_command_queue;
 651
 652                 while (retval == ERROR_OK && cmd) {
 653                         retval = osbdm_execute_command(&osbdm_context, queue, cmd);
 654                         cmd = cmd->next;
 655                 }
 656
 657                 if (retval == ERROR_OK)
 658                         retval = osbdm_flush(&osbdm_context, queue);
 659
 660                 queue_free(queue);
 661         }
 662
 663         if (retval != ERROR_OK) {
 664                 LOG_ERROR("FATAL: can't execute jtag command");
 665                 exit(-1);
 666         }
 667
 668         return retval;
 669 }
 670
 671 static int osbdm_init(void)
 672 {
 673         /* Open device */
 674         if (osbdm_open(&osbdm_context) != ERROR_OK) {
 675                 LOG_ERROR("Can't open OSBDM device");
 676                 return ERROR_FAIL;
 677         } else {
 678                 /* Device successfully opened */
 679                 LOG_DEBUG("OSBDM init");
 680         }
 681
 682         /* Perform initialize command */
 683         osbdm_context.count = 0;
 684         osbdm_context.buffer[osbdm_context.count++] = OSBDM_CMD_INIT;
 685         if (osbdm_send_and_recv(&osbdm_context) != ERROR_OK)
 686                 return ERROR_FAIL;
 687
 688         return ERROR_OK;
 689 }
 690
 691 struct jtag_interface osbdm_interface = {
 692         .name = "osbdm",
 693
 694         .transports = jtag_only,
 695         .execute_queue = osbdm_execute_queue,
 696
 697         .init = osbdm_init,
 698         .quit = osbdm_quit
 699 };