| /* nova_qty.c: NOVA multiplexor (QTY/ALM) simulator | |
| Copyright (c) 2000-2008, Robert M. Supnik | |
| Written by Bruce Ray and used with his gracious permission. | |
| Permission is hereby granted, free of charge, to any person obtaining a | |
| copy of this software and associated documentation files (the "Software"), | |
| to deal in the Software without restriction, including without limitation | |
| the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
| and/or sell copies of the Software, and to permit persons to whom the | |
| Software is furnished to do so, subject to the following conditions: | |
| The above copyright notice and this permission notice shall be included in | |
| all copies or substantial portions of the Software. | |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
| IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
| ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER | |
| IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
| CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
| Except as contained in this notice, the name of Robert M Supnik shall not be | |
| used in advertising or otherwise to promote the sale, use or other dealings | |
| in this Software without prior written authorization from Robert M Supnik. | |
| qty multiplexor: QTY = 4060, ALM = 42xx | |
| 04-Jul-07 BKR fixed QTY output line number calculation (affected higher line numbers), | |
| 25-Mar-04 RMS Updated for V3.2 | |
| 12-Jan-04 BKR Initial release | |
| includes both original DG "quad" multiplexor (QTY) | |
| and later Asynchronous Line Multiplexor (ALM) support. | |
| */ | |
| /*----------------------------------------------------------------------*/ | |
| /* QTY [4060-compatible] multiplexor */ | |
| /*----------------------------------------------------------------------*/ | |
| /* | |
| * Emulate the DG 4060 "quad" (QTY) serial port multiplexor. DG modem | |
| * control is not supported in this revision due to its obtuse nature | |
| * of using a separate [semi-secret] device MDM which is actually part | |
| * of the DG 4026/4027 multiplexor hardware(!). | |
| * (Full modem support is provided in the ALM driver.) | |
| * | |
| * | |
| * 4060 Hardware | |
| * | |
| * device code: 030 [primary], | |
| * 070 [secondary] | |
| * interrupt mask: B14 [000002] | |
| * ASM mnemonic: QTY | |
| * | |
| * | |
| * 4060 Input/Output Word Format: | |
| * | |
| * _________________________________________________________________ | |
| * | RI| TI| channel | character | | |
| * ----+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+ | |
| * 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | |
| * | |
| * | |
| * RI - receiver interrupt | |
| * TI - transmitter interrupt | |
| * channel - channel number, 0 - 63. | |
| * character- character (valid if receiver interrupt, undefined if transmitter) | |
| * | |
| * Notes: | |
| * | |
| * Maximum 64 lines supported. | |
| * DONE set whenever any received character fully assembled and ready, | |
| * or when any output character transmitted and line is ready | |
| * to accept next output character. | |
| * BUSY set whenever output character is being sent on any line. | |
| * Note that early 4060s did NOT have a busy flag! | |
| * IORST clears device Done, no other user instruction does. | |
| * IORST clears each line's individual R.I. and T.I. | |
| * | |
| * | |
| * Instructions: | |
| * | |
| * DIA get multiplexor status word [format defined above] | |
| * DOA send character to QTY line [format defined above, RI & SI ] | |
| * DIB <ignored> [returns backplane bus noise] | |
| * DOB clear QTY line | |
| * DIC <ignored> [returns backplace bus noise] | |
| * DOC <ignored> | |
| * 'C' clears global done, then checks for RI and TI; | |
| * 'P' <ignored> | |
| * 'S' <ignored> | |
| */ | |
| #include "nova_defs.h" | |
| #include "sim_sock.h" | |
| #include "sim_tmxr.h" | |
| #define UNIT_V_8B (UNIT_V_UF + 0) /* 8b output */ | |
| #define UNIT_8B (1 << UNIT_V_8B) | |
| extern int32 int_req, dev_busy, dev_done, dev_disable ; | |
| extern int32 tmxr_poll ; /* calibrated delay */ | |
| t_stat qty_setnl ( UNIT * uptr, int32 val, char * cptr, void * desc ) ; | |
| t_stat qty_attach ( UNIT * uptr, char * cptr ) ; | |
| t_stat qty_detach ( UNIT * uptr ) ; | |
| t_stat qty_reset ( DEVICE * dptr ) ; | |
| t_stat qty_svc ( UNIT * uptr ) ; | |
| int32 qty ( int32 pulse, int32 code, int32 AC ) ; | |
| t_stat alm_reset ( DEVICE * dptr ) ; | |
| t_stat alm_svc ( UNIT * uptr ) ; | |
| int32 alm ( int32 pulse, int32 code, int32 AC ) ; | |
| DEVICE alm_dev ; | |
| #define QTY_MAX 64 /* max number of QTY lines - hardware */ | |
| int32 qty_brkio = SCPE_OK ; /* default I/O status code */ | |
| int32 qty_max = QTY_MAX ; /* max # QTY lines - user */ | |
| /* controllable */ | |
| int32 qty_mdm = 0 ; /* QTY modem control active? */ | |
| int32 qty_auto = 0 ; /* QTY auto disconnect active? */ | |
| int32 qty_polls = 0 ; /* total 'qty_svc' polls */ | |
| TMLN qty_ldsc[ QTY_MAX ] = { 0 } ; /* QTY line descriptors */ | |
| TMXR qty_desc = { QTY_MAX, 0, 0, qty_ldsc } ; /* mux descriptor */ | |
| int32 qty_status[ QTY_MAX ] = { 0 } ; /* QTY line status */ | |
| /* (must be at least 32 bits) */ | |
| int32 qty_tx_chr[ QTY_MAX ] = { 0 } ; /* QTY line output character */ | |
| /* QTY data structures | |
| qty_dev QTY device descriptor | |
| qty_unit QTY unit descriptor | |
| qty_reg QTY register list | |
| */ | |
| DIB qty_dib = { DEV_QTY, INT_QTY, PI_QTY, &qty } ; | |
| UNIT qty_unit = | |
| { | |
| UDATA (&qty_svc, (UNIT_ATTABLE), 0) | |
| } ; | |
| REG qty_reg[] = /* ('alm_reg' should be similar to this except for device code related items) */ | |
| { | |
| { ORDATA (BUF, qty_unit.buf, 8) }, | |
| { FLDATA (BUSY, dev_busy, INT_V_QTY) }, | |
| { FLDATA (DONE, dev_done, INT_V_QTY) }, | |
| { FLDATA (DISABLE, dev_disable, INT_V_QTY) }, | |
| { FLDATA (INT, int_req, INT_V_QTY) }, | |
| { FLDATA (MDMCTL, qty_mdm, 0) }, | |
| { FLDATA (AUTODS, qty_auto, 0) }, | |
| { DRDATA (POLLS, qty_polls, 32) }, | |
| { NULL } | |
| } ; | |
| MTAB qty_mod[] = | |
| { | |
| { UNIT_8B, 0, "7b", "7B", NULL }, | |
| { UNIT_8B, UNIT_8B, "8b", "8B", NULL }, | |
| { MTAB_XTD | MTAB_VDV, 1, NULL, "DISCONNECT", | |
| &tmxr_dscln, NULL, (void *)&qty_desc }, | |
| { UNIT_ATT, UNIT_ATT, "connections", NULL, | |
| NULL, &tmxr_show_summ, (void *)&qty_desc }, | |
| { MTAB_XTD | MTAB_VDV | MTAB_NMO, 1, "CONNECTIONS", NULL, | |
| NULL, &tmxr_show_cstat, (void *)&qty_desc }, | |
| { MTAB_XTD | MTAB_VDV | MTAB_NMO, 0, "STATISTICS", NULL, | |
| NULL, &tmxr_show_cstat, (void *)&qty_desc }, | |
| { MTAB_XTD | MTAB_VDV, 0, "LINES", "LINES", | |
| &qty_setnl, &tmxr_show_lines, (void *) &qty_desc }, | |
| { 0 } | |
| } ; | |
| DEVICE qty_dev = | |
| { | |
| "QTY", &qty_unit, qty_reg, qty_mod, | |
| 1, 10, 31, 1, 8, 8, | |
| NULL, NULL, &qty_reset, | |
| NULL, &qty_attach, &qty_detach, | |
| &qty_dib, (DEV_DISABLE | DEV_DIS | DEV_MUX) | |
| }; | |
| #define DG_RETURN( status, data ) (int32)(((status) << IOT_V_REASON) | ((data) & 0x0FFFF) ) | |
| /* | |
| * QTY_S_xxx QTY device status reference | |
| * QTY_L_xxx QTY line status word reference (qty_status[]) | |
| */ | |
| /*----------------------------------------------*/ | |
| /* QTY device status */ | |
| /*----------------------------------------------*/ | |
| #define QTY_S_RI 0x8000 /* Receiver Interrupt */ | |
| #define QTY_S_TI 0x4000 /* Transmitter interrupt */ | |
| #define QTY_S_LMASK 0x3F00 /* line mask */ | |
| #define QTY_S_DMASK 0x00FF /* data mask (received char) */ | |
| #define QTY_MASTER_ACTIVE( desc ) ( (desc)->master ) | |
| #define QTY_LINE_EXTRACT( x ) (((x) & QTY_S_LMASK) >> 8) | |
| #define QTY_LINE_TX_CHAR( line ) qty_tx_chr[ ((line) % QTY_MAX) ] | |
| #define QTY_LINE_RX_CHAR( line ) (qty_status[ (line) ] & QTY_S_DMASK) | |
| #define QTY_UNIT_ACTIVE( unitp ) ( (unitp)->conn ) | |
| #define QTY_LINE_BITS( line, bits ) (qty_status[ (line) ] & bits) | |
| #define QTY_LINE_SET_BIT( line, bit ) qty_status[ (line) ] |= (bit) ; | |
| #define QTY_LINE_CLEAR_BIT( line, bit ) qty_status[ (line) ] &= ~(bit) ; | |
| #define QTY_LINE_BIT_SET( line, bit ) (qty_status[ (line) ] & (bit)) | |
| /*----------------------------------------------*/ | |
| /* QTY line status */ | |
| /*----------------------------------------------*/ | |
| #define QTY_L_RXE 0x800000 /* receiver enabled? */ | |
| #define QTY_L_RXBZ 0x400000 /* receiver busy? */ | |
| #define QTY_L_RXDN 0x200000 /* receiver done? */ | |
| #define QTY_L_TXE 0x080000 /* transmitter enabled? */ | |
| #define QTY_L_TXBZ 0x040000 /* transmitter busy? */ | |
| #define QTY_L_TXDN 0x020000 /* transmitter done? */ | |
| #define QTY_L_BREAK 0x008000 /* BREAK character received */ | |
| #define QTY_L_RING 0x004000 /* Ring interrupt */ | |
| #define QTY_L_CD 0x002000 /* Carrier Detect */ | |
| #define QTY_L_DTR 0x001000 /* Data Terminal Ready */ | |
| /* <0x00FF = character> */ | |
| #define QTY_L_LOOPBK 0x00010000 /* loopback mode */ | |
| #define QTY_L_OVRERR 0x00020000 /* overrun error */ | |
| #define QTY_L_FRMERR 0x00040000 /* framing error */ | |
| #define QTY_L_PARERR 0x00080000 /* parity error */ | |
| /* CD, CTS, DSR, RI */ | |
| /* <future> */ | |
| #define QTY_L_MODEM 0x0080 /* <not yet used> */ | |
| #define QTY_L_TELNET 0x0040 /* <not yet used> */ | |
| #define QTY_L_AUTODIS 0x0020 /* <not yet used> */ | |
| #define QTY_L_PARITY | |
| #define QTY_L_7BIT | |
| #define QTY_L_BAUD /* <4 bits> */ | |
| #define QTY_L_DMASK 0x000FF /* data mask (always 8 bits) */ | |
| /* Note: use at least an 'int32' for this guy */ | |
| /*------------------------------*/ | |
| /* qty_tmxr_putc */ | |
| /*------------------------------*/ | |
| int qty_tmxr_putc( int line, TMLN * lp, int kar ) | |
| { | |
| int a ; | |
| /*----------------------------------------------*/ | |
| /* Send character to given QTY/telnet line. */ | |
| /* */ | |
| /* enter: line QTY line # */ | |
| /* lp Telnet unit def ptr */ | |
| /* kar character to send */ | |
| /* */ | |
| /* return: SCPE_OK */ | |
| /* SCPE_STALL */ | |
| /* SCPE_LOST */ | |
| /*----------------------------------------------*/ | |
| a = tmxr_putc_ln( lp, kar ) ; | |
| if ( a == SCPE_OK) | |
| { | |
| QTY_LINE_SET_BIT( line, QTY_L_TXDN ) | |
| QTY_LINE_CLEAR_BIT( line, QTY_L_TXBZ ) | |
| } | |
| else if ( a == SCPE_STALL ) | |
| { | |
| /* | |
| (should we try to output the buffer | |
| and then regroup...?) | |
| */ | |
| QTY_LINE_SET_BIT( line, QTY_L_TXBZ ) | |
| QTY_LINE_CLEAR_BIT( line, QTY_L_TXDN ) | |
| QTY_LINE_TX_CHAR( line ) = kar ; | |
| } | |
| else if ( a == SCPE_LOST ) | |
| { | |
| /* no connection - hangup? */ | |
| QTY_LINE_SET_BIT( line, QTY_L_TXBZ ) | |
| QTY_LINE_CLEAR_BIT( line, QTY_L_TXDN ) | |
| QTY_LINE_TX_CHAR( line ) = kar ; | |
| } | |
| return ( a ) ; | |
| } /* end of 'qty_tmxr_putc' */ | |
| /*----------------------------------------------*/ | |
| /* qty_update_rcvi */ | |
| /*----------------------------------------------*/ | |
| int qty_update_rcvi( TMXR * mp ) | |
| { | |
| int line ; | |
| TMLN * lp ; | |
| int32 datum ; | |
| int changes ; | |
| /*------------------------------------------------------*/ | |
| /* Search through connected telnet lines for any input */ | |
| /* activity. */ | |
| /* */ | |
| /* enter: mp master telnet qty desc ptr */ | |
| /* */ | |
| /* return: int change count (0 = none seen) */ | |
| /*------------------------------------------------------*/ | |
| for ( changes = line = 0; line < mp->lines; ++line ) | |
| if ( (lp=mp->ldsc+line)->conn && lp->rcve ) | |
| if ( (datum=tmxr_getc_ln(lp)) ) | |
| { | |
| if ( datum & SCPE_BREAK ) | |
| { | |
| /* what should we do here - set QTY_L_BREAK? */ | |
| datum = datum & 0x00FF ; | |
| } | |
| else | |
| { | |
| datum = datum & 0x00FF ; | |
| } | |
| /* <check parity, masking, forced parity, CR/LF xlation> */ | |
| QTY_LINE_CLEAR_BIT( line, (QTY_L_RXBZ | QTY_L_DMASK) ) ; | |
| QTY_LINE_SET_BIT( line, (QTY_L_RXDN | datum) ) ; | |
| ++changes ; | |
| } | |
| return ( changes ) ; | |
| } /* end of 'qty_update_rcvi' */ | |
| /*----------------------------------------------*/ | |
| /* qty_update_xmti */ | |
| /*----------------------------------------------*/ | |
| int qty_update_xmti( TMXR * mp ) | |
| { | |
| int line ; | |
| TMLN * lp ; | |
| int changes ; | |
| /*------------------------------------------------------*/ | |
| /* Search through connected telnet lines for any de- */ | |
| /* ferred output activity. */ | |
| /* */ | |
| /* enter: mp master telnet qty desc ptr */ | |
| /* */ | |
| /* return: int change count (0 = none seen) */ | |
| /*------------------------------------------------------*/ | |
| /* any TX DONE flags set | |
| * any TX BUSY flags set | |
| */ | |
| for ( changes = line = 0; line < mp->lines; ++line ) | |
| if ( QTY_LINE_BIT_SET(line,QTY_L_TXBZ) ) | |
| if ( (lp=mp->ldsc+line)->conn && lp->xmte ) | |
| { | |
| /* why are we busy? buffer was full? */ | |
| /* now some space available - try | |
| * to stuff pending character in | |
| * buffer and free up the world | |
| */ | |
| qty_tmxr_putc( line, lp, QTY_LINE_TX_CHAR(line) ) ; | |
| ++changes ; | |
| } | |
| return ( changes ) ; | |
| } /* end of 'qty_update_xmti' */ | |
| /*----------------------------------------------*/ | |
| /* qty_update_status */ | |
| /*----------------------------------------------*/ | |
| int qty_update_status( DIB * dibp, TMXR * tmxr_desc ) | |
| { | |
| int line ; | |
| int status ; | |
| int txbusy ; | |
| /*----------------------------------------------*/ | |
| /* return global device status for current qty */ | |
| /* state. */ | |
| /* */ | |
| /* Receiver interrupts have higher priority */ | |
| /* than transmitter interrupts according to DG */ | |
| /* but this routine could be modified to use */ | |
| /* different priority criteria. */ | |
| /* */ | |
| /* Round-robin polling could also be used in */ | |
| /* some future release rather than starting */ | |
| /* with line 0 each time. */ | |
| /* */ | |
| /* Return <QTY_S_RI + line # + character> of */ | |
| /* first waiting character, else return */ | |
| /* <QTY_S_TI + line #> of first finished line */ | |
| /* output, else return 0. */ | |
| /* */ | |
| /* This routine does -not- clear input line */ | |
| /* BZ/DN flags; caller should do this. */ | |
| /* */ | |
| /* Global device done and busy flags are */ | |
| /* updated. */ | |
| /*----------------------------------------------*/ | |
| for ( txbusy = status = line = 0 ; line < qty_max ; ++line ) | |
| { | |
| txbusy |= (QTY_LINE_BIT_SET(line,QTY_L_TXBZ)) ; | |
| if ( QTY_LINE_BIT_SET(line,QTY_L_RXDN) ) | |
| { | |
| if ( ! status ) | |
| { | |
| status = QTY_LINE_BITS( line, QTY_S_DMASK ) | QTY_S_RI ; | |
| status = status | (line << 8) ; | |
| } | |
| break ; | |
| } | |
| else if ( QTY_LINE_BIT_SET(line,QTY_L_TXDN) ) | |
| { | |
| if ( ! (status & QTY_S_RI) ) | |
| if ( ! (status & QTY_S_RI) ) | |
| { | |
| status = QTY_S_TI ; | |
| status = status | (line << 8) ; | |
| } | |
| } | |
| } | |
| /* <we could check each line for TX busy to set DEV_SET_BUSY)?> */ | |
| DEV_CLR_BUSY( INT_QTY ) ; | |
| DEV_CLR_DONE( INT_QTY ) ; | |
| if ( txbusy ) | |
| { | |
| DEV_SET_BUSY( INT_QTY ) ; | |
| } | |
| if ( status & (QTY_S_RI | QTY_S_TI) ) | |
| { | |
| DEV_SET_DONE( INT_QTY ) ; | |
| } | |
| DEV_UPDATE_INTR ; /* update final intr status */ | |
| return ( status ) ; | |
| } /* end of 'qty_update_status' */ | |
| /*--------------------------------------------------------------*/ | |
| /* qty_attach */ | |
| /*--------------------------------------------------------------*/ | |
| t_stat qty_attach( UNIT * unitp, char * cptr ) | |
| { | |
| t_stat r ; | |
| int a ; | |
| /* switches: A auto-disconnect | |
| * M modem control | |
| */ | |
| qty_mdm = qty_auto = 0; /* modem ctl off */ | |
| r = tmxr_attach( &qty_desc, unitp, cptr ) ; /* attach QTY */ | |
| if ( r != SCPE_OK ) | |
| { | |
| return ( r ) ; /* error! */ | |
| } | |
| if ( sim_switches & SWMASK('M') ) /* modem control? */ | |
| { | |
| qty_mdm = 1; | |
| printf( "Modem control activated\n" ) ; | |
| if ( sim_log ) fprintf( sim_log, "Modem control activated\n" ) ; | |
| if ( sim_switches & SWMASK ('A') ) /* autodisconnect? */ | |
| { | |
| qty_auto = 1 ; | |
| printf( "Auto disconnect activated\n" ) ; | |
| if ( sim_log ) fprintf( sim_log, "Auto disconnect activated\n" ) ; | |
| } | |
| } | |
| qty_polls = 0 ; | |
| for ( a = 0 ; a < QTY_MAX ; ++a ) | |
| { | |
| /* QTY lines are always enabled - force RX and TX to 'enabled' */ | |
| qty_status[ a ] = (QTY_L_RXE | QTY_L_TXE) ; | |
| } | |
| sim_activate( unitp, tmxr_poll ) ; | |
| return ( SCPE_OK ) ; | |
| } /* end of 'qty_attach' */ | |
| /*--------------------------------------------------------------*/ | |
| /* qty_detach */ | |
| /*--------------------------------------------------------------*/ | |
| t_stat qty_detach( UNIT * unitp ) | |
| { | |
| sim_cancel( unitp ) ; | |
| return ( tmxr_detach(&qty_desc,unitp) ) ; | |
| } /* end of 'qty_detach' */ | |
| /*--------------------------------------------------------------*/ | |
| /* qty_clear */ | |
| /*--------------------------------------------------------------*/ | |
| t_stat qty_clear( t_bool flag ) | |
| { | |
| int line ; | |
| for ( line = 0 ; line < qty_max ; ++line ) | |
| { | |
| qty_ldsc[line].xmte = 0 ; | |
| qty_ldsc[line].rcve = 0 ; | |
| if ( ! qty_ldsc[line].conn ) | |
| { | |
| qty_ldsc[line].xmte = 1 ; /* set xmt enb */ | |
| qty_ldsc[line].rcve = 1 ; /* clr rcv enb */ | |
| } | |
| } | |
| return ( SCPE_OK ) ; | |
| } /* end of 'qty_clear' */ | |
| /*----------------------------------------------*/ | |
| /* qty_common_reset */ | |
| /*----------------------------------------------*/ | |
| t_stat qty_common_reset( DIB * dibp, UNIT * unitp, DEVICE * dptr ) | |
| { | |
| if ((dptr->flags & DEV_DIS) == 0) | |
| { | |
| if (dptr == &qty_dev) alm_dev.flags |= DEV_DIS; | |
| else qty_dev.flags |= DEV_DIS; | |
| } | |
| qty_clear( TRUE ) ; | |
| DEV_CLR_BUSY( INT_QTY ) ; /* clear busy */ | |
| DEV_CLR_DONE( INT_QTY ) ; /* clear done, int */ | |
| DEV_UPDATE_INTR ; | |
| if ( QTY_MASTER_ACTIVE(&qty_desc) ) | |
| { | |
| sim_activate( unitp, tmxr_poll ) ; | |
| } | |
| else | |
| { | |
| sim_cancel( unitp ) ; | |
| } | |
| return ( SCPE_OK ) ; | |
| } /* end of 'qty_common_reset' */ | |
| /*--------------------------------------------------------------*/ | |
| /* qty_reset */ | |
| /*--------------------------------------------------------------*/ | |
| t_stat qty_reset( DEVICE * dptr ) | |
| { | |
| return ( qty_common_reset(&qty_dib,&qty_unit,dptr) ) ; | |
| } /* end of 'qty_reset' */ | |
| /* Unit service routine | |
| The QTY/ALM polls to see if asynchronous activity has occurred and now | |
| needs to be processed. The polling interval is controlled by the clock | |
| simulator, so for most environments, it is calibrated to real time. | |
| The simulator assumes that software enables all of the multiplexors, | |
| or none of them. | |
| */ | |
| /*----------------------------------------------*/ | |
| /* qty_common_svc */ | |
| /*----------------------------------------------*/ | |
| t_stat qty_common_svc( DIB * dibp, UNIT * unitp ) | |
| { | |
| int line ; | |
| int newln ; | |
| TMLN * tmlnp ; | |
| ++qty_polls ; /* another time 'round the track */ | |
| newln = tmxr_poll_conn( &qty_desc ) ; /* anybody knocking at the door? */ | |
| if ( (newln >= 0) && qty_mdm ) | |
| if ( newln >= qty_max ) | |
| { | |
| return SCPE_IERR; /* WTF - sanity check failed, over? */ | |
| } | |
| else | |
| { | |
| line = newln ; /* handle modem control */ | |
| tmlnp =&qty_ldsc[ line ] ; | |
| tmlnp->rcve = tmlnp->xmte = 1 ; | |
| /* do QTY_LINE_ bit fiddling and state machine | |
| * manipulation with modem control signals | |
| */ | |
| } | |
| tmxr_poll_rx( &qty_desc ) ; /* poll input */ | |
| qty_update_rcvi( &qty_desc ) ; /* update receiver interrupt status */ | |
| tmxr_poll_tx( &qty_desc ) ; /* poll output */ | |
| qty_update_xmti( &qty_desc ) ; /* update transmitter interrupt status */ | |
| qty_update_status( dibp, &qty_desc ) ; /* update device status */ | |
| sim_activate( unitp, tmxr_poll ) ; /* restart the bubble machine */ | |
| return ( SCPE_OK ) ; | |
| } /* end of 'qty_common_svc' */ | |
| /*--------------------------------------------------------------*/ | |
| /* qty_svc */ | |
| /*--------------------------------------------------------------*/ | |
| t_stat qty_svc( UNIT * uptr ) | |
| { | |
| return ( qty_common_svc(&qty_dib,uptr) ) ; | |
| } /* end of 'qty_svc' */ | |
| /*--------------------------------------------------------------*/ | |
| /* qty */ | |
| /*--------------------------------------------------------------*/ | |
| int32 qty( int32 pulse, int32 code, int32 AC ) | |
| { | |
| int32 iodata ; | |
| int32 ioresult ; | |
| int line ; | |
| TMLN * tmlnp ; | |
| int a ; | |
| int kar ; | |
| /*--------------------------------------------------------------*/ | |
| /* DG 4060[-compatible] "quad" multiplexor instruction handler */ | |
| /*--------------------------------------------------------------*/ | |
| ioresult= qty_brkio ; /* (assume returning I/O break value */ | |
| iodata = 0 ; /* (assume 16-bit Nova/Eclipse bus) */ | |
| switch ( code ) | |
| { | |
| case ioNIO : /* <no operation> */ | |
| break ; | |
| case ioDIA : /* get current QTY status */ | |
| iodata = qty_update_status( &qty_dib, &qty_desc ) ; | |
| if ( iodata & QTY_S_RI ) | |
| { /* clear line's input buffer */ | |
| QTY_LINE_CLEAR_BIT( (QTY_LINE_EXTRACT(iodata)), (QTY_L_RXBZ | QTY_L_RXDN) ) | |
| /* | |
| character masking ; | |
| parity checking ; | |
| parity generating ; | |
| */ | |
| } | |
| qty_update_status( &qty_dib, &qty_desc ) ; | |
| break ; | |
| case ioDOA : /* send character to QTY */ | |
| line = QTY_LINE_EXTRACT( AC ) ; | |
| if ( line < qty_max ) | |
| if ( QTY_LINE_BIT_SET(line,QTY_L_TXE) ) | |
| { | |
| /* | |
| perform any character translation: | |
| 7 bit/ 8 bit | |
| parity generation | |
| */ | |
| kar = AC & ((qty_unit.flags & UNIT_8B)? 0377: 0177) ; | |
| /* do any parity calculations also */ | |
| tmlnp = &qty_ldsc[ line ] ; | |
| a = qty_tmxr_putc( line, tmlnp, kar ) ; | |
| if ( a != SCPE_OK) | |
| { | |
| /* do anything at this point? */ | |
| } | |
| qty_update_status( &qty_dib, &qty_desc ) ; | |
| } | |
| break ; | |
| case ioDIB : /* no QTY function - return bus noise in AC */ | |
| break ; | |
| case ioDOB : /* clear QTY output channel busy and done flag */ | |
| QTY_LINE_CLEAR_BIT( (QTY_LINE_EXTRACT(AC)), (QTY_L_TXBZ | QTY_L_TXDN) ) | |
| qty_update_status( &qty_dib, &qty_desc ) ; | |
| break ; | |
| case ioDIC : /* no QTY function - return bus noise in AC */ | |
| break ; | |
| case ioDOC : /* no QTY function - ignore */ | |
| break ; | |
| case ioSKP : /* I/O skip test - should never come here */ | |
| break ; | |
| default : | |
| /* <illegal I/O operation value> */ | |
| break ; | |
| } | |
| switch ( pulse ) | |
| { | |
| case iopN : /* <ignored (of course)> */ | |
| break ; | |
| case iopS : /* <ignored> */ | |
| break ; | |
| case iopP : /* <ignored> */ | |
| break ; | |
| case iopC : | |
| qty_update_status( &qty_dib, &qty_desc ) ; | |
| break ; | |
| default : | |
| /* <illegal pulse value> */ | |
| break ; | |
| } | |
| return ( DG_RETURN( ioresult, iodata ) ) ; | |
| } /* end of 'qty' */ | |
| /*--------------------------------------------------------------*/ | |
| /* qty_setnl */ | |
| /*--------------------------------------------------------------*/ | |
| t_stat qty_setnl( UNIT * uptr, int32 val, char * cptr, void * desc ) | |
| { | |
| int32 newln, i, t ; | |
| t_stat r ; | |
| if ( cptr == NULL ) | |
| { | |
| return ( SCPE_ARG ) ; | |
| } | |
| newln = (int32) get_uint( cptr, 10, QTY_MAX, &r ) ; | |
| if ( (r != SCPE_OK) || (newln == qty_desc.lines) ) | |
| { | |
| return ( r ) ; | |
| } | |
| if ( (newln == 0) || (newln > QTY_MAX) ) | |
| { | |
| return ( SCPE_ARG ) ; | |
| } | |
| if ( newln < qty_desc.lines ) | |
| { | |
| for ( i = newln, t = 0 ; i < qty_desc.lines ; ++i ) | |
| { | |
| t = t | qty_ldsc[i].conn ; | |
| } | |
| if ( t && ! get_yn("This will disconnect users; proceed [N]?", FALSE) ) | |
| { | |
| return ( SCPE_OK ) ; | |
| } | |
| for ( i = newln ; i < qty_desc.lines ; ++i ) | |
| { | |
| if ( qty_ldsc[i].conn ) | |
| { /* reset line */ | |
| tmxr_msg( qty_ldsc[i].conn, "\r\nOperator disconnected line\r\n" ) ; | |
| tmxr_reset_ln( &qty_ldsc[i] ) ; | |
| } | |
| qty_clear( TRUE ) ; /* reset mux */ | |
| } | |
| } | |
| qty_max = qty_desc.lines = newln ; | |
| /* Huh, I don't understand this yet... | |
| qty_max = ((qty_dev.flags & DEV_DIS)? 0 : (qty_desc.lines / QTY_MAX)) ; | |
| */ | |
| return ( SCPE_OK ) ; | |
| } /* end of 'qty_setnl' */ | |
| /*----------------------------------------------------------------------*/ | |
| /* ALM [425x-compatible] multiplexor */ | |
| /*----------------------------------------------------------------------*/ | |
| /* | |
| * device code: 034 [primary], | |
| * 074 [secondary] | |
| * interrupt mask: B14 [000002] | |
| * ASM mnemonic: ALM | |
| * | |
| * ALM [4255-4258] I/O instructions | |
| * | |
| * DIA read line and section requesting service | |
| * DOA select line and section (lines 0-255, 8-bits) + rcvr/xmit | |
| * DIB receive data | |
| * DOB 00 transmit data | |
| * 01 transmit BREAK | |
| * 10 set modem control status | |
| * 11 <ignored> | |
| * DIC read receiver or modem status | |
| * DOC 00 control line section and diag mode | |
| * 01 | |
| * 10 specify line characteristics | |
| * 11 | |
| * | |
| * undocumented DG "features": | |
| * | |
| * NIOS sets board offline | |
| * NIOC sets board online | |
| * Modem control signal state change can signal interrupt | |
| * explicit line select with DOA | |
| * implicit line select with DIA | |
| * | |
| * We support 64 lines maximum in this release although some ALM's could | |
| * theoretically support up to 256. | |
| */ | |
| DIB alm_dib = { DEV_ALM, INT_ALM, PI_ALM, &alm } ; | |
| UNIT alm_unit = | |
| { | |
| UDATA (&alm_svc, (UNIT_ATTABLE), 0) | |
| } ; | |
| REG alm_reg[] = /* ('qty_reg' should be similar to this except for device code related items) */ | |
| { | |
| { ORDATA (BUF, alm_unit.buf, 8) }, | |
| { FLDATA (BUSY, dev_busy, INT_V_ALM) }, | |
| { FLDATA (DONE, dev_done, INT_V_ALM) }, | |
| { FLDATA (DISABLE, dev_disable, INT_V_ALM) }, | |
| { FLDATA (INT, int_req, INT_V_ALM) }, | |
| { FLDATA (MDMCTL, qty_mdm, 0) }, | |
| { FLDATA (AUTODS, qty_auto, 0) }, | |
| { DRDATA (POLLS, qty_polls, 32) }, | |
| { NULL } | |
| } ; | |
| DEVICE alm_dev = | |
| { | |
| "ALM", &alm_unit, alm_reg, qty_mod, | |
| 1, 10, 31, 1, 8, 8, | |
| NULL, NULL, &alm_reset, | |
| NULL, &qty_attach, &qty_detach, | |
| &alm_dib, (DEV_DISABLE | DEV_NET) | |
| } ; | |
| int alm_section = -1 ; /* current line "section" (0 = RCV, 1 = XMT) */ | |
| int alm_line = -1 ; /* current line [0-63] */ | |
| int alm_diag_mode = 0 ; /* <not yet supported> */ | |
| int alm_line_mask = 0x003F ; /* maximum of 64 lines in this rev */ | |
| #define ALM_LINE_EXTRACT( x ) (((x) >> 1) & alm_line_mask) | |
| #define ALM_SECT_EXTRACT( x ) ((x) & 0x0001) | |
| /*--------------------------------------------------------------*/ | |
| /* alm_reset */ | |
| /*--------------------------------------------------------------*/ | |
| t_stat alm_reset( DEVICE * dptr ) | |
| { | |
| return ( qty_common_reset(&alm_dib,&alm_unit,dptr) ) ; | |
| } /* end of 'alm_reset' */ | |
| /*--------------------------------------------------------------*/ | |
| /* alm_svc */ | |
| /*--------------------------------------------------------------*/ | |
| t_stat alm_svc( UNIT * uptr ) | |
| { | |
| return ( qty_common_svc(&alm_dib,uptr) ) ; | |
| } /* end of 'alm_svc' */ | |
| /*--------------------------------------------------------------*/ | |
| /* alm */ | |
| /*--------------------------------------------------------------*/ | |
| int32 alm( int32 pulse, int32 code, int32 AC ) | |
| { | |
| int32 iodata ; | |
| int32 ioresult ; | |
| TMLN * tmlnp ; | |
| int a ; | |
| int kar ; | |
| /*--------------------------------------------------------------*/ | |
| /* DG 425x[-compatible] "ALM" multiplexor instruction handler */ | |
| /*--------------------------------------------------------------*/ | |
| ioresult= qty_brkio ; /* (assume returning I/O break value */ | |
| iodata = 0 ; /* (assume 16-bit Nova/Eclipse bus) */ | |
| switch ( code ) | |
| { | |
| case ioNIO : /* <no operation> */ | |
| break ; | |
| case ioDIA : /* read line and section requesting service */ | |
| iodata = qty_update_status( &alm_dib, &qty_desc ) ; | |
| alm_line = (QTY_LINE_EXTRACT(iodata) & alm_line_mask) ; | |
| /* (mask with 'alm_line_mask' in case ALM mask is different than QTY */ | |
| alm_section = 0 ; | |
| if ( ! ( iodata & QTY_S_RI) ) | |
| if ( iodata & QTY_S_TI ) | |
| { | |
| alm_section = 1 ; /* receiver quiet - transmitter done */ | |
| } | |
| iodata = (alm_line << 1) | alm_section ; | |
| break ; | |
| case ioDOA : /* set line and section */ | |
| alm_section = ALM_SECT_EXTRACT( AC ) ; | |
| alm_line = ALM_LINE_EXTRACT( AC ) ; | |
| break ; | |
| case ioDIB : /* no ALM function - return bus noise in AC */ | |
| if ( alm_line < qty_max ) | |
| { | |
| iodata = QTY_LINE_RX_CHAR( alm_line ) ; | |
| } | |
| break ; | |
| case ioDOB : /* output and modem control functions */ | |
| switch ( (AC >> 14) & 03 ) | |
| { | |
| case 00 : /* transmit data */ | |
| if ( alm_line < qty_max ) | |
| if ( QTY_LINE_BIT_SET(alm_line,QTY_L_TXE) ) | |
| { | |
| /* | |
| perform any character translation: | |
| 7 bit/ 8 bit | |
| parity generation | |
| */ | |
| kar = AC & ((alm_unit.flags & UNIT_8B)? 0377: 0177) ; | |
| /* do any parity calculations also */ | |
| tmlnp = &qty_ldsc[ alm_line ] ; | |
| a = qty_tmxr_putc( alm_line, tmlnp, kar ) ; | |
| if ( a != SCPE_OK) | |
| { | |
| /* do anything at this point? */ | |
| } | |
| qty_update_status( &alm_dib, &qty_desc ) ; | |
| } | |
| break ; | |
| case 01 : /* transmit break */ | |
| if ( alm_line < qty_max ) | |
| if ( QTY_LINE_BIT_SET(alm_line,QTY_L_TXE) ) | |
| { | |
| tmlnp = &qty_ldsc[ alm_line ] ; | |
| /* | |
| a = qty_tmxr_putc( alm_line, tmlnp, kar ) ; | |
| if ( a != SCPE_OK) | |
| { | |
| } | |
| */ | |
| qty_update_status( &alm_dib, &qty_desc ) ; | |
| } | |
| break ; | |
| case 02 : /* set modem control status */ | |
| break ; | |
| case 03 : /* unused */ | |
| break ; | |
| } | |
| break ; | |
| case ioDIC : /* get modem or receiver status */ | |
| if ( alm_line < qty_max ) | |
| if ( alm_section ) | |
| { | |
| /* get modem section status */ | |
| if ( qty_ldsc[ alm_line ].xmte ) | |
| { | |
| iodata = 0035 ; /* set CD, CTS, DSR, MDM flags */ | |
| } | |
| } | |
| else | |
| { | |
| /* get receiver section status */ | |
| iodata = 0 ; /* receiver error status - no errors by default */ | |
| } | |
| break ; | |
| case ioDOC : /* set line attributes */ | |
| switch ( (AC >> 14) & 03 ) | |
| { | |
| case 00 : /* control line section */ | |
| break ; | |
| case 01 : /* unused */ | |
| break ; | |
| case 02 : /* set line characteristics */ | |
| break ; | |
| case 03 : /* unused */ | |
| break ; | |
| } | |
| break ; | |
| case ioSKP : /* I/O skip test - should never come here */ | |
| break ; | |
| default : | |
| /* <illegal I/O operation value> */ | |
| break ; | |
| } | |
| switch ( pulse ) | |
| { | |
| case iopN : /* <ignored (of course)> */ | |
| break ; | |
| case iopS : /* set device busy | |
| * set all lines on board offline | |
| * clear each line's done | |
| * clear internal system | |
| * clear device busy | |
| */ | |
| for ( a = 0 ; a < qty_max ; ++a ) | |
| if ( 1 /* (not yet optimized) */ ) | |
| { | |
| QTY_LINE_CLEAR_BIT( a, (QTY_L_RXBZ | QTY_L_RXDN | QTY_L_TXBZ | QTY_L_TXDN) ) ; | |
| } | |
| qty_update_status( &alm_dib, &qty_desc ) ; | |
| break ; | |
| case iopP : /* stop clock for all boards in off-line mode */ | |
| break ; | |
| case iopC : | |
| for ( a = 0 ; a < qty_max ; ++a ) | |
| if ( 1 /* (not yet optimized) */ ) | |
| { | |
| QTY_LINE_CLEAR_BIT( a, (QTY_L_RXBZ | QTY_L_RXDN | QTY_L_TXBZ | QTY_L_TXDN) ) ; | |
| } | |
| qty_update_status( &alm_dib, &qty_desc ) ; | |
| break ; | |
| default : | |
| /* <illegal pulse value> */ | |
| break ; | |
| } | |
| return ( DG_RETURN( ioresult, iodata ) ) ; | |
| } /* end of 'alm' */ |