]>
git.proxmox.com Git - qemu.git/blob - hw/mc146818rtc.c
d5746835a11cc3065f75abcd1b0524511a4a0ef6
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
29 #define RTC_SECONDS_ALARM 1
31 #define RTC_MINUTES_ALARM 3
33 #define RTC_HOURS_ALARM 5
34 #define RTC_ALARM_DONT_CARE 0xC0
36 #define RTC_DAY_OF_WEEK 6
37 #define RTC_DAY_OF_MONTH 7
46 #define REG_A_UIP 0x80
48 #define REG_B_SET 0x80
49 #define REG_B_PIE 0x40
50 #define REG_B_AIE 0x20
51 #define REG_B_UIE 0x10
54 uint8_t cmos_data
[128];
56 int current_time
; /* in seconds */
58 uint8_t buf_data
[10]; /* buffered data */
60 QEMUTimer
*periodic_timer
;
61 int64_t next_periodic_time
;
63 int64_t next_second_time
;
64 QEMUTimer
*second_timer
;
65 QEMUTimer
*second_timer2
;
68 static void rtc_set_time(RTCState
*s
);
69 static void rtc_set_date_buf(RTCState
*s
, const struct tm
*tm
);
70 static void rtc_copy_date(RTCState
*s
);
72 static void rtc_timer_update(RTCState
*s
, int64_t current_time
)
74 int period_code
, period
;
75 int64_t cur_clock
, next_irq_clock
;
77 period_code
= s
->cmos_data
[RTC_REG_A
] & 0x0f;
78 if (period_code
!= 0 &&
79 (s
->cmos_data
[RTC_REG_B
] & REG_B_PIE
)) {
82 /* period in 32 Khz cycles */
83 period
= 1 << (period_code
- 1);
84 /* compute 32 khz clock */
85 cur_clock
= muldiv64(current_time
, 32768, ticks_per_sec
);
86 next_irq_clock
= (cur_clock
& ~(period
- 1)) + period
;
87 s
->next_periodic_time
= muldiv64(next_irq_clock
, ticks_per_sec
, 32768) + 1;
88 qemu_mod_timer(s
->periodic_timer
, s
->next_periodic_time
);
90 qemu_del_timer(s
->periodic_timer
);
94 static void rtc_periodic_timer(void *opaque
)
98 rtc_timer_update(s
, s
->next_periodic_time
);
99 s
->cmos_data
[RTC_REG_C
] |= 0xc0;
100 pic_set_irq(s
->irq
, 1);
103 static void cmos_ioport_write(void *opaque
, uint32_t addr
, uint32_t data
)
105 RTCState
*s
= opaque
;
107 if ((addr
& 1) == 0) {
108 s
->cmos_index
= data
& 0x7f;
111 printf("cmos: write index=0x%02x val=0x%02x\n",
112 s
->cmos_index
, data
);
114 switch(s
->cmos_index
) {
115 case RTC_SECONDS_ALARM
:
116 case RTC_MINUTES_ALARM
:
117 case RTC_HOURS_ALARM
:
118 /* XXX: not supported */
119 s
->cmos_data
[s
->cmos_index
] = data
;
124 case RTC_DAY_OF_WEEK
:
125 case RTC_DAY_OF_MONTH
:
128 s
->cmos_data
[s
->cmos_index
] = data
;
129 /* if in set mode, do not update the time */
130 if (!(s
->cmos_data
[RTC_REG_B
] & REG_B_SET
)) {
135 /* UIP bit is read only */
136 s
->cmos_data
[RTC_REG_A
] = (data
& ~REG_A_UIP
) |
137 (s
->cmos_data
[RTC_REG_A
] & REG_A_UIP
);
138 rtc_timer_update(s
, qemu_get_clock(vm_clock
));
141 if (data
& REG_B_SET
) {
142 /* set mode: reset UIP mode */
143 s
->cmos_data
[RTC_REG_A
] &= ~REG_A_UIP
;
146 /* if disabling set mode, update the time */
147 if (s
->cmos_data
[RTC_REG_B
] & REG_B_SET
) {
151 s
->cmos_data
[RTC_REG_B
] = data
;
152 rtc_timer_update(s
, qemu_get_clock(vm_clock
));
156 /* cannot write to them */
159 s
->cmos_data
[s
->cmos_index
] = data
;
165 static inline int to_bcd(RTCState
*s
, int a
)
167 if (s
->cmos_data
[RTC_REG_B
] & 0x04) {
170 return ((a
/ 10) << 4) | (a
% 10);
174 static inline int from_bcd(RTCState
*s
, int a
)
176 if (s
->cmos_data
[RTC_REG_B
] & 0x04) {
179 return ((a
>> 4) * 10) + (a
& 0x0f);
183 static void rtc_set_time(RTCState
*s
)
185 struct tm tm1
, *tm
= &tm1
;
187 tm
->tm_sec
= from_bcd(s
, s
->cmos_data
[RTC_SECONDS
]);
188 tm
->tm_min
= from_bcd(s
, s
->cmos_data
[RTC_MINUTES
]);
189 tm
->tm_hour
= from_bcd(s
, s
->cmos_data
[RTC_HOURS
]);
190 tm
->tm_wday
= from_bcd(s
, s
->cmos_data
[RTC_DAY_OF_WEEK
]);
191 tm
->tm_mday
= from_bcd(s
, s
->cmos_data
[RTC_DAY_OF_MONTH
]);
192 tm
->tm_mon
= from_bcd(s
, s
->cmos_data
[RTC_MONTH
]) - 1;
193 tm
->tm_year
= from_bcd(s
, s
->cmos_data
[RTC_YEAR
]) + 100;
195 /* update internal state */
196 s
->buf_data
[RTC_SECONDS
] = s
->cmos_data
[RTC_SECONDS
];
197 s
->buf_data
[RTC_MINUTES
] = s
->cmos_data
[RTC_MINUTES
];
198 s
->buf_data
[RTC_HOURS
] = s
->cmos_data
[RTC_HOURS
];
199 s
->buf_data
[RTC_DAY_OF_WEEK
] = s
->cmos_data
[RTC_DAY_OF_WEEK
];
200 s
->buf_data
[RTC_DAY_OF_MONTH
] = s
->cmos_data
[RTC_DAY_OF_MONTH
];
201 s
->buf_data
[RTC_MONTH
] = s
->cmos_data
[RTC_MONTH
];
202 s
->buf_data
[RTC_YEAR
] = s
->cmos_data
[RTC_YEAR
];
203 s
->current_time
= mktime(tm
);
206 static void rtc_update_second(void *opaque
)
208 RTCState
*s
= opaque
;
210 /* if the oscillator is not in normal operation, we do not update */
211 if ((s
->cmos_data
[RTC_REG_A
] & 0x70) != 0x20) {
212 s
->next_second_time
+= ticks_per_sec
;
213 qemu_mod_timer(s
->second_timer
, s
->next_second_time
);
217 if (!(s
->cmos_data
[RTC_REG_B
] & REG_B_SET
)) {
218 /* update in progress bit */
219 s
->cmos_data
[RTC_REG_A
] |= REG_A_UIP
;
221 qemu_mod_timer(s
->second_timer2
,
222 s
->next_second_time
+ (ticks_per_sec
* 99) / 100);
226 static void rtc_update_second2(void *opaque
)
228 RTCState
*s
= opaque
;
231 ti
= s
->current_time
;
232 rtc_set_date_buf(s
, gmtime(&ti
));
234 if (!(s
->cmos_data
[RTC_REG_B
] & REG_B_SET
)) {
239 if (s
->cmos_data
[RTC_REG_B
] & REG_B_AIE
) {
240 if (((s
->cmos_data
[RTC_SECONDS_ALARM
] & 0xc0) == 0xc0 ||
241 s
->cmos_data
[RTC_SECONDS_ALARM
] == s
->buf_data
[RTC_SECONDS
]) &&
242 ((s
->cmos_data
[RTC_MINUTES_ALARM
] & 0xc0) == 0xc0 ||
243 s
->cmos_data
[RTC_MINUTES_ALARM
] == s
->buf_data
[RTC_MINUTES
]) &&
244 ((s
->cmos_data
[RTC_HOURS_ALARM
] & 0xc0) == 0xc0 ||
245 s
->cmos_data
[RTC_HOURS_ALARM
] == s
->buf_data
[RTC_HOURS
])) {
247 s
->cmos_data
[RTC_REG_C
] |= 0xa0;
248 pic_set_irq(s
->irq
, 1);
252 /* update ended interrupt */
253 if (s
->cmos_data
[RTC_REG_B
] & REG_B_UIE
) {
254 s
->cmos_data
[RTC_REG_C
] |= 0x90;
255 pic_set_irq(s
->irq
, 1);
258 /* clear update in progress bit */
259 s
->cmos_data
[RTC_REG_A
] &= ~REG_A_UIP
;
261 s
->next_second_time
+= ticks_per_sec
;
262 qemu_mod_timer(s
->second_timer
, s
->next_second_time
);
265 static uint32_t cmos_ioport_read(void *opaque
, uint32_t addr
)
267 RTCState
*s
= opaque
;
269 if ((addr
& 1) == 0) {
272 switch(s
->cmos_index
) {
276 case RTC_DAY_OF_WEEK
:
277 case RTC_DAY_OF_MONTH
:
280 ret
= s
->cmos_data
[s
->cmos_index
];
283 ret
= s
->cmos_data
[s
->cmos_index
];
286 ret
= s
->cmos_data
[s
->cmos_index
];
287 pic_set_irq(s
->irq
, 0);
288 s
->cmos_data
[RTC_REG_C
] = 0x00;
291 ret
= s
->cmos_data
[s
->cmos_index
];
295 printf("cmos: read index=0x%02x val=0x%02x\n",
302 static void rtc_set_date_buf(RTCState
*s
, const struct tm
*tm
)
304 s
->buf_data
[RTC_SECONDS
] = to_bcd(s
, tm
->tm_sec
);
305 s
->buf_data
[RTC_MINUTES
] = to_bcd(s
, tm
->tm_min
);
306 if (s
->cmos_data
[RTC_REG_B
] & 0x02) {
308 s
->buf_data
[RTC_HOURS
] = to_bcd(s
, tm
->tm_hour
);
311 s
->buf_data
[RTC_HOURS
] = to_bcd(s
, tm
->tm_hour
% 12);
312 if (tm
->tm_hour
>= 12)
313 s
->buf_data
[RTC_HOURS
] |= 0x80;
315 s
->buf_data
[RTC_DAY_OF_WEEK
] = to_bcd(s
, tm
->tm_wday
);
316 s
->buf_data
[RTC_DAY_OF_MONTH
] = to_bcd(s
, tm
->tm_mday
);
317 s
->buf_data
[RTC_MONTH
] = to_bcd(s
, tm
->tm_mon
+ 1);
318 s
->buf_data
[RTC_YEAR
] = to_bcd(s
, tm
->tm_year
% 100);
321 static void rtc_copy_date(RTCState
*s
)
323 s
->cmos_data
[RTC_SECONDS
] = s
->buf_data
[RTC_SECONDS
];
324 s
->cmos_data
[RTC_MINUTES
] = s
->buf_data
[RTC_MINUTES
];
325 s
->cmos_data
[RTC_HOURS
] = s
->buf_data
[RTC_HOURS
];
326 s
->cmos_data
[RTC_DAY_OF_WEEK
] = s
->buf_data
[RTC_DAY_OF_WEEK
];
327 s
->cmos_data
[RTC_DAY_OF_MONTH
] = s
->buf_data
[RTC_DAY_OF_MONTH
];
328 s
->cmos_data
[RTC_MONTH
] = s
->buf_data
[RTC_MONTH
];
329 s
->cmos_data
[RTC_YEAR
] = s
->buf_data
[RTC_YEAR
];
332 void rtc_set_memory(RTCState
*s
, int addr
, int val
)
334 if (addr
>= 0 && addr
<= 127)
335 s
->cmos_data
[addr
] = val
;
338 void rtc_set_date(RTCState
*s
, const struct tm
*tm
)
340 s
->current_time
= mktime((struct tm
*)tm
);
341 rtc_set_date_buf(s
, tm
);
345 static void rtc_save(QEMUFile
*f
, void *opaque
)
347 RTCState
*s
= opaque
;
349 qemu_put_buffer(f
, s
->cmos_data
, 128);
350 qemu_put_8s(f
, &s
->cmos_index
);
351 qemu_put_be32s(f
, &s
->current_time
);
352 qemu_put_buffer(f
, s
->buf_data
, 10);
354 qemu_put_timer(f
, s
->periodic_timer
);
355 qemu_put_be64s(f
, &s
->next_periodic_time
);
357 qemu_put_be64s(f
, &s
->next_second_time
);
358 qemu_put_timer(f
, s
->second_timer
);
359 qemu_put_timer(f
, s
->second_timer2
);
362 static int rtc_load(QEMUFile
*f
, void *opaque
, int version_id
)
364 RTCState
*s
= opaque
;
369 qemu_get_buffer(f
, s
->cmos_data
, 128);
370 qemu_get_8s(f
, &s
->cmos_index
);
371 qemu_get_be32s(f
, &s
->current_time
);
372 qemu_get_buffer(f
, s
->buf_data
, 10);
374 qemu_get_timer(f
, s
->periodic_timer
);
375 qemu_get_be64s(f
, &s
->next_periodic_time
);
377 qemu_get_be64s(f
, &s
->next_second_time
);
378 qemu_get_timer(f
, s
->second_timer
);
379 qemu_get_timer(f
, s
->second_timer2
);
383 RTCState
*rtc_init(int base
, int irq
)
387 s
= qemu_mallocz(sizeof(RTCState
));
392 s
->cmos_data
[RTC_REG_A
] = 0x26;
393 s
->cmos_data
[RTC_REG_B
] = 0x02;
394 s
->cmos_data
[RTC_REG_C
] = 0x00;
395 s
->cmos_data
[RTC_REG_D
] = 0x80;
397 s
->periodic_timer
= qemu_new_timer(vm_clock
,
398 rtc_periodic_timer
, s
);
399 s
->second_timer
= qemu_new_timer(vm_clock
,
400 rtc_update_second
, s
);
401 s
->second_timer2
= qemu_new_timer(vm_clock
,
402 rtc_update_second2
, s
);
404 s
->next_second_time
= qemu_get_clock(vm_clock
) + (ticks_per_sec
* 99) / 100;
405 qemu_mod_timer(s
->second_timer2
, s
->next_second_time
);
407 register_ioport_write(base
, 2, 1, cmos_ioport_write
, s
);
408 register_ioport_read(base
, 2, 1, cmos_ioport_read
, s
);
410 register_savevm("mc146818rtc", base
, 1, rtc_save
, rtc_load
, s
);