| 0,0 → 1,1285 |
|---|
| /* |
| Copyright (C) 1996-1997 Id Software, Inc. |
| |
| This program is free software; you can redistribute it and/or |
| modify it under the terms of the GNU General Public License |
| as published by the Free Software Foundation; either version 2 |
| of the License, or (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| |
| See the GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| |
| */ |
| // net_comx.c |
| |
| #include <dos.h> |
| #include <dpmi.h> |
| |
| #define NUM_COM_PORTS 2 |
| |
| #define ERR_TTY_LINE_STATUS -1 |
| #define ERR_TTY_MODEM_STATUS -2 |
| #define ERR_TTY_NODATA -3 |
| |
| #define QUEUESIZE 8192 |
| #define QUEUEMASK (QUEUESIZE - 1) |
| |
| typedef struct |
| { |
| volatile int head; |
| volatile int tail; |
| volatile byte data[QUEUESIZE]; |
| } queue; |
| |
| #define FULL(q) (q.head == ((q.tail-1) & QUEUEMASK)) |
| #define EMPTY(q) (q.tail == q.head) |
| #define ENQUEUE(q,b) (q.data[q.head] = b, q.head = (q.head + 1) & QUEUEMASK) |
| #define DEQUEUE(q,b) (b = q.data[q.tail], q.tail = (q.tail + 1) & QUEUEMASK) |
| |
| extern cvar_t config_com_port; |
| extern cvar_t config_com_irq; |
| extern cvar_t config_com_baud; |
| extern cvar_t config_com_modem; |
| extern cvar_t config_modem_dialtype; |
| extern cvar_t config_modem_clear; |
| extern cvar_t config_modem_init; |
| extern cvar_t config_modem_hangup; |
| |
| extern int m_return_state; |
| extern int m_state; |
| extern qboolean m_return_onerror; |
| extern char m_return_reason[32]; |
| |
| // 8250, 16550 definitions |
| #define TRANSMIT_HOLDING_REGISTER 0x00 |
| #define RECEIVE_BUFFER_REGISTER 0x00 |
| #define INTERRUPT_ENABLE_REGISTER 0x01 |
| #define IER_RX_DATA_READY 0x01 |
| #define IER_TX_HOLDING_REGISTER_EMPTY 0x02 |
| #define IER_LINE_STATUS 0x04 |
| #define IER_MODEM_STATUS 0x08 |
| #define INTERRUPT_ID_REGISTER 0x02 |
| #define IIR_MODEM_STATUS_INTERRUPT 0x00 |
| #define IIR_TX_HOLDING_REGISTER_INTERRUPT 0x02 |
| #define IIR_RX_DATA_READY_INTERRUPT 0x04 |
| #define IIR_LINE_STATUS_INTERRUPT 0x06 |
| #define IIR_FIFO_TIMEOUT 0x0c |
| #define IIR_FIFO_ENABLED 0xc0 |
| #define FIFO_CONTROL_REGISTER 0x02 |
| #define FCR_FIFO_ENABLE 0x01 |
| #define FCR_RCVR_FIFO_RESET 0x02 |
| #define FCR_XMIT_FIFO_RESET 0x04 |
| #define FCR_TRIGGER_01 0x00 |
| #define FCR_TRIGGER_04 0x40 |
| #define FCR_TRIGGER_08 0x80 |
| #define FCR_TRIGGER_16 0xc0 |
| #define LINE_CONTROL_REGISTER 0x03 |
| #define LCR_DATA_BITS_5 0x00 |
| #define LCR_DATA_BITS_6 0x01 |
| #define LCR_DATA_BITS_7 0x02 |
| #define LCR_DATA_BITS_8 0x03 |
| #define LCR_STOP_BITS_1 0x00 |
| #define LCR_STOP_BITS_2 0x04 |
| #define LCR_PARITY_NONE 0x00 |
| #define LCR_PARITY_ODD 0x08 |
| #define LCR_PARITY_EVEN 0x18 |
| #define LCR_PARITY_MARK 0x28 |
| #define LCR_PARITY_SPACE 0x38 |
| #define LCR_SET_BREAK 0x40 |
| #define LCR_DLAB 0x80 |
| #define MODEM_CONTROL_REGISTER 0x04 |
| #define MCR_DTR 0x01 |
| #define MCR_RTS 0x02 |
| #define MCR_OUT1 0x04 |
| #define MCR_OUT2 0x08 |
| #define MCR_LOOPBACK 0x10 |
| #define LINE_STATUS_REGISTER 0x05 |
| #define LSR_DATA_READY 0x01 |
| #define LSR_OVERRUN_ERROR 0x02 |
| #define LSR_PARITY_ERROR 0x04 |
| #define LSR_FRAMING_ERROR 0x08 |
| #define LSR_BREAK_DETECT 0x10 |
| #define LSR_TRANSMITTER_BUFFER_EMPTY 0x20 |
| #define LSR_TRANSMITTER_EMPTY 0x40 |
| #define LSR_FIFO_DIRTY 0x80 |
| #define MODEM_STATUS_REGISTER 0x06 |
| #define MSR_DELTA_CTS 0x01 |
| #define MSR_DELTA_DSR 0x02 |
| #define MSR_DELTA_RI 0x04 |
| #define MSR_DELTA_CD 0x08 |
| #define MSR_CTS 0x10 |
| #define MSR_DSR 0x20 |
| #define MSR_RI 0x40 |
| #define MSR_CD 0x80 |
| #define DIVISOR_LATCH_LOW 0x00 |
| #define DIVISOR_LATCH_HIGH 0x01 |
| |
| #define MODEM_STATUS_MASK (MSR_CTS | MSR_DSR | MSR_CD) |
| |
| #define UART_AUTO 0 |
| #define UART_8250 1 |
| #define UART_16550 2 |
| |
| static int ISA_uarts[] = {0x3f8,0x2f8,0x3e8,0x2e8}; |
| static int ISA_IRQs[] = {4,3,4,3}; |
| |
| typedef struct ComPort_s |
| { |
| struct ComPort_s *next; |
| _go32_dpmi_seginfo protectedModeInfo; |
| _go32_dpmi_seginfo protectedModeSaveInfo; |
| int uart; |
| volatile byte modemStatus; |
| byte modemStatusIgnore; |
| byte lineStatus; |
| byte bufferUsed; |
| qboolean enabled; |
| volatile qboolean statusUpdated; |
| qboolean useModem; |
| qboolean modemInitialized; |
| qboolean modemRang; |
| qboolean modemConnected; |
| queue inputQueue; |
| queue outputQueue; |
| char clear[16]; |
| char startup[32]; |
| char shutdown[16]; |
| char buffer[128]; |
| PollProcedure poll; |
| double timestamp; |
| byte uartType; |
| byte irq; |
| byte baudBits; |
| byte lineControl; |
| byte portNumber; |
| char dialType; |
| char name[4]; |
| } ComPort; |
| |
| ComPort *portList = NULL; |
| ComPort *handleToPort [NUM_COM_PORTS]; |
| |
| static int Modem_Command(ComPort *p, char *commandString); |
| static char *Modem_Response(ComPort *p); |
| static void Modem_Hangup(ComPort *p); |
| |
| int TTY_Init(void); |
| void TTY_Shutdown(void); |
| int TTY_Open(int serialPortNumber); |
| void TTY_Close(int handle); |
| int TTY_ReadByte(int handle); |
| int TTY_WriteByte(int handle, byte data); |
| void TTY_Flush(int handle); |
| int TTY_Connect(int handle, char *host); |
| void TTY_Disconnect(int handle); |
| qboolean TTY_CheckForConnection(int handle); |
| qboolean TTY_IsEnabled(int serialPortNumber); |
| qboolean TTY_IsModem(int serialPortNumber); |
| qboolean TTY_OutputQueueIsEmpty(int handle); |
| |
| static void ISR_8250 (ComPort *p) |
| { |
| byte source = 0; |
| byte b; |
| |
| disable(); |
| |
| while((source = inportb (p->uart + INTERRUPT_ID_REGISTER) & 0x07) != 1) |
| { |
| switch (source) |
| { |
| case IIR_RX_DATA_READY_INTERRUPT: |
| b = inportb (p->uart + RECEIVE_BUFFER_REGISTER); |
| if (! FULL(p->inputQueue)) |
| { |
| ENQUEUE (p->inputQueue, b); |
| } |
| else |
| { |
| p->lineStatus |= LSR_OVERRUN_ERROR; |
| p->statusUpdated = true; |
| } |
| break; |
| |
| case IIR_TX_HOLDING_REGISTER_INTERRUPT: |
| if (! EMPTY(p->outputQueue)) |
| { |
| DEQUEUE (p->outputQueue, b); |
| outportb (p->uart + TRANSMIT_HOLDING_REGISTER, b); |
| } |
| break; |
| |
| case IIR_MODEM_STATUS_INTERRUPT: |
| p->modemStatus = (inportb (p->uart + MODEM_STATUS_REGISTER) & MODEM_STATUS_MASK) | p->modemStatusIgnore; |
| p->statusUpdated = true; |
| break; |
| |
| case IIR_LINE_STATUS_INTERRUPT: |
| p->lineStatus = inportb (p->uart + LINE_STATUS_REGISTER); |
| p->statusUpdated = true; |
| break; |
| } |
| source = inportb (p->uart + INTERRUPT_ID_REGISTER) & 0x07; |
| } |
| outportb (0x20, 0x20); |
| } |
| |
| static void COM1_ISR_8250 (void) |
| { |
| ISR_8250 (handleToPort[0]); |
| } |
| |
| static void COM2_ISR_8250 (void) |
| { |
| ISR_8250 (handleToPort[1]); |
| } |
| |
| |
| |
| static void ISR_16550 (ComPort *p) |
| { |
| int count; |
| byte source; |
| byte b; |
| |
| disable(); |
| while((source = inportb (p->uart + INTERRUPT_ID_REGISTER) & 0x07) != 1) |
| { |
| switch (source) |
| { |
| case IIR_RX_DATA_READY_INTERRUPT: |
| do |
| { |
| b = inportb (p->uart + RECEIVE_BUFFER_REGISTER); |
| if (!FULL(p->inputQueue)) |
| { |
| ENQUEUE (p->inputQueue, b); |
| } |
| else |
| { |
| p->lineStatus |= LSR_OVERRUN_ERROR; |
| p->statusUpdated = true; |
| } |
| } while (inportb (p->uart + LINE_STATUS_REGISTER) & LSR_DATA_READY); |
| break; |
| |
| case IIR_TX_HOLDING_REGISTER_INTERRUPT: |
| count = 16; |
| while ((! EMPTY(p->outputQueue)) && count--) |
| { |
| DEQUEUE (p->outputQueue, b); |
| outportb (p->uart + TRANSMIT_HOLDING_REGISTER, b); |
| } |
| break; |
| |
| case IIR_MODEM_STATUS_INTERRUPT: |
| p->modemStatus = (inportb (p->uart + MODEM_STATUS_REGISTER) & MODEM_STATUS_MASK) | p->modemStatusIgnore; |
| p->statusUpdated = true; |
| break; |
| |
| case IIR_LINE_STATUS_INTERRUPT: |
| p->lineStatus = inportb (p->uart + LINE_STATUS_REGISTER); |
| p->statusUpdated = true; |
| break; |
| } |
| source = inportb (p->uart + INTERRUPT_ID_REGISTER) & 0x07; |
| } |
| |
| // check for lost IIR_TX_HOLDING_REGISTER_INTERRUPT on 16550a! |
| if (inportb (p->uart + LINE_STATUS_REGISTER ) & LSR_TRANSMITTER_EMPTY) |
| { |
| count = 16; |
| while ((! EMPTY(p->outputQueue)) && count--) |
| { |
| DEQUEUE (p->outputQueue, b); |
| outportb (p->uart + TRANSMIT_HOLDING_REGISTER, b); |
| } |
| } |
| |
| outportb (0x20, 0x20); |
| } |
| |
| static void COM1_ISR_16550 (void) |
| { |
| ISR_16550 (handleToPort[0]); |
| } |
| |
| static void COM2_ISR_16550 (void) |
| { |
| ISR_16550 (handleToPort[1]); |
| } |
| |
| |
| void TTY_GetComPortConfig (int portNumber, int *port, int *irq, int *baud, qboolean *useModem) |
| { |
| ComPort *p; |
| |
| p = handleToPort[portNumber]; |
| *port = p->uart; |
| *irq = p->irq; |
| *baud = 115200 / p->baudBits; |
| *useModem = p->useModem; |
| } |
| |
| void TTY_SetComPortConfig (int portNumber, int port, int irq, int baud, qboolean useModem) |
| { |
| ComPort *p; |
| float temp; |
| |
| if (useModem) |
| { |
| if (baud == 14400) |
| baud = 19200; |
| if (baud == 28800) |
| baud = 38400; |
| } |
| |
| p = handleToPort[portNumber]; |
| p->uart = port; |
| p->irq = irq; |
| p->baudBits = 115200 / baud; |
| p->useModem = useModem; |
| |
| if (useModem) |
| temp = 1.0; |
| else |
| temp = 0.0; |
| |
| Cvar_SetValue ("_config_com_port", (float)port); |
| Cvar_SetValue ("_config_com_irq", (float)irq); |
| Cvar_SetValue ("_config_com_baud", (float)baud); |
| Cvar_SetValue ("_config_com_modem", temp); |
| } |
| |
| void TTY_GetModemConfig (int portNumber, char *dialType, char *clear, char *init, char *hangup) |
| { |
| ComPort *p; |
| |
| p = handleToPort[portNumber]; |
| *dialType = p->dialType; |
| Q_strcpy(clear, p->clear); |
| Q_strcpy(init, p->startup); |
| Q_strcpy(hangup, p->shutdown); |
| } |
| |
| void TTY_SetModemConfig (int portNumber, char *dialType, char *clear, char *init, char *hangup) |
| { |
| ComPort *p; |
| |
| p = handleToPort[portNumber]; |
| p->dialType = dialType[0]; |
| Q_strcpy(p->clear, clear); |
| Q_strcpy(p->startup, init); |
| Q_strcpy(p->shutdown, hangup); |
| |
| p->modemInitialized = false; |
| |
| Cvar_Set ("_config_modem_dialtype", dialType); |
| Cvar_Set ("_config_modem_clear", clear); |
| Cvar_Set ("_config_modem_init", init); |
| Cvar_Set ("_config_modem_hangup", hangup); |
| } |
| |
| |
| static void ResetComPortConfig (ComPort *p) |
| { |
| p->useModem = false; |
| p->uartType = UART_AUTO; |
| p->uart = ISA_uarts[p->portNumber]; |
| p->irq = ISA_IRQs[p->portNumber]; |
| p->modemStatusIgnore = MSR_CD | MSR_CTS | MSR_DSR; |
| p->baudBits = 115200 / 57600; |
| p->lineControl = LCR_DATA_BITS_8 | LCR_STOP_BITS_1 | LCR_PARITY_NONE; |
| Q_strcpy(p->clear, "ATZ"); |
| Q_strcpy(p->startup, ""); |
| Q_strcpy(p->shutdown, "AT H"); |
| p->modemRang = false; |
| p->modemConnected = false; |
| p->statusUpdated = false; |
| p->outputQueue.head = p->outputQueue.tail = 0; |
| p->inputQueue.head = p->inputQueue.tail = 0; |
| } |
| |
| |
| static void ComPort_Enable(ComPort *p) |
| { |
| void (*isr)(void); |
| int n; |
| byte b; |
| |
| if (p->enabled) |
| { |
| Con_Printf("Already enabled\n"); |
| return; |
| } |
| |
| // disable all UART interrupts |
| outportb (p->uart + INTERRUPT_ENABLE_REGISTER, 0); |
| |
| // clear out any buffered uncoming data |
| while((inportb (p->uart + LINE_STATUS_REGISTER)) & LSR_DATA_READY) |
| inportb (p->uart + RECEIVE_BUFFER_REGISTER); |
| |
| // get the current line and modem status |
| p->modemStatus = (inportb (p->uart + MODEM_STATUS_REGISTER) & MODEM_STATUS_MASK) | p->modemStatusIgnore; |
| p->lineStatus = inportb (p->uart + LINE_STATUS_REGISTER); |
| |
| // clear any UART interrupts |
| do |
| { |
| n = inportb (p->uart + INTERRUPT_ID_REGISTER) & 7; |
| if (n == IIR_RX_DATA_READY_INTERRUPT) |
| inportb (p->uart + RECEIVE_BUFFER_REGISTER); |
| } while (!(n & 1)); |
| |
| if (p->uartType == UART_AUTO) |
| { |
| outportb (p->uart + FIFO_CONTROL_REGISTER, FCR_FIFO_ENABLE); |
| b = inportb (p->uart + INTERRUPT_ID_REGISTER); |
| if ((b & IIR_FIFO_ENABLED) == IIR_FIFO_ENABLED) |
| p->uartType = UART_16550; |
| else |
| p->uartType = UART_8250; |
| } |
| |
| // save the old interrupt handler |
| _go32_dpmi_get_protected_mode_interrupt_vector(p->irq + 8, &p->protectedModeSaveInfo); |
| |
| if (p->uartType == UART_8250) |
| { |
| outportb (p->uart + FIFO_CONTROL_REGISTER, 0); |
| if (p == handleToPort[0]) |
| isr = COM1_ISR_8250; |
| else |
| isr = COM2_ISR_8250; |
| } |
| else |
| { |
| outportb (p->uart + FIFO_CONTROL_REGISTER, FCR_FIFO_ENABLE | FCR_RCVR_FIFO_RESET | FCR_XMIT_FIFO_RESET | FCR_TRIGGER_08); |
| if (p == handleToPort[0]) |
| isr = COM1_ISR_16550; |
| else |
| isr = COM2_ISR_16550; |
| } |
| |
| p->protectedModeInfo.pm_offset = (int)isr; |
| |
| n = _go32_dpmi_allocate_iret_wrapper(&p->protectedModeInfo); |
| if (n) |
| { |
| Con_Printf("serial: protected mode callback allocation failed\n"); |
| return; |
| } |
| |
| // disable interrupts at the processor |
| disable(); |
| |
| // install our interrupt handlers now |
| _go32_dpmi_set_protected_mode_interrupt_vector(p->irq + 8, &p->protectedModeInfo); |
| |
| // enable our interrupt at the PIC |
| outportb (0x21, inportb (0x21) & ~(1<<p->irq)); |
| |
| // enable interrupts at the processor |
| enable(); |
| |
| // enable interrupts at the PIC |
| outportb (0x20, 0xc2); |
| |
| // set baud rate & line control |
| outportb (p->uart + LINE_CONTROL_REGISTER, LCR_DLAB | p->lineControl); |
| outportb (p->uart, p->baudBits); |
| outportb (p->uart + 1, 0); |
| outportb (p->uart + LINE_CONTROL_REGISTER, p->lineControl); |
| |
| // set modem control register & enable uart interrupt generation |
| outportb(p->uart + MODEM_CONTROL_REGISTER, MCR_OUT2 | MCR_RTS | MCR_DTR); |
| |
| // enable the individual interrupts at the uart |
| outportb (p->uart + INTERRUPT_ENABLE_REGISTER, IER_RX_DATA_READY | IER_TX_HOLDING_REGISTER_EMPTY | IER_LINE_STATUS | IER_MODEM_STATUS); |
| |
| p->enabled = true; |
| } |
| |
| |
| static void ComPort_Disable(ComPort *p) |
| { |
| if (!p->enabled) |
| { |
| Con_Printf("Already disabled\n"); |
| return; |
| } |
| |
| // disable interrupts at the uart |
| outportb (p->uart + INTERRUPT_ENABLE_REGISTER, 0); |
| |
| // disable our interrupt at the PIC |
| outportb (0x21, inportb (0x21) | (1<<p->irq)); |
| |
| // disable interrupts at the processor |
| disable(); |
| |
| // restore the old interrupt handler |
| _go32_dpmi_set_protected_mode_interrupt_vector(p->irq + 8, &p->protectedModeSaveInfo); |
| _go32_dpmi_free_iret_wrapper(&p->protectedModeInfo); |
| |
| // enable interrupts at the processor |
| enable(); |
| |
| p->enabled = false; |
| } |
| |
| |
| static int CheckStatus (ComPort *p) |
| { |
| int ret = 0; |
| |
| if (p->statusUpdated) |
| { |
| p->statusUpdated = false; |
| |
| if (p->lineStatus & (LSR_OVERRUN_ERROR | LSR_PARITY_ERROR | LSR_FRAMING_ERROR | LSR_BREAK_DETECT)) |
| { |
| if (p->lineStatus & LSR_OVERRUN_ERROR) |
| Con_DPrintf ("Serial overrun error\n"); |
| if (p->lineStatus & LSR_PARITY_ERROR) |
| Con_DPrintf ("Serial parity error\n"); |
| if (p->lineStatus & LSR_FRAMING_ERROR) |
| Con_DPrintf ("Serial framing error\n"); |
| if (p->lineStatus & LSR_BREAK_DETECT) |
| Con_DPrintf ("Serial break detect\n"); |
| ret = ERR_TTY_LINE_STATUS; |
| } |
| |
| if ((p->modemStatus & MODEM_STATUS_MASK) != MODEM_STATUS_MASK) |
| { |
| if (!(p->modemStatus & MSR_CTS)) |
| Con_Printf ("Serial lost CTS\n"); |
| if (!(p->modemStatus & MSR_DSR)) |
| Con_Printf ("Serial lost DSR\n"); |
| if (!(p->modemStatus & MSR_CD)) |
| Con_Printf ("Serial lost Carrier\n"); |
| ret = ERR_TTY_MODEM_STATUS; |
| } |
| } |
| |
| return ret; |
| } |
| |
| |
| static void Modem_Init(ComPort *p) |
| { |
| double start; |
| char *response; |
| |
| Con_Printf ("Initializing modem...\n"); |
| |
| // write 0 to MCR, wait 1/2 sec, then write the real value back again |
| // I got this from the guys at head-to-head who say it's necessary. |
| outportb(p->uart + MODEM_CONTROL_REGISTER, 0); |
| start = Sys_FloatTime(); |
| while ((Sys_FloatTime() - start) < 0.5) |
| ; |
| outportb(p->uart + MODEM_CONTROL_REGISTER, MCR_OUT2 | MCR_RTS | MCR_DTR); |
| start = Sys_FloatTime(); |
| while ((Sys_FloatTime() - start) < 0.25) |
| ; |
| |
| if (*p->clear) |
| { |
| Modem_Command (p, p->clear); |
| start = Sys_FloatTime(); |
| while(1) |
| { |
| if ((Sys_FloatTime() - start) > 3.0) |
| { |
| Con_Printf("No response - clear failed\n"); |
| p->enabled = false; |
| goto failed; |
| } |
| response = Modem_Response(p); |
| if (!response) |
| continue; |
| if (Q_strncmp(response, "OK", 2) == 0) |
| break; |
| if (Q_strncmp(response, "ERROR", 5) == 0) |
| { |
| p->enabled = false; |
| goto failed; |
| } |
| } |
| } |
| |
| if (*p->startup) |
| { |
| Modem_Command (p, p->startup); |
| start = Sys_FloatTime(); |
| while(1) |
| { |
| if ((Sys_FloatTime() - start) > 3.0) |
| { |
| Con_Printf("No response - init failed\n"); |
| p->enabled = false; |
| goto failed; |
| } |
| response = Modem_Response(p); |
| if (!response) |
| continue; |
| if (Q_strncmp(response, "OK", 2) == 0) |
| break; |
| if (Q_strncmp(response, "ERROR", 5) == 0) |
| { |
| p->enabled = false; |
| goto failed; |
| } |
| } |
| } |
| |
| p->modemInitialized = true; |
| return; |
| |
| failed: |
| if (m_return_onerror) |
| { |
| key_dest = key_menu; |
| m_state = m_return_state; |
| m_return_onerror = false; |
| Q_strcpy(m_return_reason, "Initialization Failed"); |
| } |
| return; |
| } |
| |
| |
| void TTY_Enable(int handle) |
| { |
| ComPort *p; |
| |
| p = handleToPort [handle]; |
| if (p->enabled) |
| return; |
| |
| ComPort_Enable(p); |
| |
| if (p->useModem && !p->modemInitialized) |
| Modem_Init (p); |
| } |
| |
| |
| int TTY_Open(int serialPortNumber) |
| { |
| return serialPortNumber; |
| } |
| |
| |
| void TTY_Close(int handle) |
| { |
| ComPort *p; |
| double startTime; |
| |
| p = handleToPort [handle]; |
| |
| startTime = Sys_FloatTime(); |
| while ((Sys_FloatTime() - startTime) < 1.0) |
| if (EMPTY(p->outputQueue)) |
| break; |
| |
| if (p->useModem) |
| { |
| if (p->modemConnected) |
| Modem_Hangup(p); |
| } |
| } |
| |
| |
| int TTY_ReadByte(int handle) |
| { |
| int ret; |
| ComPort *p; |
| |
| p = handleToPort [handle]; |
| |
| if ((ret = CheckStatus (p)) != 0) |
| return ret; |
| |
| if (EMPTY (p->inputQueue)) |
| return ERR_TTY_NODATA; |
| |
| DEQUEUE (p->inputQueue, ret); |
| return (ret & 0xff); |
| } |
| |
| |
| int TTY_WriteByte(int handle, byte data) |
| { |
| ComPort *p; |
| |
| p = handleToPort [handle]; |
| if (FULL(p->outputQueue)) |
| return -1; |
| |
| ENQUEUE (p->outputQueue, data); |
| return 0; |
| } |
| |
| |
| void TTY_Flush(int handle) |
| { |
| byte b; |
| ComPort *p; |
| |
| p = handleToPort [handle]; |
| |
| if (inportb (p->uart + LINE_STATUS_REGISTER ) & LSR_TRANSMITTER_EMPTY) |
| { |
| DEQUEUE (p->outputQueue, b); |
| outportb(p->uart, b); |
| } |
| } |
| |
| |
| int TTY_Connect(int handle, char *host) |
| { |
| double start; |
| ComPort *p; |
| char *response = NULL; |
| keydest_t save_key_dest; |
| byte dialstring[64]; |
| byte b; |
| |
| p = handleToPort[handle]; |
| |
| if ((p->modemStatus & MODEM_STATUS_MASK) != MODEM_STATUS_MASK) |
| { |
| Con_Printf ("Serial: line not ready ("); |
| if ((p->modemStatus & MSR_CTS) == 0) |
| Con_Printf(" CTS"); |
| if ((p->modemStatus & MSR_DSR) == 0) |
| Con_Printf(" DSR"); |
| if ((p->modemStatus & MSR_CD) == 0) |
| Con_Printf(" CD"); |
| Con_Printf(" )"); |
| return -1; |
| } |
| |
| // discard any scraps in the input buffer |
| while (! EMPTY (p->inputQueue)) |
| DEQUEUE (p->inputQueue, b); |
| |
| CheckStatus (p); |
| |
| if (p->useModem) |
| { |
| save_key_dest = key_dest; |
| key_dest = key_console; |
| key_count = -2; |
| |
| Con_Printf ("Dialing...\n"); |
| sprintf(dialstring, "AT D%c %s\r", p->dialType, host); |
| Modem_Command (p, dialstring); |
| start = Sys_FloatTime(); |
| while(1) |
| { |
| if ((Sys_FloatTime() - start) > 60.0) |
| { |
| Con_Printf("Dialing failure!\n"); |
| break; |
| } |
| |
| Sys_SendKeyEvents (); |
| if (key_count == 0) |
| { |
| if (key_lastpress != K_ESCAPE) |
| { |
| key_count = -2; |
| continue; |
| } |
| Con_Printf("Aborting...\n"); |
| while ((Sys_FloatTime() - start) < 5.0) |
| ; |
| disable(); |
| p->outputQueue.head = p->outputQueue.tail = 0; |
| p->inputQueue.head = p->inputQueue.tail = 0; |
| outportb(p->uart + MODEM_CONTROL_REGISTER, inportb(p->uart + MODEM_CONTROL_REGISTER) & ~MCR_DTR); |
| enable(); |
| start = Sys_FloatTime(); |
| while ((Sys_FloatTime() - start) < 0.75) |
| ; |
| outportb(p->uart + MODEM_CONTROL_REGISTER, inportb(p->uart + MODEM_CONTROL_REGISTER) | MCR_DTR); |
| response = "Aborted"; |
| break; |
| } |
| |
| response = Modem_Response(p); |
| if (!response) |
| continue; |
| if (Q_strncmp(response, "CONNECT", 7) == 0) |
| { |
| disable(); |
| p->modemRang = true; |
| p->modemConnected = true; |
| p->outputQueue.head = p->outputQueue.tail = 0; |
| p->inputQueue.head = p->inputQueue.tail = 0; |
| enable(); |
| key_dest = save_key_dest; |
| key_count = 0; |
| m_return_onerror = false; |
| return 0; |
| } |
| if (Q_strncmp(response, "NO CARRIER", 10) == 0) |
| break; |
| if (Q_strncmp(response, "NO DIALTONE", 11) == 0) |
| break; |
| if (Q_strncmp(response, "NO DIAL TONE", 12) == 0) |
| break; |
| if (Q_strncmp(response, "NO ANSWER", 9) == 0) |
| break; |
| if (Q_strncmp(response, "BUSY", 4) == 0) |
| break; |
| if (Q_strncmp(response, "ERROR", 5) == 0) |
| break; |
| } |
| key_dest = save_key_dest; |
| key_count = 0; |
| if (m_return_onerror) |
| { |
| key_dest = key_menu; |
| m_state = m_return_state; |
| m_return_onerror = false; |
| Q_strncpy(m_return_reason, response, 31); |
| } |
| return -1; |
| } |
| m_return_onerror = false; |
| return 0; |
| } |
| |
| |
| void TTY_Disconnect(int handle) |
| { |
| ComPort *p; |
| |
| p = handleToPort[handle]; |
| |
| if (p->useModem && p->modemConnected) |
| Modem_Hangup(p); |
| } |
| |
| |
| qboolean TTY_CheckForConnection(int handle) |
| { |
| ComPort *p; |
| |
| p = handleToPort[handle]; |
| |
| CheckStatus (p); |
| |
| if (p->useModem) |
| { |
| if (!p->modemRang) |
| { |
| if (!Modem_Response(p)) |
| return false; |
| |
| if (Q_strncmp(p->buffer, "RING", 4) == 0) |
| { |
| Modem_Command (p, "ATA"); |
| p->modemRang = true; |
| p->timestamp = net_time; |
| } |
| return false; |
| } |
| if (!p->modemConnected) |
| { |
| if ((net_time - p->timestamp) > 35.0) |
| { |
| Con_Printf("Unable to establish modem connection\n"); |
| p->modemRang = false; |
| return false; |
| } |
| |
| if (!Modem_Response(p)) |
| return false; |
| |
| if (Q_strncmp (p->buffer, "CONNECT", 7) != 0) |
| return false; |
| |
| disable(); |
| p->modemConnected = true; |
| p->outputQueue.head = p->outputQueue.tail = 0; |
| p->inputQueue.head = p->inputQueue.tail = 0; |
| enable(); |
| Con_Printf("Modem Connect\n"); |
| return true; |
| } |
| return true; |
| } |
| |
| // direct connect case |
| if (EMPTY (p->inputQueue)) |
| return false; |
| return true; |
| } |
| |
| |
| qboolean TTY_IsEnabled(int serialPortNumber) |
| { |
| return handleToPort[serialPortNumber]->enabled; |
| } |
| |
| |
| qboolean TTY_IsModem(int serialPortNumber) |
| { |
| return handleToPort[serialPortNumber]->useModem; |
| } |
| |
| |
| qboolean TTY_OutputQueueIsEmpty(int handle) |
| { |
| return EMPTY(handleToPort[handle]->outputQueue); |
| } |
| |
| |
| void Com_f (void) |
| { |
| ComPort *p; |
| int portNumber; |
| int i; |
| int n; |
| |
| // first, determine which port they're messing with |
| portNumber = Q_atoi(Cmd_Argv (0) + 3) - 1; |
| if (portNumber > 1) |
| return; |
| p = handleToPort[portNumber]; |
| |
| if (Cmd_Argc() == 1) |
| { |
| Con_Printf("Settings for COM%i\n", portNumber + 1); |
| Con_Printf("enabled: %s\n", p->enabled ? "true" : "false"); |
| Con_Printf("uart: "); |
| if (p->uartType == UART_AUTO) |
| Con_Printf("auto\n"); |
| else if (p->uartType == UART_8250) |
| Con_Printf("8250\n"); |
| else |
| Con_Printf("16550\n"); |
| Con_Printf("port: %x\n", p->uart); |
| Con_Printf("irq: %i\n", p->irq); |
| Con_Printf("baud: %i\n", 115200 / p->baudBits); |
| Con_Printf("CTS: %s\n", (p->modemStatusIgnore & MSR_CTS) ? "ignored" : "honored"); |
| Con_Printf("DSR: %s\n", (p->modemStatusIgnore & MSR_DSR) ? "ignored" : "honored"); |
| Con_Printf("CD: %s\n", (p->modemStatusIgnore & MSR_CD) ? "ignored" : "honored"); |
| if (p->useModem) |
| { |
| Con_Printf("type: Modem\n"); |
| Con_Printf("clear: %s\n", p->clear); |
| Con_Printf("startup: %s\n", p->startup); |
| Con_Printf("shutdown: %s\n", p->shutdown); |
| } |
| else |
| Con_Printf("type: Direct connect\n"); |
| |
| return; |
| } |
| |
| |
| if (Cmd_CheckParm ("disable")) |
| { |
| if (p->enabled) |
| ComPort_Disable(p); |
| p->modemInitialized = false; |
| return; |
| } |
| |
| if (Cmd_CheckParm ("reset")) |
| { |
| ComPort_Disable(p); |
| ResetComPortConfig (p); |
| return; |
| } |
| |
| if ((i = Cmd_CheckParm ("port")) != 0) |
| { |
| if (p->enabled) |
| { |
| Con_Printf("COM port must be disabled to change port\n"); |
| return; |
| } |
| p->uart = Q_atoi (Cmd_Argv (i+1)); |
| } |
| |
| if ((i = Cmd_CheckParm ("irq")) != 0) |
| { |
| if (p->enabled) |
| { |
| Con_Printf("COM port must be disabled to change irq\n"); |
| return; |
| } |
| p->irq = Q_atoi (Cmd_Argv (i+1)); |
| } |
| |
| if ((i = Cmd_CheckParm ("baud")) != 0) |
| { |
| if (p->enabled) |
| { |
| Con_Printf("COM port must be disabled to change baud\n"); |
| return; |
| } |
| n = Q_atoi (Cmd_Argv (i+1)); |
| if (n == 0) |
| Con_Printf("Invalid baud rate specified\n"); |
| else |
| p->baudBits = 115200 / n; |
| } |
| |
| if (Cmd_CheckParm ("8250")) |
| { |
| if (p->enabled) |
| { |
| Con_Printf("COM port must be disabled to change uart\n"); |
| return; |
| } |
| p->uartType = UART_8250; |
| } |
| if (Cmd_CheckParm ("16550")) |
| { |
| if (p->enabled) |
| { |
| Con_Printf("COM port must be disabled to change uart\n"); |
| return; |
| } |
| p->uartType = UART_16550; |
| } |
| if (Cmd_CheckParm ("auto")) |
| { |
| if (p->enabled) |
| { |
| Con_Printf("COM port must be disabled to change uart\n"); |
| return; |
| } |
| p->uartType = UART_AUTO; |
| } |
| |
| if (Cmd_CheckParm ("pulse")) |
| p->dialType = 'P'; |
| if (Cmd_CheckParm ("tone")) |
| p->dialType = 'T'; |
| |
| if (Cmd_CheckParm ("direct")) |
| p->useModem = false; |
| if (Cmd_CheckParm ("modem")) |
| p->useModem = true; |
| |
| if ((i = Cmd_CheckParm ("clear")) != 0) |
| { |
| Q_strncpy (p->clear, Cmd_Argv (i+1), 16); |
| } |
| |
| if ((i = Cmd_CheckParm ("startup")) != 0) |
| { |
| Q_strncpy (p->startup, Cmd_Argv (i+1), 32); |
| p->modemInitialized = false; |
| } |
| |
| if ((i = Cmd_CheckParm ("shutdown")) != 0) |
| { |
| Q_strncpy (p->shutdown, Cmd_Argv (i+1), 16); |
| } |
| |
| if (Cmd_CheckParm ("-cts")) |
| { |
| p->modemStatusIgnore |= MSR_CTS; |
| p->modemStatus |= MSR_CTS; |
| } |
| |
| if (Cmd_CheckParm ("+cts")) |
| { |
| p->modemStatusIgnore &= (~MSR_CTS); |
| p->modemStatus = (inportb (p->uart + MODEM_STATUS_REGISTER) & MODEM_STATUS_MASK) | p->modemStatusIgnore; |
| } |
| |
| if (Cmd_CheckParm ("-dsr")) |
| { |
| p->modemStatusIgnore |= MSR_DSR; |
| p->modemStatus |= MSR_DSR; |
| } |
| |
| if (Cmd_CheckParm ("+dsr")) |
| { |
| p->modemStatusIgnore &= (~MSR_DSR); |
| p->modemStatus = (inportb (p->uart + MODEM_STATUS_REGISTER) & MODEM_STATUS_MASK) | p->modemStatusIgnore; |
| } |
| |
| if (Cmd_CheckParm ("-cd")) |
| { |
| p->modemStatusIgnore |= MSR_CD; |
| p->modemStatus |= MSR_CD; |
| } |
| |
| if (Cmd_CheckParm ("+cd")) |
| { |
| p->modemStatusIgnore &= (~MSR_CD); |
| p->modemStatus = (inportb (p->uart + MODEM_STATUS_REGISTER) & MODEM_STATUS_MASK) | p->modemStatusIgnore; |
| } |
| |
| if (Cmd_CheckParm ("enable")) |
| { |
| if (!p->enabled) |
| ComPort_Enable(p); |
| if (p->useModem && !p->modemInitialized) |
| Modem_Init (p); |
| } |
| } |
| |
| |
| int TTY_Init(void) |
| { |
| int n; |
| ComPort *p; |
| |
| for (n = 0; n < NUM_COM_PORTS; n++) |
| { |
| p = (ComPort *)Hunk_AllocName(sizeof(ComPort), "comport"); |
| if (p == NULL) |
| Sys_Error("Hunk alloc failed for com port\n"); |
| p->next = portList; |
| portList = p; |
| handleToPort[n] = p; |
| p->portNumber = n; |
| p->dialType = 'T'; |
| sprintf(p->name, "com%u", n+1); |
| Cmd_AddCommand (p->name, Com_f); |
| ResetComPortConfig (p); |
| } |
| |
| GetComPortConfig = TTY_GetComPortConfig; |
| SetComPortConfig = TTY_SetComPortConfig; |
| GetModemConfig = TTY_GetModemConfig; |
| SetModemConfig = TTY_SetModemConfig; |
| |
| return 0; |
| } |
| |
| |
| void TTY_Shutdown(void) |
| { |
| int n; |
| ComPort *p; |
| |
| for (n = 0; n < NUM_COM_PORTS; n++) |
| { |
| p = handleToPort[n]; |
| if (p->enabled) |
| { |
| while (p->modemConnected) |
| NET_Poll(); |
| ComPort_Disable (p); |
| } |
| } |
| } |
| |
| |
| static int Modem_Command(ComPort *p, char *commandString) |
| { |
| byte b; |
| |
| if (CheckStatus (p)) |
| return -1; |
| |
| disable(); |
| p->outputQueue.head = p->outputQueue.tail = 0; |
| p->inputQueue.head = p->inputQueue.tail = 0; |
| enable(); |
| p->bufferUsed = 0; |
| |
| while (*commandString) |
| ENQUEUE (p->outputQueue, *commandString++); |
| ENQUEUE (p->outputQueue, '\r'); |
| |
| // get the transmit rolling |
| DEQUEUE (p->outputQueue, b); |
| outportb(p->uart, b); |
| |
| return 0; |
| } |
| |
| |
| static char *Modem_Response(ComPort *p) |
| { |
| byte b; |
| |
| if (CheckStatus (p)) |
| return NULL; |
| |
| while (! EMPTY(p->inputQueue)) |
| { |
| DEQUEUE (p->inputQueue, b); |
| |
| if (p->bufferUsed == (sizeof(p->buffer) - 1)) |
| b = '\r'; |
| |
| if (b == '\r' && p->bufferUsed) |
| { |
| p->buffer[p->bufferUsed] = 0; |
| Con_Printf("%s\n", p->buffer); |
| SCR_UpdateScreen (); |
| p->bufferUsed = 0; |
| return p->buffer; |
| } |
| |
| if (b < ' ' || b > 'z') |
| continue; |
| p->buffer[p->bufferUsed] = b; |
| p->bufferUsed++; |
| } |
| |
| return NULL; |
| } |
| |
| |
| static void Modem_Hangup2(ComPort *p); |
| static void Modem_Hangup3(ComPort *p); |
| static void Modem_Hangup4(ComPort *p); |
| |
| static void Modem_Hangup(ComPort *p) |
| { |
| Con_Printf("Hanging up modem...\n"); |
| disable(); |
| p->modemRang = false; |
| p->outputQueue.head = p->outputQueue.tail = 0; |
| p->inputQueue.head = p->inputQueue.tail = 0; |
| outportb(p->uart + MODEM_CONTROL_REGISTER, inportb(p->uart + MODEM_CONTROL_REGISTER) & ~MCR_DTR); |
| enable(); |
| p->poll.procedure = Modem_Hangup2; |
| p->poll.arg = p; |
| SchedulePollProcedure(&p->poll, 1.5); |
| } |
| |
| static void Modem_Hangup2(ComPort *p) |
| { |
| outportb(p->uart + MODEM_CONTROL_REGISTER, inportb(p->uart + MODEM_CONTROL_REGISTER) | MCR_DTR); |
| Modem_Command(p, "+++"); |
| p->poll.procedure = Modem_Hangup3; |
| SchedulePollProcedure(&p->poll, 1.5); |
| } |
| |
| static void Modem_Hangup3(ComPort *p) |
| { |
| Modem_Command(p, p->shutdown); |
| p->poll.procedure = Modem_Hangup4; |
| SchedulePollProcedure(&p->poll, 1.5); |
| } |
| |
| static void Modem_Hangup4(ComPort *p) |
| { |
| Modem_Response(p); |
| Con_Printf("Hangup complete\n"); |
| p->modemConnected = false; |
| } |