Subversion Repositories eco32

/*
 * disk.c -- disk simulation
 */
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>
 
#include "common.h"
#include "console.h"
#include "error.h"
#include "except.h"
#include "cpu.h"
#include "timer.h"
#include "disk.h"
 
 
static Bool debug = false;
 
static FILE *diskImage;
static long totalSectors;
 
static Word diskCtrl;
static Word diskCnt;
static Word diskSct;
static Word diskCap;
 
static Byte diskBuffer[8 * SECTOR_SIZE];
 
static long lastSct;
 
 
static Word readWord(Byte *p) {
  Word data;
 
  data = ((Word) *(p + 0)) << 24 |
         ((Word) *(p + 1)) << 16 |
         ((Word) *(p + 2)) <<  8 |
         ((Word) *(p + 3)) <<  0;
  return data;
}
 
 
static void writeWord(Byte *p, Word data) {
  *(p + 0) = (Byte) (data >> 24);
  *(p + 1) = (Byte) (data >> 16);
  *(p + 2) = (Byte) (data >>  8);
  *(p + 3) = (Byte) (data >>  0);
}
 
 
static void diskCallback(int n) {
  int numScts;
 
  if (debug) {
    cPrintf("\n**** DISK CALLBACK, n = %d ****\n", n);
  }
  if (n == 0) {
    /* startup time expired */
    diskCap = totalSectors;
    diskCtrl |= DISK_READY;
    return;
  }
  /* disk read or write */
  numScts = ((diskCnt - 1) & 0x07) + 1;
  if (diskCap != 0 &&
      diskSct < diskCap &&
      diskSct + numScts <= diskCap) {
    /* do the transfer */
    if (fseek(diskImage, diskSct * SECTOR_SIZE, SEEK_SET) != 0) {
      error("cannot position to sector in disk image");
    }
    if (diskCtrl & DISK_WRT) {
      /* buffer --> disk */
      if (fwrite(diskBuffer, SECTOR_SIZE, numScts, diskImage) != numScts) {
        error("cannot write to disk image");
      }
    } else {
      /* disk --> buffer */
      if (fread(diskBuffer, SECTOR_SIZE, numScts, diskImage) != numScts) {
        error("cannot read from disk image");
      }
    }
    lastSct = (long) diskSct + (long) numScts - 1;
  } else {
    /* sectors requested exceed disk capacity */
    /* or we have no disk at all */
    diskCtrl |= DISK_ERR;
  }
  diskCtrl &= ~DISK_STRT;
  diskCtrl |= DISK_DONE;
  if (diskCtrl & DISK_IEN) {
    /* raise disk interrupt */
    cpuSetInterrupt(IRQ_DISK);
  }
}
 
 
Word diskRead(Word addr) {
  Word data;
 
  if (debug) {
    cPrintf("\n**** DISK READ from 0x%08X", addr);
  }
  if (addr == DISK_CTRL) {
    data = diskCtrl;
  } else
  if (addr == DISK_CNT) {
    data = diskCnt;
  } else
  if (addr == DISK_SCT) {
    data = diskSct;
  } else
  if (addr == DISK_CAP) {
    data = diskCap;
  } else
  if (addr & 0x80000) {
    /* buffer access */
    data = readWord(diskBuffer + (addr & 0x0FFC));
  } else {
    /* illegal register */
    throwException(EXC_BUS_TIMEOUT);
  }
  if (debug) {
    cPrintf(", data = 0x%08X ****\n", data);
  }
  return data;
}
 
 
void diskWrite(Word addr, Word data) {
  long delta;
 
  if (debug) {
    cPrintf("\n**** DISK WRITE to 0x%08X, data = 0x%08X ****\n",
            addr, data);
  }
  if (addr == DISK_CTRL) {
    if (data & DISK_WRT) {
      diskCtrl |= DISK_WRT;
    } else {
      diskCtrl &= ~DISK_WRT;
    }
    if (data & DISK_IEN) {
      diskCtrl |= DISK_IEN;
    } else {
      diskCtrl &= ~DISK_IEN;
    }
    if (data & DISK_STRT) {
      diskCtrl |= DISK_STRT;
      diskCtrl &= ~DISK_ERR;
      diskCtrl &= ~DISK_DONE;
      /* only start a disk operation if disk is present */
      if (diskCap != 0) {
        delta = labs((long) diskSct - lastSct);
        if (delta > diskCap) {
          delta = diskCap;
        }
        timerStart(DISK_DELAY_USEC + (delta * DISK_SEEK_USEC) / diskCap,
                   diskCallback, 1);
      }
    } else {
      diskCtrl &= ~DISK_STRT;
      if (data & DISK_ERR) {
        diskCtrl |= DISK_ERR;
      } else {
        diskCtrl &= ~DISK_ERR;
      }
      if (data & DISK_DONE) {
        diskCtrl |= DISK_DONE;
      } else {
        diskCtrl &= ~DISK_DONE;
      }
    }
    if ((diskCtrl & DISK_IEN) != 0 &&
        (diskCtrl & DISK_DONE) != 0) {
      /* raise disk interrupt */
      cpuSetInterrupt(IRQ_DISK);
    } else {
      /* lower disk interrupt */
      cpuResetInterrupt(IRQ_DISK);
    }
  } else
  if (addr == DISK_CNT) {
    diskCnt = data;
  } else
  if (addr == DISK_SCT) {
    diskSct = data;
  } else
  if (addr == DISK_CAP) {
    /* this register is read-only */
    throwException(EXC_BUS_TIMEOUT);
  } else
  if (addr & 0x80000) {
    /* buffer access */
    writeWord(diskBuffer + (addr & 0x0FFC), data);
  } else {
    /* illegal register */
    throwException(EXC_BUS_TIMEOUT);
  }
}
 
 
void diskReset(void) {
  cPrintf("Resetting Disk...\n");
  diskCtrl = 0;
  diskCnt = 0;
  diskSct = 0;
  diskCap = 0;
  lastSct = 0;
  if (totalSectors != 0) {
    cPrintf("Disk of size %ld sectors (%ld bytes) installed.\n",
            totalSectors, totalSectors * SECTOR_SIZE);
    timerStart(DISK_START_USEC, diskCallback, 0);
  }
}
 
 
void diskInit(char *diskImageName) {
  long numBytes;
 
  if (diskImageName == NULL) {
    /* do not install disk */
    diskImage = NULL;
    totalSectors = 0;
  } else {
    /* try to install disk */
    diskImage = fopen(diskImageName, "r+b");
    if (diskImage == NULL) {
      error("cannot open disk image '%s'", diskImageName);
    }
    fseek(diskImage, 0, SEEK_END);
    numBytes = ftell(diskImage);
    fseek(diskImage, 0, SEEK_SET);
    if (numBytes % SECTOR_SIZE != 0) {
      error("disk image '%s' does not contain an integral number of sectors",
            diskImageName);
    }
    totalSectors = numBytes / SECTOR_SIZE;
  }
  diskReset();
}
 
 
void diskExit(void) {
  if (diskImage == NULL) {
    /* disk not installed */
    return;
  }
  fclose(diskImage);
}