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

Cache object: e92f689f430b036f3f7f328c23dd06d6


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