Subversion Repositories or1k

/* jp-io.c -- Low level JTAG communications
   Copyright (C) 2001 Marko Mlinar, markom@opencores.org
   Copyright (C) 2004 György Jeney, nog@sdf.lonestar.org
   Code for TCP/IP copied from gdb, by Chris Ziomkowski
 
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 handles all the low-level io with the selected cable */
 
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <sys/io.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
 
#include <sys/socket.h>
#include <sys/un.h>
 
#include "jp.h"
 
static int jp_parallel_init();
static void jp_parallel_out(uint8_t value);
static uint8_t jp_parallel_in();
static int jp_parallel_opt(int c, char *str);
 
static void jp_phys_wait();
 
static int jp_rtl_sim_init();
static void jp_rtl_sim_out(uint8_t value);
static uint8_t jp_rtl_sim_in();
static void jp_rtl_sim_wait();
static int jp_rtl_sim_opt(int c, char *str);
 
static int jp_vpi_init();
static void jp_vpi_out(uint8_t value);
static uint8_t jp_vpi_in();
static void jp_vpi_wait();
static int jp_vpi_opt(int c, char *str);
 
static uint8_t jp_xpc3_in();
static void jp_xpc3_out(uint8_t value);
 
static uint8_t jp_xess_in();
static void jp_xess_out(uint8_t value);
 
static struct jtag_cable {
  const char *name;
  uint8_t (*in_func)();
  void (*out_func)(uint8_t);
  int (*init_func)();
  void (*wait_func)();
  int (*opt_func)(int c, char *str);
  const char *opts;
  const char *help;
} jtag_cables[] = {
  { "rtl_sim", jp_rtl_sim_in, jp_rtl_sim_out, jp_rtl_sim_init, jp_rtl_sim_wait,
    jp_rtl_sim_opt, "d:",
    "-d [directory] Directory in which gdb_in.dat/gdb_out.dat may be found\n" },
  { "vpi", jp_vpi_in, jp_vpi_out, jp_vpi_init, jp_vpi_wait, jp_vpi_opt, "s:",
    "-s [socket] Location of socket that the vpi module created\n" },
  { "xpc3", jp_xpc3_in, jp_xpc3_out, jp_parallel_init, jp_phys_wait,
    jp_parallel_opt, "p:",
    "-p [port] Which port to use when communicateing with the parport hardware (eg. 0x378)\n" },
  { "xess", jp_xess_in, jp_xess_out, jp_parallel_init, jp_phys_wait,
    jp_parallel_opt, "p:",
    "-p [port] Which port to use when communicateing with the parport hardware (eg. 0x378)\n" },
  { NULL, NULL, NULL, NULL } };
 
static struct jtag_cable *jtag_cable_in_use = NULL; /* The current selected cable */
 
/* Only used for the parport */
static int base = 0x378;
 
/* Only used in the vpi */
static int vpi_comm;
static char *sock_loc = "/tmp/jp-vpi";
 
/* Only used for the rtl_sim */
static char *gdb_in = "gdb_in.dat";
static char *gdb_out = "gdb_out.dat";
 
void jp_out (uint8_t value)
{
  /* finally call the cable-specific out-function */
  jtag_cable_in_use->out_func(value);
 
  if(!(value & 1))
    debug("[%x%c]", (value & TDI_BIT) != 0, (value & TMS_BIT) ? '^' : '_');
  flush_debug();
}
 
/* Receive a byte from the board.  */
uint8_t jp_in()
{
  int data;
 
  /* Get the data from the board */
  data = jtag_cable_in_use->in_func();
 
  debug(" R%01X ", data);
  flush_debug();
  return data;
}
 
/* waits */
void jp_wait()
{
  jtag_cable_in_use->wait_func();
}
 
/* Selects a cable for use, returns non-null on success */
int jp_select_cable(const char *cable)
{
  int i;
 
  for(i = 0; jtag_cables[i].name; i++) {
    if(!strcmp(cable, jtag_cables[i].name)) {
      jtag_cable_in_use = &jtag_cables[i];
      return 1;
    }
  }
 
  return 0;
}
 
/* Calls the init-fucntion of the cable */
int jp_init_cable()
{
  return jtag_cable_in_use->init_func();
}
 
/* Parses command-line options specific to the selected cable */
int jp_cable_opt(int c, char *str)
{
  return jtag_cable_in_use->opt_func(c, str);
}
 
const char *jp_get_cable_args()
{
  return jtag_cable_in_use->opts;
}
 
/* Prints a (short) useage message for each availible cable */
void jp_print_cable_help()
{
  int i;
  printf("Availible cables: ");
 
  for(i = 0; jtag_cables[i].name; i++) {
    if(i)
      printf(", ");
    printf(jtag_cables[i].name);
  }
 
  printf("\n\nOptions availible for the cables:\n");
  for(i = 0; jtag_cables[i].name; i++) {
    if(!jtag_cables[i].help)
      continue;
    printf("  %s:\n    %s", jtag_cables[i].name, jtag_cables[i].help);
  }
}
 
/*-------------------------------------[ Parallel port specific functions ]---*/
static int jp_parallel_init()
{
  if (ioperm(base, 3, 1)) {
    fprintf(stderr, "Couldn't get the port at %x\n", base);
    perror("Root privileges are required.\n");
    return 0;
  }
  printf("Connected to parallel port at %x\n", base);
  printf("Dropping root privileges.\n");
  setreuid(getuid(), getuid());
  return 1;
}
 
static void jp_parallel_out(uint8_t value)
{
  outb(value, LPT_WRITE);
}
 
static uint8_t jp_parallel_in()
{
  return inb(LPT_READ);
}
 
static int jp_parallel_opt(int c, char *str)
{
  switch(c) {
  case 'p':
    if(!sscanf(str, "%x", &base)) {
      fprintf(stderr, "p parameter must have a hex number as parameter\n");
      return 0;
    }
    break;
  default:
    fprintf(stderr, "Unknown parameter '%c'\n", c);
    return 0;
  }
  return 1;
}
 
/*-----------------------------------------[ Physical board wait function ]---*/
static void jp_phys_wait()
{
  /* FIXME: this needs some real TLC */
  int i;
  volatile int j;
  for(i = 0; i < 1000; i++)
    j = i;
}
 
/*----------------------------------------------[ xpc3 specific functions ]---*/
static void jp_xpc3_out(uint8_t value)
{
  uint8_t out = 0;
 
  /* First convert the bits in value byte to the ones that the cable wants */
  if(value & TCLK_BIT)
    out |= 0x02; /* D1 pin 3 */
  if(value & TRST_BIT)
    out |= 0x10; /* Not used */
  if(value & TDI_BIT)
    out |= 0x01; /* D0 pin 2 */
  if(value & TMS_BIT)
    out |= 0x04; /* D2 pin 4 */
 
  jp_parallel_out(out);
}
 
static uint8_t jp_xpc3_in()
{
  uint8_t in;
 
  in = jp_parallel_in();
 
  if(in & 0x10) /* S6 pin 13 */
    return 1;
  return 0;
}
 
/*----------------------------------------------[ xess specific functions ]---*/
static void jp_xess_out(uint8_t value)
{
  uint8_t out = 0;
 
  /* First convert the bits in value byte to the ones that the cable wants */
  if(value & TCLK_BIT)
    out |= 0x04; /* D2 pin 4 */
  if(value & TRST_BIT)
    out |= 0x08; /* D3 pin 5 */
  if(value & TDI_BIT)
    out |= 0x10; /* D4 pin 6 */
  if(value & TMS_BIT)
    out |= 0x20; /* D3 pin 5 */
 
  jp_parallel_out(out);
}
 
static uint8_t jp_xess_in()
{
  uint8_t in;
 
  in = jp_parallel_in();
 
  if(in & 0x20) /* S5 pin 12*/
    return 1;
  return 0;
}
 
/*-------------------------------------------[ rtl_sim specific functions ]---*/
static int jp_rtl_sim_init()
{
  FILE *fin = fopen (gdb_in, "wt+");
  if(!fin) {
    fprintf(stderr, "Can not open %s\n", gdb_in);
    return 0;
  }
  fclose(fin);
  return 1;
}
 
static void jp_rtl_sim_out(uint8_t value)
{
  FILE *fout;
  int num_read;
  int r;
  fout = fopen(gdb_in, "wt+");
  fprintf(fout, "F\n");
  fclose(fout);
  fout = fopen(gdb_out, "wt+");
  fprintf(fout, "%02X\n", value);
  fclose(fout);
  do {
    fout = fopen(gdb_out, "rt");
    r = fscanf(fout,"%x", &num_read);
    fclose(fout);
  } while(!r || (num_read != (0x10 | value)));
}
 
static uint8_t jp_rtl_sim_in()
{
  FILE *fin = 0;
  char ch;
  uint8_t data;
  while(1) {
    fin = fopen(gdb_in, "rt");
    if(!fin)
      continue;
    ch = fgetc(fin);
    fclose(fin);
    if((ch != '0') && (ch != '1'))
      continue;
    else
      break;
  }
  data = ch == '1' ? 1 : 0;
  return data;
}
 
static void jp_rtl_sim_wait()
{
  usleep(1000);
}
 
static int jp_rtl_sim_opt(int c, char *str)
{
  switch(c) {
  case 'd':
    if(!(gdb_in = malloc(strlen(str) + 12))) { /* 12 == strlen("gdb_in.dat") + 2 */
      fprintf(stderr, "Unable to allocate enough memory\n");
      return 0;
    }
    if(!(gdb_out = malloc(strlen(str) + 13))) { /* 13 == strlen("gdb_out.dat") + 2 */
      fprintf(stderr, "Unable to allocate enough memory\n");
      free(gdb_in);
      return 0;
    }
 
    sprintf(gdb_in, "%s/gdb_in.dat", str);
    sprintf(gdb_out, "%s/gdb_out.dat", str);
    break;
  default:
    fprintf(stderr, "Unknown parameter '%c'\n", c);
    return 0;
  }
  return 1;
}
 
/*-----------------------------------------------[ VPI specific functions ]---*/
static int jp_vpi_init()
{
  struct sockaddr_un addr;
 
  if((vpi_comm = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
    fprintf(stderr, "Unable to create socket (%s)\n", strerror(errno));
    return 0;
  }
 
  addr.sun_family = AF_UNIX;
  strcpy(addr.sun_path, sock_loc);
 
  if(connect(vpi_comm, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
    fprintf(stderr, "Unable to connect to %s (%s)\n", addr.sun_path,
            strerror(errno));
    return 0;
  }
  return 1;
}
 
static void jp_vpi_out(uint8_t value)
{
  uint8_t ack;
 
  /* Send the data to the socket */
  write(vpi_comm, &value, 1);
 
  do {
    /* Ok, read the data */
    read(vpi_comm, &ack, 1);
  } while(ack != (value | 0x10));
}
 
static uint8_t jp_vpi_in()
{
  uint8_t dat;
 
  /* ask vpi to send us the out-bit */
  dat = 0x80;
  write(vpi_comm, &dat, 1);
 
  /* Wait and read the data */
  read(vpi_comm, &dat, 1);
 
  if(dat > 1)
    fprintf(stderr, "Unexpected value: %i\n", dat);
 
  return dat;
}
 
static void jp_vpi_wait()
{
  uint8_t dat = 0x81;
 
  /* Get the sim to reply when the timeout has been reached */
  write(vpi_comm, &dat, 1);
 
  /* block, waiting for the data */
  read(vpi_comm, &dat, 1);
}
 
static int jp_vpi_opt(int c, char *str)
{
  switch(c) {
  case 's':
    if(!(sock_loc = strdup(str))) {
      fprintf(stderr, "Unable to allocate memory\n");
      return 0;
    }
    break;
  default:
    fprintf(stderr, "Unknown parameter '%c'\n", c);
    return 0;
  }
  return 1;
}