2004-03-14 13:20:30 +01:00
|
|
|
/*
|
|
|
|
* QEMU MC146818 RTC emulation
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2004-03-14 13:20:30 +01:00
|
|
|
* Copyright (c) 2003-2004 Fabrice Bellard
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2004-03-14 13:20:30 +01:00
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
2013-02-04 15:40:22 +01:00
|
|
|
#include "hw/hw.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/timer.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/sysemu.h"
|
2013-02-05 17:06:20 +01:00
|
|
|
#include "hw/timer/mc146818rtc.h"
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/visitor.h"
|
2004-03-14 13:20:30 +01:00
|
|
|
|
2012-02-17 18:31:17 +01:00
|
|
|
#ifdef TARGET_I386
|
2013-02-05 17:06:20 +01:00
|
|
|
#include "hw/i386/apic.h"
|
2012-02-17 18:31:17 +01:00
|
|
|
#endif
|
|
|
|
|
2004-03-14 13:20:30 +01:00
|
|
|
//#define DEBUG_CMOS
|
2010-05-30 21:20:07 +02:00
|
|
|
//#define DEBUG_COALESCED
|
2004-03-14 13:20:30 +01:00
|
|
|
|
2010-05-14 09:29:24 +02:00
|
|
|
#ifdef DEBUG_CMOS
|
|
|
|
# define CMOS_DPRINTF(format, ...) printf(format, ## __VA_ARGS__)
|
|
|
|
#else
|
|
|
|
# define CMOS_DPRINTF(format, ...) do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
2010-05-30 21:20:07 +02:00
|
|
|
#ifdef DEBUG_COALESCED
|
|
|
|
# define DPRINTF_C(format, ...) printf(format, ## __VA_ARGS__)
|
|
|
|
#else
|
|
|
|
# define DPRINTF_C(format, ...) do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
2012-08-02 18:04:09 +02:00
|
|
|
#define NSEC_PER_SEC 1000000000LL
|
2012-08-02 18:04:11 +02:00
|
|
|
#define SEC_PER_MIN 60
|
|
|
|
#define MIN_PER_HOUR 60
|
|
|
|
#define SEC_PER_HOUR 3600
|
|
|
|
#define HOUR_PER_DAY 24
|
|
|
|
#define SEC_PER_DAY 86400
|
2012-08-02 18:04:09 +02:00
|
|
|
|
2010-01-20 14:37:33 +01:00
|
|
|
#define RTC_REINJECT_ON_ACK_COUNT 20
|
2012-08-02 18:04:06 +02:00
|
|
|
#define RTC_CLOCK_RATE 32768
|
2012-08-02 18:04:09 +02:00
|
|
|
#define UIP_HOLD_LENGTH (8 * NSEC_PER_SEC / 32768)
|
2009-12-08 14:50:54 +01:00
|
|
|
|
2013-04-27 22:18:43 +02:00
|
|
|
#define MC146818_RTC(obj) OBJECT_CHECK(RTCState, (obj), TYPE_MC146818_RTC)
|
|
|
|
|
2010-05-14 09:29:17 +02:00
|
|
|
typedef struct RTCState {
|
2013-04-27 22:18:43 +02:00
|
|
|
ISADevice parent_obj;
|
|
|
|
|
2011-08-16 00:40:21 +02:00
|
|
|
MemoryRegion io;
|
2004-03-31 20:57:29 +02:00
|
|
|
uint8_t cmos_data[128];
|
|
|
|
uint8_t cmos_index;
|
2009-09-10 11:43:35 +02:00
|
|
|
int32_t base_year;
|
2012-08-02 18:04:09 +02:00
|
|
|
uint64_t base_rtc;
|
|
|
|
uint64_t last_update;
|
|
|
|
int64_t offset;
|
2007-04-07 20:14:41 +02:00
|
|
|
qemu_irq irq;
|
2007-04-17 18:28:29 +02:00
|
|
|
int it_shift;
|
2004-03-31 20:57:29 +02:00
|
|
|
/* periodic timer */
|
|
|
|
QEMUTimer *periodic_timer;
|
|
|
|
int64_t next_periodic_time;
|
2012-08-02 18:04:09 +02:00
|
|
|
/* update-ended timer */
|
|
|
|
QEMUTimer *update_timer;
|
2012-08-02 18:04:11 +02:00
|
|
|
uint64_t next_alarm_time;
|
2009-12-08 14:50:54 +01:00
|
|
|
uint16_t irq_reinject_on_ack_count;
|
2009-01-15 21:11:34 +01:00
|
|
|
uint32_t irq_coalesced;
|
|
|
|
uint32_t period;
|
2009-04-22 22:20:22 +02:00
|
|
|
QEMUTimer *coalesced_timer;
|
2011-06-20 14:06:28 +02:00
|
|
|
Notifier clock_reset_notifier;
|
2012-01-23 20:15:12 +01:00
|
|
|
LostTickPolicy lost_tick_policy;
|
2012-02-23 13:45:20 +01:00
|
|
|
Notifier suspend_notifier;
|
2010-05-14 09:29:17 +02:00
|
|
|
} RTCState;
|
2004-03-31 20:57:29 +02:00
|
|
|
|
|
|
|
static void rtc_set_time(RTCState *s);
|
2012-08-02 18:04:09 +02:00
|
|
|
static void rtc_update_time(RTCState *s);
|
2012-08-02 18:04:12 +02:00
|
|
|
static void rtc_set_cmos(RTCState *s, const struct tm *tm);
|
2012-08-02 18:04:09 +02:00
|
|
|
static inline int rtc_from_bcd(RTCState *s, int a);
|
2012-08-02 18:04:11 +02:00
|
|
|
static uint64_t get_next_alarm(RTCState *s);
|
2012-08-02 18:04:09 +02:00
|
|
|
|
2012-08-02 18:04:10 +02:00
|
|
|
static inline bool rtc_running(RTCState *s)
|
|
|
|
{
|
|
|
|
return (!(s->cmos_data[RTC_REG_B] & REG_B_SET) &&
|
|
|
|
(s->cmos_data[RTC_REG_A] & 0x70) <= 0x20);
|
|
|
|
}
|
|
|
|
|
2012-08-02 18:04:09 +02:00
|
|
|
static uint64_t get_guest_rtc_ns(RTCState *s)
|
|
|
|
{
|
|
|
|
uint64_t guest_rtc;
|
2013-08-21 17:03:04 +02:00
|
|
|
uint64_t guest_clock = qemu_clock_get_ns(rtc_clock);
|
2012-08-02 18:04:09 +02:00
|
|
|
|
|
|
|
guest_rtc = s->base_rtc * NSEC_PER_SEC
|
|
|
|
+ guest_clock - s->last_update + s->offset;
|
|
|
|
return guest_rtc;
|
|
|
|
}
|
2004-03-31 20:57:29 +02:00
|
|
|
|
2009-04-22 22:20:22 +02:00
|
|
|
#ifdef TARGET_I386
|
|
|
|
static void rtc_coalesced_timer_update(RTCState *s)
|
|
|
|
{
|
|
|
|
if (s->irq_coalesced == 0) {
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_del(s->coalesced_timer);
|
2009-04-22 22:20:22 +02:00
|
|
|
} else {
|
|
|
|
/* divide each RTC interval to 2 - 8 smaller intervals */
|
|
|
|
int c = MIN(s->irq_coalesced, 7) + 1;
|
2013-08-21 17:03:04 +02:00
|
|
|
int64_t next_clock = qemu_clock_get_ns(rtc_clock) +
|
2012-08-02 18:04:06 +02:00
|
|
|
muldiv64(s->period / c, get_ticks_per_sec(), RTC_CLOCK_RATE);
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_mod(s->coalesced_timer, next_clock);
|
2009-04-22 22:20:22 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rtc_coalesced_timer(void *opaque)
|
|
|
|
{
|
|
|
|
RTCState *s = opaque;
|
|
|
|
|
|
|
|
if (s->irq_coalesced != 0) {
|
|
|
|
apic_reset_irq_delivered();
|
|
|
|
s->cmos_data[RTC_REG_C] |= 0xc0;
|
2010-05-30 21:20:07 +02:00
|
|
|
DPRINTF_C("cmos: injecting from timer\n");
|
2010-06-13 14:15:40 +02:00
|
|
|
qemu_irq_raise(s->irq);
|
2009-04-22 22:20:22 +02:00
|
|
|
if (apic_get_irq_delivered()) {
|
|
|
|
s->irq_coalesced--;
|
2010-05-30 21:20:07 +02:00
|
|
|
DPRINTF_C("cmos: coalesced irqs decreased to %d\n",
|
|
|
|
s->irq_coalesced);
|
2009-04-22 22:20:22 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rtc_coalesced_timer_update(s);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-08-02 18:04:09 +02:00
|
|
|
/* handle periodic timer */
|
2012-08-02 18:04:05 +02:00
|
|
|
static void periodic_timer_update(RTCState *s, int64_t current_time)
|
2004-03-31 20:57:29 +02:00
|
|
|
{
|
|
|
|
int period_code, period;
|
|
|
|
int64_t cur_clock, next_irq_clock;
|
|
|
|
|
|
|
|
period_code = s->cmos_data[RTC_REG_A] & 0x0f;
|
2009-04-08 00:28:50 +02:00
|
|
|
if (period_code != 0
|
2013-08-14 13:29:43 +02:00
|
|
|
&& (s->cmos_data[RTC_REG_B] & REG_B_PIE)) {
|
2004-03-31 20:57:29 +02:00
|
|
|
if (period_code <= 2)
|
|
|
|
period_code += 7;
|
|
|
|
/* period in 32 Khz cycles */
|
|
|
|
period = 1 << (period_code - 1);
|
2009-01-15 21:11:34 +01:00
|
|
|
#ifdef TARGET_I386
|
2010-05-30 21:20:07 +02:00
|
|
|
if (period != s->period) {
|
2009-01-15 21:11:34 +01:00
|
|
|
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
|
2010-05-30 21:20:07 +02:00
|
|
|
DPRINTF_C("cmos: coalesced irqs scaled to %d\n", s->irq_coalesced);
|
|
|
|
}
|
2009-01-15 21:11:34 +01:00
|
|
|
s->period = period;
|
|
|
|
#endif
|
2004-03-31 20:57:29 +02:00
|
|
|
/* compute 32 khz clock */
|
2012-08-02 18:04:06 +02:00
|
|
|
cur_clock = muldiv64(current_time, RTC_CLOCK_RATE, get_ticks_per_sec());
|
2004-03-31 20:57:29 +02:00
|
|
|
next_irq_clock = (cur_clock & ~(period - 1)) + period;
|
2009-09-15 13:36:04 +02:00
|
|
|
s->next_periodic_time =
|
2012-08-02 18:04:06 +02:00
|
|
|
muldiv64(next_irq_clock, get_ticks_per_sec(), RTC_CLOCK_RATE) + 1;
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_mod(s->periodic_timer, s->next_periodic_time);
|
2004-03-31 20:57:29 +02:00
|
|
|
} else {
|
2009-01-15 21:11:34 +01:00
|
|
|
#ifdef TARGET_I386
|
|
|
|
s->irq_coalesced = 0;
|
|
|
|
#endif
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_del(s->periodic_timer);
|
2004-03-31 20:57:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rtc_periodic_timer(void *opaque)
|
|
|
|
{
|
|
|
|
RTCState *s = opaque;
|
|
|
|
|
2012-08-02 18:04:05 +02:00
|
|
|
periodic_timer_update(s, s->next_periodic_time);
|
2011-11-21 19:00:30 +01:00
|
|
|
s->cmos_data[RTC_REG_C] |= REG_C_PF;
|
2009-04-08 00:28:50 +02:00
|
|
|
if (s->cmos_data[RTC_REG_B] & REG_B_PIE) {
|
2011-11-21 19:00:30 +01:00
|
|
|
s->cmos_data[RTC_REG_C] |= REG_C_IRQF;
|
2009-04-22 22:20:22 +02:00
|
|
|
#ifdef TARGET_I386
|
2014-02-08 11:01:55 +01:00
|
|
|
if (s->lost_tick_policy == LOST_TICK_POLICY_SLEW) {
|
2009-12-08 14:50:54 +01:00
|
|
|
if (s->irq_reinject_on_ack_count >= RTC_REINJECT_ON_ACK_COUNT)
|
|
|
|
s->irq_reinject_on_ack_count = 0;
|
2009-04-22 22:20:22 +02:00
|
|
|
apic_reset_irq_delivered();
|
2010-06-13 14:15:40 +02:00
|
|
|
qemu_irq_raise(s->irq);
|
2009-04-22 22:20:22 +02:00
|
|
|
if (!apic_get_irq_delivered()) {
|
|
|
|
s->irq_coalesced++;
|
|
|
|
rtc_coalesced_timer_update(s);
|
2010-05-30 21:20:07 +02:00
|
|
|
DPRINTF_C("cmos: coalesced irqs increased to %d\n",
|
|
|
|
s->irq_coalesced);
|
2009-04-22 22:20:22 +02:00
|
|
|
}
|
|
|
|
} else
|
|
|
|
#endif
|
2010-06-13 14:15:40 +02:00
|
|
|
qemu_irq_raise(s->irq);
|
2009-04-08 00:28:50 +02:00
|
|
|
}
|
2004-03-31 20:57:29 +02:00
|
|
|
}
|
2004-03-14 13:20:30 +01:00
|
|
|
|
2012-08-02 18:04:09 +02:00
|
|
|
/* handle update-ended timer */
|
|
|
|
static void check_update_timer(RTCState *s)
|
|
|
|
{
|
|
|
|
uint64_t next_update_time;
|
|
|
|
uint64_t guest_nsec;
|
2012-08-02 18:04:11 +02:00
|
|
|
int next_alarm_sec;
|
2012-08-02 18:04:09 +02:00
|
|
|
|
2012-08-02 18:04:10 +02:00
|
|
|
/* From the data sheet: "Holding the dividers in reset prevents
|
|
|
|
* interrupts from operating, while setting the SET bit allows"
|
|
|
|
* them to occur. However, it will prevent an alarm interrupt
|
|
|
|
* from occurring, because the time of day is not updated.
|
2012-08-02 18:04:09 +02:00
|
|
|
*/
|
2012-08-02 18:04:10 +02:00
|
|
|
if ((s->cmos_data[RTC_REG_A] & 0x60) == 0x60) {
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_del(s->update_timer);
|
2012-08-02 18:04:10 +02:00
|
|
|
return;
|
|
|
|
}
|
2012-08-02 18:04:09 +02:00
|
|
|
if ((s->cmos_data[RTC_REG_C] & REG_C_UF) &&
|
|
|
|
(s->cmos_data[RTC_REG_B] & REG_B_SET)) {
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_del(s->update_timer);
|
2012-08-02 18:04:09 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if ((s->cmos_data[RTC_REG_C] & REG_C_UF) &&
|
|
|
|
(s->cmos_data[RTC_REG_C] & REG_C_AF)) {
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_del(s->update_timer);
|
2012-08-02 18:04:09 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
guest_nsec = get_guest_rtc_ns(s) % NSEC_PER_SEC;
|
2012-08-02 18:04:11 +02:00
|
|
|
/* if UF is clear, reprogram to next second */
|
2013-08-21 17:03:04 +02:00
|
|
|
next_update_time = qemu_clock_get_ns(rtc_clock)
|
2012-08-02 18:04:09 +02:00
|
|
|
+ NSEC_PER_SEC - guest_nsec;
|
2012-08-02 18:04:11 +02:00
|
|
|
|
|
|
|
/* Compute time of next alarm. One second is already accounted
|
|
|
|
* for in next_update_time.
|
|
|
|
*/
|
|
|
|
next_alarm_sec = get_next_alarm(s);
|
|
|
|
s->next_alarm_time = next_update_time + (next_alarm_sec - 1) * NSEC_PER_SEC;
|
|
|
|
|
|
|
|
if (s->cmos_data[RTC_REG_C] & REG_C_UF) {
|
|
|
|
/* UF is set, but AF is clear. Program the timer to target
|
|
|
|
* the alarm time. */
|
|
|
|
next_update_time = s->next_alarm_time;
|
|
|
|
}
|
2013-08-21 17:02:39 +02:00
|
|
|
if (next_update_time != timer_expire_time_ns(s->update_timer)) {
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_mod(s->update_timer, next_update_time);
|
2012-08-02 18:04:09 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline uint8_t convert_hour(RTCState *s, uint8_t hour)
|
|
|
|
{
|
|
|
|
if (!(s->cmos_data[RTC_REG_B] & REG_B_24H)) {
|
|
|
|
hour %= 12;
|
|
|
|
if (s->cmos_data[RTC_HOURS] & 0x80) {
|
|
|
|
hour += 12;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return hour;
|
|
|
|
}
|
|
|
|
|
2012-08-02 18:04:11 +02:00
|
|
|
static uint64_t get_next_alarm(RTCState *s)
|
2012-08-02 18:04:09 +02:00
|
|
|
{
|
2012-08-02 18:04:11 +02:00
|
|
|
int32_t alarm_sec, alarm_min, alarm_hour, cur_hour, cur_min, cur_sec;
|
|
|
|
int32_t hour, min, sec;
|
|
|
|
|
|
|
|
rtc_update_time(s);
|
2012-08-02 18:04:09 +02:00
|
|
|
|
|
|
|
alarm_sec = rtc_from_bcd(s, s->cmos_data[RTC_SECONDS_ALARM]);
|
|
|
|
alarm_min = rtc_from_bcd(s, s->cmos_data[RTC_MINUTES_ALARM]);
|
|
|
|
alarm_hour = rtc_from_bcd(s, s->cmos_data[RTC_HOURS_ALARM]);
|
2012-08-02 18:04:11 +02:00
|
|
|
alarm_hour = alarm_hour == -1 ? -1 : convert_hour(s, alarm_hour);
|
2012-08-02 18:04:09 +02:00
|
|
|
|
|
|
|
cur_sec = rtc_from_bcd(s, s->cmos_data[RTC_SECONDS]);
|
|
|
|
cur_min = rtc_from_bcd(s, s->cmos_data[RTC_MINUTES]);
|
|
|
|
cur_hour = rtc_from_bcd(s, s->cmos_data[RTC_HOURS]);
|
|
|
|
cur_hour = convert_hour(s, cur_hour);
|
|
|
|
|
2012-08-02 18:04:11 +02:00
|
|
|
if (alarm_hour == -1) {
|
|
|
|
alarm_hour = cur_hour;
|
|
|
|
if (alarm_min == -1) {
|
|
|
|
alarm_min = cur_min;
|
|
|
|
if (alarm_sec == -1) {
|
|
|
|
alarm_sec = cur_sec + 1;
|
|
|
|
} else if (cur_sec > alarm_sec) {
|
|
|
|
alarm_min++;
|
|
|
|
}
|
|
|
|
} else if (cur_min == alarm_min) {
|
|
|
|
if (alarm_sec == -1) {
|
|
|
|
alarm_sec = cur_sec + 1;
|
|
|
|
} else {
|
|
|
|
if (cur_sec > alarm_sec) {
|
|
|
|
alarm_hour++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (alarm_sec == SEC_PER_MIN) {
|
|
|
|
/* wrap to next hour, minutes is not in don't care mode */
|
|
|
|
alarm_sec = 0;
|
|
|
|
alarm_hour++;
|
|
|
|
}
|
|
|
|
} else if (cur_min > alarm_min) {
|
|
|
|
alarm_hour++;
|
|
|
|
}
|
|
|
|
} else if (cur_hour == alarm_hour) {
|
|
|
|
if (alarm_min == -1) {
|
|
|
|
alarm_min = cur_min;
|
|
|
|
if (alarm_sec == -1) {
|
|
|
|
alarm_sec = cur_sec + 1;
|
|
|
|
} else if (cur_sec > alarm_sec) {
|
|
|
|
alarm_min++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (alarm_sec == SEC_PER_MIN) {
|
|
|
|
alarm_sec = 0;
|
|
|
|
alarm_min++;
|
|
|
|
}
|
|
|
|
/* wrap to next day, hour is not in don't care mode */
|
|
|
|
alarm_min %= MIN_PER_HOUR;
|
|
|
|
} else if (cur_min == alarm_min) {
|
|
|
|
if (alarm_sec == -1) {
|
|
|
|
alarm_sec = cur_sec + 1;
|
|
|
|
}
|
|
|
|
/* wrap to next day, hours+minutes not in don't care mode */
|
|
|
|
alarm_sec %= SEC_PER_MIN;
|
|
|
|
}
|
2012-08-02 18:04:09 +02:00
|
|
|
}
|
|
|
|
|
2012-08-02 18:04:11 +02:00
|
|
|
/* values that are still don't care fire at the next min/sec */
|
|
|
|
if (alarm_min == -1) {
|
|
|
|
alarm_min = 0;
|
|
|
|
}
|
|
|
|
if (alarm_sec == -1) {
|
|
|
|
alarm_sec = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* keep values in range */
|
|
|
|
if (alarm_sec == SEC_PER_MIN) {
|
|
|
|
alarm_sec = 0;
|
|
|
|
alarm_min++;
|
|
|
|
}
|
|
|
|
if (alarm_min == MIN_PER_HOUR) {
|
|
|
|
alarm_min = 0;
|
|
|
|
alarm_hour++;
|
|
|
|
}
|
|
|
|
alarm_hour %= HOUR_PER_DAY;
|
|
|
|
|
|
|
|
hour = alarm_hour - cur_hour;
|
|
|
|
min = hour * MIN_PER_HOUR + alarm_min - cur_min;
|
|
|
|
sec = min * SEC_PER_MIN + alarm_sec - cur_sec;
|
|
|
|
return sec <= 0 ? sec + SEC_PER_DAY : sec;
|
2012-08-02 18:04:09 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rtc_update_timer(void *opaque)
|
|
|
|
{
|
|
|
|
RTCState *s = opaque;
|
|
|
|
int32_t irqs = REG_C_UF;
|
|
|
|
int32_t new_irqs;
|
|
|
|
|
2012-08-02 18:04:10 +02:00
|
|
|
assert((s->cmos_data[RTC_REG_A] & 0x60) != 0x60);
|
|
|
|
|
2012-08-02 18:04:09 +02:00
|
|
|
/* UIP might have been latched, update time and clear it. */
|
|
|
|
rtc_update_time(s);
|
|
|
|
s->cmos_data[RTC_REG_A] &= ~REG_A_UIP;
|
|
|
|
|
2013-08-21 17:03:04 +02:00
|
|
|
if (qemu_clock_get_ns(rtc_clock) >= s->next_alarm_time) {
|
2012-08-02 18:04:09 +02:00
|
|
|
irqs |= REG_C_AF;
|
|
|
|
if (s->cmos_data[RTC_REG_B] & REG_B_AIE) {
|
|
|
|
qemu_system_wakeup_request(QEMU_WAKEUP_REASON_RTC);
|
|
|
|
}
|
|
|
|
}
|
2012-08-02 18:04:11 +02:00
|
|
|
|
2012-08-02 18:04:09 +02:00
|
|
|
new_irqs = irqs & ~s->cmos_data[RTC_REG_C];
|
|
|
|
s->cmos_data[RTC_REG_C] |= irqs;
|
|
|
|
if ((new_irqs & s->cmos_data[RTC_REG_B]) != 0) {
|
|
|
|
s->cmos_data[RTC_REG_C] |= REG_C_IRQF;
|
|
|
|
qemu_irq_raise(s->irq);
|
|
|
|
}
|
|
|
|
check_update_timer(s);
|
|
|
|
}
|
|
|
|
|
2012-10-08 13:22:28 +02:00
|
|
|
static void cmos_ioport_write(void *opaque, hwaddr addr,
|
|
|
|
uint64_t data, unsigned size)
|
2004-03-14 13:20:30 +01:00
|
|
|
{
|
2004-03-14 22:46:48 +01:00
|
|
|
RTCState *s = opaque;
|
2004-03-14 13:20:30 +01:00
|
|
|
|
|
|
|
if ((addr & 1) == 0) {
|
|
|
|
s->cmos_index = data & 0x7f;
|
|
|
|
} else {
|
2010-05-14 09:29:24 +02:00
|
|
|
CMOS_DPRINTF("cmos: write index=0x%02x val=0x%02x\n",
|
|
|
|
s->cmos_index, data);
|
2004-03-31 20:57:29 +02:00
|
|
|
switch(s->cmos_index) {
|
2004-03-14 13:20:30 +01:00
|
|
|
case RTC_SECONDS_ALARM:
|
|
|
|
case RTC_MINUTES_ALARM:
|
|
|
|
case RTC_HOURS_ALARM:
|
|
|
|
s->cmos_data[s->cmos_index] = data;
|
2012-08-02 18:04:09 +02:00
|
|
|
check_update_timer(s);
|
2004-03-14 13:20:30 +01:00
|
|
|
break;
|
2012-10-01 14:22:07 +02:00
|
|
|
case RTC_IBM_PS2_CENTURY_BYTE:
|
|
|
|
s->cmos_index = RTC_CENTURY;
|
|
|
|
/* fall through */
|
|
|
|
case RTC_CENTURY:
|
2004-03-14 13:20:30 +01:00
|
|
|
case RTC_SECONDS:
|
|
|
|
case RTC_MINUTES:
|
|
|
|
case RTC_HOURS:
|
|
|
|
case RTC_DAY_OF_WEEK:
|
|
|
|
case RTC_DAY_OF_MONTH:
|
|
|
|
case RTC_MONTH:
|
|
|
|
case RTC_YEAR:
|
|
|
|
s->cmos_data[s->cmos_index] = data;
|
2004-03-31 20:57:29 +02:00
|
|
|
/* if in set mode, do not update the time */
|
2012-08-02 18:04:10 +02:00
|
|
|
if (rtc_running(s)) {
|
2004-03-31 20:57:29 +02:00
|
|
|
rtc_set_time(s);
|
2012-08-02 18:04:09 +02:00
|
|
|
check_update_timer(s);
|
2004-03-31 20:57:29 +02:00
|
|
|
}
|
2004-03-14 13:20:30 +01:00
|
|
|
break;
|
|
|
|
case RTC_REG_A:
|
2012-08-02 18:04:10 +02:00
|
|
|
if ((data & 0x60) == 0x60) {
|
|
|
|
if (rtc_running(s)) {
|
|
|
|
rtc_update_time(s);
|
|
|
|
}
|
|
|
|
/* What happens to UIP when divider reset is enabled is
|
|
|
|
* unclear from the datasheet. Shouldn't matter much
|
|
|
|
* though.
|
|
|
|
*/
|
|
|
|
s->cmos_data[RTC_REG_A] &= ~REG_A_UIP;
|
|
|
|
} else if (((s->cmos_data[RTC_REG_A] & 0x60) == 0x60) &&
|
|
|
|
(data & 0x70) <= 0x20) {
|
|
|
|
/* when the divider reset is removed, the first update cycle
|
|
|
|
* begins one-half second later*/
|
|
|
|
if (!(s->cmos_data[RTC_REG_B] & REG_B_SET)) {
|
|
|
|
s->offset = 500000000;
|
|
|
|
rtc_set_time(s);
|
|
|
|
}
|
|
|
|
s->cmos_data[RTC_REG_A] &= ~REG_A_UIP;
|
|
|
|
}
|
2004-03-31 20:57:29 +02:00
|
|
|
/* UIP bit is read only */
|
|
|
|
s->cmos_data[RTC_REG_A] = (data & ~REG_A_UIP) |
|
|
|
|
(s->cmos_data[RTC_REG_A] & REG_A_UIP);
|
2013-08-21 17:03:04 +02:00
|
|
|
periodic_timer_update(s, qemu_clock_get_ns(rtc_clock));
|
2012-08-02 18:04:09 +02:00
|
|
|
check_update_timer(s);
|
2004-03-31 20:57:29 +02:00
|
|
|
break;
|
2004-03-14 13:20:30 +01:00
|
|
|
case RTC_REG_B:
|
2004-03-31 20:57:29 +02:00
|
|
|
if (data & REG_B_SET) {
|
2012-08-02 18:04:09 +02:00
|
|
|
/* update cmos to when the rtc was stopping */
|
2012-08-02 18:04:10 +02:00
|
|
|
if (rtc_running(s)) {
|
2012-08-02 18:04:09 +02:00
|
|
|
rtc_update_time(s);
|
|
|
|
}
|
2004-03-31 20:57:29 +02:00
|
|
|
/* set mode: reset UIP mode */
|
|
|
|
s->cmos_data[RTC_REG_A] &= ~REG_A_UIP;
|
|
|
|
data &= ~REG_B_UIE;
|
|
|
|
} else {
|
|
|
|
/* if disabling set mode, update the time */
|
2012-08-02 18:04:10 +02:00
|
|
|
if ((s->cmos_data[RTC_REG_B] & REG_B_SET) &&
|
|
|
|
(s->cmos_data[RTC_REG_A] & 0x70) <= 0x20) {
|
2012-08-02 18:04:09 +02:00
|
|
|
s->offset = get_guest_rtc_ns(s) % NSEC_PER_SEC;
|
2004-03-31 20:57:29 +02:00
|
|
|
rtc_set_time(s);
|
|
|
|
}
|
|
|
|
}
|
2012-08-02 18:04:07 +02:00
|
|
|
/* if an interrupt flag is already set when the interrupt
|
|
|
|
* becomes enabled, raise an interrupt immediately. */
|
|
|
|
if (data & s->cmos_data[RTC_REG_C] & REG_C_MASK) {
|
|
|
|
s->cmos_data[RTC_REG_C] |= REG_C_IRQF;
|
|
|
|
qemu_irq_raise(s->irq);
|
|
|
|
} else {
|
|
|
|
s->cmos_data[RTC_REG_C] &= ~REG_C_IRQF;
|
|
|
|
qemu_irq_lower(s->irq);
|
|
|
|
}
|
2012-08-02 18:04:04 +02:00
|
|
|
s->cmos_data[RTC_REG_B] = data;
|
2013-08-21 17:03:04 +02:00
|
|
|
periodic_timer_update(s, qemu_clock_get_ns(rtc_clock));
|
2012-08-02 18:04:09 +02:00
|
|
|
check_update_timer(s);
|
2004-03-14 13:20:30 +01:00
|
|
|
break;
|
|
|
|
case RTC_REG_C:
|
|
|
|
case RTC_REG_D:
|
|
|
|
/* cannot write to them */
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
s->cmos_data[s->cmos_index] = data;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-20 01:03:47 +01:00
|
|
|
static inline int rtc_to_bcd(RTCState *s, int a)
|
2004-03-14 13:20:30 +01:00
|
|
|
{
|
2009-01-14 22:09:07 +01:00
|
|
|
if (s->cmos_data[RTC_REG_B] & REG_B_DM) {
|
2004-03-31 20:57:29 +02:00
|
|
|
return a;
|
|
|
|
} else {
|
|
|
|
return ((a / 10) << 4) | (a % 10);
|
|
|
|
}
|
2004-03-14 13:20:30 +01:00
|
|
|
}
|
|
|
|
|
2009-11-20 01:03:47 +01:00
|
|
|
static inline int rtc_from_bcd(RTCState *s, int a)
|
2004-03-14 13:20:30 +01:00
|
|
|
{
|
2012-08-02 18:04:11 +02:00
|
|
|
if ((a & 0xc0) == 0xc0) {
|
|
|
|
return -1;
|
|
|
|
}
|
2009-01-14 22:09:07 +01:00
|
|
|
if (s->cmos_data[RTC_REG_B] & REG_B_DM) {
|
2004-03-31 20:57:29 +02:00
|
|
|
return a;
|
|
|
|
} else {
|
|
|
|
return ((a >> 4) * 10) + (a & 0x0f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-02 18:04:12 +02:00
|
|
|
static void rtc_get_time(RTCState *s, struct tm *tm)
|
2004-03-31 20:57:29 +02:00
|
|
|
{
|
2009-11-20 01:03:47 +01:00
|
|
|
tm->tm_sec = rtc_from_bcd(s, s->cmos_data[RTC_SECONDS]);
|
|
|
|
tm->tm_min = rtc_from_bcd(s, s->cmos_data[RTC_MINUTES]);
|
|
|
|
tm->tm_hour = rtc_from_bcd(s, s->cmos_data[RTC_HOURS] & 0x7f);
|
2011-11-21 19:00:28 +01:00
|
|
|
if (!(s->cmos_data[RTC_REG_B] & REG_B_24H)) {
|
|
|
|
tm->tm_hour %= 12;
|
|
|
|
if (s->cmos_data[RTC_HOURS] & 0x80) {
|
|
|
|
tm->tm_hour += 12;
|
|
|
|
}
|
2004-06-03 14:51:19 +02:00
|
|
|
}
|
2009-11-20 01:03:47 +01:00
|
|
|
tm->tm_wday = rtc_from_bcd(s, s->cmos_data[RTC_DAY_OF_WEEK]) - 1;
|
|
|
|
tm->tm_mday = rtc_from_bcd(s, s->cmos_data[RTC_DAY_OF_MONTH]);
|
|
|
|
tm->tm_mon = rtc_from_bcd(s, s->cmos_data[RTC_MONTH]) - 1;
|
2012-10-01 14:22:08 +02:00
|
|
|
tm->tm_year =
|
|
|
|
rtc_from_bcd(s, s->cmos_data[RTC_YEAR]) + s->base_year +
|
|
|
|
rtc_from_bcd(s, s->cmos_data[RTC_CENTURY]) * 100 - 1900;
|
2012-08-02 18:04:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rtc_set_time(RTCState *s)
|
|
|
|
{
|
|
|
|
struct tm tm;
|
2010-02-25 16:11:44 +01:00
|
|
|
|
2012-08-02 18:04:12 +02:00
|
|
|
rtc_get_time(s, &tm);
|
|
|
|
s->base_rtc = mktimegm(&tm);
|
2013-08-21 17:03:04 +02:00
|
|
|
s->last_update = qemu_clock_get_ns(rtc_clock);
|
2012-08-02 18:04:09 +02:00
|
|
|
|
2012-08-02 18:04:12 +02:00
|
|
|
rtc_change_mon_event(&tm);
|
2004-06-03 14:51:19 +02:00
|
|
|
}
|
|
|
|
|
2012-08-02 18:04:12 +02:00
|
|
|
static void rtc_set_cmos(RTCState *s, const struct tm *tm)
|
2004-06-03 14:51:19 +02:00
|
|
|
{
|
2009-01-24 19:06:21 +01:00
|
|
|
int year;
|
2004-03-31 20:57:29 +02:00
|
|
|
|
2009-11-20 01:03:47 +01:00
|
|
|
s->cmos_data[RTC_SECONDS] = rtc_to_bcd(s, tm->tm_sec);
|
|
|
|
s->cmos_data[RTC_MINUTES] = rtc_to_bcd(s, tm->tm_min);
|
2011-01-25 11:55:15 +01:00
|
|
|
if (s->cmos_data[RTC_REG_B] & REG_B_24H) {
|
2004-06-03 14:51:19 +02:00
|
|
|
/* 24 hour format */
|
2009-11-20 01:03:47 +01:00
|
|
|
s->cmos_data[RTC_HOURS] = rtc_to_bcd(s, tm->tm_hour);
|
2004-06-03 14:51:19 +02:00
|
|
|
} else {
|
|
|
|
/* 12 hour format */
|
2011-11-21 19:00:28 +01:00
|
|
|
int h = (tm->tm_hour % 12) ? tm->tm_hour % 12 : 12;
|
|
|
|
s->cmos_data[RTC_HOURS] = rtc_to_bcd(s, h);
|
2004-06-03 14:51:19 +02:00
|
|
|
if (tm->tm_hour >= 12)
|
|
|
|
s->cmos_data[RTC_HOURS] |= 0x80;
|
|
|
|
}
|
2009-11-20 01:03:47 +01:00
|
|
|
s->cmos_data[RTC_DAY_OF_WEEK] = rtc_to_bcd(s, tm->tm_wday + 1);
|
|
|
|
s->cmos_data[RTC_DAY_OF_MONTH] = rtc_to_bcd(s, tm->tm_mday);
|
|
|
|
s->cmos_data[RTC_MONTH] = rtc_to_bcd(s, tm->tm_mon + 1);
|
2012-10-01 14:22:08 +02:00
|
|
|
year = tm->tm_year + 1900 - s->base_year;
|
|
|
|
s->cmos_data[RTC_YEAR] = rtc_to_bcd(s, year % 100);
|
|
|
|
s->cmos_data[RTC_CENTURY] = rtc_to_bcd(s, year / 100);
|
2004-06-03 14:51:19 +02:00
|
|
|
}
|
|
|
|
|
2012-08-02 18:04:09 +02:00
|
|
|
static void rtc_update_time(RTCState *s)
|
2004-06-03 14:51:19 +02:00
|
|
|
{
|
2012-08-02 18:04:09 +02:00
|
|
|
struct tm ret;
|
|
|
|
time_t guest_sec;
|
|
|
|
int64_t guest_nsec;
|
|
|
|
|
|
|
|
guest_nsec = get_guest_rtc_ns(s);
|
|
|
|
guest_sec = guest_nsec / NSEC_PER_SEC;
|
|
|
|
gmtime_r(&guest_sec, &ret);
|
2012-11-26 17:32:54 +01:00
|
|
|
|
|
|
|
/* Is SET flag of Register B disabled? */
|
|
|
|
if ((s->cmos_data[RTC_REG_B] & REG_B_SET) == 0) {
|
|
|
|
rtc_set_cmos(s, &ret);
|
|
|
|
}
|
2004-06-03 14:51:19 +02:00
|
|
|
}
|
|
|
|
|
2012-08-02 18:04:09 +02:00
|
|
|
static int update_in_progress(RTCState *s)
|
2004-06-03 14:51:19 +02:00
|
|
|
{
|
2012-08-02 18:04:09 +02:00
|
|
|
int64_t guest_nsec;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2012-08-02 18:04:10 +02:00
|
|
|
if (!rtc_running(s)) {
|
2012-08-02 18:04:09 +02:00
|
|
|
return 0;
|
2004-03-31 20:57:29 +02:00
|
|
|
}
|
2013-08-21 17:02:39 +02:00
|
|
|
if (timer_pending(s->update_timer)) {
|
|
|
|
int64_t next_update_time = timer_expire_time_ns(s->update_timer);
|
2012-08-02 18:04:09 +02:00
|
|
|
/* Latch UIP until the timer expires. */
|
2013-08-21 17:03:04 +02:00
|
|
|
if (qemu_clock_get_ns(rtc_clock) >=
|
|
|
|
(next_update_time - UIP_HOLD_LENGTH)) {
|
2012-08-02 18:04:09 +02:00
|
|
|
s->cmos_data[RTC_REG_A] |= REG_A_UIP;
|
|
|
|
return 1;
|
2004-03-31 20:57:29 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-02 18:04:09 +02:00
|
|
|
guest_nsec = get_guest_rtc_ns(s);
|
|
|
|
/* UIP bit will be set at last 244us of every second. */
|
|
|
|
if ((guest_nsec % NSEC_PER_SEC) >= (NSEC_PER_SEC - UIP_HOLD_LENGTH)) {
|
|
|
|
return 1;
|
2004-03-31 20:57:29 +02:00
|
|
|
}
|
2012-08-02 18:04:09 +02:00
|
|
|
return 0;
|
2004-03-14 13:20:30 +01:00
|
|
|
}
|
|
|
|
|
2012-10-08 13:22:28 +02:00
|
|
|
static uint64_t cmos_ioport_read(void *opaque, hwaddr addr,
|
|
|
|
unsigned size)
|
2004-03-14 13:20:30 +01:00
|
|
|
{
|
2004-03-14 22:46:48 +01:00
|
|
|
RTCState *s = opaque;
|
2004-03-14 13:20:30 +01:00
|
|
|
int ret;
|
|
|
|
if ((addr & 1) == 0) {
|
|
|
|
return 0xff;
|
|
|
|
} else {
|
|
|
|
switch(s->cmos_index) {
|
2012-10-01 14:22:07 +02:00
|
|
|
case RTC_IBM_PS2_CENTURY_BYTE:
|
|
|
|
s->cmos_index = RTC_CENTURY;
|
|
|
|
/* fall through */
|
|
|
|
case RTC_CENTURY:
|
2004-03-14 13:20:30 +01:00
|
|
|
case RTC_SECONDS:
|
|
|
|
case RTC_MINUTES:
|
|
|
|
case RTC_HOURS:
|
|
|
|
case RTC_DAY_OF_WEEK:
|
|
|
|
case RTC_DAY_OF_MONTH:
|
|
|
|
case RTC_MONTH:
|
|
|
|
case RTC_YEAR:
|
2012-08-02 18:04:09 +02:00
|
|
|
/* if not in set mode, calibrate cmos before
|
|
|
|
* reading*/
|
2012-08-02 18:04:10 +02:00
|
|
|
if (rtc_running(s)) {
|
2012-08-02 18:04:09 +02:00
|
|
|
rtc_update_time(s);
|
|
|
|
}
|
2004-03-14 13:20:30 +01:00
|
|
|
ret = s->cmos_data[s->cmos_index];
|
|
|
|
break;
|
|
|
|
case RTC_REG_A:
|
2012-08-02 18:04:09 +02:00
|
|
|
if (update_in_progress(s)) {
|
|
|
|
s->cmos_data[s->cmos_index] |= REG_A_UIP;
|
|
|
|
} else {
|
|
|
|
s->cmos_data[s->cmos_index] &= ~REG_A_UIP;
|
|
|
|
}
|
2004-03-14 13:20:30 +01:00
|
|
|
ret = s->cmos_data[s->cmos_index];
|
|
|
|
break;
|
|
|
|
case RTC_REG_C:
|
|
|
|
ret = s->cmos_data[s->cmos_index];
|
2007-04-07 20:14:41 +02:00
|
|
|
qemu_irq_lower(s->irq);
|
2011-11-21 19:00:31 +01:00
|
|
|
s->cmos_data[RTC_REG_C] = 0x00;
|
2012-08-02 18:04:09 +02:00
|
|
|
if (ret & (REG_C_UF | REG_C_AF)) {
|
|
|
|
check_update_timer(s);
|
|
|
|
}
|
2009-12-08 14:50:54 +01:00
|
|
|
#ifdef TARGET_I386
|
|
|
|
if(s->irq_coalesced &&
|
2011-11-21 19:00:31 +01:00
|
|
|
(s->cmos_data[RTC_REG_B] & REG_B_PIE) &&
|
2009-12-08 14:50:54 +01:00
|
|
|
s->irq_reinject_on_ack_count < RTC_REINJECT_ON_ACK_COUNT) {
|
|
|
|
s->irq_reinject_on_ack_count++;
|
2011-11-21 19:00:31 +01:00
|
|
|
s->cmos_data[RTC_REG_C] |= REG_C_IRQF | REG_C_PF;
|
2009-12-08 14:50:54 +01:00
|
|
|
apic_reset_irq_delivered();
|
2010-05-30 21:20:07 +02:00
|
|
|
DPRINTF_C("cmos: injecting on ack\n");
|
2009-12-08 14:50:54 +01:00
|
|
|
qemu_irq_raise(s->irq);
|
2010-05-30 21:20:07 +02:00
|
|
|
if (apic_get_irq_delivered()) {
|
2009-12-08 14:50:54 +01:00
|
|
|
s->irq_coalesced--;
|
2010-05-30 21:20:07 +02:00
|
|
|
DPRINTF_C("cmos: coalesced irqs decreased to %d\n",
|
|
|
|
s->irq_coalesced);
|
|
|
|
}
|
2009-12-08 14:50:54 +01:00
|
|
|
}
|
|
|
|
#endif
|
2004-03-14 13:20:30 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = s->cmos_data[s->cmos_index];
|
|
|
|
break;
|
|
|
|
}
|
2010-05-14 09:29:24 +02:00
|
|
|
CMOS_DPRINTF("cmos: read index=0x%02x val=0x%02x\n",
|
|
|
|
s->cmos_index, ret);
|
2004-03-14 13:20:30 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-14 09:29:17 +02:00
|
|
|
void rtc_set_memory(ISADevice *dev, int addr, int val)
|
2004-03-31 20:57:29 +02:00
|
|
|
{
|
2013-04-27 22:18:43 +02:00
|
|
|
RTCState *s = MC146818_RTC(dev);
|
2004-03-31 20:57:29 +02:00
|
|
|
if (addr >= 0 && addr <= 127)
|
|
|
|
s->cmos_data[addr] = val;
|
|
|
|
}
|
|
|
|
|
2013-04-23 10:29:40 +02:00
|
|
|
int rtc_get_memory(ISADevice *dev, int addr)
|
|
|
|
{
|
|
|
|
RTCState *s = MC146818_RTC(dev);
|
|
|
|
assert(addr >= 0 && addr <= 127);
|
|
|
|
return s->cmos_data[addr];
|
|
|
|
}
|
|
|
|
|
2010-05-14 09:29:17 +02:00
|
|
|
static void rtc_set_date_from_host(ISADevice *dev)
|
2006-12-07 18:16:55 +01:00
|
|
|
{
|
2013-04-27 22:18:43 +02:00
|
|
|
RTCState *s = MC146818_RTC(dev);
|
2008-02-17 12:42:19 +01:00
|
|
|
struct tm tm;
|
2006-12-07 18:16:55 +01:00
|
|
|
|
2008-02-17 12:42:19 +01:00
|
|
|
qemu_get_timedate(&tm, 0);
|
2012-08-02 18:04:09 +02:00
|
|
|
|
|
|
|
s->base_rtc = mktimegm(&tm);
|
2013-08-21 17:03:04 +02:00
|
|
|
s->last_update = qemu_clock_get_ns(rtc_clock);
|
2012-08-02 18:04:09 +02:00
|
|
|
s->offset = 0;
|
|
|
|
|
|
|
|
/* set the CMOS date */
|
2012-08-02 18:04:12 +02:00
|
|
|
rtc_set_cmos(s, &tm);
|
2006-12-07 18:16:55 +01:00
|
|
|
}
|
|
|
|
|
2009-10-08 00:12:06 +02:00
|
|
|
static int rtc_post_load(void *opaque, int version_id)
|
2004-03-14 13:20:30 +01:00
|
|
|
{
|
2004-03-31 20:57:29 +02:00
|
|
|
RTCState *s = opaque;
|
|
|
|
|
2012-08-02 18:04:09 +02:00
|
|
|
if (version_id <= 2) {
|
|
|
|
rtc_set_time(s);
|
|
|
|
s->offset = 0;
|
|
|
|
check_update_timer(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef TARGET_I386
|
2009-09-09 22:17:30 +02:00
|
|
|
if (version_id >= 2) {
|
2014-02-08 11:01:55 +01:00
|
|
|
if (s->lost_tick_policy == LOST_TICK_POLICY_SLEW) {
|
2009-09-09 22:17:30 +02:00
|
|
|
rtc_coalesced_timer_update(s);
|
|
|
|
}
|
|
|
|
}
|
2009-10-08 00:12:06 +02:00
|
|
|
#endif
|
2009-01-15 21:11:34 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-08 00:12:06 +02:00
|
|
|
static const VMStateDescription vmstate_rtc = {
|
|
|
|
.name = "mc146818rtc",
|
2012-08-02 18:04:09 +02:00
|
|
|
.version_id = 3,
|
2009-10-08 00:12:06 +02:00
|
|
|
.minimum_version_id = 1,
|
|
|
|
.post_load = rtc_post_load,
|
2014-04-16 15:32:32 +02:00
|
|
|
.fields = (VMStateField[]) {
|
2009-10-08 00:12:06 +02:00
|
|
|
VMSTATE_BUFFER(cmos_data, RTCState),
|
|
|
|
VMSTATE_UINT8(cmos_index, RTCState),
|
2012-08-02 18:04:13 +02:00
|
|
|
VMSTATE_UNUSED(7*4),
|
2009-10-08 00:12:06 +02:00
|
|
|
VMSTATE_TIMER(periodic_timer, RTCState),
|
|
|
|
VMSTATE_INT64(next_periodic_time, RTCState),
|
2012-08-02 18:04:09 +02:00
|
|
|
VMSTATE_UNUSED(3*8),
|
2009-10-08 00:12:06 +02:00
|
|
|
VMSTATE_UINT32_V(irq_coalesced, RTCState, 2),
|
|
|
|
VMSTATE_UINT32_V(period, RTCState, 2),
|
2012-08-02 18:04:09 +02:00
|
|
|
VMSTATE_UINT64_V(base_rtc, RTCState, 3),
|
|
|
|
VMSTATE_UINT64_V(last_update, RTCState, 3),
|
|
|
|
VMSTATE_INT64_V(offset, RTCState, 3),
|
|
|
|
VMSTATE_TIMER_V(update_timer, RTCState, 3),
|
2012-08-02 18:04:11 +02:00
|
|
|
VMSTATE_UINT64_V(next_alarm_time, RTCState, 3),
|
2009-10-08 00:12:06 +02:00
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-06-20 14:06:28 +02:00
|
|
|
static void rtc_notify_clock_reset(Notifier *notifier, void *data)
|
|
|
|
{
|
|
|
|
RTCState *s = container_of(notifier, RTCState, clock_reset_notifier);
|
|
|
|
int64_t now = *(int64_t *)data;
|
|
|
|
|
2013-04-27 22:18:43 +02:00
|
|
|
rtc_set_date_from_host(ISA_DEVICE(s));
|
2012-08-02 18:04:05 +02:00
|
|
|
periodic_timer_update(s, now);
|
2012-08-02 18:04:09 +02:00
|
|
|
check_update_timer(s);
|
2011-06-20 14:06:28 +02:00
|
|
|
#ifdef TARGET_I386
|
2014-02-08 11:01:55 +01:00
|
|
|
if (s->lost_tick_policy == LOST_TICK_POLICY_SLEW) {
|
2011-06-20 14:06:28 +02:00
|
|
|
rtc_coalesced_timer_update(s);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-02-23 13:45:20 +01:00
|
|
|
/* set CMOS shutdown status register (index 0xF) as S3_resume(0xFE)
|
|
|
|
BIOS will read it and start S3 resume at POST Entry */
|
|
|
|
static void rtc_notify_suspend(Notifier *notifier, void *data)
|
|
|
|
{
|
|
|
|
RTCState *s = container_of(notifier, RTCState, suspend_notifier);
|
2013-04-27 22:18:43 +02:00
|
|
|
rtc_set_memory(ISA_DEVICE(s), 0xF, 0xFE);
|
2012-02-23 13:45:20 +01:00
|
|
|
}
|
|
|
|
|
2009-06-08 14:56:04 +02:00
|
|
|
static void rtc_reset(void *opaque)
|
|
|
|
{
|
|
|
|
RTCState *s = opaque;
|
|
|
|
|
2009-06-15 21:33:24 +02:00
|
|
|
s->cmos_data[RTC_REG_B] &= ~(REG_B_PIE | REG_B_AIE | REG_B_SQWE);
|
|
|
|
s->cmos_data[RTC_REG_C] &= ~(REG_C_UF | REG_C_IRQF | REG_C_PF | REG_C_AF);
|
2012-08-02 18:04:09 +02:00
|
|
|
check_update_timer(s);
|
2009-06-08 14:56:04 +02:00
|
|
|
|
2009-06-15 21:33:24 +02:00
|
|
|
qemu_irq_lower(s->irq);
|
2009-06-08 14:56:04 +02:00
|
|
|
|
|
|
|
#ifdef TARGET_I386
|
2014-02-08 11:01:55 +01:00
|
|
|
if (s->lost_tick_policy == LOST_TICK_POLICY_SLEW) {
|
2012-01-23 20:15:12 +01:00
|
|
|
s->irq_coalesced = 0;
|
|
|
|
}
|
2009-06-08 14:56:04 +02:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2011-08-16 00:40:21 +02:00
|
|
|
static const MemoryRegionOps cmos_ops = {
|
2012-10-08 13:22:28 +02:00
|
|
|
.read = cmos_ioport_read,
|
|
|
|
.write = cmos_ioport_write,
|
|
|
|
.impl = {
|
|
|
|
.min_access_size = 1,
|
|
|
|
.max_access_size = 1,
|
|
|
|
},
|
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN,
|
2011-08-16 00:40:21 +02:00
|
|
|
};
|
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
static void rtc_get_date(Object *obj, Visitor *v, void *opaque,
|
2011-12-12 21:29:39 +01:00
|
|
|
const char *name, Error **errp)
|
|
|
|
{
|
2014-05-07 09:53:52 +02:00
|
|
|
Error *err = NULL;
|
2013-04-27 22:18:43 +02:00
|
|
|
RTCState *s = MC146818_RTC(obj);
|
2012-08-02 18:04:12 +02:00
|
|
|
struct tm current_tm;
|
2011-12-12 21:29:39 +01:00
|
|
|
|
2012-08-02 18:04:09 +02:00
|
|
|
rtc_update_time(s);
|
2012-08-02 18:04:12 +02:00
|
|
|
rtc_get_time(s, ¤t_tm);
|
2014-05-07 09:53:52 +02:00
|
|
|
visit_start_struct(v, NULL, "struct tm", name, 0, &err);
|
|
|
|
if (err) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
visit_type_int32(v, ¤t_tm.tm_year, "tm_year", &err);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
2014-05-07 09:53:52 +02:00
|
|
|
visit_type_int32(v, ¤t_tm.tm_mon, "tm_mon", &err);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
2014-05-07 09:53:52 +02:00
|
|
|
visit_type_int32(v, ¤t_tm.tm_mday, "tm_mday", &err);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
2014-05-07 09:53:52 +02:00
|
|
|
visit_type_int32(v, ¤t_tm.tm_hour, "tm_hour", &err);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
2014-05-07 09:53:52 +02:00
|
|
|
visit_type_int32(v, ¤t_tm.tm_min, "tm_min", &err);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
2014-05-07 09:53:52 +02:00
|
|
|
visit_type_int32(v, ¤t_tm.tm_sec, "tm_sec", &err);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
|
|
|
out_end:
|
|
|
|
error_propagate(errp, err);
|
|
|
|
err = NULL;
|
|
|
|
visit_end_struct(v, errp);
|
2014-05-07 09:53:52 +02:00
|
|
|
out:
|
|
|
|
error_propagate(errp, err);
|
2011-12-12 21:29:39 +01:00
|
|
|
}
|
|
|
|
|
2012-11-25 02:37:14 +01:00
|
|
|
static void rtc_realizefn(DeviceState *dev, Error **errp)
|
2004-03-31 20:57:29 +02:00
|
|
|
{
|
2012-11-25 02:37:14 +01:00
|
|
|
ISADevice *isadev = ISA_DEVICE(dev);
|
2013-04-27 22:18:43 +02:00
|
|
|
RTCState *s = MC146818_RTC(dev);
|
2009-09-10 11:43:35 +02:00
|
|
|
int base = 0x70;
|
2004-03-14 13:20:30 +01:00
|
|
|
|
|
|
|
s->cmos_data[RTC_REG_A] = 0x26;
|
|
|
|
s->cmos_data[RTC_REG_B] = 0x02;
|
|
|
|
s->cmos_data[RTC_REG_C] = 0x00;
|
|
|
|
s->cmos_data[RTC_REG_D] = 0x80;
|
|
|
|
|
2012-10-01 14:22:08 +02:00
|
|
|
/* This is for historical reasons. The default base year qdev property
|
|
|
|
* was set to 2000 for most machine types before the century byte was
|
|
|
|
* implemented.
|
|
|
|
*
|
|
|
|
* This if statement means that the century byte will be always 0
|
|
|
|
* (at least until 2079...) for base_year = 1980, but will be set
|
|
|
|
* correctly for base_year = 2000.
|
|
|
|
*/
|
|
|
|
if (s->base_year == 2000) {
|
|
|
|
s->base_year = 0;
|
|
|
|
}
|
|
|
|
|
2012-11-25 02:37:14 +01:00
|
|
|
rtc_set_date_from_host(isadev);
|
2006-12-07 18:16:55 +01:00
|
|
|
|
2009-04-22 22:20:22 +02:00
|
|
|
#ifdef TARGET_I386
|
2012-01-23 20:15:12 +01:00
|
|
|
switch (s->lost_tick_policy) {
|
2014-02-08 11:01:55 +01:00
|
|
|
case LOST_TICK_POLICY_SLEW:
|
2009-09-15 13:36:04 +02:00
|
|
|
s->coalesced_timer =
|
2013-08-21 17:03:04 +02:00
|
|
|
timer_new_ns(rtc_clock, rtc_coalesced_timer, s);
|
2012-01-23 20:15:12 +01:00
|
|
|
break;
|
2014-02-08 11:01:55 +01:00
|
|
|
case LOST_TICK_POLICY_DISCARD:
|
2012-01-23 20:15:12 +01:00
|
|
|
break;
|
|
|
|
default:
|
2012-11-25 02:37:14 +01:00
|
|
|
error_setg(errp, "Invalid lost tick policy.");
|
|
|
|
return;
|
2012-01-23 20:15:12 +01:00
|
|
|
}
|
2009-04-22 22:20:22 +02:00
|
|
|
#endif
|
2012-01-23 20:15:12 +01:00
|
|
|
|
2013-08-21 17:03:04 +02:00
|
|
|
s->periodic_timer = timer_new_ns(rtc_clock, rtc_periodic_timer, s);
|
|
|
|
s->update_timer = timer_new_ns(rtc_clock, rtc_update_timer, s);
|
2012-08-02 18:04:09 +02:00
|
|
|
check_update_timer(s);
|
2004-03-31 20:57:29 +02:00
|
|
|
|
2011-06-20 14:06:28 +02:00
|
|
|
s->clock_reset_notifier.notify = rtc_notify_clock_reset;
|
2013-08-21 17:03:04 +02:00
|
|
|
qemu_clock_register_reset_notifier(QEMU_CLOCK_REALTIME,
|
|
|
|
&s->clock_reset_notifier);
|
2011-06-20 14:06:28 +02:00
|
|
|
|
2012-02-23 13:45:20 +01:00
|
|
|
s->suspend_notifier.notify = rtc_notify_suspend;
|
|
|
|
qemu_register_suspend_notifier(&s->suspend_notifier);
|
|
|
|
|
2013-06-07 03:25:08 +02:00
|
|
|
memory_region_init_io(&s->io, OBJECT(s), &cmos_ops, s, "rtc", 2);
|
2012-11-25 02:37:14 +01:00
|
|
|
isa_register_ioport(isadev, &s->io, base);
|
2004-03-31 20:57:29 +02:00
|
|
|
|
2012-11-25 02:37:14 +01:00
|
|
|
qdev_set_legacy_instance_id(dev, base, 3);
|
2009-06-27 09:25:07 +02:00
|
|
|
qemu_register_reset(rtc_reset, s);
|
2011-12-12 21:29:39 +01:00
|
|
|
|
2012-01-30 15:55:55 +01:00
|
|
|
object_property_add(OBJECT(s), "date", "struct tm",
|
|
|
|
rtc_get_date, NULL, NULL, s, NULL);
|
2009-09-10 11:43:35 +02:00
|
|
|
}
|
|
|
|
|
2011-12-15 22:09:51 +01:00
|
|
|
ISADevice *rtc_init(ISABus *bus, int base_year, qemu_irq intercept_irq)
|
2009-09-10 11:43:35 +02:00
|
|
|
{
|
2013-04-27 22:18:43 +02:00
|
|
|
DeviceState *dev;
|
|
|
|
ISADevice *isadev;
|
2010-06-13 14:15:40 +02:00
|
|
|
RTCState *s;
|
2009-06-08 14:56:04 +02:00
|
|
|
|
2013-04-27 22:18:43 +02:00
|
|
|
isadev = isa_create(bus, TYPE_MC146818_RTC);
|
|
|
|
dev = DEVICE(isadev);
|
|
|
|
s = MC146818_RTC(isadev);
|
|
|
|
qdev_prop_set_int32(dev, "base_year", base_year);
|
|
|
|
qdev_init_nofail(dev);
|
2010-06-13 14:15:40 +02:00
|
|
|
if (intercept_irq) {
|
|
|
|
s->irq = intercept_irq;
|
|
|
|
} else {
|
2013-04-27 22:18:43 +02:00
|
|
|
isa_init_irq(isadev, &s->irq, RTC_ISA_IRQ);
|
2010-06-13 14:15:40 +02:00
|
|
|
}
|
2013-04-27 22:18:43 +02:00
|
|
|
return isadev;
|
2004-03-14 13:20:30 +01:00
|
|
|
}
|
|
|
|
|
2011-12-08 04:34:16 +01:00
|
|
|
static Property mc146818rtc_properties[] = {
|
|
|
|
DEFINE_PROP_INT32("base_year", RTCState, base_year, 1980),
|
|
|
|
DEFINE_PROP_LOSTTICKPOLICY("lost_tick_policy", RTCState,
|
2014-02-08 11:01:55 +01:00
|
|
|
lost_tick_policy, LOST_TICK_POLICY_DISCARD),
|
2011-12-08 04:34:16 +01:00
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
2011-12-04 18:52:49 +01:00
|
|
|
static void rtc_class_initfn(ObjectClass *klass, void *data)
|
|
|
|
{
|
2011-12-08 04:34:16 +01:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
2012-11-25 02:37:14 +01:00
|
|
|
|
|
|
|
dc->realize = rtc_realizefn;
|
2011-12-08 04:34:16 +01:00
|
|
|
dc->vmsd = &vmstate_rtc;
|
|
|
|
dc->props = mc146818rtc_properties;
|
2013-11-28 17:27:02 +01:00
|
|
|
/* Reason: needs to be wired up by rtc_init() */
|
|
|
|
dc->cannot_instantiate_with_device_add_yet = true;
|
2011-12-04 18:52:49 +01:00
|
|
|
}
|
|
|
|
|
2013-01-10 16:19:07 +01:00
|
|
|
static const TypeInfo mc146818rtc_info = {
|
2013-04-27 22:18:43 +02:00
|
|
|
.name = TYPE_MC146818_RTC,
|
2011-12-08 04:34:16 +01:00
|
|
|
.parent = TYPE_ISA_DEVICE,
|
|
|
|
.instance_size = sizeof(RTCState),
|
|
|
|
.class_init = rtc_class_initfn,
|
2009-09-10 11:43:35 +02:00
|
|
|
};
|
|
|
|
|
2012-02-09 15:20:55 +01:00
|
|
|
static void mc146818rtc_register_types(void)
|
2009-04-08 00:28:50 +02:00
|
|
|
{
|
2011-12-08 04:34:16 +01:00
|
|
|
type_register_static(&mc146818rtc_info);
|
2009-04-08 00:28:50 +02:00
|
|
|
}
|
2012-02-09 15:20:55 +01:00
|
|
|
|
|
|
|
type_init(mc146818rtc_register_types)
|