The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/i2o/iop.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

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

Cache object: 7fd94e9d8698f4294a191f56513c51c2


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.