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 #define NO_TAP_SHIFT    0
  33 #define TAP_SHIFT       1
  34
  35 #define SERVER_ADDRESS  "127.0.0.1"
  36 #define SERVER_PORT     5555
  37
  38 #define XFERT_MAX_SIZE          512
  39
  40 #define CMD_RESET               0
  41 #define CMD_TMS_SEQ             1
  42 #define CMD_SCAN_CHAIN          2
  43 #define CMD_SCAN_CHAIN_FLIP_TMS 3
  44 #define CMD_STOP_SIMU           4
  45
  46 int server_port = SERVER_PORT;
  47 char *server_address;
  48
  49 int sockfd;
  50 struct sockaddr_in serv_addr;
  51
  52 struct vpi_cmd {
  53         int cmd;
  54         unsigned char buffer_out[XFERT_MAX_SIZE];
  55         unsigned char buffer_in[XFERT_MAX_SIZE];
  56         int length;
  57         int nb_bits;
  58 };
  59
  60 static int jtag_vpi_send_cmd(struct vpi_cmd *vpi)
  61 {
  62         int retval = write_socket(sockfd, vpi, sizeof(struct vpi_cmd));
  63         if (retval <= 0)
  64                 return ERROR_FAIL;
  65
  66         return ERROR_OK;
  67 }
  68
  69 static int jtag_vpi_receive_cmd(struct vpi_cmd *vpi)
  70 {
  71         int retval = read_socket(sockfd, vpi, sizeof(struct vpi_cmd));
  72         if (retval < (int)sizeof(struct vpi_cmd))
  73                 return ERROR_FAIL;
  74
  75         return ERROR_OK;
  76 }
  77
  78 /**
  79  * jtag_vpi_reset - ask to reset the JTAG device
  80  * @trst: 1 if TRST is to be asserted
  81  * @srst: 1 if SRST is to be asserted
  82  */
  83 static int jtag_vpi_reset(int trst, int srst)
  84 {
  85         struct vpi_cmd vpi;
  86
  87         vpi.cmd = CMD_RESET;
  88         vpi.length = 0;
  89         return jtag_vpi_send_cmd(&vpi);
  90 }
  91
  92 /**
  93  * jtag_vpi_tms_seq - ask a TMS sequence transition to JTAG
  94  * @bits: TMS bits to be written (bit0, bit1 .. bitN)
  95  * @nb_bits: number of TMS bits (between 1 and 8)
  96  *
  97  * Write a serie of TMS transitions, where each transition consists in :
  98  *  - writing out TCK=0, TMS=<new_state>, TDI=<???>
  99  *  - writing out TCK=1, TMS=<new_state>, TDI=<???> which triggers the transition
 100  * The function ensures that at the end of the sequence, the clock (TCK) is put
 101  * low.
 102  */
 103 static int jtag_vpi_tms_seq(const uint8_t *bits, int nb_bits)
 104 {
 105         struct vpi_cmd vpi;
 106         int nb_bytes;
 107
 108         nb_bytes = DIV_ROUND_UP(nb_bits, 8);
 109
 110         vpi.cmd = CMD_TMS_SEQ;
 111         memcpy(vpi.buffer_out, bits, nb_bytes);
 112         vpi.length = nb_bytes;
 113         vpi.nb_bits = nb_bits;
 114
 115         return jtag_vpi_send_cmd(&vpi);
 116 }
 117
 118 /**
 119  * jtag_vpi_path_move - ask a TMS sequence transition to JTAG
 120  * @cmd: path transition
 121  *
 122  * Write a serie of TMS transitions, where each transition consists in :
 123  *  - writing out TCK=0, TMS=<new_state>, TDI=<???>
 124  *  - writing out TCK=1, TMS=<new_state>, TDI=<???> which triggers the transition
 125  * The function ensures that at the end of the sequence, the clock (TCK) is put
 126  * low.
 127  */
 128
 129 static int jtag_vpi_path_move(struct pathmove_command *cmd)
 130 {
 131         uint8_t trans[DIV_ROUND_UP(cmd->num_states, 8)];
 132
 133         memset(trans, 0, DIV_ROUND_UP(cmd->num_states, 8));
 134
 135         for (int i = 0; i < cmd->num_states; i++) {
 136                 if (tap_state_transition(tap_get_state(), true) == cmd->path[i])
 137                         buf_set_u32(trans, i, 1, 1);
 138                 tap_set_state(cmd->path[i]);
 139         }
 140
 141         return jtag_vpi_tms_seq(trans, cmd->num_states);
 142 }
 143
 144 /**
 145  * jtag_vpi_tms - ask a tms command
 146  * @cmd: tms command
 147  */
 148 static int jtag_vpi_tms(struct tms_command *cmd)
 149 {
 150         return jtag_vpi_tms_seq(cmd->bits, cmd->num_bits);
 151 }
 152
 153 static int jtag_vpi_state_move(tap_state_t state)
 154 {
 155         if (tap_get_state() == state)
 156                 return ERROR_OK;
 157
 158         uint8_t tms_scan = tap_get_tms_path(tap_get_state(), state);
 159         int tms_len = tap_get_tms_path_len(tap_get_state(), state);
 160
 161         int retval = jtag_vpi_tms_seq(&tms_scan, tms_len);
 162         if (retval != ERROR_OK)
 163                 return retval;
 164
 165         tap_set_state(state);
 166
 167         return ERROR_OK;
 168 }
 169
 170 static int jtag_vpi_queue_tdi_xfer(uint8_t *bits, int nb_bits, int tap_shift)
 171 {
 172         struct vpi_cmd vpi;
 173         int nb_bytes = DIV_ROUND_UP(nb_bits, 8);
 174
 175         vpi.cmd = tap_shift ? CMD_SCAN_CHAIN_FLIP_TMS : CMD_SCAN_CHAIN;
 176
 177         if (bits)
 178                 memcpy(vpi.buffer_out, bits, nb_bytes);
 179         else
 180                 memset(vpi.buffer_out, 0xff, nb_bytes);
 181
 182         vpi.length = nb_bytes;
 183         vpi.nb_bits = nb_bits;
 184
 185         int retval = jtag_vpi_send_cmd(&vpi);
 186         if (retval != ERROR_OK)
 187                 return retval;
 188
 189         retval = jtag_vpi_receive_cmd(&vpi);
 190         if (retval != ERROR_OK)
 191                 return retval;
 192
 193         if (bits)
 194                 memcpy(bits, vpi.buffer_in, nb_bytes);
 195
 196         return ERROR_OK;
 197 }
 198
 199 /**
 200  * jtag_vpi_queue_tdi - short description
 201  * @bits: bits to be queued on TDI (or NULL if 0 are to be queued)
 202  * @nb_bits: number of bits
 203  */
 204 static int jtag_vpi_queue_tdi(uint8_t *bits, int nb_bits, int tap_shift)
 205 {
 206         int nb_xfer = DIV_ROUND_UP(nb_bits, XFERT_MAX_SIZE * 8);
 207         uint8_t *xmit_buffer = bits;
 208         int xmit_nb_bits = nb_bits;
 209         int i = 0;
 210         int retval;
 211
 212         while (nb_xfer) {
 213
 214                 if (nb_xfer ==  1) {
 215                         retval = jtag_vpi_queue_tdi_xfer(&xmit_buffer[i], xmit_nb_bits, tap_shift);
 216                         if (retval != ERROR_OK)
 217                                 return retval;
 218                 } else {
 219                         retval = jtag_vpi_queue_tdi_xfer(&xmit_buffer[i], XFERT_MAX_SIZE * 8, NO_TAP_SHIFT);
 220                         if (retval != ERROR_OK)
 221                                 return retval;
 222                         xmit_nb_bits -= XFERT_MAX_SIZE * 8;
 223                         i += XFERT_MAX_SIZE;
 224                 }
 225
 226                 nb_xfer--;
 227         }
 228
 229         return ERROR_OK;
 230 }
 231
 232 /**
 233  * jtag_vpi_clock_tms - clock a TMS transition
 234  * @tms: the TMS to be sent
 235  *
 236  * Triggers a TMS transition (ie. one JTAG TAP state move).
 237  */
 238 static int jtag_vpi_clock_tms(int tms)
 239 {
 240         const uint8_t tms_0 = 0;
 241         const uint8_t tms_1 = 1;
 242
 243         return jtag_vpi_tms_seq(tms ? &tms_1 : &tms_0, 1);
 244 }
 245
 246 /**
 247  * jtag_vpi_scan - launches a DR-scan or IR-scan
 248  * @cmd: the command to launch
 249  *
 250  * Launch a JTAG IR-scan or DR-scan
 251  *
 252  * Returns ERROR_OK if OK, ERROR_xxx if a read/write error occured.
 253  */
 254 static int jtag_vpi_scan(struct scan_command *cmd)
 255 {
 256         int scan_bits;
 257         uint8_t *buf = NULL;
 258         int retval = ERROR_OK;
 259
 260         scan_bits = jtag_build_buffer(cmd, &buf);
 261
 262         if (cmd->ir_scan) {
 263                 retval = jtag_vpi_state_move(TAP_IRSHIFT);
 264                 if (retval != ERROR_OK)
 265                         return retval;
 266         } else {
 267                 retval = jtag_vpi_state_move(TAP_DRSHIFT);
 268                 if (retval != ERROR_OK)
 269                         return retval;
 270         }
 271
 272         if (cmd->end_state == TAP_DRSHIFT) {
 273                 retval = jtag_vpi_queue_tdi(buf, scan_bits, NO_TAP_SHIFT);
 274                 if (retval != ERROR_OK)
 275                         return retval;
 276         } else {
 277                 retval = jtag_vpi_queue_tdi(buf, scan_bits, TAP_SHIFT);
 278                 if (retval != ERROR_OK)
 279                         return retval;
 280         }
 281
 282         if (cmd->end_state != TAP_DRSHIFT) {
 283                 /*
 284                  * As our JTAG is in an unstable state (IREXIT1 or DREXIT1), move it
 285                  * forward to a stable IRPAUSE or DRPAUSE.
 286                  */
 287                 retval = jtag_vpi_clock_tms(0);
 288                 if (retval != ERROR_OK)
 289                         return retval;
 290
 291                 if (cmd->ir_scan)
 292                         tap_set_state(TAP_IRPAUSE);
 293                 else
 294                         tap_set_state(TAP_DRPAUSE);
 295         }
 296
 297         retval = jtag_read_buffer(buf, cmd);
 298         if (retval != ERROR_OK)
 299                 return retval;
 300
 301         if (buf)
 302                 free(buf);
 303
 304         if (cmd->end_state != TAP_DRSHIFT) {
 305                 retval = jtag_vpi_state_move(cmd->end_state);
 306                 if (retval != ERROR_OK)
 307                         return retval;
 308         }
 309
 310         return ERROR_OK;
 311 }
 312
 313 static int jtag_vpi_runtest(int cycles, tap_state_t state)
 314 {
 315         int retval;
 316
 317         retval = jtag_vpi_state_move(TAP_IDLE);
 318         if (retval != ERROR_OK)
 319                 return retval;
 320
 321         retval = jtag_vpi_queue_tdi(NULL, cycles, TAP_SHIFT);
 322         if (retval != ERROR_OK)
 323                 return retval;
 324
 325         return jtag_vpi_state_move(state);
 326 }
 327
 328 static int jtag_vpi_stableclocks(int cycles)
 329 {
 330         return jtag_vpi_queue_tdi(NULL, cycles, TAP_SHIFT);
 331 }
 332
 333 static int jtag_vpi_execute_queue(void)
 334 {
 335         struct jtag_command *cmd;
 336         int retval = ERROR_OK;
 337
 338         for (cmd = jtag_command_queue; retval == ERROR_OK && cmd != NULL;
 339              cmd = cmd->next) {
 340                 switch (cmd->type) {
 341                 case JTAG_RESET:
 342                         retval = jtag_vpi_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
 343                         break;
 344                 case JTAG_RUNTEST:
 345                         retval = jtag_vpi_runtest(cmd->cmd.runtest->num_cycles,
 346                                                   cmd->cmd.runtest->end_state);
 347                         break;
 348                 case JTAG_STABLECLOCKS:
 349                         retval = jtag_vpi_stableclocks(cmd->cmd.stableclocks->num_cycles);
 350                         break;
 351                 case JTAG_TLR_RESET:
 352                         retval = jtag_vpi_state_move(cmd->cmd.statemove->end_state);
 353                         break;
 354                 case JTAG_PATHMOVE:
 355                         retval = jtag_vpi_path_move(cmd->cmd.pathmove);
 356                         break;
 357                 case JTAG_TMS:
 358                         retval = jtag_vpi_tms(cmd->cmd.tms);
 359                         break;
 360                 case JTAG_SLEEP:
 361                         jtag_sleep(cmd->cmd.sleep->us);
 362                         break;
 363                 case JTAG_SCAN:
 364                         retval = jtag_vpi_scan(cmd->cmd.scan);
 365                         break;
 366                 }
 367         }
 368
 369         return retval;
 370 }
 371
 372 static int jtag_vpi_init(void)
 373 {
 374         sockfd = socket(AF_INET, SOCK_STREAM, 0);
 375         if (sockfd < 0) {
 376                 LOG_ERROR("Could not create socket");
 377                 return ERROR_FAIL;
 378         }
 379
 380         memset(&serv_addr, 0, sizeof(serv_addr));
 381
 382         serv_addr.sin_family = AF_INET;
 383         serv_addr.sin_port = htons(server_port);
 384
 385         if (!server_address)
 386                 server_address = strdup(SERVER_ADDRESS);
 387
 388         serv_addr.sin_addr.s_addr = inet_addr(server_address);
 389
 390         if (serv_addr.sin_addr.s_addr == INADDR_NONE) {
 391                 LOG_ERROR("inet_addr error occured");
 392                 return ERROR_FAIL;
 393         }
 394
 395         if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
 396                 close(sockfd);
 397                 LOG_ERROR("Can't connect to %s : %u", server_address, server_port);
 398                 return ERROR_COMMAND_CLOSE_CONNECTION;
 399         }
 400
 401         LOG_INFO("Connection to %s : %u succeed", server_address, server_port);
 402
 403         return ERROR_OK;
 404 }
 405
 406 static int jtag_vpi_quit(void)
 407 {
 408         free(server_address);
 409         return close(sockfd);
 410 }
 411
 412 COMMAND_HANDLER(jtag_vpi_set_port)
 413 {
 414         if (CMD_ARGC == 0)
 415                 LOG_WARNING("You need to set a port number");
 416         else
 417                 COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], server_port);
 418
 419         LOG_INFO("Set server port to %u", server_port);
 420
 421         return ERROR_OK;
 422 }
 423
 424 COMMAND_HANDLER(jtag_vpi_set_address)
 425 {
 426         free(server_address);
 427
 428         if (CMD_ARGC == 0) {
 429                 LOG_WARNING("You need to set an address");
 430                 server_address = strdup(SERVER_ADDRESS);
 431         } else
 432                 server_address = strdup(CMD_ARGV[0]);
 433
 434         LOG_INFO("Set server address to %s", server_address);
 435
 436         return ERROR_OK;
 437 }
 438
 439 static const struct command_registration jtag_vpi_command_handlers[] = {
 440         {
 441                 .name = "jtag_vpi_set_port",
 442                 .handler = &jtag_vpi_set_port,
 443                 .mode = COMMAND_CONFIG,
 444                 .help = "set the port of the VPI server",
 445                 .usage = "description_string",
 446         },
 447         {
 448                 .name = "jtag_vpi_set_address",
 449                 .handler = &jtag_vpi_set_address,
 450                 .mode = COMMAND_CONFIG,
 451                 .help = "set the address of the VPI server",
 452                 .usage = "description_string",
 453         },
 454         COMMAND_REGISTRATION_DONE
 455 };
 456
 457 struct jtag_interface jtag_vpi_interface = {
 458         .name = "jtag_vpi",
 459         .supported = DEBUG_CAP_TMS_SEQ,
 460         .commands = jtag_vpi_command_handlers,
 461         .transports = jtag_only,
 462
 463         .init = jtag_vpi_init,
 464         .quit = jtag_vpi_quit,
 465         .execute_queue = jtag_vpi_execute_queue,
 466 };