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