DrvHostParallel.cpp@ 100307

Last change on this file since 100307 was 98103, checked in by vboxsync, 2 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 37.2 KB

Line
1	/* $Id: DrvHostParallel.cpp 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* VirtualBox Host Parallel Port Driver.
4	*
5	* Initial Linux-only code contributed by: Alexander Eichner
6	*/
7
8	/*
9	* Copyright (C) 2006-2023 Oracle and/or its affiliates.
10	*
11	* This file is part of VirtualBox base platform packages, as
12	* available from https://www.virtualbox.org.
13	*
14	* This program is free software; you can redistribute it and/or
15	* modify it under the terms of the GNU General Public License
16	* as published by the Free Software Foundation, in version 3 of the
17	* License.
18	*
19	* This program is distributed in the hope that it will be useful, but
20	* WITHOUT ANY WARRANTY; without even the implied warranty of
21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22	* General Public License for more details.
23	*
24	* You should have received a copy of the GNU General Public License
25	* along with this program; if not, see <https://www.gnu.org/licenses>.
26	*
27	* SPDX-License-Identifier: GPL-3.0-only
28	*/
29
30
31	/*********************************************************************************************************************************
32	* Header Files *
33	*********************************************************************************************************************************/
34	#define LOG_GROUP LOG_GROUP_DRV_HOST_PARALLEL
35	#include <VBox/vmm/pdmdrv.h>
36	#include <VBox/vmm/pdmthread.h>
37	#include <iprt/asm.h>
38	#include <iprt/assert.h>
39	#include <iprt/file.h>
40	#include <iprt/pipe.h>
41	#include <iprt/semaphore.h>
42	#include <iprt/stream.h>
43	#include <iprt/uuid.h>
44	#include <iprt/cdefs.h>
45	#include <iprt/ctype.h>
46
47	#ifdef RT_OS_LINUX
48	# include <sys/ioctl.h>
49	# include <sys/types.h>
50	# include <sys/stat.h>
51	# include <sys/poll.h>
52	# include <fcntl.h>
53	# include <unistd.h>
54	# include <linux/ppdev.h>
55	# include <linux/parport.h>
56	# include <errno.h>
57	#endif
58
59	/** @def VBOX_WITH_WIN_PARPORT_SUP
60	* Indicates whether to use the generic direct hardware access or host specific
61	* code to access the parallel port.
62	*/
63	#if defined(DOXYGEN_RUNNING)
64	# define VBOX_WITH_WIN_PARPORT_SUP
65	#endif
66	#if defined(RT_OS_LINUX)
67	# undef VBOX_WITH_WIN_PARPORT_SUP
68	#elif defined(RT_OS_WINDOWS)
69	#else
70	# error "Not ported"
71	#endif
72
73	#if defined(VBOX_WITH_WIN_PARPORT_SUP) && defined(IN_RING0)
74	# include <iprt/asm-amd64-x86.h>
75	#endif
76
77	#if defined(VBOX_WITH_WIN_PARPORT_SUP) && defined(IN_RING3)
78	# include <iprt/win/windows.h>
79	# include <iprt/win/setupapi.h>
80	# include <cfgmgr32.h>
81	# include <iprt/mem.h>
82	# include <iprt/ctype.h>
83	# include <iprt/path.h>
84	# include <iprt/string.h>
85	#endif
86
87	#include "VBoxDD.h"
88
89
90	/*********************************************************************************************************************************
91	* Structures and Typedefs *
92	*********************************************************************************************************************************/
93	/**
94	* Host parallel port driver instance data.
95	* @implements PDMIHOSTPARALLELCONNECTOR
96	*/
97	typedef struct DRVHOSTPARALLEL
98	{
99	/** Pointer to the driver instance structure. */
100	PPDMDRVINS pDrvIns;
101	/** Pointer to the driver instance. */
102	PPDMDRVINSR3 pDrvInsR3;
103	PPDMDRVINSR0 pDrvInsR0;
104	/** Pointer to the char port interface of the driver/device above us. */
105	PPDMIHOSTPARALLELPORT pDrvHostParallelPort;
106	/** Our host device interface. */
107	PDMIHOSTPARALLELCONNECTOR IHostParallelConnector;
108	/** Our host device interface. */
109	PDMIHOSTPARALLELCONNECTOR IHostParallelConnectorR3;
110	/** Device Path */
111	char *pszDevicePath;
112	/** Device Handle */
113	RTFILE hFileDevice;
114	#ifndef VBOX_WITH_WIN_PARPORT_SUP
115	/** Thread waiting for interrupts. */
116	PPDMTHREAD pMonitorThread;
117	/** Wakeup pipe read end. */
118	RTPIPE hWakeupPipeR;
119	/** Wakeup pipe write end. */
120	RTPIPE hWakeupPipeW;
121	/** Current mode the parallel port is in. */
122	PDMPARALLELPORTMODE enmModeCur;
123	#endif
124
125	#ifdef VBOX_WITH_WIN_PARPORT_SUP
126	/** Data register. */
127	RTIOPORT PortDirectData;
128	/** Status register. */
129	RTIOPORT PortDirectStatus;
130	/** Control register. */
131	RTIOPORT PortDirectControl;
132	/** Control read result buffer. */
133	uint8_t bReadInControl;
134	/** Status read result buffer. */
135	uint8_t bReadInStatus;
136	/** Data buffer for reads and writes. */
137	uint8_t abDataBuf[32];
138	#endif /* VBOX_WITH_WIN_PARPORT_SUP */
139	} DRVHOSTPARALLEL, *PDRVHOSTPARALLEL;
140
141
142	/**
143	* Ring-0 operations.
144	*/
145	typedef enum DRVHOSTPARALLELR0OP
146	{
147	/** Invalid zero value. */
148	DRVHOSTPARALLELR0OP_INVALID = 0,
149	/** Perform R0 initialization. */
150	DRVHOSTPARALLELR0OP_INITR0STUFF,
151	/** Read data into the data buffer (abDataBuf). */
152	DRVHOSTPARALLELR0OP_READ,
153	/** Read status register. */
154	DRVHOSTPARALLELR0OP_READSTATUS,
155	/** Read control register. */
156	DRVHOSTPARALLELR0OP_READCONTROL,
157	/** Write data from the data buffer (abDataBuf). */
158	DRVHOSTPARALLELR0OP_WRITE,
159	/** Write control register. */
160	DRVHOSTPARALLELR0OP_WRITECONTROL,
161	/** Set port direction. */
162	DRVHOSTPARALLELR0OP_SETPORTDIRECTION
163	} DRVHOSTPARALLELR0OP;
164
165	/** Converts a pointer to DRVHOSTPARALLEL::IHostDeviceConnector to a PDRHOSTPARALLEL. */
166	#define PDMIHOSTPARALLELCONNECTOR_2_DRVHOSTPARALLEL(pInterface) ( (PDRVHOSTPARALLEL)((uintptr_t)pInterface - RT_UOFFSETOF(DRVHOSTPARALLEL, CTX_SUFF(IHostParallelConnector))) )
167
168
169	/*********************************************************************************************************************************
170	* Defined Constants And Macros *
171	*********************************************************************************************************************************/
172	#define CTRL_REG_OFFSET 2
173	#define STATUS_REG_OFFSET 1
174	#define LPT_CONTROL_ENABLE_BIDIRECT 0x20
175
176
177
178	#ifdef VBOX_WITH_WIN_PARPORT_SUP
179	# ifdef IN_RING0
180
181	/**
182	* R0 mode function to write byte value to data port.
183	*
184	* @returns VBox status code.
185	* @param pThis Pointer to the instance data.
186	* @param u64Arg The number of bytes to write (from abDataBuf).
187	*/
188	static int drvR0HostParallelReqWrite(PDRVHOSTPARALLEL pThis, uint64_t u64Arg)
189	{
190	LogFlowFunc(("write %#RX64 bytes to data (%#x)\n", u64Arg, pThis->PortDirectData));
191
192	AssertReturn(u64Arg > 0 && u64Arg <= sizeof(pThis->abDataBuf), VERR_OUT_OF_RANGE);
193	uint8_t const *pbSrc = pThis->abDataBuf;
194	while (u64Arg-- > 0)
195	{
196	ASMOutU8(pThis->PortDirectData, *pbSrc);
197	pbSrc++;
198	}
199
200	return VINF_SUCCESS;
201	}
202
203	/**
204	* R0 mode function to write byte value to parallel port control register.
205	*
206	* @returns VBox status code.
207	* @param pThis Pointer to the instance data.
208	* @param u64Arg Data to be written to control register.
209	*/
210	static int drvR0HostParallelReqWriteControl(PDRVHOSTPARALLEL pThis, uint64_t u64Arg)
211	{
212	LogFlowFunc(("write to ctrl port=%#x val=%#x\n", pThis->PortDirectControl, u64Arg));
213	ASMOutU8(pThis->PortDirectControl, (uint8_t)(u64Arg));
214	return VINF_SUCCESS;
215	}
216
217	/**
218	* R0 mode function to ready byte value from the parallel port data register.
219	*
220	* @returns VBox status code.
221	* @param pThis Pointer to the instance data.
222	* @param u64Arg The number of bytes to read into abDataBuf.
223	*/
224	static int drvR0HostParallelReqRead(PDRVHOSTPARALLEL pThis, uint64_t u64Arg)
225	{
226	LogFlowFunc(("read %#RX64 bytes to data (%#x)\n", u64Arg, pThis->PortDirectData));
227
228	AssertReturn(u64Arg > 0 && u64Arg <= sizeof(pThis->abDataBuf), VERR_OUT_OF_RANGE);
229	uint8_t *pbDst = pThis->abDataBuf;
230	while (u64Arg-- > 0)
231	*pbDst++ = ASMInU8(pThis->PortDirectData);
232
233	return VINF_SUCCESS;
234	}
235
236	/**
237	* R0 mode function to ready byte value from the parallel port control register.
238	*
239	* @returns VBox status code.
240	* @param pThis Pointer to the instance data.
241	*/
242	static int drvR0HostParallelReqReadControl(PDRVHOSTPARALLEL pThis)
243	{
244	uint8_t u8Data = ASMInU8(pThis->PortDirectControl);
245	LogFlowFunc(("read from ctrl port=%#x val=%#x\n", pThis->PortDirectControl, u8Data));
246	pThis->bReadInControl = u8Data;
247	return VINF_SUCCESS;
248	}
249
250	/**
251	* R0 mode function to ready byte value from the parallel port status register.
252	*
253	* @returns VBox status code.
254	* @param pThis Pointer to the instance data.
255	*/
256	static int drvR0HostParallelReqReadStatus(PDRVHOSTPARALLEL pThis)
257	{
258	uint8_t u8Data = ASMInU8(pThis->PortDirectStatus);
259	LogFlowFunc(("read from status port=%#x val=%#x\n", pThis->PortDirectStatus, u8Data));
260	pThis->bReadInStatus = u8Data;
261	return VINF_SUCCESS;
262	}
263
264	/**
265	* R0 mode function to set the direction of parallel port -
266	* operate in bidirectional mode or single direction.
267	*
268	* @returns VBox status code.
269	* @param pThis Pointer to the instance data.
270	* @param u64Arg Mode.
271	*/
272	static int drvR0HostParallelReqSetPortDir(PDRVHOSTPARALLEL pThis, uint64_t u64Arg)
273	{
274	uint8_t bCtl = ASMInU8(pThis->PortDirectControl);
275	if (u64Arg)
276	bCtl \|= LPT_CONTROL_ENABLE_BIDIRECT; /* enable input direction */
277	else
278	bCtl &= ~LPT_CONTROL_ENABLE_BIDIRECT; /* disable input direction */
279	ASMOutU8(pThis->PortDirectControl, bCtl);
280
281	return VINF_SUCCESS;
282	}
283
284	/**
285	* @callback_method_impl{FNPDMDRVREQHANDLERR0}
286	*/
287	PDMBOTHCBDECL(int) drvR0HostParallelReqHandler(PPDMDRVINS pDrvIns, uint32_t uOperation, uint64_t u64Arg)
288	{
289	PDRVHOSTPARALLEL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
290	int rc;
291	LogFlowFuncEnter();
292
293	if (pThis->PortDirectData != 0)
294	{
295	switch ((DRVHOSTPARALLELR0OP)uOperation)
296	{
297	case DRVHOSTPARALLELR0OP_READ:
298	rc = drvR0HostParallelReqRead(pThis, u64Arg);
299	break;
300	case DRVHOSTPARALLELR0OP_READSTATUS:
301	rc = drvR0HostParallelReqReadStatus(pThis);
302	break;
303	case DRVHOSTPARALLELR0OP_READCONTROL:
304	rc = drvR0HostParallelReqReadControl(pThis);
305	break;
306	case DRVHOSTPARALLELR0OP_WRITE:
307	rc = drvR0HostParallelReqWrite(pThis, u64Arg);
308	break;
309	case DRVHOSTPARALLELR0OP_WRITECONTROL:
310	rc = drvR0HostParallelReqWriteControl(pThis, u64Arg);
311	break;
312	case DRVHOSTPARALLELR0OP_SETPORTDIRECTION:
313	rc = drvR0HostParallelReqSetPortDir(pThis, u64Arg);
314	break;
315	default:
316	rc = VERR_INVALID_FUNCTION;
317	break;
318	}
319	}
320	else
321	rc = VERR_WRONG_ORDER;
322
323	LogFlowFuncLeaveRC(rc);
324	return rc;
325	}
326
327	# endif /* IN_RING0 */
328	#endif /* VBOX_WITH_WIN_PARPORT_SUP */
329
330	#ifdef IN_RING3
331	# ifdef VBOX_WITH_WIN_PARPORT_SUP
332
333	/**
334	* Find IO port range for the parallel port and return the lower address.
335	*
336	* @returns Parallel base I/O port.
337	* @param DevInst Device instance (dword/handle) for the parallel port.
338	*/
339	static RTIOPORT drvHostParallelGetWinHostIoPortsSub(const DEVINST DevInst)
340	{
341	RTIOPORT PortBase = 0;
342
343	/* Get handle of the first logical configuration. */
344	LOG_CONF hFirstLogConf;
345	CONFIGRET rcCm = CM_Get_First_Log_Conf(&hFirstLogConf, DevInst, ALLOC_LOG_CONF);
346	if (rcCm != CR_SUCCESS)
347	rcCm = CM_Get_First_Log_Conf(&hFirstLogConf, DevInst, BOOT_LOG_CONF);
348	if (rcCm == CR_SUCCESS)
349	{
350	/*
351	* This loop is based on the "fact" that only one I/O resource is assigned
352	* to the LPT port. Should there ever be multiple resources, we'll pick
353	* the last one for some silly reason.
354	*/
355
356	/* Get the first resource descriptor handle. */
357	LOG_CONF hCurLogConf = 0;
358	rcCm = CM_Get_Next_Res_Des(&hCurLogConf, hFirstLogConf, ResType_IO, 0, 0);
359	if (rcCm == CR_SUCCESS)
360	{
361	for (;;)
362	{
363	ULONG cbData;
364	rcCm = CM_Get_Res_Des_Data_Size(&cbData, hCurLogConf, 0);
365	if (rcCm != CR_SUCCESS)
366	cbData = 0;
367	cbData = RT_MAX(cbData, sizeof(IO_DES));
368	IO_DES pIoDesc = (IO_DES )RTMemAllocZ(cbData);
369	if (pIoDesc)
370	{
371	rcCm = CM_Get_Res_Des_Data(hCurLogConf, pIoDesc, cbData, 0L);
372	if (rcCm == CR_SUCCESS)
373	{
374	LogRel(("drvHostParallelGetWinHostIoPortsSub: Count=%#u Type=%#x Base=%#RX64 End=%#RX64 Flags=%#x\n",
375	pIoDesc->IOD_Count, pIoDesc->IOD_Type, (uint64_t)pIoDesc->IOD_Alloc_Base,
376	(uint64_t)pIoDesc->IOD_Alloc_End, pIoDesc->IOD_DesFlags));
377	PortBase = (RTIOPORT)pIoDesc->IOD_Alloc_Base;
378	}
379	else
380	LogRel(("drvHostParallelGetWinHostIoPortsSub: CM_Get_Res_Des_Data(,,%u,0) failed: %u\n", cbData, rcCm));
381	RTMemFree(pIoDesc);
382	}
383	else
384	LogRel(("drvHostParallelGetWinHostIoPortsSub: failed to allocate %#x bytes\n", cbData));
385
386	/* Next */
387	RES_DES hFreeResDesc = hCurLogConf;
388	rcCm = CM_Get_Next_Res_Des(&hCurLogConf, hCurLogConf, ResType_IO, 0, 0);
389	CM_Free_Res_Des_Handle(hFreeResDesc);
390	if (rcCm != CR_SUCCESS)
391	{
392	if (rcCm != CR_NO_MORE_RES_DES)
393	LogRel(("drvHostParallelGetWinHostIoPortsSub: CM_Get_Next_Res_Des failed: %u\n", rcCm));
394	break;
395	}
396	}
397	}
398	else
399	LogRel(("drvHostParallelGetWinHostIoPortsSub: Initial CM_Get_Next_Res_Des failed: %u\n", rcCm));
400	CM_Free_Log_Conf_Handle(hFirstLogConf);
401	}
402	LogFlowFunc(("return PortBase=%#x", PortBase));
403	return PortBase;
404	}
405
406	/**
407	* Get Parallel port address and update the shared data structure.
408	*
409	* @returns VBox status code.
410	* @param pThis The host parallel port instance data.
411	*/
412	static int drvHostParallelGetWinHostIoPorts(PDRVHOSTPARALLEL pThis)
413	{
414	/*
415	* Assume the host device path is on the form "\\.\PIPE\LPT1", then get the "LPT1" part.
416	*/
417	const char * const pszCfgPortName = RTPathFilename(pThis->pszDevicePath);
418	AssertReturn(pszCfgPortName, VERR_INTERNAL_ERROR_3);
419	size_t const cchCfgPortName = strlen(pszCfgPortName);
420	if ( cchCfgPortName != 4
421	\|\| RTStrNICmp(pszCfgPortName, "LPT", 3) != 0
422	\|\| !RT_C_IS_DIGIT(pszCfgPortName[3]) )
423	{
424	LogRel(("drvHostParallelGetWinHostIoPorts: The configured device name '%s' is not on the expected 'LPTx' form!\n",
425	pszCfgPortName));
426	return VERR_INVALID_NAME;
427	}
428
429	/*
430	* Get a list of devices then enumerate it looking for the LPT port we're using.
431	*/
432	HDEVINFO hDevInfo = SetupDiGetClassDevs(NULL, 0, 0, DIGCF_PRESENT \| DIGCF_ALLCLASSES);
433	if (hDevInfo == INVALID_HANDLE_VALUE)
434	{
435	DWORD dwErr = GetLastError();
436	LogRel(("drvHostParallelGetWinHostIoPorts: SetupDiGetClassDevs failed: %u\n", dwErr));
437	return RTErrConvertFromWin32(dwErr);
438	}
439
440	int rc = VINF_SUCCESS;
441	char *pszBuf = NULL;
442	DWORD cbBuf = 0;
443	for (int32_t idxDevInfo = 0;; idxDevInfo++)
444	{
445	/*
446	* Query the next device info.
447	*/
448	SP_DEVINFO_DATA DeviceInfoData;
449	DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
450	if (!SetupDiEnumDeviceInfo(hDevInfo, idxDevInfo, &DeviceInfoData))
451	{
452	DWORD dwErr = GetLastError();
453	if (dwErr != ERROR_NO_MORE_ITEMS && dwErr != NO_ERROR)
454	{
455	LogRel(("drvHostParallelGetWinHostIoPorts: SetupDiEnumDeviceInfo failed: %u\n", dwErr));
456	rc = RTErrConvertFromWin32(dwErr);
457	}
458	break;
459	}
460
461	/* Get the friendly name of the device. */
462	DWORD dwDataType;
463	DWORD cbBufActual;
464	BOOL fOk;
465	while (!(fOk = SetupDiGetDeviceRegistryProperty(hDevInfo, &DeviceInfoData, SPDRP_FRIENDLYNAME,
466	&dwDataType, (PBYTE)pszBuf, cbBuf, &cbBufActual)))
467	{
468	DWORD dwErr = GetLastError();
469	if (dwErr == ERROR_INSUFFICIENT_BUFFER)
470	{
471	LogFlow(("ERROR_INSUFF_BUFF = %d. dwBufSz = %d\n", dwErr, cbBuf));
472	cbBuf = RT_MAX(RT_ALIGN_Z(cbBufActual + 16, 64), 256);
473	void *pvNew = RTMemRealloc(pszBuf, cbBuf);
474	if (pvNew)
475	pszBuf = (char *)pvNew;
476	else
477	{
478	LogFlow(("GetDevProp Error = %d & cbBufActual = %d\n", dwErr, cbBufActual));
479	break;
480	}
481	}
482	else
483	{
484	/* No need to bother about this error (in most cases its errno=13,
485	* INVALID_DATA . Just break from here and proceed to next device
486	* enumerated item
487	*/
488	LogFlow(("GetDevProp Error = %d & cbBufActual = %d\n", dwErr, cbBufActual));
489	break;
490	}
491	}
492	if ( fOk
493	&& pszBuf)
494	{
495	pszBuf[cbBuf - 1] = '\0';
496
497	/*
498	* Does this look like the port name we're looking for.
499	*
500	* We're expecting either "Parallel Port (LPT1)" or just "LPT1", though we'll make do
501	* with anything that includes the name we're looking for as a separate word.
502	*/
503	char *pszMatch;
504	do
505	pszMatch = RTStrIStr(pszBuf, pszCfgPortName);
506	while ( pszMatch != NULL
507	&& !( ( pszMatch == pszBuf
508	\|\| pszMatch[-1] == '('
509	\|\| RT_C_IS_BLANK(pszMatch[-1]))
510	&& ( pszMatch[cchCfgPortName] == '\0'
511	\|\| pszMatch[cchCfgPortName] == ')'
512	\|\| RT_C_IS_BLANK(pszMatch[cchCfgPortName])) ) );
513	if (pszMatch != NULL)
514	{
515	RTIOPORT Port = drvHostParallelGetWinHostIoPortsSub(DeviceInfoData.DevInst);
516	if (Port != 0)
517	{
518	pThis->PortDirectData = Port;
519	pThis->PortDirectControl = Port + CTRL_REG_OFFSET;
520	pThis->PortDirectStatus = Port + STATUS_REG_OFFSET;
521	break;
522	}
523	LogRel(("drvHostParallelGetWinHostIoPorts: Addr not found for '%s'\n", pszBuf));
524	}
525	}
526	}
527
528	/* Cleanup. */
529	RTMemFree(pszBuf);
530	SetupDiDestroyDeviceInfoList(hDevInfo);
531	return rc;
532
533	}
534	# endif /* VBOX_WITH_WIN_PARPORT_SUP */
535
536	/**
537	* Changes the current mode of the host parallel port.
538	*
539	* @returns VBox status code.
540	* @param pThis The host parallel port instance data.
541	* @param enmMode The mode to change the port to.
542	*/
543	static int drvHostParallelSetMode(PDRVHOSTPARALLEL pThis, PDMPARALLELPORTMODE enmMode)
544	{
545	LogFlowFunc(("mode=%d\n", enmMode));
546	# ifndef VBOX_WITH_WIN_PARPORT_SUP
547	int rc = VINF_SUCCESS;
548	int iMode = 0;
549	int rcLnx;
550	if (pThis->enmModeCur != enmMode)
551	{
552	switch (enmMode)
553	{
554	case PDM_PARALLEL_PORT_MODE_SPP:
555	iMode = IEEE1284_MODE_COMPAT;
556	break;
557	case PDM_PARALLEL_PORT_MODE_EPP_DATA:
558	iMode = IEEE1284_MODE_EPP \| IEEE1284_DATA;
559	break;
560	case PDM_PARALLEL_PORT_MODE_EPP_ADDR:
561	iMode = IEEE1284_MODE_EPP \| IEEE1284_ADDR;
562	break;
563	case PDM_PARALLEL_PORT_MODE_ECP:
564	case PDM_PARALLEL_PORT_MODE_INVALID:
565	default:
566	return VERR_NOT_SUPPORTED;
567	}
568
569	rcLnx = ioctl(RTFileToNative(pThis->hFileDevice), PPSETMODE, &iMode);
570	if (RT_UNLIKELY(rcLnx < 0))
571	rc = RTErrConvertFromErrno(errno);
572	else
573	pThis->enmModeCur = enmMode;
574	}
575
576	return rc;
577	# else /* VBOX_WITH_WIN_PARPORT_SUP */
578	RT_NOREF(pThis, enmMode);
579	return VINF_SUCCESS;
580	# endif /* VBOX_WITH_WIN_PARPORT_SUP */
581	}
582
583	/* -=-=-=-=- IBase -=-=-=-=- */
584
585	/**
586	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
587	*/
588	static DECLCALLBACK(void ) drvHostParallelQueryInterface(PPDMIBASE pInterface, const char pszIID)
589	{
590	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
591	PDRVHOSTPARALLEL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
592
593	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
594	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIHOSTPARALLELCONNECTOR, &pThis->CTX_SUFF(IHostParallelConnector));
595	return NULL;
596	}
597
598
599	/* -=-=-=-=- IHostDeviceConnector -=-=-=-=- */
600
601	/**
602	* @interface_method_impl{PDMIHOSTPARALLELCONNECTOR,pfnWrite}
603	*/
604	static DECLCALLBACK(int)
605	drvHostParallelWrite(PPDMIHOSTPARALLELCONNECTOR pInterface, const void *pvBuf, size_t cbWrite, PDMPARALLELPORTMODE enmMode)
606	{
607	PDRVHOSTPARALLEL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPARALLEL, CTX_SUFF(IHostParallelConnector));
608	int rc = VINF_SUCCESS;
609
610	LogFlowFunc(("pvBuf=%#p cbWrite=%d\n", pvBuf, cbWrite));
611
612	rc = drvHostParallelSetMode(pThis, enmMode);
613	if (RT_FAILURE(rc))
614	return rc;
615	# ifndef VBOX_WITH_WIN_PARPORT_SUP
616	int rcLnx = 0;
617	if (enmMode == PDM_PARALLEL_PORT_MODE_SPP)
618	{
619	/* Set the data lines directly. */
620	rcLnx = ioctl(RTFileToNative(pThis->hFileDevice), PPWDATA, pvBuf);
621	}
622	else
623	{
624	/* Use write interface. */
625	rcLnx = write(RTFileToNative(pThis->hFileDevice), pvBuf, cbWrite);
626	}
627	if (RT_UNLIKELY(rcLnx < 0))
628	rc = RTErrConvertFromErrno(errno);
629
630	# else /* VBOX_WITH_WIN_PARPORT_SUP */
631	if (pThis->PortDirectData != 0)
632	{
633	while (cbWrite > 0)
634	{
635	size_t cbToWrite = RT_MIN(cbWrite, sizeof(pThis->abDataBuf));
636	LogFlowFunc(("Calling R0 to write %#zu bytes of data\n", cbToWrite));
637	memcpy(pThis->abDataBuf, pvBuf, cbToWrite);
638	rc = PDMDrvHlpCallR0(pThis->CTX_SUFF(pDrvIns), DRVHOSTPARALLELR0OP_WRITE, cbToWrite);
639	AssertRC(rc);
640	pvBuf = (uint8_t const *)pvBuf + cbToWrite;
641	cbWrite -= cbToWrite;
642	}
643	}
644	# endif /* VBOX_WITH_WIN_PARPORT_SUP */
645	return rc;
646	}
647
648	/**
649	* @interface_method_impl{PDMIHOSTPARALLELCONNECTOR,pfnRead}
650	*/
651	static DECLCALLBACK(int)
652	drvHostParallelRead(PPDMIHOSTPARALLELCONNECTOR pInterface, void *pvBuf, size_t cbRead, PDMPARALLELPORTMODE enmMode)
653	{
654	PDRVHOSTPARALLEL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPARALLEL, CTX_SUFF(IHostParallelConnector));
655	int rc = VINF_SUCCESS;
656
657	# ifndef VBOX_WITH_WIN_PARPORT_SUP
658	int rcLnx = 0;
659	LogFlowFunc(("pvBuf=%#p cbRead=%d\n", pvBuf, cbRead));
660
661	rc = drvHostParallelSetMode(pThis, enmMode);
662	if (RT_FAILURE(rc))
663	return rc;
664
665	if (enmMode == PDM_PARALLEL_PORT_MODE_SPP)
666	{
667	/* Set the data lines directly. */
668	rcLnx = ioctl(RTFileToNative(pThis->hFileDevice), PPWDATA, pvBuf);
669	}
670	else
671	{
672	/* Use write interface. */
673	rcLnx = read(RTFileToNative(pThis->hFileDevice), pvBuf, cbRead);
674	}
675	if (RT_UNLIKELY(rcLnx < 0))
676	rc = RTErrConvertFromErrno(errno);
677
678	# else /* VBOX_WITH_WIN_PARPORT_SUP */
679	RT_NOREF(enmMode);
680	if (pThis->PortDirectData != 0)
681	{
682	while (cbRead > 0)
683	{
684	size_t cbToRead = RT_MIN(cbRead, sizeof(pThis->abDataBuf));
685	LogFlowFunc(("Calling R0 to read %#zu bytes of data\n", cbToRead));
686	memset(pThis->abDataBuf, 0, cbToRead);
687	rc = PDMDrvHlpCallR0(pThis->CTX_SUFF(pDrvIns), DRVHOSTPARALLELR0OP_READ, cbToRead);
688	AssertRC(rc);
689	memcpy(pvBuf, pThis->abDataBuf, cbToRead);
690	pvBuf = (uint8_t *)pvBuf + cbToRead;
691	cbRead -= cbToRead;
692	}
693	}
694	# endif /* VBOX_WITH_WIN_PARPORT_SUP */
695	return rc;
696	}
697
698	/**
699	* @interface_method_impl{PDMIHOSTPARALLELCONNECTOR,pfnSetPortDirection}
700	*/
701	static DECLCALLBACK(int) drvHostParallelSetPortDirection(PPDMIHOSTPARALLELCONNECTOR pInterface, bool fForward)
702	{
703	PDRVHOSTPARALLEL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPARALLEL, CTX_SUFF(IHostParallelConnector));
704	int rc = VINF_SUCCESS;
705	int iMode = 0;
706	if (!fForward)
707	iMode = 1;
708	# ifndef VBOX_WITH_WIN_PARPORT_SUP
709	int rcLnx = ioctl(RTFileToNative(pThis->hFileDevice), PPDATADIR, &iMode);
710	if (RT_UNLIKELY(rcLnx < 0))
711	rc = RTErrConvertFromErrno(errno);
712
713	# else /* VBOX_WITH_WIN_PARPORT_SUP */
714	if (pThis->PortDirectData != 0)
715	{
716	LogFlowFunc(("calling R0 to write CTRL, data=%#x\n", iMode));
717	rc = PDMDrvHlpCallR0(pThis->CTX_SUFF(pDrvIns), DRVHOSTPARALLELR0OP_SETPORTDIRECTION, iMode);
718	AssertRC(rc);
719	}
720	# endif /* VBOX_WITH_WIN_PARPORT_SUP */
721	return rc;
722	}
723
724	/**
725	* @interface_method_impl{PDMIHOSTPARALLELCONNECTOR,pfnWriteControl}
726	*/
727	static DECLCALLBACK(int) drvHostParallelWriteControl(PPDMIHOSTPARALLELCONNECTOR pInterface, uint8_t fReg)
728	{
729	PDRVHOSTPARALLEL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPARALLEL, CTX_SUFF(IHostParallelConnector));
730	int rc = VINF_SUCCESS;
731
732	LogFlowFunc(("fReg=%#x\n", fReg));
733	# ifndef VBOX_WITH_WIN_PARPORT_SUP
734	int rcLnx = ioctl(RTFileToNative(pThis->hFileDevice), PPWCONTROL, &fReg);
735	if (RT_UNLIKELY(rcLnx < 0))
736	rc = RTErrConvertFromErrno(errno);
737	# else /* VBOX_WITH_WIN_PARPORT_SUP */
738	if (pThis->PortDirectData != 0)
739	{
740	LogFlowFunc(("calling R0 to write CTRL, data=%#x\n", fReg));
741	rc = PDMDrvHlpCallR0(pThis->CTX_SUFF(pDrvIns), DRVHOSTPARALLELR0OP_WRITECONTROL, fReg);
742	AssertRC(rc);
743	}
744	# endif /* VBOX_WITH_WIN_PARPORT_SUP */
745	return rc;
746	}
747
748
749	/**
750	* @interface_method_impl{PDMIHOSTPARALLELCONNECTOR,pfnReadControl}
751	*/
752	static DECLCALLBACK(int) drvHostParallelReadControl(PPDMIHOSTPARALLELCONNECTOR pInterface, uint8_t *pfReg)
753	{
754	PDRVHOSTPARALLEL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPARALLEL, CTX_SUFF(IHostParallelConnector));
755	int rc = VINF_SUCCESS;
756
757	# ifndef VBOX_WITH_WIN_PARPORT_SUP
758	uint8_t fReg = 0;
759	int rcLnx = ioctl(RTFileToNative(pThis->hFileDevice), PPRCONTROL, &fReg);
760	if (RT_UNLIKELY(rcLnx < 0))
761	rc = RTErrConvertFromErrno(errno);
762	else
763	{
764	LogFlowFunc(("fReg=%#x\n", fReg));
765	*pfReg = fReg;
766	}
767	# else /* VBOX_WITH_WIN_PARPORT_SUP */
768	pfReg = 0; / Initialize the buffer*/
769	if (pThis->PortDirectData != 0)
770	{
771	LogFlowFunc(("calling R0 to read control from parallel port\n"));
772	rc = PDMDrvHlpCallR0(pThis-> CTX_SUFF(pDrvIns), DRVHOSTPARALLELR0OP_READCONTROL, 0);
773	AssertRC(rc);
774	*pfReg = pThis->bReadInControl;
775	}
776	# endif /* VBOX_WITH_WIN_PARPORT_SUP */
777	return rc;
778	}
779
780	/**
781	* @interface_method_impl{PDMIHOSTPARALLELCONNECTOR,pfnReadStatus}
782	*/
783	static DECLCALLBACK(int) drvHostParallelReadStatus(PPDMIHOSTPARALLELCONNECTOR pInterface, uint8_t *pfReg)
784	{
785	PDRVHOSTPARALLEL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTPARALLEL, CTX_SUFF(IHostParallelConnector));
786	int rc = VINF_SUCCESS;
787	# ifndef VBOX_WITH_WIN_PARPORT_SUP
788	uint8_t fReg = 0;
789	int rcLnx = ioctl(RTFileToNative(pThis->hFileDevice), PPRSTATUS, &fReg);
790	if (RT_UNLIKELY(rcLnx < 0))
791	rc = RTErrConvertFromErrno(errno);
792	else
793	{
794	LogFlowFunc(("fReg=%#x\n", fReg));
795	*pfReg = fReg;
796	}
797	# else /* VBOX_WITH_WIN_PARPORT_SUP */
798	pfReg = 0; / Intialize the buffer. */
799	if (pThis->PortDirectData != 0)
800	{
801	LogFlowFunc(("calling R0 to read status from parallel port\n"));
802	rc = PDMDrvHlpCallR0(pThis->CTX_SUFF(pDrvIns), DRVHOSTPARALLELR0OP_READSTATUS, 0);
803	AssertRC(rc);
804	*pfReg = pThis->bReadInStatus;
805	}
806	# endif /* VBOX_WITH_WIN_PARPORT_SUP */
807	return rc;
808	}
809
810	# ifndef VBOX_WITH_WIN_PARPORT_SUP
811
812	static DECLCALLBACK(int) drvHostParallelMonitorThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
813	{
814	PDRVHOSTPARALLEL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
815	struct pollfd aFDs[2];
816
817	/*
818	* We can wait for interrupts using poll on linux hosts.
819	*/
820	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
821	{
822	int rc;
823
824	aFDs[0].fd = RTFileToNative(pThis->hFileDevice);
825	aFDs[0].events = POLLIN;
826	aFDs[0].revents = 0;
827	aFDs[1].fd = RTPipeToNative(pThis->hWakeupPipeR);
828	aFDs[1].events = POLLIN \| POLLERR \| POLLHUP;
829	aFDs[1].revents = 0;
830	rc = poll(aFDs, RT_ELEMENTS(aFDs), -1);
831	if (rc < 0)
832	{
833	AssertMsgFailed(("poll failed with rc=%d\n", RTErrConvertFromErrno(errno)));
834	return RTErrConvertFromErrno(errno);
835	}
836
837	if (pThread->enmState != PDMTHREADSTATE_RUNNING)
838	break;
839	if (rc > 0 && aFDs[1].revents)
840	{
841	if (aFDs[1].revents & (POLLHUP \| POLLERR \| POLLNVAL))
842	break;
843	/* notification to terminate -- drain the pipe */
844	char ch;
845	size_t cbRead;
846	RTPipeRead(pThis->hWakeupPipeR, &ch, 1, &cbRead);
847	continue;
848	}
849
850	/* Interrupt occurred. */
851	rc = pThis->pDrvHostParallelPort->pfnNotifyInterrupt(pThis->pDrvHostParallelPort);
852	AssertRC(rc);
853	}
854
855	return VINF_SUCCESS;
856	}
857
858	/**
859	* Unblock the monitor thread so it can respond to a state change.
860	*
861	* @returns a VBox status code.
862	* @param pDrvIns The driver instance.
863	* @param pThread The send thread.
864	*/
865	static DECLCALLBACK(int) drvHostParallelWakeupMonitorThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
866	{
867	RT_NOREF(pThread);
868	PDRVHOSTPARALLEL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
869	size_t cbIgnored;
870	return RTPipeWrite(pThis->hWakeupPipeW, "", 1, &cbIgnored);
871	}
872
873	# endif /* VBOX_WITH_WIN_PARPORT_SUP */
874
875	/**
876	* Destruct a host parallel driver instance.
877	*
878	* Most VM resources are freed by the VM. This callback is provided so that
879	* any non-VM resources can be freed correctly.
880	*
881	* @param pDrvIns The driver instance data.
882	*/
883	static DECLCALLBACK(void) drvHostParallelDestruct(PPDMDRVINS pDrvIns)
884	{
885	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
886	LogFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
887
888	#ifndef VBOX_WITH_WIN_PARPORT_SUP
889	PDRVHOSTPARALLEL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
890	if (pThis->hFileDevice != NIL_RTFILE)
891	ioctl(RTFileToNative(pThis->hFileDevice), PPRELEASE);
892
893	if (pThis->hWakeupPipeW != NIL_RTPIPE)
894	{
895	int rc = RTPipeClose(pThis->hWakeupPipeW); AssertRC(rc);
896	pThis->hWakeupPipeW = NIL_RTPIPE;
897	}
898
899	if (pThis->hWakeupPipeR != NIL_RTPIPE)
900	{
901	int rc = RTPipeClose(pThis->hWakeupPipeR); AssertRC(rc);
902	pThis->hWakeupPipeR = NIL_RTPIPE;
903	}
904
905	if (pThis->hFileDevice != NIL_RTFILE)
906	{
907	int rc = RTFileClose(pThis->hFileDevice); AssertRC(rc);
908	pThis->hFileDevice = NIL_RTFILE;
909	}
910
911	if (pThis->pszDevicePath)
912	{
913	PDMDrvHlpMMHeapFree(pDrvIns, pThis->pszDevicePath);
914	pThis->pszDevicePath = NULL;
915	}
916	#endif /* !VBOX_WITH_WIN_PARPORT_SUP */
917	}
918
919	/**
920	* Construct a host parallel driver instance.
921	*
922	* @copydoc FNPDMDRVCONSTRUCT
923	*/
924	static DECLCALLBACK(int) drvHostParallelConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
925	{
926	RT_NOREF(fFlags);
927	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
928	PDRVHOSTPARALLEL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTPARALLEL);
929	PCPDMDRVHLPR3 pHlp = pDrvIns->pHlpR3;
930	LogFlowFunc(("iInstance=%d\n", pDrvIns->iInstance));
931
932
933	/*
934	* Init basic data members and interfaces.
935	*
936	* Must be done before returning any failure because we've got a destructor.
937	*/
938	pThis->hFileDevice = NIL_RTFILE;
939	#ifndef VBOX_WITH_WIN_PARPORT_SUP
940	pThis->hWakeupPipeR = NIL_RTPIPE;
941	pThis->hWakeupPipeW = NIL_RTPIPE;
942	#endif
943
944	pThis->pDrvInsR3 = pDrvIns;
945	#ifdef VBOX_WITH_DRVINTNET_IN_R0
946	pThis->pDrvInsR0 = PDMDRVINS_2_R0PTR(pDrvIns);
947	#endif
948
949	/* IBase. */
950	pDrvIns->IBase.pfnQueryInterface = drvHostParallelQueryInterface;
951	/* IHostParallelConnector. */
952	pThis->IHostParallelConnectorR3.pfnWrite = drvHostParallelWrite;
953	pThis->IHostParallelConnectorR3.pfnRead = drvHostParallelRead;
954	pThis->IHostParallelConnectorR3.pfnSetPortDirection = drvHostParallelSetPortDirection;
955	pThis->IHostParallelConnectorR3.pfnWriteControl = drvHostParallelWriteControl;
956	pThis->IHostParallelConnectorR3.pfnReadControl = drvHostParallelReadControl;
957	pThis->IHostParallelConnectorR3.pfnReadStatus = drvHostParallelReadStatus;
958
959	/*
960	* Validate the config.
961	*/
962	PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns, "DevicePath", "");
963
964	/*
965	* Query configuration.
966	*/
967	/* Device */
968	int rc = pHlp->pfnCFGMQueryStringAlloc(pCfg, "DevicePath", &pThis->pszDevicePath);
969	if (RT_FAILURE(rc))
970	{
971	AssertMsgFailed(("Configuration error: query for \"DevicePath\" string returned %Rra.\n", rc));
972	return rc;
973	}
974
975	/*
976	* Open the device
977	*/
978	/** @todo exclusive access on windows? */
979	rc = RTFileOpen(&pThis->hFileDevice, pThis->pszDevicePath, RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
980	if (RT_FAILURE(rc))
981	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("Parallel#%d could not open '%s'"),
982	pDrvIns->iInstance, pThis->pszDevicePath);
983
984	#ifndef VBOX_WITH_WIN_PARPORT_SUP
985	/*
986	* Try to get exclusive access to parallel port
987	*/
988	rc = ioctl(RTFileToNative(pThis->hFileDevice), PPEXCL);
989	if (rc < 0)
990	return PDMDrvHlpVMSetError(pDrvIns, RTErrConvertFromErrno(errno), RT_SRC_POS,
991	N_("Parallel#%d could not get exclusive access for parallel port '%s'"
992	"Be sure that no other process or driver accesses this port"),
993	pDrvIns->iInstance, pThis->pszDevicePath);
994
995	/*
996	* Claim the parallel port
997	*/
998	rc = ioctl(RTFileToNative(pThis->hFileDevice), PPCLAIM);
999	if (rc < 0)
1000	return PDMDrvHlpVMSetError(pDrvIns, RTErrConvertFromErrno(errno), RT_SRC_POS,
1001	N_("Parallel#%d could not claim parallel port '%s'"
1002	"Be sure that no other process or driver accesses this port"),
1003	pDrvIns->iInstance, pThis->pszDevicePath);
1004
1005	/*
1006	* Get the IHostParallelPort interface of the above driver/device.
1007	*/
1008	pThis->pDrvHostParallelPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIHOSTPARALLELPORT);
1009	if (!pThis->pDrvHostParallelPort)
1010	return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE, RT_SRC_POS, N_("Parallel#%d has no parallel port interface above"),
1011	pDrvIns->iInstance);
1012
1013	/*
1014	* Create wakeup pipe.
1015	*/
1016	rc = RTPipeCreate(&pThis->hWakeupPipeR, &pThis->hWakeupPipeW, 0 /fFlags/);
1017	AssertRCReturn(rc, rc);
1018
1019	/*
1020	* Start in SPP mode.
1021	*/
1022	pThis->enmModeCur = PDM_PARALLEL_PORT_MODE_INVALID;
1023	rc = drvHostParallelSetMode(pThis, PDM_PARALLEL_PORT_MODE_SPP);
1024	if (RT_FAILURE(rc))
1025	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostParallel#%d cannot change mode of parallel mode to SPP"), pDrvIns->iInstance);
1026
1027	/*
1028	* Start waiting for interrupts.
1029	*/
1030	rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pMonitorThread, pThis, drvHostParallelMonitorThread, drvHostParallelWakeupMonitorThread, 0,
1031	RTTHREADTYPE_IO, "ParMon");
1032	if (RT_FAILURE(rc))
1033	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostParallel#%d cannot create monitor thread"), pDrvIns->iInstance);
1034
1035	#else /* VBOX_WITH_WIN_PARPORT_SUP */
1036
1037	pThis->PortDirectData = 0;
1038	pThis->PortDirectControl = 0;
1039	pThis->PortDirectStatus = 0;
1040	rc = drvHostParallelGetWinHostIoPorts(pThis);
1041	if (RT_FAILURE(rc))
1042	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
1043	N_("HostParallel#%d: Could not get direct access to the host parallel port!! (rc=%Rrc)"),
1044	pDrvIns->iInstance, rc);
1045
1046	#endif /* VBOX_WITH_WIN_PARPORT_SUP */
1047	return VINF_SUCCESS;
1048	}
1049
1050
1051	/**
1052	* Char driver registration record.
1053	*/
1054	const PDMDRVREG g_DrvHostParallel =
1055	{
1056	/* u32Version */
1057	PDM_DRVREG_VERSION,
1058	/* szName */
1059	"HostParallel",
1060	/* szRCMod */
1061	"",
1062	/* szR0Mod */
1063	"VBoxDDR0.r0",
1064	/* pszDescription */
1065	"Parallel host driver.",
1066	/* fFlags */
1067	# if defined(VBOX_WITH_WIN_PARPORT_SUP)
1068	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT \| PDM_DRVREG_FLAGS_R0,
1069	# else
1070	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1071	# endif
1072	/* fClass. */
1073	PDM_DRVREG_CLASS_CHAR,
1074	/* cMaxInstances */
1075	~0U,
1076	/* cbInstance */
1077	sizeof(DRVHOSTPARALLEL),
1078	/* pfnConstruct */
1079	drvHostParallelConstruct,
1080	/* pfnDestruct */
1081	drvHostParallelDestruct,
1082	/* pfnRelocate */
1083	NULL,
1084	/* pfnIOCtl */
1085	NULL,
1086	/* pfnPowerOn */
1087	NULL,
1088	/* pfnReset */
1089	NULL,
1090	/* pfnSuspend */
1091	NULL,
1092	/* pfnResume */
1093	NULL,
1094	/* pfnAttach */
1095	NULL,
1096	/* pfnDetach */
1097	NULL,
1098	/* pfnPowerOff */
1099	NULL,
1100	/* pfnSoftReset */
1101	NULL,
1102	/* u32EndVersion */
1103	PDM_DRVREG_VERSION
1104	};
1105	#endif /IN_RING3/
1106

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

source: vbox/trunk/src/VBox/Devices/Parallel/DrvHostParallel.cpp@ 100307

Download in other formats: