2 * QEMU MC146818 RTC emulation
4 * Copyright (c) 2003-2004 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu-timer.h"
30 #include "mc146818rtc.h"
33 //#define DEBUG_COALESCED
36 # define CMOS_DPRINTF(format, ...) printf(format, ## __VA_ARGS__)
38 # define CMOS_DPRINTF(format, ...) do { } while (0)
41 #ifdef DEBUG_COALESCED
42 # define DPRINTF_C(format, ...) printf(format, ## __VA_ARGS__)
44 # define DPRINTF_C(format, ...) do { } while (0)
47 #define RTC_REINJECT_ON_ACK_COUNT 20
50 #define RTC_SECONDS_ALARM 1
52 #define RTC_MINUTES_ALARM 3
54 #define RTC_HOURS_ALARM 5
55 #define RTC_ALARM_DONT_CARE 0xC0
57 #define RTC_DAY_OF_WEEK 6
58 #define RTC_DAY_OF_MONTH 7
67 #define REG_A_UIP 0x80
69 #define REG_B_SET 0x80
70 #define REG_B_PIE 0x40
71 #define REG_B_AIE 0x20
72 #define REG_B_UIE 0x10
73 #define REG_B_SQWE 0x08
75 #define REG_B_24H 0x02
78 #define REG_C_IRQF 0x80
82 typedef struct RTCState
{
85 uint8_t cmos_data
[128];
93 QEMUTimer
*periodic_timer
;
94 int64_t next_periodic_time
;
96 int64_t next_second_time
;
97 uint16_t irq_reinject_on_ack_count
;
98 uint32_t irq_coalesced
;
100 QEMUTimer
*coalesced_timer
;
101 QEMUTimer
*second_timer
;
102 QEMUTimer
*second_timer2
;
103 Notifier clock_reset_notifier
;
104 LostTickPolicy lost_tick_policy
;
105 Notifier suspend_notifier
;
108 static void rtc_set_time(RTCState
*s
);
109 static void rtc_copy_date(RTCState
*s
);
112 static void rtc_coalesced_timer_update(RTCState
*s
)
114 if (s
->irq_coalesced
== 0) {
115 qemu_del_timer(s
->coalesced_timer
);
117 /* divide each RTC interval to 2 - 8 smaller intervals */
118 int c
= MIN(s
->irq_coalesced
, 7) + 1;
119 int64_t next_clock
= qemu_get_clock_ns(rtc_clock
) +
120 muldiv64(s
->period
/ c
, get_ticks_per_sec(), 32768);
121 qemu_mod_timer(s
->coalesced_timer
, next_clock
);
125 static void rtc_coalesced_timer(void *opaque
)
127 RTCState
*s
= opaque
;
129 if (s
->irq_coalesced
!= 0) {
130 apic_reset_irq_delivered();
131 s
->cmos_data
[RTC_REG_C
] |= 0xc0;
132 DPRINTF_C("cmos: injecting from timer\n");
133 qemu_irq_raise(s
->irq
);
134 if (apic_get_irq_delivered()) {
136 DPRINTF_C("cmos: coalesced irqs decreased to %d\n",
141 rtc_coalesced_timer_update(s
);
145 static void rtc_timer_update(RTCState
*s
, int64_t current_time
)
147 int period_code
, period
;
148 int64_t cur_clock
, next_irq_clock
;
150 period_code
= s
->cmos_data
[RTC_REG_A
] & 0x0f;
152 && ((s
->cmos_data
[RTC_REG_B
] & REG_B_PIE
)
153 || ((s
->cmos_data
[RTC_REG_B
] & REG_B_SQWE
) && s
->sqw_irq
))) {
154 if (period_code
<= 2)
156 /* period in 32 Khz cycles */
157 period
= 1 << (period_code
- 1);
159 if (period
!= s
->period
) {
160 s
->irq_coalesced
= (s
->irq_coalesced
* s
->period
) / period
;
161 DPRINTF_C("cmos: coalesced irqs scaled to %d\n", s
->irq_coalesced
);
165 /* compute 32 khz clock */
166 cur_clock
= muldiv64(current_time
, 32768, get_ticks_per_sec());
167 next_irq_clock
= (cur_clock
& ~(period
- 1)) + period
;
168 s
->next_periodic_time
=
169 muldiv64(next_irq_clock
, get_ticks_per_sec(), 32768) + 1;
170 qemu_mod_timer(s
->periodic_timer
, s
->next_periodic_time
);
173 s
->irq_coalesced
= 0;
175 qemu_del_timer(s
->periodic_timer
);
179 static void rtc_periodic_timer(void *opaque
)
181 RTCState
*s
= opaque
;
183 rtc_timer_update(s
, s
->next_periodic_time
);
184 s
->cmos_data
[RTC_REG_C
] |= REG_C_PF
;
185 if (s
->cmos_data
[RTC_REG_B
] & REG_B_PIE
) {
186 s
->cmos_data
[RTC_REG_C
] |= REG_C_IRQF
;
188 if (s
->lost_tick_policy
== LOST_TICK_SLEW
) {
189 if (s
->irq_reinject_on_ack_count
>= RTC_REINJECT_ON_ACK_COUNT
)
190 s
->irq_reinject_on_ack_count
= 0;
191 apic_reset_irq_delivered();
192 qemu_irq_raise(s
->irq
);
193 if (!apic_get_irq_delivered()) {
195 rtc_coalesced_timer_update(s
);
196 DPRINTF_C("cmos: coalesced irqs increased to %d\n",
201 qemu_irq_raise(s
->irq
);
203 if (s
->cmos_data
[RTC_REG_B
] & REG_B_SQWE
) {
204 /* Not square wave at all but we don't want 2048Hz interrupts!
205 Must be seen as a pulse. */
206 qemu_irq_raise(s
->sqw_irq
);
210 static void cmos_ioport_write(void *opaque
, uint32_t addr
, uint32_t data
)
212 RTCState
*s
= opaque
;
214 if ((addr
& 1) == 0) {
215 s
->cmos_index
= data
& 0x7f;
217 CMOS_DPRINTF("cmos: write index=0x%02x val=0x%02x\n",
218 s
->cmos_index
, data
);
219 switch(s
->cmos_index
) {
220 case RTC_SECONDS_ALARM
:
221 case RTC_MINUTES_ALARM
:
222 case RTC_HOURS_ALARM
:
223 s
->cmos_data
[s
->cmos_index
] = data
;
228 case RTC_DAY_OF_WEEK
:
229 case RTC_DAY_OF_MONTH
:
232 s
->cmos_data
[s
->cmos_index
] = data
;
233 /* if in set mode, do not update the time */
234 if (!(s
->cmos_data
[RTC_REG_B
] & REG_B_SET
)) {
239 /* UIP bit is read only */
240 s
->cmos_data
[RTC_REG_A
] = (data
& ~REG_A_UIP
) |
241 (s
->cmos_data
[RTC_REG_A
] & REG_A_UIP
);
242 rtc_timer_update(s
, qemu_get_clock_ns(rtc_clock
));
245 if (data
& REG_B_SET
) {
246 /* set mode: reset UIP mode */
247 s
->cmos_data
[RTC_REG_A
] &= ~REG_A_UIP
;
250 /* if disabling set mode, update the time */
251 if (s
->cmos_data
[RTC_REG_B
] & REG_B_SET
) {
255 if (((s
->cmos_data
[RTC_REG_B
] ^ data
) & (REG_B_DM
| REG_B_24H
)) &&
256 !(data
& REG_B_SET
)) {
257 /* If the time format has changed and not in set mode,
258 update the registers immediately. */
259 s
->cmos_data
[RTC_REG_B
] = data
;
262 s
->cmos_data
[RTC_REG_B
] = data
;
264 rtc_timer_update(s
, qemu_get_clock_ns(rtc_clock
));
268 /* cannot write to them */
271 s
->cmos_data
[s
->cmos_index
] = data
;
277 static inline int rtc_to_bcd(RTCState
*s
, int a
)
279 if (s
->cmos_data
[RTC_REG_B
] & REG_B_DM
) {
282 return ((a
/ 10) << 4) | (a
% 10);
286 static inline int rtc_from_bcd(RTCState
*s
, int a
)
288 if (s
->cmos_data
[RTC_REG_B
] & REG_B_DM
) {
291 return ((a
>> 4) * 10) + (a
& 0x0f);
295 static void rtc_set_time(RTCState
*s
)
297 struct tm
*tm
= &s
->current_tm
;
299 tm
->tm_sec
= rtc_from_bcd(s
, s
->cmos_data
[RTC_SECONDS
]);
300 tm
->tm_min
= rtc_from_bcd(s
, s
->cmos_data
[RTC_MINUTES
]);
301 tm
->tm_hour
= rtc_from_bcd(s
, s
->cmos_data
[RTC_HOURS
] & 0x7f);
302 if (!(s
->cmos_data
[RTC_REG_B
] & REG_B_24H
)) {
304 if (s
->cmos_data
[RTC_HOURS
] & 0x80) {
308 tm
->tm_wday
= rtc_from_bcd(s
, s
->cmos_data
[RTC_DAY_OF_WEEK
]) - 1;
309 tm
->tm_mday
= rtc_from_bcd(s
, s
->cmos_data
[RTC_DAY_OF_MONTH
]);
310 tm
->tm_mon
= rtc_from_bcd(s
, s
->cmos_data
[RTC_MONTH
]) - 1;
311 tm
->tm_year
= rtc_from_bcd(s
, s
->cmos_data
[RTC_YEAR
]) + s
->base_year
- 1900;
313 rtc_change_mon_event(tm
);
316 static void rtc_copy_date(RTCState
*s
)
318 const struct tm
*tm
= &s
->current_tm
;
321 s
->cmos_data
[RTC_SECONDS
] = rtc_to_bcd(s
, tm
->tm_sec
);
322 s
->cmos_data
[RTC_MINUTES
] = rtc_to_bcd(s
, tm
->tm_min
);
323 if (s
->cmos_data
[RTC_REG_B
] & REG_B_24H
) {
325 s
->cmos_data
[RTC_HOURS
] = rtc_to_bcd(s
, tm
->tm_hour
);
328 int h
= (tm
->tm_hour
% 12) ? tm
->tm_hour
% 12 : 12;
329 s
->cmos_data
[RTC_HOURS
] = rtc_to_bcd(s
, h
);
330 if (tm
->tm_hour
>= 12)
331 s
->cmos_data
[RTC_HOURS
] |= 0x80;
333 s
->cmos_data
[RTC_DAY_OF_WEEK
] = rtc_to_bcd(s
, tm
->tm_wday
+ 1);
334 s
->cmos_data
[RTC_DAY_OF_MONTH
] = rtc_to_bcd(s
, tm
->tm_mday
);
335 s
->cmos_data
[RTC_MONTH
] = rtc_to_bcd(s
, tm
->tm_mon
+ 1);
336 year
= (tm
->tm_year
- s
->base_year
) % 100;
339 s
->cmos_data
[RTC_YEAR
] = rtc_to_bcd(s
, year
);
342 /* month is between 0 and 11. */
343 static int get_days_in_month(int month
, int year
)
345 static const int days_tab
[12] = {
346 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
349 if ((unsigned )month
>= 12)
353 if ((year
% 4) == 0 && ((year
% 100) != 0 || (year
% 400) == 0))
359 /* update 'tm' to the next second */
360 static void rtc_next_second(struct tm
*tm
)
365 if ((unsigned)tm
->tm_sec
>= 60) {
368 if ((unsigned)tm
->tm_min
>= 60) {
371 if ((unsigned)tm
->tm_hour
>= 24) {
375 if ((unsigned)tm
->tm_wday
>= 7)
377 days_in_month
= get_days_in_month(tm
->tm_mon
,
380 if (tm
->tm_mday
< 1) {
382 } else if (tm
->tm_mday
> days_in_month
) {
385 if (tm
->tm_mon
>= 12) {
396 static void rtc_update_second(void *opaque
)
398 RTCState
*s
= opaque
;
401 /* if the oscillator is not in normal operation, we do not update */
402 if ((s
->cmos_data
[RTC_REG_A
] & 0x70) != 0x20) {
403 s
->next_second_time
+= get_ticks_per_sec();
404 qemu_mod_timer(s
->second_timer
, s
->next_second_time
);
406 rtc_next_second(&s
->current_tm
);
408 if (!(s
->cmos_data
[RTC_REG_B
] & REG_B_SET
)) {
409 /* update in progress bit */
410 s
->cmos_data
[RTC_REG_A
] |= REG_A_UIP
;
412 /* should be 244 us = 8 / 32768 seconds, but currently the
413 timers do not have the necessary resolution. */
414 delay
= (get_ticks_per_sec() * 1) / 100;
417 qemu_mod_timer(s
->second_timer2
,
418 s
->next_second_time
+ delay
);
422 static void rtc_update_second2(void *opaque
)
424 RTCState
*s
= opaque
;
426 if (!(s
->cmos_data
[RTC_REG_B
] & REG_B_SET
)) {
431 if (((s
->cmos_data
[RTC_SECONDS_ALARM
] & 0xc0) == 0xc0 ||
432 rtc_from_bcd(s
, s
->cmos_data
[RTC_SECONDS_ALARM
]) == s
->current_tm
.tm_sec
) &&
433 ((s
->cmos_data
[RTC_MINUTES_ALARM
] & 0xc0) == 0xc0 ||
434 rtc_from_bcd(s
, s
->cmos_data
[RTC_MINUTES_ALARM
]) == s
->current_tm
.tm_min
) &&
435 ((s
->cmos_data
[RTC_HOURS_ALARM
] & 0xc0) == 0xc0 ||
436 rtc_from_bcd(s
, s
->cmos_data
[RTC_HOURS_ALARM
]) == s
->current_tm
.tm_hour
)) {
438 s
->cmos_data
[RTC_REG_C
] |= REG_C_AF
;
439 if (s
->cmos_data
[RTC_REG_B
] & REG_B_AIE
) {
440 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_RTC
);
441 qemu_irq_raise(s
->irq
);
442 s
->cmos_data
[RTC_REG_C
] |= REG_C_IRQF
;
446 /* update ended interrupt */
447 s
->cmos_data
[RTC_REG_C
] |= REG_C_UF
;
448 if (s
->cmos_data
[RTC_REG_B
] & REG_B_UIE
) {
449 s
->cmos_data
[RTC_REG_C
] |= REG_C_IRQF
;
450 qemu_irq_raise(s
->irq
);
453 /* clear update in progress bit */
454 s
->cmos_data
[RTC_REG_A
] &= ~REG_A_UIP
;
456 s
->next_second_time
+= get_ticks_per_sec();
457 qemu_mod_timer(s
->second_timer
, s
->next_second_time
);
460 static uint32_t cmos_ioport_read(void *opaque
, uint32_t addr
)
462 RTCState
*s
= opaque
;
464 if ((addr
& 1) == 0) {
467 switch(s
->cmos_index
) {
471 case RTC_DAY_OF_WEEK
:
472 case RTC_DAY_OF_MONTH
:
475 ret
= s
->cmos_data
[s
->cmos_index
];
478 ret
= s
->cmos_data
[s
->cmos_index
];
481 ret
= s
->cmos_data
[s
->cmos_index
];
482 qemu_irq_lower(s
->irq
);
483 s
->cmos_data
[RTC_REG_C
] = 0x00;
485 if(s
->irq_coalesced
&&
486 (s
->cmos_data
[RTC_REG_B
] & REG_B_PIE
) &&
487 s
->irq_reinject_on_ack_count
< RTC_REINJECT_ON_ACK_COUNT
) {
488 s
->irq_reinject_on_ack_count
++;
489 s
->cmos_data
[RTC_REG_C
] |= REG_C_IRQF
| REG_C_PF
;
490 apic_reset_irq_delivered();
491 DPRINTF_C("cmos: injecting on ack\n");
492 qemu_irq_raise(s
->irq
);
493 if (apic_get_irq_delivered()) {
495 DPRINTF_C("cmos: coalesced irqs decreased to %d\n",
502 ret
= s
->cmos_data
[s
->cmos_index
];
505 CMOS_DPRINTF("cmos: read index=0x%02x val=0x%02x\n",
511 void rtc_set_memory(ISADevice
*dev
, int addr
, int val
)
513 RTCState
*s
= DO_UPCAST(RTCState
, dev
, dev
);
514 if (addr
>= 0 && addr
<= 127)
515 s
->cmos_data
[addr
] = val
;
518 void rtc_set_date(ISADevice
*dev
, const struct tm
*tm
)
520 RTCState
*s
= DO_UPCAST(RTCState
, dev
, dev
);
525 /* PC cmos mappings */
526 #define REG_IBM_CENTURY_BYTE 0x32
527 #define REG_IBM_PS2_CENTURY_BYTE 0x37
529 static void rtc_set_date_from_host(ISADevice
*dev
)
531 RTCState
*s
= DO_UPCAST(RTCState
, dev
, dev
);
535 /* set the CMOS date */
536 qemu_get_timedate(&tm
, 0);
537 rtc_set_date(dev
, &tm
);
539 val
= rtc_to_bcd(s
, (tm
.tm_year
/ 100) + 19);
540 rtc_set_memory(dev
, REG_IBM_CENTURY_BYTE
, val
);
541 rtc_set_memory(dev
, REG_IBM_PS2_CENTURY_BYTE
, val
);
544 static int rtc_post_load(void *opaque
, int version_id
)
547 RTCState
*s
= opaque
;
549 if (version_id
>= 2) {
550 if (s
->lost_tick_policy
== LOST_TICK_SLEW
) {
551 rtc_coalesced_timer_update(s
);
558 static const VMStateDescription vmstate_rtc
= {
559 .name
= "mc146818rtc",
561 .minimum_version_id
= 1,
562 .minimum_version_id_old
= 1,
563 .post_load
= rtc_post_load
,
564 .fields
= (VMStateField
[]) {
565 VMSTATE_BUFFER(cmos_data
, RTCState
),
566 VMSTATE_UINT8(cmos_index
, RTCState
),
567 VMSTATE_INT32(current_tm
.tm_sec
, RTCState
),
568 VMSTATE_INT32(current_tm
.tm_min
, RTCState
),
569 VMSTATE_INT32(current_tm
.tm_hour
, RTCState
),
570 VMSTATE_INT32(current_tm
.tm_wday
, RTCState
),
571 VMSTATE_INT32(current_tm
.tm_mday
, RTCState
),
572 VMSTATE_INT32(current_tm
.tm_mon
, RTCState
),
573 VMSTATE_INT32(current_tm
.tm_year
, RTCState
),
574 VMSTATE_TIMER(periodic_timer
, RTCState
),
575 VMSTATE_INT64(next_periodic_time
, RTCState
),
576 VMSTATE_INT64(next_second_time
, RTCState
),
577 VMSTATE_TIMER(second_timer
, RTCState
),
578 VMSTATE_TIMER(second_timer2
, RTCState
),
579 VMSTATE_UINT32_V(irq_coalesced
, RTCState
, 2),
580 VMSTATE_UINT32_V(period
, RTCState
, 2),
581 VMSTATE_END_OF_LIST()
585 static void rtc_notify_clock_reset(Notifier
*notifier
, void *data
)
587 RTCState
*s
= container_of(notifier
, RTCState
, clock_reset_notifier
);
588 int64_t now
= *(int64_t *)data
;
590 rtc_set_date_from_host(&s
->dev
);
591 s
->next_second_time
= now
+ (get_ticks_per_sec() * 99) / 100;
592 qemu_mod_timer(s
->second_timer2
, s
->next_second_time
);
593 rtc_timer_update(s
, now
);
595 if (s
->lost_tick_policy
== LOST_TICK_SLEW
) {
596 rtc_coalesced_timer_update(s
);
601 /* set CMOS shutdown status register (index 0xF) as S3_resume(0xFE)
602 BIOS will read it and start S3 resume at POST Entry */
603 static void rtc_notify_suspend(Notifier
*notifier
, void *data
)
605 RTCState
*s
= container_of(notifier
, RTCState
, suspend_notifier
);
606 rtc_set_memory(&s
->dev
, 0xF, 0xFE);
609 static void rtc_reset(void *opaque
)
611 RTCState
*s
= opaque
;
613 s
->cmos_data
[RTC_REG_B
] &= ~(REG_B_PIE
| REG_B_AIE
| REG_B_SQWE
);
614 s
->cmos_data
[RTC_REG_C
] &= ~(REG_C_UF
| REG_C_IRQF
| REG_C_PF
| REG_C_AF
);
616 qemu_irq_lower(s
->irq
);
619 if (s
->lost_tick_policy
== LOST_TICK_SLEW
) {
620 s
->irq_coalesced
= 0;
625 static const MemoryRegionPortio cmos_portio
[] = {
626 {0, 2, 1, .read
= cmos_ioport_read
, .write
= cmos_ioport_write
},
627 PORTIO_END_OF_LIST(),
630 static const MemoryRegionOps cmos_ops
= {
631 .old_portio
= cmos_portio
634 // FIXME add int32 visitor
635 static void visit_type_int32(Visitor
*v
, int *value
, const char *name
, Error
**errp
)
637 int64_t val
= *value
;
638 visit_type_int(v
, &val
, name
, errp
);
641 static void rtc_get_date(Object
*obj
, Visitor
*v
, void *opaque
,
642 const char *name
, Error
**errp
)
644 ISADevice
*isa
= ISA_DEVICE(obj
);
645 RTCState
*s
= DO_UPCAST(RTCState
, dev
, isa
);
647 visit_start_struct(v
, NULL
, "struct tm", name
, 0, errp
);
648 visit_type_int32(v
, &s
->current_tm
.tm_year
, "tm_year", errp
);
649 visit_type_int32(v
, &s
->current_tm
.tm_mon
, "tm_mon", errp
);
650 visit_type_int32(v
, &s
->current_tm
.tm_mday
, "tm_mday", errp
);
651 visit_type_int32(v
, &s
->current_tm
.tm_hour
, "tm_hour", errp
);
652 visit_type_int32(v
, &s
->current_tm
.tm_min
, "tm_min", errp
);
653 visit_type_int32(v
, &s
->current_tm
.tm_sec
, "tm_sec", errp
);
654 visit_end_struct(v
, errp
);
657 static int rtc_initfn(ISADevice
*dev
)
659 RTCState
*s
= DO_UPCAST(RTCState
, dev
, dev
);
662 s
->cmos_data
[RTC_REG_A
] = 0x26;
663 s
->cmos_data
[RTC_REG_B
] = 0x02;
664 s
->cmos_data
[RTC_REG_C
] = 0x00;
665 s
->cmos_data
[RTC_REG_D
] = 0x80;
667 rtc_set_date_from_host(dev
);
670 switch (s
->lost_tick_policy
) {
673 qemu_new_timer_ns(rtc_clock
, rtc_coalesced_timer
, s
);
675 case LOST_TICK_DISCARD
:
682 s
->periodic_timer
= qemu_new_timer_ns(rtc_clock
, rtc_periodic_timer
, s
);
683 s
->second_timer
= qemu_new_timer_ns(rtc_clock
, rtc_update_second
, s
);
684 s
->second_timer2
= qemu_new_timer_ns(rtc_clock
, rtc_update_second2
, s
);
686 s
->clock_reset_notifier
.notify
= rtc_notify_clock_reset
;
687 qemu_register_clock_reset_notifier(rtc_clock
, &s
->clock_reset_notifier
);
689 s
->suspend_notifier
.notify
= rtc_notify_suspend
;
690 qemu_register_suspend_notifier(&s
->suspend_notifier
);
692 s
->next_second_time
=
693 qemu_get_clock_ns(rtc_clock
) + (get_ticks_per_sec() * 99) / 100;
694 qemu_mod_timer(s
->second_timer2
, s
->next_second_time
);
696 memory_region_init_io(&s
->io
, &cmos_ops
, s
, "rtc", 2);
697 isa_register_ioport(dev
, &s
->io
, base
);
699 qdev_set_legacy_instance_id(&dev
->qdev
, base
, 2);
700 qemu_register_reset(rtc_reset
, s
);
702 object_property_add(OBJECT(s
), "date", "struct tm",
703 rtc_get_date
, NULL
, NULL
, s
, NULL
);
708 ISADevice
*rtc_init(ISABus
*bus
, int base_year
, qemu_irq intercept_irq
)
713 dev
= isa_create(bus
, "mc146818rtc");
714 s
= DO_UPCAST(RTCState
, dev
, dev
);
715 qdev_prop_set_int32(&dev
->qdev
, "base_year", base_year
);
716 qdev_init_nofail(&dev
->qdev
);
718 s
->irq
= intercept_irq
;
720 isa_init_irq(dev
, &s
->irq
, RTC_ISA_IRQ
);
725 static Property mc146818rtc_properties
[] = {
726 DEFINE_PROP_INT32("base_year", RTCState
, base_year
, 1980),
727 DEFINE_PROP_LOSTTICKPOLICY("lost_tick_policy", RTCState
,
728 lost_tick_policy
, LOST_TICK_DISCARD
),
729 DEFINE_PROP_END_OF_LIST(),
732 static void rtc_class_initfn(ObjectClass
*klass
, void *data
)
734 DeviceClass
*dc
= DEVICE_CLASS(klass
);
735 ISADeviceClass
*ic
= ISA_DEVICE_CLASS(klass
);
736 ic
->init
= rtc_initfn
;
738 dc
->vmsd
= &vmstate_rtc
;
739 dc
->props
= mc146818rtc_properties
;
742 static TypeInfo mc146818rtc_info
= {
743 .name
= "mc146818rtc",
744 .parent
= TYPE_ISA_DEVICE
,
745 .instance_size
= sizeof(RTCState
),
746 .class_init
= rtc_class_initfn
,
749 static void mc146818rtc_register_types(void)
751 type_register_static(&mc146818rtc_info
);
754 type_init(mc146818rtc_register_types
)