![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nfd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at|
Return to nfd.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at |
1.1 root 1: /*
2: * Copyright (c) 1994 Shantanu Goel
3: * All Rights Reserved.
4: *
5: * Permission to use, copy, modify and distribute this software and its
6: * documentation is hereby granted, provided that both the copyright
7: * notice and this permission notice appear in all copies of the
8: * software, derivative works or modified versions, and any portions
9: * thereof, and that both notices appear in supporting documentation.
10: *
11: * THE AUTHOR ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
12: * CONDITION. THE AUTHOR DISCLAIMS ANY LIABILITY OF ANY KIND FOR
13: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
14: */
15:
16: #include <fd.h>
17: #if NFD > 0
18: /*
19: * Floppy disk driver.
20: *
21: * Supports:
22: * 1 controller and 2 drives.
23: * Media change and automatic media detection.
24: * Arbitrarily sized read/write requests.
25: * Misaligned requests
26: * DMA above 16 Meg
27: *
28: * TODO:
29: * 1) Real probe routines for controller and drives.
30: * 2) Support for multiple controllers. The driver does
31: * not assume a single controller since all functions
32: * take the controller and/or device structure as an
33: * argument, however the probe routines limit the
34: * number of controllers and drives to 1 and 2 respectively.
35: * 3) V_VERIFY ioctl.
36: * 4) User defined diskette parameters.
37: * 5) Detect Intel 82077 or compatible and use its FIFO mode.
38: *
39: * Shantanu Goel ([email protected])
40: */
41: #include <sys/types.h>
42: #include <sys/ioctl.h>
43: #include "vm_param.h"
44: #include <kern/time_out.h>
45: #include <vm/pmap.h>
46: #include <device/param.h>
47: #include <device/buf.h>
48: #include <device/errno.h>
49: #include <chips/busses.h>
50: #include <i386/machspl.h>
51: #include <i386/pio.h>
52: #include <i386at/cram.h>
53: #include <i386at/disk.h>
54: #include <i386at/nfdreg.h>
55:
56: /*
57: * Number of drives supported by an FDC.
58: * The controller is actually capable of
59: * supporting 4 drives, however, most (all?)
60: * board implementations only support 2.
61: */
62: #define NDRIVES_PER_FDC 2
63: #define NFDC ((NFD + NDRIVES_PER_FDC - 1) / NDRIVES_PER_FDC)
64:
65: #define fdunit(dev) (((int)(dev) >> 6) & 3)
66: #define fdmedia(dev) ((int)(dev) & 3)
67:
68: #define b_cylin b_resid
69: #define B_FORMAT B_MD1
70:
71: #define SECSIZE 512
72:
73: #define DMABSIZE (18*1024) /* size of DMA bounce buffer */
74:
75: #define OP_TIMEOUT 5 /* time to wait (secs) for an
76: operation before giving up */
77: #define MOTOR_TIMEOUT 5 /* time to wait (secs) before turning
78: off an idle drive motor */
79: #define MAX_RETRIES 48 /* number of times to try
80: an I/O operation */
81:
82: #define SRTHUT 0xdf /* step rate/head unload time */
83: #define HLTND 0x02 /* head load time/dma mode */
84:
85: /*
86: * DMA controller.
87: *
88: * XXX: There should be a generic <i386/dma.h> file.
89: */
90:
91: /*
92: * Ports
93: */
94: #define DMA2_PAGE 0x81 /* channel 2, page register */
95: #define DMA2_ADDR 0x04 /* channel 2, addr register */
96: #define DMA2_COUNT 0x05 /* channel 2, count register */
97: #define DMA_STATUS 0x08 /* status register */
98: #define DMA_COMMAND 0x08 /* command register */
99: #define DMA_WREQ 0x09 /* request register */
100: #define DMA_SINGLEMSK 0x0a /* single mask register */
101: #define DMA_MODE 0x0b /* mode register */
102: #define DMA_FLIPFLOP 0x0c /* pointer flip/flop */
103: #define DMA_TEMP 0x0d /* temporary register */
104: #define DMA_MASTERCLR 0x0d /* master clear */
105: #define DMA_CLRMASK 0x0e /* clear mask register */
106: #define DMA_ALLMASK 0x0f /* all mask register */
107:
108: /*
109: * Commands
110: */
111: #define DMA_WRITE 0x46 /* write on channel 2 */
112: #define DMA_READ 0x4a /* read on channel 2 */
113:
114: /*
115: * Autoconfiguration stuff.
116: */
117: struct bus_ctlr *fdminfo[NFDC];
118: struct bus_device *fddinfo[NFD];
119: int fdstd[] = { 0 };
120: int fdprobe(), fdslave(), fdintr();
121: void fdattach();
122: struct bus_driver fddriver = {
123: fdprobe, fdslave, fdattach, 0, fdstd, "fd", fddinfo, "fdc", fdminfo
124: };
125:
126: /*
127: * Per-controller state.
128: */
129: struct fdcsoftc {
130: int sc_flags;
131: #define FDF_WANT 0x01 /* someone needs direct controller access */
132: #define FDF_RESET 0x02 /* controller needs reset */
133: #define FDF_LIMIT 0x04 /* limit transfer to a single sector */
134: #define FDF_BOUNCE 0x08 /* using bounce buffer */
135: int sc_state; /* transfer fsm */
136: caddr_t sc_addr; /* buffer address */
137: int sc_resid; /* amount left to transfer */
138: int sc_amt; /* amount currently being transferred */
139: int sc_op; /* operation being performed */
140: int sc_mode; /* DMA mode */
141: int sc_sn; /* sector number */
142: int sc_tn; /* track number */
143: int sc_cn; /* cylinder number */
144: int sc_recalerr; /* # recalibration errors */
145: int sc_seekerr; /* # seek errors */
146: int sc_ioerr; /* # i/o errors */
147: int sc_dor; /* copy of digital output register */
148: int sc_rate; /* copy of transfer rate register */
149: int sc_wticks; /* watchdog */
150: u_int sc_buf; /* buffer for transfers > 16 Meg */
151: u_char sc_cmd[9]; /* command buffer */
152: u_char sc_results[7]; /* operation results */
153: } fdcsoftc[NFDC];
154:
155: #define sc_st0 sc_results[0]
156: #define sc_st3 sc_results[0]
157: #define sc_st1 sc_results[1]
158: #define sc_pcn sc_results[1]
159: #define sc_st2 sc_results[2]
160: #define sc_c sc_results[3]
161: #define sc_h sc_results[4]
162: #define sc_r sc_results[5]
163: #define sc_n sc_results[6]
164:
165: /*
166: * Transfer states.
167: */
168: #define IDLE 0 /* controller is idle */
169: #define RESET 1 /* reset controller */
170: #define RESETDONE 2 /* reset completion interrupt */
171: #define RECAL 3 /* recalibrate drive */
172: #define RECALDONE 4 /* recalibration complete interrupt */
173: #define SEEK 5 /* perform seek on drive */
174: #define SEEKDONE 6 /* seek completion interrupt */
175: #define TRANSFER 7 /* perform transfer on drive */
176: #define TRANSFERDONE 8 /* transfer completion interrupt */
177:
178: /*
179: * Per-drive state.
180: */
181: struct fdsoftc {
182: int sc_flags;
183: #define FDF_RECAL 0x02 /* drive needs recalibration */
184: #define FDF_SEEK 0x04 /* force seek during auto-detection */
185: #define FDF_AUTO 0x08 /* performing auto-density */
186: #define FDF_AUTOFORCE 0x10 /* force auto-density */
187: #define FDF_INIT 0x20 /* drive is being initialized */
188: int sc_type; /* drive type */
189: struct fddk *sc_dk; /* diskette type */
190: int sc_cyl; /* current head position */
191: int sc_mticks; /* motor timeout */
192: } fdsoftc[NFD];
193:
194: struct buf fdtab[NFDC]; /* controller queues */
195: struct buf fdutab[NFD]; /* drive queues */
196:
197: /*
198: * Floppy drive type names.
199: */
200: char *fdnames[] = { "360K", "1.2 Meg", "720K", "1.44 Meg" };
201: #define NTYPES (sizeof(fdnames) / sizeof(fdnames[0]))
202:
203: /*
204: * Floppy diskette parameters.
205: */
206: struct fddk {
207: int dk_nspu; /* sectors/unit */
208: int dk_nspc; /* sectors/cylinder */
209: int dk_ncyl; /* cylinders/unit */
210: int dk_nspt; /* sectors/track */
211: int dk_step; /* !=0 means double track steps */
212: int dk_gap; /* read/write gap length */
213: int dk_fgap; /* format gap length */
214: int dk_rate; /* transfer rate */
215: int dk_drives; /* bit mask of drives that accept diskette */
216: char *dk_name; /* type name */
217: } fddk[] = {
218: /*
219: * NOTE: largest density for each drive type must be first so
220: * fdauto() tries it before any lower ones.
221: */
222: { 2880, 36, 80, 18, 0, 0x1b, 0x6c, 0x00, 0x08, "1.44 Meg" },
223: { 2400, 30, 80, 15, 0, 0x1b, 0x54, 0x00, 0x02, "1.2 Meg" },
224: { 1440, 18, 80, 9, 0, 0x2a, 0x50, 0x02, 0x0c, "720K" },
225: { 720, 18, 40, 9, 1, 0x23, 0x50, 0x01, 0x02, "360K" },
226: { 720, 18, 40, 9, 0, 0x2a, 0x50, 0x02, 0x01, "360K PC" }
227: };
228: #define NDKTYPES (sizeof(fddk) / sizeof(fddk[0]))
229:
230: /*
231: * For compatibility with old driver.
232: * This array is indexed by the old floppy type codes
233: * and points to the corresponding entry for that
234: * type in fddk[] above.
235: */
236: struct fddk *fdcompat[NDKTYPES];
237:
238: int fdwstart = 0;
239: int fdstrategy(), fdformat();
240: char *fderrmsg();
241: void fdwatch(), fdminphys(), fdspinup(), wakeup();
242:
243: #define FDDEBUG
244: #ifdef FDDEBUG
245: int fddebug = 0;
246: #define DEBUGF(n, stmt) { if (fddebug >= (n)) stmt; }
247: #else
248: #define DEBUGF(n, stmt)
249: #endif
250:
251: /*
252: * Probe for a controller.
253: */
254: int
255: fdprobe(xxx, um)
256: int xxx;
257: struct bus_ctlr *um;
258: {
259: struct fdcsoftc *fdc;
260:
261: if (um->unit >= NFDC) {
262: printf("fdc%d: not configured\n", um->unit);
263: return (0);
264: }
265: if (um->unit > 0) /* XXX: only 1 controller */
266: return (0);
267:
268: /*
269: * XXX: need real probe
270: */
271: take_ctlr_irq(um);
272: printf("%s%d: port 0x%x, spl %d, pic %d.\n",
273: um->name, um->unit, um->address, um->sysdep, um->sysdep1);
274:
275: /*
276: * Set up compatibility array.
277: */
278: fdcompat[0] = &fddk[2];
279: fdcompat[1] = &fddk[0];
280: fdcompat[2] = &fddk[3];
281: fdcompat[3] = &fddk[1];
282:
283: fdc = &fdcsoftc[um->unit];
284: fdc->sc_rate = -1;
285: if (!fdc->sc_buf) {
286: fdc->sc_buf = alloc_dma_mem(DMABSIZE, 64*1024);
287: if (fdc->sc_buf == 0)
288: panic("fd: alloc_dma_mem() failed");
289: }
290: fdc->sc_dor = DOR_RSTCLR | DOR_IENABLE;
291: outb(FD_DOR(um->address), fdc->sc_dor);
292: return (1);
293: }
294:
295: /*
296: * Probe for a drive.
297: */
298: int
299: fdslave(ui)
300: struct bus_device *ui;
301: {
302: struct fdsoftc *sc;
303:
304: if (ui->unit >= NFD) {
305: printf("fd%d: not configured\n", ui->unit);
306: return (0);
307: }
308: if (ui->unit > 1) /* XXX: only 2 drives */
309: return (0);
310:
311: /*
312: * Find out from CMOS if drive exists.
313: */
314: sc = &fdsoftc[ui->unit];
315: outb(CMOS_ADDR, 0x10);
316: sc->sc_type = inb(CMOS_DATA);
317: if (ui->unit == 0)
318: sc->sc_type >>= 4;
319: sc->sc_type &= 0x0f;
320: return (sc->sc_type);
321: }
322:
323: /*
324: * Attach a drive to the system.
325: */
326: void
327: fdattach(ui)
328: struct bus_device *ui;
329: {
330: struct fdsoftc *sc;
331:
332: sc = &fdsoftc[ui->unit];
333: if (--sc->sc_type >= NTYPES) {
334: printf(": unknown drive type %d", sc->sc_type);
335: ui->alive = 0;
336: return;
337: }
338: printf(": %s", fdnames[sc->sc_type]);
339: sc->sc_flags = FDF_RECAL | FDF_SEEK | FDF_AUTOFORCE;
340: }
341:
342: int
343: fdopen(dev, mode)
344: dev_t dev;
345: int mode;
346: {
347: int unit = fdunit(dev), error;
348: struct bus_device *ui;
349: struct fdsoftc *sc;
350:
351: if (unit >= NFD || (ui = fddinfo[unit]) == 0 || ui->alive == 0)
352: return (ENXIO);
353:
354: /*
355: * Start watchdog.
356: */
357: if (!fdwstart) {
358: fdwstart++;
359: timeout(fdwatch, 0, hz);
360: }
361: /*
362: * Do media detection if drive is being opened for the
363: * first time or diskette has been changed since the last open.
364: */
365: sc = &fdsoftc[unit];
366: if ((sc->sc_flags & FDF_AUTOFORCE) || fddskchg(ui)) {
367: if (error = fdauto(dev))
368: return (error);
369: sc->sc_flags &= ~FDF_AUTOFORCE;
370: }
371: return (0);
372: }
373:
374: int
375: fdclose(dev)
376: dev_t dev;
377: {
378: int s, unit = fdunit(dev);
379: struct fdsoftc *sc = &fdsoftc[unit];
380:
381: /*
382: * Wait for pending operations to complete.
383: */
384: s = splbio();
385: while (fdutab[unit].b_active) {
386: sc->sc_flags |= FDF_WANT;
387: assert_wait((event_t)sc, FALSE);
388: thread_block((void (*)())0);
389: }
390: splx(s);
391: return (0);
392: }
393:
394: int
395: fdread(dev, ior)
396: dev_t dev;
397: io_req_t ior;
398: {
399: return (block_io(fdstrategy, fdminphys, ior));
400: }
401:
402: int
403: fdwrite(dev, ior)
404: dev_t dev;
405: io_req_t ior;
406: {
407: return (block_io(fdstrategy, fdminphys, ior));
408: }
409:
410: int
411: fdgetstat(dev, flavor, status, status_count)
412: dev_t dev;
413: dev_flavor_t flavor;
414: dev_status_t status;
415: mach_msg_type_number_t *status_count;
416: {
417: switch (flavor) {
418:
419: case DEV_GET_SIZE:
420: {
421: int *info;
422: io_return_t error;
423: struct disk_parms dp;
424:
425: if (error = fdgetparms(dev, &dp))
426: return (error);
427: info = (int *)status;
428: info[DEV_GET_SIZE_DEVICE_SIZE] = dp.dp_pnumsec * SECSIZE;
429: info[DEV_GET_SIZE_RECORD_SIZE] = SECSIZE;
430: *status_count = DEV_GET_SIZE_COUNT;
431: return (D_SUCCESS);
432: }
433: case V_GETPARMS:
434: if (*status_count < (sizeof(struct disk_parms) / sizeof(int)))
435: return (D_INVALID_OPERATION);
436: *status_count = sizeof(struct disk_parms) / sizeof(int);
437: return (fdgetparms(dev, (struct disk_parms *)status));
438:
439: default:
440: return (D_INVALID_OPERATION);
441: }
442: }
443:
444: int
445: fdsetstat(dev, flavor, status, status_count)
446: dev_t dev;
447: dev_flavor_t flavor;
448: dev_status_t status;
449: mach_msg_type_number_t status_count;
450: {
451: switch (flavor) {
452:
453: case V_SETPARMS:
454: return (fdsetparms(dev, *(int *)status));
455:
456: case V_FORMAT:
457: return (fdformat(dev, (union io_arg *)status));
458:
459: case V_VERIFY:
460: /*
461: * XXX: needs to be implemented
462: */
463: return (D_SUCCESS);
464:
465: default:
466: return (D_INVALID_OPERATION);
467: }
468: }
469:
470: int
471: fddevinfo(dev, flavor, info)
472: dev_t dev;
473: int flavor;
474: char *info;
475: {
476: switch (flavor) {
477:
478: case D_INFO_BLOCK_SIZE:
479: *(int *)info = SECSIZE;
480: return (D_SUCCESS);
481:
482: default:
483: return (D_INVALID_OPERATION);
484: }
485: }
486:
487: /*
488: * Allow arbitrary transfers. Standard minphys restricts
489: * transfers to a maximum of 256K preventing us from reading
490: * an entire diskette in a single system call.
491: */
492: void
493: fdminphys(ior)
494: io_req_t ior;
495: {
496: }
497:
498: /*
499: * Return current media parameters.
500: */
501: int
502: fdgetparms(dev, dp)
503: dev_t dev;
504: struct disk_parms *dp;
505: {
506: struct fddk *dk = fdsoftc[fdunit(dev)].sc_dk;
507:
508: dp->dp_type = DPT_FLOPPY;
509: dp->dp_heads = 2;
510: dp->dp_sectors = dk->dk_nspt;
511: dp->dp_pstartsec = 0;
512: dp->dp_cyls = dk->dk_ncyl;
513: dp->dp_pnumsec = dk->dk_nspu;
514: return (0);
515: }
516:
517: /*
518: * Set media parameters.
519: */
520: int
521: fdsetparms(dev, type)
522: dev_t dev;
523: int type;
524: {
525: struct fdsoftc *sc;
526: struct fddk *dk;
527:
528: if (type < 0 || type >= NDKTYPES)
529: return (EINVAL);
530: dk = fdcompat[type];
531: sc = &fdsoftc[fdunit(dev)];
532: if ((dk->dk_drives & (1 << sc->sc_type)) == 0)
533: return (EINVAL);
534: sc->sc_dk = dk;
535: return (D_SUCCESS);
536: }
537:
538: /*
539: * Format a floppy.
540: */
541: int
542: fdformat(dev, arg)
543: dev_t dev;
544: union io_arg *arg;
545: {
546: int i, j, sect, error = 0;
547: unsigned track, num_trks;
548: struct buf *bp;
549: struct fddk *dk;
550: struct format_info *fmt;
551:
552: dk = fdsoftc[fdunit(dev)].sc_dk;
553: num_trks = arg->ia_fmt.num_trks;
554: track = arg->ia_fmt.start_trk;
555: if (num_trks == 0 || track + num_trks > (dk->dk_ncyl << 1)
556: || arg->ia_fmt.intlv >= dk->dk_nspt)
557: return (EINVAL);
558:
559: bp = (struct buf *)geteblk(SECSIZE);
560: bp->b_dev = dev;
561: bp->b_bcount = dk->dk_nspt * sizeof(struct format_info);
562: bp->b_blkno = track * dk->dk_nspt;
563:
564: while (num_trks-- > 0) {
565: /*
566: * Set up format information.
567: */
568: fmt = (struct format_info *)bp->b_un.b_addr;
569: for (i = 0; i < dk->dk_nspt; i++)
570: fmt[i].sector = 0;
571: for (i = 0, j = 0, sect = 1; i < dk->dk_nspt; i++) {
572: fmt[j].cyl = track >> 1;
573: fmt[j].head = track & 1;
574: fmt[j].sector = sect++;
575: fmt[j].secsize = 2;
576: if ((j += arg->ia_fmt.intlv) < dk->dk_nspt)
577: continue;
578: for (j -= dk->dk_nspt; j < dk->dk_nspt; j++)
579: if (fmt[j].sector == 0)
580: break;
581: }
582: bp->b_flags = B_FORMAT;
583: fdstrategy(bp);
584: biowait(bp);
585: if (bp->b_flags & B_ERROR) {
586: error = bp->b_error;
587: break;
588: }
589: bp->b_blkno += dk->dk_nspt;
590: track++;
591: }
592: bp->b_flags &= ~B_FORMAT;
593: brelse(bp);
594: return (error);
595: }
596:
597: /*
598: * Strategy routine.
599: * Enqueue a request on drive queue.
600: */
601: int
602: fdstrategy(bp)
603: struct buf *bp;
604: {
605: int unit = fdunit(bp->b_dev), s;
606: int bn, sz, maxsz;
607: struct buf *dp;
608: struct bus_device *ui = fddinfo[unit];
609: struct fddk *dk = fdsoftc[unit].sc_dk;
610:
611: bn = bp->b_blkno;
612: sz = (bp->b_bcount + SECSIZE - 1) / SECSIZE;
613: maxsz = dk->dk_nspu;
614: if (bn < 0 || bn + sz > maxsz) {
615: if (bn == maxsz) {
616: bp->b_resid = bp->b_bcount;
617: goto done;
618: }
619: sz = maxsz - bn;
620: if (sz <= 0) {
621: bp->b_error = EINVAL;
622: bp->b_flags |= B_ERROR;
623: goto done;
624: }
625: bp->b_bcount = sz * SECSIZE;
626: }
627: bp->b_cylin = bn / dk->dk_nspc;
628: dp = &fdutab[unit];
629: s = splbio();
630: disksort(dp, bp);
631: if (!dp->b_active) {
632: fdustart(ui);
633: if (!fdtab[ui->mi->unit].b_active)
634: fdstart(ui->mi);
635: }
636: splx(s);
637: return;
638: done:
639: biodone(bp);
640: return;
641: }
642:
643: /*
644: * Unit start routine.
645: * Move request from drive to controller queue.
646: */
647: int
648: fdustart(ui)
649: struct bus_device *ui;
650: {
651: struct buf *bp;
652: struct buf *dp;
653:
654: bp = &fdutab[ui->unit];
655: if (bp->b_actf == 0)
656: return;
657: dp = &fdtab[ui->mi->unit];
658: if (dp->b_actf == 0)
659: dp->b_actf = bp;
660: else
661: dp->b_actl->b_forw = bp;
662: bp->b_forw = 0;
663: dp->b_actl = bp;
664: bp->b_active++;
665: }
666:
667: /*
668: * Start output on controller.
669: */
670: int
671: fdstart(um)
672: struct bus_ctlr *um;
673: {
674: struct buf *bp;
675: struct buf *dp;
676: struct fdsoftc *sc;
677: struct fdcsoftc *fdc;
678: struct bus_device *ui;
679: struct fddk *dk;
680:
681: /*
682: * Pull a request from the controller queue.
683: */
684: dp = &fdtab[um->unit];
685: if ((bp = dp->b_actf) == 0)
686: return;
687: bp = bp->b_actf;
688:
689: fdc = &fdcsoftc[um->unit];
690: ui = fddinfo[fdunit(bp->b_dev)];
691: sc = &fdsoftc[ui->unit];
692: dk = sc->sc_dk;
693:
694: /*
695: * Mark controller busy.
696: */
697: dp->b_active++;
698:
699: /*
700: * Figure out where this request is going.
701: */
702: fdc->sc_cn = bp->b_cylin;
703: fdc->sc_sn = bp->b_blkno % dk->dk_nspc;
704: fdc->sc_tn = fdc->sc_sn / dk->dk_nspt;
705: fdc->sc_sn %= dk->dk_nspt;
706:
707: /*
708: * Set up for multi-sector transfer.
709: */
710: fdc->sc_op = ((bp->b_flags & B_FORMAT) ? CMD_FORMAT
711: : ((bp->b_flags & B_READ) ? CMD_READ : CMD_WRITE));
712: fdc->sc_mode = (bp->b_flags & B_READ) ? DMA_WRITE : DMA_READ;
713: fdc->sc_addr = bp->b_un.b_addr;
714: fdc->sc_resid = bp->b_bcount;
715: fdc->sc_wticks = 0;
716: fdc->sc_recalerr = 0;
717: fdc->sc_seekerr = 0;
718: fdc->sc_ioerr = 0;
719:
720: /*
721: * Set initial transfer state.
722: */
723: if (fdc->sc_flags & FDF_RESET)
724: fdc->sc_state = RESET;
725: else if (sc->sc_flags & FDF_RECAL)
726: fdc->sc_state = RECAL;
727: else if (sc->sc_cyl != fdc->sc_cn)
728: fdc->sc_state = SEEK;
729: else
730: fdc->sc_state = TRANSFER;
731:
732: /*
733: * Set transfer rate.
734: */
735: if (fdc->sc_rate != dk->dk_rate) {
736: fdc->sc_rate = dk->dk_rate;
737: outb(FD_RATE(um->address), fdc->sc_rate);
738: }
739: /*
740: * Turn on drive motor.
741: * Don't start I/O if drive is spinning up.
742: */
743: if (fdmotoron(ui)) {
744: timeout(fdspinup, (void *)um, hz / 2);
745: return;
746: }
747: /*
748: * Call transfer state routine to do the actual I/O.
749: */
750: fdstate(um);
751: }
752:
753: /*
754: * Interrupt routine.
755: */
756: int
757: fdintr(ctlr)
758: int ctlr;
759: {
760: int timedout;
761: u_char results[7];
762: struct buf *bp;
763: struct bus_device *ui;
764: struct fdsoftc *sc;
765: struct buf *dp = &fdtab[ctlr];
766: struct fdcsoftc *fdc = &fdcsoftc[ctlr];
767: struct bus_ctlr *um = fdminfo[ctlr];
768:
769: if (!dp->b_active) {
770: printf("fdc%d: stray interrupt\n", ctlr);
771: return;
772: }
773: timedout = fdc->sc_wticks >= OP_TIMEOUT;
774: fdc->sc_wticks = 0;
775: bp = dp->b_actf->b_actf;
776: ui = fddinfo[fdunit(bp->b_dev)];
777: sc = &fdsoftc[ui->unit];
778:
779: /*
780: * Operation timed out, terminate request.
781: */
782: if (timedout) {
783: fderror("timed out", ui);
784: fdmotoroff(ui);
785: sc->sc_flags |= FDF_RECAL;
786: bp->b_flags |= B_ERROR;
787: bp->b_error = ENXIO;
788: fddone(ui, bp);
789: return;
790: }
791: /*
792: * Read results from FDC.
793: * For transfer completion they can be read immediately.
794: * For anything else, we must issue a Sense Interrupt
795: * Status Command. We keep issuing this command till
796: * FDC returns invalid command status. The Controller Busy
797: * bit in the status register indicates completion of a
798: * read/write/format operation.
799: */
800: if (inb(FD_STATUS(um->address)) & ST_CB) {
801: if (!fdresults(um, fdc->sc_results))
802: return;
803: } else {
804: while (1) {
805: fdc->sc_cmd[0] = CMD_SENSEI;
806: if (!fdcmd(um, 1)) {
807: DEBUGF(2, printf(2, "fd%d: SENSEI failed\n"));
808: return;
809: }
810: if (!fdresults(um, results))
811: return;
812: if ((results[0] & ST0_IC) == 0x80)
813: break;
814: if ((results[0] & ST0_US) == ui->slave) {
815: fdc->sc_results[0] = results[0];
816: fdc->sc_results[1] = results[1];
817: }
818: }
819: }
820: /*
821: * Let transfer state routine handle the rest.
822: */
823: fdstate(um);
824: }
825:
826: /*
827: * Transfer finite state machine driver.
828: */
829: int
830: fdstate(um)
831: struct bus_ctlr *um;
832: {
833: int unit, max, pa, s;
834: struct buf *bp;
835: struct fdsoftc *sc;
836: struct bus_device *ui;
837: struct fddk *dk;
838: struct fdcsoftc *fdc = &fdcsoftc[um->unit];
839:
840: bp = fdtab[um->unit].b_actf->b_actf;
841: ui = fddinfo[fdunit(bp->b_dev)];
842: sc = &fdsoftc[ui->unit];
843: dk = sc->sc_dk;
844:
845: while (1) switch (fdc->sc_state) {
846:
847: case RESET:
848: /*
849: * Reset the controller.
850: */
851: fdreset(um);
852: return;
853:
854: case RESETDONE:
855: /*
856: * Reset complete.
857: * Mark all drives as needing recalibration
858: * and issue specify command.
859: */
860: for (unit = 0; unit < NFD; unit++)
861: if (fddinfo[unit] && fddinfo[unit]->alive
862: && fddinfo[unit]->mi == um)
863: fdsoftc[unit].sc_flags |= FDF_RECAL;
864: fdc->sc_cmd[0] = CMD_SPECIFY;
865: fdc->sc_cmd[1] = SRTHUT;
866: fdc->sc_cmd[2] = HLTND;
867: if (!fdcmd(um, 3))
868: return;
869: fdc->sc_flags &= ~FDF_RESET;
870: fdc->sc_state = RECAL;
871: break;
872:
873: case RECAL:
874: /*
875: * Recalibrate drive.
876: */
877: fdc->sc_state = RECALDONE;
878: fdc->sc_cmd[0] = CMD_RECAL;
879: fdc->sc_cmd[1] = ui->slave;
880: fdcmd(um, 2);
881: return;
882:
883: case RECALDONE:
884: /*
885: * Recalibration complete.
886: */
887: if ((fdc->sc_st0 & ST0_IC) || (fdc->sc_st0 & ST0_EC)) {
888: if (++fdc->sc_recalerr == 2) {
889: fderror("recalibrate failed", ui);
890: goto bad;
891: }
892: fdc->sc_state = RESET;
893: break;
894: }
895: sc->sc_flags &= ~FDF_RECAL;
896: fdc->sc_recalerr = 0;
897: sc->sc_cyl = -1;
898: fdc->sc_state = SEEK;
899: break;
900:
901: case SEEK:
902: /*
903: * Perform seek operation.
904: */
905: fdc->sc_state = SEEKDONE;
906: fdc->sc_cmd[0] = CMD_SEEK;
907: fdc->sc_cmd[1] = (fdc->sc_tn << 2) | ui->slave;
908: fdc->sc_cmd[2] = fdc->sc_cn;
909: if (dk->dk_step)
910: fdc->sc_cmd[2] <<= 1;
911: fdcmd(um, 3);
912: return;
913:
914: case SEEKDONE:
915: /*
916: * Seek complete.
917: */
918: if (dk->dk_step)
919: fdc->sc_pcn >>= 1;
920: if ((fdc->sc_st0 & ST0_IC) || (fdc->sc_st0 & ST0_SE) == 0
921: || fdc->sc_pcn != fdc->sc_cn) {
922: if (++fdc->sc_seekerr == 2) {
923: fderror("seek failed", ui);
924: goto bad;
925: }
926: fdc->sc_state = RESET;
927: break;
928: }
929: fdc->sc_seekerr = 0;
930: sc->sc_cyl = fdc->sc_pcn;
931: fdc->sc_state = TRANSFER;
932: break;
933:
934: case TRANSFER:
935: /*
936: * Perform I/O transfer.
937: */
938: fdc->sc_flags &= ~FDF_BOUNCE;
939: pa = pmap_extract(kernel_pmap, fdc->sc_addr);
940: if (fdc->sc_op == CMD_FORMAT) {
941: max = sizeof(struct format_info) * dk->dk_nspt;
942: } else if (fdc->sc_flags & FDF_LIMIT) {
943: fdc->sc_flags &= ~FDF_LIMIT;
944: max = SECSIZE;
945: } else {
946: max = (dk->dk_nspc - dk->dk_nspt * fdc->sc_tn
947: - fdc->sc_sn) * SECSIZE;
948: }
949: if (max > fdc->sc_resid)
950: max = fdc->sc_resid;
951: if (pa >= 16*1024*1024) {
952: fdc->sc_flags |= FDF_BOUNCE;
953: pa = fdc->sc_buf;
954: if (max < DMABSIZE)
955: fdc->sc_amt = max;
956: else
957: fdc->sc_amt = DMABSIZE;
958: } else {
959: int prevpa, curpa, omax;
960: vm_offset_t va;
961:
962: omax = max;
963: if (max > 65536 - (pa & 0xffff))
964: max = 65536 - (pa & 0xffff);
965: fdc->sc_amt = I386_PGBYTES - (pa & (I386_PGBYTES - 1));
966: va = (vm_offset_t)fdc->sc_addr + fdc->sc_amt;
967: prevpa = pa & ~(I386_PGBYTES - 1);
968: while (fdc->sc_amt < max) {
969: curpa = pmap_extract(kernel_pmap, va);
970: if (curpa >= 16*1024*1024
971: || curpa != prevpa + I386_PGBYTES)
972: break;
973: fdc->sc_amt += I386_PGBYTES;
974: va += I386_PGBYTES;
975: prevpa = curpa;
976: }
977: if (fdc->sc_amt > max)
978: fdc->sc_amt = max;
979: if (fdc->sc_op == CMD_FORMAT) {
980: if (fdc->sc_amt != omax) {
981: fdc->sc_flags |= FDF_BOUNCE;
982: pa = fdc->sc_buf;
983: fdc->sc_amt = omax;
984: }
985: } else if (fdc->sc_amt != fdc->sc_resid) {
986: if (fdc->sc_amt < SECSIZE) {
987: fdc->sc_flags |= FDF_BOUNCE;
988: pa = fdc->sc_buf;
989: if (omax > DMABSIZE)
990: fdc->sc_amt = DMABSIZE;
991: else
992: fdc->sc_amt = omax;
993: } else
994: fdc->sc_amt &= ~(SECSIZE - 1);
995: }
996: }
997:
998: DEBUGF(2, printf("fd%d: TRANSFER: amt %d cn %d tn %d sn %d\n",
999: ui->unit, fdc->sc_amt, fdc->sc_cn,
1000: fdc->sc_tn, fdc->sc_sn + 1));
1001:
1002: if ((fdc->sc_flags & FDF_BOUNCE) && fdc->sc_op != CMD_READ) {
1003: fdc->sc_flags &= ~FDF_BOUNCE;
1004: bcopy(fdc->sc_addr, (caddr_t)phystokv(fdc->sc_buf),
1005: fdc->sc_amt);
1006: }
1007: /*
1008: * Set up DMA.
1009: */
1010: s = sploff();
1011: outb(DMA_SINGLEMSK, 0x04 | 0x02);
1012: outb(DMA_FLIPFLOP, 0);
1013: outb(DMA_MODE, fdc->sc_mode);
1014: outb(DMA2_ADDR, pa);
1015: outb(DMA2_ADDR, pa >> 8);
1016: outb(DMA2_PAGE, pa >> 16);
1017: outb(DMA2_COUNT, fdc->sc_amt - 1);
1018: outb(DMA2_COUNT, (fdc->sc_amt - 1) >> 8);
1019: outb(DMA_SINGLEMSK, 0x02);
1020: splon(s);
1021:
1022: /*
1023: * Issue command to FDC.
1024: */
1025: fdc->sc_state = TRANSFERDONE;
1026: fdc->sc_cmd[0] = fdc->sc_op;
1027: fdc->sc_cmd[1] = (fdc->sc_tn << 2) | ui->slave;
1028: if (fdc->sc_op == CMD_FORMAT) {
1029: fdc->sc_cmd[2] = 0x02;
1030: fdc->sc_cmd[3] = dk->dk_nspt;
1031: fdc->sc_cmd[4] = dk->dk_fgap;
1032: fdc->sc_cmd[5] = 0xda;
1033: fdcmd(um, 6);
1034: } else {
1035: fdc->sc_cmd[2] = fdc->sc_cn;
1036: fdc->sc_cmd[3] = fdc->sc_tn;
1037: fdc->sc_cmd[4] = fdc->sc_sn + 1;
1038: fdc->sc_cmd[5] = 0x02;
1039: fdc->sc_cmd[6] = dk->dk_nspt;
1040: fdc->sc_cmd[7] = dk->dk_gap;
1041: fdc->sc_cmd[8] = 0xff;
1042: fdcmd(um, 9);
1043: }
1044: return;
1045:
1046: case TRANSFERDONE:
1047: /*
1048: * Transfer complete.
1049: */
1050: if (fdc->sc_st0 & ST0_IC) {
1051: fdc->sc_ioerr++;
1052: if (sc->sc_flags & FDF_AUTO) {
1053: /*
1054: * Give up on second try if
1055: * media detection is in progress.
1056: */
1057: if (fdc->sc_ioerr == 2)
1058: goto bad;
1059: fdc->sc_state = RECAL;
1060: break;
1061: }
1062: if (fdc->sc_ioerr == MAX_RETRIES) {
1063: fderror(fderrmsg(ui), ui);
1064: goto bad;
1065: }
1066: /*
1067: * Give up immediately on write-protected diskettes.
1068: */
1069: if (fdc->sc_st1 & ST1_NW) {
1070: fderror("write-protected diskette", ui);
1071: goto bad;
1072: }
1073: /*
1074: * Limit transfer to a single sector.
1075: */
1076: fdc->sc_flags |= FDF_LIMIT;
1077: /*
1078: * Every fourth attempt recalibrate the drive.
1079: * Every eight attempt reset the controller.
1080: * Also, every eighth attempt inform user
1081: * about the error.
1082: */
1083: if (fdc->sc_ioerr & 3)
1084: fdc->sc_state = TRANSFER;
1085: else if (fdc->sc_ioerr & 7)
1086: fdc->sc_state = RECAL;
1087: else {
1088: fdc->sc_state = RESET;
1089: fderror(fderrmsg(ui), ui);
1090: }
1091: break;
1092: }
1093: /*
1094: * Transfer completed successfully.
1095: * Advance counters/pointers, and if more
1096: * is left, initiate I/O.
1097: */
1098: if (fdc->sc_flags & FDF_BOUNCE) {
1099: fdc->sc_flags &= ~FDF_BOUNCE;
1100: bcopy((caddr_t)phystokv(fdc->sc_buf), fdc->sc_addr,
1101: fdc->sc_amt);
1102: }
1103: if ((fdc->sc_resid -= fdc->sc_amt) == 0) {
1104: bp->b_resid = 0;
1105: fddone(ui, bp);
1106: return;
1107: }
1108: fdc->sc_state = TRANSFER;
1109: fdc->sc_ioerr = 0;
1110: fdc->sc_addr += fdc->sc_amt;
1111: if (fdc->sc_op == CMD_FORMAT) {
1112: fdc->sc_sn = 0;
1113: if (fdc->sc_tn == 1) {
1114: fdc->sc_tn = 0;
1115: fdc->sc_cn++;
1116: fdc->sc_state = SEEK;
1117: } else
1118: fdc->sc_tn = 1;
1119: } else {
1120: fdc->sc_sn += fdc->sc_amt / SECSIZE;
1121: while (fdc->sc_sn >= dk->dk_nspt) {
1122: fdc->sc_sn -= dk->dk_nspt;
1123: if (fdc->sc_tn == 1) {
1124: fdc->sc_tn = 0;
1125: fdc->sc_cn++;
1126: fdc->sc_state = SEEK;
1127: } else
1128: fdc->sc_tn = 1;
1129: }
1130: }
1131: break;
1132:
1133: default:
1134: printf("fd%d: invalid state\n", ui->unit);
1135: panic("fdstate");
1136: /*NOTREACHED*/
1137: }
1138: bad:
1139: bp->b_flags |= B_ERROR;
1140: bp->b_error = EIO;
1141: sc->sc_flags |= FDF_RECAL;
1142: fddone(ui, bp);
1143: }
1144:
1145: /*
1146: * Terminate current request and start
1147: * any others that are queued.
1148: */
1149: int
1150: fddone(ui, bp)
1151: struct bus_device *ui;
1152: struct buf *bp;
1153: {
1154: struct bus_ctlr *um = ui->mi;
1155: struct fdsoftc *sc = &fdsoftc[ui->unit];
1156: struct fdcsoftc *fdc = &fdcsoftc[um->unit];
1157: struct buf *dp = &fdtab[um->unit];
1158:
1159: DEBUGF(1, printf("fd%d: fddone()\n", ui->unit));
1160:
1161: /*
1162: * Remove this request from queue.
1163: */
1164: if (bp) {
1165: fdutab[ui->unit].b_actf = bp->b_actf;
1166: biodone(bp);
1167: bp = &fdutab[ui->unit];
1168: dp->b_actf = bp->b_forw;
1169: } else
1170: bp = &fdutab[ui->unit];
1171:
1172: /*
1173: * Mark controller and drive idle.
1174: */
1175: dp->b_active = 0;
1176: bp->b_active = 0;
1177: fdc->sc_state = IDLE;
1178: sc->sc_mticks = 0;
1179: fdc->sc_flags &= ~(FDF_LIMIT|FDF_BOUNCE);
1180:
1181: /*
1182: * Start up other requests.
1183: */
1184: fdustart(ui);
1185: fdstart(um);
1186:
1187: /*
1188: * Wakeup anyone waiting for drive or controller.
1189: */
1190: if (sc->sc_flags & FDF_WANT) {
1191: sc->sc_flags &= ~FDF_WANT;
1192: wakeup((void *)sc);
1193: }
1194: if (fdc->sc_flags & FDF_WANT) {
1195: fdc->sc_flags &= ~FDF_WANT;
1196: wakeup((void *)fdc);
1197: }
1198: }
1199:
1200: /*
1201: * Check if diskette change has occured since the last open.
1202: */
1203: int
1204: fddskchg(ui)
1205: struct bus_device *ui;
1206: {
1207: int s, dir;
1208: struct fdsoftc *sc = &fdsoftc[ui->unit];
1209: struct bus_ctlr *um = ui->mi;
1210: struct fdcsoftc *fdc = &fdcsoftc[um->unit];
1211:
1212: /*
1213: * Get access to controller.
1214: */
1215: s = splbio();
1216: while (fdtab[um->unit].b_active) {
1217: fdc->sc_flags |= FDF_WANT;
1218: assert_wait((event_t)fdc, FALSE);
1219: thread_block((void (*)())0);
1220: }
1221: fdtab[um->unit].b_active = 1;
1222: fdutab[ui->unit].b_active = 1;
1223:
1224: /*
1225: * Turn on drive motor and read digital input register.
1226: */
1227: if (fdmotoron(ui)) {
1228: timeout(wakeup, (void *)fdc, hz / 2);
1229: assert_wait((event_t)fdc, FALSE);
1230: thread_block((void (*)())0);
1231: }
1232: dir = inb(FD_DIR(um->address));
1233: fddone(ui, NULL);
1234: splx(s);
1235:
1236: if (dir & DIR_DSKCHG) {
1237: printf("fd%d: diskette change detected\n", ui->unit);
1238: sc->sc_flags |= FDF_SEEK;
1239: return (1);
1240: }
1241: return (0);
1242: }
1243:
1244: /*
1245: * Do media detection.
1246: */
1247: int
1248: fdauto(dev)
1249: dev_t dev;
1250: {
1251: int i, error = 0;
1252: struct buf *bp;
1253: struct bus_device *ui = fddinfo[fdunit(dev)];
1254: struct fdsoftc *sc = &fdsoftc[ui->unit];
1255: struct fddk *dk, *def = 0;
1256:
1257: sc->sc_flags |= FDF_AUTO;
1258: bp = (struct buf *)geteblk(SECSIZE);
1259: for (i = 0, dk = fddk; i < NDKTYPES; i++, dk++) {
1260: if ((dk->dk_drives & (1 << sc->sc_type)) == 0)
1261: continue;
1262: if (def == 0)
1263: def = dk;
1264: sc->sc_dk = dk;
1265: bp->b_flags = B_READ;
1266: bp->b_dev = dev;
1267: bp->b_bcount = SECSIZE;
1268: if (sc->sc_flags & FDF_SEEK) {
1269: sc->sc_flags &= ~FDF_SEEK;
1270: bp->b_blkno = 100;
1271: } else
1272: bp->b_blkno = 0;
1273: fdstrategy(bp);
1274: biowait(bp);
1275: if ((bp->b_flags & B_ERROR) == 0 || bp->b_error == ENXIO)
1276: break;
1277: }
1278: if (i == NDKTYPES) {
1279: printf("fd%d: couldn't detect type, using %s\n",
1280: ui->unit, def->dk_name);
1281: sc->sc_dk = def;
1282: } else if ((bp->b_flags & B_ERROR) == 0)
1283: printf("fd%d: detected %s\n", ui->unit, sc->sc_dk->dk_name);
1284: else
1285: error = ENXIO;
1286: sc->sc_flags &= ~FDF_AUTO;
1287: brelse(bp);
1288: return (error);
1289: }
1290:
1291: /*
1292: * Turn on drive motor and select drive.
1293: */
1294: int
1295: fdmotoron(ui)
1296: struct bus_device *ui;
1297: {
1298: int bit;
1299: struct bus_ctlr *um = ui->mi;
1300: struct fdcsoftc *fdc = &fdcsoftc[um->unit];
1301:
1302: bit = 1 << (ui->slave + 4);
1303: if ((fdc->sc_dor & bit) == 0) {
1304: fdc->sc_dor &= ~3;
1305: fdc->sc_dor |= bit | ui->slave;
1306: outb(FD_DOR(um->address), fdc->sc_dor);
1307: return (1);
1308: }
1309: if ((fdc->sc_dor & 3) != ui->slave) {
1310: fdc->sc_dor &= ~3;
1311: fdc->sc_dor |= ui->slave;
1312: outb(FD_DOR(um->address), fdc->sc_dor);
1313: }
1314: return (0);
1315: }
1316:
1317: /*
1318: * Turn off drive motor.
1319: */
1320: int
1321: fdmotoroff(ui)
1322: struct bus_device *ui;
1323: {
1324: struct bus_ctlr *um = ui->mi;
1325: struct fdcsoftc *fdc = &fdcsoftc[um->unit];
1326:
1327: fdc->sc_dor &= ~(1 << (ui->slave + 4));
1328: outb(FD_DOR(um->address), fdc->sc_dor);
1329: }
1330:
1331: /*
1332: * This routine is invoked via timeout() by fdstart()
1333: * to call fdstate() at splbio.
1334: */
1335: void
1336: fdspinup(um)
1337: struct bus_ctlr *um;
1338: {
1339: int s;
1340:
1341: s = splbio();
1342: fdstate(um);
1343: splx(s);
1344: }
1345:
1346: /*
1347: * Watchdog routine.
1348: * Check for hung operations.
1349: * Turn off motor of idle drives.
1350: */
1351: void
1352: fdwatch()
1353: {
1354: int unit, s;
1355: struct bus_device *ui;
1356:
1357: timeout(fdwatch, 0, hz);
1358: s = splbio();
1359: for (unit = 0; unit < NFDC; unit++)
1360: if (fdtab[unit].b_active
1361: && ++fdcsoftc[unit].sc_wticks == OP_TIMEOUT)
1362: fdintr(unit);
1363: for (unit = 0; unit < NFD; unit++) {
1364: if ((ui = fddinfo[unit]) == 0 || ui->alive == 0)
1365: continue;
1366: if (fdutab[unit].b_active == 0
1367: && (fdcsoftc[ui->mi->unit].sc_dor & (1 << (ui->slave + 4)))
1368: && ++fdsoftc[unit].sc_mticks == MOTOR_TIMEOUT)
1369: fdmotoroff(ui);
1370: }
1371: splx(s);
1372: }
1373:
1374: /*
1375: * Print an error message.
1376: */
1377: int
1378: fderror(msg, ui)
1379: char *msg;
1380: struct bus_device *ui;
1381: {
1382: struct fdcsoftc *fdc = &fdcsoftc[ui->mi->unit];
1383:
1384: printf("fd%d: %s, %sing cn %d tn %d sn %d\n", ui->unit, msg,
1385: (fdc->sc_op == CMD_READ ? "read"
1386: : (fdc->sc_op == CMD_WRITE ? "writ" : "formatt")),
1387: fdc->sc_cn, fdc->sc_tn, fdc->sc_sn + 1);
1388: }
1389:
1390: /*
1391: * Return an error message for an I/O error.
1392: */
1393: char *
1394: fderrmsg(ui)
1395: struct bus_device *ui;
1396: {
1397: struct fdcsoftc *fdc = &fdcsoftc[ui->mi->unit];
1398:
1399: if (fdc->sc_st1 & ST1_EC)
1400: return ("invalid sector");
1401: if (fdc->sc_st1 & ST1_DE)
1402: return ("CRC error");
1403: if (fdc->sc_st1 & ST1_OR)
1404: return ("DMA overrun");
1405: if (fdc->sc_st1 & ST1_ND)
1406: return ("sector not found");
1407: if (fdc->sc_st1 & ST1_NW)
1408: return ("write-protected diskette");
1409: if (fdc->sc_st1 & ST1_MA)
1410: return ("missing address mark");
1411: return ("hard error");
1412: }
1413:
1414: /*
1415: * Output a command to FDC.
1416: */
1417: int
1418: fdcmd(um, n)
1419: struct bus_ctlr *um;
1420: int n;
1421: {
1422: int i, j;
1423: struct fdcsoftc *fdc = &fdcsoftc[um->unit];
1424:
1425: for (i = j = 0; i < 200; i++) {
1426: if ((inb(FD_STATUS(um->address)) & (ST_RQM|ST_DIO)) != ST_RQM)
1427: continue;
1428: outb(FD_DATA(um->address), fdc->sc_cmd[j++]);
1429: if (--n == 0)
1430: return (1);
1431: }
1432: /*
1433: * Controller is not responding, reset it.
1434: */
1435: DEBUGF(1, printf("fdc%d: fdcmd() failed\n", um->unit));
1436: fdreset(um);
1437: return (0);
1438: }
1439:
1440: /*
1441: * Read results from FDC.
1442: */
1443: int
1444: fdresults(um, rp)
1445: struct bus_ctlr *um;
1446: u_char *rp;
1447: {
1448: int i, j, status;
1449:
1450: for (i = j = 0; i < 200; i++) {
1451: status = inb(FD_STATUS(um->address));
1452: if ((status & ST_RQM) == 0)
1453: continue;
1454: if ((status & ST_DIO) == 0)
1455: return (j);
1456: if (j == 7)
1457: break;
1458: *rp++ = inb(FD_DATA(um->address));
1459: j++;
1460: }
1461: /*
1462: * Controller is not responding, reset it.
1463: */
1464: DEBUGF(1, printf("fdc%d: fdresults() failed\n", um->unit));
1465: fdreset(um);
1466: return (0);
1467: }
1468:
1469: /*
1470: * Reset controller.
1471: */
1472: int
1473: fdreset(um)
1474: struct bus_ctlr *um;
1475: {
1476: struct fdcsoftc *fdc = &fdcsoftc[um->unit];
1477:
1478: outb(FD_DOR(um->address), fdc->sc_dor & ~(DOR_RSTCLR|DOR_IENABLE));
1479: fdc->sc_state = RESETDONE;
1480: fdc->sc_flags |= FDF_RESET;
1481: outb(FD_DOR(um->address), fdc->sc_dor);
1482: }
1483:
1484: #endif /* NFD > 0 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.