![[BACK]](/icons/back.gif){kind=icon}
Return to fd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc64 / dev|
Return to fd.c CVS log | Up to [local] / sys / arch / sparc64 / dev |
1.1 nbrk 1: /* $OpenBSD: fd.c,v 1.18 2007/06/20 18:15:46 deraadt Exp $ */
2: /* $NetBSD: fd.c,v 1.112 2003/08/07 16:29:35 agc Exp $ */
3:
4: /*-
5: * Copyright (c) 2000 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Paul Kranenburg.
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: * 3. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by the NetBSD
22: * Foundation, Inc. and its contributors.
23: * 4. Neither the name of The NetBSD Foundation nor the names of its
24: * contributors may be used to endorse or promote products derived
25: * from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: * POSSIBILITY OF SUCH DAMAGE.
38: */
39:
40: /*-
41: * Copyright (c) 1990 The Regents of the University of California.
42: * All rights reserved.
43: *
44: * This code is derived from software contributed to Berkeley by
45: * Don Ahn.
46: *
47: * Redistribution and use in source and binary forms, with or without
48: * modification, are permitted provided that the following conditions
49: * are met:
50: * 1. Redistributions of source code must retain the above copyright
51: * notice, this list of conditions and the following disclaimer.
52: * 2. Redistributions in binary form must reproduce the above copyright
53: * notice, this list of conditions and the following disclaimer in the
54: * documentation and/or other materials provided with the distribution.
55: * 3. Neither the name of the University nor the names of its contributors
56: * may be used to endorse or promote products derived from this software
57: * without specific prior written permission.
58: *
59: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
60: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
61: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
62: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
63: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
64: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
65: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
66: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
67: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
68: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
69: * SUCH DAMAGE.
70: *
71: * @(#)fd.c 7.4 (Berkeley) 5/25/91
72: */
73:
74: /*-
75: * Copyright (c) 1993, 1994, 1995 Charles M. Hannum.
76: * Copyright (c) 1995 Paul Kranenburg.
77: *
78: * This code is derived from software contributed to Berkeley by
79: * Don Ahn.
80: *
81: * Redistribution and use in source and binary forms, with or without
82: * modification, are permitted provided that the following conditions
83: * are met:
84: * 1. Redistributions of source code must retain the above copyright
85: * notice, this list of conditions and the following disclaimer.
86: * 2. Redistributions in binary form must reproduce the above copyright
87: * notice, this list of conditions and the following disclaimer in the
88: * documentation and/or other materials provided with the distribution.
89: * 3. All advertising materials mentioning features or use of this software
90: * must display the following acknowledgement:
91: * This product includes software developed by the University of
92: * California, Berkeley and its contributors.
93: * 4. Neither the name of the University nor the names of its contributors
94: * may be used to endorse or promote products derived from this software
95: * without specific prior written permission.
96: *
97: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
98: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
99: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
100: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
101: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
102: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
103: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
104: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
105: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
106: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
107: * SUCH DAMAGE.
108: *
109: * @(#)fd.c 7.4 (Berkeley) 5/25/91
110: */
111:
112: #include <sys/param.h>
113: #include <sys/systm.h>
114: #include <sys/timeout.h>
115: #include <sys/kernel.h>
116: #include <sys/file.h>
117: #include <sys/ioctl.h>
118: #include <sys/conf.h>
119: #include <sys/device.h>
120: #include <sys/disklabel.h>
121: #include <sys/disk.h>
122: #include <sys/buf.h>
123: #include <sys/malloc.h>
124: #include <sys/proc.h>
125: #include <sys/uio.h>
126: #include <sys/mtio.h>
127: #include <sys/stat.h>
128: #include <sys/syslog.h>
129: #include <sys/queue.h>
130:
131: #include <dev/cons.h>
132:
133: #include <uvm/uvm_extern.h>
134:
135: #include <machine/autoconf.h>
136: #include <machine/conf.h>
137: #include <machine/intr.h>
138: #include <machine/ioctl_fd.h>
139:
140: #include <sparc64/dev/auxioreg.h>
141: #include <sparc64/dev/auxiovar.h>
142: #include <sparc64/dev/ebusreg.h>
143: #include <sparc64/dev/ebusvar.h>
144: #include <sparc64/dev/fdreg.h>
145: #include <sparc64/dev/fdvar.h>
146:
147: #define FDUNIT(dev) ((minor(dev) / MAXPARTITIONS) / 8)
148: #define FDTYPE(dev) ((minor(dev) / MAXPARTITIONS) % 8)
149:
150: #define FTC_FLIP \
151: do { \
152: auxio_fd_control(AUXIO_LED_FTC); \
153: auxio_fd_control(0); \
154: } while (0)
155:
156: /* XXX misuse a flag to identify format operation */
157: #define B_FORMAT B_XXX
158:
159: #ifdef FD_DEBUG
160: int fdc_debug = 0;
161: #endif
162:
163: enum fdc_state {
164: DEVIDLE = 0,
165: MOTORWAIT, /* 1 */
166: DOSEEK, /* 2 */
167: SEEKWAIT, /* 3 */
168: SEEKTIMEDOUT, /* 4 */
169: SEEKCOMPLETE, /* 5 */
170: DOIO, /* 6 */
171: IOCOMPLETE, /* 7 */
172: IOTIMEDOUT, /* 8 */
173: IOCLEANUPWAIT, /* 9 */
174: IOCLEANUPTIMEDOUT,/*10 */
175: DORESET, /* 11 */
176: RESETCOMPLETE, /* 12 */
177: RESETTIMEDOUT, /* 13 */
178: DORECAL, /* 14 */
179: RECALWAIT, /* 15 */
180: RECALTIMEDOUT, /* 16 */
181: RECALCOMPLETE, /* 17 */
182: DODSKCHG, /* 18 */
183: DSKCHGWAIT, /* 19 */
184: DSKCHGTIMEDOUT, /* 20 */
185: };
186:
187: /* software state, per controller */
188: struct fdc_softc {
189: struct device sc_dev; /* boilerplate */
190: bus_space_tag_t sc_bustag;
191:
192: struct timeout fdctimeout_to;
193: struct timeout fdcpseudointr_to;
194:
195: struct fd_softc *sc_fd[4]; /* pointers to children */
196: TAILQ_HEAD(drivehead, fd_softc) sc_drives;
197: enum fdc_state sc_state;
198: int sc_flags;
199: #define FDC_EBUS 0x01
200: #define FDC_NEEDHEADSETTLE 0x02
201: #define FDC_EIS 0x04
202: #define FDC_NEEDMOTORWAIT 0x08
203: #define FDC_NOEJECT 0x10
204: int sc_errors; /* number of retries so far */
205: int sc_overruns; /* number of DMA overruns */
206: int sc_cfg; /* current configuration */
207: struct fdcio sc_io;
208: #define sc_handle sc_io.fdcio_handle
209: #define sc_itask sc_io.fdcio_itask
210: #define sc_istatus sc_io.fdcio_istatus
211: #define sc_data sc_io.fdcio_data
212: #define sc_tc sc_io.fdcio_tc
213: #define sc_nstat sc_io.fdcio_nstat
214: #define sc_status sc_io.fdcio_status
215:
216: void *sc_sicookie; /* softintr(9) cookie */
217: };
218:
219: /* controller driver configuration */
220: int fdcmatch_sbus(struct device *, void *, void *);
221: int fdcmatch_ebus(struct device *, void *, void *);
222: void fdcattach_sbus(struct device *, struct device *, void *);
223: void fdcattach_ebus(struct device *, struct device *, void *);
224:
225: int fdcattach(struct fdc_softc *, int);
226:
227: struct cfattach fdc_sbus_ca = {
228: sizeof(struct fdc_softc), fdcmatch_sbus, fdcattach_sbus
229: };
230:
231: struct cfattach fdc_ebus_ca = {
232: sizeof(struct fdc_softc), fdcmatch_ebus, fdcattach_ebus
233: };
234:
235: struct cfdriver fdc_cd = {
236: NULL, "fdc", DV_DULL
237: };
238:
239: __inline struct fd_type *fd_dev_to_type(struct fd_softc *, dev_t);
240:
241: /* The order of entries in the following table is important -- BEWARE! */
242: struct fd_type fd_types[] = {
243: { 18,2,36,2,0xff,0xcf,0x1b,0x54,80,2880,1,FDC_500KBPS, "1.44MB" }, /* 1.44MB diskette */
244: { 9,2,18,2,0xff,0xdf,0x2a,0x50,80,1440,1,FDC_250KBPS, "720KB" }, /* 3.5" 720kB diskette */
245: { 9,2,18,2,0xff,0xdf,0x2a,0x50,40, 720,2,FDC_250KBPS, "360KB/x" }, /* 360kB in 720kB drive */
246: { 8,2,16,3,0xff,0xdf,0x35,0x74,77,1232,1,FDC_500KBPS, "1.2MB/NEC" } /* 1.2 MB japanese format */
247: };
248:
249: /* software state, per disk (with up to 4 disks per ctlr) */
250: struct fd_softc {
251: struct device sc_dv; /* generic device info */
252: struct disk sc_dk; /* generic disk info */
253:
254: struct fd_type *sc_deftype; /* default type descriptor */
255: struct fd_type *sc_type; /* current type descriptor */
256:
257: struct timeout sc_motoron_to;
258: struct timeout sc_motoroff_to;
259:
260: daddr64_t sc_blkno; /* starting block number */
261: int sc_bcount; /* byte count left */
262: int sc_skip; /* bytes already transferred */
263: int sc_nblks; /* number of blocks currently transferring */
264: int sc_nbytes; /* number of bytes currently transferring */
265:
266: int sc_drive; /* physical unit number */
267: int sc_flags;
268: #define FD_OPEN 0x01 /* it's open */
269: #define FD_MOTOR 0x02 /* motor should be on */
270: #define FD_MOTOR_WAIT 0x04 /* motor coming up */
271: int sc_cylin; /* where we think the head is */
272: int sc_opts; /* user-set options */
273:
274: void *sc_sdhook; /* shutdownhook cookie */
275:
276: TAILQ_ENTRY(fd_softc) sc_drivechain;
277: int sc_ops; /* I/O ops since last switch */
278: struct buf sc_q; /* pending I/O requests */
279: };
280:
281: /* floppy driver configuration */
282: int fdmatch(struct device *, void *, void *);
283: void fdattach(struct device *, struct device *, void *);
284:
285: struct cfattach fd_ca = {
286: sizeof(struct fd_softc), fdmatch, fdattach
287: };
288:
289: struct cfdriver fd_cd = {
290: NULL, "fd", DV_DISK
291: };
292:
293: void fdgetdisklabel(dev_t);
294: int fd_get_parms(struct fd_softc *);
295: void fdstrategy(struct buf *);
296: void fdstart(struct fd_softc *);
297: int fdprint(void *, const char *);
298:
299: struct dkdriver fddkdriver = { fdstrategy };
300:
301: struct fd_type *fd_nvtotype(char *, int, int);
302: void fd_set_motor(struct fdc_softc *fdc);
303: void fd_motor_off(void *arg);
304: void fd_motor_on(void *arg);
305: int fdcresult(struct fdc_softc *fdc);
306: int fdc_wrfifo(struct fdc_softc *fdc, u_char x);
307: void fdcstart(struct fdc_softc *fdc);
308: void fdcstatus(struct fdc_softc *fdc, char *s);
309: void fdc_reset(struct fdc_softc *fdc);
310: int fdc_diskchange(struct fdc_softc *fdc);
311: void fdctimeout(void *arg);
312: void fdcpseudointr(void *arg);
313: int fdchwintr(void *);
314: void fdcswintr(void *);
315: int fdcstate(struct fdc_softc *);
316: void fdcretry(struct fdc_softc *fdc);
317: void fdfinish(struct fd_softc *fd, struct buf *bp);
318: int fdformat(dev_t, struct fd_formb *, struct proc *);
319: void fd_do_eject(struct fd_softc *);
320: static int fdconf(struct fdc_softc *);
321:
322: int
323: fdcmatch_sbus(parent, match, aux)
324: struct device *parent;
325: void *match, *aux;
326: {
327: struct sbus_attach_args *sa = aux;
328:
329: return (strcmp("SUNW,fdtwo", sa->sa_name) == 0);
330: }
331:
332: void
333: fdcattach_sbus(parent, self, aux)
334: struct device *parent, *self;
335: void *aux;
336: {
337: struct fdc_softc *fdc = (void *)self;
338: struct sbus_attach_args *sa = aux;
339:
340: if (sa->sa_nintr == 0) {
341: printf(": no interrupt line configured\n");
342: return;
343: }
344:
345: if (auxio_fd_control(0) != 0) {
346: printf(": can't attach before auxio\n");
347: return;
348: }
349:
350: fdc->sc_bustag = sa->sa_bustag;
351:
352: if (sbus_bus_map(sa->sa_bustag,
353: sa->sa_slot, sa->sa_offset, sa->sa_size,
354: BUS_SPACE_MAP_LINEAR, 0, &fdc->sc_handle) != 0) {
355: printf(": cannot map control registers\n");
356: return;
357: }
358:
359: if (strcmp(getpropstring(sa->sa_node, "status"), "disabled") == 0) {
360: printf(": no drives attached\n");
361: return;
362: }
363:
364: if (getproplen(sa->sa_node, "manual") >= 0)
365: fdc->sc_flags |= FDC_NOEJECT;
366:
367: if (fdcattach(fdc, sa->sa_pri) != 0)
368: bus_space_unmap(sa->sa_bustag, fdc->sc_handle, sa->sa_size);
369: }
370:
371: int
372: fdcmatch_ebus(parent, match, aux)
373: struct device *parent;
374: void *match, *aux;
375: {
376: struct ebus_attach_args *ea = aux;
377:
378: return (strcmp("fdthree", ea->ea_name) == 0);
379: }
380:
381: void
382: fdcattach_ebus(parent, self, aux)
383: struct device *parent, *self;
384: void *aux;
385: {
386: struct fdc_softc *fdc = (void *)self;
387: struct ebus_attach_args *ea = aux;
388:
389: if (ea->ea_nintrs == 0) {
390: printf(": no interrupt line configured\n");
391: return;
392: }
393:
394: if (ea->ea_nregs < 3) {
395: printf(": expected 3 registers, only got %d\n",
396: ea->ea_nregs);
397: return;
398: }
399:
400: if (ea->ea_nvaddrs > 0) {
401: if (bus_space_map(ea->ea_memtag, ea->ea_vaddrs[0], 0,
402: BUS_SPACE_MAP_PROMADDRESS, &fdc->sc_handle) != 0) {
403: printf(": can't map control registers\n");
404: return;
405: }
406: fdc->sc_bustag = ea->ea_memtag;
407: } else if (ebus_bus_map(ea->ea_memtag, 0,
408: EBUS_PADDR_FROM_REG(&ea->ea_regs[0]),
409: ea->ea_regs[0].size, 0, 0, &fdc->sc_handle) == 0) {
410: fdc->sc_bustag = ea->ea_memtag;
411: } else if (ebus_bus_map(ea->ea_iotag, 0,
412: EBUS_PADDR_FROM_REG(&ea->ea_regs[0]),
413: ea->ea_regs[0].size, 0, 0, &fdc->sc_handle) == 0) {
414: fdc->sc_bustag = ea->ea_iotag;
415: } else {
416: printf(": can't map control registers\n");
417: return;
418: }
419:
420: if (strcmp(getpropstring(ea->ea_node, "status"), "disabled") == 0) {
421: printf(": no drives attached\n");
422: return;
423: }
424:
425: fdc->sc_flags |= FDC_EBUS;
426:
427: if (getproplen(ea->ea_node, "manual") >= 0)
428: fdc->sc_flags |= FDC_NOEJECT;
429:
430: /* XXX unmapping if it fails */
431: fdcattach(fdc, ea->ea_intrs[0]);
432: }
433:
434: /*
435: * Arguments passed between fdcattach and fdprobe.
436: */
437: struct fdc_attach_args {
438: int fa_drive;
439: struct fd_type *fa_deftype;
440: };
441:
442: /*
443: * Print the location of a disk drive (called just before attaching the
444: * the drive). If `fdc' is not NULL, the drive was found but was not
445: * in the system config file; print the drive name as well.
446: * Return QUIET (config_find ignores this if the device was configured) to
447: * avoid printing `fdN not configured' messages.
448: */
449: int
450: fdprint(aux, fdc)
451: void *aux;
452: const char *fdc;
453: {
454: register struct fdc_attach_args *fa = aux;
455:
456: if (!fdc)
457: printf(" drive %d", fa->fa_drive);
458: return (QUIET);
459: }
460:
461: /*
462: * Configure several parameters and features on the FDC.
463: * Return 0 on success.
464: */
465: static int
466: fdconf(fdc)
467: struct fdc_softc *fdc;
468: {
469: int vroom;
470:
471: if (fdc_wrfifo(fdc, NE7CMD_DUMPREG) || fdcresult(fdc) != 10)
472: return (-1);
473:
474: /*
475: * dumpreg[7] seems to be a motor-off timeout; set it to whatever
476: * the PROM thinks is appropriate.
477: */
478: if ((vroom = fdc->sc_status[7]) == 0)
479: vroom = 0x64;
480:
481: /* Configure controller to use FIFO and Implied Seek */
482: if (fdc_wrfifo(fdc, NE7CMD_CFG) != 0)
483: return (-1);
484: if (fdc_wrfifo(fdc, vroom) != 0)
485: return (-1);
486: if (fdc_wrfifo(fdc, fdc->sc_cfg) != 0)
487: return (-1);
488: if (fdc_wrfifo(fdc, 0) != 0) /* PRETRK */
489: return (-1);
490: /* No result phase for the NE7CMD_CFG command */
491:
492: /* Lock configuration across soft resets. */
493: if (fdc_wrfifo(fdc, NE7CMD_LOCK | CFG_LOCK) != 0 ||
494: fdcresult(fdc) != 1) {
495: #ifdef FD_DEBUG
496: printf("fdconf: CFGLOCK failed");
497: #endif
498: return (-1);
499: }
500:
501: return (0);
502: #if 0
503: if (fdc_wrfifo(fdc, NE7CMD_VERSION) == 0 &&
504: fdcresult(fdc) == 1 && fdc->sc_status[0] == 0x90) {
505: if (fdc_debug)
506: printf("[version cmd]");
507: }
508: #endif
509: }
510:
511: int
512: fdcattach(fdc, pri)
513: struct fdc_softc *fdc;
514: int pri;
515: {
516: struct fdc_attach_args fa;
517: int drive_attached;
518:
519: timeout_set(&fdc->fdctimeout_to, fdctimeout, fdc);
520: timeout_set(&fdc->fdcpseudointr_to, fdcpseudointr, fdc);
521:
522: fdc->sc_state = DEVIDLE;
523: fdc->sc_itask = FDC_ITASK_NONE;
524: fdc->sc_istatus = FDC_ISTATUS_NONE;
525: fdc->sc_flags |= FDC_EIS | FDC_NEEDMOTORWAIT;
526: TAILQ_INIT(&fdc->sc_drives);
527:
528: /*
529: * Configure controller; enable FIFO, Implied seek, no POLL mode?.
530: * Note: CFG_EFIFO is active-low, initial threshold value: 8
531: */
532: fdc->sc_cfg = CFG_EIS|/*CFG_EFIFO|*/CFG_POLL|(8 & CFG_THRHLD_MASK);
533: if (fdconf(fdc) != 0) {
534: printf("\n%s: no drives attached\n", fdc->sc_dev.dv_xname);
535: return (-1);
536: }
537:
538: if (bus_intr_establish(fdc->sc_bustag, pri, IPL_BIO,
539: 0, fdchwintr, fdc, fdc->sc_dev.dv_xname) == NULL) {
540: printf("\n%s: cannot register interrupt handler\n",
541: fdc->sc_dev.dv_xname);
542: return (-1);
543: }
544:
545: fdc->sc_sicookie = softintr_establish(IPL_BIO, fdcswintr, fdc);
546: if (fdc->sc_sicookie == NULL) {
547: printf("\n%s: cannot register soft interrupt handler\n",
548: fdc->sc_dev.dv_xname);
549: return (-1);
550: }
551:
552: printf(" softpri %d", PIL_FDSOFT);
553: if (fdc->sc_flags & FDC_NOEJECT)
554: printf(": manual eject");
555: printf("\n");
556:
557: /* physical limit: four drives per controller. */
558: drive_attached = 0;
559: for (fa.fa_drive = 0; fa.fa_drive < 4; fa.fa_drive++) {
560: fa.fa_deftype = NULL; /* unknown */
561: fa.fa_deftype = &fd_types[0]; /* XXX */
562: if (config_found(&fdc->sc_dev, (void *)&fa, fdprint) != NULL)
563: drive_attached = 1;
564: }
565:
566: if (drive_attached == 0) {
567: /* XXX - dis-establish interrupts here */
568: /* return (-1); */
569: }
570:
571: return (0);
572: }
573:
574: int
575: fdmatch(parent, match, aux)
576: struct device *parent;
577: void *match;
578: void *aux;
579: {
580: struct fdc_softc *fdc = (void *)parent;
581: bus_space_tag_t t = fdc->sc_bustag;
582: bus_space_handle_t h = fdc->sc_handle;
583: struct fdc_attach_args *fa = aux;
584: int drive = fa->fa_drive;
585: int n, ok;
586:
587: if (drive > 0)
588: /* XXX - for now, punt on more than one drive */
589: return (0);
590:
591: /* select drive and turn on motor */
592: bus_space_write_1(t, h, FDREG77_DOR,
593: drive | FDO_FRST | FDO_MOEN(drive));
594: /* wait for motor to spin up */
595: delay(250000);
596:
597: fdc->sc_nstat = 0;
598: fdc_wrfifo(fdc, NE7CMD_RECAL);
599: fdc_wrfifo(fdc, drive);
600:
601: /* Wait for recalibration to complete */
602: for (n = 0; n < 10000; n++) {
603: u_int8_t v;
604:
605: delay(1000);
606: v = bus_space_read_1(t, h, FDREG77_MSR);
607: if ((v & (NE7_RQM|NE7_DIO|NE7_CB)) == NE7_RQM) {
608: /* wait a bit longer till device *really* is ready */
609: delay(100000);
610: if (fdc_wrfifo(fdc, NE7CMD_SENSEI))
611: break;
612: if (fdcresult(fdc) == 1 && fdc->sc_status[0] == 0x80)
613: /*
614: * Got `invalid command'; we interpret it
615: * to mean that the re-calibrate hasn't in
616: * fact finished yet
617: */
618: continue;
619: break;
620: }
621: }
622: n = fdc->sc_nstat;
623: #ifdef FD_DEBUG
624: if (fdc_debug) {
625: int i;
626: printf("fdprobe: %d stati:", n);
627: for (i = 0; i < n; i++)
628: printf(" 0x%x", fdc->sc_status[i]);
629: printf("\n");
630: }
631: #endif
632: ok = (n == 2 && (fdc->sc_status[0] & 0xf8) == 0x20) ? 1 : 0;
633:
634: /* deselect drive and turn motor off */
635: bus_space_write_1(t, h, FDREG77_DOR, FDO_FRST | FDO_DS);
636:
637: return (ok);
638: }
639:
640: /*
641: * Controller is working, and drive responded. Attach it.
642: */
643: void
644: fdattach(parent, self, aux)
645: struct device *parent, *self;
646: void *aux;
647: {
648: struct fdc_softc *fdc = (void *)parent;
649: struct fd_softc *fd = (void *)self;
650: struct fdc_attach_args *fa = aux;
651: struct fd_type *type = fa->fa_deftype;
652: int drive = fa->fa_drive;
653:
654: timeout_set(&fd->sc_motoron_to, fd_motor_on, fd);
655: timeout_set(&fd->sc_motoroff_to, fd_motor_off, fd);
656:
657: /* XXX Allow `flags' to override device type? */
658:
659: if (type)
660: printf(": %s %d cyl, %d head, %d sec\n", type->name,
661: type->tracks, type->heads, type->sectrac);
662: else
663: printf(": density unknown\n");
664:
665: fd->sc_cylin = -1;
666: fd->sc_drive = drive;
667: fd->sc_deftype = type;
668: fdc->sc_fd[drive] = fd;
669:
670: fdc_wrfifo(fdc, NE7CMD_SPECIFY);
671: fdc_wrfifo(fdc, type->steprate);
672: /* XXX head load time == 6ms */
673: fdc_wrfifo(fdc, 6 | NE7_SPECIFY_NODMA);
674:
675: /*
676: * Initialize and attach the disk structure.
677: */
678: fd->sc_dk.dk_name = fd->sc_dv.dv_xname;
679: fd->sc_dk.dk_driver = &fddkdriver;
680: disk_attach(&fd->sc_dk);
681:
682: /* Make sure the drive motor gets turned off at shutdown time. */
683: fd->sc_sdhook = shutdownhook_establish(fd_motor_off, fd);
684: }
685:
686: __inline struct fd_type *
687: fd_dev_to_type(fd, dev)
688: struct fd_softc *fd;
689: dev_t dev;
690: {
691: int type = FDTYPE(dev);
692:
693: if (type > (sizeof(fd_types) / sizeof(fd_types[0])))
694: return (NULL);
695: return (type ? &fd_types[type - 1] : fd->sc_deftype);
696: }
697:
698: void
699: fdstrategy(bp)
700: register struct buf *bp; /* IO operation to perform */
701: {
702: struct fd_softc *fd;
703: int unit = FDUNIT(bp->b_dev);
704: int sz;
705: int s;
706:
707: /* Valid unit, controller, and request? */
708: if (unit >= fd_cd.cd_ndevs ||
709: (fd = fd_cd.cd_devs[unit]) == 0 ||
710: bp->b_blkno < 0 ||
711: (((bp->b_bcount % FD_BSIZE(fd)) != 0 ||
712: (bp->b_blkno * DEV_BSIZE) % FD_BSIZE(fd) != 0) &&
713: (bp->b_flags & B_FORMAT) == 0)) {
714: bp->b_error = EINVAL;
715: goto bad;
716: }
717:
718: /* If it's a null transfer, return immediately. */
719: if (bp->b_bcount == 0)
720: goto done;
721:
722: sz = howmany(bp->b_bcount, DEV_BSIZE);
723:
724: if (bp->b_blkno + sz > (fd->sc_type->size * DEV_BSIZE) / FD_BSIZE(fd)) {
725: sz = (fd->sc_type->size * DEV_BSIZE) / FD_BSIZE(fd)
726: - bp->b_blkno;
727: if (sz == 0) {
728: /* If exactly at end of disk, return EOF. */
729: bp->b_resid = bp->b_bcount;
730: goto done;
731: }
732: if (sz < 0) {
733: /* If past end of disk, return EINVAL. */
734: bp->b_error = EINVAL;
735: goto bad;
736: }
737: /* Otherwise, truncate request. */
738: bp->b_bcount = sz << DEV_BSHIFT;
739: }
740:
741: bp->b_cylinder = (bp->b_blkno * DEV_BSIZE) /
742: (FD_BSIZE(fd) * fd->sc_type->seccyl);
743:
744: #ifdef FD_DEBUG
745: if (fdc_debug > 1)
746: printf("fdstrategy: b_blkno %lld b_bcount %d blkno %lld cylin %d\n",
747: bp->b_blkno, bp->b_bcount,
748: fd->sc_blkno, bp->b_cylinder);
749: #endif
750:
751: /* Queue transfer on drive, activate drive and controller if idle. */
752: s = splbio();
753: disksort(&fd->sc_q, bp);
754: timeout_del(&fd->sc_motoroff_to); /* a good idea */
755: if (!fd->sc_q.b_active)
756: fdstart(fd);
757: #ifdef DIAGNOSTIC
758: else {
759: struct fdc_softc *fdc = (void *)fd->sc_dv.dv_parent;
760: if (fdc->sc_state == DEVIDLE) {
761: printf("fdstrategy: controller inactive\n");
762: fdcstart(fdc);
763: }
764: }
765: #endif
766: splx(s);
767: return;
768:
769: bad:
770: bp->b_flags |= B_ERROR;
771: done:
772: /* Toss transfer; we're done early. */
773: s = splbio();
774: biodone(bp);
775: splx(s);
776: }
777:
778: void
779: fdstart(fd)
780: struct fd_softc *fd;
781: {
782: struct fdc_softc *fdc = (void *)fd->sc_dv.dv_parent;
783: int active = !TAILQ_EMPTY(&fdc->sc_drives);
784:
785: /* Link into controller queue. */
786: fd->sc_q.b_active = 1;
787: TAILQ_INSERT_TAIL(&fdc->sc_drives, fd, sc_drivechain);
788:
789: /* If controller not already active, start it. */
790: if (!active)
791: fdcstart(fdc);
792: }
793:
794: void
795: fdfinish(fd, bp)
796: struct fd_softc *fd;
797: struct buf *bp;
798: {
799: struct fdc_softc *fdc = (void *)fd->sc_dv.dv_parent;
800:
801: /*
802: * Move this drive to the end of the queue to give others a `fair'
803: * chance. We only force a switch if N operations are completed while
804: * another drive is waiting to be serviced, since there is a long motor
805: * startup delay whenever we switch.
806: */
807: if (TAILQ_NEXT(fd, sc_drivechain) != NULL && ++fd->sc_ops >= 8) {
808: fd->sc_ops = 0;
809: TAILQ_REMOVE(&fdc->sc_drives, fd, sc_drivechain);
810: if (bp->b_actf) {
811: TAILQ_INSERT_TAIL(&fdc->sc_drives, fd, sc_drivechain);
812: } else
813: fd->sc_q.b_active = 0;
814: }
815: bp->b_resid = fd->sc_bcount;
816: fd->sc_skip = 0;
817: fd->sc_q.b_actf = bp->b_actf;
818:
819: biodone(bp);
820: /* turn off motor 5s from now */
821: timeout_add(&fd->sc_motoroff_to, 5 * hz);
822: fdc->sc_state = DEVIDLE;
823: }
824:
825: void
826: fdc_reset(fdc)
827: struct fdc_softc *fdc;
828: {
829: bus_space_tag_t t = fdc->sc_bustag;
830: bus_space_handle_t h = fdc->sc_handle;
831:
832: bus_space_write_1(t, h, FDREG77_DOR, FDO_FDMAEN | FDO_MOEN(0));
833:
834: bus_space_write_1(t, h, FDREG77_DRS, DRS_RESET);
835: delay(10);
836: bus_space_write_1(t, h, FDREG77_DRS, 0);
837:
838: bus_space_write_1(t, h, FDREG77_DOR,
839: FDO_FRST | FDO_FDMAEN | FDO_DS);
840: #ifdef FD_DEBUG
841: if (fdc_debug)
842: printf("fdc reset\n");
843: #endif
844: }
845:
846: void
847: fd_set_motor(fdc)
848: struct fdc_softc *fdc;
849: {
850: struct fd_softc *fd;
851: u_char status;
852: int n;
853:
854: status = FDO_FRST | FDO_FDMAEN;
855: if ((fd = TAILQ_FIRST(&fdc->sc_drives)) != NULL)
856: status |= fd->sc_drive;
857:
858: for (n = 0; n < 4; n++)
859: if ((fd = fdc->sc_fd[n]) && (fd->sc_flags & FD_MOTOR))
860: status |= FDO_MOEN(n);
861: bus_space_write_1(fdc->sc_bustag, fdc->sc_handle,
862: FDREG77_DOR, status);
863: }
864:
865: void
866: fd_motor_off(arg)
867: void *arg;
868: {
869: struct fd_softc *fd = arg;
870: int s;
871:
872: s = splbio();
873: fd->sc_flags &= ~(FD_MOTOR | FD_MOTOR_WAIT);
874: fd_set_motor((struct fdc_softc *)fd->sc_dv.dv_parent);
875: splx(s);
876: }
877:
878: void
879: fd_motor_on(arg)
880: void *arg;
881: {
882: struct fd_softc *fd = arg;
883: struct fdc_softc *fdc = (void *)fd->sc_dv.dv_parent;
884: int s;
885:
886: s = splbio();
887: fd->sc_flags &= ~FD_MOTOR_WAIT;
888: if (fd == TAILQ_FIRST(&fdc->sc_drives) && fdc->sc_state == MOTORWAIT)
889: (void) fdcstate(fdc);
890: splx(s);
891: }
892:
893: /*
894: * Get status bytes off the FDC after a command has finished
895: * Returns the number of status bytes read; -1 on error.
896: * The return value is also stored in `sc_nstat'.
897: */
898: int
899: fdcresult(fdc)
900: struct fdc_softc *fdc;
901: {
902: bus_space_tag_t t = fdc->sc_bustag;
903: bus_space_handle_t h = fdc->sc_handle;
904: int j, n = 0;
905:
906: for (j = 100000; j; j--) {
907: u_int8_t v = bus_space_read_1(t, h, FDREG77_MSR);
908: v &= (NE7_DIO | NE7_RQM | NE7_CB);
909: if (v == NE7_RQM)
910: return (fdc->sc_nstat = n);
911: if (v == (NE7_DIO | NE7_RQM | NE7_CB)) {
912: if (n >= sizeof(fdc->sc_status)) {
913: log(LOG_ERR, "fdcresult: overrun\n");
914: return (-1);
915: }
916: fdc->sc_status[n++] =
917: bus_space_read_1(t, h, FDREG77_FIFO);
918: } else
919: delay(1);
920: }
921:
922: log(LOG_ERR, "fdcresult: timeout\n");
923: return (fdc->sc_nstat = -1);
924: }
925:
926: /*
927: * Write a command byte to the FDC.
928: * Returns 0 on success; -1 on failure (i.e. timeout)
929: */
930: int
931: fdc_wrfifo(fdc, x)
932: struct fdc_softc *fdc;
933: u_int8_t x;
934: {
935: bus_space_tag_t t = fdc->sc_bustag;
936: bus_space_handle_t h = fdc->sc_handle;
937: int i;
938:
939: for (i = 100000; i-- != 0;) {
940: u_int8_t v = bus_space_read_1(t, h, FDREG77_MSR);
941: if ((v & (NE7_DIO|NE7_RQM)) == NE7_RQM) {
942: /* The chip is ready */
943: bus_space_write_1(t, h, FDREG77_FIFO, x);
944: return (0);
945: }
946: delay(1);
947: }
948: return (-1);
949: }
950:
951: int
952: fdc_diskchange(fdc)
953: struct fdc_softc *fdc;
954: {
955: bus_space_tag_t t = fdc->sc_bustag;
956: bus_space_handle_t h = fdc->sc_handle;
957:
958: u_int8_t v = bus_space_read_1(t, h, FDREG77_DIR);
959: return ((v & FDI_DCHG) != 0);
960: }
961:
962: int
963: fdopen(dev, flags, fmt, p)
964: dev_t dev;
965: int flags, fmt;
966: struct proc *p;
967: {
968: int unit, pmask;
969: struct fd_softc *fd;
970: struct fd_type *type;
971:
972: unit = FDUNIT(dev);
973: if (unit >= fd_cd.cd_ndevs)
974: return (ENXIO);
975: fd = fd_cd.cd_devs[unit];
976: if (fd == NULL)
977: return (ENXIO);
978: type = fd_dev_to_type(fd, dev);
979: if (type == NULL)
980: return (ENXIO);
981:
982: if ((fd->sc_flags & FD_OPEN) != 0 &&
983: fd->sc_type != type)
984: return (EBUSY);
985:
986: fd->sc_type = type;
987: fd->sc_cylin = -1;
988: fd->sc_flags |= FD_OPEN;
989:
990: /*
991: * Only update the disklabel if we're not open anywhere else.
992: */
993: if (fd->sc_dk.dk_openmask == 0)
994: fdgetdisklabel(dev);
995:
996: pmask = (1 << DISKPART(dev));
997:
998: switch (fmt) {
999: case S_IFCHR:
1000: fd->sc_dk.dk_copenmask |= pmask;
1001: break;
1002:
1003: case S_IFBLK:
1004: fd->sc_dk.dk_bopenmask |= pmask;
1005: break;
1006: }
1007: fd->sc_dk.dk_openmask =
1008: fd->sc_dk.dk_copenmask | fd->sc_dk.dk_bopenmask;
1009:
1010: return (0);
1011: }
1012:
1013: int
1014: fdclose(dev, flags, fmt, p)
1015: dev_t dev;
1016: int flags, fmt;
1017: struct proc *p;
1018: {
1019: struct fd_softc *fd = fd_cd.cd_devs[FDUNIT(dev)];
1020: int pmask = (1 << DISKPART(dev));
1021:
1022: fd->sc_flags &= ~FD_OPEN;
1023: fd->sc_opts &= ~(FDOPT_NORETRY|FDOPT_SILENT);
1024:
1025: switch (fmt) {
1026: case S_IFCHR:
1027: fd->sc_dk.dk_copenmask &= ~pmask;
1028: break;
1029:
1030: case S_IFBLK:
1031: fd->sc_dk.dk_bopenmask &= ~pmask;
1032: break;
1033: }
1034: fd->sc_dk.dk_openmask =
1035: fd->sc_dk.dk_copenmask | fd->sc_dk.dk_bopenmask;
1036:
1037: return (0);
1038: }
1039:
1040: int
1041: fdread(dev, uio, flag)
1042: dev_t dev;
1043: struct uio *uio;
1044: int flag;
1045: {
1046:
1047: return (physio(fdstrategy, NULL, dev, B_READ, minphys, uio));
1048: }
1049:
1050: int
1051: fdwrite(dev, uio, flag)
1052: dev_t dev;
1053: struct uio *uio;
1054: int flag;
1055: {
1056:
1057: return (physio(fdstrategy, NULL, dev, B_WRITE, minphys, uio));
1058: }
1059:
1060: void
1061: fdcstart(fdc)
1062: struct fdc_softc *fdc;
1063: {
1064:
1065: #ifdef DIAGNOSTIC
1066: /* only got here if controller's drive queue was inactive; should
1067: be in idle state */
1068: if (fdc->sc_state != DEVIDLE) {
1069: printf("fdcstart: not idle\n");
1070: return;
1071: }
1072: #endif
1073: (void) fdcstate(fdc);
1074: }
1075:
1076: void
1077: fdcstatus(fdc, s)
1078: struct fdc_softc *fdc;
1079: char *s;
1080: {
1081: struct fd_softc *fd = TAILQ_FIRST(&fdc->sc_drives);
1082: int n;
1083:
1084: /* Just print last status */
1085: n = fdc->sc_nstat;
1086:
1087: #if 0
1088: if (n == 0) {
1089: fdc_wrfifo(fdc, NE7CMD_SENSEI);
1090: (void) fdcresult(fdc);
1091: n = 2;
1092: }
1093: #endif
1094:
1095: printf("%s: %s: state %d",
1096: fd ? fd->sc_dv.dv_xname : "fdc", s, fdc->sc_state);
1097:
1098: switch (n) {
1099: case 0:
1100: printf("\n");
1101: break;
1102: case 2:
1103: printf(" (st0 %b cyl %d)\n",
1104: fdc->sc_status[0], NE7_ST0BITS,
1105: fdc->sc_status[1]);
1106: break;
1107: case 7:
1108: printf(" (st0 %b st1 %b st2 %b cyl %d head %d sec %d)\n",
1109: fdc->sc_status[0], NE7_ST0BITS,
1110: fdc->sc_status[1], NE7_ST1BITS,
1111: fdc->sc_status[2], NE7_ST2BITS,
1112: fdc->sc_status[3], fdc->sc_status[4], fdc->sc_status[5]);
1113: break;
1114: #ifdef DIAGNOSTIC
1115: default:
1116: printf(" fdcstatus: weird size: %d\n", n);
1117: break;
1118: #endif
1119: }
1120: }
1121:
1122: void
1123: fdctimeout(arg)
1124: void *arg;
1125: {
1126: struct fdc_softc *fdc = arg;
1127: struct fd_softc *fd;
1128: int s;
1129:
1130: s = splbio();
1131: fd = TAILQ_FIRST(&fdc->sc_drives);
1132: if (fd == NULL) {
1133: printf("%s: timeout but no I/O pending: state %d, istatus=%d\n",
1134: fdc->sc_dev.dv_xname, fdc->sc_state, fdc->sc_istatus);
1135: fdc->sc_state = DEVIDLE;
1136: goto out;
1137: }
1138:
1139: if (fd->sc_q.b_actf)
1140: fdc->sc_state++;
1141: else
1142: fdc->sc_state = DEVIDLE;
1143:
1144: (void) fdcstate(fdc);
1145: out:
1146: splx(s);
1147:
1148: }
1149:
1150: void
1151: fdcpseudointr(arg)
1152: void *arg;
1153: {
1154: struct fdc_softc *fdc = arg;
1155: int s;
1156:
1157: /* Just ensure it has the right spl. */
1158: s = splbio();
1159: (void) fdcstate(fdc);
1160: splx(s);
1161: }
1162:
1163:
1164: /*
1165: * Hardware interrupt entry point.
1166: * Unfortunately, we have no reliable way to determine that the
1167: * interrupt really came from the floppy controller; just hope
1168: * that the other devices that share this interrupt can do better..
1169: */
1170: int
1171: fdchwintr(arg)
1172: void *arg;
1173: {
1174: struct fdc_softc *fdc = arg;
1175: bus_space_tag_t t = fdc->sc_bustag;
1176: bus_space_handle_t h = fdc->sc_handle;
1177:
1178: switch (fdc->sc_itask) {
1179: case FDC_ITASK_NONE:
1180: return (0);
1181: case FDC_ITASK_SENSEI:
1182: if (fdc_wrfifo(fdc, NE7CMD_SENSEI) != 0 || fdcresult(fdc) == -1)
1183: fdc->sc_istatus = FDC_ISTATUS_ERROR;
1184: else
1185: fdc->sc_istatus = FDC_ISTATUS_DONE;
1186: softintr_schedule(fdc->sc_sicookie);
1187: return (1);
1188: case FDC_ITASK_RESULT:
1189: if (fdcresult(fdc) == -1)
1190: fdc->sc_istatus = FDC_ISTATUS_ERROR;
1191: else
1192: fdc->sc_istatus = FDC_ISTATUS_DONE;
1193: softintr_schedule(fdc->sc_sicookie);
1194: return (1);
1195: case FDC_ITASK_DMA:
1196: /* Proceed with pseudo-DMA below */
1197: break;
1198: default:
1199: printf("fdc: stray hard interrupt: itask=%d\n", fdc->sc_itask);
1200: fdc->sc_istatus = FDC_ISTATUS_SPURIOUS;
1201: softintr_schedule(fdc->sc_sicookie);
1202: return (1);
1203: }
1204:
1205: /*
1206: * Pseudo DMA in progress
1207: */
1208: for (;;) {
1209: u_int8_t msr;
1210:
1211: msr = bus_space_read_1(t, h, FDREG77_MSR);
1212:
1213: if ((msr & NE7_RQM) == 0)
1214: /* That's all this round */
1215: break;
1216:
1217: if ((msr & NE7_NDM) == 0) {
1218: fdcresult(fdc);
1219: fdc->sc_istatus = FDC_ISTATUS_DONE;
1220: softintr_schedule(fdc->sc_sicookie);
1221: #ifdef FD_DEBUG
1222: if (fdc_debug > 1)
1223: printf("fdc: overrun: msr = %x, tc = %d\n",
1224: msr, fdc->sc_tc);
1225: #endif
1226: break;
1227: }
1228:
1229: /* Another byte can be transferred */
1230: if ((msr & NE7_DIO) != 0)
1231: *fdc->sc_data =
1232: bus_space_read_1(t, h, FDREG77_FIFO);
1233: else
1234: bus_space_write_1(t, h, FDREG77_FIFO,
1235: *fdc->sc_data);
1236:
1237: fdc->sc_data++;
1238: if (--fdc->sc_tc == 0) {
1239: fdc->sc_istatus = FDC_ISTATUS_DONE;
1240: FTC_FLIP;
1241: fdcresult(fdc);
1242: softintr_schedule(fdc->sc_sicookie);
1243: break;
1244: }
1245: }
1246: return (1);
1247: }
1248:
1249: void
1250: fdcswintr(arg)
1251: void *arg;
1252: {
1253: struct fdc_softc *fdc = arg;
1254: int s;
1255:
1256: if (fdc->sc_istatus == FDC_ISTATUS_NONE)
1257: /* This (software) interrupt is not for us */
1258: return;
1259:
1260: switch (fdc->sc_istatus) {
1261: case FDC_ISTATUS_ERROR:
1262: printf("fdc: ierror status: state %d\n", fdc->sc_state);
1263: break;
1264: case FDC_ISTATUS_SPURIOUS:
1265: printf("fdc: spurious interrupt: state %d\n", fdc->sc_state);
1266: break;
1267: }
1268:
1269: s = splbio();
1270: fdcstate(fdc);
1271: splx(s);
1272: return;
1273: }
1274:
1275: int
1276: fdcstate(fdc)
1277: struct fdc_softc *fdc;
1278: {
1279: #define st0 fdc->sc_status[0]
1280: #define st1 fdc->sc_status[1]
1281: #define cyl fdc->sc_status[1]
1282: #define FDC_WRFIFO(fdc, c) \
1283: do { \
1284: if (fdc_wrfifo(fdc, (c))) { \
1285: goto xxx; \
1286: } \
1287: } while(0)
1288:
1289: struct fd_softc *fd;
1290: struct buf *bp;
1291: int read, head, sec, nblks;
1292: struct fd_type *type;
1293: struct fd_formb *finfo = NULL;
1294:
1295: if (fdc->sc_istatus == FDC_ISTATUS_ERROR) {
1296: /* Prevent loop if the reset sequence produces errors */
1297: if (fdc->sc_state != RESETCOMPLETE &&
1298: fdc->sc_state != RECALWAIT &&
1299: fdc->sc_state != RECALCOMPLETE)
1300: fdc->sc_state = DORESET;
1301: }
1302:
1303: /* Clear I task/status field */
1304: fdc->sc_istatus = FDC_ISTATUS_NONE;
1305: fdc->sc_itask = FDC_ITASK_NONE;
1306:
1307: loop:
1308: /* Is there a drive for the controller to do a transfer with? */
1309: fd = TAILQ_FIRST(&fdc->sc_drives);
1310: if (fd == NULL) {
1311: fdc->sc_state = DEVIDLE;
1312: return (0);
1313: }
1314:
1315: /* Is there a transfer to this drive? If not, deactivate drive. */
1316: bp = fd->sc_q.b_actf;
1317: if (bp == NULL) {
1318: fd->sc_ops = 0;
1319: TAILQ_REMOVE(&fdc->sc_drives, fd, sc_drivechain);
1320: fd->sc_q.b_active = 0;
1321: goto loop;
1322: }
1323:
1324: if (bp->b_flags & B_FORMAT)
1325: finfo = (struct fd_formb *)bp->b_data;
1326:
1327: switch (fdc->sc_state) {
1328: case DEVIDLE:
1329: fdc->sc_errors = 0;
1330: fd->sc_skip = 0;
1331: fd->sc_bcount = bp->b_bcount;
1332: fd->sc_blkno = (bp->b_blkno * DEV_BSIZE) / FD_BSIZE(fd);
1333: timeout_del(&fd->sc_motoroff_to);
1334: if ((fd->sc_flags & FD_MOTOR_WAIT) != 0) {
1335: fdc->sc_state = MOTORWAIT;
1336: return (1);
1337: }
1338: if ((fd->sc_flags & FD_MOTOR) == 0) {
1339: /* Turn on the motor, being careful about pairing. */
1340: struct fd_softc *ofd = fdc->sc_fd[fd->sc_drive ^ 1];
1341: if (ofd && ofd->sc_flags & FD_MOTOR) {
1342: timeout_del(&ofd->sc_motoroff_to);
1343: ofd->sc_flags &= ~(FD_MOTOR | FD_MOTOR_WAIT);
1344: }
1345: fd->sc_flags |= FD_MOTOR | FD_MOTOR_WAIT;
1346: fd_set_motor(fdc);
1347: fdc->sc_state = MOTORWAIT;
1348: if ((fdc->sc_flags & FDC_NEEDMOTORWAIT) != 0) { /*XXX*/
1349: /* Allow .25s for motor to stabilize. */
1350: timeout_add(&fd->sc_motoron_to, hz / 4);
1351: } else {
1352: fd->sc_flags &= ~FD_MOTOR_WAIT;
1353: goto loop;
1354: }
1355: return (1);
1356: }
1357: /* Make sure the right drive is selected. */
1358: fd_set_motor(fdc);
1359:
1360: if (fdc_diskchange(fdc))
1361: goto dodskchg;
1362:
1363: /*FALLTHROUGH*/
1364: case DOSEEK:
1365: doseek:
1366: if ((fdc->sc_flags & FDC_EIS) &&
1367: (bp->b_flags & B_FORMAT) == 0) {
1368: fd->sc_cylin = bp->b_cylinder;
1369: /* We use implied seek */
1370: goto doio;
1371: }
1372:
1373: if (fd->sc_cylin == bp->b_cylinder)
1374: goto doio;
1375:
1376: fd->sc_cylin = -1;
1377: fdc->sc_state = SEEKWAIT;
1378: fdc->sc_nstat = 0;
1379:
1380: fd->sc_dk.dk_seek++;
1381:
1382: disk_busy(&fd->sc_dk);
1383: timeout_add(&fdc->fdctimeout_to, 4 * hz);
1384:
1385: /* specify command */
1386: FDC_WRFIFO(fdc, NE7CMD_SPECIFY);
1387: FDC_WRFIFO(fdc, fd->sc_type->steprate);
1388: /* XXX head load time == 6ms */
1389: FDC_WRFIFO(fdc, 6 | NE7_SPECIFY_NODMA);
1390:
1391: fdc->sc_itask = FDC_ITASK_SENSEI;
1392: /* seek function */
1393: FDC_WRFIFO(fdc, NE7CMD_SEEK);
1394: FDC_WRFIFO(fdc, fd->sc_drive); /* drive number */
1395: FDC_WRFIFO(fdc, bp->b_cylinder * fd->sc_type->step);
1396: return (1);
1397:
1398: case DODSKCHG:
1399: dodskchg:
1400: /*
1401: * Disk change: force a seek operation by going to cyl 1
1402: * followed by a recalibrate.
1403: */
1404: disk_busy(&fd->sc_dk);
1405: timeout_add(&fdc->fdctimeout_to, 4 * hz);
1406: fd->sc_cylin = -1;
1407: fdc->sc_nstat = 0;
1408: fdc->sc_state = DSKCHGWAIT;
1409:
1410: fdc->sc_itask = FDC_ITASK_SENSEI;
1411: /* seek function */
1412: FDC_WRFIFO(fdc, NE7CMD_SEEK);
1413: FDC_WRFIFO(fdc, fd->sc_drive); /* drive number */
1414: FDC_WRFIFO(fdc, 1 * fd->sc_type->step);
1415: return (1);
1416:
1417: case DSKCHGWAIT:
1418: timeout_del(&fdc->fdctimeout_to);
1419: disk_unbusy(&fd->sc_dk, 0, 0);
1420: if (fdc->sc_nstat != 2 || (st0 & 0xf8) != 0x20 ||
1421: cyl != 1 * fd->sc_type->step) {
1422: fdcstatus(fdc, "dskchg seek failed");
1423: fdc->sc_state = DORESET;
1424: } else
1425: fdc->sc_state = DORECAL;
1426:
1427: if (fdc_diskchange(fdc)) {
1428: printf("%s: cannot clear disk change status\n",
1429: fdc->sc_dev.dv_xname);
1430: fdc->sc_state = DORESET;
1431: }
1432: goto loop;
1433:
1434: case DOIO:
1435: doio:
1436: if (finfo != NULL)
1437: fd->sc_skip = (char *)&(finfo->fd_formb_cylno(0)) -
1438: (char *)finfo;
1439: type = fd->sc_type;
1440: sec = fd->sc_blkno % type->seccyl;
1441: nblks = type->seccyl - sec;
1442: nblks = min(nblks, fd->sc_bcount / FD_BSIZE(fd));
1443: nblks = min(nblks, FDC_MAXIOSIZE / FD_BSIZE(fd));
1444: fd->sc_nblks = nblks;
1445: fd->sc_nbytes = finfo ? bp->b_bcount : nblks * FD_BSIZE(fd);
1446: head = sec / type->sectrac;
1447: sec -= head * type->sectrac;
1448: #ifdef DIAGNOSTIC
1449: {
1450: daddr64_t block;
1451:
1452: block = (fd->sc_cylin * type->heads + head) *
1453: type->sectrac + sec;
1454: if (block != fd->sc_blkno) {
1455: printf("fdcintr: block %lld != blkno %d\n",
1456: block, (int)fd->sc_blkno);
1457: #if defined(FD_DEBUG) && defined(DDB)
1458: Debugger();
1459: #endif
1460: }
1461: }
1462: #endif
1463: read = bp->b_flags & B_READ;
1464:
1465: /* Setup for pseudo DMA */
1466: fdc->sc_data = bp->b_data + fd->sc_skip;
1467: fdc->sc_tc = fd->sc_nbytes;
1468:
1469: bus_space_write_1(fdc->sc_bustag, fdc->sc_handle,
1470: FDREG77_DRS, type->rate);
1471: #ifdef FD_DEBUG
1472: if (fdc_debug > 1)
1473: printf("fdcstate: doio: %s drive %d "
1474: "track %d head %d sec %d nblks %d\n",
1475: finfo ? "format" :
1476: (read ? "read" : "write"),
1477: fd->sc_drive, fd->sc_cylin, head, sec, nblks);
1478: #endif
1479: fdc->sc_state = IOCOMPLETE;
1480: fdc->sc_itask = FDC_ITASK_DMA;
1481: fdc->sc_nstat = 0;
1482:
1483: disk_busy(&fd->sc_dk);
1484:
1485: /* allow 3 seconds for operation */
1486: timeout_add(&fdc->fdctimeout_to, 3 * hz);
1487:
1488: if (finfo != NULL) {
1489: /* formatting */
1490: FDC_WRFIFO(fdc, NE7CMD_FORMAT);
1491: FDC_WRFIFO(fdc, (head << 2) | fd->sc_drive);
1492: FDC_WRFIFO(fdc, finfo->fd_formb_secshift);
1493: FDC_WRFIFO(fdc, finfo->fd_formb_nsecs);
1494: FDC_WRFIFO(fdc, finfo->fd_formb_gaplen);
1495: FDC_WRFIFO(fdc, finfo->fd_formb_fillbyte);
1496: } else {
1497: if (read)
1498: FDC_WRFIFO(fdc, NE7CMD_READ);
1499: else
1500: FDC_WRFIFO(fdc, NE7CMD_WRITE);
1501: FDC_WRFIFO(fdc, (head << 2) | fd->sc_drive);
1502: FDC_WRFIFO(fdc, fd->sc_cylin); /*track*/
1503: FDC_WRFIFO(fdc, head);
1504: FDC_WRFIFO(fdc, sec + 1); /*sector+1*/
1505: FDC_WRFIFO(fdc, type->secsize); /*sector size*/
1506: FDC_WRFIFO(fdc, type->sectrac); /*secs/track*/
1507: FDC_WRFIFO(fdc, type->gap1); /*gap1 size*/
1508: FDC_WRFIFO(fdc, type->datalen); /*data length*/
1509: }
1510:
1511: return (1); /* will return later */
1512:
1513: case SEEKWAIT:
1514: timeout_del(&fdc->fdctimeout_to);
1515: fdc->sc_state = SEEKCOMPLETE;
1516: if (fdc->sc_flags & FDC_NEEDHEADSETTLE) {
1517: /* allow 1/50 second for heads to settle */
1518: timeout_add(&fdc->fdcpseudointr_to, hz / 50);
1519: return (1); /* will return later */
1520: }
1521: /*FALLTHROUGH*/
1522: case SEEKCOMPLETE:
1523: /* no data on seek */
1524: disk_unbusy(&fd->sc_dk, 0, 0);
1525:
1526: /* Make sure seek really happened. */
1527: if (fdc->sc_nstat != 2 || (st0 & 0xf8) != 0x20 ||
1528: cyl != bp->b_cylinder * fd->sc_type->step) {
1529: #ifdef FD_DEBUG
1530: if (fdc_debug)
1531: fdcstatus(fdc, "seek failed");
1532: #endif
1533: fdcretry(fdc);
1534: goto loop;
1535: }
1536: fd->sc_cylin = bp->b_cylinder;
1537: goto doio;
1538:
1539: case IOTIMEDOUT:
1540: /*
1541: * Try to abort the I/O operation without resetting
1542: * the chip first. Poke TC and arrange to pick up
1543: * the timed out I/O command's status.
1544: */
1545: fdc->sc_itask = FDC_ITASK_RESULT;
1546: fdc->sc_state = IOCLEANUPWAIT;
1547: fdc->sc_nstat = 0;
1548: /* 1/10 second should be enough */
1549: timeout_add(&fdc->fdctimeout_to, hz / 10);
1550: return (1);
1551:
1552: case IOCLEANUPTIMEDOUT:
1553: case SEEKTIMEDOUT:
1554: case RECALTIMEDOUT:
1555: case RESETTIMEDOUT:
1556: case DSKCHGTIMEDOUT:
1557: fdcstatus(fdc, "timeout");
1558:
1559: /* All other timeouts always roll through to a chip reset */
1560: fdcretry(fdc);
1561:
1562: /* Force reset, no matter what fdcretry() says */
1563: fdc->sc_state = DORESET;
1564: goto loop;
1565:
1566: case IOCLEANUPWAIT: /* IO FAILED, cleanup succeeded */
1567: timeout_del(&fdc->fdctimeout_to);
1568: disk_unbusy(&fd->sc_dk, (bp->b_bcount - bp->b_resid),
1569: (bp->b_flags & B_READ));
1570: fdcretry(fdc);
1571: goto loop;
1572:
1573: case IOCOMPLETE: /* IO DONE, post-analyze */
1574: timeout_del(&fdc->fdctimeout_to);
1575:
1576: disk_unbusy(&fd->sc_dk, (bp->b_bcount - bp->b_resid),
1577: (bp->b_flags & B_READ));
1578:
1579: if (fdc->sc_nstat != 7 || st1 != 0 ||
1580: ((st0 & 0xf8) != 0 &&
1581: ((st0 & 0xf8) != 0x20 || (fdc->sc_cfg & CFG_EIS) == 0))) {
1582: #ifdef FD_DEBUG
1583: if (fdc_debug) {
1584: fdcstatus(fdc,
1585: bp->b_flags & B_READ
1586: ? "read failed" : "write failed");
1587: printf("blkno %lld nblks %d nstat %d tc %d\n",
1588: fd->sc_blkno, fd->sc_nblks,
1589: fdc->sc_nstat, fdc->sc_tc);
1590: }
1591: #endif
1592: if (fdc->sc_nstat == 7 &&
1593: (st1 & ST1_OVERRUN) == ST1_OVERRUN) {
1594:
1595: /*
1596: * Silently retry overruns if no other
1597: * error bit is set. Adjust threshold.
1598: */
1599: int thr = fdc->sc_cfg & CFG_THRHLD_MASK;
1600: if (thr < 15) {
1601: thr++;
1602: fdc->sc_cfg &= ~CFG_THRHLD_MASK;
1603: fdc->sc_cfg |= (thr & CFG_THRHLD_MASK);
1604: #ifdef FD_DEBUG
1605: if (fdc_debug)
1606: printf("fdc: %d -> threshold\n", thr);
1607: #endif
1608: fdconf(fdc);
1609: fdc->sc_overruns = 0;
1610: }
1611: if (++fdc->sc_overruns < 3) {
1612: fdc->sc_state = DOIO;
1613: goto loop;
1614: }
1615: }
1616: fdcretry(fdc);
1617: goto loop;
1618: }
1619: if (fdc->sc_errors) {
1620: diskerr(bp, "fd", "soft error", LOG_PRINTF,
1621: fd->sc_skip / FD_BSIZE(fd),
1622: (struct disklabel *)NULL);
1623: printf("\n");
1624: fdc->sc_errors = 0;
1625: } else {
1626: if (--fdc->sc_overruns < -20) {
1627: int thr = fdc->sc_cfg & CFG_THRHLD_MASK;
1628: if (thr > 0) {
1629: thr--;
1630: fdc->sc_cfg &= ~CFG_THRHLD_MASK;
1631: fdc->sc_cfg |= (thr & CFG_THRHLD_MASK);
1632: #ifdef FD_DEBUG
1633: if (fdc_debug)
1634: printf("fdc: %d -> threshold\n", thr);
1635: #endif
1636: fdconf(fdc);
1637: }
1638: fdc->sc_overruns = 0;
1639: }
1640: }
1641: fd->sc_blkno += fd->sc_nblks;
1642: fd->sc_skip += fd->sc_nbytes;
1643: fd->sc_bcount -= fd->sc_nbytes;
1644: if (finfo == NULL && fd->sc_bcount > 0) {
1645: bp->b_cylinder = fd->sc_blkno / fd->sc_type->seccyl;
1646: goto doseek;
1647: }
1648: fdfinish(fd, bp);
1649: goto loop;
1650:
1651: case DORESET:
1652: /* try a reset, keep motor on */
1653: fd_set_motor(fdc);
1654: delay(100);
1655: fdc->sc_nstat = 0;
1656: fdc->sc_itask = FDC_ITASK_SENSEI;
1657: fdc->sc_state = RESETCOMPLETE;
1658: timeout_add(&fdc->fdctimeout_to, hz / 2);
1659: fdc_reset(fdc);
1660: return (1); /* will return later */
1661:
1662: case RESETCOMPLETE:
1663: timeout_del(&fdc->fdctimeout_to);
1664: fdconf(fdc);
1665:
1666: /* FALLTHROUGH */
1667: case DORECAL:
1668: fdc->sc_state = RECALWAIT;
1669: fdc->sc_itask = FDC_ITASK_SENSEI;
1670: fdc->sc_nstat = 0;
1671: timeout_add(&fdc->fdctimeout_to, 5 * hz);
1672: /* recalibrate function */
1673: FDC_WRFIFO(fdc, NE7CMD_RECAL);
1674: FDC_WRFIFO(fdc, fd->sc_drive);
1675: return (1); /* will return later */
1676:
1677: case RECALWAIT:
1678: timeout_del(&fdc->fdctimeout_to);
1679: fdc->sc_state = RECALCOMPLETE;
1680: if (fdc->sc_flags & FDC_NEEDHEADSETTLE) {
1681: /* allow 1/30 second for heads to settle */
1682: timeout_add(&fdc->fdcpseudointr_to, hz / 30);
1683: return (1); /* will return later */
1684: }
1685:
1686: case RECALCOMPLETE:
1687: if (fdc->sc_nstat != 2 || (st0 & 0xf8) != 0x20 || cyl != 0) {
1688: #ifdef FD_DEBUG
1689: if (fdc_debug)
1690: fdcstatus(fdc, "recalibrate failed");
1691: #endif
1692: fdcretry(fdc);
1693: goto loop;
1694: }
1695: fd->sc_cylin = 0;
1696: goto doseek;
1697:
1698: case MOTORWAIT:
1699: if (fd->sc_flags & FD_MOTOR_WAIT)
1700: return (1); /* time's not up yet */
1701: goto doseek;
1702:
1703: default:
1704: fdcstatus(fdc, "stray interrupt");
1705: return (1);
1706: }
1707: #ifdef DIAGNOSTIC
1708: panic("fdcintr: impossible");
1709: #endif
1710:
1711: xxx:
1712: /*
1713: * We get here if the chip locks up in FDC_WRFIFO()
1714: * Cancel any operation and schedule a reset
1715: */
1716: timeout_del(&fdc->fdctimeout_to);
1717: fdcretry(fdc);
1718: fdc->sc_state = DORESET;
1719: goto loop;
1720:
1721: #undef st0
1722: #undef st1
1723: #undef cyl
1724: }
1725:
1726: void
1727: fdcretry(fdc)
1728: struct fdc_softc *fdc;
1729: {
1730: struct fd_softc *fd;
1731: struct buf *bp;
1732: int error = EIO;
1733:
1734: fd = TAILQ_FIRST(&fdc->sc_drives);
1735: bp = fd->sc_q.b_actf;
1736:
1737: fdc->sc_overruns = 0;
1738: if (fd->sc_opts & FDOPT_NORETRY)
1739: goto fail;
1740:
1741: switch (fdc->sc_errors) {
1742: case 0:
1743: if (fdc->sc_nstat == 7 &&
1744: (fdc->sc_status[0] & 0xd8) == 0x40 &&
1745: (fdc->sc_status[1] & 0x2) == 0x2) {
1746: printf("%s: read-only medium\n", fd->sc_dv.dv_xname);
1747: error = EROFS;
1748: goto failsilent;
1749: }
1750: /* try again */
1751: fdc->sc_state =
1752: (fdc->sc_flags & FDC_EIS) ? DOIO : DOSEEK;
1753: break;
1754:
1755: case 1: case 2: case 3:
1756: /* didn't work; try recalibrating */
1757: fdc->sc_state = DORECAL;
1758: break;
1759:
1760: case 4:
1761: if (fdc->sc_nstat == 7 &&
1762: fdc->sc_status[0] == 0 &&
1763: fdc->sc_status[1] == 0 &&
1764: fdc->sc_status[2] == 0) {
1765: /*
1766: * We've retried a few times and we've got
1767: * valid status and all three status bytes
1768: * are zero. Assume this condition is the
1769: * result of no disk loaded into the drive.
1770: */
1771: printf("%s: no medium?\n", fd->sc_dv.dv_xname);
1772: error = ENODEV;
1773: goto failsilent;
1774: }
1775:
1776: /* still no go; reset the bastard */
1777: fdc->sc_state = DORESET;
1778: break;
1779:
1780: default:
1781: fail:
1782: if ((fd->sc_opts & FDOPT_SILENT) == 0) {
1783: diskerr(bp, "fd", "hard error", LOG_PRINTF,
1784: fd->sc_skip / FD_BSIZE(fd),
1785: (struct disklabel *)NULL);
1786: printf("\n");
1787: fdcstatus(fdc, "controller status");
1788: }
1789:
1790: failsilent:
1791: bp->b_flags |= B_ERROR;
1792: bp->b_error = error;
1793: fdfinish(fd, bp);
1794: }
1795: fdc->sc_errors++;
1796: }
1797:
1798: daddr64_t
1799: fdsize(dev)
1800: dev_t dev;
1801: {
1802:
1803: /* Swapping to floppies would not make sense. */
1804: return (-1);
1805: }
1806:
1807: int
1808: fddump(dev, blkno, va, size)
1809: dev_t dev;
1810: daddr64_t blkno;
1811: caddr_t va;
1812: size_t size;
1813: {
1814:
1815: /* Not implemented. */
1816: return (EINVAL);
1817: }
1818:
1819: int
1820: fdioctl(dev, cmd, addr, flag, p)
1821: dev_t dev;
1822: u_long cmd;
1823: caddr_t addr;
1824: int flag;
1825: struct proc *p;
1826: {
1827: struct fd_softc *fd;
1828: struct fdc_softc *fdc;
1829: int unit;
1830: int error;
1831: #ifdef FD_DEBUG
1832: int i;
1833: #endif
1834:
1835: unit = FDUNIT(dev);
1836: if (unit >= fd_cd.cd_ndevs)
1837: return (ENXIO);
1838:
1839: fd = fd_cd.cd_devs[FDUNIT(dev)];
1840: fdc = (struct fdc_softc *)fd->sc_dv.dv_parent;
1841:
1842: switch (cmd) {
1843: case DIOCGDINFO:
1844: *(struct disklabel *)addr = *(fd->sc_dk.dk_label);
1845: return 0;
1846:
1847: case DIOCWLABEL:
1848: if ((flag & FWRITE) == 0)
1849: return EBADF;
1850: /* XXX do something */
1851: return (0);
1852:
1853: case DIOCWDINFO:
1854: if ((flag & FWRITE) == 0)
1855: return (EBADF);
1856:
1857: error = setdisklabel(fd->sc_dk.dk_label,
1858: (struct disklabel *)addr, 0);
1859: if (error)
1860: return (error);
1861:
1862: error = writedisklabel(DISKLABELDEV(dev), fdstrategy,
1863: fd->sc_dk.dk_label);
1864: return (error);
1865:
1866: case DIOCLOCK:
1867: /*
1868: * Nothing to do here, really.
1869: */
1870: return (0);
1871:
1872: case MTIOCTOP:
1873: if (((struct mtop *)addr)->mt_op != MTOFFL)
1874: return (EIO);
1875: /* FALLTHROUGH */
1876: case DIOCEJECT:
1877: if (fdc->sc_flags & FDC_NOEJECT)
1878: return (ENODEV);
1879: fd_do_eject(fd);
1880: return (0);
1881:
1882: case FD_FORM:
1883: if ((flag & FWRITE) == 0)
1884: return (EBADF); /* must be opened for writing */
1885: else if (((struct fd_formb *)addr)->format_version !=
1886: FD_FORMAT_VERSION)
1887: return (EINVAL);/* wrong version of formatting prog */
1888: else
1889: return fdformat(dev, (struct fd_formb *)addr, p);
1890: break;
1891:
1892: case FD_GTYPE: /* get drive options */
1893: *(struct fd_type *)addr = *fd->sc_type;
1894: return (0);
1895:
1896: case FD_GOPTS: /* get drive options */
1897: *(int *)addr = fd->sc_opts;
1898: return (0);
1899:
1900: case FD_SOPTS: /* set drive options */
1901: fd->sc_opts = *(int *)addr;
1902: return (0);
1903:
1904: #ifdef FD_DEBUG
1905: case _IO('f', 100):
1906: fdc_wrfifo(fdc, NE7CMD_DUMPREG);
1907: fdcresult(fdc);
1908: printf("fdc: dumpreg(%d regs): <", fdc->sc_nstat);
1909: for (i = 0; i < fdc->sc_nstat; i++)
1910: printf(" 0x%x", fdc->sc_status[i]);
1911: printf(">\n");
1912: return (0);
1913:
1914: case _IOW('f', 101, int):
1915: fdc->sc_cfg &= ~CFG_THRHLD_MASK;
1916: fdc->sc_cfg |= (*(int *)addr & CFG_THRHLD_MASK);
1917: fdconf(fdc);
1918: return (0);
1919:
1920: case _IO('f', 102):
1921: fdc_wrfifo(fdc, NE7CMD_SENSEI);
1922: fdcresult(fdc);
1923: printf("fdc: sensei(%d regs): <", fdc->sc_nstat);
1924: for (i=0; i< fdc->sc_nstat; i++)
1925: printf(" 0x%x", fdc->sc_status[i]);
1926: printf(">\n");
1927: return (0);
1928: #endif
1929: default:
1930: return (ENOTTY);
1931: }
1932: }
1933:
1934: int
1935: fdformat(dev, finfo, p)
1936: dev_t dev;
1937: struct fd_formb *finfo;
1938: struct proc *p;
1939: {
1940: int rv = 0;
1941: struct fd_softc *fd = fd_cd.cd_devs[FDUNIT(dev)];
1942: struct fd_type *type = fd->sc_type;
1943: struct buf *bp;
1944:
1945: /* set up a buffer header for fdstrategy() */
1946: bp = (struct buf *)malloc(sizeof(struct buf), M_TEMP, M_NOWAIT);
1947: if (bp == NULL)
1948: return (ENOBUFS);
1949:
1950: bzero((void *)bp, sizeof(struct buf));
1951: bp->b_flags = B_BUSY | B_PHYS | B_FORMAT;
1952: bp->b_proc = p;
1953: bp->b_dev = dev;
1954:
1955: /*
1956: * Calculate a fake blkno, so fdstrategy() would initiate a
1957: * seek to the requested cylinder.
1958: */
1959: bp->b_blkno = ((finfo->cyl * (type->sectrac * type->heads)
1960: + finfo->head * type->sectrac) * FD_BSIZE(fd))
1961: / DEV_BSIZE;
1962:
1963: bp->b_bcount = sizeof(struct fd_idfield_data) * finfo->fd_formb_nsecs;
1964: bp->b_data = (caddr_t)finfo;
1965:
1966: #ifdef FD_DEBUG
1967: if (fdc_debug) {
1968: int i;
1969:
1970: printf("fdformat: blkno 0x%llx count %ld\n",
1971: (unsigned long long)bp->b_blkno, bp->b_bcount);
1972:
1973: printf("\tcyl:\t%d\n", finfo->cyl);
1974: printf("\thead:\t%d\n", finfo->head);
1975: printf("\tnsecs:\t%d\n", finfo->fd_formb_nsecs);
1976: printf("\tsshft:\t%d\n", finfo->fd_formb_secshift);
1977: printf("\tgaplen:\t%d\n", finfo->fd_formb_gaplen);
1978: printf("\ttrack data:");
1979: for (i = 0; i < finfo->fd_formb_nsecs; i++) {
1980: printf(" [c%d h%d s%d]",
1981: finfo->fd_formb_cylno(i),
1982: finfo->fd_formb_headno(i),
1983: finfo->fd_formb_secno(i) );
1984: if (finfo->fd_formb_secsize(i) != 2)
1985: printf("<sz:%d>", finfo->fd_formb_secsize(i));
1986: }
1987: printf("\n");
1988: }
1989: #endif
1990:
1991: /* now do the format */
1992: fdstrategy(bp);
1993:
1994: /* ...and wait for it to complete */
1995: rv = biowait(bp);
1996: free(bp, M_TEMP);
1997: return (rv);
1998: }
1999:
2000: void
2001: fdgetdisklabel(dev)
2002: dev_t dev;
2003: {
2004: int unit = FDUNIT(dev);
2005: struct fd_softc *fd = fd_cd.cd_devs[unit];
2006: struct disklabel *lp = fd->sc_dk.dk_label;
2007: char *errstring;
2008:
2009: bzero(lp, sizeof(struct disklabel));
2010:
2011: lp->d_type = DTYPE_FLOPPY;
2012: lp->d_secsize = FD_BSIZE(fd);
2013: lp->d_secpercyl = fd->sc_type->seccyl;
2014: lp->d_nsectors = fd->sc_type->sectrac;
2015: lp->d_ncylinders = fd->sc_type->tracks;
2016: lp->d_ntracks = fd->sc_type->heads; /* Go figure... */
2017: DL_SETDSIZE(lp, (daddr64_t)lp->d_secpercyl * lp->d_ncylinders);
2018: lp->d_rpm = 300; /* XXX like it matters... */
2019:
2020: strncpy(lp->d_typename, "floppy disk", sizeof(lp->d_typename));
2021: strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname));
2022: lp->d_interleave = 1;
2023: lp->d_version = 1;
2024:
2025: lp->d_magic = DISKMAGIC;
2026: lp->d_magic2 = DISKMAGIC;
2027: lp->d_checksum = dkcksum(lp);
2028:
2029: /*
2030: * Call the generic disklabel extraction routine. If there's
2031: * not a label there, fake it.
2032: */
2033: errstring = readdisklabel(DISKLABELDEV(dev), fdstrategy, lp, 0);
2034: if (errstring) {
2035: /*printf("%s: %s\n", fd->sc_dv.dv_xname, errstring);*/
2036: }
2037: }
2038:
2039: void
2040: fd_do_eject(fd)
2041: struct fd_softc *fd;
2042: {
2043: struct fdc_softc *fdc = (void *)fd->sc_dv.dv_parent;
2044: bus_space_tag_t t = fdc->sc_bustag;
2045: bus_space_handle_t h = fdc->sc_handle;
2046: u_int8_t dor = FDO_FRST | FDO_FDMAEN | FDO_MOEN(0);
2047:
2048: bus_space_write_1(t, h, FDREG77_DOR, dor | FDO_EJ);
2049: delay(10);
2050: bus_space_write_1(t, h, FDREG77_DOR, FDO_FRST | FDO_DS);
2051: }