/* hp2100_lpt.c: HP 2100 12845B line printer simulator

   Copyright (c) 1993-2012, Robert M. Supnik

   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.

   LPT          12845B 2607 line printer

   10-Feb-12    JDB     Deprecated DEVNO in favor of SC
   28-Mar-11    JDB     Tidied up signal handling
   26-Oct-10    JDB     Changed I/O signal handler for revised signal model
   26-Jun-08    JDB     Rewrote device I/O to model backplane signals
                        Changed CTIME register width to match documentation
   22-Jan-07    RMS     Added UNIT_TEXT flag
   28-Dec-06    JDB     Added ioCRS state to I/O decoders
   19-Nov-04    JDB     Added restart when set online, etc.
   29-Sep-04    JDB     Added SET OFFLINE/ONLINE, POWEROFF/POWERON
                        Fixed status returns for error conditions
                        Fixed TOF handling so form remains on line 0
   03-Jun-04    RMS     Fixed timing (found by Dave Bryan)
   26-Apr-04    RMS     Fixed SFS x,C and SFC x,C
                        Implemented DMA SRQ (follows FLG)
   25-Apr-03    RMS     Revised for extended file support
   24-Oct-02    RMS     Cloned from 12653A

   Reference:
   - 12845A Line Printer Operating and Service Manual (12845-90001, Aug-1972)


   The 2607 provides three status bits via the interface:

     bit 15 -- printer ready (online)
     bit 14 -- paper out
     bit  0 -- printer idle

   The expected status returns are:

     140001 -- power off or cable disconnected
     100001 -- power on, paper loaded, printer ready
     100000 -- power on, paper loaded, printer busy
     040000 -- power on, paper out (at bottom-of-form)
     000000 -- power on, paper out (not at BOF) / print button up / platen open

   Manual Note: "2-33. PAPER OUT SIGNAL.  [...]  The signal is asserted only
   when the format tape in the line printer has reached the bottom of form."

   These simulator commands provide the listed printer states:

     SET LPT POWEROFF --> power off or cable disconnected
     SET LPT POWERON  --> power on
     SET LPT OFFLINE  --> print button up
     SET LPT ONLINE   --> print button down
     ATT LPT <file>   --> paper loaded
     DET LPT          --> paper out
*/

#include "hp2100_defs.h"

#define LPT_PAGELNT     60                              /* page length */

#define LPT_NBSY        0000001                         /* not busy */
#define LPT_PAPO        0040000                         /* paper out */
#define LPT_RDY         0100000                         /* ready */
#define LPT_PWROFF      LPT_RDY | LPT_PAPO | LPT_NBSY   /* power-off status */

#define LPT_CTL         0100000                         /* control output */
#define LPT_CHAN        0000100                         /* skip to chan */
#define LPT_SKIPM       0000077                         /* line count mask */
#define LPT_CHANM       0000007                         /* channel mask */

#define UNIT_V_POWEROFF (UNIT_V_UF + 0)                 /* unit powered off */
#define UNIT_V_OFFLINE  (UNIT_V_UF + 1)                 /* unit offline */
#define UNIT_POWEROFF   (1 << UNIT_V_POWEROFF)
#define UNIT_OFFLINE    (1 << UNIT_V_OFFLINE)

struct {
    FLIP_FLOP control;                                  /* control flip-flop */
    FLIP_FLOP flag;                                     /* flag flip-flop */
    FLIP_FLOP flagbuf;                                  /* flag buffer flip-flop */
    } lpt = { CLEAR, CLEAR, CLEAR };

int32 lpt_ctime = 4;                                    /* char time */
int32 lpt_ptime = 10000;                                /* print time */
int32 lpt_stopioe = 0;                                  /* stop on error */
int32 lpt_lcnt = 0;                                     /* line count */
static int32 lpt_cct[8] = {
    1, 1, 1, 2, 3, LPT_PAGELNT/2, LPT_PAGELNT/4, LPT_PAGELNT/6
    };

DEVICE lpt_dev;

IOHANDLER lptio;

t_stat lpt_svc (UNIT *uptr);
t_stat lpt_reset (DEVICE *dptr);
t_stat lpt_restart (UNIT *uptr, int32 value, char *cptr, void *desc);
t_stat lpt_attach (UNIT *uptr, char *cptr);

/* LPT data structures

   lpt_dev      LPT device descriptor
   lpt_unit     LPT unit descriptor
   lpt_reg      LPT register list
*/

DIB lpt_dib = { &lptio, LPT };

UNIT lpt_unit = {
    UDATA (&lpt_svc, UNIT_SEQ+UNIT_ATTABLE+UNIT_DISABLE+UNIT_TEXT, 0)
    };

REG lpt_reg[] = {
    { ORDATA (BUF, lpt_unit.buf, 7) },
    { FLDATA (CTL, lpt.control, 0) },
    { FLDATA (FLG, lpt.flag,    0) },
    { FLDATA (FBF, lpt.flagbuf, 0) },
    { DRDATA (LCNT, lpt_lcnt, 7) },
    { DRDATA (POS, lpt_unit.pos, T_ADDR_W), PV_LEFT },
    { DRDATA (CTIME, lpt_ctime, 24), PV_LEFT },
    { DRDATA (PTIME, lpt_ptime, 24), PV_LEFT },
    { FLDATA (STOP_IOE, lpt_stopioe, 0) },
    { ORDATA (SC, lpt_dib.select_code, 6), REG_HRO },
    { ORDATA (DEVNO, lpt_dib.select_code, 6), REG_HRO },
    { NULL }
    };

MTAB lpt_mod[] = {
    { UNIT_POWEROFF, UNIT_POWEROFF, "power off", "POWEROFF", NULL },
    { UNIT_POWEROFF, 0, "power on", "POWERON", lpt_restart },
    { UNIT_OFFLINE, UNIT_OFFLINE, "offline", "OFFLINE", NULL },
    { UNIT_OFFLINE, 0, "online", "ONLINE", lpt_restart },
    { MTAB_XTD | MTAB_VDV,            0, "SC",    "SC",    &hp_setsc,  &hp_showsc,  &lpt_dev },
    { MTAB_XTD | MTAB_VDV | MTAB_NMO, 0, "DEVNO", "DEVNO", &hp_setdev, &hp_showdev, &lpt_dev },
    { 0 }
    };

DEVICE lpt_dev = {
    "LPT", &lpt_unit, lpt_reg, lpt_mod,
    1, 10, 31, 1, 8, 8,
    NULL, NULL, &lpt_reset,
    NULL, &lpt_attach, NULL,
    &lpt_dib, DEV_DISABLE
    };


/* I/O signal handler */

uint32 lptio (DIB *dibptr, IOCYCLE signal_set, uint32 stat_data)
{
uint16 data;
IOSIGNAL signal;
IOCYCLE  working_set = IOADDSIR (signal_set);           /* add ioSIR if needed */

while (working_set) {
    signal = IONEXT (working_set);                      /* isolate next signal */

    switch (signal) {                                   /* dispatch I/O signal */

        case ioCLF:                                     /* clear flag flip-flop */
            lpt.flag = lpt.flagbuf = CLEAR;
            break;


        case ioSTF:                                     /* set flag flip-flop */
        case ioENF:                                     /* enable flag */
            lpt.flag = lpt.flagbuf = SET;
            break;


        case ioSFC:                                     /* skip if flag is clear */
            setstdSKF (lpt);
            break;


        case ioSFS:                                     /* skip if flag is set */
            setstdSKF (lpt);
            break;


        case ioIOI:                                         /* I/O data input */
            data = 0;

            if (lpt_unit.flags & UNIT_POWEROFF)             /* power off? */
                data = LPT_PWROFF;

            else if (!(lpt_unit.flags & UNIT_OFFLINE)) {    /* online? */
                if (lpt_unit.flags & UNIT_ATT) {            /* paper loaded? */
                    data = LPT_RDY;
                    if (!sim_is_active (&lpt_unit))         /* printer busy? */
                        data = data | LPT_NBSY;
                    }

                else if (lpt_lcnt == LPT_PAGELNT - 1)       /* paper out, at BOF? */
                    data = LPT_PAPO;
                }

            stat_data = IORETURN (SCPE_OK, data);           /* merge in return status */
            break;


        case ioIOO:                                     /* I/O data output */
            lpt_unit.buf = IODATA (stat_data) & (LPT_CTL | 0177);
            break;


        case ioPOPIO:                                   /* power-on preset to I/O */
            lpt.flag = lpt.flagbuf = SET;               /* set flag and flag buffer */
            lpt_unit.buf = 0;                           /* clear output buffer */
            break;

        case ioCRS:                                     /* control reset */
        case ioCLC:                                     /* clear control flip-flop */
            lpt.control = CLEAR;
            break;


        case ioSTC:                                     /* set control flip-flop */
            lpt.control = SET;
            sim_activate (&lpt_unit,                    /* schedule op */
                (lpt_unit.buf & LPT_CTL)? lpt_ptime: lpt_ctime);
            break;


        case ioSIR:                                     /* set interrupt request */
            setstdPRL (lpt);                            /* set standard PRL signal */
            setstdIRQ (lpt);                            /* set standard IRQ signal */
            setstdSRQ (lpt);                            /* set standard SRQ signal */
            break;


        case ioIAK:                                     /* interrupt acknowledge */
            lpt.flagbuf = CLEAR;
            break;


        default:                                        /* all other signals */
            break;                                      /*   are ignored */
        }

    working_set = working_set & ~signal;                /* remove current signal from set */
    }

return stat_data;
}


/* Unit service */

t_stat lpt_svc (UNIT *uptr)
{
int32 i, skip, chan;

if ((uptr->flags & UNIT_ATT) == 0)                      /* attached? */
    return IOERROR (lpt_stopioe, SCPE_UNATT);
else if (uptr->flags & UNIT_OFFLINE)                    /* offline? */
    return IOERROR (lpt_stopioe, STOP_OFFLINE);
else if (uptr->flags & UNIT_POWEROFF)                   /* powered off? */
    return IOERROR (lpt_stopioe, STOP_PWROFF);

lptio (&lpt_dib, ioENF, 0);                             /* set flag */

if (uptr->buf & LPT_CTL) {                              /* control word? */
    if (uptr->buf & LPT_CHAN) {
        chan = uptr->buf & LPT_CHANM;
        if (chan == 0) {                                /* top of form? */
            fputc ('\f', uptr->fileref);                /* ffeed */
            lpt_lcnt = 0;                               /* reset line cnt */
            skip = 0;
            }
        else if (chan == 1) skip = LPT_PAGELNT - lpt_lcnt - 1;
        else skip = lpt_cct[chan] - (lpt_lcnt % lpt_cct[chan]);
        }
    else {
        skip = uptr->buf & LPT_SKIPM;
        if (skip == 0) fputc ('\r', uptr->fileref);
        }
    for (i = 0; i < skip; i++) fputc ('\n', uptr->fileref);
    lpt_lcnt = (lpt_lcnt + skip) % LPT_PAGELNT;
    }
else fputc (uptr->buf & 0177, uptr->fileref);           /* no, just add char */
if (ferror (uptr->fileref)) {
    perror ("LPT I/O error");
    clearerr (uptr->fileref);
    return SCPE_IOERR;
    }
lpt_unit.pos = ftell (uptr->fileref);                   /* update pos */
return SCPE_OK;
}


/* Reset routine */

t_stat lpt_reset (DEVICE *dptr)
{
IOPRESET (&lpt_dib);                                    /* PRESET device (does not use PON) */

sim_cancel (&lpt_unit);                                 /* deactivate unit */
return SCPE_OK;
}


/* Restart I/O routine

   If I/O is started via STC, and the printer is powered off, offline,
   or out of paper, the CTL and CMD flip-flops will set, a service event
   will be scheduled, and the service routine will be entered.  If
   STOP_IOE is not set, the I/O operation will "hang" at that point
   until the printer is powered on, set online, or paper is supplied
   (attached).

   If a pending operation is "hung" when this routine is called, it is
   restarted, which clears CTL and sets FBF and FLG, completing the
   original I/O request.
 */

t_stat lpt_restart (UNIT *uptr, int32 value, char *cptr, void *desc)
{
if (lpt.control && !sim_is_active (uptr))
    sim_activate (uptr, 0);                             /* reschedule I/O */
return SCPE_OK;
}


/* Attach routine */

t_stat lpt_attach (UNIT *uptr, char *cptr)
{
lpt_lcnt = 0;                                           /* top of form */
lpt_restart (uptr, 0, NULL, NULL);                      /* restart I/O if hung */
return attach_unit (uptr, cptr);
}
