3 * Local APIC virtualization
5 * Copyright (C) 2006 Qumranet, Inc.
6 * Copyright (C) 2007 Novell
7 * Copyright (C) 2007 Intel
10 * Dor Laor <dor.laor@qumranet.com>
11 * Gregory Haskins <ghaskins@novell.com>
12 * Yaozu (Eddie) Dong <eddie.dong@intel.com>
14 * Based on Xen 3.1 code, Copyright (c) 2004, Intel Corporation.
16 * This work is licensed under the terms of the GNU GPL, version 2. See
17 * the COPYING file in the top-level directory.
21 #include <linux/kvm.h>
23 #include <linux/highmem.h>
24 #include <linux/smp.h>
25 #include <linux/hrtimer.h>
27 #include <linux/module.h>
28 #include <asm/processor.h>
31 #include <asm/current.h>
32 #include <asm/apicdef.h>
33 #include <asm/atomic.h>
34 #include <asm/div64.h>
42 #define APIC_BUS_CYCLE_NS 1
44 /* #define apic_debug(fmt,arg...) printk(KERN_WARNING fmt,##arg) */
45 #define apic_debug(fmt, arg...)
47 #define APIC_LVT_NUM 6
48 /* 14 is the version for Xeon and Pentium 8.4.8*/
49 #define APIC_VERSION (0x14UL | ((APIC_LVT_NUM - 1) << 16))
50 #define LAPIC_MMIO_LENGTH (1 << 12)
51 /* followed define is not in apicdef.h */
52 #define APIC_SHORT_MASK 0xc0000
53 #define APIC_DEST_NOSHORT 0x0
54 #define APIC_DEST_MASK 0x800
55 #define MAX_APIC_VECTOR 256
57 #define VEC_POS(v) ((v) & (32 - 1))
58 #define REG_POS(v) (((v) >> 5) << 4)
59 static inline u32
apic_get_reg(struct kvm_lapic
*apic
, int reg_off
)
61 return *((u32
*) (apic
->regs
+ reg_off
));
64 static inline void apic_set_reg(struct kvm_lapic
*apic
, int reg_off
, u32 val
)
66 *((u32
*) (apic
->regs
+ reg_off
)) = val
;
69 static inline int apic_test_and_set_vector(int vec
, void *bitmap
)
71 return test_and_set_bit(VEC_POS(vec
), (bitmap
) + REG_POS(vec
));
74 static inline int apic_test_and_clear_vector(int vec
, void *bitmap
)
76 return test_and_clear_bit(VEC_POS(vec
), (bitmap
) + REG_POS(vec
));
79 static inline void apic_set_vector(int vec
, void *bitmap
)
81 set_bit(VEC_POS(vec
), (bitmap
) + REG_POS(vec
));
84 static inline void apic_clear_vector(int vec
, void *bitmap
)
86 clear_bit(VEC_POS(vec
), (bitmap
) + REG_POS(vec
));
89 static inline int apic_hw_enabled(struct kvm_lapic
*apic
)
91 return (apic
)->vcpu
->apic_base
& MSR_IA32_APICBASE_ENABLE
;
94 static inline int apic_sw_enabled(struct kvm_lapic
*apic
)
96 return apic_get_reg(apic
, APIC_SPIV
) & APIC_SPIV_APIC_ENABLED
;
99 static inline int apic_enabled(struct kvm_lapic
*apic
)
101 return apic_sw_enabled(apic
) && apic_hw_enabled(apic
);
105 (APIC_LVT_MASKED | APIC_SEND_PENDING | APIC_VECTOR_MASK)
108 (LVT_MASK | APIC_MODE_MASK | APIC_INPUT_POLARITY | \
109 APIC_LVT_REMOTE_IRR | APIC_LVT_LEVEL_TRIGGER)
111 static inline int kvm_apic_id(struct kvm_lapic
*apic
)
113 return (apic_get_reg(apic
, APIC_ID
) >> 24) & 0xff;
116 static inline int apic_lvt_enabled(struct kvm_lapic
*apic
, int lvt_type
)
118 return !(apic_get_reg(apic
, lvt_type
) & APIC_LVT_MASKED
);
121 static inline int apic_lvt_vector(struct kvm_lapic
*apic
, int lvt_type
)
123 return apic_get_reg(apic
, lvt_type
) & APIC_VECTOR_MASK
;
126 static inline int apic_lvtt_period(struct kvm_lapic
*apic
)
128 return apic_get_reg(apic
, APIC_LVTT
) & APIC_LVT_TIMER_PERIODIC
;
131 static unsigned int apic_lvt_mask
[APIC_LVT_NUM
] = {
132 LVT_MASK
| APIC_LVT_TIMER_PERIODIC
, /* LVTT */
133 LVT_MASK
| APIC_MODE_MASK
, /* LVTTHMR */
134 LVT_MASK
| APIC_MODE_MASK
, /* LVTPC */
135 LINT_MASK
, LINT_MASK
, /* LVT0-1 */
136 LVT_MASK
/* LVTERR */
139 static int find_highest_vector(void *bitmap
)
142 int word_offset
= MAX_APIC_VECTOR
>> 5;
144 while ((word_offset
!= 0) && (word
[(--word_offset
) << 2] == 0))
147 if (likely(!word_offset
&& !word
[0]))
150 return fls(word
[word_offset
<< 2]) - 1 + (word_offset
<< 5);
153 static inline int apic_test_and_set_irr(int vec
, struct kvm_lapic
*apic
)
155 return apic_test_and_set_vector(vec
, apic
->regs
+ APIC_IRR
);
158 static inline void apic_clear_irr(int vec
, struct kvm_lapic
*apic
)
160 apic_clear_vector(vec
, apic
->regs
+ APIC_IRR
);
163 static inline int apic_find_highest_irr(struct kvm_lapic
*apic
)
167 result
= find_highest_vector(apic
->regs
+ APIC_IRR
);
168 ASSERT(result
== -1 || result
>= 16);
173 int kvm_lapic_find_highest_irr(struct kvm_vcpu
*vcpu
)
175 struct kvm_lapic
*apic
= (struct kvm_lapic
*)vcpu
->apic
;
180 highest_irr
= apic_find_highest_irr(apic
);
184 EXPORT_SYMBOL_GPL(kvm_lapic_find_highest_irr
);
186 int kvm_apic_set_irq(struct kvm_lapic
*apic
, u8 vec
, u8 trig
)
188 if (!apic_test_and_set_irr(vec
, apic
)) {
189 /* a new pending irq is set in IRR */
191 apic_set_vector(vec
, apic
->regs
+ APIC_TMR
);
193 apic_clear_vector(vec
, apic
->regs
+ APIC_TMR
);
194 kvm_vcpu_kick(apic
->vcpu
);
200 static inline int apic_find_highest_isr(struct kvm_lapic
*apic
)
204 result
= find_highest_vector(apic
->regs
+ APIC_ISR
);
205 ASSERT(result
== -1 || result
>= 16);
210 static void apic_update_ppr(struct kvm_lapic
*apic
)
215 tpr
= apic_get_reg(apic
, APIC_TASKPRI
);
216 isr
= apic_find_highest_isr(apic
);
217 isrv
= (isr
!= -1) ? isr
: 0;
219 if ((tpr
& 0xf0) >= (isrv
& 0xf0))
224 apic_debug("vlapic %p, ppr 0x%x, isr 0x%x, isrv 0x%x",
225 apic
, ppr
, isr
, isrv
);
227 apic_set_reg(apic
, APIC_PROCPRI
, ppr
);
230 static void apic_set_tpr(struct kvm_lapic
*apic
, u32 tpr
)
232 apic_set_reg(apic
, APIC_TASKPRI
, tpr
);
233 apic_update_ppr(apic
);
236 int kvm_apic_match_physical_addr(struct kvm_lapic
*apic
, u16 dest
)
238 return kvm_apic_id(apic
) == dest
;
241 int kvm_apic_match_logical_addr(struct kvm_lapic
*apic
, u8 mda
)
246 logical_id
= GET_APIC_LOGICAL_ID(apic_get_reg(apic
, APIC_LDR
));
248 switch (apic_get_reg(apic
, APIC_DFR
)) {
250 if (logical_id
& mda
)
253 case APIC_DFR_CLUSTER
:
254 if (((logical_id
>> 4) == (mda
>> 0x4))
255 && (logical_id
& mda
& 0xf))
259 printk(KERN_WARNING
"Bad DFR vcpu %d: %08x\n",
260 apic
->vcpu
->vcpu_id
, apic_get_reg(apic
, APIC_DFR
));
267 static int apic_match_dest(struct kvm_vcpu
*vcpu
, struct kvm_lapic
*source
,
268 int short_hand
, int dest
, int dest_mode
)
271 struct kvm_lapic
*target
= vcpu
->apic
;
273 apic_debug("target %p, source %p, dest 0x%x, "
274 "dest_mode 0x%x, short_hand 0x%x",
275 target
, source
, dest
, dest_mode
, short_hand
);
278 switch (short_hand
) {
279 case APIC_DEST_NOSHORT
:
280 if (dest_mode
== 0) {
282 if ((dest
== 0xFF) || (dest
== kvm_apic_id(target
)))
286 result
= kvm_apic_match_logical_addr(target
, dest
);
289 if (target
== source
)
292 case APIC_DEST_ALLINC
:
295 case APIC_DEST_ALLBUT
:
296 if (target
!= source
)
300 printk(KERN_WARNING
"Bad dest shorthand value %x\n",
309 * Add a pending IRQ into lapic.
310 * Return 1 if successfully added and 0 if discarded.
312 static int __apic_accept_irq(struct kvm_lapic
*apic
, int delivery_mode
,
313 int vector
, int level
, int trig_mode
)
317 switch (delivery_mode
) {
320 /* FIXME add logic for vcpu on reset */
321 if (unlikely(!apic_enabled(apic
)))
324 if (apic_test_and_set_irr(vector
, apic
) && trig_mode
) {
325 apic_debug("level trig mode repeatedly for vector %d",
331 apic_debug("level trig mode for vector %d", vector
);
332 apic_set_vector(vector
, apic
->regs
+ APIC_TMR
);
334 apic_clear_vector(vector
, apic
->regs
+ APIC_TMR
);
336 kvm_vcpu_kick(apic
->vcpu
);
342 printk(KERN_DEBUG
"Ignoring delivery mode 3\n");
346 printk(KERN_DEBUG
"Ignoring guest SMI\n");
349 printk(KERN_DEBUG
"Ignoring guest NMI\n");
353 printk(KERN_DEBUG
"Ignoring guest INIT\n");
356 case APIC_DM_STARTUP
:
357 printk(KERN_DEBUG
"Ignoring guest STARTUP\n");
361 printk(KERN_ERR
"TODO: unsupported delivery mode %x\n",
368 struct kvm_lapic
*kvm_apic_round_robin(struct kvm
*kvm
, u8 vector
,
369 unsigned long bitmap
)
373 /* TODO for real round robin */
374 vcpu_id
= fls(bitmap
) - 1;
376 printk(KERN_DEBUG
"vcpu not ready for apic_round_robin\n");
377 return kvm
->vcpus
[vcpu_id
]->apic
;
380 static void apic_set_eoi(struct kvm_lapic
*apic
)
382 int vector
= apic_find_highest_isr(apic
);
385 * Not every write EOI will has corresponding ISR,
386 * one example is when Kernel check timer on setup_IO_APIC
391 apic_clear_vector(vector
, apic
->regs
+ APIC_ISR
);
392 apic_update_ppr(apic
);
394 if (apic_test_and_clear_vector(vector
, apic
->regs
+ APIC_TMR
))
395 kvm_ioapic_update_eoi(apic
->vcpu
->kvm
, vector
);
398 static void apic_send_ipi(struct kvm_lapic
*apic
)
400 u32 icr_low
= apic_get_reg(apic
, APIC_ICR
);
401 u32 icr_high
= apic_get_reg(apic
, APIC_ICR2
);
403 unsigned int dest
= GET_APIC_DEST_FIELD(icr_high
);
404 unsigned int short_hand
= icr_low
& APIC_SHORT_MASK
;
405 unsigned int trig_mode
= icr_low
& APIC_INT_LEVELTRIG
;
406 unsigned int level
= icr_low
& APIC_INT_ASSERT
;
407 unsigned int dest_mode
= icr_low
& APIC_DEST_MASK
;
408 unsigned int delivery_mode
= icr_low
& APIC_MODE_MASK
;
409 unsigned int vector
= icr_low
& APIC_VECTOR_MASK
;
411 struct kvm_lapic
*target
;
412 struct kvm_vcpu
*vcpu
;
413 unsigned long lpr_map
= 0;
416 apic_debug("icr_high 0x%x, icr_low 0x%x, "
417 "short_hand 0x%x, dest 0x%x, trig_mode 0x%x, level 0x%x, "
418 "dest_mode 0x%x, delivery_mode 0x%x, vector 0x%x\n",
419 icr_high
, icr_low
, short_hand
, dest
,
420 trig_mode
, level
, dest_mode
, delivery_mode
, vector
);
422 for (i
= 0; i
< KVM_MAX_VCPUS
; i
++) {
423 vcpu
= apic
->vcpu
->kvm
->vcpus
[i
];
428 apic_match_dest(vcpu
, apic
, short_hand
, dest
, dest_mode
)) {
429 if (delivery_mode
== APIC_DM_LOWEST
)
430 set_bit(vcpu
->vcpu_id
, &lpr_map
);
432 __apic_accept_irq(vcpu
->apic
, delivery_mode
,
433 vector
, level
, trig_mode
);
437 if (delivery_mode
== APIC_DM_LOWEST
) {
438 target
= kvm_apic_round_robin(vcpu
->kvm
, vector
, lpr_map
);
440 __apic_accept_irq(target
, delivery_mode
,
441 vector
, level
, trig_mode
);
445 static u32
apic_get_tmcct(struct kvm_lapic
*apic
)
448 ktime_t passed
, now
= apic
->timer
.dev
.base
->get_time();
449 u32 tmcct
= apic_get_reg(apic
, APIC_TMICT
);
451 ASSERT(apic
!= NULL
);
453 if (unlikely(ktime_to_ns(now
) <=
454 ktime_to_ns(apic
->timer
.last_update
))) {
456 passed
= ktime_add(( {
459 (apic
->timer
.last_update
).tv64
}; }
461 apic_debug("time elapsed\n");
463 passed
= ktime_sub(now
, apic
->timer
.last_update
);
465 counter_passed
= div64_64(ktime_to_ns(passed
),
466 (APIC_BUS_CYCLE_NS
* apic
->timer
.divide_count
));
467 tmcct
-= counter_passed
;
470 if (unlikely(!apic_lvtt_period(apic
)))
474 tmcct
+= apic_get_reg(apic
, APIC_TMICT
);
475 } while (tmcct
<= 0);
481 static u32
__apic_read(struct kvm_lapic
*apic
, unsigned int offset
)
485 if (offset
>= LAPIC_MMIO_LENGTH
)
490 printk(KERN_WARNING
"Access APIC ARBPRI register "
491 "which is for P6\n");
494 case APIC_TMCCT
: /* Timer CCR */
495 val
= apic_get_tmcct(apic
);
499 apic_update_ppr(apic
);
500 val
= apic_get_reg(apic
, offset
);
507 static void apic_mmio_read(struct kvm_io_device
*this,
508 gpa_t address
, int len
, void *data
)
510 struct kvm_lapic
*apic
= (struct kvm_lapic
*)this->private;
511 unsigned int offset
= address
- apic
->base_address
;
512 unsigned char alignment
= offset
& 0xf;
515 if ((alignment
+ len
) > 4) {
516 printk(KERN_ERR
"KVM_APIC_READ: alignment error %lx %d",
517 (unsigned long)address
, len
);
520 result
= __apic_read(apic
, offset
& ~0xf);
526 memcpy(data
, (char *)&result
+ alignment
, len
);
529 printk(KERN_ERR
"Local APIC read with len = %x, "
530 "should be 1,2, or 4 instead\n", len
);
535 static void update_divide_count(struct kvm_lapic
*apic
)
537 u32 tmp1
, tmp2
, tdcr
;
539 tdcr
= apic_get_reg(apic
, APIC_TDCR
);
541 tmp2
= ((tmp1
& 0x3) | ((tmp1
& 0x8) >> 1)) + 1;
542 apic
->timer
.divide_count
= 0x1 << (tmp2
& 0x7);
544 apic_debug("timer divide count is 0x%x\n",
545 apic
->timer
.divide_count
);
548 static void start_apic_timer(struct kvm_lapic
*apic
)
550 ktime_t now
= apic
->timer
.dev
.base
->get_time();
552 apic
->timer
.last_update
= now
;
554 apic
->timer
.period
= apic_get_reg(apic
, APIC_TMICT
) *
555 APIC_BUS_CYCLE_NS
* apic
->timer
.divide_count
;
556 atomic_set(&apic
->timer
.pending
, 0);
557 hrtimer_start(&apic
->timer
.dev
,
558 ktime_add_ns(now
, apic
->timer
.period
),
561 apic_debug("%s: bus cycle is %" PRId64
"ns, now 0x%016"
563 "timer initial count 0x%x, period %lldns, "
564 "expire @ 0x%016" PRIx64
".\n", __FUNCTION__
,
565 APIC_BUS_CYCLE_NS
, ktime_to_ns(now
),
566 apic_get_reg(apic
, APIC_TMICT
),
568 ktime_to_ns(ktime_add_ns(now
,
569 apic
->timer
.period
)));
572 static void apic_mmio_write(struct kvm_io_device
*this,
573 gpa_t address
, int len
, const void *data
)
575 struct kvm_lapic
*apic
= (struct kvm_lapic
*)this->private;
576 unsigned int offset
= address
- apic
->base_address
;
577 unsigned char alignment
= offset
& 0xf;
581 * APIC register must be aligned on 128-bits boundary.
582 * 32/64/128 bits registers must be accessed thru 32 bits.
585 if (len
!= 4 || alignment
) {
586 if (printk_ratelimit())
587 printk(KERN_ERR
"apic write: bad size=%d %lx\n",
594 /* too common printing */
595 if (offset
!= APIC_EOI
)
596 apic_debug("%s: offset 0x%x with length 0x%x, and value is "
597 "0x%x\n", __FUNCTION__
, offset
, len
, val
);
602 case APIC_ID
: /* Local APIC ID */
603 apic_set_reg(apic
, APIC_ID
, val
);
607 apic_set_tpr(apic
, val
& 0xff);
615 apic_set_reg(apic
, APIC_LDR
, val
& APIC_LDR_MASK
);
619 apic_set_reg(apic
, APIC_DFR
, val
| 0x0FFFFFFF);
623 apic_set_reg(apic
, APIC_SPIV
, val
& 0x3ff);
624 if (!(val
& APIC_SPIV_APIC_ENABLED
)) {
628 for (i
= 0; i
< APIC_LVT_NUM
; i
++) {
629 lvt_val
= apic_get_reg(apic
,
630 APIC_LVTT
+ 0x10 * i
);
631 apic_set_reg(apic
, APIC_LVTT
+ 0x10 * i
,
632 lvt_val
| APIC_LVT_MASKED
);
634 atomic_set(&apic
->timer
.pending
, 0);
640 /* No delay here, so we always clear the pending bit */
641 apic_set_reg(apic
, APIC_ICR
, val
& ~(1 << 12));
646 apic_set_reg(apic
, APIC_ICR2
, val
& 0xff000000);
655 /* TODO: Check vector */
656 if (!apic_sw_enabled(apic
))
657 val
|= APIC_LVT_MASKED
;
659 val
&= apic_lvt_mask
[(offset
- APIC_LVTT
) >> 4];
660 apic_set_reg(apic
, offset
, val
);
665 hrtimer_cancel(&apic
->timer
.dev
);
666 apic_set_reg(apic
, APIC_TMICT
, val
);
667 start_apic_timer(apic
);
672 printk(KERN_ERR
"KVM_WRITE:TDCR %x\n", val
);
673 apic_set_reg(apic
, APIC_TDCR
, val
);
674 update_divide_count(apic
);
678 apic_debug("Local APIC Write to read-only register %x\n",
685 static int apic_mmio_range(struct kvm_io_device
*this, gpa_t addr
)
687 struct kvm_lapic
*apic
= (struct kvm_lapic
*)this->private;
691 if (apic_hw_enabled(apic
) &&
692 (addr
>= apic
->base_address
) &&
693 (addr
< (apic
->base_address
+ LAPIC_MMIO_LENGTH
)))
699 void kvm_free_apic(struct kvm_lapic
*apic
)
704 hrtimer_cancel(&apic
->timer
.dev
);
706 if (apic
->regs_page
) {
707 __free_page(apic
->regs_page
);
715 *----------------------------------------------------------------------
717 *----------------------------------------------------------------------
720 void kvm_lapic_set_tpr(struct kvm_vcpu
*vcpu
, unsigned long cr8
)
722 struct kvm_lapic
*apic
= (struct kvm_lapic
*)vcpu
->apic
;
726 apic_set_tpr(apic
, ((cr8
& 0x0f) << 4));
729 u64
kvm_lapic_get_cr8(struct kvm_vcpu
*vcpu
)
731 struct kvm_lapic
*apic
= (struct kvm_lapic
*)vcpu
->apic
;
736 tpr
= (u64
) apic_get_reg(apic
, APIC_TASKPRI
);
738 return (tpr
& 0xf0) >> 4;
740 EXPORT_SYMBOL_GPL(kvm_lapic_get_cr8
);
742 void kvm_lapic_set_base(struct kvm_vcpu
*vcpu
, u64 value
)
744 struct kvm_lapic
*apic
= (struct kvm_lapic
*)vcpu
->apic
;
747 value
|= MSR_IA32_APICBASE_BSP
;
748 vcpu
->apic_base
= value
;
751 if (apic
->vcpu
->vcpu_id
)
752 value
&= ~MSR_IA32_APICBASE_BSP
;
754 vcpu
->apic_base
= value
;
755 apic
->base_address
= apic
->vcpu
->apic_base
&
756 MSR_IA32_APICBASE_BASE
;
758 /* with FSB delivery interrupt, we can restart APIC functionality */
759 apic_debug("apic base msr is 0x%016" PRIx64
", and base address is "
760 "0x%lx.\n", apic
->apic_base
, apic
->base_address
);
764 u64
kvm_lapic_get_base(struct kvm_vcpu
*vcpu
)
766 return vcpu
->apic_base
;
768 EXPORT_SYMBOL_GPL(kvm_lapic_get_base
);
770 static void lapic_reset(struct kvm_vcpu
*vcpu
)
772 struct kvm_lapic
*apic
;
775 apic_debug("%s\n", __FUNCTION__
);
779 ASSERT(apic
!= NULL
);
781 /* Stop the timer in case it's a reset to an active apic */
782 hrtimer_cancel(&apic
->timer
.dev
);
784 apic_set_reg(apic
, APIC_ID
, vcpu
->vcpu_id
<< 24);
785 apic_set_reg(apic
, APIC_LVR
, APIC_VERSION
);
787 for (i
= 0; i
< APIC_LVT_NUM
; i
++)
788 apic_set_reg(apic
, APIC_LVTT
+ 0x10 * i
, APIC_LVT_MASKED
);
790 apic_set_reg(apic
, APIC_DFR
, 0xffffffffU
);
791 apic_set_reg(apic
, APIC_SPIV
, 0xff);
792 apic_set_reg(apic
, APIC_TASKPRI
, 0);
793 apic_set_reg(apic
, APIC_LDR
, 0);
794 apic_set_reg(apic
, APIC_ESR
, 0);
795 apic_set_reg(apic
, APIC_ICR
, 0);
796 apic_set_reg(apic
, APIC_ICR2
, 0);
797 apic_set_reg(apic
, APIC_TDCR
, 0);
798 apic_set_reg(apic
, APIC_TMICT
, 0);
799 for (i
= 0; i
< 8; i
++) {
800 apic_set_reg(apic
, APIC_IRR
+ 0x10 * i
, 0);
801 apic_set_reg(apic
, APIC_ISR
+ 0x10 * i
, 0);
802 apic_set_reg(apic
, APIC_TMR
+ 0x10 * i
, 0);
804 apic
->timer
.divide_count
= 0;
805 atomic_set(&apic
->timer
.pending
, 0);
806 if (vcpu
->vcpu_id
== 0)
807 vcpu
->apic_base
|= MSR_IA32_APICBASE_BSP
;
808 apic_update_ppr(apic
);
810 apic_debug(KERN_INFO
"%s: vcpu=%p, id=%d, base_msr="
811 "0x%016" PRIx64
", base_address=0x%0lx.\n", __FUNCTION__
,
812 vcpu
, kvm_apic_id(apic
),
813 vcpu
->apic_base
, apic
->base_address
);
816 int kvm_lapic_enabled(struct kvm_vcpu
*vcpu
)
818 struct kvm_lapic
*apic
= (struct kvm_lapic
*)vcpu
->apic
;
823 ret
= apic_enabled(apic
);
827 EXPORT_SYMBOL_GPL(kvm_lapic_enabled
);
830 *----------------------------------------------------------------------
832 *----------------------------------------------------------------------
834 static int __apic_timer_fn(struct kvm_lapic
*apic
)
839 if (unlikely(!apic_enabled(apic
) ||
840 !apic_lvt_enabled(apic
, APIC_LVTT
))) {
841 apic_debug("%s: time interrupt although apic is down\n",
846 vector
= apic_lvt_vector(apic
, APIC_LVTT
);
847 apic
->timer
.last_update
= apic
->timer
.dev
.expires
;
848 atomic_inc(&apic
->timer
.pending
);
849 __apic_accept_irq(apic
, APIC_DM_FIXED
, vector
, 1, 0);
851 if (apic_lvtt_period(apic
)) {
853 u32 tmict
= apic_get_reg(apic
, APIC_TMICT
);
855 offset
= APIC_BUS_CYCLE_NS
* apic
->timer
.divide_count
* tmict
;
858 apic
->timer
.dev
.expires
= ktime_add_ns(
859 apic
->timer
.dev
.expires
,
866 static enum hrtimer_restart
apic_timer_fn(struct hrtimer
*data
)
868 struct kvm_lapic
*apic
;
869 int restart_timer
= 0;
871 apic
= container_of(data
, struct kvm_lapic
, timer
.dev
);
873 restart_timer
= __apic_timer_fn(apic
);
876 return HRTIMER_RESTART
;
878 return HRTIMER_NORESTART
;
881 int kvm_create_lapic(struct kvm_vcpu
*vcpu
)
883 struct kvm_lapic
*apic
;
885 ASSERT(vcpu
!= NULL
);
886 apic_debug("apic_init %d\n", vcpu
->vcpu_id
);
888 apic
= kzalloc(sizeof(*apic
), GFP_KERNEL
);
894 apic
->regs_page
= alloc_page(GFP_KERNEL
);
895 if (apic
->regs_page
== NULL
) {
896 printk(KERN_ERR
"malloc apic regs error for vcpu %x\n",
900 apic
->regs
= page_address(apic
->regs_page
);
901 memset(apic
->regs
, 0, PAGE_SIZE
);
904 hrtimer_init(&apic
->timer
.dev
, CLOCK_MONOTONIC
, HRTIMER_MODE_ABS
);
905 apic
->timer
.dev
.function
= apic_timer_fn
;
906 apic
->base_address
= APIC_DEFAULT_PHYS_BASE
;
907 vcpu
->apic_base
= APIC_DEFAULT_PHYS_BASE
;
910 apic
->dev
.read
= apic_mmio_read
;
911 apic
->dev
.write
= apic_mmio_write
;
912 apic
->dev
.in_range
= apic_mmio_range
;
913 apic
->dev
.private = apic
;
920 EXPORT_SYMBOL_GPL(kvm_create_lapic
);
922 int kvm_apic_has_interrupt(struct kvm_vcpu
*vcpu
)
924 struct kvm_lapic
*apic
= vcpu
->apic
;
927 if (!apic
|| !apic_enabled(apic
))
930 apic_update_ppr(apic
);
931 highest_irr
= apic_find_highest_irr(apic
);
932 if ((highest_irr
== -1) ||
933 ((highest_irr
& 0xF0) <= apic_get_reg(apic
, APIC_PROCPRI
)))
938 int kvm_get_apic_interrupt(struct kvm_vcpu
*vcpu
)
940 int vector
= kvm_apic_has_interrupt(vcpu
);
941 struct kvm_lapic
*apic
= vcpu
->apic
;
946 apic_set_vector(vector
, apic
->regs
+ APIC_ISR
);
947 apic_update_ppr(apic
);
948 apic_clear_irr(vector
, apic
);
952 void kvm_apic_post_state_restore(struct kvm_vcpu
*vcpu
)
954 struct kvm_lapic
*apic
= vcpu
->apic
;
956 apic
->base_address
= vcpu
->apic_base
&
957 MSR_IA32_APICBASE_BASE
;
958 apic_set_reg(apic
, APIC_LVR
, APIC_VERSION
);
959 apic_update_ppr(apic
);
960 hrtimer_cancel(&apic
->timer
.dev
);
961 update_divide_count(apic
);
962 start_apic_timer(apic
);