blob: 043093907eb8acdc372b1071cc3d366a7583a55d [file] [log] [blame] [raw]
/* ibm1130_sca.c: IBM 1130 synchronous communications adapter emulation
Based on the SIMH simulator package written by Robert M Supnik
Brian Knittel
Revision History
2005.03.08 - Started
* (C) Copyright 2005-2010, Brian Knittel.
* You may freely use this program, but: it offered strictly on an AS-IS, AT YOUR OWN
* RISK basis, there is no warranty of fitness for any purpose, and the rest of the
* usual yada-yada. Please keep this notice and the copyright in any distributions
* or modifications.
*
* This is not a supported product, but I welcome bug reports and fixes.
* Mail to simh@ibm1130.org
*/
/******************************************************************************************************************
* NOTES:
* This module sends raw bisync data over a standard TCP port. It's meant to be
* used with the emulated 2703 device in Hercules.
*
* Attach command:
*
* to establish an outgoing connection:
*
* attach sca host connect to named host on default port (initial default port is 2703); or
* attach sca host:### connect to named host on port ###. ### is also set as new default port number.
* >> The simulator waits until the connection is established
*
* or to set up for incoming connections:
*
* attach sca -l dummy listen for a connection on default port (initially 2703); Nonnumeric "dummy" argument is ignored; or
* attach sca -l ### listen for a connection on the port ###. ### is also set as the new default port
* >> The simulator proceeds. When another simulator connects, the READY bit is set in the DSW.
*
* If the SCA's autoanswer-enable bit has been set, an incoming connection causes an interrupt (untested)
* Configuration commands:
*
* set sca bsc set bisync mode (default)
* set sca str set synchronous transmit/recieve mode (NOT IMPLEMENTED)
*
* set sca ### set simulated baud rate to ###, where ### is 600, 1200, 2000, 2400 or 4800 (4800 is default)
*
* set sca half set simulated half-duplex mode
* set sca full set simulated full-duplex mode (note: 1130's SCA can't actually send and receive at the same time!)
*
* deposit sca keepalive ### send SYN packets every ### msec when suppressing SYN's, default is 0 (no keepalives)
*
* STR/BSC mode is selected by a toggle switch on the 1130, with the SET SCA BSC or SET SET STR command here.
* Testable with in_bsc_mode() or in_str_mode() in this module. If necessary, the SET command can be configured
* to call a routine when the mode is changed; or, we can just required the user to reboot the simulated 1130
* when switching modes.
*
* STR MODE IS NOT IMPLEMENTED!
*
* The SCA adapter appears to know nothing of the protocols used by STR and BSC. It does handle the sync/idle
* character specially, and between BSC and STR mode the timers are used differently. Also in STR mode it
* can be set to a sychronization mode where it sends SYN's without program intervention.
*
* See definition of SCA_STATE for defintion of simulator states.
*
* Rather than trying to simulate the actual baud rates, we try to keep the character service interrupts
* coming at about the same number of instruction intervals -- thus existing 1130 code should work correctly
* but the effective data transfer rate will be much higher. The "timers" however are written to run on real wall clock
* time, This may or may not work. If necessary they could be set to time out based on the number of calls to sca_svc
* which occurs once per character send/receive time; For example, at 4800 baud and an 8 bit frame, we get
* 600 characters/second, so the 3 second timer would expire in 1800 sca_svc calls. Well, that's something to
* think about.
*
* To void blowing zillions of SYN characters across the network when the system is running but idle, we suppress
* them. If 100 consecutive SYN's are sent, we flush the output buffer and stop sending SYN's
* until some other character is sent, OR the line is turned around (e.g. INITR, INITW or an end-operation
* CONTROL is issued), or the number of msec set by DEPOSIT SCS KEEPALIVE has passed, if a value has
* been set. By default no keepalives are sent.
*
* Timer operations are not debugged. First, do timers automatically reset and re-interrupt if
* left alone after they timeout the first time? Does XIO_SENSE_DEV really restart all running timers?
* Does it touch the timer trigger (program timer?) How do 3 and 1.25 second timers really work
* in BSC mode? Hard to tell from the FC manual.
******************************************************************************************************************/
#include "ibm1130_defs.h"
#include "sim_sock.h" /* include path must include main simh directory */
#include <ctype.h>
#define DEBUG_SCA_FLUSH 0x0001 /* debugging options */
#define DEBUG_SCA_TRANSMIT 0x0002
#define DEBUG_SCA_CHECK_INDATA 0x0004
#define DEBUG_SCA_RECEIVE_SYNC 0x0008
#define DEBUG_SCA_RECEIVE_DATA 0x0010
#define DEBUG_SCA_XIO_READ 0x0020
#define DEBUG_SCA_XIO_WRITE 0x0040
#define DEBUG_SCA_XIO_CONTROL 0x0080
#define DEBUG_SCA_XIO_INITW 0x0100
#define DEBUG_SCA_XIO_INITR 0x0200
#define DEBUG_SCA_XIO_SENSE_DEV 0x0400
#define DEBUG_SCA_TIMERS 0x0800
#define DEBUG_SCA_ALL 0xFFFF
/* #define DEBUG_SCA (DEBUG_SCA_TIMERS|DEBUG_SCA_FLUSH|DEBUG_SCA_TRANSMIT|DEBUG_SCA_CHECK_INDATA|DEBUG_SCA_RECEIVE_SYNC|DEBUG_SCA_RECEIVE_DATA|DEBUG_SCA_XIO_INITR|DEBUG_SCA_XIO_INITW) */
#define DEBUG_SCA (DEBUG_SCA_TIMERS|DEBUG_SCA_FLUSH|DEBUG_SCA_CHECK_INDATA|DEBUG_SCA_XIO_INITR|DEBUG_SCA_XIO_INITW)
#define SCA_DEFAULT_PORT "2703" /* default socket, This is the number of the IBM 360's BSC device */
#define MAX_SYNS 100 /* number of consecutive syn's after which we stop buffering them */
/***************************************************************************************
* SCA
***************************************************************************************/
#define SCA_DSW_READ_RESPONSE 0x8000 /* receive buffer full interrupt */
#define SCA_DSW_WRITE_RESPONSE 0x4000 /* transmitter buffer empty interrupt */
#define SCA_DSW_CHECK 0x2000 /* data overrun or character gap error */
#define SCA_DSW_TIMEOUT 0x1000 /* timer interrupt, mode specific */
#define SCA_DSW_AUTOANSWER_REQUEST 0x0800 /* dataset is ringing and autoanswer is enabled */
#define SCA_DSW_BUSY 0x0400 /* adapter is in either receive or transmit mode */
#define SCA_DSW_AUTOANSWER_ENABLED 0x0200 /* 1 when autoanswer mode has been enabled */
#define SCA_DSW_READY 0x0100 /* Carrier detect? Connected and ready to rcv, xmit or sync */
#define SCA_DSW_RECEIVE_RUN 0x0080 /* used in two-wire half-duplex STR mode only. "Slave" mode (?) */
#define IS_ONLINE(u) (((u)->flags & (UNIT_ATT|UNIT_DIS)) == UNIT_ATT)
typedef enum { /* ms m = mode (0 = idle, 1 = send, 2 = receive), s = substate */
SCA_STATE_IDLE = 0x00, /* nothing happening */
SCA_STATE_TURN_SEND = 0x10, /* line turning around to the send state */
SCA_STATE_SEND_SYNC = 0x11, /* sca is sending syncs */
SCA_STATE_SEND1 = 0x12, /* have issued write response, waiting for write command */
SCA_STATE_SEND2 = 0x13, /* write command issued, "sending" byte */
SCA_STATE_TURN_RECEIVE = 0x20, /* line turnaround to the receive state */
SCA_STATE_RECEIVE_SYNC = 0x21, /* sca is receiving syncs */
SCA_STATE_RECEIVE_SYNC2 = 0x22, /* bsc mode, waiting for 2nd SYN */
SCA_STATE_RECEIVE_SYNC3 = 0x23, /* bsc mode, waiting for 1st non-SYN */
SCA_STATE_RECEIVE1 = 0x24, /* "receiving" a byte */
SCA_STATE_RECEIVE2 = 0x25, /* read response issued, "receiving" next byte */
} SCA_STATE;
#define in_send_state() (sca_state & 0x10)
#define in_receive_state() (sca_state & 0x20)
static t_stat sca_svc (UNIT *uptr); /* prototypes */
static t_stat sca_reset (DEVICE *dptr);
static t_stat sca_attach (UNIT *uptr, CONST char *cptr);
static t_stat sca_detach (UNIT *uptr);
static void sca_start_timer (int n, int msec_now);
static void sca_halt_timer (int n);
static void sca_toggle_timer (int n, int msec_now);
/* timer states, chosen so any_timer_running can be calculated by oring states of all 3 timers */
typedef enum {SCA_TIMER_INACTIVE = 0, SCA_TIMER_RUNNING = 1, SCA_TIMER_INHIBITED = 2, SCA_TIMER_TIMEDOUT = 4} SCA_TIMER_STATE;
#define TIMER_3S 0 /* 3 second timer index into sca_timer_xxx arrays */
#define TIMER_125S 1 /* 1.25 second timer */
#define TIMER_035S 2 /* 0.35 second timer */
static uint16 sca_dsw = 0; /* device status word */
static uint32 sca_cwait = 275; /* inter-character wait */
static uint32 sca_iwait = 2750; /* idle wait */
static uint32 sca_state = SCA_STATE_IDLE;
static uint8 sichar = 0; /* sync/idle character */
static uint8 rcvd_char = 0; /* most recently received character */
static uint8 sca_frame = 8;
static char sca_port[CBUFSIZE]; /* listening port */
static int32 sca_keepalive = 0; /* keepalive SYN packet period in msec, default = 0 (disabled) */
static SCA_TIMER_STATE sca_timer_state[3]; /* current timer state */
static int sca_timer_endtime[3]; /* clocktime when timeout is to occur if state is RUNNING */
static int sca_timer_timeleft[3]; /* time left in msec if state is INHIBITED */
static t_bool any_timer_running = FALSE; /* TRUE if at least one timer is running */
static int sca_timer_msec[3] = {3000, 1250, 350}; /* timebase in msec for the three timers: 3 sec, 1.25 sec, 0.35 sec */
static t_bool sca_timer_trigger; /* if TRUE, the "timer trigger" is set, the 0.35s timer is running and the 3 sec and 1.25 sec timers are inhibited */
static int sca_nsyns = 0; /* number of consecutively sent SYN's */
static int idles_since_last_write = 0; /* used to detect when software has ceased sending data */
static SOCKET sca_lsock = INVALID_SOCKET;
static SOCKET sca_sock = INVALID_SOCKET;
#define SCA_SENDBUF_SIZE 145 /* maximum number of bytes to buffer for transmission */
#define SCA_RCVBUF_SIZE 256 /* max number of bytes to read from socket at a time */
#define SCA_SEND_THRESHHOLD 140 /* number of bytes to buffer before initiating packet send */
#define SCA_IDLE_THRESHHOLD 3 /* maximum number of unintentional idles to buffer before initiating send */
static uint8 sca_sendbuf[SCA_SENDBUF_SIZE]; /* bytes pending to write to socket */
static uint8 sca_rcvbuf[SCA_RCVBUF_SIZE]; /* bytes received from socket, to be given to SCA */
static int sca_n2send = 0; /* number of bytes queued for transmission */
static int sca_nrcvd = 0; /* number of received bytes in buffer */
static int sca_rcvptr = 0; /* index of next byte to take from rcvbuf */
#define UNIT_V_BISYNC (UNIT_V_UF + 0) /* BSC (bisync) mode */
#define UNIT_V_BAUD (UNIT_V_UF + 1) /* 3 bits for baud rate encoding */
#define UNIT_V_FULLDUPLEX (UNIT_V_UF + 4)
#define UNIT_V_AUTOANSWER (UNIT_V_UF + 5)
#define UNIT_V_LISTEN (UNIT_V_UF + 6) /* listen socket mode */
#define UNIT_BISYNC (1u << UNIT_V_BISYNC)
#define UNIT_BAUDMASK (7u << UNIT_V_BAUD)
#define UNIT_BAUD600 (0u << UNIT_V_BAUD)
#define UNIT_BAUD1200 (1u << UNIT_V_BAUD)
#define UNIT_BAUD2000 (2u << UNIT_V_BAUD)
#define UNIT_BAUD2400 (3u << UNIT_V_BAUD)
#define UNIT_BAUD4800 (4u << UNIT_V_BAUD)
#define UNIT_FULLDUPLEX (1u << UNIT_V_FULLDUPLEX)
#define UNIT_AUTOANSWER (1u << UNIT_V_AUTOANSWER)
#define UNIT_LISTEN (1u << UNIT_V_LISTEN)
t_stat sca_set_baud (UNIT *uptr, int32 value, CONST char *cptr, void *desc);
UNIT sca_unit = { /* default settings */
UDATA (sca_svc, UNIT_ATTABLE|UNIT_BISYNC|UNIT_BAUD4800|UNIT_FULLDUPLEX, 0),
};
REG sca_reg[] = { /* DEVICE STATE/SETTABLE PARAMETERS: */
{ HRDATA (SCADSW, sca_dsw, 16) }, /* device status word */
{ DRDATA (SICHAR, sichar, 8), PV_LEFT }, /* sync/idle character */
{ DRDATA (RCVDCHAR, rcvd_char, 8), PV_LEFT }, /* most recently received character */
{ DRDATA (FRAME, sca_frame, 8), PV_LEFT }, /* frame bits (6, 7 or 8) */
{ DRDATA (SCASTATE, sca_state, 32), PV_LEFT }, /* current state */
{ DRDATA (CTIME, sca_cwait, 32), PV_LEFT }, /* inter-character wait */
{ DRDATA (ITIME, sca_iwait, 32), PV_LEFT }, /* idle wait (polling interval for socket connects) */
{ BRDATA (SCASOCKET, sca_port, 8, 8, sizeof(sca_port)) }, /* listening port number */
{ DRDATA (KEEPALIVE, sca_keepalive, 32), PV_LEFT }, /* keepalive packet period in msec */
{ NULL } };
MTAB sca_mod[] = { /* DEVICE OPTIONS */
{ UNIT_BISYNC, 0, "STR", "STR", NULL }, /* mode option */
{ UNIT_BISYNC, UNIT_BISYNC, "BSC", "BSC", NULL },
{ UNIT_BAUDMASK, UNIT_BAUD600, "600", "600", sca_set_baud }, /* data rate option */
{ UNIT_BAUDMASK, UNIT_BAUD1200, "1200", "1200", sca_set_baud },
{ UNIT_BAUDMASK, UNIT_BAUD2000, "2000", "2000", sca_set_baud },
{ UNIT_BAUDMASK, UNIT_BAUD2400, "2400", "2400", sca_set_baud },
{ UNIT_BAUDMASK, UNIT_BAUD4800, "4800", "4800", sca_set_baud },
{ UNIT_FULLDUPLEX, 0, "HALF", "HALF", NULL }, /* duplex option (does this matter?) */
{ UNIT_FULLDUPLEX, UNIT_FULLDUPLEX, "FULL", "FULL", NULL },
{ 0 } };
DEVICE sca_dev = {
"SCA", &sca_unit, sca_reg, sca_mod,
1, 16, 16, 1, 16, 16,
NULL, NULL, sca_reset,
NULL, sca_attach, sca_detach
};
/*********************************************************************************************
* sca_set_baud - set baud rate handler (SET SCA.BAUD nnn)
*********************************************************************************************/
t_stat sca_set_baud (UNIT *uptr, int32 value, CONST char *cptr, void *desc)
{
uint32 newbits;
switch (value) {
case 600: newbits = UNIT_BAUD600; break;
case 1200: newbits = UNIT_BAUD1200; break;
case 2000: newbits = UNIT_BAUD2000; break;
case 2400: newbits = UNIT_BAUD2400; break;
case 4800: newbits = UNIT_BAUD4800; break;
default: return SCPE_ARG;
}
CLRBIT(sca_unit.flags, UNIT_BAUDMASK);
SETBIT(sca_unit.flags, newbits);
sca_cwait = 1320000 / value; /* intercharacter wait time in instructions (roughly) */
return SCPE_OK;
}
/*********************************************************************************************
* HANDY MACROS
*********************************************************************************************/
#define in_bsc_mode() (sca_unit.flags & UNIT_BISYNC) /* TRUE if user selected BSC mode */
#define in_str_mode() ((sca_unit.flags & UNIT_BISYNC) == 0) /* TRUE if user selected STR mode */
/*********************************************************************************************
* mstring - allocate a copy of a string
*********************************************************************************************/
char *mstring (const char *str)
{
int len;
char *m;
len = strlen(str)+1;
if ((m = (char *)malloc(len)) == NULL) {
printf("Out of memory!");
return (char *)"?"; /* this will of course cause trouble if it's subsequently freed */
}
strcpy(m, str);
return m;
}
/*********************************************************************************************
* sca_socket_error - call when there is an error reading from or writing to socket
*********************************************************************************************/
static void sca_socket_error (void)
{
char name[100];
/* print diagnostic? */
printf("SCA socket error, closing connection\n");
/* tell 1130 that connection was lost */
CLRBIT(sca_dsw, SCA_DSW_READY);
if (sca_sock != INVALID_SOCKET) {
/* close socket, prepare to listen again if in listen mode. It's a "master" socket if it was an outgoing connection */
sim_close_sock(sca_sock);
sca_sock = INVALID_SOCKET;
if (sca_unit.filename != NULL) /* reset filename string in unit record */
free(sca_unit.filename);
if (sca_unit.flags & UNIT_LISTEN) {
sprintf(name, "(Listening on port %s)", sca_port);
sca_unit.filename = mstring(name);
printf("%s\n", name);
}
else
sca_unit.filename = mstring("(connection failed)");
}
/* clear buffers */
sca_nrcvd = sca_rcvptr = sca_n2send = sca_nsyns = 0;
}
/*********************************************************************************************
* sca_transmit_byte, sca_flush - send data buffering mechanism
*********************************************************************************************/
static void sca_flush (void)
{
int nbytes;
if (sca_n2send > 0) {
#if (DEBUG_SCA & DEBUG_SCA_FLUSH)
printf("* SCA_FLUSH %d byte%s\n", sca_n2send, (sca_n2send == 1) ? "" : "s");
#endif
if (sca_sock != INVALID_SOCKET) {
nbytes = sim_write_sock(sca_sock, (char *) sca_sendbuf, sca_n2send);
if (nbytes == SOCKET_ERROR)
sca_socket_error();
else if (nbytes != sca_n2send)
printf("SOCKET BLOCKED -- NEED TO REWRITE IBM1130_SCA.C");
/* I'm going to assume that SCA communications on the 1130 will consist entirely */
/* of back and forth exchanges of short records, and so we should never stuff the pipe so full that */
/* it blocks. If it does ever block, we'll have to come up with an asychronous buffering mechanism. */
}
sca_n2send = 0; /* mark buffer cleared */
}
}
/*********************************************************************************************
* sca_transmit_byte - buffer a byte to be send to the socket
*********************************************************************************************/
static void sca_transmit_byte (uint8 b)
{
uint32 curtime;
static uint32 last_syn_time, next_syn_time;
#if (DEBUG_SCA & DEBUG_SCA_TRANSMIT)
printf("* SCA_TRANSMIT: %02x\n", b);
#endif
/* write a byte to the socket. Let's assume an 8 bit frame in all cases.
* We buffer them up, then send the packet when (a) it fills up to a certain point
* and/or (b) some time has passed? We handle (b) by:
* checking in sva_svc if several sca_svc calls are made w/o any XIO_WRITES, and
* flushing send buffer on line turnaround, timeouts, or any other significant state change
*/
/* on socket error, call sca_socket_error(); */
if (b == sichar) {
if (sca_nsyns >= MAX_SYNS) { /* we're suppressing SYN's */
if (sca_keepalive > 0) { /* we're sending keepalives, though... check to see if it's time */
curtime = sim_os_msec();
if (curtime >= next_syn_time || curtime < last_syn_time) { /* check for < last_syn_time because sim_os_msec() can wrap when OS has been running a long time */
sca_sendbuf[sca_n2send++] = b;
sca_sendbuf[sca_n2send++] = b; /* send 2 of them */
sca_flush();
last_syn_time = curtime;
next_syn_time = last_syn_time + sca_keepalive;
}
}
return;
}
if (++sca_nsyns == MAX_SYNS) { /* we've sent a bunch of SYN's, time to stop sending them */
sca_sendbuf[sca_n2send] = b; /* send last one */
sca_flush();
last_syn_time = sim_os_msec(); /* remember time, and note time to send next one */
next_syn_time = last_syn_time + sca_keepalive;
return;
}
}
else
sca_nsyns = 0;
sca_sendbuf[sca_n2send] = b; /* store character */
if (++sca_n2send >= SCA_SEND_THRESHHOLD)
sca_flush(); /* buffer is full, send it immediately */
}
/*********************************************************************************************
* sca_interrupt (utility routine) - set a bit in the device status word and initiate an interrupt
*********************************************************************************************/
static void sca_interrupt (int bit)
{
sca_dsw |= bit; /* set device status word bit(s) */
SETBIT(ILSW[1], ILSW_1_SCA); /* set interrupt level status word bit */
calc_ints(); /* udpate simulator interrupt status (not really needed if within xio handler, since ibm1130_cpu calls it after xio handler) */
}
/*********************************************************************************************
* sca_reset - reset the SCA device
*********************************************************************************************/
static t_stat sca_reset (DEVICE *dptr)
{
/* flush any pending data */
sca_flush();
sca_nrcvd = sca_rcvptr = sca_n2send = sca_nsyns = 0;
/* reset sca activity */
sca_state = SCA_STATE_IDLE;
CLRBIT(sca_dsw, SCA_DSW_BUSY | SCA_DSW_AUTOANSWER_ENABLED | SCA_DSW_RECEIVE_RUN | SCA_DSW_READ_RESPONSE | SCA_DSW_WRITE_RESPONSE | SCA_DSW_CHECK | SCA_DSW_TIMEOUT | SCA_DSW_AUTOANSWER_REQUEST);
sca_timer_state[0] = sca_timer_state[1] = sca_timer_state[2] = SCA_TIMER_INACTIVE;
any_timer_running = FALSE;
sca_timer_trigger = FALSE;
if (sca_unit.flags & UNIT_ATT) /* if unit is attached (or listening) */
sim_activate(&sca_unit, sca_iwait); /* poll for service. Must do this here as BOOT clears activity queue before resetting all devices */
return SCPE_OK;
}
/*********************************************************************************************
* sca_attach - attach the SCA device
*********************************************************************************************/
static t_stat sca_attach (UNIT *uptr, CONST char *cptr)
{
char host[CBUFSIZE], port[CBUFSIZE];
t_bool do_listen;
char name[CBUFSIZE];
t_stat r;
do_listen = sim_switches & SWMASK('L'); /* -l means listen mode */
if (sca_unit.flags & UNIT_ATT) /* if already attached, detach */
detach_unit(&sca_unit);
if (do_listen) { /* if listen mode, string specifies port number (only; otherwise it's a dummy argument) */
if (sim_parse_addr (cptr, host, sizeof(host), NULL, port, sizeof(port), SCA_DEFAULT_PORT, NULL))
return SCPE_ARG;
if ((0 == strcmp(port, cptr)) && (0 == strcmp(port, "dummy")))
strcpy(port, SCA_DEFAULT_PORT);
sprintf(sca_port, "%s%s%s:%s", strchr(host, ':') ? "[" : "", host, strchr(host, ':') ? "]" : "", port);
/* else if nondigits specified, ignore... but the command has to have something there otherwise the core scp */
/* attach_cmd() routine complains "too few arguments". */
sca_lsock = sim_master_sock(sca_port, &r);
if (r != SCPE_OK)
return r;
if (sca_lsock == INVALID_SOCKET)
return SCPE_OPENERR;
SETBIT(sca_unit.flags, UNIT_LISTEN); /* note that we are listening, not yet connected */
sprintf(name, "(Listening on port %s)", sca_port);
sca_unit.filename = mstring(name);
printf("%s\n", sca_unit.filename);
}
else {
while (*cptr && *cptr <= ' ')
cptr++;
if (! *cptr)
return SCPE_2FARG;
if (sim_parse_addr (cptr, host, sizeof(host), NULL, port, sizeof(port), SCA_DEFAULT_PORT, NULL))
return SCPE_ARG;
if ((0 == strcmp(cptr, port)) && (0 == strcmp(host, ""))) {
strcpy(host, port);
strcpy(port, SCA_DEFAULT_PORT);
}
sprintf(sca_port, "%s%s%s:%s", strchr(host, ':') ? "[" : "", host, strchr(host, ':') ? "]" : "", port);
if ((sca_sock = sim_connect_sock(sca_port, NULL, NULL)) == INVALID_SOCKET)
return SCPE_OPENERR;
/* sim_connect_sock() sets socket to nonblocking before initiating the connect, so
* the connect is pending when it returns. For outgoing connections, the attach command should wait
* until the connection succeeds or fails. We use "sim_check_conn" to wait and find out which way it goes...
*/
while (0 == sim_check_conn(sca_sock, 0))/* wait for connection to complete or fail */
sim_os_ms_sleep(1000);
if (1 == sim_check_conn(sca_sock, 0)) { /* sca_sock appears in "writable" set -- connect completed */
sprintf(name, "%s%s%s:%s", strchr(host, ':') ? "[" : "", host, strchr(host, ':') ? "]" : "", port);
sca_unit.filename = mstring(name);
SETBIT(sca_dsw, SCA_DSW_READY);
}
else { /* sca_sock appears in "error" set -- connect failed */
sim_close_sock(sca_sock);
sca_sock = INVALID_SOCKET;
return SCPE_OPENERR;
}
}
/* set up socket connect or listen. on success, set UNIT_ATT.
* If listen mode, set UNIT_LISTEN. sca_svc will poll for connection
* If connect mode, set dsw SCA_DSW_READY to indicate connection is up
*/
SETBIT(sca_unit.flags, UNIT_ATT); /* record successful socket binding */
sca_state = SCA_STATE_IDLE;
sim_activate(&sca_unit, sca_iwait); /* start polling for service */
sca_n2send = 0; /* clear buffers */
sca_nrcvd = 0;
sca_rcvptr = 0;
sca_nsyns = 0;
return SCPE_OK;
}
/*********************************************************************************************
* sca_detach - detach the SCA device
*********************************************************************************************/
static t_stat sca_detach (UNIT *uptr)
{
if ((sca_unit.flags & UNIT_ATT) == 0)
return SCPE_OK;
sca_flush();
sca_state = SCA_STATE_IDLE; /* stop processing during service calls */
sim_cancel(&sca_unit); /* stop polling for service */
CLRBIT(sca_dsw, SCA_DSW_READY); /* indicate offline */
if (sca_sock != INVALID_SOCKET) { /* close connected socket */
sim_close_sock(sca_sock);
sca_sock = INVALID_SOCKET;
}
if (sca_lsock != INVALID_SOCKET) { /* close listening socket */
sim_close_sock(sca_lsock);
sca_lsock = INVALID_SOCKET;
}
free(sca_unit.filename);
sca_unit.filename = NULL;
CLRBIT(sca_unit.flags, UNIT_ATT|UNIT_LISTEN);
return SCPE_OK;
}
/*********************************************************************************************
* sca_check_connect - see if an incoming socket connection has com
*********************************************************************************************/
static void sca_check_connect (void)
{
char *connectaddress;
if ((sca_sock = sim_accept_conn(sca_lsock, &connectaddress)) == INVALID_SOCKET)
return;
printf("(SCA connection from %s)\n", connectaddress);
if (sca_unit.filename != NULL)
free(sca_unit.filename);
sca_unit.filename = connectaddress;
SETBIT(sca_dsw, SCA_DSW_READY); /* indicate active connection */
if (sca_dsw & SCA_DSW_AUTOANSWER_ENABLED) /* if autoanswer was enabled, I guess we should give them an interrupt. Untested. */
sca_interrupt(SCA_DSW_AUTOANSWER_REQUEST);
}
/*********************************************************************************************
* sca_check_indata - try to fill receive buffer from socket
*********************************************************************************************/
static void sca_check_indata (void)
{
int nbytes;
sca_rcvptr = 0; /* reset pointers and count */
sca_nrcvd = 0;
#ifdef FAKE_SCA
nbytes = 5; /* FAKE: receive SYN SYN SYN SYN DLE ACK0 */
sca_rcvbuf[0] = 0x32;
sca_rcvbuf[1] = 0x32;
sca_rcvbuf[2] = 0x32;
sca_rcvbuf[3] = 0x10;
sca_rcvbuf[4] = 0x70;
#else
/* read socket; 0 is returned if no data is available */
nbytes = sim_read_sock(sca_sock, (char *) sca_rcvbuf, SCA_RCVBUF_SIZE);
#endif
if (nbytes < 0)
sca_socket_error();
else /* zero or more */
sca_nrcvd = nbytes;
#if (DEBUG_SCA & DEBUG_SCA_CHECK_INDATA)
if (sca_nrcvd > 0)
printf("* SCA_CHECK_INDATA %d byte%s\n", sca_nrcvd, (sca_nrcvd == 1) ? "" : "s");
#endif
}
/*********************************************************************************************
* sca_svc - handled scheduled event. This will presumably be scheduled frequently, and can check
* for incoming data, reasonableness of initiating a write interrupt, timeouts etc.
*********************************************************************************************/
static t_stat sca_svc (UNIT *uptr)
{
t_bool timeout;
int msec_now;
int i;
/* if not connected, and if in wait-for-connection mode, check for connection attempt */
if ((sca_unit.flags & UNIT_LISTEN) && ! (sca_dsw & SCA_DSW_READY))
sca_check_connect();
if (any_timer_running) {
msec_now = sim_os_msec();
timeout = FALSE;
for (i = 0; i < 3; i++) {
if (sca_timer_state[i] == SCA_TIMER_RUNNING && msec_now >= sca_timer_endtime[i]) {
timeout = TRUE;
sca_timer_state[i] = SCA_TIMER_TIMEDOUT;
#if (DEBUG_SCA & DEBUG_SCA_TIMERS)
printf("+ SCA_TIMER %d timed out\n", i);
#endif
if (i == TIMER_035S && sca_timer_trigger) {
sca_timer_trigger = FALSE; /* uninhibit the other two timers */
sca_toggle_timer(TIMER_3S, msec_now);
sca_toggle_timer(TIMER_125S, msec_now);
}
}
}
if (timeout)
sca_interrupt(SCA_DSW_TIMEOUT);
any_timer_running = (sca_timer_state[0]| sca_timer_state[1] | sca_timer_state[2]) & SCA_TIMER_RUNNING;
}
if (sca_dsw & SCA_DSW_READY) { /* if connected */
/* if rcvd data buffer is empty, and if in one of the receive states, checÄk for arrival of received data */
if (in_receive_state() && sca_rcvptr >= sca_nrcvd)
sca_check_indata();
switch (sca_state) {
case SCA_STATE_IDLE:
break;
case SCA_STATE_TURN_SEND:
/* has enough time gone by yet? if so... */
sca_state = SCA_STATE_SEND1;
sca_interrupt(SCA_DSW_WRITE_RESPONSE);
break;
case SCA_STATE_SEND_SYNC:
sca_transmit_byte(sichar);
break;
case SCA_STATE_SEND1:
sca_transmit_byte(sichar); /* character interval has passed with no character written? character gap check */
sca_interrupt(SCA_DSW_CHECK); /* send an idle character (maybe? for socket IO maybe send nothing) and interrupt */
if (idles_since_last_write >= 0) {
if (++idles_since_last_write >= SCA_IDLE_THRESHHOLD) {
sca_flush();
idles_since_last_write = -1; /* don't send a short packet again until real data gets written again */
sca_nsyns = 0; /* resume sending syns if output starts up again */
}
}
break;
case SCA_STATE_SEND2:
sca_state = SCA_STATE_SEND1; /* character has been sent. Schedule another transmit */
sca_interrupt(SCA_DSW_WRITE_RESPONSE);
break;
case SCA_STATE_TURN_RECEIVE:
/* has enough time gone by yet? if so... */
sca_state = SCA_STATE_RECEIVE_SYNC; /* assume a character is coming in */
break;
case SCA_STATE_RECEIVE_SYNC:
if (sca_rcvptr < sca_nrcvd) {
rcvd_char = sca_rcvbuf[sca_rcvptr++];
#if (DEBUG_SCA & DEBUG_SCA_RECEIVE_SYNC)
printf("* SCA rcvd %02x %s\n", rcvd_char, (rcvd_char == sichar) ? "sync1" : "ignored");
#endif
if (in_bsc_mode()) {
if (rcvd_char == sichar) /* count the SYN but don't interrupt */
sca_state = SCA_STATE_RECEIVE_SYNC2;
}
}
break;
case SCA_STATE_RECEIVE_SYNC2:
if (sca_rcvptr < sca_nrcvd) {
rcvd_char = sca_rcvbuf[sca_rcvptr++];
#if (DEBUG_SCA & DEBUG_SCA_RECEIVE_SYNC)
printf("* SCA rcvd %02x %s\n", rcvd_char, (rcvd_char == sichar) ? "sync2" : "ignored");
#endif
if (in_bsc_mode()) {
if (rcvd_char == sichar) /* count the SYN but don't interrupt */
sca_state = SCA_STATE_RECEIVE_SYNC3;
}
}
break;
case SCA_STATE_RECEIVE_SYNC3:
case SCA_STATE_RECEIVE1:
if (sca_rcvptr < sca_nrcvd) {
rcvd_char = sca_rcvbuf[sca_rcvptr++];
if (sca_state == SCA_STATE_RECEIVE_SYNC3 && rcvd_char == sichar) {
/* we're ready for data, but we're still seeing SYNs */
#if (DEBUG_SCA & DEBUG_SCA_RECEIVE_SYNC)
printf("* SCA rcvd %02x extra sync\n", rcvd_char);
#endif
}
else {
#if (DEBUG_SCA & DEBUG_SCA_RECEIVE_DATA)
printf("* SCA rcvd %02x\n", rcvd_char);
#endif
sca_interrupt(SCA_DSW_READ_RESPONSE);
sca_state = SCA_STATE_RECEIVE2;
}
}
/* otherwise remain in state until data becomes available */
break;
case SCA_STATE_RECEIVE2: /* if we are still in this state when another service interval has passed */
if (sca_rcvptr < sca_nrcvd) {
rcvd_char = sca_rcvbuf[sca_rcvptr++];
sca_interrupt(SCA_DSW_CHECK); /* overrun error */
sca_state = SCA_STATE_RECEIVE1; /* another character will come soon */
}
break;
default:
printf("Simulator error: unknown state %d in sca_svc\n", sca_state);
sca_state = SCA_STATE_IDLE;
break;
}
}
/* schedule service again */
sim_activate(&sca_unit, (sca_state == SCA_STATE_IDLE) ? sca_iwait : sca_cwait);
return SCPE_OK;
}
/*********************************************************************************************
* sca_toggle_timer - toggle a given timer's running/inhibited state for XIO_CONTROL
*********************************************************************************************/
static void sca_toggle_timer (int n, int msec_now)
{
if (sca_timer_state[n] == SCA_TIMER_RUNNING && sca_timer_trigger) {
sca_timer_state[n] = SCA_TIMER_INHIBITED;
sca_timer_timeleft[n] = sca_timer_endtime[n] - msec_now; /* save time left */
#if (DEBUG_SCA & DEBUG_SCA_TIMERS)
printf("+ SCA_TIMER %d inhibited\n", n);
#endif
}
else if (sca_timer_state[n] == SCA_TIMER_INHIBITED && ! sca_timer_trigger) {
sca_timer_state[n] = SCA_TIMER_RUNNING;
sca_timer_endtime[n] = sca_timer_timeleft[n] + msec_now; /* compute new endtime */
#if (DEBUG_SCA & DEBUG_SCA_TIMERS)
printf("+ SCA_TIMER %d uninhibited\n", n);
#endif
}
}
static void sca_start_timer (int n, int msec_now)
{
sca_timer_state[n] = SCA_TIMER_RUNNING;
sca_timer_endtime[n] = sca_timer_msec[n] + msec_now;
any_timer_running = TRUE;
#if (DEBUG_SCA & DEBUG_SCA_TIMERS)
printf("+ SCA_TIMER %d started\n", n);
#endif
}
static void sca_halt_timer (int n)
{
#if (DEBUG_SCA & DEBUG_SCA_TIMERS)
if (sca_timer_state[n] != SCA_TIMER_INACTIVE)
printf("+ SCA_TIMER %d stopped\n", n);
#endif
sca_timer_state[n] = SCA_TIMER_INACTIVE;
}
/*********************************************************************************************
* sca_start_transmit - initiate transmit mode, from XIO_INITR or XIO_CONTROL (sync mode)
*********************************************************************************************/
void sca_start_transmit (int32 iocc_addr, int32 modify)
{
sca_flush();
sca_nsyns = 0; /* reset SYN suppression */
/* Address bits are used to reset DSW conditions. */
if (modify & 0x40) /* bit 9. If set, reset all conditions */
iocc_addr = 0xD800;
iocc_addr &= 0xD800; /* look at just bits 0, 1, 3 and 4 */
if (iocc_addr) { /* if set, these bits clear DSW conditions */
CLRBIT(sca_dsw, iocc_addr);
CLRBIT(ILSW[1], ILSW_1_SCA); /* and I assume clear the interrupt condition too? (Seems unlikely that INITW would */
} /* be used in an interrupt service routine before SENSE, but who knows?) */
if (! in_send_state()) {
sca_state = SCA_STATE_TURN_SEND; /* begin line turnaround */
}
else {
sca_state = SCA_STATE_SEND1; /* line is */
sca_interrupt(SCA_DSW_WRITE_RESPONSE);
}
SETBIT(sca_dsw, SCA_DSW_BUSY); /* SCA is now busy, in transmit mode */
sim_cancel(&sca_unit);
sim_activate(&sca_unit, sca_cwait); /* start polling frequently */
}
/*********************************************************************************************
* xio_sca - handle SCA XIO command
*********************************************************************************************/
void xio_sca (int32 iocc_addr, int32 func, int32 modify)
{
char msg[80];
int i, msec_now;
switch (func) {
case XIO_READ: /* ***** XIO_READ - store last-received character to memory */
#if (DEBUG_SCA & DEBUG_SCA_XIO_READ)
printf("SCA RD addr %04x mod %02x rcvd_char %02x\n", iocc_addr, modify, rcvd_char);
#endif
if (modify & 0x03) { /* bits 14 and 15 */
#if (DEBUG_SCA & DEBUG_SCA_XIO_READ)
printf("(rd diag)\n");
#endif
/* if either of low two modifier bits is set, reads diagnostic words. whatever that is */
}
else {
WriteW(iocc_addr, rcvd_char << 8); /* always return last received character */
/* note: in read mode, read w/o interrupt (or two reads after an interrupt) causes a check
* so here we have to check the current state and possibly cause an interrupt
* Failure to have read before another arrives (overrun) also causes a check.
*/
if (sca_state == SCA_STATE_RECEIVE2)/* XIO_READ should only be done (and only once) after a character interrupt */
sca_state = SCA_STATE_RECEIVE1; /* assume another character is coming in -- wait for it */
else
sca_interrupt(SCA_DSW_CHECK);
}
break;
case XIO_WRITE: /* ***** XIO_WRITE - transfer character from memory to output shift register */
#if (DEBUG_SCA & DEBUG_SCA_XIO_WRITE)
printf("SCA WRT addr %04x (%04x) mod %02x\n", iocc_addr, M[iocc_addr & mem_mask], modify);
#endif
if (modify & 0x01) { /* bit 15 */
/* clear audible alarm trigger */
#if (DEBUG_SCA & DEBUG_SCA_XIO_WRITE)
printf("(clr audible alarm trigger)\n");
#endif
}
/* else? or can they all operate in parallel? */
if (modify & 0x02) { /* bit 14 */
/* set audible alarm trigger */
#if (DEBUG_SCA & DEBUG_SCA_XIO_WRITE)
printf("(set audible alarm trigger)\n");
#endif
}
/* else? */
if (modify & 0x04) { /* bit 13 */
#if (DEBUG_SCA & DEBUG_SCA_XIO_WRITE)
printf("(set SYN)\n");
#endif
/* set sync/idle character */
sichar = (uint8) (ReadW(iocc_addr) >> 8);
sca_nsyns = 0; /* reset SYN suppression */
}
/* else? does presence of mod bit preclude sending a character? */
if ((modify & 0x07) == 0) { /* no modifiers */
/* transmit character --
* note: in write mode, failure to write soon enough after a write response interrupt causes a check
* Also, writing w/o interrupt (or two writes after an interrupt) causes a check
* so again, here we have to check the state to be sure that a write is appropriate
*
* note that in this simulator, we transmit the character immediately on XIO_WRITE. Therefore,
* there is no need to delay an end-operation function (XIO_CONTROL bit 13) until after a character time
*/
idles_since_last_write = 0;
switch (sca_state) {
case SCA_STATE_SEND_SYNC:
case SCA_STATE_SEND1:
sca_transmit_byte((uint8) (M[iocc_addr & mem_mask] >> 8));
sca_state = SCA_STATE_SEND2;
sim_cancel(&sca_unit);
sim_activate(&sca_unit, sca_cwait); /* schedule service after character write time */
break;
case SCA_STATE_SEND2:
sca_interrupt(SCA_DSW_CHECK); /* write issued while a character is in progress out? write overrun */
break;
case SCA_STATE_IDLE: /* wrong time to issue a write, incorrect sca state */
default:
sca_flush();
sca_interrupt(SCA_DSW_CHECK); /* ??? or does this just perform a line turnaround and start transmission? */
break;
}
}
break;
case XIO_CONTROL: /* ***** XIO_CONTROL - manipulate interface state */
#if (DEBUG_SCA & DEBUG_SCA_XIO_CONTROL)
printf("SCA CTL addr %04x mod %02x\n", iocc_addr, modify);
#endif
if (modify & 0x80) { /* bit 8 */
/* enable auto answer */
#if (DEBUG_SCA & DEBUG_SCA_XIO_CONTROL)
printf("(enable autoanswer)\n");
#endif
SETBIT(sca_unit.flags, UNIT_AUTOANSWER);
SETBIT(sca_dsw, SCA_DSW_AUTOANSWER_ENABLED);
}
if (modify & 0x40) { /* bit 9 */
/* disable auto answer */
#if (DEBUG_SCA & DEBUG_SCA_XIO_CONTROL)
printf("(disable autoanswer)\n");
#endif
CLRBIT(sca_unit.flags, UNIT_AUTOANSWER);
CLRBIT(sca_dsw, SCA_DSW_AUTOANSWER_ENABLED);
}
if (modify & 0x20) { /* bit 10 */
/* toggle timers, inhibit->run or run->inhibit */
#if (DEBUG_SCA & (DEBUG_SCA_XIO_CONTROL|DEBUG_SCA_TIMERS))
printf("(toggle timers)\n");
#endif
msec_now = sim_os_msec();
if (in_bsc_mode())
sca_timer_trigger = ! sca_timer_trigger; /* toggle the timer trigger */
if (sca_timer_trigger) /* if we've just set it, we're stopping the other timers and */
sca_start_timer(TIMER_035S, msec_now); /* starting the 0.35 sec timer */
else
sca_halt_timer(TIMER_035S);
sca_toggle_timer(TIMER_3S, msec_now); /* toggle the 3 sec and 1.35 sec timers accordingly */
sca_toggle_timer(TIMER_125S, msec_now);
any_timer_running = (sca_timer_state[0]| sca_timer_state[1] | sca_timer_state[2]) & SCA_TIMER_RUNNING;
}
if (modify & 0x10) { /* bit 11 */
/* enable sync mode. See references to this in FC manual
* In STR mode only, sends a constant stream of SYN's without any CPU intervention
* In BSC mode, appears to start the 1.25 second timer and otherwise act like INITW?
*/
#if (DEBUG_SCA & DEBUG_SCA_XIO_CONTROL)
printf("(enable sync mode)\n");
#endif
if (in_bsc_mode()) { /* in bsc mode start the 1.25 second timer. not sure what resets it?!? */
if (! in_send_state()) /* also may cause a line turnaround */
sca_start_transmit(iocc_addr, 0);
sca_start_timer(TIMER_125S, sim_os_msec());
}
}
if (modify & 0x08) { /* bit 12 */
/* diagnostic mode. What does this do?!? */
#if (DEBUG_SCA & DEBUG_SCA_XIO_CONTROL)
printf("(diag mode)\n");
#endif
}
if (modify & 0x04) { /* bit 13 */
/* end operation (reset adapter. See references to this in FC manual). In transmit mode the real adapter delays this
* function until current character has been sent. We don't need to do that as the character got buffered for transmission
* immediately on XIO_WRITE.
*/
#if (DEBUG_SCA & (DEBUG_SCA_XIO_CONTROL|DEBUG_SCA_XIO_INITR|DEBUG_SCA_XIO_INITW))
printf("(end operation)\n");
#endif
sca_state = SCA_STATE_IDLE;
sca_timer_state[0] = sca_timer_state[1] = sca_timer_state[2] = SCA_TIMER_INACTIVE;
any_timer_running = FALSE;
sca_timer_trigger = FALSE;
sca_nsyns = 0; /* reset SYN suppression */
CLRBIT(sca_dsw, SCA_DSW_BUSY);
}
if (modify & 0x02) { /* bit 14 */
#if (DEBUG_SCA & DEBUG_SCA_XIO_CONTROL)
printf("(6 bit frame)\n");
#endif
/* set six bit character frame. This is reset to 8 bits at every line turnaround */
sca_frame = 6;
}
if (modify & 0x01) { /* bit 15 */
#if (DEBUG_SCA & DEBUG_SCA_XIO_CONTROL)
printf("(7 bit frame)\n");
#endif
/* set seven bit character frame. This is reset to 8 bits at every line turnaround */
sca_frame = 7;
}
sca_flush();
break;
case XIO_INITW: /* ***** XIO_INITW - put SCA in transmit mode */
#if (DEBUG_SCA & DEBUG_SCA_XIO_INITW)
printf("SCA INITW addr %04x mod %02x\n", iocc_addr, modify);
#endif
/* enter transmit mode. Causes line turnaround. Resets frame to 8 bits. */
/* (may cause syncing, may involve a fixed timeout?) */
sca_frame = 8;
sca_start_transmit(iocc_addr, modify); /* this code pulled out to a subroutine cuz transmit can be started from XIO_CONTROL too */
break;
case XIO_INITR: /* ***** XIO_INITR - put SCA in receive mode */
#if (DEBUG_SCA & DEBUG_SCA_XIO_INITR)
printf("SCA INITR addr %04x mod %02x\n", iocc_addr, modify);
#endif
sca_flush();
sca_nrcvd = sca_rcvptr = 0; /* discard any data previously read! */
sca_nsyns = 0; /* reset SYN suppression */
/* enter receive mode. Causes line turnaround (e.g. resets to 8 bit frame). Modifier bits are used here too */
/* (may cause syncing, may involve a fixed timeout?) */
sca_frame = 8;
if (! in_receive_state())
sca_state = SCA_STATE_TURN_RECEIVE; /* begin line turnaround */
else
sca_state = SCA_STATE_RECEIVE_SYNC;
SETBIT(sca_dsw, SCA_DSW_BUSY); /* SCA is now busy, in receive mode */
if (in_bsc_mode()) /* in BSC mode, start the 3 second timer when we enter receive mode */
sca_start_timer(TIMER_3S, sim_os_msec());
break;
case XIO_SENSE_DEV: /* ***** XIO_SENSE_DEV - read device status word */
#if (DEBUG_SCA & DEBUG_SCA_XIO_SENSE_DEV)
printf("SCA SNS mod %02x dsw %04x\n", modify, sca_dsw);
#endif
ACC = sca_dsw; /* return DSW in accumulator */
if (modify & 0x01) { /* bit 15: reset interrupts */
#if (DEBUG_SCA & DEBUG_SCA_XIO_SENSE_DEV)
printf("(reset interrupts)\n");
#endif
CLRBIT(sca_dsw, SCA_DSW_READ_RESPONSE | SCA_DSW_WRITE_RESPONSE | SCA_DSW_CHECK | SCA_DSW_TIMEOUT | SCA_DSW_AUTOANSWER_REQUEST);
CLRBIT(ILSW[1], ILSW_1_SCA);
}
if (modify & 0x02) { /* bit 14: restart running timers */
#if (DEBUG_SCA & (DEBUG_SCA_XIO_SENSE_DEV|DEBUG_SCA_TIMERS))
printf("(restart timers)\n");
#endif
msec_now = sim_os_msec(); /* restart "any running timer?" All three, really? */
for (i = 0; i < 3; i++)
if (sca_timer_state[i] == SCA_TIMER_RUNNING || sca_timer_state[i] == SCA_TIMER_TIMEDOUT)
sca_start_timer(i, msec_now);
}
break;
default:
sprintf(msg, "Invalid SCA XIO function %x", func);
xio_error(msg);
}
}