First Commit of my working state

[simh.git] / ALTAIR / altair_dsk.c

/* altair_dsk.c: MITS Altair 88-DISK Simulator\r
\r
   Copyright (c) 1997-2005, Charles E. Owen\r
\r
   Permission is hereby granted, free of charge, to any person obtaining a\r
   copy of this software and associated documentation files (the "Software"),\r
   to deal in the Software without restriction, including without limitation\r
   the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
   and/or sell copies of the Software, and to permit persons to whom the\r
   Software is furnished to do so, subject to the following conditions:\r
\r
   The above copyright notice and this permission notice shall be included in\r
   all copies or substantial portions of the Software.\r
\r
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL\r
   ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
   IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
\r
   Except as contained in this notice, the name of Charles E. Owen shall not be\r
   used in advertising or otherwise to promote the sale, use or other dealings\r
   in this Software without prior written authorization from Charles E. Owen.\r
\r
    The 88_DISK is a 8-inch floppy controller which can control up\r
    to 16 daisy-chained Pertec FD-400 hard-sectored floppy drives.\r
    Each diskette has physically 77 tracks of 32 137-byte sectors\r
    each.\r
\r
    The controller is interfaced to the CPU by use of 3 I/O addreses,\r
    standardly, these are device numbers 10, 11, and 12 (octal).\r
\r
    Address     Mode    Function\r
    -------             ----    --------\r
\r
        10              Out             Selects and enables Controller and Drive\r
        10              In              Indicates status of Drive and Controller\r
        11              Out             Controls Disk Function\r
        11              In              Indicates current sector position of disk\r
        12              Out             Write data\r
        12              In              Read data\r
\r
    Drive Select Out (Device 10 OUT):\r
\r
    +---+---+---+---+---+---+---+---+\r
    | C | X | X | X |   Device      |\r
    +---+---+---+---+---+---+---+---+\r
\r
    C = If this bit is 1, the disk controller selected by 'device' is\r
        cleared. If the bit is zero, 'device' is selected as the\r
        device being controlled by subsequent I/O operations.\r
    X = not used\r
    Device = value zero thru 15, selects drive to be controlled.\r
\r
    Drive Status In (Device 10 IN):\r
\r
    +---+---+---+---+---+---+---+---+\r
    | R | Z | I | X | X | H | M | W |\r
    +---+---+---+---+---+---+---+---+\r
\r
    W - When 0, write circuit ready to write another byte.\r
    M - When 0, head movement is allowed\r
    H - When 0, indicates head is loaded for read/write\r
    X - not used (will be 0)\r
    I - When 0, indicates interrupts enabled (not used this simulator)\r
    Z - When 0, indicates head is on track 0\r
    R - When 0, indicates that read circuit has new byte to read\r
\r
    Drive Control (Device 11 OUT):\r
\r
    +---+---+---+---+---+---+---+---+\r
    | W | C | D | E | U | H | O | I |\r
    +---+---+---+---+---+---+---+---+\r
\r
    I - When 1, steps head IN one track\r
    O - When 1, steps head OUT out track\r
    H - When 1, loads head to drive surface\r
    U - When 1, unloads head\r
    E - Enables interrupts (ignored this simulator)\r
    D - Disables interrupts (ignored this simulator)\r
    C - When 1 lowers head current (ignored this simulator)\r
    W - When 1, starts Write Enable sequence:   W bit on device 10\r
        (see above) will go 1 and data will be read from port 12\r
        until 137 bytes have been read by the controller from\r
        that port.  The W bit will go off then, and the sector data\r
        will be written to disk. Before you do this, you must have\r
        stepped the track to the desired number, and waited until\r
        the right sector number is presented on device 11 IN, then\r
        set this bit.\r
\r
    Sector Position (Device 11 IN):\r
\r
    As the sectors pass by the read head, they are counted and the\r
    number of the current one is available in this register.\r
\r
    +---+---+---+---+---+---+---+---+\r
    | X | X |  Sector Number    | T |\r
    +---+---+---+---+---+---+---+---+\r
\r
    X = Not used\r
    Sector number = binary of the sector number currently under the\r
        head, 0-31.\r
    T = Sector True, is a 1 when the sector is positioned to read or\r
        write.\r
\r
*/\r
\r
#include <stdio.h>\r
\r
#include "altair_defs.h"\r
\r
#define UNIT_V_ENABLE   (UNIT_V_UF + 0)                 /* Write Enable */\r
#define UNIT_ENABLE (1 << UNIT_V_ENABLE)\r
\r
#define DSK_SECTSIZE 137\r
#define DSK_SECT 32\r
#define DSK_TRACSIZE 4384\r
#define DSK_SURF 1\r
#define DSK_CYL 77\r
#define DSK_SIZE (DSK_SECT * DSK_SURF * DSK_CYL * DSK_SECTSIZE)\r
\r
t_stat dsk_svc (UNIT *uptr);\r
t_stat dsk_reset (DEVICE *dptr);\r
void writebuf();\r
\r
extern int32 PCX;\r
\r
/* Global data on status */\r
\r
int32 cur_disk = 8;                                     /* Currently selected drive */\r
int32 cur_track[9] = {0, 0, 0, 0, 0, 0, 0, 0, 377};\r
int32 cur_sect[9] = {0, 0, 0, 0, 0, 0, 0, 0, 377};\r
int32 cur_byte[9] = {0, 0, 0, 0, 0, 0, 0, 0, 377};\r
int32 cur_flags[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};\r
\r
char dskbuf[137];                                       /* Data Buffer */\r
int32 dirty = 0;                                        /* 1 when buffer has unwritten data in it */\r
UNIT *dptr;                                             /* fileref to write dirty buffer to */\r
\r
int32 dsk_rwait = 100;                                  /* rotate latency */\r
\r
\r
/* 88DSK Standard I/O Data Structures */\r
\r
UNIT dsk_unit[] = {\r
    { UDATA (&dsk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE, DSK_SIZE)  },\r
    { UDATA (&dsk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE, DSK_SIZE)  },\r
    { UDATA (&dsk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE, DSK_SIZE)  },\r
    { UDATA (&dsk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE, DSK_SIZE)  },\r
    { UDATA (&dsk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE, DSK_SIZE)  },\r
    { UDATA (&dsk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE, DSK_SIZE)  },\r
    { UDATA (&dsk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE, DSK_SIZE)  },\r
    { UDATA (&dsk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE, DSK_SIZE)  }\r
};\r
\r
REG dsk_reg[] = {\r
    { ORDATA (DISK, cur_disk, 4) },\r
    { NULL }\r
};\r
\r
DEVICE dsk_dev = {\r
    "DSK", dsk_unit, dsk_reg, NULL,\r
    8, 10, 31, 1, 8, 8,\r
    NULL, NULL, &dsk_reset,\r
    NULL, NULL, NULL\r
};\r
\r
/*  Service routines to handle simlulator functions */\r
\r
/* service routine - actually gets char & places in buffer */\r
\r
t_stat dsk_svc (UNIT *uptr)\r
{\r
return SCPE_OK;\r
}\r
\r
/* Reset routine */\r
\r
t_stat dsk_reset (DEVICE *dptr)\r
{\r
cur_disk = 0;\r
return SCPE_OK;\r
}\r
\r
/*  I/O instruction handlers, called from the CPU module when an\r
    IN or OUT instruction is issued.\r
\r
    Each function is passed an 'io' flag, where 0 means a read from\r
    the port, and 1 means a write to the port.  On input, the actual\r
    input is passed as the return value, on output, 'data' is written\r
    to the device.\r
*/\r
\r
/* Disk Controller Status/Select */\r
\r
/*  IMPORTANT: The status flags read by port 8 IN instruction are\r
    INVERTED, that is, 0 is true and 1 is false.  To handle this, the\r
    simulator keeps it's own status flags as 0=false, 1=true; and\r
    returns the COMPLEMENT of the status flags when read.  This makes\r
    setting/testing of the flag bits more logical, yet meets the\r
    simulation requirement that they are reversed in hardware.\r
*/\r
\r
int32 dsk10(int32 io, int32 data)\r
{\r
\r
    if (io == 0) {                                      /* IN: return flags */\r
        return ((~cur_flags[cur_disk]) & 0xFF);         /* Return the COMPLEMENT! */\r
    }\r
\r
    /* OUT: Controller set/reset/enable/disable */\r
\r
    if (dirty == 1)\r
        writebuf();\r
\r
    /*printf("\n[%o] OUT 10: %x", PCX, data);*/\r
    cur_disk = data & 0x0F;\r
    if (data & 0x80) {\r
        cur_flags[cur_disk] = 0;                        /* Disable drive */\r
        cur_sect[cur_disk = 0377];\r
        cur_byte[cur_disk = 0377];\r
        return (0);\r
    }\r
    cur_flags[cur_disk] = 0x1A;                         /* Enable: head move true */\r
    cur_sect[cur_disk] = 0377;                          /* reset internal counters */\r
    cur_byte[cur_disk] = 0377;\r
    if (cur_track[cur_disk] == 0)\r
        cur_flags[cur_disk] |= 0x40;                    /* track 0 if there */\r
    return (0);\r
}\r
\r
/* Disk Drive Status/Functions */\r
\r
int32 dsk11(int32 io, int32 data)\r
{\r
    int32 stat;\r
\r
    if (io == 0) {                                      /* Read sector position */\r
        /*printf("\n[%o] IN 11", PCX);*/\r
        if (dirty == 1)\r
            writebuf();\r
        if (cur_flags[cur_disk] & 0x04) {               /* head loaded? */\r
            cur_sect[cur_disk]++;\r
            if (cur_sect[cur_disk] > 31)\r
                cur_sect[cur_disk] = 0;\r
            cur_byte[cur_disk] = 0377;\r
            stat = cur_sect[cur_disk] << 1;\r
            stat &= 0x3E;                               /* return 'sector true' bit = 0 (true) */\r
            stat |= 0xC0;                               /* set on 'unused' bits */\r
            return (stat);\r
        } else {\r
            return (0);                                 /* head not loaded - return 0 */\r
        }\r
    }\r
\r
    /* Drive functions */\r
\r
    if (cur_disk > 7)\r
        return (0);                                     /* no drive selected - can do nothin */\r
\r
    /*printf("\n[%o] OUT 11: %x", PCX, data);*/\r
    if (data & 0x01) {                                  /* Step head in */\r
        cur_track[cur_disk]++;\r
        if (cur_track[cur_disk] > 76 )\r
            cur_track[cur_disk] = 76;\r
        if (dirty == 1)\r
            writebuf();\r
        cur_sect[cur_disk] = 0377;\r
        cur_byte[cur_disk] = 0377;\r
    }\r
\r
    if (data & 0x02) {                                  /* Step head out */\r
        cur_track[cur_disk]--;\r
        if (cur_track[cur_disk] < 0) {\r
            cur_track[cur_disk] = 0;\r
            cur_flags[cur_disk] |= 0x40;                /* track 0 if there */\r
        }\r
        if (dirty == 1)\r
            writebuf();\r
        cur_sect[cur_disk] = 0377;\r
        cur_byte[cur_disk] = 0377;\r
    }\r
\r
    if (dirty == 1)\r
        writebuf();\r
\r
    if (data & 0x04) {                                  /* Head load */\r
        cur_flags[cur_disk] |= 0x04;                    /* turn on head loaded bit */\r
        cur_flags[cur_disk] |= 0x80;                    /* turn on 'read data available */\r
    }\r
\r
    if (data & 0x08) {                                  /* Head Unload */\r
        cur_flags[cur_disk] &= 0xFB;                    /* off on 'head loaded' */\r
        cur_flags[cur_disk] &= 0x7F;                    /* off on 'read data avail */\r
        cur_sect[cur_disk] = 0377;\r
        cur_byte[cur_disk] = 0377;\r
    }\r
\r
    /* Interrupts & head current are ignored */\r
\r
    if (data & 0x80) {                                  /* write sequence start */\r
        cur_byte[cur_disk] = 0;\r
        cur_flags[cur_disk] |= 0x01;                    /* enter new write data on */\r
    }\r
    return 0;\r
}\r
\r
/* Disk Data In/Out*/\r
\r
int32 dsk12(int32 io, int32 data)\r
{\r
    static int32 rtn, i;\r
    static long pos;\r
    UNIT *uptr;\r
\r
    uptr = dsk_dev.units + cur_disk;\r
    if (io == 0) {\r
        if ((i = cur_byte[cur_disk]) < 138) {           /* just get from buffer */\r
            cur_byte[cur_disk]++;\r
            return (dskbuf[i] & 0xFF);\r
        }\r
        /* physically read the sector */\r
        /*printf("\n[%o] IN 12 (READ) T%d S%d", PCX, cur_track[cur_disk],\r
                        cur_sect[cur_disk]);*/\r
        pos = DSK_TRACSIZE * cur_track[cur_disk];\r
        pos += DSK_SECTSIZE * cur_sect[cur_disk];\r
        rtn = fseek(uptr -> fileref, pos, 0);\r
        rtn = fread(dskbuf, 137, 1, uptr -> fileref);\r
        cur_byte[cur_disk] = 1;\r
        return (dskbuf[0] & 0xFF);\r
    } else {\r
        if (cur_byte[cur_disk] > 136) {\r
            i = cur_byte[cur_disk];\r
            dskbuf[i] = data & 0xFF;\r
            writebuf();\r
            return (0);\r
        }\r
        i = cur_byte[cur_disk];\r
        dirty = 1;\r
        dptr = uptr;\r
        dskbuf[i] = data & 0xFF;\r
        cur_byte[cur_disk]++;\r
        return (0);\r
    }\r
}\r
\r
void writebuf()\r
{\r
    long pos;\r
    int32 rtn, i;\r
\r
    i = cur_byte[cur_disk];                             /* null-fill rest of sector if any */\r
    while (i < 138) {\r
        dskbuf[i] = 0;\r
        i++;\r
    }\r
    /*printf("\n[%o] OUT 12 (WRITE) T%d S%d", PCX, cur_track[cur_disk],\r
                        cur_sect[cur_disk]); i = getch(); */\r
    pos = DSK_TRACSIZE * cur_track[cur_disk];           /* calc file pos */\r
    pos += DSK_SECTSIZE * cur_sect[cur_disk];\r
    rtn = fseek(dptr -> fileref, pos, 0);\r
    rtn = fwrite(dskbuf, 137, 1, dptr -> fileref);\r
    cur_flags[cur_disk] &= 0xFE;                        /* ENWD off */\r
    cur_byte[cur_disk] = 0377;\r
    dirty = 0;\r
    return;\r
}\r