URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [jtag.c] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log


/* Remote debugging interface for JTAG debugging protocol.
   JTAG connects to or1k target ops. See or1k-tdep.c
 
   Copyright 1993-1995, 2000 Free Software Foundation, Inc.
   Contributed by Cygnus Support.  Written by Marko Mlinar
   <markom@opencores.org>
   Areas noted by (CZ) were modified by Chris Ziomkowski
   <chris@asics.ws>
 
   This file is part of GDB.
 
   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., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */
 
#include "defs.h"
#include "inferior.h"
#include "bfd.h"
#include "symfile.h"
#include "gdb_wait.h"
#include "gdbcmd.h"
#include "gdbcore.h"
#include "serial.h"
#include "target.h"
#include "remote-utils.h"
#include "gdb_string.h"
#include "tm.h"
/* Added by CZ 24/05/01 */
#include <sys/poll.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>
 
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
 
#define TCLK (0x01)
#define TRST (0x02)
#define JTAG_WAIT()
#define NUM_RETRIES (16)
#define JTAG_RETRY_WAIT() usleep (100)
 
/* Selects crc trailer size in bits. Currently supported: 8 */
#define CRC_SIZE (8)
 
/* Scan chain size in bits.  */
#define SC_SIZE (4)
 
/* Scan chain info. */
/* *INDENT-OFF* */
static int chain_addr_size[] = { 0,  32, 0,  0,  5  };
static int chain_data_size[] = { 0,  32, 0,  32, 32 };
static int chain_is_valid[]  = { 0,  1,  0,  1,  1  };
static int chain_has_crc[]   = { 0,  1,  0,  1,  1  };
static int chain_has_rw[]    = { 0,  1,  0,  0,  1  };
/* *INDENT-OFF* */
 
/* Currently selected scan chain - just to prevent unnecessary
   transfers. */
static int current_chain;
 
/* Designates whether we are in SELECT_DR state, otherwise in
   RUN TEST/IDLE */
static int select_dr = 0;
 
/* CZ - 24/05/01 - Changed to structure for remote/local */
typedef enum {
  JTAG_NOT_CONNECTED = 0,
  JTAG_LOCAL = 1,
  JTAG_REMOTE = 2,
} jtag_location;
 
typedef struct {
  union {
    int lp; /* Printer compatible device we have open.  */
    int fd; /* Socket for remote or1k jtag interface */
  } device;
  jtag_location location;
} jtag_connection;
 
/* Our current connect information */
static jtag_connection connection;
 
/* Crc of current read or written data.  */
static int crc_r, crc_w = 0;
 
/* Generates new crc, sending in new bit input_bit */
 
static int
crc_calc (int crc, int input_bit)
{
  int c;
  int new_crc;
  int d;
 
#if (CRC_SIZE == 8)
  d = input_bit&1;
  c = crc;
 
  /* Move queue left.  */
  new_crc = crc << 1;
 
  /* Mask upper five bits.  */
  new_crc &= 0xF8;
 
  /* Set lower three bits */
  new_crc |= (d ^ ((c >> 7)&1));
  new_crc |= (d ^ ((c >> 0)&1) ^ ((c >> 7)&1)) << 1;
  new_crc |= (d ^ ((c >> 1)&1) ^ ((c >> 7)&1)) << 2;
  return new_crc;
#else
  return 0;
#endif
}
 
/* Resets JTAG.
   Writes TRST=0
   and    TRST=1 */
 
static void
jp1_reset_JTAG ()
{
  unsigned char data;
  int lp = connection.device.lp;         /* CZ */
 
  if(connection.location != JTAG_LOCAL)
    error("jp1_reset_JTAG called without a local connection!");
 
  data = 0;
  write (lp, &data, sizeof (data));
  JTAG_WAIT();
  data = TRST;
  write (lp, &data, sizeof (data));
  JTAG_WAIT();
}
 
/* Writes TCLK=0, TRST=1, TMS=bit0, TDI=bit1
   and    TCLK=1, TRST=1, TMS=bit0, TDI=bit1 */
 
static void
jp1_write_JTAG (packet)
     unsigned char packet;
{
  unsigned char data;
  int lp = connection.device.lp;    /* CZ */
 
  if(connection.location != JTAG_LOCAL)
    error("jp1_write_JTAG called without a local connection!");
 
  data = ((packet & 3) << 2) | TRST;
  write (lp, &data, sizeof (data));
  JTAG_WAIT();
  crc_w = crc_calc (crc_w, (packet >> 1)&1);
 
  /* rise clock */
  data |= TCLK;
  write (lp, &data, sizeof (data));
  JTAG_WAIT();
}
 
/* Reads TDO, using IOCTL.  */
 
static int
jp1_read_JTAG ()
{
  int data;
 
  if(connection.location != JTAG_LOCAL)    /* CZ */
    error("jp1_read_JTAG called without a local connection!");
 
  ioctl (data, 0x60b, &data);
  data = ((data & 0x80) != 0);
  crc_r = crc_calc (crc_r, data);
  return data;
}
 
/* Writes bitstream.  MS bit first.  */
 
static void
jp1_write_stream (stream, len, set_last_bit)
     ULONGEST stream;
     int len;
     int set_last_bit;
{
  int i;
  if (len <= 0) return;
  for (i = len - 1; i > 0; i--)
    jp1_write_JTAG (((stream >> i) & 1) << 1);
 
  if (set_last_bit)
    jp1_write_JTAG (((stream & 1) << 1) | 1);
  else
    jp1_write_JTAG ((stream & 1) << 1);
}
 
/* Gets bitstream.  MS bit first.  */
 
static ULONGEST
jp1_read_stream (len, stream, set_last_bit)
     int len;
     unsigned long stream;
     int set_last_bit;
{
  int i;
  ULONGEST data;
 
  if (len <= 0) return;
  data = 0;
  for (i = 0; i < len-1; i++)
    {
      jp1_write_JTAG (0 + ((stream & 1) << 1));
      stream >>= 1;
      data <<= 1;
      data |= jp1_read_JTAG ();
    }
 
  if (set_last_bit)
    jp1_write_JTAG (1 + (stream & 1) << 1);
  else
    jp1_write_JTAG (0 + (stream & 1) << 1);
  data <<= 1;
  data |= jp1_read_JTAG ();
  return data;
}
 
/* Goes into SELECT_IR state. Should be called before every control write.  */
 
static void
jp1_prepare_control ()
{
  if (!select_dr)
    jp1_write_JTAG (1); /* SELECT_DR SCAN */
  jp1_write_JTAG (1);   /* SELECT_IR SCAN */
  select_dr = 0;
}
 
/* Added by CZ 24/05/01 */
static int jtag_proxy_write(int fd,void* buf,int len)
{
  int n;
  char* w_buf = (char*)buf;
  struct pollfd block;
 
  while(len)
    {
      if((n = write(fd,w_buf,len)) < 0)
        {
          switch(errno)
            {
            case EWOULDBLOCK: /* or EAGAIN */
              /* We've been called on a descriptor marked
                 for nonblocking I/O. We better simulate
                 blocking behavior. */
              block.fd = fd;
              block.events = POLLOUT;
              block.revents = 0;
              poll(&block,1,-1);
              continue;
            case EINTR:
              continue;
            case EPIPE:
              return JTAG_PROXY_SERVER_TERMINATED;
            default:
              return errno;
            }
        }
      else
        {
          len -= n;
          w_buf += n;
        }
    }
  return 0;
}
 
/* Added by CZ 24/05/01 */
static int jtag_proxy_read(int fd,void* buf,int len)
{
  int n;
  char* r_buf = (char*)buf;
  struct pollfd block;
 
  while(len)
    {
      if((n = read(fd,r_buf,len)) < 0)
        {
          switch(errno)
            {
            case EWOULDBLOCK: /* or EAGAIN */
              /* We've been called on a descriptor marked
                 for nonblocking I/O. We better simulate
                 blocking behavior. */
              block.fd = fd;
              block.events = POLLIN;
              block.revents = 0;
              poll(&block,1,-1);
              continue;
            case EINTR:
              continue;
            default:
              return errno;
            }
        }
      else if(n == 0)
        return JTAG_PROXY_SERVER_TERMINATED;
      else
        {
          len -= n;
          r_buf += n;
        }
    }
  return 0;
}
 
static int ReadResponse(int fd,void* buffer,int len)
{
  int32_t status = 0;
  int result;
  char* buf = (char*)buffer;
 
        result = jtag_proxy_read(fd,&status,4);
 
  status = ntohl(status);
  *((int32_t*)buffer) = status;
 
  if(result)    {printf("result %i %x\n", result, result); return result;}
  if(status)    {printf("status %i %x\n", status, status); return status;}
 
  result = jtag_proxy_read(fd,&buf[4],len-4);
  return result;
}
 
/* Added by CZ 24/05/01 */
#ifndef ANSI_PROTOTYPES
static int jtag_send_proxy(va_alist)
va_dcl
#else
static int jtag_send_proxy(int command,...)
#endif
{
  va_list ap;
  int result = 0;
  int fd = connection.device.fd;
  JTAGProxyWriteMessage xmit_write;
  JTAGProxyReadMessage xmit_read;
  JTAGProxyChainMessage xmit_chain;
  JTAGProxyBlockWriteMessage *xmit_bwrite;
  JTAGProxyBlockReadMessage xmit_bread;
  JTAGProxyWriteResponse recv_write;
  JTAGProxyReadResponse recv_read;
  JTAGProxyChainResponse recv_chain;
  JTAGProxyBlockWriteResponse recv_bwrite;
  JTAGProxyBlockReadResponse recv_bread;
  unsigned long long data,* ret_val;
  uint32_t word1; /* Use word1 and word2 to ease portability to platforms */
  uint32_t word2; /* without long long and for alignment reasons */
  unsigned long  address;
  unsigned long* b_data;
  int nRegisters;
  int len,i;
 
#ifndef ANSI_PROTOTYPES
  int command;
 
  va_start(ap);
  command = va_arg(ap,int);
#else
  va_start(ap, command);
#endif
 
 
 
  if(connection.location == JTAG_REMOTE)
    {
      switch(command)
        {
        case JTAG_COMMAND_READ:
          xmit_read.command = htonl(command);
          xmit_read.length = htonl(sizeof(xmit_read)-8);
          xmit_read.address = htonl(va_arg(ap,int));
          ret_val = va_arg(ap,unsigned long long *);
          /* intentional single equals */
          if(result = jtag_proxy_write(fd,&xmit_read,sizeof(xmit_read)))
            break;
          if(result = ReadResponse(fd,&recv_read,sizeof(recv_read)))
            break;
          result = ntohl(recv_read.status);
          word1 = ntohl(recv_read.data_H);
          word2 = ntohl(recv_read.data_L);
          *ret_val = (((unsigned long long)word1) << 32) | word2;
          break;
        case JTAG_COMMAND_WRITE:
          xmit_write.command = htonl(command);
          xmit_write.length = htonl(sizeof(xmit_write)-8);
          xmit_write.address = htonl(va_arg(ap,int));
          data = va_arg(ap,unsigned long long);
          word1 = htonl(data >> 32);
          word2 = htonl(data & 0xFFFFFFFF);
          xmit_write.data_H = word1;
          xmit_write.data_L = word2;
          if(result = jtag_proxy_write(fd,&xmit_write,sizeof(xmit_write)))
            break;
          if(result = ReadResponse(fd,&recv_write,sizeof(recv_write)))
            break;
          result = recv_write.status;
          break;
        case JTAG_COMMAND_BLOCK_WRITE:
          address = va_arg(ap,unsigned long);
          b_data = va_arg(ap,unsigned long*);
          nRegisters = va_arg(ap,int);
          len = sizeof(JTAGProxyBlockWriteMessage) + (nRegisters-1)*4;
          xmit_bwrite = (JTAGProxyBlockWriteMessage*)malloc(len);
          xmit_bwrite->command = htonl(command);
          xmit_bwrite->length = htonl(len-8);
          xmit_bwrite->address = htonl(address);
          xmit_bwrite->nRegisters = htonl(nRegisters);
          for(i=0;i<nRegisters;i++)
            xmit_bwrite->data[i] = htonl(b_data[i]);
          if(!(result = jtag_proxy_write(fd,xmit_bwrite,len)) &&
             !(result = ReadResponse(fd,&recv_bwrite,sizeof(recv_bwrite))))
            result = recv_bwrite.status;
          free(xmit_bwrite);
          xmit_bwrite = NULL;
          break;
        case JTAG_COMMAND_BLOCK_READ:
          address = va_arg(ap,unsigned long);
          b_data = va_arg(ap,unsigned long*);
          nRegisters = va_arg(ap,int);
          xmit_bread.command = htonl(command);
          xmit_bread.length = htonl(sizeof(xmit_bread)-8);
          xmit_bread.address = htonl(address);
          xmit_bread.nRegisters = htonl(nRegisters);
          if(result = jtag_proxy_write(fd,&xmit_bread,sizeof(xmit_bread)))
            break;
          if(result = ReadResponse(fd,&recv_bread,sizeof(recv_bread)))
            break;
          b_data[0] = ntohl(recv_bread.data[0]);
          recv_bread.nRegisters = ntohl(recv_bread.nRegisters);
          if(result = jtag_proxy_read(fd,&b_data[1],4*(recv_bread.nRegisters-1)))
            break;
          if(recv_bread.nRegisters != nRegisters)
            result = JTAG_PROXY_PROTOCOL_ERROR;
          else
            {
              for(i=1;i<nRegisters;i++)
                b_data[i] = ntohl(b_data[i]);
            }
          break;
        case JTAG_COMMAND_CHAIN:
          xmit_chain.command = htonl(command);
          xmit_chain.length = htonl(sizeof(xmit_chain)-8);
          xmit_chain.chain = htonl(va_arg(ap,unsigned int));
          if(result = jtag_proxy_write(fd,&xmit_chain,sizeof(xmit_chain)))
            break;
          if(result = ReadResponse(fd,&recv_chain,sizeof(recv_chain)))
            break;
          result = recv_chain.status;
          break;
        default:
          result = JTAG_PROXY_INVALID_COMMAND;
          break;
        }
      va_end(ap);
    }
  else
    {
      va_end(ap);
      error("jtag_send_proxy called without a remote proxy connection!");
      result = JTAG_PROXY_NO_CONNECTION;
    }
 
  if(result == JTAG_PROXY_SERVER_TERMINATED)
    {
      close(connection.device.fd);
      connection.device.fd = 0;
      connection.location = JTAG_NOT_CONNECTED;
    }
 
  return result;
}
 
/* Added by CZ 24/05/01 */
#ifndef ANSI_PROTOTYPES
static void jtag_proxy_error(va_alist)
va_dcl
#else
static void jtag_proxy_error(int result,int command,...)
#endif
{
  va_list ap;
  char sTemp[256];
 
#ifndef ANSI_PROTOTYPES
  int result;
  int command;
 
  va_start(ap);
  result = va_arg(ap,int);
  command = va_arg(ap,int);
#else
  va_start(ap, command);
#endif
 
  switch(command)
    {
    case JTAG_COMMAND_READ:
      sprintf(sTemp,"An error was reported by the proxy server. The command was:\n"
              "\"JTAG_COMMAND_READ\",%u,0x%08x\nThe command returned %d.\n",
              va_arg(ap,unsigned int),va_arg(ap,unsigned long long*),result);
      error(sTemp);
      break;
    case JTAG_COMMAND_WRITE:
      sprintf(sTemp,"An error was reported by the proxy server. The command was:\n"
              "\"JTAG_COMMAND_WRITE\",%u,0x%016llx\nThe command returned %d.\n",
              va_arg(ap,unsigned int),va_arg(ap,unsigned long long),result);
      error(sTemp);
      break;
    case JTAG_COMMAND_CHAIN:
      sprintf(sTemp,"An error was reported by the proxy server. The command was:\n"
              "\"JTAG_COMMAND_CHAIN\",%u. The command returned %d.\n",
              va_arg(ap,unsigned int));
      error(sTemp);
      break;
    case JTAG_COMMAND_BLOCK_READ:
      sprintf(sTemp,"An error was reported by the proxy server. The command was:\n"
              "\"JTAG_COMMAND_BLOCK_READ\",0x%08x,0x%08x,%d\nThe command returned %d.\n",
              va_arg(ap,unsigned long),va_arg(ap,unsigned long),va_arg(ap,int),result);
      error(sTemp);
      break;
    case JTAG_COMMAND_BLOCK_WRITE:
    default:
      sprintf(sTemp,"An error was reported by the proxy server. The command was:\n"
              "\"JTAG_COMMAND_BLOCK_WRITE\",0x%08x,0x%08x,%d\nThe command returned %d.\n",
              va_arg(ap,unsigned long),va_arg(ap,unsigned long),va_arg(ap,int),result);
      error(sTemp);
      break;
    }
  va_end(ap);
}
 
/* Sets register/memory regno to data.  */
 
/* CZ 08/06/01: I am not sure how error checking is intended to
   be implemented here. It appears that no indication is returned
   to the caller as you have in standard unix system calls. Therefore,
   I guess the only way to use these functions when you want to know
   the exact position of the error is to manually clear err, call the
   function, and then manually check err. I have also made some changes
   where necessary because no value was returned at all int jtag_read_reg.
*/
 
void
jtag_write_reg (regno, data)
     int regno;
     ULONGEST data;
{
  int crc_read, crc_write, crc_ok, retry;
  int result;
 
#ifdef DEBUG_JTAG
  printf_unfiltered ("write reg %x <- %x\n", regno, data);
  fflush (stdout);
#endif
  switch(connection.location) /* CZ */
    {
    case JTAG_LOCAL:
      if (!select_dr)
        jp1_write_JTAG (1); /* SELECT_DR SCAN */
      select_dr = 1;
 
      /* If we don't have rw bit, we assume chain
         is read only. */
      if (!chain_has_rw[current_chain])
        error ("Internal: Chain not writable.");
 
      for (retry = 0; retry < NUM_RETRIES; retry++)
        {
          jp1_write_JTAG (0); /* CAPTURE_DR */
          jp1_write_JTAG (0); /* SHIFT_DR */
          crc_w = 0;
 
          /* write addr */
          jp1_write_stream (regno, chain_addr_size[current_chain], 0);
 
          /* write (R/W=1) - we tested that previously. */
          jp1_write_JTAG (2);
 
          /* write data */
          jp1_write_stream (data, chain_data_size[current_chain], 0);
          if (chain_has_crc[current_chain])
            {
              crc_write = crc_w;
 
              /* write CRC, EXIT1_DR */
              crc_read = jp1_read_stream (crc_write, CRC_SIZE, 1);
            }
          jp1_write_JTAG (1); /* UPDATE_DR */
 
          /* Did JTAG receive packet correctly? */
          if (chain_has_crc[current_chain])
            crc_ok = jp1_read_JTAG ();
          jp1_write_JTAG (1); /* SELECT_DR */
          if (chain_has_crc[current_chain])
            {
              if ((crc_read == crc_write) && (crc_ok))
                return;
              JTAG_RETRY_WAIT();
            }
          else return;
        }
      err = ERR_CRC;
      break;
    case JTAG_REMOTE:
      if(result = jtag_send_proxy(JTAG_COMMAND_WRITE,regno,data))
        {
          jtag_proxy_error(result,JTAG_COMMAND_WRITE,regno,data);
          err = result;
        }
      break;
    default:
      error("jtag_write_reg called with no connection!");
      break;
    }
#ifdef DEBUG_JTAG
  printf_unfiltered ("!write reg\n");
  fflush (stdout);
#endif
}
 
/* Reads register/memory from regno.  */
 
ULONGEST
jtag_read_reg (regno)
     unsigned int regno;
{
  ULONGEST data;
  int crc_read, crc_write, crc_actual_read,  retry, crc_ok;
  int result;
 
#ifdef DEBUG_JTAG
  printf_unfiltered ("read reg %x\n", regno);
  fflush (stdout);
#endif
  switch(connection.location)
    {
    case JTAG_LOCAL:
      if (!select_dr)
        jp1_write_JTAG (1); /* SELECT_DR SCAN */
      select_dr = 1;
 
      for (retry = 0; retry < NUM_RETRIES; retry++)
        {
          jp1_write_JTAG (0); /* CAPTURE_DR */
          jp1_write_JTAG (0); /* SHIFT_DR */
          crc_w = 0;
 
          /* write addr */
          jp1_write_stream (regno, chain_addr_size[current_chain], 0);
 
          /* read (R/W=0) */
          if (chain_has_rw[current_chain])
            jp1_write_JTAG (0);
          if (chain_has_crc[current_chain])
            {
              crc_r = 0;
 
              /* data = 0 */
              data = jp1_read_stream (0, chain_data_size[current_chain], 0);
              crc_write = crc_w;
              crc_actual_read = crc_read;
 
              /* Send my crc, EXIT1_DR */
              crc_read = jp1_read_stream (crc_write, CRC_SIZE, 1);
            }
          jp1_write_JTAG (1); /* UPDATE_DR */
 
          /* Did JTAG receive packet correctly? */
          if (chain_has_crc[current_chain])
            crc_ok = jp1_read_JTAG ();
          jp1_write_JTAG (1); /* SELECT_DR */
          if (chain_has_crc[current_chain])
            {
              if ((crc_read == crc_actual_read) && (crc_ok))
                return -1;  /* CZ */
              JTAG_RETRY_WAIT();
            }
          else
            return -1;  /* CZ */
        }
      err = ERR_CRC;
      break;
    case JTAG_REMOTE:
      if(result = jtag_send_proxy(JTAG_COMMAND_READ,regno,&data))
        {
          jtag_proxy_error(result,JTAG_COMMAND_READ,regno,&data);
          err = result;
        }
      break;
    default:
      error("jtag_write_reg called with no connection!");
      break;
    }
 
#ifdef DEBUG_JTAG
  printf_unfiltered ("read reg %x\n", data);
  fflush (stdout);
#endif
  return data;  /* CZ */
}
 
int jtag_write_block(unsigned int regno,void* data,int nRegisters)
{
  unsigned long* buffer = (unsigned long*)data;
  int i,result;
 
  if(nRegisters == 1) {
    jtag_write_reg(regno, *buffer);
    return err;
  }
 
#ifdef DEBUG_JTAG
  printf_unfiltered ("write block %x,%i\n", regno, nRegisters);
  fflush (stdout);
#endif
 
  err = 0;
  switch(connection.location)
    {
    case JTAG_LOCAL:         /* We can't do any better than this locally */
      for(i=0;i<nRegisters;i++)
        jtag_write_reg(regno+i,(ULONGEST)buffer[i]);
      break;
    case JTAG_REMOTE:
      if(result = jtag_send_proxy(JTAG_COMMAND_BLOCK_WRITE,regno,data,nRegisters))
        {
          jtag_proxy_error(result,JTAG_COMMAND_BLOCK_WRITE,regno,data,nRegisters);
          err = result;
        }
      break;
    default:
      error("jtag_write_reg called with no connection!");
      break;
    }
 
#ifdef DEBUG_JTAG
  printf_unfiltered ("!write block\n");
  fflush (stdout);
#endif
  return err;
}
 
int jtag_read_block(unsigned int regno,void* data,int nRegisters)
{
  unsigned long* buffer = (unsigned long*)data;
  int i,result;
 
#ifdef DEBUG_JTAG
  printf_unfiltered ("read block %x,%i\n", regno, nRegisters);
  fflush (stdout);
#endif
 
  /*  if(nRegisters == 1) {
    *buffer = jtag_read_reg(regno);
    return err;
    }*/
  err = 0;
  switch(connection.location)
    {
    case JTAG_LOCAL:         /* We can't do any better than this locally */
      for(i=0;i<nRegisters;i++)
        buffer[i] = (unsigned long)jtag_read_reg(regno+i);
      break;
    case JTAG_REMOTE:
      if(result = jtag_send_proxy(JTAG_COMMAND_BLOCK_READ,regno,data,nRegisters))
        {
          jtag_proxy_error(result,JTAG_COMMAND_BLOCK_READ,regno,data,nRegisters);
          err = result;
        }
      break;
    default:
      error("jtag_write_reg called with no connection!");
      break;
    }
 
#ifdef DEBUG_JTAG
  printf_unfiltered ("read block\n");
  fflush (stdout);
#endif  
  return err;
}
 
/* Sets scan chain.  */
 
void
jtag_set_chain (chain)
     int chain;
{
  int result;
 
#ifdef DEBUG_JTAG
  printf_unfiltered ("set chain %x\n", chain);
  fflush (stdout);
#endif
  switch(connection.location)
    {
    case JTAG_LOCAL:
      if (current_chain != chain)
        {
          if (!chain_is_valid[chain])
            error ("Chain not valid.");
 
          current_chain = chain;
          jp1_prepare_control ();
 
          jp1_write_JTAG (0); /* CAPTURE_IR */
          jp1_write_JTAG (0); /* SHIFT_IR */
 
          /* write data, EXIT1_IR */
          jp1_write_stream (JI_CHAIN_SELECT, JI_SIZE, 4);
 
          jp1_write_JTAG (1); /* UPDATE_IR */
          jp1_write_JTAG (1); /* SELECT_DR */
 
          jp1_write_JTAG (0); /* CAPTURE_DR */
          jp1_write_JTAG (0); /* SHIFT_DR */
 
          /* write data, EXIT1_DR */
          jp1_write_stream (chain, SC_SIZE, 1);
 
          jp1_write_JTAG (1); /* UPDATE_DR */
          jp1_write_JTAG (1); /* SELECT_DR */
 
          /* Now we have to go out of SELECT_CHAIN mode.  */
          jp1_write_JTAG (1); /* SELECT_IR */
          jp1_write_JTAG (0); /* CAPTURE_IR */
          jp1_write_JTAG (0); /* SHIFT_IR */
 
          /* write data, EXIT1_IR */
          jp1_write_stream (JI_DEBUG, JI_SIZE,1 );
 
          jp1_write_JTAG (1); /* UPDATE_IR */
          jp1_write_JTAG (1); /* SELECT_DR */
          select_dr = 1;
        }
      break;
    case JTAG_REMOTE:
      if(current_chain != chain)
        {
          if(result = jtag_send_proxy(JTAG_COMMAND_CHAIN,chain))
            {
              jtag_proxy_error(result,JTAG_COMMAND_CHAIN,chain);
              err = result;
            }
        }
      break;
    default:
      error("jtag_set_chain called with no connection!");
      break;
    }
#ifdef DEBUG_JTAG
  printf_unfiltered ("!set chain\n");
  fflush (stdout);
#endif
}
 
/* Added by CZ 24/05/01 */
static int jtag_connect_to_server(char* hostname,char* name)
{
  struct hostent *host;
  struct sockaddr_in sin;
  struct servent *service;
  struct protoent *protocol;
  int sock,flags;
  int fd;
  char sTemp[256],sTemp2[256];
  char* proto_name = "tcp";
  int port = 0;
  int on_off = 0; /* Turn off Nagel's algorithm on the socket */
  char *s;
 
  if(!(protocol = getprotobyname(proto_name)))
    {
      sprintf(sTemp,"jtag_connect_to_server: Protocol \"%s\" not available.\n",
              proto_name);
      error(sTemp);
      return 0;
    }
 
  /* Convert name to an integer only if it is well formatted.
     Otherwise, assume that it is a service name. */
 
  port = strtol(name,&s,10);
  if(*s)
    port = 0;
 
  if(!port)
    {
      if(!(service = getservbyname(name,protocol->p_name)))
        {
          sprintf(sTemp,"jtag_connect_to_server: Unknown service \"%s\".\n",name);
          error(sTemp);
          return 0;
        }
 
      port = ntohs(service->s_port);
    }
 
  if(!(host = gethostbyname(hostname)))
    {
      sprintf(sTemp,"jtag_connect_to_server: Unknown host \"%s\"\n",hostname);
      error(sTemp);
      return 0;
    }
 
  if((sock = socket(PF_INET,SOCK_STREAM,0)) < 0)
    {
      sprintf(sTemp,"jtag_connect_to_server: can't create socket errno = %d\n",
              errno);
      sprintf(sTemp2,"%s\n",strerror(errno));
      strcat(sTemp,sTemp2);
      error(sTemp);
      return 0;
    }
 
  if(flags = fcntl(sock,F_GETFL,0) < 0)
    {
      sprintf(sTemp,"Unable to get flags for JTAG proxy socket %d",sock);
      error(sTemp);
      close(sock);
      return 0;
    }
 
  if(fcntl(sock,F_SETFL, flags & ~O_NONBLOCK) < 0)
    {
      sprintf(sTemp,"Unable to set flags for JTAG proxy socket %d to value 0x%08x",
              sock,flags & ~O_NONBLOCK);
      perror("fcntl ~O_NONBLOCK");
      error(sTemp);
      close(sock);
      return 0;
    }
 
  memset(&sin,0,sizeof(sin));
  sin.sin_family = host->h_addrtype;
  memcpy(&sin.sin_addr,host->h_addr_list[0],host->h_length);
  sin.sin_port = htons(port);
 
  if((connect(sock,(struct sockaddr*)&sin, sizeof(sin)) < 0)
     && errno != EINPROGRESS)
    {
 
      sprintf(sTemp,"jtag_connect_to_server: connect failed  errno = %d\n",errno);
      sprintf(sTemp2,"%s\n",strerror(errno));
      close(sock);
      strcat(sTemp,sTemp2);
      error(sTemp);
      return 0;
    }
 
  if(fcntl(sock,F_SETFL, flags | O_NONBLOCK) < 0)
    {
      sprintf(sTemp,"Unable to set flags for JTAG proxy socket %d to value 0x%08x",
              sock,flags | O_NONBLOCK);
      perror("fcntl | O_NONBLOCK");
      error(sTemp);
      close(sock);
      return 0;
    }
 
  if(setsockopt(sock,protocol->p_proto,TCP_NODELAY,&on_off,sizeof(int)) < 0)
    {
      sprintf(sTemp,"Unable to disable Nagel's algorithm for socket %d.\nsetsockopt",sock);
      error(sTemp);
      close(sock);
      return 0;
    }
 
  return sock;
}
 
/* Initialize a new connection to the or1k board, and make sure we are
   really connected.  */
 
void
jtag_init (args)
     char * args;
{
  char *ptype;
  char *port_name;
  char **argv;
 
#ifdef DEBUG_JTAG
  printf_unfiltered ("INIT\n");
  fflush(stdout);
#endif
  if (args == 0) /* CZ */
    error ( "To open a or1k remote debugging connection, you need to specify a "
            "parallel port\nconnected to the target board, or else a remote "
            "server which will proxy these\nservices for you.\nExample: "
            "/dev/lp0 or jtag://debughost.mydomain.com:8100.\n");
 
  /* If we currently have an open connection, shut it
     down.  This is due to a temporary bug in gdb. */
  switch(connection.location)
    {
    case JTAG_REMOTE:
      if(connection.device.fd > 0)
        {
          close(connection.device.fd);
        }
      break;
    case JTAG_LOCAL:
      if(connection.device.lp > 0)
        {
          close(connection.device.lp);
        }
      break;
    default:
      break;
    }
 
  /* Parse the port name.  */
  if ((argv = buildargv (args)) == NULL)
    nomem (0);
  port_name = xstrdup (argv[0]);
  make_cleanup_freeargv (argv);
 
  /* CZ 24/05/01 - Check to see if we have specified a remote
     jtag interface or a local one. It is remote if it follows
     the URL naming convention jtag://<hostname>:<port> */
  if(!strncmp(port_name,"jtag://",7))
    {
      char *port = strchr(&port_name[7],':');
      char hostname[256];
 
      if(port)
        {
          int len = port - port_name - 7;
          strncpy(hostname,&port_name[7],len);
          hostname[len] = '\0';
          port++;
        }
      else
        strcpy(hostname,&port_name[7]);
 
      /* Interface is remote */
      if(!(connection.device.fd = jtag_connect_to_server(hostname,port)))
        {
          char sTemp[256];
          sprintf(sTemp,"Can not access JTAG Proxy Server at \"%s\"",
                  &port_name[5]);
          error(sTemp);
        }
      connection.location = JTAG_REMOTE;
      printf_unfiltered ("Remote or1k debugging using %s\n",port_name);
    }
  else
    {
      /* Interface is local */
      /* Open and initialize the parallel port.  */
      connection.device.lp = open (port_name, O_WRONLY);
      if (connection.device.lp < 0)
        error ("Cannot open device.");
      connection.location = JTAG_LOCAL; /* CZ */
      printf_unfiltered ("Local or1k debugging using %s\n", port_name);
 
    }
 
  current_chain = -1;
  if(connection.location == JTAG_LOCAL)
    jp1_reset_JTAG ();
  jtag_set_chain (SC_RISC_DEBUG);
 
  free (port_name);
}
 
void
jtag_done ()  /* CZ */
{
  switch(connection.location)
    {
    case JTAG_LOCAL:
      sync_close (connection.device.lp);
      connection.device.lp = 0;
      break;
    case JTAG_REMOTE:
      sync_close(connection.device.fd);
      connection.device.fd = 0;
      break;
    default:
      break;
    }
  connection.location = JTAG_NOT_CONNECTED;
}
 
int sync_close(int fd)
{
  int flags = 0;
  struct linger linger;
  char sTemp[256];
 
  linger.l_onoff = 0;
  linger.l_linger = 0;
 
  /* First, make sure we're non blocking */
  if(flags = fcntl(fd,F_GETFL,0) < 0)
    {
      sprintf(sTemp,"Unable to get flags for JTAG proxy socket %d",fd);
      error(sTemp);
    }
  if(fcntl(fd,F_SETFL, flags & ~O_NONBLOCK) < 0)
    {
      sprintf(sTemp,"Unable to set flags for JTAG proxy socket %d to value 0x%08x",
              fd,flags | O_NONBLOCK);
      error(sTemp);
    }
 
  /* Now, make sure we don't linger around */
  if(setsockopt(fd,SOL_SOCKET,SO_LINGER,&linger,sizeof(linger)) < 0)
    {
      sprintf(sTemp,"Unable to disable SO_LINGER for JTAG proxy socket %d.",fd);
      error(sTemp);
    }
 
  return close(fd);
}

Line No.	Rev	Author	Line
1	104	markom	`/* Remote debugging interface for JTAG debugging protocol.`
2	118	markom	`JTAG connects to or1k target ops. See or1k-tdep.c`
3
4	104	markom	`Copyright 1993-1995, 2000 Free Software Foundation, Inc.`
5			`Contributed by Cygnus Support. Written by Marko Mlinar`
6			`<markom@opencores.org>`
7	124	chris	`Areas noted by (CZ) were modified by Chris Ziomkowski`
8			`<chris@asics.ws>`
9	104	markom
10			`This file is part of GDB.`
11
12			`This program is free software; you can redistribute it and/or modify`
13			`it under the terms of the GNU General Public License as published by`
14			`the Free Software Foundation; either version 2 of the License, or`
15			`(at your option) any later version.`
16
17			`This program is distributed in the hope that it will be useful,`
18			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
19			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
20			`GNU General Public License for more details.`
21
22			`You should have received a copy of the GNU General Public License`
23			`along with this program; if not, write to the Free Software`
24			`Foundation, Inc., 59 Temple Place - Suite 330,`
25			`Boston, MA 02111-1307, USA. */`
26
27			`#include "defs.h"`
28			`#include "inferior.h"`
29			`#include "bfd.h"`
30			`#include "symfile.h"`
31			`#include "gdb_wait.h"`
32			`#include "gdbcmd.h"`
33			`#include "gdbcore.h"`
34			`#include "serial.h"`
35			`#include "target.h"`
36			`#include "remote-utils.h"`
37			`#include "gdb_string.h"`
38			`#include "tm.h"`
39	124	chris	`/* Added by CZ 24/05/01 */`
40			`#include <sys/poll.h>`
41			`#include <sys/socket.h>`
42			`#include <netdb.h>`
43			`#include <netinet/in.h>`
44			`#include <netinet/tcp.h>`
45			`#include <sys/select.h>`
46			`#include <sys/time.h>`
47			`#include <unistd.h>`
48	104	markom
49			`#include <signal.h>`
50			`#include <sys/types.h>`
51			`#include <sys/stat.h>`
52			`#include <sys/ioctl.h>`
53			`#include <fcntl.h>`
54
55	113	markom	`#define TCLK (0x01)`
56			`#define TRST (0x02)`
57	104	markom	`#define JTAG_WAIT()`
58	113	markom	`#define NUM_RETRIES (16)`
59			`#define JTAG_RETRY_WAIT() usleep (100)`
60	104	markom
61	113	markom	`/* Selects crc trailer size in bits. Currently supported: 8 */`
62			`#define CRC_SIZE (8)`
63	104	markom
64	113	markom	`/* Scan chain size in bits. */`
65			`#define SC_SIZE (4)`
66
67			`/* Scan chain info. */`
68			`/* INDENT-OFF */`
69			`static int chain_addr_size[] = { 0, 32, 0, 0, 5 };`
70			`static int chain_data_size[] = { 0, 32, 0, 32, 32 };`
71			`static int chain_is_valid[] = { 0, 1, 0, 1, 1 };`
72			`static int chain_has_crc[] = { 0, 1, 0, 1, 1 };`
73			`static int chain_has_rw[] = { 0, 1, 0, 0, 1 };`
74			`/* INDENT-OFF */`
75
76			`/* Currently selected scan chain - just to prevent unnecessary`
77			`transfers. */`
78			`static int current_chain;`
79
80	104	markom	`/* Designates whether we are in SELECT_DR state, otherwise in`
81			`RUN TEST/IDLE */`
82			`static int select_dr = 0;`
83
84	124	chris	`/* CZ - 24/05/01 - Changed to structure for remote/local */`
85			`typedef enum {`
86			`JTAG_NOT_CONNECTED = 0,`
87			`JTAG_LOCAL = 1,`
88			`JTAG_REMOTE = 2,`
89			`} jtag_location;`
90	104	markom
91	124	chris	`typedef struct {`
92			`union {`
93			`int lp; /* Printer compatible device we have open. */`
94			`int fd; /* Socket for remote or1k jtag interface */`
95			`} device;`
96			`jtag_location location;`
97			`} jtag_connection;`
98
99			`/* Our current connect information */`
100			`static jtag_connection connection;`
101
102	104	markom	`/* Crc of current read or written data. */`
103			`static int crc_r, crc_w = 0;`
104
105			`/* Generates new crc, sending in new bit input_bit */`
106	118	markom
107	104	markom	`static int`
108			`crc_calc (int crc, int input_bit)`
109			`{`
110			`int c;`
111			`int new_crc;`
112			`int d;`
113
114	113	markom	`#if (CRC_SIZE == 8)`
115	104	markom	`d = input_bit&1;`
116			`c = crc;`
117
118			`/* Move queue left. */`
119			`new_crc = crc << 1;`
120	118	markom
121	104	markom	`/* Mask upper five bits. */`
122			`new_crc &= 0xF8;`
123
124			`/* Set lower three bits */`
125			`new_crc \|= (d ^ ((c >> 7)&1));`
126			`new_crc \|= (d ^ ((c >> 0)&1) ^ ((c >> 7)&1)) << 1;`
127			`new_crc \|= (d ^ ((c >> 1)&1) ^ ((c >> 7)&1)) << 2;`
128			`return new_crc;`
129	113	markom	`#else`
130			`return 0;`
131			`#endif`
132	104	markom	`}`
133
134			`/* Resets JTAG.`
135			`Writes TRST=0`
136			`and TRST=1 */`
137
138			`static void`
139			`jp1_reset_JTAG ()`
140			`{`
141			`unsigned char data;`
142	124	chris	`int lp = connection.device.lp; /* CZ */`
143
144			`if(connection.location != JTAG_LOCAL)`
145			`error("jp1_reset_JTAG called without a local connection!");`
146
147	104	markom	`data = 0;`
148			`write (lp, &data, sizeof (data));`
149			`JTAG_WAIT();`
150			`data = TRST;`
151			`write (lp, &data, sizeof (data));`
152			`JTAG_WAIT();`
153			`}`
154
155			`/* Writes TCLK=0, TRST=1, TMS=bit0, TDI=bit1`
156			`and TCLK=1, TRST=1, TMS=bit0, TDI=bit1 */`
157
158			`static void`
159			`jp1_write_JTAG (packet)`
160			`unsigned char packet;`
161			`{`
162			`unsigned char data;`
163	124	chris	`int lp = connection.device.lp; /* CZ */`
164
165			`if(connection.location != JTAG_LOCAL)`
166			`error("jp1_write_JTAG called without a local connection!");`
167
168	104	markom	`data = ((packet & 3) << 2) \| TRST;`
169			`write (lp, &data, sizeof (data));`
170			`JTAG_WAIT();`
171			`crc_w = crc_calc (crc_w, (packet >> 1)&1);`
172
173			`/* rise clock */`
174			`data \|= TCLK;`
175			`write (lp, &data, sizeof (data));`
176			`JTAG_WAIT();`
177			`}`
178
179			`/* Reads TDO, using IOCTL. */`
180
181			`static int`
182			`jp1_read_JTAG ()`
183			`{`
184			`int data;`
185	124	chris
186			`if(connection.location != JTAG_LOCAL) /* CZ */`
187			`error("jp1_read_JTAG called without a local connection!");`
188
189	113	markom	`ioctl (data, 0x60b, &data);`
190	104	markom	`data = ((data & 0x80) != 0);`
191			`crc_r = crc_calc (crc_r, data);`
192			`return data;`
193			`}`
194
195			`/* Writes bitstream. MS bit first. */`
196
197			`static void`
198			`jp1_write_stream (stream, len, set_last_bit)`
199	122	markom	`ULONGEST stream;`
200	104	markom	`int len;`
201			`int set_last_bit;`
202			`{`
203			`int i;`
204			`if (len <= 0) return;`
205			`for (i = len - 1; i > 0; i--)`
206			`jp1_write_JTAG (((stream >> i) & 1) << 1);`
207
208			`if (set_last_bit)`
209			`jp1_write_JTAG (((stream & 1) << 1) \| 1);`
210			`else`
211			`jp1_write_JTAG ((stream & 1) << 1);`
212			`}`
213
214			`/* Gets bitstream. MS bit first. */`
215
216	122	markom	`static ULONGEST`
217	104	markom	`jp1_read_stream (len, stream, set_last_bit)`
218			`int len;`
219			`unsigned long stream;`
220			`int set_last_bit;`
221			`{`
222			`int i;`
223	122	markom	`ULONGEST data;`
224	104	markom
225			`if (len <= 0) return;`
226			`data = 0;`
227			`for (i = 0; i < len-1; i++)`
228			`{`
229			`jp1_write_JTAG (0 + ((stream & 1) << 1));`
230			`stream >>= 1;`
231			`data <<= 1;`
232			`data \|= jp1_read_JTAG ();`
233			`}`
234
235			`if (set_last_bit)`
236			`jp1_write_JTAG (1 + (stream & 1) << 1);`
237			`else`
238			`jp1_write_JTAG (0 + (stream & 1) << 1);`
239			`data <<= 1;`
240			`data \|= jp1_read_JTAG ();`
241			`return data;`
242			`}`
243
244			`/* Goes into SELECT_IR state. Should be called before every control write. */`
245
246			`static void`
247			`jp1_prepare_control ()`
248			`{`
249			`if (!select_dr)`
250			`jp1_write_JTAG (1); /* SELECT_DR SCAN */`
251	118	markom	`jp1_write_JTAG (1); /* SELECT_IR SCAN */`
252	104	markom	`select_dr = 0;`
253			`}`
254
255	124	chris	`/* Added by CZ 24/05/01 */`
256			`static int jtag_proxy_write(int fd,void* buf,int len)`
257			`{`
258			`int n;`
259			`char* w_buf = (char*)buf;`
260			`struct pollfd block;`
261
262			`while(len)`
263			`{`
264			`if((n = write(fd,w_buf,len)) < 0)`
265			`{`
266			`switch(errno)`
267			`{`
268			`case EWOULDBLOCK: /* or EAGAIN */`
269			`/* We've been called on a descriptor marked`
270			`for nonblocking I/O. We better simulate`
271			`blocking behavior. */`
272			`block.fd = fd;`
273			`block.events = POLLOUT;`
274			`block.revents = 0;`
275			`poll(&block,1,-1);`
276			`continue;`
277			`case EINTR:`
278			`continue;`
279			`case EPIPE:`
280			`return JTAG_PROXY_SERVER_TERMINATED;`
281			`default:`
282			`return errno;`
283			`}`
284			`}`
285			`else`
286			`{`
287			`len -= n;`
288			`w_buf += n;`
289			`}`
290			`}`
291			`return 0;`
292			`}`
293
294			`/* Added by CZ 24/05/01 */`
295			`static int jtag_proxy_read(int fd,void* buf,int len)`
296			`{`
297			`int n;`
298			`char* r_buf = (char*)buf;`
299			`struct pollfd block;`
300
301			`while(len)`
302			`{`
303			`if((n = read(fd,r_buf,len)) < 0)`
304			`{`
305			`switch(errno)`
306			`{`
307			`case EWOULDBLOCK: /* or EAGAIN */`
308			`/* We've been called on a descriptor marked`
309			`for nonblocking I/O. We better simulate`
310			`blocking behavior. */`
311			`block.fd = fd;`
312			`block.events = POLLIN;`
313			`block.revents = 0;`
314			`poll(&block,1,-1);`
315			`continue;`
316			`case EINTR:`
317			`continue;`
318			`default:`
319			`return errno;`
320			`}`
321			`}`
322			`else if(n == 0)`
323			`return JTAG_PROXY_SERVER_TERMINATED;`
324			`else`
325			`{`
326			`len -= n;`
327			`r_buf += n;`
328			`}`
329			`}`
330			`return 0;`
331			`}`
332
333			`static int ReadResponse(int fd,void* buffer,int len)`
334			`{`
335			`int32_t status = 0;`
336	362	markom	`int result;`
337	124	chris	`char* buf = (char*)buffer;`
338
339	362	markom	`result = jtag_proxy_read(fd,&status,4);`
340
341	124	chris	`status = ntohl(status);`
342			`((int32_t)buffer) = status;`
343
344	362	markom	`if(result) {printf("result %i %x\n", result, result); return result;}`
345			`if(status) {printf("status %i %x\n", status, status); return status;}`
346	124	chris
347			`result = jtag_proxy_read(fd,&buf[4],len-4);`
348			`return result;`
349			`}`
350
351			`/* Added by CZ 24/05/01 */`
352			`#ifndef ANSI_PROTOTYPES`
353			`static int jtag_send_proxy(va_alist)`
354			`va_dcl`
355			`#else`
356			`static int jtag_send_proxy(int command,...)`
357			`#endif`
358			`{`
359			`va_list ap;`
360			`int result = 0;`
361			`int fd = connection.device.fd;`
362			`JTAGProxyWriteMessage xmit_write;`
363			`JTAGProxyReadMessage xmit_read;`
364			`JTAGProxyChainMessage xmit_chain;`
365	140	chris	`JTAGProxyBlockWriteMessage *xmit_bwrite;`
366			`JTAGProxyBlockReadMessage xmit_bread;`
367	124	chris	`JTAGProxyWriteResponse recv_write;`
368			`JTAGProxyReadResponse recv_read;`
369			`JTAGProxyChainResponse recv_chain;`
370	140	chris	`JTAGProxyBlockWriteResponse recv_bwrite;`
371			`JTAGProxyBlockReadResponse recv_bread;`
372	124	chris	`unsigned long long data,* ret_val;`
373			`uint32_t word1; /* Use word1 and word2 to ease portability to platforms */`
374			`uint32_t word2; /* without long long and for alignment reasons */`
375	140	chris	`unsigned long address;`
376			`unsigned long* b_data;`
377			`int nRegisters;`
378			`int len,i;`
379	124	chris
380			`#ifndef ANSI_PROTOTYPES`
381			`int command;`
382
383			`va_start(ap);`
384			`command = va_arg(ap,int);`
385			`#else`
386			`va_start(ap, command);`
387			`#endif`
388
389
390
391			`if(connection.location == JTAG_REMOTE)`
392			`{`
393			`switch(command)`
394			`{`
395			`case JTAG_COMMAND_READ:`
396			`xmit_read.command = htonl(command);`
397			`xmit_read.length = htonl(sizeof(xmit_read)-8);`
398			`xmit_read.address = htonl(va_arg(ap,int));`
399			`ret_val = va_arg(ap,unsigned long long *);`
400			`/* intentional single equals */`
401			`if(result = jtag_proxy_write(fd,&xmit_read,sizeof(xmit_read)))`
402			`break;`
403			`if(result = ReadResponse(fd,&recv_read,sizeof(recv_read)))`
404			`break;`
405			`result = ntohl(recv_read.status);`
406			`word1 = ntohl(recv_read.data_H);`
407			`word2 = ntohl(recv_read.data_L);`
408			`*ret_val = (((unsigned long long)word1) << 32) \| word2;`
409			`break;`
410			`case JTAG_COMMAND_WRITE:`
411			`xmit_write.command = htonl(command);`
412			`xmit_write.length = htonl(sizeof(xmit_write)-8);`
413			`xmit_write.address = htonl(va_arg(ap,int));`
414			`data = va_arg(ap,unsigned long long);`
415			`word1 = htonl(data >> 32);`
416			`word2 = htonl(data & 0xFFFFFFFF);`
417			`xmit_write.data_H = word1;`
418			`xmit_write.data_L = word2;`
419			`if(result = jtag_proxy_write(fd,&xmit_write,sizeof(xmit_write)))`
420			`break;`
421			`if(result = ReadResponse(fd,&recv_write,sizeof(recv_write)))`
422			`break;`
423			`result = recv_write.status;`
424			`break;`
425	140	chris	`case JTAG_COMMAND_BLOCK_WRITE:`
426			`address = va_arg(ap,unsigned long);`
427			`b_data = va_arg(ap,unsigned long*);`
428			`nRegisters = va_arg(ap,int);`
429			`len = sizeof(JTAGProxyBlockWriteMessage) + (nRegisters-1)*4;`
430			`xmit_bwrite = (JTAGProxyBlockWriteMessage*)malloc(len);`
431			`xmit_bwrite->command = htonl(command);`
432			`xmit_bwrite->length = htonl(len-8);`
433			`xmit_bwrite->address = htonl(address);`
434			`xmit_bwrite->nRegisters = htonl(nRegisters);`
435			`for(i=0;i<nRegisters;i++)`
436			`xmit_bwrite->data[i] = htonl(b_data[i]);`
437			`if(!(result = jtag_proxy_write(fd,xmit_bwrite,len)) &&`
438			`!(result = ReadResponse(fd,&recv_bwrite,sizeof(recv_bwrite))))`
439			`result = recv_bwrite.status;`
440			`free(xmit_bwrite);`
441			`xmit_bwrite = NULL;`
442			`break;`
443			`case JTAG_COMMAND_BLOCK_READ:`
444			`address = va_arg(ap,unsigned long);`
445			`b_data = va_arg(ap,unsigned long*);`
446			`nRegisters = va_arg(ap,int);`
447			`xmit_bread.command = htonl(command);`
448			`xmit_bread.length = htonl(sizeof(xmit_bread)-8);`
449			`xmit_bread.address = htonl(address);`
450			`xmit_bread.nRegisters = htonl(nRegisters);`
451			`if(result = jtag_proxy_write(fd,&xmit_bread,sizeof(xmit_bread)))`
452			`break;`
453			`if(result = ReadResponse(fd,&recv_bread,sizeof(recv_bread)))`
454			`break;`
455			`b_data[0] = ntohl(recv_bread.data[0]);`
456	194	chris	`recv_bread.nRegisters = ntohl(recv_bread.nRegisters);`
457	140	chris	`if(result = jtag_proxy_read(fd,&b_data[1],4*(recv_bread.nRegisters-1)))`
458			`break;`
459			`if(recv_bread.nRegisters != nRegisters)`
460			`result = JTAG_PROXY_PROTOCOL_ERROR;`
461			`else`
462			`{`
463			`for(i=1;i<nRegisters;i++)`
464			`b_data[i] = ntohl(b_data[i]);`
465			`}`
466			`break;`
467	124	chris	`case JTAG_COMMAND_CHAIN:`
468			`xmit_chain.command = htonl(command);`
469			`xmit_chain.length = htonl(sizeof(xmit_chain)-8);`
470			`xmit_chain.chain = htonl(va_arg(ap,unsigned int));`
471			`if(result = jtag_proxy_write(fd,&xmit_chain,sizeof(xmit_chain)))`
472			`break;`
473			`if(result = ReadResponse(fd,&recv_chain,sizeof(recv_chain)))`
474			`break;`
475			`result = recv_chain.status;`
476			`break;`
477			`default:`
478			`result = JTAG_PROXY_INVALID_COMMAND;`
479			`break;`
480			`}`
481			`va_end(ap);`
482			`}`
483			`else`
484			`{`
485			`va_end(ap);`
486			`error("jtag_send_proxy called without a remote proxy connection!");`
487			`result = JTAG_PROXY_NO_CONNECTION;`
488			`}`
489
490			`if(result == JTAG_PROXY_SERVER_TERMINATED)`
491			`{`
492			`close(connection.device.fd);`
493			`connection.device.fd = 0;`
494			`connection.location = JTAG_NOT_CONNECTED;`
495			`}`
496
497			`return result;`
498			`}`
499
500			`/* Added by CZ 24/05/01 */`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [jtag.c] - Blame information for rev 1774