root/dev/i2o/iop.c

DEFINITIONS

1. iop_inl
2. iop_outl
3. iop_init
4. iop_config_interrupts
5. iop_create_reconf_thread
6. iop_reconf_thread
7. iop_reconfigure
8. iop_configure_devices
9. iop_adjqparam
10. iop_devinfo
11. iop_print
12. iop_vendor_print
13. iop_submatch
14. iop_shutdown
15. iop_status_get
16. iop_ofifo_init
17. iop_hrt_get0
18. iop_hrt_get
19. iop_lct_get0
20. iop_lct_get
21. iop_param_op
22. iop_simple_cmd
23. iop_systab_set
24. iop_reset
25. iop_initiator_register
26. iop_initiator_unregister
27. iop_handle_reply
28. iop_intr
29. iop_intr_event
30. iop_msg_alloc
31. iop_msg_free
32. iop_msg_map
33. iop_msg_map_bio
34. iop_msg_unmap
35. iop_post
36. iop_msg_post
37. iop_msg_poll
38. iop_msg_wait
39. iop_release_mfa
40. iop_reply_print
41. iop_tfn_print
42. iop_strvis
43. iop_print_ident
44. iop_util_claim
45. iop_util_abort
46. iop_util_eventreg
47. iopopen
48. iopclose
49. iopioctl
50. iop_passthrough

    1 /*      $OpenBSD: iop.c,v 1.29 2006/11/29 12:24:17 miod Exp $   */
    2 /*      $NetBSD: iop.c,v 1.12 2001/03/21 14:27:05 ad Exp $      */
    4 /*-
    5  * Copyright (c) 2000, 2001 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Andrew Doran.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *        This product includes software developed by the NetBSD
   22  *        Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   40 /*
   41  * Support for I2O IOPs (intelligent I/O processors).
   42  */
   44 #include <sys/param.h>
   45 #include <sys/systm.h>
   46 #include <sys/kernel.h>
   47 #include <sys/device.h>
   48 #include <sys/queue.h>
   49 #include <sys/proc.h>
   50 #include <sys/malloc.h>
   51 #include <sys/ioctl.h>
   52 #include <sys/endian.h>
   53 #include <sys/conf.h>
   54 #include <sys/kthread.h>
   56 #include <uvm/uvm_extern.h>
   58 #include <machine/bus.h>
   60 #include <dev/i2o/i2o.h>
   61 #include <dev/i2o/iopio.h>
   62 #include <dev/i2o/iopreg.h>
   63 #include <dev/i2o/iopvar.h>
   65 #define POLL(ms, cond)                          \
   66 do {                                            \
   67         int i;                                  \
   68         for (i = (ms) * 10; i; i--) {           \
   69                 if (cond)                       \
   70                         break;                  \
DELAY(100);                     \
   72         }                                       \
   73 } while (/* CONSTCOND */0);
   75 #ifdef I2ODEBUG
   76 #define DPRINTF(x)      printf x
   77 #else
   78 #define DPRINTF(x)
   79 #endif
   81 #ifdef I2OVERBOSE
   82 #define IFVERBOSE(x)    x
   83 #define COMMENT(x)      NULL
   84 #else
   85 #define IFVERBOSE(x)
   86 #define COMMENT(x)
   87 #endif
   89 #define IOP_ICTXHASH_NBUCKETS   16
   90 #define IOP_ICTXHASH(ictx)      (&iop_ictxhashtbl[(ictx) & iop_ictxhash])
   92 #define IOP_MAX_SEGS    (((IOP_MAX_XFER + PAGE_SIZE - 1) / PAGE_SIZE) + 1)
   94 #define IOP_TCTX_SHIFT  12
   95 #define IOP_TCTX_MASK   ((1 << IOP_TCTX_SHIFT) - 1)
LIST_HEAD(, iop_initiator) *iop_ictxhashtbl;
u_long  iop_ictxhash;
   99 void    *iop_sdh;
  100 struct  i2o_systab *iop_systab;
  101 int     iop_systab_size;
  103 struct cfdriver iop_cd = {
NULL, "iop", DV_DULL
  105 };
  107 #define IC_CONFIGURE    0x01
  108 #define IC_PRIORITY     0x02
  110 struct iop_class {
u_short ic_class;
u_short ic_flags;
  113 #ifdef I2OVERBOSE
  114         const char      *ic_caption;
  115 #endif
  116 } static const iop_class[] = {
  117         {       
I2O_CLASS_EXECUTIVE,
  119                 0,
COMMENT("executive")
  121         },
  122         {
I2O_CLASS_DDM,
  124                 0,
COMMENT("device driver module")
  126         },
  127         {
I2O_CLASS_RANDOM_BLOCK_STORAGE,
IC_CONFIGURE | IC_PRIORITY,
IFVERBOSE("random block storage")
  131         },
  132         {
I2O_CLASS_SEQUENTIAL_STORAGE,
IC_CONFIGURE | IC_PRIORITY,
IFVERBOSE("sequential storage")
  136         },
  137         {
I2O_CLASS_LAN,
IC_CONFIGURE | IC_PRIORITY,
IFVERBOSE("LAN port")
  141         },
  142         {
I2O_CLASS_WAN,
IC_CONFIGURE | IC_PRIORITY,
IFVERBOSE("WAN port")
  146         },
  147         {
I2O_CLASS_FIBRE_CHANNEL_PORT,
IC_CONFIGURE,
IFVERBOSE("fibrechannel port")
  151         },
  152         {
I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL,
  154                 0,
COMMENT("fibrechannel peripheral")
  156         },
  157         {
I2O_CLASS_SCSI_PERIPHERAL,
  159                 0,
COMMENT("SCSI peripheral")
  161         },
  162         {
I2O_CLASS_ATE_PORT,
IC_CONFIGURE,
IFVERBOSE("ATE port")
  166         },
  167         {       
I2O_CLASS_ATE_PERIPHERAL,
  169                 0,
COMMENT("ATE peripheral")
  171         },
  172         {       
I2O_CLASS_FLOPPY_CONTROLLER,
IC_CONFIGURE,
IFVERBOSE("floppy controller")
  176         },
  177         {
I2O_CLASS_FLOPPY_DEVICE,
  179                 0,
COMMENT("floppy device")
  181         },
  182         {
I2O_CLASS_BUS_ADAPTER_PORT,
IC_CONFIGURE,
IFVERBOSE("bus adapter port" )
  186         },
  187 };
  189 #if defined(I2ODEBUG) && defined(I2OVERBOSE)
  190 static const char * const iop_status[] = {
  191         "success",
  192         "abort (dirty)",
  193         "abort (no data transfer)",
  194         "abort (partial transfer)",
  195         "error (dirty)",
  196         "error (no data transfer)",
  197         "error (partial transfer)",
  198         "undefined error code",
  199         "process abort (dirty)",
  200         "process abort (no data transfer)",
  201         "process abort (partial transfer)",
  202         "transaction error",
  203 };
  204 #endif
  206 static inline u_int32_t iop_inl(struct iop_softc *, int);
  207 static inline void      iop_outl(struct iop_softc *, int, u_int32_t);
  209 void    iop_config_interrupts(struct device *);
  210 void    iop_configure_devices(struct iop_softc *, int, int);
  211 void    iop_devinfo(int, char *, size_t);
  212 int     iop_print(void *, const char *);
  213 int     iop_reconfigure(struct iop_softc *, u_int);
  214 void    iop_shutdown(void *);
  215 int     iop_submatch(struct device *, void *, void *);
  216 #ifdef notyet
  217 int     iop_vendor_print(void *, const char *);
  218 #endif
  220 void    iop_adjqparam(struct iop_softc *, int);
  221 void    iop_create_reconf_thread(void *);
  222 int     iop_handle_reply(struct iop_softc *, u_int32_t);
  223 int     iop_hrt_get(struct iop_softc *);
  224 int     iop_hrt_get0(struct iop_softc *, struct i2o_hrt *, size_t);
  225 void    iop_intr_event(struct device *, struct iop_msg *, void *);
  226 int     iop_lct_get0(struct iop_softc *, struct i2o_lct *, size_t, u_int32_t);
  227 void    iop_msg_poll(struct iop_softc *, struct iop_msg *, int);
  228 void    iop_msg_wait(struct iop_softc *, struct iop_msg *, int);
  229 int     iop_ofifo_init(struct iop_softc *);
  230 int     iop_passthrough(struct iop_softc *, struct ioppt *);
  231 int     iop_post(struct iop_softc *, u_int32_t *);
  232 void    iop_reconf_thread(void *);
  233 void    iop_release_mfa(struct iop_softc *, u_int32_t);
  234 int     iop_reset(struct iop_softc *);
  235 int     iop_status_get(struct iop_softc *, int);
  236 int     iop_systab_set(struct iop_softc *);
  237 void    iop_tfn_print(struct iop_softc *, struct i2o_fault_notify *);
  239 #ifdef I2ODEBUG
  240 void    iop_reply_print(struct iop_softc *, struct i2o_reply *);
  241 #endif
cdev_decl(iop);
  245 static inline u_int32_t
iop_inl(struct iop_softc *sc, int off)
  247 {
bus_space_barrier(sc->sc_iot, sc->sc_ioh, off, 4,
BUS_SPACE_BARRIER_WRITE | BUS_SPACE_BARRIER_READ);
  251         return (bus_space_read_4(sc->sc_iot, sc->sc_ioh, off));
  252 }
  254 static inline void
iop_outl(struct iop_softc *sc, int off, u_int32_t val)
  256 {
bus_space_write_4(sc->sc_iot, sc->sc_ioh, off, val);
bus_space_barrier(sc->sc_iot, sc->sc_ioh, off, 4,
BUS_SPACE_BARRIER_WRITE);
  261 }
  263 /*
  264  * Initialise the IOP and our interface.
  265  */
  266 void
iop_init(struct iop_softc *sc, const char *intrstr)
  268 {
  269         struct iop_msg *im;
u_int32_t mask;
  271         char ident[64];
  272         int rv, i, nsegs;
  273         int state = 0;
  275         if (iop_ictxhashtbl == NULL) {
iop_ictxhashtbl = hashinit(IOP_ICTXHASH_NBUCKETS, M_DEVBUF,
M_NOWAIT, &iop_ictxhash);
  278                 if (iop_ictxhashtbl == NULL) {
printf("%s: cannot allocate hashtable\n",
sc->sc_dv.dv_xname);
  281                         return;
  282                 }
  283         }
  285         /* Reset the IOP and request status. */
printf("I2O adapter");
  288         /* Allocate a scratch DMA map for small miscellaneous shared data. */
  289         if (bus_dmamap_create(sc->sc_dmat, PAGE_SIZE, 1, PAGE_SIZE, 0,
BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &sc->sc_scr_dmamap) != 0) {
printf("%s: cannot create scratch dmamap\n",
sc->sc_dv.dv_xname);
  293                 return;
  294         }
state++;
  297         if (bus_dmamem_alloc(sc->sc_dmat, PAGE_SIZE, PAGE_SIZE, 0,
sc->sc_scr_seg, 1, &nsegs, BUS_DMA_NOWAIT) != 0) {
printf("%s: cannot alloc scratch dmamem\n",
sc->sc_dv.dv_xname);
  301                 goto bail_out;
  302         }
state++;
  305         if (bus_dmamem_map(sc->sc_dmat, sc->sc_scr_seg, nsegs, PAGE_SIZE,
  306             &sc->sc_scr, 0)) {
printf("%s: cannot map scratch dmamem\n", sc->sc_dv.dv_xname);
  308                 goto bail_out;
  309         }
state++;
  312         if (bus_dmamap_load(sc->sc_dmat, sc->sc_scr_dmamap, sc->sc_scr,
PAGE_SIZE, NULL, BUS_DMA_NOWAIT)) {
printf("%s: cannot load scratch dmamap\n", sc->sc_dv.dv_xname);
  315                 goto bail_out;
  316         }
state++;
  319         if ((rv = iop_reset(sc)) != 0) {
printf("%s: not responding (reset)\n", sc->sc_dv.dv_xname);
  321                 goto bail_out;
  322         }
  323         if ((rv = iop_status_get(sc, 1)) != 0) {
printf("%s: not responding (get status)\n",
sc->sc_dv.dv_xname);
  326                 goto bail_out;
  327         }
sc->sc_flags |= IOP_HAVESTATUS;
iop_strvis(sc, sc->sc_status.productid,
  330             sizeof(sc->sc_status.productid), ident, sizeof(ident));
printf(" <%s>\n", ident);
  333 #ifdef I2ODEBUG
printf("%s: orgid=0x%04x version=%d\n", sc->sc_dv.dv_xname,
letoh16(sc->sc_status.orgid),
  336             (letoh32(sc->sc_status.segnumber) >> 12) & 15);
printf("%s: type want have cbase\n", sc->sc_dv.dv_xname);
printf("%s: mem  %04x %04x %08x\n", sc->sc_dv.dv_xname,
letoh32(sc->sc_status.desiredprivmemsize),
letoh32(sc->sc_status.currentprivmemsize),
letoh32(sc->sc_status.currentprivmembase));
printf("%s: i/o  %04x %04x %08x\n", sc->sc_dv.dv_xname,
letoh32(sc->sc_status.desiredpriviosize),
letoh32(sc->sc_status.currentpriviosize),
letoh32(sc->sc_status.currentpriviobase));
  346 #endif
sc->sc_maxob = letoh32(sc->sc_status.maxoutboundmframes);
  349         if (sc->sc_maxob > IOP_MAX_OUTBOUND)
sc->sc_maxob = IOP_MAX_OUTBOUND;
sc->sc_maxib = letoh32(sc->sc_status.maxinboundmframes);
  352         if (sc->sc_maxib > IOP_MAX_INBOUND)
sc->sc_maxib = IOP_MAX_INBOUND;
  355         /* Allocate message wrappers. */
im = malloc(sizeof(*im) * sc->sc_maxib, M_DEVBUF, M_NOWAIT);
  357         if (!im) {
printf("%s: couldn't allocate message", sc->sc_dv.dv_xname);
  359                 goto bail_out;
  360         }
state++;
bzero(im, sizeof(*im) * sc->sc_maxib);
sc->sc_ims = im;
SLIST_INIT(&sc->sc_im_freelist);
  367         for (i = 0; i < sc->sc_maxib; i++, im++) {
rv = bus_dmamap_create(sc->sc_dmat, IOP_MAX_XFER,
IOP_MAX_SEGS, IOP_MAX_XFER, 0,
BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
  371                     &im->im_xfer[0].ix_map);
  372                 if (rv != 0) {
printf("%s: couldn't create dmamap (%d)",
sc->sc_dv.dv_xname, rv);
  375                         goto bail_out;
  376                 }
im->im_tctx = i;
SLIST_INSERT_HEAD(&sc->sc_im_freelist, im, im_chain);
  380         }
  382         /* Initalise the IOP's outbound FIFO. */
  383         if (iop_ofifo_init(sc) != 0) {
printf("%s: unable to init outbound FIFO\n",
sc->sc_dv.dv_xname);
  386                 goto bail_out;
  387         }
  389         /* Configure shutdown hook before we start any device activity. */
  390         if (iop_sdh == NULL)
iop_sdh = shutdownhook_establish(iop_shutdown, NULL);
  393         /* Ensure interrupts are enabled at the IOP. */
mask = iop_inl(sc, IOP_REG_INTR_MASK);
iop_outl(sc, IOP_REG_INTR_MASK, mask & ~IOP_INTR_OFIFO);
  397         if (intrstr != NULL)
printf("%s: interrupting at %s\n", sc->sc_dv.dv_xname,
intrstr);
  401 #ifdef I2ODEBUG
printf("%s: queue depths: inbound %d/%d, outbound %d/%d\n",
sc->sc_dv.dv_xname, sc->sc_maxib,
letoh32(sc->sc_status.maxinboundmframes),
sc->sc_maxob, letoh32(sc->sc_status.maxoutboundmframes));
  406 #endif
lockinit(&sc->sc_conflock, PRIBIO, "iopconf", 0, 0);
startuphook_establish((void (*)(void *))iop_config_interrupts, sc);
  411         return;
bail_out:
  414         if (state > 4)
free(im, M_DEVBUF);
  416         if (state > 3)
bus_dmamap_unload(sc->sc_dmat, sc->sc_scr_dmamap);
  418         if (state > 2)
bus_dmamem_unmap(sc->sc_dmat, sc->sc_scr, PAGE_SIZE);
  420         if (state > 1)
bus_dmamem_free(sc->sc_dmat, sc->sc_scr_seg, nsegs);
  422         if (state > 0)
bus_dmamap_destroy(sc->sc_dmat, sc->sc_scr_dmamap);
  424 }
  426 /*
  427  * Perform autoconfiguration tasks.
  428  */
  429 void
iop_config_interrupts(struct device *self)
  431 {
  432         struct iop_softc *sc, *iop;
  433         struct i2o_systab_entry *ste;
  434         int rv, i, niop;
sc = (struct iop_softc *)self;
LIST_INIT(&sc->sc_iilist);
printf("%s: configuring...\n", sc->sc_dv.dv_xname);
  441         if (iop_hrt_get(sc) != 0) {
printf("%s: unable to retrieve HRT\n", sc->sc_dv.dv_xname);
  443                 return;
  444         }
  446         /*
  447          * Build the system table.
  448          */
  449         if (iop_systab == NULL) {
  450                 for (i = 0, niop = 0; i < iop_cd.cd_ndevs; i++) {
iop = (struct iop_softc *)device_lookup(&iop_cd, i);
  452                         if (iop == NULL)
  453                                 continue;
  454                         if ((iop->sc_flags & IOP_HAVESTATUS) == 0)
  455                                 continue;
  456                         if (iop_status_get(iop, 1) != 0) {
printf("%s: unable to retrieve status\n",
sc->sc_dv.dv_xname);
iop->sc_flags &= ~IOP_HAVESTATUS;
  460                                 continue;
  461                         }
niop++;
  463                 }
  464                 if (niop == 0)
  465                         return;
i = sizeof(struct i2o_systab_entry) * (niop - 1) +
  468                     sizeof(struct i2o_systab);
iop_systab_size = i;
iop_systab = malloc(i, M_DEVBUF, M_NOWAIT);
  471                 if (!iop_systab)
  472                         return;
bzero(iop_systab, i);
iop_systab->numentries = niop;
iop_systab->version = I2O_VERSION_11;
  478                 for (i = 0, ste = iop_systab->entry; i < iop_cd.cd_ndevs; i++)
  479                     {
iop = (struct iop_softc *)device_lookup(&iop_cd, i);
  481                         if (iop == NULL)
  482                                 continue;
  483                         if ((iop->sc_flags & IOP_HAVESTATUS) == 0)
  484                                 continue;
ste->orgid = iop->sc_status.orgid;
ste->iopid = iop->sc_dv.dv_unit + 2;
ste->segnumber =
htole32(letoh32(iop->sc_status.segnumber) & ~4095);
ste->iopcaps = iop->sc_status.iopcaps;
ste->inboundmsgframesize =
iop->sc_status.inboundmframesize;
ste->inboundmsgportaddresslow =
htole32(iop->sc_memaddr + IOP_REG_IFIFO);
ste++;
  496                 }
  497         }
  499         /*
  500          * Post the system table to the IOP and bring it to the OPERATIONAL
  501          * state.
  502          */
  503         if (iop_systab_set(sc) != 0) {
printf("%s: unable to set system table\n", sc->sc_dv.dv_xname);
  505                 return;
  506         }
  507         if (iop_simple_cmd(sc, I2O_TID_IOP, I2O_EXEC_SYS_ENABLE, IOP_ICTX, 1,
  508             30000) != 0) {
printf("%s: unable to enable system\n", sc->sc_dv.dv_xname);
  510                 return;
  511         }
  513         /*
  514          * Set up an event handler for this IOP.
  515          */
sc->sc_eventii.ii_dv = self;
sc->sc_eventii.ii_intr = iop_intr_event;
sc->sc_eventii.ii_flags = II_DISCARD | II_UTILITY;
sc->sc_eventii.ii_tid = I2O_TID_IOP;
iop_initiator_register(sc, &sc->sc_eventii);
rv = iop_util_eventreg(sc, &sc->sc_eventii,
I2O_EVENT_EXEC_RESOURCE_LIMITS |
I2O_EVENT_EXEC_CONNECTION_FAIL |
I2O_EVENT_EXEC_ADAPTER_FAULT |
I2O_EVENT_EXEC_POWER_FAIL |
I2O_EVENT_EXEC_RESET_PENDING |
I2O_EVENT_EXEC_RESET_IMMINENT |
I2O_EVENT_EXEC_HARDWARE_FAIL |
I2O_EVENT_EXEC_XCT_CHANGE |
I2O_EVENT_EXEC_DDM_AVAILIBILITY |
I2O_EVENT_GEN_DEVICE_RESET |
I2O_EVENT_GEN_STATE_CHANGE |
I2O_EVENT_GEN_GENERAL_WARNING);
  535         if (rv != 0) {
printf("%s: unable to register for events",
sc->sc_dv.dv_xname);
  538                 return;
  539         }
  541 #ifdef notyet
  542         /* Attempt to match and attach a product-specific extension. */
ia.ia_class = I2O_CLASS_ANY;
ia.ia_tid = I2O_TID_IOP;
config_found_sm(self, &ia, iop_vendor_print, iop_submatch);
  546 #endif
lockmgr(&sc->sc_conflock, LK_EXCLUSIVE, NULL);
  549         if ((rv = iop_reconfigure(sc, 0)) == -1) {
printf("%s: configure failed (%d)\n", sc->sc_dv.dv_xname, rv);
  551                 return;
  552         }
lockmgr(&sc->sc_conflock, LK_RELEASE, NULL);
kthread_create_deferred(iop_create_reconf_thread, sc);
  555 }
  557 /*
  558  * Create the reconfiguration thread.  Called after the standard kernel
  559  * threads have been created.
  560  */
  561 void
iop_create_reconf_thread(void *cookie)
  563 {
  564         struct iop_softc *sc;
  565         int rv;
sc = cookie;
sc->sc_flags |= IOP_ONLINE;
rv = kthread_create(iop_reconf_thread, sc, &sc->sc_reconf_proc,
  571             "%s", sc->sc_dv.dv_xname);
  572         if (rv != 0) {
printf("%s: unable to create reconfiguration thread (%d)",
sc->sc_dv.dv_xname, rv);
  575                 return;
  576         }
  577 }
  579 /*
  580  * Reconfiguration thread; listens for LCT change notification, and
  581  * initiates re-configuration if received.
  582  */
  583 void
iop_reconf_thread(void *cookie)
  585 {
  586         struct iop_softc *sc = cookie;
  587         struct i2o_lct lct;
u_int32_t chgind;
  589         int rv;
chgind = sc->sc_chgind + 1;
  593         for (;;) {
DPRINTF(("%s: async reconfig: requested 0x%08x\n",
sc->sc_dv.dv_xname, chgind));
rv = iop_lct_get0(sc, &lct, sizeof(lct), chgind);
DPRINTF(("%s: async reconfig: notified (0x%08x, %d)\n",
sc->sc_dv.dv_xname, letoh32(lct.changeindicator), rv));
  602                 if (rv == 0 &&
lockmgr(&sc->sc_conflock, LK_EXCLUSIVE, NULL) == 0) {
iop_reconfigure(sc, letoh32(lct.changeindicator));
chgind = sc->sc_chgind + 1;
lockmgr(&sc->sc_conflock, LK_RELEASE, NULL);
  607                 }
tsleep(iop_reconf_thread, PWAIT, "iopzzz", hz * 5);
  610         }
  611 }
  613 /*
  614  * Reconfigure: find new and removed devices.
  615  */
  616 int
iop_reconfigure(struct iop_softc *sc, u_int chgind)
  618 {
  619         struct iop_msg *im;
  620         struct i2o_hba_bus_scan mf;
  621         struct i2o_lct_entry *le;
  622         struct iop_initiator *ii, *nextii;
  623         int rv, tid, i;
  625         /*
  626          * If the reconfiguration request isn't the result of LCT change
  627          * notification, then be more thorough: ask all bus ports to scan
  628          * their busses.  Wait up to 5 minutes for each bus port to complete
  629          * the request.
  630          */
  631         if (chgind == 0) {
  632                 if ((rv = iop_lct_get(sc)) != 0) {
DPRINTF(("iop_reconfigure: unable to read LCT\n"));
  634                         return (rv);
  635                 }
le = sc->sc_lct->entry;
  638                 for (i = 0; i < sc->sc_nlctent; i++, le++) {
  639                         if ((letoh16(le->classid) & I2O_CLASS_MASK) !=
I2O_CLASS_BUS_ADAPTER_PORT)
  641                                 continue;
tid = letoh16(le->localtid) & I2O_CLASS_MASK;
im = iop_msg_alloc(sc, NULL, IM_WAIT);
mf.msgflags = I2O_MSGFLAGS(i2o_hba_bus_scan);
mf.msgfunc = I2O_MSGFUNC(tid, I2O_HBA_BUS_SCAN);
mf.msgictx = IOP_ICTX;
mf.msgtctx = im->im_tctx;
DPRINTF(("%s: scanning bus %d\n", sc->sc_dv.dv_xname,
tid));
rv = iop_msg_post(sc, im, &mf, 5*60*1000);
iop_msg_free(sc, im);
  656 #ifdef I2ODEBUG
  657                         if (rv != 0)
printf("%s: bus scan failed, status =%d\n",
sc->sc_dv.dv_xname, rv);
  660 #endif
  661                 }
  662         } else if (chgind <= sc->sc_chgind) {
DPRINTF(("%s: LCT unchanged (async)\n", sc->sc_dv.dv_xname));
  664                 return (0);
  665         }
  667         /* Re-read the LCT and determine if it has changed. */
  668         if ((rv = iop_lct_get(sc)) != 0) {
DPRINTF(("iop_reconfigure: unable to re-read LCT\n"));
  670                 return (rv);
  671         }
DPRINTF(("%s: %d LCT entries\n", sc->sc_dv.dv_xname, sc->sc_nlctent));
chgind = letoh32(sc->sc_lct->changeindicator);
  675         if (chgind == sc->sc_chgind) {
DPRINTF(("%s: LCT unchanged\n", sc->sc_dv.dv_xname));
  677                 return (0);
  678         }
DPRINTF(("%s: LCT changed\n", sc->sc_dv.dv_xname));
sc->sc_chgind = chgind;
  682         if (sc->sc_tidmap != NULL)
free(sc->sc_tidmap, M_DEVBUF);
sc->sc_tidmap = malloc(sc->sc_nlctent * sizeof(struct iop_tidmap),
M_DEVBUF, M_NOWAIT);
  686         if (!sc->sc_tidmap) {
DPRINTF(("iop_reconfigure: out of memory\n"));
  688                 return (ENOMEM);
  689         }
bzero(sc->sc_tidmap, sc->sc_nlctent * sizeof(struct iop_tidmap));
  692         /* Allow 1 queued command per device while we're configuring. */
iop_adjqparam(sc, 1);
  695         /*
  696          * Match and attach child devices.  We configure high-level devices
  697          * first so that any claims will propagate throughout the LCT,
  698          * hopefully masking off aliased devices as a result.
  699          *
  700          * Re-reading the LCT at this point is a little dangerous, but we'll
  701          * trust the IOP (and the operator) to behave itself...
  702          */
iop_configure_devices(sc, IC_CONFIGURE | IC_PRIORITY,
IC_CONFIGURE | IC_PRIORITY);
  705         if ((rv = iop_lct_get(sc)) != 0)
DPRINTF(("iop_reconfigure: unable to re-read LCT\n"));
iop_configure_devices(sc, IC_CONFIGURE | IC_PRIORITY,
IC_CONFIGURE);
  710         for (ii = LIST_FIRST(&sc->sc_iilist); ii != NULL; ii = nextii) {
nextii = LIST_NEXT(ii, ii_list);
  713                 /* Detach devices that were configured, but are now gone. */
  714                 for (i = 0; i < sc->sc_nlctent; i++)
  715                         if (ii->ii_tid == sc->sc_tidmap[i].it_tid)
  716                                 break;
  717                 if (i == sc->sc_nlctent ||
  718                     (sc->sc_tidmap[i].it_flags & IT_CONFIGURED) == 0)
config_detach(ii->ii_dv, DETACH_FORCE);
  721                 /*
  722                  * Tell initiators that existed before the re-configuration
  723                  * to re-configure.
  724                  */
  725                 if (ii->ii_reconfig == NULL)
  726                         continue;
  727                 if ((rv = (*ii->ii_reconfig)(ii->ii_dv)) != 0)
printf("%s: %s failed reconfigure (%d)\n",
sc->sc_dv.dv_xname, ii->ii_dv->dv_xname, rv);
  730         }
  732         /* Re-adjust queue parameters and return. */
  733         if (sc->sc_nii != 0)
iop_adjqparam(sc, (sc->sc_maxib - sc->sc_nuii - IOP_MF_RESERVE)
  735                     / sc->sc_nii);
  737         return (0);
  738 }
  740 /*
  741  * Configure I2O devices into the system.
  742  */
  743 void
iop_configure_devices(struct iop_softc *sc, int mask, int maskval)
  745 {
  746         struct iop_attach_args ia;
  747         struct iop_initiator *ii;
  748         const struct i2o_lct_entry *le;
  749         struct device *dv;
  750         int i, j, nent;
u_int usertid;
nent = sc->sc_nlctent;
  754         for (i = 0, le = sc->sc_lct->entry; i < nent; i++, le++) {
sc->sc_tidmap[i].it_tid =
letoh16(le->localtid) & I2O_LCT_ENTRY_TID_MASK;
  758                 /* Ignore the device if it's in use. */
usertid = letoh32(le->usertid) & I2O_LCT_ENTRY_TID_MASK;
  760                 if (usertid != I2O_TID_NONE && usertid != I2O_TID_HOST)
  761                         continue;
ia.ia_class = letoh16(le->classid) & I2O_CLASS_MASK;
ia.ia_tid = sc->sc_tidmap[i].it_tid;
  766                 /* Ignore uninteresting devices. */
  767                 for (j = 0; j < sizeof(iop_class) / sizeof(iop_class[0]); j++)
  768                         if (iop_class[j].ic_class == ia.ia_class)
  769                                 break;
  770                 if (j < sizeof(iop_class) / sizeof(iop_class[0]) &&
  771                     (iop_class[j].ic_flags & mask) != maskval)
  772                         continue;
  774                 /*
  775                  * Try to configure the device only if it's not already
  776                  * configured.
  777                  */
LIST_FOREACH(ii, &sc->sc_iilist, ii_list) {
  779                         if (ia.ia_tid == ii->ii_tid) {
sc->sc_tidmap[i].it_flags |= IT_CONFIGURED;
strlcpy(sc->sc_tidmap[i].it_dvname,
ii->ii_dv->dv_xname,
  783                                     sizeof sc->sc_tidmap[i].it_dvname);
  784                                 break;
  785                         }
  786                 }
  787                 if (ii != NULL)
  788                         continue;
dv = config_found_sm(&sc->sc_dv, &ia, iop_print, iop_submatch);
  790                 if (dv != NULL) {
sc->sc_tidmap[i].it_flags |= IT_CONFIGURED;
strlcpy(sc->sc_tidmap[i].it_dvname, dv->dv_xname,
  793                             sizeof sc->sc_tidmap[i].it_dvname);
  794                 }
  795         }
  796 }
  798 /*
  799  * Adjust queue parameters for all child devices.
  800  */
  801 void
iop_adjqparam(struct iop_softc *sc, int mpi)
  803 {
  804         struct iop_initiator *ii;
LIST_FOREACH(ii, &sc->sc_iilist, ii_list)
  807                 if (ii->ii_adjqparam != NULL)
  808                         (*ii->ii_adjqparam)(ii->ii_dv, mpi);
  809 }
  811 void
iop_devinfo(int class, char *devinfo, size_t di_len)
  813 {
  814 #ifdef I2OVERBOSE
  815         int i;
  817         for (i = 0; i < sizeof(iop_class) / sizeof(iop_class[0]); i++)
  818                 if (class == iop_class[i].ic_class)
  819                         break;
  821         if (i == sizeof(iop_class) / sizeof(iop_class[0]))
snprintf(devinfo, di_len, "device (class 0x%x)", class);
  823         else
strlcpy(devinfo, iop_class[i].ic_caption, di_len);
  825 #else
snprintf(devinfo, di_len, "device (class 0x%x)", class);
  828 #endif
  829 }
  831 int
iop_print(void *aux, const char *pnp)
  833 {
  834         struct iop_attach_args *ia;
  835         char devinfo[256];
ia = aux;
  839         if (pnp != NULL) {
iop_devinfo(ia->ia_class, devinfo, sizeof devinfo);
printf("%s at %s", devinfo, pnp);
  842         }
printf(" tid %d", ia->ia_tid);
  844         return (UNCONF);
  845 }
  847 #ifdef notyet
  848 int
iop_vendor_print(void *aux, const char *pnp)
  850 {
  852         if (pnp != NULL)
printf("vendor specific extension at %s", pnp);
  854         return (UNCONF);
  855 }
  856 #endif
  858 int
iop_submatch(struct device *parent, void *vcf, void *aux)
  860 {
  861         struct cfdata *cf = vcf;
  862         struct iop_attach_args *ia;
ia = aux;
  866         if (cf->iopcf_tid != IOPCF_TID_DEFAULT && cf->iopcf_tid != ia->ia_tid)
  867                 return (0);
  869         return ((*cf->cf_attach->ca_match)(parent, cf, aux));
  870 }
  872 /*
  873  * Shut down all configured IOPs.
  874  */ 
  875 void
iop_shutdown(void *junk)
  877 {
  878         struct iop_softc *sc;
  879         int i;
printf("shutting down iop devices...");
  883         for (i = 0; i < iop_cd.cd_ndevs; i++) {
  884                 if (!(sc = (struct iop_softc *)device_lookup(&iop_cd, i)))
  885                         continue;
  886                 if ((sc->sc_flags & IOP_ONLINE) == 0)
  887                         continue;
iop_simple_cmd(sc, I2O_TID_IOP, I2O_EXEC_SYS_QUIESCE, IOP_ICTX,
  890                     0, 5000);
  892                 if (letoh16(sc->sc_status.orgid) != I2O_ORG_AMI) {
  893                         /*
  894                          * Some AMI firmware revisions will go to sleep and
  895                          * never come back after this.
  896                          */
iop_simple_cmd(sc, I2O_TID_IOP, I2O_EXEC_IOP_CLEAR,
IOP_ICTX, 0, 1000);
  899                 }
  900         }
  902         /* Wait.  Some boards could still be flushing, stupidly enough. */
delay(5000*1000);
printf(" done.\n");
  905 }
  907 /*
  908  * Retrieve IOP status.
  909  */
  910 int
iop_status_get(struct iop_softc *sc, int nosleep)
  912 {
  913         struct i2o_exec_status_get mf;
paddr_t pa = sc->sc_scr_seg->ds_addr;
  915         struct i2o_status *st = (struct i2o_status *)sc->sc_scr;
  916         int rv;
mf.msgflags = I2O_MSGFLAGS(i2o_exec_status_get);
mf.msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_STATUS_GET);
mf.reserved[0] = 0;
mf.reserved[1] = 0;
mf.reserved[2] = 0;
mf.reserved[3] = 0;
mf.addrlow = pa & ~(u_int32_t)0;
mf.addrhigh = sizeof pa > sizeof mf.addrlow ? pa >> 32 : 0;
mf.length = sizeof(*st);
bzero(st, sizeof(*st));
bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*st),
BUS_DMASYNC_PREREAD);
  932         if ((rv = iop_post(sc, (u_int32_t *)&mf)))
  933                 return (rv);
  935         /* XXX */
POLL(2500,
  937             (bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0,
  938                 sizeof(*st), BUS_DMASYNC_POSTREAD), st->syncbyte == 0xff));
  940         if (st->syncbyte != 0xff)
  941                 return (EIO);
bcopy(st, &sc->sc_status, sizeof(sc->sc_status));
  944         return (0);
  945 }
  947 /*
  948  * Initalize and populate the IOP's outbound FIFO.
  949  */
  950 int
iop_ofifo_init(struct iop_softc *sc)
  952 {
bus_addr_t addr;
bus_dma_segment_t seg;
  955         struct i2o_exec_outbound_init *mf;
u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
u_int32_t *sw = (u_int32_t *)sc->sc_scr;
  958         int i, rseg, rv;
mf = (struct i2o_exec_outbound_init *)mb;
mf->msgflags = I2O_MSGFLAGS(i2o_exec_outbound_init);
mf->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_OUTBOUND_INIT);
mf->msgictx = IOP_ICTX;
mf->msgtctx = 0;
mf->pagesize = PAGE_SIZE;
mf->flags = IOP_INIT_CODE | ((IOP_MAX_MSG_SIZE >> 2) << 16);
mb[sizeof(*mf) / sizeof(u_int32_t) + 0] = sizeof(*sw) |
I2O_SGL_SIMPLE | I2O_SGL_END_BUFFER | I2O_SGL_END;
mb[sizeof(*mf) / sizeof(u_int32_t) + 1] = sc->sc_scr_seg->ds_addr;
mb[0] += 2 << 16;
  972         *sw = 0;
bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
BUS_DMASYNC_PREREAD);
  976         /*
  977          * The I2O spec says that there are two SGLs: one for the status
  978          * word, and one for a list of discarded MFAs.  It continues to say
  979          * that if you don't want to get the list of MFAs, an IGNORE SGL is
  980          * necessary; this isn't the case (and is in fact a bad thing).
  981          */
  982         if ((rv = iop_post(sc, mb)))
  983                 return (rv);
  985         /* XXX */
POLL(5000,
  987             (bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
BUS_DMASYNC_POSTREAD),
  989             *sw == htole32(I2O_EXEC_OUTBOUND_INIT_COMPLETE)));
  990         if (*sw != htole32(I2O_EXEC_OUTBOUND_INIT_COMPLETE)) {
printf("%s: outbound FIFO init failed (%d)\n",
sc->sc_dv.dv_xname, letoh32(*sw));
  993                 return (EIO);
  994         }
  996         /* Allocate DMA safe memory for the reply frames. */
  997         if (sc->sc_rep_phys == 0) {
sc->sc_rep_size = sc->sc_maxob * IOP_MAX_MSG_SIZE;
rv = bus_dmamem_alloc(sc->sc_dmat, sc->sc_rep_size, PAGE_SIZE,
 1001                     0, &seg, 1, &rseg, BUS_DMA_NOWAIT);
 1002                 if (rv != 0) {
printf("%s: dma alloc = %d\n", sc->sc_dv.dv_xname,
rv);
 1005                         return (rv);
 1006                 }
rv = bus_dmamem_map(sc->sc_dmat, &seg, rseg, sc->sc_rep_size,
 1009                     &sc->sc_rep, BUS_DMA_NOWAIT | BUS_DMA_COHERENT);
 1010                 if (rv != 0) {
printf("%s: dma map = %d\n", sc->sc_dv.dv_xname, rv);
 1012                         return (rv);
 1013                 }
rv = bus_dmamap_create(sc->sc_dmat, sc->sc_rep_size, 1,
sc->sc_rep_size, 0, BUS_DMA_NOWAIT, &sc->sc_rep_dmamap);
 1017                 if (rv != 0) {
printf("%s: dma create = %d\n", sc->sc_dv.dv_xname,
rv);
 1020                         return (rv);
 1021                 }
rv = bus_dmamap_load(sc->sc_dmat, sc->sc_rep_dmamap,
sc->sc_rep, sc->sc_rep_size, NULL, BUS_DMA_NOWAIT);
 1025                 if (rv != 0) {
printf("%s: dma load = %d\n", sc->sc_dv.dv_xname, rv);
 1027                         return (rv);
 1028                 }
sc->sc_rep_phys = sc->sc_rep_dmamap->dm_segs[0].ds_addr;
 1031         }
 1033         /* Populate the outbound FIFO. */
 1034         for (i = sc->sc_maxob, addr = sc->sc_rep_phys; i != 0; i--) {
iop_outl(sc, IOP_REG_OFIFO, (u_int32_t)addr);
addr += IOP_MAX_MSG_SIZE;
 1037         }
 1039         return (0);
 1040 }
 1042 /*
 1043  * Read the specified number of bytes from the IOP's hardware resource table.
 1044  */
 1045 int
iop_hrt_get0(struct iop_softc *sc, struct i2o_hrt *hrt, size_t size)
 1047 {
 1048         struct iop_msg *im;
 1049         struct i2o_exec_hrt_get *mf;
u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
 1051         int rv;
im = iop_msg_alloc(sc, NULL, IM_WAIT);
mf = (struct i2o_exec_hrt_get *)mb;
mf->msgflags = I2O_MSGFLAGS(i2o_exec_hrt_get);
mf->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_HRT_GET);
mf->msgictx = IOP_ICTX;
mf->msgtctx = im->im_tctx;
iop_msg_map(sc, im, mb, hrt, size, 0);
rv = iop_msg_post(sc, im, mb, 30000);
iop_msg_unmap(sc, im);
iop_msg_free(sc, im);
 1064         return (rv);
 1065 }
 1067 /*
 1068  * Read the IOP's hardware resource table.
 1069  */
 1070 int
iop_hrt_get(struct iop_softc *sc)
 1072 {
 1073         struct i2o_hrt hrthdr, *hrt;
size_t size;
 1075         int rv;
rv = iop_hrt_get0(sc, &hrthdr, sizeof(hrthdr));
 1078         if (rv != 0)
 1079                 return (rv);
DPRINTF(("%s: %d hrt entries\n", sc->sc_dv.dv_xname,
letoh16(hrthdr.numentries)));
size = sizeof(struct i2o_hrt) + 
 1085             (letoh16(hrthdr.numentries) - 1) * sizeof(struct i2o_hrt_entry);
hrt = (struct i2o_hrt *)malloc(size, M_DEVBUF, M_NOWAIT);
 1087         if (!hrt)
 1088                 return (ENOMEM);
 1090         if ((rv = iop_hrt_get0(sc, hrt, size)) != 0) {
free(hrt, M_DEVBUF);
 1092                 return (rv);
 1093         }
 1095         if (sc->sc_hrt != NULL)
free(sc->sc_hrt, M_DEVBUF);
sc->sc_hrt = hrt;
 1098         return (0);
 1099 }
 1101 /*
 1102  * Request the specified number of bytes from the IOP's logical
 1103  * configuration table.  If a change indicator is specified, this
 1104  * is a verbatim notification request, so the caller is prepared
 1105  * to wait indefinitely.
 1106  */
 1107 int
iop_lct_get0(struct iop_softc *sc, struct i2o_lct *lct, size_t size,
u_int32_t chgind)
 1110 {
 1111         struct iop_msg *im;
 1112         struct i2o_exec_lct_notify *mf;
 1113         int rv;
u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
im = iop_msg_alloc(sc, NULL, IM_WAIT);
memset(lct, 0, size);
mf = (struct i2o_exec_lct_notify *)mb;
mf->msgflags = I2O_MSGFLAGS(i2o_exec_lct_notify);
mf->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_LCT_NOTIFY);
mf->msgictx = IOP_ICTX;
mf->msgtctx = im->im_tctx;
mf->classid = I2O_CLASS_ANY;
mf->changeindicator = chgind;
 1127 #ifdef I2ODEBUG
printf("iop_lct_get0: reading LCT");
 1129         if (chgind != 0)
printf(" (async)");
printf("\n");
 1132 #endif
iop_msg_map(sc, im, mb, lct, size, 0);
rv = iop_msg_post(sc, im, mb, (chgind == 0 ? 120*1000 : 0));
iop_msg_unmap(sc, im);
iop_msg_free(sc, im);
 1138         return (rv);
 1139 }
 1141 /*
 1142  * Read the IOP's logical configuration table.
 1143  */
 1144 int
iop_lct_get(struct iop_softc *sc)
 1146 {
size_t esize, size;
 1148         int rv;
 1149         struct i2o_lct *lct;
esize = letoh32(sc->sc_status.expectedlctsize);
lct = (struct i2o_lct *)malloc(esize, M_DEVBUF, M_WAITOK);
 1153         if (lct == NULL)
 1154                 return (ENOMEM);
 1156         if ((rv = iop_lct_get0(sc, lct, esize, 0)) != 0) {
free(lct, M_DEVBUF);
 1158                 return (rv);
 1159         }
size = letoh16(lct->tablesize) << 2;
 1162         if (esize != size) {
free(lct, M_DEVBUF);
lct = (struct i2o_lct *)malloc(size, M_DEVBUF, M_WAITOK);
 1165                 if (lct == NULL)
 1166                         return (ENOMEM);
 1168                 if ((rv = iop_lct_get0(sc, lct, size, 0)) != 0) {
free(lct, M_DEVBUF);
 1170                         return (rv);
 1171                 }
 1172         }
 1174         /* Swap in the new LCT. */
 1175         if (sc->sc_lct != NULL)
free(sc->sc_lct, M_DEVBUF);
sc->sc_lct = lct;
sc->sc_nlctent = ((letoh16(sc->sc_lct->tablesize) << 2) -
 1179             sizeof(struct i2o_lct) + sizeof(struct i2o_lct_entry)) /
 1180             sizeof(struct i2o_lct_entry);
 1181         return (0);
 1182 }
 1184 /*
 1185  * Request the specified parameter group from the target.  If an initiator
 1186  * is specified (a) don't wait for the operation to complete, but instead
 1187  * let the initiator's interrupt handler deal with the reply and (b) place a
 1188  * pointer to the parameter group op in the wrapper's `im_dvcontext' field.
 1189  */
 1190 int
iop_param_op(struct iop_softc *sc, int tid, struct iop_initiator *ii,
 1192     int write, int group, void *buf, size_t size)
 1193 {
 1194         struct iop_msg *im;
 1195         struct i2o_util_params_op *mf;
 1196         struct i2o_reply *rf;
 1197         int rv, func, op;
 1198         struct iop_pgop *pgop;
u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
im = iop_msg_alloc(sc, ii, (ii == NULL ? IM_WAIT : 0) | IM_NOSTATUS);
 1202         if ((pgop = malloc(sizeof(*pgop), M_DEVBUF, M_WAITOK)) == NULL) {
iop_msg_free(sc, im);
 1204                 return (ENOMEM);
 1205         }
 1206         if ((rf = malloc(sizeof(*rf), M_DEVBUF, M_WAITOK)) == NULL) {
iop_msg_free(sc, im);
free(pgop, M_DEVBUF);
 1209                 return (ENOMEM);
 1210         }
im->im_dvcontext = pgop;
im->im_rb = rf;
 1214         if (write) {
func = I2O_UTIL_PARAMS_SET;
op = I2O_PARAMS_OP_FIELD_SET;
 1217         } else {
func = I2O_UTIL_PARAMS_GET;
op = I2O_PARAMS_OP_FIELD_GET;
 1220         }
mf = (struct i2o_util_params_op *)mb;
mf->msgflags = I2O_MSGFLAGS(i2o_util_params_op);
mf->msgfunc = I2O_MSGFUNC(tid, func);
mf->msgictx = IOP_ICTX;
mf->msgtctx = im->im_tctx;
mf->flags = 0;
pgop->olh.count = htole16(1);
pgop->olh.reserved = htole16(0);
pgop->oat.operation = htole16(op);
pgop->oat.fieldcount = htole16(0xffff);
pgop->oat.group = htole16(group);
memset(buf, 0, size);
iop_msg_map(sc, im, mb, pgop, sizeof(*pgop), 1);
iop_msg_map(sc, im, mb, buf, size, write);
rv = iop_msg_post(sc, im, mb, (ii == NULL ? 30000 : 0));
 1240         /* Detect errors; let partial transfers to count as success. */
 1241         if (ii == NULL && rv == 0) {
 1242                 if (rf->reqstatus == I2O_STATUS_ERROR_PARTIAL_XFER &&
rf->detail == htole16(I2O_DSC_UNKNOWN_ERROR))
rv = 0;
 1245                 else
rv = (rf->reqstatus != 0 ? EIO : 0);
 1247         }
 1249         if (ii == NULL || rv != 0) {
iop_msg_unmap(sc, im);
iop_msg_free(sc, im);
free(pgop, M_DEVBUF);
free(rf, M_DEVBUF);
 1254         }
 1256         return (rv);
 1257 }
 1259 /*
 1260  * Execute a simple command (no parameters).
 1261  */
 1262 int
iop_simple_cmd(struct iop_softc *sc, int tid, int function, int ictx,
 1264                int async, int timo)
 1265 {
 1266         struct iop_msg *im;
 1267         struct i2o_msg mf;
 1268         int rv, fl;
fl = (async != 0 ? IM_WAIT : IM_POLL);
im = iop_msg_alloc(sc, NULL, fl);
mf.msgflags = I2O_MSGFLAGS(i2o_msg);
mf.msgfunc = I2O_MSGFUNC(tid, function);
mf.msgictx = ictx;
mf.msgtctx = im->im_tctx;
rv = iop_msg_post(sc, im, &mf, timo);
iop_msg_free(sc, im);
 1280         return (rv);
 1281 }
 1283 /*
 1284  * Post the system table to the IOP.
 1285  */
 1286 int
iop_systab_set(struct iop_softc *sc)
 1288 {
 1289         struct i2o_exec_sys_tab_set *mf;
 1290         struct iop_msg *im;
bus_space_handle_t bsh;
bus_addr_t boo;
u_int32_t mema[2], ioa[2];
 1294         int rv;
u_int32_t mb[IOP_MAX_MSG_SIZE / sizeof(u_int32_t)];
im = iop_msg_alloc(sc, NULL, IM_WAIT);
mf = (struct i2o_exec_sys_tab_set *)mb;
mf->msgflags = I2O_MSGFLAGS(i2o_exec_sys_tab_set);
mf->msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_SYS_TAB_SET);
mf->msgictx = IOP_ICTX;
mf->msgtctx = im->im_tctx;
mf->iopid = (sc->sc_dv.dv_unit + 2) << 12;
mf->segnumber = 0;
mema[1] = sc->sc_status.desiredprivmemsize;
ioa[1] = sc->sc_status.desiredpriviosize;
 1310         if (mema[1] != 0) {
 1311                 /*
 1312                  * XXX This will waste virtual memory.  We need a flag to tell
 1313                  * bus_space_alloc to just reserve, not actually map the area.
 1314                  */
rv = bus_space_alloc(sc->sc_bus_memt, 0, 0xffffffff,
letoh32(mema[1]), PAGE_SIZE, 0, 0, &boo, &bsh);
mema[0] = htole32(boo);
 1318                 if (rv != 0) {
printf("%s: can't alloc priv mem space, err = %d\n",
sc->sc_dv.dv_xname, rv);
mema[0] = 0;
mema[1] = 0;
 1323                 }
 1324         }
 1326         if (ioa[1] != 0) {
 1327                 /*
 1328                  * XXX This will potentially waste virtual memory.  We
 1329                  * need a flag to tell bus_space_alloc to just
 1330                  * reserve, not actually map the area.
 1331                  */
rv = bus_space_alloc(sc->sc_bus_iot, 0, 0xffff,
letoh32(ioa[1]), 0, 0, 0, &boo, &bsh);
ioa[0] = htole32(boo);
 1335                 if (rv != 0) {
printf("%s: can't alloc priv i/o space, err = %d\n",
sc->sc_dv.dv_xname, rv);
ioa[0] = 0;
ioa[1] = 0;
 1340                 }
 1341         }
iop_msg_map(sc, im, mb, iop_systab, iop_systab_size, 1);
iop_msg_map(sc, im, mb, mema, sizeof(mema), 1);
iop_msg_map(sc, im, mb, ioa, sizeof(ioa), 1);
rv = iop_msg_post(sc, im, mb, 5000);
iop_msg_unmap(sc, im);
iop_msg_free(sc, im);
 1349         return (rv);
 1350 }
 1352 /*
 1353  * Reset the IOP.  Must be called with interrupts disabled.
 1354  */
 1355 int
iop_reset(struct iop_softc *sc)
 1357 {
 1358         struct i2o_exec_iop_reset mf;
paddr_t pa = sc->sc_scr_seg->ds_addr;
u_int32_t *sw = (u_int32_t *)sc->sc_scr;
u_int32_t mfa;
 1362         int rv = 0;
mf.msgflags = I2O_MSGFLAGS(i2o_exec_iop_reset);
mf.msgfunc = I2O_MSGFUNC(I2O_TID_IOP, I2O_EXEC_IOP_RESET);
mf.reserved[0] = 0;
mf.reserved[1] = 0;
mf.reserved[2] = 0;
mf.reserved[3] = 0;
mf.statuslow = pa & ~(u_int32_t)0;
mf.statushigh = sizeof pa > sizeof mf.statuslow ? pa >> 32 : 0;
 1373         *sw = htole32(0);
bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
BUS_DMASYNC_PREREAD);
 1377         if ((rv = iop_post(sc, (u_int32_t *)&mf)))
 1378                 return (rv);
 1380         /* XXX */
POLL(2500,
 1382             (bus_dmamap_sync(sc->sc_dmat, sc->sc_scr_dmamap, 0, sizeof(*sw),
BUS_DMASYNC_POSTREAD), *sw != htole32(0)));
 1384         if (*sw != htole32(I2O_RESET_IN_PROGRESS)) {
printf("%s: reset rejected, status 0x%x\n",
sc->sc_dv.dv_xname, letoh32(*sw));
 1387                 return (EIO);
 1388         }
 1390         /* 
 1391          * IOP is now in the INIT state.  Wait no more than 10 seconds for
 1392          * the inbound queue to become responsive.
 1393          */
POLL(10000, (mfa = iop_inl(sc, IOP_REG_IFIFO)) != IOP_MFA_EMPTY);
 1395         if (mfa == IOP_MFA_EMPTY) {
printf("%s: reset failed\n", sc->sc_dv.dv_xname);
 1397                 return (EIO);
 1398         }
iop_release_mfa(sc, mfa);
 1402         return (0);
 1403 }
 1405 /*
 1406  * Register a new initiator.  Must be called with the configuration lock
 1407  * held.
 1408  */
 1409 void
iop_initiator_register(struct iop_softc *sc, struct iop_initiator *ii)
 1411 {
 1412         static int ictxgen;
 1413         int s;
 1415         /* 0 is reserved (by us) for system messages. */
ii->ii_ictx = ++ictxgen;
 1418         /*
 1419          * `Utility initiators' don't make it onto the per-IOP initiator list
 1420          * (which is used only for configuration), but do get one slot on
 1421          * the inbound queue.
 1422          */
 1423         if ((ii->ii_flags & II_UTILITY) == 0) {
LIST_INSERT_HEAD(&sc->sc_iilist, ii, ii_list);
sc->sc_nii++;
 1426         } else
sc->sc_nuii++;
s = splbio();
LIST_INSERT_HEAD(IOP_ICTXHASH(ii->ii_ictx), ii, ii_hash);
splx(s);
 1432 }
 1434 /*
 1435  * Unregister an initiator.  Must be called with the configuration lock
 1436  * held.
 1437  */
 1438 void
iop_initiator_unregister(struct iop_softc *sc, struct iop_initiator *ii)
 1440 {
 1441         int s;
 1443         if ((ii->ii_flags & II_UTILITY) == 0) {
LIST_REMOVE(ii, ii_list);
sc->sc_nii--;
 1446         } else
sc->sc_nuii--;
s = splbio();
LIST_REMOVE(ii, ii_hash);
splx(s);
 1452 }
 1454 /*
 1455  * Handle a reply frame from the IOP.
 1456  */
 1457 int
iop_handle_reply(struct iop_softc *sc, u_int32_t rmfa)
 1459 {
 1460         struct iop_msg *im;
 1461         struct i2o_reply *rb;
 1462         struct i2o_fault_notify *fn;
 1463         struct iop_initiator *ii;
u_int off, ictx, tctx, status, size;
off = (int)(rmfa - sc->sc_rep_phys);
rb = (struct i2o_reply *)(sc->sc_rep + off);
 1469         /* Perform reply queue DMA synchronisation.  XXX This is rubbish. */
bus_dmamap_sync(sc->sc_dmat, sc->sc_rep_dmamap, off,
sc->sc_rep_dmamap->dm_mapsize, BUS_DMASYNC_POSTREAD);
 1472         if (--sc->sc_curib != 0)
bus_dmamap_sync(sc->sc_dmat, sc->sc_rep_dmamap, 0,
sc->sc_rep_size, BUS_DMASYNC_PREREAD);
 1476 #ifdef I2ODEBUG
 1477         if ((letoh32(rb->msgflags) & I2O_MSGFLAGS_64BIT) != 0)
panic("iop_handle_reply: 64-bit reply");
 1479 #endif
 1480         /* 
 1481          * Find the initiator.
 1482          */
ictx = letoh32(rb->msgictx);
 1484         if (ictx == IOP_ICTX)
ii = NULL;
 1486         else {
ii = LIST_FIRST(IOP_ICTXHASH(ictx));
 1488                 for (; ii != NULL; ii = LIST_NEXT(ii, ii_hash))
 1489                         if (ii->ii_ictx == ictx)
 1490                                 break;
 1491                 if (ii == NULL) {
 1492 #ifdef I2ODEBUG
iop_reply_print(sc, rb);
 1494 #endif
printf("%s: WARNING: bad ictx returned (%x)\n",
sc->sc_dv.dv_xname, ictx);
 1497                         return (-1);
 1498                 }
 1499         }
 1501         /*
 1502          * If we received a transport failure notice, we've got to dig the
 1503          * transaction context (if any) out of the original message frame,
 1504          * and then release the original MFA back to the inbound FIFO.
 1505          */
 1506         if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0) {
status = I2O_STATUS_SUCCESS;
fn = (struct i2o_fault_notify *)rb;
tctx = iop_inl(sc, fn->lowmfa + 12);    /* XXX */
iop_release_mfa(sc, fn->lowmfa);
iop_tfn_print(sc, fn);
 1513         } else {
status = rb->reqstatus;
tctx = letoh32(rb->msgtctx);
 1516         }
 1518         if (ii == NULL || (ii->ii_flags & II_DISCARD) == 0) {
 1519                 /*
 1520                  * This initiator tracks state using message wrappers.
 1521                  *
 1522                  * Find the originating message wrapper, and if requested
 1523                  * notify the initiator.
 1524                  */
im = sc->sc_ims + (tctx & IOP_TCTX_MASK);
 1526                 if ((tctx & IOP_TCTX_MASK) > sc->sc_maxib ||
 1527                     (im->im_flags & IM_ALLOCED) == 0 ||
tctx != im->im_tctx) {
printf("%s: WARNING: bad tctx returned (0x%08x, %p)\n",
sc->sc_dv.dv_xname, tctx, im);
 1531                         if (im != NULL)
printf("%s: flags=0x%08x tctx=0x%08x\n",
sc->sc_dv.dv_xname, im->im_flags,
im->im_tctx);
 1535 #ifdef I2ODEBUG
 1536                         if ((rb->msgflags & I2O_MSGFLAGS_FAIL) == 0)
iop_reply_print(sc, rb);
 1538 #endif
 1539                         return (-1);
 1540                 }
 1542                 if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0)
im->im_flags |= IM_FAIL;
 1545 #ifdef I2ODEBUG
 1546                 if ((im->im_flags & IM_REPLIED) != 0)
panic("%s: dup reply", sc->sc_dv.dv_xname);
 1548 #endif
im->im_flags |= IM_REPLIED;
 1551 #ifdef I2ODEBUG
 1552                 if (status != I2O_STATUS_SUCCESS)
iop_reply_print(sc, rb);
 1554 #endif
im->im_reqstatus = status;
 1557                 /* Copy the reply frame, if requested. */
 1558                 if (im->im_rb != NULL) {
size = (letoh32(rb->msgflags) >> 14) & ~3;
 1560 #ifdef I2ODEBUG
 1561                         if (size > IOP_MAX_MSG_SIZE)
panic("iop_handle_reply: reply too large");
 1563 #endif
memcpy(im->im_rb, rb, size);
 1565                 }
 1567                 /* Notify the initiator. */
 1568                 if ((im->im_flags & IM_WAIT) != 0)
wakeup(im);
 1570                 else if ((im->im_flags & (IM_POLL | IM_POLL_INTR)) != IM_POLL)
 1571                         (*ii->ii_intr)(ii->ii_dv, im, rb);
 1572         } else {
 1573                 /*
 1574                  * This initiator discards message wrappers.
 1575                  *
 1576                  * Simply pass the reply frame to the initiator.
 1577                  */
 1578                 (*ii->ii_intr)(ii->ii_dv, NULL, rb);
 1579         }
 1581         return (status);
 1582 }
 1584 /*
 1585  * Handle an interrupt from the IOP.
 1586  */
 1587 int
iop_intr(void *arg)
 1589 {
 1590         struct iop_softc *sc;
u_int32_t rmfa;
sc = arg;
 1595         if ((iop_inl(sc, IOP_REG_INTR_STATUS) & IOP_INTR_OFIFO) == 0)
 1596                 return (0);
 1598         for (;;) {
 1599                 /* Double read to account for IOP bug. */
 1600                 if ((rmfa = iop_inl(sc, IOP_REG_OFIFO)) == IOP_MFA_EMPTY) {
rmfa = iop_inl(sc, IOP_REG_OFIFO);
 1602                         if (rmfa == IOP_MFA_EMPTY)
 1603                                 break;
 1604                 }
iop_handle_reply(sc, rmfa);
iop_outl(sc, IOP_REG_OFIFO, rmfa);
 1607         }
 1609         return (1);
 1610 }
 1612 /*
 1613  * Handle an event signalled by the executive.
 1614  */
 1615 void
iop_intr_event(struct device *dv, struct iop_msg *im, void *reply)
 1617 {
 1618         struct i2o_util_event_register_reply *rb;
 1619         struct iop_softc *sc;
u_int event;
sc = (struct iop_softc *)dv;
rb = reply;
 1625         if ((rb->msgflags & I2O_MSGFLAGS_FAIL) != 0)
 1626                 return;
event = letoh32(rb->event);
printf("%s: event 0x%08x received\n", dv->dv_xname, event);
 1630 }
 1632 /* 
 1633  * Allocate a message wrapper.
 1634  */
 1635 struct iop_msg *
iop_msg_alloc(struct iop_softc *sc, struct iop_initiator *ii, int flags)
 1637 {
 1638         struct iop_msg *im;
 1639         static u_int tctxgen;
 1640         int s, i;
 1642 #ifdef I2ODEBUG
 1643         if ((flags & IM_SYSMASK) != 0)
panic("iop_msg_alloc: system flags specified");
 1645 #endif
s = splbio();   /* XXX */
im = SLIST_FIRST(&sc->sc_im_freelist);
 1649 #if defined(DIAGNOSTIC) || defined(I2ODEBUG)
 1650         if (im == NULL)
panic("iop_msg_alloc: no free wrappers");
 1652 #endif
SLIST_REMOVE_HEAD(&sc->sc_im_freelist, im_chain);
splx(s);
 1656         if (ii != NULL && (ii->ii_flags & II_DISCARD) != 0)
flags |= IM_DISCARD;
im->im_tctx = (im->im_tctx & IOP_TCTX_MASK) | tctxgen;
tctxgen += (1 << IOP_TCTX_SHIFT);
im->im_flags = flags | IM_ALLOCED;
im->im_rb = NULL;
i = 0;
 1664         do {
im->im_xfer[i++].ix_size = 0;
 1666         } while (i < IOP_MAX_MSG_XFERS);
 1668         return (im);
 1669 }
 1671 /* 
 1672  * Free a message wrapper.
 1673  */
 1674 void
iop_msg_free(struct iop_softc *sc, struct iop_msg *im)
 1676 {
 1677         int s;
 1679 #ifdef I2ODEBUG
 1680         if ((im->im_flags & IM_ALLOCED) == 0)
panic("iop_msg_free: wrapper not allocated");
 1682 #endif
im->im_flags = 0;
s = splbio();
SLIST_INSERT_HEAD(&sc->sc_im_freelist, im, im_chain);
splx(s);
 1688 }
 1690 /*
 1691  * Map a data transfer.  Write a scatter-gather list into the message frame. 
 1692  */
 1693 int
iop_msg_map(struct iop_softc *sc, struct iop_msg *im, u_int32_t *mb,
 1695     void *xferaddr, size_t xfersize, int out)
 1696 {
bus_dmamap_t dm;
bus_dma_segment_t *ds;
 1699         struct iop_xfer *ix;
u_int rv, i, nsegs, flg, off, xn;
u_int32_t *p;
 1703         for (xn = 0, ix = im->im_xfer; xn < IOP_MAX_MSG_XFERS; xn++, ix++)
 1704                 if (ix->ix_size == 0)
 1705                         break;
 1707 #ifdef I2ODEBUG
 1708         if (xfersize == 0)
panic("iop_msg_map: null transfer");
 1710         if (xfersize > IOP_MAX_XFER)
panic("iop_msg_map: transfer too large");
 1712         if (xn == IOP_MAX_MSG_XFERS)
panic("iop_msg_map: too many xfers");
 1714 #endif
 1716         /*
 1717          * Only the first DMA map is static.
 1718          */
 1719         if (xn != 0) {
rv = bus_dmamap_create(sc->sc_dmat, IOP_MAX_XFER,
IOP_MAX_SEGS, IOP_MAX_XFER, 0,
BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &ix->ix_map);
 1723                 if (rv != 0)
 1724                         return (rv);
 1725         }
dm = ix->ix_map;
rv = bus_dmamap_load(sc->sc_dmat, dm, xferaddr, xfersize, NULL, 0);
 1729         if (rv != 0)
 1730                 goto bad;
 1732         /*
 1733          * How many SIMPLE SG elements can we fit in this message?
 1734          */
off = mb[0] >> 16;
p = mb + off;
nsegs = ((IOP_MAX_MSG_SIZE / sizeof *mb) - off) >> 1;
 1739         if (dm->dm_nsegs > nsegs) {
bus_dmamap_unload(sc->sc_dmat, ix->ix_map);
rv = EFBIG;
DPRINTF(("iop_msg_map: too many segs\n"));
 1743                 goto bad;
 1744         }
nsegs = dm->dm_nsegs;
xfersize = 0;
 1749         /*
 1750          * Write out the SG list.
 1751          */
 1752         if (out)
flg = I2O_SGL_SIMPLE | I2O_SGL_DATA_OUT;
 1754         else
flg = I2O_SGL_SIMPLE;
 1757         for (i = nsegs, ds = dm->dm_segs; i > 1; i--, p += 2, ds++) {
p[0] = (u_int32_t)ds->ds_len | flg;
p[1] = (u_int32_t)ds->ds_addr;
xfersize += ds->ds_len;
 1761         }
p[0] = (u_int32_t)ds->ds_len | flg | I2O_SGL_END_BUFFER;
p[1] = (u_int32_t)ds->ds_addr;
xfersize += ds->ds_len;
 1767         /* Fix up the transfer record, and sync the map. */
ix->ix_flags = (out ? IX_OUT : IX_IN);
ix->ix_size = xfersize;
bus_dmamap_sync(sc->sc_dmat, ix->ix_map, 0, xfersize,
out ? BUS_DMASYNC_POSTWRITE : BUS_DMASYNC_POSTREAD);
 1773         /*
 1774          * If this is the first xfer we've mapped for this message, adjust
 1775          * the SGL offset field in the message header.
 1776          */
 1777         if ((im->im_flags & IM_SGLOFFADJ) == 0) {
mb[0] += (mb[0] >> 12) & 0xf0;
im->im_flags |= IM_SGLOFFADJ;
 1780         }
mb[0] += (nsegs << 17);
 1782         return (0);
bad:
 1785         if (xn != 0)
bus_dmamap_destroy(sc->sc_dmat, ix->ix_map);
 1787         return (rv);
 1788 }
 1790 /*
 1791  * Map a block I/O data transfer (different in that there's only one per
 1792  * message maximum, and PAGE addressing may be used).  Write a scatter
 1793  * gather list into the message frame.
 1794  */
 1795 int
iop_msg_map_bio(struct iop_softc *sc, struct iop_msg *im, u_int32_t *mb,
 1797                 void *xferaddr, int xfersize, int out)
 1798 {
bus_dma_segment_t *ds;
bus_dmamap_t dm;
 1801         struct iop_xfer *ix;
u_int rv, i, nsegs, off, slen, tlen, flg;
paddr_t saddr, eaddr;
u_int32_t *p;
 1806 #ifdef I2ODEBUG
 1807         if (xfersize == 0)
panic("iop_msg_map_bio: null transfer");
 1809         if (xfersize > IOP_MAX_XFER)
panic("iop_msg_map_bio: transfer too large");
 1811         if ((im->im_flags & IM_SGLOFFADJ) != 0)
panic("iop_msg_map_bio: SGLOFFADJ");
 1813 #endif
ix = im->im_xfer;
dm = ix->ix_map;
rv = bus_dmamap_load(sc->sc_dmat, dm, xferaddr, xfersize, NULL, 0);
 1818         if (rv != 0)
 1819                 return (rv);
off = mb[0] >> 16;
nsegs = ((IOP_MAX_MSG_SIZE / 4) - off) >> 1;
 1824         /*
 1825          * If the transfer is highly fragmented and won't fit using SIMPLE
 1826          * elements, use PAGE_LIST elements instead.  SIMPLE elements are
 1827          * potentially more efficient, both for us and the IOP.
 1828          */
 1829         if (dm->dm_nsegs > nsegs) {
nsegs = 1;
p = mb + off + 1;
 1833                 /* XXX This should be done with a bus_space flag. */
 1834                 for (i = dm->dm_nsegs, ds = dm->dm_segs; i > 0; i--, ds++) {
slen = ds->ds_len;
saddr = ds->ds_addr;
 1838                         while (slen > 0) {
eaddr = (saddr + PAGE_SIZE) & ~(PAGE_SIZE - 1);
tlen = min(eaddr - saddr, slen);
slen -= tlen;
 1842                                 *p++ = letoh32(saddr);
saddr = eaddr;
nsegs++;
 1845                         }
 1846                 }
mb[off] = xfersize | I2O_SGL_PAGE_LIST | I2O_SGL_END_BUFFER |
I2O_SGL_END;
 1850                 if (out)
mb[off] |= I2O_SGL_DATA_OUT;
 1852         } else {
p = mb + off;
nsegs = dm->dm_nsegs;
 1856                 if (out)
flg = I2O_SGL_SIMPLE | I2O_SGL_DATA_OUT;
 1858                 else
flg = I2O_SGL_SIMPLE;
 1861                 for (i = nsegs, ds = dm->dm_segs; i > 1; i--, p += 2, ds++) {
p[0] = (u_int32_t)ds->ds_len | flg;
p[1] = (u_int32_t)ds->ds_addr;
 1864                 }
p[0] = (u_int32_t)ds->ds_len | flg | I2O_SGL_END_BUFFER |
I2O_SGL_END;
p[1] = (u_int32_t)ds->ds_addr;
nsegs <<= 1;
 1870         }
 1872         /* Fix up the transfer record, and sync the map. */
ix->ix_flags = (out ? IX_OUT : IX_IN);
ix->ix_size = xfersize;
bus_dmamap_sync(sc->sc_dmat, ix->ix_map, 0,
ix->ix_map->dm_mapsize,
out ? BUS_DMASYNC_POSTWRITE : BUS_DMASYNC_POSTREAD);
 1879         /*
 1880          * Adjust the SGL offset and total message size fields.  We don't
 1881          * set IM_SGLOFFADJ, since it's used only for SIMPLE elements.
 1882          */
mb[0] += ((off << 4) + (nsegs << 16));
 1884         return (0);
 1885 }
 1887 /*
 1888  * Unmap all data transfers associated with a message wrapper.
 1889  */
 1890 void
iop_msg_unmap(struct iop_softc *sc, struct iop_msg *im)
 1892 {
 1893         struct iop_xfer *ix;
 1894         int i;
 1896 #ifdef I2ODEBUG 
 1897         if (im->im_xfer[0].ix_size == 0)
panic("iop_msg_unmap: no transfers mapped");
 1899 #endif
 1901         for (ix = im->im_xfer, i = 0;;) {
bus_dmamap_sync(sc->sc_dmat, ix->ix_map, 0, ix->ix_size,
ix->ix_flags & IX_OUT ? BUS_DMASYNC_POSTWRITE :
BUS_DMASYNC_POSTREAD);
bus_dmamap_unload(sc->sc_dmat, ix->ix_map);
 1907                 /* Only the first DMA map is static. */
 1908                 if (i != 0)
bus_dmamap_destroy(sc->sc_dmat, ix->ix_map);
 1910                 if ((++ix)->ix_size == 0) 
 1911                         break;
 1912                 if (++i >= IOP_MAX_MSG_XFERS)
 1913                         break;
 1914         }
 1915 }
 1917 /*
 1918  * Post a message frame to the IOP's inbound queue.
 1919  */
 1920 int
iop_post(struct iop_softc *sc, u_int32_t *mb)
 1922 {
u_int32_t mfa;
 1924         int s;
size_t size = mb[0] >> 14 & ~3;
 1927         /* ZZZ */
 1928         if (size > IOP_MAX_MSG_SIZE)
panic("iop_post: frame too large");
 1931 #ifdef I2ODEBUG
 1932         {
 1933                 int i;
printf("\niop_post\n");
 1936                 for (i = 0; i < size / sizeof *mb; i++)
printf("%4d %08x\n", i, mb[i]);
 1938         }
 1939 #endif
s = splbio();   /* XXX */
 1943         /* Allocate a slot with the IOP. */
 1944         if ((mfa = iop_inl(sc, IOP_REG_IFIFO)) == IOP_MFA_EMPTY)
 1945                 if ((mfa = iop_inl(sc, IOP_REG_IFIFO)) == IOP_MFA_EMPTY) {
splx(s);
printf("%s: mfa not forthcoming\n",
sc->sc_dv.dv_xname);
 1949                         return (EAGAIN);
 1950                 }
 1952 #ifdef I2ODEBUG
printf("mfa = %u\n", mfa);
 1954 #endif
 1956         /* Copy out the message frame. */
bus_space_write_region_4(sc->sc_iot, sc->sc_ioh, mfa, mb,
size / sizeof *mb);
bus_space_barrier(sc->sc_iot, sc->sc_ioh, mfa, size,
BUS_SPACE_BARRIER_WRITE);
 1962         /* Post the MFA back to the IOP. */
iop_outl(sc, IOP_REG_IFIFO, mfa);
splx(s);
 1966         return (0);
 1967 }
 1969 /*
 1970  * Post a message to the IOP and deal with completion.
 1971  */
 1972 int
iop_msg_post(struct iop_softc *sc, struct iop_msg *im, void *xmb, int timo)
 1974 {
u_int32_t *mb = xmb;
 1976         int rv, s;
size_t size = mb[0] >> 14 & 3;
 1979         /* Terminate the scatter/gather list chain. */
 1980         if ((im->im_flags & IM_SGLOFFADJ) != 0)
mb[size - 2] |= I2O_SGL_END;
 1983         /* Perform reply buffer DMA synchronisation. */
 1984         if (sc->sc_curib++ == 0)
bus_dmamap_sync(sc->sc_dmat, sc->sc_rep_dmamap, 0,
sc->sc_rep_size, BUS_DMASYNC_PREREAD);
 1988         if ((rv = iop_post(sc, mb)) != 0)
 1989                 return (rv);
 1991         if ((im->im_flags & IM_DISCARD) != 0)
iop_msg_free(sc, im);
 1993         else if ((im->im_flags & IM_POLL) != 0 && timo == 0) {
 1994                 /* XXX For ofifo_init(). */
rv = 0;
 1996         } else if ((im->im_flags & (IM_POLL | IM_WAIT)) != 0) {
 1997                 if ((im->im_flags & IM_POLL) != 0)
iop_msg_poll(sc, im, timo);
 1999                 else
iop_msg_wait(sc, im, timo);
s = splbio();
 2003                 if ((im->im_flags & IM_REPLIED) != 0) {
 2004                         if ((im->im_flags & IM_NOSTATUS) != 0)
rv = 0;
 2006                         else if ((im->im_flags & IM_FAIL) != 0)
rv = ENXIO;
 2008                         else if (im->im_reqstatus != I2O_STATUS_SUCCESS)
rv = EIO;
 2010                         else
rv = 0;
 2012                 } else
rv = EBUSY;
splx(s);
 2015         } else
rv = 0;
 2018         return (rv);
 2019 }
 2021 /* 
 2022  * Spin until the specified message is replied to.
 2023  */
 2024 void
iop_msg_poll(struct iop_softc *sc, struct iop_msg *im, int timo)
 2026 {
u_int32_t rmfa;
 2028         int s, status;
s = splbio();   /* XXX */
 2032         /* Wait for completion. */
 2033         for (timo *= 10; timo != 0; timo--) {
 2034                 if ((iop_inl(sc, IOP_REG_INTR_STATUS) & IOP_INTR_OFIFO) != 0) {
 2035                         /* Double read to account for IOP bug. */
rmfa = iop_inl(sc, IOP_REG_OFIFO);
 2037                         if (rmfa == IOP_MFA_EMPTY)
rmfa = iop_inl(sc, IOP_REG_OFIFO);
 2039                         if (rmfa != IOP_MFA_EMPTY) {
status = iop_handle_reply(sc, rmfa);
 2042                                 /*
 2043                                  * Return the reply frame to the IOP's
 2044                                  * outbound FIFO.
 2045                                  */
iop_outl(sc, IOP_REG_OFIFO, rmfa);
 2047                         }
 2048                 }
 2049                 if ((im->im_flags & IM_REPLIED) != 0)
 2050                         break;
DELAY(100);
 2052         }
 2054         if (timo == 0) {
 2055 #ifdef I2ODEBUG
printf("%s: poll - no reply\n", sc->sc_dv.dv_xname);
 2057                 if (iop_status_get(sc, 1) != 0)
printf("iop_msg_poll: unable to retrieve status\n");
 2059                 else
printf("iop_msg_poll: IOP state = %d\n",
 2061                             (letoh32(sc->sc_status.segnumber) >> 16) & 0xff); 
 2062 #endif
 2063         }
splx(s);
 2066 }
 2068 /*
 2069  * Sleep until the specified message is replied to.
 2070  */
 2071 void
iop_msg_wait(struct iop_softc *sc, struct iop_msg *im, int timo)
 2073 {
 2074         int s, rv;
s = splbio();
 2077         if ((im->im_flags & IM_REPLIED) != 0) {
splx(s);
 2079                 return;
 2080         }
rv = tsleep(im, PRIBIO, "iopmsg", timo * hz / 1000);
splx(s);
 2084 #ifdef I2ODEBUG
 2085         if (rv != 0) {
printf("iop_msg_wait: tsleep() == %d\n", rv);
 2087                 if (iop_status_get(sc, 0) != 0)
printf("iop_msg_wait: unable to retrieve status\n");
 2089                 else
printf("iop_msg_wait: IOP state = %d\n",
 2091                             (letoh32(sc->sc_status.segnumber) >> 16) & 0xff); 
 2092         }
 2093 #endif
 2094 }
 2096 /*
 2097  * Release an unused message frame back to the IOP's inbound fifo.
 2098  */
 2099 void
iop_release_mfa(struct iop_softc *sc, u_int32_t mfa)
 2101 {
 2103         /* Use the frame to issue a no-op. */
iop_outl(sc, mfa, I2O_VERSION_11 | (4 << 16));
iop_outl(sc, mfa + 4, I2O_MSGFUNC(I2O_TID_IOP, I2O_UTIL_NOP));
iop_outl(sc, mfa + 8, 0);
iop_outl(sc, mfa + 12, 0);
iop_outl(sc, IOP_REG_IFIFO, mfa);
 2110 }
 2112 #ifdef I2ODEBUG
 2113 /*
 2114  * Dump a reply frame header.
 2115  */
 2116 void
iop_reply_print(struct iop_softc *sc, struct i2o_reply *rb)
 2118 {
u_int function, detail;
 2120 #ifdef I2OVERBOSE
 2121         const char *statusstr;
 2122 #endif
function = (letoh32(rb->msgfunc) >> 24) & 0xff;
detail = letoh16(rb->detail);
printf("%s: reply:\n", sc->sc_dv.dv_xname);
 2129 #ifdef I2OVERBOSE
 2130         if (rb->reqstatus < sizeof(iop_status) / sizeof(iop_status[0]))
statusstr = iop_status[rb->reqstatus];
 2132         else
statusstr = "undefined error code";
printf("%s:   function=0x%02x status=0x%02x (%s)\n", 
sc->sc_dv.dv_xname, function, rb->reqstatus, statusstr);
 2137 #else
printf("%s:   function=0x%02x status=0x%02x\n", 
sc->sc_dv.dv_xname, function, rb->reqstatus);
 2140 #endif
printf("%s:   detail=0x%04x ictx=0x%08x tctx=0x%08x\n",
sc->sc_dv.dv_xname, detail, letoh32(rb->msgictx),
letoh32(rb->msgtctx));
printf("%s:   tidi=%d tidt=%d flags=0x%02x\n", sc->sc_dv.dv_xname,
 2145             (letoh32(rb->msgfunc) >> 12) & 4095, letoh32(rb->msgfunc) & 4095,
 2146             (letoh32(rb->msgflags) >> 8) & 0xff);
 2147 }
 2148 #endif
 2150 /*
 2151  * Dump a transport failure reply.
 2152  */
 2153 void
iop_tfn_print(struct iop_softc *sc, struct i2o_fault_notify *fn)
 2155 {
printf("%s: WARNING: transport failure:\n", sc->sc_dv.dv_xname);
printf("%s:   ictx=0x%08x tctx=0x%08x\n", sc->sc_dv.dv_xname,
letoh32(fn->msgictx), letoh32(fn->msgtctx));
printf("%s:  failurecode=0x%02x severity=0x%02x\n",
sc->sc_dv.dv_xname, fn->failurecode, fn->severity);
printf("%s:  highestver=0x%02x lowestver=0x%02x\n",
sc->sc_dv.dv_xname, fn->highestver, fn->lowestver);
 2165 }
 2167 /*
 2168  * Translate an I2O ASCII field into a C string.
 2169  */
 2170 void
iop_strvis(struct iop_softc *sc, const char *src, int slen, char *dst, int dlen)
 2172 {
 2173         int hc, lc, i, nit;
dlen--;
lc = 0;
hc = 0;
i = 0;
 2180         /*
 2181          * DPT use NUL as a space, whereas AMI use it as a terminator.  The
 2182          * spec has nothing to say about it.  Since AMI fields are usually
 2183          * filled with junk after the terminator, ...
 2184          */
nit = (letoh16(sc->sc_status.orgid) != I2O_ORG_DPT);
 2187         while (slen-- != 0 && dlen-- != 0) {
 2188                 if (nit && *src == '\0')
 2189                         break;
 2190                 else if (*src <= 0x20 || *src >= 0x7f) {
 2191                         if (hc)
dst[i++] = ' ';
 2193                 } else {
hc = 1;
dst[i++] = *src;
lc = i;
 2197                 }
src++;
 2199         }
dst[lc] = '\0';
 2202 }
 2204 /*
 2205  * Retrieve the DEVICE_IDENTITY parameter group from the target and dump it.
 2206  */
 2207 int
iop_print_ident(struct iop_softc *sc, int tid)
 2209 {
 2210         struct {
 2211                 struct  i2o_param_op_results pr;
 2212                 struct  i2o_param_read_results prr;
 2213                 struct  i2o_param_device_identity di;
 2214         } __attribute__ ((__packed__)) p;
 2215         char buf[32];
 2216         int rv;
rv = iop_param_op(sc, tid, NULL, 0, I2O_PARAM_DEVICE_IDENTITY, &p,
 2219             sizeof(p));
 2220         if (rv != 0)
 2221                 return (rv);
iop_strvis(sc, p.di.vendorinfo, sizeof(p.di.vendorinfo), buf,
 2224             sizeof(buf));
printf(" <%s, ", buf);
iop_strvis(sc, p.di.productinfo, sizeof(p.di.productinfo), buf,
 2227             sizeof(buf));
printf("%s, ", buf);
iop_strvis(sc, p.di.revlevel, sizeof(p.di.revlevel), buf, sizeof(buf));
printf("%s>", buf);
 2232         return (0);
 2233 }
 2235 /*
 2236  * Claim or unclaim the specified TID.
 2237  */
 2238 int
iop_util_claim(struct iop_softc *sc, struct iop_initiator *ii, int release,
 2240               int flags)
 2241 {
 2242         struct iop_msg *im;
 2243         struct i2o_util_claim mf;
 2244         int rv, func;
func = release ? I2O_UTIL_CLAIM_RELEASE : I2O_UTIL_CLAIM;
im = iop_msg_alloc(sc, ii, IM_WAIT);
 2249         /* We can use the same structure, as they're identical. */
mf.msgflags = I2O_MSGFLAGS(i2o_util_claim);
mf.msgfunc = I2O_MSGFUNC(ii->ii_tid, func);
mf.msgictx = ii->ii_ictx;
mf.msgtctx = im->im_tctx;
mf.flags = flags;
rv = iop_msg_post(sc, im, &mf, 5000);
iop_msg_free(sc, im);
 2258         return (rv);
 2259 }       
 2261 /*
 2262  * Perform an abort.
 2263  */
 2264 int iop_util_abort(struct iop_softc *sc, struct iop_initiator *ii, int func,
 2265                   int tctxabort, int flags)
 2266 {
 2267         struct iop_msg *im;
 2268         struct i2o_util_abort mf;
 2269         int rv;
im = iop_msg_alloc(sc, ii, IM_WAIT);
mf.msgflags = I2O_MSGFLAGS(i2o_util_abort);
mf.msgfunc = I2O_MSGFUNC(ii->ii_tid, I2O_UTIL_ABORT);
mf.msgictx = ii->ii_ictx;
mf.msgtctx = im->im_tctx;
mf.flags = (func << 24) | flags;
mf.tctxabort = tctxabort;
rv = iop_msg_post(sc, im, &mf, 5000);
iop_msg_free(sc, im);
 2282         return (rv);
 2283 }
 2285 /*
 2286  * Enable or disable reception of events for the specified device.
 2287  */
 2288 int iop_util_eventreg(struct iop_softc *sc, struct iop_initiator *ii, int mask)
 2289 {
 2290         struct iop_msg *im;
 2291         struct i2o_util_event_register mf;
im = iop_msg_alloc(sc, ii, 0);
mf.msgflags = I2O_MSGFLAGS(i2o_util_event_register);
mf.msgfunc = I2O_MSGFUNC(ii->ii_tid, I2O_UTIL_EVENT_REGISTER);
mf.msgictx = ii->ii_ictx;
mf.msgtctx = im->im_tctx;
mf.eventmask = mask;
 2301         /* This message is replied to only when events are signalled. */
 2302         return (iop_msg_post(sc, im, &mf, 0));
 2303 }
 2305 int
 2306 iopopen(dev_t dev, int flag, int mode, struct proc *p)
 2307 {
 2308         struct iop_softc *sc;
 2310         if (!(sc = (struct iop_softc *)device_lookup(&iop_cd, minor(dev))))
 2311                 return (ENXIO);
 2312         if ((sc->sc_flags & IOP_ONLINE) == 0)
 2313                 return (ENXIO);
 2314         if ((sc->sc_flags & IOP_OPEN) != 0)
 2315                 return (EBUSY);
sc->sc_flags |= IOP_OPEN;
sc->sc_ptb = malloc(IOP_MAX_XFER * IOP_MAX_MSG_XFERS, M_DEVBUF,
M_WAITOK);
 2320         if (sc->sc_ptb == NULL) {
sc->sc_flags ^= IOP_OPEN;
 2322                 return (ENOMEM);
 2323         }
 2325         return (0);
 2326 }
 2328 int
 2329 iopclose(dev_t dev, int flag, int mode, struct proc *p)
 2330 {
 2331         struct iop_softc *sc;
sc = (struct iop_softc *)device_lookup(&iop_cd, minor(dev)); /* XXX */
free(sc->sc_ptb, M_DEVBUF);
sc->sc_flags &= ~IOP_OPEN;
 2336         return (0);
 2337 }
 2339 int
 2340 iopioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
 2341 {
 2342         struct iop_softc *sc;
 2343         struct iovec *iov;
 2344         int rv, i;
 2346         if (securelevel >= 2)
 2347                 return (EPERM);
sc = (struct iop_softc *)device_lookup(&iop_cd, minor(dev)); /* XXX */
 2351         switch (cmd) {
 2352         case IOPIOCPT:
 2353                 return (iop_passthrough(sc, (struct ioppt *)data));
 2355         case IOPIOCGSTATUS:
iov = (struct iovec *)data;
i = sizeof(struct i2o_status);
 2358                 if (i > iov->iov_len)
i = iov->iov_len;
 2360                 else
iov->iov_len = i;
 2362                 if ((rv = iop_status_get(sc, 0)) == 0)
rv = copyout(&sc->sc_status, iov->iov_base, i);
 2364                 return (rv);
 2366         case IOPIOCGLCT:
 2367         case IOPIOCGTIDMAP:
 2368         case IOPIOCRECONFIG:
 2369                 break;
 2371         default:
 2372 #if defined(DIAGNOSTIC) || defined(I2ODEBUG)
printf("%s: unknown ioctl %lx\n", sc->sc_dv.dv_xname, cmd);
 2374 #endif
 2375                 return (ENOTTY);
 2376         }
 2378         if ((rv = lockmgr(&sc->sc_conflock, LK_SHARED, NULL)) != 0)
 2379                 return (rv);
 2381         switch (cmd) {
 2382         case IOPIOCGLCT:
iov = (struct iovec *)data;
i = letoh16(sc->sc_lct->tablesize) << 2;
 2385                 if (i > iov->iov_len)
i = iov->iov_len;
 2387                 else
iov->iov_len = i;
rv = copyout(sc->sc_lct, iov->iov_base, i);
 2390                 break;
 2392         case IOPIOCRECONFIG:
rv = iop_reconfigure(sc, 0);
 2394                 break;
 2396         case IOPIOCGTIDMAP:
iov = (struct iovec *)data;
i = sizeof(struct iop_tidmap) * sc->sc_nlctent;
 2399                 if (i > iov->iov_len)
i = iov->iov_len;
 2401                 else
iov->iov_len = i;
rv = copyout(sc->sc_tidmap, iov->iov_base, i);
 2404                 break;
 2405         }
lockmgr(&sc->sc_conflock, LK_RELEASE, NULL);
 2408         return (rv);
 2409 }
 2411 int
iop_passthrough(struct iop_softc *sc, struct ioppt *pt)
 2413 {
 2414         struct iop_msg *im;
 2415         struct i2o_msg *mf;
 2416         struct ioppt_buf *ptb;
 2417         int rv, i, mapped;
 2418         void *buf;
mf = NULL;
im = NULL;
mapped = 1;
 2424         if (pt->pt_msglen > IOP_MAX_MSG_SIZE ||
pt->pt_msglen > (letoh16(sc->sc_status.inboundmframesize) << 2) ||
pt->pt_msglen < sizeof(struct i2o_msg) ||
pt->pt_nbufs > IOP_MAX_MSG_XFERS ||
pt->pt_nbufs < 0 || pt->pt_replylen < 0 ||
pt->pt_timo < 1000 || pt->pt_timo > 5*60*1000)
 2430                 return (EINVAL);
 2432         for (i = 0; i < pt->pt_nbufs; i++)
 2433                 if (pt->pt_bufs[i].ptb_datalen > IOP_MAX_XFER) {
rv = ENOMEM;
 2435                         goto bad;
 2436                 }
mf = malloc(IOP_MAX_MSG_SIZE, M_DEVBUF, M_WAITOK);
 2439         if (mf == NULL)
 2440                 return (ENOMEM);
 2442         if ((rv = copyin(pt->pt_msg, mf, pt->pt_msglen)) != 0)
 2443                 goto bad;
im = iop_msg_alloc(sc, NULL, IM_WAIT | IM_NOSTATUS);
im->im_rb = (struct i2o_reply *)mf;
mf->msgictx = IOP_ICTX;
mf->msgtctx = im->im_tctx;
 2450         for (i = 0; i < pt->pt_nbufs; i++) {
ptb = &pt->pt_bufs[i];
buf = sc->sc_ptb + i * IOP_MAX_XFER;
 2454                 if ((u_int)ptb->ptb_datalen > IOP_MAX_XFER) {
rv = EINVAL;
 2456                         goto bad;
 2457                 }
 2459                 if (ptb->ptb_out != 0) {
rv = copyin(ptb->ptb_data, buf, ptb->ptb_datalen);
 2461                         if (rv != 0)
 2462                                 goto bad;
 2463                 }
rv = iop_msg_map(sc, im, (u_int32_t *)mf, buf,
ptb->ptb_datalen, ptb->ptb_out != 0);
 2467                 if (rv != 0)
 2468                         goto bad;
mapped = 1;
 2470         }
 2472         if ((rv = iop_msg_post(sc, im, mf, pt->pt_timo)) != 0)
 2473                 goto bad;
i = (letoh32(im->im_rb->msgflags) >> 14) & ~3;
 2476         if (i > IOP_MAX_MSG_SIZE)
i = IOP_MAX_MSG_SIZE;
 2478         if (i > pt->pt_replylen)
i = pt->pt_replylen;
 2480         if ((rv = copyout(im->im_rb, pt->pt_reply, i)) != 0)
 2481                 goto bad;
iop_msg_unmap(sc, im);
mapped = 0;
 2486         for (i = 0; i < pt->pt_nbufs; i++) {
ptb = &pt->pt_bufs[i];
 2488                 if (ptb->ptb_out != 0)
 2489                         continue;
buf = sc->sc_ptb + i * IOP_MAX_XFER;
rv = copyout(buf, ptb->ptb_data, ptb->ptb_datalen);
 2492                 if (rv != 0)
 2493                         break;
 2494         }
bad:
 2497         if (mapped != 0)
iop_msg_unmap(sc, im);
 2499         if (im != NULL)
iop_msg_free(sc, im);
 2501         if (mf != NULL)
free(mf, M_DEVBUF);
 2503         return (rv);
 2504 }