Subversion Repositories openrisc

using sc_core::sc_fifo;

using sc_core::sc_fifo;

using sc_core::sc_module_name;

using sc_core::sc_module_name;

using sc_core::sc_stop;

using sc_core::sc_stop;

using sc_core::sc_time;

using sc_core::sc_time;

SC_HAS_PROCESS (GdbServerSC);

SC_HAS_PROCESS (GdbServerSC);

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Constructor for the GDB RSP server.

//! Constructor for the GDB RSP server.

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

GdbServerSC::GdbServerSC (sc_module_name        name,

GdbServerSC::GdbServerSC (sc_module_name        name,

                          uint32_t              _flashStart,

                          uint32_t              _flashStart,

                          uint32_t              _flashEnd,

                          uint32_t              _flashEnd,

                          int                   rspPort,

                          int                   rspPort,

{

{

  pkt       = new RspPacket (RSP_PKT_MAX);

  pkt       = new RspPacket (RSP_PKT_MAX);

  rsp       = new RspConnection (rspPort);

  rsp       = new RspConnection (rspPort);

  debugUnit = new DebugUnitSC ("debug-unit", tapActionQueue);

  debugUnit = new DebugUnitSC ("debug-unit", tapActionQueue);

  mpHash    = new MpHash ();

  mpHash    = new MpHash ();

  SC_THREAD (rspServer);

  SC_THREAD (rspServer);

}       // GdbServerSC ()

}       // GdbServerSC ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Destructor

//! Destructor

//! Free up data structures

//! Free up data structures

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

  delete  rsp;

  delete  rsp;

  delete  pkt;

  delete  pkt;

}       // ~GdbServerSC

}       // ~GdbServerSC

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! SystemC thread to listen for RSP requests

//! SystemC thread to listen for RSP requests

//! JTAG actions will be queued as appropriate. Runs forever

//! JTAG actions will be queued as appropriate. Runs forever

  */

  */

  debugUnit->stall ();

  debugUnit->stall ();

  targetStopped = true;

  targetStopped = true;

  // Make sure we are connected.

  // Make sure we are connected.

      // Reconnect and stall the processor on a new connection

      // Reconnect and stall the processor on a new connection

          // Serious failure. Must abort execution.

          // Serious failure. Must abort execution.

          cerr << "*** Unable to continue: ABORTING" << endl;

          cerr << "*** Unable to continue: ABORTING" << endl;

          sc_stop ();

          sc_stop ();

        }

        }

      // Stall the processor until we get a command to handle.

      // Stall the processor until we get a command to handle.

          debugUnit->stall ();

          debugUnit->stall ();

        }

        }

      targetStopped = true;             // Processor now not running

      targetStopped = true;             // Processor now not running

    }

    }

  // Loop processing commands forever

  // Loop processing commands forever

          sc_stop ();

          sc_stop ();

          return;

          return;

        }

        }

      // Wait until the target has stopped. In this simplified implementation,

      // Wait until the target has stopped. In this simplified implementation,

      // the only reasons for stopping are hitting a breakpoint (l.trap),

      // the only reasons for stopping are hitting a breakpoint (l.trap),

      // hardware single stepping or hitting a non-breakpoint l.trap. This

      // hardware single stepping or hitting a non-breakpoint l.trap. This

      // last is not cleanly handled at the moment (we ought to redirect the

      // last is not cleanly handled at the moment (we ought to redirect the

      // restart through the trap exception vector).

      // restart through the trap exception vector).

          /* First check to see if the or1200 monitor module wants us to stall*/

          /* First check to see if the or1200 monitor module wants us to stall*/

          if (checkMonitorPipe())

          if (checkMonitorPipe())

            break;

            break;

          rspCheckForException();

          rspCheckForException();

              targetStopped = true;

              targetStopped = true;

              // If it's a breakpoint, then we need to back up one

              // If it's a breakpoint, then we need to back up one

              // instruction, so on restart we execute the actual

              // instruction, so on restart we execute the actual

              // instruction.

              // instruction.

              uint32_t  ppc = debugUnit->readSpr (SPR_PPC);

              uint32_t  ppc = debugUnit->readSpr (SPR_PPC);

                  writeNpc (ppc);

                  writeNpc (ppc);

                }

                }

              // Tell the client we've stopped.

              // Tell the client we've stopped.

              rspReportException ();

              rspReportException ();

              if (rsp->rspSocketPeek() == 0x03) // ETX, end of text control char

              if (rsp->rspSocketPeek() == 0x03) // ETX, end of text control char

                {

                {

                  // Got an interrupt command from GDB, this function should

                  // Got an interrupt command from GDB, this function should

                  // pull the packet off the socket and stall the processor.

                  // pull the packet off the socket and stall the processor.

                  // and then send a stop reply packet with signal 

                  // and then send a stop reply packet with signal 

      // Get a RSP client request

      // Get a RSP client request

      rspClientRequest ();

      rspClientRequest ();

    }

    }

}       // rspServer ()

}       // rspServer ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Deal with a request from the GDB client session

//! Deal with a request from the GDB client session

//! In general, apart from the simplest requests, this function replies on

//! In general, apart from the simplest requests, this function replies on

//! other functions to implement the functionality.

//! other functions to implement the functionality.

//!       meaning? Or does it just mean that only vAttach will be recognized

//!       meaning? Or does it just mean that only vAttach will be recognized

//!       after this?

//!       after this?

//! @param[in] pkt  The received RSP packet

//! @param[in] pkt  The received RSP packet

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

    {

    {

      rsp->rspClose ();                 // Comms failure

      rsp->rspClose ();                 // Comms failure

      return;

      return;

    }

    }

  //Uncomment the next line for the RSP client to print out every packet it gets from GDB

  //Uncomment the next line for the RSP client to print out every packet it gets from GDB

  //cerr << "rspClientRequest: " << pkt->data/*[0]*/ << endl;

  //cerr << "rspClientRequest: " << pkt->data/*[0]*/ << endl;

    case '!':

    case '!':

      // Request for extended remote mode

      // Request for extended remote mode

      pkt->packStr ("OK");

      pkt->packStr ("OK");

      rsp->putPkt (pkt);

      rsp->putPkt (pkt);

      return;

      return;

      rspReportException ();

      rspReportException ();

      return;

      return;

    case 'A':

    case 'A':

      // Initialization of argv not supported

      // Initialization of argv not supported

      pkt->packStr ("E01");

      pkt->packStr ("E01");

      rsp->putPkt (pkt);

      rsp->putPkt (pkt);

      return;

      return;

    case 'b':

    case 'b':

      cerr << "Warning: Unknown RSP request" << pkt->data << endl;

      cerr << "Warning: Unknown RSP request" << pkt->data << endl;

      return;

      return;

    }

    }

}       // rspClientRequest ()

}       // rspClientRequest ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Check if processor is stalled. If it is, read the DRR and return the

//! Check if processor is stalled. If it is, read the DRR and return the

//! target signal code.

//! target signal code.

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  uint32_t drr;

  uint32_t drr;

      // Processor not stalled. Just return;

      // Processor not stalled. Just return;

      return;

      return;

    }

    }

    default:

    default:

      // This must be the case of single step (which does not set DRR)

      // This must be the case of single step (which does not set DRR)

    }

    }

  return;

  return;

}

}

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Send a packet acknowledging an exception has occurred

//! Send a packet acknowledging an exception has occurred

//! The only signal we ever see in this implementation is TRAP.

//! The only signal we ever see in this implementation is TRAP.

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  // Construct a signal received packet

  // Construct a signal received packet

  pkt->data[0] = 'S';

  pkt->data[0] = 'S';

  pkt->data[1] = Utils::hex2Char (rsp_sigval >> 4);

  pkt->data[1] = Utils::hex2Char (rsp_sigval >> 4);

  pkt->data[2] = Utils::hex2Char (rsp_sigval % 16);

  pkt->data[2] = Utils::hex2Char (rsp_sigval % 16);

  rsp->putPkt (pkt);

  rsp->putPkt (pkt);

}       // rspReportException ()

}       // rspReportException ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Handle a RSP continue request

//! Handle a RSP continue request

//! This version is typically used for the 'c' packet, to continue without

//! This version is typically used for the 'c' packet, to continue without

//! signal, in which case EXCEPT_NONE is passed in as the exception to use.

//! signal, in which case EXCEPT_NONE is passed in as the exception to use.

//! At present other exceptions are not supported

//! At present other exceptions are not supported

//! @param[in] except  The OpenRISC 1000 exception to use

//! @param[in] except  The OpenRISC 1000 exception to use

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  uint32_t  addr;                       // Address to continue from, if any

  uint32_t  addr;                       // Address to continue from, if any

  // Reject all except 'c' packets

  // Reject all except 'c' packets

      return;

      return;

    }

    }

  // Get an address if we have one

  // Get an address if we have one

      addr = readNpc ();                // Default uses current NPC

      addr = readNpc ();                // Default uses current NPC

      cerr << "Warning: RSP continue address " << pkt->data

      cerr << "Warning: RSP continue address " << pkt->data

                << " not recognized: ignored" << endl;

                << " not recognized: ignored" << endl;

      addr = readNpc ();                // Default uses current NPC

      addr = readNpc ();                // Default uses current NPC

    }

    }

  rspContinue (addr, EXCEPT_NONE);

  rspContinue (addr, EXCEPT_NONE);

}       // rspContinue ()

}       // rspContinue ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Handle a RSP continue with signal request

//! Handle a RSP continue with signal request

//! @todo Currently does nothing. Will use the underlying generic continue

//! @todo Currently does nothing. Will use the underlying generic continue

//!       function. 

//!       function. 

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  cerr << "RSP continue with signal '" << pkt->data

  cerr << "RSP continue with signal '" << pkt->data

       << "' received" << endl;

       << "' received" << endl;

}       // rspContinue ()

}       // rspContinue ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Generic processing of a continue request

//! Generic processing of a continue request

//! The signal may be EXCEPT_NONE if there is no exception to be

//! The signal may be EXCEPT_NONE if there is no exception to be

//! handled. Currently the exception is ignored.

//! handled. Currently the exception is ignored.

//! processor is unstalled.

//! processor is unstalled.

//! @param[in] addr    Address from which to step

//! @param[in] addr    Address from which to step

//! @param[in] except  The exception to use (if any)                         

//! @param[in] except  The exception to use (if any)                         

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  // Set the address as the value of the next program counter

  // Set the address as the value of the next program counter

  writeNpc (addr);

  writeNpc (addr);

  /*

  /*

  */

  */

  // Clear Debug Reason Register and watchpoint break generation in Debug Mode

  // Clear Debug Reason Register and watchpoint break generation in Debug Mode

  // Register 2 for watchpoints that we triggered to stop this time.

  // Register 2 for watchpoints that we triggered to stop this time.

  debugUnit->writeSpr (SPR_DRR,  0);

  debugUnit->writeSpr (SPR_DRR,  0);

      /*

      /*

         Disable last trap generation on watchpoint if this is why we stopped

         Disable last trap generation on watchpoint if this is why we stopped

         last time.

         last time.

      */

      */

      uint32_t temp_dmr2 = debugUnit->readSpr (SPR_DMR2);

      uint32_t temp_dmr2 = debugUnit->readSpr (SPR_DMR2);

          /*

          /*

             One of these breakpoints is responsible for our stopping, so

             One of these breakpoints is responsible for our stopping, so

             disable it this time we start. GDB will send a packet re-enabling

             disable it this time we start. GDB will send a packet re-enabling

             it next time we continue.

             it next time we continue.

          */

          */

        }

        }

    }

    }

  // Clear the single step trigger in Debug Mode Register 1 and set traps to

  // Clear the single step trigger in Debug Mode Register 1 and set traps to

  // be handled by the debug unit in the Debug Stop Register

  // be handled by the debug unit in the Debug Stop Register

  debugUnit->andSpr (SPR_DMR1, ~SPR_DMR1_ST);

  debugUnit->andSpr (SPR_DMR1, ~SPR_DMR1_ST);

  debugUnit->orSpr ( SPR_DSR,  SPR_DSR_TE);

  debugUnit->orSpr ( SPR_DSR,  SPR_DSR_TE);

  debugUnit->unstall ();

  debugUnit->unstall ();

  targetStopped = false;

  targetStopped = false;

}       // rspContinue ()

}       // rspContinue ()

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

//!Handle an interrupt from GDB

//!Handle an interrupt from GDB

//! Detect an interrupt from GDB and stall the processor                        

//! Detect an interrupt from GDB and stall the processor                        

//------------------------------------------------------------------------------

//------------------------------------------------------------------------------

{

{

  unsigned char  c;

  unsigned char  c;

  c = rsp->getRspChar();

  c = rsp->getRspChar();

      // Had issues, just return

      // Had issues, just return

      return;

      return;

    }

    }

  // Ensure this is a ETX control char (0x3), currently, we only call this

  // Ensure this is a ETX control char (0x3), currently, we only call this

  // function when we've peeked and seen it, otherwise, ignore, return and pray

  // function when we've peeked and seen it, otherwise, ignore, return and pray

  // things go back to normal...

  // things go back to normal...

      return;

      return;

    }

    }

  // Otherwise, it's an interrupt packet, stall the processor, and upon return

  // Otherwise, it's an interrupt packet, stall the processor, and upon return

  // to the main handle_rsp() loop, it will inform GDB.

  // to the main handle_rsp() loop, it will inform GDB.

  debugUnit->stall ();

  debugUnit->stall ();

//! (i.e. SPR PPC), NPC (i.e. SPR NPC) and SR (i.e. SPR SR). Each register is

//! (i.e. SPR PPC), NPC (i.e. SPR NPC) and SR (i.e. SPR SR). Each register is

//! returned as a sequence of bytes in target endian order.

//! returned as a sequence of bytes in target endian order.

//! Each byte is packed as a pair of hex digits.                             

//! Each byte is packed as a pair of hex digits.                             

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  // The GPRs

  // The GPRs

      Utils::reg2Hex (readGpr (r), &(pkt->data[r * 8]));

      Utils::reg2Hex (readGpr (r), &(pkt->data[r * 8]));

    }

    }

  // PPC, NPC and SR

  // PPC, NPC and SR

  Utils::reg2Hex (readNpc (),                   &(pkt->data[NPC_REGNUM * 8]));

  Utils::reg2Hex (readNpc (),                   &(pkt->data[NPC_REGNUM * 8]));

  Utils::reg2Hex (debugUnit->readSpr (SPR_SR),  &(pkt->data[SR_REGNUM  * 8]));

  Utils::reg2Hex (debugUnit->readSpr (SPR_SR),  &(pkt->data[SR_REGNUM  * 8]));

  // Finalize the packet and send it

  // Finalize the packet and send it

  pkt->data[NUM_REGS * 8] = 0;

  pkt->data[NUM_REGS * 8] = 0;

  pkt->setLen (NUM_REGS * 8);

  pkt->setLen (NUM_REGS * 8);

  rsp->putPkt (pkt);

  rsp->putPkt (pkt);

}       // rspReadAllRegs ()

}       // rspReadAllRegs ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Handle a RSP write all registers request

//! Handle a RSP write all registers request

//! The registers follow the GDB sequence for OR1K: GPR0 through GPR31, PPC

//! The registers follow the GDB sequence for OR1K: GPR0 through GPR31, PPC

//! (i.e. SPR PPC), NPC (i.e. SPR NPC) and SR (i.e. SPR SR). Each register is

//! (i.e. SPR PPC), NPC (i.e. SPR NPC) and SR (i.e. SPR SR). Each register is

//! @todo There is no error checking at present. Non-hex chars will generate a

//! @todo There is no error checking at present. Non-hex chars will generate a

//!       warning message, but there is no other check that the right amount

//!       warning message, but there is no other check that the right amount

//!       of data is present. The result is always "OK".

//!       of data is present. The result is always "OK".

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  // The GPRs

  // The GPRs

      writeGpr (r, Utils::hex2Reg (&(pkt->data[r * 8])));

      writeGpr (r, Utils::hex2Reg (&(pkt->data[r * 8])));

    }

    }

  // PPC, NPC and SR

  // PPC, NPC and SR

  writeNpc (                    Utils::hex2Reg (&(pkt->data[NPC_REGNUM * 8])));

  writeNpc (                    Utils::hex2Reg (&(pkt->data[NPC_REGNUM * 8])));

  // Acknowledge (always OK for now).

  // Acknowledge (always OK for now).

  pkt->packStr ("OK");

  pkt->packStr ("OK");

  rsp->putPkt (pkt);

  rsp->putPkt (pkt);

}       // rspWriteAllRegs ()

}       // rspWriteAllRegs ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Handle a RSP read memory (symbolic) request

//! Handle a RSP read memory (symbolic) request

//! Syntax is:

//! Syntax is:

//! The response is the bytes, lowest address first, encoded as pairs of hex

//! The response is the bytes, lowest address first, encoded as pairs of hex

//! digits.

//! digits.

//! The length given is the number of bytes to be read.

//! The length given is the number of bytes to be read.

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  unsigned int    addr;                 // Where to read the memory

  unsigned int    addr;                 // Where to read the memory

  int             len;                  // Number of bytes to read

  int             len;                  // Number of bytes to read

  int             off;                  // Offset into the memory

  int             off;                  // Offset into the memory

      cerr << "Warning: Failed to recognize RSP read memory command: "

      cerr << "Warning: Failed to recognize RSP read memory command: "

                << pkt->data << endl;

                << pkt->data << endl;

      pkt->packStr ("E01");

      pkt->packStr ("E01");

      rsp->putPkt (pkt);

      rsp->putPkt (pkt);

      return;

      return;

    }

    }

  // Make sure we won't overflow the buffer (2 chars per byte)

  // Make sure we won't overflow the buffer (2 chars per byte)

      cerr << "Warning: Memory read " << pkt->data

      cerr << "Warning: Memory read " << pkt->data

           << " too large for RSP packet: truncated" << endl;

           << " too large for RSP packet: truncated" << endl;

      len = (pkt->getBufSize() - 1) / 2;

      len = (pkt->getBufSize() - 1) / 2;

    }

    }

  //cerr << "rspReadMem: " << len << " bytes@0x"<< hex << addr << endl;

  //cerr << "rspReadMem: " << len << " bytes@0x"<< hex << addr << endl;

  // Refill the buffer with the reply

  // Refill the buffer with the reply

      unsigned char  ch = debugUnit->readMem8 (addr + off);

      unsigned char  ch = debugUnit->readMem8 (addr + off);

      pkt->data[off * 2]     = Utils::hex2Char(ch >>   4);

      pkt->data[off * 2]     = Utils::hex2Char(ch >>   4);

      pkt->data[off * 2 + 1] = Utils::hex2Char(ch &  0xf);

      pkt->data[off * 2 + 1] = Utils::hex2Char(ch &  0xf);

    }

    }

  pkt->setLen (strlen (pkt->data));

  pkt->setLen (strlen (pkt->data));

  rsp->putPkt (pkt);

  rsp->putPkt (pkt);

}       // rsp_read_mem ()

}       // rsp_read_mem ()

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

//! Handle a RSP write memory (symbolic) request

//! Handle a RSP write memory (symbolic) request

//! Syntax is:

//! Syntax is:

//! The data is the bytes, lowest address first, encoded as pairs of hex

//! The data is the bytes, lowest address first, encoded as pairs of hex

//! digits.

//! digits.

//! The length given is the number of bytes to be written.

//! The length given is the number of bytes to be written.

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

{

{

  uint32_t  addr;                       // Where to write the memory

  uint32_t  addr;                       // Where to write the memory

  int       len;                        // Number of bytes to write

  int       len;                        // Number of bytes to write

      cerr << "Warning: Failed to recognize RSP write memory "

      cerr << "Warning: Failed to recognize RSP write memory "

                << pkt->data << endl;

                << pkt->data << endl;

      pkt->packStr ("E01");

      pkt->packStr ("E01");

      rsp->putPkt (pkt);

      rsp->putPkt (pkt);

      return;

      return;

    }

    }

  // Find the start of the data and check there is the amount we expect.

  // Find the start of the data and check there is the amount we expect.

  char *symDat = (char *)(memchr (pkt->data, ':', pkt->getBufSize())) + 1;

  char *symDat = (char *)(memchr (pkt->data, ':', pkt->getBufSize())) + 1;

  int   datLen = pkt->getLen() - (symDat - pkt->data);

  int   datLen = pkt->getLen() - (symDat - pkt->data);

  // Sanity check

  // Sanity check

      pkt->packStr ("E01");

      pkt->packStr ("E01");

      rsp->putPkt (pkt);

      rsp->putPkt (pkt);

      return;

      return;

    }

    }

  // Write the bytes to memory (no check the address is OK here)

  // Write the bytes to memory (no check the address is OK here)

      uint8_t  nyb1 = Utils::char2Hex (symDat[off * 2]);

      uint8_t  nyb1 = Utils::char2Hex (symDat[off * 2]);

      uint8_t  nyb2 = Utils::char2Hex (symDat[off * 2 + 1]);

      uint8_t  nyb2 = Utils::char2Hex (symDat[off * 2 + 1]);