ref: 1f6de2fe3823cc6e749b8254187e81e20589bae8
dir: /os/boot/puma/hard.c/
#include "u.h"
#include "lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "io.h"
#define DPRINT if(0)print
typedef struct Drive Drive;
typedef struct Ident Ident;
typedef struct Controller Controller;
enum
{
/* ports */
Pbase0= 0x1F0, /* primary */
Pbase1= 0x170, /* secondary */
Pbase2= 0x1E8, /* tertiary */
Pbase3= 0x168, /* quaternary */
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 */
DHmagic= 0xA0,
DHslave= 0x10,
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,
/* file types */
Qdir= 0,
Timeout= 5, /* seconds to wait for things to complete */
NCtlr= 4,
NDrive= NCtlr*2,
};
/*
* 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];
};
/*
* a hard drive
*/
struct Drive
{
Controller *cp;
uchar driveno;
uchar dh;
Disc;
};
/*
* a controller for 2 drives
*/
struct Controller
{
int pbase; /* base port */
uchar ctlrno;
/*
* current operation
*/
int cmd; /* current command */
char *buf; /* xfer buffer */
int tcyl; /* target cylinder */
int thead; /* target head */
int tsec; /* target sector */
int tbyte; /* target byte */
int nsecs; /* length of transfer (sectors) */
int sofar; /* bytes transferred so far */
int status;
int error;
Drive *dp; /* drive being accessed */
};
static int atactlrmask;
static Controller *atactlr[NCtlr];
static int atadrivemask;
static Drive *atadrive[NDrive];
static int pbase[NCtlr] = {
Pbase0, Pbase1, Pbase2, Pbase3,
};
static void hardintr(Ureg*, void*);
static long hardxfer(Drive*, Partition*, int, ulong, long);
static int hardident(Drive*);
static void hardsetbuf(Drive*, int);
static void hardpart(Drive*);
static int hardparams(Drive*);
static void hardrecal(Drive*);
static int hardprobe(Drive*, int, int, int);
static void
atactlrprobe(int ctlrno, int irq)
{
Controller *ctlr;
Drive *drive;
int driveno, port;
if(atactlrmask & (1<<ctlrno))
return;
atactlrmask |= 1<<ctlrno;
port = pbase[ctlrno];
outb(port+Pdh, DHmagic);
delay(1);
if((inb(port+Pdh) & 0xFF) != DHmagic){
DPRINT("ata%d: DHmagic not ok\n", ctlrno);
return;
}
DPRINT("ata%d: DHmagic ok\n", ctlrno);
atactlr[ctlrno] = ialloc(sizeof(Controller), 0);
ctlr = atactlr[ctlrno];
ctlr->pbase = port;
ctlr->ctlrno = ctlrno;
ctlr->buf = ialloc(Maxxfer, 0);
inb(ctlr->pbase+Pstatus);
setvec(irq, hardintr, ctlr);
driveno = ctlrno*2;
atadrive[driveno] = ialloc(sizeof(Drive), 0);
drive = atadrive[driveno];
drive->cp = ctlr;
drive->driveno = driveno;
drive->dh = DHmagic;
driveno++;
atadrive[driveno] = ialloc(sizeof(Drive), 0);
drive = atadrive[driveno];
drive->cp = ctlr;
drive->driveno = driveno;
drive->dh = DHmagic|DHslave;
}
static Drive*
atadriveprobe(int driveno)
{
Drive *drive;
int ctlrno;
ISAConf isa;
ctlrno = driveno/2;
if(atactlr[ctlrno] == 0){
if(atactlrmask & (1<<ctlrno))
return 0;
memset(&isa, 0, sizeof(ISAConf));
if(isaconfig("ata", ctlrno, &isa) == 0)
return 0;
if(ctlrno && isa.irq)
atactlrprobe(ctlrno, Int0vec+isa.irq);
if(atactlr[ctlrno] == 0)
return 0;
}
drive = atadrive[driveno];
if(drive->online == 0){
if(atadrivemask & (1<<driveno))
return 0;
atadrivemask |= 1<<driveno;
if(hardparams(drive))
return 0;
if(drive->lba)
print("hd%d: LBA %d sectors, %ud bytes\n",
drive->driveno, drive->sectors, drive->cap);
else
print("hd%d: CHS %d/%d/%d %d bytes\n",
drive->driveno, drive->cyl, drive->heads,
drive->sectors, drive->cap);
drive->online = 1;
hardpart(drive);
hardsetbuf(drive, 1);
}
return drive;
}
int
hardinit(void)
{
atactlrprobe(0, ATAvec0);
return 0xFF;
}
long
hardseek(int driveno, long offset)
{
Drive *drive;
if((drive = atadriveprobe(driveno)) == 0)
return -1;
drive->offset = offset;
return offset;
}
/*
* did an interrupt happen?
*/
static void
hardwait(Controller *cp)
{
ulong start;
int x;
x = spllo();
for(start = m->ticks; TK2SEC(m->ticks - start) < Timeout && cp->cmd;)
if(cp->cmd == Cident2 && TK2SEC(m->ticks - start) >= 1)
break;
if(TK2SEC(m->ticks - start) >= Timeout){
DPRINT("hardwait timed out %ux\n", inb(cp->pbase+Pstatus));
hardintr(0, cp);
}
splx(x);
}
Partition*
sethardpart(int driveno, char *p)
{
Partition *pp;
Drive *dp;
if((dp = atadriveprobe(driveno)) == 0)
return 0;
for(pp = dp->p; pp < &dp->p[dp->npart]; pp++)
if(strcmp(pp->name, p) == 0){
dp->current = pp;
return pp;
}
return 0;
}
long
hardread(int driveno, void *a, long n)
{
Drive *dp;
long rv, i;
int skip;
uchar *aa = a;
Partition *pp;
Controller *cp;
if((dp = atadriveprobe(driveno)) == 0)
return 0;
pp = dp->current;
if(pp == 0)
return -1;
cp = dp->cp;
skip = dp->offset % dp->bytes;
for(rv = 0; rv < n; rv += i){
i = hardxfer(dp, pp, Cread, dp->offset+rv-skip, n-rv+skip);
if(i == 0)
break;
if(i < 0)
return -1;
i -= skip;
if(i > n - rv)
i = n - rv;
memmove(aa+rv, cp->buf + skip, i);
skip = 0;
}
dp->offset += rv;
return rv;
}
/*
* wait for the controller to be ready to accept a command
*/
static int
cmdreadywait(Drive *drive)
{
ulong end;
uchar dh, status;
Controller *ctlr;
ctlr = drive->cp;
end = m->ticks+MS2TK(10)+1;
dh = (inb(ctlr->pbase+Pdh) & DHslave)^(drive->dh & DHslave);
status = 0;
while(m->ticks < end){
status = inb(ctlr->pbase+Pstatus);
if(status & Sbusy)
continue;
if(dh){
outb(ctlr->pbase+Pdh, drive->dh);
dh = 0;
continue;
}
if(status & Sready)
return 0;
}
USED(status);
DPRINT("hd%d: cmdreadywait failed %uX\n", drive->driveno, status);
outb(ctlr->pbase+Pdh, DHmagic);
return -1;
}
/*
* transfer a number of sectors. hardintr will perform all the iterative
* parts.
*/
static long
hardxfer(Drive *dp, Partition *pp, int cmd, ulong start, long len)
{
Controller *cp;
long lsec;
if(dp->online == 0){
DPRINT("disk not on line\n");
return -1;
}
if(cmd == Cwrite)
return -1;
/*
* cut transfer size down to disk buffer size
*/
start = start / dp->bytes;
if(len > Maxxfer)
len = Maxxfer;
len = (len + dp->bytes - 1) / dp->bytes;
/*
* calculate physical address
*/
cp = dp->cp;
lsec = start + pp->start;
if(lsec >= pp->end){
DPRINT("read past end of partition\n");
return 0;
}
if(dp->lba){
cp->tsec = lsec & 0xff;
cp->tcyl = (lsec>>8) & 0xffff;
cp->thead = (lsec>>24) & 0xf;
} else {
cp->tcyl = lsec/(dp->sectors*dp->heads);
cp->tsec = (lsec % dp->sectors) + 1;
cp->thead = (lsec/dp->sectors) % dp->heads;
}
/*
* can't xfer past end of disk
*/
if(lsec+len > pp->end)
len = pp->end - lsec;
cp->nsecs = len;
if(cmdreadywait(dp) < 0)
return -1;
/*
* start the transfer
*/
cp->cmd = cmd;
cp->dp = dp;
cp->sofar = 0;
cp->status = 0;
DPRINT("xfer:\ttcyl %d, tsec %d, thead %d\n", cp->tcyl, cp->tsec, cp->thead);
DPRINT("\tnsecs %d, sofar %d\n", cp->nsecs, cp->sofar);
outb(cp->pbase+Pcount, cp->nsecs);
outb(cp->pbase+Psector, cp->tsec);
outb(cp->pbase+Pdh, dp->dh | (dp->lba<<6) | cp->thead);
outb(cp->pbase+Pcyllsb, cp->tcyl);
outb(cp->pbase+Pcylmsb, cp->tcyl>>8);
outb(cp->pbase+Pcmd, cmd);
hardwait(cp);
if(cp->status & Serr){
DPRINT("hd%d err: status %lux, err %lux\n",
dp->driveno, cp->status, cp->error);
DPRINT("\ttcyl %d, tsec %d, thead %d\n",
cp->tcyl, cp->tsec, cp->thead);
DPRINT("\tnsecs %d, sofar %d\n", cp->nsecs, cp->sofar);
return -1;
}
return cp->nsecs*dp->bytes;
}
/*
* set read ahead mode (1 == on, 0 == off)
*/
static void
hardsetbuf(Drive *dp, int on)
{
Controller *cp = dp->cp;
if(cmdreadywait(dp) < 0)
return;
cp->cmd = Csetbuf;
/* BUG: precomp varies by hard drive...this is safari-specific? */
outb(cp->pbase+Pprecomp, on ? 0xAA : 0x55);
outb(cp->pbase+Pdh, dp->dh);
outb(cp->pbase+Pcmd, Csetbuf);
hardwait(cp);
}
static int
isatapi(Drive *drive)
{
Controller *cp;
cp = drive->cp;
outb(cp->pbase+Pdh, drive->dh);
microdelay(1);
if(inb(cp->pbase+Pstatus))
return 0;
if(inb(cp->pbase+Pcylmsb) != 0xEB || inb(cp->pbase+Pcyllsb) != 0x14)
return 0;
return 1;
}
/*
* get parameters from the drive
*/
static int
hardident(Drive *dp)
{
Controller *cp;
Ident *ip;
dp->bytes = 512;
cp = dp->cp;
if(isatapi(dp) || cmdreadywait(dp) < 0)
return -1;
cp->nsecs = 1;
cp->sofar = 0;
cp->cmd = Cident;
cp->dp = dp;
outb(cp->pbase+Pdh, dp->dh);
outb(cp->pbase+Pcmd, Cident);
hardwait(cp);
if(cp->status & Serr)
return -1;
hardwait(cp);
ip = (Ident*)cp->buf;
DPRINT("LBA%d: %lud\n",
ip->capabilities & (1<<9) == 1, (ip->lbasecs[0]) | (ip->lbasecs[1]<<16));
DPRINT("DEF: %ud/%ud/%ud\nMAP %ud/%ud/%ud\n",
ip->cyls, ip->heads, ip->s2t,
ip->ccyls, ip->cheads, ip->cs2t);
if(ip->capabilities & (1<<9)){
dp->lba = 1;
dp->sectors = (ip->lbasecs[0]) | (ip->lbasecs[1]<<16);
dp->cap = dp->bytes * dp->sectors;
/*print("\nata%d model %s with %d lba sectors\n", dp->driveno, id, dp->sectors);/**/
} else {
dp->lba = 0;
/* use default (unformatted) settings */
dp->cyl = ip->cyls;
dp->heads = ip->heads;
dp->sectors = ip->s2t;
/*print("\nata%d model %s with default %d cyl %d head %d sec\n", dp->driveno,
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;
}
return 0;
}
/*
* probe the given sector to see if it exists
*/
static int
hardprobe(Drive *dp, int cyl, int sec, int head)
{
Controller *cp;
cp = dp->cp;
if(cmdreadywait(dp) < 0)
return -1;
/*
* start the transfer
*/
cp->cmd = Cread;
cp->dp = dp;
cp->sofar = 0;
cp->nsecs = 1;
cp->status = 0;
outb(cp->pbase+Pcount, 1);
outb(cp->pbase+Psector, sec+1);
outb(cp->pbase+Pdh, dp->dh | (dp->lba<<6) | head);
outb(cp->pbase+Pcyllsb, cyl);
outb(cp->pbase+Pcylmsb, cyl>>8);
outb(cp->pbase+Pcmd, Cread);
hardwait(cp);
if(cp->status & Serr)
return -1;
return 0;
}
/*
* figure out the drive parameters
*/
static int
hardparams(Drive *dp)
{
int i, hi, lo;
/*
* first try the easy way, ask the drive and make sure it
* isn't lying.
*/
dp->bytes = 512;
if(hardident(dp) < 0)
return -1;
if(dp->lba){
i = dp->sectors - 1;
if(hardprobe(dp, (i>>8)&0xffff, (i&0xff)-1, (i>>24)&0xf) == 0)
return 0;
} else {
if(hardprobe(dp, dp->cyl-1, dp->sectors-1, dp->heads-1) == 0)
return 0;
}
DPRINT("hardparam: cyl %d sectors %d heads %d\n", dp->cyl, dp->sectors, dp->heads);
/*
* the drive lied, determine parameters by seeing which ones
* work to read sectors.
*/
dp->lba = 0;
for(i = 0; i < 16; i++)
if(hardprobe(dp, 0, 0, i) < 0)
break;
dp->heads = i;
for(i = 0; i < 64; i++)
if(hardprobe(dp, 0, i, 0) < 0)
break;
dp->sectors = i;
for(i = 512; ; i += 512)
if(hardprobe(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(hardprobe(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;
if(dp->cyl == 0 || dp->heads == 0 || dp->sectors == 0 || dp->cap == 0)
return -1;
return 0;
}
/*
* read partition table. The partition table is just ascii strings.
*/
#define MAGIC "plan9 partitions"
static void
hardpart(Drive *dp)
{
Partition *pp;
Controller *cp;
char *field[3], *line[Npart+1], *p, buf[NAMELEN];
ulong n;
int i;
cp = dp->cp;
/*
* 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;
/*
* Check if the partitions are described in plan9.ini.
* If not, read the disc.
*/
sprint(buf, "hd%dpartition", dp->driveno);
if((p = getconf(buf)) == 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.
*/
hardxfer(dp, pp, Cread, 0, dp->bytes);
cp->buf[dp->bytes-1] = 0;
n = getcfields(cp->buf, line, Npart+1, "\n");
if(n == 0 || strncmp(line[0], MAGIC, sizeof(MAGIC)-1)){
dp->p[0].end--;
dp->p[1].start--;
dp->p[1].end--;
hardxfer(dp, pp, Cread, 0, dp->bytes);
cp->buf[dp->bytes-1] = 0;
n = getcfields(cp->buf, line, Npart+1, "\n");
}
}
else{
strcpy(cp->buf, p);
n = getcfields(cp->buf, line, Npart+1, "\n");
}
/*
* parse partition table.
*/
if(n && strncmp(line[0], MAGIC, sizeof(MAGIC)-1) == 0){
for(i = 1; i < n; i++){
pp++;
if(getcfields(line[i], field, 3, " ") != 3)
break;
strncpy(pp->name, field[0], NAMELEN);
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++;
}
}
return;
}
/*
* we get an interrupt for every sector transferred
*/
static void
hardintr(Ureg*, void *arg)
{
Controller *cp;
Drive *dp;
long loop;
cp = arg;
dp = cp->dp;
loop = 0;
while((cp->status = inb(cp->pbase+Pstatus)) & Sbusy)
if(++loop > 100000){
print("hardintr 0x%lux\n", cp->status);
break;
}
switch(cp->cmd){
case Cread:
case Cident:
if(cp->status & Serr){
cp->cmd = 0;
cp->error = inb(cp->pbase+Perror);
return;
}
loop = 0;
while((inb(cp->pbase+Pstatus) & Sdrq) == 0)
if(++loop > 100000){
print("hardintr 2 cmd %ux status %ux",
cp->cmd, inb(cp->pbase+Pstatus));
cp->cmd = 0;
return;
}
inss(cp->pbase+Pdata, &cp->buf[cp->sofar*dp->bytes],
dp->bytes/2);
cp->sofar++;
if(cp->sofar >= cp->nsecs){
if(cp->cmd == Cident && (cp->status & Sready) == 0)
cp->cmd = Cident2; /* sometimes we get a second intr */
else
cp->cmd = 0;
inb(cp->pbase+Pstatus);
}
break;
case Csetbuf:
case Cident2:
cp->cmd = 0;
break;
default:
cp->cmd = 0;
break;
}
}