/*
 * 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