[unix-history] / usr / src / sys / i386 / isa / fd.c

#include "fd.h"
#if NFD > 0
/*-
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Don Ahn.
 *
 * %sccs.include.386.c%
 *
 *	@(#)fd.c	5.2 (Berkeley) %G%
 */

/****************************************************************************/
/*                               fd driver                                  */
/****************************************************************************/
#include "param.h"
#include "dkbad.h"
#include "systm.h"
#include "conf.h"
#include "file.h"
#include "dir.h"
#include "user.h"
#include "ioctl.h"
#include "disk.h"
#include "buf.h"
#include "vm.h"
#include "uio.h"
#include "machine/pte.h"
#include "machine/isa/device.h"
#include "machine/isa/fdreg.h"
#include "icu.h"

#define	FDUNIT(s)	((s)&1)
#define	FDTYPE(s)	(((s)>>1)&7)

#define b_cylin b_resid
#define b_step b_resid
#define FDBLK 512
#define NUMTYPES 4

struct fd_type {
	int	sectrac;		/* sectors per track         */
	int	secsize;		/* size code for sectors     */
	int	datalen;		/* data len when secsize = 0 */
	int	gap;			/* gap len between sectors   */
	int	tracks;			/* total num of tracks       */
	int	size;			/* size of disk in sectors   */
	int	steptrac;		/* steps per cylinder        */
	int	trans;			/* transfer speed code       */
};

struct fd_type fd_types[NUMTYPES] = {
 	{ 18,2,0xFF,0x1B,80,2880,1,0 },	/* 1.44 meg HD 3.5in floppy    */
	{ 15,2,0xFF,0x1B,80,2400,1,0 },	/* 1.2 meg HD floppy           */
	{ 9,2,0xFF,0x23,40,720,2,1 },	/* 360k floppy in 1.2meg drive */
	{ 9,2,0xFF,0x2A,40,720,1,1 },	/* 360k floppy in DD drive     */
};

struct fd_u {
	int type;		/* Drive type (HD, DD     */
	int active;		/* Drive activity boolean */
	int motor;		/* Motor on flag          */
	struct buf head;	/* Head of buf chain      */
	struct buf rhead;	/* Raw head of buf chain  */
	int reset;
} fd_unit[NFD];


extern int hz;

/* state needed for current transfer */
static fdc;	/* floppy disk controller io base register */
int	fd_dmachan = 2;
static int fd_skip;
static int fd_state;
static int fd_retry;
static int fd_drive;
static int fd_track = -1;
static int fd_status[7];

/*
	make sure bounce buffer for DMA is aligned since the DMA chip
	doesn't roll over properly over a 64k boundary
*/
extern struct buf *dma_bounce[];

/****************************************************************************/
/*                      autoconfiguration stuff                             */
/****************************************************************************/
int fdprobe(), fdattach(), fd_turnoff();

struct	isa_driver fddriver = {
	fdprobe, fdattach, "fd",
};

fdprobe(dev)
struct isa_device *dev;
{
	return 1;
}

fdattach(dev)
struct isa_device *dev;
{	int	s;

	fdc = dev->id_iobase;
	/* Set transfer to 500kbps */
	outb(fdc+fdctl,0);
	fd_turnoff(0);
}

int
fdsize(dev)
dev_t	dev;
{
	return(2400);
}

/****************************************************************************/
/*                               fdstrategy                                 */
/****************************************************************************/
fdstrategy(bp)
	register struct buf *bp;	/* IO operation to perform */
{
	register struct buf *dp,*dp0,*dp1;
	long nblocks,blknum;
 	int	unit, type, s;

 	unit = FDUNIT(minor(bp->b_dev));
 	type = FDTYPE(minor(bp->b_dev));

#ifdef FDTEST
printf("fdstrat%d, blk = %d, bcount = %d, addr = %x|",
	unit, bp->b_blkno, bp->b_bcount,bp->b_un.b_addr);
#endif
	if ((unit >= NFD) || (bp->b_blkno < 0)) {
		printf("fdstrat: unit = %d, blkno = %d, bcount = %d\n",
			unit, bp->b_blkno, bp->b_bcount);
		pg("fd:error in fdstrategy");
		bp->b_error = EINVAL;
		bp->b_flags |= B_ERROR;
		goto bad;
	}
	/*
	 * Set up block calculations.
	 */
	blknum = (unsigned long) bp->b_blkno * DEV_BSIZE/FDBLK;
 	nblocks = fd_types[type].size;
	if (blknum + (bp->b_bcount / FDBLK) > nblocks) {
		if (blknum == nblocks) {
			bp->b_resid = bp->b_bcount;
		} else {
			bp->b_error = ENOSPC;
			bp->b_flags |= B_ERROR;
		}
		goto bad;
	}
 	bp->b_cylin = blknum / (fd_types[type].sectrac * 2);
	dp = &fd_unit[unit].head;
	dp0 = &fd_unit[0].head;
	dp1 = &fd_unit[1].head;
	dp->b_step = (fd_types[fd_unit[unit].type].steptrac);
	s = splbio();
	disksort(dp, bp);
	if ((dp0->b_active == 0)&&(dp1->b_active == 0)) {
#ifdef FDDEBUG
printf("T|");
#endif
		dp->b_active = 1;
		fd_drive = unit;
		fd_track = -1;  /* force seek on first xfer */
		untimeout(fd_turnoff,unit);
		fdstart(unit);		/* start drive if idle */
	}
	splx(s);
	return;

bad:
	biodone(bp);
}

/****************************************************************************/
/*                            motor control stuff                           */
/****************************************************************************/
set_motor(unit,reset)
int unit,reset;
{
	int m0,m1;
	m0 = fd_unit[0].motor;
	m1 = fd_unit[1].motor;
	outb(fdc+fdout,unit | (reset ? 0 : 0xC)  | (m0 ? 16 : 0) | (m1 ? 32 : 0));
}

fd_turnoff(unit)
int unit;
{
	fd_unit[unit].motor = 0;
	if (unit) set_motor(0,0);
	else set_motor(1,0);
}

fd_turnon(unit)
int unit;
{
	fd_unit[unit].motor = 1;
	set_motor(unit,0);
}

/****************************************************************************/
/*                             fdc in/out                                   */
/****************************************************************************/
int
in_fdc()
{
	int i;
	while ((i = inb(fdc+fdsts) & (NE7_DIO|NE7_RQM)) != (NE7_DIO|NE7_RQM))
		if (i == NE7_RQM) return -1;
	return inb(fdc+fddata);
}

dump_stat()
{
	int i;
	for(i=0;i<7;i++) {
		fd_status[i] = in_fdc();
		if (fd_status[i] < 0) break;
	}
printf("FD bad status :%X %X %X %X %X %X %X\n",
	fd_status[0], fd_status[1], fd_status[2], fd_status[3],
	fd_status[4], fd_status[5], fd_status[6] );
}

out_fdc(x)
int x;
{
	int r,errcnt;
	static int maxcnt = 0;
	errcnt = 0;
	do {
		r = (inb(fdc+fdsts) & (NE7_DIO|NE7_RQM));
		if (r== NE7_RQM) break;
		if (r==(NE7_DIO|NE7_RQM)) {
			dump_stat(); /* error: direction. eat up output */
#ifdef FDOTHER
printf("%X\n",x);
#endif
		}
		/* printf("Error r = %d:",r); */
		errcnt++;
	} while (1);
	if (errcnt > maxcnt) {
		maxcnt = errcnt;
#ifdef FDOTHER
printf("New MAX = %d\n",maxcnt);
#endif
	}
	outb(fdc+fddata,x);
}

/* see if fdc responding */
int
check_fdc()
{
	int i;
	for(i=0;i<100;i++) {
		if (inb(fdc+fdsts)& NE7_RQM) return 0;
	}
	return 1;
}

/****************************************************************************/
/*                           fdopen/fdclose                                 */
/****************************************************************************/
fdopen(dev, flags)
	dev_t	dev;
	int	flags;
{
 	int unit = FDUNIT(minor(dev));
 	int type = FDTYPE(minor(dev));
	int s;

	/* check bounds */
	if (unit >= NFD) return(ENXIO);
	if (type >= NUMTYPES) return(ENXIO);
/*
	if (check_fdc()) return(EBUSY);
*/

	/* Set proper disk type, only allow one type */
	return 0;
}

fdclose(dev)
	dev_t dev;
{
}

/****************************************************************************/
/*                            fdread/fdwrite                                */
/****************************************************************************/
/*
 * Routines to do raw IO for a unit.
 */
fdread(dev, uio)			/* character read routine */
dev_t dev;
struct uio *uio;
{
 	int unit = FDUNIT(minor(dev)) ;
	if (unit >= NFD) return(ENXIO);
	return(physio(fdstrategy,&fd_unit[unit].rhead,dev,B_READ,minphys,uio));
}

fdwrite(dev, uio)			/* character write routine */
dev_t dev;
struct uio *uio;
{
 	int unit = FDUNIT(minor(dev)) ;
	if (unit >= NFD) return(ENXIO);
	return(physio(fdstrategy,&fd_unit[unit].rhead,dev,B_WRITE,minphys,uio));
}

/****************************************************************************/
/*                                 fdstart                                  */
/****************************************************************************/
fdstart(unit)
int unit;
{
	register struct buf *dp,*bp;
	int s;

#ifdef FDTEST
printf("st%d|",unit);
#endif 
	s = splbio();
	if (!fd_unit[unit].motor) {
		fd_turnon(unit);
		/* Wait for 1 sec */
		timeout(fdstart,unit,hz);
		/*DELAY(1000000);*/
	}else
		 {
		/* make sure drive is selected as well as on */
		/*set_motor(unit,0);*/

		dp = &fd_unit[unit].head;
		bp = dp->b_actf;
		fd_retry = 0;
		if (fd_unit[unit].reset) fd_state = 1;
		else {
			/* DO a RESET */
			fd_unit[unit].reset = 1;
			fd_state = 5;
		}
		fd_skip = 0;
#ifdef FDDEBUG
printf("Seek %d %d\n", bp->b_cylin, dp->b_step);
#endif
		if (bp->b_cylin != fd_track) {
		/* Seek necessary, never quite sure where head is at! */
		out_fdc(15);	/* Seek function */
		out_fdc(unit);	/* Drive number */
		out_fdc(bp->b_cylin * dp->b_step);
		} else fdintr(0);
	}
	splx(s);
}

fd_timeout(x)
int x;
{
	int i,j;
	struct buf *dp,*bp;

	dp = &fd_unit[fd_drive].head;
	bp = dp->b_actf;

	out_fdc(0x4);
	out_fdc(fd_drive);
	i = in_fdc();
	printf("Timeout drive status %X\n",i);

	out_fdc(0x8);
	i = in_fdc();
	j = in_fdc();
	printf("ST0 = %X, PCN = %X\n",i,j);

	if (bp) badtrans(dp,bp);
}

/****************************************************************************/
/*                                 fdintr                                   */
/****************************************************************************/
fdintr(vec)
int vec;
{
	register struct buf *dp,*bp;
	struct buf *dpother;
	int read,head,trac,sec,i,s,sectrac,cyl;
	unsigned long blknum;
	struct fd_type *ft;

#ifdef FDTEST
	printf("state %d, vec %d, dr %d|",fd_state,vec,fd_drive);
#endif

	dp = &fd_unit[fd_drive].head;
	bp = dp->b_actf;
	read = bp->b_flags & B_READ;
 	ft = &fd_types[FDTYPE(bp->b_dev)];

	switch (fd_state) {
	case 1 : /* SEEK DONE, START DMA */
		/* Make sure seek really happened*/
		if (vec) {
			out_fdc(0x8);
			i = in_fdc();
			cyl = in_fdc();
			if (!(i&0x20) || (cyl != bp->b_cylin*dp->b_step)) {
printf("Stray int ST0 = %X, PCN = %X:",i,cyl);
				return;
			}
		}

		fd_track = bp->b_cylin;
		at_dma(read,bp->b_un.b_addr+fd_skip,FDBLK, fd_dmachan);
		blknum = (unsigned long)bp->b_blkno*DEV_BSIZE/FDBLK
			+ fd_skip/FDBLK;
		sectrac = ft->sectrac;
		sec = blknum %  (sectrac * 2);
		head = sec / sectrac;
		sec = sec % sectrac + 1;

		if (read)  out_fdc(0xE6);	/* READ */
		else out_fdc(0xC5);		/* WRITE */
		out_fdc(head << 2 | fd_drive);	/* head & unit */
		out_fdc(fd_track);		/* track */
		out_fdc(head);
		out_fdc(sec);			/* sector XXX +1? */
		out_fdc(ft->secsize);		/* sector size */
		out_fdc(sectrac);		/* sectors/track */
		out_fdc(ft->gap);		/* gap size */
		out_fdc(ft->datalen);		/* data length */
		fd_state = 2;
		/* XXX PARANOIA */
		untimeout(fd_timeout,2);
		timeout(fd_timeout,2,hz);
		break;
	case 2 : /* IO DONE, post-analyze */
		untimeout(fd_timeout,2);
		for(i=0;i<7;i++) {
			fd_status[i] = in_fdc();
		}
		if (fd_status[0]&0xF8) {
#ifdef FDOTHER
printf("status0 err %d:",fd_status[0]);
#endif
			goto retry;
		}
/*
		if (fd_status[1]){
			printf("status1 err %d:",fd_status[0]);
			goto retry;
		}
		if (fd_status[2]){
			printf("status2 err %d:",fd_status[0]);
			goto retry;
		}
*/
		/* All OK */
		if (!kernel_space(bp->b_un.b_addr+fd_skip)) {
			/* RAW transfer */
			if (read) bcopy(dma_bounce[fd_dmachan]->b_un.b_addr,
				bp->b_un.b_addr+fd_skip, FDBLK);
		}
		fd_skip += FDBLK;
		if (fd_skip >= bp->b_bcount) {
#ifdef FDTEST
printf("DONE %d|", bp->b_blkno);
#endif
			/* ALL DONE */
			fd_skip = 0;
			bp->b_resid = 0;
			dp->b_actf = bp->av_forw;
			biodone(bp);
			nextstate(dp);

		} else {
#ifdef FDDEBUG
printf("next|");
#endif
			/* set up next transfer */
			blknum = (unsigned long)bp->b_blkno*DEV_BSIZE/FDBLK
				+ fd_skip/FDBLK;
			fd_state = 1;
			bp->b_cylin = (blknum / (ft->sectrac * 2));
			if (bp->b_cylin != fd_track) {
#ifdef FDTEST
printf("Seek|");
#endif
				/* SEEK Necessary */
				out_fdc(15);	/* Seek function */
				out_fdc(fd_drive);/* Drive number */
				out_fdc(bp->b_cylin * dp->b_step);
				break;
			} else fdintr(0);
		}
		break;
	case 3:
#ifdef FDOTHER
printf("Seek %d %d\n", bp->b_cylin, dp->b_step);
#endif
		/* Seek necessary */
		out_fdc(15);	/* Seek function */
		out_fdc(fd_drive);/* Drive number */
		out_fdc(bp->b_cylin * dp->b_step);
		fd_state = 1;
		break;
	case 4:
		out_fdc(3); /* specify command */
		out_fdc(0xDF);
		out_fdc(2);
		out_fdc(7);	/* Recalibrate Function */
		out_fdc(fd_drive);
		fd_state = 3;
		break;
	case 5:
#ifdef FDOTHER
		printf("**RESET**\n");
#endif
		/* Try a reset, keep motor on */
		set_motor(fd_drive,1);
		set_motor(fd_drive,0);
		outb(fdc+fdctl,ft->trans);
		fd_retry++;
		fd_state = 4;
		break;
	default:
		printf("Unexpected FD int->");
		out_fdc(0x8);
		i = in_fdc();
		sec = in_fdc();
		printf("ST0 = %X, PCN = %X\n",i,sec);
		out_fdc(0x4A); 
		out_fdc(fd_drive);
		for(i=0;i<7;i++) {
			fd_status[i] = in_fdc();
		}
	printf("intr status :%X %X %X %X %X %X %X ",
		fd_status[0], fd_status[1], fd_status[2], fd_status[3],
		fd_status[4], fd_status[5], fd_status[6] );
		break;
	}
	return;
retry:
	switch(fd_retry) {
	case 0: case 1:
	case 2: case 3:
		break;
	case 4:
		fd_retry++;
		fd_state = 5;
		fdintr(0);
		return;
	case 5: case 6: case 7:
		break;
	default:
		printf("FD err %X %X %X %X %X %X %X\n",
		fd_status[0], fd_status[1], fd_status[2], fd_status[3],
		fd_status[4], fd_status[5], fd_status[6] );
		badtrans(dp,bp);
		return;
	}
	fd_state = 1;
	fd_retry++;
	fdintr(0);
}

badtrans(dp,bp)
struct buf *dp,*bp;
{

	bp->b_flags |= B_ERROR;
	bp->b_error = EIO;
	bp->b_resid = bp->b_bcount - fd_skip;
	dp->b_actf = bp->av_forw;
	fd_skip = 0;
	biodone(bp);
	nextstate(dp);

}

/*
	nextstate : After a transfer is done, continue processing
	requests on the current drive queue.  If empty, go to
	the other drives queue.  If that is empty too, timeout
	to turn off the current drive in 5 seconds, and go
	to state 0 (not expecting any interrupts).
*/

nextstate(dp)
struct buf *dp;
{
	struct buf *dpother;
	
	dpother = &fd_unit[fd_drive ? 0 : 1].head;
	if (dp->b_actf) fdstart(fd_drive);
	else if (dpother->b_actf) {
#ifdef FDTEST
printf("switch|");
#endif
		untimeout(fd_turnoff,fd_drive);
		timeout(fd_turnoff,fd_drive,5*hz);
		fd_drive = 1 - fd_drive;
		dp->b_active = 0;
		dpother->b_active = 1;
		fdstart(fd_drive);
	} else {
#ifdef FDTEST
printf("off|");
#endif
		untimeout(fd_turnoff,fd_drive);
		timeout(fd_turnoff,fd_drive,5*hz);
		fd_state = 0;
		dp->b_active = 0;
	}
}
#endif
Commit	Line	Data
32f56e31 BJ	1	#include "fd.h"
32f56e31 BJ	2	#if NFD > 0
7ff33365 DA	3	/*-
	4	* Copyright (c) 1990 The Regents of the University of California.
	5	* All rights reserved.
	6	*
	7	* This code is derived from software contributed to Berkeley by
	8	* Don Ahn.
	9	*
	10	* %sccs.include.386.c%
	11	*
32f56e31	12	* @(#)fd.c 5.2 (Berkeley) %G%
7ff33365 DA	13	*/
	14
	15	/****************************************************************************/
	16	/* fd driver */
	17	/****************************************************************************/
	18	#include "param.h"
	19	#include "dkbad.h"
	20	#include "systm.h"
	21	#include "conf.h"
	22	#include "file.h"
	23	#include "dir.h"
	24	#include "user.h"
	25	#include "ioctl.h"
	26	#include "disk.h"
	27	#include "buf.h"
	28	#include "vm.h"
	29	#include "uio.h"
	30	#include "machine/pte.h"
32f56e31 BJ	31	#include "machine/isa/device.h"
32f56e31 BJ	32	#include "machine/isa/fdreg.h"
7ff33365 DA	33	#include "icu.h"
7ff33365 DA	34
7ff33365 DA	35	#define FDUNIT(s) ((s)&1)
7ff33365 DA	36	#define FDTYPE(s) (((s)>>1)&7)
32f56e31	37
7ff33365	38	#define b_cylin b_resid
32f56e31	39	#define b_step b_resid
7ff33365 DA	40	#define FDBLK 512
	41	#define NUMTYPES 4
	42
	43	struct fd_type {
	44	int sectrac; /* sectors per track */
	45	int secsize; /* size code for sectors */
	46	int datalen; /* data len when secsize = 0 */
	47	int gap; /* gap len between sectors */
	48	int tracks; /* total num of tracks */
	49	int size; /* size of disk in sectors */
	50	int steptrac; /* steps per cylinder */
	51	int trans; /* transfer speed code */
	52	};
	53
	54	struct fd_type fd_types[NUMTYPES] = {
32f56e31	55	{ 18,2,0xFF,0x1B,80,2880,1,0 }, /* 1.44 meg HD 3.5in floppy */
7ff33365 DA	56	{ 15,2,0xFF,0x1B,80,2400,1,0 }, /* 1.2 meg HD floppy */
	57	{ 9,2,0xFF,0x23,40,720,2,1 }, /* 360k floppy in 1.2meg drive */
	58	{ 9,2,0xFF,0x2A,40,720,1,1 }, /* 360k floppy in DD drive */
	59	};
	60
	61	struct fd_u {
	62	int type; /* Drive type (HD, DD */
	63	int active; /* Drive activity boolean */
	64	int motor; /* Motor on flag */
7ff33365 DA	65	struct buf head; /* Head of buf chain */
7ff33365 DA	66	struct buf rhead; /* Raw head of buf chain */
32f56e31	67	int reset;
7ff33365 DA	68	} fd_unit[NFD];
7ff33365 DA	69
32f56e31	70
7ff33365 DA	71	extern int hz;
	72
	73	/* state needed for current transfer */
32f56e31 BJ	74	static fdc; /* floppy disk controller io base register */
32f56e31 BJ	75	int fd_dmachan = 2;
7ff33365 DA	76	static int fd_skip;
	77	static int fd_state;
	78	static int fd_retry;
	79	static int fd_drive;
32f56e31	80	static int fd_track = -1;
7ff33365	81	static int fd_status[7];
7ff33365	82
32f56e31 BJ	83	/*
	84	make sure bounce buffer for DMA is aligned since the DMA chip
	85	doesn't roll over properly over a 64k boundary
	86	*/
	87	extern struct buf *dma_bounce[];
7ff33365 DA	88
	89	/****************************************************************************/
	90	/* autoconfiguration stuff */
	91	/****************************************************************************/
	92	int fdprobe(), fdattach(), fd_turnoff();
	93
32f56e31	94	struct isa_driver fddriver = {
7ff33365 DA	95	fdprobe, fdattach, "fd",
	96	};
	97
	98	fdprobe(dev)
32f56e31	99	struct isa_device *dev;
7ff33365 DA	100	{
	101	return 1;
	102	}
	103
	104	fdattach(dev)
32f56e31 BJ	105	struct isa_device *dev;
	106	{ int s;
	107
	108	fdc = dev->id_iobase;
	109	/* Set transfer to 500kbps */
	110	outb(fdc+fdctl,0);
	111	fd_turnoff(0);
	112	}
	113
	114	int
	115	fdsize(dev)
	116	dev_t dev;
7ff33365	117	{
32f56e31	118	return(2400);
7ff33365 DA	119	}
	120
	121	/****************************************************************************/
	122	/* fdstrategy */
	123	/****************************************************************************/
	124	fdstrategy(bp)
	125	register struct buf bp; / IO operation to perform */
	126	{
	127	register struct buf dp,dp0,*dp1;
	128	long nblocks,blknum;
32f56e31	129	int unit, type, s;
7ff33365	130
32f56e31 BJ	131	unit = FDUNIT(minor(bp->b_dev));
	132	type = FDTYPE(minor(bp->b_dev));
	133
	134	#ifdef FDTEST
	135	printf("fdstrat%d, blk = %d, bcount = %d, addr = %x\|",
	136	unit, bp->b_blkno, bp->b_bcount,bp->b_un.b_addr);
7ff33365 DA	137	#endif
	138	if ((unit >= NFD) \|\| (bp->b_blkno < 0)) {
	139	printf("fdstrat: unit = %d, blkno = %d, bcount = %d\n",
	140	unit, bp->b_blkno, bp->b_bcount);
	141	pg("fd:error in fdstrategy");
	142	bp->b_error = EINVAL;
32f56e31	143	bp->b_flags \|= B_ERROR;
7ff33365 DA	144	goto bad;
	145	}
	146	/*
	147	* Set up block calculations.
	148	*/
	149	blknum = (unsigned long) bp->b_blkno * DEV_BSIZE/FDBLK;
32f56e31	150	nblocks = fd_types[type].size;
7ff33365	151	if (blknum + (bp->b_bcount / FDBLK) > nblocks) {
32f56e31 BJ	152	if (blknum == nblocks) {
	153	bp->b_resid = bp->b_bcount;
	154	} else {
	155	bp->b_error = ENOSPC;
	156	bp->b_flags \|= B_ERROR;
	157	}
7ff33365 DA	158	goto bad;
7ff33365 DA	159	}
32f56e31	160	bp->b_cylin = blknum / (fd_types[type].sectrac * 2);
7ff33365 DA	161	dp = &fd_unit[unit].head;
	162	dp0 = &fd_unit[0].head;
	163	dp1 = &fd_unit[1].head;
32f56e31	164	dp->b_step = (fd_types[fd_unit[unit].type].steptrac);
7ff33365 DA	165	s = splbio();
	166	disksort(dp, bp);
	167	if ((dp0->b_active == 0)&&(dp1->b_active == 0)) {
32f56e31 BJ	168	#ifdef FDDEBUG
	169	printf("T\|");
	170	#endif
7ff33365 DA	171	dp->b_active = 1;
7ff33365 DA	172	fd_drive = unit;
32f56e31	173	fd_track = -1; /* force seek on first xfer */
7ff33365 DA	174	untimeout(fd_turnoff,unit);
	175	fdstart(unit); /* start drive if idle */
	176	}
	177	splx(s);
	178	return;
	179
	180	bad:
7ff33365 DA	181	biodone(bp);
	182	}
	183
	184	/****************************************************************************/
	185	/* motor control stuff */
	186	/****************************************************************************/
	187	set_motor(unit,reset)
	188	int unit,reset;
	189	{
	190	int m0,m1;
	191	m0 = fd_unit[0].motor;
	192	m1 = fd_unit[1].motor;
32f56e31	193	outb(fdc+fdout,unit \| (reset ? 0 : 0xC) \| (m0 ? 16 : 0) \| (m1 ? 32 : 0));
7ff33365 DA	194	}
	195
	196	fd_turnoff(unit)
	197	int unit;
	198	{
	199	fd_unit[unit].motor = 0;
	200	if (unit) set_motor(0,0);
	201	else set_motor(1,0);
	202	}
	203
	204	fd_turnon(unit)
	205	int unit;
	206	{
	207	fd_unit[unit].motor = 1;
	208	set_motor(unit,0);
	209	}
	210
	211	/****************************************************************************/
	212	/* fdc in/out */
	213	/****************************************************************************/
	214	int
	215	in_fdc()
	216	{
	217	int i;
32f56e31 BJ	218	while ((i = inb(fdc+fdsts) & (NE7_DIO\|NE7_RQM)) != (NE7_DIO\|NE7_RQM))
	219	if (i == NE7_RQM) return -1;
	220	return inb(fdc+fddata);
7ff33365 DA	221	}
	222
	223	dump_stat()
	224	{
	225	int i;
	226	for(i=0;i<7;i++) {
	227	fd_status[i] = in_fdc();
	228	if (fd_status[i] < 0) break;
	229	}
32f56e31 BJ	230	printf("FD bad status :%X %X %X %X %X %X %X\n",
	231	fd_status[0], fd_status[1], fd_status[2], fd_status[3],
	232	fd_status[4], fd_status[5], fd_status[6] );
7ff33365 DA	233	}
	234
	235	out_fdc(x)
	236	int x;
	237	{
	238	int r,errcnt;
	239	static int maxcnt = 0;
	240	errcnt = 0;
	241	do {
32f56e31 BJ	242	r = (inb(fdc+fdsts) & (NE7_DIO\|NE7_RQM));
	243	if (r== NE7_RQM) break;
	244	if (r==(NE7_DIO\|NE7_RQM)) {
7ff33365 DA	245	dump_stat(); /* error: direction. eat up output */
7ff33365 DA	246	#ifdef FDOTHER
32f56e31	247	printf("%X\n",x);
7ff33365 DA	248	#endif
	249	}
	250	/* printf("Error r = %d:",r); */
	251	errcnt++;
	252	} while (1);
	253	if (errcnt > maxcnt) {
	254	maxcnt = errcnt;
	255	#ifdef FDOTHER
32f56e31	256	printf("New MAX = %d\n",maxcnt);
7ff33365 DA	257	#endif
7ff33365 DA	258	}
32f56e31	259	outb(fdc+fddata,x);
7ff33365 DA	260	}
	261
	262	/* see if fdc responding */
	263	int
	264	check_fdc()
	265	{
	266	int i;
	267	for(i=0;i<100;i++) {
32f56e31	268	if (inb(fdc+fdsts)& NE7_RQM) return 0;
7ff33365 DA	269	}
	270	return 1;
	271	}
	272
	273	/****************************************************************************/
	274	/* fdopen/fdclose */
	275	/****************************************************************************/
	276	fdopen(dev, flags)
	277	dev_t dev;
	278	int flags;
	279	{
32f56e31 BJ	280	int unit = FDUNIT(minor(dev));
32f56e31 BJ	281	int type = FDTYPE(minor(dev));
7ff33365 DA	282	int s;
	283
	284	/* check bounds */
	285	if (unit >= NFD) return(ENXIO);
	286	if (type >= NUMTYPES) return(ENXIO);
32f56e31	287	/*
7ff33365	288	if (check_fdc()) return(EBUSY);
32f56e31	289	*/
7ff33365 DA	290
7ff33365 DA	291	/* Set proper disk type, only allow one type */
7ff33365 DA	292	return 0;
	293	}
	294
	295	fdclose(dev)
	296	dev_t dev;
	297	{
	298	}
	299
	300	/****************************************************************************/
	301	/* fdread/fdwrite */
	302	/****************************************************************************/
	303	/*
	304	* Routines to do raw IO for a unit.
	305	*/
	306	fdread(dev, uio) /* character read routine */
	307	dev_t dev;
	308	struct uio *uio;
	309	{
32f56e31	310	int unit = FDUNIT(minor(dev)) ;
7ff33365 DA	311	if (unit >= NFD) return(ENXIO);
	312	return(physio(fdstrategy,&fd_unit[unit].rhead,dev,B_READ,minphys,uio));
	313	}
	314
	315	fdwrite(dev, uio) /* character write routine */
	316	dev_t dev;
	317	struct uio *uio;
	318	{
32f56e31	319	int unit = FDUNIT(minor(dev)) ;
7ff33365 DA	320	if (unit >= NFD) return(ENXIO);
	321	return(physio(fdstrategy,&fd_unit[unit].rhead,dev,B_WRITE,minphys,uio));
	322	}
	323
	324	/****************************************************************************/
	325	/* fdstart */
	326	/****************************************************************************/
	327	fdstart(unit)
	328	int unit;
	329	{
	330	register struct buf dp,bp;
	331	int s;
	332
32f56e31 BJ	333	#ifdef FDTEST
	334	printf("st%d\|",unit);
	335	#endif
	336	s = splbio();
7ff33365 DA	337	if (!fd_unit[unit].motor) {
	338	fd_turnon(unit);
	339	/* Wait for 1 sec */
	340	timeout(fdstart,unit,hz);
32f56e31 BJ	341	/DELAY(1000000);/
	342	}else
	343	{
	344	/* make sure drive is selected as well as on */
	345	/set_motor(unit,0);/
	346
7ff33365 DA	347	dp = &fd_unit[unit].head;
	348	bp = dp->b_actf;
	349	fd_retry = 0;
32f56e31 BJ	350	if (fd_unit[unit].reset) fd_state = 1;
	351	else {
	352	/* DO a RESET */
	353	fd_unit[unit].reset = 1;
	354	fd_state = 5;
	355	}
7ff33365	356	fd_skip = 0;
32f56e31 BJ	357	#ifdef FDDEBUG
	358	printf("Seek %d %d\n", bp->b_cylin, dp->b_step);
	359	#endif
	360	if (bp->b_cylin != fd_track) {
7ff33365 DA	361	/* Seek necessary, never quite sure where head is at! */
	362	out_fdc(15); /* Seek function */
	363	out_fdc(unit); /* Drive number */
32f56e31 BJ	364	out_fdc(bp->b_cylin * dp->b_step);
32f56e31 BJ	365	} else fdintr(0);
7ff33365	366	}
32f56e31	367	splx(s);
7ff33365 DA	368	}
	369
	370	fd_timeout(x)
	371	int x;
	372	{
	373	int i,j;
	374	struct buf dp,bp;
	375
	376	dp = &fd_unit[fd_drive].head;
	377	bp = dp->b_actf;
	378
	379	out_fdc(0x4);
	380	out_fdc(fd_drive);
	381	i = in_fdc();
	382	printf("Timeout drive status %X\n",i);
	383
	384	out_fdc(0x8);
	385	i = in_fdc();
	386	j = in_fdc();
	387	printf("ST0 = %X, PCN = %X\n",i,j);
	388
	389	if (bp) badtrans(dp,bp);
	390	}
	391
	392	/****************************************************************************/
	393	/* fdintr */
	394	/****************************************************************************/
	395	fdintr(vec)
	396	int vec;
	397	{
	398	register struct buf dp,bp;
	399	struct buf *dpother;
32f56e31	400	int read,head,trac,sec,i,s,sectrac,cyl;
7ff33365 DA	401	unsigned long blknum;
7ff33365 DA	402	struct fd_type *ft;
32f56e31 BJ	403
	404	#ifdef FDTEST
	405	printf("state %d, vec %d, dr %d\|",fd_state,vec,fd_drive);
	406	#endif
7ff33365 DA	407
	408	dp = &fd_unit[fd_drive].head;
	409	bp = dp->b_actf;
	410	read = bp->b_flags & B_READ;
32f56e31	411	ft = &fd_types[FDTYPE(bp->b_dev)];
7ff33365 DA	412
	413	switch (fd_state) {
	414	case 1 : /* SEEK DONE, START DMA */
32f56e31 BJ	415	/* Make sure seek really happened*/
	416	if (vec) {
	417	out_fdc(0x8);
	418	i = in_fdc();
	419	cyl = in_fdc();
	420	if (!(i&0x20) \|\| (cyl != bp->b_cylin*dp->b_step)) {
	421	printf("Stray int ST0 = %X, PCN = %X:",i,cyl);
	422	return;
	423	}
	424	}
	425
7ff33365	426	fd_track = bp->b_cylin;
32f56e31	427	at_dma(read,bp->b_un.b_addr+fd_skip,FDBLK, fd_dmachan);
7ff33365 DA	428	blknum = (unsigned long)bp->b_blkno*DEV_BSIZE/FDBLK
	429	+ fd_skip/FDBLK;
	430	sectrac = ft->sectrac;
	431	sec = blknum % (sectrac * 2);
	432	head = sec / sectrac;
	433	sec = sec % sectrac + 1;
	434
	435	if (read) out_fdc(0xE6); /* READ */
	436	else out_fdc(0xC5); /* WRITE */
	437	out_fdc(head << 2 \| fd_drive); /* head & unit */
	438	out_fdc(fd_track); /* track */
	439	out_fdc(head);
	440	out_fdc(sec); /* sector XXX +1? */
	441	out_fdc(ft->secsize); /* sector size */
	442	out_fdc(sectrac); /* sectors/track */
	443	out_fdc(ft->gap); /* gap size */
	444	out_fdc(ft->datalen); /* data length */
	445	fd_state = 2;
	446	/* XXX PARANOIA */
	447	untimeout(fd_timeout,2);
	448	timeout(fd_timeout,2,hz);
	449	break;
	450	case 2 : /* IO DONE, post-analyze */
	451	untimeout(fd_timeout,2);
	452	for(i=0;i<7;i++) {
	453	fd_status[i] = in_fdc();
	454	}
	455	if (fd_status[0]&0xF8) {
	456	#ifdef FDOTHER
32f56e31	457	printf("status0 err %d:",fd_status[0]);
7ff33365 DA	458	#endif
	459	goto retry;
	460	}
32f56e31	461	/*
7ff33365 DA	462	if (fd_status[1]){
	463	printf("status1 err %d:",fd_status[0]);
	464	goto retry;
	465	}
	466	if (fd_status[2]){
	467	printf("status2 err %d:",fd_status[0]);
	468	goto retry;
	469	}
32f56e31	470	*/
7ff33365 DA	471	/* All OK */
	472	if (!kernel_space(bp->b_un.b_addr+fd_skip)) {
	473	/* RAW transfer */
32f56e31 BJ	474	if (read) bcopy(dma_bounce[fd_dmachan]->b_un.b_addr,
32f56e31 BJ	475	bp->b_un.b_addr+fd_skip, FDBLK);
7ff33365 DA	476	}
	477	fd_skip += FDBLK;
	478	if (fd_skip >= bp->b_bcount) {
32f56e31 BJ	479	#ifdef FDTEST
	480	printf("DONE %d\|", bp->b_blkno);
	481	#endif
7ff33365 DA	482	/* ALL DONE */
	483	fd_skip = 0;
	484	bp->b_resid = 0;
	485	dp->b_actf = bp->av_forw;
	486	biodone(bp);
	487	nextstate(dp);
	488
	489	} else {
32f56e31 BJ	490	#ifdef FDDEBUG
	491	printf("next\|");
	492	#endif
7ff33365 DA	493	/* set up next transfer */
	494	blknum = (unsigned long)bp->b_blkno*DEV_BSIZE/FDBLK
	495	+ fd_skip/FDBLK;
	496	fd_state = 1;
	497	bp->b_cylin = (blknum / (ft->sectrac * 2));
7ff33365	498	if (bp->b_cylin != fd_track) {
32f56e31 BJ	499	#ifdef FDTEST
	500	printf("Seek\|");
	501	#endif
7ff33365 DA	502	/* SEEK Necessary */
	503	out_fdc(15); /* Seek function */
	504	out_fdc(fd_drive);/* Drive number */
32f56e31	505	out_fdc(bp->b_cylin * dp->b_step);
7ff33365	506	break;
32f56e31	507	} else fdintr(0);
7ff33365 DA	508	}
	509	break;
	510	case 3:
32f56e31 BJ	511	#ifdef FDOTHER
	512	printf("Seek %d %d\n", bp->b_cylin, dp->b_step);
	513	#endif
7ff33365 DA	514	/* Seek necessary */
	515	out_fdc(15); /* Seek function */
	516	out_fdc(fd_drive);/* Drive number */
32f56e31	517	out_fdc(bp->b_cylin * dp->b_step);
7ff33365 DA	518	fd_state = 1;
	519	break;
	520	case 4:
	521	out_fdc(3); /* specify command */
	522	out_fdc(0xDF);
	523	out_fdc(2);
	524	out_fdc(7); /* Recalibrate Function */
	525	out_fdc(fd_drive);
	526	fd_state = 3;
	527	break;
32f56e31 BJ	528	case 5:
	529	#ifdef FDOTHER
	530	printf("RESET\n");
	531	#endif
	532	/* Try a reset, keep motor on */
	533	set_motor(fd_drive,1);
	534	set_motor(fd_drive,0);
	535	outb(fdc+fdctl,ft->trans);
	536	fd_retry++;
	537	fd_state = 4;
	538	break;
7ff33365	539	default:
7ff33365 DA	540	printf("Unexpected FD int->");
	541	out_fdc(0x8);
	542	i = in_fdc();
	543	sec = in_fdc();
	544	printf("ST0 = %X, PCN = %X\n",i,sec);
	545	out_fdc(0x4A);
	546	out_fdc(fd_drive);
	547	for(i=0;i<7;i++) {
	548	fd_status[i] = in_fdc();
	549	}
	550	printf("intr status :%X %X %X %X %X %X %X ",
	551	fd_status[0], fd_status[1], fd_status[2], fd_status[3],
	552	fd_status[4], fd_status[5], fd_status[6] );
7ff33365 DA	553	break;
	554	}
	555	return;
	556	retry:
	557	switch(fd_retry) {
	558	case 0: case 1:
32f56e31	559	case 2: case 3:
7ff33365	560	break;
32f56e31	561	case 4:
7ff33365	562	fd_retry++;
32f56e31 BJ	563	fd_state = 5;
32f56e31 BJ	564	fdintr(0);
7ff33365	565	return;
32f56e31	566	case 5: case 6: case 7:
7ff33365 DA	567	break;
	568	default:
	569	printf("FD err %X %X %X %X %X %X %X\n",
	570	fd_status[0], fd_status[1], fd_status[2], fd_status[3],
	571	fd_status[4], fd_status[5], fd_status[6] );
	572	badtrans(dp,bp);
	573	return;
	574	}
	575	fd_state = 1;
	576	fd_retry++;
32f56e31	577	fdintr(0);
7ff33365 DA	578	}
	579
	580	badtrans(dp,bp)
	581	struct buf dp,bp;
	582	{
	583
	584	bp->b_flags \|= B_ERROR;
	585	bp->b_error = EIO;
	586	bp->b_resid = bp->b_bcount - fd_skip;
	587	dp->b_actf = bp->av_forw;
	588	fd_skip = 0;
	589	biodone(bp);
	590	nextstate(dp);
	591
	592	}
	593
	594	/*
	595	nextstate : After a transfer is done, continue processing
	596	requests on the current drive queue. If empty, go to
	597	the other drives queue. If that is empty too, timeout
	598	to turn off the current drive in 5 seconds, and go
	599	to state 0 (not expecting any interrupts).
	600	*/
	601
	602	nextstate(dp)
	603	struct buf *dp;
	604	{
	605	struct buf *dpother;
	606
	607	dpother = &fd_unit[fd_drive ? 0 : 1].head;
	608	if (dp->b_actf) fdstart(fd_drive);
	609	else if (dpother->b_actf) {
32f56e31 BJ	610	#ifdef FDTEST
	611	printf("switch\|");
	612	#endif
	613	untimeout(fd_turnoff,fd_drive);
	614	timeout(fd_turnoff,fd_drive,5*hz);
	615	fd_drive = 1 - fd_drive;
7ff33365	616	dp->b_active = 0;
32f56e31 BJ	617	dpother->b_active = 1;
32f56e31 BJ	618	fdstart(fd_drive);
7ff33365	619	} else {
32f56e31 BJ	620	#ifdef FDTEST
	621	printf("off\|");
	622	#endif
7ff33365 DA	623	untimeout(fd_turnoff,fd_drive);
	624	timeout(fd_turnoff,fd_drive,5*hz);
	625	fd_state = 0;
	626	dp->b_active = 0;
	627	}
	628	}
32f56e31	629	#endif