2 * QEMU MC146818 RTC emulation
4 * Copyright (c) 2003-2004 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu/osdep.h"
25 #include "qemu/cutils.h"
28 #include "qemu/timer.h"
29 #include "sysemu/sysemu.h"
30 #include "sysemu/replay.h"
31 #include "hw/timer/mc146818rtc.h"
32 #include "qapi/visitor.h"
33 #include "qapi-event.h"
34 #include "qmp-commands.h"
37 #include "hw/i386/apic.h"
41 //#define DEBUG_COALESCED
44 # define CMOS_DPRINTF(format, ...) printf(format, ## __VA_ARGS__)
46 # define CMOS_DPRINTF(format, ...) do { } while (0)
49 #ifdef DEBUG_COALESCED
50 # define DPRINTF_C(format, ...) printf(format, ## __VA_ARGS__)
52 # define DPRINTF_C(format, ...) do { } while (0)
55 #define SEC_PER_MIN 60
56 #define MIN_PER_HOUR 60
57 #define SEC_PER_HOUR 3600
58 #define HOUR_PER_DAY 24
59 #define SEC_PER_DAY 86400
61 #define RTC_REINJECT_ON_ACK_COUNT 20
62 #define RTC_CLOCK_RATE 32768
63 #define UIP_HOLD_LENGTH (8 * NANOSECONDS_PER_SECOND / 32768)
65 #define MC146818_RTC(obj) OBJECT_CHECK(RTCState, (obj), TYPE_MC146818_RTC)
67 typedef struct RTCState
{
71 uint8_t cmos_data
[128];
80 QEMUTimer
*periodic_timer
;
81 int64_t next_periodic_time
;
82 /* update-ended timer */
83 QEMUTimer
*update_timer
;
84 uint64_t next_alarm_time
;
85 uint16_t irq_reinject_on_ack_count
;
86 uint32_t irq_coalesced
;
88 QEMUTimer
*coalesced_timer
;
89 Notifier clock_reset_notifier
;
90 LostTickPolicy lost_tick_policy
;
91 Notifier suspend_notifier
;
92 QLIST_ENTRY(RTCState
) link
;
95 static void rtc_set_time(RTCState
*s
);
96 static void rtc_update_time(RTCState
*s
);
97 static void rtc_set_cmos(RTCState
*s
, const struct tm
*tm
);
98 static inline int rtc_from_bcd(RTCState
*s
, int a
);
99 static uint64_t get_next_alarm(RTCState
*s
);
101 static inline bool rtc_running(RTCState
*s
)
103 return (!(s
->cmos_data
[RTC_REG_B
] & REG_B_SET
) &&
104 (s
->cmos_data
[RTC_REG_A
] & 0x70) <= 0x20);
107 static uint64_t get_guest_rtc_ns(RTCState
*s
)
109 uint64_t guest_clock
= qemu_clock_get_ns(rtc_clock
);
111 return s
->base_rtc
* NANOSECONDS_PER_SECOND
+
112 guest_clock
- s
->last_update
+ s
->offset
;
115 static void rtc_coalesced_timer_update(RTCState
*s
)
117 if (s
->irq_coalesced
== 0) {
118 timer_del(s
->coalesced_timer
);
120 /* divide each RTC interval to 2 - 8 smaller intervals */
121 int c
= MIN(s
->irq_coalesced
, 7) + 1;
122 int64_t next_clock
= qemu_clock_get_ns(rtc_clock
) +
123 periodic_clock_to_ns(s
->period
/ c
);
124 timer_mod(s
->coalesced_timer
, next_clock
);
128 static QLIST_HEAD(, RTCState
) rtc_devices
=
129 QLIST_HEAD_INITIALIZER(rtc_devices
);
132 void qmp_rtc_reset_reinjection(Error
**errp
)
136 QLIST_FOREACH(s
, &rtc_devices
, link
) {
137 s
->irq_coalesced
= 0;
141 static bool rtc_policy_slew_deliver_irq(RTCState
*s
)
143 apic_reset_irq_delivered();
144 qemu_irq_raise(s
->irq
);
145 return apic_get_irq_delivered();
148 static void rtc_coalesced_timer(void *opaque
)
150 RTCState
*s
= opaque
;
152 if (s
->irq_coalesced
!= 0) {
153 s
->cmos_data
[RTC_REG_C
] |= 0xc0;
154 DPRINTF_C("cmos: injecting from timer\n");
155 if (rtc_policy_slew_deliver_irq(s
)) {
157 DPRINTF_C("cmos: coalesced irqs decreased to %d\n",
162 rtc_coalesced_timer_update(s
);
165 static bool rtc_policy_slew_deliver_irq(RTCState
*s
)
172 static uint32_t rtc_periodic_clock_ticks(RTCState
*s
)
176 if (!(s
->cmos_data
[RTC_REG_B
] & REG_B_PIE
)) {
180 period_code
= s
->cmos_data
[RTC_REG_A
] & 0x0f;
182 return periodic_period_to_clock(period_code
);
186 * handle periodic timer. @old_period indicates the periodic timer update
187 * is just due to period adjustment.
190 periodic_timer_update(RTCState
*s
, int64_t current_time
, uint32_t old_period
)
193 int64_t cur_clock
, next_irq_clock
, lost_clock
= 0;
195 period
= rtc_periodic_clock_ticks(s
);
198 /* compute 32 khz clock */
200 muldiv64(current_time
, RTC_CLOCK_RATE
, NANOSECONDS_PER_SECOND
);
203 * if the periodic timer's update is due to period re-configuration,
204 * we should count the clock since last interrupt.
207 int64_t last_periodic_clock
, next_periodic_clock
;
209 next_periodic_clock
= muldiv64(s
->next_periodic_time
,
210 RTC_CLOCK_RATE
, NANOSECONDS_PER_SECOND
);
211 last_periodic_clock
= next_periodic_clock
- old_period
;
212 lost_clock
= cur_clock
- last_periodic_clock
;
213 assert(lost_clock
>= 0);
217 * s->irq_coalesced can change for two reasons:
219 * a) if one or more periodic timer interrupts have been lost,
220 * lost_clock will be more that a period.
222 * b) when the period may be reconfigured, we expect the OS to
223 * treat delayed tick as the new period. So, when switching
224 * from a shorter to a longer period, scale down the missing,
225 * because the OS will treat past delayed ticks as longer
226 * (leftovers are put back into lost_clock). When switching
227 * to a shorter period, scale up the missing ticks since the
228 * OS handler will treat past delayed ticks as shorter.
230 if (s
->lost_tick_policy
== LOST_TICK_POLICY_SLEW
) {
231 uint32_t old_irq_coalesced
= s
->irq_coalesced
;
234 lost_clock
+= old_irq_coalesced
* old_period
;
235 s
->irq_coalesced
= lost_clock
/ s
->period
;
236 lost_clock
%= s
->period
;
237 if (old_irq_coalesced
!= s
->irq_coalesced
||
238 old_period
!= s
->period
) {
239 DPRINTF_C("cmos: coalesced irqs scaled from %d to %d, "
240 "period scaled from %d to %d\n", old_irq_coalesced
,
241 s
->irq_coalesced
, old_period
, s
->period
);
242 rtc_coalesced_timer_update(s
);
246 * no way to compensate the interrupt if LOST_TICK_POLICY_SLEW
247 * is not used, we should make the time progress anyway.
249 lost_clock
= MIN(lost_clock
, period
);
252 assert(lost_clock
>= 0 && lost_clock
<= period
);
254 next_irq_clock
= cur_clock
+ period
- lost_clock
;
255 s
->next_periodic_time
= periodic_clock_to_ns(next_irq_clock
) + 1;
256 timer_mod(s
->periodic_timer
, s
->next_periodic_time
);
258 s
->irq_coalesced
= 0;
259 timer_del(s
->periodic_timer
);
263 static void rtc_periodic_timer(void *opaque
)
265 RTCState
*s
= opaque
;
267 periodic_timer_update(s
, s
->next_periodic_time
, 0);
268 s
->cmos_data
[RTC_REG_C
] |= REG_C_PF
;
269 if (s
->cmos_data
[RTC_REG_B
] & REG_B_PIE
) {
270 s
->cmos_data
[RTC_REG_C
] |= REG_C_IRQF
;
271 if (s
->lost_tick_policy
== LOST_TICK_POLICY_SLEW
) {
272 if (s
->irq_reinject_on_ack_count
>= RTC_REINJECT_ON_ACK_COUNT
)
273 s
->irq_reinject_on_ack_count
= 0;
274 if (!rtc_policy_slew_deliver_irq(s
)) {
276 rtc_coalesced_timer_update(s
);
277 DPRINTF_C("cmos: coalesced irqs increased to %d\n",
281 qemu_irq_raise(s
->irq
);
285 /* handle update-ended timer */
286 static void check_update_timer(RTCState
*s
)
288 uint64_t next_update_time
;
292 /* From the data sheet: "Holding the dividers in reset prevents
293 * interrupts from operating, while setting the SET bit allows"
294 * them to occur. However, it will prevent an alarm interrupt
295 * from occurring, because the time of day is not updated.
297 if ((s
->cmos_data
[RTC_REG_A
] & 0x60) == 0x60) {
298 timer_del(s
->update_timer
);
301 if ((s
->cmos_data
[RTC_REG_C
] & REG_C_UF
) &&
302 (s
->cmos_data
[RTC_REG_B
] & REG_B_SET
)) {
303 timer_del(s
->update_timer
);
306 if ((s
->cmos_data
[RTC_REG_C
] & REG_C_UF
) &&
307 (s
->cmos_data
[RTC_REG_C
] & REG_C_AF
)) {
308 timer_del(s
->update_timer
);
312 guest_nsec
= get_guest_rtc_ns(s
) % NANOSECONDS_PER_SECOND
;
313 /* if UF is clear, reprogram to next second */
314 next_update_time
= qemu_clock_get_ns(rtc_clock
)
315 + NANOSECONDS_PER_SECOND
- guest_nsec
;
317 /* Compute time of next alarm. One second is already accounted
318 * for in next_update_time.
320 next_alarm_sec
= get_next_alarm(s
);
321 s
->next_alarm_time
= next_update_time
+
322 (next_alarm_sec
- 1) * NANOSECONDS_PER_SECOND
;
324 if (s
->cmos_data
[RTC_REG_C
] & REG_C_UF
) {
325 /* UF is set, but AF is clear. Program the timer to target
327 next_update_time
= s
->next_alarm_time
;
329 if (next_update_time
!= timer_expire_time_ns(s
->update_timer
)) {
330 timer_mod(s
->update_timer
, next_update_time
);
334 static inline uint8_t convert_hour(RTCState
*s
, uint8_t hour
)
336 if (!(s
->cmos_data
[RTC_REG_B
] & REG_B_24H
)) {
338 if (s
->cmos_data
[RTC_HOURS
] & 0x80) {
345 static uint64_t get_next_alarm(RTCState
*s
)
347 int32_t alarm_sec
, alarm_min
, alarm_hour
, cur_hour
, cur_min
, cur_sec
;
348 int32_t hour
, min
, sec
;
352 alarm_sec
= rtc_from_bcd(s
, s
->cmos_data
[RTC_SECONDS_ALARM
]);
353 alarm_min
= rtc_from_bcd(s
, s
->cmos_data
[RTC_MINUTES_ALARM
]);
354 alarm_hour
= rtc_from_bcd(s
, s
->cmos_data
[RTC_HOURS_ALARM
]);
355 alarm_hour
= alarm_hour
== -1 ? -1 : convert_hour(s
, alarm_hour
);
357 cur_sec
= rtc_from_bcd(s
, s
->cmos_data
[RTC_SECONDS
]);
358 cur_min
= rtc_from_bcd(s
, s
->cmos_data
[RTC_MINUTES
]);
359 cur_hour
= rtc_from_bcd(s
, s
->cmos_data
[RTC_HOURS
]);
360 cur_hour
= convert_hour(s
, cur_hour
);
362 if (alarm_hour
== -1) {
363 alarm_hour
= cur_hour
;
364 if (alarm_min
== -1) {
366 if (alarm_sec
== -1) {
367 alarm_sec
= cur_sec
+ 1;
368 } else if (cur_sec
> alarm_sec
) {
371 } else if (cur_min
== alarm_min
) {
372 if (alarm_sec
== -1) {
373 alarm_sec
= cur_sec
+ 1;
375 if (cur_sec
> alarm_sec
) {
379 if (alarm_sec
== SEC_PER_MIN
) {
380 /* wrap to next hour, minutes is not in don't care mode */
384 } else if (cur_min
> alarm_min
) {
387 } else if (cur_hour
== alarm_hour
) {
388 if (alarm_min
== -1) {
390 if (alarm_sec
== -1) {
391 alarm_sec
= cur_sec
+ 1;
392 } else if (cur_sec
> alarm_sec
) {
396 if (alarm_sec
== SEC_PER_MIN
) {
400 /* wrap to next day, hour is not in don't care mode */
401 alarm_min
%= MIN_PER_HOUR
;
402 } else if (cur_min
== alarm_min
) {
403 if (alarm_sec
== -1) {
404 alarm_sec
= cur_sec
+ 1;
406 /* wrap to next day, hours+minutes not in don't care mode */
407 alarm_sec
%= SEC_PER_MIN
;
411 /* values that are still don't care fire at the next min/sec */
412 if (alarm_min
== -1) {
415 if (alarm_sec
== -1) {
419 /* keep values in range */
420 if (alarm_sec
== SEC_PER_MIN
) {
424 if (alarm_min
== MIN_PER_HOUR
) {
428 alarm_hour
%= HOUR_PER_DAY
;
430 hour
= alarm_hour
- cur_hour
;
431 min
= hour
* MIN_PER_HOUR
+ alarm_min
- cur_min
;
432 sec
= min
* SEC_PER_MIN
+ alarm_sec
- cur_sec
;
433 return sec
<= 0 ? sec
+ SEC_PER_DAY
: sec
;
436 static void rtc_update_timer(void *opaque
)
438 RTCState
*s
= opaque
;
439 int32_t irqs
= REG_C_UF
;
442 assert((s
->cmos_data
[RTC_REG_A
] & 0x60) != 0x60);
444 /* UIP might have been latched, update time and clear it. */
446 s
->cmos_data
[RTC_REG_A
] &= ~REG_A_UIP
;
448 if (qemu_clock_get_ns(rtc_clock
) >= s
->next_alarm_time
) {
450 if (s
->cmos_data
[RTC_REG_B
] & REG_B_AIE
) {
451 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_RTC
);
455 new_irqs
= irqs
& ~s
->cmos_data
[RTC_REG_C
];
456 s
->cmos_data
[RTC_REG_C
] |= irqs
;
457 if ((new_irqs
& s
->cmos_data
[RTC_REG_B
]) != 0) {
458 s
->cmos_data
[RTC_REG_C
] |= REG_C_IRQF
;
459 qemu_irq_raise(s
->irq
);
461 check_update_timer(s
);
464 static void cmos_ioport_write(void *opaque
, hwaddr addr
,
465 uint64_t data
, unsigned size
)
467 RTCState
*s
= opaque
;
469 bool update_periodic_timer
;
471 if ((addr
& 1) == 0) {
472 s
->cmos_index
= data
& 0x7f;
474 CMOS_DPRINTF("cmos: write index=0x%02x val=0x%02" PRIx64
"\n",
475 s
->cmos_index
, data
);
476 switch(s
->cmos_index
) {
477 case RTC_SECONDS_ALARM
:
478 case RTC_MINUTES_ALARM
:
479 case RTC_HOURS_ALARM
:
480 s
->cmos_data
[s
->cmos_index
] = data
;
481 check_update_timer(s
);
483 case RTC_IBM_PS2_CENTURY_BYTE
:
484 s
->cmos_index
= RTC_CENTURY
;
490 case RTC_DAY_OF_WEEK
:
491 case RTC_DAY_OF_MONTH
:
494 s
->cmos_data
[s
->cmos_index
] = data
;
495 /* if in set mode, do not update the time */
496 if (rtc_running(s
)) {
498 check_update_timer(s
);
502 update_periodic_timer
= (s
->cmos_data
[RTC_REG_A
] ^ data
) & 0x0f;
503 old_period
= rtc_periodic_clock_ticks(s
);
505 if ((data
& 0x60) == 0x60) {
506 if (rtc_running(s
)) {
509 /* What happens to UIP when divider reset is enabled is
510 * unclear from the datasheet. Shouldn't matter much
513 s
->cmos_data
[RTC_REG_A
] &= ~REG_A_UIP
;
514 } else if (((s
->cmos_data
[RTC_REG_A
] & 0x60) == 0x60) &&
515 (data
& 0x70) <= 0x20) {
516 /* when the divider reset is removed, the first update cycle
517 * begins one-half second later*/
518 if (!(s
->cmos_data
[RTC_REG_B
] & REG_B_SET
)) {
519 s
->offset
= 500000000;
522 s
->cmos_data
[RTC_REG_A
] &= ~REG_A_UIP
;
524 /* UIP bit is read only */
525 s
->cmos_data
[RTC_REG_A
] = (data
& ~REG_A_UIP
) |
526 (s
->cmos_data
[RTC_REG_A
] & REG_A_UIP
);
528 if (update_periodic_timer
) {
529 periodic_timer_update(s
, qemu_clock_get_ns(rtc_clock
),
533 check_update_timer(s
);
536 update_periodic_timer
= (s
->cmos_data
[RTC_REG_B
] ^ data
)
538 old_period
= rtc_periodic_clock_ticks(s
);
540 if (data
& REG_B_SET
) {
541 /* update cmos to when the rtc was stopping */
542 if (rtc_running(s
)) {
545 /* set mode: reset UIP mode */
546 s
->cmos_data
[RTC_REG_A
] &= ~REG_A_UIP
;
549 /* if disabling set mode, update the time */
550 if ((s
->cmos_data
[RTC_REG_B
] & REG_B_SET
) &&
551 (s
->cmos_data
[RTC_REG_A
] & 0x70) <= 0x20) {
552 s
->offset
= get_guest_rtc_ns(s
) % NANOSECONDS_PER_SECOND
;
556 /* if an interrupt flag is already set when the interrupt
557 * becomes enabled, raise an interrupt immediately. */
558 if (data
& s
->cmos_data
[RTC_REG_C
] & REG_C_MASK
) {
559 s
->cmos_data
[RTC_REG_C
] |= REG_C_IRQF
;
560 qemu_irq_raise(s
->irq
);
562 s
->cmos_data
[RTC_REG_C
] &= ~REG_C_IRQF
;
563 qemu_irq_lower(s
->irq
);
565 s
->cmos_data
[RTC_REG_B
] = data
;
567 if (update_periodic_timer
) {
568 periodic_timer_update(s
, qemu_clock_get_ns(rtc_clock
),
572 check_update_timer(s
);
576 /* cannot write to them */
579 s
->cmos_data
[s
->cmos_index
] = data
;
585 static inline int rtc_to_bcd(RTCState
*s
, int a
)
587 if (s
->cmos_data
[RTC_REG_B
] & REG_B_DM
) {
590 return ((a
/ 10) << 4) | (a
% 10);
594 static inline int rtc_from_bcd(RTCState
*s
, int a
)
596 if ((a
& 0xc0) == 0xc0) {
599 if (s
->cmos_data
[RTC_REG_B
] & REG_B_DM
) {
602 return ((a
>> 4) * 10) + (a
& 0x0f);
606 static void rtc_get_time(RTCState
*s
, struct tm
*tm
)
608 tm
->tm_sec
= rtc_from_bcd(s
, s
->cmos_data
[RTC_SECONDS
]);
609 tm
->tm_min
= rtc_from_bcd(s
, s
->cmos_data
[RTC_MINUTES
]);
610 tm
->tm_hour
= rtc_from_bcd(s
, s
->cmos_data
[RTC_HOURS
] & 0x7f);
611 if (!(s
->cmos_data
[RTC_REG_B
] & REG_B_24H
)) {
613 if (s
->cmos_data
[RTC_HOURS
] & 0x80) {
617 tm
->tm_wday
= rtc_from_bcd(s
, s
->cmos_data
[RTC_DAY_OF_WEEK
]) - 1;
618 tm
->tm_mday
= rtc_from_bcd(s
, s
->cmos_data
[RTC_DAY_OF_MONTH
]);
619 tm
->tm_mon
= rtc_from_bcd(s
, s
->cmos_data
[RTC_MONTH
]) - 1;
621 rtc_from_bcd(s
, s
->cmos_data
[RTC_YEAR
]) + s
->base_year
+
622 rtc_from_bcd(s
, s
->cmos_data
[RTC_CENTURY
]) * 100 - 1900;
625 static void rtc_set_time(RTCState
*s
)
629 rtc_get_time(s
, &tm
);
630 s
->base_rtc
= mktimegm(&tm
);
631 s
->last_update
= qemu_clock_get_ns(rtc_clock
);
633 qapi_event_send_rtc_change(qemu_timedate_diff(&tm
), &error_abort
);
636 static void rtc_set_cmos(RTCState
*s
, const struct tm
*tm
)
640 s
->cmos_data
[RTC_SECONDS
] = rtc_to_bcd(s
, tm
->tm_sec
);
641 s
->cmos_data
[RTC_MINUTES
] = rtc_to_bcd(s
, tm
->tm_min
);
642 if (s
->cmos_data
[RTC_REG_B
] & REG_B_24H
) {
644 s
->cmos_data
[RTC_HOURS
] = rtc_to_bcd(s
, tm
->tm_hour
);
647 int h
= (tm
->tm_hour
% 12) ? tm
->tm_hour
% 12 : 12;
648 s
->cmos_data
[RTC_HOURS
] = rtc_to_bcd(s
, h
);
649 if (tm
->tm_hour
>= 12)
650 s
->cmos_data
[RTC_HOURS
] |= 0x80;
652 s
->cmos_data
[RTC_DAY_OF_WEEK
] = rtc_to_bcd(s
, tm
->tm_wday
+ 1);
653 s
->cmos_data
[RTC_DAY_OF_MONTH
] = rtc_to_bcd(s
, tm
->tm_mday
);
654 s
->cmos_data
[RTC_MONTH
] = rtc_to_bcd(s
, tm
->tm_mon
+ 1);
655 year
= tm
->tm_year
+ 1900 - s
->base_year
;
656 s
->cmos_data
[RTC_YEAR
] = rtc_to_bcd(s
, year
% 100);
657 s
->cmos_data
[RTC_CENTURY
] = rtc_to_bcd(s
, year
/ 100);
660 static void rtc_update_time(RTCState
*s
)
666 guest_nsec
= get_guest_rtc_ns(s
);
667 guest_sec
= guest_nsec
/ NANOSECONDS_PER_SECOND
;
668 gmtime_r(&guest_sec
, &ret
);
670 /* Is SET flag of Register B disabled? */
671 if ((s
->cmos_data
[RTC_REG_B
] & REG_B_SET
) == 0) {
672 rtc_set_cmos(s
, &ret
);
676 static int update_in_progress(RTCState
*s
)
680 if (!rtc_running(s
)) {
683 if (timer_pending(s
->update_timer
)) {
684 int64_t next_update_time
= timer_expire_time_ns(s
->update_timer
);
685 /* Latch UIP until the timer expires. */
686 if (qemu_clock_get_ns(rtc_clock
) >=
687 (next_update_time
- UIP_HOLD_LENGTH
)) {
688 s
->cmos_data
[RTC_REG_A
] |= REG_A_UIP
;
693 guest_nsec
= get_guest_rtc_ns(s
);
694 /* UIP bit will be set at last 244us of every second. */
695 if ((guest_nsec
% NANOSECONDS_PER_SECOND
) >=
696 (NANOSECONDS_PER_SECOND
- UIP_HOLD_LENGTH
)) {
702 static uint64_t cmos_ioport_read(void *opaque
, hwaddr addr
,
705 RTCState
*s
= opaque
;
707 if ((addr
& 1) == 0) {
710 switch(s
->cmos_index
) {
711 case RTC_IBM_PS2_CENTURY_BYTE
:
712 s
->cmos_index
= RTC_CENTURY
;
718 case RTC_DAY_OF_WEEK
:
719 case RTC_DAY_OF_MONTH
:
722 /* if not in set mode, calibrate cmos before
724 if (rtc_running(s
)) {
727 ret
= s
->cmos_data
[s
->cmos_index
];
730 if (update_in_progress(s
)) {
731 s
->cmos_data
[s
->cmos_index
] |= REG_A_UIP
;
733 s
->cmos_data
[s
->cmos_index
] &= ~REG_A_UIP
;
735 ret
= s
->cmos_data
[s
->cmos_index
];
738 ret
= s
->cmos_data
[s
->cmos_index
];
739 qemu_irq_lower(s
->irq
);
740 s
->cmos_data
[RTC_REG_C
] = 0x00;
741 if (ret
& (REG_C_UF
| REG_C_AF
)) {
742 check_update_timer(s
);
745 if(s
->irq_coalesced
&&
746 (s
->cmos_data
[RTC_REG_B
] & REG_B_PIE
) &&
747 s
->irq_reinject_on_ack_count
< RTC_REINJECT_ON_ACK_COUNT
) {
748 s
->irq_reinject_on_ack_count
++;
749 s
->cmos_data
[RTC_REG_C
] |= REG_C_IRQF
| REG_C_PF
;
750 DPRINTF_C("cmos: injecting on ack\n");
751 if (rtc_policy_slew_deliver_irq(s
)) {
753 DPRINTF_C("cmos: coalesced irqs decreased to %d\n",
759 ret
= s
->cmos_data
[s
->cmos_index
];
762 CMOS_DPRINTF("cmos: read index=0x%02x val=0x%02x\n",
768 void rtc_set_memory(ISADevice
*dev
, int addr
, int val
)
770 RTCState
*s
= MC146818_RTC(dev
);
771 if (addr
>= 0 && addr
<= 127)
772 s
->cmos_data
[addr
] = val
;
775 int rtc_get_memory(ISADevice
*dev
, int addr
)
777 RTCState
*s
= MC146818_RTC(dev
);
778 assert(addr
>= 0 && addr
<= 127);
779 return s
->cmos_data
[addr
];
782 static void rtc_set_date_from_host(ISADevice
*dev
)
784 RTCState
*s
= MC146818_RTC(dev
);
787 qemu_get_timedate(&tm
, 0);
789 s
->base_rtc
= mktimegm(&tm
);
790 s
->last_update
= qemu_clock_get_ns(rtc_clock
);
793 /* set the CMOS date */
794 rtc_set_cmos(s
, &tm
);
797 static void rtc_pre_save(void *opaque
)
799 RTCState
*s
= opaque
;
804 static int rtc_post_load(void *opaque
, int version_id
)
806 RTCState
*s
= opaque
;
808 if (version_id
<= 2 || rtc_clock
== QEMU_CLOCK_REALTIME
) {
811 check_update_timer(s
);
814 /* The periodic timer is deterministic in record/replay mode,
815 * so there is no need to update it after loading the vmstate.
816 * Reading RTC here would misalign record and replay.
818 if (replay_mode
== REPLAY_MODE_NONE
) {
819 uint64_t now
= qemu_clock_get_ns(rtc_clock
);
820 if (now
< s
->next_periodic_time
||
821 now
> (s
->next_periodic_time
+ get_max_clock_jump())) {
822 periodic_timer_update(s
, qemu_clock_get_ns(rtc_clock
), 0);
826 if (version_id
>= 2) {
827 if (s
->lost_tick_policy
== LOST_TICK_POLICY_SLEW
) {
828 rtc_coalesced_timer_update(s
);
834 static bool rtc_irq_reinject_on_ack_count_needed(void *opaque
)
836 RTCState
*s
= (RTCState
*)opaque
;
837 return s
->irq_reinject_on_ack_count
!= 0;
840 static const VMStateDescription vmstate_rtc_irq_reinject_on_ack_count
= {
841 .name
= "mc146818rtc/irq_reinject_on_ack_count",
843 .minimum_version_id
= 1,
844 .needed
= rtc_irq_reinject_on_ack_count_needed
,
845 .fields
= (VMStateField
[]) {
846 VMSTATE_UINT16(irq_reinject_on_ack_count
, RTCState
),
847 VMSTATE_END_OF_LIST()
851 static const VMStateDescription vmstate_rtc
= {
852 .name
= "mc146818rtc",
854 .minimum_version_id
= 1,
855 .pre_save
= rtc_pre_save
,
856 .post_load
= rtc_post_load
,
857 .fields
= (VMStateField
[]) {
858 VMSTATE_BUFFER(cmos_data
, RTCState
),
859 VMSTATE_UINT8(cmos_index
, RTCState
),
861 VMSTATE_TIMER_PTR(periodic_timer
, RTCState
),
862 VMSTATE_INT64(next_periodic_time
, RTCState
),
864 VMSTATE_UINT32_V(irq_coalesced
, RTCState
, 2),
865 VMSTATE_UINT32_V(period
, RTCState
, 2),
866 VMSTATE_UINT64_V(base_rtc
, RTCState
, 3),
867 VMSTATE_UINT64_V(last_update
, RTCState
, 3),
868 VMSTATE_INT64_V(offset
, RTCState
, 3),
869 VMSTATE_TIMER_PTR_V(update_timer
, RTCState
, 3),
870 VMSTATE_UINT64_V(next_alarm_time
, RTCState
, 3),
871 VMSTATE_END_OF_LIST()
873 .subsections
= (const VMStateDescription
*[]) {
874 &vmstate_rtc_irq_reinject_on_ack_count
,
879 static void rtc_notify_clock_reset(Notifier
*notifier
, void *data
)
881 RTCState
*s
= container_of(notifier
, RTCState
, clock_reset_notifier
);
882 int64_t now
= *(int64_t *)data
;
884 rtc_set_date_from_host(ISA_DEVICE(s
));
885 periodic_timer_update(s
, now
, 0);
886 check_update_timer(s
);
888 if (s
->lost_tick_policy
== LOST_TICK_POLICY_SLEW
) {
889 rtc_coalesced_timer_update(s
);
893 /* set CMOS shutdown status register (index 0xF) as S3_resume(0xFE)
894 BIOS will read it and start S3 resume at POST Entry */
895 static void rtc_notify_suspend(Notifier
*notifier
, void *data
)
897 RTCState
*s
= container_of(notifier
, RTCState
, suspend_notifier
);
898 rtc_set_memory(ISA_DEVICE(s
), 0xF, 0xFE);
901 static void rtc_reset(void *opaque
)
903 RTCState
*s
= opaque
;
905 s
->cmos_data
[RTC_REG_B
] &= ~(REG_B_PIE
| REG_B_AIE
| REG_B_SQWE
);
906 s
->cmos_data
[RTC_REG_C
] &= ~(REG_C_UF
| REG_C_IRQF
| REG_C_PF
| REG_C_AF
);
907 check_update_timer(s
);
909 qemu_irq_lower(s
->irq
);
911 if (s
->lost_tick_policy
== LOST_TICK_POLICY_SLEW
) {
912 s
->irq_coalesced
= 0;
913 s
->irq_reinject_on_ack_count
= 0;
917 static const MemoryRegionOps cmos_ops
= {
918 .read
= cmos_ioport_read
,
919 .write
= cmos_ioport_write
,
921 .min_access_size
= 1,
922 .max_access_size
= 1,
924 .endianness
= DEVICE_LITTLE_ENDIAN
,
927 static void rtc_get_date(Object
*obj
, struct tm
*current_tm
, Error
**errp
)
929 RTCState
*s
= MC146818_RTC(obj
);
932 rtc_get_time(s
, current_tm
);
935 static void rtc_realizefn(DeviceState
*dev
, Error
**errp
)
937 ISADevice
*isadev
= ISA_DEVICE(dev
);
938 RTCState
*s
= MC146818_RTC(dev
);
941 s
->cmos_data
[RTC_REG_A
] = 0x26;
942 s
->cmos_data
[RTC_REG_B
] = 0x02;
943 s
->cmos_data
[RTC_REG_C
] = 0x00;
944 s
->cmos_data
[RTC_REG_D
] = 0x80;
946 /* This is for historical reasons. The default base year qdev property
947 * was set to 2000 for most machine types before the century byte was
950 * This if statement means that the century byte will be always 0
951 * (at least until 2079...) for base_year = 1980, but will be set
952 * correctly for base_year = 2000.
954 if (s
->base_year
== 2000) {
958 rtc_set_date_from_host(isadev
);
960 switch (s
->lost_tick_policy
) {
962 case LOST_TICK_POLICY_SLEW
:
964 timer_new_ns(rtc_clock
, rtc_coalesced_timer
, s
);
967 case LOST_TICK_POLICY_DISCARD
:
970 error_setg(errp
, "Invalid lost tick policy.");
974 s
->periodic_timer
= timer_new_ns(rtc_clock
, rtc_periodic_timer
, s
);
975 s
->update_timer
= timer_new_ns(rtc_clock
, rtc_update_timer
, s
);
976 check_update_timer(s
);
978 s
->clock_reset_notifier
.notify
= rtc_notify_clock_reset
;
979 qemu_clock_register_reset_notifier(rtc_clock
,
980 &s
->clock_reset_notifier
);
982 s
->suspend_notifier
.notify
= rtc_notify_suspend
;
983 qemu_register_suspend_notifier(&s
->suspend_notifier
);
985 memory_region_init_io(&s
->io
, OBJECT(s
), &cmos_ops
, s
, "rtc", 2);
986 isa_register_ioport(isadev
, &s
->io
, base
);
988 qdev_set_legacy_instance_id(dev
, base
, 3);
989 qemu_register_reset(rtc_reset
, s
);
991 object_property_add_tm(OBJECT(s
), "date", rtc_get_date
, NULL
);
993 object_property_add_alias(qdev_get_machine(), "rtc-time",
994 OBJECT(s
), "date", NULL
);
996 qdev_init_gpio_out(dev
, &s
->irq
, 1);
999 ISADevice
*rtc_init(ISABus
*bus
, int base_year
, qemu_irq intercept_irq
)
1005 isadev
= isa_create(bus
, TYPE_MC146818_RTC
);
1006 dev
= DEVICE(isadev
);
1007 s
= MC146818_RTC(isadev
);
1008 qdev_prop_set_int32(dev
, "base_year", base_year
);
1009 qdev_init_nofail(dev
);
1010 if (intercept_irq
) {
1011 qdev_connect_gpio_out(dev
, 0, intercept_irq
);
1013 isa_connect_gpio_out(isadev
, 0, RTC_ISA_IRQ
);
1015 QLIST_INSERT_HEAD(&rtc_devices
, s
, link
);
1020 static Property mc146818rtc_properties
[] = {
1021 DEFINE_PROP_INT32("base_year", RTCState
, base_year
, 1980),
1022 DEFINE_PROP_LOSTTICKPOLICY("lost_tick_policy", RTCState
,
1023 lost_tick_policy
, LOST_TICK_POLICY_DISCARD
),
1024 DEFINE_PROP_END_OF_LIST(),
1027 static void rtc_resetdev(DeviceState
*d
)
1029 RTCState
*s
= MC146818_RTC(d
);
1031 /* Reason: VM do suspend self will set 0xfe
1032 * Reset any values other than 0xfe(Guest suspend case) */
1033 if (s
->cmos_data
[0x0f] != 0xfe) {
1034 s
->cmos_data
[0x0f] = 0x00;
1038 static void rtc_class_initfn(ObjectClass
*klass
, void *data
)
1040 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1042 dc
->realize
= rtc_realizefn
;
1043 dc
->reset
= rtc_resetdev
;
1044 dc
->vmsd
= &vmstate_rtc
;
1045 dc
->props
= mc146818rtc_properties
;
1046 /* Reason: needs to be wired up by rtc_init() */
1047 dc
->user_creatable
= false;
1050 static void rtc_finalize(Object
*obj
)
1052 object_property_del(qdev_get_machine(), "rtc", NULL
);
1055 static const TypeInfo mc146818rtc_info
= {
1056 .name
= TYPE_MC146818_RTC
,
1057 .parent
= TYPE_ISA_DEVICE
,
1058 .instance_size
= sizeof(RTCState
),
1059 .class_init
= rtc_class_initfn
,
1060 .instance_finalize
= rtc_finalize
,
1063 static void mc146818rtc_register_types(void)
1065 type_register_static(&mc146818rtc_info
);
1068 type_init(mc146818rtc_register_types
)