serialport-os2.cpp@ 78607

Last change on this file since 78607 was 78607, checked in by vboxsync, 5 years ago
Runtime/RTSerialPort,ValidationKit/SerialTest: Add implementation for OS/2 and enable the SerialTest utility in the validation kit for OS/2
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 25.2 KB

Line
1	/* $Id: serialport-os2.cpp 78607 2019-05-20 20:59:49Z vboxsync $ */
2	/** @file
3	* IPRT - Serial Port API, OS/2 Implementation.
4	*/
5
6	/*
7	* Copyright (C) 2017-2019 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	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#define INCL_BASE
32	#define INCL_DOSFILEMGR
33	#define INCL_ERRORS
34	#define INCL_DOS
35	#define INCL_DOSDEVIOCTL
36	#define INCL_DOSDEVICES
37	#include <os2.h>
38	#undef RT_MAX
39
40	#include <iprt/serialport.h>
41	#include "internal/iprt.h"
42
43	#include <iprt/asm.h>
44	#include <iprt/assert.h>
45	#include <iprt/cdefs.h>
46	#include <iprt/err.h>
47	#include <iprt/mem.h>
48	#include <iprt/string.h>
49	#include <iprt/time.h>
50	#include "internal/magics.h"
51
52
53
54	/*********************************************************************************************************************************
55	* Structures and Typedefs *
56	*********************************************************************************************************************************/
57
58	/**
59	* Returned data structure for ASYNC_EXTGETBAUDRATE.
60	*/
61	typedef struct OS2EXTGETBAUDRATEDATA
62	{
63	/** Current bit rate. */
64	ULONG uBitRateCur;
65	/** Fraction of the current bit rate. */
66	BYTE bBitRateCurFrac;
67	/** Minimum supported bit rate. */
68	ULONG uBitRateMin;
69	/** Fraction of the minimum bit rate. */
70	BYTE bBitRateCurMin;
71	/** Maximum supported bit rate. */
72	ULONG uBitRateMax;
73	/** Fraction of the maximum bit rate. */
74	BYTE bBitRateCurMax;
75	} OS2EXTGETBAUDRATEDATA;
76	/** Pointer to the get extended baud rate data packet. */
77	typedef OS2EXTGETBAUDRATEDATA *POS2EXTGETBAUDRATEDATA;
78
79
80	/**
81	* Data packet for the ASYNC_EXTSETBAUDRATE ioctl.
82	*/
83	typedef struct OS2EXTSETBAUDRATEDATA
84	{
85	/** Current bit rate. */
86	ULONG uBitRate;
87	/** Fraction of the current bit rate. */
88	BYTE bBitRateFrac;
89	} OS2EXTSETBAUDRATEDATA;
90	/** Pointer to the set extended baud rate data packet. */
91	typedef OS2EXTSETBAUDRATEDATA *POS2EXTSETBAUDRATEDATA;
92
93
94	/**
95	* Data packet for the ASYNC_GETLINECTRL ioctl.
96	*/
97	typedef struct OS2GETLINECTRLDATA
98	{
99	/** Returns the current amount of data bits in a symbol used for the communication. */
100	BYTE bDataBits;
101	/** Current parity setting. */
102	BYTE bParity;
103	/** Current number of stop bits. */
104	BYTE bStopBits;
105	/** Flag whether a break condition is currently transmitted on the line. */
106	BYTE bTxBrk;
107	} OS2GETLINECTRLDATA;
108	/** Pointer to the get line control data packet. */
109	typedef OS2GETLINECTRLDATA *POS2GETLINECTRLDATA;
110
111
112	/**
113	* Data packet for the ASYNC_SETLINECTRL ioctl.
114	*/
115	typedef struct OS2SETLINECTRLDATA
116	{
117	/** Returns the current amount of data bits in a symbol used for the communication. */
118	BYTE bDataBits;
119	/** Current parity setting. */
120	BYTE bParity;
121	/** Current number of stop bits. */
122	BYTE bStopBits;
123	} OS2SETLINECTRLDATA;
124	/** Pointer to the get line control data packet. */
125	typedef OS2SETLINECTRLDATA *POS2SETLINECTRLDATA;
126
127
128	/**
129	* Internal serial port state.
130	*/
131	typedef struct RTSERIALPORTINTERNAL
132	{
133	/** Magic value (RTSERIALPORT_MAGIC). */
134	uint32_t u32Magic;
135	/** Flags given while opening the serial port. */
136	uint32_t fOpenFlags;
137	/** The file descriptor of the serial port. */
138	HFILE hDev;
139	/** Flag whether blocking mode is currently enabled. */
140	bool fBlocking;
141	/** Flag whether RTSerialPortEvtPoll() was interrupted by RTSerialPortEvtPollInterrupt(). */
142	volatile bool fInterrupt;
143	} RTSERIALPORTINTERNAL;
144	/** Pointer to the internal serial port state. */
145	typedef RTSERIALPORTINTERNAL *PRTSERIALPORTINTERNAL;
146
147
148
149	/*********************************************************************************************************************************
150	* Defined Constants And Macros *
151	*********************************************************************************************************************************/
152
153	/** Indicator whether the CTS input is set/clear. */
154	#define OS2_GET_MODEM_INPUT_CTS RT_BIT(4)
155	/** Indicator whether the DSR input is set/clear. */
156	#define OS2_GET_MODEM_INPUT_DSR RT_BIT(5)
157	/** Indicator whether the RI input is set/clear. */
158	#define OS2_GET_MODEM_INPUT_RI RT_BIT(6)
159	/** Indicator whether the DCD input is set/clear. */
160	#define OS2_GET_MODEM_INPUT_DCD RT_BIT(7)
161
162	/** There is something to read on the serial port. */
163	#define OS2_GET_COMM_EVT_RX RT_BIT(0)
164	/** A receive timeout interrupt was generated on the serial port during a read request. */
165	#define OS2_GET_COMM_EVT_RTI RT_BIT(1)
166	/** The transmit queue for the serial port is empty. */
167	#define OS2_GET_COMM_EVT_TX_EMPTY RT_BIT(2)
168	/** The CTS signal changes state. */
169	#define OS2_GET_COMM_EVT_CTS_CHG RT_BIT(3)
170	/** The DSR signal changes state. */
171	#define OS2_GET_COMM_EVT_DSR_CHG RT_BIT(4)
172	/** The DCD signal changes state. */
173	#define OS2_GET_COMM_EVT_DCD_CHG RT_BIT(5)
174	/** A break condition was detected on the serial port. */
175	#define OS2_GET_COMM_EVT_BRK RT_BIT(6)
176	/** A parity, framing or receive hardware overrun error occurred. */
177	#define OS2_GET_COMM_EVT_COMM_ERR RT_BIT(7)
178	/** Trailing edge ring indicator was detected. */
179	#define OS2_GET_COMM_EVT_RI_TRAIL_EDGE RT_BIT(8)
180
181
182	/*********************************************************************************************************************************
183	* Global variables *
184	*********************************************************************************************************************************/
185	/** OS/2 parity value to IPRT parity enum. */
186	static RTSERIALPORTPARITY s_aParityConvTbl[] =
187	{
188	RTSERIALPORTPARITY_NONE,
189	RTSERIALPORTPARITY_ODD,
190	RTSERIALPORTPARITY_EVEN,
191	RTSERIALPORTPARITY_MARK,
192	RTSERIALPORTPARITY_SPACE
193	};
194
195	/** OS/2 data bits value to IPRT data bits enum. */
196	static RTSERIALPORTDATABITS s_aDataBitsConvTbl[] =
197	{
198	RTSERIALPORTDATABITS_INVALID,
199	RTSERIALPORTDATABITS_INVALID,
200	RTSERIALPORTDATABITS_INVALID,
201	RTSERIALPORTDATABITS_INVALID,
202	RTSERIALPORTDATABITS_INVALID,
203	RTSERIALPORTDATABITS_5BITS,
204	RTSERIALPORTDATABITS_6BITS,
205	RTSERIALPORTDATABITS_7BITS,
206	RTSERIALPORTDATABITS_8BITS
207	};
208
209	/** OS/2 stop bits value to IPRT stop bits enum. */
210	static RTSERIALPORTSTOPBITS s_aStopBitsConvTbl[] =
211	{
212	RTSERIALPORTSTOPBITS_ONE,
213	RTSERIALPORTSTOPBITS_ONEPOINTFIVE,
214	RTSERIALPORTSTOPBITS_TWO
215	};
216
217
218	/*********************************************************************************************************************************
219	* Internal Functions *
220	*********************************************************************************************************************************/
221
222	/**
223	* The slow path of rtSerialPortSwitchBlockingMode that does the actual switching.
224	*
225	* @returns IPRT status code.
226	* @param pThis The internal serial port instance data.
227	* @param fBlocking The desired mode of operation.
228	* @remarks Do not call directly.
229	*
230	* @note Affects only read behavior.
231	*/
232	static int rtSerialPortSwitchBlockingModeSlow(PRTSERIALPORTINTERNAL pThis, bool fBlocking)
233	{
234	DCBINFO DcbInfo;
235	ULONG cbDcbInfo = sizeof(DcbInfo);
236	ULONG rcOs2 = DosDevIOCtl(pThis->hDev, IOCTL_ASYNC, ASYNC_GETDCBINFO, NULL, 0, NULL, &DcbInfo, cbDcbInfo, &cbDcbInfo);
237	if (!rcOs2)
238	{
239	DcbInfo.fbTimeout &= ~0x06;
240	DcbInfo.fbTimeout \|= fBlocking ? 0x04 : 0x06;
241	rcOs2 = DosDevIOCtl(pThis->hDev, IOCTL_ASYNC, ASYNC_SETDCBINFO, &DcbInfo, cbDcbInfo, &cbDcbInfo, NULL, 0, NULL);
242	if (rcOs2)
243	return RTErrConvertFromOS2(rcOs2);
244	}
245	else
246	return RTErrConvertFromOS2(rcOs2);
247
248	pThis->fBlocking = fBlocking;
249	return VINF_SUCCESS;
250	}
251
252
253	/**
254	* Switches the serial port to the desired blocking mode if necessary.
255	*
256	* @returns IPRT status code.
257	* @param pThis The internal serial port instance data.
258	* @param fBlocking The desired mode of operation.
259	*
260	* @note Affects only read behavior.
261	*/
262	DECLINLINE(int) rtSerialPortSwitchBlockingMode(PRTSERIALPORTINTERNAL pThis, bool fBlocking)
263	{
264	if (pThis->fBlocking != fBlocking)
265	return rtSerialPortSwitchBlockingModeSlow(pThis, fBlocking);
266	return VINF_SUCCESS;
267	}
268
269
270	RTDECL(int) RTSerialPortOpen(PRTSERIALPORT phSerialPort, const char *pszPortAddress, uint32_t fFlags)
271	{
272	AssertPtrReturn(phSerialPort, VERR_INVALID_POINTER);
273	AssertReturn(VALID_PTR(pszPortAddress) && *pszPortAddress != '\0', VERR_INVALID_PARAMETER);
274	AssertReturn(!(fFlags & ~RTSERIALPORT_OPEN_F_VALID_MASK), VERR_INVALID_PARAMETER);
275	AssertReturn((fFlags & RTSERIALPORT_OPEN_F_READ) \|\| (fFlags & RTSERIALPORT_OPEN_F_WRITE),
276	VERR_INVALID_PARAMETER);
277
278	int rc = VINF_SUCCESS;
279	PRTSERIALPORTINTERNAL pThis = (PRTSERIALPORTINTERNAL)RTMemAllocZ(sizeof(*pThis));
280	if (pThis)
281	{
282	ULONG fOpenMode = OPEN_SHARE_DENYREADWRITE
283	\| OPEN_FLAGS_SEQUENTIAL
284	\| OPEN_FLAGS_NOINHERIT
285	\| OPEN_FLAGS_FAIL_ON_ERROR;
286
287	if ((fFlags & RTSERIALPORT_OPEN_F_READ) && !(fFlags & RTSERIALPORT_OPEN_F_WRITE))
288	fOpenMode \|= OPEN_ACCESS_READONLY;
289	else if (!(fFlags & RTSERIALPORT_OPEN_F_READ) && (fFlags & RTSERIALPORT_OPEN_F_WRITE))
290	fOpenMode \|= OPEN_ACCESS_WRITEONLY;
291	else
292	fOpenMode \|= OPEN_ACCESS_READWRITE;
293
294	pThis->u32Magic = RTSERIALPORT_MAGIC;
295	pThis->fOpenFlags = fFlags;
296	pThis->fInterrupt = false;
297	pThis->fBlocking = true;
298
299	ULONG uAction = 0;
300	ULONG rcOs2 = DosOpen((const UCHAR *)pszPortAddress, &pThis->hDev, &uAction, 0, FILE_NORMAL, FILE_OPEN, fOpenMode, NULL);
301	if (!rcOs2)
302	{
303	/* Switch to a known read blocking mode. */
304	rc = rtSerialPortSwitchBlockingMode(pThis, false);
305	if (RT_SUCCESS(rc))
306	{
307	*phSerialPort = pThis;
308	return VINF_SUCCESS;
309	}
310
311	DosClose(pThis->hDev);
312	}
313	else
314	rc = RTErrConvertFromOS2(rcOs2);
315
316	RTMemFree(pThis);
317	}
318	else
319	rc = VERR_NO_MEMORY;
320
321	return rc;
322	}
323
324
325	RTDECL(int) RTSerialPortClose(RTSERIALPORT hSerialPort)
326	{
327	PRTSERIALPORTINTERNAL pThis = hSerialPort;
328	if (pThis == NIL_RTSERIALPORT)
329	return VINF_SUCCESS;
330	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
331	AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE);
332
333	/*
334	* Do the cleanup.
335	*/
336	AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, RTSERIALPORT_MAGIC_DEAD, RTSERIALPORT_MAGIC), VERR_INVALID_HANDLE);
337
338	DosClose(pThis->hDev);
339	RTMemFree(pThis);
340	return VINF_SUCCESS;
341	}
342
343
344	RTDECL(RTHCINTPTR) RTSerialPortToNative(RTSERIALPORT hSerialPort)
345	{
346	PRTSERIALPORTINTERNAL pThis = hSerialPort;
347	AssertPtrReturn(pThis, -1);
348	AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, -1);
349
350	return pThis->hDev;
351	}
352
353
354	RTDECL(int) RTSerialPortRead(RTSERIALPORT hSerialPort, void pvBuf, size_t cbToRead, size_t pcbRead)
355	{
356	PRTSERIALPORTINTERNAL pThis = hSerialPort;
357	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
358	AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE);
359	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
360	AssertReturn(cbToRead > 0, VERR_INVALID_PARAMETER);
361
362	int rc = rtSerialPortSwitchBlockingMode(pThis, true);
363	if (RT_SUCCESS(rc))
364	{
365	/*
366	* Attempt read.
367	*/
368	ULONG cbRead = 0;
369	ULONG rcOs2 = DosRead(pThis->hDev, pvBuf, cbToRead, &cbRead);
370	if (!rcOs2)
371	{
372	if (pcbRead)
373	/* caller can handle partial read. */
374	*pcbRead = cbRead;
375	else
376	{
377	/* Caller expects all to be read. */
378	while (cbToRead > cbRead)
379	{
380	ULONG cbReadPart = 0;
381	rcOs2 = DosRead(pThis->hDev, (uint8_t *)pvBuf + cbRead, cbToRead - cbRead, &cbReadPart);
382	if (rcOs2)
383	return RTErrConvertFromOS2(rcOs2);
384
385	cbRead += cbReadPart;
386	}
387	}
388	}
389	else
390	rc = RTErrConvertFromOS2(rcOs2);
391	}
392
393	return rc;
394	}
395
396
397	RTDECL(int) RTSerialPortReadNB(RTSERIALPORT hSerialPort, void pvBuf, size_t cbToRead, size_t pcbRead)
398	{
399	PRTSERIALPORTINTERNAL pThis = hSerialPort;
400	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
401	AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE);
402	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
403	AssertReturn(cbToRead > 0, VERR_INVALID_PARAMETER);
404	AssertPtrReturn(pcbRead, VERR_INVALID_POINTER);
405
406	*pcbRead = 0;
407
408	int rc = rtSerialPortSwitchBlockingMode(pThis, false);
409	if (RT_SUCCESS(rc))
410	{
411	ULONG cbThisRead = 0;
412	ULONG rcOs2 = DosRead(pThis->hDev, pvBuf, cbToRead, &cbThisRead);
413	if (!rcOs2)
414	{
415	*pcbRead = cbThisRead;
416
417	if (cbThisRead == 0)
418	rc = VINF_TRY_AGAIN;
419	}
420	else
421	rc = RTErrConvertFromOS2(rcOs2);
422	}
423
424	return rc;
425	}
426
427
428	RTDECL(int) RTSerialPortWrite(RTSERIALPORT hSerialPort, const void pvBuf, size_t cbToWrite, size_t pcbWritten)
429	{
430	PRTSERIALPORTINTERNAL pThis = hSerialPort;
431	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
432	AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE);
433	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
434	AssertReturn(cbToWrite > 0, VERR_INVALID_PARAMETER);
435
436	/*
437	* Attempt write.
438	*/
439	int rc = VINF_SUCCESS;
440	ULONG cbThisWritten = 0;
441	ULONG rcOs2 = DosWrite(pThis->hDev, pvBuf, cbToWrite, &cbThisWritten);
442	if (!rcOs2)
443	{
444	if (pcbWritten)
445	/* caller can handle partial write. */
446	*pcbWritten = cbThisWritten;
447	else
448	{
449	/** @todo Wait for TX empty and loop. */
450	rc = VERR_NOT_SUPPORTED;
451	}
452	}
453	else
454	rc = RTErrConvertFromOS2(rcOs2);
455
456	return rc;
457	}
458
459
460	RTDECL(int) RTSerialPortWriteNB(RTSERIALPORT hSerialPort, const void pvBuf, size_t cbToWrite, size_t pcbWritten)
461	{
462	PRTSERIALPORTINTERNAL pThis = hSerialPort;
463	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
464	AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE);
465	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
466	AssertReturn(cbToWrite > 0, VERR_INVALID_PARAMETER);
467	AssertPtrReturn(pcbWritten, VERR_INVALID_POINTER);
468
469	*pcbWritten = 0;
470
471	int rc = VINF_SUCCESS;
472	ULONG cbThisWritten = 0;
473	ULONG rcOs2 = DosWrite(pThis->hDev, pvBuf, cbToWrite, &cbThisWritten);
474	if (!rcOs2)
475	{
476	*pcbWritten = cbThisWritten;
477	if (!cbThisWritten)
478	rc = VINF_TRY_AGAIN;
479	}
480	else
481	rc = RTErrConvertFromOS2(rcOs2);
482
483	return rc;
484	}
485
486
487	RTDECL(int) RTSerialPortCfgQueryCurrent(RTSERIALPORT hSerialPort, PRTSERIALPORTCFG pCfg)
488	{
489	PRTSERIALPORTINTERNAL pThis = hSerialPort;
490	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
491	AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE);
492
493	int rc = VINF_SUCCESS;
494	OS2EXTGETBAUDRATEDATA ExtBaudRate;
495	ULONG cbExtBaudRate = sizeof(ExtBaudRate);
496	ULONG rcOs2 = DosDevIOCtl(pThis->hDev, IOCTL_ASYNC, ASYNC_EXTGETBAUDRATE, NULL, 0, NULL, &ExtBaudRate, cbExtBaudRate, &cbExtBaudRate);
497	if (!rcOs2)
498	{
499	OS2GETLINECTRLDATA LineCtrl;
500	ULONG cbLineCtrl = sizeof(LineCtrl);
501	rcOs2 = DosDevIOCtl(pThis->hDev, IOCTL_ASYNC, ASYNC_GETLINECTRL, NULL, 0, NULL, &LineCtrl, cbLineCtrl, &cbLineCtrl);
502	if (!rcOs2)
503	{
504	pCfg->uBaudRate = ExtBaudRate.uBitRateCur;
505	if (LineCtrl.bParity < RT_ELEMENTS(s_aParityConvTbl))
506	pCfg->enmParity = s_aParityConvTbl[LineCtrl.bParity];
507	else
508	rc = VERR_IPE_UNEXPECTED_STATUS;
509
510	if ( RT_SUCCESS(rc)
511	&& LineCtrl.bDataBits < RT_ELEMENTS(s_aDataBitsConvTbl)
512	&& s_aDataBitsConvTbl[LineCtrl.bDataBits] != RTSERIALPORTDATABITS_INVALID)
513	pCfg->enmDataBitCount = s_aDataBitsConvTbl[LineCtrl.bDataBits];
514	else
515	rc = VERR_IPE_UNEXPECTED_STATUS;
516
517	if ( RT_SUCCESS(rc)
518	&& LineCtrl.bStopBits < RT_ELEMENTS(s_aStopBitsConvTbl))
519	pCfg->enmStopBitCount = s_aStopBitsConvTbl[LineCtrl.bStopBits];
520	else
521	rc = VERR_IPE_UNEXPECTED_STATUS;
522	}
523	else
524	rc = RTErrConvertFromOS2(rcOs2);
525	}
526	else
527	rc = RTErrConvertFromOS2(rcOs2);
528
529	return rc;
530	}
531
532
533	RTDECL(int) RTSerialPortCfgSet(RTSERIALPORT hSerialPort, PCRTSERIALPORTCFG pCfg, PRTERRINFO pErrInfo)
534	{
535	PRTSERIALPORTINTERNAL pThis = hSerialPort;
536	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
537	AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE);
538
539	int rc = VINF_SUCCESS;
540	OS2EXTSETBAUDRATEDATA ExtBaudRate;
541	OS2SETLINECTRLDATA LineCtrl;
542	ULONG cbExtBaudRate = sizeof(ExtBaudRate);
543	ULONG cbLineCtrl = sizeof(LineCtrl);
544
545	ExtBaudRate.uBitRate = pCfg->uBaudRate;
546	ExtBaudRate.bBitRateFrac = 0;
547
548	BYTE idx = 0;
549	while (idx < RT_ELEMENTS(s_aParityConvTbl))
550	{
551	if (s_aParityConvTbl[idx] == pCfg->enmParity)
552	{
553	LineCtrl.bParity = idx;
554	break;
555	}
556	idx++;
557	}
558	AssertReturn(idx < RT_ELEMENTS(s_aParityConvTbl), VERR_INTERNAL_ERROR);
559
560	idx = 0;
561	while (idx < RT_ELEMENTS(s_aDataBitsConvTbl))
562	{
563	if (s_aDataBitsConvTbl[idx] == pCfg->enmDataBitCount)
564	{
565	LineCtrl.bDataBits = idx;
566	break;
567	}
568	idx++;
569	}
570	AssertReturn(idx < RT_ELEMENTS(s_aDataBitsConvTbl), VERR_INTERNAL_ERROR);
571
572	idx = 0;
573	while (idx < RT_ELEMENTS(s_aStopBitsConvTbl))
574	{
575	if (s_aStopBitsConvTbl[idx] == pCfg->enmStopBitCount)
576	{
577	LineCtrl.bStopBits = idx;
578	break;
579	}
580	idx++;
581	}
582	AssertReturn(idx < RT_ELEMENTS(s_aStopBitsConvTbl), VERR_INTERNAL_ERROR);
583
584	ULONG rcOs2 = DosDevIOCtl(pThis->hDev, IOCTL_ASYNC, ASYNC_EXTSETBAUDRATE, &ExtBaudRate, cbExtBaudRate, &cbExtBaudRate, NULL, 0, NULL);
585	if (!rcOs2)
586	{
587	rcOs2 = DosDevIOCtl(pThis->hDev, IOCTL_ASYNC, ASYNC_SETLINECTRL, &LineCtrl, cbLineCtrl, &cbLineCtrl, NULL, 0, NULL);
588	if (rcOs2)
589	rc = RTErrConvertFromOS2(rcOs2);
590	}
591	else
592	rc = RTErrConvertFromOS2(rcOs2);
593
594	return rc;
595	}
596
597
598	RTDECL(int) RTSerialPortEvtPoll(RTSERIALPORT hSerialPort, uint32_t fEvtMask, uint32_t *pfEvtsRecv,
599	RTMSINTERVAL msTimeout)
600	{
601	PRTSERIALPORTINTERNAL pThis = hSerialPort;
602	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
603	AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE);
604	AssertReturn(!(fEvtMask & ~RTSERIALPORT_EVT_F_VALID_MASK), VERR_INVALID_PARAMETER);
605	AssertPtrReturn(pfEvtsRecv, VERR_INVALID_POINTER);
606
607	*pfEvtsRecv = 0;
608
609	/*
610	* We need to kind of busy wait here as there is, to my knowledge, no API
611	* to wait for a COM event.
612	*
613	* @todo Adaptive waiting
614	* @todo Handle rollover after 48days eventually
615	*/
616	int rc = VINF_SUCCESS;
617	uint64_t tsStart = RTTimeSystemMilliTS();
618	do
619	{
620	if (ASMAtomicXchgBool(&pThis->fInterrupt, false))
621	{
622	rc = VERR_INTERRUPTED;
623	break;
624	}
625
626	USHORT fCommEvt = 0;
627	ULONG cbCommEvt = sizeof(fCommEvt);
628	ULONG rcOs2 = DosDevIOCtl(pThis->hDev, IOCTL_ASYNC, ASYNC_GETCOMMEVENT, NULL, 0, NULL,
629	&fCommEvt, cbCommEvt, &cbCommEvt);
630	if (!rcOs2)
631	{
632	AssertReturn(cbCommEvt = sizeof(fCommEvt), VERR_IPE_UNEXPECTED_STATUS);
633
634	if ( (fEvtMask & RTSERIALPORT_EVT_F_DATA_RX)
635	&& (fCommEvt & OS2_GET_COMM_EVT_RX))
636	*pfEvtsRecv \|= RTSERIALPORT_EVT_F_DATA_RX;
637
638	/** @todo Is there something better to indicate that there is room in the queue instead of queue is empty? */
639	if ( (fEvtMask & RTSERIALPORT_EVT_F_DATA_TX)
640	&& (fCommEvt & OS2_GET_COMM_EVT_TX_EMPTY))
641	*pfEvtsRecv \|= RTSERIALPORT_EVT_F_DATA_TX;
642
643	if ( (fEvtMask & RTSERIALPORT_EVT_F_STATUS_LINE_CHANGED)
644	&& (fCommEvt & (OS2_GET_COMM_EVT_CTS_CHG \| OS2_GET_COMM_EVT_DSR_CHG \| OS2_GET_COMM_EVT_DCD_CHG)))
645	*pfEvtsRecv \|= RTSERIALPORT_EVT_F_STATUS_LINE_CHANGED;
646
647	if ( (fEvtMask & RTSERIALPORT_EVT_F_BREAK_DETECTED)
648	&& (fCommEvt & OS2_GET_COMM_EVT_BRK))
649	*pfEvtsRecv \|= RTSERIALPORT_EVT_F_BREAK_DETECTED;
650
651	if (*pfEvtsRecv != 0)
652	break;
653	}
654	else
655	{
656	rc = RTErrConvertFromOS2(rcOs2);
657	break;
658	}
659
660	uint64_t tsNow = RTTimeSystemMilliTS();
661	if ( msTimeout == RT_INDEFINITE_WAIT
662	\|\| tsNow - tsStart < msTimeout)
663	DosSleep(1);
664	else
665	rc = VERR_TIMEOUT;
666	} while (RT_SUCCESS(rc));
667
668	return rc;
669	}
670
671
672	RTDECL(int) RTSerialPortEvtPollInterrupt(RTSERIALPORT hSerialPort)
673	{
674	PRTSERIALPORTINTERNAL pThis = hSerialPort;
675	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
676	AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE);
677
678	ASMAtomicXchgBool(&pThis->fInterrupt, true);
679	return VINF_SUCCESS;
680	}
681
682
683	RTDECL(int) RTSerialPortChgBreakCondition(RTSERIALPORT hSerialPort, bool fSet)
684	{
685	PRTSERIALPORTINTERNAL pThis = hSerialPort;
686	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
687	AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE);
688
689	ULONG rcOs2 = DosDevIOCtl(pThis->hDev, IOCTL_ASYNC, fSet ? ASYNC_SETBREAKON : ASYNC_SETBREAKOFF,
690	NULL, 0, NULL, NULL, 0, NULL);
691
692	return RTErrConvertFromOS2(rcOs2);
693	}
694
695
696	RTDECL(int) RTSerialPortChgStatusLines(RTSERIALPORT hSerialPort, uint32_t fClear, uint32_t fSet)
697	{
698	PRTSERIALPORTINTERNAL pThis = hSerialPort;
699	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
700	AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE);
701
702	MODEMSTATUS MdmSts;
703	ULONG cbMdmSts = sizeof(MdmSts);
704
705	MdmSts.fbModemOn = (fSet & RTSERIALPORT_CHG_STS_LINES_F_RTS ? 0x02 : 0x00)
706	\| (fSet & RTSERIALPORT_CHG_STS_LINES_F_DTR ? 0x01 : 0x00);
707	MdmSts.fbModemOff = 0xff;
708	MdmSts.fbModemOff &= ~( (fClear & RTSERIALPORT_CHG_STS_LINES_F_RTS ? 0x02 : 0x00)
709	\| (fClear & RTSERIALPORT_CHG_STS_LINES_F_DTR ? 0x01 : 0x00));
710
711	ULONG rcOs2 = DosDevIOCtl(pThis->hDev, IOCTL_ASYNC, ASYNC_SETMODEMCTRL, &MdmSts, cbMdmSts, &cbMdmSts, NULL, 0, NULL);
712
713	return RTErrConvertFromOS2(rcOs2);
714	}
715
716
717	RTDECL(int) RTSerialPortQueryStatusLines(RTSERIALPORT hSerialPort, uint32_t *pfStsLines)
718	{
719	PRTSERIALPORTINTERNAL pThis = hSerialPort;
720	AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
721	AssertReturn(pThis->u32Magic == RTSERIALPORT_MAGIC, VERR_INVALID_HANDLE);
722	AssertPtrReturn(pfStsLines, VERR_INVALID_POINTER);
723
724	*pfStsLines = 0;
725
726	int rc = VINF_SUCCESS;
727	BYTE fStsLines = 0;
728	ULONG cbStsLines = sizeof(fStsLines);
729	ULONG rcOs2 = DosDevIOCtl(pThis->hDev, IOCTL_ASYNC, ASYNC_GETMODEMINPUT, NULL, 0, NULL, &fStsLines, cbStsLines, &cbStsLines);
730	if (!rcOs2)
731	{
732	AssertReturn(cbStsLines == sizeof(BYTE), VERR_IPE_UNEXPECTED_STATUS);
733
734	*pfStsLines \|= (fStsLines & OS2_GET_MODEM_INPUT_DCD) ? RTSERIALPORT_STS_LINE_DCD : 0;
735	*pfStsLines \|= (fStsLines & OS2_GET_MODEM_INPUT_RI) ? RTSERIALPORT_STS_LINE_RI : 0;
736	*pfStsLines \|= (fStsLines & OS2_GET_MODEM_INPUT_DSR) ? RTSERIALPORT_STS_LINE_DSR : 0;
737	*pfStsLines \|= (fStsLines & OS2_GET_MODEM_INPUT_CTS) ? RTSERIALPORT_STS_LINE_CTS : 0;
738	}
739	else
740	rc = RTErrConvertFromOS2(rcOs2);
741
742	return rc;
743	}
744

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

source: vbox/trunk/src/VBox/Runtime/r3/os2/serialport-os2.cpp@ 78607

Download in other formats: