 @@ -1,14 +1,14 @@
-/*	$NetBSD: fd.c,v 1.74 2010/04/07 13:14:23 tsutsui Exp $	*/
+/*	$NetBSD: fd.c,v 1.75 2010/04/07 13:53:05 tsutsui Exp $	*/
 /*
  * Copyright (c) 1995 Leo Weppelman.
  * All rights reserved.
+ *
  * 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.
 @@ -34,27 +34,27 @@
  * use of some special DMA accessing code.
+ *
  * Interrupts from the FDC are in fact DMA interrupts which get their
  * first level handling in 'dma.c' . If the floppy driver is currently
  * using DMA the interrupt is signalled to 'fdcint'.
+ *
  * TODO:
  *   - Test it with 2 drives (I don't have them)
  *   - Test it with an HD-drive (Don't have that either)
  *   - Finish ioctl's
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: fd.c,v 1.74 2010/04/07 13:14:23 tsutsui Exp $");
+__KERNEL_RCSID(0, "$NetBSD: fd.c,v 1.75 2010/04/07 13:53:05 tsutsui Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/callout.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/buf.h>
 #include <sys/bufq.h>
 #include <sys/proc.h>
 #include <sys/device.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 #include <sys/conf.h>
 @@ -62,26 +62,28 @@ __KERNEL_RCSID(0, "$NetBSD: fd.c,v 1.74
 #include <sys/disk.h>
 #include <sys/dkbad.h>
 #include <atari/atari/device.h>
 #include <atari/atari/stalloc.h>
 #include <machine/disklabel.h>
 #include <machine/iomap.h>
 #include <machine/mfp.h>
 #include <machine/dma.h>
 #include <machine/video.h>
 #include <machine/cpu.h>
 #include <atari/dev/ym2149reg.h>
 #include <atari/dev/fdreg.h>
 #include "ioconf.h"
 /*
  * Be verbose for debugging
  */
 /*#define FLP_DEBUG	1 */
 #define	FDC_MAX_DMA_AD	0x1000000	/* No DMA possible beyond	*/
 /* Parameters for the disk drive. */
 #define SECTOR_SIZE	512	/* physical sector size in bytes	*/
 #define NR_DRIVES	2	/* maximum number of drives		*/
 #define NR_TYPES	3	/* number of diskette/drive combinations*/
 #define MAX_ERRORS	10	/* how often to try rd/wt before quitting*/
 #define STEP_DELAY	6000	/* 6ms (6000us) delay after stepping	*/
 @@ -111,52 +113,52 @@ __KERNEL_RCSID(0, "$NetBSD: fd.c,v 1.74
 #define	FLP_HD		1		/* High density			*/
 #define	b_block		b_resid		/* FIXME: this is not the place	*/
 /*
  * Global data for all physical floppy devices
  */
 static short	selected = 0;		/* drive/head currently selected*/
 static short	motoron  = 0;		/* motor is spinning		*/
 static short	nopens   = 0;		/* Number of opens executed	*/
 static short	fd_state = FLP_IDLE;	/* Current driver state		*/
-static int	lock_stat= 0;		/* DMA locking status		*/
+static int	lock_stat = 0;		/* DMA locking status		*/
 static short	fd_cmd   = 0;		/* command being executed	*/
-static const char *fd_error= NULL;	/* error from fd_xfer_ok()	*/
+static const char *fd_error = NULL;	/* error from fd_xfer_ok()	*/
 /*
  * Private per device data
  */
 struct fd_softc {
 	device_t	sc_dev;		/* generic device info		*/
 	struct disk	dkdev;		/* generic disk info		*/
 	struct bufq_state *bufq;	/* queue of buf's		*/
 	struct callout	sc_motor_ch;
 	int		unit;		/* unit for atari controlling hw*/
 	int		nheads;		/* number of heads in use	*/
 	int		nsectors;	/* number of sectors/track	*/
 	int		density;	/* density code			*/
 	int		nblocks;	/* number of blocks on disk	*/
 	int		curtrk;		/* track head positioned on	*/
 	short		flags;		/* misc flags			*/
 	short		part;		/* Current open partition	*/
 	int		sector;		/* logical sector for I/O	*/
-	char		*io_data;	/* KVA for data transfer	*/
+	uint8_t		*io_data;	/* KVA for data transfer	*/
 	int		io_bytes;	/* bytes left for I/O		*/
 	int		io_dir;		/* B_READ/B_WRITE		*/
 	int		errcnt;		/* current error count		*/
-	u_char		*bounceb;	/* Bounce buffer		*/
+	uint8_t		*bounceb;	/* Bounce buffer		*/
 };
 /*
  * Flags in fd_softc:
  */
 #define FLPF_NOTRESP	0x001		/* Unit not responding		*/
 #define FLPF_ISOPEN	0x002		/* Unit is open			*/
 #define FLPF_SPARE	0x004		/* Not used			*/
 #define FLPF_HAVELAB	0x008		/* We have a valid label	*/
 #define FLPF_BOUNCE	0x010		/* Now using the bounce buffer	*/
 #define FLPF_WRTPROT	0x020		/* Unit is write-protected	*/
 #define FLPF_EMPTY	0x040		/* Unit is empty		*/
 @@ -207,644 +209,655 @@ static void	fdstatus(struct fd_softc *);
 static void	fd_xfer(struct fd_softc *);
 static void	fdcint(struct fd_softc *);
 static int	fd_xfer_ok(struct fd_softc *);
 static void	fdmotoroff(struct fd_softc *);
 static void	fdminphys(struct buf *);
 static void	fdtestdrv(struct fd_softc *);
 static void	fdgetdefaultlabel(struct fd_softc *, struct disklabel *,
 		    int);
 static int	fdgetdisklabel(struct fd_softc *, dev_t);
 static int	fdselect(int, int, int);
 static void	fddeselect(void);
 static void	fdmoff(struct fd_softc *);
-static inline u_char	read_fdreg(u_short);
+static u_short rd_cfg_switch(void);
 static inline uint8_t	read_fdreg(u_short);
 static inline void	write_fdreg(u_short, u_short);
-static inline u_char	read_dmastat(void);
+static inline uint8_t	read_dmastat(void);
-static inline u_char read_fdreg(u_short regno)
+static inline
 uint8_t read_fdreg(u_short regno)
+{
 	DMA->dma_mode = regno;
-	return(DMA->dma_data);
+	return DMA->dma_data;
+}
-static inline void write_fdreg(u_short regno, u_short val)
+static inline
 void write_fdreg(u_short regno, u_short val)
+{
 	DMA->dma_mode = regno;
 	DMA->dma_data = val;
+}
-static inline u_char read_dmastat(void)
+static inline
 uint8_t read_dmastat(void)
+{
 	DMA->dma_mode = FDC_CS | DMA_SCREG;
-	return(DMA->dma_stat);
+	return DMA->dma_stat;
+}
 /*
  * Config switch stuff. Used only for the floppy type for now. That's
  * why it's here...
  * XXX: If needed in more places, it should be moved to it's own include file.
  * Note: This location _must_ be read as an u_short. Failure to do so
  *       will return garbage!
  */
-static u_short rd_cfg_switch(void);
+static u_short
-static u_short rd_cfg_switch(void)
+rd_cfg_switch(void)
+{
 	return(*((volatile u_short *)AD_CFG_SWITCH));
 	return *(volatile u_short *)AD_CFG_SWITCH;
+}
 /*
  * Switch definitions.
  * Note: ON reads as a zero bit!
  */
 #define	CFG_SWITCH_NOHD	0x4000
 /*
  * Autoconfig stuff....
  */
 extern struct cfdriver fd_cd;
 static int	fdcmatch(device_t, cfdata_t, void *);
 static int	fdcprint(void *, const char *);
 static void	fdcattach(device_t, device_t, void *);
 CFATTACH_DECL_NEW(fdc, 0,
     fdcmatch, fdcattach, NULL, NULL);
 const struct bdevsw fd_bdevsw = {
 	fdopen, fdclose, fdstrategy, fdioctl, nodump, nosize, D_DISK
 };
 const struct cdevsw fd_cdevsw = {
 	fdopen, fdclose, fdread, fdwrite, fdioctl,
 	nostop, notty, nopoll, nommap, nokqfilter, D_DISK
 };
 static int
 fdcmatch(device_t parent, cfdata_t match, void *aux)
+{
-	static int	fdc_matched = 0;
+	static int fdc_matched = 0;
 	/* Match only once */
-	if(strcmp("fdc", aux) || fdc_matched)
+	if (strcmp("fdc", aux) || fdc_matched)
-		return(0);
+		return 0;
 	fdc_matched = 1;
-	return(1);
+	return 1;
+}
 static void
 fdcattach(device_t parent, device_t self, void *aux)
+{
 	struct fd_softc	fdsoftc;
-	int		i, nfound, first_found;
+	int i, nfound, first_found;
 	nfound = first_found = 0;
 	printf("\n");
 	fddeselect();
-	for(i = 0; i < NR_DRIVES; i++) {
+	for (i = 0; i < NR_DRIVES; i++) {
 		/*
 		 * Test if unit is present
 		 */
 		fdsoftc.unit  = i;
 		fdsoftc.flags = 0;
 		st_dmagrab((dma_farg)fdcint, (dma_farg)fdtestdrv, &fdsoftc,
-								&lock_stat, 0);
+		    &lock_stat, 0);
 		st_dmafree(&fdsoftc, &lock_stat);
-		if(!(fdsoftc.flags & FLPF_NOTRESP)) {
+		if ((fdsoftc.flags & FLPF_NOTRESP) == 0) {
-			if(!nfound)
+			if (nfound == 0)
 				first_found = i;
 			nfound++;
-			config_found(self, (void*)i, fdcprint);
+			config_found(self, (void *)i, fdcprint);
+		}
+	}
-	if(nfound) {
+	if (nfound != 0) {
 		struct fd_softc *fdsc =
 		    device_lookup_private(&fd_cd, first_found);
 		/*
 		 * Make sure motor will be turned of when a floppy is
 		 * inserted in the first selected drive.
 		 */
 		fdselect(first_found, 0, FLP_DD);
 		fd_state = FLP_MON;
 		callout_reset(&fdsc->sc_motor_ch, 0, (FPV)fdmotoroff, fdsc);
 		/*
 		 * enable disk related interrupts
 		 */
 		MFP->mf_ierb |= IB_DINT;
-		MFP->mf_iprb  = (u_int8_t)~IB_DINT;
+		MFP->mf_iprb  = (uint8_t)~IB_DINT;
 		MFP->mf_imrb |= IB_DINT;
+	}
+}
 static int
 fdcprint(void *aux, const char *pnp)
+{
 	if (pnp != NULL)
 		aprint_normal("fd%d at %s:", (int)aux, pnp);
-	return(UNCONF);
+	return UNCONF;
+}
 static int	fdmatch(device_t, cfdata_t, void *);
 static void	fdattach(device_t, device_t, void *);
 struct dkdriver fddkdriver = { fdstrategy };
 CFATTACH_DECL_NEW(fd, sizeof(struct fd_softc),
     fdmatch, fdattach, NULL, NULL);
 extern struct cfdriver fd_cd;
 static int
 fdmatch(device_t parent, cfdata_t match, void *aux)
+{
 	return(1);
 	return 1;
+}
 static void
 fdattach(device_t parent, device_t self, void *aux)
+{
 	struct fd_softc	*sc;
 	struct fd_types *type;
 	u_short		swtch;
 	sc = device_private(self);
 	sc->sc_dev = self;
 	callout_init(&sc->sc_motor_ch, 0);
 	/*
 	 * Find out if an Ajax chip might be installed. Set the default
 	 * floppy type accordingly.
 	 */
 	swtch    = rd_cfg_switch();
 	def_type = (swtch & CFG_SWITCH_NOHD) ? FLP_TYPE_720 : FLP_TYPE_144;
 	type     = &fdtypes[def_type];
 	aprint_normal(": %s %d cyl, %d head, %d sec\n", type->descr,
-		type->nblocks / (type->nsectors * type->nheads), type->nheads,
+	    type->nblocks / (type->nsectors * type->nheads), type->nheads,
-		type->nsectors);
+	    type->nsectors);
 	/*
 	 * Initialize and attach the disk structure.
 	 */
 	disk_init(&sc->dkdev, device_xname(sc->sc_dev), &fddkdriver);
 	disk_attach(&sc->dkdev);
+}
 int
 fdioctl(dev_t dev, u_long cmd, void * addr, int flag, struct lwp *l)
+{
 	struct fd_softc *sc;
 	sc = device_lookup_private(&fd_cd, DISKUNIT(dev));
-	if((sc->flags & FLPF_HAVELAB) == 0)
+	if ((sc->flags & FLPF_HAVELAB) == 0)
-		return(EBADF);
+		return EBADF;
-	switch(cmd) {
+	switch (cmd) {
-		case DIOCSBAD:
+	case DIOCSBAD:
-			return(EINVAL);
+		return EINVAL;
-		case DIOCGDINFO:
+	case DIOCGDINFO:
-			*(struct disklabel *)addr = *(sc->dkdev.dk_label);
+		*(struct disklabel *)addr = *(sc->dkdev.dk_label);
-			return(0);
+		return 0;
-		case DIOCGPART:
+	case DIOCGPART:
-			((struct partinfo *)addr)->disklab =
+		((struct partinfo *)addr)->disklab = sc->dkdev.dk_label;
-				sc->dkdev.dk_label;
+		((struct partinfo *)addr)->part =
-			((struct partinfo *)addr)->part =
+		    &sc->dkdev.dk_label->d_partitions[RAW_PART];
-			      &sc->dkdev.dk_label->d_partitions[RAW_PART];
+		return 0;
 			return(0);
 #ifdef notyet /* XXX LWP */
-		case DIOCSRETRIES:
+	case DIOCSRETRIES:
-		case DIOCSSTEP:
+	case DIOCSSTEP:
-		case DIOCSDINFO:
+	case DIOCSDINFO:
-		case DIOCWDINFO:
+	case DIOCWDINFO:
-		case DIOCWLABEL:
+	case DIOCWLABEL:
-			break;
+		break;
 #endif /* notyet */
-		case DIOCGDEFLABEL:
+	case DIOCGDEFLABEL:
-			fdgetdefaultlabel(sc, (struct disklabel *)addr,
+		fdgetdefaultlabel(sc, (struct disklabel *)addr, RAW_PART);
-			    RAW_PART);
+		return 0;
 			return(0);
+	}
-	return(ENOTTY);
+	return ENOTTY;
+}
 /*
  * Open the device. If this is the first open on both the floppy devices,
  * intialize the controller.
  * Note that partition info on the floppy device is used to distinguise
  * between 780Kb and 360Kb floppy's.
  *	partition 0: 360Kb
  *	partition 1: 780Kb
  */
 int
 fdopen(dev_t dev, int flags, int devtype, struct lwp *l)
+{
 	struct fd_softc	*sc;
-	int		sps;
+	int s;
 #ifdef FLP_DEBUG
 	printf("fdopen dev=0x%x\n", dev);
 #endif
-	if(FLP_TYPE(dev) >= NR_TYPES)
+	if (FLP_TYPE(dev) >= NR_TYPES)
-		return(ENXIO);
+		return ENXIO;
-	if((sc = device_lookup_private(&fd_cd, DISKUNIT(dev))) == NULL)
+	if ((sc = device_lookup_private(&fd_cd, DISKUNIT(dev))) == NULL)
-		return(ENXIO);
+		return ENXIO;
 	/*
 	 * If no floppy currently open, reset the controller and select
 	 * floppy type.
 	 */
-	if(!nopens) {
+	if (nopens == 0) {
 #ifdef FLP_DEBUG
 		printf("fdopen device not yet open\n");
 #endif
 		nopens++;
 		write_fdreg(FDC_CS, IRUPT);
 		delay(40);
+	}
 	/*
 	 * Sleep while other process is opening the device
 	 */
-	sps = splbio();
+	s = splbio();
-	while(sc->flags & FLPF_INOPEN)
+	while (sc->flags & FLPF_INOPEN)
 		tsleep((void *)sc, PRIBIO, "fdopen", 0);
-	splx(sps);
+	splx(s);
-	if(!(sc->flags & FLPF_ISOPEN)) {
+	if((sc->flags & FLPF_ISOPEN) == 0) {
 		/*
 		 * Initialise some driver values.
 		 */
-		int	type;
+		int type;
-		void	*addr;
+		void *addr;
 		type = FLP_TYPE(dev);
 		bufq_alloc(&sc->bufq, "disksort", BUFQ_SORT_RAWBLOCK);
 		sc->unit        = DISKUNIT(dev);
 		sc->part        = RAW_PART;
 		sc->nheads	= fdtypes[type].nheads;
 		sc->nsectors	= fdtypes[type].nsectors;
 		sc->nblocks     = fdtypes[type].nblocks;
 		sc->density	= fdtypes[type].density;
 		sc->curtrk	= INV_TRK;
 		sc->sector	= 0;
 		sc->errcnt	= 0;
-		sc->bounceb	= (u_char*)alloc_stmem(SECTOR_SIZE, &addr);
+		sc->bounceb	= alloc_stmem(SECTOR_SIZE, &addr);
-		if(sc->bounceb == NULL)
+		if (sc->bounceb == NULL)
-			return(ENOMEM); /* XXX */
+			return ENOMEM; /* XXX */
 		/*
 		 * Go get write protect + loaded status
 		 */
 		sc->flags |= FLPF_INOPEN|FLPF_GETSTAT;
-		sps = splbio();
+		s = splbio();
 		st_dmagrab((dma_farg)fdcint, (dma_farg)fdstatus, sc,
-								&lock_stat, 0);
+		    &lock_stat, 0);
-		while(sc->flags & FLPF_GETSTAT)
+		while ((sc->flags & FLPF_GETSTAT) != 0)
 			tsleep((void *)sc, PRIBIO, "fdopen", 0);
-		splx(sps);
+		splx(s);
 		wakeup((void *)sc);
-		if((sc->flags & FLPF_WRTPROT) && (flags & FWRITE)) {
+		if ((sc->flags & FLPF_WRTPROT) != 0 &&
 		    (flags & FWRITE) != 0) {
 			sc->flags = 0;
-			return(EPERM);
+			return EPERM;
+		}
-		if(sc->flags & FLPF_EMPTY) {
+		if ((sc->flags & FLPF_EMPTY) != 0) {
 			sc->flags = 0;
-			return(ENXIO);
+			return ENXIO;
+		}
 		sc->flags &= ~(FLPF_INOPEN|FLPF_GETSTAT);
 		sc->flags |= FLPF_ISOPEN;
 	} else {
 	else {
 		/*
 		 * Multiply opens are granted when accessing the same type of
 		 * floppy (eq. the same partition).
 		 */
-		if(sc->density != fdtypes[DISKPART(dev)].density)
+		if (sc->density != fdtypes[DISKPART(dev)].density)
-			return(ENXIO);	/* XXX temporarely out of business */
+			return ENXIO;	/* XXX temporarely out of business */
+	}
 	fdgetdisklabel(sc, dev);
 #ifdef FLP_DEBUG
 	printf("fdopen open succeeded on type %d\n", sc->part);
 #endif
-	return (0);
+	return 0;
+}
 int
 fdclose(dev_t dev, int flags, int devtype, struct lwp *l)
+{
 	struct fd_softc	*sc;
 	sc = device_lookup_private(&fd_cd, DISKUNIT(dev));
 	free_stmem(sc->bounceb);
 	sc->flags = 0;
 	nopens--;
 #ifdef FLP_DEBUG
 	printf("Closed floppy device -- nopens: %d\n", nopens);
 #endif
-	return(0);
+	return 0;
+}
 void
 fdstrategy(struct buf *bp)
+{
-	struct fd_softc	 *sc;
+	struct fd_softc *sc;
 	struct disklabel *lp;
-	int		 sps, sz;
+	int s, sz;
 	sc = device_lookup_private(&fd_cd, DISKUNIT(bp->b_dev));
 #ifdef FLP_DEBUG
 	printf("fdstrategy: %p, b_bcount: %ld\n", bp, bp->b_bcount);
 #endif
 	/*
 	 * check for valid partition and bounds
 	 */
 	lp = sc->dkdev.dk_label;
 	if ((sc->flags & FLPF_HAVELAB) == 0) {
 		bp->b_error = EIO;
 		goto done;
+	}
-	if (bp->b_blkno < 0 || (bp->b_bcount % SECTOR_SIZE)) {
+	if (bp->b_blkno < 0 || (bp->b_bcount % SECTOR_SIZE) != 0) {
 		bp->b_error = EINVAL;
 		goto done;
+	}
 	if (bp->b_bcount == 0)
 		goto done;
 	sz = howmany(bp->b_bcount, SECTOR_SIZE);
 	if (bp->b_blkno + sz > sc->nblocks) {
 		sz = sc->nblocks - bp->b_blkno;
 		if (sz == 0) /* Exactly at EndOfDisk */
 			goto done;
 		if (sz < 0) { /* Past EndOfDisk */
 			bp->b_error = EINVAL;
 			goto done;
+		}
 		/* Trucate it */
 		if (bp->b_flags & B_RAW)
 			bp->b_bcount = sz << DEV_BSHIFT;
-		else bp->b_bcount = sz * lp->d_secsize;
+		else
 			bp->b_bcount = sz * lp->d_secsize;
+	}
 	/* No partition translation. */
 	bp->b_rawblkno = bp->b_blkno;
 	/*
 	 * queue the buf and kick the low level code
 	 */
-	sps = splbio();
+	s = splbio();
 	bufq_put(sc->bufq, bp);	/* XXX disksort_cylinder */
 	if (!lock_stat) {
 		if (fd_state & FLP_MON)
 			callout_stop(&sc->sc_motor_ch);
 		fd_state = FLP_IDLE;
 		st_dmagrab((dma_farg)fdcint, (dma_farg)fdstart, sc,
-							&lock_stat, 0);
+		    &lock_stat, 0);
+	}
-	splx(sps);
+	splx(s);
 	return;
 done:
 	bp->b_resid = bp->b_bcount;
 	biodone(bp);
+}
 int
 fdread(dev_t dev, struct uio *uio, int flags)
+{
 	return(physio(fdstrategy, NULL, dev, B_READ, fdminphys, uio));
 	return physio(fdstrategy, NULL, dev, B_READ, fdminphys, uio);
+}
 int
 fdwrite(dev_t dev, struct uio *uio, int flags)
+{
 	return(physio(fdstrategy, NULL, dev, B_WRITE, fdminphys, uio));
 	return physio(fdstrategy, NULL, dev, B_WRITE, fdminphys, uio);
+}
 /*
  * Called through DMA-dispatcher, get status.
  */
 static void
 fdstatus(struct fd_softc *sc)
+{
 #ifdef FLP_DEBUG
 	printf("fdstatus\n");
 #endif
 	sc->errcnt = 0;
 	fd_state   = FLP_STAT;
 	fd_xfer(sc);
+}
 /*
  * Called through the DMA-dispatcher. So we know we are the only ones
  * messing with the floppy-controller.
  * Initialize some fields in the fdsoftc for the state-machine and get
  * it going.
  */
 static void
 fdstart(struct fd_softc *sc)
+{
-	struct buf	*bp;
+	struct buf *bp;
 	bp	     = bufq_peek(sc->bufq);
 	sc->sector   = bp->b_blkno;	/* Start sector for I/O		*/
 	sc->io_data  = bp->b_data;	/* KVA base for I/O		*/
 	sc->io_bytes = bp->b_bcount;	/* Transfer size in bytes	*/
 	sc->io_dir   = bp->b_flags & B_READ;/* Direction of transfer	*/
 	sc->errcnt   = 0;		/* No errors yet		*/
 	fd_state     = FLP_XFER;	/* Yes, we're going to transfer	*/
 	/* Instrumentation. */
 	disk_busy(&sc->dkdev);
 	fd_xfer(sc);
+}
 /*
  * The current transaction is finished (for good or bad). Let go of
  * the DMA-resources. Call biodone() to finish the transaction.
  * Find a new transaction to work on.
  */
 static void
 fddone(register struct fd_softc *sc)
+{
-	struct buf	*bp;
+	struct buf *bp;
 	struct fd_softc	*sc1;
-	int		i, sps;
+	int i, s;
 	/*
 	 * Give others a chance to use the DMA.
 	 */
 	st_dmafree(sc, &lock_stat);
-	if(fd_state != FLP_STAT) {
+	if (fd_state != FLP_STAT) {
 		/*
 		 * Finish current transaction.
 		 */
-		sps = splbio();
+		s = splbio();
 		bp = bufq_get(sc->bufq);
 		if (bp == NULL)
 			panic("fddone");
-		splx(sps);
+		splx(s);
 #ifdef FLP_DEBUG
-		printf("fddone: unit: %d, buf: %p, resid: %d\n",sc->unit,bp,
+		printf("fddone: unit: %d, buf: %p, resid: %d\n",sc->unit, bp,
-								sc->io_bytes);
+		    sc->io_bytes);
 #endif
 		bp->b_resid = sc->io_bytes;
 		disk_unbusy(&sc->dkdev, (bp->b_bcount - bp->b_resid),
 		    (bp->b_flags & B_READ));
 		biodone(bp);
+	}
 	fd_state = FLP_MON;
-	if(lock_stat)
+	if (lock_stat)
 		return;		/* XXX Is this possible?	*/
 	/*
 	 * Find a new transaction on round-robin basis.
 	 */
-	for(i = sc->unit + 1; ;i++) {
+	for (i = sc->unit + 1;; i++) {
-		if(i >= fd_cd.cd_ndevs)
+		if (i >= fd_cd.cd_ndevs)
 			i = 0;
-		if((sc1 = device_lookup_private(&fd_cd, i)) == NULL)
+		if ((sc1 = device_lookup_private(&fd_cd, i)) == NULL)
 			continue;
 		if (bufq_peek(sc1->bufq) != NULL)
 			break;
-		if(i == sc->unit) {
+		if (i == sc->unit) {
 			callout_reset(&sc->sc_motor_ch, FLP_MONDELAY,
 			    (FPV)fdmotoroff, sc);
 #ifdef FLP_DEBUG
 			printf("fddone: Nothing to do\n");
 #endif
 			return;	/* No work */
+		}
+	}
 	fd_state = FLP_IDLE;
 #ifdef FLP_DEBUG
 	printf("fddone: Staring job on unit %d\n", sc1->unit);
 #endif
 	st_dmagrab((dma_farg)fdcint, (dma_farg)fdstart, sc1, &lock_stat, 0);
+}
 static int
 fdselect(int drive, int head, int dense)
+{
-	int	i, spinning;
+	int i, spinning;
 #ifdef FLP_DEBUG
 	printf("fdselect: drive=%d, head=%d, dense=%d\n", drive, head, dense);
 #endif
 	i = ((drive == 1) ? PA_FLOP1 : PA_FLOP0) | head;
 	spinning = motoron;
 	motoron  = 1;
-	switch(dense) {
+	switch (dense) {
-		case FLP_DD:
+	case FLP_DD:
-			DMA->dma_drvmode = 0;
+		DMA->dma_drvmode = 0;
-			break;
+		break;
-		case FLP_HD:
+	case FLP_HD:
-			DMA->dma_drvmode = (FDC_HDSET|FDC_HDSIG);
+		DMA->dma_drvmode = (FDC_HDSET|FDC_HDSIG);
-			break;
+		break;
-		default:
+	default:
-			panic("fdselect: unknown density code");
+		panic("fdselect: unknown density code");
+	}
-	if(i != selected) {
+	if (i != selected) {
 		selected = i;
 		ym2149_fd_select((i ^ PA_FDSEL));
+	}
-	return(spinning);
+	return spinning;
+}
 static void
 fddeselect(void)
+{
 	ym2149_fd_select(PA_FDSEL);
 	motoron = selected = 0;
 	DMA->dma_drvmode   = 0;
+}
 /****************************************************************************
  * The following functions assume to be running as a result of a            *
  * disk-interrupt (e.q. spl = splbio).				            *
  * They form the finit-state machine, the actual driver.                    *
  *                                                                          *
  *	fdstart()/ --> fd_xfer() -> activate hardware                       *
  *  fdopen()          ^                                                     *
  *                    |                                                     *
  *                    +-- not ready -<------------+                         *
  *                                                |                         *
  *  fdmotoroff()/ --> fdcint() -> fd_xfer_ok() ---+                         *
  *  h/w interrupt                 |                                         *
  *                               \|/                                        *
  *                            finished ---> fdone()                         *
  *                                                                          *
  ****************************************************************************/
 static void
 fd_xfer(struct fd_softc *sc)
+{
-	register int	head;
+	int head;
-	register int	track, sector, hbit;
+	int track, sector, hbit;
-		 u_long	phys_addr;
+	paddr_t phys_addr;
 	head = track = 0;
-	switch(fd_state) {
+	switch (fd_state) {
-	    case FLP_XFER:
+	case FLP_XFER:
 		/*
 		 * Calculate head/track values
 		 */
 		track  = sc->sector / sc->nsectors;
 		head   = track % sc->nheads;
 		track  = track / sc->nheads;
 #ifdef FLP_DEBUG
-		printf("fd_xfer: sector:%d,head:%d,track:%d\n", sc->sector,head,
+		printf("fd_xfer: sector:%d,head:%d,track:%d\n",
-								track);
+		    sc->sector, head, track);
 #endif
 		break;
-	    case FLP_STAT:
+	case FLP_STAT:
 		/*
 		 * FLP_STAT only wants to recalibrate
 		 */
 		sc->curtrk = INV_TRK;
 		break;
-	    default:
+	default:
 		panic("fd_xfer: wrong state (0x%x)", fd_state);
+	}
 	/*
 	 * Select the drive.
 	 */
 	hbit = fdselect(sc->unit, head, sc->density) ? HBIT : 0;
-	if(sc->curtrk == INV_TRK) {
+	if (sc->curtrk == INV_TRK) {
 		/*
 		 * Recalibrate, since we lost track of head positioning.
 		 * The floppy disk controller has no way of determining its
 		 * absolute arm position (track).  Instead, it steps the
 		 * arm a track at a time and keeps track of where it
 		 * thinks it is (in software).  However, after a SEEK, the
 		 * hardware reads information from the diskette telling
 		 * where the arm actually is.  If the arm is in the wrong place,
 		 * a recalibration is done, which forces the arm to track 0.
 		 * This way the controller can get back into sync with reality.
 		 */
 		fd_cmd = RESTORE;
 		write_fdreg(FDC_CS, RESTORE|VBIT|hbit);
 @@ -853,337 +866,339 @@ fd_xfer(struct fd_softc *sc)
 #ifdef FLP_DEBUG
 		printf("fd_xfer:Recalibrating drive %d\n", sc->unit);
 #endif
 		return;
+	}
 	write_fdreg(FDC_TR, sc->curtrk);
 	/*
 	 * Issue a SEEK command on the indicated drive unless the arm is
 	 * already positioned on the correct track.
 	 */
-	if(track != sc->curtrk) {
+	if (track != sc->curtrk) {
 		sc->curtrk = track;	/* be optimistic */
 		write_fdreg(FDC_DR, track);
 		write_fdreg(FDC_CS, SEEK|RATE6|VBIT|hbit);
 		callout_reset(&sc->sc_motor_ch, FLP_XFERDELAY,
 		    (FPV)fdmotoroff, sc);
 		fd_cmd = SEEK;
 #ifdef FLP_DEBUG
-		printf("fd_xfer:Seek to track %d on drive %d\n",track,sc->unit);
+		printf("fd_xfer:Seek to track %d on drive %d\n",
 		    track, sc->unit);
 #endif
 		return;
+	}
 	/*
 	 * The drive is now on the proper track. Read or write 1 block.
 	 */
 	sector = sc->sector % sc->nsectors;
 	sector++;	/* start numbering at 1 */
 	write_fdreg(FDC_SR, sector);
-	phys_addr = (u_long)kvtop(sc->io_data);
+	phys_addr = (paddr_t)kvtop(sc->io_data);
-	if(phys_addr >= FDC_MAX_DMA_AD) {
+	if (phys_addr >= FDC_MAX_DMA_AD) {
 		/*
 		 * We _must_ bounce this address
 		 */
-		phys_addr = (u_long)kvtop(sc->bounceb);
+		phys_addr = (paddr_t)kvtop(sc->bounceb);
-		if(sc->io_dir == B_WRITE)
+		if (sc->io_dir == B_WRITE)
 			memcpy(sc->bounceb, sc->io_data, SECTOR_SIZE);
 		sc->flags |= FLPF_BOUNCE;
+	}
 	st_dmaaddr_set((void *)phys_addr);	/* DMA address setup */
 #ifdef FLP_DEBUG
 	printf("fd_xfer:Start io (io_addr:%lx)\n", (u_long)kvtop(sc->io_data));
 #endif
-	if(sc->io_dir == B_READ) {
+	if (sc->io_dir == B_READ) {
 		/* Issue the command */
 		st_dmacomm(DMA_FDC | DMA_SCREG, 1);
 		write_fdreg(FDC_CS, F_READ|hbit);
 		fd_cmd = F_READ;
 	} else {
 	else {
 		/* Issue the command */
 		st_dmacomm(DMA_WRBIT | DMA_FDC | DMA_SCREG, 1);
 		write_fdreg(DMA_WRBIT | FDC_CS, F_WRITE|hbit|EBIT|PBIT);
 		fd_cmd = F_WRITE;
+	}
 	callout_reset(&sc->sc_motor_ch, FLP_XFERDELAY, (FPV)fdmotoroff, sc);
+}
 /* return values of fd_xfer_ok(): */
 #define X_OK			0
 #define X_AGAIN			1
 #define X_ERROR			2
 #define X_FAIL			3
 /*
  * Hardware interrupt function.
  */
 static void
 fdcint(struct fd_softc *sc)
+{
-	struct	buf	*bp;
+	struct buf *bp;
 #ifdef FLP_DEBUG
 	printf("fdcint: unit = %d\n", sc->unit);
 #endif
 	/*
 	 * Cancel timeout (we made it, didn't we)
 	 */
 	callout_stop(&sc->sc_motor_ch);
-	switch(fd_xfer_ok(sc)) {
+	switch (fd_xfer_ok(sc)) {
-		case X_ERROR :
+	case X_ERROR:
-			if(++(sc->errcnt) < MAX_ERRORS) {
+		if (++sc->errcnt < MAX_ERRORS) {
 				/*
 				 * Command failed but still retries left.
 				 */
 				break;
 			/* FALL THROUGH */
 		case X_FAIL  :
 			/*
-			 * Non recoverable error. Fall back to motor-on
+			 * Command failed but still retries left.
 			 * idle-state.
 			 */
-			if(fd_error != NULL) {
+			break;
 				printf("Floppy error: %s\n", fd_error);
-				fd_error = NULL;
+		/* FALL THROUGH */
 	case X_FAIL:
 		/*
-			if(fd_state == FLP_STAT) {
+		 * Non recoverable error. Fall back to motor-on
-				sc->flags |= FLPF_EMPTY;
+		 * idle-state.
-				sc->flags &= ~FLPF_GETSTAT;
+		 */
-				wakeup((void *)sc);
+		if (fd_error != NULL) {
-				fddone(sc);
+			printf("Floppy error: %s\n", fd_error);
-				return;
+			fd_error = NULL;
+		}
-			bp = bufq_peek(sc->bufq);
+		if (fd_state == FLP_STAT) {
 			sc->flags |= FLPF_EMPTY;
 			sc->flags &= ~FLPF_GETSTAT;
 			wakeup((void *)sc);
 			fddone(sc);
 			return;
+		}
-			bp->b_error  = EIO;
+		bp = bufq_peek(sc->bufq);
 			fd_state     = FLP_MON;
-			break;
+		bp->b_error  = EIO;
-		case X_AGAIN:
+		fd_state     = FLP_MON;
 			/*
-			 * Start next part of state machine.
+		break;
-			 */
+	case X_AGAIN:
-			break;
+		/*
-		case X_OK:
+		 * Start next part of state machine.
-			/*
+		 */
-			 * Command ok and finished. Reset error-counter.
+		break;
-			 * If there are no more bytes to transfer fall back
+	case X_OK:
-			 * to motor-on idle state.
+		/*
-			 */
+		 * Command ok and finished. Reset error-counter.
-			sc->errcnt = 0;
+		 * If there are no more bytes to transfer fall back
 		 * to motor-on idle state.
 		 */
 		sc->errcnt = 0;
-			if(fd_state == FLP_STAT) {
+		if (fd_state == FLP_STAT) {
-				sc->flags &= ~FLPF_GETSTAT;
+			sc->flags &= ~FLPF_GETSTAT;
-				wakeup((void *)sc);
+			wakeup((void *)sc);
-				fddone(sc);
+			fddone(sc);
-				return;
+			return;
+		}
-			if((sc->flags & FLPF_BOUNCE) && (sc->io_dir == B_READ))
+		if ((sc->flags & FLPF_BOUNCE) != 0 &&
-				memcpy(sc->io_data, sc->bounceb, SECTOR_SIZE);
+		    sc->io_dir == B_READ)
-			sc->flags &= ~FLPF_BOUNCE;
+			memcpy(sc->io_data, sc->bounceb, SECTOR_SIZE);
 		sc->flags &= ~FLPF_BOUNCE;
 			sc->sector++;
-			sc->io_data  += SECTOR_SIZE;
+		sc->sector++;
-			sc->io_bytes -= SECTOR_SIZE;
+		sc->io_data  += SECTOR_SIZE;
-			if(sc->io_bytes <= 0)
+		sc->io_bytes -= SECTOR_SIZE;
-				fd_state = FLP_MON;
+		if (sc->io_bytes <= 0)
 			fd_state = FLP_MON;
+	}
-	if(fd_state == FLP_MON)
+	if (fd_state == FLP_MON)
 		fddone(sc);
-	else fd_xfer(sc);
+	else
 		fd_xfer(sc);
+}
 /*
  * Determine status of last command. Should only be called through
  * 'fdcint()'.
  * Returns:
  *	X_ERROR : Error on command; might succeed next time.
  *	X_FAIL  : Error on command; will never succeed.
  *	X_AGAIN : Part of a command succeeded, call 'fd_xfer()' to complete.
  *	X_OK	: Command succeeded and is complete.
+ *
  * This function only affects sc->curtrk.
  */
 static int
 fd_xfer_ok(register struct fd_softc *sc)
+{
-	register int	status;
+	int status;
 #ifdef FLP_DEBUG
 	printf("fd_xfer_ok: cmd: 0x%x, state: 0x%x\n", fd_cmd, fd_state);
 #endif
-	switch(fd_cmd) {
+	switch (fd_cmd) {
-		case IRUPT:
+	case IRUPT:
-			/*
+		/*
-			 * Timeout. Force a recalibrate before we try again.
+		 * Timeout. Force a recalibrate before we try again.
-			 */
+		 */
-			status = read_fdreg(FDC_CS);
+		status = read_fdreg(FDC_CS);
-			fd_error = "Timeout";
+		fd_error = "Timeout";
-			sc->curtrk = INV_TRK;
+		sc->curtrk = INV_TRK;
-			return(X_ERROR);
+		return X_ERROR;
-		case F_READ:
+	case F_READ:
-			/*
+		/*
-			 * Test for DMA error
+		 * Test for DMA error
-			 */
+		 */
-			status = read_dmastat();
+		status = read_dmastat();
-			if(!(status & DMAOK)) {
+		if ((status & DMAOK) == 0) {
-				fd_error = "DMA error";
+			fd_error = "DMA error";
-				return(X_ERROR);
+			return X_ERROR;
+		}
-			/*
+		/*
-			 * Get controller status and check for errors.
+		 * Get controller status and check for errors.
-			 */
+		 */
-			status = read_fdreg(FDC_CS);
+		status = read_fdreg(FDC_CS);
-			if(status & (RNF | CRCERR | LD_T00)) {
+		if ((status & (RNF | CRCERR | LD_T00)) != 0) {
-				fd_error = "Read error";
+			fd_error = "Read error";
-				if(status & RNF)
+			if ((status & RNF) != 0)
 					sc->curtrk = INV_TRK;
 				return(X_ERROR);
 			break;
 		case F_WRITE:
 			/*
 			 * Test for DMA error
 			 */
 			status = read_dmastat();
 			if(!(status & DMAOK)) {
 				fd_error = "DMA error";
 				return(X_ERROR);
 			/*
 			 * Get controller status and check for errors.
 			 */
 			status = read_fdreg(FDC_CS);
 			if(status & WRI_PRO) {
 				fd_error = "Write protected";
 				return(X_FAIL);
 			if(status & (RNF | CRCERR | LD_T00)) {
 				fd_error = "Write error";
 				sc->curtrk = INV_TRK;
-				return(X_ERROR);
+			return X_ERROR;
+		}
 		break;
 	case F_WRITE:
 		/*
 		 * Test for DMA error
 		 */
 		status = read_dmastat();
 		if ((status & DMAOK) == 0) {
 			fd_error = "DMA error";
 			return X_ERROR;
+		}
 		/*
 		 * Get controller status and check for errors.
 		 */
 		status = read_fdreg(FDC_CS);
 		if ((status & WRI_PRO) != 0) {
 			fd_error = "Write protected";
 			return X_FAIL;
+		}
 		if ((status & (RNF | CRCERR | LD_T00)) != 0) {
 			fd_error = "Write error";
 			sc->curtrk = INV_TRK;
 			return X_ERROR;
+		}
 		break;
 	case SEEK:
 		status = read_fdreg(FDC_CS);
 		if ((status & (RNF | CRCERR)) != 0) {
 			fd_error = "Seek error";
 			sc->curtrk = INV_TRK;
 			return X_ERROR;
+		}
 		return X_AGAIN;
 	case RESTORE:
 		/*
 		 * Determine if the recalibration succeeded.
 		 */
 		status = read_fdreg(FDC_CS);
 		if ((status & RNF) != 0) {
 			fd_error = "Recalibrate error";
 			/* reset controller */
 			write_fdreg(FDC_CS, IRUPT);
 			sc->curtrk = INV_TRK;
 			return X_ERROR;
+		}
 		sc->curtrk = 0;
 		if (fd_state == FLP_STAT) {
 			if ((status & WRI_PRO) != 0)
 				sc->flags |= FLPF_WRTPROT;
 			break;
 		case SEEK:
-			status = read_fdreg(FDC_CS);
+		return X_AGAIN;
-			if(status & (RNF | CRCERR)) {
+	default:
-				fd_error = "Seek error";
+		fd_error = "Driver error: fd_xfer_ok : Unknown state";
-				sc->curtrk = INV_TRK;
+		return X_FAIL;
 				return(X_ERROR);
 			return(X_AGAIN);
 		case RESTORE:
 			/*
 			 * Determine if the recalibration succeeded.
 			 */
 			status = read_fdreg(FDC_CS);
 			if(status & RNF) {
 				fd_error = "Recalibrate error";
 				/* reset controller */
 				write_fdreg(FDC_CS, IRUPT);
 				sc->curtrk = INV_TRK;
 				return(X_ERROR);
 			sc->curtrk = 0;
 			if(fd_state == FLP_STAT) {
 				if(status & WRI_PRO)
 					sc->flags |= FLPF_WRTPROT;
 				break;
 			return(X_AGAIN);
 		default:
 			fd_error = "Driver error: fd_xfer_ok : Unknown state";
 			return(X_FAIL);
+	}
-	return(X_OK);
+	return X_OK;
+}
 /*
  * All timeouts will call this function.
  */
 static void
 fdmotoroff(struct fd_softc *sc)
+{
-	int	sps;
+	int s;
 	/*
 	 * Get at harware interrupt level
 	 */
-	sps = splbio();
+	s = splbio();
 #if FLP_DEBUG
 	printf("fdmotoroff, state = 0x%x\n", fd_state);
 #endif
-	switch(fd_state) {
+	switch (fd_state) {
-		case FLP_STAT :
+	case FLP_STAT:
-		case FLP_XFER :
+	case FLP_XFER:
-			/*
+		/*
-			 * Timeout during a transfer; cancel transaction
+		 * Timeout during a transfer; cancel transaction
-			 * set command to 'IRUPT'.
+		 * set command to 'IRUPT'.
-			 * A drive-interrupt is simulated to trigger the state
+		 * A drive-interrupt is simulated to trigger the state
-			 * machine.
+		 * machine.
-			 */
+		 */
-			/*
+		/*
-			 * Cancel current transaction
+		 * Cancel current transaction
-			 */
+		 */
-			fd_cmd = IRUPT;
+		fd_cmd = IRUPT;
-			write_fdreg(FDC_CS, IRUPT);
+		write_fdreg(FDC_CS, IRUPT);
-			delay(20);
+		delay(20);
-			(void)read_fdreg(FDC_CS);
+		(void)read_fdreg(FDC_CS);
-			write_fdreg(FDC_CS, RESTORE);
+		write_fdreg(FDC_CS, RESTORE);
-			break;
+		break;
-		case FLP_MON  :
+	case FLP_MON:
-			/*
+		/*
-			 * Turn motor off.
+		 * Turn motor off.
-			 */
+		 */
-			if(selected) {
+		if (selected) {
-				int tmp;
+			int tmp;
-				st_dmagrab((dma_farg)fdcint, (dma_farg)fdmoff,
+			st_dmagrab((dma_farg)fdcint, (dma_farg)fdmoff, sc,
-								sc, &tmp, 0);
+			    &tmp, 0);
 		} else
-			else  fd_state = FLP_IDLE;
+			fd_state = FLP_IDLE;
-			break;
+		break;
+	}
-	splx(sps);
+	splx(s);
+}
 /*
  * min byte count to whats left of the track in question
  */
 static void
 fdminphys(struct buf *bp)
+{
 	struct fd_softc	*sc;
-	int		sec, toff, tsz;
+	int sec, toff, tsz;
-	if((sc = device_lookup_private(&fd_cd, DISKUNIT(bp->b_dev))) == NULL)
+	if ((sc = device_lookup_private(&fd_cd, DISKUNIT(bp->b_dev))) == NULL)
 		panic("fdminphys: couldn't get softc");
 	sec  = bp->b_blkno % (sc->nsectors * sc->nheads);
 	toff = sec * SECTOR_SIZE;
 	tsz  = sc->nsectors * sc->nheads * SECTOR_SIZE;
 #ifdef FLP_DEBUG
 	printf("fdminphys: before %ld", bp->b_bcount);
 #endif
 	bp->b_bcount = min(bp->b_bcount, tsz - toff);
 #ifdef FLP_DEBUG
 @@ -1202,66 +1217,65 @@ fdminphys(struct buf *bp)
  * drive motor is really off before deselecting the drive. The FDC only
  * turns off the drive motor after having seen 10 index-pulses. You only
  * get index-pulses when a drive is selected....This means that if the
  * drive is deselected when the motor is still spinning, it will continue
  * to spin _even_ when you insert a floppy later on...
  */
 static void
 fdmoff(struct fd_softc *fdsoftc)
+{
 	int tmp;
 	if ((fd_state == FLP_MON) && selected) {
 		tmp = read_fdreg(FDC_CS);
-		if (!(tmp & MOTORON)) {
+		if ((tmp & MOTORON) == 0) {
 			fddeselect();
 			fd_state = FLP_IDLE;
 		} else
-		else
+			callout_reset(&fdsoftc->sc_motor_ch, 10 * FLP_MONDELAY,
 			callout_reset(&fdsoftc->sc_motor_ch, 10*FLP_MONDELAY,
 			    (FPV)fdmotoroff, fdsoftc);
+	}
 	st_dmafree(fdsoftc, &tmp);
+}
 /*
  * Used to find out wich drives are actually connected. We do this by issuing
  * is 'RESTORE' command and check if the 'track-0' bit is set. This also works
  * if the drive is present but no floppy is inserted.
  */
 static void
 fdtestdrv(struct fd_softc *fdsoftc)
+{
-	int	status;
+	int status;
 	/*
 	 * Select the right unit and head.
 	 */
 	fdselect(fdsoftc->unit, 0, FLP_DD);
 	write_fdreg(FDC_CS, RESTORE|HBIT);
 	/*
 	 * Wait for about 2 seconds.
 	 */
 	delay(2000000);
 	status = read_fdreg(FDC_CS);
-	if(status & (RNF|BUSY)) {
+	if ((status & (RNF|BUSY)) != 0) {
 		write_fdreg(FDC_CS, IRUPT);	/* reset controller */
 		delay(40);
+	}
-	if(!(status & LD_T00))
+	if ((status & LD_T00) == 0)
 		fdsoftc->flags |= FLPF_NOTRESP;
 	fddeselect();
+}
 static void
 fdgetdefaultlabel(struct fd_softc *sc, struct disklabel *lp, int part)
+{
 	memset(lp, 0, sizeof(struct disklabel));
 	lp->d_secsize     = SECTOR_SIZE;
 	lp->d_ntracks     = sc->nheads;
 @@ -1283,33 +1297,33 @@ fdgetdefaultlabel(struct fd_softc *sc, s
 	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;
+}
 /*
  * Build disk label. For now we only create a label from what we know
  * from 'sc'.
  */
 static int
 fdgetdisklabel(struct fd_softc *sc, dev_t dev)
+{
-	struct disklabel	*lp;
+	struct disklabel *lp;
-	int			part;
+	int part;
 	/*
 	 * If we already got one, get out.
 	 */
-	if(sc->flags & FLPF_HAVELAB)
+	if ((sc->flags & FLPF_HAVELAB) != 0)
-		return(0);
+		return 0;
 #ifdef FLP_DEBUG
 	printf("fdgetdisklabel()\n");
 #endif
 	part = RAW_PART;
 	lp   = sc->dkdev.dk_label;
 	fdgetdefaultlabel(sc, lp, part);
-	sc->flags        |= FLPF_HAVELAB;
+	sc->flags |= FLPF_HAVELAB;
-	return(0);
+	return 0;
+}