## diffname pc/devfloppy.c 1991/0727
## diff -e /dev/null /n/bootesdump/1991/0727/sys/src/9/safari/devfloppy.c
0a
#include "u.h"
#include "lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "io.h"
#include "ureg.h"
typedef struct Drive Drive;
typedef struct Controller Controller;
typedef struct Type Type;
enum
{
Fmotor= 0x3f2, /* motor port */
Fintena= 0x4, /* enable floppy interrupt */
Fena= 0x8, /* 0 == reset controller */
Fstatus= 0x3f4, /* controller main status port */
Fready= 0x80, /* ready to be touched */
Ffrom= 0x40, /* data from controller */
Fbusy= 0x10, /* operation not over */
Fdata= 0x3f5, /* controller data port */
Frecal= 0x7, /* recalibrate cmd */
Fseek= 0xf, /* seek cmd */
Fsense= 0x8, /* sense cmd */
Fread= 0x66, /* read cmd */
Fwrite= 0x47, /* write cmd */
Fmulti= 0x80, /* or'd with Fread or Fwrite for multi-head */
DMAmode0= 0xb,
DMAmode1= 0xc,
DMAaddr= 0x4,
DMAtop= 0x81,
DMAinit= 0xa,
DMAcount= 0x5,
Nfloppy= 4, /* floppies/controller */
/* sector size encodings */
S128= 0,
S256= 1,
S512= 2,
S1024= 3,
/* status 0 byte */
Drivemask= 3<<0,
Seekend= 1<<5,
Codemask= (3<<6)|(3<<3),
};
/*
* floppy types
*/
struct Type
{
char *name;
int bytes; /* bytes/sector */
int sectors; /* sectors/track */
int heads; /* number of heads */
int steps; /* steps per cylinder */
int tracks; /* tracks/disk */
int gpl; /* intersector gap length for read/write */
int fgpl; /* intersector gap length for format */
long cap; /* drive capacity in bytes */
};
Type floppytype[] =
{
{ "MF2HD", S512, 18, 2, 1, 80, 0x1B, 0x54, 512*2*18*80 },
{ "MF2DD", S512, 9, 2, 1, 80, 0x1B, 0x54, 512*2*9*80 },
{ "F2HD", S512, 15, 2, 1, 80, 0x2A, 0x50, 512*15*2*80 },
{ "F2DD", S512, 8, 2, 1, 40, 0x2A, 0x50, 512*8*2*40 },
{ "F1DD", S512, 8, 1, 1, 40, 0x2A, 0x50, 512*8*1*40 },
};
static int secbytes[] =
{
128,
256,
512,
1024
};
/*
* a floppy drive
*/
struct Drive
{
QLock;
Type *t;
int dev;
ulong lasttouched; /* time last touched */
int motoron; /* motor is on */
int cyl; /* current cylinder */
long offset; /* current offset */
int confused; /* needs to be recalibrated (or worse) */
int tcyl; /* target cylinder */
int thead; /* target head */
int tsec; /* target sector */
long len;
int busy; /* true if drive is seeking */
Rendez r; /* waiting for operation termination */
};
/*
* NEC PD765A controller for 4 floppys
*/
struct Controller
{
QLock;
Drive d[Nfloppy]; /* the floppy drives */
int busy; /* true if a read or write in progress */
uchar stat[8]; /* status of an operation */
int confused;
};
Controller floppy[1];
/*
* start a floppy drive's motor. set an alarm for 1 second later to
* mark it as started (we get no interrupt to tell us).
*
* assume the caller qlocked the drive.
*/
void
floppystart(Drive *dp)
{
int cmd;
dp->lasttouched = m->ticks;
if(dp->motoron)
return;
cmd = (1<<(dp->dev+4)) | Fintena | Fena | dp->dev;
outb(Fmotor, cmd);
dp->busy = 1;
tsleep(&dp->r, noreturn, 0, 1000);
dp->motoron = 1;
dp->busy = 0;
dp->lasttouched = m->ticks;
}
/*
* stop the floppy if it hasn't been used in 5 seconds
*/
void
floppystop(Drive *dp)
{
int cmd;
if(!canqlock(dp))
return;
cmd = Fintena | Fena | dp->dev;
outb(Fmotor, cmd);
dp->motoron = 0;
}
void
floppykproc(Alarm* a)
{
Drive *dp;
if(waserror())
for(dp = floppy.d; dp < &floppy.d[Nfloppy]; dp++){
if(dp->motoron && TK2SEC(m->ticks - dp->lasttouched) > 5)
floppystop(dp);
}
alarm(5*1000, floppyalarm, 0);
cancel(a);
}
int
floppysend(int data)
{
int tries;
uchar c;
for(tries = 0; tries < 100; tries++){
/*
* see if its ready for data
*/
c = inb(Fstatus);
if((c&(Ffrom|Fready)) != Fready)
continue;
/*
* send the data
*/
outb(Fdata, data);
return 0;
}
return -1;
}
int
floppyrcv(void)
{
int tries;
uchar c;
for(tries = 0; tries < 100; tries++){
/*
* see if its ready for data
*/
c = inb(Fstatus);
if((c&(Ffrom|Fready)) != (Ffrom|Fready))
continue;
/*
* get data
*/
return inb(Fdata)&0xff;
}
return -1;
}
int
floppyrdstat(int n)
{
int i;
int c;
for(i = 0; i < n; i++){
c = floppyrcv();
if(c < 0)
return -1;
floppy.stat[i] = c;
}
return 0;
}
void
floppypos(Drive *dp, long off)
{
int lsec;
int end;
int cyl;
lsec = off/secbytes[dp->t->bytes];
dp->tcyl = lsec/(dp->t->sectors*dp->t->heads);
dp->tsec = (lsec % dp->t->sectors) + 1;
dp->thead = (lsec/dp->t->sectors) % dp->t->heads;
/*
* can't read across cylinder boundaries.
* if so, decrement the bytes to be read.
*/
lsec = (off+dp->len)/secbytes[dp->t->bytes];
cyl = lsec/(dp->t->sectors*dp->t->heads);
if(cyl != dp->tcyl){
dp->len -= (lsec % dp->t->sectors)*secbytes[dp->t->bytes];
dp->len -= ((lsec/dp->t->sectors) % dp->t->heads)*secbytes[dp->t->bytes]
*dp->t->sectors;
}
dp->lasttouched = m->ticks;
floppy.intr = 0;
}
void
floppywait(void)
{
int tries;
for(tries = 0; tries < 100 && floppy.intr == 0; tries++)
delay(5);
if(tries >= 100)
print("tired floopy\n");
floppy.intr = 0;
}
int
floppysense(Drive *dp)
{
/*
* ask for floppy status
*/
if(floppysend(Fsense) < 0){
floppy.confused = 1;
return -1;
}
if(floppyrdstat(2) < 0){
floppy.confused = 1;
dp->confused = 1;
return -1;
}
/*
* make sure it's the right drive
*/
if((floppy.stat[0] & Drivemask) != dp-floppy.d){
print("sense failed\n");
dp->confused = 1;
return -1;
}
return 0;
}
int
floppyrecal(Drive *dp)
{
floppy.intr = 0;
if(floppysend(Frecal) < 0
|| floppysend(dp - floppy.d) < 0){
floppy.confused = 0;
return -1;
}
floppywait();
/*
* get return values
*/
if(floppysense(dp) < 0)
return -1;
/*
* see if it worked
*/
if((floppy.stat[0] & (Codemask|Seekend)) != Seekend){
print("recalibrate failed\n");
dp->confused = 1;
return -1;
}
/*
* see what cylinder we got to
*/
dp->tcyl = 0;
dp->cyl = floppy.stat[1]/dp->t->steps;
if(dp->cyl != dp->tcyl){
print("recalibrate went to wrong cylinder %d\n", dp->cyl);
dp->confused = 1;
return -1;
}
dp->confused = 0;
return 0;
}
void
floppyinit(void)
{
Drive *dp;
for(dp = floppy.d; dp < &floppy.d[Nfloppy]; dp++){
dp->t = &floppytype[0];
dp->cyl = -1;
dp->motoron = 1;
floppystop(dp);
}
setvec(22, floppyintr);
alarm(5*1000, floppyalarm, (void *)0);
}
void
floppyreset(void)
{
Drive *dp;
/*
* reset the floppy if'n it's confused
*/
if(floppy.confused){
/* reset controller and turn all motors off */
floppy.intr = 0;
splhi();
outb(Fmotor, 0);
delay(1);
outb(Fmotor, Fintena|Fena);
spllo();
for(dp = floppy.d; dp < &floppy.d[Nfloppy]; dp++){
dp->motoron = 0;
dp->confused = 1;
}
floppywait();
floppy.confused = 0;
}
/*
* recalibrate any confused drives
*/
for(dp = floppy.d; floppy.confused == 0 && dp < &floppy.d[Nfloppy]; dp++){
if(dp->confused == 0)
floppyrecal(dp);
}
}
long
floppyseek(int dev, long off)
{
Drive *dp;
dp = &floppy.d[dev];
if(floppy.confused || dp->confused)
floppyreset();
floppystart(dp);
floppypos(dp, off);
if(dp->cyl == dp->tcyl){
dp->offset = off;
return off;
}
/*
* tell floppy to seek
*/
if(floppysend(Fseek) < 0
|| floppysend((dp->thead<<2) | dev) < 0
|| floppysend(dp->tcyl * dp->t->steps) < 0){
print("seek cmd failed\n");
floppy.confused = 1;
return -1;
}
/*
* wait for interrupt
*/
floppywait();
/*
* get floppy status
*/
if(floppysense(dp) < 0)
return -1;
/*
* see if it worked
*/
if((floppy.stat[0] & (Codemask|Seekend)) != Seekend){
print("seek failed\n");
dp->confused = 1;
return -1;
}
/*
* see what cylinder we got to
*/
dp->cyl = floppy.stat[1]/dp->t->steps;
if(dp->cyl != dp->tcyl){
print("seek went to wrong cylinder %d instead of %d\n", dp->cyl, dp->tcyl);
dp->confused = 1;
return -1;
}
dp->offset = off;
return dp->offset;
}
long
floppyxfer(Drive *dp, int cmd, void *a, long n)
{
int dev;
ulong addr;
long offset;
addr = (ulong)a;
dev = dp - floppy.d;
/*
* dma can't cross 64 k boundaries
*/
if((addr & 0xffff0000) != ((addr+n) & 0xffff0000))
n -= (addr+n)&0xffff;
dp->len = n;
floppyseek(dev, dp->offset);
/* print("tcyl %d, thead %d, tsec %d, addr %lux, n %d\n",
dp->tcyl, dp->thead, dp->tsec, addr, n);/**/
/*
* set up the dma
*/
outb(DMAmode1, cmd==Fread ? 0x46 : 0x4a);
outb(DMAmode0, cmd==Fread ? 0x46 : 0x4a);
outb(DMAaddr, addr);
outb(DMAaddr, addr>>8);
outb(DMAtop, addr>>16);
outb(DMAcount, n-1);
outb(DMAcount, (n-1)>>8);
outb(DMAinit, 2);
/*
* tell floppy to go
*/
cmd = cmd | (dp->t->heads > 1 ? Fmulti : 0);
if(floppysend(cmd) < 0
|| floppysend((dp->thead<<2) | dev) < 0
|| floppysend(dp->tcyl * dp->t->steps) < 0
|| floppysend(dp->thead) < 0
|| floppysend(dp->tsec) < 0
|| floppysend(dp->t->bytes) < 0
|| floppysend(dp->t->sectors) < 0
|| floppysend(dp->t->gpl) < 0
|| floppysend(0xFF) < 0){
print("xfer cmd failed\n");
floppy.confused = 1;
return -1;
}
floppywait();
/*
* get status
*/
if(floppyrdstat(7) < 0){
print("xfer status failed\n");
floppy.confused = 1;
return -1;
}
if((floppy.stat[0] & Codemask)!=0 || floppy.stat[1] || floppy.stat[2]){
print("xfer failed %lux %lux %lux\n", floppy.stat[0],
floppy.stat[1], floppy.stat[2]);
dp->confused = 1;
return -1;
}
offset = (floppy.stat[3]/dp->t->steps) * dp->t->heads + floppy.stat[4];
offset = offset*dp->t->sectors + floppy.stat[5] - 1;
offset = offset * secbytes[floppy.stat[6]];
if(offset != dp->offset+n){
print("new offset %d instead of %d\n", offset, dp->offset+dp->len);
dp->confused = 1;
return -1;/**/
}
dp->offset += dp->len;
return dp->len;
}
long
floppyread(int dev, void *a, long n)
{
Drive *dp;
long rv, i;
uchar *aa = a;
dp = &floppy.d[dev];
for(rv = 0; rv < n; rv += i){
i = floppyxfer(dp, Fread, aa+rv, n-rv);
if(i <= 0)
break;
}
return rv;
}
void
floppyintr(Ureg *ur)
{
floppy.intr = 1;
}
.
## diffname pc/devfloppy.c 1991/0728
## diff -e /n/bootesdump/1991/0727/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0728/sys/src/9/safari/devfloppy.c
354,355c
}
void
floppyinit(void)
{
kproc(floppykproc, 0);
.
351a
dp->cyl = -1;
.
349,350c
dp->dev = dp - floppy.d;
dp->t = &floppytype[0]; /* default type */
.
344c
floppyreset(void)
.
170,172d
168a
qunlock(dp);
}
.
167c
if(dp->motoron && TK2SEC(m->ticks - dp->lasttouched) > 5
&& canqlock(dp)){
.
165d
154,155d
120c
Controller floppy;
.
50a
/* file types */
Qdir= 0,
Qdata= 16,
Qstruct= 32,
.
40a
DMAchan= 2, /* floppy dma channel */
.
32,38d
## diffname pc/devfloppy.c 1991/0729
## diff -e /n/bootesdump/1991/0728/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0729/sys/src/9/safari/devfloppy.c
166c
if(TK2SEC(m->ticks - dp->lasttouched) > 5)
floppystop(dp);
.
## diffname pc/devfloppy.c 1991/0730
## diff -e /n/bootesdump/1991/0729/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0730/sys/src/9/safari/devfloppy.c
256,270d
## diffname pc/devfloppy.c 1991/0731
## diff -e /n/bootesdump/1991/0730/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0731/sys/src/9/safari/devfloppy.c
546a
wakeup(&floppy.r);
.
527,543c
static void
.
522a
qunlock(&floppy);
qunlock(dp);
poperror();
.
520c
errors("floppy drive lost");
.
518c
print("new offset %d instead of %d\n", offset, dp->offset+dp->len);
.
516c
offset = offset * c2b[floppy.stat[6]];
.
511c
errors("floppy drive lost");
.
504c
errors("floppy result failed");
.
501,502c
if(floppyresult(7) < 0){
print("xfer status failed\n");
.
496c
sleep(&floppy.r, interrupted, 0);
.
493c
errors("floppy command failed");
.
487c
|| floppysend(dp->t->bcode) < 0
.
479c
* start operation
.
469,476c
dp->len = dmasetup(2, a, dp->len, cmd==Fread);
.
467c
* set up the dma (dp->len may be trimmed)
.
463c
print("tcyl %d, thead %d, tsec %d, addr %lux, n %d\n",
.
461c
floppypos(dp);
if(floppyseek(dp) < 0)
errors("seeking floppy");
.
459a
/*
* calculate new position and seek to it (dp->len may be trimmed)
*/
.
457,458c
if(floppy.confused || dp->confused)
floppyrevive();
if(!dp->motoron)
motoron(dp);
.
455c
* get floppy reset and spinning
.
453a
qlock(&floppy);
qlock(dp);
if(waserror){
qunlock(&floppy);
qunlock(dp);
}
.
452d
447d
444c
static long
.
413c
sleep(&floppy.r, interrupted, 0);
.
403c
|| floppysend((dp->thead<<2) | dp->dev) < 0
.
384,393d
381,382c
static long
floppyseek(Drive *dp)
.
373c
for(dp = floppy.d; floppy.confused == 0 && dp < &floppy.d[Ndrive]; dp++){
.
366c
sleep(&floppy.r, interrupted, 0);
.
362c
for(dp = floppy.d; dp < &floppy.d[Ndrive]; dp++){
.
352c
* reset the floppy if it's confused
.
331,350d
327c
floppyrevive(void)
.
325a
/*
* if the controller or a specific drive is in a confused state,
* reset it and get back to a kown state
*/
.
294c
sleep(&floppy.r, interrupted, 0);
.
285c
/*
* return true if interrupt occurred
*/
static int
interrupted(void *a)
{
return floppy.intr;
}
/*
* we've lost the floppy position, go to cylinder 0.
*/
static int
.
268c
if(floppyresult(2) < 0){
.
258c
/*
* get the interrupt cause from the floppy. we need to do this
* after seeks and recalibrations since they don't return results.
*/
static int
.
252,253c
dp->len -= (lsec % dp->t->sectors)*dp->t->bytes;
dp->len -= ((lsec/dp->t->sectors) % dp->t->heads)*dp->t->bytes
.
249c
lsec = (dp->off+dp->len)/dp->t->bytes;
.
240c
lsec = dp->off/dp->t->bytes;
.
233,234c
/*
* calculate physical address of a logical byte offset into the disk
*
* truncate dp->length if it crosses a cylinder boundary
*/
static void
floppypos(Drive *dp)
.
218,219c
/*
* read a command result message from the floppy
*/
static int
floppyresult(int n)
.
196c
/*
* get a byte from the floppy
*/
static int
.
173c
/*
* send a byte to the floppy
*/
static int
.
167c
motoroff(dp);
.
163c
for(dp = floppy.d; dp < &floppy.d[Ndrive]; dp++){
.
158,159c
static void
floppykproc(void *a)
.
149,150c
static void
motoroff(Drive *dp)
.
133,136d
128,129c
static void
motoron(Drive *dp)
.
122a
* predeclared
*/
static void motoron(Drive*);
static void motoroff(Drive*);
static void floppykproc(void*);
static int floppysend(int);
static int floppyrcv(void);
static int floppyresult(int);
static void floppypos(Drive*);
static int floppysense(Drive*);
static int interrupted(void*);
static int floppyrecal(Drive*);
static void floppyrevive(void);
static long floppyseek(Drive*);
static long floppyxfer(Drive*, int, void*, long);
static void floppyintr(Ureg*);
static int
floppygen(Chan *c, Dirtab *tab, long ntab, long s, Dir *dp)
{
long l;
Drive *dp;
if(s >= ntab)
return -1;
if(c->dev >= Ndrive)
return -1;
tab += s;
dp = &floppy.d[c->dev];
if((tab->qid.path&~Mask) == Qdata)
l = dp->t->cap;
else
l = 8;
devdir(c, tab->qid, tab->name, l, tab->perm, dp);
return 1;
}
void
floppyreset(void)
{
Drive *dp;
for(dp = floppy.d; dp < &floppy.d[Ndrive]; dp++){
dp->dev = dp - floppy.d;
dp->t = &floppytype[0]; /* default type */
dp->motoron = 1;
dp->cyl = -1;
motoroff(dp);
}
setvec(Floppyvec, floppyintr);
}
void
floppyinit(void)
{
Type *t;
/*
* init dependent parameters
*/
for(t = floppytype; t < &floppytype[NTYPES], t++){
t->cap = t->bytes * t->heads * t->sectors * t->tracks;
t->bcode = bcode[t->bytes/128];
}
/*
* watchdog to turn off the motors
*/
kproc(floppykproc, 0);
}
long
floppyread(Chan *c, void *a, long n)
{
Drive *dp;
long rv, i;
uchar *aa = a;
dp = &floppy.d[c->dev];
for(rv = 0; rv < n; rv += i){
i = floppyxfer(dp, Fread, aa+rv, n-rv);
if(i <= 0)
break;
}
return rv;
}
long
floppywrite(Chan *c, void *a, long n)
{
Drive *dp;
long rv, i;
uchar *aa = a;
dp = &floppy.d[c->dev];
for(rv = 0; rv < n; rv += i){
i = floppyxfer(dp, Fwrite, aa+rv, n-rv);
if(i <= 0)
break;
}
return rv;
}
/*
.
117a
int intr; /* true if interrupt occured */
Rendez r; /* wait here for command termination */
.
113,114c
QLock; /* exclusive access to the contoller */
Drive d[Ndrive]; /* the floppy drives */
.
105c
Rendez r; /* waiting here for motor to spin up */
.
102c
long len; /* size of xfer */
.
89c
QLock; /* exclusive access to the drive */
.
81c
1024,
.
77a
[1] 0,
[2] 1,
[4] 2,
[8] 3,
};
static int c2b[] =
{
.
76c
#define NTYPES (sizeof(floppytype)/sizeof(Type))
/*
* bytes/sector encoding for the controller, index is (bytes per sector/128)
*/
static int b2c[] =
.
70,74c
{ "MF2HD", 512, 18, 2, 1, 80, 0x1B, 0x54, },
{ "MF2DD", 512, 9, 2, 1, 80, 0x1B, 0x54, },
{ "F2HD", 512, 15, 2, 1, 80, 0x2A, 0x50, },
{ "F2DD", 512, 8, 2, 2, 40, 0x2A, 0x50, },
{ "F1DD", 512, 8, 1, 2, 40, 0x2A, 0x50, },
.
65c
int fgpl; /* intersector gap length for format */
/*
* these depend on previous entries and are set filled in
* by floppyinit
*/
int bcode; /* coded version of bytes for the controller */
.
49,50c
Qdata= 1,
Qstruct= 2,
.
32c
Ndrive= 4, /* floppies/controller */
.
## diffname pc/devfloppy.c 1991/0802
## diff -e /n/bootesdump/1991/0731/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0802/sys/src/9/safari/devfloppy.c
658d
653a
dp->lasttouched = m->ticks;
.
648,649c
if(offset != off+dp->len){
print("new offset %d instead of %d\n", offset, off+dp->len);
.
626d
614c
|| floppysend((dp->thead<<2) | dp->dev) < 0
.
611a
floppy.intr = 0;
.
597c
floppypos(dp, off);
.
580c
if(waserror()){
.
571c
floppyxfer(Drive *dp, int cmd, void *a, long off, long n)
.
566,567c
return dp->cyl;
.
535,538d
527a
floppy.intr = 0;
dp->cyl = -1; /* once the seek starts it could end anywhere */
.
520,523c
if(dp->cyl == dp->tcyl)
return dp->cyl;
.
417c
if((floppy.stat[0] & Drivemask) != dp->dev){
.
385c
lsec = (off+dp->len)/dp->t->bytes;
.
376c
lsec = off/dp->t->bytes;
.
370c
floppypos(Drive *dp, long off)
.
291a
tsleep(&floppy.kr, return0, 0, 5*1000);
.
285,290c
waserror();
for(;;){
for(dp = floppy.d; dp < &floppy.d[Ndrive]; dp++){
if(dp->motoron && TK2SEC(m->ticks - dp->lasttouched) > 5
&& canqlock(dp)){
if(TK2SEC(m->ticks - dp->lasttouched) > 5)
motoroff(dp);
qunlock(dp);
}
.
264d
261,262c
tsleep(&dp->r, return0, 0, 750);
.
249c
* start a floppy drive's motor. set an alarm for .75 second later to
.
239,243c
rv = 0;
dp = &floppy.d[c->qid.path & ~Qmask];
switch ((int)(c->qid.path & Qmask)) {
case Qdata:
for(rv = 0; rv < n; rv += i){
i = floppyxfer(dp, Fwrite, aa+rv, c->offset+rv, n-rv);
if(i <= 0)
break;
}
break;
case Qstruct:
error(Eperm);
break;
default:
panic("floppywrite: bad qid");
.
223,227c
if(c->qid.path == CHDIR)
return devdirread(c, a, n, floppydir, NFDIR, devgen);
rv = 0;
dp = &floppy.d[c->qid.path & ~Qmask];
switch ((int)(c->qid.path & Qmask)) {
case Qdata:
for(rv = 0; rv < n; rv += i){
i = floppyxfer(dp, Fread, aa+rv, c->offset+rv, n-rv);
if(i <= 0)
break;
}
break;
case Qstruct:
if (n < 2*sizeof(ulong))
error(Ebadarg);
if (c->offset >= 2*sizeof(ulong))
return 0;
rv = 2*sizeof(ulong);
ul2user((uchar*)a, dp->t->cap);
ul2user((uchar*)a+sizeof(ulong), dp->t->bytes);
break;
default:
panic("floppyread: bad qid");
.
215a
Chan*
floppyattach(char *spec)
{
return devattach('f', spec);
}
Chan*
floppyclone(Chan *c, Chan *nc)
{
return devclone(c, nc);
}
int
floppywalk(Chan *c, char *name)
{
return devwalk(c, name, floppydir, NFDIR, devgen);
}
void
floppystat(Chan *c, char *dp)
{
devstat(c, dp, floppydir, NFDIR, devgen);
}
Chan*
floppyopen(Chan *c, int omode)
{
return devopen(c, omode, floppydir, NFDIR, devgen);
}
void
floppycreate(Chan *c, char *name, int omode, ulong perm)
{
error(Eperm);
}
void
floppyclose(Chan *c)
{
}
void
floppyremove(Chan *c)
{
error(Eperm);
}
void
floppywstat(Chan *c, char *dp)
{
error(Eperm);
}
static void
ul2user(uchar *a, ulong x)
{
a[0] = x >> 24;
a[1] = x >> 16;
a[2] = x >> 8;
a[3] = x;
}
.
214c
kproc("floppy", floppykproc, 0);
.
204,211d
201,202d
192c
dp->cyl = -1; /* because we don't know */
.
190a
floppydir[2*dp->dev].length = dp->t->cap;
.
187a
/*
* init dependent parameters
*/
for(t = floppytype; t < &floppytype[NTYPES]; t++){
t->cap = t->bytes * t->heads * t->sectors * t->tracks;
t->bcode = b2c[t->bytes/128];
}
/*
* stop the motors
*/
.
186a
Type *t;
.
168,182d
162,166c
Dirtab floppydir[]={
"fd0data", {Qdata + 0}, 0, 0600,
"fd0struct", {Qstruct + 0}, 8, 0600,
"fd1data", {Qdata + 1}, 0, 0600,
"fd1struct", {Qstruct + 1}, 8, 0600,
"fd2data", {Qdata + 2}, 0, 0600,
"fd2struct", {Qstruct + 2}, 8, 0600,
"fd3data", {Qdata + 3}, 0, 0600,
"fd3struct", {Qstruct + 3}, 8, 0600,
};
#define NFDIR (sizeof(floppydir)/sizeof(Dirtab))
.
159c
static long floppyxfer(Drive*, int, void*, long, long);
.
153c
static void floppypos(Drive*,long);
.
139a
Rendez kr; /* for motor watcher */
.
135d
123d
115d
85c
* bytes per sector encoding for the controller.
* - index for b2c is is (bytes per sector/128).
* - index for c2b is code from b2c
.
49,50c
Qdata= (1<<2),
Qstruct= (2<<2),
Qmask= (3<<2),
.
11c
typedef struct Type Type;
.
9c
typedef struct Drive Drive;
.
7c
#include "errno.h"
.
## diffname pc/devfloppy.c 1991/0803
## diff -e /n/bootesdump/1991/0802/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0803/sys/src/9/safari/devfloppy.c
381a
.
380a
disp++;
if(owl(disp&1) < 0)
print("owl failed\n");
if(mail((disp>>1)&1) < 0)
print("mail failed\n");
.
369a
int disp = 0;
.
## diffname pc/devfloppy.c 1991/0806
## diff -e /n/bootesdump/1991/0803/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0806/sys/src/9/safari/devfloppy.c
756a
print("floppy intr\n");
.
## diffname pc/devfloppy.c 1991/0809
## diff -e /n/bootesdump/1991/0806/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0809/sys/src/9/safari/devfloppy.c
606c
for(dp = floppy.d; floppy.confused == 0 && dp < &floppy.d[conf.nfloppy]; dp++){
.
595c
for(dp = floppy.d; dp < &floppy.d[conf.nfloppy]; dp++){
.
385,386d
374c
for(dp = floppy.d; dp < &floppy.d[conf.nfloppy]; dp++){
.
289,292c
if(c->offset % dp->t->bytes)
errors("bad offset");
if(n % dp->t->bytes)
errors("bad len");
nn = dp->t->bytes * dp->t->sectors * dp->t->heads;
for(rv = 0; rv < n; rv += len){
/*
* truncate xfer at cylinder boundary
*/
dp->len = n - rv;
floppypos(dp, c->offset+rv);
cyl = dp->tcyl;
len = dp->len;
sec = dp->tsec + dp->thead * dp->t->sectors;
/*
* read the cylinder
*/
if(dp->ccyl != cyl){
dp->ccyl = -1;
if(floppyxfer(dp, Fread, dp->ccache, cyl * nn, nn) != nn)
errors("floppy read err");
dp->ccyl = cyl;
}
memmove(aa+rv, dp->ccache + (sec-1)*dp->t->bytes, len);
.
279c
long rv, nn, len, cyl;
int sec;
.
274a
/*
* the floppy is so slow, we always read a cylinder
* at a time and cache the extra bytes.
*/
.
200a
/*
* allocate cylinder caches that don't cross 64k boundaries
*/
for(dp = floppy.d; dp < &floppy.d[conf.nfloppy]; dp++){
do {
dp->ccache = ialloc(dp->t->cap, 1);
} while(k64(dp->ccache) != k64(dp->ccache+dp->t->cap));
dp->ccyl = -1;
}
.
193c
for(dp = floppy.d; dp < &floppy.d[conf.nfloppy]; dp++){
.
190a
* allocate the drive storage
*/
floppy.d = ialloc(conf.nfloppy*sizeof(Drive), 0);
/*
.
175a
#define k64(x) (((ulong)(x))>>16)
.
135c
Drive *d; /* the floppy drives */
.
125a
uchar *ccache; /* cylinder cache (always read a whole cyl) */
int ccyl; /* number of cached cylinder */
.
32,33d
## diffname pc/devfloppy.c 1991/0810
## diff -e /n/bootesdump/1991/0809/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0810/sys/src/9/safari/devfloppy.c
214,215c
n = 512 * 18 * 2; /* MF2HD cylinder size */
dp->ccache = ialloc(n, 1);
} while(k64(dp->ccache) != k64(dp->ccache+n));
.
182a
int n;
.
## diffname pc/devfloppy.c 1991/0811
## diff -e /n/bootesdump/1991/0810/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0811/sys/src/9/safari/devfloppy.c
307c
return devdirread(c, a, n, floppydir, conf.nfloppy*NFDIR, devgen);
.
259c
return devopen(c, omode, floppydir, conf.nfloppy*NFDIR, devgen);
.
253c
devstat(c, dp, floppydir, conf.nfloppy*NFDIR, devgen);
.
247c
return devwalk(c, name, floppydir, conf.nfloppy*NFDIR, devgen);
.
204c
floppydir[NFDIR*dp->dev].length = dp->t->cap;
.
175c
#define NFDIR 2 /* directory entries/drive */
.
## diffname pc/devfloppy.c 1991/0823
## diff -e /n/bootesdump/1991/0811/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0823/sys/src/9/safari/devfloppy.c
800c
/*print("floppy intr\n");/**/
.
736c
/*print("tcyl %d, thead %d, tsec %d, addr %lux, n %d\n",
.
372,374d
340,348d
166,173c
"fd0disk", {Qdata + 0}, 0, 0600,
"fd1disk", {Qdata + 1}, 0, 0600,
"fd2disk", {Qdata + 2}, 0, 0600,
"fd3disk", {Qdata + 3}, 0, 0600,
.
48d
34,39d
## diffname pc/devfloppy.c 1991/0831
## diff -e /n/bootesdump/1991/0823/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0831/sys/src/9/safari/devfloppy.c
345a
floppychanged(dp);
dp->ccyl = -1;
.
301a
floppychanged(dp);
.
283a
* look for a floppy change
*/
void
floppychange(Drive *dp)
{
if((inb(Fchanged) & Fchange) == 0)
return;
}
/*
.
31a
Fchanged= 0x3F7, /* disk changed register */
Fchange= 0x80, /* disk has changed */
.
29c
Fwrite= 0x45, /* write cmd */
.
## diffname pc/devfloppy.c 1991/0902
## diff -e /n/bootesdump/1991/0831/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0902/sys/src/9/safari/devfloppy.c
290c
floppychanged(Drive *dp)
.
## diffname pc/devfloppy.c 1991/0906
## diff -e /n/bootesdump/1991/0902/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0906/sys/src/9/safari/devfloppy.c
732c
dp->tcyl, dp->thead, dp->tsec, a, n);/**/
.
730a
.
706,707d
703d
## diffname pc/devfloppy.c 1991/0913
## diff -e /n/bootesdump/1991/0906/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0913/sys/src/9/safari/devfloppy.c
423,424d
## diffname pc/devfloppy.c 1991/0919
## diff -e /n/bootesdump/1991/0913/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0919/sys/src/9/safari/devfloppy.c
412c
while(waserror())
;
.
## diffname pc/devfloppy.c 1991/0920
## diff -e /n/bootesdump/1991/0919/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0920/sys/src/9/safari/devfloppy.c
295c
print("floppy has changed\n");
.
277,285d
226a
static int kstarted;
if(kstarted == 0){
/*
* watchdog to turn off the motors
*/
kstarted = 1;
kproc("floppy", floppykproc, 0);
}
.
218,221d
165a
"fd3ctl", {Qctl + 3}, 0, 0600,
.
164a
"fd2ctl", {Qctl + 2}, 0, 0600,
.
163a
"fd1ctl", {Qctl + 1}, 0, 0600,
.
162a
"fd0ctl", {Qctl + 0}, 0, 0600,
.
44a
Qctl= (2<<2),
.
8a
/* NEC PD765A (8272A compatible) floppy controller */
.
## diffname pc/devfloppy.c 1991/0921
## diff -e /n/bootesdump/1991/0920/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0921/sys/src/9/safari/devfloppy.c
719,720c
motoron(dp);
.
638a
floppy.motor = 0;
.
636d
432a
* start a floppy drive's motor. set an alarm for .75 second later to
* mark it as started (we get no interrupt to tell us).
*
* assume the caller qlocked the drive.
*
* this also selects the drive for subsequent operations
*/
static void
motoron(Drive *dp)
{
int alreadyon;
alreadyon = floppy.motor & MOTORBIT(dp->dev);
floppy.motor |= MOTORBIT(dp->dev);
driveselect(dp);
if(!alreadyon)
tsleep(&dp->r, return0, 0, 750);
dp->lasttouched = m->ticks;
}
/*
* stop the floppy if it hasn't been used in 5 seconds
*/
static void
motoroff(Drive *dp)
{
floppy.motor &= ~MOTORBIT(dp->dev);
driveselect(dp);
}
/*
.
431a
static void
driveselect(Drive *dp)
{
int cmd;
cmd = floppy.motor | Fintena | Fena | dp->dev;
outb(Fmotor, cmd);
}
.
419c
if((floppy.motor&MOTORBIT(dp->dev))
&& TK2SEC(m->ticks - dp->lasttouched) > 5
.
386,409d
379,384d
204c
floppy.motor |= MOTORBIT(dp->dev);
.
145a
#define MOTORBIT(i) (1<<((i)+4))
.
139a
int motor;
.
113d
## diffname pc/devfloppy.c 1991/0924
## diff -e /n/bootesdump/1991/0921/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0924/sys/src/9/safari/devfloppy.c
807,809c
switch(fl.cmd[0]&~Fmulti){
case Fread:
case Fwrite:
floppyresult();
break;
case Freadid:
floppyresult();
break;
case Fseek:
case Frecal:
default:
floppysense(); /* to clear interrupt */
break;
}
fl.ncmd = 0;
wakeup(&fl.r);
.
804,805c
void
floppyintr(void)
.
797c
qunlock(&fl);
.
791c
print("new offset %d instead of %d\n", offset, off+dp->len);
.
787,789c
/*
* check for correct cylinder
*/
offset = (fl.stat[3]/dp->t->steps) * dp->t->heads + fl.stat[4];
offset = offset*dp->t->sectors + fl.stat[5] - 1;
offset = offset * c2b[fl.stat[6]];
.
779,784c
if((fl.stat[0] & Codemask)!=0 || fl.stat[1] || fl.stat[2]){
if(fl.stat[1] != 0x80){
print("xfer failed %lux %lux %lux\n", fl.stat[0],
fl.stat[1], fl.stat[2]);
print("offset %lud len %d\n", off, dp->len);
dp->confused = 1;
errors("floppy drive lost");
} else
fl.stat[5]++;
.
772,776c
* give bus to DMA, floppyintr() will read result
*/
floppywait();
dmaend(DMAchan);
/*
* check for errors
*/
if(fl.nstat < 7){
print("xfer result failed %lux\n", inb(Pmsr));
fl.confused = 1;
.
769d
766d
754,764c
/* cmd = cmd | (dp->t->heads > 1 ? Fmulti : 0);/**/
fl.ncmd = 0;
fl.cmd[fl.ncmd++] = cmd;
fl.cmd[fl.ncmd++] = (dp->thead<<2) | dp->dev;
fl.cmd[fl.ncmd++] = dp->tcyl * dp->t->steps;
fl.cmd[fl.ncmd++] = dp->thead;
fl.cmd[fl.ncmd++] = dp->tsec;
fl.cmd[fl.ncmd++] = dp->t->bcode;
fl.cmd[fl.ncmd++] = dp->tsec + dp->len/dp->t->bytes - 1;
fl.cmd[fl.ncmd++] = dp->t->gpl;
fl.cmd[fl.ncmd++] = 0xFF;
if(floppycmd() < 0){
spllo();
.
749c
dp->len = dmasetup(DMAchan, a, dp->len, cmd==Fread);
.
744c
dp->tcyl, dp->thead, dp->tsec, a, dp->len);/**/
.
741d
738,739c
if(floppyseek(dp, off) < 0)
.
728,734d
724a
fl.confused = 1;
nexterror();
.
723c
dmaend(DMAchan);
qunlock(&fl);
.
720c
if(off >= dp->t->cap)
return 0;
if(off + n > dp->t->cap)
n = dp->t->cap - off;
qlock(&fl);
.
718a
ulong up;
.
702,711c
dp->cyl = dp->tcyl;
.
692,696c
}
if((fl.stat[0] & (Codemask|Seekend)) != Seekend){
.
685,690c
floppywait();
if(fl.nstat < 2){
fl.confused = 1;
.
682d
673,680c
/* print("seeking tcyl %d, thead %d\n", dp->tcyl, dp->thead); /**/
fl.ncmd = 0;
fl.cmd[fl.ncmd++] = Fseek;
fl.cmd[fl.ncmd++] = (dp->thead<<2) | dp->dev;
fl.cmd[fl.ncmd++] = dp->tcyl * dp->t->steps;
if(floppycmd() < 0){
.
669a
floppyon(dp);
floppypos(dp, off);
.
668c
floppyseek(Drive *dp, long off)
.
666a
/*
* seek to the target cylinder
*
* interrupt, no results
*/
.
655,664d
650,653c
fl.motor = 0;
floppywait();
fl.confused = 0;
/* devp->dsr = 0;
devp->ccr = 0; /**/
.
648c
for(dp = fl.d; dp < &fl.d[conf.nfloppy]; dp++)
.
646c
outb(Pdor, Fintena|Fena);
.
644c
fl.cmd[0] = 0;
outb(Pdor, 0);
.
642d
640c
if(fl.confused){
.
638c
* reset the controller if it's confused
.
612,618c
dp->cyl = fl.stat[1]/dp->t->steps;
if(dp->cyl != 0){
.
604,608c
fl.ncmd = 0;
fl.cmd[fl.ncmd++] = Frecal;
fl.cmd[fl.ncmd++] = dp->dev;
if(floppycmd() < 0)
return -1;
floppywait();
if(fl.nstat < 2){
fl.confused = 1;
return -1;
}
if((fl.stat[0] & (Codemask|Seekend)) != Seekend){
.
598,602c
dp->ccyl = -1;
.
590,596c
int type;
.
581c
tsleep(&fl.r, cmddone, 0, 2000);
.
578,579c
static void
floppywait(void)
.
576c
* wait for a floppy interrupt
.
574a
static int
cmddone(void *a)
{
return fl.ncmd == 0;
}
.
563,571d
557,560c
if(floppyresult() < 2){
print("can't read sense response\n");
fl.confused = 1;
.
551,555c
fl.ncmd = 0;
fl.cmd[fl.ncmd++] = Fsense;
if(floppycmd() < 0)
.
549c
floppysense(void)
.
545,546c
* get the interrupt cause from the floppy.
.
535,541c
end = (ltrack+1)*dp->t->sectors*dp->t->bytes;
if(off+dp->len > end)
dp->len = end - off;
.
532c
* can't read across track boundaries.
.
527c
ltrack = lsec/dp->t->sectors;
dp->tcyl = ltrack/dp->t->heads;
.
524a
int track;
.
522a
int ltrack;
.
517c
* truncate dp->length if it crosses a track boundary
.
511c
fl.nstat = i;
return i;
.
505,509c
for(i = 0; i < sizeof(fl.stat); i++){
for(tries = 0; ; tries++){
if(tries > 1000){
fl.confused = 1;
return -1;
}
s = inb(Pmsr)&(Ffrom|Fready);
if(s == Fready){
fl.nstat = i;
return i;
}
if(s == (Ffrom|Fready))
break;
}
fl.stat[i] = inb(Pdata);
.
502,503c
int i, s;
int tries;
.
500c
floppyresult(void)
.
497c
* get a command result from the floppy
*
* when the controller goes ready waiting for a command
* (instead of sending results), we're done
*
.
493c
return 0;
.
480,491c
for(i = 0; i < fl.ncmd; i++){
for(tries = 0; ; tries++){
if(tries > 1000){
print("cmd %ux can't be sent (%d %ux)\n", fl.cmd[0], i, inb(Pmsr));
fl.confused = 1;
return -1;
}
if((inb(Pmsr)&(Ffrom|Fready)) == Fready)
break;
}
outb(Pdata, fl.cmd[i]);
.
478d
476a
int i;
.
475c
floppycmd(void)
.
472c
* send a command to the floppy
.
451,468c
floppyon(dp);
floppyoff(dp);
.
448,449c
static void
floppyeject(Drive *dp)
.
446c
* eject disk ( unknown on safari )
.
441,442c
fl.motor &= ~MOTORBIT(dp->dev);
outb(Pdor, fl.motor | Fintena | Fena | dp->dev);
.
439c
floppyoff(Drive *dp)
.
431a
/* get drive to a known cylinder */
if(dp->confused)
for(tries = 0; tries < 4; tries++)
if(floppyrecal(dp) >= 0)
break;
.
427,429c
if(fl.confused)
floppyrevive();
/* start motor and select drive */
alreadyon = fl.motor & MOTORBIT(dp->dev);
fl.motor |= MOTORBIT(dp->dev);
outb(Pdor, fl.motor | Fintena | Fena | dp->dev);
.
425a
int tries;
.
423c
floppyon(Drive *dp)
.
415,420c
* start a floppy drive's motor.
.
405,413d
399,401c
tsleep(&fl.kr, return0, 0, 5*100);
.
395c
floppyoff(dp);
.
390,391c
i = inb(Pdir) & 0x80;
if(i != last)
print("fromn %d to %d\n", last, i);
last = i;
for(dp = fl.d; dp < &fl.d[conf.nfloppy]; dp++){
if((fl.motor&MOTORBIT(dp->dev))
.
385c
int i;
static int last;
.
377a
.
374a
case Qctl:
if(SNCMP(aa, "eject") == 0){
floppyeject(dp);
} else if(SNCMP(aa, "seek") == 0){
aa += 5;
floppyseek(dp, strtoul(aa, 0, 0));
} else if(SNCMP(aa, "den") == 0){
aa += 4;
i = strtoul(aa, 0, 0);
USED(i);
/* devp->dsr = i;
devp->ccr = i;/**/
} else if(SNCMP(aa, "reset") == 0){
floppyon(dp);
}
break;
.
370c
floppypos(dp, c->offset+rv);
if(dp->tcyl == dp->ccyl)
dp->ccyl = -1;
i = floppyxfer(dp, Fwrite, aa+rv, c->offset+rv,
n-rv);
.
367,368c
if(c->offset % dp->t->bytes)
errors("bad offset");
if(n % dp->t->bytes)
errors("bad len");
.
364c
dp = &fl.d[c->qid.path & ~Qmask];
.
361c
char *aa = a;
int dev;
.
355a
#define SNCMP(a, b) strncmp(a, b, sizeof(b)-1)
.
352a
.
349a
case Qctl:
break;
.
347c
memmove(aa+rv, dp->cache + (sec-1)*dp->t->bytes, len);
.
345a
dp->chead = head;
.
344a
}
.
343c
i = floppyxfer(dp, Fread, dp->cache,
(cyl*dp->t->heads+head)*nn, nn);
if(i != nn){
if(i == 0)
break;
.
341c
if(dp->ccyl!=cyl || dp->chead!=head){
.
339c
* read the track
.
336c
sec = dp->tsec;
.
334a
head = dp->thead;
.
330c
* truncate xfer at track boundary
.
327c
aa = a;
nn = dp->t->tsize;
.
322d
319c
dp = &fl.d[c->qid.path & ~Qmask];
.
311,313c
long rv, i;
int nn, sec, head, cyl;
long len;
long noff;
uchar *aa;
.
291,306d
214,221c
fl.confused = 1;
.
212c
* first operation will recalibrate
.
208c
dp->cache = (uchar*)ialloc(dp->t->tsize, 1);
dp->ccyl = -1;
.
206d
202,203c
fl.motor = 0;
delay(10);
outb(Pdor, fl.motor | Fintena | Fena);
delay(10);
/*
* init drives
*/
for(dp = fl.d; dp < &fl.d[conf.nfloppy]; dp++){
dp->dev = dp - fl.d;
.
197c
fl.d = ialloc(conf.nfloppy*sizeof(Drive), 0);
.
191a
t->tsize = t->bytes * t->sectors;
.
184a
ulong p;
long l;
.
178d
164c
static int cmddone(void*);
void Xdelay(int);
.
162c
static long floppyseek(Drive*, long);
static int floppysense(void);
static void floppywait(void);
.
160a
static int floppyresult(void);
.
158,159d
154,156c
static void floppyon(Drive*);
static void floppyoff(Drive*);
.
151,152c
static int floppycmd(void);
static void floppyeject(Drive*);
.
144c
Controller fl;
.
139,140c
int motor; /* bit mask of spinning disks */
.
135,137c
uchar cmd[14]; /* command */
int ncmd; /* # command bytes */
uchar stat[14]; /* command status */
int nstat; /* # status bytes */
int confused; /* controler needs to be reset */
.
128c
* controller for 4 floppys
.
123,124c
Rendez r; /* waiting here for motor to spin up */
.
121c
uchar *cache; /* track cache */
int ccyl;
int chead;
.
114c
int confused; /* needs to be recalibrated */
.
75c
{ "MF1DD", 512, 9, 2, 1, 80, 0x1B, 0x54, },
{ "MF4HD", 1024, 18, 2, 1, 80, 0x1B, 0x54, },
.
70a
long tsize; /* track size in bytes */
.
48a
DMAchan= 2, /* floppy dma channel */
.
37,38d
34,35c
/* digital input register */
Pdir= 0x3F7, /* disk changed port */
Fchange= 0x80, /* disk has changed */
.
26,32c
/* data register */
Pdata= 0x3f5,
Frecal= 0x07, /* recalibrate cmd */
Fseek= 0x0f, /* seek cmd */
Fsense= 0x08, /* sense cmd */
Fread= 0x66, /* read cmd */
Freadid= 0x4a, /* read track id */
Fspec= 0x03, /* set hold times */
Fwrite= 0x45, /* write cmd */
Fmulti= 0x80, /* or'd with Fread or Fwrite for multi-head */
Fdumpreg= 0x0e, /* dump internal registers */
.
21,24c
/* main status register */
Pmsr= 0x3f4,
Fready= 0x80, /* ready to be touched */
Ffrom= 0x40, /* data from controller */
Fbusy= 0x10, /* operation not over */
.
17,19c
/* digital output register */
Pdor= 0x3f2,
Fintena= 0x8, /* enable floppy interrupt */
Fena= 0x4, /* 0 == reset controller */
.
14a
/* bits in the registers */
.
9c
/* Intel 82077A (8272A compatible) floppy controller */
.
## diffname pc/devfloppy.c 1991/0925
## diff -e /n/bootesdump/1991/0924/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0925/sys/src/9/safari/devfloppy.c
816,817c
static void
floppyintr(Ureg *ur)
.
809,812d
803a
print(" %d %d %d\n", fl.stat[3], fl.stat[4], fl.stat[5]);
.
786,793c
print("xfer failed %lux %lux %lux\n", fl.stat[0],
fl.stat[1], fl.stat[2]);
print("offset %lud len %d\n", off, dp->len);
dp->confused = 1;
errors("floppy drive lost");
.
754c
cmd = cmd | (dp->t->heads > 1 ? Fmulti : 0);
.
742c
.
726,735d
686d
673,674c
outb(Pdsr, 0);
.
490a
dp->vers++;
.
481a
fl.selected = dp;
.
471a
fl.selected = dp;
.
443c
tsleep(&fl.kr, return0, 0, 1000);
.
440c
qunlock(&fl);
.
437c
&& canqlock(&fl)){
.
430,433d
424,425d
411a
qunlock(&fl);
.
409a
fl.confused = 1;
.
400,408d
397a
qlock(&fl);
.
395a
qunlock(&fl);
poperror();
.
383,386c
islegal(c, n, dp);
qlock(&fl);
if(waserror()){
qunlock(&fl);
nexterror();
}
floppyon(dp);
changed(c, dp);
.
380d
358a
qunlock(&fl);
poperror();
.
330a
qlock(&fl);
if(waserror()){
qunlock(&fl);
nexterror();
}
floppyon(dp);
changed(c, dp);
.
325,328c
islegal(c, n, dp);
.
322d
306a
static void
islegal(Chan *c, long n, Drive *dp)
{
if(c->offset % dp->t->bytes)
errors("bad offset");
if(n % dp->t->bytes)
errors("bad len");
}
/*
* check if the floppy has been replaced under foot
*
* a seek and a read clears the condition. this was determined experimentally,
* there has to be a better way.
*/
static void
changed(Chan *c, Drive *dp)
{
ulong old;
if(inb(Pdir)&Fchange)
dp->vers++;
old = c->qid.vers;
c->qid.vers = dp->vers;
if(old && old!=dp->vers){
dp->ccyl = -1;
if(dp->cyl)
floppyxfer(dp, Fread, dp->cache, 0, dp->t->tsize);
else
floppyxfer(dp, Fread, dp->cache, dp->t->heads*dp->t->tsize, dp->t->tsize);
errors("disk changed");
}
}
.
281c
devopen(c, omode, floppydir, conf.nfloppy*NFDIR, devgen);
.
237a
setvec(Floppyvec, floppyintr);
.
231a
dp->vers = 1;
.
212a
fl.selected = fl.d;
.
164a
static void floppyintr(Ureg*);
.
145a
Drive *selected;
.
124a
int vers;
.
117,118d
42c
Pdir= 0x3F7, /* disk changed port (read only) */
Pdsr= 0x3F7, /* data rate select port (write only) */
.
## diffname pc/devfloppy.c 1991/0927
## diff -e /n/bootesdump/1991/0925/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/0927/sys/src/9/safari/devfloppy.c
454a
} else if(SNCMP(aa, "v") == 0){
vgaset(aa+1);
.
422a
extern void vgaset(char*);
.
## diffname pc/devfloppy.c 1991/1001
## diff -e /n/bootesdump/1991/0927/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/1001/sys/src/9/safari/devfloppy.c
795c
fl.cmd[fl.ncmd++] = dp->t->sectors;
.
## diffname pc/devfloppy.c 1991/1003
## diff -e /n/bootesdump/1991/1001/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/1003/sys/src/9/safari/devfloppy.c
343a
old = c->qid.vers;
c->qid.vers = dp->vers;
if(old && old!=dp->vers)
errors("disk changed");
.
342d
334,336d
332c
if(inb(Pdir)&Fchange){
.
## diffname pc/devfloppy.c 1991/1005
## diff -e /n/bootesdump/1991/1003/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/1005/sys/src/9/safari/devfloppy.c
636c
/*print("can't read sense response\n");/**/
.
## diffname pc/devfloppy.c 1991/1006
## diff -e /n/bootesdump/1991/1005/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/1006/sys/src/9/safari/devfloppy.c
833,834d
758a
floppythrice(Drive *dp, int cmd, void *a, long off, long n)
{
int tries;
long rv;
for(tries = 0; ; tries++){
if(waserror()){
if(strcmp(u->error, errstrtab[Eintr])==0 || tries > 3)
nexterror();
} else {
rv = floppyxfer(dp, cmd, a, off, n);
poperror();
return rv;
}
}
}
static long
.
757a
/*
* since floppies are so flakey, try 3 times before giving up
*/
.
456,457d
444a
if(i == 0)
error(Eio);
.
443c
if(i < 0)
.
441c
i = floppythrice(dp, Fwrite, aa+rv, c->offset+rv,
.
423d
390c
i = floppythrice(dp, Fread, dp->cache,
.
177a
static long floppythrice(Drive*, int, void*, long, long);
.
## diffname pc/devfloppy.c 1991/1029
## diff -e /n/bootesdump/1991/1006/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/1029/sys/src/9/safari/devfloppy.c
457a
} else if(SNCMP(aa, "fast") == 0){
cpuspeed(1);
} else if(SNCMP(aa, "slow") == 0){
cpuspeed(0);
.
## diffname pc/devfloppy.c 1991/1112
## diff -e /n/bootesdump/1991/1029/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/1112/sys/src/9/safari/devfloppy.c
183,190c
"fd0disk", {Qdata + 0}, 0, 0666,
"fd0ctl", {Qctl + 0}, 0, 0666,
"fd1disk", {Qdata + 1}, 0, 0666,
"fd1ctl", {Qctl + 1}, 0, 0666,
"fd2disk", {Qdata + 2}, 0, 0666,
"fd2ctl", {Qctl + 2}, 0, 0666,
"fd3disk", {Qdata + 3}, 0, 0666,
"fd3ctl", {Qctl + 3}, 0, 0666,
.
## diffname pc/devfloppy.c 1991/1203
## diff -e /n/bootesdump/1991/1112/sys/src/9/safari/devfloppy.c /n/bootesdump/1991/1203/sys/src/9/safari/devfloppy.c
287c
return devopen(c, omode, floppydir, conf.nfloppy*NFDIR, devgen);
.
## diffname pc/devfloppy.c 1992/0111
## diff -e /n/bootesdump/1991/1203/sys/src/9/safari/devfloppy.c /n/bootesdump/1992/0111/sys/src/9/safari/devfloppy.c
773c
if(strcmp(u->error, Eintr)==0 || tries > 3)
.
7c
#include "../port/error.h"
.
## diffname pc/devfloppy.c 1992/0114
## diff -e /n/bootesdump/1992/0111/sys/src/9/safari/devfloppy.c /n/bootesdump/1992/0114/sys/src/9/safari/devfloppy.c
859c
error(Eio);
.
848c
error(Eio);
.
841c
error(Eio);
.
826c
error(Eio);
.
799c
error(Eio);
.
396c
error(Eio);
.
344c
error(Eio);
.
319c
error(Ebadarg);
.
317c
error(Ebadarg);
.
## diffname pc/devfloppy.c 1992/0321
## diff -e /n/bootesdump/1992/0114/sys/src/9/safari/devfloppy.c /n/bootesdump/1992/0321/sys/src/9/safari/devfloppy.c
2c
#include "../port/lib.h"
.
## diffname pc/devfloppy.c 1992/0625
## diff -e /n/bootesdump/1992/0321/sys/src/9/safari/devfloppy.c /n/bootesdump/1992/0625/sys/src/9/safari/devfloppy.c
234c
dp->cache = (uchar*)xspanalloc(dp->t->tsize, BY2PG, 0);
.
215c
fl.d = xalloc(conf.nfloppy*sizeof(Drive));
.
## diffname pc/devfloppy.c 1992/0711
## diff -e /n/bootesdump/1992/0625/sys/src/9/safari/devfloppy.c /n/bootesdump/1992/0711/sys/src/9/safari/devfloppy.c
868a
USED(ur);
.
787d
668,669d
649a
USED(a);
.
611,612d
476a
USED(a);
.
423d
354d
309a
USED(c, dp);
.
303a
USED(c);
.
298a
USED(c);
.
292a
USED(c, name, omode, perm);
.
199,201d
## diffname pc/devfloppy.c 1992/0829
## diff -e /n/bootesdump/1992/0808/sys/src/9/safari/devfloppy.c /n/bootesdump/1992/0829/sys/src/9/pc/devfloppy.c
835c
/* print("xfer result failed %lux\n", inb(Pmsr));/**/
.
821c
/* print("xfer cmd failed\n");/**/
.
## diffname pc/devfloppy.c 1992/0901
## diff -e /n/bootesdump/1992/0829/sys/src/9/pc/devfloppy.c /n/bootesdump/1992/0901/sys/src/9/pc/devfloppy.c
842c
DPRINT("offset %lud len %d\n", off, dp->len);
.
840c
DPRINT("xfer failed %lux %lux %lux\n", fl.stat[0],
.
835c
DPRINT("xfer result failed %lux\n", inb(Pmsr));
.
821c
DPRINT("xfer cmd failed\n");
.
797,798c
DPRINT("tcyl %d, thead %d, tsec %d, addr %lux, n %d\n",
dp->tcyl, dp->thead, dp->tsec, a, dp->len);
.
750c
DPRINT("seek failed\n");
.
741c
DPRINT("seek cmd failed\n");
.
735c
DPRINT("seeking tcyl %d, thead %d\n", dp->tcyl, dp->thead);
.
685c
DPRINT("recalibrate went to wrong cylinder %d\n", dp->cyl);
.
638c
DPRINT("can't read sense response\n");
.
555c
DPRINT("cmd %ux can't be sent (%d %ux)\n", fl.cmd[0], i, inb(Pmsr));
.
14a
#define DPRINT if(0)print
.
## diffname pc/devfloppy.c 1992/1002
## diff -e /n/bootesdump/1992/0901/sys/src/9/pc/devfloppy.c /n/bootesdump/1992/1002/sys/src/9/pc/devfloppy.c
762c
* since floppies are so flakey, automaticly retry failed attempts.
* every 3 tries switch to a different density
.
342c
floppythrice(dp, Fread, dp->cache, dp->t->heads*dp->t->tsize, dp->t->tsize);
.
340c
floppythrice(dp, Fread, dp->cache, 0, dp->t->tsize);
.
326c
* check if the floppy has been replaced under foot. cause a read error if it has.
.
86,91c
[0] { "MF2HD", 512, 18, 2, 1, 80, 0x1B, 0x54, 1, },
[1] { "MF1DD", 512, 9, 2, 1, 80, 0x1B, 0x54, 2, },
[2] { "MF4HD", 1024, 18, 2, 1, 80, 0x1B, 0x54, 0, },
[3] { "F2HD", 512, 15, 2, 1, 80, 0x2A, 0x50, 4, },
[4] { "F2DD", 512, 8, 2, 2, 40, 0x2A, 0x50, 5, },
[5] { "F1DD", 512, 8, 1, 2, 40, 0x2A, 0x50, 3, },
.
74a
int ring; /* ring of compatible floppy types */
.
## diffname pc/devfloppy.c 1992/1003
## diff -e /n/bootesdump/1992/1002/sys/src/9/pc/devfloppy.c /n/bootesdump/1992/1003/sys/src/9/pc/devfloppy.c
857a
DPRINT("xfer ends on wrong cyl\n");
.
854c
offset = ((fl.stat[3]+dp->t->steps-1)/dp->t->steps) * dp->t->heads + fl.stat[4];
.
775a
/* walk through the compatible types */
if(tries == 3){
if(++dp->t == &floppytype[NTYPES])
dp->t = floppytype;
floppydir[NFDIR*dp->dev].length = dp->t->cap;
if(dp->t == start)
nexterror();
tries = 0;
floppyon(dp);
}
.
774c
if(cmd != Fread || strcmp(u->error, Eintr)==0)
.
771a
start = dp->t;
.
770a
Type *start;
.
758,759c
dp->arm = dp->tcyl*dp->t->steps;
return dp->tcyl;
.
748a
DPRINT("seek cmd confused\n");
.
735,736c
if(dp->arm*dp->t->steps == dp->tcyl)
return dp->tcyl;
.
722a
fl.rate = 0;
.
686,688c
dp->arm = fl.stat[1];
if(dp->arm != 0){
DPRINT("recalibrate went to wrong cylinder %d\n", dp->arm);
.
514a
/* set transfer rate */
if(fl.rate != dp->t->rate){
fl.rate = dp->t->rate;
outb(Pdsr, fl.rate);
}
.
399c
len = 0;
continue;
.
387a
nn = dp->t->tsize;
.
369d
348a
}
.
347c
if(old && old!=dp->vers){
.
343c
floppythrice(dp, Fread, dp->cache, dp->t->heads*dp->t->tsize,
dp->t->tsize);
.
340c
if(dp->arm)
.
233c
dp->arm = -1; /* because we don't know */
.
149a
int rate; /* current rate selected */
.
125c
int arm; /* current arm position */
.
87,92c
{ "3½HD", 512, 18, 2, 1, 80, 0x1B, 0x54, 0, },
{ "3½DD", 512, 9, 2, 1, 80, 0x1B, 0x54, 2, },
{ "5¼HD", 512, 15, 2, 1, 80, 0x2A, 0x50, 0, },
{ "5¼DD2", 512, 9, 2, 2, 40, 0x2A, 0x50, 2, },
{ "5¼DD1", 512, 9, 2, 2, 40, 0x2A, 0x50, 1, },
{ "3½ED", 1024, 18, 2, 1, 80, 0x1B, 0x54, 3, },
.
75c
int rate; /* rate code */
.
63c
* floppy types (all MFM encoding)
.
## diffname pc/devfloppy.c 1992/1006
## diff -e /n/bootesdump/1992/1003/sys/src/9/pc/devfloppy.c /n/bootesdump/1992/1006/sys/src/9/pc/devfloppy.c
899,901c
case Fformat:
.
891a
/*
* format a track
*/
static int
floppyformat(Chan *c, Drive *dp, int track, char filler)
{
int cyl, h, sec;
uchar *buf, *bp;
Type *t;
t = dp->t;
cyl = track/t->heads;
h = track % t->heads;
if(track >= t->tracks * t->heads)
return 0;
buf = smalloc(t->sectors*4);
qlock(&fl);
if(waserror()){
qunlock(&fl);
free(buf);
nexterror();
}
floppyon(dp);
changed(c, dp);
if(floppyseek(dp, track*t->tsize) < 0)
error(Eio);
/*
* set up the dma (dp->len may be trimmed)
*/
bp = buf;
for(sec = 1; sec <= t->sectors; sec++){
*bp++ = cyl;
*bp++ = h;
*bp++ = sec;
*bp++ = t->bcode;
}
dmasetup(DMAchan, buf, bp-buf, 0);
/*
* start operation
*/
fl.ncmd = 0;
fl.cmd[fl.ncmd++] = Fformat;
fl.cmd[fl.ncmd++] = (h<<2) | dp->dev;
fl.cmd[fl.ncmd++] = t->bcode;
fl.cmd[fl.ncmd++] = t->sectors;
fl.cmd[fl.ncmd++] = t->fgpl;
fl.cmd[fl.ncmd++] = filler;
if(floppycmd() < 0){
DPRINT("xfer cmd failed\n");
error(Eio);
}
/*
* give bus to DMA, floppyintr() will read result
*/
floppywait();
dmaend(DMAchan);
/*
* check for errors
*/
if(fl.nstat < 7){
DPRINT("format result failed %lux\n", inb(Pmsr));
fl.confused = 1;
error(Eio);
}
if((fl.stat[0]&Codemask)!=0 || fl.stat[1] || fl.stat[2]){
DPRINT("format failed %lux %lux %lux\n",
fl.stat[0], fl.stat[1], fl.stat[2]);
dp->confused = 1;
error(Eio);
}
qunlock(&fl);
free(buf);
return 1;
}
.
879c
offset = fl.stat[3] * dp->t->heads + fl.stat[4];
.
841c
fl.cmd[fl.ncmd++] = dp->tcyl;
.
793,794c
while(++dp->t){
if(dp->t == &floppytype[NTYPES])
dp->t = floppytype;
if(dp->dt == Tnone)
break;
if(dp->dt == dp->t->dt)
break;
}
.
770c
dp->cyl = dp->tcyl;
.
746c
if(dp->cyl == dp->tcyl)
.
696,698c
dp->cyl = fl.stat[1];
if(dp->cyl != 0){
DPRINT("recalibrate went to wrong cylinder %d\n", dp->cyl);
.
464,467c
} else if(SNCMP(ctlmsg, "format") == 0){
if(getfields(ctlmsg, f, 3, ' ') != 3)
error(Ebadarg);
rv = n*floppyformat(c, dp, atoi(f[1]), *f[2]);
.
461c
} else if(SNCMP(ctlmsg, "reset") == 0){
.
459c
if(n >= sizeof(ctlmsg))
n = sizeof(ctlmsg) - 1;
memmove(ctlmsg, aa, n);
ctlmsg[n] = 0;
if(SNCMP(ctlmsg, "eject") == 0){
.
447,448c
i = floppythrice(dp, Fwrite, aa+rv, c->offset+rv, n-rv);
.
429a
char *f[3];
char ctlmsg[64];
.
340,341c
dp->confused = 1;
floppyon(dp);
if(dp->cyl)
.
338a
setdef(dp);
.
240a
* read nvram for types of floppies 0 & 1
*/
equip = nvramread(0x10);
if(conf.nfloppy > 0){
fl.d[0].dt = (equip >> 4) & 0xf;
setdef(&fl.d[0]);
}
if(conf.nfloppy > 1){
fl.d[1].dt = equip & 0xf;
setdef(&fl.d[1]);
}
/*
.
232,234c
dp->dt = T1440kb;
setdef(dp);
dp->cyl = -1; /* because we don't know */
.
202a
uchar equip;
.
197a
/*
* set floppy drive to its default type
*/
static void
setdef(Drive *dp)
{
Type *t;
for(t = floppytype; t < &floppytype[NTYPES]; t++)
if(dp->dt == t->dt){
dp->t = t;
floppydir[NFDIR*dp->dev].length = dp->t->cap;
break;
}
}
.
181a
static int floppyformat(Chan*, Drive*, int, char);
.
125c
int cyl; /* current arm position */
.
121c
Type *t; /* floppy type */
int dt; /* drive type */
.
87,92c
{ "3½HD", T1440kb, 512, 18, 2, 1, 80, 0x1B, 0x54, 0, },
{ "3½DD", T1440kb, 512, 9, 2, 1, 80, 0x1B, 0x54, 2, },
{ "3½DD", T720kb, 512, 9, 2, 1, 80, 0x1B, 0x54, 2, },
{ "5¼HD", T1200kb, 512, 15, 2, 1, 80, 0x2A, 0x50, 0, },
{ "5¼DD", T1200kb, 512, 9, 2, 2, 40, 0x2A, 0x50, 1, },
{ "5¼DD", T360kb, 512, 9, 2, 1, 40, 0x2A, 0x50, 2, },
.
67a
int dt; /* compatible drive type */
.
62a
* types of drive (from PC equipment byte)
*/
enum
{
Tnone= 0,
T360kb= 1,
T1200kb= 2,
T720kb= 3,
T1440kb= 4,
};
/*
.
39a
Fformat= 0x4d, /* format cmd */
.
## diffname pc/devfloppy.c 1992/1007
## diff -e /n/bootesdump/1992/1006/sys/src/9/pc/devfloppy.c /n/bootesdump/1992/1007/sys/src/9/pc/devfloppy.c
1027a
poperror();
.
1026d
974,977c
if(!waserror()){
floppyon(dp);
poperror();
}
floppyseek(dp, track*t->tsize);
dp->cyl = cyl;
dp->confused = 0;
.
970d
967,968d
965a
setdef(dp);
.
955c
floppyformat(Drive *dp, ulong track, ulong filler)
.
521a
poperror();
.
520c
rv = n*floppyformat(dp, strtoul(f[1], 0, 0), strtoul(f[2], 0, 0));
.
507a
if(waserror()){
qunlock(&fl);
nexterror();
}
.
463c
return readstr(offset, a, n, dp->t->name);
.
197c
static int floppyformat(Drive*, ulong, ulong);
.
## diffname pc/devfloppy.c 1992/1009
## diff -e /n/bootesdump/1992/1007/sys/src/9/pc/devfloppy.c /n/bootesdump/1992/1009/sys/src/9/pc/devfloppy.c
1034d
1026,1031d
1018,1024c
/*
* seek to track, ignore errors
*/
if(!waserror()){
floppyon(dp);
poperror();
}
floppyseek(dp, track*t->tsize);
dp->cyl = cyl;
dp->confused = 0;
/*
* set up the dma (dp->len may be trimmed)
*/
bp = buf;
for(sec = 1; sec <= t->sectors; sec++){
*bp++ = cyl;
*bp++ = h;
*bp++ = sec;
*bp++ = t->bcode;
}
dmasetup(DMAchan, buf, bp-buf, 0);
/*
* start operation
*/
fl.ncmd = 0;
fl.cmd[fl.ncmd++] = Fformat;
fl.cmd[fl.ncmd++] = (h<<2) | dp->dev;
fl.cmd[fl.ncmd++] = t->bcode;
fl.cmd[fl.ncmd++] = t->sectors;
fl.cmd[fl.ncmd++] = t->fgpl;
fl.cmd[fl.ncmd++] = 0x5a;
if(floppycmd() < 0){
DPRINT("xfer cmd failed\n");
error(Eio);
}
/*
* give bus to DMA, floppyintr() will read result
*/
floppywait();
dmaend(DMAchan);
/*
* check for errors
*/
if(fl.nstat < 7){
DPRINT("format result failed %lux\n",inb(Pmsr));
fl.confused = 1;
error(Eio);
}
if((fl.stat[0]&Codemask)!=0 || fl.stat[1]|| fl.stat[2]){
DPRINT("format failed %lux %lux %lux\n",
fl.stat[0], fl.stat[1], fl.stat[2]);
dp->confused = 1;
error(Eio);
}
.
1015,1016c
for(track = 0; track < t->tracks*t->heads; track++){
cyl = track/t->heads;
h = track % t->heads;
.
1013c
* format a track at time
.
1000,1009c
buf = smalloc(t->sectors*4);
if(waserror()){
free(buf);
nexterror();
.
998c
* buffer for per track info
.
995d
988,993c
if(getfields(params, f, 3, ' ') > 1){
for(t = floppytype; t < &floppytype[NTYPES]; t++)
if(strcmp(f[1], t->name)==0 && t->dt==dp->dt){
dp->t = t;
floppydir[NFDIR*dp->dev].length = dp->t->cap;
break;
}
} else {
setdef(dp);
t = dp->t;
.
986c
* set the type
.
966,984d
964a
char *f[3];
.
962a
ulong track;
.
959,960c
static void
floppyformat(Drive *dp, char *params)
.
522,524c
floppyformat(dp, ctlmsg);
.
506a
rv = n;
.
497c
i = floppythrice(dp, Fwrite, aa+rv, offset+rv, n-rv);
.
494c
floppypos(dp, offset+rv);
.
485c
islegal(offset, n, dp);
.
478d
473c
floppywrite(Chan *c, void *a, long n, ulong offset)
.
433c
floppypos(dp, offset+rv);
.
418c
islegal(offset, n, dp);
.
403c
floppyread(Chan *c, void *a, long n, ulong offset)
.
367c
if(offset % dp->t->bytes)
.
365c
islegal(ulong offset, long n, Drive *dp)
.
197c
static void floppyformat(Drive*, char*);
.
7a
#include "devtab.h"
.
## diffname pc/devfloppy.c 1992/1013
## diff -e /n/bootesdump/1992/1009/sys/src/9/pc/devfloppy.c /n/bootesdump/1992/1013/sys/src/9/pc/devfloppy.c
1057a
dp->confused = 1;
.
1040a
poperror();
.
1018a
if(waserror()){
dmaend(DMAchan);
nexterror();
}
.
949a
poperror();
.
921a
poperror();
.
894a
if(waserror()){
dmaend(DMAchan);
nexterror();
}
.
882,884c
/* retry on error 3 times */
while(waserror())
if(tries++ >= 3)
nexterror();
.
875a
int tries = 0;
.
836,872d
832,833c
* read or write to floppy. try up to three times.
.
755a
dp->cyl = -1;
.
497c
i = floppyxfer(dp, Fwrite, aa+rv, offset+rv, n-rv);
.
446c
i = floppyxfer(dp, Fread, dp->cache,
.
400d
398c
if(old && old != dp->vers)
.
395a
.
390,394c
floppyseek(dp, dp->t->heads*dp->t->tsize);
while(waserror()){
while(++dp->t){
if(dp->t == &floppytype[NTYPES])
dp->t = floppytype;
if(dp->dt == dp->t->dt)
break;
}
floppydir[NFDIR*dp->dev].length = dp->t->cap;
if(dp->t == start)
nexterror();
floppyon(dp);
}
floppyxfer(dp, Fread, dp->cache, 0, dp->t->tsize);
poperror();
.
388c
setdef(dp);
start = dp->t;
dp->confused = 1; /* make floppyon recal */
.
385,386c
/*
* if floppy has changed or first time through
*/
if((inb(Pdir)&Fchange) || dp->vers == 0){
.
383a
Type *start;
.
377,378c
* a seek and a read clears the condition. this was determined
* experimentally, there has to be a better way.
*
* if the read fails, cycle through the possible floppy
* density till one works or we've cycled through all
* possibilities.
.
375c
* check if the floppy has been replaced under foot. cause
* an error if it has.
.
199d
## diffname pc/devfloppy.c 1992/1016
## diff -e /n/bootesdump/1992/1013/sys/src/9/pc/devfloppy.c /n/bootesdump/1992/1016/sys/src/9/pc/devfloppy.c
1047c
DPRINT("format: failed %lux %lux %lux\n",
.
1042c
DPRINT("format: confused\n");
.
1029d
1026,1027c
if(floppycmd() < 0)
.
992,995d
981a
/* force a recalibrate to cylinder 0 */
dp->confused = 1;
if(!waserror()){
floppyon(dp);
poperror();
}
.
936c
DPRINT("xfer: ends on wrong cyl\n");
.
922c
DPRINT("xfer: failed %lux %lux %lux\n", fl.stat[0],
.
917c
DPRINT("xfer: confused\n");
.
904d
900,902c
if(floppycmd() < 0)
.
874c
DPRINT("floppyxfer: tcyl %d, thead %d, tsec %d, addr %lux, n %d\n",
.
872a
}
.
871c
if(floppyseek(dp, off) < 0){
DPRINT("xfer: seek failed\n");
dp->confused = 1;
.
868a
}
.
866c
tries = 0;
while(waserror()){
DPRINT("floppyxfer: retrying\n");
.
858c
int tries;
.
842c
DPRINT("seek: failed\n");
.
837c
DPRINT("seek: confused\n");
.
834d
831,832c
if(floppycmd() < 0)
.
826c
DPRINT("seek: tcyl %d, thead %d\n", dp->tcyl, dp->thead);
.
824a
dp->cyl = -1;
.
774c
DPRINT("recalibrate: wrong cylinder %d\n", dp->cyl);
.
768a
DPRINT("recalibrate: failed\n");
.
764a
DPRINT("recalibrate: confused\n");
.
756a
dp->cyl = -1;
.
644c
DPRINT("cmd %ux can't be sent (%d %ux)\n",
fl.cmd[0], i, inb(Pmsr));
.
640a
fl.nstat = 0;
.
542a
} else if(SNCMP(ctlmsg, "debug") == 0){
floppydebug = 1;
.
410a
DPRINT("changed: trying %s\n", dp->t->name);
.
16c
#define DPRINT if(floppydebug)print
int floppydebug;
.
## diffname pc/devfloppy.c 1992/1113
## diff -e /n/bootesdump/1992/1016/sys/src/9/pc/devfloppy.c /n/bootesdump/1992/1113/sys/src/9/pc/devfloppy.c
269c
dp->cache = (uchar*)xspanalloc(dp->t->tsize, BY2PG, 64*1024);
.
## diffname pc/devfloppy.c 1992/1120
## diff -e /n/bootesdump/1992/1113/sys/src/9/pc/devfloppy.c /n/bootesdump/1992/1120/sys/src/9/pc/devfloppy.c
819c
fl.rate = -1;
.
772c
DPRINT("recalibrate: confused %ux\n", inb(Pmsr));
.
648c
if(tries > 10000){
.
## diffname pc/devfloppy.c 1992/1216
## diff -e /n/bootesdump/1992/1120/sys/src/9/pc/devfloppy.c /n/bootesdump/1992/1216/sys/src/9/pc/devfloppy.c
819c
fl.rate = 0;
DPRINT("floppyrevive: msr %ux dir %ux\n", inb(Pmsr), inb(Pdir));
.
805a
DPRINT("floppyrevive: msr %ux dir %ux\n", inb(Pmsr), inb(Pdir));
.
764a
DPRINT("floppyrecal: msr %ux dir %ux\n", inb(Pmsr), inb(Pdir));
.
753a
if(!cmddone(0))
floppyintr(0);
.
411d
408a
floppyon(dp);
.
394a
DPRINT("changed: msr %ux dir %ux\n", inb(Pmsr), inb(Pdir));
.
## diffname pc/devfloppy.c 1992/1217
## diff -e /n/bootesdump/1992/1216/sys/src/9/pc/devfloppy.c /n/bootesdump/1992/1217/sys/src/9/pc/devfloppy.c
893,895d
842d
825c
DPRINT("floppyrevive out\n");
fldump();
.
822a
floppywait();
/* mark all drives in an unknown state */
for(dp = fl.d; dp < &fl.d[conf.nfloppy]; dp++)
dp->confused = 1;
/* set rate to a known value */
.
821d
818,819d
812a
fl.ncmd = 1;
.
810c
DPRINT("floppyrevive in\n");
fldump();
.
768d
754c
tsleep(&fl.r, cmddone, 0, 5000);
.
749c
* Wait for a floppy interrupt. If none occurs in 5 seconds, we
* may have missed one. This only happens on some portables which
* do power management behind our backs. Call the interrupt
* routine to try to clear any conditions.
.
734a
fldump();
.
692,693c
fl.nstat = sizeof(fl.stat);
return fl.nstat;
.
685c
return fl.nstat;
.
678a
DPRINT("floppyresult: %d stats\n", i);
fldump();
.
676a
/* wait for status byte */
.
675a
/* get the result of the operation */
.
649,652c
if(tries > 1000){
DPRINT("cmd %ux can't be sent (%d)\n", fl.cmd[0], i);
fldump();
/* empty fifo, might have been a bad command */
floppyresult();
.
599a
/* clear any pending interrupts */
floppysense();
}
.
597c
if(!alreadyon){
/* wait for drive to spin up */
.
413d
410a
DPRINT("changed: trying %s\n", dp->t->name);
fldump();
.
395c
DPRINT("changed\n");
fldump();
.
383c
* possibilities for this drive.
.
214a
static void
fldump(void)
{
DPRINT("sra %ux srb %ux dor %ux msr %ux dir %ux\n", inb(Psra), inb(Psrb),
inb(Pdor), inb(Pmsr), inb(Pdir));
}
.
21a
/* status registers a & b */
Psra= 0x3f0,
Psrb= 0x3f1,
.
16c
#define DPRINT if(floppydebug)kprint
.
## diffname pc/devfloppy.c 1992/1218
## diff -e /n/bootesdump/1992/1217/sys/src/9/pc/devfloppy.c /n/bootesdump/1992/1218/sys/src/9/pc/devfloppy.c
846a
delay(10);
.
845c
delay(10);
.
784a
fl.confused = 1;
}
.
783c
if(!cmddone(0)){
.
614a
setvec(Floppyvec, floppyintr);
.
280c
dp->cache = (uchar*)xspanalloc(maxtsize, BY2PG, 64*1024);
.
255a
if(maxtsize < t->tsize)
maxtsize = t->tsize;
.
251a
maxtsize = 0;
.
247a
ulong maxtsize;
.
## diffname pc/devfloppy.c 1993/0219
## diff -e /n/bootesdump/1992/1218/sys/src/9/pc/devfloppy.c /n/bootesdump/1993/0219/sys/src/9/pc/devfloppy.c
619d
## diffname pc/devfloppy.c 1993/0410
## diff -e /n/bootesdump/1993/0219/sys/src/9/pc/devfloppy.c /n/bootesdump/1993/0410/sys/src/9/pc/devfloppy.c
112a
{ "ATT3B1", T360kb, 512, 8, 2, 1, 48, 0x2A, 0x50, 2, },
.
## diffname pc/devfloppy.c 1993/0430
## diff -e /n/bootesdump/1993/0410/sys/src/9/pc/devfloppy.c /n/bootesdump/1993/0430/sys/src/9/pc/devfloppy.c
113d
111a
{ "ATT3B1", T1200kb, 512, 8, 2, 2, 48, 0x2A, 0x50, 1, },
.
## diffname pc/devfloppy.c 1993/0915
## diff -e /n/bootesdump/1993/0430/sys/src/9/pc/devfloppy.c /n/fornaxdump/1993/0915/sys/src/brazil/pc/devfloppy.c
479,496c
if(readtrack(dp, cyl, head) < 0)
break;
.
471c
* all xfers come out of the track cache
.
447,448c
long rv;
int sec, head, cyl;
.
442a
static int
readtrack(Drive *dp, int cyl, int head)
{
int i, nn, sofar;
ulong pos;
nn = dp->t->tsize;
if(dp->ccyl==cyl && dp->chead==head)
return nn;
pos = (cyl*dp->t->heads+head) * nn;
for(sofar = 0; sofar < nn; sofar += i){
dp->ccyl = -1;
i = floppyxfer(dp, Fread, dp->cache + sofar, pos + sofar, nn - sofar);
if(i <= 0)
return -1;
}
dp->ccyl = cyl;
dp->chead = head;
return nn;
}
.
## diffname pc/devfloppy.c 1993/1124
## diff -e /n/fornaxdump/1993/0915/sys/src/brazil/pc/devfloppy.c /n/fornaxdump/1993/1124/sys/src/brazil/pc/devfloppy.c
1124c
USED(ur, arg);
.
1122c
floppyintr(Ureg *ur, void *arg)
.
794c
floppyintr(0, 0);
.
307c
setvec(Floppyvec, floppyintr, 0);
.
192c
static void floppyintr(Ureg*, void*);
.
## diffname pc/devfloppy.c 1994/1017
## diff -e /n/fornaxdump/1993/1124/sys/src/brazil/pc/devfloppy.c /n/fornaxdump/1994/1017/sys/src/brazil/pc/devfloppy.c
377,378c
Dirtab *dt;
Dir d;
if(!iseve())
error(Eperm);
if(CHDIR & c->qid.path)
error(Eperm);
convM2D(dp, &d);
d.mode &= 0x666;
dt = &floppydir[2 * (c->qid.path & ~Qmask)];
dt[0].perm = dt[1].perm = d.mode;
.
209,216c
"fd0disk", {Qdata + 0}, 0, 0660,
"fd0ctl", {Qctl + 0}, 0, 0660,
"fd1disk", {Qdata + 1}, 0, 0660,
"fd1ctl", {Qctl + 1}, 0, 0660,
"fd2disk", {Qdata + 2}, 0, 0660,
"fd2ctl", {Qctl + 2}, 0, 0660,
"fd3disk", {Qdata + 3}, 0, 0660,
"fd3ctl", {Qctl + 3}, 0, 0660,
.
## diffname pc/devfloppy.c 1995/0105
## diff -e /n/fornaxdump/1994/1017/sys/src/brazil/pc/devfloppy.c /n/fornaxdump/1995/0105/sys/src/brazil/pc/devfloppy.c
16c
#define DPRINT if(floppydebug)print
.
## diffname pc/devfloppy.c 1995/0108
## diff -e /n/fornaxdump/1995/0105/sys/src/brazil/pc/devfloppy.c /n/fornaxdump/1995/0108/sys/src/brazil/pc/devfloppy.c
589a
}
long
floppybwrite(Chan *c, Block *bp, ulong offset)
{
return devbwrite(c, bp, offset);
.
526a
Block*
floppybread(Chan *c, long n, ulong offset)
{
return devbread(c, n, offset);
}
.
## diffname pc/devfloppy.c 1995/0117
## diff -e /n/fornaxdump/1995/0108/sys/src/brazil/pc/devfloppy.c /n/fornaxdump/1995/0117/sys/src/brazil/pc/devfloppy.c
1045c
if(getfields(params, f, 3, " ") > 1){
.
## diffname pc/devfloppy.c 1995/0218
## diff -e /n/fornaxdump/1995/0117/sys/src/brazil/pc/devfloppy.c /n/fornaxdump/1995/0218/sys/src/brazil/pc/devfloppy.c
1051a
}
if(t >= &floppytype[NTYPES])
error(Ebadarg);
.
1046c
for(t = floppytype; t < &floppytype[NTYPES]; t++){
.
240a
}
.
239c
return;
.
235c
for(t = floppytype; t < &floppytype[NTYPES]; t++){
.
## diffname pc/devfloppy.c 1995/0726
## diff -e /n/fornaxdump/1995/0218/sys/src/brazil/pc/devfloppy.c /n/fornaxdump/1995/0726/sys/src/brazil/pc/devfloppy.c
358d
356c
floppycreate(Chan*, char*, int, ulong)
.
## diffname pc/devfloppy.c 1995/0728
## diff -e /n/fornaxdump/1995/0726/sys/src/brazil/pc/devfloppy.c /n/fornaxdump/1995/0728/sys/src/brazil/pc/devfloppy.c
978c
fl.cmd[fl.ncmd++] = cmd | (dp->t->heads > 1 ? Fmulti : 0);
.
976c
cmd = cmd;
.
953c
if(tries++ > 20)
.
949c
/* retry on error */
.
## diffname pc/devfloppy.c 1995/0818
## diff -e /n/fornaxdump/1995/0728/sys/src/brazil/pc/devfloppy.c /n/fornaxdump/1995/0818/sys/src/brazil/pc/devfloppy.c
1009c
if((fl.stat[0]&Codemask)==Cmdexec && fl.stat[1]==Overrun)
DPRINT("DMA overrun: retry\n");
else
dp->confused = 1;
.
59a
/* status 1 byte */
Overrun= 0x10,
.
58a
Cmdexec= 1<<6,
.
## diffname pc/devfloppy.c 1995/1121
## diff -e /n/fornaxdump/1995/0818/sys/src/brazil/pc/devfloppy.c /n/fornaxdump/1995/1121/sys/src/brazil/pc/devfloppy.c
866c
static void
.
## diffname pc/devfloppy.c 1996/0223
## diff -e /n/fornaxdump/1995/1121/sys/src/brazil/pc/devfloppy.c /n/fornaxdump/1996/0223/sys/src/brazil/pc/devfloppy.c
8d
## diffname pc/devfloppy.c 1996/0315
## diff -e /n/fornaxdump/1996/0223/sys/src/brazil/pc/devfloppy.c /n/fornaxdump/1996/0315/sys/src/brazil/pc/devfloppy.c
1051c
if(parsefields(params, f, 3, " ") > 1){
.
## diffname pc/devfloppy.c 1997/0327
## diff -e /n/fornaxdump/1996/0315/sys/src/brazil/pc/devfloppy.c /n/emeliedump/1997/0327/sys/src/brazil/pc/devfloppy.c
1170a
Dev floppydevtab = {
floppyreset,
devinit,
floppyattach,
devclone,
floppywalk,
floppystat,
floppyopen,
devcreate,
floppyclose,
floppyread,
devbread,
floppywrite,
devbwrite,
devremove,
devwstat,
};
.
1159a
case Fdumpreg:
.
1155c
USED(ur);
.
1153c
floppyintr(Ureg *ur)
.
1124a
/* Poll ready bits and transfer data */
floppyexec((char *)buf, bp-buf, 0);
.
1062c
floppysetdef(dp);
.
1059c
if(t >= &floppytype[nelem(floppytype)])
.
1052c
for(t = floppytype; t < &floppytype[nelem(floppytype)]; t++){
.
1045c
FType *t;
.
1040c
floppyformat(FDrive *dp, char *params)
.
1014c
} else
.
1012c
if((fl.stat[0]&Codemask)==Cmdexec && fl.stat[1]==Overrun){
.
992a
/* Poll ready bits and transfer data */
floppyexec((char*)a, dp->len, cmd==Fread);
.
979d
957a
DPRINT("floppyxfer: retrying\n");
/*floppyon(dp);*/
.
955d
952c
/* retry on error (until it gets ridiculous) */
.
942c
floppyxfer(FDrive *dp, int cmd, void *a, long off, long n)
.
909c
floppyseek(FDrive *dp, long off)
.
891c
for(dp = fl.d; dp < &fl.d[fl.ndrive]; dp++)
.
868c
FDrive *dp;
.
828c
floppyrecal(FDrive *dp)
.
819c
floppyintr(0);
.
761c
floppypos(FDrive *dp, long off)
.
749c
fl.stat[i] = inb(Pfdata);
.
747a
if(tries > 1000){
DPRINT("floppyresult: %d stats\n", i);
fldump();
fl.confused = 1;
return -1;
}
microdelay(8); /* for machine independence */
.
735,740d
713c
outb(Pfdata, fl.cmd[i]);
.
710,711c
microdelay(8); /* for machine independence */
.
701a
if((inb(Pmsr)&(Ffrom|Fready)) == Fready)
break;
.
680,690d
676d
672c
floppyoff(FDrive *dp)
.
633c
floppyon(FDrive *dp)
.
616c
for(dp = fl.d; dp < &fl.d[fl.ndrive]; dp++){
.
610c
FDrive *dp;
.
601,606d
590c
} else
error(Ebadctl);
.
540c
FDrive *dp;
.
537c
static long
.
530,535d
487c
return devdirread(c, a, n, floppydir, fl.ndrive*NFDIR, devgen);
.
480c
FDrive *dp;
.
477c
static long
.
457c
readtrack(FDrive *dp, int cyl, int head)
.
434c
if(dp->t == &floppytype[nelem(floppytype)])
.
427c
floppysetdef(dp);
.
418c
FType *start;
.
415c
changed(Chan *c, FDrive *dp)
.
395c
islegal(ulong offset, long n, FDrive *dp)
.
370,393d
358,364c
static void
.
355c
return devopen(c, omode, floppydir, fl.ndrive*NFDIR, devgen);
.
352c
static Chan*
.
349c
devstat(c, dp, floppydir, fl.ndrive*NFDIR, devgen);
.
346c
static void
.
343c
return devwalk(c, name, floppydir, fl.ndrive*NFDIR, devgen);
.
334,340c
static int
.
319c
static Chan*
.
314,316c
floppysetup1(&fl);
.
311,312d
295,307d
287c
floppysetdef(dp);
.
284c
for(dp = fl.d; dp < &fl.d[fl.ndrive]; dp++){
.
270c
fl.d = xalloc(fl.ndrive*sizeof(FDrive));
.
259c
for(t = floppytype; t < &floppytype[nelem(floppytype)]; t++){
.
253a
floppysetup0(&fl);
.
250,252c
FDrive *dp;
FType *t;
.
247c
static void
.
244d
242c
break;
.
238c
for(t = floppytype; t < &floppytype[nelem(floppytype)]; t++)
.
236c
FType *t;
.
234c
floppysetdef(FDrive *dp)
.
212,219c
"fd0disk", {Qdata + 0}, 0, 0666,
"fd0ctl", {Qctl + 0}, 0, 0666,
"fd1disk", {Qdata + 1}, 0, 0666,
"fd1ctl", {Qctl + 1}, 0, 0666,
"fd2disk", {Qdata + 2}, 0, 0666,
"fd2ctl", {Qctl + 2}, 0, 0666,
"fd3disk", {Qdata + 3}, 0, 0666,
"fd3ctl", {Qctl + 3}, 0, 0666,
.
206,209c
static long floppyxfer(FDrive*, int, void*, long, long);
.
203c
static long floppyseek(FDrive*, long);
.
197,200c
static void floppypos(FDrive*,long);
static int floppyrecal(FDrive*);
.
193,195c
static int cmddone(void*);
static void floppyformat(FDrive*, char*);
.
149,187d
140,147c
FController fl;
.
118d
89,109d
84,87c
FType floppytype[] =
.
71a
#define DPRINT if(floppydebug)iprint
int floppydebug;
.
64c
Qdir= 0,
.
15,62c
enum {
.
11,13c
/* This module expects the following functions to be defined
* elsewhere:
*
* inb()
* outb()
* floppyexec()
* floppyeject()
* floppysetup0()
* floppysetup1()
* dmasetup()
* dmaend()
*
* On DMA systems, floppyexec() should be an empty function;
* on non-DMA systems, dmaend() should be an empty function;
* dmasetup() may enforce maximum transfer sizes.
*/
.
8a
#include "floppy.h"
.
## diffname pc/devfloppy.c 1997/0404
## diff -e /n/emeliedump/1997/0327/sys/src/brazil/pc/devfloppy.c /n/emeliedump/1997/0404/sys/src/brazil/pc/devfloppy.c
933c
if(dmasetup(DMAchan, buf, bp-buf, 0) < 0)
error(Eio);
.
795a
if(dp->len < 0)
error(Eio);
.
145a
dmainit(DMAchan);
.
21a
* dmainit()
.
## diffname pc/devfloppy.c 1997/0408
## diff -e /n/emeliedump/1997/0404/sys/src/brazil/pc/devfloppy.c /n/emeliedump/1997/0408/sys/src/brazil/pc/devfloppy.c
1005a
'f',
"floppy",
.
## diffname pc/devfloppy.c 1997/0910
## diff -e /n/emeliedump/1997/0408/sys/src/brazil/pc/devfloppy.c /n/emeliedump/1997/0910/sys/src/brazil/pc/devfloppy.c
107,114c
"fd0disk", {Qdata + 0}, 0, 0660,
"fd0ctl", {Qctl + 0}, 0, 0660,
"fd1disk", {Qdata + 1}, 0, 0660,
"fd1ctl", {Qctl + 1}, 0, 0660,
"fd2disk", {Qdata + 2}, 0, 0660,
"fd2ctl", {Qctl + 2}, 0, 0660,
"fd3disk", {Qdata + 3}, 0, 0660,
"fd3ctl", {Qctl + 3}, 0, 0660,
.
## diffname pc/devfloppy.c 1998/0120
## diff -e /n/emeliedump/1997/0910/sys/src/brazil/pc/devfloppy.c /n/emeliedump/1998/0120/sys/src/brazil/pc/devfloppy.c
188c
dp->vers = 0;
.
41,42c
#define DPRINT if(floppydebug)print
int floppydebug = 1;
.
## diffname pc/devfloppy.c 1998/0213
## diff -e /n/emeliedump/1998/0120/sys/src/brazil/pc/devfloppy.c /n/emeliedump/1998/0213/sys/src/brazil/pc/devfloppy.c
42c
int floppydebug = 0;
.
## diffname pc/devfloppy.c 1998/0319
## diff -e /n/emeliedump/1998/0213/sys/src/brazil/pc/devfloppy.c /n/emeliedump/1998/0319/sys/src/brazil/pc/devfloppy.c
987d
985c
floppyintr(Ureg *)
.
627d
625c
cmddone(void *)
.
445d
441c
floppykproc(void *)
.
381a
ulong offset = off;
.
376c
floppywrite(Chan *c, void *a, long n, vlong off)
.
328a
ulong offset = off;
.
322c
floppyread(Chan *c, void *a, long n, vlong off)
.
235d
233c
floppyclose(Chan *)
.
## diffname pc/devfloppy.c 1998/0825
## diff -e /n/emeliedump/1998/0319/sys/src/brazil/pc/devfloppy.c /n/emeliedump/1998/0825/sys/src/brazil/pc/devfloppy.c
972c
DPRINT("format: failed %ux %ux %ux\n",
.
838c
DPRINT("offset %lud len %ld\n", off, dp->len);
.
836c
DPRINT("xfer: failed %ux %ux %ux\n", fl.stat[0],
.
## diffname pc/devfloppy.c 1999/0403
## diff -e /n/emeliedump/1998/0825/sys/src/brazil/pc/devfloppy.c /n/emeliedump/1999/0403/sys/src/brazil/pc/devfloppy.c
162a
dmainit(DMAchan, maxtsize);
.
147,148d
## diffname pc/devfloppy.c 1999/0507
## diff -e /n/emeliedump/1999/0403/sys/src/brazil/pc/devfloppy.c /n/emeliedump/1999/0507/sys/src/brazil/pc/devfloppy.c
685c
* reset it and get back to a known state
.
## diffname pc/devfloppy.c 1999/0714
## diff -e /n/emeliedump/1999/0507/sys/src/brazil/pc/devfloppy.c /n/emeliedump/1999/0714/sys/src/brazil/pc/devfloppy.c
202a
if(fl.ndrive == 0)
error(Enodev);
.
148a
if(fl.ndrive == 0)
return;
.
## diffname pc/devfloppy.c 2000/0308
## diff -e /n/emeliedump/1999/0714/sys/src/brazil/pc/devfloppy.c /n/emeliedump/2000/0308/sys/src/9/pc/devfloppy.c
883c
if(getfields(params, f, 3, 1, " ") > 1){
.
## diffname pc/devfloppy.c 2000/0813
## diff -e /n/emeliedump/2000/0308/sys/src/9/pc/devfloppy.c /n/emeliedump/2000/0813/sys/src/9/pc/devfloppy.c
964c
floppywait(1);
.
828c
floppywait(0);
.
785d
782c
if(tries++ >= dp->maxtries)
.
749c
floppywait(1);
.
715c
floppywait(0);
.
665c
floppywait(1);
.
644c
tsleep(&fl.r, cmddone, 0, slow ? 5000 : 1000);
.
642c
floppywait(int slow)
.
503a
/* return -1 if this didn't work */
if(dp->confused)
return -1;
return 0;
.
470c
static int
.
295a
dp->maxtries = 20;
.
293a
/* if the read succeeds, we've got the density right */
.
288c
/* floppyon will fail if there's a controller but no drive */
if(floppyon(dp) < 0)
error(Eio);
.
280a
/*
* if first attempt doesn't reset changed bit, there's
* no floppy there
*/
if(inb(Pdir)&Fchange)
nexterror();
.
278c
if(floppyon(dp) < 0)
error(Eio);
/* seek to the first track */
.
276a
dp->maxtries = 3; /* limit it when we're probing */
/* floppyon will fail if there's a controller but no drive */
.
275d
103c
static void floppywait(int);
.
## diffname pc/devfloppy.c 2001/0527
## diff -e /n/emeliedump/2000/0813/sys/src/9/pc/devfloppy.c /n/emeliedump/2001/0527/sys/src/9/pc/devfloppy.c
1038d
354c
if(c->qid.type & QTDIR)
.
228c
return devstat(c, dp, n, floppydir, fl.ndrive*NFDIR, devgen);
.
225,226c
static int
floppystat(Chan *c, uchar *dp, int n)
.
222c
return devwalk(c, nc, name, nname, floppydir, fl.ndrive*NFDIR, devgen);
.
219,220c
static Walkqid*
floppywalk(Chan *c, Chan *nc, char **name, int nname)
.
106a
".", {Qdir, 0, QTDIR}, 0, 0550,
.
## diffname pc/devfloppy.c 2001/0716
## diff -e /n/emeliedump/2001/0527/sys/src/9/pc/devfloppy.c /n/emeliedump/2001/0716/sys/src/9/pc/devfloppy.c
911c
floppydir[1+NFDIR*dp->dev].length = dp->t->cap;
.
356c
return devdirread(c, a, n, floppydir, 1+fl.ndrive*NFDIR, devgen);
.
300c
floppydir[1+NFDIR*dp->dev].length = dp->t->cap;
.
235c
return devopen(c, omode, floppydir, 1+fl.ndrive*NFDIR, devgen);
.
229c
return devstat(c, dp, n, floppydir, 1+fl.ndrive*NFDIR, devgen);
.
223c
return devwalk(c, nc, name, nname, floppydir, 1+fl.ndrive*NFDIR, devgen);
.
137c
floppydir[1+NFDIR*dp->dev].length = dp->t->cap;
.
## diffname pc/devfloppy.c 2001/1117
## diff -e /n/emeliedump/2001/0716/sys/src/9/pc/devfloppy.c /n/emeliedump/2001/1117/sys/src/9/pc/devfloppy.c
907c
if(tokenize(params, f, 3) > 1){
.
## diffname pc/devfloppy.c 2001/1120
## diff -e /n/emeliedump/2001/1117/sys/src/9/pc/devfloppy.c /n/emeliedump/2001/1120/sys/src/9/pc/devfloppy.c
919a
} else {
cmderror(cb, "invalid floppy format command");
SET(t);
.
917c
} else if(cb->nf == 1){
.
909c
if(strcmp(cb->f[1], t->name)==0 && t->dt==dp->dt){
.
907c
if(cb->nf == 2){
.
902d
896c
floppyformat(FDrive *dp, Cmdbuf *cb)
.
457a
poperror();
free(cb);
.
454,455c
break;
}
.
450,452c
break;
case CMdebug:
.
447c
break;
case CMformat:
floppyformat(dp, cb);
break;
case CMreset:
.
441,445c
ct = lookupcmd(cb, floppyctlmsg, nelem(floppyctlmsg));
switch(ct->index){
case CMeject:
.
435a
cb = parsecmd(a, n);
if(waserror()){
free(cb);
nexterror();
}
.
406c
Cmdbuf *cb;
Cmdtab *ct;
.
399d
118a
enum
{
CMdebug,
CMeject,
CMformat,
CMreset,
};
static Cmdtab floppyctlmsg[] =
{
CMdebug, "debug", 1,
CMeject, "eject", 1,
CMformat, "format", 0,
CMreset, "reset", 1,
};
.
95c
static void floppyformat(FDrive*, Cmdbuf*);
.
## diffname pc/devfloppy.c 2002/0109
## diff -e /n/emeliedump/2001/1120/sys/src/9/pc/devfloppy.c /n/emeliedump/2002/0109/sys/src/9/pc/devfloppy.c
1063a
devshutdown,
.
## diffname pc/devfloppy.c 2003/0325
## diff -e /n/emeliedump/2002/0109/sys/src/9/pc/devfloppy.c /n/emeliedump/2003/0325/sys/src/9/pc/devfloppy.c
475a
break;
case CMnodebug:
floppydebug = 0;
.
129a
CMnodebug, "nodebug", 1,
.
121a
CMnodebug,
.
## diffname pc/devfloppy.c 2003/0407
## diff -e /n/emeliedump/2003/0325/sys/src/9/pc/devfloppy.c /n/emeliedump/2003/0407/sys/src/9/pc/devfloppy.c
534c
tsleep(&up->sleep, return0, 0, 750);
.
512c
tsleep(&up->sleep, return0, 0, 1000);
.
|
