Subversion Repositories or1k

/* jp-io-vpi.c -- JTAG communications vpi plugin

   Copyright (C) 2004 György Jeney, nog@sdf.lonestar.org

This file is part of OpenRISC 1000 Architectural Simulator.

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */

/* This plugs into an rtl simulator via vpi */

#include <stdio.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <unistd.h>

#include <stdint.h>

#include <fcntl.h>

#include <sys/un.h>

#include <errno.h>

#include <vpi_user.h>

/* The vpi<->jp connection is `mastered' by jp1.  Therefore we just sit doing

 * `nothing', waiting for jp1 to request or send us some data */

static uint8_t vpi_out; /* data that the sim gives to us */

static int jp_comm_m; /* The listening socket */

static int jp_comm; /* The socket for communitateing with jp1 */

static int jp_got_con; /* Have we got a connection ? */

static int count_comp; /* Has the predetermined cycle-count been reached ? */

static int jp_waiting; /* Is jp-waiting for count_comp ? */

int jp_check_con();

/*---------------------------------------------[ VPI interface to the sim ]---*/

/* Sends a byte from the sim */

int vpi_jp_out(char *xx)

{

  vpiHandle sys = vpi_handle(vpiSysTfCall, 0);

  vpiHandle argv = vpi_iterate(vpiArgument, sys);

  s_vpi_value value;

  if(!argv) {

    vpi_printf("$jp_out: missing destination argument\n");

    vpi_free_object(argv);

    return 0;

  }

  vpiHandle dat_to = vpi_scan(argv);

  if(vpi_get(vpiType, dat_to) != vpiNet) {

    vpi_printf("$jp_out: Must have a net as argument!!\n");

    vpi_free_object(argv);

    return 0;

  }

  value.format = vpiVectorVal;

  vpi_get_value(dat_to, &value);

  if((value.value.vector->bval & 1)) {

    vpi_free_object(argv);

    return 0;

  }

  vpi_out = value.value.vector->aval & 1;

  vpi_free_object(argv);

  return 0;

}

/* Sends a byte to the sim */

int vpi_jp_in(char *xx)

{

  int ret;

  uint8_t dat;

  s_vpi_vecval vec;

  s_vpi_value value;

  vpiHandle sys = vpi_handle(vpiSysTfCall, 0);

  vpiHandle argv;

  vpiHandle dat_to;

  vpiHandle dat_to_index;

  if(!jp_got_con) {

    if(!jp_check_con())

      return 0;

  }

  ret = read(jp_comm, &dat, 1);

  if(!ret)

    return 0;

  if((ret == -1) && (errno == EAGAIN))

    return 0;

  if(dat & 0x80) {

    switch(dat & 0x7f) {

    case 0:

      /* jp1 wants the TDO */

      write(jp_comm, &vpi_out, 1);

      return 0;

    case 1:

      /* jp wants a time-out */

      if(count_comp)

        write(jp_comm, &dat, 1); /* The value is irrelevent */

      else

        jp_waiting = 1;

      return 0;

    }

  }

  argv = vpi_iterate(vpiArgument, sys);

  /* We got the data, acknowledge it and send it on to the sim */

  if(!argv) {

    vpi_printf("$jp_in: missing destination argument\n");

    vpi_free_object(argv);

    return 0;

  }

  dat_to = vpi_scan(argv);

  if(vpi_get(vpiType, dat_to) != vpiMemory) {

    vpi_printf("$jp_in: Must have a memory as argument!!\n");

    vpi_free_object(argv);

    return 0;

  }

  value.format = vpiVectorVal;

  vec.aval = (dat & 0xf) | 0x10;

  vec.bval = 0;

  value.value.vector = &vec;

  dat_to_index = vpi_handle_by_index(dat_to, 0);

  vpi_put_value(dat_to_index, &value, 0, vpiNoDelay);

  vpi_free_object(argv);

  dat |= 0x10;

  write(jp_comm, &dat, 1);

  count_comp = 0;

  return 0;

}

/* tells us that we reached a predetermined cycle count */

int jp_wait_time(char *xx)

{

  uint8_t dat = 0;

  if(jp_waiting) {

    write(jp_comm, &dat, 1);

    jp_waiting = 0;

  }

  count_comp = 1;

  return 0;

}

/*---------------------------------------------------[ VPI<->jp functions ]---*/

int init_sock(char *xx)

{

  struct sockaddr_un addr;

  int ret;

  vpiHandle sys = vpi_handle(vpiSysTfCall, 0);

  vpiHandle argv = vpi_iterate(vpiArgument, sys);

  s_vpi_value value;

  if(!argv) {

    vpi_printf("$jp_init: missing destination argument\n");

    return 0;

  }

  vpiHandle sock = vpi_scan(argv);

/*

  if(vpi_get(vpiConstType, sock) != vpiStringConst) {

    vpi_printf("$jp_init: Must have a string as argument!!\n");

    vpi_free_object(argv);

    return 0;

  }

*/

  value.format = vpiStringVal;

  vpi_get_value(sock, &value);

  addr.sun_family = AF_UNIX;

  strcpy(addr.sun_path, value.value.str);

  if((jp_comm_m = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {

    fprintf(stderr, "Unable to create comm socket\n");

    return 0;

  }

  if(bind(jp_comm_m, (struct sockaddr *)&addr, sizeof(addr)) == -1) {

    fprintf(stderr, "Unable to bind to the unix socket %s\n", addr.sun_path);

    return 0;

  }

  if(listen(jp_comm_m, 1) == -1) {

    fprintf(stderr, "Unable to listen on %s (%s)\n", addr.sun_path,

            strerror(errno));

    return 0;

  }

  ret = fcntl(jp_comm_m, F_GETFL);

  ret |= O_NONBLOCK;

  fcntl(jp_comm_m, F_SETFL, ret);

  jp_got_con = 0;

  jp_waiting = 0;

  printf("Just registered socket!!!\n");

  return 0;

}

/* Checks to see if we got a connection */

int jp_check_con()

{

  int ret;

  if((jp_comm = accept(jp_comm_m, NULL, NULL)) == -1) {

    if(errno == EAGAIN)

      return 0;

    fprintf(stderr, "Unable to accept connection (%s)\n", strerror(errno));

    return 0;

  }

  /* Set the comm socket to non-blocking */

  ret = fcntl(jp_comm, F_GETFL);

  ret |= O_NONBLOCK;

  fcntl(jp_comm, F_SETFL, ret);

  jp_got_con = 1;

  return 1;

}

/*------------------------------------------------------------[ VPI stuff ]---*/

static void jtag_register()

{

  s_vpi_systf_data tf_data;

  tf_data.type      = vpiSysTask;

  tf_data.tfname    = "$jp_in";

  tf_data.calltf    = vpi_jp_in;

  tf_data.compiletf = 0;

  tf_data.sizetf    = 0;

  vpi_register_systf(&tf_data);

  tf_data.type      = vpiSysTask;

  tf_data.tfname    = "$jp_out";

  tf_data.calltf    = vpi_jp_out;

  tf_data.compiletf = 0;

  tf_data.sizetf    = 0;

  vpi_register_systf(&tf_data);

  tf_data.type      = vpiSysTask;

  tf_data.tfname    = "$jp_init";

  tf_data.calltf    = init_sock;

  tf_data.compiletf = 0;

  tf_data.sizetf    = 0;

  vpi_register_systf(&tf_data);

  tf_data.type      = vpiSysTask;

  tf_data.tfname    = "$jp_wait_time";

  tf_data.calltf    = jp_wait_time;

  tf_data.compiletf = 0;

  tf_data.sizetf    = 0;

  vpi_register_systf(&tf_data);

}

void (*vlog_startup_routines[])() = {

      jtag_register,

};