Subversion Repositories openrisc

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

// 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