Initial source

1 files changed, 1701 insertions, 0 deletions

diff --git a/i386/i386at/fd.c b/i386/i386at/fd.c
new file mode 100644
index 0000000..773411b
--- /dev/null
+++ b/i386/i386at/fd.c
@@ -0,0 +1,1701 @@
+/* 
+ * Mach Operating System
+ * Copyright (c) 1993,1991,1990,1989 Carnegie Mellon University
+ * All Rights Reserved.
+ * 
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation is hereby granted, provided that both the copyright
+ * notice and this permission notice appear in all copies of the
+ * software, derivative works or modified versions, and any portions
+ * thereof, and that both notices appear in supporting documentation.
+ * 
+ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
+ * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ * 
+ * Carnegie Mellon requests users of this software to return to
+ * 
+ *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
+ *  School of Computer Science
+ *  Carnegie Mellon University
+ *  Pittsburgh PA 15213-3890
+ * 
+ * any improvements or extensions that they make and grant Carnegie Mellon
+ * the rights to redistribute these changes.
+ */
+/*
+  Copyright 1988, 1989 by Intel Corporation, Santa Clara, California.
+
+		All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and
+its documentation for any purpose and without fee is hereby
+granted, provided that the above copyright notice appears in all
+copies and that both the copyright notice and this permission notice
+appear in supporting documentation, and that the name of Intel
+not be used in advertising or publicity pertaining to distribution
+of the software without specific, written prior permission.
+
+INTEL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
+IN NO EVENT SHALL INTEL BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
+NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+/*	Copyright (c) 1987, 1988 TOSHIBA Corp.		*/
+/*		All Rights Reserved			*/
+
+#if 0
+
+#include <fd.h>
+
+#ifdef	MACH_KERNEL
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <device/buf.h>
+#include <device/errno.h>
+#else	MACH_KERNEL
+#include <sys/buf.h>
+#include <sys/errno.h>
+#include <sys/user.h>
+#include <sys/ioctl.h>
+#endif	MACH_KERNEL
+#include <i386/pio.h>
+#include <i386/machspl.h>
+#include <chips/busses.h>
+#include <i386at/fdreg.h>
+#include <i386at/disk.h>
+#include <vm/vm_kern.h>
+
+#ifdef	DEBUG
+#define D(x) x
+#define DD(x) x
+#else	/* DEBUG */
+#define D(x)
+#define DD(x)
+#endif	/* DEBUG */
+
+/*
+ * Floppy Device-Table Definitions (drtabs)
+ *
+ *      Cyls,Sec,spc,part,Mtype,RWFpl,FGpl
+ */
+struct	fddrtab m765f[] = {			/* format table */
+	80, 18, 1440,  9, 0x88, 0x2a, 0x50,	/* [0] 3.50" 720  Kb  */
+	80, 36, 2880, 18, 0x08, 0x1b, 0x6c,	/* [1] 3.50" 1.44 Meg */
+	40, 18,  720,  9, 0xa8, 0x2a, 0x50,	/* [2] 5.25" 360  Kb  */
+	80, 30, 2400, 15, 0x08, 0x1b, 0x54	/* [3] 5.25" 1.20 Meg */
+};
+
+/*
+ * The following are static initialization variables
+ * which are based on the configuration.
+ */
+struct ctrl_info ctrl_info[MAXUNIT>>1] = {		/* device data table */
+	{  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ,
+	{  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+};
+
+struct unit_info unit_info[MAXUNIT];		/* unit buffer headers	*/
+
+char *fderr = "FD Error on unit";
+char *fdmsg[] = {
+	"?",
+	"Missing data address mark",
+	"Write protected",
+	"Sector not found",
+	"Data Overrun",				/* Over run error */
+	"Uncorrectable data read error",	/* CRC Error */
+	"FDC Error",
+	"Illegal format type",
+	"Drive not ready",
+	"diskette not present - please insert",
+	"Illegal interrupt type"
+};
+
+struct buf	fdrbuf[MAXUNIT];	/* data transfer buffer structures */
+
+int	fdminphys();
+int	fdintr(), fdprobe(), fdslave();
+void	fdattach();
+int	FdDmaEISA = 0;
+int	FdDmaThreshold = 16 * 1024 * 1024;
+vm_offset_t	FdDmaPage = (vm_offset_t) 0;
+vm_offset_t	fd_std[NFD] = { 0 };
+struct	bus_device *fd_dinfo[NFD*2];
+struct	bus_ctlr *fd_minfo[NFD];
+struct	bus_driver	fddriver = 
+	{fdprobe, fdslave, fdattach, 0, fd_std, "fd", fd_dinfo, "fdc", fd_minfo, 0};
+
+int	m765verify[MAXUNIT] = {1,1,1,1};	/* write after read flag */
+						/* 0 != verify mode	*/ 
+						/* 0 == not verify mode */
+#ifdef	MACH_KERNEL
+extern struct buf *geteblk();
+#endif	MACH_KERNEL
+
+#define trfrate(uip, type)   outb(VFOREG(uip->addr),(((type)&RATEMASK)>>6))
+#define rbskrate(uip, type)  trfrate(uip,(type)&RAPID?RPSEEK:NMSEEK)
+#define getparm(type)   ((type<0||type>3)?(struct fddrtab *)ERROR:&m765f[type])
+#define relative(s1,s2) ((s1)>(s2)?(s1)-(s2):(s2)-(s1))
+
+fdprobe(port, ctlr)
+struct bus_ctlr *ctlr;
+{
+	int			spot = STSREG((int) ctlr->address);
+	struct ctrl_info	*cip = &ctrl_info[ctlr->unit];
+	int			i, in;
+
+	outb(spot, DATAOK);
+	for (i = 1000; i--;) {
+		in = inb(spot);
+		if ((in&DATAOK) == DATAOK && !(in&0x0f)) {
+			take_ctlr_irq(ctlr);
+			cip->b_cmd.c_rbmtr = 0;		/* recalibrate/moter flag */
+			cip->b_cmd.c_intr = CMDRST;	/* interrupt flag */
+			cip->b_unitf = 0;
+			cip->b_uip = 0;
+			cip->b_rwerr = cip->b_seekerr = cip->b_rberr = 0;
+			cip->usebuf = 0;
+			if (FdDmaPage) {
+				cip->b_pbuf = FdDmaPage + PAGE_SIZE * ctlr->unit;
+				if (kmem_alloc_pageable(kernel_map,
+					       (vm_offset_t *)&cip->b_vbuf,
+					       PAGE_SIZE) != KERN_SUCCESS) {
+					printf("%s%d: can not kmem_alloc_pageable.\n",
+						ctlr->name, ctlr->unit);
+					return 0;
+				}
+				(void)pmap_map(cip->b_vbuf,
+					       (vm_offset_t)cip->b_pbuf, 
+					       (vm_offset_t)cip->b_pbuf+PAGE_SIZE,
+					       VM_PROT_READ | VM_PROT_WRITE);
+			}
+			printf("%s%d: port = %x, spl = %d, pic = %d.\n", ctlr->name,
+				ctlr->unit, ctlr->address, ctlr->sysdep, ctlr->sysdep1);
+			return(1);
+		}
+	}
+	return(0);
+}
+
+fdslave(dev, xxxx)
+struct bus_device		*dev;
+{
+	return(1);	/* gross hack */
+}
+
+void fdattach(dev)
+struct bus_device *dev;
+{
+	struct unit_info	*uip = &unit_info[dev->unit];
+	struct ctrl_info	*cip = &ctrl_info[dev->ctlr];
+
+	uip->dev = dev;
+	dev->address = dev->mi->address;
+	uip->addr = dev->address;
+	uip->b_cmd = &cip->b_cmd;
+	uip->b_seekaddr = 0;
+	uip->av_forw = 0;
+	uip->wakeme = 0;
+	if (cip->b_unitf) {
+		uip->b_unitf=cip->b_unitf->b_unitf;
+		cip->b_unitf->b_unitf=uip;
+	} else {
+		uip->b_unitf=uip;
+		cip->b_unitf=uip;
+	}
+	uip->d_drtab.dr_type &= ~OKTYPE; 
+
+	printf(", port = %x, spl = %d, pic = %d.",
+		dev->address, dev->sysdep, dev->sysdep1);
+
+	rstout(uip);
+	specify(uip);
+}
+/*****************************************************************************
+ *
+ * TITLE:	fdopen
+ *
+ * ABSTRACT:	Open a unit. 
+ *
+ ****************************************************************************/
+fdopen(dev, flag, otyp)
+dev_t	dev;
+int	flag;			/* not used */
+int	otyp;			/* not used */
+{
+	struct fddrtab		*driv;
+	struct buf		*wbp;
+	spl_t			x = SPL();
+	int			error = 0;
+	int			unit = UNIT(dev);
+	struct unit_info	*uip = &unit_info[unit];
+	int			slave = uip->dev->slave;
+	struct ctrl_info	*cip = &ctrl_info[uip->dev->ctlr];
+	struct	fdcmd		*cmdp = uip->b_cmd;
+	if (unit < MAXUNIT){
+	  /* Since all functions that use this are called from open, we only
+	     set this once, right here. */
+	  	rstout(uip);
+		cip->b_wup = uip;
+		openchk(cmdp);
+		cmdp->c_devflag |= FDMCHK;
+		chkbusy(cmdp);
+		cmdp->c_stsflag |= MTRFLAG;
+		mtr_on(uip);
+		if(inb(VFOREG(uip->addr))&OPENBIT || 
+		   !(uip->d_drtab.dr_type&OKTYPE)){
+			uip->d_drtab.dr_type &= ~OKTYPE;
+			if(!rbrate(RAPID, uip))
+				fdseek(RAPID, uip, 2);
+			if(inb(VFOREG(uip->addr))&OPENBIT)
+				error = ENXIO;
+		}
+		cmdp->c_stsflag &= ~MTRFLAG;
+		mtr_on(uip);
+		openfre(cmdp);
+		if(!error && !(uip->d_drtab.dr_type & OKTYPE)) {
+			if (MEDIATYPE(dev)>3)
+				goto endopen;
+			driv = &m765f[MEDIATYPE(dev)];
+			wbp = geteblk(BLKSIZE);
+			m765sweep(uip, driv);
+			cmdp->c_rbmtr &= ~(1<<(RBSHIFT+(slave)));
+			++cip->b_rwerr;
+			wbp->b_dev = dev; wbp->b_error = 0; wbp->b_resid = 0;
+			wbp->b_flags = (B_READ|B_VERIFY); wbp->b_bcount = 512;
+			wbp->b_pfcent = 2*driv->dr_spc + driv->dr_nsec - 1;
+			setqueue(wbp, uip);
+			biowait(wbp);
+			brelse(wbp);
+			error = 0;
+			uip->d_drtab.dr_type |= OKTYPE;
+		}
+	} else
+		error = ENXIO;
+      endopen:
+	splx(x);
+	return(error);
+}
+/*****************************************************************************
+ *
+ * TITLE:	fdclose
+ *
+ * ABSTRACT:	Close a unit.
+ *
+ *	Called on last close. mark the unit closed and not-ready.
+ *
+ * 	Unix doesn't actually "open" an inode for rootdev, swapdev or pipedev.
+ *	If UNIT(swapdev) != UNIT(rootdev), then must add code in init() to 
+ *	"open" swapdev.  These	devices should never be closed.
+ *
+ *****************************************************************************/
+fdclose(dev, flag, otyp, offset)
+dev_t	dev;		/* major, minor numbers */
+int	flag;		/* not used */
+int	otyp;		/* not used */
+off_t	offset;		/* not used */
+{
+	extern			dev_t	rootdev, swapdev;
+	struct unit_info	*uip = &unit_info[UNIT(dev)];
+	spl_t s;
+
+#ifdef	MACH_KERNEL
+#else	MACH_KERNEL
+	if ((dev == rootdev) || (dev == swapdev))  /* never close these */
+		return(0);
+#endif	MACH_KERNEL
+
+	/* Clear the bit.
+	 * If last close of drive insure drtab queue is empty before returning.
+	 */
+	s = SPL();
+	while(uip->av_forw != 0) {
+		uip->wakeme = 1;
+		sleep(uip, PRIBIO);
+	}
+	splx(s);
+#ifdef	MACH_KERNEL
+	return(0);
+#else	MACH_KERNEL
+	close(0);
+#endif	MACH_KERNEL
+}
+/*****************************************************************************
+ *
+ * TITLE:	fdstrategy
+ *
+ * ABSTRACT:	Queue an I/O Request, and start it if not busy already.
+ *
+ *	Reject request if unit is not-ready.
+ *
+ *	Note:	check for not-ready done here ==> could get requests
+ *		queued prior to unit going not-ready.
+ *		not-ready status to those requests that are attempted
+ *		before a new volume is inserted.  Once a new volume is
+ *		inserted, would get good I/O's to wrong volume.
+ *
+ * CALLS:	iodone(),setqueue()
+ *
+ * CALLING ROUTINES:	fdread (indirectly, thru physio)
+ *			fdwrite (indirectly, thru physio)
+ *
+ ****************************************************************************/
+fdstrategy(bp)
+struct buf *bp;	/* buffer header */
+{
+	unsigned	        bytes_left;
+	daddr_t			secno;
+	struct unit_info	*uip = &unit_info[UNIT(bp->b_dev)];
+	struct fddrtab		*dr = &uip->d_drtab;
+	struct fddrtab		*sdr;
+
+	bp->b_error = 0;
+	/* set b_resid to b_bcount because we haven't done anything yet */
+	bp->b_resid = bp->b_bcount;
+	if (!(dr->dr_type & OKTYPE) || 
+	    ((sdr = getparm(MEDIATYPE(bp->b_dev)))==(struct fddrtab *)ERROR) ||
+	    /* wrong parameters */
+	    (sdr->dr_ncyl != dr->dr_ncyl) || (sdr->dr_nsec != dr->dr_nsec) ||
+	    ((sdr->dr_type|OKTYPE) != dr->dr_type) ||
+	    (sdr->dr_rwgpl != dr->dr_rwgpl) ||
+	    (sdr->dr_fgpl != dr->dr_fgpl)) {
+		bp->b_flags |= B_ERROR;
+		bp->b_error = EIO;
+		biodone(bp);
+		return(0);
+	}
+	/*
+	 * Figure "secno" from b_blkno. Adjust sector # for partition.
+	 *
+	 * If reading just past the end of the device, it's
+	 * End of File.  If not reading, or if read starts further in
+	 * than the first sector after the partition, it's an error.
+	 *
+	 * secno is logical blockno / # of logical blocks per sector */
+	secno = (bp->b_blkno * NBPSCTR) >> 9;
+	if (secno >= dr->p_nsec) {
+		if (!((bp->b_flags & B_READ) && (secno == dr->p_nsec))){
+			/* off the deep end */
+			bp->b_flags |= B_ERROR;
+			bp->b_error = ENXIO;
+		}
+		biodone(bp);
+		return(0);
+	}
+/* At this point, it is no longer possible to directly return from strategy.
+   We now set b_resid to the number of bytes we cannot transfer because
+   they lie beyond the end of the request's partition.  This value is 0
+   if the entire request is within the partition. */
+	bytes_left = (dr->p_nsec - secno) << 9;
+	bp->b_resid = ((bp->b_bcount<=bytes_left)?0:(bp->b_bcount-bytes_left));
+	bp->b_pfcent = secno;
+	setqueue(bp, uip);
+	return(0);
+}
+
+/***************************************************************************
+ *
+ *	set queue to buffer
+ *
+ ***************************************************************************/
+setqueue(bp, uip)
+struct buf *bp;
+struct unit_info *uip;
+{
+	spl_t			x = SPL();
+	struct ctrl_info	*cip = &ctrl_info[uip->dev->ctlr];
+	struct	fdcmd		*cmdp = uip->b_cmd;
+
+	openchk(cmdp);		/* openning check */
+	cmdp->c_devflag |= STRCHK;
+	fd_disksort(uip, bp);	/* queue the request */
+	/*
+	 * If no requests are in progress, start this one up.  Else
+	 * leave it on the queue, and fdintr will call m765io later.
+	 */
+	if(!cip->b_uip)
+		m765io(uip);
+	splx(x);
+}
+/***************************************************************************
+ *
+ *	check io_busy routine
+ *
+ ***************************************************************************/
+chkbusy(cmdp)
+struct	fdcmd	*cmdp;
+{
+	while(cmdp->c_devflag & STRCHK){
+		cmdp->c_devflag |= STRWAIT;
+		sleep(&cmdp->c_devflag,PZERO);
+	} 
+}
+/***************************************************************************
+ *
+ *	check fdopen() routine
+ *
+ ***************************************************************************/
+openchk(cmdp)
+struct	fdcmd	*cmdp;
+{
+	while(cmdp->c_devflag & FDMCHK ){
+		cmdp->c_devflag |= FDWAIT;
+		sleep(&cmdp->c_devflag,PZERO);
+	} 
+}
+/***************************************************************************
+ *
+ *	free fdopen() routine
+ *
+ ***************************************************************************/
+openfre(cmdp)
+struct	fdcmd	*cmdp;
+{
+	cmdp->c_devflag &= ~FDMCHK;
+	if(cmdp->c_devflag & FDWAIT){
+		cmdp->c_devflag &= ~FDWAIT;
+		wakeup(&cmdp->c_devflag);
+	}
+}
+/*****************************************************************************
+ *
+ * TITLE:	m765io
+ *
+ * ABSTRACT:	Start handling an I/O request.
+ *
+ ****************************************************************************/
+m765io(uip)
+struct unit_info *uip;
+{
+	extern int(m765iosub)();
+	register struct buf *bp;
+	struct ctrl_info *cip = &ctrl_info[uip->dev->ctlr];
+
+	bp = uip->av_forw; /*move bp to ctrl_info[ctrl].b_buf*/
+	cip->b_buf = bp;
+	cip->b_uip = uip;
+	cip->b_xferaddr  = bp->b_un.b_addr;
+	cip->b_xfercount = bp->b_bcount - bp->b_resid;
+	cip->b_sector    = bp->b_pfcent;
+	uip->b_cmd->c_stsflag |= MTRFLAG;
+	if(!mtr_start(uip))
+		timeout(m765iosub, uip, HZ);
+	else
+		m765iosub(uip);
+}
+/****************************************************************************
+ *
+ *	m765io subroutine
+ *
+ ****************************************************************************/
+m765iosub(uip)
+struct unit_info *uip;
+{
+	struct fddrtab		*dr = &uip->d_drtab;
+	int			startsec;
+	int			slave = uip->dev->slave;
+	struct ctrl_info	*cip = &ctrl_info[uip->dev->ctlr];
+	struct	fdcmd		*cmdp = uip->b_cmd;
+
+	rwcmdset(uip);
+	if(cip->b_buf->b_flags&B_FORMAT)
+		goto skipchk;
+	startsec = (cmdp->c_rwdata[3] * dr->dr_nsec) + cmdp->c_rwdata[4];
+	if(startsec+(cip->b_xfercount>>9)-1 > dr->dr_spc)
+		cip->b_xferdma = (dr->dr_spc-startsec+1) << 9;
+	else
+skipchk:	cip->b_xferdma = cip->b_xfercount;
+	if(!(cmdp->c_rbmtr & (1<<(RBSHIFT+slave))))
+       		cip->b_status = rbirate(uip);
+	else if(uip->b_seekaddr != cmdp->c_saddr)
+		cip->b_status = fdiseek(uip,cmdp->c_saddr);
+	else
+		cip->b_status = outicmd(uip);
+	if(cip->b_status)
+		intrerr0(uip);
+	return;
+}
+/***************************************************************************
+ *
+ *	read / write / format / verify command set to command table
+ *
+ ***************************************************************************/
+rwcmdset(uip)
+struct unit_info *uip;
+{
+	short			resid;
+	int			slave = uip->dev->slave;
+	struct ctrl_info	*cip = &ctrl_info[uip->dev->ctlr];
+	struct fdcmd		*cmdp = uip->b_cmd;
+
+	switch(cip->b_buf->b_flags&(B_FORMAT|B_VERIFY|B_READ|B_WRITE)){
+	case B_VERIFY|B_WRITE:	/* VERIFY after WRITE */
+		cmdp->c_rwdata[0] = RDMV;
+		break;
+	case B_FORMAT:
+		cmdp->c_dcount = FMTCNT; 
+		cmdp->c_rwdata[0] = FMTM;
+		cmdp->c_saddr = cip->b_sector / uip->d_drtab.dr_spc;
+		resid = cip->b_sector % uip->d_drtab.dr_spc;
+		cmdp->c_rwdata[1] = slave|((resid/uip->d_drtab.dr_nsec)<<2);
+		cmdp->c_rwdata[2] = 
+			((struct fmttbl *)cip->b_buf->b_un.b_addr)->s_type;
+		cmdp->c_rwdata[3] = uip->d_drtab.dr_nsec;
+		cmdp->c_rwdata[4] = uip->d_drtab.dr_fgpl;
+		cmdp->c_rwdata[5] = FMTDATA;
+		break;
+	case B_WRITE:
+	case B_READ:
+	case B_READ|B_VERIFY:
+		cmdp->c_dcount = RWCNT;
+		if(cip->b_buf->b_flags&B_READ)
+			if(cip->b_buf->b_flags&B_VERIFY)
+				cmdp->c_rwdata[0] = RDMV;
+			else
+				cmdp->c_rwdata[0] = RDM;
+		else
+			cmdp->c_rwdata[0] = WTM;	/* format or write */
+		resid = cip->b_sector % uip->d_drtab.dr_spc;
+		cmdp->c_rwdata[3] = resid / uip->d_drtab.dr_nsec;
+		cmdp->c_rwdata[1] = slave|(cmdp->c_rwdata[3]<<2);
+		cmdp->c_rwdata[2] = cmdp->c_saddr = 
+			cip->b_sector / uip->d_drtab.dr_spc;
+		cmdp->c_rwdata[4] = (resid % uip->d_drtab.dr_nsec) + 1;
+		cmdp->c_rwdata[5] = 2;
+		cmdp->c_rwdata[6] = uip->d_drtab.dr_nsec;
+		cmdp->c_rwdata[7] = uip->d_drtab.dr_rwgpl;
+		cmdp->c_rwdata[8] = DTL;
+		D(printf("SET %x %x C%x H%x S%x %x %x %x %x ",
+			cmdp->c_rwdata[0], cmdp->c_rwdata[1],
+			cmdp->c_rwdata[2], cmdp->c_rwdata[3],
+			cmdp->c_rwdata[4], cmdp->c_rwdata[5],
+			cmdp->c_rwdata[6], cmdp->c_rwdata[7],
+			cmdp->c_rwdata[8]));
+		break;
+	}
+}
+/*****************************************************************************
+ *
+ * TITLE:	fdread
+ *
+ * ABSTRACT:	"Raw" read.  Use physio().
+ *
+ * CALLS:	m765breakup (indirectly, thru physio)
+ *
+ ****************************************************************************/
+fdread(dev, uio)
+register dev_t	dev;
+struct uio *uio;
+{ 
+#ifdef	MACH_KERNEL
+	/* no need for page-size restriction */
+	return (block_io(fdstrategy, minphys, uio));
+#else	MACH_KERNEL
+	return(physio(fdstrategy,&fdrbuf[UNIT(dev)],dev,B_READ,fdminphys,uio));
+#endif	MACH_KERNEL
+}
+/*****************************************************************************
+ *
+ * TITLE:	fdwrite
+ *
+ * ABSTRACT:	"Raw" write.  Use physio().
+ *
+ * CALLS:	m765breakup (indirectly, thru physio)
+ *
+ ****************************************************************************/
+fdwrite(dev, uio)
+register dev_t	dev;
+struct uio *uio;
+{
+#ifdef	MACH_KERNEL
+	/* no need for page-size restriction */
+	return (block_io(fdstrategy, minphys, uio));
+#else	MACH_KERNEL
+	return(physio(fdstrategy,&fdrbuf[UNIT(dev)],dev,B_WRITE,fdminphys,uio));
+#endif	MACH_KERNEL
+}
+/*****************************************************************************
+ *
+ * TITLE:	fdminphys
+ *
+ * ABSTRACT:	Trim buffer length if buffer-size is bigger than page size
+ *
+ * CALLS:	physio
+ *
+ ****************************************************************************/
+fdminphys(bp)
+struct buf	*bp;
+{
+	if (bp->b_bcount > PAGESIZ)
+		bp->b_bcount = PAGESIZ;
+}
+#ifdef	MACH_KERNEL
+/* IOC_OUT only and not IOC_INOUT */
+io_return_t fdgetstat(dev, flavor, data, count)
+	dev_t		dev;
+	int		flavor;
+	int *		data;		/* pointer to OUT array */
+	unsigned int	*count;		/* OUT */
+{
+	switch (flavor) {
+
+	/* Mandatory flavors */
+
+	case DEV_GET_SIZE: {
+		int ret;
+		struct disk_parms	p;
+
+		ret = fd_getparms(dev, &p);
+		if (ret) return ret;
+		data[DEV_GET_SIZE_DEVICE_SIZE] = p.dp_pnumsec * NBPSCTR;
+		data[DEV_GET_SIZE_RECORD_SIZE] = NBPSCTR;
+		*count = DEV_GET_SIZE_COUNT;
+		break;
+	}
+
+	/* Extra flavors */
+
+	case V_GETPARMS:
+		if (*count < sizeof (struct disk_parms)/sizeof (int))
+			return (D_INVALID_OPERATION);
+		*count = sizeof (struct disk_parms)/sizeof(int);
+		return (fd_getparms(dev, data));
+        default:
+		return (D_INVALID_OPERATION);
+	}
+}
+/* IOC_VOID or IOC_IN or IOC_INOUT */
+/*ARGSUSED*/
+io_return_t fdsetstat(dev, flavor, data, count)
+	dev_t		dev;
+	int		flavor;
+	int *		data;
+	unsigned int	count;
+{
+	int			unit = UNIT(dev);
+	switch (flavor) {
+	case V_SETPARMS:    /* Caller wants reset_parameters */
+		return(fd_setparms(unit,*(int *)data));
+	case V_FORMAT:
+		return(fd_format(dev,data));
+	case V_VERIFY:	/* cmdarg : 0 == no verify, 0 != verify */
+		m765verify[unit] = *(int *)data;
+		return(D_SUCCESS);
+	default:
+		return(D_INVALID_OPERATION);
+	}
+}
+
+/*
+ *      Get block size
+ */
+int
+fddevinfo(dev, flavor, info)
+dev_t   dev;
+int	flavor;
+char	*info;
+{
+	register struct	fddrtab	*dr;
+        register struct fdpart *p;
+	register int result = D_SUCCESS;
+
+	switch (flavor) {
+	case D_INFO_BLOCK_SIZE:
+		dr = &unit_info[UNIT(dev)].d_drtab;
+
+	        if(dr->dr_type & OKTYPE)
+        	        *((int *) info) =  512;
+		else
+			result = D_INVALID_OPERATION;
+
+		break;
+	default:
+		result = D_INVALID_OPERATION;
+	}
+
+        return(result);
+}
+#else	MACH_KERNEL
+/*****************************************************************************
+ *
+ * TITLE:	fdioctl
+ *
+ * ABSTRACT:	m765 driver special functions.
+ *
+ * CALLING ROUTINES:	kernel
+ *
+ ****************************************************************************/
+int 
+fdioctl(dev, cmd, cmdarg, flag)
+dev_t	dev;		/* major, minor numbers */
+int	cmd;		/* command code */
+int	*cmdarg;	/* user structure with parameters */
+int	flag;		/* not used */
+{
+	register unsigned 	unit = UNIT(dev);
+	switch (cmd) {
+	case V_SETPARMS:    /* Caller wants reset_parameters */
+		return(fd_setparms(unit,*cmdarg));
+	case V_GETPARMS:    /* Caller wants device parameters */
+		return(fd_getparms(dev,cmdarg));
+	case V_FORMAT:
+		return(fd_format(dev,cmdarg));
+	case V_VERIFY:	/* cmdarg : 0 == no verify, 0 != verify */
+		m765verify[unit] = *cmdarg;
+		return(0);
+	}
+	return(EINVAL);
+}
+#endif	MACH_KERNEL
+/****************************************************************************
+ *
+ *	set fd parameters 
+ *
+ ****************************************************************************/
+int
+fd_setparms(unit, cmdarg)
+register unsigned int unit;
+long cmdarg;
+{
+	struct fddrtab	 *fdparm;
+	spl_t		 x;
+	struct unit_info *uip = &unit_info[unit];
+	struct	fdcmd	 *cmdp = uip->b_cmd;
+
+	cmdp->c_rbmtr &= ~(1<<(RBSHIFT+uip->dev->slave));
+	if ((fdparm = getparm(MEDIATYPE(cmdarg))) == (struct fddrtab *)ERROR)
+	        return(EINVAL);
+	x = SPL();
+	openchk(cmdp);
+	cmdp->c_devflag |= FDMCHK;
+	chkbusy(cmdp);
+	m765sweep(uip, fdparm);
+	uip->d_drtab.dr_type |= OKTYPE;
+	openfre(cmdp);
+	splx(x);
+	return(0);
+}
+/****************************************************************************
+ *
+ *	get fd parameters 
+ *
+ ****************************************************************************/
+int
+fd_getparms(dev,cmdarg)
+dev_t	dev;		/* major, minor numbers */
+int	*cmdarg;
+{
+	struct disk_parms	*diskp = (struct disk_parms *)cmdarg;
+	register struct	fddrtab	*dr = &unit_info[UNIT(dev)].d_drtab;
+
+	if(dr->dr_type & OKTYPE){
+		diskp->dp_type = DPT_FLOPPY;
+		diskp->dp_heads = 2;
+		diskp->dp_sectors = dr->dr_nsec;
+		diskp->dp_pstartsec = 0;
+		diskp->dp_cyls = dr->dr_ncyl;
+		diskp->dp_pnumsec = dr->p_nsec;
+		return(0);
+	}
+	return(ENXIO);
+}
+/****************************************************************************
+ *
+ *	format command
+ *
+ ****************************************************************************/
+fd_format(dev,cmdarg)
+dev_t	dev;		/* major, minor numbers */
+int	*cmdarg;
+
+{
+	register struct buf	*bp;
+	register daddr_t	track;
+	union  io_arg		*varg;
+	u_short			num_trks;
+	register struct	fddrtab	*dr = &unit_info[UNIT(dev)].d_drtab;
+
+	if(!(dr->dr_type & OKTYPE))
+		return(EINVAL);	
+	varg = (union io_arg *)cmdarg;
+	num_trks = varg->ia_fmt.num_trks;
+	track = (daddr_t)(varg->ia_fmt.start_trk*dr->dr_nsec);
+	if((track + (num_trks*dr->dr_nsec))>dr->p_nsec)
+		return(EINVAL);
+	bp = geteblk(BLKSIZE);		/* get struct buf area */
+	while (num_trks>0) {
+		bp->b_flags &= ~B_DONE;
+		bp->b_dev = dev;
+		bp->b_error = 0; bp->b_resid = 0;
+		bp->b_flags = B_FORMAT;	
+		bp->b_bcount = dr->dr_nsec * FMTID;
+		bp->b_blkno = (daddr_t)((track << 9) / NBPSCTR);
+		if(makeidtbl(bp->b_un.b_addr,dr,
+			     varg->ia_fmt.start_trk++,varg->ia_fmt.intlv))
+			return(EINVAL);
+		fdstrategy(bp);
+		biowait(bp);
+		if(bp->b_error)
+			if((bp->b_error == (char)EBBHARD) || 
+			   (bp->b_error == (char)EBBSOFT))
+				return(EIO);
+			else
+				return(bp->b_error);
+		num_trks--;
+		track += dr->dr_nsec;
+	}
+	brelse(bp);
+	return(0);
+}
+/****************************************************************************
+ *
+ *	make id table for format
+ *
+ ****************************************************************************/
+makeidtbl(tblpt,dr,track,intlv)
+struct fmttbl *tblpt;
+struct fddrtab *dr;
+unsigned short track;
+unsigned short intlv;
+{
+	register int	i,j,secno;
+
+	if(intlv >= dr->dr_nsec)
+		return(1);
+	for(i=0; i<dr->dr_nsec; i++)
+		tblpt[i].sector = 0;
+	for(i=0,j=0,secno=1; i<dr->dr_nsec; i++){
+		tblpt[j].cyl = track >> 1;
+		tblpt[j].head = track & 1;
+		tblpt[j].sector = secno++;
+		tblpt[j].s_type = 2;
+		if((j+=intlv) < dr->dr_nsec)
+			continue;
+		for(j-=dr->dr_nsec; j < dr->dr_nsec ; j++)
+			if(!tblpt[j].sector)
+				break;
+	}
+	return(0);
+}
+/*****************************************************************************
+ *
+ * TITLE:	fdintr
+ *
+ * ABSTRACT:	Handle interrupt.
+ *
+ *	Interrupt procedure for m765 driver.  Gets status of last
+ *	operation and performs service function according to the
+ *	type of interrupt.  If it was an operation complete interrupt,
+ *	switches on the current driver state and either declares the
+ *	operation done, or starts the next operation
+ *
+ ****************************************************************************/
+fdintr(ctrl)
+int	ctrl;
+{
+	extern			int(m765intrsub)();
+	struct unit_info 	*uip = ctrl_info[ctrl].b_uip;
+	struct unit_info 	*wup = ctrl_info[ctrl].b_wup;
+	struct fdcmd		*cmdp = &ctrl_info[ctrl].b_cmd;
+	if(cmdp->c_stsflag & INTROUT)
+		untimeout(fdintr, ctrl);
+	cmdp->c_stsflag &= ~INTROUT;	
+	switch(cmdp->c_intr){
+	case RWFLAG:
+		rwintr(uip);
+		break;	
+	case SKFLAG:
+	case SKEFLAG|SKFLAG:
+	case RBFLAG:
+		timeout(m765intrsub, uip, SEEKWAIT);
+		break;
+	case WUPFLAG:
+		cmdp->c_intr &= ~WUPFLAG;
+		wakeup(wup);
+	}
+	return(0);
+}
+/*****************************************************************************
+ *
+ *	interrup subroutine (seek recalibrate)
+ *
+ *****************************************************************************/
+m765intrsub(uip)
+struct unit_info *uip;
+{
+	struct ctrl_info *cip = &ctrl_info[uip->dev->ctlr];
+
+	if((cip->b_status = sis(uip))!=  ST0OK)
+		switch(uip->b_cmd->c_intr){
+		case SKFLAG:
+			seekintr(uip);
+			break;
+		case SKEFLAG|SKFLAG:
+			seekintre(uip);
+			break;
+		case RBFLAG:
+			rbintr(uip);
+		}
+}
+/*****************************************************************************
+ *
+ *	read / write / format / verify interrupt routine
+ *
+ *****************************************************************************/
+rwintr(uip)
+struct unit_info *uip;
+{
+	int			rsult[7];
+	register int		rtn, count;
+	struct ctrl_info	*cip = &ctrl_info[uip->dev->ctlr];
+	struct fdcmd		*cmdp = uip->b_cmd;
+
+	cmdp->c_intr &= ~RWFLAG;
+	if((cip->b_buf->b_flags&(B_READ|B_VERIFY))!=(B_READ|B_VERIFY))
+		if(inb(VFOREG(uip->addr))&OPENBIT){
+			if(cip->b_buf->b_flags&B_FORMAT){
+				cip->b_status = TIMEOUT;
+				intrerr0(uip);
+			} else {
+				if((inb(STSREG(uip->addr))&ST0OK)!=ST0OK)
+					printf("%s %d : %s\n",
+						fderr,
+						uip-unit_info,
+						fdmsg[DOORERR]);
+				rstout(uip);
+				specify(uip);
+				cmdp->c_rbmtr &= RBRST;
+				cmdp->c_intr |= SKEFLAG;
+				if(cmdp->c_saddr > 2)
+					fdiseek(uip, cmdp->c_saddr-2);
+				else
+					fdiseek(uip, cmdp->c_saddr+2);
+			}
+			return;
+		}
+	for( count = 0 ; count < 7 ; count++ ){
+		if(rtn = fdc_sts(FD_ISTS, uip))	/* status check */
+			goto rwend;
+		rsult[count] = inb(DATAREG(uip->addr));
+	}
+	rtn = 0;
+	if(rsult[0]&0xc0){
+		rtn = cmdp->c_rwdata[0]<<8;
+		if(rsult[0]&0x80){ rtn |= FDCERR;   goto rwend; }
+		if(rsult[1]&0x80){ rtn |= NOREC;    goto rwend; }
+		if(rsult[1]&0x20){ rtn |= CRCERR;   goto rwend; }
+		if(rsult[1]&0x10){ rtn |= OVERRUN;  goto rwend; }
+		if(rsult[1]&0x04){ rtn |= NOREC;    goto rwend; }
+		if(rsult[1]&0x02){ rtn |= WTPRT;    goto rwend; }
+		if(rsult[1]&0x01){ rtn |= ADDRERR;  goto rwend; }
+		rtn |= FDCERR;
+rwend:		outb(0x0a, 0x06);
+	}
+	if(cip->b_status = rtn) {
+		D(printf("\n->rwierr %x ", rtn));
+		rwierr(uip);
+	} else { /* write command */
+		if(((cip->b_buf->b_flags&(B_FORMAT|B_READ|B_WRITE))==B_WRITE) 
+		   && !(cip->b_buf->b_flags & B_VERIFY)) {
+			D(printf("->w/v "));
+			cip->b_buf->b_flags |= B_VERIFY;
+			rwcmdset(uip);
+			if(cip->b_status = outicmd(uip))
+				intrerr0(uip);
+			return;
+		}
+		/* clear retry count */
+		if (cip->usebuf) {
+			bcopy(cip->b_vbuf, cip->b_xferaddr, cip->b_xferdma);
+			DD(printf("R(%x, %x, %x)\n",
+				cip->b_vbuf, cip->b_xferaddr, cip->b_xferdma));
+		}
+		cip->b_buf->b_flags &= ~B_VERIFY;
+		cip->b_rwerr = cip->b_seekerr = cip->b_rberr = 0;
+		cip->b_xfercount -= cip->b_xferdma;
+		cip->b_xferaddr += cip->b_xferdma;
+		cip->b_sector = cip->b_sector+(cip->b_xferdma>>9);
+		D(printf("->done%s\n", cip->b_xfercount?"":"." ));
+		/* next address (cyl,head,sec) */
+		if((int)cip->b_xfercount>0)
+			m765iosub(uip);
+		else
+			quechk(uip);
+	}
+}
+/*****************************************************************************
+ *
+ *	read / write / format / verify error routine
+ *
+ *****************************************************************************/
+rwierr(uip)
+struct unit_info *uip;
+{
+	short			status;
+	struct ctrl_info	*cip = &ctrl_info[uip->dev->ctlr];
+	struct	fdcmd		*cmdp = uip->b_cmd;
+
+	D(printf("%x-%x-%x ", cip->b_rwerr&SRMASK, cip->b_rwerr&MRMASK, cip->b_rwerr&LRMASK));
+	if((cip->b_buf->b_flags&(B_READ|B_VERIFY))==(B_READ|B_VERIFY)){
+		if((cip->b_rwerr&SRMASK)<MEDIARD)
+			goto rwrtry;
+		if((cip->b_rwerr&MRMASK)<MEDIASEEK)
+			goto rwseek;
+		goto rwexit;
+	} else
+		if(cip->b_buf->b_flags&B_VERIFY){
+			cip->b_buf->b_flags &= ~B_VERIFY;
+			rwcmdset(uip);
+		}
+rwrtry:	status = cip->b_status;
+	if((++cip->b_rwerr&SRMASK)<SRETRY)
+		cip->b_status = outicmd(uip);
+	else {
+rwseek:		cip->b_rwerr = (cip->b_rwerr&RMRMASK)+MINC;
+		if((cip->b_rwerr&MRMASK)<MRETRY){
+			cmdp->c_intr |= SKEFLAG;
+			if(cmdp->c_saddr > 2)
+				cip->b_status=fdiseek(uip,cmdp->c_saddr-2);
+			else
+				cip->b_status=fdiseek(uip,cmdp->c_saddr+2);
+		} else {
+			cip->b_rwerr = (cip->b_rwerr&LRMASK)+LINC;
+			if((cip->b_rwerr&LRMASK)<LRETRY)
+       				cip->b_status=rbirate(uip);
+		}
+	}
+	if(cip->b_status){
+		D(printf("ERR->intrerr0 "));
+		cip->b_status = status;
+rwexit:		intrerr0(uip);
+	}
+}
+/*****************************************************************************
+ *
+ *	recalibrate interrupt routine
+ *
+ *****************************************************************************/
+rbintr(uip)
+struct unit_info *uip;
+{
+	struct ctrl_info	*cip = &ctrl_info[uip->dev->ctlr];
+	struct fdcmd		*cmdp = uip->b_cmd;
+
+	cmdp->c_intr &= ~RBFLAG;
+	if(cip->b_status) {
+		if(++cip->b_rberr<SRETRY)
+			cip->b_status = rbirate(uip);
+	} else {
+		cmdp->c_rbmtr |= 1<<(RBSHIFT+uip->dev->slave);
+		uip->b_seekaddr = 0;
+		cip->b_rberr = 0;
+		cip->b_status=fdiseek(uip, cmdp->c_saddr);
+	}
+	if(cip->b_status)
+		intrerr0(uip);
+}
+/******************************************************************************
+ *
+ *	seek interrupt routine
+ *
+ *****************************************************************************/
+seekintr(uip)
+struct unit_info *uip;
+{
+	struct ctrl_info	*cip = &ctrl_info[uip->dev->ctlr];
+	struct fdcmd		*cmdp = uip->b_cmd;
+
+	cmdp->c_intr &= ~SKFLAG;
+	if(cip->b_status)
+		seekierr(uip, cmdp->c_saddr);
+	else {
+		uip->b_seekaddr = cmdp->c_saddr;
+		cip->b_status = outicmd(uip);
+	}
+	if(cip->b_status)
+		intrerr0(uip);
+	else
+		cip->b_seekerr = 0;
+}
+/*****************************************************************************
+ *
+ *	seek error retry interrupt routine
+ *
+ *****************************************************************************/
+seekintre(uip)
+struct unit_info *uip;
+{
+	register char		seekpoint;
+	struct ctrl_info	*cip = &ctrl_info[uip->dev->ctlr];
+	struct fdcmd		*cmdp = uip->b_cmd;
+
+	cmdp->c_intr &= ~(SKEFLAG|SKFLAG);
+	if(cmdp->c_saddr > 2)
+		seekpoint = cmdp->c_saddr-2;
+	else
+		seekpoint = cmdp->c_saddr+2;
+	if(cip->b_status)
+		seekierr(uip, seekpoint);
+	else {
+		uip->b_seekaddr = seekpoint;
+		cip->b_status = fdiseek(uip, cmdp->c_saddr);
+	}
+	if(cip->b_status)
+		intrerr0(uip);
+	else
+		cip->b_seekerr = 0;
+}
+/*****************************************************************************
+ *
+ *	seek error routine
+ *
+ *****************************************************************************/
+seekierr(uip, seekpoint)
+struct unit_info *uip;
+register char		seekpoint;
+{
+	struct ctrl_info *cip = &ctrl_info[uip->dev->ctlr];
+
+	if((++cip->b_seekerr&SRMASK)<SRETRY)
+		cip->b_status=fdiseek(uip, seekpoint);
+	else {
+		cip->b_seekerr = (cip->b_seekerr&MRMASK) + MINC;
+		if((cip->b_seekerr&MRMASK)<MRETRY)
+			cip->b_status=rbirate(uip);
+	}
+	if(cip->b_status)
+		intrerr0(uip);
+}
+/*****************************************************************************
+ *
+ * TITLE:	m765sweep
+ *
+ * ABSTRACT:	Perform an initialization sweep.  
+ *
+ **************************************************************************/
+m765sweep(uip, cdr)
+struct unit_info *uip;
+register struct fddrtab  *cdr;	/* device initialization data */
+{
+	register struct fddrtab *dr = &uip->d_drtab;
+
+	dr->dr_ncyl = cdr->dr_ncyl;
+	dr->dr_nsec = cdr->dr_nsec;
+	dr->dr_spc  = cdr->dr_spc;
+	dr->p_nsec  = cdr->p_nsec;
+	dr->dr_type = cdr->dr_type;
+	dr->dr_rwgpl= cdr->dr_rwgpl;
+	dr->dr_fgpl = cdr->dr_fgpl;
+}
+/*****************************************************************************
+ *
+ *  TITLE:  m765disksort
+ *
+ *****************************************************************************/
+fd_disksort(uip, bp)
+struct unit_info *uip;		/*  Pointer to head of active queue	*/
+register struct buf *bp;	/*  Pointer to buffer to be inserted	*/
+{
+	register struct buf *bp2; /*  Pointer to next buffer in queue	*/
+	register struct buf *bp1; /*  Pointer where to insert buffer	*/
+
+	if (!(bp1 = uip->av_forw)) {
+		/* No other buffers to compare against */
+		uip->av_forw = bp;
+		bp->av_forw = 0;
+		return;
+	}
+	bp2 = bp1->av_forw;
+	while(bp2 && (relative(bp1->b_pfcent,bp->b_pfcent) >=
+		      relative(bp1->b_pfcent,bp2->b_pfcent))) {
+		bp1 = bp2;
+		bp2 = bp1->av_forw;
+	}
+	bp1->av_forw = bp;
+	bp->av_forw = bp2;
+}
+/*****************************************************************************
+ *
+ *	Set Interrupt error and FDC reset
+ *
+ *****************************************************************************/
+intrerr0(uip)
+struct unit_info *uip;
+{
+	struct buf		*bp; /* Pointer to next buffer in queue	*/
+	int			resid;
+	struct ctrl_info	*cip = &ctrl_info[uip->dev->ctlr];
+	struct	fdcmd		*cmdp = uip->b_cmd;
+	register struct	fddrtab *dr = &uip->d_drtab;
+
+	if((cip->b_buf->b_flags&(B_READ|B_VERIFY))!=(B_READ|B_VERIFY)){
+		resid = cip->b_xfercount = cip->b_xferdma-1-inb(DMACNT)*0x101;
+		resid = (cip->b_sector + (resid>>9)) % dr->dr_spc;
+		printf("%s %d : %s\n",
+			fderr,
+			uip->dev->slave,
+			fdmsg[cip->b_status&BYTEMASK]);
+		printf("cylinder = %d  ",cmdp->c_saddr);
+		printf("head = %d  sector = %d  byte/sec = %d\n",
+		resid / dr->dr_nsec , (resid % dr->dr_nsec)+1 , 512);
+	}
+	cip->b_rwerr = cip->b_seekerr = cip->b_rberr = 0;
+	cmdp->c_intr = CMDRST;
+	if(((cip->b_buf->b_flags&(B_READ|B_VERIFY))!=(B_READ|B_VERIFY)) &&
+	   uip->dev->slave)
+		dr->dr_type &= ~OKTYPE; 
+	bp = cip->b_buf;
+	bp->b_flags |= B_ERROR;
+	switch(cip->b_status&BYTEMASK){
+	case ADDRERR:
+	case OVERRUN:
+	case FDCERR:
+	case TIMEOUT:
+		bp->b_error = EIO;
+		break;
+	case WTPRT:
+#ifdef MACH_KERNEL
+		bp->b_error = ENXIO;
+#else
+		bp->b_error = ENODEV;
+#endif
+		break;
+	case NOREC:
+		bp->b_error = EBBHARD;
+		break;
+	case CRCERR:
+		bp->b_error = EBBSOFT;
+	}
+	rstout(uip);
+	specify(uip);
+	cmdp->c_rbmtr &= RBRST;
+	quechk(uip);
+}
+/*****************************************************************************
+ *
+ *	Next queue check routine
+ *
+ *****************************************************************************/
+quechk(uip)
+struct unit_info *uip;
+{
+	register struct	buf 	*bp = uip->av_forw;
+	struct ctrl_info	*cip = &ctrl_info[uip->dev->ctlr];
+	struct unit_info        *loop;
+	struct fdcmd		*cmdp = uip->b_cmd;
+	/* clear retry count */
+	cip->b_rwerr = cip->b_seekerr = cip->b_rberr = 0;
+	bp->b_resid = bp->b_resid + cip->b_xfercount;
+	uip->av_forw=bp->av_forw;
+	if (!uip->av_forw && uip->wakeme) {
+		uip->wakeme = 0;
+		wakeup(uip);
+	}
+	biodone(bp);
+	loop = uip;
+	do {
+		loop=loop->b_unitf;
+		if (loop->av_forw) {
+			m765io(loop);
+			return;
+		}
+	} while (loop!=uip);
+	cip->b_uip = 0;
+	cmdp->c_stsflag &= ~MTRFLAG;
+	mtr_on(uip);
+	cmdp->c_devflag &= ~STRCHK;
+	if(cmdp->c_devflag & STRWAIT){
+		cmdp->c_devflag &= ~STRWAIT;
+		wakeup(&cmdp->c_devflag);
+	}
+}
+fdprint(dev,str)
+dev_t	dev;
+char	*str;
+{
+	printf("floppy disk driver: %s on bad dev %d, partition %d\n",
+			str, UNIT(dev), 0);
+}
+fdsize()
+{
+	printf("fdsize()	-- not implemented\n");
+}
+fddump()
+{
+	printf("fddump()	-- not implemented\n");
+}
+/*****************************************************************************
+ *
+ *	fdc reset routine
+ *
+ *****************************************************************************/
+rstout(uip)
+struct unit_info *uip;
+{
+	register int	outd;
+
+	outd = ((uip->b_cmd->c_rbmtr&MTRMASK)<<MTR_ON)|uip->dev->slave;
+	outb(CTRLREG(uip->addr), outd);
+	outd |= FDC_RST;
+	outb(CTRLREG(uip->addr), outd);
+	outd |= DMAREQ;
+	outb(CTRLREG(uip->addr), outd);
+}
+/*****************************************************************************
+ *
+ *	specify command routine
+ *
+ *****************************************************************************/
+specify(uip)
+struct unit_info *uip;
+{
+	/* status check */
+	if(fdc_sts(FD_OSTS, uip))
+		return;
+	/* Specify command */
+	outb(DATAREG(uip->addr), SPCCMD);
+	/* status check */
+	if(fdc_sts(FD_OSTS, uip))
+		return;
+	/* Step rate,Head unload time */
+	outb(DATAREG(uip->addr), SRTHUT);
+	/* status check */
+	if(fdc_sts(FD_OSTS, uip))
+		return;
+	/* Head load time,Non DMA Mode*/
+	outb(DATAREG(uip->addr), HLTND);
+	return;
+}
+/****************************************************************************
+ *
+ *	recalibrate command routine
+ *
+ ****************************************************************************/
+rbrate(mtype,uip)
+char	 mtype;
+struct unit_info *uip;
+{
+	register int	rtn = 1, rty_flg=2;
+	spl_t		x;
+	struct	fdcmd	*cmdp = uip->b_cmd;
+
+	rbskrate(uip, mtype);			/* set transfer rate */
+	while((rty_flg--)&&rtn){
+		if(rtn = fdc_sts(FD_OSTS, uip))	/* status check */
+			break;
+		/*recalibrate command*/
+		outb(DATAREG(uip->addr), RBCMD);
+		if(rtn = fdc_sts(FD_OSTS, uip))	/* status check */
+			break;
+		/* Device to wake up specified in open */
+		cmdp->c_intr |= WUPFLAG;
+		x = SPL();
+		outb(DATAREG(uip->addr), uip->dev->slave);
+		rtn = ERROR;
+		while(rtn) {
+			uip->wakeme = 1;
+			sleep(uip, PZERO);
+			if((rtn = sis(uip)) == ST0OK)
+			  /* Device to wake up specified in open */
+				cmdp->c_intr |= WUPFLAG;
+			else
+				break;
+		}
+		splx(x);
+	}
+	return(rtn);
+}
+/*****************************************************************************
+ *
+ *	seek command routine
+ *
+ ****************************************************************************/
+fdseek(mtype, uip, cylno)
+register char	mtype;
+struct unit_info *uip;
+register int	cylno;
+{
+	spl_t		x;
+	int		rtn;
+	struct	fdcmd	*cmdp = uip->b_cmd;
+
+	rbskrate(uip, mtype);
+	if(rtn = fdc_sts(FD_OSTS, uip))			/* status check */
+		return(rtn);
+	outb(DATAREG(uip->addr), SEEKCMD);		/* seek command */
+	if(rtn = fdc_sts(FD_OSTS, uip))			/* status check */
+		return(rtn);
+	outb(DATAREG(uip->addr), uip->dev->slave);	/* drive number */
+	if(rtn = fdc_sts(FD_OSTS, uip))			/* status check */
+		return(rtn);
+	x = SPL();
+	/* Device to wake up specified in open */
+	cmdp->c_intr |= WUPFLAG;
+	outb(DATAREG(uip->addr), cylno);		/* seek count */
+	rtn = ERROR;
+	while(rtn){	
+		uip->wakeme = 1;
+		sleep(uip, PZERO);
+		if((rtn = sis(uip)) == ST0OK)
+		  /* Device to wake up specified in open */
+			cmdp->c_intr |= WUPFLAG;
+		else
+			break;
+	}
+	splx(x);
+	return(rtn);
+}
+/*****************************************************************************
+ *
+ *	seek commnd routine(use interrupt)
+ *
+ *****************************************************************************/
+fdiseek(uip, cylno) 
+struct unit_info *uip;
+int	cylno;
+{
+	register int	rtn;
+
+	D(printf("SK %x ", cylno));
+	rbskrate(uip, uip->d_drtab.dr_type);/* set transfer rate */
+	if(rtn = fdc_sts(FD_OSTS, uip))		/* status check */
+		goto fdiend;
+	outb(DATAREG(uip->addr), SEEKCMD);	/* seek command */
+	if(rtn = fdc_sts(FD_OSTS, uip))		/* status check */
+		goto fdiend;
+	outb(DATAREG(uip->addr), uip->dev->slave);	/* drive number */
+	if(rtn = fdc_sts(FD_OSTS, uip))		/* status check */
+		goto fdiend;
+	uip->b_seekaddr = cylno;
+	if(uip->d_drtab.dr_type&DOUBLE)
+		cylno = cylno * 2;
+	uip->b_cmd->c_intr |= SKFLAG;
+	outb(DATAREG(uip->addr), cylno);	/* seek count */
+fdiend:	
+	if(rtn)
+		rtn |= SEEKCMD<<8;
+	return(rtn);
+}
+/*****************************************************************************
+ *
+ *	recalibrate command routine(use interrupt)
+ *
+ *****************************************************************************/
+rbirate(uip)
+struct unit_info *uip;
+{
+	register int	rtn;
+
+	rbskrate(uip, uip->d_drtab.dr_type);/* set transfer rate */
+	if(!(rtn = fdc_sts(FD_OSTS, uip))) {		/* status check */
+		/* recalibrate command */
+		outb(DATAREG(uip->addr), RBCMD);
+		if(!(rtn = fdc_sts(FD_OSTS, uip))) {	/* status check */
+			uip->b_cmd->c_intr |= RBFLAG;
+			outb(DATAREG(uip->addr), uip->dev->slave);
+		}
+	}
+	return(rtn ? rtn|RBCMD<<8 : 0);
+}
+/*****************************************************************************
+ *
+ *	read / write / format / verify command out routine(use interrupt)
+ *
+ *****************************************************************************/
+outicmd(uip)
+struct unit_info *uip;
+{
+	int			rtn;
+	register int		*data,cnt0,dmalen;
+	register long		address;
+	struct ctrl_info	*cip = &ctrl_info[uip->dev->ctlr];
+	struct fdcmd		*cmdp = uip->b_cmd;
+	spl_t			 x = splhi();
+
+	outb(DMACMD1,DMADATA0);	/* DMA #1 command register 	*/
+	outb(DMAMSK1,DMADATA1);	/* DMA #1 all mask register	*/
+	/* Perhaps outb(0x0a,0x02); might work better on line above? */
+	switch(cmdp->c_rwdata[0]){
+	case RDM:
+		D(printf("RDM"));
+		outb(DMABPFF,DMARD);
+		outb(DMAMODE,DMARD);
+		break;
+	case WTM:
+	case FMTM:
+		D(printf("W"));
+		outb(DMABPFF,DMAWT);
+		outb(DMAMODE,DMAWT);
+		break;
+	case RDMV:
+		D(printf("RDMV"));
+		outb(DMABPFF,DMAVRF);
+		outb(DMAMODE,DMAVRF);
+	}
+	/* get work buffer physical address */
+	address = kvtophys(cip->b_xferaddr);
+	dmalen = i386_trunc_page(address) + I386_PGBYTES - address;
+	if ( (cip->b_rwerr&MRMASK) >= 0x10)
+		dmalen = 0x200;
+	if (dmalen<=cip->b_xferdma) 
+		cip->b_xferdma = dmalen;
+	else
+		dmalen = cip->b_xferdma;
+	if (address >= FdDmaThreshold) {
+		DD(printf(">(%x[%x], %x[%x] L%x\n",
+			address, cip->b_pbuf,
+			cip->b_xferaddr, cip->b_vbuf, dmalen));
+		if (!FdDmaEISA) {
+			cip->usebuf = 1;
+			address = (long)cip->b_pbuf;
+			if (cmdp->c_rwdata[0] == WTM || cmdp->c_rwdata[0] == FMTM) {
+				bcopy(cip->b_xferaddr, cip->b_vbuf, dmalen);
+				DD(printf("W(%x, %x, %x)\n",
+					cip->b_xferaddr, cip->b_vbuf, dmalen));
+			}
+		} else
+			cip->usebuf = 0;
+	} else
+		cip->usebuf = 0;
+	D(printf(" %x L%x ", address, dmalen));
+	/* set buffer address */
+	outb(DMAADDR,(int)address&BYTEMASK);
+	outb(DMAADDR,(((int)address>>8)&BYTEMASK));
+	outb(DMAPAGE,(((int)address>>16)&BYTEMASK));
+	if (FdDmaEISA)
+		outb(FdDmaEISA+DMAPAGE-0x80,(((int)address>>24)&BYTEMASK));
+	/* set transfer count */
+	outb(DMACNT,(--dmalen)&BYTEMASK);
+	outb(DMACNT,((dmalen>>8)&BYTEMASK));
+	outb(DMAMSK,CHANNEL2);
+	splx(x);
+	trfrate(uip, uip->d_drtab.dr_type);	/* set transfer rate */
+	data = &cmdp->c_rwdata[0];
+	for(cnt0 = 0; cnt0<cmdp->c_dcount; cnt0++,data++){
+		if(rtn = fdc_sts(FD_OSTS, uip))	/*status check*/
+			break;
+		outb(DATAREG(uip->addr), *data);
+	}
+	if(!rtn){
+		cmdp->c_intr |= RWFLAG;
+		cmdp->c_stsflag |= INTROUT;
+		cnt0 = ((cip->b_buf->b_flags&(B_READ|B_VERIFY)) ==
+			(B_READ|B_VERIFY))?TOUT:ITOUT;
+#ifdef	MACH_KERNEL
+		timeout(fdintr,uip->dev->ctlr,cnt0);
+#else	MACH_KERNEL
+		cmdp->c_timeid = timeout(fdintr,uip->dev->ctlr,cnt0);
+#endif	MACH_KERNEL
+	}
+	return(rtn);
+}
+/*****************************************************************************
+ *
+ *	sense interrupt status routine
+ *
+ *****************************************************************************/
+sis(uip)
+struct unit_info *uip;
+{
+	register int	rtn, st0;
+
+	if(rtn = fdc_sts(FD_OSTS, uip))	/* status check */
+		return(rtn);
+	outb(DATAREG(uip->addr), SISCMD);
+	if(rtn = fdc_sts(FD_ISTS, uip))	/* status check */
+		return(rtn);
+	st0 = inb(DATAREG(uip->addr)) & ST0OK;	/* get st0 */
+	if(rtn = fdc_sts(FD_ISTS, uip))	/* status check */
+		return(rtn);
+	inb(DATAREG(uip->addr));	/* get pcn */
+	if (st0&(ST0AT|ST0IC))
+		st0 = FDCERR;
+	return(st0);
+}
+
+/*****************************************************************************
+ *
+ *	fdc status get routine
+ *
+ *****************************************************************************/
+fdc_sts(mode, uip)
+register int	mode;
+struct unit_info *uip;
+{
+	register int 	ind;
+	int		cnt0 = STSCHKCNT;
+
+	while(cnt0--)
+		if(((ind=inb(STSREG(uip->addr))) & DATAOK) && 
+		   ((ind & DTOCPU) == mode))
+			return(0);
+	return(TIMEOUT);
+}
+/*****************************************************************************
+ *
+ *	motor on routine
+ *
+ *****************************************************************************/
+mtr_on(uip)
+struct unit_info *uip;
+{
+	extern		int(mtr_off)();
+	extern		int(wakeup)();
+	struct	fdcmd	*cmdp = uip->b_cmd;
+
+	if(!(mtr_start(uip))){
+		timeout(wakeup,&cmdp->c_stsflag,HZ);
+		sleep(&cmdp->c_stsflag,PZERO);
+	}
+	cmdp->c_stsflag |= MTROFF;
+#ifdef	MACH_KERNEL
+	timeout(mtr_off,uip,MTRSTOP);
+#else	MACH_KERNEL
+	cmdp->c_mtrid = timeout(mtr_off,uip,MTRSTOP);
+#endif	MACH_KERNEL
+}
+/*****************************************************************************
+ *
+ *	motor start routine
+ *
+ *****************************************************************************/
+mtr_start(uip)
+struct unit_info *uip;
+{
+	int		status;
+	int		(mtr_off)();
+	struct	fdcmd	*cmdp = uip->b_cmd;
+	int		slave = uip->dev->slave;
+	if(cmdp->c_stsflag & MTROFF){
+		untimeout(mtr_off, uip);
+		cmdp->c_stsflag &= ~MTROFF;
+	}
+	status = cmdp->c_rbmtr&(1<<slave);
+	cmdp->c_rbmtr |= (1<<slave);
+	outb(CTRLREG(uip->addr), ((cmdp->c_rbmtr&MTRMASK)<<MTR_ON)|
+				     FDC_RST|slave|DMAREQ);
+	return(status);
+}
+/*****************************************************************************
+ *
+ *	motor off routine
+ *
+ *****************************************************************************/
+mtr_off(uip)
+struct unit_info *uip;
+{
+	struct	fdcmd	*cmdp = uip->b_cmd;
+
+	cmdp->c_stsflag &= ~MTROFF;
+	if(!(cmdp->c_stsflag&MTRFLAG)){
+		cmdp->c_rbmtr &= MTRRST;
+		outb(CTRLREG(uip->addr), FDC_RST | DMAREQ);
+	}
+}
+
+#endif