![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / i386 / isa|
Return to fd.c CVS log | Up to [Net/2] / Net2 / arch / i386 / isa |
1.1 root 1: /*-
2: * Copyright (c) 1990 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Don Ahn.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by the University of
19: * California, Berkeley and its contributors.
20: * 4. Neither the name of the University nor the names of its contributors
21: * may be used to endorse or promote products derived from this software
22: * without specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34: * SUCH DAMAGE.
35: *
36: * @(#)fd.c 7.4 (Berkeley) 5/25/91
37: */
38:
39: #include "fd.h"
40: #if NFD > 0
41:
42: #include "param.h"
43: #include "dkbad.h"
44: #include "systm.h"
45: #include "conf.h"
46: #include "file.h"
47: #include "ioctl.h"
48: #include "buf.h"
49: #include "uio.h"
50: #include "i386/isa/isa_device.h"
51: #include "i386/isa/fdreg.h"
52: #include "i386/isa/icu.h"
53:
54: #define FDUNIT(s) ((s)&1)
55: #define FDTYPE(s) (((s)>>1)&7)
56:
57: #define b_cylin b_resid
58: #define b_step b_resid
59: #define FDBLK 512
60: #define NUMTYPES 4
61:
62: struct fd_type {
63: int sectrac; /* sectors per track */
64: int secsize; /* size code for sectors */
65: int datalen; /* data len when secsize = 0 */
66: int gap; /* gap len between sectors */
67: int tracks; /* total num of tracks */
68: int size; /* size of disk in sectors */
69: int steptrac; /* steps per cylinder */
70: int trans; /* transfer speed code */
71: };
72:
73: struct fd_type fd_types[NUMTYPES] = {
74: { 18,2,0xFF,0x1B,80,2880,1,0 }, /* 1.44 meg HD 3.5in floppy */
75: { 15,2,0xFF,0x1B,80,2400,1,0 }, /* 1.2 meg HD floppy */
76: { 9,2,0xFF,0x23,40,720,2,1 }, /* 360k floppy in 1.2meg drive */
77: { 9,2,0xFF,0x2A,40,720,1,1 }, /* 360k floppy in DD drive */
78: };
79:
80: struct fd_u {
81: int type; /* Drive type (HD, DD */
82: int active; /* Drive activity boolean */
83: int motor; /* Motor on flag */
84: struct buf head; /* Head of buf chain */
85: struct buf rhead; /* Raw head of buf chain */
86: int reset;
87: } fd_unit[NFD];
88:
89:
90: extern int hz;
91:
92: /* state needed for current transfer */
93: static fdc; /* floppy disk controller io base register */
94: int fd_dmachan = 2;
95: static int fd_skip;
96: static int fd_state;
97: static int fd_retry;
98: static int fd_drive;
99: static int fd_track = -1;
100: static int fd_status[7];
101:
102: /*
103: make sure bounce buffer for DMA is aligned since the DMA chip
104: doesn't roll over properly over a 64k boundary
105: */
106: extern struct buf *dma_bounce[];
107:
108: /****************************************************************************/
109: /* autoconfiguration stuff */
110: /****************************************************************************/
111: int fdprobe(), fdattach(), fd_turnoff();
112:
113: struct isa_driver fddriver = {
114: fdprobe, fdattach, "fd",
115: };
116:
117: fdprobe(dev)
118: struct isa_device *dev;
119: {
120: return 1;
121: }
122:
123: fdattach(dev)
124: struct isa_device *dev;
125: { int s;
126:
127: fdc = dev->id_iobase;
128: /* Set transfer to 500kbps */
129: outb(fdc+fdctl,0);
130: fd_turnoff(0);
131: }
132:
133: int
134: fdsize(dev)
135: dev_t dev;
136: {
137: return(2400);
138: }
139:
140: /****************************************************************************/
141: /* fdstrategy */
142: /****************************************************************************/
143: fdstrategy(bp)
144: register struct buf *bp; /* IO operation to perform */
145: {
146: register struct buf *dp,*dp0,*dp1;
147: long nblocks,blknum;
148: int unit, type, s;
149:
150: unit = FDUNIT(minor(bp->b_dev));
151: type = FDTYPE(minor(bp->b_dev));
152:
153: #ifdef FDTEST
154: printf("fdstrat%d, blk = %d, bcount = %d, addr = %x|",
155: unit, bp->b_blkno, bp->b_bcount,bp->b_un.b_addr);
156: #endif
157: if ((unit >= NFD) || (bp->b_blkno < 0)) {
158: printf("fdstrat: unit = %d, blkno = %d, bcount = %d\n",
159: unit, bp->b_blkno, bp->b_bcount);
160: pg("fd:error in fdstrategy");
161: bp->b_error = EINVAL;
162: bp->b_flags |= B_ERROR;
163: goto bad;
164: }
165: /*
166: * Set up block calculations.
167: */
168: blknum = (unsigned long) bp->b_blkno * DEV_BSIZE/FDBLK;
169: nblocks = fd_types[type].size;
170: if (blknum + (bp->b_bcount / FDBLK) > nblocks) {
171: if (blknum == nblocks) {
172: bp->b_resid = bp->b_bcount;
173: } else {
174: bp->b_error = ENOSPC;
175: bp->b_flags |= B_ERROR;
176: }
177: goto bad;
178: }
179: bp->b_cylin = blknum / (fd_types[type].sectrac * 2);
180: dp = &fd_unit[unit].head;
181: dp0 = &fd_unit[0].head;
182: dp1 = &fd_unit[1].head;
183: dp->b_step = (fd_types[fd_unit[unit].type].steptrac);
184: s = splbio();
185: disksort(dp, bp);
186: if ((dp0->b_active == 0)&&(dp1->b_active == 0)) {
187: #ifdef FDDEBUG
188: printf("T|");
189: #endif
190: dp->b_active = 1;
191: fd_drive = unit;
192: fd_track = -1; /* force seek on first xfer */
193: untimeout(fd_turnoff,unit);
194: fdstart(unit); /* start drive if idle */
195: }
196: splx(s);
197: return;
198:
199: bad:
200: biodone(bp);
201: }
202:
203: /****************************************************************************/
204: /* motor control stuff */
205: /****************************************************************************/
206: set_motor(unit,reset)
207: int unit,reset;
208: {
209: int m0,m1;
210: m0 = fd_unit[0].motor;
211: m1 = fd_unit[1].motor;
212: outb(fdc+fdout,unit | (reset ? 0 : 0xC) | (m0 ? 16 : 0) | (m1 ? 32 : 0));
213: }
214:
215: fd_turnoff(unit)
216: int unit;
217: {
218: fd_unit[unit].motor = 0;
219: if (unit) set_motor(0,0);
220: else set_motor(1,0);
221: }
222:
223: fd_turnon(unit)
224: int unit;
225: {
226: fd_unit[unit].motor = 1;
227: set_motor(unit,0);
228: }
229:
230: /****************************************************************************/
231: /* fdc in/out */
232: /****************************************************************************/
233: int
234: in_fdc()
235: {
236: int i;
237: while ((i = inb(fdc+fdsts) & (NE7_DIO|NE7_RQM)) != (NE7_DIO|NE7_RQM))
238: if (i == NE7_RQM) return -1;
239: return inb(fdc+fddata);
240: }
241:
242: dump_stat()
243: {
244: int i;
245: for(i=0;i<7;i++) {
246: fd_status[i] = in_fdc();
247: if (fd_status[i] < 0) break;
248: }
249: printf("FD bad status :%lx %lx %lx %lx %lx %lx %lx\n",
250: fd_status[0], fd_status[1], fd_status[2], fd_status[3],
251: fd_status[4], fd_status[5], fd_status[6] );
252: }
253:
254: out_fdc(x)
255: int x;
256: {
257: int r,errcnt;
258: static int maxcnt = 0;
259: errcnt = 0;
260: do {
261: r = (inb(fdc+fdsts) & (NE7_DIO|NE7_RQM));
262: if (r== NE7_RQM) break;
263: if (r==(NE7_DIO|NE7_RQM)) {
264: dump_stat(); /* error: direction. eat up output */
265: #ifdef FDOTHER
266: printf("%lx\n",x);
267: #endif
268: }
269: /* printf("Error r = %d:",r); */
270: errcnt++;
271: } while (1);
272: if (errcnt > maxcnt) {
273: maxcnt = errcnt;
274: #ifdef FDOTHER
275: printf("New MAX = %d\n",maxcnt);
276: #endif
277: }
278: outb(fdc+fddata,x);
279: }
280:
281: /* see if fdc responding */
282: int
283: check_fdc()
284: {
285: int i;
286: for(i=0;i<100;i++) {
287: if (inb(fdc+fdsts)& NE7_RQM) return 0;
288: }
289: return 1;
290: }
291:
292: /****************************************************************************/
293: /* fdopen/fdclose */
294: /****************************************************************************/
295: Fdopen(dev, flags)
296: dev_t dev;
297: int flags;
298: {
299: int unit = FDUNIT(minor(dev));
300: int type = FDTYPE(minor(dev));
301: int s;
302:
303: /* check bounds */
304: if (unit >= NFD) return(ENXIO);
305: if (type >= NUMTYPES) return(ENXIO);
306: /*
307: if (check_fdc()) return(EBUSY);
308: */
309:
310: /* Set proper disk type, only allow one type */
311: return 0;
312: }
313:
314: fdclose(dev, flags)
315: dev_t dev;
316: {
317: }
318:
319: /****************************************************************************/
320: /* fdread/fdwrite */
321: /****************************************************************************/
322: /*
323: * Routines to do raw IO for a unit.
324: */
325: fdread(dev, uio) /* character read routine */
326: dev_t dev;
327: struct uio *uio;
328: {
329: int unit = FDUNIT(minor(dev)) ;
330: if (unit >= NFD) return(ENXIO);
331: return(physio(fdstrategy,&fd_unit[unit].rhead,dev,B_READ,minphys,uio));
332: }
333:
334: fdwrite(dev, uio) /* character write routine */
335: dev_t dev;
336: struct uio *uio;
337: {
338: int unit = FDUNIT(minor(dev)) ;
339: if (unit >= NFD) return(ENXIO);
340: return(physio(fdstrategy,&fd_unit[unit].rhead,dev,B_WRITE,minphys,uio));
341: }
342:
343: /****************************************************************************/
344: /* fdstart */
345: /****************************************************************************/
346: fdstart(unit)
347: int unit;
348: {
349: register struct buf *dp,*bp;
350: int s;
351:
352: #ifdef FDTEST
353: printf("st%d|",unit);
354: #endif
355: s = splbio();
356: if (!fd_unit[unit].motor) {
357: fd_turnon(unit);
358: /* Wait for 1 sec */
359: timeout(fdstart,unit,hz);
360: /*DELAY(1000000);*/
361: }else
362: {
363: /* make sure drive is selected as well as on */
364: /*set_motor(unit,0);*/
365:
366: dp = &fd_unit[unit].head;
367: bp = dp->b_actf;
368: fd_retry = 0;
369: if (fd_unit[unit].reset) fd_state = 1;
370: else {
371: /* DO a RESET */
372: fd_unit[unit].reset = 1;
373: fd_state = 5;
374: }
375: fd_skip = 0;
376: #ifdef FDDEBUG
377: printf("Seek %d %d\n", bp->b_cylin, dp->b_step);
378: #endif
379: if (bp->b_cylin != fd_track) {
380: /* Seek necessary, never quite sure where head is at! */
381: out_fdc(15); /* Seek function */
382: out_fdc(unit); /* Drive number */
383: out_fdc(bp->b_cylin * dp->b_step);
384: } else fdintr(0xff);
385: }
386: splx(s);
387: }
388:
389: fd_timeout(x)
390: int x;
391: {
392: int i,j;
393: struct buf *dp,*bp;
394:
395: dp = &fd_unit[fd_drive].head;
396: bp = dp->b_actf;
397:
398: out_fdc(0x4);
399: out_fdc(fd_drive);
400: i = in_fdc();
401: printf("Timeout drive status %lx\n",i);
402:
403: out_fdc(0x8);
404: i = in_fdc();
405: j = in_fdc();
406: printf("ST0 = %lx, PCN = %lx\n",i,j);
407:
408: if (bp) badtrans(dp,bp);
409: }
410:
411: /****************************************************************************/
412: /* fdintr */
413: /****************************************************************************/
414: fdintr(unit)
415: {
416: register struct buf *dp,*bp;
417: struct buf *dpother;
418: int read,head,trac,sec,i,s,sectrac,cyl;
419: unsigned long blknum;
420: struct fd_type *ft;
421:
422: #ifdef FDTEST
423: printf("state %d, unit %d, dr %d|",fd_state,unit,fd_drive);
424: #endif
425:
426: dp = &fd_unit[fd_drive].head;
427: bp = dp->b_actf;
428: read = bp->b_flags & B_READ;
429: ft = &fd_types[FDTYPE(bp->b_dev)];
430:
431: switch (fd_state) {
432: case 1 : /* SEEK DONE, START DMA */
433: /* Make sure seek really happened*/
434: if (unit != 0xff) {
435: out_fdc(0x8);
436: i = in_fdc();
437: cyl = in_fdc();
438: if (!(i&0x20) || (cyl != bp->b_cylin*dp->b_step)) {
439: printf("Stray int ST0 = %lx, PCN = %lx:",i,cyl);
440: return;
441: }
442: }
443:
444: fd_track = bp->b_cylin;
445: at_dma(read,bp->b_un.b_addr+fd_skip,FDBLK, fd_dmachan);
446: blknum = (unsigned long)bp->b_blkno*DEV_BSIZE/FDBLK
447: + fd_skip/FDBLK;
448: sectrac = ft->sectrac;
449: sec = blknum % (sectrac * 2);
450: head = sec / sectrac;
451: sec = sec % sectrac + 1;
452:
453: if (read) out_fdc(0xE6); /* READ */
454: else out_fdc(0xC5); /* WRITE */
455: out_fdc(head << 2 | fd_drive); /* head & unit */
456: out_fdc(fd_track); /* track */
457: out_fdc(head);
458: out_fdc(sec); /* sector XXX +1? */
459: out_fdc(ft->secsize); /* sector size */
460: out_fdc(sectrac); /* sectors/track */
461: out_fdc(ft->gap); /* gap size */
462: out_fdc(ft->datalen); /* data length */
463: fd_state = 2;
464: /* XXX PARANOIA */
465: untimeout(fd_timeout,2);
466: timeout(fd_timeout,2,hz);
467: break;
468: case 2 : /* IO DONE, post-analyze */
469: untimeout(fd_timeout,2);
470: for(i=0;i<7;i++) {
471: fd_status[i] = in_fdc();
472: }
473: if (fd_status[0]&0xF8) {
474: #ifdef FDOTHER
475: printf("status0 err %d:",fd_status[0]);
476: #endif
477: goto retry;
478: }
479: /*
480: if (fd_status[1]){
481: printf("status1 err %d:",fd_status[0]);
482: goto retry;
483: }
484: if (fd_status[2]){
485: printf("status2 err %d:",fd_status[0]);
486: goto retry;
487: }
488: */
489: /* All OK */
490: if (!kernel_space(bp->b_un.b_addr+fd_skip)) {
491: /* RAW transfer */
492: if (read) bcopy(dma_bounce[fd_dmachan]->b_un.b_addr,
493: bp->b_un.b_addr+fd_skip, FDBLK);
494: }
495: fd_skip += FDBLK;
496: if (fd_skip >= bp->b_bcount) {
497: #ifdef FDTEST
498: printf("DONE %d|", bp->b_blkno);
499: #endif
500: /* ALL DONE */
501: fd_skip = 0;
502: bp->b_resid = 0;
503: dp->b_actf = bp->av_forw;
504: biodone(bp);
505: nextstate(dp);
506:
507: } else {
508: #ifdef FDDEBUG
509: printf("next|");
510: #endif
511: /* set up next transfer */
512: blknum = (unsigned long)bp->b_blkno*DEV_BSIZE/FDBLK
513: + fd_skip/FDBLK;
514: fd_state = 1;
515: bp->b_cylin = (blknum / (ft->sectrac * 2));
516: if (bp->b_cylin != fd_track) {
517: #ifdef FDTEST
518: printf("Seek|");
519: #endif
520: /* SEEK Necessary */
521: out_fdc(15); /* Seek function */
522: out_fdc(fd_drive);/* Drive number */
523: out_fdc(bp->b_cylin * dp->b_step);
524: break;
525: } else fdintr(0xff);
526: }
527: break;
528: case 3:
529: #ifdef FDOTHER
530: printf("Seek %d %d\n", bp->b_cylin, dp->b_step);
531: #endif
532: /* Seek necessary */
533: out_fdc(15); /* Seek function */
534: out_fdc(fd_drive);/* Drive number */
535: out_fdc(bp->b_cylin * dp->b_step);
536: fd_state = 1;
537: break;
538: case 4:
539: out_fdc(3); /* specify command */
540: out_fdc(0xDF);
541: out_fdc(2);
542: out_fdc(7); /* Recalibrate Function */
543: out_fdc(fd_drive);
544: fd_state = 3;
545: break;
546: case 5:
547: #ifdef FDOTHER
548: printf("**RESET**\n");
549: #endif
550: /* Try a reset, keep motor on */
551: set_motor(fd_drive,1);
552: set_motor(fd_drive,0);
553: outb(fdc+fdctl,ft->trans);
554: fd_retry++;
555: fd_state = 4;
556: break;
557: default:
558: printf("Unexpected FD int->");
559: out_fdc(0x8);
560: i = in_fdc();
561: sec = in_fdc();
562: printf("ST0 = %lx, PCN = %lx\n",i,sec);
563: out_fdc(0x4A);
564: out_fdc(fd_drive);
565: for(i=0;i<7;i++) {
566: fd_status[i] = in_fdc();
567: }
568: printf("intr status :%lx %lx %lx %lx %lx %lx %lx ",
569: fd_status[0], fd_status[1], fd_status[2], fd_status[3],
570: fd_status[4], fd_status[5], fd_status[6] );
571: break;
572: }
573: return;
574: retry:
575: switch(fd_retry) {
576: case 0: case 1:
577: case 2: case 3:
578: break;
579: case 4:
580: fd_retry++;
581: fd_state = 5;
582: fdintr(0xff);
583: return;
584: case 5: case 6: case 7:
585: break;
586: default:
587: printf("FD err %lx %lx %lx %lx %lx %lx %lx\n",
588: fd_status[0], fd_status[1], fd_status[2], fd_status[3],
589: fd_status[4], fd_status[5], fd_status[6] );
590: badtrans(dp,bp);
591: return;
592: }
593: fd_state = 1;
594: fd_retry++;
595: fdintr(0xff);
596: }
597:
598: badtrans(dp,bp)
599: struct buf *dp,*bp;
600: {
601:
602: bp->b_flags |= B_ERROR;
603: bp->b_error = EIO;
604: bp->b_resid = bp->b_bcount - fd_skip;
605: dp->b_actf = bp->av_forw;
606: fd_skip = 0;
607: biodone(bp);
608: nextstate(dp);
609:
610: }
611:
612: /*
613: nextstate : After a transfer is done, continue processing
614: requests on the current drive queue. If empty, go to
615: the other drives queue. If that is empty too, timeout
616: to turn off the current drive in 5 seconds, and go
617: to state 0 (not expecting any interrupts).
618: */
619:
620: nextstate(dp)
621: struct buf *dp;
622: {
623: struct buf *dpother;
624:
625: dpother = &fd_unit[fd_drive ? 0 : 1].head;
626: if (dp->b_actf) fdstart(fd_drive);
627: else if (dpother->b_actf) {
628: #ifdef FDTEST
629: printf("switch|");
630: #endif
631: untimeout(fd_turnoff,fd_drive);
632: timeout(fd_turnoff,fd_drive,5*hz);
633: fd_drive = 1 - fd_drive;
634: dp->b_active = 0;
635: dpother->b_active = 1;
636: fdstart(fd_drive);
637: } else {
638: #ifdef FDTEST
639: printf("off|");
640: #endif
641: untimeout(fd_turnoff,fd_drive);
642: timeout(fd_turnoff,fd_drive,5*hz);
643: fd_state = 0;
644: dp->b_active = 0;
645: }
646: }
647: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.