2 * Copyright (C) 2012 ARM Ltd.
3 * Author: Marc Zyngier <marc.zyngier@arm.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 #include <linux/cpu.h>
20 #include <linux/kvm.h>
21 #include <linux/kvm_host.h>
22 #include <linux/interrupt.h>
23 #include <linux/irq.h>
24 #include <linux/uaccess.h>
26 #include <clocksource/arm_arch_timer.h>
27 #include <asm/arch_timer.h>
28 #include <asm/kvm_hyp.h>
30 #include <kvm/arm_vgic.h>
31 #include <kvm/arm_arch_timer.h>
35 static struct timecounter
*timecounter
;
36 static unsigned int host_vtimer_irq
;
37 static u32 host_vtimer_irq_flags
;
39 static const struct kvm_irq_level default_ptimer_irq
= {
44 static const struct kvm_irq_level default_vtimer_irq
= {
49 static bool kvm_timer_irq_can_fire(struct arch_timer_context
*timer_ctx
);
50 static void kvm_timer_update_irq(struct kvm_vcpu
*vcpu
, bool new_level
,
51 struct arch_timer_context
*timer_ctx
);
52 static bool kvm_timer_should_fire(struct arch_timer_context
*timer_ctx
);
54 u64
kvm_phys_timer_read(void)
56 return timecounter
->cc
->read(timecounter
->cc
);
59 static void soft_timer_start(struct hrtimer
*hrt
, u64 ns
)
61 hrtimer_start(hrt
, ktime_add_ns(ktime_get(), ns
),
65 static void soft_timer_cancel(struct hrtimer
*hrt
, struct work_struct
*work
)
69 cancel_work_sync(work
);
72 static void kvm_vtimer_update_mask_user(struct kvm_vcpu
*vcpu
)
74 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
77 * When using a userspace irqchip with the architected timers, we must
78 * prevent continuously exiting from the guest, and therefore mask the
79 * physical interrupt by disabling it on the host interrupt controller
80 * when the virtual level is high, such that the guest can make
81 * forward progress. Once we detect the output level being
82 * de-asserted, we unmask the interrupt again so that we exit from the
83 * guest when the timer fires.
85 if (vtimer
->irq
.level
)
86 disable_percpu_irq(host_vtimer_irq
);
88 enable_percpu_irq(host_vtimer_irq
, 0);
91 static irqreturn_t
kvm_arch_timer_handler(int irq
, void *dev_id
)
93 struct kvm_vcpu
*vcpu
= *(struct kvm_vcpu
**)dev_id
;
94 struct arch_timer_context
*vtimer
;
97 pr_warn_once("Spurious arch timer IRQ on non-VCPU thread\n");
100 vtimer
= vcpu_vtimer(vcpu
);
102 if (!vtimer
->irq
.level
) {
103 vtimer
->cnt_ctl
= read_sysreg_el0(cntv_ctl
);
104 if (kvm_timer_irq_can_fire(vtimer
))
105 kvm_timer_update_irq(vcpu
, true, vtimer
);
108 if (unlikely(!irqchip_in_kernel(vcpu
->kvm
)))
109 kvm_vtimer_update_mask_user(vcpu
);
115 * Work function for handling the backup timer that we schedule when a vcpu is
116 * no longer running, but had a timer programmed to fire in the future.
118 static void kvm_timer_inject_irq_work(struct work_struct
*work
)
120 struct kvm_vcpu
*vcpu
;
122 vcpu
= container_of(work
, struct kvm_vcpu
, arch
.timer_cpu
.expired
);
125 * If the vcpu is blocked we want to wake it up so that it will see
126 * the timer has expired when entering the guest.
128 kvm_vcpu_wake_up(vcpu
);
131 static u64
kvm_timer_compute_delta(struct arch_timer_context
*timer_ctx
)
135 cval
= timer_ctx
->cnt_cval
;
136 now
= kvm_phys_timer_read() - timer_ctx
->cntvoff
;
141 ns
= cyclecounter_cyc2ns(timecounter
->cc
,
151 static bool kvm_timer_irq_can_fire(struct arch_timer_context
*timer_ctx
)
153 return !(timer_ctx
->cnt_ctl
& ARCH_TIMER_CTRL_IT_MASK
) &&
154 (timer_ctx
->cnt_ctl
& ARCH_TIMER_CTRL_ENABLE
);
158 * Returns the earliest expiration time in ns among guest timers.
159 * Note that it will return 0 if none of timers can fire.
161 static u64
kvm_timer_earliest_exp(struct kvm_vcpu
*vcpu
)
163 u64 min_virt
= ULLONG_MAX
, min_phys
= ULLONG_MAX
;
164 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
165 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
167 if (kvm_timer_irq_can_fire(vtimer
))
168 min_virt
= kvm_timer_compute_delta(vtimer
);
170 if (kvm_timer_irq_can_fire(ptimer
))
171 min_phys
= kvm_timer_compute_delta(ptimer
);
173 /* If none of timers can fire, then return 0 */
174 if ((min_virt
== ULLONG_MAX
) && (min_phys
== ULLONG_MAX
))
177 return min(min_virt
, min_phys
);
180 static enum hrtimer_restart
kvm_bg_timer_expire(struct hrtimer
*hrt
)
182 struct arch_timer_cpu
*timer
;
183 struct kvm_vcpu
*vcpu
;
186 timer
= container_of(hrt
, struct arch_timer_cpu
, bg_timer
);
187 vcpu
= container_of(timer
, struct kvm_vcpu
, arch
.timer_cpu
);
190 * Check that the timer has really expired from the guest's
191 * PoV (NTP on the host may have forced it to expire
192 * early). If we should have slept longer, restart it.
194 ns
= kvm_timer_earliest_exp(vcpu
);
196 hrtimer_forward_now(hrt
, ns_to_ktime(ns
));
197 return HRTIMER_RESTART
;
200 schedule_work(&timer
->expired
);
201 return HRTIMER_NORESTART
;
204 static enum hrtimer_restart
kvm_phys_timer_expire(struct hrtimer
*hrt
)
206 struct arch_timer_context
*ptimer
;
207 struct arch_timer_cpu
*timer
;
208 struct kvm_vcpu
*vcpu
;
211 timer
= container_of(hrt
, struct arch_timer_cpu
, phys_timer
);
212 vcpu
= container_of(timer
, struct kvm_vcpu
, arch
.timer_cpu
);
213 ptimer
= vcpu_ptimer(vcpu
);
216 * Check that the timer has really expired from the guest's
217 * PoV (NTP on the host may have forced it to expire
218 * early). If not ready, schedule for a later time.
220 ns
= kvm_timer_compute_delta(ptimer
);
222 hrtimer_forward_now(hrt
, ns_to_ktime(ns
));
223 return HRTIMER_RESTART
;
226 kvm_timer_update_irq(vcpu
, true, ptimer
);
227 return HRTIMER_NORESTART
;
230 static bool kvm_timer_should_fire(struct arch_timer_context
*timer_ctx
)
234 if (!kvm_timer_irq_can_fire(timer_ctx
))
237 cval
= timer_ctx
->cnt_cval
;
238 now
= kvm_phys_timer_read() - timer_ctx
->cntvoff
;
243 bool kvm_timer_is_pending(struct kvm_vcpu
*vcpu
)
245 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
246 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
248 if (vtimer
->irq
.level
|| ptimer
->irq
.level
)
252 * When this is called from withing the wait loop of kvm_vcpu_block(),
253 * the software view of the timer state is up to date (timer->loaded
254 * is false), and so we can simply check if the timer should fire now.
256 if (!vtimer
->loaded
&& kvm_timer_should_fire(vtimer
))
259 return kvm_timer_should_fire(ptimer
);
263 * Reflect the timer output level into the kvm_run structure
265 void kvm_timer_update_run(struct kvm_vcpu
*vcpu
)
267 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
268 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
269 struct kvm_sync_regs
*regs
= &vcpu
->run
->s
.regs
;
271 /* Populate the device bitmap with the timer states */
272 regs
->device_irq_level
&= ~(KVM_ARM_DEV_EL1_VTIMER
|
273 KVM_ARM_DEV_EL1_PTIMER
);
274 if (vtimer
->irq
.level
)
275 regs
->device_irq_level
|= KVM_ARM_DEV_EL1_VTIMER
;
276 if (ptimer
->irq
.level
)
277 regs
->device_irq_level
|= KVM_ARM_DEV_EL1_PTIMER
;
280 static void kvm_timer_update_irq(struct kvm_vcpu
*vcpu
, bool new_level
,
281 struct arch_timer_context
*timer_ctx
)
285 timer_ctx
->irq
.level
= new_level
;
286 trace_kvm_timer_update_irq(vcpu
->vcpu_id
, timer_ctx
->irq
.irq
,
287 timer_ctx
->irq
.level
);
289 if (likely(irqchip_in_kernel(vcpu
->kvm
))) {
290 ret
= kvm_vgic_inject_irq(vcpu
->kvm
, vcpu
->vcpu_id
,
292 timer_ctx
->irq
.level
,
298 /* Schedule the background timer for the emulated timer. */
299 static void phys_timer_emulate(struct kvm_vcpu
*vcpu
)
301 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
302 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
305 * If the timer can fire now we have just raised the IRQ line and we
306 * don't need to have a soft timer scheduled for the future. If the
307 * timer cannot fire at all, then we also don't need a soft timer.
309 if (kvm_timer_should_fire(ptimer
) || !kvm_timer_irq_can_fire(ptimer
)) {
310 soft_timer_cancel(&timer
->phys_timer
, NULL
);
314 soft_timer_start(&timer
->phys_timer
, kvm_timer_compute_delta(ptimer
));
318 * Check if there was a change in the timer state, so that we should either
319 * raise or lower the line level to the GIC or schedule a background timer to
320 * emulate the physical timer.
322 static void kvm_timer_update_state(struct kvm_vcpu
*vcpu
)
324 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
325 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
326 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
328 if (unlikely(!timer
->enabled
))
331 if (kvm_timer_should_fire(vtimer
) != vtimer
->irq
.level
)
332 kvm_timer_update_irq(vcpu
, !vtimer
->irq
.level
, vtimer
);
334 if (kvm_timer_should_fire(ptimer
) != ptimer
->irq
.level
)
335 kvm_timer_update_irq(vcpu
, !ptimer
->irq
.level
, ptimer
);
337 phys_timer_emulate(vcpu
);
340 static void vtimer_save_state(struct kvm_vcpu
*vcpu
)
342 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
343 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
346 local_irq_save(flags
);
351 if (timer
->enabled
) {
352 vtimer
->cnt_ctl
= read_sysreg_el0(cntv_ctl
);
353 vtimer
->cnt_cval
= read_sysreg_el0(cntv_cval
);
356 /* Disable the virtual timer */
357 write_sysreg_el0(0, cntv_ctl
);
359 vtimer
->loaded
= false;
361 local_irq_restore(flags
);
365 * Schedule the background timer before calling kvm_vcpu_block, so that this
366 * thread is removed from its waitqueue and made runnable when there's a timer
367 * interrupt to handle.
369 void kvm_timer_schedule(struct kvm_vcpu
*vcpu
)
371 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
372 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
373 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
375 vtimer_save_state(vcpu
);
378 * No need to schedule a background timer if any guest timer has
379 * already expired, because kvm_vcpu_block will return before putting
380 * the thread to sleep.
382 if (kvm_timer_should_fire(vtimer
) || kvm_timer_should_fire(ptimer
))
386 * If both timers are not capable of raising interrupts (disabled or
387 * masked), then there's no more work for us to do.
389 if (!kvm_timer_irq_can_fire(vtimer
) && !kvm_timer_irq_can_fire(ptimer
))
393 * The guest timers have not yet expired, schedule a background timer.
394 * Set the earliest expiration time among the guest timers.
396 soft_timer_start(&timer
->bg_timer
, kvm_timer_earliest_exp(vcpu
));
399 static void vtimer_restore_state(struct kvm_vcpu
*vcpu
)
401 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
402 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
405 local_irq_save(flags
);
410 if (timer
->enabled
) {
411 write_sysreg_el0(vtimer
->cnt_cval
, cntv_cval
);
413 write_sysreg_el0(vtimer
->cnt_ctl
, cntv_ctl
);
416 vtimer
->loaded
= true;
418 local_irq_restore(flags
);
421 void kvm_timer_unschedule(struct kvm_vcpu
*vcpu
)
423 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
425 vtimer_restore_state(vcpu
);
427 soft_timer_cancel(&timer
->bg_timer
, &timer
->expired
);
430 static void set_cntvoff(u64 cntvoff
)
432 u32 low
= lower_32_bits(cntvoff
);
433 u32 high
= upper_32_bits(cntvoff
);
436 * Since kvm_call_hyp doesn't fully support the ARM PCS especially on
437 * 32-bit systems, but rather passes register by register shifted one
438 * place (we put the function address in r0/x0), we cannot simply pass
439 * a 64-bit value as an argument, but have to split the value in two
442 kvm_call_hyp(__kvm_timer_set_cntvoff
, low
, high
);
445 static void kvm_timer_vcpu_load_vgic(struct kvm_vcpu
*vcpu
)
447 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
451 phys_active
= vtimer
->irq
.level
||
452 kvm_vgic_map_is_active(vcpu
, vtimer
->irq
.irq
);
454 ret
= irq_set_irqchip_state(host_vtimer_irq
,
455 IRQCHIP_STATE_ACTIVE
,
460 static void kvm_timer_vcpu_load_user(struct kvm_vcpu
*vcpu
)
462 kvm_vtimer_update_mask_user(vcpu
);
465 void kvm_timer_vcpu_load(struct kvm_vcpu
*vcpu
)
467 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
468 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
470 if (unlikely(!timer
->enabled
))
473 if (unlikely(!irqchip_in_kernel(vcpu
->kvm
)))
474 kvm_timer_vcpu_load_user(vcpu
);
476 kvm_timer_vcpu_load_vgic(vcpu
);
478 set_cntvoff(vtimer
->cntvoff
);
480 vtimer_restore_state(vcpu
);
482 /* Set the background timer for the physical timer emulation. */
483 phys_timer_emulate(vcpu
);
486 bool kvm_timer_should_notify_user(struct kvm_vcpu
*vcpu
)
488 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
489 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
490 struct kvm_sync_regs
*sregs
= &vcpu
->run
->s
.regs
;
493 if (likely(irqchip_in_kernel(vcpu
->kvm
)))
496 vlevel
= sregs
->device_irq_level
& KVM_ARM_DEV_EL1_VTIMER
;
497 plevel
= sregs
->device_irq_level
& KVM_ARM_DEV_EL1_PTIMER
;
499 return vtimer
->irq
.level
!= vlevel
||
500 ptimer
->irq
.level
!= plevel
;
503 void kvm_timer_vcpu_put(struct kvm_vcpu
*vcpu
)
505 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
507 if (unlikely(!timer
->enabled
))
510 vtimer_save_state(vcpu
);
513 * Cancel the physical timer emulation, because the only case where we
514 * need it after a vcpu_put is in the context of a sleeping VCPU, and
515 * in that case we already factor in the deadline for the physical
516 * timer when scheduling the bg_timer.
518 * In any case, we re-schedule the hrtimer for the physical timer when
519 * coming back to the VCPU thread in kvm_timer_vcpu_load().
521 soft_timer_cancel(&timer
->phys_timer
, NULL
);
524 * The kernel may decide to run userspace after calling vcpu_put, so
525 * we reset cntvoff to 0 to ensure a consistent read between user
526 * accesses to the virtual counter and kernel access to the physical
532 static void unmask_vtimer_irq(struct kvm_vcpu
*vcpu
)
534 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
536 if (unlikely(!irqchip_in_kernel(vcpu
->kvm
))) {
537 kvm_vtimer_update_mask_user(vcpu
);
542 * If the guest disabled the timer without acking the interrupt, then
543 * we must make sure the physical and virtual active states are in
544 * sync by deactivating the physical interrupt, because otherwise we
545 * wouldn't see the next timer interrupt in the host.
547 if (!kvm_vgic_map_is_active(vcpu
, vtimer
->irq
.irq
)) {
549 ret
= irq_set_irqchip_state(host_vtimer_irq
,
550 IRQCHIP_STATE_ACTIVE
,
557 * kvm_timer_sync_hwstate - sync timer state from cpu
558 * @vcpu: The vcpu pointer
560 * Check if any of the timers have expired while we were running in the guest,
561 * and inject an interrupt if that was the case.
563 void kvm_timer_sync_hwstate(struct kvm_vcpu
*vcpu
)
565 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
568 * If we entered the guest with the vtimer output asserted we have to
569 * check if the guest has modified the timer so that we should lower
570 * the line at this point.
572 if (vtimer
->irq
.level
) {
573 vtimer
->cnt_ctl
= read_sysreg_el0(cntv_ctl
);
574 vtimer
->cnt_cval
= read_sysreg_el0(cntv_cval
);
575 if (!kvm_timer_should_fire(vtimer
)) {
576 kvm_timer_update_irq(vcpu
, false, vtimer
);
577 unmask_vtimer_irq(vcpu
);
582 int kvm_timer_vcpu_reset(struct kvm_vcpu
*vcpu
)
584 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
585 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
588 * The bits in CNTV_CTL are architecturally reset to UNKNOWN for ARMv8
589 * and to 0 for ARMv7. We provide an implementation that always
590 * resets the timer to be disabled and unmasked and is compliant with
591 * the ARMv7 architecture.
595 kvm_timer_update_state(vcpu
);
600 /* Make the updates of cntvoff for all vtimer contexts atomic */
601 static void update_vtimer_cntvoff(struct kvm_vcpu
*vcpu
, u64 cntvoff
)
604 struct kvm
*kvm
= vcpu
->kvm
;
605 struct kvm_vcpu
*tmp
;
607 mutex_lock(&kvm
->lock
);
608 kvm_for_each_vcpu(i
, tmp
, kvm
)
609 vcpu_vtimer(tmp
)->cntvoff
= cntvoff
;
612 * When called from the vcpu create path, the CPU being created is not
613 * included in the loop above, so we just set it here as well.
615 vcpu_vtimer(vcpu
)->cntvoff
= cntvoff
;
616 mutex_unlock(&kvm
->lock
);
619 void kvm_timer_vcpu_init(struct kvm_vcpu
*vcpu
)
621 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
622 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
623 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
625 /* Synchronize cntvoff across all vtimers of a VM. */
626 update_vtimer_cntvoff(vcpu
, kvm_phys_timer_read());
627 vcpu_ptimer(vcpu
)->cntvoff
= 0;
629 INIT_WORK(&timer
->expired
, kvm_timer_inject_irq_work
);
630 hrtimer_init(&timer
->bg_timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_ABS
);
631 timer
->bg_timer
.function
= kvm_bg_timer_expire
;
633 hrtimer_init(&timer
->phys_timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_ABS
);
634 timer
->phys_timer
.function
= kvm_phys_timer_expire
;
636 vtimer
->irq
.irq
= default_vtimer_irq
.irq
;
637 ptimer
->irq
.irq
= default_ptimer_irq
.irq
;
640 static void kvm_timer_init_interrupt(void *info
)
642 enable_percpu_irq(host_vtimer_irq
, host_vtimer_irq_flags
);
645 int kvm_arm_timer_set_reg(struct kvm_vcpu
*vcpu
, u64 regid
, u64 value
)
647 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
648 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
651 case KVM_REG_ARM_TIMER_CTL
:
652 vtimer
->cnt_ctl
= value
& ~ARCH_TIMER_CTRL_IT_STAT
;
654 case KVM_REG_ARM_TIMER_CNT
:
655 update_vtimer_cntvoff(vcpu
, kvm_phys_timer_read() - value
);
657 case KVM_REG_ARM_TIMER_CVAL
:
658 vtimer
->cnt_cval
= value
;
660 case KVM_REG_ARM_PTIMER_CTL
:
661 ptimer
->cnt_ctl
= value
& ~ARCH_TIMER_CTRL_IT_STAT
;
663 case KVM_REG_ARM_PTIMER_CVAL
:
664 ptimer
->cnt_cval
= value
;
671 kvm_timer_update_state(vcpu
);
675 static u64
read_timer_ctl(struct arch_timer_context
*timer
)
678 * Set ISTATUS bit if it's expired.
679 * Note that according to ARMv8 ARM Issue A.k, ISTATUS bit is
680 * UNKNOWN when ENABLE bit is 0, so we chose to set ISTATUS bit
681 * regardless of ENABLE bit for our implementation convenience.
683 if (!kvm_timer_compute_delta(timer
))
684 return timer
->cnt_ctl
| ARCH_TIMER_CTRL_IT_STAT
;
686 return timer
->cnt_ctl
;
689 u64
kvm_arm_timer_get_reg(struct kvm_vcpu
*vcpu
, u64 regid
)
691 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
692 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
695 case KVM_REG_ARM_TIMER_CTL
:
696 return read_timer_ctl(vtimer
);
697 case KVM_REG_ARM_TIMER_CNT
:
698 return kvm_phys_timer_read() - vtimer
->cntvoff
;
699 case KVM_REG_ARM_TIMER_CVAL
:
700 return vtimer
->cnt_cval
;
701 case KVM_REG_ARM_PTIMER_CTL
:
702 return read_timer_ctl(ptimer
);
703 case KVM_REG_ARM_PTIMER_CVAL
:
704 return ptimer
->cnt_cval
;
705 case KVM_REG_ARM_PTIMER_CNT
:
706 return kvm_phys_timer_read();
711 static int kvm_timer_starting_cpu(unsigned int cpu
)
713 kvm_timer_init_interrupt(NULL
);
717 static int kvm_timer_dying_cpu(unsigned int cpu
)
719 disable_percpu_irq(host_vtimer_irq
);
723 int kvm_timer_hyp_init(void)
725 struct arch_timer_kvm_info
*info
;
728 info
= arch_timer_get_kvm_info();
729 timecounter
= &info
->timecounter
;
731 if (!timecounter
->cc
) {
732 kvm_err("kvm_arch_timer: uninitialized timecounter\n");
736 if (info
->virtual_irq
<= 0) {
737 kvm_err("kvm_arch_timer: invalid virtual timer IRQ: %d\n",
741 host_vtimer_irq
= info
->virtual_irq
;
743 host_vtimer_irq_flags
= irq_get_trigger_type(host_vtimer_irq
);
744 if (host_vtimer_irq_flags
!= IRQF_TRIGGER_HIGH
&&
745 host_vtimer_irq_flags
!= IRQF_TRIGGER_LOW
) {
746 kvm_err("Invalid trigger for IRQ%d, assuming level low\n",
748 host_vtimer_irq_flags
= IRQF_TRIGGER_LOW
;
751 err
= request_percpu_irq(host_vtimer_irq
, kvm_arch_timer_handler
,
752 "kvm guest timer", kvm_get_running_vcpus());
754 kvm_err("kvm_arch_timer: can't request interrupt %d (%d)\n",
755 host_vtimer_irq
, err
);
759 err
= irq_set_vcpu_affinity(host_vtimer_irq
, kvm_get_running_vcpus());
761 kvm_err("kvm_arch_timer: error setting vcpu affinity\n");
765 kvm_info("virtual timer IRQ%d\n", host_vtimer_irq
);
767 cpuhp_setup_state(CPUHP_AP_KVM_ARM_TIMER_STARTING
,
768 "kvm/arm/timer:starting", kvm_timer_starting_cpu
,
769 kvm_timer_dying_cpu
);
772 free_percpu_irq(host_vtimer_irq
, kvm_get_running_vcpus());
776 void kvm_timer_vcpu_terminate(struct kvm_vcpu
*vcpu
)
778 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
779 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
781 soft_timer_cancel(&timer
->bg_timer
, &timer
->expired
);
782 soft_timer_cancel(&timer
->phys_timer
, NULL
);
783 kvm_vgic_unmap_phys_irq(vcpu
, vtimer
->irq
.irq
);
786 static bool timer_irqs_are_valid(struct kvm_vcpu
*vcpu
)
788 int vtimer_irq
, ptimer_irq
;
791 vtimer_irq
= vcpu_vtimer(vcpu
)->irq
.irq
;
792 ret
= kvm_vgic_set_owner(vcpu
, vtimer_irq
, vcpu_vtimer(vcpu
));
796 ptimer_irq
= vcpu_ptimer(vcpu
)->irq
.irq
;
797 ret
= kvm_vgic_set_owner(vcpu
, ptimer_irq
, vcpu_ptimer(vcpu
));
801 kvm_for_each_vcpu(i
, vcpu
, vcpu
->kvm
) {
802 if (vcpu_vtimer(vcpu
)->irq
.irq
!= vtimer_irq
||
803 vcpu_ptimer(vcpu
)->irq
.irq
!= ptimer_irq
)
810 int kvm_timer_enable(struct kvm_vcpu
*vcpu
)
812 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
813 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
819 /* Without a VGIC we do not map virtual IRQs to physical IRQs */
820 if (!irqchip_in_kernel(vcpu
->kvm
))
823 if (!vgic_initialized(vcpu
->kvm
))
826 if (!timer_irqs_are_valid(vcpu
)) {
827 kvm_debug("incorrectly configured timer irqs\n");
831 ret
= kvm_vgic_map_phys_irq(vcpu
, host_vtimer_irq
, vtimer
->irq
.irq
);
838 if (!irqchip_in_kernel(vcpu
->kvm
))
839 kvm_timer_vcpu_load_user(vcpu
);
841 kvm_timer_vcpu_load_vgic(vcpu
);
848 * On VHE system, we only need to configure trap on physical timer and counter
849 * accesses in EL0 and EL1 once, not for every world switch.
850 * The host kernel runs at EL2 with HCR_EL2.TGE == 1,
851 * and this makes those bits have no effect for the host kernel execution.
853 void kvm_timer_init_vhe(void)
855 /* When HCR_EL2.E2H ==1, EL1PCEN and EL1PCTEN are shifted by 10 */
856 u32 cnthctl_shift
= 10;
860 * Disallow physical timer access for the guest.
861 * Physical counter access is allowed.
863 val
= read_sysreg(cnthctl_el2
);
864 val
&= ~(CNTHCTL_EL1PCEN
<< cnthctl_shift
);
865 val
|= (CNTHCTL_EL1PCTEN
<< cnthctl_shift
);
866 write_sysreg(val
, cnthctl_el2
);
869 static void set_timer_irqs(struct kvm
*kvm
, int vtimer_irq
, int ptimer_irq
)
871 struct kvm_vcpu
*vcpu
;
874 kvm_for_each_vcpu(i
, vcpu
, kvm
) {
875 vcpu_vtimer(vcpu
)->irq
.irq
= vtimer_irq
;
876 vcpu_ptimer(vcpu
)->irq
.irq
= ptimer_irq
;
880 int kvm_arm_timer_set_attr(struct kvm_vcpu
*vcpu
, struct kvm_device_attr
*attr
)
882 int __user
*uaddr
= (int __user
*)(long)attr
->addr
;
883 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
884 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
887 if (!irqchip_in_kernel(vcpu
->kvm
))
890 if (get_user(irq
, uaddr
))
893 if (!(irq_is_ppi(irq
)))
896 if (vcpu
->arch
.timer_cpu
.enabled
)
899 switch (attr
->attr
) {
900 case KVM_ARM_VCPU_TIMER_IRQ_VTIMER
:
901 set_timer_irqs(vcpu
->kvm
, irq
, ptimer
->irq
.irq
);
903 case KVM_ARM_VCPU_TIMER_IRQ_PTIMER
:
904 set_timer_irqs(vcpu
->kvm
, vtimer
->irq
.irq
, irq
);
913 int kvm_arm_timer_get_attr(struct kvm_vcpu
*vcpu
, struct kvm_device_attr
*attr
)
915 int __user
*uaddr
= (int __user
*)(long)attr
->addr
;
916 struct arch_timer_context
*timer
;
919 switch (attr
->attr
) {
920 case KVM_ARM_VCPU_TIMER_IRQ_VTIMER
:
921 timer
= vcpu_vtimer(vcpu
);
923 case KVM_ARM_VCPU_TIMER_IRQ_PTIMER
:
924 timer
= vcpu_ptimer(vcpu
);
930 irq
= timer
->irq
.irq
;
931 return put_user(irq
, uaddr
);
934 int kvm_arm_timer_has_attr(struct kvm_vcpu
*vcpu
, struct kvm_device_attr
*attr
)
936 switch (attr
->attr
) {
937 case KVM_ARM_VCPU_TIMER_IRQ_VTIMER
:
938 case KVM_ARM_VCPU_TIMER_IRQ_PTIMER
: