/*      $NetBSD: iwm_fd.c,v 1.63 2026/05/30 10:10:11 thorpej Exp $      */

/*
 * Copyright (c) 1997, 1998 Hauke Fath.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * iwm_fd.c -- Sony (floppy disk) driver for m68k Macintoshes
 *
 * The present implementation supports the GCR format (800K) on
 * non-{DMA,IOP} machines.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: iwm_fd.c,v 1.63 2026/05/30 10:10:11 thorpej Exp $");

#include "locators.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/callout.h>
#include <sys/kernel.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/kmem.h>
#include <sys/device.h>
#include <sys/event.h>

#define FSTYPENAMES
#define DKTYPENAMES
#include <sys/disklabel.h>

#include <sys/disk.h>
#include <sys/buf.h>
#include <sys/bufq.h>
#include <sys/uio.h>
#include <sys/stat.h>
#include <sys/syslog.h>
#include <sys/conf.h>

#include <machine/autoconf.h>
#include <machine/cpu.h>

#include <mac68k/obio/iwmreg.h>
#include <mac68k/obio/iwm_fdvar.h>

/* Autoconfig */
int     iwm_match(device_t, cfdata_t, void *);
void    iwm_attach(device_t, device_t, void *);
int     iwm_print(void *, const char *);
int     fd_match(device_t, cfdata_t, void *);
void    fd_attach(device_t, device_t, void *);
int     fd_print(void *, const char *);

/**
 **     Private functions
 **/

/* Disklabel stuff */
static void fdGetDiskLabel(fd_softc_t *, dev_t);
static void fdPrintDiskLabel(struct disklabel *);

static fdInfo_t *getFDType(short);
static fdInfo_t *fdDeviceToType(fd_softc_t *, dev_t);

static void fdstart(fd_softc_t *);
static void remap_geometry(daddr_t, int, diskPosition_t *);
static void motor_off(void *);
static int seek(fd_softc_t *, int);
static int checkTrack(diskPosition_t *, int);
static int initCylinderCache(fd_softc_t *);
static void invalidateCylinderCache(fd_softc_t *);

static int fdstart_Init(fd_softc_t *);
static int fdstart_Seek(fd_softc_t *);
static int fdstart_Read(fd_softc_t *);
static int fdstart_Write(fd_softc_t *);
static int fdstart_Flush(fd_softc_t *);
static int fdstart_IOFinish(fd_softc_t *);
static int fdstart_IOErr(fd_softc_t *);
static int fdstart_Fault(fd_softc_t *);
static int fdstart_Exit(fd_softc_t *);


/**
 **     Driver debugging
 **/

#ifdef DEBUG
#define IWM_DEBUG
#endif


static void hexDump(u_char *, int);

/*
 * Stuff taken from Egan/Teixeira ch 8: 'if(TRACE_FOO)' debug output 
 * statements don't break indentation, and when DEBUG is not defined, 
 * the compiler code optimizer drops them as dead code.
 */
#ifdef IWM_DEBUG
#define M_TRACE_CONFIG  0x0001
#define M_TRACE_OPEN    0x0002
#define M_TRACE_CLOSE   0x0004
#define M_TRACE_READ    0x0008
#define M_TRACE_WRITE   0x0010
#define M_TRACE_STRAT   (M_TRACE_READ | M_TRACE_WRITE)
#define M_TRACE_IOCTL   0x0020
#define M_TRACE_STEP    0x0040
#define M_TRACE_ALL     0xFFFF

#define TRACE_CONFIG    (iwmDebugging & M_TRACE_CONFIG)
#define TRACE_OPEN      (iwmDebugging & M_TRACE_OPEN)
#define TRACE_CLOSE     (iwmDebugging & M_TRACE_CLOSE)
#define TRACE_READ      (iwmDebugging & M_TRACE_READ)
#define TRACE_WRITE     (iwmDebugging & M_TRACE_WRITE)
#define TRACE_STRAT     (iwmDebugging & M_TRACE_STRAT)
#define TRACE_IOCTL     (iwmDebugging & M_TRACE_IOCTL)
#define TRACE_STEP      (iwmDebugging & M_TRACE_STEP)
#define TRACE_ALL       (iwmDebugging & M_TRACE_ALL)

 /* -1 = all active */
int     iwmDebugging = 0 /* | M_TRACE_OPEN | M_TRACE_STRAT | M_TRACE_IOCTL */ ;

#else
#define TRACE_CONFIG    0
#define TRACE_OPEN      0
#define TRACE_CLOSE     0
#define TRACE_READ      0
#define TRACE_WRITE     0
#define TRACE_STRAT     0
#define TRACE_IOCTL     0
#define TRACE_STEP      0
#define TRACE_ALL       0
#endif

#define DISABLED        0



/**
 ** Module-global Variables
 **/

/* The controller base address */
u_long IWMBase;

/*
 * Table of supported disk types.
 * The table order seems to be pretty standardized across NetBSD ports, but
 * then, they are all MFM... So we roll our own for now.
 */
static fdInfo_t fdTypes[] = {
        {1, 80, 512, 10, 10,  800, 12, 2, IWM_GCR, "400K Sony"},
        {2, 80, 512, 10, 20, 1600, 12, 2, IWM_GCR, "800K Sony"}
};

/* Table of GCR disk zones for one side (see IM II-211, The Disk Driver) */
static diskZone_t diskZones[] = {
        {16, 12,   0, 191},
        {16, 11, 192, 367},
        {16, 10, 368, 527},
        {16,  9, 528, 671},
        {16,  8, 672, 799}
};

/* Drive format codes/indexes */
enum {
        IWM_400K_GCR = 0,
        IWM_800K_GCR = 1,
        IWM_720K_MFM = 2,
        IWM_1440K_MFM = 3
};


/**
 ** Autoconfiguration code
 **/

/*
 * Autoconfig data structures
 *
 * These data structures (see <sys/device.h>) are referenced in
 * compile/$KERNEL/ioconf.c, which is generated by config(8).
 * Their names are formed like {device}_{ca,cd}.
 *
 * {device}_ca  
 * is used for dynamically allocating driver data, probing and
 * attaching a device;
 *
 * {device}_cd
 * references all found devices of a type.
 */

extern struct cfdriver iwm_cd;
extern struct cfdriver fd_cd;

/* IWM floppy disk controller */
CFATTACH_DECL_NEW(iwm, sizeof(iwm_softc_t),
    iwm_match, iwm_attach, NULL, NULL);

/* Attached floppy disk drives */
CFATTACH_DECL_NEW(fd, sizeof(fd_softc_t),
    fd_match, fd_attach, NULL, NULL);

dev_type_open(fdopen);
dev_type_close(fdclose);
dev_type_read(fdread);
dev_type_write(fdwrite);
dev_type_ioctl(fdioctl);
dev_type_strategy(fdstrategy);

const struct bdevsw fd_bdevsw = {
        .d_open = fdopen,
        .d_close = fdclose,
        .d_strategy = fdstrategy,
        .d_ioctl = fdioctl,
        .d_dump = nodump,
        .d_psize = nosize,
        .d_discard = nodiscard,
        .d_flag = D_DISK
};

const struct cdevsw fd_cdevsw = {
        .d_open = fdopen,
        .d_close = fdclose,
        .d_read = fdread,
        .d_write = fdwrite,
        .d_ioctl = fdioctl,
        .d_stop = nostop,
        .d_tty = notty,
        .d_poll = nopoll,
        .d_mmap = nommap,
        .d_kqfilter = nokqfilter,
        .d_discard = nodiscard,
        .d_flag = D_DISK
};

/* disk(9) framework device switch */
struct dkdriver fd_dkDriver = {
        .d_strategy = fdstrategy
};

/***  Configure the IWM controller  ***/

/*
 * iwm_match
 *
 * Is the IWM chip present? Here, *aux is a ptr to struct confargs 
 * (see <mac68k/mac68k/autoconf.h>), which does not hold any information 
 * to match against. After all, that's what the obio concept is 
 * about: Onboard components that are present depending (only) 
 * on machine type.
 *
 * While here, map the machine-dependent physical IO address of IWM
 * to VM address.
 *
 * We do not match, nor return an IWMBase address, for machines whose
 * SWIM does not support the IWM register set used by this driver
 * (SWIM II/III, SWIM behind IOP, AV models' DMA based controllers).
 * Unfortunately, this distinction does not run cleanly along
 * MACH_CLASS* lines, and we will have to look at MACH_MAC{model} tags.
 *
 * See also "What chips are in what Macs?" at
 * <http://bitsavers.org/pdf/apple/mac/mess/Mac_Technical_Notes.html>,
 */
int
iwm_match(device_t parent, cfdata_t match, void *aux)
{
        int matched = 0;
        extern u_long IOBase;           /* from mac68k/machdep.c */
        extern u_long IWMBase;

        IWMBase = 0L;

        switch (current_mac_model->class) {
        case MACH_CLASSPB:      /* Not: Powerbook 5x0, 190x */
                if (current_mac_model->machineid != MACH_MACPB500 &&
                    current_mac_model->machineid != MACH_MACPB190 &&
                    current_mac_model->machineid != MACH_MACPB190CS) {
                        IWMBase = IOBase + 0x16000;
                        matched = 1;
                        break;
                }
                /* FALLTHROUGH */
        case MACH_CLASSLC:      /* Only: LC II, Classic II */
                if (current_mac_model->machineid == MACH_MACLCII ||
                    current_mac_model->machineid == MACH_MACCLASSICII) {
                        IWMBase = IOBase + 0x16000;
                        matched = 1;
                        break;
                }
                /* FALLTHROUGH */
        case MACH_CLASSII:      /* All */
        case MACH_CLASSIIci:    /* All */
        case MACH_CLASSIIsi:    /* All */
        case MACH_CLASSIIvx:    /* All */
        case MACH_CLASSDUO:     /* All */
                IWMBase = IOBase + 0x16000;
                matched = 1;
                break;
        case MACH_CLASSQ:       /* Only: Quadra 700 */
                if (current_mac_model->machineid == MACH_MACQ700) {
                        IWMBase = IOBase + 0x1E000;
                        matched = 1;
                        break;
                }
                /* FALLTHROUGH */
        case MACH_CLASSQ2:      /* None */
        case MACH_CLASSP580:    /* None */
        case MACH_CLASSIIfx:    /* None */
        case MACH_CLASSAV:      /* None */
        default:
                break;
        }

        if (TRACE_CONFIG) {
                if (matched == 0)
                        printf("IWM or original SWIM not found.\n");
                else
                        printf("IWMBase mapped to VM addr 0x%lx.\n",
                            IWMBase);
        }
        return matched;
}


/*
 * iwm_attach
 *
 * The IWM is present, initialize it. Then look up the connected drives
 * and attach them.
 */
void
iwm_attach(device_t parent, device_t self, void *aux)
{
        int iwmErr;
        iwm_softc_t *iwm;
        iwmAttachArgs_t ia;

        printf(": Apple GCR floppy disk controller\n");
        iwm = device_private(self);

        iwmErr = iwmInit();
        if (TRACE_CONFIG)
                printf("initIWM() says %d.\n", iwmErr);

        if (0 == iwmErr) {
                /* Set up the IWM softc */
                iwm->maxRetries = 10;

                /* Look for attached drives */
                for (ia.unit = 0; ia.unit < IWM_MAX_DRIVE; ia.unit++) {
                        iwm->fd[ia.unit] = NULL;
                        ia.driveType = getFDType(ia.unit);
                        if (NULL != ia.driveType)
                                config_found(self, (void *)&ia,
                                    fd_print, CFARGS_NONE);
                }
                if (TRACE_CONFIG)
                        printf("iwm: Initialization completed.\n");
        } else {
                printf("iwm: Initialization failed (%d)\n", iwmErr);
        }
}


/*
 * iwm_print -- print device configuration.
 *
 * If the device is not configured 'controller' it is NULL and 
 * we print a message in the *Attach routine; the return value 
 * of *Print() is ignored.
 */
int
iwm_print(void *aux, const char *controller)
{
        return UNCONF;
}



/***  Configure Sony disk drive(s)  ***/

/*
 * fd_match
 */
int
fd_match(device_t parent, cfdata_t match, void *aux)
{
        int matched, cfUnit;
        struct cfdata *cfp;
        iwmAttachArgs_t *fdParams;

        cfp = match;
        fdParams = aux;
        cfUnit = cfp->cf_loc[IWMCF_DRIVE];
        matched = (cfUnit == fdParams->unit || cfUnit == -1) ? 1 : 0;
        if (TRACE_CONFIG) {
                printf("fdMatch() drive %d ? cfUnit = %d\n",
                    fdParams->unit, cfUnit);
        }
        return matched;
}


/*
 * fd_attach
 *
 * We have checked that the IWM is fine and the drive is present,
 * so we can attach it.
 */
void
fd_attach(device_t parent, device_t self, void *aux)
{
        iwm_softc_t *iwm;
        fd_softc_t *fd;
        iwmAttachArgs_t *ia;
        int driveInfo;

        iwm = device_private(parent);
        fd = device_private(self);
        fd->sc_dev = self;
        ia = aux;

        driveInfo = iwmCheckDrive(ia->unit);

        fd->currentType = ia->driveType;
        fd->unit = ia->unit;
        fd->defaultType = &fdTypes[IWM_800K_GCR];
        fd->stepDirection = 0;

        iwm->fd[ia->unit] = fd;         /* iwm has ptr to this drive */
        iwm->drives++;

        bufq_alloc(&fd->bufQueue, "disksort", BUFQ_SORT_CYLINDER);
        callout_init(&fd->motor_ch, 0);

        printf(" drive %d: ", fd->unit);

        if (IWM_NO_DISK & driveInfo) {
                printf("(drive empty)\n");
        } else
                if (!(IWM_DD_DISK & driveInfo)) {
                        printf("(HD disk -- not supported)\n");
                        iwmDiskEject(fd->unit); /* XXX */
                } else {
                        printf("%s %d cyl, %d head(s)\n",
                            fd->currentType->description,
                            fd->currentType->tracks,
                            fd->currentType->heads);
                }
        if (TRACE_CONFIG) {
                int reg, flags, spl;

                /* List contents of drive status registers */
                spl = spl6();
                for (reg = 0; reg < 0x10; reg++) {
                        flags = iwmQueryDrvFlag(fd->unit, reg);
                        printf("iwm: Drive register 0x%x = 0x%x\n", reg, flags);
                }
                splx(spl);
        }
        disk_init(&fd->diskInfo, device_xname(fd->sc_dev), &fd_dkDriver);
        disk_attach(&fd->diskInfo);
}


/*
 * fdPrint -- print device configuration.
 *
 * If the device is not configured 'controller' refers to a name string
 * we print here.
 * Else it is NULL and we print a message in the *Attach routine; the
 * return value of *Print() is ignored.
 */
int
fd_print(void *aux, const char *controller)
{
        iwmAttachArgs_t *ia;

        ia = aux;
        if (NULL != controller)
                aprint_normal("fd%d at %s", ia->unit, controller);
        return UNCONF;
}

/**
 ** Implementation section of driver interface
 **
 ** The prototypes for these functions are set up automagically
 ** by macros in mac68k/conf.c. Their names are generated from {fd}
 ** and {open,close,strategy,dump,size,read,write}. The driver entry
 ** points are then plugged into bdevsw[] and cdevsw[].
 **/


/*
 * fdopen
 *
 * Open a floppy disk device.
 */
int
fdopen(dev_t dev, int flags, int devType, struct lwp *l)
{
        fd_softc_t *fd;
        fdInfo_t *info;
        int partitionMask;
        int fdType, fdUnit;
        int ierr, err;
        iwm_softc_t *iwm = device_lookup_private(&iwm_cd, 0); /* XXX */
        info = NULL;            /* XXX shut up egcs */
        fd = NULL;              /* XXX shut up gcc3 */

        /*
         * See <device.h> for struct cfdriver, <disklabel.h> for
         * DISKUNIT() and <atari/atari/device.h> for getsoftc().
         */
        fdType = minor(dev) % MAXPARTITIONS;
        fdUnit = minor(dev) / MAXPARTITIONS;
        if (TRACE_OPEN)
                printf("iwm: Open drive %d", fdUnit);

        /* Check if device # is valid */
        err = (iwm->drives < fdUnit) ? ENXIO : 0;
        if (!err) {
                (void)iwmSelectDrive(fdUnit);
                if (TRACE_OPEN)
                        printf(".\n Get softc");

                /* Get fd state */
                fd = iwm->fd[fdUnit];
                err = (NULL == fd) ? ENXIO : 0;
        }
        if (!err) {
                if (fd->state & IWM_FD_IS_OPEN) {
                        /* 
                         * Allow multiple open calls only if for identical
                         * floppy format. 
                         */
                        if (TRACE_OPEN)
                                printf(".\n Drive already opened!\n");
                        err = (fd->partition == fdType) ? 0 : ENXIO;
                } else {
                        if (TRACE_OPEN)
                                printf(".\n Get format info");

                        /* Get format type */
                        info = fdDeviceToType(fd, dev);
                        if (NULL == info) {
                                err = ENXIO;
                                if (TRACE_OPEN)
                                        printf(".\n No such drive.\n");
                        }
                }
        }
        if (!err && !(fd->state & IWM_FD_IS_OPEN)) {
                if (TRACE_OPEN)
                        printf(".\n Set diskInfo flags.\n");

                fd->writeLabel = 0;             /* XXX currently unused */
                fd->partition = fdType;
                fd->currentType = info;
                fd->drvFlags = iwmCheckDrive(fd->unit);

                if (fd->drvFlags & IWM_NO_DISK) {
                        err = EIO;
#ifdef DIAGNOSTIC
                        printf(" Drive %d is empty.\n", fd->unit);
#endif
                } else {
                        if (!(fd->drvFlags & IWM_WRITABLE) && (flags & FWRITE)) {

                                err = EPERM;
#ifdef DIAGNOSTIC
                                printf(" Disk is write protected.\n");
#endif
                        } else {
                                if (!(fd->drvFlags & IWM_DD_DISK)) {
                                        err = ENXIO;
#ifdef DIAGNOSTIC
                                        printf(" HD format not supported.\n");
#endif
                                        (void)iwmDiskEject(fd->unit);
                                } else {
                                        /* We're open now! */
                                        fd->state |= IWM_FD_IS_OPEN;
                                        err = initCylinderCache(fd);
                                }
                        }
                }
        }
        if (!err) {
                /*
                 * Later, we might not want to recalibrate the drive when it
                 * is already open. For now, it doesn't hurt.
                 */
                if (TRACE_OPEN)
                        printf(" Seek track 00 says");

                memset(&fd->pos, 0, sizeof(diskPosition_t));
                ierr = seek(fd, IWM_SEEK_RECAL);
                if (TRACE_OPEN)
                        printf(" %d.\n", ierr);
                err = (0 == ierr) ? 0 : EIO;            
        }
        if (!err) {
                /*
                 * Update disklabel if we are not yet open.
                 * (We shouldn't be: We are synchronous.)
                 */
                if (fd->diskInfo.dk_openmask == 0)
                        fdGetDiskLabel(fd, dev);

                partitionMask = (1 << fdType);

                switch (devType) {
                case S_IFCHR:
                        fd->diskInfo.dk_copenmask |= partitionMask;
                        break;

                case S_IFBLK:
                        fd->diskInfo.dk_bopenmask |= partitionMask;
                        break;
                }
                fd->diskInfo.dk_openmask =
                    fd->diskInfo.dk_copenmask | fd->diskInfo.dk_bopenmask;
        }
        if (TRACE_OPEN)
                printf("iwm: fdopen() says %d.\n", err);
        return err;
}


/*
 * fdclose
 */
int
fdclose(dev_t dev, int flags, int devType, struct lwp *l)
{
        fd_softc_t *fd;
        int partitionMask, fdUnit, fdType;
        iwm_softc_t *iwm = device_lookup_private(&iwm_cd, 0);

        if (TRACE_CLOSE)
                printf("iwm: Closing driver.");
        fdUnit = minor(dev) / MAXPARTITIONS;
        fdType = minor(dev) % MAXPARTITIONS;
        fd = iwm->fd[fdUnit];
        /* release cylinder cache memory */
        if (fd->cbuf != NULL) {
                     kmem_free(fd->cbuf,
                         IWM_MAX_GCR_SECTORS * fd->currentType->sectorSize);
        }

        partitionMask = (1 << fdType);

        /* Set state flag. */
        fd->state &= ~IWM_FD_IS_OPEN;

        switch (devType) {
        case S_IFCHR:
                fd->diskInfo.dk_copenmask &= ~partitionMask;
                break;

        case S_IFBLK:
                fd->diskInfo.dk_bopenmask &= ~partitionMask;
                break;
        }
        fd->diskInfo.dk_openmask =
            fd->diskInfo.dk_copenmask | fd->diskInfo.dk_bopenmask;
        return 0;
}


/*
 * fdioctl
 *
 * We deal with all the disk-specific ioctls in <sys/dkio.h> here even if
 * we do not support them.
 */
int
fdioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
        int result, fdUnit, fdType;
        fd_softc_t *fd;
        iwm_softc_t *iwm = device_lookup_private(&iwm_cd, 0);
        int error;

        if (TRACE_IOCTL)
                printf("iwm: Execute ioctl... ");

        /* Check if device # is valid and get its softc */
        fdUnit = minor(dev) / MAXPARTITIONS;
        fdType = minor(dev) % MAXPARTITIONS;
        if (fdUnit >= iwm->drives) {
                if (TRACE_IOCTL) {
                        printf("iwm: Wanted device no (%d) is >= %d.\n",
                            fdUnit, iwm->drives);
                }
                return ENXIO;
        }
        fd = iwm->fd[fdUnit];
        result = 0;

        error = disk_ioctl(&fd->diskInfo, fdType, cmd, data, flag, l);
        if (error != EPASSTHROUGH)
                return error;

        switch (cmd) {
        case DIOCSDINFO:
                if (TRACE_IOCTL)
                        printf(" DIOCSDINFO: Set in-core disklabel.\n");
                result = ((flag & FWRITE) == 0) ? EBADF : 0;
                if (result == 0)
                        result = setdisklabel(fd->diskInfo.dk_label,
                            (struct disklabel *)data, 0,
                            fd->diskInfo.dk_cpulabel);
                break;

        case DIOCWDINFO:
                if (TRACE_IOCTL)
                        printf(" DIOCWDINFO: Set in-core disklabel "
                            "& update disk.\n");
                result = ((flag & FWRITE) == 0) ? EBADF : 0;

                if (result == 0)
                        result = setdisklabel(fd->diskInfo.dk_label,
                            (struct disklabel *)data, 0,
                            fd->diskInfo.dk_cpulabel);
                if (result == 0)
                        result = writedisklabel(dev, fdstrategy,
                            fd->diskInfo.dk_label,
                            fd->diskInfo.dk_cpulabel);
                break;

        case DIOCRFORMAT:
        case DIOCWFORMAT:
                if (TRACE_IOCTL)
                        printf(" DIOC{R,W}FORMAT: No formatter support (yet?).\n");
                result = EINVAL;
                break;

        case DIOCSSTEP:
                if (TRACE_IOCTL)
                        printf(" DIOCSSTEP: IWM does step handshake.\n");
                result = EINVAL;
                break;

        case DIOCSRETRIES:
                if (TRACE_IOCTL)
                        printf(" DIOCSRETRIES: Set max. # of retries.\n");
                if (*(int *)data < 0)
                        result = EINVAL;
                else {
                        iwm->maxRetries = *(int *)data;
                        result = 0;
                }
                break;

        case DIOCWLABEL:
                if (TRACE_IOCTL)
                        printf(" DIOCWLABEL: Set write access to disklabel.\n");
                result = ((flag & FWRITE) == 0) ? EBADF : 0;

                if (result == 0)
                        fd->writeLabel = *(int *)data;
                break;

        case ODIOCEJECT:
        case DIOCEJECT:
                /* XXX Eject disk only when unlocked */
                if (TRACE_IOCTL)
                        printf(" DIOCEJECT: Eject disk from unit %d.\n",
                            fd->unit);
                result = iwmDiskEject(fd->unit);
                break;

        case DIOCLOCK:
                /* XXX Use lock to prevent ejectimg a mounted disk */
                if (TRACE_IOCTL)
                        printf(" DIOCLOCK: No need to (un)lock Sony drive.\n");
                result = 0;
                break;

        default:
                if (TRACE_IOCTL)
                        printf(" Not a disk related ioctl!\n");
                result = ENOTTY;
                break;
        }
        return result;
}


/*
 * fdread
 */
int
fdread(dev_t dev, struct uio *uio, int flags)
{
        return physio(fdstrategy, NULL, dev, B_READ, minphys, uio);
}


/*
 * fdwrite
 */
int
fdwrite(dev_t dev, struct uio *uio, int flags)
{
        return physio(fdstrategy, NULL, dev, B_WRITE, minphys, uio);
}


/*
 * fdstrategy
 *
 * Entry point for read and write requests. The strategy routine usually
 * queues io requests and kicks off the next transfer if the device is idle;
 * but we get no interrupts from the IWM and have to do synchronous
 * transfers - no queue.
 */
void
fdstrategy(struct buf *bp)
{
        int fdUnit, err, done, spl;
        int sectSize, transferSize;
        diskPosition_t physDiskLoc;
        fd_softc_t *fd;
        iwm_softc_t *iwm = device_lookup_private(&iwm_cd, 0);

        err = 0;
        done = 0;
        sectSize = 0;           /* XXX shut up gcc3 */
        fd = NULL;              /* XXX shut up gcc3 */

        fdUnit = minor(bp->b_dev) / MAXPARTITIONS;
        if (TRACE_STRAT) {
                printf("iwm: fdstrategy()...\n");
                printf("     struct buf is at %p\n", bp);
                printf("     Allocated buffer size (b_bufsize): 0x0%x\n",
                    bp->b_bufsize);
                printf("     Base address of buffer (b_data): %p\n",
                    bp->b_data);
                printf("     Bytes to be transferred (b_bcount): 0x0%x\n",
                    bp->b_bcount);
                printf("     Remaining I/O (b_resid): 0x0%x\n",
                    bp->b_resid);
        }
        /* Check for valid fd unit, controller and io request */

        if (fdUnit >= iwm->drives) {
                if (TRACE_STRAT)
                        printf(" No such unit (%d)\n", fdUnit);
                err = EINVAL;
        }
        if (!err) {
                fd = iwm->fd[fdUnit];
                err = (NULL == fd) ? EINVAL : 0;
        }
        if (!err) {
                sectSize = fd->currentType->sectorSize;
                if (bp->b_blkno < 0
                    || (bp->b_bcount % sectSize) != 0) {
                        if (TRACE_STRAT)
                                printf(" Illegal transfer size: "
                                    "block %lld, %d bytes\n",
                                    (long long) bp->b_blkno, bp->b_bcount);
                        err = EINVAL;
                }
        }
        if (!err) {
                /* Null transfer: Return, nothing to do. */
                if (0 == bp->b_bcount) {
                        if (TRACE_STRAT)
                                printf(" Zero transfer length.\n");
                        done = 1;
                }
        }
        if (!err && !done) {
                /* What to do if we touch the boundaries of the disk? */
                transferSize = (bp->b_bcount + (sectSize - 1)) / sectSize;
                if (bp->b_blkno + transferSize > fd->currentType->secPerDisk) {
                        if (TRACE_STRAT) {
                                printf("iwm: Transfer beyond end of disk!\n" \
                                    " (Starting block %lld, # of blocks %d," \
                                    " last disk block %d).\n",
                                    (long long) bp->b_blkno, transferSize,
                                    fd->currentType->secPerDisk);
                        }
                        /* Return EOF if we are exactly at the end of the
                         * disk, EINVAL if we try to reach past the end; else
                         * truncate the request. */
                        transferSize = fd->currentType->secPerDisk -
                            bp->b_blkno;
                        if (0 == transferSize) {
                                bp->b_resid = bp->b_bcount;
                                done = 1;
                        } else
                                if (0 > transferSize)
                                        err = EINVAL;
                                else
                                        bp->b_bcount = transferSize << DEV_BSHIFT;
                }
        }
        if (!err && !done) {
                /*
                 * Calculate cylinder # for disksort().
                 *
                 * XXX Shouldn't we use the (fake) logical cyl no here?
                 */
                remap_geometry(bp->b_blkno, fd->currentType->heads,
                    &physDiskLoc);
                bp->b_rawblkno = bp->b_blkno;
                bp->b_cylinder = physDiskLoc.track;

                if (TRACE_STRAT) {
                        printf(" This job starts at b_blkno %lld; ",
                            (long long) bp->b_blkno);
                        printf("it gets sorted for cylinder # %d.\n",
                            bp->b_cylinder);
                }
                spl = splbio();
                callout_stop(&fd->motor_ch);
                bufq_put(fd->bufQueue, bp);
                if (fd->sc_active == 0)
                        fdstart(fd);
                splx(spl);
        }
        /* Clean up, if necessary */
        else {
                if (TRACE_STRAT)
                        printf(" fdstrategy() finished early, err = %d.\n",
                            err);
                if (err)
                        bp->b_error = err;
                bp->b_resid = bp->b_bcount;
                biodone(bp);
        }
        /* Comment on results */
        if (TRACE_STRAT) {
                printf("iwm: fdstrategy() done.\n");
                printf("     We have b_resid = %d bytes left, " \
                    "b_error is %d;\n", bp->b_resid, bp->b_error);
                printf("     b_flags are 0x0%x.\n", bp->b_flags);
        }
}



/* ======================================================================== */


/*
 * fdstart
 *
 * we are called from the strategy() routine to perform a data transfer.
 *
 * The disk(9) framework demands we run at splbio(); our caller
 * takes care of that.
 *
 * Wish we had pascalish local functions here...
 */

/* fdstart FSM states */
enum {
        state_Init = 0,
        state_Seek,
        state_Read,
        state_Write,
        state_Flush,
        state_IOFinish,
        state_IOErr,
        state_Fault,
        state_Exit,
        state_Done
};

static void
fdstart(fd_softc_t *fd)
{
        int st;

        static const char *stateDesc[] = {
                "Init",
                "Seek",
                "Read",
                "Write",
                "Flush",
                "IOFinish",
                "IOErr",
                "Fault",
                "Exit",
                "Done"
        };
        int (*state[])(fd_softc_t *) = {
                fdstart_Init,
                fdstart_Seek,
                fdstart_Read,
                fdstart_Write,
                fdstart_Flush,
                fdstart_IOFinish,
                fdstart_IOErr,
                fdstart_Fault,
                fdstart_Exit
        };
        
        st = state_Init;
        do {
                if (TRACE_STRAT)
                        printf(" fdstart state %d [%s] ", 
                            st, stateDesc[st]);

                st = (*state[st])(fd);

                if (TRACE_STRAT)
                        printf(".\n");
        } while (st != state_Done);
}


/*
 * fdstart_Init 
 *
 * Set up things
 */
static int
fdstart_Init(fd_softc_t *fd)
{
        struct buf *bp;
        
        /*
         * Get the first entry from the queue. This is the buf we gave to
         * fdstrategy(); disksort() put it into our softc.
         */
        bp = bufq_peek(fd->bufQueue);
        if (NULL == bp) {
                if (TRACE_STRAT)
                        printf("Queue empty: Nothing to do");
                return state_Done;
        }
        fd->ioDirection = bp->b_flags & B_READ;

        disk_busy(&fd->diskInfo);
        if (!(fd->state & IWM_FD_MOTOR_ON)) {
                iwmMotor(fd->unit, 1);
                fd->state |= IWM_FD_MOTOR_ON;
        }
        fd->current_buffer = bp->b_data;

        /* XXX - assumes blocks of 512 bytes */
        fd->startBlk = bp->b_blkno;

        fd->iwmErr = 0;
        fd->ioRetries = 0;              /* XXX */
        fd->seekRetries = 0;
        fd->bytesDone = 0;
        fd->bytesLeft = bp->b_bcount;
        return state_Seek;
}


/*
 * fdstart_Seek
 */
static int
fdstart_Seek(fd_softc_t *fd)
{
        int state;

        /* Calculate the side/track/sector our block is at. */
        if (TRACE_STRAT)
                printf(" Remap block %lld ", (long long) fd->startBlk);
        remap_geometry(fd->startBlk,
            fd->currentType->heads, &fd->pos);
        if (TRACE_STRAT)
                printf("to c%d_h%d_s%d ", fd->pos.track,
                    fd->pos.side, fd->pos.sector);

        if (fd->cachedSide != fd->pos.side) {
                if (TRACE_STRAT)
                        printf(" (invalidate cache) ");
                invalidateCylinderCache(fd);
                fd->cachedSide = fd->pos.side;
        }

        /*
         * If necessary, seek to wanted track. Note that
         * seek() performs any necessary retries.
         */
        if (fd->pos.track != fd->pos.oldTrack &&
            0 != (fd->iwmErr = seek(fd, IWM_SEEK_VANILLA))) {
                state = state_Fault;
        } else {
                state = (fd->ioDirection == IWM_WRITE)
                    ? state_Write : state_Read;
        }
        return state;
}


/*
 * fdstart_Read
 *
 * Transfer a sector from disk. Get it from the track cache, if available;
 * otherwise, while we are at it, store in the cache all the sectors we find 
 * on the way.
 * 
 * Track buffering reads:
 * o  Look if the sector is already cached.
 * o  Else, read sectors into track cache until we meet the header of 
 *    the sector we want.
 * o  Read that sector directly to fs buffer and return.
 */
static int
fdstart_Read(fd_softc_t *fd)
{
        int i;
        diskPosition_t *pos;
        sectorHdr_t *shdr;
        iwm_softc_t *iwm = device_lookup_private(&iwm_cd, 0); /* XXX */
        
        /* Initialize retry counters */
        fd->seekRetries = 0;
        fd->sectRetries = 0;
        pos = &fd->pos;
        shdr = &fd->sHdr;

        if (TRACE_STRAT)
                printf("<%s c%d_h%d_s%d> ", 
                    fd->ioDirection ? "Read" : "Write",
                    pos->track, pos->side, pos->sector);

        /* Sector already cached? */
        i = pos->sector;
        if (fd->r_slots[i].valid) {
                if (TRACE_STRAT)
                        printf("(cached)"); 
                memcpy(fd->current_buffer, fd->r_slots[i].secbuf, 
                    fd->currentType->sectorSize);
                return state_IOFinish;
        }

        /* Get sector from disk */
        shdr->side = pos->side;
        shdr->sector = pos->sector;
        shdr->track = pos->track;

        (void)iwmSelectSide(pos->side);
        fd->iwmErr = iwmReadSector(&fd->sHdr, fd->r_slots,
            fd->current_buffer);

        /* Check possible error conditions */
        if (TRACE_STRAT)
                printf("c%d_h%d_s%d_err(%d)_sr%d ",
                    shdr->track, shdr->side >> 3,
                    shdr->sector, fd->iwmErr, fd->sectRetries);

        /* IWM IO error? */
        if (fd->iwmErr != 0)
                return state_IOErr;

        /* Bad seek? Retry */
        if (shdr->track != pos->track) {
                if (TRACE_STRAT) {
                        printf("Wanted track %d, got %d, %d seek retries.\n",
                            pos->track, shdr->track, fd->seekRetries);
                }
                if (iwm->maxRetries > fd->seekRetries++) {
                        fd->iwmErr = seek(fd, IWM_SEEK_RECAL);
                        if (TRACE_STRAT) {
                                printf("[%d]", fd->seekRetries);
                                (void)checkTrack(&fd->pos, 1);
                        }
                } else
                        fd->iwmErr = seekErr;
                return (0 == fd->iwmErr) ? state_Read : state_Fault;
        }

        /* Sector not found? */
        if (shdr->sector != pos->sector) {
                if (TRACE_STRAT)
                        printf("c%d_h%d_s%d sect not found, %d retries ", 
                            shdr->track, shdr->side >> 3, 
                            shdr->sector, fd->sectRetries);
                fd->iwmErr = noAdrMkErr;
                return state_Fault;
        }

        /* Success */
        return state_IOFinish;
}


/*
 * fdstart_Write
 *
 * Insert a sector into a write buffer slot and mark the slot dirty.
 */
static int
fdstart_Write(fd_softc_t *fd)
{
        int i;
        
        /* XXX let's see... */
        fd->sHdr.side = fd->pos.side;
        fd->sHdr.sector = fd->pos.sector;
        fd->sHdr.track = fd->pos.track;

        i = fd->pos.sector;
        fd->w_slots[i].secbuf = fd->current_buffer;
        fd->w_slots[i].valid = 1;       /* "valid" is a dirty buffer here */
        
        if (TRACE_STRAT)
                printf("<%s c%d_h%d_s%d> (cached) ", 
                    fd->ioDirection ? "Read" : "Write",
                    fd->pos.track, fd->pos.side, fd->pos.sector);
        return state_IOFinish;
}



/*
 * fdstart_Flush
 * 
 * Flush dirty buffers in the track cache to disk.
 */
static int
fdstart_Flush(fd_softc_t *fd)
{
        int state;
        int i, dcnt;
        diskPosition_t *pos;
        sectorHdr_t *shdr;
        iwm_softc_t *iwm = device_lookup_private(&iwm_cd, 0); /* XXX */

        dcnt = 0;
        pos = &fd->pos;
        shdr = &fd->sHdr;

        if (TRACE_STRAT) {
                for (i=0; i < IWM_MAX_GCR_SECTORS; i++)
                        if (fd->w_slots[i].valid) {
                                printf("|%d", i);
                                dcnt++;
                        }
                printf("|\n");
                
                printf(" <%s c%d_h%d_#s%d>\n", 
                    fd->ioDirection ? "Read" : "Write",
                    pos->track, pos->side, dcnt);
        }       
        (void)iwmSelectSide(pos->side);
        fd->iwmErr = iwmWriteSector(&fd->sHdr, fd->w_slots);

        switch (fd->iwmErr) {
        case noErr:             /* Success */
#ifdef DIAGNOSTIC
                /* XXX Panic if buffer not clean? */
                for (i=0; i<IWM_MAX_GCR_SECTORS; i++)
                        if (0 != fd->w_slots[i].valid)
                                printf("Oops! <c%d_h%d_s%d> not flushed.\n",
                                    fd->pos.track, fd->pos.side, 
                                    fd->pos.sector);
#endif
                if (TRACE_STRAT) 
                        printf("(Cache flushed, re-initialize) ");
                for (i=0; i < IWM_MAX_GCR_SECTORS; i++) {
                        fd->w_slots[i].valid = 0;
                        fd->w_slots[i].secbuf = NULL;
                }
                fd->seekRetries = 0;
                state = state_Exit;
                break;
                
        case seekErr:           /* Bad seek? Retry */
                if (TRACE_STRAT) {
                        printf("Wanted track %d, got %d, %d seek retries.\n",
                            pos->track, shdr->track, fd->seekRetries);
                }
                if (iwm->maxRetries > fd->seekRetries++) {
                        fd->iwmErr = seek(fd, IWM_SEEK_RECAL);
                        if (TRACE_STRAT) {
                                printf("[%d]", fd->seekRetries);
                        }
                }
                state = (0 == fd->iwmErr) ? state_Exit : state_Fault;
                break;
                
        default:                /* General IWM IO error? */
                state = state_IOErr;
        }
        return state;
}


/*
 * fdstart_IOFinish 
 *
 * Prepare for next block, if any is available
 */
static int
fdstart_IOFinish(fd_softc_t *fd)
{
        int state;

        if (DISABLED && TRACE_STRAT)
                printf("%s c%d_h%d_s%d ok ", 
                    fd->ioDirection ? "Read" : "Write", 
                    fd->sHdr.track, fd->sHdr.side >> 3, fd->sHdr.sector);

        fd->bytesDone += fd->currentType->sectorSize;
        fd->bytesLeft -= fd->currentType->sectorSize;
        fd->current_buffer += fd->currentType->sectorSize;
        /*
         * Instead of recalculating the chs mapping for
         * each and every sector, check for
         * 'current sector# <= max sector#' and recalculate
         * after overflow.
         */
        fd->startBlk++;
        if (fd->bytesLeft > 0) {
                if (++fd->pos.sector < fd->pos.maxSect) {
                        if (TRACE_STRAT)
                                printf("continue");
                        state = (fd->ioDirection == IWM_WRITE)
                            ? state_Write : state_Read;
                }
                else {
                        /* 
                         * Invalidate read cache when changing track;
                         * flush write cache to disk.
                         */
                        if (fd->ioDirection == IWM_WRITE) {
                                if (TRACE_STRAT)
                                        printf("flush ");
                                state = (state_Exit == fdstart_Flush(fd))
                                    ? state_Seek : state_IOErr;
                        }
                        else {
                                if (TRACE_STRAT)
                                        printf("step ");
                                invalidateCylinderCache(fd);
                                state = state_Seek;
                        }
                }
        } else {
                state = (fd->ioDirection == IWM_WRITE)
                    ? state_Flush : state_Exit;
        }
        return state;
}       


/*
 * fdstart_IOErr
 *
 * Bad IO, repeat
 */
static int
fdstart_IOErr(fd_softc_t *fd)
{
        int state;
        iwm_softc_t *iwm = device_lookup_private(&iwm_cd, 0); /* XXX */
        
#ifdef DIAGNOSTIC
        printf("iwm%sSector() err = %d, %d retries, on c%d_h%d_s%d.\n",
            fd->ioDirection ? "Read" : "Write", 
            fd->iwmErr, fd->ioRetries, fd->pos.track,
            fd->pos.side, fd->pos.sector);
#endif
        /* XXX Do statistics */
        if (fd->ioRetries++ < iwm->maxRetries)
                state = (fd->ioDirection == IWM_WRITE)
                    ? state_Flush : state_Read;
        else 
                state = state_Fault;
        return state;
}


/*
 * fdstart_Fault
 *
 * A non-recoverable error
 */
static int
fdstart_Fault(fd_softc_t *fd)
{
#ifdef DIAGNOSTIC
        printf("Seek retries %d, IO retries %d, sect retries %d :\n" \
            "\t\t only found c%d_h%d_s%d \n",
            fd->seekRetries, fd->ioRetries, fd->sectRetries, 
            fd->sHdr.track, fd->sHdr.side >> 3, fd->sHdr.sector);
        printf("A non-recoverable error: %d ", fd->iwmErr);
#else
        /* ARGSUSED */
#endif
        return state_Exit;
}


/*
 * fdstart_Exit
 *
 * We are done, for good or bad
 */
static int
fdstart_Exit(fd_softc_t *fd)
{
        struct buf *bp;
#ifdef DIAGNOSTIC
        int i;
#endif
        
        invalidateCylinderCache(fd);

#ifdef DIAGNOSTIC
        /* XXX Panic if buffer not clean? */
        for (i=0; i<IWM_MAX_GCR_SECTORS; i++)
                if (0 != fd->w_slots[i].valid)
                        printf("Oops! <c%d_h%d_s%d> not flushed.\n",
                            fd->pos.track, fd->pos.side, fd->pos.sector);
#endif

        bp = bufq_get(fd->bufQueue);

        bp->b_resid = fd->bytesLeft;
        bp->b_error = (0 == fd->iwmErr) ? 0 : EIO;

        if (TRACE_STRAT) {
                printf(" fdstart() finished job; fd->iwmErr = %d, b_error = %d",
                    fd->iwmErr, bp->b_error);
                if (DISABLED)
                        hexDump(bp->b_data, bp->b_bcount);
        }
        if (DISABLED && TRACE_STRAT)
                printf(" Next buf (bufQueue first) at %p\n",
                    bufq_peek(fd->bufQueue));
        disk_unbusy(&fd->diskInfo, bp->b_bcount - bp->b_resid,
            (bp->b_flags & B_READ));
        biodone(bp);
        /* 
         * Stop motor after 10s
         * 
         * XXX Unloading the module while the timeout is still
         *     running WILL crash the machine. 
         */
        callout_reset(&fd->motor_ch, 10 * hz, motor_off, fd);

        return state_Done;
}


/*
 * remap_geometry
 *
 * Remap the rigid UN*X view of a disk's cylinder/sector geometry
 * to our zone recorded real Sony drive by splitting the disk
 * into zones.
 *
 * Loop {
 *      Look if logical block number is in current zone
 *      NO:     Add # of tracks for current zone to track counter
 *              Process next zone
 *
 *      YES:    Subtract (number of first sector of current zone times heads)
 *              from logical block number, then break up the difference
 *              in tracks/side/sectors (spt is constant within a zone).
 *              Done
 * }
 */
static void
remap_geometry(daddr_t block, int heads, diskPosition_t *loc)
{
        int zone, spt;
        extern diskZone_t diskZones[];

        loc->oldTrack = loc->track;
        loc->track = 0;
        spt = 0;

        for (zone = 0; zone < IWM_GCR_DISK_ZONES; zone++) {
                if (block >= heads * (diskZones[zone].lastBlock + 1)) {
                        /* Process full zones */
                        loc->track += diskZones[zone].tracks;
                } else {
                        /* Process partial zone */
                        spt = diskZones[zone].sectPerTrack;
                        block -= heads * diskZones[zone].firstBlock;
                        loc->track += block / (spt * heads);
                        loc->sector = (block % spt);
                        loc->side = (block % (spt * heads)) / spt;
                        break;
                }
        }
        loc->maxSect = spt;
}


/*
 * motor_off
 *
 * Callback for timeout()
 */
static void
motor_off(void *param)
{
        int spl;
        fd_softc_t *fd;

        fd = param;
        if (TRACE_STRAT)
                printf("iwm: Switching motor OFF (timeout).\n");
        spl = spl6();
        (void)iwmMotor(fd->unit, 0);
        fd->state &= ~IWM_FD_MOTOR_ON;
        splx(spl);
}


/*
 * fdGetDiskLabel
 *
 * Set up disk label with parameters from current disk type.
 * Then call the generic disklabel read routine which tries to
 * read a label from disk and insert it. If it doesn't exist use
 * our defaults.
 */
static void
fdGetDiskLabel(fd_softc_t *fd, dev_t dev)
{
        const char *msg;
        int fdType;
        struct disklabel *lp;
        struct cpu_disklabel *clp;

        if (TRACE_IOCTL)
                printf("iwm: fdGetDiskLabel() for disk %" PRIu64 ".\n",
                    (dev_t) (minor(dev) / MAXPARTITIONS));
        fdType = minor(dev) % MAXPARTITIONS;
        lp = fd->diskInfo.dk_label;
        clp = fd->diskInfo.dk_cpulabel;
        memset(lp, 0, sizeof(struct disklabel));
        memset(clp, 0, sizeof(struct cpu_disklabel));
        /*
         * How to describe a drive with a variable # of sectors per
         * track (8..12) and variable rpm (300..550)? Apple came up
         * with ZBR in 1983! Un*x drive management sucks.
         */
        lp->d_type = DKTYPE_FLOPPY;
        lp->d_rpm = 300;
        lp->d_secsize = fd->currentType->sectorSize;
        lp->d_ntracks = fd->currentType->heads;
        lp->d_ncylinders = fd->currentType->tracks;
        lp->d_nsectors = fd->currentType->secPerTrack;
        lp->d_secpercyl = fd->currentType->secPerCyl;
        lp->d_secperunit = fd->currentType->secPerDisk;
        lp->d_interleave = fd->currentType->interleave;
        lp->d_trkseek = fd->currentType->stepRate;

        strcpy(lp->d_typename, dktypenames[DKTYPE_FLOPPY]);
        strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));

        lp->d_npartitions = fdType + 1;
        lp->d_partitions[fdType].p_offset = 0;
        lp->d_partitions[fdType].p_size = lp->d_secperunit;
        lp->d_partitions[fdType].p_fstype = FS_BSDFFS;
        lp->d_partitions[fdType].p_fsize = 512;
        lp->d_partitions[fdType].p_frag = 8;

        lp->d_magic = DISKMAGIC;
        lp->d_magic2 = DISKMAGIC;
        lp->d_checksum = dkcksum(lp);
        /*
         * Call the generic disklabel extraction routine.  If we don't
         * find a label on disk, keep our faked one.
         */
        if (TRACE_OPEN)
                printf(" now calling readdisklabel()...\n");

        msg = readdisklabel(dev, fdstrategy, lp, clp);
        if (msg == NULL) {
                strncpy(lp->d_packname, "default label",
                    sizeof(lp->d_packname));    /* XXX - ?? */
        }
#ifdef IWM_DEBUG
        else
                printf("iwm: %s.\n", msg);
#endif
        if (TRACE_OPEN)
                fdPrintDiskLabel(lp);
}



/*
 * initCylinderCache
 *
 * Allocate cylinder cache and set up pointers to sectors.
 */
static int
initCylinderCache(fd_softc_t *fd)
{
        int i;
        int err;
        int secsize;
        
        err = 0;
        secsize = fd->currentType->sectorSize;
        fd->cachedSide = 0;
        
        fd->cbuf = kmem_alloc(IWM_MAX_GCR_SECTORS * secsize, KM_SLEEP);
        if (NULL == fd->cbuf) 
                err = ENOMEM;
        else
                for (i=0; i < IWM_MAX_GCR_SECTORS; i++) {
                        fd->w_slots[i].valid = 0;
                        fd->w_slots[i].secbuf = NULL;
                        
                        fd->r_slots[i].valid = 0;
                        fd->r_slots[i].secbuf = fd->cbuf + i * secsize;
                }
        return err;
}


/*
 * invalidateCylinderCache
 *
 * Switching cylinders (tracks?) invalidates the read cache.
 */
static void
invalidateCylinderCache(fd_softc_t *fd)
{
        int i;
        
        fd->cachedSide = 0;
        for (i=0; i < IWM_MAX_GCR_SECTORS; i++) {
                fd->r_slots[i].valid = 0;
        }
}


/*
 * getFDType
 *
 * return pointer to disk format description
 */
static fdInfo_t *
getFDType(short unit)
{
        int driveFlags;
        fdInfo_t *thisType;
        extern fdInfo_t fdTypes[];

        driveFlags = iwmCheckDrive(unit);
/*
 * Drive flags are: Bit  0 - 1 = Drive is double sided
 *                       1 - 1 = No disk inserted
 *                       2 - 1 = Motor is off
 *                       3 - 1 = Disk is writable
 *                       4 - 1 = Disk is DD (800/720K)
 *                      31 - 1 = No drive / invalid drive #
 */
        if (TRACE_CONFIG) {
                printf("iwm: Drive %d says 0x0%x (%d)\n",
                    unit, driveFlags, driveFlags);
        }
        if (driveFlags < 0)
                thisType = NULL;/* no such drive         */
        else
                if (driveFlags & 0x01)
                        thisType = &fdTypes[1]; /* double sided          */
                else
                        thisType = &fdTypes[0]; /* single sided          */

        return thisType;
}


/*
 * fdDeviceToType
 *
 * maps the minor device number (elsewhere: partition type) to
 * a corresponding disk format.
 * This is currently:
 *      fdXa    default (800K GCR)
 *      fdXb    400K GCR
 *      fdXc    800K GCR
 */
static fdInfo_t *
fdDeviceToType(fd_softc_t *fd, dev_t dev)
{
        int type;
        fdInfo_t *thisInfo;
        /* XXX This broke with egcs 1.0.2 */
        /* extern fdInfo_t      fdTypes[]; */

        type = minor(dev) % MAXPARTITIONS;      /* 1,2,... */
        if (type > sizeof(fdTypes) / sizeof(fdTypes[0]))
                thisInfo = NULL;
        else
                thisInfo = (type == 0) ? fd->defaultType : &fdTypes[type - 1];
        return thisInfo;
}


/*
 * seek
 *
 * Step to given track; optionally restore to track zero before
 * and/or verify correct track.
 * Note that any necessary retries are done here.
 * We keep the current position on disk in a 'struct diskPosition'.
 */
static int
seek(fd_softc_t *fd, int style)
{
        int state, done;
        int err, ierr;
        int steps;

        diskPosition_t *loc;
        sectorHdr_t hdr;
        char action[32];
        iwm_softc_t *iwm = device_lookup_private(&iwm_cd, 0); /* XXX */

        const char *stateDesc[] = {
                "Init",
                "Seek",
                "Recalibrate",
                "Verify",
                "Exit"
        };
        enum {
                seek_state_Init = 0,
                seek_state_Seek,
                seek_state_Recalibrate,
                seek_state_Verify,
                seek_state_Exit
        };
        /* XXX egcs */
        done = err = ierr = 0;
        fd->seekRetries = 0;
        fd->verifyRetries = 0;  

        loc = &fd->pos;

        state = seek_state_Init;
        do {
                if (TRACE_STEP)
                        printf(" seek state %d [%s].\n",
                            state, stateDesc[state]);
                switch (state) {

                case seek_state_Init:
                        if (TRACE_STEP)
                                printf("Current track is %d, new track %d.\n",
                                    loc->oldTrack, loc->track);
                        memset(&hdr, 0, sizeof(hdr));
                        err = ierr = 0;
                        fd->seekRetries = 0;
                        fd->verifyRetries = 0;
                        state = (style == IWM_SEEK_RECAL)
                            ? seek_state_Recalibrate : seek_state_Seek;
                        done = 0;
                        break;

                case seek_state_Recalibrate:
                        ierr = iwmTrack00();
                        if (ierr == 0) {
                                loc->oldTrack = 0;
                                state = seek_state_Seek;
                        } else {
                                strncpy(action, "Recalibrate (track 0)",
                                    sizeof(action));
                                state = seek_state_Exit;
                        }
                        break;

                case seek_state_Seek:
                        ierr = 0;
                        steps = loc->track - loc->oldTrack;

                        if (steps != 0)
                                ierr = iwmSeek(steps);
                        if (ierr == 0) {
                                /* No error or nothing to do */
                                state = (style == IWM_SEEK_VERIFY)
                                    ? seek_state_Verify : seek_state_Exit;
                        } else {
                                if (fd->seekRetries++ < iwm->maxRetries)
                                        state = seek_state_Recalibrate;
                                else {
                                        strncpy(action, "Seek retries",
                                            sizeof(action));
                                        state = seek_state_Exit;
                                }
                        }
                        break;

                case seek_state_Verify:
                        ierr = checkTrack(loc, TRACE_STEP);
                        if (ierr == 0 && loc->track == hdr.track)
                                state = seek_state_Exit;
                        else {
                                if (fd->verifyRetries++ < iwm->maxRetries)
                                        state = seek_state_Recalibrate;
                                else {
                                        strncpy(action, "Verify retries",
                                            sizeof(action));
                                        state = seek_state_Exit;
                                }
                        }
                        break;

                case seek_state_Exit:
                        if (ierr == 0) {
                                loc->oldTrack = loc->track;
                                err = 0;
                                /* Give the head some time to settle down */
                                delay(3000);
                        } else {
#ifdef DIAGNOSTIC
                                printf(" seek() action \"%s\", err = %d.\n",
                                    action, ierr);
#endif
                                err = EIO;
                        }
                        done = 1;
                        break;
                }
        } while (!done);
        return err;
}


/*
 * checkTrack
 *
 * After positioning, get a sector header for validation
 */
static int
checkTrack(diskPosition_t *loc, int debugFlag)
{
        int spl;
        int iwmErr;
        sectorHdr_t hdr;

        spl = spl6();
        iwmSelectSide(loc->side);
        iwmErr = iwmReadSectHdr(&hdr);
        splx(spl);
        if (debugFlag) {
                printf("Seeked for %d, got at %d, Hdr read err %d.\n",
                    loc->track, hdr.track, iwmErr);
        }
        return iwmErr;
}


/* Debugging stuff */

static void
hexDump(u_char *buf, int len)
{
        int i, j;
        u_char ch;

        printf("\nDump %d from %p:\n", len, buf);
        i = j = 0;
        if (NULL != buf) do {
                printf("%04x: ", i);
                for (j = 0; j < 8; j++)
                        printf("%02x ", buf[i + j]);
                printf(" ");
                for (j = 8; j < 16; j++)
                        printf("%02x ", buf[i + j]);
                printf(" ");
                for (j = 0; j < 16; j++) {
                        ch = buf[i + j];
                        if (ch > 31 && ch < 127)
                                printf("%c", ch);
                        else
                                printf(".");
                }
                printf("\n");
                i += 16;
        } while (len > i);
}


static void
fdPrintDiskLabel(struct disklabel *lp)
{
        int i;

        printf("iwm: Disklabel entries of current floppy.\n");
        printf("\t d_type:\t%d (%s)\n", lp->d_type,
            dktypenames[lp->d_type]);
        printf("\t d_typename:\t%s\n", lp->d_typename);
        printf("\t d_packname:\t%s\n", lp->d_packname);

        printf("\t d_secsize:\t%d\n", lp->d_secsize);
        printf("\t d_nsectors:\t%d\n", lp->d_nsectors);
        printf("\t d_ntracks:\t%d\n", lp->d_ntracks);
        printf("\t d_ncylinders:\t%d\n", lp->d_ncylinders);
        printf("\t d_secpercyl:\t%d\n", lp->d_secpercyl);
        printf("\t d_secperunit:\t%d\n", lp->d_secperunit);

        printf("\t d_rpm: \t%d\n", lp->d_rpm);
        printf("\t d_interleave:\t%d\n", lp->d_interleave);
        printf("\t d_trkseek:\t%d [ms]\n", lp->d_trkseek);

        printf(" d_npartitions:\t%d\n", lp->d_npartitions);
        for (i = 0; i < lp->d_npartitions; i++) {
                printf("\t d_partitions[%d].p_offset:\t%d\n", i,
                    lp->d_partitions[i].p_offset);
                printf("\t d_partitions[%d].p_size:\t%d\n", i,
                    lp->d_partitions[i].p_size);
                printf("\t d_partitions[%d].p_fstype:\t%d (%s)\n", i,
                    lp->d_partitions[i].p_fstype,
                    fstypenames[lp->d_partitions[i].p_fstype]);
                printf("\t d_partitions[%d].p_frag:\t%d\n", i,
                    lp->d_partitions[i].p_frag);
                printf("\n");
        }
}