src/jtag/drivers/buspirate.c

   1 /***************************************************************************
   2  *   Copyright (C) 2010 by Michal Demin                                    *
   3  *   based on usbprog.c and arm-jtag-ew.c                                  *
   4  *   Several fixes by R. Diez in 2013.                                     *
   5  *                                                                         *
   6  *   This program is free software; you can redistribute it and/or modify  *
   7  *   it under the terms of the GNU General Public License as published by  *
   8  *   the Free Software Foundation; either version 2 of the License, or     *
   9  *   (at your option) any later version.                                   *
  10  *                                                                         *
  11  *   This program is distributed in the hope that it will be useful,       *
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  14  *   GNU General Public License for more details.                          *
  15  *                                                                         *
  16  *   You should have received a copy of the GNU General Public License     *
  17  *   along with this program; if not, write to the                         *
  18  *   Free Software Foundation, Inc.,                                       *
  19  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
  20  ***************************************************************************/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include <jtag/interface.h>
  27 #include <jtag/commands.h>
  28
  29 #include <termios.h>
  30 #include <fcntl.h>
  31 #include <sys/ioctl.h>
  32
  33 #undef DEBUG_SERIAL
  34 /*#define DEBUG_SERIAL */
  35 static int buspirate_execute_queue(void);
  36 static int buspirate_init(void);
  37 static int buspirate_quit(void);
  38
  39 static void buspirate_end_state(tap_state_t state);
  40 static void buspirate_state_move(void);
  41 static void buspirate_path_move(int num_states, tap_state_t *path);
  42 static void buspirate_runtest(int num_cycles);
  43 static void buspirate_scan(bool ir_scan, enum scan_type type,
  44         uint8_t *buffer, int scan_size, struct scan_command *command);
  45
  46 #define CMD_UNKNOWN       0x00
  47 #define CMD_PORT_MODE     0x01
  48 #define CMD_FEATURE       0x02
  49 #define CMD_READ_ADCS     0x03
  50 /*#define CMD_TAP_SHIFT     0x04 // old protocol */
  51 #define CMD_TAP_SHIFT     0x05
  52 #define CMD_ENTER_OOCD    0x06
  53 #define CMD_UART_SPEED    0x07
  54 #define CMD_JTAG_SPEED    0x08
  55
  56 /* Not all OSes have this speed defined */
  57 #if !defined(B1000000)
  58 #define  B1000000 0010010
  59 #endif
  60
  61 enum {
  62         MODE_HIZ = 0,
  63         MODE_JTAG = 1,          /* push-pull outputs */
  64         MODE_JTAG_OD = 2,       /* open-drain outputs */
  65 };
  66
  67 enum {
  68         FEATURE_LED = 0x01,
  69         FEATURE_VREG = 0x02,
  70         FEATURE_TRST = 0x04,
  71         FEATURE_SRST = 0x08,
  72         FEATURE_PULLUP = 0x10
  73 };
  74
  75 enum {
  76         ACTION_DISABLE = 0,
  77         ACTION_ENABLE = 1
  78 };
  79
  80 enum {
  81         SERIAL_NORMAL = 0,
  82         SERIAL_FAST = 1
  83 };
  84
  85 static const cc_t SHORT_TIMEOUT  = 1; /* Must be at least 1. */
  86 static const cc_t NORMAL_TIMEOUT = 10;
  87
  88 static int buspirate_fd = -1;
  89 static int buspirate_pinmode = MODE_JTAG_OD;
  90 static int buspirate_baudrate = SERIAL_NORMAL;
  91 static int buspirate_vreg;
  92 static int buspirate_pullup;
  93 static char *buspirate_port;
  94
  95 static enum tap_state last_tap_state = TAP_RESET;
  96
  97
  98 /* TAP interface */
  99 static void buspirate_tap_init(void);
 100 static int buspirate_tap_execute(void);
 101 static void buspirate_tap_append(int tms, int tdi);
 102 static void buspirate_tap_append_scan(int length, uint8_t *buffer,
 103                 struct scan_command *command);
 104 static void buspirate_tap_make_space(int scan, int bits);
 105
 106 static void buspirate_reset(int trst, int srst);
 107
 108 /* low level interface */
 109 static void buspirate_jtag_reset(int);
 110 static void buspirate_jtag_enable(int);
 111 static unsigned char buspirate_jtag_command(int, char *, int);
 112 static void buspirate_jtag_set_speed(int, char);
 113 static void buspirate_jtag_set_mode(int, char);
 114 static void buspirate_jtag_set_feature(int, char, char);
 115 static void buspirate_jtag_get_adcs(int);
 116
 117 /* low level HW communication interface */
 118 static int buspirate_serial_open(char *port);
 119 static int buspirate_serial_setspeed(int fd, char speed, cc_t timeout);
 120 static int buspirate_serial_write(int fd, char *buf, int size);
 121 static int buspirate_serial_read(int fd, char *buf, int size);
 122 static void buspirate_serial_close(int fd);
 123 static void buspirate_print_buffer(char *buf, int size);
 124
 125 static int buspirate_execute_queue(void)
 126 {
 127         /* currently processed command */
 128         struct jtag_command *cmd = jtag_command_queue;
 129         int scan_size;
 130         enum scan_type type;
 131         uint8_t *buffer;
 132
 133         while (cmd) {
 134                 switch (cmd->type) {
 135                 case JTAG_RUNTEST:
 136                         DEBUG_JTAG_IO("runtest %i cycles, end in %s",
 137                                 cmd->cmd.runtest->num_cycles,
 138                                 tap_state_name(cmd->cmd.runtest
 139                                         ->end_state));
 140                         buspirate_end_state(cmd->cmd.runtest
 141                                         ->end_state);
 142                         buspirate_runtest(cmd->cmd.runtest
 143                                         ->num_cycles);
 144                         break;
 145                 case JTAG_TLR_RESET:
 146                         DEBUG_JTAG_IO("statemove end in %s",
 147                                 tap_state_name(cmd->cmd.statemove
 148                                                 ->end_state));
 149                         buspirate_end_state(cmd->cmd.statemove
 150                                         ->end_state);
 151                         buspirate_state_move();
 152                         break;
 153                 case JTAG_PATHMOVE:
 154                         DEBUG_JTAG_IO("pathmove: %i states, end in %s",
 155                                 cmd->cmd.pathmove->num_states,
 156                                 tap_state_name(cmd->cmd.pathmove
 157                                         ->path[cmd->cmd.pathmove
 158                                                 ->num_states - 1]));
 159                         buspirate_path_move(cmd->cmd.pathmove
 160                                         ->num_states,
 161                                         cmd->cmd.pathmove->path);
 162                         break;
 163                 case JTAG_SCAN:
 164                         DEBUG_JTAG_IO("scan end in %s",
 165                                 tap_state_name(cmd->cmd.scan
 166                                         ->end_state));
 167
 168                         buspirate_end_state(cmd->cmd.scan
 169                                         ->end_state);
 170
 171                         scan_size = jtag_build_buffer(cmd->cmd.scan,
 172                                         &buffer);
 173                         type = jtag_scan_type(cmd->cmd.scan);
 174                         buspirate_scan(cmd->cmd.scan->ir_scan, type,
 175                                 buffer, scan_size, cmd->cmd.scan);
 176
 177                         break;
 178                 case JTAG_RESET:
 179                         DEBUG_JTAG_IO("reset trst: %i srst %i",
 180                                 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 181
 182                         /* flush buffers, so we can reset */
 183                         buspirate_tap_execute();
 184
 185                         if (cmd->cmd.reset->trst == 1)
 186                                 tap_set_state(TAP_RESET);
 187                         buspirate_reset(cmd->cmd.reset->trst,
 188                                         cmd->cmd.reset->srst);
 189                         break;
 190                 case JTAG_SLEEP:
 191                         DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
 192                         buspirate_tap_execute();
 193                         jtag_sleep(cmd->cmd.sleep->us);
 194                                 break;
 195                 default:
 196                         LOG_ERROR("BUG: unknown JTAG command type encountered");
 197                         exit(-1);
 198                 }
 199
 200                 cmd = cmd->next;
 201         }
 202
 203         return buspirate_tap_execute();
 204 }
 205
 206
 207 /* Returns true if successful, false if error. */
 208
 209 static bool read_and_discard_all_data(const int fd)
 210 {
 211         /* LOG_INFO("Discarding any stale data from a previous connection..."); */
 212
 213         bool was_msg_already_printed = false;
 214
 215         for ( ; ; ) {
 216                 char buffer[1024];  /* Any size will do, it's a trade-off between stack size and performance. */
 217
 218                 const ssize_t read_count = read(fd, buffer, sizeof(buffer));
 219
 220                 if (read_count == 0) {
 221                         /* This is the "end of file" or "connection closed at the other end" condition. */
 222                         return true;
 223                 }
 224
 225                 if (read_count > 0) {
 226                         if (!was_msg_already_printed)   {
 227                                 LOG_INFO("Some stale data from a previous connection was discarded.");
 228                                 was_msg_already_printed = true;
 229                         }
 230
 231                         continue;
 232                 }
 233
 234                 assert(read_count == -1);  /* According to the specification. */
 235
 236                 const int errno_code = errno;
 237
 238                 if (errno_code == EINTR)
 239                         continue;
 240
 241                 if (errno_code == EAGAIN ||
 242                         errno_code == EWOULDBLOCK) {
 243                         /* We know that the file descriptor has been opened with O_NONBLOCK or O_NDELAY,
 244                            and these codes mean that there is no data to read at present. */
 245                         return true;
 246                 }
 247
 248                 /* Some other error has occurred. */
 249                 return false;
 250         }
 251 }
 252
 253
 254 static int buspirate_init(void)
 255 {
 256         if (buspirate_port == NULL) {
 257                 LOG_ERROR("You need to specify the serial port!");
 258                 return ERROR_JTAG_INIT_FAILED;
 259         }
 260
 261         buspirate_fd = buspirate_serial_open(buspirate_port);
 262         if (buspirate_fd == -1) {
 263                 LOG_ERROR("Could not open serial port");
 264                 return ERROR_JTAG_INIT_FAILED;
 265         }
 266
 267         /* The Operating System or the device itself may deliver stale data from the last connection,
 268            so discard all available bytes right after the new connection has been established.
 269            After all, we are implementing here a master/slave protocol, so the slave should have nothing
 270            to say until the master sends the first command.
 271
 272            In the past, there was a tcflush() call in buspirate_serial_setspeed(), but that
 273            was not enough. I guess you must actively read from the serial port to trigger any
 274            data collection from the device and/or lower USB layers. If you disable the serial port
 275            read timeout (if you set SHORT_TIMEOUT to 0), then the discarding does not work any more.
 276
 277            Note that we are lowering the serial port timeout for this first read operation,
 278            otherwise the normal initialisation would be delayed for too long. */
 279
 280         if (-1 == buspirate_serial_setspeed(buspirate_fd, SERIAL_NORMAL, SHORT_TIMEOUT)) {
 281                 LOG_ERROR("Error configuring the serial port.");
 282                 return ERROR_JTAG_INIT_FAILED;
 283         }
 284
 285         if (!read_and_discard_all_data(buspirate_fd)) {
 286                 LOG_ERROR("Error while attempting to discard any stale data right after establishing the connection.");
 287                 return ERROR_JTAG_INIT_FAILED;
 288         }
 289
 290         if (-1 == buspirate_serial_setspeed(buspirate_fd, SERIAL_NORMAL, NORMAL_TIMEOUT)) {
 291                 LOG_ERROR("Error configuring the serial port.");
 292                 return ERROR_JTAG_INIT_FAILED;
 293         }
 294
 295         buspirate_jtag_enable(buspirate_fd);
 296
 297         if (buspirate_baudrate != SERIAL_NORMAL)
 298                 buspirate_jtag_set_speed(buspirate_fd, SERIAL_FAST);
 299
 300         LOG_INFO("Buspirate Interface ready!");
 301
 302         buspirate_tap_init();
 303         buspirate_jtag_set_mode(buspirate_fd, buspirate_pinmode);
 304         buspirate_jtag_set_feature(buspirate_fd, FEATURE_VREG,
 305                 (buspirate_vreg == 1) ? ACTION_ENABLE : ACTION_DISABLE);
 306         buspirate_jtag_set_feature(buspirate_fd, FEATURE_PULLUP,
 307                 (buspirate_pullup == 1) ? ACTION_ENABLE : ACTION_DISABLE);
 308         buspirate_reset(0, 0);
 309
 310         return ERROR_OK;
 311 }
 312
 313 static int buspirate_quit(void)
 314 {
 315         LOG_INFO("Shutting down buspirate.");
 316         buspirate_jtag_set_mode(buspirate_fd, MODE_HIZ);
 317
 318         buspirate_jtag_set_speed(buspirate_fd, SERIAL_NORMAL);
 319         buspirate_jtag_reset(buspirate_fd);
 320
 321         buspirate_serial_close(buspirate_fd);
 322
 323         if (buspirate_port) {
 324                 free(buspirate_port);
 325                 buspirate_port = NULL;
 326         }
 327         return ERROR_OK;
 328 }
 329
 330 /* openocd command interface */
 331 COMMAND_HANDLER(buspirate_handle_adc_command)
 332 {
 333         if (buspirate_fd == -1)
 334                 return ERROR_OK;
 335
 336         /* send the command */
 337         buspirate_jtag_get_adcs(buspirate_fd);
 338
 339         return ERROR_OK;
 340
 341 }
 342
 343 COMMAND_HANDLER(buspirate_handle_vreg_command)
 344 {
 345         if (CMD_ARGC < 1)
 346                 return ERROR_COMMAND_SYNTAX_ERROR;
 347
 348         if (atoi(CMD_ARGV[0]) == 1)
 349                 buspirate_vreg = 1;
 350         else if (atoi(CMD_ARGV[0]) == 0)
 351                 buspirate_vreg = 0;
 352         else
 353                 LOG_ERROR("usage: buspirate_vreg <1|0>");
 354
 355         return ERROR_OK;
 356
 357 }
 358
 359 COMMAND_HANDLER(buspirate_handle_pullup_command)
 360 {
 361         if (CMD_ARGC < 1)
 362                 return ERROR_COMMAND_SYNTAX_ERROR;
 363
 364         if (atoi(CMD_ARGV[0]) == 1)
 365                 buspirate_pullup = 1;
 366         else if (atoi(CMD_ARGV[0]) == 0)
 367                 buspirate_pullup = 0;
 368         else
 369                 LOG_ERROR("usage: buspirate_pullup <1|0>");
 370
 371         return ERROR_OK;
 372
 373 }
 374
 375 COMMAND_HANDLER(buspirate_handle_led_command)
 376 {
 377         if (CMD_ARGC < 1)
 378                 return ERROR_COMMAND_SYNTAX_ERROR;
 379
 380         if (atoi(CMD_ARGV[0]) == 1) {
 381                 /* enable led */
 382                 buspirate_jtag_set_feature(buspirate_fd, FEATURE_LED,
 383                                 ACTION_ENABLE);
 384         } else if (atoi(CMD_ARGV[0]) == 0) {
 385                 /* disable led */
 386                 buspirate_jtag_set_feature(buspirate_fd, FEATURE_LED,
 387                                 ACTION_DISABLE);
 388         } else {
 389                 LOG_ERROR("usage: buspirate_led <1|0>");
 390         }
 391
 392         return ERROR_OK;
 393
 394 }
 395
 396 COMMAND_HANDLER(buspirate_handle_mode_command)
 397 {
 398         if (CMD_ARGC < 1)
 399                 return ERROR_COMMAND_SYNTAX_ERROR;
 400
 401         if (CMD_ARGV[0][0] == 'n')
 402                 buspirate_pinmode = MODE_JTAG;
 403         else if (CMD_ARGV[0][0] == 'o')
 404                 buspirate_pinmode = MODE_JTAG_OD;
 405         else
 406                 LOG_ERROR("usage: buspirate_mode <normal|open-drain>");
 407
 408         return ERROR_OK;
 409
 410 }
 411
 412 COMMAND_HANDLER(buspirate_handle_speed_command)
 413 {
 414         if (CMD_ARGC < 1)
 415                 return ERROR_COMMAND_SYNTAX_ERROR;
 416
 417         if (CMD_ARGV[0][0] == 'n')
 418                 buspirate_baudrate = SERIAL_NORMAL;
 419         else if (CMD_ARGV[0][0] == 'f')
 420                 buspirate_baudrate = SERIAL_FAST;
 421         else
 422                 LOG_ERROR("usage: buspirate_speed <normal|fast>");
 423
 424         return ERROR_OK;
 425
 426 }
 427
 428 COMMAND_HANDLER(buspirate_handle_port_command)
 429 {
 430         if (CMD_ARGC < 1)
 431                 return ERROR_COMMAND_SYNTAX_ERROR;
 432
 433         if (buspirate_port == NULL)
 434                 buspirate_port = strdup(CMD_ARGV[0]);
 435
 436         return ERROR_OK;
 437
 438 }
 439
 440 static const struct command_registration buspirate_command_handlers[] = {
 441         {
 442                 .name = "buspirate_adc",
 443                 .handler = &buspirate_handle_adc_command,
 444                 .mode = COMMAND_EXEC,
 445                 .help = "reads voltages on adc pins",
 446         },
 447         {
 448                 .name = "buspirate_vreg",
 449                 .usage = "<1|0>",
 450                 .handler = &buspirate_handle_vreg_command,
 451                 .mode = COMMAND_CONFIG,
 452                 .help = "changes the state of voltage regulators",
 453         },
 454         {
 455                 .name = "buspirate_pullup",
 456                 .usage = "<1|0>",
 457                 .handler = &buspirate_handle_pullup_command,
 458                 .mode = COMMAND_CONFIG,
 459                 .help = "changes the state of pullup",
 460         },
 461         {
 462                 .name = "buspirate_led",
 463                 .usage = "<1|0>",
 464                 .handler = &buspirate_handle_led_command,
 465                 .mode = COMMAND_EXEC,
 466                 .help = "changes the state of led",
 467         },
 468         {
 469                 .name = "buspirate_speed",
 470                 .usage = "<normal|fast>",
 471                 .handler = &buspirate_handle_speed_command,
 472                 .mode = COMMAND_CONFIG,
 473                 .help = "speed of the interface",
 474         },
 475         {
 476                 .name = "buspirate_mode",
 477                 .usage = "<normal|open-drain>",
 478                 .handler = &buspirate_handle_mode_command,
 479                 .mode = COMMAND_CONFIG,
 480                 .help = "pin mode of the interface",
 481         },
 482         {
 483                 .name = "buspirate_port",
 484                 .usage = "/dev/ttyUSB0",
 485                 .handler = &buspirate_handle_port_command,
 486                 .mode = COMMAND_CONFIG,
 487                 .help = "name of the serial port to open",
 488         },
 489         COMMAND_REGISTRATION_DONE
 490 };
 491
 492 struct jtag_interface buspirate_interface = {
 493         .name = "buspirate",
 494         .execute_queue = buspirate_execute_queue,
 495         .commands = buspirate_command_handlers,
 496         .init = buspirate_init,
 497         .quit = buspirate_quit
 498 };
 499
 500 /*************** jtag execute commands **********************/
 501 static void buspirate_end_state(tap_state_t state)
 502 {
 503         if (tap_is_state_stable(state))
 504                 tap_set_end_state(state);
 505         else {
 506                 LOG_ERROR("BUG: %i is not a valid end state", state);
 507                 exit(-1);
 508         }
 509 }
 510
 511 static void buspirate_state_move(void)
 512 {
 513         int i = 0, tms = 0;
 514         uint8_t tms_scan = tap_get_tms_path(tap_get_state(),
 515                         tap_get_end_state());
 516         int tms_count = tap_get_tms_path_len(tap_get_state(),
 517                         tap_get_end_state());
 518
 519         for (i = 0; i < tms_count; i++) {
 520                 tms = (tms_scan >> i) & 1;
 521                 buspirate_tap_append(tms, 0);
 522         }
 523
 524         tap_set_state(tap_get_end_state());
 525 }
 526
 527 static void buspirate_path_move(int num_states, tap_state_t *path)
 528 {
 529         int i;
 530
 531         for (i = 0; i < num_states; i++) {
 532                 if (tap_state_transition(tap_get_state(), false) == path[i]) {
 533                         buspirate_tap_append(0, 0);
 534                 } else if (tap_state_transition(tap_get_state(), true)
 535                                 == path[i]) {
 536                         buspirate_tap_append(1, 0);
 537                 } else {
 538                         LOG_ERROR("BUG: %s -> %s isn't a valid "
 539                                 "TAP transition",
 540                                 tap_state_name(tap_get_state()),
 541                                 tap_state_name(path[i]));
 542                         exit(-1);
 543                 }
 544
 545                 tap_set_state(path[i]);
 546         }
 547
 548         tap_set_end_state(tap_get_state());
 549 }
 550
 551 static void buspirate_runtest(int num_cycles)
 552 {
 553         int i;
 554
 555         tap_state_t saved_end_state = tap_get_end_state();
 556
 557         /* only do a state_move when we're not already in IDLE */
 558         if (tap_get_state() != TAP_IDLE) {
 559                 buspirate_end_state(TAP_IDLE);
 560                 buspirate_state_move();
 561         }
 562
 563         for (i = 0; i < num_cycles; i++)
 564                 buspirate_tap_append(0, 0);
 565
 566         DEBUG_JTAG_IO("runtest: cur_state %s end_state %s",
 567                         tap_state_name(tap_get_state()),
 568                         tap_state_name(tap_get_end_state()));
 569
 570         /* finish in end_state */
 571         buspirate_end_state(saved_end_state);
 572         if (tap_get_state() != tap_get_end_state())
 573                 buspirate_state_move();
 574 }
 575
 576 static void buspirate_scan(bool ir_scan, enum scan_type type,
 577         uint8_t *buffer, int scan_size, struct scan_command *command)
 578 {
 579         tap_state_t saved_end_state;
 580
 581         buspirate_tap_make_space(1, scan_size+8);
 582         /* is 8 correct ? (2 moves = 16) */
 583
 584         saved_end_state = tap_get_end_state();
 585
 586         buspirate_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
 587
 588         /* Only move if we're not already there */
 589         if (tap_get_state() != tap_get_end_state())
 590                 buspirate_state_move();
 591
 592         buspirate_tap_append_scan(scan_size, buffer, command);
 593
 594         /* move to PAUSE */
 595         buspirate_tap_append(0, 0);
 596
 597         /* restore the saved state */
 598         buspirate_end_state(saved_end_state);
 599         tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
 600
 601         if (tap_get_state() != tap_get_end_state())
 602                 buspirate_state_move();
 603 }
 604
 605
 606 /************************* TAP related stuff **********/
 607
 608 /* This buffer size matches the maximum CMD_TAP_SHIFT bit length in the Bus Pirate firmware,
 609    look for constant 0x2000 in OpenOCD.c . */
 610 #define BUSPIRATE_BUFFER_SIZE 1024
 611
 612 /* The old value of 32 scans was not enough to achieve near 100% utilisation ratio
 613    for the current BUSPIRATE_BUFFER_SIZE value of 1024.
 614    With 128 scans I am getting full USB 2.0 high speed packets (512 bytes long) when
 615    using the JtagDue firmware on the Arduino Due instead of the Bus Pirate, which
 616    amounts approximately to a 10% overall speed gain. Bigger packets should also
 617    benefit the Bus Pirate, but the speed difference is much smaller.
 618    Unfortunately, each 512-byte packet is followed by a 329-byte one, which is not ideal.
 619    However, increasing BUSPIRATE_BUFFER_SIZE for the benefit of the JtagDue would
 620    make it incompatible with the Bus Pirate firmware. */
 621 #define BUSPIRATE_MAX_PENDING_SCANS 128
 622
 623 static char tms_chain[BUSPIRATE_BUFFER_SIZE]; /* send */
 624 static char tdi_chain[BUSPIRATE_BUFFER_SIZE]; /* send */
 625 static int tap_chain_index;
 626
 627 struct pending_scan_result /* this was stolen from arm-jtag-ew */
 628 {
 629         int first; /* First bit position in tdo_buffer to read */
 630         int length; /* Number of bits to read */
 631         struct scan_command *command; /* Corresponding scan command */
 632         uint8_t *buffer;
 633 };
 634
 635 static struct pending_scan_result
 636 tap_pending_scans[BUSPIRATE_MAX_PENDING_SCANS];
 637 static int tap_pending_scans_num;
 638
 639 static void buspirate_tap_init(void)
 640 {
 641         tap_chain_index = 0;
 642         tap_pending_scans_num = 0;
 643 }
 644
 645 static int buspirate_tap_execute(void)
 646 {
 647         static const int CMD_TAP_SHIFT_HEADER_LEN = 3;
 648
 649         char tmp[4096];
 650         uint8_t *in_buf;
 651         int i;
 652         int fill_index = 0;
 653         int ret;
 654         int bytes_to_send;
 655
 656         if (tap_chain_index <= 0)
 657                 return ERROR_OK;
 658
 659         LOG_DEBUG("executing tap num bits = %i scans = %i",
 660                         tap_chain_index, tap_pending_scans_num);
 661
 662         bytes_to_send = DIV_ROUND_UP(tap_chain_index, 8);
 663
 664         tmp[0] = CMD_TAP_SHIFT; /* this command expects number of bits */
 665         tmp[1] = (char)(tap_chain_index >> 8);  /* high */
 666         tmp[2] = (char)(tap_chain_index);  /* low */
 667
 668         fill_index = CMD_TAP_SHIFT_HEADER_LEN;
 669         for (i = 0; i < bytes_to_send; i++) {
 670                 tmp[fill_index] = tdi_chain[i];
 671                 fill_index++;
 672                 tmp[fill_index] = tms_chain[i];
 673                 fill_index++;
 674         }
 675
 676         /* jlink.c calls the routine below, which may be useful for debugging purposes.
 677            For example, enabling this allows you to compare the log outputs from jlink.c
 678            and from this module for JTAG development or troubleshooting purposes. */
 679         if (false) {
 680                 last_tap_state = jtag_debug_state_machine(tms_chain, tdi_chain,
 681                                                                                                   tap_chain_index, last_tap_state);
 682         }
 683
 684         ret = buspirate_serial_write(buspirate_fd, tmp, CMD_TAP_SHIFT_HEADER_LEN + bytes_to_send*2);
 685         if (ret != bytes_to_send*2+CMD_TAP_SHIFT_HEADER_LEN) {
 686                 LOG_ERROR("error writing :(");
 687                 return ERROR_JTAG_DEVICE_ERROR;
 688         }
 689
 690         ret = buspirate_serial_read(buspirate_fd, tmp, bytes_to_send + CMD_TAP_SHIFT_HEADER_LEN);
 691         if (ret != bytes_to_send + CMD_TAP_SHIFT_HEADER_LEN) {
 692                 LOG_ERROR("error reading");
 693                 return ERROR_FAIL;
 694         }
 695         in_buf = (uint8_t *)(&tmp[CMD_TAP_SHIFT_HEADER_LEN]);
 696
 697         /* parse the scans */
 698         for (i = 0; i < tap_pending_scans_num; i++) {
 699                 uint8_t *buffer = tap_pending_scans[i].buffer;
 700                 int length = tap_pending_scans[i].length;
 701                 int first = tap_pending_scans[i].first;
 702                 struct scan_command *command = tap_pending_scans[i].command;
 703
 704                 /* copy bits from buffer */
 705                 buf_set_buf(in_buf, first, buffer, 0, length);
 706
 707                 /* return buffer to higher level */
 708                 if (jtag_read_buffer(buffer, command) != ERROR_OK) {
 709                         buspirate_tap_init();
 710                         return ERROR_JTAG_QUEUE_FAILED;
 711                 }
 712
 713                 free(buffer);
 714         }
 715         buspirate_tap_init();
 716         return ERROR_OK;
 717 }
 718
 719 static void buspirate_tap_make_space(int scans, int bits)
 720 {
 721         int have_scans = BUSPIRATE_MAX_PENDING_SCANS - tap_pending_scans_num;
 722         int have_bits = BUSPIRATE_BUFFER_SIZE * 8 - tap_chain_index;
 723
 724         if ((have_scans < scans) || (have_bits < bits))
 725                 buspirate_tap_execute();
 726 }
 727
 728 static void buspirate_tap_append(int tms, int tdi)
 729 {
 730         int chain_index;
 731
 732         buspirate_tap_make_space(0, 1);
 733         chain_index = tap_chain_index / 8;
 734
 735         if (chain_index < BUSPIRATE_BUFFER_SIZE) {
 736                 int bit_index = tap_chain_index % 8;
 737                 uint8_t bit = 1 << bit_index;
 738
 739                 if (0 == bit_index) {
 740                         /* Let's say that the TAP shift operation wants to shift 9 bits,
 741                            so we will be sending to the Bus Pirate a bit count of 9 but still
 742                            full 16 bits (2 bytes) of shift data.
 743                            If we don't clear all bits at this point, the last 7 bits will contain
 744                            random data from the last buffer contents, which is not pleasant to the eye.
 745                            Besides, the Bus Pirate (or some clone) may want to assert in debug builds
 746                            that, after consuming all significant data bits, the rest of them are zero.
 747                            Therefore, for aesthetic and for assert purposes, we clear all bits below. */
 748                         tms_chain[chain_index] = 0;
 749                         tdi_chain[chain_index] = 0;
 750                 }
 751
 752                 if (tms)
 753                         tms_chain[chain_index] |= bit;
 754                 else
 755                         tms_chain[chain_index] &= ~bit;
 756
 757                 if (tdi)
 758                         tdi_chain[chain_index] |= bit;
 759                 else
 760                         tdi_chain[chain_index] &= ~bit;
 761
 762                 tap_chain_index++;
 763         } else {
 764                 LOG_ERROR("tap_chain overflow, bad things will happen");
 765                 /* Exit abruptly, like jlink.c does. After a buffer overflow we don't want
 766                    to carry on, as data will be corrupt. Another option would be to return
 767                    some error code at this point. */
 768                 exit(-1);
 769         }
 770 }
 771
 772 static void buspirate_tap_append_scan(int length, uint8_t *buffer,
 773                 struct scan_command *command)
 774 {
 775         int i;
 776         tap_pending_scans[tap_pending_scans_num].length = length;
 777         tap_pending_scans[tap_pending_scans_num].buffer = buffer;
 778         tap_pending_scans[tap_pending_scans_num].command = command;
 779         tap_pending_scans[tap_pending_scans_num].first = tap_chain_index;
 780
 781         for (i = 0; i < length; i++) {
 782                 int tms = (i < length-1 ? 0 : 1);
 783                 int tdi = (buffer[i/8] >> (i%8)) & 1;
 784                 buspirate_tap_append(tms, tdi);
 785         }
 786         tap_pending_scans_num++;
 787 }
 788
 789 /*************** jtag wrapper functions *********************/
 790
 791 /* (1) assert or (0) deassert reset lines */
 792 static void buspirate_reset(int trst, int srst)
 793 {
 794         LOG_DEBUG("trst: %i, srst: %i", trst, srst);
 795
 796         if (trst)
 797                 buspirate_jtag_set_feature(buspirate_fd,
 798                                 FEATURE_TRST, ACTION_DISABLE);
 799         else
 800                 buspirate_jtag_set_feature(buspirate_fd,
 801                                 FEATURE_TRST, ACTION_ENABLE);
 802
 803         if (srst)
 804                 buspirate_jtag_set_feature(buspirate_fd,
 805                                 FEATURE_SRST, ACTION_DISABLE);
 806         else
 807                 buspirate_jtag_set_feature(buspirate_fd,
 808                                 FEATURE_SRST, ACTION_ENABLE);
 809 }
 810
 811 /*************** jtag lowlevel functions ********************/
 812 static void buspirate_jtag_enable(int fd)
 813 {
 814         int ret;
 815         char tmp[21] = { [0 ... 20] = 0x00 };
 816         int done = 0;
 817         int cmd_sent = 0;
 818
 819         LOG_DEBUG("Entering binary mode");
 820         buspirate_serial_write(fd, tmp, 20);
 821         usleep(10000);
 822
 823         /* reads 1 to n "BBIO1"s and one "OCD1" */
 824         while (!done) {
 825                 ret = buspirate_serial_read(fd, tmp, 4);
 826                 if (ret != 4) {
 827                         LOG_ERROR("Buspirate error. Is binary"
 828                                 "/OpenOCD support enabled?");
 829                         exit(-1);
 830                 }
 831                 if (strncmp(tmp, "BBIO", 4) == 0) {
 832                         ret = buspirate_serial_read(fd, tmp, 1);
 833                         if (ret != 1) {
 834                                 LOG_ERROR("Buspirate did not answer correctly! "
 835                                         "Do you have correct firmware?");
 836                                 exit(-1);
 837                         }
 838                         if (tmp[0] != '1') {
 839                                 LOG_ERROR("Unsupported binary protocol");
 840                                 exit(-1);
 841                         }
 842                         if (cmd_sent == 0) {
 843                                 cmd_sent = 1;
 844                                 tmp[0] = CMD_ENTER_OOCD;
 845                                 ret = buspirate_serial_write(fd, tmp, 1);
 846                                 if (ret != 1) {
 847                                         LOG_ERROR("error reading");
 848                                         exit(-1);
 849                                 }
 850                         }
 851                 } else if (strncmp(tmp, "OCD1", 4) == 0)
 852                         done = 1;
 853                 else {
 854                         LOG_ERROR("Buspirate did not answer correctly! "
 855                                 "Do you have correct firmware?");
 856                         exit(-1);
 857                 }
 858         }
 859
 860 }
 861
 862 static void buspirate_jtag_reset(int fd)
 863 {
 864         char tmp[5];
 865
 866         tmp[0] = 0x00; /* exit OCD1 mode */
 867         buspirate_serial_write(fd, tmp, 1);
 868         usleep(10000);
 869         /* We ignore the return value here purposly, nothing we can do */
 870         buspirate_serial_read(fd, tmp, 5);
 871         if (strncmp(tmp, "BBIO1", 5) == 0) {
 872                 tmp[0] = 0x0F; /*  reset BP */
 873                 buspirate_serial_write(fd, tmp, 1);
 874         } else
 875                 LOG_ERROR("Unable to restart buspirate!");
 876 }
 877
 878 static void buspirate_jtag_set_speed(int fd, char speed)
 879 {
 880         int ret;
 881         char tmp[2];
 882         char ack[2];
 883
 884         ack[0] = 0xAA;
 885         ack[1] = 0x55;
 886
 887         tmp[0] = CMD_UART_SPEED;
 888         tmp[1] = speed;
 889         buspirate_jtag_command(fd, tmp, 2);
 890
 891         /* here the adapter changes speed, we need follow */
 892         if (-1 == buspirate_serial_setspeed(fd, speed, NORMAL_TIMEOUT)) {
 893                 LOG_ERROR("Error configuring the serial port.");
 894                 exit(-1);
 895         }
 896
 897         buspirate_serial_write(fd, ack, 2);
 898         ret = buspirate_serial_read(fd, tmp, 2);
 899         if (ret != 2) {
 900                 LOG_ERROR("Buspirate did not ack speed change");
 901                 exit(-1);
 902         }
 903         if ((tmp[0] != CMD_UART_SPEED) || (tmp[1] != speed)) {
 904                 LOG_ERROR("Buspirate did not reply as expected to the speed change command");
 905                 exit(-1);
 906         }
 907         LOG_INFO("Buspirate switched to %s mode",
 908                 (speed == SERIAL_NORMAL) ? "normal" : "FAST");
 909 }
 910
 911
 912 static void buspirate_jtag_set_mode(int fd, char mode)
 913 {
 914         char tmp[2];
 915         tmp[0] = CMD_PORT_MODE;
 916         tmp[1] = mode;
 917         buspirate_jtag_command(fd, tmp, 2);
 918 }
 919
 920 static void buspirate_jtag_set_feature(int fd, char feat, char action)
 921 {
 922         char tmp[3];
 923         tmp[0] = CMD_FEATURE;
 924         tmp[1] = feat;   /* what */
 925         tmp[2] = action; /* action */
 926         buspirate_jtag_command(fd, tmp, 3);
 927 }
 928
 929 static void buspirate_jtag_get_adcs(int fd)
 930 {
 931         uint8_t tmp[10];
 932         uint16_t a, b, c, d;
 933         tmp[0] = CMD_READ_ADCS;
 934         buspirate_jtag_command(fd, (char *)tmp, 1);
 935         a = tmp[2] << 8 | tmp[3];
 936         b = tmp[4] << 8 | tmp[5];
 937         c = tmp[6] << 8 | tmp[7];
 938         d = tmp[8] << 8 | tmp[9];
 939
 940         LOG_INFO("ADC: ADC_Pin = %.02f VPullup = %.02f V33 = %.02f "
 941                 "V50 = %.02f",
 942                 ((float)a)/155.1515, ((float)b)/155.1515,
 943                 ((float)c)/155.1515, ((float)d)/155.1515);
 944 }
 945
 946 static unsigned char buspirate_jtag_command(int fd,
 947                 char *cmd, int cmdlen)
 948 {
 949         int res;
 950         int len = 0;
 951
 952         res = buspirate_serial_write(fd, cmd, cmdlen);
 953
 954         if ((cmd[0] == CMD_UART_SPEED)
 955                                 || (cmd[0] == CMD_PORT_MODE)
 956                                 || (cmd[0] == CMD_FEATURE)
 957                                 || (cmd[0] == CMD_JTAG_SPEED))
 958                 return 1;
 959
 960         if (res == cmdlen) {
 961                 switch (cmd[0]) {
 962                 case CMD_READ_ADCS:
 963                         len = 10; /* 2*sizeof(char)+4*sizeof(uint16_t) */
 964                         break;
 965                 case CMD_TAP_SHIFT:
 966                         len = cmdlen;
 967                         break;
 968                 default:
 969                         LOG_INFO("Wrong !");
 970                 }
 971                 res =  buspirate_serial_read(fd, cmd, len);
 972                 if (res > 0)
 973                         return (unsigned char)cmd[1];
 974                 else
 975                         return -1;
 976         } else
 977                 return -1;
 978         return 0;
 979 }
 980
 981 /* low level serial port */
 982 /* TODO add support for WIN32 and others ! */
 983 static int buspirate_serial_open(char *port)
 984 {
 985         int fd;
 986         fd = open(buspirate_port, O_RDWR | O_NOCTTY | O_NDELAY);
 987         return fd;
 988 }
 989
 990
 991 /* Returns -1 on error. */
 992
 993 static int buspirate_serial_setspeed(int fd, char speed, cc_t timeout)
 994 {
 995         struct termios t_opt;
 996         speed_t baud = (speed == SERIAL_FAST) ? B1000000 : B115200;
 997
 998         /* set the serial port parameters */
 999         fcntl(fd, F_SETFL, 0);
1000         if (0 != tcgetattr(fd, &t_opt))
1001                 return -1;
1002
1003         if (0 != cfsetispeed(&t_opt, baud))
1004                 return -1;
1005
1006         if (0 != cfsetospeed(&t_opt, baud))
1007                 return -1;
1008
1009         t_opt.c_cflag |= (CLOCAL | CREAD);
1010         t_opt.c_cflag &= ~PARENB;
1011         t_opt.c_cflag &= ~CSTOPB;
1012         t_opt.c_cflag &= ~CSIZE;
1013         t_opt.c_cflag |= CS8;
1014         t_opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
1015
1016         /* The serial port may have been configured for human interaction with
1017            the Bus Pirate console, but OpenOCD is going to use a binary protocol,
1018            so make sure to turn off any CR/LF translation and the like. */
1019         t_opt.c_iflag &= ~(IXON | IXOFF | IXANY | INLCR | ICRNL);
1020
1021         t_opt.c_oflag &= ~OPOST;
1022         t_opt.c_cc[VMIN] = 0;
1023         t_opt.c_cc[VTIME] = timeout;
1024
1025         /* Note that, in the past, TCSANOW was used below instead of TCSADRAIN,
1026            and CMD_UART_SPEED did not work properly then, at least with
1027            the Bus Pirate v3.5 (USB). */
1028         if (0 != tcsetattr(fd, TCSADRAIN, &t_opt)) {
1029                 /* According to the Linux documentation, this is actually not enough
1030                    to detect errors, you need to call tcgetattr() and check that
1031                    all changes have been performed successfully. */
1032                 return -1;
1033         }
1034
1035         return 0;
1036 }
1037
1038 static int buspirate_serial_write(int fd, char *buf, int size)
1039 {
1040         int ret = 0;
1041
1042         ret = write(fd, buf, size);
1043
1044         LOG_DEBUG("size = %d ret = %d", size, ret);
1045         buspirate_print_buffer(buf, size);
1046
1047         if (ret != size)
1048                 LOG_ERROR("Error sending data");
1049
1050         return ret;
1051 }
1052
1053 static int buspirate_serial_read(int fd, char *buf, int size)
1054 {
1055         int len = 0;
1056         int ret = 0;
1057         int timeout = 0;
1058
1059         while (len < size) {
1060                 ret = read(fd, buf+len, size-len);
1061                 if (ret == -1)
1062                         return -1;
1063
1064                 if (ret == 0) {
1065                         timeout++;
1066
1067                         if (timeout >= 10)
1068                                 break;
1069
1070                         continue;
1071                 }
1072
1073                 len += ret;
1074         }
1075
1076         LOG_DEBUG("should have read = %d actual size = %d", size, len);
1077         buspirate_print_buffer(buf, len);
1078
1079         if (len != size)
1080                 LOG_ERROR("Error reading data");
1081
1082         return len;
1083 }
1084
1085 static void buspirate_serial_close(int fd)
1086 {
1087         close(fd);
1088 }
1089
1090 #define LINE_SIZE      81
1091 #define BYTES_PER_LINE 16
1092 static void buspirate_print_buffer(char *buf, int size)
1093 {
1094         char line[LINE_SIZE];
1095         char tmp[10];
1096         int offset = 0;
1097
1098         line[0] = 0;
1099         while (offset < size) {
1100                 snprintf(tmp, 5, "%02x ", (uint8_t)buf[offset]);
1101                 offset++;
1102
1103                 strcat(line, tmp);
1104
1105                 if (offset % BYTES_PER_LINE == 0) {
1106                         LOG_DEBUG("%s", line);
1107                         line[0] = 0;
1108                 }
1109         }
1110
1111         if (line[0] != 0)
1112                 LOG_DEBUG("%s", line);
1113 }