1 /* Main file for COMM support
3 * DEC 93 Erik Bos <erik@xs4all.nl>
4 * Copyright 1996 Marcus Meissner
5 * Copyright 2005,2006 Eric Pouech
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #include "wine/port.h"
40 #ifdef HAVE_SYS_STAT_H
41 # include <sys/stat.h>
43 #include <sys/types.h>
44 #ifdef HAVE_SYS_FILIO_H
45 # include <sys/filio.h>
47 #ifdef HAVE_SYS_IOCTL_H
48 #include <sys/ioctl.h>
50 #ifdef HAVE_SYS_POLL_H
51 # include <sys/poll.h>
53 #ifdef HAVE_SYS_MODEM_H
54 # include <sys/modem.h>
56 #ifdef HAVE_SYS_STRTIO_H
57 # include <sys/strtio.h>
60 #define NONAMELESSUNION
61 #define NONAMELESSSTRUCT
63 #define WIN32_NO_STATUS
67 #include "ddk/ntddser.h"
68 #include "ntdll_misc.h"
69 #include "wine/server.h"
70 #include "wine/library.h"
71 #include "wine/debug.h"
73 #ifdef HAVE_LINUX_SERIAL_H
74 #ifdef HAVE_ASM_TYPES_H
75 #include <asm/types.h>
77 #include <linux/serial.h>
80 #if !defined(TIOCINQ) && defined(FIONREAD)
81 #define TIOCINQ FIONREAD
84 WINE_DEFAULT_DEBUG_CHANNEL(comm
);
86 static const char* iocode2str(DWORD ioc
)
90 #define X(x) case (x): return #x
91 X(IOCTL_SERIAL_CLEAR_STATS
);
92 X(IOCTL_SERIAL_CLR_DTR
);
93 X(IOCTL_SERIAL_CLR_RTS
);
94 X(IOCTL_SERIAL_CONFIG_SIZE
);
95 X(IOCTL_SERIAL_GET_BAUD_RATE
);
96 X(IOCTL_SERIAL_GET_CHARS
);
97 X(IOCTL_SERIAL_GET_COMMSTATUS
);
98 X(IOCTL_SERIAL_GET_DTRRTS
);
99 X(IOCTL_SERIAL_GET_HANDFLOW
);
100 X(IOCTL_SERIAL_GET_LINE_CONTROL
);
101 X(IOCTL_SERIAL_GET_MODEM_CONTROL
);
102 X(IOCTL_SERIAL_GET_MODEMSTATUS
);
103 X(IOCTL_SERIAL_GET_PROPERTIES
);
104 X(IOCTL_SERIAL_GET_STATS
);
105 X(IOCTL_SERIAL_GET_TIMEOUTS
);
106 X(IOCTL_SERIAL_GET_WAIT_MASK
);
107 X(IOCTL_SERIAL_IMMEDIATE_CHAR
);
108 X(IOCTL_SERIAL_LSRMST_INSERT
);
109 X(IOCTL_SERIAL_PURGE
);
110 X(IOCTL_SERIAL_RESET_DEVICE
);
111 X(IOCTL_SERIAL_SET_BAUD_RATE
);
112 X(IOCTL_SERIAL_SET_BREAK_ON
);
113 X(IOCTL_SERIAL_SET_BREAK_OFF
);
114 X(IOCTL_SERIAL_SET_CHARS
);
115 X(IOCTL_SERIAL_SET_DTR
);
116 X(IOCTL_SERIAL_SET_FIFO_CONTROL
);
117 X(IOCTL_SERIAL_SET_HANDFLOW
);
118 X(IOCTL_SERIAL_SET_LINE_CONTROL
);
119 X(IOCTL_SERIAL_SET_MODEM_CONTROL
);
120 X(IOCTL_SERIAL_SET_QUEUE_SIZE
);
121 X(IOCTL_SERIAL_SET_RTS
);
122 X(IOCTL_SERIAL_SET_TIMEOUTS
);
123 X(IOCTL_SERIAL_SET_WAIT_MASK
);
124 X(IOCTL_SERIAL_SET_XOFF
);
125 X(IOCTL_SERIAL_SET_XON
);
126 X(IOCTL_SERIAL_WAIT_ON_MASK
);
127 X(IOCTL_SERIAL_XOFF_COUNTER
);
129 default: { static char tmp
[32]; sprintf(tmp
, "IOCTL_SERIAL_%d\n", ioc
); return tmp
; }
133 static NTSTATUS
get_baud_rate(int fd
, SERIAL_BAUD_RATE
* sbr
)
138 if (tcgetattr(fd
, &port
) == -1)
140 ERR("tcgetattr error '%s'\n", strerror(errno
));
141 return FILE_GetNtStatus();
143 speed
= cfgetospeed(&port
);
146 case B0
: sbr
->BaudRate
= 0; break;
147 case B50
: sbr
->BaudRate
= 50; break;
148 case B75
: sbr
->BaudRate
= 75; break;
149 case B110
: sbr
->BaudRate
= 110; break;
150 case B134
: sbr
->BaudRate
= 134; break;
151 case B150
: sbr
->BaudRate
= 150; break;
152 case B200
: sbr
->BaudRate
= 200; break;
153 case B300
: sbr
->BaudRate
= 300; break;
154 case B600
: sbr
->BaudRate
= 600; break;
155 case B1200
: sbr
->BaudRate
= 1200; break;
156 case B1800
: sbr
->BaudRate
= 1800; break;
157 case B2400
: sbr
->BaudRate
= 2400; break;
158 case B4800
: sbr
->BaudRate
= 4800; break;
159 case B9600
: sbr
->BaudRate
= 9600; break;
160 case B19200
: sbr
->BaudRate
= 19200; break;
161 case B38400
: sbr
->BaudRate
= 38400; break;
163 case B57600
: sbr
->BaudRate
= 57600; break;
166 case B115200
: sbr
->BaudRate
= 115200; break;
169 case B230400
: sbr
->BaudRate
= 230400; break;
172 case B460800
: sbr
->BaudRate
= 460800; break;
175 ERR("unknown speed %x\n", speed
);
176 return STATUS_INVALID_PARAMETER
;
178 return STATUS_SUCCESS
;
181 static NTSTATUS
get_hand_flow(int fd
, SERIAL_HANDFLOW
* shf
)
186 if (tcgetattr(fd
, &port
) == -1)
188 ERR("tcgetattr error '%s'\n", strerror(errno
));
189 return FILE_GetNtStatus();
191 /* termios does not support DTR/DSR flow control */
192 shf
->ControlHandShake
= 0;
193 shf
->FlowReplace
= 0;
195 if (ioctl(fd
, TIOCMGET
, &stat
) == -1)
197 WARN("ioctl error '%s'\n", strerror(errno
));
198 shf
->ControlHandShake
|= SERIAL_DTR_CONTROL
;
199 shf
->FlowReplace
|= SERIAL_RTS_CONTROL
;
202 WARN("Setting DTR/RTS to enabled by default\n");
203 shf
->ControlHandShake
|= SERIAL_DTR_CONTROL
;
204 shf
->FlowReplace
|= SERIAL_RTS_CONTROL
;
207 if (stat
& TIOCM_DTR
)
209 shf
->ControlHandShake
|= SERIAL_DTR_CONTROL
;
211 if (port
.c_cflag
& CRTSCTS
)
213 shf
->FlowReplace
|= SERIAL_RTS_CONTROL
;
214 shf
->ControlHandShake
|= SERIAL_CTS_HANDSHAKE
;
220 if (stat
& TIOCM_RTS
)
222 shf
->FlowReplace
|= SERIAL_RTS_CONTROL
;
224 if (port
.c_iflag
& IXOFF
)
225 shf
->FlowReplace
|= SERIAL_AUTO_RECEIVE
;
226 if (port
.c_iflag
& IXON
)
227 shf
->FlowReplace
|= SERIAL_AUTO_TRANSMIT
;
231 return STATUS_SUCCESS
;
234 static NTSTATUS
get_line_control(int fd
, SERIAL_LINE_CONTROL
* slc
)
238 if (tcgetattr(fd
, &port
) == -1)
240 ERR("tcgetattr error '%s'\n", strerror(errno
));
241 return FILE_GetNtStatus();
245 switch (port
.c_cflag
& (PARENB
| PARODD
| CMSPAR
))
247 switch (port
.c_cflag
& (PARENB
| PARODD
))
250 case 0: slc
->Parity
= NOPARITY
; break;
251 case PARENB
: slc
->Parity
= EVENPARITY
; break;
252 case PARENB
|PARODD
: slc
->Parity
= ODDPARITY
; break;
254 case PARENB
|CMSPAR
: slc
->Parity
= MARKPARITY
; break;
255 case PARENB
|PARODD
|CMSPAR
: slc
->Parity
= SPACEPARITY
; break;
258 switch (port
.c_cflag
& CSIZE
)
260 case CS5
: slc
->WordLength
= 5; break;
261 case CS6
: slc
->WordLength
= 6; break;
262 case CS7
: slc
->WordLength
= 7; break;
263 case CS8
: slc
->WordLength
= 8; break;
264 default: ERR("unknown size %x\n", (UINT
)(port
.c_cflag
& CSIZE
));
267 if (port
.c_cflag
& CSTOPB
)
269 if (slc
->WordLength
== 5)
270 slc
->StopBits
= ONE5STOPBITS
;
272 slc
->StopBits
= TWOSTOPBITS
;
275 slc
->StopBits
= ONESTOPBIT
;
277 return STATUS_SUCCESS
;
280 static NTSTATUS
get_modem_status(int fd
, DWORD
* lpModemStat
)
282 NTSTATUS status
= STATUS_NOT_SUPPORTED
;
287 if (!ioctl(fd
, TIOCMGET
, &mstat
))
290 if (mstat
& TIOCM_CTS
) *lpModemStat
|= MS_CTS_ON
;
293 if (mstat
& TIOCM_DSR
) *lpModemStat
|= MS_DSR_ON
;
296 if (mstat
& TIOCM_RNG
) *lpModemStat
|= MS_RING_ON
;
299 /* FIXME: Not really sure about RLSD UB 990810 */
300 if (mstat
& TIOCM_CAR
) *lpModemStat
|= MS_RLSD_ON
;
302 TRACE("%04x -> %s%s%s%s\n", mstat
,
303 (*lpModemStat
& MS_RLSD_ON
) ? "MS_RLSD_ON " : "",
304 (*lpModemStat
& MS_RING_ON
) ? "MS_RING_ON " : "",
305 (*lpModemStat
& MS_DSR_ON
) ? "MS_DSR_ON " : "",
306 (*lpModemStat
& MS_CTS_ON
) ? "MS_CTS_ON " : "");
307 return STATUS_SUCCESS
;
309 WARN("ioctl failed\n");
310 status
= FILE_GetNtStatus();
315 static NTSTATUS
get_special_chars(int fd
, SERIAL_CHARS
* sc
)
319 if (tcgetattr(fd
, &port
) == -1)
321 ERR("tcgetattr error '%s'\n", strerror(errno
));
322 return FILE_GetNtStatus();
324 sc
->EofChar
= port
.c_cc
[VEOF
];
325 sc
->ErrorChar
= 0xFF;
326 sc
->BreakChar
= 0; /* FIXME */
327 sc
->EventChar
= 0; /* FIXME */
328 sc
->XonChar
= port
.c_cc
[VSTART
];
329 sc
->XoffChar
= port
.c_cc
[VSTOP
];
331 return STATUS_SUCCESS
;
334 static NTSTATUS
get_status(int fd
, SERIAL_STATUS
* ss
)
336 NTSTATUS status
= STATUS_SUCCESS
;
340 ss
->EofReceived
= FALSE
;
341 ss
->WaitForImmediate
= FALSE
;
343 if (ioctl(fd
, TIOCOUTQ
, &ss
->AmountInOutQueue
) == -1)
345 WARN("ioctl returned error\n");
346 status
= FILE_GetNtStatus();
349 ss
->AmountInOutQueue
= 0; /* FIXME: find a different way to find out */
353 if (ioctl(fd
, TIOCINQ
, &ss
->AmountInInQueue
))
355 WARN("ioctl returned error\n");
356 status
= FILE_GetNtStatus();
359 ss
->AmountInInQueue
= 0; /* FIXME: find a different way to find out */
364 static NTSTATUS
get_timeouts(HANDLE handle
, SERIAL_TIMEOUTS
* st
)
367 SERVER_START_REQ( get_serial_info
)
369 req
->handle
= wine_server_obj_handle( handle
);
370 if (!(status
= wine_server_call( req
)))
372 st
->ReadIntervalTimeout
= reply
->readinterval
;
373 st
->ReadTotalTimeoutMultiplier
= reply
->readmult
;
374 st
->ReadTotalTimeoutConstant
= reply
->readconst
;
375 st
->WriteTotalTimeoutMultiplier
= reply
->writemult
;
376 st
->WriteTotalTimeoutConstant
= reply
->writeconst
;
383 static NTSTATUS
get_wait_mask(HANDLE hDevice
, DWORD
* mask
)
387 SERVER_START_REQ( get_serial_info
)
389 req
->handle
= wine_server_obj_handle( hDevice
);
390 if (!(status
= wine_server_call( req
)))
391 *mask
= reply
->eventmask
;
397 static NTSTATUS
purge(int fd
, DWORD flags
)
400 ** not exactly sure how these are different
401 ** Perhaps if we had our own internal queues, one flushes them
402 ** and the other flushes the kernel's buffers.
404 if (flags
& PURGE_TXABORT
) tcflush(fd
, TCOFLUSH
);
405 if (flags
& PURGE_RXABORT
) tcflush(fd
, TCIFLUSH
);
406 if (flags
& PURGE_TXCLEAR
) tcflush(fd
, TCOFLUSH
);
407 if (flags
& PURGE_RXCLEAR
) tcflush(fd
, TCIFLUSH
);
408 return STATUS_SUCCESS
;
411 static NTSTATUS
set_baud_rate(int fd
, const SERIAL_BAUD_RATE
* sbr
)
415 if (tcgetattr(fd
, &port
) == -1)
417 ERR("tcgetattr error '%s'\n", strerror(errno
));
418 return FILE_GetNtStatus();
421 switch (sbr
->BaudRate
)
423 case 0: cfsetospeed( &port
, B0
); break;
424 case 50: cfsetospeed( &port
, B50
); break;
425 case 75: cfsetospeed( &port
, B75
); break;
427 case CBR_110
: cfsetospeed( &port
, B110
); break;
428 case 134: cfsetospeed( &port
, B134
); break;
429 case 150: cfsetospeed( &port
, B150
); break;
430 case 200: cfsetospeed( &port
, B200
); break;
432 case CBR_300
: cfsetospeed( &port
, B300
); break;
434 case CBR_600
: cfsetospeed( &port
, B600
); break;
436 case CBR_1200
: cfsetospeed( &port
, B1200
); break;
437 case 1800: cfsetospeed( &port
, B1800
); break;
439 case CBR_2400
: cfsetospeed( &port
, B2400
); break;
441 case CBR_4800
: cfsetospeed( &port
, B4800
); break;
443 case CBR_9600
: cfsetospeed( &port
, B9600
); break;
445 case CBR_19200
: cfsetospeed( &port
, B19200
); break;
447 case CBR_38400
: cfsetospeed( &port
, B38400
); break;
449 case 57600: cfsetospeed( &port
, B57600
); break;
452 case 115200: cfsetospeed( &port
, B115200
); break;
455 case 230400: cfsetospeed( &port
, B230400
); break;
458 case 460800: cfsetospeed( &port
, B460800
); break;
461 #if defined (HAVE_LINUX_SERIAL_H) && defined (TIOCSSERIAL)
463 struct serial_struct nuts
;
466 ioctl(fd
, TIOCGSERIAL
, &nuts
);
467 nuts
.custom_divisor
= nuts
.baud_base
/ sbr
->BaudRate
;
468 if (!(nuts
.custom_divisor
)) nuts
.custom_divisor
= 1;
469 arby
= nuts
.baud_base
/ nuts
.custom_divisor
;
470 nuts
.flags
&= ~ASYNC_SPD_MASK
;
471 nuts
.flags
|= ASYNC_SPD_CUST
;
472 WARN("You (or a program acting at your behest) have specified\n"
473 "a non-standard baud rate %d. Wine will set the rate to %d,\n"
474 "which is as close as we can get by our present understanding of your\n"
475 "hardware. I hope you know what you are doing. Any disruption Wine\n"
476 "has caused to your linux system can be undone with setserial\n"
477 "(see man setserial). If you have incapacitated a Hayes type modem,\n"
478 "reset it and it will probably recover.\n", sbr
->BaudRate
, arby
);
479 ioctl(fd
, TIOCSSERIAL
, &nuts
);
480 cfsetospeed( &port
, B38400
);
483 #else /* Don't have linux/serial.h or lack TIOCSSERIAL */
484 ERR("baudrate %d\n", sbr
->BaudRate
);
485 return STATUS_NOT_SUPPORTED
;
486 #endif /* Don't have linux/serial.h or lack TIOCSSERIAL */
488 cfsetispeed( &port
, cfgetospeed(&port
) );
489 if (tcsetattr(fd
, TCSANOW
, &port
) == -1)
491 ERR("tcsetattr error '%s'\n", strerror(errno
));
492 return FILE_GetNtStatus();
494 return STATUS_SUCCESS
;
497 static int whack_modem(int fd
, unsigned int andy
, unsigned int orrie
)
500 unsigned int mstat
, okay
;
501 okay
= ioctl(fd
, TIOCMGET
, &mstat
);
502 if (okay
) return okay
;
503 if (andy
) mstat
&= andy
;
505 return ioctl(fd
, TIOCMSET
, &mstat
);
511 static NTSTATUS
set_handflow(int fd
, const SERIAL_HANDFLOW
* shf
)
515 if ((shf
->FlowReplace
& (SERIAL_RTS_CONTROL
| SERIAL_RTS_HANDSHAKE
)) ==
516 (SERIAL_RTS_CONTROL
| SERIAL_RTS_HANDSHAKE
))
517 return STATUS_NOT_SUPPORTED
;
519 if (tcgetattr(fd
, &port
) == -1)
521 ERR("tcgetattr error '%s'\n", strerror(errno
));
522 return FILE_GetNtStatus();
526 if ((shf
->ControlHandShake
& SERIAL_CTS_HANDSHAKE
) ||
527 (shf
->FlowReplace
& SERIAL_RTS_HANDSHAKE
))
529 port
.c_cflag
|= CRTSCTS
;
533 port
.c_cflag
&= ~CRTSCTS
;
536 if (shf
->ControlHandShake
& SERIAL_DTR_HANDSHAKE
)
538 WARN("DSR/DTR flow control not supported\n");
539 } else if (!(shf
->ControlHandShake
& SERIAL_DTR_CONTROL
))
540 whack_modem(fd
, ~TIOCM_DTR
, 0);
542 whack_modem(fd
, 0, TIOCM_DTR
);
545 if (!(shf
->ControlHandShake
& SERIAL_CTS_HANDSHAKE
))
547 if ((shf
->FlowReplace
& (SERIAL_RTS_CONTROL
|SERIAL_RTS_HANDSHAKE
)) == 0)
548 whack_modem(fd
, ~TIOCM_RTS
, 0);
550 whack_modem(fd
, 0, TIOCM_RTS
);
554 if (shf
->FlowReplace
& SERIAL_AUTO_RECEIVE
)
555 port
.c_iflag
|= IXOFF
;
557 port
.c_iflag
&= ~IXOFF
;
558 if (shf
->FlowReplace
& SERIAL_AUTO_TRANSMIT
)
559 port
.c_iflag
|= IXON
;
561 port
.c_iflag
&= ~IXON
;
562 if (tcsetattr(fd
, TCSANOW
, &port
) == -1)
564 ERR("tcsetattr error '%s'\n", strerror(errno
));
565 return FILE_GetNtStatus();
568 return STATUS_SUCCESS
;
571 static NTSTATUS
set_line_control(int fd
, const SERIAL_LINE_CONTROL
* slc
)
574 unsigned bytesize
, stopbits
;
576 if (tcgetattr(fd
, &port
) == -1)
578 ERR("tcgetattr error '%s'\n", strerror(errno
));
579 return FILE_GetNtStatus();
583 port
.c_iflag
&= ~(ISTRIP
|BRKINT
|IGNCR
|ICRNL
|INLCR
|PARMRK
|IMAXBEL
);
585 port
.c_iflag
&= ~(ISTRIP
|BRKINT
|IGNCR
|ICRNL
|INLCR
|PARMRK
);
587 port
.c_iflag
|= IGNBRK
| INPCK
;
589 port
.c_oflag
&= ~(OPOST
);
591 port
.c_cflag
&= ~(HUPCL
);
592 port
.c_cflag
|= CLOCAL
| CREAD
;
595 * on FreeBSD, turning off ICANON does not disable IEXTEN,
596 * so we must turn it off explicitly. No harm done on Linux.
598 port
.c_lflag
&= ~(ICANON
|ECHO
|ISIG
|IEXTEN
);
599 port
.c_lflag
|= NOFLSH
;
601 bytesize
= slc
->WordLength
;
602 stopbits
= slc
->StopBits
;
605 port
.c_cflag
&= ~(PARENB
| PARODD
| CMSPAR
);
607 port
.c_cflag
&= ~(PARENB
| PARODD
);
610 /* make sure that reads don't block */
612 port
.c_cc
[VTIME
] = 0;
616 case NOPARITY
: port
.c_iflag
&= ~INPCK
; break;
617 case ODDPARITY
: port
.c_cflag
|= PARENB
| PARODD
; break;
618 case EVENPARITY
: port
.c_cflag
|= PARENB
; break;
620 /* Linux defines mark/space (stick) parity */
621 case MARKPARITY
: port
.c_cflag
|= PARENB
| CMSPAR
; break;
622 case SPACEPARITY
: port
.c_cflag
|= PARENB
| PARODD
| CMSPAR
; break;
624 /* try the POSIX way */
626 if (slc
->StopBits
== ONESTOPBIT
)
628 stopbits
= TWOSTOPBITS
;
629 port
.c_iflag
&= ~INPCK
;
633 ERR("Cannot set MARK Parity\n");
634 return STATUS_NOT_SUPPORTED
;
638 if (slc
->WordLength
< 8)
641 port
.c_iflag
&= ~INPCK
;
645 ERR("Cannot set SPACE Parity\n");
646 return STATUS_NOT_SUPPORTED
;
652 return STATUS_NOT_SUPPORTED
;
655 port
.c_cflag
&= ~CSIZE
;
658 case 5: port
.c_cflag
|= CS5
; break;
659 case 6: port
.c_cflag
|= CS6
; break;
660 case 7: port
.c_cflag
|= CS7
; break;
661 case 8: port
.c_cflag
|= CS8
; break;
664 return STATUS_NOT_SUPPORTED
;
669 case ONESTOPBIT
: port
.c_cflag
&= ~CSTOPB
; break;
670 case ONE5STOPBITS
: /* will be selected if bytesize is 5 */
671 case TWOSTOPBITS
: port
.c_cflag
|= CSTOPB
; break;
674 return STATUS_NOT_SUPPORTED
;
676 /* otherwise it hangs with pending input*/
677 if (tcsetattr(fd
, TCSANOW
, &port
) == -1)
679 ERR("tcsetattr error '%s'\n", strerror(errno
));
680 return FILE_GetNtStatus();
682 return STATUS_SUCCESS
;
685 static NTSTATUS
set_queue_size(int fd
, const SERIAL_QUEUE_SIZE
* sqs
)
687 FIXME("insize %d outsize %d unimplemented stub\n", sqs
->InSize
, sqs
->OutSize
);
688 return STATUS_SUCCESS
;
691 static NTSTATUS
set_special_chars(int fd
, const SERIAL_CHARS
* sc
)
695 if (tcgetattr(fd
, &port
) == -1)
697 ERR("tcgetattr error '%s'\n", strerror(errno
));
698 return FILE_GetNtStatus();
701 port
.c_cc
[VEOF
] = sc
->EofChar
;
702 /* FIXME: sc->ErrorChar is not supported */
703 /* FIXME: sc->BreakChar is not supported */
704 /* FIXME: sc->EventChar is not supported */
705 port
.c_cc
[VSTART
] = sc
->XonChar
;
706 port
.c_cc
[VSTOP
] = sc
->XoffChar
;
708 if (tcsetattr(fd
, TCSANOW
, &port
) == -1)
710 ERR("tcsetattr error '%s'\n", strerror(errno
));
711 return FILE_GetNtStatus();
713 return STATUS_SUCCESS
;
716 static NTSTATUS
set_timeouts(HANDLE handle
, const SERIAL_TIMEOUTS
* st
)
720 SERVER_START_REQ( set_serial_info
)
722 req
->handle
= wine_server_obj_handle( handle
);
723 req
->flags
= SERIALINFO_SET_TIMEOUTS
;
724 req
->readinterval
= st
->ReadIntervalTimeout
;
725 req
->readmult
= st
->ReadTotalTimeoutMultiplier
;
726 req
->readconst
= st
->ReadTotalTimeoutConstant
;
727 req
->writemult
= st
->WriteTotalTimeoutMultiplier
;
728 req
->writeconst
= st
->WriteTotalTimeoutConstant
;
729 status
= wine_server_call( req
);
735 static NTSTATUS
set_wait_mask(HANDLE hDevice
, DWORD mask
)
739 SERVER_START_REQ( set_serial_info
)
741 req
->handle
= wine_server_obj_handle( hDevice
);
742 req
->flags
= SERIALINFO_SET_MASK
;
743 req
->eventmask
= mask
;
744 status
= wine_server_call( req
);
751 * does not change IXOFF but simulates that IXOFF has been received:
753 static NTSTATUS
set_XOff(int fd
)
755 if (tcflow(fd
, TCOOFF
))
757 return FILE_GetNtStatus();
759 return STATUS_SUCCESS
;
763 * does not change IXON but simulates that IXON has been received:
765 static NTSTATUS
set_XOn(int fd
)
767 if (tcflow(fd
, TCOON
))
769 return FILE_GetNtStatus();
771 return STATUS_SUCCESS
;
775 * local structure holding the irq values we need for WaitCommEvent()
777 * Stripped down from struct serial_icounter_struct, which may not be available on some systems
778 * As the modem line interrupts (cts, dsr, rng, dcd) only get updated with TIOCMIWAIT active,
779 * no need to carry them in the internal structure
782 typedef struct serial_irq_info
784 int rx
, tx
, frame
, overrun
, parity
, brk
, buf_overrun
;
788 /***********************************************************************
789 * Data needed by the thread polling for the changing CommEvent
791 typedef struct async_commio
795 IO_STATUS_BLOCK
* iosb
;
799 serial_irq_info irq_info
;
802 /***********************************************************************
803 * Get extended interrupt count info, needed for wait_on
805 static NTSTATUS
get_irq_info(int fd
, serial_irq_info
*irq_info
)
808 struct serial_icounter_struct einfo
;
809 if (!ioctl(fd
, TIOCGICOUNT
, &einfo
))
811 irq_info
->rx
= einfo
.rx
;
812 irq_info
->tx
= einfo
.tx
;
813 irq_info
->frame
= einfo
.frame
;
814 irq_info
->overrun
= einfo
.overrun
;
815 irq_info
->parity
= einfo
.parity
;
816 irq_info
->brk
= einfo
.brk
;
817 irq_info
->buf_overrun
= einfo
.buf_overrun
;
821 TRACE("TIOCGICOUNT err %s\n", strerror(errno
));
822 memset(irq_info
,0, sizeof(serial_irq_info
));
823 return FILE_GetNtStatus();
826 memset(irq_info
,0, sizeof(serial_irq_info
));
827 return STATUS_NOT_IMPLEMENTED
;
830 /* Generate a single TX_TXEMPTY event when the TX Buffer turns empty*/
831 #ifdef TIOCSERGETLSR /* prefer to log the state TIOCSERGETLSR */
832 if (ioctl(fd
, TIOCSERGETLSR
, &irq_info
->temt
))
834 TRACE("TIOCSERGETLSR err %s\n", strerror(errno
));
835 return FILE_GetNtStatus();
837 #elif defined(TIOCOUTQ) /* otherwise we log when the out queue gets empty */
838 if (ioctl(fd
, TIOCOUTQ
, &irq_info
->temt
))
840 TRACE("TIOCOUTQ err %s\n", strerror(errno
));
841 return FILE_GetNtStatus();
845 if (irq_info
->temt
== 0)
849 return STATUS_SUCCESS
;
853 static DWORD
check_events(int fd
, DWORD mask
,
854 const serial_irq_info
*new,
855 const serial_irq_info
*old
,
856 DWORD new_mstat
, DWORD old_mstat
)
858 DWORD ret
= 0, queue
;
860 TRACE("mask 0x%08x\n", mask
);
861 TRACE("old->rx 0x%08x vs. new->rx 0x%08x\n", old
->rx
, new->rx
);
862 TRACE("old->tx 0x%08x vs. new->tx 0x%08x\n", old
->tx
, new->tx
);
863 TRACE("old->frame 0x%08x vs. new->frame 0x%08x\n", old
->frame
, new->frame
);
864 TRACE("old->overrun 0x%08x vs. new->overrun 0x%08x\n", old
->overrun
, new->overrun
);
865 TRACE("old->parity 0x%08x vs. new->parity 0x%08x\n", old
->parity
, new->parity
);
866 TRACE("old->brk 0x%08x vs. new->brk 0x%08x\n", old
->brk
, new->brk
);
867 TRACE("old->buf_overrun 0x%08x vs. new->buf_overrun 0x%08x\n", old
->buf_overrun
, new->buf_overrun
);
869 if (old
->brk
!= new->brk
) ret
|= EV_BREAK
;
870 if ((old_mstat
& MS_CTS_ON
) != (new_mstat
& MS_CTS_ON
)) ret
|= EV_CTS
;
871 if ((old_mstat
& MS_DSR_ON
) != (new_mstat
& MS_DSR_ON
)) ret
|= EV_DSR
;
872 if ((old_mstat
& MS_RING_ON
) != (new_mstat
& MS_RING_ON
)) ret
|= EV_RING
;
873 if ((old_mstat
& MS_RLSD_ON
) != (new_mstat
& MS_RLSD_ON
)) ret
|= EV_RLSD
;
874 if (old
->frame
!= new->frame
|| old
->overrun
!= new->overrun
|| old
->parity
!= new->parity
) ret
|= EV_ERR
;
875 if (mask
& EV_RXCHAR
)
879 if (ioctl(fd
, TIOCINQ
, &queue
))
880 WARN("TIOCINQ returned error\n");
885 if (mask
& EV_TXEMPTY
)
887 if (!old
->temt
&& new->temt
)
893 /***********************************************************************
894 * wait_for_event (INTERNAL)
896 * We need to poll for what is interesting
897 * TIOCMIWAIT only checks modem status line and may not be aborted by a changing mask
900 static DWORD CALLBACK
wait_for_event(LPVOID arg
)
902 async_commio
*commio
= arg
;
905 if (!server_get_unix_fd( commio
->hDevice
, FILE_READ_DATA
| FILE_WRITE_DATA
, &fd
, &needs_close
, NULL
, NULL
))
907 serial_irq_info new_irq_info
;
908 DWORD new_mstat
, new_evtmask
;
911 TRACE("device=%p fd=0x%08x mask=0x%08x buffer=%p event=%p irq_info=%p\n",
912 commio
->hDevice
, fd
, commio
->evtmask
, commio
->events
, commio
->hEvent
, &commio
->irq_info
);
914 time
.QuadPart
= (ULONGLONG
)10000;
915 time
.QuadPart
= -time
.QuadPart
;
919 * TIOCMIWAIT is not adequate
922 * We don't handle the EV_RXFLAG (the eventchar)
924 NtDelayExecution(FALSE
, &time
);
925 get_irq_info(fd
, &new_irq_info
);
926 if (get_modem_status(fd
, &new_mstat
))
927 TRACE("get_modem_status failed\n");
928 *commio
->events
= check_events(fd
, commio
->evtmask
,
929 &new_irq_info
, &commio
->irq_info
,
930 new_mstat
, commio
->mstat
);
931 if (*commio
->events
) break;
932 get_wait_mask(commio
->hDevice
, &new_evtmask
);
933 if (commio
->evtmask
!= new_evtmask
)
939 if (needs_close
) close( fd
);
941 if (commio
->iosb
) commio
->iosb
->u
.Status
= *commio
->events
? STATUS_SUCCESS
: STATUS_CANCELLED
;
942 if (commio
->hEvent
) NtSetEvent(commio
->hEvent
, NULL
);
943 RtlFreeHeap(GetProcessHeap(), 0, commio
);
947 static NTSTATUS
wait_on(HANDLE hDevice
, int fd
, HANDLE hEvent
, PIO_STATUS_BLOCK piosb
, DWORD
* events
)
949 async_commio
* commio
;
952 if ((status
= NtResetEvent(hEvent
, NULL
)))
955 commio
= RtlAllocateHeap(GetProcessHeap(), 0, sizeof (async_commio
));
956 if (!commio
) return STATUS_NO_MEMORY
;
958 commio
->hDevice
= hDevice
;
959 commio
->events
= events
;
960 commio
->iosb
= piosb
;
961 commio
->hEvent
= hEvent
;
962 get_wait_mask(commio
->hDevice
, &commio
->evtmask
);
964 /* We may never return, if some capabilities miss
965 * Return error in that case
967 #if !defined(TIOCINQ)
968 if (commio
->evtmask
& EV_RXCHAR
)
971 #if !(defined(TIOCSERGETLSR) && defined(TIOCSER_TEMT)) || !defined(TIOCINQ)
972 if (commio
->evtmask
& EV_TXEMPTY
)
975 #if !defined(TIOCMGET)
976 if (commio
->evtmask
& (EV_CTS
| EV_DSR
| EV_RING
| EV_RLSD
))
979 #if !defined(TIOCM_CTS)
980 if (commio
->evtmask
& EV_CTS
)
983 #if !defined(TIOCM_DSR)
984 if (commio
->evtmask
& EV_DSR
)
987 #if !defined(TIOCM_RNG)
988 if (commio
->evtmask
& EV_RING
)
991 #if !defined(TIOCM_CAR)
992 if (commio
->evtmask
& EV_RLSD
)
995 if (commio
->evtmask
& EV_RXFLAG
)
996 FIXME("EV_RXFLAG not handled\n");
998 if ((status
= get_irq_info(fd
, &commio
->irq_info
)) &&
999 (commio
->evtmask
& (EV_BREAK
| EV_ERR
)))
1002 if ((status
= get_modem_status(fd
, &commio
->mstat
)) &&
1003 (commio
->evtmask
& (EV_CTS
| EV_DSR
| EV_RING
| EV_RLSD
)))
1006 /* We might have received something or the TX buffer is delivered */
1007 *events
= check_events(fd
, commio
->evtmask
,
1008 &commio
->irq_info
, &commio
->irq_info
,
1009 commio
->mstat
, commio
->mstat
);
1012 status
= STATUS_SUCCESS
;
1016 /* create the worker for the task */
1017 status
= RtlQueueWorkItem(wait_for_event
, commio
, 0 /* FIXME */);
1018 if (status
!= STATUS_SUCCESS
) goto out_now
;
1019 return STATUS_PENDING
;
1021 #if !defined(TIOCINQ) || (!(defined(TIOCSERGETLSR) && defined(TIOCSER_TEMT)) || !defined(TIOCINQ)) || !defined(TIOCMGET) || !defined(TIOCM_CTS) ||!defined(TIOCM_DSR) || !defined(TIOCM_RNG) || !defined(TIOCM_CAR)
1023 FIXME("Returning error because of missing capabilities\n");
1024 status
= STATUS_INVALID_PARAMETER
;
1027 RtlFreeHeap(GetProcessHeap(), 0, commio
);
1031 static NTSTATUS
xmit_immediate(HANDLE hDevice
, int fd
, const char* ptr
)
1033 /* FIXME: not perfect as it should bypass the in-queue */
1034 WARN("(%p,'%c') not perfect!\n", hDevice
, *ptr
);
1035 if (write(fd
, ptr
, 1) != 1)
1036 return FILE_GetNtStatus();
1037 return STATUS_SUCCESS
;
1040 /******************************************************************
1041 * COMM_DeviceIoControl
1045 static inline NTSTATUS
io_control(HANDLE hDevice
,
1046 HANDLE hEvent
, PIO_APC_ROUTINE UserApcRoutine
,
1047 PVOID UserApcContext
,
1048 PIO_STATUS_BLOCK piosb
,
1049 ULONG dwIoControlCode
,
1050 LPVOID lpInBuffer
, DWORD nInBufferSize
,
1051 LPVOID lpOutBuffer
, DWORD nOutBufferSize
)
1053 DWORD sz
= 0, access
= FILE_READ_DATA
;
1054 NTSTATUS status
= STATUS_SUCCESS
;
1055 int fd
= -1, needs_close
= 0;
1057 TRACE("%p %s %p %d %p %d %p\n",
1058 hDevice
, iocode2str(dwIoControlCode
), lpInBuffer
, nInBufferSize
,
1059 lpOutBuffer
, nOutBufferSize
, piosb
);
1061 piosb
->Information
= 0;
1063 if (dwIoControlCode
!= IOCTL_SERIAL_GET_TIMEOUTS
&&
1064 dwIoControlCode
!= IOCTL_SERIAL_SET_TIMEOUTS
)
1066 enum server_fd_type type
;
1067 if ((status
= server_get_unix_fd( hDevice
, access
, &fd
, &needs_close
, &type
, NULL
)))
1069 if (type
!= FD_TYPE_SERIAL
)
1071 if (needs_close
) close( fd
);
1072 status
= STATUS_OBJECT_TYPE_MISMATCH
;
1077 switch (dwIoControlCode
)
1079 case IOCTL_SERIAL_CLR_DTR
:
1081 if (whack_modem(fd
, ~TIOCM_DTR
, 0) == -1) status
= FILE_GetNtStatus();
1083 status
= STATUS_NOT_SUPPORTED
;
1086 case IOCTL_SERIAL_CLR_RTS
:
1088 if (whack_modem(fd
, ~TIOCM_RTS
, 0) == -1) status
= FILE_GetNtStatus();
1090 status
= STATUS_NOT_SUPPORTED
;
1093 case IOCTL_SERIAL_GET_BAUD_RATE
:
1094 if (lpOutBuffer
&& nOutBufferSize
== sizeof(SERIAL_BAUD_RATE
))
1096 if (!(status
= get_baud_rate(fd
, lpOutBuffer
)))
1097 sz
= sizeof(SERIAL_BAUD_RATE
);
1100 status
= STATUS_INVALID_PARAMETER
;
1102 case IOCTL_SERIAL_GET_CHARS
:
1103 if (lpOutBuffer
&& nOutBufferSize
== sizeof(SERIAL_CHARS
))
1105 if (!(status
= get_special_chars(fd
, lpOutBuffer
)))
1106 sz
= sizeof(SERIAL_CHARS
);
1109 status
= STATUS_INVALID_PARAMETER
;
1111 case IOCTL_SERIAL_GET_COMMSTATUS
:
1112 if (lpOutBuffer
&& nOutBufferSize
== sizeof(SERIAL_STATUS
))
1114 if (!(status
= get_status(fd
, lpOutBuffer
)))
1115 sz
= sizeof(SERIAL_STATUS
);
1117 else status
= STATUS_INVALID_PARAMETER
;
1119 case IOCTL_SERIAL_GET_HANDFLOW
:
1120 if (lpOutBuffer
&& nOutBufferSize
== sizeof(SERIAL_HANDFLOW
))
1122 if (!(status
= get_hand_flow(fd
, lpOutBuffer
)))
1123 sz
= sizeof(SERIAL_HANDFLOW
);
1126 status
= STATUS_INVALID_PARAMETER
;
1128 case IOCTL_SERIAL_GET_LINE_CONTROL
:
1129 if (lpOutBuffer
&& nOutBufferSize
== sizeof(SERIAL_LINE_CONTROL
))
1131 if (!(status
= get_line_control(fd
, lpOutBuffer
)))
1132 sz
= sizeof(SERIAL_LINE_CONTROL
);
1135 status
= STATUS_INVALID_PARAMETER
;
1137 case IOCTL_SERIAL_GET_MODEMSTATUS
:
1138 if (lpOutBuffer
&& nOutBufferSize
== sizeof(DWORD
))
1140 if (!(status
= get_modem_status(fd
, lpOutBuffer
)))
1143 else status
= STATUS_INVALID_PARAMETER
;
1145 case IOCTL_SERIAL_GET_TIMEOUTS
:
1146 if (lpOutBuffer
&& nOutBufferSize
== sizeof(SERIAL_TIMEOUTS
))
1148 if (!(status
= get_timeouts(hDevice
, lpOutBuffer
)))
1149 sz
= sizeof(SERIAL_TIMEOUTS
);
1152 status
= STATUS_INVALID_PARAMETER
;
1154 case IOCTL_SERIAL_GET_WAIT_MASK
:
1155 if (lpOutBuffer
&& nOutBufferSize
== sizeof(DWORD
))
1157 if (!(status
= get_wait_mask(hDevice
, lpOutBuffer
)))
1161 status
= STATUS_INVALID_PARAMETER
;
1163 case IOCTL_SERIAL_IMMEDIATE_CHAR
:
1164 if (lpInBuffer
&& nInBufferSize
== sizeof(CHAR
))
1165 status
= xmit_immediate(hDevice
, fd
, lpInBuffer
);
1167 status
= STATUS_INVALID_PARAMETER
;
1169 case IOCTL_SERIAL_PURGE
:
1170 if (lpInBuffer
&& nInBufferSize
== sizeof(DWORD
))
1171 status
= purge(fd
, *(DWORD
*)lpInBuffer
);
1173 status
= STATUS_INVALID_PARAMETER
;
1175 case IOCTL_SERIAL_RESET_DEVICE
:
1176 FIXME("Unsupported\n");
1178 case IOCTL_SERIAL_SET_BAUD_RATE
:
1179 if (lpInBuffer
&& nInBufferSize
== sizeof(SERIAL_BAUD_RATE
))
1180 status
= set_baud_rate(fd
, lpInBuffer
);
1182 status
= STATUS_INVALID_PARAMETER
;
1184 case IOCTL_SERIAL_SET_BREAK_OFF
:
1185 #if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
1186 if (ioctl(fd
, TIOCCBRK
, 0) == -1)
1188 TRACE("ioctl failed\n");
1189 status
= FILE_GetNtStatus();
1192 FIXME("ioctl not available\n");
1193 status
= STATUS_NOT_SUPPORTED
;
1196 case IOCTL_SERIAL_SET_BREAK_ON
:
1197 #if defined(TIOCSBRK) && defined(TIOCCBRK) /* check if available for compilation */
1198 if (ioctl(fd
, TIOCSBRK
, 0) == -1)
1200 TRACE("ioctl failed\n");
1201 status
= FILE_GetNtStatus();
1204 FIXME("ioctl not available\n");
1205 status
= STATUS_NOT_SUPPORTED
;
1208 case IOCTL_SERIAL_SET_CHARS
:
1209 if (lpInBuffer
&& nInBufferSize
== sizeof(SERIAL_CHARS
))
1210 status
= set_special_chars(fd
, lpInBuffer
);
1212 status
= STATUS_INVALID_PARAMETER
;
1214 case IOCTL_SERIAL_SET_DTR
:
1216 if (whack_modem(fd
, 0, TIOCM_DTR
) == -1) status
= FILE_GetNtStatus();
1218 status
= STATUS_NOT_SUPPORTED
;
1221 case IOCTL_SERIAL_SET_HANDFLOW
:
1222 if (lpInBuffer
&& nInBufferSize
== sizeof(SERIAL_HANDFLOW
))
1223 status
= set_handflow(fd
, lpInBuffer
);
1225 status
= STATUS_INVALID_PARAMETER
;
1227 case IOCTL_SERIAL_SET_LINE_CONTROL
:
1228 if (lpInBuffer
&& nInBufferSize
== sizeof(SERIAL_LINE_CONTROL
))
1229 status
= set_line_control(fd
, lpInBuffer
);
1231 status
= STATUS_INVALID_PARAMETER
;
1233 case IOCTL_SERIAL_SET_QUEUE_SIZE
:
1234 if (lpInBuffer
&& nInBufferSize
== sizeof(SERIAL_QUEUE_SIZE
))
1235 status
= set_queue_size(fd
, lpInBuffer
);
1237 status
= STATUS_INVALID_PARAMETER
;
1239 case IOCTL_SERIAL_SET_RTS
:
1241 if (whack_modem(fd
, 0, TIOCM_RTS
) == -1) status
= FILE_GetNtStatus();
1243 status
= STATUS_NOT_SUPPORTED
;
1246 case IOCTL_SERIAL_SET_TIMEOUTS
:
1247 if (lpInBuffer
&& nInBufferSize
== sizeof(SERIAL_TIMEOUTS
))
1248 status
= set_timeouts(hDevice
, lpInBuffer
);
1250 status
= STATUS_INVALID_PARAMETER
;
1252 case IOCTL_SERIAL_SET_WAIT_MASK
:
1253 if (lpInBuffer
&& nInBufferSize
== sizeof(DWORD
))
1255 status
= set_wait_mask(hDevice
, *(DWORD
*)lpInBuffer
);
1257 else status
= STATUS_INVALID_PARAMETER
;
1259 case IOCTL_SERIAL_SET_XOFF
:
1260 status
= set_XOff(fd
);
1262 case IOCTL_SERIAL_SET_XON
:
1263 status
= set_XOn(fd
);
1265 case IOCTL_SERIAL_WAIT_ON_MASK
:
1266 if (lpOutBuffer
&& nOutBufferSize
== sizeof(DWORD
))
1268 if (!(status
= wait_on(hDevice
, fd
, hEvent
, piosb
, lpOutBuffer
)))
1272 status
= STATUS_INVALID_PARAMETER
;
1275 FIXME("Unsupported IOCTL %x (type=%x access=%x func=%x meth=%x)\n",
1276 dwIoControlCode
, dwIoControlCode
>> 16, (dwIoControlCode
>> 14) & 3,
1277 (dwIoControlCode
>> 2) & 0xFFF, dwIoControlCode
& 3);
1279 status
= STATUS_INVALID_PARAMETER
;
1282 if (needs_close
) close( fd
);
1284 piosb
->u
.Status
= status
;
1285 piosb
->Information
= sz
;
1286 if (hEvent
&& status
!= STATUS_PENDING
) NtSetEvent(hEvent
, NULL
);
1290 NTSTATUS
COMM_DeviceIoControl(HANDLE hDevice
,
1291 HANDLE hEvent
, PIO_APC_ROUTINE UserApcRoutine
,
1292 PVOID UserApcContext
,
1293 PIO_STATUS_BLOCK piosb
,
1294 ULONG dwIoControlCode
,
1295 LPVOID lpInBuffer
, DWORD nInBufferSize
,
1296 LPVOID lpOutBuffer
, DWORD nOutBufferSize
)
1300 if (dwIoControlCode
== IOCTL_SERIAL_WAIT_ON_MASK
)
1302 HANDLE hev
= hEvent
;
1304 /* this is an ioctl we implement in a non blocking way if hEvent is not
1306 * so we have to explicitly wait if no hEvent is provided
1310 OBJECT_ATTRIBUTES attr
;
1312 attr
.Length
= sizeof(attr
);
1313 attr
.RootDirectory
= 0;
1314 attr
.ObjectName
= NULL
;
1315 attr
.Attributes
= OBJ_CASE_INSENSITIVE
| OBJ_OPENIF
;
1316 attr
.SecurityDescriptor
= NULL
;
1317 attr
.SecurityQualityOfService
= NULL
;
1318 status
= NtCreateEvent(&hev
, EVENT_ALL_ACCESS
, &attr
, SynchronizationEvent
, FALSE
);
1320 if (status
) goto done
;
1322 status
= io_control(hDevice
, hev
, UserApcRoutine
, UserApcContext
,
1323 piosb
, dwIoControlCode
, lpInBuffer
, nInBufferSize
,
1324 lpOutBuffer
, nOutBufferSize
);
1327 if (status
== STATUS_PENDING
)
1329 NtWaitForSingleObject(hev
, FALSE
, NULL
);
1330 status
= STATUS_SUCCESS
;
1335 else status
= io_control(hDevice
, hEvent
, UserApcRoutine
, UserApcContext
,
1336 piosb
, dwIoControlCode
, lpInBuffer
, nInBufferSize
,
1337 lpOutBuffer
, nOutBufferSize
);