xref: /src/sys/arch/mac68k/obio/iwm_fd.c

/*	$NetBSD: iwm_fd.c,v 1.60 2021/05/13 08:47:21 hauke 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.60 2021/05/13 08:47:21 hauke 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/dkbad.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: 5x0, 190x */
		if (current_mac_model->machineid == MACH_MACPB500 ||
		    current_mac_model->machineid == MACH_MACPB190 ||
		    current_mac_model->machineid == MACH_MACPB190CS)
			break;
		/* FALLTHROUGH */
	case MACH_CLASSLC:	/* Only: LC II, Classic II */
		if (current_mac_model->machineid != MACH_MACLCII &&
		    current_mac_model->machineid != MACH_MACCLASSICII)
			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: 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:
		IWMBase = 0L;
		matched = 0;
		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, CFARG_EOL);
		}
		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 DIOCSBAD:
		if (TRACE_IOCTL)
			printf(" DIOCSBAD: No bad144-style handling.\n");
		result = EINVAL;
		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");
	}
}