![[BACK]](/icons/back.gif){kind=icon}
Return to fdd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / dev / i386 / pc|
Return to fdd.c CVS log | Up to [local] / prex-old / dev / i386 / pc |
1.1 nbrk 1: /*-
2: * Copyright (c) 2005-2006, Kohsuke Ohtani
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. Neither the name of the author nor the names of any co-contributors
14: * may be used to endorse or promote products derived from this software
15: * without specific prior written permission.
16: *
17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27: * SUCH DAMAGE.
28: */
29:
30: /*
31: * fdd.c - Floppy disk driver
32: */
33:
34: /*
35: * State transition table:
36: *
37: * State Interrupt Timeout Error
38: * --------- --------- --------- ---------
39: * Off N/A On N/A
40: * On N/A Reset N/A
41: * Reset Recal Off N/A
42: * Recal Seek Off Off
43: * Seek IO Reset Off
44: * IO Ready Reset Off
45: * Ready N/A Off N/A
46: *
47: */
48:
49: #include <driver.h>
50: #include <delay.h>
51: #include <cpu.h>
52:
53: #include "dma.h"
54:
55: /* #define DEBUG_FDD */
56:
57: #ifdef DEBUG_FDD
58: #define fdd_printf(fmt, args...) printk("%s: " fmt, ## args)
59: #else
60: #define fdd_printf(fmt...) do {} while (0)
61: #endif
62:
63: #define FDD_IRQ 6 /* IRQ6 */
64: #define FDD_DMA 2 /* DMA2 */
65:
66: #define SECTOR_SIZE 512
67: #define TRACK_SIZE (SECTOR_SIZE * 18)
68: #define INVALID_TRACK -1
69:
70: /* I/O ports */
71: #define FDC_DOR 0x3f2 /* Digital output register */
72: #define FDC_MSR 0x3f4 /* Main status register (in) */
73: #define FDC_DSR 0x3f4 /* Data rate select register (out) */
74: #define FDC_DAT 0x3f5 /* Data register */
75: #define FDC_DIR 0x3f7 /* Digital input register (in) */
76: #define FDC_CCR 0x3f7 /* Configuration control register (out) */
77:
78: /* Command bytes */
79: #define CMD_SPECIFY 0x03 /* Specify drive timing */
80: #define CMD_DRVSTS 0x04
81: #define CMD_WRITE 0xc5 /* Sector write, multi-track */
82: #define CMD_READ 0xe6 /* Sector read */
83: #define CMD_RECAL 0x07 /* Recalibrate */
84: #define CMD_SENSE 0x08 /* Sense interrupt status */
85: #define CMD_FORMAT 0x4d /* Format track */
86: #define CMD_SEEK 0x0f /* Seek track */
87: #define CMD_VERSION 0x10 /* FDC version */
88:
89: /* Floppy Drive Geometries */
90: #define FDG_HEADS 2
91: #define FDG_TRACKS 80
92: #define FDG_SECTORS 18
93: #define FDG_GAP3FMT 0x54
94: #define FDG_GAP3RW 0x1b
95:
96: /* FDC state */
97: #define FDS_OFF 0 /* Motor off */
98: #define FDS_ON 1 /* Motor on */
99: #define FDS_RESET 2 /* Reset */
100: #define FDS_RECAL 3 /* Recalibrate */
101: #define FDS_SEEK 4 /* Seek */
102: #define FDS_IO 5 /* Read/write */
103: #define FDS_READY 6 /* Ready */
104:
105: static void fdc_timeout(u_long);
106: static void fdc_recal(void);
107: static void fdc_off(void);
108: static void fdc_io(void);
109:
110: static int fdd_init(void);
111: static int fdd_open(device_t, int);
112: static int fdd_close(device_t);
113: static int fdd_read(device_t, char *, size_t *, int);
114: static int fdd_write(device_t, char *, size_t *, int);
115:
116: /*
117: * I/O request
118: */
119: struct io_req {
120: int cmd;
121: int nr_retry;
122: int blkno;
123: u_long blksz;
124: void *buf;
125: int errno;
126: };
127: typedef struct io_req *ioreq_t;
128:
129: /* I/O command */
130: #define IO_NONE 0
131: #define IO_READ 1
132: #define IO_WRITE 2
133: #define IO_FORMAT 3 /* not supported */
134: #define IO_CANCEL 4
135:
136: /*
137: * Driver structure
138: */
139: struct driver fdd_drv = {
140: /* name */ "Floppy Disk Controller",
141: /* order */ 5,
142: /* init */ fdd_init,
143: };
144:
145: static struct devio fdd_io = {
146: /* open */ fdd_open,
147: /* close */ fdd_close,
148: /* read */ fdd_read,
149: /* write */ fdd_write,
150: /* ioctl */ NULL,
151: /* event */ NULL,
152: };
153:
154: static device_t fdd_dev; /* Device object */
155: static int fdd_irq; /* Interrupt handle */
156: static int fdd_dma; /* DMA handle */
157: static int nr_open; /* Open count */
158: static struct timer fdd_tmr; /* Timer */
159:
160: static int fdc_stat; /* Current state */
161: static struct io_req ioreq; /* I/O request */
162: static void *read_buf; /* DMA buffer for read (1 track) */
163: static void *write_buf; /* DMA buffer for write (1 sector) */
164: static u_char result[7]; /* Result from fdc */
165: static struct event io_event = EVENT_INIT(io_event, "fdd");
166: static int track_cache; /* Current track of read buffer */
167:
168: /*
169: * Send data to FDC
170: * Return -1 on failure
171: */
172: static int
173: fdc_out(u_char dat)
174: {
175: int i;
176:
177: for (i = 0; i < 100000; i++) {
178: if ((inb_p(FDC_MSR) & 0xc0) == 0x80) {
179: outb_p(dat, FDC_DAT);
180: return 0;
181: }
182: }
183: printk("fdc: timeout msr=%x\n", inb(FDC_MSR));
184: return -1;
185: }
186:
187: /* Return number of result bytes */
188: static int
189: fdc_result(void)
190: {
191: int i, msr, index = 0;
192:
193: for (i = 0; i < 50000; i++) { /* timeout=500msec */
194: msr = inb_p(FDC_MSR);
195: if ((msr & 0xd0) == 0x80) {
196: return index;
197: }
198: if ((msr & 0xd0) == 0xd0) {
199: if (index > 6) {
200: printk("fdc: overrun\n");
201: return -1;
202: }
203: result[index++] = inb_p(FDC_DAT);
204: /*
205: fdd_printf("result[%d]=%x\n", index - 1,
206: result[index - 1]);
207: */
208: }
209: delay_usec(10);
210: }
211: printk("fdc: timeout\n");
212: return -1;
213: }
214:
215: static void
216: fdc_error(int errno)
217: {
218: printk("fdc: errno=%d\n", errno);
219:
220: dma_stop(fdd_dma);
221: ioreq.errno = errno;
222: sched_wakeup(&io_event);
223: fdc_off();
224: }
225:
226: /*
227: * Stop motor. (No interrupt)
228: */
229: static void
230: fdc_off(void)
231: {
232: fdd_printf("motor off\n");
233:
234: fdc_stat = FDS_OFF;
235: timer_stop(&fdd_tmr);
236: outb_p(0x0c, FDC_DOR);
237: }
238:
239: /*
240: * Start motor and wait 250msec. (No interrupt)
241: */
242: static void
243: fdc_on(void)
244: {
245: fdd_printf("motor on\n");
246:
247: fdc_stat = FDS_ON;
248: outb_p(0x1c, FDC_DOR);
249: timer_callout(&fdd_tmr, fdc_timeout, 0, 250);
250: }
251:
252: /*
253: * Reset FDC and wait an intterupt.
254: * Timeout is 500msec.
255: */
256: static void
257: fdc_reset(void)
258: {
259: fdd_printf("reset\n");
260:
261: fdc_stat = FDS_RESET;
262: timer_callout(&fdd_tmr, fdc_timeout, 0, 500);
263: outb_p(0x18, FDC_DOR); /* Motor0 enable, DMA enable */
264: delay_usec(20); /* Wait 20 usec while reset */
265: outb_p(0x1c, FDC_DOR); /* Clear reset */
266: }
267:
268: /*
269: * Recalibrate FDC and wait an interrupt.
270: * Timeout is 5sec.
271: */
272: static void
273: fdc_recal(void)
274: {
275: fdd_printf("recalibrate\n");
276:
277: fdc_stat = FDS_RECAL;
278: timer_callout(&fdd_tmr, fdc_timeout, 0, 5000);
279: fdc_out(CMD_RECAL);
280: fdc_out(0); /* Drive 0 */
281: }
282:
283: /*
284: * Seek FDC and wait an interrupt.
285: * Timeout is 4sec.
286: */
287: static void
288: fdc_seek(void)
289: {
290: u_int head, track;
291:
292: fdd_printf("seek\n");
293: fdc_stat = FDS_SEEK;
294: head = (ioreq.blkno % (FDG_SECTORS * FDG_HEADS)) / FDG_SECTORS;
295: track = ioreq.blkno / (FDG_SECTORS * FDG_HEADS);
296:
297: timer_callout(&fdd_tmr, fdc_timeout, 0, 4000);
298:
299: fdc_out(CMD_SPECIFY); /* specify command parameter */
300: fdc_out(0xd1); /* Step rate = 3msec, Head unload time = 16msec */
301: fdc_out(0x02); /* Head load time = 2msec, Dma on (0) */
302:
303: fdc_out(CMD_SEEK);
304: fdc_out(head << 2);
305: fdc_out(track);
306: }
307:
308: /*
309: * Read/write data and wait an interrupt.
310: * Timeout is 2sec.
311: */
312: static void
313: fdc_io(void)
314: {
315: u_int head, track, sect;
316: u_long io_size;
317: int read;
318:
319: fdd_printf("read/write\n");
320: fdc_stat = FDS_IO;
321:
322: head = (ioreq.blkno % (FDG_SECTORS * FDG_HEADS)) / FDG_SECTORS;
323: track = ioreq.blkno / (FDG_SECTORS * FDG_HEADS);
324: sect = ioreq.blkno % FDG_SECTORS + 1;
325: io_size = ioreq.blksz * SECTOR_SIZE;
326: read = (ioreq.cmd == IO_READ) ? 1 : 0;
327:
328: fdd_printf("hd=%x trk=%x sec=%x size=%d read=%d\n",
329: head, track, sect, io_size, read);
330:
331: timer_callout(&fdd_tmr, fdc_timeout, 0, 2000);
332:
333: dma_setup(fdd_dma, (u_long) ioreq.buf, io_size, read);
334:
335: /* Send command */
336: fdc_out(read ? CMD_READ : CMD_WRITE);
337: fdc_out(head << 2);
338: fdc_out(track);
339: fdc_out(head);
340: fdc_out(sect);
341: fdc_out(2); /* sector size = 512 bytes */
342: fdc_out(FDG_SECTORS);
343: fdc_out(FDG_GAP3RW);
344: fdc_out(0xff);
345: }
346:
347: /*
348: * Wake up iorequester.
349: * FDC motor is set to off after 5sec.
350: */
351: static void
352: fdc_ready(void)
353: {
354: fdd_printf("wakeup requester\n");
355:
356: fdc_stat = FDS_READY;
357: sched_wakeup(&io_event);
358: timer_callout(&fdd_tmr, fdc_timeout, 0, 5000);
359: }
360:
361: /*
362: * Timeout handler
363: */
364: static void
365: fdc_timeout(u_long unused)
366: {
367: fdd_printf("fdc_stat=%d\n", fdc_stat);
368:
369: switch (fdc_stat) {
370: case FDS_ON:
371: fdc_reset();
372: break;
373: case FDS_RESET:
374: case FDS_RECAL:
375: printk("fdc: reset/recal timeout\n");
376: fdc_error(EIO);
377: break;
378: case FDS_SEEK:
379: case FDS_IO:
380: printk("fdc: seek/io timeout retry=%d\n", ioreq.nr_retry);
381: if (++ioreq.nr_retry <= 3)
382: fdc_reset();
383: else
384: fdc_error(EIO);
385: break;
386: case FDS_READY:
387: fdc_off();
388: break;
389: default:
390: panic("fdc: unknown timeout\n");
391: }
392: }
393:
394: /*
395: * Interrupt service routine
396: * Do not change the fdc_stat in isr.
397: */
398: static int
399: fdc_isr(int irq)
400: {
401: fdd_printf("fdc_stat=%d\n", fdc_stat);
402:
403: timer_stop(&fdd_tmr);
404: switch (fdc_stat) {
405: case FDS_IO:
406: dma_stop(fdd_dma);
407: /* Fall through */
408: case FDS_RESET:
409: case FDS_RECAL:
410: case FDS_SEEK:
411: if (ioreq.cmd == IO_NONE) {
412: printk("fdc: invalid interrupt\n");
413: timer_stop(&fdd_tmr);
414: break;
415: }
416: return INT_CONTINUE;
417: case FDS_OFF:
418: break;
419: default:
420: printk("fdc: unknown interrupt\n");
421: break;
422: }
423: return 0;
424: }
425:
426: /*
427: * Interrupt service thread
428: * This is called when command completion.
429: */
430: static void
431: fdc_ist(int irq)
432: {
433: int i;
434:
435: fdd_printf("fdc_stat=%d\n", fdc_stat);
436: if (ioreq.cmd == IO_NONE)
437: return;
438:
439: switch (fdc_stat) {
440: case FDS_RESET:
441: /* clear output buffer */
442: for (i = 0; i < 4; i++) {
443: fdc_out(CMD_SENSE);
444: fdc_result();
445: }
446: fdc_recal();
447: break;
448: case FDS_RECAL:
449: fdc_out(CMD_SENSE);
450: fdc_result();
451: if ((result[0] & 0xf8) != 0x20) {
452: printk("fdc: recal error\n");
453: fdc_error(EIO);
454: break;
455: }
456: fdc_seek();
457: break;
458: case FDS_SEEK:
459: fdc_out(CMD_SENSE);
460: fdc_result();
461: if ((result[0] & 0xf8) != 0x20) {
462: printk("fdc: seek error\n");
463: if (++ioreq.nr_retry <= 3)
464: fdc_reset();
465: else
466: fdc_error(EIO);
467: break;
468: }
469: fdc_io();
470: break;
471: case FDS_IO:
472: fdc_result();
473: if ((result[0] & 0xd8) != 0x00) {
474: printk("fdc: i/o error st0=%x st1=%x st2=%x st3=%x retry=%d\n",
475: result[0], result[1], result[2], result[3],
476: ioreq.nr_retry);
477: if (++ioreq.nr_retry <= 3)
478: fdc_reset();
479: else
480: fdc_error(EIO);
481: break;
482: }
483: fdd_printf("i/o complete\n");
484: fdc_ready();
485: break;
486: case FDS_OFF:
487: /* Ignore */
488: break;
489: default:
490: ASSERT(0);
491: }
492: return;
493: }
494:
495: /*
496: * Open
497: */
498: static int
499: fdd_open(device_t dev, int mode)
500: {
501:
502: nr_open++;
503: fdd_printf("nr_open=%d\n", nr_open);
504: return 0;
505: }
506:
507: /*
508: * Close
509: */
510: static int
511: fdd_close(device_t dev)
512: {
513: fdd_printf("dev=%x\n", dev);
514:
515: if (nr_open < 1)
516: return EINVAL;
517: nr_open--;
518: if (nr_open == 0) {
519: ioreq.cmd = IO_NONE;
520: fdc_off();
521: }
522: return 0;
523: }
524:
525: /*
526: * Common routine for read/write
527: */
528: static int
529: fdd_rw(int cmd, char *buf, u_long blksz, int blkno)
530: {
531: int err;
532:
533: fdd_printf("cmd=%x buf=%x blksz=%d blkno=%x\n", cmd, buf, blksz, blkno);
534: ioreq.cmd = cmd;
535: ioreq.nr_retry = 0;
536: ioreq.blkno = blkno;
537: ioreq.blksz = blksz;
538: ioreq.buf = buf;
539: ioreq.errno = 0;
540:
541: sched_lock();
542: if (fdc_stat == FDS_OFF)
543: fdc_on();
544: else
545: fdc_seek();
546:
547: if (sched_sleep(&io_event) == SLP_INTR)
548: err = EINTR;
549: else
550: err = ioreq.errno;
551:
552: sched_unlock();
553: return err;
554: }
555:
556: /*
557: * Read
558: *
559: * Error:
560: * EINTR ... Interrupted by signal
561: * EIO ... Low level I/O error
562: * ENXIO ... Write protected
563: * EFAULT ... No physical memory is mapped to buffer
564: */
565: static int
566: fdd_read(device_t dev, char *buf, size_t *nbyte, int blkno)
567: {
568: char *kbuf;
569: int i, track, sect, nr_sect, err;
570:
571: fdd_printf("read buf=%x nbyte=%d blkno=%x\n", buf, *nbyte, blkno);
572:
573: /* Check overrun */
574: if (blkno > FDG_HEADS * FDG_TRACKS * FDG_SECTORS)
575: return EIO;
576:
577: /* Translate buffer address to kernel address */
578: kbuf = kmem_map(buf, *nbyte);
579: if (kbuf == NULL)
580: return EFAULT;
581:
582: nr_sect = *nbyte / SECTOR_SIZE;
583: err = 0;
584: for (i = 0; i < nr_sect; i++) {
585: /* Translate the logical sector# to logical track#/sector#. */
586: track = blkno / FDG_SECTORS;
587: sect = blkno % FDG_SECTORS;
588: /*
589: * If target sector does not exist in buffer,
590: * read 1 track (18 sectors) at once.
591: */
592: if (track != track_cache) {
593: err = fdd_rw(IO_READ, read_buf, FDG_SECTORS,
594: track * FDG_SECTORS);
595: if (err) {
596: track_cache = INVALID_TRACK;
597: break;
598: }
599: track_cache = track;
600: }
601: memcpy(kbuf, (char *)read_buf + sect * SECTOR_SIZE,
602: SECTOR_SIZE);
603: blkno++;
604: kbuf += SECTOR_SIZE;
605: }
606: *nbyte = i * SECTOR_SIZE;
607: return err;
608: }
609:
610: /*
611: * Write
612: *
613: * Error:
614: * EINTR ... Interrupted by signal
615: * EIO ... Low level I/O error
616: * ENXIO ... Write protected
617: * EFAULT ... No physical memory is mapped to buffer
618: */
619: static int
620: fdd_write(device_t dev, char *buf, size_t *nbyte, int blkno)
621: {
622: char *kbuf, *wbuf;
623: int i, track, sect, nr_sect, err;
624:
625: fdd_printf("write buf=%x nbyte=%d blkno=%x\n", buf, *nbyte, blkno);
626:
627: /* Check overrun */
628: if (blkno > FDG_HEADS * FDG_TRACKS * FDG_SECTORS)
629: return EIO;
630:
631: /* Translate buffer address to kernel address */
632: kbuf = kmem_map(buf, *nbyte);
633: if (kbuf == NULL)
634: return EFAULT;
635:
636: nr_sect = *nbyte / SECTOR_SIZE;
637: err = 0;
638: for (i = 0; i < nr_sect; i++) {
639: /* Translate the logical sector# to track#/sector#. */
640: track = blkno / FDG_SECTORS;
641: sect = blkno % FDG_SECTORS;
642: /*
643: * If target sector exists in read buffer, use it as
644: * write buffer to keep the cache cohrency.
645: */
646: if (track == track_cache)
647: wbuf = (char *)read_buf + sect * SECTOR_SIZE;
648: else
649: wbuf = write_buf;
650:
651: memcpy(wbuf, kbuf, SECTOR_SIZE);
652: err = fdd_rw(IO_WRITE, wbuf, 1, blkno);
653: if (err) {
654: track_cache = INVALID_TRACK;
655: break;
656: }
657: blkno++;
658: kbuf += SECTOR_SIZE;
659: }
660: *nbyte = i * SECTOR_SIZE;
661:
662: fdd_printf("fdd_write err=%d\n", err);
663: return err;
664: }
665:
666: /*
667: * Initialize
668: */
669: static int
670: fdd_init(void)
671: {
672: char *buf;
673: int i;
674:
675: fdd_printf("fdd_init\n");
676: if (inb(FDC_MSR) == 0xff) {
677: printk("Floppy drive not found!\n");
678: return -1;
679: }
680:
681: /* Create device object */
682: fdd_dev = device_create(&fdd_io, "fd0", DF_BLK);
683: ASSERT(fdd_dev);
684:
685: /*
686: * Allocate physical pages for DMA buffer.
687: * Buffer: 1 track for read, 1 sector for write.
688: */
689: buf = dma_alloc(TRACK_SIZE + SECTOR_SIZE);
690:
691: ASSERT(buf);
692: read_buf = buf;
693: write_buf = buf + TRACK_SIZE;
694:
695: /* Allocate DMA */
696: fdd_dma = dma_attach(FDD_DMA);
697: ASSERT(fdd_dma != -1);
698:
699: /* Allocate IRQ */
700: fdd_irq = irq_attach(FDD_IRQ, IPL_BLOCK, 0, fdc_isr, fdc_ist);
701: ASSERT(fdd_irq != -1);
702:
703: timer_init(&fdd_tmr);
704: fdc_stat = FDS_OFF;
705: ioreq.cmd = IO_NONE;
706: track_cache = INVALID_TRACK;
707:
708: /* Reset FDC */
709: outb_p(0x08, FDC_DOR);
710: delay_usec(20);
711: outb_p(0x0C, FDC_DOR);
712:
713: /* Data rate 500kbps */
714: outb_p(0x00, FDC_CCR);
715:
716: /* clear output buffer */
717: for (i = 0; i < 4; i++) {
718: fdc_out(CMD_SENSE);
719: fdc_result();
720: }
721: return 0;
722: }