Subversion Repositories planix.SVN

/*

 * read-only driver for BIOS LBA devices.

 * devbios must be initialised first and no disks may be accessed

 * via non-BIOS means (i.e., talking to the disk controller directly).

 * EDD 4.0 defines the INT 0x13 functions.

 *

 * heavily dependent upon correct BIOS implementation.

 * some bioses (e.g., vmware) seem to hang for two minutes then report

 * a disk timeout on reset and extended read operations.

 */

#include	"u.h"

#include	"../port/lib.h"

#include	"mem.h"

#include	"dat.h"

#include	"fns.h"

#include	"io.h"

#include	"ureg.h"

#include	"pool.h"

#include	"../port/error.h"

#include	"../port/netif.h"

#include	"../port/sd.h"

#include	"dosfs.h"

#define TYPE(q)		((ulong)(q).path & 0xf)

#define UNIT(q)		(((ulong)(q).path>>4) & 0xff)

#define L(q)		(((ulong)(q).path>>12) & 0xf)

#define QID(u, t) 	((u)<<4 | (t))

typedef struct Biosdev Biosdev;

typedef struct Dap Dap;

typedef uvlong Devbytes, Devsects;

typedef uchar Devid;

typedef struct Edrvparam Edrvparam;

enum {

	Debug = 0,

	Pause = 0,			/* delay to read debugging */

	Minsectsz	= 512,		/* for disks */

	Maxsectsz	= 2048,		/* for optical (CDs, etc.) */

	Highshort	= ((1ul<<16) - 1) << 16,  /* upper short of a long */

	Maxdevs		= 8,

	CF		= 1,		/* carry flag: indicates an error */

	Flopid		= 0,		/* first floppy */

	Baseid		= 0x80,		/* first disk */

	Diskint		= 0x13,		/* "INT 13" for bios disk i/o */

	/* cx capability bits in Biosckext results */

	Fixeddisk	= 1<<0,		/* fixed disk access subset */

	Drlock		= 1<<1,

	Edd		= 1<<2,		/* enhanced disk drive support */

	Bit64ext	= 1<<3,

	/* bios calls: int 0x13 disk services w buffer at es:bx */

	Biosinit	= 0,		/* initialise disk & floppy ctlrs */

	Biosdrvsts,			/* status of last int 0x13 call */

	Biosdrvparam	= 8,

	Biosctlrinit,

	Biosreset	=  0xd,		/* reset disk */

	Biosdrvrdy	= 0x10,

	/* extended int 0x13 calls w dap at ds:si */

	Biosckext	= 0x41,

	Biosrdsect,

	Biosedrvparam	= 0x48,

	/* magic numbers for bios calls */

	Imok		= 0x55aa,

	Youreok		= 0xaa55,

};

enum {

	Qzero,				/* assumed to be 0 by devattach */

	Qtopdir		= 1,

	Qtopbase,

	Qtopctl		= Qtopbase,

	Qtopend,

	Qunitdir,

	Qunitbase,

	Qctl		= Qunitbase,

	Qdata,

	Qtopfiles	= Qtopend-Qtopbase,

};

struct Biosdev {

	Devbytes size;

	Devbytes offset;

	Devid	id;			/* drive number; e.g., 0x80 */

	ushort	sectsz;

	Chan	*rootchan;

	Bootfs;

};

struct Dap {				/* a device address packet */

	uchar	size;

	uchar	_unused1;

	uchar	nsects;

	uchar	_unused2;

	union {

		ulong	addr;		/* actual address (nominally seg:off) */

		struct {

			ushort	addroff;	/* :offset */

			ushort	addrseg;	/* segment: */

		};

	};

	uvlong	stsect;			/* starting sector */

	uvlong	addr64;			/* instead of addr, if addr is ~0 */

	ulong	lnsects;		/* nsects to match addr64 */

	ulong	_unused3;

};

struct Edrvparam {

	ushort	size;			/* max. buffer (struct) size */

	ushort	flags;

	ulong	physcyls;

	ulong	physheads;

	ulong	phystracksects;

	uvlong	physsects;

	ushort	sectsz;

	/* pointer is required to be unaligned, bytes 26-29.  ick. */

//	void	*dpte;			/* ~0ull: invalid */

	ushort	dpteoff;		/* device parameter table extension */

	ushort	dpteseg;

	/* remainder from edd 3.0 spec */

	ushort	key;			/* 0xbedd if device path info present */

	uchar	dpilen;			/* must be 44 (says edd 4.0) */

	uchar	_unused1;

	ushort	_unused2;

	char	bustype[4];		/* "PCI" or "ISA" */

	char	ifctype[8]; /* "ATA", "ATAPI", "SCSI", "USB", "1394", "FIBRE" */

	uvlong	ifcpath;

	uvlong	devpath[2];

	uchar	_unused3;

	uchar	dpicksum;

};

int biosinited;

int biosndevs;

void *biosgetfspart(int i, char *name, int chatty);

static Biosdev bdev[Maxdevs];

static Ureg regs;

static RWlock devs;

static int	dreset(Devid drive);

static Devbytes	extgetsize(Biosdev *);

static int	drivecap(Devid drive);

/* convert ah error code to a string (just common cases) */

static char *

strerr(uchar err)

{

	switch (err) {

	case 0:

		return "no error";

	case 1:

		return "bad command";

	case 0x80:

		return "disk timeout";

	default:

		return "unknown";

	}

}

static void

assertlow64k(uintptr p, char *tag)

{

	if (p & Highshort)

		panic("devbios: %s address %#p not in bottom 64k", tag, p);

}

static void

initrealregs(Ureg *ureg)

{

	memset(ureg, 0, sizeof *ureg);

}

/*

 * caller must zero or otherwise initialise *ureg,

 * other than ax, bx, dx, si & ds.

 */

static int

biosdiskcall(Ureg *ureg, uchar op, ulong bx, ulong dx, ulong si)

{

	int s;

	uchar err;

	s = splhi();		/* don't let the bios call be interrupted */

	initrealregs(ureg);

	ureg->ax = op << 8;

	ureg->bx = bx;

	ureg->dx = dx;		/* often drive id */

	assertlow64k(si, "dap");

	if(si && (si & Highshort) != ((si + Maxsectsz - 1) & Highshort))

		print("biosdiskcall: dap address %#lux too near segment boundary\n",

			si);

	ureg->si = si;		/* ds:si forms data address packet addr */

	ureg->ds = 0;		/* bottom 64K */

	ureg->es = 0;		/* es:bx is conventional buffer */

	ureg->di = 0;		/* buffer segment? */

	ureg->flags = 0;

	/*

	 * *ureg is copied into low memory (realmoderegs) and thence into

	 * the machine registers before the BIOS call, and the registers are

	 * copied into realmoderegs and thence into *ureg after.

	 *

	 * realmode loads these registers: di, si, ax, bx, cx, dx, ds, es.

	 */

	ureg->trap = Diskint;

	realmode(ureg);

	if (ureg->flags & CF) {

		if (dx == Baseid) {

			err = ureg->ax >> 8;

			print("\nbiosdiskcall: int %#x op %#ux drive %#lux "

				"failed, ah error code %#ux (%s)\n",

				Diskint, op, dx, err, strerr(err));

		}

		splx(s);

		return -1;

	}

	splx(s);

	return 0;

}

/*

 * Find out what the bios knows about devices.

 * our boot device could be usb; ghod only knows where it will appear.

 */

int

biosinit0(void)

{

	int cap, mask, lastbit, ndrive;

	Devbytes size;

	Devid devid;

	Biosdev *bdp;

	static int beenhere;

	delay(Pause);		/* pause to read the screen (DEBUG) */

	if (biosinited || beenhere)

		return 0;

	beenhere = 1;

	ndrive = *(uchar *)KADDR(0x475);		/* from bda */

	if (Debug)

		print("%d bios drive(s)\n", ndrive);

	mask = lastbit = 0;

	for (devid = Baseid, biosndevs = 0; devid != 0 && biosndevs < Maxdevs &&

	    biosndevs < ndrive; devid++) {

		cap = drivecap(devid);

		/* don't reset; it seems to hang the bios */

		if(cap < 0 || (cap & (Fixeddisk|Edd)) != (Fixeddisk|Edd)

		    /* || devid != Baseid && dreset(devid) < 0 || */)

			continue;		/* no suitable device */

		/* found a live one */

		lastbit = 1 << biosndevs;

		mask |= lastbit;

		bdp = &bdev[biosndevs];

		bdp->id = devid;

		size = extgetsize(bdp);

		if (size == 0)

			continue;		/* no device */

		bdp->size = size;

		print("bios%d: drive %#ux: %,llud bytes, %d-byte sectors\n",

			biosndevs, devid, size, bdp->sectsz);

		biosndevs++;

	}

	USED(lastbit);

	if (Debug && ndrive != biosndevs)

		print("devbios: expected %d drives, found %d\n", ndrive, biosndevs);

	/*

	 * some bioses seem to only be able to read from drive number 0x80 and

	 * can't read from the highest drive number, even if there is only one.

	 */

	if (biosndevs > 0)

		biosinited = 1;

	else

		panic("devbios: no bios drives seen"); /* 9loadusb needs ≥ 1 */

	delay(Pause);		/* pause to read the screen (DEBUG) */

	return mask;

}

static void

biosreset(void)

{

	biosinit0();

}

static void

biosinit(void)

{

}

static Chan*

biosattach(char *spec)

{

	ulong drive;

	char *p;

	Chan *chan;

	drive = 0;

	if(spec && *spec){

		drive = strtoul(spec, &p, 0);

		if((drive == 0 && p == spec) || *p || (drive >= Maxdevs))

			error(Ebadarg);

	}

	if(bdev[drive].rootchan)

		return bdev[drive].rootchan;

	chan = devattach(L'☹', spec);

	if(waserror()){

		chanfree(chan);

		nexterror();

	}

	chan->dev = drive;

	bdev[drive].rootchan = chan;

	/* arbitrary initialisation can go here */

	poperror();

	return chan;

}

static int

unitgen(Chan *c, ulong type, Dir *dp)

{

	int perm, t;

	ulong vers;

	vlong size;

	char *p;

	Qid q;

	perm = 0644;

	size = 0;

//	d = unit2dev(UNIT(c->qid));

//	vers = d->vers;

	vers = 0;

	t = QTFILE;

	switch(type){

	default:

		return -1;

	case Qctl:

		p = "ctl";

		break;

	case Qdata:

		p = "data";

		perm = 0640;

		break;

	}

	mkqid(&q, QID(UNIT(c->qid), type), vers, t);

	devdir(c, q, p, size, eve, perm, dp);

	return 1;

}

static int

topgen(Chan *c, ulong type, Dir *d)

{

	int perm;

	vlong size;

	char *p;

	Qid q;

	size = 0;

	switch(type){

	default:

		return -1;

	case Qdata:

		p = "data";

		perm = 0644;

		break;

	}

	mkqid(&q, type, 0, QTFILE);

	devdir(c, q, p, size, eve, perm, d);

	return 1;

}

static int

biosgen(Chan *c, char *, Dirtab *, int, int s, Dir *dp)

{

	Qid q;

	if(c->qid.path == 0){

		switch(s){

		case DEVDOTDOT:

			q.path = 0;

			q.type = QTDIR;

			devdir(c, q, "#☹", 0, eve, 0555, dp);

			break;

		case 0:

			q.path = Qtopdir;

			q.type = QTDIR;

			devdir(c, q, "bios", 0, eve, 0555, dp);

			break;

		default:

			return -1;

		}

		return 1;

	}

	switch(TYPE(c->qid)){

	default:

		return -1;

	case Qtopdir:

		if(s == DEVDOTDOT){

			mkqid(&q, Qzero, 0, QTDIR);

			devdir(c, q, "bios", 0, eve, 0555, dp);

			return 1;

		}

		if(s < Qtopfiles)

			return topgen(c, Qtopbase + s, dp);

		s -= Qtopfiles;

		if(s >= 1)

			return -1;

		mkqid(&q, QID(s, Qunitdir), 0, QTDIR);

		devdir(c, q, "bios", 0, eve, 0555, dp);

		return 1;

	case Qdata:

		return unitgen(c, TYPE(c->qid), dp);

	}

}

static Walkqid*

bioswalk(Chan *c, Chan *nc, char **name, int nname)

{

	return devwalk(c, nc, name, nname, nil, 0, biosgen);

}

static int

biosstat(Chan *c, uchar *db, int n)

{

	return devstat(c, db, n, nil, 0, biosgen);

}

static Chan*

biosopen(Chan *c, int omode)

{

	return devopen(c, omode, 0, 0, biosgen);

}

static void

biosclose(Chan *)

{

}

#ifdef UNUSED

int

biosboot(int dev, char *file, Boot *b)

{

	Bootfs *fs;

	if(strncmp(file, "dos!", 4) == 0)

		file += 4;

	if(strchr(file, '!') != nil || strcmp(file, "") == 0) {

		print("syntax is bios0!file\n");

		return -1;

	}

	fs = biosgetfspart(dev, "9fat", 1);

	if(fs == nil)

		return -1;

	return fsboot(fs, file, b);

}

#endif

/* read n bytes at sector offset into a from drive id */

long

sectread(Biosdev *bdp, void *a, long n, Devsects offset)

{

	uchar *xch;

	uintptr xchaddr;

	Dap *dap;

	if(bdp->sectsz <= 0 || n < 0 || n > bdp->sectsz)

		return -1;

	xch = (uchar *)BIOSXCHG;

	assertlow64k(PADDR(xch), "biosxchg");

	if(Debug)

		/* scribble on the buffer to provoke trouble */

		memset(xch, 'r', bdp->sectsz);

	/* read into BIOSXCHG; alloc space for a worst-case (optical) sector */

	dap = (Dap *)(xch + Maxsectsz);

	assertlow64k(PADDR(dap), "Dap");

	memset(dap, 0, sizeof *dap);

	dap->size = sizeof *dap;

	dap->nsects = 1;

	dap->stsect = offset;

	xchaddr = PADDR(xch);

	assertlow64k(xchaddr, "sectread buffer");

	dap->addr = xchaddr;		/* ulong version */

	dap->addroff = xchaddr;		/* pedantic seg:off */

	dap->addrseg = 0;

	dap->addr64 = xchaddr;		/* paranoid redundancy */

	dap->lnsects = 1;

	/*

	 * ensure that entire buffer fits in low memory.

	 */

	if((dap->addr & Highshort) !=

	    ((dap->addr + Minsectsz - 1) & Highshort))

		print("devbios: sectread: address %#lux too near seg boundary\n",

			dap->addr);

	if (Debug)

		print("reading bios drive %#ux sector %lld -> %#lux...",

			bdp->id, offset, dap->addr);

	delay(Pause);			/* pause to read the screen (DEBUG) */

	/*

	 * int 13 read sector expects buffer seg in di?,

	 * dap in si, 0x42 in ah, drive in dl.

	 */

	if (biosdiskcall(&regs, Biosrdsect, 0, bdp->id, PADDR(dap)) < 0) {

		print("devbios: sectread: bios failed to read %ld @ sector %lld of %#ux\n",

			n, offset, bdp->id);

		return -1;

	}

	if (dap->nsects != 1)

		panic("devbios: sector read ok but read %d sectors",

			dap->nsects);

	if (Debug)

		print("OK\n");

	/* copy into caller's buffer */

	memmove(a, xch, n);

	if(0 && Debug)

		print("-%ux %ux %ux %ux--%16.16s-\n",

			xch[0], xch[1], xch[2], xch[3], (char *)xch + 480);

	delay(Pause);		/* pause to read the screen (DEBUG) */

	return n;

}

/* seems to hang bioses, at least vmware's */

static int

dreset(Devid drive)

{

	print("devbios: resetting %#ux...", drive);

	/* ignore carry flag for Biosinit */

	biosdiskcall(&regs, Biosinit, 0, drive, 0);

	print("\n");

	return regs.ax? -1: 0;		/* ax != 0 on error */

}

/* returns capabilities bitmap */

static int

drivecap(Devid drive)

{

	int cap;

	if (biosdiskcall(&regs, Biosckext, Imok, drive, 0) < 0)

		/*

		 * we have an old bios without extensions, in theory.

		 * in practice, there may just be no drive for this number.

		 */

		return -1;

	if(regs.bx != Youreok){

		print("devbios: buggy bios: drive %#ux extension check "

			 "returned %lux in bx\n", drive, regs.bx);

		return -1;

	}

	cap = regs.cx;

	if (Debug) {

		print("bios drive %#ux extensions version %#x.%d cx %#ux\n",

			drive, (uchar)(regs.ax >> 8), (uchar)regs.ax, cap);

		if ((uchar)(regs.ax >> 8) < 0x30) {

			print("drivecap: extensions prior to 0x30\n");

			return -1;

		}

		print("\tsubsets supported:");

		if (cap & Fixeddisk)

			print(" fixed disk access;");

		if (cap & Drlock)

			print(" drive locking;");

		if (cap & Edd)

			print(" enhanced disk support;");

		if (cap & Bit64ext)

			print(" 64-bit extensions;");

		print("\n");

	}

	delay(Pause);			/* pause to read the screen (DEBUG) */

	return cap;

}

/* extended get size; reads bdp->id, fills in bdp->sectsz, returns # sectors */

static Devbytes

extgetsize(Biosdev *bdp)

{

	ulong sectsz;

	Edrvparam *edp;

	edp = (Edrvparam *)BIOSXCHG;

	memset(edp, 0, sizeof *edp);

	edp->size = sizeof *edp;

	edp->dpteseg = edp->dpteoff = ~0;	/* no pointer */

	edp->dpilen = 44;

	if (biosdiskcall(&regs, Biosedrvparam, 0, bdp->id, PADDR(edp)) < 0)

		return 0;		/* old bios without extensions */

	if(Debug) {

		print("bios drive %#ux info flags %#ux", bdp->id, edp->flags);

		if (edp->key == 0xbedd)

			print("; edd 3.0  %.4s %.8s",

				edp->bustype, edp->ifctype);

		else

			print("; NOT edd 3.0 compliant (key %#ux)", edp->key);

		print("\n");

	}

	if (edp->sectsz <= 0) {

		print("devbios: drive %#ux: sector size <= 0\n", bdp->id);

		edp->sectsz = 1;		/* don't divide by 0 */

		return 0;

	}

	sectsz = edp->sectsz;

	if (sectsz > Maxsectsz) {

		print("devbios: sector size %lud > %d\n", sectsz, Maxsectsz);

		return 0;

	}

	bdp->sectsz = sectsz;

	return edp->physsects * sectsz;

}

vlong

biossize(uint dev)

{

	Biosdev *bdp;

	if (dev >= biosndevs)

		return -1;

	bdp = &bdev[dev];

	if (bdp->sectsz <= 0)

		return -1;

	return bdp->size / bdp->sectsz;

}

long

biossectsz(uint dev)

{

	Biosdev *bdp;

	if (dev >= biosndevs)

		return -1;

	bdp = &bdev[dev];

	if (bdp->sectsz <= 0)

		return -1;

	return bdp->sectsz;

}

long

biosread0(Bootfs *fs, void *a, long n)

{

	int want, got, part, dev;

	long totnr, stuck;

	Devbytes offset;

	Biosdev *bdp;

	dev = fs->dev;				/* only use of fs */

	if(dev > biosndevs)

		return -1;

	if (n <= 0)

		return n;

	bdp = &bdev[dev];

	offset = bdp->offset;

	stuck = 0;

	for (totnr = 0; totnr < n && stuck < 4; totnr += got) {

		if (bdp->sectsz == 0) {

			print("devbios: zero sector size\n");

			return -1;

		}

		want = bdp->sectsz;

		if (totnr + want > n)

			want = n - totnr;

		if(0 && Debug && debugload)

			print("bios%d, read: %ld @ off %lld, want: %d, id: %#ux\n",

				dev, n, offset, want, bdp->id);

		part = offset % bdp->sectsz;

		if (part != 0) {	/* back up to start of sector */

			offset -= part;

			totnr  -= part;

			if (totnr < 0) {

				print("biosread0: negative count %ld\n", totnr);

				return -1;

			}

		}

		if ((vlong)offset < 0) {

			print("biosread0: negative offset %lld\n", offset);

			return -1;

		}

		got = sectread(bdp, (char *)a + totnr, want,

			offset / bdp->sectsz);

		if(got <= 0)

			return -1;

		offset += got;

		bdp->offset = offset;

		if (got < bdp->sectsz)

			stuck++;	/* we'll have to re-read this sector */

		else

			stuck = 0;

	}

	return totnr;

}

vlong

biosseek(Bootfs *fs, vlong off)

{

	if (off < 0) {

		print("biosseek(fs, %lld) is illegal\n", off);

		return -1;

	}

	if(fs->dev > biosndevs) {

		print("biosseek: fs->dev %d > biosndevs %d\n", fs->dev, biosndevs);

		return -1;

	}

	bdev[fs->dev].offset = off;	/* do not know size... (yet) */

	return off;

}

static long

biosread(Chan *c, void *db, long n, vlong off)

{

	Biosdev *bp;

	switch(TYPE(c->qid)){

	default:

		error(Eperm);

	case Qzero:

	case Qtopdir:

		return devdirread(c, db, n, 0, 0, biosgen);

	case Qdata:

		bp = &bdev[UNIT(c->qid)];

		if (bp->rootchan == nil)

			panic("biosread: nil root chan for bios%ld",

				UNIT(c->qid));

		biosseek(&bp->Bootfs, off);

		return biosread0(&bp->Bootfs, db, n);

	}

}

/* name is typically "9fat" */

void *

biosgetfspart(int i, char *name, int chatty)

{

	char part[32];

	static Bootfs fs;

	fs.dev = i;

	fs.diskread = biosread0;

	fs.diskseek = biosseek;

	snprint(part, sizeof part, "#S/sdB0/%s", name);

	if(dosinit(&fs, part) < 0){

		if(chatty)

			print("bios%d!%s does not contain a FAT file system\n",

				i, name);

		return nil;

	}

	return &fs;

}

static long

bioswrite(Chan *, void *, long, vlong)

{

	error("bios devices are read-only in bootstrap");

	return 0;

}

Dev biosdevtab = {

	L'☹',

	"bios",

	biosreset,

	biosinit,

	devshutdown,

	biosattach,

	bioswalk,

	biosstat,

	biosopen,

	devcreate,

	biosclose,

	biosread,

	devbread,

	bioswrite,

	devbwrite,

	devremove,

	devwstat,

	devpower,

	devconfig,

};