2004-03-14 20:20:30 +08:00
|
|
|
/*
|
|
|
|
* QEMU MC146818 RTC emulation
|
2007-09-17 05:08:06 +08:00
|
|
|
*
|
2004-03-14 20:20:30 +08:00
|
|
|
* Copyright (c) 2003-2004 Fabrice Bellard
|
2007-09-17 05:08:06 +08:00
|
|
|
*
|
2004-03-14 20:20:30 +08: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.
|
|
|
|
*/
|
2018-02-01 19:18:31 +08:00
|
|
|
|
2016-01-27 02:17:03 +08:00
|
|
|
#include "qemu/osdep.h"
|
2019-05-23 22:35:08 +08:00
|
|
|
#include "qemu-common.h"
|
2016-03-21 01:16:19 +08:00
|
|
|
#include "qemu/cutils.h"
|
2019-05-23 22:35:07 +08:00
|
|
|
#include "qemu/module.h"
|
2016-03-21 01:16:19 +08:00
|
|
|
#include "qemu/bcd.h"
|
2020-05-15 23:04:07 +08:00
|
|
|
#include "hw/acpi/aml-build.h"
|
2019-08-12 13:23:42 +08:00
|
|
|
#include "hw/irq.h"
|
2019-08-12 13:23:51 +08:00
|
|
|
#include "hw/qdev-properties.h"
|
2012-12-18 01:20:00 +08:00
|
|
|
#include "qemu/timer.h"
|
2012-12-18 01:20:04 +08:00
|
|
|
#include "sysemu/sysemu.h"
|
2017-01-24 15:17:30 +08:00
|
|
|
#include "sysemu/replay.h"
|
2019-08-12 13:23:38 +08:00
|
|
|
#include "sysemu/reset.h"
|
2019-08-12 13:23:59 +08:00
|
|
|
#include "sysemu/runstate.h"
|
2019-10-04 07:03:53 +08:00
|
|
|
#include "hw/rtc/mc146818rtc.h"
|
2019-10-04 07:04:02 +08:00
|
|
|
#include "hw/rtc/mc146818rtc_regs.h"
|
2019-08-12 13:23:45 +08:00
|
|
|
#include "migration/vmstate.h"
|
2018-02-01 19:18:31 +08:00
|
|
|
#include "qapi/error.h"
|
2019-06-20 04:10:46 +08:00
|
|
|
#include "qapi/qapi-events-misc-target.h"
|
2012-12-18 01:19:43 +08:00
|
|
|
#include "qapi/visitor.h"
|
2018-10-19 03:19:13 +08:00
|
|
|
#include "exec/address-spaces.h"
|
2019-10-26 21:36:22 +08:00
|
|
|
#include "hw/rtc/mc146818rtc_regs.h"
|
2004-03-14 20:20:30 +08:00
|
|
|
|
2012-02-18 01:31:17 +08:00
|
|
|
#ifdef TARGET_I386
|
2019-10-18 00:26:14 +08:00
|
|
|
#include "qapi/qapi-commands-misc-target.h"
|
2013-02-06 00:06:20 +08:00
|
|
|
#include "hw/i386/apic.h"
|
2012-02-18 01:31:17 +08:00
|
|
|
#endif
|
|
|
|
|
2004-03-14 20:20:30 +08:00
|
|
|
//#define DEBUG_CMOS
|
2010-05-31 03:20:07 +08:00
|
|
|
//#define DEBUG_COALESCED
|
2004-03-14 20:20:30 +08:00
|
|
|
|
2010-05-14 15:29:24 +08:00
|
|
|
#ifdef DEBUG_CMOS
|
|
|
|
# define CMOS_DPRINTF(format, ...) printf(format, ## __VA_ARGS__)
|
|
|
|
#else
|
|
|
|
# define CMOS_DPRINTF(format, ...) do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
2010-05-31 03:20:07 +08:00
|
|
|
#ifdef DEBUG_COALESCED
|
|
|
|
# define DPRINTF_C(format, ...) printf(format, ## __VA_ARGS__)
|
|
|
|
#else
|
|
|
|
# define DPRINTF_C(format, ...) do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
2012-08-03 00:04:11 +08: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-03 00:04:09 +08:00
|
|
|
|
2010-01-20 21:37:33 +08:00
|
|
|
#define RTC_REINJECT_ON_ACK_COUNT 20
|
2012-08-03 00:04:06 +08:00
|
|
|
#define RTC_CLOCK_RATE 32768
|
2015-07-08 22:10:09 +08:00
|
|
|
#define UIP_HOLD_LENGTH (8 * NANOSECONDS_PER_SECOND / 32768)
|
2009-12-08 21:50:54 +08:00
|
|
|
|
2004-04-01 02:57:29 +08:00
|
|
|
static void rtc_set_time(RTCState *s);
|
2012-08-03 00:04:09 +08:00
|
|
|
static void rtc_update_time(RTCState *s);
|
2012-08-03 00:04:12 +08:00
|
|
|
static void rtc_set_cmos(RTCState *s, const struct tm *tm);
|
2012-08-03 00:04:09 +08:00
|
|
|
static inline int rtc_from_bcd(RTCState *s, int a);
|
2012-08-03 00:04:11 +08:00
|
|
|
static uint64_t get_next_alarm(RTCState *s);
|
2012-08-03 00:04:09 +08:00
|
|
|
|
2012-08-03 00:04:10 +08: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-03 00:04:09 +08:00
|
|
|
static uint64_t get_guest_rtc_ns(RTCState *s)
|
|
|
|
{
|
2013-08-21 23:03:04 +08:00
|
|
|
uint64_t guest_clock = qemu_clock_get_ns(rtc_clock);
|
2012-08-03 00:04:09 +08:00
|
|
|
|
2016-06-14 05:57:58 +08:00
|
|
|
return s->base_rtc * NANOSECONDS_PER_SECOND +
|
2016-03-22 00:02:30 +08:00
|
|
|
guest_clock - s->last_update + s->offset;
|
2012-08-03 00:04:09 +08:00
|
|
|
}
|
2004-04-01 02:57:29 +08:00
|
|
|
|
2009-04-23 04:20:22 +08:00
|
|
|
static void rtc_coalesced_timer_update(RTCState *s)
|
|
|
|
{
|
|
|
|
if (s->irq_coalesced == 0) {
|
2013-08-21 23:03:08 +08:00
|
|
|
timer_del(s->coalesced_timer);
|
2009-04-23 04:20:22 +08:00
|
|
|
} else {
|
|
|
|
/* divide each RTC interval to 2 - 8 smaller intervals */
|
2018-08-16 19:35:53 +08:00
|
|
|
int c = MIN(s->irq_coalesced, 7) + 1;
|
2013-08-21 23:03:04 +08:00
|
|
|
int64_t next_clock = qemu_clock_get_ns(rtc_clock) +
|
2017-05-27 10:53:01 +08:00
|
|
|
periodic_clock_to_ns(s->period / c);
|
2013-08-21 23:03:08 +08:00
|
|
|
timer_mod(s->coalesced_timer, next_clock);
|
2009-04-23 04:20:22 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-05-10 16:32:59 +08:00
|
|
|
static QLIST_HEAD(, RTCState) rtc_devices =
|
|
|
|
QLIST_HEAD_INITIALIZER(rtc_devices);
|
|
|
|
|
2017-05-10 16:32:58 +08:00
|
|
|
#ifdef TARGET_I386
|
2017-05-10 16:32:59 +08:00
|
|
|
void qmp_rtc_reset_reinjection(Error **errp)
|
|
|
|
{
|
|
|
|
RTCState *s;
|
|
|
|
|
|
|
|
QLIST_FOREACH(s, &rtc_devices, link) {
|
|
|
|
s->irq_coalesced = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool rtc_policy_slew_deliver_irq(RTCState *s)
|
|
|
|
{
|
|
|
|
apic_reset_irq_delivered();
|
|
|
|
qemu_irq_raise(s->irq);
|
|
|
|
return apic_get_irq_delivered();
|
|
|
|
}
|
|
|
|
|
2009-04-23 04:20:22 +08:00
|
|
|
static void rtc_coalesced_timer(void *opaque)
|
|
|
|
{
|
|
|
|
RTCState *s = opaque;
|
|
|
|
|
|
|
|
if (s->irq_coalesced != 0) {
|
|
|
|
s->cmos_data[RTC_REG_C] |= 0xc0;
|
2010-05-31 03:20:07 +08:00
|
|
|
DPRINTF_C("cmos: injecting from timer\n");
|
2017-05-10 16:32:59 +08:00
|
|
|
if (rtc_policy_slew_deliver_irq(s)) {
|
2009-04-23 04:20:22 +08:00
|
|
|
s->irq_coalesced--;
|
2010-05-31 03:20:07 +08:00
|
|
|
DPRINTF_C("cmos: coalesced irqs decreased to %d\n",
|
|
|
|
s->irq_coalesced);
|
2009-04-23 04:20:22 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rtc_coalesced_timer_update(s);
|
|
|
|
}
|
2017-05-10 16:32:59 +08:00
|
|
|
#else
|
|
|
|
static bool rtc_policy_slew_deliver_irq(RTCState *s)
|
|
|
|
{
|
|
|
|
assert(0);
|
|
|
|
return false;
|
|
|
|
}
|
2009-04-23 04:20:22 +08:00
|
|
|
#endif
|
|
|
|
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
static uint32_t rtc_periodic_clock_ticks(RTCState *s)
|
2004-04-01 02:57:29 +08:00
|
|
|
{
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
int period_code;
|
|
|
|
|
|
|
|
if (!(s->cmos_data[RTC_REG_B] & REG_B_PIE)) {
|
|
|
|
return 0;
|
|
|
|
}
|
2004-04-01 02:57:29 +08:00
|
|
|
|
|
|
|
period_code = s->cmos_data[RTC_REG_A] & 0x0f;
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
|
2017-05-27 10:53:01 +08:00
|
|
|
return periodic_period_to_clock(period_code);
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* handle periodic timer. @old_period indicates the periodic timer update
|
|
|
|
* is just due to period adjustment.
|
|
|
|
*/
|
|
|
|
static void
|
2019-11-17 17:28:14 +08:00
|
|
|
periodic_timer_update(RTCState *s, int64_t current_time, uint32_t old_period, bool period_change)
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
{
|
|
|
|
uint32_t period;
|
|
|
|
int64_t cur_clock, next_irq_clock, lost_clock = 0;
|
|
|
|
|
|
|
|
period = rtc_periodic_clock_ticks(s);
|
2019-11-17 17:28:14 +08:00
|
|
|
s->period = period;
|
|
|
|
|
2019-10-10 20:30:08 +08:00
|
|
|
if (!period) {
|
|
|
|
s->irq_coalesced = 0;
|
|
|
|
timer_del(s->periodic_timer);
|
|
|
|
return;
|
|
|
|
}
|
2016-03-22 00:02:30 +08:00
|
|
|
|
2019-10-10 20:30:08 +08:00
|
|
|
/* compute 32 khz clock */
|
|
|
|
cur_clock =
|
|
|
|
muldiv64(current_time, RTC_CLOCK_RATE, NANOSECONDS_PER_SECOND);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if the periodic timer's update is due to period re-configuration,
|
|
|
|
* we should count the clock since last interrupt.
|
|
|
|
*/
|
2019-11-17 17:28:14 +08:00
|
|
|
if (old_period && period_change) {
|
2019-10-10 20:30:08 +08:00
|
|
|
int64_t last_periodic_clock, next_periodic_clock;
|
|
|
|
|
|
|
|
next_periodic_clock = muldiv64(s->next_periodic_time,
|
|
|
|
RTC_CLOCK_RATE, NANOSECONDS_PER_SECOND);
|
|
|
|
last_periodic_clock = next_periodic_clock - old_period;
|
|
|
|
lost_clock = cur_clock - last_periodic_clock;
|
|
|
|
assert(lost_clock >= 0);
|
2019-11-17 17:07:38 +08:00
|
|
|
}
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
|
2019-11-17 17:07:38 +08:00
|
|
|
/*
|
|
|
|
* s->irq_coalesced can change for two reasons:
|
|
|
|
*
|
|
|
|
* a) if one or more periodic timer interrupts have been lost,
|
|
|
|
* lost_clock will be more that a period.
|
|
|
|
*
|
|
|
|
* b) when the period may be reconfigured, we expect the OS to
|
|
|
|
* treat delayed tick as the new period. So, when switching
|
|
|
|
* from a shorter to a longer period, scale down the missing,
|
|
|
|
* because the OS will treat past delayed ticks as longer
|
|
|
|
* (leftovers are put back into lost_clock). When switching
|
|
|
|
* to a shorter period, scale up the missing ticks since the
|
|
|
|
* OS handler will treat past delayed ticks as shorter.
|
|
|
|
*/
|
|
|
|
if (s->lost_tick_policy == LOST_TICK_POLICY_SLEW) {
|
|
|
|
uint32_t old_irq_coalesced = s->irq_coalesced;
|
|
|
|
|
|
|
|
lost_clock += old_irq_coalesced * old_period;
|
|
|
|
s->irq_coalesced = lost_clock / s->period;
|
|
|
|
lost_clock %= s->period;
|
|
|
|
if (old_irq_coalesced != s->irq_coalesced ||
|
|
|
|
old_period != s->period) {
|
|
|
|
DPRINTF_C("cmos: coalesced irqs scaled from %d to %d, "
|
|
|
|
"period scaled from %d to %d\n", old_irq_coalesced,
|
|
|
|
s->irq_coalesced, old_period, s->period);
|
|
|
|
rtc_coalesced_timer_update(s);
|
|
|
|
}
|
|
|
|
} else {
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
/*
|
2019-11-17 17:07:38 +08:00
|
|
|
* no way to compensate the interrupt if LOST_TICK_POLICY_SLEW
|
|
|
|
* is not used, we should make the time progress anyway.
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
*/
|
2019-11-17 17:07:38 +08:00
|
|
|
lost_clock = MIN(lost_clock, period);
|
2019-10-10 20:30:08 +08:00
|
|
|
}
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
|
2019-10-10 20:30:08 +08:00
|
|
|
assert(lost_clock >= 0 && lost_clock <= period);
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
|
2019-10-10 20:30:08 +08:00
|
|
|
next_irq_clock = cur_clock + period - lost_clock;
|
|
|
|
s->next_periodic_time = periodic_clock_to_ns(next_irq_clock) + 1;
|
|
|
|
timer_mod(s->periodic_timer, s->next_periodic_time);
|
2004-04-01 02:57:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rtc_periodic_timer(void *opaque)
|
|
|
|
{
|
|
|
|
RTCState *s = opaque;
|
|
|
|
|
2019-11-17 17:28:14 +08:00
|
|
|
periodic_timer_update(s, s->next_periodic_time, s->period, false);
|
2011-11-22 02:00:30 +08:00
|
|
|
s->cmos_data[RTC_REG_C] |= REG_C_PF;
|
2009-04-08 06:28:50 +08:00
|
|
|
if (s->cmos_data[RTC_REG_B] & REG_B_PIE) {
|
2011-11-22 02:00:30 +08:00
|
|
|
s->cmos_data[RTC_REG_C] |= REG_C_IRQF;
|
2014-02-08 18:01:55 +08:00
|
|
|
if (s->lost_tick_policy == LOST_TICK_POLICY_SLEW) {
|
2009-12-08 21:50:54 +08:00
|
|
|
if (s->irq_reinject_on_ack_count >= RTC_REINJECT_ON_ACK_COUNT)
|
2017-05-10 16:32:59 +08:00
|
|
|
s->irq_reinject_on_ack_count = 0;
|
|
|
|
if (!rtc_policy_slew_deliver_irq(s)) {
|
2009-04-23 04:20:22 +08:00
|
|
|
s->irq_coalesced++;
|
|
|
|
rtc_coalesced_timer_update(s);
|
2010-05-31 03:20:07 +08:00
|
|
|
DPRINTF_C("cmos: coalesced irqs increased to %d\n",
|
|
|
|
s->irq_coalesced);
|
2009-04-23 04:20:22 +08:00
|
|
|
}
|
|
|
|
} else
|
2017-05-10 16:32:59 +08:00
|
|
|
qemu_irq_raise(s->irq);
|
2009-04-08 06:28:50 +08:00
|
|
|
}
|
2004-04-01 02:57:29 +08:00
|
|
|
}
|
2004-03-14 20:20:30 +08:00
|
|
|
|
2012-08-03 00:04:09 +08:00
|
|
|
/* handle update-ended timer */
|
|
|
|
static void check_update_timer(RTCState *s)
|
|
|
|
{
|
|
|
|
uint64_t next_update_time;
|
|
|
|
uint64_t guest_nsec;
|
2012-08-03 00:04:11 +08:00
|
|
|
int next_alarm_sec;
|
2012-08-03 00:04:09 +08:00
|
|
|
|
2012-08-03 00:04:10 +08:00
|
|
|
/* From the data sheet: "Holding the dividers in reset prevents
|
|
|
|
* interrupts from operating, while setting the SET bit allows"
|
2017-07-25 20:35:35 +08:00
|
|
|
* them to occur.
|
2012-08-03 00:04:09 +08:00
|
|
|
*/
|
2012-08-03 00:04:10 +08:00
|
|
|
if ((s->cmos_data[RTC_REG_A] & 0x60) == 0x60) {
|
2017-07-25 20:55:38 +08:00
|
|
|
assert((s->cmos_data[RTC_REG_A] & REG_A_UIP) == 0);
|
2013-08-21 23:03:08 +08:00
|
|
|
timer_del(s->update_timer);
|
2012-08-03 00:04:10 +08:00
|
|
|
return;
|
|
|
|
}
|
2012-08-03 00:04:09 +08:00
|
|
|
|
2015-07-08 22:10:09 +08:00
|
|
|
guest_nsec = get_guest_rtc_ns(s) % NANOSECONDS_PER_SECOND;
|
2013-08-21 23:03:04 +08:00
|
|
|
next_update_time = qemu_clock_get_ns(rtc_clock)
|
2015-07-08 22:10:09 +08:00
|
|
|
+ NANOSECONDS_PER_SECOND - guest_nsec;
|
2012-08-03 00:04:11 +08:00
|
|
|
|
|
|
|
/* Compute time of next alarm. One second is already accounted
|
|
|
|
* for in next_update_time.
|
|
|
|
*/
|
|
|
|
next_alarm_sec = get_next_alarm(s);
|
2015-07-08 22:10:09 +08:00
|
|
|
s->next_alarm_time = next_update_time +
|
|
|
|
(next_alarm_sec - 1) * NANOSECONDS_PER_SECOND;
|
2012-08-03 00:04:11 +08:00
|
|
|
|
2017-07-25 20:55:38 +08:00
|
|
|
/* If update_in_progress latched the UIP bit, we must keep the timer
|
|
|
|
* programmed to the next second, so that UIP is cleared. Otherwise,
|
|
|
|
* if UF is already set, we might be able to optimize.
|
|
|
|
*/
|
|
|
|
if (!(s->cmos_data[RTC_REG_A] & REG_A_UIP) &&
|
|
|
|
(s->cmos_data[RTC_REG_C] & REG_C_UF)) {
|
2017-07-25 20:35:35 +08:00
|
|
|
/* If AF cannot change (i.e. either it is set already, or
|
|
|
|
* SET=1 and then the time is not updated), nothing to do.
|
|
|
|
*/
|
|
|
|
if ((s->cmos_data[RTC_REG_B] & REG_B_SET) ||
|
|
|
|
(s->cmos_data[RTC_REG_C] & REG_C_AF)) {
|
|
|
|
timer_del(s->update_timer);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-08-03 00:04:11 +08:00
|
|
|
/* 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 23:02:39 +08:00
|
|
|
if (next_update_time != timer_expire_time_ns(s->update_timer)) {
|
2013-08-21 23:03:08 +08:00
|
|
|
timer_mod(s->update_timer, next_update_time);
|
2012-08-03 00:04:09 +08: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-03 00:04:11 +08:00
|
|
|
static uint64_t get_next_alarm(RTCState *s)
|
2012-08-03 00:04:09 +08:00
|
|
|
{
|
2012-08-03 00:04:11 +08: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-03 00:04:09 +08: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-03 00:04:11 +08:00
|
|
|
alarm_hour = alarm_hour == -1 ? -1 : convert_hour(s, alarm_hour);
|
2012-08-03 00:04:09 +08: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-03 00:04:11 +08: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-03 00:04:09 +08:00
|
|
|
}
|
|
|
|
|
2012-08-03 00:04:11 +08: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-03 00:04:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rtc_update_timer(void *opaque)
|
|
|
|
{
|
|
|
|
RTCState *s = opaque;
|
|
|
|
int32_t irqs = REG_C_UF;
|
|
|
|
int32_t new_irqs;
|
|
|
|
|
2012-08-03 00:04:10 +08:00
|
|
|
assert((s->cmos_data[RTC_REG_A] & 0x60) != 0x60);
|
|
|
|
|
2012-08-03 00:04:09 +08: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 23:03:04 +08:00
|
|
|
if (qemu_clock_get_ns(rtc_clock) >= s->next_alarm_time) {
|
2012-08-03 00:04:09 +08:00
|
|
|
irqs |= REG_C_AF;
|
|
|
|
if (s->cmos_data[RTC_REG_B] & REG_B_AIE) {
|
qmp hmp: Make system_wakeup check wake-up support and run state
The qmp/hmp command 'system_wakeup' is simply a direct call to
'qemu_system_wakeup_request' from vl.c. This function verifies if
runstate is SUSPENDED and if the wake up reason is valid before
proceeding. However, no error or warning is thrown if any of those
pre-requirements isn't met. There is no way for the caller to
differentiate between a successful wakeup or an error state caused
when trying to wake up a guest that wasn't suspended.
This means that system_wakeup is silently failing, which can be
considered a bug. Adding error handling isn't an API break in this
case - applications that didn't check the result will remain broken,
the ones that check it will have a chance to deal with it.
Adding to that, the commit before previous created a new QMP API called
query-current-machine, with a new flag called wakeup-suspend-support,
that indicates if the guest has the capability of waking up from suspended
state. Although such guest will never reach SUSPENDED state and erroring
it out in this scenario would suffice, it is more informative for the user
to differentiate between a failure because the guest isn't suspended versus
a failure because the guest does not have support for wake up at all.
All this considered, this patch changes qmp_system_wakeup to check if
the guest is capable of waking up from suspend, and if it is suspended.
After this patch, this is the output of system_wakeup in a guest that
does not have wake-up from suspend support (ppc64):
(qemu) system_wakeup
wake-up from suspend is not supported by this guest
(qemu)
And this is the output of system_wakeup in a x86 guest that has the
support but isn't suspended:
(qemu) system_wakeup
Unable to wake up: guest is not in suspended state
(qemu)
Reported-by: Balamuruhan S <bala24@linux.vnet.ibm.com>
Signed-off-by: Daniel Henrique Barboza <danielhb413@gmail.com>
Message-Id: <20181205194701.17836-4-danielhb413@gmail.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2018-12-06 03:47:01 +08:00
|
|
|
qemu_system_wakeup_request(QEMU_WAKEUP_REASON_RTC, NULL);
|
2012-08-03 00:04:09 +08:00
|
|
|
}
|
|
|
|
}
|
2012-08-03 00:04:11 +08:00
|
|
|
|
2012-08-03 00:04:09 +08: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 19:22:28 +08:00
|
|
|
static void cmos_ioport_write(void *opaque, hwaddr addr,
|
|
|
|
uint64_t data, unsigned size)
|
2004-03-14 20:20:30 +08:00
|
|
|
{
|
2004-03-15 05:46:48 +08:00
|
|
|
RTCState *s = opaque;
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
uint32_t old_period;
|
2017-05-10 16:32:55 +08:00
|
|
|
bool update_periodic_timer;
|
2004-03-14 20:20:30 +08:00
|
|
|
|
|
|
|
if ((addr & 1) == 0) {
|
|
|
|
s->cmos_index = data & 0x7f;
|
|
|
|
} else {
|
Fix debug print warning
Steps:
1.enable qemu debug print, using simply scprit as below:
grep "//#define DEBUG" * -rl | xargs sed -i "s/\/\/#define DEBUG/#define DEBUG/g"
2. make -j
3. get some warning:
hw/i2c/pm_smbus.c: In function 'smb_ioport_writeb':
hw/i2c/pm_smbus.c:142: warning: format '%04x' expects type 'unsigned int', but argument 2 has type 'hwaddr'
hw/i2c/pm_smbus.c:142: warning: format '%02x' expects type 'unsigned int', but argument 3 has type 'uint64_t'
hw/i2c/pm_smbus.c: In function 'smb_ioport_readb':
hw/i2c/pm_smbus.c:209: warning: format '%04x' expects type 'unsigned int', but argument 2 has type 'hwaddr'
hw/intc/i8259.c: In function 'pic_ioport_read':
hw/intc/i8259.c:373: warning: format '%02x' expects type 'unsigned int', but argument 2 has type 'hwaddr'
hw/input/pckbd.c: In function 'kbd_write_command':
hw/input/pckbd.c:232: warning: format '%02x' expects type 'unsigned int', but argument 2 has type 'uint64_t'
hw/input/pckbd.c: In function 'kbd_write_data':
hw/input/pckbd.c:333: warning: format '%02x' expects type 'unsigned int', but argument 2 has type 'uint64_t'
hw/isa/apm.c: In function 'apm_ioport_writeb':
hw/isa/apm.c:44: warning: format '%x' expects type 'unsigned int', but argument 2 has type 'hwaddr'
hw/isa/apm.c:44: warning: format '%02x' expects type 'unsigned int', but argument 3 has type 'uint64_t'
hw/isa/apm.c: In function 'apm_ioport_readb':
hw/isa/apm.c:67: warning: format '%x' expects type 'unsigned int', but argument 2 has type 'hwaddr'
hw/timer/mc146818rtc.c: In function 'cmos_ioport_write':
hw/timer/mc146818rtc.c:394: warning: format '%02x' expects type 'unsigned int', but argument 3 has type 'uint64_t'
hw/i386/pc.c: In function 'port92_write':
hw/i386/pc.c:479: warning: format '%02x' expects type 'unsigned int', but argument 2 has type 'uint64_t'
Fix them.
Cc: qemu-trivial@nongnu.org
Signed-off-by: Gonglei <arei.gonglei@huawei.com>
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2014-08-25 10:01:27 +08:00
|
|
|
CMOS_DPRINTF("cmos: write index=0x%02x val=0x%02" PRIx64 "\n",
|
2010-05-14 15:29:24 +08:00
|
|
|
s->cmos_index, data);
|
2004-04-01 02:57:29 +08:00
|
|
|
switch(s->cmos_index) {
|
2004-03-14 20:20:30 +08:00
|
|
|
case RTC_SECONDS_ALARM:
|
|
|
|
case RTC_MINUTES_ALARM:
|
|
|
|
case RTC_HOURS_ALARM:
|
|
|
|
s->cmos_data[s->cmos_index] = data;
|
2012-08-03 00:04:09 +08:00
|
|
|
check_update_timer(s);
|
2004-03-14 20:20:30 +08:00
|
|
|
break;
|
2018-08-16 19:35:53 +08:00
|
|
|
case RTC_IBM_PS2_CENTURY_BYTE:
|
2012-10-01 20:22:07 +08:00
|
|
|
s->cmos_index = RTC_CENTURY;
|
|
|
|
/* fall through */
|
|
|
|
case RTC_CENTURY:
|
2004-03-14 20:20:30 +08: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-04-01 02:57:29 +08:00
|
|
|
/* if in set mode, do not update the time */
|
2012-08-03 00:04:10 +08:00
|
|
|
if (rtc_running(s)) {
|
2004-04-01 02:57:29 +08:00
|
|
|
rtc_set_time(s);
|
2012-08-03 00:04:09 +08:00
|
|
|
check_update_timer(s);
|
2004-04-01 02:57:29 +08:00
|
|
|
}
|
2004-03-14 20:20:30 +08:00
|
|
|
break;
|
|
|
|
case RTC_REG_A:
|
2017-05-10 16:32:55 +08:00
|
|
|
update_periodic_timer = (s->cmos_data[RTC_REG_A] ^ data) & 0x0f;
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
old_period = rtc_periodic_clock_ticks(s);
|
2017-05-10 16:32:55 +08:00
|
|
|
|
2012-08-03 00:04:10 +08: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-04-01 02:57:29 +08: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);
|
2017-05-10 16:32:55 +08:00
|
|
|
|
|
|
|
if (update_periodic_timer) {
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
periodic_timer_update(s, qemu_clock_get_ns(rtc_clock),
|
2019-11-17 17:28:14 +08:00
|
|
|
old_period, true);
|
2017-05-10 16:32:55 +08:00
|
|
|
}
|
|
|
|
|
2012-08-03 00:04:09 +08:00
|
|
|
check_update_timer(s);
|
2004-04-01 02:57:29 +08:00
|
|
|
break;
|
2004-03-14 20:20:30 +08:00
|
|
|
case RTC_REG_B:
|
2017-05-10 16:32:55 +08:00
|
|
|
update_periodic_timer = (s->cmos_data[RTC_REG_B] ^ data)
|
|
|
|
& REG_B_PIE;
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
old_period = rtc_periodic_clock_ticks(s);
|
2017-05-10 16:32:55 +08:00
|
|
|
|
2004-04-01 02:57:29 +08:00
|
|
|
if (data & REG_B_SET) {
|
2012-08-03 00:04:09 +08:00
|
|
|
/* update cmos to when the rtc was stopping */
|
2012-08-03 00:04:10 +08:00
|
|
|
if (rtc_running(s)) {
|
2012-08-03 00:04:09 +08:00
|
|
|
rtc_update_time(s);
|
|
|
|
}
|
2004-04-01 02:57:29 +08: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-03 00:04:10 +08:00
|
|
|
if ((s->cmos_data[RTC_REG_B] & REG_B_SET) &&
|
|
|
|
(s->cmos_data[RTC_REG_A] & 0x70) <= 0x20) {
|
2015-07-08 22:10:09 +08:00
|
|
|
s->offset = get_guest_rtc_ns(s) % NANOSECONDS_PER_SECOND;
|
2004-04-01 02:57:29 +08:00
|
|
|
rtc_set_time(s);
|
|
|
|
}
|
|
|
|
}
|
2012-08-03 00:04:07 +08: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-03 00:04:04 +08:00
|
|
|
s->cmos_data[RTC_REG_B] = data;
|
2017-05-10 16:32:55 +08:00
|
|
|
|
|
|
|
if (update_periodic_timer) {
|
mc146818rtc: precisely count the clock for periodic timer
There are two issues in current code:
1) If the period is changed by re-configuring RegA, the coalesced
irq will be scaled to reflect the new period, however, it
calculates the new interrupt number like this:
s->irq_coalesced = (s->irq_coalesced * s->period) / period;
There are some clocks will be lost if they are not enough to
be squeezed to a single new period that will cause the VM clock
slower
In order to fix the issue, we calculate the interrupt window
based on the precise clock rather than period, then the clocks
lost during period is scaled can be compensated properly
2) If periodic_timer_update() is called due to RegA reconfiguration,
i.e, the period is updated, current time is not the start point
for the next periodic timer, instead, which should start from the
last interrupt, otherwise, the clock in VM will become slow
This patch takes the clocks from last interrupt to current clock
into account and compensates the clocks for the next interrupt,
especially if a complete interrupt was lost in this window, the
time can be caught up by LOST_TICK_POLICY_SLEW
Signed-off-by: Tai Yunfang <yunfangtai@tencent.com>
Signed-off-by: Xiao Guangrong <xiaoguangrong@tencent.com>
Message-Id: <20170510083259.3900-3-xiaoguangrong@tencent.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2017-05-10 16:32:56 +08:00
|
|
|
periodic_timer_update(s, qemu_clock_get_ns(rtc_clock),
|
2019-11-17 17:28:14 +08:00
|
|
|
old_period, true);
|
2017-05-10 16:32:55 +08:00
|
|
|
}
|
|
|
|
|
2012-08-03 00:04:09 +08:00
|
|
|
check_update_timer(s);
|
2004-03-14 20:20:30 +08: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 08:03:47 +08:00
|
|
|
static inline int rtc_to_bcd(RTCState *s, int a)
|
2004-03-14 20:20:30 +08:00
|
|
|
{
|
2009-01-15 05:09:07 +08:00
|
|
|
if (s->cmos_data[RTC_REG_B] & REG_B_DM) {
|
2004-04-01 02:57:29 +08:00
|
|
|
return a;
|
|
|
|
} else {
|
|
|
|
return ((a / 10) << 4) | (a % 10);
|
|
|
|
}
|
2004-03-14 20:20:30 +08:00
|
|
|
}
|
|
|
|
|
2009-11-20 08:03:47 +08:00
|
|
|
static inline int rtc_from_bcd(RTCState *s, int a)
|
2004-03-14 20:20:30 +08:00
|
|
|
{
|
2012-08-03 00:04:11 +08:00
|
|
|
if ((a & 0xc0) == 0xc0) {
|
|
|
|
return -1;
|
|
|
|
}
|
2009-01-15 05:09:07 +08:00
|
|
|
if (s->cmos_data[RTC_REG_B] & REG_B_DM) {
|
2004-04-01 02:57:29 +08:00
|
|
|
return a;
|
|
|
|
} else {
|
|
|
|
return ((a >> 4) * 10) + (a & 0x0f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-03 00:04:12 +08:00
|
|
|
static void rtc_get_time(RTCState *s, struct tm *tm)
|
2004-04-01 02:57:29 +08:00
|
|
|
{
|
2009-11-20 08:03:47 +08: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-22 02:00:28 +08: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 20:51:19 +08:00
|
|
|
}
|
2009-11-20 08:03:47 +08: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 20:22:08 +08: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-03 00:04:12 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rtc_set_time(RTCState *s)
|
|
|
|
{
|
|
|
|
struct tm tm;
|
2010-02-25 23:11:44 +08:00
|
|
|
|
2012-08-03 00:04:12 +08:00
|
|
|
rtc_get_time(s, &tm);
|
|
|
|
s->base_rtc = mktimegm(&tm);
|
2013-08-21 23:03:04 +08:00
|
|
|
s->last_update = qemu_clock_get_ns(rtc_clock);
|
2012-08-03 00:04:09 +08:00
|
|
|
|
2018-08-15 21:37:37 +08:00
|
|
|
qapi_event_send_rtc_change(qemu_timedate_diff(&tm));
|
2004-06-03 20:51:19 +08:00
|
|
|
}
|
|
|
|
|
2012-08-03 00:04:12 +08:00
|
|
|
static void rtc_set_cmos(RTCState *s, const struct tm *tm)
|
2004-06-03 20:51:19 +08:00
|
|
|
{
|
2009-01-25 02:06:21 +08:00
|
|
|
int year;
|
2004-04-01 02:57:29 +08:00
|
|
|
|
2009-11-20 08:03:47 +08: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 18:55:15 +08:00
|
|
|
if (s->cmos_data[RTC_REG_B] & REG_B_24H) {
|
2004-06-03 20:51:19 +08:00
|
|
|
/* 24 hour format */
|
2009-11-20 08:03:47 +08:00
|
|
|
s->cmos_data[RTC_HOURS] = rtc_to_bcd(s, tm->tm_hour);
|
2004-06-03 20:51:19 +08:00
|
|
|
} else {
|
|
|
|
/* 12 hour format */
|
2011-11-22 02:00:28 +08: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 20:51:19 +08:00
|
|
|
if (tm->tm_hour >= 12)
|
|
|
|
s->cmos_data[RTC_HOURS] |= 0x80;
|
|
|
|
}
|
2009-11-20 08:03:47 +08: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 20:22:08 +08: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 20:51:19 +08:00
|
|
|
}
|
|
|
|
|
2012-08-03 00:04:09 +08:00
|
|
|
static void rtc_update_time(RTCState *s)
|
2004-06-03 20:51:19 +08:00
|
|
|
{
|
2012-08-03 00:04:09 +08:00
|
|
|
struct tm ret;
|
|
|
|
time_t guest_sec;
|
|
|
|
int64_t guest_nsec;
|
|
|
|
|
|
|
|
guest_nsec = get_guest_rtc_ns(s);
|
2015-07-08 22:10:09 +08:00
|
|
|
guest_sec = guest_nsec / NANOSECONDS_PER_SECOND;
|
2012-08-03 00:04:09 +08:00
|
|
|
gmtime_r(&guest_sec, &ret);
|
2012-11-27 00:32:54 +08: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 20:51:19 +08:00
|
|
|
}
|
|
|
|
|
2012-08-03 00:04:09 +08:00
|
|
|
static int update_in_progress(RTCState *s)
|
2004-06-03 20:51:19 +08:00
|
|
|
{
|
2012-08-03 00:04:09 +08:00
|
|
|
int64_t guest_nsec;
|
2007-09-17 16:09:54 +08:00
|
|
|
|
2012-08-03 00:04:10 +08:00
|
|
|
if (!rtc_running(s)) {
|
2012-08-03 00:04:09 +08:00
|
|
|
return 0;
|
2004-04-01 02:57:29 +08:00
|
|
|
}
|
2013-08-21 23:02:39 +08:00
|
|
|
if (timer_pending(s->update_timer)) {
|
|
|
|
int64_t next_update_time = timer_expire_time_ns(s->update_timer);
|
2012-08-03 00:04:09 +08:00
|
|
|
/* Latch UIP until the timer expires. */
|
2013-08-21 23:03:04 +08:00
|
|
|
if (qemu_clock_get_ns(rtc_clock) >=
|
|
|
|
(next_update_time - UIP_HOLD_LENGTH)) {
|
2012-08-03 00:04:09 +08:00
|
|
|
s->cmos_data[RTC_REG_A] |= REG_A_UIP;
|
|
|
|
return 1;
|
2004-04-01 02:57:29 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-03 00:04:09 +08:00
|
|
|
guest_nsec = get_guest_rtc_ns(s);
|
|
|
|
/* UIP bit will be set at last 244us of every second. */
|
2015-07-08 22:10:09 +08:00
|
|
|
if ((guest_nsec % NANOSECONDS_PER_SECOND) >=
|
|
|
|
(NANOSECONDS_PER_SECOND - UIP_HOLD_LENGTH)) {
|
2012-08-03 00:04:09 +08:00
|
|
|
return 1;
|
2004-04-01 02:57:29 +08:00
|
|
|
}
|
2012-08-03 00:04:09 +08:00
|
|
|
return 0;
|
2004-03-14 20:20:30 +08:00
|
|
|
}
|
|
|
|
|
2012-10-08 19:22:28 +08:00
|
|
|
static uint64_t cmos_ioport_read(void *opaque, hwaddr addr,
|
|
|
|
unsigned size)
|
2004-03-14 20:20:30 +08:00
|
|
|
{
|
2004-03-15 05:46:48 +08:00
|
|
|
RTCState *s = opaque;
|
2004-03-14 20:20:30 +08:00
|
|
|
int ret;
|
|
|
|
if ((addr & 1) == 0) {
|
|
|
|
return 0xff;
|
|
|
|
} else {
|
|
|
|
switch(s->cmos_index) {
|
2018-08-16 19:35:53 +08:00
|
|
|
case RTC_IBM_PS2_CENTURY_BYTE:
|
2012-10-01 20:22:07 +08:00
|
|
|
s->cmos_index = RTC_CENTURY;
|
|
|
|
/* fall through */
|
|
|
|
case RTC_CENTURY:
|
2004-03-14 20:20:30 +08: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-03 00:04:09 +08:00
|
|
|
/* if not in set mode, calibrate cmos before
|
|
|
|
* reading*/
|
2012-08-03 00:04:10 +08:00
|
|
|
if (rtc_running(s)) {
|
2012-08-03 00:04:09 +08:00
|
|
|
rtc_update_time(s);
|
|
|
|
}
|
2004-03-14 20:20:30 +08:00
|
|
|
ret = s->cmos_data[s->cmos_index];
|
|
|
|
break;
|
|
|
|
case RTC_REG_A:
|
2017-07-25 20:55:38 +08:00
|
|
|
ret = s->cmos_data[s->cmos_index];
|
2012-08-03 00:04:09 +08:00
|
|
|
if (update_in_progress(s)) {
|
2017-07-25 20:55:38 +08:00
|
|
|
ret |= REG_A_UIP;
|
2012-08-03 00:04:09 +08:00
|
|
|
}
|
2004-03-14 20:20:30 +08:00
|
|
|
break;
|
|
|
|
case RTC_REG_C:
|
|
|
|
ret = s->cmos_data[s->cmos_index];
|
2007-04-08 02:14:41 +08:00
|
|
|
qemu_irq_lower(s->irq);
|
2011-11-22 02:00:31 +08:00
|
|
|
s->cmos_data[RTC_REG_C] = 0x00;
|
2012-08-03 00:04:09 +08:00
|
|
|
if (ret & (REG_C_UF | REG_C_AF)) {
|
|
|
|
check_update_timer(s);
|
|
|
|
}
|
2017-05-10 16:32:59 +08:00
|
|
|
|
2009-12-08 21:50:54 +08:00
|
|
|
if(s->irq_coalesced &&
|
2011-11-22 02:00:31 +08:00
|
|
|
(s->cmos_data[RTC_REG_B] & REG_B_PIE) &&
|
2009-12-08 21:50:54 +08:00
|
|
|
s->irq_reinject_on_ack_count < RTC_REINJECT_ON_ACK_COUNT) {
|
|
|
|
s->irq_reinject_on_ack_count++;
|
2011-11-22 02:00:31 +08:00
|
|
|
s->cmos_data[RTC_REG_C] |= REG_C_IRQF | REG_C_PF;
|
2010-05-31 03:20:07 +08:00
|
|
|
DPRINTF_C("cmos: injecting on ack\n");
|
2017-05-10 16:32:59 +08:00
|
|
|
if (rtc_policy_slew_deliver_irq(s)) {
|
2009-12-08 21:50:54 +08:00
|
|
|
s->irq_coalesced--;
|
2010-05-31 03:20:07 +08:00
|
|
|
DPRINTF_C("cmos: coalesced irqs decreased to %d\n",
|
|
|
|
s->irq_coalesced);
|
|
|
|
}
|
2009-12-08 21:50:54 +08:00
|
|
|
}
|
2004-03-14 20:20:30 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = s->cmos_data[s->cmos_index];
|
|
|
|
break;
|
|
|
|
}
|
2010-05-14 15:29:24 +08:00
|
|
|
CMOS_DPRINTF("cmos: read index=0x%02x val=0x%02x\n",
|
|
|
|
s->cmos_index, ret);
|
2004-03-14 20:20:30 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-14 15:29:17 +08:00
|
|
|
void rtc_set_memory(ISADevice *dev, int addr, int val)
|
2004-04-01 02:57:29 +08:00
|
|
|
{
|
2013-04-28 04:18:43 +08:00
|
|
|
RTCState *s = MC146818_RTC(dev);
|
2004-04-01 02:57:29 +08:00
|
|
|
if (addr >= 0 && addr <= 127)
|
|
|
|
s->cmos_data[addr] = val;
|
|
|
|
}
|
|
|
|
|
2013-04-23 16:29:40 +08: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 15:29:17 +08:00
|
|
|
static void rtc_set_date_from_host(ISADevice *dev)
|
2006-12-08 01:16:55 +08:00
|
|
|
{
|
2013-04-28 04:18:43 +08:00
|
|
|
RTCState *s = MC146818_RTC(dev);
|
2008-02-17 19:42:19 +08:00
|
|
|
struct tm tm;
|
2006-12-08 01:16:55 +08:00
|
|
|
|
2008-02-17 19:42:19 +08:00
|
|
|
qemu_get_timedate(&tm, 0);
|
2012-08-03 00:04:09 +08:00
|
|
|
|
|
|
|
s->base_rtc = mktimegm(&tm);
|
2013-08-21 23:03:04 +08:00
|
|
|
s->last_update = qemu_clock_get_ns(rtc_clock);
|
2012-08-03 00:04:09 +08:00
|
|
|
s->offset = 0;
|
|
|
|
|
|
|
|
/* set the CMOS date */
|
2012-08-03 00:04:12 +08:00
|
|
|
rtc_set_cmos(s, &tm);
|
2006-12-08 01:16:55 +08:00
|
|
|
}
|
|
|
|
|
2017-09-25 19:29:12 +08:00
|
|
|
static int rtc_pre_save(void *opaque)
|
MC146818 RTC: coordinate guest clock base to destination host after migration
qemu tracks guest time based on vector [base_rtc, last_update], in which
last_update stands for a monotonic tick which is actually uptime of the
host.
according to rtc implementation codes of recent releases and upstream,
after
migration, the time base vector [base_rtc, last_update] isn't updated to
coordinate with the destionation host, ie. qemu doesnt update last_update
to
uptime of the destination host.
what problem have we got because of this bug? after migration, guest time
may
jump back to several days ago, that will make some critical business
applications,
such as lotus notes, malfunction.
this patch is trying to fix the problem. first, when vmsave in progress,
we
rtc_update_time to refresh time stamp in cmos array, then during
vmrestore,
we rtc_set_time to update qemu base_rtc and last_update variable according
to time
stamp in cmos array.
Signed-off-by: Junlian Bell <zhongjun@sangfor.com.cn>
Message-Id: <20160926124101.2364-1-zhongjun@sangfor.com.cn>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-09-26 20:41:01 +08:00
|
|
|
{
|
|
|
|
RTCState *s = opaque;
|
|
|
|
|
|
|
|
rtc_update_time(s);
|
2017-09-25 19:29:12 +08:00
|
|
|
|
|
|
|
return 0;
|
MC146818 RTC: coordinate guest clock base to destination host after migration
qemu tracks guest time based on vector [base_rtc, last_update], in which
last_update stands for a monotonic tick which is actually uptime of the
host.
according to rtc implementation codes of recent releases and upstream,
after
migration, the time base vector [base_rtc, last_update] isn't updated to
coordinate with the destionation host, ie. qemu doesnt update last_update
to
uptime of the destination host.
what problem have we got because of this bug? after migration, guest time
may
jump back to several days ago, that will make some critical business
applications,
such as lotus notes, malfunction.
this patch is trying to fix the problem. first, when vmsave in progress,
we
rtc_update_time to refresh time stamp in cmos array, then during
vmrestore,
we rtc_set_time to update qemu base_rtc and last_update variable according
to time
stamp in cmos array.
Signed-off-by: Junlian Bell <zhongjun@sangfor.com.cn>
Message-Id: <20160926124101.2364-1-zhongjun@sangfor.com.cn>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-09-26 20:41:01 +08:00
|
|
|
}
|
|
|
|
|
2009-10-08 06:12:06 +08:00
|
|
|
static int rtc_post_load(void *opaque, int version_id)
|
2004-03-14 20:20:30 +08:00
|
|
|
{
|
2004-04-01 02:57:29 +08:00
|
|
|
RTCState *s = opaque;
|
|
|
|
|
MC146818 RTC: coordinate guest clock base to destination host after migration
qemu tracks guest time based on vector [base_rtc, last_update], in which
last_update stands for a monotonic tick which is actually uptime of the
host.
according to rtc implementation codes of recent releases and upstream,
after
migration, the time base vector [base_rtc, last_update] isn't updated to
coordinate with the destionation host, ie. qemu doesnt update last_update
to
uptime of the destination host.
what problem have we got because of this bug? after migration, guest time
may
jump back to several days ago, that will make some critical business
applications,
such as lotus notes, malfunction.
this patch is trying to fix the problem. first, when vmsave in progress,
we
rtc_update_time to refresh time stamp in cmos array, then during
vmrestore,
we rtc_set_time to update qemu base_rtc and last_update variable according
to time
stamp in cmos array.
Signed-off-by: Junlian Bell <zhongjun@sangfor.com.cn>
Message-Id: <20160926124101.2364-1-zhongjun@sangfor.com.cn>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-09-26 20:41:01 +08:00
|
|
|
if (version_id <= 2 || rtc_clock == QEMU_CLOCK_REALTIME) {
|
2012-08-03 00:04:09 +08:00
|
|
|
rtc_set_time(s);
|
|
|
|
s->offset = 0;
|
|
|
|
check_update_timer(s);
|
|
|
|
}
|
2019-11-17 17:28:14 +08:00
|
|
|
s->period = rtc_periodic_clock_ticks(s);
|
2012-08-03 00:04:09 +08:00
|
|
|
|
2017-01-24 15:17:30 +08:00
|
|
|
/* The periodic timer is deterministic in record/replay mode,
|
|
|
|
* so there is no need to update it after loading the vmstate.
|
|
|
|
* Reading RTC here would misalign record and replay.
|
|
|
|
*/
|
|
|
|
if (replay_mode == REPLAY_MODE_NONE) {
|
|
|
|
uint64_t now = qemu_clock_get_ns(rtc_clock);
|
|
|
|
if (now < s->next_periodic_time ||
|
|
|
|
now > (s->next_periodic_time + get_max_clock_jump())) {
|
2019-11-17 17:28:14 +08:00
|
|
|
periodic_timer_update(s, qemu_clock_get_ns(rtc_clock), s->period, false);
|
2017-01-24 15:17:30 +08:00
|
|
|
}
|
2015-06-12 22:10:14 +08:00
|
|
|
}
|
|
|
|
|
2009-09-10 04:17:30 +08:00
|
|
|
if (version_id >= 2) {
|
2014-02-08 18:01:55 +08:00
|
|
|
if (s->lost_tick_policy == LOST_TICK_POLICY_SLEW) {
|
2009-09-10 04:17:30 +08:00
|
|
|
rtc_coalesced_timer_update(s);
|
|
|
|
}
|
|
|
|
}
|
2009-01-16 04:11:34 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-23 20:09:54 +08:00
|
|
|
static bool rtc_irq_reinject_on_ack_count_needed(void *opaque)
|
|
|
|
{
|
|
|
|
RTCState *s = (RTCState *)opaque;
|
|
|
|
return s->irq_reinject_on_ack_count != 0;
|
|
|
|
}
|
|
|
|
|
2014-08-28 19:19:25 +08:00
|
|
|
static const VMStateDescription vmstate_rtc_irq_reinject_on_ack_count = {
|
2015-02-05 19:33:11 +08:00
|
|
|
.name = "mc146818rtc/irq_reinject_on_ack_count",
|
2014-08-28 19:19:25 +08:00
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
2014-09-23 20:09:54 +08:00
|
|
|
.needed = rtc_irq_reinject_on_ack_count_needed,
|
2014-08-28 19:19:25 +08:00
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_UINT16(irq_reinject_on_ack_count, RTCState),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-10-08 06:12:06 +08:00
|
|
|
static const VMStateDescription vmstate_rtc = {
|
|
|
|
.name = "mc146818rtc",
|
2012-08-03 00:04:09 +08:00
|
|
|
.version_id = 3,
|
2009-10-08 06:12:06 +08:00
|
|
|
.minimum_version_id = 1,
|
MC146818 RTC: coordinate guest clock base to destination host after migration
qemu tracks guest time based on vector [base_rtc, last_update], in which
last_update stands for a monotonic tick which is actually uptime of the
host.
according to rtc implementation codes of recent releases and upstream,
after
migration, the time base vector [base_rtc, last_update] isn't updated to
coordinate with the destionation host, ie. qemu doesnt update last_update
to
uptime of the destination host.
what problem have we got because of this bug? after migration, guest time
may
jump back to several days ago, that will make some critical business
applications,
such as lotus notes, malfunction.
this patch is trying to fix the problem. first, when vmsave in progress,
we
rtc_update_time to refresh time stamp in cmos array, then during
vmrestore,
we rtc_set_time to update qemu base_rtc and last_update variable according
to time
stamp in cmos array.
Signed-off-by: Junlian Bell <zhongjun@sangfor.com.cn>
Message-Id: <20160926124101.2364-1-zhongjun@sangfor.com.cn>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-09-26 20:41:01 +08:00
|
|
|
.pre_save = rtc_pre_save,
|
2009-10-08 06:12:06 +08:00
|
|
|
.post_load = rtc_post_load,
|
2014-04-16 21:32:32 +08:00
|
|
|
.fields = (VMStateField[]) {
|
2009-10-08 06:12:06 +08:00
|
|
|
VMSTATE_BUFFER(cmos_data, RTCState),
|
|
|
|
VMSTATE_UINT8(cmos_index, RTCState),
|
2012-08-03 00:04:13 +08:00
|
|
|
VMSTATE_UNUSED(7*4),
|
2015-01-08 17:18:59 +08:00
|
|
|
VMSTATE_TIMER_PTR(periodic_timer, RTCState),
|
2009-10-08 06:12:06 +08:00
|
|
|
VMSTATE_INT64(next_periodic_time, RTCState),
|
2012-08-03 00:04:09 +08:00
|
|
|
VMSTATE_UNUSED(3*8),
|
2009-10-08 06:12:06 +08:00
|
|
|
VMSTATE_UINT32_V(irq_coalesced, RTCState, 2),
|
|
|
|
VMSTATE_UINT32_V(period, RTCState, 2),
|
2012-08-03 00:04:09 +08:00
|
|
|
VMSTATE_UINT64_V(base_rtc, RTCState, 3),
|
|
|
|
VMSTATE_UINT64_V(last_update, RTCState, 3),
|
|
|
|
VMSTATE_INT64_V(offset, RTCState, 3),
|
2015-01-08 17:18:59 +08:00
|
|
|
VMSTATE_TIMER_PTR_V(update_timer, RTCState, 3),
|
2012-08-03 00:04:11 +08:00
|
|
|
VMSTATE_UINT64_V(next_alarm_time, RTCState, 3),
|
2009-10-08 06:12:06 +08:00
|
|
|
VMSTATE_END_OF_LIST()
|
2014-08-28 19:19:25 +08:00
|
|
|
},
|
2014-09-23 20:09:54 +08:00
|
|
|
.subsections = (const VMStateDescription*[]) {
|
|
|
|
&vmstate_rtc_irq_reinject_on_ack_count,
|
|
|
|
NULL
|
2009-10-08 06:12:06 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-02-23 20:45:20 +08: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-28 04:18:43 +08:00
|
|
|
rtc_set_memory(ISA_DEVICE(s), 0xF, 0xFE);
|
2012-02-23 20:45:20 +08:00
|
|
|
}
|
|
|
|
|
2009-06-08 20:56:04 +08:00
|
|
|
static void rtc_reset(void *opaque)
|
|
|
|
{
|
|
|
|
RTCState *s = opaque;
|
|
|
|
|
2009-06-16 03:33:24 +08: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-03 00:04:09 +08:00
|
|
|
check_update_timer(s);
|
2009-06-08 20:56:04 +08:00
|
|
|
|
2009-06-16 03:33:24 +08:00
|
|
|
qemu_irq_lower(s->irq);
|
2009-06-08 20:56:04 +08:00
|
|
|
|
2014-02-08 18:01:55 +08:00
|
|
|
if (s->lost_tick_policy == LOST_TICK_POLICY_SLEW) {
|
2012-01-24 03:15:12 +08:00
|
|
|
s->irq_coalesced = 0;
|
2018-08-16 19:35:53 +08:00
|
|
|
s->irq_reinject_on_ack_count = 0;
|
2012-01-24 03:15:12 +08:00
|
|
|
}
|
2009-06-08 20:56:04 +08:00
|
|
|
}
|
|
|
|
|
2011-08-16 06:40:21 +08:00
|
|
|
static const MemoryRegionOps cmos_ops = {
|
2012-10-08 19:22:28 +08: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 06:40:21 +08:00
|
|
|
};
|
|
|
|
|
2015-02-06 11:55:45 +08:00
|
|
|
static void rtc_get_date(Object *obj, struct tm *current_tm, Error **errp)
|
2011-12-13 04:29:39 +08:00
|
|
|
{
|
2013-04-28 04:18:43 +08:00
|
|
|
RTCState *s = MC146818_RTC(obj);
|
2011-12-13 04:29:39 +08:00
|
|
|
|
2012-08-03 00:04:09 +08:00
|
|
|
rtc_update_time(s);
|
2015-02-06 11:55:45 +08:00
|
|
|
rtc_get_time(s, current_tm);
|
2011-12-13 04:29:39 +08:00
|
|
|
}
|
|
|
|
|
2012-11-25 09:37:14 +08:00
|
|
|
static void rtc_realizefn(DeviceState *dev, Error **errp)
|
2004-04-01 02:57:29 +08:00
|
|
|
{
|
2012-11-25 09:37:14 +08:00
|
|
|
ISADevice *isadev = ISA_DEVICE(dev);
|
2013-04-28 04:18:43 +08:00
|
|
|
RTCState *s = MC146818_RTC(dev);
|
2004-03-14 20:20:30 +08: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 20:22:08 +08: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 09:37:14 +08:00
|
|
|
rtc_set_date_from_host(isadev);
|
2006-12-08 01:16:55 +08:00
|
|
|
|
2012-01-24 03:15:12 +08:00
|
|
|
switch (s->lost_tick_policy) {
|
2017-05-10 16:32:57 +08:00
|
|
|
#ifdef TARGET_I386
|
2014-02-08 18:01:55 +08:00
|
|
|
case LOST_TICK_POLICY_SLEW:
|
2009-09-15 19:36:04 +08:00
|
|
|
s->coalesced_timer =
|
2013-08-21 23:03:04 +08:00
|
|
|
timer_new_ns(rtc_clock, rtc_coalesced_timer, s);
|
2012-01-24 03:15:12 +08:00
|
|
|
break;
|
2017-05-10 16:32:57 +08:00
|
|
|
#endif
|
2014-02-08 18:01:55 +08:00
|
|
|
case LOST_TICK_POLICY_DISCARD:
|
2012-01-24 03:15:12 +08:00
|
|
|
break;
|
|
|
|
default:
|
2012-11-25 09:37:14 +08:00
|
|
|
error_setg(errp, "Invalid lost tick policy.");
|
|
|
|
return;
|
2012-01-24 03:15:12 +08:00
|
|
|
}
|
|
|
|
|
2013-08-21 23:03:04 +08: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-03 00:04:09 +08:00
|
|
|
check_update_timer(s);
|
2004-04-01 02:57:29 +08:00
|
|
|
|
2012-02-23 20:45:20 +08:00
|
|
|
s->suspend_notifier.notify = rtc_notify_suspend;
|
|
|
|
qemu_register_suspend_notifier(&s->suspend_notifier);
|
|
|
|
|
2013-06-07 09:25:08 +08:00
|
|
|
memory_region_init_io(&s->io, OBJECT(s), &cmos_ops, s, "rtc", 2);
|
2020-04-29 21:59:54 +08:00
|
|
|
isa_register_ioport(isadev, &s->io, RTC_ISA_BASE);
|
2004-04-01 02:57:29 +08:00
|
|
|
|
2018-10-19 03:19:13 +08:00
|
|
|
/* register rtc 0x70 port for coalesced_pio */
|
|
|
|
memory_region_set_flush_coalesced(&s->io);
|
|
|
|
memory_region_init_io(&s->coalesced_io, OBJECT(s), &cmos_ops,
|
|
|
|
s, "rtc-index", 1);
|
|
|
|
memory_region_add_subregion(&s->io, 0, &s->coalesced_io);
|
|
|
|
memory_region_add_coalescing(&s->coalesced_io, 0, 1);
|
|
|
|
|
2020-04-29 21:59:54 +08:00
|
|
|
qdev_set_legacy_instance_id(dev, RTC_ISA_BASE, 3);
|
2009-06-27 15:25:07 +08:00
|
|
|
qemu_register_reset(rtc_reset, s);
|
2011-12-13 04:29:39 +08:00
|
|
|
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 23:29:22 +08:00
|
|
|
object_property_add_tm(OBJECT(s), "date", rtc_get_date);
|
2014-06-05 01:52:03 +08:00
|
|
|
|
2016-06-22 20:24:57 +08:00
|
|
|
qdev_init_gpio_out(dev, &s->irq, 1);
|
2019-10-18 21:35:47 +08:00
|
|
|
QLIST_INSERT_HEAD(&rtc_devices, s, link);
|
2009-09-10 17:43:35 +08:00
|
|
|
}
|
|
|
|
|
2017-10-18 00:44:16 +08:00
|
|
|
ISADevice *mc146818_rtc_init(ISABus *bus, int base_year, qemu_irq intercept_irq)
|
2009-09-10 17:43:35 +08:00
|
|
|
{
|
2013-04-28 04:18:43 +08:00
|
|
|
DeviceState *dev;
|
|
|
|
ISADevice *isadev;
|
2009-06-08 20:56:04 +08:00
|
|
|
|
isa: Convert uses of isa_create() with Coccinelle
Replace
dev = isa_create(bus, type_name);
...
qdev_init_nofail(dev);
by
dev = isa_new(type_name);
...
isa_realize_and_unref(dev, bus, &error_fatal);
Recent commit "qdev: New qdev_new(), qdev_realize(), etc." explains
why.
Coccinelle script:
@@
expression dev, bus, expr;
expression list args;
expression d;
@@
- dev = isa_create(bus, args);
+ dev = isa_new(args);
(
d = &dev->qdev;
|
d = DEVICE(dev);
)
... when != dev = expr
- qdev_init_nofail(d);
+ isa_realize_and_unref(dev, bus, &error_fatal);
@@
expression dev, bus, expr;
expression list args;
@@
- dev = isa_create(bus, args);
+ dev = isa_new(args);
... when != dev = expr
- qdev_init_nofail(DEVICE(dev));
+ isa_realize_and_unref(dev, bus, &error_fatal);
@@
expression dev, bus, expr;
expression list args;
@@
- dev = DEVICE(isa_create(bus, args));
+ ISADevice *isa_dev; // TODO move
+ isa_dev = isa_new(args);
+ dev = DEVICE(isa_dev);
... when != dev = expr
- qdev_init_nofail(dev);
+ isa_realize_and_unref(isa_dev, bus, &error_fatal);
Missing #include "qapi/error.h" added manually, whitespace changes
minimized manually.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-20-armbru@redhat.com>
2020-06-10 13:32:08 +08:00
|
|
|
isadev = isa_new(TYPE_MC146818_RTC);
|
2013-04-28 04:18:43 +08:00
|
|
|
dev = DEVICE(isadev);
|
|
|
|
qdev_prop_set_int32(dev, "base_year", base_year);
|
isa: Convert uses of isa_create() with Coccinelle
Replace
dev = isa_create(bus, type_name);
...
qdev_init_nofail(dev);
by
dev = isa_new(type_name);
...
isa_realize_and_unref(dev, bus, &error_fatal);
Recent commit "qdev: New qdev_new(), qdev_realize(), etc." explains
why.
Coccinelle script:
@@
expression dev, bus, expr;
expression list args;
expression d;
@@
- dev = isa_create(bus, args);
+ dev = isa_new(args);
(
d = &dev->qdev;
|
d = DEVICE(dev);
)
... when != dev = expr
- qdev_init_nofail(d);
+ isa_realize_and_unref(dev, bus, &error_fatal);
@@
expression dev, bus, expr;
expression list args;
@@
- dev = isa_create(bus, args);
+ dev = isa_new(args);
... when != dev = expr
- qdev_init_nofail(DEVICE(dev));
+ isa_realize_and_unref(dev, bus, &error_fatal);
@@
expression dev, bus, expr;
expression list args;
@@
- dev = DEVICE(isa_create(bus, args));
+ ISADevice *isa_dev; // TODO move
+ isa_dev = isa_new(args);
+ dev = DEVICE(isa_dev);
... when != dev = expr
- qdev_init_nofail(dev);
+ isa_realize_and_unref(isa_dev, bus, &error_fatal);
Missing #include "qapi/error.h" added manually, whitespace changes
minimized manually.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200610053247.1583243-20-armbru@redhat.com>
2020-06-10 13:32:08 +08:00
|
|
|
isa_realize_and_unref(isadev, bus, &error_fatal);
|
2010-06-13 20:15:40 +08:00
|
|
|
if (intercept_irq) {
|
2016-06-22 20:24:57 +08:00
|
|
|
qdev_connect_gpio_out(dev, 0, intercept_irq);
|
2010-06-13 20:15:40 +08:00
|
|
|
} else {
|
2016-06-22 20:24:57 +08:00
|
|
|
isa_connect_gpio_out(isadev, 0, RTC_ISA_IRQ);
|
2010-06-13 20:15:40 +08:00
|
|
|
}
|
2014-06-25 05:55:11 +08:00
|
|
|
|
2019-10-18 21:35:47 +08:00
|
|
|
object_property_add_alias(qdev_get_machine(), "rtc-time", OBJECT(isadev),
|
qom: Drop parameter @errp of object_property_add() & friends
The only way object_property_add() can fail is when a property with
the same name already exists. Since our property names are all
hardcoded, failure is a programming error, and the appropriate way to
handle it is passing &error_abort.
Same for its variants, except for object_property_add_child(), which
additionally fails when the child already has a parent. Parentage is
also under program control, so this is a programming error, too.
We have a bit over 500 callers. Almost half of them pass
&error_abort, slightly fewer ignore errors, one test case handles
errors, and the remaining few callers pass them to their own callers.
The previous few commits demonstrated once again that ignoring
programming errors is a bad idea.
Of the few ones that pass on errors, several violate the Error API.
The Error ** argument must be NULL, &error_abort, &error_fatal, or a
pointer to a variable containing NULL. Passing an argument of the
latter kind twice without clearing it in between is wrong: if the
first call sets an error, it no longer points to NULL for the second
call. ich9_pm_add_properties(), sparc32_ledma_realize(),
sparc32_dma_realize(), xilinx_axidma_realize(), xilinx_enet_realize()
are wrong that way.
When the one appropriate choice of argument is &error_abort, letting
users pick the argument is a bad idea.
Drop parameter @errp and assert the preconditions instead.
There's one exception to "duplicate property name is a programming
error": the way object_property_add() implements the magic (and
undocumented) "automatic arrayification". Don't drop @errp there.
Instead, rename object_property_add() to object_property_try_add(),
and add the obvious wrapper object_property_add().
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200505152926.18877-15-armbru@redhat.com>
[Two semantic rebase conflicts resolved]
2020-05-05 23:29:22 +08:00
|
|
|
"date");
|
hw/timer/mc146818rtc: Fix introspection problem
There is currently a funny problem with the "mc146818rtc" device:
1) Start QEMU like this:
qemu-system-ppc64 -M pseries -S
2) At the HMP monitor, enter "info qom-tree". Note that there is an
entry for "/rtc (spapr-rtc)".
3) Introspect the mc146818rtc device like this:
device_add mc146818rtc,help
4) Run "info qom-tree" again. The "/rtc" entry is gone now!
The rtc_finalize() function of the mc146818rtc device has two bugs: First,
it tries to remove a "rtc" property, while the rtc_realizefn() added a
"rtc-time" property instead. And second, it should have been done in an
unrealize function, not in a finalize function, to avoid that this causes
problems during introspection.
But since adding aliases to the global machine state should not be done
from a device's realize function anyway, let's rather fix this issue
by moving the creation of the alias to the code that creates the device
(and thus is run from the machine init functions instead), i.e. the
mc146818_rtc_init() function for most machines. The prep machines are
special, since the mc146818rtc device is created here in the realize
function of the i82378 device. Since we certainly don't want to add the
alias there, we add it to some code that is called from the ibm_40p_init()
machine init function instead.
Since the alias is now only created during the machine init, we can remove
the object_property_del() completely.
Fixes: 654a36d857ff949e0d1989904b76f53fded9dc83
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-Id: <1534419358-10932-5-git-send-email-thuth@redhat.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2018-08-16 19:35:54 +08:00
|
|
|
|
2013-04-28 04:18:43 +08:00
|
|
|
return isadev;
|
2004-03-14 20:20:30 +08:00
|
|
|
}
|
|
|
|
|
2011-12-08 11:34:16 +08:00
|
|
|
static Property mc146818rtc_properties[] = {
|
|
|
|
DEFINE_PROP_INT32("base_year", RTCState, base_year, 1980),
|
|
|
|
DEFINE_PROP_LOSTTICKPOLICY("lost_tick_policy", RTCState,
|
2014-02-08 18:01:55 +08:00
|
|
|
lost_tick_policy, LOST_TICK_POLICY_DISCARD),
|
2011-12-08 11:34:16 +08:00
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
2016-12-19 14:03:36 +08:00
|
|
|
static void rtc_resetdev(DeviceState *d)
|
|
|
|
{
|
|
|
|
RTCState *s = MC146818_RTC(d);
|
|
|
|
|
|
|
|
/* Reason: VM do suspend self will set 0xfe
|
|
|
|
* Reset any values other than 0xfe(Guest suspend case) */
|
|
|
|
if (s->cmos_data[0x0f] != 0xfe) {
|
|
|
|
s->cmos_data[0x0f] = 0x00;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-15 23:04:07 +08:00
|
|
|
static void rtc_build_aml(ISADevice *isadev, Aml *scope)
|
|
|
|
{
|
|
|
|
Aml *dev;
|
|
|
|
Aml *crs;
|
|
|
|
|
2020-05-15 23:04:08 +08:00
|
|
|
/*
|
|
|
|
* Reserving 8 io ports here, following what physical hardware
|
|
|
|
* does, even though qemu only responds to the first two ports.
|
|
|
|
*/
|
2020-05-15 23:04:07 +08:00
|
|
|
crs = aml_resource_template();
|
|
|
|
aml_append(crs, aml_io(AML_DECODE16, RTC_ISA_BASE, RTC_ISA_BASE,
|
2020-05-15 23:04:08 +08:00
|
|
|
0x01, 0x08));
|
2020-05-15 23:04:07 +08:00
|
|
|
aml_append(crs, aml_irq_no_flags(RTC_ISA_IRQ));
|
|
|
|
|
|
|
|
dev = aml_device("RTC");
|
|
|
|
aml_append(dev, aml_name_decl("_HID", aml_eisaid("PNP0B00")));
|
|
|
|
aml_append(dev, aml_name_decl("_CRS", crs));
|
|
|
|
|
|
|
|
aml_append(scope, dev);
|
|
|
|
}
|
|
|
|
|
2011-12-05 01:52:49 +08:00
|
|
|
static void rtc_class_initfn(ObjectClass *klass, void *data)
|
|
|
|
{
|
2011-12-08 11:34:16 +08:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
2020-05-15 23:04:07 +08:00
|
|
|
ISADeviceClass *isa = ISA_DEVICE_CLASS(klass);
|
2012-11-25 09:37:14 +08:00
|
|
|
|
|
|
|
dc->realize = rtc_realizefn;
|
2016-12-19 14:03:36 +08:00
|
|
|
dc->reset = rtc_resetdev;
|
2011-12-08 11:34:16 +08:00
|
|
|
dc->vmsd = &vmstate_rtc;
|
2020-05-15 23:04:07 +08:00
|
|
|
isa->build_aml = rtc_build_aml;
|
2020-01-10 23:30:32 +08:00
|
|
|
device_class_set_props(dc, mc146818rtc_properties);
|
2011-12-05 01:52:49 +08:00
|
|
|
}
|
|
|
|
|
2013-01-10 23:19:07 +08:00
|
|
|
static const TypeInfo mc146818rtc_info = {
|
2013-04-28 04:18:43 +08:00
|
|
|
.name = TYPE_MC146818_RTC,
|
2011-12-08 11:34:16 +08:00
|
|
|
.parent = TYPE_ISA_DEVICE,
|
|
|
|
.instance_size = sizeof(RTCState),
|
|
|
|
.class_init = rtc_class_initfn,
|
2009-09-10 17:43:35 +08:00
|
|
|
};
|
|
|
|
|
2012-02-09 22:20:55 +08:00
|
|
|
static void mc146818rtc_register_types(void)
|
2009-04-08 06:28:50 +08:00
|
|
|
{
|
2011-12-08 11:34:16 +08:00
|
|
|
type_register_static(&mc146818rtc_info);
|
2009-04-08 06:28:50 +08:00
|
|
|
}
|
2012-02-09 22:20:55 +08:00
|
|
|
|
|
|
|
type_init(mc146818rtc_register_types)
|