source: trunk/libs/newlib/src/libgloss/hp74x/pa_stub.c @ 444

/* -*-C-*-
*******************************************************************************
*
* File:         pa_stub.c
* RCS:          $Header$
* Description:  main routines for PA RISC monitor stub
* Author:       Robert Quist
* Created:      Mon Nov  1 10:00:36 1993
* Modified:     Fri Nov 12 15:14:23 1993 (Robert Quist) quist@hpfcrdq
* Language:     C
* Package:      N/A
* Status:       Experimental (Do Not Distribute)
*
*******************************************************************************
*/

/****************************************************************************

                THIS SOFTWARE IS NOT COPYRIGHTED

   HP offers the following for use in the public domain.  HP makes no
   warranty with regard to the software or it's performance and the
   user accepts the software "AS IS" with all faults.

   HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
   TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

****************************************************************************/

/****************************************************************************
 *
 *  Description:     low level support for gdb debugger. $
 *
 *  Considerations:  only works on target hardware $
 *
 *  NOTES:           See Below $
 *
 *    To enable debugger support, two things need to happen.
 *
 *  One, a call to set_debug_traps() is necessary in order to allow
 *  any breakpoints or error conditions to be properly intercepted and
 *  reported to gdb.  
 *
 *  Two, a breakpoint needs to be generated to begin communication.
 *  This is most easily accomplished by a call to breakpoint().
 *  breakpoint() simulates a breakpoint


 *************
 *
 *    The following gdb commands are supported:
 *
 * command          function                               Return value
 *
 *    g             return the value of the CPU registers  hex data or ENN
 *    G             set the value of the CPU registers     OK or ENN
 *
 *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
 *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
 *
 *    c             Resume at current address              SNN   ( signal NN)
 *    cAA..AA       Continue at address AA..AA             SNN
 *
 *    s             Step one instruction                   SNN
 *    sAA..AA       Step one instruction from AA..AA       SNN
 *
 *    k             kill
 *
 *    ?             What was the last sigval ?             SNN   (signal NN)
 *
 *    bBB..BB       Set baud rate to BB..BB                OK or BNN, then sets
 *                                                         baud rate
 *

 ************
 * All commands and responses are sent with a packet which includes a
 * checksum.  A packet consists of :
 *
 * $<packet info>#<checksum>.
 *
 * where
 * <packet info> :: <characters representing the command or response>
 * <checksum>    :: < two hex digits computed as modulo 256 sum of <packetinfo>>
 *
 * When a packet is received, it is first acknowledged with either '+' or '-'.
 * '+' indicates a successful transfer.  '-' indicates a failed transfer.
 *
 * Example:
 *
 * Host:                  Reply:
 * $m0,10#2a               +$00010203040506070809101112131415#42
 *
 ****************************************************************************/
#include <signal.h>
#include "hppa-defs.h"

/************************************************************************
 *
 * external low-level support
 */
#define OPT_PDC_CACHE        5
#define OPT_PDC_ADD_VALID   12
#define PGZ_MEM_PDC     0x0388  /* location of PDC_ENTRY in memory    */
#define CALL_PDC        (*(int (*)())((int *)(*((int *)PGZ_MEM_PDC))))

extern putDebugChar();   /* write a single character      */
extern getDebugChar();   /* read and return a single char */
extern FICE();           /* flush i cache entry */
extern INLINE_BREAK();   /* break for user call */

#define RADDR_ALIGN(s,r) (s = ((unsigned int *) ((((int) r ) + 7 ) & 0xFFFFFFF8)))

/************************************************************************/
/* BUFMAX defines the maximum number of characters in inbound/outbound buffers*/
/* at least NUMREGBYTES*2 are needed for register packets */

#define BUFMAX 2048

#define NUMGPRS   32
#define NUMSRS     8
#define NUMCRS    32
#define NUMSPCLS   3
#define NUMFPRS   32

#define NUMGPRBYTES     4
#define NUMSRBYTES      4
#define NUMCRBYTES      4
#define NUMSPCLBYTES    4
#define NUMFPRBYTES     8

/* Number of bytes of registers.  */
#define NUMREGBYTES \
        (  (NUMGPRS * NUMGPRBYTES) \
         + (NUMSRS * NUMSRBYTES)   \
         + (NUMCRS * NUMCRBYTES)   \
         + (NUMSPCLS * NUMSPCLBYTES) \
         + (NUMFPRS * NUMFPRBYTES) \
        )
         

enum regnames   {GR0,  GR1,  GR2,  GR3,  GR4,  GR5,  GR6,  GR7,
                 GR8,  GR9,  GR10, GR11, GR12, GR13, GR14, GR15,
                 GR16, GR17, GR18, GR19, GR20, GR21, GR22, GR23,
                 GR24, GR25, GR26, GR27, GR28, GR29, GR30, GR31,
                 
                 SR0,  SR1,  SR2,  SR3,  SR4,  SR5,  SR6,  SR7,

                 CR0,  CR1,  CR2,  CR3,  CR4,  CR5,  CR6,  CR7,
                 CR8,  CR9,  CR10, CR11, CR12, CR13, CR14, CR15,
                 CR16, CR17H,CR18H,CR19, CR20, CR21, CR22, CR23,
                 CR24, CR25, CR26, CR27, CR28, CR29, CR30, CR31,
                 
                 CR17T,CR18T,CPUD0 };

enum fregnames  {FPR0,  FPR1,  FPR2,  FPR3,  FPR4,  FPR5,  FPR6,  FPR7,
                 FPR8,  FPR9,  FPR10, FPR11, FPR12, FPR13, FPR14, FPR15,
                 FPR16, FPR17, FPR18, FPR19, FPR20, FPR21, FPR22, FPR23,
                 FPR24, FPR25, FPR26, FPR27, FPR28, FPR29, FPR30, FPR31 };

#define PC  CR18H
#define NPC CR18T
#define SP  GR30
                
struct registers {
       int intregs[NUMGPRS + NUMSRS + NUMCRS + NUMSPCLS];
       int fpregs [NUMFPRS * 2];
                 };    
/* Global Variables */

static int initialized = 0;     /* !0 means we've been initialized */
static unsigned char hexchars[]="0123456789abcdef";
static unsigned char remcomInBuffer[BUFMAX];
static unsigned char remcomOutBuffer[BUFMAX];
static unsigned int  i_cache_params[6];

/* This table contains the mapping between PA hardware exception
   types, and signals, which are primarily what GDB understands.  It also
   indicates which hardware traps we need to commandeer when initializing
   the stub.

   The only two currently used are Recovery counter (single stepping)
   and Break trap ( break points ).
*/

static struct hard_trap_info
{
  unsigned char tt;             /* Trap number for PA-RISC */
  unsigned char signo;          /* Signal that we map this trap into */
} hard_trap_info[] = {
/* 1  High priority machine check */
/* 2  Power failure interrupt*/
/* 3  Recovery counter -- init */
/* 4  External interrupt */
/* 5  Low priority machine check */
  {6, SIGSEGV},                 /* Instruction TLB miss/page fault */
  {7, SIGSEGV},                 /* Memory protection */
  {8, SIGILL},                  /* Illegal instruction */
  {9, SIGTRAP},                 /* Break instruction -- init */
  {10,SIGILL},                  /* Privileged instruction */
  {11,SIGILL},                  /* Privileged register */
  {12,SIGUSR1},                 /* Overflow */
  {13,SIGUSR2},                 /* Conditional */
  {14,SIGEMT},                  /* Assist Exception */
  {15,SIGSEGV},                 /* Data TLB miss/page fault */
  {16,SIGSEGV},                 /* Non-access Instruction TLB miss */
  {17,SIGSEGV},                 /* Non-access Data TLB miss/page fault */
  {18,SIGSEGV},                 /* Data memory protection/ unaligned data reference */
  {19,SIGTRAP},                 /* Data memory break */
  {20,SIGSEGV},                 /* TLB dirty bit */
  {21,SIGSEGV},                 /* Page reference */
  {22,SIGEMT},                  /* Assist emulation */
  {23,SIGILL},                  /* Higher-privilege */
  {24,SIGILL},                  /* Lower-privilege */
  {25,SIGTRAP},                 /* Taken branch */
  {0, 0}                        /* Must be last */
};

/* Functions */
/*========================================================================== */

/* Convert ch from a hex digit to an int */

static int
hex(ch)
     unsigned char ch;
{
  if (ch >= 'a' && ch <= 'f')
    return ch-'a'+10;
  if (ch >= '0' && ch <= '9')
    return ch-'0';
  if (ch >= 'A' && ch <= 'F')
    return ch-'A'+10;
  return -1;
}

/* scan for the sequence $<data>#<checksum>     */

static void
getpacket(buffer)
     char *buffer;
{
  unsigned char checksum;
  unsigned char xmitcsum;
  int i;
  int count;
  unsigned char ch;

  do
    {
      /* wait around for the start character, ignore all other characters */
      strobe();
      while ((ch = getDebugChar()) != '$') ;

      checksum = 0;
      xmitcsum = -1;

      count = 0;

      /* now, read until a # or end of buffer is found */
      while (count < BUFMAX)
        {
          ch = getDebugChar();
          if (ch == '#')
            break;
          checksum = checksum + ch;
          buffer[count] = ch;
          count = count + 1;
        }

      if (count >= BUFMAX)
        continue;

      buffer[count] = 0;

      if (ch == '#')
        {
          xmitcsum = hex(getDebugChar()) << 4;
          xmitcsum |= hex(getDebugChar());

#if TESTING
          /* Humans shouldn't have to figure out checksums to type to it. */
          putDebugChar ('+');
          return;
#endif
          if (checksum != xmitcsum)
            putDebugChar('-');  /* failed checksum */
          else
            {
              putDebugChar('+'); /* successful transfer */
              /* if a sequence char is present, reply the sequence ID */
              if (buffer[2] == ':')
                {
                  putDebugChar(buffer[0]);
                  putDebugChar(buffer[1]);
                  /* remove sequence chars from buffer */
                  count = strlen(buffer);
                  for (i=3; i <= count; i++)
                    buffer[i-3] = buffer[i];
                }
            }
        }
    }
  while (checksum != xmitcsum);
}

/* send the packet in buffer.  */

static void
putpacket(buffer)
     unsigned char *buffer;
{
  unsigned char checksum;
  int count;
  unsigned char ch;

  /*  $<packet info>#<checksum>. */

  do
    {
      putDebugChar('$');
      checksum = 0;
      count = 0;

      while (ch = buffer[count])
        {
          if (! putDebugChar(ch))
            return;
          checksum += ch;
          count += 1;
        }

      putDebugChar('#');
      putDebugChar(hexchars[checksum >> 4]);
      putDebugChar(hexchars[checksum & 0xf]);
      } while (getDebugChar() != '+');
}

/* Convert the memory pointed to by mem into hex, placing result in buf.
 * Return a pointer to the last char put in buf (null), in case of mem fault,
 * return 0.
 * If MAY_FAULT is non-zero, then we will handle memory faults by returning
 * a 0, else treat a fault like any other fault in the stub.
 */

static unsigned char *
mem2hex(mem, buf, count, may_fault)
     unsigned char *mem;
     unsigned char *buf;
     int count;
     int may_fault;
{
  unsigned char ch;
  int           check_addr,
                new_addr;

  check_addr = 0;

  while (count-- > 0)
    {
      if (may_fault)
      { new_addr = ((int) (mem+3)) & 0xFFFFFFF8;
        if (new_addr != check_addr)
        { check_addr = new_addr;
          if (pdc_call(OPT_PDC_ADD_VALID,0,check_addr)) return 0;
        }
      }
      ch = *mem++;
      *buf++ = hexchars[ch >> 4];
      *buf++ = hexchars[ch & 0xf];
    }

  *buf = 0;

  return buf;
}

/* convert the hex array pointed to by buf into binary to be placed in mem
 * return a pointer to the character AFTER the last byte written */

static unsigned char *
hex2mem(buf, mem, count, may_fault)
     unsigned char *buf;
     unsigned char *mem;
     int count;
     int may_fault;
{
  int          i;
  unsigned int ch;
  int          check_addr,
               new_addr;

  check_addr = 0;

  for (i=0; i<count; i++)
    {
      ch = hex(*buf++) << 4;
      ch |= hex(*buf++);
      if (may_fault)
      { new_addr = ((int)(mem+3)) & 0xFFFFFFF8;
        if (new_addr != check_addr)
        { check_addr = new_addr;
          if (pdc_call(OPT_PDC_ADD_VALID,0,check_addr)) return 0;
        }
      }
      *mem++ = ch;
    }

  return mem;
}

/* Set up exception handlers for traceing and breakpoints */

void
set_debug_traps()
{ 
  unsigned int  R_addr[33];
  unsigned int  *Raddr_ptr;
  
  setup_vectors();
 
  /* get cache params for use by flush_i_cache */
  RADDR_ALIGN(Raddr_ptr,R_addr);

  if (pdc_call(OPT_PDC_CACHE,0,Raddr_ptr,0))
    i_cache_params[0] = -1;
  else
    i_cache_params[0] = R_addr[0];

  i_cache_params[1] = Raddr_ptr[1];
  i_cache_params[2] = Raddr_ptr[2];
  i_cache_params[3] = Raddr_ptr[3];
  i_cache_params[4] = Raddr_ptr[4];
  i_cache_params[5] = Raddr_ptr[5];

  /* In case GDB is started before us, ack any packets (presumably
     "$?#xx") sitting there.  */

  putDebugChar ('+');

  initialized = 1;
}


/* Convert the PA-RISC hardware trap number to a unix signal number. */

static int
computeSignal(tt)
     int tt;
{
  struct hard_trap_info *ht;

  for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
    if (ht->tt == tt)
      return ht->signo;

  return SIGHUP;                /* default for things we don't know about */
}

/*
 * While we find nice hex chars, build an int.
 * Return number of chars processed.
 */

static int
hexToInt(ptr, intValue)
     unsigned char **ptr;
     int *intValue;
{
  int numChars = 0;
  int hexValue;

  *intValue = 0;

  while (**ptr)
    {
      hexValue = hex(**ptr);
      if (hexValue < 0)
        break;

      *intValue = (*intValue << 4) | hexValue;
      numChars ++;

      (*ptr)++;
    }

  return (numChars);
}

void
flush_i_cache()

{
  unsigned int addr,count,loop;

  if (i_cache_params[0] <= 0) return;

  addr = i_cache_params[2];
  for (count = 0; count < i_cache_params[4]; count++)
    { for ( loop = 0; loop < i_cache_params[5]; loop++) FICE(addr);
      addr = addr + i_cache_params[3];
    }
}

/*
 * This function does all command procesing for interfacing to gdb.
   return of 0 will execute DEBUG_GO (continue)
   return of 1 will execute DEBUG_SS (single step)
 */

int
handle_exception (registers,tt)
  unsigned long *registers;
  int  tt;                      /* Trap type */
{
  int sigval;
  int addr;
  int length;
  unsigned char *ptr;

  /* reply to host that an exception has occurred */
  sigval = computeSignal(tt);
  ptr = remcomOutBuffer;

  *ptr++ = 'T';
  *ptr++ = hexchars[sigval >> 4];
  *ptr++ = hexchars[sigval & 0xf];

/* could be lots of stuff here like PC and SP registers */

  *ptr++ = 0;

  putpacket(remcomOutBuffer);

  while (1)
    {
      remcomOutBuffer[0] = 0;

      getpacket(remcomInBuffer);
      switch (remcomInBuffer[0])
        {
        case '?':
          remcomOutBuffer[0] = 'S';
          remcomOutBuffer[1] = hexchars[sigval >> 4];
          remcomOutBuffer[2] = hexchars[sigval & 0xf];
          remcomOutBuffer[3] = 0;
          break;

        case 'd':
          /* toggle debug flag */
          led_putnum (16);
          break;

        case 'g':               /* return the value of the CPU registers */
          {
            ptr = remcomOutBuffer;
            /* GR0..GR31 SR0..SR7 CR0..CR31 specials */
            ptr = mem2hex((char *)registers, ptr, NUMREGBYTES, 0);
            /* need to add floating point registers */
          }
          break;

        case 'G':          /* set the value of the CPU registers - return OK */
          {
            ptr = &remcomInBuffer[1];
            /* GR0..GR31 SR0..SR7 CR0..CR31 specials */
            hex2mem(ptr, (char *)registers, NUMREGBYTES, 0);
            strcpy(remcomOutBuffer,"OK 1");
          }
          break;

        case 'm':         /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
          /* Try to read %x,%x.  */

          ptr = &remcomInBuffer[1];

          if (hexToInt(&ptr, &addr)
              && *ptr++ == ','
              && hexToInt(&ptr, &length))
            {
              if (mem2hex((char *)addr, remcomOutBuffer, length, 1))
                break;

              strcpy (remcomOutBuffer, "E03");
            }
          else
            strcpy(remcomOutBuffer,"E01");
          break;

        case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
          /* Try to read '%x,%x:'.  */

          ptr = &remcomInBuffer[1];

          if (hexToInt(&ptr, &addr)
              && *ptr++ == ','
              && hexToInt(&ptr, &length)
              && *ptr++ == ':')
            {
              if (hex2mem(ptr, (char *)addr, length, 1))
                strcpy(remcomOutBuffer, "OK");
              else
                strcpy(remcomOutBuffer, "E03");
            }
          else
            strcpy(remcomOutBuffer, "E02");
          break;

        case 'c':    /* cAA..AA    Continue at address AA..AA(optional) */
          /* try to read optional parameter, pc unchanged if no parm */

          ptr = &remcomInBuffer[1];
          if (hexToInt(&ptr, &addr))
            {
              registers[PC] = addr;
              registers[NPC] = addr + 4;
            }

/* Need to flush the instruction cache here, as we may have deposited a
   breakpoint, and the icache probably has no way of knowing that a data ref to
   some location may have changed something that is in the instruction cache.
 */

          flush_i_cache();
          return 0;             /* execute GO */

          /* kill the program */
        case 'k' :              /* do nothing */
          break;

        case 's' :              /* single step */
          /* try to read optional parameter, pc unchanged if no parm */

          ptr = &remcomInBuffer[1];
          if (hexToInt(&ptr, &addr))
            {
              registers[PC] = addr;
              registers[NPC] = addr + 4;
            }
/* Need to flush the instruction cache here, as we may have deposited a
   breakpoint, and the icache probably has no way of knowing that a data ref to
   some location may have changed something that is in the instruction cache.
 */
          flush_i_cache();
          return 1;             /* execute Single Step */
          break;

#if TESTING1
        case 't':               /* Test feature */
          break;
#endif
        case 'r':               /* Reset */
          break;

#if TESTING2
Disabled until we can unscrew this properly

        case 'b':         /* bBB...  Set baud rate to BB... */
          {
            int baudrate;
            extern void set_timer_3();

            ptr = &remcomInBuffer[1];
            if (!hexToInt(&ptr, &baudrate))
              {
                strcpy(remcomOutBuffer,"B01");
                break;
              }

            /* Convert baud rate to uart clock divider */
            switch (baudrate)
              {
              case 38400:
                baudrate = 16;
                break;
              case 19200:
                baudrate = 33;
                break;
              case 9600:
                baudrate = 65;
                break;
              default:
                strcpy(remcomOutBuffer,"B02");
                goto x1;
              }

            putpacket("OK 2");  /* Ack before changing speed */
            set_timer_3(baudrate); /* Set it */
          }
x1:       break;
#endif
        }                       /* switch */

      /* reply to the request */
      putpacket(remcomOutBuffer);
    }
  print ("\r\nEscaped handle_exception\r\n");
}