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