diff --git a/hw/mc146818rtc.c b/hw/mc146818rtc.c
index 9cbd052..ac1854e 100644
--- a/hw/mc146818rtc.c
+++ b/hw/mc146818rtc.c
@@ -84,7 +84,7 @@ typedef struct RTCState {
     MemoryRegion io;
     uint8_t cmos_data[128];
     uint8_t cmos_index;
-    struct tm current_tm;
+    int64_t offset;
     int32_t base_year;
     qemu_irq irq;
     qemu_irq sqw_irq;
@@ -93,19 +93,18 @@ typedef struct RTCState {
     QEMUTimer *periodic_timer;
     int64_t next_periodic_time;
     /* second update */
-    int64_t next_second_time;
+    QEMUTimer *update_timer;
+    int64_t next_update_time;
+    /* alarm  */
+    QEMUTimer *alarm_timer;
+    int64_t next_alarm_time;
     uint16_t irq_reinject_on_ack_count;
     uint32_t irq_coalesced;
     uint32_t period;
     QEMUTimer *coalesced_timer;
-    QEMUTimer *second_timer;
-    QEMUTimer *second_timer2;
     Notifier clock_reset_notifier;
 } RTCState;

-static void rtc_set_time(RTCState *s);
-static void rtc_copy_date(RTCState *s);
-
 #ifdef TARGET_I386
 static void rtc_coalesced_timer_update(RTCState *s)
 {
@@ -140,6 +139,72 @@ static void rtc_coalesced_timer(void *opaque)
 }
 #endif

+static inline int rtc_to_bcd(RTCState *s, int a)
+{
+    if (s->cmos_data[RTC_REG_B] & REG_B_DM) {
+        return a;
+    } else {
+        return ((a / 10) << 4) | (a % 10);
+    }
+}
+
+static inline int rtc_from_bcd(RTCState *s, int a)
+{
+    if (s->cmos_data[RTC_REG_B] & REG_B_DM) {
+        return a;
+    } else {
+        return ((a >> 4) * 10) + (a & 0x0f);
+    }
+}
+
+static void rtc_set_time(RTCState *s)
+{
+    struct tm tm ;
+
+    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);
+    if (!(s->cmos_data[RTC_REG_B] & REG_B_24H) &&
+        (s->cmos_data[RTC_HOURS] & 0x80)) {
+        tm.tm_hour += 12;
+    }
+    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;
+    tm.tm_year = rtc_from_bcd(s, s->cmos_data[RTC_YEAR]) + s->base_year - 1900;
+
+    s->offset = qemu_timedate_diff(&tm);
+
+    rtc_change_mon_event(&tm);
+}
+
+static void rtc_update_time(RTCState *s)
+{
+    struct tm tm;
+    int year;
+
+    qemu_get_timedate(&tm, s->offset);
+
+    s->cmos_data[RTC_SECONDS] = rtc_to_bcd(s, tm.tm_sec);
+    s->cmos_data[RTC_MINUTES] = rtc_to_bcd(s, tm.tm_min);
+    if (s->cmos_data[RTC_REG_B] & REG_B_24H) {
+        /* 24 hour format */
+        s->cmos_data[RTC_HOURS] = rtc_to_bcd(s, tm.tm_hour);
+    } else {
+        /* 12 hour format */
+        s->cmos_data[RTC_HOURS] = rtc_to_bcd(s, tm.tm_hour % 12);
+        if (tm.tm_hour >= 12)
+            s->cmos_data[RTC_HOURS] |= 0x80;
+    }
+    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);
+    year = (tm.tm_year - s->base_year) % 100;
+    if (year < 0)
+        year += 100;
+    s->cmos_data[RTC_YEAR] = rtc_to_bcd(s, year);
+}
+
 static void rtc_timer_update(RTCState *s, int64_t current_time)
 {
     int period_code, period;
@@ -174,7 +239,7 @@ static void rtc_timer_update(RTCState *s, int64_t current_time)
     }
 }

-static void rtc_periodic_timer(void *opaque)
+static void rtc_periodic_interrupt(void *opaque)
 {
     RTCState *s = opaque;

@@ -204,6 +269,92 @@ static void rtc_periodic_timer(void *opaque)
     }
 }

+static void rtc_enable_update_interrupt(void *opaque)
+{
+    RTCState *s = opaque;
+
+    s->next_update_time = qemu_get_clock_ns(rtc_clock) + get_ticks_per_sec();
+    qemu_mod_timer(s->update_timer, s->next_update_time);
+}
+
+static void rtc_disable_update_interrupt(void *opaque)
+{
+    RTCState *s = opaque;
+
+    qemu_del_timer(s->update_timer);
+}
+
+static void rtc_update_interrupt(void *opaque)
+{
+    RTCState *s = opaque;
+
+    /* update ended interrupt */
+    s->cmos_data[RTC_REG_C] |= REG_C_UF;
+    if (s->cmos_data[RTC_REG_B] & REG_B_UIE) {
+        s->cmos_data[RTC_REG_C] |= REG_C_IRQF;
+        qemu_irq_raise(s->irq);
+
+        s->next_update_time += get_ticks_per_sec();
+       qemu_mod_timer(s->update_timer, s->next_update_time);
+    } else
+       rtc_disable_update_interrupt(s);
+}
+
+static void rtc_enable_alarm(void *opaque)
+{
+    RTCState *s = opaque;
+
+    s->next_alarm_time = qemu_get_clock_ns(rtc_clock) + get_ticks_per_sec();
+    s->next_alarm_time /= get_ticks_per_sec();
+    s->next_alarm_time *= get_ticks_per_sec();
+
+    qemu_mod_timer(s->alarm_timer, s->next_alarm_time);
+}
+
+static void rtc_disable_alarm(void *opaque)
+{
+    RTCState *s = opaque;
+
+    qemu_del_timer(s->alarm_timer);
+}
+
+static void rtc_alarm_interrupt(void *opaque)
+{
+    RTCState *s = opaque;
+    struct tm tm;
+    int hour = 0;
+
+    qemu_get_timedate(&tm, s->offset);
+
+    if ((s->cmos_data[RTC_HOURS_ALARM] & 0xc0) != 0xc0) {
+       hour = rtc_from_bcd(s, s->cmos_data[RTC_HOURS_ALARM] & 0x7f);
+       if (!(s->cmos_data[RTC_REG_B] & REG_B_24H) &&
+            (s->cmos_data[RTC_HOURS_ALARM] & 0x80)) {
+                   hour += 12;
+       }
+    }
+
+    /* check alarm */
+    if (s->cmos_data[RTC_REG_B] & REG_B_AIE) {
+        if (((s->cmos_data[RTC_SECONDS_ALARM] & 0xc0) == 0xc0 ||
+             rtc_from_bcd(s, s->cmos_data[RTC_SECONDS_ALARM]) == tm.tm_sec) &&
+            ((s->cmos_data[RTC_MINUTES_ALARM] & 0xc0) == 0xc0 ||
+             rtc_from_bcd(s, s->cmos_data[RTC_MINUTES_ALARM]) == tm.tm_min) &&
+            ((s->cmos_data[RTC_HOURS_ALARM] & 0xc0) == 0xc0 ||
+             hour == tm.tm_hour)) {
+
+           printf("raise irq\n");
+            s->cmos_data[RTC_REG_C] |= 0xa0;
+            qemu_irq_raise(s->irq);
+        }
+
+       s->next_alarm_time += get_ticks_per_sec();
+       qemu_mod_timer(s->alarm_timer, s->next_alarm_time);
+    } else
+       rtc_disable_alarm(s);
+
+}
+
 static void cmos_ioport_write(void *opaque, uint32_t addr, uint32_t data)
 {
     RTCState *s = opaque;
@@ -239,26 +390,37 @@ static void cmos_ioport_write(void *opaque, uint32_t addr, uint32_t data)
             rtc_timer_update(s, qemu_get_clock_ns(rtc_clock));
             break;
         case RTC_REG_B:
-            if (data & REG_B_SET) {
-                /* set mode: reset UIP mode */
-                s->cmos_data[RTC_REG_A] &= ~REG_A_UIP;
-                data &= ~REG_B_UIE;
-            } else {
+            if (data & REG_B_SET)
+                rtc_update_time(s);
+            else {
                 /* if disabling set mode, update the time */
                 if (s->cmos_data[RTC_REG_B] & REG_B_SET) {
                     rtc_set_time(s);
                 }
             }
+
             if (((s->cmos_data[RTC_REG_B] ^ data) & (REG_B_DM | REG_B_24H)) &&
                 !(data & REG_B_SET)) {
                 /* If the time format has changed and not in set mode,
                    update the registers immediately. */
                 s->cmos_data[RTC_REG_B] = data;
-                rtc_copy_date(s);
-            } else {
+                rtc_update_time(s);
+            } else
                 s->cmos_data[RTC_REG_B] = data;
-            }
+
+           /* check alarm interrupt */
+           if ((s->cmos_data[RTC_REG_B] & REG_B_AIE) &&
+               !(s->cmos_data[RTC_REG_B] & REG_B_SET) )
+               rtc_enable_alarm(s);
+
+           /* check update-ended interrupt */
+           if ((s->cmos_data[RTC_REG_B] & REG_B_UIE) &&
+               !(s->cmos_data[RTC_REG_B] & REG_B_SET))
+               rtc_enable_update_interrupt(s);
+
+           /* check periodic interrupt or square-wave */
             rtc_timer_update(s, qemu_get_clock_ns(rtc_clock));
+
             break;
         case RTC_REG_C:
         case RTC_REG_D:
@@ -271,184 +433,6 @@ static void cmos_ioport_write(void *opaque, uint32_t addr, uint32_t data)
     }
 }

-static inline int rtc_to_bcd(RTCState *s, int a)
-{
-    if (s->cmos_data[RTC_REG_B] & REG_B_DM) {
-        return a;
-    } else {
-        return ((a / 10) << 4) | (a % 10);
-    }
-}
-
-static inline int rtc_from_bcd(RTCState *s, int a)
-{
-    if (s->cmos_data[RTC_REG_B] & REG_B_DM) {
-        return a;
-    } else {
-        return ((a >> 4) * 10) + (a & 0x0f);
-    }
-}
-
-static void rtc_set_time(RTCState *s)
-{
-    struct tm *tm = &s->current_tm;
-
-    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);
-    if (!(s->cmos_data[RTC_REG_B] & REG_B_24H) &&
-        (s->cmos_data[RTC_HOURS] & 0x80)) {
-        tm->tm_hour += 12;
-    }
-    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;
-    tm->tm_year = rtc_from_bcd(s, s->cmos_data[RTC_YEAR]) + s->base_year - 1900;
-
-    rtc_change_mon_event(tm);
-}
-
-static void rtc_copy_date(RTCState *s)
-{
-    const struct tm *tm = &s->current_tm;
-    int year;
-
-    s->cmos_data[RTC_SECONDS] = rtc_to_bcd(s, tm->tm_sec);
-    s->cmos_data[RTC_MINUTES] = rtc_to_bcd(s, tm->tm_min);
-    if (s->cmos_data[RTC_REG_B] & REG_B_24H) {
-        /* 24 hour format */
-        s->cmos_data[RTC_HOURS] = rtc_to_bcd(s, tm->tm_hour);
-    } else {
-        /* 12 hour format */
-        s->cmos_data[RTC_HOURS] = rtc_to_bcd(s, tm->tm_hour % 12);
-        if (tm->tm_hour >= 12)
-            s->cmos_data[RTC_HOURS] |= 0x80;
-    }
-    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);
-    year = (tm->tm_year - s->base_year) % 100;
-    if (year < 0)
-        year += 100;
-    s->cmos_data[RTC_YEAR] = rtc_to_bcd(s, year);
-}
-
-/* month is between 0 and 11. */
-static int get_days_in_month(int month, int year)
-{
-    static const int days_tab[12] = {
-        31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
-    };
-    int d;
-    if ((unsigned )month >= 12)
-        return 31;
-    d = days_tab[month];
-    if (month == 1) {
-        if ((year % 4) == 0 && ((year % 100) != 0 || (year % 400) == 0))
-            d++;
-    }
-    return d;
-}
-
-/* update 'tm' to the next second */
-static void rtc_next_second(struct tm *tm)
-{
-    int days_in_month;
-
-    tm->tm_sec++;
-    if ((unsigned)tm->tm_sec >= 60) {
-        tm->tm_sec = 0;
-        tm->tm_min++;
-        if ((unsigned)tm->tm_min >= 60) {
-            tm->tm_min = 0;
-            tm->tm_hour++;
-            if ((unsigned)tm->tm_hour >= 24) {
-                tm->tm_hour = 0;
-                /* next day */
-                tm->tm_wday++;
-                if ((unsigned)tm->tm_wday >= 7)
-                    tm->tm_wday = 0;
-                days_in_month = get_days_in_month(tm->tm_mon,
-                                                  tm->tm_year + 1900);
-                tm->tm_mday++;
-                if (tm->tm_mday < 1) {
-                    tm->tm_mday = 1;
-                } else if (tm->tm_mday > days_in_month) {
-                    tm->tm_mday = 1;
-                    tm->tm_mon++;
-                    if (tm->tm_mon >= 12) {
-                        tm->tm_mon = 0;
-                        tm->tm_year++;
-                    }
-                }
-            }
-        }
-    }
-}
-
-
-static void rtc_update_second(void *opaque)
-{
-    RTCState *s = opaque;
-    int64_t delay;
-
-    /* if the oscillator is not in normal operation, we do not update */
-    if ((s->cmos_data[RTC_REG_A] & 0x70) != 0x20) {
-        s->next_second_time += get_ticks_per_sec();
-        qemu_mod_timer(s->second_timer, s->next_second_time);
-    } else {
-        rtc_next_second(&s->current_tm);
-
-        if (!(s->cmos_data[RTC_REG_B] & REG_B_SET)) {
-            /* update in progress bit */
-            s->cmos_data[RTC_REG_A] |= REG_A_UIP;
-        }
-        /* should be 244 us = 8 / 32768 seconds, but currently the
-           timers do not have the necessary resolution. */
-        delay = (get_ticks_per_sec() * 1) / 100;
-        if (delay < 1)
-            delay = 1;
-        qemu_mod_timer(s->second_timer2,
-                       s->next_second_time + delay);
-    }
-}
-
-static void rtc_update_second2(void *opaque)
-{
-    RTCState *s = opaque;
-
-    if (!(s->cmos_data[RTC_REG_B] & REG_B_SET)) {
-        rtc_copy_date(s);
-    }
-
-    /* check alarm */
-    if (s->cmos_data[RTC_REG_B] & REG_B_AIE) {
-        if (((s->cmos_data[RTC_SECONDS_ALARM] & 0xc0) == 0xc0 ||
-             rtc_from_bcd(s, s->cmos_data[RTC_SECONDS_ALARM]) == s->current_tm.tm_sec) &&
-            ((s->cmos_data[RTC_MINUTES_ALARM] & 0xc0) == 0xc0 ||
-             rtc_from_bcd(s, s->cmos_data[RTC_MINUTES_ALARM]) == s->current_tm.tm_min) &&
-            ((s->cmos_data[RTC_HOURS_ALARM] & 0xc0) == 0xc0 ||
-             rtc_from_bcd(s, s->cmos_data[RTC_HOURS_ALARM]) == s->current_tm.tm_hour)) {
-
-            s->cmos_data[RTC_REG_C] |= 0xa0;
-            qemu_irq_raise(s->irq);
-        }
-    }
-
-    /* update ended interrupt */
-    s->cmos_data[RTC_REG_C] |= REG_C_UF;
-    if (s->cmos_data[RTC_REG_B] & REG_B_UIE) {
-        s->cmos_data[RTC_REG_C] |= REG_C_IRQF;
-        qemu_irq_raise(s->irq);
-    }
-
-    /* clear update in progress bit */
-    s->cmos_data[RTC_REG_A] &= ~REG_A_UIP;
-
-    s->next_second_time += get_ticks_per_sec();
-    qemu_mod_timer(s->second_timer, s->next_second_time);
-}
-
 static uint32_t cmos_ioport_read(void *opaque, uint32_t addr)
 {
     RTCState *s = opaque;
@@ -464,9 +448,9 @@ static uint32_t cmos_ioport_read(void *opaque, uint32_t addr)
         case RTC_DAY_OF_MONTH:
         case RTC_MONTH:
         case RTC_YEAR:
-            ret = s->cmos_data[s->cmos_index];
-            break;
-        case RTC_REG_A:
+           /* if not in set mode, update the time before read */
+           if (!(s->cmos_data[RTC_REG_B] & REG_B_SET))
+               rtc_update_time(s);
             ret = s->cmos_data[s->cmos_index];
             break;
         case RTC_REG_C:
@@ -507,13 +491,6 @@ void rtc_set_memory(ISADevice *dev, int addr, int val)
         s->cmos_data[addr] = val;
 }

-void rtc_set_date(ISADevice *dev, const struct tm *tm)
-{
-    RTCState *s = DO_UPCAST(RTCState, dev, dev);
-    s->current_tm = *tm;
-    rtc_copy_date(s);
-}
-
 /* PC cmos mappings */
 #define REG_IBM_CENTURY_BYTE        0x32
 #define REG_IBM_PS2_CENTURY_BYTE    0x37
@@ -524,10 +501,11 @@ static void rtc_set_date_from_host(ISADevice *dev)
     struct tm tm;
     int val;

+    s->offset = 0;
     /* set the CMOS date */
-    qemu_get_timedate(&tm, 0);
-    rtc_set_date(dev, &tm);
+    rtc_update_time(s);

+    qemu_get_timedate(&tm, s->offset);
     val = rtc_to_bcd(s, (tm.tm_year / 100) + 19);
     rtc_set_memory(dev, REG_IBM_CENTURY_BYTE, val);
     rtc_set_memory(dev, REG_IBM_PS2_CENTURY_BYTE, val);
@@ -556,18 +534,13 @@ static const VMStateDescription vmstate_rtc = {
     .fields      = (VMStateField []) {
         VMSTATE_BUFFER(cmos_data, RTCState),
         VMSTATE_UINT8(cmos_index, RTCState),
-        VMSTATE_INT32(current_tm.tm_sec, RTCState),
-        VMSTATE_INT32(current_tm.tm_min, RTCState),
-        VMSTATE_INT32(current_tm.tm_hour, RTCState),
-        VMSTATE_INT32(current_tm.tm_wday, RTCState),
-        VMSTATE_INT32(current_tm.tm_mday, RTCState),
-        VMSTATE_INT32(current_tm.tm_mon, RTCState),
-        VMSTATE_INT32(current_tm.tm_year, RTCState),
+        VMSTATE_INT64(offset, RTCState),
         VMSTATE_TIMER(periodic_timer, RTCState),
         VMSTATE_INT64(next_periodic_time, RTCState),
-        VMSTATE_INT64(next_second_time, RTCState),
-        VMSTATE_TIMER(second_timer, RTCState),
-        VMSTATE_TIMER(second_timer2, RTCState),
+        VMSTATE_TIMER(update_timer, RTCState),
+        VMSTATE_INT64(next_update_time, RTCState),
+        VMSTATE_TIMER(alarm_timer, RTCState),
+        VMSTATE_INT64(next_alarm_time, RTCState),
         VMSTATE_UINT32_V(irq_coalesced, RTCState, 2),
         VMSTATE_UINT32_V(period, RTCState, 2),
         VMSTATE_END_OF_LIST()
@@ -580,8 +553,6 @@ static void rtc_notify_clock_reset(Notifier *notifier, void *data)
     int64_t now = *(int64_t *)data;

     rtc_set_date_from_host(&s->dev);
-    s->next_second_time = now + (get_ticks_per_sec() * 99) / 100;
-    qemu_mod_timer(s->second_timer2, s->next_second_time);
     rtc_timer_update(s, now);
 #ifdef TARGET_I386
     if (rtc_td_hack) {
@@ -627,13 +598,15 @@ static void rtc_get_date(DeviceState *dev, Visitor *v, void *opaque,
     ISADevice *isa = DO_UPCAST(ISADevice, qdev, dev);
     RTCState *s = DO_UPCAST(RTCState, dev, isa);

+    struct tm tm;
+    qemu_get_timedate(&tm, s->offset);
     visit_start_struct(v, NULL, "struct tm", name, 0, errp);
-    visit_type_int32(v, &s->current_tm.tm_year, "tm_year", errp);
-    visit_type_int32(v, &s->current_tm.tm_mon, "tm_mon", errp);
-    visit_type_int32(v, &s->current_tm.tm_mday, "tm_mday", errp);
-    visit_type_int32(v, &s->current_tm.tm_hour, "tm_hour", errp);
-    visit_type_int32(v, &s->current_tm.tm_min, "tm_min", errp);
-    visit_type_int32(v, &s->current_tm.tm_sec, "tm_sec", errp);
+    visit_type_int32(v, &tm.tm_year, "tm_year", errp);
+    visit_type_int32(v, &tm.tm_mon, "tm_mon", errp);
+    visit_type_int32(v, &tm.tm_mday, "tm_mday", errp);
+    visit_type_int32(v, &tm.tm_hour, "tm_hour", errp);
+    visit_type_int32(v, &tm.tm_min, "tm_min", errp);
+    visit_type_int32(v, &tm.tm_sec, "tm_sec", errp);
     visit_end_struct(v, errp);
 }

@@ -649,22 +622,18 @@ static int rtc_initfn(ISADevice *dev)

     rtc_set_date_from_host(dev);

-    s->periodic_timer = qemu_new_timer_ns(rtc_clock, rtc_periodic_timer, s);
+    s->periodic_timer = qemu_new_timer_ns(rtc_clock, rtc_periodic_interrupt, s);
 #ifdef TARGET_I386
     if (rtc_td_hack)
         s->coalesced_timer =
             qemu_new_timer_ns(rtc_clock, rtc_coalesced_timer, s);
 #endif
-    s->second_timer = qemu_new_timer_ns(rtc_clock, rtc_update_second, s);
-    s->second_timer2 = qemu_new_timer_ns(rtc_clock, rtc_update_second2, s);
+    s->update_timer = qemu_new_timer_ns(rtc_clock, rtc_update_interrupt, s);
+    s->alarm_timer = qemu_new_timer_ns(rtc_clock, rtc_alarm_interrupt, s);

     s->clock_reset_notifier.notify = rtc_notify_clock_reset;
     qemu_register_clock_reset_notifier(rtc_clock, &s->clock_reset_notifier);

-    s->next_second_time =
-        qemu_get_clock_ns(rtc_clock) + (get_ticks_per_sec() * 99) / 100;
-    qemu_mod_timer(s->second_timer2, s->next_second_time);
-
     memory_region_init_io(&s->io, &cmos_ops, s, "rtc", 2);
     isa_register_ioport(dev, &s->io, base);

