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/mly/mly.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 /*-
    2  * Copyright (c) 2000, 2001 Michael Smith
    3  * Copyright (c) 2000 BSDi
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   25  * SUCH DAMAGE.
   26  *
   27  *      $FreeBSD$
   28  */
   29 
   30 #include <sys/param.h>
   31 #include <sys/systm.h>
   32 #include <sys/malloc.h>
   33 #include <sys/kernel.h>
   34 #include <sys/bus.h>
   35 #include <sys/conf.h>
   36 #include <sys/ctype.h>
   37 #include <sys/ioccom.h>
   38 #include <sys/stat.h>
   39 
   40 #include <machine/bus.h>
   41 #include <machine/resource.h>
   42 #include <sys/rman.h>
   43 
   44 #include <cam/cam.h>
   45 #include <cam/cam_ccb.h>
   46 #include <cam/cam_periph.h>
   47 #include <cam/cam_sim.h>
   48 #include <cam/cam_xpt_sim.h>
   49 #include <cam/scsi/scsi_all.h>
   50 #include <cam/scsi/scsi_message.h>
   51 
   52 #include <dev/pci/pcireg.h>
   53 #include <dev/pci/pcivar.h>
   54 
   55 #include <dev/mly/mlyreg.h>
   56 #include <dev/mly/mlyio.h>
   57 #include <dev/mly/mlyvar.h>
   58 #include <dev/mly/mly_tables.h>
   59 
   60 static int      mly_probe(device_t dev);
   61 static int      mly_attach(device_t dev);
   62 static int      mly_pci_attach(struct mly_softc *sc);
   63 static int      mly_detach(device_t dev);
   64 static int      mly_shutdown(device_t dev);
   65 static void     mly_intr(void *arg);
   66 
   67 static int      mly_sg_map(struct mly_softc *sc);
   68 static void     mly_sg_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error);
   69 static int      mly_mmbox_map(struct mly_softc *sc);
   70 static void     mly_mmbox_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error);
   71 static void     mly_free(struct mly_softc *sc);
   72 
   73 static int      mly_get_controllerinfo(struct mly_softc *sc);
   74 static void     mly_scan_devices(struct mly_softc *sc);
   75 static void     mly_rescan_btl(struct mly_softc *sc, int bus, int target);
   76 static void     mly_complete_rescan(struct mly_command *mc);
   77 static int      mly_get_eventstatus(struct mly_softc *sc);
   78 static int      mly_enable_mmbox(struct mly_softc *sc);
   79 static int      mly_flush(struct mly_softc *sc);
   80 static int      mly_ioctl(struct mly_softc *sc, struct mly_command_ioctl *ioctl, void **data, 
   81                           size_t datasize, u_int8_t *status, void *sense_buffer, size_t *sense_length);
   82 static void     mly_check_event(struct mly_softc *sc);
   83 static void     mly_fetch_event(struct mly_softc *sc);
   84 static void     mly_complete_event(struct mly_command *mc);
   85 static void     mly_process_event(struct mly_softc *sc, struct mly_event *me);
   86 static void     mly_periodic(void *data);
   87 
   88 static int      mly_immediate_command(struct mly_command *mc);
   89 static int      mly_start(struct mly_command *mc);
   90 static void     mly_done(struct mly_softc *sc);
   91 static void     mly_complete(void *context, int pending);
   92 
   93 static int      mly_alloc_command(struct mly_softc *sc, struct mly_command **mcp);
   94 static void     mly_release_command(struct mly_command *mc);
   95 static void     mly_alloc_commands_map(void *arg, bus_dma_segment_t *segs, int nseg, int error);
   96 static int      mly_alloc_commands(struct mly_softc *sc);
   97 static void     mly_release_commands(struct mly_softc *sc);
   98 static void     mly_map_command(struct mly_command *mc);
   99 static void     mly_unmap_command(struct mly_command *mc);
  100 
  101 static int      mly_cam_attach(struct mly_softc *sc);
  102 static void     mly_cam_detach(struct mly_softc *sc);
  103 static void     mly_cam_rescan_btl(struct mly_softc *sc, int bus, int target);
  104 static void     mly_cam_rescan_callback(struct cam_periph *periph, union ccb *ccb);
  105 static void     mly_cam_action(struct cam_sim *sim, union ccb *ccb);
  106 static int      mly_cam_action_io(struct cam_sim *sim, struct ccb_scsiio *csio);
  107 static void     mly_cam_poll(struct cam_sim *sim);
  108 static void     mly_cam_complete(struct mly_command *mc);
  109 static struct cam_periph *mly_find_periph(struct mly_softc *sc, int bus, int target);
  110 static int      mly_name_device(struct mly_softc *sc, int bus, int target);
  111 
  112 static int      mly_fwhandshake(struct mly_softc *sc);
  113 
  114 static void     mly_describe_controller(struct mly_softc *sc);
  115 #ifdef MLY_DEBUG
  116 static void     mly_printstate(struct mly_softc *sc);
  117 static void     mly_print_command(struct mly_command *mc);
  118 static void     mly_print_packet(struct mly_command *mc);
  119 static void     mly_panic(struct mly_softc *sc, char *reason);
  120 #endif
  121 void            mly_print_controller(int controller);
  122 static int      mly_timeout(struct mly_softc *sc);
  123 
  124 
  125 static d_open_t         mly_user_open;
  126 static d_close_t        mly_user_close;
  127 static d_ioctl_t        mly_user_ioctl;
  128 static int      mly_user_command(struct mly_softc *sc, struct mly_user_command *uc);
  129 static int      mly_user_health(struct mly_softc *sc, struct mly_user_health *uh);
  130 
  131 #define MLY_CMD_TIMEOUT         20
  132 
  133 static device_method_t mly_methods[] = {
  134     /* Device interface */
  135     DEVMETHOD(device_probe,     mly_probe),
  136     DEVMETHOD(device_attach,    mly_attach),
  137     DEVMETHOD(device_detach,    mly_detach),
  138     DEVMETHOD(device_shutdown,  mly_shutdown),
  139     { 0, 0 }
  140 };
  141 
  142 static driver_t mly_pci_driver = {
  143         "mly",
  144         mly_methods,
  145         sizeof(struct mly_softc)
  146 };
  147 
  148 static devclass_t       mly_devclass;
  149 DRIVER_MODULE(mly, pci, mly_pci_driver, mly_devclass, 0, 0);
  150 MODULE_DEPEND(mly, pci, 1, 1, 1);
  151 MODULE_DEPEND(mly, cam, 1, 1, 1);
  152 
  153 static struct cdevsw mly_cdevsw = {
  154         .d_version =    D_VERSION,
  155         .d_flags =      D_NEEDGIANT,
  156         .d_open =       mly_user_open,
  157         .d_close =      mly_user_close,
  158         .d_ioctl =      mly_user_ioctl,
  159         .d_name =       "mly",
  160 };
  161 
  162 /********************************************************************************
  163  ********************************************************************************
  164                                                                  Device Interface
  165  ********************************************************************************
  166  ********************************************************************************/
  167 
  168 static struct mly_ident
  169 {
  170     u_int16_t           vendor;
  171     u_int16_t           device;
  172     u_int16_t           subvendor;
  173     u_int16_t           subdevice;
  174     int                 hwif;
  175     char                *desc;
  176 } mly_identifiers[] = {
  177     {0x1069, 0xba56, 0x1069, 0x0040, MLY_HWIF_STRONGARM, "Mylex eXtremeRAID 2000"},
  178     {0x1069, 0xba56, 0x1069, 0x0030, MLY_HWIF_STRONGARM, "Mylex eXtremeRAID 3000"},
  179     {0x1069, 0x0050, 0x1069, 0x0050, MLY_HWIF_I960RX,    "Mylex AcceleRAID 352"},
  180     {0x1069, 0x0050, 0x1069, 0x0052, MLY_HWIF_I960RX,    "Mylex AcceleRAID 170"},
  181     {0x1069, 0x0050, 0x1069, 0x0054, MLY_HWIF_I960RX,    "Mylex AcceleRAID 160"},
  182     {0, 0, 0, 0, 0, 0}
  183 };
  184 
  185 /********************************************************************************
  186  * Compare the provided PCI device with the list we support.
  187  */
  188 static int
  189 mly_probe(device_t dev)
  190 {
  191     struct mly_ident    *m;
  192 
  193     debug_called(1);
  194 
  195     for (m = mly_identifiers; m->vendor != 0; m++) {
  196         if ((m->vendor == pci_get_vendor(dev)) &&
  197             (m->device == pci_get_device(dev)) &&
  198             ((m->subvendor == 0) || ((m->subvendor == pci_get_subvendor(dev)) &&
  199                                      (m->subdevice == pci_get_subdevice(dev))))) {
  200             
  201             device_set_desc(dev, m->desc);
  202             return(BUS_PROBE_DEFAULT);  /* allow room to be overridden */
  203         }
  204     }
  205     return(ENXIO);
  206 }
  207 
  208 /********************************************************************************
  209  * Initialise the controller and softc
  210  */
  211 static int
  212 mly_attach(device_t dev)
  213 {
  214     struct mly_softc    *sc = device_get_softc(dev);
  215     int                 error;
  216 
  217     debug_called(1);
  218 
  219     sc->mly_dev = dev;
  220 
  221 #ifdef MLY_DEBUG
  222     if (device_get_unit(sc->mly_dev) == 0)
  223         mly_softc0 = sc;
  224 #endif    
  225 
  226     /*
  227      * Do PCI-specific initialisation.
  228      */
  229     if ((error = mly_pci_attach(sc)) != 0)
  230         goto out;
  231 
  232     /*
  233      * Initialise per-controller queues.
  234      */
  235     mly_initq_free(sc);
  236     mly_initq_busy(sc);
  237     mly_initq_complete(sc);
  238 
  239     /*
  240      * Initialise command-completion task.
  241      */
  242     TASK_INIT(&sc->mly_task_complete, 0, mly_complete, sc);
  243 
  244     /* disable interrupts before we start talking to the controller */
  245     MLY_MASK_INTERRUPTS(sc);
  246 
  247     /* 
  248      * Wait for the controller to come ready, handshake with the firmware if required.
  249      * This is typically only necessary on platforms where the controller BIOS does not
  250      * run.
  251      */
  252     if ((error = mly_fwhandshake(sc)))
  253         goto out;
  254 
  255     /*
  256      * Allocate initial command buffers.
  257      */
  258     if ((error = mly_alloc_commands(sc)))
  259         goto out;
  260 
  261     /* 
  262      * Obtain controller feature information
  263      */
  264     if ((error = mly_get_controllerinfo(sc)))
  265         goto out;
  266 
  267     /*
  268      * Reallocate command buffers now we know how many we want.
  269      */
  270     mly_release_commands(sc);
  271     if ((error = mly_alloc_commands(sc)))
  272         goto out;
  273 
  274     /*
  275      * Get the current event counter for health purposes, populate the initial
  276      * health status buffer.
  277      */
  278     if ((error = mly_get_eventstatus(sc)))
  279         goto out;
  280 
  281     /*
  282      * Enable memory-mailbox mode.
  283      */
  284     if ((error = mly_enable_mmbox(sc)))
  285         goto out;
  286 
  287     /*
  288      * Attach to CAM.
  289      */
  290     if ((error = mly_cam_attach(sc)))
  291         goto out;
  292 
  293     /* 
  294      * Print a little information about the controller 
  295      */
  296     mly_describe_controller(sc);
  297 
  298     /*
  299      * Mark all attached devices for rescan.
  300      */
  301     mly_scan_devices(sc);
  302 
  303     /*
  304      * Instigate the first status poll immediately.  Rescan completions won't
  305      * happen until interrupts are enabled, which should still be before
  306      * the SCSI subsystem gets to us, courtesy of the "SCSI settling delay".
  307      */
  308     mly_periodic((void *)sc);
  309 
  310     /*
  311      * Create the control device.
  312      */
  313     sc->mly_dev_t = make_dev(&mly_cdevsw, device_get_unit(sc->mly_dev), UID_ROOT, GID_OPERATOR,
  314                              S_IRUSR | S_IWUSR, "mly%d", device_get_unit(sc->mly_dev));
  315     sc->mly_dev_t->si_drv1 = sc;
  316 
  317     /* enable interrupts now */
  318     MLY_UNMASK_INTERRUPTS(sc);
  319 
  320 #ifdef MLY_DEBUG
  321     timeout((timeout_t *)mly_timeout, sc, MLY_CMD_TIMEOUT * hz);
  322 #endif
  323 
  324  out:
  325     if (error != 0)
  326         mly_free(sc);
  327     return(error);
  328 }
  329 
  330 /********************************************************************************
  331  * Perform PCI-specific initialisation.
  332  */
  333 static int
  334 mly_pci_attach(struct mly_softc *sc)
  335 {
  336     int                 i, error;
  337     u_int32_t           command;
  338 
  339     debug_called(1);
  340 
  341     /* assume failure is 'not configured' */
  342     error = ENXIO;
  343 
  344     /* 
  345      * Verify that the adapter is correctly set up in PCI space.
  346      * 
  347      * XXX we shouldn't do this; the PCI code should.
  348      */
  349     command = pci_read_config(sc->mly_dev, PCIR_COMMAND, 2);
  350     command |= PCIM_CMD_BUSMASTEREN;
  351     pci_write_config(sc->mly_dev, PCIR_COMMAND, command, 2);
  352     command = pci_read_config(sc->mly_dev, PCIR_COMMAND, 2);
  353     if (!(command & PCIM_CMD_BUSMASTEREN)) {
  354         mly_printf(sc, "can't enable busmaster feature\n");
  355         goto fail;
  356     }
  357     if ((command & PCIM_CMD_MEMEN) == 0) {
  358         mly_printf(sc, "memory window not available\n");
  359         goto fail;
  360     }
  361 
  362     /*
  363      * Allocate the PCI register window.
  364      */
  365     sc->mly_regs_rid = PCIR_BAR(0);     /* first base address register */
  366     if ((sc->mly_regs_resource = bus_alloc_resource_any(sc->mly_dev, 
  367             SYS_RES_MEMORY, &sc->mly_regs_rid, RF_ACTIVE)) == NULL) {
  368         mly_printf(sc, "can't allocate register window\n");
  369         goto fail;
  370     }
  371     sc->mly_btag = rman_get_bustag(sc->mly_regs_resource);
  372     sc->mly_bhandle = rman_get_bushandle(sc->mly_regs_resource);
  373 
  374     /* 
  375      * Allocate and connect our interrupt.
  376      */
  377     sc->mly_irq_rid = 0;
  378     if ((sc->mly_irq = bus_alloc_resource_any(sc->mly_dev, SYS_RES_IRQ, 
  379                     &sc->mly_irq_rid, RF_SHAREABLE | RF_ACTIVE)) == NULL) {
  380         mly_printf(sc, "can't allocate interrupt\n");
  381         goto fail;
  382     }
  383     if (bus_setup_intr(sc->mly_dev, sc->mly_irq, INTR_TYPE_CAM | INTR_ENTROPY, NULL, mly_intr, sc, &sc->mly_intr)) {
  384         mly_printf(sc, "can't set up interrupt\n");
  385         goto fail;
  386     }
  387 
  388     /* assume failure is 'out of memory' */
  389     error = ENOMEM;
  390 
  391     /*
  392      * Allocate the parent bus DMA tag appropriate for our PCI interface.
  393      * 
  394      * Note that all of these controllers are 64-bit capable.
  395      */
  396     if (bus_dma_tag_create(NULL,                        /* parent */
  397                            1, 0,                        /* alignment, boundary */
  398                            BUS_SPACE_MAXADDR_32BIT,     /* lowaddr */
  399                            BUS_SPACE_MAXADDR,           /* highaddr */
  400                            NULL, NULL,                  /* filter, filterarg */
  401                            MAXBSIZE, MLY_MAX_SGENTRIES, /* maxsize, nsegments */
  402                            BUS_SPACE_MAXSIZE_32BIT,     /* maxsegsize */
  403                            BUS_DMA_ALLOCNOW,            /* flags */
  404                            NULL,                        /* lockfunc */
  405                            NULL,                        /* lockarg */
  406                            &sc->mly_parent_dmat)) {
  407         mly_printf(sc, "can't allocate parent DMA tag\n");
  408         goto fail;
  409     }
  410 
  411     /*
  412      * Create DMA tag for mapping buffers into controller-addressable space.
  413      */
  414     if (bus_dma_tag_create(sc->mly_parent_dmat,         /* parent */
  415                            1, 0,                        /* alignment, boundary */
  416                            BUS_SPACE_MAXADDR,           /* lowaddr */
  417                            BUS_SPACE_MAXADDR,           /* highaddr */
  418                            NULL, NULL,                  /* filter, filterarg */
  419                            MAXBSIZE, MLY_MAX_SGENTRIES, /* maxsize, nsegments */
  420                            BUS_SPACE_MAXSIZE_32BIT,     /* maxsegsize */
  421                            0,                           /* flags */
  422                            busdma_lock_mutex,           /* lockfunc */
  423                            &Giant,                      /* lockarg */
  424                            &sc->mly_buffer_dmat)) {
  425         mly_printf(sc, "can't allocate buffer DMA tag\n");
  426         goto fail;
  427     }
  428 
  429     /*
  430      * Initialise the DMA tag for command packets.
  431      */
  432     if (bus_dma_tag_create(sc->mly_parent_dmat,         /* parent */
  433                            1, 0,                        /* alignment, boundary */
  434                            BUS_SPACE_MAXADDR,           /* lowaddr */
  435                            BUS_SPACE_MAXADDR,           /* highaddr */
  436                            NULL, NULL,                  /* filter, filterarg */
  437                            sizeof(union mly_command_packet) * MLY_MAX_COMMANDS, 1,      /* maxsize, nsegments */
  438                            BUS_SPACE_MAXSIZE_32BIT,     /* maxsegsize */
  439                            BUS_DMA_ALLOCNOW,            /* flags */
  440                            NULL, NULL,                  /* lockfunc, lockarg */
  441                            &sc->mly_packet_dmat)) {
  442         mly_printf(sc, "can't allocate command packet DMA tag\n");
  443         goto fail;
  444     }
  445 
  446     /* 
  447      * Detect the hardware interface version 
  448      */
  449     for (i = 0; mly_identifiers[i].vendor != 0; i++) {
  450         if ((mly_identifiers[i].vendor == pci_get_vendor(sc->mly_dev)) &&
  451             (mly_identifiers[i].device == pci_get_device(sc->mly_dev))) {
  452             sc->mly_hwif = mly_identifiers[i].hwif;
  453             switch(sc->mly_hwif) {
  454             case MLY_HWIF_I960RX:
  455                 debug(1, "set hardware up for i960RX");
  456                 sc->mly_doorbell_true = 0x00;
  457                 sc->mly_command_mailbox =  MLY_I960RX_COMMAND_MAILBOX;
  458                 sc->mly_status_mailbox =   MLY_I960RX_STATUS_MAILBOX;
  459                 sc->mly_idbr =             MLY_I960RX_IDBR;
  460                 sc->mly_odbr =             MLY_I960RX_ODBR;
  461                 sc->mly_error_status =     MLY_I960RX_ERROR_STATUS;
  462                 sc->mly_interrupt_status = MLY_I960RX_INTERRUPT_STATUS;
  463                 sc->mly_interrupt_mask =   MLY_I960RX_INTERRUPT_MASK;
  464                 break;
  465             case MLY_HWIF_STRONGARM:
  466                 debug(1, "set hardware up for StrongARM");
  467                 sc->mly_doorbell_true = 0xff;           /* doorbell 'true' is 0 */
  468                 sc->mly_command_mailbox =  MLY_STRONGARM_COMMAND_MAILBOX;
  469                 sc->mly_status_mailbox =   MLY_STRONGARM_STATUS_MAILBOX;
  470                 sc->mly_idbr =             MLY_STRONGARM_IDBR;
  471                 sc->mly_odbr =             MLY_STRONGARM_ODBR;
  472                 sc->mly_error_status =     MLY_STRONGARM_ERROR_STATUS;
  473                 sc->mly_interrupt_status = MLY_STRONGARM_INTERRUPT_STATUS;
  474                 sc->mly_interrupt_mask =   MLY_STRONGARM_INTERRUPT_MASK;
  475                 break;
  476             }
  477             break;
  478         }
  479     }
  480 
  481     /*
  482      * Create the scatter/gather mappings.
  483      */
  484     if ((error = mly_sg_map(sc)))
  485         goto fail;
  486 
  487     /*
  488      * Allocate and map the memory mailbox
  489      */
  490     if ((error = mly_mmbox_map(sc)))
  491         goto fail;
  492 
  493     error = 0;
  494             
  495 fail:
  496     return(error);
  497 }
  498 
  499 /********************************************************************************
  500  * Shut the controller down and detach all our resources.
  501  */
  502 static int
  503 mly_detach(device_t dev)
  504 {
  505     int                 error;
  506 
  507     if ((error = mly_shutdown(dev)) != 0)
  508         return(error);
  509     
  510     mly_free(device_get_softc(dev));
  511     return(0);
  512 }
  513 
  514 /********************************************************************************
  515  * Bring the controller to a state where it can be safely left alone.
  516  *
  517  * Note that it should not be necessary to wait for any outstanding commands,
  518  * as they should be completed prior to calling here.
  519  *
  520  * XXX this applies for I/O, but not status polls; we should beware of
  521  *     the case where a status command is running while we detach.
  522  */
  523 static int
  524 mly_shutdown(device_t dev)
  525 {
  526     struct mly_softc    *sc = device_get_softc(dev);
  527 
  528     debug_called(1);
  529     
  530     if (sc->mly_state & MLY_STATE_OPEN)
  531         return(EBUSY);
  532 
  533     /* kill the periodic event */
  534     untimeout(mly_periodic, sc, sc->mly_periodic);
  535 
  536     /* flush controller */
  537     mly_printf(sc, "flushing cache...");
  538     printf("%s\n", mly_flush(sc) ? "failed" : "done");
  539 
  540     MLY_MASK_INTERRUPTS(sc);
  541 
  542     return(0);
  543 }
  544 
  545 /*******************************************************************************
  546  * Take an interrupt, or be poked by other code to look for interrupt-worthy
  547  * status.
  548  */
  549 static void
  550 mly_intr(void *arg)
  551 {
  552     struct mly_softc    *sc = (struct mly_softc *)arg;
  553 
  554     debug_called(2);
  555 
  556     mly_done(sc);
  557 };
  558 
  559 /********************************************************************************
  560  ********************************************************************************
  561                                                 Bus-dependant Resource Management
  562  ********************************************************************************
  563  ********************************************************************************/
  564 
  565 /********************************************************************************
  566  * Allocate memory for the scatter/gather tables
  567  */
  568 static int
  569 mly_sg_map(struct mly_softc *sc)
  570 {
  571     size_t      segsize;
  572 
  573     debug_called(1);
  574 
  575     /*
  576      * Create a single tag describing a region large enough to hold all of
  577      * the s/g lists we will need.
  578      */
  579     segsize = sizeof(struct mly_sg_entry) * MLY_MAX_COMMANDS *MLY_MAX_SGENTRIES;
  580     if (bus_dma_tag_create(sc->mly_parent_dmat,         /* parent */
  581                            1, 0,                        /* alignment,boundary */
  582                            BUS_SPACE_MAXADDR,           /* lowaddr */
  583                            BUS_SPACE_MAXADDR,           /* highaddr */
  584                            NULL, NULL,                  /* filter, filterarg */
  585                            segsize, 1,                  /* maxsize, nsegments */
  586                            BUS_SPACE_MAXSIZE_32BIT,     /* maxsegsize */
  587                            BUS_DMA_ALLOCNOW,            /* flags */
  588                            NULL, NULL,                  /* lockfunc, lockarg */
  589                            &sc->mly_sg_dmat)) {
  590         mly_printf(sc, "can't allocate scatter/gather DMA tag\n");
  591         return(ENOMEM);
  592     }
  593 
  594     /*
  595      * Allocate enough s/g maps for all commands and permanently map them into
  596      * controller-visible space.
  597      *  
  598      * XXX this assumes we can get enough space for all the s/g maps in one 
  599      * contiguous slab.
  600      */
  601     if (bus_dmamem_alloc(sc->mly_sg_dmat, (void **)&sc->mly_sg_table,
  602                          BUS_DMA_NOWAIT, &sc->mly_sg_dmamap)) {
  603         mly_printf(sc, "can't allocate s/g table\n");
  604         return(ENOMEM);
  605     }
  606     if (bus_dmamap_load(sc->mly_sg_dmat, sc->mly_sg_dmamap, sc->mly_sg_table,
  607                         segsize, mly_sg_map_helper, sc, BUS_DMA_NOWAIT) != 0)
  608         return (ENOMEM);
  609     return(0);
  610 }
  611 
  612 /********************************************************************************
  613  * Save the physical address of the base of the s/g table.
  614  */
  615 static void
  616 mly_sg_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
  617 {
  618     struct mly_softc    *sc = (struct mly_softc *)arg;
  619 
  620     debug_called(1);
  621 
  622     /* save base of s/g table's address in bus space */
  623     sc->mly_sg_busaddr = segs->ds_addr;
  624 }
  625 
  626 /********************************************************************************
  627  * Allocate memory for the memory-mailbox interface
  628  */
  629 static int
  630 mly_mmbox_map(struct mly_softc *sc)
  631 {
  632 
  633     /*
  634      * Create a DMA tag for a single contiguous region large enough for the
  635      * memory mailbox structure.
  636      */
  637     if (bus_dma_tag_create(sc->mly_parent_dmat,         /* parent */
  638                            1, 0,                        /* alignment,boundary */
  639                            BUS_SPACE_MAXADDR,           /* lowaddr */
  640                            BUS_SPACE_MAXADDR,           /* highaddr */
  641                            NULL, NULL,                  /* filter, filterarg */
  642                            sizeof(struct mly_mmbox), 1, /* maxsize, nsegments */
  643                            BUS_SPACE_MAXSIZE_32BIT,     /* maxsegsize */
  644                            BUS_DMA_ALLOCNOW,            /* flags */
  645                            NULL, NULL,                  /* lockfunc, lockarg */
  646                            &sc->mly_mmbox_dmat)) {
  647         mly_printf(sc, "can't allocate memory mailbox DMA tag\n");
  648         return(ENOMEM);
  649     }
  650 
  651     /*
  652      * Allocate the buffer
  653      */
  654     if (bus_dmamem_alloc(sc->mly_mmbox_dmat, (void **)&sc->mly_mmbox, BUS_DMA_NOWAIT, &sc->mly_mmbox_dmamap)) {
  655         mly_printf(sc, "can't allocate memory mailbox\n");
  656         return(ENOMEM);
  657     }
  658     if (bus_dmamap_load(sc->mly_mmbox_dmat, sc->mly_mmbox_dmamap, sc->mly_mmbox,
  659                         sizeof(struct mly_mmbox), mly_mmbox_map_helper, sc, 
  660                         BUS_DMA_NOWAIT) != 0)
  661         return (ENOMEM);
  662     bzero(sc->mly_mmbox, sizeof(*sc->mly_mmbox));
  663     return(0);
  664 
  665 }
  666 
  667 /********************************************************************************
  668  * Save the physical address of the memory mailbox 
  669  */
  670 static void
  671 mly_mmbox_map_helper(void *arg, bus_dma_segment_t *segs, int nseg, int error)
  672 {
  673     struct mly_softc    *sc = (struct mly_softc *)arg;
  674 
  675     debug_called(1);
  676 
  677     sc->mly_mmbox_busaddr = segs->ds_addr;
  678 }
  679 
  680 /********************************************************************************
  681  * Free all of the resources associated with (sc)
  682  *
  683  * Should not be called if the controller is active.
  684  */
  685 static void
  686 mly_free(struct mly_softc *sc)
  687 {
  688     
  689     debug_called(1);
  690 
  691     /* Remove the management device */
  692     destroy_dev(sc->mly_dev_t);
  693 
  694     /* detach from CAM */
  695     mly_cam_detach(sc);
  696 
  697     /* release command memory */
  698     mly_release_commands(sc);
  699     
  700     /* throw away the controllerinfo structure */
  701     if (sc->mly_controllerinfo != NULL)
  702         free(sc->mly_controllerinfo, M_DEVBUF);
  703 
  704     /* throw away the controllerparam structure */
  705     if (sc->mly_controllerparam != NULL)
  706         free(sc->mly_controllerparam, M_DEVBUF);
  707 
  708     /* destroy data-transfer DMA tag */
  709     if (sc->mly_buffer_dmat)
  710         bus_dma_tag_destroy(sc->mly_buffer_dmat);
  711 
  712     /* free and destroy DMA memory and tag for s/g lists */
  713     if (sc->mly_sg_table) {
  714         bus_dmamap_unload(sc->mly_sg_dmat, sc->mly_sg_dmamap);
  715         bus_dmamem_free(sc->mly_sg_dmat, sc->mly_sg_table, sc->mly_sg_dmamap);
  716     }
  717     if (sc->mly_sg_dmat)
  718         bus_dma_tag_destroy(sc->mly_sg_dmat);
  719 
  720     /* free and destroy DMA memory and tag for memory mailbox */
  721     if (sc->mly_mmbox) {
  722         bus_dmamap_unload(sc->mly_mmbox_dmat, sc->mly_mmbox_dmamap);
  723         bus_dmamem_free(sc->mly_mmbox_dmat, sc->mly_mmbox, sc->mly_mmbox_dmamap);
  724     }
  725     if (sc->mly_mmbox_dmat)
  726         bus_dma_tag_destroy(sc->mly_mmbox_dmat);
  727 
  728     /* disconnect the interrupt handler */
  729     if (sc->mly_intr)
  730         bus_teardown_intr(sc->mly_dev, sc->mly_irq, sc->mly_intr);
  731     if (sc->mly_irq != NULL)
  732         bus_release_resource(sc->mly_dev, SYS_RES_IRQ, sc->mly_irq_rid, sc->mly_irq);
  733 
  734     /* destroy the parent DMA tag */
  735     if (sc->mly_parent_dmat)
  736         bus_dma_tag_destroy(sc->mly_parent_dmat);
  737 
  738     /* release the register window mapping */
  739     if (sc->mly_regs_resource != NULL)
  740         bus_release_resource(sc->mly_dev, SYS_RES_MEMORY, sc->mly_regs_rid, sc->mly_regs_resource);
  741 }
  742 
  743 /********************************************************************************
  744  ********************************************************************************
  745                                                                  Command Wrappers
  746  ********************************************************************************
  747  ********************************************************************************/
  748 
  749 /********************************************************************************
  750  * Fill in the mly_controllerinfo and mly_controllerparam fields in the softc.
  751  */
  752 static int
  753 mly_get_controllerinfo(struct mly_softc *sc)
  754 {
  755     struct mly_command_ioctl    mci;
  756     u_int8_t                    status;
  757     int                         error;
  758 
  759     debug_called(1);
  760 
  761     if (sc->mly_controllerinfo != NULL)
  762         free(sc->mly_controllerinfo, M_DEVBUF);
  763 
  764     /* build the getcontrollerinfo ioctl and send it */
  765     bzero(&mci, sizeof(mci));
  766     sc->mly_controllerinfo = NULL;
  767     mci.sub_ioctl = MDACIOCTL_GETCONTROLLERINFO;
  768     if ((error = mly_ioctl(sc, &mci, (void **)&sc->mly_controllerinfo, sizeof(*sc->mly_controllerinfo),
  769                            &status, NULL, NULL)))
  770         return(error);
  771     if (status != 0)
  772         return(EIO);
  773 
  774     if (sc->mly_controllerparam != NULL)
  775         free(sc->mly_controllerparam, M_DEVBUF);
  776 
  777     /* build the getcontrollerparameter ioctl and send it */
  778     bzero(&mci, sizeof(mci));
  779     sc->mly_controllerparam = NULL;
  780     mci.sub_ioctl = MDACIOCTL_GETCONTROLLERPARAMETER;
  781     if ((error = mly_ioctl(sc, &mci, (void **)&sc->mly_controllerparam, sizeof(*sc->mly_controllerparam),
  782                            &status, NULL, NULL)))
  783         return(error);
  784     if (status != 0)
  785         return(EIO);
  786 
  787     return(0);
  788 }
  789 
  790 /********************************************************************************
  791  * Schedule all possible devices for a rescan.
  792  *
  793  */
  794 static void
  795 mly_scan_devices(struct mly_softc *sc)
  796 {
  797     int         bus, target;
  798 
  799     debug_called(1);
  800 
  801     /*
  802      * Clear any previous BTL information.
  803      */
  804     bzero(&sc->mly_btl, sizeof(sc->mly_btl));
  805 
  806     /*
  807      * Mark all devices as requiring a rescan, and let the next
  808      * periodic scan collect them. 
  809      */
  810     for (bus = 0; bus < sc->mly_cam_channels; bus++)
  811         if (MLY_BUS_IS_VALID(sc, bus)) 
  812             for (target = 0; target < MLY_MAX_TARGETS; target++)
  813                 sc->mly_btl[bus][target].mb_flags = MLY_BTL_RESCAN;
  814 
  815 }
  816 
  817 /********************************************************************************
  818  * Rescan a device, possibly as a consequence of getting an event which suggests
  819  * that it may have changed.
  820  *
  821  * If we suffer resource starvation, we can abandon the rescan as we'll be
  822  * retried.
  823  */
  824 static void
  825 mly_rescan_btl(struct mly_softc *sc, int bus, int target)
  826 {
  827     struct mly_command          *mc;
  828     struct mly_command_ioctl    *mci;
  829 
  830     debug_called(1);
  831 
  832     /* check that this bus is valid */
  833     if (!MLY_BUS_IS_VALID(sc, bus))
  834         return;
  835 
  836     /* get a command */
  837     if (mly_alloc_command(sc, &mc))
  838         return;
  839 
  840     /* set up the data buffer */
  841     if ((mc->mc_data = malloc(sizeof(union mly_devinfo), M_DEVBUF, M_NOWAIT | M_ZERO)) == NULL) {
  842         mly_release_command(mc);
  843         return;
  844     }
  845     mc->mc_flags |= MLY_CMD_DATAIN;
  846     mc->mc_complete = mly_complete_rescan;
  847 
  848     /* 
  849      * Build the ioctl.
  850      */
  851     mci = (struct mly_command_ioctl *)&mc->mc_packet->ioctl;
  852     mci->opcode = MDACMD_IOCTL;
  853     mci->addr.phys.controller = 0;
  854     mci->timeout.value = 30;
  855     mci->timeout.scale = MLY_TIMEOUT_SECONDS;
  856     if (MLY_BUS_IS_VIRTUAL(sc, bus)) {
  857         mc->mc_length = mci->data_size = sizeof(struct mly_ioctl_getlogdevinfovalid);
  858         mci->sub_ioctl = MDACIOCTL_GETLOGDEVINFOVALID;
  859         mci->addr.log.logdev = MLY_LOGDEV_ID(sc, bus, target);
  860         debug(1, "logical device %d", mci->addr.log.logdev);
  861     } else {
  862         mc->mc_length = mci->data_size = sizeof(struct mly_ioctl_getphysdevinfovalid);
  863         mci->sub_ioctl = MDACIOCTL_GETPHYSDEVINFOVALID;
  864         mci->addr.phys.lun = 0;
  865         mci->addr.phys.target = target;
  866         mci->addr.phys.channel = bus;
  867         debug(1, "physical device %d:%d", mci->addr.phys.channel, mci->addr.phys.target);
  868     }
  869     
  870     /*
  871      * Dispatch the command.  If we successfully send the command, clear the rescan
  872      * bit.
  873      */
  874     if (mly_start(mc) != 0) {
  875         mly_release_command(mc);
  876     } else {
  877         sc->mly_btl[bus][target].mb_flags &= ~MLY_BTL_RESCAN;   /* success */   
  878     }
  879 }
  880 
  881 /********************************************************************************
  882  * Handle the completion of a rescan operation
  883  */
  884 static void
  885 mly_complete_rescan(struct mly_command *mc)
  886 {
  887     struct mly_softc                            *sc = mc->mc_sc;
  888     struct mly_ioctl_getlogdevinfovalid         *ldi;
  889     struct mly_ioctl_getphysdevinfovalid        *pdi;
  890     struct mly_command_ioctl                    *mci;
  891     struct mly_btl                              btl, *btlp;
  892     int                                         bus, target, rescan;
  893 
  894     debug_called(1);
  895 
  896     /*
  897      * Recover the bus and target from the command.  We need these even in
  898      * the case where we don't have a useful response.
  899      */
  900     mci = (struct mly_command_ioctl *)&mc->mc_packet->ioctl;
  901     if (mci->sub_ioctl == MDACIOCTL_GETLOGDEVINFOVALID) {
  902         bus = MLY_LOGDEV_BUS(sc, mci->addr.log.logdev);
  903         target = MLY_LOGDEV_TARGET(sc, mci->addr.log.logdev);
  904     } else {
  905         bus = mci->addr.phys.channel;
  906         target = mci->addr.phys.target;
  907     }
  908     /* XXX validate bus/target? */
  909     
  910     /* the default result is 'no device' */
  911     bzero(&btl, sizeof(btl));
  912 
  913     /* if the rescan completed OK, we have possibly-new BTL data */
  914     if (mc->mc_status == 0) {
  915         if (mc->mc_length == sizeof(*ldi)) {
  916             ldi = (struct mly_ioctl_getlogdevinfovalid *)mc->mc_data;
  917             if ((MLY_LOGDEV_BUS(sc, ldi->logical_device_number) != bus) ||
  918                 (MLY_LOGDEV_TARGET(sc, ldi->logical_device_number) != target)) {
  919                 mly_printf(sc, "WARNING: BTL rescan for %d:%d returned data for %d:%d instead\n",
  920                            bus, target, MLY_LOGDEV_BUS(sc, ldi->logical_device_number),
  921                            MLY_LOGDEV_TARGET(sc, ldi->logical_device_number));
  922                 /* XXX what can we do about this? */
  923             }
  924             btl.mb_flags = MLY_BTL_LOGICAL;
  925             btl.mb_type = ldi->raid_level;
  926             btl.mb_state = ldi->state;
  927             debug(1, "BTL rescan for %d returns %s, %s", ldi->logical_device_number, 
  928                   mly_describe_code(mly_table_device_type, ldi->raid_level),
  929                   mly_describe_code(mly_table_device_state, ldi->state));
  930         } else if (mc->mc_length == sizeof(*pdi)) {
  931             pdi = (struct mly_ioctl_getphysdevinfovalid *)mc->mc_data;
  932             if ((pdi->channel != bus) || (pdi->target != target)) {
  933                 mly_printf(sc, "WARNING: BTL rescan for %d:%d returned data for %d:%d instead\n",
  934                            bus, target, pdi->channel, pdi->target);
  935                 /* XXX what can we do about this? */
  936             }
  937             btl.mb_flags = MLY_BTL_PHYSICAL;
  938             btl.mb_type = MLY_DEVICE_TYPE_PHYSICAL;
  939             btl.mb_state = pdi->state;
  940             btl.mb_speed = pdi->speed;
  941             btl.mb_width = pdi->width;
  942             if (pdi->state != MLY_DEVICE_STATE_UNCONFIGURED)
  943                 sc->mly_btl[bus][target].mb_flags |= MLY_BTL_PROTECTED;
  944             debug(1, "BTL rescan for %d:%d returns %s", bus, target, 
  945                   mly_describe_code(mly_table_device_state, pdi->state));
  946         } else {
  947             mly_printf(sc, "BTL rescan result invalid\n");
  948         }
  949     }
  950 
  951     free(mc->mc_data, M_DEVBUF);
  952     mly_release_command(mc);
  953 
  954     /*
  955      * Decide whether we need to rescan the device.
  956      */
  957     rescan = 0;
  958 
  959     /* device type changes (usually between 'nothing' and 'something') */
  960     btlp = &sc->mly_btl[bus][target];
  961     if (btl.mb_flags != btlp->mb_flags) {
  962         debug(1, "flags changed, rescanning");
  963         rescan = 1;
  964     }
  965     
  966     /* XXX other reasons? */
  967 
  968     /*
  969      * Update BTL information.
  970      */
  971     *btlp = btl;
  972 
  973     /*
  974      * Perform CAM rescan if required.
  975      */
  976     if (rescan)
  977         mly_cam_rescan_btl(sc, bus, target);
  978 }
  979 
  980 /********************************************************************************
  981  * Get the current health status and set the 'next event' counter to suit.
  982  */
  983 static int
  984 mly_get_eventstatus(struct mly_softc *sc)
  985 {
  986     struct mly_command_ioctl    mci;
  987     struct mly_health_status    *mh;
  988     u_int8_t                    status;
  989     int                         error;
  990 
  991     /* build the gethealthstatus ioctl and send it */
  992     bzero(&mci, sizeof(mci));
  993     mh = NULL;
  994     mci.sub_ioctl = MDACIOCTL_GETHEALTHSTATUS;
  995 
  996     if ((error = mly_ioctl(sc, &mci, (void **)&mh, sizeof(*mh), &status, NULL, NULL)))
  997         return(error);
  998     if (status != 0)
  999         return(EIO);
 1000 
 1001     /* get the event counter */
 1002     sc->mly_event_change = mh->change_counter;
 1003     sc->mly_event_waiting = mh->next_event;
 1004     sc->mly_event_counter = mh->next_event;
 1005 
 1006     /* save the health status into the memory mailbox */
 1007     bcopy(mh, &sc->mly_mmbox->mmm_health.status, sizeof(*mh));
 1008 
 1009     debug(1, "initial change counter %d, event counter %d", mh->change_counter, mh->next_event);
 1010     
 1011     free(mh, M_DEVBUF);
 1012     return(0);
 1013 }
 1014 
 1015 /********************************************************************************
 1016  * Enable the memory mailbox mode.
 1017  */
 1018 static int
 1019 mly_enable_mmbox(struct mly_softc *sc)
 1020 {
 1021     struct mly_command_ioctl    mci;
 1022     u_int8_t                    *sp, status;
 1023     int                         error;
 1024 
 1025     debug_called(1);
 1026 
 1027     /* build the ioctl and send it */
 1028     bzero(&mci, sizeof(mci));
 1029     mci.sub_ioctl = MDACIOCTL_SETMEMORYMAILBOX;
 1030     /* set buffer addresses */
 1031     mci.param.setmemorymailbox.command_mailbox_physaddr = 
 1032         sc->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_command);
 1033     mci.param.setmemorymailbox.status_mailbox_physaddr = 
 1034         sc->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_status);
 1035     mci.param.setmemorymailbox.health_buffer_physaddr = 
 1036         sc->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_health);
 1037 
 1038     /* set buffer sizes - abuse of data_size field is revolting */
 1039     sp = (u_int8_t *)&mci.data_size;
 1040     sp[0] = ((sizeof(union mly_command_packet) * MLY_MMBOX_COMMANDS) / 1024);
 1041     sp[1] = (sizeof(union mly_status_packet) * MLY_MMBOX_STATUS) / 1024;
 1042     mci.param.setmemorymailbox.health_buffer_size = sizeof(union mly_health_region) / 1024;
 1043 
 1044     debug(1, "memory mailbox at %p (0x%llx/%d 0x%llx/%d 0x%llx/%d", sc->mly_mmbox,
 1045           mci.param.setmemorymailbox.command_mailbox_physaddr, sp[0],
 1046           mci.param.setmemorymailbox.status_mailbox_physaddr, sp[1],
 1047           mci.param.setmemorymailbox.health_buffer_physaddr, 
 1048           mci.param.setmemorymailbox.health_buffer_size);
 1049 
 1050     if ((error = mly_ioctl(sc, &mci, NULL, 0, &status, NULL, NULL)))
 1051         return(error);
 1052     if (status != 0)
 1053         return(EIO);
 1054     sc->mly_state |= MLY_STATE_MMBOX_ACTIVE;
 1055     debug(1, "memory mailbox active");
 1056     return(0);
 1057 }
 1058 
 1059 /********************************************************************************
 1060  * Flush all pending I/O from the controller.
 1061  */
 1062 static int
 1063 mly_flush(struct mly_softc *sc)
 1064 {
 1065     struct mly_command_ioctl    mci;
 1066     u_int8_t                    status;
 1067     int                         error;
 1068 
 1069     debug_called(1);
 1070 
 1071     /* build the ioctl */
 1072     bzero(&mci, sizeof(mci));
 1073     mci.sub_ioctl = MDACIOCTL_FLUSHDEVICEDATA;
 1074     mci.param.deviceoperation.operation_device = MLY_OPDEVICE_PHYSICAL_CONTROLLER;
 1075 
 1076     /* pass it off to the controller */
 1077     if ((error = mly_ioctl(sc, &mci, NULL, 0, &status, NULL, NULL)))
 1078         return(error);
 1079 
 1080     return((status == 0) ? 0 : EIO);
 1081 }
 1082 
 1083 /********************************************************************************
 1084  * Perform an ioctl command.
 1085  *
 1086  * If (data) is not NULL, the command requires data transfer.  If (*data) is NULL
 1087  * the command requires data transfer from the controller, and we will allocate
 1088  * a buffer for it.  If (*data) is not NULL, the command requires data transfer
 1089  * to the controller.
 1090  *
 1091  * XXX passing in the whole ioctl structure is ugly.  Better ideas?
 1092  *
 1093  * XXX we don't even try to handle the case where datasize > 4k.  We should.
 1094  */
 1095 static int
 1096 mly_ioctl(struct mly_softc *sc, struct mly_command_ioctl *ioctl, void **data, size_t datasize, 
 1097           u_int8_t *status, void *sense_buffer, size_t *sense_length)
 1098 {
 1099     struct mly_command          *mc;
 1100     struct mly_command_ioctl    *mci;
 1101     int                         error;
 1102 
 1103     debug_called(1);
 1104 
 1105     mc = NULL;
 1106     if (mly_alloc_command(sc, &mc)) {
 1107         error = ENOMEM;
 1108         goto out;
 1109     }
 1110 
 1111     /* copy the ioctl structure, but save some important fields and then fixup */
 1112     mci = &mc->mc_packet->ioctl;
 1113     ioctl->sense_buffer_address = mci->sense_buffer_address;
 1114     ioctl->maximum_sense_size = mci->maximum_sense_size;
 1115     *mci = *ioctl;
 1116     mci->opcode = MDACMD_IOCTL;
 1117     mci->timeout.value = 30;
 1118     mci->timeout.scale = MLY_TIMEOUT_SECONDS;
 1119     
 1120     /* handle the data buffer */
 1121     if (data != NULL) {
 1122         if (*data == NULL) {
 1123             /* allocate data buffer */
 1124             if ((mc->mc_data = malloc(datasize, M_DEVBUF, M_NOWAIT)) == NULL) {
 1125                 error = ENOMEM;
 1126                 goto out;
 1127             }
 1128             mc->mc_flags |= MLY_CMD_DATAIN;
 1129         } else {
 1130             mc->mc_data = *data;
 1131             mc->mc_flags |= MLY_CMD_DATAOUT;
 1132         }
 1133         mc->mc_length = datasize;
 1134         mc->mc_packet->generic.data_size = datasize;
 1135     }
 1136     
 1137     /* run the command */
 1138     if ((error = mly_immediate_command(mc)))
 1139         goto out;
 1140     
 1141     /* clean up and return any data */
 1142     *status = mc->mc_status;
 1143     if ((mc->mc_sense > 0) && (sense_buffer != NULL)) {
 1144         bcopy(mc->mc_packet, sense_buffer, mc->mc_sense);
 1145         *sense_length = mc->mc_sense;
 1146         goto out;
 1147     }
 1148 
 1149     /* should we return a data pointer? */
 1150     if ((data != NULL) && (*data == NULL))
 1151         *data = mc->mc_data;
 1152 
 1153     /* command completed OK */
 1154     error = 0;
 1155 
 1156 out:
 1157     if (mc != NULL) {
 1158         /* do we need to free a data buffer we allocated? */
 1159         if (error && (mc->mc_data != NULL) && (*data == NULL))
 1160             free(mc->mc_data, M_DEVBUF);
 1161         mly_release_command(mc);
 1162     }
 1163     return(error);
 1164 }
 1165 
 1166 /********************************************************************************
 1167  * Check for event(s) outstanding in the controller.
 1168  */
 1169 static void
 1170 mly_check_event(struct mly_softc *sc)
 1171 {
 1172     
 1173     /*
 1174      * The controller may have updated the health status information,
 1175      * so check for it here.  Note that the counters are all in host memory,
 1176      * so this check is very cheap.  Also note that we depend on checking on
 1177      * completion 
 1178      */
 1179     if (sc->mly_mmbox->mmm_health.status.change_counter != sc->mly_event_change) {
 1180         sc->mly_event_change = sc->mly_mmbox->mmm_health.status.change_counter;
 1181         debug(1, "event change %d, event status update, %d -> %d", sc->mly_event_change,
 1182               sc->mly_event_waiting, sc->mly_mmbox->mmm_health.status.next_event);
 1183         sc->mly_event_waiting = sc->mly_mmbox->mmm_health.status.next_event;
 1184 
 1185         /* wake up anyone that might be interested in this */
 1186         wakeup(&sc->mly_event_change);
 1187     }
 1188     if (sc->mly_event_counter != sc->mly_event_waiting)
 1189     mly_fetch_event(sc);
 1190 }
 1191 
 1192 /********************************************************************************
 1193  * Fetch one event from the controller.
 1194  *
 1195  * If we fail due to resource starvation, we'll be retried the next time a 
 1196  * command completes.
 1197  */
 1198 static void
 1199 mly_fetch_event(struct mly_softc *sc)
 1200 {
 1201     struct mly_command          *mc;
 1202     struct mly_command_ioctl    *mci;
 1203     int                         s;
 1204     u_int32_t                   event;
 1205 
 1206     debug_called(1);
 1207 
 1208     /* get a command */
 1209     if (mly_alloc_command(sc, &mc))
 1210         return;
 1211 
 1212     /* set up the data buffer */
 1213     if ((mc->mc_data = malloc(sizeof(struct mly_event), M_DEVBUF, M_NOWAIT | M_ZERO)) == NULL) {
 1214         mly_release_command(mc);
 1215         return;
 1216     }
 1217     mc->mc_length = sizeof(struct mly_event);
 1218     mc->mc_flags |= MLY_CMD_DATAIN;
 1219     mc->mc_complete = mly_complete_event;
 1220 
 1221     /*
 1222      * Get an event number to fetch.  It's possible that we've raced with another
 1223      * context for the last event, in which case there will be no more events.
 1224      */
 1225     s = splcam();
 1226     if (sc->mly_event_counter == sc->mly_event_waiting) {
 1227         mly_release_command(mc);
 1228         splx(s);
 1229         return;
 1230     }
 1231     event = sc->mly_event_counter++;
 1232     splx(s);
 1233 
 1234     /* 
 1235      * Build the ioctl.
 1236      *
 1237      * At this point we are committed to sending this request, as it
 1238      * will be the only one constructed for this particular event number.
 1239      */
 1240     mci = (struct mly_command_ioctl *)&mc->mc_packet->ioctl;
 1241     mci->opcode = MDACMD_IOCTL;
 1242     mci->data_size = sizeof(struct mly_event);
 1243     mci->addr.phys.lun = (event >> 16) & 0xff;
 1244     mci->addr.phys.target = (event >> 24) & 0xff;
 1245     mci->addr.phys.channel = 0;
 1246     mci->addr.phys.controller = 0;
 1247     mci->timeout.value = 30;
 1248     mci->timeout.scale = MLY_TIMEOUT_SECONDS;
 1249     mci->sub_ioctl = MDACIOCTL_GETEVENT;
 1250     mci->param.getevent.sequence_number_low = event & 0xffff;
 1251 
 1252     debug(1, "fetch event %u", event);
 1253 
 1254     /*
 1255      * Submit the command.
 1256      *
 1257      * Note that failure of mly_start() will result in this event never being
 1258      * fetched.
 1259      */
 1260     if (mly_start(mc) != 0) {
 1261         mly_printf(sc, "couldn't fetch event %u\n", event);
 1262         mly_release_command(mc);
 1263     }
 1264 }
 1265 
 1266 /********************************************************************************
 1267  * Handle the completion of an event poll.
 1268  */
 1269 static void
 1270 mly_complete_event(struct mly_command *mc)
 1271 {
 1272     struct mly_softc    *sc = mc->mc_sc;
 1273     struct mly_event    *me = (struct mly_event *)mc->mc_data;
 1274 
 1275     debug_called(1);
 1276 
 1277     /* 
 1278      * If the event was successfully fetched, process it.
 1279      */
 1280     if (mc->mc_status == SCSI_STATUS_OK) {
 1281         mly_process_event(sc, me);
 1282         free(me, M_DEVBUF);
 1283     }
 1284     mly_release_command(mc);
 1285 
 1286     /*
 1287      * Check for another event.
 1288      */
 1289     mly_check_event(sc);
 1290 }
 1291 
 1292 /********************************************************************************
 1293  * Process a controller event.
 1294  */
 1295 static void
 1296 mly_process_event(struct mly_softc *sc, struct mly_event *me)
 1297 {
 1298     struct scsi_sense_data      *ssd = (struct scsi_sense_data *)&me->sense[0];
 1299     char                        *fp, *tp;
 1300     int                         bus, target, event, class, action;
 1301 
 1302     /* 
 1303      * Errors can be reported using vendor-unique sense data.  In this case, the
 1304      * event code will be 0x1c (Request sense data present), the sense key will
 1305      * be 0x09 (vendor specific), the MSB of the ASC will be set, and the 
 1306      * actual event code will be a 16-bit value comprised of the ASCQ (low byte)
 1307      * and low seven bits of the ASC (low seven bits of the high byte).
 1308      */
 1309     if ((me->code == 0x1c) && 
 1310         ((ssd->flags & SSD_KEY) == SSD_KEY_Vendor_Specific) &&
 1311         (ssd->add_sense_code & 0x80)) {
 1312         event = ((int)(ssd->add_sense_code & ~0x80) << 8) + ssd->add_sense_code_qual;
 1313     } else {
 1314         event = me->code;
 1315     }
 1316 
 1317     /* look up event, get codes */
 1318     fp = mly_describe_code(mly_table_event, event);
 1319 
 1320     debug(1, "Event %d  code 0x%x", me->sequence_number, me->code);
 1321 
 1322     /* quiet event? */
 1323     class = fp[0];
 1324     if (isupper(class) && bootverbose)
 1325         class = tolower(class);
 1326 
 1327     /* get action code, text string */
 1328     action = fp[1];
 1329     tp = &fp[2];
 1330 
 1331     /*
 1332      * Print some information about the event.
 1333      *
 1334      * This code uses a table derived from the corresponding portion of the Linux
 1335      * driver, and thus the parser is very similar.
 1336      */
 1337     switch(class) {
 1338     case 'p':           /* error on physical device */
 1339         mly_printf(sc, "physical device %d:%d %s\n", me->channel, me->target, tp);
 1340         if (action == 'r')
 1341             sc->mly_btl[me->channel][me->target].mb_flags |= MLY_BTL_RESCAN;
 1342         break;
 1343     case 'l':           /* error on logical unit */
 1344     case 'm':           /* message about logical unit */
 1345         bus = MLY_LOGDEV_BUS(sc, me->lun);
 1346         target = MLY_LOGDEV_TARGET(sc, me->lun);
 1347         mly_name_device(sc, bus, target);
 1348         mly_printf(sc, "logical device %d (%s) %s\n", me->lun, sc->mly_btl[bus][target].mb_name, tp);
 1349         if (action == 'r')
 1350             sc->mly_btl[bus][target].mb_flags |= MLY_BTL_RESCAN;
 1351         break;
 1352       break;
 1353     case 's':           /* report of sense data */
 1354         if (((ssd->flags & SSD_KEY) == SSD_KEY_NO_SENSE) ||
 1355             (((ssd->flags & SSD_KEY) == SSD_KEY_NOT_READY) && 
 1356              (ssd->add_sense_code == 0x04) && 
 1357              ((ssd->add_sense_code_qual == 0x01) || (ssd->add_sense_code_qual == 0x02))))
 1358             break;      /* ignore NO_SENSE or NOT_READY in one case */
 1359 
 1360         mly_printf(sc, "physical device %d:%d %s\n", me->channel, me->target, tp);
 1361         mly_printf(sc, "  sense key %d  asc %02x  ascq %02x\n", 
 1362                       ssd->flags & SSD_KEY, ssd->add_sense_code, ssd->add_sense_code_qual);
 1363         mly_printf(sc, "  info %4D  csi %4D\n", ssd->info, "", ssd->cmd_spec_info, "");
 1364         if (action == 'r')
 1365             sc->mly_btl[me->channel][me->target].mb_flags |= MLY_BTL_RESCAN;
 1366         break;
 1367     case 'e':
 1368         mly_printf(sc, tp, me->target, me->lun);
 1369         printf("\n");
 1370         break;
 1371     case 'c':
 1372         mly_printf(sc, "controller %s\n", tp);
 1373         break;
 1374     case '?':
 1375         mly_printf(sc, "%s - %d\n", tp, me->code);
 1376         break;
 1377     default:    /* probably a 'noisy' event being ignored */
 1378         break;
 1379     }
 1380 }
 1381 
 1382 /********************************************************************************
 1383  * Perform periodic activities.
 1384  */
 1385 static void
 1386 mly_periodic(void *data)
 1387 {
 1388     struct mly_softc    *sc = (struct mly_softc *)data;
 1389     int                 bus, target;
 1390 
 1391     debug_called(2);
 1392 
 1393     /*
 1394      * Scan devices.
 1395      */
 1396     for (bus = 0; bus < sc->mly_cam_channels; bus++) {
 1397         if (MLY_BUS_IS_VALID(sc, bus)) {
 1398             for (target = 0; target < MLY_MAX_TARGETS; target++) {
 1399 
 1400                 /* ignore the controller in this scan */
 1401                 if (target == sc->mly_controllerparam->initiator_id)
 1402                     continue;
 1403 
 1404                 /* perform device rescan? */
 1405                 if (sc->mly_btl[bus][target].mb_flags & MLY_BTL_RESCAN)
 1406                     mly_rescan_btl(sc, bus, target);
 1407             }
 1408         }
 1409     }
 1410     
 1411     /* check for controller events */
 1412     mly_check_event(sc);
 1413 
 1414     /* reschedule ourselves */
 1415     sc->mly_periodic = timeout(mly_periodic, sc, MLY_PERIODIC_INTERVAL * hz);
 1416 }
 1417 
 1418 /********************************************************************************
 1419  ********************************************************************************
 1420                                                                Command Processing
 1421  ********************************************************************************
 1422  ********************************************************************************/
 1423 
 1424 /********************************************************************************
 1425  * Run a command and wait for it to complete.
 1426  *
 1427  */
 1428 static int
 1429 mly_immediate_command(struct mly_command *mc)
 1430 {
 1431     struct mly_softc    *sc = mc->mc_sc;
 1432     int                 error, s;
 1433 
 1434     debug_called(1);
 1435 
 1436     /* spinning at splcam is ugly, but we're only used during controller init */
 1437     s = splcam();
 1438     if ((error = mly_start(mc))) {
 1439         splx(s);
 1440         return(error);
 1441     }
 1442 
 1443     if (sc->mly_state & MLY_STATE_INTERRUPTS_ON) {
 1444         /* sleep on the command */
 1445         while(!(mc->mc_flags & MLY_CMD_COMPLETE)) {
 1446             tsleep(mc, PRIBIO, "mlywait", 0);
 1447         }
 1448     } else {
 1449         /* spin and collect status while we do */
 1450         while(!(mc->mc_flags & MLY_CMD_COMPLETE)) {
 1451             mly_done(mc->mc_sc);
 1452         }
 1453     }
 1454     splx(s);
 1455     return(0);
 1456 }
 1457 
 1458 /********************************************************************************
 1459  * Deliver a command to the controller.
 1460  *
 1461  * XXX it would be good to just queue commands that we can't submit immediately
 1462  *     and send them later, but we probably want a wrapper for that so that
 1463  *     we don't hang on a failed submission for an immediate command.
 1464  */
 1465 static int
 1466 mly_start(struct mly_command *mc)
 1467 {
 1468     struct mly_softc            *sc = mc->mc_sc;
 1469     union mly_command_packet    *pkt;
 1470     int                         s;
 1471 
 1472     debug_called(2);
 1473 
 1474     /* 
 1475      * Set the command up for delivery to the controller. 
 1476      */
 1477     mly_map_command(mc);
 1478     mc->mc_packet->generic.command_id = mc->mc_slot;
 1479 
 1480 #ifdef MLY_DEBUG
 1481     mc->mc_timestamp = time_second;
 1482 #endif
 1483 
 1484     s = splcam();
 1485 
 1486     /*
 1487      * Do we have to use the hardware mailbox?
 1488      */
 1489     if (!(sc->mly_state & MLY_STATE_MMBOX_ACTIVE)) {
 1490         /*
 1491          * Check to see if the controller is ready for us.
 1492          */
 1493         if (MLY_IDBR_TRUE(sc, MLY_HM_CMDSENT)) {
 1494             splx(s);
 1495             return(EBUSY);
 1496         }
 1497         mc->mc_flags |= MLY_CMD_BUSY;
 1498         
 1499         /*
 1500          * It's ready, send the command.
 1501          */
 1502         MLY_SET_MBOX(sc, sc->mly_command_mailbox, &mc->mc_packetphys);
 1503         MLY_SET_REG(sc, sc->mly_idbr, MLY_HM_CMDSENT);
 1504 
 1505     } else {    /* use memory-mailbox mode */
 1506 
 1507         pkt = &sc->mly_mmbox->mmm_command[sc->mly_mmbox_command_index];
 1508 
 1509         /* check to see if the next index is free yet */
 1510         if (pkt->mmbox.flag != 0) {
 1511             splx(s);
 1512             return(EBUSY);
 1513         }
 1514         mc->mc_flags |= MLY_CMD_BUSY;
 1515         
 1516         /* copy in new command */
 1517         bcopy(mc->mc_packet->mmbox.data, pkt->mmbox.data, sizeof(pkt->mmbox.data));
 1518         /* barrier to ensure completion of previous write before we write the flag */
 1519         bus_space_barrier(sc->mly_btag, sc->mly_bhandle, 0, 0,
 1520             BUS_SPACE_BARRIER_WRITE);
 1521         /* copy flag last */
 1522         pkt->mmbox.flag = mc->mc_packet->mmbox.flag;
 1523         /* barrier to ensure completion of previous write before we notify the controller */
 1524         bus_space_barrier(sc->mly_btag, sc->mly_bhandle, 0, 0,
 1525             BUS_SPACE_BARRIER_WRITE);
 1526 
 1527         /* signal controller, update index */
 1528         MLY_SET_REG(sc, sc->mly_idbr, MLY_AM_CMDSENT);
 1529         sc->mly_mmbox_command_index = (sc->mly_mmbox_command_index + 1) % MLY_MMBOX_COMMANDS;
 1530     }
 1531 
 1532     mly_enqueue_busy(mc);
 1533     splx(s);
 1534     return(0);
 1535 }
 1536 
 1537 /********************************************************************************
 1538  * Pick up command status from the controller, schedule a completion event
 1539  */
 1540 static void
 1541 mly_done(struct mly_softc *sc) 
 1542 {
 1543     struct mly_command          *mc;
 1544     union mly_status_packet     *sp;
 1545     u_int16_t                   slot;
 1546     int                         s, worked;
 1547 
 1548     s = splcam();
 1549     worked = 0;
 1550 
 1551     /* pick up hardware-mailbox commands */
 1552     if (MLY_ODBR_TRUE(sc, MLY_HM_STSREADY)) {
 1553         slot = MLY_GET_REG2(sc, sc->mly_status_mailbox);
 1554         if (slot < MLY_SLOT_MAX) {
 1555             mc = &sc->mly_command[slot - MLY_SLOT_START];
 1556             mc->mc_status = MLY_GET_REG(sc, sc->mly_status_mailbox + 2);
 1557             mc->mc_sense = MLY_GET_REG(sc, sc->mly_status_mailbox + 3);
 1558             mc->mc_resid = MLY_GET_REG4(sc, sc->mly_status_mailbox + 4);
 1559             mly_remove_busy(mc);
 1560             mc->mc_flags &= ~MLY_CMD_BUSY;
 1561             mly_enqueue_complete(mc);
 1562             worked = 1;
 1563         } else {
 1564             /* slot 0xffff may mean "extremely bogus command" */
 1565             mly_printf(sc, "got HM completion for illegal slot %u\n", slot);
 1566         }
 1567         /* unconditionally acknowledge status */
 1568         MLY_SET_REG(sc, sc->mly_odbr, MLY_HM_STSREADY);
 1569         MLY_SET_REG(sc, sc->mly_idbr, MLY_HM_STSACK);
 1570     }
 1571 
 1572     /* pick up memory-mailbox commands */
 1573     if (MLY_ODBR_TRUE(sc, MLY_AM_STSREADY)) {
 1574         for (;;) {
 1575             sp = &sc->mly_mmbox->mmm_status[sc->mly_mmbox_status_index];
 1576 
 1577             /* check for more status */
 1578             if (sp->mmbox.flag == 0)
 1579                 break;
 1580 
 1581             /* get slot number */
 1582             slot = sp->status.command_id;
 1583             if (slot < MLY_SLOT_MAX) {
 1584                 mc = &sc->mly_command[slot - MLY_SLOT_START];
 1585                 mc->mc_status = sp->status.status;
 1586                 mc->mc_sense = sp->status.sense_length;
 1587                 mc->mc_resid = sp->status.residue;
 1588                 mly_remove_busy(mc);
 1589                 mc->mc_flags &= ~MLY_CMD_BUSY;
 1590                 mly_enqueue_complete(mc);
 1591                 worked = 1;
 1592             } else {
 1593                 /* slot 0xffff may mean "extremely bogus command" */
 1594                 mly_printf(sc, "got AM completion for illegal slot %u at %d\n", 
 1595                            slot, sc->mly_mmbox_status_index);
 1596             }
 1597 
 1598             /* clear and move to next index */
 1599             sp->mmbox.flag = 0;
 1600             sc->mly_mmbox_status_index = (sc->mly_mmbox_status_index + 1) % MLY_MMBOX_STATUS;
 1601         }
 1602         /* acknowledge that we have collected status value(s) */
 1603         MLY_SET_REG(sc, sc->mly_odbr, MLY_AM_STSREADY);
 1604     }
 1605 
 1606     splx(s);
 1607     if (worked) {
 1608         if (sc->mly_state & MLY_STATE_INTERRUPTS_ON)
 1609             taskqueue_enqueue(taskqueue_swi_giant, &sc->mly_task_complete);
 1610         else
 1611             mly_complete(sc, 0);
 1612     }
 1613 }
 1614 
 1615 /********************************************************************************
 1616  * Process completed commands
 1617  */
 1618 static void
 1619 mly_complete(void *context, int pending)
 1620 {
 1621     struct mly_softc    *sc = (struct mly_softc *)context;
 1622     struct mly_command  *mc;
 1623     void                (* mc_complete)(struct mly_command *mc);
 1624 
 1625 
 1626     debug_called(2);
 1627 
 1628     /* 
 1629      * Spin pulling commands off the completed queue and processing them.
 1630      */
 1631     while ((mc = mly_dequeue_complete(sc)) != NULL) {
 1632 
 1633         /*
 1634          * Free controller resources, mark command complete.
 1635          *
 1636          * Note that as soon as we mark the command complete, it may be freed
 1637          * out from under us, so we need to save the mc_complete field in
 1638          * order to later avoid dereferencing mc.  (We would not expect to
 1639          * have a polling/sleeping consumer with mc_complete != NULL).
 1640          */
 1641         mly_unmap_command(mc);
 1642         mc_complete = mc->mc_complete;
 1643         mc->mc_flags |= MLY_CMD_COMPLETE;
 1644 
 1645         /* 
 1646          * Call completion handler or wake up sleeping consumer.
 1647          */
 1648         if (mc_complete != NULL) {
 1649             mc_complete(mc);
 1650         } else {
 1651             wakeup(mc);
 1652         }
 1653     }
 1654     
 1655     /*
 1656      * XXX if we are deferring commands due to controller-busy status, we should
 1657      *     retry submitting them here.
 1658      */
 1659 }
 1660 
 1661 /********************************************************************************
 1662  ********************************************************************************
 1663                                                         Command Buffer Management
 1664  ********************************************************************************
 1665  ********************************************************************************/
 1666 
 1667 /********************************************************************************
 1668  * Allocate a command.
 1669  */
 1670 static int
 1671 mly_alloc_command(struct mly_softc *sc, struct mly_command **mcp)
 1672 {
 1673     struct mly_command  *mc;
 1674 
 1675     debug_called(3);
 1676 
 1677     if ((mc = mly_dequeue_free(sc)) == NULL)
 1678         return(ENOMEM);
 1679 
 1680     *mcp = mc;
 1681     return(0);
 1682 }
 1683 
 1684 /********************************************************************************
 1685  * Release a command back to the freelist.
 1686  */
 1687 static void
 1688 mly_release_command(struct mly_command *mc)
 1689 {
 1690     debug_called(3);
 1691 
 1692     /*
 1693      * Fill in parts of the command that may cause confusion if
 1694      * a consumer doesn't when we are later allocated.
 1695      */
 1696     mc->mc_data = NULL;
 1697     mc->mc_flags = 0;
 1698     mc->mc_complete = NULL;
 1699     mc->mc_private = NULL;
 1700 
 1701     /*
 1702      * By default, we set up to overwrite the command packet with
 1703      * sense information.
 1704      */
 1705     mc->mc_packet->generic.sense_buffer_address = mc->mc_packetphys;
 1706     mc->mc_packet->generic.maximum_sense_size = sizeof(union mly_command_packet);
 1707 
 1708     mly_enqueue_free(mc);
 1709 }
 1710 
 1711 /********************************************************************************
 1712  * Map helper for command allocation.
 1713  */
 1714 static void
 1715 mly_alloc_commands_map(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 1716 {
 1717     struct mly_softc    *sc = (struct mly_softc *)arg;
 1718 
 1719     debug_called(1);
 1720 
 1721     sc->mly_packetphys = segs[0].ds_addr;
 1722 }
 1723 
 1724 /********************************************************************************
 1725  * Allocate and initialise command and packet structures.
 1726  *
 1727  * If the controller supports fewer than MLY_MAX_COMMANDS commands, limit our
 1728  * allocation to that number.  If we don't yet know how many commands the
 1729  * controller supports, allocate a very small set (suitable for initialisation
 1730  * purposes only).
 1731  */
 1732 static int
 1733 mly_alloc_commands(struct mly_softc *sc)
 1734 {
 1735     struct mly_command          *mc;
 1736     int                         i, ncmd;
 1737  
 1738     if (sc->mly_controllerinfo == NULL) {
 1739         ncmd = 4;
 1740     } else {
 1741         ncmd = min(MLY_MAX_COMMANDS, sc->mly_controllerinfo->maximum_parallel_commands);
 1742     }
 1743 
 1744     /*
 1745      * Allocate enough space for all the command packets in one chunk and
 1746      * map them permanently into controller-visible space.
 1747      */
 1748     if (bus_dmamem_alloc(sc->mly_packet_dmat, (void **)&sc->mly_packet, 
 1749                          BUS_DMA_NOWAIT, &sc->mly_packetmap)) {
 1750         return(ENOMEM);
 1751     }
 1752     if (bus_dmamap_load(sc->mly_packet_dmat, sc->mly_packetmap, sc->mly_packet, 
 1753                         ncmd * sizeof(union mly_command_packet), 
 1754                         mly_alloc_commands_map, sc, BUS_DMA_NOWAIT) != 0)
 1755         return (ENOMEM);
 1756 
 1757     for (i = 0; i < ncmd; i++) {
 1758         mc = &sc->mly_command[i];
 1759         bzero(mc, sizeof(*mc));
 1760         mc->mc_sc = sc;
 1761         mc->mc_slot = MLY_SLOT_START + i;
 1762         mc->mc_packet = sc->mly_packet + i;
 1763         mc->mc_packetphys = sc->mly_packetphys + (i * sizeof(union mly_command_packet));
 1764         if (!bus_dmamap_create(sc->mly_buffer_dmat, 0, &mc->mc_datamap))
 1765             mly_release_command(mc);
 1766     }
 1767     return(0);
 1768 }
 1769 
 1770 /********************************************************************************
 1771  * Free all the storage held by commands.
 1772  *
 1773  * Must be called with all commands on the free list.
 1774  */
 1775 static void
 1776 mly_release_commands(struct mly_softc *sc)
 1777 {
 1778     struct mly_command  *mc;
 1779 
 1780     /* throw away command buffer DMA maps */
 1781     while (mly_alloc_command(sc, &mc) == 0)
 1782         bus_dmamap_destroy(sc->mly_buffer_dmat, mc->mc_datamap);
 1783 
 1784     /* release the packet storage */
 1785     if (sc->mly_packet != NULL) {
 1786         bus_dmamap_unload(sc->mly_packet_dmat, sc->mly_packetmap);
 1787         bus_dmamem_free(sc->mly_packet_dmat, sc->mly_packet, sc->mly_packetmap);
 1788         sc->mly_packet = NULL;
 1789     }
 1790 }
 1791 
 1792 
 1793 /********************************************************************************
 1794  * Command-mapping helper function - populate this command's s/g table
 1795  * with the s/g entries for its data.
 1796  */
 1797 static void
 1798 mly_map_command_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 1799 {
 1800     struct mly_command          *mc = (struct mly_command *)arg;
 1801     struct mly_softc            *sc = mc->mc_sc;
 1802     struct mly_command_generic  *gen = &(mc->mc_packet->generic);
 1803     struct mly_sg_entry         *sg;
 1804     int                         i, tabofs;
 1805 
 1806     debug_called(2);
 1807 
 1808     /* can we use the transfer structure directly? */
 1809     if (nseg <= 2) {
 1810         sg = &gen->transfer.direct.sg[0];
 1811         gen->command_control.extended_sg_table = 0;
 1812     } else {
 1813         tabofs = ((mc->mc_slot - MLY_SLOT_START) * MLY_MAX_SGENTRIES);
 1814         sg = sc->mly_sg_table + tabofs;
 1815         gen->transfer.indirect.entries[0] = nseg;
 1816         gen->transfer.indirect.table_physaddr[0] = sc->mly_sg_busaddr + (tabofs * sizeof(struct mly_sg_entry));
 1817         gen->command_control.extended_sg_table = 1;
 1818     }
 1819 
 1820     /* copy the s/g table */
 1821     for (i = 0; i < nseg; i++) {
 1822         sg[i].physaddr = segs[i].ds_addr;
 1823         sg[i].length = segs[i].ds_len;
 1824     }
 1825 
 1826 }
 1827 
 1828 #if 0
 1829 /********************************************************************************
 1830  * Command-mapping helper function - save the cdb's physical address.
 1831  *
 1832  * We don't support 'large' SCSI commands at this time, so this is unused.
 1833  */
 1834 static void
 1835 mly_map_command_cdb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 1836 {
 1837     struct mly_command                  *mc = (struct mly_command *)arg;
 1838 
 1839     debug_called(2);
 1840 
 1841     /* XXX can we safely assume that a CDB will never cross a page boundary? */
 1842     if ((segs[0].ds_addr % PAGE_SIZE) > 
 1843         ((segs[0].ds_addr + mc->mc_packet->scsi_large.cdb_length) % PAGE_SIZE))
 1844         panic("cdb crosses page boundary");
 1845 
 1846     /* fix up fields in the command packet */
 1847     mc->mc_packet->scsi_large.cdb_physaddr = segs[0].ds_addr;
 1848 }
 1849 #endif
 1850 
 1851 /********************************************************************************
 1852  * Map a command into controller-visible space
 1853  */
 1854 static void
 1855 mly_map_command(struct mly_command *mc)
 1856 {
 1857     struct mly_softc    *sc = mc->mc_sc;
 1858 
 1859     debug_called(2);
 1860 
 1861     /* don't map more than once */
 1862     if (mc->mc_flags & MLY_CMD_MAPPED)
 1863         return;
 1864 
 1865     /* does the command have a data buffer? */
 1866     if (mc->mc_data != NULL) {
 1867         bus_dmamap_load(sc->mly_buffer_dmat, mc->mc_datamap, mc->mc_data, mc->mc_length, 
 1868                         mly_map_command_sg, mc, 0);
 1869         
 1870         if (mc->mc_flags & MLY_CMD_DATAIN)
 1871             bus_dmamap_sync(sc->mly_buffer_dmat, mc->mc_datamap, BUS_DMASYNC_PREREAD);
 1872         if (mc->mc_flags & MLY_CMD_DATAOUT)
 1873             bus_dmamap_sync(sc->mly_buffer_dmat, mc->mc_datamap, BUS_DMASYNC_PREWRITE);
 1874     }
 1875     mc->mc_flags |= MLY_CMD_MAPPED;
 1876 }
 1877 
 1878 /********************************************************************************
 1879  * Unmap a command from controller-visible space
 1880  */
 1881 static void
 1882 mly_unmap_command(struct mly_command *mc)
 1883 {
 1884     struct mly_softc    *sc = mc->mc_sc;
 1885 
 1886     debug_called(2);
 1887 
 1888     if (!(mc->mc_flags & MLY_CMD_MAPPED))
 1889         return;
 1890 
 1891     /* does the command have a data buffer? */
 1892     if (mc->mc_data != NULL) {
 1893         if (mc->mc_flags & MLY_CMD_DATAIN)
 1894             bus_dmamap_sync(sc->mly_buffer_dmat, mc->mc_datamap, BUS_DMASYNC_POSTREAD);
 1895         if (mc->mc_flags & MLY_CMD_DATAOUT)
 1896             bus_dmamap_sync(sc->mly_buffer_dmat, mc->mc_datamap, BUS_DMASYNC_POSTWRITE);
 1897 
 1898         bus_dmamap_unload(sc->mly_buffer_dmat, mc->mc_datamap);
 1899     }
 1900     mc->mc_flags &= ~MLY_CMD_MAPPED;
 1901 }
 1902 
 1903 
 1904 /********************************************************************************
 1905  ********************************************************************************
 1906                                                                     CAM interface
 1907  ********************************************************************************
 1908  ********************************************************************************/
 1909 
 1910 /********************************************************************************
 1911  * Attach the physical and virtual SCSI busses to CAM.
 1912  *
 1913  * Physical bus numbering starts from 0, virtual bus numbering from one greater
 1914  * than the highest physical bus.  Physical busses are only registered if
 1915  * the kernel environment variable "hw.mly.register_physical_channels" is set.
 1916  *
 1917  * When we refer to a "bus", we are referring to the bus number registered with
 1918  * the SIM, wheras a "channel" is a channel number given to the adapter.  In order
 1919  * to keep things simple, we map these 1:1, so "bus" and "channel" may be used
 1920  * interchangeably.
 1921  */
 1922 static int
 1923 mly_cam_attach(struct mly_softc *sc)
 1924 {
 1925     struct cam_devq     *devq;
 1926     int                 chn, i;
 1927 
 1928     debug_called(1);
 1929 
 1930     /*
 1931      * Allocate a devq for all our channels combined.
 1932      */
 1933     if ((devq = cam_simq_alloc(sc->mly_controllerinfo->maximum_parallel_commands)) == NULL) {
 1934         mly_printf(sc, "can't allocate CAM SIM queue\n");
 1935         return(ENOMEM);
 1936     }
 1937 
 1938     /*
 1939      * If physical channel registration has been requested, register these first.
 1940      * Note that we enable tagged command queueing for physical channels.
 1941      */
 1942     if (testenv("hw.mly.register_physical_channels")) {
 1943         chn = 0;
 1944         for (i = 0; i < sc->mly_controllerinfo->physical_channels_present; i++, chn++) {
 1945 
 1946             if ((sc->mly_cam_sim[chn] = cam_sim_alloc(mly_cam_action, mly_cam_poll, "mly", sc,
 1947                                                       device_get_unit(sc->mly_dev),
 1948                                                       &Giant,
 1949                                                       sc->mly_controllerinfo->maximum_parallel_commands,
 1950                                                       1, devq)) == NULL) {
 1951                 return(ENOMEM);
 1952             }
 1953             if (xpt_bus_register(sc->mly_cam_sim[chn], sc->mly_dev, chn)) {
 1954                 mly_printf(sc, "CAM XPT phsyical channel registration failed\n");
 1955                 return(ENXIO);
 1956             }
 1957             debug(1, "registered physical channel %d", chn);
 1958         }
 1959     }
 1960 
 1961     /*
 1962      * Register our virtual channels, with bus numbers matching channel numbers.
 1963      */
 1964     chn = sc->mly_controllerinfo->physical_channels_present;
 1965     for (i = 0; i < sc->mly_controllerinfo->virtual_channels_present; i++, chn++) {
 1966         if ((sc->mly_cam_sim[chn] = cam_sim_alloc(mly_cam_action, mly_cam_poll, "mly", sc,
 1967                                                   device_get_unit(sc->mly_dev),
 1968                                                   &Giant,
 1969                                                   sc->mly_controllerinfo->maximum_parallel_commands,
 1970                                                   0, devq)) == NULL) {
 1971             return(ENOMEM);
 1972         }
 1973         if (xpt_bus_register(sc->mly_cam_sim[chn], sc->mly_dev, chn)) {
 1974             mly_printf(sc, "CAM XPT virtual channel registration failed\n");
 1975             return(ENXIO);
 1976         }
 1977         debug(1, "registered virtual channel %d", chn);
 1978     }
 1979 
 1980     /*
 1981      * This is the total number of channels that (might have been) registered with
 1982      * CAM.  Some may not have been; check the mly_cam_sim array to be certain.
 1983      */
 1984     sc->mly_cam_channels = sc->mly_controllerinfo->physical_channels_present +
 1985         sc->mly_controllerinfo->virtual_channels_present;
 1986 
 1987     return(0);
 1988 }
 1989 
 1990 /********************************************************************************
 1991  * Detach from CAM
 1992  */
 1993 static void
 1994 mly_cam_detach(struct mly_softc *sc)
 1995 {
 1996     int         i;
 1997     
 1998     debug_called(1);
 1999 
 2000     for (i = 0; i < sc->mly_cam_channels; i++) {
 2001         if (sc->mly_cam_sim[i] != NULL) {
 2002             xpt_bus_deregister(cam_sim_path(sc->mly_cam_sim[i]));
 2003             cam_sim_free(sc->mly_cam_sim[i], 0);
 2004         }
 2005     }
 2006     if (sc->mly_cam_devq != NULL)
 2007         cam_simq_free(sc->mly_cam_devq);
 2008 }
 2009 
 2010 /************************************************************************
 2011  * Rescan a device.
 2012  */ 
 2013 static void
 2014 mly_cam_rescan_btl(struct mly_softc *sc, int bus, int target)
 2015 {
 2016     union ccb   *ccb;
 2017 
 2018     debug_called(1);
 2019 
 2020     if ((ccb = malloc(sizeof(union ccb), M_TEMP, M_WAITOK | M_ZERO)) == NULL) {
 2021         mly_printf(sc, "rescan failed (can't allocate CCB)\n");
 2022         return;
 2023     }
 2024     
 2025     if (xpt_create_path(&sc->mly_cam_path, xpt_periph, 
 2026                         cam_sim_path(sc->mly_cam_sim[bus]), target, 0) != CAM_REQ_CMP) {
 2027         mly_printf(sc, "rescan failed (can't create path)\n");
 2028         free(ccb, M_TEMP);
 2029         return;
 2030     }
 2031     xpt_setup_ccb(&ccb->ccb_h, sc->mly_cam_path, 5/*priority (low)*/);
 2032     ccb->ccb_h.func_code = XPT_SCAN_LUN;
 2033     ccb->ccb_h.cbfcnp = mly_cam_rescan_callback;
 2034     ccb->crcn.flags = CAM_FLAG_NONE;
 2035     debug(1, "rescan target %d:%d", bus, target);
 2036     xpt_action(ccb);
 2037 }
 2038 
 2039 static void
 2040 mly_cam_rescan_callback(struct cam_periph *periph, union ccb *ccb)
 2041 {
 2042     free(ccb, M_TEMP);
 2043 }
 2044 
 2045 /********************************************************************************
 2046  * Handle an action requested by CAM
 2047  */
 2048 static void
 2049 mly_cam_action(struct cam_sim *sim, union ccb *ccb)
 2050 {
 2051     struct mly_softc    *sc = cam_sim_softc(sim);
 2052 
 2053     debug_called(2);
 2054 
 2055     switch (ccb->ccb_h.func_code) {
 2056 
 2057         /* perform SCSI I/O */
 2058     case XPT_SCSI_IO:
 2059         if (!mly_cam_action_io(sim, (struct ccb_scsiio *)&ccb->csio))
 2060             return;
 2061         break;
 2062 
 2063         /* perform geometry calculations */
 2064     case XPT_CALC_GEOMETRY:
 2065     {
 2066         struct ccb_calc_geometry        *ccg = &ccb->ccg;
 2067         u_int32_t                       secs_per_cylinder;
 2068 
 2069         debug(2, "XPT_CALC_GEOMETRY %d:%d:%d", cam_sim_bus(sim), ccb->ccb_h.target_id, ccb->ccb_h.target_lun);
 2070 
 2071         if (sc->mly_controllerparam->bios_geometry == MLY_BIOSGEOM_8G) {
 2072             ccg->heads = 255;
 2073             ccg->secs_per_track = 63;
 2074         } else {                                /* MLY_BIOSGEOM_2G */
 2075             ccg->heads = 128;
 2076             ccg->secs_per_track = 32;
 2077         }
 2078         secs_per_cylinder = ccg->heads * ccg->secs_per_track;
 2079         ccg->cylinders = ccg->volume_size / secs_per_cylinder;
 2080         ccb->ccb_h.status = CAM_REQ_CMP;
 2081         break;
 2082     }
 2083 
 2084         /* handle path attribute inquiry */
 2085     case XPT_PATH_INQ:
 2086     {
 2087         struct ccb_pathinq      *cpi = &ccb->cpi;
 2088 
 2089         debug(2, "XPT_PATH_INQ %d:%d:%d", cam_sim_bus(sim), ccb->ccb_h.target_id, ccb->ccb_h.target_lun);
 2090 
 2091         cpi->version_num = 1;
 2092         cpi->hba_inquiry = PI_TAG_ABLE;         /* XXX extra flags for physical channels? */
 2093         cpi->target_sprt = 0;
 2094         cpi->hba_misc = 0;
 2095         cpi->max_target = MLY_MAX_TARGETS - 1;
 2096         cpi->max_lun = MLY_MAX_LUNS - 1;
 2097         cpi->initiator_id = sc->mly_controllerparam->initiator_id;
 2098         strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
 2099         strncpy(cpi->hba_vid, "FreeBSD", HBA_IDLEN);
 2100         strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
 2101         cpi->unit_number = cam_sim_unit(sim);
 2102         cpi->bus_id = cam_sim_bus(sim);
 2103         cpi->base_transfer_speed = 132 * 1024;  /* XXX what to set this to? */
 2104         cpi->transport = XPORT_SPI;
 2105         cpi->transport_version = 2;
 2106         cpi->protocol = PROTO_SCSI;
 2107         cpi->protocol_version = SCSI_REV_2;
 2108         ccb->ccb_h.status = CAM_REQ_CMP;
 2109         break;
 2110     }
 2111 
 2112     case XPT_GET_TRAN_SETTINGS:
 2113     {
 2114         struct ccb_trans_settings       *cts = &ccb->cts;
 2115         int                             bus, target;
 2116         struct ccb_trans_settings_scsi *scsi = &cts->proto_specific.scsi;
 2117         struct ccb_trans_settings_spi *spi = &cts->xport_specific.spi;
 2118 
 2119         cts->protocol = PROTO_SCSI;
 2120         cts->protocol_version = SCSI_REV_2;
 2121         cts->transport = XPORT_SPI;
 2122         cts->transport_version = 2;
 2123 
 2124         scsi->flags = 0;
 2125         scsi->valid = 0;
 2126         spi->flags = 0;
 2127         spi->valid = 0;
 2128 
 2129         bus = cam_sim_bus(sim);
 2130         target = cts->ccb_h.target_id;
 2131         debug(2, "XPT_GET_TRAN_SETTINGS %d:%d", bus, target);
 2132         /* logical device? */
 2133         if (sc->mly_btl[bus][target].mb_flags & MLY_BTL_LOGICAL) {
 2134             /* nothing special for these */
 2135         /* physical device? */
 2136         } else if (sc->mly_btl[bus][target].mb_flags & MLY_BTL_PHYSICAL) {
 2137             /* allow CAM to try tagged transactions */
 2138             scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB;
 2139             scsi->valid |= CTS_SCSI_VALID_TQ;
 2140 
 2141             /* convert speed (MHz) to usec */
 2142             if (sc->mly_btl[bus][target].mb_speed == 0) {
 2143                 spi->sync_period = 1000000 / 5;
 2144             } else {
 2145                 spi->sync_period = 1000000 / sc->mly_btl[bus][target].mb_speed;
 2146             }
 2147 
 2148             /* convert bus width to CAM internal encoding */
 2149             switch (sc->mly_btl[bus][target].mb_width) {
 2150             case 32:
 2151                 spi->bus_width = MSG_EXT_WDTR_BUS_32_BIT;
 2152                 break;
 2153             case 16:
 2154                 spi->bus_width = MSG_EXT_WDTR_BUS_16_BIT;
 2155                 break;
 2156             case 8:
 2157             default:
 2158                 spi->bus_width = MSG_EXT_WDTR_BUS_8_BIT;
 2159                 break;
 2160             }
 2161             spi->valid |= CTS_SPI_VALID_SYNC_RATE | CTS_SPI_VALID_BUS_WIDTH;
 2162 
 2163             /* not a device, bail out */
 2164         } else {
 2165             cts->ccb_h.status = CAM_REQ_CMP_ERR;
 2166             break;
 2167         }
 2168 
 2169         /* disconnect always OK */
 2170         spi->flags |= CTS_SPI_FLAGS_DISC_ENB;
 2171         spi->valid |= CTS_SPI_VALID_DISC;
 2172 
 2173         cts->ccb_h.status = CAM_REQ_CMP;
 2174         break;
 2175     }
 2176 
 2177     default:            /* we can't do this */
 2178         debug(2, "unspported func_code = 0x%x", ccb->ccb_h.func_code);
 2179         ccb->ccb_h.status = CAM_REQ_INVALID;
 2180         break;
 2181     }
 2182 
 2183     xpt_done(ccb);
 2184 }
 2185 
 2186 /********************************************************************************
 2187  * Handle an I/O operation requested by CAM
 2188  */
 2189 static int
 2190 mly_cam_action_io(struct cam_sim *sim, struct ccb_scsiio *csio)
 2191 {
 2192     struct mly_softc                    *sc = cam_sim_softc(sim);
 2193     struct mly_command                  *mc;
 2194     struct mly_command_scsi_small       *ss;
 2195     int                                 bus, target;
 2196     int                                 error;
 2197     int                                 s;
 2198 
 2199     bus = cam_sim_bus(sim);
 2200     target = csio->ccb_h.target_id;
 2201 
 2202     debug(2, "XPT_SCSI_IO %d:%d:%d", bus, target, csio->ccb_h.target_lun);
 2203 
 2204     /* validate bus number */
 2205     if (!MLY_BUS_IS_VALID(sc, bus)) {
 2206         debug(0, " invalid bus %d", bus);
 2207         csio->ccb_h.status = CAM_REQ_CMP_ERR;
 2208     }
 2209 
 2210     /*  check for I/O attempt to a protected device */
 2211     if (sc->mly_btl[bus][target].mb_flags & MLY_BTL_PROTECTED) {
 2212         debug(2, "  device protected");
 2213         csio->ccb_h.status = CAM_REQ_CMP_ERR;
 2214     }
 2215 
 2216     /* check for I/O attempt to nonexistent device */
 2217     if (!(sc->mly_btl[bus][target].mb_flags & (MLY_BTL_LOGICAL | MLY_BTL_PHYSICAL))) {
 2218         debug(2, "  device %d:%d does not exist", bus, target);
 2219         csio->ccb_h.status = CAM_REQ_CMP_ERR;
 2220     }
 2221 
 2222     /* XXX increase if/when we support large SCSI commands */
 2223     if (csio->cdb_len > MLY_CMD_SCSI_SMALL_CDB) {
 2224         debug(0, "  command too large (%d > %d)", csio->cdb_len, MLY_CMD_SCSI_SMALL_CDB);
 2225         csio->ccb_h.status = CAM_REQ_CMP_ERR;
 2226     }
 2227 
 2228     /* check that the CDB pointer is not to a physical address */
 2229     if ((csio->ccb_h.flags & CAM_CDB_POINTER) && (csio->ccb_h.flags & CAM_CDB_PHYS)) {
 2230         debug(0, "  CDB pointer is to physical address");
 2231         csio->ccb_h.status = CAM_REQ_CMP_ERR;
 2232     }
 2233 
 2234     /* if there is data transfer, it must be to/from a virtual address */
 2235     if ((csio->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
 2236         if (csio->ccb_h.flags & CAM_DATA_PHYS) {                /* we can't map it */
 2237             debug(0, "  data pointer is to physical address");
 2238             csio->ccb_h.status = CAM_REQ_CMP_ERR;
 2239         }
 2240         if (csio->ccb_h.flags & CAM_SCATTER_VALID) {    /* we want to do the s/g setup */
 2241             debug(0, "  data has premature s/g setup");
 2242             csio->ccb_h.status = CAM_REQ_CMP_ERR;
 2243         }
 2244     }
 2245 
 2246     /* abandon aborted ccbs or those that have failed validation */
 2247     if ((csio->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_INPROG) {
 2248         debug(2, "abandoning CCB due to abort/validation failure");
 2249         return(EINVAL);
 2250     }
 2251 
 2252     /*
 2253      * Get a command, or push the ccb back to CAM and freeze the queue.
 2254      */
 2255     if ((error = mly_alloc_command(sc, &mc))) {
 2256         s = splcam();
 2257         xpt_freeze_simq(sim, 1);
 2258         csio->ccb_h.status |= CAM_REQUEUE_REQ;
 2259         sc->mly_qfrzn_cnt++;
 2260         splx(s);
 2261         return(error);
 2262     }
 2263     
 2264     /* build the command */
 2265     mc->mc_data = csio->data_ptr;
 2266     mc->mc_length = csio->dxfer_len;
 2267     mc->mc_complete = mly_cam_complete;
 2268     mc->mc_private = csio;
 2269 
 2270     /* save the bus number in the ccb for later recovery XXX should be a better way */
 2271      csio->ccb_h.sim_priv.entries[0].field = bus;
 2272 
 2273     /* build the packet for the controller */
 2274     ss = &mc->mc_packet->scsi_small;
 2275     ss->opcode = MDACMD_SCSI;
 2276     if (csio->ccb_h.flags & CAM_DIS_DISCONNECT)
 2277         ss->command_control.disable_disconnect = 1;
 2278     if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT)
 2279         ss->command_control.data_direction = MLY_CCB_WRITE;
 2280     ss->data_size = csio->dxfer_len;
 2281     ss->addr.phys.lun = csio->ccb_h.target_lun;
 2282     ss->addr.phys.target = csio->ccb_h.target_id;
 2283     ss->addr.phys.channel = bus;
 2284     if (csio->ccb_h.timeout < (60 * 1000)) {
 2285         ss->timeout.value = csio->ccb_h.timeout / 1000;
 2286         ss->timeout.scale = MLY_TIMEOUT_SECONDS;
 2287     } else if (csio->ccb_h.timeout < (60 * 60 * 1000)) {
 2288         ss->timeout.value = csio->ccb_h.timeout / (60 * 1000);
 2289         ss->timeout.scale = MLY_TIMEOUT_MINUTES;
 2290     } else {
 2291         ss->timeout.value = csio->ccb_h.timeout / (60 * 60 * 1000);     /* overflow? */
 2292         ss->timeout.scale = MLY_TIMEOUT_HOURS;
 2293     }
 2294     ss->maximum_sense_size = csio->sense_len;
 2295     ss->cdb_length = csio->cdb_len;
 2296     if (csio->ccb_h.flags & CAM_CDB_POINTER) {
 2297         bcopy(csio->cdb_io.cdb_ptr, ss->cdb, csio->cdb_len);
 2298     } else {
 2299         bcopy(csio->cdb_io.cdb_bytes, ss->cdb, csio->cdb_len);
 2300     }
 2301 
 2302     /* give the command to the controller */
 2303     if ((error = mly_start(mc))) {
 2304         s = splcam();
 2305         xpt_freeze_simq(sim, 1);
 2306         csio->ccb_h.status |= CAM_REQUEUE_REQ;
 2307         sc->mly_qfrzn_cnt++;
 2308         splx(s);
 2309         return(error);
 2310     }
 2311 
 2312     return(0);
 2313 }
 2314 
 2315 /********************************************************************************
 2316  * Check for possibly-completed commands.
 2317  */
 2318 static void
 2319 mly_cam_poll(struct cam_sim *sim)
 2320 {
 2321     struct mly_softc    *sc = cam_sim_softc(sim);
 2322 
 2323     debug_called(2);
 2324 
 2325     mly_done(sc);
 2326 }
 2327 
 2328 /********************************************************************************
 2329  * Handle completion of a command - pass results back through the CCB
 2330  */
 2331 static void
 2332 mly_cam_complete(struct mly_command *mc)
 2333 {
 2334     struct mly_softc            *sc = mc->mc_sc;
 2335     struct ccb_scsiio           *csio = (struct ccb_scsiio *)mc->mc_private;
 2336     struct scsi_inquiry_data    *inq = (struct scsi_inquiry_data *)csio->data_ptr;
 2337     struct mly_btl              *btl;
 2338     u_int8_t                    cmd;
 2339     int                         bus, target;
 2340     int                         s;
 2341 
 2342     debug_called(2);
 2343 
 2344     csio->scsi_status = mc->mc_status;
 2345     switch(mc->mc_status) {
 2346     case SCSI_STATUS_OK:
 2347         /*
 2348          * In order to report logical device type and status, we overwrite
 2349          * the result of the INQUIRY command to logical devices.
 2350          */
 2351         bus = csio->ccb_h.sim_priv.entries[0].field;
 2352         target = csio->ccb_h.target_id;
 2353         /* XXX validate bus/target? */
 2354         if (sc->mly_btl[bus][target].mb_flags & MLY_BTL_LOGICAL) {
 2355             if (csio->ccb_h.flags & CAM_CDB_POINTER) {
 2356                 cmd = *csio->cdb_io.cdb_ptr;
 2357             } else {
 2358                 cmd = csio->cdb_io.cdb_bytes[0];
 2359             }
 2360             if (cmd == INQUIRY) {
 2361                 btl = &sc->mly_btl[bus][target];
 2362                 padstr(inq->vendor, mly_describe_code(mly_table_device_type, btl->mb_type), 8);
 2363                 padstr(inq->product, mly_describe_code(mly_table_device_state, btl->mb_state), 16);
 2364                 padstr(inq->revision, "", 4);
 2365             }
 2366         }
 2367 
 2368         debug(2, "SCSI_STATUS_OK");
 2369         csio->ccb_h.status = CAM_REQ_CMP;
 2370         break;
 2371 
 2372     case SCSI_STATUS_CHECK_COND:
 2373         debug(1, "SCSI_STATUS_CHECK_COND  sense %d  resid %d", mc->mc_sense, mc->mc_resid);
 2374         csio->ccb_h.status = CAM_SCSI_STATUS_ERROR;
 2375         bzero(&csio->sense_data, SSD_FULL_SIZE);
 2376         bcopy(mc->mc_packet, &csio->sense_data, mc->mc_sense);
 2377         csio->sense_len = mc->mc_sense;
 2378         csio->ccb_h.status |= CAM_AUTOSNS_VALID;
 2379         csio->resid = mc->mc_resid;     /* XXX this is a signed value... */
 2380         break;
 2381 
 2382     case SCSI_STATUS_BUSY:
 2383         debug(1, "SCSI_STATUS_BUSY");
 2384         csio->ccb_h.status = CAM_SCSI_BUSY;
 2385         break;
 2386 
 2387     default:
 2388         debug(1, "unknown status 0x%x", csio->scsi_status);
 2389         csio->ccb_h.status = CAM_REQ_CMP_ERR;
 2390         break;
 2391     }
 2392 
 2393     s = splcam();
 2394     if (sc->mly_qfrzn_cnt) {
 2395         csio->ccb_h.status |= CAM_RELEASE_SIMQ;
 2396         sc->mly_qfrzn_cnt--;
 2397     }
 2398     splx(s);
 2399 
 2400     xpt_done((union ccb *)csio);
 2401     mly_release_command(mc);
 2402 }
 2403 
 2404 /********************************************************************************
 2405  * Find a peripheral attahed at (bus),(target)
 2406  */
 2407 static struct cam_periph *
 2408 mly_find_periph(struct mly_softc *sc, int bus, int target)
 2409 {
 2410     struct cam_periph   *periph;
 2411     struct cam_path     *path;
 2412     int                 status;
 2413 
 2414     status = xpt_create_path(&path, NULL, cam_sim_path(sc->mly_cam_sim[bus]), target, 0);
 2415     if (status == CAM_REQ_CMP) {
 2416         periph = cam_periph_find(path, NULL);
 2417         xpt_free_path(path);
 2418     } else {
 2419         periph = NULL;
 2420     }
 2421     return(periph);
 2422 }
 2423 
 2424 /********************************************************************************
 2425  * Name the device at (bus)(target)
 2426  */
 2427 static int
 2428 mly_name_device(struct mly_softc *sc, int bus, int target)
 2429 {
 2430     struct cam_periph   *periph;
 2431 
 2432     if ((periph = mly_find_periph(sc, bus, target)) != NULL) {
 2433         sprintf(sc->mly_btl[bus][target].mb_name, "%s%d", periph->periph_name, periph->unit_number);
 2434         return(0);
 2435     }
 2436     sc->mly_btl[bus][target].mb_name[0] = 0;
 2437     return(ENOENT);
 2438 }
 2439 
 2440 /********************************************************************************
 2441  ********************************************************************************
 2442                                                                  Hardware Control
 2443  ********************************************************************************
 2444  ********************************************************************************/
 2445 
 2446 /********************************************************************************
 2447  * Handshake with the firmware while the card is being initialised.
 2448  */
 2449 static int
 2450 mly_fwhandshake(struct mly_softc *sc) 
 2451 {
 2452     u_int8_t    error, param0, param1;
 2453     int         spinup = 0;
 2454 
 2455     debug_called(1);
 2456 
 2457     /* set HM_STSACK and let the firmware initialise */
 2458     MLY_SET_REG(sc, sc->mly_idbr, MLY_HM_STSACK);
 2459     DELAY(1000);        /* too short? */
 2460 
 2461     /* if HM_STSACK is still true, the controller is initialising */
 2462     if (!MLY_IDBR_TRUE(sc, MLY_HM_STSACK))
 2463         return(0);
 2464     mly_printf(sc, "controller initialisation started\n");
 2465 
 2466     /* spin waiting for initialisation to finish, or for a message to be delivered */
 2467     while (MLY_IDBR_TRUE(sc, MLY_HM_STSACK)) {
 2468         /* check for a message */
 2469         if (MLY_ERROR_VALID(sc)) {
 2470             error = MLY_GET_REG(sc, sc->mly_error_status) & ~MLY_MSG_EMPTY;
 2471             param0 = MLY_GET_REG(sc, sc->mly_command_mailbox);
 2472             param1 = MLY_GET_REG(sc, sc->mly_command_mailbox + 1);
 2473 
 2474             switch(error) {
 2475             case MLY_MSG_SPINUP:
 2476                 if (!spinup) {
 2477                     mly_printf(sc, "drive spinup in progress\n");
 2478                     spinup = 1;                 /* only print this once (should print drive being spun?) */
 2479                 }
 2480                 break;
 2481             case MLY_MSG_RACE_RECOVERY_FAIL:
 2482                 mly_printf(sc, "mirror race recovery failed, one or more drives offline\n");
 2483                 break;
 2484             case MLY_MSG_RACE_IN_PROGRESS:
 2485                 mly_printf(sc, "mirror race recovery in progress\n");
 2486                 break;
 2487             case MLY_MSG_RACE_ON_CRITICAL:
 2488                 mly_printf(sc, "mirror race recovery on a critical drive\n");
 2489                 break;
 2490             case MLY_MSG_PARITY_ERROR:
 2491                 mly_printf(sc, "FATAL MEMORY PARITY ERROR\n");
 2492                 return(ENXIO);
 2493             default:
 2494                 mly_printf(sc, "unknown initialisation code 0x%x\n", error);
 2495             }
 2496         }
 2497     }
 2498     return(0);
 2499 }
 2500 
 2501 /********************************************************************************
 2502  ********************************************************************************
 2503                                                         Debugging and Diagnostics
 2504  ********************************************************************************
 2505  ********************************************************************************/
 2506 
 2507 /********************************************************************************
 2508  * Print some information about the controller.
 2509  */
 2510 static void
 2511 mly_describe_controller(struct mly_softc *sc)
 2512 {
 2513     struct mly_ioctl_getcontrollerinfo  *mi = sc->mly_controllerinfo;
 2514 
 2515     mly_printf(sc, "%16s, %d channel%s, firmware %d.%02d-%d-%02d (%02d%02d%02d%02d), %dMB RAM\n", 
 2516                mi->controller_name, mi->physical_channels_present, (mi->physical_channels_present) > 1 ? "s" : "",
 2517                mi->fw_major, mi->fw_minor, mi->fw_turn, mi->fw_build,   /* XXX turn encoding? */
 2518                mi->fw_century, mi->fw_year, mi->fw_month, mi->fw_day,
 2519                mi->memory_size);
 2520 
 2521     if (bootverbose) {
 2522         mly_printf(sc, "%s %s (%x), %dMHz %d-bit %.16s\n", 
 2523                    mly_describe_code(mly_table_oemname, mi->oem_information), 
 2524                    mly_describe_code(mly_table_controllertype, mi->controller_type), mi->controller_type,
 2525                    mi->interface_speed, mi->interface_width, mi->interface_name);
 2526         mly_printf(sc, "%dMB %dMHz %d-bit %s%s%s, cache %dMB\n",
 2527                    mi->memory_size, mi->memory_speed, mi->memory_width, 
 2528                    mly_describe_code(mly_table_memorytype, mi->memory_type),
 2529                    mi->memory_parity ? "+parity": "",mi->memory_ecc ? "+ECC": "",
 2530                    mi->cache_size);
 2531         mly_printf(sc, "CPU: %s @ %dMHZ\n", 
 2532                    mly_describe_code(mly_table_cputype, mi->cpu[0].type), mi->cpu[0].speed);
 2533         if (mi->l2cache_size != 0)
 2534             mly_printf(sc, "%dKB L2 cache\n", mi->l2cache_size);
 2535         if (mi->exmemory_size != 0)
 2536             mly_printf(sc, "%dMB %dMHz %d-bit private %s%s%s\n",
 2537                        mi->exmemory_size, mi->exmemory_speed, mi->exmemory_width,
 2538                        mly_describe_code(mly_table_memorytype, mi->exmemory_type),
 2539                        mi->exmemory_parity ? "+parity": "",mi->exmemory_ecc ? "+ECC": "");
 2540         mly_printf(sc, "battery backup %s\n", mi->bbu_present ? "present" : "not installed");
 2541         mly_printf(sc, "maximum data transfer %d blocks, maximum sg entries/command %d\n",
 2542                    mi->maximum_block_count, mi->maximum_sg_entries);
 2543         mly_printf(sc, "logical devices present/critical/offline %d/%d/%d\n",
 2544                    mi->logical_devices_present, mi->logical_devices_critical, mi->logical_devices_offline);
 2545         mly_printf(sc, "physical devices present %d\n",
 2546                    mi->physical_devices_present);
 2547         mly_printf(sc, "physical disks present/offline %d/%d\n",
 2548                    mi->physical_disks_present, mi->physical_disks_offline);
 2549         mly_printf(sc, "%d physical channel%s, %d virtual channel%s of %d possible\n",
 2550                    mi->physical_channels_present, mi->physical_channels_present == 1 ? "" : "s",
 2551                    mi->virtual_channels_present, mi->virtual_channels_present == 1 ? "" : "s",
 2552                    mi->virtual_channels_possible);
 2553         mly_printf(sc, "%d parallel commands supported\n", mi->maximum_parallel_commands);
 2554         mly_printf(sc, "%dMB flash ROM, %d of %d maximum cycles\n",
 2555                    mi->flash_size, mi->flash_age, mi->flash_maximum_age);
 2556     }
 2557 }
 2558 
 2559 #ifdef MLY_DEBUG
 2560 /********************************************************************************
 2561  * Print some controller state
 2562  */
 2563 static void
 2564 mly_printstate(struct mly_softc *sc)
 2565 {
 2566     mly_printf(sc, "IDBR %02x  ODBR %02x  ERROR %02x  (%x %x %x)\n",
 2567                   MLY_GET_REG(sc, sc->mly_idbr),
 2568                   MLY_GET_REG(sc, sc->mly_odbr),
 2569                   MLY_GET_REG(sc, sc->mly_error_status),
 2570                   sc->mly_idbr,
 2571                   sc->mly_odbr,
 2572                   sc->mly_error_status);
 2573     mly_printf(sc, "IMASK %02x  ISTATUS %02x\n",
 2574                   MLY_GET_REG(sc, sc->mly_interrupt_mask),
 2575                   MLY_GET_REG(sc, sc->mly_interrupt_status));
 2576     mly_printf(sc, "COMMAND %02x %02x %02x %02x %02x %02x %02x %02x\n",
 2577                   MLY_GET_REG(sc, sc->mly_command_mailbox),
 2578                   MLY_GET_REG(sc, sc->mly_command_mailbox + 1),
 2579                   MLY_GET_REG(sc, sc->mly_command_mailbox + 2),
 2580                   MLY_GET_REG(sc, sc->mly_command_mailbox + 3),
 2581                   MLY_GET_REG(sc, sc->mly_command_mailbox + 4),
 2582                   MLY_GET_REG(sc, sc->mly_command_mailbox + 5),
 2583                   MLY_GET_REG(sc, sc->mly_command_mailbox + 6),
 2584                   MLY_GET_REG(sc, sc->mly_command_mailbox + 7));
 2585     mly_printf(sc, "STATUS  %02x %02x %02x %02x %02x %02x %02x %02x\n",
 2586                   MLY_GET_REG(sc, sc->mly_status_mailbox),
 2587                   MLY_GET_REG(sc, sc->mly_status_mailbox + 1),
 2588                   MLY_GET_REG(sc, sc->mly_status_mailbox + 2),
 2589                   MLY_GET_REG(sc, sc->mly_status_mailbox + 3),
 2590                   MLY_GET_REG(sc, sc->mly_status_mailbox + 4),
 2591                   MLY_GET_REG(sc, sc->mly_status_mailbox + 5),
 2592                   MLY_GET_REG(sc, sc->mly_status_mailbox + 6),
 2593                   MLY_GET_REG(sc, sc->mly_status_mailbox + 7));
 2594     mly_printf(sc, "        %04x        %08x\n",
 2595                   MLY_GET_REG2(sc, sc->mly_status_mailbox),
 2596                   MLY_GET_REG4(sc, sc->mly_status_mailbox + 4));
 2597 }
 2598 
 2599 struct mly_softc        *mly_softc0 = NULL;
 2600 void
 2601 mly_printstate0(void)
 2602 {
 2603     if (mly_softc0 != NULL)
 2604         mly_printstate(mly_softc0);
 2605 }
 2606 
 2607 /********************************************************************************
 2608  * Print a command
 2609  */
 2610 static void
 2611 mly_print_command(struct mly_command *mc)
 2612 {
 2613     struct mly_softc    *sc = mc->mc_sc;
 2614     
 2615     mly_printf(sc, "COMMAND @ %p\n", mc);
 2616     mly_printf(sc, "  slot      %d\n", mc->mc_slot);
 2617     mly_printf(sc, "  status    0x%x\n", mc->mc_status);
 2618     mly_printf(sc, "  sense len %d\n", mc->mc_sense);
 2619     mly_printf(sc, "  resid     %d\n", mc->mc_resid);
 2620     mly_printf(sc, "  packet    %p/0x%llx\n", mc->mc_packet, mc->mc_packetphys);
 2621     if (mc->mc_packet != NULL)
 2622         mly_print_packet(mc);
 2623     mly_printf(sc, "  data      %p/%d\n", mc->mc_data, mc->mc_length);
 2624     mly_printf(sc, "  flags     %b\n", mc->mc_flags, "\2\1busy\2complete\3slotted\4mapped\5datain\6dataout\n");
 2625     mly_printf(sc, "  complete  %p\n", mc->mc_complete);
 2626     mly_printf(sc, "  private   %p\n", mc->mc_private);
 2627 }
 2628 
 2629 /********************************************************************************
 2630  * Print a command packet
 2631  */
 2632 static void
 2633 mly_print_packet(struct mly_command *mc)
 2634 {
 2635     struct mly_softc                    *sc = mc->mc_sc;
 2636     struct mly_command_generic          *ge = (struct mly_command_generic *)mc->mc_packet;
 2637     struct mly_command_scsi_small       *ss = (struct mly_command_scsi_small *)mc->mc_packet;
 2638     struct mly_command_scsi_large       *sl = (struct mly_command_scsi_large *)mc->mc_packet;
 2639     struct mly_command_ioctl            *io = (struct mly_command_ioctl *)mc->mc_packet;
 2640     int                                 transfer;
 2641 
 2642     mly_printf(sc, "   command_id           %d\n", ge->command_id);
 2643     mly_printf(sc, "   opcode               %d\n", ge->opcode);
 2644     mly_printf(sc, "   command_control      fua %d  dpo %d  est %d  dd %s  nas %d ddis %d\n",
 2645                   ge->command_control.force_unit_access,
 2646                   ge->command_control.disable_page_out,
 2647                   ge->command_control.extended_sg_table,
 2648                   (ge->command_control.data_direction == MLY_CCB_WRITE) ? "WRITE" : "READ",
 2649                   ge->command_control.no_auto_sense,
 2650                   ge->command_control.disable_disconnect);
 2651     mly_printf(sc, "   data_size            %d\n", ge->data_size);
 2652     mly_printf(sc, "   sense_buffer_address 0x%llx\n", ge->sense_buffer_address);
 2653     mly_printf(sc, "   lun                  %d\n", ge->addr.phys.lun);
 2654     mly_printf(sc, "   target               %d\n", ge->addr.phys.target);
 2655     mly_printf(sc, "   channel              %d\n", ge->addr.phys.channel);
 2656     mly_printf(sc, "   logical device       %d\n", ge->addr.log.logdev);
 2657     mly_printf(sc, "   controller           %d\n", ge->addr.phys.controller);
 2658     mly_printf(sc, "   timeout              %d %s\n", 
 2659                   ge->timeout.value,
 2660                   (ge->timeout.scale == MLY_TIMEOUT_SECONDS) ? "seconds" : 
 2661                   ((ge->timeout.scale == MLY_TIMEOUT_MINUTES) ? "minutes" : "hours"));
 2662     mly_printf(sc, "   maximum_sense_size   %d\n", ge->maximum_sense_size);
 2663     switch(ge->opcode) {
 2664     case MDACMD_SCSIPT:
 2665     case MDACMD_SCSI:
 2666         mly_printf(sc, "   cdb length           %d\n", ss->cdb_length);
 2667         mly_printf(sc, "   cdb                  %*D\n", ss->cdb_length, ss->cdb, " ");
 2668         transfer = 1;
 2669         break;
 2670     case MDACMD_SCSILC:
 2671     case MDACMD_SCSILCPT:
 2672         mly_printf(sc, "   cdb length           %d\n", sl->cdb_length);
 2673         mly_printf(sc, "   cdb                  0x%llx\n", sl->cdb_physaddr);
 2674         transfer = 1;
 2675         break;
 2676     case MDACMD_IOCTL:
 2677         mly_printf(sc, "   sub_ioctl            0x%x\n", io->sub_ioctl);
 2678         switch(io->sub_ioctl) {
 2679         case MDACIOCTL_SETMEMORYMAILBOX:
 2680             mly_printf(sc, "   health_buffer_size   %d\n", 
 2681                           io->param.setmemorymailbox.health_buffer_size);
 2682             mly_printf(sc, "   health_buffer_phys   0x%llx\n",
 2683                           io->param.setmemorymailbox.health_buffer_physaddr);
 2684             mly_printf(sc, "   command_mailbox      0x%llx\n",
 2685                           io->param.setmemorymailbox.command_mailbox_physaddr);
 2686             mly_printf(sc, "   status_mailbox       0x%llx\n",
 2687                           io->param.setmemorymailbox.status_mailbox_physaddr);
 2688             transfer = 0;
 2689             break;
 2690 
 2691         case MDACIOCTL_SETREALTIMECLOCK:
 2692         case MDACIOCTL_GETHEALTHSTATUS:
 2693         case MDACIOCTL_GETCONTROLLERINFO:
 2694         case MDACIOCTL_GETLOGDEVINFOVALID:
 2695         case MDACIOCTL_GETPHYSDEVINFOVALID:
 2696         case MDACIOCTL_GETPHYSDEVSTATISTICS:
 2697         case MDACIOCTL_GETLOGDEVSTATISTICS:
 2698         case MDACIOCTL_GETCONTROLLERSTATISTICS:
 2699         case MDACIOCTL_GETBDT_FOR_SYSDRIVE:         
 2700         case MDACIOCTL_CREATENEWCONF:
 2701         case MDACIOCTL_ADDNEWCONF:
 2702         case MDACIOCTL_GETDEVCONFINFO:
 2703         case MDACIOCTL_GETFREESPACELIST:
 2704         case MDACIOCTL_MORE:
 2705         case MDACIOCTL_SETPHYSDEVPARAMETER:
 2706         case MDACIOCTL_GETPHYSDEVPARAMETER:
 2707         case MDACIOCTL_GETLOGDEVPARAMETER:
 2708         case MDACIOCTL_SETLOGDEVPARAMETER:
 2709             mly_printf(sc, "   param                %10D\n", io->param.data.param, " ");
 2710             transfer = 1;
 2711             break;
 2712 
 2713         case MDACIOCTL_GETEVENT:
 2714             mly_printf(sc, "   event                %d\n", 
 2715                        io->param.getevent.sequence_number_low + ((u_int32_t)io->addr.log.logdev << 16));
 2716             transfer = 1;
 2717             break;
 2718 
 2719         case MDACIOCTL_SETRAIDDEVSTATE:
 2720             mly_printf(sc, "   state                %d\n", io->param.setraiddevstate.state);
 2721             transfer = 0;
 2722             break;
 2723 
 2724         case MDACIOCTL_XLATEPHYSDEVTORAIDDEV:
 2725             mly_printf(sc, "   raid_device          %d\n", io->param.xlatephysdevtoraiddev.raid_device);
 2726             mly_printf(sc, "   controller           %d\n", io->param.xlatephysdevtoraiddev.controller);
 2727             mly_printf(sc, "   channel              %d\n", io->param.xlatephysdevtoraiddev.channel);
 2728             mly_printf(sc, "   target               %d\n", io->param.xlatephysdevtoraiddev.target);
 2729             mly_printf(sc, "   lun                  %d\n", io->param.xlatephysdevtoraiddev.lun);
 2730             transfer = 0;
 2731             break;
 2732 
 2733         case MDACIOCTL_GETGROUPCONFINFO:
 2734             mly_printf(sc, "   group                %d\n", io->param.getgroupconfinfo.group);
 2735             transfer = 1;
 2736             break;
 2737 
 2738         case MDACIOCTL_GET_SUBSYSTEM_DATA:
 2739         case MDACIOCTL_SET_SUBSYSTEM_DATA:
 2740         case MDACIOCTL_STARTDISOCVERY:
 2741         case MDACIOCTL_INITPHYSDEVSTART:
 2742         case MDACIOCTL_INITPHYSDEVSTOP:
 2743         case MDACIOCTL_INITRAIDDEVSTART:
 2744         case MDACIOCTL_INITRAIDDEVSTOP:
 2745         case MDACIOCTL_REBUILDRAIDDEVSTART:
 2746         case MDACIOCTL_REBUILDRAIDDEVSTOP:
 2747         case MDACIOCTL_MAKECONSISTENTDATASTART:
 2748         case MDACIOCTL_MAKECONSISTENTDATASTOP:
 2749         case MDACIOCTL_CONSISTENCYCHECKSTART:
 2750         case MDACIOCTL_CONSISTENCYCHECKSTOP:
 2751         case MDACIOCTL_RESETDEVICE:
 2752         case MDACIOCTL_FLUSHDEVICEDATA:
 2753         case MDACIOCTL_PAUSEDEVICE:
 2754         case MDACIOCTL_UNPAUSEDEVICE:
 2755         case MDACIOCTL_LOCATEDEVICE:
 2756         case MDACIOCTL_SETMASTERSLAVEMODE:
 2757         case MDACIOCTL_DELETERAIDDEV:
 2758         case MDACIOCTL_REPLACEINTERNALDEV:
 2759         case MDACIOCTL_CLEARCONF:
 2760         case MDACIOCTL_GETCONTROLLERPARAMETER:
 2761         case MDACIOCTL_SETCONTRLLERPARAMETER:
 2762         case MDACIOCTL_CLEARCONFSUSPMODE:
 2763         case MDACIOCTL_STOREIMAGE:
 2764         case MDACIOCTL_READIMAGE:
 2765         case MDACIOCTL_FLASHIMAGES:
 2766         case MDACIOCTL_RENAMERAIDDEV:
 2767         default:                        /* no idea what to print */
 2768             transfer = 0;
 2769             break;
 2770         }
 2771         break;
 2772 
 2773     case MDACMD_IOCTLCHECK:
 2774     case MDACMD_MEMCOPY:
 2775     default:
 2776         transfer = 0;
 2777         break;  /* print nothing */
 2778     }
 2779     if (transfer) {
 2780         if (ge->command_control.extended_sg_table) {
 2781             mly_printf(sc, "   sg table             0x%llx/%d\n",
 2782                           ge->transfer.indirect.table_physaddr[0], ge->transfer.indirect.entries[0]);
 2783         } else {
 2784             mly_printf(sc, "   0000                 0x%llx/%lld\n",
 2785                           ge->transfer.direct.sg[0].physaddr, ge->transfer.direct.sg[0].length);
 2786             mly_printf(sc, "   0001                 0x%llx/%lld\n",
 2787                           ge->transfer.direct.sg[1].physaddr, ge->transfer.direct.sg[1].length);
 2788         }
 2789     }
 2790 }
 2791 
 2792 /********************************************************************************
 2793  * Panic in a slightly informative fashion
 2794  */
 2795 static void
 2796 mly_panic(struct mly_softc *sc, char *reason)
 2797 {
 2798     mly_printstate(sc);
 2799     panic(reason);
 2800 }
 2801 
 2802 /********************************************************************************
 2803  * Print queue statistics, callable from DDB.
 2804  */
 2805 void
 2806 mly_print_controller(int controller)
 2807 {
 2808     struct mly_softc    *sc;
 2809     
 2810     if ((sc = devclass_get_softc(devclass_find("mly"), controller)) == NULL) {
 2811         printf("mly: controller %d invalid\n", controller);
 2812     } else {
 2813         device_printf(sc->mly_dev, "queue    curr max\n");
 2814         device_printf(sc->mly_dev, "free     %04d/%04d\n", 
 2815                       sc->mly_qstat[MLYQ_FREE].q_length, sc->mly_qstat[MLYQ_FREE].q_max);
 2816         device_printf(sc->mly_dev, "busy     %04d/%04d\n", 
 2817                       sc->mly_qstat[MLYQ_BUSY].q_length, sc->mly_qstat[MLYQ_BUSY].q_max);
 2818         device_printf(sc->mly_dev, "complete %04d/%04d\n", 
 2819                       sc->mly_qstat[MLYQ_COMPLETE].q_length, sc->mly_qstat[MLYQ_COMPLETE].q_max);
 2820     }
 2821 }
 2822 #endif
 2823 
 2824 
 2825 /********************************************************************************
 2826  ********************************************************************************
 2827                                                          Control device interface
 2828  ********************************************************************************
 2829  ********************************************************************************/
 2830 
 2831 /********************************************************************************
 2832  * Accept an open operation on the control device.
 2833  */
 2834 static int
 2835 mly_user_open(struct cdev *dev, int flags, int fmt, struct thread *td)
 2836 {
 2837     int                 unit = minor(dev);
 2838     struct mly_softc    *sc = devclass_get_softc(devclass_find("mly"), unit);
 2839 
 2840     sc->mly_state |= MLY_STATE_OPEN;
 2841     return(0);
 2842 }
 2843 
 2844 /********************************************************************************
 2845  * Accept the last close on the control device.
 2846  */
 2847 static int
 2848 mly_user_close(struct cdev *dev, int flags, int fmt, struct thread *td)
 2849 {
 2850     int                 unit = minor(dev);
 2851     struct mly_softc    *sc = devclass_get_softc(devclass_find("mly"), unit);
 2852 
 2853     sc->mly_state &= ~MLY_STATE_OPEN;
 2854     return (0);
 2855 }
 2856 
 2857 /********************************************************************************
 2858  * Handle controller-specific control operations.
 2859  */
 2860 static int
 2861 mly_user_ioctl(struct cdev *dev, u_long cmd, caddr_t addr,
 2862                                 int32_t flag, struct thread *td)
 2863 {
 2864     struct mly_softc            *sc = (struct mly_softc *)dev->si_drv1;
 2865     struct mly_user_command     *uc = (struct mly_user_command *)addr;
 2866     struct mly_user_health      *uh = (struct mly_user_health *)addr;
 2867     
 2868     switch(cmd) {
 2869     case MLYIO_COMMAND:
 2870         return(mly_user_command(sc, uc));
 2871     case MLYIO_HEALTH:
 2872         return(mly_user_health(sc, uh));
 2873     default:
 2874         return(ENOIOCTL);
 2875     }
 2876 }
 2877 
 2878 /********************************************************************************
 2879  * Execute a command passed in from userspace.
 2880  *
 2881  * The control structure contains the actual command for the controller, as well
 2882  * as the user-space data pointer and data size, and an optional sense buffer
 2883  * size/pointer.  On completion, the data size is adjusted to the command
 2884  * residual, and the sense buffer size to the size of the returned sense data.
 2885  * 
 2886  */
 2887 static int
 2888 mly_user_command(struct mly_softc *sc, struct mly_user_command *uc)
 2889 {
 2890     struct mly_command  *mc;
 2891     int                 error, s;
 2892 
 2893     /* allocate a command */
 2894     if (mly_alloc_command(sc, &mc)) {
 2895         error = ENOMEM;
 2896         goto out;               /* XXX Linux version will wait for a command */
 2897     }
 2898 
 2899     /* handle data size/direction */
 2900     mc->mc_length = (uc->DataTransferLength >= 0) ? uc->DataTransferLength : -uc->DataTransferLength;
 2901     if (mc->mc_length > 0) {
 2902         if ((mc->mc_data = malloc(mc->mc_length, M_DEVBUF, M_NOWAIT)) == NULL) {
 2903             error = ENOMEM;
 2904             goto out;
 2905         }
 2906     }
 2907     if (uc->DataTransferLength > 0) {
 2908         mc->mc_flags |= MLY_CMD_DATAIN;
 2909         bzero(mc->mc_data, mc->mc_length);
 2910     }
 2911     if (uc->DataTransferLength < 0) {
 2912         mc->mc_flags |= MLY_CMD_DATAOUT;
 2913         if ((error = copyin(uc->DataTransferBuffer, mc->mc_data, mc->mc_length)) != 0)
 2914             goto out;
 2915     }
 2916 
 2917     /* copy the controller command */
 2918     bcopy(&uc->CommandMailbox, mc->mc_packet, sizeof(uc->CommandMailbox));
 2919 
 2920     /* clear command completion handler so that we get woken up */
 2921     mc->mc_complete = NULL;
 2922 
 2923     /* execute the command */
 2924     if ((error = mly_start(mc)) != 0)
 2925         goto out;
 2926     s = splcam();
 2927     while (!(mc->mc_flags & MLY_CMD_COMPLETE))
 2928         tsleep(mc, PRIBIO, "mlyioctl", 0);
 2929     splx(s);
 2930 
 2931     /* return the data to userspace */
 2932     if (uc->DataTransferLength > 0)
 2933         if ((error = copyout(mc->mc_data, uc->DataTransferBuffer, mc->mc_length)) != 0)
 2934             goto out;
 2935     
 2936     /* return the sense buffer to userspace */
 2937     if ((uc->RequestSenseLength > 0) && (mc->mc_sense > 0)) {
 2938         if ((error = copyout(mc->mc_packet, uc->RequestSenseBuffer, 
 2939                              min(uc->RequestSenseLength, mc->mc_sense))) != 0)
 2940             goto out;
 2941     }
 2942     
 2943     /* return command results to userspace (caller will copy out) */
 2944     uc->DataTransferLength = mc->mc_resid;
 2945     uc->RequestSenseLength = min(uc->RequestSenseLength, mc->mc_sense);
 2946     uc->CommandStatus = mc->mc_status;
 2947     error = 0;
 2948 
 2949  out:
 2950     if (mc->mc_data != NULL)
 2951         free(mc->mc_data, M_DEVBUF);
 2952     if (mc != NULL)
 2953         mly_release_command(mc);
 2954     return(error);
 2955 }
 2956 
 2957 /********************************************************************************
 2958  * Return health status to userspace.  If the health change index in the user
 2959  * structure does not match that currently exported by the controller, we
 2960  * return the current status immediately.  Otherwise, we block until either
 2961  * interrupted or new status is delivered.
 2962  */
 2963 static int
 2964 mly_user_health(struct mly_softc *sc, struct mly_user_health *uh)
 2965 {
 2966     struct mly_health_status            mh;
 2967     int                                 error, s;
 2968     
 2969     /* fetch the current health status from userspace */
 2970     if ((error = copyin(uh->HealthStatusBuffer, &mh, sizeof(mh))) != 0)
 2971         return(error);
 2972 
 2973     /* spin waiting for a status update */
 2974     s = splcam();
 2975     error = EWOULDBLOCK;
 2976     while ((error != 0) && (sc->mly_event_change == mh.change_counter))
 2977         error = tsleep(&sc->mly_event_change, PRIBIO | PCATCH, "mlyhealth", 0);
 2978     splx(s);
 2979     
 2980     /* copy the controller's health status buffer out (there is a race here if it changes again) */
 2981     error = copyout(&sc->mly_mmbox->mmm_health.status, uh->HealthStatusBuffer, 
 2982                     sizeof(uh->HealthStatusBuffer));
 2983     return(error);
 2984 }
 2985 
 2986 static int
 2987 mly_timeout(struct mly_softc *sc)
 2988 {
 2989         struct mly_command *mc;
 2990         int deadline;
 2991 
 2992         deadline = time_second - MLY_CMD_TIMEOUT;
 2993         TAILQ_FOREACH(mc, &sc->mly_busy, mc_link) {
 2994                 if ((mc->mc_timestamp < deadline)) {
 2995                         device_printf(sc->mly_dev,
 2996                             "COMMAND %p TIMEOUT AFTER %d SECONDS\n", mc,
 2997                             (int)(time_second - mc->mc_timestamp));
 2998                 }
 2999         }
 3000 
 3001         timeout((timeout_t *)mly_timeout, sc, MLY_CMD_TIMEOUT * hz);
 3002 
 3003         return (0);
 3004 }

Cache object: 75949056cc82fb1c9c091ec0c8b11ca8


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