src/jtag/drivers/jtag_vpi.c

   1 /*
   2  * JTAG to VPI driver
   3  *
   4  * Copyright (C) 2013 Franck Jullien, <elec4fun@gmail.com>
   5  *
   6  * See file CREDITS for list of people who contributed to this
   7  * project.
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <jtag/interface.h>
  28 #ifdef HAVE_ARPA_INET_H
  29 #include <arpa/inet.h>
  30 #endif
  31
  32 #ifndef _WIN32
  33 #include <netinet/tcp.h>
  34 #endif
  35
  36 #define NO_TAP_SHIFT    0
  37 #define TAP_SHIFT       1
  38
  39 #define SERVER_ADDRESS  "127.0.0.1"
  40 #define SERVER_PORT     5555
  41
  42 #define XFERT_MAX_SIZE          512
  43
  44 #define CMD_RESET               0
  45 #define CMD_TMS_SEQ             1
  46 #define CMD_SCAN_CHAIN          2
  47 #define CMD_SCAN_CHAIN_FLIP_TMS 3
  48 #define CMD_STOP_SIMU           4
  49
  50 int server_port = SERVER_PORT;
  51 char *server_address;
  52
  53 int sockfd;
  54 struct sockaddr_in serv_addr;
  55
  56 struct vpi_cmd {
  57         int cmd;
  58         unsigned char buffer_out[XFERT_MAX_SIZE];
  59         unsigned char buffer_in[XFERT_MAX_SIZE];
  60         int length;
  61         int nb_bits;
  62 };
  63
  64 static int jtag_vpi_send_cmd(struct vpi_cmd *vpi)
  65 {
  66         int retval = write_socket(sockfd, vpi, sizeof(struct vpi_cmd));
  67         if (retval <= 0)
  68                 return ERROR_FAIL;
  69
  70         return ERROR_OK;
  71 }
  72
  73 static int jtag_vpi_receive_cmd(struct vpi_cmd *vpi)
  74 {
  75         int retval = read_socket(sockfd, vpi, sizeof(struct vpi_cmd));
  76         if (retval < (int)sizeof(struct vpi_cmd))
  77                 return ERROR_FAIL;
  78
  79         return ERROR_OK;
  80 }
  81
  82 /**
  83  * jtag_vpi_reset - ask to reset the JTAG device
  84  * @trst: 1 if TRST is to be asserted
  85  * @srst: 1 if SRST is to be asserted
  86  */
  87 static int jtag_vpi_reset(int trst, int srst)
  88 {
  89         struct vpi_cmd vpi;
  90
  91         vpi.cmd = CMD_RESET;
  92         vpi.length = 0;
  93         return jtag_vpi_send_cmd(&vpi);
  94 }
  95
  96 /**
  97  * jtag_vpi_tms_seq - ask a TMS sequence transition to JTAG
  98  * @bits: TMS bits to be written (bit0, bit1 .. bitN)
  99  * @nb_bits: number of TMS bits (between 1 and 8)
 100  *
 101  * Write a serie of TMS transitions, where each transition consists in :
 102  *  - writing out TCK=0, TMS=<new_state>, TDI=<???>
 103  *  - writing out TCK=1, TMS=<new_state>, TDI=<???> which triggers the transition
 104  * The function ensures that at the end of the sequence, the clock (TCK) is put
 105  * low.
 106  */
 107 static int jtag_vpi_tms_seq(const uint8_t *bits, int nb_bits)
 108 {
 109         struct vpi_cmd vpi;
 110         int nb_bytes;
 111
 112         nb_bytes = DIV_ROUND_UP(nb_bits, 8);
 113
 114         vpi.cmd = CMD_TMS_SEQ;
 115         memcpy(vpi.buffer_out, bits, nb_bytes);
 116         vpi.length = nb_bytes;
 117         vpi.nb_bits = nb_bits;
 118
 119         return jtag_vpi_send_cmd(&vpi);
 120 }
 121
 122 /**
 123  * jtag_vpi_path_move - ask a TMS sequence transition to JTAG
 124  * @cmd: path transition
 125  *
 126  * Write a serie of TMS transitions, where each transition consists in :
 127  *  - writing out TCK=0, TMS=<new_state>, TDI=<???>
 128  *  - writing out TCK=1, TMS=<new_state>, TDI=<???> which triggers the transition
 129  * The function ensures that at the end of the sequence, the clock (TCK) is put
 130  * low.
 131  */
 132
 133 static int jtag_vpi_path_move(struct pathmove_command *cmd)
 134 {
 135         uint8_t trans[DIV_ROUND_UP(cmd->num_states, 8)];
 136
 137         memset(trans, 0, DIV_ROUND_UP(cmd->num_states, 8));
 138
 139         for (int i = 0; i < cmd->num_states; i++) {
 140                 if (tap_state_transition(tap_get_state(), true) == cmd->path[i])
 141                         buf_set_u32(trans, i, 1, 1);
 142                 tap_set_state(cmd->path[i]);
 143         }
 144
 145         return jtag_vpi_tms_seq(trans, cmd->num_states);
 146 }
 147
 148 /**
 149  * jtag_vpi_tms - ask a tms command
 150  * @cmd: tms command
 151  */
 152 static int jtag_vpi_tms(struct tms_command *cmd)
 153 {
 154         return jtag_vpi_tms_seq(cmd->bits, cmd->num_bits);
 155 }
 156
 157 static int jtag_vpi_state_move(tap_state_t state)
 158 {
 159         if (tap_get_state() == state)
 160                 return ERROR_OK;
 161
 162         uint8_t tms_scan = tap_get_tms_path(tap_get_state(), state);
 163         int tms_len = tap_get_tms_path_len(tap_get_state(), state);
 164
 165         int retval = jtag_vpi_tms_seq(&tms_scan, tms_len);
 166         if (retval != ERROR_OK)
 167                 return retval;
 168
 169         tap_set_state(state);
 170
 171         return ERROR_OK;
 172 }
 173
 174 static int jtag_vpi_queue_tdi_xfer(uint8_t *bits, int nb_bits, int tap_shift)
 175 {
 176         struct vpi_cmd vpi;
 177         int nb_bytes = DIV_ROUND_UP(nb_bits, 8);
 178
 179         vpi.cmd = tap_shift ? CMD_SCAN_CHAIN_FLIP_TMS : CMD_SCAN_CHAIN;
 180
 181         if (bits)
 182                 memcpy(vpi.buffer_out, bits, nb_bytes);
 183         else
 184                 memset(vpi.buffer_out, 0xff, nb_bytes);
 185
 186         vpi.length = nb_bytes;
 187         vpi.nb_bits = nb_bits;
 188
 189         int retval = jtag_vpi_send_cmd(&vpi);
 190         if (retval != ERROR_OK)
 191                 return retval;
 192
 193         retval = jtag_vpi_receive_cmd(&vpi);
 194         if (retval != ERROR_OK)
 195                 return retval;
 196
 197         if (bits)
 198                 memcpy(bits, vpi.buffer_in, nb_bytes);
 199
 200         return ERROR_OK;
 201 }
 202
 203 /**
 204  * jtag_vpi_queue_tdi - short description
 205  * @bits: bits to be queued on TDI (or NULL if 0 are to be queued)
 206  * @nb_bits: number of bits
 207  */
 208 static int jtag_vpi_queue_tdi(uint8_t *bits, int nb_bits, int tap_shift)
 209 {
 210         int nb_xfer = DIV_ROUND_UP(nb_bits, XFERT_MAX_SIZE * 8);
 211         int retval;
 212
 213         while (nb_xfer) {
 214                 if (nb_xfer ==  1) {
 215                         retval = jtag_vpi_queue_tdi_xfer(bits, nb_bits, tap_shift);
 216                         if (retval != ERROR_OK)
 217                                 return retval;
 218                 } else {
 219                         retval = jtag_vpi_queue_tdi_xfer(bits, XFERT_MAX_SIZE * 8, NO_TAP_SHIFT);
 220                         if (retval != ERROR_OK)
 221                                 return retval;
 222                         nb_bits -= XFERT_MAX_SIZE * 8;
 223                         if (bits)
 224                                 bits += XFERT_MAX_SIZE;
 225                 }
 226
 227                 nb_xfer--;
 228         }
 229
 230         return ERROR_OK;
 231 }
 232
 233 /**
 234  * jtag_vpi_clock_tms - clock a TMS transition
 235  * @tms: the TMS to be sent
 236  *
 237  * Triggers a TMS transition (ie. one JTAG TAP state move).
 238  */
 239 static int jtag_vpi_clock_tms(int tms)
 240 {
 241         const uint8_t tms_0 = 0;
 242         const uint8_t tms_1 = 1;
 243
 244         return jtag_vpi_tms_seq(tms ? &tms_1 : &tms_0, 1);
 245 }
 246
 247 /**
 248  * jtag_vpi_scan - launches a DR-scan or IR-scan
 249  * @cmd: the command to launch
 250  *
 251  * Launch a JTAG IR-scan or DR-scan
 252  *
 253  * Returns ERROR_OK if OK, ERROR_xxx if a read/write error occured.
 254  */
 255 static int jtag_vpi_scan(struct scan_command *cmd)
 256 {
 257         int scan_bits;
 258         uint8_t *buf = NULL;
 259         int retval = ERROR_OK;
 260
 261         scan_bits = jtag_build_buffer(cmd, &buf);
 262
 263         if (cmd->ir_scan) {
 264                 retval = jtag_vpi_state_move(TAP_IRSHIFT);
 265                 if (retval != ERROR_OK)
 266                         return retval;
 267         } else {
 268                 retval = jtag_vpi_state_move(TAP_DRSHIFT);
 269                 if (retval != ERROR_OK)
 270                         return retval;
 271         }
 272
 273         if (cmd->end_state == TAP_DRSHIFT) {
 274                 retval = jtag_vpi_queue_tdi(buf, scan_bits, NO_TAP_SHIFT);
 275                 if (retval != ERROR_OK)
 276                         return retval;
 277         } else {
 278                 retval = jtag_vpi_queue_tdi(buf, scan_bits, TAP_SHIFT);
 279                 if (retval != ERROR_OK)
 280                         return retval;
 281         }
 282
 283         if (cmd->end_state != TAP_DRSHIFT) {
 284                 /*
 285                  * As our JTAG is in an unstable state (IREXIT1 or DREXIT1), move it
 286                  * forward to a stable IRPAUSE or DRPAUSE.
 287                  */
 288                 retval = jtag_vpi_clock_tms(0);
 289                 if (retval != ERROR_OK)
 290                         return retval;
 291
 292                 if (cmd->ir_scan)
 293                         tap_set_state(TAP_IRPAUSE);
 294                 else
 295                         tap_set_state(TAP_DRPAUSE);
 296         }
 297
 298         retval = jtag_read_buffer(buf, cmd);
 299         if (retval != ERROR_OK)
 300                 return retval;
 301
 302         if (buf)
 303                 free(buf);
 304
 305         if (cmd->end_state != TAP_DRSHIFT) {
 306                 retval = jtag_vpi_state_move(cmd->end_state);
 307                 if (retval != ERROR_OK)
 308                         return retval;
 309         }
 310
 311         return ERROR_OK;
 312 }
 313
 314 static int jtag_vpi_runtest(int cycles, tap_state_t state)
 315 {
 316         int retval;
 317
 318         retval = jtag_vpi_state_move(TAP_IDLE);
 319         if (retval != ERROR_OK)
 320                 return retval;
 321
 322         retval = jtag_vpi_queue_tdi(NULL, cycles, NO_TAP_SHIFT);
 323         if (retval != ERROR_OK)
 324                 return retval;
 325
 326         return jtag_vpi_state_move(state);
 327 }
 328
 329 static int jtag_vpi_stableclocks(int cycles)
 330 {
 331         uint8_t tms_bits[4];
 332         int cycles_remain = cycles;
 333         int nb_bits;
 334         int retval;
 335         const int CYCLES_ONE_BATCH = sizeof(tms_bits) * 8;
 336
 337         assert(cycles >= 0);
 338
 339         /* use TMS=1 in TAP RESET state, TMS=0 in all other stable states */
 340         memset(&tms_bits, (tap_get_state() == TAP_RESET) ? 0xff : 0x00, sizeof(tms_bits));
 341
 342         /* send the TMS bits */
 343         while (cycles_remain > 0) {
 344                 nb_bits = (cycles_remain < CYCLES_ONE_BATCH) ? cycles_remain : CYCLES_ONE_BATCH;
 345                 retval = jtag_vpi_tms_seq(tms_bits, nb_bits);
 346                 if (retval != ERROR_OK)
 347                         return retval;
 348                 cycles_remain -= nb_bits;
 349         }
 350
 351         return ERROR_OK;
 352 }
 353
 354 static int jtag_vpi_execute_queue(void)
 355 {
 356         struct jtag_command *cmd;
 357         int retval = ERROR_OK;
 358
 359         for (cmd = jtag_command_queue; retval == ERROR_OK && cmd != NULL;
 360              cmd = cmd->next) {
 361                 switch (cmd->type) {
 362                 case JTAG_RESET:
 363                         retval = jtag_vpi_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 364                         break;
 365                 case JTAG_RUNTEST:
 366                         retval = jtag_vpi_runtest(cmd->cmd.runtest->num_cycles,
 367                                                   cmd->cmd.runtest->end_state);
 368                         break;
 369                 case JTAG_STABLECLOCKS:
 370                         retval = jtag_vpi_stableclocks(cmd->cmd.stableclocks->num_cycles);
 371                         break;
 372                 case JTAG_TLR_RESET:
 373                         retval = jtag_vpi_state_move(cmd->cmd.statemove->end_state);
 374                         break;
 375                 case JTAG_PATHMOVE:
 376                         retval = jtag_vpi_path_move(cmd->cmd.pathmove);
 377                         break;
 378                 case JTAG_TMS:
 379                         retval = jtag_vpi_tms(cmd->cmd.tms);
 380                         break;
 381                 case JTAG_SLEEP:
 382                         jtag_sleep(cmd->cmd.sleep->us);
 383                         break;
 384                 case JTAG_SCAN:
 385                         retval = jtag_vpi_scan(cmd->cmd.scan);
 386                         break;
 387                 default:
 388                         LOG_ERROR("BUG: unknown JTAG command type 0x%X",
 389                                   cmd->type);
 390                         retval = ERROR_FAIL;
 391                         break;
 392                 }
 393         }
 394
 395         return retval;
 396 }
 397
 398 static int jtag_vpi_init(void)
 399 {
 400         int flag = 1;
 401
 402         sockfd = socket(AF_INET, SOCK_STREAM, 0);
 403         if (sockfd < 0) {
 404                 LOG_ERROR("Could not create socket");
 405                 return ERROR_FAIL;
 406         }
 407
 408         memset(&serv_addr, 0, sizeof(serv_addr));
 409
 410         serv_addr.sin_family = AF_INET;
 411         serv_addr.sin_port = htons(server_port);
 412
 413         if (!server_address)
 414                 server_address = strdup(SERVER_ADDRESS);
 415
 416         serv_addr.sin_addr.s_addr = inet_addr(server_address);
 417
 418         if (serv_addr.sin_addr.s_addr == INADDR_NONE) {
 419                 LOG_ERROR("inet_addr error occured");
 420                 return ERROR_FAIL;
 421         }
 422
 423         if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
 424                 close(sockfd);
 425                 LOG_ERROR("Can't connect to %s : %u", server_address, server_port);
 426                 return ERROR_COMMAND_CLOSE_CONNECTION;
 427         }
 428
 429         if (serv_addr.sin_addr.s_addr == htonl(INADDR_LOOPBACK)) {
 430                 /* This increases performance drematically for local
 431                  * connections, which is the most likely arrangement
 432                  * for a VPI connection. */
 433                 setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (char *)&flag, sizeof(int));
 434         }
 435
 436         LOG_INFO("Connection to %s : %u succeed", server_address, server_port);
 437
 438         return ERROR_OK;
 439 }
 440
 441 static int jtag_vpi_quit(void)
 442 {
 443         free(server_address);
 444         return close(sockfd);
 445 }
 446
 447 COMMAND_HANDLER(jtag_vpi_set_port)
 448 {
 449         if (CMD_ARGC == 0)
 450                 LOG_WARNING("You need to set a port number");
 451         else
 452                 COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], server_port);
 453
 454         LOG_INFO("Set server port to %u", server_port);
 455
 456         return ERROR_OK;
 457 }
 458
 459 COMMAND_HANDLER(jtag_vpi_set_address)
 460 {
 461         free(server_address);
 462
 463         if (CMD_ARGC == 0) {
 464                 LOG_WARNING("You need to set an address");
 465                 server_address = strdup(SERVER_ADDRESS);
 466         } else
 467                 server_address = strdup(CMD_ARGV[0]);
 468
 469         LOG_INFO("Set server address to %s", server_address);
 470
 471         return ERROR_OK;
 472 }
 473
 474 static const struct command_registration jtag_vpi_command_handlers[] = {
 475         {
 476                 .name = "jtag_vpi_set_port",
 477                 .handler = &jtag_vpi_set_port,
 478                 .mode = COMMAND_CONFIG,
 479                 .help = "set the port of the VPI server",
 480                 .usage = "description_string",
 481         },
 482         {
 483                 .name = "jtag_vpi_set_address",
 484                 .handler = &jtag_vpi_set_address,
 485                 .mode = COMMAND_CONFIG,
 486                 .help = "set the address of the VPI server",
 487                 .usage = "description_string",
 488         },
 489         COMMAND_REGISTRATION_DONE
 490 };
 491
 492 struct jtag_interface jtag_vpi_interface = {
 493         .name = "jtag_vpi",
 494         .supported = DEBUG_CAP_TMS_SEQ,
 495         .commands = jtag_vpi_command_handlers,
 496         .transports = jtag_only,
 497
 498         .init = jtag_vpi_init,
 499         .quit = jtag_vpi_quit,
 500         .execute_queue = jtag_vpi_execute_queue,
 501 };