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/twa/tw_osl_freebsd.c

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

    1 /*
    2  * Copyright (c) 2004-07 Applied Micro Circuits Corporation.
    3  * Copyright (c) 2004-05 Vinod Kashyap.
    4  * Copyright (c) 2000 Michael Smith
    5  * Copyright (c) 2000 BSDi
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   27  * SUCH DAMAGE.
   28  *
   29  *      $FreeBSD: releng/6.4/sys/dev/twa/tw_osl_freebsd.c 173048 2007-10-26 23:51:46Z scottl $
   30  */
   31 
   32 /*
   33  * AMCC'S 3ware driver for 9000 series storage controllers.
   34  *
   35  * Author: Vinod Kashyap
   36  * Modifications by: Adam Radford
   37  */
   38 
   39 
   40 /*
   41  * FreeBSD specific functions not related to CAM, and other
   42  * miscellaneous functions.
   43  */
   44 
   45 
   46 #include <dev/twa/tw_osl_includes.h>
   47 #include <dev/twa/tw_cl_fwif.h>
   48 #include <dev/twa/tw_cl_ioctl.h>
   49 #include <dev/twa/tw_osl_ioctl.h>
   50 
   51 #ifdef TW_OSL_DEBUG
   52 TW_INT32        TW_DEBUG_LEVEL_FOR_OSL = TW_OSL_DEBUG;
   53 TW_INT32        TW_OSL_DEBUG_LEVEL_FOR_CL = TW_OSL_DEBUG;
   54 #endif /* TW_OSL_DEBUG */
   55 
   56 MALLOC_DEFINE(TW_OSLI_MALLOC_CLASS, "twa_commands", "twa commands");
   57 
   58 
   59 static  d_open_t                twa_open;
   60 static  d_close_t               twa_close;
   61 static  d_ioctl_t               twa_ioctl;
   62 
   63 static struct cdevsw twa_cdevsw = {
   64         .d_version =    D_VERSION,
   65         .d_open =       twa_open,
   66         .d_close =      twa_close,
   67         .d_ioctl =      twa_ioctl,
   68         .d_name =       "twa",
   69 };
   70 
   71 static devclass_t       twa_devclass;
   72 
   73 
   74 /*
   75  * Function name:       twa_open
   76  * Description:         Called when the controller is opened.
   77  *                      Simply marks the controller as open.
   78  *
   79  * Input:               dev     -- control device corresponding to the ctlr
   80  *                      flags   -- mode of open
   81  *                      fmt     -- device type (character/block etc.)
   82  *                      proc    -- current process
   83  * Output:              None
   84  * Return value:        0       -- success
   85  *                      non-zero-- failure
   86  */
   87 static TW_INT32
   88 twa_open(struct cdev *dev, TW_INT32 flags, TW_INT32 fmt, d_thread_t *proc)
   89 {
   90         TW_INT32                unit = minor(dev);
   91         struct twa_softc        *sc = devclass_get_softc(twa_devclass, unit);
   92 
   93         tw_osli_dbg_dprintf(5, sc, "entered");
   94         sc->state |= TW_OSLI_CTLR_STATE_OPEN;
   95         return(0);
   96 }
   97 
   98 
   99 
  100 /*
  101  * Function name:       twa_close
  102  * Description:         Called when the controller is closed.
  103  *                      Simply marks the controller as not open.
  104  *
  105  * Input:               dev     -- control device corresponding to the ctlr
  106  *                      flags   -- mode of corresponding open
  107  *                      fmt     -- device type (character/block etc.)
  108  *                      proc    -- current process
  109  * Output:              None
  110  * Return value:        0       -- success
  111  *                      non-zero-- failure
  112  */
  113 static TW_INT32
  114 twa_close(struct cdev *dev, TW_INT32 flags, TW_INT32 fmt, d_thread_t *proc)
  115 {
  116         TW_INT32                unit = minor(dev);
  117         struct twa_softc        *sc = devclass_get_softc(twa_devclass, unit);
  118 
  119         tw_osli_dbg_dprintf(5, sc, "entered");
  120         sc->state &= ~TW_OSLI_CTLR_STATE_OPEN;
  121         return(0);
  122 }
  123 
  124 
  125 
  126 /*
  127  * Function name:       twa_ioctl
  128  * Description:         Called when an ioctl is posted to the controller.
  129  *                      Handles any OS Layer specific cmds, passes the rest
  130  *                      on to the Common Layer.
  131  *
  132  * Input:               dev     -- control device corresponding to the ctlr
  133  *                      cmd     -- ioctl cmd
  134  *                      buf     -- ptr to buffer in kernel memory, which is
  135  *                                 a copy of the input buffer in user-space
  136  *                      flags   -- mode of corresponding open
  137  *                      proc    -- current process
  138  * Output:              buf     -- ptr to buffer in kernel memory, which will
  139  *                                 be copied to the output buffer in user-space
  140  * Return value:        0       -- success
  141  *                      non-zero-- failure
  142  */
  143 static TW_INT32
  144 twa_ioctl(struct cdev *dev, u_long cmd, caddr_t buf, TW_INT32 flags, d_thread_t *proc)
  145 {
  146         struct twa_softc        *sc = (struct twa_softc *)(dev->si_drv1);
  147         TW_INT32                error;
  148 
  149         tw_osli_dbg_dprintf(5, sc, "entered");
  150 
  151         switch (cmd) {
  152         case TW_OSL_IOCTL_FIRMWARE_PASS_THROUGH:
  153                 tw_osli_dbg_dprintf(6, sc, "ioctl: fw_passthru");
  154                 error = tw_osli_fw_passthru(sc, (TW_INT8 *)buf);
  155                 break;
  156 
  157         case TW_OSL_IOCTL_SCAN_BUS:
  158                 /* Request CAM for a bus scan. */
  159                 tw_osli_dbg_dprintf(6, sc, "ioctl: scan bus");
  160                 error = tw_osli_request_bus_scan(sc);
  161                 break;
  162 
  163         default:
  164                 tw_osli_dbg_dprintf(6, sc, "ioctl: 0x%lx", cmd);
  165                 error = tw_cl_ioctl(&sc->ctlr_handle, cmd, buf);
  166                 break;
  167         }
  168         return(error);
  169 }
  170 
  171 
  172 
  173 static TW_INT32 twa_probe(device_t dev);
  174 static TW_INT32 twa_attach(device_t dev);
  175 static TW_INT32 twa_detach(device_t dev);
  176 static TW_INT32 twa_shutdown(device_t dev);
  177 static TW_VOID  twa_busdma_lock(TW_VOID *lock_arg, bus_dma_lock_op_t op);
  178 static TW_VOID  twa_pci_intr(TW_VOID *arg);
  179 #ifdef TW_OSLI_DEFERRED_INTR_USED
  180 static TW_VOID  twa_deferred_intr(TW_VOID *context, TW_INT32 pending);
  181 #endif /* TW_OSLI_DEFERRED_INTR_USED */
  182 
  183 static TW_INT32 tw_osli_alloc_mem(struct twa_softc *sc);
  184 static TW_VOID  tw_osli_free_resources(struct twa_softc *sc);
  185 
  186 static TW_VOID  twa_map_load_data_callback(TW_VOID *arg,
  187         bus_dma_segment_t *segs, TW_INT32 nsegments, TW_INT32 error);
  188 static TW_VOID  twa_map_load_callback(TW_VOID *arg,
  189         bus_dma_segment_t *segs, TW_INT32 nsegments, TW_INT32 error);
  190 
  191 
  192 static device_method_t  twa_methods[] = {
  193         /* Device interface */
  194         DEVMETHOD(device_probe,         twa_probe),
  195         DEVMETHOD(device_attach,        twa_attach),
  196         DEVMETHOD(device_detach,        twa_detach),
  197         DEVMETHOD(device_shutdown,      twa_shutdown),
  198 
  199         DEVMETHOD(bus_print_child,      bus_generic_print_child),
  200         DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
  201         {0, 0}
  202 };
  203 
  204 static driver_t twa_pci_driver = {
  205         "twa",
  206         twa_methods,
  207         sizeof(struct twa_softc)
  208 };
  209 
  210 DRIVER_MODULE(twa, pci, twa_pci_driver, twa_devclass, 0, 0);
  211 MODULE_DEPEND(twa, cam, 1, 1, 1);
  212 MODULE_DEPEND(twa, pci, 1, 1, 1);
  213 
  214 
  215 /*
  216  * Function name:       twa_probe
  217  * Description:         Called at driver load time.  Claims 9000 ctlrs.
  218  *
  219  * Input:               dev     -- bus device corresponding to the ctlr
  220  * Output:              None
  221  * Return value:        <= 0    -- success
  222  *                      > 0     -- failure
  223  */
  224 static TW_INT32
  225 twa_probe(device_t dev)
  226 {
  227         static TW_UINT8 first_ctlr = 1;
  228 
  229         tw_osli_dbg_printf(3, "entered");
  230 
  231         if (tw_cl_ctlr_supported(pci_get_vendor(dev), pci_get_device(dev))) {
  232                 device_set_desc(dev, TW_OSLI_DEVICE_NAME);
  233                 /* Print the driver version only once. */
  234                 if (first_ctlr) {
  235                         printf("3ware device driver for 9000 series storage "
  236                                 "controllers, version: %s\n",
  237                                 TW_OSL_DRIVER_VERSION_STRING);
  238                         first_ctlr = 0;
  239                 }
  240                 return(0);
  241         }
  242         return(ENXIO);
  243 }
  244 
  245 
  246 
  247 /*
  248  * Function name:       twa_attach
  249  * Description:         Allocates pci resources; updates sc; adds a node to the
  250  *                      sysctl tree to expose the driver version; makes calls
  251  *                      (to the Common Layer) to initialize ctlr, and to
  252  *                      attach to CAM.
  253  *
  254  * Input:               dev     -- bus device corresponding to the ctlr
  255  * Output:              None
  256  * Return value:        0       -- success
  257  *                      non-zero-- failure
  258  */
  259 static TW_INT32
  260 twa_attach(device_t dev)
  261 {
  262         struct twa_softc        *sc = device_get_softc(dev);
  263         TW_UINT32               command;
  264         TW_INT32                bar_num;
  265         TW_INT32                bar0_offset;
  266         TW_INT32                bar_size;
  267         TW_INT32                error;
  268 
  269         tw_osli_dbg_dprintf(3, sc, "entered");
  270 
  271         sc->ctlr_handle.osl_ctlr_ctxt = sc;
  272 
  273         /* Initialize the softc structure. */
  274         sc->bus_dev = dev;
  275         sc->device_id = pci_get_device(dev);
  276 
  277         /* Initialize the mutexes right here. */
  278         sc->io_lock = &(sc->io_lock_handle);
  279         mtx_init(sc->io_lock, "tw_osl_io_lock", NULL, MTX_SPIN);
  280         sc->q_lock = &(sc->q_lock_handle);
  281         mtx_init(sc->q_lock, "tw_osl_q_lock", NULL, MTX_SPIN);
  282 
  283         sysctl_ctx_init(&sc->sysctl_ctxt);
  284         sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctxt,
  285                 SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
  286                 device_get_nameunit(dev), CTLFLAG_RD, 0, "");
  287         if (sc->sysctl_tree == NULL) {
  288                 tw_osli_printf(sc, "error = %d",
  289                         TW_CL_SEVERITY_ERROR_STRING,
  290                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  291                         0x2000,
  292                         "Cannot add sysctl tree node",
  293                         ENXIO);
  294                 return(ENXIO);
  295         }
  296         SYSCTL_ADD_STRING(&sc->sysctl_ctxt, SYSCTL_CHILDREN(sc->sysctl_tree),
  297                 OID_AUTO, "driver_version", CTLFLAG_RD,
  298                 TW_OSL_DRIVER_VERSION_STRING, 0, "TWA driver version");
  299 
  300         /* Make sure we are going to be able to talk to this board. */
  301         command = pci_read_config(dev, PCIR_COMMAND, 2);
  302         if ((command & PCIM_CMD_PORTEN) == 0) {
  303                 tw_osli_printf(sc, "error = %d",
  304                         TW_CL_SEVERITY_ERROR_STRING,
  305                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  306                         0x2001,
  307                         "Register window not available",
  308                         ENXIO);
  309                 tw_osli_free_resources(sc);
  310                 return(ENXIO);
  311         }
  312 
  313         /* Force the busmaster enable bit on, in case the BIOS forgot. */
  314         command |= PCIM_CMD_BUSMASTEREN;
  315         pci_write_config(dev, PCIR_COMMAND, command, 2);
  316 
  317         /* Allocate the PCI register window. */
  318         if ((error = tw_cl_get_pci_bar_info(sc->device_id, TW_CL_BAR_TYPE_MEM,
  319                 &bar_num, &bar0_offset, &bar_size))) {
  320                 tw_osli_printf(sc, "error = %d",
  321                         TW_CL_SEVERITY_ERROR_STRING,
  322                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  323                         0x201F,
  324                         "Can't get PCI BAR info",
  325                         error);
  326                 tw_osli_free_resources(sc);
  327                 return(error);
  328         }
  329         sc->reg_res_id = PCIR_BARS + bar0_offset;
  330         if ((sc->reg_res = bus_alloc_resource(dev, SYS_RES_MEMORY,
  331                                 &(sc->reg_res_id), 0, ~0, 1, RF_ACTIVE))
  332                                 == NULL) {
  333                 tw_osli_printf(sc, "error = %d",
  334                         TW_CL_SEVERITY_ERROR_STRING,
  335                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  336                         0x2002,
  337                         "Can't allocate register window",
  338                         ENXIO);
  339                 tw_osli_free_resources(sc);
  340                 return(ENXIO);
  341         }
  342         sc->bus_tag = rman_get_bustag(sc->reg_res);
  343         sc->bus_handle = rman_get_bushandle(sc->reg_res);
  344 
  345         /* Allocate and register our interrupt. */
  346         sc->irq_res_id = 0;
  347         if ((sc->irq_res = bus_alloc_resource(sc->bus_dev, SYS_RES_IRQ,
  348                                 &(sc->irq_res_id), 0, ~0, 1,
  349                                 RF_SHAREABLE | RF_ACTIVE)) == NULL) {
  350                 tw_osli_printf(sc, "error = %d",
  351                         TW_CL_SEVERITY_ERROR_STRING,
  352                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  353                         0x2003,
  354                         "Can't allocate interrupt",
  355                         ENXIO);
  356                 tw_osli_free_resources(sc);
  357                 return(ENXIO);
  358         }
  359         if ((error = bus_setup_intr(sc->bus_dev, sc->irq_res,
  360                         ((mp_ncpus > 1) ? (INTR_MPSAFE
  361 #ifdef TW_OSLI_DEFERRED_INTR_USED
  362                         | INTR_FAST
  363 #endif /* TW_OSLI_DEFERRED_INTR_USED */
  364                         ) : 0) | INTR_TYPE_CAM,
  365                         twa_pci_intr, sc, &sc->intr_handle))) {
  366                 tw_osli_printf(sc, "error = %d",
  367                         TW_CL_SEVERITY_ERROR_STRING,
  368                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  369                         0x2004,
  370                         "Can't set up interrupt",
  371                         error);
  372                 tw_osli_free_resources(sc);
  373                 return(error);
  374         }
  375 
  376 #ifdef TW_OSLI_DEFERRED_INTR_USED
  377         TASK_INIT(&sc->deferred_intr_callback, 0, twa_deferred_intr, sc);
  378 #endif /* TW_OSLI_DEFERRED_INTR_USED */
  379 
  380         if ((error = tw_osli_alloc_mem(sc))) {
  381                 tw_osli_printf(sc, "error = %d",
  382                         TW_CL_SEVERITY_ERROR_STRING,
  383                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  384                         0x2005,
  385                         "Memory allocation failure",
  386                         error);
  387                 tw_osli_free_resources(sc);
  388                 return(error);
  389         }
  390 
  391         /* Initialize the Common Layer for this controller. */
  392         if ((error = tw_cl_init_ctlr(&sc->ctlr_handle, sc->flags, sc->device_id,
  393                         TW_OSLI_MAX_NUM_IOS, TW_OSLI_MAX_NUM_AENS,
  394                         sc->non_dma_mem, sc->dma_mem,
  395                         sc->dma_mem_phys
  396                         ))) {
  397                 tw_osli_printf(sc, "error = %d",
  398                         TW_CL_SEVERITY_ERROR_STRING,
  399                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  400                         0x2006,
  401                         "Failed to initialize Common Layer/controller",
  402                         error);
  403                 tw_osli_free_resources(sc);
  404                 return(error);
  405         }
  406 
  407         /* Create the control device. */
  408         sc->ctrl_dev = make_dev(&twa_cdevsw, device_get_unit(sc->bus_dev),
  409                         UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR,
  410                         "twa%d", device_get_unit(sc->bus_dev));
  411         sc->ctrl_dev->si_drv1 = sc;
  412 
  413         if ((error = tw_osli_cam_attach(sc))) {
  414                 tw_osli_free_resources(sc);
  415                 tw_osli_printf(sc, "error = %d",
  416                         TW_CL_SEVERITY_ERROR_STRING,
  417                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  418                         0x2007,
  419                         "Failed to initialize CAM",
  420                         error);
  421                 return(error);
  422         }
  423 
  424         return(0);
  425 }
  426 
  427 
  428 
  429 /*
  430  * Function name:       tw_osli_alloc_mem
  431  * Description:         Allocates memory needed both by CL and OSL.
  432  *
  433  * Input:               sc      -- OSL internal controller context
  434  * Output:              None
  435  * Return value:        0       -- success
  436  *                      non-zero-- failure
  437  */
  438 static TW_INT32
  439 tw_osli_alloc_mem(struct twa_softc *sc)
  440 {
  441         struct tw_osli_req_context      *req;
  442         TW_UINT32                       max_sg_elements;
  443         TW_UINT32                       non_dma_mem_size;
  444         TW_UINT32                       dma_mem_size;
  445         TW_INT32                        error;
  446         TW_INT32                        i;
  447 
  448         tw_osli_dbg_dprintf(3, sc, "entered");
  449 
  450         sc->flags |= (sizeof(bus_addr_t) == 8) ? TW_CL_64BIT_ADDRESSES : 0;
  451         sc->flags |= (sizeof(bus_size_t) == 8) ? TW_CL_64BIT_SG_LENGTH : 0;
  452 #ifdef TW_OSLI_DEFERRED_INTR_USED
  453         sc->flags |= TW_CL_DEFERRED_INTR_USED; 
  454 #endif /* TW_OSLI_DEFERRED_INTR_USED */
  455 
  456         max_sg_elements = (sizeof(bus_addr_t) == 8) ?
  457                 TW_CL_MAX_64BIT_SG_ELEMENTS : TW_CL_MAX_32BIT_SG_ELEMENTS;
  458 
  459         if ((error = tw_cl_get_mem_requirements(&sc->ctlr_handle, sc->flags,
  460                         sc->device_id, TW_OSLI_MAX_NUM_IOS,  TW_OSLI_MAX_NUM_AENS,
  461                         &(sc->alignment), &(sc->sg_size_factor),
  462                         &non_dma_mem_size, &dma_mem_size
  463                         ))) {
  464                 tw_osli_printf(sc, "error = %d",
  465                         TW_CL_SEVERITY_ERROR_STRING,
  466                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  467                         0x2008,
  468                         "Can't get Common Layer's memory requirements",
  469                         error);
  470                 return(error);
  471         }
  472 
  473         if ((sc->non_dma_mem = malloc(non_dma_mem_size, TW_OSLI_MALLOC_CLASS,
  474                                 M_WAITOK)) == NULL) {
  475                 tw_osli_printf(sc, "error = %d",
  476                         TW_CL_SEVERITY_ERROR_STRING,
  477                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  478                         0x2009,
  479                         "Can't allocate non-dma memory",
  480                         ENOMEM);
  481                 return(ENOMEM);
  482         }
  483 
  484         /* Create the parent dma tag. */
  485         if (bus_dma_tag_create(NULL,                    /* parent */
  486                                 sc->alignment,          /* alignment */
  487                                 0,                      /* boundary */
  488                                 BUS_SPACE_MAXADDR,      /* lowaddr */
  489                                 BUS_SPACE_MAXADDR,      /* highaddr */
  490                                 NULL, NULL,             /* filter, filterarg */
  491                                 TW_CL_MAX_IO_SIZE,      /* maxsize */
  492                                 max_sg_elements,        /* nsegments */
  493                                 TW_CL_MAX_IO_SIZE,      /* maxsegsize */
  494                                 0,                      /* flags */
  495                                 NULL,                   /* lockfunc */
  496                                 NULL,                   /* lockfuncarg */
  497                                 &sc->parent_tag         /* tag */)) {
  498                 tw_osli_printf(sc, "error = %d",
  499                         TW_CL_SEVERITY_ERROR_STRING,
  500                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  501                         0x200A,
  502                         "Can't allocate parent DMA tag",
  503                         ENOMEM);
  504                 return(ENOMEM);
  505         }
  506 
  507         /* Create a dma tag for Common Layer's DMA'able memory (dma_mem). */
  508         if (bus_dma_tag_create(sc->parent_tag,          /* parent */
  509                                 sc->alignment,          /* alignment */
  510                                 0,                      /* boundary */
  511                                 BUS_SPACE_MAXADDR,      /* lowaddr */
  512                                 BUS_SPACE_MAXADDR,      /* highaddr */
  513                                 NULL, NULL,             /* filter, filterarg */
  514                                 dma_mem_size,           /* maxsize */
  515                                 1,                      /* nsegments */
  516                                 BUS_SPACE_MAXSIZE,      /* maxsegsize */
  517                                 0,                      /* flags */
  518                                 NULL,                   /* lockfunc */
  519                                 NULL,                   /* lockfuncarg */
  520                                 &sc->cmd_tag            /* tag */)) {
  521                 tw_osli_printf(sc, "error = %d",
  522                         TW_CL_SEVERITY_ERROR_STRING,
  523                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  524                         0x200B,
  525                         "Can't allocate DMA tag for Common Layer's "
  526                         "DMA'able memory",
  527                         ENOMEM);
  528                 return(ENOMEM);
  529         }
  530 
  531         if (bus_dmamem_alloc(sc->cmd_tag, &sc->dma_mem,
  532                 BUS_DMA_NOWAIT, &sc->cmd_map)) {
  533                 /* Try a second time. */
  534                 if (bus_dmamem_alloc(sc->cmd_tag, &sc->dma_mem,
  535                         BUS_DMA_NOWAIT, &sc->cmd_map)) {
  536                         tw_osli_printf(sc, "error = %d",
  537                                 TW_CL_SEVERITY_ERROR_STRING,
  538                                 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  539                                 0x200C,
  540                                 "Can't allocate DMA'able memory for the"
  541                                 "Common Layer",
  542                                 ENOMEM);
  543                         return(ENOMEM);
  544                 }
  545         }
  546 
  547         bus_dmamap_load(sc->cmd_tag, sc->cmd_map, sc->dma_mem,
  548                 dma_mem_size, twa_map_load_callback,
  549                 &sc->dma_mem_phys, 0);
  550 
  551         /*
  552          * Create a dma tag for data buffers; size will be the maximum
  553          * possible I/O size (128kB).
  554          */
  555         if (bus_dma_tag_create(sc->parent_tag,          /* parent */
  556                                 sc->alignment,          /* alignment */
  557                                 0,                      /* boundary */
  558                                 BUS_SPACE_MAXADDR,      /* lowaddr */
  559                                 BUS_SPACE_MAXADDR,      /* highaddr */
  560                                 NULL, NULL,             /* filter, filterarg */
  561                                 TW_CL_MAX_IO_SIZE,      /* maxsize */
  562                                 max_sg_elements,        /* nsegments */
  563                                 TW_CL_MAX_IO_SIZE,      /* maxsegsize */
  564                                 BUS_DMA_ALLOCNOW,       /* flags */
  565                                 twa_busdma_lock,        /* lockfunc */
  566                                 sc->io_lock,            /* lockfuncarg */
  567                                 &sc->dma_tag            /* tag */)) {
  568                 tw_osli_printf(sc, "error = %d",
  569                         TW_CL_SEVERITY_ERROR_STRING,
  570                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  571                         0x200F,
  572                         "Can't allocate DMA tag for data buffers",
  573                         ENOMEM);
  574                 return(ENOMEM);
  575         }
  576 
  577         /*
  578          * Create a dma tag for ioctl data buffers; size will be the maximum
  579          * possible I/O size (128kB).
  580          */
  581         if (bus_dma_tag_create(sc->parent_tag,          /* parent */
  582                                 sc->alignment,          /* alignment */
  583                                 0,                      /* boundary */
  584                                 BUS_SPACE_MAXADDR,      /* lowaddr */
  585                                 BUS_SPACE_MAXADDR,      /* highaddr */
  586                                 NULL, NULL,             /* filter, filterarg */
  587                                 TW_CL_MAX_IO_SIZE,      /* maxsize */
  588                                 max_sg_elements,        /* nsegments */
  589                                 TW_CL_MAX_IO_SIZE,      /* maxsegsize */
  590                                 BUS_DMA_ALLOCNOW,       /* flags */
  591                                 twa_busdma_lock,        /* lockfunc */
  592                                 sc->io_lock,            /* lockfuncarg */
  593                                 &sc->ioctl_tag          /* tag */)) {
  594                 tw_osli_printf(sc, "error = %d",
  595                         TW_CL_SEVERITY_ERROR_STRING,
  596                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  597                         0x2010,
  598                         "Can't allocate DMA tag for ioctl data buffers",
  599                         ENOMEM);
  600                 return(ENOMEM);
  601         }
  602 
  603         /* Create just one map for all ioctl request data buffers. */
  604         if (bus_dmamap_create(sc->ioctl_tag, 0, &sc->ioctl_map)) {
  605                 tw_osli_printf(sc, "error = %d",
  606                         TW_CL_SEVERITY_ERROR_STRING,
  607                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  608                         0x2011,
  609                         "Can't create ioctl map",
  610                         ENOMEM);
  611                 return(ENOMEM);
  612         }
  613 
  614 
  615         /* Initialize request queues. */
  616         tw_osli_req_q_init(sc, TW_OSLI_FREE_Q);
  617         tw_osli_req_q_init(sc, TW_OSLI_BUSY_Q);
  618 
  619         if ((sc->req_ctxt_buf = (struct tw_osli_req_context *)
  620                         malloc((sizeof(struct tw_osli_req_context) *
  621                                 TW_OSLI_MAX_NUM_IOS),
  622                                 TW_OSLI_MALLOC_CLASS, M_WAITOK)) == NULL) {
  623                 tw_osli_printf(sc, "error = %d",
  624                         TW_CL_SEVERITY_ERROR_STRING,
  625                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  626                         0x2012,
  627                         "Failed to allocate request packets",
  628                         ENOMEM);
  629                 return(ENOMEM);
  630         }
  631         bzero(sc->req_ctxt_buf,
  632                 sizeof(struct tw_osli_req_context) * TW_OSLI_MAX_NUM_IOS);
  633 
  634         for (i = 0; i < TW_OSLI_MAX_NUM_IOS; i++) {
  635                 req = &(sc->req_ctxt_buf[i]);
  636                 req->ctlr = sc;
  637                 if (bus_dmamap_create(sc->dma_tag, 0, &req->dma_map)) {
  638                         tw_osli_printf(sc, "request # = %d, error = %d",
  639                                 TW_CL_SEVERITY_ERROR_STRING,
  640                                 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  641                                 0x2013,
  642                                 "Can't create dma map",
  643                                 i, ENOMEM);
  644                         return(ENOMEM);
  645                 }
  646 
  647                 /* Insert request into the free queue. */
  648                 tw_osli_req_q_insert_tail(req, TW_OSLI_FREE_Q);
  649         }
  650 
  651         return(0);
  652 }
  653 
  654 
  655 
  656 /*
  657  * Function name:       tw_osli_free_resources
  658  * Description:         Performs clean-up at the time of going down.
  659  *
  660  * Input:               sc      -- ptr to OSL internal ctlr context
  661  * Output:              None
  662  * Return value:        None
  663  */
  664 static TW_VOID
  665 tw_osli_free_resources(struct twa_softc *sc)
  666 {
  667         struct tw_osli_req_context      *req;
  668         TW_INT32                        error = 0;
  669 
  670         tw_osli_dbg_dprintf(3, sc, "entered");
  671 
  672         /* Detach from CAM */
  673         tw_osli_cam_detach(sc);
  674 
  675         if (sc->req_ctxt_buf)
  676                 while ((req = tw_osli_req_q_remove_head(sc, TW_OSLI_FREE_Q)) !=
  677                         NULL)
  678                         if ((error = bus_dmamap_destroy(sc->dma_tag,
  679                                         req->dma_map)))
  680                                 tw_osli_dbg_dprintf(1, sc,
  681                                         "dmamap_destroy(dma) returned %d",
  682                                         error);
  683 
  684         if ((sc->ioctl_tag) && (sc->ioctl_map))
  685                 if ((error = bus_dmamap_destroy(sc->ioctl_tag, sc->ioctl_map)))
  686                         tw_osli_dbg_dprintf(1, sc,
  687                                 "dmamap_destroy(ioctl) returned %d", error);
  688 
  689         /* Free all memory allocated so far. */
  690         if (sc->req_ctxt_buf)
  691                 free(sc->req_ctxt_buf, TW_OSLI_MALLOC_CLASS);
  692 
  693         if (sc->non_dma_mem)
  694                 free(sc->non_dma_mem, TW_OSLI_MALLOC_CLASS);
  695 
  696         if (sc->dma_mem) {
  697                 bus_dmamap_unload(sc->cmd_tag, sc->cmd_map);
  698                 bus_dmamem_free(sc->cmd_tag, sc->dma_mem,
  699                         sc->cmd_map);
  700         }
  701         if (sc->cmd_tag)
  702                 if ((error = bus_dma_tag_destroy(sc->cmd_tag)))
  703                         tw_osli_dbg_dprintf(1, sc,
  704                                 "dma_tag_destroy(cmd) returned %d", error);
  705 
  706         if (sc->dma_tag)
  707                 if ((error = bus_dma_tag_destroy(sc->dma_tag)))
  708                         tw_osli_dbg_dprintf(1, sc,
  709                                 "dma_tag_destroy(dma) returned %d", error);
  710 
  711         if (sc->ioctl_tag)
  712                 if ((error = bus_dma_tag_destroy(sc->ioctl_tag)))
  713                         tw_osli_dbg_dprintf(1, sc,
  714                                 "dma_tag_destroy(ioctl) returned %d", error);
  715 
  716         if (sc->parent_tag)
  717                 if ((error = bus_dma_tag_destroy(sc->parent_tag)))
  718                         tw_osli_dbg_dprintf(1, sc,
  719                                 "dma_tag_destroy(parent) returned %d", error);
  720 
  721 
  722         /* Disconnect the interrupt handler. */
  723         if (sc->intr_handle)
  724                 if ((error = bus_teardown_intr(sc->bus_dev,
  725                                 sc->irq_res, sc->intr_handle)))
  726                         tw_osli_dbg_dprintf(1, sc,
  727                                 "teardown_intr returned %d", error);
  728 
  729         if (sc->irq_res != NULL)
  730                 if ((error = bus_release_resource(sc->bus_dev,
  731                                 SYS_RES_IRQ, sc->irq_res_id, sc->irq_res)))
  732                         tw_osli_dbg_dprintf(1, sc,
  733                                 "release_resource(irq) returned %d", error);
  734 
  735 
  736         /* Release the register window mapping. */
  737         if (sc->reg_res != NULL)
  738                 if ((error = bus_release_resource(sc->bus_dev,
  739                                 SYS_RES_MEMORY, sc->reg_res_id, sc->reg_res)))
  740                         tw_osli_dbg_dprintf(1, sc,
  741                                 "release_resource(io) returned %d", error);
  742 
  743 
  744         /* Destroy the control device. */
  745         if (sc->ctrl_dev != (struct cdev *)NULL)
  746                 destroy_dev(sc->ctrl_dev);
  747 
  748         if ((error = sysctl_ctx_free(&sc->sysctl_ctxt)))
  749                 tw_osli_dbg_dprintf(1, sc,
  750                         "sysctl_ctx_free returned %d", error);
  751 
  752 }
  753 
  754 
  755 
  756 /*
  757  * Function name:       twa_detach
  758  * Description:         Called when the controller is being detached from
  759  *                      the pci bus.
  760  *
  761  * Input:               dev     -- bus device corresponding to the ctlr
  762  * Output:              None
  763  * Return value:        0       -- success
  764  *                      non-zero-- failure
  765  */
  766 static TW_INT32
  767 twa_detach(device_t dev)
  768 {
  769         struct twa_softc        *sc = device_get_softc(dev);
  770         TW_INT32                error;
  771 
  772         tw_osli_dbg_dprintf(3, sc, "entered");
  773 
  774         error = EBUSY;
  775         if (sc->state & TW_OSLI_CTLR_STATE_OPEN) {
  776                 tw_osli_printf(sc, "error = %d",
  777                         TW_CL_SEVERITY_ERROR_STRING,
  778                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  779                         0x2014,
  780                         "Device open",
  781                         error);
  782                 goto out;
  783         }
  784 
  785         /* Shut the controller down. */
  786         if ((error = twa_shutdown(dev)))
  787                 goto out;
  788 
  789         /* Free all resources associated with this controller. */
  790         tw_osli_free_resources(sc);
  791         error = 0;
  792 
  793 out:
  794         return(error);
  795 }
  796 
  797 
  798 
  799 /*
  800  * Function name:       twa_shutdown
  801  * Description:         Called at unload/shutdown time.  Lets the controller
  802  *                      know that we are going down.
  803  *
  804  * Input:               dev     -- bus device corresponding to the ctlr
  805  * Output:              None
  806  * Return value:        0       -- success
  807  *                      non-zero-- failure
  808  */
  809 static TW_INT32
  810 twa_shutdown(device_t dev)
  811 {
  812         struct twa_softc        *sc = device_get_softc(dev);
  813         TW_INT32                error = 0;
  814 
  815         tw_osli_dbg_dprintf(3, sc, "entered");
  816 
  817         /* Disconnect from the controller. */
  818         if ((error = tw_cl_shutdown_ctlr(&(sc->ctlr_handle), 0))) {
  819                 tw_osli_printf(sc, "error = %d",
  820                         TW_CL_SEVERITY_ERROR_STRING,
  821                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  822                         0x2015,
  823                         "Failed to shutdown Common Layer/controller",
  824                         error);
  825         }
  826         return(error);
  827 }
  828 
  829 
  830 
  831 /*
  832  * Function name:       twa_busdma_lock
  833  * Description:         Function to provide synchronization during busdma_swi.
  834  *
  835  * Input:               lock_arg -- lock mutex sent as argument
  836  *                      op -- operation (lock/unlock) expected of the function
  837  * Output:              None
  838  * Return value:        None
  839  */
  840 TW_VOID
  841 twa_busdma_lock(TW_VOID *lock_arg, bus_dma_lock_op_t op)
  842 {
  843         struct mtx      *lock;
  844 
  845         lock = (struct mtx *)lock_arg;
  846         switch (op) {
  847         case BUS_DMA_LOCK:
  848                 mtx_lock_spin(lock);
  849                 break;
  850 
  851         case BUS_DMA_UNLOCK:
  852                 mtx_unlock_spin(lock);
  853                 break;
  854 
  855         default:
  856                 panic("Unknown operation 0x%x for twa_busdma_lock!", op);
  857         }
  858 }
  859 
  860 
  861 
  862 /*
  863  * Function name:       twa_pci_intr
  864  * Description:         Interrupt handler.  Wrapper for twa_interrupt.
  865  *
  866  * Input:               arg     -- ptr to OSL internal ctlr context
  867  * Output:              None
  868  * Return value:        None
  869  */
  870 static TW_VOID
  871 twa_pci_intr(TW_VOID *arg)
  872 {
  873         struct twa_softc        *sc = (struct twa_softc *)arg;
  874 
  875         tw_osli_dbg_dprintf(10, sc, "entered");
  876         if (tw_cl_interrupt(&(sc->ctlr_handle)))
  877 #ifdef TW_OSLI_DEFERRED_INTR_USED
  878                 taskqueue_enqueue_fast(taskqueue_fast,
  879                         &(sc->deferred_intr_callback));
  880 #else /* TW_OSLI_DEFERRED_INTR_USED */
  881                 tw_cl_deferred_interrupt(&(sc->ctlr_handle));
  882 #endif /* TW_OSLI_DEFERRED_INTR_USED */
  883 }
  884 
  885 
  886 
  887 #ifdef TW_OSLI_DEFERRED_INTR_USED
  888 
  889 /*
  890  * Function name:       twa_deferred_intr
  891  * Description:         Deferred interrupt handler.
  892  *
  893  * Input:               context -- ptr to OSL internal ctlr context
  894  *                      pending -- not used
  895  * Output:              None
  896  * Return value:        None
  897  */
  898 static TW_VOID
  899 twa_deferred_intr(TW_VOID *context, TW_INT32 pending)
  900 {
  901         struct twa_softc        *sc = (struct twa_softc *)context;
  902 
  903         tw_osli_dbg_dprintf(10, sc, "entered");
  904 
  905         tw_cl_deferred_interrupt(&(sc->ctlr_handle));
  906 }
  907 
  908 #endif /* TW_OSLI_DEFERRED_INTR_USED */
  909 
  910 
  911 
  912 /*
  913  * Function name:       tw_osli_fw_passthru
  914  * Description:         Builds a fw passthru cmd pkt, and submits it to CL.
  915  *
  916  * Input:               sc      -- ptr to OSL internal ctlr context
  917  *                      buf     -- ptr to ioctl pkt understood by CL
  918  * Output:              None
  919  * Return value:        0       -- success
  920  *                      non-zero-- failure
  921  */
  922 TW_INT32
  923 tw_osli_fw_passthru(struct twa_softc *sc, TW_INT8 *buf)
  924 {
  925         struct tw_osli_req_context              *req;
  926         struct tw_osli_ioctl_no_data_buf        *user_buf =
  927                 (struct tw_osli_ioctl_no_data_buf *)buf;
  928         TW_TIME                                 end_time;
  929         TW_UINT32                               timeout = 60;
  930         TW_UINT32                               data_buf_size_adjusted;
  931         struct tw_cl_req_packet                 *req_pkt;
  932         struct tw_cl_passthru_req_packet        *pt_req;
  933         TW_INT32                                error;
  934 
  935         tw_osli_dbg_dprintf(5, sc, "ioctl: passthru");
  936                 
  937         if ((req = tw_osli_get_request(sc)) == NULL)
  938                 return(EBUSY);
  939 
  940         req->req_handle.osl_req_ctxt = req;
  941         req->orig_req = buf;
  942         req->flags |= TW_OSLI_REQ_FLAGS_PASSTHRU;
  943 
  944         req_pkt = &(req->req_pkt);
  945         req_pkt->status = 0;
  946         req_pkt->tw_osl_callback = tw_osl_complete_passthru;
  947         /* Let the Common Layer retry the request on cmd queue full. */
  948         req_pkt->flags |= TW_CL_REQ_RETRY_ON_BUSY;
  949 
  950         pt_req = &(req_pkt->gen_req_pkt.pt_req);
  951         /*
  952          * Make sure that the data buffer sent to firmware is a 
  953          * 512 byte multiple in size.
  954          */
  955         data_buf_size_adjusted =
  956                 (user_buf->driver_pkt.buffer_length +
  957                 (sc->sg_size_factor - 1)) & ~(sc->sg_size_factor - 1);
  958         if ((req->length = data_buf_size_adjusted)) {
  959                 if ((req->data = malloc(data_buf_size_adjusted,
  960                         TW_OSLI_MALLOC_CLASS, M_WAITOK)) == NULL) {
  961                         error = ENOMEM;
  962                         tw_osli_printf(sc, "error = %d",
  963                                 TW_CL_SEVERITY_ERROR_STRING,
  964                                 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  965                                 0x2016,
  966                                 "Could not alloc mem for "
  967                                 "fw_passthru data_buf",
  968                                 error);
  969                         goto fw_passthru_err;
  970                 }
  971                 /* Copy the payload. */
  972                 if ((error = copyin((TW_VOID *)(user_buf->pdata), 
  973                         req->data,
  974                         user_buf->driver_pkt.buffer_length)) != 0) {
  975                         tw_osli_printf(sc, "error = %d",
  976                                 TW_CL_SEVERITY_ERROR_STRING,
  977                                 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  978                                 0x2017,
  979                                 "Could not copyin fw_passthru data_buf",
  980                                 error);
  981                         goto fw_passthru_err;
  982                 }
  983                 pt_req->sgl_entries = 1; /* will be updated during mapping */
  984                 req->flags |= (TW_OSLI_REQ_FLAGS_DATA_IN |
  985                         TW_OSLI_REQ_FLAGS_DATA_OUT);
  986         } else
  987                 pt_req->sgl_entries = 0; /* no payload */
  988 
  989         pt_req->cmd_pkt = (TW_VOID *)(&(user_buf->cmd_pkt));
  990         pt_req->cmd_pkt_length = sizeof(struct tw_cl_command_packet);
  991 
  992         if ((error = tw_osli_map_request(req)))
  993                 goto fw_passthru_err;
  994 
  995         end_time = tw_osl_get_local_time() + timeout;
  996         while (req->state != TW_OSLI_REQ_STATE_COMPLETE) {
  997                 req->flags |= TW_OSLI_REQ_FLAGS_SLEEPING;
  998                 
  999                 error = tsleep(req, PRIBIO, "twa_passthru", timeout * hz);
 1000 
 1001                 if (!(req->flags & TW_OSLI_REQ_FLAGS_SLEEPING))
 1002                         error = 0;
 1003                 req->flags &= ~TW_OSLI_REQ_FLAGS_SLEEPING;
 1004 
 1005                 if (! error) {
 1006                         if (((error = req->error_code)) ||
 1007                                 ((error = (req->state !=
 1008                                 TW_OSLI_REQ_STATE_COMPLETE))) ||
 1009                                 ((error = req_pkt->status)))
 1010                                 goto fw_passthru_err;
 1011                         break;
 1012                 }
 1013 
 1014                 if (req_pkt->status) {
 1015                         error = req_pkt->status;
 1016                         goto fw_passthru_err;
 1017                 }
 1018 
 1019                 if (error == EWOULDBLOCK) {
 1020                         /* Time out! */
 1021                         tw_osli_printf(sc, "request = %p",
 1022                                 TW_CL_SEVERITY_ERROR_STRING,
 1023                                 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 1024                                 0x2018,
 1025                                 "Passthru request timed out!",
 1026                                 req);
 1027                         /*
 1028                          * Should I check here if the timeout happened
 1029                          * because of yet another reset, and not do a
 1030                          * second reset?
 1031                          */
 1032                         tw_cl_reset_ctlr(&sc->ctlr_handle);
 1033                         /*
 1034                          * Don't touch req after a reset.  It (and any
 1035                          * associated data) will already have been
 1036                          * unmapped by the callback.
 1037                          */
 1038                         user_buf->driver_pkt.os_status = error;
 1039                         error = ETIMEDOUT;
 1040                         goto fw_passthru_err;
 1041                 }
 1042                 /* 
 1043                  * Either the request got completed, or we were woken up by a
 1044                  * signal.  Calculate the new timeout, in case it was the latter.
 1045                  */
 1046                 timeout = (end_time - tw_osl_get_local_time());
 1047         }
 1048 
 1049         /* If there was a payload, copy it back. */
 1050         if ((!error) && (req->length))
 1051                 if ((error = copyout(req->data, user_buf->pdata,
 1052                         user_buf->driver_pkt.buffer_length)))
 1053                         tw_osli_printf(sc, "error = %d",
 1054                                 TW_CL_SEVERITY_ERROR_STRING,
 1055                                 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 1056                                 0x2019,
 1057                                 "Could not copyout fw_passthru data_buf",
 1058                                 error);
 1059         
 1060 fw_passthru_err:
 1061         /*
 1062          * Print the failure message.  For some reason, on certain OS versions,
 1063          * printing this error message during reset hangs the display (although
 1064          * the rest of the system is running fine.  So, don't print it if the
 1065          * failure was due to a reset.
 1066          */
 1067         if ((error) && (error != TW_CL_ERR_REQ_BUS_RESET))
 1068                 tw_osli_printf(sc, "error = %d",                
 1069                         TW_CL_SEVERITY_ERROR_STRING,
 1070                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 1071                         0x201A,
 1072                         "Firmware passthru failed!",
 1073                         error);
 1074 
 1075         user_buf->driver_pkt.os_status = error;
 1076         /* Free resources. */
 1077         if (req->data)
 1078                 free(req->data, TW_OSLI_MALLOC_CLASS);
 1079         tw_osli_req_q_insert_tail(req, TW_OSLI_FREE_Q);
 1080         return(error);
 1081 }
 1082 
 1083 
 1084 
 1085 /*
 1086  * Function name:       tw_osl_complete_passthru
 1087  * Description:         Called to complete passthru requests.
 1088  *
 1089  * Input:               req_handle      -- ptr to request handle
 1090  * Output:              None
 1091  * Return value:        None
 1092  */
 1093 TW_VOID
 1094 tw_osl_complete_passthru(struct tw_cl_req_handle *req_handle)
 1095 {
 1096         struct tw_osli_req_context      *req = req_handle->osl_req_ctxt;
 1097         struct twa_softc                *sc = req->ctlr;
 1098 
 1099         tw_osli_dbg_dprintf(5, sc, "entered");
 1100 
 1101         if (req->state != TW_OSLI_REQ_STATE_BUSY) {
 1102                 tw_osli_printf(sc, "request = %p, status = %d",
 1103                         TW_CL_SEVERITY_ERROR_STRING,
 1104                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 1105                         0x201B,
 1106                         "Unposted command completed!!",
 1107                         req, req->state);
 1108         }
 1109 
 1110         /*
 1111          * Remove request from the busy queue.  Just mark it complete.
 1112          * There's no need to move it into the complete queue as we are
 1113          * going to be done with it right now.
 1114          */
 1115         req->state = TW_OSLI_REQ_STATE_COMPLETE;
 1116         tw_osli_req_q_remove_item(req, TW_OSLI_BUSY_Q);
 1117 
 1118         tw_osli_unmap_request(req);
 1119 
 1120         /*
 1121          * Don't do a wake up if there was an error even before the request
 1122          * was sent down to the Common Layer, and we hadn't gotten an
 1123          * EINPROGRESS.  The request originator will then be returned an
 1124          * error, and he can do the clean-up.
 1125          */
 1126         if ((req->error_code) &&
 1127                 (!(req->state & TW_OSLI_REQ_FLAGS_IN_PROGRESS)))
 1128                 return;
 1129 
 1130         if (req->flags & TW_OSLI_REQ_FLAGS_PASSTHRU) {
 1131                 if (req->flags & TW_OSLI_REQ_FLAGS_SLEEPING) {
 1132                         /* Wake up the sleeping command originator. */
 1133                         tw_osli_dbg_dprintf(5, sc,
 1134                                 "Waking up originator of request %p", req);
 1135                         req->flags &= ~TW_OSLI_REQ_FLAGS_SLEEPING;
 1136                         wakeup_one(req);
 1137                 } else {
 1138                         /*
 1139                          * If the request completed even before tsleep
 1140                          * was called, simply return.
 1141                          */
 1142                         if (req->flags & TW_OSLI_REQ_FLAGS_MAPPED)
 1143                                 return;
 1144 
 1145                         tw_osli_printf(sc, "request = %p",
 1146                                 TW_CL_SEVERITY_ERROR_STRING,
 1147                                 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 1148                                 0x201C,
 1149                                 "Passthru callback called, "
 1150                                 "and caller not sleeping",
 1151                                 req);
 1152                 }
 1153         } else {
 1154                 tw_osli_printf(sc, "request = %p",
 1155                         TW_CL_SEVERITY_ERROR_STRING,
 1156                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 1157                         0x201D,
 1158                         "Passthru callback called for non-passthru request",
 1159                         req);
 1160         }
 1161 }
 1162 
 1163 
 1164 
 1165 /*
 1166  * Function name:       tw_osli_get_request
 1167  * Description:         Gets a request pkt from the free queue.
 1168  *
 1169  * Input:               sc      -- ptr to OSL internal ctlr context
 1170  * Output:              None
 1171  * Return value:        ptr to request pkt      -- success
 1172  *                      NULL                    -- failure
 1173  */
 1174 struct tw_osli_req_context *
 1175 tw_osli_get_request(struct twa_softc *sc)
 1176 {
 1177         struct tw_osli_req_context      *req;
 1178 
 1179         tw_osli_dbg_dprintf(4, sc, "entered");
 1180 
 1181         /* Get a free request packet. */
 1182         req = tw_osli_req_q_remove_head(sc, TW_OSLI_FREE_Q);
 1183 
 1184         /* Initialize some fields to their defaults. */
 1185         if (req) {
 1186                 req->req_handle.osl_req_ctxt = NULL;
 1187                 req->req_handle.cl_req_ctxt = NULL;
 1188                 req->data = NULL;
 1189                 req->length = 0;
 1190                 req->real_data = NULL;
 1191                 req->real_length = 0;
 1192                 req->state = TW_OSLI_REQ_STATE_INIT;/* req being initialized */
 1193                 req->flags = 0;
 1194                 req->error_code = 0;
 1195                 req->orig_req = NULL;
 1196 
 1197                 bzero(&(req->req_pkt), sizeof(struct tw_cl_req_packet));
 1198 
 1199         }
 1200         return(req);
 1201 }
 1202 
 1203 
 1204 
 1205 /*
 1206  * Function name:       twa_map_load_data_callback
 1207  * Description:         Callback of bus_dmamap_load for the buffer associated
 1208  *                      with data.  Updates the cmd pkt (size/sgl_entries
 1209  *                      fields, as applicable) to reflect the number of sg
 1210  *                      elements.
 1211  *
 1212  * Input:               arg     -- ptr to OSL internal request context
 1213  *                      segs    -- ptr to a list of segment descriptors
 1214  *                      nsegments--# of segments
 1215  *                      error   -- 0 if no errors encountered before callback,
 1216  *                                 non-zero if errors were encountered
 1217  * Output:              None
 1218  * Return value:        None
 1219  */
 1220 static TW_VOID
 1221 twa_map_load_data_callback(TW_VOID *arg, bus_dma_segment_t *segs,
 1222         TW_INT32 nsegments, TW_INT32 error)
 1223 {
 1224         struct tw_osli_req_context      *req =
 1225                 (struct tw_osli_req_context *)arg;
 1226         struct twa_softc                *sc = req->ctlr;
 1227         struct tw_cl_req_packet         *req_pkt = &(req->req_pkt);
 1228 
 1229         tw_osli_dbg_dprintf(10, sc, "entered");
 1230 
 1231         /* Mark the request as currently being processed. */
 1232         req->state = TW_OSLI_REQ_STATE_BUSY;
 1233         /* Move the request into the busy queue. */
 1234         tw_osli_req_q_insert_tail(req, TW_OSLI_BUSY_Q);
 1235 
 1236         req->flags |= TW_OSLI_REQ_FLAGS_MAPPED;
 1237         if (req->flags & TW_OSLI_REQ_FLAGS_IN_PROGRESS)
 1238                 tw_osli_allow_new_requests(sc, (TW_VOID *)(req->orig_req));
 1239 
 1240         if (error == EFBIG) {
 1241                 req->error_code = error;
 1242                 goto out;
 1243         }
 1244 
 1245         if (req->flags & TW_OSLI_REQ_FLAGS_PASSTHRU) {
 1246                 struct tw_cl_passthru_req_packet        *pt_req;
 1247 
 1248                 if (req->flags & TW_OSLI_REQ_FLAGS_DATA_IN)
 1249                         bus_dmamap_sync(sc->ioctl_tag, sc->ioctl_map,
 1250                                 BUS_DMASYNC_PREREAD);
 1251 
 1252                 if (req->flags & TW_OSLI_REQ_FLAGS_DATA_OUT) {
 1253                         /* 
 1254                          * If we're using an alignment buffer, and we're
 1255                          * writing data, copy the real data out.
 1256                          */
 1257                         if (req->flags & TW_OSLI_REQ_FLAGS_DATA_COPY_NEEDED)
 1258                                 bcopy(req->real_data, req->data, req->real_length);
 1259                         bus_dmamap_sync(sc->ioctl_tag, sc->ioctl_map,
 1260                                 BUS_DMASYNC_PREWRITE);
 1261                 }
 1262 
 1263                 pt_req = &(req_pkt->gen_req_pkt.pt_req);
 1264                 pt_req->sg_list = (TW_UINT8 *)segs;
 1265                 pt_req->sgl_entries += (nsegments - 1);
 1266                 error = tw_cl_fw_passthru(&(sc->ctlr_handle), req_pkt,
 1267                         &(req->req_handle));
 1268         } else {
 1269                 struct tw_cl_scsi_req_packet    *scsi_req;
 1270 
 1271                 if (req->flags & TW_OSLI_REQ_FLAGS_DATA_IN)
 1272                         bus_dmamap_sync(sc->dma_tag, req->dma_map,
 1273                                 BUS_DMASYNC_PREREAD);
 1274 
 1275                 if (req->flags & TW_OSLI_REQ_FLAGS_DATA_OUT) {
 1276                         /* 
 1277                          * If we're using an alignment buffer, and we're
 1278                          * writing data, copy the real data out.
 1279                          */
 1280                         if (req->flags & TW_OSLI_REQ_FLAGS_DATA_COPY_NEEDED)
 1281                                 bcopy(req->real_data, req->data, req->real_length);
 1282                         bus_dmamap_sync(sc->dma_tag, req->dma_map,
 1283                                 BUS_DMASYNC_PREWRITE);
 1284                 }
 1285 
 1286                 scsi_req = &(req_pkt->gen_req_pkt.scsi_req);
 1287                 scsi_req->sg_list = (TW_UINT8 *)segs;
 1288                 scsi_req->sgl_entries += (nsegments - 1);
 1289                 error = tw_cl_start_io(&(sc->ctlr_handle), req_pkt,
 1290                         &(req->req_handle));
 1291         }
 1292 
 1293 out:
 1294         if (error) {
 1295                 req->error_code = error;
 1296                 req_pkt->tw_osl_callback(&(req->req_handle));
 1297                 /*
 1298                  * If the caller had been returned EINPROGRESS, and he has
 1299                  * registered a callback for handling completion, the callback
 1300                  * will never get called because we were unable to submit the
 1301                  * request.  So, free up the request right here.
 1302                  */
 1303                 if (req->flags & TW_OSLI_REQ_FLAGS_IN_PROGRESS)
 1304                         tw_osli_req_q_insert_tail(req, TW_OSLI_FREE_Q);
 1305         }
 1306 }
 1307 
 1308 
 1309 
 1310 /*
 1311  * Function name:       twa_map_load_callback
 1312  * Description:         Callback of bus_dmamap_load for the buffer associated
 1313  *                      with a cmd pkt.
 1314  *
 1315  * Input:               arg     -- ptr to variable to hold phys addr
 1316  *                      segs    -- ptr to a list of segment descriptors
 1317  *                      nsegments--# of segments
 1318  *                      error   -- 0 if no errors encountered before callback,
 1319  *                                 non-zero if errors were encountered
 1320  * Output:              None
 1321  * Return value:        None
 1322  */
 1323 static TW_VOID
 1324 twa_map_load_callback(TW_VOID *arg, bus_dma_segment_t *segs,
 1325         TW_INT32 nsegments, TW_INT32 error)
 1326 {
 1327         *((bus_addr_t *)arg) = segs[0].ds_addr;
 1328 }
 1329 
 1330 
 1331 
 1332 /*
 1333  * Function name:       tw_osli_map_request
 1334  * Description:         Maps a cmd pkt and data associated with it, into
 1335  *                      DMA'able memory.
 1336  *
 1337  * Input:               req     -- ptr to request pkt
 1338  * Output:              None
 1339  * Return value:        0       -- success
 1340  *                      non-zero-- failure
 1341  */
 1342 TW_INT32
 1343 tw_osli_map_request(struct tw_osli_req_context *req)
 1344 {
 1345         struct twa_softc        *sc = req->ctlr;
 1346         TW_INT32                error = 0;
 1347 
 1348         tw_osli_dbg_dprintf(10, sc, "entered");
 1349 
 1350         /* If the command involves data, map that too. */
 1351         if (req->data != NULL) {
 1352                 /*
 1353                  * It's sufficient for the data pointer to be 4-byte aligned
 1354                  * to work with 9000.  However, if 4-byte aligned addresses
 1355                  * are passed to bus_dmamap_load, we can get back sg elements
 1356                  * that are not 512-byte multiples in size.  So, we will let
 1357                  * only those buffers that are 512-byte aligned to pass
 1358                  * through, and bounce the rest, so as to make sure that we
 1359                  * always get back sg elements that are 512-byte multiples
 1360                  * in size.
 1361                  */
 1362                 if (((vm_offset_t)req->data % sc->sg_size_factor) ||
 1363                         (req->length % sc->sg_size_factor)) {
 1364                         req->flags |= TW_OSLI_REQ_FLAGS_DATA_COPY_NEEDED;
 1365                         /* Save original data pointer and length. */
 1366                         req->real_data = req->data;
 1367                         req->real_length = req->length;
 1368                         req->length = (req->length +
 1369                                 (sc->sg_size_factor - 1)) &
 1370                                 ~(sc->sg_size_factor - 1);
 1371                         req->data = malloc(req->length, TW_OSLI_MALLOC_CLASS,
 1372                                         M_NOWAIT);
 1373                         if (req->data == NULL) {
 1374                                 tw_osli_printf(sc, "error = %d",
 1375                                         TW_CL_SEVERITY_ERROR_STRING,
 1376                                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
 1377                                         0x201E,
 1378                                         "Failed to allocate memory "
 1379                                         "for bounce buffer",
 1380                                         ENOMEM);
 1381                                 /* Restore original data pointer and length. */
 1382                                 req->data = req->real_data;
 1383                                 req->length = req->real_length;
 1384                                 return(ENOMEM);
 1385                         }
 1386                 }
 1387         
 1388                 /*
 1389                  * Map the data buffer into bus space and build the SG list.
 1390                  */
 1391                 if (req->flags & TW_OSLI_REQ_FLAGS_PASSTHRU) {
 1392                         /* Lock against multiple simultaneous ioctl calls. */
 1393                         mtx_lock_spin(sc->io_lock);
 1394                         error = bus_dmamap_load(sc->ioctl_tag, sc->ioctl_map,
 1395                                 req->data, req->length,
 1396                                 twa_map_load_data_callback, req,
 1397                                 BUS_DMA_WAITOK);
 1398                         mtx_unlock_spin(sc->io_lock);
 1399                 } else {
 1400                         /*
 1401                          * There's only one CAM I/O thread running at a time.
 1402                          * So, there's no need to hold the io_lock.
 1403                          */
 1404                         error = bus_dmamap_load(sc->dma_tag, req->dma_map,
 1405                                 req->data, req->length,
 1406                                 twa_map_load_data_callback, req,
 1407                                 BUS_DMA_WAITOK);
 1408                 }
 1409                 
 1410                 if (!error)
 1411                         error = req->error_code;
 1412                 else {
 1413                         if (error == EINPROGRESS) {
 1414                                 /*
 1415                                  * Specifying sc->io_lock as the lockfuncarg
 1416                                  * in ...tag_create should protect the access
 1417                                  * of ...FLAGS_MAPPED from the callback.
 1418                                  */
 1419                                 mtx_lock_spin(sc->io_lock);
 1420                                 if (!(req->flags & TW_OSLI_REQ_FLAGS_MAPPED)) {
 1421                                         req->flags |=
 1422                                                 TW_OSLI_REQ_FLAGS_IN_PROGRESS;
 1423                                         tw_osli_disallow_new_requests(sc);
 1424                                 }
 1425                                 mtx_unlock_spin(sc->io_lock);
 1426                                 error = 0;
 1427                         } else {
 1428                                 /* Free alignment buffer if it was used. */
 1429                                 if (req->flags &
 1430                                         TW_OSLI_REQ_FLAGS_DATA_COPY_NEEDED) {
 1431                                         free(req->data, TW_OSLI_MALLOC_CLASS);
 1432                                         /*
 1433                                          * Restore original data pointer
 1434                                          * and length.
 1435                                          */
 1436                                         req->data = req->real_data;
 1437                                         req->length = req->real_length;
 1438                                 }
 1439                         }
 1440                 }
 1441 
 1442         } else {
 1443                 /* Mark the request as currently being processed. */
 1444                 req->state = TW_OSLI_REQ_STATE_BUSY;
 1445                 /* Move the request into the busy queue. */
 1446                 tw_osli_req_q_insert_tail(req, TW_OSLI_BUSY_Q);
 1447                 if (req->flags & TW_OSLI_REQ_FLAGS_PASSTHRU)
 1448                         error = tw_cl_fw_passthru(&sc->ctlr_handle,
 1449                                         &(req->req_pkt), &(req->req_handle));
 1450                 else
 1451                         error = tw_cl_start_io(&sc->ctlr_handle,
 1452                                         &(req->req_pkt), &(req->req_handle));
 1453                 if (error) {
 1454                         req->error_code = error;
 1455                         req->req_pkt.tw_osl_callback(&(req->req_handle));
 1456                 }
 1457         }
 1458         return(error);
 1459 }
 1460 
 1461 
 1462 
 1463 /*
 1464  * Function name:       tw_osli_unmap_request
 1465  * Description:         Undoes the mapping done by tw_osli_map_request.
 1466  *
 1467  * Input:               req     -- ptr to request pkt
 1468  * Output:              None
 1469  * Return value:        None
 1470  */
 1471 TW_VOID
 1472 tw_osli_unmap_request(struct tw_osli_req_context *req)
 1473 {
 1474         struct twa_softc        *sc = req->ctlr;
 1475 
 1476         tw_osli_dbg_dprintf(10, sc, "entered");
 1477 
 1478         /* If the command involved data, unmap that too. */
 1479         if (req->data != NULL) {
 1480                 if (req->flags & TW_OSLI_REQ_FLAGS_PASSTHRU) {
 1481                         /* Lock against multiple simultaneous ioctl calls. */
 1482                         mtx_lock_spin(sc->io_lock);
 1483 
 1484                         if (req->flags & TW_OSLI_REQ_FLAGS_DATA_IN) {
 1485                                 bus_dmamap_sync(sc->ioctl_tag,
 1486                                         sc->ioctl_map, BUS_DMASYNC_POSTREAD);
 1487 
 1488                                 /* 
 1489                                  * If we are using a bounce buffer, and we are
 1490                                  * reading data, copy the real data in.
 1491                                  */
 1492                                 if (req->flags & TW_OSLI_REQ_FLAGS_DATA_COPY_NEEDED)
 1493                                         bcopy(req->data, req->real_data,
 1494                                                 req->real_length);
 1495                         }
 1496 
 1497                         if (req->flags & TW_OSLI_REQ_FLAGS_DATA_OUT)
 1498                                 bus_dmamap_sync(sc->ioctl_tag, sc->ioctl_map,
 1499                                         BUS_DMASYNC_POSTWRITE);
 1500 
 1501                         bus_dmamap_unload(sc->ioctl_tag, sc->ioctl_map);
 1502 
 1503                         mtx_unlock_spin(sc->io_lock);
 1504                 } else {
 1505                         if (req->flags & TW_OSLI_REQ_FLAGS_DATA_IN) {
 1506                                 bus_dmamap_sync(sc->dma_tag,
 1507                                         req->dma_map, BUS_DMASYNC_POSTREAD);
 1508 
 1509                                 /* 
 1510                                  * If we are using a bounce buffer, and we are
 1511                                  * reading data, copy the real data in.
 1512                                  */
 1513                                 if (req->flags & TW_OSLI_REQ_FLAGS_DATA_COPY_NEEDED)
 1514                                         bcopy(req->data, req->real_data,
 1515                                                 req->real_length);
 1516                         }
 1517                         if (req->flags & TW_OSLI_REQ_FLAGS_DATA_OUT)
 1518                                 bus_dmamap_sync(sc->dma_tag, req->dma_map,
 1519                                         BUS_DMASYNC_POSTWRITE);
 1520 
 1521                         bus_dmamap_unload(sc->dma_tag, req->dma_map);
 1522                 }
 1523         }
 1524 
 1525         /* Free alignment buffer if it was used. */
 1526         if (req->flags & TW_OSLI_REQ_FLAGS_DATA_COPY_NEEDED) {
 1527                 free(req->data, TW_OSLI_MALLOC_CLASS);
 1528                 /* Restore original data pointer and length. */
 1529                 req->data = req->real_data;
 1530                 req->length = req->real_length;
 1531         }
 1532 }
 1533 
 1534 
 1535 
 1536 #ifdef TW_OSL_DEBUG
 1537 
 1538 TW_VOID twa_report_stats(TW_VOID);
 1539 TW_VOID twa_reset_stats(TW_VOID);
 1540 TW_VOID tw_osli_print_ctlr_stats(struct twa_softc *sc);
 1541 TW_VOID twa_print_req_info(struct tw_osli_req_context *req);
 1542 
 1543 
 1544 /*
 1545  * Function name:       twa_report_stats
 1546  * Description:         For being called from ddb.  Calls functions that print
 1547  *                      OSL and CL internal stats for the controller.
 1548  *
 1549  * Input:               None
 1550  * Output:              None
 1551  * Return value:        None
 1552  */
 1553 TW_VOID
 1554 twa_report_stats(TW_VOID)
 1555 {
 1556         struct twa_softc        *sc;
 1557         TW_INT32                i;
 1558 
 1559         for (i = 0; (sc = devclass_get_softc(twa_devclass, i)) != NULL; i++) {
 1560                 tw_osli_print_ctlr_stats(sc);
 1561                 tw_cl_print_ctlr_stats(&sc->ctlr_handle);
 1562         }
 1563 }
 1564 
 1565 
 1566 
 1567 /*
 1568  * Function name:       tw_osli_print_ctlr_stats
 1569  * Description:         For being called from ddb.  Prints OSL controller stats
 1570  *
 1571  * Input:               sc      -- ptr to OSL internal controller context
 1572  * Output:              None
 1573  * Return value:        None
 1574  */
 1575 TW_VOID
 1576 tw_osli_print_ctlr_stats(struct twa_softc *sc)
 1577 {
 1578         twa_printf(sc, "osl_ctlr_ctxt = %p\n", sc);
 1579         twa_printf(sc, "OSLq type  current  max\n");
 1580         twa_printf(sc, "free      %04d     %04d\n",
 1581                 sc->q_stats[TW_OSLI_FREE_Q].cur_len,
 1582                 sc->q_stats[TW_OSLI_FREE_Q].max_len);
 1583         twa_printf(sc, "busy      %04d     %04d\n",
 1584                 sc->q_stats[TW_OSLI_BUSY_Q].cur_len,
 1585                 sc->q_stats[TW_OSLI_BUSY_Q].max_len);
 1586 }       
 1587 
 1588 
 1589 
 1590 /*
 1591  * Function name:       twa_print_req_info
 1592  * Description:         For being called from ddb.  Calls functions that print
 1593  *                      OSL and CL internal details for the request.
 1594  *
 1595  * Input:               req     -- ptr to OSL internal request context
 1596  * Output:              None
 1597  * Return value:        None
 1598  */
 1599 TW_VOID
 1600 twa_print_req_info(struct tw_osli_req_context *req)
 1601 {
 1602         struct twa_softc        *sc = req->ctlr;
 1603 
 1604         twa_printf(sc, "OSL details for request:\n");
 1605         twa_printf(sc, "osl_req_ctxt = %p, cl_req_ctxt = %p\n"
 1606                 "data = %p, length = 0x%x, real_data = %p, real_length = 0x%x\n"
 1607                 "state = 0x%x, flags = 0x%x, error = 0x%x, orig_req = %p\n"
 1608                 "next_req = %p, prev_req = %p, dma_map = %p\n",
 1609                 req->req_handle.osl_req_ctxt, req->req_handle.cl_req_ctxt,
 1610                 req->data, req->length, req->real_data, req->real_length,
 1611                 req->state, req->flags, req->error_code, req->orig_req,
 1612                 req->link.next, req->link.prev, req->dma_map);
 1613         tw_cl_print_req_info(&(req->req_handle));
 1614 }
 1615 
 1616 
 1617 
 1618 /*
 1619  * Function name:       twa_reset_stats
 1620  * Description:         For being called from ddb.
 1621  *                      Resets some OSL controller stats.
 1622  *
 1623  * Input:               None
 1624  * Output:              None
 1625  * Return value:        None
 1626  */
 1627 TW_VOID
 1628 twa_reset_stats(TW_VOID)
 1629 {
 1630         struct twa_softc        *sc;
 1631         TW_INT32                i;
 1632 
 1633         for (i = 0; (sc = devclass_get_softc(twa_devclass, i)) != NULL; i++) {
 1634                 sc->q_stats[TW_OSLI_FREE_Q].max_len = 0;
 1635                 sc->q_stats[TW_OSLI_BUSY_Q].max_len = 0;
 1636                 tw_cl_reset_stats(&sc->ctlr_handle);
 1637         }
 1638 }
 1639 
 1640 #endif /* TW_OSL_DEBUG */

Cache object: 040f965e39f5984624e78cf532f92fe5


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