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

Cache object: 78feee077bf9e26e0415c819a1a7689b


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