IOMInternal.h@ 12986

Last change on this file since 12986 was 12772, checked in by vboxsync, 16 years ago
#1865: IOM.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 18.9 KB

Line
1	/* $Id: IOMInternal.h 12772 2008-09-26 16:13:09Z vboxsync $ */
2	/** @file
3	* IOM - Internal header file.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
18	* Clara, CA 95054 USA or visit http://www.sun.com if you need
19	* additional information or have any questions.
20	*/
21
22	#ifndef ___IOMInternal_h
23	#define ___IOMInternal_h
24
25	#include <VBox/cdefs.h>
26	#include <VBox/types.h>
27	#include <VBox/iom.h>
28	#include <VBox/stam.h>
29	#include <VBox/pgm.h>
30	#include <VBox/param.h>
31	#include <iprt/avl.h>
32
33	#if !defined(IN_IOM_R3) && !defined(IN_IOM_R0) && !defined(IN_IOM_GC)
34	# error "Not in IOM! This is an internal header!"
35	#endif
36
37
38	/** @defgroup grp_iom_int Internals
39	* @ingroup grp_iom
40	* @internal
41	* @{
42	*/
43
44	/**
45	* MMIO range descriptor.
46	*/
47	typedef struct IOMMMIORANGE
48	{
49	/** Avl node core with GCPhys as Key and GCPhys + cbSize - 1 as KeyLast. */
50	AVLROGCPHYSNODECORE Core;
51	/** Start physical address. */
52	RTGCPHYS GCPhys;
53	/** Size of the range. */
54	uint32_t cb;
55	uint32_t u32Alignment; /*< Alignment padding. /
56
57	/** Pointer to user argument - R3. */
58	RTR3PTR pvUserR3;
59	/** Pointer to device instance - R3. */
60	PPDMDEVINSR3 pDevInsR3;
61	/** Pointer to write callback function - R3. */
62	R3PTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallbackR3;
63	/** Pointer to read callback function - R3. */
64	R3PTRTYPE(PFNIOMMMIOREAD) pfnReadCallbackR3;
65	/** Pointer to fill (memset) callback function - R3. */
66	R3PTRTYPE(PFNIOMMMIOFILL) pfnFillCallbackR3;
67
68	/** Pointer to user argument - R0. */
69	RTR0PTR pvUserR0;
70	/** Pointer to device instance - R0. */
71	PPDMDEVINSR0 pDevInsR0;
72	/** Pointer to write callback function - R0. */
73	R0PTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallbackR0;
74	/** Pointer to read callback function - R0. */
75	R0PTRTYPE(PFNIOMMMIOREAD) pfnReadCallbackR0;
76	/** Pointer to fill (memset) callback function - R0. */
77	R0PTRTYPE(PFNIOMMMIOFILL) pfnFillCallbackR0;
78
79	/** Pointer to user argument - RC. */
80	RTRCPTR pvUserRC;
81	/** Pointer to device instance - RC. */
82	PPDMDEVINSRC pDevInsRC;
83	/** Pointer to write callback function - RC. */
84	RCPTRTYPE(PFNIOMMMIOWRITE) pfnWriteCallbackRC;
85	/** Pointer to read callback function - RC. */
86	RCPTRTYPE(PFNIOMMMIOREAD) pfnReadCallbackRC;
87	/** Pointer to fill (memset) callback function - RC. */
88	RCPTRTYPE(PFNIOMMMIOFILL) pfnFillCallbackRC;
89	/** Alignment padding. */
90	RTRCPTR RCPtrAlignment;
91
92	/** Description / Name. For easing debugging. */
93	R3PTRTYPE(const char *) pszDesc;
94	} IOMMMIORANGE;
95	/** Pointer to a MMIO range descriptor, R3 version. */
96	typedef struct IOMMMIORANGE *PIOMMMIORANGE;
97
98
99	/**
100	* MMIO address statistics. (one address)
101	*
102	* This is a simple way of making on demand statistics, however it's a
103	* bit free with the hypervisor heap memory.
104	*/
105	typedef struct IOMMMIOSTATS
106	{
107	/** Avl node core with the address as Key. */
108	AVLOGCPHYSNODECORE Core;
109
110	/** Number of reads to this address from R3. */
111	STAMCOUNTER ReadR3;
112	/** Profiling read handler overhead in R3. */
113	STAMPROFILEADV ProfReadR3;
114
115	/** Number of writes to this address from R3. */
116	STAMCOUNTER WriteR3;
117	/** Profiling write handler overhead in R3. */
118	STAMPROFILEADV ProfWriteR3;
119
120	/** Number of reads to this address from R0/RC. */
121	STAMCOUNTER ReadRZ;
122	/** Profiling read handler overhead in R0/RC. */
123	STAMPROFILEADV ProfReadRZ;
124	/** Number of reads to this address from R0/RC which was serviced in R3. */
125	STAMCOUNTER ReadRZToR3;
126
127	/** Number of writes to this address from R0/RC. */
128	STAMCOUNTER WriteRZ;
129	/** Profiling write handler overhead in R0/RC. */
130	STAMPROFILEADV ProfWriteRZ;
131	/** Number of writes to this address from R0/RC which was serviced in R3. */
132	STAMCOUNTER WriteRZToR3;
133	} IOMMMIOSTATS;
134	/** Pointer to I/O port statistics. */
135	typedef IOMMMIOSTATS *PIOMMMIOSTATS;
136
137
138	/**
139	* I/O port range descriptor, R3 version.
140	*/
141	typedef struct IOMIOPORTRANGER3
142	{
143	/** Avl node core with Port as Key and Port + cPorts - 1 as KeyLast. */
144	AVLROIOPORTNODECORE Core;
145	#if HC_ARCH_BITS == 64 && !defined(RT_OS_WINDOWS)
146	uint32_t u32Alignment; /*< The sizeof(Core) differs. /
147	#endif
148	/** Start I/O port address. */
149	RTIOPORT Port;
150	/** Size of the range. */
151	uint16_t cPorts;
152	/** Pointer to user argument. */
153	RTR3PTR pvUser;
154	/** Pointer to the associated device instance. */
155	R3PTRTYPE(PPDMDEVINS) pDevIns;
156	/** Pointer to OUT callback function. */
157	R3PTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback;
158	/** Pointer to IN callback function. */
159	R3PTRTYPE(PFNIOMIOPORTIN) pfnInCallback;
160	/** Pointer to string OUT callback function. */
161	R3PTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback;
162	/** Pointer to string IN callback function. */
163	R3PTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback;
164	/** Description / Name. For easing debugging. */
165	R3PTRTYPE(const char *) pszDesc;
166	} IOMIOPORTRANGER3;
167	/** Pointer to I/O port range descriptor, R3 version. */
168	typedef IOMIOPORTRANGER3 *PIOMIOPORTRANGER3;
169
170	/**
171	* I/O port range descriptor, R0 version.
172	*/
173	typedef struct IOMIOPORTRANGER0
174	{
175	/** Avl node core with Port as Key and Port + cPorts - 1 as KeyLast. */
176	AVLROIOPORTNODECORE Core;
177	#if HC_ARCH_BITS == 64 && !defined(RT_OS_WINDOWS)
178	uint32_t u32Alignment; /*< The sizeof(Core) differs. /
179	#endif
180	/** Start I/O port address. */
181	RTIOPORT Port;
182	/** Size of the range. */
183	uint16_t cPorts;
184	/** Pointer to user argument. */
185	RTR0PTR pvUser;
186	/** Pointer to the associated device instance. */
187	R0PTRTYPE(PPDMDEVINS) pDevIns;
188	/** Pointer to OUT callback function. */
189	R0PTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback;
190	/** Pointer to IN callback function. */
191	R0PTRTYPE(PFNIOMIOPORTIN) pfnInCallback;
192	/** Pointer to string OUT callback function. */
193	R0PTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback;
194	/** Pointer to string IN callback function. */
195	R0PTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback;
196	/** Description / Name. For easing debugging. */
197	R3PTRTYPE(const char *) pszDesc;
198	} IOMIOPORTRANGER0;
199	/** Pointer to I/O port range descriptor, R0 version. */
200	typedef IOMIOPORTRANGER0 *PIOMIOPORTRANGER0;
201
202	/**
203	* I/O port range descriptor, RC version.
204	*/
205	typedef struct IOMIOPORTRANGERC
206	{
207	/** Avl node core with Port as Key and Port + cPorts - 1 as KeyLast. */
208	AVLROIOPORTNODECORE Core;
209	/** Start I/O port address. */
210	RTIOPORT Port;
211	/** Size of the range. */
212	uint16_t cPorts;
213	/** Pointer to user argument. */
214	RTRCPTR pvUser;
215	/** Pointer to the associated device instance. */
216	RCPTRTYPE(PPDMDEVINS) pDevIns;
217	/** Pointer to OUT callback function. */
218	RCPTRTYPE(PFNIOMIOPORTOUT) pfnOutCallback;
219	/** Pointer to IN callback function. */
220	RCPTRTYPE(PFNIOMIOPORTIN) pfnInCallback;
221	/** Pointer to string OUT callback function. */
222	RCPTRTYPE(PFNIOMIOPORTOUTSTRING) pfnOutStrCallback;
223	/** Pointer to string IN callback function. */
224	RCPTRTYPE(PFNIOMIOPORTINSTRING) pfnInStrCallback;
225	#if HC_ARCH_BITS == 64
226	RTRCPTR RCPtrAlignment; /*< pszDesc is 8 byte aligned. /
227	#endif
228	/** Description / Name. For easing debugging. */
229	R3PTRTYPE(const char *) pszDesc;
230	} IOMIOPORTRANGERC;
231	/** Pointer to I/O port range descriptor, RC version. */
232	typedef IOMIOPORTRANGERC *PIOMIOPORTRANGERC;
233
234
235	/**
236	* I/O port statistics. (one I/O port)
237	*
238	* This is a simple way of making on demand statistics, however it's a
239	* bit free with the hypervisor heap memory.
240	*/
241	typedef struct IOMIOPORTSTATS
242	{
243	/** Avl node core with the port as Key. */
244	AVLOIOPORTNODECORE Core;
245	#if HC_ARCH_BITS == 64 && !defined(RT_OS_WINDOWS)
246	uint32_t u32Alignment; /*< The sizeof(Core) differs. /
247	#endif
248	/** Number of INs to this port from R3. */
249	STAMCOUNTER InR3;
250	/** Profiling IN handler overhead in R3. */
251	STAMPROFILEADV ProfInR3;
252	/** Number of OUTs to this port from R3. */
253	STAMCOUNTER OutR3;
254	/** Profiling OUT handler overhead in R3. */
255	STAMPROFILEADV ProfOutR3;
256
257	/** Number of INs to this port from R0/RC. */
258	STAMCOUNTER InRZ;
259	/** Profiling IN handler overhead in R0/RC. */
260	STAMPROFILEADV ProfInRZ;
261	/** Number of INs to this port from R0/RC which was serviced in R3. */
262	STAMCOUNTER InRZToR3;
263
264	/** Number of OUTs to this port from R0/RC. */
265	STAMCOUNTER OutRZ;
266	/** Profiling OUT handler overhead in R0/RC. */
267	STAMPROFILEADV ProfOutRZ;
268	/** Number of OUTs to this port from R0/RC which was serviced in R3. */
269	STAMCOUNTER OutRZToR3;
270	} IOMIOPORTSTATS;
271	/** Pointer to I/O port statistics. */
272	typedef IOMIOPORTSTATS *PIOMIOPORTSTATS;
273
274
275	/**
276	* The IOM trees.
277	* These are offset based the nodes and root must be in the same
278	* memory block in HC. The locations of IOM structure and the hypervisor heap
279	* are quite different in R3, R0 and RC.
280	*/
281	typedef struct IOMTREES
282	{
283	/** Tree containing I/O port range descriptors registered for HC (IOMIOPORTRANGEHC). */
284	AVLROIOPORTTREE IOPortTreeR3;
285	/** Tree containing I/O port range descriptors registered for R0 (IOMIOPORTRANGER0). */
286	AVLROIOPORTTREE IOPortTreeR0;
287	/** Tree containing I/O port range descriptors registered for RC (IOMIOPORTRANGERC). */
288	AVLROIOPORTTREE IOPortTreeRC;
289
290	/** Tree containing the MMIO range descriptors (IOMMMIORANGE). */
291	AVLROGCPHYSTREE MMIOTree;
292
293	/** Tree containing I/O port statistics (IOMIOPORTSTATS). */
294	AVLOIOPORTTREE IOPortStatTree;
295	/** Tree containing MMIO statistics (IOMMMIOSTATS). */
296	AVLOGCPHYSTREE MMIOStatTree;
297	} IOMTREES;
298	/** Pointer to the IOM trees. */
299	typedef IOMTREES *PIOMTREES;
300
301
302	/**
303	* Converts an IOM pointer into a VM pointer.
304	* @returns Pointer to the VM structure the PGM is part of.
305	* @param pIOM Pointer to IOM instance data.
306	*/
307	#define IOM2VM(pIOM) ( (PVM)((char*)pIOM - pIOM->offVM) )
308
309	/**
310	* IOM Data (part of VM)
311	*/
312	typedef struct IOM
313	{
314	/** Offset to the VM structure. */
315	RTINT offVM;
316
317	/** Pointer to the trees - RC ptr. */
318	RCPTRTYPE(PIOMTREES) pTreesRC;
319	/** Pointer to the trees - R3 ptr. */
320	R3PTRTYPE(PIOMTREES) pTreesR3;
321	/** Pointer to the trees - R0 ptr. */
322	R0PTRTYPE(PIOMTREES) pTreesR0;
323
324	/** The ring-0 address of IOMMMIOHandler. */
325	R0PTRTYPE(PFNPGMR0PHYSHANDLER) pfnMMIOHandlerR0;
326	/** The RC address of IOMMMIOHandler. */
327	RCPTRTYPE(PFNPGMGCPHYSHANDLER) pfnMMIOHandlerRC;
328	#if GC_ARCH_BITS == 64
329	RTRCPTR padding;
330	#endif
331
332	/** @name Caching of I/O Port and MMIO ranges and statistics.
333	* (Saves quite some time in rep outs/ins instruction emulation.)
334	* @{ */
335	R3PTRTYPE(PIOMIOPORTRANGER3) pRangeLastReadR3;
336	R3PTRTYPE(PIOMIOPORTRANGER3) pRangeLastWriteR3;
337	R3PTRTYPE(PIOMIOPORTSTATS) pStatsLastReadR3;
338	R3PTRTYPE(PIOMIOPORTSTATS) pStatsLastWriteR3;
339	R3PTRTYPE(PIOMMMIORANGE) pMMIORangeLastR3;
340	R3PTRTYPE(PIOMMMIOSTATS) pMMIOStatsLastR3;
341
342	R0PTRTYPE(PIOMIOPORTRANGER0) pRangeLastReadR0;
343	R0PTRTYPE(PIOMIOPORTRANGER0) pRangeLastWriteR0;
344	R0PTRTYPE(PIOMIOPORTSTATS) pStatsLastReadR0;
345	R0PTRTYPE(PIOMIOPORTSTATS) pStatsLastWriteR0;
346	R0PTRTYPE(PIOMMMIORANGE) pMMIORangeLastR0;
347	R0PTRTYPE(PIOMMMIOSTATS) pMMIOStatsLastR0;
348
349	RCPTRTYPE(PIOMIOPORTRANGERC) pRangeLastReadRC;
350	RCPTRTYPE(PIOMIOPORTRANGERC) pRangeLastWriteRC;
351	RCPTRTYPE(PIOMIOPORTSTATS) pStatsLastReadRC;
352	RCPTRTYPE(PIOMIOPORTSTATS) pStatsLastWriteRC;
353	RCPTRTYPE(PIOMMMIORANGE) pMMIORangeLastRC;
354	RCPTRTYPE(PIOMMMIOSTATS) pMMIOStatsLastRC;
355	/** @} */
356
357	/** @name I/O Port statistics.
358	* @{ */
359	STAMCOUNTER StatInstIn;
360	STAMCOUNTER StatInstOut;
361	STAMCOUNTER StatInstIns;
362	STAMCOUNTER StatInstOuts;
363	/** @} */
364
365	/** @name MMIO statistics.
366	* @{ */
367	STAMPROFILE StatRZMMIOHandler;
368	STAMCOUNTER StatRZMMIOFailures;
369
370	STAMPROFILE StatRZInstMov;
371	STAMPROFILE StatRZInstCmp;
372	STAMPROFILE StatRZInstAnd;
373	STAMPROFILE StatRZInstOr;
374	STAMPROFILE StatRZInstXor;
375	STAMPROFILE StatRZInstBt;
376	STAMPROFILE StatRZInstTest;
377	STAMPROFILE StatRZInstXchg;
378	STAMPROFILE StatRZInstStos;
379	STAMPROFILE StatRZInstLods;
380	#ifdef IOM_WITH_MOVS_SUPPORT
381	STAMPROFILEADV StatRZInstMovs;
382	STAMPROFILE StatRZInstMovsToMMIO;
383	STAMPROFILE StatRZInstMovsFromMMIO;
384	STAMPROFILE StatRZInstMovsMMIO;
385	#endif
386	STAMCOUNTER StatRZInstOther;
387
388	STAMCOUNTER StatRZMMIO1Byte;
389	STAMCOUNTER StatRZMMIO2Bytes;
390	STAMCOUNTER StatRZMMIO4Bytes;
391	STAMCOUNTER StatRZMMIO8Bytes;
392
393	STAMCOUNTER StatR3MMIOHandler;
394
395	RTUINT cMovsMaxBytes;
396	RTUINT cStosMaxBytes;
397	/** @} */
398	} IOM;
399	/** Pointer to IOM instance data. */
400	typedef IOM *PIOM;
401
402
403	__BEGIN_DECLS
404
405	#ifdef IN_IOM_R3
406	PIOMIOPORTSTATS iomR3IOPortStatsCreate(PVM pVM, RTIOPORT Port, const char *pszDesc);
407	PIOMMMIOSTATS iomR3MMIOStatsCreate(PVM pVM, RTGCPHYS GCPhys, const char *pszDesc);
408	#endif /* IN_IOM_R3 */
409
410	/**
411	* \#PF Handler callback for MMIO ranges.
412	*
413	* @returns VBox status code (appropriate for GC return).
414	*
415	* @param pVM VM Handle.
416	* @param uErrorCode CPU Error code.
417	* @param pRegFrame Trap register frame.
418	* @param pvFault The fault address (cr2).
419	* @param GCPhysFault The GC physical address corresponding to pvFault.
420	* @param pvUser Pointer to the MMIO range entry.
421	*/
422	IOMDECL(int) IOMMMIOHandler(PVM pVM, RTGCUINT uErrorCode, PCPUMCTXCORE pRegFrame, RTGCPTR pvFault, RTGCPHYS GCPhysFault, void *pvUser);
423
424	#ifdef IN_RING3
425	/**
426	* \#PF Handler callback for MMIO ranges.
427	*
428	* @returns VINF_SUCCESS if the handler have carried out the operation.
429	* @returns VINF_PGM_HANDLER_DO_DEFAULT if the caller should carry out the access operation.
430	* @param pVM VM Handle.
431	* @param GCPhys The physical address the guest is writing to.
432	* @param pvPhys The HC mapping of that address.
433	* @param pvBuf What the guest is reading/writing.
434	* @param cbBuf How much it's reading/writing.
435	* @param enmAccessType The access type.
436	* @param pvUser Pointer to the MMIO range entry.
437	*/
438	DECLCALLBACK(int) IOMR3MMIOHandler(PVM pVM, RTGCPHYS GCPhys, void pvPhys, void pvBuf, size_t cbBuf, PGMACCESSTYPE enmAccessType, void *pvUser);
439	#endif
440
441
442	/**
443	* Gets the I/O port range for the specified I/O port in the current context.
444	*
445	* @returns Pointer to I/O port range.
446	* @returns NULL if no port registered.
447	*
448	* @param pIOM IOM instance data.
449	* @param Port Port to lookup.
450	*/
451	DECLINLINE(CTX_SUFF(PIOMIOPORTRANGE)) iomIOPortGetRange(PIOM pIOM, RTIOPORT Port)
452	{
453	CTX_SUFF(PIOMIOPORTRANGE) pRange = (CTX_SUFF(PIOMIOPORTRANGE))RTAvlroIOPortRangeGet(&pIOM->CTX_SUFF(pTrees)->CTX_SUFF(IOPortTree), Port);
454	return pRange;
455	}
456
457
458	/**
459	* Gets the I/O port range for the specified I/O port in the HC.
460	*
461	* @returns Pointer to I/O port range.
462	* @returns NULL if no port registered.
463	*
464	* @param pIOM IOM instance data.
465	* @param Port Port to lookup.
466	*/
467	DECLINLINE(PIOMIOPORTRANGER3) iomIOPortGetRangeR3(PIOM pIOM, RTIOPORT Port)
468	{
469	PIOMIOPORTRANGER3 pRange = (PIOMIOPORTRANGER3)RTAvlroIOPortRangeGet(&pIOM->CTX_SUFF(pTrees)->IOPortTreeR3, Port);
470	return pRange;
471	}
472
473
474	/**
475	* Gets the MMIO range for the specified physical address in the current context.
476	*
477	* @returns Pointer to MMIO range.
478	* @returns NULL if address not in a MMIO range.
479	*
480	* @param pIOM IOM instance data.
481	* @param GCPhys Physical address to lookup.
482	*/
483	DECLINLINE(PIOMMMIORANGE) iomMMIOGetRange(PIOM pIOM, RTGCPHYS GCPhys)
484	{
485	PIOMMMIORANGE pRange = pIOM->CTX_SUFF(pMMIORangeLast);
486	if ( !pRange
487	\|\| GCPhys - pRange->GCPhys >= pRange->cb)
488	pIOM->CTX_SUFF(pMMIORangeLast) = pRange = (PIOMMMIORANGE)RTAvlroGCPhysRangeGet(&pIOM->CTX_SUFF(pTrees)->MMIOTree, GCPhys);
489	return pRange;
490	}
491
492
493	#ifdef VBOX_WITH_STATISTICS
494	/**
495	* Gets the MMIO statistics record.
496	*
497	* In ring-3 this will lazily create missing records, while in GC/R0 the caller has to
498	* return the appropriate status to defer the operation to ring-3.
499	*
500	* @returns Pointer to MMIO stats.
501	* @returns NULL if not found (R0/GC), or out of memory (R3).
502	*
503	* @param pIOM IOM instance data.
504	* @param GCPhys Physical address to lookup.
505	* @param pRange The MMIO range.
506	*/
507	DECLINLINE(PIOMMMIOSTATS) iomMMIOGetStats(PIOM pIOM, RTGCPHYS GCPhys, PIOMMMIORANGE pRange)
508	{
509	/* For large ranges, we'll put everything on the first byte. */
510	if (pRange->cb > PAGE_SIZE)
511	GCPhys = pRange->GCPhys;
512
513	PIOMMMIOSTATS pStats = pIOM->CTX_SUFF(pMMIOStatsLast);
514	if ( !pStats
515	\|\| pStats->Core.Key != GCPhys)
516	{
517	pStats = (PIOMMMIOSTATS)RTAvloGCPhysGet(&pIOM->CTX_SUFF(pTrees)->MMIOStatTree, GCPhys);
518	# ifdef IN_RING3
519	if (!pStats)
520	pStats = iomR3MMIOStatsCreate(IOM2VM(pIOM), GCPhys, pRange->pszDesc);
521	# endif
522	}
523	return pStats;
524	}
525	#endif
526
527	/* Disassembly helpers used in IOMAll.cpp & IOMAllMMIO.cpp */
528	bool iomGetRegImmData(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint64_t pu64Data, unsigned pcbSize);
529	bool iomSaveDataToReg(PDISCPUSTATE pCpu, PCOP_PARAMETER pParam, PCPUMCTXCORE pRegFrame, uint64_t u32Data);
530
531	__END_DECLS
532
533
534	#ifdef IN_RING3
535
536	#endif
537
538	/** @} */
539
540	#endif /* ___IOMInternal_h */

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

source: vbox/trunk/src/VBox/VMM/IOMInternal.h@ 12986

Download in other formats: