src/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         /**
  13          * @author Tom Haber
  14          * @date Apr 23, 2008
  15          * @brief A register
  16          *
  17          * Represents general purpose registers and IORegisters
  18          */
  19         class Register {
  20                 public:
  21                         Register() {}
  22                         Register(word address, const std::string & name);
  23                         ~Register() {}
  24
  25                 public:
  26                         /**
  27                          * Initialize the register
  28                          * @param address the address of the register (IO address not mem)
  29                          * @param name the name of the register
  30                          */
  31                         void init(word address, const std::string & name);
  32
  33                         /**
  34                          * Changes the register value to \e val.
  35                          */
  36                 unsigned char operator =(unsigned char val);
  37
  38                         /**
  39                          * Returns the register value.
  40                          */
  41                 operator unsigned char() const;
  42
  43                         /**
  44                          * Changes the register value to the value of register \reg.
  45                          */
  46                 void operator =(const Register & reg);
  47
  48                 public:
  49                         void set(unsigned char val);
  50                         unsigned char get() const;
  51
  52                 public:
  53                         /**
  54                          * Returns the IO address of the register
  55                          */
  56                         word getAddress() const { return address; }
  57
  58                         /**
  59                          * Returns the name of the register
  60                          */
  61                         const std::string & getName() const { return name; }
  62
  63                 protected:
  64                         word address;
  65                         std::string name;
  66                         unsigned char val;
  67         };
  68
  69         /**
  70          * @author Tom Haber
  71          * @date Apr 23, 2008
  72          * @brief An IOregister
  73          *
  74          * Adds functionality to Register for IORegisters.
  75          * Hardware can be bound to an IORegister and it will be
  76          * notified on changes.
  77          *
  78          * Some registers share an I/O location with another register.
  79          * When doing a write access to this I/O location, the high bit
  80          * controls which one of the two registers will be written.
  81          *
  82          * Read access is more complex: the read access is controlled by a
  83          * timed sequence. Reading the I/O location once returns the first
  84          * register content. If the register location was read in the
  85          * previous clock cycle, reading the register in the current cycle
  86          * will return the second register content.
  87          *
  88          * Note that the timed sequence for reading the shared location is
  89          * an atomic operation. Interrupts must therefore be controlled
  90          * (e.g., by disabling interrupts globally) during the read operation.
  91          *
  92          * These type of locations have to be taken into account elsewhere!
  93          */
  94         class IORegister : public Register {
  95                 public:
  96                         IORegister(word address, const std::string & name,
  97                                         unsigned char initial = 0);
  98
  99                 public:
 100                         /**
 101                          * Reset the register to its initial value.
 102                          */
 103                         void reset();
 104
 105                         /**
 106                          * Returns the register value.
 107                          */
 108                 operator unsigned char();
 109
 110                         /**
 111                          * Changes the register value to \e val
 112                          */
 113                 unsigned char operator =(unsigned char val);
 114
 115                 void operator |=(unsigned char val);
 116                 void operator &=(unsigned char val);
 117
 118                 public:
 119                         /**
 120                          * Bind an internal device to this register.
 121                          * The hardware will be notified on register value changes.
 122                          */
 123                         void registerHW(Hardware *hw);
 124
 125                 private:
 126                         unsigned char initial;
 127                         Hardware *hw;
 128         };
 129
 130         /**
 131          * @author Tom Haber
 132          * @date Apr 23, 2008
 133          * @brief All IORegisters
 134          *
 135          * Contains all IORegisters and provides an interface for the MMU.
 136          */
 137         class IORegisters {
 138                 public:
 139                         IORegisters(unsigned int count);
 140                         ~IORegisters();
 141
 142                 public:
 143                         unsigned int size() const { return regs.size(); }
 144
 145                         /**
 146                          * Reset all registers to their initial value.
 147                          */
 148                         void reset();
 149
 150                         /**
 151                          * Reads a single bytes of raw data from the register memory
 152                          * at offset \e offset.
 153                          */
 154                         byte readByte(unsigned int offset) const;
 155
 156                         /**
 157                          * Writes a single bytes of raw data to the register memory
 158                          * at offset \e offset.
 159                          */
 160                         void writeByte(unsigned int offset, byte val);
 161
 162                 public:
 163                         void addReg( word addr, IORegister *reg );
 164                         IORegister & getIoreg(unsigned int offset) const;
 165                         IORegister *getIoreg(const std::string & name, bool required = true) const;
 166
 167                 private:
 168                         std::vector<IORegister *> regs;
 169         };
 170
 171         inline Register::Register(word address, const std::string & name) {
 172                 init( address, name );
 173         }
 174
 175         inline void Register::init(word address, const std::string & name) {
 176                 this->address = address;
 177                 this->name = name;
 178         }
 179
 180         inline IORegister::IORegister(word address,
 181                         const std::string & name, unsigned char initial)
 182                 : Register(address, name), initial(initial), hw(0) {
 183         }
 184
 185         inline void IORegister::reset() {
 186                 set( initial );
 187         }
 188
 189         inline void Register::set(unsigned char val) {
 190                 this->val = val;
 191         }
 192
 193         inline unsigned char Register::get() const {
 194                 return val;
 195         }
 196
 197         inline void Register::operator =(const Register & reg) {
 198             *this = (unsigned char)reg;
 199         }
 200
 201         inline byte IORegisters::readByte(unsigned int offset) const {
 202                 if( regs[offset] != 0 )
 203                         return (byte)*regs[offset];
 204
 205                 return 0;
 206         }
 207
 208         inline unsigned char Register::operator =(unsigned char val) {
 209                 unsigned char ret = this->val;
 210                 this->val = val;
 211                 return ret;
 212         }
 213
 214         inline Register::operator unsigned char() const {
 215                 return val;
 216         }
 217
 218         inline void IORegisters::writeByte(unsigned int offset, byte val) {
 219                 if( regs[offset] != 0 )
 220                         (*regs[offset]) = val;
 221         }
 222
 223         inline IORegister & IORegisters::getIoreg(unsigned int offset) const {
 224                 return *regs[offset];
 225         }
 226
 227         inline void IORegister::registerHW(Hardware *hw) {
 228                 this->hw = hw;
 229         }
 230
 231 }
 232
 233 #endif /*AVR_REGISTERS_H*/