![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to f002551 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port|
Return to f002551 CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port |
1.1 root 1: #include "u.h"
2: #include "../port/lib.h"
3: #include "mem.h"
4: #include "dat.h"
5: #include "fns.h"
6: #include "io.h"
7: #include "../port/error.h"
8: #include "devtab.h"
9:
10: /* Intel 82077A (8272A compatible) floppy controller */
11:
12: /* This module expects the following functions to be defined
13: * elsewhere:
14: *
15: * inb()
16: * outb()
17: * floppyexec()
18: * floppyeject()
19: * floppysetup0()
20: * floppysetup1()
21: * dmasetup()
22: * dmaend()
23: *
24: * On DMA systems, floppyexec() should be an empty function;
25: * on non-DMA systems, dmaend() should be an empty function;
26: * dmasetup() may enforce maximum transfer sizes.
27: */
28:
29: enum {
30: /* file types */
31: Qdir= 0,
32: Qdata= (1<<2),
33: Qctl= (2<<2),
34: Qmask= (3<<2),
35:
36: DMAchan= 2, /* floppy dma channel */
37: };
38:
39: #define DPRINT if(floppydebug)kprint
40: int floppydebug;
41:
42: /*
43: * types of drive (from PC equipment byte)
44: */
45: enum
46: {
47: Tnone= 0,
48: T360kb= 1,
49: T1200kb= 2,
50: T720kb= 3,
51: T1440kb= 4,
52: };
53:
54: FType floppytype[] =
55: {
56: { "3½HD", T1440kb, 512, 18, 2, 1, 80, 0x1B, 0x54, 0, },
57: { "3½DD", T1440kb, 512, 9, 2, 1, 80, 0x1B, 0x54, 2, },
58: { "3½DD", T720kb, 512, 9, 2, 1, 80, 0x1B, 0x54, 2, },
59: { "5¼HD", T1200kb, 512, 15, 2, 1, 80, 0x2A, 0x50, 0, },
60: { "5¼DD", T1200kb, 512, 9, 2, 2, 40, 0x2A, 0x50, 1, },
61: { "ATT3B1", T1200kb, 512, 8, 2, 2, 48, 0x2A, 0x50, 1, },
62: { "5¼DD", T360kb, 512, 9, 2, 1, 40, 0x2A, 0x50, 2, },
63: };
64: #define NTYPES (sizeof(floppytype)/sizeof(FType))
65:
66: /*
67: * bytes per sector encoding for the controller.
68: * - index for b2c is is (bytes per sector/128).
69: * - index for c2b is code from b2c
70: */
71: static int b2c[] =
72: {
73: [1] 0,
74: [2] 1,
75: [4] 2,
76: [8] 3,
77: };
78: static int c2b[] =
79: {
80: 128,
81: 256,
82: 512,
83: 1024,
84: };
85:
86: FController fl;
87:
88: #define MOTORBIT(i) (1<<((i)+4))
89:
90: /*
91: * predeclared
92: */
93: static void floppykproc(void*);
94: static void floppypos(FDrive*,long);
95: static int floppyrecal(FDrive*);
96: static void floppyrevive(void);
97: static long floppyseek(FDrive*, long);
98: static int floppysense(void);
99: static void floppywait(void);
100: static long floppyxfer(FDrive*, int, void*, long, long);
101: static void floppyformat(FDrive*, char*);
102: static int cmddone(void*);
103: void Xdelay(int);
104:
105: Dirtab floppydir[]={
106: "fd0disk", {Qdata + 0}, 0, 0666,
107: "fd0ctl", {Qctl + 0}, 0, 0666,
108: "fd1disk", {Qdata + 1}, 0, 0666,
109: "fd1ctl", {Qctl + 1}, 0, 0666,
110: "fd2disk", {Qdata + 2}, 0, 0666,
111: "fd2ctl", {Qctl + 2}, 0, 0666,
112: "fd3disk", {Qdata + 3}, 0, 0666,
113: "fd3ctl", {Qctl + 3}, 0, 0666,
114: };
115: #define NFDIR 2 /* directory entries/drive */
116:
117: static void
118: fldump(void)
119: {
120: DPRINT("sra %ux srb %ux dor %ux msr %ux dir %ux\n", inb(Psra), inb(Psrb),
121: inb(Pdor), inb(Pmsr), inb(Pdir));
122: }
123:
124: /*
125: * set floppy drive to its default type
126: */
127: void
128: floppysetdef(FDrive *dp)
129: {
130: FType *t;
131:
132: for(t = floppytype; t < &floppytype[NTYPES]; t++)
133: if(dp->dt == t->dt){
134: dp->t = t;
135: floppydir[NFDIR*dp->dev].length = dp->t->cap;
136: break;
137: }
138: }
139:
140: void
141: floppyreset(void)
142: {
143: FDrive *dp;
144: FType *t;
145: ulong maxtsize;
146:
147: floppysetup0(&fl);
148:
149: /*
150: * init dependent parameters
151: */
152: maxtsize = 0;
153: for(t = floppytype; t < &floppytype[NTYPES]; t++){
154: t->cap = t->bytes * t->heads * t->sectors * t->tracks;
155: t->bcode = b2c[t->bytes/128];
156: t->tsize = t->bytes * t->sectors;
157: if(maxtsize < t->tsize)
158: maxtsize = t->tsize;
159: }
160:
161: /*
162: * allocate the drive storage
163: */
164: fl.d = xalloc(conf.nfloppy*sizeof(FDrive));
165: fl.selected = fl.d;
166:
167: /*
168: * stop the motors
169: */
170: fl.motor = 0;
171: delay(10);
172: outb(Pdor, fl.motor | Fintena | Fena);
173: delay(10);
174:
175: /*
176: * init drives
177: */
178: for(dp = fl.d; dp < &fl.d[conf.nfloppy]; dp++){
179: dp->dev = dp - fl.d;
180: dp->dt = T1440kb;
181: floppysetdef(dp);
182: dp->cyl = -1; /* because we don't know */
183: dp->cache = (uchar*)xspanalloc(maxtsize, BY2PG, 64*1024);
184: dp->ccyl = -1;
185: dp->vers = 1;
186: }
187:
188: /*
189: * first operation will recalibrate
190: */
191: fl.confused = 1;
192:
193: floppysetup1(&fl);
194: }
195:
196: void
197: floppyinit(void)
198: {
199: }
200:
201: Chan*
202: floppyattach(char *spec)
203: {
204: static int kstarted;
205:
206: if(kstarted == 0){
207: /*
208: * watchdog to turn off the motors
209: */
210: kstarted = 1;
211: kproc("floppy", floppykproc, 0);
212: }
213: return devattach('f', spec);
214: }
215:
216: Chan*
217: floppyclone(Chan *c, Chan *nc)
218: {
219: return devclone(c, nc);
220: }
221:
222: int
223: floppywalk(Chan *c, char *name)
224: {
225: return devwalk(c, name, floppydir, conf.nfloppy*NFDIR, devgen);
226: }
227:
228: void
229: floppystat(Chan *c, char *dp)
230: {
231: devstat(c, dp, floppydir, conf.nfloppy*NFDIR, devgen);
232: }
233:
234: Chan*
235: floppyopen(Chan *c, int omode)
236: {
237: return devopen(c, omode, floppydir, conf.nfloppy*NFDIR, devgen);
238: }
239:
240: void
241: floppycreate(Chan *c, char *name, int omode, ulong perm)
242: {
243: USED(c, name, omode, perm);
244: error(Eperm);
245: }
246:
247: void
248: floppyclose(Chan *c)
249: {
250: USED(c);
251: }
252:
253: void
254: floppyremove(Chan *c)
255: {
256: USED(c);
257: error(Eperm);
258: }
259:
260: void
261: floppywstat(Chan *c, char *dp)
262: {
263: USED(c, dp);
264: error(Eperm);
265: }
266:
267: static void
268: islegal(ulong offset, long n, FDrive *dp)
269: {
270: if(offset % dp->t->bytes)
271: error(Ebadarg);
272: if(n % dp->t->bytes)
273: error(Ebadarg);
274: }
275:
276: /*
277: * check if the floppy has been replaced under foot. cause
278: * an error if it has.
279: *
280: * a seek and a read clears the condition. this was determined
281: * experimentally, there has to be a better way.
282: *
283: * if the read fails, cycle through the possible floppy
284: * density till one works or we've cycled through all
285: * possibilities for this drive.
286: */
287: static void
288: changed(Chan *c, FDrive *dp)
289: {
290: ulong old;
291: FType *start;
292:
293: /*
294: * if floppy has changed or first time through
295: */
296: if((inb(Pdir)&Fchange) || dp->vers == 0){
297: DPRINT("changed\n");
298: fldump();
299: dp->vers++;
300: floppysetdef(dp);
301: start = dp->t;
302: dp->confused = 1; /* make floppyon recal */
303: floppyon(dp);
304: floppyseek(dp, dp->t->heads*dp->t->tsize);
305: while(waserror()){
306: while(++dp->t){
307: if(dp->t == &floppytype[NTYPES])
308: dp->t = floppytype;
309: if(dp->dt == dp->t->dt)
310: break;
311: }
312: floppydir[NFDIR*dp->dev].length = dp->t->cap;
313: floppyon(dp);
314: DPRINT("changed: trying %s\n", dp->t->name);
315: fldump();
316: if(dp->t == start)
317: nexterror();
318: }
319: floppyxfer(dp, Fread, dp->cache, 0, dp->t->tsize);
320: poperror();
321: }
322:
323: old = c->qid.vers;
324: c->qid.vers = dp->vers;
325: if(old && old != dp->vers)
326: error(Eio);
327: }
328:
329: static int
330: readtrack(FDrive *dp, int cyl, int head)
331: {
332: int i, nn, sofar;
333: ulong pos;
334:
335: nn = dp->t->tsize;
336: if(dp->ccyl==cyl && dp->chead==head)
337: return nn;
338: pos = (cyl*dp->t->heads+head) * nn;
339: for(sofar = 0; sofar < nn; sofar += i){
340: dp->ccyl = -1;
341: i = floppyxfer(dp, Fread, dp->cache + sofar, pos + sofar, nn - sofar);
342: if(i <= 0)
343: return -1;
344: }
345: dp->ccyl = cyl;
346: dp->chead = head;
347: return nn;
348: }
349:
350: long
351: floppyread(Chan *c, void *a, long n, ulong offset)
352: {
353: FDrive *dp;
354: long rv;
355: int sec, head, cyl;
356: long len;
357: uchar *aa;
358:
359: if(c->qid.path == CHDIR)
360: return devdirread(c, a, n, floppydir, conf.nfloppy*NFDIR, devgen);
361:
362: rv = 0;
363: dp = &fl.d[c->qid.path & ~Qmask];
364: switch ((int)(c->qid.path & Qmask)) {
365: case Qdata:
366: islegal(offset, n, dp);
367: aa = a;
368:
369: qlock(&fl);
370: if(waserror()){
371: qunlock(&fl);
372: nexterror();
373: }
374: floppyon(dp);
375: changed(c, dp);
376: for(rv = 0; rv < n; rv += len){
377: /*
378: * all xfers come out of the track cache
379: */
380: dp->len = n - rv;
381: floppypos(dp, offset+rv);
382: cyl = dp->tcyl;
383: head = dp->thead;
384: len = dp->len;
385: sec = dp->tsec;
386: if(readtrack(dp, cyl, head) < 0)
387: break;
388: memmove(aa+rv, dp->cache + (sec-1)*dp->t->bytes, len);
389: }
390: qunlock(&fl);
391: poperror();
392:
393: break;
394: case Qctl:
395: return readstr(offset, a, n, dp->t->name);
396: default:
397: panic("floppyread: bad qid");
398: }
399:
400: return rv;
401: }
402:
403: #define SNCMP(a, b) strncmp(a, b, sizeof(b)-1)
404: long
405: floppywrite(Chan *c, void *a, long n, ulong offset)
406: {
407: FDrive *dp;
408: long rv, i;
409: char *aa = a;
410: char ctlmsg[64];
411:
412: rv = 0;
413: dp = &fl.d[c->qid.path & ~Qmask];
414: switch ((int)(c->qid.path & Qmask)) {
415: case Qdata:
416: islegal(offset, n, dp);
417: qlock(&fl);
418: if(waserror()){
419: qunlock(&fl);
420: nexterror();
421: }
422: floppyon(dp);
423: changed(c, dp);
424: for(rv = 0; rv < n; rv += i){
425: floppypos(dp, offset+rv);
426: if(dp->tcyl == dp->ccyl)
427: dp->ccyl = -1;
428: i = floppyxfer(dp, Fwrite, aa+rv, offset+rv, n-rv);
429: if(i < 0)
430: break;
431: if(i == 0)
432: error(Eio);
433: }
434: qunlock(&fl);
435: poperror();
436: break;
437: case Qctl:
438: rv = n;
439: qlock(&fl);
440: if(waserror()){
441: qunlock(&fl);
442: nexterror();
443: }
444: if(n >= sizeof(ctlmsg))
445: n = sizeof(ctlmsg) - 1;
446: memmove(ctlmsg, aa, n);
447: ctlmsg[n] = 0;
448: if(SNCMP(ctlmsg, "eject") == 0){
449: floppyeject(dp);
450: } else if(SNCMP(ctlmsg, "reset") == 0){
451: fl.confused = 1;
452: floppyon(dp);
453: } else if(SNCMP(ctlmsg, "format") == 0){
454: floppyformat(dp, ctlmsg);
455: } else if(SNCMP(ctlmsg, "debug") == 0){
456: floppydebug = 1;
457: } else
458: error(Ebadctl);
459: poperror();
460: qunlock(&fl);
461: break;
462: default:
463: panic("floppywrite: bad qid");
464: }
465:
466: return rv;
467: }
468:
469: static void
470: floppykproc(void *a)
471: {
472: FDrive *dp;
473:
474: USED(a);
475: while(waserror())
476: ;
477: for(;;){
478: for(dp = fl.d; dp < &fl.d[conf.nfloppy]; dp++){
479: if((fl.motor&MOTORBIT(dp->dev))
480: && TK2SEC(m->ticks - dp->lasttouched) > 5
481: && canqlock(&fl)){
482: if(TK2SEC(m->ticks - dp->lasttouched) > 5)
483: floppyoff(dp);
484: qunlock(&fl);
485: }
486: }
487: tsleep(&fl.kr, return0, 0, 1000);
488: }
489: }
490:
491: /*
492: * start a floppy drive's motor.
493: */
494: void
495: floppyon(FDrive *dp)
496: {
497: int alreadyon;
498: int tries;
499:
500: if(fl.confused)
501: floppyrevive();
502:
503: /* start motor and select drive */
504: alreadyon = fl.motor & MOTORBIT(dp->dev);
505: fl.motor |= MOTORBIT(dp->dev);
506: outb(Pdor, fl.motor | Fintena | Fena | dp->dev);
507: if(!alreadyon){
508: /* wait for drive to spin up */
509: tsleep(&dp->r, return0, 0, 750);
510:
511: /* clear any pending interrupts */
512: floppysense();
513: }
514:
515: /* set transfer rate */
516: if(fl.rate != dp->t->rate){
517: fl.rate = dp->t->rate;
518: outb(Pdsr, fl.rate);
519: }
520:
521: /* get drive to a known cylinder */
522: if(dp->confused)
523: for(tries = 0; tries < 4; tries++)
524: if(floppyrecal(dp) >= 0)
525: break;
526: dp->lasttouched = m->ticks;
527: fl.selected = dp;
528: }
529:
530: /*
531: * stop the floppy if it hasn't been used in 5 seconds
532: */
533: void
534: floppyoff(FDrive *dp)
535: {
536: fl.motor &= ~MOTORBIT(dp->dev);
537: outb(Pdor, fl.motor | Fintena | Fena | dp->dev);
538: fl.selected = dp;
539: }
540:
541: /*
542: * send a command to the floppy
543: */
544: int
545: floppycmd(void)
546: {
547: int i;
548: int tries;
549:
550: fl.nstat = 0;
551: for(i = 0; i < fl.ncmd; i++){
552: for(tries = 0; ; tries++){
553: if(tries > 1000){
554: DPRINT("cmd %ux can't be sent (%d)\n", fl.cmd[0], i);
555: fldump();
556:
557: /* empty fifo, might have been a bad command */
558: floppyresult();
559: return -1;
560: }
561: if((inb(Pmsr)&(Ffrom|Fready)) == Fready)
562: break;
563: }
564: outb(Pfdata, fl.cmd[i]);
565: }
566: return 0;
567: }
568:
569: /*
570: * get a command result from the floppy
571: *
572: * when the controller goes ready waiting for a command
573: * (instead of sending results), we're done
574: *
575: */
576: int
577: floppyresult(void)
578: {
579: int i, s;
580: int tries;
581:
582: /* get the result of the operation */
583: for(i = 0; i < sizeof(fl.stat); i++){
584: /* wait for status byte */
585: for(tries = 0; ; tries++){
586: if(tries > 1000){
587: DPRINT("floppyresult: %d stats\n", i);
588: fldump();
589: fl.confused = 1;
590: return -1;
591: }
592: s = inb(Pmsr)&(Ffrom|Fready);
593: if(s == Fready){
594: fl.nstat = i;
595: return fl.nstat;
596: }
597: if(s == (Ffrom|Fready))
598: break;
599: }
600: fl.stat[i] = inb(Pfdata);
601: }
602: fl.nstat = sizeof(fl.stat);
603: return fl.nstat;
604: }
605:
606: /*
607: * calculate physical address of a logical byte offset into the disk
608: *
609: * truncate dp->length if it crosses a track boundary
610: */
611: static void
612: floppypos(FDrive *dp, long off)
613: {
614: int lsec;
615: int ltrack;
616: int end;
617:
618: lsec = off/dp->t->bytes;
619: ltrack = lsec/dp->t->sectors;
620: dp->tcyl = ltrack/dp->t->heads;
621: dp->tsec = (lsec % dp->t->sectors) + 1;
622: dp->thead = (lsec/dp->t->sectors) % dp->t->heads;
623:
624: /*
625: * can't read across track boundaries.
626: * if so, decrement the bytes to be read.
627: */
628: end = (ltrack+1)*dp->t->sectors*dp->t->bytes;
629: if(off+dp->len > end)
630: dp->len = end - off;
631: }
632:
633: /*
634: * get the interrupt cause from the floppy.
635: */
636: static int
637: floppysense(void)
638: {
639: fl.ncmd = 0;
640: fl.cmd[fl.ncmd++] = Fsense;
641: if(floppycmd() < 0)
642: return -1;
643: if(floppyresult() < 2){
644: DPRINT("can't read sense response\n");
645: fldump();
646: fl.confused = 1;
647: return -1;
648: }
649: return 0;
650: }
651:
652: static int
653: cmddone(void *a)
654: {
655: USED(a);
656: return fl.ncmd == 0;
657: }
658:
659: /*
660: * Wait for a floppy interrupt. If none occurs in 5 seconds, we
661: * may have missed one. This only happens on some portables which
662: * do power management behind our backs. Call the interrupt
663: * routine to try to clear any conditions.
664: */
665: static void
666: floppywait(void)
667: {
668: tsleep(&fl.r, cmddone, 0, 5000);
669: if(!cmddone(0)){
670: floppyintr(0);
671: fl.confused = 1;
672: }
673: }
674:
675: /*
676: * we've lost the floppy position, go to cylinder 0.
677: */
678: static int
679: floppyrecal(FDrive *dp)
680: {
681: dp->ccyl = -1;
682: dp->cyl = -1;
683:
684: fl.ncmd = 0;
685: fl.cmd[fl.ncmd++] = Frecal;
686: fl.cmd[fl.ncmd++] = dp->dev;
687: if(floppycmd() < 0)
688: return -1;
689: floppywait();
690: if(fl.nstat < 2){
691: DPRINT("recalibrate: confused %ux\n", inb(Pmsr));
692: fl.confused = 1;
693: return -1;
694: }
695: if((fl.stat[0] & (Codemask|Seekend)) != Seekend){
696: DPRINT("recalibrate: failed\n");
697: dp->confused = 1;
698: return -1;
699: }
700: dp->cyl = fl.stat[1];
701: if(dp->cyl != 0){
702: DPRINT("recalibrate: wrong cylinder %d\n", dp->cyl);
703: dp->cyl = -1;
704: dp->confused = 1;
705: return -1;
706: }
707:
708: dp->confused = 0;
709: return 0;
710: }
711:
712: /*
713: * if the controller or a specific drive is in a confused state,
714: * reset it and get back to a kown state
715: */
716: void
717: floppyrevive(void)
718: {
719: FDrive *dp;
720:
721: /*
722: * reset the controller if it's confused
723: */
724: if(fl.confused){
725: DPRINT("floppyrevive in\n");
726: fldump();
727:
728: /* reset controller and turn all motors off */
729: splhi();
730: fl.ncmd = 1;
731: fl.cmd[0] = 0;
732: outb(Pdor, 0);
733: delay(10);
734: outb(Pdor, Fintena|Fena);
735: delay(10);
736: spllo();
737: fl.motor = 0;
738: fl.confused = 0;
739: floppywait();
740:
741: /* mark all drives in an unknown state */
742: for(dp = fl.d; dp < &fl.d[conf.nfloppy]; dp++)
743: dp->confused = 1;
744:
745: /* set rate to a known value */
746: outb(Pdsr, 0);
747: fl.rate = 0;
748:
749: DPRINT("floppyrevive out\n");
750: fldump();
751: }
752: }
753:
754: /*
755: * seek to the target cylinder
756: *
757: * interrupt, no results
758: */
759: static long
760: floppyseek(FDrive *dp, long off)
761: {
762: floppypos(dp, off);
763: if(dp->cyl == dp->tcyl)
764: return dp->tcyl;
765: dp->cyl = -1;
766:
767: fl.ncmd = 0;
768: fl.cmd[fl.ncmd++] = Fseek;
769: fl.cmd[fl.ncmd++] = (dp->thead<<2) | dp->dev;
770: fl.cmd[fl.ncmd++] = dp->tcyl * dp->t->steps;
771: if(floppycmd() < 0)
772: return -1;
773: floppywait();
774: if(fl.nstat < 2){
775: DPRINT("seek: confused\n");
776: fl.confused = 1;
777: return -1;
778: }
779: if((fl.stat[0] & (Codemask|Seekend)) != Seekend){
780: DPRINT("seek: failed\n");
781: dp->confused = 1;
782: return -1;
783: }
784:
785: dp->cyl = dp->tcyl;
786: return dp->tcyl;
787: }
788:
789: /*
790: * read or write to floppy. try up to three times.
791: */
792: static long
793: floppyxfer(FDrive *dp, int cmd, void *a, long off, long n)
794: {
795: long offset;
796: int tries;
797:
798: if(off >= dp->t->cap)
799: return 0;
800: if(off + n > dp->t->cap)
801: n = dp->t->cap - off;
802:
803: /* retry on error 3 times */
804: tries = 0;
805: while(waserror()){
806: if(tries++ >= 3)
807: nexterror();
808: DPRINT("floppyxfer: retrying\n");
809: floppyon(dp);
810: }
811:
812: dp->len = n;
813: if(floppyseek(dp, off) < 0){
814: DPRINT("xfer: seek failed\n");
815: dp->confused = 1;
816: error(Eio);
817: }
818:
819: /*
820: * set up the dma (dp->len may be trimmed)
821: */
822: if(waserror()){
823: dmaend(DMAchan);
824: nexterror();
825: }
826: dp->len = dmasetup(DMAchan, a, dp->len, cmd==Fread);
827:
828: /*
829: * start operation
830: */
831: cmd = cmd | (dp->t->heads > 1 ? Fmulti : 0);
832: fl.ncmd = 0;
833: fl.cmd[fl.ncmd++] = cmd;
834: fl.cmd[fl.ncmd++] = (dp->thead<<2) | dp->dev;
835: fl.cmd[fl.ncmd++] = dp->tcyl;
836: fl.cmd[fl.ncmd++] = dp->thead;
837: fl.cmd[fl.ncmd++] = dp->tsec;
838: fl.cmd[fl.ncmd++] = dp->t->bcode;
839: fl.cmd[fl.ncmd++] = dp->t->sectors;
840: fl.cmd[fl.ncmd++] = dp->t->gpl;
841: fl.cmd[fl.ncmd++] = 0xFF;
842: if(floppycmd() < 0)
843: error(Eio);
844:
845: /* Poll ready bits and transfer data */
846: floppyexec((char*)a, dp->len, (cmd & ~Fmulti)==Fread);
847:
848: /*
849: * give bus to DMA, floppyintr() will read result
850: */
851: floppywait();
852: dmaend(DMAchan);
853: poperror();
854:
855: /*
856: * check for errors
857: */
858: if(fl.nstat < 7){
859: DPRINT("xfer: confused\n");
860: fl.confused = 1;
861: error(Eio);
862: }
863: if((fl.stat[0] & Codemask)!=0 || fl.stat[1] || fl.stat[2]){
864: DPRINT("xfer: failed %lux %lux %lux\n", fl.stat[0],
865: fl.stat[1], fl.stat[2]);
866: DPRINT("offset %lud len %d\n", off, dp->len);
867: dp->confused = 1;
868: error(Eio);
869: }
870:
871: /*
872: * check for correct cylinder
873: */
874: offset = fl.stat[3] * dp->t->heads + fl.stat[4];
875: offset = offset*dp->t->sectors + fl.stat[5] - 1;
876: offset = offset * c2b[fl.stat[6]];
877: if(offset != off+dp->len){
878: DPRINT("xfer: ends on wrong cyl\n");
879: dp->confused = 1;
880: error(Eio);
881: }
882: poperror();
883:
884: dp->lasttouched = m->ticks;
885: return dp->len;
886: }
887:
888: /*
889: * format a track
890: */
891: static void
892: floppyformat(FDrive *dp, char *params)
893: {
894: int cyl, h, sec;
895: ulong track;
896: uchar *buf, *bp;
897: FType *t;
898: char *f[3];
899:
900: /*
901: * set the type
902: */
903: if(getfields(params, f, 3, " ") > 1){
904: for(t = floppytype; t < &floppytype[NTYPES]; t++){
905: if(strcmp(f[1], t->name)==0 && t->dt==dp->dt){
906: dp->t = t;
907: floppydir[NFDIR*dp->dev].length = dp->t->cap;
908: break;
909: }
910: }
911: if(t >= &floppytype[NTYPES])
912: error(Ebadarg);
913: } else {
914: floppysetdef(dp);
915: t = dp->t;
916: }
917:
918: /*
919: * buffer for per track info
920: */
921: buf = smalloc(t->sectors*4);
922: if(waserror()){
923: free(buf);
924: nexterror();
925: }
926:
927: /* force a recalibrate to cylinder 0 */
928: dp->confused = 1;
929: if(!waserror()){
930: floppyon(dp);
931: poperror();
932: }
933:
934: /*
935: * format a track at time
936: */
937: for(track = 0; track < t->tracks*t->heads; track++){
938: cyl = track/t->heads;
939: h = track % t->heads;
940:
941: /*
942: * seek to track, ignore errors
943: */
944: floppyseek(dp, track*t->tsize);
945: dp->cyl = cyl;
946: dp->confused = 0;
947:
948: /*
949: * set up the dma (dp->len may be trimmed)
950: */
951: bp = buf;
952: for(sec = 1; sec <= t->sectors; sec++){
953: *bp++ = cyl;
954: *bp++ = h;
955: *bp++ = sec;
956: *bp++ = t->bcode;
957: }
958: if(waserror()){
959: dmaend(DMAchan);
960: nexterror();
961: }
962: dmasetup(DMAchan, buf, bp-buf, 0);
963:
964: /*
965: * start operation
966: */
967: fl.ncmd = 0;
968: fl.cmd[fl.ncmd++] = Fformat;
969: fl.cmd[fl.ncmd++] = (h<<2) | dp->dev;
970: fl.cmd[fl.ncmd++] = t->bcode;
971: fl.cmd[fl.ncmd++] = t->sectors;
972: fl.cmd[fl.ncmd++] = t->fgpl;
973: fl.cmd[fl.ncmd++] = 0x5a;
974: if(floppycmd() < 0)
975: error(Eio);
976:
977: /* Poll ready bits and transfer data */
978: floppyexec((char *)buf, bp-buf, 0);
979:
980: /*
981: * give bus to DMA, floppyintr() will read result
982: */
983: floppywait();
984: dmaend(DMAchan);
985: poperror();
986:
987: /*
988: * check for errors
989: */
990: if(fl.nstat < 7){
991: DPRINT("format: confused\n");
992: fl.confused = 1;
993: error(Eio);
994: }
995: if((fl.stat[0]&Codemask)!=0 || fl.stat[1]|| fl.stat[2]){
996: DPRINT("format: failed %lux %lux %lux\n",
997: fl.stat[0], fl.stat[1], fl.stat[2]);
998: dp->confused = 1;
999: error(Eio);
1000: }
1001: }
1002: free(buf);
1003: dp->confused = 1;
1004: poperror();
1005: }
1006:
1007: void
1008: floppyintr(Ureg *ur)
1009: {
1010: USED(ur);
1011: switch(fl.cmd[0]&~Fmulti){
1012: case Fread:
1013: case Fwrite:
1014: case Fformat:
1015: case Fdumpreg:
1016: floppyresult();
1017: break;
1018: case Fseek:
1019: case Frecal:
1020: default:
1021: floppysense(); /* to clear interrupt */
1022: break;
1023: }
1024: fl.ncmd = 0;
1025: wakeup(&fl.r);
1026: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.