sys/dev/mrsas/mrsas_cam.c

   1 /*
   2  * Copyright (c) 2014, LSI Corp. All rights reserved. Author: Marian Choy
   3  * Support: freebsdraid@lsi.com
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright notice,
  10  * this list of conditions and the following disclaimer. 2. Redistributions
  11  * in binary form must reproduce the above copyright notice, this list of
  12  * conditions and the following disclaimer in the documentation and/or other
  13  * materials provided with the distribution. 3. Neither the name of the
  14  * <ORGANIZATION> nor the names of its contributors may be used to endorse or
  15  * promote products derived from this software without specific prior written
  16  * permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  22  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include "dev/mrsas/mrsas.h"
  36
  37 #include <cam/cam.h>
  38 #include <cam/cam_ccb.h>
  39 #include <cam/cam_sim.h>
  40 #include <cam/cam_xpt_sim.h>
  41 #include <cam/cam_debug.h>
  42 #include <cam/cam_periph.h>
  43 #include <cam/cam_xpt_periph.h>
  44
  45 #include <cam/scsi/scsi_all.h>
  46 #include <cam/scsi/scsi_message.h>
  47 #include <sys/taskqueue.h>
  48 #include <sys/kernel.h>
  49
  50
  51 #include <sys/time.h>                   /* XXX for pcpu.h */
  52 #include <sys/pcpu.h>                   /* XXX for PCPU_GET */
  53
  54 #define smp_processor_id()  PCPU_GET(cpuid)
  55
  56 /*
  57  * Function prototypes
  58  */
  59 int     mrsas_cam_attach(struct mrsas_softc *sc);
  60 int     mrsas_ldio_inq(struct cam_sim *sim, union ccb *ccb);
  61 int     mrsas_bus_scan(struct mrsas_softc *sc);
  62 int     mrsas_bus_scan_sim(struct mrsas_softc *sc, struct cam_sim *sim);
  63 int     mrsas_map_request(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd);
  64 int
  65 mrsas_build_ldio(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd,
  66     union ccb *ccb);
  67 int
  68 mrsas_build_dcdb(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd,
  69     union ccb *ccb, struct cam_sim *sim);
  70 int
  71 mrsas_setup_io(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd,
  72     union ccb *ccb, u_int32_t device_id,
  73     MRSAS_RAID_SCSI_IO_REQUEST * io_request);
  74 void    mrsas_xpt_freeze(struct mrsas_softc *sc);
  75 void    mrsas_xpt_release(struct mrsas_softc *sc);
  76 void    mrsas_cam_detach(struct mrsas_softc *sc);
  77 void    mrsas_release_mpt_cmd(struct mrsas_mpt_cmd *cmd);
  78 void    mrsas_unmap_request(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd);
  79 void    mrsas_cmd_done(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd);
  80 void
  81 mrsas_fire_cmd(struct mrsas_softc *sc, u_int32_t req_desc_lo,
  82     u_int32_t req_desc_hi);
  83 void
  84 mrsas_set_pd_lba(MRSAS_RAID_SCSI_IO_REQUEST * io_request,
  85     u_int8_t cdb_len, struct IO_REQUEST_INFO *io_info, union ccb *ccb,
  86     MR_DRV_RAID_MAP_ALL * local_map_ptr, u_int32_t ref_tag,
  87     u_int32_t ld_block_size);
  88 static void mrsas_freeze_simq(struct mrsas_mpt_cmd *cmd, struct cam_sim *sim);
  89 static void mrsas_cam_poll(struct cam_sim *sim);
  90 static void mrsas_action(struct cam_sim *sim, union ccb *ccb);
  91 static void mrsas_scsiio_timeout(void *data);
  92 static void
  93 mrsas_data_load_cb(void *arg, bus_dma_segment_t *segs,
  94     int nseg, int error);
  95 static int32_t
  96 mrsas_startio(struct mrsas_softc *sc, struct cam_sim *sim,
  97     union ccb *ccb);
  98 struct mrsas_mpt_cmd *mrsas_get_mpt_cmd(struct mrsas_softc *sc);
  99 MRSAS_REQUEST_DESCRIPTOR_UNION *
 100         mrsas_get_request_desc(struct mrsas_softc *sc, u_int16_t index);
 101
 102 extern u_int16_t MR_TargetIdToLdGet(u_int32_t ldTgtId, MR_DRV_RAID_MAP_ALL * map);
 103 extern u_int32_t
 104 MR_LdBlockSizeGet(u_int32_t ldTgtId, MR_DRV_RAID_MAP_ALL * map,
 105     struct mrsas_softc *sc);
 106 extern void mrsas_isr(void *arg);
 107 extern void mrsas_aen_handler(struct mrsas_softc *sc);
 108 extern u_int8_t
 109 MR_BuildRaidContext(struct mrsas_softc *sc,
 110     struct IO_REQUEST_INFO *io_info, RAID_CONTEXT * pRAID_Context,
 111     MR_DRV_RAID_MAP_ALL * map);
 112 extern u_int16_t
 113 MR_LdSpanArrayGet(u_int32_t ld, u_int32_t span,
 114     MR_DRV_RAID_MAP_ALL * map);
 115 extern u_int16_t
 116 mrsas_get_updated_dev_handle(PLD_LOAD_BALANCE_INFO lbInfo,
 117     struct IO_REQUEST_INFO *io_info);
 118 extern u_int8_t
 119 megasas_get_best_arm(PLD_LOAD_BALANCE_INFO lbInfo, u_int8_t arm,
 120     u_int64_t block, u_int32_t count);
 121
 122
 123 /*
 124  * mrsas_cam_attach:    Main entry to CAM subsystem
 125  * input:                               Adapter instance soft state
 126  *
 127  * This function is called from mrsas_attach() during initialization to perform
 128  * SIM allocations and XPT bus registration.  If the kernel version is 7.4 or
 129  * earlier, it would also initiate a bus scan.
 130  */
 131 int
 132 mrsas_cam_attach(struct mrsas_softc *sc)
 133 {
 134         struct cam_devq *devq;
 135         int mrsas_cam_depth;
 136
 137         mrsas_cam_depth = sc->max_fw_cmds - MRSAS_INTERNAL_CMDS;
 138
 139         if ((devq = cam_simq_alloc(mrsas_cam_depth)) == NULL) {
 140                 device_printf(sc->mrsas_dev, "Cannot allocate SIM queue\n");
 141                 return (ENOMEM);
 142         }
 143         /*
 144          * Create SIM for bus 0 and register, also create path
 145          */
 146         sc->sim_0 = cam_sim_alloc(mrsas_action, mrsas_cam_poll, "mrsas", sc,
 147             device_get_unit(sc->mrsas_dev), &sc->sim_lock, mrsas_cam_depth,
 148             mrsas_cam_depth, devq);
 149         if (sc->sim_0 == NULL) {
 150                 cam_simq_free(devq);
 151                 device_printf(sc->mrsas_dev, "Cannot register SIM\n");
 152                 return (ENXIO);
 153         }
 154         /* Initialize taskqueue for Event Handling */
 155         TASK_INIT(&sc->ev_task, 0, (void *)mrsas_aen_handler, sc);
 156         sc->ev_tq = taskqueue_create("mrsas_taskq", M_NOWAIT | M_ZERO,
 157             taskqueue_thread_enqueue, &sc->ev_tq);
 158
 159         /* Run the task queue with lowest priority */
 160         taskqueue_start_threads(&sc->ev_tq, 1, 255, "%s taskq",
 161             device_get_nameunit(sc->mrsas_dev));
 162         mtx_lock(&sc->sim_lock);
 163         if (xpt_bus_register(sc->sim_0, sc->mrsas_dev, 0) != CAM_SUCCESS) {
 164                 cam_sim_free(sc->sim_0, TRUE);  /* passing true frees the devq */
 165                 mtx_unlock(&sc->sim_lock);
 166                 return (ENXIO);
 167         }
 168         if (xpt_create_path(&sc->path_0, NULL, cam_sim_path(sc->sim_0),
 169             CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
 170                 xpt_bus_deregister(cam_sim_path(sc->sim_0));
 171                 cam_sim_free(sc->sim_0, TRUE);  /* passing true will free the
 172                                                  * devq */
 173                 mtx_unlock(&sc->sim_lock);
 174                 return (ENXIO);
 175         }
 176         mtx_unlock(&sc->sim_lock);
 177
 178         /*
 179          * Create SIM for bus 1 and register, also create path
 180          */
 181         sc->sim_1 = cam_sim_alloc(mrsas_action, mrsas_cam_poll, "mrsas", sc,
 182             device_get_unit(sc->mrsas_dev), &sc->sim_lock, mrsas_cam_depth,
 183             mrsas_cam_depth, devq);
 184         if (sc->sim_1 == NULL) {
 185                 cam_simq_free(devq);
 186                 device_printf(sc->mrsas_dev, "Cannot register SIM\n");
 187                 return (ENXIO);
 188         }
 189         mtx_lock(&sc->sim_lock);
 190         if (xpt_bus_register(sc->sim_1, sc->mrsas_dev, 1) != CAM_SUCCESS) {
 191                 cam_sim_free(sc->sim_1, TRUE);  /* passing true frees the devq */
 192                 mtx_unlock(&sc->sim_lock);
 193                 return (ENXIO);
 194         }
 195         if (xpt_create_path(&sc->path_1, NULL, cam_sim_path(sc->sim_1),
 196             CAM_TARGET_WILDCARD,
 197             CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
 198                 xpt_bus_deregister(cam_sim_path(sc->sim_1));
 199                 cam_sim_free(sc->sim_1, TRUE);
 200                 mtx_unlock(&sc->sim_lock);
 201                 return (ENXIO);
 202         }
 203         mtx_unlock(&sc->sim_lock);
 204
 205 #if (__FreeBSD_version <= 704000)
 206         if (mrsas_bus_scan(sc)) {
 207                 device_printf(sc->mrsas_dev, "Error in bus scan.\n");
 208                 return (1);
 209         }
 210 #endif
 211         return (0);
 212 }
 213
 214 /*
 215  * mrsas_cam_detach:    De-allocates and teardown CAM
 216  * input:                               Adapter instance soft state
 217  *
 218  * De-registers and frees the paths and SIMs.
 219  */
 220 void
 221 mrsas_cam_detach(struct mrsas_softc *sc)
 222 {
 223         if (sc->ev_tq != NULL)
 224                 taskqueue_free(sc->ev_tq);
 225         mtx_lock(&sc->sim_lock);
 226         if (sc->path_0)
 227                 xpt_free_path(sc->path_0);
 228         if (sc->sim_0) {
 229                 xpt_bus_deregister(cam_sim_path(sc->sim_0));
 230                 cam_sim_free(sc->sim_0, FALSE);
 231         }
 232         if (sc->path_1)
 233                 xpt_free_path(sc->path_1);
 234         if (sc->sim_1) {
 235                 xpt_bus_deregister(cam_sim_path(sc->sim_1));
 236                 cam_sim_free(sc->sim_1, TRUE);
 237         }
 238         mtx_unlock(&sc->sim_lock);
 239 }
 240
 241 /*
 242  * mrsas_action:        SIM callback entry point
 243  * input:                       pointer to SIM pointer to CAM Control Block
 244  *
 245  * This function processes CAM subsystem requests. The type of request is stored
 246  * in ccb->ccb_h.func_code.  The preprocessor #ifdef is necessary because
 247  * ccb->cpi.maxio is not supported for FreeBSD version 7.4 or earlier.
 248  */
 249 static void
 250 mrsas_action(struct cam_sim *sim, union ccb *ccb)
 251 {
 252         struct mrsas_softc *sc = (struct mrsas_softc *)cam_sim_softc(sim);
 253         struct ccb_hdr *ccb_h = &(ccb->ccb_h);
 254         u_int32_t device_id;
 255
 256         switch (ccb->ccb_h.func_code) {
 257         case XPT_SCSI_IO:
 258                 {
 259                         device_id = ccb_h->target_id;
 260
 261                         /*
 262                          * bus 0 is LD, bus 1 is for system-PD
 263                          */
 264                         if (cam_sim_bus(sim) == 1 &&
 265                             sc->pd_list[device_id].driveState != MR_PD_STATE_SYSTEM) {
 266                                 ccb->ccb_h.status |= CAM_DEV_NOT_THERE;
 267                                 xpt_done(ccb);
 268                         } else {
 269                                 if (mrsas_startio(sc, sim, ccb)) {
 270                                         ccb->ccb_h.status |= CAM_REQ_INVALID;
 271                                         xpt_done(ccb);
 272                                 }
 273                         }
 274                         break;
 275                 }
 276         case XPT_ABORT:
 277                 {
 278                         ccb->ccb_h.status = CAM_UA_ABORT;
 279                         xpt_done(ccb);
 280                         break;
 281                 }
 282         case XPT_RESET_BUS:
 283                 {
 284                         xpt_done(ccb);
 285                         break;
 286                 }
 287         case XPT_GET_TRAN_SETTINGS:
 288                 {
 289                         ccb->cts.protocol = PROTO_SCSI;
 290                         ccb->cts.protocol_version = SCSI_REV_2;
 291                         ccb->cts.transport = XPORT_SPI;
 292                         ccb->cts.transport_version = 2;
 293                         ccb->cts.xport_specific.spi.valid = CTS_SPI_VALID_DISC;
 294                         ccb->cts.xport_specific.spi.flags = CTS_SPI_FLAGS_DISC_ENB;
 295                         ccb->cts.proto_specific.scsi.valid = CTS_SCSI_VALID_TQ;
 296                         ccb->cts.proto_specific.scsi.flags = CTS_SCSI_FLAGS_TAG_ENB;
 297                         ccb->ccb_h.status = CAM_REQ_CMP;
 298                         xpt_done(ccb);
 299                         break;
 300                 }
 301         case XPT_SET_TRAN_SETTINGS:
 302                 {
 303                         ccb->ccb_h.status = CAM_FUNC_NOTAVAIL;
 304                         xpt_done(ccb);
 305                         break;
 306                 }
 307         case XPT_CALC_GEOMETRY:
 308                 {
 309                         cam_calc_geometry(&ccb->ccg, 1);
 310                         xpt_done(ccb);
 311                         break;
 312                 }
 313         case XPT_PATH_INQ:
 314                 {
 315                         ccb->cpi.version_num = 1;
 316                         ccb->cpi.hba_inquiry = 0;
 317                         ccb->cpi.target_sprt = 0;
 318                         ccb->cpi.hba_misc = 0;
 319                         ccb->cpi.hba_eng_cnt = 0;
 320                         ccb->cpi.max_lun = MRSAS_SCSI_MAX_LUNS;
 321                         ccb->cpi.unit_number = cam_sim_unit(sim);
 322                         ccb->cpi.bus_id = cam_sim_bus(sim);
 323                         ccb->cpi.initiator_id = MRSAS_SCSI_INITIATOR_ID;
 324                         ccb->cpi.base_transfer_speed = 150000;
 325                         strncpy(ccb->cpi.sim_vid, "FreeBSD", SIM_IDLEN);
 326                         strncpy(ccb->cpi.hba_vid, "LSI", HBA_IDLEN);
 327                         strncpy(ccb->cpi.dev_name, cam_sim_name(sim), DEV_IDLEN);
 328                         ccb->cpi.transport = XPORT_SPI;
 329                         ccb->cpi.transport_version = 2;
 330                         ccb->cpi.protocol = PROTO_SCSI;
 331                         ccb->cpi.protocol_version = SCSI_REV_2;
 332                         if (ccb->cpi.bus_id == 0)
 333                                 ccb->cpi.max_target = MRSAS_MAX_PD - 1;
 334                         else
 335                                 ccb->cpi.max_target = MRSAS_MAX_LD_IDS - 1;
 336 #if (__FreeBSD_version > 704000)
 337                         ccb->cpi.maxio = MRSAS_MAX_IO_SIZE;
 338 #endif
 339                         ccb->ccb_h.status = CAM_REQ_CMP;
 340                         xpt_done(ccb);
 341                         break;
 342                 }
 343         default:
 344                 {
 345                         ccb->ccb_h.status = CAM_REQ_INVALID;
 346                         xpt_done(ccb);
 347                         break;
 348                 }
 349         }
 350 }
 351
 352 /*
 353  * mrsas_scsiio_timeout:        Callback function for IO timed out
 354  * input:                                       mpt command context
 355  *
 356  * This function will execute after timeout value provided by ccb header from
 357  * CAM layer, if timer expires. Driver will run timer for all DCDM and LDIO
 358  * comming from CAM layer. This function is callback function for IO timeout
 359  * and it runs in no-sleep context. Set do_timedout_reset in Adapter context
 360  * so that it will execute OCR/Kill adpter from ocr_thread context.
 361  */
 362 static void
 363 mrsas_scsiio_timeout(void *data)
 364 {
 365         struct mrsas_mpt_cmd *cmd;
 366         struct mrsas_softc *sc;
 367
 368         cmd = (struct mrsas_mpt_cmd *)data;
 369         sc = cmd->sc;
 370
 371         if (cmd->ccb_ptr == NULL) {
 372                 printf("command timeout with NULL ccb\n");
 373                 return;
 374         }
 375         /*
 376          * Below callout is dummy entry so that it will be cancelled from
 377          * mrsas_cmd_done(). Now Controller will go to OCR/Kill Adapter based
 378          * on OCR enable/disable property of Controller from ocr_thread
 379          * context.
 380          */
 381         callout_reset(&cmd->cm_callout, (600000 * hz) / 1000,
 382             mrsas_scsiio_timeout, cmd);
 383         sc->do_timedout_reset = 1;
 384         if (sc->ocr_thread_active)
 385                 wakeup(&sc->ocr_chan);
 386 }
 387
 388 /*
 389  * mrsas_startio:       SCSI IO entry point
 390  * input:                       Adapter instance soft state
 391  *                                      pointer to CAM Control Block
 392  *
 393  * This function is the SCSI IO entry point and it initiates IO processing. It
 394  * copies the IO and depending if the IO is read/write or inquiry, it would
 395  * call mrsas_build_ldio() or mrsas_build_dcdb(), respectively.  It returns 0
 396  * if the command is sent to firmware successfully, otherwise it returns 1.
 397  */
 398 static int32_t
 399 mrsas_startio(struct mrsas_softc *sc, struct cam_sim *sim,
 400     union ccb *ccb)
 401 {
 402         struct mrsas_mpt_cmd *cmd;
 403         struct ccb_hdr *ccb_h = &(ccb->ccb_h);
 404         struct ccb_scsiio *csio = &(ccb->csio);
 405         MRSAS_REQUEST_DESCRIPTOR_UNION *req_desc;
 406
 407         if ((csio->cdb_io.cdb_bytes[0]) == SYNCHRONIZE_CACHE) {
 408                 ccb->ccb_h.status = CAM_REQ_CMP;
 409                 xpt_done(ccb);
 410                 return (0);
 411         }
 412         ccb_h->status |= CAM_SIM_QUEUED;
 413         cmd = mrsas_get_mpt_cmd(sc);
 414
 415         if (!cmd) {
 416                 ccb_h->status |= CAM_REQUEUE_REQ;
 417                 xpt_done(ccb);
 418                 return (0);
 419         }
 420         if ((ccb_h->flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
 421                 if (ccb_h->flags & CAM_DIR_IN)
 422                         cmd->flags |= MRSAS_DIR_IN;
 423                 if (ccb_h->flags & CAM_DIR_OUT)
 424                         cmd->flags |= MRSAS_DIR_OUT;
 425         } else
 426                 cmd->flags = MRSAS_DIR_NONE;    /* no data */
 427
 428         /* For FreeBSD 10.0 and higher */
 429 #if (__FreeBSD_version >= 1000000)
 430         /*
 431          * XXX We don't yet support physical addresses here.
 432          */
 433         switch ((ccb->ccb_h.flags & CAM_DATA_MASK)) {
 434         case CAM_DATA_PADDR:
 435         case CAM_DATA_SG_PADDR:
 436                 device_printf(sc->mrsas_dev, "%s: physical addresses not supported\n",
 437                     __func__);
 438                 mrsas_release_mpt_cmd(cmd);
 439                 ccb_h->status = CAM_REQ_INVALID;
 440                 ccb_h->status &= ~CAM_SIM_QUEUED;
 441                 goto done;
 442         case CAM_DATA_SG:
 443                 device_printf(sc->mrsas_dev, "%s: scatter gather is not supported\n",
 444                     __func__);
 445                 mrsas_release_mpt_cmd(cmd);
 446                 ccb_h->status = CAM_REQ_INVALID;
 447                 goto done;
 448         case CAM_DATA_VADDR:
 449                 if (csio->dxfer_len > MRSAS_MAX_IO_SIZE) {
 450                         mrsas_release_mpt_cmd(cmd);
 451                         ccb_h->status = CAM_REQ_TOO_BIG;
 452                         goto done;
 453                 }
 454                 cmd->length = csio->dxfer_len;
 455                 if (cmd->length)
 456                         cmd->data = csio->data_ptr;
 457                 break;
 458         default:
 459                 ccb->ccb_h.status = CAM_REQ_INVALID;
 460                 goto done;
 461         }
 462 #else
 463         if (!(ccb_h->flags & CAM_DATA_PHYS)) {  /* Virtual data address */
 464                 if (!(ccb_h->flags & CAM_SCATTER_VALID)) {
 465                         if (csio->dxfer_len > MRSAS_MAX_IO_SIZE) {
 466                                 mrsas_release_mpt_cmd(cmd);
 467                                 ccb_h->status = CAM_REQ_TOO_BIG;
 468                                 goto done;
 469                         }
 470                         cmd->length = csio->dxfer_len;
 471                         if (cmd->length)
 472                                 cmd->data = csio->data_ptr;
 473                 } else {
 474                         mrsas_release_mpt_cmd(cmd);
 475                         ccb_h->status = CAM_REQ_INVALID;
 476                         goto done;
 477                 }
 478         } else {                        /* Data addresses are physical. */
 479                 mrsas_release_mpt_cmd(cmd);
 480                 ccb_h->status = CAM_REQ_INVALID;
 481                 ccb_h->status &= ~CAM_SIM_QUEUED;
 482                 goto done;
 483         }
 484 #endif
 485         /* save ccb ptr */
 486         cmd->ccb_ptr = ccb;
 487
 488         req_desc = mrsas_get_request_desc(sc, (cmd->index) - 1);
 489         if (!req_desc) {
 490                 device_printf(sc->mrsas_dev, "Cannot get request_descriptor.\n");
 491                 return (FAIL);
 492         }
 493         memset(req_desc, 0, sizeof(MRSAS_REQUEST_DESCRIPTOR_UNION));
 494         cmd->request_desc = req_desc;
 495
 496         if (ccb_h->flags & CAM_CDB_POINTER)
 497                 bcopy(csio->cdb_io.cdb_ptr, cmd->io_request->CDB.CDB32, csio->cdb_len);
 498         else
 499                 bcopy(csio->cdb_io.cdb_bytes, cmd->io_request->CDB.CDB32, csio->cdb_len);
 500         mtx_lock(&sc->raidmap_lock);
 501
 502         if (mrsas_ldio_inq(sim, ccb)) {
 503                 if (mrsas_build_ldio(sc, cmd, ccb)) {
 504                         device_printf(sc->mrsas_dev, "Build LDIO failed.\n");
 505                         mtx_unlock(&sc->raidmap_lock);
 506                         return (1);
 507                 }
 508         } else {
 509                 if (mrsas_build_dcdb(sc, cmd, ccb, sim)) {
 510                         device_printf(sc->mrsas_dev, "Build DCDB failed.\n");
 511                         mtx_unlock(&sc->raidmap_lock);
 512                         return (1);
 513                 }
 514         }
 515         mtx_unlock(&sc->raidmap_lock);
 516
 517         if (cmd->flags == MRSAS_DIR_IN) /* from device */
 518                 cmd->io_request->Control |= MPI2_SCSIIO_CONTROL_READ;
 519         else if (cmd->flags == MRSAS_DIR_OUT)   /* to device */
 520                 cmd->io_request->Control |= MPI2_SCSIIO_CONTROL_WRITE;
 521
 522         cmd->io_request->SGLFlags = MPI2_SGE_FLAGS_64_BIT_ADDRESSING;
 523         cmd->io_request->SGLOffset0 = offsetof(MRSAS_RAID_SCSI_IO_REQUEST, SGL) / 4;
 524         cmd->io_request->SenseBufferLowAddress = cmd->sense_phys_addr;
 525         cmd->io_request->SenseBufferLength = MRSAS_SCSI_SENSE_BUFFERSIZE;
 526
 527         req_desc = cmd->request_desc;
 528         req_desc->SCSIIO.SMID = cmd->index;
 529
 530         /*
 531          * Start timer for IO timeout. Default timeout value is 90 second.
 532          */
 533         callout_reset(&cmd->cm_callout, (sc->mrsas_io_timeout * hz) / 1000,
 534             mrsas_scsiio_timeout, cmd);
 535         mrsas_atomic_inc(&sc->fw_outstanding);
 536
 537         if (mrsas_atomic_read(&sc->fw_outstanding) > sc->io_cmds_highwater)
 538                 sc->io_cmds_highwater++;
 539
 540         mrsas_fire_cmd(sc, req_desc->addr.u.low, req_desc->addr.u.high);
 541         return (0);
 542
 543 done:
 544         xpt_done(ccb);
 545         return (0);
 546 }
 547
 548 /*
 549  * mrsas_ldio_inq:      Determines if IO is read/write or inquiry
 550  * input:                       pointer to CAM Control Block
 551  *
 552  * This function determines if the IO is read/write or inquiry.  It returns a 1
 553  * if the IO is read/write and 0 if it is inquiry.
 554  */
 555 int
 556 mrsas_ldio_inq(struct cam_sim *sim, union ccb *ccb)
 557 {
 558         struct ccb_scsiio *csio = &(ccb->csio);
 559
 560         if (cam_sim_bus(sim) == 1)
 561                 return (0);
 562
 563         switch (csio->cdb_io.cdb_bytes[0]) {
 564         case READ_10:
 565         case WRITE_10:
 566         case READ_12:
 567         case WRITE_12:
 568         case READ_6:
 569         case WRITE_6:
 570         case READ_16:
 571         case WRITE_16:
 572                 return 1;
 573         default:
 574                 return 0;
 575         }
 576 }
 577
 578 /*
 579  * mrsas_get_mpt_cmd:   Get a cmd from free command pool
 580  * input:                               Adapter instance soft state
 581  *
 582  * This function removes an MPT command from the command free list and
 583  * initializes it.
 584  */
 585 struct mrsas_mpt_cmd *
 586 mrsas_get_mpt_cmd(struct mrsas_softc *sc)
 587 {
 588         struct mrsas_mpt_cmd *cmd = NULL;
 589
 590         mtx_lock(&sc->mpt_cmd_pool_lock);
 591         if (!TAILQ_EMPTY(&sc->mrsas_mpt_cmd_list_head)) {
 592                 cmd = TAILQ_FIRST(&sc->mrsas_mpt_cmd_list_head);
 593                 TAILQ_REMOVE(&sc->mrsas_mpt_cmd_list_head, cmd, next);
 594         }
 595         memset((uint8_t *)cmd->io_request, 0, MRSAS_MPI2_RAID_DEFAULT_IO_FRAME_SIZE);
 596         cmd->data = NULL;
 597         cmd->length = 0;
 598         cmd->flags = 0;
 599         cmd->error_code = 0;
 600         cmd->load_balance = 0;
 601         cmd->ccb_ptr = NULL;
 602         mtx_unlock(&sc->mpt_cmd_pool_lock);
 603
 604         return cmd;
 605 }
 606
 607 /*
 608  * mrsas_release_mpt_cmd:       Return a cmd to free command pool
 609  * input:                                       Command packet for return to free command pool
 610  *
 611  * This function returns an MPT command to the free command list.
 612  */
 613 void
 614 mrsas_release_mpt_cmd(struct mrsas_mpt_cmd *cmd)
 615 {
 616         struct mrsas_softc *sc = cmd->sc;
 617
 618         mtx_lock(&sc->mpt_cmd_pool_lock);
 619         cmd->sync_cmd_idx = (u_int32_t)MRSAS_ULONG_MAX;
 620         TAILQ_INSERT_TAIL(&(sc->mrsas_mpt_cmd_list_head), cmd, next);
 621         mtx_unlock(&sc->mpt_cmd_pool_lock);
 622
 623         return;
 624 }
 625
 626 /*
 627  * mrsas_get_request_desc:      Get request descriptor from array
 628  * input:                                       Adapter instance soft state
 629  *                                                      SMID index
 630  *
 631  * This function returns a pointer to the request descriptor.
 632  */
 633 MRSAS_REQUEST_DESCRIPTOR_UNION *
 634 mrsas_get_request_desc(struct mrsas_softc *sc, u_int16_t index)
 635 {
 636         u_int8_t *p;
 637
 638         if (index >= sc->max_fw_cmds) {
 639                 device_printf(sc->mrsas_dev, "Invalid SMID (0x%x)request for desc\n", index);
 640                 return NULL;
 641         }
 642         p = sc->req_desc + sizeof(MRSAS_REQUEST_DESCRIPTOR_UNION) * index;
 643
 644         return (MRSAS_REQUEST_DESCRIPTOR_UNION *) p;
 645 }
 646
 647 /*
 648  * mrsas_build_ldio:    Builds an LDIO command
 649  * input:                               Adapter instance soft state
 650  *                                              Pointer to command packet
 651  *                                              Pointer to CCB
 652  *
 653  * This function builds the LDIO command packet.  It returns 0 if the command is
 654  * built successfully, otherwise it returns a 1.
 655  */
 656 int
 657 mrsas_build_ldio(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd,
 658     union ccb *ccb)
 659 {
 660         struct ccb_hdr *ccb_h = &(ccb->ccb_h);
 661         struct ccb_scsiio *csio = &(ccb->csio);
 662         u_int32_t device_id;
 663         MRSAS_RAID_SCSI_IO_REQUEST *io_request;
 664
 665         device_id = ccb_h->target_id;
 666
 667         io_request = cmd->io_request;
 668         io_request->RaidContext.VirtualDiskTgtId = device_id;
 669         io_request->RaidContext.status = 0;
 670         io_request->RaidContext.exStatus = 0;
 671
 672         /* just the cdb len, other flags zero, and ORed-in later for FP */
 673         io_request->IoFlags = csio->cdb_len;
 674
 675         if (mrsas_setup_io(sc, cmd, ccb, device_id, io_request) != SUCCESS)
 676                 device_printf(sc->mrsas_dev, "Build ldio or fpio error\n");
 677
 678         io_request->DataLength = cmd->length;
 679
 680         if (mrsas_map_request(sc, cmd) == SUCCESS) {
 681                 if (cmd->sge_count > MRSAS_MAX_SGL) {
 682                         device_printf(sc->mrsas_dev, "Error: sge_count (0x%x) exceeds"
 683                             "max (0x%x) allowed\n", cmd->sge_count, sc->max_num_sge);
 684                         return (FAIL);
 685                 }
 686                 io_request->RaidContext.numSGE = cmd->sge_count;
 687         } else {
 688                 device_printf(sc->mrsas_dev, "Data map/load failed.\n");
 689                 return (FAIL);
 690         }
 691         return (0);
 692 }
 693
 694 /*
 695  * mrsas_setup_io:      Set up data including Fast Path I/O
 696  * input:                       Adapter instance soft state
 697  *                                      Pointer to command packet
 698  *                                      Pointer to CCB
 699  *
 700  * This function builds the DCDB inquiry command.  It returns 0 if the command
 701  * is built successfully, otherwise it returns a 1.
 702  */
 703 int
 704 mrsas_setup_io(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd,
 705     union ccb *ccb, u_int32_t device_id,
 706     MRSAS_RAID_SCSI_IO_REQUEST * io_request)
 707 {
 708         struct ccb_hdr *ccb_h = &(ccb->ccb_h);
 709         struct ccb_scsiio *csio = &(ccb->csio);
 710         struct IO_REQUEST_INFO io_info;
 711         MR_DRV_RAID_MAP_ALL *map_ptr;
 712         u_int8_t fp_possible;
 713         u_int32_t start_lba_hi, start_lba_lo, ld_block_size;
 714         u_int32_t datalength = 0;
 715
 716         start_lba_lo = 0;
 717         start_lba_hi = 0;
 718         fp_possible = 0;
 719
 720         /*
 721          * READ_6 (0x08) or WRITE_6 (0x0A) cdb
 722          */
 723         if (csio->cdb_len == 6) {
 724                 datalength = (u_int32_t)csio->cdb_io.cdb_bytes[4];
 725                 start_lba_lo = ((u_int32_t)csio->cdb_io.cdb_bytes[1] << 16) |
 726                     ((u_int32_t)csio->cdb_io.cdb_bytes[2] << 8) |
 727                     (u_int32_t)csio->cdb_io.cdb_bytes[3];
 728                 start_lba_lo &= 0x1FFFFF;
 729         }
 730         /*
 731          * READ_10 (0x28) or WRITE_6 (0x2A) cdb
 732          */
 733         else if (csio->cdb_len == 10) {
 734                 datalength = (u_int32_t)csio->cdb_io.cdb_bytes[8] |
 735                     ((u_int32_t)csio->cdb_io.cdb_bytes[7] << 8);
 736                 start_lba_lo = ((u_int32_t)csio->cdb_io.cdb_bytes[2] << 24) |
 737                     ((u_int32_t)csio->cdb_io.cdb_bytes[3] << 16) |
 738                     (u_int32_t)csio->cdb_io.cdb_bytes[4] << 8 |
 739                     ((u_int32_t)csio->cdb_io.cdb_bytes[5]);
 740         }
 741         /*
 742          * READ_12 (0xA8) or WRITE_12 (0xAA) cdb
 743          */
 744         else if (csio->cdb_len == 12) {
 745                 datalength = (u_int32_t)csio->cdb_io.cdb_bytes[6] << 24 |
 746                     ((u_int32_t)csio->cdb_io.cdb_bytes[7] << 16) |
 747                     ((u_int32_t)csio->cdb_io.cdb_bytes[8] << 8) |
 748                     ((u_int32_t)csio->cdb_io.cdb_bytes[9]);
 749                 start_lba_lo = ((u_int32_t)csio->cdb_io.cdb_bytes[2] << 24) |
 750                     ((u_int32_t)csio->cdb_io.cdb_bytes[3] << 16) |
 751                     (u_int32_t)csio->cdb_io.cdb_bytes[4] << 8 |
 752                     ((u_int32_t)csio->cdb_io.cdb_bytes[5]);
 753         }
 754         /*
 755          * READ_16 (0x88) or WRITE_16 (0xx8A) cdb
 756          */
 757         else if (csio->cdb_len == 16) {
 758                 datalength = (u_int32_t)csio->cdb_io.cdb_bytes[10] << 24 |
 759                     ((u_int32_t)csio->cdb_io.cdb_bytes[11] << 16) |
 760                     ((u_int32_t)csio->cdb_io.cdb_bytes[12] << 8) |
 761                     ((u_int32_t)csio->cdb_io.cdb_bytes[13]);
 762                 start_lba_lo = ((u_int32_t)csio->cdb_io.cdb_bytes[6] << 24) |
 763                     ((u_int32_t)csio->cdb_io.cdb_bytes[7] << 16) |
 764                     (u_int32_t)csio->cdb_io.cdb_bytes[8] << 8 |
 765                     ((u_int32_t)csio->cdb_io.cdb_bytes[9]);
 766                 start_lba_hi = ((u_int32_t)csio->cdb_io.cdb_bytes[2] << 24) |
 767                     ((u_int32_t)csio->cdb_io.cdb_bytes[3] << 16) |
 768                     (u_int32_t)csio->cdb_io.cdb_bytes[4] << 8 |
 769                     ((u_int32_t)csio->cdb_io.cdb_bytes[5]);
 770         }
 771         memset(&io_info, 0, sizeof(struct IO_REQUEST_INFO));
 772         io_info.ldStartBlock = ((u_int64_t)start_lba_hi << 32) | start_lba_lo;
 773         io_info.numBlocks = datalength;
 774         io_info.ldTgtId = device_id;
 775
 776         switch (ccb_h->flags & CAM_DIR_MASK) {
 777         case CAM_DIR_IN:
 778                 io_info.isRead = 1;
 779                 break;
 780         case CAM_DIR_OUT:
 781                 io_info.isRead = 0;
 782                 break;
 783         case CAM_DIR_NONE:
 784         default:
 785                 mrsas_dprint(sc, MRSAS_TRACE, "From %s : DMA Flag is %d \n", __func__, ccb_h->flags & CAM_DIR_MASK);
 786                 break;
 787         }
 788
 789         map_ptr = sc->ld_drv_map[(sc->map_id & 1)];
 790         ld_block_size = MR_LdBlockSizeGet(device_id, map_ptr, sc);
 791
 792         if ((MR_TargetIdToLdGet(device_id, map_ptr) >= MAX_LOGICAL_DRIVES_EXT) ||
 793             (!sc->fast_path_io)) {
 794                 io_request->RaidContext.regLockFlags = 0;
 795                 fp_possible = 0;
 796         } else {
 797                 if (MR_BuildRaidContext(sc, &io_info, &io_request->RaidContext, map_ptr))
 798                         fp_possible = io_info.fpOkForIo;
 799         }
 800
 801         cmd->request_desc->SCSIIO.MSIxIndex =
 802             sc->msix_vectors ? smp_processor_id() % sc->msix_vectors : 0;
 803
 804
 805         if (fp_possible) {
 806                 mrsas_set_pd_lba(io_request, csio->cdb_len, &io_info, ccb, map_ptr,
 807                     start_lba_lo, ld_block_size);
 808                 io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
 809                 cmd->request_desc->SCSIIO.RequestFlags =
 810                     (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY <<
 811                     MRSAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
 812                 if ((sc->device_id == MRSAS_INVADER) || (sc->device_id == MRSAS_FURY)) {
 813                         if (io_request->RaidContext.regLockFlags == REGION_TYPE_UNUSED)
 814                                 cmd->request_desc->SCSIIO.RequestFlags =
 815                                     (MRSAS_REQ_DESCRIPT_FLAGS_NO_LOCK <<
 816                                     MRSAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
 817                         io_request->RaidContext.Type = MPI2_TYPE_CUDA;
 818                         io_request->RaidContext.nseg = 0x1;
 819                         io_request->IoFlags |= MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH;
 820                         io_request->RaidContext.regLockFlags |=
 821                             (MR_RL_FLAGS_GRANT_DESTINATION_CUDA |
 822                             MR_RL_FLAGS_SEQ_NUM_ENABLE);
 823                 }
 824                 if ((sc->load_balance_info[device_id].loadBalanceFlag) &&
 825                     (io_info.isRead)) {
 826                         io_info.devHandle =
 827                             mrsas_get_updated_dev_handle(&sc->load_balance_info[device_id],
 828                             &io_info);
 829                         cmd->load_balance = MRSAS_LOAD_BALANCE_FLAG;
 830                 } else
 831                         cmd->load_balance = 0;
 832                 cmd->request_desc->SCSIIO.DevHandle = io_info.devHandle;
 833                 io_request->DevHandle = io_info.devHandle;
 834         } else {
 835                 /* Not FP IO */
 836                 io_request->RaidContext.timeoutValue = map_ptr->raidMap.fpPdIoTimeoutSec;
 837                 cmd->request_desc->SCSIIO.RequestFlags =
 838                     (MRSAS_REQ_DESCRIPT_FLAGS_LD_IO <<
 839                     MRSAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
 840                 if ((sc->device_id == MRSAS_INVADER) || (sc->device_id == MRSAS_FURY)) {
 841                         if (io_request->RaidContext.regLockFlags == REGION_TYPE_UNUSED)
 842                                 cmd->request_desc->SCSIIO.RequestFlags =
 843                                     (MRSAS_REQ_DESCRIPT_FLAGS_NO_LOCK <<
 844                                     MRSAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
 845                         io_request->RaidContext.Type = MPI2_TYPE_CUDA;
 846                         io_request->RaidContext.regLockFlags |=
 847                             (MR_RL_FLAGS_GRANT_DESTINATION_CPU0 |
 848                             MR_RL_FLAGS_SEQ_NUM_ENABLE);
 849                         io_request->RaidContext.nseg = 0x1;
 850                 }
 851                 io_request->Function = MRSAS_MPI2_FUNCTION_LD_IO_REQUEST;
 852                 io_request->DevHandle = device_id;
 853         }
 854         return (0);
 855 }
 856
 857 /*
 858  * mrsas_build_dcdb:    Builds an DCDB command
 859  * input:                               Adapter instance soft state
 860  *                                              Pointer to command packet
 861  *                                              Pointer to CCB
 862  *
 863  * This function builds the DCDB inquiry command.  It returns 0 if the command
 864  * is built successfully, otherwise it returns a 1.
 865  */
 866 int
 867 mrsas_build_dcdb(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd,
 868     union ccb *ccb, struct cam_sim *sim)
 869 {
 870         struct ccb_hdr *ccb_h = &(ccb->ccb_h);
 871         u_int32_t device_id;
 872         MR_DRV_RAID_MAP_ALL *map_ptr;
 873         MRSAS_RAID_SCSI_IO_REQUEST *io_request;
 874
 875         io_request = cmd->io_request;
 876         device_id = ccb_h->target_id;
 877         map_ptr = sc->ld_drv_map[(sc->map_id & 1)];
 878
 879         /* Check if this is for system PD */
 880         if (cam_sim_bus(sim) == 1 &&
 881             sc->pd_list[device_id].driveState == MR_PD_STATE_SYSTEM) {
 882                 io_request->Function = 0;
 883                 io_request->DevHandle = map_ptr->raidMap.devHndlInfo[device_id].
 884                     curDevHdl;
 885                 io_request->RaidContext.timeoutValue = map_ptr->raidMap.fpPdIoTimeoutSec;
 886                 io_request->RaidContext.regLockFlags = 0;
 887                 io_request->RaidContext.regLockRowLBA = 0;
 888                 io_request->RaidContext.regLockLength = 0;
 889
 890                 io_request->RaidContext.RAIDFlags = MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD
 891                     << MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;
 892                 if ((sc->device_id == MRSAS_INVADER) || (sc->device_id == MRSAS_FURY))
 893                         io_request->IoFlags |= MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH;
 894                 cmd->request_desc->SCSIIO.RequestFlags =
 895                     (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY <<
 896                     MRSAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
 897                 cmd->request_desc->SCSIIO.DevHandle =
 898                     map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
 899                 cmd->request_desc->SCSIIO.MSIxIndex =
 900                     sc->msix_vectors ? smp_processor_id() % sc->msix_vectors : 0;
 901
 902         } else {
 903                 io_request->Function = MRSAS_MPI2_FUNCTION_LD_IO_REQUEST;
 904                 io_request->DevHandle = device_id;
 905                 cmd->request_desc->SCSIIO.RequestFlags =
 906                     (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
 907                     MRSAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
 908         }
 909
 910         io_request->RaidContext.VirtualDiskTgtId = device_id;
 911         io_request->LUN[1] = ccb_h->target_lun & 0xF;
 912         io_request->DataLength = cmd->length;
 913
 914         if (mrsas_map_request(sc, cmd) == SUCCESS) {
 915                 if (cmd->sge_count > sc->max_num_sge) {
 916                         device_printf(sc->mrsas_dev, "Error: sge_count (0x%x) exceeds"
 917                             "max (0x%x) allowed\n", cmd->sge_count, sc->max_num_sge);
 918                         return (1);
 919                 }
 920                 io_request->RaidContext.numSGE = cmd->sge_count;
 921         } else {
 922                 device_printf(sc->mrsas_dev, "Data map/load failed.\n");
 923                 return (1);
 924         }
 925         return (0);
 926 }
 927
 928 /*
 929  * mrsas_map_request:   Map and load data
 930  * input:                               Adapter instance soft state
 931  *                                              Pointer to command packet
 932  *
 933  * For data from OS, map and load the data buffer into bus space.  The SG list
 934  * is built in the callback.  If the  bus dmamap load is not successful,
 935  * cmd->error_code will contain the  error code and a 1 is returned.
 936  */
 937 int
 938 mrsas_map_request(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd)
 939 {
 940         u_int32_t retcode = 0;
 941         struct cam_sim *sim;
 942         int flag = BUS_DMA_NOWAIT;
 943
 944         sim = xpt_path_sim(cmd->ccb_ptr->ccb_h.path);
 945
 946         if (cmd->data != NULL) {
 947                 mtx_lock(&sc->io_lock);
 948                 /* Map data buffer into bus space */
 949                 retcode = bus_dmamap_load(sc->data_tag, cmd->data_dmamap, cmd->data,
 950                     cmd->length, mrsas_data_load_cb, cmd, flag);
 951                 mtx_unlock(&sc->io_lock);
 952                 if (retcode)
 953                         device_printf(sc->mrsas_dev, "bus_dmamap_load(): retcode = %d\n", retcode);
 954                 if (retcode == EINPROGRESS) {
 955                         device_printf(sc->mrsas_dev, "request load in progress\n");
 956                         mrsas_freeze_simq(cmd, sim);
 957                 }
 958         }
 959         if (cmd->error_code)
 960                 return (1);
 961         return (retcode);
 962 }
 963
 964 /*
 965  * mrsas_unmap_request: Unmap and unload data
 966  * input:                               Adapter instance soft state
 967  *                                              Pointer to command packet
 968  *
 969  * This function unmaps and unloads data from OS.
 970  */
 971 void
 972 mrsas_unmap_request(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd)
 973 {
 974         if (cmd->data != NULL) {
 975                 if (cmd->flags & MRSAS_DIR_IN)
 976                         bus_dmamap_sync(sc->data_tag, cmd->data_dmamap, BUS_DMASYNC_POSTREAD);
 977                 if (cmd->flags & MRSAS_DIR_OUT)
 978                         bus_dmamap_sync(sc->data_tag, cmd->data_dmamap, BUS_DMASYNC_POSTWRITE);
 979                 mtx_lock(&sc->io_lock);
 980                 bus_dmamap_unload(sc->data_tag, cmd->data_dmamap);
 981                 mtx_unlock(&sc->io_lock);
 982         }
 983 }
 984
 985 /*
 986  * mrsas_data_load_cb:  Callback entry point
 987  * input:                               Pointer to command packet as argument
 988  *                                              Pointer to segment
 989  *                                              Number of segments Error
 990  *
 991  * This is the callback function of the bus dma map load.  It builds the SG
 992  * list.
 993  */
 994 static void
 995 mrsas_data_load_cb(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 996 {
 997         struct mrsas_mpt_cmd *cmd = (struct mrsas_mpt_cmd *)arg;
 998         struct mrsas_softc *sc = cmd->sc;
 999         MRSAS_RAID_SCSI_IO_REQUEST *io_request;
1000         pMpi25IeeeSgeChain64_t sgl_ptr;
1001         int i = 0, sg_processed = 0;
1002
1003         if (error) {
1004                 cmd->error_code = error;
1005                 device_printf(sc->mrsas_dev, "mrsas_data_load_cb: error=%d\n", error);
1006                 if (error == EFBIG) {
1007                         cmd->ccb_ptr->ccb_h.status = CAM_REQ_TOO_BIG;
1008                         return;
1009                 }
1010         }
1011         if (cmd->flags & MRSAS_DIR_IN)
1012                 bus_dmamap_sync(cmd->sc->data_tag, cmd->data_dmamap,
1013                     BUS_DMASYNC_PREREAD);
1014         if (cmd->flags & MRSAS_DIR_OUT)
1015                 bus_dmamap_sync(cmd->sc->data_tag, cmd->data_dmamap,
1016                     BUS_DMASYNC_PREWRITE);
1017         if (nseg > sc->max_num_sge) {
1018                 device_printf(sc->mrsas_dev, "SGE count is too large or 0.\n");
1019                 return;
1020         }
1021         io_request = cmd->io_request;
1022         sgl_ptr = (pMpi25IeeeSgeChain64_t)&io_request->SGL;
1023
1024         if ((sc->device_id == MRSAS_INVADER) || (sc->device_id == MRSAS_FURY)) {
1025                 pMpi25IeeeSgeChain64_t sgl_ptr_end = sgl_ptr;
1026
1027                 sgl_ptr_end += sc->max_sge_in_main_msg - 1;
1028                 sgl_ptr_end->Flags = 0;
1029         }
1030         if (nseg != 0) {
1031                 for (i = 0; i < nseg; i++) {
1032                         sgl_ptr->Address = segs[i].ds_addr;
1033                         sgl_ptr->Length = segs[i].ds_len;
1034                         sgl_ptr->Flags = 0;
1035                         if ((sc->device_id == MRSAS_INVADER) || (sc->device_id == MRSAS_FURY)) {
1036                                 if (i == nseg - 1)
1037                                         sgl_ptr->Flags = IEEE_SGE_FLAGS_END_OF_LIST;
1038                         }
1039                         sgl_ptr++;
1040                         sg_processed = i + 1;
1041                         if ((sg_processed == (sc->max_sge_in_main_msg - 1)) &&
1042                             (nseg > sc->max_sge_in_main_msg)) {
1043                                 pMpi25IeeeSgeChain64_t sg_chain;
1044
1045                                 if ((sc->device_id == MRSAS_INVADER) || (sc->device_id == MRSAS_FURY)) {
1046                                         if ((cmd->io_request->IoFlags & MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH)
1047                                             != MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH)
1048                                                 cmd->io_request->ChainOffset = sc->chain_offset_io_request;
1049                                         else
1050                                                 cmd->io_request->ChainOffset = 0;
1051                                 } else
1052                                         cmd->io_request->ChainOffset = sc->chain_offset_io_request;
1053                                 sg_chain = sgl_ptr;
1054                                 if ((sc->device_id == MRSAS_INVADER) || (sc->device_id == MRSAS_FURY))
1055                                         sg_chain->Flags = IEEE_SGE_FLAGS_CHAIN_ELEMENT;
1056                                 else
1057                                         sg_chain->Flags = (IEEE_SGE_FLAGS_CHAIN_ELEMENT | MPI2_IEEE_SGE_FLAGS_IOCPLBNTA_ADDR);
1058                                 sg_chain->Length = (sizeof(MPI2_SGE_IO_UNION) * (nseg - sg_processed));
1059                                 sg_chain->Address = cmd->chain_frame_phys_addr;
1060                                 sgl_ptr = (pMpi25IeeeSgeChain64_t)cmd->chain_frame;
1061                         }
1062                 }
1063         }
1064         cmd->sge_count = nseg;
1065 }
1066
1067 /*
1068  * mrsas_freeze_simq:   Freeze SIM queue
1069  * input:                               Pointer to command packet
1070  *                                              Pointer to SIM
1071  *
1072  * This function freezes the sim queue.
1073  */
1074 static void
1075 mrsas_freeze_simq(struct mrsas_mpt_cmd *cmd, struct cam_sim *sim)
1076 {
1077         union ccb *ccb = (union ccb *)(cmd->ccb_ptr);
1078
1079         xpt_freeze_simq(sim, 1);
1080         ccb->ccb_h.status |= CAM_RELEASE_SIMQ;
1081         ccb->ccb_h.status |= CAM_REQUEUE_REQ;
1082 }
1083
1084 void
1085 mrsas_xpt_freeze(struct mrsas_softc *sc)
1086 {
1087         xpt_freeze_simq(sc->sim_0, 1);
1088         xpt_freeze_simq(sc->sim_1, 1);
1089 }
1090
1091 void
1092 mrsas_xpt_release(struct mrsas_softc *sc)
1093 {
1094         xpt_release_simq(sc->sim_0, 1);
1095         xpt_release_simq(sc->sim_1, 1);
1096 }
1097
1098 /*
1099  * mrsas_cmd_done:      Perform remaining command completion
1100  * input:                       Adapter instance soft state  Pointer to command packet
1101  *
1102  * This function calls ummap request and releases the MPT command.
1103  */
1104 void
1105 mrsas_cmd_done(struct mrsas_softc *sc, struct mrsas_mpt_cmd *cmd)
1106 {
1107         callout_stop(&cmd->cm_callout);
1108         mrsas_unmap_request(sc, cmd);
1109         mtx_lock(&sc->sim_lock);
1110         xpt_done(cmd->ccb_ptr);
1111         cmd->ccb_ptr = NULL;
1112         mtx_unlock(&sc->sim_lock);
1113         mrsas_release_mpt_cmd(cmd);
1114 }
1115
1116 /*
1117  * mrsas_cam_poll:      Polling entry point
1118  * input:                       Pointer to SIM
1119  *
1120  * This is currently a stub function.
1121  */
1122 static void
1123 mrsas_cam_poll(struct cam_sim *sim)
1124 {
1125         struct mrsas_softc *sc = (struct mrsas_softc *)cam_sim_softc(sim);
1126
1127         mrsas_isr((void *)sc);
1128 }
1129
1130 /*
1131  * mrsas_bus_scan:      Perform bus scan
1132  * input:                       Adapter instance soft state
1133  *
1134  * This mrsas_bus_scan function is needed for FreeBSD 7.x.  Also, it should not
1135  * be called in FreeBSD 8.x and later versions, where the bus scan is
1136  * automatic.
1137  */
1138 int
1139 mrsas_bus_scan(struct mrsas_softc *sc)
1140 {
1141         union ccb *ccb_0;
1142         union ccb *ccb_1;
1143
1144         if ((ccb_0 = xpt_alloc_ccb()) == NULL) {
1145                 return (ENOMEM);
1146         }
1147         if ((ccb_1 = xpt_alloc_ccb()) == NULL) {
1148                 xpt_free_ccb(ccb_0);
1149                 return (ENOMEM);
1150         }
1151         mtx_lock(&sc->sim_lock);
1152         if (xpt_create_path(&ccb_0->ccb_h.path, xpt_periph, cam_sim_path(sc->sim_0),
1153             CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
1154                 xpt_free_ccb(ccb_0);
1155                 xpt_free_ccb(ccb_1);
1156                 mtx_unlock(&sc->sim_lock);
1157                 return (EIO);
1158         }
1159         if (xpt_create_path(&ccb_1->ccb_h.path, xpt_periph, cam_sim_path(sc->sim_1),
1160             CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
1161                 xpt_free_ccb(ccb_0);
1162                 xpt_free_ccb(ccb_1);
1163                 mtx_unlock(&sc->sim_lock);
1164                 return (EIO);
1165         }
1166         mtx_unlock(&sc->sim_lock);
1167         xpt_rescan(ccb_0);
1168         xpt_rescan(ccb_1);
1169
1170         return (0);
1171 }
1172
1173 /*
1174  * mrsas_bus_scan_sim:  Perform bus scan per SIM
1175  * input:                               adapter instance soft state
1176  *
1177  * This function will be called from Event handler on LD creation/deletion,
1178  * JBOD on/off.
1179  */
1180 int
1181 mrsas_bus_scan_sim(struct mrsas_softc *sc, struct cam_sim *sim)
1182 {
1183         union ccb *ccb;
1184
1185         if ((ccb = xpt_alloc_ccb()) == NULL) {
1186                 return (ENOMEM);
1187         }
1188         mtx_lock(&sc->sim_lock);
1189         if (xpt_create_path(&ccb->ccb_h.path, xpt_periph, cam_sim_path(sim),
1190             CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
1191                 xpt_free_ccb(ccb);
1192                 mtx_unlock(&sc->sim_lock);
1193                 return (EIO);
1194         }
1195         mtx_unlock(&sc->sim_lock);
1196         xpt_rescan(ccb);
1197
1198         return (0);
1199 }