2 * DEC 93 Erik Bos <erik@xs4all.nl>
4 * Copyright 1996 Marcus Meissner
6 * Copyright 2001 Mike McCormack
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 * Mar 31, 1999. Ove Kåven <ovek@arcticnet.no>
25 * - Implemented buffers and EnableCommNotification.
27 * Apr 3, 1999. Lawson Whitney <lawson_whitney@juno.com>
28 * - Fixed the modem control part of EscapeCommFunction16.
30 * Mar 3, 1999. Ove Kåven <ovek@arcticnet.no>
31 * - Use port indices instead of unixfds for win16
32 * - Moved things around (separated win16 and win32 routines)
33 * - Added some hints on how to implement buffers and EnableCommNotification.
35 * May 26, 1997. Fixes and comments by Rick Richardson <rick@dgii.com> [RER]
36 * - ptr->fd wasn't getting cleared on close.
37 * - GetCommEventMask() and GetCommError() didn't do much of anything.
38 * IMHO, they are still wrong, but they at least implement the RXCHAR
39 * event and return I/O queue sizes, which makes the app I'm interested
40 * in (analog devices EZKIT DSP development system) work.
42 * August 12, 1997. Take a bash at SetCommEventMask - Lawson Whitney
43 * <lawson_whitney@juno.com>
44 * July 6, 1998. Fixes and comments by Valentijn Sessink
45 * <vsessink@ic.uva.nl> [V]
46 * Oktober 98, Rein Klazes [RHK]
47 * A program that wants to monitor the modem status line (RLSD/DCD) may
48 * poll the modem status register in the commMask structure. I update the bit
49 * in GetCommError, waiting for an implementation of communication events.
54 #include "wine/port.h"
65 #include "wine/winuser16.h"
67 #include "user_private.h"
69 #include "wine/debug.h"
71 WINE_DEFAULT_DEBUG_CHANNEL(comm
);
73 /* window's semi documented modem status register */
74 #define COMM_MSR_OFFSET 35
79 #define MSR_MASK (MSR_CTS|MSR_DSR|MSR_RI|MSR_RLSD)
85 struct DosDeviceStruct
{
91 int commerror
, eventmask
;
94 unsigned ibuf_size
,ibuf_head
,ibuf_tail
;
95 unsigned obuf_size
,obuf_head
,obuf_tail
;
99 OVERLAPPED read_ov
, write_ov
;
100 /* save terminal states */
102 /* pointer to unknown(==undocumented) comm structure */
107 static struct DosDeviceStruct COM
[MAX_PORTS
];
108 static struct DosDeviceStruct LPT
[MAX_PORTS
];
110 /* update window's semi documented modem status register */
111 /* see knowledge base Q101417 */
112 static void COMM_MSRUpdate( HANDLE handle
, UCHAR
* pMsr
)
117 if(!GetCommModemStatus(handle
,&mstat
))
120 if(mstat
& MS_CTS_ON
) tmpmsr
|= MSR_CTS
;
121 if(mstat
& MS_DSR_ON
) tmpmsr
|= MSR_DSR
;
122 if(mstat
& MS_RING_ON
) tmpmsr
|= MSR_RI
;
123 if(mstat
& MS_RLSD_ON
) tmpmsr
|= MSR_RLSD
;
124 *pMsr
= (*pMsr
& ~MSR_MASK
) | tmpmsr
;
127 static struct DosDeviceStruct
*GetDeviceStruct(int index
)
129 if ((index
&0x7F)<=MAX_PORTS
) {
130 if (!(index
&FLAG_LPT
)) {
131 if (COM
[index
].handle
)
135 if (LPT
[index
].handle
)
143 static int GetCommPort_ov(const OVERLAPPED
*ov
, int write
)
147 for (x
=0; x
<MAX_PORTS
; x
++) {
148 if (ov
== (write
?&COM
[x
].write_ov
:&COM
[x
].read_ov
))
155 static int WinError(void)
157 TRACE("errno = %d\n", errno
);
164 static unsigned comm_inbuf(const struct DosDeviceStruct
*ptr
)
166 return ((ptr
->ibuf_tail
> ptr
->ibuf_head
) ? ptr
->ibuf_size
: 0)
167 + ptr
->ibuf_head
- ptr
->ibuf_tail
;
170 static unsigned comm_outbuf(const struct DosDeviceStruct
*ptr
)
172 return ((ptr
->obuf_tail
> ptr
->obuf_head
) ? ptr
->obuf_size
: 0)
173 + ptr
->obuf_head
- ptr
->obuf_tail
;
176 static void comm_waitread(struct DosDeviceStruct
*ptr
);
177 static void comm_waitwrite(struct DosDeviceStruct
*ptr
);
179 static VOID WINAPI
COMM16_ReadComplete(DWORD dwErrorCode
, DWORD len
, LPOVERLAPPED ov
)
183 int cid
= GetCommPort_ov(ov
,0);
184 struct DosDeviceStruct
*ptr
;
187 ERR("async write with bad overlapped pointer\n");
192 /* we get cancelled when CloseComm is called */
193 if (dwErrorCode
==ERROR_OPERATION_ABORTED
)
195 TRACE("Cancelled\n");
199 /* read data from comm port */
200 if (dwErrorCode
!= NO_ERROR
) {
201 ERR("async read failed, error %d\n",dwErrorCode
);
202 COM
[cid
].commerror
= CE_RXOVER
;
205 TRACE("async read completed %d bytes\n",len
);
207 prev
= comm_inbuf(ptr
);
209 /* check for events */
210 if ((ptr
->eventmask
& EV_RXFLAG
) &&
211 memchr(ptr
->inbuf
+ ptr
->ibuf_head
, ptr
->evtchar
, len
)) {
212 *(WORD
*)(COM
[cid
].unknown
) |= EV_RXFLAG
;
215 if (ptr
->eventmask
& EV_RXCHAR
) {
216 *(WORD
*)(COM
[cid
].unknown
) |= EV_RXCHAR
;
220 /* advance buffer position */
221 ptr
->ibuf_head
+= len
;
222 if (ptr
->ibuf_head
>= ptr
->ibuf_size
)
225 /* check for notification */
226 if (ptr
->wnd
&& (ptr
->n_read
>0) && (prev
<ptr
->n_read
) &&
227 (comm_inbuf(ptr
)>=ptr
->n_read
)) {
228 /* passed the receive notification threshold */
232 /* send notifications, if any */
233 if (ptr
->wnd
&& mask
) {
234 TRACE("notifying %p: cid=%d, mask=%02x\n", ptr
->wnd
, cid
, mask
);
235 PostMessageA(ptr
->wnd
, WM_COMMNOTIFY
, cid
, mask
);
238 /* on real windows, this could cause problems, since it is recursive */
239 /* restart the receive */
243 /* this is meant to work like write() */
244 static INT
COMM16_WriteFile(HANDLE hComm
, LPCVOID buffer
, DWORD len
)
249 ZeroMemory(&ov
,sizeof(ov
));
250 ov
.hEvent
= CreateEventW(NULL
,0,0,NULL
);
251 if(ov
.hEvent
==INVALID_HANDLE_VALUE
)
254 if(!WriteFile(hComm
,buffer
,len
,&count
,&ov
))
256 if(GetLastError()==ERROR_IO_PENDING
)
258 GetOverlappedResult(hComm
,&ov
,&count
,TRUE
);
261 CloseHandle(ov
.hEvent
);
266 static VOID WINAPI
COMM16_WriteComplete(DWORD dwErrorCode
, DWORD len
, LPOVERLAPPED ov
)
270 int cid
= GetCommPort_ov(ov
,1);
271 struct DosDeviceStruct
*ptr
;
274 ERR("async write with bad overlapped pointer\n");
279 /* read data from comm port */
280 if (dwErrorCode
!= NO_ERROR
) {
281 ERR("async write failed, error %d\n",dwErrorCode
);
282 COM
[cid
].commerror
= CE_RXOVER
;
285 TRACE("async write completed %d bytes\n",len
);
287 /* update the buffer pointers */
288 prev
= comm_outbuf(&COM
[cid
]);
289 ptr
->obuf_tail
+= len
;
290 if (ptr
->obuf_tail
>= ptr
->obuf_size
)
293 /* write any TransmitCommChar character */
295 len
= COMM16_WriteFile(ptr
->handle
, &(ptr
->xmit
), 1);
296 if (len
> 0) ptr
->xmit
= -1;
299 /* write from output queue */
300 bleft
= ((ptr
->obuf_tail
<= ptr
->obuf_head
) ?
301 ptr
->obuf_head
: ptr
->obuf_size
) - ptr
->obuf_tail
;
303 /* check for notification */
304 if (ptr
->wnd
&& (ptr
->n_write
>0) && (prev
>=ptr
->n_write
) &&
305 (comm_outbuf(ptr
)<ptr
->n_write
)) {
306 /* passed the transmit notification threshold */
310 /* send notifications, if any */
311 if (ptr
->wnd
&& mask
) {
312 TRACE("notifying %p: cid=%d, mask=%02x\n", ptr
->wnd
, cid
, mask
);
313 PostMessageA(ptr
->wnd
, WM_COMMNOTIFY
, cid
, mask
);
316 /* start again if necessary */
321 static void comm_waitread(struct DosDeviceStruct
*ptr
)
326 /* FIXME: get timeouts working properly so we can read bleft bytes */
327 bleft
= ((ptr
->ibuf_tail
> ptr
->ibuf_head
) ?
328 (ptr
->ibuf_tail
-1) : ptr
->ibuf_size
) - ptr
->ibuf_head
;
330 /* find out how many bytes are left in the buffer */
331 if(ClearCommError(ptr
->handle
,NULL
,&stat
))
332 bleft
= (bleft
<stat
.cbInQue
) ? bleft
: stat
.cbInQue
;
336 /* always read at least one byte */
340 ReadFileEx(ptr
->handle
,
341 ptr
->inbuf
+ ptr
->ibuf_head
,
344 COMM16_ReadComplete
);
347 static void comm_waitwrite(struct DosDeviceStruct
*ptr
)
351 bleft
= ((ptr
->obuf_tail
<= ptr
->obuf_head
) ?
352 ptr
->obuf_head
: ptr
->obuf_size
) - ptr
->obuf_tail
;
353 WriteFileEx(ptr
->handle
,
354 ptr
->outbuf
+ ptr
->obuf_tail
,
357 COMM16_WriteComplete
);
360 /*****************************************************************************
361 * COMM16_DCBtoDCB16 (Internal)
363 static INT16
COMM16_DCBtoDCB16(const DCB
*lpdcb
, LPDCB16 lpdcb16
)
365 if(lpdcb
->BaudRate
<0x10000)
366 lpdcb16
->BaudRate
= lpdcb
->BaudRate
;
367 else if(lpdcb
->BaudRate
==115200)
368 lpdcb16
->BaudRate
= 57601;
370 WARN("Baud rate can't be converted\n");
371 lpdcb16
->BaudRate
= 57601;
373 lpdcb16
->ByteSize
= lpdcb
->ByteSize
;
374 lpdcb16
->fParity
= lpdcb
->fParity
;
375 lpdcb16
->Parity
= lpdcb
->Parity
;
376 lpdcb16
->StopBits
= lpdcb
->StopBits
;
378 lpdcb16
->RlsTimeout
= 50;
379 lpdcb16
->CtsTimeout
= 50;
380 lpdcb16
->DsrTimeout
= 50;
383 lpdcb16
->fBinary
= 1;
385 lpdcb16
->fDtrflow
= (lpdcb
->fDtrControl
==DTR_CONTROL_HANDSHAKE
);
386 lpdcb16
->fRtsflow
= (lpdcb
->fRtsControl
==RTS_CONTROL_HANDSHAKE
);
387 lpdcb16
->fOutxCtsFlow
= lpdcb
->fOutxCtsFlow
;
388 lpdcb16
->fOutxDsrFlow
= lpdcb
->fOutxDsrFlow
;
389 lpdcb16
->fDtrDisable
= (lpdcb
->fDtrControl
==DTR_CONTROL_DISABLE
);
391 lpdcb16
->fInX
= lpdcb
->fInX
;
393 lpdcb16
->fOutX
= lpdcb
->fOutX
;
398 lpdcb16
->XonLim
= 10;
399 lpdcb16
->XoffLim
= 10;
405 /**************************************************************************
406 * BuildCommDCB (USER.213)
408 * According to the ECMA-234 (368.3) the function will return FALSE on
409 * success, otherwise it will return -1.
411 INT16 WINAPI
BuildCommDCB16(LPCSTR device
, LPDCB16 lpdcb
)
413 /* "COM1:96,n,8,1" */
418 TRACE("(%s), ptr %p\n", device
, lpdcb
);
420 if (strncasecmp(device
,"COM",3))
422 port
= device
[3] - '0';
425 ERR("BUG ! COM0 can't exist!\n");
429 memset(lpdcb
, 0, sizeof(DCB16
)); /* initialize */
432 dcb
.DCBlength
= sizeof(DCB
);
434 if (strchr(device
,'=')) /* block new style */
437 if(!BuildCommDCBA(device
,&dcb
))
440 return COMM16_DCBtoDCB16(&dcb
, lpdcb
);
443 /*****************************************************************************
444 * OpenComm (USER.200)
446 INT16 WINAPI
OpenComm16(LPCSTR device
,UINT16 cbInQueue
,UINT16 cbOutQueue
)
451 TRACE("%s, %d, %d\n", device
, cbInQueue
, cbOutQueue
);
453 if (strlen(device
) < 4)
456 port
= device
[3] - '0';
459 ERR("BUG ! COM0 or LPT0 don't exist !\n");
461 if (!strncasecmp(device
,"COM",3))
463 if (COM
[port
].handle
)
466 handle
= CreateFileA(device
, GENERIC_READ
|GENERIC_WRITE
,
467 FILE_SHARE_READ
| FILE_SHARE_WRITE
, NULL
, CREATE_ALWAYS
,
468 FILE_FLAG_OVERLAPPED
|FILE_FLAG_NO_BUFFERING
, 0 );
469 if (handle
== INVALID_HANDLE_VALUE
) {
472 memset(COM
[port
].unknown
, 0, sizeof(COM
[port
].unknown
));
473 COM
[port
].seg_unknown
= 0;
474 COM
[port
].handle
= handle
;
475 COM
[port
].commerror
= 0;
476 COM
[port
].eventmask
= 0;
477 COM
[port
].evtchar
= 0; /* FIXME: default? */
478 /* save terminal state */
479 GetCommState16(port
,&COM
[port
].dcb
);
480 /* init priority characters */
481 COM
[port
].unget
= -1;
483 /* allocate buffers */
484 COM
[port
].ibuf_size
= cbInQueue
;
485 COM
[port
].ibuf_head
= COM
[port
].ibuf_tail
= 0;
486 COM
[port
].obuf_size
= cbOutQueue
;
487 COM
[port
].obuf_head
= COM
[port
].obuf_tail
= 0;
489 COM
[port
].inbuf
= HeapAlloc(GetProcessHeap(), 0, cbInQueue
);
490 if (COM
[port
].inbuf
) {
491 COM
[port
].outbuf
= HeapAlloc( GetProcessHeap(), 0, cbOutQueue
);
492 if (!COM
[port
].outbuf
)
493 HeapFree( GetProcessHeap(), 0, COM
[port
].inbuf
);
494 } else COM
[port
].outbuf
= NULL
;
495 if (!COM
[port
].outbuf
) {
496 /* not enough memory */
497 CloseHandle(COM
[port
].handle
);
498 ERR("out of memory\n");
502 ZeroMemory(&COM
[port
].read_ov
,sizeof (OVERLAPPED
));
503 ZeroMemory(&COM
[port
].write_ov
,sizeof (OVERLAPPED
));
505 comm_waitread( &COM
[port
] );
506 USER16_AlertableWait
++;
512 if (!strncasecmp(device
,"LPT",3)) {
514 if (LPT
[port
].handle
)
517 handle
= CreateFileA(device
, GENERIC_READ
|GENERIC_WRITE
,
518 FILE_SHARE_READ
| FILE_SHARE_WRITE
, NULL
, CREATE_ALWAYS
, 0, 0 );
519 if (handle
== INVALID_HANDLE_VALUE
) {
522 LPT
[port
].handle
= handle
;
523 LPT
[port
].commerror
= 0;
524 LPT
[port
].eventmask
= 0;
525 return port
|FLAG_LPT
;
531 /*****************************************************************************
532 * CloseComm (USER.207)
534 INT16 WINAPI
CloseComm16(INT16 cid
)
536 struct DosDeviceStruct
*ptr
;
538 TRACE("cid=%d\n", cid
);
539 if ((ptr
= GetDeviceStruct(cid
)) == NULL
) {
540 FIXME("no cid=%d found!\n", cid
);
543 if (!(cid
&FLAG_LPT
)) {
545 UnMapLS( COM
[cid
].seg_unknown
);
546 USER16_AlertableWait
--;
547 CancelIo(ptr
->handle
);
550 HeapFree( GetProcessHeap(), 0, ptr
->outbuf
);
551 HeapFree( GetProcessHeap(), 0, ptr
->inbuf
);
553 /* reset modem lines */
554 SetCommState16(&COM
[cid
].dcb
);
557 if (!CloseHandle(ptr
->handle
)) {
558 ptr
->commerror
= WinError();
559 /* FIXME: should we clear ptr->handle here? */
568 /*****************************************************************************
569 * SetCommBreak (USER.210)
571 INT16 WINAPI
SetCommBreak16(INT16 cid
)
573 struct DosDeviceStruct
*ptr
;
575 TRACE("cid=%d\n", cid
);
576 if ((ptr
= GetDeviceStruct(cid
)) == NULL
) {
577 FIXME("no cid=%d found!\n", cid
);
586 /*****************************************************************************
587 * ClearCommBreak (USER.211)
589 INT16 WINAPI
ClearCommBreak16(INT16 cid
)
591 struct DosDeviceStruct
*ptr
;
593 TRACE("cid=%d\n", cid
);
594 if (!(ptr
= GetDeviceStruct(cid
))) {
595 FIXME("no cid=%d found!\n", cid
);
603 /*****************************************************************************
604 * EscapeCommFunction (USER.214)
606 LONG WINAPI
EscapeCommFunction16(UINT16 cid
,UINT16 nFunction
)
608 struct DosDeviceStruct
*ptr
;
610 TRACE("cid=%d, function=%d\n", cid
, nFunction
);
614 TRACE("GETMAXCOM\n");
615 return 4; /* FIXME */
618 TRACE("GETMAXLPT\n");
619 return FLAG_LPT
+ 3; /* FIXME */
622 TRACE("GETBASEIRQ\n");
623 /* FIXME: use tables */
624 /* just fake something for now */
625 if (cid
& FLAG_LPT
) {
626 /* LPT1: irq 7, LPT2: irq 5 */
627 return (cid
& 0x7f) ? 5 : 7;
629 /* COM1: irq 4, COM2: irq 3,
630 COM3: irq 4, COM4: irq 3 */
631 return 4 - (cid
& 1);
635 if ((ptr
= GetDeviceStruct(cid
)) == NULL
) {
636 FIXME("no cid=%d found!\n", cid
);
648 if(EscapeCommFunction(ptr
->handle
,nFunction
))
651 ptr
->commerror
= WinError();
658 WARN("(cid=%d,nFunction=%d): Unknown function\n",
664 /*****************************************************************************
665 * FlushComm (USER.215)
667 INT16 WINAPI
FlushComm16(INT16 cid
,INT16 fnQueue
)
670 struct DosDeviceStruct
*ptr
;
672 TRACE("cid=%d, queue=%d\n", cid
, fnQueue
);
673 if ((ptr
= GetDeviceStruct(cid
)) == NULL
) {
674 FIXME("no cid=%d found!\n", cid
);
679 queue
= PURGE_TXABORT
;
680 ptr
->obuf_tail
= ptr
->obuf_head
;
683 queue
= PURGE_RXABORT
;
684 ptr
->ibuf_head
= ptr
->ibuf_tail
;
687 WARN("(cid=%d,fnQueue=%d):Unknown queue\n",
692 if (!PurgeComm(ptr
->handle
,queue
)) {
693 ptr
->commerror
= WinError();
701 /********************************************************************
702 * GetCommError (USER.203)
704 INT16 WINAPI
GetCommError16(INT16 cid
,LPCOMSTAT16 lpStat
)
707 struct DosDeviceStruct
*ptr
;
710 if ((ptr
= GetDeviceStruct(cid
)) == NULL
) {
711 FIXME("no handle for cid = %0x!\n",cid
);
715 WARN(" cid %d not comm port\n",cid
);
718 stol
= (unsigned char *)COM
[cid
].unknown
+ COMM_MSR_OFFSET
;
719 COMM_MSRUpdate( ptr
->handle
, stol
);
724 if (comm_inbuf(ptr
) == 0)
727 lpStat
->cbOutQue
= comm_outbuf(ptr
);
728 lpStat
->cbInQue
= comm_inbuf(ptr
);
730 TRACE("cid %d, error %d, stat %d in %d out %d, stol %x\n",
731 cid
, ptr
->commerror
, lpStat
->status
, lpStat
->cbInQue
,
732 lpStat
->cbOutQue
, *stol
);
735 TRACE("cid %d, error %d, lpStat NULL stol %x\n",
736 cid
, ptr
->commerror
, *stol
);
738 /* Return any errors and clear it */
739 temperror
= ptr
->commerror
;
744 /*****************************************************************************
745 * SetCommEventMask (USER.208)
747 SEGPTR WINAPI
SetCommEventMask16(INT16 cid
,UINT16 fuEvtMask
)
749 struct DosDeviceStruct
*ptr
;
752 TRACE("cid %d,mask %d\n",cid
,fuEvtMask
);
753 if ((ptr
= GetDeviceStruct(cid
)) == NULL
) {
754 FIXME("no handle for cid = %0x!\n",cid
);
758 ptr
->eventmask
= fuEvtMask
;
761 WARN(" cid %d not comm port\n",cid
);
764 /* it's a COM port ? -> modify flags */
765 stol
= (unsigned char *)COM
[cid
].unknown
+ COMM_MSR_OFFSET
;
766 COMM_MSRUpdate( ptr
->handle
, stol
);
768 TRACE(" modem dcd construct %x\n",*stol
);
769 if (!COM
[cid
].seg_unknown
) COM
[cid
].seg_unknown
= MapLS( COM
[cid
].unknown
);
770 return COM
[cid
].seg_unknown
;
773 /*****************************************************************************
774 * GetCommEventMask (USER.209)
776 UINT16 WINAPI
GetCommEventMask16(INT16 cid
,UINT16 fnEvtClear
)
778 struct DosDeviceStruct
*ptr
;
781 TRACE("cid %d, mask %d\n", cid
, fnEvtClear
);
782 if ((ptr
= GetDeviceStruct(cid
)) == NULL
) {
783 FIXME("no handle for cid = %0x!\n",cid
);
788 WARN(" cid %d not comm port\n",cid
);
792 events
= *(WORD
*)(COM
[cid
].unknown
) & fnEvtClear
;
793 *(WORD
*)(COM
[cid
].unknown
) &= ~fnEvtClear
;
797 /*****************************************************************************
798 * SetCommState (USER.201)
800 INT16 WINAPI
SetCommState16(LPDCB16 lpdcb
)
802 struct DosDeviceStruct
*ptr
;
805 TRACE("cid %d, ptr %p\n", lpdcb
->Id
, lpdcb
);
806 if ((ptr
= GetDeviceStruct(lpdcb
->Id
)) == NULL
) {
807 FIXME("no handle for cid = %0x!\n",lpdcb
->Id
);
811 memset(&dcb
,0,sizeof(dcb
));
812 dcb
.DCBlength
= sizeof(dcb
);
815 * according to MSDN, we should first interpret lpdcb->BaudRate as follows:
816 * 1. if the baud rate is a CBR constant, interpret it.
817 * 2. if it is greater than 57600, the baud rate is 115200
818 * 3. use the actual baudrate
819 * steps 2 and 3 are equivilent to 16550 baudrate divisor = 115200/BaudRate
820 * see http://support.microsoft.com/support/kb/articles/q108/9/28.asp
822 switch(lpdcb
->BaudRate
)
824 case CBR_110
: dcb
.BaudRate
= 110; break;
825 case CBR_300
: dcb
.BaudRate
= 300; break;
826 case CBR_600
: dcb
.BaudRate
= 600; break;
827 case CBR_1200
: dcb
.BaudRate
= 1200; break;
828 case CBR_2400
: dcb
.BaudRate
= 2400; break;
829 case CBR_4800
: dcb
.BaudRate
= 4800; break;
830 case CBR_9600
: dcb
.BaudRate
= 9600; break;
831 case CBR_14400
: dcb
.BaudRate
= 14400; break;
832 case CBR_19200
: dcb
.BaudRate
= 19200; break;
833 case CBR_38400
: dcb
.BaudRate
= 38400; break;
834 case CBR_56000
: dcb
.BaudRate
= 56000; break;
835 case CBR_128000
: dcb
.BaudRate
= 128000; break;
836 case CBR_256000
: dcb
.BaudRate
= 256000; break;
838 if(lpdcb
->BaudRate
>57600)
839 dcb
.BaudRate
= 115200;
841 dcb
.BaudRate
= lpdcb
->BaudRate
;
844 dcb
.ByteSize
=lpdcb
->ByteSize
;
845 dcb
.StopBits
=lpdcb
->StopBits
;
847 dcb
.fParity
=lpdcb
->fParity
;
848 dcb
.Parity
=lpdcb
->Parity
;
850 dcb
.fOutxCtsFlow
= lpdcb
->fOutxCtsFlow
;
852 if (lpdcb
->fDtrflow
|| lpdcb
->fRtsflow
)
853 dcb
.fRtsControl
= TRUE
;
855 if (lpdcb
->fDtrDisable
)
856 dcb
.fDtrControl
= TRUE
;
858 ptr
->evtchar
= lpdcb
->EvtChar
;
860 dcb
.fInX
= lpdcb
->fInX
;
861 dcb
.fOutX
= lpdcb
->fOutX
;
863 if (!SetCommState(ptr
->handle
,&dcb
)) {
864 ptr
->commerror
= WinError();
872 /*****************************************************************************
873 * GetCommState (USER.202)
875 INT16 WINAPI
GetCommState16(INT16 cid
, LPDCB16 lpdcb
)
877 struct DosDeviceStruct
*ptr
;
880 TRACE("cid %d, ptr %p\n", cid
, lpdcb
);
881 if ((ptr
= GetDeviceStruct(cid
)) == NULL
) {
882 FIXME("no handle for cid = %0x!\n",cid
);
885 if (!GetCommState(ptr
->handle
,&dcb
)) {
886 ptr
->commerror
= WinError();
892 COMM16_DCBtoDCB16(&dcb
,lpdcb
);
894 lpdcb
->EvtChar
= ptr
->evtchar
;
900 /*****************************************************************************
901 * TransmitCommChar (USER.206)
903 INT16 WINAPI
TransmitCommChar16(INT16 cid
,CHAR chTransmit
)
905 struct DosDeviceStruct
*ptr
;
907 TRACE("cid %d, data %d\n", cid
, chTransmit
);
908 if ((ptr
= GetDeviceStruct(cid
)) == NULL
) {
909 FIXME("no handle for cid = %0x!\n",cid
);
913 if (ptr
->suspended
) {
914 ptr
->commerror
= IE_HARDWARE
;
918 if (ptr
->xmit
>= 0) {
919 /* character already queued */
920 /* FIXME: which error would Windows return? */
921 ptr
->commerror
= CE_TXFULL
;
925 if (ptr
->obuf_head
== ptr
->obuf_tail
) {
926 /* transmit queue empty, try to transmit directly */
927 if(1!=COMM16_WriteFile(ptr
->handle
, &chTransmit
, 1))
929 /* didn't work, queue it */
930 ptr
->xmit
= chTransmit
;
934 /* data in queue, let this char be transmitted next */
935 ptr
->xmit
= chTransmit
;
943 /*****************************************************************************
944 * UngetCommChar (USER.212)
946 INT16 WINAPI
UngetCommChar16(INT16 cid
,CHAR chUnget
)
948 struct DosDeviceStruct
*ptr
;
950 TRACE("cid %d (char %d)\n", cid
, chUnget
);
951 if ((ptr
= GetDeviceStruct(cid
)) == NULL
) {
952 FIXME("no handle for cid = %0x!\n",cid
);
956 if (ptr
->suspended
) {
957 ptr
->commerror
= IE_HARDWARE
;
962 /* character already queued */
963 /* FIXME: which error would Windows return? */
964 ptr
->commerror
= CE_RXOVER
;
968 ptr
->unget
= chUnget
;
974 /*****************************************************************************
975 * ReadComm (USER.204)
977 INT16 WINAPI
ReadComm16(INT16 cid
,LPSTR lpvBuf
,INT16 cbRead
)
980 struct DosDeviceStruct
*ptr
;
981 LPSTR orgBuf
= lpvBuf
;
983 TRACE("cid %d, ptr %p, length %d\n", cid
, lpvBuf
, cbRead
);
984 if ((ptr
= GetDeviceStruct(cid
)) == NULL
) {
985 FIXME("no handle for cid = %0x!\n",cid
);
989 if (ptr
->suspended
) {
990 ptr
->commerror
= IE_HARDWARE
;
994 if(0==comm_inbuf(ptr
))
997 /* read unget character */
999 *lpvBuf
++ = ptr
->unget
;
1006 /* read from receive buffer */
1007 while (length
< cbRead
) {
1008 status
= ((ptr
->ibuf_head
< ptr
->ibuf_tail
) ?
1009 ptr
->ibuf_size
: ptr
->ibuf_head
) - ptr
->ibuf_tail
;
1011 if ((cbRead
- length
) < status
)
1012 status
= cbRead
- length
;
1014 memcpy(lpvBuf
, ptr
->inbuf
+ ptr
->ibuf_tail
, status
);
1015 ptr
->ibuf_tail
+= status
;
1016 if (ptr
->ibuf_tail
>= ptr
->ibuf_size
)
1022 TRACE("%s\n", debugstr_an( orgBuf
, length
));
1027 /*****************************************************************************
1028 * WriteComm (USER.205)
1030 INT16 WINAPI
WriteComm16(INT16 cid
, LPSTR lpvBuf
, INT16 cbWrite
)
1033 struct DosDeviceStruct
*ptr
;
1035 TRACE("cid %d, ptr %p, length %d\n",
1036 cid
, lpvBuf
, cbWrite
);
1037 if ((ptr
= GetDeviceStruct(cid
)) == NULL
) {
1038 FIXME("no handle for cid = %0x!\n",cid
);
1042 if (ptr
->suspended
) {
1043 ptr
->commerror
= IE_HARDWARE
;
1047 TRACE("%s\n", debugstr_an( lpvBuf
, cbWrite
));
1050 while (length
< cbWrite
) {
1051 if ((ptr
->obuf_head
== ptr
->obuf_tail
) && (ptr
->xmit
< 0)) {
1052 /* no data queued, try to write directly */
1053 status
= COMM16_WriteFile(ptr
->handle
, lpvBuf
, cbWrite
- length
);
1060 /* can't write directly, put into transmit buffer */
1061 status
= ((ptr
->obuf_tail
> ptr
->obuf_head
) ?
1062 (ptr
->obuf_tail
-1) : ptr
->obuf_size
) - ptr
->obuf_head
;
1064 if ((cbWrite
- length
) < status
)
1065 status
= cbWrite
- length
;
1066 memcpy(lpvBuf
, ptr
->outbuf
+ ptr
->obuf_head
, status
);
1067 ptr
->obuf_head
+= status
;
1068 if (ptr
->obuf_head
>= ptr
->obuf_size
)
1072 comm_waitwrite(ptr
);
1079 /***********************************************************************
1080 * EnableCommNotification (USER.245)
1082 BOOL16 WINAPI
EnableCommNotification16( INT16 cid
, HWND16 hwnd
,
1083 INT16 cbWriteNotify
, INT16 cbOutQueue
)
1085 struct DosDeviceStruct
*ptr
;
1087 TRACE("(%d, %x, %d, %d)\n", cid
, hwnd
, cbWriteNotify
, cbOutQueue
);
1088 if ((ptr
= GetDeviceStruct(cid
)) == NULL
) {
1089 FIXME("no handle for cid = %0x!\n",cid
);
1092 ptr
->wnd
= WIN_Handle32( hwnd
);
1093 ptr
->n_read
= cbWriteNotify
;
1094 ptr
->n_write
= cbOutQueue
;