Ibm1130/ibm1130_sca.c

/* 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);
	}
}