Lock the scsi_low code and the drivers which use it along with other

related cleanups:
- Require each driver to initalize a mutex in the scsi_low_softc that
  is shared with the scsi_low code.  This mutex is used for CAM SIMs,
  timers, and interrupt handlers.
- Replace the osdep function switch with direct calls to the relevant
  CAM functions and direct manipulation of timers via callout(9).
- Collapse the CAM-specific scsi_low_osdep_interface substructure
  directly into scsi_low_softc.
- Use bus_*() instead of bus_space_*().
- Return BUS_PROBE_DEFAULT from probe routines instead of 0.
- No need to zero softcs.
- Pass 0ul and ~0ul instead of 0 and ~0 to bus_alloc_resource().
- Spell "dettach" as "detach".
- Remove unused 'dvname' variables.
- De-spl().

Tested by:	no one

3 files changed, 162 insertions, 243 deletions

diff --git a/sys/dev/nsp/nsp.c b/sys/dev/nsp/nsp.c
index dae2bd6..5cda44e 100644
--- a/sys/dev/nsp/nsp.c
+++ b/sys/dev/nsp/nsp.c
@@ -50,6 +50,7 @@ __FBSDID("$FreeBSD$");
 #include <sys/queue.h>
 #include <sys/malloc.h>
 #include <sys/errno.h>
+#include <sys/rman.h>
 
 #include <machine/cpu.h>
 #include <machine/bus.h>
@@ -178,45 +179,36 @@ struct scsi_low_funcs nspfuncs = {
 /****************************************************
  * hwfuncs
  ****************************************************/
-static __inline u_int8_t nsp_cr_read_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_addr_t ofs);
-static __inline void nsp_cr_write_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_addr_t ofs, u_int8_t va);
-
-static __inline u_int8_t
-nsp_cr_read_1(bst, bsh, ofs)
-	bus_space_tag_t bst;
-	bus_space_handle_t bsh;
-	bus_addr_t ofs;
+static __inline uint8_t
+nsp_cr_read_1(struct resource *res, bus_addr_t ofs)
 {
-	
-	bus_space_write_1(bst, bsh, nsp_idxr, ofs);
-	return bus_space_read_1(bst, bsh, nsp_datar);
+
+	bus_write_1(res, nsp_idxr, ofs);
+	return bus_read_1(res, nsp_datar);
 }
 
 static __inline void 
-nsp_cr_write_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_addr_t ofs,
-    u_int8_t va)
+nsp_cr_write_1(struct resource *res, bus_addr_t ofs, uint8_t va)
 {
 
-	bus_space_write_1(bst, bsh, nsp_idxr, ofs);
-	bus_space_write_1(bst, bsh, nsp_datar, va);
+	bus_write_1(res, nsp_idxr, ofs);
+	bus_write_1(res, nsp_datar, va);
 }
 	
 static int
 nsp_expect_signal(struct nsp_softc *sc, u_int8_t curphase, u_int8_t mask)
 {
 	struct scsi_low_softc *slp = &sc->sc_sclow;
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	int wc;
 	u_int8_t ph, isrc;
 
 	for (wc = 0; wc < NSP_DELAY_MAX / NSP_DELAY_INTERVAL; wc ++)
 	{
-		ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
+		ph = nsp_cr_read_1(sc->port_res, NSPR_SCBUSMON);
 		if (ph == (u_int8_t) -1)
 			return -1;
 
-		isrc = bus_space_read_1(bst, bsh, nsp_irqsr);
+		isrc = bus_read_1(sc->port_res, nsp_irqsr);
 		if (isrc & IRQSR_SCSI)
 			return 0;
 
@@ -234,42 +226,40 @@ static void
 nsphw_init(sc)
 	struct nsp_softc *sc;
 {
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 
 	/* block all interrupts */
-	bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_ALLMASK);
+	bus_write_1(sc->port_res, nsp_irqcr, IRQCR_ALLMASK);
 
 	/* setup SCSI interface */
-	bus_space_write_1(bst, bsh, nsp_ifselr, IFSELR_IFSEL);
+	bus_write_1(sc->port_res, nsp_ifselr, IFSELR_IFSEL);
 
-	nsp_cr_write_1(bst, bsh, NSPR_SCIENR, 0);
+	nsp_cr_write_1(sc->port_res, NSPR_SCIENR, 0);
 
-	nsp_cr_write_1(bst, bsh, NSPR_XFERMR, XFERMR_IO8);
-	nsp_cr_write_1(bst, bsh, NSPR_CLKDIVR, sc->sc_iclkdiv);
+	nsp_cr_write_1(sc->port_res, NSPR_XFERMR, XFERMR_IO8);
+	nsp_cr_write_1(sc->port_res, NSPR_CLKDIVR, sc->sc_iclkdiv);
 
-	nsp_cr_write_1(bst, bsh, NSPR_SCIENR, sc->sc_icr);
-	nsp_cr_write_1(bst, bsh, NSPR_PARITYR, sc->sc_parr);
-	nsp_cr_write_1(bst, bsh, NSPR_PTCLRR,
+	nsp_cr_write_1(sc->port_res, NSPR_SCIENR, sc->sc_icr);
+	nsp_cr_write_1(sc->port_res, NSPR_PARITYR, sc->sc_parr);
+	nsp_cr_write_1(sc->port_res, NSPR_PTCLRR,
 		       PTCLRR_ACK | PTCLRR_REQ | PTCLRR_HOST | PTCLRR_RSS);
 
 	/* setup fifo asic */
-	bus_space_write_1(bst, bsh, nsp_ifselr, IFSELR_REGSEL);
-	nsp_cr_write_1(bst, bsh, NSPR_TERMPWRC, 0);
-	if ((nsp_cr_read_1(bst, bsh, NSPR_OCR) & OCR_TERMPWRS) == 0)
-		nsp_cr_write_1(bst, bsh, NSPR_TERMPWRC, TERMPWRC_POWON);
+	bus_write_1(sc->port_res, nsp_ifselr, IFSELR_REGSEL);
+	nsp_cr_write_1(sc->port_res, NSPR_TERMPWRC, 0);
+	if ((nsp_cr_read_1(sc->port_res, NSPR_OCR) & OCR_TERMPWRS) == 0)
+		nsp_cr_write_1(sc->port_res, NSPR_TERMPWRC, TERMPWRC_POWON);
 
-	nsp_cr_write_1(bst, bsh, NSPR_XFERMR, XFERMR_IO8);
-	nsp_cr_write_1(bst, bsh, NSPR_CLKDIVR, sc->sc_clkdiv);
-	nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, 0);
-	nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, 0);
+	nsp_cr_write_1(sc->port_res, NSPR_XFERMR, XFERMR_IO8);
+	nsp_cr_write_1(sc->port_res, NSPR_CLKDIVR, sc->sc_clkdiv);
+	nsp_cr_write_1(sc->port_res, NSPR_TIMERCNT, 0);
+	nsp_cr_write_1(sc->port_res, NSPR_TIMERCNT, 0);
 
-	nsp_cr_write_1(bst, bsh, NSPR_SYNCR, 0);
-	nsp_cr_write_1(bst, bsh, NSPR_ACKWIDTH, 0);
+	nsp_cr_write_1(sc->port_res, NSPR_SYNCR, 0);
+	nsp_cr_write_1(sc->port_res, NSPR_ACKWIDTH, 0);
 
 	/* enable interrupts and ack them */
-	nsp_cr_write_1(bst, bsh, NSPR_SCIENR, sc->sc_icr);
-	bus_space_write_1(bst, bsh, nsp_irqcr, IRQSR_MASK);
+	nsp_cr_write_1(sc->port_res, NSPR_SCIENR, sc->sc_icr);
+	bus_write_1(sc->port_res, nsp_irqcr, IRQSR_MASK);
 
 	nsp_setup_fifo(sc, NSP_FIFO_OFF, SCSI_LOW_READ, 0);
 }
@@ -281,12 +271,10 @@ static void
 nsphw_attention(sc)
 	struct nsp_softc *sc;
 {
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	u_int8_t cr;
 
-	cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR)/*  & ~SCBUSCR_ACK */;
-	nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr | SCBUSCR_ATN);
+	cr = nsp_cr_read_1(sc->port_res, NSPR_SCBUSCR)/*  & ~SCBUSCR_ACK */;
+	nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR, cr | SCBUSCR_ATN);
 	DELAY(10);
 }
 
@@ -294,19 +282,17 @@ static void
 nsphw_bus_reset(sc)
 	struct nsp_softc *sc;
 {
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	int i;
 
-	bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_ALLMASK);
+	bus_write_1(sc->port_res, nsp_irqcr, IRQCR_ALLMASK);
 
-	nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, SCBUSCR_RST);
+	nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR, SCBUSCR_RST);
 	DELAY(100 * 1000);	/* 100ms */
-	nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, 0);
+	nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR, 0);
 	for (i = 0; i < 5; i ++)
-		(void) nsp_cr_read_1(bst, bsh, NSPR_IRQPHS);
+		(void) nsp_cr_read_1(sc->port_res, NSPR_IRQPHS);
 
-	bus_space_write_1(bst, bsh, nsp_irqcr, IRQSR_MASK);
+	bus_write_1(sc->port_res, nsp_irqcr, IRQSR_MASK);
 }
 
 static void
@@ -314,19 +300,17 @@ nsphw_selection_done_and_expect_msgout(sc)
 	struct nsp_softc *sc;
 {
 	struct scsi_low_softc *slp = &sc->sc_sclow;
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 
 	/* clear ack counter */
 	sc->sc_cnt = 0;
-	nsp_cr_write_1(bst, bsh, NSPR_PTCLRR, PTCLRR_PT | PTCLRR_ACK |
+	nsp_cr_write_1(sc->port_res, NSPR_PTCLRR, PTCLRR_PT | PTCLRR_ACK |
 			PTCLRR_REQ | PTCLRR_HOST);
 
 	/* deassert sel and assert atten */
 	sc->sc_seltout = 0;
-	nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, sc->sc_busc);
+	nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR, sc->sc_busc);
 	DELAY(1);
-	nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, 
+	nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR, 
 			sc->sc_busc | SCBUSCR_ADIR | SCBUSCR_ACKEN);
 	SCSI_LOW_ASSERT_ATN(slp);
 }
@@ -337,21 +321,17 @@ nsphw_start_selection(sc, cb)
 	struct slccb *cb;
 {
 	struct scsi_low_softc *slp = &sc->sc_sclow;
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	struct targ_info *ti = cb->ti;
 	register u_int8_t arbs, ph;
-	int s, wc;
+	int wc;
 
 	wc = sc->sc_tmaxcnt = cb->ccb_tcmax * 1000 * 1000;
 	sc->sc_dataout_timeout = 0;
 
 	/* check bus free */
-	s = splhigh();
-	ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
+	ph = nsp_cr_read_1(sc->port_res, NSPR_SCBUSMON);
 	if (ph != SCBUSMON_FREE)
 	{
-		splx(s);
 #ifdef	NSP_STATICS
 		nsp_statics.arbit_conflict_1 ++;
 #endif	/* NSP_STATICS */
@@ -359,21 +339,20 @@ nsphw_start_selection(sc, cb)
 	}
 
 	/* start arbitration */
-	nsp_cr_write_1(bst, bsh, NSPR_ARBITS, ARBITS_EXEC);
-	splx(s);
+	nsp_cr_write_1(sc->port_res, NSPR_ARBITS, ARBITS_EXEC);
 
 	SCSI_LOW_SETUP_PHASE(ti, PH_ARBSTART);
 	do 
 	{
 		/* XXX: what a stupid chip! */
-		arbs = nsp_cr_read_1(bst, bsh, NSPR_ARBITS);
+		arbs = nsp_cr_read_1(sc->port_res, NSPR_ARBITS);
 		DELAY(1);
 	} 
 	while ((arbs & (ARBITS_WIN | ARBITS_FAIL)) == 0 && wc -- > 0);
 
 	if ((arbs & ARBITS_WIN) == 0)
 	{
-		nsp_cr_write_1(bst, bsh, NSPR_ARBITS, ARBITS_CLR);
+		nsp_cr_write_1(sc->port_res, NSPR_ARBITS, ARBITS_CLR);
 #ifdef	NSP_STATICS
 		nsp_statics.arbit_conflict_2 ++;
 #endif	/* NSP_STATICS */
@@ -384,18 +363,17 @@ nsphw_start_selection(sc, cb)
 	SCSI_LOW_SETUP_PHASE(ti, PH_SELSTART);
 	scsi_low_arbit_win(slp);
 
-	s = splhigh();
 	DELAY(3);
-	nsp_cr_write_1(bst, bsh, NSPR_DATA,
+	nsp_cr_write_1(sc->port_res, NSPR_DATA,
 		       sc->sc_idbit | (1 << ti->ti_id));
-	nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR,
+	nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR,
 			SCBUSCR_SEL | SCBUSCR_BSY | sc->sc_busc);
 	DELAY(3);
-	nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, SCBUSCR_SEL |
+	nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR, SCBUSCR_SEL |
 			SCBUSCR_BSY | SCBUSCR_DOUT | sc->sc_busc);
-	nsp_cr_write_1(bst, bsh, NSPR_ARBITS, ARBITS_CLR);
+	nsp_cr_write_1(sc->port_res, NSPR_ARBITS, ARBITS_CLR);
 	DELAY(3);
-	nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR,
+	nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR,
 		       SCBUSCR_SEL | SCBUSCR_DOUT | sc->sc_busc);
 	DELAY(1);
 
@@ -408,7 +386,7 @@ nsphw_start_selection(sc, cb)
 		for (wc = 0; wc < NSP_FIRST_SEL_WAIT / NSP_SEL_CHECK_INTERVAL;
 		     wc ++)
 		{
-			ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
+			ph = nsp_cr_read_1(sc->port_res, NSPR_SCBUSMON);
 			if ((ph & SCBUSMON_BSY) == 0)
 			{
 				DELAY(NSP_SEL_CHECK_INTERVAL);
@@ -416,18 +394,16 @@ nsphw_start_selection(sc, cb)
 			}
 
 			DELAY(1);
-			ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
+			ph = nsp_cr_read_1(sc->port_res, NSPR_SCBUSMON);
 			if ((ph & SCBUSMON_BSY) != 0)
 			{
 				nsphw_selection_done_and_expect_msgout(sc);
-				splx(s);
 
 				SCSI_LOW_SETUP_PHASE(ti, PH_SELECTED);
 				return SCSI_LOW_START_OK;
 			}
 		}
 	}
-	splx(s);
 
 	/* check a selection timeout */
 	nsp_start_timer(sc, NSP_TIMER_1MS);
@@ -491,8 +467,6 @@ nsp_msg(sc, ti, msg)
 	struct targ_info *ti;
 	u_int msg;
 {
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	struct ncp_synch_data *sdp;
 	struct nsp_targ_info *nti = (void *) ti;
 	u_int period, offset;
@@ -544,8 +518,8 @@ nsp_msg(sc, ti, msg)
 		error = 0;
 	}
 
-	nsp_cr_write_1(bst, bsh, NSPR_SYNCR, nti->nti_reg_syncr);
-	nsp_cr_write_1(bst, bsh, NSPR_ACKWIDTH, nti->nti_reg_ackwidth);
+	nsp_cr_write_1(sc->port_res, NSPR_SYNCR, nti->nti_reg_syncr);
+	nsp_cr_write_1(sc->port_res, NSPR_ACKWIDTH, nti->nti_reg_ackwidth);
 	return error;
 }
 
@@ -573,25 +547,20 @@ nsp_start_timer(sc, time)
 	struct nsp_softc *sc;
 	int time;
 {
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 
 	sc->sc_timer = time;
-	nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, time);
+	nsp_cr_write_1(sc->port_res, NSPR_TIMERCNT, time);
 }
 
 /**************************************************************
  * General probe attach
  **************************************************************/
 int
-nspprobesubr(iot, ioh, dvcfg)
-	bus_space_tag_t iot;
-	bus_space_handle_t ioh;
-	u_int dvcfg;
+nspprobesubr(struct resource *res, u_int dvcfg)
 {
 	u_int8_t regv;
 
-	regv = bus_space_read_1(iot, ioh, nsp_fifosr);
+	regv = bus_read_1(res, nsp_fifosr);
 	if (regv < 0x11 || regv >= 0x20)
 		return 0;
 	return 1;
@@ -603,8 +572,6 @@ nspattachsubr(sc)
 {
 	struct scsi_low_softc *slp = &sc->sc_sclow;
 
-	printf("\n");
-
 	sc->sc_idbit = (1 << slp->sl_hostid);
 	slp->sl_flags |= HW_READ_PADDING;
 	slp->sl_funcs = &nspfuncs;
@@ -621,14 +588,12 @@ static u_int
 nsp_fifo_count(sc)
 	struct nsp_softc *sc;
 {
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	u_int count;
 
-	nsp_cr_write_1(bst, bsh, NSPR_PTCLRR, PTCLRR_RSS_ACK | PTCLRR_PT);
-	count = bus_space_read_1(bst, bsh, nsp_datar);
-	count += (((u_int) bus_space_read_1(bst, bsh, nsp_datar)) << 8);
-	count += (((u_int) bus_space_read_1(bst, bsh, nsp_datar)) << 16);
+	nsp_cr_write_1(sc->port_res, NSPR_PTCLRR, PTCLRR_RSS_ACK | PTCLRR_PT);
+	count = bus_read_1(sc->port_res, nsp_datar);
+	count += (((u_int) bus_read_1(sc->port_res, nsp_datar)) << 8);
+	count += (((u_int) bus_read_1(sc->port_res, nsp_datar)) << 16);
 	return count;
 }
 
@@ -636,14 +601,12 @@ static u_int
 nsp_request_count(sc)
 	struct nsp_softc *sc;
 {
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	u_int count;
 
-	nsp_cr_write_1(bst, bsh, NSPR_PTCLRR, PTCLRR_RSS_REQ | PTCLRR_PT);
-	count = bus_space_read_1(bst, bsh, nsp_datar);
-	count += (((u_int) bus_space_read_1(bst, bsh, nsp_datar)) << 8);
-	count += (((u_int) bus_space_read_1(bst, bsh, nsp_datar)) << 16);
+	nsp_cr_write_1(sc->port_res, NSPR_PTCLRR, PTCLRR_RSS_REQ | PTCLRR_PT);
+	count = bus_read_1(sc->port_res, nsp_datar);
+	count += (((u_int) bus_read_1(sc->port_res, nsp_datar)) << 8);
+	count += (((u_int) bus_read_1(sc->port_res, nsp_datar)) << 16);
 	return count;
 }
 
@@ -683,7 +646,7 @@ nsp_setup_fifo(sc, on, direction, datalen)
 	/* determine a transfer type */
 	if (datalen < DEV_BSIZE || (datalen & 3) != 0)
 	{
-		if (sc->sc_memh != 0 &&
+		if (sc->mem_res != NULL &&
 		    (nsp_io_control & NSP_USE_MEMIO) != 0)
 			xfermode = XFERMR_XEN | XFERMR_MEM8;
 		else
@@ -691,7 +654,7 @@ nsp_setup_fifo(sc, on, direction, datalen)
 	}
 	else
 	{
-		if (sc->sc_memh != 0 &&
+		if (sc->mem_res != NULL &&
 		    (nsp_io_control & NSP_USE_MEMIO) != 0)
 			xfermode = XFERMR_XEN | XFERMR_MEM32;
 		else
@@ -703,7 +666,7 @@ nsp_setup_fifo(sc, on, direction, datalen)
 
 out:
 	sc->sc_xfermr = xfermode;
-	nsp_cr_write_1(sc->sc_iot, sc->sc_ioh, NSPR_XFERMR, sc->sc_xfermr);
+	nsp_cr_write_1(sc->port_res, NSPR_XFERMR, sc->sc_xfermr);
 }
 
 static void
@@ -721,7 +684,7 @@ nsp_pdma_end(sc, ti)
 	if ((sc->sc_icr & SCIENR_FIFO) != 0)
 	{
 		sc->sc_icr &= ~SCIENR_FIFO;
-		nsp_cr_write_1(sc->sc_iot, sc->sc_ioh, NSPR_SCIENR, sc->sc_icr);
+		nsp_cr_write_1(sc->port_res, NSPR_SCIENR, sc->sc_icr);
 	}
 
 	if (cb == NULL)
@@ -783,24 +746,22 @@ nsp_data_padding(sc, direction, count)
 	int direction;
 	u_int count;
 {
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 
 	if (count > NSP_MAX_DATA_SIZE)
 		count = NSP_MAX_DATA_SIZE;
 
-	nsp_cr_write_1(bst, bsh, NSPR_XFERMR, XFERMR_XEN | XFERMR_IO8);
+	nsp_cr_write_1(sc->port_res, NSPR_XFERMR, XFERMR_XEN | XFERMR_IO8);
 	if (direction == SCSI_LOW_READ)
 	{
 		while (count -- > 0)
-			(void) bus_space_read_1(bst, bsh, nsp_fifodr);
+			(void) bus_read_1(sc->port_res, nsp_fifodr);
 	}
 	else
 	{
 		while (count -- > 0)
-			(void) bus_space_write_1(bst, bsh, nsp_fifodr, 0);
+			(void) bus_write_1(sc->port_res, nsp_fifodr, 0);
 	}
-	nsp_cr_write_1(bst, bsh, NSPR_XFERMR, sc->sc_xfermr);
+	nsp_cr_write_1(sc->port_res, NSPR_XFERMR, sc->sc_xfermr);
 }
 
 static int
@@ -809,8 +770,6 @@ nsp_read_fifo(sc, suspendio)
 	int suspendio;
 {
 	struct scsi_low_softc *slp = &sc->sc_sclow;
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	u_int res;
 
 	res = nsp_fifo_count(sc);
@@ -857,12 +816,12 @@ nsp_read_fifo(sc, suspendio)
 		if ((sc->sc_xfermr & XFERMR_MEM32) != 0)
 		{
 			res &= ~3;
-			bus_space_read_region_4(sc->sc_memt, sc->sc_memh, 0, 
+			bus_read_region_4(sc->mem_res, 0, 
 				(u_int32_t *) slp->sl_scp.scp_data, res >> 2);
 		}
 		else
 		{
-			bus_space_read_region_1(sc->sc_memt, sc->sc_memh, 0, 
+			bus_read_region_1(sc->mem_res, 0, 
 				(u_int8_t *) slp->sl_scp.scp_data, res);
 		}
 	}
@@ -871,19 +830,19 @@ nsp_read_fifo(sc, suspendio)
 		if ((sc->sc_xfermr & XFERMR_IO32) != 0)
 		{
 			res &= ~3;
-			bus_space_read_multi_4(bst, bsh, nsp_fifodr,
+			bus_read_multi_4(sc->port_res, nsp_fifodr,
 				(u_int32_t *) slp->sl_scp.scp_data, res >> 2);
 		}
 		else 
 		{
-			bus_space_read_multi_1(bst, bsh, nsp_fifodr,
+			bus_read_multi_1(sc->port_res, nsp_fifodr,
 				(u_int8_t *) slp->sl_scp.scp_data, res);
 		}
 	}
 
-	if (nsp_cr_read_1(bst, bsh, NSPR_PARITYR) & PARITYR_PE)
+	if (nsp_cr_read_1(sc->port_res, NSPR_PARITYR) & PARITYR_PE)
 	{
-		nsp_cr_write_1(bst, bsh, NSPR_PARITYR, 
+		nsp_cr_write_1(sc->port_res, NSPR_PARITYR, 
 			       PARITYR_ENABLE | PARITYR_CLEAR);
 		scsi_low_assert_msg(slp, slp->sl_Tnexus, SCSI_LOW_MSG_ERROR, 1);
 	}
@@ -900,8 +859,6 @@ nsp_write_fifo(sc, suspendio)
 	int suspendio;
 {
 	struct scsi_low_softc *slp = &sc->sc_sclow;
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	u_int res;
 	register u_int8_t stat;
 
@@ -930,7 +887,7 @@ nsp_write_fifo(sc, suspendio)
 		res = slp->sl_scp.scp_datalen;
 
 	/* XXX: reconfirm! */
-	stat = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON) & SCBUSMON_PHMASK;
+	stat = nsp_cr_read_1(sc->port_res, NSPR_SCBUSMON) & SCBUSMON_PHMASK;
 	if (stat != PHASE_DATAOUT)
 		return 0;
 
@@ -938,12 +895,12 @@ nsp_write_fifo(sc, suspendio)
 	{
 		if ((sc->sc_xfermr & XFERMR_MEM32) != 0)
 		{
-			bus_space_write_region_4(sc->sc_memt, sc->sc_memh, 0,
+			bus_write_region_4(sc->mem_res, 0,
 				(u_int32_t *) slp->sl_scp.scp_data, res >> 2);
 		}
 		else
 		{
-			bus_space_write_region_1(sc->sc_memt, sc->sc_memh, 0,
+			bus_write_region_1(sc->mem_res, 0,
 				(u_int8_t *) slp->sl_scp.scp_data, res);
 		}
 	}
@@ -951,12 +908,12 @@ nsp_write_fifo(sc, suspendio)
 	{
 		if ((sc->sc_xfermr & XFERMR_IO32) != 0)
 		{
-			bus_space_write_multi_4(bst, bsh, nsp_fifodr,
+			bus_write_multi_4(sc->port_res, nsp_fifodr,
 				(u_int32_t *) slp->sl_scp.scp_data, res >> 2);
 		}
 		else
 		{
-			bus_space_write_multi_1(bst, bsh, nsp_fifodr,
+			bus_write_multi_1(sc->port_res, nsp_fifodr,
 				(u_int8_t *) slp->sl_scp.scp_data, res);
 		}
 	}
@@ -971,19 +928,17 @@ static int
 nsp_wait_interrupt(sc)
 	struct nsp_softc *sc;
 {
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	int tout;
 	register u_int8_t isrc;
 
 	for (tout = 0; tout < DEV_BSIZE / 10; tout ++)
 	{
-		isrc = bus_space_read_1(bst, bsh, nsp_irqsr);
+		isrc = bus_read_1(sc->port_res, nsp_irqsr);
 		if ((isrc & (IRQSR_SCSI | IRQSR_FIFO)) != 0)
 		{
 			if ((isrc & IRQSR_FIFO) != 0)
 			{
-				bus_space_write_1(bst, bsh,
+				bus_write_1(sc->port_res,
 					nsp_irqcr, IRQCR_FIFOCL);
 			}
 			return 1;
@@ -999,8 +954,6 @@ nsp_pio_read(sc, suspendio)
 	int suspendio;
 {
 	struct scsi_low_softc *slp = &sc->sc_sclow;
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	int tout, padding, datalen;
 	register u_int8_t stat, fstat;
 
@@ -1012,7 +965,7 @@ nsp_pio_read(sc, suspendio)
 ReadLoop:
 	while (1)
 	{
-		stat = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
+		stat = nsp_cr_read_1(sc->port_res, NSPR_SCBUSMON);
 		if (stat == (u_int8_t) -1)
 			return;
 
@@ -1024,12 +977,12 @@ ReadLoop:
 		}
 
 		/* data phase */
-		fstat = bus_space_read_1(bst, bsh, nsp_fifosr);
+		fstat = bus_read_1(sc->port_res, nsp_fifosr);
 		if ((fstat & FIFOSR_FULLEMP) != 0)
 		{
 			if ((sc->sc_icr & SCIENR_FIFO) != 0)
 			{
-				bus_space_write_1(bst, bsh, nsp_irqcr, 
+				bus_write_1(sc->port_res, nsp_irqcr, 
 						  IRQCR_FIFOCL);
 			}
 
@@ -1078,8 +1031,6 @@ nsp_pio_write(sc, suspendio)
 	int suspendio;
 {
 	struct scsi_low_softc *slp = &sc->sc_sclow;
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	u_int rcount, acount;
 	int tout, datalen;
 	register u_int8_t stat, fstat;
@@ -1091,7 +1042,7 @@ nsp_pio_write(sc, suspendio)
 WriteLoop:
 	while (1)
 	{
-		stat = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON) & SCBUSMON_PHMASK;
+		stat = nsp_cr_read_1(sc->port_res, NSPR_SCBUSMON) & SCBUSMON_PHMASK;
 		if (stat != PHASE_DATAOUT)
 			return;
 
@@ -1102,12 +1053,12 @@ WriteLoop:
 			return;
 		}
 
-		fstat = bus_space_read_1(bst, bsh, nsp_fifosr);
+		fstat = bus_read_1(sc->port_res, nsp_fifosr);
 		if ((fstat & FIFOSR_FULLEMP) != 0)
 		{
 			if ((sc->sc_icr & SCIENR_FIFO) != 0)
 			{
-				bus_space_write_1(bst, bsh, nsp_irqcr,
+				bus_write_1(sc->port_res, nsp_irqcr,
 						  IRQCR_FIFOCL);
 			}
 
@@ -1187,14 +1138,12 @@ static int
 nsp_negate_signal(struct nsp_softc *sc, u_int8_t mask, u_char *s)
 {
 	struct scsi_low_softc *slp = &sc->sc_sclow;
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	int wc;
 	u_int8_t regv;
 
 	for (wc = 0; wc < NSP_DELAY_MAX / NSP_DELAY_INTERVAL; wc ++)
 	{
-		regv = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
+		regv = nsp_cr_read_1(sc->port_res, NSPR_SCBUSMON);
 		if (regv == (u_int8_t) -1)
 			return -1;
 		if ((regv & mask) == 0)
@@ -1214,8 +1163,6 @@ nsp_xfer(sc, buf, len, phase, clear_atn)
 	int phase;
 	int clear_atn;
 {
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	int ptr, rv;
 
 	for (ptr = 0; len > 0; len --, ptr ++)
@@ -1226,18 +1173,18 @@ nsp_xfer(sc, buf, len, phase, clear_atn)
 
 		if (len == 1 && clear_atn != 0)
 		{
-			nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR,
+			nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR,
 				       SCBUSCR_ADIR | SCBUSCR_ACKEN);
 			SCSI_LOW_DEASSERT_ATN(&sc->sc_sclow);
 		}
 
 		if (phase & SCBUSMON_IO)
 		{
-			buf[ptr] = nsp_cr_read_1(bst, bsh, NSPR_DATAACK);
+			buf[ptr] = nsp_cr_read_1(sc->port_res, NSPR_DATAACK);
 		}
 		else
 		{
-			nsp_cr_write_1(bst, bsh, NSPR_DATAACK, buf[ptr]);
+			nsp_cr_write_1(sc->port_res, NSPR_DATAACK, buf[ptr]);
 		}
 		nsp_negate_signal(sc, SCBUSMON_ACK, "xfer<ACK>");
 	}
@@ -1254,13 +1201,11 @@ nsp_reselected(sc)
 	struct nsp_softc *sc;
 {
 	struct scsi_low_softc *slp = &sc->sc_sclow;
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	struct targ_info *ti;
 	u_int sid;
 	u_int8_t cr;
 
-	sid = (u_int) nsp_cr_read_1(bst, bsh, NSPR_RESELR);
+	sid = (u_int) nsp_cr_read_1(sc->port_res, NSPR_RESELR);
 	sid &= ~sc->sc_idbit;
 	sid = ffs(sid) - 1;
 	if ((ti = scsi_low_reselected(slp, sid)) == NULL)
@@ -1268,11 +1213,11 @@ nsp_reselected(sc)
 
 	nsp_negate_signal(sc, SCBUSMON_SEL, "reselect<SEL>");
 
-	cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR);
+	cr = nsp_cr_read_1(sc->port_res, NSPR_SCBUSCR);
 	cr &= ~(SCBUSCR_BSY | SCBUSCR_ATN);
-	nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr);
+	nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR, cr);
 	cr |= SCBUSCR_ADIR | SCBUSCR_ACKEN;
-	nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr);
+	nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR, cr);
 
 #ifdef	NSP_STATICS
 	nsp_statics.reselect ++;
@@ -1286,15 +1231,13 @@ nsp_disconnected(sc, ti)
 	struct targ_info *ti;
 {
 	struct scsi_low_softc *slp = &sc->sc_sclow;
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 
-	nsp_cr_write_1(bst, bsh, NSPR_PTCLRR, PTCLRR_PT | PTCLRR_ACK |
+	nsp_cr_write_1(sc->port_res, NSPR_PTCLRR, PTCLRR_PT | PTCLRR_ACK |
 			PTCLRR_REQ | PTCLRR_HOST);
 	if ((sc->sc_icr & SCIENR_FIFO) != 0)
 	{
 		sc->sc_icr &= ~SCIENR_FIFO;
-		nsp_cr_write_1(bst, bsh, NSPR_SCIENR, sc->sc_icr);
+		nsp_cr_write_1(sc->port_res, NSPR_SCIENR, sc->sc_icr);
 	}
 	sc->sc_cnt = 0;
 	sc->sc_dataout_timeout = 0;
@@ -1326,14 +1269,12 @@ nsp_target_nexus_establish(sc)
 	struct nsp_softc *sc;
 {
 	struct scsi_low_softc *slp = &sc->sc_sclow;
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	struct targ_info *ti = slp->sl_Tnexus;
 	struct nsp_targ_info *nti = (void *) ti;
 
 	/* setup synch transfer registers */
-	nsp_cr_write_1(bst, bsh, NSPR_SYNCR, nti->nti_reg_syncr);
-	nsp_cr_write_1(bst, bsh, NSPR_ACKWIDTH, nti->nti_reg_ackwidth);
+	nsp_cr_write_1(sc->port_res, NSPR_SYNCR, nti->nti_reg_syncr);
+	nsp_cr_write_1(sc->port_res, NSPR_ACKWIDTH, nti->nti_reg_ackwidth);
 
 	/* setup pdma fifo (minimum) */
 	nsp_setup_fifo(sc, NSP_FIFO_ON, SCSI_LOW_READ, 0);
@@ -1367,7 +1308,7 @@ nsp_ccb_nexus_establish(sc)
 		    (nsp_io_control & NSP_READ_FIFO_INTERRUPTS) != 0)
 		{
 			sc->sc_icr |= SCIENR_FIFO;
-			nsp_cr_write_1(sc->sc_iot, sc->sc_ioh,
+			nsp_cr_write_1(sc->port_res,
 				       NSPR_SCIENR, sc->sc_icr);
 		}
 	}
@@ -1377,7 +1318,7 @@ nsp_ccb_nexus_establish(sc)
 		    (nsp_io_control & NSP_WRITE_FIFO_INTERRUPTS) != 0)
 		{
 			sc->sc_icr |= SCIENR_FIFO;
-			nsp_cr_write_1(sc->sc_iot, sc->sc_ioh,
+			nsp_cr_write_1(sc->port_res,
 				       NSPR_SCIENR, sc->sc_icr);
 		}
 	}
@@ -1408,8 +1349,6 @@ nspintr(arg)
 {
 	struct nsp_softc *sc = arg;
 	struct scsi_low_softc *slp = &sc->sc_sclow;
-	bus_space_tag_t bst = sc->sc_iot;
-	bus_space_handle_t bsh = sc->sc_ioh;
 	struct targ_info *ti;
 	struct buf *bp;
 	u_int derror, flags;
@@ -1422,11 +1361,11 @@ nspintr(arg)
 	if (slp->sl_flags & HW_INACTIVE)
 		return 0;
 
-	bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_IRQDIS);
-	isrc = bus_space_read_1(bst, bsh, nsp_irqsr);
+	bus_write_1(sc->port_res, nsp_irqcr, IRQCR_IRQDIS);
+	isrc = bus_read_1(sc->port_res, nsp_irqsr);
 	if (isrc == (u_int8_t) -1 || (isrc & IRQSR_MASK) == 0)
 	{
-		bus_space_write_1(bst, bsh, nsp_irqcr, 0);
+		bus_write_1(sc->port_res, nsp_irqcr, 0);
 		return 0;
 	}
 
@@ -1434,10 +1373,10 @@ nspintr(arg)
  	 * Do not read an irqphs register if no scsi phase interrupt.
 	 * Unless, you should lose a scsi phase interrupt.
 	 */
-	ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON);
+	ph = nsp_cr_read_1(sc->port_res, NSPR_SCBUSMON);
 	if ((isrc & IRQSR_SCSI) != 0)
 	{
-		irqphs = nsp_cr_read_1(bst, bsh, NSPR_IRQPHS);
+		irqphs = nsp_cr_read_1(sc->port_res, NSPR_IRQPHS);
 	}
 	else
 		irqphs = 0;
@@ -1447,8 +1386,8 @@ nspintr(arg)
 	 */
 	if (sc->sc_timer != 0)
 	{
-		nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, 0);
-		nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, 0);
+		nsp_cr_write_1(sc->port_res, NSPR_TIMERCNT, 0);
+		nsp_cr_write_1(sc->port_res, NSPR_TIMERCNT, 0);
 		sc->sc_timer = 0;
 	}
 	
@@ -1458,7 +1397,7 @@ nspintr(arg)
 	{
 		if ((isrc & IRQSR_MASK) == IRQSR_TIMER && sc->sc_seltout == 0)
 		{
-			bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_TIMERCL);
+			bus_write_1(sc->port_res, nsp_irqcr, IRQCR_TIMERCL);
 			return 1;
 		}
 		regv |= IRQCR_TIMERCL;
@@ -1471,7 +1410,7 @@ nspintr(arg)
 	}
 
 	/* OK. enable all interrupts */
-	bus_space_write_1(bst, bsh, nsp_irqcr, regv);
+	bus_write_1(sc->port_res, nsp_irqcr, regv);
 
 	/*******************************************
 	 * debug section
@@ -1502,7 +1441,7 @@ nspintr(arg)
 
 		if ((irqphs & IRQPHS_RSEL) != 0)
 		{
-			bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_RESCL);
+			bus_write_1(sc->port_res, nsp_irqcr, IRQCR_RESCL);
 			if (nsp_reselected(sc) == EJUSTRETURN)
 				return 1;
 		}
@@ -1532,7 +1471,7 @@ nspintr(arg)
 			if (sc->sc_seltout >= NSP_SELTIMEOUT)
 			{
 				sc->sc_seltout = 0;
-				nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, 0);
+				nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR, 0);
 				return nsp_disconnected(sc, ti);
 			}
 			sc->sc_seltout ++;
@@ -1624,12 +1563,12 @@ nspintr(arg)
 			scsi_low_attention(slp);
 		}
 
-		nsp_cr_write_1(bst, bsh, NSPR_CMDCR, CMDCR_PTCLR);
+		nsp_cr_write_1(sc->port_res, NSPR_CMDCR, CMDCR_PTCLR);
 		for (len = 0; len < slp->sl_scp.scp_cmdlen; len ++)
-			nsp_cr_write_1(bst, bsh, NSPR_CMDDR,
+			nsp_cr_write_1(sc->port_res, NSPR_CMDDR,
 				       slp->sl_scp.scp_cmd[len]);
 
-		nsp_cr_write_1(bst, bsh, NSPR_CMDCR, CMDCR_PTCLR | CMDCR_EXEC);
+		nsp_cr_write_1(sc->port_res, NSPR_CMDCR, CMDCR_PTCLR | CMDCR_EXEC);
 		break;
 
 	case IRQPHS_DATAOUT:
@@ -1657,10 +1596,10 @@ nspintr(arg)
 			return 1;
 
 		SCSI_LOW_SETUP_PHASE(ti, PH_STAT);
-		regv = nsp_cr_read_1(bst, bsh, NSPR_DATA);
-		if (nsp_cr_read_1(bst, bsh, NSPR_PARITYR) & PARITYR_PE)
+		regv = nsp_cr_read_1(sc->port_res, NSPR_DATA);
+		if (nsp_cr_read_1(sc->port_res, NSPR_PARITYR) & PARITYR_PE)
 		{
-			nsp_cr_write_1(bst, bsh, NSPR_PARITYR, 
+			nsp_cr_write_1(sc->port_res, NSPR_PARITYR, 
 				       PARITYR_ENABLE | PARITYR_CLEAR);
 			derror = SCSI_LOW_DATA_PE;
 		}
@@ -1668,8 +1607,8 @@ nspintr(arg)
 			derror = 0;
 
 		/* assert ACK */
-		cr = SCBUSCR_ACK | nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR);
-		nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr);
+		cr = SCBUSCR_ACK | nsp_cr_read_1(sc->port_res, NSPR_SCBUSCR);
+		nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR, cr);
 
 		if (scsi_low_statusin(slp, ti, derror | regv) != 0)
 		{
@@ -1680,8 +1619,8 @@ nspintr(arg)
 		nsp_negate_signal(sc, SCBUSMON_REQ, "statin<REQ>");
 
 		/* deassert ACK */
-		cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR) & (~SCBUSCR_ACK);
-		nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr);
+		cr = nsp_cr_read_1(sc->port_res, NSPR_SCBUSCR) & (~SCBUSCR_ACK);
+		nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR, cr);
 		break;
 
 	case IRQPHS_MSGOUT:
@@ -1756,10 +1695,10 @@ nspintr(arg)
 			SCSI_LOW_SETUP_PHASE(ti, PH_MSGIN);
 
 			/* read a data */
-			regv = nsp_cr_read_1(bst, bsh, NSPR_DATA);
-			if (nsp_cr_read_1(bst, bsh, NSPR_PARITYR) & PARITYR_PE)
+			regv = nsp_cr_read_1(sc->port_res, NSPR_DATA);
+			if (nsp_cr_read_1(sc->port_res, NSPR_PARITYR) & PARITYR_PE)
 			{
-				nsp_cr_write_1(bst, bsh,
+				nsp_cr_write_1(sc->port_res,
 					       NSPR_PARITYR, 
 					       PARITYR_ENABLE | PARITYR_CLEAR);
 				derror = SCSI_LOW_DATA_PE;
@@ -1770,8 +1709,8 @@ nspintr(arg)
 			}
 
 			/* assert ack */
-			cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR) | SCBUSCR_ACK;
-			nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr);
+			cr = nsp_cr_read_1(sc->port_res, NSPR_SCBUSCR) | SCBUSCR_ACK;
+			nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR, cr);
 
 			if (scsi_low_msgin(slp, ti, regv | derror) == 0)
 			{
@@ -1785,8 +1724,8 @@ nspintr(arg)
 			nsp_negate_signal(sc, SCBUSMON_REQ, "msgin<REQ>");
 
 			/* deassert ack */
-			cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR) & (~SCBUSCR_ACK);
-			nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr);
+			cr = nsp_cr_read_1(sc->port_res, NSPR_SCBUSCR) & (~SCBUSCR_ACK);
+			nsp_cr_write_1(sc->port_res, NSPR_SCBUSCR, cr);
 
 			/* catch a next signal */
 			rv = nsp_expect_signal(sc, PHASE_MSGIN, SCBUSMON_REQ);
@@ -1814,15 +1753,13 @@ nsp_timeout(sc)
 	struct nsp_softc *sc;
 {
 	struct scsi_low_softc *slp = &sc->sc_sclow;
-	bus_space_tag_t iot = sc->sc_iot;
-	bus_space_handle_t ioh = sc->sc_ioh;
 	int tout;
 	u_int8_t ph, regv;
 
 	if (slp->sl_Tnexus == NULL)
 		return 0;
 
-	ph = nsp_cr_read_1(iot, ioh, NSPR_SCBUSMON);
+	ph = nsp_cr_read_1(sc->port_res, NSPR_SCBUSMON);
 	switch (ph & SCBUSMON_PHMASK)
 	{
 	case PHASE_DATAOUT:
@@ -1830,13 +1767,13 @@ nsp_timeout(sc)
 			break;
 
 		/* check a fifo empty */
-		regv = bus_space_read_1(iot, ioh, nsp_fifosr);
+		regv = bus_read_1(sc->port_res, nsp_fifosr);
 		if ((regv & FIFOSR_FULLEMP) == 0)
 			break;
-		bus_space_write_1(iot, ioh, nsp_irqcr, IRQCR_FIFOCL);
+		bus_write_1(sc->port_res, nsp_irqcr, IRQCR_FIFOCL);
 
 		/* check still requested */
-		ph = nsp_cr_read_1(iot, ioh, NSPR_SCBUSMON);
+		ph = nsp_cr_read_1(sc->port_res, NSPR_SCBUSMON);
 		if ((ph & SCBUSMON_REQ) == 0)
 			break;
 		/* check timeout */
@@ -1853,20 +1790,20 @@ nsp_timeout(sc)
 		tout = NSP_DELAY_MAX;
 		while (tout -- > 0)
 		{
-			ph = nsp_cr_read_1(iot, ioh, NSPR_SCBUSMON);
+			ph = nsp_cr_read_1(sc->port_res, NSPR_SCBUSMON);
 			if ((ph & SCBUSMON_PHMASK) != PHASE_DATAOUT)
 				break;
-			regv = bus_space_read_1(iot, ioh, nsp_fifosr);
+			regv = bus_read_1(sc->port_res, nsp_fifosr);
 			if ((regv & FIFOSR_FULLEMP) == 0)
 			{
 				DELAY(1);
 				continue;
 			}
 
-			bus_space_write_1(iot, ioh, nsp_irqcr, IRQCR_FIFOCL);
+			bus_write_1(sc->port_res, nsp_irqcr, IRQCR_FIFOCL);
 			nsp_data_padding(sc, SCSI_LOW_WRITE, 32);
 		}
-		ph = nsp_cr_read_1(iot, ioh, NSPR_SCBUSMON);
+		ph = nsp_cr_read_1(sc->port_res, NSPR_SCBUSMON);
 		if ((ph & SCBUSMON_PHMASK) == PHASE_DATAOUT)
 			sc->sc_dataout_timeout = SCSI_LOW_TIMEOUT_HZ;
 		break;
diff --git a/sys/dev/nsp/nsp_pccard.c b/sys/dev/nsp/nsp_pccard.c
index 08ed66f..a235c22 100644
--- a/sys/dev/nsp/nsp_pccard.c
+++ b/sys/dev/nsp/nsp_pccard.c
@@ -84,7 +84,12 @@ const struct pccard_product nsp_products[] = {
 static void
 nsp_pccard_intr(void * arg)
 {
-	nspintr(arg);
+	struct nsp_softc *sc;
+
+	sc = arg;
+	SCSI_LOW_LOCK(&sc->sc_sclow);
+	nspintr(sc);
+	SCSI_LOW_UNLOCK(&sc->sc_sclow);
 }
 
 static void
@@ -103,6 +108,7 @@ nsp_release_resource(device_t dev)
 	if (sc->mem_res)
 		bus_release_resource(dev, SYS_RES_MEMORY,
 				     sc->mem_rid, sc->mem_res);
+	mtx_destroy(&sc->sc_sclow.sl_lock);
 }
 
 static int
@@ -116,6 +122,7 @@ nsp_alloc_resource(device_t dev)
 	if (error || iosize < NSP_IOSIZE)
 		return(ENOMEM);
 
+	mtx_init(&sc->sc_sclow.sl_lock, "nsp", NULL, MTX_DEF);
 	sc->port_rid = 0;
 	sc->port_res = bus_alloc_resource(dev, SYS_RES_IOPORT, &sc->port_rid,
 					  0, ~0, NSP_IOSIZE, RF_ACTIVE);
@@ -167,7 +174,7 @@ nsp_pccard_probe(device_t dev)
 	    sizeof(nsp_products[0]), NULL)) != NULL) {
 		if (pp->pp_name)
 			device_set_desc(dev, pp->pp_name);
-		return(0);
+		return (BUS_PROBE_DEFAULT);
 	}
 	return(EIO);
 }
@@ -185,8 +192,8 @@ nsp_pccard_attach(device_t dev)
 		nsp_release_resource(dev);
 		return(ENXIO);
 	}
-	error = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_CAM | INTR_ENTROPY,
-			       NULL, nsp_pccard_intr, (void *)sc, &sc->nsp_intrhand);
+	error = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_CAM | INTR_ENTROPY |
+	    INTR_MPSAFE, NULL, nsp_pccard_intr, sc, &sc->nsp_intrhand);
 	if (error) {
 		nsp_release_resource(dev);
 		return(error);
@@ -231,12 +238,9 @@ static void
 nsp_card_unload(device_t devi)
 {
 	struct nsp_softc *sc = device_get_softc(devi);
-	intrmask_t s;
 
-	s = splcam();
-	scsi_low_deactivate((struct scsi_low_softc *)sc);
-        scsi_low_dettach(&sc->sc_sclow);
-	splx(s);
+	scsi_low_deactivate(&sc->sc_sclow);
+        scsi_low_detach(&sc->sc_sclow);
 }
 
 static	int
@@ -245,8 +249,7 @@ nspprobe(device_t devi)
 	int rv;
 	struct nsp_softc *sc = device_get_softc(devi);
 
-	rv = nspprobesubr(rman_get_bustag(sc->port_res),
-			  rman_get_bushandle(sc->port_res),
+	rv = nspprobesubr(sc->port_res,
 			  device_get_flags(devi));
 
 	return rv;
@@ -259,36 +262,22 @@ nspattach(device_t devi)
 	struct scsi_low_softc *slp;
 	u_int32_t flags = device_get_flags(devi);
 	u_int	iobase = bus_get_resource_start(devi, SYS_RES_IOPORT, 0);
-	intrmask_t s;
-	char	dvname[16];
-
-	strcpy(dvname,"nsp");
 
 	if (iobase == 0) {
-		printf("%s: no ioaddr is given\n", dvname);
-		return (0);
+		device_printf(devi, "no ioaddr is given\n");
+		return (ENXIO);
 	}
 
 	sc = device_get_softc(devi);
-	if (sc == NULL)
-		return (0);
-
 	slp = &sc->sc_sclow;
 	slp->sl_dev = devi;
-	sc->sc_iot = rman_get_bustag(sc->port_res);
-	sc->sc_ioh = rman_get_bushandle(sc->port_res);
 
 	if (sc->mem_res == NULL) {
-		printf("WARNING: CANNOT GET Memory RESOURCE going PIO mode");
+		device_printf(devi,
+		    "WARNING: CANNOT GET Memory RESOURCE going PIO mode\n");
 		flags |= PIO_MODE;
 	}
 
-	if ((flags & PIO_MODE) == 0) {
-		sc->sc_memt = rman_get_bustag(sc->mem_res);
-		sc->sc_memh = rman_get_bushandle(sc->mem_res);
-	} else {
-		sc->sc_memh = 0;
-	}
 	/* slp->sl_irq = devi->pd_irq; */
 	sc->sc_iclkdiv = CLKDIVR_20M;
 	sc->sc_clkdiv = CLKDIVR_40M;
@@ -296,9 +285,7 @@ nspattach(device_t devi)
 	slp->sl_hostid = NSP_HOSTID;
 	slp->sl_cfgflags = flags;
 
-	s = splcam();
 	nspattachsubr(sc);
-	splx(s);
 
 	return(NSP_IOSIZE);
 }
diff --git a/sys/dev/nsp/nspvar.h b/sys/dev/nsp/nspvar.h
index ec4fd44..ed8a981 100644
--- a/sys/dev/nsp/nspvar.h
+++ b/sys/dev/nsp/nspvar.h
@@ -43,11 +43,6 @@
 struct nsp_softc {
 	struct scsi_low_softc sc_sclow;		/* generic data */
 
-	bus_space_tag_t sc_iot;
-	bus_space_handle_t sc_ioh;
-	bus_space_tag_t sc_memt;
-	bus_space_handle_t sc_memh;
-
 	int port_rid;
 	int irq_rid;
 	int mem_rid;
@@ -89,7 +84,7 @@ struct nsp_targ_info {
 /*****************************************************************
  * Proto
  *****************************************************************/
-int nspprobesubr(bus_space_tag_t, bus_space_handle_t, u_int);
+int nspprobesubr(struct resource *, u_int);
 void nspattachsubr(struct nsp_softc *);
 int nspintr(void *);