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 #include "timerprescaler.h"
00027 #include "traceval.h"
00028
00029 HWPrescaler::HWPrescaler(AvrDevice *core, const std::string &tracename):
00030 Hardware(core),
00031 countEnable(true),
00032 _resetBit(-1),
00033 _resetSyncBit(-1)
00034 {
00035 core->AddToCycleList(this);
00036 trace_direct(&(core->coreTraceGroup), "PRESCALER" + tracename, &preScaleValue);
00037 resetRegister = NULL;
00038 }
00039
00040 HWPrescaler::HWPrescaler(AvrDevice *core,
00041 const std::string &tracename,
00042 IOSpecialReg *ioreg,
00043 int resetBit):
00044 Hardware(core),
00045 countEnable(true),
00046 _resetBit(resetBit),
00047 _resetSyncBit(-1)
00048 {
00049 core->AddToCycleList(this);
00050 trace_direct(&(core->coreTraceGroup), "PRESCALER" + tracename, &preScaleValue);
00051 resetRegister = ioreg;
00052 ioreg->connectSRegClient(this);
00053 }
00054
00055 HWPrescaler::HWPrescaler(AvrDevice *core,
00056 const std::string &tracename,
00057 IOSpecialReg *ioreg,
00058 int resetBit,
00059 int resetSyncBit):
00060 Hardware(core),
00061 countEnable(true),
00062 _resetBit(resetBit),
00063 _resetSyncBit(resetSyncBit)
00064 {
00065 core->AddToCycleList(this);
00066 trace_direct(&(core->coreTraceGroup), "PRESCALER" + tracename, &preScaleValue);
00067 resetRegister = ioreg;
00068 ioreg->connectSRegClient(this);
00069 }
00070
00071 unsigned char HWPrescaler::set_from_reg(const IOSpecialReg *reg, unsigned char nv) {
00072
00073 if(reg != resetRegister) return nv;
00074
00075 int reset = (1 << _resetBit) & nv;
00076
00077 int sync = 0;
00078 if(_resetSyncBit >= 0)
00079 sync = (1 << _resetSyncBit) & nv;
00080
00081 if(reset) {
00082 Reset();
00083 if(sync)
00084 countEnable = false;
00085 else {
00086 countEnable = true;
00087 return ~(1 << _resetBit) & nv;
00088 }
00089 }
00090 return nv;
00091 }
00092
00093 HWPrescalerAsync::HWPrescalerAsync(AvrDevice *core,
00094 const std::string &tracename,
00095 PinAtPort tosc,
00096 IOSpecialReg *asyreg,
00097 int clockSelBit,
00098 IOSpecialReg *ioreg,
00099 int resetBit):
00100 HWPrescaler(core, tracename, ioreg, resetBit),
00101 tosc_pin(tosc),
00102 clockSelectBit(clockSelBit)
00103 {
00104 asyncRegister = asyreg;
00105 asyreg->connectSRegClient(this);
00106 pinstate = tosc_pin.GetPin();
00107 clockselect = false;
00108 }
00109
00110 HWPrescalerAsync::HWPrescalerAsync(AvrDevice *core,
00111 const std::string &tracename,
00112 PinAtPort tosc,
00113 IOSpecialReg *asyreg,
00114 int clockSelBit,
00115 IOSpecialReg *ioreg,
00116 int resetBit,
00117 int resetSyncBit):
00118 HWPrescaler(core, tracename, ioreg, resetBit, resetSyncBit),
00119 tosc_pin(tosc),
00120 clockSelectBit(clockSelBit)
00121 {
00122 asyncRegister = asyreg;
00123 asyreg->connectSRegClient(this);
00124 pinstate = tosc_pin.GetPin();
00125 clockselect = false;
00126 }
00127
00128 unsigned int HWPrescalerAsync::CpuCycle() {
00129 bool e = true;
00130 if(clockselect) {
00131 bool ps = tosc_pin.GetPin();
00132 if(pinstate || !ps) e = false;
00133 pinstate = ps;
00134 }
00135 if(e && countEnable) {
00136 preScaleValue++;
00137 if(preScaleValue > 1023) preScaleValue = 0;
00138 }
00139 return 0;
00140 }
00141
00142 unsigned char HWPrescalerAsync::set_from_reg(const IOSpecialReg *reg, unsigned char nv) {
00143 unsigned char v = HWPrescaler::set_from_reg(reg, nv);
00144 if(reg != asyncRegister) return v;
00145 if((1 << clockSelectBit) & v) {
00146 clockselect = true;
00147
00148 } else {
00149 clockselect = false;
00150
00151 }
00152 return v;
00153 }
00154