 @@ -1,14 +1,14 @@
-/*	$NetBSD: ncr53c9x.c,v 1.142 2011/07/04 16:06:17 joerg Exp $	*/
+/*	$NetBSD: ncr53c9x.c,v 1.143 2011/07/31 18:39:00 jakllsch Exp $	*/
 /*-
  * Copyright (c) 1998, 2002 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Charles M. Hannum.
+ *
  * 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.
 @@ -60,27 +60,27 @@
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Based on aic6360 by Jarle Greipsland
+ *
  * Acknowledgements: Many of the algorithms used in this driver are
  * inspired by the work of Julian Elischer (julian@tfs.com) and
  * Charles Hannum (mycroft@duality.gnu.ai.mit.edu).  Thanks a million!
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ncr53c9x.c,v 1.142 2011/07/04 16:06:17 joerg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ncr53c9x.c,v 1.143 2011/07/31 18:39:00 jakllsch Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/callout.h>
 #include <sys/kernel.h>
 #include <sys/errno.h>
 #include <sys/ioctl.h>
 #include <sys/device.h>
 #include <sys/buf.h>
 #include <sys/malloc.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/pool.h>
 @@ -184,27 +184,27 @@ ncr53c9x_lunsearch(struct ncr53c9x_tinfo
 			return li;
 	return NULL;
+}
 /*
  * Attach this instance, and then all the sub-devices
  */
 void
 ncr53c9x_attach(struct ncr53c9x_softc *sc)
+{
 	struct scsipi_adapter *adapt = &sc->sc_adapter;
 	struct scsipi_channel *chan = &sc->sc_channel;
-	simple_lock_init(&sc->sc_lock);
+	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_BIO);
 	callout_init(&sc->sc_watchdog, 0);
 	/*
 	 * Note, the front-end has set us up to print the chip variation.
 	 */
 	if (sc->sc_rev >= NCR_VARIANT_MAX) {
 		aprint_error(": unknown variant %d, devices not attached\n",
 		    sc->sc_rev);
 		return;
+	}
 	aprint_normal(": %s, %dMHz, SCSI ID %d\n",
 @@ -331,26 +331,28 @@ ncr53c9x_detach(struct ncr53c9x_softc *s
+	}
 	if (sc->sc_child) {
 		error = config_detach(sc->sc_child, flags);
 		if (error)
 			return error;
+	}
 	if (sc->sc_imess)
 		free(sc->sc_imess, M_DEVBUF);
 	if (sc->sc_omess)
 		free(sc->sc_omess, M_DEVBUF);
 	mutex_destroy(&sc->sc_lock);
 	return 0;
+}
 /*
  * This is the generic ncr53c9x reset function. It does not reset the SCSI bus,
  * only this controller, but kills any on-going commands, and also stops
  * and resets the DMA.
+ *
  * After reset, registers are loaded with the defaults from the attach
  * routine above.
  */
 void
 ncr53c9x_reset(struct ncr53c9x_softc *sc)
 @@ -847,57 +849,55 @@ ncr53c9x_get_ecb(struct ncr53c9x_softc *
  * Start a SCSI-command
  * This function is called by the higher level SCSI-driver to queue/run
  * SCSI-commands.
  */
 void
 ncr53c9x_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req,
     void *arg)
+{
 	struct scsipi_xfer *xs;
 	struct scsipi_periph *periph;
 	struct ncr53c9x_softc *sc;
 	struct ncr53c9x_ecb *ecb;
-	int s, flags;
+	int flags;
 	NCR_TRACE(("[ncr53c9x_scsipi_request] "));
 	sc = device_private(chan->chan_adapter->adapt_dev);
-	s = splbio();
+	mutex_enter(&sc->sc_lock);
 	simple_lock(&sc->sc_lock);
 	switch (req) {
 	case ADAPTER_REQ_RUN_XFER:
 		xs = arg;
 		periph = xs->xs_periph;
 		flags = xs->xs_control;
 		NCR_CMDS(("[0x%x, %d]->%d ", (int)xs->cmd->opcode, xs->cmdlen,
 		    periph->periph_target));
 		/* Get an ECB to use. */
 		ecb = ncr53c9x_get_ecb(sc, xs->xs_control);
 		/*
 		 * This should never happen as we track resources
 		 * in the mid-layer, but for now it can as pool_get()
 		 * can fail.
 		 */
 		if (ecb == NULL) {
 			scsipi_printaddr(periph);
 			printf("%s: unable to allocate ecb\n",
 			    device_xname(sc->sc_dev));
 			xs->error = XS_RESOURCE_SHORTAGE;
-			simple_unlock(&sc->sc_lock);
+			mutex_exit(&sc->sc_lock);
 			splx(s);
 			scsipi_done(xs);
 			return;
+		}
 		/* Initialize ecb */
 		ecb->xs = xs;
 		ecb->timeout = xs->timeout;
 		if (flags & XS_CTL_RESET) {
 			ecb->flags |= ECB_RESET;
 			ecb->clen = 0;
 			ecb->dleft = 0;
 		} else {
 @@ -962,28 +962,27 @@ ncr53c9x_scsipi_request(struct scsipi_ch
 			ti->flags |= T_NEGOTIATE;
 			ti->period = sc->sc_minsync;
+		}
 		/*
 		 * If we're not going to negotiate, send the notification
 		 * now, since it won't happen later.
 		 */
 		if ((ti->flags & T_NEGOTIATE) == 0)
 			ncr53c9x_update_xfer_mode(sc, xm->xm_target);
+	    }
 		break;
+	}
-	simple_unlock(&sc->sc_lock);
+	mutex_exit(&sc->sc_lock);
 	splx(s);
+}
 void
 ncr53c9x_update_xfer_mode(struct ncr53c9x_softc *sc, int target)
+{
 	struct scsipi_xfer_mode xm;
 	struct ncr53c9x_tinfo *ti = &sc->sc_tinfo[target];
 	xm.xm_target = target;
 	xm.xm_mode = 0;
 	xm.xm_period = 0;
 	xm.xm_offset = 0;
 @@ -1001,61 +1000,59 @@ ncr53c9x_update_xfer_mode(struct ncr53c9
 	scsipi_async_event(&sc->sc_channel, ASYNC_EVENT_XFER_MODE, &xm);
+}
 /*
  * Used when interrupt driven I/O isn't allowed, e.g. during boot.
  */
 int
 ncr53c9x_poll(struct ncr53c9x_softc *sc, struct scsipi_xfer *xs, int count)
+{
 	NCR_TRACE(("[ncr53c9x_poll] "));
 	while (count) {
 		if (NCRDMA_ISINTR(sc)) {
-			simple_unlock(&sc->sc_lock);
+			mutex_exit(&sc->sc_lock);
 			ncr53c9x_intr(sc);
-			simple_lock(&sc->sc_lock);
+			mutex_enter(&sc->sc_lock);
+		}
 #if alternatively
 		if (NCR_READ_REG(sc, NCR_STAT) & NCRSTAT_INT)
 			ncr53c9x_intr(sc);
 #endif
 		if ((xs->xs_status & XS_STS_DONE) != 0)
 			return 0;
 		if (sc->sc_state == NCR_IDLE) {
 			NCR_TRACE(("[ncr53c9x_poll: rescheduling] "));
 			ncr53c9x_sched(sc);
+		}
 		DELAY(1000);
 		count--;
+	}
 	return 1;
+}
 int
 ncr53c9x_ioctl(struct scsipi_channel *chan, u_long cmd, void *arg,
     int flag, struct proc *p)
+{
 	struct ncr53c9x_softc *sc;
-	int s, error = 0;
+	int error = 0;
 	sc = device_private(chan->chan_adapter->adapt_dev);
 	switch (cmd) {
 	case SCBUSIORESET:
-		s = splbio();
+		mutex_enter(&sc->sc_lock);
 		simple_lock(&sc->sc_lock);
 		ncr53c9x_init(sc, 1);
-		simple_unlock(&sc->sc_lock);
+		mutex_exit(&sc->sc_lock);
 		splx(s);
 		break;
 	default:
 		error = ENOTTY;
 		break;
+	}
 	return error;
+}
 /*
  * LOW LEVEL SCSI UTILITIES
  */
 @@ -1269,29 +1266,29 @@ ncr53c9x_done(struct ncr53c9x_softc *sc,
 	if (xs->error == XS_SELTIMEOUT) {
 		/* Selection timeout -- discard this LUN if empty */
 		if (li->untagged == NULL && li->used == 0) {
 			if (lun < NCR_NLUN)
 				ti->lun[lun] = NULL;
 			LIST_REMOVE(li, link);
 			free(li, M_DEVBUF);
+		}
+	}
 	ncr53c9x_free_ecb(sc, ecb);
 	ti->cmds++;
-	simple_unlock(&sc->sc_lock);
+	mutex_exit(&sc->sc_lock);
 	scsipi_done(xs);
-	simple_lock(&sc->sc_lock);
+	mutex_enter(&sc->sc_lock);
+}
 void
 ncr53c9x_dequeue(struct ncr53c9x_softc *sc, struct ncr53c9x_ecb *ecb)
+{
 	struct ncr53c9x_tinfo *ti =
 	    &sc->sc_tinfo[ecb->xs->xs_periph->periph_target];
 	struct ncr53c9x_linfo *li;
 	int64_t lun = ecb->xs->xs_periph->periph_lun;
 	li = TINFO_LUN(ti, lun);
 #ifdef DIAGNOSTIC
 	if (li == NULL || li->lun != lun)
 @@ -2080,27 +2077,27 @@ ncr53c9x_intr(void *arg)
+{
 	struct ncr53c9x_softc *sc = arg;
 	struct ncr53c9x_ecb *ecb;
 	struct scsipi_periph *periph;
 	struct ncr53c9x_tinfo *ti;
 	size_t size;
 	int nfifo;
 	NCR_INTS(("[ncr53c9x_intr: state %d]", sc->sc_state));
 	if (!NCRDMA_ISINTR(sc))
 		return 0;
-	simple_lock(&sc->sc_lock);
+	mutex_enter(&sc->sc_lock);
 again:
 	/* and what do the registers say... */
 	ncr53c9x_readregs(sc);
 	sc->sc_intrcnt.ev_count++;
 	/*
 	 * At the moment, only a SCSI Bus Reset or Illegal
 	 * Command are classed as errors. A disconnect is a
 	 * valid condition, and we let the code check is the
 	 * "NCR_BUSFREE_OK" flag was set before declaring it
 	 * and error.
+	 *
 @@ -2614,27 +2611,27 @@ again:
 		} else {
 			printf("%s: unexpected status after select"
 			    ": [intr %x, stat %x, step %x]\n",
 			    device_xname(sc->sc_dev),
 			    sc->sc_espintr, sc->sc_espstat, sc->sc_espstep);
 			NCRCMD(sc, NCRCMD_FLUSH);
 			DELAY(1);
 			goto reset;
+		}
 		if (sc->sc_state == NCR_IDLE) {
 			printf("%s: stray interrupt\n",
 			    device_xname(sc->sc_dev));
-			simple_unlock(&sc->sc_lock);
+			mutex_exit(&sc->sc_lock);
 			return 0;
+		}
 		break;
 	case NCR_CONNECTED:
 		if ((sc->sc_flags & NCR_ICCS) != 0) {
 			/* "Initiate Command Complete Steps" in progress */
 			uint8_t msg;
 			sc->sc_flags &= ~NCR_ICCS;
 			if ((sc->sc_espintr & NCRINTR_DONE) == 0) {
 				printf("%s: ICCS: "
 @@ -2805,27 +2802,27 @@ msgin:
 		sc->sc_prevphase = STATUS_PHASE;
 		goto shortcut;	/* i.e. expect status results soon */
 	case INVALID_PHASE:
 		break;
 	default:
 		printf("%s: unexpected bus phase; resetting\n",
 		    device_xname(sc->sc_dev));
 		goto reset;
+	}
 out:
-	simple_unlock(&sc->sc_lock);
+	mutex_exit(&sc->sc_lock);
 	return 1;
 reset:
 	ncr53c9x_init(sc, 1);
 	goto out;
 finish:
 	ncr53c9x_done(sc, ecb);
 	goto out;
 sched:
 	sc->sc_state = NCR_IDLE;
 	ncr53c9x_sched(sc);
 @@ -2889,98 +2886,93 @@ ncr53c9x_abort(struct ncr53c9x_softc *sc
 		if (sc->sc_state == NCR_IDLE)
 			ncr53c9x_sched(sc);
+	}
+}
 void
 ncr53c9x_timeout(void *arg)
+{
 	struct ncr53c9x_ecb *ecb = arg;
 	struct scsipi_xfer *xs = ecb->xs;
 	struct scsipi_periph *periph = xs->xs_periph;
 	struct ncr53c9x_softc *sc;
 	struct ncr53c9x_tinfo *ti;
 	int s;
 	sc = device_private(periph->periph_channel->chan_adapter->adapt_dev);
 	ti = &sc->sc_tinfo[periph->periph_target];
 	scsipi_printaddr(periph);
 	printf("%s: timed out [ecb %p (flags 0x%x, dleft %x, stat %x)], "
 	    "<state %d, nexus %p, phase(l %x, c %x, p %x), resid %lx, "
 	    "msg(q %x,o %x) %s>",
 	    device_xname(sc->sc_dev),
 	    ecb, ecb->flags, ecb->dleft, ecb->stat,
 	    sc->sc_state, sc->sc_nexus,
 	    NCR_READ_REG(sc, NCR_STAT),
 	    sc->sc_phase, sc->sc_prevphase,
 	    (long)sc->sc_dleft, sc->sc_msgpriq, sc->sc_msgout,
 	    NCRDMA_ISACTIVE(sc) ? "DMA active" : "");
 #if NCR53C9X_DEBUG > 1
 	printf("TRACE: %s.", ecb->trace);
 #endif
-	s = splbio();
+	mutex_enter(&sc->sc_lock);
 	simple_lock(&sc->sc_lock);
 	if (ecb->flags & ECB_ABORT) {
 		/* abort timed out */
 		printf(" AGAIN\n");
 		ncr53c9x_init(sc, 1);
 	} else {
 		/* abort the operation that has timed out */
 		printf("\n");
 		xs->error = XS_TIMEOUT;
 		ncr53c9x_abort(sc, ecb);
 		/* Disable sync mode if stuck in a data phase */
 		if (ecb == sc->sc_nexus &&
 		    (ti->flags & T_SYNCMODE) != 0 &&
 		    (sc->sc_phase & (MSGI | CDI)) == 0) {
 			/* XXX ASYNC CALLBACK! */
 			scsipi_printaddr(periph);
 			printf("sync negotiation disabled\n");
 			sc->sc_cfflags |=
 			    (1 << ((periph->periph_target & 7) + 8));
 			ncr53c9x_update_xfer_mode(sc, periph->periph_target);
+		}
+	}
-	simple_unlock(&sc->sc_lock);
+	mutex_exit(&sc->sc_lock);
 	splx(s);
+}
 void
 ncr53c9x_watch(void *arg)
+{
 	struct ncr53c9x_softc *sc = arg;
 	struct ncr53c9x_tinfo *ti;
 	struct ncr53c9x_linfo *li;
-	int t, s;
+	int t;
 	/* Delete any structures that have not been used in 10min. */
 	time_t old = time_second - (10 * 60);
-	s = splbio();
+	mutex_enter(&sc->sc_lock);
 	simple_lock(&sc->sc_lock);
 	for (t = 0; t < sc->sc_ntarg; t++) {
 		ti = &sc->sc_tinfo[t];
 		li = LIST_FIRST(&ti->luns);
 		while (li) {
 			if (li->last_used < old &&
 			    li->untagged == NULL &&
 			    li->used == 0) {
 				if (li->lun < NCR_NLUN)
 					ti->lun[li->lun] = NULL;
 				LIST_REMOVE(li, link);
 				free(li, M_DEVBUF);
 				/* Restart the search at the beginning */
 				li = LIST_FIRST(&ti->luns);
 				continue;
+			}
 			li = LIST_NEXT(li, link);
+		}
+	}
-	simple_unlock(&sc->sc_lock);
+	mutex_exit(&sc->sc_lock);
 	splx(s);
 	callout_reset(&sc->sc_watchdog, 60 * hz, ncr53c9x_watch, sc);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: ncr53c9xvar.h,v 1.54 2009/09/07 13:31:44 tsutsui Exp $	*/
+/*	$NetBSD: ncr53c9xvar.h,v 1.55 2011/07/31 18:39:00 jakllsch Exp $	*/
 /*-
  * Copyright (c) 1997 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center.
+ *
  * 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
 @@ -52,27 +52,27 @@
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR 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.
  */
 #ifndef _DEV_IC_NCR53C9XVAR_H_
 #define _DEV_IC_NCR53C9XVAR_H_
-#include <sys/simplelock.h>
+#include <sys/mutex.h>
 /* Set this to 1 for normal debug, or 2 for per-target tracing. */
 /* #define NCR53C9X_DEBUG		1 */
 /* Wide or differential can have 16 targets */
 #define NCR_NLUN		8
 #define	NCR_ABORT_TIMEOUT	2000	/* time to wait for abort */
 #define	NCR_SENSE_TIMEOUT	1000	/* time to wait for sense */
 #define FREQTOCCF(freq)	(((freq + 4) / 5))
 /*
 @@ -325,27 +325,27 @@ struct ncr53c9x_softc {
 	size_t	sc_imlen;
 	uint8_t	*sc_cmdp;	/* Command pointer (for DMAed commands) */
 	size_t	sc_cmdlen;	/* Size of command in transit */
 	/* Hardware attributes */
 	int sc_freq;		/* SCSI bus frequency in MHz */
 	int sc_id;		/* Our SCSI id */
 	int sc_rev;		/* Chip revision */
 	int sc_features;	/* Chip features */
 	int sc_minsync;		/* Minimum sync period / 4 */
 	int sc_maxxfer;		/* Maximum transfer size */
-	struct simplelock sc_lock;/* driver mutex */
+	kmutex_t sc_lock;	/* driver mutex */
 };
 /* values for sc_state */
 #define NCR_IDLE	1	/* waiting for something to do */
 #define NCR_SELECTING	2	/* SCSI command is arbiting  */
 #define NCR_RESELECTED	3	/* Has been reselected */
 #define NCR_IDENTIFIED	4	/* Has gotten IFY but not TAG */
 #define NCR_CONNECTED	5	/* Actively using the SCSI bus */
 #define	NCR_DISCONNECT	6	/* MSG_DISCONNECT received */
 #define	NCR_CMDCOMPLETE	7	/* MSG_CMDCOMPLETE received */
 #define	NCR_CLEANING	8
 #define NCR_SBR		9	/* Expect a SCSI RST because we commanded it */