git.gag.com Git - fw/openocd/blob - 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, see <http://www.gnu.org/licenses/>. *
  18  ***************************************************************************/
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include <jtag/interface.h>
  25 #include <jtag/swd.h>
  26 #include <jtag/commands.h>
  27
  28 #include <termios.h>
  29 #include <fcntl.h>
  30 #include <sys/ioctl.h>
  31
  32 #undef DEBUG_SERIAL
  33 /*#define DEBUG_SERIAL */
  34 static int buspirate_execute_queue(void);
  35 static int buspirate_init(void);
  36 static int buspirate_quit(void);
  37
  38 static void buspirate_end_state(tap_state_t state);
  39 static void buspirate_state_move(void);
  40 static void buspirate_path_move(int num_states, tap_state_t *path);
  41 static void buspirate_runtest(int num_cycles);
  42 static void buspirate_scan(bool ir_scan, enum scan_type type,
  43         uint8_t *buffer, int scan_size, struct scan_command *command);
  44 static void buspirate_stableclocks(int num_cycles);
  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_RWIRE   0x05
  53 #define CMD_ENTER_OOCD    0x06
  54 #define CMD_UART_SPEED    0x07
  55 #define CMD_JTAG_SPEED    0x08
  56 #define CMD_RAW_PERIPH    0x40
  57 #define CMD_RAW_SPEED     0x60
  58 #define CMD_RAW_MODE      0x80
  59
  60 /* raw-wire mode configuration */
  61 #define CMD_RAW_CONFIG_HIZ 0x00
  62 #define CMD_RAW_CONFIG_3V3 0x08
  63 #define CMD_RAW_CONFIG_2W  0x00
  64 #define CMD_RAW_CONFIG_3W  0x04
  65 #define CMD_RAW_CONFIG_MSB 0x00
  66 #define CMD_RAW_CONFIG_LSB 0x02
  67
  68 /* Not all OSes have this speed defined */
  69 #if !defined(B1000000)
  70 #define  B1000000 0010010
  71 #endif
  72
  73 enum {
  74         MODE_HIZ = 0,
  75         MODE_JTAG = 1,          /* push-pull outputs */
  76         MODE_JTAG_OD = 2,       /* open-drain outputs */
  77 };
  78
  79 enum {
  80         FEATURE_LED = 0x01,
  81         FEATURE_VREG = 0x02,
  82         FEATURE_TRST = 0x04,
  83         FEATURE_SRST = 0x08,
  84         FEATURE_PULLUP = 0x10
  85 };
  86
  87 enum {
  88         ACTION_DISABLE = 0,
  89         ACTION_ENABLE = 1
  90 };
  91
  92 enum {
  93         SERIAL_NORMAL = 0,
  94         SERIAL_FAST = 1
  95 };
  96
  97 enum {
  98         SPEED_RAW_5_KHZ   = 0x0,
  99         SPEED_RAW_50_KHZ  = 0x1,
 100         SPEED_RAW_100_KHZ = 0x2,
 101         SPEED_RAW_400_KHZ = 0x3
 102 };
 103
 104 /* SWD mode specific */
 105 static bool swd_mode;
 106 static int  queued_retval;
 107 static char swd_features;
 108
 109 static const cc_t SHORT_TIMEOUT  = 1; /* Must be at least 1. */
 110 static const cc_t NORMAL_TIMEOUT = 10;
 111
 112 static int buspirate_fd = -1;
 113 static int buspirate_pinmode = MODE_JTAG_OD;
 114 static int buspirate_baudrate = SERIAL_NORMAL;
 115 static int buspirate_vreg;
 116 static int buspirate_pullup;
 117 static char *buspirate_port;
 118
 119 static enum tap_state last_tap_state = TAP_RESET;
 120
 121 /* SWD interface */
 122 static int buspirate_swd_init(void);
 123 static void buspirate_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk);
 124 static void buspirate_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk);
 125 static int buspirate_swd_switch_seq(enum swd_special_seq seq);
 126 static int buspirate_swd_run_queue(void);
 127
 128 /* TAP interface */
 129 static void buspirate_tap_init(void);
 130 static int buspirate_tap_execute(void);
 131 static void buspirate_tap_append(int tms, int tdi);
 132 static void buspirate_tap_append_scan(int length, uint8_t *buffer,
 133                 struct scan_command *command);
 134 static void buspirate_tap_make_space(int scan, int bits);
 135
 136 static void buspirate_reset(int trst, int srst);
 137 static void buspirate_set_feature(int, char, char);
 138 static void buspirate_set_mode(int, char);
 139 static void buspirate_set_speed(int, char);
 140
 141 /* low level interface */
 142 static void buspirate_bbio_enable(int);
 143 static void buspirate_jtag_reset(int);
 144 static unsigned char buspirate_jtag_command(int, uint8_t *, int);
 145 static void buspirate_jtag_set_speed(int, char);
 146 static void buspirate_jtag_set_mode(int, char);
 147 static void buspirate_jtag_set_feature(int, char, char);
 148 static void buspirate_jtag_get_adcs(int);
 149
 150 /* low level two-wire interface */
 151 static void buspirate_swd_set_speed(int, char);
 152 static void buspirate_swd_set_feature(int, char, char);
 153 static void buspirate_swd_set_mode(int, char);
 154
 155 /* low level HW communication interface */
 156 static int buspirate_serial_open(char *port);
 157 static int buspirate_serial_setspeed(int fd, char speed, cc_t timeout);
 158 static int buspirate_serial_write(int fd, uint8_t *buf, int size);
 159 static int buspirate_serial_read(int fd, uint8_t *buf, int size);
 160 static void buspirate_serial_close(int fd);
 161 static void buspirate_print_buffer(uint8_t *buf, int size);
 162
 163 static int buspirate_execute_queue(void)
 164 {
 165         /* currently processed command */
 166         struct jtag_command *cmd = jtag_command_queue;
 167         int scan_size;
 168         enum scan_type type;
 169         uint8_t *buffer;
 170
 171         while (cmd) {
 172                 switch (cmd->type) {
 173                 case JTAG_RUNTEST:
 174                         LOG_DEBUG_IO("runtest %i cycles, end in %s",
 175                                 cmd->cmd.runtest->num_cycles,
 176                                 tap_state_name(cmd->cmd.runtest
 177                                         ->end_state));
 178                         buspirate_end_state(cmd->cmd.runtest
 179                                         ->end_state);
 180                         buspirate_runtest(cmd->cmd.runtest
 181                                         ->num_cycles);
 182                         break;
 183                 case JTAG_TLR_RESET:
 184                         LOG_DEBUG_IO("statemove end in %s",
 185                                 tap_state_name(cmd->cmd.statemove
 186                                                 ->end_state));
 187                         buspirate_end_state(cmd->cmd.statemove
 188                                         ->end_state);
 189                         buspirate_state_move();
 190                         break;
 191                 case JTAG_PATHMOVE:
 192                         LOG_DEBUG_IO("pathmove: %i states, end in %s",
 193                                 cmd->cmd.pathmove->num_states,
 194                                 tap_state_name(cmd->cmd.pathmove
 195                                         ->path[cmd->cmd.pathmove
 196                                                 ->num_states - 1]));
 197                         buspirate_path_move(cmd->cmd.pathmove
 198                                         ->num_states,
 199                                         cmd->cmd.pathmove->path);
 200                         break;
 201                 case JTAG_SCAN:
 202                         LOG_DEBUG_IO("scan end in %s",
 203                                 tap_state_name(cmd->cmd.scan
 204                                         ->end_state));
 205
 206                         buspirate_end_state(cmd->cmd.scan
 207                                         ->end_state);
 208
 209                         scan_size = jtag_build_buffer(cmd->cmd.scan,
 210                                         &buffer);
 211                         type = jtag_scan_type(cmd->cmd.scan);
 212                         buspirate_scan(cmd->cmd.scan->ir_scan, type,
 213                                 buffer, scan_size, cmd->cmd.scan);
 214
 215                         break;
 216                 case JTAG_RESET:
 217                         LOG_DEBUG_IO("reset trst: %i srst %i",
 218                                 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 219
 220                         /* flush buffers, so we can reset */
 221                         buspirate_tap_execute();
 222
 223                         if (cmd->cmd.reset->trst == 1)
 224                                 tap_set_state(TAP_RESET);
 225                         buspirate_reset(cmd->cmd.reset->trst,
 226                                         cmd->cmd.reset->srst);
 227                         break;
 228                 case JTAG_SLEEP:
 229                         LOG_DEBUG_IO("sleep %i", cmd->cmd.sleep->us);
 230                         buspirate_tap_execute();
 231                         jtag_sleep(cmd->cmd.sleep->us);
 232                                 break;
 233                 case JTAG_STABLECLOCKS:
 234                         LOG_DEBUG_IO("stable clock %i cycles", cmd->cmd.stableclocks->num_cycles);
 235                         buspirate_stableclocks(cmd->cmd.stableclocks->num_cycles);
 236                                 break;
 237                 default:
 238                         LOG_ERROR("BUG: unknown JTAG command type encountered");
 239                         exit(-1);
 240                 }
 241
 242                 cmd = cmd->next;
 243         }
 244
 245         return buspirate_tap_execute();
 246 }
 247
 248
 249 /* Returns true if successful, false if error. */
 250
 251 static bool read_and_discard_all_data(const int fd)
 252 {
 253         /* LOG_INFO("Discarding any stale data from a previous connection..."); */
 254
 255         bool was_msg_already_printed = false;
 256
 257         for ( ; ; ) {
 258                 uint8_t buffer[1024];  /* Any size will do, it's a trade-off between stack size and performance. */
 259
 260                 const ssize_t read_count = read(fd, buffer, sizeof(buffer));
 261
 262                 if (read_count == 0) {
 263                         /* This is the "end of file" or "connection closed at the other end" condition. */
 264                         return true;
 265                 }
 266
 267                 if (read_count > 0) {
 268                         if (!was_msg_already_printed)   {
 269                                 LOG_INFO("Some stale data from a previous connection was discarded.");
 270                                 was_msg_already_printed = true;
 271                         }
 272
 273                         continue;
 274                 }
 275
 276                 assert(read_count == -1);  /* According to the specification. */
 277
 278                 const int errno_code = errno;
 279
 280                 if (errno_code == EINTR)
 281                         continue;
 282
 283                 if (errno_code == EAGAIN ||
 284                         errno_code == EWOULDBLOCK) {
 285                         /* We know that the file descriptor has been opened with O_NONBLOCK or O_NDELAY,
 286                            and these codes mean that there is no data to read at present. */
 287                         return true;
 288                 }
 289
 290                 /* Some other error has occurred. */
 291                 return false;
 292         }
 293 }
 294
 295
 296 static int buspirate_init(void)
 297 {
 298         if (buspirate_port == NULL) {
 299                 LOG_ERROR("You need to specify the serial port!");
 300                 return ERROR_JTAG_INIT_FAILED;
 301         }
 302
 303         buspirate_fd = buspirate_serial_open(buspirate_port);
 304         if (buspirate_fd == -1) {
 305                 LOG_ERROR("Could not open serial port");
 306                 return ERROR_JTAG_INIT_FAILED;
 307         }
 308
 309         /* The Operating System or the device itself may deliver stale data from the last connection,
 310            so discard all available bytes right after the new connection has been established.
 311            After all, we are implementing here a master/slave protocol, so the slave should have nothing
 312            to say until the master sends the first command.
 313
 314            In the past, there was a tcflush() call in buspirate_serial_setspeed(), but that
 315            was not enough. I guess you must actively read from the serial port to trigger any
 316            data collection from the device and/or lower USB layers. If you disable the serial port
 317            read timeout (if you set SHORT_TIMEOUT to 0), then the discarding does not work any more.
 318
 319            Note that we are lowering the serial port timeout for this first read operation,
 320            otherwise the normal initialisation would be delayed for too long. */
 321
 322         if (-1 == buspirate_serial_setspeed(buspirate_fd, SERIAL_NORMAL, SHORT_TIMEOUT)) {
 323                 LOG_ERROR("Error configuring the serial port.");
 324                 return ERROR_JTAG_INIT_FAILED;
 325         }
 326
 327         if (!read_and_discard_all_data(buspirate_fd)) {
 328                 LOG_ERROR("Error while attempting to discard any stale data right after establishing the connection.");
 329                 return ERROR_JTAG_INIT_FAILED;
 330         }
 331
 332         if (-1 == buspirate_serial_setspeed(buspirate_fd, SERIAL_NORMAL, NORMAL_TIMEOUT)) {
 333                 LOG_ERROR("Error configuring the serial port.");
 334                 return ERROR_JTAG_INIT_FAILED;
 335         }
 336
 337         buspirate_bbio_enable(buspirate_fd);
 338
 339         if (swd_mode || buspirate_baudrate != SERIAL_NORMAL)
 340                 buspirate_set_speed(buspirate_fd, SERIAL_FAST);
 341
 342         LOG_INFO("Buspirate %s Interface ready!", swd_mode ? "SWD" : "JTAG");
 343
 344         if (!swd_mode)
 345                 buspirate_tap_init();
 346
 347         buspirate_set_mode(buspirate_fd, buspirate_pinmode);
 348         buspirate_set_feature(buspirate_fd, FEATURE_VREG,
 349                 (buspirate_vreg == 1) ? ACTION_ENABLE : ACTION_DISABLE);
 350         buspirate_set_feature(buspirate_fd, FEATURE_PULLUP,
 351                 (buspirate_pullup == 1) ? ACTION_ENABLE : ACTION_DISABLE);
 352         buspirate_reset(0, 0);
 353
 354         return ERROR_OK;
 355 }
 356
 357 static int buspirate_quit(void)
 358 {
 359         LOG_INFO("Shutting down buspirate.");
 360         buspirate_set_mode(buspirate_fd, MODE_HIZ);
 361         buspirate_set_speed(buspirate_fd, SERIAL_NORMAL);
 362
 363         buspirate_jtag_reset(buspirate_fd);
 364
 365         buspirate_serial_close(buspirate_fd);
 366
 367         if (buspirate_port) {
 368                 free(buspirate_port);
 369                 buspirate_port = NULL;
 370         }
 371         return ERROR_OK;
 372 }
 373
 374 /* openocd command interface */
 375 COMMAND_HANDLER(buspirate_handle_adc_command)
 376 {
 377         if (buspirate_fd == -1)
 378                 return ERROR_OK;
 379
 380         /* unavailable in SWD mode */
 381         if (swd_mode)
 382                 return ERROR_OK;
 383
 384         /* send the command */
 385         buspirate_jtag_get_adcs(buspirate_fd);
 386
 387         return ERROR_OK;
 388
 389 }
 390
 391 COMMAND_HANDLER(buspirate_handle_vreg_command)
 392 {
 393         if (CMD_ARGC < 1)
 394                 return ERROR_COMMAND_SYNTAX_ERROR;
 395
 396         if (atoi(CMD_ARGV[0]) == 1)
 397                 buspirate_vreg = 1;
 398         else if (atoi(CMD_ARGV[0]) == 0)
 399                 buspirate_vreg = 0;
 400         else
 401                 LOG_ERROR("usage: buspirate_vreg <1|0>");
 402
 403         return ERROR_OK;
 404
 405 }
 406
 407 COMMAND_HANDLER(buspirate_handle_pullup_command)
 408 {
 409         if (CMD_ARGC < 1)
 410                 return ERROR_COMMAND_SYNTAX_ERROR;
 411
 412         if (atoi(CMD_ARGV[0]) == 1)
 413                 buspirate_pullup = 1;
 414         else if (atoi(CMD_ARGV[0]) == 0)
 415                 buspirate_pullup = 0;
 416         else
 417                 LOG_ERROR("usage: buspirate_pullup <1|0>");
 418
 419         return ERROR_OK;
 420
 421 }
 422
 423 COMMAND_HANDLER(buspirate_handle_led_command)
 424 {
 425         if (CMD_ARGC < 1)
 426                 return ERROR_COMMAND_SYNTAX_ERROR;
 427
 428         if (atoi(CMD_ARGV[0]) == 1) {
 429                 /* enable led */
 430                 buspirate_set_feature(buspirate_fd, FEATURE_LED,
 431                                 ACTION_ENABLE);
 432         } else if (atoi(CMD_ARGV[0]) == 0) {
 433                 /* disable led */
 434                 buspirate_set_feature(buspirate_fd, FEATURE_LED,
 435                                 ACTION_DISABLE);
 436         } else {
 437                 LOG_ERROR("usage: buspirate_led <1|0>");
 438         }
 439
 440         return ERROR_OK;
 441
 442 }
 443
 444 COMMAND_HANDLER(buspirate_handle_mode_command)
 445 {
 446         if (CMD_ARGC < 1)
 447                 return ERROR_COMMAND_SYNTAX_ERROR;
 448
 449         if (CMD_ARGV[0][0] == 'n')
 450                 buspirate_pinmode = MODE_JTAG;
 451         else if (CMD_ARGV[0][0] == 'o')
 452                 buspirate_pinmode = MODE_JTAG_OD;
 453         else
 454                 LOG_ERROR("usage: buspirate_mode <normal|open-drain>");
 455
 456         return ERROR_OK;
 457
 458 }
 459
 460 COMMAND_HANDLER(buspirate_handle_speed_command)
 461 {
 462         if (CMD_ARGC < 1)
 463                 return ERROR_COMMAND_SYNTAX_ERROR;
 464
 465         if (CMD_ARGV[0][0] == 'n')
 466                 buspirate_baudrate = SERIAL_NORMAL;
 467         else if (CMD_ARGV[0][0] == 'f')
 468                 buspirate_baudrate = SERIAL_FAST;
 469         else
 470                 LOG_ERROR("usage: buspirate_speed <normal|fast>");
 471
 472         return ERROR_OK;
 473
 474 }
 475
 476 COMMAND_HANDLER(buspirate_handle_port_command)
 477 {
 478         if (CMD_ARGC < 1)
 479                 return ERROR_COMMAND_SYNTAX_ERROR;
 480
 481         if (buspirate_port == NULL)
 482                 buspirate_port = strdup(CMD_ARGV[0]);
 483
 484         return ERROR_OK;
 485
 486 }
 487
 488 static const struct command_registration buspirate_command_handlers[] = {
 489         {
 490                 .name = "buspirate_adc",
 491                 .handler = &buspirate_handle_adc_command,
 492                 .mode = COMMAND_EXEC,
 493                 .help = "reads voltages on adc pins",
 494                 .usage = "",
 495         },
 496         {
 497                 .name = "buspirate_vreg",
 498                 .usage = "<1|0>",
 499                 .handler = &buspirate_handle_vreg_command,
 500                 .mode = COMMAND_CONFIG,
 501                 .help = "changes the state of voltage regulators",
 502         },
 503         {
 504                 .name = "buspirate_pullup",
 505                 .usage = "<1|0>",
 506                 .handler = &buspirate_handle_pullup_command,
 507                 .mode = COMMAND_CONFIG,
 508                 .help = "changes the state of pullup",
 509         },
 510         {
 511                 .name = "buspirate_led",
 512                 .usage = "<1|0>",
 513                 .handler = &buspirate_handle_led_command,
 514                 .mode = COMMAND_EXEC,
 515                 .help = "changes the state of led",
 516         },
 517         {
 518                 .name = "buspirate_speed",
 519                 .usage = "<normal|fast>",
 520                 .handler = &buspirate_handle_speed_command,
 521                 .mode = COMMAND_CONFIG,
 522                 .help = "speed of the interface",
 523         },
 524         {
 525                 .name = "buspirate_mode",
 526                 .usage = "<normal|open-drain>",
 527                 .handler = &buspirate_handle_mode_command,
 528                 .mode = COMMAND_CONFIG,
 529                 .help = "pin mode of the interface",
 530         },
 531         {
 532                 .name = "buspirate_port",
 533                 .usage = "/dev/ttyUSB0",
 534                 .handler = &buspirate_handle_port_command,
 535                 .mode = COMMAND_CONFIG,
 536                 .help = "name of the serial port to open",
 537         },
 538         COMMAND_REGISTRATION_DONE
 539 };
 540
 541 static const struct swd_driver buspirate_swd = {
 542         .init = buspirate_swd_init,
 543         .switch_seq = buspirate_swd_switch_seq,
 544         .read_reg = buspirate_swd_read_reg,
 545         .write_reg = buspirate_swd_write_reg,
 546         .run = buspirate_swd_run_queue,
 547 };
 548
 549 static const char * const buspirate_transports[] = { "jtag", "swd", NULL };
 550
 551 struct jtag_interface buspirate_interface = {
 552         .name = "buspirate",
 553         .execute_queue = buspirate_execute_queue,
 554         .commands = buspirate_command_handlers,
 555         .transports = buspirate_transports,
 556         .swd = &buspirate_swd,
 557         .init = buspirate_init,
 558         .quit = buspirate_quit
 559 };
 560
 561 /*************** jtag execute commands **********************/
 562 static void buspirate_end_state(tap_state_t state)
 563 {
 564         if (tap_is_state_stable(state))
 565                 tap_set_end_state(state);
 566         else {
 567                 LOG_ERROR("BUG: %i is not a valid end state", state);
 568                 exit(-1);
 569         }
 570 }
 571
 572 static void buspirate_state_move(void)
 573 {
 574         int i = 0, tms = 0;
 575         uint8_t tms_scan = tap_get_tms_path(tap_get_state(),
 576                         tap_get_end_state());
 577         int tms_count = tap_get_tms_path_len(tap_get_state(),
 578                         tap_get_end_state());
 579
 580         for (i = 0; i < tms_count; i++) {
 581                 tms = (tms_scan >> i) & 1;
 582                 buspirate_tap_append(tms, 0);
 583         }
 584
 585         tap_set_state(tap_get_end_state());
 586 }
 587
 588 static void buspirate_path_move(int num_states, tap_state_t *path)
 589 {
 590         int i;
 591
 592         for (i = 0; i < num_states; i++) {
 593                 if (tap_state_transition(tap_get_state(), false) == path[i]) {
 594                         buspirate_tap_append(0, 0);
 595                 } else if (tap_state_transition(tap_get_state(), true)
 596                                 == path[i]) {
 597                         buspirate_tap_append(1, 0);
 598                 } else {
 599                         LOG_ERROR("BUG: %s -> %s isn't a valid "
 600                                 "TAP transition",
 601                                 tap_state_name(tap_get_state()),
 602                                 tap_state_name(path[i]));
 603                         exit(-1);
 604                 }
 605
 606                 tap_set_state(path[i]);
 607         }
 608
 609         tap_set_end_state(tap_get_state());
 610 }
 611
 612 static void buspirate_runtest(int num_cycles)
 613 {
 614         int i;
 615
 616         tap_state_t saved_end_state = tap_get_end_state();
 617
 618         /* only do a state_move when we're not already in IDLE */
 619         if (tap_get_state() != TAP_IDLE) {
 620                 buspirate_end_state(TAP_IDLE);
 621                 buspirate_state_move();
 622         }
 623
 624         for (i = 0; i < num_cycles; i++)
 625                 buspirate_tap_append(0, 0);
 626
 627         LOG_DEBUG_IO("runtest: cur_state %s end_state %s",
 628                         tap_state_name(tap_get_state()),
 629                         tap_state_name(tap_get_end_state()));
 630
 631         /* finish in end_state */
 632         buspirate_end_state(saved_end_state);
 633         if (tap_get_state() != tap_get_end_state())
 634                 buspirate_state_move();
 635 }
 636
 637 static void buspirate_scan(bool ir_scan, enum scan_type type,
 638         uint8_t *buffer, int scan_size, struct scan_command *command)
 639 {
 640         tap_state_t saved_end_state;
 641
 642         buspirate_tap_make_space(1, scan_size+8);
 643         /* is 8 correct ? (2 moves = 16) */
 644
 645         saved_end_state = tap_get_end_state();
 646
 647         buspirate_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
 648
 649         /* Only move if we're not already there */
 650         if (tap_get_state() != tap_get_end_state())
 651                 buspirate_state_move();
 652
 653         buspirate_tap_append_scan(scan_size, buffer, command);
 654
 655         /* move to PAUSE */
 656         buspirate_tap_append(0, 0);
 657
 658         /* restore the saved state */
 659         buspirate_end_state(saved_end_state);
 660         tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
 661
 662         if (tap_get_state() != tap_get_end_state())
 663                 buspirate_state_move();
 664 }
 665
 666 static void buspirate_stableclocks(int num_cycles)
 667 {
 668         int i;
 669         int tms = (tap_get_state() == TAP_RESET ? 1 : 0);
 670
 671         buspirate_tap_make_space(0, num_cycles);
 672
 673         for (i = 0; i < num_cycles; i++)
 674                 buspirate_tap_append(tms, 0);
 675 }
 676
 677 /************************* TAP related stuff **********/
 678
 679 /* This buffer size matches the maximum CMD_TAP_SHIFT bit length in the Bus Pirate firmware,
 680    look for constant 0x2000 in OpenOCD.c . */
 681 #define BUSPIRATE_BUFFER_SIZE 1024
 682
 683 /* The old value of 32 scans was not enough to achieve near 100% utilisation ratio
 684    for the current BUSPIRATE_BUFFER_SIZE value of 1024.
 685    With 128 scans I am getting full USB 2.0 high speed packets (512 bytes long) when
 686    using the JtagDue firmware on the Arduino Due instead of the Bus Pirate, which
 687    amounts approximately to a 10% overall speed gain. Bigger packets should also
 688    benefit the Bus Pirate, but the speed difference is much smaller.
 689    Unfortunately, each 512-byte packet is followed by a 329-byte one, which is not ideal.
 690    However, increasing BUSPIRATE_BUFFER_SIZE for the benefit of the JtagDue would
 691    make it incompatible with the Bus Pirate firmware. */
 692 #define BUSPIRATE_MAX_PENDING_SCANS 128
 693
 694 static uint8_t tms_chain[BUSPIRATE_BUFFER_SIZE]; /* send */
 695 static uint8_t tdi_chain[BUSPIRATE_BUFFER_SIZE]; /* send */
 696 static int tap_chain_index;
 697
 698 struct pending_scan_result /* this was stolen from arm-jtag-ew */
 699 {
 700         int first; /* First bit position in tdo_buffer to read */
 701         int length; /* Number of bits to read */
 702         struct scan_command *command; /* Corresponding scan command */
 703         uint8_t *buffer;
 704 };
 705
 706 static struct pending_scan_result
 707 tap_pending_scans[BUSPIRATE_MAX_PENDING_SCANS];
 708 static int tap_pending_scans_num;
 709
 710 static void buspirate_tap_init(void)
 711 {
 712         tap_chain_index = 0;
 713         tap_pending_scans_num = 0;
 714 }
 715
 716 static int buspirate_tap_execute(void)
 717 {
 718         static const int CMD_TAP_SHIFT_HEADER_LEN = 3;
 719
 720         uint8_t tmp[4096];
 721         uint8_t *in_buf;
 722         int i;
 723         int fill_index = 0;
 724         int ret;
 725         int bytes_to_send;
 726
 727         if (tap_chain_index <= 0)
 728                 return ERROR_OK;
 729
 730         LOG_DEBUG("executing tap num bits = %i scans = %i",
 731                         tap_chain_index, tap_pending_scans_num);
 732
 733         bytes_to_send = DIV_ROUND_UP(tap_chain_index, 8);
 734
 735         tmp[0] = CMD_TAP_SHIFT; /* this command expects number of bits */
 736         tmp[1] = tap_chain_index >> 8;  /* high */
 737         tmp[2] = tap_chain_index;  /* low */
 738
 739         fill_index = CMD_TAP_SHIFT_HEADER_LEN;
 740         for (i = 0; i < bytes_to_send; i++) {
 741                 tmp[fill_index] = tdi_chain[i];
 742                 fill_index++;
 743                 tmp[fill_index] = tms_chain[i];
 744                 fill_index++;
 745         }
 746
 747         /* jlink.c calls the routine below, which may be useful for debugging purposes.
 748            For example, enabling this allows you to compare the log outputs from jlink.c
 749            and from this module for JTAG development or troubleshooting purposes. */
 750         if (false) {
 751                 last_tap_state = jtag_debug_state_machine(tms_chain, tdi_chain,
 752                                                                                                   tap_chain_index, last_tap_state);
 753         }
 754
 755         ret = buspirate_serial_write(buspirate_fd, tmp, CMD_TAP_SHIFT_HEADER_LEN + bytes_to_send*2);
 756         if (ret != bytes_to_send*2+CMD_TAP_SHIFT_HEADER_LEN) {
 757                 LOG_ERROR("error writing :(");
 758                 return ERROR_JTAG_DEVICE_ERROR;
 759         }
 760
 761         ret = buspirate_serial_read(buspirate_fd, tmp, bytes_to_send + CMD_TAP_SHIFT_HEADER_LEN);
 762         if (ret != bytes_to_send + CMD_TAP_SHIFT_HEADER_LEN) {
 763                 LOG_ERROR("error reading");
 764                 return ERROR_FAIL;
 765         }
 766         in_buf = (uint8_t *)(&tmp[CMD_TAP_SHIFT_HEADER_LEN]);
 767
 768         /* parse the scans */
 769         for (i = 0; i < tap_pending_scans_num; i++) {
 770                 uint8_t *buffer = tap_pending_scans[i].buffer;
 771                 int length = tap_pending_scans[i].length;
 772                 int first = tap_pending_scans[i].first;
 773                 struct scan_command *command = tap_pending_scans[i].command;
 774
 775                 /* copy bits from buffer */
 776                 buf_set_buf(in_buf, first, buffer, 0, length);
 777
 778                 /* return buffer to higher level */
 779                 if (jtag_read_buffer(buffer, command) != ERROR_OK) {
 780                         buspirate_tap_init();
 781                         return ERROR_JTAG_QUEUE_FAILED;
 782                 }
 783
 784                 free(buffer);
 785         }
 786         buspirate_tap_init();
 787         return ERROR_OK;
 788 }
 789
 790 static void buspirate_tap_make_space(int scans, int bits)
 791 {
 792         int have_scans = BUSPIRATE_MAX_PENDING_SCANS - tap_pending_scans_num;
 793         int have_bits = BUSPIRATE_BUFFER_SIZE * 8 - tap_chain_index;
 794
 795         if ((have_scans < scans) || (have_bits < bits))
 796                 buspirate_tap_execute();
 797 }
 798
 799 static void buspirate_tap_append(int tms, int tdi)
 800 {
 801         int chain_index;
 802
 803         buspirate_tap_make_space(0, 1);
 804         chain_index = tap_chain_index / 8;
 805
 806         if (chain_index < BUSPIRATE_BUFFER_SIZE) {
 807                 int bit_index = tap_chain_index % 8;
 808                 uint8_t bit = 1 << bit_index;
 809
 810                 if (0 == bit_index) {
 811                         /* Let's say that the TAP shift operation wants to shift 9 bits,
 812                            so we will be sending to the Bus Pirate a bit count of 9 but still
 813                            full 16 bits (2 bytes) of shift data.
 814                            If we don't clear all bits at this point, the last 7 bits will contain
 815                            random data from the last buffer contents, which is not pleasant to the eye.
 816                            Besides, the Bus Pirate (or some clone) may want to assert in debug builds
 817                            that, after consuming all significant data bits, the rest of them are zero.
 818                            Therefore, for aesthetic and for assert purposes, we clear all bits below. */
 819                         tms_chain[chain_index] = 0;
 820                         tdi_chain[chain_index] = 0;
 821                 }
 822
 823                 if (tms)
 824                         tms_chain[chain_index] |= bit;
 825                 else
 826                         tms_chain[chain_index] &= ~bit;
 827
 828                 if (tdi)
 829                         tdi_chain[chain_index] |= bit;
 830                 else
 831                         tdi_chain[chain_index] &= ~bit;
 832
 833                 tap_chain_index++;
 834         } else {
 835                 LOG_ERROR("tap_chain overflow, bad things will happen");
 836                 /* Exit abruptly, like jlink.c does. After a buffer overflow we don't want
 837                    to carry on, as data will be corrupt. Another option would be to return
 838                    some error code at this point. */
 839                 exit(-1);
 840         }
 841 }
 842
 843 static void buspirate_tap_append_scan(int length, uint8_t *buffer,
 844                 struct scan_command *command)
 845 {
 846         int i;
 847         tap_pending_scans[tap_pending_scans_num].length = length;
 848         tap_pending_scans[tap_pending_scans_num].buffer = buffer;
 849         tap_pending_scans[tap_pending_scans_num].command = command;
 850         tap_pending_scans[tap_pending_scans_num].first = tap_chain_index;
 851
 852         for (i = 0; i < length; i++) {
 853                 int tms = (i < length-1 ? 0 : 1);
 854                 int tdi = (buffer[i/8] >> (i%8)) & 1;
 855                 buspirate_tap_append(tms, tdi);
 856         }
 857         tap_pending_scans_num++;
 858 }
 859
 860 /*************** wrapper functions *********************/
 861
 862 /* (1) assert or (0) deassert reset lines */
 863 static void buspirate_reset(int trst, int srst)
 864 {
 865         LOG_DEBUG("trst: %i, srst: %i", trst, srst);
 866
 867         if (trst)
 868                 buspirate_set_feature(buspirate_fd, FEATURE_TRST, ACTION_DISABLE);
 869         else
 870                 buspirate_set_feature(buspirate_fd, FEATURE_TRST, ACTION_ENABLE);
 871
 872         if (srst)
 873                 buspirate_set_feature(buspirate_fd, FEATURE_SRST, ACTION_DISABLE);
 874         else
 875                 buspirate_set_feature(buspirate_fd, FEATURE_SRST, ACTION_ENABLE);
 876 }
 877
 878 static void buspirate_set_feature(int fd, char feat, char action)
 879 {
 880         if (swd_mode)
 881                 buspirate_swd_set_feature(fd, feat, action);
 882         else
 883                 buspirate_jtag_set_feature(fd, feat, action);
 884 }
 885
 886 static void buspirate_set_mode(int fd, char mode)
 887 {
 888         if (swd_mode)
 889                 buspirate_swd_set_mode(fd, mode);
 890         else
 891                 buspirate_jtag_set_mode(fd, mode);
 892 }
 893
 894 static void buspirate_set_speed(int fd, char speed)
 895 {
 896         if (swd_mode)
 897                 buspirate_swd_set_speed(fd, speed);
 898         else
 899                 buspirate_jtag_set_speed(fd, speed);
 900 }
 901
 902
 903 /*************** swd lowlevel functions ********************/
 904
 905 static void buspirate_swd_set_speed(int fd, char speed)
 906 {
 907         int  ret;
 908         uint8_t tmp[1];
 909
 910         LOG_DEBUG("Buspirate speed setting in SWD mode defaults to 400 kHz");
 911
 912         /* speed settings */
 913         tmp[0] = CMD_RAW_SPEED | SPEED_RAW_400_KHZ;
 914         buspirate_serial_write(fd, tmp, 1);
 915         ret = buspirate_serial_read(fd, tmp, 1);
 916         if (ret != 1) {
 917                 LOG_ERROR("Buspirate did not answer correctly");
 918                 exit(-1);
 919         }
 920         if (tmp[0] != 1) {
 921                 LOG_ERROR("Buspirate did not reply as expected to the speed change command");
 922                 exit(-1);
 923         }
 924 }
 925
 926 static void buspirate_swd_set_mode(int fd, char mode)
 927 {
 928         int ret;
 929         uint8_t tmp[1];
 930
 931         /* raw-wire mode configuration */
 932         if (mode == MODE_HIZ)
 933                 tmp[0] = CMD_RAW_MODE | CMD_RAW_CONFIG_LSB;
 934         else
 935                 tmp[0] = CMD_RAW_MODE | CMD_RAW_CONFIG_LSB | CMD_RAW_CONFIG_3V3;
 936
 937         buspirate_serial_write(fd, tmp, 1);
 938         ret = buspirate_serial_read(fd, tmp, 1);
 939         if (ret != 1) {
 940                 LOG_ERROR("Buspirate did not answer correctly");
 941                 exit(-1);
 942         }
 943         if (tmp[0] != 1) {
 944                 LOG_ERROR("Buspirate did not reply as expected to the configure command");
 945                 exit(-1);
 946         }
 947 }
 948
 949 static void buspirate_swd_set_feature(int fd, char feat, char action)
 950 {
 951         int  ret;
 952         uint8_t tmp[1];
 953
 954         switch (feat) {
 955                 case FEATURE_TRST:
 956                         LOG_DEBUG("Buspirate TRST feature not available in SWD mode");
 957                         return;
 958                 case FEATURE_LED:
 959                         LOG_ERROR("Buspirate LED feature not available in SWD mode");
 960                         return;
 961                 case FEATURE_SRST:
 962                         swd_features = (action == ACTION_ENABLE) ? swd_features | 0x02 : swd_features & 0x0D;
 963                         break;
 964                 case FEATURE_PULLUP:
 965                         swd_features = (action == ACTION_ENABLE) ? swd_features | 0x04 : swd_features & 0x0B;
 966                         break;
 967                 case FEATURE_VREG:
 968                         swd_features = (action == ACTION_ENABLE) ? swd_features | 0x08 : swd_features & 0x07;
 969                         break;
 970                 default:
 971                         LOG_DEBUG("Buspirate unknown feature %d", feat);
 972                         return;
 973         }
 974
 975         tmp[0] = CMD_RAW_PERIPH | swd_features;
 976         buspirate_serial_write(fd, tmp, 1);
 977         ret = buspirate_serial_read(fd, tmp, 1);
 978         if (ret != 1) {
 979                 LOG_DEBUG("Buspirate feature %d not supported in SWD mode", feat);
 980         } else if (tmp[0] != 1) {
 981                 LOG_ERROR("Buspirate did not reply as expected to the configure command");
 982                 exit(-1);
 983         }
 984 }
 985
 986 /*************** jtag lowlevel functions ********************/
 987 static void buspirate_bbio_enable(int fd)
 988 {
 989         int ret;
 990         char command;
 991         const char *mode_answers[2] = { "OCD1", "RAW1" };
 992         const char *correct_ans     = NULL;
 993         uint8_t tmp[21] = { [0 ... 20] = 0x00 };
 994         int done = 0;
 995         int cmd_sent = 0;
 996
 997         if (swd_mode) {
 998                 command     = CMD_ENTER_RWIRE;
 999                 correct_ans = mode_answers[1];
1000         } else {
1001                 command     = CMD_ENTER_OOCD;
1002                 correct_ans = mode_answers[0];
1003         }
1004
1005         LOG_DEBUG("Entering binary mode, that is %s", correct_ans);
1006         buspirate_serial_write(fd, tmp, 20);
1007         usleep(10000);
1008
1009         /* reads 1 to n "BBIO1"s and one "OCD1" or "RAW1" */
1010         while (!done) {
1011                 ret = buspirate_serial_read(fd, tmp, 4);
1012                 if (ret != 4) {
1013                         LOG_ERROR("Buspirate error. Is binary"
1014                                 "/OpenOCD support enabled?");
1015                         exit(-1);
1016                 }
1017                 if (strncmp((char *)tmp, "BBIO", 4) == 0) {
1018                         ret = buspirate_serial_read(fd, tmp, 1);
1019                         if (ret != 1) {
1020                                 LOG_ERROR("Buspirate did not answer correctly! "
1021                                         "Do you have correct firmware?");
1022                                 exit(-1);
1023                         }
1024                         if (tmp[0] != '1') {
1025                                 LOG_ERROR("Unsupported binary protocol");
1026                                 exit(-1);
1027                         }
1028                         if (cmd_sent == 0) {
1029                                 cmd_sent = 1;
1030                                 tmp[0] = command;
1031                                 ret = buspirate_serial_write(fd, tmp, 1);
1032                                 if (ret != 1) {
1033                                         LOG_ERROR("error reading");
1034                                         exit(-1);
1035                                 }
1036                         }
1037                 } else if (strncmp((char *)tmp, correct_ans, 4) == 0)
1038                         done = 1;
1039                 else {
1040                         LOG_ERROR("Buspirate did not answer correctly! "
1041                                 "Do you have correct firmware?");
1042                         exit(-1);
1043                 }
1044         }
1045
1046 }
1047
1048 static void buspirate_jtag_reset(int fd)
1049 {
1050         uint8_t tmp[5];
1051
1052         tmp[0] = 0x00; /* exit OCD1 mode */
1053         buspirate_serial_write(fd, tmp, 1);
1054         usleep(10000);
1055         /* We ignore the return value here purposly, nothing we can do */
1056         buspirate_serial_read(fd, tmp, 5);
1057         if (strncmp((char *)tmp, "BBIO1", 5) == 0) {
1058                 tmp[0] = 0x0F; /*  reset BP */
1059                 buspirate_serial_write(fd, tmp, 1);
1060         } else
1061                 LOG_ERROR("Unable to restart buspirate!");
1062 }
1063
1064 static void buspirate_jtag_set_speed(int fd, char speed)
1065 {
1066         int ret;
1067         uint8_t tmp[2];
1068         uint8_t ack[2];
1069
1070         ack[0] = 0xAA;
1071         ack[1] = 0x55;
1072
1073         tmp[0] = CMD_UART_SPEED;
1074         tmp[1] = speed;
1075         buspirate_jtag_command(fd, tmp, 2);
1076
1077         /* here the adapter changes speed, we need follow */
1078         if (-1 == buspirate_serial_setspeed(fd, speed, NORMAL_TIMEOUT)) {
1079                 LOG_ERROR("Error configuring the serial port.");
1080                 exit(-1);
1081         }
1082
1083         buspirate_serial_write(fd, ack, 2);
1084         ret = buspirate_serial_read(fd, tmp, 2);
1085         if (ret != 2) {
1086                 LOG_ERROR("Buspirate did not ack speed change");
1087                 exit(-1);
1088         }
1089         if ((tmp[0] != CMD_UART_SPEED) || (tmp[1] != speed)) {
1090                 LOG_ERROR("Buspirate did not reply as expected to the speed change command");
1091                 exit(-1);
1092         }
1093         LOG_INFO("Buspirate switched to %s mode",
1094                 (speed == SERIAL_NORMAL) ? "normal" : "FAST");
1095 }
1096
1097
1098 static void buspirate_jtag_set_mode(int fd, char mode)
1099 {
1100         uint8_t tmp[2];
1101         tmp[0] = CMD_PORT_MODE;
1102         tmp[1] = mode;
1103         buspirate_jtag_command(fd, tmp, 2);
1104 }
1105
1106 static void buspirate_jtag_set_feature(int fd, char feat, char action)
1107 {
1108         uint8_t tmp[3];
1109         tmp[0] = CMD_FEATURE;
1110         tmp[1] = feat;   /* what */
1111         tmp[2] = action; /* action */
1112         buspirate_jtag_command(fd, tmp, 3);
1113 }
1114
1115 static void buspirate_jtag_get_adcs(int fd)
1116 {
1117         uint8_t tmp[10];
1118         uint16_t a, b, c, d;
1119         tmp[0] = CMD_READ_ADCS;
1120         buspirate_jtag_command(fd, tmp, 1);
1121         a = tmp[2] << 8 | tmp[3];
1122         b = tmp[4] << 8 | tmp[5];
1123         c = tmp[6] << 8 | tmp[7];
1124         d = tmp[8] << 8 | tmp[9];
1125
1126         LOG_INFO("ADC: ADC_Pin = %.02f VPullup = %.02f V33 = %.02f "
1127                 "V50 = %.02f",
1128                 ((float)a)/155.1515, ((float)b)/155.1515,
1129                 ((float)c)/155.1515, ((float)d)/155.1515);
1130 }
1131
1132 static unsigned char buspirate_jtag_command(int fd,
1133                 uint8_t *cmd, int cmdlen)
1134 {
1135         int res;
1136         int len = 0;
1137
1138         res = buspirate_serial_write(fd, cmd, cmdlen);
1139
1140         if ((cmd[0] == CMD_UART_SPEED)
1141                                 || (cmd[0] == CMD_PORT_MODE)
1142                                 || (cmd[0] == CMD_FEATURE)
1143                                 || (cmd[0] == CMD_JTAG_SPEED))
1144                 return 1;
1145
1146         if (res == cmdlen) {
1147                 switch (cmd[0]) {
1148                 case CMD_READ_ADCS:
1149                         len = 10; /* 2*sizeof(char)+4*sizeof(uint16_t) */
1150                         break;
1151                 case CMD_TAP_SHIFT:
1152                         len = cmdlen;
1153                         break;
1154                 default:
1155                         LOG_INFO("Wrong !");
1156                 }
1157                 res =  buspirate_serial_read(fd, cmd, len);
1158                 if (res > 0)
1159                         return (unsigned char)cmd[1];
1160                 else
1161                         return -1;
1162         } else
1163                 return -1;
1164         return 0;
1165 }
1166
1167 /* low level serial port */
1168 /* TODO add support for WIN32 and others ! */
1169 static int buspirate_serial_open(char *port)
1170 {
1171         int fd;
1172         fd = open(buspirate_port, O_RDWR | O_NOCTTY | O_NDELAY);
1173         return fd;
1174 }
1175
1176
1177 /* Returns -1 on error. */
1178
1179 static int buspirate_serial_setspeed(int fd, char speed, cc_t timeout)
1180 {
1181         struct termios t_opt;
1182         speed_t baud = (speed == SERIAL_FAST) ? B1000000 : B115200;
1183
1184         /* set the serial port parameters */
1185         fcntl(fd, F_SETFL, 0);
1186         if (0 != tcgetattr(fd, &t_opt))
1187                 return -1;
1188
1189         if (0 != cfsetispeed(&t_opt, baud))
1190                 return -1;
1191
1192         if (0 != cfsetospeed(&t_opt, baud))
1193                 return -1;
1194
1195         t_opt.c_cflag |= (CLOCAL | CREAD);
1196         t_opt.c_cflag &= ~PARENB;
1197         t_opt.c_cflag &= ~CSTOPB;
1198         t_opt.c_cflag &= ~CSIZE;
1199         t_opt.c_cflag |= CS8;
1200         t_opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
1201
1202         /* The serial port may have been configured for human interaction with
1203            the Bus Pirate console, but OpenOCD is going to use a binary protocol,
1204            so make sure to turn off any CR/LF translation and the like. */
1205         t_opt.c_iflag &= ~(IXON | IXOFF | IXANY | INLCR | ICRNL);
1206
1207         t_opt.c_oflag &= ~OPOST;
1208         t_opt.c_cc[VMIN] = 0;
1209         t_opt.c_cc[VTIME] = timeout;
1210
1211         /* Note that, in the past, TCSANOW was used below instead of TCSADRAIN,
1212            and CMD_UART_SPEED did not work properly then, at least with
1213            the Bus Pirate v3.5 (USB). */
1214         if (0 != tcsetattr(fd, TCSADRAIN, &t_opt)) {
1215                 /* According to the Linux documentation, this is actually not enough
1216                    to detect errors, you need to call tcgetattr() and check that
1217                    all changes have been performed successfully. */
1218                 return -1;
1219         }
1220
1221         return 0;
1222 }
1223
1224 static int buspirate_serial_write(int fd, uint8_t *buf, int size)
1225 {
1226         int ret = 0;
1227
1228         ret = write(fd, buf, size);
1229
1230         LOG_DEBUG("size = %d ret = %d", size, ret);
1231         buspirate_print_buffer(buf, size);
1232
1233         if (ret != size)
1234                 LOG_ERROR("Error sending data");
1235
1236         return ret;
1237 }
1238
1239 static int buspirate_serial_read(int fd, uint8_t *buf, int size)
1240 {
1241         int len = 0;
1242         int ret = 0;
1243         int timeout = 0;
1244
1245         while (len < size) {
1246                 ret = read(fd, buf+len, size-len);
1247                 if (ret == -1)
1248                         return -1;
1249
1250                 if (ret == 0) {
1251                         timeout++;
1252
1253                         if (timeout >= 10)
1254                                 break;
1255
1256                         continue;
1257                 }
1258
1259                 len += ret;
1260         }
1261
1262         LOG_DEBUG("should have read = %d actual size = %d", size, len);
1263         buspirate_print_buffer(buf, len);
1264
1265         if (len != size)
1266                 LOG_ERROR("Error reading data");
1267
1268         return len;
1269 }
1270
1271 static void buspirate_serial_close(int fd)
1272 {
1273         close(fd);
1274 }
1275
1276 #define LINE_SIZE      81
1277 #define BYTES_PER_LINE 16
1278 static void buspirate_print_buffer(uint8_t *buf, int size)
1279 {
1280         char line[LINE_SIZE];
1281         char tmp[10];
1282         int offset = 0;
1283
1284         line[0] = 0;
1285         while (offset < size) {
1286                 snprintf(tmp, 5, "%02x ", (uint8_t)buf[offset]);
1287                 offset++;
1288
1289                 strcat(line, tmp);
1290
1291                 if (offset % BYTES_PER_LINE == 0) {
1292                         LOG_DEBUG("%s", line);
1293                         line[0] = 0;
1294                 }
1295         }
1296
1297         if (line[0] != 0)
1298                 LOG_DEBUG("%s", line);
1299 }
1300
1301 /************************* SWD related stuff **********/
1302
1303 static int buspirate_swd_init(void)
1304 {
1305         LOG_INFO("Buspirate SWD mode enabled");
1306         swd_mode = true;
1307
1308         return ERROR_OK;
1309 }
1310
1311 static int buspirate_swd_switch_seq(enum swd_special_seq seq)
1312 {
1313         const uint8_t *sequence;
1314         int sequence_len;
1315         uint8_t tmp[64];
1316
1317         switch (seq) {
1318         case LINE_RESET:
1319                 LOG_DEBUG("SWD line reset");
1320                 sequence = swd_seq_line_reset;
1321                 sequence_len = DIV_ROUND_UP(swd_seq_line_reset_len, 8);
1322                 break;
1323         case JTAG_TO_SWD:
1324                 LOG_DEBUG("JTAG-to-SWD");
1325                 sequence = swd_seq_jtag_to_swd;
1326                 sequence_len = DIV_ROUND_UP(swd_seq_jtag_to_swd_len, 8);
1327                 break;
1328         case SWD_TO_JTAG:
1329                 LOG_DEBUG("SWD-to-JTAG");
1330                 sequence = swd_seq_swd_to_jtag;
1331                 sequence_len = DIV_ROUND_UP(swd_seq_swd_to_jtag_len, 8);
1332                 break;
1333         default:
1334                 LOG_ERROR("Sequence %d not supported", seq);
1335                 return ERROR_FAIL;
1336         }
1337
1338         /* FIXME: all above sequences fit into one pirate command for now
1339          *        but it may cause trouble later
1340          */
1341
1342         tmp[0] = 0x10 + ((sequence_len - 1) & 0x0F);
1343         memcpy(tmp + 1, sequence, sequence_len);
1344
1345         buspirate_serial_write(buspirate_fd, tmp, sequence_len + 1);
1346         buspirate_serial_read(buspirate_fd, tmp, sequence_len + 1);
1347
1348         return ERROR_OK;
1349 }
1350
1351 static uint8_t buspirate_swd_write_header(uint8_t cmd)
1352 {
1353         uint8_t tmp[8];
1354         int  to_send;
1355
1356         tmp[0] = 0x10; /* bus pirate: send 1 byte */
1357         tmp[1] = cmd;  /* swd cmd */
1358         tmp[2] = 0x07; /* ack __x */
1359         tmp[3] = 0x07; /* ack _x_ */
1360         tmp[4] = 0x07; /* ack x__ */
1361         tmp[5] = 0x07; /* write mode trn_1 */
1362         tmp[6] = 0x07; /* write mode trn_2 */
1363
1364         to_send = ((cmd & SWD_CMD_RnW) == 0) ? 7 : 5;
1365         buspirate_serial_write(buspirate_fd, tmp, to_send);
1366
1367         /* read ack */
1368         buspirate_serial_read(buspirate_fd, tmp, 2); /* drop pirate command ret vals */
1369         buspirate_serial_read(buspirate_fd, tmp, to_send - 2); /* ack bits */
1370
1371         return tmp[2] << 2 | tmp[1] << 1 | tmp[0];
1372 }
1373
1374 static void buspirate_swd_idle_clocks(uint32_t no_bits)
1375 {
1376         uint32_t no_bytes;
1377         uint8_t tmp[20];
1378
1379         no_bytes = (no_bits + 7) / 8;
1380         memset(tmp + 1, 0x00, sizeof(tmp) - 1);
1381
1382         /* unfortunately bus pirate misbehaves when clocks are sent in parts
1383          * so we need to limit at 128 clock cycles
1384          */
1385         if (no_bytes > 16)
1386                 no_bytes = 16;
1387
1388         while (no_bytes) {
1389                 uint8_t to_send = no_bytes > 16 ? 16 : no_bytes;
1390                 tmp[0] = 0x10 + ((to_send - 1) & 0x0F);
1391
1392                 buspirate_serial_write(buspirate_fd, tmp, to_send + 1);
1393                 buspirate_serial_read(buspirate_fd, tmp, to_send + 1);
1394
1395                 no_bytes -= to_send;
1396         }
1397 }
1398
1399 static void buspirate_swd_clear_sticky_errors(void)
1400 {
1401         buspirate_swd_write_reg(swd_cmd(false,  false, DP_ABORT),
1402                 STKCMPCLR | STKERRCLR | WDERRCLR | ORUNERRCLR, 0);
1403 }
1404
1405 static void buspirate_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
1406 {
1407         uint8_t tmp[16];
1408
1409         LOG_DEBUG("buspirate_swd_read_reg");
1410         assert(cmd & SWD_CMD_RnW);
1411
1412         if (queued_retval != ERROR_OK) {
1413                 LOG_DEBUG("Skip buspirate_swd_read_reg because queued_retval=%d", queued_retval);
1414                 return;
1415         }
1416
1417         cmd |= SWD_CMD_START | SWD_CMD_PARK;
1418         uint8_t ack = buspirate_swd_write_header(cmd);
1419
1420         /* do a read transaction */
1421         tmp[0] = 0x06; /* 4 data bytes */
1422         tmp[1] = 0x06;
1423         tmp[2] = 0x06;
1424         tmp[3] = 0x06;
1425         tmp[4] = 0x07; /* parity bit */
1426         tmp[5] = 0x21; /* 2 turnaround clocks */
1427
1428         buspirate_serial_write(buspirate_fd, tmp, 6);
1429         buspirate_serial_read(buspirate_fd, tmp, 6);
1430
1431         /* store the data and parity */
1432         uint32_t data = (uint8_t) tmp[0];
1433         data |= (uint8_t) tmp[1] << 8;
1434         data |= (uint8_t) tmp[2] << 16;
1435         data |= (uint8_t) tmp[3] << 24;
1436         int parity = tmp[4] ? 0x01 : 0x00;
1437
1438         LOG_DEBUG("%s %s %s reg %X = %08"PRIx32,
1439                         ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
1440                         cmd & SWD_CMD_APnDP ? "AP" : "DP",
1441                         cmd & SWD_CMD_RnW ? "read" : "write",
1442                         (cmd & SWD_CMD_A32) >> 1,
1443                         data);
1444
1445         switch (ack) {
1446          case SWD_ACK_OK:
1447                 if (parity != parity_u32(data)) {
1448                         LOG_DEBUG("Read data parity mismatch %x %x", parity, parity_u32(data));
1449                         queued_retval = ERROR_FAIL;
1450                         return;
1451                 }
1452                 if (value)
1453                         *value = data;
1454                 if (cmd & SWD_CMD_APnDP)
1455                         buspirate_swd_idle_clocks(ap_delay_clk);
1456                 return;
1457          case SWD_ACK_WAIT:
1458                 LOG_DEBUG("SWD_ACK_WAIT");
1459                 buspirate_swd_clear_sticky_errors();
1460                 return;
1461          case SWD_ACK_FAULT:
1462                 LOG_DEBUG("SWD_ACK_FAULT");
1463                 queued_retval = ack;
1464                 return;
1465          default:
1466                 LOG_DEBUG("No valid acknowledge: ack=%d", ack);
1467                 queued_retval = ack;
1468                 return;
1469         }
1470 }
1471
1472 static void buspirate_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
1473 {
1474         uint8_t tmp[16];
1475
1476         LOG_DEBUG("buspirate_swd_write_reg");
1477         assert(!(cmd & SWD_CMD_RnW));
1478
1479         if (queued_retval != ERROR_OK) {
1480                 LOG_DEBUG("Skip buspirate_swd_write_reg because queued_retval=%d", queued_retval);
1481                 return;
1482         }
1483
1484         cmd |= SWD_CMD_START | SWD_CMD_PARK;
1485         uint8_t ack = buspirate_swd_write_header(cmd);
1486
1487         /* do a write transaction */
1488         tmp[0] = 0x10 + ((4 + 1 - 1) & 0xF); /* bus pirate: send 4+1 bytes */
1489         buf_set_u32((uint8_t *) tmp + 1, 0, 32, value);
1490         /* write sequence ends with parity bit and 7 idle ticks */
1491         tmp[5] = parity_u32(value) ? 0x01 : 0x00;
1492
1493         buspirate_serial_write(buspirate_fd, tmp, 6);
1494         buspirate_serial_read(buspirate_fd, tmp, 6);
1495
1496         LOG_DEBUG("%s %s %s reg %X = %08"PRIx32,
1497                         ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
1498                         cmd & SWD_CMD_APnDP ? "AP" : "DP",
1499                         cmd & SWD_CMD_RnW ? "read" : "write",
1500                         (cmd & SWD_CMD_A32) >> 1,
1501                         value);
1502
1503         switch (ack) {
1504          case SWD_ACK_OK:
1505                 if (cmd & SWD_CMD_APnDP)
1506                         buspirate_swd_idle_clocks(ap_delay_clk);
1507                 return;
1508          case SWD_ACK_WAIT:
1509                 LOG_DEBUG("SWD_ACK_WAIT");
1510                 buspirate_swd_clear_sticky_errors();
1511                 return;
1512          case SWD_ACK_FAULT:
1513                 LOG_DEBUG("SWD_ACK_FAULT");
1514                 queued_retval = ack;
1515                 return;
1516          default:
1517                 LOG_DEBUG("No valid acknowledge: ack=%d", ack);
1518                 queued_retval = ack;
1519                 return;
1520         }
1521 }
1522
1523 static int buspirate_swd_run_queue(void)
1524 {
1525         LOG_DEBUG("buspirate_swd_run_queue");
1526         /* A transaction must be followed by another transaction or at least 8 idle cycles to
1527          * ensure that data is clocked through the AP. */
1528         buspirate_swd_idle_clocks(8);
1529
1530         int retval = queued_retval;
1531         queued_retval = ERROR_OK;
1532         LOG_DEBUG("SWD queue return value: %02x", retval);
1533         return retval;
1534 }
1535
1536