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
00028
00029
00030
00031
00032 #include "avrerror.h"
00033 #include "traceval.h"
00034 #include "avrdevice.h"
00035 #include "helper.h"
00036 #include "rwmem.h"
00037
00038 using namespace std;
00039
00040 RWMemoryMember::RWMemoryMember(TraceValueRegister *_reg,
00041 const std::string &tracename,
00042 const int index):
00043 registry(_reg)
00044 {
00045 if (tracename.size()) {
00046 tv = new TraceValue(8, registry->GetTraceValuePrefix() + tracename, index);
00047 if (!registry) {
00048 avr_error("registry not initialized for RWMemoryMember '%s'.", tracename.c_str());
00049 }
00050 registry->RegisterTraceValue(tv);
00051 } else {
00052 tv=0;
00053 }
00054 }
00055
00056 RWMemoryMember::RWMemoryMember(void):
00057 registry(NULL),
00058 tv(NULL) {}
00059
00060 RWMemoryMember::operator unsigned char() const {
00061 if (tv)
00062 tv->read();
00063 return get();
00064 }
00065
00066 unsigned char RWMemoryMember::operator=(unsigned char val) {
00067 set(val);
00068 if (tv)
00069 tv->write(val);
00070 return val;
00071 }
00072
00073 unsigned char RWMemoryMember::operator=(const RWMemoryMember &mm) {
00074 if (mm.tv)
00075 mm.tv->read();
00076 unsigned char v=mm.get();
00077 set(v);
00078 if (tv)
00079 tv->write(v);
00080 return v;
00081 }
00082
00083
00084 RWMemoryMember::~RWMemoryMember() {
00085 if (tv)
00086 delete tv;
00087 }
00088
00089 RAM::RAM(TraceValueCoreRegister *_reg, const std::string &name, const size_t number, const size_t maxsize) {
00090 corereg = _reg;
00091 if(name.size()) {
00092 tv = new TraceValue(8, corereg->GetTraceValuePrefix() + name, number);
00093 if(!corereg) {
00094 avr_error("registry not initialized for RWMemoryMember '%s'.", name.c_str());
00095 }
00096 corereg->RegisterTraceSetValue(tv, name, maxsize);
00097 } else {
00098 tv = NULL;
00099 }
00100 }
00101
00102 unsigned char RAM::get() const { return value; }
00103
00104 void RAM::set(unsigned char v) { value=v; }
00105
00106 InvalidMem::InvalidMem(AvrDevice* _c, int _a):
00107 RWMemoryMember(),
00108 core(_c),
00109 addr(_a) {}
00110
00111 unsigned char InvalidMem::get() const {
00112 string s = "Invalid read access from IO[0x" + int2hex(addr) + "], PC=0x" + int2hex(core->PC * 2);
00113 if(core->abortOnInvalidAccess)
00114 avr_error(s.c_str());
00115 avr_warning(s.c_str());
00116 return 0;
00117 }
00118
00119 void InvalidMem::set(unsigned char c) {
00120 string s = "Invalid write access to IO[0x" + int2hex(addr) +
00121 "]=0x" + int2hex(c) + ", PC=0x" + int2hex(core->PC * 2);
00122 if(core->abortOnInvalidAccess)
00123 avr_error(s.c_str());
00124 avr_warning(s.c_str());
00125 }
00126
00127 NotSimulatedRegister::NotSimulatedRegister(const char * message_on_access_)
00128 : message_on_access(message_on_access_) {}
00129
00130 unsigned char NotSimulatedRegister::get() const {
00131 avr_warning(message_on_access);
00132 return 0;
00133 }
00134
00135 void NotSimulatedRegister::set(unsigned char c) {
00136 avr_warning(message_on_access);
00137 }
00138
00139
00140
00141 IOSpecialReg::IOSpecialReg(TraceValueRegister *registry, const std::string &name):
00142 RWMemoryMember(registry, name)
00143 {
00144 Reset();
00145 }
00146
00147 unsigned char IOSpecialReg::get() const {
00148 unsigned char val = value;
00149 for(size_t i = 0; i < clients.size(); i++)
00150 val = clients[i]->get_from_client(this, val);
00151 return val;
00152 }
00153
00154 void IOSpecialReg::set(unsigned char val) {
00155 for(size_t i = 0; i < clients.size(); i++)
00156 val = clients[i]->set_from_reg(this, val);
00157 value = val;
00158 }
00159