/* s3_disk.c: IBM 5444 Disk Drives

   Copyright (c) 2001-2005, Charles E. Owen

   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 Charles E. Owen shall not be
   used in advertising or otherwise to promote the sale, use or other dealings
   in this Software without prior written authorization from Charles E. Owen.

   r1   Removeable disk 1
   f1   Fixed disk 1
   r2   Removeable disk 2
   f2   Fixed disk 2

   25-Apr-03    RMS     Revised for extended file support
   08-Oct-02    RMS     Added impossible function catcher
*/

#include "s3_defs.h"
#include <ctype.h>

extern uint8 M[];
extern int32 IAR[], level;
extern FILE *trace;
extern int32 debug_reg;
char dbuf[DSK_SECTSIZE];                                /* Disk buffer */
int32 dsk (int32 disk, int32 op, int32 m, int32 n, int32 data);
int32 read_sector(UNIT *uptr, char *dbuf, int32 sect);
int32 write_sector(UNIT *uptr, char *dbuf, int32 sect);
t_stat r1_svc (UNIT *uptr);
t_stat r1_boot (int32 unitno, DEVICE *dptr);
t_stat r1_attach (UNIT *uptr, CONST char *cptr);
t_stat r1_reset (DEVICE *dptr);
t_stat f1_svc (UNIT *uptr);
t_stat f1_boot (int32 unitno, DEVICE *dptr);
t_stat f1_attach (UNIT *uptr, CONST char *cptr);
t_stat f1_reset (DEVICE *dptr);
t_stat r2_svc (UNIT *uptr);
t_stat r2_boot (int32 unitno, DEVICE *dptr);
t_stat r2_attach (UNIT *uptr, CONST char *cptr);
t_stat r2_reset (DEVICE *dptr);
t_stat f2_svc (UNIT *uptr);
t_stat f2_boot (int32 unitno, DEVICE *dptr);
t_stat f2_attach (UNIT *uptr, CONST char *cptr);
t_stat f2_reset (DEVICE *dptr);
extern int32 GetMem(int32 addr);
extern int32 PutMem(int32 addr, int32 data);

char opstr[5][5] = { "SIO", "LIO", "TIO", "SNS", "APL" };

int32 DDAR[2];                                          /* Data address register */
int32 DCAR[2];                                          /* Disk Control Address Register */
int32 diskerr[2] = { 0, 0 };                            /* Error status */
int32 notrdy[2] = { 0, 0 };                             /* Not ready error */
int32 seekbusy[2] = { 0, 0 };                           /* Drive busy flags */
int32 seekhead[2] = { 0, 0 };                           /* Disk head 0,1 */
int32 found[2] = { 0, 0 };                              /* Scan found bit */
int32 RIDsect[2] = { 0, 0 };                            /* for Read ID */

/* Disk data structures

   xy_dev       CDR descriptor
   xy_unit      CDR unit descriptor
   xy_reg       CDR register list

   x = F or R
   y = 1 or 2
*/

UNIT r1_unit = { UDATA (&r1_svc, UNIT_FIX+UNIT_ATTABLE, 0), 100 };

REG r1_reg[] = {
    { FLDATA (NOTRDY, notrdy[0], 0) },
    { FLDATA (SEEK, seekbusy[0], 0) },
    { HRDATA (DAR, DDAR[0], 16) },
    { HRDATA (CAR, DCAR[0], 16) },
    { HRDATA (ERR, diskerr[0], 16) },
    { DRDATA (CYL, r1_unit.u3, 8) },
    { DRDATA (HEAD, seekhead[0], 8) },
    { DRDATA (POS, r1_unit.pos, T_ADDR_W), PV_LEFT },
    { DRDATA (TIME, r1_unit.wait, 24), PV_LEFT },
    { BRDATA (BUF, dbuf, 8, 8, 256) },
    { NULL }
};

DEVICE r1_dev = {
    "R1", &r1_unit, r1_reg, NULL,
    1, 10, 31, 1, 8, 7,
    NULL, NULL, &r1_reset,
    &r1_boot, &r1_attach, NULL
};

UNIT f1_unit = { UDATA (&f1_svc, UNIT_FIX+UNIT_ATTABLE, 0), 100 };

REG f1_reg[] = {
    { FLDATA (NOTRDY, notrdy[0], 0) },
    { FLDATA (SEEK, seekbusy[0], 0) },
    { HRDATA (DAR, DDAR[0], 16) },
    { HRDATA (CAR, DCAR[0], 16) },
    { HRDATA (ERR, diskerr[0], 16) },
    { DRDATA (CYL, f1_unit.u3, 8) },
    { DRDATA (HEAD, seekhead[0], 8) },
    { DRDATA (POS, f1_unit.pos, 32), PV_LEFT },
    { DRDATA (TIME, f1_unit.wait, 24), PV_LEFT },
    { BRDATA (BUF, dbuf, 8, 8, 256) },
    { NULL }
};

DEVICE f1_dev = {
    "F1", &f1_unit, f1_reg, NULL,
    1, 10, 31, 1, 8, 7,
    NULL, NULL, &f1_reset,
    &f1_boot, &f1_attach, NULL
};

UNIT r2_unit = { UDATA (&r2_svc, UNIT_FIX+UNIT_ATTABLE, 0), 100 };

REG r2_reg[] = {
    { FLDATA (NOTRDY, notrdy[1], 0) },
    { FLDATA (SEEK, seekbusy[1], 0) },
    { HRDATA (DAR, DDAR[1], 16) },
    { HRDATA (CAR, DCAR[1], 16) },
    { HRDATA (ERR, diskerr[1], 16) },
    { DRDATA (CYL, r2_unit.u3, 8) },
    { DRDATA (HEAD, seekhead[1], 8) },
    { DRDATA (POS, r2_unit.pos, 32), PV_LEFT },
    { DRDATA (TIME, r2_unit.wait, 24), PV_LEFT },
    { BRDATA (BUF, dbuf, 8, 8, 256) },
    { NULL }
};

DEVICE r2_dev = {
    "R2", &r2_unit, r2_reg, NULL,
    1, 10, 31, 1, 8, 7,
    NULL, NULL, &r2_reset,
    &r2_boot, &r2_attach, NULL
};

UNIT f2_unit = { UDATA (&f2_svc, UNIT_FIX+UNIT_ATTABLE, 0), 100 };

REG f2_reg[] = {
    { FLDATA (NOTRDY, notrdy[1], 0) },
    { FLDATA (SEEK, seekbusy[1], 0) },
    { HRDATA (DAR, DDAR[1], 16) },
    { HRDATA (CAR, DCAR[1], 16) },
    { HRDATA (ERR, diskerr[1], 16) },
    { DRDATA (CYL, f2_unit.u3, 8) },
    { DRDATA (HEAD, seekhead[1], 8) },
    { DRDATA (POS, f2_unit.pos, 32), PV_LEFT },
    { DRDATA (TIME, f2_unit.wait, 24), PV_LEFT },
    { BRDATA (BUF, dbuf, 8, 8, 256) },
    { NULL }
};

DEVICE f2_dev = {
    "F2", &f2_unit, f2_reg, NULL,
    1, 10, 31, 1, 8, 7,
    NULL, NULL, &f2_reset,
    &f2_boot, &f2_attach, NULL
};

/* -------------------------------------------------------------------- */

/* 5444: master routines */

int32 dsk1 (int32 op, int32 m, int32 n, int32 data)
{
    int32 r;
    
    r = dsk(0, op, m, n, data);
    return (r);
}

int32 dsk2 (int32 op, int32 m, int32 n, int32 data)
{
    int32 r;
    
    r = dsk(1, op, m, n, data);
    return (r);
}

/* 5444: operational routine */

int32 dsk (int32 disk, int32 op, int32 m, int32 n, int32 data)
{
    int32 iodata, i, j, u, sect, nsects, addr, r, c, res;
    int32 F, C, S, N, usave;
    UNIT *uptr;
    
    u = m;
    if (disk == 1) u += 2;
    F = GetMem(DCAR[disk]+0);                           /* Flag bits */
    C = GetMem(DCAR[disk]+1);                           /* Cylinder */
    S = GetMem(DCAR[disk]+2);                           /* Sector */
    N = GetMem(DCAR[disk]+3);                           /* Number of sectors */
    switch (u) {
        case 0:
            uptr = r1_dev.units;
            break;
        case 1:
            uptr = f1_dev.units;
            break;
        case 2:
            uptr = r2_dev.units;
            break;
        case 3:
            uptr = f2_dev.units;
            break;
        default:
            break;
    }
    if (debug_reg & 0x02)
        fprintf(trace, "==> %04X %s %01X,%d,%04X DAR=%04X CAR=%04X C=%02X, S=%02X, N=%02X\n",
            IAR[level],
            opstr[op],
            m, n, data,
            DDAR[disk],
            DCAR[disk],
            C, S, N);

    switch (op) {

        /* SIO 5444 */
        case 0:
            if ((uptr->flags & UNIT_ATT) == 0)
                return SCPE_UNATT;
            diskerr[disk] = 0;                          /* SIO resets errors */
            found[disk] = 0;                            /* ... and found bit */
            iodata = 0;
            switch (n) {
                case 0x00:                              /* Seek */
                    if (S & 0x80)
                        seekhead[disk] = 1;
                        else
                        seekhead[disk] = 0;
                    if (S & 1) {
                        uptr -> u3 += N;
                    } else {
                        uptr -> u3 -= N;
                    }
                    if (uptr -> u3 < 0)
                        uptr -> u3 = 0;
                    if (uptr -> u3 > 203) {
                        uptr -> u3 = 0;
                        diskerr[disk] |= 0x0100;
                        if (debug_reg & 0x02)
                            fprintf(trace, "==> Seek Past End of Disk\n");
                    }   

                    /*sim_activate(uptr, uptr -> wait);*/               
                    sim_activate(uptr, 1);              
                    
                    /* Seek arms are the same for both disks on a drive:
                       update the other arm */
                            
                    usave = uptr -> u3;     
                    if (u == 0) uptr = f1_dev.units;
                    if (u == 1) uptr = r1_dev.units;
                    if (u == 2) uptr = f2_dev.units;
                    if (u == 3) uptr = r2_dev.units;
                    uptr -> u3 = usave;     
                            
                    seekbusy[disk] = 1; 
                    iodata = SCPE_OK;
                    break;

                case 0x01:                              /* Read */
                    switch (data) {
                        case 0:                         /* Read data */
                            sect = (S >> 2) & 0x3F;
                            nsects = N + 1;
                            addr = DDAR[disk];

                            for (i = 0; i < nsects; i++) {
                                r = read_sector(uptr, dbuf, sect);
                                if (r != 1 || uptr->u3 != C) {
                                    diskerr[disk] |= 0x0800;
                                    break;
                                }   
                                for (j = 0; j < DSK_SECTSIZE; j++) {
                                    PutMem(addr, dbuf[j]);
                                    addr++;
                                }

                                if (sect == 55) {       /* HJS MODS */
                                    S = sect;
                                    N = nsects - i - 2;
                                    if (N > -1) diskerr[disk] |= 0x0020; /* end of cyl. */
                                    DDAR[disk] = addr & 0xFFFF;  /* HJS mod */
                                    PutMem(DCAR[disk]+2, S << 2);
                                    PutMem(DCAR[disk]+3, N);
                                    sim_activate(uptr, 1);
                                    iodata = SCPE_OK;
                                    break;
                                }

                                sect++;
                                S = sect - 1;
                                N = nsects - i - 2;
                                if (sect == 24)
                                    sect = 32;
                            }
                            DDAR[disk] = addr & 0xFFFF;   /* HJS mod */
                            PutMem(DCAR[disk]+2, S << 2);
                            PutMem(DCAR[disk]+3, N);
                            /*sim_activate(uptr, uptr -> wait);*/
                            sim_activate(uptr, 1);
                            iodata = SCPE_OK;
                            break;
                        case 1:                         /* Read ID */
                            if (uptr -> u3 > 0 && uptr -> u3 < 4)
                                PutMem(DCAR[disk], 1);
                                else
                                PutMem(DCAR[disk], 0);
                            PutMem(DCAR[disk]+1, uptr -> u3);
                            PutMem(DCAR[disk]+2, RIDsect[disk]);
                            RIDsect[disk]++;
                            if (RIDsect[disk] > 23)
                                RIDsect[disk] = 32;
                            if (RIDsect[disk] > 55)
                                RIDsect[disk] = 0;  
                            break;
                        case 2:                         /* Read Diagnostic */
                            iodata = STOP_INVDEV;
                            break;
                        case 3:                         /* Verify */
                            sect = (S >> 2) & 0x3F;
                            nsects = N + 1;
                            addr = DDAR[disk];
                            for (i = 0; i < nsects; i++) {
                                r = read_sector(uptr, dbuf, sect);
                                if (r != 1 || uptr->u3 != C) {
                                    diskerr[disk] |= 0x0800;
                                    break;
                                }   
                                if (sect == 55) {       /* HJS MODS */
                                    S = sect;
                                    N = nsects - i - 2;
                                    if (N > -1) diskerr[disk] |= 0x0020; /* end of cyl. */
                                    DDAR[disk] = addr & 0xFFFF;
                                    PutMem(DCAR[disk]+2, S << 2);
                                    PutMem(DCAR[disk]+3, N);
                                    sim_activate(uptr, 1);
                                    iodata = SCPE_OK;
                                    break;
                                }
                                sect++;
                                S = sect - 1;
                                N = nsects - i - 2;
                                if (sect == 24)
                                    sect = 32;
                            }
                            DDAR[disk] = addr & 0xFFFF;
                            PutMem(DCAR[disk]+2, S << 2);
                            PutMem(DCAR[disk]+3, N);
                            /*sim_activate(uptr, uptr -> wait);*/
                            sim_activate(uptr, 1);
                            break;      
                        default:
                            return STOP_INVDEV;
                    }                               
                    break;
                case 0x02:                              /* Write */
                    switch (data) {
                        case 0:                         /* Write Data */
                            sect = (S >> 2) & 0x3F;
                            nsects = N + 1;
                            addr = DDAR[disk];
                            for (i = 0; i < nsects; i++) {
                                for (j = 0; j < DSK_SECTSIZE; j++) {
                                    dbuf[j] = GetMem(addr);
                                    addr++;
                                }
                                r = write_sector(uptr, dbuf, sect);
                                if (r != 1 || uptr->u3 != C) {
                                    diskerr[disk] |= 0x0400;
                                    break;
                                }   
                                if (sect == 55) {   /* HJS MODS */
                                    S = sect;
                                    N = nsects - i - 2;
                                    if (N > -1) diskerr[disk] |= 0x0020; /* end of cyl. */
                                    DDAR[disk] = addr & 0xFFFF;
                                    PutMem(DCAR[disk]+2, S << 2);
                                    PutMem(DCAR[disk]+3, N);
                                    sim_activate(uptr, 1);
                                    iodata = SCPE_OK;
                                    break;
                                }
                                sect++;
                                S = sect - 1;
                                N = nsects - i - 2;
                                if (sect == 24)
                                    sect = 32;
                            }
                            DDAR[disk] = addr & 0xFFFF;  /* HJS mod */
                            PutMem(DCAR[disk]+2, S << 2);
                            PutMem(DCAR[disk]+3, N);
                            /*sim_activate(uptr, uptr -> wait);*/
                            sim_activate(uptr, 1);
                            break;
                        case 1:                         /* Write identifier */
                            if (seekhead[disk] == 0)
                                S = 0;
                                else
                                S = 0x80;
                            N = 23;

                            sect = (S >> 2) & 0x3F;
                            nsects = N + 1;
                            addr = DDAR[disk];
                            for (i = 0; i < nsects; i++) {
                                for (j = 0; j < DSK_SECTSIZE; j++) {
                                    dbuf[j] = GetMem(addr);
                                }
                                r = write_sector(uptr, dbuf, sect);
                                if (r != 1) {
                                    diskerr[disk] |= 0x0400;
                                    break;
                                }   
                                if (sect == 55) {
                                    S = sect;
                                    N = nsects - i - 2;
                                    if (N > 0) diskerr[disk] |= 0x0020;
                                        DDAR[disk] = addr & 0xFFFF;
                                    PutMem(DCAR[disk]+2, S << 2);
                                    PutMem(DCAR[disk]+3, N);
                                    sim_activate(uptr, 1);
                                    iodata = SCPE_OK;
                                    break;
                                }
                                sect++;
                                S = sect - 1;
                                N = nsects - i - 2;
                                if (sect == 24)
                                    sect = 32;
                            }
                            DDAR[disk] = addr & 0xFFFF;
                            PutMem(DCAR[disk]+2, S << 2);
                            PutMem(DCAR[disk]+3, N);
                            /*sim_activate(uptr, uptr -> wait);*/
                            sim_activate(uptr, 1);
                            break;
                        default:
                            return STOP_INVDEV;
                    }                               
                    break;
                case 0x03:                              /* Scan */
                    sect = (S >> 2) & 0x3F;
                    nsects = N + 1;
                    addr = DDAR[disk];
                    for (i = 0; i < nsects; i++) {
                        r = read_sector(uptr, dbuf, sect);
                        if (r != 1 || uptr->u3 != C) {
                            diskerr[disk] |= 0x0800;
                            break;
                        }
                        res = 0;    
                        for (j = 0; j < DSK_SECTSIZE; j++) {
                            c = GetMem(addr);
                            if (j != 0xff) {
                                if (dbuf[i] < c)
                                    res = 1;
                                if (dbuf[i] > c)
                                    res = 3;    
                            }
                            addr++;
                        }
                        if (res == 0)
                            found[disk] = 1;
                        if (res == data)
                            break;
                        if (sect == 55) {               /* HJS MODS */
                            S = sect;
                            N = nsects - i - 2;
                            if (N > -1) diskerr[disk] |= 0x0020; /* end of cyl. */
                            DDAR[disk] = addr & 0xFFFF;
                            PutMem(DCAR[disk]+2, S << 2);
                            PutMem(DCAR[disk]+3, N);
                            sim_activate(uptr, 1);
                            iodata = SCPE_OK;
                            break;
                        }
                        sect++;
                        S = sect - 1;
                        N = nsects - i - 2;
                        if (sect == 24)
                            sect = 32;
                    }
                    PutMem(DCAR[disk]+2, S << 2);
                    PutMem(DCAR[disk]+3, N);
                    /*sim_activate(uptr, uptr -> wait);*/
                    sim_activate(uptr, 1);
                    break;
                default:
                    return STOP_INVDEV;
            }
            return iodata;

        /* LIO 5444 */
        case 1:     
            if ((uptr->flags & UNIT_ATT) == 0)
                return SCPE_UNATT;
            switch (n) {
                case 0x04:                              /* Data Addr  */
                    DDAR[disk] = data;
                    break;
                case 0x06:                              /* Control Addr */
                    DCAR[disk] = data;
                    break;
                default:
                    return STOP_INVDEV;
            }
            return SCPE_OK;
        /* TIO 5444 */
        case 2:
            if ((uptr->flags & UNIT_ATT) == 0)
                return SCPE_UNATT << 16;
            iodata = 0;
            switch (n) {
                case 0x00:                              /* Error */
                    if (diskerr[disk] || notrdy[disk])
                        iodata = 1;
                    if ((uptr -> flags & UNIT_ATT) == 0)
                        iodata = 1;
                    break;
                case 0x02:                              /* Busy */
                    if (sim_is_active (uptr))
                        iodata = 1;
                    break;
                case 0x04:
                    if (found[disk])
                        iodata = 1;
                    break;          
                default:
                    return (STOP_INVDEV << 16);
            }                       
            return ((SCPE_OK << 16) | iodata);

        /* SNS 5444 */
        case 3: 
            if ((uptr->flags & UNIT_ATT) == 0)
                return SCPE_UNATT << 16;
            iodata = 0;
            switch (n) {
                case 0x01:
                    break;
                case 0x02:
                    iodata = diskerr[disk];
                    if (notrdy[disk])
                        iodata |= 0x4000;
                    if ((uptr -> flags & UNIT_ATT) == 0)
                        iodata |= 0x4000;
                    if (seekbusy[disk])
                        iodata |= 0x0010;
                    if (uptr -> u3 == 0)
                        iodata |= 0x0040;       
                    break;
                case 0x03:
                    iodata = 0;
                    break;  
                case 0x04:
                    iodata = DDAR[disk];
                    break;
                case 0x06:
                    iodata = DCAR[disk];
                    break;  
                default:
                    return (STOP_INVDEV << 16);
            }
            iodata |= ((SCPE_OK << 16) & 0xffff0000);       
            return (iodata);

        /* APL 5444 */
        case 4: 
            if ((uptr->flags & UNIT_ATT) == 0)
                return SCPE_UNATT << 16;
            iodata = 0;
            switch (n) {
                case 0x00:                              /* Error */
                    if (diskerr[disk] || notrdy[disk])
                        iodata = 1;
                    if ((uptr -> flags & UNIT_ATT) == 0)
                        iodata = 1;
                    break;
                case 0x02:                              /* Busy */
                    if (sim_is_active (uptr))
                        iodata = 1;
                    break;  
                default:
                    return (STOP_INVDEV << 16);
            }                       
            return ((SCPE_OK << 16) | iodata);
        default:
            break;
    }
    sim_printf (">>DSK%d non-existent function %d\n", disk, op);
    return SCPE_OK;                     
}

/* Disk unit service.  If a stacker select is active, copy to the
   selected stacker.  Otherwise, copy to the normal stacker.  If the
   unit is unattached, simply exit.
*/

t_stat r1_svc (UNIT *uptr)
{
seekbusy[0] = 0;
return SCPE_OK;
}
t_stat f1_svc (UNIT *uptr)
{
seekbusy[0] = 0;
return SCPE_OK;
}
t_stat r2_svc (UNIT *uptr)
{
seekbusy[1] = 0;
return SCPE_OK;
}
t_stat f2_svc (UNIT *uptr)
{
seekbusy[1] = 0;
return SCPE_OK;
}


/* Disk reset */

t_stat r1_reset (DEVICE *dptr)
{
diskerr[0] = notrdy[0] = seekbusy[0] = 0;               /* clear indicators */
found[0] = 0;
sim_cancel (&r1_unit);                                  /* clear event */
r1_unit.u3 = 0;                                         /* cylinder 0 */
return SCPE_OK;
}
t_stat f1_reset (DEVICE *dptr)
{
diskerr[0] = notrdy[0] = seekbusy[0] = 0;               /* clear indicators */
found[0] = 0;
sim_cancel (&f1_unit);                                  /* clear event */
f1_unit.u3 = 0;                                         /* cylinder 0 */
return SCPE_OK;
}
t_stat r2_reset (DEVICE *dptr)
{
diskerr[1] = notrdy[1] = seekbusy[1] = 0;               /* clear indicators */
found[1] = 0;
sim_cancel (&r2_unit);                                  /* clear event */
r2_unit.u3 = 0;                                         /* cylinder 0 */
return SCPE_OK;
}
t_stat f2_reset (DEVICE *dptr)
{
diskerr[1] = notrdy[1] = seekbusy[1] = 0;               /* clear indicators */
found[1] = 0;
sim_cancel (&f2_unit);                                  /* clear event */
f2_unit.u3 = 0;                                         /* cylinder 0 */
return SCPE_OK;
}

/* Disk unit attach */

t_stat r1_attach (UNIT *uptr, CONST char *cptr)
{
diskerr[0] = notrdy[0] = seekbusy[0] = 0;               /* clear status */
found[0] = 0;
uptr -> u3 = 0;                                         /* cylinder 0 */
return attach_unit (uptr, cptr);
}
t_stat f1_attach (UNIT *uptr, CONST char *cptr)
{
diskerr[0] = notrdy[0] = seekbusy[0] = 0;               /* clear status */
found[0] = 0;
uptr -> u3 = 0;                                         /* cylinder 0 */
return attach_unit (uptr, cptr);
}
t_stat r2_attach (UNIT *uptr, CONST char *cptr)
{
diskerr[1] = notrdy[1] = seekbusy[1] = 0;               /* clear status */
found[1] = 0;
uptr -> u3 = 0;                                         /* cylinder 0 */
return attach_unit (uptr, cptr);
}
t_stat f2_attach (UNIT *uptr, CONST char *cptr)
{
diskerr[1] = notrdy[1] = seekbusy[1] = 0;               /* clear status */
found[1] = 0;
uptr -> u3 = 0;                                         /* cylinder 0 */
return attach_unit (uptr, cptr);
}

/* Bootstrap routine */

t_stat r1_boot (int32 unitno, DEVICE *dptr)
{
int i;
r1_unit.u3 = 0;
read_sector(r1_dev.units, dbuf, 0);
for (i = 0; i < 256; i++) {
    M[i] = dbuf[i];
}
return SCPE_OK;
}
t_stat f1_boot (int32 unitno, DEVICE *dptr)
{
int i;
f1_unit.u3 = 0;
read_sector(f1_dev.units, dbuf, 0);
for (i = 0; i < 256; i++) {
    M[i] = dbuf[i];
}
return SCPE_OK;
}
t_stat r2_boot (int32 unitno, DEVICE *dptr)
{
int i;
r2_unit.u3 = 0;
read_sector(r2_dev.units, dbuf, 0);
for (i = 0; i < 256; i++) {
    M[i] = dbuf[i];
}
return SCPE_OK;
}
t_stat f2_boot (int32 unitno, DEVICE *dptr)
{
int i;
f2_unit.u3 = 0;
read_sector(f2_dev.units, dbuf, 0);
for (i = 0; i < 256; i++) {
    M[i] = dbuf[i];
}
return SCPE_OK;
}


/* Raw Disk Data In/Out */

int32 read_sector(UNIT *uptr, char *dbuf, int32 sect)
{
    static int32 rtn, realsect;
    static long pos;

                                                        /* calculate real sector no */
    if (sect > 23)
        realsect = sect - 8;
        else
        realsect = sect;
                                                        /* physically read the sector */
        pos = DSK_CYLSIZE * uptr -> u3;
        pos += DSK_SECTSIZE * realsect;
        rtn = fseek(uptr -> fileref, pos, 0);
        rtn = fread(dbuf, DSK_SECTSIZE, 1, uptr -> fileref);
        return (rtn);
}

int32 write_sector(UNIT *uptr, char *dbuf, int32 sect)
{
    static int32 rtn, realsect;
    static long pos;

                                                        /* calculate real sector no */
    if (sect > 23)
        realsect = sect - 8;
        else
        realsect = sect;
        if (uptr -> u3 == 0 && realsect == 32)
            rtn = 0;
                                                        /* physically write the sector */
        pos = DSK_CYLSIZE * uptr -> u3;
        pos += DSK_SECTSIZE * realsect;
        rtn = fseek(uptr -> fileref, pos, 0);
        rtn = fwrite(dbuf, DSK_SECTSIZE, 1, uptr -> fileref);
        return (rtn);
}
