diff options
Diffstat (limited to 'sys/arch/sparc/dev/fd.c')
| -rw-r--r-- | sys/arch/sparc/dev/fd.c | 657 |
1 files changed, 411 insertions, 246 deletions
diff --git a/sys/arch/sparc/dev/fd.c b/sys/arch/sparc/dev/fd.c index 9df2ebfb3e2..abd328067d8 100644 --- a/sys/arch/sparc/dev/fd.c +++ b/sys/arch/sparc/dev/fd.c @@ -1,7 +1,42 @@ -/* $OpenBSD: fd.c,v 1.36 2004/04/02 04:31:21 deraadt Exp $ */ +/* $OpenBSD: fd.c,v 1.37 2004/09/22 22:12:57 miod Exp $ */ /* $NetBSD: fd.c,v 1.51 1997/05/24 20:16:19 pk Exp $ */ /*- + * Copyright (c) 2000 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Paul Kranenburg. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the NetBSD + * Foundation, Inc. and its contributors. + * 4. Neither the name of The NetBSD Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +/*- * Copyright (c) 1993, 1994, 1995 Charles Hannum. * Copyright (c) 1990 The Regents of the University of California. * All rights reserved. @@ -84,28 +119,29 @@ #define b_cylin b_resid -#define FD_DEBUG #ifdef FD_DEBUG int fdc_debug = 0; #endif enum fdc_state { DEVIDLE = 0, - MOTORWAIT, - DOSEEK, - SEEKWAIT, - SEEKTIMEDOUT, - SEEKCOMPLETE, - DOIO, - IOCOMPLETE, - IOTIMEDOUT, - DORESET, - RESETCOMPLETE, - RESETTIMEDOUT, - DORECAL, - RECALWAIT, - RECALTIMEDOUT, - RECALCOMPLETE, + MOTORWAIT, /* 1 */ + DOSEEK, /* 2 */ + SEEKWAIT, /* 3 */ + SEEKTIMEDOUT, /* 4 */ + SEEKCOMPLETE, /* 5 */ + DOIO, /* 6 */ + IOCOMPLETE, /* 7 */ + IOTIMEDOUT, /* 8 */ + IOCLEANUPWAIT, /* 9 */ + IOCLEANUPTIMEDOUT,/*10 */ + DORESET, /* 11 */ + RESETCOMPLETE, /* 12 */ + RESETTIMEDOUT, /* 13 */ + DORECAL, /* 14 */ + RECALWAIT, /* 15 */ + RECALTIMEDOUT, /* 16 */ + RECALCOMPLETE, /* 17 */ }; /* software state, per controller */ @@ -121,6 +157,7 @@ struct fdc_softc { #define FDC_82077 0x01 #define FDC_NEEDHEADSETTLE 0x02 #define FDC_EIS 0x04 +#define FDC_NEEDMOTORWAIT 0x08 int sc_errors; /* number of retries so far */ int sc_overruns; /* number of DMA overruns */ int sc_cfg; /* current configuration */ @@ -129,7 +166,8 @@ struct fdc_softc { #define sc_reg_fifo sc_io.fdcio_reg_fifo #define sc_reg_dor sc_io.fdcio_reg_dor #define sc_reg_drs sc_io.fdcio_reg_msr -#define sc_istate sc_io.fdcio_istate +#define sc_itask sc_io.fdcio_itask +#define sc_istatus sc_io.fdcio_istatus #define sc_data sc_io.fdcio_data #define sc_tc sc_io.fdcio_tc #define sc_nstat sc_io.fdcio_nstat @@ -159,13 +197,10 @@ __inline struct fd_type *fd_dev_to_type(struct fd_softc *, dev_t); /* The order of entries in the following table is important -- BEWARE! */ struct fd_type fd_types[] = { - { 18,2,36,2,0xff,0xcf,0x1b,0x6c,80,2880,1,FDC_500KBPS, "1.44MB" }, /* 1.44MB diskette */ - { 15,2,30,2,0xff,0xdf,0x1b,0x54,80,2400,1,FDC_500KBPS, "1.2MB" }, /* 1.2 MB AT-diskettes */ - { 9,2,18,2,0xff,0xdf,0x23,0x50,40, 720,2,FDC_300KBPS, "360KB/AT" }, /* 360kB in 1.2MB drive */ - { 9,2,18,2,0xff,0xdf,0x2a,0x50,40, 720,1,FDC_250KBPS, "360KB/PC" }, /* 360kB PC diskettes */ + { 18,2,36,2,0xff,0xcf,0x1b,0x54,80,2880,1,FDC_500KBPS, "1.44MB" }, /* 1.44MB diskette */ { 9,2,18,2,0xff,0xdf,0x2a,0x50,80,1440,1,FDC_250KBPS, "720KB" }, /* 3.5" 720kB diskette */ - { 9,2,18,2,0xff,0xdf,0x23,0x50,80,1440,1,FDC_300KBPS, "720KB/x" }, /* 720kB in 1.2MB drive */ { 9,2,18,2,0xff,0xdf,0x2a,0x50,40, 720,2,FDC_250KBPS, "360KB/x" }, /* 360kB in 720kB drive */ + { 8,2,16,3,0xff,0xdf,0x35,0x74,77,1232,1,FDC_500KBPS, "1.2MB/NEC" } /* 1.2 MB japanese format */ }; /* software state, per disk (with up to 4 disks per ctlr) */ @@ -225,14 +260,14 @@ void fd_set_motor(struct fdc_softc *fdc); void fd_motor_off(void *arg); void fd_motor_on(void *arg); int fdcresult(struct fdc_softc *fdc); -int out_fdc(struct fdc_softc *fdc, u_char x); +int fdc_wrfifo(struct fdc_softc *fdc, u_char x); void fdcstart(struct fdc_softc *fdc); -void fdcstatus(struct device *dv, int n, char *s); +void fdcstatus(struct fdc_softc *fdc, char *s); void fdc_reset(struct fdc_softc *fdc); void fdctimeout(void *arg); void fdcpseudointr(void *arg); #ifdef FDC_C_HANDLER -int fdchwintr(struct fdc_softc *); +int fdc_c_hwintr(struct fdc_softc *); #else void fdchwintr(void); #endif @@ -243,7 +278,7 @@ void fdfinish(struct fd_softc *fd, struct buf *bp); int fdformat(dev_t, struct fd_formb *, struct proc *); void fd_do_eject(struct fd_softc *); void fd_mountroot_hook(struct device *); -static void fdconf(struct fdc_softc *); +static int fdconf(struct fdc_softc *); #if IPL_FDSOFT == 4 #define IE_FDSOFT IE_L4 @@ -332,14 +367,18 @@ fdprint(aux, fdc) return (QUIET); } -static void +/* + * Configure several parameters and features on the FDC. + * Return 0 on success. + */ +static int fdconf(fdc) struct fdc_softc *fdc; { int vroom; - if (out_fdc(fdc, NE7CMD_DUMPREG) || fdcresult(fdc) != 10) - return; + if (fdc_wrfifo(fdc, NE7CMD_DUMPREG) || fdcresult(fdc) != 10) + return (-1); /* * dumpreg[7] seems to be a motor-off timeout; set it to whatever @@ -349,11 +388,35 @@ fdconf(fdc) vroom = 0x64; /* Configure controller to use FIFO and Implied Seek */ - out_fdc(fdc, NE7CMD_CFG); - out_fdc(fdc, vroom); - out_fdc(fdc, fdc->sc_cfg); - out_fdc(fdc, 0); /* PRETRK */ - /* No result phase */ + if (fdc_wrfifo(fdc, NE7CMD_CFG) != 0) + return (-1); + if (fdc_wrfifo(fdc, vroom) != 0) + return (-1); + if (fdc_wrfifo(fdc, fdc->sc_cfg) != 0) + return (-1); + if (fdc_wrfifo(fdc, 0) != 0) /* PRETRK */ + return (-1); + /* No result phase for the NE7CMD_CFG command */ + + if ((fdc->sc_flags & FDC_82077) != 0) { + /* Lock configuration accross soft resets. */ + if (fdc_wrfifo(fdc, NE7CMD_LOCK | CFG_LOCK) != 0 || + fdcresult(fdc) != 1) { +#ifdef FD_DEBUG + printf("fdconf: CFGLOCK failed"); +#endif + return (-1); + } + } + return (0); +#if 0 + if (fdc_wrfifo(fdc, NE7CMD_VERSION) == 0 && + fdcresult(fdc) == 1 && fdc->sc_status[0] == 0x90) { + if (fdc_debug) + printf("[version cmd]"); + } +#endif + } void @@ -375,13 +438,14 @@ fdcattach(parent, self, aux) ca->ca_ra.ra_len); fdc->sc_state = DEVIDLE; - fdc->sc_istate = ISTATE_IDLE; + fdc->sc_itask = FDC_ITASK_NONE; + fdc->sc_istatus = FDC_ISTATUS_NONE; fdc->sc_flags |= FDC_EIS; TAILQ_INIT(&fdc->sc_drives); pri = ca->ca_ra.ra_intr[0].int_pri; #ifdef FDC_C_HANDLER - fdc->sc_hih.ih_fun = (void *)fdchwintr; + fdc->sc_hih.ih_fun = (void *)fdc_c_hwintr; fdc->sc_hih.ih_arg = fdc; intr_establish(pri, &fdc->sc_hih, IPL_FD); #else @@ -411,30 +475,26 @@ fdcattach(parent, self, aux) } if (code == '7') { fdc->sc_flags |= FDC_82077; + fdc->sc_flags |= FDC_NEEDMOTORWAIT; } else { fdc->sc_reg_msr = &((struct fdreg_72 *)fdc->sc_reg)->fd_msr; fdc->sc_reg_fifo = &((struct fdreg_72 *)fdc->sc_reg)->fd_fifo; fdc->sc_reg_dor = 0; } -#ifdef FD_DEBUG - if (out_fdc(fdc, NE7CMD_VERSION) == 0 && - fdcresult(fdc) == 1 && fdc->sc_status[0] == 0x90) { - if (fdc_debug) - printf("[version cmd]"); - } -#endif - /* * Configure controller; enable FIFO, Implied seek, no POLL mode?. * Note: CFG_EFIFO is active-low, initial threshold value: 8 */ fdc->sc_cfg = CFG_EIS|/*CFG_EFIFO|*/CFG_POLL|(8 & CFG_THRHLD_MASK); - fdconf(fdc); + if (fdconf(fdc) != 0) { + printf("%s: no drives attached\n", fdc->sc_dev.dv_xname); + return; + } - if (fdc->sc_flags & FDC_82077) { + if ((fdc->sc_flags & FDC_82077) != 0) { /* Lock configuration across soft resets. */ - out_fdc(fdc, NE7CMD_LOCK | CFG_LOCK); + fdc_wrfifo(fdc, NE7CMD_LOCK | CFG_LOCK); if (fdcresult(fdc) != 1) printf(" CFGLOCK: unexpected response"); } @@ -516,25 +576,26 @@ fdmatch(parent, match, aux) /* XXX - for now, punt on more than one drive */ return (0); - if (fdc->sc_flags & FDC_82077) { + if ((fdc->sc_flags & FDC_82077) != 0) { /* select drive and turn on motor */ *fdc->sc_reg_dor = drive | FDO_FRST | FDO_MOEN(drive); + /* wait for motor to spin up */ + delay(250000); } else { auxregbisc(AUXIO4C_FDS, 0); } - /* wait for motor to spin up */ - delay(250000); fdc->sc_nstat = 0; - out_fdc(fdc, NE7CMD_RECAL); - out_fdc(fdc, drive); + fdc_wrfifo(fdc, NE7CMD_RECAL); + fdc_wrfifo(fdc, drive); + /* wait for recalibrate */ for (n = 0; n < 10000; n++) { delay(1000); if ((*fdc->sc_reg_msr & (NE7_RQM|NE7_DIO|NE7_CB)) == NE7_RQM) { /* wait a bit longer till device *really* is ready */ delay(100000); - if (out_fdc(fdc, NE7CMD_SENSEI)) + if (fdc_wrfifo(fdc, NE7CMD_SENSEI)) break; if (fdcresult(fdc) == 1 && fdc->sc_status[0] == 0x80) /* @@ -552,14 +613,14 @@ fdmatch(parent, match, aux) int i; printf("fdprobe: %d stati:", n); for (i = 0; i < n; i++) - printf(" %x", fdc->sc_status[i]); + printf(" 0x%x", fdc->sc_status[i]); printf("\n"); } #endif ok = (n == 2 && (fdc->sc_status[0] & 0xf8) == 0x20) ? 1 : 0; /* turn off motor */ - if (fdc->sc_flags & FDC_82077) { + if ((fdc->sc_flags & FDC_82077) != 0) { /* deselect drive and turn motor off */ *fdc->sc_reg_dor = FDO_FRST | FDO_DS; } else { @@ -583,6 +644,10 @@ fdattach(parent, self, aux) struct fd_type *type = fa->fa_deftype; int drive = fa->fa_drive; + /* Setup timeouts */ + timeout_set(&fd->fd_motor_on_to, fd_motor_on, fd); + timeout_set(&fd->fd_motor_off_to, fd_motor_off, fd); + /* XXX Allow `flags' to override device type? */ if (type) @@ -596,9 +661,10 @@ fdattach(parent, self, aux) fd->sc_deftype = type; fdc->sc_fd[drive] = fd; - out_fdc(fdc, NE7CMD_SPECIFY); - out_fdc(fdc, type->steprate); - out_fdc(fdc, 6 | NE7_SPECIFY_NODMA); + fdc_wrfifo(fdc, NE7CMD_SPECIFY); + fdc_wrfifo(fdc, type->steprate); + /* XXX head load time == 6ms */ + fdc_wrfifo(fdc, 6 | NE7_SPECIFY_NODMA); /* * Initialize and attach the disk structure. @@ -624,10 +690,6 @@ fdattach(parent, self, aux) /* XXX Need to do some more fiddling with sc_dk. */ dk_establish(&fd->sc_dk, &fd->sc_dv); - - /* Setup timeouts */ - timeout_set(&fd->fd_motor_on_to, fd_motor_on, fd); - timeout_set(&fd->fd_motor_off_to, fd_motor_off, fd); } __inline struct fd_type * @@ -655,7 +717,8 @@ fdstrategy(bp) if (unit >= fd_cd.cd_ndevs || (fd = fd_cd.cd_devs[unit]) == 0 || bp->b_blkno < 0 || - ((bp->b_bcount % FDC_BSIZE) != 0 && + (((bp->b_bcount % FD_BSIZE(fd)) != 0 || + (bp->b_blkno * DEV_BSIZE) % FD_BSIZE(fd) != 0) && (bp->b_flags & B_FORMAT) == 0)) { bp->b_error = EINVAL; goto bad; @@ -665,10 +728,11 @@ fdstrategy(bp) if (bp->b_bcount == 0) goto done; - sz = howmany(bp->b_bcount, FDC_BSIZE); + sz = howmany(bp->b_bcount, DEV_BSIZE); - if (bp->b_blkno + sz > fd->sc_type->size) { - sz = fd->sc_type->size - bp->b_blkno; + if (bp->b_blkno + sz > (fd->sc_type->size * DEV_BSIZE) / FD_BSIZE(fd)) { + sz = (fd->sc_type->size * DEV_BSIZE) / FD_BSIZE(fd) + - bp->b_blkno; if (sz == 0) { /* If exactly at end of disk, return EOF. */ bp->b_resid = bp->b_bcount; @@ -683,7 +747,8 @@ fdstrategy(bp) bp->b_bcount = sz << DEV_BSHIFT; } - bp->b_cylin = bp->b_blkno / (FDC_BSIZE / DEV_BSIZE) / fd->sc_type->seccyl; + bp->b_cylin = (bp->b_blkno * DEV_BSIZE) / + (FD_BSIZE(fd) * fd->sc_type->seccyl); #ifdef FD_DEBUG if (fdc_debug > 1) @@ -804,16 +869,14 @@ fd_set_motor(fdc) status |= FDO_MOEN(n); *fdc->sc_reg_dor = status; } else { - int on = 0; - - for (n = 0; n < 4; n++) - if ((fd = fdc->sc_fd[n]) && (fd->sc_flags & FD_MOTOR)) - on = 1; - if (on) { - auxregbisc(AUXIO4C_FDS, 0); - } else { - auxregbisc(0, AUXIO4C_FDS); + for (n = 0; n < 4; n++) { + if ((fd = fdc->sc_fd[n]) != NULL && + (fd->sc_flags & FD_MOTOR) != 0) { + auxregbisc(AUXIO4C_FDS, 0); + return; + } } + auxregbisc(0, AUXIO4C_FDS); } } @@ -845,15 +908,19 @@ fd_motor_on(arg) splx(s); } +/* + * Get status bytes off the FDC after a command has finished + * Returns the number of status bytes read; -1 on error. + * The return value is also stored in `sc_nstat'. + */ int fdcresult(fdc) struct fdc_softc *fdc; { u_char i; - int j = 100000, - n = 0; + int j, n = 0; - for (; j; j--) { + for (j = 100000; j; j--) { i = *fdc->sc_reg_msr & (NE7_DIO | NE7_RQM | NE7_CB); if (i == NE7_RQM) return (fdc->sc_nstat = n); @@ -864,26 +931,33 @@ fdcresult(fdc) } fdc->sc_status[n++] = *fdc->sc_reg_fifo; } else - delay(10); + delay(1); } + log(LOG_ERR, "fdcresult: timeout\n"); return (fdc->sc_nstat = -1); } +/* + * Write a command byte to the FDC. + * Returns 0 on success; -1 on failure (i.e. timeout) + */ int -out_fdc(fdc, x) +fdc_wrfifo(fdc, x) struct fdc_softc *fdc; u_char x; { - int i = 100000; + int i; - while (((*fdc->sc_reg_msr & (NE7_DIO|NE7_RQM)) != NE7_RQM) && i-- > 0) + for (i = 100000; i-- > 0;) { + if ((*fdc->sc_reg_msr & (NE7_DIO|NE7_RQM)) == NE7_RQM) { + /* The chip is ready */ + *fdc->sc_reg_fifo = x; + return (0); + } delay(1); - if (i <= 0) - return (-1); - - *fdc->sc_reg_fifo = x; - return (0); + } + return (-1); } int @@ -900,7 +974,7 @@ fdopen(dev, flags, fmt, p) if (unit >= fd_cd.cd_ndevs) return (ENXIO); fd = fd_cd.cd_devs[unit]; - if (fd == 0) + if (fd == NULL) return (ENXIO); type = fd_dev_to_type(fd, dev); if (type == NULL) @@ -1001,29 +1075,30 @@ fdcstart(fdc) } void -fdcstatus(dv, n, s) - struct device *dv; - int n; +fdcstatus(fdc, s) + struct fdc_softc *fdc; char *s; { - struct fdc_softc *fdc = (void *)dv->dv_parent; + struct fd_softc *fd = fdc->sc_drives.tqh_first; + int n; + + /* Just print last status */ + n = fdc->sc_nstat; #if 0 /* * A 82072 seems to return <invalid command> on * gratuitous Sense Interrupt commands. */ - if (n == 0 && (fdc->sc_flags & FDC_82077)) { - out_fdc(fdc, NE7CMD_SENSEI); + if (n == 0 && (fdc->sc_flags & FDC_82077) != 0) { + fdc_wrfifo(fdc, NE7CMD_SENSEI); (void) fdcresult(fdc); n = 2; } #endif - /* Just print last status */ - n = fdc->sc_nstat; - - printf("%s: %s: state %d", dv->dv_xname, s, fdc->sc_state); + printf("%s: %s: state %d", + fd ? fd->sc_dv.dv_xname : "fdc", s, fdc->sc_state); switch (n) { case 0: @@ -1054,11 +1129,17 @@ fdctimeout(arg) void *arg; { struct fdc_softc *fdc = arg; - struct fd_softc *fd = fdc->sc_drives.tqh_first; + struct fd_softc *fd; int s; s = splbio(); - fdcstatus(&fd->sc_dv, 0, "timeout"); + fd = fdc->sc_drives.tqh_first; + if (fd == NULL) { + printf("%s: timeout but no I/O pending: statu %d, istatus=%d\n", + fdc->sc_dev.dv_xname, fdc->sc_state, fdc->sc_istatus); + fdc->sc_state = DEVIDLE; + goto out; + } if (fd->sc_q.b_actf) fdc->sc_state++; @@ -1066,6 +1147,7 @@ fdctimeout(arg) fdc->sc_state = DEVIDLE; (void) fdcstate(fdc); +out: splx(s); } @@ -1089,55 +1171,67 @@ fdcpseudointr(arg) * (in-window) handler. */ int -fdchwintr(fdc) +fdc_c_hwintr(fdc) struct fdc_softc *fdc; { - switch (fdc->sc_istate) { - case ISTATE_IDLE: + switch (fdc->sc_itask) { + case FDC_ITASK_NONE: return (0); - case ISTATE_SENSEI: - out_fdc(fdc, NE7CMD_SENSEI); - fdcresult(fdc); - fdc->sc_istate = ISTATE_IDLE; + case FDC_ITASK_SENSEI: + if (fdc_wrfifo(fdc, NE7CMD_SENSEI) != 0 || fdcresult(fdc) == -1) + fdc->sc_istatus = FDC_ISTATUS_ERROR; + else + fdc->sc_istatus = FDC_ISTATUS_DONE; FD_SET_SWINTR; goto done; - case ISTATE_SPURIOUS: - fdcresult(fdc); - fdc->sc_istate = ISTATE_SPURIOUS; - printf("fdc: stray hard interrupt... "); + case FDC_ITASK_RESULT: + if (fdcresult(fdc) == -1) + fdc->sc_istatus = FDC_ISTATUS_ERROR; + else + fdc->sc_istatus = FDC_ISTATUS_DONE; FD_SET_SWINTR; goto done; - case ISTATE_DMA: + case FDC_ITASK_DMA: + /* Proceed with pseudo-DMA below */ break; default: - printf("fdc: goofed ...\n"); + printf("fdc: stray hard interrupt: itask=%d\n", fdc->sc_itask); + fdc->sc_istatus = FDC_ISTATUS_SPURIOUS; + FD_SET_SWINTR; goto done; } + /* + * Pseudo DMA in progress + */ for (;;) { register int msr; msr = *fdc->sc_reg_msr; if ((msr & NE7_RQM) == 0) + /* That's all this round */ break; if ((msr & NE7_NDM) == 0) { fdcresult(fdc); - fdc->sc_istate = ISTATE_IDLE; + fdc->sc_istatus = FDC_ISTATUS_DONE; FD_SET_SWINTR; - printf("fdc: overrun: tc = %d\n", fdc->sc_tc); +#ifdef FD_DEBUG + if (fdc_debug > 1) + printf("fdc: overrun: tc = %d\n", fdc->sc_tc); +#endif break; } - if (msr & NE7_DIO) { + /* Another byte can be transferred */ + if ((msr & NE7_DIO) != 0) *fdc->sc_data++ = *fdc->sc_reg_fifo; - } else { + else *fdc->sc_reg_fifo = *fdc->sc_data++; - } if (--fdc->sc_tc == 0) { - fdc->sc_istate = ISTATE_DONE; + fdc->sc_istatus = FDC_ISTATUS_DONE; FTC_FLIP; fdcresult(fdc); FD_SET_SWINTR; @@ -1156,10 +1250,19 @@ fdcswintr(fdc) { int s; - if (fdc->sc_istate != ISTATE_DONE) + if (fdc->sc_istatus == FDC_ISTATUS_NONE) + /* This (software) interrupt is not for us */ return (0); - fdc->sc_istate = ISTATE_IDLE; + switch (fdc->sc_istatus) { + case FDC_ISTATUS_ERROR: + printf("fdc: ierror status: state %d\n", fdc->sc_state); + break; + case FDC_ISTATUS_SPURIOUS: + printf("fdc: spurious interrupt: state %d\n", fdc->sc_state); + break; + } + s = splbio(); fdcstate(fdc); splx(s); @@ -1173,8 +1276,12 @@ fdcstate(fdc) #define st0 fdc->sc_status[0] #define st1 fdc->sc_status[1] #define cyl fdc->sc_status[1] -#define OUT_FDC(fdc, c, s) \ - do { if (out_fdc(fdc, (c))) { (fdc)->sc_state = (s); goto loop; } } while(0) +#define FDC_WRFIFO(fdc, c) \ + do { \ + if (fdc_wrfifo(fdc, (c))) { \ + goto xxx; \ + } \ + } while (0) struct fd_softc *fd; struct buf *bp; @@ -1183,18 +1290,18 @@ fdcstate(fdc) struct fd_formb *finfo = NULL; - if (fdc->sc_istate != ISTATE_IDLE) { - /* Trouble... */ - printf("fdc: spurious interrupt: state %d, istate=%d\n", - fdc->sc_state, fdc->sc_istate); - fdc->sc_istate = ISTATE_IDLE; - if (fdc->sc_state == RESETCOMPLETE || - fdc->sc_state == RESETTIMEDOUT) { - panic("fdcintr: spurious interrupt can't be cleared"); - } - goto doreset; + if (fdc->sc_istatus == FDC_ISTATUS_ERROR) { + /* Prevent loop if the reset sequence produces errors */ + if (fdc->sc_state != RESETCOMPLETE && + fdc->sc_state != RECALWAIT && + fdc->sc_state != RECALCOMPLETE) + fdc->sc_state = DORESET; } + /* Clear I task/status field */ + fdc->sc_istatus = FDC_ISTATUS_NONE; + fdc->sc_itask = FDC_ITASK_NONE; + loop: /* Is there a drive for the controller to do a transfer with? */ fd = fdc->sc_drives.tqh_first; @@ -1220,7 +1327,7 @@ loop: fdc->sc_errors = 0; fd->sc_skip = 0; fd->sc_bcount = bp->b_bcount; - fd->sc_blkno = bp->b_blkno / (FDC_BSIZE / DEV_BSIZE); + fd->sc_blkno = (bp->b_blkno * DEV_BSIZE) / FD_BSIZE(fd); timeout_del(&fd->fd_motor_off_to); if ((fd->sc_flags & FD_MOTOR_WAIT) != 0) { fdc->sc_state = MOTORWAIT; @@ -1236,7 +1343,7 @@ loop: fd->sc_flags |= FD_MOTOR | FD_MOTOR_WAIT; fd_set_motor(fdc); fdc->sc_state = MOTORWAIT; - if (fdc->sc_flags & FDC_82077) { /* XXX */ + if ((fdc->sc_flags & FDC_NEEDMOTORWAIT) != 0) { /* XXX */ /* Allow .25s for motor to stabilize. */ timeout_add(&fd->fd_motor_on_to, hz / 4); } else { @@ -1261,26 +1368,27 @@ loop: if (fd->sc_cylin == bp->b_cylin) goto doio; - /* specify command */ - OUT_FDC(fdc, NE7CMD_SPECIFY, SEEKTIMEDOUT); - OUT_FDC(fdc, fd->sc_type->steprate, SEEKTIMEDOUT); - /* XXX head load time == 6ms */ - OUT_FDC(fdc, 6 | NE7_SPECIFY_NODMA, SEEKTIMEDOUT); - - fdc->sc_istate = ISTATE_SENSEI; - /* seek function */ - OUT_FDC(fdc, NE7CMD_SEEK, SEEKTIMEDOUT); - OUT_FDC(fdc, fd->sc_drive, SEEKTIMEDOUT); /* drive number */ - OUT_FDC(fdc, bp->b_cylin * fd->sc_type->step, SEEKTIMEDOUT); - fd->sc_cylin = -1; fdc->sc_state = SEEKWAIT; fdc->sc_nstat = 0; fd->sc_dk.dk_seek++; - disk_busy(&fd->sc_dk); + disk_busy(&fd->sc_dk); timeout_add(&fdc->fdctimeout_to, 4 * hz); + + /* specify command */ + FDC_WRFIFO(fdc, NE7CMD_SPECIFY); + FDC_WRFIFO(fdc, fd->sc_type->steprate); + /* XXX head load time == 6ms */ + FDC_WRFIFO(fdc, 6 | NE7_SPECIFY_NODMA); + + fdc->sc_itask = FDC_ITASK_SENSEI; + /* seek function */ + FDC_WRFIFO(fdc, NE7CMD_SEEK); + FDC_WRFIFO(fdc, fd->sc_drive); /* drive number */ + FDC_WRFIFO(fdc, bp->b_cylin * fd->sc_type->step); + return (1); case DOIO: @@ -1291,10 +1399,10 @@ loop: type = fd->sc_type; sec = fd->sc_blkno % type->seccyl; nblks = type->seccyl - sec; - nblks = min(nblks, fd->sc_bcount / FDC_BSIZE); - nblks = min(nblks, FDC_MAXIOSIZE / FDC_BSIZE); + nblks = min(nblks, fd->sc_bcount / FD_BSIZE(fd)); + nblks = min(nblks, FDC_MAXIOSIZE / FD_BSIZE(fd)); fd->sc_nblks = nblks; - fd->sc_nbytes = finfo ? bp->b_bcount : nblks * FDC_BSIZE; + fd->sc_nbytes = finfo ? bp->b_bcount : nblks * FD_BSIZE(fd); head = sec / type->sectrac; sec -= head * type->sectrac; #ifdef DIAGNOSTIC @@ -1316,40 +1424,44 @@ loop: *fdc->sc_reg_drs = type->rate; #ifdef FD_DEBUG if (fdc_debug > 1) - printf("fdcintr: %s drive %d track %d head %d sec %d nblks %d\n", - read ? "read" : "write", fd->sc_drive, - fd->sc_cylin, head, sec, nblks); + printf("fdcstate: doio: %s drive %d " + "track %d head %d sec %d nblks %d\n", + finfo ? "format" : + (read ? "read" : "write"), + fd->sc_drive, fd->sc_cylin, head, sec, nblks); #endif fdc->sc_state = IOCOMPLETE; - fdc->sc_istate = ISTATE_DMA; + fdc->sc_itask = FDC_ITASK_DMA; fdc->sc_nstat = 0; + + disk_busy(&fd->sc_dk); + + /* allow 3 seconds for operation */ + timeout_add(&fdc->fdctimeout_to, 3 * hz); + if (finfo != NULL) { /* formatting */ - OUT_FDC(fdc, NE7CMD_FORMAT, IOTIMEDOUT); - OUT_FDC(fdc, (head << 2) | fd->sc_drive, IOTIMEDOUT); - OUT_FDC(fdc, finfo->fd_formb_secshift, IOTIMEDOUT); - OUT_FDC(fdc, finfo->fd_formb_nsecs, IOTIMEDOUT); - OUT_FDC(fdc, finfo->fd_formb_gaplen, IOTIMEDOUT); - OUT_FDC(fdc, finfo->fd_formb_fillbyte, IOTIMEDOUT); + FDC_WRFIFO(fdc, NE7CMD_FORMAT); + FDC_WRFIFO(fdc, (head << 2) | fd->sc_drive); + FDC_WRFIFO(fdc, finfo->fd_formb_secshift); + FDC_WRFIFO(fdc, finfo->fd_formb_nsecs); + FDC_WRFIFO(fdc, finfo->fd_formb_gaplen); + FDC_WRFIFO(fdc, finfo->fd_formb_fillbyte); } else { if (read) - OUT_FDC(fdc, NE7CMD_READ, IOTIMEDOUT); + FDC_WRFIFO(fdc, NE7CMD_READ); else - OUT_FDC(fdc, NE7CMD_WRITE, IOTIMEDOUT); - OUT_FDC(fdc, (head << 2) | fd->sc_drive, IOTIMEDOUT); - OUT_FDC(fdc, fd->sc_cylin, IOTIMEDOUT); /*track*/ - OUT_FDC(fdc, head, IOTIMEDOUT); - OUT_FDC(fdc, sec + 1, IOTIMEDOUT); /*sector+1*/ - OUT_FDC(fdc, type->secsize, IOTIMEDOUT);/*sector size*/ - OUT_FDC(fdc, type->sectrac, IOTIMEDOUT);/*secs/track*/ - OUT_FDC(fdc, type->gap1, IOTIMEDOUT); /*gap1 size*/ - OUT_FDC(fdc, type->datalen, IOTIMEDOUT);/*data length*/ + FDC_WRFIFO(fdc, NE7CMD_WRITE); + FDC_WRFIFO(fdc, (head << 2) | fd->sc_drive); + FDC_WRFIFO(fdc, fd->sc_cylin); /*track*/ + FDC_WRFIFO(fdc, head); + FDC_WRFIFO(fdc, sec + 1); /*sector+1*/ + FDC_WRFIFO(fdc, type->secsize); /*sector size*/ + FDC_WRFIFO(fdc, type->sectrac); /*secs/track*/ + FDC_WRFIFO(fdc, type->gap1); /*gap1 size*/ + FDC_WRFIFO(fdc, type->datalen); /*data length*/ } - disk_busy(&fd->sc_dk); - - /* allow 2 seconds for operation */ - timeout_add(&fdc->fdctimeout_to, 2 * hz); return (1); /* will return later */ case SEEKWAIT: @@ -1369,7 +1481,7 @@ loop: cyl != bp->b_cylin * fd->sc_type->step) { #ifdef FD_DEBUG if (fdc_debug) - fdcstatus(&fd->sc_dv, 2, "seek failed"); + fdcstatus(fdc, "seek failed"); #endif fdcretry(fdc); goto loop; @@ -1378,12 +1490,35 @@ loop: goto doio; case IOTIMEDOUT: - FTC_FLIP; - (void)fdcresult(fdc); - /*FALLTHROUGH*/ + /* + * Try to abort the I/O operation without resetting + * the chip first. Poke TC and arrange to pick up + * the timed out I/O command's status. + */ + fdc->sc_itask = FDC_ITASK_RESULT; + fdc->sc_state = IOCLEANUPWAIT; + fdc->sc_nstat = 0; + /* 1/10 second should be enough */ + timeout_add(&fdc->fdctimeout_to, hz / 10); + return (1); + + case IOCLEANUPTIMEDOUT: case SEEKTIMEDOUT: case RECALTIMEDOUT: case RESETTIMEDOUT: + fdcstatus(fdc, "timeout"); + + /* All other timeouts always roll through a chip reset */ + fdcretry(fdc); + + /* Force reset, no matter what fdcretry() says */ + fdc->sc_state = DORESET; + goto loop; + + case IOCLEANUPWAIT: /* IO FAILED, cleanup succeeded */ + timeout_del(&fdc->fdctimeout_to); + disk_unbusy(&fd->sc_dk, (bp->b_bcount - bp->b_resid), + (bp->b_flags & B_READ)); fdcretry(fdc); goto loop; @@ -1398,7 +1533,7 @@ loop: ((st0 & 0xf8) != 0x20 || (fdc->sc_cfg & CFG_EIS) == 0))) { #ifdef FD_DEBUG if (fdc_debug) { - fdcstatus(&fd->sc_dv, 7, + fdcstatus(fdc, bp->b_flags & B_READ ? "read failed" : "write failed"); printf("blkno %d nblks %d nstat %d tc %d\n", @@ -1435,7 +1570,8 @@ loop: } if (fdc->sc_errors) { diskerr(bp, "fd", "soft error", LOG_PRINTF, - fd->sc_skip / FDC_BSIZE, (struct disklabel *)NULL); + fd->sc_skip / FD_BSIZE(fd), + (struct disklabel *)NULL); printf("\n"); fdc->sc_errors = 0; } else { @@ -1465,30 +1601,29 @@ loop: goto loop; case DORESET: - doreset: /* try a reset, keep motor on */ fd_set_motor(fdc); delay(100); - fdc_reset(fdc); fdc->sc_nstat = 0; - fdc->sc_istate = ISTATE_SENSEI; + fdc->sc_itask = FDC_ITASK_SENSEI; fdc->sc_state = RESETCOMPLETE; timeout_add(&fdc->fdctimeout_to, hz / 2); + fdc_reset(fdc); return (1); /* will return later */ case RESETCOMPLETE: timeout_del(&fdc->fdctimeout_to); fdconf(fdc); - /* fall through */ + /* FALLTHROUGH */ case DORECAL: fdc->sc_state = RECALWAIT; - fdc->sc_istate = ISTATE_SENSEI; + fdc->sc_itask = FDC_ITASK_SENSEI; fdc->sc_nstat = 0; - /* recalibrate function */ - OUT_FDC(fdc, NE7CMD_RECAL, RECALTIMEDOUT); - OUT_FDC(fdc, fd->sc_drive, RECALTIMEDOUT); timeout_add(&fdc->fdctimeout_to, 5 * hz); + /* recalibrate function */ + FDC_WRFIFO(fdc, NE7CMD_RECAL); + FDC_WRFIFO(fdc, fd->sc_drive); return (1); /* will return later */ case RECALWAIT: @@ -1504,7 +1639,7 @@ loop: if (fdc->sc_nstat != 2 || (st0 & 0xf8) != 0x20 || cyl != 0) { #ifdef FD_DEBUG if (fdc_debug) - fdcstatus(&fd->sc_dv, 2, "recalibrate failed"); + fdcstatus(fdc, "recalibrate failed"); #endif fdcretry(fdc); goto loop; @@ -1518,12 +1653,23 @@ loop: goto doseek; default: - fdcstatus(&fd->sc_dv, 0, "stray interrupt"); + fdcstatus(fdc, "stray interrupt"); return (1); } #ifdef DIAGNOSTIC panic("fdcintr: impossible"); #endif + +xxx: + /* + * We get here if the chip locks up in FDC_WRFIFO() + * Cancel any operation and schedule a reset. + */ + timeout_del(&fdc->fdctimeout_to); + fdcretry(fdc); + fdc->sc_state = DORESET; + goto loop; + #undef st0 #undef st1 #undef cyl @@ -1535,6 +1681,7 @@ fdcretry(fdc) { struct fd_softc *fd; struct buf *bp; + int error = EIO; fd = fdc->sc_drives.tqh_first; bp = fd->sc_q.b_actf; @@ -1545,6 +1692,13 @@ fdcretry(fdc) switch (fdc->sc_errors) { case 0: + if (fdc->sc_nstat == 7 && + (fdc->sc_status[0] & 0xd8) == 0x40 && + (fdc->sc_status[1] & 0x2) == 0x2) { + printf("%s: read-only medium\n", fd->sc_dv.dv_xname); + error = EROFS; + goto failsilent; + } /* try again */ fdc->sc_state = (fdc->sc_flags & FDC_EIS) ? DOIO : DOSEEK; @@ -1556,6 +1710,21 @@ fdcretry(fdc) break; case 4: + if (fdc->sc_nstat == 7 && + fdc->sc_status[0] == 0 && + fdc->sc_status[1] == 0 && + fdc->sc_status[2] == 0) { + /* + * We've retried a few times and we've got + * valid status and all three status bytes + * are zero. Assume this condition is the + * result of no disk loaded into the drive. + */ + printf("%s: no medium?\n", fd->sc_dv.dv_xname); + error = ENODEV; + goto failsilent; + } + /* still no go; reset the bastard */ fdc->sc_state = DORESET; break; @@ -1564,19 +1733,15 @@ fdcretry(fdc) fail: if ((fd->sc_opts & FDOPT_SILENT) == 0) { diskerr(bp, "fd", "hard error", LOG_PRINTF, - fd->sc_skip / FDC_BSIZE, + fd->sc_skip / FD_BSIZE(fd), (struct disklabel *)NULL); - - printf(" (st0 %b st1 %b st2 %b cyl %d head %d sec %d)\n", - fdc->sc_status[0], NE7_ST0BITS, - fdc->sc_status[1], NE7_ST1BITS, - fdc->sc_status[2], NE7_ST2BITS, - fdc->sc_status[3], fdc->sc_status[4], - fdc->sc_status[5]); + printf("\n"); + fdcstatus(fdc, "controller status"); } + failsilent: bp->b_flags |= B_ERROR; - bp->b_error = EIO; + bp->b_error = error; fdfinish(fd, bp); } fdc->sc_errors++; @@ -1679,38 +1844,40 @@ fdioctl(dev, cmd, addr, flag, p) fd->sc_opts = *(int *)addr; return (0); -#ifdef DEBUG +#ifdef FD_DEBUG case _IO('f', 100): { int i; struct fdc_softc *fdc = (struct fdc_softc *) fd->sc_dv.dv_parent; - out_fdc(fdc, NE7CMD_DUMPREG); + fdc_wrfifo(fdc, NE7CMD_DUMPREG); fdcresult(fdc); printf("dumpreg(%d regs): <", fdc->sc_nstat); for (i = 0; i < fdc->sc_nstat; i++) - printf(" %x", fdc->sc_status[i]); + printf(" 0x%x", fdc->sc_status[i]); printf(">\n"); } return (0); case _IOW('f', 101, int): - ((struct fdc_softc *)fd->sc_dv.dv_parent)->sc_cfg &= - ~CFG_THRHLD_MASK; - ((struct fdc_softc *)fd->sc_dv.dv_parent)->sc_cfg |= - (*(int *)addr & CFG_THRHLD_MASK); - fdconf((struct fdc_softc *) fd->sc_dv.dv_parent); + { + struct fdc_softc *fdc = (struct fdc_softc *) + fd->sc_dv.dv_parent; + fdc->sc_cfg &= ~CFG_THRHLD_MASK; + fdc->sc_cfg |= (*(int *)addr & CFG_THRHLD_MASK); + fdconf(fdc); + } return (0); case _IO('f', 102): { int i; struct fdc_softc *fdc = (struct fdc_softc *) fd->sc_dv.dv_parent; - out_fdc(fdc, NE7CMD_SENSEI); + fdc_wrfifo(fdc, NE7CMD_SENSEI); fdcresult(fdc); printf("sensei(%d regs): <", fdc->sc_nstat); - for (i=0; i< fdc->sc_nstat; i++) + for (i = 0; i < fdc->sc_nstat; i++) printf(" 0x%x", fdc->sc_status[i]); } printf(">\n"); @@ -1719,10 +1886,6 @@ fdioctl(dev, cmd, addr, flag, p) default: return (ENOTTY); } - -#ifdef DIAGNOSTIC - panic("fdioctl: impossible"); -#endif } int @@ -1731,7 +1894,7 @@ fdformat(dev, finfo, p) struct fd_formb *finfo; struct proc *p; { - int rv = 0, s; + int rv = 0; struct fd_softc *fd = fd_cd.cd_devs[FDUNIT(dev)]; struct fd_type *type = fd->sc_type; struct buf *bp; @@ -1751,40 +1914,43 @@ fdformat(dev, finfo, p) * Calculate a fake blkno, so fdstrategy() would initiate a * seek to the requested cylinder. */ - bp->b_blkno = (finfo->cyl * (type->sectrac * type->heads) - + finfo->head * type->sectrac) * FDC_BSIZE / DEV_BSIZE; + bp->b_blkno = ((finfo->cyl * (type->sectrac * type->heads) + + finfo->head * type->sectrac) * FD_BSIZE(fd)) + / DEV_BSIZE; bp->b_bcount = sizeof(struct fd_idfield_data) * finfo->fd_formb_nsecs; bp->b_data = (caddr_t)finfo; #ifdef FD_DEBUG - if (fdc_debug) - printf("fdformat: blkno %x count %ld\n", + if (fdc_debug) { + int i; + + printf("fdformat: blkno 0x%x count %ld\n", bp->b_blkno, bp->b_bcount); + + printf("\tcyl:\t%d\n", finfo->cyl); + printf("\thead:\t%d\n", finfo->head); + printf("\tnsecs:\t%d\n", finfo->fd_formb_nsecs); + printf("\tsshft:\t%d\n", finfo->fd_formb_secshift); + printf("\tgaplen:\t%d\n", finfo->fd_formb_gaplen); + printf("\ttrack data:"); + for (i = 0; i < finfo->fd_formb_nsecs; i++) { + printf(" [c%d h%d s%d]", + finfo->fd_formb_cylno(i), + finfo->fd_formb_headno(i), + finfo->fd_formb_secno(i) ); + if (finfo->fd_formb_secsize(i) != 2) + printf("<sz:%d>", finfo->fd_formb_secsize(i)); + } + printf("\n"); + } #endif /* now do the format */ fdstrategy(bp); /* ...and wait for it to complete */ - s = splbio(); - while (!(bp->b_flags & B_DONE)) { - rv = tsleep((caddr_t)bp, PRIBIO, "fdform", 20 * hz); - if (rv == EWOULDBLOCK) - break; - } - splx(s); - - if (rv == EWOULDBLOCK) { - /* timed out */ - rv = EIO; - s = splbio(); - biodone(bp); - splx(s); - } - if (bp->b_flags & B_ERROR) { - rv = bp->b_error; - } + rv = biowait(bp); PRELE(p); free(bp, M_TEMP); return (rv); @@ -1803,17 +1969,17 @@ fdgetdisklabel(dev) bzero(lp, sizeof(struct disklabel)); bzero(clp, sizeof(struct cpu_disklabel)); - lp->d_secsize = FDC_BSIZE; + lp->d_type = DTYPE_FLOPPY; + lp->d_secsize = FD_BSIZE(fd); lp->d_secpercyl = fd->sc_type->seccyl; - lp->d_ntracks = fd->sc_type->heads; /* Go figure... */ lp->d_nsectors = fd->sc_type->sectrac; lp->d_ncylinders = fd->sc_type->tracks; + lp->d_ntracks = fd->sc_type->heads; /* Go figure... */ + lp->d_secperunit = fd->sc_type->size; + lp->d_rpm = 300; /* XXX like it matters... */ strncpy(lp->d_typename, "floppy disk", sizeof(lp->d_typename)); - lp->d_type = DTYPE_FLOPPY; strncpy(lp->d_packname, "fictitious", sizeof(lp->d_packname)); - lp->d_rpm = 300; /* XXX like it matters... */ - lp->d_secperunit = fd->sc_type->size; lp->d_interleave = 1; lp->d_flags = D_REMOVABLE; @@ -1832,7 +1998,6 @@ fdgetdisklabel(dev) errstring = readdisklabel(dev, fdstrategy, lp, clp, 0); if (errstring) { printf("%s: %s\n", fd->sc_dv.dv_xname, errstring); - return; } } @@ -1848,7 +2013,7 @@ fd_do_eject(fd) auxregbisc(AUXIO4C_FEJ, AUXIO4C_FDS); return; } - if (CPU_ISSUN4M && (fdc->sc_flags & FDC_82077)) { + if (CPU_ISSUN4M && (fdc->sc_flags & FDC_82077) != 0) { int dor = FDO_FRST | FDO_FDMAEN | FDO_MOEN(0); *fdc->sc_reg_dor = dor | FDO_EJ; delay(10); |