SDS/sds_dsk.c

   1 /* sds_dsk.c: SDS 940 moving head disk simulator
   2
   3    Copyright (c) 2001-2005, Robert M. Supnik
   4
   5    Permission is hereby granted, free of charge, to any person obtaining a
   6    copy of this software and associated documentation files (the "Software"),
   7    to deal in the Software without restriction, including without limitation
   8    the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9    and/or sell copies of the Software, and to permit persons to whom the
  10    Software is furnished to do so, subject to the following conditions:
  11
  12    The above copyright notice and this permission notice shall be included in
  13    all copies or substantial portions of the Software.
  14
  15    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18    ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  19    IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20    CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21
  22    Except as contained in this notice, the name of Robert M Supnik shall not be
  23    used in advertising or otherwise to promote the sale, use or other dealings
  24    in this Software without prior written authorization from Robert M Supnik.
  25
  26    dsk          moving head disk
  27
  28    The SDS 9164 disk has a subsector feature, allowing each 64W sector to be
  29    viewed as 16W packets.  In addition, it has a chaining feature, allowing
  30    records to be extended beyond a sector boundary.  To accomodate this, the
  31    first word of each sector has 3 extra bits:
  32
  33    <26> =       end of chain flag
  34    <25:24> =    4 - number of packets
  35
  36    These values were chosen so that 000 = continue chain, full sector.
  37 */
  38
  39 #include "sds_defs.h"
  40
  41 #define UNIT_V_WLK      (UNIT_V_UF + 0)                 /* write locked */
  42 #define UNIT_WLK        (1 << UNIT_V_WLK)
  43 #define UNIT_WPRT       (UNIT_WLK | UNIT_RO)            /* write protect */
  44
  45 #define DSK_PKTWD       16                              /* words/packet */
  46 #define DSK_NUMPKT      4                               /* packets/sector */
  47 #define DSK_NUMWD       (DSK_PKTWD*DSK_NUMPKT)          /* words/sector */
  48 #define DSK_N_SC        5                               /* sect addr width */
  49 #define DSK_V_SC        0                               /* position */
  50 #define DSK_M_SC        ((1 << DSK_N_SC) - 1)           /* mask */
  51 #define DSK_NUMSC       (1 << DSK_N_SC)                 /* sectors/track */
  52 #define DSK_N_TR        8                               /* track addr width */
  53 #define DSK_V_TR        (DSK_N_SC)                      /* position */
  54 #define DSK_M_TR        ((1 << DSK_N_TR) - 1)           /* mask */
  55 #define DSK_NUMTR       (1 << DSK_N_TR)                 /* tracks/surface */
  56 #define DSK_N_SF        5                               /* surf addr width */
  57 #define DSK_V_SF        (DSK_N_SC + DSK_N_TR)           /* position */
  58 #define DSK_M_SF        ((1 << DSK_N_SF) - 1)           /* mask */
  59 #define DSK_NUMSF       (1 << DSK_N_SF)                 /* surfaces/drive */
  60 #define DSK_SCSIZE      (DSK_NUMSF*DSK_NUMTR*DSK_NUMSC) /* sectors/drive */
  61 #define DSK_AMASK       (DSK_SCSIZE - 1)                /* address mask */
  62 #define DSK_SIZE        (DSK_SCSIZE * DSK_NUMWD)        /* words/drive */
  63 #define DSK_GETTR(x)    (((x) >> DSK_V_TR) & DSK_M_TR)
  64 #define cyl             u3                              /* curr cylinder */
  65 #define DSK_SIP         (1 << (DSK_N_TR + 2))
  66 #define DSK_V_PKT       24
  67 #define DSK_M_PKT       03
  68 #define DSK_V_CHN       26
  69 #define DSK_GETPKT(x)   (4 - (((x) >> DSK_V_PKT) & DSK_M_PKT))
  70 #define DSK_ENDCHN(x)   ((x) & (1 << DSK_V_CHN))
  71
  72 extern uint32 xfr_req;
  73 extern uint32 alert;
  74 extern int32 stop_invins, stop_invdev, stop_inviop;
  75 int32 dsk_da = 0;                                       /* disk addr */
  76 int32 dsk_op = 0;                                       /* operation */
  77 int32 dsk_err = 0;                                      /* error flag */
  78 uint32 dsk_buf[DSK_NUMWD];                              /* sector buf */
  79 int32 dsk_bptr = 0;                                     /* byte ptr */
  80 int32 dsk_blnt = 0;                                     /* byte lnt */
  81 int32 dsk_time = 5;                                     /* time per char */
  82 int32 dsk_stime = 200;                                  /* seek time */
  83 int32 dsk_stopioe = 1;
  84 DSPT dsk_tplt[] = {                                     /* template */
  85     { 1, 0 },
  86     { 1, DEV_OUT },
  87     { 0, 0 }
  88     };
  89
  90 DEVICE dsk_dev;
  91 t_stat dsk_svc (UNIT *uptr);
  92 t_stat dsk_reset (DEVICE *dptr);
  93 t_stat dsk_fill (uint32 dev);
  94 t_stat dsk_read_buf (uint32 dev);
  95 t_stat dsk_write_buf (uint32 dev);
  96 void dsk_end_op (uint32 fl);
  97 t_stat dsk (uint32 fnc, uint32 inst, uint32 *dat);
  98
  99 /* DSK data structures
 100
 101    dsk_dev      device descriptor
 102    dsk_unit     unit descriptor
 103    dsk_reg      register list
 104 */
 105
 106 DIB dsk_dib = { CHAN_F, DEV_DSK, XFR_DSK, dsk_tplt, &dsk };
 107
 108 UNIT dsk_unit = { UDATA (&dsk_svc, UNIT_FIX+UNIT_ATTABLE, DSK_SIZE) };
 109
 110 REG dsk_reg[] = {
 111     { BRDATA (BUF, dsk_buf, 8, 24, DSK_NUMWD) },
 112     { DRDATA (BPTR, dsk_bptr, 9), PV_LEFT },
 113     { DRDATA (BLNT, dsk_bptr, 9), PV_LEFT },
 114     { ORDATA (DA, dsk_da, 21) },
 115     { ORDATA (INST, dsk_op, 24) },
 116     { FLDATA (XFR, xfr_req, XFR_V_DSK) },
 117     { FLDATA (ERR, dsk_err, 0) },
 118     { DRDATA (WTIME, dsk_time, 24), REG_NZ + PV_LEFT },
 119     { DRDATA (STIME, dsk_stime,24), REG_NZ + PV_LEFT },
 120     { FLDATA (STOP_IOE, dsk_stopioe, 0) },
 121     { NULL }
 122     };
 123
 124 MTAB dsk_mod[] = {
 125     { UNIT_WLK, 0, "write enabled", "WRITEENABLED", NULL },
 126     { UNIT_WLK, UNIT_WLK, "write locked", "LOCKED", NULL },
 127     { MTAB_XTD|MTAB_VDV, 0, "CHANNEL", "CHANNEL",
 128       &set_chan, &show_chan, NULL },
 129     { 0 }
 130     };
 131
 132 DEVICE dsk_dev = {
 133     "DSK", &dsk_unit, dsk_reg, dsk_mod,
 134     1, 8, 24, 1, 8, 27,
 135     NULL, NULL, &dsk_reset,
 136     NULL, NULL, NULL,
 137     &dsk_dib, DEV_DISABLE
 138     };
 139
 140 /* Moving head disk routine
 141
 142    conn -       inst = EOM0, dat = NULL
 143    eom1 -       inst = EOM1, dat = NULL
 144    sks -        inst = SKS, dat = ptr to result
 145    disc -       inst = device number, dat = NULL
 146    wreor -      inst = device number, dat = NULL
 147    read -       inst = device number, dat = ptr to data
 148    write -      inst = device number, dat = ptr to result
 149 */
 150
 151 t_stat dsk (uint32 fnc, uint32 inst, uint32 *dat)
 152 {
 153 int32 i, t, new_ch, dsk_wptr, dsk_byte;
 154 t_stat r;
 155
 156 switch (fnc) {                                          /* case on function */
 157
 158     case IO_CONN:                                       /* connect */
 159         new_ch = I_GETEOCH (inst);                      /* get new chan */
 160         if (new_ch != dsk_dib.chan) return SCPE_IERR;   /* wrong chan? */
 161         dsk_op = inst;                                  /* save instr */
 162         dsk_bptr = dsk_blnt = 0;                        /* init ptrs */
 163         for (i = 0; i < DSK_NUMWD; i++) dsk_buf[i] = 0; /* clear buffer */
 164         xfr_req = xfr_req & ~XFR_DSK;                   /* clr xfr flg */
 165         sim_activate (&dsk_unit, dsk_stime);            /* activate */
 166         break;
 167
 168     case IO_EOM1:                                       /* EOM mode 1 */
 169         new_ch = I_GETEOCH (inst);                      /* get new chan */
 170         if (new_ch != dsk_dib.chan) return SCPE_IERR;   /* wrong chan? */
 171         if (inst & 07600) CRETIOP;                      /* inv inst? */
 172         alert = POT_DSK;                                /* alert */
 173         break;
 174
 175     case IO_DISC:                                       /* disconnect */
 176         dsk_end_op (0);                                 /* normal term */
 177         if (inst & DEV_OUT) return dsk_fill (inst);     /* fill write */
 178         break;
 179
 180     case IO_WREOR:                                      /* write eor */
 181         dsk_end_op (CHF_EOR);                           /* eor term */
 182         return dsk_fill (inst);                         /* fill write */
 183
 184     case IO_SKS:                                        /* SKS */
 185         new_ch = I_GETSKCH (inst);                      /* sks chan */
 186         if (new_ch != dsk_dib.chan) return SCPE_IERR;   /* wrong chan? */
 187         t = I_GETSKCND (inst);                          /* sks cond */
 188         if (((t == 000) && !sim_is_active (&dsk_unit) &&/* 10026: ready  */
 189              (dsk_unit.flags & UNIT_ATT)) ||
 190             ((t == 004) && !dsk_err &&                  /* 11026: !err */
 191              (dsk_unit.flags & UNIT_ATT)) ||
 192             ((t == 010) && ((dsk_unit.cyl & DSK_SIP) == 0)) || /* 12026: on trk */
 193             ((t == 014) && !(dsk_unit.flags & UNIT_WPRT)) ||   /* 13026: !wrprot */
 194             ((t == 001) && (dsk_unit.flags & UNIT_ATT)))       /* 10226: online */
 195             *dat = 1;
 196         break;
 197
 198     case IO_READ:
 199         xfr_req = xfr_req & ~XFR_DSK;                   /* clr xfr req */
 200         if (dsk_bptr >= dsk_blnt) {                     /* no more data? */
 201             if (r = dsk_read_buf (inst)) return r;      /* read sector */
 202             }
 203         dsk_wptr = dsk_bptr >> 2;                       /* word pointer */
 204         dsk_byte = dsk_bptr & 03;                       /* byte in word */
 205         *dat = (dsk_buf[dsk_wptr] >> ((3 - dsk_byte) * 6)) & 077;
 206         dsk_bptr = dsk_bptr + 1;                        /* incr buf ptr */
 207         if ((dsk_bptr >= dsk_blnt) &&                   /* end sector, */
 208             ((dsk_op & CHC_BIN) || DSK_ENDCHN (dsk_buf[0])))/* sec mode | eoch? */
 209             dsk_end_op (CHF_EOR);                       /* eor term */
 210         break;
 211
 212     case IO_WRITE:
 213         xfr_req = xfr_req & ~XFR_DSK;                   /* clr xfr req */
 214         if (dsk_bptr >= (DSK_NUMWD * 4)) {              /* full? */
 215             if (r = dsk_write_buf (inst)) return r;     /* write sector */
 216             }
 217         dsk_wptr = dsk_bptr >> 2;                       /* word pointer */
 218         dsk_buf[dsk_wptr] = ((dsk_buf[dsk_wptr] << 6) | (*dat & 077)) & DMASK;
 219         dsk_bptr = dsk_bptr + 1;                        /* incr buf ptr */
 220         break;
 221
 222     default:
 223         CRETINS;
 224         }
 225
 226 return SCPE_OK;
 227 }
 228
 229 /* PIN routine - return disk address */
 230
 231 t_stat pin_dsk (uint32 num, uint32 *dat)
 232 {
 233 *dat = dsk_da;                                          /* ret disk addr */
 234 return SCPE_OK;
 235 }
 236
 237 /* POT routine - start seek */
 238
 239 t_stat pot_dsk (uint32 num, uint32 *dat)
 240 {
 241 int32 st;
 242
 243 if (sim_is_active (&dsk_unit)) return STOP_IONRDY;      /* busy? wait */
 244 dsk_da = (*dat) & DSK_AMASK;                            /* save dsk addr */
 245 st = abs (DSK_GETTR (dsk_da) -                          /* calc seek time */
 246      (dsk_unit.cyl & DSK_M_TR)) * dsk_stime;
 247 if (st == 0) st = dsk_stime;                            /* min time */
 248 sim_activate (&dsk_unit, st);                           /* set timer */
 249 dsk_unit.cyl = dsk_unit.cyl | DSK_SIP;                  /* seeking */
 250 return SCPE_OK;
 251 }
 252
 253 /* Unit service and read/write */
 254
 255 t_stat dsk_svc (UNIT *uptr)
 256 {
 257 if (uptr->cyl & DSK_SIP) {                              /* end seek? */
 258     uptr->cyl = DSK_GETTR (dsk_da);                     /* on cylinder */
 259     if (dsk_op) sim_activate (&dsk_unit, dsk_stime);    /* sched r/w */
 260     }
 261 else {
 262     xfr_req = xfr_req | XFR_DSK;                        /* set xfr req */
 263     sim_activate (&dsk_unit, dsk_time);                 /* activate */
 264     }
 265 return SCPE_OK;
 266 }
 267
 268 /* Read sector */
 269
 270 t_stat dsk_read_buf (uint32 dev)
 271 {
 272 int32 da, pkts, awc;
 273
 274 if ((dsk_unit.flags & UNIT_ATT) == 0) {                 /* !attached? */
 275     dsk_end_op (CHF_ERR | CHF_EOR);                     /* disk error */
 276     CRETIOE (dsk_stopioe, SCPE_UNATT);
 277     }
 278 da = dsk_da * DSK_NUMWD * sizeof (uint32);
 279 fseek (dsk_unit.fileref, da, SEEK_SET);                 /* locate sector */
 280 awc = fxread (dsk_buf, sizeof (uint32), DSK_NUMWD, dsk_unit.fileref);
 281 if (ferror (dsk_unit.fileref)) {                        /* error? */
 282     dsk_end_op (CHF_ERR | CHF_EOR);                     /* disk error */
 283     return SCPE_IOERR;
 284     }
 285 for ( ; awc < DSK_NUMWD; awc++) dsk_buf[awc] = 0;
 286 pkts = DSK_GETPKT (dsk_buf[0]);                         /* get packets */
 287 dsk_blnt = pkts * DSK_PKTWD * 4;                        /* new buf size */
 288 dsk_bptr = 0;                                           /* init bptr */
 289 dsk_da = (dsk_da + 1) & DSK_AMASK;                      /* incr disk addr */
 290 return SCPE_OK;
 291 }
 292
 293 /* Write sector.  If this routine is called directly, then the sector
 294    buffer is full, and there is at least one more character to write;
 295    therefore, there are 4 packets in the sector, and the sector is not
 296    the end of the chain.
 297 */
 298
 299 t_stat dsk_write_buf (uint32 dev)
 300 {
 301 int32 i, da;
 302
 303 if ((dsk_unit.flags & UNIT_ATT) == 0) {                 /* !attached? */
 304     dsk_end_op (CHF_ERR | CHF_EOR);                     /* disk error */
 305     CRETIOE (dsk_stopioe, SCPE_UNATT);
 306     }
 307 if (dsk_unit.flags & UNIT_WPRT) {                       /* write prot? */
 308     dsk_end_op (CHF_ERR | CHF_EOR);                     /* disk error */
 309     return SCPE_OK;
 310     }
 311 da = dsk_da * DSK_NUMWD * sizeof (uint32);
 312 fseek (dsk_unit.fileref, da, SEEK_SET);                 /* locate sector */
 313 fxwrite (dsk_buf, sizeof (uint32), DSK_NUMWD, dsk_unit.fileref);
 314 if (ferror (dsk_unit.fileref)) {                        /* error? */
 315     dsk_end_op (CHF_ERR | CHF_EOR);                     /* disk error */
 316     return SCPE_IOERR;
 317     }
 318 dsk_bptr = 0;                                           /* init bptr */
 319 dsk_da = (dsk_da + 1) & DSK_AMASK;                      /* incr disk addr */
 320 for (i = 0; i < DSK_NUMWD; i++) dsk_buf[i] = 0;         /* clear buffer */
 321 return SCPE_OK;
 322 }
 323
 324 /* Fill incomplete sector at end of operation.  Calculate the number
 325    of packets and set the end of chain flag.
 326 */
 327
 328 t_stat dsk_fill (uint32 dev)
 329 {
 330 int32 nochn = (dsk_op & CHC_BIN)? 0: 1;                 /* chain? */
 331 int32 pktend = (dsk_bptr + ((DSK_PKTWD * 4) - 1)) &     /* end pkt */
 332     ~((DSK_PKTWD * 4) - 1);
 333 int32 pkts = pktend / (DSK_PKTWD * 4);                  /* # packets */
 334
 335 if (dsk_bptr == 0) return SCPE_OK;                      /* no fill? */
 336 for ( ; dsk_bptr < pktend; dsk_bptr++) {                /* fill packet */
 337     int32 dsk_wptr = dsk_bptr >> 2;
 338     dsk_buf[dsk_wptr] = (dsk_buf[dsk_wptr] << 6) & DMASK;
 339     }
 340 dsk_buf[0] = dsk_buf[0] | (nochn << DSK_V_CHN) |        /* insert chain, */
 341     ((4 - pkts) << DSK_V_PKT);                          /* num pkts */
 342 return dsk_write_buf (dev);                             /* write sec */
 343 }
 344
 345 /* Terminate DSK operation */
 346
 347 void dsk_end_op (uint32 fl)
 348 {
 349 if (fl) chan_set_flag (dsk_dib.chan, fl);               /* set flags */
 350 dsk_op = 0;                                             /* clear op */
 351 xfr_req = xfr_req & ~XFR_DSK;                           /* clear xfr */
 352 sim_cancel (&dsk_unit);                                 /* stop */
 353 if (fl & CHF_ERR) {                                     /* error? */
 354     chan_disc (dsk_dib.chan);                           /* disconnect */
 355     dsk_err = 1;                                        /* set disk err */
 356     }
 357 return;
 358 }
 359
 360 /* Reset routine */
 361
 362 t_stat dsk_reset (DEVICE *dptr)
 363 {
 364 int32 i;
 365
 366 chan_disc (dsk_dib.chan);                               /* disconnect */
 367 dsk_da = 0;                                             /* clear state */
 368 dsk_op = 0;
 369 dsk_err = 0;
 370 dsk_bptr = dsk_blnt = 0;
 371 xfr_req = xfr_req & ~XFR_DSK;                           /* clr xfr req */
 372 sim_cancel (&dsk_unit);                                 /* deactivate */
 373 dsk_unit.cyl = 0;
 374 for (i = 0; i < DSK_NUMWD; i++) dsk_buf[i] = 0;         /* clear buffer */
 375 return SCPE_OK;
 376 }