2 * Copyright (c) 2004-2005 The Regents of The University of Michigan
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 #include "dev/mc146818.hh"
36 #include "base/bitfield.hh"
37 #include "base/time.hh"
38 #include "base/trace.hh"
39 #include "debug/MC146818.hh"
40 #include "dev/rtcreg.h"
49 result
+= (val
/ 10) << 4;
58 result
+= (val
>> 4) * 10;
63 MC146818::setTime(const struct tm time
)
67 // Unix is 0-11 for month, data seet says start at 1
68 mon
= time
.tm_mon
+ 1;
74 // Datasheet says 1 is sunday
75 wday
= time
.tm_wday
+ 1;
78 // The datasheet says that the year field can be either BCD or
79 // years since 1900. Linux seems to be happy with years since
81 year
= bcdize(year
% 100);
90 MC146818::MC146818(EventManager
*em
, const string
&n
, const struct tm time
,
91 bool bcd
, Tick frequency
)
92 : EventManager(em
), _name(n
), event(this, frequency
), tickEvent(this)
94 memset(clock_data
, 0, sizeof(clock_data
));
97 stat_regA
.dv
= RTCA_DV_32768HZ
;
98 stat_regA
.rs
= RTCA_RS_1024HZ
;
102 stat_regB
.format24h
= 1;
103 stat_regB
.dm
= bcd
? 0 : 1;
106 DPRINTFN("Real-time clock set to %s", asctime(&time
));
109 MC146818::~MC146818()
111 deschedule(tickEvent
);
116 MC146818::rega_dv_disabled(const RtcRegA
®
)
118 return reg
.dv
== RTCA_DV_DISABLED0
||
119 reg
.dv
== RTCA_DV_DISABLED1
;
125 assert(!event
.scheduled());
126 assert(!tickEvent
.scheduled());
129 schedule(event
, curTick() + event
.offset
);
130 if (!rega_dv_disabled(stat_regA
))
131 schedule(tickEvent
, curTick() + tickEvent
.offset
);
135 MC146818::writeData(const uint8_t addr
, const uint8_t data
)
137 bool panic_unsupported(false);
139 if (addr
< RTC_STAT_REGA
) {
140 clock_data
[addr
] = data
;
141 curTime
.tm_sec
= unbcdize(sec
);
142 curTime
.tm_min
= unbcdize(min
);
143 curTime
.tm_hour
= unbcdize(hour
);
144 curTime
.tm_mday
= unbcdize(mday
);
145 curTime
.tm_mon
= unbcdize(mon
) - 1;
146 curTime
.tm_year
= ((unbcdize(year
) + 50) % 100) + 1950;
147 curTime
.tm_wday
= unbcdize(wday
) - 1;
150 case RTC_STAT_REGA
: {
151 RtcRegA
old_rega(stat_regA
);
153 // The "update in progress" bit is read only.
154 stat_regA
.uip
= old_rega
;
156 if (!rega_dv_disabled(stat_regA
) &&
157 stat_regA
.dv
!= RTCA_DV_32768HZ
) {
158 inform("RTC: Unimplemented divider configuration: %i\n",
160 panic_unsupported
= true;
163 if (stat_regA
.rs
!= RTCA_RS_1024HZ
) {
164 inform("RTC: Unimplemented interrupt rate: %i\n",
166 panic_unsupported
= true;
169 if (rega_dv_disabled(stat_regA
)) {
170 // The divider is disabled, make sure that we don't
171 // schedule any ticks.
172 if (tickEvent
.scheduled())
173 deschedule(tickEvent
);
174 } else if (rega_dv_disabled(old_rega
)) {
175 // According to the specification, the next tick
176 // happens after 0.5s when the divider chain goes
177 // from reset to active. So, we simply schedule the
179 assert(!tickEvent
.scheduled());
180 schedule(tickEvent
, curTick() + SimClock::Int::s
/ 2);
185 if (stat_regB
.aie
|| stat_regB
.uie
) {
186 inform("RTC: Unimplemented interrupt configuration: %s %s\n",
187 stat_regB
.aie
? "alarm" : "",
188 stat_regB
.uie
? "update" : "");
189 panic_unsupported
= true;
193 inform("RTC: The binary interface is not fully implemented.\n");
194 panic_unsupported
= true;
197 if (!stat_regB
.format24h
) {
198 inform("RTC: The 12h time format not supported.\n");
199 panic_unsupported
= true;
203 inform("RTC: Automatic daylight saving time not supported.\n");
204 panic_unsupported
= true;
208 if (!event
.scheduled())
209 event
.scheduleIntr();
211 if (event
.scheduled())
217 panic("RTC status registers C and D are not implemented.\n");
222 if (panic_unsupported
)
223 panic("Unimplemented RTC configuration!\n");
228 MC146818::readData(uint8_t addr
)
230 if (addr
< RTC_STAT_REGA
)
231 return clock_data
[addr
];
235 // toggle UIP bit for linux
236 stat_regA
.uip
= !stat_regA
.uip
;
247 panic("Shouldn't be here");
253 MC146818::tickClock()
255 assert(!rega_dv_disabled(stat_regA
));
259 time_t calTime
= mkutctime(&curTime
);
261 setTime(*gmtime(&calTime
));
265 MC146818::serialize(const string
&base
, CheckpointOut
&cp
) const
267 uint8_t regA_serial(stat_regA
);
268 uint8_t regB_serial(stat_regB
);
270 arrayParamOut(cp
, base
+ ".clock_data", clock_data
, sizeof(clock_data
));
271 paramOut(cp
, base
+ ".stat_regA", (uint8_t)regA_serial
);
272 paramOut(cp
, base
+ ".stat_regB", (uint8_t)regB_serial
);
275 // save the timer tick and rtc clock tick values to correctly reschedule
276 // them during unserialize
278 Tick rtcTimerInterruptTickOffset
= event
.when() - curTick();
279 SERIALIZE_SCALAR(rtcTimerInterruptTickOffset
);
280 Tick rtcClockTickOffset
= tickEvent
.when() - curTick();
281 SERIALIZE_SCALAR(rtcClockTickOffset
);
285 MC146818::unserialize(const string
&base
, CheckpointIn
&cp
)
289 arrayParamIn(cp
, base
+ ".clock_data", clock_data
,
292 paramIn(cp
, base
+ ".stat_regA", tmp8
);
294 paramIn(cp
, base
+ ".stat_regB", tmp8
);
298 // properly schedule the timer and rtc clock events
300 Tick rtcTimerInterruptTickOffset
;
301 UNSERIALIZE_SCALAR(rtcTimerInterruptTickOffset
);
302 event
.offset
= rtcTimerInterruptTickOffset
;
303 Tick rtcClockTickOffset
;
304 UNSERIALIZE_SCALAR(rtcClockTickOffset
);
305 tickEvent
.offset
= rtcClockTickOffset
;
308 MC146818::RTCEvent::RTCEvent(MC146818
* _parent
, Tick i
)
309 : parent(_parent
), interval(i
), offset(i
)
311 DPRINTF(MC146818
, "RTC Event Initilizing\n");
315 MC146818::RTCEvent::scheduleIntr()
317 parent
->schedule(this, curTick() + interval
);
321 MC146818::RTCEvent::process()
323 DPRINTF(MC146818
, "RTC Timer Interrupt\n");
324 parent
->schedule(this, curTick() + interval
);
325 parent
->handleEvent();
329 MC146818::RTCEvent::description() const
331 return "RTC interrupt";
335 MC146818::RTCTickEvent::process()
337 DPRINTF(MC146818
, "RTC clock tick\n");
338 parent
->schedule(this, curTick() + SimClock::Int::s
);
343 MC146818::RTCTickEvent::description() const
345 return "RTC clock tick";