src/jtag/drivers/buspirate.c

   1 /***************************************************************************
   2  *   Copyright (C) 2010 by Michal Demin                                    *
   3  *   based on usbprog.c and arm-jtag-ew.c                                  *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <jtag/interface.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_speed(int speed);
  36 static int buspirate_khz(int khz, int *jtag_speed);
  37 static int buspirate_init(void);
  38 static int buspirate_quit(void);
  39
  40 static void buspirate_end_state(tap_state_t state);
  41 static void buspirate_state_move(void);
  42 static void buspirate_path_move(int num_states, tap_state_t *path);
  43 static void buspirate_runtest(int num_cycles);
  44 static void buspirate_scan(bool ir_scan, enum scan_type type,
  45         uint8_t *buffer, int scan_size, struct scan_command *command);
  46
  47
  48 #define CMD_UNKOWN        0x00
  49 #define CMD_PORT_MODE     0x01
  50 #define CMD_FEATURE       0x02
  51 #define CMD_READ_ADCS     0x03
  52 /*#define CMD_TAP_SHIFT     0x04 // old protocol */
  53 #define CMD_TAP_SHIFT     0x05
  54 #define CMD_ENTER_OOCD    0x06
  55 #define CMD_UART_SPEED    0x07
  56 #define CMD_JTAG_SPEED    0x08
  57
  58 enum {
  59         MODE_HIZ = 0,
  60         MODE_JTAG = 1,          /* push-pull outputs */
  61         MODE_JTAG_OD = 2,       /* open-drain outputs */
  62 };
  63
  64 enum {
  65         FEATURE_LED = 0x01,
  66         FEATURE_VREG = 0x02,
  67         FEATURE_TRST = 0x04,
  68         FEATURE_SRST = 0x08,
  69         FEATURE_PULLUP = 0x10
  70 };
  71
  72 enum {
  73         ACTION_DISABLE = 0,
  74         ACTION_ENABLE = 1
  75 };
  76
  77 enum {
  78         SERIAL_NORMAL = 0,
  79         SERIAL_FAST = 1
  80 };
  81
  82
  83 static int buspirate_fd = -1;
  84 static int buspirate_pinmode = MODE_JTAG_OD;
  85 static int buspirate_baudrate = SERIAL_NORMAL;
  86 static int buspirate_vreg;
  87 static int buspirate_pullup;
  88 static char *buspirate_port;
  89
  90
  91 /* TAP interface */
  92 static void buspirate_tap_init(void);
  93 static int buspirate_tap_execute(void);
  94 static void buspirate_tap_append(int tms, int tdi);
  95 static void buspirate_tap_append_scan(int length, uint8_t *buffer,
  96                 struct scan_command *command);
  97 static void buspirate_tap_make_space(int scan, int bits);
  98
  99 static void buspirate_reset(int trst, int srst);
 100
 101 /* low level interface */
 102 static void buspirate_jtag_reset(int);
 103 static void buspirate_jtag_enable(int);
 104 static unsigned char buspirate_jtag_command(int, char *, int);
 105 static void buspirate_jtag_set_speed(int, char);
 106 static void buspirate_jtag_set_mode(int, char);
 107 static void buspirate_jtag_set_feature(int, char, char);
 108 static void buspirate_jtag_get_adcs(int);
 109
 110 /* low level HW communication interface */
 111 static int buspirate_serial_open(char *port);
 112 static int buspirate_serial_setspeed(int fd, char speed);
 113 static int buspirate_serial_write(int fd, char *buf, int size);
 114 static int buspirate_serial_read(int fd, char *buf, int size);
 115 static void buspirate_serial_close(int fd);
 116 static void buspirate_print_buffer(char *buf, int size);
 117
 118 static int buspirate_speed(int speed)
 119 {
 120         /* TODO */
 121         LOG_INFO("Want to set speed to %dkHz, but not implemented yet", speed);
 122         return ERROR_OK;
 123 }
 124
 125 static int buspirate_khz(int khz, int *jtag_speed)
 126 {
 127         *jtag_speed = khz;
 128         return ERROR_OK;
 129 }
 130
 131 static int buspirate_execute_queue(void)
 132 {
 133         /* currently processed command */
 134         struct jtag_command *cmd = jtag_command_queue;
 135         int scan_size;
 136         enum scan_type type;
 137         uint8_t *buffer;
 138
 139         while (cmd) {
 140                 switch (cmd->type) {
 141                 case JTAG_RUNTEST:
 142                         DEBUG_JTAG_IO("runtest %i cycles, end in %s",
 143                                 cmd->cmd.runtest->num_cycles,
 144                                 tap_state_name(cmd->cmd.runtest
 145                                         ->end_state));
 146                         buspirate_end_state(cmd->cmd.runtest
 147                                         ->end_state);
 148                         buspirate_runtest(cmd->cmd.runtest
 149                                         ->num_cycles);
 150                         break;
 151                 case JTAG_TLR_RESET:
 152                         DEBUG_JTAG_IO("statemove end in %s",
 153                                 tap_state_name(cmd->cmd.statemove
 154                                                 ->end_state));
 155                         buspirate_end_state(cmd->cmd.statemove
 156                                         ->end_state);
 157                         buspirate_state_move();
 158                         break;
 159                 case JTAG_PATHMOVE:
 160                         DEBUG_JTAG_IO("pathmove: %i states, end in %s",
 161                                 cmd->cmd.pathmove->num_states,
 162                                 tap_state_name(cmd->cmd.pathmove
 163                                         ->path[cmd->cmd.pathmove
 164                                                 ->num_states - 1]));
 165                         buspirate_path_move(cmd->cmd.pathmove
 166                                         ->num_states,
 167                                         cmd->cmd.pathmove->path);
 168                         break;
 169                 case JTAG_SCAN:
 170                         DEBUG_JTAG_IO("scan end in %s",
 171                                 tap_state_name(cmd->cmd.scan
 172                                         ->end_state));
 173
 174                         buspirate_end_state(cmd->cmd.scan
 175                                         ->end_state);
 176
 177                         scan_size = jtag_build_buffer(cmd->cmd.scan,
 178                                         &buffer);
 179                         type = jtag_scan_type(cmd->cmd.scan);
 180                         buspirate_scan(cmd->cmd.scan->ir_scan, type,
 181                                 buffer, scan_size, cmd->cmd.scan);
 182
 183                         break;
 184                 case JTAG_RESET:
 185                         DEBUG_JTAG_IO("reset trst: %i srst %i",
 186                                 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 187
 188                         /* flush buffers, so we can reset */
 189                         buspirate_tap_execute();
 190
 191                         if (cmd->cmd.reset->trst == 1)
 192                                 tap_set_state(TAP_RESET);
 193                         buspirate_reset(cmd->cmd.reset->trst,
 194                                         cmd->cmd.reset->srst);
 195                         break;
 196                 case JTAG_SLEEP:
 197                         DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
 198                         buspirate_tap_execute();
 199                         jtag_sleep(cmd->cmd.sleep->us);
 200                                 break;
 201                 default:
 202                         LOG_ERROR("BUG: unknown JTAG command type encountered");
 203                         exit(-1);
 204                 }
 205
 206                 cmd = cmd->next;
 207         }
 208
 209         return buspirate_tap_execute();
 210 }
 211
 212 static int buspirate_init(void)
 213 {
 214         if (buspirate_port == NULL) {
 215                 LOG_ERROR("You need to specify port !");
 216                 return ERROR_JTAG_INIT_FAILED;
 217         }
 218
 219         buspirate_fd = buspirate_serial_open(buspirate_port);
 220         if (buspirate_fd == -1) {
 221                 LOG_ERROR("Could not open serial port.");
 222                 return ERROR_JTAG_INIT_FAILED;
 223         }
 224
 225         buspirate_serial_setspeed(buspirate_fd, SERIAL_NORMAL);
 226
 227         buspirate_jtag_enable(buspirate_fd);
 228
 229         if (buspirate_baudrate != SERIAL_NORMAL)
 230                 buspirate_jtag_set_speed(buspirate_fd, SERIAL_FAST);
 231
 232         LOG_INFO("Buspirate Interface ready!");
 233
 234         buspirate_tap_init();
 235         buspirate_jtag_set_mode(buspirate_fd, buspirate_pinmode);
 236         buspirate_jtag_set_feature(buspirate_fd, FEATURE_VREG,
 237                 (buspirate_vreg == 1) ? ACTION_ENABLE : ACTION_DISABLE);
 238         buspirate_jtag_set_feature(buspirate_fd, FEATURE_PULLUP,
 239                 (buspirate_pullup == 1) ? ACTION_ENABLE : ACTION_DISABLE);
 240         buspirate_reset(0, 0);
 241
 242         return ERROR_OK;
 243 }
 244
 245 static int buspirate_quit(void)
 246 {
 247         LOG_INFO("Shuting down buspirate ");
 248         buspirate_jtag_set_mode(buspirate_fd, MODE_HIZ);
 249
 250         buspirate_jtag_set_speed(buspirate_fd, SERIAL_NORMAL);
 251         buspirate_jtag_reset(buspirate_fd);
 252
 253         buspirate_serial_close(buspirate_fd);
 254
 255         if (buspirate_port) {
 256                 free(buspirate_port);
 257                 buspirate_port = NULL;
 258         }
 259         return ERROR_OK;
 260 }
 261
 262 /* openocd command interface */
 263 COMMAND_HANDLER(buspirate_handle_adc_command)
 264 {
 265         if (CMD_ARGC != 0) {
 266                 LOG_ERROR("usage: buspirate_adc");
 267                 return ERROR_OK;
 268         }
 269
 270         if (buspirate_fd == -1)
 271                 return ERROR_OK;
 272
 273         /* send the command */
 274         buspirate_jtag_get_adcs(buspirate_fd);
 275
 276         return ERROR_OK;
 277
 278 }
 279
 280 COMMAND_HANDLER(buspirate_handle_vreg_command)
 281 {
 282         if (CMD_ARGC != 1) {
 283                 LOG_ERROR("usage: buspirate_vreg <1|0>");
 284                 return ERROR_OK;
 285         }
 286
 287         if (atoi(CMD_ARGV[0]) == 1)
 288                 buspirate_vreg = 1;
 289         else
 290                 buspirate_vreg = 0;
 291
 292         return ERROR_OK;
 293
 294 }
 295
 296 COMMAND_HANDLER(buspirate_handle_pullup_command)
 297 {
 298         if (CMD_ARGC != 1) {
 299                 LOG_ERROR("usage: buspirate_pullup <1|0>");
 300                 return ERROR_OK;
 301         }
 302
 303         if (atoi(CMD_ARGV[0]) == 1)
 304                 buspirate_pullup = 1;
 305         else
 306                 buspirate_pullup = 0;
 307
 308         return ERROR_OK;
 309
 310 }
 311
 312 COMMAND_HANDLER(buspirate_handle_led_command)
 313 {
 314         if (CMD_ARGC != 1) {
 315                 LOG_ERROR("usage: buspirate_led <1|0>");
 316                 return ERROR_OK;
 317         }
 318
 319         if (atoi(CMD_ARGV[0]) == 1) {
 320                 /* enable led */
 321                 buspirate_jtag_set_feature(buspirate_fd, FEATURE_LED,
 322                                 ACTION_ENABLE);
 323         } else {
 324                 /* disable led */
 325                 buspirate_jtag_set_feature(buspirate_fd, FEATURE_LED,
 326                                 ACTION_DISABLE);
 327         }
 328
 329         return ERROR_OK;
 330
 331 }
 332
 333 COMMAND_HANDLER(buspirate_handle_mode_command)
 334 {
 335         if (CMD_ARGC != 1) {
 336                 LOG_ERROR("usage: buspirate_mode <normal|open-drain>");
 337                 return ERROR_OK;
 338         }
 339
 340         if (CMD_ARGV[0][0] == 'n')
 341                 buspirate_pinmode = MODE_JTAG;
 342         else if (CMD_ARGV[0][0] == 'o')
 343                 buspirate_pinmode = MODE_JTAG_OD;
 344         else
 345                 LOG_ERROR("usage: buspirate_mode <normal|open-drain>");
 346
 347         return ERROR_OK;
 348
 349 }
 350
 351 COMMAND_HANDLER(buspirate_handle_speed_command)
 352 {
 353         if (CMD_ARGC != 1) {
 354                 LOG_ERROR("usage: buspirate_speed <normal|fast>");
 355                 return ERROR_OK;
 356         }
 357
 358         if (CMD_ARGV[0][0] == 'n')
 359                 buspirate_baudrate = SERIAL_NORMAL;
 360         else if (CMD_ARGV[0][0] == 'f')
 361                 buspirate_baudrate = SERIAL_FAST;
 362         else
 363                 LOG_ERROR("usage: buspirate_speed <normal|fast>");
 364
 365         return ERROR_OK;
 366
 367 }
 368
 369 COMMAND_HANDLER(buspirate_handle_port_command)
 370 {
 371         if (CMD_ARGC != 1) {
 372                 LOG_ERROR("usage: buspirate_port /dev/ttyUSB0");
 373                 return ERROR_OK;
 374         }
 375
 376         if (buspirate_port == 0)
 377                 buspirate_port = strdup(CMD_ARGV[0]);
 378
 379         return ERROR_OK;
 380
 381 }
 382
 383 static const struct command_registration buspirate_command_handlers[] = {
 384         {
 385                 .name = "buspirate_adc",
 386                 .handler = &buspirate_handle_adc_command,
 387                 .mode = COMMAND_EXEC,
 388                 .help = "reads voltages on adc pins",
 389         },
 390         {
 391                 .name = "buspirate_vreg",
 392                 .handler = &buspirate_handle_vreg_command,
 393                 .mode = COMMAND_CONFIG,
 394                 .help = "changes the state of voltage regulators",
 395         },
 396         {
 397                 .name = "buspirate_pullup",
 398                 .handler = &buspirate_handle_pullup_command,
 399                 .mode = COMMAND_CONFIG,
 400                 .help = "changes the state of pullup",
 401         },
 402         {
 403                 .name = "buspirate_led",
 404                 .handler = &buspirate_handle_led_command,
 405                 .mode = COMMAND_EXEC,
 406                 .help = "changes the state of led",
 407         },
 408         {
 409                 .name = "buspirate_speed",
 410                 .handler = &buspirate_handle_speed_command,
 411                 .mode = COMMAND_CONFIG,
 412                 .help = "speed of the interface",
 413         },
 414         {
 415                 .name = "buspirate_mode",
 416                 .handler = &buspirate_handle_mode_command,
 417                 .mode = COMMAND_CONFIG,
 418                 .help = "pin mode of the interface",
 419         },
 420         {
 421                 .name = "buspirate_port",
 422                 .handler = &buspirate_handle_port_command,
 423                 .mode = COMMAND_CONFIG,
 424                 .help = "name of the serial port to open",
 425         },
 426         COMMAND_REGISTRATION_DONE
 427 };
 428
 429 struct jtag_interface buspirate_interface = {
 430         .name = "buspirate",
 431         .execute_queue = buspirate_execute_queue,
 432         .speed = buspirate_speed,
 433         .khz = buspirate_khz,
 434         .commands = buspirate_command_handlers,
 435         .init = buspirate_init,
 436         .quit = buspirate_quit
 437 };
 438
 439 /*************** jtag execute commands **********************/
 440 static void buspirate_end_state(tap_state_t state)
 441 {
 442         if (tap_is_state_stable(state))
 443                 tap_set_end_state(state);
 444         else {
 445                 LOG_ERROR("BUG: %i is not a valid end state", state);
 446                 exit(-1);
 447         }
 448 }
 449
 450 static void buspirate_state_move(void)
 451 {
 452         int i = 0, tms = 0;
 453         uint8_t tms_scan = tap_get_tms_path(tap_get_state(),
 454                         tap_get_end_state());
 455         int tms_count = tap_get_tms_path_len(tap_get_state(),
 456                         tap_get_end_state());
 457
 458         for (i = 0; i < tms_count; i++) {
 459                 tms = (tms_scan >> i) & 1;
 460                 buspirate_tap_append(tms, 0);
 461         }
 462
 463         tap_set_state(tap_get_end_state());
 464 }
 465
 466 static void buspirate_path_move(int num_states, tap_state_t *path)
 467 {
 468         int i;
 469
 470         for (i = 0; i < num_states; i++) {
 471                 if (tap_state_transition(tap_get_state(), false) == path[i]) {
 472                         buspirate_tap_append(0, 0);
 473                 } else if (tap_state_transition(tap_get_state(), true)
 474                                 == path[i]) {
 475                         buspirate_tap_append(1, 0);
 476                 } else {
 477                         LOG_ERROR("BUG: %s -> %s isn't a valid "
 478                                 "TAP transition",
 479                                 tap_state_name(tap_get_state()),
 480                                 tap_state_name(path[i]));
 481                         exit(-1);
 482                 }
 483
 484                 tap_set_state(path[i]);
 485         }
 486
 487         tap_set_end_state(tap_get_state());
 488 }
 489
 490 static void buspirate_runtest(int num_cycles)
 491 {
 492         int i;
 493
 494         tap_state_t saved_end_state = tap_get_end_state();
 495
 496         /* only do a state_move when we're not already in IDLE */
 497         if (tap_get_state() != TAP_IDLE) {
 498                 buspirate_end_state(TAP_IDLE);
 499                 buspirate_state_move();
 500         }
 501
 502         for (i = 0; i < num_cycles; i++)
 503                 buspirate_tap_append(0, 0);
 504
 505         DEBUG_JTAG_IO("runtest: cur_state %s end_state %s",
 506                         tap_state_name(tap_get_state()),
 507                         tap_state_name(tap_get_end_state()));
 508
 509         /* finish in end_state */
 510         buspirate_end_state(saved_end_state);
 511         if (tap_get_state() != tap_get_end_state())
 512                 buspirate_state_move();
 513 }
 514
 515 static void buspirate_scan(bool ir_scan, enum scan_type type,
 516         uint8_t *buffer, int scan_size, struct scan_command *command)
 517 {
 518         tap_state_t saved_end_state;
 519
 520         buspirate_tap_make_space(1, scan_size+8);
 521         /* is 8 correct ? (2 moves = 16) */
 522
 523         saved_end_state = tap_get_end_state();
 524
 525         buspirate_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT);
 526         buspirate_state_move();
 527
 528         buspirate_tap_append_scan(scan_size, buffer, command);
 529
 530         /* move to PAUSE */
 531         buspirate_tap_append(0, 0);
 532
 533         /* restore the saved state */
 534         buspirate_end_state(saved_end_state);
 535         tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE);
 536
 537         if (tap_get_state() != tap_get_end_state())
 538                 buspirate_state_move();
 539 }
 540
 541
 542 /************************* TAP related stuff **********/
 543
 544 #define BUSPIRATE_BUFFER_SIZE 1024
 545 #define BUSPIRATE_MAX_PENDING_SCANS 32
 546
 547 static char tms_chain[BUSPIRATE_BUFFER_SIZE]; /* send */
 548 static char tdi_chain[BUSPIRATE_BUFFER_SIZE]; /* send */
 549 static int tap_chain_index;
 550
 551 struct pending_scan_result /* this was stolen from arm-jtag-ew */
 552 {
 553         int first; /* First bit position in tdo_buffer to read */
 554         int length; /* Number of bits to read */
 555         struct scan_command *command; /* Corresponding scan command */
 556         uint8_t *buffer;
 557 };
 558
 559 static struct pending_scan_result
 560 tap_pending_scans[BUSPIRATE_MAX_PENDING_SCANS];
 561 static int tap_pending_scans_num;
 562
 563 static void buspirate_tap_init(void)
 564 {
 565         tap_chain_index = 0;
 566         tap_pending_scans_num = 0;
 567 }
 568
 569 static int buspirate_tap_execute(void)
 570 {
 571         char tmp[4096];
 572         uint8_t *in_buf;
 573         int i;
 574         int fill_index = 0;
 575         int ret;
 576         int bytes_to_send;
 577
 578         if (tap_chain_index <= 0)
 579                 return ERROR_OK;
 580
 581         LOG_DEBUG("executing tap num bits = %i scans = %i",
 582                         tap_chain_index, tap_pending_scans_num);
 583
 584         bytes_to_send = (tap_chain_index+7) / 8;
 585
 586         tmp[0] = CMD_TAP_SHIFT; /* this command expects number of bits */
 587         tmp[1] = (char)(tap_chain_index >> 8);  /* high */
 588         tmp[2] = (char)(tap_chain_index);  /* low */
 589
 590         fill_index = 3;
 591         for (i = 0; i < bytes_to_send; i++) {
 592                 tmp[fill_index] = tdi_chain[i];
 593                 fill_index++;
 594                 tmp[fill_index] = tms_chain[i];
 595                 fill_index++;
 596         }
 597
 598         ret = buspirate_serial_write(buspirate_fd, tmp, 3 + bytes_to_send*2);
 599         if (ret != bytes_to_send*2+3) {
 600                 LOG_ERROR("error writing :(");
 601                 return ERROR_JTAG_DEVICE_ERROR;
 602         }
 603
 604         ret = buspirate_serial_read(buspirate_fd, tmp, bytes_to_send + 3);
 605         in_buf = (uint8_t *)(&tmp[3]);
 606
 607         /* parse the scans */
 608         for (i = 0; i < tap_pending_scans_num; i++) {
 609                 uint8_t *buffer = tap_pending_scans[i].buffer;
 610                 int length = tap_pending_scans[i].length;
 611                 int first = tap_pending_scans[i].first;
 612                 struct scan_command *command = tap_pending_scans[i].command;
 613
 614                 /* copy bits from buffer */
 615                 buf_set_buf(in_buf, first, buffer, 0, length);
 616
 617                 /* return buffer to higher level */
 618                 if (jtag_read_buffer(buffer, command) != ERROR_OK) {
 619                         buspirate_tap_init();
 620                         return ERROR_JTAG_QUEUE_FAILED;
 621                 }
 622
 623                 free(buffer);
 624         }
 625         tap_pending_scans_num = 0;
 626         tap_chain_index = 0;
 627         return ERROR_OK;
 628 }
 629
 630 static void buspirate_tap_make_space(int scans, int bits)
 631 {
 632         int have_scans = BUSPIRATE_MAX_PENDING_SCANS - tap_pending_scans_num;
 633         int have_bits = BUSPIRATE_BUFFER_SIZE * 8 - tap_chain_index;
 634
 635         if ((have_scans < scans) || (have_bits < bits))
 636                 buspirate_tap_execute();
 637 }
 638
 639 static void buspirate_tap_append(int tms, int tdi)
 640 {
 641         int chain_index;
 642
 643         buspirate_tap_make_space(0, 1);
 644         chain_index = tap_chain_index / 8;
 645
 646         if (chain_index < BUSPIRATE_BUFFER_SIZE) {
 647                 int bit_index = tap_chain_index % 8;
 648                 uint8_t bit = 1 << bit_index;
 649
 650                 if (tms)
 651                         tms_chain[chain_index] |= bit;
 652                 else
 653                         tms_chain[chain_index] &= ~bit;
 654
 655                 if (tdi)
 656                         tdi_chain[chain_index] |= bit;
 657                 else
 658                         tdi_chain[chain_index] &= ~bit;
 659
 660                 tap_chain_index++;
 661         } else
 662                 LOG_ERROR("tap_chain overflow, Bad things will happen");
 663
 664 }
 665
 666 static void buspirate_tap_append_scan(int length, uint8_t *buffer,
 667                 struct scan_command *command)
 668 {
 669         int i;
 670         tap_pending_scans[tap_pending_scans_num].length = length;
 671         tap_pending_scans[tap_pending_scans_num].buffer = buffer;
 672         tap_pending_scans[tap_pending_scans_num].command = command;
 673         tap_pending_scans[tap_pending_scans_num].first = tap_chain_index;
 674
 675         for (i = 0; i < length; i++) {
 676                 int tms = (i < length-1 ? 0 : 1);
 677                 int tdi = (buffer[i/8] >> (i%8)) & 1;
 678                 buspirate_tap_append(tms, tdi);
 679         }
 680         tap_pending_scans_num++;
 681 }
 682
 683 /*************** jtag wrapper functions *********************/
 684
 685 /* (1) assert or (0) deassert reset lines */
 686 static void buspirate_reset(int trst, int srst)
 687 {
 688         LOG_DEBUG("trst: %i, srst: %i", trst, srst);
 689
 690         if (trst)
 691                 buspirate_jtag_set_feature(buspirate_fd,
 692                                 FEATURE_TRST, ACTION_DISABLE);
 693         else
 694                 buspirate_jtag_set_feature(buspirate_fd,
 695                                 FEATURE_TRST, ACTION_ENABLE);
 696
 697         if (srst)
 698                 buspirate_jtag_set_feature(buspirate_fd,
 699                                 FEATURE_SRST, ACTION_DISABLE);
 700         else
 701                 buspirate_jtag_set_feature(buspirate_fd,
 702                                 FEATURE_SRST, ACTION_ENABLE);
 703 }
 704
 705 /*************** jtag lowlevel functions ********************/
 706 static void buspirate_jtag_enable(int fd)
 707 {
 708         int ret;
 709         char tmp[21] = { [0 ... 20] = 0x00 };
 710         int done = 0;
 711         int cmd_sent = 0;
 712
 713         LOG_DEBUG("Entering binary mode");
 714         buspirate_serial_write(fd, tmp, 20);
 715         usleep(10000);
 716
 717         /* reads 1 to n "BBIO1"s and one "OCD1" */
 718         while (!done) {
 719                 ret = buspirate_serial_read(fd, tmp, 4);
 720                 if (ret != 4) {
 721                         LOG_ERROR("Buspirate did not respond :"
 722                                 "( restart everything");
 723                         exit(-1);
 724                 }
 725                 LOG_DEBUG("TUI");
 726                 if (strncmp(tmp, "BBIO", 4) == 0) {
 727                         ret = buspirate_serial_read(fd, tmp, 1);
 728                         if (ret != 1) {
 729                                 LOG_ERROR("Buspirate did not respond well :"
 730                                         "( restart everything");
 731                                 exit(-1);
 732                         }
 733                         if (tmp[0] != '1') {
 734                                 LOG_ERROR("Unsupported binary protocol ");
 735                                 exit(-1);
 736                         }
 737                         if (cmd_sent == 0) {
 738                                 cmd_sent = 1;
 739                                 tmp[0] = CMD_ENTER_OOCD;
 740                                 ret = buspirate_serial_write(fd, tmp, 1);
 741                         }
 742                 } else if (strncmp(tmp, "OCD1", 4) == 0)
 743                         done = 1;
 744                 else {
 745                         LOG_ERROR("Buspirate did not respond :"
 746                                 "( restart everything");
 747                         exit(-1);
 748                 }
 749         }
 750
 751 }
 752
 753 static void buspirate_jtag_reset(int fd)
 754 {
 755         int ret;
 756         char tmp[5];
 757
 758         tmp[0] = 0x00; /* exit OCD1 mode */
 759         buspirate_serial_write(fd, tmp, 1);
 760         usleep(10000);
 761         ret = buspirate_serial_read(fd, tmp, 5);
 762         if (strncmp(tmp, "BBIO1", 5) == 0) {
 763                 tmp[0] = 0x0F; /*  reset BP */
 764                 buspirate_serial_write(fd, tmp, 1);
 765         } else
 766                 LOG_ERROR("Bad reply :( Please restart manually");
 767 }
 768
 769 static void buspirate_jtag_set_speed(int fd, char speed)
 770 {
 771         int ret;
 772         char tmp[2];
 773         char ack[2];
 774
 775         ack[0] = 0xAA;
 776         ack[1] = 0x55;
 777
 778         tmp[0] = CMD_UART_SPEED;
 779         tmp[1] = speed;
 780         buspirate_jtag_command(fd, tmp, 2);
 781
 782         /* here the adapter changes speed, we need follow */
 783         buspirate_serial_setspeed(fd, speed);
 784
 785         buspirate_serial_write(fd, ack, 2);
 786         ret = buspirate_serial_read(fd, tmp, 2);
 787         if (ret != 2) {
 788                 LOG_ERROR("Buspirate did not respond :"
 789                         "( restart everything");
 790                 exit(-1);
 791         }
 792         if ((tmp[0] != CMD_UART_SPEED) || (tmp[1] != speed)) {
 793                 LOG_ERROR("Buspirate didn't reply as expected :"
 794                         "( restart everything");
 795                 exit(-1);
 796         }
 797         LOG_INFO("Buspirate switched to %s mode",
 798                 (speed == SERIAL_NORMAL) ? "normal" : "FAST");
 799 }
 800
 801
 802 static void buspirate_jtag_set_mode(int fd, char mode)
 803 {
 804         char tmp[2];
 805         tmp[0] = CMD_PORT_MODE;
 806         tmp[1] = mode;
 807         buspirate_jtag_command(fd, tmp, 2);
 808 }
 809
 810 static void buspirate_jtag_set_feature(int fd, char feat, char action)
 811 {
 812         char tmp[3];
 813         tmp[0] = CMD_FEATURE;
 814         tmp[1] = feat;   /* what */
 815         tmp[2] = action; /* action */
 816         buspirate_jtag_command(fd, tmp, 3);
 817 }
 818
 819 static void buspirate_jtag_get_adcs(int fd)
 820 {
 821         uint8_t tmp[10];
 822         uint16_t a, b, c, d;
 823         tmp[0] = CMD_READ_ADCS;
 824         buspirate_jtag_command(fd, (char *)tmp, 1);
 825         a = tmp[2] << 8 | tmp[3];
 826         b = tmp[4] << 8 | tmp[5];
 827         c = tmp[6] << 8 | tmp[7];
 828         d = tmp[8] << 8 | tmp[9];
 829
 830         LOG_INFO("ADC: ADC_Pin = %.02f VPullup = %.02f V33 = %.02f "
 831                 "V50 = %.02f",
 832                 ((float)a)/155.1515, ((float)b)/155.1515,
 833                 ((float)c)/155.1515, ((float)d)/155.1515);
 834 }
 835
 836 static unsigned char buspirate_jtag_command(int fd,
 837                 char *cmd, int cmdlen)
 838 {
 839         int res;
 840         int len = 0;
 841
 842         res = buspirate_serial_write(fd, cmd, cmdlen);
 843
 844         if ((cmd[0] == CMD_UART_SPEED)
 845                                 || (cmd[0] == CMD_PORT_MODE)
 846                                 || (cmd[0] == CMD_FEATURE)
 847                                 || (cmd[0] == CMD_JTAG_SPEED))
 848                 return 1;
 849
 850         if (res == cmdlen) {
 851                 switch (cmd[0]) {
 852                 case CMD_READ_ADCS:
 853                         len = 10; /* 2*sizeof(char)+4*sizeof(uint16_t) */
 854                         break;
 855                 case CMD_TAP_SHIFT:
 856                         len = cmdlen;
 857                         break;
 858                 default:
 859                         LOG_INFO("Wrong !");
 860                 }
 861                 res =  buspirate_serial_read(fd, cmd, len);
 862                 if (res > 0)
 863                         return (unsigned char)cmd[1];
 864                 else
 865                         return -1;
 866         } else
 867                 return -1;
 868         return 0;
 869 }
 870
 871 /* low level serial port */
 872 /* TODO add support for WIN32 and others ! */
 873 static int buspirate_serial_open(char *port)
 874 {
 875         int fd;
 876         fd = open(buspirate_port, O_RDWR | O_NOCTTY | O_NDELAY);
 877         return fd;
 878 }
 879
 880 static int buspirate_serial_setspeed(int fd, char speed)
 881 {
 882         struct termios t_opt;
 883         speed_t baud = (speed == SERIAL_FAST) ? B1000000 : B115200;
 884
 885         /* set the serial port parameters */
 886         fcntl(fd, F_SETFL, 0);
 887         tcgetattr(fd, &t_opt);
 888         cfsetispeed(&t_opt, baud);
 889         cfsetospeed(&t_opt, baud);
 890         t_opt.c_cflag |= (CLOCAL | CREAD);
 891         t_opt.c_cflag &= ~PARENB;
 892         t_opt.c_cflag &= ~CSTOPB;
 893         t_opt.c_cflag &= ~CSIZE;
 894         t_opt.c_cflag |= CS8;
 895         t_opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
 896         t_opt.c_iflag &= ~(IXON | IXOFF | IXANY);
 897         t_opt.c_oflag &= ~OPOST;
 898         t_opt.c_cc[VMIN] = 0;
 899         t_opt.c_cc[VTIME] = 10;
 900         tcflush(fd, TCIFLUSH);
 901         tcsetattr(fd, TCSANOW, &t_opt);
 902
 903         return 0;
 904 }
 905
 906 static int buspirate_serial_write(int fd, char *buf, int size)
 907 {
 908         int ret = 0;
 909
 910         ret = write(fd, buf, size);
 911
 912         LOG_DEBUG("size = %d ret = %d", size, ret);
 913         buspirate_print_buffer(buf, size);
 914
 915         if (ret != size)
 916                 LOG_ERROR("Error sending data");
 917
 918         return ret;
 919 }
 920
 921 static int buspirate_serial_read(int fd, char *buf, int size)
 922 {
 923         int len = 0;
 924         int ret = 0;
 925         int timeout = 0;
 926
 927         while (len < size) {
 928                 ret = read(fd, buf+len, size-len);
 929                 if (ret == -1)
 930                         return -1;
 931
 932                 if (ret == 0) {
 933                         timeout++;
 934
 935                         if (timeout >= 10)
 936                                 break;
 937
 938                         continue;
 939                 }
 940
 941                 len += ret;
 942         }
 943
 944         LOG_DEBUG("should have read = %d actual size = %d", size, len);
 945         buspirate_print_buffer(buf, len);
 946
 947         if (len != size)
 948                 LOG_ERROR("Error sending data");
 949
 950         return len;
 951 }
 952
 953 static void buspirate_serial_close(int fd)
 954 {
 955         close(fd);
 956 }
 957
 958 #define LINE_SIZE      81
 959 #define BYTES_PER_LINE 16
 960 static void buspirate_print_buffer(char *buf, int size)
 961 {
 962         char line[LINE_SIZE];
 963         char tmp[10];
 964         int offset = 0;
 965
 966         line[0] = 0;
 967         while (offset < size) {
 968                 snprintf(tmp, 5, "%02x ", (uint8_t)buf[offset]);
 969                 offset++;
 970
 971                 strcat(line, tmp);
 972
 973                 if (offset % BYTES_PER_LINE == 0) {
 974                         LOG_DEBUG("%s", line);
 975                         line[0] = 0;
 976                 }
 977         }
 978
 979         if (line[0] != 0) {
 980                 LOG_DEBUG("%s", line);
 981         }
 982 }
 983