Home | History | Annotate | Line # | Download | only in i2o
iop.c revision 1.9
      1 /*	$NetBSD: iop.c,v 1.9 2001/01/03 21:04:01 ad Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2000 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Andrew Doran.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. Redistributions in binary form must reproduce the above copyright
     16  *    notice, this list of conditions and the following disclaimer in the
     17  *    documentation and/or other materials provided with the distribution.
     18  * 3. All advertising materials mentioning features or use of this software
     19  *    must display the following acknowledgement:
     20  *        This product includes software developed by the NetBSD
     21  *        Foundation, Inc. and its contributors.
     22  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23  *    contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36  * POSSIBILITY OF SUCH DAMAGE.
     37  */
     38 
     39 /*
     40  * Support for I2O IOPs (intelligent I/O processors).
     41  */
     42 
     43 #include "opt_i2o.h"
     44 #include "iop.h"
     45 
     46 #include <sys/param.h>
     47 #include <sys/systm.h>
     48 #include <sys/kernel.h>
     49 #include <sys/device.h>
     50 #include <sys/queue.h>
     51 #include <sys/proc.h>
     52 #include <sys/malloc.h>
     53 #include <sys/ioctl.h>
     54 #include <sys/endian.h>
     55 #include <sys/pool.h>
     56 #include <sys/conf.h>
     57 #include <sys/kthread.h>
     58 
     59 #include <uvm/uvm_extern.h>
     60 
     61 #include <machine/bus.h>
     62 
     63 #include <dev/i2o/i2o.h>
     64 #include <dev/i2o/iopreg.h>
     65 #include <dev/i2o/iopvar.h>
     66 
     67 #define POLL(ms, cond)				\
     68 do {						\
     69 	int i;					\
     70 	for (i = (ms) * 10; i; i--) {		\
     71 		if (cond)			\
     72 			break;			\
     73 		DELAY(100);			\
     74 	}					\
     75 } while (/* CONSTCOND */0);
     76 
     77 #ifdef I2ODEBUG
     78 #define DPRINTF(x)	printf x
     79 #else
     80 #define	DPRINTF(x)
     81 #endif
     82 
     83 #ifdef I2OVERBOSE
     84 #define IFVERBOSE(x)	x
     85 #else
     86 #define	IFVERBOSE(x)
     87 #endif
     88 
     89 #define	COMMENT(x)	""
     90 
     91 #define IOP_ICTXHASH_NBUCKETS	16
     92 #define	IOP_ICTXHASH(ictx)	(&iop_ictxhashtbl[(ictx) & iop_ictxhash])
     93 #define IOP_TCTXHASH_NBUCKETS	64
     94 #define	IOP_TCTXHASH(tctx)	(&iop_tctxhashtbl[(tctx) & iop_tctxhash])
     95 
     96 static LIST_HEAD(, iop_initiator) *iop_ictxhashtbl;
     97 static u_long	iop_ictxhash;
     98 static TAILQ_HEAD(, iop_msg) *iop_tctxhashtbl;
     99 static u_long	iop_tctxhash;
    100 static void	*iop_sdh;
    101 static struct	pool *iop_msgpool;
    102 static struct	i2o_systab *iop_systab;
    103 static int	iop_systab_size;
    104 
    105 extern struct cfdriver iop_cd;
    106 
    107 #define	IC_CONFIGURE	0x01
    108 
    109 struct iop_class {
    110 	u_short	ic_class;
    111 	u_short	ic_flags;
    112 	const char	*ic_caption;
    113 } static const iop_class[] = {
    114 	{
    115 		I2O_CLASS_EXECUTIVE,
    116 		0,
    117 		COMMENT("executive")
    118 	},
    119 	{
    120 		I2O_CLASS_DDM,
    121 		0,
    122 		COMMENT("device driver module")
    123 	},
    124 	{
    125 		I2O_CLASS_RANDOM_BLOCK_STORAGE,
    126 		IC_CONFIGURE,
    127 		IFVERBOSE("random block storage")
    128 	},
    129 	{
    130 		I2O_CLASS_SEQUENTIAL_STORAGE,
    131 		IC_CONFIGURE,
    132 		IFVERBOSE("sequential storage")
    133 	},
    134 	{
    135 		I2O_CLASS_LAN,
    136 		IC_CONFIGURE,
    137 		IFVERBOSE("LAN port")
    138 	},
    139 	{
    140 		I2O_CLASS_WAN,
    141 		IC_CONFIGURE,
    142 		IFVERBOSE("WAN port")
    143 	},
    144 	{
    145 		I2O_CLASS_FIBRE_CHANNEL_PORT,
    146 		IC_CONFIGURE,
    147 		IFVERBOSE("fibrechannel port")
    148 	},
    149 	{
    150 		I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL,
    151 		0,
    152 		COMMENT("fibrechannel peripheral")
    153 	},
    154  	{
    155  		I2O_CLASS_SCSI_PERIPHERAL,
    156  		0,
    157  		COMMENT("SCSI peripheral")
    158  	},
    159 	{
    160 		I2O_CLASS_ATE_PORT,
    161 		IC_CONFIGURE,
    162 		IFVERBOSE("ATE port")
    163 	},
    164 	{
    165 		I2O_CLASS_ATE_PERIPHERAL,
    166 		0,
    167 		COMMENT("ATE peripheral")
    168 	},
    169 	{
    170 		I2O_CLASS_FLOPPY_CONTROLLER,
    171 		IC_CONFIGURE,
    172 		IFVERBOSE("floppy controller")
    173 	},
    174 	{
    175 		I2O_CLASS_FLOPPY_DEVICE,
    176 		0,
    177 		COMMENT("floppy device")
    178 	},
    179 	{
    180 		I2O_CLASS_BUS_ADAPTER_PORT,
    181 		IC_CONFIGURE,
    182 		IFVERBOSE("bus adapter port" )
    183 	},
    184 };
    185 
    186 #if defined(I2ODEBUG) && defined(I2OVERBOSE)
    187 static const char *iop_status[] = {
    188 	"success",
    189 	"abort (dirty)",
    190 	"abort (no data transfer)",
    191 	"abort (partial transfer)",
    192 	"error (dirty)",
    193 	"error (no data transfer)",
    194 	"error (partial transfer)",
    195 	"undefined error code",
    196 	"process abort (dirty)",
    197 	"process abort (no data transfer)",
    198 	"process abort (partial transfer)",
    199 	"transaction error",
    200 };
    201 #endif
    202 
    203 static inline u_int32_t	iop_inl(struct iop_softc *, int);
    204 static inline void	iop_outl(struct iop_softc *, int, u_int32_t);
    205 
    206 static void	iop_config_interrupts(struct device *);
    207 static void	iop_configure_devices(struct iop_softc *);
    208 static void	iop_devinfo(int, char *);
    209 static int	iop_print(void *, const char *);
    210 static int	iop_reconfigure(struct iop_softc *, u_int32_t, int);
    211 static void	iop_shutdown(void *);
    212 static int	iop_submatch(struct device *, struct cfdata *, void *);
    213 #ifdef notyet
    214 static int	iop_vendor_print(void *, const char *);
    215 #endif
    216 
    217 static void	iop_create_reconf_thread(void *);
    218 static void	iop_intr_event(struct device *, struct iop_msg *, void *);
    219 static int	iop_hrt_get(struct iop_softc *);
    220 static int	iop_hrt_get0(struct iop_softc *, struct i2o_hrt *, int);
    221 static int	iop_lct_get0(struct iop_softc *, struct i2o_lct *, int,
    222 			     u_int32_t);
    223 static int	iop_msg_wait(struct iop_softc *, struct iop_msg *, int);
    224 static int	iop_ofifo_init(struct iop_softc *);
    225 static int	iop_handle_reply(struct iop_softc *, u_int32_t);
    226 static void	iop_reconf_thread(void *);
    227 static void	iop_release_mfa(struct iop_softc *, u_int32_t);
    228 static int	iop_reset(struct iop_softc *);
    229 static int	iop_status_get(struct iop_softc *);
    230 static int	iop_systab_set(struct iop_softc *);
    231 
    232 #ifdef I2ODEBUG
    233 static void	iop_reply_print(struct iop_softc *, struct iop_msg *,
    234 				struct i2o_reply *);
    235 #endif
    236 
    237 cdev_decl(iop);
    238 
    239 static inline u_int32_t
    240 iop_inl(struct iop_softc *sc, int off)
    241 {
    242 
    243 	bus_space_barrier(sc->sc_iot, sc->sc_ioh, off, 4,
    244 	    BUS_SPACE_BARRIER_WRITE | BUS_SPACE_BARRIER_READ);
    245 	return (bus_space_read_4(sc->sc_iot, sc->sc_ioh, off));
    246 }
    247 
    248 static inline void
    249 iop_outl(struct iop_softc *sc, int off, u_int32_t val)
    250 {
    251 
    252 	bus_space_write_4(sc->sc_iot, sc->sc_ioh, off, val);
    253 	bus_space_barrier(sc->sc_iot, sc->sc_ioh, off, 4,
    254 	    BUS_SPACE_BARRIER_WRITE);
    255 }
    256 
    257 /*
    258  * Initialise the adapter.
    259  */
    260 void
    261 iop_init(struct iop_softc *sc, const char *intrstr)
    262 {
    263 	int rv;
    264 	u_int32_t mask;
    265 	static int again;
    266 	char ident[64];
    267 
    268 	if (again == 0) {
    269 		/* Create the shared message wrapper pool and hashes. */
    270 		iop_msgpool = pool_create(sizeof(struct iop_msg), 0, 0, 0,
    271 		    "ioppl", 0, NULL, NULL, M_DEVBUF);
    272 		iop_ictxhashtbl = hashinit(IOP_ICTXHASH_NBUCKETS, HASH_LIST,
    273 		    M_DEVBUF, M_NOWAIT, &iop_ictxhash);
    274 		iop_tctxhashtbl = hashinit(IOP_TCTXHASH_NBUCKETS, HASH_TAILQ,
    275 		    M_DEVBUF, M_NOWAIT, &iop_tctxhash);
    276 		again = 1;
    277 	}
    278 
    279 	/* Reset the IOP and request status. */
    280 	printf("I2O adapter");
    281 
    282 	if ((rv = iop_reset(sc)) != 0) {
    283 		printf("%s: not responding (reset)\n", sc->sc_dv.dv_xname);
    284 		return;
    285 	}
    286 	if ((rv = iop_status_get(sc)) != 0) {
    287 		printf("%s: not responding (get status)\n", sc->sc_dv.dv_xname);
    288 		return;
    289 	}
    290 	DPRINTF((" (state=%d)",
    291 	    (le32toh(sc->sc_status.segnumber) >> 16) & 0xff));
    292 	sc->sc_flags |= IOP_HAVESTATUS;
    293 
    294 	iop_strvis(sc, sc->sc_status.productid, sizeof(sc->sc_status.productid),
    295 	    ident, sizeof(ident));
    296 	printf(" <%s>\n", ident);
    297 
    298 #ifdef I2ODEBUG
    299 	printf("%s: orgid=0x%04x version=%d\n", sc->sc_dv.dv_xname,
    300 	    le16toh(sc->sc_status.orgid),
    301 	    (le32toh(sc->sc_status.segnumber) >> 12) & 15);
    302 	printf("%s: type want have cbase\n", sc->sc_dv.dv_xname);
    303 	printf("%s: mem  %04x %04x %08x\n", sc->sc_dv.dv_xname,
    304 	    le32toh(sc->sc_status.desiredprivmemsize),
    305 	    le32toh(sc->sc_status.currentprivmemsize),
    306 	    le32toh(sc->sc_status.currentprivmembase));
    307 	printf("%s: i/o  %04x %04x %08x\n", sc->sc_dv.dv_xname,
    308 	    le32toh(sc->sc_status.desiredpriviosize),
    309 	    le32toh(sc->sc_status.currentpriviosize),
    310 	    le32toh(sc->sc_status.currentpriviobase));
    311 #endif
    312 
    313 	sc->sc_maxreplycnt = le32toh(sc->sc_status.maxoutboundmframes);
    314 	if (sc->sc_maxreplycnt > IOP_MAX_HW_REPLYCNT)
    315 		sc->sc_maxreplycnt = IOP_MAX_HW_REPLYCNT;
    316 	sc->sc_maxqueuecnt = le32toh(sc->sc_status.maxinboundmframes);
    317 	if (sc->sc_maxqueuecnt > IOP_MAX_HW_QUEUECNT)
    318 		sc->sc_maxqueuecnt = IOP_MAX_HW_QUEUECNT;
    319 
    320 	if (iop_ofifo_init(sc) != 0) {
    321 		printf("%s: unable to init oubound FIFO\n", sc->sc_dv.dv_xname);
    322 		return;
    323 	}
    324 
    325 	/*
    326  	 * Defer further configuration until (a) interrupts are working and
    327  	 * (b) we have enough information to build the system table.
    328  	 */
    329 	config_interrupts((struct device *)sc, iop_config_interrupts);
    330 
    331 	/* Configure shutdown hook before we start any device activity. */
    332 	if (iop_sdh == NULL)
    333 		iop_sdh = shutdownhook_establish(iop_shutdown, NULL);
    334 
    335 	/* Ensure interrupts are enabled at the IOP. */
    336 	mask = iop_inl(sc, IOP_REG_INTR_MASK);
    337 	iop_outl(sc, IOP_REG_INTR_MASK, mask & ~IOP_INTR_OFIFO);
    338 
    339 	if (intrstr != NULL)
    340 		printf("%s: interrupting at %s\n", sc->sc_dv.dv_xname,
    341 		    intrstr);
    342 
    343 #ifdef I2ODEBUG
    344 	printf("%s: queue depths: inbound %d/%d, outbound %d/%d\n",
    345 	    sc->sc_dv.dv_xname,
    346 	    sc->sc_maxqueuecnt, le32toh(sc->sc_status.maxinboundmframes),
    347 	    sc->sc_maxreplycnt, le32toh(sc->sc_status.maxoutboundmframes));
    348 #endif
    349 
    350 	lockinit(&sc->sc_conflock, PRIBIO, "iopconf", hz * 30, 0);
    351 	SIMPLEQ_INIT(&sc->sc_queue);
    352 }
    353 
    354 /*
    355  * Perform autoconfiguration tasks.
    356  */
    357 static void
    358 iop_config_interrupts(struct device *self)
    359 {
    360 	struct iop_softc *sc, *iop;
    361 	struct i2o_systab_entry *ste;
    362 	int rv, i, niop;
    363 
    364 	sc = (struct iop_softc *)self;
    365 	LIST_INIT(&sc->sc_iilist);
    366 
    367 	printf("%s: configuring...\n", sc->sc_dv.dv_xname);
    368 
    369 	if (iop_hrt_get(sc) != 0) {
    370 		printf("%s: unable to retrieve HRT\n", sc->sc_dv.dv_xname);
    371 		return;
    372 	}
    373 
    374 	/*
    375  	 * Build the system table.
    376  	 */
    377 	if (iop_systab == NULL) {
    378 		for (i = 0, niop = 0; i < iop_cd.cd_ndevs; i++) {
    379 			if ((iop = device_lookup(&iop_cd, i)) == NULL)
    380 				continue;
    381 			if ((iop->sc_flags & IOP_HAVESTATUS) == 0)
    382 				continue;
    383 			if (iop_status_get(iop) != 0) {
    384 				printf("%s: unable to retrieve status\n",
    385 				    sc->sc_dv.dv_xname);
    386 				iop->sc_flags &= ~IOP_HAVESTATUS;
    387 				continue;
    388 			}
    389 			niop++;
    390 		}
    391 		if (niop == 0)
    392 			return;
    393 
    394 		i = sizeof(struct i2o_systab_entry) * (niop - 1) +
    395 		    sizeof(struct i2o_systab);
    396 		iop_systab_size = i;
    397 		iop_systab = malloc(i, M_DEVBUF, M_NOWAIT);
    398 
    399 		memset(iop_systab, 0, i);
    400 		iop_systab->numentries = niop;
    401 		iop_systab->version = I2O_VERSION_11;
    402 
    403 		for (i = 0, ste = iop_systab->entry; i < iop_cd.cd_ndevs; i++) {
    404 			if ((iop = device_lookup(&iop_cd, i)) == NULL)
    405 				continue;
    406 			if ((iop->sc_flags & IOP_HAVESTATUS) == 0)
    407 				continue;
    408 
    409 			ste->orgid = iop->sc_status.orgid;
    410 			ste->iopid = iop->sc_dv.dv_unit + 2;
    411 			ste->segnumber =
    412 			    htole32(le32toh(iop->sc_status.segnumber) & ~4095);
    413 			ste->iopcaps = iop->sc_status.iopcaps;
    414 			ste->inboundmsgframesize =
    415 			    iop->sc_status.inboundmframesize;
    416 			ste->inboundmsgportaddresslow =
    417 			    htole32(iop->sc_memaddr + IOP_REG_IFIFO);
    418 			ste++;
    419 		}
    420 	}
    421 
    422 	if (iop_systab_set(sc) != 0) {
    423 		printf("%s: unable to set system table\n", sc->sc_dv.dv_xname);
    424 		return;
    425 	}
    426 	if (iop_simple_cmd(sc, I2O_TID_IOP, I2O_EXEC_SYS_ENABLE, IOP_ICTX, 1,
    427 	    5000) != 0) {
    428 		printf("%s: unable to enable system\n", sc->sc_dv.dv_xname);
    429 		return;
    430 	}
    431 
    432 	/*
    433 	 * Set up an event handler for this IOP.
    434 	 */
    435 	sc->sc_eventii.ii_dv = self;
    436 	sc->sc_eventii.ii_intr = iop_intr_event;
    437 	sc->sc_eventii.ii_flags = II_DISCARD | II_UTILITY;
    438 	sc->sc_eventii.ii_tid = I2O_TID_IOP;
    439 	if (iop_initiator_register(sc, &sc->sc_eventii) != 0) {
    440 		printf("%s: unable to register initiator", sc->sc_dv.dv_xname);
    441 		return;
    442 	}
    443 	if (iop_util_eventreg(sc, &sc->sc_eventii, 0xffffffff)) {
    444 		printf("%s: unable to register for events", sc->sc_dv.dv_xname);
    445 		return;
    446 	}
    447 
    448 #ifdef notyet
    449 	/* Attempt to match and attach a product-specific extension. */
    450 	ia.ia_class = I2O_CLASS_ANY;
    451 	ia.ia_tid = I2O_TID_IOP;
    452 	config_found_sm(self, &ia, iop_vendor_print, iop_submatch);
    453 #endif
    454 
    455 	if ((rv = iop_reconfigure(sc, 0, 0)) != 0) {
    456 		printf("%s: configure failed (%d)\n", sc->sc_dv.dv_xname, rv);
    457 		return;
    458 	}
    459 
    460 	kthread_create(iop_create_reconf_thread, sc);
    461 }
    462 
    463 /*
    464  * Create the reconfiguration thread.  Called after the standard kernel
    465  * threads have been created.
    466  */
    467 static void
    468 iop_create_reconf_thread(void *cookie)
    469 {
    470 	struct iop_softc *sc;
    471 	int rv;
    472 
    473 	sc = cookie;
    474 
    475 	sc->sc_flags |= IOP_ONLINE;
    476 	rv = kthread_create1(iop_reconf_thread, sc, &sc->sc_reconf_proc,
    477 	    "%s", sc->sc_dv.dv_xname);
    478 	if (rv != 0) {
    479 		printf("%s: unable to create reconfiguration thread (%d)",
    480 		    sc->sc_dv.dv_xname, rv);
    481 		return;
    482 	}
    483 }
    484 
    485 /*
    486  * Reconfiguration thread; listens for LCT change notification, and
    487  * initiates re-configuration if recieved.
    488  */
    489 static void
    490 iop_reconf_thread(void *cookie)
    491 {
    492 	struct iop_softc *sc;
    493 	struct i2o_lct lct;
    494 	u_int32_t chgind;
    495 
    496 	sc = cookie;
    497 
    498 	for (;;) {
    499 		chgind = le32toh(sc->sc_chgindicator) + 1;
    500 
    501 		if (iop_lct_get0(sc, &lct, sizeof(lct), chgind) == 0) {
    502 			DPRINTF(("%s: async reconfiguration (0x%08x)\n",
    503 			    sc->sc_dv.dv_xname, le32toh(lct.changeindicator)));
    504 			iop_reconfigure(sc, lct.changeindicator, LK_NOWAIT);
    505 		}
    506 
    507 		tsleep(iop_reconf_thread, PWAIT, "iopzzz", hz * 5);
    508 	}
    509 }
    510 
    511 /*
    512  * Reconfigure: find new and removed devices.
    513  */
    514 static int
    515 iop_reconfigure(struct iop_softc *sc, u_int32_t chgind, int lkflags)
    516 {
    517 	struct iop_msg *im;
    518 	struct i2o_hba_bus_scan *mb;
    519 	struct i2o_lct_entry *le;
    520 	struct iop_initiator *ii, *nextii;
    521 	int rv, tid, i;
    522 
    523 	lkflags |= LK_EXCLUSIVE | LK_RECURSEFAIL;
    524 	if ((rv = lockmgr(&sc->sc_conflock, lkflags, NULL)) != 0) {
    525 		DPRINTF(("iop_reconfigure: unable to acquire lock\n"));
    526 		return (rv);
    527 	}
    528 
    529 	/*
    530 	 * If the reconfiguration request isn't the result of LCT change
    531 	 * notification, then be more thorough: ask all bus ports to scan
    532 	 * their busses.  Wait up to 5 minutes for each bus port to complete
    533 	 * the request.
    534 	 */
    535 	if (chgind == 0) {
    536 		if ((rv = iop_lct_get(sc)) != 0) {
    537 			DPRINTF(("iop_reconfigure: unable to read LCT\n"));
    538 			goto done;
    539 		}
    540 
    541 		le = sc->sc_lct->entry;
    542 		for (i = 0; i < sc->sc_nlctent; i++, le++) {
    543 			if ((le16toh(le->classid) & 4095) !=
    544 			    I2O_CLASS_BUS_ADAPTER_PORT)
    545 				continue;
    546 			tid = le32toh(le->localtid) & 4095;
    547 
    548 			rv = iop_msg_alloc(sc, NULL, &im, IM_NOINTR);
    549 			if (rv != 0) {
    550 				DPRINTF(("iop_reconfigure: alloc msg\n"));
    551 				goto done;
    552 			}
    553 
    554 			mb = (struct i2o_hba_bus_scan *)im->im_msg;
    555 			mb->msgflags = I2O_MSGFLAGS(i2o_hba_bus_scan);
    556 			mb->msgfunc = I2O_MSGFUNC(tid, I2O_HBA_BUS_SCAN);
    557 			mb->msgictx = IOP_ICTX;
    558 			mb->msgtctx = im->im_tctx;
    559 
    560 			DPRINTF(("%s: scanning bus %d\n", sc->sc_dv.dv_xname,
    561 			    tid));
    562 
    563 			rv = iop_msg_enqueue(sc, im, 5*60*1000);
    564 			iop_msg_free(sc, NULL, im);
    565 			if (rv != 0) {
    566 				DPRINTF(("iop_reconfigure: scan failed\n"));
    567 				goto done;
    568 			}
    569 		}
    570 	} else if (chgind == sc->sc_chgindicator) {
    571 		DPRINTF(("%s: LCT unchanged (async)\n", sc->sc_dv.dv_xname));
    572 		goto done;
    573 	}
    574 
    575 	/* Re-read the LCT and determine if it has changed. */
    576 	if ((rv = iop_lct_get(sc)) != 0) {
    577 		DPRINTF(("iop_reconfigure: unable to re-read LCT\n"));
    578 		goto done;
    579 	}
    580 	DPRINTF(("%s: %d LCT entries\n", sc->sc_dv.dv_xname, sc->sc_nlctent));
    581 
    582 	if (sc->sc_lct->changeindicator == sc->sc_chgindicator) {
    583 		DPRINTF(("%s: LCT unchanged\n", sc->sc_dv.dv_xname));
    584 		/* Nothing to do. */
    585 		rv = 0;
    586 		goto done;
    587 	}
    588 	DPRINTF(("%s: LCT changed\n", sc->sc_dv.dv_xname));
    589 	sc->sc_chgindicator = sc->sc_lct->changeindicator;
    590 
    591 	if (sc->sc_tidmap != NULL)
    592 		free(sc->sc_tidmap, M_DEVBUF);
    593 	sc->sc_tidmap = malloc(sc->sc_nlctent * sizeof(struct iop_tidmap),
    594 	    M_DEVBUF, M_NOWAIT);
    595 
    596 	/* Match and attach child devices. */
    597 	iop_configure_devices(sc);
    598 
    599 	for (ii = LIST_FIRST(&sc->sc_iilist); ii != NULL; ii = nextii) {
    600 		nextii = ii;
    601 		do {
    602 			if ((nextii = LIST_NEXT(nextii, ii_list)) == NULL)
    603 				break;
    604 		} while ((nextii->ii_flags & II_UTILITY) != 0);
    605 		if ((ii->ii_flags & II_UTILITY) != 0)
    606 			continue;
    607 
    608 		/* Detach devices that were configured, but are now gone. */
    609 		for (i = 0; i < sc->sc_nlctent; i++)
    610 			if (ii->ii_tid == sc->sc_tidmap[i].it_tid)
    611 				break;
    612 		if (i == sc->sc_nlctent ||
    613 		    (sc->sc_tidmap[i].it_flags & IT_CONFIGURED) == 0)
    614 			config_detach(ii->ii_dv, DETACH_FORCE);
    615 
    616 		/*
    617 		 * Tell initiators that existed before the re-configuration
    618 		 * to re-configure.
    619 		 */
    620 		if (ii->ii_reconfig == NULL)
    621 			continue;
    622 		if ((rv = (*ii->ii_reconfig)(ii->ii_dv)) != 0)
    623 			printf("%s: %s failed reconfigure (%d)\n",
    624 			    sc->sc_dv.dv_xname, ii->ii_dv->dv_xname, rv);
    625 	}
    626 	rv = 0;
    627 
    628 done:
    629 	lockmgr(&sc->sc_conflock, LK_RELEASE, NULL);
    630 	return (rv);
    631 }
    632 
    633 /*
    634  * Configure I2O devices into the system.
    635  */
    636 static void
    637 iop_configure_devices(struct iop_softc *sc)
    638 {
    639 	struct iop_attach_args ia;
    640 	struct iop_initiator *ii;
    641 	const struct i2o_lct_entry *le;
    642 	struct device *dv;
    643 	int i, j, nent;
    644 
    645 	nent = sc->sc_nlctent;
    646 	for (i = 0, le = sc->sc_lct->entry; i < nent; i++, le++) {
    647 		sc->sc_tidmap[i].it_tid = le32toh(le->localtid) & 4095;
    648 		sc->sc_tidmap[i].it_flags = 0;
    649 		sc->sc_tidmap[i].it_dvname[0] = '\0';
    650 
    651 		/*
    652 		 * Ignore the device if it's in use.
    653 		 */
    654 		if ((le32toh(le->usertid) & 4095) != 4095)
    655 			continue;
    656 
    657 		ia.ia_class = le16toh(le->classid) & 4095;
    658 		ia.ia_tid = sc->sc_tidmap[i].it_tid;
    659 
    660 		/* Ignore uninteresting devices. */
    661 		for (j = 0; j < sizeof(iop_class) / sizeof(iop_class[0]); j++)
    662 			if (iop_class[j].ic_class == ia.ia_class)
    663 				break;
    664 		if (j < sizeof(iop_class) / sizeof(iop_class[0]) &&
    665 		    (iop_class[j].ic_flags & IC_CONFIGURE) == 0)
    666 			continue;
    667 
    668 		/*
    669 		 * Try to configure the device only if it's not already
    670 		 * configured.
    671  		 */
    672  		LIST_FOREACH(ii, &sc->sc_iilist, ii_list) {
    673  			if ((ii->ii_flags & II_UTILITY) != 0)
    674  				continue;
    675  			if (ia.ia_tid == ii->ii_tid) {
    676 				sc->sc_tidmap[i].it_flags |= IT_CONFIGURED;
    677 				strcpy(sc->sc_tidmap[i].it_dvname,
    678 				    ii->ii_dv->dv_xname);
    679 				break;
    680 			}
    681 		}
    682 		if (ii != NULL)
    683 			continue;
    684 
    685 		dv = config_found_sm(&sc->sc_dv, &ia, iop_print, iop_submatch);
    686 		if (dv != NULL) {
    687 			sc->sc_tidmap[i].it_flags |= IT_CONFIGURED;
    688 			strcpy(sc->sc_tidmap[i].it_dvname, dv->dv_xname);
    689 		}
    690 	}
    691 }
    692 
    693 static void
    694 iop_devinfo(int class, char *devinfo)
    695 {
    696 #ifdef I2OVERBOSE
    697 	int i;
    698 
    699 	for (i = 0; i < sizeof(iop_class) / sizeof(iop_class[0]); i++)
    700 		if (class == iop_class[i].ic_class)
    701 			break;
    702 
    703 	if (i == sizeof(iop_class) / sizeof(iop_class[0]))
    704 		sprintf(devinfo, "device (class 0x%x)", class);
    705 	else
    706 		strcpy(devinfo, iop_class[i].ic_caption);
    707 #else
    708 
    709 	sprintf(devinfo, "device (class 0x%x)", class);
    710 #endif
    711 }
    712 
    713 static int
    714 iop_print(void *aux, const char *pnp)
    715 {
    716 	struct iop_attach_args *ia;
    717 	char devinfo[256];
    718 
    719 	ia = aux;
    720 
    721 	if (pnp != NULL) {
    722 		iop_devinfo(ia->ia_class, devinfo);
    723 		printf("%s at %s", devinfo, pnp);
    724 	}
    725 	printf(" tid %d", ia->ia_tid);
    726 	return (UNCONF);
    727 }
    728 
    729 #ifdef notyet
    730 static int
    731 iop_vendor_print(void *aux, const char *pnp)
    732 {
    733 
    734 	if (pnp != NULL)
    735 		printf("vendor specific extension at %s", pnp);
    736 	return (UNCONF);
    737 }
    738 #endif
    739 
    740 static int
    741 iop_submatch(struct device *parent, struct cfdata *cf, void *aux)
    742 {
    743 	struct iop_attach_args *ia;
    744 
    745 	ia = aux;
    746 
    747 	if (cf->iopcf_tid != IOPCF_TID_DEFAULT && cf->iopcf_tid != ia->ia_tid)
    748 		return (0);
    749 
    750 	return ((*cf->cf_attach->ca_match)(parent, cf, aux));
    751 }
    752 
    753 /*
    754  * Shut down all configured IOPs.
    755  */
    756 static void
    757 iop_shutdown(void *junk)
    758 {
    759 	struct iop_softc *sc;
    760 	int i;
    761 
    762 	printf("shutting down iop devices... ");
    763 
    764 	for (i = 0; i < iop_cd.cd_ndevs; i++) {
    765 		if ((sc = device_lookup(&iop_cd, i)) == NULL)
    766 			continue;
    767 		if ((sc->sc_flags & IOP_ONLINE) == 0)
    768 			continue;
    769 		iop_simple_cmd(sc, I2O_TID_IOP, I2O_EXEC_SYS_QUIESCE, IOP_ICTX,
    770 		    0, 5000);
    771 		iop_simple_cmd(sc, I2O_TID_IOP, I2O_EXEC_IOP_CLEAR, IOP_ICTX,
    772 		    0, 5000);
    773 	}
    774 
    775 	/* Wait.  Some boards could still be flushing, stupidly enough. */
    776 	delay(5000*1000);
    777 	printf(" done\n");
    778 }
    779 
    780 /*
    781  * Retrieve adapter status.
    782  */
    783 static int
    784 iop_status_get(struct iop_softc *sc)
    785 {
    786 	struct iop_msg *im;
    787 	struct i2o_exec_status_get *mb;
    788 	int rv, s;
    789 
    790 	if ((rv = iop_msg_alloc(sc, NULL, &im, IM_NOWAIT | IM_NOICTX)) != 0)
    791 		return (rv);
    792 
    793 	mb = (struct i2o_exec_status_get *)im->im_msg;
    794 	mb->msgflags = I2O_MSGFLAGS(i2o_exec_status_get);
    795 	mb->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_STATUS_GET);
    796 	mb->reserved[0] = 0;
    797 	mb->reserved[1] = 0;
    798 	mb->reserved[2] = 0;
    799 	mb->reserved[3] = 0;
    800 	mb->addrlow = kvtop((caddr_t)&sc->sc_status);	/* XXX */
    801 	mb->addrhigh = 0;
    802 	mb->length = sizeof(sc->sc_status);
    803 
    804 	s = splbio();
    805 	memset(&sc->sc_status, 0, sizeof(sc->sc_status));
    806 
    807 	if ((rv = iop_msg_send(sc, im, 0)) != 0) {
    808 		splx(s);
    809 		iop_msg_free(sc, NULL, im);
    810 		return (rv);
    811 	}
    812 
    813 	/* XXX */
    814 	POLL(2500, *((volatile u_char *)&sc->sc_status.syncbyte) == 0xff);
    815 
    816 	splx(s);
    817 	iop_msg_free(sc, NULL, im);
    818 	return (*((volatile u_char *)&sc->sc_status.syncbyte) != 0xff);
    819 }
    820 
    821 /*
    822  * Initalize and populate the adapter's outbound FIFO.
    823  */
    824 static int
    825 iop_ofifo_init(struct iop_softc *sc)
    826 {
    827 	struct iop_msg *im;
    828 	volatile u_int32_t status;
    829 	bus_addr_t addr;
    830 	bus_dma_segment_t seg;
    831 	struct i2o_exec_outbound_init *mb;
    832 	int i, rseg, rv;
    833 
    834 	if ((rv = iop_msg_alloc(sc, NULL, &im, IM_NOWAIT | IM_NOICTX)) != 0)
    835 		return (rv);
    836 
    837 	mb = (struct i2o_exec_outbound_init *)im->im_msg;
    838 	mb->msgflags = I2O_MSGFLAGS(i2o_exec_outbound_init);
    839 	mb->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_OUTBOUND_INIT);
    840 	mb->msgictx = IOP_ICTX;
    841 	mb->msgtctx = im->im_tctx;
    842 	mb->pagesize = PAGE_SIZE;
    843 	mb->flags = 0x80 | ((IOP_MAX_REPLY_SIZE >> 2) << 16);	/* XXX */
    844 
    845 	status = 0;
    846 
    847 	/*
    848 	 * The I2O spec says that there are two SGLs: one for the status
    849 	 * word, and one for a list of discarded MFAs.  It continues to say
    850 	 * that if you don't want to get the list of MFAs, an IGNORE SGL is
    851 	 * necessary; this isn't the case (and in fact appears to be a bad
    852 	 * thing).
    853 	 */
    854 	iop_msg_map(sc, im, (void *)&status, sizeof(status), 0);
    855 	if ((rv = iop_msg_send(sc, im, 0)) != 0) {
    856 		iop_msg_free(sc, NULL, im);
    857 		return (rv);
    858 	}
    859 	iop_msg_unmap(sc, im);
    860 	iop_msg_free(sc, NULL, im);
    861 
    862 	/* XXX */
    863 	POLL(5000, status == I2O_EXEC_OUTBOUND_INIT_COMPLETE);
    864 	if (status != I2O_EXEC_OUTBOUND_INIT_COMPLETE) {
    865 		printf("%s: outbound FIFO init failed\n", sc->sc_dv.dv_xname);
    866 		return (EIO);
    867 	}
    868 
    869 	/* If we need to allocate DMA safe memory, do it now. */
    870 	if (sc->sc_rep_phys == 0) {
    871 		sc->sc_rep_size = sc->sc_maxreplycnt * IOP_MAX_REPLY_SIZE;
    872 
    873 		rv = bus_dmamem_alloc(sc->sc_dmat, sc->sc_rep_size, PAGE_SIZE,
    874 		    0, &seg, 1, &rseg, BUS_DMA_NOWAIT);
    875 		if (rv != 0) {
    876 			printf("%s: dma alloc = %d\n", sc->sc_dv.dv_xname,
    877 			   rv);
    878 			return (rv);
    879 		}
    880 
    881 		rv = bus_dmamem_map(sc->sc_dmat, &seg, rseg, sc->sc_rep_size,
    882 		    &sc->sc_rep, BUS_DMA_NOWAIT | BUS_DMA_COHERENT);
    883 		if (rv != 0) {
    884 			printf("%s: dma map = %d\n", sc->sc_dv.dv_xname, rv);
    885 			return (rv);
    886 		}
    887 
    888 		rv = bus_dmamap_create(sc->sc_dmat, sc->sc_rep_size, 1,
    889 		    sc->sc_rep_size, 0, BUS_DMA_NOWAIT, &sc->sc_rep_dmamap);
    890 		if (rv != 0) {
    891 			printf("%s: dma create = %d\n", sc->sc_dv.dv_xname, rv);
    892 			return (rv);
    893 		}
    894 
    895 		rv = bus_dmamap_load(sc->sc_dmat, sc->sc_rep_dmamap, sc->sc_rep,
    896 		    sc->sc_rep_size, NULL, BUS_DMA_NOWAIT);
    897 		if (rv != 0) {
    898 			printf("%s: dma load = %d\n", sc->sc_dv.dv_xname, rv);
    899 			return (rv);
    900 		}
    901 
    902 		sc->sc_rep_phys = sc->sc_rep_dmamap->dm_segs[0].ds_addr;
    903 	}
    904 
    905 	/* Populate the outbound FIFO. */
    906 	for (i = sc->sc_maxreplycnt, addr = sc->sc_rep_phys; i != 0; i--) {
    907 		iop_outl(sc, IOP_REG_OFIFO, (u_int32_t)addr);
    908 		addr += IOP_MAX_REPLY_SIZE;
    909 	}
    910 
    911 	return (0);
    912 }
    913 
    914 /*
    915  * Read the specified number of bytes from the IOP's hardware resource table.
    916  */
    917 static int
    918 iop_hrt_get0(struct iop_softc *sc, struct i2o_hrt *hrt, int size)
    919 {
    920 	struct iop_msg *im;
    921 	int rv;
    922 	struct i2o_exec_hrt_get *mb;
    923 
    924 	if ((rv = iop_msg_alloc(sc, NULL, &im, IM_NOINTR)) != 0)
    925 		return (rv);
    926 
    927 	mb = (struct i2o_exec_hrt_get *)im->im_msg;
    928 	mb->msgflags = I2O_MSGFLAGS(i2o_exec_hrt_get);
    929 	mb->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_HRT_GET);
    930 	mb->msgictx = IOP_ICTX;
    931 	mb->msgtctx = im->im_tctx;
    932 
    933 	iop_msg_map(sc, im, hrt, size, 0);
    934 	rv = iop_msg_enqueue(sc, im, 5000);
    935 	iop_msg_unmap(sc, im);
    936 	iop_msg_free(sc, NULL, im);
    937 	return (rv);
    938 }
    939 
    940 /*
    941  * Read the IOP's hardware resource table.
    942  */
    943 static int
    944 iop_hrt_get(struct iop_softc *sc)
    945 {
    946 	struct i2o_hrt hrthdr, *hrt;
    947 	int size, rv;
    948 
    949 	if ((rv = iop_hrt_get0(sc, &hrthdr, sizeof(hrthdr))) != 0)
    950 		return (rv);
    951 
    952 	DPRINTF(("%s: %d hrt entries\n", sc->sc_dv.dv_xname,
    953 	    le16toh(hrthdr.numentries)));
    954 
    955 	size = sizeof(struct i2o_hrt) +
    956 	    (htole32(hrthdr.numentries) - 1) * sizeof(struct i2o_hrt_entry);
    957 	hrt = (struct i2o_hrt *)malloc(size, M_DEVBUF, M_NOWAIT);
    958 
    959 	if ((rv = iop_hrt_get0(sc, hrt, size)) != 0) {
    960 		free(hrt, M_DEVBUF);
    961 		return (rv);
    962 	}
    963 
    964 	if (sc->sc_hrt != NULL)
    965 		free(sc->sc_hrt, M_DEVBUF);
    966 	sc->sc_hrt = hrt;
    967 	return (0);
    968 }
    969 
    970 /*
    971  * Request the specified number of bytes from the IOP's logical
    972  * configuration table.  If a change indicator is specified, this
    973  * is an verbatim notification request, so the caller is prepared
    974  * to wait indefinitely.
    975  */
    976 static int
    977 iop_lct_get0(struct iop_softc *sc, struct i2o_lct *lct, int size,
    978 	     u_int32_t chgind)
    979 {
    980 	struct iop_msg *im;
    981 	struct i2o_exec_lct_notify *mb;
    982 	int rv;
    983 
    984 	if ((rv = iop_msg_alloc(sc, NULL, &im, IM_NOINTR)) != 0)
    985 		return (rv);
    986 
    987 	memset(lct, 0, size);
    988 	memset(im->im_msg, 0, sizeof(im->im_msg));
    989 
    990 	mb = (struct i2o_exec_lct_notify *)im->im_msg;
    991 	mb->msgflags = I2O_MSGFLAGS(i2o_exec_lct_notify);
    992 	mb->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_LCT_NOTIFY);
    993 	mb->msgictx = IOP_ICTX;
    994 	mb->msgtctx = im->im_tctx;
    995 	mb->classid = I2O_CLASS_ANY;
    996 	mb->changeindicator = chgind;
    997 
    998 #ifdef I2ODEBUG
    999 	printf("iop_lct_get0: reading LCT");
   1000 	if (chgind != 0)
   1001 		printf(" (async)");
   1002 	printf("\n");
   1003 #endif
   1004 
   1005 	iop_msg_map(sc, im, lct, size, 0);
   1006 	rv = iop_msg_enqueue(sc, im, (chgind == 0 ? 120*1000 : 0));
   1007 	iop_msg_unmap(sc, im);
   1008 	iop_msg_free(sc, NULL, im);
   1009 	return (rv);
   1010 }
   1011 
   1012 /*
   1013  * Read the IOP's logical configuration table.
   1014  */
   1015 int
   1016 iop_lct_get(struct iop_softc *sc)
   1017 {
   1018 	int esize, size, rv;
   1019 	struct i2o_lct *lct;
   1020 
   1021 	esize = le32toh(sc->sc_status.expectedlctsize);
   1022 	lct = (struct i2o_lct *)malloc(esize, M_DEVBUF, M_WAITOK);
   1023 	if (lct == NULL)
   1024 		return (ENOMEM);
   1025 
   1026 	if ((rv = iop_lct_get0(sc, lct, esize, 0)) != 0) {
   1027 		free(lct, M_DEVBUF);
   1028 		return (rv);
   1029 	}
   1030 
   1031 	size = le16toh(lct->tablesize) << 2;
   1032 	if (esize != size) {
   1033 		free(lct, M_DEVBUF);
   1034 		lct = (struct i2o_lct *)malloc(size, M_DEVBUF, M_WAITOK);
   1035 		if (lct == NULL)
   1036 			return (ENOMEM);
   1037 
   1038 		if ((rv = iop_lct_get0(sc, lct, size, 0)) != 0) {
   1039 			free(lct, M_DEVBUF);
   1040 			return (rv);
   1041 		}
   1042 	}
   1043 
   1044 	/* Swap in the new LCT. */
   1045 	if (sc->sc_lct != NULL)
   1046 		free(sc->sc_lct, M_DEVBUF);
   1047 	sc->sc_lct = lct;
   1048 	sc->sc_nlctent = ((le16toh(sc->sc_lct->tablesize) << 2) -
   1049 	    sizeof(struct i2o_lct) + sizeof(struct i2o_lct_entry)) /
   1050 	    sizeof(struct i2o_lct_entry);
   1051 	return (0);
   1052 }
   1053 
   1054 /*
   1055  * Request the specified parameter group from the target.
   1056  */
   1057 int
   1058 iop_param_op(struct iop_softc *sc, int tid, int write, int group, void *buf,
   1059 	     int size)
   1060 {
   1061 	struct iop_msg *im;
   1062 	struct i2o_util_params_op *mb;
   1063 	int rv, func, op;
   1064 	struct {
   1065 		struct	i2o_param_op_list_header olh;
   1066 		struct	i2o_param_op_all_template oat;
   1067 	} req;
   1068 
   1069 	if ((rv = iop_msg_alloc(sc, NULL, &im, IM_NOINTR)) != 0)
   1070 		return (rv);
   1071 
   1072 	if (write) {
   1073 		func = I2O_UTIL_PARAMS_SET;
   1074 		op = I2O_PARAMS_OP_FIELD_SET;
   1075 	} else {
   1076 		func = I2O_UTIL_PARAMS_GET;
   1077 		op = I2O_PARAMS_OP_FIELD_GET;
   1078 	}
   1079 
   1080 	mb = (struct i2o_util_params_op *)im->im_msg;
   1081 	mb->msgflags = I2O_MSGFLAGS(i2o_util_params_op);
   1082 	mb->msgfunc = I2O_MSGFUNC(tid, func);
   1083 	mb->msgictx = IOP_ICTX;
   1084 	mb->msgtctx = im->im_tctx;
   1085 	mb->flags = 0;
   1086 
   1087 	req.olh.count = htole16(1);
   1088 	req.olh.reserved = htole16(0);
   1089 	req.oat.operation = htole16(op);
   1090 	req.oat.fieldcount = htole16(0xffff);
   1091 	req.oat.group = htole16(group);
   1092 
   1093 	memset(buf, 0, size);
   1094 	iop_msg_map(sc, im, &req, sizeof(req), 1);
   1095 	iop_msg_map(sc, im, buf, size, write);
   1096 
   1097 	rv = iop_msg_enqueue(sc, im, 5000);
   1098 	iop_msg_unmap(sc, im);
   1099 	iop_msg_free(sc, NULL, im);
   1100 	return (rv);
   1101 }
   1102 
   1103 /*
   1104  * Execute a simple command (no parameters).
   1105  */
   1106 int
   1107 iop_simple_cmd(struct iop_softc *sc, int tid, int function, int ictx,
   1108 	       int async, int timo)
   1109 {
   1110 	struct iop_msg *im;
   1111 	struct i2o_msg *mb;
   1112 	int rv, fl;
   1113 
   1114 	fl = (async != 0 ? IM_NOWAIT : 0);
   1115 	if ((rv = iop_msg_alloc(sc, NULL, &im, fl | IM_NOINTR)) != 0)
   1116 		return (rv);
   1117 
   1118 	mb = (struct i2o_msg *)im->im_msg;
   1119 	mb->msgflags = I2O_MSGFLAGS(i2o_msg);
   1120 	mb->msgfunc = I2O_MSGFUNC(tid, function);
   1121 	mb->msgictx = ictx;
   1122 	mb->msgtctx = im->im_tctx;
   1123 
   1124 	if (async)
   1125 		rv = iop_msg_enqueue(sc, im, timo);
   1126 	else
   1127 		rv = iop_msg_send(sc, im, timo);
   1128 	iop_msg_free(sc, NULL, im);
   1129 	return (rv);
   1130 }
   1131 
   1132 /*
   1133  * Post the system table to the IOP.
   1134  */
   1135 static int
   1136 iop_systab_set(struct iop_softc *sc)
   1137 {
   1138 	struct i2o_exec_sys_tab_set *mb;
   1139 	struct iop_msg *im;
   1140 	u_int32_t mema[2], ioa[2];
   1141 	int rv;
   1142 
   1143 	if ((rv = iop_msg_alloc(sc, NULL, &im, IM_NOINTR)) != 0)
   1144 		return (rv);
   1145 
   1146 	mb = (struct i2o_exec_sys_tab_set *)im->im_msg;
   1147 	mb->msgflags = I2O_MSGFLAGS(i2o_exec_sys_tab_set);
   1148 	mb->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_SYS_TAB_SET);
   1149 	mb->msgictx = IOP_ICTX;
   1150 	mb->msgtctx = im->im_tctx;
   1151 	mb->iopid = (sc->sc_dv.dv_unit + 2) << 12;
   1152 	mb->segnumber = 0;
   1153 
   1154 	/* XXX This is questionable, but better than nothing... */
   1155 	mema[0] = le32toh(sc->sc_status.currentprivmembase);
   1156 	mema[1] = le32toh(sc->sc_status.currentprivmemsize);
   1157 	ioa[0] = le32toh(sc->sc_status.currentpriviobase);
   1158 	ioa[1] = le32toh(sc->sc_status.currentpriviosize);
   1159 
   1160 	iop_msg_map(sc, im, iop_systab, iop_systab_size, 1);
   1161 	iop_msg_map(sc, im, mema, sizeof(mema), 1);
   1162 	iop_msg_map(sc, im, ioa, sizeof(ioa), 1);
   1163 
   1164 	rv = iop_msg_enqueue(sc, im, 5000);
   1165 	iop_msg_unmap(sc, im);
   1166 	iop_msg_free(sc, NULL, im);
   1167 	return (rv);
   1168 }
   1169 
   1170 /*
   1171  * Reset the adapter.  Must be called with interrupts disabled.
   1172  */
   1173 static int
   1174 iop_reset(struct iop_softc *sc)
   1175 {
   1176 	struct iop_msg *im;
   1177 	volatile u_int32_t sw;
   1178 	u_int32_t mfa;
   1179 	struct i2o_exec_iop_reset *mb;
   1180 	int rv;
   1181 
   1182 	if ((rv = iop_msg_alloc(sc, NULL, &im, IM_NOWAIT | IM_NOICTX)) != 0)
   1183 		return (rv);
   1184 
   1185 	sw = 0;
   1186 
   1187 	mb = (struct i2o_exec_iop_reset *)im->im_msg;
   1188 	mb->msgflags = I2O_MSGFLAGS(i2o_exec_iop_reset);
   1189 	mb->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_IOP_RESET);
   1190 	mb->reserved[0] = 0;
   1191 	mb->reserved[1] = 0;
   1192 	mb->reserved[2] = 0;
   1193 	mb->reserved[3] = 0;
   1194 	mb->statuslow = kvtop((caddr_t)&sw);		/* XXX */
   1195 	mb->statushigh = 0;
   1196 
   1197 	if ((rv = iop_msg_send(sc, im, 0)))
   1198 		return (rv);
   1199 	iop_msg_free(sc, NULL, im);
   1200 
   1201 	POLL(2500, sw != 0);					/* XXX */
   1202 	if (sw != I2O_RESET_IN_PROGRESS) {
   1203 		printf("%s: reset rejected\n", sc->sc_dv.dv_xname);
   1204 		return (EIO);
   1205 	}
   1206 
   1207 	/*
   1208 	 * IOP is now in the INIT state.  Wait no more than 10 seconds for
   1209 	 * the inbound queue to become responsive.
   1210 	 */
   1211 	POLL(10000, (mfa = iop_inl(sc, IOP_REG_IFIFO)) != IOP_MFA_EMPTY);
   1212 	if (mfa == IOP_MFA_EMPTY) {
   1213 		printf("%s: reset failed\n", sc->sc_dv.dv_xname);
   1214 		return (EIO);
   1215 	}
   1216 
   1217 	if (sw == I2O_RESET_REJECTED)
   1218 		printf("%s: reset rejected?\n", sc->sc_dv.dv_xname);
   1219 
   1220 	iop_release_mfa(sc, mfa);
   1221 	return (0);
   1222 }
   1223 
   1224 /*
   1225  * Register a new initiator.
   1226  */
   1227 int
   1228 iop_initiator_register(struct iop_softc *sc, struct iop_initiator *ii)
   1229 {
   1230 	static int ictx;
   1231 	static int stctx;
   1232 
   1233 	/* 0 is reserved for system messages. */
   1234 	ii->ii_ictx = ++ictx;
   1235 	ii->ii_stctx = ++stctx | 0x80000000;
   1236 
   1237 	LIST_INSERT_HEAD(&sc->sc_iilist, ii, ii_list);
   1238 	LIST_INSERT_HEAD(IOP_ICTXHASH(ii->ii_ictx), ii, ii_hash);
   1239 
   1240 	return (0);
   1241 }
   1242 
   1243 /*
   1244  * Unregister an initiator.
   1245  */
   1246 void
   1247 iop_initiator_unregister(struct iop_softc *sc, struct iop_initiator *ii)
   1248 {
   1249 
   1250 	LIST_REMOVE(ii, ii_list);
   1251 	LIST_REMOVE(ii, ii_hash);
   1252 }
   1253 
   1254 /*
   1255  * Handle a reply frame from the adapter.
   1256  */
   1257 static int
   1258 iop_handle_reply(struct iop_softc *sc, u_int32_t rmfa)
   1259 {
   1260 	struct iop_msg *im;
   1261 	struct i2o_reply *rb;
   1262 	struct iop_initiator *ii;
   1263 	u_int off, ictx, tctx, status, size;
   1264 
   1265 	off = (int)(rmfa - sc->sc_rep_phys);
   1266 	rb = (struct i2o_reply *)(sc->sc_rep + off);
   1267 
   1268 	/* Perform reply queue DMA synchronisation... */
   1269 	bus_dmamap_sync(sc->sc_dmat, sc->sc_rep_dmamap, off, IOP_MAX_MSG_SIZE,
   1270 	    BUS_DMASYNC_POSTREAD);
   1271 	if (--sc->sc_stat.is_cur_hwqueue != 0)
   1272 		bus_dmamap_sync(sc->sc_dmat, sc->sc_rep_dmamap,
   1273 		    0, sc->sc_rep_size, BUS_DMASYNC_PREREAD);
   1274 
   1275 #ifdef I2ODEBUG
   1276 	if ((le32toh(rb->msgflags) & I2O_MSGFLAGS_64BIT) != 0)
   1277 		panic("iop_handle_reply: 64-bit reply");
   1278 #endif
   1279 	/*
   1280 	 * Find the initiator.
   1281 	 */
   1282 	ictx = le32toh(rb->msgictx);
   1283 	if (ictx == IOP_ICTX)
   1284 		ii = NULL;
   1285 	else {
   1286 		ii = LIST_FIRST(IOP_ICTXHASH(ictx));
   1287 		for (; ii != NULL; ii = LIST_NEXT(ii, ii_hash))
   1288 			if (ii->ii_ictx == ictx)
   1289 				break;
   1290 		if (ii == NULL) {
   1291 #ifdef I2ODEBUG
   1292 			iop_reply_print(sc, NULL, rb);
   1293 #endif
   1294 			printf("%s: WARNING: bad ictx returned (%x)",
   1295 			    sc->sc_dv.dv_xname, ictx);
   1296 
   1297 			/* Return the reply frame to the IOP's outbound FIFO. */
   1298 			iop_outl(sc, IOP_REG_OFIFO, rmfa);
   1299 			return (-1);
   1300 		}
   1301 	}
   1302 
   1303 	status = rb->reqstatus;
   1304 
   1305 	if (ii == NULL || (ii->ii_flags & II_DISCARD) == 0) {
   1306 		/*
   1307 		 * This initiator tracks state using message wrappers.
   1308 		 *
   1309 		 * Find the originating message wrapper, and if requested
   1310 		 * notify the initiator.
   1311 		 */
   1312 		tctx = le32toh(rb->msgtctx);
   1313 		im = TAILQ_FIRST(IOP_TCTXHASH(tctx));
   1314 		for (; im != NULL; im = TAILQ_NEXT(im, im_hash))
   1315 			if (im->im_tctx == tctx)
   1316 				break;
   1317 		if (im == NULL || (im->im_flags & IM_ALLOCED) == 0) {
   1318 #ifdef I2ODEBUG
   1319 			iop_reply_print(sc, NULL, rb);
   1320 #endif
   1321 			printf("%s: WARNING: bad tctx returned (%x, %p)",
   1322 			    sc->sc_dv.dv_xname, tctx, im);
   1323 
   1324 			/* Return the reply frame to the IOP's outbound FIFO. */
   1325 			iop_outl(sc, IOP_REG_OFIFO, rmfa);
   1326 			return (-1);
   1327 		}
   1328 #ifdef I2ODEBUG
   1329 		if ((im->im_flags & IM_REPLIED) != 0)
   1330 			panic("%s: dup reply", sc->sc_dv.dv_xname);
   1331 #endif
   1332 
   1333 		im->im_flags |= IM_REPLIED;
   1334 
   1335 #ifdef I2ODEBUG
   1336 		if (rb->reqstatus != 0)
   1337 			iop_reply_print(sc, im, rb);
   1338 #endif
   1339 		/* Notify the initiator. */
   1340 		if ((im->im_flags & IM_WAITING) != 0) {
   1341 			size = (le32toh(rb->msgflags) >> 14) & ~3;
   1342 			if (size > IOP_MAX_REPLY_SIZE)
   1343 				size = IOP_MAX_REPLY_SIZE;
   1344 			memcpy(im->im_msg, rb, size);
   1345 			wakeup(im);
   1346 		} else if ((im->im_flags & IM_NOINTR) == 0)
   1347 			(*ii->ii_intr)(ii->ii_dv, im, rb);
   1348 	} else {
   1349 		/*
   1350 		 * This initiator discards message wrappers.
   1351 		 *
   1352 		 * Simply pass the reply frame to the initiator.
   1353 		 */
   1354 		(*ii->ii_intr)(ii->ii_dv, NULL, rb);
   1355 	}
   1356 
   1357 	/* Return the reply frame to the IOP's outbound FIFO. */
   1358 	iop_outl(sc, IOP_REG_OFIFO, rmfa);
   1359 
   1360 	/* Run the queue. */
   1361 	if ((im = SIMPLEQ_FIRST(&sc->sc_queue)) != NULL)
   1362 		iop_msg_enqueue(sc, im, 0);
   1363 
   1364 	return (status);
   1365 }
   1366 
   1367 /*
   1368  * Handle an interrupt from the adapter.
   1369  */
   1370 int
   1371 iop_intr(void *arg)
   1372 {
   1373 	struct iop_softc *sc;
   1374 	u_int32_t rmfa;
   1375 
   1376 	sc = arg;
   1377 
   1378 	if ((iop_inl(sc, IOP_REG_INTR_STATUS) & IOP_INTR_OFIFO) == 0)
   1379 		return (0);
   1380 
   1381 	for (;;) {
   1382 		/* Double read to account for IOP bug. */
   1383 		if ((rmfa = iop_inl(sc, IOP_REG_OFIFO)) == IOP_MFA_EMPTY &&
   1384 		    (rmfa = iop_inl(sc, IOP_REG_OFIFO)) == IOP_MFA_EMPTY)
   1385 			break;
   1386 		iop_handle_reply(sc, rmfa);
   1387 	}
   1388 
   1389 	return (1);
   1390 }
   1391 
   1392 /*
   1393  * Handle an event signalled by the executive.
   1394  */
   1395 static void
   1396 iop_intr_event(struct device *dv, struct iop_msg *im, void *reply)
   1397 {
   1398 	struct i2o_util_event_register_reply *rb;
   1399 	struct iop_softc *sc;
   1400 	u_int event;
   1401 
   1402 	sc = (struct iop_softc *)dv;
   1403 	rb = reply;
   1404 	event = le32toh(rb->event);
   1405 
   1406 #ifndef I2ODEBUG
   1407 	if (event == I2O_EVENT_GEN_EVENT_MASK_MODIFIED)
   1408 		return;
   1409 #endif
   1410 
   1411 	printf("%s: event 0x%08x received\n", dv->dv_xname, event);
   1412 }
   1413 
   1414 /*
   1415  * Allocate a message wrapper.
   1416  */
   1417 int
   1418 iop_msg_alloc(struct iop_softc *sc, struct iop_initiator *ii,
   1419 	      struct iop_msg **imp, int flags)
   1420 {
   1421 	struct iop_msg *im;
   1422 	static int tctxgen = 666;
   1423 	int s, rv, i, tctx;
   1424 
   1425 #ifdef I2ODEBUG
   1426 	if ((flags & IM_SYSMASK) != 0)
   1427 		panic("iop_msg_alloc: system flags specified");
   1428 #endif
   1429 
   1430 	s = splbio();	/* XXX */
   1431 
   1432 	if (ii != NULL && (ii->ii_flags & II_DISCARD) != 0) {
   1433 		flags |= IM_DISCARD;
   1434 		tctx = ii->ii_stctx;
   1435 	} else
   1436 		tctx = tctxgen++ & 0x7fffffff;
   1437 
   1438 	im = (struct iop_msg *)pool_get(iop_msgpool,
   1439 	    (flags & IM_NOWAIT) == 0 ? PR_WAITOK : 0);
   1440 	if (im == NULL) {
   1441 		splx(s);
   1442 		return (ENOMEM);
   1443 	}
   1444 
   1445 	/* XXX */
   1446 	rv = bus_dmamap_create(sc->sc_dmat, IOP_MAX_XFER, IOP_MAX_SGL_ENTRIES,
   1447 	    IOP_MAX_XFER, 0, BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
   1448 	    &im->im_xfer[0].ix_map);
   1449 	if (rv != 0) {
   1450 		pool_put(iop_msgpool, im);
   1451 		splx(s);
   1452 		return (rv);
   1453 	}
   1454 
   1455 	if ((flags & (IM_DISCARD | IM_NOICTX)) == 0)
   1456 		TAILQ_INSERT_TAIL(IOP_TCTXHASH(tctx), im, im_hash);
   1457 
   1458 	splx(s);
   1459 
   1460 	im->im_tctx = tctx;
   1461 	im->im_flags = flags | IM_ALLOCED;
   1462 	for (i = 0; i < IOP_MAX_MSG_XFERS; i++)
   1463 		im->im_xfer[i].ix_size = 0;
   1464 	*imp = im;
   1465 
   1466 	return (0);
   1467 }
   1468 
   1469 /*
   1470  * Free a message wrapper.
   1471  */
   1472 void
   1473 iop_msg_free(struct iop_softc *sc, struct iop_initiator *ii, struct iop_msg *im)
   1474 {
   1475 	int s;
   1476 
   1477 #ifdef I2ODEBUG
   1478 	if ((im->im_flags & IM_ALLOCED) == 0)
   1479 		panic("iop_msg_free: wrapper not allocated");
   1480 #endif
   1481 
   1482 	/* XXX */
   1483 	bus_dmamap_destroy(sc->sc_dmat, im->im_xfer[0].ix_map);
   1484 
   1485 	s = splbio();	/* XXX */
   1486 
   1487 	if ((im->im_flags & (IM_DISCARD | IM_NOICTX)) == 0)
   1488 		TAILQ_REMOVE(IOP_TCTXHASH(im->im_tctx), im, im_hash);
   1489 
   1490 	im->im_flags = 0;
   1491 	pool_put(iop_msgpool, im);
   1492 	splx(s);
   1493 }
   1494 
   1495 /*
   1496  * Map a data transfer.  Write a scatter-gather list into the message frame.
   1497  */
   1498 int
   1499 iop_msg_map(struct iop_softc *sc, struct iop_msg *im, void *xferaddr,
   1500 	    int xfersize, int out)
   1501 {
   1502 	struct iop_xfer *ix;
   1503 	u_int32_t *mb;
   1504 	int rv, seg, i;
   1505 
   1506 	for (i = 0, ix = im->im_xfer; i < IOP_MAX_MSG_XFERS; i++, ix++)
   1507 		if (ix->ix_size == 0)
   1508 			break;
   1509 #ifdef I2ODEBUG
   1510 	if (i == IOP_MAX_MSG_XFERS)
   1511 		panic("iop_msg_map: too many xfers");
   1512 #endif
   1513 
   1514 	/* Only the first DMA map is static. */
   1515 	if (i != 0) {
   1516 		rv = bus_dmamap_create(sc->sc_dmat, IOP_MAX_XFER,
   1517 		    IOP_MAX_SGL_ENTRIES, IOP_MAX_XFER, 0,
   1518 		    BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &ix->ix_map);
   1519 		if (rv != 0)
   1520 			return (rv);
   1521 	}
   1522 
   1523 	ix->ix_flags = (out ? IX_OUT : IX_IN);
   1524 	ix->ix_size = xfersize;
   1525 
   1526 	rv = bus_dmamap_load(sc->sc_dmat, ix->ix_map, xferaddr, xfersize,
   1527 	    NULL, 0);
   1528 	if (rv != 0)
   1529 		return (rv);
   1530 	bus_dmamap_sync(sc->sc_dmat, ix->ix_map, 0, xfersize,
   1531 	    out ? BUS_DMASYNC_POSTWRITE : BUS_DMASYNC_POSTREAD);
   1532 
   1533 	mb = im->im_msg + (im->im_msg[0] >> 16);
   1534 	if (out)
   1535 		out = I2O_SGL_SIMPLE | I2O_SGL_DATA_OUT;
   1536 	else
   1537 		out = I2O_SGL_SIMPLE;
   1538 
   1539 	for (seg = 0; seg < ix->ix_map->dm_nsegs; seg++) {
   1540 #ifdef I2ODEBUG
   1541 		if ((seg << 1) + (im->im_msg[0] >> 16) >=
   1542 		    (IOP_MAX_MSG_SIZE >> 2))
   1543 			panic("iop_map_xfer: message frame too large");
   1544 #endif
   1545 		if (seg == ix->ix_map->dm_nsegs - 1)
   1546 			out |= I2O_SGL_END_BUFFER;
   1547 		*mb++ = (u_int32_t)ix->ix_map->dm_segs[seg].ds_len | out;
   1548 		*mb++ = (u_int32_t)ix->ix_map->dm_segs[seg].ds_addr;
   1549 	}
   1550 
   1551 	/*
   1552 	 * If this is the first xfer we've mapped for this message, adjust
   1553 	 * the SGL offset field in the message header.
   1554 	 */
   1555 	if ((im->im_flags & IM_SGLOFFADJ) == 0) {
   1556 		im->im_msg[0] += ((im->im_msg[0] >> 16) + seg * 2) << 4;
   1557 		im->im_flags |= IM_SGLOFFADJ;
   1558 	}
   1559 	im->im_msg[0] += (seg << 17);
   1560 	return (0);
   1561 }
   1562 
   1563 /*
   1564  * Unmap all data transfers associated with a message wrapper.
   1565  */
   1566 void
   1567 iop_msg_unmap(struct iop_softc *sc, struct iop_msg *im)
   1568 {
   1569 	struct iop_xfer *ix;
   1570 	int i;
   1571 
   1572 	for (i = 0, ix = im->im_xfer; i < IOP_MAX_MSG_XFERS; i++, ix++) {
   1573 		if (ix->ix_size == 0)
   1574 			break;
   1575 		bus_dmamap_sync(sc->sc_dmat, ix->ix_map, 0, ix->ix_size,
   1576 		    ix->ix_flags & IX_OUT ? BUS_DMASYNC_POSTWRITE :
   1577 		    BUS_DMASYNC_POSTREAD);
   1578 		bus_dmamap_unload(sc->sc_dmat, ix->ix_map);
   1579 
   1580 		/* Only the first DMA map is static. */
   1581 		if (i != 0)
   1582 			bus_dmamap_destroy(sc->sc_dmat, ix->ix_map);
   1583 
   1584 		ix->ix_size = 0;
   1585 	}
   1586 }
   1587 
   1588 /*
   1589  * Send a message to the IOP.  Optionally, poll on completion.  Return
   1590  * non-zero if failure status is returned and IM_NOINTR is set.
   1591  */
   1592 int
   1593 iop_msg_send(struct iop_softc *sc, struct iop_msg *im, int timo)
   1594 {
   1595 	u_int32_t mfa, rmfa;
   1596 	int rv, status, i, s;
   1597 
   1598 #ifdef I2ODEBUG
   1599 	if ((im->im_flags & IM_NOICTX) == 0)
   1600 		if (im->im_msg[3] == IOP_ICTX &&
   1601 		    (im->im_flags & IM_NOINTR) == 0)
   1602 			panic("iop_msg_send: IOP_ICTX and !IM_NOINTR");
   1603 	if ((im->im_flags & IM_DISCARD) != 0)
   1604 		panic("iop_msg_send: IM_DISCARD");
   1605 #endif
   1606 
   1607 	s = splbio();	/* XXX */
   1608 
   1609 	/* Wait up to 250ms for an MFA. */
   1610 	POLL(250, (mfa = iop_inl(sc, IOP_REG_IFIFO)) != IOP_MFA_EMPTY);
   1611 	if (mfa == IOP_MFA_EMPTY) {
   1612 		DPRINTF(("%s: mfa not forthcoming\n", sc->sc_dv.dv_xname));
   1613 		splx(s);
   1614 		return (EBUSY);
   1615 	}
   1616 
   1617 	/* Perform reply queue DMA synchronisation and update counters. */
   1618 	if ((im->im_flags & IM_NOICTX) == 0) {
   1619 		if (sc->sc_stat.is_cur_hwqueue == 0)
   1620 			bus_dmamap_sync(sc->sc_dmat, sc->sc_rep_dmamap, 0,
   1621 			    sc->sc_rep_size, BUS_DMASYNC_PREREAD);
   1622 		for (i = 0; i < IOP_MAX_MSG_XFERS; i++)
   1623 			sc->sc_stat.is_bytes += im->im_xfer[i].ix_size;
   1624 		sc->sc_stat.is_requests++;
   1625 		if (++sc->sc_stat.is_cur_hwqueue > sc->sc_stat.is_peak_hwqueue)
   1626 			sc->sc_stat.is_peak_hwqueue =
   1627 			    sc->sc_stat.is_cur_hwqueue;
   1628 	}
   1629 
   1630 	/* Terminate scatter/gather lists. */
   1631 	if ((im->im_flags & IM_SGLOFFADJ) != 0)
   1632 		im->im_msg[(im->im_msg[0] >> 16) - 2] |= I2O_SGL_END;
   1633 
   1634 	/* Post the message frame. */
   1635 	bus_space_write_region_4(sc->sc_iot, sc->sc_ioh, mfa,
   1636 	    im->im_msg, im->im_msg[0] >> 16);
   1637 	bus_space_barrier(sc->sc_iot, sc->sc_ioh, mfa,
   1638 	    (im->im_msg[0] >> 14) & ~3, BUS_SPACE_BARRIER_WRITE);
   1639 
   1640 	/* Post the MFA back to the IOP, thus starting the command. */
   1641 	iop_outl(sc, IOP_REG_IFIFO, mfa);
   1642 
   1643 	if (timo == 0) {
   1644 		splx(s);
   1645 		return (0);
   1646 	}
   1647 
   1648 	/* Wait for completion. */
   1649 	for (timo *= 10; timo != 0; timo--) {
   1650 		if ((iop_inl(sc, IOP_REG_INTR_STATUS) & IOP_INTR_OFIFO) != 0) {
   1651 			/* Double read to account for IOP bug. */
   1652 			rmfa = iop_inl(sc, IOP_REG_OFIFO);
   1653 			if (rmfa == IOP_MFA_EMPTY)
   1654 				rmfa = iop_inl(sc, IOP_REG_OFIFO);
   1655 			if (rmfa != IOP_MFA_EMPTY)
   1656 				status = iop_handle_reply(sc, rmfa);
   1657 		}
   1658 		if ((im->im_flags & IM_REPLIED) != 0)
   1659 			break;
   1660 		DELAY(100);
   1661 	}
   1662 
   1663 	splx(s);
   1664 
   1665 	if (timo == 0) {
   1666 #ifdef I2ODEBUG
   1667 		printf("%s: poll - no reply\n", sc->sc_dv.dv_xname);
   1668 		if (iop_status_get(sc) != 0)
   1669 			printf("iop_msg_send: unable to retrieve status\n");
   1670 		else
   1671 			printf("iop_msg_send: IOP state = %d\n",
   1672 			    (le32toh(sc->sc_status.segnumber) >> 16) & 0xff);
   1673 #endif
   1674 		rv = EBUSY;
   1675 	} else if ((im->im_flags & IM_NOINTR) != 0)
   1676 		rv = (status != I2O_STATUS_SUCCESS ? EIO : 0);
   1677 
   1678 	return (rv);
   1679 }
   1680 
   1681 /*
   1682  * Try to post a message to the adapter; if that's not possible, enqueue it
   1683  * with us.  If a timeout is specified, wait for the message to complete.
   1684  */
   1685 int
   1686 iop_msg_enqueue(struct iop_softc *sc, struct iop_msg *im, int timo)
   1687 {
   1688 	u_int mfa;
   1689 	int s, fromqueue, i, rv;
   1690 
   1691 #ifdef I2ODEBUG
   1692 	if (im == NULL)
   1693 		panic("iop_msg_enqueue: im == NULL");
   1694 	if (sc == NULL)
   1695 		panic("iop_msg_enqueue: sc == NULL");
   1696 	if ((im->im_flags & IM_NOICTX) != 0)
   1697 		panic("iop_msg_enqueue: IM_NOICTX");
   1698 	if (im->im_msg[3] == IOP_ICTX && (im->im_flags & IM_NOINTR) == 0)
   1699 		panic("iop_msg_enqueue: IOP_ICTX and no IM_NOINTR");
   1700 	if ((im->im_flags & IM_DISCARD) != 0 && timo != 0)
   1701 		panic("iop_msg_enqueue: IM_DISCARD && timo != 0");
   1702 	if ((im->im_flags & IM_NOINTR) == 0 && timo != 0)
   1703 		panic("iop_msg_enqueue: !IM_NOINTR && timo != 0");
   1704 #endif
   1705 
   1706 	s = splbio();	/* XXX */
   1707 	fromqueue = (im == SIMPLEQ_FIRST(&sc->sc_queue));
   1708 
   1709 	if (sc->sc_stat.is_cur_hwqueue >= sc->sc_maxqueuecnt) {
   1710 		/*
   1711 		 * While the IOP may be able to accept more inbound message
   1712 		 * frames than it advertises, don't push harder than it
   1713 		 * wants to go lest we starve it.
   1714 		 *
   1715 		 * XXX We should be handling IOP resource shortages.
   1716 		 */
   1717 		mfa = IOP_MFA_EMPTY;
   1718 		DPRINTF(("iop_msg_enqueue: exceeded max queue count\n"));
   1719 	} else {
   1720 		/* Double read to account for IOP bug. */
   1721 		if ((mfa = iop_inl(sc, IOP_REG_IFIFO)) == IOP_MFA_EMPTY)
   1722 			mfa = iop_inl(sc, IOP_REG_IFIFO);
   1723 	}
   1724 
   1725 	if (mfa == IOP_MFA_EMPTY) {
   1726 		DPRINTF(("iop_msg_enqueue: no mfa\n"));
   1727 		/* Can't transfer to h/w queue - queue with us. */
   1728 		if (!fromqueue) {
   1729 			SIMPLEQ_INSERT_TAIL(&sc->sc_queue, im, im_queue);
   1730 			if (++sc->sc_stat.is_cur_swqueue >
   1731 			    sc->sc_stat.is_peak_swqueue)
   1732 				sc->sc_stat.is_peak_swqueue =
   1733 				    sc->sc_stat.is_cur_swqueue;
   1734 		}
   1735 		splx(s);
   1736 		if ((im->im_flags & IM_NOINTR) != 0)
   1737 			rv = iop_msg_wait(sc, im, timo);
   1738 		else
   1739 			rv = 0;
   1740 		return (rv);
   1741 	} else if (fromqueue) {
   1742 		SIMPLEQ_REMOVE_HEAD(&sc->sc_queue, im, im_queue);
   1743 		sc->sc_stat.is_cur_swqueue--;
   1744 	}
   1745 
   1746 	if ((im->im_flags & IM_NOINTR) != 0)
   1747 		im->im_flags |= IM_WAITING;
   1748 
   1749 	/* Perform reply queue DMA synchronisation and update counters. */
   1750 	if (sc->sc_stat.is_cur_hwqueue == 0)
   1751 		bus_dmamap_sync(sc->sc_dmat, sc->sc_rep_dmamap, 0,
   1752 		    sc->sc_rep_size, BUS_DMASYNC_PREREAD);
   1753 
   1754 	for (i = 0; i < IOP_MAX_MSG_XFERS; i++)
   1755 		sc->sc_stat.is_bytes += im->im_xfer[i].ix_size;
   1756 	sc->sc_stat.is_requests++;
   1757 	if (++sc->sc_stat.is_cur_hwqueue > sc->sc_stat.is_peak_hwqueue)
   1758 		sc->sc_stat.is_peak_hwqueue = sc->sc_stat.is_cur_hwqueue;
   1759 
   1760 	/* Terminate the scatter/gather list. */
   1761 	if ((im->im_flags & IM_SGLOFFADJ) != 0)
   1762 		im->im_msg[(im->im_msg[0] >> 16) - 2] |= I2O_SGL_END;
   1763 
   1764 	/* Post the message frame. */
   1765 	bus_space_write_region_4(sc->sc_iot, sc->sc_ioh, mfa,
   1766 	    im->im_msg, im->im_msg[0] >> 16);
   1767 	bus_space_barrier(sc->sc_iot, sc->sc_ioh, mfa,
   1768 	    (im->im_msg[0] >> 14) & ~3, BUS_SPACE_BARRIER_WRITE);
   1769 
   1770 	/* Post the MFA back to the IOP, thus starting the command. */
   1771 	iop_outl(sc, IOP_REG_IFIFO, mfa);
   1772 
   1773 	/* If this is a discardable message wrapper, free it. */
   1774 	if ((im->im_flags & IM_DISCARD) != 0)
   1775 		iop_msg_free(sc, NULL, im);
   1776 	splx(s);
   1777 
   1778 	if ((im->im_flags & IM_NOINTR) != 0)
   1779 		rv = iop_msg_wait(sc, im, timo);
   1780 	else
   1781 		rv = 0;
   1782 	return (rv);
   1783 }
   1784 
   1785 /*
   1786  * Wait for the specified message to complete.
   1787  */
   1788 static int
   1789 iop_msg_wait(struct iop_softc *sc, struct iop_msg *im, int timo)
   1790 {
   1791 	struct i2o_reply *rb;
   1792 	int rv, s;
   1793 
   1794 	s = splbio();
   1795 	if ((im->im_flags & IM_REPLIED) != 0) {
   1796 		splx(s);
   1797 		return (0);
   1798 	}
   1799 	rv = tsleep(im, PRIBIO, "iopmsg", timo * hz / 1000);
   1800 	splx(s);
   1801 #ifdef I2ODEBUG
   1802 	if (rv != 0) {
   1803 		printf("iop_msg_wait: tsleep() == %d\n", rv);
   1804 		if (iop_status_get(sc) != 0)
   1805 			printf("iop_msg_wait: unable to retrieve status\n");
   1806 		else
   1807 			printf("iop_msg_wait: IOP state = %d\n",
   1808 			    (le32toh(sc->sc_status.segnumber) >> 16) & 0xff);
   1809 	}
   1810 #endif
   1811 
   1812 	if ((im->im_flags & (IM_REPLIED | IM_NOSTATUS)) == IM_REPLIED) {
   1813 		rb = (struct i2o_reply *)im->im_msg;
   1814 		rv = (rb->reqstatus != I2O_STATUS_SUCCESS ? EIO : 0);
   1815 	}
   1816 	return (rv);
   1817 }
   1818 
   1819 /*
   1820  * Release an unused message frame back to the IOP's inbound fifo.
   1821  */
   1822 static void
   1823 iop_release_mfa(struct iop_softc *sc, u_int32_t mfa)
   1824 {
   1825 
   1826 	/* Use the frame to issue a no-op. */
   1827 	iop_outl(sc, mfa, I2O_VERSION_11 | (4 << 16));
   1828 	iop_outl(sc, mfa + 4, I2O_MSGFUNC(I2O_TID_IOP, I2O_UTIL_NOP));
   1829 	iop_outl(sc, mfa + 8, 0);
   1830 	iop_outl(sc, mfa + 12, 0);
   1831 
   1832 	iop_outl(sc, IOP_REG_IFIFO, mfa);
   1833 }
   1834 
   1835 #ifdef I2ODEBUG
   1836 /*
   1837  * Print status information from a failure reply frame.
   1838  */
   1839 static void
   1840 iop_reply_print(struct iop_softc *sc, struct iop_msg *im,
   1841 		struct i2o_reply *rb)
   1842 {
   1843 	u_int function, detail;
   1844 #ifdef I2OVERBOSE
   1845 	const char *statusstr;
   1846 #endif
   1847 
   1848 	if (im != NULL && (im->im_flags & IM_REPLIED) == 0)
   1849 		panic("iop_msg_print_status: %p not replied to", im);
   1850 
   1851 	function = (le32toh(rb->msgfunc) >> 24) & 0xff;
   1852 	detail = le16toh(rb->detail);
   1853 
   1854 	printf("%s: reply:\n", sc->sc_dv.dv_xname);
   1855 
   1856 #ifdef I2OVERBOSE
   1857 	if (rb->reqstatus < sizeof(iop_status) / sizeof(iop_status[0]))
   1858 		statusstr = iop_status[rb->reqstatus];
   1859 	else
   1860 		statusstr = "undefined error code";
   1861 
   1862 	printf("%s:   function=0x%02x status=0x%02x (%s)\n",
   1863 	    sc->sc_dv.dv_xname, function, rb->reqstatus, statusstr);
   1864 #else
   1865 	printf("%s:   function=0x%02x status=0x%02x\n",
   1866 	    sc->sc_dv.dv_xname, function, rb->reqstatus);
   1867 #endif
   1868 	printf("%s:   detail=0x%04x ictx=0x%08x tctx=0x%08x\n",
   1869 	    sc->sc_dv.dv_xname, detail, le32toh(rb->msgictx),
   1870 	    le32toh(rb->msgtctx));
   1871 	printf("%s:   tidi=%d tidt=%d flags=0x%02x\n", sc->sc_dv.dv_xname,
   1872 	    (le32toh(rb->msgfunc) >> 12) & 4095, le32toh(rb->msgfunc) & 4095,
   1873 	    (le32toh(rb->msgflags) >> 8) & 0xff);
   1874 }
   1875 #endif
   1876 
   1877 /*
   1878  * Translate an I2O ASCII field into a C string.
   1879  */
   1880 void
   1881 iop_strvis(struct iop_softc *sc, const char *src, int slen, char *dst, int dlen)
   1882 {
   1883 	int hc, lc, i, nit;
   1884 
   1885 	dlen--;
   1886 	lc = 0;
   1887 	hc = 0;
   1888 	i = 0;
   1889 
   1890 	/*
   1891 	 * DPT use NUL as a space, whereas AMI use it as a terminator.  The
   1892 	 * spec has nothing to say about it.  Since AMI fields are usually
   1893 	 * filled with junk after the terminator, ...
   1894 	 */
   1895 	nit = (le16toh(sc->sc_status.orgid) != I2O_ORG_DPT);
   1896 
   1897 	while (slen-- != 0 && dlen-- != 0) {
   1898 		if (nit && *src == '\0')
   1899 			break;
   1900 		else if (*src <= 0x20 || *src >= 0x7f) {
   1901 			if (hc)
   1902 				dst[i++] = ' ';
   1903 		} else {
   1904 			hc = 1;
   1905 			dst[i++] = *src;
   1906 			lc = i;
   1907 		}
   1908 		src++;
   1909 	}
   1910 
   1911 	dst[lc] = '\0';
   1912 }
   1913 
   1914 /*
   1915  * Claim or unclaim the specified TID.
   1916  */
   1917 int
   1918 iop_util_claim(struct iop_softc *sc, struct iop_initiator *ii, int release,
   1919 	      int flags)
   1920 {
   1921 	struct iop_msg *im;
   1922 	struct i2o_util_claim *mb;
   1923 	int rv, func;
   1924 
   1925 	func = release ? I2O_UTIL_CLAIM_RELEASE : I2O_UTIL_CLAIM;
   1926 
   1927 	if ((rv = iop_msg_alloc(sc, ii, &im, IM_NOINTR)) != 0)
   1928 		return (rv);
   1929 
   1930 	/* We can use the same structure, as both are identical. */
   1931 	mb = (struct i2o_util_claim *)im->im_msg;
   1932 	mb->msgflags = I2O_MSGFLAGS(i2o_util_claim);
   1933 	mb->msgfunc = I2O_MSGFUNC(ii->ii_tid, func);
   1934 	mb->msgictx = ii->ii_ictx;
   1935 	mb->msgtctx = im->im_tctx;
   1936 	mb->flags = flags;
   1937 
   1938 	rv = iop_msg_enqueue(sc, im, 5000);
   1939 	iop_msg_free(sc, ii, im);
   1940 	return (rv);
   1941 }
   1942 
   1943 /*
   1944  * Perform an abort.
   1945  */
   1946 int iop_util_abort(struct iop_softc *sc, struct iop_initiator *ii, int func,
   1947 		  int tctxabort, int flags)
   1948 {
   1949 	struct iop_msg *im;
   1950 	struct i2o_util_abort *mb;
   1951 	int rv;
   1952 
   1953 	if ((rv = iop_msg_alloc(sc, ii, &im, IM_NOINTR)) != 0)
   1954 		return (rv);
   1955 
   1956 	mb = (struct i2o_util_abort *)im->im_msg;
   1957 	mb->msgflags = I2O_MSGFLAGS(i2o_util_abort);
   1958 	mb->msgfunc = I2O_MSGFUNC(ii->ii_tid, I2O_UTIL_ABORT);
   1959 	mb->msgictx = ii->ii_ictx;
   1960 	mb->msgtctx = im->im_tctx;
   1961 	mb->flags = (func << 24) | flags;
   1962 	mb->tctxabort = tctxabort;
   1963 
   1964 	rv = iop_msg_enqueue(sc, im, 5000);
   1965 	iop_msg_free(sc, ii, im);
   1966 	return (rv);
   1967 }
   1968 
   1969 /*
   1970  * Enable or disable event types for the specified device.
   1971  */
   1972 int iop_util_eventreg(struct iop_softc *sc, struct iop_initiator *ii, int mask)
   1973 {
   1974 	struct iop_msg *im;
   1975 	struct i2o_util_event_register *mb;
   1976 	int rv;
   1977 
   1978 	if ((rv = iop_msg_alloc(sc, ii, &im, 0)) != 0)
   1979 		return (rv);
   1980 
   1981 	mb = (struct i2o_util_event_register *)im->im_msg;
   1982 	mb->msgflags = I2O_MSGFLAGS(i2o_util_event_register);
   1983 	mb->msgfunc = I2O_MSGFUNC(ii->ii_tid, I2O_UTIL_EVENT_REGISTER);
   1984 	mb->msgictx = ii->ii_ictx;
   1985 	mb->msgtctx = im->im_tctx;
   1986 	mb->eventmask = mask;
   1987 
   1988 	return (iop_msg_enqueue(sc, im, 0));
   1989 }
   1990 
   1991 int
   1992 iopopen(dev_t dev, int flag, int mode, struct proc *p)
   1993 {
   1994 	struct iop_softc *sc;
   1995 	int unit, error;
   1996 
   1997 	unit = minor(dev);
   1998 
   1999 	sc = device_lookup(&iop_cd, minor(dev));
   2000 	if ((sc = iop_cd.cd_devs[unit]) == NULL)
   2001 		return (ENXIO);
   2002 	if ((error = suser(p->p_ucred, &p->p_acflag)) != 0)
   2003 		return (error);
   2004 
   2005 	if ((sc->sc_flags & IOP_OPEN) != 0)
   2006 		return (EBUSY);
   2007 	if ((sc->sc_flags & IOP_ONLINE) == 0)
   2008 		return (EIO);
   2009 	sc->sc_flags |= IOP_OPEN;
   2010 
   2011 	/* XXX */
   2012 	sc->sc_ptb = malloc(((MAXPHYS + 3) & ~3) * IOP_MAX_MSG_XFERS, M_DEVBUF,
   2013 	    M_WAITOK);
   2014 	if (sc->sc_ptb == NULL) {
   2015 		sc->sc_flags ^= IOP_OPEN;
   2016 		return (ENOMEM);
   2017 	}
   2018 
   2019 	return (0);
   2020 }
   2021 
   2022 int
   2023 iopclose(dev_t dev, int flag, int mode, struct proc *p)
   2024 {
   2025 	struct iop_softc *sc;
   2026 
   2027 	sc = device_lookup(&iop_cd, minor(dev));
   2028 	free(sc->sc_ptb, M_DEVBUF);
   2029 	sc->sc_flags ^= IOP_OPEN;
   2030 	return (0);
   2031 }
   2032 
   2033 int
   2034 iopioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
   2035 {
   2036 	struct iop_softc *sc;
   2037 	struct iovec *iov;
   2038 	struct ioppt *pt;
   2039 	struct iop_msg *im;
   2040 	struct i2o_msg *mb;
   2041 	struct i2o_reply *rb;
   2042 	int rv, i;
   2043 	struct ioppt_buf *ptb;
   2044 	void *buf;
   2045 
   2046 	if (securelevel >= 2)
   2047 		return (EPERM);
   2048 
   2049 	sc = device_lookup(&iop_cd, minor(dev));
   2050 
   2051 	PHOLD(p);
   2052 
   2053 	switch (cmd) {
   2054 	case IOPIOCPT:
   2055 		pt = (struct ioppt *)data;
   2056 
   2057 		if (pt->pt_msglen > IOP_MAX_MSG_SIZE ||
   2058 		    pt->pt_msglen < sizeof(struct i2o_msg) ||
   2059 		    pt->pt_nbufs > IOP_MAX_MSG_XFERS ||
   2060 		    pt->pt_nbufs < 0 ||
   2061 		    pt->pt_replylen < 0 ||
   2062 		    pt->pt_timo < 1000 ||
   2063 		    pt->pt_timo > 5*60*1000) {
   2064 		    	rv = EINVAL;
   2065 		    	break;
   2066 		}
   2067 		for (i = 0; i < pt->pt_nbufs; i++)
   2068 			if (pt->pt_bufs[i].ptb_datalen > ((MAXPHYS + 3) & ~3))
   2069 				return (ENOMEM);
   2070 
   2071 		rv = iop_msg_alloc(sc, NULL, &im, IM_NOINTR | IM_NOSTATUS);
   2072 		if (rv != 0)
   2073 			break;
   2074 
   2075 		if ((rv = copyin(pt->pt_msg, im->im_msg, pt->pt_msglen)) != 0) {
   2076 			iop_msg_free(sc, NULL, im);
   2077 			break;
   2078 		}
   2079 
   2080 		mb = (struct i2o_msg *)im->im_msg;
   2081 		mb->msgictx = IOP_ICTX;
   2082 		mb->msgtctx = im->im_tctx;
   2083 
   2084 		for (i = 0; i < pt->pt_nbufs; i++) {
   2085 			ptb = &pt->pt_bufs[i];
   2086 			buf = sc->sc_ptb + i * ((MAXPHYS + 3) & ~3);
   2087 
   2088 			if (ptb->ptb_out != 0)
   2089 				rv = copyin(ptb->ptb_data, buf,
   2090 				    ptb->ptb_datalen);
   2091 
   2092 			rv = iop_msg_map(sc, im, buf, ptb->ptb_datalen,
   2093 			    ptb->ptb_out != 0);
   2094 			if (rv != 0) {
   2095 				iop_msg_free(sc, NULL, im);
   2096 				break;
   2097 			}
   2098 		}
   2099 
   2100 		if ((rv = iop_msg_enqueue(sc, im, pt->pt_timo)) == 0) {
   2101 			rb = (struct i2o_reply *)im->im_msg;
   2102 			i = (le32toh(rb->msgflags) >> 14) & ~3;	/* XXX */
   2103 			if (i > IOP_MAX_REPLY_SIZE)
   2104 				i = IOP_MAX_REPLY_SIZE;
   2105 			if (i > pt->pt_replylen)
   2106 				i = pt->pt_replylen;
   2107 			rv = copyout(rb, pt->pt_reply, i);
   2108 		}
   2109 
   2110 		for (i = 0; i < pt->pt_nbufs; i++) {
   2111 			ptb = &pt->pt_bufs[i];
   2112 			if (ptb->ptb_out != 0 || rv != 0)
   2113 				continue;
   2114 			rv = copyout(sc->sc_ptb + i * ((MAXPHYS + 3) & ~3),
   2115 			    ptb->ptb_data, ptb->ptb_datalen);
   2116 		}
   2117 
   2118 		iop_msg_free(sc, NULL, im);
   2119 		break;
   2120 
   2121 	case IOPIOCGLCT:
   2122 		iov = (struct iovec *)data;
   2123 		rv = lockmgr(&sc->sc_conflock, LK_SHARED, NULL);
   2124 		if (rv == 0) {
   2125 			i = le16toh(sc->sc_lct->tablesize) << 2;
   2126 			if (i > iov->iov_len)
   2127 				i = iov->iov_len;
   2128 			else
   2129 				iov->iov_len = i;
   2130 			rv = copyout(sc->sc_lct, iov->iov_base, i);
   2131 			lockmgr(&sc->sc_conflock, LK_RELEASE, NULL);
   2132 		}
   2133 		break;
   2134 
   2135 	case IOPIOCGSTATUS:
   2136 		iov = (struct iovec *)data;
   2137 		i = sizeof(struct i2o_status);
   2138 		if (i > iov->iov_len)
   2139 			i = iov->iov_len;
   2140 		else
   2141 			iov->iov_len = i;
   2142 		if ((rv = iop_status_get(sc)) == 0)
   2143 			rv = copyout(&sc->sc_status, iov->iov_base, i);
   2144 		break;
   2145 
   2146 	case IOPIOCRECONFIG:
   2147 		rv = iop_reconfigure(sc, 0, 0);
   2148 		break;
   2149 
   2150 	case IOPIOCGTIDMAP:
   2151 		iov = (struct iovec *)data;
   2152 		rv = lockmgr(&sc->sc_conflock, LK_SHARED, NULL);
   2153 		if (rv == 0) {
   2154 			i = sizeof(struct iop_tidmap) * sc->sc_nlctent;
   2155 			if (i > iov->iov_len)
   2156 				i = iov->iov_len;
   2157 			else
   2158 				iov->iov_len = i;
   2159 			rv = copyout(sc->sc_tidmap, iov->iov_base, i);
   2160 			lockmgr(&sc->sc_conflock, LK_RELEASE, NULL);
   2161 		}
   2162 		break;
   2163 
   2164 	default:
   2165 #if defined(DIAGNOSTIC) || defined(I2ODEBUG)
   2166 		printf("%s: unknown ioctl %lx\n", sc->sc_dv.dv_xname, cmd);
   2167 #endif
   2168 		rv = ENOTTY;
   2169 		break;
   2170 	}
   2171 
   2172 	PRELE(p);
   2173 
   2174 	return (rv);
   2175 }
   2176