DevIoApic.cpp@ 47928

Last change on this file since 47928 was 45025, checked in by vboxsync, 12 years ago
Update PDMDEVREG initialization comment so they refer to pfnMemSetup instead of pfnIOCtl.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 34.7 KB

Line
1	/* $Id: DevIoApic.cpp 45025 2013-03-13 16:45:15Z vboxsync $ */
2	/** @file
3	* I/O Advanced Programmable Interrupt Controller (IO-APIC) Device.
4	*/
5
6	/*
7	* Copyright (C) 2006-2013 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	* --------------------------------------------------------------------
17	*
18	* This code is based on:
19	*
20	* apic.c revision 1.5 @@OSETODO
21	*
22	* APIC support
23	*
24	* Copyright (c) 2004-2005 Fabrice Bellard
25	*
26	* This library is free software; you can redistribute it and/or
27	* modify it under the terms of the GNU Lesser General Public
28	* License as published by the Free Software Foundation; either
29	* version 2 of the License, or (at your option) any later version.
30	*
31	* This library is distributed in the hope that it will be useful,
32	* but WITHOUT ANY WARRANTY; without even the implied warranty of
33	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
34	* Lesser General Public License for more details.
35	*
36	* You should have received a copy of the GNU Lesser General Public
37	* License along with this library; if not, write to the Free Software
38	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
39	*/
40
41	/*******************************************************************************
42	* Header Files *
43	*******************************************************************************/
44	#define LOG_GROUP LOG_GROUP_DEV_APIC
45	#include <VBox/vmm/pdmdev.h>
46
47	#include <VBox/log.h>
48	#include <VBox/vmm/stam.h>
49	#include <iprt/assert.h>
50	#include <iprt/asm.h>
51
52	#include <VBox/msi.h>
53
54	#include "VBoxDD2.h"
55	#include "DevApic.h"
56
57
58	/*******************************************************************************
59	* Defined Constants And Macros *
60	*******************************************************************************/
61	/** @def IOAPIC_LOCK
62	* Acquires the PDM lock. */
63	#define IOAPIC_LOCK(pThis, rc) \
64	do { \
65	int rc2 = (pThis)->CTX_SUFF(pIoApicHlp)->pfnLock((pThis)->CTX_SUFF(pDevIns), rc); \
66	if (rc2 != VINF_SUCCESS) \
67	return rc2; \
68	} while (0)
69
70	/** @def IOAPIC_UNLOCK
71	* Releases the PDM lock. */
72	#define IOAPIC_UNLOCK(pThis) (pThis)->CTX_SUFF(pIoApicHlp)->pfnUnlock((pThis)->CTX_SUFF(pDevIns))
73
74	#define DEBUG_IOAPIC
75	#define IOAPIC_NUM_PINS 0x18
76
77
78	/*******************************************************************************
79	* Structures and Typedefs *
80	*******************************************************************************/
81	typedef struct IOAPIC
82	{
83	uint8_t id;
84	uint8_t ioregsel;
85	uint8_t cCpus;
86
87	uint32_t irr;
88	uint64_t ioredtbl[IOAPIC_NUM_PINS];
89	/** The IRQ tags and source IDs for each pin (tracing purposes). */
90	uint32_t auTagSrc[IOAPIC_NUM_PINS];
91
92	/** The device instance - R3 Ptr. */
93	PPDMDEVINSR3 pDevInsR3;
94	/** The IOAPIC helpers - R3 Ptr. */
95	PCPDMIOAPICHLPR3 pIoApicHlpR3;
96
97	/** The device instance - R0 Ptr. */
98	PPDMDEVINSR0 pDevInsR0;
99	/** The IOAPIC helpers - R0 Ptr. */
100	PCPDMIOAPICHLPR0 pIoApicHlpR0;
101
102	/** The device instance - RC Ptr. */
103	PPDMDEVINSRC pDevInsRC;
104	/** The IOAPIC helpers - RC Ptr. */
105	PCPDMIOAPICHLPRC pIoApicHlpRC;
106
107	# ifdef VBOX_WITH_STATISTICS
108	STAMCOUNTER StatMMIOReadGC;
109	STAMCOUNTER StatMMIOReadHC;
110	STAMCOUNTER StatMMIOWriteGC;
111	STAMCOUNTER StatMMIOWriteHC;
112	STAMCOUNTER StatSetIrqGC;
113	STAMCOUNTER StatSetIrqHC;
114	# endif
115	} IOAPIC;
116	typedef IOAPIC *PIOAPIC;
117
118	#ifndef VBOX_DEVICE_STRUCT_TESTCASE
119
120	/*******************************************************************************
121	* Internal Functions *
122	*******************************************************************************/
123
124
125	static void ioapic_service(PIOAPIC pThis)
126	{
127	uint8_t i;
128	uint8_t trig_mode;
129	uint8_t vector;
130	uint8_t delivery_mode;
131	uint32_t mask;
132	uint64_t entry;
133	uint8_t dest;
134	uint8_t dest_mode;
135	uint8_t polarity;
136
137	for (i = 0; i < IOAPIC_NUM_PINS; i++)
138	{
139	mask = 1 << i;
140	if (pThis->irr & mask)
141	{
142	entry = pThis->ioredtbl[i];
143	if (!(entry & APIC_LVT_MASKED))
144	{
145	trig_mode = ((entry >> 15) & 1);
146	dest = entry >> 56;
147	dest_mode = (entry >> 11) & 1;
148	delivery_mode = (entry >> 8) & 7;
149	polarity = (entry >> 13) & 1;
150	uint32_t uTagSrc = pThis->auTagSrc[i];
151	if (trig_mode == APIC_TRIGGER_EDGE)
152	{
153	pThis->auTagSrc[i] = 0;
154	pThis->irr &= ~mask;
155	}
156	if (delivery_mode == APIC_DM_EXTINT)
157	/* malc: i'm still not so sure about ExtINT delivery */
158	{
159	AssertMsgFailed(("Delivery mode ExtINT"));
160	vector = 0xff; /* incorrect but shuts up gcc. */
161	}
162	else
163	vector = entry & 0xff;
164
165	int rc = pThis->CTX_SUFF(pIoApicHlp)->pfnApicBusDeliver(pThis->CTX_SUFF(pDevIns),
166	dest,
167	dest_mode,
168	delivery_mode,
169	vector,
170	polarity,
171	trig_mode,
172	uTagSrc);
173	/* We must be sure that attempts to reschedule in R3
174	never get here */
175	Assert(rc == VINF_SUCCESS);
176	}
177	}
178	}
179	}
180
181
182	static void ioapic_set_irq(PIOAPIC pThis, int vector, int level, uint32_t uTagSrc)
183	{
184	if (vector >= 0 && vector < IOAPIC_NUM_PINS)
185	{
186	uint32_t mask = 1 << vector;
187	uint64_t entry = pThis->ioredtbl[vector];
188
189	if ((entry >> 15) & 1)
190	{
191	/* level triggered */
192	if (level)
193	{
194	pThis->irr \|= mask;
195	if (!pThis->auTagSrc[vector])
196	pThis->auTagSrc[vector] = uTagSrc;
197	else
198	pThis->auTagSrc[vector] = RT_BIT_32(31);
199
200	ioapic_service(pThis);
201
202	if ((level & PDM_IRQ_LEVEL_FLIP_FLOP) == PDM_IRQ_LEVEL_FLIP_FLOP)
203	{
204	pThis->irr &= ~mask;
205	pThis->auTagSrc[vector] = 0;
206	}
207	}
208	else
209	{
210	pThis->irr &= ~mask;
211	pThis->auTagSrc[vector] = 0;
212	}
213	}
214	else
215	{
216	/* edge triggered */
217	if (level)
218	{
219	pThis->irr \|= mask;
220	if (!pThis->auTagSrc[vector])
221	pThis->auTagSrc[vector] = uTagSrc;
222	else
223	pThis->auTagSrc[vector] = RT_BIT_32(31);
224
225	ioapic_service(pThis);
226	}
227	}
228	}
229	}
230
231
232	/**
233	* Handles a read from the IOAPICID register.
234	*/
235	static int ioapic_IoApicId_r(PIOAPIC pThis, uint32_t *pu32Value)
236	{
237	*pu32Value = (uint32_t)pThis->id << 24;
238	return VINF_SUCCESS;
239	}
240
241
242	/**
243	* Handles a write to the IOAPICID register.
244	*/
245	static int ioapic_IoApicId_w(PIOAPIC pThis, uint32_t u32Value)
246	{
247	/* Note! Compared to the 82093AA spec, we've extended the IOAPIC
248	identification from bits 27:24 to bits 31:24. */
249	Log(("ioapic: IOAPICID %#x -> %#x\n", pThis->id, u32Value >> 24));
250	pThis->id = u32Value >> 24;
251	return VINF_SUCCESS;
252	}
253
254
255	/**
256	* Handles a read from the IOAPICVER register.
257	*/
258	static int ioapic_IoApicVer_r(PIOAPIC pThis, uint32_t *pu32Value)
259	{
260	pu32Value = RT_MAKE_U32(0x11, IOAPIC_NUM_PINS - 1); / (0x11 is the version.) */
261	return VINF_SUCCESS;
262	}
263
264
265	/**
266	* Handles a read from the IOAPICARB register.
267	*/
268	static int ioapic_IoApicArb_r(PIOAPIC pThis, uint32_t *pu32Value)
269	{
270	pu32Value = 0; / (arbitration winner) */
271	return VINF_SUCCESS;
272	}
273
274
275	/**
276	* Handles a read from the IOREGSEL register.
277	*/
278	static int ioapic_IoRegSel_r(PIOAPIC pThis, uint32_t *pu32Value)
279	{
280	*pu32Value = pThis->ioregsel;
281	return VINF_SUCCESS;
282	}
283
284	/**
285	* Handles a write to the IOREGSEL register.
286	*/
287	static int ioapic_IoRegSel_w(PIOAPIC pThis, uint32_t u32Value)
288	{
289	Log2(("ioapic: IOREGSEL %#04x -> %#04x\n", pThis->ioregsel, u32Value & 0xff));
290	/* Bits 7:0 are writable, the rest aren't. Confirmed on recent AMD box. */
291	pThis->ioregsel = u32Value & 0xff;
292	return VINF_SUCCESS;
293	}
294
295
296	/**
297	* Handles a write to the IOWIN register.
298	*/
299	static int ioapic_IoWin_r(PIOAPIC pThis, uint32_t *pu32Value)
300	{
301	int rc = VINF_SUCCESS;
302	uint32_t const uIoRegSel = pThis->ioregsel;
303
304	if (uIoRegSel == 0)
305	rc = ioapic_IoApicId_r(pThis, pu32Value);
306	else if (uIoRegSel == 1)
307	rc = ioapic_IoApicVer_r(pThis, pu32Value);
308	else if (uIoRegSel == 2)
309	rc = ioapic_IoApicArb_r(pThis, pu32Value);
310	/*
311	* IOREDTBL0..IOREDTBL23.
312	*/
313	else if (uIoRegSel - UINT32_C(0x10) < IOAPIC_NUM_PINS * 2)
314	{
315	uint32_t const idxIoRedTbl = (uIoRegSel - UINT32_C(0x10)) >> 1;
316	if (!(uIoRegSel & 1))
317	/** @todo r=bird: Do we need to emulate DELIVS or/and Remote IRR? */
318	*pu32Value = RT_LODWORD(pThis->ioredtbl[idxIoRedTbl]);
319	else
320	*pu32Value = RT_HIDWORD(pThis->ioredtbl[idxIoRedTbl]);
321	}
322	else
323	{
324	Log(("ioapic: Attempt to read from register %#x.\n", uIoRegSel));
325	*pu32Value = UINT32_MAX;
326	}
327
328	Log(("ioapic: IOWIN rd -> %#010x (%Rrc)\n", *pu32Value, rc));
329	return rc;
330	}
331
332
333	/**
334	* Handles a write to the IOWIN register.
335	*/
336	static int ioapic_IoWin_w(PIOAPIC pThis, uint32_t u32Value)
337	{
338	int rc = VINF_SUCCESS;
339	uint32_t const uIoRegSel = pThis->ioregsel;
340	Log2(("ioapic: IOWIN[%#04x] = %#x\n", uIoRegSel, u32Value));
341
342	/*
343	* IOAPICID.
344	*/
345	if (uIoRegSel == 0)
346	rc = ioapic_IoApicId_w(pThis, u32Value);
347	/*
348	* IOREDTBL0..IOREDTBL23.
349	*/
350	else if (uIoRegSel - UINT32_C(0x10) < IOAPIC_NUM_PINS * 2)
351	{
352	uint32_t const idxIoRedTbl = (uIoRegSel - UINT32_C(0x10)) >> 1;
353	uint64_t u64NewValue;
354	if (!(uIoRegSel & 1))
355	{
356	/*
357	* Low DWORD.
358	*
359	* Have to do some sanity checks here because Linux 2.6 kernels
360	* writes seemingly bogus value (u32Value = 0) in their
361	* unlock_ExtINT_logic() function. Not sure what it's good for, but
362	* we ran into trouble with INTVEC = 0. Luckily the 82093AA specs
363	* limits the INTVEC range to 0x10 thru 0xfe, so we use this to
364	* ignore harmful values.
365	*
366	* Update: Looking at real hw (recent AMD), they don't reject
367	* invalid vector numbers, at least not at this point. Could be that
368	* some other code path needs to refuse something instead. Results:
369	* - Writing 0 to lo+hi -> 0.
370	* - Writing ~0 to lo+hi -> 0xff0000000001afff.
371	* - Writing ~0 w/ DELMOD set to 011b or 110b (both reserved)
372	* results in DELMOD containing the reserved values.
373	* - Ditto with same + DELMOD in [0..7], DELMOD is stored as written.
374	*/
375	if ( (u32Value & APIC_LVT_MASKED)
376	\|\| ((u32Value & UINT32_C(0xff)) - UINT32_C(0x10)) <= UINT32_C(0xee) /* (0xfe - 0x10 = 0xee) */ )
377	u64NewValue = (pThis->ioredtbl[idxIoRedTbl] & (UINT64_C(0xffffffff00000000) \| RT_BIT(14) \| RT_BIT(12)))
378	\| (u32Value & ~(RT_BIT(14) \| RT_BIT(12)));
379	else
380	{
381	LogRel(("IOAPIC GUEST BUG: bad vector writing %x(sel=%x) to %u\n", u32Value, uIoRegSel, idxIoRedTbl));
382	u64NewValue = pThis->ioredtbl[idxIoRedTbl];
383	}
384	}
385	else
386	{
387	/*
388	* High DWORD.
389	*/
390	u64NewValue = (pThis->ioredtbl[idxIoRedTbl] & UINT64_C(0x00000000ffffffff))
391	\| ((uint64_t)(u32Value & UINT32_C(0xff000000)) << 32);
392	}
393
394	Log(("ioapic: IOREDTBL%u %#018llx -> %#018llx\n", idxIoRedTbl, pThis->ioredtbl[idxIoRedTbl], u64NewValue));
395	pThis->ioredtbl[idxIoRedTbl] = u64NewValue;
396
397	ioapic_service(pThis);
398	}
399	/*
400	* Read-only or unknown registers. Log it.
401	*/
402	else if (uIoRegSel == 1)
403	Log(("ioapic: Attempt to write (%#x) to IOAPICVER.\n", u32Value));
404	else if (uIoRegSel == 2)
405	Log(("ioapic: Attempt to write (%#x) to IOAPICARB.\n", u32Value));
406	else
407	Log(("ioapic: Attempt to write (%#x) to register %#x.\n", u32Value, uIoRegSel));
408
409	return rc;
410	}
411
412
413	PDMBOTHCBDECL(int) ioapicMMIORead(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb)
414	{
415	PIOAPIC pThis = PDMINS_2_DATA(pDevIns, PIOAPIC);
416	IOAPIC_LOCK(pThis, VINF_IOM_R3_MMIO_READ);
417
418	STAM_COUNTER_INC(&CTXSUFF(pThis->StatMMIORead));
419
420	/*
421	* Pass it on to the register read handlers.
422	* (See 0xff comments in ioapicMMIOWrite.)
423	*/
424	int rc;
425	uint32_t offReg = GCPhysAddr & 0xff;
426	if (offReg == 0)
427	rc = ioapic_IoRegSel_r(pThis, (uint32_t *)pv);
428	else if (offReg == 0x10)
429	rc = ioapic_IoWin_r(pThis, (uint32_t *)pv);
430	else
431	{
432	Log(("ioapicMMIORead: Invalid access: offReg=%#x\n", offReg));
433	rc = VINF_IOM_MMIO_UNUSED_FF;
434	}
435	Log3(("ioapicMMIORead: @%#x -> %#x %Rrc\n", offReg, (uint32_t )pv, rc));
436
437	IOAPIC_UNLOCK(pThis);
438	return rc;
439	}
440
441	PDMBOTHCBDECL(int) ioapicMMIOWrite(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void const pv, unsigned cb)
442	{
443	PIOAPIC pThis = PDMINS_2_DATA(pDevIns, PIOAPIC);
444
445	STAM_COUNTER_INC(&CTXSUFF(pThis->StatMMIOWrite));
446	IOAPIC_LOCK(pThis, VINF_IOM_R3_MMIO_WRITE);
447
448	/*
449	* Fetch the value.
450	*
451	* We've told IOM to only give us DWORD accesses. Observations on AMD
452	* indicates that unaligned writes get their missing bytes written as zero.
453	*/
454	Assert(!(GCPhysAddr & 3)); Assert(cb == 4);
455	uint32_t u32Value = (uint32_t const )pv;
456
457	/*
458	* The 0xff mask is because we don't really implement the APICBASE register
459	* in the PIIX3, so if the guest tries to relocate the IOAPIC via PIIX3 we
460	* won't know. The I/O APIC address is on the form FEC0xy00h, where xy is
461	* programmable. Masking 0xff means we cover the y. The x would require
462	* reregistering MMIO memory, which means the guest is out of luck there.
463	*/
464	int rc;
465	uint32_t offReg = GCPhysAddr & 0xff;
466	if (offReg == 0)
467	rc = ioapic_IoRegSel_w(pThis, u32Value);
468	else if (offReg == 0x10)
469	rc = ioapic_IoWin_w(pThis, u32Value);
470	else
471	{
472	Log(("ioapicMMIOWrite: Invalid access: offReg=%#x u32Value=%#x\n", offReg, u32Value));
473	rc = VINF_SUCCESS;
474	}
475	Log3(("ioapicMMIOWrite: @%#x := %#x %Rrc\n", offReg, u32Value, rc));
476
477	IOAPIC_UNLOCK(pThis);
478	return rc;
479	}
480
481	PDMBOTHCBDECL(void) ioapicSetIrq(PPDMDEVINS pDevIns, int iIrq, int iLevel, uint32_t uTagSrc)
482	{
483	/* PDM lock is taken here; / /* @todo add assertion */
484	PIOAPIC pThis = PDMINS_2_DATA(pDevIns, PIOAPIC);
485	STAM_COUNTER_INC(&pThis->CTXSUFF(StatSetIrq));
486	LogFlow(("ioapicSetIrq: iIrq=%d iLevel=%d uTagSrc=%#x\n", iIrq, iLevel, uTagSrc));
487	ioapic_set_irq(pThis, iIrq, iLevel, uTagSrc);
488	}
489
490	PDMBOTHCBDECL(void) ioapicSendMsi(PPDMDEVINS pDevIns, RTGCPHYS GCAddr, uint32_t uValue, uint32_t uTagSrc)
491	{
492	PIOAPIC pThis = PDMINS_2_DATA(pDevIns, PIOAPIC);
493
494	LogFlow(("ioapicSendMsi: Address=%p uValue=%\n", GCAddr, uValue));
495
496	uint8_t dest = (GCAddr & VBOX_MSI_ADDR_DEST_ID_MASK) >> VBOX_MSI_ADDR_DEST_ID_SHIFT;
497	uint8_t vector_num = (uValue & VBOX_MSI_DATA_VECTOR_MASK) >> VBOX_MSI_DATA_VECTOR_SHIFT;
498	uint8_t dest_mode = (GCAddr >> VBOX_MSI_ADDR_DEST_MODE_SHIFT) & 0x1;
499	uint8_t trigger_mode = (uValue >> VBOX_MSI_DATA_TRIGGER_SHIFT) & 0x1;
500	uint8_t delivery_mode = (uValue >> VBOX_MSI_DATA_DELIVERY_MODE_SHIFT) & 0x7;
501	#if 0
502	/*
503	* This bit indicates whether the message should be directed to the
504	* processor with the lowest interrupt priority among
505	* processors that can receive the interrupt, ignored ATM.
506	*/
507	uint8_t redir_hint = (GCAddr >> VBOX_MSI_ADDR_REDIRECTION_SHIFT) & 0x1;
508	#endif
509	int rc = pThis->CTX_SUFF(pIoApicHlp)->pfnApicBusDeliver(pDevIns,
510	dest,
511	dest_mode,
512	delivery_mode,
513	vector_num,
514	0 /* polarity, n/a */,
515	trigger_mode,
516	uTagSrc);
517	/* We must be sure that attempts to reschedule in R3
518	never get here */
519	Assert(rc == VINF_SUCCESS);
520	}
521
522	#ifdef IN_RING3
523
524	/** @interface_method_impl{DBGFREGDESC,pfnGet} */
525	static DECLCALLBACK(int) ioapicDbgReg_IoRegSel_r(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
526	{
527	return ioapic_IoRegSel_r(PDMINS_2_DATA((PPDMDEVINS)pvUser, PIOAPIC), &pValue->u32);
528	}
529
530	/** @interface_method_impl{DBGFREGDESC,pfnSet} */
531	static DECLCALLBACK(int) ioapicDbgReg_IoRegSel_w(void *pvUser, PCDBGFREGDESC pDesc, PCDBGFREGVAL pValue, PCDBGFREGVAL pfMask)
532	{
533	return ioapic_IoRegSel_w(PDMINS_2_DATA((PPDMDEVINS)pvUser, PIOAPIC), pValue->u8);
534	}
535
536	/** @interface_method_impl{DBGFREGDESC,pfnGet} */
537	static DECLCALLBACK(int) ioapicDbgReg_IoWin_r(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
538	{
539	return ioapic_IoWin_r(PDMINS_2_DATA((PPDMDEVINS)pvUser, PIOAPIC), &pValue->u32);
540	}
541
542	/** @interface_method_impl{DBGFREGDESC,pfnSet} */
543	static DECLCALLBACK(int) ioapicDbgReg_IoWin_w(void *pvUser, PCDBGFREGDESC pDesc, PCDBGFREGVAL pValue, PCDBGFREGVAL pfMask)
544	{
545	return ioapic_IoWin_w(PDMINS_2_DATA((PPDMDEVINS)pvUser, PIOAPIC), pValue->u32);
546	}
547
548	/** @interface_method_impl{DBGFREGDESC,pfnGet} */
549	static DECLCALLBACK(int) ioapicDbgReg_IoApicVer_r(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
550	{
551	return ioapic_IoApicVer_r(PDMINS_2_DATA((PPDMDEVINS)pvUser, PIOAPIC), &pValue->u32);
552	}
553
554	/** @interface_method_impl{DBGFREGDESC,pfnGet} */
555	static DECLCALLBACK(int) ioapicDbgReg_IoApicArb_r(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
556	{
557	return ioapic_IoApicArb_r(PDMINS_2_DATA((PPDMDEVINS)pvUser, PIOAPIC), &pValue->u32);
558	}
559
560	/** @interface_method_impl{DBGFREGDESC,pfnGet} */
561	static DECLCALLBACK(int) ioapicDbgReg_IoRedRblN_r(void *pvUser, PCDBGFREGDESC pDesc, PDBGFREGVAL pValue)
562	{
563	PIOAPIC pThis = PDMINS_2_DATA((PPDMDEVINS)pvUser, PIOAPIC);
564	pValue->u64 = pThis->ioredtbl[pDesc->offRegister];
565	return VINF_SUCCESS;
566	}
567
568	/** @interface_method_impl{DBGFREGDESC,pfnSet} */
569	static DECLCALLBACK(int) ioapicDbgReg_IoRedRblN_w(void *pvUser, PCDBGFREGDESC pDesc, PCDBGFREGVAL pValue, PCDBGFREGVAL pfMask)
570	{
571	PIOAPIC pThis = PDMINS_2_DATA((PPDMDEVINS)pvUser, PIOAPIC);
572	pThis->ioredtbl[pDesc->offRegister] = pValue->u64 \| (~pfMask->u64 &pThis->ioredtbl[pDesc->offRegister]);
573	return VINF_SUCCESS;
574	}
575
576	/** IOREDTBLn sub fields. */
577	static DBGFREGSUBFIELD const g_aIoRedTblSubs[] =
578	{
579	{ "intvec", 0, 8, 0, 0, NULL, NULL },
580	{ "delmode", 8, 3, 0, 0, NULL, NULL },
581	{ "destmode", 11, 1, 0, 0, NULL, NULL },
582	{ "delivs", 12, 1, 0, DBGFREGSUBFIELD_FLAGS_READ_ONLY, NULL, NULL },
583	{ "intpol", 13, 1, 0, 0, NULL, NULL },
584	{ "remoteirr", 14, 1, 0, DBGFREGSUBFIELD_FLAGS_READ_ONLY, NULL, NULL },
585	{ "triggermode", 15, 1, 0, 0, NULL, NULL },
586	{ "intmask", 16, 1, 0, 0, NULL, NULL },
587	{ "dst", 56, 8, 0, 0, NULL, NULL },
588	DBGFREGSUBFIELD_TERMINATOR()
589	};
590
591	/** Register descriptors for DBGF. */
592	static DBGFREGDESC const g_aRegDesc[] =
593	{
594	{ "ioregsel", DBGFREG_END, DBGFREGVALTYPE_U8, 0, 0, ioapicDbgReg_IoRegSel_r, ioapicDbgReg_IoRegSel_w, NULL, NULL },
595	{ "iowin", DBGFREG_END, DBGFREGVALTYPE_U32, 0, 0, ioapicDbgReg_IoWin_r, ioapicDbgReg_IoWin_w, NULL, NULL },
596	{ "ioapicver", DBGFREG_END, DBGFREGVALTYPE_U32, DBGFREG_FLAGS_READ_ONLY, 0, ioapicDbgReg_IoApicVer_r, NULL, NULL, NULL },
597	{ "ioapicarb", DBGFREG_END, DBGFREGVALTYPE_U32, DBGFREG_FLAGS_READ_ONLY, 0, ioapicDbgReg_IoApicArb_r, NULL, NULL, NULL },
598	{ "ioredtbl0", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 0, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
599	{ "ioredtbl1", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 1, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
600	{ "ioredtbl2", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 2, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
601	{ "ioredtbl3", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 3, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
602	{ "ioredtbl4", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 4, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
603	{ "ioredtbl5", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 5, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
604	{ "ioredtbl6", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 6, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
605	{ "ioredtbl7", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 7, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
606	{ "ioredtbl8", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 8, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
607	{ "ioredtbl9", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 9, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
608	{ "ioredtbl10", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 10, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
609	{ "ioredtbl11", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 11, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
610	{ "ioredtbl12", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 12, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
611	{ "ioredtbl13", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 13, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
612	{ "ioredtbl14", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 14, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
613	{ "ioredtbl15", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 15, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
614	{ "ioredtbl16", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 16, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
615	{ "ioredtbl17", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 17, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
616	{ "ioredtbl18", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 18, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
617	{ "ioredtbl19", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 19, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
618	{ "ioredtbl20", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 20, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
619	{ "ioredtbl21", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 21, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
620	{ "ioredtbl22", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 22, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
621	{ "ioredtbl23", DBGFREG_END, DBGFREGVALTYPE_U64, 0, 23, ioapicDbgReg_IoRedRblN_r, ioapicDbgReg_IoRedRblN_w, NULL, &g_aIoRedTblSubs[0] },
622	DBGFREGDESC_TERMINATOR()
623	};
624
625
626	/**
627	* Info handler, device version. Dumps I/O APIC state.
628	*
629	* @param pDevIns Device instance which registered the info.
630	* @param pHlp Callback functions for doing output.
631	* @param pszArgs Argument string. Optional and specific to the handler.
632	*/
633	static DECLCALLBACK(void) ioapicInfo(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
634	{
635	PIOAPIC pThis = PDMINS_2_DATA(pDevIns, PIOAPIC);
636	uint32_t uVal;
637
638	pHlp->pfnPrintf(pHlp, "I/O APIC at %#010x:\n", 0xfec00000);
639
640	ioapic_IoApicId_r(pThis, &uVal);
641	pHlp->pfnPrintf(pHlp, " IOAPICID : %#010x\n", uVal);
642	pHlp->pfnPrintf(pHlp, " APIC ID = %#04x\n", (uVal >> 24) & 0xff);
643
644	ioapic_IoApicVer_r(pThis, &uVal);
645	unsigned iLastRedir = RT_BYTE3(uVal);
646	pHlp->pfnPrintf(pHlp, " IOAPICVER : %#010x\n", uVal);
647	pHlp->pfnPrintf(pHlp, " version = %#04x\n", uVal & 0xff);
648	pHlp->pfnPrintf(pHlp, " redirs = %u\n", iLastRedir + 1);
649
650	ioapic_IoApicArb_r(pThis, &uVal);
651	pHlp->pfnPrintf(pHlp, " arb ID = %#010x\n", RT_BYTE4(uVal));
652	pHlp->pfnPrintf(pHlp, " IOAPICARB : %#08x\n", uVal);
653
654	Assert(sizeof(pThis->ioredtbl) / sizeof(pThis->ioredtbl[0]) > iLastRedir);
655	pHlp->pfnPrintf(pHlp, "I/O redirection table\n");
656	pHlp->pfnPrintf(pHlp, " idx dst_mode dst_addr mask trigger rirr polarity dlvr_st dlvr_mode vector\n");
657	for (unsigned i = 0; i <= iLastRedir; ++i)
658	{
659	static const char * const s_apszDModes[] =
660	{
661	"Fixed ", "LowPri", "SMI ", "Resrvd", "NMI ", "INIT ", "Resrvd", "ExtINT"
662	};
663
664	pHlp->pfnPrintf(pHlp, " %02d %s %02x %d %s %d %s %s %s %3d (%016llx)\n",
665	i,
666	pThis->ioredtbl[i] & RT_BIT(11) ? "log " : "phys", /* dest mode */
667	(int)(pThis->ioredtbl[i] >> 56), /* dest addr */
668	(int)(pThis->ioredtbl[i] >> 16) & 1, /* mask */
669	pThis->ioredtbl[i] & RT_BIT(15) ? "level" : "edge ", /* trigger */
670	(int)(pThis->ioredtbl[i] >> 14) & 1, /* remote IRR */
671	pThis->ioredtbl[i] & RT_BIT(13) ? "activelo" : "activehi", /* polarity */
672	pThis->ioredtbl[i] & RT_BIT(12) ? "pend" : "idle", /* delivery status */
673	s_apszDModes[(pThis->ioredtbl[i] >> 8) & 0x07], /* delivery mode */
674	(int)pThis->ioredtbl[i] & 0xff, /* vector */
675	pThis->ioredtbl[i] /* entire register */
676	);
677	}
678	}
679
680	/**
681	* @copydoc FNSSMDEVSAVEEXEC
682	*/
683	static DECLCALLBACK(int) ioapicSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
684	{
685	PIOAPIC pThis = PDMINS_2_DATA(pDevIns, PIOAPIC);
686
687	SSMR3PutU8(pSSM, pThis->id);
688	SSMR3PutU8(pSSM, pThis->ioregsel);
689	for (unsigned i = 0; i < IOAPIC_NUM_PINS; i++)
690	SSMR3PutU64(pSSM, pThis->ioredtbl[i]);
691
692	return VINF_SUCCESS;
693	}
694
695	/**
696	* @copydoc FNSSMDEVLOADEXEC
697	*/
698	static DECLCALLBACK(int) ioapicLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
699	{
700	PIOAPIC pThis = PDMINS_2_DATA(pDevIns, PIOAPIC);
701	if (uVersion != 1)
702	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
703
704	SSMR3GetU8(pSSM, &pThis->id);
705	SSMR3GetU8(pSSM, &pThis->ioregsel);
706	for (unsigned i = 0; i < IOAPIC_NUM_PINS; i++)
707	SSMR3GetU64(pSSM, &pThis->ioredtbl[i]);
708
709	Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
710	return VINF_SUCCESS;
711	}
712
713	/**
714	* @copydoc FNPDMDEVRESET
715	*/
716	static DECLCALLBACK(void) ioapicReset(PPDMDEVINS pDevIns)
717	{
718	PIOAPIC pThis = PDMINS_2_DATA(pDevIns, PIOAPIC);
719	pThis->pIoApicHlpR3->pfnLock(pDevIns, VERR_INTERNAL_ERROR);
720
721	pThis->id = pThis->cCpus;
722	pThis->ioregsel = 0;
723	pThis->irr = 0;
724	for (unsigned i = 0; i < IOAPIC_NUM_PINS; i++)
725	{
726	pThis->ioredtbl[i] = 1 << 16; /* mask LVT */
727	pThis->auTagSrc[i] = 0;
728	}
729
730	IOAPIC_UNLOCK(pThis);
731	}
732
733	/**
734	* @copydoc FNPDMDEVRELOCATE
735	*/
736	static DECLCALLBACK(void) ioapicRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
737	{
738	PIOAPIC pThis = PDMINS_2_DATA(pDevIns, PIOAPIC);
739	pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
740	pThis->pIoApicHlpRC = pThis->pIoApicHlpR3->pfnGetRCHelpers(pDevIns);
741	}
742
743	/**
744	* @copydoc FNPDMDEVCONSTRUCT
745	*/
746	static DECLCALLBACK(int) ioapicConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
747	{
748	PIOAPIC pThis = PDMINS_2_DATA(pDevIns, PIOAPIC);
749	Assert(iInstance == 0);
750
751	/*
752	* Initialize the state data.
753	*/
754	pThis->pDevInsR3 = pDevIns;
755	pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
756	pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
757	/* (the rest is done by the reset call at the end) */
758
759	/* PDM provides locking via the IOAPIC helpers. */
760	int rc = PDMDevHlpSetDeviceCritSect(pDevIns, PDMDevHlpCritSectGetNop(pDevIns));
761	AssertRCReturn(rc, rc);
762
763	/*
764	* Validate and read the configuration.
765	*/
766	PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns, "NumCPUs\|RZEnabled", "");
767
768	uint32_t cCpus;
769	rc = CFGMR3QueryU32Def(pCfg, "NumCPUs", &cCpus, 1);
770	if (RT_FAILURE(rc))
771	return PDMDEV_SET_ERROR(pDevIns, rc,
772	N_("Configuration error: Failed to query integer value \"NumCPUs\""));
773	if (cCpus > UINT8_MAX - 2) /* ID 255 is broadcast and the IO-APIC needs one (ID=cCpus). */
774	return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
775	N_("Configuration error: Max %u CPUs, %u specified"), UINT8_MAX - 1, cCpus);
776	pThis->cCpus = (uint8_t)cCpus;
777
778	bool fRZEnabled;
779	rc = CFGMR3QueryBoolDef(pCfg, "RZEnabled", &fRZEnabled, true);
780	if (RT_FAILURE(rc))
781	return PDMDEV_SET_ERROR(pDevIns, rc,
782	N_("Configuration error: Failed to query boolean value \"RZEnabled\""));
783
784	Log(("IOAPIC: cCpus=%u fRZEnabled=%RTbool\n", cCpus, fRZEnabled));
785
786	/*
787	* Register the IOAPIC and get helpers.
788	*/
789	PDMIOAPICREG IoApicReg;
790	IoApicReg.u32Version = PDM_IOAPICREG_VERSION;
791	IoApicReg.pfnSetIrqR3 = ioapicSetIrq;
792	IoApicReg.pszSetIrqRC = fRZEnabled ? "ioapicSetIrq" : NULL;
793	IoApicReg.pszSetIrqR0 = fRZEnabled ? "ioapicSetIrq" : NULL;
794	IoApicReg.pfnSendMsiR3 = ioapicSendMsi;
795	IoApicReg.pszSendMsiRC = fRZEnabled ? "ioapicSendMsi" : NULL;
796	IoApicReg.pszSendMsiR0 = fRZEnabled ? "ioapicSendMsi" : NULL;
797
798	rc = PDMDevHlpIOAPICRegister(pDevIns, &IoApicReg, &pThis->pIoApicHlpR3);
799	if (RT_FAILURE(rc))
800	{
801	AssertMsgFailed(("IOAPICRegister -> %Rrc\n", rc));
802	return rc;
803	}
804
805	/*
806	* Register MMIO callbacks and saved state.
807	* Note! The write ZEROing was observed on a real AMD system.
808	*/
809	rc = PDMDevHlpMMIORegister(pDevIns, UINT32_C(0xfec00000), 0x1000, pThis,
810	IOMMMIO_FLAGS_READ_DWORD \| IOMMMIO_FLAGS_WRITE_DWORD_ZEROED,
811	ioapicMMIOWrite, ioapicMMIORead, "I/O APIC Memory");
812	if (RT_FAILURE(rc))
813	return rc;
814
815	if (fRZEnabled)
816	{
817	pThis->pIoApicHlpRC = pThis->pIoApicHlpR3->pfnGetRCHelpers(pDevIns);
818	rc = PDMDevHlpMMIORegisterRC(pDevIns, UINT32_C(0xfec00000), 0x1000, NIL_RTRCPTR /pvUser/,
819	"ioapicMMIOWrite", "ioapicMMIORead");
820	AssertRCReturn(rc, rc);
821
822	pThis->pIoApicHlpR0 = pThis->pIoApicHlpR3->pfnGetR0Helpers(pDevIns);
823	rc = PDMDevHlpMMIORegisterR0(pDevIns, UINT32_C(0xfec00000), 0x1000, NIL_RTR0PTR /pvUser/,
824	"ioapicMMIOWrite", "ioapicMMIORead");
825	AssertRCReturn(rc, rc);
826	}
827
828	rc = PDMDevHlpSSMRegister(pDevIns, 1 /* version /, sizeof(pThis), ioapicSaveExec, ioapicLoadExec);
829	if (RT_FAILURE(rc))
830	return rc;
831
832	/*
833	* Register debugger info callback.
834	*/
835	rc = PDMDevHlpDBGFInfoRegister(pDevIns, "ioapic", "Display I/O APIC state.", ioapicInfo); AssertRC(rc);
836	rc = PDMDevHlpDBGFRegRegister(pDevIns, g_aRegDesc); AssertRC(rc);
837
838	#ifdef VBOX_WITH_STATISTICS
839	/*
840	* Statistics.
841	*/
842	PDMDevHlpSTAMRegister(pDevIns, &pThis->StatMMIOReadGC, STAMTYPE_COUNTER, "/Devices/IOAPIC/MMIOReadGC", STAMUNIT_OCCURENCES, "Number of IOAPIC MMIO reads in GC.");
843	PDMDevHlpSTAMRegister(pDevIns, &pThis->StatMMIOReadHC, STAMTYPE_COUNTER, "/Devices/IOAPIC/MMIOReadHC", STAMUNIT_OCCURENCES, "Number of IOAPIC MMIO reads in HC.");
844	PDMDevHlpSTAMRegister(pDevIns, &pThis->StatMMIOWriteGC, STAMTYPE_COUNTER, "/Devices/IOAPIC/MMIOWriteGC", STAMUNIT_OCCURENCES, "Number of IOAPIC MMIO writes in GC.");
845	PDMDevHlpSTAMRegister(pDevIns, &pThis->StatMMIOWriteHC, STAMTYPE_COUNTER, "/Devices/IOAPIC/MMIOWriteHC", STAMUNIT_OCCURENCES, "Number of IOAPIC MMIO writes in HC.");
846	PDMDevHlpSTAMRegister(pDevIns, &pThis->StatSetIrqGC, STAMTYPE_COUNTER, "/Devices/IOAPIC/SetIrqGC", STAMUNIT_OCCURENCES, "Number of IOAPIC SetIrq calls in GC.");
847	PDMDevHlpSTAMRegister(pDevIns, &pThis->StatSetIrqHC, STAMTYPE_COUNTER, "/Devices/IOAPIC/SetIrqHC", STAMUNIT_OCCURENCES, "Number of IOAPIC SetIrq calls in HC.");
848	#endif
849
850	/*
851	* Reset the device state.
852	*/
853	ioapicReset(pDevIns);
854
855	return VINF_SUCCESS;
856	}
857
858	/**
859	* IO APIC device registration structure.
860	*/
861	const PDMDEVREG g_DeviceIOAPIC =
862	{
863	/* u32Version */
864	PDM_DEVREG_VERSION,
865	/* szName */
866	"ioapic",
867	/* szRCMod */
868	"VBoxDD2GC.gc",
869	/* szR0Mod */
870	"VBoxDD2R0.r0",
871	/* pszDescription */
872	"I/O Advanced Programmable Interrupt Controller (IO-APIC) Device",
873	/* fFlags */
874	PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT \| PDM_DEVREG_FLAGS_GUEST_BITS_32_64 \| PDM_DEVREG_FLAGS_PAE36 \| PDM_DEVREG_FLAGS_RC \| PDM_DEVREG_FLAGS_R0,
875	/* fClass */
876	PDM_DEVREG_CLASS_PIC,
877	/* cMaxInstances */
878	1,
879	/* cbInstance */
880	sizeof(IOAPIC),
881	/* pfnConstruct */
882	ioapicConstruct,
883	/* pfnDestruct */
884	NULL,
885	/* pfnRelocate */
886	ioapicRelocate,
887	/* pfnMemSetup */
888	NULL,
889	/* pfnPowerOn */
890	NULL,
891	/* pfnReset */
892	ioapicReset,
893	/* pfnSuspend */
894	NULL,
895	/* pfnResume */
896	NULL,
897	/* pfnAttach */
898	NULL,
899	/* pfnDetach */
900	NULL,
901	/* pfnQueryInterface. */
902	NULL,
903	/* pfnInitComplete */
904	NULL,
905	/* pfnPowerOff */
906	NULL,
907	/* pfnSoftReset */
908	NULL,
909	/* u32VersionEnd */
910	PDM_DEVREG_VERSION
911	};
912
913	#endif /* IN_RING3 */
914	#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */

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

source: vbox/trunk/src/VBox/Devices/PC/DevIoApic.cpp@ 47928

Download in other formats: