2 * KVM in-kernel PIT (i8254) support
4 * Copyright (c) 2003-2004 Fabrice Bellard
5 * Copyright (c) 2012 Jan Kiszka, Siemens AG
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu/osdep.h"
26 #include "qapi/error.h"
27 #include "qemu/timer.h"
28 #include "sysemu/sysemu.h"
29 #include "hw/timer/i8254.h"
30 #include "hw/timer/i8254_internal.h"
31 #include "sysemu/kvm.h"
33 #define KVM_PIT_REINJECT_BIT 0
35 #define CALIBRATION_ROUNDS 3
37 #define KVM_PIT(obj) OBJECT_CHECK(KVMPITState, (obj), TYPE_KVM_I8254)
38 #define KVM_PIT_CLASS(class) \
39 OBJECT_CLASS_CHECK(KVMPITClass, (class), TYPE_KVM_I8254)
40 #define KVM_PIT_GET_CLASS(obj) \
41 OBJECT_GET_CLASS(KVMPITClass, (obj), TYPE_KVM_I8254)
43 typedef struct KVMPITState
{
44 PITCommonState parent_obj
;
46 LostTickPolicy lost_tick_policy
;
48 int64_t kernel_clock_offset
;
51 typedef struct KVMPITClass
{
52 PITCommonClass parent_class
;
54 DeviceRealize parent_realize
;
57 static int64_t abs64(int64_t v
)
59 return v
< 0 ? -v
: v
;
62 static void kvm_pit_update_clock_offset(KVMPITState
*s
)
64 int64_t offset
, clock_offset
;
69 * Measure the delta between CLOCK_MONOTONIC, the base used for
70 * kvm_pit_channel_state::count_load_time, and QEMU_CLOCK_VIRTUAL. Take the
71 * minimum of several samples to filter out scheduling noise.
73 clock_offset
= INT64_MAX
;
74 for (i
= 0; i
< CALIBRATION_ROUNDS
; i
++) {
75 offset
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
76 clock_gettime(CLOCK_MONOTONIC
, &ts
);
78 offset
-= (int64_t)ts
.tv_sec
* 1000000000;
79 if (abs64(offset
) < abs64(clock_offset
)) {
80 clock_offset
= offset
;
83 s
->kernel_clock_offset
= clock_offset
;
86 static void kvm_pit_get(PITCommonState
*pit
)
88 KVMPITState
*s
= KVM_PIT(pit
);
89 struct kvm_pit_state2 kpit
;
90 struct kvm_pit_channel_state
*kchan
;
91 struct PITChannelState
*sc
;
94 /* No need to re-read the state if VM is stopped. */
99 if (kvm_has_pit_state2()) {
100 ret
= kvm_vm_ioctl(kvm_state
, KVM_GET_PIT2
, &kpit
);
102 fprintf(stderr
, "KVM_GET_PIT2 failed: %s\n", strerror(ret
));
105 pit
->channels
[0].irq_disabled
= kpit
.flags
& KVM_PIT_FLAGS_HPET_LEGACY
;
108 * kvm_pit_state2 is superset of kvm_pit_state struct,
109 * so we can use it for KVM_GET_PIT as well.
111 ret
= kvm_vm_ioctl(kvm_state
, KVM_GET_PIT
, &kpit
);
113 fprintf(stderr
, "KVM_GET_PIT failed: %s\n", strerror(ret
));
117 for (i
= 0; i
< 3; i
++) {
118 kchan
= &kpit
.channels
[i
];
119 sc
= &pit
->channels
[i
];
120 sc
->count
= kchan
->count
;
121 sc
->latched_count
= kchan
->latched_count
;
122 sc
->count_latched
= kchan
->count_latched
;
123 sc
->status_latched
= kchan
->status_latched
;
124 sc
->status
= kchan
->status
;
125 sc
->read_state
= kchan
->read_state
;
126 sc
->write_state
= kchan
->write_state
;
127 sc
->write_latch
= kchan
->write_latch
;
128 sc
->rw_mode
= kchan
->rw_mode
;
129 sc
->mode
= kchan
->mode
;
130 sc
->bcd
= kchan
->bcd
;
131 sc
->gate
= kchan
->gate
;
132 sc
->count_load_time
= kchan
->count_load_time
+ s
->kernel_clock_offset
;
135 sc
= &pit
->channels
[0];
136 sc
->next_transition_time
=
137 pit_get_next_transition_time(sc
, sc
->count_load_time
);
140 static void kvm_pit_put(PITCommonState
*pit
)
142 KVMPITState
*s
= KVM_PIT(pit
);
143 struct kvm_pit_state2 kpit
= {};
144 struct kvm_pit_channel_state
*kchan
;
145 struct PITChannelState
*sc
;
148 /* The offset keeps changing as long as the VM is stopped. */
150 kvm_pit_update_clock_offset(s
);
153 kpit
.flags
= pit
->channels
[0].irq_disabled
? KVM_PIT_FLAGS_HPET_LEGACY
: 0;
154 for (i
= 0; i
< 3; i
++) {
155 kchan
= &kpit
.channels
[i
];
156 sc
= &pit
->channels
[i
];
157 kchan
->count
= sc
->count
;
158 kchan
->latched_count
= sc
->latched_count
;
159 kchan
->count_latched
= sc
->count_latched
;
160 kchan
->status_latched
= sc
->status_latched
;
161 kchan
->status
= sc
->status
;
162 kchan
->read_state
= sc
->read_state
;
163 kchan
->write_state
= sc
->write_state
;
164 kchan
->write_latch
= sc
->write_latch
;
165 kchan
->rw_mode
= sc
->rw_mode
;
166 kchan
->mode
= sc
->mode
;
167 kchan
->bcd
= sc
->bcd
;
168 kchan
->gate
= sc
->gate
;
169 kchan
->count_load_time
= sc
->count_load_time
- s
->kernel_clock_offset
;
172 ret
= kvm_vm_ioctl(kvm_state
,
173 kvm_has_pit_state2() ? KVM_SET_PIT2
: KVM_SET_PIT
,
176 fprintf(stderr
, "%s failed: %s\n",
177 kvm_has_pit_state2() ? "KVM_SET_PIT2" : "KVM_SET_PIT",
183 static void kvm_pit_set_gate(PITCommonState
*s
, PITChannelState
*sc
, int val
)
191 /* XXX: just disable/enable counting */
197 if (sc
->gate
< val
) {
198 /* restart counting on rising edge */
199 sc
->count_load_time
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
208 static void kvm_pit_get_channel_info(PITCommonState
*s
, PITChannelState
*sc
,
209 PITChannelInfo
*info
)
213 pit_get_channel_info_common(s
, sc
, info
);
216 static void kvm_pit_reset(DeviceState
*dev
)
218 PITCommonState
*s
= PIT_COMMON(dev
);
225 static void kvm_pit_irq_control(void *opaque
, int n
, int enable
)
227 PITCommonState
*pit
= opaque
;
228 PITChannelState
*s
= &pit
->channels
[0];
232 s
->irq_disabled
= !enable
;
237 static void kvm_pit_vm_state_change(void *opaque
, int running
,
240 KVMPITState
*s
= opaque
;
243 kvm_pit_update_clock_offset(s
);
244 kvm_pit_put(PIT_COMMON(s
));
245 s
->vm_stopped
= false;
247 kvm_pit_update_clock_offset(s
);
248 kvm_pit_get(PIT_COMMON(s
));
249 s
->vm_stopped
= true;
253 static void kvm_pit_realizefn(DeviceState
*dev
, Error
**errp
)
255 PITCommonState
*pit
= PIT_COMMON(dev
);
256 KVMPITClass
*kpc
= KVM_PIT_GET_CLASS(dev
);
257 KVMPITState
*s
= KVM_PIT(pit
);
258 struct kvm_pit_config config
= {
263 if (kvm_check_extension(kvm_state
, KVM_CAP_PIT2
)) {
264 ret
= kvm_vm_ioctl(kvm_state
, KVM_CREATE_PIT2
, &config
);
266 ret
= kvm_vm_ioctl(kvm_state
, KVM_CREATE_PIT
);
269 error_setg(errp
, "Create kernel PIC irqchip failed: %s",
273 switch (s
->lost_tick_policy
) {
274 case LOST_TICK_POLICY_DELAY
:
275 break; /* enabled by default */
276 case LOST_TICK_POLICY_DISCARD
:
277 if (kvm_check_extension(kvm_state
, KVM_CAP_REINJECT_CONTROL
)) {
278 struct kvm_reinject_control control
= { .pit_reinject
= 0 };
280 ret
= kvm_vm_ioctl(kvm_state
, KVM_REINJECT_CONTROL
, &control
);
283 "Can't disable in-kernel PIT reinjection: %s",
290 error_setg(errp
, "Lost tick policy not supported.");
294 memory_region_init_reservation(&pit
->ioports
, NULL
, "kvm-pit", 4);
296 qdev_init_gpio_in(dev
, kvm_pit_irq_control
, 1);
298 qemu_add_vm_change_state_handler(kvm_pit_vm_state_change
, s
);
300 kpc
->parent_realize(dev
, errp
);
303 static Property kvm_pit_properties
[] = {
304 DEFINE_PROP_UINT32("iobase", PITCommonState
, iobase
, -1),
305 DEFINE_PROP_LOSTTICKPOLICY("lost_tick_policy", KVMPITState
,
306 lost_tick_policy
, LOST_TICK_POLICY_DELAY
),
307 DEFINE_PROP_END_OF_LIST(),
310 static void kvm_pit_class_init(ObjectClass
*klass
, void *data
)
312 KVMPITClass
*kpc
= KVM_PIT_CLASS(klass
);
313 PITCommonClass
*k
= PIT_COMMON_CLASS(klass
);
314 DeviceClass
*dc
= DEVICE_CLASS(klass
);
316 kpc
->parent_realize
= dc
->realize
;
317 dc
->realize
= kvm_pit_realizefn
;
318 k
->set_channel_gate
= kvm_pit_set_gate
;
319 k
->get_channel_info
= kvm_pit_get_channel_info
;
320 dc
->reset
= kvm_pit_reset
;
321 dc
->props
= kvm_pit_properties
;
324 static const TypeInfo kvm_pit_info
= {
325 .name
= TYPE_KVM_I8254
,
326 .parent
= TYPE_PIT_COMMON
,
327 .instance_size
= sizeof(KVMPITState
),
328 .class_init
= kvm_pit_class_init
,
329 .class_size
= sizeof(KVMPITClass
),
332 static void kvm_pit_register(void)
334 type_register_static(&kvm_pit_info
);
337 type_init(kvm_pit_register
)