 @@ -1,14 +1,14 @@
-/*	$NetBSD: fd.c,v 1.126 2022/05/23 16:58:37 tsutsui Exp $	*/
+/*	$NetBSD: fd.c,v 1.127 2022/05/26 14:27:43 tsutsui Exp $	*/
 /*-
  * Copyright (c) 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Charles M. Hannum and Minoura Makoto.
+ *
  * 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.
 @@ -54,27 +54,27 @@
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS 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.
+ *
  *	@(#)fd.c	7.4 (Berkeley) 5/25/91
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: fd.c,v 1.126 2022/05/23 16:58:37 tsutsui Exp $");
+__KERNEL_RCSID(0, "$NetBSD: fd.c,v 1.127 2022/05/26 14:27:43 tsutsui Exp $");
 #include "opt_ddb.h"
 #include "opt_m68k_arch.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/bus.h>
 #include <sys/callout.h>
 #include <sys/kernel.h>
 #include <sys/conf.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 @@ -150,33 +150,33 @@ struct fdc_softc {
 	bus_dmamap_t sc_dmamap;		/* DMA map */
 	uint8_t *sc_addr;		/* physical address */
 	struct dmac_channel_stat *sc_dmachan; /* intio DMA channel */
 	struct dmac_dma_xfer *sc_xfer;	/* DMA transfer */
 	int sc_read;
 	struct fd_softc *sc_fd[4];	/* pointers to children */
 	TAILQ_HEAD(drivehead, fd_softc) sc_drives;
 	enum fdc_state sc_state;
 	int sc_errors;			/* number of retries so far */
 	uint8_t sc_status[7];		/* copy of registers */
 };
-int fdcintr(void *);
+static int fdcintr(void *);
-void fdcreset(struct fdc_softc *);
+static void fdcreset(struct fdc_softc *);
 /* controller driver configuration */
-int fdcprobe(device_t, cfdata_t, void *);
+static int fdcprobe(device_t, cfdata_t, void *);
-void fdcattach(device_t, device_t, void *);
+static void fdcattach(device_t, device_t, void *);
-int fdprint(void *, const char *);
+static int fdprint(void *, const char *);
 CFATTACH_DECL_NEW(fdc, sizeof(struct fdc_softc),
     fdcprobe, fdcattach, NULL, NULL);
 /*
  * Floppies come in various flavors, e.g., 1.2MB vs 1.44MB; here is how
  * we tell them apart.
  */
 struct fd_type {
 	int	sectrac;	/* sectors per track */
 	int	heads;		/* number of heads */
 	int	seccyl;		/* sectors per cylinder */
 	int	secsize;	/* size code for sectors */
 @@ -184,27 +184,27 @@ struct fd_type {
 	int	steprate;	/* step rate and head unload time */
 	int	gap1;		/* gap len between sectors */
 	int	gap2;		/* formatting gap */
 	int	cyls;		/* total num of cylinders */
 	int	size;		/* size of disk in sectors */
 	int	step;		/* steps per cylinder */
 	int	rate;		/* transfer speed code */
 	uint8_t	fillbyte;	/* format fill byte */
 	uint8_t	interleave;	/* interleave factor (formatting) */
 	const char *name;
 };
 /* The order of entries in the following table is important -- BEWARE! */
-struct fd_type fd_types[] = {
+static struct fd_type fd_types[] = {
 	{  8,2,16,3,0xff,0xdf,0x35,0x74,77,1232,1,FDC_500KBPS, 0xf6, 1,
 	    "1.2MB/[1024bytes/sector]"    }, /* 1.2 MB japanese format */
 	{ 18,2,36,2,0xff,0xcf,0x1b,0x6c,80,2880,1,FDC_500KBPS, 0xf6, 1,
 	    "1.44MB"    }, /* 1.44MB diskette */
 	{ 15,2,30,2,0xff,0xdf,0x1b,0x54,80,2400,1,FDC_500KBPS, 0xf6, 1,
 	    "1.2MB"    }, /* 1.2 MB AT-diskettes */
 	{  9,2,18,2,0xff,0xdf,0x23,0x50,40, 720,2,FDC_300KBPS, 0xf6, 1,
 	    "360KB/AT" }, /* 360kB in 1.2MB drive */
 	{  9,2,18,2,0xff,0xdf,0x2a,0x50,40, 720,1,FDC_250KBPS, 0xf6, 1,
 	    "360KB/PC" }, /* 360kB PC diskettes */
 	{  9,2,18,2,0xff,0xdf,0x2a,0x50,80,1440,1,FDC_250KBPS, 0xf6, 1,
 	    "720KB"    }, /* 3.5" 720kB diskette */
 	{  9,2,18,2,0xff,0xdf,0x23,0x50,80,1440,1,FDC_300KBPS, 0xf6, 1,
 @@ -247,38 +247,38 @@ struct fd_softc {
 	int sc_ops;		/* I/O ops since last switch */
 	struct bufq_state *sc_q;/* pending I/O requests */
 	int sc_active;		/* number of active I/O operations */
 	uint8_t *sc_copybuf;	/* for secsize >=3 */
 	uint8_t sc_part;	/* for secsize >=3 */
 #define	SEC_P10	0x02		/* first part */
 #define	SEC_P01	0x01		/* second part */
 #define	SEC_P11	0x03		/* both part */
 	krndsource_t	rnd_source;
 };
 /* floppy driver configuration */
-int fdprobe(device_t, cfdata_t, void *);
+static int fdprobe(device_t, cfdata_t, void *);
-void fdattach(device_t, device_t, void *);
+static void fdattach(device_t, device_t, void *);
 CFATTACH_DECL_NEW(fd, sizeof(struct fd_softc),
     fdprobe, fdattach, NULL, NULL);
-dev_type_open(fdopen);
+static dev_type_open(fdopen);
-dev_type_close(fdclose);
+static dev_type_close(fdclose);
-dev_type_read(fdread);
+static dev_type_read(fdread);
-dev_type_write(fdwrite);
+static dev_type_write(fdwrite);
-dev_type_ioctl(fdioctl);
+static dev_type_ioctl(fdioctl);
-dev_type_strategy(fdstrategy);
+static dev_type_strategy(fdstrategy);
 const struct bdevsw fd_bdevsw = {
 	.d_open = fdopen,
 	.d_close = fdclose,
 	.d_strategy = fdstrategy,
 	.d_ioctl = fdioctl,
 	.d_dump = nodump,
 	.d_psize = nosize,
 	.d_discard = nodiscard,
 	.d_flag = D_DISK
 };
 const struct cdevsw fd_cdevsw = {
 @@ -286,52 +286,54 @@ const struct cdevsw fd_cdevsw = {
 	.d_close = fdclose,
 	.d_read = fdread,
 	.d_write = fdwrite,
 	.d_ioctl = fdioctl,
 	.d_stop = nostop,
 	.d_tty = notty,
 	.d_poll = nopoll,
 	.d_mmap = nommap,
 	.d_kqfilter = nokqfilter,
 	.d_discard = nodiscard,
 	.d_flag = D_DISK
 };
-void fdstart(struct fd_softc *);
+static void fdstart(struct fd_softc *);
 struct dkdriver fddkdriver = {
 	.d_strategy = fdstrategy
 };
-void fd_set_motor(struct fdc_softc *, int);
+static void fd_set_motor(struct fdc_softc *, int);
-void fd_motor_off(void *);
+static void fd_motor_off(void *);
 #if 0
-void fd_motor_on(void *);
+static void fd_motor_on(void *);
 #endif
-int fdcresult(struct fdc_softc *);
+static int fdcresult(struct fdc_softc *);
-int out_fdc(bus_space_tag_t, bus_space_handle_t, uint8_t);
+static int out_fdc(bus_space_tag_t, bus_space_handle_t, uint8_t);
-void fdcstart(struct fdc_softc *);
+static void fdcstart(struct fdc_softc *);
-void fdcstatus(device_t, int, const char *);
+static void fdcstatus(device_t, int, const char *);
-void fdctimeout(void *);
+static void fdctimeout(void *);
-void fdcpseudointr(void *);
+#if 0
-void fdcretry(struct fdc_softc *);
+static void fdcpseudointr(void *);
-void fdfinish(struct fd_softc *, struct buf *);
+#endif
 static void fdcretry(struct fdc_softc *);
 static void fdfinish(struct fd_softc *, struct buf *);
 static struct fd_type *fd_dev_to_type(struct fd_softc *, dev_t);
-int fdformat(dev_t, struct ne7_fd_formb *, struct lwp *);
+static int fdformat(dev_t, struct ne7_fd_formb *, struct lwp *);
 static int fdcpoll(struct fdc_softc *);
 static int fdgetdisklabel(struct fd_softc *, dev_t);
 static void fd_do_eject(struct fdc_softc *, int);
-void fd_mountroot_hook(device_t);
+static void fd_mountroot_hook(device_t);
 /* DMA transfer routines */
 inline static void fdc_dmastart(struct fdc_softc *, int, void *, vsize_t);
 inline static void fdc_dmaabort(struct fdc_softc *);
 static int fdcdmaintr(void *);
 static int fdcdmaerrintr(void *);
 inline static void
 fdc_dmastart(struct fdc_softc *fdc, int read, void *addr, vsize_t count)
+{
 	int error;
 	DPRINTF(("fdc_dmastart: %s, addr = %p, count = %ld\n",
 @@ -390,27 +392,27 @@ fdcdmaintr(void *arg)
 	return 0;
+}
 static int
 fdcdmaerrintr(void *dummy)
+{
 	DPRINTF(("fdcdmaerrintr\n"));
 	return 0;
+}
 /* ARGSUSED */
-int
+static int
 fdcprobe(device_t parent, cfdata_t cf, void *aux)
+{
 	struct intio_attach_args *ia = aux;
 	if (strcmp(ia->ia_name, "fdc") != 0)
 		return 0;
 	if (ia->ia_addr == INTIOCF_ADDR_DEFAULT)
 		ia->ia_addr = FDC_ADDR;
 	if (ia->ia_intr == INTIOCF_INTR_DEFAULT)
 		ia->ia_intr = FDC_INTR;
 	if (ia->ia_dma == INTIOCF_DMA_DEFAULT)
 		ia->ia_dma = FDC_DMA;
 @@ -433,37 +435,37 @@ fdcprobe(device_t parent, cfdata_t cf, v
  */
 struct fdc_attach_args {
 	int fa_drive;
 	struct fd_type *fa_deftype;
 };
 /*
  * Print the location of a disk drive (called just before attaching the
  * the drive).  If `fdc' is not NULL, the drive was found but was not
  * in the system config file; print the drive name as well.
  * Return QUIET (config_find ignores this if the device was configured) to
  * avoid printing `fdN not configured' messages.
  */
-int
+static int
 fdprint(void *aux, const char *fdc)
+{
 	struct fdc_attach_args *fa = aux;
 	if (fdc == NULL)
 		aprint_normal(" drive %d", fa->fa_drive);
 	return QUIET;
+}
-void
+static void
 fdcattach(device_t parent, device_t self, void *aux)
+{
 	struct fdc_softc *fdc = device_private(self);
 	bus_space_tag_t iot;
 	bus_space_handle_t ioh;
 	struct intio_attach_args *ia = aux;
 	struct fdc_attach_args fa;
 	iot = ia->ia_bst;
 	aprint_normal("\n");
 	/* Re-map the I/O space. */
 @@ -510,50 +512,50 @@ fdcattach(device_t parent, device_t self
 	aprint_normal_dev(self, "uPD72065 FDC\n");
 	out_fdc(iot, ioh, NE7CMD_SPECIFY);	/* specify command */
 	out_fdc(iot, ioh, 0xd0);
 	out_fdc(iot, ioh, 0x10);
 	/* physical limit: four drives per controller. */
 	for (fa.fa_drive = 0; fa.fa_drive < 4; fa.fa_drive++) {
 		(void)config_found(self, (void *)&fa, fdprint, CFARGS_NONE);
+	}
 	intio_enable_intr(SICILIAN_INTR_FDC);
+}
-void
+static void
 fdcreset(struct fdc_softc *fdc)
+{
 	bus_space_write_1(fdc->sc_iot, fdc->sc_ioh, fdsts, NE7CMD_RESET);
+}
 static int
 fdcpoll(struct fdc_softc *fdc)
+{
 	int i = 25000;
 	while (--i > 0) {
 		if ((intio_get_sicilian_intr() & SICILIAN_STAT_FDC) != 0) {
 			out_fdc(fdc->sc_iot, fdc->sc_ioh, NE7CMD_SENSEI);
 			fdcresult(fdc);
 			break;
+		}
 		DELAY(100);
+	}
 	return i;
+}
-int
+static int
 fdprobe(device_t parent, cfdata_t cf, void *aux)
+{
 	struct fdc_softc *fdc = device_private(parent);
 	struct fd_type *type;
 	struct fdc_attach_args *fa = aux;
 	int drive = fa->fa_drive;
 	bus_space_tag_t iot = fdc->sc_iot;
 	bus_space_handle_t ioh = fdc->sc_ioh;
 	int n = 0;
 	int found = 0;
 	int i;
 	if (cf->cf_loc[FDCCF_UNIT] != FDCCF_UNIT_DEFAULT &&
 @@ -610,27 +612,27 @@ fdprobe(device_t parent, cfdata_t cf, vo
 	    fdctl, (type->rate << 4) | drive);
 	fdc_force_ready(FDCSTBY);
 	if (!found) {
 		intio_enable_intr(SICILIAN_INTR_FDC);
 		return 0;
+	}
 	return 1;
+}
 /*
  * Controller is working, and drive responded.  Attach it.
  */
-void
+static void
 fdattach(device_t parent, device_t self, void *aux)
+{
 	struct fdc_softc *fdc = device_private(parent);
 	struct fd_softc *fd = device_private(self);
 	struct fdc_attach_args *fa = aux;
 	struct fd_type *type = &fd_types[0];	/* XXX 1.2MB */
 	int drive = fa->fa_drive;
 #if 0
 	callout_init(&fd->sc_motoron_ch, 0);
 #endif
 	callout_init(&fd->sc_motoroff_ch, 0);
 @@ -670,27 +672,27 @@ fdattach(device_t parent, device_t self,
 	    RND_TYPE_DISK, RND_FLAG_DEFAULT);
+}
 static struct fd_type *
 fd_dev_to_type(struct fd_softc *fd, dev_t dev)
+{
 	size_t type = FDTYPE(dev);
 	if (type >= __arraycount(fd_types))
 		return NULL;
 	return &fd_types[type];
+}
-void
+static void
 fdstrategy(struct buf *bp)
+{
 	struct fd_softc *fd;
 	int unit;
 	int sz;
 	int s;
 	unit = FDUNIT(bp->b_dev);
 	fd = device_lookup_private(&fd_cd, unit);
 	if (fd == NULL) {
 		bp->b_error = EINVAL;
 		goto done;
+	}
 @@ -751,42 +753,42 @@ fdstrategy(struct buf *bp)
 			printf("fdstrategy: controller inactive\n");
 			fdcstart(fdc);
+		}
+	}
 #endif
 	splx(s);
 	return;
  done:
 	/* Toss transfer; we're done early. */
 	biodone(bp);
+}
-void
+static void
 fdstart(struct fd_softc *fd)
+{
 	struct fdc_softc *fdc = device_private(device_parent(fd->sc_dev));
 	int active = !TAILQ_EMPTY(&fdc->sc_drives);
 	/* Link into controller queue. */
 	fd->sc_active = 1;
 	TAILQ_INSERT_TAIL(&fdc->sc_drives, fd, sc_drivechain);
 	/* If controller not already active, start it. */
 	if (!active)
 		fdcstart(fdc);
+}
-void
+static void
 fdfinish(struct fd_softc *fd, struct buf *bp)
+{
 	struct fdc_softc *fdc = device_private(device_parent(fd->sc_dev));
 	/*
 	 * Move this drive to the end of the queue to give others a `fair'
 	 * chance.  We only force a switch if N operations are completed while
 	 * another drive is waiting to be serviced, since there is a long motor
 	 * startup delay whenever we switch.
 	 */
 	(void)bufq_get(fd->sc_q);
 	if (TAILQ_NEXT(fd, sc_drivechain) && ++fd->sc_ops >= 8) {
 		fd->sc_ops = 0;
 @@ -797,94 +799,94 @@ fdfinish(struct fd_softc *fd, struct buf
 			fd->sc_active = 0;
+	}
 	bp->b_resid = fd->sc_bcount;
 	fd->sc_skip = 0;
 	rnd_add_uint32(&fd->rnd_source, bp->b_blkno);
 	biodone(bp);
 	/* turn off motor 5s from now */
 	callout_reset(&fd->sc_motoroff_ch, 5 * hz, fd_motor_off, fd);
 	fdc->sc_state = DEVIDLE;
+}
-int
+static int
 fdread(dev_t dev, struct uio *uio, int flags)
+{
 	return physio(fdstrategy, NULL, dev, B_READ, minphys, uio);
+}
-int
+static int
 fdwrite(dev_t dev, struct uio *uio, int flags)
+{
 	return physio(fdstrategy, NULL, dev, B_WRITE, minphys, uio);
+}
-void
+static void
 fd_set_motor(struct fdc_softc *fdc, int reset)
+{
 	struct fd_softc *fd;
 	int n;
 	DPRINTF(("fd_set_motor:\n"));
 	for (n = 0; n < 4; n++) {
 		fd = fdc->sc_fd[n];
 		if (fd != NULL && (fd->sc_flags & FD_MOTOR) != 0)
 			bus_space_write_1(fdc->sc_iot, fdc->sc_ioh, fdctl,
 x80 | (fd->sc_type->rate << 4)| n);
+	}
+}
-void
+static void
 fd_motor_off(void *arg)
+{
 	struct fd_softc *fd = arg;
 	struct fdc_softc *fdc = device_private(device_parent(fd->sc_dev));
 	int s;
 	DPRINTF(("fd_motor_off:\n"));
 	s = splbio();
 	fd->sc_flags &= ~(FD_MOTOR | FD_MOTOR_WAIT);
 	bus_space_write_1(fdc->sc_iot, fdc->sc_ioh, fdctl,
 	    (fd->sc_type->rate << 4) | fd->sc_drive);
 #if 0
 	fd_set_motor(fdc, 0); /* XXX */
 #endif
 	splx(s);
+}
 #if 0 /* on x68k motor on triggers interrupts by state change of ready line. */
-void
+static void
 fd_motor_on(void *arg)
+{
 	struct fd_softc *fd = arg;
 	struct fdc_softc *fdc = device_private(device_parent(fd->sc_dev));
 	int s;
 	DPRINTF(("fd_motor_on:\n"));
 	s = splbio();
 	fd->sc_flags &= ~FD_MOTOR_WAIT;
 	if ((TAILQ_FIRST(&fdc->sc_drives) == fd) &&
 	    (fdc->sc_state == MOTORWAIT))
 		(void)fdcintr(fdc);
 	splx(s);
+}
 #endif
-int
+static int
 fdcresult(struct fdc_softc *fdc)
+{
 	bus_space_tag_t iot = fdc->sc_iot;
 	bus_space_handle_t ioh = fdc->sc_ioh;
 	uint8_t i;
 	int j, n;
 	n = 0;
 	for (j = 100000; j != 0; j--) {
 		i = bus_space_read_1(iot, ioh, fdsts) &
 		  (NE7_DIO | NE7_RQM | NE7_CB);
 		if (i == NE7_RQM)
 @@ -893,42 +895,42 @@ fdcresult(struct fdc_softc *fdc)
 			if (n >= sizeof(fdc->sc_status)) {
 				log(LOG_ERR, "fdcresult: overrun\n");
 				return -1;
+			}
 			fdc->sc_status[n++] =
 			    bus_space_read_1(iot, ioh, fddata);
+		}
 		delay(10);
+	}
 	log(LOG_ERR, "fdcresult: timeout\n");
 	return -1;
+}
-int
+static int
 out_fdc(bus_space_tag_t iot, bus_space_handle_t ioh, uint8_t x)
+{
 	int i = 100000;
 	while ((bus_space_read_1(iot, ioh, fdsts) & NE7_DIO) && i-- > 0);
 	if (i <= 0)
 		return -1;
 	while ((bus_space_read_1(iot, ioh, fdsts) & NE7_RQM) == 0 && i-- > 0);
 	if (i <= 0)
 		return -1;
 	bus_space_write_1(iot, ioh, fddata, x);
 	return 0;
+}
-int
+static int
 fdopen(dev_t dev, int flags, int mode, struct lwp *l)
+{
 	int unit;
 	struct fd_softc *fd;
 	struct fd_type *type;
 	struct fdc_softc *fdc;
 	unit = FDUNIT(dev);
 	fd = device_lookup_private(&fd_cd, unit);
 	if (fd == NULL)
 		return ENXIO;
 	type = fd_dev_to_type(fd, dev);
 	if (type == NULL)
 @@ -953,27 +955,27 @@ fdopen(dev_t dev, int flags, int mode, s
 	case S_IFCHR:
 		fd->sc_flags |= FD_COPEN;
 		break;
 	case S_IFBLK:
 		fd->sc_flags |= FD_BOPEN;
 		break;
+	}
 	fdgetdisklabel(fd, dev);
 	return 0;
+}
-int
+static int
 fdclose(dev_t dev, int flags, int mode, struct lwp *l)
+{
 	int unit = FDUNIT(dev);
 	struct fd_softc *fd = device_lookup_private(&fd_cd, unit);
 	struct fdc_softc *fdc = device_private(device_parent(fd->sc_dev));
 	DPRINTF(("fdclose %d\n", unit));
 	switch (mode) {
 	case S_IFCHR:
 		fd->sc_flags &= ~FD_COPEN;
 		break;
 	case S_IFBLK:
 @@ -982,27 +984,27 @@ fdclose(dev_t dev, int flags, int mode,
+	}
 	/* clear flags */
 	fd->sc_opts &= ~(FDOPT_NORETRY | FDOPT_SILENT);
 	if ((fd->sc_flags & FD_OPEN) == 0) {
 		bus_space_write_1(fdc->sc_iot, fdc->sc_ioh, fdout,
 		    (1 << unit));
 		bus_space_write_1(fdc->sc_iot, fdc->sc_ioh, fdout, 0);
+	}
 	return 0;
+}
-void
+static void
 fdcstart(struct fdc_softc *fdc)
+{
 #ifdef DIAGNOSTIC
 	/*
 	 * only got here if controller's drive queue was inactive; should
 	 * be in idle state
 	 */
 	if (fdc->sc_state != DEVIDLE) {
 		printf("fdcstart: not idle\n");
 		return;
+	}
 #endif
 @@ -1031,75 +1033,75 @@ fdcpstatus(int n, struct fdc_softc *fdc)
 		snprintb(bits, sizeof(bits), NE7_ST2BITS, fdc->sc_status[2]);
 		printf(" st2 %s", bits);
 		printf(" cyl %d head %d sec %d)\n",
 		    fdc->sc_status[3], fdc->sc_status[4], fdc->sc_status[5]);
 		break;
 #ifdef DIAGNOSTIC
 	default:
 		printf("\nfdcstatus: weird size");
 		break;
 #endif
+	}
+}
-void
+static void
 fdcstatus(device_t dv, int n, const char *s)
+{
 	struct fdc_softc *fdc = device_private(device_parent(dv));
 	if (n == 0) {
 		out_fdc(fdc->sc_iot, fdc->sc_ioh, NE7CMD_SENSEI);
 		(void)fdcresult(fdc);
 		n = 2;
+	}
 	printf("%s: %s: state %d", device_xname(dv), s, fdc->sc_state);
 	fdcpstatus(n, fdc);
+}
-void
+static void
 fdctimeout(void *arg)
+{
 	struct fdc_softc *fdc = arg;
 	struct fd_softc *fd = TAILQ_FIRST(&fdc->sc_drives);
 	int s;
 	s = splbio();
 	fdcstatus(fd->sc_dev, 0, "timeout");
 	if (bufq_peek(fd->sc_q) != NULL)
 		fdc->sc_state++;
 	else
 		fdc->sc_state = DEVIDLE;
 	(void)fdcintr(fdc);
 	splx(s);
+}
 #if 0
-void
+static void
 fdcpseudointr(void *arg)
+{
 	int s;
 	struct fdc_softc *fdc = arg;
 	/* just ensure it has the right spl */
 	s = splbio();
 	(void)fdcintr(fdc);
 	splx(s);
+}
 #endif
-int
+static int
 fdcintr(void *arg)
+{
 	struct fdc_softc *fdc = arg;
 #define	st0	fdc->sc_status[0]
 #define	cyl	fdc->sc_status[1]
 	struct fd_softc *fd;
 	struct buf *bp;
 	bus_space_tag_t iot = fdc->sc_iot;
 	bus_space_handle_t ioh = fdc->sc_ioh;
 	int read, head, sec, pos, i, sectrac, nblks;
 	int tmp;
 	struct fd_type *type;
 	struct ne7_fd_formb *finfo = NULL;
 @@ -1550,27 +1552,27 @@ fdcintr(void *arg)
 		goto doseek;
 	default:
 		fdcstatus(fd->sc_dev, 0, "stray interrupt");
 		return 1;
+	}
 #ifdef DIAGNOSTIC
 	panic("fdcintr: impossible");
 #endif
 #undef	st0
 #undef	cyl
+}
-void
+static void
 fdcretry(struct fdc_softc *fdc)
+{
 	struct fd_softc *fd;
 	struct buf *bp;
 	DPRINTF(("fdcretry:\n"));
 	fd = TAILQ_FIRST(&fdc->sc_drives);
 	bp = bufq_peek(fd->sc_q);
 	if (fd->sc_opts & FDOPT_NORETRY)
 		goto fail;
 	switch (fdc->sc_errors) {
 @@ -1595,27 +1597,27 @@ fdcretry(struct fdc_softc *fdc)
 	fail:
 		if ((fd->sc_opts & FDOPT_SILENT) == 0) {
 			diskerr(bp, "fd", "hard error", LOG_PRINTF,
 			    fd->sc_skip, (struct disklabel *)NULL);
 			fdcpstatus(7, fdc);
+		}
 		bp->b_error = EIO;
 		fdfinish(fd, bp);
+	}
 	fdc->sc_errors++;
+}
-int
+static int
 fdioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
+{
 	struct fd_softc *fd = device_lookup_private(&fd_cd, FDUNIT(dev));
 	struct fdc_softc *fdc = device_private(device_parent(fd->sc_dev));
 	struct fdformat_parms *form_parms;
 	struct fdformat_cmd *form_cmd;
 	struct ne7_fd_formb *fd_formb;
 	int part = DISKPART(dev);
 	struct disklabel buffer;
 	int error;
 	unsigned int scratch;
 	int il[FD_MAX_NSEC + 1];
 	int i, j;
 @@ -1795,27 +1797,27 @@ fdioctl(dev_t dev, u_long cmd, void *add
 		DPRINTF(("ODIOCEJECT\n"));
 		fd_do_eject(fdc, FDUNIT(dev));
 		return 0;
 	default:
 		return ENOTTY;
+	}
 #ifdef DIAGNOSTIC
 	panic("fdioctl: impossible");
 #endif
+}
-int
+static int
 fdformat(dev_t dev, struct ne7_fd_formb *finfo, struct lwp *l)
+{
 	int rv = 0;
 	struct fd_softc *fd = device_lookup_private(&fd_cd, FDUNIT(dev));
 	struct fd_type *type = fd->sc_type;
 	struct buf *bp;
 	/* set up a buffer header for fdstrategy() */
 	bp = getiobuf(NULL, false);
 	if (bp == NULL)
 		return ENOBUFS;
 	bp->b_cflags = BC_BUSY;
 @@ -1837,27 +1839,27 @@ fdformat(dev_t dev, struct ne7_fd_formb
 	printf("fdformat: blkno %" PRIx64 " count %x\n",
 	    bp->b_blkno, bp->b_bcount);
 #endif
 	/* now do the format */
 	fdstrategy(bp);
 	/* ...and wait for it to complete */
 	rv = biowait(bp);
 	putiobuf(bp);
 	return rv;
+}
-void
+static void
 fd_do_eject(struct fdc_softc *fdc, int unit)
+{
 	bus_space_write_1(fdc->sc_iot, fdc->sc_ioh, fdout, 0x20 | (1 << unit));
 	DELAY(1); /* XXX */
 	bus_space_write_1(fdc->sc_iot, fdc->sc_ioh, fdout, 0x20);
+}
 /*
  * Build disk label. For now we only create a label from what we know
  * from 'sc'.
  */
 static int
 @@ -1892,27 +1894,27 @@ fdgetdisklabel(struct fd_softc *sc, dev_
 	lp->d_checksum    = dkcksum(lp);
 	lp->d_partitions[part].p_size   = lp->d_secperunit;
 	lp->d_partitions[part].p_fstype = FS_UNUSED;
 	lp->d_partitions[part].p_fsize  = 1024;
 	lp->d_partitions[part].p_frag   = 8;
 	return 0;
+}
 /*
  * Mountroot hook: prompt the user to enter the root file system
  * floppy.
  */
-void
+static void
 fd_mountroot_hook(device_t dev)
+{
 	struct fd_softc *fd = device_private(dev);
 	struct fdc_softc *fdc = device_private(device_parent(fd->sc_dev));
 	int c;
 	/* XXX device_unit() abuse */
 	fd_do_eject(fdc, device_unit(dev));
 	printf("Insert filesystem floppy and press return.");
 	for (;;) {
 		c = cngetc();
 		if ((c == '\r') || (c == '\n')) {
 			printf("\n");