xref: /titanic_50/usr/src/uts/common/io/fd.c (revision 3d729aecc03ea6ebb9bd5d56b8dccd24f57daa41)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


/*
 * Floppy Disk driver
 */

/*
 * Set CMOS feature:
 *	CMOS_CONF_MEM:	CMOS memory contains configuration info
 */
#define	CMOS_CONF_MEM

#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/file.h>
#include <sys/open.h>
#include <sys/ioctl.h>
#include <sys/uio.h>
#include <sys/conf.h>
#include <sys/stat.h>
#include <sys/autoconf.h>
#include <sys/vtoc.h>
#include <sys/dkio.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/kstat.h>
#include <sys/kmem.h>
#include <sys/ddidmareq.h>
#include <sys/fdio.h>
#include <sys/fdc.h>
#include <sys/fd_debug.h>
#include <sys/fdmedia.h>
#include <sys/debug.h>
#include <sys/modctl.h>

/*
 * Local Function Prototypes
 */
static int fd_unit_is_open(struct fdisk *);
static int fdgetlabel(struct fcu_obj *, int);
static void fdstart(struct fcu_obj *);
static int fd_build_label_vtoc(struct fcu_obj *, struct fdisk *,
    struct vtoc *, struct dk_label *);
static void fd_build_user_vtoc(struct fcu_obj *, struct fdisk *,
    struct vtoc *);
static int fd_rawioctl(struct fcu_obj *, int, caddr_t, int);
static void fd_media_watch(void *);

static int fd_open(dev_t *, int, int, cred_t *);
static int fd_close(dev_t, int, int, cred_t *);
static int fd_strategy(struct buf *);
static int fd_read(dev_t, struct uio *, cred_t *);
static int fd_write(dev_t, struct uio *, cred_t *);
static int fd_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);
static int fd_prop_op(dev_t, dev_info_t *, ddi_prop_op_t, int, char *,
    caddr_t, int *);
static int fd_check_media(dev_t dev, enum dkio_state state);
static int fd_get_media_info(struct fcu_obj *fjp, caddr_t buf, int flag);

static struct cb_ops fd_cb_ops = {
	fd_open,		/* open */
	fd_close,		/* close */
	fd_strategy,		/* strategy */
	nodev,			/* print */
	nodev,			/* dump */
	fd_read,		/* read */
	fd_write,		/* write */
	fd_ioctl,		/* ioctl */
	nodev,			/* devmap */
	nodev,			/* mmap */
	nodev,			/* segmap */
	nochpoll,		/* poll */
	fd_prop_op,		/* cb_prop_op */
	0,			/* streamtab  */
	D_NEW | D_MP		/* Driver compatibility flag */
};

static int fd_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int fd_probe(dev_info_t *);
static int fd_attach(dev_info_t *, ddi_attach_cmd_t);
static int fd_detach(dev_info_t *, ddi_detach_cmd_t);

static struct dev_ops fd_ops = {
	DEVO_REV,		/* devo_rev, */
	0,			/* refcnt  */
	fd_getinfo,		/* getinfo */
	nulldev,		/* identify */
	fd_probe,		/* probe */
	fd_attach,		/* attach */
	fd_detach,		/* detach */
	nodev,			/* reset */
	&fd_cb_ops,		/* driver operations */
	(struct bus_ops *)0,	/* bus operations */
	NULL,			/* power */
	ddi_quiesce_not_supported,	/* devo_quiesce */
};


/*
 * static data
 */
static void *fd_state_head;		/* opaque handle top of state structs */
static int fd_check_media_time = 5000000;	/* 5 second state check */

/*
 * error handling
 *
 * for debugging,
 *		set fderrlevel to 1
 *		set fderrmask  to 224  or 644
 */
#ifdef DEBUG
static uint_t fderrmask = FDEM_ALL;
#endif
static int fderrlevel = 5;

#define	KIOSP	KSTAT_IO_PTR(fdp->d_iostat)

static struct driver_minor_data {
	char	*name;
	int	minor;
	int	type;
} fd_minor [] = {
	{ "a", 0, S_IFBLK},
	{ "b", 1, S_IFBLK},
	{ "c", 2, S_IFBLK},
	{ "a,raw", 0, S_IFCHR},
	{ "b,raw", 1, S_IFCHR},
	{ "c,raw", 2, S_IFCHR},
	{0}
};

static struct modldrv modldrv = {
	&mod_driverops,		/* Type of module. This one is a driver */
	"Floppy Disk driver",	/* Name of the module. */
	&fd_ops,		/* driver ops */
};

static struct modlinkage modlinkage = {
	MODREV_1, (void *)&modldrv, NULL
};


int
_init(void)
{
	int retval;

	if ((retval = ddi_soft_state_init(&fd_state_head,
	    sizeof (struct fdisk) + sizeof (struct fd_drive) +
	    sizeof (struct fd_char) + sizeof (struct fdattr), 0)) != 0)
		return (retval);

	if ((retval = mod_install(&modlinkage)) != 0)
		ddi_soft_state_fini(&fd_state_head);
	return (retval);
}

int
_fini(void)
{
	int retval;

	if ((retval = mod_remove(&modlinkage)) != 0)
		return (retval);
	ddi_soft_state_fini(&fd_state_head);
	return (retval);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}


static int
fd_getdrive(dev_t dev, struct fcu_obj **fjpp, struct fdisk **fdpp)
{
	if (fdpp) {
		*fdpp = ddi_get_soft_state(fd_state_head, DRIVE(dev));
		if (*fdpp && fjpp) {
			*fjpp = (*fdpp)->d_obj;
			if (*fjpp)
				return ((*fjpp)->fj_unit);
		}
	}
	return (-1);
}

/*ARGSUSED*/
static int
fd_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
	dev_t dev = (dev_t)arg;
	struct fcu_obj *fjp = NULL;
	struct fdisk *fdp = NULL;
	int rval;

	switch (cmd) {
	case DDI_INFO_DEVT2DEVINFO:
		(void) fd_getdrive(dev, &fjp, &fdp);
		/*
		 * Ignoring return value because success is checked by
		 * verifying fjp and fdp and returned unit value is not used.
		 */
		if (fjp && fdp) {
			*result = fjp->fj_dip;
			rval = DDI_SUCCESS;
		} else
			rval = DDI_FAILURE;
		break;
	case DDI_INFO_DEVT2INSTANCE:
		*result = (void *)(uintptr_t)DRIVE(dev);
		rval = DDI_SUCCESS;
		break;
	default:
		rval = DDI_FAILURE;
	}
	return (rval);
}

#ifdef CMOS_CONF_MEM
#define	CMOS_ADDR	0x70
#define	CMOS_DATA	0x71
#define	CMOS_FDRV	0x10
#endif	/* CMOS_CONF_MEM */

static int
fd_probe(dev_info_t *dip)
{
#ifdef CMOS_CONF_MEM
	int cmos;
	int drive_type;
#endif	/* CMOS_CONF_MEM */
	int debug[2];
	int drive_size;
	int len;
	int unit_num;
	char density[8];

	len = sizeof (debug);
	if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF,
	    DDI_PROP_DONTPASS, "debug", (caddr_t)debug, &len) ==
	    DDI_PROP_SUCCESS) {
		fderrlevel = debug[0];
#ifdef DEBUG
		fderrmask = (uint_t)debug[1];
#endif
	}
	len = sizeof (unit_num);
	if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF,
	    DDI_PROP_DONTPASS, "unit", (caddr_t)&unit_num, &len) !=
	    DDI_PROP_SUCCESS) {
		FDERRPRINT(FDEP_L3, FDEM_ATTA,
		    (CE_WARN, "fd_probe failed: dip %p", (void *)dip));
		return (DDI_PROBE_FAILURE);
	}

#ifdef CMOS_CONF_MEM
	/* get the cmos memory values quick and dirty */
	outb(CMOS_ADDR, CMOS_FDRV);
	cmos = drive_type = (int)inb(CMOS_DATA);
#endif	/* CMOS_CONF_MEM */

	switch (unit_num) {
#ifdef CMOS_CONF_MEM
	case 0:
		drive_type = drive_type >> 4;
		/* FALLTHROUGH */
	case 1:
		if (cmos && (drive_type & 0x0F)) {
			break;
		}
		/*
		 * Some enhanced floppy-disk controller adaptor cards
		 * require NO drives defined in the CMOS configuration
		 * memory.
		 * So fall through
		 */
#endif	/* CMOS_CONF_MEM */
	default:		/* need to check conf file */
		len = sizeof (density);
		if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF,
		    DDI_PROP_DONTPASS, "density", (caddr_t)&density, &len) !=
		    DDI_PROP_SUCCESS) {
			FDERRPRINT(FDEP_L3, FDEM_ATTA,
			    (CE_WARN,
			    "fd_probe failed density: dip %p unit %d",
			    (void *)dip, unit_num));
			return (DDI_PROBE_FAILURE);
		}
		len = sizeof (drive_size);
		if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF,
		    DDI_PROP_DONTPASS, "size", (caddr_t)&drive_size, &len) !=
		    DDI_PROP_SUCCESS) {
			FDERRPRINT(FDEP_L3, FDEM_ATTA,
			    (CE_WARN, "fd_probe failed size: dip %p unit %d",
			    (void *)dip, unit_num));
			return (DDI_PROBE_FAILURE);
		}
	}
	FDERRPRINT(FDEP_L3, FDEM_ATTA,
	    (CE_WARN, "fd_probe dip %p unit %d", (void *)dip, unit_num));
	return (DDI_PROBE_SUCCESS);
}


/* ARGSUSED */
static int
fd_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	struct fcu_obj *fjp;
	struct fdisk *fdp;
	struct driver_minor_data *dmdp;
	int mode_3D;
	int drive_num, drive_size, drive_type;
#ifdef CMOS_CONF_MEM
	int cmos;
#endif	/* CMOS_CONF_MEM */
	int len, sig_minor;
	int unit_num;
	char density[8];
	char name[MAXNAMELEN];

	switch (cmd) {
	case DDI_ATTACH:
		len = sizeof (unit_num);
		if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF,
		    DDI_PROP_DONTPASS, "unit", (caddr_t)&unit_num, &len) !=
		    DDI_PROP_SUCCESS) {
			FDERRPRINT(FDEP_L3, FDEM_ATTA,
			    (CE_WARN, "fd_attach failed: dip %p", (void *)dip));
			return (DDI_FAILURE);
		}

#ifdef CMOS_CONF_MEM
		outb(CMOS_ADDR, CMOS_FDRV);
		cmos = drive_type = (int)inb(CMOS_DATA);
#endif	/* CMOS_CONF_MEM */

		switch (unit_num) {
#ifdef CMOS_CONF_MEM
		case 0:
			drive_type = drive_type >> 4;
			/* FALLTHROUGH */
		case 1:
			drive_type = drive_type & 0x0F;
			if (cmos)
				break;
			/*
			 * Some enhanced floppy-disk controller adaptor cards
			 * require NO drives defined in the CMOS configuration
			 * memory.
			 * So fall through
			 */
#endif	/* CMOS_CONF_MEM */
		default:		/* need to check .conf file */
			drive_type = 0;
			len = sizeof (density);
			if (ddi_prop_op(DDI_DEV_T_ANY, dip,
			    PROP_LEN_AND_VAL_BUF, DDI_PROP_DONTPASS, "density",
			    (caddr_t)&density, &len) != DDI_PROP_SUCCESS)
				density[0] = '\0';
			len = sizeof (drive_size);
			if (ddi_prop_op(DDI_DEV_T_ANY, dip,
			    PROP_LEN_AND_VAL_BUF, DDI_PROP_DONTPASS, "size",
			    (caddr_t)&drive_size, &len) != DDI_PROP_SUCCESS)
				drive_size = 0;
			if (strcmp(density, "DSDD") == 0) {
				if (drive_size == 5)
					drive_type = 1;
				else if (drive_size == 3)
					drive_type = 3;
			} else if (strcmp(density, "DSHD") == 0) {
				if (drive_size == 5)
					drive_type = 2;
				else if (drive_size == 3)
					drive_type = 4;
			} else if (strcmp(density, "DSED") == 0 &&
			    drive_size == 3) {
				drive_type = 6;
			}
			break;
		}
		if (drive_type == 0) {
			FDERRPRINT(FDEP_L3, FDEM_ATTA,
			    (CE_WARN, "fd_attach failed type: dip %p unit %d",
			    (void *)dip, unit_num));
			return (DDI_FAILURE);
		}

		drive_num = ddi_get_instance(dip);
		if (ddi_soft_state_zalloc(fd_state_head, drive_num) != 0)
			return (DDI_FAILURE);
		fdp = ddi_get_soft_state(fd_state_head, drive_num);
		fjp = fdp->d_obj = ddi_get_driver_private(dip);

		mutex_init(&fjp->fj_lock, NULL, MUTEX_DRIVER, *fjp->fj_iblock);
		sema_init(&fdp->d_ocsem, 1, NULL, SEMA_DRIVER, NULL);

		fjp->fj_drive = (struct fd_drive *)(fdp + 1);
		fjp->fj_chars = (struct fd_char *)(fjp->fj_drive + 1);
		fjp->fj_attr = (struct fdattr *)(fjp->fj_chars + 1);

		/*
		 * set default floppy drive characteristics & geometry
		 */
		switch (drive_type) {	/* assume doubled sided */
		case 2:			/* 5.25 high density */
			*fjp->fj_drive = dfd_525HD;
			fdp->d_media = 1<<FMT_5H | 1<<FMT_5D9 | 1<<FMT_5D8 |
			    1<<FMT_5D4 | 1<<FMT_5D16;
			fdp->d_deffdtype = fdp->d_curfdtype = FMT_5H;
			break;
		case 4:			/* 3.5 high density */
			*fjp->fj_drive = dfd_350HD;
			fdp->d_media = 1<<FMT_3H | 1<<FMT_3I | 1<<FMT_3D;
			len = sizeof (mode_3D);
			if (ddi_prop_op(DDI_DEV_T_ANY, dip,
			    PROP_LEN_AND_VAL_BUF, DDI_PROP_DONTPASS, "mode_3D",
			    (caddr_t)&mode_3D, &len) != DDI_PROP_SUCCESS)
				mode_3D = 0;
			if (mode_3D && (fjp->fj_fdc->c_flags & FCFLG_3DMODE))
				/*
				 * 3D mode should be enabled only if a dual-
				 * speed 3.5" high-density drive and a
				 * supported floppy controller are installed.
				 */
				fdp->d_media |= 1 << FMT_3M;
			fdp->d_deffdtype = fdp->d_curfdtype = FMT_3H;
			break;
		case 1:			/* 5.25 double density */
			*fjp->fj_drive = dfd_525DD;
			fdp->d_media = 1<<FMT_5D9 | 1<<FMT_5D8 | 1<<FMT_5D4 |
			    1<<FMT_5D16;
			fdp->d_deffdtype = fdp->d_curfdtype = FMT_5D9;
			break;
		case 3:			/* 3.5 double density */
			*fjp->fj_drive = dfd_350HD;
			fdp->d_media = 1<<FMT_3D;
			fdp->d_deffdtype = fdp->d_curfdtype = FMT_3D;
			break;
		case 5:			/* 3.5 extended density */
		case 6:
		case 7:
			*fjp->fj_drive = dfd_350ED;
			fdp->d_media = 1<<FMT_3E | 1<<FMT_3H | 1<<FMT_3I |
			    1<<FMT_3D;
			fdp->d_deffdtype = fdp->d_curfdtype = FMT_3E;
			break;
		case 0:			/* no drive defined */
		default:
			goto no_attach;
		}
		*fjp->fj_chars = *defchar[fdp->d_deffdtype];
		*fjp->fj_attr = fdtypes[fdp->d_deffdtype];
		bcopy(fdparts[fdp->d_deffdtype], fdp->d_part,
		    sizeof (struct partition) * NDKMAP);
		fjp->fj_rotspd = fdtypes[fdp->d_deffdtype].fda_rotatespd;

		sig_minor = drive_num << 3;
		for (dmdp = fd_minor; dmdp->name != NULL; dmdp++) {
			if (ddi_create_minor_node(dip, dmdp->name, dmdp->type,
			    sig_minor | dmdp->minor, DDI_NT_FD, NULL)
			    == DDI_FAILURE) {
				ddi_remove_minor_node(dip, NULL);
				goto no_attach;
			}
		}

		FDERRPRINT(FDEP_L3, FDEM_ATTA,
		    (CE_WARN, "fd_attach: dip %p unit %d",
		    (void *)dip, unit_num));
		(void) sprintf(name, "fd%d", drive_num);
		fdp->d_iostat = kstat_create("fd", drive_num, name, "disk",
		    KSTAT_TYPE_IO, 1, KSTAT_FLAG_PERSISTENT);
		if (fdp->d_iostat) {
			fdp->d_iostat->ks_lock = &fjp->fj_lock;
			kstat_install(fdp->d_iostat);
		}

		fjp->fj_data = (caddr_t)fdp;
		fjp->fj_flags |= FUNIT_DRVATCH;

		/*
		 * Add a zero-length attribute to tell the world we support
		 * kernel ioctls (for layered drivers)
		 */
		(void) ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP,
		    DDI_KERNEL_IOCTL, NULL, 0);

		/*
		 * We want to get suspend/resume events, so that we can
		 * refuse to suspend when pcfs is mounted.
		 */
		(void) ddi_prop_update_string(DDI_DEV_T_NONE, dip,
		    "pm-hardware-state", "needs-suspend-resume");

		/*
		 * Ignoring return value because, for passed arguments, only
		 * DDI_SUCCESS is returned.
		 */
		ddi_report_dev(dip);
		return (DDI_SUCCESS);

	case DDI_RESUME:
		/* nothing for us to do */
		return (DDI_SUCCESS);

	default:
		return (DDI_FAILURE);
	}
no_attach:
	fjp->fj_drive = NULL;
	fjp->fj_chars = NULL;
	fjp->fj_attr = NULL;
	mutex_destroy(&fjp->fj_lock);
	sema_destroy(&fdp->d_ocsem);
	ddi_soft_state_free(fd_state_head, drive_num);
	FDERRPRINT(FDEP_L3, FDEM_ATTA,
	    (CE_WARN, "fd_attach failed: dip %p unit %d",
	    (void *)dip, unit_num));
	return (DDI_FAILURE);
}


/* ARGSUSED */
static int
fd_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	struct fcu_obj *fjp;
	struct fdisk *fdp;
	int drive_num;
	int rval = DDI_SUCCESS;

	FDERRPRINT(FDEP_L3, FDEM_ATTA, (CE_WARN, "fd_detach dip %p",
	    (void *)dip));

	drive_num = ddi_get_instance(dip);
	if (!(fdp = ddi_get_soft_state(fd_state_head, drive_num)))
		return (rval);

	switch (cmd) {
	case DDI_DETACH:
		if (fd_unit_is_open(fdp)) {
			rval = DDI_FAILURE;
			break;
		}
		kstat_delete(fdp->d_iostat);
		fdp->d_iostat = NULL;
		fjp = (struct fcu_obj *)fdp->d_obj;
		fjp->fj_flags &= ~FUNIT_DRVATCH;
		fjp->fj_data = NULL;
		fjp->fj_drive = NULL;
		fjp->fj_chars = NULL;
		fjp->fj_attr = NULL;
		ddi_prop_remove_all(dip);
		mutex_destroy(&fjp->fj_lock);
		sema_destroy(&fdp->d_ocsem);
		ddi_soft_state_free(fd_state_head, drive_num);
		break;

	case DDI_SUSPEND:
		/*
		 * Bad, bad, bad things will happen if someone
		 * *changes* the disk in the drive while it is mounted
		 * and the system is suspended.  We have no way to
		 * detect that.  (Undetected filesystem corruption.
		 * Its akin to changing the boot disk while the system
		 * is suspended.  Don't do it!)
		 *
		 * So we refuse to suspend if there is a mounted filesystem.
		 * (We guess this by looking for a block open.  Character
		 * opens are fine.)  This limits some of the usability of
		 * suspend/resume, but it certainly avoids this
		 * potential filesytem corruption from pilot error.
		 * Given the decreasing popularity of floppy media, we
		 * don't see this as much of a limitation.
		 */
		if (fdp->d_regopen[OTYP_BLK]) {
			cmn_err(CE_NOTE,
			    "Unable to suspend while floppy is in use.");
			rval = DDI_FAILURE;
		}
		break;

	default:
		rval = DDI_FAILURE;
		break;
	}
	return (rval);
}


static int
fd_part_is_open(struct fdisk *fdp, int part)
{
	int i;

	for (i = 0; i < (OTYPCNT - 1); i++)
		if (fdp->d_regopen[i] & (1 << part))
			return (1);
	return (0);
}

static int
fd_unit_is_open(struct fdisk *fdp)
{
	int i;

	for (i = 0; i < NDKMAP; i++)
		if (fdp->d_lyropen[i])
			return (1);
	for (i = 0; i < (OTYPCNT - 1); i++)
		if (fdp->d_regopen[i])
			return (1);
	return (0);
}

/*ARGSUSED*/
static int
fd_open(dev_t *devp, int flag, int otyp, cred_t *cred_p)
{
	struct fcu_obj *fjp = NULL;
	struct fdisk *fdp = NULL;
	struct partition *pp;
	dev_t dev;
	int part, unit;
	int part_is_open;
	int rval;
	uint_t pbit;

	dev = *devp;
	unit = fd_getdrive(dev, &fjp, &fdp);
	if (!fjp || !fdp)
		return (ENXIO);
	part = PARTITION(dev);
	pbit = 1 << part;
	pp = &fdp->d_part[part];

	/*
	 * Serialize opens/closes
	 */
	sema_p(&fdp->d_ocsem);
	FDERRPRINT(FDEP_L1, FDEM_OPEN,
	    (CE_CONT, "fd_open: fd%d part %d flag %x otype %x\n", DRIVE(dev),
	    part, flag, otyp));

	/*
	 * Check for previous exclusive open, or trying to exclusive open
	 * An "exclusive open" on any partition is not guaranteed to
	 * protect against opens on another partition that overlaps it.
	 */
	if (otyp == OTYP_LYR) {
		part_is_open = (fdp->d_lyropen[part] != 0);
	} else {
		part_is_open = fd_part_is_open(fdp, part);
	}
	if ((fdp->d_exclmask & pbit) || ((flag & FEXCL) && part_is_open)) {
		FDERRPRINT(FDEP_L0, FDEM_OPEN, (CE_CONT,
		    "fd_open: exclparts %lx openparts %lx lyrcnt %lx pbit %x\n",
		    fdp->d_exclmask, fdp->d_regopen[otyp], fdp->d_lyropen[part],
		    pbit));
		sema_v(&fdp->d_ocsem);
		return (EBUSY);
	}

	/*
	 * Ensure that drive is recalibrated on first open of new diskette.
	 */
	fjp->fj_ops->fco_select(fjp, unit, 1);
	if (fjp->fj_ops->fco_getchng(fjp, unit) != 0) {
		if (fjp->fj_ops->fco_rcseek(fjp, unit, -1, 0)) {
			FDERRPRINT(FDEP_L2, FDEM_OPEN,
			    (CE_NOTE, "fd_open fd%d: not ready", DRIVE(dev)));
			fjp->fj_ops->fco_select(fjp, unit, 0);
			sema_v(&fdp->d_ocsem);
			return (ENXIO);
		}
		fjp->fj_flags &= ~(FUNIT_LABELOK | FUNIT_UNLABELED);
	}
	if (flag & (FNDELAY | FNONBLOCK)) {
		/* don't attempt access, just return successfully */
		fjp->fj_ops->fco_select(fjp, unit, 0);
		goto out;
	}

	/*
	 * auto-sense the density/format of the diskette
	 */
	rval = fdgetlabel(fjp, unit);
	fjp->fj_ops->fco_select(fjp, unit, 0);
	if (rval) {
		/* didn't find label (couldn't read anything) */
		FDERRPRINT(FDEP_L2, FDEM_OPEN,
		    (CE_NOTE, "fd%d: drive not ready", DRIVE(dev)));
		sema_v(&fdp->d_ocsem);
		return (EIO);
	}
	/* check partition */
	if (pp->p_size == 0) {
		sema_v(&fdp->d_ocsem);
		return (ENXIO);
	}
	/*
	 * if opening for writing, check write protect on diskette
	 */
	if ((flag & FWRITE) && (fdp->d_obj->fj_flags & FUNIT_WPROT)) {
		sema_v(&fdp->d_ocsem);
		return (EROFS);
	}

out:
	/*
	 * mark open as having succeeded
	 */
	if (flag & FEXCL)
		fdp->d_exclmask |= pbit;
	if (otyp == OTYP_LYR)
		fdp->d_lyropen[part]++;
	else
		fdp->d_regopen[otyp] |= 1 << part;

	sema_v(&fdp->d_ocsem);
	return (0);
}

/*
 * fdgetlabel - read the SunOS label off the diskette
 *	if it can read a valid label it does so, else it will use a
 *	default.  If it can`t read the diskette - that is an error.
 *
 * RETURNS: 0 for ok - meaning that it could at least read the device,
 *	!0 for error XXX TBD NYD error codes
 */
static int
fdgetlabel(struct fcu_obj *fjp, int unit)
{
	struct dk_label *label;
	struct fdisk *fdp;
	char *newlabel;
	short *sp;
	short count;
	short xsum;
	int tries, try_this;
	uint_t nexttype;
	int rval;
	short oldlvl;
	int i;

	FDERRPRINT(FDEP_L0, FDEM_GETL,
	    (CE_CONT, "fdgetlabel fd unit %d\n", unit));
	fdp = (struct fdisk *)fjp->fj_data;
	fjp->fj_flags &= ~(FUNIT_UNLABELED);

	/*
	 * get some space to play with the label
	 */
	label = kmem_zalloc(sizeof (struct dk_label), KM_SLEEP);
	FDERRPRINT(FDEP_L0, FDEM_GETL, (CE_CONT,
	    "fdgetlabel fd unit %d kmem_zalloc: ptr = %p, size = %lx\n",
	    unit, (void *)label, (size_t)sizeof (struct dk_label)));

	/*
	 * read block 0 (0/0/1) to find the label
	 * (disk is potentially not present or unformatted)
	 */
	/* noerrprint since this is a private cmd */
	oldlvl = fderrlevel;
	fderrlevel = FDEP_LMAX;
	/*
	 * try different characteristics (ie densities)
	 *
	 * if fdp->d_curfdtype is -1 then the current characteristics
	 * were set by ioctl and need to try it as well as everything
	 * in the table
	 */
	nexttype = fdp->d_deffdtype;
	try_this = 1;		/* always try the current characteristics */

	for (tries = nfdtypes; tries; tries--) {
		if (try_this) {
			fjp->fj_flags &= ~FUNIT_CHAROK;

			/* try reading last sector of cyl 1, head 0 */
			if (!(rval = fjp->fj_ops->fco_rw(fjp, unit,
			    FDREAD, 1, 0, fjp->fj_chars->fdc_secptrack,
			    (caddr_t)label,
			    sizeof (struct dk_label))) &&
			    /* and last sector plus 1 of cylinder 1 */
			    fjp->fj_ops->fco_rw(fjp, unit, FDREAD, 1,
			    0, fjp->fj_chars->fdc_secptrack + 1,
			    (caddr_t)label,
			    sizeof (struct dk_label)) &&
			    /* and label sector on cylinder 0 */
			    !(rval = fjp->fj_ops->fco_rw(fjp, unit,
			    FDREAD, 0, 0, 1, (caddr_t)label,
			    sizeof (struct dk_label))))
				break;
			if (rval == ENXIO)
				break;
		}
		/*
		 * try the next entry in the characteristics tbl
		 */
		fdp->d_curfdtype = (signed char)nexttype;
		nexttype = (nexttype + 1) % nfdtypes;
		if ((1 << fdp->d_curfdtype) & fdp->d_media) {
			*fjp->fj_chars = *defchar[fdp->d_curfdtype];
			*fjp->fj_attr = fdtypes[fdp->d_curfdtype];
			bcopy(fdparts[fdp->d_curfdtype], fdp->d_part,
			    sizeof (struct partition) * NDKMAP);
			/*
			 * check for a double_density diskette
			 * in a high_density 5.25" drive
			 */
			if (fjp->fj_chars->fdc_transfer_rate == 250 &&
			    fjp->fj_rotspd > fjp->fj_attr->fda_rotatespd) {
				/*
				 * yes - adjust transfer rate since we don't
				 * know if we have a 5.25" dual-speed drive
				 */
				fjp->fj_attr->fda_rotatespd = 360;
				fjp->fj_chars->fdc_transfer_rate = 300;
				fjp->fj_chars->fdc_medium = 5;
			}
			if ((2 * fjp->fj_chars->fdc_ncyl) ==
			    defchar[fdp->d_deffdtype]->fdc_ncyl) {
				/* yes - adjust steps per cylinder */
				fjp->fj_chars->fdc_steps = 2;
			} else
				fjp->fj_chars->fdc_steps = 1;
			try_this = 1;
		} else
			try_this = 0;
	}
	fderrlevel = oldlvl;	/* print errors again */

	if (rval) {
		fdp->d_curfdtype = fdp->d_deffdtype;
		goto out;			/* couldn't read anything */
	}

	FDERRPRINT(FDEP_L0, FDEM_GETL,
	    (CE_CONT,
	    "fdgetlabel fd unit=%d ncyl=%d nsct=%d step=%d rpm=%d intlv=%d\n",
	    unit, fjp->fj_chars->fdc_ncyl, fjp->fj_chars->fdc_secptrack,
	    fjp->fj_chars->fdc_steps, fjp->fj_attr->fda_rotatespd,
	    fjp->fj_attr->fda_intrlv));

	/*
	 * _something_ was read  -  look for unixtype label
	 */
	if (label->dkl_magic != DKL_MAGIC ||
	    label->dkl_vtoc.v_sanity != VTOC_SANE) {
		/* not a label - no magic number */
		goto nolabel;	/* no errors, but no label */
	}

	count = sizeof (struct dk_label) / sizeof (short);
	sp = (short *)label;
	xsum = 0;
	while (count--)
		xsum ^= *sp++;	/* should add up to 0 */
	if (xsum) {
		/* not a label - checksum didn't compute */
		goto nolabel;	/* no errors, but no label */
	}

	/*
	 * the SunOS label overrides current diskette characteristics
	 */
	fjp->fj_chars->fdc_ncyl = label->dkl_pcyl;
	fjp->fj_chars->fdc_nhead = label->dkl_nhead;
	fjp->fj_chars->fdc_secptrack = (label->dkl_nsect * DEV_BSIZE) /
	    fjp->fj_chars->fdc_sec_size;
	if (defchar[fdp->d_deffdtype]->fdc_ncyl == 2 * fjp->fj_chars->fdc_ncyl)
		fjp->fj_chars->fdc_steps = 2;
	else
		fjp->fj_chars->fdc_steps = 1;

	fjp->fj_attr->fda_rotatespd = label->dkl_rpm;
	fjp->fj_attr->fda_intrlv = label->dkl_intrlv;

	fdp->d_vtoc_version = label->dkl_vtoc.v_version;
	bcopy(label->dkl_vtoc.v_volume, fdp->d_vtoc_volume, LEN_DKL_VVOL);
	bcopy(label->dkl_vtoc.v_asciilabel,
	    fdp->d_vtoc_asciilabel, LEN_DKL_ASCII);
	/*
	 * logical partitions
	 */
	for (i = 0; i < NDKMAP; i++) {
		fdp->d_part[i].p_tag = label->dkl_vtoc.v_part[i].p_tag;
		fdp->d_part[i].p_flag = label->dkl_vtoc.v_part[i].p_flag;
		fdp->d_part[i].p_start = label->dkl_vtoc.v_part[i].p_start;
		fdp->d_part[i].p_size = label->dkl_vtoc.v_part[i].p_size;

		fdp->d_vtoc_timestamp[i] = label->dkl_vtoc.timestamp[i];
	}

	fjp->fj_flags |= FUNIT_LABELOK;
	goto out;

nolabel:
	/*
	 * if not found, fill in label info from default (mark default used)
	 */
	if (fdp->d_media & (1<<FMT_3D))
		newlabel = deflabel_35;
	else /* if (fdp->d_media & (1<<FMT_5D9)) */
		newlabel = deflabel_525;
	bzero(fdp->d_vtoc_volume, LEN_DKL_VVOL);
	(void) sprintf(fdp->d_vtoc_asciilabel, newlabel,
	    fjp->fj_chars->fdc_ncyl, fjp->fj_chars->fdc_nhead,
	    fjp->fj_chars->fdc_secptrack);
	fjp->fj_flags |= FUNIT_UNLABELED;

out:
	kmem_free(label, sizeof (struct dk_label));
	return (rval);
}


/*ARGSUSED*/
static int
fd_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
{
	struct fcu_obj *fjp = NULL;
	struct fdisk *fdp = NULL;
	int part, part_is_closed;

#ifdef DEBUG
	int unit;
#define	DEBUG_ASSIGN	unit=
#else
#define	DEBUG_ASSIGN	(void)
#endif

	DEBUG_ASSIGN fd_getdrive(dev, &fjp, &fdp);
	/*
	 * Ignoring return in non DEBUG mode because success is checked by
	 * verifying fjp and fdp and returned unit value is not used.
	 */
	if (!fjp || !fdp)
		return (ENXIO);
	part = PARTITION(dev);

	sema_p(&fdp->d_ocsem);
	FDERRPRINT(FDEP_L1, FDEM_CLOS,
	    (CE_CONT, "fd_close: fd unit %d part %d otype %x\n",
	    unit, part, otyp));

	if (otyp == OTYP_LYR) {
		if (fdp->d_lyropen[part])
			fdp->d_lyropen[part]--;
		part_is_closed = (fdp->d_lyropen[part] == 0);
	} else {
		fdp->d_regopen[otyp] &= ~(1<<part);
		part_is_closed = 1;
	}
	if (part_is_closed) {
		if (part == 2 && fdp->d_exclmask&(1<<part))
			fdp->d_exclmask = 0;
		else
			fdp->d_exclmask &= ~(1<<part);
		FDERRPRINT(FDEP_L0, FDEM_CLOS,
		    (CE_CONT,
		    "fd_close: exclparts %lx openparts %lx lyrcnt %lx\n",
		    fdp->d_exclmask, fdp->d_regopen[otyp],
		    fdp->d_lyropen[part]));

		if (fd_unit_is_open(fdp) == 0)
			fdp->d_obj->fj_flags &= ~FUNIT_CHANGED;
	}
	sema_v(&fdp->d_ocsem);
	return (0);
}

/* ARGSUSED */
static int
fd_read(dev_t dev, struct uio *uio, cred_t *cred_p)
{
	return (physio(fd_strategy, NULL, dev, B_READ, minphys, uio));
}

/* ARGSUSED */
static int
fd_write(dev_t dev, struct uio *uio, cred_t *cred_p)
{
	return (physio(fd_strategy, NULL, dev, B_WRITE, minphys, uio));
}

/*
 * fd_strategy
 *	checks operation, hangs buf struct off fdcntlr, calls fdstart
 *	if not already busy.  Note that if we call start, then the operation
 *	will already be done on return (start sleeps).
 */
static int
fd_strategy(struct buf *bp)
{
	struct fcu_obj *fjp;
	struct fdisk *fdp;
	struct partition *pp;

	FDERRPRINT(FDEP_L1, FDEM_STRA,
	    (CE_CONT, "fd_strategy: bp = 0x%p, dev = 0x%lx\n",
	    (void *)bp, bp->b_edev));

	(void) fd_getdrive(bp->b_edev, &fjp, &fdp);

	/*
	 * Ignoring return because device exist.
	 * Returned unit value is not used.
	 */
	pp = &fdp->d_part[PARTITION(bp->b_edev)];

	if (fjp->fj_chars->fdc_sec_size > NBPSCTR && (bp->b_blkno & 1))  {
		FDERRPRINT(FDEP_L3, FDEM_STRA,
		    (CE_WARN, "fd%d: block %ld is not start of sector!",
		    DRIVE(bp->b_edev), (long)bp->b_blkno));
		bp->b_error = EINVAL;
		goto bad;
	}

	if ((bp->b_blkno > pp->p_size)) {
		FDERRPRINT(FDEP_L3, FDEM_STRA,
		    (CE_WARN, "fd%d: block %ld is past the end! (nblk=%ld)",
		    DRIVE(bp->b_edev), (long)bp->b_blkno, pp->p_size));
		bp->b_error = ENOSPC;
		goto bad;
	}

	/* if at end of file, skip out now */
	if (bp->b_blkno == pp->p_size) {
		if ((bp->b_flags & B_READ) == 0) {
			/* a write needs to get an error! */
			bp->b_error = ENOSPC;
			goto bad;
		}
		bp->b_resid = bp->b_bcount;
		biodone(bp);
		return (0);
	}

	/* if operation not a multiple of sector size, is error! */
	if (bp->b_bcount % fjp->fj_chars->fdc_sec_size)  {
		FDERRPRINT(FDEP_L3, FDEM_STRA,
		    (CE_WARN, "fd%d: count %ld must be a multiple of %d",
		    DRIVE(bp->b_edev), bp->b_bcount,
		    fjp->fj_chars->fdc_sec_size));
		bp->b_error = EINVAL;
		goto bad;
	}

	/*
	 * Put the buf request in the drive's queue, FIFO.
	 */
	bp->av_forw = 0;
	mutex_enter(&fjp->fj_lock);
	if (fdp->d_iostat)
		kstat_waitq_enter(KIOSP);
	if (fdp->d_actf)
		fdp->d_actl->av_forw = bp;
	else
		fdp->d_actf = bp;
	fdp->d_actl = bp;
	if (!(fjp->fj_flags & FUNIT_BUSY)) {
		fdstart(fjp);
	}
	mutex_exit(&fjp->fj_lock);
	return (0);

bad:
	bp->b_resid = bp->b_bcount;
	bp->b_flags |= B_ERROR;
	biodone(bp);
	return (0);
}

/*
 * fdstart
 *	called from fd_strategy() or from fdXXXX() to setup and
 *	start operations of read or write only (using buf structs).
 *	Because the chip doesn't handle crossing cylinder boundaries on
 *	the fly, this takes care of those boundary conditions.  Note that
 *	it sleeps until the operation is done *within fdstart* - so that
 *	when fdstart returns, the operation is already done.
 */
static void
fdstart(struct fcu_obj *fjp)
{
	struct buf *bp;
	struct fdisk *fdp = (struct fdisk *)fjp->fj_data;
	struct fd_char *chp;
	struct partition *pp;
	uint_t ptend;
	uint_t bincyl;		/* (the number of the desired) block in cyl. */
	uint_t blk, len, tlen;
	uint_t secpcyl;		/* number of sectors per cylinder */
	int cyl, head, sect;
	int sctrshft, unit;
	caddr_t	addr;

	ASSERT(MUTEX_HELD(&fjp->fj_lock));
	fjp->fj_flags |= FUNIT_BUSY;

	while ((bp = fdp->d_actf) != NULL) {
		fdp->d_actf = bp->av_forw;
		fdp->d_current = bp;
		if (fdp->d_iostat) {
			kstat_waitq_to_runq(KIOSP);
		}
		mutex_exit(&fjp->fj_lock);

		FDERRPRINT(FDEP_L0, FDEM_STRT,
		    (CE_CONT, "fdstart: bp=0x%p blkno=0x%lx bcount=0x%lx\n",
		    (void *)bp, (long)bp->b_blkno, bp->b_bcount));
		bp->b_flags &= ~B_ERROR;
		bp->b_error = 0;
		bp->b_resid = bp->b_bcount;	/* init resid */

		ASSERT(DRIVE(bp->b_edev) == ddi_get_instance(fjp->fj_dip));
		unit = fjp->fj_unit;
		fjp->fj_ops->fco_select(fjp, unit, 1);

		bp_mapin(bp);			/* map in buffers */

		pp = &fdp->d_part[PARTITION(bp->b_edev)];
		/* starting blk adjusted for the partition */
		blk = bp->b_blkno + pp->p_start;
		ptend = pp->p_start + pp->p_size;   /* end of the partition */

		chp = fjp->fj_chars;
		secpcyl = chp->fdc_nhead * chp->fdc_secptrack;
		switch (chp->fdc_sec_size) {
		/* convert logical block numbers to sector numbers */
		case 1024:
			sctrshft = SCTRSHFT + 1;
			blk >>= 1;
			ptend >>= 1;
			break;
		default:
		case NBPSCTR:
			sctrshft = SCTRSHFT;
			break;
		case 256:
			sctrshft = SCTRSHFT - 1;
			blk <<= 1;
			ptend <<= 1;
			break;
		}

		/*
		 * If off the end, limit to actual amount that
		 * can be transferred.
		 */
		if ((blk + (bp->b_bcount >> sctrshft)) > ptend)
			/* to end of partition */
			len = (ptend - blk) << sctrshft;
		else
			len = bp->b_bcount;
		addr = bp->b_un.b_addr;		/* data buffer address */

		/*
		 * now we have the real start blk, addr and len for xfer op
		 */
		while (len != 0) {
			/* start cyl of req */
			cyl = blk / secpcyl;
			bincyl = blk % secpcyl;
			/* start head of req */
			head = bincyl / chp->fdc_secptrack;
			/* start sector of req */
			sect = (bincyl % chp->fdc_secptrack) + 1;
			/*
			 * If the desired block and length will go beyond the
			 * cylinder end, then limit it to the cylinder end.
			 */
			if (bp->b_flags & B_READ) {
				if (len > ((secpcyl - bincyl) << sctrshft))
					tlen = (secpcyl - bincyl) << sctrshft;
				else
					tlen = len;
			} else {
				if (len >
				    ((chp->fdc_secptrack - sect + 1) <<
				    sctrshft))
					tlen =
					    (chp->fdc_secptrack - sect + 1) <<
					    sctrshft;
				else
					tlen = len;
			}

			FDERRPRINT(FDEP_L0, FDEM_STRT, (CE_CONT,
			    "  blk 0x%x addr 0x%p len 0x%x "
			    "cyl %d head %d sec %d\n  resid 0x%lx, tlen %d\n",
			    blk, (void *)addr, len, cyl, head, sect,
			    bp->b_resid, tlen));

			/*
			 * (try to) do the operation - failure returns an errno
			 */
			bp->b_error = fjp->fj_ops->fco_rw(fjp, unit,
			    bp->b_flags & B_READ, cyl, head, sect, addr, tlen);
			if (bp->b_error != 0) {
				FDERRPRINT(FDEP_L3, FDEM_STRT, (CE_WARN,
				    "fdstart: bad exec of bp: 0x%p, err=%d",
				    (void *)bp, bp->b_error));
				bp->b_flags |= B_ERROR;
				break;
			}
			blk += tlen >> sctrshft;
			len -= tlen;
			addr += tlen;
			bp->b_resid -= tlen;
		}
		FDERRPRINT(FDEP_L0, FDEM_STRT,
		    (CE_CONT, "fdstart done: b_resid %lu, b_count %lu\n",
		    bp->b_resid, bp->b_bcount));
		if (fdp->d_iostat) {
			if (bp->b_flags & B_READ) {
				KIOSP->reads++;
				KIOSP->nread += (bp->b_bcount - bp->b_resid);
			} else {
				KIOSP->writes++;
				KIOSP->nwritten += (bp->b_bcount - bp->b_resid);
			}
			kstat_runq_exit(KIOSP);
		}
		bp_mapout(bp);
		biodone(bp);

		fjp->fj_ops->fco_select(fjp, unit, 0);
		mutex_enter(&fjp->fj_lock);
		fdp->d_current = 0;
	}
	fjp->fj_flags ^= FUNIT_BUSY;
}

/* ARGSUSED */
static int
fd_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cred_p,
	int *rval_p)
{
	union {
		struct dk_cinfo dki;
		struct dk_geom dkg;
		struct dk_allmap dka;
		struct fd_char fdchar;
		struct fd_drive drvchar;
		int	temp;
	} cpy;
	struct vtoc vtoc;
	struct fcu_obj *fjp = NULL;
	struct fdisk *fdp = NULL;
	struct dk_map *dmp;
	struct dk_label *label;
	int nblks, part, unit;
	int rval = 0;
	enum dkio_state state;

	unit = fd_getdrive(dev, &fjp, &fdp);
	if (!fjp || !fdp)
		return (ENXIO);

	FDERRPRINT(FDEP_L1, FDEM_IOCT,
	    (CE_CONT, "fd_ioctl fd unit %d: cmd %x, arg %lx\n",
	    unit, cmd, arg));

	switch (cmd) {
	case DKIOCINFO:
		fjp->fj_ops->fco_dkinfo(fjp, &cpy.dki);
		cpy.dki.dki_cnum = FDCTLR(fjp->fj_unit);
		cpy.dki.dki_unit = FDUNIT(fjp->fj_unit);
		cpy.dki.dki_partition = PARTITION(dev);
		if (ddi_copyout(&cpy.dki, (void *)arg, sizeof (cpy.dki), flag))
			rval = EFAULT;
		break;

	case DKIOCG_PHYGEOM:
	case DKIOCG_VIRTGEOM:
		cpy.dkg.dkg_nsect = fjp->fj_chars->fdc_secptrack;
		goto get_geom;
	case DKIOCGGEOM:
		if (fjp->fj_flags & FUNIT_LABELOK)
			cpy.dkg.dkg_nsect = (fjp->fj_chars->fdc_secptrack *
			    fjp->fj_chars->fdc_sec_size) / DEV_BSIZE;
		else
			cpy.dkg.dkg_nsect = fjp->fj_chars->fdc_secptrack;
get_geom:
		cpy.dkg.dkg_pcyl = fjp->fj_chars->fdc_ncyl;
		cpy.dkg.dkg_ncyl = fjp->fj_chars->fdc_ncyl;
		cpy.dkg.dkg_nhead = fjp->fj_chars->fdc_nhead;
		cpy.dkg.dkg_intrlv = fjp->fj_attr->fda_intrlv;
		cpy.dkg.dkg_rpm = fjp->fj_attr->fda_rotatespd;
		cpy.dkg.dkg_read_reinstruct =
		    (int)(cpy.dkg.dkg_nsect * cpy.dkg.dkg_rpm * 4) / 60000;
		cpy.dkg.dkg_write_reinstruct = cpy.dkg.dkg_read_reinstruct;
		if (ddi_copyout(&cpy.dkg, (void *)arg, sizeof (cpy.dkg), flag))
			rval = EFAULT;
		break;

	case DKIOCSGEOM:
		if (ddi_copyin((void *)arg, &cpy.dkg,
		    sizeof (struct dk_geom), flag)) {
			rval = EFAULT;
			break;
		}
		mutex_enter(&fjp->fj_lock);
		fjp->fj_chars->fdc_ncyl = cpy.dkg.dkg_ncyl;
		fjp->fj_chars->fdc_nhead = cpy.dkg.dkg_nhead;
		fjp->fj_chars->fdc_secptrack = cpy.dkg.dkg_nsect;
		fjp->fj_attr->fda_intrlv = cpy.dkg.dkg_intrlv;
		fjp->fj_attr->fda_rotatespd = cpy.dkg.dkg_rpm;
		fdp->d_curfdtype = -1;
		mutex_exit(&fjp->fj_lock);
		break;

	/*
	 * return the map of all logical partitions
	 */
	case DKIOCGAPART:
		/*
		 * Note the conversion from starting sector number
		 * to starting cylinder number.
		 * Return error if division results in a remainder.
		 */
		nblks = fjp->fj_chars->fdc_nhead * fjp->fj_chars->fdc_secptrack;

#ifdef _MULTI_DATAMODEL
		switch (ddi_model_convert_from(flag & FMODELS)) {
		case DDI_MODEL_ILP32:
		{
			struct dk_allmap32 dka32;

			for (part = 0; part < NDKMAP; part++) {
				if ((fdp->d_part[part].p_start % nblks) != 0)
					return (EINVAL);
				dka32.dka_map[part].dkl_cylno =
				    fdp->d_part[part].p_start / nblks;
				dka32.dka_map[part].dkl_nblk =
				    fdp->d_part[part].p_size;
			}

			if (ddi_copyout(&dka32, (void *)arg,
			    sizeof (struct dk_allmap32), flag))
				rval = EFAULT;

			break;
		}
		case DDI_MODEL_NONE:

#endif /* _MULTI_DATAMODEL */

			dmp = (struct dk_map *)&cpy.dka;
			for (part = 0; part < NDKMAP; part++) {
				if ((fdp->d_part[part].p_start % nblks) != 0)
					return (EINVAL);
				dmp->dkl_cylno =
				    fdp->d_part[part].p_start / nblks;
				dmp->dkl_nblk = fdp->d_part[part].p_size;
				dmp++;
			}

			if (ddi_copyout(&cpy.dka, (void *)arg,
			    sizeof (struct dk_allmap), flag))
				rval = EFAULT;
#ifdef _MULTI_DATAMODEL
			break;

		}
#endif /* _MULTI_DATAMODEL */

		break;

	/*
	 * Set the map of all logical partitions
	 */
	case DKIOCSAPART:

#ifdef _MULTI_DATAMODEL
		switch (ddi_model_convert_from(flag & FMODELS)) {
		case DDI_MODEL_ILP32:
		{
			struct dk_allmap32 dka32;

			if (ddi_copyin((void *)arg, &dka32,
			    sizeof (dka32), flag)) {
				rval = EFAULT;
				break;
			}
			for (part = 0; part < NDKMAP; part++) {
				cpy.dka.dka_map[part].dkl_cylno =
				    dka32.dka_map[part].dkl_cylno;
				cpy.dka.dka_map[part].dkl_nblk =
				    dka32.dka_map[part].dkl_nblk;
			}
			break;
		}
		case DDI_MODEL_NONE:

#endif /* _MULTI_DATAMODEL */
		if (ddi_copyin((void *)arg, &cpy.dka, sizeof (cpy.dka), flag))
			rval = EFAULT;
#ifdef _MULTI_DATAMODEL

			break;
		}
#endif /* _MULTI_DATAMODEL */

		if (rval != 0)
			break;

		dmp = (struct dk_map *)&cpy.dka;
		nblks = fjp->fj_chars->fdc_nhead *
		    fjp->fj_chars->fdc_secptrack;
		mutex_enter(&fjp->fj_lock);
		/*
		 * Note the conversion from starting cylinder number
		 * to starting sector number.
		 */
		for (part = 0; part < NDKMAP; part++) {
			fdp->d_part[part].p_start = dmp->dkl_cylno *
			    nblks;
			fdp->d_part[part].p_size = dmp->dkl_nblk;
			dmp++;
		}
		mutex_exit(&fjp->fj_lock);

		break;

	case DKIOCGVTOC:
		mutex_enter(&fjp->fj_lock);

		/*
		 * Exit if the diskette has no label.
		 * Also, get the label to make sure the correct one is
		 * being used since the diskette may have changed
		 */
		fjp->fj_ops->fco_select(fjp, unit, 1);
		rval = fdgetlabel(fjp, unit);
		fjp->fj_ops->fco_select(fjp, unit, 0);
		if (rval) {
			mutex_exit(&fjp->fj_lock);
			rval = EINVAL;
			break;
		}

		fd_build_user_vtoc(fjp, fdp, &vtoc);
		mutex_exit(&fjp->fj_lock);

#ifdef _MULTI_DATAMODEL
		switch (ddi_model_convert_from(flag & FMODELS)) {
		case DDI_MODEL_ILP32:
		{
			struct vtoc32	vtoc32;

			vtoctovtoc32(vtoc, vtoc32);

			if (ddi_copyout(&vtoc32, (void *)arg,
			    sizeof (vtoc32), flag))
				rval = EFAULT;

			break;
		}
		case DDI_MODEL_NONE:

#endif /* _MULTI_DATAMODEL */
			if (ddi_copyout(&vtoc, (void *)arg,
			    sizeof (vtoc), flag))
				rval = EFAULT;
#ifdef _MULTI_DATAMODEL
			break;
		}
#endif /* _MULTI_DATAMODEL */

		break;

	case DKIOCSVTOC:

#ifdef _MULTI_DATAMODEL
		switch (ddi_model_convert_from(flag & FMODELS)) {
		case DDI_MODEL_ILP32:
		{
			struct vtoc32	vtoc32;

			if (ddi_copyin((void *)arg, &vtoc32,
			    sizeof (vtoc32), flag)) {
				rval = EFAULT;
				break;
			}

			vtoc32tovtoc(vtoc32, vtoc);

			break;
		}
		case DDI_MODEL_NONE:

#endif /* _MULTI_DATAMODEL */
			if (ddi_copyin((void *)arg, &vtoc, sizeof (vtoc), flag))
				rval = EFAULT;
#ifdef _MULTI_DATAMODEL
			break;
		}
#endif /* _MULTI_DATAMODEL */

		if (rval != 0)
			break;


		label = kmem_zalloc(sizeof (struct dk_label), KM_SLEEP);

		mutex_enter(&fjp->fj_lock);

		if ((rval = fd_build_label_vtoc(fjp, fdp, &vtoc, label)) == 0) {
			fjp->fj_ops->fco_select(fjp, unit, 1);
			rval = fjp->fj_ops->fco_rw(fjp, unit, FDWRITE,
			    0, 0, 1, (caddr_t)label, sizeof (struct dk_label));
			fjp->fj_ops->fco_select(fjp, unit, 0);
		}
		mutex_exit(&fjp->fj_lock);
		kmem_free(label, sizeof (struct dk_label));
		break;

	case DKIOCSTATE:
		FDERRPRINT(FDEP_L1, FDEM_IOCT,
		    (CE_CONT, "fd_ioctl fd unit %d: DKIOCSTATE\n", unit));

		if (ddi_copyin((void *)arg, &state, sizeof (int), flag)) {
			rval = EFAULT;
			break;
		}

		rval = fd_check_media(dev, state);

		if (ddi_copyout(&fdp->d_media_state, (void *)arg,
		    sizeof (int), flag))
			rval = EFAULT;
		break;

	case FDIOGCHAR:
		if (ddi_copyout(fjp->fj_chars, (void *)arg,
		    sizeof (struct fd_char), flag))
			rval = EFAULT;
		break;

	case FDIOSCHAR:
		if (ddi_copyin((void *)arg, &cpy.fdchar,
		    sizeof (struct fd_char), flag)) {
			rval = EFAULT;
			break;
		}
		switch (cpy.fdchar.fdc_transfer_rate) {
		case 417:
			if ((fdp->d_media & (1 << FMT_3M)) == 0) {
				cmn_err(CE_CONT,
				    "fdioschar:Medium density not supported\n");
				rval = EINVAL;
				break;
			}
			mutex_enter(&fjp->fj_lock);
			fjp->fj_attr->fda_rotatespd = 360;
			mutex_exit(&fjp->fj_lock);
			/* cpy.fdchar.fdc_transfer_rate = 500; */
			/* FALLTHROUGH */
		case 1000:
		case 500:
		case 300:
		case 250:
			mutex_enter(&fjp->fj_lock);
			*(fjp->fj_chars) = cpy.fdchar;
			fdp->d_curfdtype = -1;
			fjp->fj_flags &= ~FUNIT_CHAROK;
			mutex_exit(&fjp->fj_lock);

			break;

		default:
			FDERRPRINT(FDEP_L4, FDEM_IOCT,
			    (CE_WARN, "fd_ioctl fd unit %d: FDIOSCHAR odd "
			    "xfer rate %dkbs",
			    unit, cpy.fdchar.fdc_transfer_rate));
			rval = EINVAL;
			break;
		}
		break;

	/*
	 * set all characteristics and geometry to the defaults
	 */
	case FDDEFGEOCHAR:
		mutex_enter(&fjp->fj_lock);
		fdp->d_curfdtype = fdp->d_deffdtype;
		*fjp->fj_chars = *defchar[fdp->d_curfdtype];
		*fjp->fj_attr = fdtypes[fdp->d_curfdtype];
		bcopy(fdparts[fdp->d_curfdtype],
		    fdp->d_part, sizeof (struct partition) * NDKMAP);
		fjp->fj_flags &= ~FUNIT_CHAROK;
		mutex_exit(&fjp->fj_lock);
		break;

	case FDEJECT:  /* eject disk */
	case DKIOCEJECT:
		fjp->fj_flags &= ~(FUNIT_LABELOK | FUNIT_UNLABELED);
		rval = ENOSYS;
		break;

	case FDGETCHANGE: /* disk changed */
		if (ddi_copyin((void *)arg, &cpy.temp, sizeof (int), flag)) {
			rval = EFAULT;
			break;
		}
		mutex_enter(&fjp->fj_lock);
		fjp->fj_ops->fco_select(fjp, unit, 1);

		if (fjp->fj_flags & FUNIT_CHANGED)
			cpy.temp |= FDGC_HISTORY;
		else
			cpy.temp &= ~FDGC_HISTORY;
		fjp->fj_flags &= ~FUNIT_CHANGED;

		if (fjp->fj_ops->fco_getchng(fjp, unit)) {
			cpy.temp |= FDGC_DETECTED;
			fjp->fj_ops->fco_resetchng(fjp, unit);
			/*
			 * check diskette again only if it was removed
			 */
			if (fjp->fj_ops->fco_getchng(fjp, unit)) {
				/*
				 * no diskette is present
				 */
				cpy.temp |= FDGC_CURRENT;
				if (fjp->fj_flags & FUNIT_CHGDET)
					/*
					 * again no diskette; not a new change
					 */
					cpy.temp ^= FDGC_DETECTED;
				else
					fjp->fj_flags |= FUNIT_CHGDET;
			} else {
				/*
				 * a new diskette is present
				 */
				cpy.temp &= ~FDGC_CURRENT;
				fjp->fj_flags &= ~FUNIT_CHGDET;
			}
		} else {
			cpy.temp &= ~(FDGC_DETECTED | FDGC_CURRENT);
			fjp->fj_flags &= ~FUNIT_CHGDET;
		}
		/*
		 * also get state of write protection
		 */
		if (fjp->fj_flags & FUNIT_WPROT) {
			cpy.temp |= FDGC_CURWPROT;
		} else {
			cpy.temp &= ~FDGC_CURWPROT;
		}
		fjp->fj_ops->fco_select(fjp, unit, 0);
		mutex_exit(&fjp->fj_lock);

		if (ddi_copyout(&cpy.temp, (void *)arg, sizeof (int), flag))
			rval = EFAULT;
		break;

	case FDGETDRIVECHAR:
		if (ddi_copyout(fjp->fj_drive, (void *)arg,
		    sizeof (struct fd_drive), flag))
			rval = EFAULT;
		break;

	case FDSETDRIVECHAR:
		if (ddi_copyin((void *)arg, &cpy.drvchar,
		    sizeof (struct fd_drive), flag)) {
			rval = EFAULT;
			break;
		}
		mutex_enter(&fjp->fj_lock);
		*(fjp->fj_drive) = cpy.drvchar;
		fdp->d_curfdtype = -1;
		fjp->fj_flags &= ~FUNIT_CHAROK;
		mutex_exit(&fjp->fj_lock);
		break;

	case DKIOCREMOVABLE: {
		int	i = 1;

		/* no brainer: floppies are always removable */
		if (ddi_copyout(&i, (void *)arg, sizeof (int), flag)) {
			rval = EFAULT;
		}
		break;
	}

	case DKIOCGMEDIAINFO:
		rval = fd_get_media_info(fjp, (caddr_t)arg, flag);
		break;

	case FDIOCMD:
	{
		struct fd_cmd fc;
		int cyl, head, spc, spt;

#ifdef _MULTI_DATAMODEL
		switch (ddi_model_convert_from(flag & FMODELS)) {
		case DDI_MODEL_ILP32:
		{
			struct fd_cmd32 fc32;

			if (ddi_copyin((void *)arg, &fc32,
			    sizeof (fc32), flag)) {
				rval = EFAULT;
				break;
			}

			fc.fdc_cmd = fc32.fdc_cmd;
			fc.fdc_flags = fc32.fdc_flags;
			fc.fdc_blkno = fc32.fdc_blkno;
			fc.fdc_secnt = fc32.fdc_secnt;
			fc.fdc_bufaddr = (caddr_t)(uintptr_t)fc32.fdc_bufaddr;
			fc.fdc_buflen = fc32.fdc_buflen;

			break;
		}
		case DDI_MODEL_NONE:

#endif /* _MULTI_DATAMODEL */

			if (ddi_copyin((void *)arg, &fc, sizeof (fc), flag)) {
				rval = EFAULT;
				break;
			}
#ifdef _MULTI_DATAMODEL
			break;
		}
#endif /* _MULTI_DATAMODEL */

		if (rval != 0)
			break;

	if (fc.fdc_cmd == FDCMD_READ || fc.fdc_cmd == FDCMD_WRITE) {
			auto struct iovec aiov;
			auto struct uio auio;
			struct uio *uio = &auio;

			spc = (fc.fdc_cmd == FDCMD_READ)? B_READ: B_WRITE;

			bzero(&auio, sizeof (struct uio));
			bzero(&aiov, sizeof (struct iovec));
			aiov.iov_base = fc.fdc_bufaddr;
			aiov.iov_len = (uint_t)fc.fdc_secnt *
			    fjp->fj_chars->fdc_sec_size;
			uio->uio_iov = &aiov;

			uio->uio_iovcnt = 1;
			uio->uio_resid = aiov.iov_len;
			uio->uio_segflg = UIO_USERSPACE;

			rval = physio(fd_strategy, (struct buf *)0, dev,
			    spc, minphys, uio);
			break;
		} else if (fc.fdc_cmd == FDCMD_FORMAT_TRACK) {
			spt = fjp->fj_chars->fdc_secptrack;	/* sec/trk */
			spc = fjp->fj_chars->fdc_nhead * spt;	/* sec/cyl */
			cyl = fc.fdc_blkno / spc;
			head = (fc.fdc_blkno % spc) / spt;
			if ((cyl | head) == 0)
				fjp->fj_flags &=
				    ~(FUNIT_LABELOK | FUNIT_UNLABELED);

			FDERRPRINT(FDEP_L0, FDEM_FORM,
			    (CE_CONT, "fd_format cyl %d, hd %d\n", cyl, head));
			fjp->fj_ops->fco_select(fjp, unit, 1);
			rval = fjp->fj_ops->fco_format(fjp, unit, cyl, head,
			    (int)fc.fdc_flags);
			fjp->fj_ops->fco_select(fjp, unit, 0);

			break;
		}
		FDERRPRINT(FDEP_L4, FDEM_IOCT,
		    (CE_WARN, "fd_ioctl fd unit %d: FDIOCSCMD not yet complete",
		    unit));
		rval = EINVAL;
		break;
	}

	case FDRAW:
		rval = fd_rawioctl(fjp, unit, (caddr_t)arg, flag);
		break;

	default:
		FDERRPRINT(FDEP_L4, FDEM_IOCT,
		    (CE_WARN, "fd_ioctl fd unit %d: invalid ioctl 0x%x",
		    unit, cmd));
		rval = ENOTTY;
		break;
	}
	return (rval);
}

static void
fd_build_user_vtoc(struct fcu_obj *fjp, struct fdisk *fdp, struct vtoc *vtocp)
{
	struct partition *vpart;
	int	i;
	int	xblk;

	/*
	 * Return vtoc structure fields in the provided VTOC area, addressed
	 * by *vtocp.
	 *
	 */
	bzero(vtocp, sizeof (struct vtoc));

	bcopy(fdp->d_vtoc_bootinfo,
	    vtocp->v_bootinfo, sizeof (vtocp->v_bootinfo));

	vtocp->v_sanity = VTOC_SANE;
	vtocp->v_version = fdp->d_vtoc_version;
	bcopy(fdp->d_vtoc_volume, vtocp->v_volume, LEN_DKL_VVOL);
	if (fjp->fj_flags & FUNIT_LABELOK) {
		vtocp->v_sectorsz = DEV_BSIZE;
		xblk = 1;
	} else {
		vtocp->v_sectorsz = fjp->fj_chars->fdc_sec_size;
		xblk = vtocp->v_sectorsz / DEV_BSIZE;
	}
	vtocp->v_nparts = 3;	/* <= NDKMAP;	*/

	/*
	 * Copy partitioning information.
	 */
	bcopy(fdp->d_part, vtocp->v_part, sizeof (struct partition) * NDKMAP);
	for (i = NDKMAP, vpart = vtocp->v_part; i && (xblk > 1); i--, vpart++) {
		/* correct partition info if sector size > 512 bytes */
		vpart->p_start /= xblk;
		vpart->p_size /= xblk;
	}

	bcopy(fdp->d_vtoc_timestamp,
	    vtocp->timestamp, sizeof (fdp->d_vtoc_timestamp));
	bcopy(fdp->d_vtoc_asciilabel, vtocp->v_asciilabel, LEN_DKL_ASCII);
}


static int
fd_build_label_vtoc(struct fcu_obj *fjp, struct fdisk *fdp, struct vtoc *vtocp,
    struct dk_label *labelp)
{
	struct partition *vpart;
	int	i;
	int	nblks;
	int	ncyl;
	ushort_t sum, *sp;


	/*
	 * Sanity-check the vtoc
	 */
	if (vtocp->v_sanity != VTOC_SANE ||
	    vtocp->v_nparts > NDKMAP || vtocp->v_nparts <= 0) {
		FDERRPRINT(FDEP_L3, FDEM_IOCT,
		    (CE_WARN, "fd_build_label:  sanity check on vtoc failed"));
		return (EINVAL);
	}

	/*
	 * before copying the vtoc, the partition information in it should be
	 * checked against the information the driver already has on the
	 * diskette.
	 */

	nblks = (fjp->fj_chars->fdc_nhead * fjp->fj_chars->fdc_secptrack *
	    fjp->fj_chars->fdc_sec_size) / DEV_BSIZE;
	if (nblks == 0 || fjp->fj_chars->fdc_ncyl == 0)
		return (EFAULT);
	vpart = vtocp->v_part;

	/*
	 * Check the partition information in the vtoc.  The starting sectors
	 * must lie along cylinder boundaries. (NDKMAP entries are checked
	 * to ensure that the unused entries are set to 0 if vtoc->v_nparts
	 * is less than NDKMAP)
	 */
	for (i = NDKMAP; i; i--) {
		if ((vpart->p_start % nblks) != 0) {
			return (EINVAL);
		}
		ncyl = vpart->p_start / nblks;
		ncyl += vpart->p_size / nblks;
		if ((vpart->p_size % nblks) != 0)
			ncyl++;
		if (ncyl > (long)fjp->fj_chars->fdc_ncyl) {
			return (EINVAL);
		}
		vpart++;
	}


	bcopy(vtocp->v_bootinfo, fdp->d_vtoc_bootinfo,
	    sizeof (vtocp->v_bootinfo));
	fdp->d_vtoc_version = vtocp->v_version;
	bcopy(vtocp->v_volume, fdp->d_vtoc_volume, LEN_DKL_VVOL);

	/*
	 * Copy partitioning information.
	 */
	bcopy(vtocp->v_part, fdp->d_part, sizeof (struct partition) * NDKMAP);
	bcopy(vtocp->timestamp, fdp->d_vtoc_timestamp,
	    sizeof (fdp->d_vtoc_timestamp));
	bcopy(vtocp->v_asciilabel, fdp->d_vtoc_asciilabel, LEN_DKL_ASCII);

	/*
	 * construct the diskette label in supplied buffer
	 */

	/* Put appropriate vtoc structure fields into the disk label */
	labelp->dkl_vtoc.v_bootinfo[0] = (uint32_t)vtocp->v_bootinfo[0];
	labelp->dkl_vtoc.v_bootinfo[1] = (uint32_t)vtocp->v_bootinfo[1];
	labelp->dkl_vtoc.v_bootinfo[2] = (uint32_t)vtocp->v_bootinfo[2];

	labelp->dkl_vtoc.v_sanity = vtocp->v_sanity;
	labelp->dkl_vtoc.v_version = vtocp->v_version;

	bcopy(vtocp->v_volume, labelp->dkl_vtoc.v_volume, LEN_DKL_VVOL);

	labelp->dkl_vtoc.v_nparts = vtocp->v_nparts;

	bcopy(vtocp->v_reserved, labelp->dkl_vtoc.v_reserved,
	    sizeof (labelp->dkl_vtoc.v_reserved));

	for (i = 0; i < (int)vtocp->v_nparts; i++) {
		labelp->dkl_vtoc.v_part[i].p_tag  = vtocp->v_part[i].p_tag;
		labelp->dkl_vtoc.v_part[i].p_flag  = vtocp->v_part[i].p_flag;
		labelp->dkl_vtoc.v_part[i].p_start  = vtocp->v_part[i].p_start;
		labelp->dkl_vtoc.v_part[i].p_size  = vtocp->v_part[i].p_size;
	}

	for (i = 0; i < NDKMAP; i++) {
		labelp->dkl_vtoc.v_timestamp[i] = vtocp->timestamp[i];
	}
	bcopy(vtocp->v_asciilabel, labelp->dkl_asciilabel, LEN_DKL_ASCII);


	labelp->dkl_pcyl = fjp->fj_chars->fdc_ncyl;
	labelp->dkl_ncyl = fjp->fj_chars->fdc_ncyl;
	labelp->dkl_nhead = fjp->fj_chars->fdc_nhead;
	/*
	 * The fdc_secptrack field of the fd_char structure is the number
	 * of sectors per track where the sectors are fdc_sec_size.
	 * The dkl_nsect field of the dk_label structure is the number of
	 * DEV_BSIZE (512) byte sectors per track.
	 */
	labelp->dkl_nsect = (fjp->fj_chars->fdc_secptrack *
	    fjp->fj_chars->fdc_sec_size) / DEV_BSIZE;
	labelp->dkl_intrlv = fjp->fj_attr->fda_intrlv;
	labelp->dkl_rpm = fjp->fj_attr->fda_rotatespd;
	labelp->dkl_read_reinstruct =
	    (int)(labelp->dkl_nsect * labelp->dkl_rpm * 4) / 60000;
	labelp->dkl_write_reinstruct = labelp->dkl_read_reinstruct;

	labelp->dkl_magic = DKL_MAGIC;

	sum = 0;
	labelp->dkl_cksum = 0;
	sp = (ushort_t *)labelp;
	while (sp < &(labelp->dkl_cksum)) {
		sum ^= *sp++;
	}
	labelp->dkl_cksum = sum;

	return (0);
}

static int
fd_rawioctl(struct fcu_obj *fjp, int unit, caddr_t arg, int mode)
{
	struct fd_raw fdr;
	char *arg_result = NULL;
	int flag = B_READ;
	int rval = 0;
	caddr_t	uaddr;
	uint_t ucount;

	FDERRPRINT(FDEP_L1, FDEM_RAWI,
	    (CE_CONT, "fd_rawioctl: cmd[0]=0x%x\n", fdr.fdr_cmd[0]));

	if (fjp->fj_chars->fdc_medium != 3 && fjp->fj_chars->fdc_medium != 5) {
		cmn_err(CE_CONT, "fd_rawioctl: Medium density not supported\n");
		return (ENXIO);
	}

#ifdef _MULTI_DATAMODEL
	switch (ddi_model_convert_from(mode & FMODELS)) {
	case DDI_MODEL_ILP32:
	{
		struct fd_raw32 fdr32;

		if (ddi_copyin(arg, &fdr32, sizeof (fdr32), mode))
			return (EFAULT);

		bcopy(fdr32.fdr_cmd, fdr.fdr_cmd, sizeof (fdr.fdr_cmd));
		fdr.fdr_cnum = fdr32.fdr_cnum;
		fdr.fdr_nbytes = fdr32.fdr_nbytes;
		fdr.fdr_addr = (caddr_t)(uintptr_t)fdr32.fdr_addr;
		arg_result = ((struct fd_raw32 *)arg)->fdr_result;

		break;
	}
	case DDI_MODEL_NONE:
#endif /* ! _MULTI_DATAMODEL */

		if (ddi_copyin(arg, &fdr, sizeof (fdr), mode))
			return (EFAULT);

		arg_result = ((struct fd_raw *)arg)->fdr_result;

#ifdef _MULTI_DATAMODEL
		break;
	}
#endif /* _MULTI_DATAMODEL */



	/*
	 * copy user address & nbytes from raw_req so that we can
	 * put kernel address in req structure
	 */
	uaddr = fdr.fdr_addr;
	ucount = (uint_t)fdr.fdr_nbytes;
	unit &= 3;

	switch (fdr.fdr_cmd[0] & 0x0f) {

	case FDRAW_FORMAT:
		ucount += 16;
		fdr.fdr_addr = kmem_zalloc(ucount, KM_SLEEP);
		if (ddi_copyin(uaddr, fdr.fdr_addr,
		    (size_t)fdr.fdr_nbytes, mode)) {
			kmem_free(fdr.fdr_addr, ucount);
			return (EFAULT);
		}
		if ((*fdr.fdr_addr | fdr.fdr_addr[1]) == 0)
			fjp->fj_flags &= ~(FUNIT_LABELOK | FUNIT_UNLABELED);
		flag = B_WRITE;
		fdr.fdr_cmd[1] = (fdr.fdr_cmd[1] & ~3) | unit;
		break;

	case FDRAW_WRCMD:
	case FDRAW_WRITEDEL:
		flag = B_WRITE;
		/* FALLTHROUGH */
	case FDRAW_RDCMD:
	case FDRAW_READDEL:
	case FDRAW_READTRACK:
		if (ucount) {
			/*
			 * In SunOS 4.X, we used to as_fault things in.
			 * We really cannot do this in 5.0/SVr4. Unless
			 * someone really believes that speed is of the
			 * essence here, it is just much simpler to do
			 * this in kernel space and use copyin/copyout.
			 */
			fdr.fdr_addr = kmem_alloc((size_t)ucount, KM_SLEEP);
			if (flag == B_WRITE) {
				if (ddi_copyin(uaddr, fdr.fdr_addr, ucount,
				    mode)) {
					kmem_free(fdr.fdr_addr, ucount);
					return (EFAULT);
				}
			}
		} else
			return (EINVAL);
		fdr.fdr_cmd[1] = (fdr.fdr_cmd[1] & ~3) | unit;
		break;

	case FDRAW_READID:
	case FDRAW_REZERO:
	case FDRAW_SEEK:
	case FDRAW_SENSE_DRV:
		ucount = 0;
		fdr.fdr_cmd[1] = (fdr.fdr_cmd[1] & ~3) | unit;
		break;

	case FDRAW_SPECIFY:
		fdr.fdr_cmd[2] &= 0xfe;	/* keep NoDMA bit clear */
		/* FALLTHROUGH */
	case FDRAW_SENSE_INT:
		ucount = 0;
		break;

	default:
		return (EINVAL);
	}

	/*
	 * Note that we ignore any error returns from controller
	 * This is the way the driver has been, and it may be
	 * that the raw ioctl senders simply don't want to
	 * see any errors returned in this fashion.
	 */

	fjp->fj_ops->fco_select(fjp, unit, 1);
	rval = fjp->fj_ops->fco_rwioctl(fjp, unit, (caddr_t)&fdr);

	if (ucount && flag == B_READ && rval == 0) {
		if (ddi_copyout(fdr.fdr_addr, uaddr, ucount, mode)) {
			rval = EFAULT;
		}
	}
	if (ddi_copyout(fdr.fdr_result, arg_result, sizeof (fdr.fdr_cmd), mode))
		rval = EFAULT;

	fjp->fj_ops->fco_select(fjp, unit, 0);
	if (ucount)
		kmem_free(fdr.fdr_addr, ucount);

	return (rval);
}

/*
 * property operation routine.  return the number of blocks for the partition
 * in question or forward the request to the property facilities.
 */
static int
fd_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
    char *name, caddr_t valuep, int *lengthp)
{
	struct fcu_obj	*fjp = NULL;
	struct fdisk	*fdp = NULL;
	uint64_t	nblocks64;

	FDERRPRINT(FDEP_L1, FDEM_PROP,
	    (CE_CONT, "fd_prop_op: dip %p %s\n", (void *)dip, name));

	/*
	 * Our dynamic properties are all device specific and size oriented.
	 * Requests issued under conditions where size is valid are passed
	 * to ddi_prop_op_nblocks with the size information, otherwise the
	 * request is passed to ddi_prop_op.
	 */
	if (dev == DDI_DEV_T_ANY) {
pass:  		return (ddi_prop_op(dev, dip, prop_op, mod_flags,
		    name, valuep, lengthp));
	} else {
		/*
		 * Ignoring return value because success is checked by
		 * verifying fjp and fdp and returned unit value is not used.
		 */
		(void) fd_getdrive(dev, &fjp, &fdp);
		if (!fjp || !fdp)
			goto pass;

		/* get nblocks value */
		nblocks64 = (ulong_t)fdp->d_part[PARTITION(dev)].p_size;

		return (ddi_prop_op_nblocks(dev, dip, prop_op, mod_flags,
		    name, valuep, lengthp, nblocks64));
	}
}

static void
fd_media_watch(void *arg)
{
	struct fcu_obj *fjp;
	struct fdisk *fdp;

#ifdef DEBUG
	int	unit;
#define	DEBUG_ASSIGN	unit=
#else
#define	DEBUG_ASSIGN	(void)
#endif
	DEBUG_ASSIGN fd_getdrive((dev_t)arg, &fjp, &fdp);
	/*
	 * Ignoring return in non DEBUG mode because device exist.
	 * Returned unit value is not used.
	 */

	FDERRPRINT(FDEP_L0, FDEM_IOCT,
	    (CE_CONT, "fd_media_watch unit %d\n", unit));

	/*
	 * fd_get_media_state() cannot be called from this timeout function
	 * because the  floppy drive has to be selected first, and that could
	 * force this function to sleep (while waiting for the select
	 * semaphore).
	 * Instead, just wakeup up driver.
	 */
	mutex_enter(&fjp->fj_lock);
	cv_broadcast(&fdp->d_statecv);
	mutex_exit(&fjp->fj_lock);
}

enum dkio_state
fd_get_media_state(struct fcu_obj *fjp, int unit)
{
	enum dkio_state state;

	if (fjp->fj_ops->fco_getchng(fjp, unit)) {
		/* recheck disk only if DSKCHG "high" */
		fjp->fj_ops->fco_resetchng(fjp, unit);
		if (fjp->fj_ops->fco_getchng(fjp, unit)) {
			if (fjp->fj_flags & FUNIT_CHGDET) {
				/*
				 * again no diskette; not a new change
				 */
				state = DKIO_NONE;
			} else {
				/*
				 * a new change; diskette was ejected
				 */
				fjp->fj_flags |= FUNIT_CHGDET;
				state = DKIO_EJECTED;
			}
		} else {
			fjp->fj_flags &= ~FUNIT_CHGDET;
			state = DKIO_INSERTED;
		}
	} else {
		fjp->fj_flags &= ~FUNIT_CHGDET;
		state = DKIO_INSERTED;
	}
	FDERRPRINT(FDEP_L0, FDEM_IOCT,
	    (CE_CONT, "fd_get_media_state unit %d: state %x\n", unit, state));
	return (state);
}

static int
fd_check_media(dev_t dev, enum dkio_state state)
{
	struct fcu_obj *fjp;
	struct fdisk *fdp;
	int	unit;
	int	err;

	unit = fd_getdrive(dev, &fjp, &fdp);

	mutex_enter(&fjp->fj_lock);

	fjp->fj_ops->fco_select(fjp, unit, 1);
	fdp->d_media_state = fd_get_media_state(fjp, unit);
	fdp->d_media_timeout = drv_usectohz(fd_check_media_time);

	while (fdp->d_media_state == state) {
		/* release the controller and drive */
		fjp->fj_ops->fco_select(fjp, unit, 0);

		/* turn on timer */
		fdp->d_media_timeout_id = timeout(fd_media_watch,
		    (void *)dev, fdp->d_media_timeout);

		if (cv_wait_sig(&fdp->d_statecv, &fjp->fj_lock) == 0) {
			fdp->d_media_timeout = 0;
			mutex_exit(&fjp->fj_lock);
			return (EINTR);
		}
		fjp->fj_ops->fco_select(fjp, unit, 1);
		fdp->d_media_state = fd_get_media_state(fjp, unit);
	}

	if (fdp->d_media_state == DKIO_INSERTED) {
		err = fdgetlabel(fjp, unit);
		if (err) {
			fjp->fj_ops->fco_select(fjp, unit, 0);
			mutex_exit(&fjp->fj_lock);
			return (EIO);
		}
	}
	fjp->fj_ops->fco_select(fjp, unit, 0);
	mutex_exit(&fjp->fj_lock);
	return (0);
}

/*
 * fd_get_media_info :
 * 	Collects medium information for
 *	DKIOCGMEDIAINFO ioctl.
 */

static int
fd_get_media_info(struct fcu_obj *fjp, caddr_t buf, int flag)
{
	struct dk_minfo media_info;
	int err = 0;

	media_info.dki_media_type = DK_FLOPPY;
	media_info.dki_lbsize = fjp->fj_chars->fdc_sec_size;
	media_info.dki_capacity = fjp->fj_chars->fdc_ncyl *
	    fjp->fj_chars->fdc_secptrack * fjp->fj_chars->fdc_nhead;

	if (ddi_copyout(&media_info, buf, sizeof (struct dk_minfo), flag))
		err = EFAULT;
	return (err);
}