Subversion Repositories eco32

/*
 * main.c -- program to write the partition table
 *           and the bootblock on a hard disk
 */
 
 
#include "types.h"
#include "stdarg.h"
#include "iolib.h"
#include "start.h"
#include "idedsk.h"
 
 
/**************************************************************/
 
 
void error(char *fmt, ...) {
  va_list ap;
 
  va_start(ap, fmt);
  printf("Error: ");
  vprintf(fmt, ap);
  printf(", halting...\n");
  va_end(ap);
  while (1) ;
}
 
 
/**************************************************************/
 
 
/*
 * the boot block byte array need not be word-aligned
 */
unsigned char mboot[32 * SECTOR_SIZE] = {
  #include "mboot.dump"
};
 
 
/*
 * the write buffer must be word-aligned
 */
unsigned int wrBuf[32 * SECTOR_SIZE / sizeof(unsigned int)];
 
 
/*
 * copy byte array to write buffer
 */
void copyBootBlock(void) {
  unsigned char *p;
  unsigned char *q;
  int i;
 
  p = (unsigned char *) wrBuf;
  q = (unsigned char *) mboot;
  for (i = 0; i < 32 * SECTOR_SIZE; i++) {
    *p++ = *q++;
  }
}
 
 
/**************************************************************/
 
 
static char *exceptionCause[32] = {
  /* 00 */  "terminal 0 transmitter interrupt",
  /* 01 */  "terminal 0 receiver interrupt",
  /* 02 */  "terminal 1 transmitter interrupt",
  /* 03 */  "terminal 1 receiver interrupt",
  /* 04 */  "keyboard interrupt",
  /* 05 */  "unknown interrupt",
  /* 06 */  "unknown interrupt",
  /* 07 */  "unknown interrupt",
  /* 08 */  "disk interrupt",
  /* 09 */  "unknown interrupt",
  /* 10 */  "unknown interrupt",
  /* 11 */  "unknown interrupt",
  /* 12 */  "unknown interrupt",
  /* 13 */  "unknown interrupt",
  /* 14 */  "timer interrupt",
  /* 15 */  "unknown interrupt",
  /* 16 */  "bus timeout exception",
  /* 17 */  "illegal instruction exception",
  /* 18 */  "privileged instruction exception",
  /* 19 */  "divide instruction exception",
  /* 20 */  "trap instruction exception",
  /* 21 */  "TLB miss exception",
  /* 22 */  "TLB write exception",
  /* 23 */  "TLB invalid exception",
  /* 24 */  "illegal address exception",
  /* 25 */  "privileged address exception",
  /* 26 */  "unknown exception",
  /* 27 */  "unknown exception",
  /* 28 */  "unknown exception",
  /* 29 */  "unknown exception",
  /* 30 */  "unknown exception",
  /* 31 */  "unknown exception"
};
 
 
int defaultISR(int irq) {
  printf("\n%s\n", exceptionCause[irq]);
  return 0;  /* do not skip any instruction */
}
 
 
void initInterrupts(void) {
  int i;
 
  for (i = 0; i < 32; i++) {
    setISR(i, defaultISR);
  }
}
 
 
/**************************************************************/
 
 
Bool checkDiskReady(void) {
  int tries;
  int i;
 
  for (tries = 0; tries < 10; tries++) {
    for (i = 0; i < 500000; i++) {
      if ((*DISK_CTRL & DISK_CTRL_READY) != 0) {
        return TRUE;
      }
    }
    printf(".");
  }
  return FALSE;
}
 
 
unsigned long getDiskSize(void) {
  return *DISK_CAP;
}
 
 
Bool readDisk(unsigned long sector,
              unsigned int count,
              unsigned int *addr) {
  unsigned int n;
  unsigned int *p;
  unsigned int i;
 
  while (count != 0) {
    n = count > 8 ? 8 : count;
    *DISK_SCT = sector;
    *DISK_CNT = n;
    *DISK_CTRL = DISK_CTRL_STRT;
    while ((*DISK_CTRL & DISK_CTRL_DONE) == 0) ;
    if (*DISK_CTRL & DISK_CTRL_ERR) {
      return FALSE;
    }
    p = DISK_BUFFER;
    for (i = 0; i < n * SECTOR_SIZE / sizeof(unsigned int); i++) {
      *addr++ = *p++;
    }
    sector += n;
    count -= n;
  }
  return TRUE;
}
 
 
Bool writeDisk(unsigned long sector,
               unsigned int count,
               unsigned int *addr) {
  unsigned int n;
  unsigned int *p;
  unsigned int i;
 
  while (count != 0) {
    n = count > 8 ? 8 : count;
    p = DISK_BUFFER;
    for (i = 0; i < n * SECTOR_SIZE / sizeof(unsigned int); i++) {
      *p++ = *addr++;
    }
    *DISK_SCT = sector;
    *DISK_CNT = n;
    *DISK_CTRL = DISK_CTRL_WRT | DISK_CTRL_STRT;
    while ((*DISK_CTRL & DISK_CTRL_DONE) == 0) ;
    if (*DISK_CTRL & DISK_CTRL_ERR) {
      return FALSE;
    }
    sector += n;
    count -= n;
  }
  return TRUE;
}
 
 
/**************************************************************/
 
 
void main(void) {
  unsigned long numSectors;
 
  /* init interrupts */
  initInterrupts();
  /* check disk ready */
  if (!checkDiskReady()) {
    error("disk not ready");
  }
  /* determine disk size */
  numSectors = getDiskSize();
  printf("Disk has %lu (0x%lX) sectors.\n",
         numSectors, numSectors);
  if (numSectors < 32) {
    error("disk is too small");
  }
  /* copy boot block to write buffer */
  copyBootBlock();
  /* write boot block to disk */
  printf("Writing boot block to disk...\n");
  if (!writeDisk(0, 32, wrBuf)) {
    error("cannot write boot block to disk");
  }
  /* done */
  printf("Halting...\n");
}