Home | History | Annotate | Line # | Download | only in scsipi
sd.c revision 1.74
      1  1.74  mycroft /*	$NetBSD: sd.c,v 1.74 1995/08/05 23:48:55 mycroft Exp $	*/
      2  1.33      cgd 
      3   1.1      cgd /*
      4  1.65  mycroft  * Copyright (c) 1994, 1995 Charles M. Hannum.  All rights reserved.
      5  1.25  mycroft  *
      6  1.25  mycroft  * Redistribution and use in source and binary forms, with or without
      7  1.25  mycroft  * modification, are permitted provided that the following conditions
      8  1.25  mycroft  * are met:
      9  1.25  mycroft  * 1. Redistributions of source code must retain the above copyright
     10  1.25  mycroft  *    notice, this list of conditions and the following disclaimer.
     11  1.25  mycroft  * 2. Redistributions in binary form must reproduce the above copyright
     12  1.25  mycroft  *    notice, this list of conditions and the following disclaimer in the
     13  1.25  mycroft  *    documentation and/or other materials provided with the distribution.
     14  1.25  mycroft  * 3. All advertising materials mentioning features or use of this software
     15  1.25  mycroft  *    must display the following acknowledgement:
     16  1.65  mycroft  *	This product includes software developed by Charles M. Hannum.
     17  1.25  mycroft  * 4. The name of the author may not be used to endorse or promote products
     18  1.25  mycroft  *    derived from this software without specific prior written permission.
     19  1.25  mycroft  *
     20  1.25  mycroft  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     21  1.25  mycroft  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     22  1.25  mycroft  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     23  1.25  mycroft  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     24  1.25  mycroft  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     25  1.25  mycroft  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     26  1.25  mycroft  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     27  1.25  mycroft  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     28  1.25  mycroft  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     29  1.25  mycroft  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     30  1.25  mycroft  */
     31  1.25  mycroft 
     32  1.25  mycroft /*
     33  1.25  mycroft  * Originally written by Julian Elischer (julian (at) dialix.oz.au)
     34   1.8  deraadt  * for TRW Financial Systems for use under the MACH(2.5) operating system.
     35   1.1      cgd  *
     36   1.1      cgd  * TRW Financial Systems, in accordance with their agreement with Carnegie
     37   1.1      cgd  * Mellon University, makes this software available to CMU to distribute
     38   1.1      cgd  * or use in any manner that they see fit as long as this message is kept with
     39   1.1      cgd  * the software. For this reason TFS also grants any other persons or
     40   1.1      cgd  * organisations permission to use or modify this software.
     41   1.1      cgd  *
     42   1.1      cgd  * TFS supplies this software to be publicly redistributed
     43   1.1      cgd  * on the understanding that TFS is not responsible for the correct
     44   1.1      cgd  * functioning of this software in any circumstances.
     45   1.9      cgd  *
     46  1.25  mycroft  * Ported to run under 386BSD by Julian Elischer (julian (at) dialix.oz.au) Sept 1992
     47   1.1      cgd  */
     48   1.1      cgd 
     49  1.19  mycroft #include <sys/types.h>
     50  1.19  mycroft #include <sys/param.h>
     51  1.19  mycroft #include <sys/systm.h>
     52  1.54  mycroft #include <sys/kernel.h>
     53  1.19  mycroft #include <sys/conf.h>
     54  1.19  mycroft #include <sys/file.h>
     55  1.19  mycroft #include <sys/stat.h>
     56  1.19  mycroft #include <sys/ioctl.h>
     57  1.19  mycroft #include <sys/buf.h>
     58  1.19  mycroft #include <sys/uio.h>
     59  1.19  mycroft #include <sys/malloc.h>
     60  1.19  mycroft #include <sys/errno.h>
     61  1.25  mycroft #include <sys/device.h>
     62  1.19  mycroft #include <sys/disklabel.h>
     63  1.25  mycroft #include <sys/disk.h>
     64  1.19  mycroft 
     65  1.19  mycroft #include <scsi/scsi_all.h>
     66  1.19  mycroft #include <scsi/scsi_disk.h>
     67  1.19  mycroft #include <scsi/scsiconf.h>
     68   1.3  deraadt 
     69  1.25  mycroft #ifdef	DDB
     70  1.25  mycroft int     Debugger();
     71  1.25  mycroft #else	/* DDB */
     72  1.25  mycroft #define Debugger()
     73  1.25  mycroft #endif	/* DDB */
     74   1.1      cgd 
     75   1.1      cgd #define	SDOUTSTANDING	2
     76  1.25  mycroft #define	SDRETRIES	4
     77   1.1      cgd 
     78  1.36      cgd #define	SDUNIT(dev)			DISKUNIT(dev)
     79  1.36      cgd #define	SDPART(dev)			DISKPART(dev)
     80  1.36      cgd #define	MAKESDDEV(maj, unit, part)	MAKEDISKDEV(maj, unit, part)
     81  1.36      cgd 
     82  1.36      cgd #define	SDLABELDEV(dev)	(MAKESDDEV(major(dev), SDUNIT(dev), RAW_PART))
     83   1.1      cgd 
     84  1.51  mycroft struct sd_softc {
     85  1.25  mycroft 	struct device sc_dev;
     86  1.25  mycroft 	struct dkdevice sc_dk;
     87  1.25  mycroft 
     88  1.29  mycroft 	int flags;
     89  1.45  mycroft #define	SDF_LOCKED	0x01
     90  1.45  mycroft #define	SDF_WANTED	0x02
     91  1.52  mycroft #define	SDF_WLABEL	0x04		/* label is writable */
     92  1.61  mycroft #define	SDF_LABELLING	0x08		/* writing label */
     93  1.61  mycroft 	struct scsi_link *sc_link;	/* contains our targ, lun, etc. */
     94  1.25  mycroft 	struct disk_parms {
     95  1.61  mycroft 		u_char heads;		/* number of heads */
     96  1.61  mycroft 		u_short cyls;		/* number of cylinders */
     97  1.61  mycroft 		u_char sectors;		/* number of sectors/track */
     98  1.61  mycroft 		int blksize;		/* number of bytes/sector */
     99  1.25  mycroft 		u_long disksize;	/* total number sectors */
    100  1.25  mycroft 	} params;
    101  1.25  mycroft 	struct buf buf_queue;
    102  1.25  mycroft };
    103  1.25  mycroft 
    104  1.51  mycroft int sdmatch __P((struct device *, void *, void *));
    105  1.25  mycroft void sdattach __P((struct device *, struct device *, void *));
    106  1.25  mycroft 
    107  1.25  mycroft struct cfdriver sdcd = {
    108  1.51  mycroft 	NULL, "sd", sdmatch, sdattach, DV_DISK, sizeof(struct sd_softc)
    109  1.25  mycroft };
    110  1.25  mycroft 
    111  1.51  mycroft void sdgetdisklabel __P((struct sd_softc *));
    112  1.51  mycroft int sd_get_parms __P((struct sd_softc *, int));
    113  1.25  mycroft void sdstrategy __P((struct buf *));
    114  1.51  mycroft void sdstart __P((struct sd_softc *));
    115  1.25  mycroft 
    116  1.25  mycroft struct dkdriver sddkdriver = { sdstrategy };
    117  1.25  mycroft 
    118  1.25  mycroft struct scsi_device sd_switch = {
    119  1.25  mycroft 	NULL,			/* Use default error handler */
    120  1.25  mycroft 	sdstart,		/* have a queue, served by this */
    121  1.25  mycroft 	NULL,			/* have no async handler */
    122  1.25  mycroft 	NULL,			/* Use default 'done' routine */
    123  1.25  mycroft };
    124   1.1      cgd 
    125  1.51  mycroft struct scsi_inquiry_pattern sd_patterns[] = {
    126  1.51  mycroft 	{T_DIRECT, T_FIXED,
    127  1.51  mycroft 	 "",         "",                 ""},
    128  1.51  mycroft 	{T_DIRECT, T_REMOV,
    129  1.51  mycroft 	 "",         "",                 ""},
    130  1.60  mycroft 	{T_OPTICAL, T_FIXED,
    131  1.60  mycroft 	 "",         "",                 ""},
    132  1.60  mycroft 	{T_OPTICAL, T_REMOV,
    133  1.60  mycroft 	 "",         "",                 ""},
    134  1.51  mycroft };
    135  1.51  mycroft 
    136  1.51  mycroft int
    137  1.51  mycroft sdmatch(parent, match, aux)
    138  1.51  mycroft 	struct device *parent;
    139  1.51  mycroft 	void *match, *aux;
    140  1.51  mycroft {
    141  1.51  mycroft 	struct cfdata *cf = match;
    142  1.51  mycroft 	struct scsibus_attach_args *sa = aux;
    143  1.51  mycroft 	int priority;
    144  1.51  mycroft 
    145  1.51  mycroft 	(void)scsi_inqmatch(sa->sa_inqbuf,
    146  1.51  mycroft 	    (caddr_t)sd_patterns, sizeof(sd_patterns)/sizeof(sd_patterns[0]),
    147  1.51  mycroft 	    sizeof(sd_patterns[0]), &priority);
    148  1.51  mycroft 	return (priority);
    149  1.51  mycroft }
    150  1.51  mycroft 
    151   1.3  deraadt /*
    152   1.3  deraadt  * The routine called by the low level scsi routine when it discovers
    153  1.25  mycroft  * a device suitable for this driver.
    154   1.3  deraadt  */
    155  1.25  mycroft void
    156  1.25  mycroft sdattach(parent, self, aux)
    157  1.25  mycroft 	struct device *parent, *self;
    158  1.25  mycroft 	void *aux;
    159   1.1      cgd {
    160  1.51  mycroft 	struct sd_softc *sd = (void *)self;
    161  1.25  mycroft 	struct disk_parms *dp = &sd->params;
    162  1.51  mycroft 	struct scsibus_attach_args *sa = aux;
    163  1.51  mycroft 	struct scsi_link *sc_link = sa->sa_sc_link;
    164  1.25  mycroft 
    165  1.25  mycroft 	SC_DEBUG(sc_link, SDEV_DB2, ("sdattach: "));
    166  1.25  mycroft 
    167  1.25  mycroft 	/*
    168  1.25  mycroft 	 * Store information needed to contact our base driver
    169  1.25  mycroft 	 */
    170  1.25  mycroft 	sd->sc_link = sc_link;
    171  1.25  mycroft 	sc_link->device = &sd_switch;
    172  1.46  mycroft 	sc_link->device_softc = sd;
    173  1.51  mycroft 	if (sc_link->openings > SDOUTSTANDING)
    174  1.51  mycroft 		sc_link->openings = SDOUTSTANDING;
    175   1.3  deraadt 
    176  1.25  mycroft 	sd->sc_dk.dk_driver = &sddkdriver;
    177  1.25  mycroft #if !defined(i386) || defined(NEWCONFIG)
    178  1.25  mycroft 	dk_establish(&sd->sc_dk, &sd->sc_dev);
    179  1.25  mycroft #endif
    180   1.3  deraadt 
    181   1.3  deraadt 	/*
    182   1.3  deraadt 	 * Use the subdriver to request information regarding
    183   1.3  deraadt 	 * the drive. We cannot use interrupts yet, so the
    184   1.3  deraadt 	 * request must specify this.
    185   1.3  deraadt 	 */
    186  1.59  mycroft 	if (scsi_start(sd->sc_link, SSS_START,
    187  1.55  mycroft 	    SCSI_AUTOCONF | SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE | SCSI_SILENT) ||
    188  1.51  mycroft 	    sd_get_parms(sd, SCSI_AUTOCONF) != 0)
    189  1.51  mycroft 		printf(": drive offline\n");
    190  1.51  mycroft 	else
    191  1.51  mycroft 	        printf(": %dMB, %d cyl, %d head, %d sec, %d bytes/sec\n",
    192  1.51  mycroft 		    dp->disksize / (1048576 / dp->blksize), dp->cyls,
    193  1.51  mycroft 		    dp->heads, dp->sectors, dp->blksize);
    194   1.1      cgd }
    195   1.1      cgd 
    196  1.65  mycroft /*
    197  1.65  mycroft  * Wait interruptibly for an exclusive lock.
    198  1.65  mycroft  *
    199  1.65  mycroft  * XXX
    200  1.65  mycroft  * Several drivers do this; it should be abstracted and made MP-safe.
    201  1.65  mycroft  */
    202  1.61  mycroft int
    203  1.65  mycroft sdlock(sd)
    204  1.61  mycroft 	struct sd_softc *sd;
    205  1.61  mycroft {
    206  1.61  mycroft 	int error;
    207  1.61  mycroft 
    208  1.61  mycroft 	while ((sd->flags & SDF_LOCKED) != 0) {
    209  1.61  mycroft 		sd->flags |= SDF_WANTED;
    210  1.61  mycroft 		if ((error = tsleep(sd, PRIBIO | PCATCH, "sdlck", 0)) != 0)
    211  1.61  mycroft 			return error;
    212  1.61  mycroft 	}
    213  1.65  mycroft 	sd->flags |= SDF_LOCKED;
    214  1.61  mycroft 	return 0;
    215  1.61  mycroft }
    216  1.61  mycroft 
    217  1.65  mycroft /*
    218  1.65  mycroft  * Unlock and wake up any waiters.
    219  1.65  mycroft  */
    220  1.61  mycroft void
    221  1.61  mycroft sdunlock(sd)
    222  1.61  mycroft 	struct sd_softc *sd;
    223  1.61  mycroft {
    224  1.61  mycroft 
    225  1.61  mycroft 	sd->flags &= ~SDF_LOCKED;
    226  1.61  mycroft 	if ((sd->flags & SDF_WANTED) != 0) {
    227  1.61  mycroft 		sd->flags &= ~SDF_WANTED;
    228  1.61  mycroft 		wakeup(sd);
    229  1.61  mycroft 	}
    230  1.61  mycroft }
    231  1.61  mycroft 
    232   1.3  deraadt /*
    233  1.25  mycroft  * open the device. Make sure the partition info is a up-to-date as can be.
    234   1.3  deraadt  */
    235   1.3  deraadt int
    236  1.45  mycroft sdopen(dev, flag, fmt)
    237  1.25  mycroft 	dev_t dev;
    238  1.37  mycroft 	int flag, fmt;
    239   1.1      cgd {
    240  1.51  mycroft 	struct sd_softc *sd;
    241  1.25  mycroft 	struct scsi_link *sc_link;
    242  1.65  mycroft 	int unit, part;
    243  1.65  mycroft 	int error;
    244   1.1      cgd 
    245  1.25  mycroft 	unit = SDUNIT(dev);
    246  1.25  mycroft 	if (unit >= sdcd.cd_ndevs)
    247   1.3  deraadt 		return ENXIO;
    248  1.25  mycroft 	sd = sdcd.cd_devs[unit];
    249  1.29  mycroft 	if (!sd)
    250   1.3  deraadt 		return ENXIO;
    251   1.3  deraadt 
    252  1.25  mycroft 	sc_link = sd->sc_link;
    253  1.25  mycroft 
    254  1.25  mycroft 	SC_DEBUG(sc_link, SDEV_DB1,
    255  1.25  mycroft 	    ("sdopen: dev=0x%x (unit %d (of %d), partition %d)\n", dev, unit,
    256  1.25  mycroft 	    sdcd.cd_ndevs, part));
    257   1.3  deraadt 
    258  1.65  mycroft 	if (error = sdlock(sd))
    259  1.61  mycroft 		return error;
    260  1.45  mycroft 
    261  1.47  mycroft 	if (sd->sc_dk.dk_openmask != 0) {
    262  1.47  mycroft 		/*
    263  1.47  mycroft 		 * If any partition is open, but the disk has been invalidated,
    264  1.47  mycroft 		 * disallow further opens.
    265  1.47  mycroft 		 */
    266  1.66  mycroft 		if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
    267  1.66  mycroft 			error = EIO;
    268  1.66  mycroft 			goto bad3;
    269  1.66  mycroft 		}
    270  1.47  mycroft 	} else {
    271  1.55  mycroft 		/* Check that it is still responding and ok. */
    272  1.55  mycroft 		if (error = scsi_test_unit_ready(sc_link,
    273  1.55  mycroft 		    SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE | SCSI_IGNORE_NOT_READY))
    274  1.57  mycroft 			goto bad3;
    275  1.57  mycroft 
    276  1.57  mycroft 		/* Start the pack spinning if necessary. */
    277  1.59  mycroft 		if (error = scsi_start(sc_link, SSS_START,
    278  1.57  mycroft 		    SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE | SCSI_SILENT))
    279  1.57  mycroft 			goto bad3;
    280  1.57  mycroft 
    281  1.57  mycroft 		sc_link->flags |= SDEV_OPEN;
    282  1.48  mycroft 
    283  1.45  mycroft 		/* Lock the pack in. */
    284  1.55  mycroft 		if (error = scsi_prevent(sc_link, PR_PREVENT,
    285  1.55  mycroft 		    SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE))
    286  1.55  mycroft 			goto bad;
    287  1.54  mycroft 
    288  1.45  mycroft 		if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
    289  1.45  mycroft 			sc_link->flags |= SDEV_MEDIA_LOADED;
    290   1.3  deraadt 
    291  1.45  mycroft 			/* Load the physical device parameters. */
    292  1.45  mycroft 			if (sd_get_parms(sd, 0) != 0) {
    293  1.45  mycroft 				error = ENXIO;
    294  1.45  mycroft 				goto bad2;
    295  1.45  mycroft 			}
    296  1.45  mycroft 			SC_DEBUG(sc_link, SDEV_DB3, ("Params loaded "));
    297  1.45  mycroft 
    298  1.45  mycroft 			/* Load the partition info if not already loaded. */
    299  1.45  mycroft 			sdgetdisklabel(sd);
    300  1.45  mycroft 			SC_DEBUG(sc_link, SDEV_DB3, ("Disklabel loaded "));
    301  1.45  mycroft 		}
    302  1.65  mycroft 	}
    303  1.25  mycroft 
    304  1.65  mycroft 	part = SDPART(dev);
    305  1.63  mycroft 
    306  1.47  mycroft 	/* Check that the partition exists. */
    307  1.37  mycroft 	if (part != RAW_PART &&
    308  1.37  mycroft 	    (part >= sd->sc_dk.dk_label.d_npartitions ||
    309  1.37  mycroft 	     sd->sc_dk.dk_label.d_partitions[part].p_fstype == FS_UNUSED)) {
    310  1.25  mycroft 		error = ENXIO;
    311  1.25  mycroft 		goto bad;
    312   1.1      cgd 	}
    313   1.3  deraadt 
    314  1.37  mycroft 	/* Insure only one open at a time. */
    315  1.37  mycroft 	switch (fmt) {
    316  1.37  mycroft 	case S_IFCHR:
    317  1.40  mycroft 		sd->sc_dk.dk_copenmask |= (1 << part);
    318  1.37  mycroft 		break;
    319  1.37  mycroft 	case S_IFBLK:
    320  1.40  mycroft 		sd->sc_dk.dk_bopenmask |= (1 << part);
    321  1.37  mycroft 		break;
    322   1.1      cgd 	}
    323  1.40  mycroft 	sd->sc_dk.dk_openmask = sd->sc_dk.dk_copenmask | sd->sc_dk.dk_bopenmask;
    324  1.37  mycroft 
    325  1.25  mycroft 	SC_DEBUG(sc_link, SDEV_DB3, ("open complete\n"));
    326  1.65  mycroft 	sdunlock(sd);
    327   1.3  deraadt 	return 0;
    328   1.1      cgd 
    329  1.45  mycroft bad2:
    330  1.45  mycroft 	sc_link->flags &= ~SDEV_MEDIA_LOADED;
    331  1.45  mycroft 
    332  1.25  mycroft bad:
    333  1.40  mycroft 	if (sd->sc_dk.dk_openmask == 0) {
    334  1.51  mycroft 		scsi_prevent(sc_link, PR_ALLOW,
    335  1.55  mycroft 		    SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_MEDIA_CHANGE);
    336  1.25  mycroft 		sc_link->flags &= ~SDEV_OPEN;
    337  1.65  mycroft 	}
    338  1.45  mycroft 
    339  1.57  mycroft bad3:
    340  1.65  mycroft 	sdunlock(sd);
    341  1.25  mycroft 	return error;
    342   1.1      cgd }
    343   1.1      cgd 
    344   1.3  deraadt /*
    345  1.25  mycroft  * close the device.. only called if we are the LAST occurence of an open
    346  1.25  mycroft  * device.  Convenient now but usually a pain.
    347   1.3  deraadt  */
    348  1.25  mycroft int
    349  1.37  mycroft sdclose(dev, flag, fmt)
    350  1.25  mycroft 	dev_t dev;
    351  1.37  mycroft 	int flag, fmt;
    352   1.1      cgd {
    353  1.51  mycroft 	struct sd_softc *sd = sdcd.cd_devs[SDUNIT(dev)];
    354  1.37  mycroft 	int part = SDPART(dev);
    355  1.65  mycroft 	int error;
    356  1.65  mycroft 
    357  1.65  mycroft 	if (error = sdlock(sd))
    358  1.65  mycroft 		return error;
    359  1.37  mycroft 
    360  1.37  mycroft 	switch (fmt) {
    361  1.37  mycroft 	case S_IFCHR:
    362  1.40  mycroft 		sd->sc_dk.dk_copenmask &= ~(1 << part);
    363  1.37  mycroft 		break;
    364  1.37  mycroft 	case S_IFBLK:
    365  1.40  mycroft 		sd->sc_dk.dk_bopenmask &= ~(1 << part);
    366  1.37  mycroft 		break;
    367  1.37  mycroft 	}
    368  1.40  mycroft 	sd->sc_dk.dk_openmask = sd->sc_dk.dk_copenmask | sd->sc_dk.dk_bopenmask;
    369  1.25  mycroft 
    370  1.40  mycroft 	if (sd->sc_dk.dk_openmask == 0) {
    371  1.65  mycroft 		/* XXXX Must wait for I/O to complete! */
    372  1.47  mycroft 
    373  1.51  mycroft 		scsi_prevent(sd->sc_link, PR_ALLOW,
    374  1.51  mycroft 		    SCSI_IGNORE_ILLEGAL_REQUEST | SCSI_IGNORE_NOT_READY);
    375  1.25  mycroft 		sd->sc_link->flags &= ~SDEV_OPEN;
    376   1.1      cgd 	}
    377  1.47  mycroft 
    378  1.65  mycroft 	sdunlock(sd);
    379  1.25  mycroft 	return 0;
    380   1.1      cgd }
    381   1.1      cgd 
    382   1.3  deraadt /*
    383  1.25  mycroft  * Actually translate the requested transfer into one the physical driver
    384  1.25  mycroft  * can understand.  The transfer is described by a buf and will include
    385   1.3  deraadt  * only one physical transfer.
    386   1.3  deraadt  */
    387  1.25  mycroft void
    388  1.25  mycroft sdstrategy(bp)
    389  1.25  mycroft 	struct buf *bp;
    390   1.1      cgd {
    391  1.51  mycroft 	struct sd_softc *sd = sdcd.cd_devs[SDUNIT(bp->b_dev)];
    392  1.25  mycroft 	int opri;
    393   1.1      cgd 
    394  1.25  mycroft 	SC_DEBUG(sd->sc_link, SDEV_DB2, ("sdstrategy "));
    395  1.25  mycroft 	SC_DEBUG(sd->sc_link, SDEV_DB1,
    396  1.25  mycroft 	    ("%d bytes @ blk %d\n", bp->b_bcount, bp->b_blkno));
    397  1.25  mycroft 	/*
    398  1.25  mycroft 	 * If the device has been made invalid, error out
    399  1.25  mycroft 	 */
    400  1.61  mycroft 	if ((sd->sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
    401   1.1      cgd 		bp->b_error = EIO;
    402   1.1      cgd 		goto bad;
    403   1.1      cgd 	}
    404  1.25  mycroft 	/*
    405  1.25  mycroft 	 * If it's a null transfer, return immediatly
    406  1.25  mycroft 	 */
    407   1.1      cgd 	if (bp->b_bcount == 0)
    408   1.1      cgd 		goto done;
    409  1.52  mycroft 
    410   1.3  deraadt 	/*
    411  1.52  mycroft 	 * Do bounds checking, adjust transfer. if error, process.
    412  1.52  mycroft 	 * If end of partition, just return.
    413   1.3  deraadt 	 */
    414  1.68  mycroft 	if (SDPART(bp->b_dev) != RAW_PART &&
    415  1.68  mycroft 	    bounds_check_with_label(bp, &sd->sc_dk.dk_label,
    416  1.61  mycroft 	    (sd->flags & (SDF_WLABEL|SDF_LABELLING)) != 0) <= 0)
    417  1.52  mycroft 		goto done;
    418  1.37  mycroft 
    419  1.25  mycroft 	opri = splbio();
    420   1.1      cgd 
    421  1.25  mycroft 	/*
    422  1.25  mycroft 	 * Place it in the queue of disk activities for this disk
    423  1.25  mycroft 	 */
    424  1.37  mycroft 	disksort(&sd->buf_queue, bp);
    425   1.1      cgd 
    426   1.3  deraadt 	/*
    427   1.3  deraadt 	 * Tell the device to get going on the transfer if it's
    428   1.3  deraadt 	 * not doing anything, otherwise just wait for completion
    429   1.3  deraadt 	 */
    430  1.46  mycroft 	sdstart(sd);
    431   1.1      cgd 
    432   1.1      cgd 	splx(opri);
    433   1.1      cgd 	return;
    434  1.25  mycroft 
    435   1.1      cgd bad:
    436   1.1      cgd 	bp->b_flags |= B_ERROR;
    437   1.1      cgd done:
    438  1.25  mycroft 	/*
    439  1.25  mycroft 	 * Correctly set the buf to indicate a completed xfer
    440  1.25  mycroft 	 */
    441  1.25  mycroft 	bp->b_resid = bp->b_bcount;
    442   1.1      cgd 	biodone(bp);
    443   1.1      cgd }
    444   1.1      cgd 
    445   1.3  deraadt /*
    446   1.3  deraadt  * sdstart looks to see if there is a buf waiting for the device
    447   1.3  deraadt  * and that the device is not already busy. If both are true,
    448  1.25  mycroft  * It dequeues the buf and creates a scsi command to perform the
    449  1.25  mycroft  * transfer in the buf. The transfer request will call scsi_done
    450   1.3  deraadt  * on completion, which will in turn call this routine again
    451   1.3  deraadt  * so that the next queued transfer is performed.
    452   1.3  deraadt  * The bufs are queued by the strategy routine (sdstrategy)
    453  1.25  mycroft  *
    454   1.3  deraadt  * This routine is also called after other non-queued requests
    455   1.3  deraadt  * have been made of the scsi driver, to ensure that the queue
    456   1.3  deraadt  * continues to be drained.
    457  1.25  mycroft  *
    458   1.3  deraadt  * must be called at the correct (highish) spl level
    459  1.25  mycroft  * sdstart() is called at splbio from sdstrategy and scsi_done
    460   1.3  deraadt  */
    461  1.25  mycroft void
    462  1.46  mycroft sdstart(sd)
    463  1.51  mycroft 	register struct sd_softc *sd;
    464   1.3  deraadt {
    465  1.25  mycroft 	register struct	scsi_link *sc_link = sd->sc_link;
    466  1.25  mycroft 	struct buf *bp = 0;
    467  1.25  mycroft 	struct buf *dp;
    468   1.3  deraadt 	struct scsi_rw_big cmd;
    469  1.25  mycroft 	int blkno, nblks;
    470   1.3  deraadt 	struct partition *p;
    471   1.3  deraadt 
    472  1.25  mycroft 	SC_DEBUG(sc_link, SDEV_DB2, ("sdstart "));
    473   1.3  deraadt 	/*
    474  1.25  mycroft 	 * Check if the device has room for another command
    475   1.3  deraadt 	 */
    476  1.51  mycroft 	while (sc_link->openings > 0) {
    477  1.25  mycroft 		/*
    478  1.25  mycroft 		 * there is excess capacity, but a special waits
    479  1.25  mycroft 		 * It'll need the adapter as soon as we clear out of the
    480  1.25  mycroft 		 * way and let it run (user level wait).
    481  1.25  mycroft 		 */
    482  1.25  mycroft 		if (sc_link->flags & SDEV_WAITING) {
    483  1.25  mycroft 			sc_link->flags &= ~SDEV_WAITING;
    484  1.25  mycroft 			wakeup((caddr_t)sc_link);
    485  1.25  mycroft 			return;
    486  1.25  mycroft 		}
    487   1.1      cgd 
    488  1.25  mycroft 		/*
    489  1.25  mycroft 		 * See if there is a buf with work for us to do..
    490  1.25  mycroft 		 */
    491  1.25  mycroft 		dp = &sd->buf_queue;
    492  1.25  mycroft 		if ((bp = dp->b_actf) == NULL)	/* yes, an assign */
    493  1.25  mycroft 			return;
    494  1.22  mycroft 		dp->b_actf = bp->b_actf;
    495   1.3  deraadt 
    496  1.25  mycroft 		/*
    497  1.25  mycroft 		 * If the device has become invalid, abort all the
    498  1.25  mycroft 		 * reads and writes until all files have been closed and
    499  1.51  mycroft 		 * re-opened
    500  1.25  mycroft 		 */
    501  1.61  mycroft 		if ((sc_link->flags & SDEV_MEDIA_LOADED) == 0) {
    502  1.32   chopps 			bp->b_error = EIO;
    503  1.32   chopps 			bp->b_flags |= B_ERROR;
    504  1.32   chopps 			biodone(bp);
    505  1.32   chopps 			continue;
    506  1.25  mycroft 		}
    507   1.1      cgd 
    508  1.25  mycroft 		/*
    509  1.61  mycroft 		 * We have a buf, now we should make a command
    510  1.25  mycroft 		 *
    511  1.61  mycroft 		 * First, translate the block to absolute and put it in terms
    512  1.61  mycroft 		 * of the logical blocksize of the device.
    513  1.25  mycroft 		 */
    514  1.37  mycroft 		blkno =
    515  1.37  mycroft 		    bp->b_blkno / (sd->sc_dk.dk_label.d_secsize / DEV_BSIZE);
    516  1.25  mycroft 		if (SDPART(bp->b_dev) != RAW_PART) {
    517  1.25  mycroft 			p = &sd->sc_dk.dk_label.d_partitions[SDPART(bp->b_dev)];
    518  1.25  mycroft 			blkno += p->p_offset;
    519  1.25  mycroft 		}
    520  1.38  mycroft 		nblks = howmany(bp->b_bcount, sd->sc_dk.dk_label.d_secsize);
    521   1.3  deraadt 
    522  1.25  mycroft 		/*
    523  1.25  mycroft 		 *  Fill out the scsi command
    524  1.25  mycroft 		 */
    525  1.25  mycroft 		bzero(&cmd, sizeof(cmd));
    526  1.51  mycroft 		cmd.opcode = (bp->b_flags & B_READ) ? READ_BIG : WRITE_BIG;
    527  1.69  mycroft 		cmd.addr_3 = (blkno >> 24) & 0xff;
    528  1.69  mycroft 		cmd.addr_2 = (blkno >> 16) & 0xff;
    529  1.69  mycroft 		cmd.addr_1 = (blkno >> 8) & 0xff;
    530  1.25  mycroft 		cmd.addr_0 = blkno & 0xff;
    531  1.69  mycroft 		cmd.length2 = (nblks >> 8) & 0xff;
    532  1.69  mycroft 		cmd.length1 = nblks & 0xff;
    533   1.1      cgd 
    534  1.25  mycroft 		/*
    535  1.25  mycroft 		 * Call the routine that chats with the adapter.
    536  1.25  mycroft 		 * Note: we cannot sleep as we may be an interrupt
    537  1.25  mycroft 		 */
    538  1.39  mycroft 		if (scsi_scsi_cmd(sc_link, (struct scsi_generic *)&cmd,
    539  1.39  mycroft 		    sizeof(cmd), (u_char *)bp->b_data, bp->b_bcount,
    540  1.25  mycroft 		    SDRETRIES, 10000, bp, SCSI_NOSLEEP |
    541  1.51  mycroft 		    ((bp->b_flags & B_READ) ? SCSI_DATA_IN : SCSI_DATA_OUT)))
    542  1.25  mycroft 			printf("%s: not queued", sd->sc_dev.dv_xname);
    543  1.25  mycroft 	}
    544  1.72  mycroft }
    545  1.72  mycroft 
    546  1.73      cgd u_int
    547  1.72  mycroft sdminphys(bp)
    548  1.72  mycroft 	struct buf *bp;
    549  1.72  mycroft {
    550  1.72  mycroft 	register struct sd_softc *sd = sdcd.cd_devs[SDUNIT(bp->b_dev)];
    551  1.72  mycroft 
    552  1.73      cgd 	return (sd->sc_link->adapter->scsi_minphys)(bp);
    553  1.72  mycroft }
    554  1.72  mycroft 
    555  1.72  mycroft int
    556  1.72  mycroft sdread(dev, uio)
    557  1.72  mycroft 	dev_t dev;
    558  1.72  mycroft 	struct uio *uio;
    559  1.72  mycroft {
    560  1.72  mycroft 
    561  1.72  mycroft 	return (physio(sdstrategy, NULL, dev, B_READ, sdminphys, uio));
    562  1.72  mycroft }
    563  1.72  mycroft 
    564  1.72  mycroft int
    565  1.72  mycroft sdwrite(dev, uio)
    566  1.72  mycroft 	dev_t dev;
    567  1.72  mycroft 	struct uio *uio;
    568  1.72  mycroft {
    569  1.72  mycroft 
    570  1.72  mycroft 	return (physio(sdstrategy, NULL, dev, B_WRITE, sdminphys, uio));
    571   1.1      cgd }
    572   1.3  deraadt 
    573   1.3  deraadt /*
    574   1.3  deraadt  * Perform special action on behalf of the user
    575   1.3  deraadt  * Knows about the internals of this device
    576   1.3  deraadt  */
    577  1.25  mycroft int
    578  1.51  mycroft sdioctl(dev, cmd, addr, flag, p)
    579  1.25  mycroft 	dev_t dev;
    580  1.43      cgd 	u_long cmd;
    581  1.25  mycroft 	caddr_t addr;
    582  1.25  mycroft 	int flag;
    583  1.51  mycroft 	struct proc *p;
    584   1.1      cgd {
    585  1.51  mycroft 	struct sd_softc *sd = sdcd.cd_devs[SDUNIT(dev)];
    586  1.45  mycroft 	int error;
    587   1.1      cgd 
    588  1.61  mycroft 	SC_DEBUG(sd->sc_link, SDEV_DB2, ("sdioctl 0x%lx ", cmd));
    589  1.61  mycroft 
    590  1.25  mycroft 	/*
    591  1.25  mycroft 	 * If the device is not valid.. abandon ship
    592  1.25  mycroft 	 */
    593  1.61  mycroft 	if ((sd->sc_link->flags & SDEV_MEDIA_LOADED) == 0)
    594   1.3  deraadt 		return EIO;
    595  1.45  mycroft 
    596  1.25  mycroft 	switch (cmd) {
    597   1.1      cgd 	case DIOCGDINFO:
    598  1.37  mycroft 		*(struct disklabel *)addr = sd->sc_dk.dk_label;
    599  1.25  mycroft 		return 0;
    600  1.25  mycroft 
    601   1.3  deraadt 	case DIOCGPART:
    602  1.37  mycroft 		((struct partinfo *)addr)->disklab = &sd->sc_dk.dk_label;
    603  1.37  mycroft 		((struct partinfo *)addr)->part =
    604  1.25  mycroft 		    &sd->sc_dk.dk_label.d_partitions[SDPART(dev)];
    605  1.25  mycroft 		return 0;
    606  1.25  mycroft 
    607  1.61  mycroft 	case DIOCWDINFO:
    608   1.3  deraadt 	case DIOCSDINFO:
    609   1.3  deraadt 		if ((flag & FWRITE) == 0)
    610  1.25  mycroft 			return EBADF;
    611  1.61  mycroft 
    612  1.65  mycroft 		if (error = sdlock(sd))
    613  1.61  mycroft 			return error;
    614  1.65  mycroft 		sd->flags |= SDF_LABELLING;
    615  1.61  mycroft 
    616  1.25  mycroft 		error = setdisklabel(&sd->sc_dk.dk_label,
    617  1.52  mycroft 		    (struct disklabel *)addr, /*sd->sc_dk.dk_openmask : */0,
    618  1.37  mycroft 		    &sd->sc_dk.dk_cpulabel);
    619  1.62  mycroft 		if (error == 0) {
    620  1.62  mycroft 			if (cmd == DIOCWDINFO)
    621  1.62  mycroft 				error = writedisklabel(SDLABELDEV(dev),
    622  1.62  mycroft 				    sdstrategy, &sd->sc_dk.dk_label,
    623  1.62  mycroft 				    &sd->sc_dk.dk_cpulabel);
    624  1.62  mycroft 		}
    625  1.61  mycroft 
    626  1.61  mycroft 		sd->flags &= ~SDF_LABELLING;
    627  1.61  mycroft 		sdunlock(sd);
    628  1.25  mycroft 		return error;
    629  1.25  mycroft 
    630   1.3  deraadt 	case DIOCWLABEL:
    631   1.3  deraadt 		if ((flag & FWRITE) == 0)
    632  1.25  mycroft 			return EBADF;
    633  1.37  mycroft 		if (*(int *)addr)
    634  1.37  mycroft 			sd->flags |= SDF_WLABEL;
    635  1.37  mycroft 		else
    636  1.37  mycroft 			sd->flags &= ~SDF_WLABEL;
    637  1.25  mycroft 		return 0;
    638  1.25  mycroft 
    639   1.1      cgd 	default:
    640  1.45  mycroft 		if (SDPART(dev) != RAW_PART)
    641  1.25  mycroft 			return ENOTTY;
    642  1.51  mycroft 		return scsi_do_ioctl(sd->sc_link, dev, cmd, addr, flag, p);
    643  1.25  mycroft 	}
    644  1.45  mycroft 
    645  1.25  mycroft #ifdef DIAGNOSTIC
    646  1.25  mycroft 	panic("sdioctl: impossible");
    647  1.25  mycroft #endif
    648   1.1      cgd }
    649   1.1      cgd 
    650   1.3  deraadt /*
    651   1.3  deraadt  * Load the label information on the named device
    652   1.3  deraadt  */
    653  1.45  mycroft void
    654  1.25  mycroft sdgetdisklabel(sd)
    655  1.51  mycroft 	struct sd_softc *sd;
    656   1.1      cgd {
    657  1.74  mycroft 	struct disklabel *lp = &sd->sc_dk.dk_label;
    658   1.1      cgd 	char *errstring;
    659   1.1      cgd 
    660  1.74  mycroft 	bzero(lp, sizeof(struct disklabel));
    661  1.25  mycroft 	bzero(&sd->sc_dk.dk_cpulabel, sizeof(struct cpu_disklabel));
    662  1.25  mycroft 
    663  1.74  mycroft 	lp->d_secsize = sd->params.blksize;
    664  1.74  mycroft 	lp->d_ntracks = sd->params.heads;
    665  1.74  mycroft 	lp->d_nsectors = sd->params.sectors;
    666  1.74  mycroft 	lp->d_ncylinders = sd->params.cyls;
    667  1.74  mycroft 	lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
    668  1.74  mycroft 	if (lp->d_secpercyl == 0) {
    669  1.74  mycroft 		lp->d_secpercyl = 100;
    670  1.25  mycroft 		/* as long as it's not 0 - readdisklabel divides by it (?) */
    671   1.1      cgd 	}
    672   1.1      cgd 
    673  1.74  mycroft 	strncpy(lp->d_typename, "SCSI disk", 16);
    674  1.74  mycroft 	lp->d_type = DTYPE_SCSI;
    675  1.74  mycroft 	strncpy(lp->d_packname, "fictitious", 16);
    676  1.74  mycroft 	lp->d_secperunit = sd->params.disksize;
    677  1.74  mycroft 	lp->d_rpm = 3600;
    678  1.74  mycroft 	lp->d_interleave = 1;
    679  1.74  mycroft 	lp->d_flags = 0;
    680  1.74  mycroft 
    681  1.74  mycroft 	lp->d_partitions[RAW_PART].p_offset = 0;
    682  1.74  mycroft 	lp->d_partitions[RAW_PART].p_size =
    683  1.74  mycroft 	    lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);
    684  1.74  mycroft 	lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
    685  1.74  mycroft 	lp->d_npartitions = RAW_PART + 1;
    686  1.74  mycroft 
    687  1.74  mycroft 	lp->d_magic = DISKMAGIC;
    688  1.74  mycroft 	lp->d_magic2 = DISKMAGIC;
    689  1.74  mycroft 	lp->d_checksum = dkcksum(lp);
    690  1.45  mycroft 
    691  1.25  mycroft 	/*
    692  1.25  mycroft 	 * Call the generic disklabel extraction routine
    693  1.25  mycroft 	 */
    694  1.36      cgd 	if (errstring = readdisklabel(MAKESDDEV(0, sd->sc_dev.dv_unit,
    695  1.74  mycroft 	    RAW_PART), sdstrategy, lp, &sd->sc_dk.dk_cpulabel)) {
    696  1.25  mycroft 		printf("%s: %s\n", sd->sc_dev.dv_xname, errstring);
    697  1.45  mycroft 		return;
    698   1.1      cgd 	}
    699   1.1      cgd }
    700   1.1      cgd 
    701   1.3  deraadt /*
    702   1.3  deraadt  * Find out from the device what it's capacity is
    703   1.3  deraadt  */
    704  1.51  mycroft u_long
    705  1.25  mycroft sd_size(sd, flags)
    706  1.51  mycroft 	struct sd_softc *sd;
    707  1.25  mycroft 	int flags;
    708   1.1      cgd {
    709   1.1      cgd 	struct scsi_read_cap_data rdcap;
    710   1.1      cgd 	struct scsi_read_capacity scsi_cmd;
    711  1.51  mycroft 	u_long size;
    712   1.1      cgd 
    713   1.3  deraadt 	/*
    714   1.3  deraadt 	 * make up a scsi command and ask the scsi driver to do
    715   1.3  deraadt 	 * it for you.
    716   1.3  deraadt 	 */
    717   1.1      cgd 	bzero(&scsi_cmd, sizeof(scsi_cmd));
    718  1.51  mycroft 	scsi_cmd.opcode = READ_CAPACITY;
    719   1.1      cgd 
    720   1.3  deraadt 	/*
    721   1.3  deraadt 	 * If the command works, interpret the result as a 4 byte
    722   1.3  deraadt 	 * number of blocks
    723   1.3  deraadt 	 */
    724  1.39  mycroft 	if (scsi_scsi_cmd(sd->sc_link, (struct scsi_generic *)&scsi_cmd,
    725  1.39  mycroft 	    sizeof(scsi_cmd), (u_char *)&rdcap, sizeof(rdcap), SDRETRIES,
    726  1.51  mycroft 	    2000, NULL, flags | SCSI_DATA_IN) != 0)
    727   1.3  deraadt 		return 0;
    728  1.45  mycroft 
    729  1.45  mycroft 	size = (rdcap.addr_3 << 24) + (rdcap.addr_2 << 16) +
    730  1.45  mycroft 	    (rdcap.addr_1 << 8) + rdcap.addr_0 + 1;
    731  1.45  mycroft 
    732   1.3  deraadt 	return size;
    733   1.1      cgd }
    734   1.3  deraadt 
    735   1.3  deraadt /*
    736   1.3  deraadt  * Tell the device to map out a defective block
    737   1.3  deraadt  */
    738   1.3  deraadt int
    739  1.25  mycroft sd_reassign_blocks(sd, block)
    740  1.51  mycroft 	struct sd_softc *sd;
    741  1.51  mycroft 	u_long block;
    742   1.1      cgd {
    743  1.25  mycroft 	struct scsi_reassign_blocks scsi_cmd;
    744   1.3  deraadt 	struct scsi_reassign_blocks_data rbdata;
    745   1.1      cgd 
    746   1.1      cgd 	bzero(&scsi_cmd, sizeof(scsi_cmd));
    747   1.1      cgd 	bzero(&rbdata, sizeof(rbdata));
    748  1.51  mycroft 	scsi_cmd.opcode = REASSIGN_BLOCKS;
    749   1.1      cgd 
    750   1.1      cgd 	rbdata.length_msb = 0;
    751   1.1      cgd 	rbdata.length_lsb = sizeof(rbdata.defect_descriptor[0]);
    752  1.70      cgd 	rbdata.defect_descriptor[0].dlbaddr_3 = (block >> 24) & 0xff;
    753  1.70      cgd 	rbdata.defect_descriptor[0].dlbaddr_2 = (block >> 16) & 0xff;
    754  1.70      cgd 	rbdata.defect_descriptor[0].dlbaddr_1 = (block >> 8) & 0xff;
    755  1.69  mycroft 	rbdata.defect_descriptor[0].dlbaddr_0 = block & 0xff;
    756   1.1      cgd 
    757  1.39  mycroft 	return scsi_scsi_cmd(sd->sc_link, (struct scsi_generic *)&scsi_cmd,
    758  1.39  mycroft 	    sizeof(scsi_cmd), (u_char *)&rbdata, sizeof(rbdata), SDRETRIES,
    759  1.25  mycroft 	    5000, NULL, SCSI_DATA_OUT);
    760   1.1      cgd }
    761   1.1      cgd 
    762   1.1      cgd #define b2tol(a)	(((unsigned)(a##_1) << 8) + (unsigned)a##_0 )
    763   1.1      cgd 
    764   1.3  deraadt /*
    765  1.25  mycroft  * Get the scsi driver to send a full inquiry to the * device and use the
    766  1.25  mycroft  * results to fill out the disk parameter structure.
    767   1.3  deraadt  */
    768  1.25  mycroft int
    769  1.25  mycroft sd_get_parms(sd, flags)
    770  1.51  mycroft 	struct sd_softc *sd;
    771  1.25  mycroft 	int flags;
    772   1.1      cgd {
    773  1.45  mycroft 	struct disk_parms *dp = &sd->params;
    774  1.25  mycroft 	struct scsi_mode_sense scsi_cmd;
    775   1.3  deraadt 	struct scsi_mode_sense_data {
    776  1.25  mycroft 		struct scsi_mode_header header;
    777  1.51  mycroft 		struct scsi_blk_desc blk_desc;
    778  1.25  mycroft 		union disk_pages pages;
    779   1.3  deraadt 	} scsi_sense;
    780  1.51  mycroft 	u_long sectors;
    781   1.1      cgd 
    782  1.25  mycroft 	/*
    783  1.25  mycroft 	 * do a "mode sense page 4"
    784  1.25  mycroft 	 */
    785   1.1      cgd 	bzero(&scsi_cmd, sizeof(scsi_cmd));
    786  1.51  mycroft 	scsi_cmd.opcode = MODE_SENSE;
    787  1.25  mycroft 	scsi_cmd.page = 4;
    788   1.1      cgd 	scsi_cmd.length = 0x20;
    789   1.3  deraadt 	/*
    790   1.3  deraadt 	 * If the command worked, use the results to fill out
    791   1.3  deraadt 	 * the parameter structure
    792   1.3  deraadt 	 */
    793  1.39  mycroft 	if (scsi_scsi_cmd(sd->sc_link, (struct scsi_generic *)&scsi_cmd,
    794  1.39  mycroft 	    sizeof(scsi_cmd), (u_char *)&scsi_sense, sizeof(scsi_sense),
    795  1.25  mycroft 	    SDRETRIES, 6000, NULL, flags | SCSI_DATA_IN) != 0) {
    796  1.26  mycroft 		printf("%s: could not mode sense (4)", sd->sc_dev.dv_xname);
    797  1.26  mycroft 	fake_it:
    798  1.60  mycroft 		printf("; using fictitious geometry\n");
    799  1.25  mycroft 		/*
    800  1.60  mycroft 		 * use adaptec standard fictitious geometry
    801  1.25  mycroft 		 * this depends on which controller (e.g. 1542C is
    802  1.25  mycroft 		 * different. but we have to put SOMETHING here..)
    803  1.25  mycroft 		 */
    804  1.25  mycroft 		sectors = sd_size(sd, flags);
    805  1.45  mycroft 		dp->heads = 64;
    806  1.45  mycroft 		dp->sectors = 32;
    807  1.45  mycroft 		dp->cyls = sectors / (64 * 32);
    808  1.45  mycroft 		dp->blksize = 512;
    809  1.45  mycroft 		dp->disksize = sectors;
    810   1.3  deraadt 	} else {
    811  1.25  mycroft 		SC_DEBUG(sd->sc_link, SDEV_DB3,
    812  1.25  mycroft 		    ("%d cyls, %d heads, %d precomp, %d red_write, %d land_zone\n",
    813  1.25  mycroft 		    _3btol(&scsi_sense.pages.rigid_geometry.ncyl_2),
    814  1.25  mycroft 		    scsi_sense.pages.rigid_geometry.nheads,
    815  1.25  mycroft 		    b2tol(scsi_sense.pages.rigid_geometry.st_cyl_wp),
    816  1.25  mycroft 		    b2tol(scsi_sense.pages.rigid_geometry.st_cyl_rwc),
    817  1.25  mycroft 		    b2tol(scsi_sense.pages.rigid_geometry.land_zone)));
    818   1.1      cgd 
    819   1.3  deraadt 		/*
    820  1.25  mycroft 		 * KLUDGE!! (for zone recorded disks)
    821   1.3  deraadt 		 * give a number of sectors so that sec * trks * cyls
    822  1.25  mycroft 		 * is <= disk_size
    823  1.25  mycroft 		 * can lead to wasted space! THINK ABOUT THIS !
    824   1.3  deraadt 		 */
    825  1.45  mycroft 		dp->heads = scsi_sense.pages.rigid_geometry.nheads;
    826  1.45  mycroft 		dp->cyls =
    827  1.25  mycroft 		    _3btol(&scsi_sense.pages.rigid_geometry.ncyl_2);
    828  1.45  mycroft 		dp->blksize = _3btol(scsi_sense.blk_desc.blklen);
    829  1.27  mycroft 
    830  1.53  mycroft 		if (dp->heads == 0 || dp->cyls == 0) {
    831  1.27  mycroft 			printf("%s: mode sense (4) returned nonsense",
    832  1.27  mycroft 			    sd->sc_dev.dv_xname);
    833  1.27  mycroft 			goto fake_it;
    834  1.27  mycroft 		}
    835  1.53  mycroft 
    836  1.53  mycroft 		if (dp->blksize == 0)
    837  1.53  mycroft 			dp->blksize = 512;
    838   1.1      cgd 
    839  1.25  mycroft 		sectors = sd_size(sd, flags);
    840  1.45  mycroft 		dp->disksize = sectors;
    841  1.45  mycroft 		sectors /= (dp->heads * dp->cyls);
    842  1.45  mycroft 		dp->sectors = sectors;	/* XXX dubious on SCSI */
    843   1.1      cgd 	}
    844  1.45  mycroft 
    845   1.3  deraadt 	return 0;
    846   1.1      cgd }
    847   1.1      cgd 
    848   1.3  deraadt int
    849  1.45  mycroft sdsize(dev)
    850  1.45  mycroft 	dev_t dev;
    851   1.1      cgd {
    852  1.51  mycroft 	struct sd_softc *sd;
    853  1.45  mycroft 	int part;
    854  1.45  mycroft 	int size;
    855   1.1      cgd 
    856  1.45  mycroft 	if (sdopen(dev, 0, S_IFBLK) != 0)
    857  1.25  mycroft 		return -1;
    858  1.45  mycroft 	sd = sdcd.cd_devs[SDUNIT(dev)];
    859  1.45  mycroft 	part = SDPART(dev);
    860  1.52  mycroft 	if (sd->sc_dk.dk_label.d_partitions[part].p_fstype != FS_SWAP)
    861  1.45  mycroft 		size = -1;
    862  1.45  mycroft 	else
    863  1.45  mycroft 		size = sd->sc_dk.dk_label.d_partitions[part].p_size;
    864  1.45  mycroft 	if (sdclose(dev, 0, S_IFBLK) != 0)
    865  1.25  mycroft 		return -1;
    866  1.45  mycroft 	return size;
    867   1.3  deraadt }
    868   1.3  deraadt 
    869  1.71      cgd #ifndef __BDEVSW_DUMP_OLD_TYPE
    870  1.71      cgd /* #define SD_DUMP_NOT_TRUSTED if you just want to watch */
    871  1.25  mycroft static struct scsi_xfer sx;
    872  1.71      cgd static int sddoingadump;
    873   1.3  deraadt 
    874   1.3  deraadt /*
    875  1.25  mycroft  * dump all of physical memory into the partition specified, starting
    876  1.25  mycroft  * at offset 'dumplo' into the partition.
    877   1.3  deraadt  */
    878   1.3  deraadt int
    879  1.71      cgd sddump(dev, blkno, va, size)
    880  1.71      cgd 	dev_t dev;
    881  1.71      cgd 	daddr_t blkno;
    882  1.71      cgd 	caddr_t va;
    883  1.71      cgd 	size_t size;
    884  1.71      cgd {
    885  1.71      cgd 	struct sd_softc *sd;	/* disk unit to do the I/O */
    886  1.71      cgd 	struct disklabel *lp;	/* disk's disklabel */
    887  1.71      cgd 	int	unit, part;
    888  1.71      cgd 	int	sectorsize;	/* size of a disk sector */
    889  1.71      cgd 	int	nsects;		/* number of sectors in partition */
    890  1.71      cgd 	int	sectoff;	/* sector offset of partition */
    891  1.71      cgd 	int	totwrt;		/* total number of sectors left to write */
    892  1.71      cgd 	int	nwrt;		/* current number of sectors to write */
    893  1.71      cgd 	struct scsi_rw_big cmd;	/* write command */
    894  1.71      cgd 	struct scsi_xfer *xs;	/* ... convenience */
    895  1.25  mycroft 	int	retval;
    896  1.25  mycroft 
    897  1.71      cgd 	/* Check if recursive dump; if so, punt. */
    898  1.71      cgd 	if (sddoingadump)
    899  1.71      cgd 		return EFAULT;
    900  1.71      cgd 
    901  1.71      cgd 	/* Mark as active early. */
    902  1.71      cgd 	sddoingadump = 1;
    903   1.1      cgd 
    904  1.71      cgd 	unit = SDUNIT(dev);	/* Decompose unit & partition. */
    905  1.71      cgd 	part = SDPART(dev);
    906   1.1      cgd 
    907  1.71      cgd 	/* Check for acceptable drive number. */
    908  1.71      cgd 	if (unit >= sdcd.cd_ndevs || (sd = sdcd.cd_devs[unit]) == NULL)
    909  1.25  mycroft 		return ENXIO;
    910   1.3  deraadt 
    911  1.71      cgd 	/* Make sure it was initialized. */
    912  1.25  mycroft 	if (sd->sc_link->flags & SDEV_MEDIA_LOADED != SDEV_MEDIA_LOADED)
    913  1.25  mycroft 		return ENXIO;
    914  1.25  mycroft 
    915  1.71      cgd 	/* Convert to disk sectors.  Request must be a multiple of size. */
    916  1.71      cgd 	lp = &sd->sc_dk.dk_label;
    917  1.71      cgd 	sectorsize = lp->d_secsize;
    918  1.71      cgd 	if ((size % sectorsize) != 0)
    919  1.25  mycroft 		return EFAULT;
    920  1.71      cgd 	totwrt = size / sectorsize;
    921  1.71      cgd 	blkno = dbtob(blkno) / sectorsize;	/* blkno in DEV_BSIZE units */
    922  1.25  mycroft 
    923  1.71      cgd 	nsects = lp->d_partitions[part].p_size;
    924  1.71      cgd 	sectoff = lp->d_partitions[part].p_offset;
    925  1.25  mycroft 
    926  1.71      cgd 	/* Check transfer bounds against partition size. */
    927  1.71      cgd 	if ((blkno < 0) || ((blkno + totwrt) > nsects))
    928  1.25  mycroft 		return EINVAL;
    929  1.25  mycroft 
    930  1.71      cgd 	/* Offset block number to start of partition. */
    931  1.71      cgd 	blkno += sectoff;
    932  1.71      cgd 
    933  1.71      cgd 	xs = &sx;
    934   1.3  deraadt 
    935  1.71      cgd 	while (totwrt > 0) {
    936  1.71      cgd 		nwrt = totwrt;		/* XXX */
    937  1.71      cgd #ifndef	SD_DUMP_NOT_TRUSTED
    938  1.25  mycroft 		/*
    939  1.25  mycroft 		 *  Fill out the scsi command
    940  1.25  mycroft 		 */
    941  1.25  mycroft 		bzero(&cmd, sizeof(cmd));
    942  1.51  mycroft 		cmd.opcode = WRITE_BIG;
    943  1.69  mycroft 		cmd.addr_3 = (blkno >> 24) & 0xff;
    944  1.69  mycroft 		cmd.addr_2 = (blkno >> 16) & 0xff;
    945  1.69  mycroft 		cmd.addr_1 = (blkno >> 8) & 0xff;
    946  1.69  mycroft 		cmd.addr_0 = blkno & 0xff;
    947  1.71      cgd 		cmd.length2 = (nwrt >> 8) & 0xff;
    948  1.71      cgd 		cmd.length1 = nwrt & 0xff;
    949  1.25  mycroft 		/*
    950  1.25  mycroft 		 * Fill out the scsi_xfer structure
    951  1.25  mycroft 		 *    Note: we cannot sleep as we may be an interrupt
    952  1.25  mycroft 		 * don't use scsi_scsi_cmd() as it may want
    953  1.25  mycroft 		 * to wait for an xs.
    954  1.25  mycroft 		 */
    955  1.25  mycroft 		bzero(xs, sizeof(sx));
    956  1.51  mycroft 		xs->flags |= SCSI_AUTOCONF | INUSE;
    957  1.25  mycroft 		xs->sc_link = sd->sc_link;
    958  1.25  mycroft 		xs->retries = SDRETRIES;
    959  1.25  mycroft 		xs->timeout = 10000;	/* 10000 millisecs for a disk ! */
    960  1.39  mycroft 		xs->cmd = (struct scsi_generic *)&cmd;
    961  1.25  mycroft 		xs->cmdlen = sizeof(cmd);
    962  1.71      cgd 		xs->resid = nwrt * sectorsize;
    963  1.25  mycroft 		xs->error = XS_NOERROR;
    964  1.25  mycroft 		xs->bp = 0;
    965  1.71      cgd 		xs->data = va;
    966  1.71      cgd 		xs->datalen = nwrt * sectorsize;
    967   1.1      cgd 
    968  1.25  mycroft 		/*
    969  1.25  mycroft 		 * Pass all this info to the scsi driver.
    970  1.25  mycroft 		 */
    971  1.25  mycroft 		retval = (*(sd->sc_link->adapter->scsi_cmd)) (xs);
    972  1.51  mycroft 		if (retval != COMPLETE)
    973  1.51  mycroft 			return ENXIO;
    974  1.71      cgd #else	/* SD_DUMP_NOT_TRUSTED */
    975  1.71      cgd 		/* Let's just talk about this first... */
    976  1.71      cgd 		printf("sd%d: dump addr 0x%x, blk %d\n", unit, va, blkno);
    977  1.71      cgd 		delay(500 * 1000);	/* half a second */
    978  1.71      cgd #endif	/* SD_DUMP_NOT_TRUSTED */
    979  1.25  mycroft 
    980  1.25  mycroft 		/* update block count */
    981  1.71      cgd 		totwrt -= nwrt;
    982  1.71      cgd 		blkno += nwrt;
    983  1.71      cgd 		va += sectorsize * nwrt;
    984  1.25  mycroft 	}
    985  1.71      cgd 	sddoingadump = 0;
    986  1.25  mycroft 	return 0;
    987   1.1      cgd }
    988  1.71      cgd #else	/* __BDEVSW_DUMP_NEW_TYPE */
    989  1.25  mycroft int
    990  1.71      cgd sddump(dev, blkno, va, size)
    991  1.71      cgd 	dev_t dev;
    992  1.71      cgd 	daddr_t blkno;
    993  1.71      cgd 	caddr_t va;
    994  1.71      cgd 	size_t size;
    995   1.1      cgd {
    996  1.71      cgd 
    997  1.71      cgd 	/* Not implemented. */
    998  1.71      cgd 	return ENXIO;
    999   1.1      cgd }
   1000  1.71      cgd #endif	/* __BDEVSW_DUMP_NEW_TYPE */
   1001