![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to posix-serial.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / host / posix|
Return to posix-serial.c CVS log | Up to [The Machine Emulator] / tme / host / posix |
1.1 root 1: /* $Id: posix-serial.c,v 1.7 2003/05/16 21:48:09 fredette Exp $ */
2:
3: /* host/posix/serial.c - implementation of serial ports on a POSIX system: */
4:
5: /*
6: * Copyright (c) 2003 Matt Fredette
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by Matt Fredette.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33: * POSSIBILITY OF SUCH DAMAGE.
34: */
35:
36: #include <tme/common.h>
37: _TME_RCSID("$Id: posix-serial.c,v 1.7 2003/05/16 21:48:09 fredette Exp $");
38:
39: /* includes: */
40: #include <tme/generic/serial.h>
41: #include <tme/threads.h>
42: #include <unistd.h>
43: #include <fcntl.h>
44: #include <stdio.h>
45: #include <termios.h>
46: #include <sys/types.h>
47: #include <sys/time.h>
48: #include <sys/ioctl.h>
49:
50: /* macros: */
51: #define TME_POSIX_SERIAL_BUFFER_SIZE (4096)
52:
53: /* structures: */
54: struct tme_posix_serial {
55:
56: /* our mutex: */
57: tme_mutex_t tme_posix_serial_mutex;
58:
59: /* backpointer to our element: */
60: struct tme_element *tme_posix_serial_element;
61:
62: /* our connection: */
63: struct tme_serial_connection *tme_posix_serial_connection;
64:
65: /* our writer thread condition: */
66: tme_cond_t tme_posix_serial_cond_writer;
67:
68: /* this is nonzero iff callouts are running: */
69: int tme_posix_serial_callouts_running;
70:
71: /* our input file descriptor: */
72: int tme_posix_serial_fd_in;
73:
74: /* our output file descriptor: */
75: int tme_posix_serial_fd_out;
76:
77: /* if we're emulating break: */
78: int tme_posix_serial_emulate_break;
79:
80: /* our current control inputs: */
81: unsigned int tme_posix_serial_ctrl_callin;
82:
83: /* the number of control output cycles to assert BREAK: */
84: int tme_posix_serial_ctrl_callout_break;
85:
86: /* our current control outputs: */
87: unsigned int tme_posix_serial_ctrl_callout;
88:
89: /* the last control outputs we successfully called out: */
90: unsigned int tme_posix_serial_ctrl_callout_last;
91:
92: /* our input and output buffers: */
93: struct tme_serial_buffer tme_posix_serial_buffer_in;
94: struct tme_serial_buffer tme_posix_serial_buffer_out;
95:
96: /* our input scanner state: */
97: int tme_posix_serial_input_scanner_state;
98: };
99:
100: /* the serial callout function. it must be called with the mutex locked: */
101: static void
102: _tme_posix_serial_callout(struct tme_posix_serial *serial)
103: {
104: struct tme_serial_connection *conn_serial;
105: unsigned int ctrl;
106: tme_uint8_t buffer_input[1024];
107: unsigned int buffer_input_size;
108: tme_serial_data_flags_t data_flags;
109: int rc;
110: int again;
111:
112: /* if this function is already running in another thread, return
113: now. the other thread will do our work: */
114: if (serial->tme_posix_serial_callouts_running) {
115: return;
116: }
117:
118: /* callouts are now running: */
119: serial->tme_posix_serial_callouts_running = TRUE;
120:
121: /* loop running callouts until there is nothing to do: */
122: for (again = TRUE; again;) {
123: again = FALSE;
124:
125: /* if we're connected: */
126: conn_serial = serial->tme_posix_serial_connection;
127: if (conn_serial != NULL) {
128:
129: /* if we need to notify our connection of new ctrl bits: */
130: ctrl = serial->tme_posix_serial_ctrl_callout;
131: if (ctrl != serial->tme_posix_serial_ctrl_callout_last) {
132:
133: /* unlock the mutex: */
134: tme_mutex_unlock(&serial->tme_posix_serial_mutex);
135:
136: /* try to do the notify: */
137: rc = (*conn_serial->tme_serial_connection_ctrl)(conn_serial, ctrl);
138:
139: /* lock the mutex: */
140: tme_mutex_lock(&serial->tme_posix_serial_mutex);
141:
142: /* if the notify was successful, note what we sent, and allow
143: the outermost loop to run again: */
144: if (rc == TME_OK) {
145: serial->tme_posix_serial_ctrl_callout_last = ctrl;
146: again = TRUE;
147: }
148: }
149:
150: /* if our connection is readable, and our output buffer isn't full,
151: read the connection: */
152: if ((serial->tme_posix_serial_ctrl_callin & TME_SERIAL_CTRL_OK_READ)
153: && !tme_serial_buffer_is_full(&serial->tme_posix_serial_buffer_out)) {
154:
155: /* get the minimum of the free space in the output buffer and
156: the size of our stack buffer: */
157: buffer_input_size = tme_serial_buffer_space_free(&serial->tme_posix_serial_buffer_out);
158: buffer_input_size = TME_MIN(buffer_input_size, sizeof(buffer_input));
159:
160: /* unlock the mutex: */
161: tme_mutex_unlock(&serial->tme_posix_serial_mutex);
162:
163: /* do the read: */
164: rc = (*conn_serial->tme_serial_connection_read)
165: (conn_serial,
166: buffer_input,
167: buffer_input_size,
168: &data_flags);
169:
170: /* lock the mutex: */
171: tme_mutex_lock(&serial->tme_posix_serial_mutex);
172:
173: /* if the read was successful, add what we got and notify the
174: writer so that it may try to write: */
175: if (rc > 0) {
176: (void) tme_serial_buffer_copyin(&serial->tme_posix_serial_buffer_out,
177: buffer_input,
178: rc,
179: data_flags,
180: TME_SERIAL_COPY_NORMAL);
181: tme_cond_notify(&serial->tme_posix_serial_cond_writer, TRUE);
182:
183: /* allow the outermost loop to run again: */
184: again = TRUE;
185: }
186:
187: /* otherwise, the read failed, and the convention dictates
188: that we forget this connection was readable: */
189: else {
190: serial->tme_posix_serial_ctrl_callin &= ~TME_SERIAL_CTRL_OK_READ;
191: }
192: }
193: }
194: }
195:
196: /* there are no more callouts to make: */
197: serial->tme_posix_serial_callouts_running = FALSE;
198: }
199:
200: /* the serial control thread: */
201: static void
202: _tme_posix_serial_th_ctrl(struct tme_posix_serial *serial)
203: {
204: int modem_state, modem_state_out;
205: unsigned int ctrl;
206:
207: /* loop forever: */
208: for (;;) {
209:
210: /* get the modem state of the input device: */
211: ioctl(serial->tme_posix_serial_fd_in, TIOCMGET, &modem_state);
212:
213: /* if the output device is different, get the modem state of the
214: output device and merge it in: */
215: if (serial->tme_posix_serial_fd_out
216: != serial->tme_posix_serial_fd_in) {
217: ioctl(serial->tme_posix_serial_fd_in, TIOCMGET, &modem_state_out);
218: modem_state &= ~(TIOCM_DTR | TIOCM_RTS | TIOCM_CTS);
219: modem_state |= modem_state_out & ~(TIOCM_CD | TIOCM_RI | TIOCM_DSR);
220: }
221:
222: /* lock the mutex: */
223: tme_mutex_lock(&serial->tme_posix_serial_mutex);
224:
225: /* update the control outputs: */
226: ctrl = (serial->tme_posix_serial_ctrl_callout
227: & ~(TME_SERIAL_CTRL_CTS
228: | TME_SERIAL_CTRL_DCD
229: | TME_SERIAL_CTRL_RI
230: | TME_SERIAL_CTRL_BREAK));
231: if (modem_state & TIOCM_CTS) {
232: ctrl |= TME_SERIAL_CTRL_CTS;
233: }
234: if (modem_state & TIOCM_CD) {
235: ctrl |= TME_SERIAL_CTRL_DCD;
236: }
237: if (modem_state & TIOCM_RI) {
238: ctrl |= TME_SERIAL_CTRL_RI;
239: }
240: if (serial->tme_posix_serial_ctrl_callout_break > 0) {
241: ctrl |= TME_SERIAL_CTRL_BREAK;
242: serial->tme_posix_serial_ctrl_callout_break--;
243: }
244:
245: /* if the control outputs have changed, call out the change: */
246: if (ctrl != serial->tme_posix_serial_ctrl_callout) {
247: serial->tme_posix_serial_ctrl_callout = ctrl;
248: _tme_posix_serial_callout(serial);
249: }
250:
251: /* unlock the mutex: */
252: tme_mutex_unlock(&serial->tme_posix_serial_mutex);
253:
254: /* check the controls again in .5 seconds: */
255: tme_thread_sleep_yield(0, 500000);
256: }
257: /* NOTREACHED */
258: }
259:
260: /* the serial writer thread: */
261: static void
262: _tme_posix_serial_th_writer(struct tme_posix_serial *serial)
263: {
264: tme_uint8_t buffer_output[1024];
265: unsigned int buffer_output_size;
266: int rc;
267:
268: /* lock the mutex: */
269: tme_mutex_lock(&serial->tme_posix_serial_mutex);
270:
271: /* loop forever: */
272: for (;;) {
273:
274: /* if there is no data to write, wait on the writer condition,
275: after which there must be data to write: */
276: if (tme_serial_buffer_is_empty(&serial->tme_posix_serial_buffer_out)) {
277: tme_cond_wait_yield(&serial->tme_posix_serial_cond_writer,
278: &serial->tme_posix_serial_mutex);
279: }
280:
281: /* get the data to write: */
282: buffer_output_size =
283: tme_serial_buffer_copyout(&serial->tme_posix_serial_buffer_out,
284: buffer_output,
285: sizeof(buffer_output),
286: NULL,
287: TME_SERIAL_COPY_PEEK);
288: assert(buffer_output_size > 0);
289:
290: /* unlock the mutex: */
291: tme_mutex_unlock(&serial->tme_posix_serial_mutex);
292:
293: /* try to write the device: */
294: rc = tme_thread_write_yield(serial->tme_posix_serial_fd_out,
295: buffer_output,
296: buffer_output_size);
297:
298: /* lock the mutex: */
299: tme_mutex_lock(&serial->tme_posix_serial_mutex);
300:
301: /* if the write was successful: */
302: if (rc > 0) {
303:
304: /* remove the written data from the output buffer: */
305: tme_serial_buffer_copyout(&serial->tme_posix_serial_buffer_out,
306: NULL,
307: rc,
308: NULL,
309: TME_SERIAL_COPY_NORMAL);
310:
311: /* call out for more data: */
312: _tme_posix_serial_callout(serial);
313: }
314: }
315: /* NOTREACHED */
316: }
317:
318: /* the serial reader thread: */
319: static void
320: _tme_posix_serial_th_reader(struct tme_posix_serial *serial)
321: {
322: tme_uint8_t buffer_input[1024];
323: tme_uint8_t buffer_slack[10];
324: tme_uint8_t byte, *byte_head, *byte_tail;
325: int scanner_state;
326: int buffer_was_empty;
327: int rc;
328:
329: /* loop forever: */
330: for (;;) {
331:
332: /* try to read the device: */
333: rc = tme_thread_read_yield(serial->tme_posix_serial_fd_in,
334: buffer_input,
335: sizeof(buffer_input));
336:
337: /* if the read failed: */
338: if (rc <= 0) {
339: /* XXX diagnostic */
340: continue;
341: }
342:
343: /* lock the mutex: */
344: tme_mutex_lock(&serial->tme_posix_serial_mutex);
345:
346: /* remember if this buffer was empty: */
347: buffer_was_empty =
348: tme_serial_buffer_is_empty(&serial->tme_posix_serial_buffer_in);
349:
350: /* scan the input: */
351: byte_head = buffer_input;
352: scanner_state = serial->tme_posix_serial_input_scanner_state;
353: for (; rc > 0; ) {
354:
355: /* in state zero, we haven't seen anything interesting: */
356: if (scanner_state == 0) {
357:
358: /* scan quickly, stopping only when we see an escape: */
359: byte_tail = byte_head;
360: if (serial->tme_posix_serial_emulate_break) {
361: do {
362: byte = *(byte_head++);
363: if (byte == 0xff
364: || byte == '^') {
365: break;
366: }
367: } while (--rc > 0);
368: }
369: else {
370: do {
371: byte = *(byte_head++);
372: if (byte == 0xff) {
373: break;
374: }
375: } while (--rc > 0);
376: }
377:
378: /* if we stopped scanning because we saw an escape, back up: */
379: if (rc > 0) {
380: byte_head--;
381: }
382:
383: /* add in the normal data we scanned quickly: */
384: if (byte_head > byte_tail) {
385: (void) tme_serial_buffer_copyin(&serial->tme_posix_serial_buffer_in,
386: byte_tail,
387: (byte_head - byte_tail),
388: TME_SERIAL_DATA_NORMAL,
389: TME_SERIAL_COPY_FULL_IS_OVERRUN);
390: }
391:
392: /* if this byte is an 0xff, move to state one: */
393: if (byte == 0xff) {
394: byte_head++;
395: --rc;
396: scanner_state = 1;
397: }
398:
399: /* if we're emulating breaks, and this is a carat, move to
400: state eight: */
401: else if (serial->tme_posix_serial_emulate_break
402: && byte == '^') {
403: byte_head++;
404: --rc;
405: scanner_state = 8;
406: }
407:
408: /* otherwise, we must have drained everything: */
409: else {
410: assert(rc == 0);
411: }
412: }
413:
414: /* in state one, we have seen 0xff: */
415: else if (scanner_state == 1) {
416:
417: /* get the next byte: */
418: byte = *(byte_head++);
419: --rc;
420:
421: /* if this is an 0x00, move to state two: */
422: if (byte == 0x00) {
423: scanner_state = 2;
424: }
425:
426: /* otherwise, receive 0xff, and if this is not an 0xff, return
427: it to the buffer. move to state zero: */
428: else {
429: buffer_slack[0] = 0xff;
430: (void) tme_serial_buffer_copyin(&serial->tme_posix_serial_buffer_in,
431: buffer_slack,
432: 1,
433: TME_SERIAL_DATA_NORMAL,
434: TME_SERIAL_COPY_FULL_IS_OVERRUN);
435: if (byte != 0xff) {
436: byte_head--;
437: ++rc;
438: }
439: scanner_state = 0;
440: }
441: }
442:
443: /* in state two, we have seen 0xff 0x00: */
444: else if (scanner_state == 2) {
445:
446: /* get the next byte: */
447: byte = *(byte_head++);
448: --rc;
449:
450: /* if this is an 0x00, this is a break: */
451: if (byte == 0x00) {
452:
453: /* if break isn't already being asserted, assert it and call
454: out the change. always reset the assertion time: */
455: if (!(serial->tme_posix_serial_ctrl_callout & TME_SERIAL_CTRL_BREAK)) {
456: serial->tme_posix_serial_ctrl_callout |= TME_SERIAL_CTRL_BREAK;
457: _tme_posix_serial_callout(serial);
458: }
459: serial->tme_posix_serial_ctrl_callout_break = 2;
460: }
461:
462: /* otherwise, this byte was received with bad framing or
463: parity. we can't tell which, so call it bad parity: */
464: else {
465: (void) tme_serial_buffer_copyin(&serial->tme_posix_serial_buffer_in,
466: byte_head - 1,
467: 1,
468: TME_SERIAL_DATA_BAD_PARITY,
469: TME_SERIAL_COPY_FULL_IS_OVERRUN);
470: }
471:
472: /* move to state zero: */
473: scanner_state = 0;
474: }
475:
476: /* in states eight and nine, we have seen one or two break escapes,
477: respectively: */
478: else if (scanner_state == 8
479: || scanner_state == 9) {
480: assert(serial->tme_posix_serial_emulate_break);
481:
482: /* get the next byte: */
483: byte = *(byte_head++);
484: --rc;
485:
486: /* if this isn't also a break escape, return it to the
487: buffer, receive the break escapes, and move to state
488: zero: */
489: if (byte != '^') {
490: byte_head--;
491: ++rc;
492: buffer_slack[0] = buffer_slack[1] = '^';
493: (void) tme_serial_buffer_copyin(&serial->tme_posix_serial_buffer_in,
494: buffer_slack,
495: scanner_state - 7,
496: TME_SERIAL_DATA_NORMAL,
497: TME_SERIAL_COPY_FULL_IS_OVERRUN);
498: scanner_state = 0;
499: }
500:
501: /* otherwise, this is a break escape. if we have now seen
502: three total, this is a break, and move to state zero: */
503: else if (++scanner_state == 10) {
504:
505: /* if break isn't already being asserted, assert it and call
506: out the change. always reset the assertion time: */
507: if (!(serial->tme_posix_serial_ctrl_callout & TME_SERIAL_CTRL_BREAK)) {
508: serial->tme_posix_serial_ctrl_callout |= TME_SERIAL_CTRL_BREAK;
509: _tme_posix_serial_callout(serial);
510: }
511: serial->tme_posix_serial_ctrl_callout_break = 2;
512: scanner_state = 0;
513: }
514: }
515:
516: /* any other state is impossible: */
517: else {
518: assert(FALSE);
519: }
520: }
521:
522: /* update the scanner state: */
523: serial->tme_posix_serial_input_scanner_state = scanner_state;
524:
525: /* if the input buffer was previously empty, and it is now not
526: empty, call out that we can be read again: */
527: if (buffer_was_empty
528: && !tme_serial_buffer_is_empty(&serial->tme_posix_serial_buffer_in)) {
529: serial->tme_posix_serial_ctrl_callout |= TME_SERIAL_CTRL_OK_READ;
530: _tme_posix_serial_callout(serial);
531: }
532:
533: /* unlock the mutex: */
534: tme_mutex_unlock(&serial->tme_posix_serial_mutex);
535: }
536: /* NOTREACHED */
537: }
538:
539: /* the serial configuration callin function: */
540: static int
541: _tme_posix_serial_config(struct tme_serial_connection *conn_serial, struct tme_serial_config *config)
542: {
543: struct tme_posix_serial *serial;
544: struct termios serial_termios;
545: tme_uint32_t config_baud;
546: speed_t termios_baud;
547: int is_input, rc;
548:
549: /* recover our data structure: */
550: serial = conn_serial->tme_serial_connection.tme_connection_element->tme_element_private;
551:
552: /* lock our mutex: */
553: tme_mutex_lock(&serial->tme_posix_serial_mutex);
554:
555: /* loop over the input and output devices: */
556: for (is_input = 2; is_input-- > 0; ) {
557:
558: /* get the current configuration of the device: */
559: rc = tcgetattr((is_input
560: ? serial->tme_posix_serial_fd_in
561: : serial->tme_posix_serial_fd_out),
562: &serial_termios);
563:
564: /* update the configuration: */
565:
566: /* baud rate: */
567: config_baud = config->tme_serial_config_baud;
568: termios_baud = (config_baud == 0 ? B0
569: : config_baud <= 50 ? B50
570: : config_baud <= 75 ? B75
571: : config_baud <= 110 ? B110
572: : config_baud <= 134 ? B134
573: : config_baud <= 150 ? B150
574: : config_baud <= 200 ? B200
575: : config_baud <= 300 ? B300
576: : config_baud <= 600 ? B600
577: : config_baud <= 1200 ? B1200
578: : config_baud <= 1800 ? B1800
579: : config_baud <= 2400 ? B2400
580: : config_baud <= 4800 ? B4800
581: : config_baud <= 9600 ? B9600
582: : config_baud <= 19200 ? B19200
583: : config_baud <= 38400 ? B38400
584: : (speed_t) -1);
585: if (termios_baud == (speed_t) -1) {
586: /* XXX diagnostic */
587: termios_baud = B38400;
588: }
589: rc = cfsetspeed(&serial_termios, termios_baud);
590:
591: /* input mode or output mode: */
592: if (is_input) {
593: serial_termios.c_iflag = PARMRK;
594: if (config->tme_serial_config_flags & TME_SERIAL_FLAGS_CHECK_PARITY) {
595: serial_termios.c_iflag = INPCK;
596: }
597: }
598: else {
599: serial_termios.c_oflag = 0;
600: }
601:
602: /* control mode: */
603: serial_termios.c_cflag = CREAD | CLOCAL;
604: switch (config->tme_serial_config_bits_data) {
605: case 5: serial_termios.c_cflag |= CS5; break;
606: case 6: serial_termios.c_cflag |= CS6; break;
607: case 7: serial_termios.c_cflag |= CS7; break;
608: default: assert(FALSE);
609: case 8: serial_termios.c_cflag |= CS8; break;
610: }
611: switch (config->tme_serial_config_bits_stop) {
612: case 1: break;
613: default: assert(FALSE);
614: case 2: serial_termios.c_cflag |= CSTOPB; break;
615: }
616: switch (config->tme_serial_config_parity) {
617: default: assert(FALSE);
618: case TME_SERIAL_PARITY_NONE: break;
619: case TME_SERIAL_PARITY_ODD: serial_termios.c_cflag |= PARENB | PARODD; break;
620: case TME_SERIAL_PARITY_EVEN: serial_termios.c_cflag |= PARENB; break;
621: }
622:
623: /* local mode: */
624: serial_termios.c_lflag = 0;
625:
626: /* set the configuration on the devices: */
627: rc = tcsetattr((is_input
628: ? serial->tme_posix_serial_fd_in
629: : serial->tme_posix_serial_fd_out),
630: TCSADRAIN,
631: &serial_termios);
632: }
633:
634: /* unlock our mutex: */
635: tme_mutex_unlock(&serial->tme_posix_serial_mutex);
636:
637: /* done: */
638: return (TME_OK);
639: }
640:
641: /* the serial control callin function: */
642: static int
643: _tme_posix_serial_ctrl(struct tme_serial_connection *conn_serial, unsigned int control)
644: {
645: struct tme_posix_serial *serial;
646: int modem_state;
647: int rc;
648:
649: /* recover our data structure: */
650: serial = conn_serial->tme_serial_connection.tme_connection_element->tme_element_private;
651:
652: /* lock our mutex: */
653: tme_mutex_lock(&serial->tme_posix_serial_mutex);
654:
655: /* get the current output device modem state: */
656: rc = ioctl(serial->tme_posix_serial_fd_out, TIOCMGET, &modem_state);
657:
658: /* update the modem state: */
659: if (control & TME_SERIAL_CTRL_DTR) {
660: modem_state |= TIOCM_DTR;
661: }
662: else {
663: modem_state &= TIOCM_DTR;
664: }
665: if (control & TME_SERIAL_CTRL_RTS) {
666: modem_state |= TIOCM_RTS;
667: }
668: else {
669: modem_state &= TIOCM_RTS;
670: }
671:
672: /* set the new modem state: */
673: rc = ioctl(serial->tme_posix_serial_fd_out, TIOCMSET, &modem_state);
674:
675: /* send a break: */
676: if (control & TME_SERIAL_CTRL_BREAK) {
677: tcsendbreak(serial->tme_posix_serial_fd_out, 0);
678: }
679:
680: /* remember these controls. if the OK_READ is set, call out a read: */
681: serial->tme_posix_serial_ctrl_callin = control;
682: if (control & TME_SERIAL_CTRL_OK_READ) {
683: _tme_posix_serial_callout(serial);
684: }
685:
686: /* unlock our mutex: */
687: tme_mutex_unlock(&serial->tme_posix_serial_mutex);
688:
689: /* done: */
690: return (TME_OK);
691: }
692:
693: /* the serial read callin function: */
694: static int
695: _tme_posix_serial_read(struct tme_serial_connection *conn_serial,
696: tme_uint8_t *data, unsigned int count,
697: tme_serial_data_flags_t *_data_flags)
698: {
699: struct tme_posix_serial *serial;
700: unsigned int rc;
701:
702: /* recover our data structure: */
703: serial = conn_serial->tme_serial_connection.tme_connection_element->tme_element_private;
704:
705: /* lock the mutex: */
706: tme_mutex_lock(&serial->tme_posix_serial_mutex);
707:
708: /* copy data out of the input buffer: */
709: rc = tme_serial_buffer_copyout(&serial->tme_posix_serial_buffer_in,
710: data, count,
711: _data_flags,
712: TME_SERIAL_COPY_NORMAL);
713:
714: /* if the input buffer is now empty, our connection shouldn't read
715: again until we have filled some of the buffer. we don't call
716: this transition out, because the convention dictates that
717: our connection forget that we're readable: */
718: if (rc < count) {
719: serial->tme_posix_serial_ctrl_callout &= ~TME_SERIAL_CTRL_OK_READ;
720: serial->tme_posix_serial_ctrl_callout_last &= ~TME_SERIAL_CTRL_OK_READ;
721: }
722:
723: /* unlock the mutex: */
724: tme_mutex_unlock(&serial->tme_posix_serial_mutex);
725:
726: /* done: */
727: return (rc);
728: }
729:
730: /* this scores a connection: */
731: static int
732: _tme_posix_serial_connection_score(struct tme_connection *conn, unsigned int *_score)
733: {
734: struct tme_posix_serial *serial;
735:
736: /* recover our serial: */
737: serial = conn->tme_connection_element->tme_element_private;
738:
739: /* both sides must be serial connections: */
740: assert(conn->tme_connection_type == TME_CONNECTION_SERIAL);
741: assert(conn->tme_connection_other->tme_connection_type == TME_CONNECTION_SERIAL);
742:
743: /* serial connections are always good: */
744: *_score = 1;
745: return (TME_OK);
746: }
747:
748: /* this makes a new connection: */
749: static int
750: _tme_posix_serial_connection_make(struct tme_connection *conn, unsigned int state)
751: {
752: struct tme_posix_serial *serial;
753:
754: /* recover our serial: */
755: serial = conn->tme_connection_element->tme_element_private;
756:
757: /* both sides must be generic bus connections: */
758: assert(conn->tme_connection_type == TME_CONNECTION_SERIAL);
759: assert(conn->tme_connection_other->tme_connection_type == TME_CONNECTION_SERIAL);
760:
761: /* serials are always set up to answer calls across the connection,
762: so we only have to do work when the connection has gone full,
763: namely taking the other side of the connection: */
764: if (state == TME_CONNECTION_FULL) {
765:
766: /* lock our mutex: */
767: tme_mutex_lock(&serial->tme_posix_serial_mutex);
768:
769: /* save our connection: */
770: serial->tme_posix_serial_connection =
771: (struct tme_serial_connection *) conn->tme_connection_other;
772:
773: /* do any pending callouts: */
774: _tme_posix_serial_callout(serial);
775:
776: /* unlock our mutex: */
777: tme_mutex_unlock(&serial->tme_posix_serial_mutex);
778: }
779:
780: return (TME_OK);
781: }
782:
783: /* this breaks a connection: */
784: static int
785: _tme_posix_serial_connection_break(struct tme_connection *conn, unsigned int state)
786: {
787: abort();
788: }
789:
790: /* this makes a new connection side for a serial: */
791: static int
792: _tme_posix_serial_connections_new(struct tme_element *element,
793: const char * const *args,
794: struct tme_connection **_conns,
795: char **_output)
796: {
797: struct tme_posix_serial *serial;
798: struct tme_serial_connection *conn_serial;
799: struct tme_connection *conn;
800:
801: /* recover our serial: */
802: serial = (struct tme_posix_serial *) element->tme_element_private;
803:
804: /* if this serial is already connected, we can do nothing: */
805: if (TME_ATOMIC_READ(struct tme_serial_connection *,
806: serial->tme_posix_serial_connection) != NULL) {
807: return (EISCONN);
808: }
809:
810: /* create our side of a serial connection: */
811: conn_serial = tme_new0(struct tme_serial_connection, 1);
812: conn = &conn_serial->tme_serial_connection;
813:
814: /* fill in the generic connection: */
815: conn->tme_connection_next = *_conns;
816: conn->tme_connection_type = TME_CONNECTION_SERIAL;
817: conn->tme_connection_score = _tme_posix_serial_connection_score;
818: conn->tme_connection_make = _tme_posix_serial_connection_make;
819: conn->tme_connection_break = _tme_posix_serial_connection_break;
820:
821: /* fill in the serial connection: */
822: conn_serial->tme_serial_connection_config = _tme_posix_serial_config;
823: conn_serial->tme_serial_connection_ctrl = _tme_posix_serial_ctrl;
824: conn_serial->tme_serial_connection_read = _tme_posix_serial_read;
825:
826: /* return the connection side possibility: */
827: *_conns = conn;
828: return (TME_OK);
829: }
830:
831: /* the new serial function: */
832: TME_ELEMENT_SUB_NEW_DECL(tme_host_posix,serial) {
833: struct tme_posix_serial *serial;
834: const char *filename_in;
835: const char *filename_out;
836: int fd_in, fd_out;
837: int usage;
838: int arg_i;
839: int saved_errno;
840: int emulate_break;
841:
842: /* initialize: */
843: filename_in = NULL;
844: filename_out = NULL;
845: emulate_break = FALSE;
846: arg_i = 1;
847: usage = FALSE;
848:
849: /* loop reading our arguments: */
850: for (;;) {
851:
852: /* the device we're supposed to use for input: */
853: if (TME_ARG_IS(args[arg_i + 0], "device-input")
854: && args[arg_i + 1] != NULL
855: && filename_in == NULL) {
856: filename_in = args[arg_i + 1];
857: arg_i += 2;
858: }
859:
860: /* the device we're supposed to use for output: */
861: else if (TME_ARG_IS(args[arg_i + 0], "device-output")
862: && args[arg_i + 1] != NULL
863: && filename_out == NULL) {
864: filename_out = args[arg_i + 1];
865: arg_i += 2;
866: }
867:
868: /* the device we're supposed to use for input and output: */
869: else if (TME_ARG_IS(args[arg_i + 0], "device")
870: && args[arg_i + 1] != NULL
871: && filename_in == NULL
872: && filename_out == NULL) {
873: filename_in = filename_out = args[arg_i + 1];
874: arg_i += 2;
875: }
876:
877: /* if we're supposed to emulate break: */
878: else if (TME_ARG_IS(args[arg_i + 0], "break-carats")) {
879: emulate_break = TRUE;
880: arg_i++;
881: }
882:
883: /* if we've run out of arguments: */
884: else if (args[arg_i + 0] == NULL) {
885:
886: /* we must have been given input and output devices: */
887: if (filename_in == NULL
888: || filename_out == NULL) {
889: usage = TRUE;
890: }
891: break;
892: }
893:
894: /* this is a bad argument: */
895: else {
896: tme_output_append_error(_output,
897: "%s %s",
898: args[arg_i],
899: _("unexpected"));
900: usage = TRUE;
901: break;
902: }
903: }
904:
905: if (usage) {
906: tme_output_append_error(_output,
907: "%s %s { device %s | { device-input %s device-output %s } } [break-carats]",
908: _("usage:"),
909: args[0],
910: _("DEVICE"),
911: _("DEVICE"),
912: _("DEVICE"));
913: return (EINVAL);
914: }
915:
916: /* open the devices: */
917: fd_in = fd_out = -1;
918: if (fd_in < 0
919: && !strcmp(filename_in, "-")) {
920: fd_in = STDIN_FILENO;
921: }
922: if (fd_out < 0
923: && !strcmp(filename_out, "-")) {
924: fd_out = STDOUT_FILENO;
925: }
926: if (fd_in < 0) {
927: if (strcmp(filename_in, filename_out) == 0) {
928: fd_in = fd_out = open(filename_in, O_RDWR | O_NONBLOCK);
929: }
930: else {
931: fd_in = open(filename_in, O_RDONLY | O_NONBLOCK);
932: }
933: if (fd_in < 0) {
934: tme_output_append_error(_output, "%s", filename_in);
935: return (errno);
936: }
937: }
938: if (fd_out < 0) {
939: fd_out = open(filename_out, O_WRONLY | O_NONBLOCK);
940: if (fd_out < 0) {
941: saved_errno = errno;
942: close(fd_in);
943: tme_output_append_error(_output, "%s", filename_out);
944: return (saved_errno);
945: }
946: }
947:
948: /* start the serial structure: */
949: serial = tme_new0(struct tme_posix_serial, 1);
950: serial->tme_posix_serial_element = element;
951: serial->tme_posix_serial_fd_in = fd_in;
952: serial->tme_posix_serial_fd_out = fd_out;
953: serial->tme_posix_serial_emulate_break = emulate_break;
954: serial->tme_posix_serial_ctrl_callout = 0;
955: serial->tme_posix_serial_ctrl_callout_last = 0;
956: tme_serial_buffer_init(&serial->tme_posix_serial_buffer_in,
957: TME_POSIX_SERIAL_BUFFER_SIZE);
958: tme_serial_buffer_init(&serial->tme_posix_serial_buffer_out,
959: TME_POSIX_SERIAL_BUFFER_SIZE);
960:
961: /* start the threads: */
962: tme_mutex_init(&serial->tme_posix_serial_mutex);
963: tme_cond_init(&serial->tme_posix_serial_cond_writer);
964: tme_thread_create((tme_thread_t) _tme_posix_serial_th_writer, serial);
965: tme_thread_create((tme_thread_t) _tme_posix_serial_th_reader, serial);
966: tme_thread_create((tme_thread_t) _tme_posix_serial_th_ctrl, serial);
967:
968: /* fill the element: */
969: element->tme_element_private = serial;
970: element->tme_element_connections_new = _tme_posix_serial_connections_new;
971:
972: return (TME_OK);
973: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.