ioapic.c 10.3 KB
Newer Older
E
Eddie Dong 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/*
 *  Copyright (C) 2001  MandrakeSoft S.A.
 *
 *    MandrakeSoft S.A.
 *    43, rue d'Aboukir
 *    75002 Paris - France
 *    http://www.linux-mandrake.com/
 *    http://www.mandrakesoft.com/
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 *  Yunhong Jiang <yunhong.jiang@intel.com>
 *  Yaozu (Eddie) Dong <eddie.dong@intel.com>
 *  Based on Xen 3.1 code.
 */

29
#include <linux/kvm_host.h>
E
Eddie Dong 已提交
30 31 32 33 34 35 36 37 38
#include <linux/kvm.h>
#include <linux/mm.h>
#include <linux/highmem.h>
#include <linux/smp.h>
#include <linux/hrtimer.h>
#include <linux/io.h>
#include <asm/processor.h>
#include <asm/page.h>
#include <asm/current.h>
39 40 41

#include "ioapic.h"
#include "lapic.h"
M
Marcelo Tosatti 已提交
42
#include "irq.h"
43

44 45 46
#if 0
#define ioapic_debug(fmt,arg...) printk(KERN_WARNING fmt,##arg)
#else
E
Eddie Dong 已提交
47
#define ioapic_debug(fmt, arg...)
48
#endif
49
static int ioapic_deliver(struct kvm_ioapic *vioapic, int irq);
E
Eddie Dong 已提交
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85

static unsigned long ioapic_read_indirect(struct kvm_ioapic *ioapic,
					  unsigned long addr,
					  unsigned long length)
{
	unsigned long result = 0;

	switch (ioapic->ioregsel) {
	case IOAPIC_REG_VERSION:
		result = ((((IOAPIC_NUM_PINS - 1) & 0xff) << 16)
			  | (IOAPIC_VERSION_ID & 0xff));
		break;

	case IOAPIC_REG_APIC_ID:
	case IOAPIC_REG_ARB_ID:
		result = ((ioapic->id & 0xf) << 24);
		break;

	default:
		{
			u32 redir_index = (ioapic->ioregsel - 0x10) >> 1;
			u64 redir_content;

			ASSERT(redir_index < IOAPIC_NUM_PINS);

			redir_content = ioapic->redirtbl[redir_index].bits;
			result = (ioapic->ioregsel & 0x1) ?
			    (redir_content >> 32) & 0xffffffff :
			    redir_content & 0xffffffff;
			break;
		}
	}

	return result;
}

86
static int ioapic_service(struct kvm_ioapic *ioapic, unsigned int idx)
E
Eddie Dong 已提交
87
{
S
Sheng Yang 已提交
88
	union kvm_ioapic_redirect_entry *pent;
89
	int injected = -1;
E
Eddie Dong 已提交
90 91 92 93

	pent = &ioapic->redirtbl[idx];

	if (!pent->fields.mask) {
94
		injected = ioapic_deliver(ioapic, idx);
95
		if (injected && pent->fields.trig_mode == IOAPIC_LEVEL_TRIG)
E
Eddie Dong 已提交
96 97 98 99
			pent->fields.remote_irr = 1;
	}
	if (!pent->fields.trig_mode)
		ioapic->irr &= ~(1 << idx);
100 101

	return injected;
E
Eddie Dong 已提交
102 103 104 105 106
}

static void ioapic_write_indirect(struct kvm_ioapic *ioapic, u32 val)
{
	unsigned index;
107
	bool mask_before, mask_after;
E
Eddie Dong 已提交
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123

	switch (ioapic->ioregsel) {
	case IOAPIC_REG_VERSION:
		/* Writes are ignored. */
		break;

	case IOAPIC_REG_APIC_ID:
		ioapic->id = (val >> 24) & 0xf;
		break;

	case IOAPIC_REG_ARB_ID:
		break;

	default:
		index = (ioapic->ioregsel - 0x10) >> 1;

124
		ioapic_debug("change redir index %x val %x\n", index, val);
E
Eddie Dong 已提交
125 126
		if (index >= IOAPIC_NUM_PINS)
			return;
127
		mask_before = ioapic->redirtbl[index].fields.mask;
E
Eddie Dong 已提交
128 129 130 131 132 133 134 135
		if (ioapic->ioregsel & 1) {
			ioapic->redirtbl[index].bits &= 0xffffffff;
			ioapic->redirtbl[index].bits |= (u64) val << 32;
		} else {
			ioapic->redirtbl[index].bits &= ~0xffffffffULL;
			ioapic->redirtbl[index].bits |= (u32) val;
			ioapic->redirtbl[index].fields.remote_irr = 0;
		}
136 137 138
		mask_after = ioapic->redirtbl[index].fields.mask;
		if (mask_before != mask_after)
			kvm_fire_mask_notifiers(ioapic->kvm, index, mask_after);
E
Eddie Dong 已提交
139 140 141 142 143 144
		if (ioapic->irr & (1 << index))
			ioapic_service(ioapic, index);
		break;
	}
}

145
static int ioapic_inj_irq(struct kvm_ioapic *ioapic,
146
			   struct kvm_vcpu *vcpu,
E
Eddie Dong 已提交
147 148
			   u8 vector, u8 trig_mode, u8 delivery_mode)
{
149
	ioapic_debug("irq %d trig %d deliv %d\n", vector, trig_mode,
E
Eddie Dong 已提交
150 151
		     delivery_mode);

152 153
	ASSERT((delivery_mode == IOAPIC_FIXED) ||
	       (delivery_mode == IOAPIC_LOWEST_PRIORITY));
E
Eddie Dong 已提交
154

155
	return kvm_apic_set_irq(vcpu, vector, trig_mode);
E
Eddie Dong 已提交
156 157
}

158 159 160
static void ioapic_inj_nmi(struct kvm_vcpu *vcpu)
{
	kvm_inject_nmi(vcpu);
J
Jan Kiszka 已提交
161
	kvm_vcpu_kick(vcpu);
162 163
}

164 165
void kvm_ioapic_get_delivery_bitmask(struct kvm_ioapic *ioapic, u8 dest,
				     u8 dest_mode, unsigned long *mask)
E
Eddie Dong 已提交
166 167 168 169 170
{
	int i;
	struct kvm *kvm = ioapic->kvm;
	struct kvm_vcpu *vcpu;

171
	ioapic_debug("dest %d dest_mode %d\n", dest, dest_mode);
E
Eddie Dong 已提交
172

173
	*mask = 0;
E
Eddie Dong 已提交
174 175 176
	if (dest_mode == 0) {	/* Physical mode. */
		if (dest == 0xFF) {	/* Broadcast. */
			for (i = 0; i < KVM_MAX_VCPUS; ++i)
177
				if (kvm->vcpus[i] && kvm->vcpus[i]->arch.apic)
178 179
					*mask |= 1 << i;
			return;
E
Eddie Dong 已提交
180 181 182 183 184
		}
		for (i = 0; i < KVM_MAX_VCPUS; ++i) {
			vcpu = kvm->vcpus[i];
			if (!vcpu)
				continue;
185 186
			if (kvm_apic_match_physical_addr(vcpu->arch.apic, dest)) {
				if (vcpu->arch.apic)
187
					*mask = 1 << i;
E
Eddie Dong 已提交
188 189 190 191 192 193 194 195
				break;
			}
		}
	} else if (dest != 0)	/* Logical mode, MDA non-zero. */
		for (i = 0; i < KVM_MAX_VCPUS; ++i) {
			vcpu = kvm->vcpus[i];
			if (!vcpu)
				continue;
196 197
			if (vcpu->arch.apic &&
			    kvm_apic_match_logical_addr(vcpu->arch.apic, dest))
198
				*mask |= 1 << vcpu->vcpu_id;
E
Eddie Dong 已提交
199
		}
200
	ioapic_debug("mask %x\n", *mask);
E
Eddie Dong 已提交
201 202
}

203
static int ioapic_deliver(struct kvm_ioapic *ioapic, int irq)
E
Eddie Dong 已提交
204
{
205 206
	union kvm_ioapic_redirect_entry entry = ioapic->redirtbl[irq];
	unsigned long deliver_bitmask;
E
Eddie Dong 已提交
207
	struct kvm_vcpu *vcpu;
208
	int vcpu_id, r = -1;
E
Eddie Dong 已提交
209 210

	ioapic_debug("dest=%x dest_mode=%x delivery_mode=%x "
211
		     "vector=%x trig_mode=%x\n",
212 213 214
		     entry.fields.dest, entry.fields.dest_mode,
		     entry.fields.delivery_mode, entry.fields.vector,
		     entry.fields.trig_mode);
E
Eddie Dong 已提交
215

216
	kvm_get_intr_delivery_bitmask(ioapic, &entry, &deliver_bitmask);
E
Eddie Dong 已提交
217
	if (!deliver_bitmask) {
218
		ioapic_debug("no target on destination\n");
219
		return 0;
E
Eddie Dong 已提交
220 221
	}

222
	/* Always delivery PIT interrupt to vcpu 0 */
223
#ifdef CONFIG_X86
224 225
	if (irq == 0)
		deliver_bitmask = 1;
226
#endif
227 228 229 230 231 232 233 234 235 236

	for (vcpu_id = 0; deliver_bitmask != 0; vcpu_id++) {
		if (!(deliver_bitmask & (1 << vcpu_id)))
			continue;
		deliver_bitmask &= ~(1 << vcpu_id);
		vcpu = ioapic->kvm->vcpus[vcpu_id];
		if (vcpu) {
			if (entry.fields.delivery_mode ==
					IOAPIC_LOWEST_PRIORITY ||
			    entry.fields.delivery_mode == IOAPIC_FIXED) {
237 238
				if (r < 0)
					r = 0;
239 240 241 242 243
				r += ioapic_inj_irq(ioapic, vcpu,
						    entry.fields.vector,
						    entry.fields.trig_mode,
						    entry.fields.delivery_mode);
			} else if (entry.fields.delivery_mode == IOAPIC_NMI) {
244
				r = 1;
245 246 247 248 249 250 251 252 253 254
				ioapic_inj_nmi(vcpu);
			} else
				ioapic_debug("unsupported delivery mode %x!\n",
					     entry.fields.delivery_mode);
		} else
			ioapic_debug("null destination vcpu: "
				     "mask=%x vector=%x delivery_mode=%x\n",
				     entry.fields.deliver_bitmask,
				     entry.fields.vector,
				     entry.fields.delivery_mode);
E
Eddie Dong 已提交
255
	}
256
	return r;
E
Eddie Dong 已提交
257 258
}

259
int kvm_ioapic_set_irq(struct kvm_ioapic *ioapic, int irq, int level)
E
Eddie Dong 已提交
260 261 262
{
	u32 old_irr = ioapic->irr;
	u32 mask = 1 << irq;
S
Sheng Yang 已提交
263
	union kvm_ioapic_redirect_entry entry;
264
	int ret = 1;
E
Eddie Dong 已提交
265 266 267 268 269 270 271 272 273 274

	if (irq >= 0 && irq < IOAPIC_NUM_PINS) {
		entry = ioapic->redirtbl[irq];
		level ^= entry.fields.polarity;
		if (!level)
			ioapic->irr &= ~mask;
		else {
			ioapic->irr |= mask;
			if ((!entry.fields.trig_mode && old_irr != ioapic->irr)
			    || !entry.fields.remote_irr)
275
				ret = ioapic_service(ioapic, irq);
E
Eddie Dong 已提交
276 277
		}
	}
278
	return ret;
E
Eddie Dong 已提交
279 280
}

281
static void __kvm_ioapic_update_eoi(struct kvm_ioapic *ioapic, int pin,
M
Marcelo Tosatti 已提交
282
				    int trigger_mode)
E
Eddie Dong 已提交
283
{
S
Sheng Yang 已提交
284
	union kvm_ioapic_redirect_entry *ent;
E
Eddie Dong 已提交
285

286
	ent = &ioapic->redirtbl[pin];
E
Eddie Dong 已提交
287

288
	kvm_notify_acked_irq(ioapic->kvm, KVM_IRQCHIP_IOAPIC, pin);
M
Marcelo Tosatti 已提交
289 290 291 292

	if (trigger_mode == IOAPIC_LEVEL_TRIG) {
		ASSERT(ent->fields.trig_mode == IOAPIC_LEVEL_TRIG);
		ent->fields.remote_irr = 0;
293 294
		if (!ent->fields.mask && (ioapic->irr & (1 << pin)))
			ioapic_service(ioapic, pin);
M
Marcelo Tosatti 已提交
295
	}
E
Eddie Dong 已提交
296 297
}

M
Marcelo Tosatti 已提交
298
void kvm_ioapic_update_eoi(struct kvm *kvm, int vector, int trigger_mode)
299 300 301 302 303 304
{
	struct kvm_ioapic *ioapic = kvm->arch.vioapic;
	int i;

	for (i = 0; i < IOAPIC_NUM_PINS; i++)
		if (ioapic->redirtbl[i].fields.vector == vector)
M
Marcelo Tosatti 已提交
305
			__kvm_ioapic_update_eoi(ioapic, i, trigger_mode);
306 307
}

308 309
static int ioapic_in_range(struct kvm_io_device *this, gpa_t addr,
			   int len, int is_write)
E
Eddie Dong 已提交
310 311 312 313 314 315 316 317 318 319 320 321 322
{
	struct kvm_ioapic *ioapic = (struct kvm_ioapic *)this->private;

	return ((addr >= ioapic->base_address &&
		 (addr < ioapic->base_address + IOAPIC_MEM_LENGTH)));
}

static void ioapic_mmio_read(struct kvm_io_device *this, gpa_t addr, int len,
			     void *val)
{
	struct kvm_ioapic *ioapic = (struct kvm_ioapic *)this->private;
	u32 result;

323
	ioapic_debug("addr %lx\n", (unsigned long)addr);
E
Eddie Dong 已提交
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
	ASSERT(!(addr & 0xf));	/* check alignment */

	addr &= 0xff;
	switch (addr) {
	case IOAPIC_REG_SELECT:
		result = ioapic->ioregsel;
		break;

	case IOAPIC_REG_WINDOW:
		result = ioapic_read_indirect(ioapic, addr, len);
		break;

	default:
		result = 0;
		break;
	}
	switch (len) {
	case 8:
		*(u64 *) val = result;
		break;
	case 1:
	case 2:
	case 4:
		memcpy(val, (char *)&result, len);
		break;
	default:
		printk(KERN_WARNING "ioapic: wrong length %d\n", len);
	}
}

static void ioapic_mmio_write(struct kvm_io_device *this, gpa_t addr, int len,
			      const void *val)
{
	struct kvm_ioapic *ioapic = (struct kvm_ioapic *)this->private;
	u32 data;

360 361
	ioapic_debug("ioapic_mmio_write addr=%p len=%d val=%p\n",
		     (void*)addr, len, val);
E
Eddie Dong 已提交
362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
	ASSERT(!(addr & 0xf));	/* check alignment */
	if (len == 4 || len == 8)
		data = *(u32 *) val;
	else {
		printk(KERN_WARNING "ioapic: Unsupported size %d\n", len);
		return;
	}

	addr &= 0xff;
	switch (addr) {
	case IOAPIC_REG_SELECT:
		ioapic->ioregsel = data;
		break;

	case IOAPIC_REG_WINDOW:
		ioapic_write_indirect(ioapic, data);
		break;
379 380
#ifdef	CONFIG_IA64
	case IOAPIC_REG_EOI:
381
		kvm_ioapic_update_eoi(ioapic->kvm, data, IOAPIC_LEVEL_TRIG);
382 383
		break;
#endif
E
Eddie Dong 已提交
384 385 386 387 388 389

	default:
		break;
	}
}

390 391 392 393 394 395 396 397 398 399 400 401
void kvm_ioapic_reset(struct kvm_ioapic *ioapic)
{
	int i;

	for (i = 0; i < IOAPIC_NUM_PINS; i++)
		ioapic->redirtbl[i].fields.mask = 1;
	ioapic->base_address = IOAPIC_DEFAULT_BASE_ADDRESS;
	ioapic->ioregsel = 0;
	ioapic->irr = 0;
	ioapic->id = 0;
}

E
Eddie Dong 已提交
402 403 404 405 406 407 408
int kvm_ioapic_init(struct kvm *kvm)
{
	struct kvm_ioapic *ioapic;

	ioapic = kzalloc(sizeof(struct kvm_ioapic), GFP_KERNEL);
	if (!ioapic)
		return -ENOMEM;
409
	kvm->arch.vioapic = ioapic;
410
	kvm_ioapic_reset(ioapic);
E
Eddie Dong 已提交
411 412 413 414 415 416 417 418
	ioapic->dev.read = ioapic_mmio_read;
	ioapic->dev.write = ioapic_mmio_write;
	ioapic->dev.in_range = ioapic_in_range;
	ioapic->dev.private = ioapic;
	ioapic->kvm = kvm;
	kvm_io_bus_register_dev(&kvm->mmio_bus, &ioapic->dev);
	return 0;
}
419