## diffname pc/devata.c 1995/0213
## diff -e /dev/null /n/fornaxdump/1995/0213/sys/src/brazil/pc/devata.c
0a
#include	"u.h"
#include	"../port/lib.h"
#include	"mem.h"
#include	"dat.h"
#include	"fns.h"
#include	"io.h"
#include	"../port/error.h"

#include	"devtab.h"

#define DPRINT if(1)print

typedef	struct Drive		Drive;
typedef	struct Ident		Ident;
typedef	struct Controller	Controller;
typedef struct Partition	Partition;
typedef struct Repl		Repl;

enum
{
	/* ports */
	Pbase=		0x1F0,
	Pdata=		0,	/* data port (16 bits) */
	Perror=		1,	/* error port (read) */
	Pprecomp=	1,	/* buffer mode port (write) */
	Pcount=		2,	/* sector count port */
	Psector=	3,	/* sector number port */
	Pcyllsb=	4,	/* least significant byte cylinder # */
	Pcylmsb=	5,	/* most significant byte cylinder # */
	Pdh=		6,	/* drive/head port */
	Pstatus=	7,	/* status port (read) */
	 Sbusy=		 (1<<7),
	 Sready=	 (1<<6),
	 Sdrq=		 (1<<3),
	 Serr=		 (1<<0),
	Pcmd=		7,	/* cmd port (write) */

	/* commands */
	Crecal=		0x10,
	Cread=		0x20,
	Cwrite=		0x30,
	Cident=		0xEC,
	Cident2=	0xFF,	/* pseudo command for post Cident interrupt */
	Csetbuf=	0xEF,
	Cinitparam=	0x91,

	/* conner specific commands */
	Cstandby=	0xE2,
	Cidle=		0xE1,
	Cpowerdown=	0xE3,

	/* disk states */
	Sspinning,
	Sstandby,
	Sidle,
	Spowerdown,

	/* file types */
	Qdir=		0,

	Maxxfer=	BY2PG,		/* maximum transfer size/cmd */
	Npart=		8+2,		/* 8 sub partitions, disk, and partition */
	Nrepl=		64,		/* maximum replacement blocks */
};
#define PART(x)		((x)&0xF)
#define DRIVE(x)	(((x)>>4)&0x7)
#define MKQID(d,p)	(((d)<<4) | (p))

struct Partition
{
	ulong	start;
	ulong	end;
	char	name[NAMELEN+1];
};

struct Repl
{
	Partition *p;
	int	nrepl;
	ulong	blk[Nrepl];
};

#define PARTMAGIC	"plan9 partitions"
#define REPLMAGIC	"block replacements"

/*
 *  an ata drive
 */
struct Drive
{
	QLock;

	Controller *cp;
	int	drive;
	int	confused;	/* needs to be recalibrated (or worse) */
	int	online;
	int	npart;		/* number of real partitions */
	Partition p[Npart];
	Repl	repl;
	ulong	usetime;
	int	state;
	char	vol[NAMELEN];

	ulong	cap;		/* total bytes */
	int	bytes;		/* bytes/sector */
	int	sectors;	/* sectors/track */
	int	heads;		/* heads/cyl */
	long	cyl;		/* cylinders/drive */

	char	lba;		/* true if drive has logical block addressing */
	char	multi;		/* non-zero if drive does multiple block xfers */
};

/*
 *  a controller for 2 drives
 */
struct Controller
{
	QLock;			/* exclusive access to the controller */

	Lock;			/* exclusive access to the registers */

	int	confused;	/* needs to be recalibrated (or worse) */
	int	pbase;		/* base port */

	/*
	 *  current operation
	 */
	int	cmd;		/* current command */
	int	lastcmd;	/* debugging info */
	Rendez	r;		/* wait here for command termination */
	char	*buf;		/* xfer buffer */
	int	nsecs;		/* length of transfer (sectors) */
	int	sofar;		/* sectors transferred so far */
	int	status;
	int	error;
	Drive	*dp;		/* drive being accessed */
};

Controller	*atac;
Drive		*ata;
static int	spindowntime;

static void	ataintr(Ureg*, void*);
static long	ataxfer(Drive*, Partition*, int, long, long, char*);
static void	ataident(Drive*);
static void	atasetbuf(Drive*, int);
static void	ataparams(Drive*);
static void	atapart(Drive*);
static int	ataprobe(Drive*, int, int, int);

static int
atagen(Chan *c, Dirtab *tab, long ntab, long s, Dir *dirp)
{
	Qid qid;
	int drive;
	char name[NAMELEN+4];
	Drive *dp;
	Partition *pp;
	ulong l;

	USED(tab, ntab);
	qid.vers = 0;
	drive = s/Npart;
	s = s % Npart;
	if(drive >= conf.nhard)
		return -1;
	dp = &ata[drive];

	if(s >= dp->npart)
		return 0;

	pp = &dp->p[s];
	sprint(name, "%s%s", dp->vol, pp->name);
	name[NAMELEN] = 0;
	qid.path = MKQID(drive, s);
	l = (pp->end - pp->start) * dp->bytes;
	devdir(c, qid, name, l, eve, 0660, dirp);
	return 1;
}

/*
 *  we assume drives 0 and 1 are on the first controller, 2 and 3 on the
 *  second, etc.
 */
void
atareset(void)
{
	Drive *dp;
	Controller *cp;
	int drive;
	uchar equip;
	char *p;

	ata = xalloc(conf.nhard * sizeof(Drive));
	atac = xalloc(((conf.nhard+1)/2) * sizeof(Controller));
	
	/*
	 *  read nvram for number of ata drives (2 max)
	 */
	equip = nvramread(0x12);
	if(conf.nhard > 0 && (equip>>4) == 0)
		conf.nhard = 0;
	if(conf.nhard > 1 && (equip&0xf) == 0)
		conf.nhard = 1;
	if(conf.nhard > 2)
		conf.nhard = 2;

	for(drive = 0; drive < conf.nhard; drive++){
		dp = &ata[drive];
		cp = &atac[drive/2];
		dp->drive = drive&1;
		dp->online = 0;
		dp->cp = cp;
		if((drive&1) == 0){
			cp->buf = 0;
			cp->lastcmd = cp->cmd;
			cp->cmd = 0;
			cp->pbase = Pbase;
			setvec(Hardvec, ataintr, 0);
		}
	}
	
	if(conf.nhard && (p = getconf("spindowntime")))
		spindowntime = atoi(p);
}

void
atainit(void)
{
}

/*
 *  Get the characteristics of each drive.  Mark unresponsive ones
 *  off line.
 */
Chan*
ataattach(char *spec)
{
	Drive *dp;

	for(dp = ata; dp < &ata[conf.nhard]; dp++){
		if(waserror()){
			dp->online = 0;
			qunlock(dp);
			continue;
		}
		qlock(dp);
		if(!dp->online){
			/*
			 * Make sure ataclock() doesn't
			 * interfere.
			 */
			dp->usetime = m->ticks;
			ataparams(dp);
			dp->online = 1;
			atasetbuf(dp, 1);
		}

		/*
		 *  read Plan 9 partition table
		 */
		atapart(dp);
		qunlock(dp);
		poperror();
	}
	return devattach('H', spec);
}

Chan*
ataclone(Chan *c, Chan *nc)
{
	return devclone(c, nc);
}

int
atawalk(Chan *c, char *name)
{
	return devwalk(c, name, 0, 0, atagen);
}

void
atastat(Chan *c, char *dp)
{
	devstat(c, dp, 0, 0, atagen);
}

Chan*
ataopen(Chan *c, int omode)
{
	return devopen(c, omode, 0, 0, atagen);
}

void
atacreate(Chan *c, char *name, int omode, ulong perm)
{
	USED(c, name, omode, perm);
	error(Eperm);
}

void
ataclose(Chan *c)
{
	Drive *d;
	Partition *p;

	if(c->mode != OWRITE && c->mode != ORDWR)
		return;

	d = &ata[DRIVE(c->qid.path)];
	p = &d->p[PART(c->qid.path)];
	if(strcmp(p->name, "partition") != 0)
		return;

	if(waserror()){
		qunlock(d);
		nexterror();
	}
	qlock(d);
	atapart(d);
	qunlock(d);
	poperror();
}

void
ataremove(Chan *c)
{
	USED(c);
	error(Eperm);
}

void
atawstat(Chan *c, char *dp)
{
	USED(c, dp);
	error(Eperm);
}

long
ataread(Chan *c, void *a, long n, ulong offset)
{
	Drive *dp;
	long rv, i;
	int skip;
	uchar *aa = a;
	Partition *pp;
	char *buf;

	if(c->qid.path == CHDIR)
		return devdirread(c, a, n, 0, 0, atagen);

	buf = smalloc(Maxxfer);
	if(waserror()){
		free(buf);
		nexterror();
	}

	dp = &ata[DRIVE(c->qid.path)];
	pp = &dp->p[PART(c->qid.path)];

	skip = offset % dp->bytes;
	for(rv = 0; rv < n; rv += i){
		i = ataxfer(dp, pp, Cread, offset+rv-skip, n-rv+skip, buf);
		if(i == 0)
			break;
		i -= skip;
		if(i > n - rv)
			i = n - rv;
		memmove(aa+rv, buf + skip, i);
		skip = 0;
	}

	free(buf);
	poperror();

	return rv;
}

Block*
atabread(Chan *c, long n, ulong offset)
{
	return devbread(c, n, offset);
}

long
atawrite(Chan *c, void *a, long n, ulong offset)
{
	Drive *dp;
	long rv, i, partial;
	uchar *aa = a;
	Partition *pp;
	char *buf;

	if(c->qid.path == CHDIR)
		error(Eisdir);

	dp = &ata[DRIVE(c->qid.path)];
	pp = &dp->p[PART(c->qid.path)];
	buf = smalloc(Maxxfer);
	if(waserror()){
		free(buf);
		nexterror();
	}

	/*
	 *  if not starting on a sector boundary,
	 *  read in the first sector before writing
	 *  it out.
	 */
	partial = offset % dp->bytes;
	if(partial){
		ataxfer(dp, pp, Cread, offset-partial, dp->bytes, buf);
		if(partial+n > dp->bytes)
			rv = dp->bytes - partial;
		else
			rv = n;
		memmove(buf+partial, aa, rv);
		ataxfer(dp, pp, Cwrite, offset-partial, dp->bytes, buf);
	} else
		rv = 0;

	/*
	 *  write out the full sectors
	 */
	partial = (n - rv) % dp->bytes;
	n -= partial;
	for(; rv < n; rv += i){
		i = n - rv;
		if(i > Maxxfer)
			i = Maxxfer;
		memmove(buf, aa+rv, i);
		i = ataxfer(dp, pp, Cwrite, offset+rv, i, buf);
		if(i == 0)
			break;
	}

	/*
	 *  if not ending on a sector boundary,
	 *  read in the last sector before writing
	 *  it out.
	 */
	if(partial){
		ataxfer(dp, pp, Cread, offset+rv, dp->bytes, buf);
		memmove(buf, aa+rv, partial);
		ataxfer(dp, pp, Cwrite, offset+rv, dp->bytes, buf);
		rv += partial;
	}

	free(buf);
	poperror();

	return rv;
}

long
atabwrite(Chan *c, Block *bp, ulong offset)
{
	return devbwrite(c, bp, offset);
}

/*
 *  did an interrupt happen?
 */
static int
cmddone(void *a)
{
	Controller *cp = a;

	return cp->cmd == 0;
}

/*
 * Wait for the controller to be ready to accept a command.
 * This is protected from intereference by ataclock() by
 * setting dp->usetime before it is called.
 */
static void
cmdreadywait(Drive *dp)
{
	long start;
	int period;
	Controller *cp = dp->cp;

	/* give it 2 seconds to spin down and up */
	if(dp->state == Sspinning)
		period = 10;
	else
		period = 2000;

	start = m->ticks;
	while((inb(cp->pbase+Pstatus) & (Sready|Sbusy)) != Sready)
		if(TK2MS(m->ticks - start) > period){
			DPRINT("cmdreadywait failed\n");
			error(Eio);
		}
}

static void
atarepl(Drive *dp, long bblk)
{
	int i;

	if(dp->repl.p == 0)
		return;
	for(i = 0; i < dp->repl.nrepl; i++){
		if(dp->repl.blk[i] == bblk)
			DPRINT("found bblk %ld at offset %ld\n", bblk, i);
	}
}

/*
 *  transfer a number of sectors.  ataintr will perform all the iterative
 *  parts.
 */
static long
ataxfer(Drive *dp, Partition *pp, int cmd, long start, long len, char *buf)
{
	Controller *cp;
	long lblk;
	int cyl, sec, head;
	int loop, stat;

	if(dp->online == 0)
		error(Eio);

	/*
	 *  cut transfer size down to disk buffer size
	 */
	start = start / dp->bytes;
	if(len > Maxxfer)
		len = Maxxfer;
	len = (len + dp->bytes - 1) / dp->bytes;
	if(len == 0)
		return 0;

	/*
	 *  calculate physical address
	 */
	lblk = start + pp->start;
	if(lblk >= pp->end)
		return 0;
	if(lblk+len > pp->end)
		len = pp->end - lblk;
	if(dp->lba){
		sec = lblk & 0xff;
		cyl = (lblk>>8) & 0xffff;
		head = (lblk>>24) & 0xf;
	} else {
		cyl = lblk/(dp->sectors*dp->heads);
		sec = (lblk % dp->sectors) + 1;
		head = ((lblk/dp->sectors) % dp->heads);
	}

	cp = dp->cp;
	qlock(cp);
	if(waserror()){
		cp->buf = 0;
		qunlock(cp);
		nexterror();
	}

	/*
	 * Make sure hardclock() doesn't
	 * interfere.
	 */
	dp->usetime = m->ticks;
	cmdreadywait(dp);

	ilock(cp);
	cp->sofar = 0;
	cp->buf = buf;
	cp->nsecs = len;
	cp->cmd = cmd;
	cp->dp = dp;
	cp->status = 0;

	outb(cp->pbase+Pcount, cp->nsecs);
	outb(cp->pbase+Psector, sec);
	outb(cp->pbase+Pdh, 0x20 | (dp->drive<<4) | (dp->lba<<6) | head);
	outb(cp->pbase+Pcyllsb, cyl);
	outb(cp->pbase+Pcylmsb, cyl>>8);
	outb(cp->pbase+Pcmd, cmd);

	if(cmd == Cwrite){
		loop = 0;
		while((stat = inb(cp->pbase+Pstatus) & (Serr|Sdrq)) == 0)
			if(++loop > 10000)
				panic("ataxfer");
		outss(cp->pbase+Pdata, cp->buf, dp->bytes/2);
	} else
		stat = 0;
	iunlock(cp);

	if(stat & Serr)
		error(Eio);

	/*
	 *  wait for command to complete.  if we get a note,
	 *  remember it but keep waiting to let the disk finish
	 *  the current command.
	 */
	loop = 0;
	while(waserror()){
		DPRINT("interrupted ataxfer\n");
		if(loop++ > 10){
			print("ata disk error\n");
			nexterror();
		}
	}
	sleep(&cp->r, cmddone, cp);
	dp->state = Sspinning;
	dp->usetime = m->ticks;
	poperror();
	if(loop)
		nexterror();

	if(cp->status & Serr){
		DPRINT("hd%d err: lblk %ld status %lux, err %lux\n",
			dp-ata, lblk, cp->status, cp->error);
		DPRINT("\tcyl %d, sec %d, head %d\n", cyl, sec, head);
		DPRINT("\tnsecs %d, sofar %d\n", cp->nsecs, cp->sofar);
		atarepl(dp, lblk+cp->sofar);
		error(Eio);
	}
	cp->buf = 0;
	len = cp->sofar*dp->bytes;
	qunlock(cp);
	poperror();

	return len;
}

/*
 *  set read ahead mode
 */
static void
atasetbuf(Drive *dp, int on)
{
	Controller *cp = dp->cp;

	qlock(cp);
	if(waserror()){
		qunlock(cp);
		nexterror();
	}

	cmdreadywait(dp);

	ilock(cp);
	cp->cmd = Csetbuf;
	outb(cp->pbase+Pprecomp, on ? 0xAA : 0x55);	/* read look ahead */
	outb(cp->pbase+Pdh, 0x20 | (dp->drive<<4));
	outb(cp->pbase+Pcmd, Csetbuf);
	iunlock(cp);

	sleep(&cp->r, cmddone, cp);

/*	if(cp->status & Serr)
		DPRINT("hd%d setbuf err: status %lux, err %lux\n",
			dp-ata, cp->status, cp->error);/**/

	poperror();
	qunlock(cp);
}

/*
 *  ident sector from drive.  this is from ANSI X3.221-1994
 */
struct Ident
{
	ushort	config;		/* general configuration info */
	ushort	cyls;		/* # of cylinders (default) */
	ushort	reserved0;
	ushort	heads;		/* # of heads (default) */
	ushort	b2t;		/* unformatted bytes/track */
	ushort	b2s;		/* unformated bytes/sector */
	ushort	s2t;		/* sectors/track (default) */
	ushort	reserved1[3];
/* 10 */
	ushort	serial[10];	/* serial number */
	ushort	type;		/* buffer type */
	ushort	bsize;		/* buffer size/512 */
	ushort	ecc;		/* ecc bytes returned by read long */
	ushort	firm[4];	/* firmware revision */
	ushort	model[20];	/* model number */
/* 47 */
	ushort	s2i;		/* number of sectors/interrupt */
	ushort	dwtf;		/* double word transfer flag */
	ushort	capabilities;
	ushort	reserved2;
	ushort	piomode;
	ushort	dmamode;
	ushort	cvalid;		/* (cvald&1) if next 4 words are valid */
	ushort	ccyls;		/* current # cylinders */
	ushort	cheads;		/* current # heads */
	ushort	cs2t;		/* current sectors/track */
	ushort	ccap[2];	/* current capacity in sectors */
	ushort	cs2i;		/* current number of sectors/interrupt */
/* 60 */
	ushort	lbasecs[2];	/* # LBA user addressable sectors */
	ushort	dmasingle;
	ushort	dmadouble;
/* 64 */
	ushort	reserved3[64];
	ushort	vendor[32];	/* vendor specific */
	ushort	reserved4[96];
};

/*
 *  get parameters from the drive
 */
static void
ataident(Drive *dp)
{
	Controller *cp;
	char *buf;
	Ident *ip;
	char id[21];

	cp = dp->cp;
	buf = smalloc(Maxxfer);
	qlock(cp);
	if(waserror()){
		qunlock(cp);
		nexterror();
	}

	cmdreadywait(dp);

	ilock(cp);
	cp->nsecs = 1;
	cp->sofar = 0;
	cp->cmd = Cident;
	cp->dp = dp;
	cp->buf = buf;
	outb(cp->pbase+Pdh, 0x20 | (dp->drive<<4));
	outb(cp->pbase+Pcmd, Cident);
	iunlock(cp);

	sleep(&cp->r, cmddone, cp);
	if(cp->status & Serr){
		DPRINT("bad disk ident status\n");
		error(Eio);
	}
	ip = (Ident*)buf;

	/*
	 * this function appears to respond with an extra interrupt after
	 * the ident information is read, except on the safari.  The following
	 * delay gives this extra interrupt a chance to happen while we are quiet.
	 * Otherwise, the interrupt may come during a subsequent read or write,
	 * causing a panic and much confusion.
	 */
	if (cp->cmd == Cident2)
		tsleep(&cp->r, return0, 0, 10);

	memmove(id, ip->model, sizeof(id)-1);
	id[sizeof(id)-1] = 0;

	if(ip->capabilities & (1<<9)){
		dp->lba = 1;
		dp->sectors = (ip->lbasecs[0]) | (ip->lbasecs[1]<<16);
		dp->cap = dp->bytes * dp->sectors;
		print("ata%d model %s with %d lba sectors\n", dp->drive,
			id, dp->sectors);
	} else {
		dp->lba = 0;

		/* use default (unformatted) settings */
		dp->cyl = ip->cyls;
		dp->heads = ip->heads;
		dp->sectors = ip->s2t;
		print("ata%d model %s with default %d cyl %d head %d sec\n", dp->drive,
			id, dp->cyl, dp->heads, dp->sectors);

		if(ip->cvalid&(1<<0)){
			/* use current settings */
			dp->cyl = ip->ccyls;
			dp->heads = ip->cheads;
			dp->sectors = ip->cs2t;
			print("\tchanged to %d cyl %d head %d sec\n", dp->cyl,
				dp->heads, dp->sectors);
		}
		dp->cap = dp->bytes * dp->cyl * dp->heads * dp->sectors;
	}
	cp->lastcmd = cp->cmd;
	cp->cmd = 0;
	cp->buf = 0;
	free(buf);
	poperror();
	qunlock(cp);
}

/*
 *  probe the given sector to see if it exists
 */
static int
ataprobe(Drive *dp, int cyl, int sec, int head)
{
	Controller *cp;
	char *buf;
	int rv;

	cp = dp->cp;
	buf = smalloc(Maxxfer);
	qlock(cp);
	if(waserror()){
		free(buf);
		qunlock(cp);
		nexterror();
	}

	cmdreadywait(dp);

	ilock(cp);
	cp->cmd = Cread;
	cp->dp = dp;
	cp->status = 0;
	cp->nsecs = 1;
	cp->sofar = 0;

	outb(cp->pbase+Pcount, 1);
	outb(cp->pbase+Psector, sec+1);
	outb(cp->pbase+Pdh, 0x20 | head | (dp->drive<<4));
	outb(cp->pbase+Pcyllsb, cyl);
	outb(cp->pbase+Pcylmsb, cyl>>8);
	outb(cp->pbase+Pcmd, Cread);
	iunlock(cp);

	sleep(&cp->r, cmddone, cp);

	if(cp->status & Serr)
		rv = -1;
	else
		rv = 0;

	cp->buf = 0;
	free(buf);
	poperror();
	qunlock(cp);
	return rv;
}

/*
 *  figure out the drive parameters
 */
static void
ataparams(Drive *dp)
{
	int i, hi, lo;

	/*
	 *  first try the easy way, ask the drive and make sure it
	 *  isn't lying.
	 */
	dp->bytes = 512;
	ataident(dp);
	if(dp->lba){
		i = dp->sectors - 1;
		if(ataprobe(dp, (i>>8)&0xffff, i&0xff, (i>>24)&0xf) == 0)
			return;
	} else {
		if(ataprobe(dp, dp->cyl-1, dp->sectors-1, dp->heads-1) == 0)
			return;
	}

	/*
	 *  the drive lied, determine parameters by seeing which ones
	 *  work to read sectors.
	 */
print("ata%d lied.  probing...\n", dp->drive);
	dp->lba = 0;
	for(i = 0; i < 32; i++)
		if(ataprobe(dp, 0, 0, i) < 0)
			break;
	dp->heads = i;
	for(i = 0; i < 128; i++)
		if(ataprobe(dp, 0, i, 0) < 0)
			break;
	dp->sectors = i;
	for(i = 512; ; i += 512)
		if(ataprobe(dp, i, dp->sectors-1, dp->heads-1) < 0)
			break;
	lo = i - 512;
	hi = i;
	for(; hi-lo > 1;){
		i = lo + (hi - lo)/2;
		if(ataprobe(dp, i, dp->sectors-1, dp->heads-1) < 0)
			hi = i;
		else
			lo = i;
	}
	dp->cyl = lo + 1;
	dp->cap = dp->bytes * dp->cyl * dp->heads * dp->sectors;
}

/*
 *  Read block replacement table.
 *  The table is just ascii block numbers.
 */
static void
atareplinit(Drive *dp)
{
	char *line[Nrepl+1];
	char *field[1];
	ulong n;
	int i;
	char *buf;

	/*
	 *  check the partition is big enough
	 */
	if(dp->repl.p->end - dp->repl.p->start < Nrepl+1){
		dp->repl.p = 0;
		return;
	}

	buf = smalloc(Maxxfer);
	if(waserror()){
		free(buf);
		nexterror();
	}

	/*
	 *  read replacement table from disk, null terminate
	 */
	ataxfer(dp, dp->repl.p, Cread, 0, dp->bytes, buf);
	buf[dp->bytes-1] = 0;

	/*
	 *  parse replacement table.
	 */
	n = getfields(buf, line, Nrepl+1, "\n");
	if(strncmp(line[0], REPLMAGIC, sizeof(REPLMAGIC)-1)){
		dp->repl.p = 0;
	} else {
		for(dp->repl.nrepl = 0, i = 1; i < n; i++, dp->repl.nrepl++){
			if(getfields(line[i], field, 1, " ") != 1)
				break;
			dp->repl.blk[dp->repl.nrepl] = strtoul(field[0], 0, 0);
			if(dp->repl.blk[dp->repl.nrepl] <= 0)
				break;
		}
	}
	free(buf);
	poperror();
}

/*
 *  read partition table.  The partition table is just ascii strings.
 */
static void
atapart(Drive *dp)
{
	Partition *pp;
	char *line[Npart+1];
	char *field[3];
	ulong n;
	int i;
	char *buf;

	sprint(dp->vol, "hd%d", dp - ata);

	/*
	 *  we always have a partition for the whole disk
	 *  and one for the partition table
	 */
	pp = &dp->p[0];
	strcpy(pp->name, "disk");
	pp->start = 0;
	pp->end = dp->cap / dp->bytes;
	pp++;
	strcpy(pp->name, "partition");
	pp->start = dp->p[0].end - 1;
	pp->end = dp->p[0].end;
	dp->npart = 2;

	/*
	 * initialise the bad-block replacement info
	 */
	dp->repl.p = 0;

	buf = smalloc(Maxxfer);
	if(waserror()){
		free(buf);
		nexterror();
	}

	/*
	 *  read last sector from disk, null terminate.  This used
	 *  to be the sector we used for the partition tables.
	 *  However, this sector is special on some PC's so we've
	 *  started to use the second last sector as the partition
	 *  table instead.  To avoid reconfiguring all our old systems
	 *  we first look to see if there is a valid partition
	 *  table in the last sector.  If so, we use it.  Otherwise
	 *  we switch to the second last.
	 */
	ataxfer(dp, pp, Cread, 0, dp->bytes, buf);
	buf[dp->bytes-1] = 0;
	n = getfields(buf, line, Npart+1, "\n");
	if(n == 0 || strncmp(line[0], PARTMAGIC, sizeof(PARTMAGIC)-1)){
		dp->p[0].end--;
		dp->p[1].start--;
		dp->p[1].end--;
		ataxfer(dp, pp, Cread, 0, dp->bytes, buf);
		buf[dp->bytes-1] = 0;
		n = getfields(buf, line, Npart+1, "\n");
	}

	/*
	 *  parse partition table.
	 */
	if(n && strncmp(line[0], PARTMAGIC, sizeof(PARTMAGIC)-1) == 0){
		for(i = 1; i < n; i++){
			pp++;
			switch(getfields(line[i], field, 3, " ")) {
			case 2:
				if(strcmp(field[0], "unit") == 0)
					strncpy(dp->vol, field[1], NAMELEN);
				break;	
			case 3:
				strncpy(pp->name, field[0], NAMELEN);
				if(strncmp(pp->name, "repl", NAMELEN) == 0)
					dp->repl.p = pp;
				pp->start = strtoul(field[1], 0, 0);
				pp->end = strtoul(field[2], 0, 0);
				if(pp->start > pp->end || pp->start >= dp->p[0].end)
					break;
				dp->npart++;
			}
		}
	}
	free(buf);
	poperror();

	if(dp->repl.p)
		atareplinit(dp);
}

/*
 *  we get an interrupt for every sector transferred
 */
static void
ataintr(Ureg *ur, void *arg)
{
	Controller *cp;
	Drive *dp;
	long loop;
	char *addr;

	USED(ur, arg);

	/*
 	 *  BUG!! if there is ever more than one controller, we need a way to
	 *	  distinguish which interrupted (use arg).
	 */
	cp = &atac[0];
	dp = cp->dp;

	ilock(cp);

	loop = 0;
	while((cp->status = inb(cp->pbase+Pstatus)) & Sbusy){
		if(++loop > 100) {
			DPRINT("cmd=%lux status=%lux\n",
				cp->cmd, inb(cp->pbase+Pstatus));
			panic("ataintr: wait busy");
		}
	}

	switch(cp->cmd){
	case Cwrite:
		if(cp->status & Serr){
			cp->lastcmd = cp->cmd;
			cp->cmd = 0;
			cp->error = inb(cp->pbase+Perror);
			wakeup(&cp->r);
			break;
		}
		cp->sofar++;
		if(cp->sofar < cp->nsecs){
			loop = 0;
			while(((cp->status = inb(cp->pbase+Pstatus)) & Sdrq) == 0)
				if(++loop > 100) {
					DPRINT("cmd=%lux status=%lux\n",
						cp->cmd, inb(cp->pbase+Pstatus));
					panic("ataintr: write");
				}
			addr = cp->buf;
			if(addr){
				addr += cp->sofar*dp->bytes;
				outss(cp->pbase+Pdata, addr, dp->bytes/2);
			}
		} else{
			cp->lastcmd = cp->cmd;
			cp->cmd = 0;
			wakeup(&cp->r);
		}
		break;
	case Cread:
	case Cident:
		loop = 0;
		while((cp->status & (Serr|Sdrq)) == 0){
			if(++loop > 10000) {
				DPRINT("cmd=%lux status=%lux\n",
					cp->cmd, inb(cp->pbase+Pstatus));
				panic("ataintr: read/ident");
			}
			cp->status = inb(cp->pbase+Pstatus);
		}
		if(cp->status & Serr){
			cp->lastcmd = cp->cmd;
			cp->cmd = 0;
			cp->error = inb(cp->pbase+Perror);
			wakeup(&cp->r);
			break;
		}
		addr = cp->buf;
		if(addr){
			addr += cp->sofar*dp->bytes;
			inss(cp->pbase+Pdata, addr, dp->bytes/2);
		}
		cp->sofar++;
		if(cp->sofar > cp->nsecs)
			print("ataintr %d %d\n", cp->sofar, cp->nsecs);
		if(cp->sofar >= cp->nsecs){
			cp->lastcmd = cp->cmd;
			if (cp->cmd == Cread)
				cp->cmd = 0;
			else
				cp->cmd = Cident2;
			wakeup(&cp->r);
		}
		break;
	case Cinitparam:
	case Csetbuf:
	case Cidle:
	case Cstandby:
	case Cpowerdown:
		cp->lastcmd = cp->cmd;
		cp->cmd = 0;
		wakeup(&cp->r);
		break;
	case Cident2:
		cp->lastcmd = cp->cmd;
		cp->cmd = 0;
		break;
	default:
		print("weird disk interrupt, cmd=%.2ux, lastcmd= %.2ux status=%.2ux\n",
			cp->cmd, cp->lastcmd, cp->status);
		break;
	}

	iunlock(cp);
}

void
hardclock(void)
{
	int drive;
	Drive *dp;
	Controller *cp;
	int diff;

	if(spindowntime <= 0)
		return;

	for(drive = 0; drive < conf.nhard; drive++){
		dp = &ata[drive];
		cp = dp->cp;

		diff = TK2SEC(m->ticks - dp->usetime);
		if((dp->state == Sspinning) && (diff >= spindowntime)){
			ilock(cp);
			cp->cmd = Cstandby;
			outb(cp->pbase+Pcount, 0);
			outb(cp->pbase+Pdh, 0x20 | (dp->drive<<4) | 0);
			outb(cp->pbase+Pcmd, cp->cmd);
			iunlock(cp);
			dp->state = Sstandby;
		}
	}
}
.
## diffname pc/devata.c 1995/0214
## diff -e /n/fornaxdump/1995/0213/sys/src/brazil/pc/devata.c /n/fornaxdump/1995/0214/sys/src/brazil/pc/devata.c
1180c
			iunlock(&cp->reglock);
.
1175c
			ilock(&cp->reglock);
.
1155c
	iunlock(&cp->reglock);
.
1061c
	ilock(&cp->reglock);
.
828c
	iunlock(&cp->reglock);
.
815c
	ilock(&cp->reglock);
.
738c
	iunlock(&cp->reglock);
.
730c
	ilock(&cp->reglock);
.
654c
	iunlock(&cp->reglock);
.
649c
	ilock(&cp->reglock);
.
592c
	iunlock(&cp->reglock);
.
569c
	ilock(&cp->reglock);
.
121c
	Lock	reglock;	/* exclusive access to the registers */
.
## diffname pc/devata.c 1995/0215
## diff -e /n/fornaxdump/1995/0214/sys/src/brazil/pc/devata.c /n/fornaxdump/1995/0215/sys/src/brazil/pc/devata.c
1178c
			outb(cp->pbase+Pdh, DHmagic | (dp->drive<<4) | 0);
.
1105c
			if(++loop > Maxloop) {
.
1085c
				if(++loop > Maxloop) {
.
1065c
		if(++loop > Maxloop) {
.
1040a
enum
{
	Maxloop=	10000,
};

.
871c
print("ata%d probing...\n", dp->drive);
.
860c
		if(ataprobe(dp, (i>>8)&0xffff, (i&0xff)-1, (i>>24)&0xf) == 0)
.
824c
	outb(cp->pbase+Pdh, DHmagic | head | (dp->lba<<6) | (dp->drive<<4));
.
781,782c
/*print("\tchanged to %d cyl %d head %d sec\n", dp->cyl, dp->heads, dp->sectors);/**/
.
773,774c
/*print("\nata%d model %s with default %d cyl %d head %d sec\n", dp->drive,
			id, dp->cyl, dp->heads, dp->sectors);/**/
.
764,765c
print("\nata%d model %s with %d lba sectors\n", dp->drive, id, dp->sectors);
.
736c
	outb(cp->pbase+Pdh, DHmagic | (dp->drive<<4));
.
652c
	outb(cp->pbase+Pdh, DHmagic | (dp->drive<<4));
.
579c
	outb(cp->pbase+Pdh, DHmagic | (dp->drive<<4) | (dp->lba<<6) | head);
.
222a
	if((equip & 0x0f)){
		dp->drive = 1;
		dp->online = 0;
		dp->cp = cp;
		dp++;
	}
	conf.nhard = dp - ata;
.
215,221c
		dp++;
.
209,212c
	ata = xalloc(2 * sizeof(Drive));
	atac = xalloc(sizeof(Controller));

	cp = atac;
	cp->buf = 0;
	cp->lastcmd = cp->cmd;
	cp->cmd = 0;
	cp->pbase = Pbase;
	setvec(Hardvec, ataintr, 0);

	dp = ata;
	if(equip & 0xf0){
		dp->drive = 0;
.
202,207c
	if(equip == 0)
		equip = 0x10;		/* the Globalyst 250 lies */
.
195,200d
191d
182,185d
170c
	if(dp->online == 0 || s >= dp->npart)
.
57a
	/* something we have to or into the drive/head reg */
	DHmagic=	0xA0,

.
11c
#define DPRINT if(0)print
.
## diffname pc/devata.c 1995/0222
## diff -e /n/fornaxdump/1995/0215/sys/src/brazil/pc/devata.c /n/fornaxdump/1995/0222/sys/src/brazil/pc/devata.c
762c
/*print("\nata%d model %s with %d lba sectors\n", dp->drive, id, dp->sectors);/**/
.
## diffname pc/devata.c 1995/0726
## diff -e /n/fornaxdump/1995/0222/sys/src/brazil/pc/devata.c /n/fornaxdump/1995/0726/sys/src/brazil/pc/devata.c
295d
293c
atacreate(Chan*, char*, int, ulong)
.
## diffname pc/devata.c 1995/0728
## diff -e /n/fornaxdump/1995/0726/sys/src/brazil/pc/devata.c /n/fornaxdump/1995/0728/sys/src/brazil/pc/devata.c
1122a
		} else {
			/* old drives/controllers hang unless the buffer is emptied */
			for(loop = dp->bytes/2; --loop >= 0;)
				ins(cp->pbase+Pdata);
.
815a
	cp->buf = buf;
.
## diffname pc/devata.c 1995/0818
## diff -e /n/fornaxdump/1995/0728/sys/src/brazil/pc/devata.c /n/fornaxdump/1995/0818/sys/src/brazil/pc/devata.c
1124,1127d
1109c
				cp->status |= Serr;
				break;
.
1106,1107c
			if(++loop > Maxloop){
				print("ataintr: read/ident cmd=%lux status=%lux\n",
.
1089,1090d
1086,1087c
				if(++loop > Maxloop)
					panic("ataintr: write cmd=%lux status=%lux\n",
.
1069,1070d
1066,1067c
		if(++loop > Maxloop)
			panic("ataintr: wait busy cmd=%lux status=%lux",
.
1039c
	Maxloop=	1000000,
.
867d
826c
	atasleep(cp);
.
759c
		dp->sectors = lbasecs;
.
757c
	lbasecs = (ip->lbasecs[0]) | (ip->lbasecs[1]<<16);
	if((ip->capabilities & (1<<9)) && (lbasecs & 0xf0000000) == 0){
.
752c
		tsleep(&cp->r, return0, 0, Hardtimeout);
.
737c
	atasleep(cp);

.
715a
	ulong lbasecs;
.
653c
	atasleep(cp);
.
607c
	atasleep(cp);
.
550a
/*print("ataxfer cyl %d sec %d head %d\n", cyl, sec, head);/**/

.
507a
static void
atasleep(Controller *cp)
{
	tsleep(&cp->r, cmddone, cp, Hardtimeout);
	if(cp->cmd && cp->cmd != Cident2){
		DPRINT("hard drive timeout\n");
		error("ata drive timeout");
	}
}


.
294a
	USED(c, name, omode, perm);
.
293c
atacreate(Chan *c, char *name, int omode, ulong perm)
.
204,205c
	cp->pbase = Pbase0;
	setvec(ATAvec0, ataintr, 0);
.
66a

	Hardtimeout=	4000,		/* disk access timeout */
.
22c
	Pbase0=		0x1F0,
	Pbase1=		0x170,
.
## diffname pc/devata.c 1995/0908
## diff -e /n/fornaxdump/1995/0818/sys/src/brazil/pc/devata.c /n/fornaxdump/1995/0908/sys/src/brazil/pc/devata.c
892c
	for(i = 0; i < 64; i++)
.
888c
	for(i = 0; i < 16; i++)
.
## diffname pc/devata.c 1995/1206
## diff -e /n/fornaxdump/1995/0908/sys/src/brazil/pc/devata.c /n/fornaxdump/1995/1206/sys/src/brazil/pc/devata.c
1199a
	}
}

static int
isatapi(Drive *dp)
{
	Controller *cp;

	cp = dp->cp;
	outb(cp->pbase+Pdh, dp->dh);
	DPRINT("%s: isatapi %d\n", dp->vol, dp->atapi);
	if(dp->atapi){
		outb(cp->pbase+Pcmd, 0x08);
		delay(20);
	}
	dp->atapi = 0;
	dp->bytes = 512;
	microdelay(1);
	if(inb(cp->pbase+Pstatus)){
		DPRINT("%s: isatapi status %ux\n", dp->vol, inb(cp->pbase+Pstatus));
		return 0;
	}
	if(inb(cp->pbase+Pcylmsb) != 0xEB || inb(cp->pbase+Pcyllsb) != 0x14){
		DPRINT("%s: isatapi cyl %ux %ux\n",
			dp->vol, inb(cp->pbase+Pcylmsb), inb(cp->pbase+Pcyllsb));
		return 0;
	}
	dp->atapi = 1;
	sprint(dp->vol, "atapi%d", dp->driveno);
	dp->spindown = 0;
	spindownmask &= ~(1<<dp->driveno);
	return 1;
}

static void
atapiexec(Drive *dp)
{
	Controller *cp;
	int loop;

	cp = dp->cp;

	if(cmdreadywait(dp)){
		error(Eio);
	}
	
	ILOCK(&cp->reglock);
	cp->nsecs = 1;
	cp->sofar = 0;
	cp->error = 0;
	cp->cmd = Cpktcmd;
	outb(cp->pbase+Pcount, 0);
	outb(cp->pbase+Psector, 0);
	outb(cp->pbase+Pfeature, 0);
	outb(cp->pbase+Pcyllsb, cp->len);
	outb(cp->pbase+Pcylmsb, cp->len>>8);
	outb(cp->pbase+Pdh, dp->dh);
	outb(cp->pbase+Pcmd, cp->cmd);

	if(dp->drqintr == 0){
		microdelay(1);
		for(loop = 0; (inb(cp->pbase+Pstatus) & (Serr|Sdrq)) == 0; loop++){
			if(loop < 10000)
				continue;
			panic("%s: cmddrqwait: cmd=%lux status=%lux\n",
				dp->vol, cp->cmd, inb(cp->pbase+Pstatus));
		}
		outss(cp->pbase+Pdata, cp->cmdblk, sizeof(cp->cmdblk)/2);
	}
	IUNLOCK(&cp->reglock);

	loop = 0;
	while(waserror()){
		DPRINT("%s: interrupted atapiexec\n", dp->vol);
		if(loop++ > 10){
			print("%s: disk error\n", dp->vol);
			nexterror();
		}
	}
	atasleep(cp);
	poperror();
	if(loop)
		nexterror();

	if(cp->status & Serr){
		DPRINT("%s: Bad packet command %ux\n", dp->vol, cp->error);
		error(Eio);
	}
}

static long
atapiio(Drive *dp, char *a, ulong len, ulong offset)
{
	ulong bn, n, o, m;
	Controller *cp;
	uchar *buf;
	int retrycount;

	cp = dp->cp;

	buf = smalloc(Maxxfer);
	qlock(cp->ctlrlock);
	retrycount = 1;
retry:
	if(waserror()){
		dp->partok = 0;
		if((cp->status & Serr) && (cp->error & 0xF0) == 0x60){
			dp->vers++;
			if(retrycount){
				retrycount--;
				goto retry;
			}
		}
		cp->dp = 0;
		free(buf);
		qunlock(cp->ctlrlock);
		nexterror();
	}

	cp->buf = buf;
	cp->dp = dp;
	cp->len = dp->bytes;

	n = len;
	while(n > 0){
		bn = offset / dp->bytes;
		if(offset > dp->cap-dp->bytes)
			break;
		o = offset % dp->bytes;
		m = dp->bytes - o;
		if(m > n)
			m = n;
		memset(cp->cmdblk, 0, 12);
		cp->cmdblk[0] = Cread2;
		cp->cmdblk[2] = bn >> 24;
		cp->cmdblk[3] = bn >> 16;
		cp->cmdblk[4] = bn >> 8;
		cp->cmdblk[5] = bn;
		cp->cmdblk[7] = 0;
		cp->cmdblk[8] = 1;
		atapiexec(dp);
		if(cp->count != dp->bytes){
			print("short read\n");
			break;
		}
		memmove(a, cp->buf + o, m);
		n -= m;
		offset += m;
		a += m;
	}
	poperror();
	free(buf);
	cp->dp = 0;
	qunlock(cp->ctlrlock);
	return len-n;
}

static long
atapirwio(Chan *c, char *a, ulong len, ulong offset)
{
	Drive *dp;
	ulong vers;
	long rv;

	dp = atadrive[DRIVE(c->qid.path)];

	qlock(dp);
	if(waserror()){
		qunlock(dp);
		nexterror();
	}

	vers = c->qid.vers;
	c->qid.vers = dp->vers;
	if(vers && vers != dp->vers)
		error(Eio);
	rv = atapiio(dp, a, len, offset);

	poperror();
	qunlock(dp);
	return rv;
}

static void
atapipart(Drive *dp)
{
	Controller *cp;
	uchar *buf, err;
	Partition *pp;
	int retrycount;

	cp = dp->cp;

	pp = &dp->p[0];
	strcpy(pp->name, "disk");
	pp->start = 0;
	pp->end = 0;
	dp->npart = 1;

	buf = smalloc(Maxxfer);
	qlock(cp->ctlrlock);
	retrycount = 1;
retry:
	if(waserror()){
		if((cp->status & Serr) && (cp->error & 0xF0) == 0x60){
			dp->vers++;
			if(retrycount){
				retrycount--;
				goto retry;
			}
		}
		cp->dp = 0;
		free(buf);
		if((cp->status & Serr) && (cp->error & 0xF0) == 0x20)
			err = cp->error;
		else
			err = 0;
		qunlock(cp->ctlrlock);
		if(err == 0x20)
			return;
		nexterror();
	}

	cp->buf = buf;
	cp->dp = dp;

	cp->len = 8;
	cp->count = 0;
	memset(cp->cmdblk, 0, sizeof(cp->cmdblk));
	cp->cmdblk[0] = Ccapacity;
	atapiexec(dp);
	if(cp->count != 8){
		print("cmd=%2.2uX, lastcmd=%2.2uX ", cp->cmd, cp->lastcmd);
		print("cdsize count %d, status 0x%2.2uX, error 0x%2.2uX\n",
			cp->count, cp->status, cp->error);
		error(Eio);
	}
	dp->lbasecs = (cp->buf[0]<<24)|(cp->buf[1]<<16)|(cp->buf[2]<<8)|cp->buf[3];
	dp->cap = dp->lbasecs*dp->bytes;
	cp->dp = 0;
	free(cp->buf);
	poperror();
	qunlock(cp->ctlrlock);

	pp->end = dp->cap / dp->bytes;
	dp->partok = 1;
}

static void
atapiintr(Controller *cp)
{
	uchar cause;
	int count, loop, pbase;
	uchar *addr;

	pbase = cp->pbase;
	cause = inb(pbase+Pcount) & 0x03;
	DPRINT("%s: atapiintr %uX\n", cp->dp->vol, cause);
	switch(cause){

	case 0:						/* data out */
		cp->status |= Serr;
		/*FALLTHROUGH*/
	case 1:						/* command */
		if(cp->status & Serr){
			cp->lastcmd = cp->cmd;
			cp->cmd = 0;
			cp->error = inb(pbase+Perror);
			wakeup(&cp->r); 
			break;
		}
		outss(pbase+Pdata, cp->cmdblk, sizeof(cp->cmdblk)/2);
		break;

	case 2:						/* data in */
		addr = cp->buf;
		if(addr == 0){
			cp->lastcmd = cp->cmd;
			cp->cmd = 0;
			if(cp->status & Serr)
				cp->error = inb(pbase+Perror);
			wakeup(&cp->r);	 
			break;	
		}
		loop = 0;
		while((cp->status & (Serr|Sdrq)) == 0){
			if(++loop > Maxloop){
				cp->status |= Serr;
				break;
			}
			cp->status = inb(pbase+Pstatus);
		}
		if(cp->status & Serr){
			cp->lastcmd = cp->cmd;
			cp->cmd = 0;
			cp->error = inb(pbase+Perror);
			print("%s: Cpktcmd status=%uX, error=%uX\n",
				cp->dp->vol, cp->status, cp->error);
			wakeup(&cp->r);
			break;
		}
		count = inb(pbase+Pcyllsb)|(inb(pbase+Pcylmsb)<<8);
		if (count > Maxxfer) 
			count = Maxxfer;
		inss(pbase+Pdata, addr, count/2);
		cp->count = count;
		cp->lastcmd = cp->cmd; 
		break;

	case 3:						/* status */
		cp->lastcmd = cp->cmd;
		cp->cmd = 0;
		if(cp->status & Serr)
			cp->error = inb(cp->pbase+Perror);
		wakeup(&cp->r);	
		break;
.
1197c
			IUNLOCK(&cp->reglock);
.
1195c
			outb(cp->pbase+Pdh, dp->dh);
.
1191,1192c
		if((dp->state == Sspinning) && (diff >= dp->spindown)){
			DPRINT("%s: spindown\n", dp->vol);
			ILOCK(&cp->reglock);
.
1186,1187c
	for(driveno = 0; driveno < NDrive && mask; driveno++){
		mask &= ~(1<<driveno);
		if((dp = atadrive[driveno]) == 0)
			continue;
.
1183c
	if((mask = spindownmask) == 0)
.
1178c
	int driveno, mask;
.
1172c
	IUNLOCK(&cp->reglock);
.
1167,1168c
		if(cp->cmd == 0 && cp->lastcmd == Cpktcmd && cp->cmdblk[0] == Ccapacity)
			break;
		if(cp->status & Serr)
			cp->error = inb(cp->pbase+Perror);
		print("%s: weird interrupt, cmd=%.2ux, lastcmd=%.2ux, ",
			dp->vol, cp->cmd, cp->lastcmd);
		print("status=%.2ux, error=%.2ux, count=%.2ux\n",
			cp->ctlrno, cp->error, inb(cp->pbase+Pcount));
.
1165a
	case Cpktcmd:
		atapiintr(cp);
		break;
.
1157c
	case Cedd:
.
1153,1155c
	case Cfeature:
.
1149a
			else if(cp->cmd == Cident && (cp->status & Sready) == 0)
				cp->cmd = Cident2;
			else
				cp->cmd = 0;
			inb(cp->pbase+Pstatus);
			DPRINT("status %uX, alt %uX\n",
				inb(cp->pbase+Pstatus), inb(cp->pbase+0x206));
.
1146,1148c
			if(cp->cmd == Cidentd)
.
1143c
			print("%s: intr %d %d\n", dp->vol, cp->sofar, cp->nsecs);
.
1122,1123c
				print("%s: read/ident cmd=%lux status=%lux\n",
					dp->vol, cp->cmd, inb(cp->pbase+Pstatus));
.
1118a
	case Cidentd:
.
1104,1105c
					panic("%s: write cmd=%lux status=%lux\n",
						dp->vol, cp->cmd, inb(cp->pbase+Pstatus));
.
1085,1087c
		if(++loop > Maxloop){
			print("ata%d: cmd=%lux, lastcmd=%lux status=%lux\n",
				cp->ctlrno, cp->cmd, cp->lastcmd, inb(cp->pbase+Pstatus));
			panic("%s: wait busy\n", dp->vol);
		}
.
1081,1082d
1074,1079c
	ILOCK(&cp->reglock);
.
1072c
	cp = arg;
	if((dp = cp->dp) == 0 && cp->cmd != Cedd)
		return;
.
1069,1070c
	int loop;
	uchar *addr;
.
1065c
ataintr(Ureg*, void* arg)
.
1051a
	dp->partok = 1;

.
1048a
	dp->npart = pp - dp->p;
.
1032,1046d
1030a
			if(getfields(line[i], field, 3, " ") != 3)
				break;
			if(pp >= &dp->p[Npart])
				break;
			strncpy(pp->name, field[0], NAMELEN);
			if(strncmp(pp->name, "repl", NAMELEN) == 0)
				dp->repl.p = pp;
			pp->start = strtoul(field[1], 0, 0);
			pp->end = strtoul(field[2], 0, 0);
			if(pp->start > pp->end || pp->start >= dp->p[0].end)
				break;
.
1029c
	if(n > 0 && strncmp(line[0], PARTMAGIC, sizeof(PARTMAGIC)-1) == 0){
.
1024a
	else{
		strcpy((char*)buf, p);
		n = getfields((char*)buf, line, Npart+1, "\n");
	}
.
1023c
		n = getfields((char*)buf, line, Npart+1, "\n");
		if(n == 0 || strncmp(line[0], PARTMAGIC, sizeof(PARTMAGIC)-1)){
			dp->p[0].end--;
			dp->p[1].start--;
			dp->p[1].end--;
			ataxfer(dp, &dp->p[1], Cread, 0, dp->bytes, buf);
			buf[dp->bytes-1] = 0;
			n = getfields((char*)buf, line, Npart+1, "\n");
		}
.
1014,1021c
	sprint(namebuf, "%spartition", dp->vol);
	if((p = getconf(namebuf)) == 0){	
		/*
		 *  read last sector from disk, null terminate.  This used
		 *  to be the sector we used for the partition tables.
		 *  However, this sector is special on some PC's so we've
		 *  started to use the second last sector as the partition
		 *  table instead.  To avoid reconfiguring all our old systems
		 *  we first look to see if there is a valid partition
		 *  table in the last sector.  If so, we use it.  Otherwise
		 *  we switch to the second last.
		 */
		ataxfer(dp, &dp->p[1], Cread, 0, dp->bytes, buf);
.
1005,1012c
	 * Check if the partitions are described in plan9.ini.
	 * If not, read the disc.
.
1003a

.
999a
		DPRINT("%s: atapart error\n", dp->vol);
.
990a
	pp++;
.
978a
	if(dp->partok)
		return;

.
977c
	DPRINT("%s: partok %d\n", dp->vol, dp->partok);
.
975c
	uchar *buf;
.
972c
	char *field[3], namebuf[NAMELEN], *p;
.
948c
	n = getfields((char*)buf, line, Nrepl+1, "\n");
.
923c
	uchar *buf;
.
909a
	DPRINT("%s: probed: %d/%d/%d CHS %d bytes\n",
		dp->vol, dp->cyl, dp->heads, dp->sectors, dp->cap);
	if(dp->cyl == 0 || dp->heads == 0 || dp->sectors == 0)
		error(Eio);
.
875c
		i = dp->lbasecs - 1;
.
873a
	if(dp->atapi)
		return;
.
856c
	qunlock(cp->ctlrlock);
.
852a
	cp->dp = 0;
.
849a
	}
.
848c
	if(cp->status & Serr){
		DPRINT("%s: probe err: status %lux, err %lux\n",
			dp->vol, cp->status, cp->error);
.
844c
	IUNLOCK(&cp->reglock);
.
840c
	outb(cp->pbase+Pdh, dp->dh | (dp->lba<<6) | head);
.
830c
	ILOCK(&cp->reglock);
.
828c
	if(cmdreadywait(dp)){
		error(Eio);
	}
.
824c
		qunlock(cp->ctlrlock);
.
822a
		cp->dp = 0;
.
821c
	qlock(cp->ctlrlock);
.
816c
	uchar *buf;
.
806c
	qunlock(cp->ctlrlock);
.
801,802c

	if(cp->cmd){
		cp->lastcmd = cp->cmd;
		cp->cmd = 0;
	}
	cp->dp = 0;
.
784,798c
		dp->lbasecs = 0;
.
779,781c
		dp->lbasecs = lbasecs;
		dp->cap = dp->bytes * dp->lbasecs;
		DPRINT("%s: LBA: %s %d sectors %d bytes\n",
			dp->vol, id, dp->lbasecs, dp->cap);
.
775a
	DPRINT("%s: config 0x%uX capabilities 0x%uX\n",
		dp->vol, ip->config, ip->capabilities);
	if(dp->atapi){
		dp->bytes = 2048;
		if((ip->config & 0x0060) == 0x0020)
			dp->drqintr = 1;
	}
	if(dp->spindown && (ip->capabilities & (1<<13)))
		dp->spindown /= 5;

	/* use default (unformatted) settings */
	dp->cyl = ip->cyls;
	dp->heads = ip->heads;
	dp->sectors = ip->s2t;
	DPRINT("%s: %s %d/%d/%d CHS %d bytes\n",
		dp->vol, id, dp->cyl, dp->heads, dp->sectors, dp->cap);

	if(ip->cvalid&(1<<0)){
		/* use current settings */
		dp->cyl = ip->ccyls;
		dp->heads = ip->cheads;
		dp->sectors = ip->cs2t;
		DPRINT("%s: changed to %d cyl %d head %d sec\n",
			dp->vol, dp->cyl, dp->heads, dp->sectors);
	}

.
758c
		DPRINT("%s: bad disk ident status\n", dp->vol);
		if(dp->atapi == 0 && (cp->error & Eabort)){
			dp->atapi = 1;
			if(isatapi(dp)){
				cmd = Cidentd;
				goto retryatapi;
			}
		}
.
751,753c
	outb(cp->pbase+Pdh, dp->dh);
	outb(cp->pbase+Pcmd, cmd);
	IUNLOCK(&cp->reglock);
.
748c
	cp->cmd = cmd;
.
745c
retryatapi:
	ILOCK(&cp->reglock);
.
743c
	if(dp->atapi || isatapi(dp))
		cmd = Cidentd;
	else{
		cmd = Cident;
		if(cmdreadywait(dp)){
			dp->atapi = 1;
			if(isatapi(dp) == 0)
				error(Eio);
			cmd = Cidentd;
		}
	}
.
739c
		cp->dp = 0;
		free(buf);
		qunlock(cp->ctlrlock);
.
737c
	qlock(cp->ctlrlock);
.
733a
	uchar cmd;
.
730c
	uchar *buf;
.
677c
	qunlock(cp->ctlrlock);
.
675a
	cp->dp = 0;
.
672,674c
	if(cp->status & Serr)
		DPRINT("%s: setbuf err: status %lux, err %lux\n",
			dp->vol, cp->status, cp->error);
.
663,668c
	ILOCK(&cp->reglock);
	cp->cmd = Cfeature;
	cp->dp = dp;
	outb(cp->pbase+Pfeature, arg);
	outb(cp->pbase+Pdh, dp->dh);
	outb(cp->pbase+Pcmd, Cfeature);
	IUNLOCK(&cp->reglock);
.
661c
	if(cmdreadywait(dp)){
		error(Eio);
	}
.
657c
		cp->dp = 0;
		qunlock(cp->ctlrlock);
.
655c
	if(dp->atapi)
		return;

	qlock(cp->ctlrlock);
.
651c
atafeature(Drive *dp, uchar arg)
.
641c
	qunlock(cp->ctlrlock);
.
638a
	cp->dp = 0;
.
632,633c
		DPRINT("%s err: lblk %ld status %lux, err %lux\n",
			dp->vol, lblk, cp->status, cp->error);
.
626a
	dp->state = Sspinning;
.
625d
620c
			print("%s: disk error\n", dp->vol);
.
618c
		DPRINT("%s: interrupted ataxfer\n", dp->vol);
.
606c
	IUNLOCK(&cp->reglock);
.
602c
				panic("%s: ataxfer", dp->vol);
.
599a
		microdelay(1);
.
593c
	outb(cp->pbase+Pdh, dp->dh | (dp->lba<<6) | head);
.
583c
	ILOCK(&cp->reglock);
.
576,581c
	if(cmdreadywait(dp)){
		error(Eio);
	}
.
572c
		qunlock(cp->ctlrlock);
.
570a
		cp->dp = 0;
.
569c
	qlock(cp->ctlrlock);
.
566c
	XPRINT("%s: ataxfer cyl %d sec %d head %d len %d\n", dp->vol, cyl, sec, head, len);
.
528c
ataxfer(Drive *dp, Partition *pp, int cmd, long start, long len, uchar *buf)
.
517c
		DPRINT("ata%d: cmd 0x%uX timeout\n", cp->ctlrno, cp->cmd);
.
508c
			DPRINT("%s: found bblk %ld at offset %ld\n", dp->vol, bblk, i);
.
491,496c
	if(dp->atapi)
		ready = 0;
	else
		ready = Sready;

	return atactlrwait(dp->cp, dp->dh, ready, ticks);
.
489c
		ticks = MS2TK(2000);
.
487c
		ticks = MS2TK(10);
.
485a
	dp->usetime = m->ticks;
.
481,483c
	ulong ticks;
	uchar ready;
.
478c
static int
.
475,476d
399a

.
398c
	dp = atadrive[DRIVE(c->qid.path)];
	if(dp->atapi)
		error(Eperm);
.
393c
	uchar *buf;
.
359,361d
352a
	dp = atadrive[DRIVE(c->qid.path)];
	if(dp->atapi){
		if(dp->online == 0)
			error(Eio);
		if(waserror()){
			qunlock(dp);
			nexterror();
		}
		qlock(dp);
		if(dp->partok == 0)
			atapipart(dp);
		qunlock(dp);
		poperror();
		return atapirwio(c, a, n, offset);
	}
	pp = &dp->p[PART(c->qid.path)];

.
348c
	uchar *buf;
.
336d
334c
atawstat(Chan*, char*)
.
329d
327c
ataremove(Chan*)
.
320,322c
	qlock(dp);
	dp->partok = 0;
	atapart(dp);
	qunlock(dp);
.
317c
		qunlock(dp);
.
311,312c
	dp = atadrive[DRIVE(c->qid.path)];
	p = &dp->p[PART(c->qid.path)];
.
305c
	Drive *dp;
.
298d
296c
atacreate(Chan*, char*, int, ulong)
.
264c
		if(dp->partok == 0){
			if(dp->atapi)
				atapipart(dp);
			else
				atapart(dp);
		}
.
258c
			atafeature(dp, 0xAA);	/* read look ahead */
.
251,255d
243c
	DPRINT("ataattach\n");

	qlock(&ataprobelock);
	if(ataprobedone == 0){
		atactlrreset();
		ataprobedone = 1;
	}
	qunlock(&ataprobelock);

	for(driveno = 0; driveno < NDrive; driveno++){
		if((dp = atadrive[driveno]) == 0)
			continue;
.
240a
	int driveno;
.
229a
atareset(void)
{
}

void
.
225,226c
		for(i = 0; i < isa.nopt; i++){
			DPRINT("ata%d: opt %s\n", ctlrno, isa.opt[i]);
			if(strncmp(isa.opt[i], "spindown", 8) == 0){
				if(isa.opt[i][9] != '=')
					continue;
				if(isa.opt[i][8] == '0')
					slave = 0;
				else if(isa.opt[i][8] == '1')
					slave = 1;
				else
					continue;
				driveno = ctlrno*2+slave;
				if(atadrive[driveno] == 0)
					continue;
				if((spindown = strtol(&isa.opt[i][10], 0, 0)) == 0)
					continue;
				if(spindown < (Hardtimeout+2000)/1000)
					spindown = (Hardtimeout+2000)/1000;
				atadrive[driveno]->spindown = spindown;
				spindownmask |= (1<<driveno);
				DPRINT("ata%d: opt spindownmask %ux\n",
					ctlrno, spindownmask);
			}
			else if(strcmp(isa.opt[i], "noatapi") == 0)
				atactlr[ctlrno]->noatapi = 1;
		}
	}
.
223c
	DPRINT("ata%d: DHmagic ok\n", ctlrno);
	if((ctlr = xalloc(sizeof(Controller))) == 0)
		return -1;
	ctlr->pbase = port;
	ctlr->ctlrno = ctlrno;
	ctlr->lastcmd = 0xFF;

	/*
	 * Attempt to check the existence of drives on the controller
	 * by issuing a 'check device diagnostics' command.
	 * Issuing a device reset here would possibly destroy any BIOS
	 * drive remapping and, anyway, some controllers (Vibra16) don't
	 * seem to implement the control-block registers.
	 * Unfortunately the vector must be set at this point as the Cedd
	 * command will generate an interrupt, which means the ataintr routine
	 * will be left on the interrupt call chain even if there are no
	 * drives found.
	 * At least one controller/ATAPI-drive combination doesn't respond
	 * to the Edd (Micronics M54Li + Sanyo CDR-XXX) so let's check for the
	 * ATAPI signature straight off. If we find it there will be no probe
	 * done for a slave. Tough.
	 */
	atapi = 0;
	mask = 0;
	status = inb(port+Pstatus);
	DPRINT("ata%d: ATAPI %uX %uX %uX\n", ctlrno, status,
		inb(port+Pcylmsb), inb(port+Pcyllsb));
	if(status == 0 && inb(port+Pcylmsb) == 0xEB && inb(port+Pcyllsb) == 0x14){
		DPRINT("ata%d: ATAPI ok\n", ctlrno);
		setvec(irq, ataintr, ctlr);
		atapi |= 0x01;
		mask |= 0x01;
		goto skipedd;
	}
	if(atactlrwait(ctlr, DHmagic, 0, MS2TK(1)) || waserror()){
		xfree(ctlr);
		return -1;
	}
	setvec(irq, ataintr, ctlr);
	ctlr->cmd = Cedd;
	outb(port+Pcmd, Cedd);
	atasleep(ctlr);
	poperror();

	/*
	 * The diagnostic returns a code in the error register, good
	 * status is bits 6-0 == 0x01.
	 * The existence of the slave is more difficult to determine,
	 * different generations of controllers may respond in different
	 * ways. The standards here offer little light but only more and
	 * more heat:
	 *   1) the slave must be done and have dropped Sbusy by now (six
	 *	seconds for the master, 5 seconds for the slave). If it
	 *	hasn't, then it has either failed or the controller is
	 *	broken in some way (e.g. Vibra16 returns status of 0xFF);
	 *   2) theory says the status of a non-existent slave should be 0.
	 *	Of course, it's valid for all the bits to be 0 for a slave
	 *	that exists too...
	 *   3) a valid ATAPI drive can have status 0 and the ATAPI signature
	 *	in the cylinder registers after reset. Of course, if the drive
	 *	has been messed about by the BIOS or some other O/S then the
	 *	signature may be gone.
	 */
	error = inb(port+Perror);
	DPRINT("ata%d: master diag error %ux\n", ctlr->ctlrno, error);
	if((error & ~0x80) == 0x01)
		mask |= 0x01;

	outb(port+Pdh, DHmagic|DHslave);
	microdelay(1);
	status = inb(port+Pstatus);
	error = inb(port+Perror);
	DPRINT("ata%d: slave diag status %ux, error %ux\n", ctlr->ctlrno, status, error);
	if(status && (status & (Sbusy|Serr)) == 0 && (error & ~0x80) == 0x01)
		mask |= 0x02;
	else if(status == 0 && inb(port+Pcylmsb) == 0xEB && inb(port+Pcyllsb) == 0x14){
		atapi |= 0x02;
		mask |= 0x02;
	}

skipedd:
	if(mask == 0){
		xfree(ctlr);
		return -1;
	}
	atactlr[ctlrno] = ctlr;

	if(have640b >= 0 && (ctlrno & 0x01))
		ctlr->ctlrlock = &atactlrlock[ctlrno-1];
	else
		ctlr->ctlrlock = &atactlrlock[ctlrno];

	if(mask & 0x01)
		atadrivealloc(ctlr, ctlrno*2, atapi & 0x01);
	if(mask & 0x02)
		atadrivealloc(ctlr, ctlrno*2+1, atapi & 0x02);

	return 0;
}

void
atactlrreset(void)
{
	int ctlrno, driveno, i, slave, spindown;
	ISAConf isa;

	cmd640b();
	rz1000();

	for(ctlrno = 0; ctlrno < NCtlr; ctlrno++){
		memset(&isa, 0, sizeof(ISAConf));
		if(isaconfig("ata", ctlrno, &isa) == 0 && ctlrno)
			continue;
		if(isa.irq == 0 && (isa.irq = defirq[ctlrno]) == 0)
			continue;

		if(atactlrprobe(ctlrno, Int0vec+isa.irq))
			continue;
.
217,221c
	drive->cp = ctlr;
	drive->driveno = driveno;
	sprint(drive->vol, "hd%d", drive->driveno);
	drive->dh = DHmagic;
	if(driveno & 0x01)
		drive->dh |= DHslave;
	drive->vers = 1;
	if(atapi)
		drive->atapi = 1;

	atadrive[driveno] = drive;
}

static int
atactlrprobe(int ctlrno, int irq)
{
	Controller *ctlr;
	int atapi, mask, port;
	uchar error, status;

	/*
	 * Check the existence of a controller by verifying a sensible
	 * value can be written to and read from the drive/head register.
	 * We define the primary/secondary/tertiary and quaternary controller
	 * port addresses to be at fixed values.
	 * If it's OK, allocate and initialise a Controller structure.
	 */
	port = pbase[ctlrno];
	outb(port+Pdh, DHmagic);
	microdelay(1);
	if((inb(port+Pdh) & 0xFF) != DHmagic){
		DPRINT("ata%d: DHmagic not ok\n", ctlrno);
		return -1;
.
210,215c
static int
atactlrwait(Controller* ctlr, uchar pdh, uchar ready, ulong ticks)
{
	int port;
	uchar dh, status;

	port = ctlr->pbase;
	dh = (inb(port+Pdh) & DHslave)^(pdh & DHslave);
	ticks += m->ticks+1;

	do{
		status = inb(port+Pstatus);
		if(status & Sbusy)
			continue;
		if(dh){
			outb(port+Pdh, pdh);
			dh = 0;
			continue;
		}
		if((status & ready) == ready)
			return 0;
	}while(m->ticks < ticks);

	DPRINT("ata%d: ctlrwait failed %uX\n", ctlr->ctlrno, status);
	outb(port+Pdh, DHmagic);
	return 1;
}

static void
atadrivealloc(Controller* ctlr, int driveno, int atapi)
{
	Drive *drive;

	if((drive = xalloc(sizeof(Drive))) == 0){
		DPRINT("ata%d: can't xalloc drive0\n", ctlr->ctlrno);
		return;
.
203,208c
	/*
	 * Look for PC-Tech RZ1000 controllers and turn off prefetch.
	 * This is overkill, but cheap.
	 */
	pcicfg = malloc(sizeof(PCIcfg));
	pcicfg->vid = 0x1042;
	pcicfg->did = 0;
	devno = 0;
	while((devno = pcimatch(0, devno, pcicfg)) != -1){
		if(pcicfg->did != 0x1000 && pcicfg->did != 0x1001)
			continue;
		pcicfgr(0, devno-1, 0, 0x40, &r40, sizeof(r40));
		r40 &= ~0x2000;
		pcicfgw(0, devno-1, 0, 0x40, &r40, sizeof(r40));
	}
	free(pcicfg);
}
.
200,201c
static void
rz1000(void)
{
	PCIcfg* pcicfg;
	ulong r40;
	int devno;
.
196,198c
	/*
	 * Look for CMD640B dual PCI controllers. Amongst other
	 * bugs only one of the controllers can be active at a time.
	 * Unfortunately there's no way to tell which pair of
	 * controllers this is, so if one is found then all controller
	 * pairs are synchronised.
	 */
	pcicfg = malloc(sizeof(PCIcfg));
	pcicfg->vid = 0x1095;
	pcicfg->did = 0x0640;
	devno = 0;
	while((devno = pcimatch(0, devno, pcicfg)) != -1){
		have640b = devno-1;
		/*
		 * If one is found, make sure read-ahead is disabled on all
		 * drives and that the 2nd controller is enabled:
		 *   reg 0x51:	bit 7 - drive 1 read ahead disable
		 *  		bit 6 - drive 0 read ahead disable
		 *  		bit 3 - 2nd controller enable
		 *   reg 0x57:	bit 3 - drive 1 read ahead disable
		 *  		bit 2 - drive 0 read ahead disable
		 * Doing byte-writes to PCI configuration space is not in the
		 * spec...
		 */
		pcicfgr(0, have640b, 0, 0x50, r50, sizeof(r50));
		r50[0x01] |= 0xC8;
		pcicfgw8(0, have640b, 0, 0x51, &r50[0x01], sizeof(r50[0x01]));
		r50[0x07] |= 0x0C;
		pcicfgw8(0, have640b, 0, 0x57, &r50[0x07], sizeof(r50[0x07]));
	}
	free(pcicfg);
}
.
191,194c
	PCIcfg* pcicfg;
	uchar r50[12];
	int devno;
	extern void pcicfgw8(int, int, int, int, void*, int);
.
188,189c
static void
cmd640b(void)
.
174c
	if(atadrive[drive] == 0)
		return 0;
	dp = atadrive[drive];
.
172c

	if(drive >= NDrive)
.
168d
159c
atagen(Chan *c, Dirtab*, long, long s, Dir *dirp)
.
157a
static int	isatapi(Drive*);
static long	atapirwio(Chan*, char*, ulong, ulong);
static void	atapipart(Drive*);
static void	atapiintr(Controller*);

.
156a
static void	atasleep(Controller*);
.
153c
static void	atafeature(Drive*, uchar);
.
151c
static long	ataxfer(Drive*, Partition*, int, long, long, uchar*);
.
146,148c
static QLock ataprobelock;
static int ataprobedone;
static Controller *atactlr[NCtlr];
static QLock atactlrlock[NCtlr];
static Drive *atadrive[NDrive];
static int spindownmask;
static int have640b = -1;
static int pbase[NCtlr] = {
	Pbase0, Pbase1, Pbase2, Pbase3,
};
static int defirq[NCtlr] = {
	14, 15, 0, 0,
};
.
141,143c
	Drive*	dp;		/* drive being accessed */
.
138c
	uchar	cmd;		/* current command */
	uchar	cmdblk[12];	/* ATAPI */
	int	len;		/* ATAPI */
	int	count;		/* ATAPI */
	uchar	lastcmd;	/* debugging info */
	uchar	status;
	uchar	error;
	uchar*	buf;		/* xfer buffer */
.
135,136d
130a
	uchar	ctlrno;
	uchar	noatapi;
.
129d
125c
	QLock*	ctlrlock;	/* exclusive access to the controller */
.
116,117c
	uchar	lba;		/* true if drive has logical block addressing */
	uchar	multi;		/* true if drive can do multiple block xfers (unused) */
	uchar	drqintr;	/* ATAPI */
	ulong	vers;		/* ATAPI */

	int	spindown;
.
114a
	ulong	lbasecs;
.
103a
	int	partok;
.
100,102c
	uchar	driveno;
	uchar	dh;		/* DHmagic|Am-I-A-Slave */
	uchar	atapi;
	uchar	online;

.
70a

.
69c
	Hardtimeout=	30000,		/* disk access timeout (ms) */

	NCtlr=		4,
	NDrive=		NCtlr*2,
.
66c
	Npart=		20+2,		/* 8 sub partitions, disk, and partition */
.
59,61d
56,57d
52a
	Cpktcmd=	0xA0,
	Cidentd=	0xA1,
	Ccapacity=	0x25,
	Cread2=		0x28,

.
50,51d
48d
44,46c
	Cident2=	0xFE,	/* pseudo command for post Cident interrupt */
	Cfeature=	0xEF,
.
42a
	Cedd=		0x90,	/* execute device diagnostics */
.
40c
	Cfirst=		0xFF,	/* pseudo command for initialisation */
.
34a
	 Sdf=		 (1<<5),
.
31a
	 DHmagic=	0xA0,
	 DHslave=	0x10,
.
26c
	 Eabort=	(1<<2),
	Pfeature=	1,	/* buffer mode port (write) */
.
22,23c
	Pbase0=		0x1F0,	/* primary */
	Pbase1=		0x170,	/* secondary */
	Pbase2=		0x1E8,	/* tertiary */
	Pbase3=		0x168,	/* quaternary */
.
11a
#define XPRINT if(0)print
#define ILOCK(x)
#define IUNLOCK(x)
.
0a
/*
 * This has gotten a bit messy with the addition of multiple controller
 * and ATAPI support; needs a rewrite before adding any 'ctl' functions.
 */
.
## diffname pc/devata.c 1995/1208
## diff -e /n/fornaxdump/1995/1206/sys/src/brazil/pc/devata.c /n/fornaxdump/1995/1208/sys/src/brazil/pc/devata.c
1820c
			err = cp->error & 0xF0;
.
1807c
	retrycount = 2;
.
1708c
	retrycount = 2;
.
1691c
		DPRINT("%s: Bad packet command %ux, error %ux\n", dp->vol, cp->cmdblk[0], cp->error);
.
1617,1619c
	outb(cp->pbase+Pcmd, 0x08);
	if(atactlrwait(dp->cp, DHmagic, 0, MS2TK(100))){
		DPRINT("%s: isatapi ctlrwait status %ux\n", dp->vol, inb(cp->pbase+Pstatus));
		return 0;
.
1544,1545d
1540a
#else
			if(cp->cmd != Cread && (cp->status & (Sbusy|Sready)) != Sready)
				cp->cmd = Cident2;
#endif /* notdef */
.
1536a
#ifdef notdef
.
1154c
		XPRINT("%s: LBA: %s %d sectors %d bytes\n",
.
1145c
		XPRINT("%s: changed to %d cyl %d head %d sec\n",
.
1137c
	XPRINT("%s: %s %d/%d/%d CHS %d bytes\n",
.
1099,1100c
		if(cp->error & Eabort){
.
1094a
	DPRINT("%s: ident command %ux sent\n", dp->vol, cmd);
.
1072,1083c
	cmd = Cident;
.
403a
		DPRINT("ata%d: Cedd status %ux/%ux/%ux\n",
			ctlrno, inb(port+Pstatus), inb(port+Pcylmsb), inb(port+Pcyllsb));
.
387c
	 * to the Cedd (Micronics M54Li + Sanyo CRD-254P) so let's check for the
.
343a
	}
.
342c
	if(atapi){
		sprint(drive->vol, "atapi%d", drive->driveno);
.
79c
	Hardtimeout=	6000,		/* disk access timeout (ms) */
.
## diffname pc/devata.c 1995/1209
## diff -e /n/fornaxdump/1995/1208/sys/src/brazil/pc/devata.c /n/fornaxdump/1995/1209/sys/src/brazil/pc/devata.c
1682c
	atasleep(cp, Hardtimeout);
.
1533,1538d
1530,1531c
			if(cp->cmd != Cread)
.
1206c
	atasleep(cp, Hardtimeout);
.
1089c
	atasleep(cp, 1000);
.
999c
	atasleep(cp, Hardtimeout);
.
945c
	atasleep(cp, Hardtimeout);
.
837c
	tsleep(&cp->r, cmddone, cp, ms);
.
835c
atasleep(Controller *cp, int ms)
.
414c
	atasleep(ctlr, Hardtimeout);
.
193c
static void	atasleep(Controller*, int);
.
## diffname pc/devata.c 1995/1218
## diff -e /n/fornaxdump/1995/1209/sys/src/brazil/pc/devata.c /n/fornaxdump/1995/1218/sys/src/brazil/pc/devata.c
1405a
			if(n == 0 || strncmp(line[0], PARTMAGIC, sizeof(PARTMAGIC)-1)){
				dp->p[0].end--;
				dp->p[1].start--;
				dp->p[1].end--;
			}
.
1402a
		}
		else{
.
1399c
		if(n > 0 && strncmp(line[0], PARTMAGIC, sizeof(PARTMAGIC)-1) == 0){
.
1396c
		ataxfer(dp, &dp->p[0], Cread, dp->p[0].end-1, dp->bytes, buf);
.
1392,1394c
		 *  we still check if there is a valid partition table in
		 *  the last sector if none is found in the second last.
.
1387,1388c
		 *  Read second last sector from disk, null terminate.
		 *  The last sector used to hold the partition tables.
.
## diffname pc/devata.c 1995/1219
## diff -e /n/fornaxdump/1995/1218/sys/src/brazil/pc/devata.c /n/fornaxdump/1995/1219/sys/src/brazil/pc/devata.c
1411a
else print("ok%d|", dp->p[1].start);
.
1410a
print("nok%d|", dp->p[1].start);
.
1403a
print("r%d|", dp->p[1].start);
.
1401a
print("OK%d|", dp->p[1].start);
.
1395c
print("R%d|", dp->p[0].end-2);
		ataxfer(dp, &dp->p[0], Cread, dp->p[0].end-2, dp->bytes, buf);
.
## diffname pc/devata.c 1995/1221
## diff -e /n/fornaxdump/1995/1219/sys/src/brazil/pc/devata.c /n/fornaxdump/1995/1221/sys/src/brazil/pc/devata.c
1410,1416c
			if(n == 0 || strncmp(line[0], PARTMAGIC, sizeof(PARTMAGIC)-1))
				i = 1;
		}
		if(i){
			dp->p[0].end--;
			dp->p[1].start--;
			dp->p[1].end--;
.
1406d
1399,1404c
		if(n > 0 && strncmp(line[0], PARTMAGIC, sizeof(PARTMAGIC)-1) == 0)
			i = 1;
.
1395,1396c
		i = 0;
		ataxfer(dp, &dp->p[0], Cread, (dp->p[0].end-2)*dp->bytes, dp->bytes, buf);
.
## diffname pc/devata.c 1996/0112
## diff -e /n/fornaxdump/1995/1221/sys/src/brazil/pc/devata.c /n/fornaxdump/1996/0112/sys/src/brazil/pc/devata.c
1826a

	cp->len = 18;
	cp->count = 0;
	memset(cp->cmdblk, 0, sizeof(cp->cmdblk));
	cp->cmdblk[0] = Creqsense;
	cp->cmdblk[4] = 18;
	atapiexec(dp);
	if(cp->count != 18){
		print("cmd=%2.2uX, lastcmd=%2.2uX ", cp->cmd, cp->lastcmd);
		print("cdsize count %d, status 0x%2.2uX, error 0x%2.2uX\n",
			cp->count, cp->status, cp->error);
		error(Eio);
	}
.
1805a
		DPRINT("atapipart: cmd %uX error %uX\n", cp->cmd, cp->error);
.
1076c
	if(dp->atapi)
		cmd = Cidentd;
	else
		cmd = Cident;
.
64a
	Ctur=		0x00,
	Creqsense=	0x03,
.
## diffname pc/devata.c 1996/0210
## diff -e /n/fornaxdump/1996/0112/sys/src/brazil/pc/devata.c /n/fornaxdump/1996/0210/sys/src/brazil/pc/devata.c
1094c
	if(cmd == Cident)
		atasleep(cp, 3000);
	else
		atasleep(cp, 30000);
.
517,518c
			else if(strcmp(isa.opt[i], "reset") == 0)
				atactlr[ctlrno]->resetok = 1;
.
450,452c
	else if(status == 0){
		msb = inb(port+Pcylmsb);
		lsb = inb(port+Pcyllsb);
		DPRINT("ata%d: ATAPI slave %uX %uX %uX\n", ctlrno, status,
			inb(port+Pcylmsb), inb(port+Pcyllsb));
		if(msb == 0xEB && lsb == 0x14){
			atapi |= 0x02;
			mask |= 0x02;
		}
.
408,409c
		DPRINT("ata%d: Cedd status %ux/%ux/%ux\n", ctlrno,
			inb(port+Pstatus), inb(port+Pcylmsb), inb(port+Pcyllsb));
.
394a
	if(ctlr->resetok){
		outb(port+Pctrl, Srst|nIEN);
		microdelay(1);
		outb(port+Pctrl, 0);
		if(atactlrwait(ctlr, DHmagic, 0, 100)){
			DPRINT("ata%d: Srst status %ux/%ux/%ux\n", ctlrno,
				inb(port+Pstatus), inb(port+Pcylmsb), inb(port+Pcyllsb));
			xfree(ctlr);
		}
	}

.
385c
	 * seem to implement the control-block registers; do it if requested.
.
379a

.
357c
	uchar error, status, msb, lsb;
.
155c
	uchar	resetok;
.
51a
	Pctrl=		0x206,	/* device control, alternate status */
	 nIEN=		(1<<1),
	 Srst=		(1<<2),

.
## diffname pc/devata.c 1996/0215
## diff -e /n/fornaxdump/1996/0210/sys/src/brazil/pc/devata.c /n/fornaxdump/1996/0215/sys/src/brazil/pc/devata.c
1119c
		atasleep(cp, 10000);
.
404c
		if(atactlrwait(ctlr, DHmagic, 0, MS2TK(20)){
.
402c
		delay(10);
.
## diffname pc/devata.c 1996/0216
## diff -e /n/fornaxdump/1996/0215/sys/src/brazil/pc/devata.c /n/fornaxdump/1996/0216/sys/src/brazil/pc/devata.c
404c
		if(atactlrwait(ctlr, DHmagic, 0, MS2TK(20))){
.
## diffname pc/devata.c 1996/0223
## diff -e /n/fornaxdump/1996/0216/sys/src/brazil/pc/devata.c /n/fornaxdump/1996/0223/sys/src/brazil/pc/devata.c
13d
## diffname pc/devata.c 1996/0315
## diff -e /n/fornaxdump/1996/0223/sys/src/brazil/pc/devata.c /n/fornaxdump/1996/0315/sys/src/brazil/pc/devata.c
1453c
			if(parsefields(line[i], field, 3, " ") != 3)
.
1445c
		n = parsefields((char*)buf, line, Npart+1, "\n");
.
1433c
			n = parsefields((char*)buf, line, Npart+1, "\n");
.
1427c
		n = parsefields((char*)buf, line, Npart+1, "\n");
.
1352c
			if(parsefields(line[i], field, 1, " ") != 1)
.
1347c
	n = parsefields((char*)buf, line, Nrepl+1, "\n");
.
## diffname pc/devata.c 1996/0803
## diff -e /n/fornaxdump/1996/0315/sys/src/brazil/pc/devata.c /n/fornaxdump/1996/0803/sys/src/brazil/pc/devata.c
642a
	if(dp == 0)
		return;
.
## diffname pc/devata.c 1996/1225
## diff -e /n/fornaxdump/1996/0803/sys/src/brazil/pc/devata.c /n/fornaxdump/1996/1225/sys/src/brazil/pc/devata.c
206c
atagen(Chan *c, Dirtab*, int, int s, Dir *dirp)
.
## diffname pc/devata.c 1997/0327
## diff -e /n/fornaxdump/1996/1225/sys/src/brazil/pc/devata.c /n/emeliedump/1997/0327/sys/src/brazil/pc/devata.c
1964a

Dev atadevtab = {
	devreset,
	devinit,
	ataattach,
	devclone,
	atawalk,
	atastat,
	ataopen,
	devcreate,
	ataclose,
	ataread,
	devbread,
	atawrite,
	devbwrite,
	devremove,
	devwstat,
};
.
1604,1605c
static void
ataclock(void)
.
805,810d
726,732c
static long
.
663,674d
660,661c
static long
ataread(Chan* c, void* a, long n, ulong offset)
.
630,635d
628c
ataclose(Chan* c)
.
621,622c
static Chan*
ataopen(Chan* c, int omode)
.
615,616c
static void
atastat(Chan* c, char* dp)
.
606,611d
603,604c
static int
atawalk(Chan* c, char* name)
.
558,559c
static Chan*
ataattach(char* spec)
.
549,553d
544,546c
	if(spindownmask)
		addclock0link(ataclock);
.
542d
512c
		if(atactlrprobe(ctlrno, VectorPIC+isa.irq))
.
496c
static void
.
483c
	if(have640b && (ctlrno & 0x01))
.
428c
	intrenable(irq, ataintr, ctlr, ctlr->tbdf);
.
417c
		intrenable(irq, ataintr, ctlr, ctlr->tbdf);
.
380a
	ctlr->tbdf = BUSUNKNOWN;
.
300d
296,298c
		r = pcicfgr32(p, 0x40);
		r &= ~0x2000;
		pcicfgw32(p, 0x40, r);
.
289,294c
	p = 0;
	while(p = pcimatch(p, 0x1042, 0)){
		if(p->did != 0x1000 && p->did != 0x1001)
.
281,283c
	Pcidev *p;
	ulong r;
.
275d
269,273c
		r = pcicfgr8(p, 0x51);
		r |= 0xC8;
		pcicfgw8(p, 0x51, r);
		r = pcicfgr8(p, 0x57);
		r |= 0x0C;
		pcicfgw8(p, 0x57, r);
.
266,267d
252,257c
	p = 0;
	while(p = pcimatch(p, 0x1095, 0x0640)){
		have640b++;
.
240,243c
	Pcidev *p;
	int r;
.
206c
atagen(Chan* c, Dirtab*, int, int s, Dir* dirp)
.
198a
static void	ataclock(void);
.
183c
static int have640b;
.
157a
	int	tbdf;
.
## diffname pc/devata.c 1997/0408
## diff -e /n/emeliedump/1997/0327/sys/src/brazil/pc/devata.c /n/emeliedump/1997/0408/sys/src/brazil/pc/devata.c
1914a
	'H',
	"ata",

.
## diffname pc/devata.c 1997/0812
## diff -e /n/emeliedump/1997/0408/sys/src/brazil/pc/devata.c /n/emeliedump/1997/0812/sys/src/brazil/pc/devata.c
823c
ataxfer(Drive *dp, Partition *pp, int cmd, ulong start, long len, uchar *buf)
.
193c
static long	ataxfer(Drive*, Partition*, int, ulong, long, uchar*);
.
## diffname pc/devata.c 1997/0815
## diff -e /n/emeliedump/1997/0812/sys/src/brazil/pc/devata.c /n/emeliedump/1997/0815/sys/src/brazil/pc/devata.c
531a

		if(atactlrprobe(ctlrno, VectorPIC+isa.irq, resetok))
			continue;

		if(spindown == 0 || atadrive[driveno] == 0)
			continue;
		atadrive[driveno]->spindown = spindown;
		spindownmask |= (1<<driveno);
		DPRINT("ata%d: opt spindownmask %ux\n", ctlrno, spindownmask);
.
530c
				resetok = 1;
.
524,527c
				driveno = ctlrno*2+slave;
.
517,519d
503,505c
		driveno = resetok = spindown = 0;
.
490c
	int ctlrno, driveno, i, resetok, slave, spindown;
.
390c
	if(resetok){
.
362,363c
	status = inb(port+Pdh) & 0xFF;
	if(status != DHmagic){
		DPRINT("ata%d: DHmagic not ok == %ux\n", ctlrno, status);
.
346c
atactlrprobe(int ctlrno, int irq, int resetok)
.
159d
14c
#define DPRINT if(1)print
.
## diffname pc/devata.c 1997/0818
## diff -e /n/emeliedump/1997/0815/sys/src/brazil/pc/devata.c /n/emeliedump/1997/0818/sys/src/brazil/pc/devata.c
14c
#define DPRINT if(0)print
.
## diffname pc/devata.c 1997/1230
## diff -e /n/emeliedump/1997/0818/sys/src/brazil/pc/devata.c /n/emeliedump/1997/1230/sys/src/brazil/pc/devata.c
1834a
	DPRINT("%s: atapipart secs %ud, bytes %ud, cap %ud\n",
		dp->vol, dp->lbasecs, dp->bytes, dp->cap);
.
1833a
	dp->bytes = (cp->buf[4]<<24)|(cp->buf[5]<<16)|(cp->buf[6]<<8)|cp->buf[7];
.
1820a
{ int i;
  for(i = 0; i < 18; i++)
    print("%2.2uX ", buf[i]);
  print("\n");
}
.
14,15c
#define DPRINT if(1)print
#define XPRINT if(1)print
.
## diffname pc/devata.c 1998/0106
## diff -e /n/emeliedump/1997/1230/sys/src/brazil/pc/devata.c /n/emeliedump/1998/0106/sys/src/brazil/pc/devata.c
1839a
	if(dp->bytes > 2048 && dp->bytes <= 2352)
		dp->bytes = 2048;
.
448a
atapislave:
.
411c
//		goto skipedd;
goto atapislave;
.
14,15c
#define DPRINT if(0)print
#define XPRINT if(0)print
.
## diffname pc/devata.c 1998/0115
## diff -e /n/emeliedump/1998/0106/sys/src/brazil/pc/devata.c /n/emeliedump/1998/0115/sys/src/brazil/pc/devata.c
1823,1827d
## diffname pc/devata.c 1998/0219
## diff -e /n/emeliedump/1998/0115/sys/src/brazil/pc/devata.c /n/emeliedump/1998/0219/sys/src/brazil/pc/devata.c
1907c
		if(cause == 0)
			outss(pbase+Pdata, addr, count/2);
		else
			inss(pbase+Pdata, addr, count/2);
.
1876a
	case 0:						/* data out */
.
1863,1865d
1760c
	rv = atapiio(dp, a, len, offset, cmd);
.
1742c
atapirwio(Chan *c, uchar *a, ulong len, ulong offset, int cmd)
.
1735c
	if(cmd == Cread2)
		free(buf);
.
1717c
		cp->cmdblk[0] = cmd;
.
1703c
	if(cmd == Cread2)
		cp->buf = buf;
	else
		cp->buf = a;
.
1698c
		if(cmd == Cread2)
			free(buf);
.
1684c
	if(cmd == Cread2)
		buf = smalloc(Maxxfer);
	else
		buf = 0;
.
1675c
atapiio(Drive *dp, uchar *a, ulong len, ulong offset, int cmd)
.
1103a
		if((ip->config & 0x1F00) == 0x0000)
			dp->atapi = 2;
.
752c
		if(dp->atapi)
			atapirwio(c, buf, dp->bytes, offset+rv, Cwrite2);
		else
			ataxfer(dp, pp, Cwrite, offset+rv, dp->bytes, buf);
.
750c
		if(dp->atapi)
			atapirwio(c, buf, dp->bytes, offset+rv, Cread2);
		else
			ataxfer(dp, pp, Cread, offset+rv, dp->bytes, buf);
.
739c
		if(dp->atapi)
			i = atapirwio(c, buf, i, offset+rv, Cwrite2);
		else
			i = ataxfer(dp, pp, Cwrite, offset+rv, i, buf);
.
725c
		if(dp->atapi)
			atapirwio(c, buf, dp->bytes, offset-partial, Cwrite2);
		else
			ataxfer(dp, pp, Cwrite, offset-partial, dp->bytes, buf);
.
719c
		if(dp->atapi)
			atapirwio(c, buf, dp->bytes, offset-partial, Cread2);
		else
			ataxfer(dp, pp, Cread, offset-partial, dp->bytes, buf);
.
702,703c
	if(dp->atapi){
		if(dp->online == 0 || dp->atapi == 1)
			error(Eio);
		if(waserror()){
			qunlock(dp);
			nexterror();
		}
		qlock(dp);
		if(dp->partok == 0)
			atapipart(dp);
		qunlock(dp);
		poperror();
	}
.
661c
		return atapirwio(c, a, n, offset, Cread2);
.
456c
	if((status & ~0x02) && (status & (Sbusy|Serr)) == 0 && (error & ~0x80) == 0x01)
.
446c
	DPRINT("ata%d: master diag status %uX, error %ux\n",
		ctlr->ctlrno, inb(port+Pstatus), error);
.
443a
	 * When checking status, mask off the IDX bit.
.
411,412c
		goto atapislave;
.
403d
202c
static long	atapirwio(Chan*, uchar*, ulong, ulong, int);
.
71a
	Cwrite2=	0x2A,
.
13,15c
#define DEBUG	0
#define DPRINT if(DEBUG)print
#define XPRINT if(DEBUG)print
.
## diffname pc/devata.c 1998/0319
## diff -e /n/emeliedump/1998/0219/sys/src/brazil/pc/devata.c /n/emeliedump/1998/0319/sys/src/brazil/pc/devata.c
697a
	ulong offset = off;
.
691c
atawrite(Chan *c, void *a, long n, vlong off)
.
644a
	ulong offset = off;
.
637c
ataread(Chan* c, void* a, long n, vlong off)
.
## diffname pc/devata.c 1998/0327
## diff -e /n/emeliedump/1998/0319/sys/src/brazil/pc/devata.c /n/emeliedump/1998/0327/sys/src/brazil/pc/devata.c
1799c
	rv = atapiio(dp, a, len, off, cmd);
.
1781c
atapirwio(Chan *c, uchar *a, ulong len, vlong off, int cmd)
.
1769c
		off += m;
.
1750c
		o = off % dp->bytes;
.
1747,1748c
		bn = off / dp->bytes;
		if(off > dp->cap-dp->bytes)
.
1720a

.
1706c
atapiio(Drive *dp, uchar *a, ulong len, vlong off, int cmd)
.
1288,1290c
	dp->cap = (vlong)dp->bytes * dp->cyl * dp->heads * dp->sectors;
	DPRINT("%s: probed: %d/%d/%d CHS %lld bytes\n",
		dp->vol, dp->cyl, dp->heads, dp->sectors,
		dp->cap);
.
1165c
		dp->cap = (vlong)dp->bytes * dp->cyl * dp->heads * dp->sectors;
.
1159,1161c
		dp->cap = (vlong)dp->bytes * dp->lbasecs;
		XPRINT("%s: LBA: %s %d sectors %lld bytes\n",
			dp->vol, id, dp->lbasecs,
			dp->cap);
.
1143,1144c
	XPRINT("%s: %s %d/%d/%d CHS %lld bytes\n",
		dp->vol, id, dp->cyl, dp->heads, dp->sectors,
		dp->cap);
.
893c
	XPRINT("%s: ataxfer cyl %d sec %d head %d len %d\n",
		dp->vol, cyl, sec, head, len);
.
868c
	start = off / dp->bytes;
.
860a
	ulong start;
.
855c
ataxfer(Drive *dp, Partition *pp, int cmd, vlong off, long len, uchar *buf)
.
835c
			DPRINT("%s: found bblk %ld at offset %ld\n",
			dp->vol, bblk, i);
.
781c
			ataxfer(dp, pp, Cwrite, off+rv, dp->bytes, buf);
.
779c
			atapirwio(c, buf, dp->bytes, off+rv, Cwrite2);
.
776c
			ataxfer(dp, pp, Cread, off+rv, dp->bytes, buf);
.
774c
			atapirwio(c, buf, dp->bytes, off+rv, Cread2);
.
762c
			i = ataxfer(dp, pp, Cwrite, off+rv, i, buf);
.
760c
			i = atapirwio(c, buf, i, off+rv, Cwrite2);
.
745c
			ataxfer(dp, pp, Cwrite, off-partial, dp->bytes, buf);
.
743c
			atapirwio(c, buf, dp->bytes, off-partial, Cwrite2);
.
736c
			ataxfer(dp, pp, Cread, off-partial, dp->bytes, buf);
.
734c
			atapirwio(c, buf, dp->bytes, off-partial, Cread2);
.
731c
	partial = off % dp->bytes;
.
699d
675c
		i = ataxfer(dp, pp, Cread, off+rv-skip, n-rv+skip, buf);
.
673c
	skip = off % dp->bytes;
.
663c
		return atapirwio(c, a, n, off, Cread2);
.
645d
234c
	l = (pp->end - pp->start) * (vlong)dp->bytes;
.
215c
	vlong l;
.
203c
static long	atapirwio(Chan*, uchar*, ulong, vlong, int);
.
193c
static long	ataxfer(Drive*, Partition*, int, vlong, long, uchar*);
.
133c
	vlong	cap;		/* total bytes */
.
## diffname pc/devata.c 1998/0331
## diff -e /n/emeliedump/1998/0327/sys/src/brazil/pc/devata.c /n/emeliedump/1998/0331/sys/src/brazil/pc/devata.c
1413c
		ataxfer(dp, &dp->p[0], Cread, (dp->p[0].end-2)*
			(vlong)dp->bytes, dp->bytes, buf);
.
419c
	if(once)
		intrenable(irq, ataintr, ctlr, ctlr->tbdf);
.
415a
		if(once){
			once = 0;
			ctlr->cmd = 0;
			goto retry;
		}
.
408c
		if(once)
			intrenable(irq, ataintr, ctlr, ctlr->tbdf);
.
406c
	if(/*status == 0 &&*/ inb(port+Pcylmsb) == 0xEB && inb(port+Pcyllsb) == 0x14){
.
401a
	once = 1;
retry:
.
349c
	int atapi, mask, once, port;
.
## diffname pc/devata.c 1998/0501
## diff -e /n/emeliedump/1998/0331/sys/src/brazil/pc/devata.c /n/emeliedump/1998/0501/sys/src/brazil/pc/devata.c
1782c
		if(cmd == Cread2)
			memmove(a, cp->buf + o, m);
		else
			cp->buf += m;
.
## diffname pc/devata.c 1998/0510
## diff -e /n/emeliedump/1998/0501/sys/src/brazil/pc/devata.c /n/emeliedump/1998/0510/sys/src/brazil/pc/devata.c
1845c
		DPRINT("atapipart: cmd %uX error %uX\n", cp->cmdblk[0], cp->error);
.
1739a
			atapireqsense(dp);
.
1737a
		DPRINT("atapiio: cmd %uX error %uX\n", cp->cmdblk[0], cp->error);
.
1718a
static void
atapireqsense(Drive* dp)
{
	Controller *cp;
	uchar *buf;

	cp = dp->cp;

	buf = smalloc(Maxxfer);
	cp->buf = buf;
	cp->dp = dp;

	if(waserror()){
		free(buf);
		return;
	}

	cp->len = 18;
	cp->count = 0;
	memset(cp->cmdblk, 0, sizeof(cp->cmdblk));
	cp->cmdblk[0] = Creqsense;
	cp->cmdblk[4] = 18;
	atapiexec(dp);
	if(cp->count != 18){
		print("cmd=%2.2uX, lastcmd=%2.2uX ", cp->cmd, cp->lastcmd);
		print("cdsize count %d, status 0x%2.2uX, error 0x%2.2uX\n",
			cp->count, cp->status, cp->error);
	}

	poperror();
	free(buf);
}

.
1178a
	XPRINT("%s: %s %d/%d/%d CHS %lld bytes\n",
		dp->vol, id, dp->cyl, dp->heads, dp->sectors,
		dp->cap);
.
1153,1155d
13,17c
#define DEBUG		0
#define DPRINT 		if(DEBUG)print
#define XPRINT 		if(DEBUG)print
#define ILOCK(x)	ilock(x)
#define IUNLOCK(x)	iunlock(x)
.
3a
 * The register locking needs looked at.
.
## diffname pc/devata.c 1998/0516
## diff -e /n/emeliedump/1998/0510/sys/src/brazil/pc/devata.c /n/emeliedump/1998/0516/sys/src/brazil/pc/devata.c
2001,2003c
			inss(pbase+Pdata, cp->buf+cp->count, count/2);
		cp->count += count;
.
1999c
			outss(pbase+Pdata, cp->buf+cp->count, count/2);
.
1996,1997c
		if(cp->count+count > Maxxfer)
			panic("hd%d: count %d, already %d\n", count, cp->count);
.
1969,1970c
		if(cp->buf == 0){
.
1949d
1918d
1916a
	cp->nsecs = 1;
.
1905d
1903a
	cp->nsecs = 1;
.
1831c
	poperror();

	return len;
.
1829a
	cp->buf = 0;
	len = cp->count;
.
1796,1828c
	memset(cp->cmdblk, 0, 12);
	cp->cmdblk[0] = cmd;
	cp->cmdblk[2] = start>>24;
	cp->cmdblk[3] = start>>16;
	cp->cmdblk[4] = start>>8;
	cp->cmdblk[5] = start;
	cp->cmdblk[7] = cp->nsecs>>8;
	cp->cmdblk[8] = cp->nsecs;
	atapiexec(dp);
	if(cp->count != cp->len)
		print("short read\n");
.
1794d
1789,1792c
	cp->buf = buf;
	cp->nsecs = len;
	cp->len = len*dp->bytes;
	cp->cmd = cmd;
.
1783,1784c
		cp->buf = 0;
.
1763,1766c
	cp = dp->cp;
.
1761c
	/*
	 *  cut transfer size down to disk buffer size
	 */
	start = off / dp->bytes;
	if(len > Maxxfer)
		len = Maxxfer;
	len = (len + dp->bytes - 1) / dp->bytes;
	if(len == 0)
		return 0;
.
1758d
1756c
	ulong start;
.
1754c
atapiio(Drive *dp, uchar *buf, ulong len, vlong off, int cmd)
.
1738d
1736a
	cp->nsecs = 1;
.
1677c
	cp->count = 0;
.
684c
		if(dp->atapi)
			i = atapirwio(c, buf, n-rv+skip, off+rv-skip, Cread2);
		else
			i = ataxfer(dp, pp, Cread, off+rv-skip, n-rv+skip, buf);
.
672d
## diffname pc/devata.c 1998/0825
## diff -e /n/emeliedump/1998/0516/sys/src/brazil/pc/devata.c /n/emeliedump/1998/0825/sys/src/brazil/pc/devata.c
1919c
	DPRINT("%s: atapipart secs %lud, bytes %ud, cap %lld\n",
.
1542c
				print("%s: read/ident cmd=%ux status=%ux\n",
.
1503c
			print("ata%d: cmd=%ux, lastcmd=%ux status=%ux\n",
.
1304c
	DPRINT("%s: probed: %ld/%d/%d CHS %lld bytes\n",
.
1237c
		DPRINT("%s: probe err: status %ux, err %ux\n",
.
1179c
	XPRINT("%s: %s %ld/%d/%d CHS %lld bytes\n",
.
1171c
		XPRINT("%s: LBA: %s %lud sectors %lld bytes\n",
.
1162c
		XPRINT("%s: changed to %ld cyl %d head %d sec\n",
.
1020c
		DPRINT("%s: setbuf err: status %ux, err %ux\n",
.
971c
		DPRINT("%s err: lblk %ld status %ux, err %ux\n",
.
905c
	XPRINT("%s: ataxfer cyl %d sec %d head %d len %ld\n",
.
845c
			DPRINT("%s: found bblk %ld at offset %d\n",
.
## diffname pc/devata.c 1998/0831
## diff -e /n/emeliedump/1998/0825/sys/src/brazil/pc/devata.c /n/emeliedump/1998/0831/sys/src/brazil/pc/devata.c
1860a

	if(dp->atapi == 1) { /* cd-rom */ 
		dp->npart = CDmax;
		pp = &dp->p[CDcmd];
		strcpy(pp->name, "cmd");
		pp->start = pp->end = 0;
		pp = &dp->p[CDdata];
		strcpy(pp->name, "data");
		pp->start = pp->end = 0;
	}
.
1711c
	atasleep(cp, Atapitimeout);
.
1674a
		print("cmdreadywait fails");
.
1589c
		if(cp->cmd == 0 && cp->lastcmd == Cpktcmd)
.
722,726d
720c
			poperror();
			break;
		case CDcmd:
			if(n != 12)
				error(Ebadarg);
			acmd = &dp->atapicmd;
			qlock(acmd);
			acmd->pid = up->pid;
			memmove(acmd->cmdblk, a, n);
			return n;
		case CDdata:
			error(Egreg);
.
716,718c
		switch(PART(c->qid.path)) {
		case CDdisk:
			if(dp->online == 0 || dp->atapi == 1)
				error(Eio);
			if(waserror()){
				qunlock(dp);
				nexterror();
			}
			qlock(dp);
			if(dp->partok == 0)
				atapipart(dp);
.
709a
	Atapicmd *acmd;
.
667,671d
665c
			poperror();
			break;
		case CDcmd:
			acmd = &dp->atapicmd;
			if(n < 4)
				error(Ebadarg);
			if(canqlock(acmd)) {
				qunlock(acmd);
				error(Egreg);
			}
			if(acmd->pid != up->pid)
				error(Egreg);
			n = 4;
			*aa++ = 0;
			*aa++ = 0;
			*aa++ = acmd->error;
			*aa   = acmd->status;
			qunlock(acmd);
			return n;
		case CDdata:
			acmd = &dp->atapicmd;
			if(canqlock(acmd)) {
				qunlock(acmd);
				error(Egreg);
			}
			if(acmd->pid != up->pid)
				error(Egreg);
			if(n > Maxxfer)
				error(Ebadarg);

			cp = dp->cp;
			qlock(cp->ctlrlock);
			cp->len = 0;
			cp->buf = 0;
			cp->dp = dp;
			if(waserror()) {
				if(cp->buf)
					free(cp->buf);
				cp->buf = 0;
				cp->dp = 0;
				acmd->status = cp->status;
				acmd->error = cp->error;
				qunlock(cp->ctlrlock);
				nexterror();
			}
			if(n)
				cp->buf = smalloc(Maxxfer);
			cp->len = n;
			memmove(cp->cmdblk, acmd->cmdblk, sizeof cp->cmdblk);
			atapiexec(dp);
			memmove(a, cp->buf, cp->count);
			poperror();
			if(cp->buf)
				free(cp->buf);
			acmd->status = cp->status;
			acmd->error = cp->error;
			n = cp->count;
			qunlock(cp->ctlrlock);
			return n;
.
661,663c
		switch(PART(c->qid.path)){
		case CDdisk:
			if(dp->online == 0)
				error(Eio);
			if(waserror()){
				qunlock(dp);
				nexterror();
			}
			qlock(dp);
			if(dp->partok == 0)
				atapipart(dp);
.
654a
	Atapicmd *acmd;
	Controller *cp;
.
631a
	if(dp->atapi == 1 && strcmp(p->name, "cmd") == 0) {
		acmd = &dp->atapicmd;
		if(canqlock(acmd)) {
			qunlock(acmd);
			return;
		}
		if(acmd->pid == up->pid)
			qunlock(acmd);
		return;
	}
.
623a
	Atapicmd *acmd;
.
206a
static void	atapiexec(Drive*);
.
146a
	Atapicmd atapicmd;
.
113a
 * the result of the last user-invoked atapi cmd
 */
struct Atapicmd
{
	QLock;
	int	pid;
	ushort	status;
	ushort	error;
	uchar	cmdblk[12];
};

/*
.
89a

	/* cd files */
	CDdisk = 0,
	CDcmd,
	CDdata,
	CDmax,
.
87c
	Atapitimeout=	10000,		/* disk access timeout (ms) */
.
24a
typedef struct Atapicmd		Atapicmd;
.
## diffname pc/devata.c 1998/0910
## diff -e /n/emeliedump/1998/0831/sys/src/brazil/pc/devata.c /n/emeliedump/1998/0910/sys/src/brazil/pc/devata.c
559c
		if(atactlrprobe(ctlrno, isa.irq, resetok))
.
## diffname pc/devata.c 1998/0922
## diff -e /n/emeliedump/1998/0910/sys/src/brazil/pc/devata.c /n/emeliedump/1998/0922/sys/src/brazil/pc/devata.c
2030c
		print("cmd=0x%2.2uX, lastcmd=0x%2.2uX ", cp->cmd, cp->lastcmd);
.
2018c
		print("cmd=0x%2.2uX, lastcmd=0x%2.2uX ", cp->cmd, cp->lastcmd);
.
1988c
		DPRINT("atapipart: cmd 0x%uX error 0x%uX\n", cp->cmdblk[0], cp->error);
.
1828c
		DPRINT("%s: Bad packet command 0x%ux, error 0x%ux\n",
			dp->vol, cp->cmdblk[0], cp->error);
.
## diffname pc/devata.c 1998/1006
## diff -e /n/emeliedump/1998/0922/sys/src/brazil/pc/devata.c /n/emeliedump/1998/1006/sys/src/brazil/pc/devata.c
1615c
			panic("ata%d: wait busy\n", cp->ctlrno);
.
397d
## diffname pc/devata.c 1998/1007
## diff -e /n/emeliedump/1998/1006/sys/src/brazil/pc/devata.c /n/emeliedump/1998/1007/sys/src/brazil/pc/devata.c
2095c
			print("%s: Cpktcmd status=0x%uX, error=0x%uX\n",
.
2088a
			microdelay(1);
.
2059c
	DPRINT("%s: atapiintr 0x%uX\n", cp->dp->vol, cause);
.
1889c
		DPRINT("atapiio: cmd 0x%uX error 0x%uX\n", cp->cmdblk[0], cp->error);
.
1827c
		DPRINT("%s: Bad packet command 0x%uX, error 0x%uX\n",
.
1803a
			microdelay(1);
.
1764c
		DPRINT("%s: isatapi cyl 0x%uX 0x%uX\n",
.
1760c
		DPRINT("%s: isatapi status 0x%uX\n", dp->vol, inb(cp->pbase+Pstatus));
.
1753c
		DPRINT("%s: isatapi ctlrwait status 0x%uX\n", dp->vol, inb(cp->pbase+Pstatus));
.
1690a
		DPRINT("Cident2\n");
.
1675,1677c
			//if(cp->cmd != Cread)
			//	cp->cmd = Cident2;
			//else
.
1655a
			microdelay(1);
.
1651c
				print("%s: read/ident cmd=0x%uX status=0x%uX\n",
.
1633a
				microdelay(1);
			}
.
1630c
			while(((cp->status = inb(cp->pbase+Pstatus)) & Sdrq) == 0){
.
1615a
		microdelay(1);
.
1614c
			panic("%s: wait busy\n", dp->vol);
.
1612c
			print("ata%d: cmd=0x%uX, lastcmd=0x%uX status=0x%uX\n",
.
1346c
		DPRINT("%s: probe err: status 0x%uX, err 0x%uX\n",
.
1243,1244c
	//if (cp->cmd == Cident2)
	//	tsleep(&cp->r, return0, 0, Hardtimeout);
.
1218c
	DPRINT("%s: ident command 0x%uX sent\n", dp->vol, cmd);
.
1129c
		DPRINT("%s: setbuf err: status 0x%uX, err 0x%uX\n",
.
1080c
		DPRINT("%s err: lblk %ld status 0x%uX, err 0x%uX\n",
.
1050a
		}
.
1048c
		while((stat = inb(cp->pbase+Pstatus) & (Serr|Sdrq)) == 0){
			microdelay(1);
.
565c
		DPRINT("ata%d: opt spindownmask 0x%uX\n", ctlrno, spindownmask);
.
500c
//skipedd:
.
492c
		DPRINT("ata%d: ATAPI slave 0x%uX 0x%uX 0x%uX\n", ctlrno, status,
.
486c
	DPRINT("ata%d: slave diag status 0x%uX, error 0x%uX\n",
		ctlr->ctlrno, status, error);
.
476c
	DPRINT("ata%d: master diag status 0x%uX, error 0x%uX\n",
.
438c
		DPRINT("ata%d: Cedd status 0x%uX/0x%uX/0x%uX\n", ctlrno,
.
427c
	DPRINT("ata%d: ATAPI 0x%uX 0x%uX 0x%uX\n", ctlrno, status,
.
417c
			DPRINT("ata%d: Srst status 0x%uX/0x%uX/0x%uX\n", ctlrno,
.
396a

.
386c
		DPRINT("ata%d: DHmagic not ok == 0x%uX\n", ctlrno, status);
.
338c
	DPRINT("ata%d: ctlrwait failed 0x%uX\n", ctlr->ctlrno, status);
.
## diffname pc/devata.c 1998/1101
## diff -e /n/emeliedump/1998/1007/sys/src/brazil/pc/devata.c /n/emeliedump/1998/1101/sys/src/brazil/pc/devata.c
427a
	status = inb(port+Pstatus);
.
420a
			return -1;
.
397d
## diffname pc/devata.c 1998/1126
## diff -e /n/emeliedump/1998/1101/sys/src/brazil/pc/devata.c /n/emeliedump/1998/1126/sys/src/brazil/pc/devata.c
2136c
	atareset,
.
2126c
			cp->error = inb(cp->cmdport+Perror);
.
2118c
			inss(cmdport+Pdata, cp->buf+cp->count, count/2);
.
2116c
			outss(cmdport+Pdata, cp->buf+cp->count, count/2);
.
2112c
		count = inb(cmdport+Pcyllsb)|(inb(cmdport+Pcylmsb)<<8);
.
2106c
			cp->error = inb(cmdport+Perror);
.
2101c
			cp->status = inb(cmdport+Pstatus);
.
2090c
				cp->error = inb(cmdport+Perror);
.
2081c
		outss(cmdport+Pdata, cp->cmdblk, sizeof(cp->cmdblk)/2);
.
2077c
			cp->error = inb(cmdport+Perror);
.
2068,2069c
	cmdport = cp->cmdport;
	cause = inb(cmdport+Pcount) & 0x03;
.
2066c
	int count, loop, cmdport;
.
1820c
		outss(cp->cmdport+Pdata, cp->cmdblk, sizeof(cp->cmdblk)/2);
.
1818c
				dp->vol, cp->cmd, inb(cp->cmdport+Pstatus));
.
1813c
		for(loop = 0; (inb(cp->cmdport+Pstatus) & (Serr|Sdrq)) == 0; loop++){
.
1803,1809c
	outb(cp->cmdport+Pcount, 0);
	outb(cp->cmdport+Psector, 0);
	outb(cp->cmdport+Pfeature, 0);
	outb(cp->cmdport+Pcyllsb, cp->len);
	outb(cp->cmdport+Pcylmsb, cp->len>>8);
	outb(cp->cmdport+Pdh, dp->dh);
	outb(cp->cmdport+Pcmd, cp->cmd);
.
1775c
			dp->vol, inb(cp->cmdport+Pcylmsb), inb(cp->cmdport+Pcyllsb));
.
1773c
	if(inb(cp->cmdport+Pcylmsb) != 0xEB || inb(cp->cmdport+Pcyllsb) != 0x14){
.
1769,1770c
	if(inb(cp->cmdport+Pstatus)){
		DPRINT("%s: isatapi status 0x%uX\n", dp->vol, inb(cp->cmdport+Pstatus));
.
1763c
		DPRINT("%s: isatapi ctlrwait status 0x%uX\n", dp->vol, inb(cp->cmdport+Pstatus));
.
1761c
	outb(cp->cmdport+Pcmd, 0x08);
.
1759c
	outb(cp->cmdport+Pdh, dp->dh);
.
1744,1746c
			outb(cp->cmdport+Pcount, 0);
			outb(cp->cmdport+Pdh, dp->dh);
			outb(cp->cmdport+Pcmd, cp->cmd);
.
1715c
			cp->ctlrno, cp->error, inb(cp->cmdport+Pcount));
.
1711c
			cp->error = inb(cp->cmdport+Perror);
.
1688c
			inb(cp->cmdport+Pstatus);
.
1677c
			inss(cp->cmdport+Pdata, addr, dp->bytes/2);
.
1670c
			cp->error = inb(cp->cmdport+Perror);
.
1665c
			cp->status = inb(cp->cmdport+Pstatus);
.
1660c
					dp->vol, cp->cmd, inb(cp->cmdport+Pstatus));
.
1645c
				outss(cp->cmdport+Pdata, addr, dp->bytes/2);
.
1639c
						dp->vol, cp->cmd, inb(cp->cmdport+Pstatus));
.
1636c
			while(((cp->status = inb(cp->cmdport+Pstatus)) & Sdrq) == 0){
.
1629c
			cp->error = inb(cp->cmdport+Perror);
.
1618c
				cp->ctlrno, cp->cmd, cp->lastcmd, inb(cp->cmdport+Pstatus));
.
1615c
	while((cp->status = inb(cp->cmdport+Pstatus)) & Sbusy){
.
1340,1345c
	outb(cp->cmdport+Pcount, 1);
	outb(cp->cmdport+Psector, sec+1);
	outb(cp->cmdport+Pdh, dp->dh | (dp->lba<<6) | head);
	outb(cp->cmdport+Pcyllsb, cyl);
	outb(cp->cmdport+Pcylmsb, cyl>>8);
	outb(cp->cmdport+Pcmd, Cread);
.
1276,1277c
		XPRINT("%s: %d/%d/%d changed to %ld/%d/%d CHS\n",
			dp->vol,
			ip->cyls, ip->heads, ip->s2t,
			dp->cyl, dp->heads, dp->sectors);
.
1219,1220c
	outb(cp->cmdport+Pdh, dp->dh);
	outb(cp->cmdport+Pcmd, cmd);
.
1126,1128c
	outb(cp->cmdport+Pfeature, arg);
	outb(cp->cmdport+Pdh, dp->dh);
	outb(cp->cmdport+Pcmd, Cfeature);
.
1056c
		outss(cp->cmdport+Pdata, cp->buf, dp->bytes/2);
.
1051c
		while((stat = inb(cp->cmdport+Pstatus) & (Serr|Sdrq)) == 0){
.
1041,1046c
	outb(cp->cmdport+Pcount, cp->nsecs);
	outb(cp->cmdport+Psector, sec);
	outb(cp->cmdport+Pdh, dp->dh | (dp->lba<<6) | head);
	outb(cp->cmdport+Pcyllsb, cyl);
	outb(cp->cmdport+Pcylmsb, cyl>>8);
	outb(cp->cmdport+Pcmd, cmd);
.
562a
		ctlrno++;
.
561c
		if(atactlrprobe(ctlrno, devp, isa.irq, resetok))
.
557c
			else if(cistrcmp(isa.opt[i], "reset") == 0)
.
542c
			if(cistrncmp(isa.opt[i], "spindown", 8) == 0){
.
536c
		if(isa.irq == 0 && (isa.irq = devp->irq) == 0)
.
534c
		isaconfig("ata", ctlrno, &isa);
		if(isa.port && isa.port != devp->cmdport)
.
529,532c
	ctlrno = 0;
	for(devno = 0; devno < natadev; devno++){
		devp = &atadev[devno];
.
527a
	Atadev *devp;
.
526c
	int ctlrno, devno, driveno, i, resetok, slave, spindown;
.
519a
	print("#H%d: cmdport 0x%uX ctlport 0x%uX irq %d mask 0x%uX atapi 0x%uX\n",
		ctlrno, cmdport, ctlport,  irq, mask, atapi);
	intrenable(irq, ataintr, ctlr, ctlr->tbdf);
	inb(cmdport+Pstatus);
	outb(ctlport+Pctl, 0);
	if(devp->ienable)
		devp->ienable(devp);

.
503c
//skipslave:
.
501a
	outb(cmdport+Pdh, DHmagic);
.
496c
			inb(cmdport+Pcylmsb), inb(cmdport+Pcyllsb));
.
493,494c
		msb = inb(cmdport+Pcylmsb);
		lsb = inb(cmdport+Pcyllsb);
.
486,487c
	status = inb(cmdport+Pstatus);
	error = inb(cmdport+Perror);
.
484c
	outb(cmdport+Pdh, DHmagic|DHslave);
.
479c
		ctlr->ctlrno, inb(cmdport+Pstatus), error);
.
477c
	error = inb(cmdport+Perror);
.
453,455c
	outb(cmdport+Pcmd, Cedd);
	microdelay(1);
	status = inb(cmdport+Pstatus);
	if(!(status & Sbusy)){
		DPRINT("ata%d: !busy 1 0x%uX\n", ctlrno, status);
		xfree(ctlr);
		return -1;
	}
	for(timo = 6000; timo; timo--){
		status = inb(cmdport+Pstatus);
		if(!(status & Sbusy))
			break;
		delay(1);
	}
	DPRINT("ata%d: timo %d\n", ctlrno, 6000-timo);
	status = inb(cmdport+Pstatus);
	if(status & Sbusy){
		DPRINT("ata%d: busy 2 0x%uX\n", ctlrno, status);
		xfree(ctlr);
		return -1;
	}
.
450,451c

	/*
	 * Can only get here if controller is not busy.
	 * If there are drives Sbusy will be set within 400nS.
	 * Wait for the command to complete (6 seconds max).
	 */
.
441c
			inb(cmdport+Pstatus), inb(cmdport+Pcylmsb), inb(cmdport+Pcyllsb));
.
439c
	if(atactlrwait(ctlr, DHmagic, 0, MS2TK(1))){
.
433,434d
430,431c
		inb(cmdport+Pcylmsb), inb(cmdport+Pcyllsb));
	USED(status);
	if(/*status == 0 &&*/ inb(cmdport+Pcylmsb) == 0xEB && inb(cmdport+Pcyllsb) == 0x14){
.
428c
	status = inb(cmdport+Pstatus);
.
423a
	/*
	 * Disable interrupts.
	 */
	outb(ctlport+Pctl, nIEN);

.
418c
				inb(cmdport+Pstatus), inb(cmdport+Pcylmsb), inb(cmdport+Pcyllsb));
.
415c
		outb(ctlport+Pctl, 0);
.
412,413c
	if(resetok && ctlport){
		outb(ctlport+Pctl, Srst|nIEN);
.
403,406d
392c
	ctlr->cmdport = cmdport;
	ctlr->ctlport = ctlport;
.
386c
		DPRINT("ata%d: DHmagic not ok == 0x%uX, 0x%uX\n",
			ctlrno, status, inb(cmdport+Pstatus));
.
381,384c
	DPRINT("ata%d: port 0x%uX\n", ctlrno, cmdport);
	outb(cmdport+Pdh, DHmagic);
	for(timo = 30000; timo; timo--){
		microdelay(1);
		status = inb(cmdport+Pdh);
		if(status == DHmagic)
			break;
	}
	status = inb(cmdport+Pdh);
.
377,378d
373a
	cmdport = devp->cmdport;
	ctlport = devp->ctlport;

.
371c
	int atapi, cmdport, ctlport, mask, once, timo;
.
368c
atactlrprobe(int ctlrno, Atadev* devp, int irq, int resetok)
.
321c
	port = ctlr->cmdport;
.
301,311c
	p = nil;
	while(p = pcimatch(p, 0, 0)){
		if(p->vid == 0x1095 && p->did == 0x0640){
			/*
			 * CMD640B dual PCI controllers. Amongst other
			 * bugs only one of the controllers can be active at a time.
			 * Unfortunately there's no way to tell which pair of
			 * controllers this is, so if one is found then all controller
			 * pairs are synchronised.
			 */
			have640b++;

			/*
			 * Make sure read-ahead is disabled on all
			 * drives and that the 2nd controller is enabled:
			 *   reg 0x51:	bit 7 - drive 1 read ahead disable
			 *  		bit 6 - drive 0 read ahead disable
			 *  		bit 3 - 2nd controller enable
			 *   reg 0x57:	bit 3 - drive 1 read ahead disable
			 *  		bit 2 - drive 0 read ahead disable
			 */
			r = pcicfgr8(p, 0x51);
			r |= 0xC8;
			pcicfgw8(p, 0x51, r);
			r = pcicfgr8(p, 0x57);
			r |= 0x0C;
			pcicfgw8(p, 0x57, r);
		}
		else if(p->vid == 0x1042 && (p->did == 0x1000 || p->did == 0x1001)){
			/*
			 * PC-Tech RZ1000 controllers.
			 * Turn off prefetch.
			 * This is overkill, but cheap.
			 */
			r = pcicfgr32(p, 0x40);
			r &= ~0x2000;
			pcicfgw32(p, 0x40, r);
		}
		else if(p->vid == 0x100B && p->did == 0x0002){
			/*
			 * National Semiconductor PC87415.
			 * Disable interrupts on both channels until
			 * after they are probed for drives.
			 * This must be called before interrupts are
			 * enabled in case the IRQ is being shared.
			 */
			pcicfgw32(p, 0x40, 0x00000300);

			/*
			 * Add any native-mode channels to the list to
			 * be probed.
			 */
			ccrp = pcicfgr8(p, PciCCRp);
			if((ccrp & 0x01) && natadev < nelem(atadev)){
				atadev[natadev].cmdport = p->mem[0].bar & ~0x01;
				atadev[natadev].ctlport = p->mem[1].bar & ~0x01;
				atadev[natadev].irq = p->intl;
				atadev[natadev].p = p;
				atadev[natadev].ienable = pc87415ienable;
				natadev++;
			}
			if((ccrp & 0x04) && natadev < nelem(atadev)){
				atadev[natadev].cmdport = p->mem[2].bar & ~0x01;
				atadev[natadev].ctlport = p->mem[3].bar & ~0x01;
				atadev[natadev].irq = p->intl;
				atadev[natadev].p = p;
				atadev[natadev].ienable = pc87415ienable;
				natadev++;
			}
		}
.
299c
	int ccrp, r;
.
296c
atareset(void)
.
267,292c
	p = devp->p;
	if(p == nil)
		return;

	x = pcicfgr32(p, 0x40);
	if(devp->cmdport == (p->mem[0].bar & ~0x01))
		x &= ~0x00000100;
	else
		x &= ~0x00000200;
	pcicfgw32(p, 0x40, x);
.
265c
	int x;
.
262c
pc87415ienable(Atadev* devp)
.
209,211c
static int natadev = 4;
.
206,207c

typedef struct Atadev Atadev;
typedef struct Atadev {
	int	cmdport;
	int	ctlport;
	int	irq;

	Pcidev*	p;
	void	(*ienable)(Atadev*);
} Atadev;

static void pc87415ienable(Atadev*);

static Atadev atadev[NCtlr] = {
	{ 0x1F0, 0x3F4, 14, },	/* primary */
	{ 0x170, 0x374, 15, },	/* secondary */
	{ 0x1E8, 0x3EC,  0, },	/* tertiary */
	{ 0x168, 0x36C,  0, },	/* quaternary */
.
178c
	int	cmdport;	/* base port */
	int	ctlport;
.
89c
	NCtlr=		8,		/* not really */
.
53c
	Pctl=		2,	/* device control, alternate status */
.
30,33d
4a
 * The PCI hacks are truly awful.
.
## diffname pc/devata.c 1999/0324
## diff -e /n/emeliedump/1998/1126/sys/src/brazil/pc/devata.c /n/emeliedump/1999/0324/sys/src/brazil/pc/devata.c
936a

	if(off < 0)
		error(Ebadarg);
.
867a
	if(off < 0)
		error(Ebadarg);

.
## diffname pc/devata.c 1999/0714
## diff -e /n/emeliedump/1999/0324/sys/src/brazil/pc/devata.c /n/emeliedump/1999/0714/sys/src/brazil/pc/devata.c
590a
		xfree(ctlr);
		return -1;
	}
	sprint(name, "ata%dcmd", ctlrno);
	if(ioalloc(devp->cmdport, 0x8, 0, name) < 0){
		print("#H%d: cmd port %d in use", ctlrno, devp->cmdport);
		xfree(ctlr);
		return -1;
	}
	sprint(name, "ata%dctl", ctlrno);
	if(ioalloc(devp->ctlport+Pctl, 1, 0, name) < 0){
		iofree(devp->cmdport);
		print("#H%d: ctl port %d in use", ctlrno, devp->ctlport);
.
427a
	char name[13];
.
## diffname pc/devata.c 1999/0819
## diff -e /n/emeliedump/1999/0714/sys/src/brazil/pc/devata.c /n/emeliedump/1999/0819/sys/src/brazil/pc/devata.c
622c
	snprint(name, sizeof name, "ata%d", ctlrno);
	intrenable(irq, ataintr, ctlr, ctlr->tbdf, name);
.
## diffname pc/devata.c 1999/1230
## diff -e /n/emeliedump/1999/0819/sys/src/brazil/pc/devata.c /n/emeliedump/1999/1230/sys/src/9/pc/devata.c
250a
	if(s == DEVDOTDOT){
		devdir(c, (Qid){CHDIR, 0}, "#H", 0, eve, 0555, dirp);
		return 1;
	}

.
## diffname pc/devata.c 2000/0308
## diff -e /n/emeliedump/1999/1230/sys/src/9/pc/devata.c /n/emeliedump/2000/0308/sys/src/9/pc/devata.c
1692c
			if(getfields(line[i], field, 3, 1, " ") != 3)
.
1684c
		n = getfields((char*)buf, line, Npart+1, 1, "\n");
.
1672c
			n = getfields((char*)buf, line, Npart+1, 1, "\n");
.
1666c
		n = getfields((char*)buf, line, Npart+1, 1, "\n");
.
1590c
			if(getfields(line[i], field, 1, 1, " ") != 1)
.
1585c
	n = getfields((char*)buf, line, Nrepl+1, 1, "\n");
.
## diffname pc/devata.c 2000/0517 # deleted
## diff -e /n/emeliedump/2000/0308/sys/src/9/pc/devata.c /n/emeliedump/2000/0517/sys/src/9/pc/devata.c
1,2275d