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_cam.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  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   25  * SUCH DAMAGE.
   26  *
   27  *      $FreeBSD: releng/8.1/sys/dev/twa/tw_osl_cam.c 203889 2010-02-14 19:38:27Z mav $
   28  */
   29 
   30 /*
   31  * AMCC'S 3ware driver for 9000 series storage controllers.
   32  *
   33  * Author: Vinod Kashyap
   34  * Modifications by: Adam Radford
   35  * Modifications by: Manjunath Ranganathaiah
   36  */
   37 
   38 
   39 /*
   40  * FreeBSD CAM related functions.
   41  */
   42 
   43 
   44 #include <dev/twa/tw_osl_includes.h>
   45 
   46 #include <cam/cam.h>
   47 #include <cam/cam_ccb.h>
   48 #include <cam/cam_sim.h>
   49 #include <cam/cam_xpt_sim.h>
   50 #include <cam/cam_debug.h>
   51 #include <cam/cam_periph.h>
   52 
   53 #include <cam/scsi/scsi_all.h>
   54 #include <cam/scsi/scsi_message.h>
   55 
   56 static TW_VOID  twa_action(struct cam_sim *sim, union ccb *ccb);
   57 static TW_VOID  twa_poll(struct cam_sim *sim);
   58 static TW_VOID  twa_timeout(TW_VOID *arg);
   59 
   60 static TW_INT32 tw_osli_execute_scsi(struct tw_osli_req_context *req,
   61         union ccb *ccb);
   62 
   63 
   64 
   65 /*
   66  * Function name:       tw_osli_cam_attach
   67  * Description:         Attaches the driver to CAM.
   68  *
   69  * Input:               sc      -- ptr to OSL internal ctlr context
   70  * Output:              None
   71  * Return value:        0       -- success
   72  *                      non-zero-- failure
   73  */
   74 TW_INT32
   75 tw_osli_cam_attach(struct twa_softc *sc)
   76 {
   77         struct cam_devq         *devq;
   78 
   79         tw_osli_dbg_dprintf(3, sc, "entered");
   80 
   81         /*
   82          * Create the device queue for our SIM.
   83          */
   84         if ((devq = cam_simq_alloc(TW_OSLI_MAX_NUM_IOS)) == NULL) {
   85                 tw_osli_printf(sc, "error = %d",
   86                         TW_CL_SEVERITY_ERROR_STRING,
   87                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
   88                         0x2100,
   89                         "Failed to create SIM device queue",
   90                         ENOMEM);
   91                 return(ENOMEM);
   92         }
   93 
   94         /*
   95          * Create a SIM entry.  Though we can support TW_OSLI_MAX_NUM_IOS
   96          * simultaneous requests, we claim to be able to handle only
   97          * (TW_OSLI_MAX_NUM_IOS - 1), so that we always have a request
   98          * packet available to service ioctls.
   99          */
  100         tw_osli_dbg_dprintf(3, sc, "Calling cam_sim_alloc");
  101         sc->sim = cam_sim_alloc(twa_action, twa_poll, "twa", sc,
  102                         device_get_unit(sc->bus_dev), sc->sim_lock,
  103                         TW_OSLI_MAX_NUM_IOS - 1, 1, devq);
  104         if (sc->sim == NULL) {
  105                 cam_simq_free(devq);
  106                 tw_osli_printf(sc, "error = %d",
  107                         TW_CL_SEVERITY_ERROR_STRING,
  108                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  109                         0x2101,
  110                         "Failed to create a SIM entry",
  111                         ENOMEM);
  112                 return(ENOMEM);
  113         }
  114 
  115         /*
  116          * Register the bus.
  117          */
  118         tw_osli_dbg_dprintf(3, sc, "Calling xpt_bus_register");
  119         mtx_lock(sc->sim_lock);
  120         if (xpt_bus_register(sc->sim, sc->bus_dev, 0) != CAM_SUCCESS) {
  121                 cam_sim_free(sc->sim, TRUE);
  122                 sc->sim = NULL; /* so cam_detach will not try to free it */
  123                 tw_osli_printf(sc, "error = %d",
  124                         TW_CL_SEVERITY_ERROR_STRING,
  125                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  126                         0x2102,
  127                         "Failed to register the bus",
  128                         ENXIO);
  129                 mtx_unlock(sc->sim_lock);
  130                 return(ENXIO);
  131         }
  132 
  133         tw_osli_dbg_dprintf(3, sc, "Calling xpt_create_path");
  134         if (xpt_create_path(&sc->path, NULL,
  135                                 cam_sim_path(sc->sim),
  136                                 CAM_TARGET_WILDCARD,
  137                                 CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
  138                 xpt_bus_deregister(cam_sim_path (sc->sim));
  139                 /* Passing TRUE to cam_sim_free will free the devq as well. */
  140                 cam_sim_free(sc->sim, TRUE);
  141                 tw_osli_printf(sc, "error = %d",
  142                         TW_CL_SEVERITY_ERROR_STRING,
  143                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  144                         0x2103,
  145                         "Failed to create path",
  146                         ENXIO);
  147                 mtx_unlock(sc->sim_lock);
  148                 return(ENXIO);
  149         }
  150         mtx_unlock(sc->sim_lock);
  151 
  152         tw_osli_dbg_dprintf(3, sc, "exiting");
  153         return(0);
  154 }
  155 
  156 
  157 
  158 /*
  159  * Function name:       tw_osli_cam_detach
  160  * Description:         Detaches the driver from CAM.
  161  *
  162  * Input:               sc      -- ptr to OSL internal ctlr context
  163  * Output:              None
  164  * Return value:        None
  165  */
  166 TW_VOID
  167 tw_osli_cam_detach(struct twa_softc *sc)
  168 {
  169         tw_osli_dbg_dprintf(3, sc, "entered");
  170 
  171 #ifdef TW_OSLI_DEFERRED_INTR_USED
  172         /*  - drain the taskqueue 
  173            Ctrl is already went down so, no more enqueuetask will
  174            happen . Don't  hold any locks, that task might need.
  175         */ 
  176 
  177         taskqueue_drain(taskqueue_fast, &(sc->deferred_intr_callback));
  178 #endif
  179         mtx_lock(sc->sim_lock);
  180            
  181         if (sc->path)
  182                 xpt_free_path(sc->path);
  183         if (sc->sim) {
  184                 xpt_bus_deregister(cam_sim_path(sc->sim));
  185                 /* Passing TRUE to cam_sim_free will free the devq as well. */
  186                 cam_sim_free(sc->sim, TRUE);
  187         }
  188         /* It's ok have 1 hold count while destroying the mutex */
  189         mtx_destroy(sc->sim_lock);
  190 }
  191 
  192 
  193 
  194 /*
  195  * Function name:       tw_osli_execute_scsi
  196  * Description:         Build a fw cmd, based on a CAM style ccb, and
  197  *                      send it down.
  198  *
  199  * Input:               req     -- ptr to OSL internal request context
  200  *                      ccb     -- ptr to CAM style ccb
  201  * Output:              None
  202  * Return value:        0       -- success
  203  *                      non-zero-- failure
  204  */
  205 TW_INT32
  206 tw_osli_execute_scsi(struct tw_osli_req_context *req, union ccb *ccb)
  207 {
  208         struct twa_softc                *sc = req->ctlr;
  209         struct tw_cl_req_packet         *req_pkt;
  210         struct tw_cl_scsi_req_packet    *scsi_req;
  211         struct ccb_hdr                  *ccb_h = &(ccb->ccb_h);
  212         struct ccb_scsiio               *csio = &(ccb->csio);
  213         TW_INT32                        error;
  214 
  215         tw_osli_dbg_dprintf(10, sc, "SCSI I/O request 0x%x",
  216                 csio->cdb_io.cdb_bytes[0]);
  217 
  218         if (ccb_h->target_id >= TW_CL_MAX_NUM_UNITS) {
  219                 tw_osli_dbg_dprintf(3, sc, "Invalid target. PTL = %x %x %x",
  220                         ccb_h->path_id, ccb_h->target_id, ccb_h->target_lun);
  221                 ccb_h->status |= CAM_TID_INVALID;
  222                 xpt_done(ccb);
  223                 return(1);
  224         }
  225         if (ccb_h->target_lun >= TW_CL_MAX_NUM_LUNS) {
  226                 tw_osli_dbg_dprintf(3, sc, "Invalid lun. PTL = %x %x %x",
  227                         ccb_h->path_id, ccb_h->target_id, ccb_h->target_lun);
  228                 ccb_h->status |= CAM_LUN_INVALID;
  229                 xpt_done(ccb);
  230                 return(1);
  231         }
  232 
  233         if(ccb_h->flags & CAM_CDB_PHYS) {
  234                 tw_osli_printf(sc, "",
  235                         TW_CL_SEVERITY_ERROR_STRING,
  236                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  237                         0x2105,
  238                         "Physical CDB address!");
  239                 ccb_h->status = CAM_REQ_CMP_ERR;
  240                 xpt_done(ccb);
  241                 return(1);
  242         }
  243 
  244         /*
  245          * We are going to work on this request.  Mark it as enqueued (though
  246          * we don't actually queue it...)
  247          */
  248         ccb_h->status |= CAM_SIM_QUEUED;
  249 
  250         if((ccb_h->flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
  251                 if(ccb_h->flags & CAM_DIR_IN)
  252                         req->flags |= TW_OSLI_REQ_FLAGS_DATA_IN;
  253                 else
  254                         req->flags |= TW_OSLI_REQ_FLAGS_DATA_OUT;
  255         }
  256 
  257         /* Build the CL understood request packet for SCSI cmds. */
  258         req_pkt = &req->req_pkt;
  259         req_pkt->status = 0;
  260         req_pkt->tw_osl_callback = tw_osl_complete_io;
  261         scsi_req = &(req_pkt->gen_req_pkt.scsi_req);
  262         scsi_req->unit = ccb_h->target_id;
  263         scsi_req->lun = ccb_h->target_lun;
  264         scsi_req->sense_len = 0;
  265         scsi_req->sense_data = (TW_UINT8 *)(&csio->sense_data);
  266         scsi_req->scsi_status = 0;
  267         if(ccb_h->flags & CAM_CDB_POINTER)
  268                 scsi_req->cdb = csio->cdb_io.cdb_ptr;
  269         else
  270                 scsi_req->cdb = csio->cdb_io.cdb_bytes;
  271         scsi_req->cdb_len = csio->cdb_len;
  272 
  273         if (!(ccb_h->flags & CAM_DATA_PHYS)) {
  274                 /* Virtual data addresses.  Need to convert them... */
  275                 tw_osli_dbg_dprintf(3, sc,
  276                         "XPT_SCSI_IO: Single virtual address!");
  277                 if (!(ccb_h->flags & CAM_SCATTER_VALID)) {
  278                         if (csio->dxfer_len > TW_CL_MAX_IO_SIZE) {
  279                                 tw_osli_printf(sc, "size = %d",
  280                                         TW_CL_SEVERITY_ERROR_STRING,
  281                                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  282                                         0x2106,
  283                                         "I/O size too big",
  284                                         csio->dxfer_len);
  285                                 ccb_h->status = CAM_REQ_TOO_BIG;
  286                                 xpt_done(ccb);
  287                                 return(1);
  288                         }
  289 
  290                         if ((req->length = csio->dxfer_len)) {
  291                                 req->data = csio->data_ptr;
  292                                 scsi_req->sgl_entries = 1;
  293                         }
  294                 } else {
  295                         tw_osli_printf(sc, "",
  296                                 TW_CL_SEVERITY_ERROR_STRING,
  297                                 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  298                                 0x2107,
  299                                 "XPT_SCSI_IO: Got SGList");
  300                         ccb_h->status = CAM_REQ_CMP_ERR;
  301                         xpt_done(ccb);
  302                         return(1);
  303                 }
  304         } else {
  305                 /* Data addresses are physical. */
  306                 tw_osli_printf(sc, "",
  307                         TW_CL_SEVERITY_ERROR_STRING,
  308                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  309                         0x2108,
  310                         "XPT_SCSI_IO: Physical data addresses");
  311                 ccb_h->status = CAM_REQ_CMP_ERR;
  312                 ccb_h->status |= CAM_RELEASE_SIMQ;
  313                 ccb_h->status &= ~CAM_SIM_QUEUED;
  314                 xpt_done(ccb);
  315                 return(1);
  316         }
  317 
  318         ccb_h->timeout_ch = timeout(twa_timeout, req,
  319                 (ccb_h->timeout * hz) / 1000);
  320         /*
  321          * twa_map_load_data_callback will fill in the SGL,
  322          * and submit the I/O.
  323          */
  324         error = tw_osli_map_request(req);
  325         return(error);
  326 }
  327 
  328 
  329 
  330 /*
  331  * Function name:       twa_action
  332  * Description:         Driver entry point for CAM's use.
  333  *
  334  * Input:               sim     -- sim corresponding to the ctlr
  335  *                      ccb     -- ptr to CAM request
  336  * Output:              None
  337  * Return value:        None
  338  */
  339 TW_VOID
  340 twa_action(struct cam_sim *sim, union ccb *ccb)
  341 {
  342         struct twa_softc        *sc = (struct twa_softc *)cam_sim_softc(sim);
  343         struct ccb_hdr          *ccb_h = &(ccb->ccb_h);
  344 
  345         switch (ccb_h->func_code) {
  346         case XPT_SCSI_IO:       /* SCSI I/O */
  347         {
  348                 struct tw_osli_req_context      *req;
  349 
  350                 if ((sc->state & TW_OSLI_CTLR_STATE_SIMQ_FROZEN) ||
  351                                 ((req = tw_osli_get_request(sc)) == NULL)) {
  352                         tw_osli_dbg_dprintf(2, sc,
  353                                 "simq frozen/Cannot get request pkt.");
  354                         /*
  355                          * Freeze the simq to maintain ccb ordering.  The next
  356                          * ccb that gets completed will unfreeze the simq.
  357                          */
  358                         tw_osli_disallow_new_requests(sc);
  359                         ccb_h->status |= CAM_REQUEUE_REQ;
  360                         xpt_done(ccb);
  361                         break;
  362                 }
  363                 req->req_handle.osl_req_ctxt = req;
  364                 req->orig_req = ccb;
  365                 if (tw_osli_execute_scsi(req, ccb))
  366                         tw_osli_req_q_insert_tail(req, TW_OSLI_FREE_Q);
  367                 break;
  368         }
  369 
  370         case XPT_ABORT:
  371                 tw_osli_dbg_dprintf(2, sc, "Abort request.");
  372                 ccb_h->status = CAM_UA_ABORT;
  373                 xpt_done(ccb);
  374                 break;
  375 
  376         case XPT_RESET_BUS:
  377                 tw_cl_create_event(&(sc->ctlr_handle), TW_CL_TRUE,
  378                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  379                         0x2108, 0x3, TW_CL_SEVERITY_INFO_STRING,
  380                         "Received Reset Bus request from CAM",
  381                         " ");
  382 
  383                 mtx_unlock(sc->sim_lock);
  384                 if (tw_cl_reset_ctlr(&sc->ctlr_handle)) {
  385                         tw_cl_create_event(&(sc->ctlr_handle), TW_CL_TRUE,
  386                                 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  387                                 0x2109, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  388                                 "Failed to reset bus",
  389                                 " ");
  390                         ccb_h->status = CAM_REQ_CMP_ERR;
  391                 }
  392                 else
  393                         ccb_h->status = CAM_REQ_CMP;
  394 
  395                 mtx_lock(sc->sim_lock);
  396                 xpt_done(ccb);
  397                 break;
  398 
  399         case XPT_SET_TRAN_SETTINGS:
  400                 tw_osli_dbg_dprintf(3, sc, "XPT_SET_TRAN_SETTINGS");
  401 
  402                 /*
  403                  * This command is not supported, since it's very specific
  404                  * to SCSI, and we are doing ATA.
  405                  */
  406                 ccb_h->status = CAM_FUNC_NOTAVAIL;
  407                 xpt_done(ccb);
  408                 break;
  409 
  410         case XPT_GET_TRAN_SETTINGS: 
  411         {
  412                 struct ccb_trans_settings       *cts = &ccb->cts;
  413                 struct ccb_trans_settings_scsi *scsi =
  414                     &cts->proto_specific.scsi;
  415                 struct ccb_trans_settings_spi *spi =
  416                     &cts->xport_specific.spi;
  417 
  418                 cts->protocol = PROTO_SCSI;
  419                 cts->protocol_version = SCSI_REV_2;
  420                 cts->transport = XPORT_SPI;
  421                 cts->transport_version = 2;
  422 
  423                 spi->valid = CTS_SPI_VALID_DISC;
  424                 spi->flags = CTS_SPI_FLAGS_DISC_ENB;
  425                 scsi->valid = CTS_SCSI_VALID_TQ;
  426                 scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
  427                 tw_osli_dbg_dprintf(3, sc, "XPT_GET_TRAN_SETTINGS");
  428                 ccb_h->status = CAM_REQ_CMP;
  429                 xpt_done(ccb);
  430                 break;
  431         }
  432 
  433         case XPT_CALC_GEOMETRY:
  434                 tw_osli_dbg_dprintf(3, sc, "XPT_CALC_GEOMETRY");
  435                 cam_calc_geometry(&ccb->ccg, 1/* extended */);
  436                 xpt_done(ccb);
  437                 break;
  438 
  439         case XPT_PATH_INQ:    /* Path inquiry -- get twa properties */
  440         {
  441                 struct ccb_pathinq      *path_inq = &ccb->cpi;
  442 
  443                 tw_osli_dbg_dprintf(3, sc, "XPT_PATH_INQ request");
  444 
  445                 path_inq->version_num = 1;
  446                 path_inq->hba_inquiry = 0;
  447                 path_inq->target_sprt = 0;
  448                 path_inq->hba_misc = 0;
  449                 path_inq->hba_eng_cnt = 0;
  450                 path_inq->max_target = TW_CL_MAX_NUM_UNITS;
  451                 path_inq->max_lun = TW_CL_MAX_NUM_LUNS - 1;
  452                 path_inq->unit_number = cam_sim_unit(sim);
  453                 path_inq->bus_id = cam_sim_bus(sim);
  454                 path_inq->initiator_id = TW_CL_MAX_NUM_UNITS;
  455                 path_inq->base_transfer_speed = 100000;
  456                 strncpy(path_inq->sim_vid, "FreeBSD", SIM_IDLEN);
  457                 strncpy(path_inq->hba_vid, "3ware", HBA_IDLEN);
  458                 strncpy(path_inq->dev_name, cam_sim_name(sim), DEV_IDLEN);
  459                 path_inq->transport = XPORT_SPI;
  460                 path_inq->transport_version = 2;
  461                 path_inq->protocol = PROTO_SCSI;
  462                 path_inq->protocol_version = SCSI_REV_2;
  463                 ccb_h->status = CAM_REQ_CMP;
  464                 xpt_done(ccb);
  465                 break;
  466         }
  467 
  468         default:
  469                 tw_osli_dbg_dprintf(3, sc, "func_code = %x", ccb_h->func_code);
  470                 ccb_h->status = CAM_REQ_INVALID;
  471                 xpt_done(ccb);
  472                 break;
  473         }
  474 }
  475 
  476 
  477 
  478 /*
  479  * Function name:       twa_poll
  480  * Description:         Driver entry point called when interrupts are not
  481  *                      available.
  482  *
  483  * Input:               sim     -- sim corresponding to the controller
  484  * Output:              None
  485  * Return value:        None
  486  */
  487 TW_VOID
  488 twa_poll(struct cam_sim *sim)
  489 {
  490         struct twa_softc *sc = (struct twa_softc *)(cam_sim_softc(sim));
  491 
  492         tw_osli_dbg_dprintf(3, sc, "entering; sc = %p", sc);
  493         /*
  494          * It's been observed that twa_poll can get called (from
  495          * dashutdown --> xpt_polled_action) even when interrupts are
  496          * active, in which case, the ISR might clear the interrupt,
  497          * leaving the call to tw_cl_interrupt below, no way of determining
  498          * that the response from firmware is ready, resulting in
  499          * tw_cl_deferred_interrupt never getting called.  To cover this case,
  500          * we will make the call to tw_cl_deferred_interrupt not dependent
  501          * on the return value from tw_cl_interrupt.
  502          */
  503         tw_cl_interrupt(&(sc->ctlr_handle));
  504         tw_cl_deferred_interrupt(&(sc->ctlr_handle));
  505         tw_osli_dbg_dprintf(3, sc, "exiting; sc = %p", sc);
  506 }
  507 
  508 
  509 
  510 /*
  511  * Function name:       twa_timeout
  512  * Description:         Driver entry point for being alerted on a request
  513  *                      timing out.
  514  *
  515  * Input:               arg     -- ptr to timed out request
  516  * Output:              None
  517  * Return value:        None
  518  */
  519 static TW_VOID
  520 twa_timeout(TW_VOID *arg)
  521 {
  522         struct tw_osli_req_context      *req =
  523                 (struct tw_osli_req_context *)arg;
  524 
  525         tw_cl_create_event(&(req->ctlr->ctlr_handle), TW_CL_TRUE,
  526                 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  527                 0x210B, 0x1, TW_CL_SEVERITY_ERROR_STRING,
  528                 "Request timed out!",
  529                 "request = %p", req);
  530         tw_cl_reset_ctlr(&(req->ctlr->ctlr_handle));
  531 }
  532 
  533 
  534 
  535 /*
  536  * Function name:       tw_osli_request_bus_scan
  537  * Description:         Requests CAM for a scan of the bus.
  538  *
  539  * Input:               sc      -- ptr to per ctlr structure
  540  * Output:              None
  541  * Return value:        0       -- success
  542  *                      non-zero-- failure
  543  */
  544 TW_INT32
  545 tw_osli_request_bus_scan(struct twa_softc *sc)
  546 {
  547         union ccb       *ccb;
  548 
  549         tw_osli_dbg_dprintf(3, sc, "entering");
  550 
  551         /* If we get here before sc->sim is initialized, return an error. */
  552         if (!(sc->sim))
  553                 return(ENXIO);
  554         if ((ccb = xpt_alloc_ccb()) == NULL)
  555                 return(ENOMEM);
  556         mtx_lock(sc->sim_lock);
  557         if (xpt_create_path(&ccb->ccb_h.path, xpt_periph, cam_sim_path(sc->sim),
  558             CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
  559                 xpt_free_ccb(ccb);
  560                 mtx_unlock(sc->sim_lock);
  561                 return(EIO);
  562         }
  563 
  564         /* Release simq at the end of a reset */
  565         if (sc->state & TW_OSLI_CTLR_STATE_SIMQ_FROZEN) {
  566                 xpt_release_simq(sc->sim, 1);
  567                 sc->state &= ~TW_OSLI_CTLR_STATE_SIMQ_FROZEN;
  568         }
  569 
  570         xpt_rescan(ccb);
  571         mtx_unlock(sc->sim_lock);
  572         return(0);
  573 }
  574 
  575 
  576 
  577 /*
  578  * Function name:       tw_osli_allow_new_requests
  579  * Description:         Sets the appropriate status bits in a ccb such that,
  580  *                      when the ccb is completed by a call to xpt_done,
  581  *                      CAM knows that it's ok to unfreeze the flow of new
  582  *                      requests to this controller, if the flow is frozen.
  583  *
  584  * Input:               sc      -- ptr to OSL internal ctlr context
  585  *                      ccb     -- ptr to CAM request
  586  * Output:              None
  587  * Return value:        None
  588  */
  589 TW_VOID
  590 tw_osli_allow_new_requests(struct twa_softc *sc, TW_VOID *ccb)
  591 {
  592         ((union ccb *)(ccb))->ccb_h.status |= CAM_RELEASE_SIMQ;
  593         sc->state &= ~TW_OSLI_CTLR_STATE_SIMQ_FROZEN;
  594 }
  595 
  596 
  597 
  598 /*
  599  * Function name:       tw_osli_disallow_new_requests
  600  * Description:         Calls the appropriate CAM function, so as to freeze
  601  *                      the flow of new requests from CAM to this controller.
  602  *
  603  * Input:               sc      -- ptr to OSL internal ctlr context
  604  * Output:              None
  605  * Return value:        None
  606  */
  607 TW_VOID
  608 tw_osli_disallow_new_requests(struct twa_softc *sc)
  609 {
  610         /* Don't double freeze if already frozen */
  611         if ((sc->state & TW_OSLI_CTLR_STATE_SIMQ_FROZEN) == 0) {
  612                 mtx_lock(sc->sim_lock);
  613                 xpt_freeze_simq(sc->sim, 1);
  614                 mtx_unlock(sc->sim_lock);
  615                 sc->state |= TW_OSLI_CTLR_STATE_SIMQ_FROZEN;
  616         }
  617 }
  618 
  619 
  620 
  621 /*
  622  * Function name:       tw_osl_ctlr_busy
  623  * Description:         CL calls this function on cmd queue full or otherwise,
  624  *                      when it is too busy to accept new requests.
  625  *
  626  * Input:               ctlr_handle     -- ptr to controller handle
  627  *                      req_handle      -- ptr to request handle sent by OSL.
  628  * Output:              None
  629  * Return value:        None
  630  */
  631 TW_VOID
  632 tw_osl_ctlr_busy(struct tw_cl_ctlr_handle *ctlr_handle,
  633         struct tw_cl_req_handle *req_handle)
  634 {
  635         tw_osli_disallow_new_requests(ctlr_handle->osl_ctlr_ctxt);
  636 }
  637 
  638 
  639 
  640 /*
  641  * Function name:       tw_osl_scan_bus
  642  * Description:         CL calls this function to request for a bus scan.
  643  *
  644  * Input:               ctlr_handle     -- ptr to controller handle
  645  * Output:              None
  646  * Return value:        None
  647  */
  648 TW_VOID
  649 tw_osl_scan_bus(struct tw_cl_ctlr_handle *ctlr_handle)
  650 {
  651         struct twa_softc        *sc = ctlr_handle->osl_ctlr_ctxt;
  652         TW_INT32                error;
  653 
  654         if ((error = tw_osli_request_bus_scan(sc)))
  655                 tw_osli_printf(sc, "error = %d",
  656                         TW_CL_SEVERITY_ERROR_STRING,
  657                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  658                         0x2109,
  659                         "Bus scan request to CAM failed",
  660                         error);
  661 }
  662 
  663 
  664 
  665 /*
  666  * Function name:       tw_osl_complete_io
  667  * Description:         Called to complete CAM scsi requests.
  668  *
  669  * Input:               req_handle      -- ptr to request handle
  670  * Output:              None
  671  * Return value:        None
  672  */
  673 TW_VOID
  674 tw_osl_complete_io(struct tw_cl_req_handle *req_handle)
  675 {
  676         struct tw_osli_req_context      *req = req_handle->osl_req_ctxt;
  677         struct tw_cl_req_packet         *req_pkt =
  678                 (struct tw_cl_req_packet *)(&req->req_pkt);
  679         struct tw_cl_scsi_req_packet    *scsi_req;
  680         struct twa_softc                *sc = req->ctlr;
  681         union ccb                       *ccb = (union ccb *)(req->orig_req);
  682 
  683         tw_osli_dbg_dprintf(10, sc, "entering");
  684 
  685         if (req->state != TW_OSLI_REQ_STATE_BUSY)
  686                 tw_osli_printf(sc, "request = %p, status = %d",
  687                         TW_CL_SEVERITY_ERROR_STRING,
  688                         TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
  689                         0x210A,
  690                         "Unposted command completed!!",
  691                         req, req->state);
  692 
  693         /*
  694          * Remove request from the busy queue.  Just mark it complete.
  695          * There's no need to move it into the complete queue as we are
  696          * going to be done with it right now.
  697          */
  698         req->state = TW_OSLI_REQ_STATE_COMPLETE;
  699         tw_osli_req_q_remove_item(req, TW_OSLI_BUSY_Q);
  700 
  701         tw_osli_unmap_request(req);
  702 
  703         untimeout(twa_timeout, req, ccb->ccb_h.timeout_ch);
  704         if (req->error_code) {
  705                 /* This request never got submitted to the firmware. */
  706                 if (req->error_code == EBUSY) {
  707                         /*
  708                          * Cmd queue is full, or the Common Layer is out of
  709                          * resources.  The simq will already have been frozen
  710                          * by CL's call to tw_osl_ctlr_busy, and this will
  711                          * maintain ccb ordering.  The next ccb that gets
  712                          * completed will unfreeze the simq.
  713                          */
  714                         ccb->ccb_h.status |= CAM_REQUEUE_REQ;
  715                 }
  716                 else if (req->error_code == EFBIG)
  717                         ccb->ccb_h.status = CAM_REQ_TOO_BIG;
  718                 else
  719                         ccb->ccb_h.status = CAM_REQ_CMP_ERR;
  720         } else {
  721                 scsi_req = &(req_pkt->gen_req_pkt.scsi_req);
  722                 if (req_pkt->status == TW_CL_ERR_REQ_SUCCESS)
  723                         ccb->ccb_h.status = CAM_REQ_CMP;
  724                 else {
  725                         if (req_pkt->status & TW_CL_ERR_REQ_INVALID_TARGET)
  726                                 ccb->ccb_h.status |= CAM_TID_INVALID;
  727                         else if (req_pkt->status & TW_CL_ERR_REQ_INVALID_LUN)
  728                                 ccb->ccb_h.status |= CAM_LUN_INVALID;
  729                         else if (req_pkt->status & TW_CL_ERR_REQ_SCSI_ERROR)
  730                                 ccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR;
  731                         else if (req_pkt->status & TW_CL_ERR_REQ_BUS_RESET)
  732                                 ccb->ccb_h.status |= CAM_SCSI_BUS_RESET;
  733                         /*
  734                          * If none of the above errors occurred, simply
  735                          * mark completion error.
  736                          */
  737                         if (ccb->ccb_h.status == 0)
  738                                 ccb->ccb_h.status = CAM_REQ_CMP_ERR;
  739 
  740                         if (req_pkt->status & TW_CL_ERR_REQ_AUTO_SENSE_VALID) {
  741                                 ccb->csio.sense_len = scsi_req->sense_len;
  742                                 ccb->ccb_h.status |= CAM_AUTOSNS_VALID;
  743                         }
  744                 }
  745 
  746                 ccb->csio.scsi_status = scsi_req->scsi_status;
  747                 /* If simq is frozen, unfreeze it. */
  748                 if (sc->state & TW_OSLI_CTLR_STATE_SIMQ_FROZEN)
  749                         tw_osli_allow_new_requests(sc, (TW_VOID *)ccb);
  750         }
  751 
  752         ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
  753         mtx_lock(sc->sim_lock);
  754         xpt_done(ccb);
  755         mtx_unlock(sc->sim_lock);
  756         if (! req->error_code)
  757                  /* twa_action will free the request otherwise */
  758                 tw_osli_req_q_insert_tail(req, TW_OSLI_FREE_Q);
  759 }
  760 

Cache object: d67bb8cd26429c02b27b87e17a1b3d10


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