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                          * Reads a single bytes of raw data from memory at
  47                          * offset \e offset.
  48                          *
  49                          * \exception AccessViolation { When the data requested is
  50                          *              not available, this exception is thrown }
  51                          */
  52                         byte readByte(unsigned int offset) const;
  53
  54                         /**
  55                          * Reads a word of raw data from memory starting at
  56                          * offset \e offset.
  57                          *
  58                          * \exception AccessViolation { When the data requested is
  59                          *              not available, this exception is thrown }
  60                          */
  61                         word readWord(unsigned int offset) const;
  62
  63                         /**
  64                          * Reads a single bytes of raw data from memory at
  65                          * offset \e offset.
  66                          *
  67                          * \exception AccessViolation { When the data requested is
  68                          *              not available, this exception is thrown }
  69                          */
  70                         void writeByte(unsigned int offset, byte val);
  71
  72                         /**
  73                          * Reads a word of raw data from memory starting at
  74                          * offset \e offset.
  75                          *
  76                          * \exception AccessViolation { When the data requested is
  77                          *              not available, this exception is thrown }
  78                          */
  79                         void writeWord(unsigned int offset, word val);
  80
  81                         const unsigned char *readRam(unsigned int offset, unsigned int size) const;
  82                         void writeRam(unsigned char *data, unsigned int offset, unsigned int size);
  83
  84                 public:
  85                         static const unsigned int registerSpaceSize = 32;
  86
  87                 private:
  88                         Register R[registerSpaceSize];
  89
  90                         IORegisters regs;
  91                         SRam sram;
  92                         ERam *eram;
  93         };
  94
  95         inline IORegister & MMU::getIoreg(unsigned int offset) {
  96                 return regs.getIoreg(offset);
  97         }
  98
  99         inline const IORegister & MMU::getIoreg(unsigned int offset) const {
 100                 return regs.getIoreg(offset);
 101         }
 102
 103         inline IORegister *MMU::getIoreg(const std::string & name) {
 104                 return regs.getIoreg(name);
 105         }
 106
 107         inline byte MMU::statusReg() const {
 108                 return regs.getIoreg("SREG")->getAddress() - registerSpaceSize;
 109         }
 110
 111         inline void MMU::reset() {
 112                 for(unsigned int i = 0; i < registerSpaceSize; ++i)
 113                         R[i] = 0;
 114                 regs.reset();
 115         }
 116
 117 }
 118
 119 #endif /*AVR_MMU_H_*/