 @@ -1,1081 +1,1078 @@
-/*	$NetBSD: ts.c,v 1.34 2022/01/01 10:32:29 msaitoh Exp $ */
+/*	$NetBSD: ts.c,v 1.35 2022/02/12 02:40:20 riastradh Exp $ */
 /*-
  * Copyright (c) 1991 The Regents of the University of California.
  * 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.
  * 3. Neither the name of the University 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 REGENTS 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 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.
+ *
  *	@(#)tmscp.c	7.16 (Berkeley) 5/9/91
  */
 /*
  * sccsid = "@(#)tmscp.c	1.24	(ULTRIX)	1/21/86";
  */
 /************************************************************************
  *									*
  *	  Licensed from Digital Equipment Corporation			*
  *			 Copyright (c)					*
  *		 Digital Equipment Corporation				*
  *		     Maynard, Massachusetts				*
  *			   1985, 1986					*
  *		      All rights reserved.				*
  *									*
  *	  The Information in this software is subject to change		*
  *   without notice and should not be construed as a commitment		*
  *   by	 Digital  Equipment  Corporation.   Digital   makes  no		*
  *   representations about the suitability of this software for		*
  *   any purpose.  It is supplied "As Is" without expressed  or		*
  *   implied  warranty.							*
  *									*
  *	  If the Regents of the University of California or its		*
  *   licensees modify the software in a manner creating			*
  *   derivative copyright rights, appropriate copyright			*
  *   legends may be placed on  the derivative work in addition		*
  *   to that set forth above.						*
  *									*
  ************************************************************************/
 /*
  * TSV05/TS05 device driver, written by Bertram Barth.
+ *
  * should be TS11 compatible (untested)
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ts.c,v 1.34 2022/01/01 10:32:29 msaitoh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ts.c,v 1.35 2022/02/12 02:40:20 riastradh Exp $");
 #undef	TSDEBUG
 /*
  * TODO:
+ *
  * Keep track of tape position so that lseek et al works.
  * Use tprintf to inform the user, not the system console.
  */
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/buf.h>
 #include <sys/bufq.h>
 #include <sys/conf.h>
 #include <sys/device.h>
 #include <sys/errno.h>
 #include <sys/file.h>
 #include <sys/syslog.h>
 #include <sys/ioctl.h>
 #include <sys/mtio.h>
 #include <sys/uio.h>
 #include <sys/proc.h>
 #include <sys/bus.h>
 #include <dev/qbus/ubareg.h>
 #include <dev/qbus/ubavar.h>
 #include <dev/qbus/tsreg.h>
 #include "ioconf.h"
 struct ts {
 	struct cmd cmd;	/* command packet */
 	struct chr chr;	/* characteristics packet */
 	struct status status;	/* status packet */
 };
 /*
  * Software status, per controller.
  * also status per tape-unit, since only one unit per controller
  * (thus we have no struct ts_info)
  */
 struct ts_softc {
 	device_t sc_dev;		/* Autoconf ... */
 	struct uba_softc *sc_uh;	/* the parent UBA */
 	struct uba_unit sc_unit;	/* Struct common for UBA to talk */
 	struct evcnt sc_intrcnt;	/* Interrupt counting */
 	struct ubinfo sc_ui;		/* mapping info for struct ts */
 	struct uba_unit sc_uu;		/* Struct for UBA to communicate */
 	bus_space_tag_t sc_iot;
 	bus_addr_t sc_ioh;
 	bus_dma_tag_t sc_dmat;
 	bus_dmamap_t sc_dmam;
 	volatile struct ts *sc_vts;	/* Memory address of ts struct */
 	struct ts *sc_bts;		/* Unibus address of ts struct */
 	int	sc_type;		/* TS11 or TS05? */
 	short	sc_waddr;		/* Value to write to TSDB */
 	struct bufq_state *sc_bufq;	/* pending I/O requests */
 	short	sc_mapped;		/* Unibus map allocated ? */
 	short	sc_state;		/* see below: ST_xxx */
 	short	sc_rtc;			/* retry count for lcmd */
 	short	sc_openf;		/* lock against multiple opens */
 	short	sc_liowf;		/* last operation was write */
 	struct buf ts_cbuf;		/* internal cmd buffer (for ioctls) */
 };
 #define	TS_WCSR(csr, val) \
 	bus_space_write_2(sc->sc_iot, sc->sc_ioh, csr, val)
 #define TS_RCSR(csr) \
 	bus_space_read_2(sc->sc_iot, sc->sc_ioh, csr)
 #define LOWORD(x)	((int)(x) & 0xffff)
 #define HIWORD(x)	(((int)(x) >> 16) & 0x3f)
 #define	TYPE_TS11	0
 #define	TYPE_TS05	1
 #define	TYPE_TU80	2
 #define	TS_INVALID	0
 #define	TS_INIT		1
 #define	TS_RUNNING	2
 #define	TS_FASTREPOS	3
 static	void tsintr(void *);
 static	void tsinit(struct ts_softc *);
 static	void tscommand(struct ts_softc *, dev_t, int, int);
 static	int tsstart(struct ts_softc *, int);
 static	void tswchar(struct ts_softc *);
 static	bool tsreset(struct ts_softc *);
 static	int tsmatch(device_t, cfdata_t, void *);
 static	void tsattach(device_t, device_t, void *);
 static	int tsready(struct uba_unit *);
 CFATTACH_DECL_NEW(ts, sizeof(struct ts_softc),
     tsmatch, tsattach, NULL, NULL);
 dev_type_open(tsopen);
 dev_type_close(tsclose);
 dev_type_read(tsread);
 dev_type_write(tswrite);
 dev_type_ioctl(tsioctl);
 dev_type_strategy(tsstrategy);
 dev_type_dump(tsdump);
 const struct bdevsw ts_bdevsw = {
 	.d_open = tsopen,
 	.d_close = tsclose,
 	.d_strategy = tsstrategy,
 	.d_ioctl = tsioctl,
 	.d_dump = tsdump,
 	.d_psize = nosize,
 	.d_discard = nodiscard,
 	.d_flag = D_TAPE
 };
 const struct cdevsw ts_cdevsw = {
 	.d_open = tsopen,
 	.d_close = tsclose,
 	.d_read = tsread,
 	.d_write = tswrite,
 	.d_ioctl = tsioctl,
 	.d_stop = nostop,
 	.d_tty = notty,
 	.d_poll = nopoll,
 	.d_mmap = nommap,
 	.d_kqfilter = nokqfilter,
 	.d_discard = nodiscard,
 	.d_flag = D_TAPE
 };
 /* Bits in minor device */
 #define TS_UNIT(dev)	(minor(dev)&03)
 #define TS_HIDENSITY	010
 #define TS_PRI	LOG_INFO
 /*
  * Probe for device. If found, try to raise an interrupt.
  */
 int
 tsmatch(device_t parent, cfdata_t match, void *aux)
+{
 	struct device tsdev;
 	struct ts_softc ssc;
 	struct ts_softc *sc = &ssc;
 	struct uba_attach_args *ua = aux;
 	int i;
 	sc->sc_iot = ua->ua_iot;
 	sc->sc_ioh = ua->ua_ioh;
 	sc->sc_mapped = 0;
 	sc->sc_dev = &tsdev;
 	sc->sc_uh = device_private(parent);
 	strcpy(sc->sc_dev->dv_xname, "ts");
 	/* Try to reset the device */
 	for (i = 0; i < 3; i++) {
 		if (tsreset(sc))
 			break;
+	}
 	if (i == 3)
 		return 0;
 	tsinit(sc);
 	tswchar(sc);		/* write charact. to enable interrupts */
 				/* completion of this will raise the intr. */
 	DELAY(1000000);		/* Wait for interrupt */
 	ubmemfree(sc->sc_uh, &sc->sc_ui);
 	return 1;
+}
 /*
  */
 void
 tsattach(device_t parent, device_t self, void *aux)
+{
 	struct ts_softc *sc = device_private(self);
 	struct uba_attach_args *ua = aux;
 	int error;
 	const char *t;
 	sc->sc_dev = self;
 	sc->sc_uh = device_private(parent);
 	sc->sc_iot = ua->ua_iot;
 	sc->sc_ioh = ua->ua_ioh;
 	sc->sc_dmat = ua->ua_dmat;
 	sc->sc_uu.uu_dev = self;
 	sc->sc_uu.uu_ready = tsready;
 	tsinit(sc);	/* reset and map */
 	error = bus_dmamap_create(sc->sc_dmat, (64*1024), 16, (64*1024),
 , BUS_DMA_NOWAIT, &sc->sc_dmam);
 	if (error) {
 		aprint_error(": failed create DMA map %d\n", error);
 		return;
+	}
 	bufq_alloc(&sc->sc_bufq, "fcfs", 0);
 	/*
 	 * write the characteristics (again)
 	 */
 	sc->sc_state = TS_INIT;		/* tsintr() checks this ... */
 	tswchar(sc);
 	if (tsleep(sc, PRIBIO, "tsattach", 100)) {
 		aprint_error(": failed SET CHARACTERISTICS\n");
 		return;
+	}
 	sc->sc_state = TS_RUNNING;
 	if (sc->sc_uh->uh_type == UBA_UBA) {
 		if (sc->sc_vts->status.xst2 & TS_SF_TU80) {
 			sc->sc_type = TYPE_TU80;
 			t = "TU80";
 		} else {
 			sc->sc_type = TYPE_TS11;
 			t = "TS11";
+		}
 	} else {
 		sc->sc_type = TYPE_TS05;
 		t = "TS05";
+	}
 	aprint_normal(": %s\n", t);
 	aprint_normal_dev(sc->sc_dev,
 	    "rev %d, extended features %s, transport %s\n",
 	    (sc->sc_vts->status.xst2 & TS_SF_MCRL) >> 2,
 	    (sc->sc_vts->status.xst2 & TS_SF_EFES ? "enabled" : "disabled"),
 	    (TS_RCSR(TSSR) & TS_OFL ? "offline" : "online"));
 	uba_intr_establish(ua->ua_icookie, ua->ua_cvec, tsintr,
 	    sc, &sc->sc_intrcnt);
 	evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
 	    device_xname(sc->sc_dev), "intr");
+}
 /*
  * Initialize a TS device. Set up UBA mapping registers,
  * initialize data structures, what else ???
  */
 void
 tsinit(struct ts_softc *sc)
+{
 	if (sc->sc_mapped == 0) {
 		/*
 		 * Map the communications area and command and message
 		 * buffer into Unibus address space.
 		 */
 		sc->sc_ui.ui_size = sizeof(struct ts);
 		if (ubmemalloc(sc->sc_uh, &sc->sc_ui, UBA_CANTWAIT))
 			return;
 		sc->sc_vts = (void *)sc->sc_ui.ui_vaddr;
 		sc->sc_bts = (void *)sc->sc_ui.ui_baddr;
 		sc->sc_waddr = sc->sc_ui.ui_baddr |
 		    ((sc->sc_ui.ui_baddr >> 16) & 3);
 		sc->sc_mapped = 1;
+	}
 	tsreset(sc);
+}
 /*
  * Execute a (ioctl) command on the tape drive a specified number of times.
  * This routine sets up a buffer and calls the strategy routine which
  * issues the command to the controller.
  */
 void
 tscommand(struct ts_softc *sc, dev_t dev, int cmd, int count)
+{
 	struct buf *bp;
 #ifdef TSDEBUG
 	printf("tscommand (%x, %d)\n", cmd, count);
 #endif
 	bp = &sc->ts_cbuf;
 	mutex_enter(&bufcache_lock);
 	while (bp->b_cflags & BC_BUSY) {
 		/*
 		 * This special check is because BC_BUSY never
 		 * gets cleared in the non-waiting rewind case. ???
 		 */
 		if (bp->b_bcount == 0 && (bp->b_oflags & BO_DONE))
 			break;
 		if (bbusy(bp, false, 0, NULL) == 0)
 			break;
 		/* check MOT-flag !!! */
+	}
 	bp->b_flags = B_READ;
 	mutex_exit(&bufcache_lock);
 	/*
 	 * Load the buffer.  The b_count field gets used to hold the command
 	 * count.  the b_resid field gets used to hold the command mneumonic.
 	 * These 2 fields are "known" to be "safe" to use for this purpose.
 	 * (Most other drivers also use these fields in this way.)
 	 */
 	bp->b_dev = dev;
 	bp->b_bcount = count;
 	bp->b_resid = cmd;
 	bp->b_blkno = 0;
 	bp->b_oflags = 0;
 	bp->b_objlock = &buffer_lock;
 	tsstrategy(bp);
 	/*
 	 * In case of rewind from close, don't wait.
 	 * This is the only case where count can be 0.
 	 */
 	if (count == 0)
 		return;
 	biowait(bp);
 	mutex_enter(&bufcache_lock);
 	cv_broadcast(&bp->b_busy);
 	bp->b_cflags = 0;
 	mutex_exit(&bufcache_lock);
+}
 /*
  * Start an I/O operation on TS05 controller
  */
 int
 tsstart(struct ts_softc *sc, int isloaded)
+{
 	struct buf *bp;
 	int cmd;
 	bp = bufq_peek(sc->sc_bufq);
 	if (bp == NULL) {
 		return 0;
+	}
 #ifdef TSDEBUG
 	printf("buf: %p bcount %ld blkno %d\n", bp, bp->b_bcount, bp->b_blkno);
 #endif
 	/*
 	 * Check if command is an ioctl or not (ie. read or write).
 	 * If it's an ioctl then just set the flags for later use;
 	 * For other commands attempt to setup a buffer pointer.
 	 */
 	if (bp == &sc->ts_cbuf) {
 		switch ((int)bp->b_resid) {
 		case MTWEOF:
 			cmd = TS_CMD_WTM;
 			break;
 		case MTFSF:
 			cmd = TS_CMD_STMF;
 			sc->sc_vts->cmd.cw1 = bp->b_bcount;
 			break;
 		case MTBSF:
 			cmd = TS_CMD_STMR;
 			sc->sc_vts->cmd.cw1 = bp->b_bcount;
 			break;
 		case MTFSR:
 			cmd = TS_CMD_SRF;
 			sc->sc_vts->cmd.cw1 = bp->b_bcount;
 			break;
 		case MTBSR:
 			cmd = TS_CMD_SRR;
 			sc->sc_vts->cmd.cw1 = bp->b_bcount;
 			break;
 		case MTREW:
 			cmd = TS_CMD_RWND;
 			break;
 		case MTOFFL:
 			cmd = TS_CMD_RWUL;
 			break;
 		case MTNOP:
 			cmd = TS_CMD_STAT;
 			break;
 		default:
 			aprint_error_dev(sc->sc_dev, "bad ioctl %d\n",
 				(int)bp->b_resid);
 			/* Need a no-op. get status */
 			cmd = TS_CMD_STAT;
 		} /* end switch (bp->b_resid) */
 	} else {
 		if (isloaded == 0) {
 			/*
 			 * now we try to map the buffer into uba map space (???)
 			 */
 			if (bus_dmamap_load(sc->sc_dmat, sc->sc_dmam,
 			    bp->b_data,
 			    bp->b_bcount, bp->b_proc, BUS_DMA_NOWAIT)) {
 				uba_enqueue(&sc->sc_uu);
 				return 0;
+			}
 			sc->sc_rtc = 0;
+		}
 		sc->sc_vts->cmd.cw1 = LOWORD(sc->sc_dmam->dm_segs[0].ds_addr);
 		sc->sc_vts->cmd.cw2 = HIWORD(sc->sc_dmam->dm_segs[0].ds_addr);
 		sc->sc_vts->cmd.cw3 = bp->b_bcount;
 		bp->b_error = 0; /* Used for error count */
 #ifdef TSDEBUG
 		printf("tsstart-1: err %d\n", bp->b_error);
 #endif
 		if (bp->b_flags & B_READ)
 			cmd = TS_CMD_RNF;
 		else
 			cmd = TS_CMD_WD;
+	}
 	/*
 	 * Now that the command-buffer is setup, give it to the controller
 	 */
 	sc->sc_vts->cmd.cmdr = TS_CF_ACK | TS_CF_IE | cmd;
 #ifdef TSDEBUG
 	printf("tsstart: sending cmdr %x\n", sc->sc_vts->cmd.cmdr);
 #endif
 	TS_WCSR(TSDB, sc->sc_waddr);
 	return 1;
+}
 /*
  * Called when there are free uba resources.
  */
 int
 tsready(struct uba_unit *uu)
+{
 	struct ts_softc *sc = device_private(uu->uu_dev);
 	struct buf *bp = bufq_peek(sc->sc_bufq);
 	if (bus_dmamap_load(sc->sc_dmat, sc->sc_dmam, bp->b_data,
 	    bp->b_bcount, bp->b_proc, BUS_DMA_NOWAIT))
 		return 0;
 	tsstart(sc, 1);
 	return 1;
+}
 /*
  * initialize the controller by sending WRITE CHARACTERISTICS command.
  * contents of command- and message-buffer are assembled during this
  * function.
  */
 void
 tswchar(struct ts_softc *sc)
+{
 	/*
 	 * assemble and send "WRITE CHARACTERISTICS" command
 	 */
 	sc->sc_vts->cmd.cmdr = TS_CF_ACK | TS_CF_IE | TS_CMD_WCHAR;
 	sc->sc_vts->cmd.cw1  = LOWORD(&sc->sc_bts->chr);
 	sc->sc_vts->cmd.cw2  = HIWORD(&sc->sc_bts->chr);
 	sc->sc_vts->cmd.cw3  = 010;		   /* size of charact.-data */
 	sc->sc_vts->chr.sadrl = LOWORD(&sc->sc_bts->status);
 	sc->sc_vts->chr.sadrh = HIWORD(&sc->sc_bts->status);
 	sc->sc_vts->chr.onesix = (sc->sc_type == TYPE_TS05 ? 020 : 016);
 	sc->sc_vts->chr.chrw = TS_WC_ESS;
 	sc->sc_vts->chr.xchrw = TS_WCX_HSP|TS_WCX_RBUF|TS_WCX_WBUF;
 	TS_WCSR(TSDB, sc->sc_waddr);
+}
 /*
  * Reset the TS11. Return 1 if failed, 0 if succeeded.
  */
 bool
 tsreset(struct ts_softc *sc)
+{
 	int timeout;
 	/*
 	 * reset ctlr by writing into TSSR, then write characteristics
 	 */
 	timeout = 0;		/* timeout in 10 seconds */
 	TS_WCSR(TSSR, 0);	/* start initialization */
 	while ((TS_RCSR(TSSR) & TS_SSR) == 0) {
 		DELAY(10000);
 		if (timeout++ > 1000)
 			return false;
+	}
 	return true;
+}
 static void
 prtstat(struct ts_softc *sc, int sr)
+{
 	char buf[100];
 	snprintb(buf, sizeof(buf), TS_TSSR_BITS, sr);
 	aprint_normal_dev(sc->sc_dev, "TSSR=%s\n", buf);
 	snprintb(buf, sizeof(buf), TS_XST0_BITS, sc->sc_vts->status.xst0);
 	aprint_normal_dev(sc->sc_dev, "XST0=%s\n", buf);
+}
 /*
  * TSV05/TS05 interrupt routine
  */
 static void
 tsintr(void *arg)
+{
 	struct ts_softc *sc = arg;
 	struct buf *bp;
 	unsigned short sr = TS_RCSR(TSSR);	/* save TSSR */
 	unsigned short mh = sc->sc_vts->status.hdr;	/* and msg-header */
 		/* clear the message header ??? */
 	short ccode = sc->sc_vts->cmd.cmdr & TS_CF_CCODE;
 	bp = bufq_peek(sc->sc_bufq);
 #ifdef TSDEBUG
+	{
 		char buf[100];
 		snprintb(buf, sizeof(buf), TS_TSSR_BITS, sr);
 		printf("tsintr: sr %x mh %x\n", sr, mh);
 		printf("srbits: %s\n", buf);
+	}
 #endif
 	/*
 	 * There are two different things which can (and should) be checked:
 	 * the actual (internal) state and the device's result (tssr/msg.hdr)
+	 *
 	 * For each state there's only one "normal" interrupt. Anything else
 	 * has to be checked more intensively. Thus in a first run according
 	 * to the internal state the expected interrupt is checked/handled.
+	 *
 	 * In a second run the remaining (not yet handled) interrupts are
 	 * checked according to the drive's result.
 	 */
 	switch (sc->sc_state) {
 	case TS_INVALID:
 		/*
 		 * Ignore unsolicited interrupts.
 		 */
 		log(LOG_WARNING, "%s: stray intr [%x,%x]\n",
 			device_xname(sc->sc_dev), sr, mh);
 		return;
 	case TS_INIT:
 		/*
 		 * Init phase ready.
 		 */
 		wakeup(sc);
 		return;
 	case TS_RUNNING:
 	case TS_FASTREPOS:
 		/*
 		 * Here we expect interrupts indicating the end of
 		 * commands or indicating problems.
 		 */
 		/*
 		 * Anything else is handled outside this switch ...
 		 */
 		break;
 	default:
 		aprint_error_dev(sc->sc_dev,
 		    "unexpected interrupt during state %d [%x,%x]\n",
 		    sc->sc_state, sr, mh);
 		return;
+	}
 	/*
 	 * now we check the termination class.
 	 */
 	switch (sr & TS_TC) {
 	case TS_TC_NORM:
 		/*
 		 * Normal termination -- The operation is completed
 		 * witout incident.
 		 */
 		if (sc->sc_state == TS_FASTREPOS) {
 #ifdef TSDEBUG
 			printf("Fast repos interrupt\n");
 #endif
 			/* Fast repos succeeded, start normal data xfer */
 			sc->sc_state = TS_RUNNING;
 			tsstart(sc, 1);
 			return;
+		}
 		sc->sc_liowf = (ccode == TS_CC_WRITE);
 		break;
 	case TS_TC_ATTN:
 		/*
 		 * Attention condition -- this code indicates that the
 		 * drive has undergone a status change, such as going
 		 * off-line or coming on-line.
 		 * (Without EAI enabled, no Attention interrupts occur.
 		 * drive status changes are signaled by the VCK flag.)
 		 */
 		return;
 	case TS_TC_TSA:
 		/*
 		 * Tape Status Alert -- A status condition is encountered
 		 * that may have significance to the program. Bits of
 		 * interest in the extended status registers include
 		 * TMK, EOT and RLL.
 		 */
 #ifdef TSDEBUG
+		{
 			char buf[100];
 			snprintb(buf, sizeof(buf),
 			    TS_XST0_BITS, sc->sc_vts->status.xst0);
 			printf("TSA: sr %x bits %s\n",
 			    sc->sc_vts->status.xst0, buf);
+		}
 #endif
 		if (sc->sc_vts->status.xst0 & TS_SF_TMK) {
 #ifdef TSDEBUG
 			printf(("Tape Mark detected"));
 #endif
 			/* Read to end-of-file. No error. */
 			break;
+		}
 		if (sc->sc_vts->status.xst0 & TS_SF_EOT) {
 			/* End of tape. Bad. */
 #ifdef TSDEBUG
 			printf("TS_TC_TSA: EOT\n");
 #endif
 			if (bp != NULL)
 				bp->b_error = EIO;
 			break;
+		}
 		if (sc->sc_vts->status.xst0 & TS_SF_RLS)
 			break;
 #ifndef TSDEBUG
+		{
 			char buf[100];
 			snprintb(buf, sizeof(buf),
 			    TS_XST0_BITS, sc->sc_vts->status.xst0);
 			printf("TSA: sr %x bits %s\n",
 			    sc->sc_vts->status.xst0, buf);
+		}
 #endif
 		break;
 	case TS_TC_FR:
 		/*
 		 * Function Reject -- The specified function was not
 		 * initiated. Bits of interest include OFL, VCK, BOT,
 		 * WLE, ILC and ILA.
 		 */
 		if (sr & TS_OFL)
 			printf("tape is off-line.\n");
 #ifdef TSDEBUG
+		{
 			char buf[100];
 			snprintb(buf, sizeof(buf),
 			    TS_XST0_BITS, sc->sc_vts->status.xst0);
 			printf("FR: sr %x bits %s\n",
 			    sc->sc_vts->status.xst0, buf);
+		}
 #endif
 		if (sc->sc_vts->status.xst0 & TS_SF_VCK)
 			printf("Volume check\n");
 		if (sc->sc_vts->status.xst0 & TS_SF_BOT)
 			printf("Start of tape.\n");
 		if (sc->sc_vts->status.xst0 & TS_SF_WLE)
 			printf("Write Lock Error\n");
 		if (sc->sc_vts->status.xst0 & TS_SF_EOT)
 			printf("End of tape.\n");
 		break;
 	case TS_TC_TPD:
 		/*
 		 * Recoverable Error -- Tape position is a record beyond
 		 * what its position was when the function was initiated.
 		 * Suggested recovery procedure is to log the error and
 		 * issue the appropriate retry command.
+		 *
 		 * Do a fast repositioning one record back.
 		 */
 		sc->sc_state = TS_FASTREPOS;
 #ifdef TSDEBUG
 		printf("TS_TC_TPD: errcnt %d\n", sc->sc_rtc);
 #endif
 		if (sc->sc_rtc++ == 8) {
 			aprint_error_dev(sc->sc_dev, "failed 8 retries\n");
 			prtstat(sc, sr);
 			if (bp != NULL)
 				bp->b_error = EIO;
 			break;
+		}
 		sc->sc_vts->cmd.cmdr = TS_CF_ACK | TS_CF_IE | TS_CMD_SRR;
 		sc->sc_vts->cmd.cw1 = 1;
 		TS_WCSR(TSDB, sc->sc_waddr);
 		return;
 	case TS_TC_TNM:
 		/*
 		 * Recoverable Error -- Tape position has not changed.
 		 * Suggested recovery procedure is to log the error and
 		 * reissue the original command.
 		 */
 		if (sc->sc_rtc++ == 8) {
 			aprint_error_dev(sc->sc_dev, "failed 8 retries\n");
 			prtstat(sc, sr);
 			if (bp != NULL)
 				bp->b_error = EIO;
 			break;
+		}
 		tsstart(sc, 1);
 		return;
 	case TS_TC_TPL:
 		/*
 		 * Unrecoverable Error -- Tape position has been lost.
 		 * No valid recovery procedures exist unless the tape
 		 * has labels or sequence numbers.
 		 */
 		aprint_error_dev(sc->sc_dev, "tape position lost\n");
 		if (bp != NULL)
 			bp->b_error = EIO;
 		break;
 	case TS_TC_FCE:
 		/*
 		 * Fatal subsystem Error -- The subsystem is incapable
 		 * of properly performing commands, or at least its
 		 * integrity is seriously questionable. Refer to the
 		 * fatal class code field in the TSSR register for
 		 * additional information on the type of fatal error.
 		 */
 		aprint_error_dev(sc->sc_dev, "fatal controller error\n");
 		prtstat(sc, sr);
 		break;
 	default:
 		aprint_error_dev(sc->sc_dev,
 		    "error 0x%x, resetting controller\n", sr & TS_TC);
 		tsreset(sc);
+	}
 	if ((bp = bufq_get(sc->sc_bufq)) != NULL) {
 #ifdef TSDEBUG
 		printf("tsintr2: que %p\n", bufq_peek(sc->sc_bufq));
 #endif
 		if (bp != &sc->ts_cbuf) {	/* no ioctl */
 			bus_dmamap_unload(sc->sc_dmat, sc->sc_dmam);
 			uba_done(sc->sc_uh);
+		}
 		bp->b_resid = sc->sc_vts->status.rbpcr;
 		biodone (bp);
+	}
 	tsstart(sc, 0);
+}
 /*
  * Open a ts device and set the unit online.  If the controller is not
  * in the run state, call init to initialize the ts controller first.
  */
 int
 tsopen(dev_t dev, int flag, int type, struct lwp *l)
+{
 	struct ts_softc *sc = device_lookup_private(&ts_cd, TS_UNIT(dev));
 	if (sc == NULL)
 		return ENXIO;
 	if (sc->sc_state < TS_RUNNING)
 		return ENXIO;
 	if (sc->sc_openf)
 		return EBUSY;
 	sc->sc_openf = 1;
 	/*
 	 * check if transport is really online.
 	 * (without attention-interrupts enabled, we really don't know
 	 * the actual state of the transport. Thus we call get-status
 	 * (ie. MTNOP) once and check the actual status.)
 	 */
 	if (TS_RCSR(TSSR) & TS_OFL) {
 		uprintf("%s: transport is offline.\n", device_xname(sc->sc_dev));
 		sc->sc_openf = 0;
 		return EIO;		/* transport is offline */
+	}
 	tscommand(sc, dev, MTNOP, 1);
 	if ((flag & FWRITE) && (sc->sc_vts->status.xst0 & TS_SF_WLK)) {
 		uprintf("%s: no write ring.\n", device_xname(sc->sc_dev));
 		sc->sc_openf = 0;
 		return EROFS;
+	}
 	if (sc->sc_vts->status.xst0 & TS_SF_VCK) {
 		sc->sc_vts->cmd.cmdr = TS_CF_CVC|TS_CF_ACK;
 		TS_WCSR(TSDB, sc->sc_waddr);
+	}
 	tscommand(sc, dev, MTNOP, 1);
 #ifdef TSDEBUG
+	{
 		char buf[100];
 		snprintb(buf, sizeof(buf),
 		    TS_XST0_BITS, sc->sc_vts->status.xst0);
 		printf("tsopen: xst0 %s\n", buf);
+	}
 #endif
 	sc->sc_liowf = 0;
 	return 0;
+}
 /*
  * Close tape device.
+ *
  * If tape was open for writing or last operation was
  * a write, then write two EOF's and backspace over the last one.
  * Unless this is a non-rewinding special file, rewind the tape.
+ *
  * Make the tape available to others, by clearing openf flag.
  */
 int
 tsclose(dev_t dev, int flag, int type, struct lwp *l)
+{
 	struct ts_softc *sc = device_lookup_private(&ts_cd, TS_UNIT(dev));
 	if (flag == FWRITE || ((flag & FWRITE) && sc->sc_liowf)) {
 		/*
 		 * We are writing two tape marks (EOT), but place the tape
 		 * before the second one, so that another write operation
 		 * will overwrite the second one and leave and EOF-mark.
 		 */
 		tscommand(sc, dev, MTWEOF, 1);	/* Write Tape Mark */
 		tscommand(sc, dev, MTWEOF, 1);	/* Write Tape Mark */
 		tscommand(sc, dev, MTBSF, 1);	/* Skip Tape Marks Reverse */
+	}
 	if ((dev & T_NOREWIND) == 0)
 		tscommand(sc, dev, MTREW, 0);
 	sc->sc_openf = 0;
 	sc->sc_liowf = 0;
 	return 0;
+}
 /*
  * Manage buffers and perform block mode read and write operations.
  */
 void
 tsstrategy(struct buf *bp)
+{
 	struct ts_softc *sc = device_lookup_private(&ts_cd, TS_UNIT(bp->b_dev));
 	bool empty;
 	int s;
 #ifdef TSDEBUG
 	printf("buf: %p bcount %ld blkno %d\n", bp, bp->b_bcount, bp->b_blkno);
 #endif
 	s = splbio ();
 	empty = (bufq_peek(sc->sc_bufq) == NULL);
 	bufq_put(sc->sc_bufq, bp);
 	if (empty)
 		tsstart(sc, 0);
 	splx(s);
+}
 /*
  * Catch ioctl commands, and call the "command" routine to do them.
  */
 int
 tsioctl(dev_t dev,
 	u_long cmd,
 	void *data,
 	int flag,
 	struct lwp *l)
+{
 	struct buf *bp;
 	struct ts_softc * const sc = device_lookup_private(&ts_cd, TS_UNIT(dev));
 	struct mtop *mtop;	/* mag tape cmd op to perform */
 	struct mtget *mtget;	/* mag tape struct to get info in */
 	int callcount;		/* number of times to call routine */
 	int scount;			/* number of files/records to space */
 	int spaceop = 0;		/* flag for skip/space operation */
 	int error = 0;
 #ifdef TSDEBUG
 	printf("tsioctl (%x, %lx, %p, %d)\n", dev, cmd, data, flag);
 #endif
 	bp = &sc->ts_cbuf;
 	switch (cmd) {
 	case MTIOCTOP:			/* do a mag tape op */
 		mtop = (struct mtop *)data;
 		switch (mtop->mt_op) {
 		case MTWEOF:		/* write an end-of-file record */
 			callcount = mtop->mt_count;
 			scount = 1;
 			break;
 		case MTFSR:		/* forward space record */
 		case MTBSR:		/* backward space record */
 			spaceop = 1;
 		case MTFSF:		/* forward space file */
 		case MTBSF:		/* backward space file */
 			callcount = 1;
 			scount = mtop->mt_count;
 			break;
 		case MTREW:		/* rewind */
 		case MTOFFL:		/* rewind and put the drive offline */
 		case MTNOP:		/* no operation, sets status only */
 			callcount = 1;
 			scount = 1;		/* wait for this rewind */
 			break;
 		case MTRETEN:		/* retension */
 		case MTERASE:		/* erase entire tape */
 		case MTEOM:		/* forward to end of media */
 		case MTNBSF:		/* backward space to begin of file */
 		case MTCACHE:		/* enable controller cache */
 		case MTNOCACHE:		/* disable controller cache */
 		case MTSETBSIZ:		/* set block size; 0 for variable */
 		case MTSETDNSTY:	/* set density code for current mode */
 			printf("ioctl %d not implemented.\n", mtop->mt_op);
 			return (ENXIO);
 		default:
 #ifdef TSDEBUG
 			printf("invalid ioctl %d\n", mtop->mt_op);
 #endif
 			return (ENXIO);
 		}	/* switch (mtop->mt_op) */
 		if (callcount <= 0 || scount <= 0) {
 #ifdef TSDEBUG
 			printf("invalid values %d/%d\n", callcount, scount);
 #endif
 			return (EINVAL);
+		}
 		do {
 			tscommand(sc, dev, mtop->mt_op, scount);
 			if (spaceop && bp->b_resid) {
 #ifdef TSDEBUG
 				printf(("spaceop didn't complete\n"));
 #endif
 				return (EIO);
+			}
 			if (bp->b_error != 0) {
 #ifdef TSDEBUG
 				printf("error in ioctl %d\n", mtop->mt_op);
 #endif
 				break;
+			}
 		} while (--callcount > 0);
 		if (bp->b_error != 0)
 			error = bp->b_error;
 		return (error);
 	case MTIOCGET:			/* get tape status */
 		mtget = (struct mtget *)data;
 		mtget->mt_type = MT_ISTS;
 		mtget->mt_dsreg = TS_RCSR(TSSR);
 		mtget->mt_erreg = sc->sc_vts->status.xst0;
 		mtget->mt_resid = 0;		/* ??? */
 		mtget->mt_density = 0;		/* ??? */
 		break;
 	case MTIOCIEOT:			/* ignore EOT error */
 #ifdef TSDEBUG
 		printf(("MTIOCIEOT not implemented.\n"));
 #endif
 		return (ENXIO);
 	case MTIOCEEOT:			/* enable EOT error */
 #ifdef TSDEBUG
 		printf(("MTIOCEEOT not implemented.\n"));
 #endif
 		return (ENXIO);
 	default:
 #ifdef TSDEBUG
 		printf("invalid ioctl cmd 0x%lx\n", cmd);
 #endif
 		return (ENXIO);
+	}
 	return (0);
+}
 /*
+ *
  */
 int
 tsread(dev_t dev, struct uio *uio, int flag)
+{
 	return (physio (tsstrategy, NULL, dev, B_READ, minphys, uio));
+}
 /*
+ *
  */
 int
 tswrite(dev_t dev, struct uio *uio, int flag)
+{
 	return (physio (tsstrategy, NULL, dev, B_WRITE, minphys, uio));
+}
 /*
+ *
  */
 int
 tsdump(dev_t dev, daddr_t blkno, void *va, size_t size)
+{
 	return EIO;
+}