DrvHostSerialNew.cpp@ 73565

Last change on this file since 73565 was 73331, checked in by vboxsync, 7 years ago
Serial: Fixes
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 25.4 KB

Line
1	/* $Id: DrvHostSerialNew.cpp 73331 2018-07-23 15:23:48Z vboxsync $ */
2	/** @file
3	* VBox serial devices: Host serial driver
4	*/
5
6	/*
7	* Copyright (C) 2006-2018 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19
20	/*********************************************************************************************************************************
21	* Header Files *
22	*********************************************************************************************************************************/
23	#define LOG_GROUP LOG_GROUP_DRV_HOST_SERIAL
24	#include <VBox/vmm/pdm.h>
25	#include <VBox/vmm/pdmserialifs.h>
26	#include <VBox/err.h>
27
28	#include <VBox/log.h>
29	#include <iprt/asm.h>
30	#include <iprt/assert.h>
31	#include <iprt/file.h>
32	#include <iprt/mem.h>
33	#include <iprt/pipe.h>
34	#include <iprt/semaphore.h>
35	#include <iprt/uuid.h>
36	#include <iprt/serialport.h>
37
38	#include "VBoxDD.h"
39
40
41	/*********************************************************************************************************************************
42	* Structures and Typedefs *
43	*********************************************************************************************************************************/
44
45	/**
46	* Char driver instance data.
47	*
48	* @implements PDMISERIALCONNECTOR
49	*/
50	typedef struct DRVHOSTSERIAL
51	{
52	/** Pointer to the driver instance structure. */
53	PPDMDRVINS pDrvIns;
54	/** Pointer to the serial port interface of the driver/device above us. */
55	PPDMISERIALPORT pDrvSerialPort;
56	/** Our serial interface. */
57	PDMISERIALCONNECTOR ISerialConnector;
58	/** I/O thread. */
59	PPDMTHREAD pIoThrd;
60	/** The serial port handle. */
61	RTSERIALPORT hSerialPort;
62	/** the device path */
63	char *pszDevicePath;
64
65	/** Amount of data available for sending from the device/driver above. */
66	volatile size_t cbAvailWr;
67	/** Small send buffer. */
68	uint8_t abTxBuf[16];
69	/** Amount of data in the buffer. */
70	size_t cbTxUsed;
71
72	/** The read queue. */
73	uint8_t abReadBuf[256];
74	/** Current offset to write to next. */
75	volatile uint32_t offWrite;
76	/** Current offset into the read buffer. */
77	volatile uint32_t offRead;
78	/** Current amount of data in the buffer. */
79	volatile size_t cbReadBuf;
80
81	/** Read/write statistics */
82	STAMCOUNTER StatBytesRead;
83	STAMCOUNTER StatBytesWritten;
84	} DRVHOSTSERIAL, *PDRVHOSTSERIAL;
85
86
87	/*********************************************************************************************************************************
88	* Global Variables *
89	*********************************************************************************************************************************/
90
91
92	/*********************************************************************************************************************************
93	* Internal Functions *
94	*********************************************************************************************************************************/
95
96
97	/**
98	* Returns number of bytes free in the read buffer and pointer to the start of the free space
99	* in the read buffer.
100	*
101	* @returns Number of bytes free in the buffer.
102	* @param pThis The host serial driver instance.
103	* @param ppv Where to return the pointer if there is still free space.
104	*/
105	DECLINLINE(size_t) drvHostSerialReadBufGetWrite(PDRVHOSTSERIAL pThis, void **ppv)
106	{
107	if (ppv)
108	*ppv = &pThis->abReadBuf[pThis->offWrite];
109
110	size_t cbFree = sizeof(pThis->abReadBuf) - ASMAtomicReadZ(&pThis->cbReadBuf);
111	if (cbFree)
112	cbFree = RT_MIN(cbFree, sizeof(pThis->abReadBuf) - pThis->offWrite);
113
114	return cbFree;
115	}
116
117
118	/**
119	* Returns number of bytes used in the read buffer and pointer to the next byte to read.
120	*
121	* @returns Number of bytes free in the buffer.
122	* @param pThis The host serial driver instance.
123	* @param ppv Where to return the pointer to the next data to read.
124	*/
125	DECLINLINE(size_t) drvHostSerialReadBufGetRead(PDRVHOSTSERIAL pThis, void **ppv)
126	{
127	if (ppv)
128	*ppv = &pThis->abReadBuf[pThis->offRead];
129
130	size_t cbUsed = ASMAtomicReadZ(&pThis->cbReadBuf);
131	if (cbUsed)
132	cbUsed = RT_MIN(cbUsed, sizeof(pThis->abReadBuf) - pThis->offRead);
133
134	return cbUsed;
135	}
136
137
138	/**
139	* Advances the write position of the read buffer by the given amount of bytes.
140	*
141	* @returns nothing.
142	* @param pThis The host serial driver instance.
143	* @param cbAdv Number of bytes to advance.
144	*/
145	DECLINLINE(void) drvHostSerialReadBufWriteAdv(PDRVHOSTSERIAL pThis, size_t cbAdv)
146	{
147	uint32_t offWrite = ASMAtomicReadU32(&pThis->offWrite);
148	offWrite = (offWrite + cbAdv) % sizeof(pThis->abReadBuf);
149	ASMAtomicWriteU32(&pThis->offWrite, offWrite);
150	ASMAtomicAddZ(&pThis->cbReadBuf, cbAdv);
151	}
152
153
154	/**
155	* Advances the read position of the read buffer by the given amount of bytes.
156	*
157	* @returns nothing.
158	* @param pThis The host serial driver instance.
159	* @param cbAdv Number of bytes to advance.
160	*/
161	DECLINLINE(void) drvHostSerialReadBufReadAdv(PDRVHOSTSERIAL pThis, size_t cbAdv)
162	{
163	uint32_t offRead = ASMAtomicReadU32(&pThis->offRead);
164	offRead = (offRead + cbAdv) % sizeof(pThis->abReadBuf);
165	ASMAtomicWriteU32(&pThis->offRead, offRead);
166	ASMAtomicSubZ(&pThis->cbReadBuf, cbAdv);
167	}
168
169
170	/* -=-=-=-=- IBase -=-=-=-=- */
171
172	/**
173	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
174	*/
175	static DECLCALLBACK(void ) drvHostSerialQueryInterface(PPDMIBASE pInterface, const char pszIID)
176	{
177	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
178	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
179
180	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
181	PDMIBASE_RETURN_INTERFACE(pszIID, PDMISERIALCONNECTOR, &pThis->ISerialConnector);
182	return NULL;
183	}
184
185
186	/* -=-=-=-=- ISerialConnector -=-=-=-=- */
187
188	/** @interface_method_impl{PDMISERIALCONNECTOR,pfnDataAvailWrNotify} */
189	static DECLCALLBACK(int) drvHostSerialDataAvailWrNotify(PPDMISERIALCONNECTOR pInterface, size_t cbAvail)
190	{
191	PDRVHOSTSERIAL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ISerialConnector);
192
193	int rc = VINF_SUCCESS;
194	size_t cbAvailOld = ASMAtomicAddZ(&pThis->cbAvailWr, cbAvail);
195	if (!cbAvailOld)
196	rc = RTSerialPortEvtPollInterrupt(pThis->hSerialPort);
197
198	return rc;
199	}
200
201
202	/**
203	* @interface_method_impl{PDMISERIALCONNECTOR,pfnReadRdr}
204	*/
205	static DECLCALLBACK(int) drvHostSerialReadRdr(PPDMISERIALCONNECTOR pInterface, void *pvBuf,
206	size_t cbRead, size_t *pcbRead)
207	{
208	PDRVHOSTSERIAL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ISerialConnector);
209	int rc = VINF_SUCCESS;
210	uint8_t pbDst = (uint8_t )pvBuf;
211	size_t cbReadAll = 0;
212
213	do
214	{
215	void *pvSrc = NULL;
216	size_t cbThisRead = RT_MIN(drvHostSerialReadBufGetRead(pThis, &pvSrc), cbRead);
217	if (cbThisRead)
218	{
219	memcpy(pbDst, pvSrc, cbThisRead);
220	cbRead -= cbThisRead;
221	pbDst += cbThisRead;
222	cbReadAll += cbThisRead;
223	drvHostSerialReadBufReadAdv(pThis, cbThisRead);
224	}
225	else
226	break;
227	} while (cbRead > 0);
228
229	*pcbRead = cbReadAll;
230	/* Kick the I/O thread if there is nothing to read to recalculate the poll flags. */
231	if (!drvHostSerialReadBufGetRead(pThis, NULL))
232	rc = RTSerialPortEvtPollInterrupt(pThis->hSerialPort);
233
234	STAM_COUNTER_ADD(&pThis->StatBytesRead, cbReadAll);
235	return rc;
236	}
237
238
239	/**
240	* @interface_method_impl{PDMISERIALCONNECTOR,pfnChgParams}
241	*/
242	static DECLCALLBACK(int) drvHostSerialChgParams(PPDMISERIALCONNECTOR pInterface, uint32_t uBps,
243	PDMSERIALPARITY enmParity, unsigned cDataBits,
244	PDMSERIALSTOPBITS enmStopBits)
245	{
246	PDRVHOSTSERIAL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ISerialConnector);
247	RTSERIALPORTCFG Cfg;
248
249	Cfg.uBaudRate = uBps;
250
251	switch (enmParity)
252	{
253	case PDMSERIALPARITY_EVEN:
254	Cfg.enmParity = RTSERIALPORTPARITY_EVEN;
255	break;
256	case PDMSERIALPARITY_ODD:
257	Cfg.enmParity = RTSERIALPORTPARITY_ODD;
258	break;
259	case PDMSERIALPARITY_NONE:
260	Cfg.enmParity = RTSERIALPORTPARITY_NONE;
261	break;
262	case PDMSERIALPARITY_MARK:
263	Cfg.enmParity = RTSERIALPORTPARITY_MARK;
264	break;
265	case PDMSERIALPARITY_SPACE:
266	Cfg.enmParity = RTSERIALPORTPARITY_SPACE;
267	break;
268	default:
269	AssertMsgFailed(("Unsupported parity setting %d\n", enmParity)); /* Should not happen. */
270	Cfg.enmParity = RTSERIALPORTPARITY_NONE;
271	}
272
273	switch (cDataBits)
274	{
275	case 5:
276	Cfg.enmDataBitCount = RTSERIALPORTDATABITS_5BITS;
277	break;
278	case 6:
279	Cfg.enmDataBitCount = RTSERIALPORTDATABITS_6BITS;
280	break;
281	case 7:
282	Cfg.enmDataBitCount = RTSERIALPORTDATABITS_7BITS;
283	break;
284	case 8:
285	Cfg.enmDataBitCount = RTSERIALPORTDATABITS_8BITS;
286	break;
287	default:
288	AssertMsgFailed(("Unsupported data bit count %u\n", cDataBits)); /* Should not happen. */
289	Cfg.enmDataBitCount = RTSERIALPORTDATABITS_8BITS;
290	}
291
292	switch (enmStopBits)
293	{
294	case PDMSERIALSTOPBITS_ONE:
295	Cfg.enmStopBitCount = RTSERIALPORTSTOPBITS_ONE;
296	break;
297	case PDMSERIALSTOPBITS_ONEPOINTFIVE:
298	Cfg.enmStopBitCount = RTSERIALPORTSTOPBITS_ONEPOINTFIVE;
299	break;
300	case PDMSERIALSTOPBITS_TWO:
301	Cfg.enmStopBitCount = RTSERIALPORTSTOPBITS_TWO;
302	break;
303	default:
304	AssertMsgFailed(("Unsupported stop bit count %d\n", enmStopBits)); /* Should not happen. */
305	Cfg.enmStopBitCount = RTSERIALPORTSTOPBITS_ONE;
306	}
307
308	return RTSerialPortCfgSet(pThis->hSerialPort, &Cfg, NULL);
309	}
310
311
312	/**
313	* @interface_method_impl{PDMISERIALCONNECTOR,pfnChgModemLines}
314	*/
315	static DECLCALLBACK(int) drvHostSerialChgModemLines(PPDMISERIALCONNECTOR pInterface, bool fRts, bool fDtr)
316	{
317	PDRVHOSTSERIAL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ISerialConnector);
318
319	uint32_t fClear = 0;
320	uint32_t fSet = 0;
321
322	if (fRts)
323	fSet \|= RTSERIALPORT_CHG_STS_LINES_F_RTS;
324	else
325	fClear \|= RTSERIALPORT_CHG_STS_LINES_F_RTS;
326
327	if (fDtr)
328	fSet \|= RTSERIALPORT_CHG_STS_LINES_F_DTR;
329	else
330	fClear \|= RTSERIALPORT_CHG_STS_LINES_F_DTR;
331
332	return RTSerialPortChgStatusLines(pThis->hSerialPort, fClear, fSet);
333	}
334
335
336	/**
337	* @interface_method_impl{PDMISERIALCONNECTOR,pfnChgBrk}
338	*/
339	static DECLCALLBACK(int) drvHostSerialChgBrk(PPDMISERIALCONNECTOR pInterface, bool fBrk)
340	{
341	PDRVHOSTSERIAL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ISerialConnector);
342
343	return RTSerialPortChgBreakCondition(pThis->hSerialPort, fBrk);
344	}
345
346
347	/**
348	* @interface_method_impl{PDMISERIALCONNECTOR,pfnQueryStsLines}
349	*/
350	static DECLCALLBACK(int) drvHostSerialQueryStsLines(PPDMISERIALCONNECTOR pInterface, uint32_t *pfStsLines)
351	{
352	PDRVHOSTSERIAL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ISerialConnector);
353
354	return RTSerialPortQueryStatusLines(pThis->hSerialPort, pfStsLines);
355	}
356
357
358	/* -=-=-=-=- I/O thread -=-=-=-=- */
359
360	/**
361	* I/O thread loop.
362	*
363	* @returns VINF_SUCCESS.
364	* @param pDrvIns PDM driver instance data.
365	* @param pThread The PDM thread data.
366	*/
367	static DECLCALLBACK(int) drvHostSerialIoThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
368	{
369	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
370
371	if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
372	return VINF_SUCCESS;
373
374	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
375	{
376	uint32_t fEvtFlags = RTSERIALPORT_EVT_F_STATUS_LINE_CHANGED \| RTSERIALPORT_EVT_F_BREAK_DETECTED;
377
378	/* Wait until there is room again if there is anyting to send. */
379	if ( pThis->cbAvailWr
380	\|\| pThis->cbTxUsed)
381	fEvtFlags \|= RTSERIALPORT_EVT_F_DATA_TX;
382
383	/* Try to receive more if there is still room. */
384	if (drvHostSerialReadBufGetWrite(pThis, NULL) > 0)
385	fEvtFlags \|= RTSERIALPORT_EVT_F_DATA_RX;
386
387	uint32_t fEvtsRecv = 0;
388	int rc = RTSerialPortEvtPoll(pThis->hSerialPort, fEvtFlags, &fEvtsRecv, RT_INDEFINITE_WAIT);
389	if (RT_SUCCESS(rc))
390	{
391	if (fEvtsRecv & RTSERIALPORT_EVT_F_DATA_TX)
392	{
393	if (pThis->cbAvailWr)
394	{
395	/* Stuff as much data into the TX buffer as we can. */
396	size_t cbToFetch = RT_MIN(RT_ELEMENTS(pThis->abTxBuf) - pThis->cbTxUsed, pThis->cbAvailWr);
397	size_t cbFetched = 0;
398	rc = pThis->pDrvSerialPort->pfnReadWr(pThis->pDrvSerialPort, &pThis->abTxBuf[pThis->cbTxUsed], cbToFetch,
399	&cbFetched);
400	AssertRC(rc);
401
402	if (cbFetched > 0)
403	{
404	ASMAtomicSubZ(&pThis->cbAvailWr, cbFetched);
405	pThis->cbTxUsed += cbFetched;
406	}
407	else
408	{
409	/* The guest reset the send queue and there is no data available anymore. */
410	pThis->cbAvailWr = 0;
411	}
412	}
413
414	if (pThis->cbTxUsed)
415	{
416	size_t cbProcessed = 0;
417	rc = RTSerialPortWriteNB(pThis->hSerialPort, &pThis->abTxBuf[0], pThis->cbTxUsed, &cbProcessed);
418	if (RT_SUCCESS(rc))
419	{
420	pThis->cbTxUsed -= cbProcessed;
421	if (pThis->cbTxUsed)
422	{
423	/* Move the data in the TX buffer to the front to fill the end again. */
424	memmove(&pThis->abTxBuf[0], &pThis->abTxBuf[cbProcessed], pThis->cbTxUsed);
425	}
426	else
427	pThis->pDrvSerialPort->pfnDataSentNotify(pThis->pDrvSerialPort);
428	STAM_COUNTER_ADD(&pThis->StatBytesWritten, cbProcessed);
429	}
430	else
431	{
432	LogRelMax(10, ("HostSerial#%d: Sending data failed even though the serial port is marked as writeable (rc=%Rrc)\n",
433	pThis->pDrvIns->iInstance, rc));
434	break;
435	}
436	}
437	}
438
439	if (fEvtsRecv & RTSERIALPORT_EVT_F_DATA_RX)
440	{
441	void *pvDst = NULL;
442	size_t cbToRead = drvHostSerialReadBufGetWrite(pThis, &pvDst);
443	size_t cbRead = 0;
444	rc = RTSerialPortReadNB(pThis->hSerialPort, pvDst, cbToRead, &cbRead);
445	if (RT_SUCCESS(rc))
446	{
447	drvHostSerialReadBufWriteAdv(pThis, cbRead);
448	/* Notify the device/driver above. */
449	rc = pThis->pDrvSerialPort->pfnDataAvailRdrNotify(pThis->pDrvSerialPort, cbRead);
450	AssertRC(rc);
451	}
452	else
453	LogRelMax(10, ("HostSerial#%d: Reading data failed even though the serial port is marked as readable (rc=%Rrc)\n",
454	pThis->pDrvIns->iInstance, rc));
455	}
456
457	if (fEvtsRecv & RTSERIALPORT_EVT_F_BREAK_DETECTED)
458	pThis->pDrvSerialPort->pfnNotifyBrk(pThis->pDrvSerialPort);
459
460	if (fEvtsRecv & RTSERIALPORT_EVT_F_STATUS_LINE_CHANGED)
461	{
462	/* The status lines have changed. Notify the device. */
463	uint32_t fStsLines = 0;
464	rc = RTSerialPortQueryStatusLines(pThis->hSerialPort, &fStsLines);
465	if (RT_SUCCESS(rc))
466	{
467	uint32_t fPdmStsLines = 0;
468
469	if (fStsLines & RTSERIALPORT_STS_LINE_DCD)
470	fPdmStsLines \|= PDMISERIALPORT_STS_LINE_DCD;
471	if (fStsLines & RTSERIALPORT_STS_LINE_RI)
472	fPdmStsLines \|= PDMISERIALPORT_STS_LINE_RI;
473	if (fStsLines & RTSERIALPORT_STS_LINE_DSR)
474	fPdmStsLines \|= PDMISERIALPORT_STS_LINE_DSR;
475	if (fStsLines & RTSERIALPORT_STS_LINE_CTS)
476	fPdmStsLines \|= PDMISERIALPORT_STS_LINE_CTS;
477
478	rc = pThis->pDrvSerialPort->pfnNotifyStsLinesChanged(pThis->pDrvSerialPort, fPdmStsLines);
479	if (RT_FAILURE(rc))
480	{
481	/* Notifying device failed, continue but log it */
482	LogRelMax(10, ("HostSerial#%d: Notifying device about changed status lines failed with error %Rrc; continuing.\n",
483	pDrvIns->iInstance, rc));
484	}
485	}
486	else
487	LogRelMax(10, ("HostSerial#%d: Getting status lines state failed with error %Rrc; continuing.\n", pDrvIns->iInstance, rc));
488	}
489
490	if (fEvtsRecv & RTSERIALPORT_EVT_F_STATUS_LINE_MONITOR_FAILED)
491	LogRel(("HostSerial#%d: Status line monitoring failed at a lower level and is disabled\n", pDrvIns->iInstance));
492	}
493	else if (rc == VERR_TIMEOUT \|\| rc == VERR_INTERRUPTED)
494	{
495	/* Getting interrupted or running into a timeout are no error conditions. */
496	rc = VINF_SUCCESS;
497	}
498	}
499
500	return VINF_SUCCESS;
501	}
502
503
504	/**
505	* Unblock the send thread so it can respond to a state change.
506	*
507	* @returns a VBox status code.
508	* @param pDrvIns The driver instance.
509	* @param pThread The send thread.
510	*/
511	static DECLCALLBACK(int) drvHostSerialWakeupIoThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
512	{
513	RT_NOREF(pThread);
514	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
515
516	return RTSerialPortEvtPollInterrupt(pThis->hSerialPort);
517	}
518
519
520	/* -=-=-=-=- driver interface -=-=-=-=- */
521
522	/**
523	* Destruct a char driver instance.
524	*
525	* Most VM resources are freed by the VM. This callback is provided so that
526	* any non-VM resources can be freed correctly.
527	*
528	* @param pDrvIns The driver instance data.
529	*/
530	static DECLCALLBACK(void) drvHostSerialDestruct(PPDMDRVINS pDrvIns)
531	{
532	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
533	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
534	LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
535
536	if (pThis->hSerialPort != NIL_RTSERIALPORT)
537	{
538	RTSerialPortClose(pThis->hSerialPort);
539	pThis->hSerialPort = NIL_RTSERIALPORT;
540	}
541
542	if (pThis->pszDevicePath)
543	{
544	MMR3HeapFree(pThis->pszDevicePath);
545	pThis->pszDevicePath = NULL;
546	}
547	}
548
549
550	/**
551	* Construct a char driver instance.
552	*
553	* @copydoc FNPDMDRVCONSTRUCT
554	*/
555	static DECLCALLBACK(int) drvHostSerialConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
556	{
557	RT_NOREF1(fFlags);
558	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
559	LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
560	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
561
562	/*
563	* Init basic data members and interfaces.
564	*/
565	pThis->pDrvIns = pDrvIns;
566	pThis->hSerialPort = NIL_RTSERIALPORT;
567	pThis->cbAvailWr = 0;
568	pThis->cbTxUsed = 0;
569	pThis->offWrite = 0;
570	pThis->offRead = 0;
571	pThis->cbReadBuf = 0;
572	/* IBase. */
573	pDrvIns->IBase.pfnQueryInterface = drvHostSerialQueryInterface;
574	/* ISerialConnector. */
575	pThis->ISerialConnector.pfnDataAvailWrNotify = drvHostSerialDataAvailWrNotify;
576	pThis->ISerialConnector.pfnReadRdr = drvHostSerialReadRdr;
577	pThis->ISerialConnector.pfnChgParams = drvHostSerialChgParams;
578	pThis->ISerialConnector.pfnChgModemLines = drvHostSerialChgModemLines;
579	pThis->ISerialConnector.pfnChgBrk = drvHostSerialChgBrk;
580	pThis->ISerialConnector.pfnQueryStsLines = drvHostSerialQueryStsLines;
581
582	/*
583	* Query configuration.
584	*/
585	/* Device */
586	int rc = CFGMR3QueryStringAlloc(pCfg, "DevicePath", &pThis->pszDevicePath);
587	if (RT_FAILURE(rc))
588	{
589	AssertMsgFailed(("Configuration error: query for \"DevicePath\" string returned %Rra.\n", rc));
590	return rc;
591	}
592
593	/*
594	* Open the device
595	*/
596	uint32_t fOpenFlags = RTSERIALPORT_OPEN_F_READ
597	\| RTSERIALPORT_OPEN_F_WRITE
598	\| RTSERIALPORT_OPEN_F_SUPPORT_STATUS_LINE_MONITORING
599	\| RTSERIALPORT_OPEN_F_DETECT_BREAK_CONDITION;
600	rc = RTSerialPortOpen(&pThis->hSerialPort, pThis->pszDevicePath, fOpenFlags);
601	if (rc == VERR_NOT_SUPPORTED)
602	{
603	/*
604	* For certain devices (or pseudo terminals) status line monitoring does not work
605	* so try again without it.
606	*/
607	fOpenFlags &= ~RTSERIALPORT_OPEN_F_SUPPORT_STATUS_LINE_MONITORING;
608	rc = RTSerialPortOpen(&pThis->hSerialPort, pThis->pszDevicePath, fOpenFlags);
609	}
610
611	if (RT_FAILURE(rc))
612	{
613	AssertMsgFailed(("Could not open host device %s, rc=%Rrc\n", pThis->pszDevicePath, rc));
614	switch (rc)
615	{
616	case VERR_ACCESS_DENIED:
617	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
618	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
619	N_("Cannot open host device '%s' for read/write access. Check the permissions "
620	"of that device ('/bin/ls -l %s'): Most probably you need to be member "
621	"of the device group. Make sure that you logout/login after changing "
622	"the group settings of the current user"),
623	#else
624	N_("Cannot open host device '%s' for read/write access. Check the permissions "
625	"of that device"),
626	#endif
627	pThis->pszDevicePath, pThis->pszDevicePath);
628	default:
629	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
630	N_("Failed to open host device '%s'"),
631	pThis->pszDevicePath);
632	}
633	}
634
635	/*
636	* Get the ISerialPort interface of the above driver/device.
637	*/
638	pThis->pDrvSerialPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMISERIALPORT);
639	if (!pThis->pDrvSerialPort)
640	return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE, RT_SRC_POS, N_("HostSerial#%d has no serial port interface above"), pDrvIns->iInstance);
641
642	/*
643	* Create the I/O thread.
644	*/
645	rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pIoThrd, pThis, drvHostSerialIoThread, drvHostSerialWakeupIoThread, 0, RTTHREADTYPE_IO, "SerIo");
646	if (RT_FAILURE(rc))
647	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostSerial#%d cannot create I/O thread"), pDrvIns->iInstance);
648
649	/*
650	* Register release statistics.
651	*/
652	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesWritten, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES,
653	"Nr of bytes written", "/Devices/HostSerial%d/Written", pDrvIns->iInstance);
654	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesRead, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES,
655	"Nr of bytes read", "/Devices/HostSerial%d/Read", pDrvIns->iInstance);
656
657	return VINF_SUCCESS;
658	}
659
660	/**
661	* Char driver registration record.
662	*/
663	const PDMDRVREG g_DrvHostSerial =
664	{
665	/* u32Version */
666	PDM_DRVREG_VERSION,
667	/* szName */
668	"Host Serial",
669	/* szRCMod */
670	"",
671	/* szR0Mod */
672	"",
673	/* pszDescription */
674	"Host serial driver.",
675	/* fFlags */
676	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
677	/* fClass. */
678	PDM_DRVREG_CLASS_CHAR,
679	/* cMaxInstances */
680	~0U,
681	/* cbInstance */
682	sizeof(DRVHOSTSERIAL),
683	/* pfnConstruct */
684	drvHostSerialConstruct,
685	/* pfnDestruct */
686	drvHostSerialDestruct,
687	/* pfnRelocate */
688	NULL,
689	/* pfnIOCtl */
690	NULL,
691	/* pfnPowerOn */
692	NULL,
693	/* pfnReset */
694	NULL,
695	/* pfnSuspend */
696	NULL,
697	/* pfnResume */
698	NULL,
699	/* pfnAttach */
700	NULL,
701	/* pfnDetach */
702	NULL,
703	/* pfnPowerOff */
704	NULL,
705	/* pfnSoftReset */
706	NULL,
707	/* u32EndVersion */
708	PDM_DRVREG_VERSION
709	};
710

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

source: vbox/trunk/src/VBox/Devices/Serial/DrvHostSerialNew.cpp@ 73565

Download in other formats: