src/MMU.h

   1 #ifndef AVR_MMU_H
   2 #define AVR_MMU_H
   3
   4 #include "Memory.h"
   5 #include "SRam.h"
   6 #include "Registers.h"
   7
   8 namespace avr {
   9         class ERam;
  10
  11         /**
  12          * @author Tom Haber
  13          * @date Apr 23, 2008
  14          * @brief Memory Mapping Unit
  15          *
  16          * Manages address decoding for memory accesses: maps the different
  17          * regions to the correct classes.
  18          */
  19         class MMU {
  20                 public:
  21                         MMU(unsigned int ioSpaceSize, unsigned int ramSize, ERam *eram = 0);
  22                         ~MMU();
  23
  24                 public:
  25                         void addIOReg(unsigned int address,
  26                                                         const std::string & name, byte initial = 0);
  27                         const Register & getR(int r) const { return R[r]; }
  28
  29                         Register & reg(int r);
  30                         const Register & reg(int r) const;
  31
  32                         byte statusReg() const;
  33
  34                         IORegister & getIoreg(unsigned int offset);
  35                         const IORegister & getIoreg(unsigned int offset) const;
  36                         IORegister *getIoreg(const std::string & name);
  37
  38                         void reset();
  39
  40                 public:
  41                         unsigned int ioregs() const { return regs.size(); }
  42                         const std::string & registerName(byte addr) const;
  43
  44                 public:
  45                         /**
  46                          * Checks whether an offset is associated with a register
  47                          */
  48                         bool isRegister(unsigned int offset) const;
  49
  50                         /**
  51                          * Reads a single bytes of raw data from memory at
  52                          * offset \e offset.
  53                          *
  54                          * \exception AccessViolation { When the data requested is
  55                          *              not available, this exception is thrown }
  56                          */
  57                         byte readByte(unsigned int offset) const;
  58
  59                         /**
  60                          * Reads a word of raw data from memory starting at
  61                          * offset \e offset.
  62                          *
  63                          * \exception AccessViolation { When the data requested is
  64                          *              not available, this exception is thrown }
  65                          */
  66                         word readWord(unsigned int offset) const;
  67
  68                         /**
  69                          * Reads a single bytes of raw data from memory at
  70                          * offset \e offset.
  71                          *
  72                          * \exception AccessViolation { When the data requested is
  73                          *              not available, this exception is thrown }
  74                          */
  75                         void writeByte(unsigned int offset, byte val);
  76
  77                         /**
  78                          * Reads a word of raw data from memory starting at
  79                          * offset \e offset.
  80                          *
  81                          * \exception AccessViolation { When the data requested is
  82                          *              not available, this exception is thrown }
  83                          */
  84                         void writeWord(unsigned int offset, word val);
  85
  86                         const unsigned char *readRam(unsigned int offset, unsigned int size) const;
  87                         void writeRam(unsigned char *data, unsigned int offset, unsigned int size);
  88
  89                 public:
  90                         static const unsigned int registerSpaceSize = 32;
  91
  92                 private:
  93                         Register R[registerSpaceSize];
  94
  95                         IORegisters regs;
  96                         SRam sram;
  97                         ERam *eram;
  98         };
  99
 100         inline IORegister & MMU::getIoreg(unsigned int offset) {
 101                 return regs.getIoreg(offset);
 102         }
 103
 104         inline const IORegister & MMU::getIoreg(unsigned int offset) const {
 105                 return regs.getIoreg(offset);
 106         }
 107
 108         inline IORegister *MMU::getIoreg(const std::string & name) {
 109                 return regs.getIoreg(name);
 110         }
 111
 112         inline byte MMU::statusReg() const {
 113                 return regs.getIoreg("SREG")->getAddress() - registerSpaceSize;
 114         }
 115
 116         inline void MMU::reset() {
 117                 for(unsigned int i = 0; i < registerSpaceSize; ++i)
 118                         R[i] = 0;
 119                 regs.reset();
 120         }
 121
 122         inline bool MMU::isRegister(unsigned int offset) const {
 123                 return  offset < registerSpaceSize + regs.size();
 124         }
 125
 126 }
 127
 128 #endif /*AVR_MMU_H_*/