i8254.h File Reference

#include <linux/kthread.h>
#include <kvm/iodev.h>

Include dependency graph for i8254.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	kvm_kpit_channel_state
struct	kvm_kpit_state
struct	kvm_pit

Macros
#define	KVM_PIT_BASE_ADDRESS   0x40
#define	KVM_SPEAKER_BASE_ADDRESS   0x61
#define	KVM_PIT_MEM_LENGTH   4
#define	KVM_PIT_FREQ   1193181
#define	KVM_MAX_PIT_INTR_INTERVAL   HZ / 100
#define	KVM_PIT_CHANNEL_MASK   0x3

Functions
struct kvm_pit *	kvm_create_pit (struct kvm *kvm, u32 flags)
void	kvm_free_pit (struct kvm *kvm)
void	kvm_pit_load_count (struct kvm_pit *pit, int channel, u32 val, int hpet_legacy_start)
void	kvm_pit_set_reinject (struct kvm_pit *pit, bool reinject)

Macro Definition Documentation

KVM_MAX_PIT_INTR_INTERVAL

#define KVM_MAX_PIT_INTR_INTERVAL   HZ / 100

Definition at line 55 of file i8254.h.

KVM_PIT_BASE_ADDRESS

#define KVM_PIT_BASE_ADDRESS   0x40

Definition at line 51 of file i8254.h.

KVM_PIT_CHANNEL_MASK

#define KVM_PIT_CHANNEL_MASK   0x3

Definition at line 56 of file i8254.h.

KVM_PIT_FREQ

#define KVM_PIT_FREQ   1193181

Definition at line 54 of file i8254.h.

KVM_PIT_MEM_LENGTH

#define KVM_PIT_MEM_LENGTH   4

Definition at line 53 of file i8254.h.

KVM_SPEAKER_BASE_ADDRESS

#define KVM_SPEAKER_BASE_ADDRESS   0x61

Definition at line 52 of file i8254.h.

Function Documentation

kvm_create_pit()

struct kvm_pit* kvm_create_pit	(	struct kvm *	kvm,
		u32	flags
	)

Definition at line 662 of file i8254.c.

{
    struct kvm_pit *pit;
    struct kvm_kpit_state *pit_state;
    struct pid *pid;
    pid_t pid_nr;
    int ret;
 
    pit = kzalloc(sizeof(struct kvm_pit), GFP_KERNEL_ACCOUNT);
    if (!pit)
        return NULL;
 
    pit->irq_source_id = kvm_request_irq_source_id(kvm);
    if (pit->irq_source_id < 0)
        goto fail_request;
 
    mutex_init(&pit->pit_state.lock);
 
    pid = get_pid(task_tgid(current));
    pid_nr = pid_vnr(pid);
    put_pid(pid);
 
    pit->worker = kthread_create_worker(0, "kvm-pit/%d", pid_nr);
    if (IS_ERR(pit->worker))
        goto fail_kthread;
 
    kthread_init_work(&pit->expired, pit_do_work);
 
    pit->kvm = kvm;
 
    pit_state = &pit->pit_state;
    hrtimer_init(&pit_state->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
    pit_state->timer.function = pit_timer_fn;
 
    pit_state->irq_ack_notifier.gsi = 0;
    pit_state->irq_ack_notifier.irq_acked = kvm_pit_ack_irq;
    pit->mask_notifier.func = pit_mask_notifer;
 
    kvm_pit_reset(pit);
 
    kvm_pit_set_reinject(pit, true);
 
    mutex_lock(&kvm->slots_lock);
    kvm_iodevice_init(&pit->dev, &pit_dev_ops);
    ret = kvm_io_bus_register_dev(kvm, KVM_PIO_BUS, KVM_PIT_BASE_ADDRESS,
                      KVM_PIT_MEM_LENGTH, &pit->dev);
    if (ret < 0)
        goto fail_register_pit;
 
    if (flags & KVM_PIT_SPEAKER_DUMMY) {
        kvm_iodevice_init(&pit->speaker_dev, &speaker_dev_ops);
        ret = kvm_io_bus_register_dev(kvm, KVM_PIO_BUS,
                          KVM_SPEAKER_BASE_ADDRESS, 4,
                          &pit->speaker_dev);
        if (ret < 0)
            goto fail_register_speaker;
    }
    mutex_unlock(&kvm->slots_lock);
 
    return pit;
 
fail_register_speaker:
    kvm_io_bus_unregister_dev(kvm, KVM_PIO_BUS, &pit->dev);
fail_register_pit:
    mutex_unlock(&kvm->slots_lock);
    kvm_pit_set_reinject(pit, false);
    kthread_destroy_worker(pit->worker);
fail_kthread:
    kvm_free_irq_source_id(kvm, pit->irq_source_id);
fail_request:
    kfree(pit);
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_free_pit()

void kvm_free_pit

(

struct kvm *

kvm

)

Definition at line 736 of file i8254.c.

{
    struct kvm_pit *pit = kvm->arch.vpit;
 
    if (pit) {
        mutex_lock(&kvm->slots_lock);
        kvm_io_bus_unregister_dev(kvm, KVM_PIO_BUS, &pit->dev);
        kvm_io_bus_unregister_dev(kvm, KVM_PIO_BUS, &pit->speaker_dev);
        mutex_unlock(&kvm->slots_lock);
        kvm_pit_set_reinject(pit, false);
        hrtimer_cancel(&pit->pit_state.timer);
        kthread_destroy_worker(pit->worker);
        kvm_free_irq_source_id(kvm, pit->irq_source_id);
        kfree(pit);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_pit_load_count()

void kvm_pit_load_count	(	struct kvm_pit *	pit,
		int	channel,
		u32	val,
		int	hpet_legacy_start
	)

Definition at line 403 of file i8254.c.

{
    u8 saved_mode;
 
    WARN_ON_ONCE(!mutex_is_locked(&pit->pit_state.lock));
 
    if (hpet_legacy_start) {
        /* save existing mode for later reenablement */
        WARN_ON(channel != 0);
        saved_mode = pit->pit_state.channels[0].mode;
        pit->pit_state.channels[0].mode = 0xff; /* disable timer */
        pit_load_count(pit, channel, val);
        pit->pit_state.channels[0].mode = saved_mode;
    } else {
        pit_load_count(pit, channel, val);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_pit_set_reinject()

void kvm_pit_set_reinject	(	struct kvm_pit *	pit,
		bool	reinject
	)

Definition at line 291 of file i8254.c.

{
    struct kvm_kpit_state *ps = &pit->pit_state;
    struct kvm *kvm = pit->kvm;
 
    if (atomic_read(&ps->reinject) == reinject)
        return;
 
    /*
     * AMD SVM AVIC accelerates EOI write and does not trap.
     * This cause in-kernel PIT re-inject mode to fail
     * since it checks ps->irq_ack before kvm_set_irq()
     * and relies on the ack notifier to timely queue
     * the pt->worker work iterm and reinject the missed tick.
     * So, deactivate APICv when PIT is in reinject mode.
     */
    if (reinject) {
        kvm_set_apicv_inhibit(kvm, APICV_INHIBIT_REASON_PIT_REINJ);
        /* The initial state is preserved while ps->reinject == 0. */
        kvm_pit_reset_reinject(pit);
        kvm_register_irq_ack_notifier(kvm, &ps->irq_ack_notifier);
        kvm_register_irq_mask_notifier(kvm, 0, &pit->mask_notifier);
    } else {
        kvm_clear_apicv_inhibit(kvm, APICV_INHIBIT_REASON_PIT_REINJ);
        kvm_unregister_irq_ack_notifier(kvm, &ps->irq_ack_notifier);
        kvm_unregister_irq_mask_notifier(kvm, 0, &pit->mask_notifier);
    }
 
    atomic_set(&ps->reinject, reinject);
}

Here is the call graph for this function:

Here is the caller graph for this function: