//+++2004-08-31
//    Copyright (C) 2004  Mike Rieker, Beverly, MA USA
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; version 2 of the License.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//---2004-08-31

/************************************************************************/
/*									*/
/*  82078 floppy disk controller driver					*/
/*									*/
/*  Creates devices named floppy.cn					*/
/*									*/
/*	c = controller: p for primary, s for secondary			*/
/*	n = unitnumber: 0 or 1						*/
/*									*/
/************************************************************************/

#include "ozone.h"

#include "oz_dev_disk.h"
#include "oz_dev_timer.h"
#include "oz_io_disk.h"
#include "oz_knl_devio.h"
#include "oz_knl_event.h"
#include "oz_knl_hw.h"
#include "oz_knl_kmalloc.h"
#include "oz_knl_misc.h"
#include "oz_knl_procmode.h"
#include "oz_knl_sdata.h"
#include "oz_knl_section.h"
#include "oz_knl_spte.h"
#include "oz_knl_status.h"
#include "oz_knl_thread.h"
#include "oz_knl_userjob.h"
#include "oz_sys_dateconv.h"
#include "oz_sys_xprintf.h"

#define NAME "floppy"

#define L2DISK_BLOCK_SIZE (devex -> sizecode + 7)
#define DISK_BLOCK_SIZE (128 << devex -> sizecode)
#define MAXSIZECODE (sizeof sectorspertrack / sizeof sectorspertrack[0])
#define TRACKSPERCYLINDER (2)
#define CYLINDERS (80)
#define GPL_1 (0x1B)
#define GPL_2 (0x54)

#define IRQ_LEVEL 6		// all controllers share this IRQ
#define INT_TIMEOUT 5		// number of seconds to wait for an interrupt
#define DRIVE_RDY_TIME 3	// within 3Sec after recalibrate, drive should be ready
#define MSR_RQM_TIMEOUT 50000	// within 50mS after interrupt, RQM should be set
#define MOTOR_TIMER_SECONDS 2	// let motor run for 2Sec after last using it

#define MAX_READ_RETRIES 8	// retry reads 8 times

#define LOCKDMA() while (oz_knl_event_set (dmapage_event, 0) == 0) oz_knl_event_waitone (dmapage_event)
#define UNLKDMA() oz_knl_event_set (dmapage_event, 1)

typedef struct Controller Controller;
typedef struct Devex Devex;
typedef struct Iopex Iopex;

/* Registers */

#define SRB (1)		/* R/W - Status Register B */
#define SRB_IDLE (0x01)
#define SRB_PD (0x02)
#define SRB_IDLEMSK (0x04)
#define DOR (2)		/* R/W - Digital Output Register */
#define DOR_DRIVESEL (0x01)
#define DOR_RESET_ (0x04)
#define DOR_DMAGATE (0x08)
#define DOR_MOTEN0 (0x10)
#define DOR_MOTEN1 (0x20)
#define DOR_DRIVE0 (0x1c)	/* Composite value to enable drive 0 */
#define DOR_DRIVE1 (0x2d)	/* Composite value to enable drive 1 */
#define TDR (3)		/* R/W - Tape Drive Register */
#define MSR (4)		/* R-O - Main Status Register */
#define MSR_DRV0BUSY (0x01)	/* Drive 0 is busy doing a seek */
#define MSR_DRV1BUSY (0x02)	/* Drive 1 is busy doing a seek */
#define MSR_CB (0x10)		/* 0: No command in progress; 1: Command in progress */
#define MSR_NONDMA (0x20)	/* 0: Result data can be read; 1: Disk data can be read */
#define MSR_DIO (0x40)		/* 0: Host can write data; 1: Host can read data */
#define MSR_RQM (0x80)		/* 0: Host cannot transfer data; 1: Host can transfer data */
#define DSR (4)		/* W-O - Data Rate Select Register */
#define FIFO (5)	/* R/W - Data Register */
#define DIR (7)		/* R-O - Digital Input Register */
#define DIR_DSKCHG_ (0x80)	/* 0: Disk has not been changed; 1: Disk has been changed */
#define CCR (7)		/* W-O - Configuration Control Register */

#define ST3_WP (0x40)	/* R-O - write protected */
#define ST3_TRK0 (0x10)	/* R-O - track zero */

/* DMA registers (channel 2) */

#define DMA_ADDR2 (0x04)		/* W-O - start address */
					/* R-O - current address */
#define DMA_COUNT2 (0x05)		/* W-O - start count */
					/* R-O - remaining count */
#define DMA_CTRL (0x08)			/* W-O - control */
					/*       <0> = 0 : mem-to-mem disabled */
					/*             1 : mem-to-mem enabled */
					/*       <1> = 0 : ch 0 addr hold disabled */
					/*             1 : ch 0 addr hold enabled */
					/*       <2> = 0 : controller enabled */
					/*             1 : controller disabled */
					/*       <3> = 0 : normal timing */
					/*             1 : compressed timing */
					/*       <4> = 0 : fixed priority */
					/*             1 : rotating priority */
					/*       <5> = 0 : late write selection */
					/*             1 : extended write selection */
					/*       <6> = 0 : DRQn sense asserted HI */
					/*             1 : DRQn sense asserted LO */
					/*       <7> = 0 : DAKn sense asserted LO */
					/*             1 : DAKn sense asserted HI */
#define DMA_MODE (0x0B)			/* W-0 - dma mode */
					/*       <0:1> = channel select */
					/*       <2:3> = 00 : verify */
					/*               01 : device-to-memory */
					/*               10 : memory-to-device */
					/*               11 : reserved */
					/*       <4> = 0 : no auto-init */
					/*             1 : auto-init */
					/*       <5> = 0 : address increment */
					/*             1 : address decrement */
					/*       <6:7> = 00 : demand transfer mode */
					/*               01 : single transfer mode */
					/*               10 : block transfer mode */
					/*               11 : cascade transfer mode */
#define DMA_CBP (0x0C)			/* writing to this causes the DMAC to reset the hi/lo byte sequencing */
#define DMA_MCLR (0x0D)			/* writing to this does a hardware reset of the DMAC */
#define DMA_ACT (0x0E)			/* writing to this activates all four DMA channels */
#define DMA_MASK (0x0F)			/* mask bit for each four channels (when set, inhibits operation of the channel) */
#define DMA_PAGE2 (0x81)		/* R/W - address page (64K page) */

#define DMA_DEV2MEM (0x04)
#define DMA_MEM2DEV (0x08)

/* One of these per controller */

struct Controller { Controller *next;		/* next controller in list */
                    OZ_Event *event;		/* associated event */
                    OZ_Timer *inttimer;		/* interrupt timer */
                    const char *ctrlname;	/* controller name ("primary", "secondary") */
                    Devex *devexs;		/* list of devices on this controller */
                    Iopex *iopexqh;		/* list of I/O requests waiting for thread */
                    Iopex **iopexqt;
                    Iopex *iopexip;		/* the I/O request currently in progress */
                    volatile int waitingforint;	/* 0=not (no longer) waiting for interrupt; 1=waiting for interrupt; -1=timedout */
                    uWord ioportbase;		/* io port base address, 0x03F0 or 0x0370 */
                  };

/* Device extension structure */

struct Devex { Devex *next;			/* next device on controller */
               OZ_Timer *motor_timer;		/* motor timer */
               OZ_Datebin motoroff;		/* when the motor is to be turned off (or 0 if it is off) */
               Controller *controller;		/* the controller it is connected to */
               OZ_Devunit *devunit;		/* device unit struct pointer */
               const char *unitname;		/* unit name string (for error messages) */
               OZ_Dbn startblock;		/* starting block of the track in trackbuf */
               uLong validblocks;		/* number of blocks in trackbuf that are valid */
               uLong dirtybeg;			/* offset of first block in trackbuf that is dirty */
               uLong dirtyend;			/* offset past last block in trackbuf that is dirty */
               uByte *trackbuffer;		/* virtual address of track buffer */
               uLong trackbuf_pageoffs;		/* offset of first byte of track buffer in first physical page */
               OZ_Mempage trackbuf_phypages[8];	/* array of track buffer physical page numbers */
               uByte sizecode;			/* 0=128, 1=256, 2=512, ... 7=16k */
               uByte drivesel;			/* drive select: 0=drive 0; 1=drive 1 */
               uByte datarate;			/* datarate for the media currently in drive */
               char failed;			/*  0: initialization in progress */
						/*  1: failed to initialize, delete in progress */
						/* -1: init completed successfully, drive is online */
               char volvalid;			/* volume is valid */
               char writable;			/* volume is writable */
             };

/* I/O operation extension */

struct Iopex { Iopex *next;			/* next request in queue */
               OZ_Ioop *ioop;			/* corresponding ioop */
               uLong (*be) (Iopex *iopex);	/* backend routine */
               Devex *devex;			/* device that it is for */
               int aborted;			/* tagged for abort by floppy_abort routine */
               int writing;			/* 0=reading; 1=writing */
               int writethru;			/* 0=normal; 1=writethru */
               uLong size;			/* size of buffer */
               const OZ_Mempage *phypages;	/* points to array of physical page numbers */
               uLong byteoffs;			/* byte offset in first physical page */
               OZ_Dbn slbn;			/* starting logical block number */
             };

/* Function table */

static int floppy_shutdown (OZ_Devunit *devunit, void *devexv);
static int floppy_clonedel (OZ_Devunit *devunit, void *devexv, int cloned);
static void floppy_abort (OZ_Devunit *devunit, void *devexv, OZ_Iochan *iochan, void *chnexv, 
                          OZ_Ioop *ioop, void *iopexv, OZ_Procmode procmode);
static uLong floppy_start (OZ_Devunit *devunit, void *devexv, OZ_Iochan *iochan, void *chnexv, OZ_Procmode procmode, 
                           OZ_Ioop *ioop, void *iopexv, uLong funcode, uLong as, void *ap);

static const OZ_Devfunc floppy_functable = { sizeof (Devex), 0, sizeof (Iopex), 0, floppy_shutdown, NULL, 
                                             floppy_clonedel, NULL, NULL, floppy_abort, floppy_start, NULL };

/* Internal static data */

                                        // 128,  256,  512, 1024, 2048, 4096, 8192	corresponding bytes per sector
static const uByte sectorspertrack[8] = {   34,   26,   18,   11,    6,    3,    1 };	// indexed using devex->sizecode

#define MAX_TRACK_SIZE (2048*6)			// what blocksize*sectorspertrack size gives the max data bytes on a track

static Controller *controllers;
static int initialized = 0;
static OZ_Devclass *devclass;
static OZ_Devdriver *devdriver;
static OZ_Event *dmapage_event;			/* dma page's access event flag */
static OZ_Smplock *smplock_fd;			/* floppy drive's irq smplock */
static uByte dmapage_buff[MAX_TRACK_SIZE*2];	/* dma buffer, phyaddr = virtaddr */
static uByte *dmapage_vadr;			/* dma page's virtual address = dma page's physical address */
static OZ_Phyaddr dmapage_padr;			/* dma page's physical address = dma page's virtual address */
static uLong dmapage_size;			/* number of bytes available in dmapage_phypage */
static OZ_Hw486_irq_many fd_irq_many;		/* interrupt handler link block */

/* Internal routines */

static void config (uWord ioportbase, const char *ctrlname);
static uLong floppy_thread (void *controllerv);
static void setdrivefailed (Devex *devex);
static void setdrivestatus (Devex *devex, const char *status);
static uLong be_setvolvalid (Iopex *iopex);
static uLong be_writeblocks (Iopex *iopex);
static uLong be_readblocks (Iopex *iopex);
static uLong be_format (Iopex *iopex);
static int mediaonline (Iopex *iopex);
static uLong flushtrackbuffer (Devex *devex);
static uLong filltrackbuffer (Devex *devex);
static int resetctrlr (Controller *controller, uByte datarate);
static uLong resetctrlr_check (void *ioportbasev);
static int recalibrate (Devex *devex);
static void driveidlewait (Devex *devex);
static uLong write_blocks (uLong size, const uByte *buff, uLong slbn, uLong *wlen, Devex *devex);
static uLong read_blocks (uLong size, uByte *buff, uLong slbn, uLong *rlen, Devex *devex);
static uLong chkvolvalid (Devex *devex);
static void motor_timer_start (Devex *devex);
static void motor_timer_expired (void *devexv, OZ_Timer *timer);
static int send_command (int size, uByte *buff, Controller *controller, int interrupts);
static void int_timeout (void *controllerv, OZ_Timer *timer);
static uLong recv_results (int size, uByte *buff, uWord port, Devex *devex, uByte command);
static int command_done (uWord port, uByte command);
static uLong command_done_check (void *portv);
static uByte wait_for_rqm (uWord port);
static uLong check_for_rqm (void *rqmprmv);
static uByte wait_for_rqmdio (uWord port);
static uLong check_for_rqmdio (void *rqmprmv);
static void print_rw_err (const char *rw, Devex *devex, uByte *command, uByte *results, uLong len);
static uLong dmapage_setup (int dmadir, uLong transferlen, Devex *devex, uLong byteoffs, OZ_Mempage *phypages, OZ_Dbn slbn);
static int fd_interrupt (void *dummy, OZ_Mchargs *mchargs);

/************************************************************************/
/*									*/
/*  Boot-time initialization routine					*/
/*									*/
/************************************************************************/

void oz_dev_floppy_init ()

{
  uLong pm, sts;

  if (initialized) return;

  oz_knl_printk ("oz_dev_floppy_init\n");
  initialized = 1;

  /* Make sure the dmapage_buff meets the restrictions of the DMA controller.  The stupid DMA  */
  /* controller can't cross 64K boundaries and it can't address anything above 0xFFFFFF (16M). */

  dmapage_size = sizeof dmapage_buff;
  dmapage_vadr = dmapage_buff;
  if (((OZ_Pointer)dmapage_vadr & -65536) != ((((OZ_Pointer)dmapage_vadr) + dmapage_size - 1) & -65536)) {
    dmapage_size /= 2;
    if (((OZ_Pointer)dmapage_vadr & -65536) != ((((OZ_Pointer)dmapage_vadr) + dmapage_size - 1) & -65536)) {
      dmapage_vadr  = (uByte *)((((OZ_Pointer)dmapage_vadr) + 65535) & -65536);
      if (((OZ_Pointer)dmapage_vadr & -65536) != ((((OZ_Pointer)dmapage_vadr) + dmapage_size - 1) & -65536)) {
        oz_crash ("oz_dev_floppy_init: dmapage_vadr %p size %x still crosses 64K boundary", dmapage_vadr, dmapage_size);
      }
    }
    oz_knl_printk ("oz_dev_floppy_init: dmapage_buff size %x at %p crosses 64K boundary\n", sizeof dmapage_buff, dmapage_buff);
    oz_knl_printk ("oz_dev_floppy_init: - using size %x at %p instead\n", dmapage_size, dmapage_vadr);
  }

  sts = oz_knl_misc_sva2pax (dmapage_vadr, &dmapage_padr, &pm, dmapage_size);
  if (sts < dmapage_size) {
    oz_knl_printk ("oz_dev_floppy: dmapage_buff %p only %u bytes out of %u\n", dmapage_vadr, sts, dmapage_size);
    return;
  }
  dmapage_padr = (dmapage_padr << OZ_HW_L2PAGESIZE) + pm;

  if ((dmapage_padr + dmapage_size) > 16*1024*1024) {
    oz_knl_printk ("oz_dev_floppy: dmapage_buff 0x%x is beyond 16Meg limit\n", dmapage_padr, dmapage_size);
    return;
  }

  /* Allocate an event flag for the (potentially) two threads to serialize access to the one-and-only DMA controller */

  sts = oz_knl_event_create (10, "floppy dma", NULL, &dmapage_event);
  if (sts != OZ_SUCCESS) oz_crash ("oz_dev_floppy: error %u creating dmpage_event", sts);
  UNLKDMA ();

  /* Create device driver database entries */

  devclass   = oz_knl_devclass_create (OZ_IO_DISK_CLASSNAME, OZ_IO_DISK_BASE, OZ_IO_DISK_MASK, "floppy_486");
  devdriver  = oz_knl_devdriver_create (devclass, "floppy_486");
  fd_irq_many.entry = fd_interrupt;
  fd_irq_many.param = NULL;
  fd_irq_many.descr = NAME;
  smplock_fd = oz_hw486_irq_many_add (IRQ_LEVEL, &fd_irq_many);

  /* Configure controllers */

  controllers = NULL;
  config (0x03F0, "primary");
  config (0x0370, "secondary");
}

/* This routine sets up the devunit structs immediately then forks a thread to perform the actual probing and     */
/* initialization.  Meanwhile, the main thread is free to continue on.   If anything tries to queue I/O to the    */
/* floppy devices before they have been configured, the requests will wait until the configuration is complete.   */
/* If the configuration finds that the controller and/or drive does not exist, it will abort any queued requests. */

static void config (uWord ioportbase, const char *ctrlname)

{
  char threadname[OZ_THREAD_NAMESIZE], unitname[OZ_DEVUNIT_NAMESIZE];
  Controller *controller;
  Devex *devex, **ldevex;
  int drivesel;
  OZ_Devunit *devunit;
  OZ_Thread *thread;
  uLong sts;

  /* Create and initialize controller struct */

  controller = OZ_KNL_NPPMALLOC (sizeof *controller);
  memset (controller, 0, sizeof *controller);
  controller -> ioportbase = ioportbase;
  controller -> ctrlname   = ctrlname;
  controller -> iopexqt    = &(controller -> iopexqh);
  controller -> inttimer   = oz_knl_timer_alloc ();

  /* Create the devices now in case someone wants to queue requests before we sense if the drive is there or not. */
  /* This will happen if we are booting from floppy and the floppy will be mounted right away.  In that case, the */
  /* mount will wait for the initialization to complete.  I hate waiting for boot routines to grind on floppies.  */

  ldevex = &(controller -> devexs);
  for (drivesel = 0; drivesel < 2; drivesel ++) {

    /* Create the device unit struct */

    oz_sys_sprintf (sizeof unitname, unitname, NAME ".%c%u", ctrlname[0], drivesel);
    devunit = oz_knl_devunit_create (devdriver, unitname, "", &floppy_functable, 0, oz_s_secattr_sysdev);
    if (devunit == NULL) continue;

    /* Fill in the device unit extension info */

    devex = oz_knl_devunit_ex (devunit);
    devex -> failed      = 0;
    devex -> devunit     = devunit;
    devex -> motor_timer = oz_knl_timer_alloc ();
    devex -> motoroff    = 0;
    devex -> controller  = controller;
    devex -> sizecode    = 0;
    devex -> drivesel    = drivesel;
    devex -> volvalid    = 0;
    devex -> unitname    = oz_knl_devunit_devname (devunit);

    /* Link it to list of devices on the controller */

    *ldevex = devex;
    ldevex = &(devex -> next);

    /* Set its status */

    setdrivestatus (devex, "probing");

    /* Set it up to automount a filesystem (theoretically, it can do partitions, too) */

    oz_knl_devunit_autogen (devunit, oz_dev_disk_auto, NULL);
  }
  *ldevex = NULL;

  /* Start the kernel thread to process the initialization and then the I/O requests */

  oz_sys_sprintf (sizeof threadname, threadname, NAME " %s", ctrlname);
  sts = oz_knl_event_create (sizeof threadname, threadname, NULL, &(controller -> event));
  if (sts != OZ_SUCCESS) oz_knl_printk ("oz_dev_floppy config: error %u creating event %s\n", sts, ctrlname);
  else {
    sts = oz_knl_thread_create (oz_s_systemproc, oz_knl_user_getmaxbasepri (NULL), NULL, NULL, NULL, 0, 
                                floppy_thread, controller, OZ_ASTMODE_INHIBIT, sizeof threadname, threadname, 
                                NULL, &thread);
    if (sts != OZ_SUCCESS) oz_knl_printk ("oz_dev_floppy config: error %u creating thread %s\n", sts, ctrlname);
    else {
      oz_knl_thread_orphan (thread);
      oz_knl_thread_increfc (thread, -1);
    }
  }
}

/************************************************************************/
/*									*/
/*  This routine is called when the system is being shut down.  It can 	*/
/*  be assumed that there is no floppy I/O going as disks have been 	*/
/*  dismounted at this point.						*/
/*									*/
/************************************************************************/

static int floppy_shutdown (OZ_Devunit *devunit, void *devexv)

{
  /* Turn both motors off and reset controller */

  oz_hw486_outb (0, ((Devex *)devexv) -> controller -> ioportbase + DOR);
  return (1);
}

/************************************************************************/
/*									*/
/*  The last reference was removed from the device and now the system 	*/
/*  wants to know if it should be deleted				*/
/*									*/
/*    Input:								*/
/*									*/
/*	devunit/devexv = device to be deleted				*/
/*	cloned = as passed to oz_knl_devunit_create			*/
/*	smplevel = dv							*/
/*									*/
/*    Output:								*/
/*									*/
/*	floppy_clonedel = 1 : ok to delete the device			*/
/*									*/
/*    Note:								*/
/*									*/
/*	This routine is used to delete a device that failed to 		*/
/*	initialize at boot time.  It should only get called with 	*/
/*	'failed=1' after the setdevicefailed routine decrements the 	*/
/*	reference count.						*/
/*									*/
/*	It should never be called for good devices, as the driver 	*/
/*	keeps its original reference count out on the devunit.		*/
/*									*/
/************************************************************************/

static int floppy_clonedel (OZ_Devunit *devunit, void *devexv, int cloned)

{
  Controller *controller;
  Devex *devex, **ldevex, *xdevex;

  devex = devexv;
  if (devex -> failed <= 0) oz_crash ("oz_dev_floppy_486 clonedel: devex %p -> failed %d", devex, devex -> failed);
  controller = devex -> controller;		// unlink it from controller
  for (ldevex = &(controller -> devexs); (xdevex = *ldevex) != devex; ldevex = &(xdevex -> next)) {}
  *ldevex = xdevex -> next;
  return (1);					// it's ok to delete it
}

/************************************************************************/
/*									*/
/*  Abort I/O request in progress					*/
/*									*/
/************************************************************************/

static void floppy_abort (OZ_Devunit *devunit, void *devexv, OZ_Iochan *iochan, void *chnexv, 
                          OZ_Ioop *ioop, void *iopexv, OZ_Procmode procmode)

{
  Controller *controller;
  Devex *devex;
  Iopex *iopex, **liopex, *xiopex;
  uLong fd;

  devex  = devexv;
  xiopex = NULL;								// haven't found anything to abort yet
  controller = devex -> controller;						// point to controller struct

  /* Remove any matching requests from controller queue */

  fd  = oz_hw_smplock_wait (smplock_fd);					// lock its queue
  for (liopex = &(controller -> iopexqh); (iopex = *liopex) != NULL;) {		// scan the queue
    if (oz_knl_ioabortok (iopex -> ioop, iochan, procmode, ioop)) {		// see if this is something we should abort
      *liopex = iopex -> next;							// if so, unlink from queue
      iopex -> next = xiopex;							// link to stuff to abort
      xiopex = iopex;
    } else {
      liopex = &(iopex -> next);						// leave it alone
    }
  }
  controller -> iopexqt = liopex;						// set up possibly new tail pointer

  iopex = controller -> iopexip;						// maybe abort the request in progress
  if ((iopex != NULL) && oz_knl_ioabortok (iopex -> ioop, iochan, procmode, ioop)) iopex -> aborted = 1;
  oz_hw_smplock_clr (smplock_fd, fd);						// unlock the queue

  /* Now that we're back at softint level, abort all the requests we found */

  while ((iopex = xiopex) != NULL) {
    xiopex = iopex -> next;
    oz_knl_iodone (iopex -> ioop, OZ_ABORTED, NULL, NULL, NULL);
  }
}

/************************************************************************/
/*									*/
/*  Start performing a disk i/o function				*/
/*									*/
/************************************************************************/

static uLong floppy_start (OZ_Devunit *devunit, void *devexv, OZ_Iochan *iochan, void *chnexv, OZ_Procmode procmode, 
                           OZ_Ioop *ioop, void *iopexv, uLong funcode, uLong as, void *ap)

{
  Controller *controller;
  Devex *devex;
  Iopex *iopex;
  uLong fd, sts;

  devex = devexv;
  iopex = iopexv;
  iopex -> aborted = 0;

  /* Process individual functions */

  switch (funcode) {

    /* Set volume valid bit one way or the other */

    case OZ_IO_DISK_SETVOLVALID: {
      OZ_IO_disk_setvolvalid disk_setvolvalid;

      movc4 (as, ap, sizeof disk_setvolvalid, &disk_setvolvalid);
      iopex -> writing = disk_setvolvalid.valid;
      iopex -> be = be_setvolvalid;
      break;
    }

    /* Write blocks to the disk */

    case OZ_IO_DISK_WRITEBLOCKS: {
      OZ_IO_disk_writeblocks disk_writeblocks;

      movc4 (as, ap, sizeof disk_writeblocks, &disk_writeblocks);
      sts = oz_knl_ioop_lockr (ioop, disk_writeblocks.size, disk_writeblocks.buff, &(iopex -> phypages), NULL, &(iopex -> byteoffs));
      if (sts != OZ_SUCCESS) return (sts);

      iopex -> size      = disk_writeblocks.size;
      iopex -> slbn      = disk_writeblocks.slbn;
      iopex -> writethru = disk_writeblocks.writethru;
      iopex -> be        = be_writeblocks;
      break;
    }

    /* Read blocks from the disk */

    case OZ_IO_DISK_READBLOCKS: {
      OZ_IO_disk_readblocks disk_readblocks;

      movc4 (as, ap, sizeof disk_readblocks, &disk_readblocks);
      sts = oz_knl_ioop_lockw (ioop, disk_readblocks.size, disk_readblocks.buff, &(iopex -> phypages), NULL, &(iopex -> byteoffs));
      if (sts != OZ_SUCCESS) return (sts);

      iopex -> size = disk_readblocks.size;
      iopex -> slbn = disk_readblocks.slbn;
      iopex -> be   = be_readblocks;
      break;
    }

    /* Write pages to the disk */

    case OZ_IO_DISK_WRITEPAGES: {
      OZ_IO_disk_writepages disk_writepages;

      if (procmode != OZ_PROCMODE_KNL) return (OZ_KERNELONLY);

      movc4 (as, ap, sizeof disk_writepages, &disk_writepages);

      iopex -> phypages  = disk_writepages.pages;
      iopex -> byteoffs  = disk_writepages.offset;
      iopex -> size      = disk_writepages.size;
      iopex -> slbn      = disk_writepages.slbn;
      iopex -> writethru = disk_writepages.writethru;
      iopex -> be        = be_writeblocks;
      break;
    }

    /* Read pages from the disk */

    case OZ_IO_DISK_READPAGES: {
      OZ_IO_disk_readpages disk_readpages;

      if (procmode != OZ_PROCMODE_KNL) return (OZ_KERNELONLY);

      movc4 (as, ap, sizeof disk_readpages, &disk_readpages);

      iopex -> phypages = disk_readpages.pages;
      iopex -> byteoffs = disk_readpages.offset;
      iopex -> size = disk_readpages.size;
      iopex -> slbn = disk_readpages.slbn;
      iopex -> be   = be_readblocks;
      break;
    }

    /* Get info part 1 */

    case OZ_IO_DISK_GETINFO1: {
      OZ_IO_disk_getinfo1 disk_getinfo1;

      if (!OZ_HW_WRITABLE (as, ap, procmode)) return (OZ_ACCVIO);
      memset (&disk_getinfo1, 0, sizeof disk_getinfo1);				/* zero fill to clear params we don't care and/or know about */
      if (devex -> volvalid) {
        disk_getinfo1.blocksize   = DISK_BLOCK_SIZE;				/* return what we know about */
        disk_getinfo1.secpertrk   = sectorspertrack[devex->sizecode];
        disk_getinfo1.trkpercyl   = TRACKSPERCYLINDER;
        disk_getinfo1.cylinders   = CYLINDERS;
        disk_getinfo1.totalblocks = disk_getinfo1.secpertrk * disk_getinfo1.trkpercyl * disk_getinfo1.cylinders;
      }
      if (as <= sizeof disk_getinfo1) {
        memcpy (ap, &(disk_getinfo1), as);
      } else {
        memcpy (ap, &disk_getinfo1, sizeof disk_getinfo1);
        memset (((uByte *)ap) + sizeof disk_getinfo1, 0, as - sizeof disk_getinfo1);
      }
      return (OZ_SUCCESS);
    }

    /* Format -- param string 'sectorsize[,gaplength]' */

    case OZ_IO_DISK_FORMAT: {
      char paramstr[16];
      int usedup, usedup2;
      OZ_IO_disk_format disk_format;
      uLong blocksize, gaplength, sizecode;

      movc4 (as, ap, sizeof disk_format, &disk_format);
      sts = oz_knl_section_ugetz (procmode, sizeof paramstr, disk_format.paramstr, paramstr, NULL);
      if (sts != OZ_SUCCESS) return (sts);				// param string is not addressible
      blocksize = oz_hw_atoi (paramstr, &usedup);			// get sector size from param string
      for (sizecode = 0; sizecode < MAXSIZECODE; sizecode ++) {		// try to find it in the table
        devex -> sizecode = sizecode;
        if (DISK_BLOCK_SIZE == blocksize) break;
      }
      if (sizecode == MAXSIZECODE) return (OZ_BADPARAM);		// if not found, return error status
      gaplength = GPL_2;						// set up default gap length
      if (paramstr[usedup] == ',') {					// see if gap length specified
        gaplength = oz_hw_atoi (paramstr + (++ usedup), &usedup2);	// ok, decode it
        if (gaplength > 0xFF) return (OZ_BADPARAM);			// make sure it is not too big
        usedup += usedup2;						// increment to where terminator is
      }
      if (paramstr[usedup] != 0) return (OZ_BADPARAM);			// check for no junk left in param string
      iopex -> size     = sizecode;					// save the size code here
      iopex -> writing  = 1;						// we are writing to floppy
      iopex -> phypages = NULL;						// we will use the dmapage_buff
      iopex -> byteoffs = gaplength;					// save the gap length here
      iopex -> be = be_format;						// queue the formatting routine
      break;
    }

    /* Who knows what */

    default: {
      return (OZ_BADIOFUNC);
    }
  }

  /* Queue request to kernel thread and wake it if this is the first one on queue */

  iopex -> ioop  = ioop;
  iopex -> devex = devex;
  iopex -> next  = NULL;								// this shall be last in the queue
  controller = devex -> controller;							// point to controller struct
  sts = OZ_DEVOFFLINE;									// assume the device has failed to init
  fd  = oz_hw_smplock_wait (smplock_fd);						// lock its queue
  if (devex -> failed <= 0) {
    *(controller -> iopexqt) = iopex;							// link new request on end
    controller -> iopexqt = &(iopex -> next);
    sts = OZ_STARTED;									// it has been successfully queued
  }
  oz_hw_smplock_clr (smplock_fd, fd);							// unlock the queue
  if (controller -> iopexqh == iopex) {							// wake if this is first in queue
    oz_knl_event_set (controller -> event, 1);
  }
  return (sts);
}

/************************************************************************/
/*									*/
/*  This kernel thread processes requests for the floppy.  There is 	*/
/*  one kernel thread per controller.					*/
/*									*/
/************************************************************************/

static uLong floppy_thread (void *controllerv)

{
  char c, *q, unitdesc[OZ_DEVUNIT_DESCSIZE], unitname[OZ_DEVUNIT_NAMESIZE];
  Controller *controller;
  Devex *devex, **dp;
  int foundone, si;
  Iopex *iopex;
  OZ_Datebin now;
  OZ_Devunit *devunit;
  OZ_Event *event;
  uByte dor, drivesel;
  uLong dv, fd, sts;
  uWord ioportbase;

  controller = controllerv;
  ioportbase = controller -> ioportbase;

  si = oz_hw_cpu_setsoftint (0);

  /* Link it so interrupt routine can see it */

  fd = oz_hw_smplock_wait (smplock_fd);
  controller -> next = controllers;
  controllers = controller;
  oz_hw_smplock_clr (smplock_fd, fd);

  /* See if the controller is even there.  If not, delete the devices and exit. */

  oz_knl_printk ("oz_dev_floppy: resetting %s floppy controller (port %X)\n", controller -> ctrlname, ioportbase);
  if (!resetctrlr (controller, 0)) {
    oz_knl_printk ("oz_dev_floppy: %s controller didn't come ready\n", controller -> ctrlname);
    while (1) {
      dv = oz_hw_smplock_wait (&oz_s_smplock_dv);
      for (devex = controller -> devexs; devex != NULL; devex = devex -> next) if (devex -> failed <= 0) break;
      oz_hw_smplock_clr (&oz_s_smplock_dv, dv);
      if (devex == NULL) break;
      setdrivefailed (devex);
    }
    oz_hw_cpu_setsoftint (si);
    return (OZ_SUCCESS);
  }

  /* Loop through each possible device to see if it is there by doing a recalibrate */

  foundone = 0;
  while (1) {
    dv = oz_hw_smplock_wait (&oz_s_smplock_dv);					// find one we haven't processed yet
    for (devex = controller -> devexs; devex != NULL; devex = devex -> next) if (devex -> failed == 0) break;
    oz_hw_smplock_clr (&oz_s_smplock_dv, dv);
    if (devex == NULL) break;							// we've done them all, exit loop
    oz_knl_printk ("oz_dev_floppy: recalibrating %s\n", devex -> unitname);	// announce we are going to check it
    if (!recalibrate (devex)) setdrivefailed (devex);				// check it, if failed, delete drive
    else {
      devex -> failed = -1;							// it's ok, mark it online
      setdrivestatus (devex, "online");
      oz_knl_printk ("oz_dev_floppy: %s available\n", devex -> unitname);	//   print a message
      foundone = 1;								//   don't exit the kernel thread
    }
    oz_hw486_outb (DOR_RESET_, ioportbase + DOR);					// anyway, turn the motors all off
  }

  /* Init completed, good or bad      */
  /* If there aren't any drives, exit */

  if (!foundone) {
    oz_knl_printk ("oz_dev_floppy: no drives attached to %s controller\n", controller -> ctrlname);
    oz_hw_cpu_setsoftint (si);
    return (OZ_SUCCESS);
  }

  /* Process I/O requests for those drives forever */

  while (1) {

    /* See if there are any requests to process */

    fd = oz_hw_smplock_wait (smplock_fd);
    iopex = controller -> iopexqh;
    if (iopex != NULL) {
      controller -> iopexqh = iopex -> next;
      if (iopex -> next == NULL) controller -> iopexqt = &(controller -> iopexqh);
      controller -> iopexip = iopex;
    }
    oz_hw_smplock_clr (smplock_fd, fd);

    /* If not, wait for something to do */

    if (iopex == NULL) {

      /* Meanwhile, maybe some motors need turning off                */
      /* Do this here instead of in timer ast so it gets synchronized */

      now = oz_hw_tod_getnow ();
      for (devex = controller -> devexs; devex != NULL; devex = devex -> next) {
        if ((devex -> motoroff != 0) && (now >= devex -> motoroff)) {
          if (devex -> volvalid) flushtrackbuffer (devex);	// make sure any pending writes are flushed first
          dor  = oz_hw486_inb (ioportbase + DOR);			// now turn the motor off
          dor &= ~ (DOR_MOTEN0 << devex -> drivesel);
          oz_hw486_outb (dor, ioportbase + DOR);
        }
      }

      /* Now we can wait */

      if (controller -> iopexqh == NULL) {			// flushtrackbuffer may have cleared event flag
								// just after a new request was queued so test again
        oz_knl_event_waitone (controller -> event);
        oz_knl_event_set (controller -> event, 0);
      }
    }

    /* Otherwise, process request */

    else {
      oz_knl_process_setcur (oz_knl_ioop_getprocess (iopex -> ioop));	// switch processes to access parameters and buffers
      sts = (*(iopex -> be)) (iopex);					// perform the I/O request
      controller -> iopexip = NULL;					// don't let floppy_abort see it now
      oz_knl_iodone (iopex -> ioop, sts, NULL, NULL, NULL);		// post completion
      oz_knl_process_setcur (oz_s_systemproc);				// switch back to neutral territory
    }
  }
}

/* The drive failed initialization tests, mark it as failed then abort any I/O requests that may have queued */
/* Upon return, the devex pointer is no longer valid, and the controller->devexs list might be modified      */

static void setdrivefailed (Devex *devex)

{
  Controller *controller;
  Iopex *iopex, **liopex;
  OZ_Devunit *devunit;
  uLong fd;

  /* Set the status string to note that it has failed to initialize */

  setdrivestatus (devex, "init failed");

  /* Abort any pending I/O requests */

  controller = devex -> controller;
check:
  fd = oz_hw_smplock_wait (smplock_fd);			// lock this controller's i/o request queue
  devex -> failed = 1;					// mark it as failed so no new requests will queue
  for (liopex = &(controller -> iopexqh); (iopex = *liopex) != NULL; liopex = &(iopex -> next)) {
    if (iopex -> devex != devex) continue;		// skip request if it's not for this drive
    *liopex = iopex -> next;				// unlink the request
    if (*liopex == NULL) controller -> iopexqt = liopex;
    oz_hw_smplock_clr (smplock_fd, fd);			// release lock and post request
    oz_knl_iodone (iopex -> ioop, OZ_DEVOFFLINE, NULL, NULL, NULL);
    goto check;						// re-scan list for more
  }
  oz_hw_smplock_clr (smplock_fd, fd);			// none in there, release lock

  /* Call the clonedel routine to actually delete the devunit/devex structs when all channels are deassigned */

  oz_knl_devunit_increfc (devex -> devunit, -1);	// dec ref count, if/when it goes zero, call clonedel
}

/* Set the drive status string in the unit description */

static void setdrivestatus (Devex *devex, const char *status)

{
  char unitdesc[OZ_DEVUNIT_DESCSIZE];
  Controller *controller;

  controller = devex -> controller;
  oz_sys_sprintf (sizeof unitdesc, unitdesc, "(port %X) %s", controller -> ioportbase, status);
  oz_knl_devunit_rename (devex -> devunit, NULL, unitdesc);
}

/************************************************************************/
/*									*/
/*  Set volume valid I/O request					*/
/*									*/
/*    Input:								*/
/*									*/
/*	iopex -> writing = 0 : turn volume offline, flush track buffer	*/
/*	                   1 : turn volume online (if media is loaded)	*/
/*									*/
/************************************************************************/

static uLong be_setvolvalid (Iopex *iopex)

{
  Devex *devex;
  uByte dor;
  uLong sts;

  devex = iopex -> devex;

  sts = OZ_SUCCESS;
  if (iopex -> writing) {					// see if turning it online
    devex -> volvalid = mediaonline (iopex);			// ... see if media is loaded
    if (!(devex -> volvalid)) sts = OZ_VOLNOTVALID;		// ... and maybe return error code
  } else if (devex -> volvalid) {				// turning offline, see if currently online
    sts = flushtrackbuffer (devex);				// if online, flush track buffer
    OZ_KNL_NPPFREE (devex -> trackbuffer);			// ... then free track buffer
    devex -> trackbuffer = NULL;
    devex -> volvalid = 0;					// ... and mark volume offline
    dor  = oz_hw486_inb (devex -> controller -> ioportbase + DOR);	// ... and turn the motor off
    dor &= ~ (DOR_MOTEN0 << devex -> drivesel);
    oz_hw486_outb (dor, devex -> controller -> ioportbase + DOR);
  }
  return (sts);
}

/************************************************************************/
/*									*/
/*  Write blocks of data to floppy disk					*/
/*									*/
/*    Input:								*/
/*									*/
/*	size  = number of bytes to write				*/
/*	phypages/byteoffs = address of bytes to write			*/
/*	slbn  = starting logical block number				*/
/*	devex = device extension identifying floppy drive to write to	*/
/*									*/
/*	smplock = softint						*/
/*									*/
/*    Output:								*/
/*									*/
/*	write_blocks = OZ_SUCCES : successful write			*/
/*	                    else : error status				*/
/*	data written to floppy						*/
/*									*/
/************************************************************************/

static uLong be_writeblocks (Iopex *iopex)

{
  uByte command[9], cylinder, msr, results[7], secintrk, sector, track;
  const uByte *p;
  Devex *devex;
  OZ_Dbn startblock;
  uLong direct, secpertrk, sts, writelen;
  uWord port;

  devex = iopex -> devex;

  /* Check volume valid bit */

  sts = chkvolvalid (devex);
  if (sts != OZ_SUCCESS) return (sts);

  /* Check write-protect switch */

  if (!(devex -> writable)) return (OZ_WRITELOCKED);

  /* Turn mo-toron (if not already) */

  port = devex -> controller -> ioportbase;
  msr  = oz_hw486_inb (port + DOR);
  oz_hw486_outb ((msr & 0xFC) | DOR_RESET_ | DOR_DMAGATE | devex -> drivesel | (DOR_MOTEN0 << devex -> drivesel), port + DOR);

  /* Start writing */

  secpertrk = sectorspertrack[devex->sizecode];
  while (iopex -> size > 0) {

    /* If it doesn't start within current track buffer, flush current track buffer and start a new one */

    secintrk   = iopex -> slbn % secpertrk;	// get sector within track we are doing
    startblock = iopex -> slbn - secintrk;	// get block at beginning of track we are doing
    if (startblock != devex -> startblock) {	// see if it is in the track buffer
      sts = flushtrackbuffer (devex);		// if not, flush the track that's in there
      if (sts != OZ_SUCCESS) goto rtn;
      devex -> startblock  = startblock;	// then say this track is in there now
      devex -> validblocks = 0;			// ... but none of it is valid
      devex -> dirtybeg    = secpertrk;		// ... and none of it is dirty
      devex -> dirtyend    = 0;
    }
    if (secintrk > devex -> validblocks) {	// see if there is a gap after what's valid and where we're starting
      sts = filltrackbuffer (devex);		// if so, read the rest of the track from the floppy to fill the gap
      if (sts != OZ_SUCCESS) goto rtn;
    }

    /* Copy data into track buffer and make sure the dirty limits contain it */

    writelen = (secpertrk - secintrk) << L2DISK_BLOCK_SIZE;	// get how many bytes are left in the track from where we start
    if (writelen > iopex -> size) writelen = iopex -> size;	// ... but don't do more than the caller gave us to write
    oz_hw_phys_movetovirt (writelen, devex -> trackbuffer + (secintrk << L2DISK_BLOCK_SIZE), iopex -> phypages, iopex -> byteoffs);

    if (devex -> dirtybeg > secintrk) devex -> dirtybeg = secintrk;		// maybe move beg of dirty stuff back
    secintrk += writelen >> L2DISK_BLOCK_SIZE;					// get block number after where we wrote
    if (devex -> dirtyend < secintrk) devex -> dirtyend = secintrk;		// maybe move end of dirty stuff down
    if (devex -> validblocks < secintrk) devex -> validblocks = secintrk;	// maybe move end of valid stuff down

    /* Increment and continue */

    iopex -> size -= writelen;				// this fewer bytes to do
    iopex -> slbn += writelen >> L2DISK_BLOCK_SIZE;	// start at this block number next time
    iopex -> byteoffs += writelen;			// start at this offset in buffer next time

    /* Maybe it is being aborted */

    sts = OZ_ABORTED;
    if (iopex -> aborted) goto rtn;
  }

  /* If writethru mode, flush the track buffer out to the floppy */

  sts = OZ_SUCCESS;
  if (iopex -> writethru) sts = flushtrackbuffer (devex);

rtn:
  motor_timer_start (devex);
  return (sts);
}

/************************************************************************/
/*									*/
/*  Read blocks of data from floppy disk				*/
/*									*/
/*    Input:								*/
/*									*/
/*	size  = number of bytes to read					*/
/*	slbn  = starting logical block number				*/
/*	devex = device extension identifying floppy drive to read from	*/
/*									*/
/*	smplock = softint						*/
/*									*/
/*    Output:								*/
/*									*/
/*	read_blocks = OZ_SUCCES : successful read			*/
/*	                   else : error status				*/
/*	phypages/byteoffs = filled with data read from floppy		*/
/*									*/
/************************************************************************/

static uLong be_readblocks (Iopex *iopex)

{
  uByte command[9], cylinder, endintrk, msr, results[7], secintrk, sector, track;
  Devex *devex;
  int retries;
  OZ_Dbn startblock;
  uLong direct, readlen, secpertrk, sts;
  uWord port;

  devex = iopex -> devex;

  /* Check volume valid bit */

  sts = chkvolvalid (devex);
  if (sts != OZ_SUCCESS) return (sts);

  /* Turn motor on (if not already) */

  port = devex -> controller -> ioportbase;
  msr  = oz_hw486_inb (port + DOR);
  oz_hw486_outb ((msr & 0xFC) | DOR_RESET_ | DOR_DMAGATE | devex -> drivesel | (DOR_MOTEN0 << devex -> drivesel), port + DOR);

  /* Start reading */

  secpertrk = sectorspertrack[devex->sizecode];
  while (iopex -> size > 0) {

    /* If it doesn't start within current track buffer, flush current track buffer and start a new one */

    secintrk   = iopex -> slbn % secpertrk;			// get sector within track we are doing
    startblock = iopex -> slbn - secintrk;			// get block at beginning of track we are doing
    if (startblock != devex -> startblock) {			// see if it is in the track buffer
      sts = flushtrackbuffer (devex);				// if not, flush the track that's in there
      if (sts != OZ_SUCCESS) goto rtn;
      devex -> startblock  = startblock;			// then say this track is in there now
      devex -> validblocks = 0;					// ... but none of it is valid
      devex -> dirtybeg    = secintrk;				// ... and none of it is dirty
      devex -> dirtyend    = 0;
    }
    readlen  = (secpertrk - secintrk) << L2DISK_BLOCK_SIZE;	// this is now many bytes to end of track
    if (readlen > iopex -> size) readlen = iopex -> size;	// if more than we want, read just enough
    endintrk = secintrk + (readlen >> L2DISK_BLOCK_SIZE);
    if (endintrk > devex -> validblocks) {			// see if there is a gap after what's valid and where we end reading
      sts = filltrackbuffer (devex);				// if so, read the rest of the track from the floppy to fill the gap
      if (sts != OZ_SUCCESS) goto rtn;
    }

    /* Copy from track buffer, increment and continue */

    oz_hw_phys_movefromvirt (readlen, devex -> trackbuffer + (secintrk << L2DISK_BLOCK_SIZE), iopex -> phypages, iopex -> byteoffs);

    iopex -> size -= readlen;					// decrement what we have left to do
    iopex -> slbn += readlen >> L2DISK_BLOCK_SIZE;		// increment block number
    iopex -> byteoffs += readlen;				// increment where we put what's left

    /* Maybe it is being aborted */

    sts = OZ_ABORTED;
    if (iopex -> aborted) goto rtn;
  }

  sts = OZ_SUCCESS;

rtn:
  motor_timer_start (devex);
  return (sts);
}

/************************************************************************/
/*									*/
/*  Format a floppy							*/
/*									*/
/*    Input:								*/
/*									*/
/*	size  = size code (0=128, 1=256, 2=512, ...)			*/
/*	devex = device extension identifying floppy drive to write to	*/
/*									*/
/*	smplock = softint						*/
/*									*/
/*    Output:								*/
/*									*/
/*	be_format = OZ_SUCCES : successful				*/
/*	                 else : error status				*/
/*									*/
/************************************************************************/

static uLong be_format (Iopex *iopex)

{
  Controller *controller;
  Devex *devex;
  int i;
  OZ_Datebin when;
  uByte command[6], cylinder, gaplength, msr, *p, results[7], sector, track;
  uLong secpertrk, sts, writelen;
  uWord port;

  devex = iopex -> devex;
  controller = devex -> controller;

  /* Turn mo-toron (if not already) */

  port = controller -> ioportbase;
  msr  = oz_hw486_inb (port + DOR);
  oz_hw486_outb ((msr & 0xFC) | DOR_RESET_ | DOR_DMAGATE | devex -> drivesel | (DOR_MOTEN0 << devex -> drivesel), port + DOR);

  /* Start formatting */

  devex -> sizecode = iopex -> size;
  gaplength  = iopex -> byteoffs;
  iopex -> byteoffs = 0;
  secpertrk = sectorspertrack[devex->sizecode];
  writelen  = secpertrk * 4;
  oz_knl_printk ("oz_dev_floppy_486: formatting %s, sector size %u, gap length %u\n", devex -> unitname, DISK_BLOCK_SIZE, gaplength);

  oz_hw486_outb (0, port + CCR);					// set data rate

  for (cylinder = 0; cylinder < CYLINDERS; cylinder ++) {
    oz_knl_printk ("\roz_dev_floppy_486: formatting %s cylinder %2u ...       ", devex -> unitname, cylinder);

    /* Seek to the cylinder to be formatted */

    sts = OZ_IOFAILED;
    if (cylinder == 0) {
      command[0] = 0x07;					// command = RECALIBRATE
      command[1] = devex -> drivesel;				// drive select bits
      if (!send_command (2, command, controller, 1)) goto rtn;
    } else {
      command[0] = 0x0F;					// command = SEEK
      command[1] = devex -> drivesel;				// drive select bits
      command[2] = cylinder;					// cylinder number
      if (!send_command (3, command, controller, 1)) goto rtn;
    }
    command[0] = 0x08;						// command = sense interrupt status
    if (!send_command (1, command, controller, 0)) goto rtn;
    sts = recv_results (2, results, port, devex, 0x08);		// read seek results
    if (sts != OZ_SUCCESS) goto rtn;
    if ((results[0] & 0xE0) != 0x20) {
      oz_knl_printk ("\noz_dev_floppy: %s seek to cyl %u did not complete, st0 %X\n", devex -> unitname, cylinder, results[0]);
      sts = OZ_IOFAILED;
      goto rtn;
    }
    if (results[1] != cylinder) {
      oz_knl_printk ("\noz_dev_floppy: %s seek went to cylinder %u instead of %u\n", devex -> unitname, results[1], cylinder);
      sts = OZ_IOFAILED;
      goto rtn;
    }

    /* Wait a settling time */

    when  = oz_hw_tod_getnow ();								// get what time it is now
    when += OZ_TIMER_RESOLUTION / 2;								// get what time it will be in 1/2 sec
    do {
      controller -> waitingforint = 0;								// we're just waiting for interrupt timeout timer
      oz_knl_timer_insert (controller -> inttimer, when, int_timeout, controller);		// put timer in queue
      while (controller -> waitingforint >= 0) {						// wait for it to time out
        oz_knl_event_waitone (controller -> event);
        oz_knl_event_set (controller -> event, 0);
      }
    } while (oz_hw_tod_getnow () < when);							// repeat if it woke too soon

    /* Do each track in the cylinder */

    for (track = 0; track < TRACKSPERCYLINDER; track ++) {

      /* Put formatting data in temp DMA buffer and set up dma registers    */
      /* phypages = NULL so dmapage_setup routine knows to use dmapage_buff */

      oz_knl_printk ("f");
      LOCKDMA ();
      dmapage_setup (DMA_MEM2DEV, secpertrk * 4, devex, 0, NULL, 0);
      p = dmapage_vadr;
      for (sector = 1; sector <= secpertrk; sector ++) {
        *(p ++) = cylinder;
        *(p ++) = track;
        *(p ++) = sector;
        *(p ++) = devex -> sizecode;
      }

      /* Send a format track command to the controller */

      command[0] = 0x4D;					// command = MFM, FORMAT TRACK
      command[1] = (track << 2) + devex -> drivesel;		// drive select and head select bits
      command[2] = devex -> sizecode;				// 00=128 bytes per sector, 01=256 bytes per sector, ...
      command[3] = secpertrk;					// number of sectors in the track
      command[4] = gaplength;
      command[5] = 0x00;					// initial data fill byte value
      if (!send_command (6, command, controller, 1)) {
        UNLKDMA ();
        sts = OZ_IOFAILED;
        goto rtn;
      }

      /* Receive the results back */

      sts = recv_results (7, results, port, devex, 0x4D);
      UNLKDMA ();
      if (sts != OZ_SUCCESS) goto rtn;
      if ((results[0] & 0xC0) != 0x00) {
        oz_knl_printk ("\n");
        print_rw_err ("format", devex, command, results, writelen);
        sts = OZ_IOFAILED;
        goto rtn;
      }

      /* Now write all zeroes to the track */

      oz_knl_printk ("w");
      LOCKDMA ();
      dmapage_setup (DMA_MEM2DEV, secpertrk * DISK_BLOCK_SIZE, devex, 0, NULL, 0);
      memset (dmapage_vadr, 0x69, secpertrk * DISK_BLOCK_SIZE);

      command[0] = 0x45;				/* command = MFM, WRITE */
      command[1] = (track << 2) + devex -> drivesel;	/* drive select and head select bits */
      command[2] = cylinder;				/* cylinder number (starting at zero) */
      command[3] = track;				/* track number (head select, 0 or 1) */
      command[4] = 1;					/* sector number (starting at one) */
      command[5] = devex -> sizecode;			/* 00=128 bytes per sector, 01=256 bytes per sector, ... */
      command[6] = secpertrk;				/* last sector on track (inclusive) */
      command[7] = GPL_1;
      command[8] = 0xFF;				/* data transfer length = maximum */
      sts = OZ_IOFAILED;
      if (!send_command (9, command, devex -> controller, 1)) {
        UNLKDMA ();
        goto rtn;
      }

      sts = recv_results (7, results, devex -> controller -> ioportbase, devex, 0x45);
      UNLKDMA ();
      if (sts != OZ_SUCCESS) goto rtn;
      if ((results[0] & 0xC0) != 0x00) {
        oz_knl_printk ("\n");
        print_rw_err ("write", devex, command, results, writelen);
        sts = OZ_IOFAILED;
        goto rtn;
      }

      /* Now read the whole track back */

      oz_knl_printk ("r");
      LOCKDMA ();
      dmapage_setup (DMA_DEV2MEM, secpertrk * DISK_BLOCK_SIZE, devex, 0, NULL, 0);

      command[0] = 0x42;				/* command = MFM, READ TRACK */
      command[1] = (track << 2) + devex -> drivesel;	/* drive select and head select bits */
      command[2] = cylinder;				/* cylinder number (starting at zero) */
      command[3] = track;				/* track number (head select, 0 or 1) */
      command[4] = 1;					/* sector number (starting at one) */
      command[5] = devex -> sizecode;			/* 00=128 bytes per sector, 01=256 bytes per sector, ... */
      command[6] = secpertrk;				/* last sector on track (inclusive) */
      command[7] = GPL_1;
      command[8] = 0xFF;				/* data transfer length = maximum */
      sts = OZ_IOFAILED;
      if (!send_command (9, command, devex -> controller, 1)) {
        UNLKDMA ();
        goto rtn;
      }

      sts = recv_results (7, results, devex -> controller -> ioportbase, devex, 0x42);
      UNLKDMA ();
      if (sts != OZ_SUCCESS) goto rtn;
      if ((results[0] & 0xC0) != 0x00) {
        oz_knl_printk ("\n");
        print_rw_err ("read", devex, command, results, writelen);
        sts = OZ_IOFAILED;
        goto rtn;
      }

      /* Maybe it is being aborted */

      sts = OZ_ABORTED;
      if (iopex -> aborted) goto rtn;
    }
  }

  command[0] = 0x07;						// command = RECALIBRATE
  command[1] = devex -> drivesel;				// drive select bits
  send_command (2, command, controller, 1);			// retract the heads to cyl 0
  sts = OZ_SUCCESS;						// we're done

rtn:
  if (sts == OZ_SUCCESS) oz_knl_printk ("\noz_dev_floppy_486: format %s successful\n", devex -> unitname);
  else oz_knl_printk ("\noz_dev_floppy_486: error %u formatting %s\n", sts, devex -> unitname);
  motor_timer_start (devex);
  return (sts);
}

/************************************************************************/
/*									*/
/*  See if a volume is loaded in floppy drive and reset media changed 	*/
/*  flag								*/
/*									*/
/*    Input:								*/
/*									*/
/*	iopex = I/O requesting media online check			*/
/*	smplevel = softint						*/
/*									*/
/*    Output:								*/
/*									*/
/*	mediaonline = 0 : media not online				*/
/*	              1 : media is online				*/
/*									*/
/************************************************************************/

static int mediaonline (Iopex *iopex)

{
  Controller *controller;
  Devex *devex;
  int rc, retries;
  uByte command[3], dir, results[7];
  uLong byteoffs, pageoffs, sts, tracksize;
  uWord ioportbase;

  devex      = iopex -> devex;
  controller = devex -> controller;
  ioportbase = controller -> ioportbase;

  if (devex -> trackbuffer != NULL) {
    OZ_KNL_NPPFREE (devex -> trackbuffer);
    devex -> trackbuffer = NULL;
  }

  rc = 0;							/* assume we will fail to find media online */

  for (devex -> datarate = 0; devex -> datarate < 4; devex -> datarate ++) {
    if (iopex -> aborted) goto done;
    if (!resetctrlr (controller, devex -> datarate)) {		/* reset controller */
      oz_knl_printk ("oz_dev_floppy mediaonline: %s controller failed to reset\n", controller -> ctrlname);
      goto done;
    }
    if (iopex -> aborted) goto done;
    if (!recalibrate (devex)) goto done;			/* try to recalibrate drive */
    retries = 0;						/* DSKCHG flag reset retry counter */

retry:
    if (iopex -> aborted) goto done;
    command[0] = 0x0F;						/* command = seek */
    command[1] = devex -> drivesel;				/* drive select and head select bits */
    command[2] = retries + 1;					/* cylinder number (starting at zero) */
    if (!send_command (3, command, controller, 1)) goto done;
    if (!command_done (ioportbase, 0x0F)) goto done;
    driveidlewait (devex);					/* wait for drive to not be busy */
    if (iopex -> aborted) goto done;
    command[0] = 0x08;						/* send sense interrupt command */
    if (!send_command (1, command, controller, 0)) goto done;
    if (recv_results (2, results, ioportbase, devex, 0x08) != OZ_SUCCESS) goto done;
    if (results[0] & 0xC0) {
      oz_knl_printk ("oz_dev_floppy: %s recal error st0=%x, pcn=%x\n", devex -> unitname, results[0], results[1]);
      goto done;
    }
								/* if it came ready in there, media is online */
    dir = oz_hw486_inb (ioportbase + DIR);				/* make sure the DIR_DSKCHG_ bit is clear */
    if (dir & DIR_DSKCHG_) {
      if (++ retries < 3) goto retry;				/* if DIR_DSKCHG_ bit is set, seek again to clear it */
      oz_knl_printk ("oz_dev_floppy: %s media offline\n", devex -> unitname);
      goto done;
    }

    if (iopex -> aborted) goto done;
    devex -> writable = 0;					/* assume it is not write enabled */
    command[0] = 0x04;						/* 'sense drive status' command */
    command[1] = devex -> drivesel;				/* drive select and head select bits */
    if (!send_command (2, command, controller, 0)) goto done;	/* sense the drive's status */
    sts = recv_results (1, results, ioportbase, devex, 0x04);	/* read the results back */
    if (sts != OZ_SUCCESS) goto done;
    if (!(results[0] & ST3_WP)) devex -> writable = 1;		/* it is write enabled */

    if (iopex -> aborted) goto done;
    command[0] = 0x4A;						/* read ID to see if data rate it correct and to get block size code */
    command[1] = devex -> drivesel;
    if (!send_command (2, command, controller, 1)) goto done;
    sts = recv_results (7, results, ioportbase, devex, 0x4A);
    if (sts != OZ_SUCCESS) goto done;
    if ((results[0] & 0xC3) == devex -> drivesel) {		/* check the results */
      oz_knl_printk ("oz_dev_floppy: %s datarate %u seems to work\n", devex -> unitname, devex -> datarate);
      devex -> sizecode = results[6];
      if (results[6] >= MAXSIZECODE) oz_knl_printk ("oz_dev_floppy: %s size code %u too big\n", devex -> unitname, results[6]);
      else if (L2DISK_BLOCK_SIZE > OZ_HW_L2PAGESIZE) oz_knl_printk ("oz_dev_floppy: %s block size %u greater than page size\n", devex -> unitname, DISK_BLOCK_SIZE);
      else {
        rc = devex -> datarate + 1;				/* if everything worked, media is online */
        break;
      }
    } else {
      oz_knl_printk ("oz_dev_floppy: %s failed datarate %u, st0=%x, st1=%x, st2=%x\n", 
                     devex -> unitname, devex -> datarate, results[0], results[1], results[2]);
    }
  }

  /* If working datarate was found, allocate a track buffer */

  if (rc > 0) {
    devex -> datarate = rc - 1;
    oz_knl_printk ("oz_dev_floppy: %s using datarate %u\n", devex -> unitname, devex -> datarate);
    oz_knl_printk ("oz_dev_floppy: %s block size %u\n", devex -> unitname, DISK_BLOCK_SIZE);
    tracksize = sectorspertrack[devex->sizecode] << L2DISK_BLOCK_SIZE;
    devex -> trackbuffer = OZ_KNL_NPPMALLOC (tracksize);	/* malloc a track buffer */
    rc = 0;							/* get its physical page array for DMAing */
    for (byteoffs = 0; byteoffs < tracksize; byteoffs += sts) {
      if (rc > sizeof devex -> trackbuf_phypages / sizeof devex -> trackbuf_phypages[0]) {
        oz_crash ("oz_dev_floppy mediaonline: trackbuffer %p spans too many pages %d", devex -> trackbuffer, rc);
      }
      sts = oz_knl_misc_sva2pa (devex -> trackbuffer + byteoffs, devex -> trackbuf_phypages + rc, &pageoffs);
      if (rc == 0) devex -> trackbuf_pageoffs = pageoffs;
      else if (pageoffs != 0) {
        oz_crash ("oz_dev_floppy mediaonline: trackbuffer %p pageoffs[%d] = %X", devex -> trackbuffer, rc, pageoffs);
      }
      rc ++;
    }
    devex -> startblock  = 0;					/* say track buffer is empty */
    devex -> validblocks = 0;
    devex -> dirtybeg    = sectorspertrack[devex->sizecode];
    devex -> dirtyend    = 0;
    rc = 1;
    oz_knl_printk ("oz_dev_floppy: %s media %s\n", devex -> unitname, devex -> writable ? "read/write" : "read-only");
  }

done:
  motor_timer_start (devex);					/* restart motor timer */
  return (rc);							/* return resultant status */
}

/************************************************************************/
/*									*/
/*  Flush dirty blocks from current track buffer to the floppy		*/
/*									*/
/*    Input:								*/
/*									*/
/*	devex -> startblock  = starting block number of the track	*/
/*	devex -> dirtybeg    = starting block within the track that's	*/
/*	                       dirty (zero based)			*/
/*	devex -> dirtyend    = ending block (exclusive) that's dirty	*/
/*	devex -> trackbuffer = virtual address of track buffer		*/
/*									*/
/*    Output:								*/
/*									*/
/*	flushtrackbuffer = OZ_SUCCESS : successful			*/
/*	                         else : write error status		*/
/*	devex -> dirtybeg = devex -> dirtyend				*/
/*									*/
/************************************************************************/

static uLong flushtrackbuffer (Devex *devex)

{
  uByte command[9], cylinder, results[7], secpertrk, sector, track;
  uLong direct, sts, writelen;

  /* Calculate cylinder, track and sector that we will start writing */

  secpertrk = sectorspertrack[devex->sizecode];
  track     = devex -> startblock / secpertrk;
  cylinder  = track / TRACKSPERCYLINDER;
  track    %= TRACKSPERCYLINDER;
  sector    = devex -> dirtybeg;

  /* Repeat as long as there are dirty blocks to process */

  while (devex -> dirtyend > sector) {

    /* Determine how much to write = to end of dirty blocks or end of dma buffer */

    writelen = (devex -> dirtyend - sector) << L2DISK_BLOCK_SIZE;
    if (writelen > dmapage_size) writelen = dmapage_size;

    /* Set up DMA registers, copy data to temp dma buffer if track buffer not directly accessible */

    LOCKDMA ();
    direct = dmapage_setup (DMA_MEM2DEV, writelen, devex, devex -> trackbuf_pageoffs + (sector << L2DISK_BLOCK_SIZE), 
                            devex -> trackbuf_phypages, devex -> startblock + sector);
    if (direct != 0) writelen = direct;
    else memcpy (dmapage_vadr, devex -> trackbuffer + (sector << L2DISK_BLOCK_SIZE), writelen);

    /* Send a write command to the controller */

    command[0] = 0xC5;					/* command = MULTITRACK, MFM, WRITE */
    command[1] = (track << 2) + devex -> drivesel;	/* drive select and head select bits */
    command[2] = cylinder;				/* cylinder number (starting at zero) */
    command[3] = track;					/* track number (head select, 0 or 1) */
    command[4] = sector + 1;				/* sector number (starting at one) */
    command[5] = devex -> sizecode;			/* 00=128 bytes per sector, 01=256 bytes per sector, ... */
    command[6] = secpertrk;				/* last sector on track (inclusive) */
    command[7] = GPL_1;
    command[8] = 0xFF;					/* data transfer length = maximum */
    if (!send_command (9, command, devex -> controller, 1)) {
      UNLKDMA ();
      return (OZ_IOFAILED);
    }

    /* Receive the results back */

    sts = recv_results (7, results, devex -> controller -> ioportbase, devex, 0xC5);
    UNLKDMA ();
    if (sts != OZ_SUCCESS) return (sts);
    if ((results[0] & 0xC0) != 0x00) {
      print_rw_err ("write", devex, command, results, writelen);
      return (OZ_IOFAILED);
    }

    /* Maybe there are more sectors in the track that are dirty */

    sector += writelen >> L2DISK_BLOCK_SIZE;
  }

  devex -> dirtybeg = sector;

  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Fill track buffer by reading track from floppy			*/
/*									*/
/*    Input:								*/
/*									*/
/*	devex -> startblock  = starting block number of the track	*/
/*	devex -> validblocks = how many blocks in track are already valid
/*	devex -> trackbuffer = virtual address of track buffer		*/
/*									*/
/*    Output:								*/
/*									*/
/*	filltrackbuffer = OZ_SUCCESS : successful			*/
/*	                        else : read error status		*/
/*	devex -> validblocks = the whole track				*/
/*									*/
/************************************************************************/

static uLong filltrackbuffer (Devex *devex)

{
  int retries;
  uByte command[9], cylinder, results[7], secpertrk, sector, track;
  uLong direct, readlen, sts;

  /* Calculate cylinder, track and sector that we will start reading */

  secpertrk = sectorspertrack[devex->sizecode];
  track     = devex -> startblock / secpertrk;
  cylinder  = track / TRACKSPERCYLINDER;
  track    %= TRACKSPERCYLINDER;
  sector    = devex -> validblocks;

  /* Keep reading until we have the whole track */

  while (sector < secpertrk) {

    /* Determine how much to read = to end of track or end of dma buffer */

    readlen = (secpertrk - sector) << L2DISK_BLOCK_SIZE;
    if (readlen > dmapage_size) readlen = dmapage_size;

    /* Set up DMA registers to transfer directly to track buffer */

    retries = 3;
retry:
    LOCKDMA ();
    direct = dmapage_setup (DMA_DEV2MEM, readlen, devex, devex -> trackbuf_pageoffs + (sector << L2DISK_BLOCK_SIZE), 
                            devex -> trackbuf_phypages, devex -> startblock + sector);
    if ((direct != 0) && (direct < readlen)) readlen = direct;

    /* Send a read command to the controller */

    command[0] = 0xE6;							// command = MULTITRACK, MFM, SKIP_DELETED, READ
    command[1] = (track << 2) + devex -> drivesel;			// drive select and head select bits
    command[2] = cylinder;						// cylinder number (starting at zero)
    command[3] = track;							// track number (head select, 0 or 1)
    command[4] = sector + 1;						// sector number (starting at one)
    command[5] = devex -> sizecode;					// 00=128 bytes per sector, 01=256 bytes per sector, ...
    command[6] = secpertrk;						// last sector on track (inclusive)
    command[7] = GPL_1;
    command[8] = 0xFF;							// data transfer length = maximum
    if (!send_command (9, command, devex -> controller, 1)) {		// send command, wait for interrupt
      UNLKDMA ();
      return (OZ_IOFAILED);
    }

    /* Receive the results back */

    sts = recv_results (7, results, devex -> controller -> ioportbase, devex, 0xE6);
    UNLKDMA ();
    if (sts != OZ_SUCCESS) {
      readlen = 512;
      if (-- retries > 0) goto retry;
      return (sts);
    }
    if ((results[0] & 0xC0) != 0x00) {					// check for any error
      print_rw_err ("read", devex, command, results, readlen);
      readlen = 512;							// on retry, just do one block
      if (-- retries > 0) goto retry;
      return (OZ_IOFAILED);
    }

    /* If data is in temp dma buffer, copy to track buffer */

    if (direct == 0) memcpy (devex -> trackbuffer + (sector << L2DISK_BLOCK_SIZE), dmapage_vadr, readlen);

    /* Maybe there are more sectors in the track */

    sector += readlen >> L2DISK_BLOCK_SIZE;
  }

  devex -> validblocks = sector;

  return (OZ_SUCCESS);
}

/************************************************************************/
/*									*/
/*  Reset the controller then enable it					*/
/*									*/
/*    Input:								*/
/*									*/
/*	controller = controller to be reset				*/
/*	datarate   = what to program the data rate to			*/
/*									*/
/*    Output:								*/
/*									*/
/*	resetctrlr = 0 : controller never came ready			*/
/*	             1 : controller is ready				*/
/*									*/
/************************************************************************/

static int resetctrlr (Controller *controller, uByte datarate)

{
  uByte command[4];
  uWord ioportbase;

  ioportbase = controller -> ioportbase;

  /* Reset it */

  oz_hw486_outb (0, ioportbase + DOR);				/* make reset line active */
  oz_hw_stl_microwait (2000, NULL, NULL);			/* wait at least 2mS */
  oz_hw486_outb (DOR_RESET_ | DOR_DMAGATE, ioportbase + DOR);	/* release reset line */

  /* Wait for it to come ready */

  if (!oz_hw_stl_microwait (200000, resetctrlr_check, &ioportbase)) { /* wait up to 200mS for it to come ready */
    oz_knl_printk ("oz_dev_floppy resetctrlr: %s didn't come ready, msr %2.2X\n", controller -> ctrlname, oz_hw486_inb (ioportbase + MSR));
    return (0);							/* never came ready, fail */
  }

  /* Configure it */

  oz_hw486_outb (datarate, ioportbase + CCR);			/* set data rate */

#if 000 // screws up bochs
  command[0] = 0x12;						/* PERPENDICULAR command code */
  command[1] = 0;						/* disable perpendicular mode */
  if (!send_command (2, command, controller, 0)) return (0);
  if (!command_done (ioportbase, 0x12)) return (0);
#endif

  command[0] = 0x13;						/* CONFIGURE command code */
  command[1] = 0;
  command[2] = 0x4B;						/* - enable implied seek, enable fifo, fifo threshold=12 (0b+1) */
  command[3] = 0;
  if (!send_command (4, command, controller, 0)) return (0);
  if (!command_done (ioportbase, 0x13)) return (0);

  command[0] = 0x03;						/* SPECIFY command code */
  command[1] = 0;
  command[2] = 0;						/* - dma mode */
  if (!send_command (3, command, controller, 0)) return (0);
  if (!command_done (ioportbase, 0x03)) return (0);

  return (1);
}

static uLong resetctrlr_check (void *ioportbasev)

{
  uByte msr;
  uWord ioportbase;

  ioportbase = *(uWord *)ioportbasev;

  msr = oz_hw486_inb (ioportbase + MSR);			// read the master status register
  return ((msr & (MSR_RQM | MSR_CB)) == MSR_RQM);	// success if it is ready to accept a command
}

/************************************************************************/
/*									*/
/*  Recalibrate floppy							*/
/*									*/
/*    Input:								*/
/*									*/
/*	devex = drive to recalibrate					*/
/*									*/
/*    Output:								*/
/*									*/
/*	recalibrate = 0 : failed					*/
/*	              1 : successful					*/
/*									*/
/************************************************************************/

static int recalibrate (Devex *devex)

{
  Controller *controller;
  uByte command[2], dor, results[2];
  uWord ioportbase;

  controller = devex -> controller;
  ioportbase = controller -> ioportbase;

  dor  = oz_hw486_inb (ioportbase + DOR) & 0xFC;				/* turn on its motor */
  dor |= (DOR_MOTEN0 << devex -> drivesel) | devex -> drivesel | DOR_RESET_ | DOR_DMAGATE;
  oz_hw486_outb (dor, ioportbase + DOR);
  command[0] = 0x07;							/* send recalibrate command to drive */
  command[1] = devex -> drivesel;
  if (!send_command (2, command, controller, 1)) return (0);
  driveidlewait (devex);						/* wait for drive to not be busy */
  command[0] = 0x08;							/* send sense interrupt command */
  if (!send_command (1, command, controller, 0)) return (0);
  if (recv_results (2, results, ioportbase, NULL, 0x08) != OZ_SUCCESS) return (0);
  if (results[0] & 0xC0) {
    oz_knl_printk ("oz_dev_floppy: %s recal error st0=%x, pcn=%x\n", devex -> unitname, results[0], results[1]);
    return (0);
  }
  command[0] = 0x04;							/* send sense drive status command */
  command[1] = devex -> drivesel;
  if (!send_command (2, command, controller, 0)) return (0);
  if (recv_results (1, results, ioportbase, NULL, 0x04) != OZ_SUCCESS) return (0);
  if (!(results[0] & ST3_TRK0)) {
    oz_knl_printk ("oz_dev_floppy: %s not at track 0 after recal (st3=%x)\n", devex -> unitname, results[0]);
    return (0);
  }

  return (1);
}

/************************************************************************/
/*									*/
/*  Wait up to 'DRIVE_RDY_TIME' seconds for drive busy bit to turn off	*/
/*									*/
/*  This routine waits 50mS before checking the bit for the first time 	*/
/*  and it waits 50mS after seeing the bit off before it returns.	*/
/*									*/
/************************************************************************/

static void driveidlewait (Devex *devex)

{
  Controller *controller;
  int i, j;
  OZ_Datebin when;
  uByte msr;

  controller = devex -> controller;
  j = 1;										// haven't seen it idle yet
  for (i = 20 * DRIVE_RDY_TIME; -- i >= 0;) {
    controller -> waitingforint = 0;							// we want to wait for the timeout
    when  = oz_hw_tod_getnow ();							// get current time
    when += OZ_TIMER_RESOLUTION / 20;							// calc when timeout should happen
    oz_knl_timer_insert (controller -> inttimer, when, int_timeout, controller);	// start the timer going
    while (controller -> waitingforint >= 0) {						// wait for 50mS
      oz_knl_event_waitone (controller -> event);
      oz_knl_event_set (controller -> event, 0);
    }
    msr = oz_hw486_inb (controller -> ioportbase + MSR);					// check the drive's busy bit
    if (!(msr & (1 << devex -> drivesel)) && (-- j < 0)) break;				// if not busy twice, we're done
  }
}

/************************************************************************/
/*									*/
/*  Check the 'media changed' status bit and set datarate		*/
/*									*/
/*    Input:								*/
/*									*/
/*	devex = device extension pointer				*/
/*									*/
/*	smplock = softint, lock set					*/
/*									*/
/*    Output:								*/
/*									*/
/*	chkvolvalid = OZ_SUCCESS : disk not changed			*/
/*	          OZ_VOLNOTVALID : disk was changed			*/
/*									*/
/************************************************************************/

static uLong chkvolvalid (Devex *devex)

{
  uByte dir;

  if (devex -> volvalid) {							// maybe it was invalidated by software
    dir = oz_hw486_inb (devex -> controller -> ioportbase + DIR);			// now check to see if hardware invalidated it
    if (dir & DIR_DSKCHG_) {
      oz_knl_printk ("oz_dev_floppy: %s media changed\n", devex -> unitname);	// if so, print a message
      devex -> volvalid = 0;							// ... and software invalidate it, too
    } else {
      oz_hw486_outb (devex -> datarate, devex -> controller -> ioportbase + CCR);	// ok, set the datarate for this drive
    }
  }
  return (devex -> volvalid ? OZ_SUCCESS : OZ_VOLNOTVALID);
}

/************************************************************************/
/*									*/
/*  Restart motor timer for a drive					*/
/*									*/
/*    Input:								*/
/*									*/
/*	devex = pointer to device to start the timer for		*/
/*	smplock = softint						*/
/*									*/
/************************************************************************/

static void motor_timer_start (Devex *devex)

{
  OZ_Datebin now;

  now = oz_hw_tod_getnow ();
  devex -> motoroff = now + (MOTOR_TIMER_SECONDS * OZ_TIMER_RESOLUTION);
  oz_knl_timer_insert (devex -> motor_timer, devex -> motoroff, motor_timer_expired, devex);
}

/************************************************************************/
/*									*/
/*  This routine is called back (at softint level) by the timer when 	*/
/*  the motor timer expires						*/
/*									*/
/************************************************************************/

static void motor_timer_expired (void *devexv, OZ_Timer *timer)

{
  Devex *devex;
  OZ_Datebin now;

  devex = devexv;
  now   = oz_hw_tod_getnow ();
  if (now >= devex -> motoroff) oz_knl_event_set (devex -> controller -> event, 1);
  else oz_knl_timer_insert (timer, devex -> motoroff, motor_timer_expired, devex);
}

/************************************************************************/
/*									*/
/*  Send a command to the floppy disk controller and wait for 		*/
/*  corresponding interrupt (if any)					*/
/*									*/
/*    Input:								*/
/*									*/
/*	size = number of command bytes to send				*/
/*	buff = address of command bytes to send				*/
/*	controller = the controller to send the command to		*/
/*	interrupts = 0 : the command does not produce an interrupt	*/
/*	             1 : wait for the command to interrupt		*/
/*									*/
/*    Output:								*/
/*									*/
/*	send_command = 0: error sending command				*/
/*	               1: success					*/
/*	command sent to controller					*/
/*									*/
/************************************************************************/

static int send_command (int size, uByte *buff, Controller *controller, int interrupts)

{
  int i;
  OZ_Datebin when;
  uByte msr;
  uWord port;

  port = controller -> ioportbase;

  /* Send command to the controller, byte by byte */

  /* While sending the command, RQM should be set (indicating the controller is ready to accept command bytes or send result bytes) */
  /*                            DIO should be clear (indicating the controller is accepting command bytes now) */
  /*                            CB should be clear for the first byte (indicating the controller is ready for the first byte of a command) */
  /*                               then it should be set until we read the last result byte from it */

  for (i = 0; i < size; i ++) {
    msr = wait_for_rqm (port);
    if (!(msr & MSR_RQM)) return (0);
    if ((msr & MSR_DIO) || ((i > 0) && !(msr & MSR_CB))) {
      oz_knl_printk ("oz_dev_floppy: %s premature termination of %2.2X command after %d bytes, msr %X\n", 
                     controller -> ctrlname, buff[0], i, msr);
      return (0);
    }
    if (i == size - 1) controller -> waitingforint = interrupts;
    oz_hw486_outb (buff[i], port + FIFO);
  }

  /* If the command produces an interrupt, wait for the interrupt.  The interrupt routine will clear */
  /* 'waitingforint' only when it sees msr<RQM> set.  The timeout routine sets watingforint = -1.    */

  if (controller -> waitingforint > 0) {
    when  = oz_hw_tod_getnow ();							// get current time
    when += INT_TIMEOUT * OZ_TIMER_RESOLUTION;						// calc when timeout should happen
    oz_knl_timer_insert (controller -> inttimer, when, int_timeout, controller);	// start the timer going
    while (controller -> waitingforint > 0) {						// wait for interrupt or timeout
      oz_knl_event_waitone (controller -> event);
      oz_knl_event_set (controller -> event, 0);
    }
    if (!oz_knl_timer_remove (controller -> inttimer)) {				// remove timer from queue
      while (controller -> waitingforint >= 0) {					// couldn't, wait for timeout
        oz_knl_event_waitone (controller -> event);
        oz_knl_event_set (controller -> event, 0);
      }
    }
  }

  return (1);
}

/* This routine is called at softint level when we have waited too long for an interrupt */

static void int_timeout (void *controllerv, OZ_Timer *timer)

{
  Controller *controller;

  controller = controllerv;
  controller -> waitingforint = -1;		// say we have executed
  oz_knl_event_set (controller -> event, 1);	// wake in case it is still waiting
}

/************************************************************************/
/*									*/
/*  Receive results from the floppy disk controller			*/
/*									*/
/*    Input:								*/
/*									*/
/*	size = number of command bytes to send				*/
/*	buff = address of command bytes to send				*/
/*	port = I/O port base (0x3F0 or 0x370)				*/
/*	devex = device extension data pointer (or NULL if none)		*/
/*									*/
/*    Output:								*/
/*									*/
/*	recv_results = OZ_SUCCESS : success				*/
/*	                     else : error receiving results		*/
/*									*/
/************************************************************************/

static uLong recv_results (int size, uByte *buff, uWord port, Devex *devex, uByte command)

{
  uByte msr;
  int dtc, i;

  dtc = 0;
  for (i = 0; i < size;) {
    msr = wait_for_rqmdio (port);
    if (!(msr & MSR_RQM)) goto volnotvalid;
    if (msr & MSR_NONDMA) {
      if (dtc == 0) oz_knl_printk ("oz_dev_floppy: %s trying to read results but still in data transfer mode on port %x\n", 
	devex -> controller -> ctrlname, port);
      oz_hw486_inb (port + FIFO);
      dtc ++;
      continue;
    }
    if (!(msr & MSR_DIO)) goto premature;
    if ((i < size - 1) && !(msr & MSR_CB)) goto busyclear;
    buff[i++] = oz_hw486_inb (port + FIFO);
  }
  if (dtc != 0) {
    oz_knl_printk ("oz_dev_floppy: %s skipped %d data bytes before results\n", devex -> controller -> ctrlname, dtc);
  }
  return (OZ_SUCCESS);

volnotvalid:
  if (devex != NULL) devex -> volvalid = 0;
  return (OZ_VOLNOTVALID);

premature:
  oz_knl_printk ("oz_dev_floppy: %s premature termination of command %2.2X results after %d of %d bytes, msr %2.2X\n", 
                 devex -> controller -> ctrlname, command, i, size, msr);
  return (OZ_IOFAILED);

busyclear:
  oz_knl_printk ("oz_dev_floppy: %s command %2.2X busy bit did not stay set after %d of %d results bytes, msr %2.2X\n", 
                 devex -> controller -> ctrlname, command, i, size, msr);
  return (OZ_IOFAILED);
}

/************************************************************************/
/*									*/
/*  Wait for the command to be done					*/
/*									*/
/*    Input:								*/
/*									*/
/*	port = I/O port base (0x3F0 or 0x370)				*/
/*									*/
/*    Output:								*/
/*									*/
/*	command done = 0 : timed out					*/
/*	            else : success					*/
/*									*/
/************************************************************************/

static int command_done (uWord port, uByte command)

{
  uLong rc;

  rc = oz_hw_stl_microwait (50000, command_done_check, &port);	/* give it up to 50mS to complete */
  if (!rc) oz_knl_printk ("oz_dev_floppy command_done: %X command %2.2X timed out, msr %2.2X\n", port, command, oz_hw486_inb (port + MSR));
  return (rc);
}

static uLong command_done_check (void *portv)

{
  uByte msr;

  msr = oz_hw486_inb (*(uWord *)portv + MSR);
  return (!(msr & MSR_CB));
}

/************************************************************************/
/*									*/
/*  Wait for Master Status Register's RQM bit to be set			*/
/*									*/
/*    Input:								*/
/*									*/
/*	port = I/O port base number (0x3F0 or 0x370)			*/
/*									*/
/*    Output:								*/
/*									*/
/*	wait_for_rqm = resultant msr contents				*/
/*		if MSR_RQM is set, it succeeded				*/
/*		otherwise, it timed out					*/
/*									*/
/************************************************************************/

typedef struct { uWord port;
                 uByte msr;
               } Rqmprm;

static uByte wait_for_rqm (uWord port)

{
  Rqmprm rqmprm;

  rqmprm.port = port;

  if (!oz_hw_stl_microwait (MSR_RQM_TIMEOUT, check_for_rqm, &rqmprm)) {
    oz_knl_printk ("oz_dev_floppy: timed out waiting for MSR_RQM on port %x (msr=%x)\n", port, rqmprm.msr);
  }

  return (rqmprm.msr);
}

static uLong check_for_rqm (void *rqmprmv)

{
  uByte msr;

  ((Rqmprm *)rqmprmv) -> msr = msr = oz_hw486_inb (((Rqmprm *)rqmprmv) -> port + MSR);
  return (msr & MSR_RQM);
}

static uByte wait_for_rqmdio (uWord port)

{
  Rqmprm rqmprm;

  rqmprm.port = port;

  if (!oz_hw_stl_microwait (MSR_RQM_TIMEOUT, check_for_rqmdio, &rqmprm)) {
    oz_knl_printk ("oz_dev_floppy: timed out waiting for MSR_RQM and _DIO on port %x (msr=%x)\n", port, rqmprm.msr);
  }

  return (rqmprm.msr);
}

static uLong check_for_rqmdio (void *rqmprmv)

{
  uByte msr;

  ((Rqmprm *)rqmprmv) -> msr = msr = oz_hw486_inb (((Rqmprm *)rqmprmv) -> port + MSR);
  return ((msr & (MSR_RQM | MSR_DIO)) == (MSR_RQM | MSR_DIO));
}

/************************************************************************/
/*									*/
/*  Print error status bits						*/
/*									*/
/*    Input:								*/
/*									*/
/*	rw      = "read" or "write"					*/
/*	devex   = device that had error					*/
/*	command = read/write command buffer				*/
/*	results = read/write results buffer				*/
/*	len     = length of attempted transfer				*/
/*									*/
/*    Output:								*/
/*									*/
/*	error message printed on console				*/
/*									*/
/************************************************************************/

static void print_rw_err (const char *rw, Devex *devex, uByte *command, uByte *results, uLong len)

{
  static const char *term[4] = { "normal", "abnormal", "invalid", "polling" };

  oz_knl_printk ("oz_dev_floppy: %s %s error len %u, st0 %x, st1 %x, st2 %x\n", devex -> unitname, rw, len, results[0], results[1], results[2]);
  oz_knl_printk ("oz_dev_floppy: - %s termination%s%s%s%s%s%s%s%s%s%s%s%s\n", 
	term[results[0]>>6], 
	results[0] & 0x10 ? ", recal fail" : "", 
	results[1] & 0x80 ? ", end of cyl" : "", 
	results[1] & 0x20 ? ", data error" : "", 
	results[1] & 0x10 ? ", overrun" : "", 
	results[1] & 0x04 ? ", sector not found" : "", 
	results[1] & 0x02 ? ", write protect" : "", 
	results[1] & 0x01 ? ", missing AM" : "", 
	results[2] & 0x40 ? ", deleted data" : "", 
	results[2] & 0x20 ? ", data CRC error" : "", 
	results[2] & 0x10 ? ", wrong cylinder" : "", 
	results[2] & 0x02 ? ", bad cylinder" : "", 
	results[2] & 0x01 ? ", missing DAM" : "");
  oz_knl_printk ("oz_dev_floppy: - track/drive %x, cylinder %x, track %x, sector %x..%x\n", 
                 command[1], command[2], command[3], command[4], command[6]);
}

/************************************************************************/
/*									*/
/*  Set up a DMA operation						*/
/*									*/
/*    Input:								*/
/*									*/
/*	dmadir = 8 : memory to device (floppy write)			*/
/*	         4 : device to memory (floppy read)			*/
/*	transferlen = transfer length					*/
/*	iopex -> phypages = NULL : force temp buffer			*/
/*	                    else : points to physical page number array	*/
/*	         byteoffs = 0 : must be when using phypages = NULL	*/
/*	                 else : offset in first physical page to start	*/
/*									*/
/*    Output:								*/
/*									*/
/*	dmapage_setup = 0 : transfer set up using dmapage_vadr buffer	*/
/*	             else : direct access to iopex buffer, this many bytes
/*									*/
/************************************************************************/

static uLong dmapage_setup (int dmadir, uLong transferlen, Devex *devex, uLong byteoffs, OZ_Mempage *phypages, OZ_Dbn slbn)

{
  OZ_Mempage npage;
  OZ_Phyaddr phyaddr;
  uByte secpertrk, starttrack, stoptrack;
  uLong direct;

  if (transferlen > dmapage_size) oz_crash ("oz_dev_floppy_486 dmapage_setup: transferlen %u, dmapage_size %u\n", transferlen, dmapage_size);

  /* Make sure byteoffs fits within a physical page */

  phypages += byteoffs >> OZ_HW_L2PAGESIZE;
  byteoffs &= (1 << OZ_HW_L2PAGESIZE) - 1;

  /* See if we can directly access the caller's buffer                                */
  /* - we can do as much as is physically contiguous                                  */
  /* - if we can't do all that was requested, we just do to end of starting track     */
  /*   (so we don't waste a rev of the disk after we got a couple blocks from the     */
  /*   second side, we would have to wait for a rev to get the rest)                  */
  /* - if we can't even do to end of track, use temp buffer                           */
  /* In any case, we can't DMA to phys address > 16M, and we can't cross 64K boundary */

  direct  = 0;									// assume we're beyond 16M limit
  if (phypages != NULL) {							// make sure caller isn't forcing temp buffer
    phyaddr = (phypages[0] << OZ_HW_L2PAGESIZE) + byteoffs;			// get starting physical address
    if (phyaddr < 0x1000000) {							// make sure we at least start within 16M limit
      direct = (1 << OZ_HW_L2PAGESIZE) - byteoffs;				// see how much is left of start page
      while (direct < transferlen) {						// repeat as long as there is more to do
        npage = (direct + byteoffs) >> OZ_HW_L2PAGESIZE;			// - calculate new page index
        if (phypages[npage] != phypages[0] + npage) break;			// - stop if it is not contiguous
        direct += (1 << OZ_HW_L2PAGESIZE);					// - ok, we can do one more page of bytes
      }
      if (direct > transferlen) direct = transferlen;				// don't do more than caller asked for
      if (direct + phyaddr > 0x1000000) direct = 0x1000000 - phyaddr;		// stop at 16M limit
      if (((direct + phyaddr - 1) ^ phyaddr) & -65536) direct = 65536 - (phyaddr & 65535); // don't cross 64K boundary
      if (direct < transferlen) {						// see if we're doing less than caller asked for
        secpertrk  = sectorspertrack[devex->sizecode];
        starttrack = slbn / secpertrk;						// can't do it all, get track starting on
        stoptrack  = (slbn + (direct / DISK_BLOCK_SIZE)) / secpertrk;		// get track stopping on
        if (starttrack == stoptrack) direct = 0;				// if can't do to end of track, use temp buffer
        else direct = (secpertrk - (slbn % secpertrk)) * DISK_BLOCK_SIZE;	// can do to end of track, so just do that much
      }
    }
  }

  if (direct != 0) transferlen = direct;	// direct, this is how much of it we're going to do
  else phyaddr = dmapage_padr;			// not direct, do all requested bytes using temp buffer

  if (transferlen == 0) oz_crash ("oz_dev_floppy dmapage_setup: transferlen 0");

  /* Set up controller to transfer 'transferlen' bytes starting at physical address 'phyaddr' */

  transferlen --;				// controller requires length - 1
  oz_hw486_outb (0x04, DMA_MASK);			// turn off channel 2
  oz_hw486_outb (0, DMA_CBP);			// make sure it is ready for low byte
  oz_hw486_outb (phyaddr, DMA_ADDR2);		// write bits <00:07> of the physical address
  oz_hw486_outb (phyaddr >> 8, DMA_ADDR2);		// write bits <08:15> of the physical address
  oz_hw486_outb (phyaddr >> 16, DMA_PAGE2);	// write bits <16:23> of the physical address
  oz_hw486_outb (transferlen, DMA_COUNT2);		// write bits <00:07> of the byte count - 1
  oz_hw486_outb (transferlen >> 8, DMA_COUNT2);	// write bits <08:15> of the byte count - 1
  oz_hw486_outb (0, DMA_CTRL);			// select defaults for everything in here
  oz_hw486_outb (dmadir + 2, DMA_MODE);		// set to demand transfer mode, address increment, 
						// no auto-init, direction, channel 2
  oz_hw486_outb (0, DMA_ACT);			// activate all four DMA channels

  return (direct);
}

/************************************************************************/
/*									*/
/*  Interrupt routine							*/
/*									*/
/*  If the thread is waiting for an interrupt and the controller is 	*/
/*  ready, wake the kernel thread					*/
/*									*/
/*  This routines runs with the smplock_fd set				*/
/*									*/
/************************************************************************/

static int fd_interrupt (void *dummy, OZ_Mchargs *mchargs)

{
  Controller *controller;

  for (controller = controllers; controller != NULL; controller = controller -> next) {
    if (controller -> waitingforint > 0) {				// see if the thread is waiting for an interrupt
      controller -> waitingforint = 0;					// if so, say it is no longer waiting
      oz_knl_event_set (controller -> event, 1);			// ... then wake it up
    }
  }

  return (0);
}