00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #ifndef RWMEM
00028 #define RWMEM
00029
00030 #include <string>
00031 #include <vector>
00032
00033 #include "traceval.h"
00034 #include "avrerror.h"
00035 #include "hardware.h"
00036
00037 class TraceValue;
00038
00040
00042 class RWMemoryMember {
00043
00044 public:
00051 RWMemoryMember(
00052 TraceValueRegister *registry,
00053 const std::string &tracename="",
00054 const int index=-1);
00057 RWMemoryMember(void);
00058 #ifndef SWIG
00059
00060 operator unsigned char() const;
00062 unsigned char operator=(unsigned char val);
00064 unsigned char operator=(const RWMemoryMember &mm);
00065 #endif
00066 virtual ~RWMemoryMember();
00067
00068 protected:
00072 virtual void set(unsigned char nv)=0;
00075 virtual unsigned char get() const=0;
00076
00082 mutable TraceValue *tv;
00083 TraceValueRegister *registry;
00084 };
00085
00087
00088 class GPIORegister: public RWMemoryMember, public Hardware {
00089
00090 public:
00091 GPIORegister(AvrDevice *core,
00092 TraceValueRegister *registry,
00093 const std::string &tracename):
00094 Hardware(core),
00095 RWMemoryMember(registry, tracename) { value = 0; }
00096
00097
00098 void Reset(void) { value = 0; }
00099
00100 protected:
00101 unsigned char get() const { return value; }
00102 void set(unsigned char v) { value = v; }
00103
00104 private:
00105 unsigned char value;
00106 };
00107
00109
00110 class RAM : public RWMemoryMember {
00111
00112 public:
00113 RAM(TraceValueCoreRegister *registry,
00114 const std::string &tracename,
00115 const size_t number,
00116 const size_t maxsize);
00117
00118 protected:
00119 unsigned char get() const;
00120 void set(unsigned char);
00121
00122 private:
00123 unsigned char value;
00124 TraceValueCoreRegister *corereg;
00125 };
00126
00128
00129 class InvalidMem : public RWMemoryMember {
00130 private:
00131 AvrDevice* core;
00132 int addr;
00133
00134 public:
00135 InvalidMem(AvrDevice *core, int addr);
00136
00137 protected:
00138 unsigned char get() const;
00139 void set(unsigned char);
00140 };
00141
00143
00144 class NotSimulatedRegister : public RWMemoryMember {
00145 private:
00146 const char * message_on_access;
00147
00148 public:
00149 NotSimulatedRegister(const char * message_on_access);
00150
00151 protected:
00152 unsigned char get() const;
00153 void set(unsigned char);
00154 };
00155
00157
00159 template<class P>
00160 class IOReg: public RWMemoryMember {
00161
00162 public:
00163 typedef unsigned char(P::*getter_t)();
00164 typedef void (P::*setter_t)(unsigned char);
00169 IOReg(TraceValueRegister *registry,
00170 const std::string &tracename,
00171 P *_p,
00172 getter_t _g=0,
00173 setter_t _s=0):
00174 RWMemoryMember(registry, tracename),
00175 p(_p),
00176 g(_g),
00177 s(_s)
00178 {
00179
00180 if (tv)
00181 tv->set_written();
00182 }
00183
00186 void hardwareChange(unsigned char val) { if(tv) tv->change(val); }
00188 void releaseTraceValue(void) {
00189 if(tv) {
00190 registry->UnregisterTraceValue(tv);
00191 delete tv;
00192 tv = NULL;
00193 }
00194 }
00195
00196 protected:
00197 unsigned char get() const {
00198 if (g)
00199 return (p->*g)();
00200 else if (tv) {
00201 avr_warning("Reading of '%s' is not supported.", tv->name().c_str());
00202 }
00203 return 0;
00204 }
00205 void set(unsigned char val) {
00206 if (s)
00207 (p->*s)(val);
00208 else if (tv) {
00209 avr_warning("Writing of '%s' (with %d) is not supported.", tv->name().c_str(), val);
00210 }
00211 }
00212
00213 private:
00214 P *p;
00215 getter_t g;
00216 setter_t s;
00217 };
00218
00219 class IOSpecialReg;
00220
00222
00233 class IOSpecialRegClient {
00234
00235 protected:
00236 friend class IOSpecialReg;
00237
00242 virtual unsigned char set_from_reg(const IOSpecialReg* reg, unsigned char nv)=0;
00243
00247 virtual unsigned char get_from_client(const IOSpecialReg* reg, unsigned char v)=0;
00248 };
00249
00253 class IOSpecialReg: public RWMemoryMember {
00254
00255 public:
00257 IOSpecialReg(TraceValueRegister *registry, const std::string &tracename);
00258
00260 void connectSRegClient(IOSpecialRegClient *c) { clients.push_back(c); }
00261
00263 void Reset(void) { Reset(0); }
00266 void Reset(unsigned char val) { value = 0; if(tv) tv->set_written(val); }
00267
00270 void hardwareChange(unsigned char val) { if(tv) tv->change(val); }
00271
00275 void hardwareChangeMask(unsigned char val, unsigned char mask) { if(tv) tv->change(val, mask); }
00276
00277 protected:
00278 std::vector<IOSpecialRegClient*> clients;
00279
00280 unsigned char get() const;
00281 void set(unsigned char);
00282
00283 private:
00284 unsigned char value;
00285 };
00286
00287 #endif