Subversion Repositories openrisc_me

// ----------------------------------------------------------------------------
 
// SystemC GDB RSP server: definition
 
// Copyright (C) 2008  Embecosm Limited <info@embecosm.com>
 
// Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
// This file is part of the GDB interface to the cycle accurate model of the
// OpenRISC 1000 based system-on-chip, ORPSoC, built using Verilator.
 
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 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 Lesser General Public
// License for more details.
 
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
// ----------------------------------------------------------------------------
 
// $Id$
 
#ifndef GDB_SERVER_SC__H
#define GDB_SERVER_SC__H
 
#include <stdint.h>
 
#include "systemc"
 
#include "JtagSC_includes.h"
 
#include "OrpsocAccess.h"
#include "RspConnection.h"
#include "MpHash.h"
#include "RspPacket.h"
#include "DebugUnitSC.h"
 
 
//! Module implementing a GDB RSP server.
 
//! A thread listens for RSP requests, which are converted to requests to read
//! and write registers, memory or control the CPU in the debug unit
 
class GdbServerSC
  : public sc_core::sc_module
{
public:
 
  // Constructor and destructor
  GdbServerSC (sc_core::sc_module_name        name,
	       uint32_t                       _flashStart,
	       uint32_t                       _flashEnd,
	       int                            rspPort,
	       sc_core::sc_fifo<TapAction *> *tapActionQueue);
  ~GdbServerSC ();
 
private:
 
  //! Definition of GDB target signals.
 
  //! Data taken from the GDB 6.8 source. Only those we use defined here.
  enum TargetSignal {
    TARGET_SIGNAL_NONE =  0,
    TARGET_SIGNAL_INT  =  2,
    TARGET_SIGNAL_ILL  =  4,
    TARGET_SIGNAL_TRAP =  5,
    TARGET_SIGNAL_FPE  =  8,
    TARGET_SIGNAL_BUS  = 10,
    TARGET_SIGNAL_SEGV = 11,
    TARGET_SIGNAL_ALRM = 14,
    TARGET_SIGNAL_USR2 = 31,
    TARGET_SIGNAL_PWR  = 32
  };
 
  // Register numbering. Matches GDB client
  static const int  MAX_SPRS   = 0x10000;	//!< Max number of OR1K SPRs
  static const int  max_gprs   = 32;		//!< Max number of OR1K GPRs
 
  static const int  PPC_REGNUM = max_gprs + 0;	//!< Previous PC
  static const int  NPC_REGNUM = max_gprs + 1;	//!< Next PC
  static const int  SR_REGNUM  = max_gprs + 2;	//!< Supervision Register
 
  static const int  NUM_REGS   = max_gprs + 3;	//!< Total GDB registers
 
  //! Maximum size of a GDB RSP packet
  //static const int  RSP_PKT_MAX  = NUM_REGS * 8 + 1;
  static const int  RSP_PKT_MAX  = 1024*16;
 
  // OpenRISC exception addresses. Only the ones we need to know about
  static const uint32_t  EXCEPT_NONE  = 0x000;  //!< No exception
  static const uint32_t  EXCEPT_RESET = 0x100;  //!< Reset
 
  // SPR numbers
  static const uint16_t  SPR_NPC  = 0x0010;	//!< Next program counter
  static const uint16_t  SPR_SR   = 0x0011;	//!< Supervision register
  static const uint16_t  SPR_PPC  = 0x0012;	//!< Previous program counter
  static const uint16_t  SPR_GPR0 = 0x0400;	//!< GPR 0
 
  static const uint16_t  SPR_DVR0 = 0x3000;	//!< Debug value register 0
  static const uint16_t  SPR_DVR1 = 0x3001;	//!< Debug value register 1
  static const uint16_t  SPR_DVR2 = 0x3002;	//!< Debug value register 2
  static const uint16_t  SPR_DVR3 = 0x3003;	//!< Debug value register 3
  static const uint16_t  SPR_DVR4 = 0x3004;	//!< Debug value register 4
  static const uint16_t  SPR_DVR5 = 0x3005;	//!< Debug value register 5
  static const uint16_t  SPR_DVR6 = 0x3006;	//!< Debug value register 6
  static const uint16_t  SPR_DVR7 = 0x3007;	//!< Debug value register 7
 
  static const uint16_t  SPR_DCR0 = 0x3008;	//!< Debug control register 0
  static const uint16_t  SPR_DCR1 = 0x3009;	//!< Debug control register 1
  static const uint16_t  SPR_DCR2 = 0x300a;	//!< Debug control register 2
  static const uint16_t  SPR_DCR3 = 0x300b;	//!< Debug control register 3
  static const uint16_t  SPR_DCR4 = 0x300c;	//!< Debug control register 4
  static const uint16_t  SPR_DCR5 = 0x300d;	//!< Debug control register 5
  static const uint16_t  SPR_DCR6 = 0x300e;	//!< Debug control register 6
  static const uint16_t  SPR_DCR7 = 0x300f;	//!< Debug control register 7  
 
  static const uint16_t  SPR_DMR1 = 0x3010;	//!< Debug mode register 1
  static const uint16_t  SPR_DMR2 = 0x3011;	//!< Debug mode register 2
  static const uint16_t  SPR_DSR  = 0x3014;	//!< Debug stop register
  static const uint16_t  SPR_DRR  = 0x3015;	//!< Debug reason register
 
  // SPR masks and offsets
  static const uint32_t  SPR_DMR1_ST   = 0x00400000;  //!< Single-step trace
  static const uint32_t  SPR_DMR2_WGB  = 0x003ff000;  //!< W/pt generating B/pt
  static const uint32_t  SPR_DMR2_WBS  = 0xffc00000;  //!< W/pt B/pt status
  static const uint32_t  SPR_DSR_TE    = 0x00002000;  //!< Trap
  static const uint32_t  SPR_DCR_DP_MASK  = 0x00000001;  //!< Debug Pair Present
  static const uint32_t  SPR_DCR_CC_MASK  = 0x0000000e;  //!< Compare Condition
  static const uint32_t  SPR_DCR_SC_MASK  = 0x00000010;  //!< Signed Comparison
  static const uint32_t  SPR_DCR_CT_MASK  = 0x000000e0;  //!< Compare To
  static const uint32_t  SPR_DMR2_WGB_SHIFT  = 12;  //!< W/pt Generate B/pt
 
 
  // DRR (Debug Reason Register) Bits
  static const uint32_t SPR_DRR_RSTE   = 0x00000001;  //!< Reset
  static const uint32_t SPR_DRR_BUSEE  = 0x00000002;  //!< Bus error
  static const uint32_t SPR_DRR_DPFE   = 0x00000004;  //!< Data page fault
  static const uint32_t SPR_DRR_IPFE   = 0x00000008;  //!< Insn page fault
  static const uint32_t SPR_DRR_TTE    = 0x00000010;  //!< Tick timer
  static const uint32_t SPR_DRR_AE     = 0x00000020;  //!< Alignment
  static const uint32_t SPR_DRR_IIE    = 0x00000040;  //!< Illegal instruction
  static const uint32_t SPR_DRR_IE     = 0x00000080;  //!< Interrupt
  static const uint32_t SPR_DRR_DME    = 0x00000100;  //!< DTLB miss
  static const uint32_t SPR_DRR_IME    = 0x00000200;  //!< ITLB miss
  static const uint32_t SPR_DRR_RE     = 0x00000400;  //!< Range fault
  static const uint32_t SPR_DRR_SCE    = 0x00000800;  //!< System call
  static const uint32_t SPR_DRR_FPE    = 0x00001000;  //!< Floating point
  static const uint32_t SPR_DRR_TE     = 0x00002000;  //!< Trap
 
  //! RSP Signal valu
  uint32_t rsp_sigval;
 
  //! Trap instruction for OR32
  static const uint32_t  OR1K_TRAP_INSTR = 0x21000001;
 
  //! Thread ID used by Or1ksim
  static const int  OR1KSIM_TID = 1;
 
  // The bounds of flash memory
  uint32_t  flashStart;			//<! Start of flash memory
  uint32_t  flashEnd;			//<! End of flash memory
 
  //! Our associated Debug Unit
  DebugUnitSC *debugUnit;
 
  //! Our associated RSP interface (which we create)
  RspConnection *rsp;
 
  //! The packet pointer. There is only ever one packet in use at one time, so
  //! there is no need to repeatedly allocate and delete it.
  RspPacket *pkt;
 
  //! Hash table for matchpoints
  MpHash *mpHash;
 
  //! Is the target stopped
  bool  targetStopped;
 
  // SystemC thread to listen for and service RSP requests
  void  rspServer ();
 
  // Main RSP request handler
  void  rspClientRequest ();
 
  // Handle the various RSP requests
  void  rspCheckForException();
  void  rspReportException ();
  void  rspContinue ();
  void  rspContinue (uint32_t   except);
  void  rspContinue (uint32_t  addr,
		     uint32_t  except);
  void  rspInterrupt ();
  void  rspReadAllRegs ();
  void  rspWriteAllRegs ();
  void  rspReadMem ();
  void  rspWriteMem ();
  void  rspReadReg ();
  void  rspWriteReg ();
  void  rspQuery ();
  void  rspCommand ();
  void  rspSet ();
  void  rspRestart ();
  void  rspStep ();
  void  rspStep (uint32_t   except);
  void  rspStep (uint32_t  addr,
		 uint32_t  except);
  void  rspVpkt ();
  void  rspWriteMemBin ();
  void  rspRemoveMatchpoint ();
  void  rspInsertMatchpoint ();
 
  // Convenience wrappers for getting particular registers, which are really
  // SPRs.
  uint32_t  readNpc ();
  void      writeNpc (uint32_t  addr);
 
  uint32_t  readGpr (int  regNum);
  void      writeGpr (int       regNum,
		      uint32_t  value);
 
  // Check if we got a message from the or1200 monitor module telling us
  // to stall
  bool   checkMonitorPipe ();
 
};	// GdbServerSC ()
 
#endif	// GDB_SERVER_SC__H