コード例 #1
0
uint32 mtdio (uint32 select_code, IOSIG signal, uint32 data)
{
const IOSIG base_signal = IOBASE (signal);              /* derive base signal */

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

    case ioCLF:                                         /* clear flag flip-flop */
        mtd_flag = mtd_flagbuf = CLEAR;
        break;

    case ioSTF:                                         /* set flag flip-flop */
    case ioENF:                                         /* enable flag */
        mtd_flag = mtd_flagbuf = SET;
        break;

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

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

    case ioIOI:                                         /* I/O data input */
        data = mtc_unit.buf;
        break;

    case ioIOO:                                         /* I/O data output */
        mtc_unit.buf = data & 0377;                     /* store data */
        break;

    case ioPOPIO:                                       /* power-on preset to I/O */
        mt_clear ();                                    /* issue CLR to controller */
        mtd_flag = mtd_flagbuf = CLEAR;                 /* clear flag and flag buffer */
                                                        /* fall into CRS handler */
    case ioCRS:                                         /* control reset */
        break;

    case ioCLC:                                         /* clear control flip-flop */
        mtc_dtf = 0;                                    /* clr xfer flop */
        mtd_flag = mtd_flagbuf = CLEAR;                 /* clear flag and flag buffer */
        break;

    case ioSIR:                                         /* set interrupt request */
        setstdSRQ (select_code, mtd);                   /* set standard SRQ signal */
        break;

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

if (signal > ioCLF)                                     /* multiple signals? */
    mtdio (select_code, ioCLF, 0);                      /* issue CLF */
else if (signal > ioSIR)                                /* signal affected interrupt status? */
    mtdio (select_code, ioSIR, 0);                      /* set interrupt request */

return data;
}
コード例 #2
0
static u_char
dynalink_read_reg(u_char *base, u_int offset)
{
	outb(IOBASE(base)+ADDR, (offset+IS_HSCXB_HACK(base))&ADDRMASK);
	return (inb(IOADDR(base)));
}
コード例 #3
0
static void
dynalink_write_reg(u_char *base, u_int offset, u_int v)
{
	outb(IOBASE(base)+ADDR, (offset+IS_HSCXB_HACK(base))&ADDRMASK);
	outb(IOADDR(base), (u_char)v);
}
コード例 #4
0
static void
dynalink_write_fifo(void *base, const void *buf, size_t len)
{
	outb(IOBASE(base)+ADDR, 0+IS_HSCXB_HACK(base));
	outsb(IOADDR(base), (u_char *)buf, (u_int)len);
}
コード例 #5
0
uint32 mtcio (uint32 select_code, IOSIG signal, uint32 data)
{
const IOSIG base_signal = IOBASE (signal);              /* derive base signal */
uint32 i;
int32 valid;

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

    case ioCLF:                                         /* clear flag flip-flop */
        mtc_flag = mtc_flagbuf = CLEAR;
        break;


    case ioSTF:                                         /* set flag flip-flop */
    case ioENF:                                         /* enable flag */
        mtc_flag = mtc_flagbuf = SET;
        break;


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


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


    case ioIOI:                                         /* I/O data input */
        data = mtc_sta & ~(STA_LOCAL | STA_WLK | STA_BUSY);

        if (mtc_unit.flags & UNIT_ATT) {                /* construct status */
            if (sim_is_active (&mtc_unit))
                data = data | STA_BUSY;

            if (sim_tape_wrp (&mtc_unit))
                data = data | STA_WLK;
            }
        else
            data = data | STA_BUSY | STA_LOCAL;
        break;


    case ioIOO:                                         /* I/O data output */
        data = data & 0377;
        mtc_sta = mtc_sta & ~STA_REJ;                   /* clear reject */

        if (data == FNC_CLR) {                          /* clear? */
            mt_clear ();                                /* send CLR to controller */

            mtd_flag = mtd_flagbuf = CLEAR;             /* clear data flag and flag buffer */
            mtc_flag = mtc_flagbuf = SET;               /* set command flag and flag buffer */
            break;                                      /* command completes immediately */
            }

        for (i = valid = 0; i < sizeof (mtc_cmd); i++)  /* is fnc valid? */
            if (data == mtc_cmd[i])
                valid = 1;

        if (!valid || sim_is_active (&mtc_unit) ||      /* is cmd valid? */
           ((mtc_sta & STA_BOT) && (data == FNC_BSR)) ||
           (sim_tape_wrp (&mtc_unit) &&
             ((data == FNC_WC) || (data == FNC_GAP) || (data == FNC_WFM))))
            mtc_sta = mtc_sta | STA_REJ;

        else {
            sim_activate (&mtc_unit, mtc_ctime);        /* start tape */
            mtc_fnc = data;                             /* save function */
            mtc_sta = STA_BUSY;                         /* unit busy */
            mt_ptr = 0;                                 /* init buffer ptr */

            mtcio (select_code, ioCLF, 0);              /* clear flags */
            mtcio (mtd_dib.devno, ioCLF, 0);

            mtc_1st = 1;                                /* set 1st flop */
            mtc_dtf = 1;                                /* set xfer flop */
            }
        break;


    case ioPOPIO:                                       /* power-on preset to I/O */
        mtc_flag = mtc_flagbuf = CLEAR;                 /* clear flag and flag buffer */
                                                        /* fall into CRS handler */

    case ioCRS:                                         /* control reset */
                                                        /* fall into CLC handler */

    case ioCLC:                                         /* clear control flip-flop */
        mtc_control = CLEAR;
        break;


    case ioSTC:                                         /* set control flip-flop */
        mtc_control = SET;
        break;


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

    case ioIAK:                                         /* interrupt acknowledge */
        mtc_flagbuf = CLEAR;
        break;


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


if (signal > ioCLF)                                     /* multiple signals? */
    mtcio (select_code, ioCLF, 0);                      /* issue CLF */
else if (signal > ioSIR)                                /* signal affected interrupt status? */
    mtcio (select_code, ioSIR, 0);                      /* set interrupt request */

return data;
}
コード例 #6
0
ファイル: hp2100_lpt.c プロジェクト: jehurodrig/simh-pre-git
uint32 lptio (uint32 select_code, IOSIG signal, uint32 data)
{
const IOSIG base_signal = IOBASE (signal);              /* derive base signal */

switch (base_signal) {                                  /* dispatch base 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 */
        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;
            }

        else
            data = 0;
        break;


    case ioIOO:                                         /* I/O data output */
        lpt_unit.buf = 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 */
                                                        /* fall into CRS handler */

    case ioCRS:                                         /* control reset */
                                                        /* fall into CLC handler */

    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 (select_code, lpt);                   /* set standard PRL signal */
        setstdIRQ (select_code, lpt);                   /* set standard IRQ signal */
        setstdSRQ (select_code, lpt);                   /* set standard SRQ signal */
        break;


    case ioIAK:                                         /* interrupt acknowledge */
        lpt_flagbuf = CLEAR;
        break;


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


if (signal > ioCLF)                                     /* multiple signals? */
    lptio (select_code, ioCLF, 0);                      /* issue CLF */
else if (signal > ioSIR)                                /* signal affected interrupt status? */
    lptio (select_code, ioSIR, 0);                      /* set interrupt request */

return data;
}