DevAPIC.cpp@ 3670

Last change on this file since 3670 was 2981, checked in by vboxsync, 17 years ago
InnoTek -> innotek: all the headers and comments.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 60.1 KB

Line
1	#ifdef VBOX
2	/* $Id: DevAPIC.cpp 2981 2007-06-01 16:01:28Z vboxsync $ */
3	/** @file
4	* Advanced Programmable Interrupt Controller (APIC) Device and
5	* I/O Advanced Programmable Interrupt Controller (IO-APIC) Device.
6	*/
7
8	/*
9	* Copyright (C) 2006-2007 innotek GmbH
10	*
11	* This file is part of VirtualBox Open Source Edition (OSE), as
12	* available from http://www.virtualbox.org. This file is free software;
13	* you can redistribute it and/or modify it under the terms of the GNU
14	* General Public License as published by the Free Software Foundation,
15	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
16	* distribution. VirtualBox OSE is distributed in the hope that it will
17	* be useful, but WITHOUT ANY WARRANTY of any kind.
18	*
19	* If you received this file as part of a commercial VirtualBox
20	* distribution, then only the terms of your commercial VirtualBox
21	* license agreement apply instead of the previous paragraph.
22	*
23	* --------------------------------------------------------------------
24	*
25	* This code is based on:
26	*
27	* apic.c revision 1.5 @@OSETODO
28	*/
29
30	/*******************************************************************************
31	* Header Files *
32	*******************************************************************************/
33	#define LOG_GROUP LOG_GROUP_DEV_APIC
34	#include <VBox/pdm.h>
35
36	#include <VBox/log.h>
37	#include <VBox/stam.h>
38	#include <iprt/assert.h>
39	#include <iprt/asm.h>
40
41	#include "Builtins2.h"
42	#include "vl_vbox.h"
43
44	#define MSR_IA32_APICBASE 0x1b
45	#define MSR_IA32_APICBASE_BSP (1<<8)
46	#define MSR_IA32_APICBASE_ENABLE (1<<11)
47	#define MSR_IA32_APICBASE_BASE (0xfffff<<12)
48
49	#ifndef EINVAL
50	# define EINVAL 1
51	#endif
52
53	#ifdef _MSC_VER
54	# pragma warning(disable:4244)
55	#endif
56
57	/** @def APIC_LOCK
58	* Acquires the PDM lock. This is a NOP if locking is disabled. */
59	/** @def APIC_UNLOCK
60	* Releases the PDM lock. This is a NOP if locking is disabled. */
61	/** @def IOAPIC_LOCK
62	* Acquires the PDM lock. This is a NOP if locking is disabled. */
63	/** @def IOAPIC_UNLOCK
64	* Releases the PDM lock. This is a NOP if locking is disabled. */
65	#ifdef VBOX_WITH_PDM_LOCK
66	# define APIC_LOCK(pThis, rc) \
67	do { \
68	int rc2 = (pThis)->CTXALLSUFF(pApicHlp)->pfnLock((pThis)->CTXSUFF(pDevIns), rc); \
69	if (rc2 != VINF_SUCCESS) \
70	return rc2; \
71	} while (0)
72	# define APIC_UNLOCK(pThis) \
73	(pThis)->CTXALLSUFF(pApicHlp)->pfnUnlock((pThis)->CTXSUFF(pDevIns))
74	# define IOAPIC_LOCK(pThis, rc) \
75	do { \
76	int rc2 = (pThis)->CTXALLSUFF(pIoApicHlp)->pfnLock((pThis)->CTXSUFF(pDevIns), rc); \
77	if (rc2 != VINF_SUCCESS) \
78	return rc2; \
79	} while (0)
80	# define IOAPIC_UNLOCK(pThis) (pThis)->CTXALLSUFF(pIoApicHlp)->pfnUnlock((pThis)->CTXSUFF(pDevIns))
81	#else /* !VBOX_WITH_PDM_LOCK */
82	# define APIC_LOCK(pThis, rc) do { } while (0)
83	# define APIC_UNLOCK(pThis) do { } while (0)
84	# define IOAPIC_LOCK(pThis, rc) do { } while (0)
85	# define IOAPIC_UNLOCK(pThis) do { } while (0)
86	#endif /* !VBOX_WITH_PDM_LOCK */
87
88
89	#endif /* VBOX */
90
91	/*
92	* APIC support
93	*
94	* Copyright (c) 2004-2005 Fabrice Bellard
95	*
96	* This library is free software; you can redistribute it and/or
97	* modify it under the terms of the GNU Lesser General Public
98	* License as published by the Free Software Foundation; either
99	* version 2 of the License, or (at your option) any later version.
100	*
101	* This library is distributed in the hope that it will be useful,
102	* but WITHOUT ANY WARRANTY; without even the implied warranty of
103	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
104	* Lesser General Public License for more details.
105	*
106	* You should have received a copy of the GNU Lesser General Public
107	* License along with this library; if not, write to the Free Software
108	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
109	*/
110	#ifndef VBOX
111	#include "vl.h"
112	#endif
113
114	#define DEBUG_APIC
115	#define DEBUG_IOAPIC
116
117	/* APIC Local Vector Table */
118	#define APIC_LVT_TIMER 0
119	#define APIC_LVT_THERMAL 1
120	#define APIC_LVT_PERFORM 2
121	#define APIC_LVT_LINT0 3
122	#define APIC_LVT_LINT1 4
123	#define APIC_LVT_ERROR 5
124	#define APIC_LVT_NB 6
125
126	/* APIC delivery modes */
127	#define APIC_DM_FIXED 0
128	#define APIC_DM_LOWPRI 1
129	#define APIC_DM_SMI 2
130	#define APIC_DM_NMI 4
131	#define APIC_DM_INIT 5
132	#define APIC_DM_SIPI 6
133	#define APIC_DM_EXTINT 7
134
135	/* APIC destination mode */
136	#define APIC_DESTMODE_FLAT 0xf
137	#define APIC_DESTMODE_CLUSTER 1
138
139	#define APIC_TRIGGER_EDGE 0
140	#define APIC_TRIGGER_LEVEL 1
141
142	#define APIC_LVT_TIMER_PERIODIC (1<<17)
143	#define APIC_LVT_MASKED (1<<16)
144	#define APIC_LVT_LEVEL_TRIGGER (1<<15)
145	#define APIC_LVT_REMOTE_IRR (1<<14)
146	#define APIC_INPUT_POLARITY (1<<13)
147	#define APIC_SEND_PENDING (1<<12)
148
149	#define IOAPIC_NUM_PINS 0x18
150
151	#define ESR_ILLEGAL_ADDRESS (1 << 7)
152
153	#define APIC_SV_ENABLE (1 << 8)
154
155	#ifdef VBOX
156	#define APIC_MAX_PATCH_ATTEMPTS 100
157	#endif
158
159	typedef struct APICState {
160	#ifndef VBOX
161	CPUState *cpu_env;
162	#endif /* !VBOX */
163	uint32_t apicbase;
164	uint8_t id;
165	uint8_t arb_id;
166	#ifdef VBOX
167	uint32_t tpr;
168	#else
169	uint8_t tpr;
170	#endif
171	uint32_t spurious_vec;
172	uint8_t log_dest;
173	uint8_t dest_mode;
174	uint32_t isr[8]; /* in service register */
175	uint32_t tmr[8]; /* trigger mode register */
176	uint32_t irr[8]; /* interrupt request register */
177	uint32_t lvt[APIC_LVT_NB];
178	uint32_t esr; /* error register */
179	uint32_t icr[2];
180
181	uint32_t divide_conf;
182	int count_shift;
183	uint32_t initial_count;
184	#ifdef VBOX
185	uint32_t Alignment0;
186	#endif
187	int64_t initial_count_load_time, next_time;
188	#ifndef VBOX
189	QEMUTimer *timer;
190
191	struct APICState *next_apic;
192	#else /* VBOX */
193	/** HC pointer to the device instance. */
194	PPDMDEVINSHC pDevInsHC;
195	/** Pointer to the APIC HC helpers. */
196	PCPDMAPICHLPR3 pApicHlpR3;
197	/** The APIC timer - HC Ptr. */
198	PTMTIMERHC pTimerHC;
199	/** Pointer to the APIC R0 helpers. */
200	PCPDMAPICHLPR0 pApicHlpR0;
201
202	/** GC pointer to the device instance. */
203	PPDMDEVINSGC pDevInsGC;
204	/** Pointer to the APIC GC helpers. */
205	PCPDMAPICHLPGC pApicHlpGC;
206	/** The APIC timer - GC Ptr. */
207	PTMTIMERGC pTimerGC;
208
209	/** Number of attempts made to optimize TPR accesses. */
210	uint32_t ulTPRPatchAttempts;
211
212	# ifdef VBOX_WITH_STATISTICS
213	STAMCOUNTER StatMMIOReadGC;
214	STAMCOUNTER StatMMIOReadHC;
215	STAMCOUNTER StatMMIOWriteGC;
216	STAMCOUNTER StatMMIOWriteHC;
217	STAMCOUNTER StatClearedActiveIrq;
218	# endif
219	#endif /* VBOX */
220	} APICState;
221
222	struct IOAPICState {
223	uint8_t id;
224	uint8_t ioregsel;
225
226	uint32_t irr;
227	uint64_t ioredtbl[IOAPIC_NUM_PINS];
228
229	#ifdef VBOX
230	/** HC pointer to the device instance. */
231	PPDMDEVINSHC pDevInsHC;
232	/** Pointer to the IOAPIC R3 helpers. */
233	PCPDMIOAPICHLPR3 pIoApicHlpR3;
234
235	/** GC pointer to the device instance. */
236	PPDMDEVINSGC pDevInsGC;
237	/** Pointer to the IOAPIC GC helpers. */
238	PCPDMIOAPICHLPGC pIoApicHlpGC;
239
240	/** Pointer to the IOAPIC R0 helpers. */
241	PCPDMIOAPICHLPR0 pIoApicHlpR0;
242	# if HC_ARCH_BITS == 32
243	uint32_t Alignment0;
244	# endif
245	# ifdef VBOX_WITH_STATISTICS
246	STAMCOUNTER StatMMIOReadGC;
247	STAMCOUNTER StatMMIOReadHC;
248	STAMCOUNTER StatMMIOWriteGC;
249	STAMCOUNTER StatMMIOWriteHC;
250	STAMCOUNTER StatSetIrqGC;
251	STAMCOUNTER StatSetIrqHC;
252	# endif
253	#endif /* VBOX */
254	};
255
256	#ifdef VBOX
257	typedef struct IOAPICState IOAPICState;
258	#endif /* VBOX */
259
260	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
261	#ifndef VBOX
262	static int apic_io_memory;
263	static APICState *first_local_apic = NULL;
264	static int last_apic_id = 0;
265	#endif /* !VBOX */
266
267	static void apic_init_ipi(APICState *s);
268	static void apic_set_irq(APICState *s, int vector_num, int trigger_mode);
269	static bool apic_update_irq(APICState *s);
270
271	#ifdef VBOX
272	static uint32_t apic_get_delivery_bitmask(APICState *s, uint8_t dest, uint8_t dest_mode);
273	__BEGIN_DECLS
274	PDMBOTHCBDECL(int) apicMMIORead(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb);
275	PDMBOTHCBDECL(int) apicMMIOWrite(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb);
276	PDMBOTHCBDECL(int) apicGetInterrupt(PPDMDEVINS pDevIns);
277	PDMBOTHCBDECL(void) apicSetBase(PPDMDEVINS pDevIns, uint64_t val);
278	PDMBOTHCBDECL(uint64_t) apicGetBase(PPDMDEVINS pDevIns);
279	PDMBOTHCBDECL(void) apicSetTPR(PPDMDEVINS pDevIns, uint8_t val);
280	PDMBOTHCBDECL(uint8_t) apicGetTPR(PPDMDEVINS pDevIns);
281	PDMBOTHCBDECL(void) apicBusDeliverCallback(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode,
282	uint8_t u8DeliveryMode, uint8_t iVector, uint8_t u8Polarity,
283	uint8_t u8TriggerMode);
284	PDMBOTHCBDECL(int) ioapicMMIORead(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb);
285	PDMBOTHCBDECL(int) ioapicMMIOWrite(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb);
286	PDMBOTHCBDECL(void) ioapicSetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel);
287
288	static void apic_update_tpr(APICState *s, uint32_t val);
289	__END_DECLS
290	#endif /* VBOX */
291
292	#ifndef VBOX
293	static void apic_bus_deliver(uint32_t deliver_bitmask, uint8_t delivery_mode,
294	uint8_t vector_num, uint8_t polarity,
295	uint8_t trigger_mode)
296	{
297	APICState *apic_iter;
298	#else /* VBOX */
299	static void apic_bus_deliver(APICState *s, uint32_t deliver_bitmask, uint8_t delivery_mode,
300	uint8_t vector_num, uint8_t polarity,
301	uint8_t trigger_mode)
302	{
303	#endif /* VBOX */
304
305	switch (delivery_mode) {
306	case APIC_DM_LOWPRI:
307	case APIC_DM_FIXED:
308	/* XXX: arbitration */
309	break;
310
311	case APIC_DM_SMI:
312	case APIC_DM_NMI:
313	break;
314
315	case APIC_DM_INIT:
316	/* normal INIT IPI sent to processors */
317	#ifdef VBOX
318	apic_init_ipi (s);
319	#else
320	for (apic_iter = first_local_apic; apic_iter != NULL;
321	apic_iter = apic_iter->next_apic) {
322	apic_init_ipi(apic_iter);
323	}
324	#endif
325	return;
326
327	case APIC_DM_EXTINT:
328	/* handled in I/O APIC code */
329	break;
330
331	default:
332	return;
333	}
334
335	#ifdef VBOX
336	if (deliver_bitmask & (1 << s->id))
337	apic_set_irq (s, vector_num, trigger_mode);
338	#else /* VBOX */
339	for (apic_iter = first_local_apic; apic_iter != NULL;
340	apic_iter = apic_iter->next_apic) {
341	if (deliver_bitmask & (1 << apic_iter->id))
342	apic_set_irq(apic_iter, vector_num, trigger_mode);
343	}
344	#endif /* VBOX */
345	}
346
347	#ifndef VBOX
348	void cpu_set_apic_base(CPUState *env, uint64_t val)
349	{
350	APICState *s = env->apic_state;
351	#ifdef DEBUG_APIC
352	Log(("cpu_set_apic_base: %016llx\n", val));
353	#endif
354
355	s->apicbase = (val & 0xfffff000) \|
356	(s->apicbase & (MSR_IA32_APICBASE_BSP \| MSR_IA32_APICBASE_ENABLE));
357	/* if disabled, cannot be enabled again */
358	if (!(val & MSR_IA32_APICBASE_ENABLE)) {
359	s->apicbase &= ~MSR_IA32_APICBASE_ENABLE;
360	env->cpuid_features &= ~CPUID_APIC;
361	s->spurious_vec &= ~APIC_SV_ENABLE;
362	}
363	}
364	#else /* VBOX */
365	PDMBOTHCBDECL(void) apicSetBase(PPDMDEVINS pDevIns, uint64_t val)
366	{
367	APICState s = PDMINS2DATA(pDevIns, APICState );
368	Log(("cpu_set_apic_base: %016RX64\n", val));
369
370	/** @todo If this change is valid immediately, then we should change the MMIO registration! */
371	s->apicbase = (val & 0xfffff000) \|
372	(s->apicbase & (MSR_IA32_APICBASE_BSP \| MSR_IA32_APICBASE_ENABLE));
373	/* if disabled, cannot be enabled again (until reset) */
374	if (!(val & MSR_IA32_APICBASE_ENABLE)) {
375	s->apicbase &= ~MSR_IA32_APICBASE_ENABLE;
376	s->spurious_vec &= ~APIC_SV_ENABLE;
377
378	/* Clear any pending APIC interrupt action flag. */
379	s->CTXALLSUFF(pApicHlp)->pfnClearInterruptFF(s->CTXSUFF(pDevIns));
380	s->CTXALLSUFF(pApicHlp)->pfnChangeFeature(pDevIns, false);
381	}
382	}
383	#endif /* VBOX */
384	#ifndef VBOX
385
386	uint64_t cpu_get_apic_base(CPUState *env)
387	{
388	APICState *s = env->apic_state;
389	#ifdef DEBUG_APIC
390	Log(("cpu_get_apic_base: %016llx\n", (uint64_t)s->apicbase));
391	#endif
392	return s->apicbase;
393	}
394
395	void cpu_set_apic_tpr(CPUX86State *env, uint8_t val)
396	{
397	APICState *s = env->apic_state;
398	s->tpr = (val & 0x0f) << 4;
399	apic_update_irq(s);
400	}
401
402	uint8_t cpu_get_apic_tpr(CPUX86State *env)
403	{
404	APICState *s = env->apic_state;
405	return s->tpr >> 4;
406	}
407
408	static int fls_bit(int value)
409	{
410	unsigned int ret = 0;
411
412	#ifdef HOST_I386
413	__asm__ __volatile__ ("bsr %1, %0\n" : "+r" (ret) : "rm" (value));
414	return ret;
415	#else
416	if (value > 0xffff)
417	value >>= 16, ret = 16;
418	if (value > 0xff)
419	value >>= 8, ret += 8;
420	if (value > 0xf)
421	value >>= 4, ret += 4;
422	if (value > 0x3)
423	value >>= 2, ret += 2;
424	return ret + (value >> 1);
425	#endif
426	}
427
428	static inline void set_bit(uint32_t *tab, int index)
429	{
430	int i, mask;
431	i = index >> 5;
432	mask = 1 << (index & 0x1f);
433	tab[i] \|= mask;
434	}
435
436	static inline void reset_bit(uint32_t *tab, int index)
437	{
438	int i, mask;
439	i = index >> 5;
440	mask = 1 << (index & 0x1f);
441	tab[i] &= ~mask;
442	}
443
444
445	#else /* VBOX */
446
447	PDMBOTHCBDECL(uint64_t) apicGetBase(PPDMDEVINS pDevIns)
448	{
449	APICState s = PDMINS2DATA(pDevIns, APICState );
450	Log(("apicGetBase: %016llx\n", (uint64_t)s->apicbase));
451	return s->apicbase;
452	}
453
454	PDMBOTHCBDECL(void) apicSetTPR(PPDMDEVINS pDevIns, uint8_t val)
455	{
456	APICState s = PDMINS2DATA(pDevIns, APICState );
457	LogFlow(("apicSetTPR: val=%#x (trp %#x -> %#x)\n", val, s->tpr, (val & 0x0f) << 4));
458	apic_update_tpr(s, (val & 0x0f) << 4);
459	}
460
461	PDMBOTHCBDECL(uint8_t) apicGetTPR(PPDMDEVINS pDevIns)
462	{
463	APICState s = PDMINS2DATA(pDevIns, APICState );
464	LogFlow(("apicGetTPR: returns %#x\n", s->tpr >> 4));
465	return s->tpr >> 4;
466	}
467
468	/**
469	* More or less private interface between IOAPIC, only PDM is responsible
470	* for connecting the two devices.
471	*/
472	PDMBOTHCBDECL(void) apicBusDeliverCallback(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode,
473	uint8_t u8DeliveryMode, uint8_t iVector, uint8_t u8Polarity,
474	uint8_t u8TriggerMode)
475	{
476	APICState s = PDMINS2DATA(pDevIns, APICState );
477	LogFlow(("apicBusDeliverCallback: s=%p pDevIns=%p u8Dest=%#x u8DestMode=%#x u8DeliveryMode=%#x iVector=%#x u8Polarity=%#x u8TriggerMode=%#x\n",
478	s, pDevIns, u8Dest, u8DestMode, u8DeliveryMode, iVector, u8Polarity, u8TriggerMode));
479	apic_bus_deliver(s, apic_get_delivery_bitmask(s, u8Dest, u8DestMode),
480	u8DeliveryMode, iVector, u8Polarity, u8TriggerMode);
481	}
482
483	# define set_bit(pvBitmap, iBit) ASMBitSet(pvBitmap, iBit)
484	# define reset_bit(pvBitmap, iBit) ASMBitClear(pvBitmap, iBit)
485	# define fls_bit(value) (ASMBitLastSetU32(value) - 1)
486
487	#endif /* VBOX */
488
489	/* return -1 if no bit is set */
490	static int get_highest_priority_int(uint32_t *tab)
491	{
492	int i;
493	for(i = 7; i >= 0; i--) {
494	if (tab[i] != 0) {
495	return i * 32 + fls_bit(tab[i]);
496	}
497	}
498	return -1;
499	}
500
501	static int apic_get_ppr(APICState *s)
502	{
503	int tpr, isrv, ppr;
504
505	tpr = (s->tpr >> 4);
506	isrv = get_highest_priority_int(s->isr);
507	if (isrv < 0)
508	isrv = 0;
509	isrv >>= 4;
510	if (tpr >= isrv)
511	ppr = s->tpr;
512	else
513	ppr = isrv << 4;
514	return ppr;
515	}
516
517	static int apic_get_arb_pri(APICState *s)
518	{
519	/* XXX: arbitration */
520	return 0;
521	}
522
523	/* signal the CPU if an irq is pending */
524	static bool apic_update_irq(APICState *s)
525	{
526	int irrv, ppr;
527	if (!(s->spurious_vec & APIC_SV_ENABLE))
528	#ifdef VBOX
529	{
530	/* Clear any pending APIC interrupt action flag. */
531	s->CTXALLSUFF(pApicHlp)->pfnClearInterruptFF(s->CTXSUFF(pDevIns));
532	return false;
533	}
534	#else
535	return false;
536	#endif /* VBOX */
537	irrv = get_highest_priority_int(s->irr);
538	if (irrv < 0)
539	return false;
540	ppr = apic_get_ppr(s);
541	if (ppr && (irrv & 0xf0) <= (ppr & 0xf0))
542	return false;
543	#ifndef VBOX
544	cpu_interrupt(s->cpu_env, CPU_INTERRUPT_HARD);
545	#else
546	s->CTXALLSUFF(pApicHlp)->pfnSetInterruptFF(s->CTXSUFF(pDevIns));
547	return true;
548	#endif
549	}
550
551	#ifdef VBOX
552	static void apic_update_tpr(APICState *s, uint32_t val)
553	{
554	bool fIrqIsActive = false;
555	bool fIrqWasActive = false;
556
557	fIrqWasActive = apic_update_irq(s);
558	s->tpr = val;
559	fIrqIsActive = apic_update_irq(s);
560
561	/* If an interrupt is pending and now masked, then clear the FF flag. */
562	if (fIrqWasActive && !fIrqIsActive)
563	{
564	Log(("apic_update_tpr: deactivate interrupt that was masked by the TPR update (%x)\n", val));
565	STAM_COUNTER_INC(&s->StatClearedActiveIrq);
566	s->CTXALLSUFF(pApicHlp)->pfnClearInterruptFF(s->CTXSUFF(pDevIns));
567	}
568	}
569	#endif
570
571	static void apic_set_irq(APICState *s, int vector_num, int trigger_mode)
572	{
573	set_bit(s->irr, vector_num);
574	if (trigger_mode)
575	set_bit(s->tmr, vector_num);
576	else
577	reset_bit(s->tmr, vector_num);
578	apic_update_irq(s);
579	}
580
581	static void apic_eoi(APICState *s)
582	{
583	int isrv;
584	isrv = get_highest_priority_int(s->isr);
585	if (isrv < 0)
586	return;
587	reset_bit(s->isr, isrv);
588	/* XXX: send the EOI packet to the APIC bus to allow the I/O APIC to
589	set the remote IRR bit for level triggered interrupts. */
590	apic_update_irq(s);
591	}
592
593	#ifndef VBOX
594	static uint32_t apic_get_delivery_bitmask(uint8_t dest, uint8_t dest_mode)
595	#else /* VBOX */
596	static uint32_t apic_get_delivery_bitmask(APICState *s, uint8_t dest, uint8_t dest_mode)
597	#endif /* VBOX */
598	{
599	uint32_t mask = 0;
600	#ifndef VBOX
601	APICState *apic_iter;
602	#endif /* !VBOX */
603
604	if (dest_mode == 0) {
605	if (dest == 0xff)
606	mask = 0xff;
607	else
608	mask = 1 << dest;
609	} else {
610	/* XXX: cluster mode */
611	#ifdef VBOX
612	if (dest & s->log_dest)
613	mask \|= 1 << s->id;
614	#else /* !VBOX */
615	for (apic_iter = first_local_apic; apic_iter != NULL;
616	apic_iter = apic_iter->next_apic) {
617	if (dest & apic_iter->log_dest)
618	mask \|= (1 << apic_iter->id);
619	}
620	#endif /* !VBOX */
621	}
622
623	return mask;
624	}
625
626
627	static void apic_init_ipi(APICState *s)
628	{
629	int i;
630
631	for(i = 0; i < APIC_LVT_NB; i++)
632	s->lvt[i] = 1 << 16; /* mask LVT */
633	s->tpr = 0;
634	s->spurious_vec = 0xff;
635	s->log_dest = 0;
636	s->dest_mode = 0xff;
637	memset(s->isr, 0, sizeof(s->isr));
638	memset(s->tmr, 0, sizeof(s->tmr));
639	memset(s->irr, 0, sizeof(s->irr));
640	for(i = 0; i < APIC_LVT_NB; i++)
641	s->lvt[i] = 1 << 16; /* mask LVT */
642	s->esr = 0;
643	memset(s->icr, 0, sizeof(s->icr));
644	s->divide_conf = 0;
645	s->count_shift = 0;
646	s->initial_count = 0;
647	s->initial_count_load_time = 0;
648	s->next_time = 0;
649	}
650
651	static void apic_deliver(APICState *s, uint8_t dest, uint8_t dest_mode,
652	uint8_t delivery_mode, uint8_t vector_num,
653	uint8_t polarity, uint8_t trigger_mode)
654	{
655	uint32_t deliver_bitmask = 0;
656	int dest_shorthand = (s->icr[0] >> 18) & 3;
657	#ifndef VBOX
658	APICState *apic_iter;
659	#endif /* !VBOX */
660
661	switch (delivery_mode) {
662	case APIC_DM_LOWPRI:
663	/* XXX: serch for focus processor, arbitration */
664	dest = s->id;
665
666	case APIC_DM_INIT:
667	{
668	int trig_mode = (s->icr[0] >> 15) & 1;
669	int level = (s->icr[0] >> 14) & 1;
670	if (level == 0 && trig_mode == 1) {
671	#ifdef VBOX
672	if (deliver_bitmask & (1 << s->id)) {
673	s->arb_id = s->id;
674	}
675	#else /* !VBOX */
676	for (apic_iter = first_local_apic; apic_iter != NULL;
677	apic_iter = apic_iter->next_apic) {
678	if (deliver_bitmask & (1 << apic_iter->id)) {
679	apic_iter->arb_id = apic_iter->id;
680	}
681	}
682	#endif /* !VBOX */
683	return;
684	}
685	}
686	break;
687
688	case APIC_DM_SIPI:
689	#ifndef VBOX
690	for (apic_iter = first_local_apic; apic_iter != NULL;
691	apic_iter = apic_iter->next_apic) {
692	if (deliver_bitmask & (1 << apic_iter->id)) {
693	/* XXX: SMP support */
694	/* apic_startup(apic_iter); */
695	}
696	}
697	#endif /* !VBOX */
698	return;
699	}
700
701	switch (dest_shorthand) {
702	case 0:
703	#ifndef VBOX
704	deliver_bitmask = apic_get_delivery_bitmask(dest, dest_mode);
705	#else /* VBOX */
706	deliver_bitmask = apic_get_delivery_bitmask(s, dest, dest_mode);
707	#endif /* !VBOX */
708	break;
709	case 1:
710	deliver_bitmask = (1 << s->id);
711	break;
712	case 2:
713	deliver_bitmask = 0xffffffff;
714	break;
715	case 3:
716	deliver_bitmask = 0xffffffff & ~(1 << s->id);
717	break;
718	}
719
720	#ifndef VBOX
721	apic_bus_deliver(deliver_bitmask, delivery_mode, vector_num, polarity,
722	trigger_mode);
723	#else /* VBOX */
724	apic_bus_deliver(s, deliver_bitmask, delivery_mode, vector_num, polarity,
725	trigger_mode);
726	#endif /* VBOX */
727	}
728
729	#ifndef VBOX
730	int apic_get_interrupt(CPUState *env)
731	{
732	APICState *s = env->apic_state;
733	#else /* VBOX */
734	PDMBOTHCBDECL(int) apicGetInterrupt(PPDMDEVINS pDevIns)
735	{
736	APICState s = PDMINS2DATA(pDevIns, APICState );
737	#endif /* VBOX */
738	int intno;
739
740	/* if the APIC is installed or enabled, we let the 8259 handle the
741	IRQs */
742	if (!s) {
743	Log(("apic_get_interrupt: returns -1 (!s)\n"));
744	return -1;
745	}
746	if (!(s->spurious_vec & APIC_SV_ENABLE)) {
747	Log(("apic_get_interrupt: returns -1 (APIC_SV_ENABLE)\n"));
748	return -1;
749	}
750
751	/* XXX: spurious IRQ handling */
752	intno = get_highest_priority_int(s->irr);
753	if (intno < 0) {
754	Log(("apic_get_interrupt: returns -1 (irr)\n"));
755	return -1;
756	}
757	if (s->tpr && (uint32_t)intno <= s->tpr) {
758	Log(("apic_get_interrupt: returns %d (sp)\n", s->spurious_vec & 0xff));
759	return s->spurious_vec & 0xff;
760	}
761	reset_bit(s->irr, intno);
762	set_bit(s->isr, intno);
763	apic_update_irq(s);
764	LogFlow(("apic_get_interrupt: returns %d\n", intno));
765	return intno;
766	}
767
768	static uint32_t apic_get_current_count(APICState *s)
769	{
770	int64_t d;
771	uint32_t val;
772	#ifndef VBOX
773	d = (qemu_get_clock(vm_clock) - s->initial_count_load_time) >>
774	s->count_shift;
775	#else /* VBOX */
776	d = (TMTimerGet(s->CTXSUFF(pTimer)) - s->initial_count_load_time) >>
777	s->count_shift;
778	#endif /* VBOX */
779	if (s->lvt[APIC_LVT_TIMER] & APIC_LVT_TIMER_PERIODIC) {
780	/* periodic */
781	val = s->initial_count - (d % ((uint64_t)s->initial_count + 1));
782	} else {
783	if (d >= s->initial_count)
784	val = 0;
785	else
786	val = s->initial_count - d;
787	}
788	return val;
789	}
790
791	static void apic_timer_update(APICState *s, int64_t current_time)
792	{
793	int64_t next_time, d;
794
795	if (!(s->lvt[APIC_LVT_TIMER] & APIC_LVT_MASKED)) {
796	d = (current_time - s->initial_count_load_time) >>
797	s->count_shift;
798	if (s->lvt[APIC_LVT_TIMER] & APIC_LVT_TIMER_PERIODIC) {
799	d = ((d / ((uint64_t)s->initial_count + 1)) + 1) * ((uint64_t)s->initial_count + 1);
800	} else {
801	if (d >= s->initial_count)
802	goto no_timer;
803	d = (uint64_t)s->initial_count + 1;
804	}
805	next_time = s->initial_count_load_time + (d << s->count_shift);
806	#ifndef VBOX
807	qemu_mod_timer(s->timer, next_time);
808	#else
809	TMTimerSet(s->CTXSUFF(pTimer), next_time);
810	#endif
811	s->next_time = next_time;
812	} else {
813	no_timer:
814	#ifndef VBOX
815	qemu_del_timer(s->timer);
816	#else
817	TMTimerStop(s->CTXSUFF(pTimer));
818	#endif
819	}
820	}
821
822	#ifdef IN_RING3
823	#ifndef VBOX
824	static void apic_timer(void *opaque)
825	{
826	APICState *s = opaque;
827	#else /* VBOX */
828	static DECLCALLBACK(void) apicTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer)
829	{
830	APICState s = PDMINS2DATA(pDevIns, APICState );
831	# ifdef VBOX_WITH_PDM_LOCK
832	s->pApicHlpR3->pfnLock(pDevIns, VERR_INTERNAL_ERROR);
833	# endif
834	#endif /* VBOX */
835
836	if (!(s->lvt[APIC_LVT_TIMER] & APIC_LVT_MASKED)) {
837	apic_set_irq(s, s->lvt[APIC_LVT_TIMER] & 0xff, APIC_TRIGGER_EDGE);
838	}
839	apic_timer_update(s, s->next_time);
840
841	#ifdef VBOX
842	APIC_UNLOCK(s);
843	#endif
844	}
845	#endif /* IN_RING3 */
846
847	#ifndef VBOX
848	static uint32_t apic_mem_readb(void *opaque, target_phys_addr_t addr)
849	{
850	return 0;
851	}
852
853	static uint32_t apic_mem_readw(void *opaque, target_phys_addr_t addr)
854	{
855	return 0;
856	}
857
858	static void apic_mem_writeb(void *opaque, target_phys_addr_t addr, uint32_t val)
859	{
860	}
861
862	static void apic_mem_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
863	{
864	}
865	#endif /* !VBOX */
866
867
868	#ifndef VBOX
869	static uint32_t apic_mem_readl(void *opaque, target_phys_addr_t addr)
870	{
871	CPUState *env;
872	APICState *s;
873	#else /* VBOX */
874	static uint32_t apic_mem_readl(APICState *s, target_phys_addr_t addr)
875	{
876	#endif /* VBOX */
877	uint32_t val;
878	int index;
879
880	#ifndef VBOX
881	env = cpu_single_env;
882	if (!env)
883	return 0;
884	s = env->apic_state;
885	#endif /* !VBOX */
886
887	index = (addr >> 4) & 0xff;
888	switch(index) {
889	case 0x02: /* id */
890	val = s->id << 24;
891	break;
892	case 0x03: /* version */
893	val = 0x11 \| ((APIC_LVT_NB - 1) << 16); /* version 0x11 */
894	break;
895	case 0x08:
896	val = s->tpr;
897	break;
898	case 0x09:
899	val = apic_get_arb_pri(s);
900	break;
901	case 0x0a:
902	/* ppr */
903	val = apic_get_ppr(s);
904	break;
905	#ifdef VBOX
906	case 0x0b:
907	Log(("apic_mem_readl %x %x -> write only returning 0\n", addr, index));
908	val = 0;
909	break;
910	#endif
911
912	case 0x0d:
913	val = s->log_dest << 24;
914	break;
915	case 0x0e:
916	#ifdef VBOX
917	/* Bottom 28 bits are always 1 */
918	val = (s->dest_mode << 28) \| 0xfffffff;
919	#else
920	val = s->dest_mode << 28;
921	#endif
922	break;
923	case 0x0f:
924	val = s->spurious_vec;
925	break;
926	#ifndef VBOX
927	case 0x10 ... 0x17:
928	#else /* VBOX */
929	case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
930	#endif /* VBOX */
931	val = s->isr[index & 7];
932	break;
933	#ifndef VBOX
934	case 0x18 ... 0x1f:
935	#else /* VBOX */
936	case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:
937	#endif /* VBOX */
938	val = s->tmr[index & 7];
939	break;
940	#ifndef VBOX
941	case 0x20 ... 0x27:
942	#else /* VBOX */
943	case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27:
944	#endif /* VBOX */
945	val = s->irr[index & 7];
946	break;
947	case 0x28:
948	val = s->esr;
949	break;
950	case 0x30:
951	case 0x31:
952	val = s->icr[index & 1];
953	break;
954	#ifndef VBOX
955	case 0x32 ... 0x37:
956	#else /* VBOX */
957	case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
958	#endif /* VBOX */
959	val = s->lvt[index - 0x32];
960	break;
961	case 0x38:
962	val = s->initial_count;
963	break;
964	case 0x39:
965	val = apic_get_current_count(s);
966	break;
967	case 0x3e:
968	val = s->divide_conf;
969	break;
970	default:
971	AssertMsgFailed(("apic_mem_readl: unknown index %x\n", index));
972	s->esr \|= ESR_ILLEGAL_ADDRESS;
973	val = 0;
974	break;
975	}
976	#ifdef DEBUG_APIC
977	Log(("APIC read: %08x = %08x\n", (uint32_t)addr, val));
978	#endif
979	return val;
980	}
981
982	#ifndef VBOX
983	static void apic_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
984	{
985	CPUState *env;
986	APICState *s;
987	#else /* VBOX */
988	static int apic_mem_writel(APICState *s, target_phys_addr_t addr, uint32_t val)
989	{
990	#endif /* VBOX */
991	int index;
992
993	#ifndef VBOX
994	env = cpu_single_env;
995	if (!env)
996	return;
997	s = env->apic_state;
998	#endif /* !VBOX */
999
1000	#ifdef DEBUG_APIC
1001	Log(("APIC write: %08x = %08x\n", (uint32_t)addr, val));
1002	#endif
1003
1004	index = (addr >> 4) & 0xff;
1005	switch(index) {
1006	case 0x02:
1007	s->id = (val >> 24);
1008	break;
1009	case 0x03:
1010	Log(("apic_mem_writel: write to version register; ignored\n"));
1011	break;
1012	case 0x08:
1013	#ifdef VBOX
1014	apic_update_tpr(s, val);
1015	#else
1016	s->tpr = val;
1017	apic_update_irq(s);
1018	#endif
1019	break;
1020	case 0x09:
1021	case 0x0a:
1022	Log(("apic_mem_writel: write to read-only register %d ignored\n", index));
1023	break;
1024	case 0x0b: /* EOI */
1025	apic_eoi(s);
1026	break;
1027	case 0x0d:
1028	s->log_dest = val >> 24;
1029	break;
1030	case 0x0e:
1031	s->dest_mode = val >> 28;
1032	break;
1033	case 0x0f:
1034	s->spurious_vec = val & 0x1ff;
1035	apic_update_irq(s);
1036	break;
1037	#ifndef VBOX
1038	case 0x10 ... 0x17:
1039	case 0x18 ... 0x1f:
1040	case 0x20 ... 0x27:
1041	case 0x28:
1042	#else
1043	case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
1044	case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:
1045	case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27:
1046	case 0x28:
1047	Log(("apic_mem_writel: write to read-only register %d ignored\n", index));
1048	#endif
1049	break;
1050
1051	case 0x30:
1052	s->icr[0] = val;
1053	apic_deliver(s, (s->icr[1] >> 24) & 0xff, (s->icr[0] >> 11) & 1,
1054	(s->icr[0] >> 8) & 7, (s->icr[0] & 0xff),
1055	(s->icr[0] >> 14) & 1, (s->icr[0] >> 15) & 1);
1056	break;
1057	case 0x31:
1058	s->icr[1] = val;
1059	break;
1060	#ifndef VBOX
1061	case 0x32 ... 0x37:
1062	#else /* VBOX */
1063	case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
1064	#endif /* VBOX */
1065	{
1066	int n = index - 0x32;
1067	s->lvt[n] = val;
1068	if (n == APIC_LVT_TIMER)
1069	#ifndef VBOX
1070	apic_timer_update(s, qemu_get_clock(vm_clock));
1071	#else /* VBOX */
1072	apic_timer_update(s, TMTimerGet(s->CTXSUFF(pTimer)));
1073	#endif /* VBOX*/
1074	}
1075	break;
1076	case 0x38:
1077	s->initial_count = val;
1078	#ifndef VBOX
1079	s->initial_count_load_time = qemu_get_clock(vm_clock);
1080	#else /* VBOX */
1081	s->initial_count_load_time = TMTimerGet(s->CTXSUFF(pTimer));
1082	#endif /* VBOX*/
1083	apic_timer_update(s, s->initial_count_load_time);
1084	break;
1085	case 0x39:
1086	Log(("apic_mem_writel: write to read-only register %d ignored\n", index));
1087	break;
1088	case 0x3e:
1089	{
1090	int v;
1091	s->divide_conf = val & 0xb;
1092	v = (s->divide_conf & 3) \| ((s->divide_conf >> 1) & 4);
1093	s->count_shift = (v + 1) & 7;
1094	}
1095	break;
1096	default:
1097	AssertMsgFailed(("apic_mem_writel: unknown index %x\n", index));
1098	s->esr \|= ESR_ILLEGAL_ADDRESS;
1099	break;
1100	}
1101	#ifdef VBOX
1102	return VINF_SUCCESS;
1103	#endif
1104	}
1105
1106	#ifdef IN_RING3
1107
1108	static void apic_save(QEMUFile f, void opaque)
1109	{
1110	APICState s = (APICState)opaque;
1111	int i;
1112
1113	qemu_put_be32s(f, &s->apicbase);
1114	qemu_put_8s(f, &s->id);
1115	qemu_put_8s(f, &s->arb_id);
1116	#ifdef VBOX
1117	qemu_put_be32s(f, &s->tpr);
1118	#else
1119	qemu_put_8s(f, &s->tpr);
1120	#endif
1121	qemu_put_be32s(f, &s->spurious_vec);
1122	qemu_put_8s(f, &s->log_dest);
1123	qemu_put_8s(f, &s->dest_mode);
1124	for (i = 0; i < 8; i++) {
1125	qemu_put_be32s(f, &s->isr[i]);
1126	qemu_put_be32s(f, &s->tmr[i]);
1127	qemu_put_be32s(f, &s->irr[i]);
1128	}
1129	for (i = 0; i < APIC_LVT_NB; i++) {
1130	qemu_put_be32s(f, &s->lvt[i]);
1131	}
1132	qemu_put_be32s(f, &s->esr);
1133	qemu_put_be32s(f, &s->icr[0]);
1134	qemu_put_be32s(f, &s->icr[1]);
1135	qemu_put_be32s(f, &s->divide_conf);
1136	qemu_put_be32s(f, &s->count_shift);
1137	qemu_put_be32s(f, &s->initial_count);
1138	qemu_put_be64s(f, &s->initial_count_load_time);
1139	qemu_put_be64s(f, &s->next_time);
1140	}
1141
1142	static int apic_load(QEMUFile f, void opaque, int version_id)
1143	{
1144	APICState s = (APICState)opaque;
1145	int i;
1146
1147	if (version_id != 1)
1148	return -EINVAL;
1149
1150	/* XXX: what if the base changes? (registered memory regions) */
1151	qemu_get_be32s(f, &s->apicbase);
1152	qemu_get_8s(f, &s->id);
1153	qemu_get_8s(f, &s->arb_id);
1154	#ifdef VBOX
1155	qemu_get_be32s(f, &s->tpr);
1156	#else
1157	qemu_get_8s(f, &s->tpr);
1158	#endif
1159	qemu_get_be32s(f, &s->spurious_vec);
1160	qemu_get_8s(f, &s->log_dest);
1161	qemu_get_8s(f, &s->dest_mode);
1162	for (i = 0; i < 8; i++) {
1163	qemu_get_be32s(f, &s->isr[i]);
1164	qemu_get_be32s(f, &s->tmr[i]);
1165	qemu_get_be32s(f, &s->irr[i]);
1166	}
1167	for (i = 0; i < APIC_LVT_NB; i++) {
1168	qemu_get_be32s(f, &s->lvt[i]);
1169	}
1170	qemu_get_be32s(f, &s->esr);
1171	qemu_get_be32s(f, &s->icr[0]);
1172	qemu_get_be32s(f, &s->icr[1]);
1173	qemu_get_be32s(f, &s->divide_conf);
1174	qemu_get_be32s(f, (uint32_t *)&s->count_shift);
1175	qemu_get_be32s(f, (uint32_t *)&s->initial_count);
1176	qemu_get_be64s(f, (uint64_t *)&s->initial_count_load_time);
1177	qemu_get_be64s(f, (uint64_t *)&s->next_time);
1178	return 0;
1179	}
1180
1181	static void apic_reset(void *opaque)
1182	{
1183	APICState s = (APICState)opaque;
1184	#ifdef VBOX
1185	TMTimerStop(s->CTXSUFF(pTimer));
1186
1187	/* malc, I've removed the initing duplicated in apic_init_ipi(). This
1188	* arb_id was left over.. */
1189	s->arb_id = 0;
1190
1191	/* Reset should re-enable the APIC. */
1192	s->apicbase = 0xfee00000 \| MSR_IA32_APICBASE_BSP \| MSR_IA32_APICBASE_ENABLE;
1193	s->pApicHlpR3->pfnChangeFeature(s->pDevInsHC, true);
1194
1195	#endif /* VBOX */
1196	apic_init_ipi(s);
1197	}
1198
1199	#endif /* IN_RING3 */
1200
1201	#ifndef VBOX
1202	static CPUReadMemoryFunc *apic_mem_read[3] = {
1203	apic_mem_readb,
1204	apic_mem_readw,
1205	apic_mem_readl,
1206	};
1207
1208	static CPUWriteMemoryFunc *apic_mem_write[3] = {
1209	apic_mem_writeb,
1210	apic_mem_writew,
1211	apic_mem_writel,
1212	};
1213
1214	int apic_init(CPUState *env)
1215	{
1216	APICState *s;
1217
1218	s = qemu_mallocz(sizeof(APICState));
1219	if (!s)
1220	return -1;
1221	env->apic_state = s;
1222	apic_init_ipi(s);
1223	s->id = last_apic_id++;
1224	s->cpu_env = env;
1225	s->apicbase = 0xfee00000 \|
1226	(s->id ? 0 : MSR_IA32_APICBASE_BSP) \| MSR_IA32_APICBASE_ENABLE;
1227
1228	/* XXX: mapping more APICs at the same memory location */
1229	if (apic_io_memory == 0) {
1230	/* NOTE: the APIC is directly connected to the CPU - it is not
1231	on the global memory bus. */
1232	apic_io_memory = cpu_register_io_memory(0, apic_mem_read,
1233	apic_mem_write, NULL);
1234	cpu_register_physical_memory(s->apicbase & ~0xfff, 0x1000,
1235	apic_io_memory);
1236	}
1237	s->timer = qemu_new_timer(vm_clock, apic_timer, s);
1238
1239	register_savevm("apic", 0, 1, apic_save, apic_load, s);
1240	qemu_register_reset(apic_reset, s);
1241
1242	s->next_apic = first_local_apic;
1243	first_local_apic = s;
1244
1245	return 0;
1246	}
1247	#endif /* !VBOX */
1248
1249	static void ioapic_service(IOAPICState *s)
1250	{
1251	uint8_t i;
1252	uint8_t trig_mode;
1253	uint8_t vector;
1254	uint8_t delivery_mode;
1255	uint32_t mask;
1256	uint64_t entry;
1257	uint8_t dest;
1258	uint8_t dest_mode;
1259	uint8_t polarity;
1260
1261	for (i = 0; i < IOAPIC_NUM_PINS; i++) {
1262	mask = 1 << i;
1263	if (s->irr & mask) {
1264	entry = s->ioredtbl[i];
1265	if (!(entry & APIC_LVT_MASKED)) {
1266	trig_mode = ((entry >> 15) & 1);
1267	dest = entry >> 56;
1268	dest_mode = (entry >> 11) & 1;
1269	delivery_mode = (entry >> 8) & 7;
1270	polarity = (entry >> 13) & 1;
1271	if (trig_mode == APIC_TRIGGER_EDGE)
1272	s->irr &= ~mask;
1273	if (delivery_mode == APIC_DM_EXTINT)
1274	#ifndef VBOX /* malc: i'm still not so sure about ExtINT delivery */
1275	vector = pic_read_irq(isa_pic);
1276	#else /* VBOX */
1277	{
1278	AssertMsgFailed(("Delivery mode ExtINT"));
1279	vector = 0xff; /* incorrect but shuts up gcc. */
1280	}
1281	#endif /* VBOX */
1282	else
1283	vector = entry & 0xff;
1284
1285	#ifndef VBOX
1286	apic_bus_deliver(apic_get_delivery_bitmask(dest, dest_mode),
1287	delivery_mode, vector, polarity, trig_mode);
1288	#else /* VBOX */
1289	s->CTXALLSUFF(pIoApicHlp)->pfnApicBusDeliver(s->CTXSUFF(pDevIns),
1290	dest,
1291	dest_mode,
1292	delivery_mode,
1293	vector,
1294	polarity,
1295	trig_mode);
1296	#endif /* VBOX */
1297	}
1298	}
1299	}
1300	}
1301
1302	#ifdef VBOX
1303	static
1304	#endif
1305	void ioapic_set_irq(void *opaque, int vector, int level)
1306	{
1307	IOAPICState s = (IOAPICState)opaque;
1308
1309	if (vector >= 0 && vector < IOAPIC_NUM_PINS) {
1310	uint32_t mask = 1 << vector;
1311	uint64_t entry = s->ioredtbl[vector];
1312
1313	if ((entry >> 15) & 1) {
1314	/* level triggered */
1315	if (level) {
1316	s->irr \|= mask;
1317	ioapic_service(s);
1318	#ifdef VBOX
1319	if ((level & PDM_IRQ_LEVEL_FLIP_FLOP) == PDM_IRQ_LEVEL_FLIP_FLOP) {
1320	s->irr &= ~mask;
1321	}
1322	#endif
1323	} else {
1324	s->irr &= ~mask;
1325	}
1326	} else {
1327	/* edge triggered */
1328	if (level) {
1329	s->irr \|= mask;
1330	ioapic_service(s);
1331	}
1332	}
1333	}
1334	}
1335
1336	static uint32_t ioapic_mem_readl(void *opaque, target_phys_addr_t addr)
1337	{
1338	IOAPICState s = (IOAPICState)opaque;
1339	int index;
1340	uint32_t val = 0;
1341
1342	addr &= 0xff;
1343	if (addr == 0x00) {
1344	val = s->ioregsel;
1345	} else if (addr == 0x10) {
1346	switch (s->ioregsel) {
1347	case 0x00:
1348	val = s->id << 24;
1349	break;
1350	case 0x01:
1351	val = 0x11 \| ((IOAPIC_NUM_PINS - 1) << 16); /* version 0x11 */
1352	break;
1353	case 0x02:
1354	val = 0;
1355	break;
1356	default:
1357	index = (s->ioregsel - 0x10) >> 1;
1358	if (index >= 0 && index < IOAPIC_NUM_PINS) {
1359	if (s->ioregsel & 1)
1360	val = s->ioredtbl[index] >> 32;
1361	else
1362	val = s->ioredtbl[index] & 0xffffffff;
1363	}
1364	}
1365	#ifdef DEBUG_IOAPIC
1366	Log(("I/O APIC read: %08x = %08x\n", s->ioregsel, val));
1367	#endif
1368	}
1369	return val;
1370	}
1371
1372	static void ioapic_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
1373	{
1374	IOAPICState s = (IOAPICState)opaque;
1375	int index;
1376
1377	addr &= 0xff;
1378	if (addr == 0x00) {
1379	s->ioregsel = val;
1380	return;
1381	} else if (addr == 0x10) {
1382	#ifdef DEBUG_IOAPIC
1383	Log(("I/O APIC write: %08x = %08x\n", s->ioregsel, val));
1384	#endif
1385	switch (s->ioregsel) {
1386	case 0x00:
1387	s->id = (val >> 24) & 0xff;
1388	return;
1389	case 0x01:
1390	case 0x02:
1391	return;
1392	default:
1393	index = (s->ioregsel - 0x10) >> 1;
1394	if (index >= 0 && index < IOAPIC_NUM_PINS) {
1395	if (s->ioregsel & 1) {
1396	s->ioredtbl[index] &= 0xffffffff;
1397	s->ioredtbl[index] \|= (uint64_t)val << 32;
1398	} else {
1399	s->ioredtbl[index] &= ~0xffffffffULL;
1400	s->ioredtbl[index] \|= val;
1401	}
1402	ioapic_service(s);
1403	}
1404	}
1405	}
1406	}
1407
1408	#ifdef IN_RING3
1409
1410	static void ioapic_save(QEMUFile f, void opaque)
1411	{
1412	IOAPICState s = (IOAPICState)opaque;
1413	int i;
1414
1415	qemu_put_8s(f, &s->id);
1416	qemu_put_8s(f, &s->ioregsel);
1417	for (i = 0; i < IOAPIC_NUM_PINS; i++) {
1418	qemu_put_be64s(f, &s->ioredtbl[i]);
1419	}
1420	}
1421
1422	static int ioapic_load(QEMUFile f, void opaque, int version_id)
1423	{
1424	IOAPICState s = (IOAPICState)opaque;
1425	int i;
1426
1427	if (version_id != 1)
1428	return -EINVAL;
1429
1430	qemu_get_8s(f, &s->id);
1431	qemu_get_8s(f, &s->ioregsel);
1432	for (i = 0; i < IOAPIC_NUM_PINS; i++) {
1433	qemu_get_be64s(f, &s->ioredtbl[i]);
1434	}
1435	return 0;
1436	}
1437
1438	static void ioapic_reset(void *opaque)
1439	{
1440	IOAPICState s = (IOAPICState)opaque;
1441	#ifdef VBOX
1442	PPDMDEVINSHC pDevIns = s->pDevInsHC;
1443	PCPDMIOAPICHLPR3 pIoApicHlp = s->pIoApicHlpR3;
1444	#endif
1445	int i;
1446
1447	memset(s, 0, sizeof(*s));
1448	for(i = 0; i < IOAPIC_NUM_PINS; i++)
1449	s->ioredtbl[i] = 1 << 16; /* mask LVT */
1450
1451	#ifdef VBOX
1452	if (pDevIns)
1453	{
1454	s->pDevInsHC = pDevIns;
1455	s->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
1456	}
1457	if (pIoApicHlp)
1458	{
1459	s->pIoApicHlpR3 = pIoApicHlp;
1460	s->pIoApicHlpGC = s->pIoApicHlpR3->pfnGetGCHelpers(pDevIns);
1461	s->pIoApicHlpR0 = s->pIoApicHlpR3->pfnGetR0Helpers(pDevIns);
1462	}
1463	#endif
1464	}
1465
1466	#endif /* IN_RING3 */
1467
1468	#ifndef VBOX
1469	static CPUReadMemoryFunc *ioapic_mem_read[3] = {
1470	ioapic_mem_readl,
1471	ioapic_mem_readl,
1472	ioapic_mem_readl,
1473	};
1474
1475	static CPUWriteMemoryFunc *ioapic_mem_write[3] = {
1476	ioapic_mem_writel,
1477	ioapic_mem_writel,
1478	ioapic_mem_writel,
1479	};
1480
1481	IOAPICState *ioapic_init(void)
1482	{
1483	IOAPICState *s;
1484	int io_memory;
1485
1486	s = qemu_mallocz(sizeof(IOAPICState));
1487	if (!s)
1488	return NULL;
1489	ioapic_reset(s);
1490	s->id = last_apic_id++;
1491
1492	io_memory = cpu_register_io_memory(0, ioapic_mem_read,
1493	ioapic_mem_write, s);
1494	cpu_register_physical_memory(0xfec00000, 0x1000, io_memory);
1495
1496	register_savevm("ioapic", 0, 1, ioapic_save, ioapic_load, s);
1497	qemu_register_reset(ioapic_reset, s);
1498
1499	return s;
1500	}
1501	#endif /* !VBOX */
1502
1503	/* LAPIC */
1504
1505	/* LAPICs MMIO is wrong, in SMP there is no relation between memory range and
1506	lapic, it's only the CPU that executes this memory access is what matters */
1507
1508	PDMBOTHCBDECL(int) apicMMIORead(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb)
1509	{
1510	APICState s = PDMINS2DATA(pDevIns, APICState );
1511
1512	STAM_COUNTER_INC(&CTXSUFF(s->StatMMIORead));
1513	switch (cb)
1514	{
1515	case 1:
1516	(uint8_t )pv = 0;
1517	break;
1518
1519	case 2:
1520	(uint16_t )pv = 0;
1521	break;
1522
1523	case 4:
1524	{
1525	#if 0 /** @note experimental */
1526	#ifndef IN_RING3
1527	uint32_t index = (GCPhysAddr >> 4) & 0xff;
1528
1529	if ( index == 0x08 /* TPR */
1530	&& ++s->ulTPRPatchAttempts < APIC_MAX_PATCH_ATTEMPTS)
1531	{
1532	#ifdef IN_GC
1533	pDevIns->pDevHlpGC->pfnPATMSetMMIOPatchInfo(pDevIns, GCPhysAddr, &s->tpr);
1534	#else
1535	RTGCPTR pDevInsGC = PDMINS2DATA_GCPTR(pDevIns);
1536	pDevIns->pDevHlpR0->pfnPATMSetMMIOPatchInfo(pDevIns, GCPhysAddr, pDevIns + RT_OFFSETOF(APICState, tpr));
1537	#endif
1538	return VINF_PATM_HC_MMIO_PATCH_READ;
1539	}
1540	#endif
1541	#endif /* experimental */
1542	APIC_LOCK(s, VINF_IOM_HC_MMIO_READ);
1543	(uint32_t )pv = apic_mem_readl(s, GCPhysAddr);
1544	APIC_UNLOCK(s);
1545	break;
1546	}
1547	default:
1548	AssertReleaseMsgFailed(("cb=%d\n", cb)); /* for now we assume simple accesses. */
1549	return VERR_INTERNAL_ERROR;
1550	}
1551	return VINF_SUCCESS;
1552	}
1553
1554	PDMBOTHCBDECL(int) apicMMIOWrite(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb)
1555	{
1556	APICState s = PDMINS2DATA(pDevIns, APICState );
1557
1558	STAM_COUNTER_INC(&CTXSUFF(s->StatMMIOWrite));
1559	switch (cb)
1560	{
1561	case 1:
1562	case 2:
1563	/* ignore */
1564	break;
1565
1566	case 4:
1567	{
1568	int rc;
1569	APIC_LOCK(s, VINF_IOM_HC_MMIO_WRITE);
1570	rc = apic_mem_writel(s, GCPhysAddr, (uint32_t )pv);
1571	APIC_UNLOCK(s);
1572	return rc;
1573	}
1574
1575	default:
1576	AssertReleaseMsgFailed(("cb=%d\n", cb)); /* for now we assume simple accesses. */
1577	return VERR_INTERNAL_ERROR;
1578	}
1579	return VINF_SUCCESS;
1580	}
1581
1582	#ifdef IN_RING3
1583
1584	/**
1585	* @copydoc FNSSMDEVSAVEEXEC
1586	*/
1587	static DECLCALLBACK(int) apicSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
1588	{
1589	APICState s = PDMINS2DATA(pDevIns, APICState );
1590	apic_save(pSSMHandle, s);
1591	return TMR3TimerSave(s->CTXSUFF(pTimer), pSSMHandle);
1592	}
1593
1594	/**
1595	* @copydoc FNSSMDEVLOADEXEC
1596	*/
1597	static DECLCALLBACK(int) apicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t u32Version)
1598	{
1599	APICState s = PDMINS2DATA(pDevIns, APICState );
1600	if (apic_load(pSSMHandle, s, u32Version)) {
1601	AssertFailed();
1602	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
1603	}
1604	return TMR3TimerLoad(s->CTXSUFF(pTimer), pSSMHandle);
1605	}
1606
1607	/**
1608	* @copydoc FNPDMDEVRESET
1609	*/
1610	static DECLCALLBACK(void) apicReset(PPDMDEVINS pDevIns)
1611	{
1612	APICState s = PDMINS2DATA(pDevIns, APICState );
1613	#ifdef VBOX_WITH_PDM_LOCK
1614	s->pApicHlpR3->pfnLock(pDevIns, VERR_INTERNAL_ERROR);
1615	#endif
1616	apic_reset(s);
1617	/* Clear any pending APIC interrupt action flag. */
1618	s->pApicHlpR3->pfnClearInterruptFF(pDevIns);
1619	APIC_UNLOCK(s);
1620	}
1621
1622	/**
1623	* @copydoc FNPDMDEVRELOCATE
1624	*/
1625	static DECLCALLBACK(void) apicRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
1626	{
1627	APICState pData = PDMINS2DATA(pDevIns, APICState );
1628	pData->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
1629	pData->pApicHlpGC = pData->pApicHlpR3->pfnGetGCHelpers(pDevIns);
1630	pData->pTimerGC = TMTimerGCPtr(pData->CTXSUFF(pTimer));
1631	}
1632
1633	/**
1634	* @copydoc FNPDMDEVCONSTRUCT
1635	*/
1636	static DECLCALLBACK(int) apicConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
1637	{
1638	APICState pData = PDMINS2DATA(pDevIns, APICState );
1639	PDMAPICREG ApicReg;
1640	int rc;
1641	int i;
1642	bool fIOAPIC;
1643	bool fGCEnabled;
1644	bool fR0Enabled;
1645	Assert(iInstance == 0);
1646
1647	/*
1648	* Validate configuration.
1649	*/
1650	if (!CFGMR3AreValuesValid(pCfgHandle, "IOAPIC\0GCEnabled\0R0Enabled\0"))
1651	return VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
1652
1653	rc = CFGMR3QueryBool (pCfgHandle, "IOAPIC", &fIOAPIC);
1654	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1655	fIOAPIC = true;
1656	else if (VBOX_FAILURE (rc))
1657	return PDMDEV_SET_ERROR(pDevIns, rc,
1658	N_("Configuration error: Failed to read \"IOAPIC\"."));
1659
1660	rc = CFGMR3QueryBool(pCfgHandle, "GCEnabled", &fGCEnabled);
1661	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1662	fGCEnabled = true;
1663	else
1664	return PDMDEV_SET_ERROR(pDevIns, rc,
1665	N_("Configuration error: Failed to query boolean value \"GCEnabled\""));
1666	Log(("APIC: fGCEnabled=%d\n", fGCEnabled));
1667
1668	rc = CFGMR3QueryBool(pCfgHandle, "R0Enabled", &fR0Enabled);
1669	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1670	fR0Enabled = true;
1671	else
1672	return PDMDEV_SET_ERROR(pDevIns, rc,
1673	N_("Configuration error: Failed to query boolean value \"R0Enabled\""));
1674	Log(("APIC: fR0Enabled=%d\n", fR0Enabled));
1675
1676	/*
1677	* Init the data.
1678	*/
1679	pData->pDevInsHC = pDevIns;
1680	pData->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
1681	pData->apicbase = 0xfee00000 \| MSR_IA32_APICBASE_BSP \| MSR_IA32_APICBASE_ENABLE;
1682	for (i = 0; i < APIC_LVT_NB; i++)
1683	pData->lvt[i] = 1 << 16; /* mask LVT */
1684	pData->spurious_vec = 0xff;
1685
1686	/*
1687	* Register the APIC.
1688	*/
1689	ApicReg.u32Version = PDM_APICREG_VERSION;
1690	ApicReg.pfnGetInterruptHC = apicGetInterrupt;
1691	ApicReg.pfnSetBaseHC = apicSetBase;
1692	ApicReg.pfnGetBaseHC = apicGetBase;
1693	ApicReg.pfnSetTPRHC = apicSetTPR;
1694	ApicReg.pfnGetTPRHC = apicGetTPR;
1695	ApicReg.pfnBusDeliverHC = apicBusDeliverCallback;
1696	if (fGCEnabled) {
1697	ApicReg.pszGetInterruptGC = "apicGetInterrupt";
1698	ApicReg.pszSetBaseGC = "apicSetBase";
1699	ApicReg.pszGetBaseGC = "apicGetBase";
1700	ApicReg.pszSetTPRGC = "apicSetTPR";
1701	ApicReg.pszGetTPRGC = "apicGetTPR";
1702	ApicReg.pszBusDeliverGC = "apicBusDeliverCallback";
1703	} else {
1704	ApicReg.pszGetInterruptGC = NULL;
1705	ApicReg.pszSetBaseGC = NULL;
1706	ApicReg.pszGetBaseGC = NULL;
1707	ApicReg.pszSetTPRGC = NULL;
1708	ApicReg.pszGetTPRGC = NULL;
1709	ApicReg.pszBusDeliverGC = NULL;
1710	}
1711	if (fR0Enabled) {
1712	ApicReg.pszGetInterruptR0 = "apicGetInterrupt";
1713	ApicReg.pszSetBaseR0 = "apicSetBase";
1714	ApicReg.pszGetBaseR0 = "apicGetBase";
1715	ApicReg.pszSetTPRR0 = "apicSetTPR";
1716	ApicReg.pszGetTPRR0 = "apicGetTPR";
1717	ApicReg.pszBusDeliverR0 = "apicBusDeliverCallback";
1718	} else {
1719	ApicReg.pszGetInterruptR0 = NULL;
1720	ApicReg.pszSetBaseR0 = NULL;
1721	ApicReg.pszGetBaseR0 = NULL;
1722	ApicReg.pszSetTPRR0 = NULL;
1723	ApicReg.pszGetTPRR0 = NULL;
1724	ApicReg.pszBusDeliverR0 = NULL;
1725	}
1726
1727	Assert(pDevIns->pDevHlp->pfnAPICRegister);
1728	rc = pDevIns->pDevHlp->pfnAPICRegister(pDevIns, &ApicReg, &pData->pApicHlpR3);
1729	if (VBOX_FAILURE(rc))
1730	{
1731	AssertMsgFailed(("APICRegister -> %Vrc\n", rc));
1732	return rc;
1733	}
1734	pData->pApicHlpGC = pData->pApicHlpR3->pfnGetGCHelpers(pDevIns);
1735
1736	/*
1737	* The the CPUID feature bit.
1738	*/
1739	uint32_t u32Eax, u32Ebx, u32Ecx, u32Edx;
1740	PDMDevHlpGetCpuId(pDevIns, 0, &u32Eax, &u32Ebx, &u32Ecx, &u32Edx);
1741	if (u32Eax >= 1)
1742	{
1743	if ( fIOAPIC /* If IOAPIC is enabled, enable Local APIC in any case */
1744	\|\| u32Ebx == 0x756e6547 && u32Ecx == 0x6c65746e && u32Edx == 0x49656e69 /* GenuineIntel */
1745	\|\| u32Ebx == 0x68747541 && u32Ecx == 0x69746e65 && u32Edx == 0x444d4163 /* AuthenticAMD */)
1746	pData->pApicHlpR3->pfnChangeFeature(pDevIns, true);
1747	}
1748
1749	/*
1750	* Register the MMIO range.
1751	*/
1752	rc = PDMDevHlpMMIORegister(pDevIns, pData->apicbase & ~0xfff, 0x1000, pData,
1753	apicMMIOWrite, apicMMIORead, NULL, "APIC Memory");
1754	if (VBOX_FAILURE(rc))
1755	return rc;
1756
1757	if (fGCEnabled) {
1758	rc = PDMDevHlpMMIORegisterGC(pDevIns, pData->apicbase & ~0xfff, 0x1000, 0,
1759	"apicMMIOWrite", "apicMMIORead", NULL, "APIC Memory");
1760	if (VBOX_FAILURE(rc))
1761	return rc;
1762	}
1763
1764	if (fR0Enabled) {
1765	pData->pApicHlpR0 = pData->pApicHlpR3->pfnGetR0Helpers(pDevIns);
1766
1767	rc = PDMDevHlpMMIORegisterR0(pDevIns, pData->apicbase & ~0xfff, 0x1000, 0,
1768	"apicMMIOWrite", "apicMMIORead", NULL, "APIC Memory");
1769	if (VBOX_FAILURE(rc))
1770	return rc;
1771	}
1772
1773	/*
1774	* Create the APIC timer.
1775	*/
1776	rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, apicTimer,
1777	"APIC Timer", &pData->CTXSUFF(pTimer));
1778	if (VBOX_FAILURE(rc))
1779	return rc;
1780	pData->pTimerGC = TMTimerGCPtr(pData->CTXSUFF(pTimer));
1781
1782	/*
1783	* Saved state.
1784	*/
1785	rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance, 1 /* version */,
1786	sizeof(*pData), NULL, apicSaveExec, NULL, NULL, apicLoadExec, NULL);
1787	if (VBOX_FAILURE(rc))
1788	return rc;
1789
1790	#ifdef VBOX_WITH_STATISTICS
1791	/*
1792	* Statistics.
1793	*/
1794	PDMDevHlpSTAMRegister(pDevIns, &pData->StatMMIOReadGC, STAMTYPE_COUNTER, "/PDM/APIC/MMIOReadGC", STAMUNIT_OCCURENCES, "Number of APIC MMIO reads in GC.");
1795	PDMDevHlpSTAMRegister(pDevIns, &pData->StatMMIOReadHC, STAMTYPE_COUNTER, "/PDM/APIC/MMIOReadHC", STAMUNIT_OCCURENCES, "Number of APIC MMIO reads in HC.");
1796	PDMDevHlpSTAMRegister(pDevIns, &pData->StatMMIOWriteGC, STAMTYPE_COUNTER, "/PDM/APIC/MMIOWriteGC", STAMUNIT_OCCURENCES, "Number of APIC MMIO writes in GC.");
1797	PDMDevHlpSTAMRegister(pDevIns, &pData->StatMMIOWriteHC, STAMTYPE_COUNTER, "/PDM/APIC/MMIOWriteHC", STAMUNIT_OCCURENCES, "Number of APIC MMIO writes in HC.");
1798	PDMDevHlpSTAMRegister(pDevIns, &pData->StatClearedActiveIrq, STAMTYPE_COUNTER, "/PDM/APIC/Masked/ActiveIRQ", STAMUNIT_OCCURENCES, "Number of cleared irqs.");
1799	#endif
1800
1801	return VINF_SUCCESS;
1802	}
1803
1804
1805	/**
1806	* APIC device registration structure.
1807	*/
1808	const PDMDEVREG g_DeviceAPIC =
1809	{
1810	/* u32Version */
1811	PDM_DEVREG_VERSION,
1812	/* szDeviceName */
1813	"apic",
1814	/* szGCMod */
1815	"VBoxDD2GC.gc",
1816	/* szR0Mod */
1817	"VBoxDD2R0.r0",
1818	/* pszDescription */
1819	"Advanced Programmable Interrupt Controller (APIC) Device",
1820	/* fFlags */
1821	PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_GUEST_BITS_32_64 \| PDM_DEVREG_FLAGS_PAE36 \| PDM_DEVREG_FLAGS_GC \| PDM_DEVREG_FLAGS_R0,
1822	/* fClass */
1823	PDM_DEVREG_CLASS_PIC,
1824	/* cMaxInstances */
1825	1,
1826	/* cbInstance */
1827	sizeof(APICState),
1828	/* pfnConstruct */
1829	apicConstruct,
1830	/* pfnDestruct */
1831	NULL,
1832	/* pfnRelocate */
1833	apicRelocate,
1834	/* pfnIOCtl */
1835	NULL,
1836	/* pfnPowerOn */
1837	NULL,
1838	/* pfnReset */
1839	apicReset,
1840	/* pfnSuspend */
1841	NULL,
1842	/* pfnResume */
1843	NULL,
1844	/* pfnAttach */
1845	NULL,
1846	/* pfnDetach */
1847	NULL,
1848	/* pfnQueryInterface. */
1849	NULL
1850	};
1851
1852	#endif /* IN_RING3 */
1853
1854
1855
1856
1857	/* IOAPIC */
1858
1859	PDMBOTHCBDECL(int) ioapicMMIORead(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb)
1860	{
1861	IOAPICState s = PDMINS2DATA(pDevIns, IOAPICState );
1862	IOAPIC_LOCK(s, VINF_IOM_HC_MMIO_READ);
1863
1864	STAM_COUNTER_INC(&CTXSUFF(s->StatMMIORead));
1865	switch (cb)
1866	{
1867	case 1:
1868	(uint8_t )pv = ioapic_mem_readl(s, GCPhysAddr);
1869	break;
1870
1871	case 2:
1872	(uint16_t )pv = ioapic_mem_readl(s, GCPhysAddr);
1873	break;
1874
1875	case 4:
1876	(uint32_t )pv = ioapic_mem_readl(s, GCPhysAddr);
1877	break;
1878
1879	default:
1880	AssertReleaseMsgFailed(("cb=%d\n", cb)); /* for now we assume simple accesses. */
1881	IOAPIC_UNLOCK(s);
1882	return VERR_INTERNAL_ERROR;
1883	}
1884	IOAPIC_UNLOCK(s);
1885	return VINF_SUCCESS;
1886	}
1887
1888	PDMBOTHCBDECL(int) ioapicMMIOWrite(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb)
1889	{
1890	IOAPICState s = PDMINS2DATA(pDevIns, IOAPICState );
1891
1892	STAM_COUNTER_INC(&CTXSUFF(s->StatMMIOWrite));
1893	switch (cb)
1894	{
1895	case 1:
1896	case 2:
1897	case 4:
1898	IOAPIC_LOCK(s, VINF_IOM_HC_MMIO_WRITE);
1899	ioapic_mem_writel(s, GCPhysAddr, (uint32_t )pv);
1900	IOAPIC_UNLOCK(s);
1901	break;
1902
1903	default:
1904	AssertReleaseMsgFailed(("cb=%d\n", cb)); /* for now we assume simple accesses. */
1905	return VERR_INTERNAL_ERROR;
1906	}
1907	return VINF_SUCCESS;
1908	}
1909
1910	PDMBOTHCBDECL(void) ioapicSetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel)
1911	{
1912	IOAPICState pThis = PDMINS2DATA(pDevIns, IOAPICState );
1913	STAM_COUNTER_INC(&pThis->CTXSUFF(StatSetIrq));
1914	LogFlow(("ioapicSetIrq: iIrq=%d iLevel=%d\n", iIrq, iLevel));
1915	ioapic_set_irq(pThis, iIrq, iLevel);
1916	}
1917
1918
1919	#ifdef IN_RING3
1920
1921	/**
1922	* @copydoc FNSSMDEVSAVEEXEC
1923	*/
1924	static DECLCALLBACK(int) ioapicSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle)
1925	{
1926	IOAPICState s = PDMINS2DATA(pDevIns, IOAPICState );
1927	ioapic_save(pSSMHandle, s);
1928	return VINF_SUCCESS;
1929	}
1930
1931	/**
1932	* @copydoc FNSSMDEVLOADEXEC
1933	*/
1934	static DECLCALLBACK(int) ioapicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSMHandle, uint32_t u32Version)
1935	{
1936	IOAPICState s = PDMINS2DATA(pDevIns, IOAPICState );
1937
1938	if (ioapic_load(pSSMHandle, s, u32Version)) {
1939	AssertFailed();
1940	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
1941	}
1942
1943	return VINF_SUCCESS;
1944	}
1945
1946	/**
1947	* @copydoc FNPDMDEVRESET
1948	*/
1949	static DECLCALLBACK(void) ioapicReset(PPDMDEVINS pDevIns)
1950	{
1951	IOAPICState s = PDMINS2DATA(pDevIns, IOAPICState );
1952	#ifdef VBOX_WITH_PDM_LOCK
1953	s->pIoApicHlpR3->pfnLock(pDevIns, VERR_INTERNAL_ERROR);
1954	#endif
1955	ioapic_reset(s);
1956	IOAPIC_UNLOCK(s);
1957	}
1958
1959	/**
1960	* @copydoc FNPDMDEVRELOCATE
1961	*/
1962	static DECLCALLBACK(void) ioapicRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
1963	{
1964	IOAPICState s = PDMINS2DATA(pDevIns, IOAPICState );
1965	s->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
1966	s->pIoApicHlpGC = s->pIoApicHlpR3->pfnGetGCHelpers(pDevIns);
1967	}
1968
1969	/**
1970	* @copydoc FNPDMDEVCONSTRUCT
1971	*/
1972	static DECLCALLBACK(int) ioapicConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfgHandle)
1973	{
1974	IOAPICState s = PDMINS2DATA(pDevIns, IOAPICState );
1975	PDMIOAPICREG IoApicReg;
1976	bool fGCEnabled;
1977	bool fR0Enabled;
1978	int rc;
1979
1980	Assert(iInstance == 0);
1981
1982	/*
1983	* Validate and read the configuration.
1984	*/
1985	if (!CFGMR3AreValuesValid(pCfgHandle, "GCEnabled\0R0Enabled\0"))
1986	return VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
1987
1988	rc = CFGMR3QueryBool(pCfgHandle, "GCEnabled", &fGCEnabled);
1989	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1990	fGCEnabled = true;
1991	else if (VBOX_FAILURE(rc))
1992	return PDMDEV_SET_ERROR(pDevIns, rc,
1993	N_("Configuration error: Failed to query boolean value \"GCEnabled\"!"));
1994	Log(("IOAPIC: fGCEnabled=%d\n", fGCEnabled));
1995
1996	rc = CFGMR3QueryBool(pCfgHandle, "R0Enabled", &fR0Enabled);
1997	if (rc == VERR_CFGM_VALUE_NOT_FOUND)
1998	fR0Enabled = true;
1999	else if (VBOX_FAILURE(rc))
2000	return PDMDEV_SET_ERROR(pDevIns, rc,
2001	N_("Configuration error: Failed to query boolean value \"R0Enabled\"!"));
2002	Log(("IOAPIC: fR0Enabled=%d\n", fR0Enabled));
2003
2004	/*
2005	* Initialize the state data.
2006	*/
2007	s->pDevInsHC = pDevIns;
2008	s->pDevInsGC = PDMDEVINS_2_GCPTR(pDevIns);
2009	ioapic_reset(s);
2010	s->id = 0;
2011
2012	/*
2013	* Register the IOAPIC and get helpers.
2014	*/
2015	IoApicReg.u32Version = PDM_IOAPICREG_VERSION;
2016	IoApicReg.pfnSetIrqHC = ioapicSetIrq;
2017	IoApicReg.pszSetIrqGC = fGCEnabled ? "ioapicSetIrq" : NULL;
2018	IoApicReg.pszSetIrqR0 = fR0Enabled ? "ioapicSetIrq" : NULL;
2019	rc = pDevIns->pDevHlp->pfnIOAPICRegister(pDevIns, &IoApicReg, &s->pIoApicHlpR3);
2020	if (VBOX_FAILURE(rc))
2021	{
2022	AssertMsgFailed(("IOAPICRegister -> %Vrc\n", rc));
2023	return rc;
2024	}
2025	s->pIoApicHlpGC = s->pIoApicHlpR3->pfnGetGCHelpers(pDevIns);
2026
2027	/*
2028	* Register MMIO callbacks and saved state.
2029	*/
2030	rc = PDMDevHlpMMIORegister(pDevIns, 0xfec00000, 0x1000, s,
2031	ioapicMMIOWrite, ioapicMMIORead, NULL, "I/O APIC Memory");
2032	if (VBOX_FAILURE(rc))
2033	return rc;
2034
2035	if (fGCEnabled) {
2036	rc = PDMDevHlpMMIORegisterGC(pDevIns, 0xfec00000, 0x1000, 0,
2037	"ioapicMMIOWrite", "ioapicMMIORead", NULL, "I/O APIC Memory");
2038	if (VBOX_FAILURE(rc))
2039	return rc;
2040	}
2041
2042	if (fR0Enabled) {
2043	s->pIoApicHlpR0 = s->pIoApicHlpR3->pfnGetR0Helpers(pDevIns);
2044
2045	rc = PDMDevHlpMMIORegisterR0(pDevIns, 0xfec00000, 0x1000, 0,
2046	"ioapicMMIOWrite", "ioapicMMIORead", NULL, "I/O APIC Memory");
2047	if (VBOX_FAILURE(rc))
2048	return rc;
2049	}
2050
2051	rc = PDMDevHlpSSMRegister(pDevIns, pDevIns->pDevReg->szDeviceName, iInstance, 1 /* version */,
2052	sizeof(*s), NULL, ioapicSaveExec, NULL, NULL, ioapicLoadExec, NULL);
2053	if (VBOX_FAILURE(rc))
2054	return rc;
2055
2056	#ifdef VBOX_WITH_STATISTICS
2057	/*
2058	* Statistics.
2059	*/
2060	PDMDevHlpSTAMRegister(pDevIns, &s->StatMMIOReadGC, STAMTYPE_COUNTER, "/PDM/IOAPIC/MMIOReadGC", STAMUNIT_OCCURENCES, "Number of IOAPIC MMIO reads in GC.");
2061	PDMDevHlpSTAMRegister(pDevIns, &s->StatMMIOReadHC, STAMTYPE_COUNTER, "/PDM/IOAPIC/MMIOReadHC", STAMUNIT_OCCURENCES, "Number of IOAPIC MMIO reads in HC.");
2062	PDMDevHlpSTAMRegister(pDevIns, &s->StatMMIOWriteGC, STAMTYPE_COUNTER, "/PDM/IOAPIC/MMIOWriteGC", STAMUNIT_OCCURENCES, "Number of IOAPIC MMIO writes in GC.");
2063	PDMDevHlpSTAMRegister(pDevIns, &s->StatMMIOWriteHC, STAMTYPE_COUNTER, "/PDM/IOAPIC/MMIOWriteHC", STAMUNIT_OCCURENCES, "Number of IOAPIC MMIO writes in HC.");
2064	PDMDevHlpSTAMRegister(pDevIns, &s->StatSetIrqGC, STAMTYPE_COUNTER, "/PDM/IOAPIC/SetIrqGC", STAMUNIT_OCCURENCES, "Number of IOAPIC SetIrq calls in GC.");
2065	PDMDevHlpSTAMRegister(pDevIns, &s->StatSetIrqHC, STAMTYPE_COUNTER, "/PDM/IOAPIC/SetIrqHC", STAMUNIT_OCCURENCES, "Number of IOAPIC SetIrq calls in HC.");
2066	#endif
2067
2068	return VINF_SUCCESS;
2069	}
2070
2071	/**
2072	* IO APIC device registration structure.
2073	*/
2074	const PDMDEVREG g_DeviceIOAPIC =
2075	{
2076	/* u32Version */
2077	PDM_DEVREG_VERSION,
2078	/* szDeviceName */
2079	"ioapic",
2080	/* szGCMod */
2081	"VBoxDD2GC.gc",
2082	/* szR0Mod */
2083	"VBoxDD2R0.r0",
2084	/* pszDescription */
2085	"I/O Advanced Programmable Interrupt Controller (IO-APIC) Device",
2086	/* fFlags */
2087	PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_GUEST_BITS_32_64 \| PDM_DEVREG_FLAGS_PAE36 \| PDM_DEVREG_FLAGS_GC \| PDM_DEVREG_FLAGS_R0,
2088	/* fClass */
2089	PDM_DEVREG_CLASS_PIC,
2090	/* cMaxInstances */
2091	1,
2092	/* cbInstance */
2093	sizeof(IOAPICState),
2094	/* pfnConstruct */
2095	ioapicConstruct,
2096	/* pfnDestruct */
2097	NULL,
2098	/* pfnRelocate */
2099	ioapicRelocate,
2100	/* pfnIOCtl */
2101	NULL,
2102	/* pfnPowerOn */
2103	NULL,
2104	/* pfnReset */
2105	ioapicReset,
2106	/* pfnSuspend */
2107	NULL,
2108	/* pfnResume */
2109	NULL,
2110	/* pfnAttach */
2111	NULL,
2112	/* pfnDetach */
2113	NULL,
2114	/* pfnQueryInterface. */
2115	NULL,
2116	/* pfnInitComplete */
2117	NULL,
2118	/* pfnPowerOff */
2119	NULL
2120	};
2121
2122	#endif /* IN_RING3 */
2123	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
2124

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/PC/DevAPIC.cpp@ 3670

Download in other formats: