1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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>
25
26#include <clocksource/arm_arch_timer.h>
27#include <asm/arch_timer.h>
28#include <asm/kvm_hyp.h>
29
30#include <kvm/arm_vgic.h>
31#include <kvm/arm_arch_timer.h>
32
33#include "trace.h"
34
35static struct timecounter *timecounter;
36static unsigned int host_vtimer_irq;
37static u32 host_vtimer_irq_flags;
38
39static DEFINE_STATIC_KEY_FALSE(has_gic_active_state);
40
41static const struct kvm_irq_level default_ptimer_irq = {
42 .irq = 30,
43 .level = 1,
44};
45
46static const struct kvm_irq_level default_vtimer_irq = {
47 .irq = 27,
48 .level = 1,
49};
50
51static bool kvm_timer_irq_can_fire(struct arch_timer_context *timer_ctx);
52static void kvm_timer_update_irq(struct kvm_vcpu *vcpu, bool new_level,
53 struct arch_timer_context *timer_ctx);
54static bool kvm_timer_should_fire(struct arch_timer_context *timer_ctx);
55
56u64 kvm_phys_timer_read(void)
57{
58 return timecounter->cc->read(timecounter->cc);
59}
60
61static inline bool userspace_irqchip(struct kvm *kvm)
62{
63 return static_branch_unlikely(&userspace_irqchip_in_use) &&
64 unlikely(!irqchip_in_kernel(kvm));
65}
66
67static void soft_timer_start(struct hrtimer *hrt, u64 ns)
68{
69 hrtimer_start(hrt, ktime_add_ns(ktime_get(), ns),
70 HRTIMER_MODE_ABS);
71}
72
73static void soft_timer_cancel(struct hrtimer *hrt, struct work_struct *work)
74{
75 hrtimer_cancel(hrt);
76 if (work)
77 cancel_work_sync(work);
78}
79
80static irqreturn_t kvm_arch_timer_handler(int irq, void *dev_id)
81{
82 struct kvm_vcpu *vcpu = *(struct kvm_vcpu **)dev_id;
83 struct arch_timer_context *vtimer;
84
85
86
87
88
89
90
91 if (!vcpu)
92 return IRQ_HANDLED;
93
94 vtimer = vcpu_vtimer(vcpu);
95 if (kvm_timer_should_fire(vtimer))
96 kvm_timer_update_irq(vcpu, true, vtimer);
97
98 if (userspace_irqchip(vcpu->kvm) &&
99 !static_branch_unlikely(&has_gic_active_state))
100 disable_percpu_irq(host_vtimer_irq);
101
102 return IRQ_HANDLED;
103}
104
105
106
107
108
109static void kvm_timer_inject_irq_work(struct work_struct *work)
110{
111 struct kvm_vcpu *vcpu;
112
113 vcpu = container_of(work, struct kvm_vcpu, arch.timer_cpu.expired);
114
115
116
117
118
119 kvm_vcpu_wake_up(vcpu);
120}
121
122static u64 kvm_timer_compute_delta(struct arch_timer_context *timer_ctx)
123{
124 u64 cval, now;
125
126 cval = timer_ctx->cnt_cval;
127 now = kvm_phys_timer_read() - timer_ctx->cntvoff;
128
129 if (now < cval) {
130 u64 ns;
131
132 ns = cyclecounter_cyc2ns(timecounter->cc,
133 cval - now,
134 timecounter->mask,
135 &timecounter->frac);
136 return ns;
137 }
138
139 return 0;
140}
141
142static bool kvm_timer_irq_can_fire(struct arch_timer_context *timer_ctx)
143{
144 return !(timer_ctx->cnt_ctl & ARCH_TIMER_CTRL_IT_MASK) &&
145 (timer_ctx->cnt_ctl & ARCH_TIMER_CTRL_ENABLE);
146}
147
148
149
150
151
152static u64 kvm_timer_earliest_exp(struct kvm_vcpu *vcpu)
153{
154 u64 min_virt = ULLONG_MAX, min_phys = ULLONG_MAX;
155 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
156 struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
157
158 if (kvm_timer_irq_can_fire(vtimer))
159 min_virt = kvm_timer_compute_delta(vtimer);
160
161 if (kvm_timer_irq_can_fire(ptimer))
162 min_phys = kvm_timer_compute_delta(ptimer);
163
164
165 if ((min_virt == ULLONG_MAX) && (min_phys == ULLONG_MAX))
166 return 0;
167
168 return min(min_virt, min_phys);
169}
170
171static enum hrtimer_restart kvm_bg_timer_expire(struct hrtimer *hrt)
172{
173 struct arch_timer_cpu *timer;
174 struct kvm_vcpu *vcpu;
175 u64 ns;
176
177 timer = container_of(hrt, struct arch_timer_cpu, bg_timer);
178 vcpu = container_of(timer, struct kvm_vcpu, arch.timer_cpu);
179
180
181
182
183
184
185 ns = kvm_timer_earliest_exp(vcpu);
186 if (unlikely(ns)) {
187 hrtimer_forward_now(hrt, ns_to_ktime(ns));
188 return HRTIMER_RESTART;
189 }
190
191 schedule_work(&timer->expired);
192 return HRTIMER_NORESTART;
193}
194
195static enum hrtimer_restart kvm_phys_timer_expire(struct hrtimer *hrt)
196{
197 struct arch_timer_context *ptimer;
198 struct arch_timer_cpu *timer;
199 struct kvm_vcpu *vcpu;
200 u64 ns;
201
202 timer = container_of(hrt, struct arch_timer_cpu, phys_timer);
203 vcpu = container_of(timer, struct kvm_vcpu, arch.timer_cpu);
204 ptimer = vcpu_ptimer(vcpu);
205
206
207
208
209
210
211 ns = kvm_timer_compute_delta(ptimer);
212 if (unlikely(ns)) {
213 hrtimer_forward_now(hrt, ns_to_ktime(ns));
214 return HRTIMER_RESTART;
215 }
216
217 kvm_timer_update_irq(vcpu, true, ptimer);
218 return HRTIMER_NORESTART;
219}
220
221static bool kvm_timer_should_fire(struct arch_timer_context *timer_ctx)
222{
223 u64 cval, now;
224
225 if (timer_ctx->loaded) {
226 u32 cnt_ctl;
227
228
229 cnt_ctl = read_sysreg_el0(cntv_ctl);
230 return (cnt_ctl & ARCH_TIMER_CTRL_ENABLE) &&
231 (cnt_ctl & ARCH_TIMER_CTRL_IT_STAT) &&
232 !(cnt_ctl & ARCH_TIMER_CTRL_IT_MASK);
233 }
234
235 if (!kvm_timer_irq_can_fire(timer_ctx))
236 return false;
237
238 cval = timer_ctx->cnt_cval;
239 now = kvm_phys_timer_read() - timer_ctx->cntvoff;
240
241 return cval <= now;
242}
243
244bool kvm_timer_is_pending(struct kvm_vcpu *vcpu)
245{
246 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
247 struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
248
249 if (kvm_timer_should_fire(vtimer))
250 return true;
251
252 return kvm_timer_should_fire(ptimer);
253}
254
255
256
257
258void kvm_timer_update_run(struct kvm_vcpu *vcpu)
259{
260 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
261 struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
262 struct kvm_sync_regs *regs = &vcpu->run->s.regs;
263
264
265 regs->device_irq_level &= ~(KVM_ARM_DEV_EL1_VTIMER |
266 KVM_ARM_DEV_EL1_PTIMER);
267 if (kvm_timer_should_fire(vtimer))
268 regs->device_irq_level |= KVM_ARM_DEV_EL1_VTIMER;
269 if (kvm_timer_should_fire(ptimer))
270 regs->device_irq_level |= KVM_ARM_DEV_EL1_PTIMER;
271}
272
273static void kvm_timer_update_irq(struct kvm_vcpu *vcpu, bool new_level,
274 struct arch_timer_context *timer_ctx)
275{
276 int ret;
277
278 timer_ctx->irq.level = new_level;
279 trace_kvm_timer_update_irq(vcpu->vcpu_id, timer_ctx->irq.irq,
280 timer_ctx->irq.level);
281
282 if (!userspace_irqchip(vcpu->kvm)) {
283 ret = kvm_vgic_inject_irq(vcpu->kvm, vcpu->vcpu_id,
284 timer_ctx->irq.irq,
285 timer_ctx->irq.level,
286 timer_ctx);
287 WARN_ON(ret);
288 }
289}
290
291
292static void phys_timer_emulate(struct kvm_vcpu *vcpu)
293{
294 struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
295 struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
296
297
298
299
300
301
302 if (kvm_timer_should_fire(ptimer) || !kvm_timer_irq_can_fire(ptimer)) {
303 soft_timer_cancel(&timer->phys_timer, NULL);
304 return;
305 }
306
307 soft_timer_start(&timer->phys_timer, kvm_timer_compute_delta(ptimer));
308}
309
310
311
312
313
314
315static void kvm_timer_update_state(struct kvm_vcpu *vcpu)
316{
317 struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
318 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
319 struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
320 bool level;
321
322 if (unlikely(!timer->enabled))
323 return;
324
325
326
327
328
329
330
331
332 level = kvm_timer_should_fire(vtimer);
333 kvm_timer_update_irq(vcpu, level, vtimer);
334
335 if (kvm_timer_should_fire(ptimer) != ptimer->irq.level)
336 kvm_timer_update_irq(vcpu, !ptimer->irq.level, ptimer);
337
338 phys_timer_emulate(vcpu);
339}
340
341static void vtimer_save_state(struct kvm_vcpu *vcpu)
342{
343 struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
344 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
345 unsigned long flags;
346
347 local_irq_save(flags);
348
349 if (!vtimer->loaded)
350 goto out;
351
352 if (timer->enabled) {
353 vtimer->cnt_ctl = read_sysreg_el0(cntv_ctl);
354 vtimer->cnt_cval = read_sysreg_el0(cntv_cval);
355 }
356
357
358 write_sysreg_el0(0, cntv_ctl);
359 isb();
360
361 vtimer->loaded = false;
362out:
363 local_irq_restore(flags);
364}
365
366
367
368
369
370
371void kvm_timer_schedule(struct kvm_vcpu *vcpu)
372{
373 struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
374 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
375 struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
376
377 vtimer_save_state(vcpu);
378
379
380
381
382
383
384 if (kvm_timer_should_fire(vtimer) || kvm_timer_should_fire(ptimer))
385 return;
386
387
388
389
390
391 if (!kvm_timer_irq_can_fire(vtimer) && !kvm_timer_irq_can_fire(ptimer))
392 return;
393
394
395
396
397
398 soft_timer_start(&timer->bg_timer, kvm_timer_earliest_exp(vcpu));
399}
400
401static void vtimer_restore_state(struct kvm_vcpu *vcpu)
402{
403 struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
404 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
405 unsigned long flags;
406
407 local_irq_save(flags);
408
409 if (vtimer->loaded)
410 goto out;
411
412 if (timer->enabled) {
413 write_sysreg_el0(vtimer->cnt_cval, cntv_cval);
414 isb();
415 write_sysreg_el0(vtimer->cnt_ctl, cntv_ctl);
416 }
417
418 vtimer->loaded = true;
419out:
420 local_irq_restore(flags);
421}
422
423void kvm_timer_unschedule(struct kvm_vcpu *vcpu)
424{
425 struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
426
427 vtimer_restore_state(vcpu);
428
429 soft_timer_cancel(&timer->bg_timer, &timer->expired);
430}
431
432static void set_cntvoff(u64 cntvoff)
433{
434 u32 low = lower_32_bits(cntvoff);
435 u32 high = upper_32_bits(cntvoff);
436
437
438
439
440
441
442
443
444 kvm_call_hyp(__kvm_timer_set_cntvoff, low, high);
445}
446
447static inline void set_vtimer_irq_phys_active(struct kvm_vcpu *vcpu, bool active)
448{
449 int r;
450 r = irq_set_irqchip_state(host_vtimer_irq, IRQCHIP_STATE_ACTIVE, active);
451 WARN_ON(r);
452}
453
454static void kvm_timer_vcpu_load_gic(struct kvm_vcpu *vcpu)
455{
456 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
457 bool phys_active;
458
459 if (irqchip_in_kernel(vcpu->kvm))
460 phys_active = kvm_vgic_map_is_active(vcpu, vtimer->irq.irq);
461 else
462 phys_active = vtimer->irq.level;
463 set_vtimer_irq_phys_active(vcpu, phys_active);
464}
465
466static void kvm_timer_vcpu_load_nogic(struct kvm_vcpu *vcpu)
467{
468 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
469
470
471
472
473
474
475
476
477
478
479
480 if (vtimer->irq.level)
481 disable_percpu_irq(host_vtimer_irq);
482 else
483 enable_percpu_irq(host_vtimer_irq, host_vtimer_irq_flags);
484}
485
486void kvm_timer_vcpu_load(struct kvm_vcpu *vcpu)
487{
488 struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
489 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
490
491 if (unlikely(!timer->enabled))
492 return;
493
494 if (static_branch_likely(&has_gic_active_state))
495 kvm_timer_vcpu_load_gic(vcpu);
496 else
497 kvm_timer_vcpu_load_nogic(vcpu);
498
499 set_cntvoff(vtimer->cntvoff);
500
501 vtimer_restore_state(vcpu);
502
503
504 phys_timer_emulate(vcpu);
505}
506
507bool kvm_timer_should_notify_user(struct kvm_vcpu *vcpu)
508{
509 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
510 struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
511 struct kvm_sync_regs *sregs = &vcpu->run->s.regs;
512 bool vlevel, plevel;
513
514 if (likely(irqchip_in_kernel(vcpu->kvm)))
515 return false;
516
517 vlevel = sregs->device_irq_level & KVM_ARM_DEV_EL1_VTIMER;
518 plevel = sregs->device_irq_level & KVM_ARM_DEV_EL1_PTIMER;
519
520 return kvm_timer_should_fire(vtimer) != vlevel ||
521 kvm_timer_should_fire(ptimer) != plevel;
522}
523
524void kvm_timer_vcpu_put(struct kvm_vcpu *vcpu)
525{
526 struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
527
528 if (unlikely(!timer->enabled))
529 return;
530
531 vtimer_save_state(vcpu);
532
533
534
535
536
537
538
539
540
541
542 soft_timer_cancel(&timer->phys_timer, NULL);
543
544
545
546
547
548
549
550 set_cntvoff(0);
551}
552
553
554
555
556
557
558static void unmask_vtimer_irq_user(struct kvm_vcpu *vcpu)
559{
560 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
561
562 if (!kvm_timer_should_fire(vtimer)) {
563 kvm_timer_update_irq(vcpu, false, vtimer);
564 if (static_branch_likely(&has_gic_active_state))
565 set_vtimer_irq_phys_active(vcpu, false);
566 else
567 enable_percpu_irq(host_vtimer_irq, host_vtimer_irq_flags);
568 }
569}
570
571void kvm_timer_sync_hwstate(struct kvm_vcpu *vcpu)
572{
573 struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
574
575 if (unlikely(!timer->enabled))
576 return;
577
578 if (unlikely(!irqchip_in_kernel(vcpu->kvm)))
579 unmask_vtimer_irq_user(vcpu);
580}
581
582int kvm_timer_vcpu_reset(struct kvm_vcpu *vcpu)
583{
584 struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
585 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
586 struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
587
588
589
590
591
592
593
594 vtimer->cnt_ctl = 0;
595 ptimer->cnt_ctl = 0;
596 kvm_timer_update_state(vcpu);
597
598 if (timer->enabled && irqchip_in_kernel(vcpu->kvm))
599 kvm_vgic_reset_mapped_irq(vcpu, vtimer->irq.irq);
600
601 return 0;
602}
603
604
605static void update_vtimer_cntvoff(struct kvm_vcpu *vcpu, u64 cntvoff)
606{
607 int i;
608 struct kvm *kvm = vcpu->kvm;
609 struct kvm_vcpu *tmp;
610
611 mutex_lock(&kvm->lock);
612 kvm_for_each_vcpu(i, tmp, kvm)
613 vcpu_vtimer(tmp)->cntvoff = cntvoff;
614
615
616
617
618
619 vcpu_vtimer(vcpu)->cntvoff = cntvoff;
620 mutex_unlock(&kvm->lock);
621}
622
623void kvm_timer_vcpu_init(struct kvm_vcpu *vcpu)
624{
625 struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
626 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
627 struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
628
629
630 update_vtimer_cntvoff(vcpu, kvm_phys_timer_read());
631 vcpu_ptimer(vcpu)->cntvoff = 0;
632
633 INIT_WORK(&timer->expired, kvm_timer_inject_irq_work);
634 hrtimer_init(&timer->bg_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
635 timer->bg_timer.function = kvm_bg_timer_expire;
636
637 hrtimer_init(&timer->phys_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
638 timer->phys_timer.function = kvm_phys_timer_expire;
639
640 vtimer->irq.irq = default_vtimer_irq.irq;
641 ptimer->irq.irq = default_ptimer_irq.irq;
642}
643
644static void kvm_timer_init_interrupt(void *info)
645{
646 enable_percpu_irq(host_vtimer_irq, host_vtimer_irq_flags);
647}
648
649int kvm_arm_timer_set_reg(struct kvm_vcpu *vcpu, u64 regid, u64 value)
650{
651 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
652 struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
653
654 switch (regid) {
655 case KVM_REG_ARM_TIMER_CTL:
656 vtimer->cnt_ctl = value & ~ARCH_TIMER_CTRL_IT_STAT;
657 break;
658 case KVM_REG_ARM_TIMER_CNT:
659 update_vtimer_cntvoff(vcpu, kvm_phys_timer_read() - value);
660 break;
661 case KVM_REG_ARM_TIMER_CVAL:
662 vtimer->cnt_cval = value;
663 break;
664 case KVM_REG_ARM_PTIMER_CTL:
665 ptimer->cnt_ctl = value & ~ARCH_TIMER_CTRL_IT_STAT;
666 break;
667 case KVM_REG_ARM_PTIMER_CVAL:
668 ptimer->cnt_cval = value;
669 break;
670
671 default:
672 return -1;
673 }
674
675 kvm_timer_update_state(vcpu);
676 return 0;
677}
678
679static u64 read_timer_ctl(struct arch_timer_context *timer)
680{
681
682
683
684
685
686
687 if (!kvm_timer_compute_delta(timer))
688 return timer->cnt_ctl | ARCH_TIMER_CTRL_IT_STAT;
689 else
690 return timer->cnt_ctl;
691}
692
693u64 kvm_arm_timer_get_reg(struct kvm_vcpu *vcpu, u64 regid)
694{
695 struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
696 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
697
698 switch (regid) {
699 case KVM_REG_ARM_TIMER_CTL:
700 return read_timer_ctl(vtimer);
701 case KVM_REG_ARM_TIMER_CNT:
702 return kvm_phys_timer_read() - vtimer->cntvoff;
703 case KVM_REG_ARM_TIMER_CVAL:
704 return vtimer->cnt_cval;
705 case KVM_REG_ARM_PTIMER_CTL:
706 return read_timer_ctl(ptimer);
707 case KVM_REG_ARM_PTIMER_CVAL:
708 return ptimer->cnt_cval;
709 case KVM_REG_ARM_PTIMER_CNT:
710 return kvm_phys_timer_read();
711 }
712 return (u64)-1;
713}
714
715static int kvm_timer_starting_cpu(unsigned int cpu)
716{
717 kvm_timer_init_interrupt(NULL);
718 return 0;
719}
720
721static int kvm_timer_dying_cpu(unsigned int cpu)
722{
723 disable_percpu_irq(host_vtimer_irq);
724 return 0;
725}
726
727int kvm_timer_hyp_init(bool has_gic)
728{
729 struct arch_timer_kvm_info *info;
730 int err;
731
732 info = arch_timer_get_kvm_info();
733 timecounter = &info->timecounter;
734
735 if (!timecounter->cc) {
736 kvm_err("kvm_arch_timer: uninitialized timecounter\n");
737 return -ENODEV;
738 }
739
740 if (info->virtual_irq <= 0) {
741 kvm_err("kvm_arch_timer: invalid virtual timer IRQ: %d\n",
742 info->virtual_irq);
743 return -ENODEV;
744 }
745 host_vtimer_irq = info->virtual_irq;
746
747 host_vtimer_irq_flags = irq_get_trigger_type(host_vtimer_irq);
748 if (host_vtimer_irq_flags != IRQF_TRIGGER_HIGH &&
749 host_vtimer_irq_flags != IRQF_TRIGGER_LOW) {
750 kvm_err("Invalid trigger for IRQ%d, assuming level low\n",
751 host_vtimer_irq);
752 host_vtimer_irq_flags = IRQF_TRIGGER_LOW;
753 }
754
755 err = request_percpu_irq(host_vtimer_irq, kvm_arch_timer_handler,
756 "kvm guest timer", kvm_get_running_vcpus());
757 if (err) {
758 kvm_err("kvm_arch_timer: can't request interrupt %d (%d)\n",
759 host_vtimer_irq, err);
760 return err;
761 }
762
763 if (has_gic) {
764 err = irq_set_vcpu_affinity(host_vtimer_irq,
765 kvm_get_running_vcpus());
766 if (err) {
767 kvm_err("kvm_arch_timer: error setting vcpu affinity\n");
768 goto out_free_irq;
769 }
770
771 static_branch_enable(&has_gic_active_state);
772 }
773
774 kvm_debug("virtual timer IRQ%d\n", host_vtimer_irq);
775
776 cpuhp_setup_state(CPUHP_AP_KVM_ARM_TIMER_STARTING,
777 "kvm/arm/timer:starting", kvm_timer_starting_cpu,
778 kvm_timer_dying_cpu);
779 return 0;
780out_free_irq:
781 free_percpu_irq(host_vtimer_irq, kvm_get_running_vcpus());
782 return err;
783}
784
785void kvm_timer_vcpu_terminate(struct kvm_vcpu *vcpu)
786{
787 struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
788 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
789
790 soft_timer_cancel(&timer->bg_timer, &timer->expired);
791 soft_timer_cancel(&timer->phys_timer, NULL);
792 kvm_vgic_unmap_phys_irq(vcpu, vtimer->irq.irq);
793}
794
795static bool timer_irqs_are_valid(struct kvm_vcpu *vcpu)
796{
797 int vtimer_irq, ptimer_irq;
798 int i, ret;
799
800 vtimer_irq = vcpu_vtimer(vcpu)->irq.irq;
801 ret = kvm_vgic_set_owner(vcpu, vtimer_irq, vcpu_vtimer(vcpu));
802 if (ret)
803 return false;
804
805 ptimer_irq = vcpu_ptimer(vcpu)->irq.irq;
806 ret = kvm_vgic_set_owner(vcpu, ptimer_irq, vcpu_ptimer(vcpu));
807 if (ret)
808 return false;
809
810 kvm_for_each_vcpu(i, vcpu, vcpu->kvm) {
811 if (vcpu_vtimer(vcpu)->irq.irq != vtimer_irq ||
812 vcpu_ptimer(vcpu)->irq.irq != ptimer_irq)
813 return false;
814 }
815
816 return true;
817}
818
819bool kvm_arch_timer_get_input_level(int vintid)
820{
821 struct kvm_vcpu *vcpu = kvm_arm_get_running_vcpu();
822 struct arch_timer_context *timer;
823
824 if (vintid == vcpu_vtimer(vcpu)->irq.irq)
825 timer = vcpu_vtimer(vcpu);
826 else
827 BUG();
828
829 return kvm_timer_should_fire(timer);
830}
831
832int kvm_timer_enable(struct kvm_vcpu *vcpu)
833{
834 struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
835 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
836 int ret;
837
838 if (timer->enabled)
839 return 0;
840
841
842 if (!irqchip_in_kernel(vcpu->kvm))
843 goto no_vgic;
844
845 if (!vgic_initialized(vcpu->kvm))
846 return -ENODEV;
847
848 if (!timer_irqs_are_valid(vcpu)) {
849 kvm_debug("incorrectly configured timer irqs\n");
850 return -EINVAL;
851 }
852
853 ret = kvm_vgic_map_phys_irq(vcpu, host_vtimer_irq, vtimer->irq.irq,
854 kvm_arch_timer_get_input_level);
855 if (ret)
856 return ret;
857
858no_vgic:
859 preempt_disable();
860 timer->enabled = 1;
861 kvm_timer_vcpu_load(vcpu);
862 preempt_enable();
863
864 return 0;
865}
866
867
868
869
870
871
872
873void kvm_timer_init_vhe(void)
874{
875
876 u32 cnthctl_shift = 10;
877 u64 val;
878
879
880
881
882
883 val = read_sysreg(cnthctl_el2);
884 val &= ~(CNTHCTL_EL1PCEN << cnthctl_shift);
885 val |= (CNTHCTL_EL1PCTEN << cnthctl_shift);
886 write_sysreg(val, cnthctl_el2);
887}
888
889static void set_timer_irqs(struct kvm *kvm, int vtimer_irq, int ptimer_irq)
890{
891 struct kvm_vcpu *vcpu;
892 int i;
893
894 kvm_for_each_vcpu(i, vcpu, kvm) {
895 vcpu_vtimer(vcpu)->irq.irq = vtimer_irq;
896 vcpu_ptimer(vcpu)->irq.irq = ptimer_irq;
897 }
898}
899
900int kvm_arm_timer_set_attr(struct kvm_vcpu *vcpu, struct kvm_device_attr *attr)
901{
902 int __user *uaddr = (int __user *)(long)attr->addr;
903 struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
904 struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
905 int irq;
906
907 if (!irqchip_in_kernel(vcpu->kvm))
908 return -EINVAL;
909
910 if (get_user(irq, uaddr))
911 return -EFAULT;
912
913 if (!(irq_is_ppi(irq)))
914 return -EINVAL;
915
916 if (vcpu->arch.timer_cpu.enabled)
917 return -EBUSY;
918
919 switch (attr->attr) {
920 case KVM_ARM_VCPU_TIMER_IRQ_VTIMER:
921 set_timer_irqs(vcpu->kvm, irq, ptimer->irq.irq);
922 break;
923 case KVM_ARM_VCPU_TIMER_IRQ_PTIMER:
924 set_timer_irqs(vcpu->kvm, vtimer->irq.irq, irq);
925 break;
926 default:
927 return -ENXIO;
928 }
929
930 return 0;
931}
932
933int kvm_arm_timer_get_attr(struct kvm_vcpu *vcpu, struct kvm_device_attr *attr)
934{
935 int __user *uaddr = (int __user *)(long)attr->addr;
936 struct arch_timer_context *timer;
937 int irq;
938
939 switch (attr->attr) {
940 case KVM_ARM_VCPU_TIMER_IRQ_VTIMER:
941 timer = vcpu_vtimer(vcpu);
942 break;
943 case KVM_ARM_VCPU_TIMER_IRQ_PTIMER:
944 timer = vcpu_ptimer(vcpu);
945 break;
946 default:
947 return -ENXIO;
948 }
949
950 irq = timer->irq.irq;
951 return put_user(irq, uaddr);
952}
953
954int kvm_arm_timer_has_attr(struct kvm_vcpu *vcpu, struct kvm_device_attr *attr)
955{
956 switch (attr->attr) {
957 case KVM_ARM_VCPU_TIMER_IRQ_VTIMER:
958 case KVM_ARM_VCPU_TIMER_IRQ_PTIMER:
959 return 0;
960 }
961
962 return -ENXIO;
963}
964