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

Cache object: 2a6fb861e01690a231d9f335ca400958


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