linux/arch/x86/kvm/i8259.c

/*
 * 8259 interrupt controller emulation
 *
 * Copyright (c) 2003-2004 Fabrice Bellard
 * Copyright (c) 2007 Intel Corporation
 * Copyright 2009 Red Hat, Inc. and/or its affiliates.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 * Authors:
 *   Yaozu (Eddie) Dong <[email protected]>
 *   Port from Qemu.
 */
#define pr_fmt(fmt) …

#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/bitops.h>
#include "irq.h"

#include <linux/kvm_host.h>
#include "trace.h"

#define pr_pic_unimpl(fmt, ...) …

static void pic_irq_request(struct kvm *kvm, int level);

static void pic_lock(struct kvm_pic *s)
	__acquires(&s->lock)
{ … }

static void pic_unlock(struct kvm_pic *s)
	__releases(&s->lock)
{ … }

static void pic_clear_isr(struct kvm_kpic_state *s, int irq)
{ … }

/*
 * set irq level. If an edge is detected, then the IRR is set to 1
 */
static inline int pic_set_irq1(struct kvm_kpic_state *s, int irq, int level)
{ … }

/*
 * return the highest priority found in mask (highest = smallest
 * number). Return 8 if no irq
 */
static inline int get_priority(struct kvm_kpic_state *s, int mask)
{ … }

/*
 * return the pic wanted interrupt. return -1 if none
 */
static int pic_get_irq(struct kvm_kpic_state *s)
{ … }

/*
 * raise irq to CPU if necessary. must be called every time the active
 * irq may change
 */
static void pic_update_irq(struct kvm_pic *s)
{ … }

void kvm_pic_update_irq(struct kvm_pic *s)
{ … }

int kvm_pic_set_irq(struct kvm_pic *s, int irq, int irq_source_id, int level)
{ … }

void kvm_pic_clear_all(struct kvm_pic *s, int irq_source_id)
{ … }

/*
 * acknowledge interrupt 'irq'
 */
static inline void pic_intack(struct kvm_kpic_state *s, int irq)
{ … }

int kvm_pic_read_irq(struct kvm *kvm)
{ … }

static void kvm_pic_reset(struct kvm_kpic_state *s)
{ … }

static void pic_ioport_write(void *opaque, u32 addr, u32 val)
{ … }

static u32 pic_poll_read(struct kvm_kpic_state *s, u32 addr1)
{ … }

static u32 pic_ioport_read(void *opaque, u32 addr)
{ … }

static void elcr_ioport_write(void *opaque, u32 val)
{ … }

static u32 elcr_ioport_read(void *opaque)
{ … }

static int picdev_write(struct kvm_pic *s,
			 gpa_t addr, int len, const void *val)
{ … }

static int picdev_read(struct kvm_pic *s,
		       gpa_t addr, int len, void *val)
{ … }

static int picdev_master_write(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
			       gpa_t addr, int len, const void *val)
{ … }

static int picdev_master_read(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
			      gpa_t addr, int len, void *val)
{ … }

static int picdev_slave_write(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
			      gpa_t addr, int len, const void *val)
{ … }

static int picdev_slave_read(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
			     gpa_t addr, int len, void *val)
{ … }

static int picdev_elcr_write(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
			     gpa_t addr, int len, const void *val)
{ … }

static int picdev_elcr_read(struct kvm_vcpu *vcpu, struct kvm_io_device *dev,
			    gpa_t addr, int len, void *val)
{ … }

/*
 * callback when PIC0 irq status changed
 */
static void pic_irq_request(struct kvm *kvm, int level)
{ … }

static const struct kvm_io_device_ops picdev_master_ops = …;

static const struct kvm_io_device_ops picdev_slave_ops = …;

static const struct kvm_io_device_ops picdev_elcr_ops = …;

int kvm_pic_init(struct kvm *kvm)
{ … }

void kvm_pic_destroy(struct kvm *kvm)
{ … }