?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Replaced Exit() by exit() because Exit() is like abort().
[AROS-Contrib.git] / Games / Quake / net_comx.c
blob2115a14e23d0ccc1a81dbaf9e776729b2cd17d25
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18
19 */
20 // net_comx.c
21
22 #include <dos.h>
23 #include <dpmi.h>
24
25 #define NUM_COM_PORTS 2
26
27 #define ERR_TTY_LINE_STATUS -1
28 #define ERR_TTY_MODEM_STATUS -2
29 #define ERR_TTY_NODATA -3
30
31 #define QUEUESIZE 8192
32 #define QUEUEMASK (QUEUESIZE - 1)
33
34 typedef struct
35 {
36 volatile int head;
37 volatile int tail;
38 volatile byte data[QUEUESIZE];
39 } queue;
40
41 #define FULL(q) (q.head == ((q.tail-1) & QUEUEMASK))
42 #define EMPTY(q) (q.tail == q.head)
43 #define ENQUEUE(q,b) (q.data[q.head] = b, q.head = (q.head + 1) & QUEUEMASK)
44 #define DEQUEUE(q,b) (b = q.data[q.tail], q.tail = (q.tail + 1) & QUEUEMASK)
45
46 extern cvar_t config_com_port;
47 extern cvar_t config_com_irq;
48 extern cvar_t config_com_baud;
49 extern cvar_t config_com_modem;
50 extern cvar_t config_modem_dialtype;
51 extern cvar_t config_modem_clear;
52 extern cvar_t config_modem_init;
53 extern cvar_t config_modem_hangup;
54
55 extern int m_return_state;
56 extern int m_state;
57 extern qboolean m_return_onerror;
58 extern char m_return_reason[32];
59
60 // 8250, 16550 definitions
61 #define TRANSMIT_HOLDING_REGISTER 0x00
62 #define RECEIVE_BUFFER_REGISTER 0x00
63 #define INTERRUPT_ENABLE_REGISTER 0x01
64 #define IER_RX_DATA_READY 0x01
65 #define IER_TX_HOLDING_REGISTER_EMPTY 0x02
66 #define IER_LINE_STATUS 0x04
67 #define IER_MODEM_STATUS 0x08
68 #define INTERRUPT_ID_REGISTER 0x02
69 #define IIR_MODEM_STATUS_INTERRUPT 0x00
70 #define IIR_TX_HOLDING_REGISTER_INTERRUPT 0x02
71 #define IIR_RX_DATA_READY_INTERRUPT 0x04
72 #define IIR_LINE_STATUS_INTERRUPT 0x06
73 #define IIR_FIFO_TIMEOUT 0x0c
74 #define IIR_FIFO_ENABLED 0xc0
75 #define FIFO_CONTROL_REGISTER 0x02
76 #define FCR_FIFO_ENABLE 0x01
77 #define FCR_RCVR_FIFO_RESET 0x02
78 #define FCR_XMIT_FIFO_RESET 0x04
79 #define FCR_TRIGGER_01 0x00
80 #define FCR_TRIGGER_04 0x40
81 #define FCR_TRIGGER_08 0x80
82 #define FCR_TRIGGER_16 0xc0
83 #define LINE_CONTROL_REGISTER 0x03
84 #define LCR_DATA_BITS_5 0x00
85 #define LCR_DATA_BITS_6 0x01
86 #define LCR_DATA_BITS_7 0x02
87 #define LCR_DATA_BITS_8 0x03
88 #define LCR_STOP_BITS_1 0x00
89 #define LCR_STOP_BITS_2 0x04
90 #define LCR_PARITY_NONE 0x00
91 #define LCR_PARITY_ODD 0x08
92 #define LCR_PARITY_EVEN 0x18
93 #define LCR_PARITY_MARK 0x28
94 #define LCR_PARITY_SPACE 0x38
95 #define LCR_SET_BREAK 0x40
96 #define LCR_DLAB 0x80
97 #define MODEM_CONTROL_REGISTER 0x04
98 #define MCR_DTR 0x01
99 #define MCR_RTS 0x02
100 #define MCR_OUT1 0x04
101 #define MCR_OUT2 0x08
102 #define MCR_LOOPBACK 0x10
103 #define LINE_STATUS_REGISTER 0x05
104 #define LSR_DATA_READY 0x01
105 #define LSR_OVERRUN_ERROR 0x02
106 #define LSR_PARITY_ERROR 0x04
107 #define LSR_FRAMING_ERROR 0x08
108 #define LSR_BREAK_DETECT 0x10
109 #define LSR_TRANSMITTER_BUFFER_EMPTY 0x20
110 #define LSR_TRANSMITTER_EMPTY 0x40
111 #define LSR_FIFO_DIRTY 0x80
112 #define MODEM_STATUS_REGISTER 0x06
113 #define MSR_DELTA_CTS 0x01
114 #define MSR_DELTA_DSR 0x02
115 #define MSR_DELTA_RI 0x04
116 #define MSR_DELTA_CD 0x08
117 #define MSR_CTS 0x10
118 #define MSR_DSR 0x20
119 #define MSR_RI 0x40
120 #define MSR_CD 0x80
121 #define DIVISOR_LATCH_LOW 0x00
122 #define DIVISOR_LATCH_HIGH 0x01
123
124 #define MODEM_STATUS_MASK (MSR_CTS | MSR_DSR | MSR_CD)
125
126 #define UART_AUTO 0
127 #define UART_8250 1
128 #define UART_16550 2
129
130 static int ISA_uarts[] = {0x3f8,0x2f8,0x3e8,0x2e8};
131 static int ISA_IRQs[] = {4,3,4,3};
132
133 typedef struct ComPort_s
134 {
135 struct ComPort_s *next;
136 _go32_dpmi_seginfo protectedModeInfo;
137 _go32_dpmi_seginfo protectedModeSaveInfo;
138 int uart;
139 volatile byte modemStatus;
140 byte modemStatusIgnore;
141 byte lineStatus;
142 byte bufferUsed;
143 qboolean enabled;
144 volatile qboolean statusUpdated;
145 qboolean useModem;
146 qboolean modemInitialized;
147 qboolean modemRang;
148 qboolean modemConnected;
149 queue inputQueue;
150 queue outputQueue;
151 char clear[16];
152 char startup[32];
153 char shutdown[16];
154 char buffer[128];
155 PollProcedure poll;
156 double timestamp;
157 byte uartType;
158 byte irq;
159 byte baudBits;
160 byte lineControl;
161 byte portNumber;
162 char dialType;
163 char name[4];
164 } ComPort;
165
166 ComPort *portList = NULL;
167 ComPort *handleToPort [NUM_COM_PORTS];
168
169 static int Modem_Command(ComPort *p, char *commandString);
170 static char *Modem_Response(ComPort *p);
171 static void Modem_Hangup(ComPort *p);
172
173 int TTY_Init(void);
174 void TTY_Shutdown(void);
175 int TTY_Open(int serialPortNumber);
176 void TTY_Close(int handle);
177 int TTY_ReadByte(int handle);
178 int TTY_WriteByte(int handle, byte data);
179 void TTY_Flush(int handle);
180 int TTY_Connect(int handle, char *host);
181 void TTY_Disconnect(int handle);
182 qboolean TTY_CheckForConnection(int handle);
183 qboolean TTY_IsEnabled(int serialPortNumber);
184 qboolean TTY_IsModem(int serialPortNumber);
185 qboolean TTY_OutputQueueIsEmpty(int handle);
186
187 static void ISR_8250 (ComPort *p)
188 {
189 byte source = 0;
190 byte b;
191
192 disable();
193
194 while((source = inportb (p->uart + INTERRUPT_ID_REGISTER) & 0x07) != 1)
195 {
196 switch (source)
197 {
198 case IIR_RX_DATA_READY_INTERRUPT:
199 b = inportb (p->uart + RECEIVE_BUFFER_REGISTER);
200 if (! FULL(p->inputQueue))
201 {
202 ENQUEUE (p->inputQueue, b);
203 }
204 else
205 {
206 p->lineStatus |= LSR_OVERRUN_ERROR;
207 p->statusUpdated = true;
208 }
209 break;
210
211 case IIR_TX_HOLDING_REGISTER_INTERRUPT:
212 if (! EMPTY(p->outputQueue))
213 {
214 DEQUEUE (p->outputQueue, b);
215 outportb (p->uart + TRANSMIT_HOLDING_REGISTER, b);
216 }
217 break;
218
219 case IIR_MODEM_STATUS_INTERRUPT:
220 p->modemStatus = (inportb (p->uart + MODEM_STATUS_REGISTER) & MODEM_STATUS_MASK) | p->modemStatusIgnore;
221 p->statusUpdated = true;
222 break;
223
224 case IIR_LINE_STATUS_INTERRUPT:
225 p->lineStatus = inportb (p->uart + LINE_STATUS_REGISTER);
226 p->statusUpdated = true;
227 break;
228 }
229 source = inportb (p->uart + INTERRUPT_ID_REGISTER) & 0x07;
230 }
231 outportb (0x20, 0x20);
232 }
233
234 static void COM1_ISR_8250 (void)
235 {
236 ISR_8250 (handleToPort[0]);
237 }
238
239 static void COM2_ISR_8250 (void)
240 {
241 ISR_8250 (handleToPort[1]);
242 }
243
244
245
246 static void ISR_16550 (ComPort *p)
247 {
248 int count;
249 byte source;
250 byte b;
251
252 disable();
253 while((source = inportb (p->uart + INTERRUPT_ID_REGISTER) & 0x07) != 1)
254 {
255 switch (source)
256 {
257 case IIR_RX_DATA_READY_INTERRUPT:
258 do
259 {
260 b = inportb (p->uart + RECEIVE_BUFFER_REGISTER);
261 if (!FULL(p->inputQueue))
262 {
263 ENQUEUE (p->inputQueue, b);
264 }
265 else
266 {
267 p->lineStatus |= LSR_OVERRUN_ERROR;
268 p->statusUpdated = true;
269 }
270 } while (inportb (p->uart + LINE_STATUS_REGISTER) & LSR_DATA_READY);
271 break;
272
273 case IIR_TX_HOLDING_REGISTER_INTERRUPT:
274 count = 16;
275 while ((! EMPTY(p->outputQueue)) && count--)
276 {
277 DEQUEUE (p->outputQueue, b);
278 outportb (p->uart + TRANSMIT_HOLDING_REGISTER, b);
279 }
280 break;
281
282 case IIR_MODEM_STATUS_INTERRUPT:
283 p->modemStatus = (inportb (p->uart + MODEM_STATUS_REGISTER) & MODEM_STATUS_MASK) | p->modemStatusIgnore;
284 p->statusUpdated = true;
285 break;
286
287 case IIR_LINE_STATUS_INTERRUPT:
288 p->lineStatus = inportb (p->uart + LINE_STATUS_REGISTER);
289 p->statusUpdated = true;
290 break;
291 }
292 source = inportb (p->uart + INTERRUPT_ID_REGISTER) & 0x07;
293 }
294
295 // check for lost IIR_TX_HOLDING_REGISTER_INTERRUPT on 16550a!
296 if (inportb (p->uart + LINE_STATUS_REGISTER ) & LSR_TRANSMITTER_EMPTY)
297 {
298 count = 16;
299 while ((! EMPTY(p->outputQueue)) && count--)
300 {
301 DEQUEUE (p->outputQueue, b);
302 outportb (p->uart + TRANSMIT_HOLDING_REGISTER, b);
303 }
304 }
305
306 outportb (0x20, 0x20);
307 }
308
309 static void COM1_ISR_16550 (void)
310 {
311 ISR_16550 (handleToPort[0]);
312 }
313
314 static void COM2_ISR_16550 (void)
315 {
316 ISR_16550 (handleToPort[1]);
317 }
318
319
320 void TTY_GetComPortConfig (int portNumber, int *port, int *irq, int *baud, qboolean *useModem)
321 {
322 ComPort *p;
323
324 p = handleToPort[portNumber];
325 *port = p->uart;
326 *irq = p->irq;
327 *baud = 115200 / p->baudBits;
328 *useModem = p->useModem;
329 }
330
331 void TTY_SetComPortConfig (int portNumber, int port, int irq, int baud, qboolean useModem)
332 {
333 ComPort *p;
334 float temp;
335
336 if (useModem)
337 {
338 if (baud == 14400)
339 baud = 19200;
340 if (baud == 28800)
341 baud = 38400;
342 }
343
344 p = handleToPort[portNumber];
345 p->uart = port;
346 p->irq = irq;
347 p->baudBits = 115200 / baud;
348 p->useModem = useModem;
349
350 if (useModem)
351 temp = 1.0;
352 else
353 temp = 0.0;
354
355 Cvar_SetValue ("_config_com_port", (float)port);
356 Cvar_SetValue ("_config_com_irq", (float)irq);
357 Cvar_SetValue ("_config_com_baud", (float)baud);
358 Cvar_SetValue ("_config_com_modem", temp);
359 }
360
361 void TTY_GetModemConfig (int portNumber, char *dialType, char *clear, char *init, char *hangup)
362 {
363 ComPort *p;
364
365 p = handleToPort[portNumber];
366 *dialType = p->dialType;
367 Q_strcpy(clear, p->clear);
368 Q_strcpy(init, p->startup);
369 Q_strcpy(hangup, p->shutdown);
370 }
371
372 void TTY_SetModemConfig (int portNumber, char *dialType, char *clear, char *init, char *hangup)
373 {
374 ComPort *p;
375
376 p = handleToPort[portNumber];
377 p->dialType = dialType[0];
378 Q_strcpy(p->clear, clear);
379 Q_strcpy(p->startup, init);
380 Q_strcpy(p->shutdown, hangup);
381
382 p->modemInitialized = false;
383
384 Cvar_Set ("_config_modem_dialtype", dialType);
385 Cvar_Set ("_config_modem_clear", clear);
386 Cvar_Set ("_config_modem_init", init);
387 Cvar_Set ("_config_modem_hangup", hangup);
388 }
389
390
391 static void ResetComPortConfig (ComPort *p)
392 {
393 p->useModem = false;
394 p->uartType = UART_AUTO;
395 p->uart = ISA_uarts[p->portNumber];
396 p->irq = ISA_IRQs[p->portNumber];
397 p->modemStatusIgnore = MSR_CD | MSR_CTS | MSR_DSR;
398 p->baudBits = 115200 / 57600;
399 p->lineControl = LCR_DATA_BITS_8 | LCR_STOP_BITS_1 | LCR_PARITY_NONE;
400 Q_strcpy(p->clear, "ATZ");
401 Q_strcpy(p->startup, "");
402 Q_strcpy(p->shutdown, "AT H");
403 p->modemRang = false;
404 p->modemConnected = false;
405 p->statusUpdated = false;
406 p->outputQueue.head = p->outputQueue.tail = 0;
407 p->inputQueue.head = p->inputQueue.tail = 0;
408 }
409
410
411 static void ComPort_Enable(ComPort *p)
412 {
413 void (*isr)(void);
414 int n;
415 byte b;
416
417 if (p->enabled)
418 {
419 Con_Printf("Already enabled\n");
420 return;
421 }
422
423 // disable all UART interrupts
424 outportb (p->uart + INTERRUPT_ENABLE_REGISTER, 0);
425
426 // clear out any buffered uncoming data
427 while((inportb (p->uart + LINE_STATUS_REGISTER)) & LSR_DATA_READY)
428 inportb (p->uart + RECEIVE_BUFFER_REGISTER);
429
430 // get the current line and modem status
431 p->modemStatus = (inportb (p->uart + MODEM_STATUS_REGISTER) & MODEM_STATUS_MASK) | p->modemStatusIgnore;
432 p->lineStatus = inportb (p->uart + LINE_STATUS_REGISTER);
433
434 // clear any UART interrupts
435 do
436 {
437 n = inportb (p->uart + INTERRUPT_ID_REGISTER) & 7;
438 if (n == IIR_RX_DATA_READY_INTERRUPT)
439 inportb (p->uart + RECEIVE_BUFFER_REGISTER);
440 } while (!(n & 1));
441
442 if (p->uartType == UART_AUTO)
443 {
444 outportb (p->uart + FIFO_CONTROL_REGISTER, FCR_FIFO_ENABLE);
445 b = inportb (p->uart + INTERRUPT_ID_REGISTER);
446 if ((b & IIR_FIFO_ENABLED) == IIR_FIFO_ENABLED)
447 p->uartType = UART_16550;
448 else
449 p->uartType = UART_8250;
450 }
451
452 // save the old interrupt handler
453 _go32_dpmi_get_protected_mode_interrupt_vector(p->irq + 8, &p->protectedModeSaveInfo);
454
455 if (p->uartType == UART_8250)
456 {
457 outportb (p->uart + FIFO_CONTROL_REGISTER, 0);
458 if (p == handleToPort[0])
459 isr = COM1_ISR_8250;
460 else
461 isr = COM2_ISR_8250;
462 }
463 else
464 {
465 outportb (p->uart + FIFO_CONTROL_REGISTER, FCR_FIFO_ENABLE | FCR_RCVR_FIFO_RESET | FCR_XMIT_FIFO_RESET | FCR_TRIGGER_08);
466 if (p == handleToPort[0])
467 isr = COM1_ISR_16550;
468 else
469 isr = COM2_ISR_16550;
470 }
471
472 p->protectedModeInfo.pm_offset = (int)isr;
473
474 n = _go32_dpmi_allocate_iret_wrapper(&p->protectedModeInfo);
475 if (n)
476 {
477 Con_Printf("serial: protected mode callback allocation failed\n");
478 return;
479 }
480
481 // disable interrupts at the processor
482 disable();
483
484 // install our interrupt handlers now
485 _go32_dpmi_set_protected_mode_interrupt_vector(p->irq + 8, &p->protectedModeInfo);
486
487 // enable our interrupt at the PIC
488 outportb (0x21, inportb (0x21) & ~(1<<p->irq));
489
490 // enable interrupts at the processor
491 enable();
492
493 // enable interrupts at the PIC
494 outportb (0x20, 0xc2);
495
496 // set baud rate & line control
497 outportb (p->uart + LINE_CONTROL_REGISTER, LCR_DLAB | p->lineControl);
498 outportb (p->uart, p->baudBits);
499 outportb (p->uart + 1, 0);
500 outportb (p->uart + LINE_CONTROL_REGISTER, p->lineControl);
501
502 // set modem control register & enable uart interrupt generation
503 outportb(p->uart + MODEM_CONTROL_REGISTER, MCR_OUT2 | MCR_RTS | MCR_DTR);
504
505 // enable the individual interrupts at the uart
506 outportb (p->uart + INTERRUPT_ENABLE_REGISTER, IER_RX_DATA_READY | IER_TX_HOLDING_REGISTER_EMPTY | IER_LINE_STATUS | IER_MODEM_STATUS);
507
508 p->enabled = true;
509 }
510
511
512 static void ComPort_Disable(ComPort *p)
513 {
514 if (!p->enabled)
515 {
516 Con_Printf("Already disabled\n");
517 return;
518 }
519
520 // disable interrupts at the uart
521 outportb (p->uart + INTERRUPT_ENABLE_REGISTER, 0);
522
523 // disable our interrupt at the PIC
524 outportb (0x21, inportb (0x21) | (1<<p->irq));
525
526 // disable interrupts at the processor
527 disable();
528
529 // restore the old interrupt handler
530 _go32_dpmi_set_protected_mode_interrupt_vector(p->irq + 8, &p->protectedModeSaveInfo);
531 _go32_dpmi_free_iret_wrapper(&p->protectedModeInfo);
532
533 // enable interrupts at the processor
534 enable();
535
536 p->enabled = false;
537 }
538
539
540 static int CheckStatus (ComPort *p)
541 {
542 int ret = 0;
543
544 if (p->statusUpdated)
545 {
546 p->statusUpdated = false;
547
548 if (p->lineStatus & (LSR_OVERRUN_ERROR | LSR_PARITY_ERROR | LSR_FRAMING_ERROR | LSR_BREAK_DETECT))
549 {
550 if (p->lineStatus & LSR_OVERRUN_ERROR)
551 Con_DPrintf ("Serial overrun error\n");
552 if (p->lineStatus & LSR_PARITY_ERROR)
553 Con_DPrintf ("Serial parity error\n");
554 if (p->lineStatus & LSR_FRAMING_ERROR)
555 Con_DPrintf ("Serial framing error\n");
556 if (p->lineStatus & LSR_BREAK_DETECT)
557 Con_DPrintf ("Serial break detect\n");
558 ret = ERR_TTY_LINE_STATUS;
559 }
560
561 if ((p->modemStatus & MODEM_STATUS_MASK) != MODEM_STATUS_MASK)
562 {
563 if (!(p->modemStatus & MSR_CTS))
564 Con_Printf ("Serial lost CTS\n");
565 if (!(p->modemStatus & MSR_DSR))
566 Con_Printf ("Serial lost DSR\n");
567 if (!(p->modemStatus & MSR_CD))
568 Con_Printf ("Serial lost Carrier\n");
569 ret = ERR_TTY_MODEM_STATUS;
570 }
571 }
572
573 return ret;
574 }
575
576
577 static void Modem_Init(ComPort *p)
578 {
579 double start;
580 char *response;
581
582 Con_Printf ("Initializing modem...\n");
583
584 // write 0 to MCR, wait 1/2 sec, then write the real value back again
585 // I got this from the guys at head-to-head who say it's necessary.
586 outportb(p->uart + MODEM_CONTROL_REGISTER, 0);
587 start = Sys_FloatTime();
588 while ((Sys_FloatTime() - start) < 0.5)
589 ;
590 outportb(p->uart + MODEM_CONTROL_REGISTER, MCR_OUT2 | MCR_RTS | MCR_DTR);
591 start = Sys_FloatTime();
592 while ((Sys_FloatTime() - start) < 0.25)
593 ;
594
595 if (*p->clear)
596 {
597 Modem_Command (p, p->clear);
598 start = Sys_FloatTime();
599 while(1)
600 {
601 if ((Sys_FloatTime() - start) > 3.0)
602 {
603 Con_Printf("No response - clear failed\n");
604 p->enabled = false;
605 goto failed;
606 }
607 response = Modem_Response(p);
608 if (!response)
609 continue;
610 if (Q_strncmp(response, "OK", 2) == 0)
611 break;
612 if (Q_strncmp(response, "ERROR", 5) == 0)
613 {
614 p->enabled = false;
615 goto failed;
616 }
617 }
618 }
619
620 if (*p->startup)
621 {
622 Modem_Command (p, p->startup);
623 start = Sys_FloatTime();
624 while(1)
625 {
626 if ((Sys_FloatTime() - start) > 3.0)
627 {
628 Con_Printf("No response - init failed\n");
629 p->enabled = false;
630 goto failed;
631 }
632 response = Modem_Response(p);
633 if (!response)
634 continue;
635 if (Q_strncmp(response, "OK", 2) == 0)
636 break;
637 if (Q_strncmp(response, "ERROR", 5) == 0)
638 {
639 p->enabled = false;
640 goto failed;
641 }
642 }
643 }
644
645 p->modemInitialized = true;
646 return;
647
648 failed:
649 if (m_return_onerror)
650 {
651 key_dest = key_menu;
652 m_state = m_return_state;
653 m_return_onerror = false;
654 Q_strcpy(m_return_reason, "Initialization Failed");
655 }
656 return;
657 }
658
659
660 void TTY_Enable(int handle)
661 {
662 ComPort *p;
663
664 p = handleToPort [handle];
665 if (p->enabled)
666 return;
667
668 ComPort_Enable(p);
669
670 if (p->useModem && !p->modemInitialized)
671 Modem_Init (p);
672 }
673
674
675 int TTY_Open(int serialPortNumber)
676 {
677 return serialPortNumber;
678 }
679
680
681 void TTY_Close(int handle)
682 {
683 ComPort *p;
684 double startTime;
685
686 p = handleToPort [handle];
687
688 startTime = Sys_FloatTime();
689 while ((Sys_FloatTime() - startTime) < 1.0)
690 if (EMPTY(p->outputQueue))
691 break;
692
693 if (p->useModem)
694 {
695 if (p->modemConnected)
696 Modem_Hangup(p);
697 }
698 }
699
700
701 int TTY_ReadByte(int handle)
702 {
703 int ret;
704 ComPort *p;
705
706 p = handleToPort [handle];
707
708 if ((ret = CheckStatus (p)) != 0)
709 return ret;
710
711 if (EMPTY (p->inputQueue))
712 return ERR_TTY_NODATA;
713
714 DEQUEUE (p->inputQueue, ret);
715 return (ret & 0xff);
716 }
717
718
719 int TTY_WriteByte(int handle, byte data)
720 {
721 ComPort *p;
722
723 p = handleToPort [handle];
724 if (FULL(p->outputQueue))
725 return -1;
726
727 ENQUEUE (p->outputQueue, data);
728 return 0;
729 }
730
731
732 void TTY_Flush(int handle)
733 {
734 byte b;
735 ComPort *p;
736
737 p = handleToPort [handle];
738
739 if (inportb (p->uart + LINE_STATUS_REGISTER ) & LSR_TRANSMITTER_EMPTY)
740 {
741 DEQUEUE (p->outputQueue, b);
742 outportb(p->uart, b);
743 }
744 }
745
746
747 int TTY_Connect(int handle, char *host)
748 {
749 double start;
750 ComPort *p;
751 char *response = NULL;
752 keydest_t save_key_dest;
753 byte dialstring[64];
754 byte b;
755
756 p = handleToPort[handle];
757
758 if ((p->modemStatus & MODEM_STATUS_MASK) != MODEM_STATUS_MASK)
759 {
760 Con_Printf ("Serial: line not ready (");
761 if ((p->modemStatus & MSR_CTS) == 0)
762 Con_Printf(" CTS");
763 if ((p->modemStatus & MSR_DSR) == 0)
764 Con_Printf(" DSR");
765 if ((p->modemStatus & MSR_CD) == 0)
766 Con_Printf(" CD");
767 Con_Printf(" )");
768 return -1;
769 }
770
771 // discard any scraps in the input buffer
772 while (! EMPTY (p->inputQueue))
773 DEQUEUE (p->inputQueue, b);
774
775 CheckStatus (p);
776
777 if (p->useModem)
778 {
779 save_key_dest = key_dest;
780 key_dest = key_console;
781 key_count = -2;
782
783 Con_Printf ("Dialing...\n");
784 sprintf(dialstring, "AT D%c %s\r", p->dialType, host);
785 Modem_Command (p, dialstring);
786 start = Sys_FloatTime();
787 while(1)
788 {
789 if ((Sys_FloatTime() - start) > 60.0)
790 {
791 Con_Printf("Dialing failure!\n");
792 break;
793 }
794
795 Sys_SendKeyEvents ();
796 if (key_count == 0)
797 {
798 if (key_lastpress != K_ESCAPE)
799 {
800 key_count = -2;
801 continue;
802 }
803 Con_Printf("Aborting...\n");
804 while ((Sys_FloatTime() - start) < 5.0)
805 ;
806 disable();
807 p->outputQueue.head = p->outputQueue.tail = 0;
808 p->inputQueue.head = p->inputQueue.tail = 0;
809 outportb(p->uart + MODEM_CONTROL_REGISTER, inportb(p->uart + MODEM_CONTROL_REGISTER) & ~MCR_DTR);
810 enable();
811 start = Sys_FloatTime();
812 while ((Sys_FloatTime() - start) < 0.75)
813 ;
814 outportb(p->uart + MODEM_CONTROL_REGISTER, inportb(p->uart + MODEM_CONTROL_REGISTER) | MCR_DTR);
815 response = "Aborted";
816 break;
817 }
818
819 response = Modem_Response(p);
820 if (!response)
821 continue;
822 if (Q_strncmp(response, "CONNECT", 7) == 0)
823 {
824 disable();
825 p->modemRang = true;
826 p->modemConnected = true;
827 p->outputQueue.head = p->outputQueue.tail = 0;
828 p->inputQueue.head = p->inputQueue.tail = 0;
829 enable();
830 key_dest = save_key_dest;
831 key_count = 0;
832 m_return_onerror = false;
833 return 0;
834 }
835 if (Q_strncmp(response, "NO CARRIER", 10) == 0)
836 break;
837 if (Q_strncmp(response, "NO DIALTONE", 11) == 0)
838 break;
839 if (Q_strncmp(response, "NO DIAL TONE", 12) == 0)
840 break;
841 if (Q_strncmp(response, "NO ANSWER", 9) == 0)
842 break;
843 if (Q_strncmp(response, "BUSY", 4) == 0)
844 break;
845 if (Q_strncmp(response, "ERROR", 5) == 0)
846 break;
847 }
848 key_dest = save_key_dest;
849 key_count = 0;
850 if (m_return_onerror)
851 {
852 key_dest = key_menu;
853 m_state = m_return_state;
854 m_return_onerror = false;
855 Q_strncpy(m_return_reason, response, 31);
856 }
857 return -1;
858 }
859 m_return_onerror = false;
860 return 0;
861 }
862
863
864 void TTY_Disconnect(int handle)
865 {
866 ComPort *p;
867
868 p = handleToPort[handle];
869
870 if (p->useModem && p->modemConnected)
871 Modem_Hangup(p);
872 }
873
874
875 qboolean TTY_CheckForConnection(int handle)
876 {
877 ComPort *p;
878
879 p = handleToPort[handle];
880
881 CheckStatus (p);
882
883 if (p->useModem)
884 {
885 if (!p->modemRang)
886 {
887 if (!Modem_Response(p))
888 return false;
889
890 if (Q_strncmp(p->buffer, "RING", 4) == 0)
891 {
892 Modem_Command (p, "ATA");
893 p->modemRang = true;
894 p->timestamp = net_time;
895 }
896 return false;
897 }
898 if (!p->modemConnected)
899 {
900 if ((net_time - p->timestamp) > 35.0)
901 {
902 Con_Printf("Unable to establish modem connection\n");
903 p->modemRang = false;
904 return false;
905 }
906
907 if (!Modem_Response(p))
908 return false;
909
910 if (Q_strncmp (p->buffer, "CONNECT", 7) != 0)
911 return false;
912
913 disable();
914 p->modemConnected = true;
915 p->outputQueue.head = p->outputQueue.tail = 0;
916 p->inputQueue.head = p->inputQueue.tail = 0;
917 enable();
918 Con_Printf("Modem Connect\n");
919 return true;
920 }
921 return true;
922 }
923
924 // direct connect case
925 if (EMPTY (p->inputQueue))
926 return false;
927 return true;
928 }
929
930
931 qboolean TTY_IsEnabled(int serialPortNumber)
932 {
933 return handleToPort[serialPortNumber]->enabled;
934 }
935
936
937 qboolean TTY_IsModem(int serialPortNumber)
938 {
939 return handleToPort[serialPortNumber]->useModem;
940 }
941
942
943 qboolean TTY_OutputQueueIsEmpty(int handle)
944 {
945 return EMPTY(handleToPort[handle]->outputQueue);
946 }
947
948
949 void Com_f (void)
950 {
951 ComPort *p;
952 int portNumber;
953 int i;
954 int n;
955
956 // first, determine which port they're messing with
957 portNumber = Q_atoi(Cmd_Argv (0) + 3) - 1;
958 if (portNumber > 1)
959 return;
960 p = handleToPort[portNumber];
961
962 if (Cmd_Argc() == 1)
963 {
964 Con_Printf("Settings for COM%i\n", portNumber + 1);
965 Con_Printf("enabled: %s\n", p->enabled ? "true" : "false");
966 Con_Printf("uart: ");
967 if (p->uartType == UART_AUTO)
968 Con_Printf("auto\n");
969 else if (p->uartType == UART_8250)
970 Con_Printf("8250\n");
971 else
972 Con_Printf("16550\n");
973 Con_Printf("port: %x\n", p->uart);
974 Con_Printf("irq: %i\n", p->irq);
975 Con_Printf("baud: %i\n", 115200 / p->baudBits);
976 Con_Printf("CTS: %s\n", (p->modemStatusIgnore & MSR_CTS) ? "ignored" : "honored");
977 Con_Printf("DSR: %s\n", (p->modemStatusIgnore & MSR_DSR) ? "ignored" : "honored");
978 Con_Printf("CD: %s\n", (p->modemStatusIgnore & MSR_CD) ? "ignored" : "honored");
979 if (p->useModem)
980 {
981 Con_Printf("type: Modem\n");
982 Con_Printf("clear: %s\n", p->clear);
983 Con_Printf("startup: %s\n", p->startup);
984 Con_Printf("shutdown: %s\n", p->shutdown);
985 }
986 else
987 Con_Printf("type: Direct connect\n");
988
989 return;
990 }
991
992
993 if (Cmd_CheckParm ("disable"))
994 {
995 if (p->enabled)
996 ComPort_Disable(p);
997 p->modemInitialized = false;
998 return;
999 }
1000
1001 if (Cmd_CheckParm ("reset"))
1002 {
1003 ComPort_Disable(p);
1004 ResetComPortConfig (p);
1005 return;
1006 }
1007
1008 if ((i = Cmd_CheckParm ("port")) != 0)
1009 {
1010 if (p->enabled)
1011 {
1012 Con_Printf("COM port must be disabled to change port\n");
1013 return;
1014 }
1015 p->uart = Q_atoi (Cmd_Argv (i+1));
1016 }
1017
1018 if ((i = Cmd_CheckParm ("irq")) != 0)
1019 {
1020 if (p->enabled)
1021 {
1022 Con_Printf("COM port must be disabled to change irq\n");
1023 return;
1024 }
1025 p->irq = Q_atoi (Cmd_Argv (i+1));
1026 }
1027
1028 if ((i = Cmd_CheckParm ("baud")) != 0)
1029 {
1030 if (p->enabled)
1031 {
1032 Con_Printf("COM port must be disabled to change baud\n");
1033 return;
1034 }
1035 n = Q_atoi (Cmd_Argv (i+1));
1036 if (n == 0)
1037 Con_Printf("Invalid baud rate specified\n");
1038 else
1039 p->baudBits = 115200 / n;
1040 }
1041
1042 if (Cmd_CheckParm ("8250"))
1043 {
1044 if (p->enabled)
1045 {
1046 Con_Printf("COM port must be disabled to change uart\n");
1047 return;
1048 }
1049 p->uartType = UART_8250;
1050 }
1051 if (Cmd_CheckParm ("16550"))
1052 {
1053 if (p->enabled)
1054 {
1055 Con_Printf("COM port must be disabled to change uart\n");
1056 return;
1057 }
1058 p->uartType = UART_16550;
1059 }
1060 if (Cmd_CheckParm ("auto"))
1061 {
1062 if (p->enabled)
1063 {
1064 Con_Printf("COM port must be disabled to change uart\n");
1065 return;
1066 }
1067 p->uartType = UART_AUTO;
1068 }
1069
1070 if (Cmd_CheckParm ("pulse"))
1071 p->dialType = 'P';
1072 if (Cmd_CheckParm ("tone"))
1073 p->dialType = 'T';
1074
1075 if (Cmd_CheckParm ("direct"))
1076 p->useModem = false;
1077 if (Cmd_CheckParm ("modem"))
1078 p->useModem = true;
1079
1080 if ((i = Cmd_CheckParm ("clear")) != 0)
1081 {
1082 Q_strncpy (p->clear, Cmd_Argv (i+1), 16);
1083 }
1084
1085 if ((i = Cmd_CheckParm ("startup")) != 0)
1086 {
1087 Q_strncpy (p->startup, Cmd_Argv (i+1), 32);
1088 p->modemInitialized = false;
1089 }
1090
1091 if ((i = Cmd_CheckParm ("shutdown")) != 0)
1092 {
1093 Q_strncpy (p->shutdown, Cmd_Argv (i+1), 16);
1094 }
1095
1096 if (Cmd_CheckParm ("-cts"))
1097 {
1098 p->modemStatusIgnore |= MSR_CTS;
1099 p->modemStatus |= MSR_CTS;
1100 }
1101
1102 if (Cmd_CheckParm ("+cts"))
1103 {
1104 p->modemStatusIgnore &= (~MSR_CTS);
1105 p->modemStatus = (inportb (p->uart + MODEM_STATUS_REGISTER) & MODEM_STATUS_MASK) | p->modemStatusIgnore;
1106 }
1107
1108 if (Cmd_CheckParm ("-dsr"))
1109 {
1110 p->modemStatusIgnore |= MSR_DSR;
1111 p->modemStatus |= MSR_DSR;
1112 }
1113
1114 if (Cmd_CheckParm ("+dsr"))
1115 {
1116 p->modemStatusIgnore &= (~MSR_DSR);
1117 p->modemStatus = (inportb (p->uart + MODEM_STATUS_REGISTER) & MODEM_STATUS_MASK) | p->modemStatusIgnore;
1118 }
1119
1120 if (Cmd_CheckParm ("-cd"))
1121 {
1122 p->modemStatusIgnore |= MSR_CD;
1123 p->modemStatus |= MSR_CD;
1124 }
1125
1126 if (Cmd_CheckParm ("+cd"))
1127 {
1128 p->modemStatusIgnore &= (~MSR_CD);
1129 p->modemStatus = (inportb (p->uart + MODEM_STATUS_REGISTER) & MODEM_STATUS_MASK) | p->modemStatusIgnore;
1130 }
1131
1132 if (Cmd_CheckParm ("enable"))
1133 {
1134 if (!p->enabled)
1135 ComPort_Enable(p);
1136 if (p->useModem && !p->modemInitialized)
1137 Modem_Init (p);
1138 }
1139 }
1140
1141
1142 int TTY_Init(void)
1143 {
1144 int n;
1145 ComPort *p;
1146
1147 for (n = 0; n < NUM_COM_PORTS; n++)
1148 {
1149 p = (ComPort *)Hunk_AllocName(sizeof(ComPort), "comport");
1150 if (p == NULL)
1151 Sys_Error("Hunk alloc failed for com port\n");
1152 p->next = portList;
1153 portList = p;
1154 handleToPort[n] = p;
1155 p->portNumber = n;
1156 p->dialType = 'T';
1157 sprintf(p->name, "com%u", n+1);
1158 Cmd_AddCommand (p->name, Com_f);
1159 ResetComPortConfig (p);
1160 }
1161
1162 GetComPortConfig = TTY_GetComPortConfig;
1163 SetComPortConfig = TTY_SetComPortConfig;
1164 GetModemConfig = TTY_GetModemConfig;
1165 SetModemConfig = TTY_SetModemConfig;
1166
1167 return 0;
1168 }
1169
1170
1171 void TTY_Shutdown(void)
1172 {
1173 int n;
1174 ComPort *p;
1175
1176 for (n = 0; n < NUM_COM_PORTS; n++)
1177 {
1178 p = handleToPort[n];
1179 if (p->enabled)
1180 {
1181 while (p->modemConnected)
1182 NET_Poll();
1183 ComPort_Disable (p);
1184 }
1185 }
1186 }
1187
1188
1189 static int Modem_Command(ComPort *p, char *commandString)
1190 {
1191 byte b;
1192
1193 if (CheckStatus (p))
1194 return -1;
1195
1196 disable();
1197 p->outputQueue.head = p->outputQueue.tail = 0;
1198 p->inputQueue.head = p->inputQueue.tail = 0;
1199 enable();
1200 p->bufferUsed = 0;
1201
1202 while (*commandString)
1203 ENQUEUE (p->outputQueue, *commandString++);
1204 ENQUEUE (p->outputQueue, '\r');
1205
1206 // get the transmit rolling
1207 DEQUEUE (p->outputQueue, b);
1208 outportb(p->uart, b);
1209
1210 return 0;
1211 }
1212
1213
1214 static char *Modem_Response(ComPort *p)
1215 {
1216 byte b;
1217
1218 if (CheckStatus (p))
1219 return NULL;
1220
1221 while (! EMPTY(p->inputQueue))
1222 {
1223 DEQUEUE (p->inputQueue, b);
1224
1225 if (p->bufferUsed == (sizeof(p->buffer) - 1))
1226 b = '\r';
1227
1228 if (b == '\r' && p->bufferUsed)
1229 {
1230 p->buffer[p->bufferUsed] = 0;
1231 Con_Printf("%s\n", p->buffer);
1232 SCR_UpdateScreen ();
1233 p->bufferUsed = 0;
1234 return p->buffer;
1235 }
1236
1237 if (b < ' ' || b > 'z')
1238 continue;
1239 p->buffer[p->bufferUsed] = b;
1240 p->bufferUsed++;
1241 }
1242
1243 return NULL;
1244 }
1245
1246
1247 static void Modem_Hangup2(ComPort *p);
1248 static void Modem_Hangup3(ComPort *p);
1249 static void Modem_Hangup4(ComPort *p);
1250
1251 static void Modem_Hangup(ComPort *p)
1252 {
1253 Con_Printf("Hanging up modem...\n");
1254 disable();
1255 p->modemRang = false;
1256 p->outputQueue.head = p->outputQueue.tail = 0;
1257 p->inputQueue.head = p->inputQueue.tail = 0;
1258 outportb(p->uart + MODEM_CONTROL_REGISTER, inportb(p->uart + MODEM_CONTROL_REGISTER) & ~MCR_DTR);
1259 enable();
1260 p->poll.procedure = Modem_Hangup2;
1261 p->poll.arg = p;
1262 SchedulePollProcedure(&p->poll, 1.5);
1263 }
1264
1265 static void Modem_Hangup2(ComPort *p)
1266 {
1267 outportb(p->uart + MODEM_CONTROL_REGISTER, inportb(p->uart + MODEM_CONTROL_REGISTER) | MCR_DTR);
1268 Modem_Command(p, "+++");
1269 p->poll.procedure = Modem_Hangup3;
1270 SchedulePollProcedure(&p->poll, 1.5);
1271 }
1272
1273 static void Modem_Hangup3(ComPort *p)
1274 {
1275 Modem_Command(p, p->shutdown);
1276 p->poll.procedure = Modem_Hangup4;
1277 SchedulePollProcedure(&p->poll, 1.5);
1278 }
1279
1280 static void Modem_Hangup4(ComPort *p)
1281 {
1282 Modem_Response(p);
1283 Con_Printf("Hangup complete\n");
1284 p->modemConnected = false;
1285 }
Mirror of AROS' Contrib svn.