OpenSolaris_b135/uts/common/io/fd.c
/*
* 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);
}