PDMInternal.h@ 5458

Last change on this file since 5458 was 4787, checked in by vboxsync, 17 years ago
Eliminated HCPTRTYPE and replaced with R3R0PTRTYPE where necessary.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 31.7 KB

Line
1	/* $Id: PDMInternal.h 4787 2007-09-14 09:08:56Z vboxsync $ */
2	/** @file
3	* PDM - Internal header file.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 innotek GmbH
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 as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#ifndef ___PDMInternal_h
19	#define ___PDMInternal_h
20
21	#include <VBox/cdefs.h>
22	#include <VBox/types.h>
23	#include <VBox/param.h>
24	#include <VBox/cfgm.h>
25	#include <VBox/stam.h>
26	#include <iprt/critsect.h>
27	#ifdef IN_RING3
28	# include <iprt/thread.h>
29	#endif
30
31	__BEGIN_DECLS
32
33
34	/** @defgroup grp_pdm_int Internal
35	* @ingroup grp_pdm
36	* @internal
37	* @{
38	*/
39
40	/*******************************************************************************
41	* Structures and Typedefs *
42	*******************************************************************************/
43
44	/** Pointer to a PDM Device. */
45	typedef struct PDMDEV *PPDMDEV;
46	/** Pointer to a pointer to a PDM Device. */
47	typedef PPDMDEV *PPPDMDEV;
48
49	/** Pointer to a PDM USB Device. */
50	typedef struct PDMUSB *PPDMUSB;
51	/** Pointer to a pointer to a PDM USB Device. */
52	typedef PPDMUSB *PPPDMUSB;
53
54	/** Pointer to a PDM Driver. */
55	typedef struct PDMDRV *PPDMDRV;
56	/** Pointer to a pointer to a PDM Driver. */
57	typedef PPDMDRV *PPPDMDRV;
58
59	/** Pointer to a PDM Logical Unit. */
60	typedef struct PDMLUN *PPDMLUN;
61	/** Pointer to a pointer to a PDM Logical Unit. */
62	typedef PPDMLUN *PPPDMLUN;
63
64	/** Pointer to a PDM PCI Bus instance. */
65	typedef struct PDMPCIBUS *PPDMPCIBUS;
66	/** Pointer to a DMAC instance. */
67	typedef struct PDMDMAC *PPDMDMAC;
68	/** Pointer to a RTC instance. */
69	typedef struct PDMRTC *PPDMRTC;
70
71	/** Pointer to an USB HUB registration record. */
72	typedef struct PDMUSBHUB *PPDMUSBHUB;
73
74	/**
75	* Private device instance data.
76	*/
77	typedef struct PDMDEVINSINT
78	{
79	/** Pointer to the next instance (HC Ptr).
80	* (Head is pointed to by PDM::pDevInstances.) */
81	R3PTRTYPE(PPDMDEVINS) pNextHC;
82	/** Pointer to the next per device instance (HC Ptr).
83	* (Head is pointed to by PDMDEV::pInstances.) */
84	R3PTRTYPE(PPDMDEVINS) pPerDeviceNextHC;
85
86	/** Pointer to device structure - HC Ptr. */
87	R3PTRTYPE(PPDMDEV) pDevHC;
88
89	/** Pointer to the VM this instance was created for - HC Ptr. */
90	R3R0PTRTYPE(PVM) pVMHC;
91	/** Pointer to the list of logical units associated with the device. (FIFO) */
92	R3PTRTYPE(PPDMLUN) pLunsHC;
93	/** Configuration handle to the instance node. */
94	R3PTRTYPE(PCFGMNODE) pCfgHandle;
95	/** HC pointer to associated PCI device structure. */
96	R3R0PTRTYPE(struct PCIDevice *) pPciDeviceHC;
97	/** HC pointer to associated PCI bus structure. */
98	R3R0PTRTYPE(PPDMPCIBUS) pPciBusHC;
99
100	/** GC pointer to associated PCI device structure. */
101	GCPTRTYPE(struct PCIDevice *) pPciDeviceGC;
102	/** Pointer to the VM this instance was created for - GC Ptr. */
103	GCPTRTYPE(PVM) pVMGC;
104	/** GC pointer to associated PCI bus structure. */
105	GCPTRTYPE(PPDMPCIBUS) pPciBusGC;
106	#if GC_ARCH_BITS == 32
107	uint32_t Alignment0;
108	#endif
109	} PDMDEVINSINT;
110
111
112	/**
113	* Private USB device instance data.
114	*/
115	typedef struct PDMUSBINSINT
116	{
117	/** Pointer to the next instance.
118	* (Head is pointed to by PDM::pUsbInstances.) */
119	R3PTRTYPE(PPDMUSBINS) pNext;
120	/** Pointer to the next per USB device instance.
121	* (Head is pointed to by PDMUSB::pInstances.) */
122	R3PTRTYPE(PPDMUSBINS) pPerDeviceNext;
123
124	/** Pointer to device structure. */
125	R3PTRTYPE(PPDMUSB) pUsb;
126
127	/** Pointer to the VM this instance was created for. */
128	PVMR3 pVM;
129	/** Pointer to the list of logical units associated with the device. (FIFO) */
130	R3PTRTYPE(PPDMLUN) pLuns;
131	/** The per instance device configuration. */
132	R3PTRTYPE(PCFGMNODE) pCfg;
133	/** The global device configuration. */
134	R3PTRTYPE(PCFGMNODE) pCfgGlobal;
135
136	/** Pointer to the USB hub this device is connected to. */
137	R3PTRTYPE(PPDMUSBHUB) pHub;
138	/** The port number that we're connected to. */
139	uint32_t iPort;
140	#if HC_ARCH_BITS == 64
141	uint32_t Alignment0;
142	#endif
143	} PDMUSBINSINT;
144
145
146	/**
147	* Private driver instance data.
148	*/
149	typedef struct PDMDRVINSINT
150	{
151	/** Pointer to the driver instance above.
152	* This is NULL for the topmost drive. */
153	PPDMDRVINS pUp;
154	/** Pointer to the driver instance below.
155	* This is NULL for the bottommost driver. */
156	PPDMDRVINS pDown;
157	/** Pointer to the logical unit this driver chained on. */
158	PPDMLUN pLun;
159	/** Pointer to driver structure from which this was instantiated. */
160	PPDMDRV pDrv;
161	/** Pointer to the VM this instance was created for. */
162	PVM pVM;
163	/** Flag indicating that the driver is being detached and destroyed.
164	* (Helps detect potential recursive detaching.) */
165	bool fDetaching;
166	/** Configuration handle to the instance node. */
167	PCFGMNODE pCfgHandle;
168
169	} PDMDRVINSINT;
170
171
172	/**
173	* Private critical section data.
174	*/
175	typedef struct PDMCRITSECTINT
176	{
177	/** The critical section core which is shared with IPRT. */
178	RTCRITSECT Core;
179	/** Pointer to the next critical section.
180	* This chain is used for relocating pVMGC and device cleanup. */
181	R3PTRTYPE(struct PDMCRITSECTINT *) pNext;
182	/** Owner identifier.
183	* This is pDevIns if the owner is a device. Similarily for a driver or service.
184	* PDMR3CritSectInit() sets this to point to the critsect itself. */
185	RTR3PTR pvKey;
186	/** Pointer to the VM - R3Ptr. */
187	R3PTRTYPE(PVM) pVMR3;
188	/** Pointer to the VM - R0Ptr. */
189	R0PTRTYPE(PVM) pVMR0;
190	/** Pointer to the VM - GCPtr. */
191	GCPTRTYPE(PVM) pVMGC;
192	#if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 32
193	uint32_t padding;
194	#endif
195	/** Event semaphore that is scheduled to be signaled upon leaving the
196	* critical section. This is Ring-3 only of course. */
197	RTSEMEVENT EventToSignal;
198	/** R0/GC lock contention. */
199	STAMCOUNTER StatContentionR0GCLock;
200	/** R0/GC unlock contention. */
201	STAMCOUNTER StatContentionR0GCUnlock;
202	/** R3 lock contention. */
203	STAMCOUNTER StatContentionR3;
204	/** Profiling the time the section is locked. */
205	STAMPROFILEADV StatLocked;
206	} PDMCRITSECTINT, *PPDMCRITSECTINT;
207
208
209	/**
210	* The usual device/driver/internal/external stuff.
211	*/
212	typedef enum
213	{
214	/** The usual invalid entry. */
215	PDMTHREADTYPE_INVALID = 0,
216	/** Device type. */
217	PDMTHREADTYPE_DEVICE,
218	/** USB Device type. */
219	PDMTHREADTYPE_USB,
220	/** Driver type. */
221	PDMTHREADTYPE_DRIVER,
222	/** Internal type. */
223	PDMTHREADTYPE_INTERNAL,
224	/** External type. */
225	PDMTHREADTYPE_EXTERNAL,
226	/** The usual 32-bit hack. */
227	PDMTHREADTYPE_32BIT_HACK = 0x7fffffff
228	} PDMTHREADTYPE;
229
230
231	/**
232	* The internal structure for the thread.
233	*/
234	typedef struct PDMTHREADINT
235	{
236	/** The VM pointer. */
237	PVMR3 pVM;
238	/** The event semaphore the thread blocks on. */
239	RTSEMEVENTMULTI BlockEvent;
240	/** Pointer to the next thread. */
241	R3PTRTYPE(struct PDMTHREAD *) pNext;
242	/** The thread type. */
243	PDMTHREADTYPE enmType;
244	} PDMTHREADINT;
245
246
247
248	/* Must be included after PDMDEVINSINT is defined. */
249	#define PDMDEVINSINT_DECLARED
250	#define PDMUSBINSINT_DECLARED
251	#define PDMDRVINSINT_DECLARED
252	#define PDMCRITSECTINT_DECLARED
253	#define PDMTHREADINT_DECLARED
254	#ifdef ___VBox_pdm_h
255	# error "Invalid header PDM order. Include PDMInternal.h before VBox/pdm.h!"
256	#endif
257	__END_DECLS
258	#include <VBox/pdm.h>
259	__BEGIN_DECLS
260
261	/**
262	* PDM Logical Unit.
263	*
264	* This typically the representation of a physical port on a
265	* device, like for instance the PS/2 keyboard port on the
266	* keyboard controller device. The LUNs are chained on the
267	* device the belong to (PDMDEVINSINT::pLunsHC).
268	*/
269	typedef struct PDMLUN
270	{
271	/** The LUN - The Logical Unit Number. */
272	RTUINT iLun;
273	/** Pointer to the next LUN. */
274	PPDMLUN pNext;
275	/** Pointer to the top driver in the driver chain. */
276	PPDMDRVINS pTop;
277	/** Pointer to the device instance which the LUN belongs to.
278	* Either this is set or pUsbIns is set. Both is never set at the same time. */
279	PPDMDEVINS pDevIns;
280	/** Pointer to the USB device instance which the LUN belongs to. */
281	PPDMUSBINS pUsbIns;
282	/** Pointer to the device base interface. */
283	PPDMIBASE pBase;
284	/** Description of this LUN. */
285	const char *pszDesc;
286	} PDMLUN;
287
288
289	/**
290	* PDM Device.
291	*/
292	typedef struct PDMDEV
293	{
294	/** Pointer to the next device (HC Ptr). */
295	R3PTRTYPE(PPDMDEV) pNext;
296	/** Device name length. (search optimization) */
297	RTUINT cchName;
298	/** Registration structure. */
299	R3PTRTYPE(const struct PDMDEVREG *) pDevReg;
300	/** Number of instances. */
301	RTUINT cInstances;
302	/** Pointer to chain of instances (HC Ptr). */
303	R3PTRTYPE(PPDMDEVINS) pInstances;
304	} PDMDEV;
305
306
307	/**
308	* PDM USB Device.
309	*/
310	typedef struct PDMUSB
311	{
312	/** Pointer to the next device (R3 Ptr). */
313	R3PTRTYPE(PPDMUSB) pNext;
314	/** Device name length. (search optimization) */
315	RTUINT cchName;
316	/** Registration structure. */
317	R3PTRTYPE(const struct PDMUSBREG *) pUsbReg;
318	/** Next instance number. */
319	RTUINT iNextInstance;
320	/** Pointer to chain of instances (R3 Ptr). */
321	R3PTRTYPE(PPDMUSBINS) pInstances;
322	} PDMUSB;
323
324
325	/**
326	* PDM Driver.
327	*/
328	typedef struct PDMDRV
329	{
330	/** Pointer to the next device. */
331	PPDMDRV pNext;
332	/** Registration structure. */
333	const struct PDMDRVREG * pDrvReg;
334	/** Number of instances. */
335	RTUINT cInstances;
336	} PDMDRV;
337
338
339	/**
340	* PDM registered PIC device.
341	*/
342	typedef struct PDMPIC
343	{
344	/** Pointer to the PIC device instance - HC. */
345	R3PTRTYPE(PPDMDEVINS) pDevInsR3;
346	/** @copydoc PDMPICREG::pfnSetIrqHC */
347	DECLR3CALLBACKMEMBER(void, pfnSetIrqR3,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
348	/** @copydoc PDMPICREG::pfnGetInterruptHC */
349	DECLR3CALLBACKMEMBER(int, pfnGetInterruptR3,(PPDMDEVINS pDevIns));
350
351	/** Pointer to the PIC device instance - R0. */
352	R0PTRTYPE(PPDMDEVINS) pDevInsR0;
353	/** @copydoc PDMPICREG::pfnSetIrqHC */
354	DECLR0CALLBACKMEMBER(void, pfnSetIrqR0,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
355	/** @copydoc PDMPICREG::pfnGetInterruptHC */
356	DECLR0CALLBACKMEMBER(int, pfnGetInterruptR0,(PPDMDEVINS pDevIns));
357
358	/** Pointer to the PIC device instance - GC. */
359	GCPTRTYPE(PPDMDEVINS) pDevInsGC;
360	/** @copydoc PDMPICREG::pfnSetIrqHC */
361	DECLGCCALLBACKMEMBER(void, pfnSetIrqGC,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
362	/** @copydoc PDMPICREG::pfnGetInterruptHC */
363	DECLGCCALLBACKMEMBER(int, pfnGetInterruptGC,(PPDMDEVINS pDevIns));
364	#if GC_ARCH_BITS == 32
365	RTGCPTR GCPtrPadding; /*< Alignment padding. /
366	#endif
367	} PDMPIC;
368
369
370	/**
371	* PDM registered APIC device.
372	*/
373	typedef struct PDMAPIC
374	{
375	/** Pointer to the APIC device instance - HC Ptr. */
376	PPDMDEVINSR3 pDevInsR3;
377	/** @copydoc PDMAPICREG::pfnGetInterruptHC */
378	DECLR3CALLBACKMEMBER(int, pfnGetInterruptR3,(PPDMDEVINS pDevIns));
379	/** @copydoc PDMAPICREG::pfnSetBaseHC */
380	DECLR3CALLBACKMEMBER(void, pfnSetBaseR3,(PPDMDEVINS pDevIns, uint64_t u64Base));
381	/** @copydoc PDMAPICREG::pfnGetBaseHC */
382	DECLR3CALLBACKMEMBER(uint64_t, pfnGetBaseR3,(PPDMDEVINS pDevIns));
383	/** @copydoc PDMAPICREG::pfnSetTPRHC */
384	DECLR3CALLBACKMEMBER(void, pfnSetTPRR3,(PPDMDEVINS pDevIns, uint8_t u8TPR));
385	/** @copydoc PDMAPICREG::pfnGetTPRHC */
386	DECLR3CALLBACKMEMBER(uint8_t, pfnGetTPRR3,(PPDMDEVINS pDevIns));
387	/** @copydoc PDMAPICREG::pfnBusDeliverHC */
388	DECLR3CALLBACKMEMBER(void, pfnBusDeliverR3,(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
389	uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode));
390
391	/** Pointer to the PIC device instance - R0. */
392	R0PTRTYPE(PPDMDEVINS) pDevInsR0;
393	/** @copydoc PDMAPICREG::pfnGetInterruptHC */
394	DECLR0CALLBACKMEMBER(int, pfnGetInterruptR0,(PPDMDEVINS pDevIns));
395	/** @copydoc PDMAPICREG::pfnSetBaseHC */
396	DECLR0CALLBACKMEMBER(void, pfnSetBaseR0,(PPDMDEVINS pDevIns, uint64_t u64Base));
397	/** @copydoc PDMAPICREG::pfnGetBaseHC */
398	DECLR0CALLBACKMEMBER(uint64_t, pfnGetBaseR0,(PPDMDEVINS pDevIns));
399	/** @copydoc PDMAPICREG::pfnSetTPRHC */
400	DECLR0CALLBACKMEMBER(void, pfnSetTPRR0,(PPDMDEVINS pDevIns, uint8_t u8TPR));
401	/** @copydoc PDMAPICREG::pfnGetTPRHC */
402	DECLR0CALLBACKMEMBER(uint8_t, pfnGetTPRR0,(PPDMDEVINS pDevIns));
403	/** @copydoc PDMAPICREG::pfnBusDeliverHC */
404	DECLR0CALLBACKMEMBER(void, pfnBusDeliverR0,(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
405	uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode));
406
407	/** Pointer to the APIC device instance - GC Ptr. */
408	PPDMDEVINSGC pDevInsGC;
409	/** @copydoc PDMAPICREG::pfnGetInterruptHC */
410	DECLGCCALLBACKMEMBER(int, pfnGetInterruptGC,(PPDMDEVINS pDevIns));
411	/** @copydoc PDMAPICREG::pfnSetBaseHC */
412	DECLGCCALLBACKMEMBER(void, pfnSetBaseGC,(PPDMDEVINS pDevIns, uint64_t u64Base));
413	/** @copydoc PDMAPICREG::pfnGetBaseHC */
414	DECLGCCALLBACKMEMBER(uint64_t, pfnGetBaseGC,(PPDMDEVINS pDevIns));
415	/** @copydoc PDMAPICREG::pfnSetTPRHC */
416	DECLGCCALLBACKMEMBER(void, pfnSetTPRGC,(PPDMDEVINS pDevIns, uint8_t u8TPR));
417	/** @copydoc PDMAPICREG::pfnGetTPRHC */
418	DECLGCCALLBACKMEMBER(uint8_t, pfnGetTPRGC,(PPDMDEVINS pDevIns));
419	/** @copydoc PDMAPICREG::pfnBusDeliverHC */
420	DECLGCCALLBACKMEMBER(void, pfnBusDeliverGC,(PPDMDEVINS pDevIns, uint8_t u8Dest, uint8_t u8DestMode, uint8_t u8DeliveryMode,
421	uint8_t iVector, uint8_t u8Polarity, uint8_t u8TriggerMode));
422	#if GC_ARCH_BITS == 32
423	RTGCPTR GCPtrPadding; /*< Alignment padding. /
424	#endif
425	} PDMAPIC;
426
427
428	/**
429	* PDM registered I/O APIC device.
430	*/
431	typedef struct PDMIOAPIC
432	{
433	/** Pointer to the APIC device instance - HC Ptr. */
434	PPDMDEVINSR3 pDevInsR3;
435	/** @copydoc PDMIOAPICREG::pfnSetIrqHC */
436	DECLR3CALLBACKMEMBER(void, pfnSetIrqR3,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
437
438	/** Pointer to the PIC device instance - R0. */
439	R0PTRTYPE(PPDMDEVINS) pDevInsR0;
440	/** @copydoc PDMIOAPICREG::pfnSetIrqHC */
441	DECLR0CALLBACKMEMBER(void, pfnSetIrqR0,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
442
443	/** Pointer to the APIC device instance - GC Ptr. */
444	PPDMDEVINSGC pDevInsGC;
445	/** @copydoc PDMIOAPICREG::pfnSetIrqHC */
446	DECLGCCALLBACKMEMBER(void, pfnSetIrqGC,(PPDMDEVINS pDevIns, int iIrq, int iLevel));
447	} PDMIOAPIC;
448
449
450	/**
451	* PDM PCI Bus instance.
452	*/
453	typedef struct PDMPCIBUS
454	{
455	/** PCI bus number. */
456	RTUINT iBus;
457	RTUINT uPadding0; /*< Alignment padding./
458
459	/** Pointer to PCI Bus device instance. */
460	PPDMDEVINSR3 pDevInsR3;
461	/** @copydoc PDMPCIBUSREG::pfnSetIrqHC */
462	DECLR3CALLBACKMEMBER(void, pfnSetIrqR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, int iIrq, int iLevel));
463	/** @copydoc PDMPCIBUSREG::pfnRegisterHC */
464	DECLR3CALLBACKMEMBER(int, pfnRegisterR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, const char *pszName, int iDev));
465	/** @copydoc PDMPCIBUSREG::pfnIORegionRegisterHC */
466	DECLR3CALLBACKMEMBER(int, pfnIORegionRegisterR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, int iRegion, uint32_t cbRegion,
467	PCIADDRESSSPACE enmType, PFNPCIIOREGIONMAP pfnCallback));
468	/** @copydoc PDMPCIBUSREG::pfnSetConfigCallbacksHC */
469	DECLR3CALLBACKMEMBER(void, pfnSetConfigCallbacksR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PFNPCICONFIGREAD pfnRead,
470	PPFNPCICONFIGREAD ppfnReadOld, PFNPCICONFIGWRITE pfnWrite, PPFNPCICONFIGWRITE ppfnWriteOld));
471	/** @copydoc PDMPCIBUSREG::pfnSaveExecHC */
472	DECLR3CALLBACKMEMBER(int, pfnSaveExecR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PSSMHANDLE pSSMHandle));
473	/** @copydoc PDMPCIBUSREG::pfnLoadExecHC */
474	DECLR3CALLBACKMEMBER(int, pfnLoadExecR3,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, PSSMHANDLE pSSMHandle));
475	/** @copydoc PDMPCIBUSREG::pfnFakePCIBIOSHC */
476	DECLR3CALLBACKMEMBER(int, pfnFakePCIBIOSR3,(PPDMDEVINS pDevIns));
477
478	/** Pointer to the PIC device instance - R0. */
479	R0PTRTYPE(PPDMDEVINS) pDevInsR0;
480	/** @copydoc PDMPCIBUSREG::pfnSetIrqHC */
481	DECLR0CALLBACKMEMBER(void, pfnSetIrqR0,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, int iIrq, int iLevel));
482
483	/** Pointer to PCI Bus device instance. */
484	PPDMDEVINSGC pDevInsGC;
485	/** @copydoc PDMPCIBUSREG::pfnSetIrqHC */
486	DECLGCCALLBACKMEMBER(void, pfnSetIrqGC,(PPDMDEVINS pDevIns, PPCIDEVICE pPciDev, int iIrq, int iLevel));
487	} PDMPCIBUS;
488
489
490	#ifdef IN_RING3
491	/**
492	* PDM registered DMAC (DMA Controller) device.
493	*/
494	typedef struct PDMDMAC
495	{
496	/** Pointer to the DMAC device instance. */
497	PPDMDEVINS pDevIns;
498	/** Copy of the registration structure. */
499	PDMDMACREG Reg;
500	} PDMDMAC;
501
502
503	/**
504	* PDM registered RTC (Real Time Clock) device.
505	*/
506	typedef struct PDMRTC
507	{
508	/** Pointer to the RTC device instance. */
509	PPDMDEVINS pDevIns;
510	/** Copy of the registration structure. */
511	PDMRTCREG Reg;
512	} PDMRTC;
513
514	#endif /* IN_RING3 */
515
516	/**
517	* Module type.
518	*/
519	typedef enum PDMMODTYPE
520	{
521	/** Guest context module. */
522	PDMMOD_TYPE_GC,
523	/** Ring-0 (host) context module. */
524	PDMMOD_TYPE_R0,
525	/** Ring-3 (host) context module. */
526	PDMMOD_TYPE_R3
527	} PDMMODTYPE, *PPDMMODTYPE;
528
529
530	/** The module name length including the terminator. */
531	#define PDMMOD_NAME_LEN 32
532
533	/**
534	* Loaded module instance.
535	*/
536	typedef struct PDMMOD
537	{
538	/** Module name. This is used for refering to
539	* the module internally, sort of like a handle. */
540	char szName[PDMMOD_NAME_LEN];
541	/** Module type. */
542	PDMMODTYPE eType;
543	/** Loader module handle. Not used for R0 modules. */
544	RTLDRMOD hLdrMod;
545	/** Loaded address.
546	* This is the 'handle' for R0 modules. */
547	RTUINTPTR ImageBase;
548	/** Old loaded address.
549	* This is used during relocation of GC modules. Not used for R0 modules. */
550	RTUINTPTR OldImageBase;
551	/** Where the R3 HC bits are stored.
552	* This can be equal to ImageBase but doesn't have to. Not used for R0 modules. */
553	void *pvBits;
554
555	/** Pointer to next module. */
556	struct PDMMOD *pNext;
557	/** Module filename. */
558	char szFilename[1];
559	} PDMMOD;
560	/** Pointer to loaded module instance. */
561	typedef PDMMOD *PPDMMOD;
562
563
564
565	/** Extra space in the free array. */
566	#define PDMQUEUE_FREE_SLACK 16
567
568	/**
569	* Queue type.
570	*/
571	typedef enum PDMQUEUETYPE
572	{
573	/** Device consumer. */
574	PDMQUEUETYPE_DEV = 1,
575	/** Driver consumer. */
576	PDMQUEUETYPE_DRV,
577	/** Internal consumer. */
578	PDMQUEUETYPE_INTERNAL,
579	/** External consumer. */
580	PDMQUEUETYPE_EXTERNAL
581	} PDMQUEUETYPE;
582
583	/** Pointer to a PDM Queue. */
584	typedef struct PDMQUEUE *PPDMQUEUE;
585
586	/**
587	* PDM Queue.
588	*/
589	typedef struct PDMQUEUE
590	{
591	/** Pointer to the next queue in the list. */
592	R3PTRTYPE(PPDMQUEUE) pNext;
593	/** Type specific data. */
594	union
595	{
596	/** PDMQUEUETYPE_DEV */
597	struct
598	{
599	/** Pointer to consumer function. */
600	R3PTRTYPE(PFNPDMQUEUEDEV) pfnCallback;
601	/** Pointer to the device instance owning the queue. */
602	R3PTRTYPE(PPDMDEVINS) pDevIns;
603	} Dev;
604	/** PDMQUEUETYPE_DRV */
605	struct
606	{
607	/** Pointer to consumer function. */
608	R3PTRTYPE(PFNPDMQUEUEDRV) pfnCallback;
609	/** Pointer to the driver instance owning the queue. */
610	R3PTRTYPE(PPDMDRVINS) pDrvIns;
611	} Drv;
612	/** PDMQUEUETYPE_INTERNAL */
613	struct
614	{
615	/** Pointer to consumer function. */
616	R3PTRTYPE(PFNPDMQUEUEINT) pfnCallback;
617	} Int;
618	/** PDMQUEUETYPE_EXTERNAL */
619	struct
620	{
621	/** Pointer to consumer function. */
622	R3PTRTYPE(PFNPDMQUEUEEXT) pfnCallback;
623	/** Pointer to user argument. */
624	R3PTRTYPE(void *) pvUser;
625	} Ext;
626	} u;
627	/** Queue type. */
628	PDMQUEUETYPE enmType;
629	/** The interval between checking the queue for events.
630	* The realtime timer below is used to do the waiting.
631	* If 0, the queue will use the VM_FF_PDM_QUEUE forced action. */
632	uint32_t cMilliesInterval;
633	/** Interval timer. Only used if cMilliesInterval is non-zero. */
634	PTMTIMERR3 pTimer;
635	/** Pointer to the VM. */
636	R3R0PTRTYPE(PVM) pVMHC;
637	/** LIFO of pending items - HC. */
638	R3R0PTRTYPE(PPDMQUEUEITEMCORE) volatile pPendingHC;
639	/** Pointer to the GC VM and indicator for GC enabled queue.
640	* If this is NULL, the queue cannot be used in GC.
641	*/
642	GCPTRTYPE(PVM) pVMGC;
643	/** LIFO of pending items - GC. */
644	GCPTRTYPE(PPDMQUEUEITEMCORE) pPendingGC;
645	/** Item size (bytes). */
646	RTUINT cbItem;
647	/** Number of items in the queue. */
648	RTUINT cItems;
649	/** Index to the free head (where we insert). */
650	uint32_t volatile iFreeHead;
651	/** Index to the free tail (where we remove). */
652	uint32_t volatile iFreeTail;
653	/** Array of pointers to free items. Variable size. */
654	struct PDMQUEUEFREEITEM
655	{
656	/** Pointer to the free item - HC Ptr. */
657	R3R0PTRTYPE(PPDMQUEUEITEMCORE) volatile pItemHC;
658	/** Pointer to the free item - GC Ptr. */
659	GCPTRTYPE(PPDMQUEUEITEMCORE) volatile pItemGC;
660	#if HC_ARCH_BITS == 64 && GC_ARCH_BITS == 32
661	uint32_t Alignment0;
662	#endif
663	} aFreeItems[1];
664	} PDMQUEUE;
665
666
667	/**
668	* Queue device helper task operation.
669	*/
670	typedef enum PDMDEVHLPTASKOP
671	{
672	/** The usual invalid 0 entry. */
673	PDMDEVHLPTASKOP_INVALID = 0,
674	/** ISASetIrq */
675	PDMDEVHLPTASKOP_ISA_SET_IRQ,
676	/** PCISetIrq */
677	PDMDEVHLPTASKOP_PCI_SET_IRQ,
678	/** PCISetIrq */
679	PDMDEVHLPTASKOP_IOAPIC_SET_IRQ,
680	/** The usual 32-bit hack. */
681	PDMDEVHLPTASKOP_32BIT_HACK = 0x7fffffff
682	} PDMDEVHLPTASKOP;
683
684	/**
685	* Queued Device Helper Task.
686	*/
687	typedef struct PDMDEVHLPTASK
688	{
689	/** The queue item core (don't touch). */
690	PDMQUEUEITEMCORE Core;
691	/** Pointer to the device instance (HC Ptr). */
692	R3R0PTRTYPE(PPDMDEVINS) pDevInsHC;
693	/** This operation to perform. */
694	PDMDEVHLPTASKOP enmOp;
695	#if HC_ARCH_BITS == 64
696	uint32_t Alignment0;
697	#endif
698	/** Parameters to the operation. */
699	union PDMDEVHLPTASKPARAMS
700	{
701	/**
702	* PDMDEVHLPTASKOP_ISA_SET_IRQ and PDMDEVHLPTASKOP_PCI_SET_IRQ.
703	*/
704	struct PDMDEVHLPTASKSETIRQ
705	{
706	/** The IRQ */
707	int iIrq;
708	/** The new level. */
709	int iLevel;
710	} SetIRQ;
711	} u;
712	} PDMDEVHLPTASK;
713	/** Pointer to a queued Device Helper Task. */
714	typedef PDMDEVHLPTASK *PPDMDEVHLPTASK;
715	/** Pointer to a const queued Device Helper Task. */
716	typedef const PDMDEVHLPTASK *PCPDMDEVHLPTASK;
717
718
719
720	/**
721	* An USB hub registration record.
722	*/
723	typedef struct PDMUSBHUB
724	{
725	/** The USB versions this hub support.
726	* Note that 1.1 hubs can take on 2.0 devices. */
727	uint32_t fVersions;
728	/** The number of occupied ports. */
729	uint32_t cAvailablePorts;
730	/** Pointer to the next hub in the list. */
731	struct PDMUSBHUB *pNext;
732	/** The driver instance of the hub.. */
733	PPDMDRVINS pDrvIns;
734
735	} PDMUSBHUB;
736
737	/** Pointer to a const USB HUB registration record. */
738	typedef const PDMUSBHUB *PCPDMUSBHUB;
739
740
741	/**
742	* Converts a PDM pointer into a VM pointer.
743	* @returns Pointer to the VM structure the PDM is part of.
744	* @param pPDM Pointer to PDM instance data.
745	*/
746	#define PDM2VM(pPDM) ( (PVM)((char*)pPDM - pPDM->offVM) )
747
748
749	/**
750	* PDM VM Instance data.
751	* Changes to this must checked against the padding of the cfgm union in VM!
752	*/
753	typedef struct PDM
754	{
755	/** Offset to the VM structure.
756	* See PDM2VM(). */
757	RTUINT offVM;
758	RTUINT uPadding0; /*< Alignment padding./
759
760	/** Pointer to list of loaded modules. This is HC only! */
761	R3PTRTYPE(PPDMMOD) pModules;
762
763	/** List of registered devices. (FIFO) */
764	R3PTRTYPE(PPDMDEV) pDevs;
765	/** List of devices instances. (FIFO) */
766	R3PTRTYPE(PPDMDEVINS) pDevInstances;
767	/** List of registered USB devices. (FIFO) */
768	R3PTRTYPE(PPDMUSB) pUsbDevs;
769	/** List of USB devices instances. (FIFO) */
770	R3PTRTYPE(PPDMUSBINS) pUsbInstances;
771	/** List of registered drivers. (FIFO) */
772	R3PTRTYPE(PPDMDRV) pDrvs;
773	/** List of initialized critical sections. (LIFO) */
774	R3PTRTYPE(PPDMCRITSECTINT) pCritSects;
775	/** PCI Buses. */
776	PDMPCIBUS aPciBuses[1];
777	/** The register PIC device. */
778	PDMPIC Pic;
779	/** The registerd APIC device. */
780	PDMAPIC Apic;
781	/** The registerd I/O APIC device. */
782	PDMIOAPIC IoApic;
783	/** The registered DMAC device. */
784	R3PTRTYPE(PPDMDMAC) pDmac;
785	/** The registered RTC device. */
786	R3PTRTYPE(PPDMRTC) pRtc;
787	/** The registered USB HUBs. (FIFO) */
788	R3PTRTYPE(PPDMUSBHUB) pUsbHubs;
789
790	/** Queue in which devhlp tasks are queued for R3 execution - HC Ptr. */
791	R3R0PTRTYPE(PPDMQUEUE) pDevHlpQueueHC;
792	/** Queue in which devhlp tasks are queued for R3 execution - GC Ptr. */
793	GCPTRTYPE(PPDMQUEUE) pDevHlpQueueGC;
794
795	/** The number of entries in the apQueuedCritSectsLeaves table that's currnetly in use. */
796	RTUINT cQueuedCritSectLeaves;
797	/** Critical sections queued in GC/R0 because of contention preventing leave to complete. (R3 Ptrs)
798	* We will return to Ring-3 ASAP, so this queue doesn't has to be very long. */
799	R3PTRTYPE(PPDMCRITSECT) apQueuedCritSectsLeaves[8];
800
801	/** Linked list of timer driven PDM queues. */
802	R3PTRTYPE(struct PDMQUEUE *) pQueuesTimer;
803	/** Linked list of force action driven PDM queues. */
804	R3PTRTYPE(struct PDMQUEUE *) pQueuesForced;
805	/** Pointer to the queue which should be manually flushed - HCPtr.
806	* Only touched by EMT. */
807	R3R0PTRTYPE(struct PDMQUEUE *) pQueueFlushHC;
808	/** Pointer to the queue which should be manually flushed - GCPtr. */
809	GCPTRTYPE(struct PDMQUEUE *) pQueueFlushGC;
810	#if HC_ARCH_BITS == 64
811	uint32_t padding0;
812	#endif
813
814	/** Head of the PDM Thread list. (singly linked) */
815	R3PTRTYPE(PPDMTHREAD) pThreads;
816	/** Tail of the PDM Thread list. (singly linked) */
817	R3PTRTYPE(PPDMTHREAD) pThreadsTail;
818
819	/** TEMPORARY HACKS FOR NETWORK POLLING.
820	* @todo fix NAT and kill this!
821	* @{ */
822	RTUINT cPollers;
823	#if HC_ARCH_BITS == 64
824	RTUINT padding1;
825	#endif
826	R3PTRTYPE(PFNPDMDRVPOLLER) apfnPollers[16];
827	R3PTRTYPE(PPDMDRVINS) aDrvInsPollers[16];
828	PTMTIMERR3 pTimerPollers;
829	/** @} */
830
831	#ifdef VBOX_WITH_PDM_LOCK
832	/** The PDM lock.
833	* This is used to protect everything that deals with interrupts, i.e.
834	* the PIC, APIC, IOAPIC and PCI devices pluss some PDM functions. */
835	PDMCRITSECT CritSect;
836	#endif
837
838
839	/** Number of times a critical section leave requesed needed to be queued for ring-3 execution. */
840	STAMCOUNTER StatQueuedCritSectLeaves;
841	} PDM;
842	/** Pointer to PDM VM instance data. */
843	typedef PDM *PPDM;
844
845
846
847	/*******************************************************************************
848	* Global Variables *
849	*******************************************************************************/
850	#ifdef IN_RING3
851	extern const PDMDRVHLP g_pdmR3DrvHlp;
852	#endif
853
854
855	/*******************************************************************************
856	* Internal Functions *
857	*******************************************************************************/
858	#ifdef IN_RING3
859	int pdmR3CritSectInit(PVM pVM);
860	int pdmR3CritSectTerm(PVM pVM);
861	void pdmR3CritSectRelocate(PVM pVM);
862	int pdmR3CritSectInitDevice(PVM pVM, PPDMDEVINS pDevIns, PPDMCRITSECT pCritSect, const char *pszName);
863	int pdmR3CritSectDeleteDevice(PVM pVM, PPDMDEVINS pDevIns);
864
865	int pdmR3DevInit(PVM pVM);
866	PPDMDEV pdmR3DevLookup(PVM pVM, const char *pszName);
867	int pdmR3DevFindLun(PVM pVM, const char pszDevice, unsigned iInstance, unsigned iLun, PPDMLUN ppLun);
868
869	int pdmR3UsbLoadModules(PVM pVM);
870	int pdmR3UsbInstantiateDevices(PVM pVM);
871	int pdmR3UsbInitComplete(PVM pVM);
872	PPDMUSB pdmR3UsbLookup(PVM pVM, const char *pszName);
873	int pdmR3UsbFindLun(PVM pVM, const char pszDevice, unsigned iInstance, unsigned iLun, PPDMLUN ppLun);
874
875	int pdmR3DrvInit(PVM pVM);
876	int pdmR3DrvDetach(PPDMDRVINS pDrvIns);
877	PPDMDRV pdmR3DrvLookup(PVM pVM, const char *pszName);
878
879	int pdmR3LdrInit(PVM pVM);
880	void pdmR3LdrTerm(PVM pVM);
881	char * pdmR3FileR3(const char *pszFile, bool fShared = false);
882	int pdmR3LoadR3(PVM pVM, const char pszFilename, const char pszName);
883
884	void pdmR3QueueRelocate(PVM pVM, RTGCINTPTR offDelta);
885
886	int pdmR3ThreadCreateDevice(PVM pVM, PPDMDEVINS pDevIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDEV pfnThread,
887	PFNPDMTHREADWAKEUPDEV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
888	int pdmR3ThreadCreateUsb(PVM pVM, PPDMDRVINS pUsbIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADUSB pfnThread,
889	PFNPDMTHREADWAKEUPUSB pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
890	int pdmR3ThreadCreateDriver(PVM pVM, PPDMDRVINS pDrvIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDRV pfnThread,
891	PFNPDMTHREADWAKEUPDRV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName);
892	int pdmR3ThreadDestroyDevice(PVM pVM, PPDMDEVINS pDevIns);
893	int pdmR3ThreadDestroyUsb(PVM pVM, PPDMUSBINS pUsbIns);
894	int pdmR3ThreadDestroyDriver(PVM pVM, PPDMDRVINS pDrvIns);
895	void pdmR3ThreadDestroyAll(PVM pVM);
896	int pdmR3ThreadResumeAll(PVM pVM);
897	int pdmR3ThreadSuspendAll(PVM pVM);
898
899	#endif /* IN_RING3 */
900
901	#ifdef VBOX_WITH_PDM_LOCK
902	void pdmLock(PVM pVM);
903	int pdmLockEx(PVM pVM, int rc);
904	void pdmUnlock(PVM pVM);
905	#else
906	# define pdmLock(pVM) do {} while (0)
907	# define pdmLockEx(pVM, rc) (VINF_SUCCESS)
908	# define pdmUnlock(pVM) do {} while (0)
909	#endif
910
911	/** @} */
912
913	__END_DECLS
914
915	#endif

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

source: vbox/trunk/src/VBox/VMM/PDMInternal.h@ 5458

Download in other formats: