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-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: 19aa373c7548daad30244238da7d3c11


[ 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.