Subversion Repositories openrisc

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

// SystemC OpenRISC 1000 Debug Unit: 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 DEBUG_UNIT_SC__H

#define DEBUG_UNIT_SC__H

// Define if no cache is wanted

#define NOCACHE

#include <stdint.h>

#include "systemc"

#include "JtagSC_includes.h"

#include "OrpsocAccess.h"

#include "SprCache.h"

#include "MemCache.h"

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

//! Module modeling the OpenRISC 1000 Debug Unit

//! Provides a high level interface to the GDB Server module with functions to

//! access SPRs, Wishbone memory and CPU control.

//! Provides a low level interface to the Embecosm SystemC JTAG interface,

//! queueing requests to read and write JTAG registers.

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

class DebugUnitSC:public sc_core::sc_module {

public:

        // Constructor and destructor

        DebugUnitSC(sc_core::sc_module_name name,

                    sc_core::sc_fifo < TapAction * >*_tapActionQueue);

        ~DebugUnitSC();

        // Reset function for the debug unit

        void resetDebugUnit();

        // Functions to control and report on the CPU

        void reset();

        void stall();

        void unstall();

        bool isStalled();

        // Functions to access SPRs

        uint32_t readSpr(uint16_t sprNum);

        void writeSpr(uint16_t sprNum, uint32_t value);

        void andSpr(uint16_t sprNum, uint32_t value);

        void orSpr(uint16_t sprNum, uint32_t value);

        // Functions to access memory

        uint32_t readMem32(uint32_t addr);

        bool writeMem32(uint32_t addr, uint32_t value);

        uint8_t readMem8(uint32_t addr);

        bool writeMem8(uint32_t addr, uint8_t value);

private:

        // JTAG instructions

        static const uint32_t CHAIN_SELECT_IR = 0x3;    //!< Chain Select instruction

        static const uint32_t DEBUG_IR = 0x8;   //!< Debug instruction

        //! JTAG instruction register length. There is no CRC for this register.

        static const int JTAG_IR_LEN = 4;       //!< JTAG instr reg length

        // DEBUG UNIT CHAIN data register fields

        static const int DUSEL_DR_LEN = 73;     //!< total DUSEL DR size

        static const int DUSEL_SEL_OFF = 0;      //!< start of select field

        static const int DUSEL_SEL_LEN = 1;     //!< length of select field

        static const int DUSEL_OPCODE_OFF = DUSEL_SEL_OFF + DUSEL_SEL_LEN;      //!< start of opcode field

        static const int DUSEL_OPCODE_LEN = 4;  //!< length of opcode field

        static const int DUSEL_CRC_OFF = DUSEL_OPCODE_OFF + DUSEL_OPCODE_LEN;   //!< start of CRC field

        static const int DUSEL_CRC_LEN = 32;    //!< length of CRC field

        static const int DUSEL_RESP_STATUS_OFF = DUSEL_CRC_OFF + DUSEL_CRC_LEN;

        static const int DUSEL_RESP_STATUS_LEN = 4;

        static const int DUSEL_RESP_CRC_OFF =

            DUSEL_RESP_STATUS_OFF + DUSEL_RESP_STATUS_LEN;

        static const int DUSEL_RESP_CRC_LEN = 32;

        static const uint32_t DBG_CRC32_POLY = 0x04c11db7;

        // OpenRISC 1000 scan chains (values in DUSEL data register field)

        static const int OR1K_SC_UNDEF = -1;    //!< Undefined OR1K scan chain

        static const int OR1K_SC_WISHBONE = 0;   //!< for memory access

        static const int OR1K_SC_CPU0 = 1;      //!< for access to CPU0

        static const int OR1K_SC_CPU1 = 2;      //!< for access to CPU1

        // JTAG RISC_DEBUG (for accessing SPR) data register fields

        static const int RISC_DEBUG_DR_LEN = 74;        //!< Total RISC_DEBUG DR size

        static const int RISC_DEBUG_ADDR_OFF = 0;        //!< start of address field

        static const int RISC_DEBUG_ADDR_LEN = 32;      //!< length of address field

        static const int RISC_DEBUG_RW_OFF = 32;        //!< start of read/write field

        static const int RISC_DEBUG_RW_LEN = 1; //!< length of read/write field

        static const int RISC_DEBUG_DATA_OFF = 33;      //!< start of data field

        static const int RISC_DEBUG_DATA_LEN = 32;      //!< length of data field

        static const int RISC_DEBUG_CRC_OFF = 65;       //!< start of CRC field

        static const int RISC_DEBUG_CRC_LEN = 8;        //!< length of CRC field

        static const int RISC_DEBUG_SPARE_OFF = 73;     //!< start of spare bits

        static const int RISC_DEBUG_SPARE_LEN = 1;      //!< length of spare bit field

        // JTAG REGISTER (for controlling the CPU) data register fields

        static const int REGISTER_DR_LEN = 47;  //!< Total REGISTER DR size

        static const int REGISTER_ADDR_OFF = 0;  //!< start of address field

        static const int REGISTER_ADDR_LEN = 5; //!< length of address field

        static const int REGISTER_RW_OFF = 5;   //!< start of read/write field

        static const int REGISTER_RW_LEN = 1;   //!< length of read/write field

        static const int REGISTER_DATA_OFF = 6; //!< start of data field

        static const int REGISTER_DATA_LEN = 32;        //!< length of data field

        static const int REGISTER_CRC_OFF = 38; //!< start of CRC field

        static const int REGISTER_CRC_LEN = 8;  //!< length of CRC field

        static const int REGISTER_SPARE_OFF = 46;       //!< start of spare bits

        static const int REGISTER_SPARE_LEN = 1;        //!< length of spare bit field

        // Register addresses for the REGISTER scan chain

        static const uint8_t OR1K_RSC_RISCOP = 0x04;    //!< Used to reset/stall CPU

        // Bits for the RISCOP register

        static const uint32_t RISCOP_RESET = 0x00000001;        //!< Reset the CPU

        static const uint32_t RISCOP_STALL = 0x00000002;        //!< Stall the CPU

        // JTAG WISHBONE (for accessing SPR) data register fields

        static const int WISHBONE_DR_LEN = 74;  //!< Total WISHBONE DR size

        static const int WISHBONE_ADDR_OFF = 0;  //!< start of address field

        static const int WISHBONE_ADDR_LEN = 32;        //!< length of address field

        static const int WISHBONE_RW_OFF = 32;  //!< start of read/write field

        static const int WISHBONE_RW_LEN = 1;   //!< length of read/write field

        static const int WISHBONE_DATA_OFF = 33;        //!< start of data field

        static const int WISHBONE_DATA_LEN = 32;        //!< length of data field

        static const int WISHBONE_CRC_OFF = 65; //!< start of CRC field

        static const int WISHBONE_CRC_LEN = 8;  //!< length of CRC field

        static const int WISHBONE_SPARE_OFF = 73;       //!< start of spare bits

        static const int WISHBONE_SPARE_LEN = 1;        //!< length of spare bit field

        //! The NPC is special, so we need to know about it

        static const int SPR_NPC = 0x10;

        //! The JTAG fifo we queue on

        sc_core::sc_fifo < TapAction * >*tapActionQueue;

        //! The processor stall state. When stalled we can use cacheing on

        //! reads/writes of memory and SPRs.

        enum {

                UNKNOWN,

                STALLED,

        } stallState;

        //! The currently selected scan chain

        int currentScanChain;

#ifdef NOCACHE

        //! Even if no cached, we need to cache the NPC

        uint32_t npcCachedValue;

        //! Cached NPC is valid

        bool npcCacheIsValid;

#else

        //! The SPR cache

        SprCache *sprCache;

        //! The memory cache

        MemCache *memCache;

#endif

        // Functions to control the CPU

        uint32_t readRiscop();

        void writeRiscop(uint32_t value);

        // Or1k JTAG actions

        void selectDebugModule(int chain);

        uint32_t readJtagReg(uint32_t addr);

        uint32_t readJtagReg1(uint32_t addr, int bitSizeNoCrc);

        uint32_t readJtagReg1(uint64_t * dRegArray,

                              uint32_t addr, int bitSizeNoCrc);

        void writeJtagReg(uint32_t addr, uint32_t data);

        // Utilities to pack and unpack bits to/from data registers.

        void clearBits(uint64_t regArray[], int regBits);

        void packBits(uint64_t regArray[],

                      int fieldOffset, int fieldBits, uint64_t fieldVal);

        uint64_t unpackBits(uint64_t regArray[],

                            int fieldOffset, int fieldBits);

        // Utility to compute CRC-8 the OpenRISC way.

        uint8_t crc8(uint64_t dataArray[], int size);

        // Utility to compute CRC-32 for the debug unit

        uint32_t crc32(uint64_t dataArray[], int size, int offset);

        // Functions to bitreverse values

        uint32_t bit_reverse_swar_2(uint32_t x);

        uint32_t bit_reverse_swar_4(uint32_t x);

        uint32_t bit_reverse_swar_8(uint32_t x);

        uint32_t bit_reverse_swar_16(uint32_t x);

        uint32_t bit_reverse_swar_32(uint32_t x);

#define BITREV(x,y) bit_reverse_data(x,y)

        uint32_t bit_reverse_data(uint32_t x, int length);

};                              // DebugUnitSC ()

#endif // DEBUG_UNIT_SC__H