Home | History | Annotate | Line # | Download | only in i2o
iop.c revision 1.86
      1  1.86  dholland /*	$NetBSD: iop.c,v 1.86 2014/07/25 08:10:37 dholland Exp $	*/
      2   1.1        ad 
      3   1.1        ad /*-
      4  1.63        ad  * Copyright (c) 2000, 2001, 2002, 2007 The NetBSD Foundation, Inc.
      5   1.1        ad  * All rights reserved.
      6   1.1        ad  *
      7   1.1        ad  * This code is derived from software contributed to The NetBSD Foundation
      8   1.1        ad  * by Andrew Doran.
      9   1.1        ad  *
     10   1.1        ad  * Redistribution and use in source and binary forms, with or without
     11   1.1        ad  * modification, are permitted provided that the following conditions
     12   1.1        ad  * are met:
     13   1.1        ad  * 1. Redistributions of source code must retain the above copyright
     14   1.1        ad  *    notice, this list of conditions and the following disclaimer.
     15   1.1        ad  * 2. Redistributions in binary form must reproduce the above copyright
     16   1.1        ad  *    notice, this list of conditions and the following disclaimer in the
     17   1.1        ad  *    documentation and/or other materials provided with the distribution.
     18   1.1        ad  *
     19   1.1        ad  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20   1.1        ad  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21   1.1        ad  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22   1.1        ad  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23   1.1        ad  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24   1.1        ad  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25   1.1        ad  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26   1.1        ad  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27   1.1        ad  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28   1.1        ad  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29   1.1        ad  * POSSIBILITY OF SUCH DAMAGE.
     30   1.1        ad  */
     31   1.1        ad 
     32   1.1        ad /*
     33   1.1        ad  * Support for I2O IOPs (intelligent I/O processors).
     34   1.1        ad  */
     35  1.20     lukem 
     36  1.20     lukem #include <sys/cdefs.h>
     37  1.86  dholland __KERNEL_RCSID(0, "$NetBSD: iop.c,v 1.86 2014/07/25 08:10:37 dholland Exp $");
     38   1.1        ad 
     39   1.5        ad #include "iop.h"
     40   1.1        ad 
     41   1.1        ad #include <sys/param.h>
     42   1.1        ad #include <sys/systm.h>
     43   1.1        ad #include <sys/kernel.h>
     44   1.1        ad #include <sys/device.h>
     45   1.1        ad #include <sys/queue.h>
     46   1.1        ad #include <sys/proc.h>
     47   1.1        ad #include <sys/malloc.h>
     48   1.1        ad #include <sys/ioctl.h>
     49   1.1        ad #include <sys/endian.h>
     50   1.5        ad #include <sys/conf.h>
     51   1.5        ad #include <sys/kthread.h>
     52  1.60      elad #include <sys/kauth.h>
     53  1.67        ad #include <sys/bus.h>
     54   1.1        ad 
     55   1.1        ad #include <dev/i2o/i2o.h>
     56  1.11        ad #include <dev/i2o/iopio.h>
     57   1.1        ad #include <dev/i2o/iopreg.h>
     58   1.1        ad #include <dev/i2o/iopvar.h>
     59   1.1        ad 
     60  1.44  drochner #include "locators.h"
     61  1.44  drochner 
     62   1.1        ad #define POLL(ms, cond)				\
     63   1.1        ad do {						\
     64  1.48  christos 	int xi;					\
     65  1.48  christos 	for (xi = (ms) * 10; xi; xi--) {	\
     66   1.1        ad 		if (cond)			\
     67   1.1        ad 			break;			\
     68   1.1        ad 		DELAY(100);			\
     69   1.1        ad 	}					\
     70   1.1        ad } while (/* CONSTCOND */0);
     71   1.1        ad 
     72   1.1        ad #ifdef I2ODEBUG
     73   1.1        ad #define DPRINTF(x)	printf x
     74   1.1        ad #else
     75   1.1        ad #define	DPRINTF(x)
     76   1.1        ad #endif
     77   1.1        ad 
     78   1.5        ad #define IOP_ICTXHASH_NBUCKETS	16
     79   1.5        ad #define	IOP_ICTXHASH(ictx)	(&iop_ictxhashtbl[(ictx) & iop_ictxhash])
     80  1.11        ad 
     81  1.11        ad #define	IOP_MAX_SEGS	(((IOP_MAX_XFER + PAGE_SIZE - 1) / PAGE_SIZE) + 1)
     82  1.11        ad 
     83  1.11        ad #define	IOP_TCTX_SHIFT	12
     84  1.11        ad #define	IOP_TCTX_MASK	((1 << IOP_TCTX_SHIFT) - 1)
     85   1.5        ad 
     86   1.5        ad static LIST_HEAD(, iop_initiator) *iop_ictxhashtbl;
     87   1.5        ad static u_long	iop_ictxhash;
     88   1.1        ad static void	*iop_sdh;
     89   1.5        ad static struct	i2o_systab *iop_systab;
     90   1.5        ad static int	iop_systab_size;
     91   1.1        ad 
     92   1.1        ad extern struct cfdriver iop_cd;
     93   1.1        ad 
     94  1.25   gehenna dev_type_open(iopopen);
     95  1.25   gehenna dev_type_close(iopclose);
     96  1.25   gehenna dev_type_ioctl(iopioctl);
     97  1.25   gehenna 
     98  1.25   gehenna const struct cdevsw iop_cdevsw = {
     99  1.85  dholland 	.d_open = iopopen,
    100  1.85  dholland 	.d_close = iopclose,
    101  1.85  dholland 	.d_read = noread,
    102  1.85  dholland 	.d_write = nowrite,
    103  1.85  dholland 	.d_ioctl = iopioctl,
    104  1.85  dholland 	.d_stop = nostop,
    105  1.85  dholland 	.d_tty = notty,
    106  1.85  dholland 	.d_poll = nopoll,
    107  1.85  dholland 	.d_mmap = nommap,
    108  1.85  dholland 	.d_kqfilter = nokqfilter,
    109  1.86  dholland 	.d_discard = nodiscard,
    110  1.85  dholland 	.d_flag = D_OTHER,
    111  1.25   gehenna };
    112  1.25   gehenna 
    113   1.5        ad #define	IC_CONFIGURE	0x01
    114  1.11        ad #define	IC_PRIORITY	0x02
    115   1.1        ad 
    116  1.57  christos static struct iop_class {
    117   1.5        ad 	u_short	ic_class;
    118   1.5        ad 	u_short	ic_flags;
    119  1.65        ad 	const char *ic_caption;
    120  1.57  christos } const iop_class[] = {
    121  1.47     perry 	{
    122   1.1        ad 		I2O_CLASS_EXECUTIVE,
    123   1.1        ad 		0,
    124  1.65        ad 		"executive"
    125   1.1        ad 	},
    126   1.1        ad 	{
    127   1.1        ad 		I2O_CLASS_DDM,
    128   1.1        ad 		0,
    129  1.65        ad 		"device driver module"
    130   1.1        ad 	},
    131   1.1        ad 	{
    132   1.1        ad 		I2O_CLASS_RANDOM_BLOCK_STORAGE,
    133  1.11        ad 		IC_CONFIGURE | IC_PRIORITY,
    134  1.65        ad 		"random block storage"
    135   1.1        ad 	},
    136   1.1        ad 	{
    137   1.1        ad 		I2O_CLASS_SEQUENTIAL_STORAGE,
    138  1.11        ad 		IC_CONFIGURE | IC_PRIORITY,
    139  1.65        ad 		"sequential storage"
    140   1.1        ad 	},
    141   1.1        ad 	{
    142   1.1        ad 		I2O_CLASS_LAN,
    143  1.11        ad 		IC_CONFIGURE | IC_PRIORITY,
    144  1.65        ad 		"LAN port"
    145   1.1        ad 	},
    146   1.1        ad 	{
    147   1.1        ad 		I2O_CLASS_WAN,
    148  1.11        ad 		IC_CONFIGURE | IC_PRIORITY,
    149  1.65        ad 		"WAN port"
    150   1.1        ad 	},
    151   1.1        ad 	{
    152   1.1        ad 		I2O_CLASS_FIBRE_CHANNEL_PORT,
    153   1.1        ad 		IC_CONFIGURE,
    154  1.65        ad 		"fibrechannel port"
    155   1.1        ad 	},
    156   1.1        ad 	{
    157   1.1        ad 		I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL,
    158   1.1        ad 		0,
    159  1.65        ad 		"fibrechannel peripheral"
    160   1.1        ad 	},
    161   1.1        ad  	{
    162   1.1        ad  		I2O_CLASS_SCSI_PERIPHERAL,
    163   1.1        ad  		0,
    164  1.65        ad  		"SCSI peripheral"
    165   1.1        ad  	},
    166   1.1        ad 	{
    167   1.1        ad 		I2O_CLASS_ATE_PORT,
    168   1.1        ad 		IC_CONFIGURE,
    169  1.65        ad 		"ATE port"
    170   1.1        ad 	},
    171  1.47     perry 	{
    172   1.1        ad 		I2O_CLASS_ATE_PERIPHERAL,
    173   1.1        ad 		0,
    174  1.65        ad 		"ATE peripheral"
    175   1.1        ad 	},
    176  1.47     perry 	{
    177   1.1        ad 		I2O_CLASS_FLOPPY_CONTROLLER,
    178   1.1        ad 		IC_CONFIGURE,
    179  1.65        ad 		"floppy controller"
    180   1.1        ad 	},
    181   1.1        ad 	{
    182   1.1        ad 		I2O_CLASS_FLOPPY_DEVICE,
    183   1.1        ad 		0,
    184  1.65        ad 		"floppy device"
    185   1.1        ad 	},
    186   1.1        ad 	{
    187   1.1        ad 		I2O_CLASS_BUS_ADAPTER_PORT,
    188   1.1        ad 		IC_CONFIGURE,
    189  1.65        ad 		"bus adapter port"
    190   1.1        ad 	},
    191   1.1        ad };
    192   1.1        ad 
    193  1.83     joerg #ifdef I2ODEBUG
    194  1.11        ad static const char * const iop_status[] = {
    195   1.1        ad 	"success",
    196   1.1        ad 	"abort (dirty)",
    197   1.1        ad 	"abort (no data transfer)",
    198   1.1        ad 	"abort (partial transfer)",
    199   1.1        ad 	"error (dirty)",
    200   1.1        ad 	"error (no data transfer)",
    201   1.1        ad 	"error (partial transfer)",
    202   1.1        ad 	"undefined error code",
    203   1.1        ad 	"process abort (dirty)",
    204   1.1        ad 	"process abort (no data transfer)",
    205   1.1        ad 	"process abort (partial transfer)",
    206   1.1        ad 	"transaction error",
    207   1.1        ad };
    208  1.83     joerg #endif
    209   1.1        ad 
    210   1.5        ad static inline u_int32_t	iop_inl(struct iop_softc *, int);
    211   1.5        ad static inline void	iop_outl(struct iop_softc *, int, u_int32_t);
    212   1.5        ad 
    213  1.29   msaitoh static inline u_int32_t	iop_inl_msg(struct iop_softc *, int);
    214  1.30        ad static inline void	iop_outl_msg(struct iop_softc *, int, u_int32_t);
    215  1.29   msaitoh 
    216  1.76    cegger static void	iop_config_interrupts(device_t);
    217  1.11        ad static void	iop_configure_devices(struct iop_softc *, int, int);
    218  1.43    itojun static void	iop_devinfo(int, char *, size_t);
    219   1.1        ad static int	iop_print(void *, const char *);
    220   1.1        ad static void	iop_shutdown(void *);
    221   1.1        ad 
    222  1.11        ad static void	iop_adjqparam(struct iop_softc *, int);
    223  1.11        ad static int	iop_handle_reply(struct iop_softc *, u_int32_t);
    224   1.1        ad static int	iop_hrt_get(struct iop_softc *);
    225   1.1        ad static int	iop_hrt_get0(struct iop_softc *, struct i2o_hrt *, int);
    226  1.76    cegger static void	iop_intr_event(device_t, struct iop_msg *, void *);
    227   1.5        ad static int	iop_lct_get0(struct iop_softc *, struct i2o_lct *, int,
    228   1.5        ad 			     u_int32_t);
    229  1.11        ad static void	iop_msg_poll(struct iop_softc *, struct iop_msg *, int);
    230  1.11        ad static void	iop_msg_wait(struct iop_softc *, struct iop_msg *, int);
    231   1.1        ad static int	iop_ofifo_init(struct iop_softc *);
    232  1.15        ad static int	iop_passthrough(struct iop_softc *, struct ioppt *,
    233  1.15        ad 				struct proc *);
    234   1.9        ad static void	iop_reconf_thread(void *);
    235   1.1        ad static void	iop_release_mfa(struct iop_softc *, u_int32_t);
    236   1.1        ad static int	iop_reset(struct iop_softc *);
    237  1.42        ad static int	iop_sys_enable(struct iop_softc *);
    238   1.1        ad static int	iop_systab_set(struct iop_softc *);
    239  1.11        ad static void	iop_tfn_print(struct iop_softc *, struct i2o_fault_notify *);
    240   1.1        ad 
    241   1.1        ad #ifdef I2ODEBUG
    242  1.11        ad static void	iop_reply_print(struct iop_softc *, struct i2o_reply *);
    243   1.1        ad #endif
    244   1.5        ad 
    245   1.5        ad static inline u_int32_t
    246   1.5        ad iop_inl(struct iop_softc *sc, int off)
    247   1.5        ad {
    248   1.5        ad 
    249   1.5        ad 	bus_space_barrier(sc->sc_iot, sc->sc_ioh, off, 4,
    250   1.5        ad 	    BUS_SPACE_BARRIER_WRITE | BUS_SPACE_BARRIER_READ);
    251   1.5        ad 	return (bus_space_read_4(sc->sc_iot, sc->sc_ioh, off));
    252   1.5        ad }
    253   1.5        ad 
    254   1.5        ad static inline void
    255   1.5        ad iop_outl(struct iop_softc *sc, int off, u_int32_t val)
    256   1.5        ad {
    257   1.5        ad 
    258   1.5        ad 	bus_space_write_4(sc->sc_iot, sc->sc_ioh, off, val);
    259   1.5        ad 	bus_space_barrier(sc->sc_iot, sc->sc_ioh, off, 4,
    260   1.5        ad 	    BUS_SPACE_BARRIER_WRITE);
    261   1.5        ad }
    262   1.5        ad 
    263  1.29   msaitoh static inline u_int32_t
    264  1.29   msaitoh iop_inl_msg(struct iop_softc *sc, int off)
    265  1.29   msaitoh {
    266  1.29   msaitoh 
    267  1.32        ad 	bus_space_barrier(sc->sc_msg_iot, sc->sc_msg_ioh, off, 4,
    268  1.29   msaitoh 	    BUS_SPACE_BARRIER_WRITE | BUS_SPACE_BARRIER_READ);
    269  1.32        ad 	return (bus_space_read_4(sc->sc_msg_iot, sc->sc_msg_ioh, off));
    270  1.29   msaitoh }
    271  1.29   msaitoh 
    272  1.29   msaitoh static inline void
    273  1.30        ad iop_outl_msg(struct iop_softc *sc, int off, u_int32_t val)
    274  1.29   msaitoh {
    275  1.29   msaitoh 
    276  1.30        ad 	bus_space_write_4(sc->sc_msg_iot, sc->sc_msg_ioh, off, val);
    277  1.30        ad 	bus_space_barrier(sc->sc_msg_iot, sc->sc_msg_ioh, off, 4,
    278  1.29   msaitoh 	    BUS_SPACE_BARRIER_WRITE);
    279  1.29   msaitoh }
    280  1.29   msaitoh 
    281   1.1        ad /*
    282  1.11        ad  * Initialise the IOP and our interface.
    283   1.1        ad  */
    284   1.5        ad void
    285   1.1        ad iop_init(struct iop_softc *sc, const char *intrstr)
    286   1.1        ad {
    287  1.11        ad 	struct iop_msg *im;
    288  1.40   mycroft 	int rv, i, j, state, nsegs;
    289   1.1        ad 	u_int32_t mask;
    290   1.1        ad 	char ident[64];
    291   1.1        ad 
    292  1.15        ad 	state = 0;
    293  1.15        ad 
    294  1.15        ad 	printf("I2O adapter");
    295  1.15        ad 
    296  1.68        ad 	mutex_init(&sc->sc_intrlock, MUTEX_DEFAULT, IPL_VM);
    297  1.68        ad 	mutex_init(&sc->sc_conflock, MUTEX_DEFAULT, IPL_NONE);
    298  1.65        ad 	cv_init(&sc->sc_confcv, "iopconf");
    299  1.65        ad 
    300  1.71        ad 	if (iop_ictxhashtbl == NULL) {
    301   1.5        ad 		iop_ictxhashtbl = hashinit(IOP_ICTXHASH_NBUCKETS, HASH_LIST,
    302  1.71        ad 		    true, &iop_ictxhash);
    303  1.71        ad 	}
    304   1.1        ad 
    305  1.15        ad 	/* Disable interrupts at the IOP. */
    306  1.15        ad 	mask = iop_inl(sc, IOP_REG_INTR_MASK);
    307  1.15        ad 	iop_outl(sc, IOP_REG_INTR_MASK, mask | IOP_INTR_OFIFO);
    308   1.5        ad 
    309  1.15        ad 	/* Allocate a scratch DMA map for small miscellaneous shared data. */
    310  1.15        ad 	if (bus_dmamap_create(sc->sc_dmat, PAGE_SIZE, 1, PAGE_SIZE, 0,
    311  1.15        ad 	    BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &sc->sc_scr_dmamap) != 0) {
    312  1.82       chs 		aprint_error_dev(sc->sc_dev, "cannot create scratch dmamap\n");
    313   1.5        ad 		return;
    314   1.1        ad 	}
    315  1.15        ad 
    316  1.15        ad 	if (bus_dmamem_alloc(sc->sc_dmat, PAGE_SIZE, PAGE_SIZE, 0,
    317  1.15        ad 	    sc->sc_scr_seg, 1, &nsegs, BUS_DMA_NOWAIT) != 0) {
    318  1.82       chs 		aprint_error_dev(sc->sc_dev, "cannot alloc scratch dmamem\n");
    319  1.15        ad 		goto bail_out;
    320  1.15        ad 	}
    321  1.15        ad 	state++;
    322  1.15        ad 
    323  1.15        ad 	if (bus_dmamem_map(sc->sc_dmat, sc->sc_scr_seg, nsegs, PAGE_SIZE,
    324  1.15        ad 	    &sc->sc_scr, 0)) {
    325  1.82       chs 		aprint_error_dev(sc->sc_dev, "cannot map scratch dmamem\n");
    326  1.15        ad 		goto bail_out;
    327  1.15        ad 	}
    328  1.15        ad 	state++;
    329  1.15        ad 
    330  1.15        ad 	if (bus_dmamap_load(sc->sc_dmat, sc->sc_scr_dmamap, sc->sc_scr,
    331  1.15        ad 	    PAGE_SIZE, NULL, BUS_DMA_NOWAIT)) {
    332  1.82       chs 		aprint_error_dev(sc->sc_dev, "cannot load scratch dmamap\n");
    333  1.15        ad 		goto bail_out;
    334  1.15        ad 	}
    335  1.15        ad 	state++;
    336  1.15        ad 
    337  1.21        ad #ifdef I2ODEBUG
    338  1.21        ad 	/* So that our debug checks don't choke. */
    339  1.21        ad 	sc->sc_framesize = 128;
    340  1.21        ad #endif
    341  1.21        ad 
    342  1.65        ad 	/* Avoid syncing the reply map until it's set up. */
    343  1.65        ad 	sc->sc_curib = 0x123;
    344  1.65        ad 
    345  1.15        ad 	/* Reset the adapter and request status. */
    346  1.15        ad  	if ((rv = iop_reset(sc)) != 0) {
    347  1.82       chs  		aprint_error_dev(sc->sc_dev, "not responding (reset)\n");
    348  1.15        ad 		goto bail_out;
    349  1.15        ad  	}
    350  1.15        ad 
    351  1.15        ad  	if ((rv = iop_status_get(sc, 1)) != 0) {
    352  1.82       chs 		aprint_error_dev(sc->sc_dev, "not responding (get status)\n");
    353  1.15        ad 		goto bail_out;
    354  1.15        ad  	}
    355  1.15        ad 
    356   1.5        ad 	sc->sc_flags |= IOP_HAVESTATUS;
    357   1.5        ad 	iop_strvis(sc, sc->sc_status.productid, sizeof(sc->sc_status.productid),
    358   1.1        ad 	    ident, sizeof(ident));
    359   1.5        ad 	printf(" <%s>\n", ident);
    360   1.5        ad 
    361   1.5        ad #ifdef I2ODEBUG
    362  1.69    cegger 	printf("%s: orgid=0x%04x version=%d\n",
    363  1.82       chs 	    device_xname(sc->sc_dev),
    364   1.5        ad 	    le16toh(sc->sc_status.orgid),
    365   1.5        ad 	    (le32toh(sc->sc_status.segnumber) >> 12) & 15);
    366  1.82       chs 	printf("%s: type want have cbase\n", device_xname(sc->sc_dev));
    367  1.82       chs 	printf("%s: mem  %04x %04x %08x\n", device_xname(sc->sc_dev),
    368   1.5        ad 	    le32toh(sc->sc_status.desiredprivmemsize),
    369   1.5        ad 	    le32toh(sc->sc_status.currentprivmemsize),
    370   1.5        ad 	    le32toh(sc->sc_status.currentprivmembase));
    371  1.82       chs 	printf("%s: i/o  %04x %04x %08x\n", device_xname(sc->sc_dev),
    372   1.5        ad 	    le32toh(sc->sc_status.desiredpriviosize),
    373   1.5        ad 	    le32toh(sc->sc_status.currentpriviosize),
    374   1.5        ad 	    le32toh(sc->sc_status.currentpriviobase));
    375   1.5        ad #endif
    376   1.1        ad 
    377  1.11        ad 	sc->sc_maxob = le32toh(sc->sc_status.maxoutboundmframes);
    378  1.11        ad 	if (sc->sc_maxob > IOP_MAX_OUTBOUND)
    379  1.11        ad 		sc->sc_maxob = IOP_MAX_OUTBOUND;
    380  1.11        ad 	sc->sc_maxib = le32toh(sc->sc_status.maxinboundmframes);
    381  1.11        ad 	if (sc->sc_maxib > IOP_MAX_INBOUND)
    382  1.11        ad 		sc->sc_maxib = IOP_MAX_INBOUND;
    383  1.19        ad 	sc->sc_framesize = le16toh(sc->sc_status.inboundmframesize) << 2;
    384  1.19        ad 	if (sc->sc_framesize > IOP_MAX_MSG_SIZE)
    385  1.19        ad 		sc->sc_framesize = IOP_MAX_MSG_SIZE;
    386  1.19        ad 
    387  1.19        ad #if defined(I2ODEBUG) || defined(DIAGNOSTIC)
    388  1.19        ad 	if (sc->sc_framesize < IOP_MIN_MSG_SIZE) {
    389  1.82       chs 		aprint_error_dev(sc->sc_dev, "frame size too small (%d)\n",
    390  1.69    cegger 		    sc->sc_framesize);
    391  1.23        ad 		goto bail_out;
    392  1.19        ad 	}
    393  1.19        ad #endif
    394  1.11        ad 
    395  1.11        ad 	/* Allocate message wrappers. */
    396  1.22   tsutsui 	im = malloc(sizeof(*im) * sc->sc_maxib, M_DEVBUF, M_NOWAIT|M_ZERO);
    397  1.23        ad 	if (im == NULL) {
    398  1.82       chs 		aprint_error_dev(sc->sc_dev, "memory allocation failure\n");
    399  1.23        ad 		goto bail_out;
    400  1.23        ad 	}
    401  1.23        ad 	state++;
    402  1.11        ad 	sc->sc_ims = im;
    403  1.11        ad 	SLIST_INIT(&sc->sc_im_freelist);
    404  1.11        ad 
    405  1.40   mycroft 	for (i = 0; i < sc->sc_maxib; i++, im++) {
    406  1.11        ad 		rv = bus_dmamap_create(sc->sc_dmat, IOP_MAX_XFER,
    407  1.11        ad 		    IOP_MAX_SEGS, IOP_MAX_XFER, 0,
    408  1.11        ad 		    BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
    409  1.11        ad 		    &im->im_xfer[0].ix_map);
    410  1.11        ad 		if (rv != 0) {
    411  1.82       chs 			aprint_error_dev(sc->sc_dev, "couldn't create dmamap (%d)", rv);
    412  1.40   mycroft 			goto bail_out3;
    413  1.11        ad 		}
    414  1.11        ad 
    415  1.11        ad 		im->im_tctx = i;
    416  1.11        ad 		SLIST_INSERT_HEAD(&sc->sc_im_freelist, im, im_chain);
    417  1.65        ad 		cv_init(&im->im_cv, "iopmsg");
    418  1.11        ad 	}
    419   1.1        ad 
    420  1.17       wiz 	/* Initialise the IOP's outbound FIFO. */
    421   1.5        ad 	if (iop_ofifo_init(sc) != 0) {
    422  1.82       chs 		aprint_error_dev(sc->sc_dev, "unable to init oubound FIFO\n");
    423  1.40   mycroft 		goto bail_out3;
    424   1.5        ad 	}
    425   1.1        ad 
    426   1.5        ad 	/*
    427   1.5        ad  	 * Defer further configuration until (a) interrupts are working and
    428   1.5        ad  	 * (b) we have enough information to build the system table.
    429   1.5        ad  	 */
    430  1.82       chs 	config_interrupts(sc->sc_dev, iop_config_interrupts);
    431   1.1        ad 
    432   1.5        ad 	/* Configure shutdown hook before we start any device activity. */
    433   1.1        ad 	if (iop_sdh == NULL)
    434   1.1        ad 		iop_sdh = shutdownhook_establish(iop_shutdown, NULL);
    435   1.1        ad 
    436   1.1        ad 	/* Ensure interrupts are enabled at the IOP. */
    437   1.5        ad 	mask = iop_inl(sc, IOP_REG_INTR_MASK);
    438   1.5        ad 	iop_outl(sc, IOP_REG_INTR_MASK, mask & ~IOP_INTR_OFIFO);
    439   1.1        ad 
    440   1.1        ad 	if (intrstr != NULL)
    441  1.82       chs 		printf("%s: interrupting at %s\n", device_xname(sc->sc_dev),
    442   1.1        ad 		    intrstr);
    443   1.1        ad 
    444   1.1        ad #ifdef I2ODEBUG
    445   1.1        ad 	printf("%s: queue depths: inbound %d/%d, outbound %d/%d\n",
    446  1.82       chs 	    device_xname(sc->sc_dev), sc->sc_maxib,
    447  1.11        ad 	    le32toh(sc->sc_status.maxinboundmframes),
    448  1.11        ad 	    sc->sc_maxob, le32toh(sc->sc_status.maxoutboundmframes));
    449   1.1        ad #endif
    450   1.1        ad 
    451  1.15        ad 	return;
    452  1.15        ad 
    453  1.40   mycroft  bail_out3:
    454  1.15        ad  	if (state > 3) {
    455  1.15        ad 		for (j = 0; j < i; j++)
    456  1.15        ad 			bus_dmamap_destroy(sc->sc_dmat,
    457  1.15        ad 			    sc->sc_ims[j].im_xfer[0].ix_map);
    458  1.15        ad 		free(sc->sc_ims, M_DEVBUF);
    459  1.15        ad 	}
    460  1.40   mycroft  bail_out:
    461  1.15        ad 	if (state > 2)
    462  1.15        ad 		bus_dmamap_unload(sc->sc_dmat, sc->sc_scr_dmamap);
    463  1.15        ad 	if (state > 1)
    464  1.15        ad 		bus_dmamem_unmap(sc->sc_dmat, sc->sc_scr, PAGE_SIZE);
    465  1.15        ad 	if (state > 0)
    466  1.15        ad 		bus_dmamem_free(sc->sc_dmat, sc->sc_scr_seg, nsegs);
    467  1.15        ad 	bus_dmamap_destroy(sc->sc_dmat, sc->sc_scr_dmamap);
    468   1.1        ad }
    469   1.1        ad 
    470   1.1        ad /*
    471   1.5        ad  * Perform autoconfiguration tasks.
    472   1.1        ad  */
    473   1.1        ad static void
    474  1.76    cegger iop_config_interrupts(device_t self)
    475   1.1        ad {
    476  1.18        ad 	struct iop_attach_args ia;
    477   1.5        ad 	struct iop_softc *sc, *iop;
    478   1.5        ad 	struct i2o_systab_entry *ste;
    479   1.5        ad 	int rv, i, niop;
    480  1.49  drochner 	int locs[IOPCF_NLOCS];
    481   1.1        ad 
    482  1.54   thorpej 	sc = device_private(self);
    483  1.65        ad 	mutex_enter(&sc->sc_conflock);
    484  1.65        ad 
    485   1.5        ad 	LIST_INIT(&sc->sc_iilist);
    486   1.5        ad 
    487  1.82       chs 	printf("%s: configuring...\n", device_xname(sc->sc_dev));
    488   1.1        ad 
    489   1.5        ad 	if (iop_hrt_get(sc) != 0) {
    490  1.82       chs 		printf("%s: unable to retrieve HRT\n", device_xname(sc->sc_dev));
    491  1.65        ad 		mutex_exit(&sc->sc_conflock);
    492   1.5        ad 		return;
    493   1.5        ad 	}
    494   1.1        ad 
    495   1.5        ad 	/*
    496   1.5        ad  	 * Build the system table.
    497   1.5        ad  	 */
    498   1.5        ad 	if (iop_systab == NULL) {
    499   1.5        ad 		for (i = 0, niop = 0; i < iop_cd.cd_ndevs; i++) {
    500  1.73   tsutsui 			if ((iop = device_lookup_private(&iop_cd, i)) == NULL)
    501   1.5        ad 				continue;
    502   1.5        ad 			if ((iop->sc_flags & IOP_HAVESTATUS) == 0)
    503   1.5        ad 				continue;
    504  1.11        ad 			if (iop_status_get(iop, 1) != 0) {
    505  1.82       chs 				aprint_error_dev(sc->sc_dev, "unable to retrieve status\n");
    506   1.5        ad 				iop->sc_flags &= ~IOP_HAVESTATUS;
    507   1.5        ad 				continue;
    508   1.5        ad 			}
    509   1.5        ad 			niop++;
    510   1.5        ad 		}
    511  1.65        ad 		if (niop == 0) {
    512  1.65        ad 			mutex_exit(&sc->sc_conflock);
    513   1.5        ad 			return;
    514  1.65        ad 		}
    515   1.5        ad 
    516   1.5        ad 		i = sizeof(struct i2o_systab_entry) * (niop - 1) +
    517   1.5        ad 		    sizeof(struct i2o_systab);
    518   1.5        ad 		iop_systab_size = i;
    519  1.22   tsutsui 		iop_systab = malloc(i, M_DEVBUF, M_NOWAIT|M_ZERO);
    520   1.5        ad 
    521   1.5        ad 		iop_systab->numentries = niop;
    522   1.5        ad 		iop_systab->version = I2O_VERSION_11;
    523   1.5        ad 
    524   1.5        ad 		for (i = 0, ste = iop_systab->entry; i < iop_cd.cd_ndevs; i++) {
    525  1.73   tsutsui 			if ((iop = device_lookup_private(&iop_cd, i)) == NULL)
    526   1.5        ad 				continue;
    527   1.5        ad 			if ((iop->sc_flags & IOP_HAVESTATUS) == 0)
    528   1.5        ad 				continue;
    529   1.5        ad 
    530   1.5        ad 			ste->orgid = iop->sc_status.orgid;
    531  1.82       chs 			ste->iopid = device_unit(iop->sc_dev) + 2;
    532   1.5        ad 			ste->segnumber =
    533   1.5        ad 			    htole32(le32toh(iop->sc_status.segnumber) & ~4095);
    534   1.5        ad 			ste->iopcaps = iop->sc_status.iopcaps;
    535   1.5        ad 			ste->inboundmsgframesize =
    536   1.5        ad 			    iop->sc_status.inboundmframesize;
    537   1.5        ad 			ste->inboundmsgportaddresslow =
    538   1.5        ad 			    htole32(iop->sc_memaddr + IOP_REG_IFIFO);
    539   1.5        ad 			ste++;
    540   1.5        ad 		}
    541   1.5        ad 	}
    542   1.5        ad 
    543  1.11        ad 	/*
    544  1.11        ad 	 * Post the system table to the IOP and bring it to the OPERATIONAL
    545  1.11        ad 	 * state.
    546  1.11        ad 	 */
    547   1.5        ad 	if (iop_systab_set(sc) != 0) {
    548  1.82       chs 		aprint_error_dev(sc->sc_dev, "unable to set system table\n");
    549  1.65        ad 		mutex_exit(&sc->sc_conflock);
    550   1.5        ad 		return;
    551   1.5        ad 	}
    552  1.42        ad 	if (iop_sys_enable(sc) != 0) {
    553  1.82       chs 		aprint_error_dev(sc->sc_dev, "unable to enable system\n");
    554  1.65        ad 		mutex_exit(&sc->sc_conflock);
    555   1.5        ad 		return;
    556   1.5        ad 	}
    557   1.5        ad 
    558   1.5        ad 	/*
    559   1.5        ad 	 * Set up an event handler for this IOP.
    560   1.5        ad 	 */
    561   1.5        ad 	sc->sc_eventii.ii_dv = self;
    562   1.5        ad 	sc->sc_eventii.ii_intr = iop_intr_event;
    563  1.15        ad 	sc->sc_eventii.ii_flags = II_NOTCTX | II_UTILITY;
    564   1.5        ad 	sc->sc_eventii.ii_tid = I2O_TID_IOP;
    565  1.11        ad 	iop_initiator_register(sc, &sc->sc_eventii);
    566  1.11        ad 
    567  1.11        ad 	rv = iop_util_eventreg(sc, &sc->sc_eventii,
    568  1.11        ad 	    I2O_EVENT_EXEC_RESOURCE_LIMITS |
    569  1.11        ad 	    I2O_EVENT_EXEC_CONNECTION_FAIL |
    570  1.11        ad 	    I2O_EVENT_EXEC_ADAPTER_FAULT |
    571  1.11        ad 	    I2O_EVENT_EXEC_POWER_FAIL |
    572  1.11        ad 	    I2O_EVENT_EXEC_RESET_PENDING |
    573  1.11        ad 	    I2O_EVENT_EXEC_RESET_IMMINENT |
    574  1.11        ad 	    I2O_EVENT_EXEC_HARDWARE_FAIL |
    575  1.11        ad 	    I2O_EVENT_EXEC_XCT_CHANGE |
    576  1.11        ad 	    I2O_EVENT_EXEC_DDM_AVAILIBILITY |
    577  1.11        ad 	    I2O_EVENT_GEN_DEVICE_RESET |
    578  1.11        ad 	    I2O_EVENT_GEN_STATE_CHANGE |
    579  1.11        ad 	    I2O_EVENT_GEN_GENERAL_WARNING);
    580  1.11        ad 	if (rv != 0) {
    581  1.82       chs 		aprint_error_dev(sc->sc_dev, "unable to register for events");
    582  1.65        ad 		mutex_exit(&sc->sc_conflock);
    583   1.5        ad 		return;
    584   1.5        ad 	}
    585   1.5        ad 
    586  1.18        ad 	/*
    587  1.18        ad 	 * Attempt to match and attach a product-specific extension.
    588  1.18        ad 	 */
    589   1.1        ad 	ia.ia_class = I2O_CLASS_ANY;
    590   1.1        ad 	ia.ia_tid = I2O_TID_IOP;
    591  1.49  drochner 	locs[IOPCF_TID] = I2O_TID_IOP;
    592  1.50  drochner 	config_found_sm_loc(self, "iop", locs, &ia, iop_print,
    593  1.50  drochner 		config_stdsubmatch);
    594   1.5        ad 
    595  1.18        ad 	/*
    596  1.18        ad 	 * Start device configuration.
    597  1.18        ad 	 */
    598  1.63        ad 	if ((rv = iop_reconfigure(sc, 0)) == -1)
    599  1.82       chs 		aprint_error_dev(sc->sc_dev, "configure failed (%d)\n", rv);
    600  1.65        ad 
    601   1.9        ad 
    602  1.11        ad 	sc->sc_flags |= IOP_ONLINE;
    603  1.66        ad 	rv = kthread_create(PRI_NONE, 0, NULL, iop_reconf_thread, sc,
    604  1.82       chs 	    &sc->sc_reconf_thread, "%s", device_xname(sc->sc_dev));
    605  1.65        ad 	mutex_exit(&sc->sc_conflock);
    606  1.11        ad  	if (rv != 0) {
    607  1.82       chs 		aprint_error_dev(sc->sc_dev, "unable to create reconfiguration thread (%d)", rv);
    608  1.11        ad  		return;
    609  1.11        ad  	}
    610   1.5        ad }
    611   1.5        ad 
    612   1.5        ad /*
    613   1.5        ad  * Reconfiguration thread; listens for LCT change notification, and
    614  1.14       wiz  * initiates re-configuration if received.
    615   1.5        ad  */
    616   1.5        ad static void
    617   1.9        ad iop_reconf_thread(void *cookie)
    618   1.5        ad {
    619   1.5        ad 	struct iop_softc *sc;
    620   1.5        ad 	struct i2o_lct lct;
    621   1.5        ad 	u_int32_t chgind;
    622  1.11        ad 	int rv;
    623   1.5        ad 
    624   1.5        ad 	sc = cookie;
    625  1.11        ad 	chgind = sc->sc_chgind + 1;
    626   1.5        ad 
    627   1.5        ad 	for (;;) {
    628  1.11        ad 		DPRINTF(("%s: async reconfig: requested 0x%08x\n",
    629  1.82       chs 		    device_xname(sc->sc_dev), chgind));
    630   1.5        ad 
    631  1.11        ad 		rv = iop_lct_get0(sc, &lct, sizeof(lct), chgind);
    632  1.11        ad 
    633  1.11        ad 		DPRINTF(("%s: async reconfig: notified (0x%08x, %d)\n",
    634  1.82       chs 		    device_xname(sc->sc_dev), le32toh(lct.changeindicator), rv));
    635  1.11        ad 
    636  1.65        ad 		mutex_enter(&sc->sc_conflock);
    637  1.63        ad 		if (rv == 0) {
    638  1.11        ad 			iop_reconfigure(sc, le32toh(lct.changeindicator));
    639  1.11        ad 			chgind = sc->sc_chgind + 1;
    640   1.5        ad 		}
    641  1.65        ad 		(void)cv_timedwait(&sc->sc_confcv, &sc->sc_conflock, hz * 5);
    642  1.65        ad 		mutex_exit(&sc->sc_conflock);
    643   1.5        ad 	}
    644   1.5        ad }
    645   1.5        ad 
    646   1.5        ad /*
    647   1.5        ad  * Reconfigure: find new and removed devices.
    648   1.5        ad  */
    649  1.18        ad int
    650  1.11        ad iop_reconfigure(struct iop_softc *sc, u_int chgind)
    651   1.5        ad {
    652   1.5        ad 	struct iop_msg *im;
    653  1.11        ad 	struct i2o_hba_bus_scan mf;
    654   1.5        ad 	struct i2o_lct_entry *le;
    655   1.5        ad 	struct iop_initiator *ii, *nextii;
    656   1.5        ad 	int rv, tid, i;
    657   1.5        ad 
    658  1.65        ad 	KASSERT(mutex_owned(&sc->sc_conflock));
    659  1.65        ad 
    660   1.1        ad 	/*
    661   1.5        ad 	 * If the reconfiguration request isn't the result of LCT change
    662   1.5        ad 	 * notification, then be more thorough: ask all bus ports to scan
    663   1.5        ad 	 * their busses.  Wait up to 5 minutes for each bus port to complete
    664   1.5        ad 	 * the request.
    665   1.1        ad 	 */
    666   1.5        ad 	if (chgind == 0) {
    667   1.5        ad 		if ((rv = iop_lct_get(sc)) != 0) {
    668   1.5        ad 			DPRINTF(("iop_reconfigure: unable to read LCT\n"));
    669  1.11        ad 			return (rv);
    670   1.5        ad 		}
    671   1.5        ad 
    672   1.5        ad 		le = sc->sc_lct->entry;
    673   1.5        ad 		for (i = 0; i < sc->sc_nlctent; i++, le++) {
    674   1.5        ad 			if ((le16toh(le->classid) & 4095) !=
    675   1.5        ad 			    I2O_CLASS_BUS_ADAPTER_PORT)
    676   1.5        ad 				continue;
    677  1.15        ad 			tid = le16toh(le->localtid) & 4095;
    678   1.5        ad 
    679  1.15        ad 			im = iop_msg_alloc(sc, IM_WAIT);
    680   1.5        ad 
    681  1.11        ad 			mf.msgflags = I2O_MSGFLAGS(i2o_hba_bus_scan);
    682  1.11        ad 			mf.msgfunc = I2O_MSGFUNC(tid, I2O_HBA_BUS_SCAN);
    683  1.11        ad 			mf.msgictx = IOP_ICTX;
    684  1.11        ad 			mf.msgtctx = im->im_tctx;
    685   1.5        ad 
    686  1.82       chs 			DPRINTF(("%s: scanning bus %d\n", device_xname(sc->sc_dev),
    687   1.5        ad 			    tid));
    688   1.5        ad 
    689  1.11        ad 			rv = iop_msg_post(sc, im, &mf, 5*60*1000);
    690  1.11        ad 			iop_msg_free(sc, im);
    691  1.11        ad #ifdef I2ODEBUG
    692  1.11        ad 			if (rv != 0)
    693  1.82       chs 				aprint_error_dev(sc->sc_dev, "bus scan failed\n");
    694  1.11        ad #endif
    695   1.5        ad 		}
    696  1.11        ad 	} else if (chgind <= sc->sc_chgind) {
    697  1.82       chs 		DPRINTF(("%s: LCT unchanged (async)\n", device_xname(sc->sc_dev)));
    698  1.11        ad 		return (0);
    699   1.5        ad 	}
    700   1.5        ad 
    701   1.5        ad 	/* Re-read the LCT and determine if it has changed. */
    702   1.5        ad 	if ((rv = iop_lct_get(sc)) != 0) {
    703   1.5        ad 		DPRINTF(("iop_reconfigure: unable to re-read LCT\n"));
    704  1.11        ad 		return (rv);
    705   1.5        ad 	}
    706  1.82       chs 	DPRINTF(("%s: %d LCT entries\n", device_xname(sc->sc_dev), sc->sc_nlctent));
    707   1.5        ad 
    708  1.11        ad 	chgind = le32toh(sc->sc_lct->changeindicator);
    709  1.11        ad 	if (chgind == sc->sc_chgind) {
    710  1.82       chs 		DPRINTF(("%s: LCT unchanged\n", device_xname(sc->sc_dev)));
    711  1.11        ad 		return (0);
    712   1.5        ad 	}
    713  1.82       chs 	DPRINTF(("%s: LCT changed\n", device_xname(sc->sc_dev)));
    714  1.11        ad 	sc->sc_chgind = chgind;
    715   1.5        ad 
    716   1.5        ad 	if (sc->sc_tidmap != NULL)
    717   1.5        ad 		free(sc->sc_tidmap, M_DEVBUF);
    718   1.5        ad 	sc->sc_tidmap = malloc(sc->sc_nlctent * sizeof(struct iop_tidmap),
    719  1.22   tsutsui 	    M_DEVBUF, M_NOWAIT|M_ZERO);
    720   1.5        ad 
    721  1.11        ad 	/* Allow 1 queued command per device while we're configuring. */
    722  1.11        ad 	iop_adjqparam(sc, 1);
    723  1.11        ad 
    724  1.11        ad 	/*
    725  1.11        ad 	 * Match and attach child devices.  We configure high-level devices
    726  1.11        ad 	 * first so that any claims will propagate throughout the LCT,
    727  1.11        ad 	 * hopefully masking off aliased devices as a result.
    728  1.11        ad 	 *
    729  1.11        ad 	 * Re-reading the LCT at this point is a little dangerous, but we'll
    730  1.11        ad 	 * trust the IOP (and the operator) to behave itself...
    731  1.11        ad 	 */
    732  1.11        ad 	iop_configure_devices(sc, IC_CONFIGURE | IC_PRIORITY,
    733  1.11        ad 	    IC_CONFIGURE | IC_PRIORITY);
    734  1.58  christos 	if ((rv = iop_lct_get(sc)) != 0) {
    735  1.11        ad 		DPRINTF(("iop_reconfigure: unable to re-read LCT\n"));
    736  1.58  christos 	}
    737  1.11        ad 	iop_configure_devices(sc, IC_CONFIGURE | IC_PRIORITY,
    738  1.11        ad 	    IC_CONFIGURE);
    739   1.5        ad 
    740   1.5        ad 	for (ii = LIST_FIRST(&sc->sc_iilist); ii != NULL; ii = nextii) {
    741  1.11        ad 		nextii = LIST_NEXT(ii, ii_list);
    742   1.5        ad 
    743   1.5        ad 		/* Detach devices that were configured, but are now gone. */
    744   1.5        ad 		for (i = 0; i < sc->sc_nlctent; i++)
    745   1.5        ad 			if (ii->ii_tid == sc->sc_tidmap[i].it_tid)
    746   1.5        ad 				break;
    747   1.5        ad 		if (i == sc->sc_nlctent ||
    748  1.52    bouyer 		    (sc->sc_tidmap[i].it_flags & IT_CONFIGURED) == 0) {
    749   1.5        ad 			config_detach(ii->ii_dv, DETACH_FORCE);
    750  1.52    bouyer 			continue;
    751  1.52    bouyer 		}
    752   1.5        ad 
    753   1.5        ad 		/*
    754   1.5        ad 		 * Tell initiators that existed before the re-configuration
    755   1.5        ad 		 * to re-configure.
    756   1.5        ad 		 */
    757   1.5        ad 		if (ii->ii_reconfig == NULL)
    758   1.5        ad 			continue;
    759   1.5        ad 		if ((rv = (*ii->ii_reconfig)(ii->ii_dv)) != 0)
    760  1.82       chs 			aprint_error_dev(sc->sc_dev, "%s failed reconfigure (%d)\n",
    761  1.69    cegger 			    device_xname(ii->ii_dv), rv);
    762   1.5        ad 	}
    763   1.5        ad 
    764  1.11        ad 	/* Re-adjust queue parameters and return. */
    765  1.11        ad 	if (sc->sc_nii != 0)
    766  1.11        ad 		iop_adjqparam(sc, (sc->sc_maxib - sc->sc_nuii - IOP_MF_RESERVE)
    767  1.11        ad 		    / sc->sc_nii);
    768  1.11        ad 
    769  1.11        ad 	return (0);
    770   1.1        ad }
    771   1.1        ad 
    772   1.1        ad /*
    773   1.5        ad  * Configure I2O devices into the system.
    774   1.1        ad  */
    775   1.1        ad static void
    776  1.11        ad iop_configure_devices(struct iop_softc *sc, int mask, int maskval)
    777   1.1        ad {
    778   1.1        ad 	struct iop_attach_args ia;
    779   1.5        ad 	struct iop_initiator *ii;
    780   1.1        ad 	const struct i2o_lct_entry *le;
    781  1.76    cegger 	device_t dv;
    782   1.8        ad 	int i, j, nent;
    783  1.11        ad 	u_int usertid;
    784  1.49  drochner 	int locs[IOPCF_NLOCS];
    785   1.1        ad 
    786   1.1        ad 	nent = sc->sc_nlctent;
    787   1.1        ad 	for (i = 0, le = sc->sc_lct->entry; i < nent; i++, le++) {
    788  1.15        ad 		sc->sc_tidmap[i].it_tid = le16toh(le->localtid) & 4095;
    789   1.9        ad 
    790  1.11        ad 		/* Ignore the device if it's in use. */
    791  1.11        ad 		usertid = le32toh(le->usertid) & 4095;
    792  1.11        ad 		if (usertid != I2O_TID_NONE && usertid != I2O_TID_HOST)
    793   1.1        ad 			continue;
    794   1.1        ad 
    795   1.1        ad 		ia.ia_class = le16toh(le->classid) & 4095;
    796   1.9        ad 		ia.ia_tid = sc->sc_tidmap[i].it_tid;
    797   1.8        ad 
    798   1.8        ad 		/* Ignore uninteresting devices. */
    799   1.8        ad 		for (j = 0; j < sizeof(iop_class) / sizeof(iop_class[0]); j++)
    800   1.8        ad 			if (iop_class[j].ic_class == ia.ia_class)
    801   1.8        ad 				break;
    802   1.8        ad 		if (j < sizeof(iop_class) / sizeof(iop_class[0]) &&
    803  1.11        ad 		    (iop_class[j].ic_flags & mask) != maskval)
    804   1.8        ad 			continue;
    805   1.1        ad 
    806   1.1        ad 		/*
    807   1.5        ad 		 * Try to configure the device only if it's not already
    808   1.5        ad 		 * configured.
    809   1.1        ad  		 */
    810   1.7        ad  		LIST_FOREACH(ii, &sc->sc_iilist, ii_list) {
    811   1.9        ad  			if (ia.ia_tid == ii->ii_tid) {
    812   1.9        ad 				sc->sc_tidmap[i].it_flags |= IT_CONFIGURED;
    813   1.9        ad 				strcpy(sc->sc_tidmap[i].it_dvname,
    814  1.69    cegger 				    device_xname(ii->ii_dv));
    815  1.11        ad  				break;
    816   1.9        ad 			}
    817   1.7        ad 		}
    818   1.5        ad 		if (ii != NULL)
    819   1.5        ad 			continue;
    820   1.5        ad 
    821  1.49  drochner 		locs[IOPCF_TID] = ia.ia_tid;
    822  1.44  drochner 
    823  1.82       chs 		dv = config_found_sm_loc(sc->sc_dev, "iop", locs, &ia,
    824  1.50  drochner 					 iop_print, config_stdsubmatch);
    825   1.9        ad 		if (dv != NULL) {
    826  1.11        ad  			sc->sc_tidmap[i].it_flags |= IT_CONFIGURED;
    827  1.69    cegger 			strcpy(sc->sc_tidmap[i].it_dvname, device_xname(dv));
    828   1.9        ad 		}
    829   1.1        ad 	}
    830   1.1        ad }
    831   1.1        ad 
    832  1.11        ad /*
    833  1.11        ad  * Adjust queue parameters for all child devices.
    834  1.11        ad  */
    835  1.11        ad static void
    836  1.11        ad iop_adjqparam(struct iop_softc *sc, int mpi)
    837  1.11        ad {
    838  1.11        ad 	struct iop_initiator *ii;
    839  1.11        ad 
    840  1.11        ad 	LIST_FOREACH(ii, &sc->sc_iilist, ii_list)
    841  1.11        ad 		if (ii->ii_adjqparam != NULL)
    842  1.11        ad 			(*ii->ii_adjqparam)(ii->ii_dv, mpi);
    843  1.11        ad }
    844  1.11        ad 
    845   1.1        ad static void
    846  1.43    itojun iop_devinfo(int class, char *devinfo, size_t l)
    847   1.1        ad {
    848   1.1        ad 	int i;
    849   1.1        ad 
    850   1.1        ad 	for (i = 0; i < sizeof(iop_class) / sizeof(iop_class[0]); i++)
    851   1.1        ad 		if (class == iop_class[i].ic_class)
    852   1.1        ad 			break;
    853  1.47     perry 
    854   1.1        ad 	if (i == sizeof(iop_class) / sizeof(iop_class[0]))
    855  1.43    itojun 		snprintf(devinfo, l, "device (class 0x%x)", class);
    856   1.1        ad 	else
    857  1.43    itojun 		strlcpy(devinfo, iop_class[i].ic_caption, l);
    858   1.1        ad }
    859   1.1        ad 
    860   1.1        ad static int
    861   1.1        ad iop_print(void *aux, const char *pnp)
    862   1.1        ad {
    863   1.1        ad 	struct iop_attach_args *ia;
    864   1.1        ad 	char devinfo[256];
    865   1.1        ad 
    866   1.1        ad 	ia = aux;
    867   1.1        ad 
    868   1.1        ad 	if (pnp != NULL) {
    869  1.43    itojun 		iop_devinfo(ia->ia_class, devinfo, sizeof(devinfo));
    870  1.33   thorpej 		aprint_normal("%s at %s", devinfo, pnp);
    871   1.1        ad 	}
    872  1.33   thorpej 	aprint_normal(" tid %d", ia->ia_tid);
    873   1.1        ad 	return (UNCONF);
    874   1.1        ad }
    875   1.1        ad 
    876   1.1        ad /*
    877   1.1        ad  * Shut down all configured IOPs.
    878  1.47     perry  */
    879   1.1        ad static void
    880  1.61  christos iop_shutdown(void *junk)
    881   1.1        ad {
    882   1.1        ad 	struct iop_softc *sc;
    883   1.1        ad 	int i;
    884   1.1        ad 
    885  1.11        ad 	printf("shutting down iop devices...");
    886   1.1        ad 
    887   1.1        ad 	for (i = 0; i < iop_cd.cd_ndevs; i++) {
    888  1.73   tsutsui 		if ((sc = device_lookup_private(&iop_cd, i)) == NULL)
    889   1.1        ad 			continue;
    890   1.5        ad 		if ((sc->sc_flags & IOP_ONLINE) == 0)
    891   1.5        ad 			continue;
    892  1.27        ad 
    893   1.5        ad 		iop_simple_cmd(sc, I2O_TID_IOP, I2O_EXEC_SYS_QUIESCE, IOP_ICTX,
    894  1.12        ad 		    0, 5000);
    895  1.27        ad 
    896  1.27        ad 		if (le16toh(sc->sc_status.orgid) != I2O_ORG_AMI) {
    897  1.27        ad 			/*
    898  1.27        ad 			 * Some AMI firmware revisions will go to sleep and
    899  1.27        ad 			 * never come back after this.
    900  1.27        ad 			 */
    901  1.27        ad 			iop_simple_cmd(sc, I2O_TID_IOP, I2O_EXEC_IOP_CLEAR,
    902  1.27        ad 			    IOP_ICTX, 0, 1000);
    903  1.27        ad 		}
    904   1.1        ad 	}
    905   1.1        ad 
    906   1.1        ad 	/* Wait.  Some boards could still be flushing, stupidly enough. */
    907   1.1        ad 	delay(5000*1000);
    908  1.18        ad 	printf(" done\n");
    909   1.1        ad }
    910   1.1        ad 
    911   1.1        ad /*
    912  1.11        ad  * Retrieve IOP status.
    913   1.1        ad  */
    914  1.18        ad int
    915  1.11        ad iop_status_get(struct iop_softc *sc, int nosleep)
    916   1.1        ad {
    917  1.11        ad 	struct i2o_exec_status_get mf;
    918  1.15        ad 	struct i2o_status *st;
    919  1.15        ad 	paddr_t pa;
    920  1.11        ad 	int rv, i;
    921   1.1        ad 
    922  1.75    mhitch 	pa = sc->sc_scr_dmamap->dm_segs[0].ds_addr;
    923  1.15        ad 	st = (struct i2o_status *)sc->sc_scr;
    924  1.15        ad 
    925  1.11        ad 	mf.msgflags = I2O_MSGFLAGS(i2o_exec_status_get);
    926  1.11        ad 	mf.msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_STATUS_GET);
    927  1.11        ad 	mf.reserved[0] = 0;
    928  1.11        ad 	mf.reserved[1] = 0;
    929  1.11        ad 	mf.reserved[2] = 0;
    930  1.11        ad 	mf.reserved[3] = 0;
    931  1.15        ad 	mf.addrlow = (u_int32_t)pa;
    932  1.15        ad 	mf.addrhigh = (u_int32_t)((u_int64_t)pa >> 32);
    933  1.11        ad 	mf.length = sizeof(sc->sc_status);
    934   1.1        ad 
    935  1.72        ad 	bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*st),
    936  1.72        ad 	    BUS_DMASYNC_PREWRITE);
    937  1.15        ad 	memset(st, 0, sizeof(*st));
    938  1.15        ad 	bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*st),
    939  1.78      asau 	    BUS_DMASYNC_POSTWRITE);
    940   1.1        ad 
    941  1.11        ad 	if ((rv = iop_post(sc, (u_int32_t *)&mf)) != 0)
    942   1.1        ad 		return (rv);
    943   1.1        ad 
    944  1.72        ad 	for (i = 100; i != 0; i--) {
    945  1.15        ad 		bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0,
    946  1.15        ad 		    sizeof(*st), BUS_DMASYNC_POSTREAD);
    947  1.15        ad 		if (st->syncbyte == 0xff)
    948  1.11        ad 			break;
    949  1.11        ad 		if (nosleep)
    950  1.11        ad 			DELAY(100*1000);
    951  1.11        ad 		else
    952  1.65        ad 			kpause("iopstat", false, hz / 10, NULL);
    953  1.11        ad 	}
    954   1.1        ad 
    955  1.21        ad 	if (st->syncbyte != 0xff) {
    956  1.82       chs 		aprint_error_dev(sc->sc_dev, "STATUS_GET timed out\n");
    957  1.11        ad 		rv = EIO;
    958  1.21        ad 	} else {
    959  1.15        ad 		memcpy(&sc->sc_status, st, sizeof(sc->sc_status));
    960  1.11        ad 		rv = 0;
    961  1.15        ad 	}
    962  1.15        ad 
    963  1.11        ad 	return (rv);
    964   1.1        ad }
    965   1.1        ad 
    966   1.1        ad /*
    967  1.17       wiz  * Initialize and populate the IOP's outbound FIFO.
    968   1.1        ad  */
    969   1.1        ad static int
    970   1.1        ad iop_ofifo_init(struct iop_softc *sc)
    971   1.1        ad {
    972   1.1        ad 	bus_addr_t addr;
    973   1.5        ad 	bus_dma_segment_t seg;
    974  1.11        ad 	struct i2o_exec_outbound_init *mf;
    975   1.5        ad 	int i, rseg, rv;
    976  1.15        ad 	u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)], *sw;
    977   1.1        ad 
    978  1.15        ad 	sw = (u_int32_t *)sc->sc_scr;
    979   1.1        ad 
    980  1.11        ad 	mf = (struct i2o_exec_outbound_init *)mb;
    981  1.11        ad 	mf->msgflags = I2O_MSGFLAGS(i2o_exec_outbound_init);
    982  1.11        ad 	mf->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_OUTBOUND_INIT);
    983  1.11        ad 	mf->msgictx = IOP_ICTX;
    984  1.15        ad 	mf->msgtctx = 0;
    985  1.11        ad 	mf->pagesize = PAGE_SIZE;
    986  1.19        ad 	mf->flags = IOP_INIT_CODE | ((sc->sc_framesize >> 2) << 16);
    987   1.1        ad 
    988   1.5        ad 	/*
    989   1.5        ad 	 * The I2O spec says that there are two SGLs: one for the status
    990   1.5        ad 	 * word, and one for a list of discarded MFAs.  It continues to say
    991   1.5        ad 	 * that if you don't want to get the list of MFAs, an IGNORE SGL is
    992  1.11        ad 	 * necessary; this isn't the case (and is in fact a bad thing).
    993   1.5        ad 	 */
    994  1.15        ad 	mb[sizeof(*mf) / sizeof(u_int32_t) + 0] = sizeof(*sw) |
    995  1.15        ad 	    I2O_SGL_SIMPLE | I2O_SGL_END_BUFFER | I2O_SGL_END;
    996  1.15        ad 	mb[sizeof(*mf) / sizeof(u_int32_t) + 1] =
    997  1.75    mhitch 	    (u_int32_t)sc->sc_scr_dmamap->dm_segs[0].ds_addr;
    998  1.15        ad 	mb[0] += 2 << 16;
    999  1.15        ad 
   1000  1.72        ad 	bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
   1001  1.80    bouyer 	    BUS_DMASYNC_POSTWRITE);
   1002  1.15        ad 	*sw = 0;
   1003  1.15        ad 	bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
   1004  1.80    bouyer 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
   1005  1.15        ad 
   1006  1.15        ad 	if ((rv = iop_post(sc, mb)) != 0)
   1007   1.1        ad 		return (rv);
   1008   1.1        ad 
   1009  1.15        ad 	POLL(5000,
   1010  1.15        ad 	    (bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
   1011  1.80    bouyer 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD),
   1012  1.15        ad 	    *sw == htole32(I2O_EXEC_OUTBOUND_INIT_COMPLETE)));
   1013  1.15        ad 
   1014  1.15        ad 	if (*sw != htole32(I2O_EXEC_OUTBOUND_INIT_COMPLETE)) {
   1015  1.82       chs 		aprint_error_dev(sc->sc_dev, "outbound FIFO init failed (%d)\n",
   1016  1.69    cegger 		    le32toh(*sw));
   1017   1.5        ad 		return (EIO);
   1018   1.1        ad 	}
   1019   1.1        ad 
   1020  1.11        ad 	/* Allocate DMA safe memory for the reply frames. */
   1021   1.1        ad 	if (sc->sc_rep_phys == 0) {
   1022  1.19        ad 		sc->sc_rep_size = sc->sc_maxob * sc->sc_framesize;
   1023   1.5        ad 
   1024   1.5        ad 		rv = bus_dmamem_alloc(sc->sc_dmat, sc->sc_rep_size, PAGE_SIZE,
   1025   1.5        ad 		    0, &seg, 1, &rseg, BUS_DMA_NOWAIT);
   1026   1.5        ad 		if (rv != 0) {
   1027  1.82       chs 			aprint_error_dev(sc->sc_dev, "DMA alloc = %d\n",
   1028   1.5        ad 			   rv);
   1029   1.5        ad 			return (rv);
   1030   1.5        ad 		}
   1031   1.5        ad 
   1032   1.5        ad 		rv = bus_dmamem_map(sc->sc_dmat, &seg, rseg, sc->sc_rep_size,
   1033   1.5        ad 		    &sc->sc_rep, BUS_DMA_NOWAIT | BUS_DMA_COHERENT);
   1034   1.5        ad 		if (rv != 0) {
   1035  1.82       chs 			aprint_error_dev(sc->sc_dev, "DMA map = %d\n", rv);
   1036   1.5        ad 			return (rv);
   1037   1.5        ad 		}
   1038   1.5        ad 
   1039   1.5        ad 		rv = bus_dmamap_create(sc->sc_dmat, sc->sc_rep_size, 1,
   1040   1.5        ad 		    sc->sc_rep_size, 0, BUS_DMA_NOWAIT, &sc->sc_rep_dmamap);
   1041   1.5        ad 		if (rv != 0) {
   1042  1.82       chs 			aprint_error_dev(sc->sc_dev, "DMA create = %d\n", rv);
   1043   1.5        ad 			return (rv);
   1044   1.5        ad 		}
   1045   1.5        ad 
   1046  1.15        ad 		rv = bus_dmamap_load(sc->sc_dmat, sc->sc_rep_dmamap,
   1047  1.15        ad 		    sc->sc_rep, sc->sc_rep_size, NULL, BUS_DMA_NOWAIT);
   1048   1.5        ad 		if (rv != 0) {
   1049  1.82       chs 			aprint_error_dev(sc->sc_dev, "DMA load = %d\n", rv);
   1050   1.5        ad 			return (rv);
   1051   1.5        ad 		}
   1052   1.5        ad 
   1053   1.5        ad 		sc->sc_rep_phys = sc->sc_rep_dmamap->dm_segs[0].ds_addr;
   1054  1.65        ad 
   1055  1.65        ad 		/* Now safe to sync the reply map. */
   1056  1.65        ad 		sc->sc_curib = 0;
   1057   1.1        ad 	}
   1058   1.1        ad 
   1059   1.1        ad 	/* Populate the outbound FIFO. */
   1060  1.11        ad 	for (i = sc->sc_maxob, addr = sc->sc_rep_phys; i != 0; i--) {
   1061   1.5        ad 		iop_outl(sc, IOP_REG_OFIFO, (u_int32_t)addr);
   1062  1.19        ad 		addr += sc->sc_framesize;
   1063   1.1        ad 	}
   1064   1.1        ad 
   1065   1.1        ad 	return (0);
   1066   1.1        ad }
   1067   1.1        ad 
   1068   1.1        ad /*
   1069   1.1        ad  * Read the specified number of bytes from the IOP's hardware resource table.
   1070   1.1        ad  */
   1071   1.1        ad static int
   1072   1.1        ad iop_hrt_get0(struct iop_softc *sc, struct i2o_hrt *hrt, int size)
   1073   1.1        ad {
   1074   1.1        ad 	struct iop_msg *im;
   1075   1.1        ad 	int rv;
   1076  1.11        ad 	struct i2o_exec_hrt_get *mf;
   1077  1.11        ad 	u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
   1078   1.1        ad 
   1079  1.15        ad 	im = iop_msg_alloc(sc, IM_WAIT);
   1080  1.11        ad 	mf = (struct i2o_exec_hrt_get *)mb;
   1081  1.11        ad 	mf->msgflags = I2O_MSGFLAGS(i2o_exec_hrt_get);
   1082  1.11        ad 	mf->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_HRT_GET);
   1083  1.11        ad 	mf->msgictx = IOP_ICTX;
   1084  1.11        ad 	mf->msgtctx = im->im_tctx;
   1085   1.1        ad 
   1086  1.15        ad 	iop_msg_map(sc, im, mb, hrt, size, 0, NULL);
   1087  1.11        ad 	rv = iop_msg_post(sc, im, mb, 30000);
   1088   1.1        ad 	iop_msg_unmap(sc, im);
   1089  1.11        ad 	iop_msg_free(sc, im);
   1090   1.1        ad 	return (rv);
   1091   1.1        ad }
   1092   1.1        ad 
   1093   1.1        ad /*
   1094   1.5        ad  * Read the IOP's hardware resource table.
   1095   1.1        ad  */
   1096   1.1        ad static int
   1097   1.1        ad iop_hrt_get(struct iop_softc *sc)
   1098   1.1        ad {
   1099   1.1        ad 	struct i2o_hrt hrthdr, *hrt;
   1100   1.1        ad 	int size, rv;
   1101   1.1        ad 
   1102  1.11        ad 	rv = iop_hrt_get0(sc, &hrthdr, sizeof(hrthdr));
   1103  1.11        ad 	if (rv != 0)
   1104   1.1        ad 		return (rv);
   1105   1.1        ad 
   1106  1.82       chs 	DPRINTF(("%s: %d hrt entries\n", device_xname(sc->sc_dev),
   1107   1.5        ad 	    le16toh(hrthdr.numentries)));
   1108   1.5        ad 
   1109  1.47     perry 	size = sizeof(struct i2o_hrt) +
   1110  1.15        ad 	    (le16toh(hrthdr.numentries) - 1) * sizeof(struct i2o_hrt_entry);
   1111   1.1        ad 	hrt = (struct i2o_hrt *)malloc(size, M_DEVBUF, M_NOWAIT);
   1112   1.1        ad 
   1113   1.1        ad 	if ((rv = iop_hrt_get0(sc, hrt, size)) != 0) {
   1114   1.1        ad 		free(hrt, M_DEVBUF);
   1115   1.1        ad 		return (rv);
   1116   1.1        ad 	}
   1117   1.1        ad 
   1118   1.1        ad 	if (sc->sc_hrt != NULL)
   1119   1.1        ad 		free(sc->sc_hrt, M_DEVBUF);
   1120   1.1        ad 	sc->sc_hrt = hrt;
   1121   1.1        ad 	return (0);
   1122   1.1        ad }
   1123   1.1        ad 
   1124   1.1        ad /*
   1125   1.1        ad  * Request the specified number of bytes from the IOP's logical
   1126   1.5        ad  * configuration table.  If a change indicator is specified, this
   1127  1.11        ad  * is a verbatim notification request, so the caller is prepared
   1128   1.5        ad  * to wait indefinitely.
   1129   1.1        ad  */
   1130   1.1        ad static int
   1131   1.5        ad iop_lct_get0(struct iop_softc *sc, struct i2o_lct *lct, int size,
   1132   1.5        ad 	     u_int32_t chgind)
   1133   1.1        ad {
   1134   1.1        ad 	struct iop_msg *im;
   1135  1.11        ad 	struct i2o_exec_lct_notify *mf;
   1136   1.1        ad 	int rv;
   1137  1.11        ad 	u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
   1138   1.1        ad 
   1139  1.15        ad 	im = iop_msg_alloc(sc, IM_WAIT);
   1140   1.1        ad 	memset(lct, 0, size);
   1141   1.1        ad 
   1142  1.11        ad 	mf = (struct i2o_exec_lct_notify *)mb;
   1143  1.11        ad 	mf->msgflags = I2O_MSGFLAGS(i2o_exec_lct_notify);
   1144  1.11        ad 	mf->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_LCT_NOTIFY);
   1145  1.11        ad 	mf->msgictx = IOP_ICTX;
   1146  1.11        ad 	mf->msgtctx = im->im_tctx;
   1147  1.11        ad 	mf->classid = I2O_CLASS_ANY;
   1148  1.11        ad 	mf->changeindicator = chgind;
   1149   1.5        ad 
   1150   1.9        ad #ifdef I2ODEBUG
   1151   1.9        ad 	printf("iop_lct_get0: reading LCT");
   1152   1.9        ad 	if (chgind != 0)
   1153   1.9        ad 		printf(" (async)");
   1154   1.9        ad 	printf("\n");
   1155   1.9        ad #endif
   1156   1.1        ad 
   1157  1.15        ad 	iop_msg_map(sc, im, mb, lct, size, 0, NULL);
   1158  1.11        ad 	rv = iop_msg_post(sc, im, mb, (chgind == 0 ? 120*1000 : 0));
   1159   1.1        ad 	iop_msg_unmap(sc, im);
   1160  1.11        ad 	iop_msg_free(sc, im);
   1161   1.1        ad 	return (rv);
   1162   1.1        ad }
   1163   1.1        ad 
   1164   1.1        ad /*
   1165   1.6        ad  * Read the IOP's logical configuration table.
   1166   1.1        ad  */
   1167   1.1        ad int
   1168   1.1        ad iop_lct_get(struct iop_softc *sc)
   1169   1.1        ad {
   1170   1.5        ad 	int esize, size, rv;
   1171   1.5        ad 	struct i2o_lct *lct;
   1172   1.1        ad 
   1173   1.5        ad 	esize = le32toh(sc->sc_status.expectedlctsize);
   1174   1.5        ad 	lct = (struct i2o_lct *)malloc(esize, M_DEVBUF, M_WAITOK);
   1175   1.5        ad 	if (lct == NULL)
   1176   1.1        ad 		return (ENOMEM);
   1177   1.1        ad 
   1178   1.5        ad 	if ((rv = iop_lct_get0(sc, lct, esize, 0)) != 0) {
   1179   1.1        ad 		free(lct, M_DEVBUF);
   1180   1.1        ad 		return (rv);
   1181   1.1        ad 	}
   1182   1.1        ad 
   1183   1.5        ad 	size = le16toh(lct->tablesize) << 2;
   1184   1.5        ad 	if (esize != size) {
   1185   1.1        ad 		free(lct, M_DEVBUF);
   1186   1.5        ad 		lct = (struct i2o_lct *)malloc(size, M_DEVBUF, M_WAITOK);
   1187   1.5        ad 		if (lct == NULL)
   1188   1.5        ad 			return (ENOMEM);
   1189   1.5        ad 
   1190   1.5        ad 		if ((rv = iop_lct_get0(sc, lct, size, 0)) != 0) {
   1191   1.5        ad 			free(lct, M_DEVBUF);
   1192   1.5        ad 			return (rv);
   1193   1.5        ad 		}
   1194   1.1        ad 	}
   1195   1.5        ad 
   1196   1.5        ad 	/* Swap in the new LCT. */
   1197   1.1        ad 	if (sc->sc_lct != NULL)
   1198   1.1        ad 		free(sc->sc_lct, M_DEVBUF);
   1199   1.1        ad 	sc->sc_lct = lct;
   1200   1.1        ad 	sc->sc_nlctent = ((le16toh(sc->sc_lct->tablesize) << 2) -
   1201   1.1        ad 	    sizeof(struct i2o_lct) + sizeof(struct i2o_lct_entry)) /
   1202   1.1        ad 	    sizeof(struct i2o_lct_entry);
   1203   1.1        ad 	return (0);
   1204   1.1        ad }
   1205   1.1        ad 
   1206   1.1        ad /*
   1207  1.42        ad  * Post a SYS_ENABLE message to the adapter.
   1208  1.42        ad  */
   1209  1.42        ad int
   1210  1.42        ad iop_sys_enable(struct iop_softc *sc)
   1211  1.42        ad {
   1212  1.42        ad 	struct iop_msg *im;
   1213  1.42        ad 	struct i2o_msg mf;
   1214  1.42        ad 	int rv;
   1215  1.42        ad 
   1216  1.42        ad 	im = iop_msg_alloc(sc, IM_WAIT | IM_NOSTATUS);
   1217  1.42        ad 
   1218  1.42        ad 	mf.msgflags = I2O_MSGFLAGS(i2o_msg);
   1219  1.42        ad 	mf.msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_SYS_ENABLE);
   1220  1.42        ad 	mf.msgictx = IOP_ICTX;
   1221  1.42        ad 	mf.msgtctx = im->im_tctx;
   1222  1.42        ad 
   1223  1.42        ad 	rv = iop_msg_post(sc, im, &mf, 30000);
   1224  1.42        ad 	if (rv == 0) {
   1225  1.42        ad 		if ((im->im_flags & IM_FAIL) != 0)
   1226  1.42        ad 			rv = ENXIO;
   1227  1.42        ad 		else if (im->im_reqstatus == I2O_STATUS_SUCCESS ||
   1228  1.42        ad 		    (im->im_reqstatus == I2O_STATUS_ERROR_NO_DATA_XFER &&
   1229  1.42        ad 		    im->im_detstatus == I2O_DSC_INVALID_REQUEST))
   1230  1.42        ad 			rv = 0;
   1231  1.42        ad 		else
   1232  1.42        ad 			rv = EIO;
   1233  1.42        ad 	}
   1234  1.42        ad 
   1235  1.42        ad 	iop_msg_free(sc, im);
   1236  1.42        ad 	return (rv);
   1237  1.42        ad }
   1238  1.42        ad 
   1239  1.42        ad /*
   1240  1.11        ad  * Request the specified parameter group from the target.  If an initiator
   1241  1.11        ad  * is specified (a) don't wait for the operation to complete, but instead
   1242  1.11        ad  * let the initiator's interrupt handler deal with the reply and (b) place a
   1243  1.11        ad  * pointer to the parameter group op in the wrapper's `im_dvcontext' field.
   1244   1.1        ad  */
   1245   1.1        ad int
   1246  1.16        ad iop_field_get_all(struct iop_softc *sc, int tid, int group, void *buf,
   1247  1.16        ad 		  int size, struct iop_initiator *ii)
   1248   1.1        ad {
   1249   1.1        ad 	struct iop_msg *im;
   1250  1.11        ad 	struct i2o_util_params_op *mf;
   1251  1.16        ad 	int rv;
   1252  1.11        ad 	struct iop_pgop *pgop;
   1253  1.11        ad 	u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
   1254   1.1        ad 
   1255  1.15        ad 	im = iop_msg_alloc(sc, (ii == NULL ? IM_WAIT : 0) | IM_NOSTATUS);
   1256  1.11        ad 	if ((pgop = malloc(sizeof(*pgop), M_DEVBUF, M_WAITOK)) == NULL) {
   1257  1.11        ad 		iop_msg_free(sc, im);
   1258  1.11        ad 		return (ENOMEM);
   1259  1.11        ad 	}
   1260  1.11        ad 	im->im_dvcontext = pgop;
   1261   1.1        ad 
   1262  1.11        ad 	mf = (struct i2o_util_params_op *)mb;
   1263  1.11        ad 	mf->msgflags = I2O_MSGFLAGS(i2o_util_params_op);
   1264  1.16        ad 	mf->msgfunc = I2O_MSGFUNC(tid, I2O_UTIL_PARAMS_GET);
   1265  1.11        ad 	mf->msgictx = IOP_ICTX;
   1266  1.11        ad 	mf->msgtctx = im->im_tctx;
   1267  1.11        ad 	mf->flags = 0;
   1268  1.11        ad 
   1269  1.11        ad 	pgop->olh.count = htole16(1);
   1270  1.11        ad 	pgop->olh.reserved = htole16(0);
   1271  1.16        ad 	pgop->oat.operation = htole16(I2O_PARAMS_OP_FIELD_GET);
   1272  1.11        ad 	pgop->oat.fieldcount = htole16(0xffff);
   1273  1.11        ad 	pgop->oat.group = htole16(group);
   1274  1.11        ad 
   1275   1.5        ad 	memset(buf, 0, size);
   1276  1.15        ad 	iop_msg_map(sc, im, mb, pgop, sizeof(*pgop), 1, NULL);
   1277  1.16        ad 	iop_msg_map(sc, im, mb, buf, size, 0, NULL);
   1278  1.11        ad 	rv = iop_msg_post(sc, im, mb, (ii == NULL ? 30000 : 0));
   1279  1.11        ad 
   1280  1.11        ad 	/* Detect errors; let partial transfers to count as success. */
   1281  1.11        ad 	if (ii == NULL && rv == 0) {
   1282  1.42        ad 		if (im->im_reqstatus == I2O_STATUS_ERROR_PARTIAL_XFER &&
   1283  1.42        ad 		    im->im_detstatus == I2O_DSC_UNKNOWN_ERROR)
   1284  1.11        ad 			rv = 0;
   1285  1.11        ad 		else
   1286  1.42        ad 			rv = (im->im_reqstatus != 0 ? EIO : 0);
   1287  1.16        ad 
   1288  1.16        ad 		if (rv != 0)
   1289  1.16        ad 			printf("%s: FIELD_GET failed for tid %d group %d\n",
   1290  1.82       chs 			    device_xname(sc->sc_dev), tid, group);
   1291  1.11        ad 	}
   1292  1.11        ad 
   1293  1.11        ad 	if (ii == NULL || rv != 0) {
   1294  1.11        ad 		iop_msg_unmap(sc, im);
   1295  1.11        ad 		iop_msg_free(sc, im);
   1296  1.11        ad 		free(pgop, M_DEVBUF);
   1297  1.11        ad 	}
   1298   1.1        ad 
   1299   1.1        ad 	return (rv);
   1300  1.11        ad }
   1301   1.1        ad 
   1302   1.1        ad /*
   1303  1.16        ad  * Set a single field in a scalar parameter group.
   1304  1.16        ad  */
   1305  1.16        ad int
   1306  1.16        ad iop_field_set(struct iop_softc *sc, int tid, int group, void *buf,
   1307  1.16        ad 	      int size, int field)
   1308  1.16        ad {
   1309  1.16        ad 	struct iop_msg *im;
   1310  1.16        ad 	struct i2o_util_params_op *mf;
   1311  1.16        ad 	struct iop_pgop *pgop;
   1312  1.16        ad 	int rv, totsize;
   1313  1.16        ad 	u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
   1314  1.16        ad 
   1315  1.16        ad 	totsize = sizeof(*pgop) + size;
   1316  1.16        ad 
   1317  1.16        ad 	im = iop_msg_alloc(sc, IM_WAIT);
   1318  1.16        ad 	if ((pgop = malloc(totsize, M_DEVBUF, M_WAITOK)) == NULL) {
   1319  1.16        ad 		iop_msg_free(sc, im);
   1320  1.16        ad 		return (ENOMEM);
   1321  1.16        ad 	}
   1322  1.16        ad 
   1323  1.16        ad 	mf = (struct i2o_util_params_op *)mb;
   1324  1.16        ad 	mf->msgflags = I2O_MSGFLAGS(i2o_util_params_op);
   1325  1.16        ad 	mf->msgfunc = I2O_MSGFUNC(tid, I2O_UTIL_PARAMS_SET);
   1326  1.16        ad 	mf->msgictx = IOP_ICTX;
   1327  1.16        ad 	mf->msgtctx = im->im_tctx;
   1328  1.16        ad 	mf->flags = 0;
   1329  1.16        ad 
   1330  1.16        ad 	pgop->olh.count = htole16(1);
   1331  1.16        ad 	pgop->olh.reserved = htole16(0);
   1332  1.16        ad 	pgop->oat.operation = htole16(I2O_PARAMS_OP_FIELD_SET);
   1333  1.16        ad 	pgop->oat.fieldcount = htole16(1);
   1334  1.16        ad 	pgop->oat.group = htole16(group);
   1335  1.16        ad 	pgop->oat.fields[0] = htole16(field);
   1336  1.16        ad 	memcpy(pgop + 1, buf, size);
   1337  1.16        ad 
   1338  1.16        ad 	iop_msg_map(sc, im, mb, pgop, totsize, 1, NULL);
   1339  1.16        ad 	rv = iop_msg_post(sc, im, mb, 30000);
   1340  1.16        ad 	if (rv != 0)
   1341  1.82       chs 		aprint_error_dev(sc->sc_dev, "FIELD_SET failed for tid %d group %d\n",
   1342  1.69    cegger 		    tid, group);
   1343  1.16        ad 
   1344  1.16        ad 	iop_msg_unmap(sc, im);
   1345  1.16        ad 	iop_msg_free(sc, im);
   1346  1.16        ad 	free(pgop, M_DEVBUF);
   1347  1.16        ad 	return (rv);
   1348  1.16        ad }
   1349  1.16        ad 
   1350  1.16        ad /*
   1351  1.16        ad  * Delete all rows in a tablular parameter group.
   1352  1.16        ad  */
   1353  1.16        ad int
   1354  1.16        ad iop_table_clear(struct iop_softc *sc, int tid, int group)
   1355  1.16        ad {
   1356  1.16        ad 	struct iop_msg *im;
   1357  1.16        ad 	struct i2o_util_params_op *mf;
   1358  1.16        ad 	struct iop_pgop pgop;
   1359  1.16        ad 	u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
   1360  1.16        ad 	int rv;
   1361  1.16        ad 
   1362  1.16        ad 	im = iop_msg_alloc(sc, IM_WAIT);
   1363  1.16        ad 
   1364  1.16        ad 	mf = (struct i2o_util_params_op *)mb;
   1365  1.16        ad 	mf->msgflags = I2O_MSGFLAGS(i2o_util_params_op);
   1366  1.16        ad 	mf->msgfunc = I2O_MSGFUNC(tid, I2O_UTIL_PARAMS_SET);
   1367  1.16        ad 	mf->msgictx = IOP_ICTX;
   1368  1.16        ad 	mf->msgtctx = im->im_tctx;
   1369  1.16        ad 	mf->flags = 0;
   1370  1.16        ad 
   1371  1.16        ad 	pgop.olh.count = htole16(1);
   1372  1.16        ad 	pgop.olh.reserved = htole16(0);
   1373  1.16        ad 	pgop.oat.operation = htole16(I2O_PARAMS_OP_TABLE_CLEAR);
   1374  1.16        ad 	pgop.oat.fieldcount = htole16(0);
   1375  1.16        ad 	pgop.oat.group = htole16(group);
   1376  1.16        ad 	pgop.oat.fields[0] = htole16(0);
   1377  1.16        ad 
   1378  1.16        ad 	iop_msg_map(sc, im, mb, &pgop, sizeof(pgop), 1, NULL);
   1379  1.16        ad 	rv = iop_msg_post(sc, im, mb, 30000);
   1380  1.16        ad 	if (rv != 0)
   1381  1.82       chs 		aprint_error_dev(sc->sc_dev, "TABLE_CLEAR failed for tid %d group %d\n",
   1382  1.69    cegger 		    tid, group);
   1383  1.16        ad 
   1384  1.16        ad 	iop_msg_unmap(sc, im);
   1385  1.16        ad 	iop_msg_free(sc, im);
   1386  1.16        ad 	return (rv);
   1387  1.16        ad }
   1388  1.16        ad 
   1389  1.16        ad /*
   1390  1.16        ad  * Add a single row to a tabular parameter group.  The row can have only one
   1391  1.16        ad  * field.
   1392  1.16        ad  */
   1393  1.16        ad int
   1394  1.16        ad iop_table_add_row(struct iop_softc *sc, int tid, int group, void *buf,
   1395  1.16        ad 		  int size, int row)
   1396  1.16        ad {
   1397  1.16        ad 	struct iop_msg *im;
   1398  1.16        ad 	struct i2o_util_params_op *mf;
   1399  1.16        ad 	struct iop_pgop *pgop;
   1400  1.16        ad 	int rv, totsize;
   1401  1.16        ad 	u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
   1402  1.16        ad 
   1403  1.16        ad 	totsize = sizeof(*pgop) + sizeof(u_int16_t) * 2 + size;
   1404  1.16        ad 
   1405  1.16        ad 	im = iop_msg_alloc(sc, IM_WAIT);
   1406  1.16        ad 	if ((pgop = malloc(totsize, M_DEVBUF, M_WAITOK)) == NULL) {
   1407  1.16        ad 		iop_msg_free(sc, im);
   1408  1.16        ad 		return (ENOMEM);
   1409  1.16        ad 	}
   1410  1.16        ad 
   1411  1.16        ad 	mf = (struct i2o_util_params_op *)mb;
   1412  1.16        ad 	mf->msgflags = I2O_MSGFLAGS(i2o_util_params_op);
   1413  1.16        ad 	mf->msgfunc = I2O_MSGFUNC(tid, I2O_UTIL_PARAMS_SET);
   1414  1.16        ad 	mf->msgictx = IOP_ICTX;
   1415  1.16        ad 	mf->msgtctx = im->im_tctx;
   1416  1.16        ad 	mf->flags = 0;
   1417  1.16        ad 
   1418  1.16        ad 	pgop->olh.count = htole16(1);
   1419  1.16        ad 	pgop->olh.reserved = htole16(0);
   1420  1.16        ad 	pgop->oat.operation = htole16(I2O_PARAMS_OP_ROW_ADD);
   1421  1.16        ad 	pgop->oat.fieldcount = htole16(1);
   1422  1.16        ad 	pgop->oat.group = htole16(group);
   1423  1.16        ad 	pgop->oat.fields[0] = htole16(0);	/* FieldIdx */
   1424  1.16        ad 	pgop->oat.fields[1] = htole16(1);	/* RowCount */
   1425  1.16        ad 	pgop->oat.fields[2] = htole16(row);	/* KeyValue */
   1426  1.16        ad 	memcpy(&pgop->oat.fields[3], buf, size);
   1427  1.16        ad 
   1428  1.16        ad 	iop_msg_map(sc, im, mb, pgop, totsize, 1, NULL);
   1429  1.16        ad 	rv = iop_msg_post(sc, im, mb, 30000);
   1430  1.16        ad 	if (rv != 0)
   1431  1.82       chs 		aprint_error_dev(sc->sc_dev, "ADD_ROW failed for tid %d group %d row %d\n",
   1432  1.69    cegger 		    tid, group, row);
   1433  1.16        ad 
   1434  1.16        ad 	iop_msg_unmap(sc, im);
   1435  1.16        ad 	iop_msg_free(sc, im);
   1436  1.16        ad 	free(pgop, M_DEVBUF);
   1437  1.16        ad 	return (rv);
   1438  1.16        ad }
   1439  1.16        ad 
   1440  1.16        ad /*
   1441   1.5        ad  * Execute a simple command (no parameters).
   1442   1.1        ad  */
   1443   1.1        ad int
   1444   1.5        ad iop_simple_cmd(struct iop_softc *sc, int tid, int function, int ictx,
   1445   1.5        ad 	       int async, int timo)
   1446   1.1        ad {
   1447   1.1        ad 	struct iop_msg *im;
   1448  1.11        ad 	struct i2o_msg mf;
   1449   1.5        ad 	int rv, fl;
   1450   1.1        ad 
   1451  1.11        ad 	fl = (async != 0 ? IM_WAIT : IM_POLL);
   1452  1.15        ad 	im = iop_msg_alloc(sc, fl);
   1453   1.1        ad 
   1454  1.11        ad 	mf.msgflags = I2O_MSGFLAGS(i2o_msg);
   1455  1.11        ad 	mf.msgfunc = I2O_MSGFUNC(tid, function);
   1456  1.11        ad 	mf.msgictx = ictx;
   1457  1.11        ad 	mf.msgtctx = im->im_tctx;
   1458   1.1        ad 
   1459  1.11        ad 	rv = iop_msg_post(sc, im, &mf, timo);
   1460  1.11        ad 	iop_msg_free(sc, im);
   1461   1.1        ad 	return (rv);
   1462   1.1        ad }
   1463   1.1        ad 
   1464   1.1        ad /*
   1465   1.5        ad  * Post the system table to the IOP.
   1466   1.1        ad  */
   1467   1.1        ad static int
   1468   1.1        ad iop_systab_set(struct iop_softc *sc)
   1469   1.1        ad {
   1470  1.11        ad 	struct i2o_exec_sys_tab_set *mf;
   1471   1.1        ad 	struct iop_msg *im;
   1472  1.13        ad 	bus_space_handle_t bsh;
   1473  1.13        ad 	bus_addr_t boo;
   1474   1.1        ad 	u_int32_t mema[2], ioa[2];
   1475   1.1        ad 	int rv;
   1476  1.11        ad 	u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
   1477   1.1        ad 
   1478  1.15        ad 	im = iop_msg_alloc(sc, IM_WAIT);
   1479   1.1        ad 
   1480  1.11        ad 	mf = (struct i2o_exec_sys_tab_set *)mb;
   1481  1.11        ad 	mf->msgflags = I2O_MSGFLAGS(i2o_exec_sys_tab_set);
   1482  1.11        ad 	mf->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_SYS_TAB_SET);
   1483  1.11        ad 	mf->msgictx = IOP_ICTX;
   1484  1.11        ad 	mf->msgtctx = im->im_tctx;
   1485  1.82       chs 	mf->iopid = (device_unit(sc->sc_dev) + 2) << 12;
   1486  1.11        ad 	mf->segnumber = 0;
   1487   1.5        ad 
   1488  1.13        ad 	mema[1] = sc->sc_status.desiredprivmemsize;
   1489  1.13        ad 	ioa[1] = sc->sc_status.desiredpriviosize;
   1490  1.13        ad 
   1491  1.13        ad 	if (mema[1] != 0) {
   1492  1.13        ad 		rv = bus_space_alloc(sc->sc_bus_memt, 0, 0xffffffff,
   1493  1.13        ad 		    le32toh(mema[1]), PAGE_SIZE, 0, 0, &boo, &bsh);
   1494  1.13        ad 		mema[0] = htole32(boo);
   1495  1.13        ad 		if (rv != 0) {
   1496  1.82       chs 			aprint_error_dev(sc->sc_dev, "can't alloc priv mem space, err = %d\n", rv);
   1497  1.13        ad 			mema[0] = 0;
   1498  1.13        ad 			mema[1] = 0;
   1499  1.13        ad 		}
   1500  1.13        ad 	}
   1501  1.13        ad 
   1502  1.13        ad 	if (ioa[1] != 0) {
   1503  1.13        ad 		rv = bus_space_alloc(sc->sc_bus_iot, 0, 0xffff,
   1504  1.13        ad 		    le32toh(ioa[1]), 0, 0, 0, &boo, &bsh);
   1505  1.13        ad 		ioa[0] = htole32(boo);
   1506  1.13        ad 		if (rv != 0) {
   1507  1.82       chs 			aprint_error_dev(sc->sc_dev, "can't alloc priv i/o space, err = %d\n", rv);
   1508  1.13        ad 			ioa[0] = 0;
   1509  1.13        ad 			ioa[1] = 0;
   1510  1.13        ad 		}
   1511  1.13        ad 	}
   1512   1.1        ad 
   1513  1.15        ad 	iop_msg_map(sc, im, mb, iop_systab, iop_systab_size, 1, NULL);
   1514  1.15        ad 	iop_msg_map(sc, im, mb, mema, sizeof(mema), 1, NULL);
   1515  1.15        ad 	iop_msg_map(sc, im, mb, ioa, sizeof(ioa), 1, NULL);
   1516  1.11        ad 	rv = iop_msg_post(sc, im, mb, 5000);
   1517   1.1        ad 	iop_msg_unmap(sc, im);
   1518  1.11        ad 	iop_msg_free(sc, im);
   1519   1.1        ad 	return (rv);
   1520   1.1        ad }
   1521   1.1        ad 
   1522   1.1        ad /*
   1523  1.11        ad  * Reset the IOP.  Must be called with interrupts disabled.
   1524   1.1        ad  */
   1525   1.1        ad static int
   1526   1.1        ad iop_reset(struct iop_softc *sc)
   1527   1.1        ad {
   1528  1.15        ad 	u_int32_t mfa, *sw;
   1529  1.11        ad 	struct i2o_exec_iop_reset mf;
   1530   1.1        ad 	int rv;
   1531  1.15        ad 	paddr_t pa;
   1532   1.1        ad 
   1533  1.15        ad 	sw = (u_int32_t *)sc->sc_scr;
   1534  1.75    mhitch 	pa = sc->sc_scr_dmamap->dm_segs[0].ds_addr;
   1535   1.1        ad 
   1536  1.11        ad 	mf.msgflags = I2O_MSGFLAGS(i2o_exec_iop_reset);
   1537  1.11        ad 	mf.msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_IOP_RESET);
   1538  1.11        ad 	mf.reserved[0] = 0;
   1539  1.11        ad 	mf.reserved[1] = 0;
   1540  1.11        ad 	mf.reserved[2] = 0;
   1541  1.11        ad 	mf.reserved[3] = 0;
   1542  1.15        ad 	mf.statuslow = (u_int32_t)pa;
   1543  1.15        ad 	mf.statushigh = (u_int32_t)((u_int64_t)pa >> 32);
   1544  1.15        ad 
   1545  1.72        ad 	bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
   1546  1.80    bouyer 	    BUS_DMASYNC_POSTWRITE);
   1547  1.15        ad 	*sw = htole32(0);
   1548  1.15        ad 	bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
   1549  1.80    bouyer 	    BUS_DMASYNC_PREWRITE|BUS_DMASYNC_PREREAD);
   1550   1.1        ad 
   1551  1.11        ad 	if ((rv = iop_post(sc, (u_int32_t *)&mf)))
   1552   1.1        ad 		return (rv);
   1553   1.1        ad 
   1554  1.15        ad 	POLL(2500,
   1555  1.15        ad 	    (bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
   1556  1.80    bouyer 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD), *sw != 0));
   1557  1.15        ad 	if (*sw != htole32(I2O_RESET_IN_PROGRESS)) {
   1558  1.82       chs 		aprint_error_dev(sc->sc_dev, "reset rejected, status 0x%x\n",
   1559  1.69    cegger 		    le32toh(*sw));
   1560   1.1        ad 		return (EIO);
   1561   1.1        ad 	}
   1562   1.1        ad 
   1563  1.47     perry 	/*
   1564   1.5        ad 	 * IOP is now in the INIT state.  Wait no more than 10 seconds for
   1565   1.1        ad 	 * the inbound queue to become responsive.
   1566   1.1        ad 	 */
   1567   1.5        ad 	POLL(10000, (mfa = iop_inl(sc, IOP_REG_IFIFO)) != IOP_MFA_EMPTY);
   1568   1.1        ad 	if (mfa == IOP_MFA_EMPTY) {
   1569  1.82       chs 		aprint_error_dev(sc->sc_dev, "reset failed\n");
   1570   1.1        ad 		return (EIO);
   1571   1.1        ad 	}
   1572   1.1        ad 
   1573   1.1        ad 	iop_release_mfa(sc, mfa);
   1574   1.1        ad 	return (0);
   1575   1.1        ad }
   1576   1.1        ad 
   1577   1.1        ad /*
   1578  1.11        ad  * Register a new initiator.  Must be called with the configuration lock
   1579  1.11        ad  * held.
   1580   1.1        ad  */
   1581  1.11        ad void
   1582   1.1        ad iop_initiator_register(struct iop_softc *sc, struct iop_initiator *ii)
   1583   1.1        ad {
   1584  1.11        ad 	static int ictxgen;
   1585   1.5        ad 
   1586  1.11        ad 	/* 0 is reserved (by us) for system messages. */
   1587  1.11        ad 	ii->ii_ictx = ++ictxgen;
   1588   1.1        ad 
   1589  1.11        ad 	/*
   1590  1.11        ad 	 * `Utility initiators' don't make it onto the per-IOP initiator list
   1591  1.11        ad 	 * (which is used only for configuration), but do get one slot on
   1592  1.11        ad 	 * the inbound queue.
   1593  1.11        ad 	 */
   1594  1.11        ad 	if ((ii->ii_flags & II_UTILITY) == 0) {
   1595  1.11        ad 		LIST_INSERT_HEAD(&sc->sc_iilist, ii, ii_list);
   1596  1.11        ad 		sc->sc_nii++;
   1597  1.11        ad 	} else
   1598  1.11        ad 		sc->sc_nuii++;
   1599  1.11        ad 
   1600  1.65        ad 	cv_init(&ii->ii_cv, "iopevt");
   1601  1.65        ad 
   1602  1.65        ad 	mutex_spin_enter(&sc->sc_intrlock);
   1603   1.5        ad 	LIST_INSERT_HEAD(IOP_ICTXHASH(ii->ii_ictx), ii, ii_hash);
   1604  1.65        ad 	mutex_spin_exit(&sc->sc_intrlock);
   1605   1.1        ad }
   1606   1.1        ad 
   1607   1.1        ad /*
   1608  1.11        ad  * Unregister an initiator.  Must be called with the configuration lock
   1609  1.11        ad  * held.
   1610   1.1        ad  */
   1611   1.1        ad void
   1612   1.1        ad iop_initiator_unregister(struct iop_softc *sc, struct iop_initiator *ii)
   1613   1.1        ad {
   1614  1.11        ad 
   1615  1.11        ad 	if ((ii->ii_flags & II_UTILITY) == 0) {
   1616  1.11        ad 		LIST_REMOVE(ii, ii_list);
   1617  1.11        ad 		sc->sc_nii--;
   1618  1.11        ad 	} else
   1619  1.11        ad 		sc->sc_nuii--;
   1620   1.1        ad 
   1621  1.65        ad 	mutex_spin_enter(&sc->sc_intrlock);
   1622   1.5        ad 	LIST_REMOVE(ii, ii_hash);
   1623  1.65        ad 	mutex_spin_exit(&sc->sc_intrlock);
   1624  1.65        ad 
   1625  1.65        ad 	cv_destroy(&ii->ii_cv);
   1626   1.1        ad }
   1627   1.1        ad 
   1628   1.1        ad /*
   1629  1.11        ad  * Handle a reply frame from the IOP.
   1630   1.1        ad  */
   1631   1.1        ad static int
   1632   1.5        ad iop_handle_reply(struct iop_softc *sc, u_int32_t rmfa)
   1633   1.1        ad {
   1634   1.1        ad 	struct iop_msg *im;
   1635   1.1        ad 	struct i2o_reply *rb;
   1636  1.11        ad 	struct i2o_fault_notify *fn;
   1637   1.1        ad 	struct iop_initiator *ii;
   1638   1.5        ad 	u_int off, ictx, tctx, status, size;
   1639   1.1        ad 
   1640  1.65        ad 	KASSERT(mutex_owned(&sc->sc_intrlock));
   1641  1.65        ad 
   1642   1.1        ad 	off = (int)(rmfa - sc->sc_rep_phys);
   1643  1.64  christos 	rb = (struct i2o_reply *)((char *)sc->sc_rep + off);
   1644   1.1        ad 
   1645  1.15        ad 	/* Perform reply queue DMA synchronisation. */
   1646  1.11        ad 	bus_dmamap_sync(sc->sc_dmat, sc->sc_rep_dmamap, off,
   1647  1.19        ad 	    sc->sc_framesize, BUS_DMASYNC_POSTREAD);
   1648   1.1        ad 
   1649   1.1        ad #ifdef I2ODEBUG
   1650   1.1        ad 	if ((le32toh(rb->msgflags) & I2O_MSGFLAGS_64BIT) != 0)
   1651   1.5        ad 		panic("iop_handle_reply: 64-bit reply");
   1652   1.1        ad #endif
   1653  1.47     perry 	/*
   1654   1.1        ad 	 * Find the initiator.
   1655   1.1        ad 	 */
   1656   1.1        ad 	ictx = le32toh(rb->msgictx);
   1657   1.1        ad 	if (ictx == IOP_ICTX)
   1658   1.1        ad 		ii = NULL;
   1659   1.1        ad 	else {
   1660   1.5        ad 		ii = LIST_FIRST(IOP_ICTXHASH(ictx));
   1661   1.5        ad 		for (; ii != NULL; ii = LIST_NEXT(ii, ii_hash))
   1662   1.5        ad 			if (ii->ii_ictx == ictx)
   1663   1.5        ad 				break;
   1664   1.5        ad 		if (ii == NULL) {
   1665   1.1        ad #ifdef I2ODEBUG
   1666  1.11        ad 			iop_reply_print(sc, rb);
   1667   1.1        ad #endif
   1668  1.82       chs 			aprint_error_dev(sc->sc_dev, "WARNING: bad ictx returned (%x)\n",
   1669  1.69    cegger 			    ictx);
   1670   1.5        ad 			return (-1);
   1671   1.5        ad 		}
   1672   1.1        ad 	}
   1673   1.1        ad 
   1674  1.11        ad 	/*
   1675  1.14       wiz 	 * If we received a transport failure notice, we've got to dig the
   1676  1.11        ad 	 * transaction context (if any) out of the original message frame,
   1677  1.11        ad 	 * and then release the original MFA back to the inbound FIFO.
   1678  1.11        ad 	 */
   1679  1.11        ad 	if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0) {
   1680  1.11        ad 		status = I2O_STATUS_SUCCESS;
   1681  1.11        ad 
   1682  1.11        ad 		fn = (struct i2o_fault_notify *)rb;
   1683  1.29   msaitoh 		tctx = iop_inl_msg(sc, fn->lowmfa + 12);
   1684  1.11        ad 		iop_release_mfa(sc, fn->lowmfa);
   1685  1.11        ad 		iop_tfn_print(sc, fn);
   1686  1.11        ad 	} else {
   1687  1.11        ad 		status = rb->reqstatus;
   1688  1.11        ad 		tctx = le32toh(rb->msgtctx);
   1689  1.11        ad 	}
   1690   1.1        ad 
   1691  1.15        ad 	if (ii == NULL || (ii->ii_flags & II_NOTCTX) == 0) {
   1692   1.1        ad 		/*
   1693   1.1        ad 		 * This initiator tracks state using message wrappers.
   1694   1.1        ad 		 *
   1695   1.1        ad 		 * Find the originating message wrapper, and if requested
   1696   1.1        ad 		 * notify the initiator.
   1697   1.1        ad 		 */
   1698  1.11        ad 		im = sc->sc_ims + (tctx & IOP_TCTX_MASK);
   1699  1.11        ad 		if ((tctx & IOP_TCTX_MASK) > sc->sc_maxib ||
   1700  1.11        ad 		    (im->im_flags & IM_ALLOCED) == 0 ||
   1701  1.11        ad 		    tctx != im->im_tctx) {
   1702  1.82       chs 			aprint_error_dev(sc->sc_dev, "WARNING: bad tctx returned (0x%08x, %p)\n", tctx, im);
   1703  1.11        ad 			if (im != NULL)
   1704  1.82       chs 				aprint_error_dev(sc->sc_dev, "flags=0x%08x tctx=0x%08x\n",
   1705  1.69    cegger 				    im->im_flags, im->im_tctx);
   1706   1.5        ad #ifdef I2ODEBUG
   1707  1.11        ad 			if ((rb->msgflags & I2O_MSGFLAGS_FAIL) == 0)
   1708  1.11        ad 				iop_reply_print(sc, rb);
   1709   1.5        ad #endif
   1710   1.5        ad 			return (-1);
   1711   1.5        ad 		}
   1712  1.11        ad 
   1713  1.11        ad 		if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0)
   1714  1.11        ad 			im->im_flags |= IM_FAIL;
   1715  1.11        ad 
   1716   1.1        ad #ifdef I2ODEBUG
   1717   1.1        ad 		if ((im->im_flags & IM_REPLIED) != 0)
   1718  1.82       chs 			panic("%s: dup reply", device_xname(sc->sc_dev));
   1719   1.1        ad #endif
   1720  1.11        ad 		im->im_flags |= IM_REPLIED;
   1721   1.1        ad 
   1722  1.11        ad #ifdef I2ODEBUG
   1723  1.11        ad 		if (status != I2O_STATUS_SUCCESS)
   1724  1.11        ad 			iop_reply_print(sc, rb);
   1725  1.11        ad #endif
   1726  1.11        ad 		im->im_reqstatus = status;
   1727  1.42        ad 		im->im_detstatus = le16toh(rb->detail);
   1728   1.1        ad 
   1729  1.11        ad 		/* Copy the reply frame, if requested. */
   1730  1.11        ad 		if (im->im_rb != NULL) {
   1731  1.11        ad 			size = (le32toh(rb->msgflags) >> 14) & ~3;
   1732   1.1        ad #ifdef I2ODEBUG
   1733  1.19        ad 			if (size > sc->sc_framesize)
   1734  1.11        ad 				panic("iop_handle_reply: reply too large");
   1735   1.1        ad #endif
   1736  1.11        ad 			memcpy(im->im_rb, rb, size);
   1737  1.11        ad 		}
   1738  1.11        ad 
   1739   1.1        ad 		/* Notify the initiator. */
   1740  1.11        ad 		if ((im->im_flags & IM_WAIT) != 0)
   1741  1.65        ad 			cv_broadcast(&im->im_cv);
   1742  1.55  christos 		else if ((im->im_flags & (IM_POLL | IM_POLL_INTR)) != IM_POLL) {
   1743  1.65        ad 			if (ii != NULL) {
   1744  1.65        ad 				mutex_spin_exit(&sc->sc_intrlock);
   1745  1.55  christos 				(*ii->ii_intr)(ii->ii_dv, im, rb);
   1746  1.65        ad 				mutex_spin_enter(&sc->sc_intrlock);
   1747  1.65        ad 			}
   1748  1.55  christos 		}
   1749   1.1        ad 	} else {
   1750   1.1        ad 		/*
   1751   1.1        ad 		 * This initiator discards message wrappers.
   1752   1.1        ad 		 *
   1753   1.1        ad 		 * Simply pass the reply frame to the initiator.
   1754   1.1        ad 		 */
   1755  1.65        ad 		if (ii != NULL) {
   1756  1.65        ad 			mutex_spin_exit(&sc->sc_intrlock);
   1757  1.55  christos 			(*ii->ii_intr)(ii->ii_dv, NULL, rb);
   1758  1.65        ad 			mutex_spin_enter(&sc->sc_intrlock);
   1759  1.65        ad 		}
   1760   1.1        ad 	}
   1761   1.1        ad 
   1762   1.1        ad 	return (status);
   1763   1.1        ad }
   1764   1.1        ad 
   1765   1.1        ad /*
   1766  1.11        ad  * Handle an interrupt from the IOP.
   1767   1.1        ad  */
   1768   1.1        ad int
   1769   1.1        ad iop_intr(void *arg)
   1770   1.1        ad {
   1771   1.1        ad 	struct iop_softc *sc;
   1772   1.5        ad 	u_int32_t rmfa;
   1773   1.1        ad 
   1774   1.1        ad 	sc = arg;
   1775   1.1        ad 
   1776  1.65        ad 	mutex_spin_enter(&sc->sc_intrlock);
   1777  1.65        ad 
   1778  1.65        ad 	if ((iop_inl(sc, IOP_REG_INTR_STATUS) & IOP_INTR_OFIFO) == 0) {
   1779  1.65        ad 		mutex_spin_exit(&sc->sc_intrlock);
   1780   1.5        ad 		return (0);
   1781  1.65        ad 	}
   1782   1.5        ad 
   1783   1.5        ad 	for (;;) {
   1784   1.5        ad 		/* Double read to account for IOP bug. */
   1785  1.11        ad 		if ((rmfa = iop_inl(sc, IOP_REG_OFIFO)) == IOP_MFA_EMPTY) {
   1786  1.11        ad 			rmfa = iop_inl(sc, IOP_REG_OFIFO);
   1787  1.11        ad 			if (rmfa == IOP_MFA_EMPTY)
   1788  1.11        ad 				break;
   1789  1.11        ad 		}
   1790   1.5        ad 		iop_handle_reply(sc, rmfa);
   1791  1.11        ad 		iop_outl(sc, IOP_REG_OFIFO, rmfa);
   1792   1.1        ad 	}
   1793   1.1        ad 
   1794  1.65        ad 	mutex_spin_exit(&sc->sc_intrlock);
   1795   1.5        ad 	return (1);
   1796   1.5        ad }
   1797   1.5        ad 
   1798   1.5        ad /*
   1799   1.5        ad  * Handle an event signalled by the executive.
   1800   1.5        ad  */
   1801   1.5        ad static void
   1802  1.76    cegger iop_intr_event(device_t dv, struct iop_msg *im, void *reply)
   1803   1.5        ad {
   1804   1.5        ad 	struct i2o_util_event_register_reply *rb;
   1805   1.5        ad 	u_int event;
   1806   1.5        ad 
   1807   1.5        ad 	rb = reply;
   1808   1.5        ad 
   1809  1.11        ad 	if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0)
   1810   1.5        ad 		return;
   1811   1.5        ad 
   1812  1.11        ad 	event = le32toh(rb->event);
   1813  1.69    cegger 	printf("%s: event 0x%08x received\n", device_xname(dv), event);
   1814   1.1        ad }
   1815   1.1        ad 
   1816  1.47     perry /*
   1817   1.1        ad  * Allocate a message wrapper.
   1818   1.1        ad  */
   1819  1.11        ad struct iop_msg *
   1820  1.15        ad iop_msg_alloc(struct iop_softc *sc, int flags)
   1821   1.1        ad {
   1822   1.1        ad 	struct iop_msg *im;
   1823  1.11        ad 	static u_int tctxgen;
   1824  1.65        ad 	int i;
   1825   1.1        ad 
   1826   1.1        ad #ifdef I2ODEBUG
   1827   1.1        ad 	if ((flags & IM_SYSMASK) != 0)
   1828   1.1        ad 		panic("iop_msg_alloc: system flags specified");
   1829   1.1        ad #endif
   1830   1.1        ad 
   1831  1.65        ad 	mutex_spin_enter(&sc->sc_intrlock);
   1832  1.11        ad 	im = SLIST_FIRST(&sc->sc_im_freelist);
   1833  1.11        ad #if defined(DIAGNOSTIC) || defined(I2ODEBUG)
   1834  1.11        ad 	if (im == NULL)
   1835  1.11        ad 		panic("iop_msg_alloc: no free wrappers");
   1836  1.11        ad #endif
   1837  1.11        ad 	SLIST_REMOVE_HEAD(&sc->sc_im_freelist, im_chain);
   1838  1.65        ad 	mutex_spin_exit(&sc->sc_intrlock);
   1839   1.1        ad 
   1840  1.11        ad 	im->im_tctx = (im->im_tctx & IOP_TCTX_MASK) | tctxgen;
   1841  1.11        ad 	tctxgen += (1 << IOP_TCTX_SHIFT);
   1842   1.1        ad 	im->im_flags = flags | IM_ALLOCED;
   1843  1.11        ad 	im->im_rb = NULL;
   1844  1.11        ad 	i = 0;
   1845  1.11        ad 	do {
   1846  1.11        ad 		im->im_xfer[i++].ix_size = 0;
   1847  1.11        ad 	} while (i < IOP_MAX_MSG_XFERS);
   1848   1.1        ad 
   1849  1.11        ad 	return (im);
   1850   1.1        ad }
   1851   1.1        ad 
   1852  1.47     perry /*
   1853   1.1        ad  * Free a message wrapper.
   1854   1.1        ad  */
   1855   1.1        ad void
   1856  1.11        ad iop_msg_free(struct iop_softc *sc, struct iop_msg *im)
   1857   1.1        ad {
   1858   1.1        ad 
   1859   1.1        ad #ifdef I2ODEBUG
   1860   1.1        ad 	if ((im->im_flags & IM_ALLOCED) == 0)
   1861   1.1        ad 		panic("iop_msg_free: wrapper not allocated");
   1862   1.1        ad #endif
   1863   1.1        ad 
   1864   1.1        ad 	im->im_flags = 0;
   1865  1.65        ad 	mutex_spin_enter(&sc->sc_intrlock);
   1866  1.11        ad 	SLIST_INSERT_HEAD(&sc->sc_im_freelist, im, im_chain);
   1867  1.65        ad 	mutex_spin_exit(&sc->sc_intrlock);
   1868   1.1        ad }
   1869   1.1        ad 
   1870   1.1        ad /*
   1871  1.47     perry  * Map a data transfer.  Write a scatter-gather list into the message frame.
   1872   1.1        ad  */
   1873   1.1        ad int
   1874  1.11        ad iop_msg_map(struct iop_softc *sc, struct iop_msg *im, u_int32_t *mb,
   1875  1.15        ad 	    void *xferaddr, int xfersize, int out, struct proc *up)
   1876   1.1        ad {
   1877  1.11        ad 	bus_dmamap_t dm;
   1878  1.11        ad 	bus_dma_segment_t *ds;
   1879   1.1        ad 	struct iop_xfer *ix;
   1880  1.11        ad 	u_int rv, i, nsegs, flg, off, xn;
   1881  1.11        ad 	u_int32_t *p;
   1882   1.5        ad 
   1883  1.11        ad 	for (xn = 0, ix = im->im_xfer; xn < IOP_MAX_MSG_XFERS; xn++, ix++)
   1884   1.1        ad 		if (ix->ix_size == 0)
   1885   1.1        ad 			break;
   1886  1.11        ad 
   1887   1.1        ad #ifdef I2ODEBUG
   1888  1.11        ad 	if (xfersize == 0)
   1889  1.11        ad 		panic("iop_msg_map: null transfer");
   1890  1.11        ad 	if (xfersize > IOP_MAX_XFER)
   1891  1.11        ad 		panic("iop_msg_map: transfer too large");
   1892  1.11        ad 	if (xn == IOP_MAX_MSG_XFERS)
   1893   1.1        ad 		panic("iop_msg_map: too many xfers");
   1894   1.1        ad #endif
   1895   1.1        ad 
   1896  1.11        ad 	/*
   1897  1.11        ad 	 * Only the first DMA map is static.
   1898  1.11        ad 	 */
   1899  1.11        ad 	if (xn != 0) {
   1900   1.1        ad 		rv = bus_dmamap_create(sc->sc_dmat, IOP_MAX_XFER,
   1901  1.11        ad 		    IOP_MAX_SEGS, IOP_MAX_XFER, 0,
   1902   1.1        ad 		    BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &ix->ix_map);
   1903   1.1        ad 		if (rv != 0)
   1904   1.1        ad 			return (rv);
   1905   1.1        ad 	}
   1906   1.1        ad 
   1907  1.11        ad 	dm = ix->ix_map;
   1908  1.15        ad 	rv = bus_dmamap_load(sc->sc_dmat, dm, xferaddr, xfersize, up,
   1909  1.15        ad 	    (up == NULL ? BUS_DMA_NOWAIT : 0));
   1910  1.11        ad 	if (rv != 0)
   1911  1.11        ad 		goto bad;
   1912  1.11        ad 
   1913  1.11        ad 	/*
   1914  1.11        ad 	 * How many SIMPLE SG elements can we fit in this message?
   1915  1.11        ad 	 */
   1916  1.11        ad 	off = mb[0] >> 16;
   1917  1.11        ad 	p = mb + off;
   1918  1.19        ad 	nsegs = ((sc->sc_framesize >> 2) - off) >> 1;
   1919  1.11        ad 
   1920  1.11        ad 	if (dm->dm_nsegs > nsegs) {
   1921  1.11        ad 		bus_dmamap_unload(sc->sc_dmat, ix->ix_map);
   1922  1.11        ad 		rv = EFBIG;
   1923  1.11        ad 		DPRINTF(("iop_msg_map: too many segs\n"));
   1924  1.11        ad 		goto bad;
   1925  1.11        ad 	}
   1926   1.1        ad 
   1927  1.11        ad 	nsegs = dm->dm_nsegs;
   1928  1.11        ad 	xfersize = 0;
   1929   1.1        ad 
   1930  1.11        ad 	/*
   1931  1.11        ad 	 * Write out the SG list.
   1932  1.11        ad 	 */
   1933   1.1        ad 	if (out)
   1934  1.11        ad 		flg = I2O_SGL_SIMPLE | I2O_SGL_DATA_OUT;
   1935   1.1        ad 	else
   1936  1.11        ad 		flg = I2O_SGL_SIMPLE;
   1937   1.1        ad 
   1938  1.11        ad 	for (i = nsegs, ds = dm->dm_segs; i > 1; i--, p += 2, ds++) {
   1939  1.11        ad 		p[0] = (u_int32_t)ds->ds_len | flg;
   1940  1.11        ad 		p[1] = (u_int32_t)ds->ds_addr;
   1941  1.11        ad 		xfersize += ds->ds_len;
   1942   1.1        ad 	}
   1943   1.1        ad 
   1944  1.11        ad 	p[0] = (u_int32_t)ds->ds_len | flg | I2O_SGL_END_BUFFER;
   1945  1.11        ad 	p[1] = (u_int32_t)ds->ds_addr;
   1946  1.11        ad 	xfersize += ds->ds_len;
   1947  1.11        ad 
   1948  1.11        ad 	/* Fix up the transfer record, and sync the map. */
   1949  1.11        ad 	ix->ix_flags = (out ? IX_OUT : IX_IN);
   1950  1.11        ad 	ix->ix_size = xfersize;
   1951  1.11        ad 	bus_dmamap_sync(sc->sc_dmat, ix->ix_map, 0, xfersize,
   1952  1.72        ad 	    out ? BUS_DMASYNC_PREWRITE : BUS_DMASYNC_PREREAD);
   1953  1.11        ad 
   1954   1.1        ad 	/*
   1955   1.1        ad 	 * If this is the first xfer we've mapped for this message, adjust
   1956   1.1        ad 	 * the SGL offset field in the message header.
   1957   1.1        ad 	 */
   1958   1.2        ad 	if ((im->im_flags & IM_SGLOFFADJ) == 0) {
   1959  1.11        ad 		mb[0] += (mb[0] >> 12) & 0xf0;
   1960   1.2        ad 		im->im_flags |= IM_SGLOFFADJ;
   1961   1.2        ad 	}
   1962  1.11        ad 	mb[0] += (nsegs << 17);
   1963  1.11        ad 	return (0);
   1964  1.11        ad 
   1965  1.11        ad  bad:
   1966  1.11        ad  	if (xn != 0)
   1967  1.11        ad 		bus_dmamap_destroy(sc->sc_dmat, ix->ix_map);
   1968  1.11        ad 	return (rv);
   1969  1.11        ad }
   1970  1.11        ad 
   1971  1.11        ad /*
   1972  1.11        ad  * Map a block I/O data transfer (different in that there's only one per
   1973  1.11        ad  * message maximum, and PAGE addressing may be used).  Write a scatter
   1974  1.11        ad  * gather list into the message frame.
   1975  1.11        ad  */
   1976  1.11        ad int
   1977  1.11        ad iop_msg_map_bio(struct iop_softc *sc, struct iop_msg *im, u_int32_t *mb,
   1978  1.11        ad 		void *xferaddr, int xfersize, int out)
   1979  1.11        ad {
   1980  1.11        ad 	bus_dma_segment_t *ds;
   1981  1.11        ad 	bus_dmamap_t dm;
   1982  1.11        ad 	struct iop_xfer *ix;
   1983  1.11        ad 	u_int rv, i, nsegs, off, slen, tlen, flg;
   1984  1.11        ad 	paddr_t saddr, eaddr;
   1985  1.11        ad 	u_int32_t *p;
   1986  1.11        ad 
   1987  1.11        ad #ifdef I2ODEBUG
   1988  1.11        ad 	if (xfersize == 0)
   1989  1.11        ad 		panic("iop_msg_map_bio: null transfer");
   1990  1.11        ad 	if (xfersize > IOP_MAX_XFER)
   1991  1.11        ad 		panic("iop_msg_map_bio: transfer too large");
   1992  1.11        ad 	if ((im->im_flags & IM_SGLOFFADJ) != 0)
   1993  1.11        ad 		panic("iop_msg_map_bio: SGLOFFADJ");
   1994  1.11        ad #endif
   1995  1.11        ad 
   1996  1.11        ad 	ix = im->im_xfer;
   1997  1.11        ad 	dm = ix->ix_map;
   1998  1.15        ad 	rv = bus_dmamap_load(sc->sc_dmat, dm, xferaddr, xfersize, NULL,
   1999  1.15        ad 	    BUS_DMA_NOWAIT | BUS_DMA_STREAMING);
   2000  1.11        ad 	if (rv != 0)
   2001  1.11        ad 		return (rv);
   2002  1.11        ad 
   2003  1.11        ad 	off = mb[0] >> 16;
   2004  1.19        ad 	nsegs = ((sc->sc_framesize >> 2) - off) >> 1;
   2005  1.11        ad 
   2006  1.11        ad 	/*
   2007  1.11        ad 	 * If the transfer is highly fragmented and won't fit using SIMPLE
   2008  1.11        ad 	 * elements, use PAGE_LIST elements instead.  SIMPLE elements are
   2009  1.11        ad 	 * potentially more efficient, both for us and the IOP.
   2010  1.11        ad 	 */
   2011  1.11        ad 	if (dm->dm_nsegs > nsegs) {
   2012  1.11        ad 		nsegs = 1;
   2013  1.11        ad 		p = mb + off + 1;
   2014  1.11        ad 
   2015  1.11        ad 		/* XXX This should be done with a bus_space flag. */
   2016  1.11        ad 		for (i = dm->dm_nsegs, ds = dm->dm_segs; i > 0; i--, ds++) {
   2017  1.11        ad 			slen = ds->ds_len;
   2018  1.11        ad 			saddr = ds->ds_addr;
   2019  1.11        ad 
   2020  1.11        ad 			while (slen > 0) {
   2021  1.11        ad 				eaddr = (saddr + PAGE_SIZE) & ~(PAGE_SIZE - 1);
   2022  1.11        ad 				tlen = min(eaddr - saddr, slen);
   2023  1.11        ad 				slen -= tlen;
   2024  1.11        ad 				*p++ = le32toh(saddr);
   2025  1.11        ad 				saddr = eaddr;
   2026  1.11        ad 				nsegs++;
   2027  1.11        ad 			}
   2028  1.11        ad 		}
   2029  1.11        ad 
   2030  1.11        ad 		mb[off] = xfersize | I2O_SGL_PAGE_LIST | I2O_SGL_END_BUFFER |
   2031  1.11        ad 		    I2O_SGL_END;
   2032  1.11        ad 		if (out)
   2033  1.11        ad 			mb[off] |= I2O_SGL_DATA_OUT;
   2034  1.11        ad 	} else {
   2035  1.11        ad 		p = mb + off;
   2036  1.13        ad 		nsegs = dm->dm_nsegs;
   2037  1.11        ad 
   2038  1.11        ad 		if (out)
   2039  1.11        ad 			flg = I2O_SGL_SIMPLE | I2O_SGL_DATA_OUT;
   2040  1.11        ad 		else
   2041  1.11        ad 			flg = I2O_SGL_SIMPLE;
   2042  1.11        ad 
   2043  1.11        ad 		for (i = nsegs, ds = dm->dm_segs; i > 1; i--, p += 2, ds++) {
   2044  1.11        ad 			p[0] = (u_int32_t)ds->ds_len | flg;
   2045  1.11        ad 			p[1] = (u_int32_t)ds->ds_addr;
   2046  1.11        ad 		}
   2047  1.11        ad 
   2048  1.11        ad 		p[0] = (u_int32_t)ds->ds_len | flg | I2O_SGL_END_BUFFER |
   2049  1.11        ad 		    I2O_SGL_END;
   2050  1.11        ad 		p[1] = (u_int32_t)ds->ds_addr;
   2051  1.11        ad 		nsegs <<= 1;
   2052  1.11        ad 	}
   2053  1.11        ad 
   2054  1.11        ad 	/* Fix up the transfer record, and sync the map. */
   2055  1.11        ad 	ix->ix_flags = (out ? IX_OUT : IX_IN);
   2056  1.11        ad 	ix->ix_size = xfersize;
   2057  1.11        ad 	bus_dmamap_sync(sc->sc_dmat, ix->ix_map, 0, xfersize,
   2058  1.72        ad 	    out ? BUS_DMASYNC_PREWRITE : BUS_DMASYNC_PREREAD);
   2059  1.11        ad 
   2060  1.11        ad 	/*
   2061  1.11        ad 	 * Adjust the SGL offset and total message size fields.  We don't
   2062  1.11        ad 	 * set IM_SGLOFFADJ, since it's used only for SIMPLE elements.
   2063  1.11        ad 	 */
   2064  1.11        ad 	mb[0] += ((off << 4) + (nsegs << 16));
   2065   1.1        ad 	return (0);
   2066   1.1        ad }
   2067   1.1        ad 
   2068   1.1        ad /*
   2069   1.1        ad  * Unmap all data transfers associated with a message wrapper.
   2070   1.1        ad  */
   2071   1.1        ad void
   2072   1.1        ad iop_msg_unmap(struct iop_softc *sc, struct iop_msg *im)
   2073   1.1        ad {
   2074   1.1        ad 	struct iop_xfer *ix;
   2075   1.1        ad 	int i;
   2076  1.11        ad 
   2077  1.47     perry #ifdef I2ODEBUG
   2078  1.11        ad 	if (im->im_xfer[0].ix_size == 0)
   2079  1.11        ad 		panic("iop_msg_unmap: no transfers mapped");
   2080  1.11        ad #endif
   2081  1.11        ad 
   2082  1.11        ad 	for (ix = im->im_xfer, i = 0;;) {
   2083   1.1        ad 		bus_dmamap_sync(sc->sc_dmat, ix->ix_map, 0, ix->ix_size,
   2084   1.1        ad 		    ix->ix_flags & IX_OUT ? BUS_DMASYNC_POSTWRITE :
   2085   1.1        ad 		    BUS_DMASYNC_POSTREAD);
   2086   1.1        ad 		bus_dmamap_unload(sc->sc_dmat, ix->ix_map);
   2087   1.1        ad 
   2088   1.1        ad 		/* Only the first DMA map is static. */
   2089   1.1        ad 		if (i != 0)
   2090   1.1        ad 			bus_dmamap_destroy(sc->sc_dmat, ix->ix_map);
   2091  1.47     perry 		if ((++ix)->ix_size == 0)
   2092  1.11        ad 			break;
   2093  1.11        ad 		if (++i >= IOP_MAX_MSG_XFERS)
   2094  1.11        ad 			break;
   2095   1.1        ad 	}
   2096   1.1        ad }
   2097   1.1        ad 
   2098  1.11        ad /*
   2099  1.11        ad  * Post a message frame to the IOP's inbound queue.
   2100   1.1        ad  */
   2101   1.1        ad int
   2102  1.11        ad iop_post(struct iop_softc *sc, u_int32_t *mb)
   2103   1.1        ad {
   2104  1.11        ad 	u_int32_t mfa;
   2105  1.11        ad 
   2106  1.15        ad #ifdef I2ODEBUG
   2107  1.19        ad 	if ((mb[0] >> 16) > (sc->sc_framesize >> 2))
   2108  1.13        ad 		panic("iop_post: frame too large");
   2109  1.15        ad #endif
   2110  1.13        ad 
   2111  1.65        ad 	mutex_spin_enter(&sc->sc_intrlock);
   2112  1.11        ad 
   2113  1.11        ad 	/* Allocate a slot with the IOP. */
   2114  1.11        ad 	if ((mfa = iop_inl(sc, IOP_REG_IFIFO)) == IOP_MFA_EMPTY)
   2115  1.11        ad 		if ((mfa = iop_inl(sc, IOP_REG_IFIFO)) == IOP_MFA_EMPTY) {
   2116  1.65        ad 			mutex_spin_exit(&sc->sc_intrlock);
   2117  1.82       chs 			aprint_error_dev(sc->sc_dev, "mfa not forthcoming\n");
   2118  1.11        ad 			return (EAGAIN);
   2119  1.11        ad 		}
   2120  1.11        ad 
   2121  1.15        ad 	/* Perform reply buffer DMA synchronisation. */
   2122  1.72        ad 	if (sc->sc_rep_size != 0) {
   2123  1.11        ad 		bus_dmamap_sync(sc->sc_dmat, sc->sc_rep_dmamap, 0,
   2124  1.11        ad 		    sc->sc_rep_size, BUS_DMASYNC_PREREAD);
   2125  1.72        ad 	}
   2126   1.1        ad 
   2127  1.11        ad 	/* Copy out the message frame. */
   2128  1.30        ad 	bus_space_write_region_4(sc->sc_msg_iot, sc->sc_msg_ioh, mfa, mb,
   2129  1.29   msaitoh 	    mb[0] >> 16);
   2130  1.30        ad 	bus_space_barrier(sc->sc_msg_iot, sc->sc_msg_ioh, mfa,
   2131  1.29   msaitoh 	    (mb[0] >> 14) & ~3, BUS_SPACE_BARRIER_WRITE);
   2132  1.11        ad 
   2133  1.11        ad 	/* Post the MFA back to the IOP. */
   2134  1.11        ad 	iop_outl(sc, IOP_REG_IFIFO, mfa);
   2135   1.1        ad 
   2136  1.65        ad 	mutex_spin_exit(&sc->sc_intrlock);
   2137  1.11        ad 	return (0);
   2138  1.11        ad }
   2139   1.1        ad 
   2140  1.11        ad /*
   2141  1.11        ad  * Post a message to the IOP and deal with completion.
   2142  1.11        ad  */
   2143  1.11        ad int
   2144  1.11        ad iop_msg_post(struct iop_softc *sc, struct iop_msg *im, void *xmb, int timo)
   2145  1.11        ad {
   2146  1.11        ad 	u_int32_t *mb;
   2147  1.65        ad 	int rv;
   2148   1.1        ad 
   2149  1.11        ad 	mb = xmb;
   2150   1.1        ad 
   2151  1.11        ad 	/* Terminate the scatter/gather list chain. */
   2152   1.1        ad 	if ((im->im_flags & IM_SGLOFFADJ) != 0)
   2153  1.11        ad 		mb[(mb[0] >> 16) - 2] |= I2O_SGL_END;
   2154   1.1        ad 
   2155  1.11        ad 	if ((rv = iop_post(sc, mb)) != 0)
   2156  1.11        ad 		return (rv);
   2157   1.1        ad 
   2158  1.15        ad 	if ((im->im_flags & (IM_POLL | IM_WAIT)) != 0) {
   2159  1.11        ad 		if ((im->im_flags & IM_POLL) != 0)
   2160  1.11        ad 			iop_msg_poll(sc, im, timo);
   2161  1.11        ad 		else
   2162  1.11        ad 			iop_msg_wait(sc, im, timo);
   2163   1.1        ad 
   2164  1.65        ad 		mutex_spin_enter(&sc->sc_intrlock);
   2165  1.11        ad 		if ((im->im_flags & IM_REPLIED) != 0) {
   2166  1.11        ad 			if ((im->im_flags & IM_NOSTATUS) != 0)
   2167  1.11        ad 				rv = 0;
   2168  1.11        ad 			else if ((im->im_flags & IM_FAIL) != 0)
   2169  1.11        ad 				rv = ENXIO;
   2170  1.11        ad 			else if (im->im_reqstatus != I2O_STATUS_SUCCESS)
   2171  1.11        ad 				rv = EIO;
   2172  1.11        ad 			else
   2173  1.11        ad 				rv = 0;
   2174  1.11        ad 		} else
   2175  1.11        ad 			rv = EBUSY;
   2176  1.65        ad 		mutex_spin_exit(&sc->sc_intrlock);
   2177  1.11        ad 	} else
   2178  1.11        ad 		rv = 0;
   2179  1.11        ad 
   2180  1.11        ad 	return (rv);
   2181  1.11        ad }
   2182  1.11        ad 
   2183  1.47     perry /*
   2184  1.11        ad  * Spin until the specified message is replied to.
   2185  1.11        ad  */
   2186  1.11        ad static void
   2187  1.11        ad iop_msg_poll(struct iop_softc *sc, struct iop_msg *im, int timo)
   2188  1.11        ad {
   2189  1.11        ad 	u_int32_t rmfa;
   2190  1.11        ad 
   2191  1.65        ad 	mutex_spin_enter(&sc->sc_intrlock);
   2192   1.1        ad 
   2193   1.1        ad 	for (timo *= 10; timo != 0; timo--) {
   2194   1.5        ad 		if ((iop_inl(sc, IOP_REG_INTR_STATUS) & IOP_INTR_OFIFO) != 0) {
   2195   1.5        ad 			/* Double read to account for IOP bug. */
   2196   1.5        ad 			rmfa = iop_inl(sc, IOP_REG_OFIFO);
   2197   1.5        ad 			if (rmfa == IOP_MFA_EMPTY)
   2198   1.5        ad 				rmfa = iop_inl(sc, IOP_REG_OFIFO);
   2199  1.11        ad 			if (rmfa != IOP_MFA_EMPTY) {
   2200  1.35    simonb 				iop_handle_reply(sc, rmfa);
   2201  1.11        ad 
   2202  1.11        ad 				/*
   2203  1.11        ad 				 * Return the reply frame to the IOP's
   2204  1.11        ad 				 * outbound FIFO.
   2205  1.11        ad 				 */
   2206  1.11        ad 				iop_outl(sc, IOP_REG_OFIFO, rmfa);
   2207  1.11        ad 			}
   2208   1.5        ad 		}
   2209   1.1        ad 		if ((im->im_flags & IM_REPLIED) != 0)
   2210   1.1        ad 			break;
   2211  1.65        ad 		mutex_spin_exit(&sc->sc_intrlock);
   2212   1.1        ad 		DELAY(100);
   2213  1.65        ad 		mutex_spin_enter(&sc->sc_intrlock);
   2214   1.1        ad 	}
   2215   1.1        ad 
   2216   1.1        ad 	if (timo == 0) {
   2217   1.5        ad #ifdef I2ODEBUG
   2218  1.82       chs 		printf("%s: poll - no reply\n", device_xname(sc->sc_dev));
   2219  1.11        ad 		if (iop_status_get(sc, 1) != 0)
   2220  1.11        ad 			printf("iop_msg_poll: unable to retrieve status\n");
   2221   1.5        ad 		else
   2222  1.11        ad 			printf("iop_msg_poll: IOP state = %d\n",
   2223  1.47     perry 			    (le32toh(sc->sc_status.segnumber) >> 16) & 0xff);
   2224   1.5        ad #endif
   2225   1.1        ad 	}
   2226   1.1        ad 
   2227  1.65        ad 	mutex_spin_exit(&sc->sc_intrlock);
   2228   1.1        ad }
   2229   1.1        ad 
   2230   1.1        ad /*
   2231  1.11        ad  * Sleep until the specified message is replied to.
   2232   1.1        ad  */
   2233  1.11        ad static void
   2234  1.61  christos iop_msg_wait(struct iop_softc *sc, struct iop_msg *im, int timo)
   2235   1.1        ad {
   2236  1.65        ad 	int rv;
   2237   1.1        ad 
   2238  1.65        ad 	mutex_spin_enter(&sc->sc_intrlock);
   2239   1.5        ad 	if ((im->im_flags & IM_REPLIED) != 0) {
   2240  1.65        ad 		mutex_spin_exit(&sc->sc_intrlock);
   2241  1.11        ad 		return;
   2242   1.5        ad 	}
   2243  1.65        ad 	rv = cv_timedwait(&im->im_cv, &sc->sc_intrlock, mstohz(timo));
   2244  1.65        ad 	mutex_spin_exit(&sc->sc_intrlock);
   2245  1.11        ad 
   2246   1.5        ad #ifdef I2ODEBUG
   2247   1.5        ad 	if (rv != 0) {
   2248   1.5        ad 		printf("iop_msg_wait: tsleep() == %d\n", rv);
   2249  1.11        ad 		if (iop_status_get(sc, 0) != 0)
   2250  1.84  christos 			printf("%s: unable to retrieve status\n", __func__);
   2251   1.5        ad 		else
   2252  1.84  christos 			printf("%s: IOP state = %d\n", __func__,
   2253  1.47     perry 			    (le32toh(sc->sc_status.segnumber) >> 16) & 0xff);
   2254   1.5        ad 	}
   2255  1.84  christos #else
   2256  1.84  christos 	__USE(rv);
   2257   1.5        ad #endif
   2258   1.1        ad }
   2259   1.1        ad 
   2260   1.1        ad /*
   2261   1.1        ad  * Release an unused message frame back to the IOP's inbound fifo.
   2262   1.1        ad  */
   2263   1.1        ad static void
   2264   1.1        ad iop_release_mfa(struct iop_softc *sc, u_int32_t mfa)
   2265   1.1        ad {
   2266   1.1        ad 
   2267   1.1        ad 	/* Use the frame to issue a no-op. */
   2268  1.30        ad 	iop_outl_msg(sc, mfa, I2O_VERSION_11 | (4 << 16));
   2269  1.30        ad 	iop_outl_msg(sc, mfa + 4, I2O_MSGFUNC(I2O_TID_IOP, I2O_UTIL_NOP));
   2270  1.30        ad 	iop_outl_msg(sc, mfa + 8, 0);
   2271  1.30        ad 	iop_outl_msg(sc, mfa + 12, 0);
   2272   1.1        ad 
   2273   1.5        ad 	iop_outl(sc, IOP_REG_IFIFO, mfa);
   2274   1.1        ad }
   2275   1.1        ad 
   2276   1.1        ad #ifdef I2ODEBUG
   2277   1.1        ad /*
   2278  1.11        ad  * Dump a reply frame header.
   2279   1.1        ad  */
   2280   1.1        ad static void
   2281  1.11        ad iop_reply_print(struct iop_softc *sc, struct i2o_reply *rb)
   2282   1.1        ad {
   2283   1.5        ad 	u_int function, detail;
   2284   1.1        ad 	const char *statusstr;
   2285   1.1        ad 
   2286   1.5        ad 	function = (le32toh(rb->msgfunc) >> 24) & 0xff;
   2287   1.1        ad 	detail = le16toh(rb->detail);
   2288   1.1        ad 
   2289  1.82       chs 	printf("%s: reply:\n", device_xname(sc->sc_dev));
   2290   1.5        ad 
   2291   1.1        ad 	if (rb->reqstatus < sizeof(iop_status) / sizeof(iop_status[0]))
   2292   1.1        ad 		statusstr = iop_status[rb->reqstatus];
   2293   1.1        ad 	else
   2294   1.1        ad 		statusstr = "undefined error code";
   2295   1.1        ad 
   2296  1.47     perry 	printf("%s:   function=0x%02x status=0x%02x (%s)\n",
   2297  1.82       chs 	    device_xname(sc->sc_dev), function, rb->reqstatus, statusstr);
   2298   1.5        ad 	printf("%s:   detail=0x%04x ictx=0x%08x tctx=0x%08x\n",
   2299  1.82       chs 	    device_xname(sc->sc_dev), detail, le32toh(rb->msgictx),
   2300   1.5        ad 	    le32toh(rb->msgtctx));
   2301  1.82       chs 	printf("%s:   tidi=%d tidt=%d flags=0x%02x\n", device_xname(sc->sc_dev),
   2302   1.5        ad 	    (le32toh(rb->msgfunc) >> 12) & 4095, le32toh(rb->msgfunc) & 4095,
   2303   1.5        ad 	    (le32toh(rb->msgflags) >> 8) & 0xff);
   2304   1.1        ad }
   2305   1.1        ad #endif
   2306   1.1        ad 
   2307   1.1        ad /*
   2308  1.11        ad  * Dump a transport failure reply.
   2309  1.11        ad  */
   2310  1.11        ad static void
   2311  1.11        ad iop_tfn_print(struct iop_softc *sc, struct i2o_fault_notify *fn)
   2312  1.11        ad {
   2313  1.11        ad 
   2314  1.82       chs 	printf("%s: WARNING: transport failure:\n", device_xname(sc->sc_dev));
   2315  1.11        ad 
   2316  1.82       chs 	printf("%s:  ictx=0x%08x tctx=0x%08x\n", device_xname(sc->sc_dev),
   2317  1.11        ad 	    le32toh(fn->msgictx), le32toh(fn->msgtctx));
   2318  1.11        ad 	printf("%s:  failurecode=0x%02x severity=0x%02x\n",
   2319  1.82       chs 	    device_xname(sc->sc_dev), fn->failurecode, fn->severity);
   2320  1.11        ad 	printf("%s:  highestver=0x%02x lowestver=0x%02x\n",
   2321  1.82       chs 	    device_xname(sc->sc_dev), fn->highestver, fn->lowestver);
   2322  1.11        ad }
   2323  1.11        ad 
   2324  1.11        ad /*
   2325   1.5        ad  * Translate an I2O ASCII field into a C string.
   2326   1.1        ad  */
   2327   1.1        ad void
   2328   1.5        ad iop_strvis(struct iop_softc *sc, const char *src, int slen, char *dst, int dlen)
   2329   1.1        ad {
   2330   1.5        ad 	int hc, lc, i, nit;
   2331   1.1        ad 
   2332   1.1        ad 	dlen--;
   2333   1.1        ad 	lc = 0;
   2334   1.1        ad 	hc = 0;
   2335   1.1        ad 	i = 0;
   2336   1.5        ad 
   2337   1.5        ad 	/*
   2338   1.5        ad 	 * DPT use NUL as a space, whereas AMI use it as a terminator.  The
   2339   1.5        ad 	 * spec has nothing to say about it.  Since AMI fields are usually
   2340   1.5        ad 	 * filled with junk after the terminator, ...
   2341   1.5        ad 	 */
   2342   1.5        ad 	nit = (le16toh(sc->sc_status.orgid) != I2O_ORG_DPT);
   2343   1.5        ad 
   2344   1.5        ad 	while (slen-- != 0 && dlen-- != 0) {
   2345   1.5        ad 		if (nit && *src == '\0')
   2346   1.5        ad 			break;
   2347   1.5        ad 		else if (*src <= 0x20 || *src >= 0x7f) {
   2348   1.1        ad 			if (hc)
   2349   1.1        ad 				dst[i++] = ' ';
   2350   1.1        ad 		} else {
   2351   1.1        ad 			hc = 1;
   2352   1.1        ad 			dst[i++] = *src;
   2353   1.1        ad 			lc = i;
   2354   1.1        ad 		}
   2355   1.1        ad 		src++;
   2356   1.1        ad 	}
   2357  1.47     perry 
   2358   1.1        ad 	dst[lc] = '\0';
   2359   1.1        ad }
   2360   1.1        ad 
   2361   1.1        ad /*
   2362  1.11        ad  * Retrieve the DEVICE_IDENTITY parameter group from the target and dump it.
   2363  1.11        ad  */
   2364  1.11        ad int
   2365  1.11        ad iop_print_ident(struct iop_softc *sc, int tid)
   2366  1.11        ad {
   2367  1.11        ad 	struct {
   2368  1.11        ad 		struct	i2o_param_op_results pr;
   2369  1.11        ad 		struct	i2o_param_read_results prr;
   2370  1.11        ad 		struct	i2o_param_device_identity di;
   2371  1.74  gmcgarry 	} __packed p;
   2372  1.11        ad 	char buf[32];
   2373  1.11        ad 	int rv;
   2374  1.11        ad 
   2375  1.16        ad 	rv = iop_field_get_all(sc, tid, I2O_PARAM_DEVICE_IDENTITY, &p,
   2376  1.16        ad 	    sizeof(p), NULL);
   2377  1.11        ad 	if (rv != 0)
   2378  1.11        ad 		return (rv);
   2379  1.11        ad 
   2380  1.11        ad 	iop_strvis(sc, p.di.vendorinfo, sizeof(p.di.vendorinfo), buf,
   2381  1.11        ad 	    sizeof(buf));
   2382  1.11        ad 	printf(" <%s, ", buf);
   2383  1.11        ad 	iop_strvis(sc, p.di.productinfo, sizeof(p.di.productinfo), buf,
   2384  1.11        ad 	    sizeof(buf));
   2385  1.11        ad 	printf("%s, ", buf);
   2386  1.11        ad 	iop_strvis(sc, p.di.revlevel, sizeof(p.di.revlevel), buf, sizeof(buf));
   2387  1.11        ad 	printf("%s>", buf);
   2388  1.11        ad 
   2389  1.11        ad 	return (0);
   2390  1.11        ad }
   2391  1.11        ad 
   2392  1.11        ad /*
   2393   1.5        ad  * Claim or unclaim the specified TID.
   2394   1.1        ad  */
   2395   1.1        ad int
   2396   1.5        ad iop_util_claim(struct iop_softc *sc, struct iop_initiator *ii, int release,
   2397  1.15        ad 	       int flags)
   2398   1.1        ad {
   2399   1.5        ad 	struct iop_msg *im;
   2400  1.11        ad 	struct i2o_util_claim mf;
   2401   1.5        ad 	int rv, func;
   2402   1.5        ad 
   2403   1.5        ad 	func = release ? I2O_UTIL_CLAIM_RELEASE : I2O_UTIL_CLAIM;
   2404  1.15        ad 	im = iop_msg_alloc(sc, IM_WAIT);
   2405   1.5        ad 
   2406  1.11        ad 	/* We can use the same structure, as they're identical. */
   2407  1.11        ad 	mf.msgflags = I2O_MSGFLAGS(i2o_util_claim);
   2408  1.11        ad 	mf.msgfunc = I2O_MSGFUNC(ii->ii_tid, func);
   2409  1.11        ad 	mf.msgictx = ii->ii_ictx;
   2410  1.11        ad 	mf.msgtctx = im->im_tctx;
   2411  1.11        ad 	mf.flags = flags;
   2412   1.5        ad 
   2413  1.11        ad 	rv = iop_msg_post(sc, im, &mf, 5000);
   2414  1.11        ad 	iop_msg_free(sc, im);
   2415   1.5        ad 	return (rv);
   2416  1.47     perry }
   2417   1.5        ad 
   2418   1.5        ad /*
   2419   1.5        ad  * Perform an abort.
   2420   1.5        ad  */
   2421   1.5        ad int iop_util_abort(struct iop_softc *sc, struct iop_initiator *ii, int func,
   2422  1.15        ad 		   int tctxabort, int flags)
   2423   1.5        ad {
   2424   1.5        ad 	struct iop_msg *im;
   2425  1.11        ad 	struct i2o_util_abort mf;
   2426   1.5        ad 	int rv;
   2427   1.5        ad 
   2428  1.15        ad 	im = iop_msg_alloc(sc, IM_WAIT);
   2429   1.1        ad 
   2430  1.11        ad 	mf.msgflags = I2O_MSGFLAGS(i2o_util_abort);
   2431  1.11        ad 	mf.msgfunc = I2O_MSGFUNC(ii->ii_tid, I2O_UTIL_ABORT);
   2432  1.11        ad 	mf.msgictx = ii->ii_ictx;
   2433  1.11        ad 	mf.msgtctx = im->im_tctx;
   2434  1.11        ad 	mf.flags = (func << 24) | flags;
   2435  1.11        ad 	mf.tctxabort = tctxabort;
   2436   1.1        ad 
   2437  1.11        ad 	rv = iop_msg_post(sc, im, &mf, 5000);
   2438  1.11        ad 	iop_msg_free(sc, im);
   2439   1.5        ad 	return (rv);
   2440   1.1        ad }
   2441   1.1        ad 
   2442   1.1        ad /*
   2443  1.11        ad  * Enable or disable reception of events for the specified device.
   2444   1.1        ad  */
   2445   1.5        ad int iop_util_eventreg(struct iop_softc *sc, struct iop_initiator *ii, int mask)
   2446   1.5        ad {
   2447  1.11        ad 	struct i2o_util_event_register mf;
   2448   1.5        ad 
   2449  1.11        ad 	mf.msgflags = I2O_MSGFLAGS(i2o_util_event_register);
   2450  1.11        ad 	mf.msgfunc = I2O_MSGFUNC(ii->ii_tid, I2O_UTIL_EVENT_REGISTER);
   2451  1.11        ad 	mf.msgictx = ii->ii_ictx;
   2452  1.15        ad 	mf.msgtctx = 0;
   2453  1.11        ad 	mf.eventmask = mask;
   2454   1.5        ad 
   2455  1.11        ad 	/* This message is replied to only when events are signalled. */
   2456  1.15        ad 	return (iop_post(sc, (u_int32_t *)&mf));
   2457   1.5        ad }
   2458   1.5        ad 
   2459   1.1        ad int
   2460  1.61  christos iopopen(dev_t dev, int flag, int mode, struct lwp *l)
   2461   1.1        ad {
   2462   1.5        ad 	struct iop_softc *sc;
   2463   1.5        ad 
   2464  1.73   tsutsui 	if ((sc = device_lookup_private(&iop_cd, minor(dev))) == NULL)
   2465  1.11        ad 		return (ENXIO);
   2466  1.11        ad 	if ((sc->sc_flags & IOP_ONLINE) == 0)
   2467   1.1        ad 		return (ENXIO);
   2468   1.5        ad 	if ((sc->sc_flags & IOP_OPEN) != 0)
   2469   1.5        ad 		return (EBUSY);
   2470   1.5        ad 	sc->sc_flags |= IOP_OPEN;
   2471   1.5        ad 
   2472   1.5        ad 	return (0);
   2473   1.1        ad }
   2474   1.1        ad 
   2475   1.5        ad int
   2476  1.61  christos iopclose(dev_t dev, int flag, int mode,
   2477  1.61  christos     struct lwp *l)
   2478   1.1        ad {
   2479   1.5        ad 	struct iop_softc *sc;
   2480   1.1        ad 
   2481  1.73   tsutsui 	sc = device_lookup_private(&iop_cd, minor(dev));
   2482  1.11        ad 	sc->sc_flags &= ~IOP_OPEN;
   2483  1.15        ad 
   2484   1.5        ad 	return (0);
   2485   1.1        ad }
   2486   1.1        ad 
   2487   1.1        ad int
   2488  1.64  christos iopioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
   2489   1.1        ad {
   2490   1.5        ad 	struct iop_softc *sc;
   2491   1.5        ad 	struct iovec *iov;
   2492   1.5        ad 	int rv, i;
   2493   1.5        ad 
   2494  1.73   tsutsui 	sc = device_lookup_private(&iop_cd, minor(dev));
   2495  1.63        ad 	rv = 0;
   2496   1.5        ad 
   2497   1.5        ad 	switch (cmd) {
   2498   1.5        ad 	case IOPIOCPT:
   2499  1.62      elad 		rv = kauth_authorize_device_passthru(l->l_cred, dev,
   2500  1.62      elad 		    KAUTH_REQ_DEVICE_RAWIO_PASSTHRU_ALL, data);
   2501  1.60      elad 		if (rv)
   2502  1.60      elad 			return (rv);
   2503  1.56  christos 
   2504  1.51  christos 		return (iop_passthrough(sc, (struct ioppt *)data, l->l_proc));
   2505   1.5        ad 
   2506  1.11        ad 	case IOPIOCGSTATUS:
   2507  1.11        ad 		iov = (struct iovec *)data;
   2508  1.11        ad 		i = sizeof(struct i2o_status);
   2509  1.11        ad 		if (i > iov->iov_len)
   2510  1.11        ad 			i = iov->iov_len;
   2511  1.11        ad 		else
   2512  1.11        ad 			iov->iov_len = i;
   2513  1.11        ad 		if ((rv = iop_status_get(sc, 0)) == 0)
   2514  1.11        ad 			rv = copyout(&sc->sc_status, iov->iov_base, i);
   2515  1.11        ad 		return (rv);
   2516   1.5        ad 
   2517  1.11        ad 	case IOPIOCGLCT:
   2518  1.11        ad 	case IOPIOCGTIDMAP:
   2519  1.11        ad 	case IOPIOCRECONFIG:
   2520  1.11        ad 		break;
   2521   1.5        ad 
   2522  1.11        ad 	default:
   2523  1.11        ad #if defined(DIAGNOSTIC) || defined(I2ODEBUG)
   2524  1.82       chs 		printf("%s: unknown ioctl %lx\n", device_xname(sc->sc_dev), cmd);
   2525  1.11        ad #endif
   2526  1.11        ad 		return (ENOTTY);
   2527  1.11        ad 	}
   2528   1.5        ad 
   2529  1.63        ad 	mutex_enter(&sc->sc_conflock);
   2530   1.1        ad 
   2531  1.11        ad 	switch (cmd) {
   2532   1.5        ad 	case IOPIOCGLCT:
   2533   1.5        ad 		iov = (struct iovec *)data;
   2534  1.11        ad 		i = le16toh(sc->sc_lct->tablesize) << 2;
   2535   1.5        ad 		if (i > iov->iov_len)
   2536   1.5        ad 			i = iov->iov_len;
   2537   1.5        ad 		else
   2538   1.5        ad 			iov->iov_len = i;
   2539  1.11        ad 		rv = copyout(sc->sc_lct, iov->iov_base, i);
   2540   1.5        ad 		break;
   2541   1.5        ad 
   2542   1.5        ad 	case IOPIOCRECONFIG:
   2543  1.63        ad 		rv = iop_reconfigure(sc, 0);
   2544   1.9        ad 		break;
   2545   1.9        ad 
   2546   1.9        ad 	case IOPIOCGTIDMAP:
   2547   1.9        ad 		iov = (struct iovec *)data;
   2548  1.11        ad 		i = sizeof(struct iop_tidmap) * sc->sc_nlctent;
   2549  1.11        ad 		if (i > iov->iov_len)
   2550  1.11        ad 			i = iov->iov_len;
   2551  1.11        ad 		else
   2552  1.11        ad 			iov->iov_len = i;
   2553  1.11        ad 		rv = copyout(sc->sc_tidmap, iov->iov_base, i);
   2554  1.11        ad 		break;
   2555  1.11        ad 	}
   2556  1.11        ad 
   2557  1.63        ad 	mutex_exit(&sc->sc_conflock);
   2558  1.11        ad 	return (rv);
   2559  1.11        ad }
   2560  1.11        ad 
   2561  1.11        ad static int
   2562  1.15        ad iop_passthrough(struct iop_softc *sc, struct ioppt *pt, struct proc *p)
   2563  1.11        ad {
   2564  1.11        ad 	struct iop_msg *im;
   2565  1.11        ad 	struct i2o_msg *mf;
   2566  1.11        ad 	struct ioppt_buf *ptb;
   2567  1.11        ad 	int rv, i, mapped;
   2568  1.11        ad 
   2569  1.11        ad 	mf = NULL;
   2570  1.11        ad 	im = NULL;
   2571  1.11        ad 	mapped = 1;
   2572  1.11        ad 
   2573  1.19        ad 	if (pt->pt_msglen > sc->sc_framesize ||
   2574  1.11        ad 	    pt->pt_msglen < sizeof(struct i2o_msg) ||
   2575  1.11        ad 	    pt->pt_nbufs > IOP_MAX_MSG_XFERS ||
   2576  1.57  christos 	    pt->pt_nbufs < 0 ||
   2577  1.57  christos #if 0
   2578  1.57  christos 	    pt->pt_replylen < 0 ||
   2579  1.57  christos #endif
   2580  1.11        ad             pt->pt_timo < 1000 || pt->pt_timo > 5*60*1000)
   2581  1.11        ad 		return (EINVAL);
   2582  1.11        ad 
   2583  1.11        ad 	for (i = 0; i < pt->pt_nbufs; i++)
   2584  1.11        ad 		if (pt->pt_bufs[i].ptb_datalen > IOP_MAX_XFER) {
   2585  1.11        ad 			rv = ENOMEM;
   2586  1.11        ad 			goto bad;
   2587  1.11        ad 		}
   2588  1.11        ad 
   2589  1.19        ad 	mf = malloc(sc->sc_framesize, M_DEVBUF, M_WAITOK);
   2590  1.11        ad 	if (mf == NULL)
   2591  1.11        ad 		return (ENOMEM);
   2592  1.11        ad 
   2593  1.11        ad 	if ((rv = copyin(pt->pt_msg, mf, pt->pt_msglen)) != 0)
   2594  1.11        ad 		goto bad;
   2595  1.11        ad 
   2596  1.15        ad 	im = iop_msg_alloc(sc, IM_WAIT | IM_NOSTATUS);
   2597  1.11        ad 	im->im_rb = (struct i2o_reply *)mf;
   2598  1.11        ad 	mf->msgictx = IOP_ICTX;
   2599  1.11        ad 	mf->msgtctx = im->im_tctx;
   2600  1.11        ad 
   2601  1.11        ad 	for (i = 0; i < pt->pt_nbufs; i++) {
   2602  1.11        ad 		ptb = &pt->pt_bufs[i];
   2603  1.15        ad 		rv = iop_msg_map(sc, im, (u_int32_t *)mf, ptb->ptb_data,
   2604  1.15        ad 		    ptb->ptb_datalen, ptb->ptb_out != 0, p);
   2605  1.11        ad 		if (rv != 0)
   2606  1.11        ad 			goto bad;
   2607  1.11        ad 		mapped = 1;
   2608  1.11        ad 	}
   2609  1.11        ad 
   2610  1.11        ad 	if ((rv = iop_msg_post(sc, im, mf, pt->pt_timo)) != 0)
   2611  1.11        ad 		goto bad;
   2612  1.11        ad 
   2613  1.11        ad 	i = (le32toh(im->im_rb->msgflags) >> 14) & ~3;
   2614  1.19        ad 	if (i > sc->sc_framesize)
   2615  1.19        ad 		i = sc->sc_framesize;
   2616  1.11        ad 	if (i > pt->pt_replylen)
   2617  1.11        ad 		i = pt->pt_replylen;
   2618  1.15        ad 	rv = copyout(im->im_rb, pt->pt_reply, i);
   2619   1.9        ad 
   2620  1.11        ad  bad:
   2621  1.11        ad 	if (mapped != 0)
   2622  1.11        ad 		iop_msg_unmap(sc, im);
   2623  1.11        ad 	if (im != NULL)
   2624  1.11        ad 		iop_msg_free(sc, im);
   2625  1.11        ad 	if (mf != NULL)
   2626  1.11        ad 		free(mf, M_DEVBUF);
   2627   1.1        ad 	return (rv);
   2628   1.5        ad }
   2629