iom.h@ 88534

Last change on this file since 88534 was 85121, checked in by vboxsync, 4 years ago
iprt/cdefs.h: Refactored the typedef use of DECLCALLBACK as well as DECLCALLBACKMEMBER to wrap the whole expression, similar to the DECLR?CALLBACKMEMBER macros. This allows adding a throw() at the end when compiling with the VC++ compiler to indicate that the callbacks won't throw anything, so we can stop supressing the C5039 warning about passing functions that can potential throw C++ exceptions to extern C code that can't necessarily cope with such (unwind,++). Introduced a few _EX variations that allows specifying different/no calling convention too, as that's handy when dynamically resolving host APIs. Fixed numerous places missing DECLCALLBACK and such. Left two angry @todos regarding use of CreateThread. bugref:9794
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 25.0 KB

Line
1	/** @file
2	* IOM - Input / Output Monitor.
3	*/
4
5	/*
6	* Copyright (C) 2006-2020 Oracle Corporation
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*
16	* The contents of this file may alternatively be used under the terms
17	* of the Common Development and Distribution License Version 1.0
18	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19	* VirtualBox OSE distribution, in which case the provisions of the
20	* CDDL are applicable instead of those of the GPL.
21	*
22	* You may elect to license modified versions of this file under the
23	* terms and conditions of either the GPL or the CDDL or both.
24	*/
25
26	#ifndef VBOX_INCLUDED_vmm_iom_h
27	#define VBOX_INCLUDED_vmm_iom_h
28	#ifndef RT_WITHOUT_PRAGMA_ONCE
29	# pragma once
30	#endif
31
32	#include <VBox/types.h>
33	#include <VBox/dis.h>
34	#include <VBox/vmm/dbgf.h>
35
36	RT_C_DECLS_BEGIN
37
38
39	/** @defgroup grp_iom The Input / Ouput Monitor API
40	* @ingroup grp_vmm
41	* @{
42	*/
43
44	/** @def IOM_NO_PDMINS_CHECKS
45	* Until all devices have been fully adjusted to PDM style, the pPdmIns
46	* parameter is not checked by IOM.
47	* @todo Check this again, now.
48	*/
49	#define IOM_NO_PDMINS_CHECKS
50
51	/**
52	* Macro for checking if an I/O or MMIO emulation call succeeded.
53	*
54	* This macro shall only be used with the IOM APIs where it's mentioned
55	* in the return value description. And there it must be used to correctly
56	* determine if the call succeeded and things like the RIP needs updating.
57	*
58	*
59	* @returns Success indicator (true/false).
60	*
61	* @param rc The status code. This may be evaluated
62	* more than once!
63	*
64	* @remarks To avoid making assumptions about the layout of the
65	* VINF_EM_FIRST...VINF_EM_LAST range we're checking explicitly for
66	* each exact exception. However, for efficiency we ASSUME that the
67	* VINF_EM_LAST is smaller than most of the relevant status codes. We
68	* also ASSUME that the VINF_EM_RESCHEDULE_REM status code is the
69	* most frequent status code we'll enounter in this range.
70	*
71	* @todo Will have to add VINF_EM_DBG_HYPER_BREAKPOINT if the
72	* I/O port and MMIO breakpoints should trigger before
73	* the I/O is done. Currently, we don't implement these
74	* kind of breakpoints.
75	*/
76	#ifdef IN_RING3
77	# define IOM_SUCCESS(rc) ( (rc) == VINF_SUCCESS \
78	\|\| ( (rc) <= VINF_EM_LAST \
79	&& (rc) != VINF_EM_RESCHEDULE_REM \
80	&& (rc) >= VINF_EM_FIRST \
81	&& (rc) != VINF_EM_RESCHEDULE_RAW \
82	&& (rc) != VINF_EM_RESCHEDULE_HM \
83	) \
84	)
85	#else
86	# define IOM_SUCCESS(rc) ( (rc) == VINF_SUCCESS \
87	\|\| ( (rc) <= VINF_EM_LAST \
88	&& (rc) != VINF_EM_RESCHEDULE_REM \
89	&& (rc) >= VINF_EM_FIRST \
90	&& (rc) != VINF_EM_RESCHEDULE_RAW \
91	&& (rc) != VINF_EM_RESCHEDULE_HM \
92	) \
93	\|\| (rc) == VINF_IOM_R3_IOPORT_COMMIT_WRITE \
94	\|\| (rc) == VINF_IOM_R3_MMIO_COMMIT_WRITE \
95	)
96	#endif
97
98	/** @name IOMMMIO_FLAGS_XXX
99	* @{ */
100	/** Pass all reads thru unmodified. */
101	#define IOMMMIO_FLAGS_READ_PASSTHRU UINT32_C(0x00000000)
102	/** All read accesses are DWORD sized (32-bit). */
103	#define IOMMMIO_FLAGS_READ_DWORD UINT32_C(0x00000001)
104	/** All read accesses are DWORD (32-bit) or QWORD (64-bit) sized.
105	* Only accesses that are both QWORD sized and aligned are performed as QWORD.
106	* All other access will be done DWORD fashion (because it is way simpler). */
107	#define IOMMMIO_FLAGS_READ_DWORD_QWORD UINT32_C(0x00000002)
108	/** The read access mode mask. */
109	#define IOMMMIO_FLAGS_READ_MODE UINT32_C(0x00000003)
110
111	/** Pass all writes thru unmodified. */
112	#define IOMMMIO_FLAGS_WRITE_PASSTHRU UINT32_C(0x00000000)
113	/** All write accesses are DWORD (32-bit) sized and unspecified bytes are
114	* written as zero. */
115	#define IOMMMIO_FLAGS_WRITE_DWORD_ZEROED UINT32_C(0x00000010)
116	/** All write accesses are either DWORD (32-bit) or QWORD (64-bit) sized,
117	* missing bytes will be written as zero. Only accesses that are both QWORD
118	* sized and aligned are performed as QWORD, all other accesses will be done
119	* DWORD fashion (because it's way simpler). */
120	#define IOMMMIO_FLAGS_WRITE_DWORD_QWORD_ZEROED UINT32_C(0x00000020)
121	/** All write accesses are DWORD (32-bit) sized and unspecified bytes are
122	* read from the device first as DWORDs.
123	* @remarks This isn't how it happens on real hardware, but it allows
124	* simplifications of devices where reads doesn't change the device
125	* state in any way. */
126	#define IOMMMIO_FLAGS_WRITE_DWORD_READ_MISSING UINT32_C(0x00000030)
127	/** All write accesses are DWORD (32-bit) or QWORD (64-bit) sized and
128	* unspecified bytes are read from the device first as DWORDs. Only accesses
129	* that are both QWORD sized and aligned are performed as QWORD, all other
130	* accesses will be done DWORD fashion (because it's way simpler).
131	* @remarks This isn't how it happens on real hardware, but it allows
132	* simplifications of devices where reads doesn't change the device
133	* state in any way. */
134	#define IOMMMIO_FLAGS_WRITE_DWORD_QWORD_READ_MISSING UINT32_C(0x00000040)
135	/** All write accesses are DWORD (32-bit) sized and aligned, attempts at other
136	* accesses are ignored.
137	* @remarks E1000, APIC */
138	#define IOMMMIO_FLAGS_WRITE_ONLY_DWORD UINT32_C(0x00000050)
139	/** All write accesses are DWORD (32-bit) or QWORD (64-bit) sized and aligned,
140	* attempts at other accesses are ignored.
141	* @remarks Seemingly required by AHCI (although I doubt it's _really_
142	* required as EM/REM doesn't do the right thing in ring-3 anyway,
143	* esp. not in raw-mode). */
144	#define IOMMMIO_FLAGS_WRITE_ONLY_DWORD_QWORD UINT32_C(0x00000060)
145	/** The read access mode mask. */
146	#define IOMMMIO_FLAGS_WRITE_MODE UINT32_C(0x00000070)
147
148	/** Whether to do a DBGSTOP on complicated reads.
149	* What this includes depends on the read mode, but generally all misaligned
150	* reads as well as word and byte reads and maybe qword reads. */
151	#define IOMMMIO_FLAGS_DBGSTOP_ON_COMPLICATED_READ UINT32_C(0x00000100)
152	/** Whether to do a DBGSTOP on complicated writes.
153	* This depends on the write mode, but generally all writes where we have to
154	* supply bytes (zero them or read them). */
155	#define IOMMMIO_FLAGS_DBGSTOP_ON_COMPLICATED_WRITE UINT32_C(0x00000200)
156
157	/** Pass the absolute physical address (GC) to the callback rather than the
158	* relative one.
159	* @note New-style only, is implicit in old-style interface. */
160	#define IOMMMIO_FLAGS_ABS UINT32_C(0x00001000)
161
162	/** Mask of valid flags. */
163	#define IOMMMIO_FLAGS_VALID_MASK UINT32_C(0x00001373)
164	/** @} */
165
166	/**
167	* Checks whether the write mode allows aligned QWORD accesses to be passed
168	* thru to the device handler.
169	* @param a_fFlags The MMIO handler flags.
170	*/
171	#define IOMMMIO_DOES_WRITE_MODE_ALLOW_QWORD(a_fFlags) \
172	( ((a_fFlags) & IOMMMIO_FLAGS_WRITE_MODE) == IOMMMIO_FLAGS_WRITE_DWORD_QWORD_ZEROED \
173	\|\| ((a_fFlags) & IOMMMIO_FLAGS_WRITE_MODE) == IOMMMIO_FLAGS_WRITE_DWORD_QWORD_READ_MISSING \
174	\|\| ((a_fFlags) & IOMMMIO_FLAGS_WRITE_MODE) == IOMMMIO_FLAGS_WRITE_ONLY_DWORD_QWORD )
175
176
177	/**
178	* Port I/O Handler for IN operations.
179	*
180	* @returns VINF_SUCCESS or VINF_EM_*.
181	* @returns VERR_IOM_IOPORT_UNUSED if the port is really unused and a ~0 value should be returned.
182	*
183	* @param pDevIns The device instance.
184	* @param pvUser User argument.
185	* @param uPort Port number used for the IN operation.
186	* @param pu32 Where to store the result. This is always a 32-bit
187	* variable regardless of what @a cb might say.
188	* @param cb Number of bytes read.
189	* @remarks Caller enters the device critical section.
190	*/
191	typedef DECLCALLBACKTYPE(int, FNIOMIOPORTIN,(PPDMDEVINS pDevIns, void pvUser, RTIOPORT uPort, uint32_t pu32, unsigned cb));
192	/** Pointer to a FNIOMIOPORTIN(). */
193	typedef FNIOMIOPORTIN *PFNIOMIOPORTIN;
194
195	/**
196	* Port I/O Handler for string IN operations.
197	*
198	* @returns VINF_SUCCESS or VINF_EM_*.
199	* @returns VERR_IOM_IOPORT_UNUSED if the port is really unused and a ~0 value should be returned.
200	*
201	* @param pDevIns The device instance.
202	* @param pvUser User argument.
203	* @param uPort Port number used for the IN operation.
204	* @param pbDst Pointer to the destination buffer.
205	* @param pcTransfers Pointer to the number of transfer units to read, on
206	* return remaining transfer units.
207	* @param cb Size of the transfer unit (1, 2 or 4 bytes).
208	* @remarks Caller enters the device critical section.
209	*/
210	typedef DECLCALLBACKTYPE(int, FNIOMIOPORTINSTRING,(PPDMDEVINS pDevIns, void pvUser, RTIOPORT uPort, uint8_t pbDst,
211	uint32_t *pcTransfers, unsigned cb));
212	/** Pointer to a FNIOMIOPORTINSTRING(). */
213	typedef FNIOMIOPORTINSTRING *PFNIOMIOPORTINSTRING;
214
215	/**
216	* Port I/O Handler for OUT operations.
217	*
218	* @returns VINF_SUCCESS or VINF_EM_*.
219	*
220	* @param pDevIns The device instance.
221	* @param pvUser User argument.
222	* @param uPort Port number used for the OUT operation.
223	* @param u32 The value to output.
224	* @param cb The value size in bytes.
225	* @remarks Caller enters the device critical section.
226	*/
227	typedef DECLCALLBACKTYPE(int, FNIOMIOPORTOUT,(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT uPort, uint32_t u32, unsigned cb));
228	/** Pointer to a FNIOMIOPORTOUT(). */
229	typedef FNIOMIOPORTOUT *PFNIOMIOPORTOUT;
230
231	/**
232	* Port I/O Handler for string OUT operations.
233	*
234	* @returns VINF_SUCCESS or VINF_EM_*.
235	*
236	* @param pDevIns The device instance.
237	* @param pvUser User argument.
238	* @param uPort Port number used for the OUT operation.
239	* @param pbSrc Pointer to the source buffer.
240	* @param pcTransfers Pointer to the number of transfer units to write, on
241	* return remaining transfer units.
242	* @param cb Size of the transfer unit (1, 2 or 4 bytes).
243	* @remarks Caller enters the device critical section.
244	*/
245	typedef DECLCALLBACKTYPE(int, FNIOMIOPORTOUTSTRING,(PPDMDEVINS pDevIns, void pvUser, RTIOPORT uPort, const uint8_t pbSrc,
246	uint32_t *pcTransfers, unsigned cb));
247	/** Pointer to a FNIOMIOPORTOUTSTRING(). */
248	typedef FNIOMIOPORTOUTSTRING *PFNIOMIOPORTOUTSTRING;
249
250
251	/**
252	* Port I/O Handler for IN operations.
253	*
254	* @returns VINF_SUCCESS or VINF_EM_*.
255	* @returns VERR_IOM_IOPORT_UNUSED if the port is really unused and a ~0 value should be returned.
256	*
257	* @param pDevIns The device instance.
258	* @param pvUser User argument.
259	* @param offPort The port number if IOM_IOPORT_F_ABS is used, otherwise
260	* relative to the mapping base.
261	* @param pu32 Where to store the result. This is always a 32-bit
262	* variable regardless of what @a cb might say.
263	* @param cb Number of bytes read.
264	* @remarks Caller enters the device critical section.
265	*/
266	typedef DECLCALLBACKTYPE(VBOXSTRICTRC, FNIOMIOPORTNEWIN,(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort,
267	uint32_t *pu32, unsigned cb));
268	/** Pointer to a FNIOMIOPORTNEWIN(). */
269	typedef FNIOMIOPORTNEWIN *PFNIOMIOPORTNEWIN;
270
271	/**
272	* Port I/O Handler for string IN operations.
273	*
274	* @returns VINF_SUCCESS or VINF_EM_*.
275	* @returns VERR_IOM_IOPORT_UNUSED if the port is really unused and a ~0 value should be returned.
276	*
277	* @param pDevIns The device instance.
278	* @param pvUser User argument.
279	* @param offPort The port number if IOM_IOPORT_F_ABS is used, otherwise
280	* relative to the mapping base.
281	* @param pbDst Pointer to the destination buffer.
282	* @param pcTransfers Pointer to the number of transfer units to read, on
283	* return remaining transfer units.
284	* @param cb Size of the transfer unit (1, 2 or 4 bytes).
285	* @remarks Caller enters the device critical section.
286	*/
287	typedef DECLCALLBACKTYPE(VBOXSTRICTRC, FNIOMIOPORTNEWINSTRING,(PPDMDEVINS pDevIns, void pvUser, RTIOPORT offPort, uint8_t pbDst,
288	uint32_t *pcTransfers, unsigned cb));
289	/** Pointer to a FNIOMIOPORTNEWINSTRING(). */
290	typedef FNIOMIOPORTNEWINSTRING *PFNIOMIOPORTNEWINSTRING;
291
292	/**
293	* Port I/O Handler for OUT operations.
294	*
295	* @returns VINF_SUCCESS or VINF_EM_*.
296	*
297	* @param pDevIns The device instance.
298	* @param pvUser User argument.
299	* @param offPort The port number if IOM_IOPORT_F_ABS is used, otherwise
300	* relative to the mapping base.
301	* @param u32 The value to output.
302	* @param cb The value size in bytes.
303	* @remarks Caller enters the device critical section.
304	*/
305	typedef DECLCALLBACKTYPE(VBOXSTRICTRC, FNIOMIOPORTNEWOUT,(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort,
306	uint32_t u32, unsigned cb));
307	/** Pointer to a FNIOMIOPORTNEWOUT(). */
308	typedef FNIOMIOPORTNEWOUT *PFNIOMIOPORTNEWOUT;
309
310	/**
311	* Port I/O Handler for string OUT operations.
312	*
313	* @returns VINF_SUCCESS or VINF_EM_*.
314	*
315	* @param pDevIns The device instance.
316	* @param pvUser User argument.
317	* @param offPort The port number if IOM_IOPORT_F_ABS is used, otherwise
318	* relative to the mapping base.
319	* @param pbSrc Pointer to the source buffer.
320	* @param pcTransfers Pointer to the number of transfer units to write, on
321	* return remaining transfer units.
322	* @param cb Size of the transfer unit (1, 2 or 4 bytes).
323	* @remarks Caller enters the device critical section.
324	*/
325	typedef DECLCALLBACKTYPE(VBOXSTRICTRC, FNIOMIOPORTNEWOUTSTRING,(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort,
326	const uint8_t pbSrc, uint32_t pcTransfers, unsigned cb));
327	/** Pointer to a FNIOMIOPORTNEWOUTSTRING(). */
328	typedef FNIOMIOPORTNEWOUTSTRING *PFNIOMIOPORTNEWOUTSTRING;
329
330	/**
331	* I/O port description.
332	*
333	* If both pszIn and pszOut are NULL, the entry is considered a terminator.
334	*/
335	typedef struct IOMIOPORTDESC
336	{
337	/** Brief description / name of the IN port. */
338	const char *pszIn;
339	/** Brief description / name of the OUT port. */
340	const char *pszOut;
341	/** Detailed description of the IN port, optional. */
342	const char *pszInDetail;
343	/** Detialed description of the OUT port, optional. */
344	const char *pszOutDetail;
345	} IOMIOPORTDESC;
346	/** Pointer to an I/O port description. */
347	typedef IOMIOPORTDESC const *PCIOMIOPORTDESC;
348
349
350	/**
351	* Memory mapped I/O Handler for read operations.
352	*
353	* @returns VBox status code.
354	*
355	* @param pDevIns The device instance.
356	* @param pvUser User argument.
357	* @param GCPhysAddr Physical address (in GC) where the read starts.
358	* @param pv Where to store the result.
359	* @param cb Number of bytes read.
360	* @remarks Caller enters the device critical section.
361	*/
362	typedef DECLCALLBACKTYPE(int, FNIOMMMIOREAD,(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void pv, unsigned cb));
363	/** Pointer to a FNIOMMMIOREAD(). */
364	typedef FNIOMMMIOREAD *PFNIOMMMIOREAD;
365
366	/**
367	* Memory mapped I/O Handler for write operations.
368	*
369	* @returns VBox status code.
370	*
371	* @param pDevIns The device instance.
372	* @param pvUser User argument.
373	* @param GCPhysAddr Physical address (in GC) where the read starts.
374	* @param pv Where to fetch the result.
375	* @param cb Number of bytes to write.
376	* @remarks Caller enters the device critical section.
377	*/
378	typedef DECLCALLBACKTYPE(int, FNIOMMMIOWRITE,(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS GCPhysAddr, void const pv, unsigned cb));
379	/** Pointer to a FNIOMMMIOWRITE(). */
380	typedef FNIOMMMIOWRITE *PFNIOMMMIOWRITE;
381
382	/**
383	* Memory mapped I/O Handler for memset operations, actually for REP STOS* instructions handling.
384	*
385	* @returns VBox status code.
386	*
387	* @param pDevIns The device instance.
388	* @param pvUser User argument.
389	* @param GCPhysAddr Physical address (in GC) where the write starts.
390	* @param u32Item Byte/Word/Dword data to fill.
391	* @param cbItem Size of data in u32Item parameter, restricted to 1/2/4 bytes.
392	* @param cItems Number of iterations.
393	* @remarks Caller enters the device critical section.
394	*/
395	typedef DECLCALLBACKTYPE(int, FNIOMMMIOFILL,(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS GCPhysAddr,
396	uint32_t u32Item, unsigned cbItem, unsigned cItems));
397	/** Pointer to a FNIOMMMIOFILL(). */
398	typedef FNIOMMMIOFILL *PFNIOMMMIOFILL;
399
400
401	/**
402	* Memory mapped I/O Handler for read operations.
403	*
404	* @returns Strict VBox status code.
405	*
406	* @param pDevIns The device instance.
407	* @param pvUser User argument.
408	* @param off Offset into the mapping of the read,
409	* or the physical address if IOMMMIO_FLAGS_ABS is active.
410	* @param pv Where to store the result.
411	* @param cb Number of bytes read.
412	* @remarks Caller enters the device critical section.
413	*/
414	typedef DECLCALLBACKTYPE(VBOXSTRICTRC, FNIOMMMIONEWREAD,(PPDMDEVINS pDevIns, void pvUser, RTGCPHYS off, void pv, uint32_t cb));
415	/** Pointer to a FNIOMMMIONEWREAD(). */
416	typedef FNIOMMMIONEWREAD *PFNIOMMMIONEWREAD;
417
418	/**
419	* Memory mapped I/O Handler for write operations.
420	*
421	* @returns Strict VBox status code.
422	*
423	* @param pDevIns The device instance.
424	* @param pvUser User argument.
425	* @param off Offset into the mapping of the write,
426	* or the physical address if IOMMMIO_FLAGS_ABS is active.
427	* @param pv Where to fetch the result.
428	* @param cb Number of bytes to write.
429	* @remarks Caller enters the device critical section.
430	*/
431	typedef DECLCALLBACKTYPE(VBOXSTRICTRC, FNIOMMMIONEWWRITE,(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off,
432	void const *pv, uint32_t cb));
433	/** Pointer to a FNIOMMMIONEWWRITE(). */
434	typedef FNIOMMMIONEWWRITE *PFNIOMMMIONEWWRITE;
435
436	/**
437	* Memory mapped I/O Handler for memset operations, actually for REP STOS* instructions handling.
438	*
439	* @returns Strict VBox status code.
440	*
441	* @param pDevIns The device instance.
442	* @param pvUser User argument.
443	* @param off Offset into the mapping of the fill,
444	* or the physical address if IOMMMIO_FLAGS_ABS is active.
445	* @param u32Item Byte/Word/Dword data to fill.
446	* @param cbItem Size of data in u32Item parameter, restricted to 1/2/4 bytes.
447	* @param cItems Number of iterations.
448	* @remarks Caller enters the device critical section.
449	*/
450	typedef DECLCALLBACKTYPE(VBOXSTRICTRC, FNIOMMMIONEWFILL,(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off,
451	uint32_t u32Item, uint32_t cbItem, uint32_t cItems));
452	/** Pointer to a FNIOMMMIONEWFILL(). */
453	typedef FNIOMMMIONEWFILL *PFNIOMMMIONEWFILL;
454
455	VMMDECL(VBOXSTRICTRC) IOMIOPortRead(PVMCC pVM, PVMCPU pVCpu, RTIOPORT Port, uint32_t *pu32Value, size_t cbValue);
456	VMMDECL(VBOXSTRICTRC) IOMIOPortWrite(PVMCC pVM, PVMCPU pVCpu, RTIOPORT Port, uint32_t u32Value, size_t cbValue);
457	VMM_INT_DECL(VBOXSTRICTRC) IOMIOPortReadString(PVMCC pVM, PVMCPU pVCpu, RTIOPORT Port, void *pvDst,
458	uint32_t *pcTransfers, unsigned cb);
459	VMM_INT_DECL(VBOXSTRICTRC) IOMIOPortWriteString(PVMCC pVM, PVMCPU pVCpu, RTIOPORT uPort, void const *pvSrc,
460	uint32_t *pcTransfers, unsigned cb);
461	VMMDECL(VBOXSTRICTRC) IOMMMIORead(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, uint32_t *pu32Value, size_t cbValue);
462	VMMDECL(VBOXSTRICTRC) IOMMMIOWrite(PVM pVM, PVMCPU pVCpu, RTGCPHYS GCPhys, uint32_t u32Value, size_t cbValue);
463	VMM_INT_DECL(VBOXSTRICTRC) IOMR0MmioPhysHandler(PVMCC pVM, PVMCPUCC pVCpu, uint32_t uErrorCode, RTGCPHYS GCPhysFault);
464	VMMDECL(int) IOMMmioMapMmio2Page(PVMCC pVM, PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS offRegion,
465	uint64_t hMmio2, RTGCPHYS offMmio2, uint64_t fPageFlags);
466	VMMR0_INT_DECL(int) IOMR0MmioMapMmioHCPage(PVMCC pVM, PVMCPUCC pVCpu, RTGCPHYS GCPhys, RTHCPHYS HCPhys, uint64_t fPageFlags);
467	VMMDECL(int) IOMMmioResetRegion(PVMCC pVM, PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion);
468
469
470	/** @name IOM_IOPORT_F_XXX - Flags for IOMR3IoPortCreate() and PDMDevHlpIoPortCreateEx().
471	* @{ */
472	/** Pass the absolute I/O port to the callback rather than the relative one. */
473	#define IOM_IOPORT_F_ABS RT_BIT_32(0)
474	/** Valid flags for IOMR3IoPortCreate(). */
475	#define IOM_IOPORT_F_VALID_MASK UINT32_C(0x00000001)
476	/** @} */
477
478	#ifdef IN_RING3
479	/** @defgroup grp_iom_r3 The IOM Host Context Ring-3 API
480	* @{
481	*/
482	VMMR3_INT_DECL(int) IOMR3Init(PVM pVM);
483	VMMR3_INT_DECL(int) IOMR3InitCompleted(PVM pVM, VMINITCOMPLETED enmWhat);
484	VMMR3_INT_DECL(void) IOMR3Reset(PVM pVM);
485	VMMR3_INT_DECL(void) IOMR3Relocate(PVM pVM, RTGCINTPTR offDelta);
486	VMMR3_INT_DECL(int) IOMR3Term(PVM pVM);
487
488	VMMR3_INT_DECL(int) IOMR3IoPortCreate(PVM pVM, PPDMDEVINS pDevIns, RTIOPORT cPorts, uint32_t fFlags, PPDMPCIDEV pPciDev,
489	uint32_t iPciRegion, PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
490	PFNIOMIOPORTNEWOUTSTRING pfnOutStr, PFNIOMIOPORTNEWINSTRING pfnInStr, RTR3PTR pvUser,
491	const char *pszDesc, PCIOMIOPORTDESC paExtDescs, PIOMIOPORTHANDLE phIoPorts);
492	VMMR3_INT_DECL(int) IOMR3IoPortMap(PVM pVM, PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts, RTIOPORT Port);
493	VMMR3_INT_DECL(int) IOMR3IoPortUnmap(PVM pVM, PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts);
494	VMMR3_INT_DECL(int) IOMR3IoPortValidateHandle(PVM pVM, PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts);
495	VMMR3_INT_DECL(uint32_t) IOMR3IoPortGetMappingAddress(PVM pVM, PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts);
496
497	VMMR3_INT_DECL(int) IOMR3MmioCreate(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS cbRegion, uint32_t fFlags, PPDMPCIDEV pPciDev,
498	uint32_t iPciRegion, PFNIOMMMIONEWWRITE pfnWrite, PFNIOMMMIONEWREAD pfnRead,
499	PFNIOMMMIONEWFILL pfnFill, void pvUser, const char pszDesc, PIOMMMIOHANDLE phRegion);
500	VMMR3_INT_DECL(int) IOMR3MmioMap(PVM pVM, PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS GCPhys);
501	VMMR3_INT_DECL(int) IOMR3MmioUnmap(PVM pVM, PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion);
502	VMMR3_INT_DECL(int) IOMR3MmioReduce(PVM pVM, PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, RTGCPHYS cbRegion);
503	VMMR3_INT_DECL(int) IOMR3MmioValidateHandle(PVM pVM, PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion);
504	VMMR3_INT_DECL(RTGCPHYS) IOMR3MmioGetMappingAddress(PVM pVM, PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion);
505
506	VMMR3_INT_DECL(VBOXSTRICTRC) IOMR3ProcessForceFlag(PVM pVM, PVMCPU pVCpu, VBOXSTRICTRC rcStrict);
507
508	VMMR3_INT_DECL(void) IOMR3NotifyBreakpointCountChange(PVM pVM, bool fPortIo, bool fMmio);
509	VMMR3_INT_DECL(void) IOMR3NotifyDebugEventChange(PVM pVM, DBGFEVENT enmEvent, bool fEnabled);
510	/** @} */
511	#endif /* IN_RING3 */
512
513
514	#if defined(IN_RING0) \|\| defined(DOXYGEN_RUNNING)
515	/** @defgroup grpm_iom_r0 The IOM Host Context Ring-0 API
516	* @{ */
517	VMMR0_INT_DECL(void) IOMR0InitPerVMData(PGVM pGVM);
518	VMMR0_INT_DECL(void) IOMR0CleanupVM(PGVM pGVM);
519
520	VMMR0_INT_DECL(int) IOMR0IoPortSetUpContext(PGVM pGVM, PPDMDEVINS pDevIns, IOMIOPORTHANDLE hIoPorts,
521	PFNIOMIOPORTNEWOUT pfnOut, PFNIOMIOPORTNEWIN pfnIn,
522	PFNIOMIOPORTNEWOUTSTRING pfnOutStr, PFNIOMIOPORTNEWINSTRING pfnInStr, void *pvUser);
523	VMMR0_INT_DECL(int) IOMR0IoPortGrowRegistrationTables(PGVM pGVM, uint64_t cMinEntries);
524	VMMR0_INT_DECL(int) IOMR0IoPortGrowStatisticsTable(PGVM pGVM, uint64_t cMinEntries);
525	VMMR0_INT_DECL(int) IOMR0IoPortSyncStatisticsIndices(PGVM pGVM);
526
527	VMMR0_INT_DECL(int) IOMR0MmioSetUpContext(PGVM pGVM, PPDMDEVINS pDevIns, IOMMMIOHANDLE hRegion, PFNIOMMMIONEWWRITE pfnWrite,
528	PFNIOMMMIONEWREAD pfnRead, PFNIOMMMIONEWFILL pfnFill, void *pvUser);
529	VMMR0_INT_DECL(int) IOMR0MmioGrowRegistrationTables(PGVM pGVM, uint64_t cMinEntries);
530	VMMR0_INT_DECL(int) IOMR0MmioGrowStatisticsTable(PGVM pGVM, uint64_t cMinEntries);
531	VMMR0_INT_DECL(int) IOMR0MmioSyncStatisticsIndices(PGVM pGVM);
532
533	/** @} */
534	#endif /* IN_RING0 \|\| DOXYGEN_RUNNING */
535
536	/** @} */
537
538	RT_C_DECLS_END
539
540	#endif /* !VBOX_INCLUDED_vmm_iom_h */
541

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

source: vbox/trunk/include/VBox/vmm/iom.h@ 88534

Download in other formats: