Registers.h

   1 #ifndef AVR_REGISTERS_H
   2 #define AVR_REGISTERS_H
   3
   4 #include <vector>
   5 #include <string>
   6 #include "Memory.h"
   7
   8 namespace avr {
   9
  10         class Hardware;
  11
  12         class Register {
  13                 public:
  14                         Register() {}
  15                         Register(word address, const std::string & name);
  16                         ~Register() {}
  17
  18                 public:
  19                         void init(word address, const std::string & name);
  20                 unsigned char operator =(unsigned char val);
  21                 operator unsigned char() const;
  22                 void operator =(const Register & reg);
  23
  24                 public:
  25                         void set(unsigned char val);
  26                         unsigned char get() const;
  27
  28                 public:
  29                         word getAddress() const { return address; }
  30                         const std::string & getName() const { return name; }
  31
  32                 protected:
  33                         word address;
  34                         std::string name;
  35                         unsigned char val;
  36         };
  37
  38         class IORegister : public Register {
  39                 public:
  40                         IORegister(word address, const std::string & name,
  41                                         unsigned char initial = 0);
  42
  43                 public:
  44                         void reset();
  45                 unsigned char operator =(unsigned char val);
  46                 void operator |=(unsigned char val);
  47                 void operator &=(unsigned char val);
  48
  49                 public:
  50                         void registerHW(Hardware *hw);
  51
  52                 private:
  53                         unsigned char initial;
  54                         Hardware *hw;
  55         };
  56
  57         class IORegisters {
  58                 public:
  59                         IORegisters(unsigned int count);
  60                         ~IORegisters();
  61
  62                 public:
  63                         unsigned int size() const { return regs.size(); }
  64
  65                         /**
  66                          * Reset all registers to their initial value.
  67                          */
  68                         void reset();
  69
  70                         /**
  71                          * Reads a single bytes of raw data from the register memory
  72                          * at offset \e offset.
  73                          */
  74                         byte readByte(unsigned int offset) const;
  75
  76                         /**
  77                          * Writes a single bytes of raw data to the register memory
  78                          * at offset \e offset.
  79                          */
  80                         void writeByte(unsigned int offset, byte val);
  81
  82                 public:
  83                         void addReg( word addr, IORegister *reg );
  84                         IORegister & getIoreg(unsigned int offset) const;
  85                         IORegister *getIoreg(const std::string & name, bool required = true) const;
  86
  87                 private:
  88                         std::vector<IORegister *> regs;
  89         };
  90
  91         inline Register::Register(word address, const std::string & name) {
  92                 init( address, name );
  93         }
  94
  95         inline void Register::init(word address, const std::string & name) {
  96                 this->address = address;
  97                 this->name = name;
  98         }
  99
 100         inline IORegister::IORegister(word address,
 101                         const std::string & name, unsigned char initial)
 102                 : Register(address, name), initial(initial), hw(0) {
 103         }
 104
 105         inline void IORegister::reset() {
 106                 set( initial );
 107         }
 108
 109         inline void Register::set(unsigned char val) {
 110                 this->val = val;
 111         }
 112
 113         inline unsigned char Register::get() const {
 114                 return val;
 115         }
 116
 117         inline void Register::operator =(const Register & reg) {
 118             *this = (unsigned char)reg;
 119         }
 120
 121         inline byte IORegisters::readByte(unsigned int offset) const {
 122                 if( regs[offset] != 0 )
 123                         return (byte)*regs[offset];
 124
 125                 return 0;
 126         }
 127
 128         inline void IORegisters::writeByte(unsigned int offset, byte val) {
 129                 if( regs[offset] != 0 )
 130                         (*regs[offset]) = val;
 131         }
 132
 133         inline IORegister & IORegisters::getIoreg(unsigned int offset) const {
 134                 return *regs[offset];
 135         }
 136
 137         inline void IORegister::registerHW(Hardware *hw) {
 138                 this->hw = hw;
 139         }
 140
 141 }
 142
 143 #endif /*AVR_REGISTERS_H*/