From bbaabbd16842078effc42f1bf9e92790b4180ae8 Mon Sep 17 00:00:00 2001 From: AZBevier Date: Thu, 1 Apr 2021 20:40:55 -0700 Subject: [PATCH] SEL32: Update sel32_com.c for telnet support in UTX and MPX. SEL32: Correct DIB functions to return t_stat instead if UINT16. SEL32: DO more code cleanup. --- SEL32/sel32_chan.c | 100 +-- SEL32/sel32_com.c | 1248 ++++++++++++++++++++++++------------- SEL32/sel32_con.c | 122 ++-- SEL32/sel32_cpu.c | 78 ++- SEL32/sel32_defs.h | 16 +- SEL32/sel32_disk.c | 52 +- SEL32/sel32_ec.c | 42 +- SEL32/sel32_hsdp.c | 54 +- SEL32/sel32_iop.c | 28 +- SEL32/sel32_lpr.c | 28 +- SEL32/sel32_mfp.c | 28 +- SEL32/sel32_mt.c | 44 +- SEL32/sel32_scfi.c | 52 +- SEL32/sel32_scsi.c | 46 +- SEL32/taptools/tap2disk.c | 234 +++++++ 15 files changed, 1445 insertions(+), 727 deletions(-) create mode 100644 SEL32/taptools/tap2disk.c diff --git a/SEL32/sel32_chan.c b/SEL32/sel32_chan.c index 0932223..61137a0 100644 --- a/SEL32/sel32_chan.c +++ b/SEL32/sel32_chan.c @@ -547,11 +547,13 @@ int32 load_ccw(CHANP *chp, int32 tic_ok) int32 docmd = 0; DIB *dibp = dib_unit[chp->chan_dev]; /* get the DIB pointer */ UNIT *uptr = chp->unitptr; /* get the unit ptr */ - uint16 chan = get_chan(chp->chan_dev); /* our channel */ + uint16 chan = get_chan(chp->chan_dev); /* our channel */ + uint16 chsa = chp->chan_dev; /* our chan/sa */ uint16 devstat = 0; sim_debug(DEBUG_XIO, &cpu_dev, - "load_ccw @%06x entry chan_status[%04x] %04x\n", chp->chan_caw, chan, chp->chan_status); + "load_ccw @%06x entry chan_status[%04x] %04x\n", + chp->chan_caw, chan, chp->chan_status); /* determine if channel DIB has a pre iocl processor */ if (dibp->iocl_io != NULL) { /* NULL if no function */ /* call the device controller to process the iocl */ @@ -710,8 +712,8 @@ loop: chp->chan_byte = BUFF_BUSY; /* busy & no bytes transferred yet */ sim_debug(DEBUG_XIO, &cpu_dev, - "load_ccw @%06x read docmd %01x addr %06x count %04x chan %04x ccw_flags %04x\n", - chp->chan_caw, docmd, chp->ccw_addr, chp->ccw_count, chan, chp->ccw_flags); + "load_ccw @%06x read docmd %01x addr %06x count %04x chsa %04x ccw_flags %04x\n", + chp->chan_caw, docmd, chp->ccw_addr, chp->ccw_count, chsa, chp->ccw_flags); if (docmd) { /* see if we need to process a command */ DIB *dibp = dib_unit[chp->chan_dev]; /* get the DIB pointer */ @@ -723,8 +725,8 @@ loop: } sim_debug(DEBUG_XIO, &cpu_dev, - "load_ccw @%06x before start_cmd chan %04x status %04x count %04x SNS %08x\n", - chp->chan_caw, chan, chp->chan_status, chp->ccw_count, uptr->u5); + "load_ccw @%06x before start_cmd chsa %04x status %04x count %04x SNS %08x\n", + chp->chan_caw, chsa, chp->chan_status, chp->ccw_count, uptr->u5); /* call the device startcmd function to process the current command */ /* just replace device status bits */ @@ -734,8 +736,8 @@ loop: chp->chan_info &= ~INFO_SIOCD; /* not first IOCD in channel prog */ sim_debug(DEBUG_XIO, &cpu_dev, - "load_ccw @%06x after start_cmd chan %04x status %08x count %04x\n", - chp->chan_caw, chan, chp->chan_status, chp->ccw_count); + "load_ccw @%06x after start_cmd chsa %04x status %08x count %04x\n", + chp->chan_caw, chsa, chp->chan_status, chp->ccw_count); /* see if bad status */ if (chp->chan_status & (STATUS_ATTN|STATUS_ERROR)) { @@ -774,8 +776,8 @@ loop: /* the device processor returned OK (0), so wait for I/O to complete */ /* nothing happening, so return */ sim_debug(DEBUG_XIO, &cpu_dev, - "load_ccw @%06x return, chan %04x status %04x count %04x irq_pend %1x\n", - chp->chan_caw, chan, chp->chan_status, chp->ccw_count, irq_pend); + "load_ccw @%06x return, chsa %04x status %04x count %04x irq_pend %1x\n", + chp->chan_caw, chsa, chp->chan_status, chp->ccw_count, irq_pend); return 0; /* good return */ } @@ -808,7 +810,7 @@ int chan_read_byte(uint16 chsa, uint8 *data) chp->ccw_count, chp->ccw_addr, chsa); return 1; /* return error */ } - sim_debug(DEBUG_EXP, &cpu_dev, + sim_debug(DEBUG_DETAIL, &cpu_dev, "chan_read_byte with DC IOCD loaded, cnt %04x addr %06x chsa %04x\n", chp->ccw_count, chp->ccw_addr, chsa); } @@ -856,9 +858,9 @@ int chan_write_byte(uint16 chsa, uint8 *data) /* see if at end of buffer */ if (chp->chan_byte == BUFF_CHNEND) { /* check for end of data */ - sim_debug(DEBUG_EXP, &cpu_dev, - "chan_write_byte BUFF_CHNEND ccw_flags %04x addr %06x cnt %04x\n", - chp->ccw_flags, chp->ccw_addr, chp->ccw_count); +// sim_debug(DEBUG_EXP, &cpu_dev, +// "chan_write_byte BUFF_CHNEND ccw_flags %04x addr %06x cnt %04x\n", +// chp->ccw_flags, chp->ccw_addr, chp->ccw_count); /* if SLI not set, we have incorrect length */ if ((chp->ccw_flags & FLAG_SLI) == 0) { sim_debug(DEBUG_EXP, &cpu_dev, "chan_write_byte 4 setting SLI ret\n"); @@ -867,18 +869,18 @@ int chan_write_byte(uint16 chsa, uint8 *data) return 1; /* return error */ } if (chp->ccw_count == 0) { - sim_debug(DEBUG_EXP, &cpu_dev, - "chan_write_byte ZERO chan %04x ccw_count %04x addr %06x\n", - chan, chp->ccw_count, chp->ccw_addr); +// sim_debug(DEBUG_EXP, &cpu_dev, +// "chan_write_byte ZERO chan %04x ccw_count %04x addr %06x\n", +// chan, chp->ccw_count, chp->ccw_addr); if ((chp->ccw_flags & FLAG_DC) == 0) { /* see if we have data chaining */ sim_debug(DEBUG_EXP, &cpu_dev, "chan_write_byte no DC ccw_flags %04x\n", chp->ccw_flags); chp->chan_status |= STATUS_CEND; /* no, end of data */ chp->chan_byte = BUFF_CHNEND; /* thats all the data we want */ - sim_debug(DEBUG_EXP, &cpu_dev, - "chan_write_byte BUFF_CHNEND chp %p chan_byte %04x\n", - chp, chp->chan_byte); +// sim_debug(DEBUG_EXP, &cpu_dev, +// "chan_write_byte BUFF_CHNEND chp %p chan_byte %04x\n", +// chp, chp->chan_byte); return 1; /* return done error */ } else { /* we have data chaining, process iocl */ @@ -888,9 +890,9 @@ int chan_write_byte(uint16 chsa, uint8 *data) chp->ccw_count, chp->ccw_addr, chan); return 1; /* return error */ } - sim_debug(DEBUG_EXP, &cpu_dev, - "chan_write_byte with DC IOCD loaded cnt %04x addr %06x chan %04x\n", - chp->ccw_count, chp->ccw_addr, chan); +// sim_debug(DEBUG_EXP, &cpu_dev, +// "chan_write_byte with DC IOCD loaded cnt %04x addr %06x chan %04x\n", +// chp->ccw_count, chp->ccw_addr, chan); } } /* we have data byte to write to chp->ccw_addr */ @@ -898,14 +900,14 @@ int chan_write_byte(uint16 chsa, uint8 *data) if (chp->ccw_flags & FLAG_SKIP) { chp->ccw_count--; /* decrement skip count */ chp->chan_byte = BUFF_BUSY; /* busy, but no data */ - sim_debug(DEBUG_EXP, &cpu_dev, - "chan_write_byte1 BUFF_BUSY chp %p chan_byte %04x\n", chp, chp->chan_byte); +// sim_debug(DEBUG_EXP, &cpu_dev, +// "chan_write_byte1 BUFF_BUSY chp %p chan_byte %04x\n", chp, chp->chan_byte); if ((chp->ccw_cmd & 0xff) == CMD_RDBWD) chp->ccw_addr--; /* backward */ else chp->ccw_addr++; /* forward */ - sim_debug(DEBUG_EXP, &cpu_dev, "chan_write_byte SKIP ret addr %08x cnt %04x\n", - chp->ccw_addr, chp->ccw_count); +// sim_debug(DEBUG_EXP, &cpu_dev, "chan_write_byte SKIP ret addr %08x cnt %04x\n", +// chp->ccw_addr, chp->ccw_count); return 0; } chp->chan_buf = *data; /* get data byte */ @@ -914,8 +916,8 @@ int chan_write_byte(uint16 chsa, uint8 *data) chp->ccw_count--; /* reduce count */ chp->chan_byte = BUFF_BUSY; /* busy, but no data */ - sim_debug(DEBUG_DETAIL, &cpu_dev, - "chan_write_byte2 BUFF_BUSY chp %p chan_byte %04x\n", chp, chp->chan_byte); +// sim_debug(DEBUG_DETAIL, &cpu_dev, +// "chan_write_byte2 BUFF_BUSY chp %p chan_byte %04x\n", chp, chp->chan_byte); if ((chp->ccw_cmd & 0xff) == CMD_RDBWD) /* see if reading backwards */ chp->ccw_addr -= 1; /* no, use previous address */ else @@ -947,7 +949,7 @@ void set_devattn(uint16 chsa, uint16 flags) /* can not do anything, so just return */ sim_debug(DEBUG_EXP, &cpu_dev, "set_devattn chsa %04x, flags %04x\n", chsa, flags); fprintf(stdout, "set_devattn chsa %04x invalid configured device\n", chsa); - fflush(stdout); +// fflush(stdout); return; } @@ -966,6 +968,7 @@ void chan_end(uint16 chsa, uint16 flags) { sim_debug(DEBUG_DETAIL, &cpu_dev, "chan_end entry chsa %04x flags %04x status %04x cmd %02x\n", chsa, flags, chp->chan_status, chp->ccw_cmd); +// fflush(sim_deb); chp->chan_byte = BUFF_BUSY; /* we are empty & still busy now */ chp->chan_status |= STATUS_CEND; /* set channel end */ @@ -1045,6 +1048,9 @@ void chan_end(uint16 chsa, uint16 flags) { } else { /* we have channel end and no CC flag, continue channel prog */ UNIT *uptr = chp->unitptr; /* get the unit ptr */ +// DEVICE *dptr = uptr->dptr; /* get device pointer */ +// int unit = uptr - dptr->units; /* get the UNIT number */ +// DIB *dibp = dib_chan[get_chan(chsa)]; /* get the DIB pointer */ DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->u3); int unit = (uptr-dptr->units); /* get the UNIT number */ @@ -1119,8 +1125,8 @@ void chan_end(uint16 chsa, uint16 flags) { } goout: sim_debug(DEBUG_CMD, &cpu_dev, - "chan_end done chsa %04x chp %p status %08x chan_byte %02x\n", - chsa, chp, chp->chan_status, chp->chan_byte); + "chan_end done chsa %04x status %08x chan_byte %02x\n", + chsa, chp->chan_status, chp->chan_byte); /* following statement required for boot to work */ irq_pend = 1; /* flag to test for int condition */ } @@ -1258,7 +1264,6 @@ nothere: dptr = get_dev(uptr); /* pointer to DEVICE structure */ /* is device or unit marked disabled? */ - dptr = get_dev(uptr); if ((dptr->flags & DEV_DIS) || (uptr->flags & UNIT_DIS)) { /* is device/unit disabled? */ /* UTX wants CC1 on "mt offline" call. If not, UTX loops forever */ @@ -2584,6 +2589,13 @@ DEVICE *get_dev(UNIT *uptr) if (uptr->dptr) /* get device pointer from unit */ return uptr->dptr; /* return valid pointer */ +#if 0 + sim_debug(DEBUG_EXP, &cpu_dev, + "get_dev got NULL uptr %p uptr->dptr %p\n", + uptr, uptr->dptr); + fflush(sim_deb); +#endif + /* the device pointer in the unit is not set up, do it now */ /* This should never happen as the pointer is setup in first reset call */ for (i = 0; (dptr = sim_devices[i]) != NULL; i++) { /* do all devices */ @@ -2628,7 +2640,7 @@ t_stat chan_set_devs() { if ((dptr->flags & DEV_DIS) || /* Skip disabled devices */ ((dibp->chan_prg) == NULL)) { /* must have channel info for each device */ chsa = GET_UADDR(uptr->u3); /* ch/sa value */ -//printf("Device %s chsa %04x not set up dibp %p\n", dptr->name, chsa, dibp); +//printf("Device %s chsa %04x not set up dibp %p uptr %p\n", dptr->name, chsa, dibp, uptr); continue; } @@ -2636,8 +2648,8 @@ t_stat chan_set_devs() { /* Check if address is in unit or dev entry */ for (j = 0; j < dptr->numunits; j++) { /* loop through unit entries */ chsa = GET_UADDR(uptr->u3); /* ch/sa value */ -//printf("Setup device %s%d chsa %04x type %02x dibp %p\n", -//dptr->name, j, chsa, GET_TYPE(uptr->flags), dibp); +//printf("Setup device %s%d chsa %04x type %02x dibp %p uptr %p\n", +//dptr->name, j, chsa, GET_TYPE(uptr->flags), dibp, uptr); /* zero some channel data loc's for device */ chp->unitptr = uptr; /* set the unit back pointer */ chp->chan_status = 0; /* clear the channel status */ @@ -2669,13 +2681,13 @@ t_stat chan_set_devs() { } else { /* we have unit 0 of non-IOP/MFP device */ if (dib_unit[chsa] != 0) { -//printf("Channel/Dev %04x already defined\n", chsa); +//printf("Channel/Dev %04x already defined uptr %p\n", chsa, uptr); return SCPE_IERR; /* no, arg error */ } else { /* channel mux, save dib for channel */ /* for now, save any zero dev as chan */ if (chsa) { -//printf("Setting Channel zero unit 0 device %04x dibp %p\n", chsa, dibp); +//printf("Setting Channel zero unit 0 device %04x dibp %p uptr %p\n", chsa, dibp, uptr); dib_unit[chsa] = dibp; /* no, save the dib address */ if (dibp->dev_ini != NULL) /* if there is an init routine, call it now */ dibp->dev_ini(uptr, 1); /* init the channel */ @@ -2737,15 +2749,15 @@ t_stat set_dev_addr(UNIT *uptr, int32 val, CONST char *cptr, void *desc) { return SCPE_IERR; /* no, arg error */ dptr = get_dev(uptr); /* find the device from unit pointer */ if (dptr == NULL) { /* device not found, so error */ - fprintf(stderr, "Set dev no DEVICE cptr %s\r\n", cptr); + fprintf(stderr, "Set dev no DEVICE cptr %s uptr %p\r\n", cptr, uptr); //printf("Set dev no DEVICE ptr %s\r\n", cptr); return SCPE_IERR; /* error */ } -//printf("Set dev DEVICE ptr %s\r\n", cptr); +//printf("Set dev DEVICE ptr %s uptr %p\r\n", cptr, uptr); dibp = (DIB *)dptr->ctxt; /* get dib pointer from device struct */ if (dibp == NULL) { /* we need a DIB */ - fprintf(stderr, "Set dev no DIB ptr %s\r\n", cptr); + fprintf(stderr, "Set dev no DIB ptr %s uptr %p\r\n", cptr, uptr); //printf("Set dev no DIB ptr %s\r\n", cptr); return SCPE_IERR; /* no DIB, so error */ } @@ -2765,7 +2777,7 @@ t_stat set_dev_addr(UNIT *uptr, int32 val, CONST char *cptr, void *desc) { /* loop through all units for this device */ for (i = 0; i < dibp->numunits; i++) { ochsa = GET_UADDR(tuptr->u3); /* get old chsa for this unit */ -//printf("Got old chsa %04x\r\n", ochsa); +//printf("Got unit %x old chsa %04x\r\n", i, ochsa); dib_unit[ochsa] = NULL; /* clear sa dib pointer */ dib_unit[ochsa&0x7f00] = NULL; /* clear the channel dib address */ // if (dptr->flags & DEV_CHAN) { /* Is this a channel device IOP/MFP */ @@ -2777,8 +2789,8 @@ t_stat set_dev_addr(UNIT *uptr, int32 val, CONST char *cptr, void *desc) { chsa = chan | (ochsa & 0xff); /* merge new channel with old sa */ } if (chsa != ochsa) { - fprintf(stderr, "Set new chsa %04x old chsa %04x\r\n", chsa, ochsa); -//printf("Set new chsa %04x old chsa %04x\r\n", chsa, ochsa); + fprintf(stderr, "Set unit %x new chsa %04x old chsa %04x\r\n", i, chsa, ochsa); +//printf("Set unit %x new chsa %04x old chsa %04x\r\n", i, chsa, ochsa); } tuptr->u3 &= ~UNIT_ADDR_MASK; /* clear old chsa for this unit */ tuptr->u3 |= UNIT_ADDR(chsa); /* set new chsa for this unit */ diff --git a/SEL32/sel32_com.c b/SEL32/sel32_com.c index 09f3b40..4799c85 100644 --- a/SEL32/sel32_com.c +++ b/SEL32/sel32_com.c @@ -30,9 +30,9 @@ #if NUM_DEVS_COM > 0 /* Constants */ -#define COM_LINES 8 /* max lines */ -#define COM_LINES_DFLT 8 /* default lines */ +#define COM_LINES 8 /* lines defined */ #define COM_INIT_POLL 8000 +//#define COML_WAIT 500 #define COML_WAIT 500 #define COM_WAIT 500 #define COM_NUMLIN com_desc.lines /* curr # lines */ @@ -52,18 +52,26 @@ #define COMC_RCV 2 /* receive */ #define COMC_END 3 /* end */ +struct _com_data +{ + uint8 incnt; /* char count */ + uint8 ibuff[120]; /* Input line buffer */ +} +com_data[COM_LINES]; + uint8 com_rbuf[COM_LINES]; /* rcv buf */ uint8 com_xbuf[COM_LINES]; /* xmt buf */ -uint8 com_sta[COM_LINES]; /* status */ +uint8 com_stat[COM_LINES]; /* status */ uint32 com_lstat[COM_LINES][2] = { 0 }; /* 8 bytes of line settings status */ uint32 com_tps = 2; /* polls/second */ uint32 com_scan = 0; /* scanner */ uint32 com_slck = 0; /* scanner locked */ -uint32 comc_cmd = COMC_IDLE; /* channel state */ +uint32 comi_cmd = COMC_IDLE; /* channel state */ TMLN com_ldsc[COM_LINES] = { 0 }; /* line descrs */ -TMXR com_desc = { COM_LINES_DFLT, 0, 0, com_ldsc }; /* com descr */ +TMXR com_desc = { COM_LINES, 0, 0, com_ldsc }; /* com descr */ +#define CMD u3 /* Held in u3 is the device command and status */ #define COM_INCH 0x00 /* Initialize channel command */ #define COM_WR 0x01 /* Write terminal */ @@ -75,28 +83,33 @@ TMXR com_desc = { COM_LINES_DFLT, 0, 0, com_ldsc }; /* com descr */ #define COM_RDFC 0x0A /* Read w/flow control */ #define COM_DEFSC 0x0B /* Define special char */ #define COM_WRHFC 0x0D /* Write hardware flow control */ +#define COM_RRDFLOW 0x0E /* Read w/hardware flow control only RTS */ #define COM_RDTR 0x13 /* Reset DTR (ADVR) */ #define COM_SDTR 0x17 /* Set DTR (ADVF) */ #define COM_RRTS 0x1B /* Reset RTS */ #define COM_SRTS 0x1F /* Set RTS */ #define COM_RBRK 0x33 /* Reset BREAK */ #define COM_SBRK 0x37 /* Set BREAK */ -#define COM_RDHFC 0x8E /* Read w/hardware flow control only */ +#define COM_SETFLOW 0x53 /* Set transparent flow control mode */ +#define COM_RDHFC 0x8E /* Read w/hardware flow control only DTR */ #define COM_SACE 0xFF /* Set ACE parameters */ #define COM_MSK 0xFF /* Command mask */ -/* Status held in u3 */ +/* Status held in CMD (u3) */ /* controller/unit address in upper 16 bits */ #define COM_INPUT 0x0100 /* Input ready for unit */ -#define COM_CR 0x0200 /* Output at beginning of line */ -#define COM_REQ 0x0400 /* Request key pressed */ +//#define COM_RDY 0x0200 /* SNS_DSRS */ /* Device is ready */ +#define COM_SCD 0x0400 /* Special char detect */ #define COM_EKO 0x0800 /* Echo input character */ #define COM_OUTPUT 0x1000 /* Output ready for unit */ #define COM_READ 0x2000 /* Read mode selected */ +#define COM_ACC 0x4000 /* ASCII control char detect */ +#define COM_CONN 0x8000 /* TMXR ATT */ /* Terminal connected */ /* ACE data kept in u4 */ /* ACE information in u4 */ +#define ACE u4 #if 0 /* ACE byte 0 Modem Control/Operation status */ /* stored in u4 bytes 0-3 */ @@ -106,12 +119,12 @@ TMXR com_desc = { COM_LINES_DFLT, 0, 0, com_ldsc }; /* com descr */ #define SNS_ACEP 0x10000000 /* Parity 0=odd, 1=even */ #define SNS_ACEPE 0x08000000 /* Parity enable 0=dis, 1=enb */ #define SNS_ACESTOP 0x04000000 /* Stop bit 0=1, 1=1.5 or 2 */ -#define SNS_ACECLEN 0x02000000 /* Character length 00=5, 01=6, 11=7, 11=8 */ +#define SNS_ACECLEN 0x02000000 /* Character length 00=5, 01=6, 10=7, 11=8 */ #define SNS_ACECL2 0x01000000 /* 2nd bit for above */ /* ACE byte 1 Baud rate */ -#define SNS_NUB50 0x00800000 /* Zero N/U */ -#define SNS_NUB51 0x00400000 /* Zero N/U */ +#define SNS_NODCDA 0x00800000 /* Enable Delta DCD Attention Interrupt */ +#define SNS_WAITOLB 0x00400000 /* Wait on last byte enabled */ #define SNS_RINGCR 0x00200000 /* Ring or wakeup character recognition 0=enb, 1=dis */ #define SNS_DIAGL 0x00100000 /* Set diagnostic loopback */ #define SNS_BAUD 0x000F0000 /* Baud rate bits 4-7 */ @@ -137,9 +150,7 @@ TMXR com_desc = { COM_LINES_DFLT, 0, 0, com_ldsc }; /* com descr */ #endif #define ACE_WAKE 0x0000FF00 /* 8 bit wake-up character in byte 2 of ACE */ -/* in u5 packs sense byte 0,1 and 3 */ -/* sense byte 3 */ - +#define SNS u5 /* in u5 packs sense byte 0, 1, 2 and 3 */ /* Sense byte 0 */ #define SNS_CMDREJ 0x80000000 /* Command reject */ @@ -149,7 +160,9 @@ TMXR com_desc = { COM_LINES_DFLT, 0, 0, com_ldsc }; /* com descr */ #define SNS_DATACK 0x08000000 /* Data check */ #define SNS_OVERRN 0x04000000 /* Overrun (N/U) */ #define SNS_NUB01 0x02000000 /* Zero (N/U) */ +#define SNS_RDY SNS_NUB01 /* SNS_RDY device ready */ #define SNS_NUB02 0x01000000 /* Zero (N/U) */ +#define SNS_CONN SNS_NUB02 /* SNS_CONN device connected */ /* Sense byte 1 */ #define SNS_ASCIICD 0x00800000 /* ASCII control char detected interrupt */ #define SNS_SPCLCD 0x00400000 /* Special char detected interrupt */ @@ -160,18 +173,15 @@ TMXR com_desc = { COM_LINES_DFLT, 0, 0, com_ldsc }; /* com descr */ #define SNS_ACEOVR 0x00020000 /* ACE overrun error interrupt */ #define SNS_RING 0x00010000 /* Ring character interrupt */ /* Sense byte 2 Modem status */ -#define SNS_RLSDS 0x00008000 /* Received line signal detect status */ -#define SNS_RINGST 0x00004000 /* Ring indicator line status */ +#define SNS_RLSDS 0x00008000 /* Received line signal detect */ +#define SNS_RINGST 0x00004000 /* Ring indicator signal detect */ #define SNS_DSRS 0x00002000 /* DSR Data set ready line status */ #define SNS_CTSS 0x00001000 /* CTS Clear to send line status */ #define SNS_DELTA 0x00000800 /* Delta receive line signal detect failure interrupt */ #define SNS_MRING 0x00000400 /* RI Modem ring interrupt */ -#define SNS_DELDSR 0x00000200 /* Delta data set ready interrupt */ -#define SNS_DELCLR 0x00000100 /* Ring character interrupt */ +#define SNS_DELDSR 0x00000200 /* DSR failure interrupt */ +#define SNS_DELCTS 0x00000100 /* CLS failure interrupt */ /* Sense byte 3 Modem Control/Operation status */ -#define SNS_RDY 0x80 /* device ready */ -#define SNS_ONLN 0x40 /* device online */ -//#define SNS_DSR 0x04 /* data set ready */ #define SNS_HALFD 0x00000080 /* Half-duplix operation set */ #define SNS_MRINGE 0x00000040 /* Modem ring enabled (1) */ #define SNS_ACEDEF 0x00000020 /* ACE parameters defined */ @@ -190,8 +200,8 @@ TMXR com_desc = { COM_LINES_DFLT, 0, 0, com_ldsc }; /* com descr */ #define SNS_ACECLEN 0x02000000 /* Character length 00=5, 01=6, 11=7, 11=8 */ #define SNS_ACECL2 0x01000000 /* 2nd bit for above */ /* Sense byte 5 Baud rate */ -#define SNS_NUB50 0x00800000 /* Zero N/U */ -#define SNS_NUB51 0x00400000 /* Zero N/U */ +#define SNS_NODCDA 0x00800000 /* Enable Delta DCD Attention Interrupt */ +#define SNS_WAITOLB 0x00400000 /* Wait on last byte enabled */ #define SNS_RINGCR 0x00200000 /* Ring or wakeup character recognition 0=enb, 1=dis */ #define SNS_DIAGL 0x00100000 /* Set diagnostic loopback */ #define SNS_BAUD 0x000F0000 /* Baud rate bits 4-7 */ @@ -217,23 +227,24 @@ TMXR com_desc = { COM_LINES_DFLT, 0, 0, com_ldsc }; /* com descr */ #define SNS_REV 0x0000004f /* ID part 2 plus 4 bit rev # */ /* u6 */ +#define CNT u6 /* forward definitions */ -uint16 com_preio(UNIT *uptr, uint16 chan); -uint16 com_startcmd(UNIT *uptr, uint16 chan, uint8 cmd); -uint16 com_haltio(UNIT *uptr); +t_stat coml_preio(UNIT *uptr, uint16 chan); +t_stat coml_startcmd(UNIT *uptr, uint16 chan, uint8 cmd); +t_stat coml_haltio(UNIT *uptr); void com_ini(UNIT *, t_bool); void coml_ini(UNIT *, t_bool); -uint16 coml_rschnlio(UNIT *uptr); -uint16 com_rschnlio(UNIT *uptr); -t_stat comc_srv(UNIT *uptr); -t_stat como_srv(UNIT *uptr); +t_stat coml_rschnlio(UNIT *uptr); +t_stat com_rschnlio(UNIT *uptr); t_stat comi_srv(UNIT *uptr); +t_stat como_srv(UNIT *uptr); +t_stat comc_srv(UNIT *uptr); t_stat com_reset(DEVICE *dptr); t_stat com_attach(UNIT *uptr, CONST char *cptr); t_stat com_detach(UNIT *uptr); void com_reset_ln(int32 ln); -const char *com_description(DEVICE *dptr); /* device description */ +const char *com_description(DEVICE *dptr); /* device description */ /* COM data structures com_chp COM channel program information @@ -253,37 +264,25 @@ CHANP com_chp[COM_UNITS] = {0}; MTAB com_mod[] = { {MTAB_XTD | MTAB_VUN | MTAB_VALR, 0, "DEV", "DEV", &set_dev_addr, &show_dev_addr, NULL}, {MTAB_XTD | MTAB_VDV, 1, NULL, "DISCONNECT", &tmxr_dscln, NULL, &com_desc}, - {UNIT_ATT, UNIT_ATT, "summary", NULL, NULL, &tmxr_show_summ, (void *) &com_desc}, + {UNIT_ATT, UNIT_ATT, "SUMMARY", NULL, NULL, &tmxr_show_summ, (void *) &com_desc}, {MTAB_XTD | MTAB_VDV | MTAB_NMO, 1, "CONNECTIONS", NULL, NULL, &tmxr_show_cstat,(void *)&com_desc}, {MTAB_XTD | MTAB_VDV | MTAB_NMO, 0, "STATISTICS", NULL, NULL, &tmxr_show_cstat, (void *)&com_desc}, -// {MTAB_XTD|MTAB_VDV, 0, "CHAN", "CHAN", &io_set_dvc, &io_show_dvc, NULL}, -// {MTAB_XTD|MTAB_VDV, 0, "DVA", "DVA", &io_set_dva, &io_show_dva, NULL}, -// {MTAB_XTD | MTAB_VDV, 0, "LINES", "LINES", &com_vlines, &tmxr_show_lines, (void *)&com_desc}, -// {MTAB_XTD|MTAB_VDV|MTAB_NMO, 0, "CSTATE", NULL, NULL, &io_show_cst, NULL}, -// {MTAB_XTD|MTAB_VDV|MTAB_NMO, 1, "POLL", "POLL", &rtc_set_tps, &rtc_show_tps,(void *)&com_tps}, -/// { TT_MODE, TT_MODE_UC, "UC", "UC", NULL }, -/// { TT_MODE, TT_MODE_7B, "7b", "7B", NULL }, -/// { TT_MODE, TT_MODE_8B, "8b", "8B", NULL }, -/// { TT_MODE, TT_MODE_7P, "7p", "7P", NULL }, -/// { MTAB_XTD|MTAB_VUN, 0, NULL, "DISCONNECT", &tmxr_dscln, NULL, &com_desc }, -/// { MTAB_XTD|MTAB_VUN|MTAB_NC, 0, "LOG", "LOG", &tmxr_set_log, &tmxr_show_log, &com_desc }, -/// { MTAB_XTD|MTAB_VUN|MTAB_NC, 0, NULL, "NOLOG", &tmxr_set_nolog, NULL, &com_desc }, { 0 } }; UNIT com_unit[] = { - {UDATA(&comi_srv, UNIT_ATTABLE|UNIT_IDLE, 0), COM_WAIT, UNIT_ADDR(0x0000)}, /* 0 */ + {UDATA(&comc_srv, UNIT_ATTABLE|UNIT_IDLE, 0), COM_WAIT, UNIT_ADDR(0x0000)}, /* 0 */ }; DIB com_dib = { - com_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - com_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - NULL, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - com_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - NULL, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + NULL, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + NULL, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + NULL, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + com_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + NULL, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ com_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ com_unit, /* UNIT* units */ /* Pointer to units structure */ com_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -297,7 +296,7 @@ DIB com_dib = { }; REG com_reg[] = { - { BRDATAD (STA, com_sta, 16, 8, COM_LINES, "status buffers, lines 0 to 7") }, + { BRDATAD (STA, com_stat, 16, 8, COM_LINES, "status buffers, lines 0 to 7") }, { BRDATAD (RBUF, com_rbuf, 16, 8, COM_LINES, "input buffer, lines 0 to 7") }, { BRDATAD (XBUF, com_xbuf, 16, 8, COM_LINES, "output buffer, lines 0 to 7") }, { ORDATAD (SCAN, com_scan, 6, "scanner line number") }, @@ -325,40 +324,43 @@ DEVICE com_dev = { */ /*#define UNIT_COML UNIT_ATTABLE|UNIT_DISABLE|UNIT_IDLE */ -#define UNIT_COML UNIT_IDLE|UNIT_DISABLE +//#define UNIT_COML UNIT_IDLE|UNIT_DISABLE|TT_MODE_UC +//#define UNIT_COML UNIT_IDLE|UNIT_DISABLE|TT_MODE_7P +//#define UNIT_COML UNIT_IDLE|UNIT_DISABLE|TT_MODE_8B +#define UNIT_COML UNIT_IDLE|UNIT_DISABLE|TT_MODE_7B /* channel program information */ CHANP coml_chp[COM_LINES*2] = {0}; UNIT coml_unit[] = { /* 0-7 is input, 8-f is output */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EC0)}, /* 0 */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EC1)}, /* 1 */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EC2)}, /* 2 */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EC3)}, /* 3 */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EC4)}, /* 4 */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EC5)}, /* 5 */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EC6)}, /* 6 */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EC7)}, /* 7 */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EC8)}, /* 8 */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EC9)}, /* 9 */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7ECA)}, /* A */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7ECB)}, /* B */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7ECC)}, /* C */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7ECD)}, /* D */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7ECE)}, /* E */ - {UDATA(&como_srv, TT_MODE_UC|UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7ECF)}, /* F */ + {UDATA(&comi_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EA0)}, /* 0 */ + {UDATA(&comi_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EA1)}, /* 1 */ + {UDATA(&comi_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EA2)}, /* 2 */ + {UDATA(&comi_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EA3)}, /* 3 */ + {UDATA(&comi_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EA4)}, /* 4 */ + {UDATA(&comi_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EA5)}, /* 5 */ + {UDATA(&comi_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EA6)}, /* 6 */ + {UDATA(&comi_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EA7)}, /* 7 */ + {UDATA(&como_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EA8)}, /* 8 */ + {UDATA(&como_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EA9)}, /* 9 */ + {UDATA(&como_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EAA)}, /* A */ + {UDATA(&como_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EAB)}, /* B */ + {UDATA(&como_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EAC)}, /* C */ + {UDATA(&como_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EAD)}, /* D */ + {UDATA(&como_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EAE)}, /* E */ + {UDATA(&como_srv, UNIT_COML, 0), COML_WAIT, UNIT_ADDR(0x7EAF)}, /* F */ }; DIB coml_dib = { - NULL, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - com_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - NULL, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - coml_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - NULL, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + coml_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + coml_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + coml_haltio, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + coml_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + NULL, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ coml_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ coml_unit, /* UNIT* units */ /* Pointer to units structure */ coml_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -366,6 +368,9 @@ DIB coml_dib = { COM_LINES*2, /* uint8 numunits */ /* number of units defined */ 0xff, /* uint8 mask */ /* 16 devices - device mask */ 0x7E00, /* uint16 chan_addr */ /* parent channel address */ + 0, /* uint32 chan_fifo_in */ /* fifo input index */ + 0, /* uint32 chan_fifo_out */ /* fifo output index */ + {0} /* uint32 chan_fifo[FIFO_SIZE] */ /* interrupt status fifo for channel */ }; REG coml_reg[] = { @@ -402,21 +407,22 @@ DEVICE coml_dev = { /* 8-line serial routines */ void coml_ini(UNIT *uptr, t_bool f) { - /* maybe do someting here on master channel init */ - uptr->u5 = SNS_RDY|SNS_ONLN; /* status is online & ready */ - uptr->u3 &= LMASK; /* leave only chsa */ - sim_cancel(uptr); /* stop any timer */ + /* maybe do something here on master channel init */ +// uptr->SNS = 0; /* status is online & ready */ + uptr->SNS = 0x00003003; /* status is online & ready */ + uptr->CMD &= LMASK; /* leave only chsa */ + sim_cancel(uptr); /* stop any timer */ } /* handle rschnlio cmds for coml */ -uint16 coml_rschnlio(UNIT *uptr) { +t_stat coml_rschnlio(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); - uint16 chsa = GET_UADDR(uptr->u3); - int cmd = uptr->u3 & COM_MSK; + uint16 chsa = GET_UADDR(uptr->CMD); + int cmd = uptr->CMD & COM_MSK; sim_debug(DEBUG_EXP, dptr, "coml_rschnl chsa %04x cmd = %02x\n", chsa, cmd); - coml_ini(uptr, 0); /* reset the unit */ + coml_ini(uptr, 0); /* reset the unit */ return SCPE_OK; } @@ -427,80 +433,116 @@ void com_ini(UNIT *uptr, t_bool f) sim_debug(DEBUG_CMD, dptr, "COM init device %s controller 0x7e00\n", dptr->name); - sim_cancel(uptr); /* stop input poll */ - sim_activate(uptr, 1000); /* start input poll */ + sim_cancel(uptr); /* stop input poll */ + sim_activate(uptr, 1000); /* start input poll */ } /* handle rschnlio cmds for com */ -uint16 com_rschnlio(UNIT *uptr) { +t_stat com_rschnlio(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); - uint16 chsa = GET_UADDR(uptr->u3); - int cmd = uptr->u3 & COM_MSK; + uint16 chsa = GET_UADDR(uptr->CMD); + int cmd = uptr->CMD & COM_MSK; sim_debug(DEBUG_EXP, dptr, "com_rschnl chsa %04x cmd = %02x\n", chsa, cmd); - com_ini(uptr, 0); /* reset the unit */ + com_ini(uptr, 0); /* reset the unit */ return SCPE_OK; } /* start a com operation */ -uint16 com_preio(UNIT *uptr, uint16 chan) { +t_stat coml_preio(UNIT *uptr, uint16 chan) { DEVICE *dptr = get_dev(uptr); int unit = (uptr - dptr->units); - uint16 chsa = GET_UADDR(uptr->u3); /* get channel/sub-addr */ -// int cmd = uptr->u3 & 0xff; + uint16 chsa = GET_UADDR(uptr->CMD); /* get channel/sub-addr */ +// int cmd = coml_chp[unit].ccw_cmd; + UNIT *ruptr = &dptr->units[unit&7]; /* read uptr */ + UNIT *wuptr = &dptr->units[(unit&7)+8]; /* write uptr */ -#ifndef WAIT_FOR_TESTING - sim_debug(DEBUG_CMD, dptr, "com_preio CMD %08x unit %02x chsa %04x\n", - uptr->u3, unit, chsa); - if ((uptr->u3 & COM_MSK) != 0) { /* just return if busy */ + sim_debug(DEBUG_CMD, dptr, + "coml_preio CMD %08x unit %02x chsa %04x\n", + uptr->CMD, unit, chsa); + sim_debug(DEBUG_CMD, dptr, + "coml_preio chsa %04x ln %1x conn %x rcve %x xmte %x SNS %08x SNS %08x\n", + chsa, unit, com_ldsc[unit&7].conn, com_ldsc[unit&7].rcve, + com_ldsc[unit&7].xmte, ruptr->SNS, wuptr->SNS); + + if ((uptr->CMD & COM_MSK) != 0) { /* just return if busy */ sim_debug(DEBUG_CMD, dptr, - "com_preio unit %02x chsa %04x BUSY\n", unit, chsa); + "coml_preio unit %02x chsa %04x BUSY\n", unit, chsa); return SNS_BSY; } -#endif - - sim_debug(DEBUG_CMD, dptr, "t_preio unit %02x chsa %04xOK\n", unit, chsa); - return SCPE_OK; /* good to go */ -} - -/* called from sel32_chan to start an I/O operation */ -uint16 com_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) -{ - DEVICE *dptr = get_dev(uptr); - int unit = (uptr - dptr->units); - uint16 chsa = (((uptr->u3 & LMASK) >> 16) | (chan << 8)); - uint8 ch; - - if ((uptr->u3 & COM_MSK) != 0) { /* is unit busy */ - return SNS_BSY; /* yes, return busy */ - } sim_debug(DEBUG_CMD, dptr, - "CMD unit %04x chan %04x cmd %02x\n", unit, chan, cmd); + "coml_preio unit %02x chsa %04x OK\n", unit, chsa); + return SCPE_OK; /* good to go */ +} +/* called from sel32_chan to start an I/O operation */ +t_stat coml_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) +{ + DEVICE *dptr = get_dev(uptr); + int unit = (uptr - dptr->units); +// int unit = (uptr - dptr->units) & 0x7; /* make 0-7 */ + UNIT *ruptr = &dptr->units[unit&7]; /* read uptr */ + UNIT *wuptr = &dptr->units[(unit&7)+8]; /* write uptr */ + uint16 chsa = (((uptr->CMD & LMASK) >> 16) | (chan << 8)); + uint8 ch, fcb[3]; + + if ((uptr->CMD & COM_MSK) != 0) { /* is unit busy */ + return SNS_BSY; /* yes, return busy */ + } + + sim_debug(DEBUG_CMD, dptr, + "coml_startcmd chsa %04x line %1x cmd %02x conn %x rcve %x xmte %x SNS %08x SNS %08x\n", + chsa, unit, cmd, com_ldsc[unit&7].conn, com_ldsc[unit&7].rcve, + com_ldsc[unit&7].xmte, ruptr->SNS, wuptr->SNS); + + uptr->CMD &= LMASK; /* clear any flags that are set */ /* process the commands */ switch (cmd & 0xFF) { - case COM_INCH: /* 00 */ /* INCH command */ - sim_debug(DEBUG_CMD, dptr, "com_startcmd %04x: CMD INCH\n", chan); - uptr->u3 &= LMASK; /* leave only chsa */ - uptr->u3 |= (0x7f & COM_MSK); /* save 0x7f as INCH cmd command */ - uptr->u5 = SNS_RDY|SNS_ONLN; /* status is online & ready */ - sim_activate(uptr, 20); /* start us up */ + case COM_INCH: /* 00 */ /* INCH command */ + sim_debug(DEBUG_CMD, dptr, "coml_startcmd chsa %04x: CMD INCH\n", chsa); + uptr->CMD &= LMASK; /* leave only chsa */ + uptr->CMD |= (0x7f & COM_MSK); /* save 0x7f as INCH cmd command */ + uptr->SNS |= SNS_RDY; /* status is online & ready */ + sim_activate(uptr, 200); /* start us up */ break; /* write commands must use address 8-f */ - case COM_WR: /* 0x01 */ /* Write command */ - case COM_WRSCM: /* 0x05 */ /* Write w/sub channel monitor */ - case COM_WRHFC: /* 0x0D */ /* Write w/hardware flow control */ + case COM_WR: /* 0x01 */ /* Write command */ + case COM_WRSCM: /* 0x05 */ /* Write w/ input sub channel monitor */ + case COM_WRHFC: /* 0x0D */ /* Write w/hardware flow control only */ sim_debug(DEBUG_CMD, dptr, - "com_startcmd %04x: Cmd WRITE %02x\n", chan, cmd); + "coml_startcmd chsa %04x: Cmd WRITE %02x\n", chsa, cmd); - uptr->u3 &= LMASK; /* leave only chsa */ - uptr->u3 |= (cmd & COM_MSK); /* save command */ - uptr->u5 = SNS_RDY|SNS_ONLN; /* status is online & ready */ - sim_activate(uptr, 150); /* TRY 08-13-18 */ - return 0; /* no status change */ + /* see if DSR is set, if not give unit check error */ + if (((ruptr->SNS & SNS_DSRS) == 0)|| ((ruptr->SNS & SNS_CONN) == 0)) { +//jj if (!((ruptr->SNS & SNS_DSRS) || (ruptr->SNS & SNS_CONN))) { +//YY if ((com_ldsc[unit&7].conn == 0) || +//YY !((ruptr->SNS & SNS_DSRS) || (ruptr->SNS & SNS_CONN))) { +//XX if (com_ldsc[unit&7].conn == 0) { +//JJ ruptr->SNS &= ~SNS_DSRS; /* status is not ready */ +//JJ wuptr->SNS &= ~SNS_DSRS; /* status is not ready */ +//M ruptr->SNS &= ~SNS_CONN; /* status is not ready */ +//M wuptr->SNS &= ~SNS_CONN; /* status is not ready */ + ruptr->SNS &= ~SNS_RDY; /* status is not ready */ + wuptr->SNS &= ~SNS_RDY; /* status is not ready */ + ruptr->SNS |= SNS_CMDREJ; /* command reject */ + wuptr->SNS |= SNS_CMDREJ; /* command reject */ + /* SNS_DSRS will be 0 */ +///*UTX*/ ruptr->SNS |= SNS_DELDSR; /* set attention status */ +///*UTX*/ wuptr->SNS |= SNS_DELDSR; /* set attention status */ +/*MPX*/ ruptr->SNS |= SNS_DELTA; /* set attention status */ +/*MPX*/ wuptr->SNS |= SNS_DELTA; /* set attention status */ + sim_debug(DEBUG_CMD, dptr, + "coml_startcmd chsa %04x: Cmd WRITE %02x unit check\n", chsa, cmd); + return SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK; /* good return */ + } + uptr->CMD &= LMASK; /* leave only chsa */ + uptr->CMD |= (cmd & COM_MSK); /* save command */ + uptr->SNS |= SNS_RDY; /* status is online & ready */ + sim_activate(uptr, 150); /* TRY 08-13-18 */ + return 0; /* no status change */ break; /* read commands must use address 0-7 */ @@ -509,130 +551,207 @@ uint16 com_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) /* bit 1 A=1 ASCII control character detect (7-char mode only) */ /* bit 2 S=1 Special character detect (7-char mode only) */ /* bit 3 P=1 Purge input buffer */ - case COM_RD: /* 0x02 */ /* Read command */ - case COM_RDECHO: /* 0x06 */ /* Read command w/ECHO */ - case 0x32: /* 0x32 */ /* Read command ASCII & Purge input */ - case 0x46: /* 0x46 */ /* Read command w/ECHO & ASCII */ - case 0x56: /* 0x56 */ /* Read command w/ECHO & ASCII & Purge input */ + case COM_RD: /* 0x02 */ /* Read command */ + case 0x22: /* 0x22 */ /* Read command w/ASCII CC */ + case 0x32: /* 0x32 */ /* Read command w/ASCII CC & Purge input */ + case COM_RDECHO: /* 0x06 */ /* Read command w/ECHO */ + case 0x46: /* 0x46 */ /* Read command w/ECHO & ASCII CC*/ + case 0x56: /* 0x56 */ /* Read command w/ECHO & ASCII CC & Purge input */ /* if bit 0 set for COM_RDFC, use DTR for flow, else use RTS for flow control */ - case COM_RDFC: /* 0x0A */ /* Read command w/flow control */ - case COM_RDHFC: /* 0x8E */ /* Read command w/hardware flow control only */ - sim_debug(DEBUG_CMD, dptr, "com_startcmd %04x: Cmd read\n", chan); - uptr->u3 &= LMASK; /* leave only chsa */ - uptr->u3 |= (cmd & COM_MSK); /* save command */ - if ((cmd & 0x06) == COM_RDECHO) /* echo command? */ - uptr->u3 |= COM_EKO; /* save echo status */ - uptr->u3 |= COM_READ; /* show read mode */ - uptr->u5 = SNS_RDY|SNS_ONLN; /* status is online & ready */ + case COM_RDFC: /* 0x0A */ /* Read command w/flow control */ + case COM_RDHFC: /* 0x8E */ /* Read command w/hardware flow control only */ + + /* see if DSR is set, if not give unit check error */ + if (((ruptr->SNS & SNS_DSRS) == 0)|| ((ruptr->SNS & SNS_CONN) == 0)) { +//jj if (!((ruptr->SNS & SNS_DSRS) || (ruptr->SNS & SNS_CONN))) { +//YY if ((com_ldsc[unit&7].conn == 0) || +//YY !((ruptr->SNS & SNS_DSRS) || (ruptr->SNS & SNS_CONN))) { +//XX if (com_ldsc[unit&7].conn == 0) { +//M ruptr->SNS &= ~SNS_DSRS; /* status is not ready */ +//M wuptr->SNS &= ~SNS_DSRS; /* status is not ready */ +//M ruptr->SNS &= ~SNS_CONN; /* status is not ready */ +//M wuptr->SNS &= ~SNS_CONN; /* status is not ready */ + ruptr->SNS &= ~SNS_RDY; /* status is not ready */ + wuptr->SNS &= ~SNS_RDY; /* status is not ready */ + ruptr->SNS |= SNS_CMDREJ; /* command reject */ + wuptr->SNS |= SNS_CMDREJ; /* command reject */ + /* SNS_DSRS will be 0 */ +/*UTX*/ ruptr->SNS |= SNS_DELDSR; /* set attention status */ +/*UTX*/ wuptr->SNS |= SNS_DELDSR; /* set attention status */ +/*MPX*/ ruptr->SNS |= SNS_DELTA; /* set attention status */ +/*MPX*/ wuptr->SNS |= SNS_DELTA; /* set attention status */ + sim_debug(DEBUG_CMD, dptr, + "coml_startcmd chsa %04x: Cmd READ %02x unit check\n", chsa, cmd); + return SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK; /* good return */ + } + unit &= 0x7; /* make unit 0-7 */ + uptr->CMD &= ~COM_EKO; /* clear echo status */ + sim_debug(DEBUG_CMD, dptr, "coml_startcmd chsa %04x: Cmd read\n", chsa); + uptr->CMD &= LMASK; /* leave only chsa */ + uptr->CMD |= (cmd & COM_MSK); /* save command */ + if ((cmd & 0x0f) == COM_RDECHO) /* echo command? */ + uptr->CMD |= COM_EKO; /* save echo status */ + if (cmd & 0x10) { /* purge input request? */ + uptr->CNT = 0; /* no input count */ + com_data[unit].incnt = 0; /* no input data */ + com_rbuf[unit&7] = 0; /* clear read buffer */ + } + uptr->CMD |= COM_READ; /* show read mode */ + uptr->SNS |= SNS_RDY; /* status is online & ready */ sim_debug(DEBUG_CMD, dptr, - "com_startcmd %04x: input cnt = %04x\n", - chan, coml_chp[unit].ccw_count); + "coml_startcmd chsa %04x: input cnt = %04x\n", + chsa, coml_chp[unit].ccw_count); + sim_activate(uptr, 150); /* TRY 08-13-18 */ return 0; break; - case COM_NOP: /* 0x03 */ /* NOP has do nothing */ + case COM_NOP: /* 0x03 */ /* NOP has do nothing */ sim_debug(DEBUG_CMD, dptr, - "com_startcmd %04x: Cmd %02x NOP\n", chan, cmd); - uptr->u5 = SNS_RDY|SNS_ONLN; /* status is online & ready */ - uptr->u3 &= LMASK; /* leave only chsa */ - uptr->u3 |= (cmd & COM_MSK); /* save command */ - sim_activate(uptr, 20); /* start us up */ + "coml_startcmd chsa %04x: Cmd %02x NOP\n", chsa, cmd); + uptr->SNS |= SNS_RDY; /* status is online & ready */ + uptr->CMD &= LMASK; /* leave only chsa */ + uptr->CMD |= (cmd & COM_MSK); /* save command */ + sim_activate(uptr, 200); /* start us up */ break; - case COM_SNS: /* 0x04 */ /* Sense (8 bytes) */ - com_lstat[unit][0] = 0; /* Clear status wd 0 */ - com_lstat[unit][1] = 0; /* Clear status wd 1 */ - /* value 4 is Data Set Ready */ - /* value 5 is Data carrier detected n/u */ - sim_debug(DEBUG_CMD, dptr, - "com_startcmd %04x: unit %04x Cmd Sense %02x\n", - chan, unit, uptr->u5); - - ch = (com_lstat[unit][0] >> 24) & 0xff; - chan_write_byte(GET_UADDR(uptr->u3), &ch); /* write status */ - - com_lstat[unit][0] |= (SNS_RING); /* set char detect status */ - com_lstat[unit][0] |= (SNS_ASCIICD); /* set char detect status */ - ch = (com_lstat[unit][0] >> 16) & 0xff; - chan_write_byte(GET_UADDR(uptr->u3), &ch); /* write status */ - - com_lstat[unit][0] |= (SNS_CTSS|SNS_DSRS); /* set CTS & DSR status */ - com_lstat[unit][0] |= (SNS_MRING); /* set char detect status */ - ch = (com_lstat[unit][0] >> 8) & 0xff; - chan_write_byte(GET_UADDR(uptr->u3), &ch); /* write status */ - - com_lstat[unit][0] |= (SNS_DTR); /* set DTR status */ - ch = (com_lstat[unit][0] >> 0) & 0xff; - chan_write_byte(GET_UADDR(uptr->u3), &ch); /* write status */ - - ch = (com_lstat[unit][1] >> 24) & 0xff; - chan_write_byte(GET_UADDR(uptr->u3), &ch); /* write status */ - - ch = (com_lstat[unit][1] >> 16) & 0xff; - chan_write_byte(GET_UADDR(uptr->u3), &ch); /* write status */ - - ch = (com_lstat[unit][1] >> 8) & 0xff; - chan_write_byte(GET_UADDR(uptr->u3), &ch); /* write status */ - - ch = (com_lstat[unit][1] >> 0) & 0xff; - chan_write_byte(GET_UADDR(uptr->u3), &ch); /* write status */ + case COM_SNS: /* 0x04 */ /* Sense (8 bytes) */ + unit &= 0x7; /* make unit 0-7 */ + com_lstat[unit][0] = 0; /* Clear status wd 0 */ + com_lstat[unit][1] = 0; /* Clear status wd 1 */ + /* status is in SNS (u5) */ + /* ACE is in ACE (u4) */ +///*MPX*/ uptr->SNS = 0x03813401; sim_debug(DEBUG_CMD, dptr, - "com_startcmd Cmd SENSE return chan %04x u5-status %04x ls0 %08x ls1 %08x\n", - chan, uptr->u5, com_lstat[unit][0], com_lstat[unit][1]); - return SNS_CHNEND|SNS_DEVEND; /* good return */ + "coml_startcmd SENSE chsa %04x: unit %02x Cmd Sense SNS %08x ACE %08x\n", + chsa, unit, uptr->SNS, uptr->ACE); + + /* byte 0 device status */ + ch = (uptr->SNS >> 24) & 0xff; /* no bits in byte 0 */ +// ch = (com_lstat[unit][0] >> 24) & 0xff; + chan_write_byte(chsa, &ch); /* write status */ + + /* byte 1 line status and error conditions */ + ch = (uptr->SNS >> 16) & 0xff; /* no bits in byte 1 */ +// com_lstat[unit][0] |= (SNS_RING); /* set char detect status */ +// com_lstat[unit][0] |= (SNS_ASCIICD); /* set char detect status */ +// ch = (com_lstat[unit][0] >> 16) & 0xff; + chan_write_byte(chsa, &ch); /* write status */ + + /* byte 2 modem status */ +// com_lstat[unit][0] |= (SNS_CTSS|SNS_DSRS); /* set CTS & DSR status */ +// com_lstat[unit][0] |= (SNS_MRING); /* set char detect status */ +// SNS_DELDSR will be set if just connected, clear at end + ch = (uptr->SNS >> 8) & 0xff; /* CTS & DSR bits in byte 2 */ + chan_write_byte(chsa, &ch); /* write status */ + + /* byte 3 modem control/operation mode */ +// com_lstat[unit][0] |= (SNS_DTR); /* set DTR status */ +// ch = (com_lstat[unit][0]) & 0xff; /* set current status */ + ch = uptr->SNS & 0xff; /* maybe DTR bit in byte 3 */ + chan_write_byte(chsa, &ch); /* write status */ + + /* byte 4 ACE byte 0 parameters (parity, stop bits, char len */ +// ch = (com_lstat[unit][1] >> 24) & 0xff; + ch = (uptr->ACE >> 24) & 0xff; /* ACE byte 0 */ + chan_write_byte(chsa, &ch); /* write status */ + + /* byte 5 ACE byte 1 parameters (baud rate) */ +// ch = (com_lstat[unit][1] >> 16) & 0xff; + ch = (uptr->ACE >> 16) & 0xff; /* ACE byte 1 */ + chan_write_byte(chsa, &ch); /* write status */ + + /* byte 6 ACE parameters (Firmware ID 0x62) */ +// ch = (com_lstat[unit][1] >> 8) & 0xff; + ch = 0x62; /* ACE IOP firmware byte 0 */ +// ch = 0x19; /* ACE MFP firmware byte 0 */ + chan_write_byte(chsa, &ch); /* write status */ + + /* byte 7 ACE parameters (Revision Level 0x4?) */ +// ch = (com_lstat[unit][1] >> 0) & 0xff; +// Firmware 0x44 supports RTS flow control */ +// Firmware 0x45 supports DCD modem control */ +// ch = 0x44; /* ACE firmware byte 1 */ +// ch = 0x45; /* ACE firmware byte 1 */ + ch = 0x43; /* ACE firmware byte 1 */ +// ch = 0x40; /* ACE firmware byte 1 */ + chan_write_byte(chsa, &ch); /* write status */ + + ruptr->SNS &= ~SNS_RING; /* reset ring attention status */ + ruptr->SNS &= ~SNS_MRING; /* reset ring attention status */ + ruptr->SNS &= ~SNS_ASCIICD; /* reset ASCII attention status */ + ruptr->SNS &= ~SNS_DELDSR; /* reset attention status */ +//MPX ruptr->SNS &= ~SNS_RLSDS; /* reset rec'd line signal detect */ + ruptr->SNS &= ~SNS_CMDREJ; /* command reject */ +/*MPX*/ ruptr->SNS &= ~SNS_DELTA; /* reset attention status */ + + wuptr->SNS &= ~SNS_RING; /* reset ring attention status */ + wuptr->SNS &= ~SNS_MRING; /* reset ring attention status */ + wuptr->SNS &= ~SNS_ASCIICD; /* reset ASCII attention status */ + wuptr->SNS &= ~SNS_DELDSR; /* reset attention status */ + wuptr->SNS &= ~SNS_RLSDS; /* reset rec'd line signal detect */ + wuptr->SNS &= ~SNS_CMDREJ; /* command reject */ +/*MPX*/ wuptr->SNS &= ~SNS_DELTA; /* reset attention status */ + + uptr->CMD &= LMASK; /* nothing left, command complete */ + sim_debug(DEBUG_CMD, dptr, + "coml_startcmd CMD SENSE return chsa %04x: unit %02x Cmd Sense SNS %08x ACE %08x\n", + chsa, unit, uptr->SNS, uptr->ACE); + return SNS_CHNEND|SNS_DEVEND; /* good return */ break; - case COM_DEFSC: /* 0x0B */ /* Define special char */ + case COM_DEFSC: /* 0x0B */ /* Define special char */ sim_debug(DEBUG_CMD, dptr, - "com_startcmd %04x: Cmd %02x DEFSC\n", chsa, cmd); - if (chan_read_byte(GET_UADDR(uptr->u3), &ch)) { /* read char from memory */ + "coml_startcmd chsa %04x: Cmd %02x DEFSC\n", chsa, cmd); + if (chan_read_byte(GET_UADDR(uptr->CMD), &ch)) { /* read char from memory */ /* nothing to read, error */ return SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK; /* good return */ } - uptr->u4 &= ~ACE_WAKE; /* clear out old wake char */ - uptr->u4 |= ((uint32)ch << 8); /* insert special char */ - uptr->u5 = ~SNS_RTS; /* Request to send not ready */ + uptr->ACE &= ~ACE_WAKE; /* clear out old wake char */ + uptr->ACE |= ((uint32)ch << 8); /* insert special char */ + ruptr->ACE = uptr->ACE; /* set special char in read unit */ + wuptr->ACE = uptr->ACE; /* set special char in write unit */ +// uptr->CMD = ~SNS_RTS; /* Request to send not ready */ sim_debug(DEBUG_CMD, dptr, - "com_startcmd %04x: Cmd %02x DEFSC char %02x ACE %08x\n", - chsa, cmd, ch, uptr->u4); - return SNS_CHNEND|SNS_DEVEND; /* good return */ + "coml_startcmd chsa %04x: Cmd %02x DEFSC char %02x SNS %08x ACE %08x\n", + chsa, cmd, ch, uptr->SNS, uptr->ACE); + return SNS_CHNEND|SNS_DEVEND; /* good return */ break; - case COM_RRTS: /* 0x1B */ /* Reset RTS */ - sim_debug(DEBUG_CMD, dptr, "com_startcmd %04x: Cmd %02x RRTS\n", chan, cmd); - uptr->u5 &= ~SNS_RTS; /* Request to send not ready */ - return SNS_CHNEND|SNS_DEVEND; /* good return */ + case COM_RRTS: /* 0x1B */ /* Reset RTS */ + sim_debug(DEBUG_CMD, dptr, "coml_startcmd chsa %04x: Cmd %02x RRTS\n", chsa, cmd); + uptr->SNS &= ~SNS_RTS; /* Request to send not ready */ + return SNS_CHNEND|SNS_DEVEND; /* good return */ break; - case COM_SRTS: /* 0x1F */ /* Set RTS */ - sim_debug(DEBUG_CMD, dptr, "com_startcmd %04x: Cmd %02x SRTS\n", chan, cmd); - uptr->u5 |= SNS_RTS; /* Requestd to send ready */ - return SNS_CHNEND|SNS_DEVEND; /* good return */ + case COM_SRTS: /* 0x1F */ /* Set RTS */ + sim_debug(DEBUG_CMD, dptr, "coml_startcmd chsa %04x: Cmd %02x SRTS\n", chsa, cmd); + uptr->SNS |= SNS_RTS; /* Request to send ready */ + return SNS_CHNEND|SNS_DEVEND; /* good return */ break; - case COM_RBRK: /* 0x33 */ /* Reset BREAK */ - sim_debug(DEBUG_CMD, dptr, "com_startcmd %04x: Cmd %02x RBRK\n", chan, cmd); - uptr->u5 &= ~SNS_BREAK; /* Request to send not ready */ - return SNS_CHNEND|SNS_DEVEND; /* good return */ + case COM_RBRK: /* 0x33 */ /* Reset BREAK */ + sim_debug(DEBUG_CMD, dptr, "coml_startcmd chsa %04x: Cmd %02x RBRK\n", chsa, cmd); + uptr->SNS &= ~SNS_BREAK; /* Request to send not ready */ + return SNS_CHNEND|SNS_DEVEND; /* good return */ break; - case COM_SBRK: /* 0x37 */ /* Set BREAK */ - sim_debug(DEBUG_CMD, dptr, "com_startcmd %04x: Cmd %02x SBRK\n", chan, cmd); - uptr->u5 |= SNS_BREAK; /* Requestd to send ready */ - return SNS_CHNEND|SNS_DEVEND; /* good return */ + case COM_SBRK: /* 0x37 */ /* Set BREAK */ + sim_debug(DEBUG_CMD, dptr, "coml_startcmd chsa %04x: Cmd %02x SBRK\n", chsa, cmd); + uptr->SNS |= SNS_BREAK; /* Requestd to send ready */ + return SNS_CHNEND|SNS_DEVEND; /* good return */ break; - case COM_RDTR: /* 0x13 */ /* Reset DTR (ADVR) */ - sim_debug(DEBUG_CMD, dptr, "com_startcmd %04x: Cmd %02x RDTR\n", chan, cmd); - uptr->u5 &= ~SNS_DTR; /* Data terminal not ready */ - return SNS_CHNEND|SNS_DEVEND; /* good return */ + case COM_RDTR: /* 0x13 */ /* Reset DTR (ADVR) */ + sim_debug(DEBUG_CMD, dptr, "coml_startcmd chsa %04x: Cmd %02x RDTR\n", chsa, cmd); + uptr->SNS &= ~SNS_DTR; /* Data terminal not ready */ + return SNS_CHNEND|SNS_DEVEND; /* good return */ break; - case COM_SDTR: /* 0x17 */ /* Set DTR (ADVF) */ - sim_debug(DEBUG_CMD, dptr, "com_startcmd %04x: Cmd %02x SDTR\n", chan, cmd); - uptr->u5 |= SNS_DTR; /* Data terminal ready */ - return SNS_CHNEND|SNS_DEVEND; /* good return */ + case COM_SDTR: /* 0x17 */ /* Set DTR (ADVF) */ + sim_debug(DEBUG_CMD, dptr, "coml_startcmd chsa %04x: Cmd %02x SDTR\n", chsa, cmd); + uptr->SNS |= SNS_DTR; /* Data terminal ready */ + return SNS_CHNEND|SNS_DEVEND; /* good return */ break; #if 0 @@ -674,50 +793,103 @@ uint16 com_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) #define ACE_WAKE 0x0000FF00 /* 8 bit wake-up character */ #endif - case COM_SACE: /* 0xff */ /* Set ACE parameters (3 chars) */ + case COM_SACE: /* 0xff */ /* Set ACE parameters (3 chars) */ sim_debug(DEBUG_CMD, dptr, - "com_startcmd %04x: Cmd %02x SACE\n", chsa, cmd); + "coml_startcmd chsa %04x: Cmd %02x SACE\n", chsa, cmd); - if (chan_read_byte(GET_UADDR(uptr->u3), &ch)) { /* read char 0 */ + if (chan_read_byte(GET_UADDR(uptr->CMD), &ch)) { /* read char 0 */ /* nothing to read, error */ return SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK; /* good return */ } - uptr->u4 = ((uint32)ch)<<24; /* byte 0 of ACE data */ + uptr->ACE = ((uint32)ch)<<24; /* byte 0 of ACE data */ sim_debug(DEBUG_CMD, dptr, - "com_startcmd %04x: Cmd %02x ACE byte 0 %02x\n", + "coml_startcmd chsa %04x: Cmd %02x ACE byte 0 %02x\n", chsa, cmd, ch); - if (chan_read_byte(GET_UADDR(uptr->u3), &ch)) { /* read char 1 */ + if (chan_read_byte(GET_UADDR(uptr->CMD), &ch)) { /* read char 1 */ /* nothing to read, error */ return SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK; /* good return */ } - uptr->u4 |= ((uint32)ch)<<16; /* byte 1 of ACE data */ + uptr->ACE |= ((uint32)ch)<<16; /* byte 1 of ACE data */ sim_debug(DEBUG_CMD, dptr, - "com_startcmd %04x: Cmd %02x ACE byte 1 %02x\n", + "coml_startcmd chsa %04x: Cmd %02x ACE byte 1 %02x\n", chsa, cmd, ch); - if (chan_read_byte(GET_UADDR(uptr->u3), &ch)) { /* read char 2 */ + if (chan_read_byte(GET_UADDR(uptr->CMD), &ch)) { /* read char 2 */ /* nothing to read, error */ return SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK; /* good return */ } - uptr->u4 |= ((uint32)ch)<<8; /* byte 2 of ACE data */ + uptr->ACE |= ((uint32)ch)<<8; /* byte 2 of ACE data */ + uptr->SNS |= SNS_ACEDEF; /* show ACE defined */ + if (uptr->SNS & SNS_CONN) { + if (!(uptr->ACE & SNS_MRINGE)) { /* see if RING enabled */ + uptr->SNS |= (SNS_DTR | SNS_RTS); /* set DTR & DSR if yes */ + } + } + ruptr->SNS |= SNS_RDY; /* status is online & ready */ + if (uptr == wuptr) { + ruptr->ACE = uptr->ACE; /* set ACE in read uptr */ + ruptr->SNS = uptr->SNS; /* set status to read uptr */ + } else { + wuptr->ACE = uptr->ACE; /* set ACE in write uptr */ + wuptr->SNS = uptr->SNS; /* set status to write uptr */ + } sim_debug(DEBUG_CMD, dptr, - "com_startcmd %04x: Cmd %02x ACE byte 2 %02x\n", + "coml_startcmd chsa %04x: Cmd %02x ACE byte 2 %02x\n", chsa, cmd, ch); sim_debug(DEBUG_CMD, dptr, - "com_startcmd %04x: Cmd %02x ACE bytes %08x\n", - chan, cmd, uptr->u4); + "coml_startcmd ACE DONE chsa %04x: Cmd %02x ACE bytes %08x\n", + chsa, cmd, uptr->ACE); - return SNS_CHNEND|SNS_DEVEND; /* good return */ + uptr->CMD &= LMASK; /* nothing left, command complete */ + return SNS_CHNEND|SNS_DEVEND; /* good return */ break; - - default: /* invalid command */ - uptr->u5 |= SNS_CMDREJ; /* command rejected */ + /* Set transparent flow control mode */ + case COM_SETFLOW: /* 0x53 */ /* Set flow control (3 chars) */ sim_debug(DEBUG_CMD, dptr, - "com_startcmd %04x: Cmd Invald %02x status %02x\n", - chan, cmd, uptr->u5); - return SNS_CHNEND|STATUS_PCHK; /* program check */ + "coml_startcmd chsa %04x: Cmd %02x SETFLOW\n", chsa, cmd); + + if (chan_read_byte(GET_UADDR(uptr->CMD), &ch)) { /* read char 0 */ + /* nothing to read, error */ + return SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK; /* good return */ + } + fcb[0] = ch; /* byte 0 of Flow Cont data */ + sim_debug(DEBUG_CMD, dptr, + "coml_startcmd chsa %04x: Cmd %02x SETFLOW byte 0 %02x\n", + chsa, cmd, ch); + + if (chan_read_byte(GET_UADDR(uptr->CMD), &ch)) { /* read char 1 */ + /* nothing to read, error */ + return SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK; /* good return */ + } + fcb[1] = ch; /* byte 1 of Flow Cont data */ + sim_debug(DEBUG_CMD, dptr, + "coml_startcmd chsa %04x: Cmd %02x SETFLOW byte 1 %02x\n", + chsa, cmd, ch); + + if (chan_read_byte(GET_UADDR(uptr->CMD), &ch)) { /* read char 2 */ + /* nothing to read, error */ + return SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK; /* good return */ + } + fcb[2] = ch; /* byte 2 of Flow Cont data */ + ruptr->SNS |= SNS_RDY; /* status is online & ready */ + sim_debug(DEBUG_CMD, dptr, + "coml_startcmd chsa %04x: Cmd %02x SETFLOW byte 2 %02x\n", + chsa, cmd, ch); + sim_debug(DEBUG_CMD, dptr, + "coml_startcmd SETFLOW DONE chsa %04x: Cmd %02x FCB bytes %02x%02x%02x\n", + chsa, cmd, fcb[0], fcb[1], fcb[2]); + + uptr->CMD &= LMASK; /* nothing left, command complete */ + return SNS_CHNEND|SNS_DEVEND; /* good return */ + break; + default: /* invalid command */ + uptr->SNS |= SNS_CMDREJ; /* command rejected */ + sim_debug(DEBUG_CMD, dptr, + "coml_startcmd chsa %04x: Cmd Invalid %02x status %02x\n", + chsa, cmd, uptr->u5); + return SNS_CHNEND|SNS_DEVEND|STATUS_PCHK; /* program check */ break; } @@ -730,207 +902,428 @@ uint16 com_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) Poll for new connections Poll all connected lines for input */ -t_stat comi_srv(UNIT *uptr) +t_stat comc_srv(UNIT *uptr) { uint8 ch; DEVICE *dptr = get_dev(uptr); int32 newln, ln, c; - uint16 chsa = GET_UADDR(uptr->u3); /* get channel/sub-addr */ - int cmd = uptr->u3 & 0xff; +// int cmd = uptr->CMD & 0xff; + uint16 chsa = GET_UADDR(coml_unit[0].CMD); /* get channel/sub-addr */ - ln = uptr - com_unit; /* line # */ - /* handle NOP and INCH cmds */ - sim_debug(DEBUG_CMD, dptr, - "comi_srv entry chsa %04x line %02x cmd %02x\n", chsa, ln, cmd); - if (cmd == COM_NOP || cmd == 0x7f) { /* check for NOP or INCH */ - uptr->u3 &= LMASK; /* leave only chsa */ - sim_debug(DEBUG_CMD, dptr, - "comi_srv NOP or INCH done chsa %04x line %02x cmd %02x\n", - chsa, ln, cmd); - chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* done */ - return SCPE_OK; /* return */ - } - - /* handle SACE, 3 char already read, so we are done */ - if (cmd == COM_SACE) { /* check for SACE 0xff */ - uptr->u3 &= LMASK; /* leave only chsa */ - sim_debug(DEBUG_CMD, &com_dev, - "comi_srv SACE done chsa %04x line %02x cmd %02x ACE %08x\n", - chsa, ln, cmd, uptr->u4); - chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* done */ - return SCPE_OK; /* return */ - } - - ln = uptr - com_unit; /* line # */ + /* see if comc attached */ if ((com_unit[COMC].flags & UNIT_ATT) == 0){ /* attached? */ return SCPE_OK; } - newln = tmxr_poll_conn(&com_desc); /* look for connect */ - if (newln >= 0) { /* rcv enb pending? */ - uint16 chsa = GET_UADDR(coml_unit[newln].u3); /* get channel/sub-addr */ - com_ldsc[newln].rcve = 1; /* enable rcv */ - com_ldsc[newln].xmte = 1; /* enable xmt for output line */ - com_sta[newln] &= ~COML_REP; /* clr pending */ - /* send attention to OS here for this channel */ - /* need to get chsa here for the channel */ + /* poll for any input from com lines, units 0-7 */ + newln = tmxr_poll_conn(&com_desc); /* look for connect */ + if (newln >= 0) { /* rcv enb pending? */ + uint16 chsa = GET_UADDR(coml_unit[newln].CMD); /* get read channel/sub-addr */ + uint16 wchsa = GET_UADDR(coml_unit[newln+8].CMD); /* get write channel/sub-addr */ + UNIT *nuptr = coml_unit+newln; /* get uptr for coml line */ + UNIT *wuptr = coml_unit+newln+8; /* get output uptr for coml line */ + com_ldsc[newln].rcve = 1; /* enable rcv */ + com_ldsc[newln].xmte = 1; /* enable xmt for output line */ + com_stat[newln] |= COML_RBP; /* connected */ + com_stat[newln] &= ~COML_REP; /* not pending */ + sim_debug(DEBUG_CMD, &com_dev, - "comi_srv wakeup on chsa %04x line %02x cmd %02x ACE %08x\n", - chsa, ln, cmd, uptr->u4); + "comc_srv conn b4 wakeup on read chsa %04x line %02x SNS %08x ACE %08x\n", + chsa, newln, nuptr->SNS, nuptr->ACE); + sim_debug(DEBUG_CMD, &com_dev, + "comc_srv conn b4 wakeup on write chsa %04x line %02x SNS %08x ACE %08x\n", + wchsa, newln+8, wuptr->SNS, wuptr->ACE); + + /* send attention to OS here for this channel */ + /* set DSR, CTS and delta DSR status */ + nuptr->SNS |= SNS_CONN; /* status is now connected */ + /* UTX says this is an error if set, so do not set SNS_DELDSR */ +/*MPX*/ nuptr->SNS |= (SNS_DSRS | SNS_CTSS | SNS_RING); /* set the read bits */ +// nuptr->SNS |= (SNS_DSRS | SNS_CTSS); /* set the read bits */ +//GG/*MM*/ nuptr->SNS |= (SNS_RTS | SNS_DTR); /* set RTS & DTR */ +/*M*/ nuptr->SNS |= SNS_DTR; /* set DTR */ +/*MPX*/ nuptr->SNS |= SNS_MRING; /* set RING interrupt */ +///*M*/ nuptr->SNS |= SNS_ASCIICD; /* set ring attention status */ + if (nuptr->SNS & SNS_ACEDEF) { /* ACE defined */ + /* this must be set to login for UTX after system is up */ +/*UTX*/ nuptr->SNS |= SNS_DELDSR; /* set delta dsr status */ +//JJ nuptr->SNS |= (SNS_DELTA); /* status is not connected */ + nuptr->SNS |= SNS_RLSDS; /* set rec'd line signal detect */ + } else { + nuptr->SNS |= SNS_DELDSR; /* set delta dsr status */ + nuptr->SNS |= SNS_RLSDS; /* set rec'd line signal detect */ + } + nuptr->SNS &= ~SNS_CMDREJ; /* no command reject */ + wuptr->SNS = nuptr->SNS; /* set write line too */ + wuptr->SNS &= ~(SNS_RLSDS | SNS_RING); /* not for write channel */ + wuptr->ACE = nuptr->ACE; /* set write line too */ + sim_debug(DEBUG_CMD, &com_dev, + "comc_srv conn wakeup on chsa %04x line %02x SNS %08x ACE %08x\n", + chsa, newln, nuptr->SNS, nuptr->ACE); set_devwake(chsa, SNS_ATTN|SNS_DEVEND|SNS_CHNEND); /* tell user */ +// /*MPX*/ sim_activate(nuptr, uptr->wait); /* start input */ } /* poll all devices for input */ - tmxr_poll_rx(&com_desc); /* poll for input */ - for (ln = 0; ln < COM_NUMLIN; ln++) { /* loop thru lines */ - UNIT *comlp = coml_unit+ln; /* get uptr for coml line */ - int cmd = comlp->u3 & 0xff; /* get the active cmd */ - uint16 chsa = GET_UADDR(comlp->u3); /* get channel/sub-addr */ - if (com_ldsc[ln].conn) { /* connected? */ - if ((c = tmxr_getc_ln(&com_ldsc[ln]))) { /* get char */ - ch = c; /* just the char */ - /* echo the char out */ - tmxr_putc_ln(&com_ldsc[ln], ch); /* output char */ - tmxr_poll_tx(&com_desc); /* poll xmt */ - if (c & SCPE_BREAK) /* break? */ - com_sta[ln] |= COML_RBP; /* set rcv brk */ - else { /* normal char */ - com_sta[ln] &= ~COML_RBP; /* clr rcv brk */ - c = sim_tt_inpcvt(c, TT_GET_MODE(coml_unit[ln].flags)); - com_rbuf[ln] = c; /* save char */ - if ((cmd & COM_RD) == COM_RD) { /* read active? */ - ch = c; /* clean the char */ - if (ch == '\n') /* convert newline */ - ch = '\r'; /* to C/R */ - /* write byte to memory */ - if (chan_write_byte(chsa, &ch)) { - /* done, reading chars */ - comlp->u3 &= LMASK; /* nothing left, clear cmd */ - chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* we done */ - } else { - /* more to go, continue */ - if (ch == '\r') { /* see if done */ - comlp->u3 &= LMASK; /* nothing left, clear cmd */ - chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* we done */ - } - } - } - else { - /* see if user hit the wakeup key */ - if (((comlp->u4 & ACE_WAKE) >> 8) == ch) { - /* send attention to OS here for this channel */ - /* need to get chsa here for the channel */ - /* tell user */ - sim_debug(DEBUG_CMD, &com_dev, - "comi_srv user wakeup on chsa %04x line %02x cmd %02x ACE %08x\n", - chsa, ln, cmd, uptr->u4); - set_devwake(chsa, SNS_ATTN|SNS_DEVEND|SNS_CHNEND); - } - } - } /* end else char */ - } /* end if char */ - } /* end if conn */ - else { - com_sta[ln] &= ~COML_RBP; /* disconnected */ - com_sta[ln] |= COML_REP; /* set pending */ + tmxr_poll_rx(&com_desc); /* poll for input */ + for (ln = 0; ln < COM_NUMLIN; ln++) { /* loop thru lines */ + UNIT *nuptr = coml_unit+ln; /* get uptr for coml line */ + int cmd = nuptr->CMD & 0xff; /* get the active cmd */ + uint16 chsa = GET_UADDR(nuptr->CMD); /* get channel/sub-addr */ + + if (com_ldsc[ln].conn) /* connected? */ + sim_debug(DEBUG_CMD, &com_dev, + "comc_srv conn poll input chsa %04x line %02x SNS %08x ACE %08x\n", + chsa, ln, nuptr->SNS, nuptr->ACE); + + if ((com_ldsc[ln].conn) && /* connected? */ + (c = tmxr_getc_ln(&com_ldsc[ln]))) { /* get char */ + ch = c & 0x7f; + if (ch == '\n') /* convert newline */ + ch = '\r'; /* to C/R */ + sim_debug(DEBUG_CMD, &com_dev, + "comc_srv read %02x (%02x) chsa %04x line %02x SNS %08x ACE %08x CMD %08x\n", + c, ch, chsa, ln, nuptr->SNS, nuptr->ACE, nuptr->CMD); + /* tmxr says break is 0x80??, but SCPE_BREAK is 0x800000?? */ + if (c & SCPE_BREAK) { /* break? */ + nuptr->SNS |= SNS_BREAK; /* set received break bit */ + com_stat[ln] |= COML_RBP; /* set rcv brk */ + set_devwake(chsa, SNS_ATTN|SNS_DEVEND|SNS_CHNEND); + continue; + } + /* normal char */ + nuptr->SNS &= ~SNS_BREAK; /* reset received break bit */ + com_stat[ln] &= ~COML_RBP; /* clr rcv brk */ + + /* convert to user requested input */ + ch = sim_tt_inpcvt(ch, TT_GET_MODE(coml_unit[ln].flags)); + com_rbuf[ln] = ch; /* save char */ + +#if 1 + /* Special char detect? */ + if ((ch & 0x7f) == ((nuptr->ACE >> 8) & 0xff)) { /* is it spec char */ +#if 0 + if (cmd == 0) { + nuptr->CNT = 0; /* no I/O yet */ + com_data[ln].incnt = 0; /* no input data */ + } +#endif + nuptr->CMD |= COM_SCD; /* set special char detected */ + nuptr->SNS |= SNS_SPCLCD; /* set special char detected */ +// nuptr->SNS |= SNS_RLSDS; /* set rec'd line signal detect */ + nuptr->SNS |= SNS_RING; /* set ring attention status */ + sim_debug(DEBUG_CMD, &com_dev, + "comc_srv user ACE wakeup on chsa %04x line %02x cmd %02x SNS %08x ACE %08x\n", + chsa, ln, cmd, nuptr->SNS, nuptr->ACE); + set_devwake(chsa, SNS_ATTN|SNS_DEVEND|SNS_CHNEND); + continue; + } +#endif + + /* put char in buffer */ + com_data[ln].ibuff[com_data[ln].incnt++] = ch; + + /* see if at max, if so reset to start */ + if (com_data[ln].incnt >= sizeof(com_data[ln].ibuff)) + com_data[ln].incnt = 0; /* reset buffer cnt */ + + nuptr->CMD |= COM_INPUT; /* we have a char available */ + sim_debug(DEBUG_CMD, dptr, + "comc_srv readch ln %02x: CMD %08x read %02x CNT %02x incnt %02x c %04x\n", + ln, nuptr->CMD, ch, nuptr->CNT, com_data[ln].incnt, c); } - } /* end for */ - return sim_clock_coschedule(uptr, 200); /* continue poll */ + else /* end if conn */ + /* if we were connected and not now, reset serial line */ + if ((nuptr->SNS & SNS_CONN) && (com_ldsc[ln].conn == 0)) { + UNIT *wuptr = coml_unit+ln+8; /* get output uptr for coml line */ + sim_debug(DEBUG_CMD, &com_dev, + "comc_srv disconnect on chsa %04x line %02x cmd %02x SNS %08x ACE %08x\n", + chsa, ln, cmd, nuptr->SNS, nuptr->ACE); + com_ldsc[ln].rcve = 0; /* disable rcv */ + com_ldsc[ln].xmte = 0; /* disable xmt for output line */ + com_stat[ln] &= ~COML_RBP; /* disconnected */ + com_stat[ln] |= COML_REP; /* set pending */ + nuptr->SNS &= ~(SNS_RTS | SNS_DTR); /* reset RTS & DTR */ + nuptr->SNS &= ~(SNS_DSRS); /* status is not connected */ + nuptr->SNS |= (SNS_DELDSR); /* status is not connected */ +//TT nuptr->SNS &= ~(SNS_DELDSR); /* status is not connected */ + nuptr->SNS |= (SNS_DELTA); /* status is not connected */ + nuptr->SNS &= ~(SNS_RDY|SNS_CONN); /* status is not connected */ + wuptr->SNS = nuptr->SNS; /* set write channel too */ + set_devwake(chsa, SNS_ATTN|SNS_DEVEND|SNS_CHNEND); + } + } /* end for */ + + sim_debug(DEBUG_DETAIL, &com_dev, + "comc_srv POLL DONE on chsa %04x\n", chsa); + /* this says to use 200, but simh really uses 50000 for cnt */ +// return sim_clock_coschedule(uptr, 200); /* continue poll */ + return sim_activate(uptr, 10000); /* continue poll */ +// return sim_activate(uptr, 5000); /* continue poll */ +} + +/* Unit service - input transfers */ +t_stat comi_srv(UNIT *uptr) +{ + DEVICE *dptr = get_dev(uptr); + uint16 chsa = GET_UADDR(uptr->CMD); /* get channel/sub-addr */ + uint32 ln = (uptr - coml_unit) & 0x7; /* use line # 0-7 for 8-15 */ + CHANP *chp = find_chanp_ptr(chsa); /* find the chanp pointer */ + int cmd = uptr->CMD & 0xff; /* get active cmd */ + uint8 ch, cc; + + /* handle NOP and INCH cmds */ + sim_debug(DEBUG_CMD, dptr, + "comi_srv entry chsa %04x line %04x cmd %02x conn %x rcve %x xmte %x SNS %08x\n", + chsa, ln, cmd, com_ldsc[ln].conn, com_ldsc[ln].rcve, com_ldsc[ln].xmte, uptr->SNS); + + if (com_ldsc[ln].conn) { /* connected? */ + if ((uptr->CNT != com_data[ln].incnt) || /* input empty */ + (uptr->CMD & COM_INPUT)) { /* input waiting? */ + ch = com_data[ln].ibuff[uptr->CNT]; /* get char from read buffer */ + sim_debug(DEBUG_CMD, dptr, + "com_srvi readbuf unit %02x: CMD %08x read %02x incnt %02x CNT %02x len %02x\n", + ln, uptr->CMD, ch, com_data[ln].incnt, uptr->CNT, chp->ccw_count); + + if (uptr->CNT != com_data[ln].incnt) { /* input available */ + /* process any characters */ + /* this fixes mpx1x time entry on startup */ + if (uptr->CMD & COM_EKO) { /* ECHO requested */ + /* echo the char out */ + /* convert to user requested output */ + sim_debug(DEBUG_CMD, &com_dev, + "comi_srv echo char %02x on chsa %04x line %02x cmd %02x ACE %08x\n", + ch, chsa, ln, cmd, uptr->ACE); +// cc = sim_tt_outcvt(c, TT_GET_MODE(coml_unit[ln].flags)); + tmxr_putc_ln(&com_ldsc[ln], ch); /* output char */ + tmxr_poll_tx(&com_desc); /* poll xmt to send */ + } + if (chan_write_byte(chsa, &ch)) { /* write byte to memory */ + /* write error */ + cmd = 0; /* no cmd now */ + sim_debug(DEBUG_CMD, dptr, + "comi_srv write error ln %02x: CMD %08x read %02x CNT %02x ccw_count %02x\n", + ln, uptr->CMD, ch, uptr->CNT, chp->ccw_count); + uptr->CMD &= ~COM_MSK; /* remove old CMD */ + uptr->CMD &= ~COM_INPUT; /* input waiting? */ + chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* we done */ + return SCPE_OK; + } + /* character accepted, bump buffer pointer */ + uptr->CNT++; /* next char position */ + + sim_debug(DEBUG_CMD, dptr, + "comi_srv write to mem line %02x: CMD %08x read %02x CNT %02x incnt %02x\n", + ln, uptr->CMD, ch, uptr->CNT, com_data[ln].incnt); + + /* see if at end of buffer */ + if (uptr->CNT >= (int32)sizeof(com_data[ln].ibuff)) + uptr->CNT = 0; /* reset pointer */ + + cc = ch & 0x7f; /* clear parity bit */ + /* Special char detected? (7 bit read only) */ + if (cc == ((uptr->ACE >> 8) & 0xff)) { /* is it spec char */ +// uptr->CMD |= COM_SCD; /* set special char detected */ + uptr->SNS |= SNS_SPCLCD; /* set special char detected */ + sim_debug(DEBUG_CMD, &com_dev, + "comi_srv user ACE %02x wakeup on chsa %04x line %02x cmd %02x ACE %08x\n", + cc, chsa, ln, cmd, uptr->ACE); + uptr->CMD &= LMASK; /* nothing left, command complete */ + sim_debug(DEBUG_CMD, dptr, + "comi_srv read done chsa %04x ln %04x: chnend|devend\n", chsa, ln); + chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* done */ + return SCPE_OK; + } + + /* ASCII control char (7 bit read only) */ + /* see if control char detected */ + if (uptr->CMD & 0x40) { /* is ASCII ctrl char test bit set */ + if (((cc & 0x60) == 0) || (cc == 0x7f)) { + uptr->SNS |= SNS_ASCIICD; /* ASCII ctrl char detected */ + sim_debug(DEBUG_CMD, &com_dev, + "comi_srv user ASCII %02x wakeup on chsa %04x line %02x cmd %02x ACE %08x\n", + cc, chsa, ln, cmd, uptr->ACE); + uptr->CMD &= LMASK; /* nothing left, command complete */ + sim_debug(DEBUG_CMD, dptr, + "comi_srv read CC done chsa %04x ln %04x: chnend|devend\n", chsa, ln); + chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* done */ + return SCPE_OK; + } + } + + /* user want more data? */ + if ((test_write_byte_end(chsa)) == 0) { + sim_debug(DEBUG_CMD, dptr, + "comi_srv need more line %02x CMD %08x CNT %02x ccw_count %02x incnt %02x\n", + ln, uptr->CMD, uptr->CNT, chp->ccw_count, com_data[ln].incnt); + /* user wants more, look next time */ + if (uptr->CNT == com_data[ln].incnt) { /* input empty */ + uptr->CMD &= ~COM_INPUT; /* no input available */ + } + sim_activate(uptr, uptr->wait); /* wait */ + return SCPE_OK; + } + /* command is completed */ + sim_debug(DEBUG_CMD, dptr, + "comi_srv read done line %02x CMD %08x read %02x CNT %02x ccw_count %02x incnt %02x\n", + ln, uptr->CMD, ch, uptr->CNT, chp->ccw_count, com_data[ln].incnt); + uptr->CMD &= LMASK; /* nothing left, command complete */ + if (uptr->CNT != com_data[ln].incnt) { /* input empty */ + uptr->CMD |= COM_INPUT; /* input still available */ + } + chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* we done */ + } + } + sim_activate(uptr, uptr->wait); /* wait */ + return SCPE_OK; + } + /* not connected, so dump chars on ground */ + uptr->CNT = 0; /* no input count */ + com_data[ln].incnt = 0; /* no input data */ + uptr->CMD &= LMASK; /* nothing left, command complete */ + uptr->SNS |= 0x00003003; /* status is online & ready */ + uptr->SNS &= SNS_DSRS; /* reset DSR */ + uptr->SNS |= SNS_DELDSR; /* give change status */ + uptr->SNS |= SNS_MRING; /* give RING status */ + sim_debug(DEBUG_CMD, dptr, + "comi_srv read dump DONE line %04x status %04x cmd %02x SNS %08x\n", + ln, SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK, cmd, uptr->SNS); + /* if line active, abort cmd */ + chan_end(chsa, SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK); /* error return */ + return SCPE_OK; } /* Unit service - output transfers */ t_stat como_srv(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); - uint16 chsa = GET_UADDR(uptr->u3); /* get channel/sub-addr */ - uint32 ln = (uptr - coml_unit) & 0x7; /* use line # 0-7 for 8-15 */ + uint16 chsa = GET_UADDR(uptr->CMD); /* get channel/sub-addr */ + uint32 ln = (uptr - coml_unit) & 0x7; /* use line # 0-7 for 8-15 */ + UNIT *ruptr = &dptr->units[ln&7]; /* read uptr */ uint32 done; - int cmd = uptr->u3 & 0xff; /* get active cmd */ + int cmd = uptr->CMD & 0xff; /* get active cmd */ uint8 ch; - /* handle NOP and INCH cmds */ sim_debug(DEBUG_CMD, dptr, - "como_srv entry chsa %04x line %04x cmd %02x\n", chsa, ln, cmd); - if (cmd == COM_NOP || cmd == 0x7f) { /* check for NOP or INCH */ - uptr->u3 &= LMASK; /* leave only chsa */ + "como_srv entry chsa %04x line %04x cmd %02x conn %x rcve %x xmte %x\n", + chsa, ln, cmd, com_ldsc[ln].conn, com_ldsc[ln].rcve, com_ldsc[ln].xmte); + + if (com_dev.flags & DEV_DIS) { /* disabled */ + sim_debug(DEBUG_CMD, dptr, + "como_srv chsa %04x line %02x SNS %08x DEV_DIS set\n", chsa, ln, uptr->SNS); + sim_debug(DEBUG_CMD, dptr, + "como_srv Write forced DONE %04x status %04x\n", + ln, SNS_CHNEND|SNS_DEVEND); + uptr->CMD &= LMASK; /* nothing left, command complete */ + ruptr->SNS &= SNS_DSRS; /* reset DSR */ + ruptr->SNS |= SNS_DELDSR; /* give change status */ +// chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* done */ + chan_end(chsa, SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK); /* error return */ + return SCPE_OK; /* return */ + } + + /* handle NOP and INCH cmds */ + if (cmd == COM_NOP || cmd == 0x7f) { /* check for NOP or INCH */ + uptr->CMD &= LMASK; /* leave only chsa */ sim_debug(DEBUG_CMD, &com_dev, "como_srv NOP or INCH done chsa %04x line %04x cmd %02x\n", chsa, ln, cmd); chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* done */ - return SCPE_OK; /* return */ + return SCPE_OK; /* return */ } /* handle SACE, 3 char already read, so we are done */ - if (cmd == COM_SACE) { /* check for SACE 0xff */ - uptr->u3 &= LMASK; /* leave only chsa */ + if (cmd == COM_SACE) { /* check for SACE 0xff */ + uptr->CMD &= LMASK; /* leave only chsa */ sim_debug(DEBUG_CMD, &com_dev, "como_srv SACE done chsa %04x line %02x cmd %02x ACE %08x\n", - chsa, ln, cmd, uptr->u4); + chsa, ln, cmd, uptr->ACE); chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* done */ - return SCPE_OK; /* return */ + return SCPE_OK; /* return */ + } + + if (cmd == 0) + /* all done, so stop polling */ + return SCPE_OK; + + if (com_ldsc[ln].conn == 0) { /* connected? */ + /* not connected, so dump char on ground */ + sim_debug(DEBUG_CMD, dptr, + "como_srv write dump DONE line %04x status %04x cmd %02x\n", + ln, SNS_CHNEND|SNS_DEVEND, cmd); + uptr->CMD &= LMASK; /* nothing left, command complete */ + + uptr->SNS |= 0x00003003; /* status is online & ready */ + ruptr->SNS &= SNS_DSRS; /* reset DSR */ + ruptr->SNS |= SNS_DELDSR; /* give change status */ + uptr->SNS |= SNS_MRING; /* give RING status */ + /* if line not active, abort cmd */ + chan_end(chsa, SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK); /* error return */ + return SCPE_OK; } sim_debug(DEBUG_CMD, dptr, "como_srv entry 1 chsa %04x line %04x cmd %02x\n", chsa, ln, cmd); - if (cmd) { - /* get a user byte from memory */ - done = chan_read_byte(chsa, &ch); /* get byte from memory */ - if (done) - uptr->u3 &= LMASK; /* leave only chsa */ - } else - return SCPE_OK; - - if (com_dev.flags & DEV_DIS) { /* disabled */ + /* get a user byte from memory */ +doagain: + done = chan_read_byte(chsa, &ch); /* get byte from memory */ + if (done) { + uptr->CMD &= LMASK; /* leave only chsa */ sim_debug(DEBUG_CMD, dptr, - "como_srv chsa %04x line %04x DEV_DIS set\n", chsa, ln); - if (done) { - sim_debug(DEBUG_CMD, dptr, - "como_srv Write DONE %04x status %04x\n", - ln, SNS_CHNEND|SNS_DEVEND); - chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* done */ - } - return SCPE_OK; /* return */ + "como_srv Write DONE %01x chsa %04x line %04x status %04x\n", + done, chsa, ln, SNS_CHNEND|SNS_DEVEND); + tmxr_poll_tx(&com_desc); /* send out data */ + chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* done */ + return SCPE_OK; /* return */ } - sim_debug(DEBUG_CMD, dptr, - "como_srv poll chsa %04x line %04x DEV_DIS set\n", chsa, ln); - if (com_ldsc[ln].conn) { /* connected? */ - if (com_ldsc[ln].xmte) { /* xmt enabled? */ - if (done) { /* are we done writing */ -endit: - uptr->u3 &= LMASK; /* nothing left, command complete */ - sim_debug(DEBUG_CMD, dptr, - "com_srvo write %04x: chnend|devend\n", ln); - chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* done */ - return SCPE_OK; - } - /* send the next char out */ - tmxr_putc_ln(&com_ldsc[ln], ch); /* output char */ - sim_debug(DEBUG_CMD, dptr, - "com_srvo writing char 0x%02x to ln %04x\n", ch, ln); - tmxr_poll_tx(&com_desc); /* poll xmt */ - sim_activate(uptr, uptr->wait); /* wait */ - return SCPE_OK; - } else { /* buf full */ - if (done) /* are we done writing */ - goto endit; /* done */ - /* just dump the char */ - sim_debug(DEBUG_CMD, dptr, - "com_srvo write dumping char 0x%02x on line %04x\n", ch, ln); - tmxr_poll_tx(&com_desc); /* poll xmt */ - sim_activate(uptr, uptr->wait); /* wait */ - return SCPE_OK; - } - } else { - /* not connected, so dump char on ground */ - if (done) { - sim_debug(DEBUG_CMD, dptr, - "com_srvo write dump DONE line %04x status %04x cmd %02x\n", - ln, SNS_CHNEND|SNS_DEVEND, cmd); - uptr->u3 &= LMASK; /* nothing left, command complete */ - chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* done */ - } - sim_activate(uptr, uptr->wait); /* wait */ - return SCPE_OK; + /* not done */ + sim_debug(DEBUG_DETAIL, dptr, + "como_srv poll chsa %04x line %02x SNS %08x ACE %08x\n", + chsa, ln, uptr->SNS, uptr->ACE); + + /* convert to user requested output */ + ch = sim_tt_outcvt(ch, TT_GET_MODE(coml_unit[ln].flags)); + /* send the next char out */ + tmxr_putc_ln(&com_ldsc[ln], ch); /* output char */ + sim_debug(DEBUG_CMD, dptr, + "como_srv writing char 0x%02x to ln %04x\n", ch, ln); + goto doagain; /* keep going */ +} + +/* haltxio routine */ +t_stat coml_haltio(UNIT *uptr) { + uint16 chsa = GET_UADDR(uptr->CMD); + int cmd = uptr->CMD & COM_MSK; + int unit = (uptr - coml_unit); /* unit # 0 is read, 1 is write */ + CHANP *chp = find_chanp_ptr(chsa); /* find the chanp pointer */ + + sim_debug(DEBUG_EXP, &com_dev, "coml_haltio enter chsa %04x cmd = %02x\n", chsa, cmd); + + /* terminate any input command */ + /* UTX wants SLI bit, but no unit exception */ + /* status must not have an error bit set */ + /* otherwise, UTX will panic with "bad status" */ + if ((uptr->CMD & COM_MSK) != 0) { /* is unit busy */ + sim_debug(DEBUG_CMD, &coml_dev, + "coml_haltio HIO chsa %04x cmd = %02x ccw_count %02x\n", chsa, cmd, chp->ccw_count); + /* stop any I/O and post status and return error status */ + chp->ccw_count = 0; /* zero the count */ + chp->ccw_flags &= ~(FLAG_DC|FLAG_CC); /* reset chaining bits */ + uptr->CMD &= LMASK; /* make non-busy */ + uptr->CNT = 0; /* no I/O yet */ + com_data[unit].incnt = 0; /* no input data */ + sim_cancel(uptr); /* stop timer */ +// uptr->SNS |= (SNS_RDY|SNS_CONN); /* status is online & ready */ + sim_debug(DEBUG_CMD, &coml_dev, + "coml_haltio HIO I/O stop chsa %04x cmd = %02x\n", chsa, cmd); + chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* force end */ +//BAD chan_end(chsa, SNS_CHNEND|SNS_DEVEND|SNS_UNITEXP); /* force end */ + return 1; /* tell chan code to post status */ } + uptr->CNT = 0; /* no I/O yet */ + com_data[unit].incnt = 0; /* no input data */ + uptr->CMD &= LMASK; /* make non-busy */ +// uptr->SNS |= (SNS_RDY|SNS_CONN); /* status is online & ready */ + return SCPE_OK; /* not busy */ } /* Reset routine */ @@ -938,13 +1331,13 @@ t_stat com_reset (DEVICE *dptr) { int32 i; - if (com_dev.flags & DEV_DIS) /* master disabled? */ - com_dev.flags |= DEV_DIS; /* disable lines */ + if (com_dev.flags & DEV_DIS) /* master disabled? */ + com_dev.flags |= DEV_DIS; /* disable lines */ else com_dev.flags &= ~DEV_DIS; - if (com_unit[COMC].flags & UNIT_ATT) /* master att? */ + if (com_unit[COMC].flags & UNIT_ATT) /* master att? */ sim_clock_coschedule(&com_unit[0], 200); /* activate */ - for (i = 0; i < COM_LINES; i++) /* reset lines */ + for (i = 0; i < COM_LINES; i++) /* reset lines */ com_reset_ln(i); return SCPE_OK; } @@ -956,11 +1349,11 @@ t_stat com_attach(UNIT *uptr, CONST char *cptr) DEVICE *dptr = get_dev(uptr); t_stat r; - r = tmxr_attach(&com_desc, uptr, cptr); /* attach */ - if (r != SCPE_OK) /* error? */ - return r; /* return error */ + r = tmxr_attach(&com_desc, uptr, cptr); /* attach */ + if (r != SCPE_OK) /* error? */ + return r; /* return error */ sim_debug(DEBUG_CMD, dptr, "com_srv comc is now attached\n"); - sim_activate(uptr, 0); /* start poll at once */ + sim_activate(uptr, 0); /* start poll at once */ return SCPE_OK; } @@ -970,10 +1363,10 @@ t_stat com_detach(UNIT *uptr) int32 i; t_stat r; - r = tmxr_detach(&com_desc, uptr); /* detach */ - for (i = 0; i < COM_LINES; i++) /* disable rcv */ - com_reset_ln(i); /* reset the line */ - sim_cancel(uptr); /* stop poll, cancel timer */ + r = tmxr_detach(&com_desc, uptr); /* detach */ + for (i = 0; i < COM_LINES; i++) /* disable rcv */ + com_reset_ln(i); /* reset the line */ + sim_cancel(uptr); /* stop poll, cancel timer */ return r; } @@ -981,11 +1374,14 @@ t_stat com_detach(UNIT *uptr) void com_reset_ln (int32 ln) { sim_cancel(&coml_unit[ln]); - com_sta[ln] = 0; - com_sta[ln] |= COML_REP; /* set pending */ - com_rbuf[ln] = 0; /* clear read buffer */ - com_xbuf[ln] = 0; /* clear write buffer */ + com_stat[ln] = 0; + com_stat[ln] |= COML_REP; /* set pending */ + com_rbuf[ln] = 0; /* clear read buffer */ + com_xbuf[ln] = 0; /* clear write buffer */ com_ldsc[ln].rcve = 0; + com_ldsc[ln].xmte = 0; + coml_unit[ln].CNT = 0; /* no input count */ + com_data[ln].incnt = 0; /* no input data */ return; } diff --git a/SEL32/sel32_con.c b/SEL32/sel32_con.c index e079fac..00477a2 100644 --- a/SEL32/sel32_con.c +++ b/SEL32/sel32_con.c @@ -94,13 +94,13 @@ uint32 outbusy = 0; /* output waiting on timeout */ uint32 inbusy = 0; /* input waiting on timeout */ /* forward definitions */ -uint16 con_preio(UNIT *uptr, uint16 chan); -uint16 con_startcmd(UNIT*, uint16, uint8); +t_stat con_preio(UNIT *uptr, uint16 chan); +t_stat con_startcmd(UNIT*, uint16, uint8); void con_ini(UNIT*, t_bool); t_stat con_srvi(UNIT*); t_stat con_srvo(UNIT*); -uint16 con_haltio(UNIT *); -uint16 con_rschnlio(UNIT *uptr); /* Reset Channel */ +t_stat con_haltio(UNIT *); +t_stat con_rschnlio(UNIT *uptr); /* Reset Channel */ t_stat con_poll(UNIT *); t_stat con_reset(DEVICE *); @@ -113,19 +113,19 @@ MTAB con_mod[] = { }; UNIT con_unit[] = { - {UDATA(&con_srvi, UNIT_CON, 0), 0, UNIT_ADDR(0x7EFC)}, /* Input */ - {UDATA(&con_srvo, UNIT_CON, 0), 0, UNIT_ADDR(0x7EFD)}, /* Output */ + {UDATA(&con_srvi, UNIT_CON, 0), 0, UNIT_ADDR(0x7EFC)}, /* 0 Input */ + {UDATA(&con_srvo, UNIT_CON, 0), 0, UNIT_ADDR(0x7EFD)}, /* 1 Output */ }; DIB con_dib = { - con_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - con_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - con_haltio, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - con_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - NULL, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + con_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + con_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + con_haltio, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + con_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + NULL, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ con_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ con_unit, /* UNIT* units */ /* Pointer to units structure */ con_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -164,31 +164,32 @@ void con_ini(UNIT *uptr, t_bool f) { } /* start a console operation */ -uint16 con_preio(UNIT *uptr, uint16 chan) { +t_stat con_preio(UNIT *uptr, uint16 chan) { DEVICE *dptr = get_dev(uptr); int unit = (uptr - dptr->units); if ((uptr->CMD & CON_MSK) != 0) { /* just return if busy */ - sim_debug(DEBUG_CMD, &con_dev, "con_preio unit=%02x BUSY\n", unit); + sim_debug(DEBUG_CMD, dptr, "con_preio unit=%02x BUSY\n", unit); return SNS_BSY; } - sim_debug(DEBUG_CMD, &con_dev, "con_preio unit=%02x OK\n", unit); + sim_debug(DEBUG_CMD, dptr, "con_preio unit=%02x OK\n", unit); return SCPE_OK; /* good to go */ } /* start an I/O operation */ -uint16 con_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) { +t_stat con_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) { + DEVICE *dptr = uptr->dptr; int unit = (uptr - con_unit); /* unit 0 is read, unit 1 is write */ if ((uptr->CMD & CON_MSK) != 0) { /* is unit busy */ - sim_debug(DEBUG_EXP, &con_dev, - "con_startcmd unit %01x chan %02x cmd %02x BUSY cmd %02x\n", - unit, chan, cmd, uptr->CMD); + sim_debug(DEBUG_EXP, dptr, + "con_startcmd unit %01x chan %02x cmd %02x BUSY cmd %02x uptr %p\n", + unit, chan, cmd, uptr->CMD, uptr); return SNS_BSY; /* yes, return busy */ } - sim_debug(DEBUG_DETAIL, &con_dev, + sim_debug(DEBUG_DETAIL, dptr, "con_startcmd unit %01x chan %02x cmd %02x enter\n", unit, chan, cmd); /* substitute CON_INCH2 for CON_INCH for pprocessing */ @@ -226,7 +227,7 @@ uint16 con_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) { } /* invalid command */ uptr->SNS |= SNS_CMDREJ; /* command rejected */ - sim_debug(DEBUG_EXP, &con_dev, + sim_debug(DEBUG_EXP, dptr, "con_startcmd %04x: Invalid command %02x Sense %02x\n", chan, cmd, uptr->SNS); return SNS_CHNEND|SNS_DEVEND|STATUS_PCHK; @@ -234,6 +235,7 @@ uint16 con_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) { /* Handle output transfers for console */ t_stat con_srvo(UNIT *uptr) { + DEVICE *dptr = uptr->dptr; uint16 chsa = GET_UADDR(uptr->CMD); int unit = (uptr - con_unit); /* unit 0 is read, unit 1 is write */ int cmd = uptr->CMD & CON_MSK; @@ -244,8 +246,9 @@ t_stat con_srvo(UNIT *uptr) { int cnt = 0; uint8 ch; - sim_debug(DEBUG_CMD, &con_dev, - "con_srvo enter CMD %08x chsa %04x cmd = %02x\n", uptr->CMD, chsa, cmd); + sim_debug(DEBUG_CMD, dptr, + "con_srvo enter CMD %08x chsa %04x cmd = %02x uptr %p\n", + uptr->CMD, chsa, cmd, uptr); switch (cmd) { @@ -256,14 +259,14 @@ t_stat con_srvo(UNIT *uptr) { /* if input requested for output device, give error */ uptr->SNS |= SNS_CMDREJ; /* command rejected */ uptr->CMD &= LMASK; /* nothing left, command complete */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvo Read to output device CMD %08x chsa %04x cmd = %02x\n", uptr->CMD, chsa, cmd); chan_end(chsa, SNS_CHNEND|SNS_UNITCHK); /* unit check */ break; case CON_CON: /* 0x1f */ /* Connect, return Data Set ready */ uptr->SNS |= (SNS_DSR|SNS_DCD); /* Data set ready, Data Carrier detected */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvo CON CMD %08x chsa %04x cmd = %02x\n", uptr->CMD, chsa, cmd); uptr->CMD &= ~CON_MSK; /* remove old CMD */ chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* return OK */ @@ -271,7 +274,7 @@ t_stat con_srvo(UNIT *uptr) { case CON_DIS: /* 0x23 */ /* Disconnect has do nothing */ uptr->SNS &= ~(SNS_DSR|SNS_DCD); /* Data set not ready */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvo DIS CMD %08x chsa %04x cmd = %02x\n", uptr->CMD, chsa, cmd); uptr->CMD &= ~CON_MSK; /* remove old CMD */ chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* return OK */ @@ -279,7 +282,7 @@ t_stat con_srvo(UNIT *uptr) { case CON_INCH2: /* 0xf0 */ /* INCH command */ uptr->CMD &= LMASK; /* nothing left, command complete */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvo INCH unit %02x: CMD %08x cmd %02x incnt %02x u4 %02x\n", unit, uptr->CMD, cmd, con_data[unit].incnt, uptr->u4); @@ -288,13 +291,13 @@ t_stat con_srvo(UNIT *uptr) { if ((tstart == SCPE_MEM) || (tstart == SCPE_ARG)) { /* any error */ /* we have error, bail out */ uptr->SNS |= SNS_CMDREJ; - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvo INCH Error unit %02x: CMD %08x cmd %02x incnt %02x u4 %02x\n", unit, uptr->CMD, cmd, con_data[unit].incnt, uptr->u4); chan_end(chsa, SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK); break; } - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvo INCH CMD %08x chsa %04x len %02x inch %06x\n", uptr->CMD, chsa, len, mema); /* WARNING, if SNS_DEVEND is not set, diags fail by looping in CON diag */ chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* return OK */ @@ -302,7 +305,7 @@ t_stat con_srvo(UNIT *uptr) { case CON_NOP: /* 0x03 */ /* NOP has do nothing */ uptr->CMD &= ~CON_MSK; /* remove old CMD */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvo NOP CMD %08x chsa %04x cmd = %02x\n", uptr->CMD, chsa, cmd); chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* return OK */ break; @@ -310,7 +313,7 @@ t_stat con_srvo(UNIT *uptr) { case CON_SNS: /* 0x04 */ /* Sense */ /* value 4 is Data Set Ready */ /* value 5 is Data carrier detected n/u */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvo cmd %04x: Cmd Sense %02x\n", chsa, uptr->SNS); /* value 4 is Data Set Ready */ /* value 5 is Data carrier detected n/u */ @@ -318,7 +321,7 @@ t_stat con_srvo(UNIT *uptr) { if (chan_write_byte(chsa, &ch)) { /* write byte to memory */ /* write error */ cmd = 0; /* no cmd now */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvo write error unit %02x: CMD %08x read %02x u4 %02x ccw_count %02x\n", unit, uptr->CMD, ch, uptr->u4, chp->ccw_count); uptr->CMD &= LMASK; /* nothing left, command complete */ @@ -340,7 +343,7 @@ t_stat con_srvo(UNIT *uptr) { cnt++; /* count chars output */ } /* write is complete, post status */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvo write CMD %08x chsa %04x cmd %02x complete\n", uptr->CMD, chsa, cmd); uptr->CMD &= LMASK; /* nothing left, command complete */ @@ -353,6 +356,7 @@ t_stat con_srvo(UNIT *uptr) { /* Handle input transfers for console */ t_stat con_srvi(UNIT *uptr) { + DEVICE *dptr = uptr->dptr; uint16 chsa = GET_UADDR(uptr->CMD); int unit = (uptr - con_unit); /* unit 0 is read, unit 1 is write */ int cmd = uptr->CMD & CON_MSK; @@ -364,10 +368,6 @@ t_stat con_srvi(UNIT *uptr) { t_stat r; int32 wait_time=10000; - sim_debug(DEBUG_CMD, &con_dev, - "con_srvi enter CMD %08x chsa %04x cmd %02x incnt %02x u4 %02x\n", - uptr->CMD, chsa, cmd, con_data[unit].incnt, uptr->u4); - switch (cmd) { /* if output tried to input device, error */ @@ -376,14 +376,14 @@ t_stat con_srvi(UNIT *uptr) { /* if input requested for output device, give error */ uptr->SNS |= SNS_CMDREJ; /* command rejected */ uptr->CMD &= LMASK; /* nothing left, command complete */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi Write to input device CMD %08x chsa %04x cmd = %02x\n", uptr->CMD, chsa, cmd); chan_end(chsa, SNS_CHNEND|SNS_UNITCHK); /* unit check */ break; case CON_INCH2: /* 0xf0 */ /* INCH command */ uptr->CMD &= LMASK; /* nothing left, command complete */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi INCH unit %02x: CMD %08x cmd %02x incnt %02x u4 %02x\n", unit, uptr->CMD, cmd, con_data[unit].incnt, uptr->u4); @@ -392,7 +392,7 @@ t_stat con_srvi(UNIT *uptr) { if ((tstart == SCPE_MEM) || (tstart == SCPE_ARG)) { /* any error */ /* we have error, bail out */ uptr->SNS |= SNS_CMDREJ; - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi INCH Error unit %02x: CMD %08x cmd %02x incnt %02x u4 %02x\n", unit, uptr->CMD, cmd, con_data[unit].incnt, uptr->u4); chan_end(chsa, SNS_CHNEND|SNS_DEVEND|SNS_UNITCHK); @@ -400,7 +400,7 @@ t_stat con_srvi(UNIT *uptr) { } con_data[unit].incnt = 0; /* buffer empty */ uptr->u4 = 0; /* no I/O yet */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi INCH CMD %08x chsa %04x len %02x inch %06x\n", uptr->CMD, chsa, len, mema); /* WARNING, if SNS_DEVEND is not set, diags fail by looping in CON diag */ chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* return OK */ @@ -409,7 +409,7 @@ t_stat con_srvi(UNIT *uptr) { case CON_NOP: /* 0x03 */ /* NOP has do nothing */ uptr->CMD &= ~CON_MSK; /* remove old CMD */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi NOP CMD %08x chsa %04x cmd = %02x\n", uptr->CMD, chsa, cmd); chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* return OK */ /* drop through to poll input */ @@ -417,7 +417,7 @@ t_stat con_srvi(UNIT *uptr) { case CON_CON: /* 0x1f */ /* Connect, return Data Set ready */ uptr->SNS |= (SNS_DSR|SNS_DCD); /* Data set ready, Data Carrier detected */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi CON CMD %08x chsa %04x cmd = %02x\n", uptr->CMD, chsa, cmd); uptr->CMD &= ~CON_MSK; /* remove old CMD */ chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* return OK */ @@ -425,14 +425,14 @@ t_stat con_srvi(UNIT *uptr) { case CON_DIS: /* 0x23 */ /* Disconnect has do nothing */ uptr->SNS &= ~(SNS_DSR|SNS_DCD); /* Data set not ready */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi DIS CMD %08x chsa %04x cmd = %02x\n", uptr->CMD, chsa, cmd); uptr->CMD &= ~CON_MSK; /* remove old CMD */ chan_end(chsa, SNS_CHNEND|SNS_DEVEND); /* return OK */ break; case CON_SNS: /* 0x04 */ /* Sense */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi cmd %04x: Cmd Sense %02x\n", chsa, uptr->SNS); /* value 4 is Data Set Ready */ /* value 5 is Data carrier detected n/u */ @@ -440,7 +440,7 @@ t_stat con_srvi(UNIT *uptr) { if (chan_write_byte(chsa, &ch)) { /* write byte to memory */ /* write error */ cmd = 0; /* no cmd now */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi write error unit %02x: CMD %08x read %02x u4 %02x ccw_count %02x\n", unit, uptr->CMD, ch, uptr->u4, chp->ccw_count); uptr->CMD &= LMASK; /* nothing left, command complete */ @@ -459,7 +459,7 @@ t_stat con_srvi(UNIT *uptr) { if ((uptr->u4 != con_data[unit].incnt) || /* input empty */ (uptr->CMD & CON_INPUT)) { /* input waiting? */ ch = con_data[unit].ibuff[uptr->u4]; /* get char from read buffer */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi readbuf unit %02x: CMD %08x read %02x incnt %02x u4 %02x len %02x\n", unit, uptr->CMD, ch, con_data[unit].incnt, uptr->u4, chp->ccw_count); @@ -472,7 +472,7 @@ t_stat con_srvi(UNIT *uptr) { if (chan_write_byte(chsa, &ch)) { /* write byte to memory */ /* write error */ cmd = 0; /* no cmd now */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi write error unit %02x: CMD %08x read %02x u4 %02x ccw_count %02x\n", unit, uptr->CMD, ch, uptr->u4, chp->ccw_count); uptr->CMD &= ~CON_MSK; /* remove old CMD */ @@ -483,7 +483,7 @@ t_stat con_srvi(UNIT *uptr) { /* character accepted, bump buffer pointer */ uptr->u4++; /* next char position */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi write to mem unit %02x: CMD %08x read %02x u4 %02x incnt %02x\n", unit, uptr->CMD, ch, uptr->u4, con_data[unit].incnt); @@ -493,7 +493,7 @@ t_stat con_srvi(UNIT *uptr) { /* user want more data? */ if ((test_write_byte_end(chsa)) == 0) { - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi need more unit %02x CMD %08x u4 %02x ccw_count %02x incnt %02x\n", unit, uptr->CMD, uptr->u4, chp->ccw_count, con_data[unit].incnt); /* user wants more, look next time */ @@ -506,10 +506,10 @@ t_stat con_srvi(UNIT *uptr) { break; } /* command is completed */ + sim_debug(DEBUG_CMD, dptr, + "con_srvi read done unit %02x uptr %p CMD %08x read %02x u4 %02x ccw_count %02x incnt %02x\n", + unit, uptr, uptr->CMD, ch, uptr->u4, chp->ccw_count, con_data[unit].incnt); cmd = 0; /* no cmd now */ - sim_debug(DEBUG_CMD, &con_dev, - "con_srvi read done unit %02x CMD %08x read %02x u4 %02x ccw_count %02x incnt %02x\n", - unit, uptr->CMD, ch, uptr->u4, chp->ccw_count, con_data[unit].incnt); uptr->CMD &= LMASK; /* nothing left, command complete */ if (uptr->u4 != con_data[unit].incnt) { /* input empty */ uptr->CMD |= CON_INPUT; /* input still available */ @@ -538,7 +538,7 @@ t_stat con_srvi(UNIT *uptr) { if (ch == '\n') /* convert newline */ ch = '\r'; /* make newline into carriage return */ #endif - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi handle readch unit %02x: CMD %08x read %02x u4 %02x incnt %02x r %x\n", unit, uptr->CMD, ch, uptr->u4, con_data[unit].incnt, r); @@ -550,7 +550,7 @@ t_stat con_srvi(UNIT *uptr) { con_data[unit].incnt = 0; /* reset buffer cnt */ uptr->CMD |= CON_INPUT; /* we have a char available */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi readch unit %02x: CMD %08x read %02x u4 %02x incnt %02x\n", unit, uptr->CMD, ch, uptr->u4, con_data[unit].incnt); sim_activate(uptr, 400); /* do this again */ @@ -577,7 +577,7 @@ t_stat con_srvi(UNIT *uptr) { uptr->CMD &= ~CON_ATAT; /* no @@A input */ sim_putchar('\r'); /* return char */ sim_putchar('\n'); /* line feed char */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi unit %02x: CMD %08x read @@A Console Trap\n", unit, uptr->CMD); uptr->u4 = 0; /* no input count */ con_data[unit].incnt = 0; /* no input data */ @@ -605,7 +605,7 @@ t_stat con_srvi(UNIT *uptr) { con_data[unit].ibuff[con_data[unit].incnt++] = ch; uptr->CMD |= CON_INPUT; /* we have a char available */ - sim_debug(DEBUG_CMD, &con_dev, + sim_debug(DEBUG_CMD, dptr, "con_srvi readch2 unit %02x: CMD %08x read %02x u4 %02x incnt %02x r %x\n", unit, uptr->CMD, ch, uptr->u4, con_data[unit].incnt, r); } @@ -619,7 +619,7 @@ t_stat con_reset(DEVICE *dptr) { } /* Handle rschnlio cmds for console */ -uint16 con_rschnlio(UNIT *uptr) { +t_stat con_rschnlio(UNIT *uptr) { uint16 chsa = GET_UADDR(uptr->CMD); int cmd = uptr->CMD & CON_MSK; con_ini(uptr, 0); /* reset the unit */ @@ -628,7 +628,7 @@ uint16 con_rschnlio(UNIT *uptr) { } /* Handle haltio transfers for console */ -uint16 con_haltio(UNIT *uptr) { +t_stat con_haltio(UNIT *uptr) { uint16 chsa = GET_UADDR(uptr->CMD); int cmd = uptr->CMD & CON_MSK; int unit = (uptr - con_unit); /* unit # 0 is read, 1 is write */ diff --git a/SEL32/sel32_cpu.c b/SEL32/sel32_cpu.c index 110e89a..f19b59d 100644 --- a/SEL32/sel32_cpu.c +++ b/SEL32/sel32_cpu.c @@ -1879,6 +1879,14 @@ wait_loop: //JB return reason; //JB break; /* process */ } +#else + else { + sim_debug(DEBUG_EXP, &cpu_dev, + "Process Event other reason %08x interval %08x\n", + reason, sim_interval); + return reason; + break; /* process */ + } #endif } } @@ -1962,9 +1970,69 @@ wait_loop: goto wait_loop; /* continue waiting */ } +//#define NEW_WAIT +#ifdef NEW_WAIT + /* process IOCL entries that are waiting */ + /* loop through the IOCL ready Q and decrement wait counts */ + if ((int32c = RDYQ_Num())) { + int32 i, rqo = RDYQOUT; + for (i=0; ichan_byte != BUFF_NEXT) { + /* if not BUFF_NEXT, channel has been stopped, do nothing */ + sim_debug(DEBUG_XIO, &cpu_dev, + "scan_chan Bad CPU RDYQ entry for chsa %04x chan_byte %02x\n", + chsa, chp->chan_byte); + /* not BUFF_NEXT, just zero entry */ + continue; /* ignore the entry */ + } + /* state is BUFF_NEXT, see if wait is over */ + if (wait4int) + chp->chan_qwait = 0; /* doing nothing, so do it now */ + if (chp->chan_qwait > 0) /* still waiting? */ + chp->chan_qwait--; /* decrement count */ + /* process 0 wait entry */ + if (chp->chan_qwait == 0) { + int32 stat; + sim_debug(DEBUG_XIO, &cpu_dev, + "scan_chan CPU RDYQ entry for chsa %04x starting byte %02x\n", + chsa, chp->chan_byte); + /* if not BUFF_NEXT, channel has been stopped, do nothing */ + stat = cont_chan(chsa); /* resume the channel program */ + if (stat == SCPE_OK) + sim_debug(DEBUG_XIO, &cpu_dev, + "scan_chan CPU RDYQ entry for chsa %04x processed byte %04x\n", + chsa, chp->chan_byte); + else + sim_debug(DEBUG_XIO, &cpu_dev, + "scan_chan CPU RDYQ entry for chsa %04x processed w/error byte %04x\n", + chsa, chp->chan_byte); + irq_pend = 1; /* start scanning interrupts again */ + continue; + } else + RDYQ_Put(chsa); /* requeue the non-zero entry */ + rqo++; /* next queue entry */ + rqo %= RDYQ_SIZE; /* don't overrun end */ + } + } +#endif /* we get here when not booting */ /* process any pending interrupts */ - if ((irq_pend || wait4int) && (irq_auto == 0)) { /* see if ints are pending */ +#ifdef NEW_WAIT + if ((irq_pend || wait4int) && (RDYQ_Num() == 0) && (irq_auto == 0)) { +#else + if ((irq_pend || wait4int) && (irq_auto == 0)) { +#endif + /* see if ints are pending */ uint32 ilev; uint32 oldstatus = CPUSTATUS; /* keep for retain blocking state */ SPAD[0xf9] = CPUSTATUS; /* save the cpu status in SPAD */ @@ -2076,6 +2144,7 @@ wait_loop: } } +#ifndef NEW_WAIT /* process IOCL entries that are waiting */ /* loop through the IOCL ready Q and decrement wait counts */ if ((int32c = RDYQ_Num())) { @@ -2126,9 +2195,14 @@ wait_loop: rqo %= RDYQ_SIZE; /* don't overrun end */ } } +#endif /* see if in wait instruction */ if (wait4int) { /* keep waiting */ +#ifdef NEW_WAIT + if (RDYQ_Num()) + goto wait_loop; /* continue waiting */ +#endif /* tell simh we will be waiting */ sim_idle(TMR_RTC, 1); /* wait for clock tick */ irq_pend = 1; /* start scanning interrupts again */ @@ -2651,9 +2725,11 @@ exec: "Starting WAIT mode %08x\n", (uint32)result); } wait4int = 1; /* show we are waiting for interrupt */ +#ifndef NEW_WAIT /* tell simh we will be waiting */ sim_idle(TMR_RTC, 0); /* wait for next pending device event */ irq_pend = 1; /* start scanning interrupts again */ +#endif i_flags |= BT; /* keep PC from being incremented while waiting */ break; case 0x2: /* NOP */ diff --git a/SEL32/sel32_defs.h b/SEL32/sel32_defs.h index d0d08e5..64d40e3 100644 --- a/SEL32/sel32_defs.h +++ b/SEL32/sel32_defs.h @@ -252,21 +252,21 @@ extern int32 IOCLQ_Num(IOCLQ *qptr); typedef struct dib { /* Pre start I/O operation */ - uint16 (*pre_io)(UNIT *uptr, uint16 chan); + t_stat (*pre_io)(UNIT *uptr, uint16 chan); /* Start a channel command SIO */ - uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd); + t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd); /* Halt I/O HIO */ - uint16 (*halt_io)(UNIT *uptr); /* Halt I/O */ + t_stat (*halt_io)(UNIT *uptr); /* Halt I/O */ /* Test I/O STOPIO */ - uint16 (*stop_io)(UNIT *uptr); /* Stop I/O */ + t_stat (*stop_io)(UNIT *uptr); /* Stop I/O */ /* Test I/O TESTIO */ - uint16 (*test_io)(UNIT *uptr); /* Test I/O */ + t_stat (*test_io)(UNIT *uptr); /* Test I/O */ /* Reset Controller RSCTL */ - uint16 (*rsctl_io)(UNIT *uptr); /* Reset Controller */ + t_stat (*rsctl_io)(UNIT *uptr); /* Reset Controller */ /* Reset Controller RSCHNL */ - uint16 (*rschnl_io)(UNIT *uptr); /* Reset Channel */ + t_stat (*rschnl_io)(UNIT *uptr); /* Reset Channel */ /* Post I/O processing */ - uint16 (*iocl_io)(CHANP *chp, int32 tic_ok); /* IOCL processing */ + t_stat (*iocl_io)(CHANP *chp, int32 tic_ok); /* IOCL processing */ /* Controller init */ void (*dev_ini)(UNIT *, t_bool); /* init function */ UNIT *units; /* Pointer to units structure */ diff --git a/SEL32/sel32_disk.c b/SEL32/sel32_disk.c index 585e538..43a6f47 100644 --- a/SEL32/sel32_disk.c +++ b/SEL32/sel32_disk.c @@ -385,14 +385,14 @@ disk_type[] = {NULL, 0} }; -uint16 disk_preio(UNIT *uptr, uint16 chan) ; -uint16 disk_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) ; -uint16 disk_haltio(UNIT *uptr); -uint16 disk_iocl(CHANP *chp, int32 tic_ok); +t_stat disk_preio(UNIT *uptr, uint16 chan) ; +t_stat disk_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) ; +t_stat disk_haltio(UNIT *uptr); +t_stat disk_iocl(CHANP *chp, int32 tic_ok); t_stat disk_srv(UNIT *uptr); t_stat disk_boot(int32 unitnum, DEVICE *dptr); void disk_ini(UNIT *, t_bool); -uint16 disk_rschnlio(UNIT *uptr); +t_stat disk_rschnlio(UNIT *uptr); t_stat disk_reset(DEVICE *); t_stat disk_attach(UNIT *, CONST char *); t_stat disk_detach(UNIT *); @@ -447,14 +447,14 @@ UNIT dda_unit[] = { }; DIB dda_dib = { - disk_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - disk_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - disk_haltio, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - disk_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - disk_iocl, /* uint16 (*iocl_io)(CHANP *chp, int32 tik_ok)) */ /* Process IOCL */ + disk_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + disk_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + disk_haltio, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + disk_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + disk_iocl, /* t_stat (*iocl_io)(CHANP *chp, int32 tik_ok)) */ /* Process IOCL */ disk_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ dda_unit, /* UNIT* units */ /* Pointer to units structure */ dda_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -493,14 +493,14 @@ UNIT ddb_unit[] = { }; DIB ddb_dib = { - disk_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - disk_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - disk_haltio, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - disk_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - disk_iocl, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + disk_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + disk_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + disk_haltio, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + disk_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + disk_iocl, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ disk_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ ddb_unit, /* UNIT* units */ /* Pointer to units structure */ ddb_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -703,7 +703,7 @@ uint32 get_dmatrk(UNIT *uptr, uint32 star, uint8 buf[]) } /* start a disk operation */ -uint16 disk_preio(UNIT *uptr, uint16 chan) +t_stat disk_preio(UNIT *uptr, uint16 chan) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->CMD); @@ -721,7 +721,7 @@ uint16 disk_preio(UNIT *uptr, uint16 chan) /* load in the IOCD and process the commands */ /* return = 0 OK */ /* return = 1 error, chan_status will have reason */ -uint16 disk_iocl(CHANP *chp, int32 tic_ok) +t_stat disk_iocl(CHANP *chp, int32 tic_ok) { uint32 word1 = 0; uint32 word2 = 0; @@ -969,7 +969,7 @@ loop: return 0; /* good return */ } -uint16 disk_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) +t_stat disk_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) { uint16 chsa = GET_UADDR(uptr->CMD); DEVICE *dptr = get_dev(uptr); @@ -1074,7 +1074,7 @@ uint16 disk_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) } /* Handle haltio transfers for disk */ -uint16 disk_haltio(UNIT *uptr) { +t_stat disk_haltio(UNIT *uptr) { uint16 chsa = GET_UADDR(uptr->CMD); DEVICE *dptr = get_dev(uptr); int cmd = uptr->CMD & DSK_CMDMSK; @@ -2664,7 +2664,7 @@ iha_error: } /* handle rschnlio cmds for disk */ -uint16 disk_rschnlio(UNIT *uptr) { +t_stat disk_rschnlio(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->CMD); int cmd = uptr->CMD & DSK_CMDMSK; diff --git a/SEL32/sel32_ec.c b/SEL32/sel32_ec.c index 4742f1f..d891392 100644 --- a/SEL32/sel32_ec.c +++ b/SEL32/sel32_ec.c @@ -204,7 +204,7 @@ struct ec_device { int amc; /* Recieve all multicast packets */ uint32 rx_count; /* Packets received */ uint32 tx_count; /* Packets sent */ - uint16 drop_cnt; /* Packets dropped */ + t_stat drop_cnt; /* Packets dropped */ int r_pkt; /* Packet pending */ int poll; /* Need to poll receiver */ int lp_rdy; /* Loop back packet ready */ @@ -224,17 +224,17 @@ static CONST ETH_MAC broadcast_ethaddr = {0xff,0xff,0xff,0xff,0xff,0xff}; CHANP ec_chp[NUM_UNITS_ETHER] = {0}; /* forward definitions */ -uint16 ec_preio(UNIT *uptr, uint16 chan); -uint16 ec_startcmd(UNIT *uptr, uint16 chan, uint8 cmd); +t_stat ec_preio(UNIT *uptr, uint16 chan); +t_stat ec_startcmd(UNIT *uptr, uint16 chan, uint8 cmd); t_stat ec_rec_srv(UNIT *uptr); t_stat ec_srv(UNIT *uptr); -uint16 ec_haltio(UNIT *uptr); -uint16 ec_iocl(CHANP *chp, int32 tic_ok); +t_stat ec_haltio(UNIT *uptr); +t_stat ec_iocl(CHANP *chp, int32 tic_ok); void ec_packet_debug(struct ec_device *ec, const char *action, ETH_PACK *packet); t_stat ec_reset (DEVICE *dptr); void ec_ini(UNIT *, t_bool); -uint16 ec_rsctrl(UNIT *uptr); -uint16 ec_rschnlio(UNIT *uptr); +t_stat ec_rsctrl(UNIT *uptr); +t_stat ec_rschnlio(UNIT *uptr); t_stat ec_show_mac (FILE* st, UNIT* uptr, int32 val, CONST void* desc); t_stat ec_set_mac (UNIT* uptr, int32 val, CONST char* cptr, void* desc); t_stat ec_show_mode (FILE* st, UNIT* uptr, int32 val, CONST void* desc); @@ -278,14 +278,14 @@ UNIT ec_unit[] = { }; DIB ec_dib = { - ec_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - ec_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - ec_haltio, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - ec_rsctrl, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - ec_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - ec_iocl, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + ec_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + ec_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + ec_haltio, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + ec_rsctrl, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + ec_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + ec_iocl, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ ec_ini, /* void (*dev_ini)(UNIT *uptr) */ /* init function */ ec_unit, /* UNIT *units */ /* Pointer to units structure */ ec_chp, /* CHANP *chan_prg */ /* Pointer to chan_prg structure */ @@ -342,7 +342,7 @@ DEVICE ec_dev = { /* load in the IOCD and process the commands */ /* return = 0 OK */ /* return = 1 error, chan_status will have reason */ -uint16 ec_iocl(CHANP *chp, int32 tic_ok) +t_stat ec_iocl(CHANP *chp, int32 tic_ok) { uint32 word1 = 0; uint32 word2 = 0; @@ -664,7 +664,7 @@ loop: } /* start an ethernet operation */ -uint16 ec_preio(UNIT *uptr, uint16 chan) { +t_stat ec_preio(UNIT *uptr, uint16 chan) { DEVICE *dptr = get_dev(uptr); int unit = (uptr - dptr->units); uint16 chsa = GET_UADDR(uptr->CMD); @@ -683,7 +683,7 @@ uint16 ec_preio(UNIT *uptr, uint16 chan) { } /* Start ethernet command */ -uint16 ec_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) +t_stat ec_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->CMD); @@ -1350,7 +1350,7 @@ wr_end: } /* Handle haltio transfers for ethernet */ -uint16 ec_haltio(UNIT *uptr) { +t_stat ec_haltio(UNIT *uptr) { uint16 chsa = GET_UADDR(uptr->CMD); DEVICE *dptr = get_dev(uptr); int cmd = uptr->CMD & EC_CMDMSK; @@ -1416,7 +1416,7 @@ void ec_ini(UNIT *uptr, t_bool f) } /* handle reset controller cmds for Ethernet */ -uint16 ec_rsctrl(UNIT *uptr) { +t_stat ec_rsctrl(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->CMD); int cmd = uptr->CMD & EC_CMDMSK; @@ -1434,7 +1434,7 @@ uint16 ec_rsctrl(UNIT *uptr) { } /* handle reset channel cmds for Ethernet */ -uint16 ec_rschnlio(UNIT *uptr) { +t_stat ec_rschnlio(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->CMD); int cmd = uptr->CMD & EC_CMDMSK; diff --git a/SEL32/sel32_hsdp.c b/SEL32/sel32_hsdp.c index 736e79e..7cdf061 100644 --- a/SEL32/sel32_hsdp.c +++ b/SEL32/sel32_hsdp.c @@ -518,11 +518,11 @@ hsdp_type[] = {NULL} }; -uint16 hsdp_preio(UNIT *uptr, uint16 chan) ; -uint16 hsdp_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) ; -uint16 hsdp_haltio(UNIT *uptr); -uint16 hsdp_rsctl(UNIT *uptr); -uint16 hsdp_iocl(CHANP *chp, int32 tic_ok); +t_stat hsdp_preio(UNIT *uptr, uint16 chan) ; +t_stat hsdp_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) ; +t_stat hsdp_haltio(UNIT *uptr); +t_stat hsdp_rsctl(UNIT *uptr); +t_stat hsdp_iocl(CHANP *chp, int32 tic_ok); t_stat hsdp_srv(UNIT *); t_stat hsdp_boot(int32 unitnum, DEVICE *); void hsdp_ini(UNIT *, t_bool); @@ -583,14 +583,14 @@ UNIT dpa_unit[] = { }; DIB dpa_dib = { - hsdp_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - hsdp_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - hsdp_haltio, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - hsdp_haltio, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - hsdp_rsctl, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - NULL, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - hsdp_iocl, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + hsdp_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + hsdp_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + hsdp_haltio, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + hsdp_haltio, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + hsdp_rsctl, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + NULL, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + hsdp_iocl, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ hsdp_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ dpa_unit, /* UNIT* units */ /* Pointer to units structure */ dpa_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -632,14 +632,14 @@ UNIT dpb_unit[] = { DIB dpb_dib = { - hsdp_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - hsdp_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - hsdp_haltio, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - hsdp_haltio, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - hsdp_rsctl, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - NULL, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - hsdp_iocl, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + hsdp_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + hsdp_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + hsdp_haltio, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + hsdp_haltio, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + hsdp_rsctl, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + NULL, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + hsdp_iocl, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ hsdp_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ dpb_unit, /* UNIT* units */ /* Pointer to units structure */ dpb_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -825,7 +825,7 @@ uint32 get_dpatrk(UNIT *uptr, uint32 star, uint8 buf[]) } /* start a disk operation */ -uint16 hsdp_preio(UNIT *uptr, uint16 chan) +t_stat hsdp_preio(UNIT *uptr, uint16 chan) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->CMD); @@ -852,7 +852,7 @@ uint16 hsdp_preio(UNIT *uptr, uint16 chan) /* load in the IOCD and process the commands */ /* return = 0 OK */ /* return = 1 error, chan_status will have reason */ -uint16 hsdp_iocl(CHANP *chp, int32 tic_ok) +t_stat hsdp_iocl(CHANP *chp, int32 tic_ok) { uint32 word1 = 0; uint32 word2 = 0; @@ -1091,7 +1091,7 @@ loop: return 0; /* good return */ } -uint16 hsdp_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) +t_stat hsdp_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) { uint16 chsa = GET_UADDR(uptr->CMD); DEVICE *dptr = get_dev(uptr); @@ -1189,7 +1189,7 @@ uint16 hsdp_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) } /* Handle haltio transfers for disk */ -uint16 hsdp_haltio(UNIT *uptr) { +t_stat hsdp_haltio(UNIT *uptr) { uint16 chsa = GET_UADDR(uptr->CMD); DEVICE *dptr = get_dev(uptr); int cmd = uptr->CMD & DSK_CMDMSK; @@ -1224,7 +1224,7 @@ uint16 hsdp_haltio(UNIT *uptr) { } /* Handle rsctl command for disk */ -uint16 hsdp_rsctl(UNIT *uptr) { +t_stat hsdp_rsctl(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->CMD); int cmd = uptr->CMD & DSK_CMDMSK; @@ -2961,7 +2961,7 @@ void hsdp_ini(UNIT *uptr, t_bool f) } /* handle rschnlio cmds for hsdp */ -uint16 hsdp_rschnlio(UNIT *uptr) { +t_stat hsdp_rschnlio(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->CMD); int cmd = uptr->CMD & DSK_CMDMSK; diff --git a/SEL32/sel32_iop.c b/SEL32/sel32_iop.c index 4335464..d1a6552 100644 --- a/SEL32/sel32_iop.c +++ b/SEL32/sel32_iop.c @@ -38,10 +38,10 @@ #define UNIT_IOP UNIT_IDLE | UNIT_DISABLE /* forward definitions */ -uint16 iop_preio(UNIT *uptr, uint16 chan); -uint16 iop_startcmd(UNIT *uptr, uint16 chan, uint8 cmd); +t_stat iop_preio(UNIT *uptr, uint16 chan); +t_stat iop_startcmd(UNIT *uptr, uint16 chan, uint8 cmd); void iop_ini(UNIT *uptr, t_bool f); -uint16 iop_rschnlio(UNIT *uptr); +t_stat iop_rschnlio(UNIT *uptr); t_stat iop_srv(UNIT *uptr); t_stat iop_reset(DEVICE *dptr); t_stat iop_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -100,14 +100,14 @@ UNIT iop_unit[] = { }; DIB iop_dib = { - iop_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - iop_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command SIO */ - NULL, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O HIO */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O HIO */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O TIO */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - iop_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - NULL, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + iop_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + iop_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command SIO */ + NULL, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O HIO */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O HIO */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O TIO */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + iop_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + NULL, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ iop_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ iop_unit, /* UNIT* units */ /* Pointer to units structure */ iop_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -145,7 +145,7 @@ void iop_ini(UNIT *uptr, t_bool f) } /* handle rschnlio cmds for iop */ -uint16 iop_rschnlio(UNIT *uptr) { +t_stat iop_rschnlio(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->u3); int cmd = uptr->u3 & IOP_MSK; @@ -157,7 +157,7 @@ uint16 iop_rschnlio(UNIT *uptr) { } /* start an iop operation */ -uint16 iop_preio(UNIT *uptr, uint16 chan) { +t_stat iop_preio(UNIT *uptr, uint16 chan) { DEVICE *dptr = get_dev(uptr); int unit = (uptr - dptr->units); uint16 chsa = GET_UADDR(uptr->u3); @@ -176,7 +176,7 @@ uint16 iop_preio(UNIT *uptr, uint16 chan) { } /* start an I/O operation */ -uint16 iop_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) +t_stat iop_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) { sim_debug(DEBUG_CMD, &iop_dev, "IOP startcmd %02x controller/device %04x\n", diff --git a/SEL32/sel32_lpr.c b/SEL32/sel32_lpr.c index 277d848..d8fd18c 100644 --- a/SEL32/sel32_lpr.c +++ b/SEL32/sel32_lpr.c @@ -141,10 +141,10 @@ struct _lpr_data struct _lpr_data lpr_data[NUM_DEVS_LPR]; /* forward definitions */ -uint16 lpr_preio(UNIT *uptr, uint16 chan); -uint16 lpr_startcmd(UNIT *, uint16, uint8); +t_stat lpr_preio(UNIT *uptr, uint16 chan); +t_stat lpr_startcmd(UNIT *, uint16, uint8); void lpr_ini(UNIT *, t_bool); -uint16 lpr_rschnlio(UNIT *uptr); +t_stat lpr_rschnlio(UNIT *uptr); t_stat lpr_srv(UNIT *); t_stat lpr_reset(DEVICE *); t_stat lpr_attach(UNIT *, CONST char *); @@ -172,14 +172,14 @@ UNIT lpr_unit[] = { /* Device Information Block */ DIB lpr_dib = { - lpr_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - lpr_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - NULL, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - lpr_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - NULL, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + lpr_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + lpr_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + NULL, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + lpr_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + NULL, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ lpr_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ lpr_unit, /* UNIT* units */ /* Pointer to units structure */ lpr_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -210,7 +210,7 @@ void lpr_ini(UNIT *uptr, t_bool f) { } /* handle rschnlio cmds for lpr */ -uint16 lpr_rschnlio(UNIT *uptr) { +t_stat lpr_rschnlio(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); /* get device pointer */ uint16 chsa = GET_UADDR(uptr->CMD); int cmd = uptr->CMD & LPR_CMDMSK; @@ -222,7 +222,7 @@ uint16 lpr_rschnlio(UNIT *uptr) { } /* start a line printer operation */ -uint16 lpr_preio(UNIT *uptr, uint16 chan) { +t_stat lpr_preio(UNIT *uptr, uint16 chan) { DEVICE *dptr = get_dev(uptr); int unit = (uptr - dptr->units); uint16 chsa = GET_UADDR(uptr->CMD); @@ -241,7 +241,7 @@ uint16 lpr_preio(UNIT *uptr, uint16 chan) { } /* start an I/O operation */ -uint16 lpr_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) +t_stat lpr_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) { DEVICE *dptr = get_dev(uptr); /* get device pointer */ diff --git a/SEL32/sel32_mfp.c b/SEL32/sel32_mfp.c index d076415..3f2f366 100644 --- a/SEL32/sel32_mfp.c +++ b/SEL32/sel32_mfp.c @@ -39,10 +39,10 @@ #define UNIT_MFP UNIT_IDLE | UNIT_DISABLE /* forward definitions */ -uint16 mfp_preio(UNIT *uptr, uint16 chan); -uint16 mfp_startcmd(UNIT *uptr, uint16 chan, uint8 cmd); +t_stat mfp_preio(UNIT *uptr, uint16 chan); +t_stat mfp_startcmd(UNIT *uptr, uint16 chan, uint8 cmd); void mfp_ini(UNIT *uptr, t_bool f); -uint16 mfp_rschnlio(UNIT *uptr); +t_stat mfp_rschnlio(UNIT *uptr); t_stat mfp_srv(UNIT *uptr); t_stat mfp_reset(DEVICE *dptr); t_stat mfp_help(FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); @@ -104,14 +104,14 @@ UNIT mfp_unit[] = { //DIB mfp_dib = {NULL, mfp_startcmd, NULL, NULL, NULL, mfp_ini, mfp_unit, mfp_chp, NUM_UNITS_MFP, 0xff, 0x7600,0,0,0}; DIB mfp_dib = { - mfp_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - mfp_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - NULL, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O HIO */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O HIO */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O TIO */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - mfp_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - NULL, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + mfp_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + mfp_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + NULL, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O HIO */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O HIO */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O TIO */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + mfp_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + NULL, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ mfp_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ mfp_unit, /* UNIT* units */ /* Pointer to units structure */ mfp_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -149,7 +149,7 @@ void mfp_ini(UNIT *uptr, t_bool f) } /* handle rschnlio cmds for disk */ -uint16 mfp_rschnlio(UNIT *uptr) { +t_stat mfp_rschnlio(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->u3); int cmd = uptr->u3 & MFP_MSK; @@ -161,7 +161,7 @@ uint16 mfp_rschnlio(UNIT *uptr) { } /* start an mfp operation */ -uint16 mfp_preio(UNIT *uptr, uint16 chan) { +t_stat mfp_preio(UNIT *uptr, uint16 chan) { DEVICE *dptr = get_dev(uptr); int unit = (uptr - dptr->units); uint16 chsa = GET_UADDR(uptr->u3); @@ -180,7 +180,7 @@ uint16 mfp_preio(UNIT *uptr, uint16 chan) { } /* start an I/O operation */ -uint16 mfp_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) +t_stat mfp_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) { sim_debug(DEBUG_CMD, &mfp_dev, "MFP startcmd %02x controller/device %04x\n", diff --git a/SEL32/sel32_mt.c b/SEL32/sel32_mt.c index e2aa2e9..33100c5 100644 --- a/SEL32/sel32_mt.c +++ b/SEL32/sel32_mt.c @@ -153,12 +153,12 @@ #define CLR_BUF(u) u->hwmark = 0xFFFFFFFF /* forward definitions */ -uint16 mt_preio(UNIT *uptr, uint16 chan); -uint16 mt_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) ; +t_stat mt_preio(UNIT *uptr, uint16 chan); +t_stat mt_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) ; t_stat mt_srv(UNIT *uptr); t_stat mt_boot(int32 unitnum, DEVICE *dptr); void mt_ini(UNIT *uptr, t_bool); -uint16 mt_rschnlio(UNIT *uptr); +t_stat mt_rschnlio(UNIT *uptr); t_stat mt_reset(DEVICE *dptr); t_stat mt_attach(UNIT *uptr, CONST char *); t_stat mt_detach(UNIT *uptr); @@ -298,14 +298,14 @@ UNIT mta_unit[] = { CHANP mta_chp[NUM_UNITS_MT] = {0}; DIB mta_dib = { - mt_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - mt_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - NULL, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - mt_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - NULL, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + mt_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + mt_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + NULL, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + mt_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + NULL, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ mt_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ mta_unit, /* UNIT* units */ /* Pointer to units structure */ mta_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -346,14 +346,14 @@ UNIT mtb_unit[] = { /* device information block */ DIB mtb_dib = { - mt_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - mt_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - NULL, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - mt_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - NULL, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + mt_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + mt_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + NULL, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + mt_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + NULL, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ mt_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ mtb_unit, /* UNIT* units */ /* Pointer to units structure */ mtb_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -377,7 +377,7 @@ DEVICE mtb_dev = { #endif /* start a tape operation */ -uint16 mt_preio(UNIT *uptr, uint16 chan) { +t_stat mt_preio(UNIT *uptr, uint16 chan) { DEVICE *dptr = get_dev(uptr); int unit = (uptr - dptr->units); uint16 chsa = GET_UADDR(uptr->CMD); @@ -403,7 +403,7 @@ uint16 mt_preio(UNIT *uptr, uint16 chan) { } /* start an I/O operation */ -uint16 mt_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) +t_stat mt_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) { uint16 chsa = GET_UADDR(uptr->CMD); DEVICE *dptr = get_dev(uptr); @@ -1172,7 +1172,7 @@ void mt_ini(UNIT *uptr, t_bool f) } /* handle rschnlio cmds for tape */ -uint16 mt_rschnlio(UNIT *uptr) { +t_stat mt_rschnlio(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->CMD); int cmd = uptr->CMD & MT_CMDMSK; diff --git a/SEL32/sel32_scfi.c b/SEL32/sel32_scfi.c index 4e34d9a..0c21774 100644 --- a/SEL32/sel32_scfi.c +++ b/SEL32/sel32_scfi.c @@ -267,14 +267,14 @@ scfi_type[] = {NULL, 0} }; -uint16 scfi_preio(UNIT *uptr, uint16 chan); -uint16 scfi_startcmd(UNIT *uptr, uint16 chan, uint8 cmd); -uint16 scfi_haltio(UNIT *uptr); -uint16 scfi_iocl(CHANP *chp, int32 tic_ok); +t_stat scfi_preio(UNIT *uptr, uint16 chan); +t_stat scfi_startcmd(UNIT *uptr, uint16 chan, uint8 cmd); +t_stat scfi_haltio(UNIT *uptr); +t_stat scfi_iocl(CHANP *chp, int32 tic_ok); t_stat scfi_srv(UNIT *uptr); t_stat scfi_boot(int32 unitnum, DEVICE *dptr); void scfi_ini(UNIT *, t_bool); -uint16 scfi_rschnlio(UNIT *uptr); +t_stat scfi_rschnlio(UNIT *uptr); t_stat scfi_reset(DEVICE *); t_stat scfi_attach(UNIT *, CONST char *); t_stat scfi_detach(UNIT *); @@ -313,14 +313,14 @@ UNIT sda_unit[] = { }; DIB sda_dib = { - scfi_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - scfi_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - scfi_haltio, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - scfi_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - scfi_iocl, /* uint16 (*iocl_io)(CHANP *chp, int32 tik_ok)) */ /* Process IOCL */ + scfi_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + scfi_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + scfi_haltio, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + scfi_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + scfi_iocl, /* t_stat (*iocl_io)(CHANP *chp, int32 tik_ok)) */ /* Process IOCL */ scfi_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ sda_unit, /* UNIT* units */ /* Pointer to units structure */ sda_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -359,14 +359,14 @@ UNIT sdb_unit[] = { }; DIB sdb_dib = { - scfi_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - scfi_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - scfi_haltio, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - scfi_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - scfi_iocl, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + scfi_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + scfi_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + scfi_haltio, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + scfi_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + scfi_iocl, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ scfi_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ sdb_unit, /* UNIT* units */ /* Pointer to units structure */ sdb_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -402,7 +402,7 @@ uint32 scfisec2star(uint32 daddr, int type) } /* start a disk operation */ -uint16 scfi_preio(UNIT *uptr, uint16 chan) +t_stat scfi_preio(UNIT *uptr, uint16 chan) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->CMD); @@ -422,7 +422,7 @@ uint16 scfi_preio(UNIT *uptr, uint16 chan) /* load in the IOCD and process the commands */ /* return = 0 OK */ /* return = 1 error, chan_status will have reason */ -uint16 scfi_iocl(CHANP *chp, int32 tic_ok) +t_stat scfi_iocl(CHANP *chp, int32 tic_ok) { uint32 word1 = 0; uint32 word2 = 0; @@ -665,7 +665,7 @@ loop: return 0; /* good return */ } -uint16 scfi_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) +t_stat scfi_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) { uint16 chsa = GET_UADDR(uptr->CMD); DEVICE *dptr = get_dev(uptr); @@ -760,7 +760,7 @@ uint16 scfi_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) } /* Handle haltio transfers for disk */ -uint16 scfi_haltio(UNIT *uptr) { +t_stat scfi_haltio(UNIT *uptr) { uint16 chsa = GET_UADDR(uptr->CMD); DEVICE *dptr = get_dev(uptr); int cmd = uptr->CMD & DSK_CMDMSK; @@ -1484,7 +1484,7 @@ t_stat scfi_srv(UNIT *uptr) } /* handle rschnlio cmds for disk */ -uint16 scfi_rschnlio(UNIT *uptr) { +t_stat scfi_rschnlio(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->CMD); int cmd = uptr->CMD & DSK_CMDMSK; diff --git a/SEL32/sel32_scsi.c b/SEL32/sel32_scsi.c index c8791fc..15975a6 100644 --- a/SEL32/sel32_scsi.c +++ b/SEL32/sel32_scsi.c @@ -283,13 +283,13 @@ scsi_type[] = {NULL, 0} }; -uint16 scsi_preio(UNIT *uptr, uint16 chan); -uint16 scsi_startcmd(UNIT *uptr, uint16 chan, uint8 cmd); -uint16 scsi_haltio(UNIT *uptr); +t_stat scsi_preio(UNIT *uptr, uint16 chan); +t_stat scsi_startcmd(UNIT *uptr, uint16 chan, uint8 cmd); +t_stat scsi_haltio(UNIT *uptr); t_stat scsi_srv(UNIT *); t_stat scsi_boot(int32 unitnum, DEVICE *); void scsi_ini(UNIT *, t_bool); -uint16 scsi_rschnlio(UNIT *uptr); +t_stat scsi_rschnlio(UNIT *uptr); t_stat scsi_reset(DEVICE *); t_stat scsi_attach(UNIT *, CONST char *); t_stat scsi_detach(UNIT *); @@ -321,14 +321,14 @@ UNIT sba_unit[] = { }; DIB sba_dib = { - scsi_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - scsi_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - NULL, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - scsi_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - NULL, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + scsi_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + scsi_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + NULL, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + scsi_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + NULL, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ scsi_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ sba_unit, /* UNIT* units */ /* Pointer to units structure */ sba_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -365,14 +365,14 @@ UNIT sbb_unit[] = { //scsi_ini, sdb_unit, sdb_chp, NUM_UNITS_SCSI, 0x0f, 0x0c00, 0, 0, 0}; DIB sbb_dib = { - scsi_preio, /* uint16 (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ - scsi_startcmd, /* uint16 (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ - NULL, /* uint16 (*halt_io)(UNIT *uptr) */ /* Halt I/O */ - NULL, /* uint16 (*stop_io)(UNIT *uptr) */ /* Stop I/O */ - NULL, /* uint16 (*test_io)(UNIT *uptr) */ /* Test I/O */ - NULL, /* uint16 (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ - scsi_rschnlio, /* uint16 (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ - NULL, /* uint16 (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ + scsi_preio, /* t_stat (*pre_io)(UNIT *uptr, uint16 chan)*/ /* Pre Start I/O */ + scsi_startcmd, /* t_stat (*start_cmd)(UNIT *uptr, uint16 chan, uint8 cmd)*/ /* Start command */ + NULL, /* t_stat (*halt_io)(UNIT *uptr) */ /* Halt I/O */ + NULL, /* t_stat (*stop_io)(UNIT *uptr) */ /* Stop I/O */ + NULL, /* t_stat (*test_io)(UNIT *uptr) */ /* Test I/O */ + NULL, /* t_stat (*rsctl_io)(UNIT *uptr) */ /* Reset Controller */ + scsi_rschnlio, /* t_stat (*rschnl_io)(UNIT *uptr) */ /* Reset Channel */ + NULL, /* t_stat (*iocl_io)(CHANP *chp, int32 tic_ok)) */ /* Process IOCL */ scsi_ini, /* void (*dev_ini)(UNIT *, t_bool) */ /* init function */ sbb_unit, /* UNIT* units */ /* Pointer to units structure */ sbb_chp, /* CHANP* chan_prg */ /* Pointer to chan_prg structure */ @@ -408,7 +408,7 @@ uint32 scsisec2star(uint32 daddr, int type) } /* start a disk operation */ -uint16 scsi_preio(UNIT *uptr, uint16 chan) +t_stat scsi_preio(UNIT *uptr, uint16 chan) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->CMD); @@ -422,7 +422,7 @@ uint16 scsi_preio(UNIT *uptr, uint16 chan) return 0; /* good to go */ } -uint16 scsi_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) +t_stat scsi_startcmd(UNIT *uptr, uint16 chan, uint8 cmd) { uint16 chsa = GET_UADDR(uptr->CMD); DEVICE *dptr = get_dev(uptr); @@ -1326,7 +1326,7 @@ void scsi_ini(UNIT *uptr, t_bool f) } /* handle rschnlio cmds for scsi */ -uint16 scsi_rschnlio(UNIT *uptr) { +t_stat scsi_rschnlio(UNIT *uptr) { DEVICE *dptr = get_dev(uptr); uint16 chsa = GET_UADDR(uptr->CMD); int cmd = uptr->CMD & DSK_CMDMSK; diff --git a/SEL32/taptools/tap2disk.c b/SEL32/taptools/tap2disk.c new file mode 100644 index 0000000..2d504af --- /dev/null +++ b/SEL32/taptools/tap2disk.c @@ -0,0 +1,234 @@ +/* + * tap2disk.c + * + * This program scans a metatape file and copies a file until EOF is found. + * input - specified filename + * output - specified filename + */ + +#include +#include +#include +#include +#include +#include + +int filen = 1; +int EOFcnt = 0; +int count=0, lcount=0; +int size=0, tsize=0; +int oldsize, newsize; +FILE *outfp; +int inp; +int ln; + +/* get a line of input. */ +int getloi(char *s, int lim) +{ + int c, i; + int n1, n2, hc, tc, n; + + /* read the byte count in 32 bit word as header */ + n1 = read(inp, (char *)(&hc), (size_t)4); + if (n1 <= 0) { + hc = -1; /* at EOM on disk file */ + return hc; /* return EOM */ + } + + /* check for EOF & EOM on tape data */ + if (hc & 0xffff0000) { /* check for garbage, assume EOF */ + hc = -1; /* at EOM on disk file */ + return hc; /* return EOM */ + } + + /* check for EOF & EOM on tape data */ + if (hc == 0) { + /* we are at tape EOF */ + if (++EOFcnt < 2) { /* if 1st EOF, print32_t file info */ + if (ln > 0) { + if (count - lcount > 1) + fprintf(stderr, "file %d: records %d to %d: size %d\n", filen, lcount, count - 1, ln); + else + fprintf(stderr, "file %d: record %d: size %d\n", filen, lcount, ln); + } + fprintf(stderr, "file %d: EOF after %d records: %d bytes\n\n", filen, count, size); + filen++; /* set next file number */ + } else { + fprintf(stderr, "second EOF after %d files: %d bytes\n", filen-1, tsize+size); + } + count = 0; /* file record count back to zero */ + lcount = 0; /* last record count back to zero */ + tsize += size; /* add to total tape size */ + size = 0; /* file size back to zero */ + ln = -1; /* set ln to -1 showing we are at EOF */ + return 0; /* return EOF on tape data */ + } + + /* check for EOM */ + if (hc == -1) { + return -1; /* at EOM on disk file */ + } + + /* read the data */ + n = read(inp, s, (size_t)hc); + if (n <= 0) + return -1; /* at EOM on disk file */ + + /* if odd byte record, read extra byte and throw it away */ + if (n & 0x1) { + n2 = read(inp, (char *)(&tc), (size_t)1); + if (n2 <= 0) + return -1; /* at EOM on disk file */ + } + + /* read the byte count in 32 bit word as trailer */ + n2 = read(inp, (char *)(&tc), (size_t)4); + if (n2 <= 0) + return -1; /* at EOM on disk file */ + + count++; /* bump record count */ + size += n; /* update bytes read */ + EOFcnt = 0; /* not an EOF */ + if (n != ln) { + if (ln > 0) { + if (count - lcount > 1) + fprintf(stderr, "file %d: records %d to %d: size %d\n", filen, lcount, count - 1, ln); + else + fprintf(stderr, "file %d: record %d: size %d\n", filen, lcount, ln); + } + ln = n; + lcount = count; + } + /* return bytes in buffer */ + return n; +} + +void putrec(int cnt, char *buf) +{ + int n1, n2, nw; + int hc = (cnt + 1) & ~1; /* make byte count even */ + int ac = cnt; /* get actual byte count */ + +//printf("writing %d chars\n", cnt); +#if 0 + /* write actual byte count to 32 bit word as header */ + n1 = fwrite((char *)(&hc), (size_t)1, (size_t)4, outfp); +#endif + /* write the data mod 2 */ + nw = fwrite((char *)buf, (size_t)1, (size_t)hc, outfp); +#if 0 + /* write the byte count in 32 bit word as footer */ + n2 = fwrite((char *)(&hc), (size_t)1, (size_t)4, outfp); +#endif +#if 0 + if (n1 != 4 || nw != hc || n2 != 4) +#else + if (nw != hc) +#endif + { + fprintf(stderr, "write (%d) failure\n", nw); + fprintf(stderr, "Operation aborted\n"); + fclose(outfp); + close(inp); + free(buf); + exit(1); + } +} + +int main (int argc, char *argv[]) +{ + char *buf; + size_t buf_size = 256 * 1024; + size_t ll, gotboth = 0; + int zero = 0; + + if (argc != 3) { + fprintf(stderr, "usage: %s infile outfile\n", argv[0]); + exit(1); + } + + /* open input file */ + if ((inp = open(argv[1], O_RDONLY, 0666)) < 0) { + fprintf(stderr,"%s: fopen: unable to open input file %s\n", argv[0], argv[1]); + return (1); + } + + close(inp); /* close input */ + outfp = fopen(argv[1],"r"); /* reopen */ + fseek(outfp, 0, SEEK_END); /* seek to end */ + oldsize = ftell(outfp); /* get filesize in bytes */ + fclose(outfp); /* now close it */ + + /* open input file */ + if ((inp = open(argv[1], O_RDONLY, 0666)) < 0) { + fprintf(stderr,"%s: fopen: unable to open input file %s\n", argv[0], argv[1]); + return (1); + } + + /* open output file */ + outfp = fopen(argv[2],"w"); + if (outfp == NULL) { + fprintf(stderr,"%s: fopen: unable to open output file %s\n", argv[0], argv[2]); + exit(1); + } + + /* init counts */ + ln = -2; /* look for 2 eof */ + count = 0; + size = 0; + tsize = 0; + lcount = 0; + + /* get a 256k buffer */ + if ((buf = malloc(buf_size)) == NULL) { + fprintf(stderr, "Can't allocate memory for %s\n", argv[0]); + return (4); + } + + /* get buffers until eof */ +domore: + while ((ll=getloi(buf, buf_size)) > 0) { +//printf("got %d char\n", ll); + /* we have data to write */ + putrec(ll, buf); /* write the buffer */ + gotboth = 0; + } +//printf("we have EOF %d\n", gotboth+1); + /* we have an EOF or an EOM */ + if (ll == 0) { + /* we have EOF, write a zero */ + fwrite((char *)(&zero), (size_t)1, (size_t)4, outfp); + gotboth++; /* one more EOF */ + if (gotboth == 2) { + /* we have written both EOF's, now write EOM */ + ll = -1; + } else { + goto domore; /* get more data */ + } + } + +//printf("we have EOM, DONE\n"); + /* We have EOM, see if EOF's needed */ + switch (gotboth) { + case 0: /* we have written no EOFs, so write two */ + fwrite((char *)(&zero), (size_t)1, (size_t)4, outfp); + /* drop through */ + case 1: /* we have written 1 EOF, so write one more */ + fwrite((char *)(&zero), (size_t)1, (size_t)4, outfp); + /* drop through */ + default: + case 2: /* we have written 2 EOFs, now do EOM */ + zero = -1; + fwrite((char *)(&zero), (size_t)1, (size_t)4, outfp); + } + fprintf(stderr, "EOM after 2 EOFs %d files: %d bytes\n", filen-1, tsize); + + newsize = ftell(outfp); /* get filesize in bytes */ + fprintf(stderr, "Size of file changed from %d to %d\n", oldsize, newsize); + + /* we done */ + fclose(outfp); + close(inp); + free(buf); + exit(0); +}