sys/dev/mpr/mpr_sas.c

   1 /*-
   2  * Copyright (c) 2009 Yahoo! Inc.
   3  * Copyright (c) 2011-2015 LSI Corp.
   4  * Copyright (c) 2013-2016 Avago Technologies
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * Avago Technologies (LSI) MPT-Fusion Host Adapter FreeBSD
  29  *
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 /* Communications core for Avago Technologies (LSI) MPT3 */
  36
  37 /* TODO Move headers to mprvar */
  38 #include <sys/types.h>
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/kernel.h>
  42 #include <sys/selinfo.h>
  43 #include <sys/module.h>
  44 #include <sys/bus.h>
  45 #include <sys/conf.h>
  46 #include <sys/bio.h>
  47 #include <sys/malloc.h>
  48 #include <sys/uio.h>
  49 #include <sys/sysctl.h>
  50 #include <sys/endian.h>
  51 #include <sys/queue.h>
  52 #include <sys/kthread.h>
  53 #include <sys/taskqueue.h>
  54 #include <sys/sbuf.h>
  55
  56 #include <machine/bus.h>
  57 #include <machine/resource.h>
  58 #include <sys/rman.h>
  59
  60 #include <machine/stdarg.h>
  61
  62 #include <cam/cam.h>
  63 #include <cam/cam_ccb.h>
  64 #include <cam/cam_debug.h>
  65 #include <cam/cam_sim.h>
  66 #include <cam/cam_xpt_sim.h>
  67 #include <cam/cam_xpt_periph.h>
  68 #include <cam/cam_periph.h>
  69 #include <cam/scsi/scsi_all.h>
  70 #include <cam/scsi/scsi_message.h>
  71 #if __FreeBSD_version >= 900026
  72 #include <cam/scsi/smp_all.h>
  73 #endif
  74
  75 #include <dev/nvme/nvme.h>
  76
  77 #include <dev/mpr/mpi/mpi2_type.h>
  78 #include <dev/mpr/mpi/mpi2.h>
  79 #include <dev/mpr/mpi/mpi2_ioc.h>
  80 #include <dev/mpr/mpi/mpi2_sas.h>
  81 #include <dev/mpr/mpi/mpi2_pci.h>
  82 #include <dev/mpr/mpi/mpi2_cnfg.h>
  83 #include <dev/mpr/mpi/mpi2_init.h>
  84 #include <dev/mpr/mpi/mpi2_tool.h>
  85 #include <dev/mpr/mpr_ioctl.h>
  86 #include <dev/mpr/mprvar.h>
  87 #include <dev/mpr/mpr_table.h>
  88 #include <dev/mpr/mpr_sas.h>
  89
  90 #define MPRSAS_DISCOVERY_TIMEOUT        20
  91 #define MPRSAS_MAX_DISCOVERY_TIMEOUTS   10 /* 200 seconds */
  92
  93 /*
  94  * static array to check SCSI OpCode for EEDP protection bits
  95  */
  96 #define PRO_R MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP
  97 #define PRO_W MPI2_SCSIIO_EEDPFLAGS_INSERT_OP
  98 #define PRO_V MPI2_SCSIIO_EEDPFLAGS_INSERT_OP
  99 static uint8_t op_code_prot[256] = {
 100         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 101         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 102         0, 0, 0, 0, 0, 0, 0, 0, PRO_R, 0, PRO_W, 0, 0, 0, PRO_W, PRO_V,
 103         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 104         0, PRO_W, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 105         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 106         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 107         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 108         0, 0, 0, 0, 0, 0, 0, 0, PRO_R, 0, PRO_W, 0, 0, 0, PRO_W, PRO_V,
 109         0, 0, 0, PRO_W, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 110         0, 0, 0, 0, 0, 0, 0, 0, PRO_R, 0, PRO_W, 0, 0, 0, PRO_W, PRO_V,
 111         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 112         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 113         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 114         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 115         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 116 };
 117
 118 MALLOC_DEFINE(M_MPRSAS, "MPRSAS", "MPR SAS memory");
 119
 120 static void mprsas_remove_device(struct mpr_softc *, struct mpr_command *);
 121 static void mprsas_remove_complete(struct mpr_softc *, struct mpr_command *);
 122 static void mprsas_action(struct cam_sim *sim, union ccb *ccb);
 123 static void mprsas_poll(struct cam_sim *sim);
 124 static void mprsas_scsiio_timeout(void *data);
 125 static void mprsas_abort_complete(struct mpr_softc *sc, struct mpr_command *cm);
 126 static void mprsas_action_scsiio(struct mprsas_softc *, union ccb *);
 127 static void mprsas_scsiio_complete(struct mpr_softc *, struct mpr_command *);
 128 static void mprsas_action_resetdev(struct mprsas_softc *, union ccb *);
 129 static void mprsas_resetdev_complete(struct mpr_softc *, struct mpr_command *);
 130 static int mprsas_send_abort(struct mpr_softc *sc, struct mpr_command *tm,
 131     struct mpr_command *cm);
 132 static void mprsas_async(void *callback_arg, uint32_t code,
 133     struct cam_path *path, void *arg);
 134 #if (__FreeBSD_version < 901503) || \
 135     ((__FreeBSD_version >= 1000000) && (__FreeBSD_version < 1000006))
 136 static void mprsas_check_eedp(struct mpr_softc *sc, struct cam_path *path,
 137     struct ccb_getdev *cgd);
 138 static void mprsas_read_cap_done(struct cam_periph *periph,
 139     union ccb *done_ccb);
 140 #endif
 141 static int mprsas_send_portenable(struct mpr_softc *sc);
 142 static void mprsas_portenable_complete(struct mpr_softc *sc,
 143     struct mpr_command *cm);
 144
 145 #if __FreeBSD_version >= 900026
 146 static void mprsas_smpio_complete(struct mpr_softc *sc, struct mpr_command *cm);
 147 static void mprsas_send_smpcmd(struct mprsas_softc *sassc, union ccb *ccb,
 148     uint64_t sasaddr);
 149 static void mprsas_action_smpio(struct mprsas_softc *sassc, union ccb *ccb);
 150 #endif //FreeBSD_version >= 900026
 151
 152 struct mprsas_target *
 153 mprsas_find_target_by_handle(struct mprsas_softc *sassc, int start,
 154     uint16_t handle)
 155 {
 156         struct mprsas_target *target;
 157         int i;
 158
 159         for (i = start; i < sassc->maxtargets; i++) {
 160                 target = &sassc->targets[i];
 161                 if (target->handle == handle)
 162                         return (target);
 163         }
 164
 165         return (NULL);
 166 }
 167
 168 /* we need to freeze the simq during attach and diag reset, to avoid failing
 169  * commands before device handles have been found by discovery.  Since
 170  * discovery involves reading config pages and possibly sending commands,
 171  * discovery actions may continue even after we receive the end of discovery
 172  * event, so refcount discovery actions instead of assuming we can unfreeze
 173  * the simq when we get the event.
 174  */
 175 void
 176 mprsas_startup_increment(struct mprsas_softc *sassc)
 177 {
 178         MPR_FUNCTRACE(sassc->sc);
 179
 180         if ((sassc->flags & MPRSAS_IN_STARTUP) != 0) {
 181                 if (sassc->startup_refcount++ == 0) {
 182                         /* just starting, freeze the simq */
 183                         mpr_dprint(sassc->sc, MPR_INIT,
 184                             "%s freezing simq\n", __func__);
 185 #if (__FreeBSD_version >= 1000039) || \
 186     ((__FreeBSD_version < 1000000) && (__FreeBSD_version >= 902502))
 187                         xpt_hold_boot();
 188 #endif
 189                         xpt_freeze_simq(sassc->sim, 1);
 190                 }
 191                 mpr_dprint(sassc->sc, MPR_INIT, "%s refcount %u\n", __func__,
 192                     sassc->startup_refcount);
 193         }
 194 }
 195
 196 void
 197 mprsas_release_simq_reinit(struct mprsas_softc *sassc)
 198 {
 199         if (sassc->flags & MPRSAS_QUEUE_FROZEN) {
 200                 sassc->flags &= ~MPRSAS_QUEUE_FROZEN;
 201                 xpt_release_simq(sassc->sim, 1);
 202                 mpr_dprint(sassc->sc, MPR_INFO, "Unfreezing SIM queue\n");
 203         }
 204 }
 205
 206 void
 207 mprsas_startup_decrement(struct mprsas_softc *sassc)
 208 {
 209         MPR_FUNCTRACE(sassc->sc);
 210
 211         if ((sassc->flags & MPRSAS_IN_STARTUP) != 0) {
 212                 if (--sassc->startup_refcount == 0) {
 213                         /* finished all discovery-related actions, release
 214                          * the simq and rescan for the latest topology.
 215                          */
 216                         mpr_dprint(sassc->sc, MPR_INIT,
 217                             "%s releasing simq\n", __func__);
 218                         sassc->flags &= ~MPRSAS_IN_STARTUP;
 219                         xpt_release_simq(sassc->sim, 1);
 220 #if (__FreeBSD_version >= 1000039) || \
 221     ((__FreeBSD_version < 1000000) && (__FreeBSD_version >= 902502))
 222                         xpt_release_boot();
 223 #else
 224                         mprsas_rescan_target(sassc->sc, NULL);
 225 #endif
 226                 }
 227                 mpr_dprint(sassc->sc, MPR_INIT, "%s refcount %u\n", __func__,
 228                     sassc->startup_refcount);
 229         }
 230 }
 231
 232 /* The firmware requires us to stop sending commands when we're doing task
 233  * management, so refcount the TMs and keep the simq frozen when any are in
 234  * use.
 235  */
 236 struct mpr_command *
 237 mprsas_alloc_tm(struct mpr_softc *sc)
 238 {
 239         struct mpr_command *tm;
 240
 241         MPR_FUNCTRACE(sc);
 242         tm = mpr_alloc_high_priority_command(sc);
 243         return tm;
 244 }
 245
 246 void
 247 mprsas_free_tm(struct mpr_softc *sc, struct mpr_command *tm)
 248 {
 249         int target_id = 0xFFFFFFFF;
 250
 251         MPR_FUNCTRACE(sc);
 252         if (tm == NULL)
 253                 return;
 254
 255         /*
 256          * For TM's the devq is frozen for the device.  Unfreeze it here and
 257          * free the resources used for freezing the devq.  Must clear the
 258          * INRESET flag as well or scsi I/O will not work.
 259          */
 260         if (tm->cm_targ != NULL) {
 261                 tm->cm_targ->flags &= ~MPRSAS_TARGET_INRESET;
 262                 target_id = tm->cm_targ->tid;
 263         }
 264         if (tm->cm_ccb) {
 265                 mpr_dprint(sc, MPR_INFO, "Unfreezing devq for target ID %d\n",
 266                     target_id);
 267                 xpt_release_devq(tm->cm_ccb->ccb_h.path, 1, TRUE);
 268                 xpt_free_path(tm->cm_ccb->ccb_h.path);
 269                 xpt_free_ccb(tm->cm_ccb);
 270         }
 271
 272         mpr_free_high_priority_command(sc, tm);
 273 }
 274
 275 void
 276 mprsas_rescan_target(struct mpr_softc *sc, struct mprsas_target *targ)
 277 {
 278         struct mprsas_softc *sassc = sc->sassc;
 279         path_id_t pathid;
 280         target_id_t targetid;
 281         union ccb *ccb;
 282
 283         MPR_FUNCTRACE(sc);
 284         pathid = cam_sim_path(sassc->sim);
 285         if (targ == NULL)
 286                 targetid = CAM_TARGET_WILDCARD;
 287         else
 288                 targetid = targ - sassc->targets;
 289
 290         /*
 291          * Allocate a CCB and schedule a rescan.
 292          */
 293         ccb = xpt_alloc_ccb_nowait();
 294         if (ccb == NULL) {
 295                 mpr_dprint(sc, MPR_ERROR, "unable to alloc CCB for rescan\n");
 296                 return;
 297         }
 298
 299         if (xpt_create_path(&ccb->ccb_h.path, NULL, pathid, targetid,
 300             CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
 301                 mpr_dprint(sc, MPR_ERROR, "unable to create path for rescan\n");
 302                 xpt_free_ccb(ccb);
 303                 return;
 304         }
 305
 306         if (targetid == CAM_TARGET_WILDCARD)
 307                 ccb->ccb_h.func_code = XPT_SCAN_BUS;
 308         else
 309                 ccb->ccb_h.func_code = XPT_SCAN_TGT;
 310
 311         mpr_dprint(sc, MPR_TRACE, "%s targetid %u\n", __func__, targetid);
 312         xpt_rescan(ccb);
 313 }
 314
 315 static void
 316 mprsas_log_command(struct mpr_command *cm, u_int level, const char *fmt, ...)
 317 {
 318         struct sbuf sb;
 319         va_list ap;
 320         char str[192];
 321         char path_str[64];
 322
 323         if (cm == NULL)
 324                 return;
 325
 326         /* No need to be in here if debugging isn't enabled */
 327         if ((cm->cm_sc->mpr_debug & level) == 0)
 328                 return;
 329
 330         sbuf_new(&sb, str, sizeof(str), 0);
 331
 332         va_start(ap, fmt);
 333
 334         if (cm->cm_ccb != NULL) {
 335                 xpt_path_string(cm->cm_ccb->csio.ccb_h.path, path_str,
 336                     sizeof(path_str));
 337                 sbuf_cat(&sb, path_str);
 338                 if (cm->cm_ccb->ccb_h.func_code == XPT_SCSI_IO) {
 339                         scsi_command_string(&cm->cm_ccb->csio, &sb);
 340                         sbuf_printf(&sb, "length %d ",
 341                             cm->cm_ccb->csio.dxfer_len);
 342                 }
 343         } else {
 344                 sbuf_printf(&sb, "(noperiph:%s%d:%u:%u:%u): ",
 345                     cam_sim_name(cm->cm_sc->sassc->sim),
 346                     cam_sim_unit(cm->cm_sc->sassc->sim),
 347                     cam_sim_bus(cm->cm_sc->sassc->sim),
 348                     cm->cm_targ ? cm->cm_targ->tid : 0xFFFFFFFF,
 349                     cm->cm_lun);
 350         }
 351
 352         sbuf_printf(&sb, "SMID %u ", cm->cm_desc.Default.SMID);
 353         sbuf_vprintf(&sb, fmt, ap);
 354         sbuf_finish(&sb);
 355         mpr_print_field(cm->cm_sc, "%s", sbuf_data(&sb));
 356
 357         va_end(ap);
 358 }
 359
 360 static void
 361 mprsas_remove_volume(struct mpr_softc *sc, struct mpr_command *tm)
 362 {
 363         MPI2_SCSI_TASK_MANAGE_REPLY *reply;
 364         struct mprsas_target *targ;
 365         uint16_t handle;
 366
 367         MPR_FUNCTRACE(sc);
 368
 369         reply = (MPI2_SCSI_TASK_MANAGE_REPLY *)tm->cm_reply;
 370         handle = (uint16_t)(uintptr_t)tm->cm_complete_data;
 371         targ = tm->cm_targ;
 372
 373         if (reply == NULL) {
 374                 /* XXX retry the remove after the diag reset completes? */
 375                 mpr_dprint(sc, MPR_FAULT, "%s NULL reply resetting device "
 376                     "0x%04x\n", __func__, handle);
 377                 mprsas_free_tm(sc, tm);
 378                 return;
 379         }
 380
 381         if ((le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK) !=
 382             MPI2_IOCSTATUS_SUCCESS) {
 383                 mpr_dprint(sc, MPR_ERROR, "IOCStatus = 0x%x while resetting "
 384                     "device 0x%x\n", le16toh(reply->IOCStatus), handle);
 385         }
 386
 387         mpr_dprint(sc, MPR_XINFO, "Reset aborted %u commands\n",
 388             le32toh(reply->TerminationCount));
 389         mpr_free_reply(sc, tm->cm_reply_data);
 390         tm->cm_reply = NULL;    /* Ensures the reply won't get re-freed */
 391
 392         mpr_dprint(sc, MPR_XINFO, "clearing target %u handle 0x%04x\n",
 393             targ->tid, handle);
 394
 395         /*
 396          * Don't clear target if remove fails because things will get confusing.
 397          * Leave the devname and sasaddr intact so that we know to avoid reusing
 398          * this target id if possible, and so we can assign the same target id
 399          * to this device if it comes back in the future.
 400          */
 401         if ((le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK) ==
 402             MPI2_IOCSTATUS_SUCCESS) {
 403                 targ = tm->cm_targ;
 404                 targ->handle = 0x0;
 405                 targ->encl_handle = 0x0;
 406                 targ->encl_level_valid = 0x0;
 407                 targ->encl_level = 0x0;
 408                 targ->connector_name[0] = ' ';
 409                 targ->connector_name[1] = ' ';
 410                 targ->connector_name[2] = ' ';
 411                 targ->connector_name[3] = ' ';
 412                 targ->encl_slot = 0x0;
 413                 targ->exp_dev_handle = 0x0;
 414                 targ->phy_num = 0x0;
 415                 targ->linkrate = 0x0;
 416                 targ->devinfo = 0x0;
 417                 targ->flags = 0x0;
 418                 targ->scsi_req_desc_type = 0;
 419         }
 420
 421         mprsas_free_tm(sc, tm);
 422 }
 423
 424
 425 /*
 426  * No Need to call "MPI2_SAS_OP_REMOVE_DEVICE" For Volume removal.
 427  * Otherwise Volume Delete is same as Bare Drive Removal.
 428  */
 429 void
 430 mprsas_prepare_volume_remove(struct mprsas_softc *sassc, uint16_t handle)
 431 {
 432         MPI2_SCSI_TASK_MANAGE_REQUEST *req;
 433         struct mpr_softc *sc;
 434         struct mpr_command *cm;
 435         struct mprsas_target *targ = NULL;
 436
 437         MPR_FUNCTRACE(sassc->sc);
 438         sc = sassc->sc;
 439
 440         targ = mprsas_find_target_by_handle(sassc, 0, handle);
 441         if (targ == NULL) {
 442                 /* FIXME: what is the action? */
 443                 /* We don't know about this device? */
 444                 mpr_dprint(sc, MPR_ERROR,
 445                    "%s %d : invalid handle 0x%x \n", __func__,__LINE__, handle);
 446                 return;
 447         }
 448
 449         targ->flags |= MPRSAS_TARGET_INREMOVAL;
 450
 451         cm = mprsas_alloc_tm(sc);
 452         if (cm == NULL) {
 453                 mpr_dprint(sc, MPR_ERROR,
 454                     "%s: command alloc failure\n", __func__);
 455                 return;
 456         }
 457
 458         mprsas_rescan_target(sc, targ);
 459
 460         req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)cm->cm_req;
 461         req->DevHandle = targ->handle;
 462         req->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
 463         req->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
 464
 465         /* SAS Hard Link Reset / SATA Link Reset */
 466         req->MsgFlags = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
 467
 468         cm->cm_targ = targ;
 469         cm->cm_data = NULL;
 470         cm->cm_desc.HighPriority.RequestFlags =
 471             MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY;
 472         cm->cm_complete = mprsas_remove_volume;
 473         cm->cm_complete_data = (void *)(uintptr_t)handle;
 474
 475         mpr_dprint(sc, MPR_INFO, "%s: Sending reset for target ID %d\n",
 476             __func__, targ->tid);
 477         mprsas_prepare_for_tm(sc, cm, targ, CAM_LUN_WILDCARD);
 478
 479         mpr_map_command(sc, cm);
 480 }
 481
 482 /*
 483  * The firmware performs debounce on the link to avoid transient link errors
 484  * and false removals.  When it does decide that link has been lost and a
 485  * device needs to go away, it expects that the host will perform a target reset
 486  * and then an op remove.  The reset has the side-effect of aborting any
 487  * outstanding requests for the device, which is required for the op-remove to
 488  * succeed.  It's not clear if the host should check for the device coming back
 489  * alive after the reset.
 490  */
 491 void
 492 mprsas_prepare_remove(struct mprsas_softc *sassc, uint16_t handle)
 493 {
 494         MPI2_SCSI_TASK_MANAGE_REQUEST *req;
 495         struct mpr_softc *sc;
 496         struct mpr_command *cm;
 497         struct mprsas_target *targ = NULL;
 498
 499         MPR_FUNCTRACE(sassc->sc);
 500
 501         sc = sassc->sc;
 502
 503         targ = mprsas_find_target_by_handle(sassc, 0, handle);
 504         if (targ == NULL) {
 505                 /* FIXME: what is the action? */
 506                 /* We don't know about this device? */
 507                 mpr_dprint(sc, MPR_ERROR, "%s : invalid handle 0x%x \n",
 508                     __func__, handle);
 509                 return;
 510         }
 511
 512         targ->flags |= MPRSAS_TARGET_INREMOVAL;
 513
 514         cm = mprsas_alloc_tm(sc);
 515         if (cm == NULL) {
 516                 mpr_dprint(sc, MPR_ERROR, "%s: command alloc failure\n",
 517                     __func__);
 518                 return;
 519         }
 520
 521         mprsas_rescan_target(sc, targ);
 522
 523         req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)cm->cm_req;
 524         memset(req, 0, sizeof(*req));
 525         req->DevHandle = htole16(targ->handle);
 526         req->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
 527         req->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
 528
 529         /* SAS Hard Link Reset / SATA Link Reset */
 530         req->MsgFlags = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
 531
 532         cm->cm_targ = targ;
 533         cm->cm_data = NULL;
 534         cm->cm_desc.HighPriority.RequestFlags =
 535             MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY;
 536         cm->cm_complete = mprsas_remove_device;
 537         cm->cm_complete_data = (void *)(uintptr_t)handle;
 538
 539         mpr_dprint(sc, MPR_INFO, "%s: Sending reset for target ID %d\n",
 540             __func__, targ->tid);
 541         mprsas_prepare_for_tm(sc, cm, targ, CAM_LUN_WILDCARD);
 542
 543         mpr_map_command(sc, cm);
 544 }
 545
 546 static void
 547 mprsas_remove_device(struct mpr_softc *sc, struct mpr_command *tm)
 548 {
 549         MPI2_SCSI_TASK_MANAGE_REPLY *reply;
 550         MPI2_SAS_IOUNIT_CONTROL_REQUEST *req;
 551         struct mprsas_target *targ;
 552         struct mpr_command *next_cm;
 553         uint16_t handle;
 554
 555         MPR_FUNCTRACE(sc);
 556
 557         reply = (MPI2_SCSI_TASK_MANAGE_REPLY *)tm->cm_reply;
 558         handle = (uint16_t)(uintptr_t)tm->cm_complete_data;
 559         targ = tm->cm_targ;
 560
 561         /*
 562          * Currently there should be no way we can hit this case.  It only
 563          * happens when we have a failure to allocate chain frames, and
 564          * task management commands don't have S/G lists.
 565          */
 566         if ((tm->cm_flags & MPR_CM_FLAGS_ERROR_MASK) != 0) {
 567                 mpr_dprint(sc, MPR_ERROR, "%s: cm_flags = %#x for remove of "
 568                     "handle %#04x! This should not happen!\n", __func__,
 569                     tm->cm_flags, handle);
 570         }
 571
 572         if (reply == NULL) {
 573                 /* XXX retry the remove after the diag reset completes? */
 574                 mpr_dprint(sc, MPR_FAULT, "%s NULL reply resetting device "
 575                     "0x%04x\n", __func__, handle);
 576                 mprsas_free_tm(sc, tm);
 577                 return;
 578         }
 579
 580         if ((le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK) !=
 581             MPI2_IOCSTATUS_SUCCESS) {
 582                 mpr_dprint(sc, MPR_ERROR, "IOCStatus = 0x%x while resetting "
 583                     "device 0x%x\n", le16toh(reply->IOCStatus), handle);
 584         }
 585
 586         mpr_dprint(sc, MPR_XINFO, "Reset aborted %u commands\n",
 587             le32toh(reply->TerminationCount));
 588         mpr_free_reply(sc, tm->cm_reply_data);
 589         tm->cm_reply = NULL;    /* Ensures the reply won't get re-freed */
 590
 591         /* Reuse the existing command */
 592         req = (MPI2_SAS_IOUNIT_CONTROL_REQUEST *)tm->cm_req;
 593         memset(req, 0, sizeof(*req));
 594         req->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
 595         req->Operation = MPI2_SAS_OP_REMOVE_DEVICE;
 596         req->DevHandle = htole16(handle);
 597         tm->cm_data = NULL;
 598         tm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
 599         tm->cm_complete = mprsas_remove_complete;
 600         tm->cm_complete_data = (void *)(uintptr_t)handle;
 601
 602         mpr_map_command(sc, tm);
 603
 604         mpr_dprint(sc, MPR_INFO, "clearing target %u handle 0x%04x\n",
 605             targ->tid, handle);
 606         if (targ->encl_level_valid) {
 607                 mpr_dprint(sc, MPR_INFO, "At enclosure level %d, slot %d, "
 608                     "connector name (%4s)\n", targ->encl_level, targ->encl_slot,
 609                     targ->connector_name);
 610         }
 611         TAILQ_FOREACH_SAFE(tm, &targ->commands, cm_link, next_cm) {
 612                 union ccb *ccb;
 613
 614                 mpr_dprint(sc, MPR_XINFO, "Completing missed command %p\n", tm);
 615                 ccb = tm->cm_complete_data;
 616                 mprsas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
 617                 mprsas_scsiio_complete(sc, tm);
 618         }
 619 }
 620
 621 static void
 622 mprsas_remove_complete(struct mpr_softc *sc, struct mpr_command *tm)
 623 {
 624         MPI2_SAS_IOUNIT_CONTROL_REPLY *reply;
 625         uint16_t handle;
 626         struct mprsas_target *targ;
 627         struct mprsas_lun *lun;
 628
 629         MPR_FUNCTRACE(sc);
 630
 631         reply = (MPI2_SAS_IOUNIT_CONTROL_REPLY *)tm->cm_reply;
 632         handle = (uint16_t)(uintptr_t)tm->cm_complete_data;
 633
 634         /*
 635          * Currently there should be no way we can hit this case.  It only
 636          * happens when we have a failure to allocate chain frames, and
 637          * task management commands don't have S/G lists.
 638          */
 639         if ((tm->cm_flags & MPR_CM_FLAGS_ERROR_MASK) != 0) {
 640                 mpr_dprint(sc, MPR_XINFO, "%s: cm_flags = %#x for remove of "
 641                     "handle %#04x! This should not happen!\n", __func__,
 642                     tm->cm_flags, handle);
 643                 mprsas_free_tm(sc, tm);
 644                 return;
 645         }
 646
 647         if (reply == NULL) {
 648                 /* most likely a chip reset */
 649                 mpr_dprint(sc, MPR_FAULT, "%s NULL reply removing device "
 650                     "0x%04x\n", __func__, handle);
 651                 mprsas_free_tm(sc, tm);
 652                 return;
 653         }
 654
 655         mpr_dprint(sc, MPR_XINFO, "%s on handle 0x%04x, IOCStatus= 0x%x\n",
 656             __func__, handle, le16toh(reply->IOCStatus));
 657
 658         /*
 659          * Don't clear target if remove fails because things will get confusing.
 660          * Leave the devname and sasaddr intact so that we know to avoid reusing
 661          * this target id if possible, and so we can assign the same target id
 662          * to this device if it comes back in the future.
 663          */
 664         if ((le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK) ==
 665             MPI2_IOCSTATUS_SUCCESS) {
 666                 targ = tm->cm_targ;
 667                 targ->handle = 0x0;
 668                 targ->encl_handle = 0x0;
 669                 targ->encl_level_valid = 0x0;
 670                 targ->encl_level = 0x0;
 671                 targ->connector_name[0] = ' ';
 672                 targ->connector_name[1] = ' ';
 673                 targ->connector_name[2] = ' ';
 674                 targ->connector_name[3] = ' ';
 675                 targ->encl_slot = 0x0;
 676                 targ->exp_dev_handle = 0x0;
 677                 targ->phy_num = 0x0;
 678                 targ->linkrate = 0x0;
 679                 targ->devinfo = 0x0;
 680                 targ->flags = 0x0;
 681                 targ->scsi_req_desc_type = 0;
 682
 683                 while (!SLIST_EMPTY(&targ->luns)) {
 684                         lun = SLIST_FIRST(&targ->luns);
 685                         SLIST_REMOVE_HEAD(&targ->luns, lun_link);
 686                         free(lun, M_MPR);
 687                 }
 688         }
 689
 690         mprsas_free_tm(sc, tm);
 691 }
 692
 693 static int
 694 mprsas_register_events(struct mpr_softc *sc)
 695 {
 696         uint8_t events[16];
 697
 698         bzero(events, 16);
 699         setbit(events, MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE);
 700         setbit(events, MPI2_EVENT_SAS_DISCOVERY);
 701         setbit(events, MPI2_EVENT_SAS_BROADCAST_PRIMITIVE);
 702         setbit(events, MPI2_EVENT_SAS_INIT_DEVICE_STATUS_CHANGE);
 703         setbit(events, MPI2_EVENT_SAS_INIT_TABLE_OVERFLOW);
 704         setbit(events, MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST);
 705         setbit(events, MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE);
 706         setbit(events, MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST);
 707         setbit(events, MPI2_EVENT_IR_VOLUME);
 708         setbit(events, MPI2_EVENT_IR_PHYSICAL_DISK);
 709         setbit(events, MPI2_EVENT_IR_OPERATION_STATUS);
 710         setbit(events, MPI2_EVENT_TEMP_THRESHOLD);
 711         if (sc->facts->MsgVersion >= MPI2_VERSION_02_06) {
 712                 setbit(events, MPI2_EVENT_ACTIVE_CABLE_EXCEPTION);
 713                 if (sc->mpr_flags & MPR_FLAGS_GEN35_IOC) {
 714                         setbit(events, MPI2_EVENT_PCIE_DEVICE_STATUS_CHANGE);
 715                         setbit(events, MPI2_EVENT_PCIE_ENUMERATION);
 716                         setbit(events, MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST);
 717                 }
 718         }
 719
 720         mpr_register_events(sc, events, mprsas_evt_handler, NULL,
 721             &sc->sassc->mprsas_eh);
 722
 723         return (0);
 724 }
 725
 726 int
 727 mpr_attach_sas(struct mpr_softc *sc)
 728 {
 729         struct mprsas_softc *sassc;
 730         cam_status status;
 731         int unit, error = 0;
 732
 733         MPR_FUNCTRACE(sc);
 734         mpr_dprint(sc, MPR_INIT, "%s entered\n", __func__);
 735
 736         sassc = malloc(sizeof(struct mprsas_softc), M_MPR, M_WAITOK|M_ZERO);
 737         if (!sassc) {
 738                 mpr_dprint(sc, MPR_INIT|MPR_ERROR,
 739                     "Cannot allocate SAS subsystem memory\n");
 740                 return (ENOMEM);
 741         }
 742
 743         /*
 744          * XXX MaxTargets could change during a reinit.  Since we don't
 745          * resize the targets[] array during such an event, cache the value
 746          * of MaxTargets here so that we don't get into trouble later.  This
 747          * should move into the reinit logic.
 748          */
 749         sassc->maxtargets = sc->facts->MaxTargets + sc->facts->MaxVolumes;
 750         sassc->targets = malloc(sizeof(struct mprsas_target) *
 751             sassc->maxtargets, M_MPR, M_WAITOK|M_ZERO);
 752         if (!sassc->targets) {
 753                 mpr_dprint(sc, MPR_INIT|MPR_ERROR,
 754                     "Cannot allocate SAS target memory\n");
 755                 free(sassc, M_MPR);
 756                 return (ENOMEM);
 757         }
 758         sc->sassc = sassc;
 759         sassc->sc = sc;
 760
 761         if ((sassc->devq = cam_simq_alloc(sc->num_reqs)) == NULL) {
 762                 mpr_dprint(sc, MPR_INIT|MPR_ERROR, "Cannot allocate SIMQ\n");
 763                 error = ENOMEM;
 764                 goto out;
 765         }
 766
 767         unit = device_get_unit(sc->mpr_dev);
 768         sassc->sim = cam_sim_alloc(mprsas_action, mprsas_poll, "mpr", sassc,
 769             unit, &sc->mpr_mtx, sc->num_reqs, sc->num_reqs, sassc->devq);
 770         if (sassc->sim == NULL) {
 771                 mpr_dprint(sc, MPR_INIT|MPR_ERROR, "Cannot allocate SIM\n");
 772                 error = EINVAL;
 773                 goto out;
 774         }
 775
 776         TAILQ_INIT(&sassc->ev_queue);
 777
 778         /* Initialize taskqueue for Event Handling */
 779         TASK_INIT(&sassc->ev_task, 0, mprsas_firmware_event_work, sc);
 780         sassc->ev_tq = taskqueue_create("mpr_taskq", M_NOWAIT | M_ZERO,
 781             taskqueue_thread_enqueue, &sassc->ev_tq);
 782         taskqueue_start_threads(&sassc->ev_tq, 1, PRIBIO, "%s taskq",
 783             device_get_nameunit(sc->mpr_dev));
 784
 785         mpr_lock(sc);
 786
 787         /*
 788          * XXX There should be a bus for every port on the adapter, but since
 789          * we're just going to fake the topology for now, we'll pretend that
 790          * everything is just a target on a single bus.
 791          */
 792         if ((error = xpt_bus_register(sassc->sim, sc->mpr_dev, 0)) != 0) {
 793                 mpr_dprint(sc, MPR_INIT|MPR_ERROR,
 794                     "Error %d registering SCSI bus\n", error);
 795                 mpr_unlock(sc);
 796                 goto out;
 797         }
 798
 799         /*
 800          * Assume that discovery events will start right away.
 801          *
 802          * Hold off boot until discovery is complete.
 803          */
 804         sassc->flags |= MPRSAS_IN_STARTUP | MPRSAS_IN_DISCOVERY;
 805         sc->sassc->startup_refcount = 0;
 806         mprsas_startup_increment(sassc);
 807
 808         callout_init(&sassc->discovery_callout, 1 /*mpsafe*/);
 809
 810         /*
 811          * Register for async events so we can determine the EEDP
 812          * capabilities of devices.
 813          */
 814         status = xpt_create_path(&sassc->path, /*periph*/NULL,
 815             cam_sim_path(sc->sassc->sim), CAM_TARGET_WILDCARD,
 816             CAM_LUN_WILDCARD);
 817         if (status != CAM_REQ_CMP) {
 818                 mpr_dprint(sc, MPR_INIT|MPR_ERROR,
 819                     "Error %#x creating sim path\n", status);
 820                 sassc->path = NULL;
 821         } else {
 822                 int event;
 823
 824 #if (__FreeBSD_version >= 1000006) || \
 825     ((__FreeBSD_version >= 901503) && (__FreeBSD_version < 1000000))
 826                 event = AC_ADVINFO_CHANGED | AC_FOUND_DEVICE;
 827 #else
 828                 event = AC_FOUND_DEVICE;
 829 #endif
 830
 831                 /*
 832                  * Prior to the CAM locking improvements, we can't call
 833                  * xpt_register_async() with a particular path specified.
 834                  *
 835                  * If a path isn't specified, xpt_register_async() will
 836                  * generate a wildcard path and acquire the XPT lock while
 837                  * it calls xpt_action() to execute the XPT_SASYNC_CB CCB.
 838                  * It will then drop the XPT lock once that is done.
 839                  *
 840                  * If a path is specified for xpt_register_async(), it will
 841                  * not acquire and drop the XPT lock around the call to
 842                  * xpt_action().  xpt_action() asserts that the caller
 843                  * holds the SIM lock, so the SIM lock has to be held when
 844                  * calling xpt_register_async() when the path is specified.
 845                  *
 846                  * But xpt_register_async calls xpt_for_all_devices(),
 847                  * which calls xptbustraverse(), which will acquire each
 848                  * SIM lock.  When it traverses our particular bus, it will
 849                  * necessarily acquire the SIM lock, which will lead to a
 850                  * recursive lock acquisition.
 851                  *
 852                  * The CAM locking changes fix this problem by acquiring
 853                  * the XPT topology lock around bus traversal in
 854                  * xptbustraverse(), so the caller can hold the SIM lock
 855                  * and it does not cause a recursive lock acquisition.
 856                  *
 857                  * These __FreeBSD_version values are approximate, especially
 858                  * for stable/10, which is two months later than the actual
 859                  * change.
 860                  */
 861
 862 #if (__FreeBSD_version < 1000703) || \
 863     ((__FreeBSD_version >= 1100000) && (__FreeBSD_version < 1100002))
 864                 mpr_unlock(sc);
 865                 status = xpt_register_async(event, mprsas_async, sc,
 866                                             NULL);
 867                 mpr_lock(sc);
 868 #else
 869                 status = xpt_register_async(event, mprsas_async, sc,
 870                                             sassc->path);
 871 #endif
 872
 873                 if (status != CAM_REQ_CMP) {
 874                         mpr_dprint(sc, MPR_ERROR,
 875                             "Error %#x registering async handler for "
 876                             "AC_ADVINFO_CHANGED events\n", status);
 877                         xpt_free_path(sassc->path);
 878                         sassc->path = NULL;
 879                 }
 880         }
 881         if (status != CAM_REQ_CMP) {
 882                 /*
 883                  * EEDP use is the exception, not the rule.
 884                  * Warn the user, but do not fail to attach.
 885                  */
 886                 mpr_printf(sc, "EEDP capabilities disabled.\n");
 887         }
 888
 889         mpr_unlock(sc);
 890
 891         mprsas_register_events(sc);
 892 out:
 893         if (error)
 894                 mpr_detach_sas(sc);
 895
 896         mpr_dprint(sc, MPR_INIT, "%s exit, error= %d\n", __func__, error);
 897         return (error);
 898 }
 899
 900 int
 901 mpr_detach_sas(struct mpr_softc *sc)
 902 {
 903         struct mprsas_softc *sassc;
 904         struct mprsas_lun *lun, *lun_tmp;
 905         struct mprsas_target *targ;
 906         int i;
 907
 908         MPR_FUNCTRACE(sc);
 909
 910         if (sc->sassc == NULL)
 911                 return (0);
 912
 913         sassc = sc->sassc;
 914         mpr_deregister_events(sc, sassc->mprsas_eh);
 915
 916         /*
 917          * Drain and free the event handling taskqueue with the lock
 918          * unheld so that any parallel processing tasks drain properly
 919          * without deadlocking.
 920          */
 921         if (sassc->ev_tq != NULL)
 922                 taskqueue_free(sassc->ev_tq);
 923
 924         /* Make sure CAM doesn't wedge if we had to bail out early. */
 925         mpr_lock(sc);
 926
 927         while (sassc->startup_refcount != 0)
 928                 mprsas_startup_decrement(sassc);
 929
 930         /* Deregister our async handler */
 931         if (sassc->path != NULL) {
 932                 xpt_register_async(0, mprsas_async, sc, sassc->path);
 933                 xpt_free_path(sassc->path);
 934                 sassc->path = NULL;
 935         }
 936
 937         if (sassc->flags & MPRSAS_IN_STARTUP)
 938                 xpt_release_simq(sassc->sim, 1);
 939
 940         if (sassc->sim != NULL) {
 941                 xpt_bus_deregister(cam_sim_path(sassc->sim));
 942                 cam_sim_free(sassc->sim, FALSE);
 943         }
 944
 945         mpr_unlock(sc);
 946
 947         if (sassc->devq != NULL)
 948                 cam_simq_free(sassc->devq);
 949
 950         for (i = 0; i < sassc->maxtargets; i++) {
 951                 targ = &sassc->targets[i];
 952                 SLIST_FOREACH_SAFE(lun, &targ->luns, lun_link, lun_tmp) {
 953                         free(lun, M_MPR);
 954                 }
 955         }
 956         free(sassc->targets, M_MPR);
 957         free(sassc, M_MPR);
 958         sc->sassc = NULL;
 959
 960         return (0);
 961 }
 962
 963 void
 964 mprsas_discovery_end(struct mprsas_softc *sassc)
 965 {
 966         struct mpr_softc *sc = sassc->sc;
 967
 968         MPR_FUNCTRACE(sc);
 969
 970         if (sassc->flags & MPRSAS_DISCOVERY_TIMEOUT_PENDING)
 971                 callout_stop(&sassc->discovery_callout);
 972
 973         /*
 974          * After discovery has completed, check the mapping table for any
 975          * missing devices and update their missing counts. Only do this once
 976          * whenever the driver is initialized so that missing counts aren't
 977          * updated unnecessarily. Note that just because discovery has
 978          * completed doesn't mean that events have been processed yet. The
 979          * check_devices function is a callout timer that checks if ALL devices
 980          * are missing. If so, it will wait a little longer for events to
 981          * complete and keep resetting itself until some device in the mapping
 982          * table is not missing, meaning that event processing has started.
 983          */
 984         if (sc->track_mapping_events) {
 985                 mpr_dprint(sc, MPR_XINFO | MPR_MAPPING, "Discovery has "
 986                     "completed. Check for missing devices in the mapping "
 987                     "table.\n");
 988                 callout_reset(&sc->device_check_callout,
 989                     MPR_MISSING_CHECK_DELAY * hz, mpr_mapping_check_devices,
 990                     sc);
 991         }
 992 }
 993
 994 static void
 995 mprsas_action(struct cam_sim *sim, union ccb *ccb)
 996 {
 997         struct mprsas_softc *sassc;
 998
 999         sassc = cam_sim_softc(sim);
1000
1001         MPR_FUNCTRACE(sassc->sc);
1002         mpr_dprint(sassc->sc, MPR_TRACE, "ccb func_code 0x%x\n",
1003             ccb->ccb_h.func_code);
1004         mtx_assert(&sassc->sc->mpr_mtx, MA_OWNED);
1005
1006         switch (ccb->ccb_h.func_code) {
1007         case XPT_PATH_INQ:
1008         {
1009                 struct ccb_pathinq *cpi = &ccb->cpi;
1010                 struct mpr_softc *sc = sassc->sc;
1011                 uint8_t sges_per_frame;
1012
1013                 cpi->version_num = 1;
1014                 cpi->hba_inquiry = PI_SDTR_ABLE|PI_TAG_ABLE|PI_WIDE_16;
1015                 cpi->target_sprt = 0;
1016 #if (__FreeBSD_version >= 1000039) || \
1017     ((__FreeBSD_version < 1000000) && (__FreeBSD_version >= 902502))
1018                 cpi->hba_misc = PIM_NOBUSRESET | PIM_UNMAPPED | PIM_NOSCAN;
1019 #else
1020                 cpi->hba_misc = PIM_NOBUSRESET | PIM_UNMAPPED;
1021 #endif
1022                 cpi->hba_eng_cnt = 0;
1023                 cpi->max_target = sassc->maxtargets - 1;
1024                 cpi->max_lun = 255;
1025
1026                 /*
1027                  * initiator_id is set here to an ID outside the set of valid
1028                  * target IDs (including volumes).
1029                  */
1030                 cpi->initiator_id = sassc->maxtargets;
1031                 strlcpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
1032                 strlcpy(cpi->hba_vid, "Avago Tech", HBA_IDLEN);
1033                 strlcpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
1034                 cpi->unit_number = cam_sim_unit(sim);
1035                 cpi->bus_id = cam_sim_bus(sim);
1036                 /*
1037                  * XXXSLM-I think this needs to change based on config page or
1038                  * something instead of hardcoded to 150000.
1039                  */
1040                 cpi->base_transfer_speed = 150000;
1041                 cpi->transport = XPORT_SAS;
1042                 cpi->transport_version = 0;
1043                 cpi->protocol = PROTO_SCSI;
1044                 cpi->protocol_version = SCSI_REV_SPC;
1045
1046                 /*
1047                  * Max IO Size is Page Size * the following:
1048                  * ((SGEs per frame - 1 for chain element) *
1049                  * Max Chain Depth) + 1 for no chain needed in last frame
1050                  *
1051                  * If user suggests a Max IO size to use, use the smaller of the
1052                  * user's value and the calculated value as long as the user's
1053                  * value is larger than 0. The user's value is in pages.
1054                  */
1055                 sges_per_frame = (sc->chain_frame_size /
1056                     sizeof(MPI2_IEEE_SGE_SIMPLE64)) - 1;
1057                 cpi->maxio = (sges_per_frame * sc->facts->MaxChainDepth) + 1;
1058                 cpi->maxio *= PAGE_SIZE;
1059                 if ((sc->max_io_pages > 0) && (sc->max_io_pages * PAGE_SIZE <
1060                     cpi->maxio))
1061                         cpi->maxio = sc->max_io_pages * PAGE_SIZE;
1062                 sc->maxio = cpi->maxio;
1063                 mprsas_set_ccbstatus(ccb, CAM_REQ_CMP);
1064                 break;
1065         }
1066         case XPT_GET_TRAN_SETTINGS:
1067         {
1068                 struct ccb_trans_settings       *cts;
1069                 struct ccb_trans_settings_sas   *sas;
1070                 struct ccb_trans_settings_scsi  *scsi;
1071                 struct mprsas_target *targ;
1072
1073                 cts = &ccb->cts;
1074                 sas = &cts->xport_specific.sas;
1075                 scsi = &cts->proto_specific.scsi;
1076
1077                 KASSERT(cts->ccb_h.target_id < sassc->maxtargets,
1078                     ("Target %d out of bounds in XPT_GET_TRAN_SETTINGS\n",
1079                     cts->ccb_h.target_id));
1080                 targ = &sassc->targets[cts->ccb_h.target_id];
1081                 if (targ->handle == 0x0) {
1082                         mprsas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
1083                         break;
1084                 }
1085
1086                 cts->protocol_version = SCSI_REV_SPC2;
1087                 cts->transport = XPORT_SAS;
1088                 cts->transport_version = 0;
1089
1090                 sas->valid = CTS_SAS_VALID_SPEED;
1091                 switch (targ->linkrate) {
1092                 case 0x08:
1093                         sas->bitrate = 150000;
1094                         break;
1095                 case 0x09:
1096                         sas->bitrate = 300000;
1097                         break;
1098                 case 0x0a:
1099                         sas->bitrate = 600000;
1100                         break;
1101                 case 0x0b:
1102                         sas->bitrate = 1200000;
1103                         break;
1104                 default:
1105                         sas->valid = 0;
1106                 }
1107
1108                 cts->protocol = PROTO_SCSI;
1109                 scsi->valid = CTS_SCSI_VALID_TQ;
1110                 scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
1111
1112                 mprsas_set_ccbstatus(ccb, CAM_REQ_CMP);
1113                 break;
1114         }
1115         case XPT_CALC_GEOMETRY:
1116                 cam_calc_geometry(&ccb->ccg, /*extended*/1);
1117                 mprsas_set_ccbstatus(ccb, CAM_REQ_CMP);
1118                 break;
1119         case XPT_RESET_DEV:
1120                 mpr_dprint(sassc->sc, MPR_XINFO, "mprsas_action "
1121                     "XPT_RESET_DEV\n");
1122                 mprsas_action_resetdev(sassc, ccb);
1123                 return;
1124         case XPT_RESET_BUS:
1125         case XPT_ABORT:
1126         case XPT_TERM_IO:
1127                 mpr_dprint(sassc->sc, MPR_XINFO, "mprsas_action faking success "
1128                     "for abort or reset\n");
1129                 mprsas_set_ccbstatus(ccb, CAM_REQ_CMP);
1130                 break;
1131         case XPT_SCSI_IO:
1132                 mprsas_action_scsiio(sassc, ccb);
1133                 return;
1134 #if __FreeBSD_version >= 900026
1135         case XPT_SMP_IO:
1136                 mprsas_action_smpio(sassc, ccb);
1137                 return;
1138 #endif
1139         default:
1140                 mprsas_set_ccbstatus(ccb, CAM_FUNC_NOTAVAIL);
1141                 break;
1142         }
1143         xpt_done(ccb);
1144
1145 }
1146
1147 static void
1148 mprsas_announce_reset(struct mpr_softc *sc, uint32_t ac_code,
1149     target_id_t target_id, lun_id_t lun_id)
1150 {
1151         path_id_t path_id = cam_sim_path(sc->sassc->sim);
1152         struct cam_path *path;
1153
1154         mpr_dprint(sc, MPR_XINFO, "%s code %x target %d lun %jx\n", __func__,
1155             ac_code, target_id, (uintmax_t)lun_id);
1156
1157         if (xpt_create_path(&path, NULL,
1158                 path_id, target_id, lun_id) != CAM_REQ_CMP) {
1159                 mpr_dprint(sc, MPR_ERROR, "unable to create path for reset "
1160                     "notification\n");
1161                 return;
1162         }
1163
1164         xpt_async(ac_code, path, NULL);
1165         xpt_free_path(path);
1166 }
1167
1168 static void
1169 mprsas_complete_all_commands(struct mpr_softc *sc)
1170 {
1171         struct mpr_command *cm;
1172         int i;
1173         int completed;
1174
1175         MPR_FUNCTRACE(sc);
1176         mtx_assert(&sc->mpr_mtx, MA_OWNED);
1177
1178         /* complete all commands with a NULL reply */
1179         for (i = 1; i < sc->num_reqs; i++) {
1180                 cm = &sc->commands[i];
1181                 cm->cm_reply = NULL;
1182                 completed = 0;
1183
1184                 if (cm->cm_flags & MPR_CM_FLAGS_POLLED)
1185                         cm->cm_flags |= MPR_CM_FLAGS_COMPLETE;
1186
1187                 if (cm->cm_complete != NULL) {
1188                         mprsas_log_command(cm, MPR_RECOVERY,
1189                             "completing cm %p state %x ccb %p for diag reset\n",
1190                             cm, cm->cm_state, cm->cm_ccb);
1191                         cm->cm_complete(sc, cm);
1192                         completed = 1;
1193                 }
1194
1195                 if (cm->cm_flags & MPR_CM_FLAGS_WAKEUP) {
1196                         mprsas_log_command(cm, MPR_RECOVERY,
1197                             "waking up cm %p state %x ccb %p for diag reset\n",
1198                             cm, cm->cm_state, cm->cm_ccb);
1199                         wakeup(cm);
1200                         completed = 1;
1201                 }
1202
1203                 if (cm->cm_sc->io_cmds_active != 0)
1204                         cm->cm_sc->io_cmds_active--;
1205
1206                 if ((completed == 0) && (cm->cm_state != MPR_CM_STATE_FREE)) {
1207                         /* this should never happen, but if it does, log */
1208                         mprsas_log_command(cm, MPR_RECOVERY,
1209                             "cm %p state %x flags 0x%x ccb %p during diag "
1210                             "reset\n", cm, cm->cm_state, cm->cm_flags,
1211                             cm->cm_ccb);
1212                 }
1213         }
1214 }
1215
1216 void
1217 mprsas_handle_reinit(struct mpr_softc *sc)
1218 {
1219         int i;
1220
1221         /* Go back into startup mode and freeze the simq, so that CAM
1222          * doesn't send any commands until after we've rediscovered all
1223          * targets and found the proper device handles for them.
1224          *
1225          * After the reset, portenable will trigger discovery, and after all
1226          * discovery-related activities have finished, the simq will be
1227          * released.
1228          */
1229         mpr_dprint(sc, MPR_INIT, "%s startup\n", __func__);
1230         sc->sassc->flags |= MPRSAS_IN_STARTUP;
1231         sc->sassc->flags |= MPRSAS_IN_DISCOVERY;
1232         mprsas_startup_increment(sc->sassc);
1233
1234         /* notify CAM of a bus reset */
1235         mprsas_announce_reset(sc, AC_BUS_RESET, CAM_TARGET_WILDCARD,
1236             CAM_LUN_WILDCARD);
1237
1238         /* complete and cleanup after all outstanding commands */
1239         mprsas_complete_all_commands(sc);
1240
1241         mpr_dprint(sc, MPR_INIT, "%s startup %u after command completion\n",
1242             __func__, sc->sassc->startup_refcount);
1243
1244         /* zero all the target handles, since they may change after the
1245          * reset, and we have to rediscover all the targets and use the new
1246          * handles.
1247          */
1248         for (i = 0; i < sc->sassc->maxtargets; i++) {
1249                 if (sc->sassc->targets[i].outstanding != 0)
1250                         mpr_dprint(sc, MPR_INIT, "target %u outstanding %u\n",
1251                             i, sc->sassc->targets[i].outstanding);
1252                 sc->sassc->targets[i].handle = 0x0;
1253                 sc->sassc->targets[i].exp_dev_handle = 0x0;
1254                 sc->sassc->targets[i].outstanding = 0;
1255                 sc->sassc->targets[i].flags = MPRSAS_TARGET_INDIAGRESET;
1256         }
1257 }
1258 static void
1259 mprsas_tm_timeout(void *data)
1260 {
1261         struct mpr_command *tm = data;
1262         struct mpr_softc *sc = tm->cm_sc;
1263
1264         mtx_assert(&sc->mpr_mtx, MA_OWNED);
1265
1266         mprsas_log_command(tm, MPR_INFO|MPR_RECOVERY, "task mgmt %p timed "
1267             "out\n", tm);
1268         mpr_reinit(sc);
1269 }
1270
1271 static void
1272 mprsas_logical_unit_reset_complete(struct mpr_softc *sc, struct mpr_command *tm)
1273 {
1274         MPI2_SCSI_TASK_MANAGE_REPLY *reply;
1275         MPI2_SCSI_TASK_MANAGE_REQUEST *req;
1276         unsigned int cm_count = 0;
1277         struct mpr_command *cm;
1278         struct mprsas_target *targ;
1279
1280         callout_stop(&tm->cm_callout);
1281
1282         req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
1283         reply = (MPI2_SCSI_TASK_MANAGE_REPLY *)tm->cm_reply;
1284         targ = tm->cm_targ;
1285
1286         /*
1287          * Currently there should be no way we can hit this case.  It only
1288          * happens when we have a failure to allocate chain frames, and
1289          * task management commands don't have S/G lists.
1290          */
1291         if ((tm->cm_flags & MPR_CM_FLAGS_ERROR_MASK) != 0) {
1292                 mpr_dprint(sc, MPR_RECOVERY|MPR_ERROR,
1293                     "%s: cm_flags = %#x for LUN reset! "
1294                     "This should not happen!\n", __func__, tm->cm_flags);
1295                 mprsas_free_tm(sc, tm);
1296                 return;
1297         }
1298
1299         if (reply == NULL) {
1300                 mpr_dprint(sc, MPR_RECOVERY, "NULL reset reply for tm %p\n",
1301                     tm);
1302                 if ((sc->mpr_flags & MPR_FLAGS_DIAGRESET) != 0) {
1303                         /* this completion was due to a reset, just cleanup */
1304                         mpr_dprint(sc, MPR_RECOVERY, "Hardware undergoing "
1305                             "reset, ignoring NULL LUN reset reply\n");
1306                         targ->tm = NULL;
1307                         mprsas_free_tm(sc, tm);
1308                 }
1309                 else {
1310                         /* we should have gotten a reply. */
1311                         mpr_dprint(sc, MPR_INFO|MPR_RECOVERY, "NULL reply on "
1312                             "LUN reset attempt, resetting controller\n");
1313                         mpr_reinit(sc);
1314                 }
1315                 return;
1316         }
1317
1318         mpr_dprint(sc, MPR_RECOVERY,
1319             "logical unit reset status 0x%x code 0x%x count %u\n",
1320             le16toh(reply->IOCStatus), le32toh(reply->ResponseCode),
1321             le32toh(reply->TerminationCount));
1322
1323         /*
1324          * See if there are any outstanding commands for this LUN.
1325          * This could be made more efficient by using a per-LU data
1326          * structure of some sort.
1327          */
1328         TAILQ_FOREACH(cm, &targ->commands, cm_link) {
1329                 if (cm->cm_lun == tm->cm_lun)
1330                         cm_count++;
1331         }
1332
1333         if (cm_count == 0) {
1334                 mpr_dprint(sc, MPR_RECOVERY|MPR_INFO,
1335                     "Finished recovery after LUN reset for target %u\n",
1336                     targ->tid);
1337
1338                 mprsas_announce_reset(sc, AC_SENT_BDR, targ->tid,
1339                     tm->cm_lun);
1340
1341                 /*
1342                  * We've finished recovery for this logical unit.  check and
1343                  * see if some other logical unit has a timedout command
1344                  * that needs to be processed.
1345                  */
1346                 cm = TAILQ_FIRST(&targ->timedout_commands);
1347                 if (cm) {
1348                         mpr_dprint(sc, MPR_INFO|MPR_RECOVERY,
1349                            "More commands to abort for target %u\n", targ->tid);
1350                         mprsas_send_abort(sc, tm, cm);
1351                 } else {
1352                         targ->tm = NULL;
1353                         mprsas_free_tm(sc, tm);
1354                 }
1355         } else {
1356                 /* if we still have commands for this LUN, the reset
1357                  * effectively failed, regardless of the status reported.
1358                  * Escalate to a target reset.
1359                  */
1360                 mpr_dprint(sc, MPR_INFO|MPR_RECOVERY,
1361                     "logical unit reset complete for target %u, but still "
1362                     "have %u command(s), sending target reset\n", targ->tid,
1363                     cm_count);
1364                 mprsas_send_reset(sc, tm,
1365                     MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET);
1366         }
1367 }
1368
1369 static void
1370 mprsas_target_reset_complete(struct mpr_softc *sc, struct mpr_command *tm)
1371 {
1372         MPI2_SCSI_TASK_MANAGE_REPLY *reply;
1373         MPI2_SCSI_TASK_MANAGE_REQUEST *req;
1374         struct mprsas_target *targ;
1375
1376         callout_stop(&tm->cm_callout);
1377
1378         req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
1379         reply = (MPI2_SCSI_TASK_MANAGE_REPLY *)tm->cm_reply;
1380         targ = tm->cm_targ;
1381
1382         /*
1383          * Currently there should be no way we can hit this case.  It only
1384          * happens when we have a failure to allocate chain frames, and
1385          * task management commands don't have S/G lists.
1386          */
1387         if ((tm->cm_flags & MPR_CM_FLAGS_ERROR_MASK) != 0) {
1388                 mpr_dprint(sc, MPR_ERROR, "%s: cm_flags = %#x for target "
1389                     "reset! This should not happen!\n", __func__, tm->cm_flags);
1390                 mprsas_free_tm(sc, tm);
1391                 return;
1392         }
1393
1394         if (reply == NULL) {
1395                 mpr_dprint(sc, MPR_RECOVERY,
1396                     "NULL target reset reply for tm %p TaskMID %u\n",
1397                     tm, le16toh(req->TaskMID));
1398                 if ((sc->mpr_flags & MPR_FLAGS_DIAGRESET) != 0) {
1399                         /* this completion was due to a reset, just cleanup */
1400                         mpr_dprint(sc, MPR_RECOVERY, "Hardware undergoing "
1401                             "reset, ignoring NULL target reset reply\n");
1402                         targ->tm = NULL;
1403                         mprsas_free_tm(sc, tm);
1404                 }
1405                 else {
1406                         /* we should have gotten a reply. */
1407                         mpr_dprint(sc, MPR_INFO|MPR_RECOVERY, "NULL reply on "
1408                             "target reset attempt, resetting controller\n");
1409                         mpr_reinit(sc);
1410                 }
1411                 return;
1412         }
1413
1414         mpr_dprint(sc, MPR_RECOVERY,
1415             "target reset status 0x%x code 0x%x count %u\n",
1416             le16toh(reply->IOCStatus), le32toh(reply->ResponseCode),
1417             le32toh(reply->TerminationCount));
1418
1419         if (targ->outstanding == 0) {
1420                 /*
1421                  * We've finished recovery for this target and all
1422                  * of its logical units.
1423                  */
1424                 mpr_dprint(sc, MPR_RECOVERY|MPR_INFO,
1425                     "Finished reset recovery for target %u\n", targ->tid);
1426
1427                 mprsas_announce_reset(sc, AC_SENT_BDR, tm->cm_targ->tid,
1428                     CAM_LUN_WILDCARD);
1429
1430                 targ->tm = NULL;
1431                 mprsas_free_tm(sc, tm);
1432         } else {
1433                 /*
1434                  * After a target reset, if this target still has
1435                  * outstanding commands, the reset effectively failed,
1436                  * regardless of the status reported.  escalate.
1437                  */
1438                 mpr_dprint(sc, MPR_INFO|MPR_RECOVERY,
1439                     "Target reset complete for target %u, but still have %u "
1440                     "command(s), resetting controller\n", targ->tid,
1441                     targ->outstanding);
1442                 mpr_reinit(sc);
1443         }
1444 }
1445
1446 #define MPR_RESET_TIMEOUT 30
1447
1448 int
1449 mprsas_send_reset(struct mpr_softc *sc, struct mpr_command *tm, uint8_t type)
1450 {
1451         MPI2_SCSI_TASK_MANAGE_REQUEST *req;
1452         struct mprsas_target *target;
1453         int err;
1454
1455         target = tm->cm_targ;
1456         if (target->handle == 0) {
1457                 mpr_dprint(sc, MPR_ERROR, "%s null devhandle for target_id "
1458                     "%d\n", __func__, target->tid);
1459                 return -1;
1460         }
1461
1462         req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
1463         req->DevHandle = htole16(target->handle);
1464         req->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
1465         req->TaskType = type;
1466
1467         if (type == MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET) {
1468                 /* XXX Need to handle invalid LUNs */
1469                 MPR_SET_LUN(req->LUN, tm->cm_lun);
1470                 tm->cm_targ->logical_unit_resets++;
1471                 mpr_dprint(sc, MPR_RECOVERY|MPR_INFO,
1472                     "Sending logical unit reset to target %u lun %d\n",
1473                     target->tid, tm->cm_lun);
1474                 tm->cm_complete = mprsas_logical_unit_reset_complete;
1475                 mprsas_prepare_for_tm(sc, tm, target, tm->cm_lun);
1476         } else if (type == MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET) {
1477                 /*
1478                  * Target reset method =
1479                  *     SAS Hard Link Reset / SATA Link Reset
1480                  */
1481                 req->MsgFlags = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
1482                 tm->cm_targ->target_resets++;
1483                 mpr_dprint(sc, MPR_RECOVERY|MPR_INFO,
1484                     "Sending target reset to target %u\n", target->tid);
1485                 tm->cm_complete = mprsas_target_reset_complete;
1486                 mprsas_prepare_for_tm(sc, tm, target, CAM_LUN_WILDCARD);
1487         }
1488         else {
1489                 mpr_dprint(sc, MPR_ERROR, "unexpected reset type 0x%x\n", type);
1490                 return -1;
1491         }
1492
1493         if (target->encl_level_valid) {
1494                 mpr_dprint(sc, MPR_RECOVERY|MPR_INFO,
1495                     "At enclosure level %d, slot %d, connector name (%4s)\n",
1496                     target->encl_level, target->encl_slot,
1497                     target->connector_name);
1498         }
1499
1500         tm->cm_data = NULL;
1501         tm->cm_desc.HighPriority.RequestFlags =
1502             MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY;
1503         tm->cm_complete_data = (void *)tm;
1504
1505         callout_reset(&tm->cm_callout, MPR_RESET_TIMEOUT * hz,
1506             mprsas_tm_timeout, tm);
1507
1508         err = mpr_map_command(sc, tm);
1509         if (err)
1510                 mpr_dprint(sc, MPR_ERROR|MPR_RECOVERY,
1511                     "error %d sending reset type %u\n", err, type);
1512
1513         return err;
1514 }
1515
1516
1517 static void
1518 mprsas_abort_complete(struct mpr_softc *sc, struct mpr_command *tm)
1519 {
1520         struct mpr_command *cm;
1521         MPI2_SCSI_TASK_MANAGE_REPLY *reply;
1522         MPI2_SCSI_TASK_MANAGE_REQUEST *req;
1523         struct mprsas_target *targ;
1524
1525         callout_stop(&tm->cm_callout);
1526
1527         req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
1528         reply = (MPI2_SCSI_TASK_MANAGE_REPLY *)tm->cm_reply;
1529         targ = tm->cm_targ;
1530
1531         /*
1532          * Currently there should be no way we can hit this case.  It only
1533          * happens when we have a failure to allocate chain frames, and
1534          * task management commands don't have S/G lists.
1535          */
1536         if ((tm->cm_flags & MPR_CM_FLAGS_ERROR_MASK) != 0) {
1537                 mpr_dprint(sc, MPR_RECOVERY|MPR_ERROR,
1538                     "cm_flags = %#x for abort %p TaskMID %u!\n",
1539                     tm->cm_flags, tm, le16toh(req->TaskMID));
1540                 mprsas_free_tm(sc, tm);
1541                 return;
1542         }
1543
1544         if (reply == NULL) {
1545                 mpr_dprint(sc, MPR_RECOVERY,
1546                     "NULL abort reply for tm %p TaskMID %u\n",
1547                     tm, le16toh(req->TaskMID));
1548                 if ((sc->mpr_flags & MPR_FLAGS_DIAGRESET) != 0) {
1549                         /* this completion was due to a reset, just cleanup */
1550                         mpr_dprint(sc, MPR_RECOVERY, "Hardware undergoing "
1551                             "reset, ignoring NULL abort reply\n");
1552                         targ->tm = NULL;
1553                         mprsas_free_tm(sc, tm);
1554                 } else {
1555                         /* we should have gotten a reply. */
1556                         mpr_dprint(sc, MPR_INFO|MPR_RECOVERY, "NULL reply on "
1557                             "abort attempt, resetting controller\n");
1558                         mpr_reinit(sc);
1559                 }
1560                 return;
1561         }
1562
1563         mpr_dprint(sc, MPR_RECOVERY,
1564             "abort TaskMID %u status 0x%x code 0x%x count %u\n",
1565             le16toh(req->TaskMID),
1566             le16toh(reply->IOCStatus), le32toh(reply->ResponseCode),
1567             le32toh(reply->TerminationCount));
1568
1569         cm = TAILQ_FIRST(&tm->cm_targ->timedout_commands);
1570         if (cm == NULL) {
1571                 /*
1572                  * if there are no more timedout commands, we're done with
1573                  * error recovery for this target.
1574                  */
1575                 mpr_dprint(sc, MPR_INFO|MPR_RECOVERY,
1576                     "Finished abort recovery for target %u\n", targ->tid);
1577                 targ->tm = NULL;
1578                 mprsas_free_tm(sc, tm);
1579         } else if (le16toh(req->TaskMID) != cm->cm_desc.Default.SMID) {
1580                 /* abort success, but we have more timedout commands to abort */
1581                 mpr_dprint(sc, MPR_INFO|MPR_RECOVERY,
1582                     "Continuing abort recovery for target %u\n", targ->tid);
1583                 mprsas_send_abort(sc, tm, cm);
1584         } else {
1585                 /*
1586                  * we didn't get a command completion, so the abort
1587                  * failed as far as we're concerned.  escalate.
1588                  */
1589                 mpr_dprint(sc, MPR_INFO|MPR_RECOVERY,
1590                     "Abort failed for target %u, sending logical unit reset\n",
1591                     targ->tid);
1592
1593                 mprsas_send_reset(sc, tm,
1594                     MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET);
1595         }
1596 }
1597
1598 #define MPR_ABORT_TIMEOUT 5
1599
1600 static int
1601 mprsas_send_abort(struct mpr_softc *sc, struct mpr_command *tm,
1602     struct mpr_command *cm)
1603 {
1604         MPI2_SCSI_TASK_MANAGE_REQUEST *req;
1605         struct mprsas_target *targ;
1606         int err;
1607
1608         targ = cm->cm_targ;
1609         if (targ->handle == 0) {
1610                 mpr_dprint(sc, MPR_ERROR|MPR_RECOVERY,
1611                    "%s null devhandle for target_id %d\n",
1612                     __func__, cm->cm_ccb->ccb_h.target_id);
1613                 return -1;
1614         }
1615
1616         mprsas_log_command(cm, MPR_RECOVERY|MPR_INFO,
1617             "Aborting command %p\n", cm);
1618
1619         req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
1620         req->DevHandle = htole16(targ->handle);
1621         req->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
1622         req->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK;
1623
1624         /* XXX Need to handle invalid LUNs */
1625         MPR_SET_LUN(req->LUN, cm->cm_ccb->ccb_h.target_lun);
1626
1627         req->TaskMID = htole16(cm->cm_desc.Default.SMID);
1628
1629         tm->cm_data = NULL;
1630         tm->cm_desc.HighPriority.RequestFlags =
1631             MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY;
1632         tm->cm_complete = mprsas_abort_complete;
1633         tm->cm_complete_data = (void *)tm;
1634         tm->cm_targ = cm->cm_targ;
1635         tm->cm_lun = cm->cm_lun;
1636
1637         callout_reset(&tm->cm_callout, MPR_ABORT_TIMEOUT * hz,
1638             mprsas_tm_timeout, tm);
1639
1640         targ->aborts++;
1641
1642         mprsas_prepare_for_tm(sc, tm, targ, tm->cm_lun);
1643
1644         err = mpr_map_command(sc, tm);
1645         if (err)
1646                 mpr_dprint(sc, MPR_ERROR|MPR_RECOVERY,
1647                     "error %d sending abort for cm %p SMID %u\n",
1648                     err, cm, req->TaskMID);
1649         return err;
1650 }
1651
1652 static void
1653 mprsas_scsiio_timeout(void *data)
1654 {
1655         sbintime_t elapsed, now;
1656         union ccb *ccb;
1657         struct mpr_softc *sc;
1658         struct mpr_command *cm;
1659         struct mprsas_target *targ;
1660
1661         cm = (struct mpr_command *)data;
1662         sc = cm->cm_sc;
1663         ccb = cm->cm_ccb;
1664         now = sbinuptime();
1665
1666         MPR_FUNCTRACE(sc);
1667         mtx_assert(&sc->mpr_mtx, MA_OWNED);
1668
1669         mpr_dprint(sc, MPR_XINFO|MPR_RECOVERY, "Timeout checking cm %p\n", cm);
1670
1671         /*
1672          * Run the interrupt handler to make sure it's not pending.  This
1673          * isn't perfect because the command could have already completed
1674          * and been re-used, though this is unlikely.
1675          */
1676         mpr_intr_locked(sc);
1677         if (cm->cm_state == MPR_CM_STATE_FREE) {
1678                 mprsas_log_command(cm, MPR_XINFO,
1679                     "SCSI command %p almost timed out\n", cm);
1680                 return;
1681         }
1682
1683         if (cm->cm_ccb == NULL) {
1684                 mpr_dprint(sc, MPR_ERROR, "command timeout with NULL ccb\n");
1685                 return;
1686         }
1687
1688         targ = cm->cm_targ;
1689         targ->timeouts++;
1690
1691         elapsed = now - ccb->ccb_h.qos.sim_data;
1692         mprsas_log_command(cm, MPR_INFO|MPR_RECOVERY,
1693             "Command timeout on target %u(0x%04x), %d set, %d.%d elapsed\n",
1694             targ->tid, targ->handle, ccb->ccb_h.timeout,
1695             sbintime_getsec(elapsed), elapsed & 0xffffffff);
1696         if (targ->encl_level_valid) {
1697                 mpr_dprint(sc, MPR_INFO|MPR_RECOVERY,
1698                     "At enclosure level %d, slot %d, connector name (%4s)\n",
1699                     targ->encl_level, targ->encl_slot, targ->connector_name);
1700         }
1701
1702         /* XXX first, check the firmware state, to see if it's still
1703          * operational.  if not, do a diag reset.
1704          */
1705         mprsas_set_ccbstatus(cm->cm_ccb, CAM_CMD_TIMEOUT);
1706         cm->cm_state = MPR_CM_STATE_TIMEDOUT;
1707         TAILQ_INSERT_TAIL(&targ->timedout_commands, cm, cm_recovery);
1708
1709         if (targ->tm != NULL) {
1710                 /* target already in recovery, just queue up another
1711                  * timedout command to be processed later.
1712                  */
1713                 mpr_dprint(sc, MPR_RECOVERY, "queued timedout cm %p for "
1714                     "processing by tm %p\n", cm, targ->tm);
1715         }
1716         else if ((targ->tm = mprsas_alloc_tm(sc)) != NULL) {
1717
1718                 /* start recovery by aborting the first timedout command */
1719                 mpr_dprint(sc, MPR_RECOVERY|MPR_INFO,
1720                     "Sending abort to target %u for SMID %d\n", targ->tid,
1721                     cm->cm_desc.Default.SMID);
1722                 mpr_dprint(sc, MPR_RECOVERY, "timedout cm %p allocated tm %p\n",
1723                     cm, targ->tm);
1724                 mprsas_send_abort(sc, targ->tm, cm);
1725         }
1726         else {
1727                 /* XXX queue this target up for recovery once a TM becomes
1728                  * available.  The firmware only has a limited number of
1729                  * HighPriority credits for the high priority requests used
1730                  * for task management, and we ran out.
1731                  *
1732                  * Isilon: don't worry about this for now, since we have
1733                  * more credits than disks in an enclosure, and limit
1734                  * ourselves to one TM per target for recovery.
1735                  */
1736                 mpr_dprint(sc, MPR_ERROR|MPR_RECOVERY,
1737                     "timedout cm %p failed to allocate a tm\n", cm);
1738         }
1739 }
1740
1741 /**
1742  * mprsas_build_nvme_unmap - Build Native NVMe DSM command equivalent
1743  *                           to SCSI Unmap.
1744  * Return 0 - for success,
1745  *        1 - to immediately return back the command with success status to CAM
1746  *        negative value - to fallback to firmware path i.e. issue scsi unmap
1747  *                         to FW without any translation.
1748  */
1749 static int
1750 mprsas_build_nvme_unmap(struct mpr_softc *sc, struct mpr_command *cm,
1751     union ccb *ccb, struct mprsas_target *targ)
1752 {
1753         Mpi26NVMeEncapsulatedRequest_t *req = NULL;
1754         struct ccb_scsiio *csio;
1755         struct unmap_parm_list *plist;
1756         struct nvme_dsm_range *nvme_dsm_ranges = NULL;
1757         struct nvme_command *c;
1758         int i, res;
1759         uint16_t ndesc, list_len, data_length;
1760         struct mpr_prp_page *prp_page_info;
1761         uint64_t nvme_dsm_ranges_dma_handle;
1762
1763         csio = &ccb->csio;
1764 #if __FreeBSD_version >= 1100103
1765         list_len = (scsiio_cdb_ptr(csio)[7] << 8 | scsiio_cdb_ptr(csio)[8]);
1766 #else
1767         if (csio->ccb_h.flags & CAM_CDB_POINTER) {
1768                 list_len = (ccb->csio.cdb_io.cdb_ptr[7] << 8 |
1769                     ccb->csio.cdb_io.cdb_ptr[8]);
1770         } else {
1771                 list_len = (ccb->csio.cdb_io.cdb_bytes[7] << 8 |
1772                     ccb->csio.cdb_io.cdb_bytes[8]);
1773         }
1774 #endif
1775         if (!list_len) {
1776                 mpr_dprint(sc, MPR_ERROR, "Parameter list length is Zero\n");
1777                 return -EINVAL;
1778         }
1779
1780         plist = malloc(csio->dxfer_len, M_MPR, M_ZERO|M_NOWAIT);
1781         if (!plist) {
1782                 mpr_dprint(sc, MPR_ERROR, "Unable to allocate memory to "
1783                     "save UNMAP data\n");
1784                 return -ENOMEM;
1785         }
1786
1787         /* Copy SCSI unmap data to a local buffer */
1788         bcopy(csio->data_ptr, plist, csio->dxfer_len);
1789
1790         /* return back the unmap command to CAM with success status,
1791          * if number of descripts is zero.
1792          */
1793         ndesc = be16toh(plist->unmap_blk_desc_data_len) >> 4;
1794         if (!ndesc) {
1795                 mpr_dprint(sc, MPR_XINFO, "Number of descriptors in "
1796                     "UNMAP cmd is Zero\n");
1797                 res = 1;
1798                 goto out;
1799         }
1800
1801         data_length = ndesc * sizeof(struct nvme_dsm_range);
1802         if (data_length > targ->MDTS) {
1803                 mpr_dprint(sc, MPR_ERROR, "data length: %d is greater than "
1804                     "Device's MDTS: %d\n", data_length, targ->MDTS);
1805                 res = -EINVAL;
1806                 goto out;
1807         }
1808
1809         prp_page_info = mpr_alloc_prp_page(sc);
1810         KASSERT(prp_page_info != NULL, ("%s: There is no PRP Page for "
1811             "UNMAP command.\n", __func__));
1812
1813         /*
1814          * Insert the allocated PRP page into the command's PRP page list. This
1815          * will be freed when the command is freed.
1816          */
1817         TAILQ_INSERT_TAIL(&cm->cm_prp_page_list, prp_page_info, prp_page_link);
1818
1819         nvme_dsm_ranges = (struct nvme_dsm_range *)prp_page_info->prp_page;
1820         nvme_dsm_ranges_dma_handle = prp_page_info->prp_page_busaddr;
1821
1822         bzero(nvme_dsm_ranges, data_length);
1823
1824         /* Convert SCSI unmap's descriptor data to NVMe DSM specific Range data
1825          * for each descriptors contained in SCSI UNMAP data.
1826          */
1827         for (i = 0; i < ndesc; i++) {
1828                 nvme_dsm_ranges[i].length =
1829                     htole32(be32toh(plist->desc[i].nlb));
1830                 nvme_dsm_ranges[i].starting_lba =
1831                     htole64(be64toh(plist->desc[i].slba));
1832                 nvme_dsm_ranges[i].attributes = 0;
1833         }
1834
1835         /* Build MPI2.6's NVMe Encapsulated Request Message */
1836         req = (Mpi26NVMeEncapsulatedRequest_t *)cm->cm_req;
1837         bzero(req, sizeof(*req));
1838         req->DevHandle = htole16(targ->handle);
1839         req->Function = MPI2_FUNCTION_NVME_ENCAPSULATED;
1840         req->Flags = MPI26_NVME_FLAGS_WRITE;
1841         req->ErrorResponseBaseAddress.High =
1842             htole32((uint32_t)((uint64_t)cm->cm_sense_busaddr >> 32));
1843         req->ErrorResponseBaseAddress.Low =
1844             htole32(cm->cm_sense_busaddr);
1845         req->ErrorResponseAllocationLength =
1846             htole16(sizeof(struct nvme_completion));
1847         req->EncapsulatedCommandLength =
1848             htole16(sizeof(struct nvme_command));
1849         req->DataLength = htole32(data_length);
1850
1851         /* Build NVMe DSM command */
1852         c = (struct nvme_command *) req->NVMe_Command;
1853         c->opc = NVME_OPC_DATASET_MANAGEMENT;
1854         c->nsid = htole32(csio->ccb_h.target_lun + 1);
1855         c->cdw10 = htole32(ndesc - 1);
1856         c->cdw11 = htole32(NVME_DSM_ATTR_DEALLOCATE);
1857
1858         cm->cm_length = data_length;
1859         cm->cm_data = NULL;
1860
1861         cm->cm_complete = mprsas_scsiio_complete;
1862         cm->cm_complete_data = ccb;
1863         cm->cm_targ = targ;
1864         cm->cm_lun = csio->ccb_h.target_lun;
1865         cm->cm_ccb = ccb;
1866
1867         cm->cm_desc.Default.RequestFlags =
1868             MPI26_REQ_DESCRIPT_FLAGS_PCIE_ENCAPSULATED;
1869
1870         csio->ccb_h.qos.sim_data = sbinuptime();
1871 #if __FreeBSD_version >= 1000029
1872         callout_reset_sbt(&cm->cm_callout, SBT_1MS * ccb->ccb_h.timeout, 0,
1873             mprsas_scsiio_timeout, cm, 0);
1874 #else //__FreeBSD_version < 1000029
1875         callout_reset(&cm->cm_callout, (ccb->ccb_h.timeout * hz) / 1000,
1876             mprsas_scsiio_timeout, cm);
1877 #endif //__FreeBSD_version >= 1000029
1878
1879         targ->issued++;
1880         targ->outstanding++;
1881         TAILQ_INSERT_TAIL(&targ->commands, cm, cm_link);
1882         ccb->ccb_h.status |= CAM_SIM_QUEUED;
1883
1884         mprsas_log_command(cm, MPR_XINFO, "%s cm %p ccb %p outstanding %u\n",
1885             __func__, cm, ccb, targ->outstanding);
1886
1887         mpr_build_nvme_prp(sc, cm, req,
1888             (void *)(uintptr_t)nvme_dsm_ranges_dma_handle, 0, data_length);
1889         mpr_map_command(sc, cm);
1890
1891 out:
1892         free(plist, M_MPR);
1893         return 0;
1894 }
1895
1896 static void
1897 mprsas_action_scsiio(struct mprsas_softc *sassc, union ccb *ccb)
1898 {
1899         MPI2_SCSI_IO_REQUEST *req;
1900         struct ccb_scsiio *csio;
1901         struct mpr_softc *sc;
1902         struct mprsas_target *targ;
1903         struct mprsas_lun *lun;
1904         struct mpr_command *cm;
1905         uint8_t i, lba_byte, *ref_tag_addr, scsi_opcode;
1906         uint16_t eedp_flags;
1907         uint32_t mpi_control;
1908         int rc;
1909
1910         sc = sassc->sc;
1911         MPR_FUNCTRACE(sc);
1912         mtx_assert(&sc->mpr_mtx, MA_OWNED);
1913
1914         csio = &ccb->csio;
1915         KASSERT(csio->ccb_h.target_id < sassc->maxtargets,
1916             ("Target %d out of bounds in XPT_SCSI_IO\n",
1917              csio->ccb_h.target_id));
1918         targ = &sassc->targets[csio->ccb_h.target_id];
1919         mpr_dprint(sc, MPR_TRACE, "ccb %p target flag %x\n", ccb, targ->flags);
1920         if (targ->handle == 0x0) {
1921                 mpr_dprint(sc, MPR_ERROR, "%s NULL handle for target %u\n",
1922                     __func__, csio->ccb_h.target_id);
1923                 mprsas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
1924                 xpt_done(ccb);
1925                 return;
1926         }
1927         if (targ->flags & MPR_TARGET_FLAGS_RAID_COMPONENT) {
1928                 mpr_dprint(sc, MPR_ERROR, "%s Raid component no SCSI IO "
1929                     "supported %u\n", __func__, csio->ccb_h.target_id);
1930                 mprsas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
1931                 xpt_done(ccb);
1932                 return;
1933         }
1934         /*
1935          * Sometimes, it is possible to get a command that is not "In
1936          * Progress" and was actually aborted by the upper layer.  Check for
1937          * this here and complete the command without error.
1938          */
1939         if (mprsas_get_ccbstatus(ccb) != CAM_REQ_INPROG) {
1940                 mpr_dprint(sc, MPR_TRACE, "%s Command is not in progress for "
1941                     "target %u\n", __func__, csio->ccb_h.target_id);
1942                 xpt_done(ccb);
1943                 return;
1944         }
1945         /*
1946          * If devinfo is 0 this will be a volume.  In that case don't tell CAM
1947          * that the volume has timed out.  We want volumes to be enumerated
1948          * until they are deleted/removed, not just failed.
1949          */
1950         if (targ->flags & MPRSAS_TARGET_INREMOVAL) {
1951                 if (targ->devinfo == 0)
1952                         mprsas_set_ccbstatus(ccb, CAM_REQ_CMP);
1953                 else
1954                         mprsas_set_ccbstatus(ccb, CAM_SEL_TIMEOUT);
1955                 xpt_done(ccb);
1956                 return;
1957         }
1958
1959         if ((sc->mpr_flags & MPR_FLAGS_SHUTDOWN) != 0) {
1960                 mpr_dprint(sc, MPR_INFO, "%s shutting down\n", __func__);
1961                 mprsas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
1962                 xpt_done(ccb);
1963                 return;
1964         }
1965
1966         /*
1967          * If target has a reset in progress, freeze the devq and return.  The
1968          * devq will be released when the TM reset is finished.
1969          */
1970         if (targ->flags & MPRSAS_TARGET_INRESET) {
1971                 ccb->ccb_h.status = CAM_BUSY | CAM_DEV_QFRZN;
1972                 mpr_dprint(sc, MPR_INFO, "%s: Freezing devq for target ID %d\n",
1973                     __func__, targ->tid);
1974                 xpt_freeze_devq(ccb->ccb_h.path, 1);
1975                 xpt_done(ccb);
1976                 return;
1977         }
1978
1979         cm = mpr_alloc_command(sc);
1980         if (cm == NULL || (sc->mpr_flags & MPR_FLAGS_DIAGRESET)) {
1981                 if (cm != NULL) {
1982                         mpr_free_command(sc, cm);
1983                 }
1984                 if ((sassc->flags & MPRSAS_QUEUE_FROZEN) == 0) {
1985                         xpt_freeze_simq(sassc->sim, 1);
1986                         sassc->flags |= MPRSAS_QUEUE_FROZEN;
1987                 }
1988                 ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
1989                 ccb->ccb_h.status |= CAM_REQUEUE_REQ;
1990                 xpt_done(ccb);
1991                 return;
1992         }
1993
1994         /* For NVME device's issue UNMAP command directly to NVME drives by
1995          * constructing equivalent native NVMe DataSetManagement command.
1996          */
1997 #if __FreeBSD_version >= 1100103
1998         scsi_opcode = scsiio_cdb_ptr(csio)[0];
1999 #else
2000         if (csio->ccb_h.flags & CAM_CDB_POINTER)
2001                 scsi_opcode = csio->cdb_io.cdb_ptr[0];
2002         else
2003                 scsi_opcode = csio->cdb_io.cdb_bytes[0];
2004 #endif
2005         if (scsi_opcode == UNMAP &&
2006             targ->is_nvme &&
2007             (csio->ccb_h.flags & CAM_DATA_MASK) == CAM_DATA_VADDR) {
2008                 rc = mprsas_build_nvme_unmap(sc, cm, ccb, targ);
2009                 if (rc == 1) { /* return command to CAM with success status */
2010                         mpr_free_command(sc, cm);
2011                         mprsas_set_ccbstatus(ccb, CAM_REQ_CMP);
2012                         xpt_done(ccb);
2013                         return;
2014                 } else if (!rc) /* Issued NVMe Encapsulated Request Message */
2015                         return;
2016         }
2017
2018         req = (MPI2_SCSI_IO_REQUEST *)cm->cm_req;
2019         bzero(req, sizeof(*req));
2020         req->DevHandle = htole16(targ->handle);
2021         req->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
2022         req->MsgFlags = 0;
2023         req->SenseBufferLowAddress = htole32(cm->cm_sense_busaddr);
2024         req->SenseBufferLength = MPR_SENSE_LEN;
2025         req->SGLFlags = 0;
2026         req->ChainOffset = 0;
2027         req->SGLOffset0 = 24;   /* 32bit word offset to the SGL */
2028         req->SGLOffset1= 0;
2029         req->SGLOffset2= 0;
2030         req->SGLOffset3= 0;
2031         req->SkipCount = 0;
2032         req->DataLength = htole32(csio->dxfer_len);
2033         req->BidirectionalDataLength = 0;
2034         req->IoFlags = htole16(csio->cdb_len);
2035         req->EEDPFlags = 0;
2036
2037         /* Note: BiDirectional transfers are not supported */
2038         switch (csio->ccb_h.flags & CAM_DIR_MASK) {
2039         case CAM_DIR_IN:
2040                 mpi_control = MPI2_SCSIIO_CONTROL_READ;
2041                 cm->cm_flags |= MPR_CM_FLAGS_DATAIN;
2042                 break;
2043         case CAM_DIR_OUT:
2044                 mpi_control = MPI2_SCSIIO_CONTROL_WRITE;
2045                 cm->cm_flags |= MPR_CM_FLAGS_DATAOUT;
2046                 break;
2047         case CAM_DIR_NONE:
2048         default:
2049                 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER;
2050                 break;
2051         }
2052
2053         if (csio->cdb_len == 32)
2054                 mpi_control |= 4 << MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT;
2055         /*
2056          * It looks like the hardware doesn't require an explicit tag
2057          * number for each transaction.  SAM Task Management not supported
2058          * at the moment.
2059          */
2060         switch (csio->tag_action) {
2061         case MSG_HEAD_OF_Q_TAG:
2062                 mpi_control |= MPI2_SCSIIO_CONTROL_HEADOFQ;
2063                 break;
2064         case MSG_ORDERED_Q_TAG:
2065                 mpi_control |= MPI2_SCSIIO_CONTROL_ORDEREDQ;
2066                 break;
2067         case MSG_ACA_TASK:
2068                 mpi_control |= MPI2_SCSIIO_CONTROL_ACAQ;
2069                 break;
2070         case CAM_TAG_ACTION_NONE:
2071         case MSG_SIMPLE_Q_TAG:
2072         default:
2073                 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
2074                 break;
2075         }
2076         mpi_control |= sc->mapping_table[csio->ccb_h.target_id].TLR_bits;
2077         req->Control = htole32(mpi_control);
2078
2079         if (MPR_SET_LUN(req->LUN, csio->ccb_h.target_lun) != 0) {
2080                 mpr_free_command(sc, cm);
2081                 mprsas_set_ccbstatus(ccb, CAM_LUN_INVALID);
2082                 xpt_done(ccb);
2083                 return;
2084         }
2085
2086         if (csio->ccb_h.flags & CAM_CDB_POINTER)
2087                 bcopy(csio->cdb_io.cdb_ptr, &req->CDB.CDB32[0], csio->cdb_len);
2088         else {
2089                 KASSERT(csio->cdb_len <= IOCDBLEN,
2090                     ("cdb_len %d is greater than IOCDBLEN but CAM_CDB_POINTER "
2091                     "is not set", csio->cdb_len));
2092                 bcopy(csio->cdb_io.cdb_bytes, &req->CDB.CDB32[0],csio->cdb_len);
2093         }
2094         req->IoFlags = htole16(csio->cdb_len);
2095
2096         /*
2097          * Check if EEDP is supported and enabled.  If it is then check if the
2098          * SCSI opcode could be using EEDP.  If so, make sure the LUN exists and
2099          * is formatted for EEDP support.  If all of this is true, set CDB up
2100          * for EEDP transfer.
2101          */
2102         eedp_flags = op_code_prot[req->CDB.CDB32[0]];
2103         if (sc->eedp_enabled && eedp_flags) {
2104                 SLIST_FOREACH(lun, &targ->luns, lun_link) {
2105                         if (lun->lun_id == csio->ccb_h.target_lun) {
2106                                 break;
2107                         }
2108                 }
2109
2110                 if ((lun != NULL) && (lun->eedp_formatted)) {
2111                         req->EEDPBlockSize = htole16(lun->eedp_block_size);
2112                         eedp_flags |= (MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
2113                             MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
2114                             MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD);
2115                         if (sc->mpr_flags & MPR_FLAGS_GEN35_IOC) {
2116                                 eedp_flags |=
2117                                     MPI25_SCSIIO_EEDPFLAGS_APPTAG_DISABLE_MODE;
2118                         }
2119                         req->EEDPFlags = htole16(eedp_flags);
2120
2121                         /*
2122                          * If CDB less than 32, fill in Primary Ref Tag with
2123                          * low 4 bytes of LBA.  If CDB is 32, tag stuff is
2124                          * already there.  Also, set protection bit.  FreeBSD
2125                          * currently does not support CDBs bigger than 16, but
2126                          * the code doesn't hurt, and will be here for the
2127                          * future.
2128                          */
2129                         if (csio->cdb_len != 32) {
2130                                 lba_byte = (csio->cdb_len == 16) ? 6 : 2;
2131                                 ref_tag_addr = (uint8_t *)&req->CDB.EEDP32.
2132                                     PrimaryReferenceTag;
2133                                 for (i = 0; i < 4; i++) {
2134                                         *ref_tag_addr =
2135                                             req->CDB.CDB32[lba_byte + i];
2136                                         ref_tag_addr++;
2137                                 }
2138                                 req->CDB.EEDP32.PrimaryReferenceTag =
2139                                     htole32(req->
2140                                     CDB.EEDP32.PrimaryReferenceTag);
2141                                 req->CDB.EEDP32.PrimaryApplicationTagMask =
2142                                     0xFFFF;
2143                                 req->CDB.CDB32[1] = (req->CDB.CDB32[1] & 0x1F) |
2144                                     0x20;
2145                         } else {
2146                                 eedp_flags |=
2147                                     MPI2_SCSIIO_EEDPFLAGS_INC_PRI_APPTAG;
2148                                 req->EEDPFlags = htole16(eedp_flags);
2149                                 req->CDB.CDB32[10] = (req->CDB.CDB32[10] &
2150                                     0x1F) | 0x20;
2151                         }
2152                 }
2153         }
2154
2155         cm->cm_length = csio->dxfer_len;
2156         if (cm->cm_length != 0) {
2157                 cm->cm_data = ccb;
2158                 cm->cm_flags |= MPR_CM_FLAGS_USE_CCB;
2159         } else {
2160                 cm->cm_data = NULL;
2161         }
2162         cm->cm_sge = &req->SGL;
2163         cm->cm_sglsize = (32 - 24) * 4;
2164         cm->cm_complete = mprsas_scsiio_complete;
2165         cm->cm_complete_data = ccb;
2166         cm->cm_targ = targ;
2167         cm->cm_lun = csio->ccb_h.target_lun;
2168         cm->cm_ccb = ccb;
2169         /*
2170          * If using FP desc type, need to set a bit in IoFlags (SCSI IO is 0)
2171          * and set descriptor type.
2172          */
2173         if (targ->scsi_req_desc_type ==
2174             MPI25_REQ_DESCRIPT_FLAGS_FAST_PATH_SCSI_IO) {
2175                 req->IoFlags |= MPI25_SCSIIO_IOFLAGS_FAST_PATH;
2176                 cm->cm_desc.FastPathSCSIIO.RequestFlags =
2177                     MPI25_REQ_DESCRIPT_FLAGS_FAST_PATH_SCSI_IO;
2178                 if (!sc->atomic_desc_capable) {
2179                         cm->cm_desc.FastPathSCSIIO.DevHandle =
2180                             htole16(targ->handle);
2181                 }
2182         } else {
2183                 cm->cm_desc.SCSIIO.RequestFlags =
2184                     MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO;
2185                 if (!sc->atomic_desc_capable)
2186                         cm->cm_desc.SCSIIO.DevHandle = htole16(targ->handle);
2187         }
2188
2189         csio->ccb_h.qos.sim_data = sbinuptime();
2190 #if __FreeBSD_version >= 1000029
2191         callout_reset_sbt(&cm->cm_callout, SBT_1MS * ccb->ccb_h.timeout, 0,
2192             mprsas_scsiio_timeout, cm, 0);
2193 #else //__FreeBSD_version < 1000029
2194         callout_reset(&cm->cm_callout, (ccb->ccb_h.timeout * hz) / 1000,
2195             mprsas_scsiio_timeout, cm);
2196 #endif //__FreeBSD_version >= 1000029
2197
2198         targ->issued++;
2199         targ->outstanding++;
2200         TAILQ_INSERT_TAIL(&targ->commands, cm, cm_link);
2201         ccb->ccb_h.status |= CAM_SIM_QUEUED;
2202
2203         mprsas_log_command(cm, MPR_XINFO, "%s cm %p ccb %p outstanding %u\n",
2204             __func__, cm, ccb, targ->outstanding);
2205
2206         mpr_map_command(sc, cm);
2207         return;
2208 }
2209
2210 /**
2211  * mpr_sc_failed_io_info - translated non-succesfull SCSI_IO request
2212  */
2213 static void
2214 mpr_sc_failed_io_info(struct mpr_softc *sc, struct ccb_scsiio *csio,
2215     Mpi2SCSIIOReply_t *mpi_reply, struct mprsas_target *targ)
2216 {
2217         u32 response_info;
2218         u8 *response_bytes;
2219         u16 ioc_status = le16toh(mpi_reply->IOCStatus) &
2220             MPI2_IOCSTATUS_MASK;
2221         u8 scsi_state = mpi_reply->SCSIState;
2222         u8 scsi_status = mpi_reply->SCSIStatus;
2223         char *desc_ioc_state = NULL;
2224         char *desc_scsi_status = NULL;
2225         u32 log_info = le32toh(mpi_reply->IOCLogInfo);
2226
2227         if (log_info == 0x31170000)
2228                 return;
2229
2230         desc_ioc_state = mpr_describe_table(mpr_iocstatus_string,
2231              ioc_status);
2232         desc_scsi_status = mpr_describe_table(mpr_scsi_status_string,
2233             scsi_status);
2234
2235         mpr_dprint(sc, MPR_XINFO, "\thandle(0x%04x), ioc_status(%s)(0x%04x)\n",
2236             le16toh(mpi_reply->DevHandle), desc_ioc_state, ioc_status);
2237         if (targ->encl_level_valid) {
2238                 mpr_dprint(sc, MPR_XINFO, "At enclosure level %d, slot %d, "
2239                     "connector name (%4s)\n", targ->encl_level, targ->encl_slot,
2240                     targ->connector_name);
2241         }
2242
2243         /*
2244          * We can add more detail about underflow data here
2245          * TO-DO
2246          */
2247         mpr_dprint(sc, MPR_XINFO, "\tscsi_status(%s)(0x%02x), "
2248             "scsi_state %b\n", desc_scsi_status, scsi_status,
2249             scsi_state, "\20" "\1AutosenseValid" "\2AutosenseFailed"
2250             "\3NoScsiStatus" "\4Terminated" "\5Response InfoValid");
2251
2252         if (sc->mpr_debug & MPR_XINFO &&
2253             scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
2254                 mpr_dprint(sc, MPR_XINFO, "-> Sense Buffer Data : Start :\n");
2255                 scsi_sense_print(csio);
2256                 mpr_dprint(sc, MPR_XINFO, "-> Sense Buffer Data : End :\n");
2257         }
2258
2259         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) {
2260                 response_info = le32toh(mpi_reply->ResponseInfo);
2261                 response_bytes = (u8 *)&response_info;
2262                 mpr_dprint(sc, MPR_XINFO, "response code(0x%01x): %s\n",
2263                     response_bytes[0],
2264                     mpr_describe_table(mpr_scsi_taskmgmt_string,
2265                     response_bytes[0]));
2266         }
2267 }
2268
2269 /** mprsas_nvme_trans_status_code
2270  *
2271  * Convert Native NVMe command error status to
2272  * equivalent SCSI error status.
2273  *
2274  * Returns appropriate scsi_status
2275  */
2276 static u8
2277 mprsas_nvme_trans_status_code(struct nvme_status nvme_status,
2278     struct mpr_command *cm)
2279 {
2280         u8 status = MPI2_SCSI_STATUS_GOOD;
2281         int skey, asc, ascq;
2282         union ccb *ccb = cm->cm_complete_data;
2283         int returned_sense_len;
2284
2285         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2286         skey = SSD_KEY_ILLEGAL_REQUEST;
2287         asc = SCSI_ASC_NO_SENSE;
2288         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2289
2290         switch (nvme_status.sct) {
2291         case NVME_SCT_GENERIC:
2292                 switch (nvme_status.sc) {
2293                 case NVME_SC_SUCCESS:
2294                         status = MPI2_SCSI_STATUS_GOOD;
2295                         skey = SSD_KEY_NO_SENSE;
2296                         asc = SCSI_ASC_NO_SENSE;
2297                         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2298                         break;
2299                 case NVME_SC_INVALID_OPCODE:
2300                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2301                         skey = SSD_KEY_ILLEGAL_REQUEST;
2302                         asc = SCSI_ASC_ILLEGAL_COMMAND;
2303                         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2304                         break;
2305                 case NVME_SC_INVALID_FIELD:
2306                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2307                         skey = SSD_KEY_ILLEGAL_REQUEST;
2308                         asc = SCSI_ASC_INVALID_CDB;
2309                         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2310                         break;
2311                 case NVME_SC_DATA_TRANSFER_ERROR:
2312                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2313                         skey = SSD_KEY_MEDIUM_ERROR;
2314                         asc = SCSI_ASC_NO_SENSE;
2315                         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2316                         break;
2317                 case NVME_SC_ABORTED_POWER_LOSS:
2318                         status = MPI2_SCSI_STATUS_TASK_ABORTED;
2319                         skey = SSD_KEY_ABORTED_COMMAND;
2320                         asc = SCSI_ASC_WARNING;
2321                         ascq = SCSI_ASCQ_POWER_LOSS_EXPECTED;
2322                         break;
2323                 case NVME_SC_INTERNAL_DEVICE_ERROR:
2324                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2325                         skey = SSD_KEY_HARDWARE_ERROR;
2326                         asc = SCSI_ASC_INTERNAL_TARGET_FAILURE;
2327                         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2328                         break;
2329                 case NVME_SC_ABORTED_BY_REQUEST:
2330                 case NVME_SC_ABORTED_SQ_DELETION:
2331                 case NVME_SC_ABORTED_FAILED_FUSED:
2332                 case NVME_SC_ABORTED_MISSING_FUSED:
2333                         status = MPI2_SCSI_STATUS_TASK_ABORTED;
2334                         skey = SSD_KEY_ABORTED_COMMAND;
2335                         asc = SCSI_ASC_NO_SENSE;
2336                         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2337                         break;
2338                 case NVME_SC_INVALID_NAMESPACE_OR_FORMAT:
2339                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2340                         skey = SSD_KEY_ILLEGAL_REQUEST;
2341                         asc = SCSI_ASC_ACCESS_DENIED_INVALID_LUN_ID;
2342                         ascq = SCSI_ASCQ_INVALID_LUN_ID;
2343                         break;
2344                 case NVME_SC_LBA_OUT_OF_RANGE:
2345                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2346                         skey = SSD_KEY_ILLEGAL_REQUEST;
2347                         asc = SCSI_ASC_ILLEGAL_BLOCK;
2348                         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2349                         break;
2350                 case NVME_SC_CAPACITY_EXCEEDED:
2351                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2352                         skey = SSD_KEY_MEDIUM_ERROR;
2353                         asc = SCSI_ASC_NO_SENSE;
2354                         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2355                         break;
2356                 case NVME_SC_NAMESPACE_NOT_READY:
2357                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2358                         skey = SSD_KEY_NOT_READY;
2359                         asc = SCSI_ASC_LUN_NOT_READY;
2360                         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2361                         break;
2362                 }
2363                 break;
2364         case NVME_SCT_COMMAND_SPECIFIC:
2365                 switch (nvme_status.sc) {
2366                 case NVME_SC_INVALID_FORMAT:
2367                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2368                         skey = SSD_KEY_ILLEGAL_REQUEST;
2369                         asc = SCSI_ASC_FORMAT_COMMAND_FAILED;
2370                         ascq = SCSI_ASCQ_FORMAT_COMMAND_FAILED;
2371                         break;
2372                 case NVME_SC_CONFLICTING_ATTRIBUTES:
2373                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2374                         skey = SSD_KEY_ILLEGAL_REQUEST;
2375                         asc = SCSI_ASC_INVALID_CDB;
2376                         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2377                         break;
2378                 }
2379                 break;
2380         case NVME_SCT_MEDIA_ERROR:
2381                 switch (nvme_status.sc) {
2382                 case NVME_SC_WRITE_FAULTS:
2383                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2384                         skey = SSD_KEY_MEDIUM_ERROR;
2385                         asc = SCSI_ASC_PERIPHERAL_DEV_WRITE_FAULT;
2386                         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2387                         break;
2388                 case NVME_SC_UNRECOVERED_READ_ERROR:
2389                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2390                         skey = SSD_KEY_MEDIUM_ERROR;
2391                         asc = SCSI_ASC_UNRECOVERED_READ_ERROR;
2392                         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2393                         break;
2394                 case NVME_SC_GUARD_CHECK_ERROR:
2395                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2396                         skey = SSD_KEY_MEDIUM_ERROR;
2397                         asc = SCSI_ASC_LOG_BLOCK_GUARD_CHECK_FAILED;
2398                         ascq = SCSI_ASCQ_LOG_BLOCK_GUARD_CHECK_FAILED;
2399                         break;
2400                 case NVME_SC_APPLICATION_TAG_CHECK_ERROR:
2401                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2402                         skey = SSD_KEY_MEDIUM_ERROR;
2403                         asc = SCSI_ASC_LOG_BLOCK_APPTAG_CHECK_FAILED;
2404                         ascq = SCSI_ASCQ_LOG_BLOCK_APPTAG_CHECK_FAILED;
2405                         break;
2406                 case NVME_SC_REFERENCE_TAG_CHECK_ERROR:
2407                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2408                         skey = SSD_KEY_MEDIUM_ERROR;
2409                         asc = SCSI_ASC_LOG_BLOCK_REFTAG_CHECK_FAILED;
2410                         ascq = SCSI_ASCQ_LOG_BLOCK_REFTAG_CHECK_FAILED;
2411                         break;
2412                 case NVME_SC_COMPARE_FAILURE:
2413                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2414                         skey = SSD_KEY_MISCOMPARE;
2415                         asc = SCSI_ASC_MISCOMPARE_DURING_VERIFY;
2416                         ascq = SCSI_ASCQ_CAUSE_NOT_REPORTABLE;
2417                         break;
2418                 case NVME_SC_ACCESS_DENIED:
2419                         status = MPI2_SCSI_STATUS_CHECK_CONDITION;
2420                         skey = SSD_KEY_ILLEGAL_REQUEST;
2421                         asc = SCSI_ASC_ACCESS_DENIED_INVALID_LUN_ID;
2422                         ascq = SCSI_ASCQ_INVALID_LUN_ID;
2423                         break;
2424                 }
2425                 break;
2426         }
2427
2428         returned_sense_len = sizeof(struct scsi_sense_data);
2429         if (returned_sense_len < ccb->csio.sense_len)
2430                 ccb->csio.sense_resid = ccb->csio.sense_len -
2431                     returned_sense_len;
2432         else
2433                 ccb->csio.sense_resid = 0;
2434
2435         scsi_set_sense_data(&ccb->csio.sense_data, SSD_TYPE_FIXED,
2436             1, skey, asc, ascq, SSD_ELEM_NONE);
2437         ccb->ccb_h.status |= CAM_AUTOSNS_VALID;
2438
2439         return status;
2440 }
2441
2442 /** mprsas_complete_nvme_unmap
2443  *
2444  * Complete native NVMe command issued using NVMe Encapsulated
2445  * Request Message.
2446  */
2447 static u8
2448 mprsas_complete_nvme_unmap(struct mpr_softc *sc, struct mpr_command *cm)
2449 {
2450         Mpi26NVMeEncapsulatedErrorReply_t *mpi_reply;
2451         struct nvme_completion *nvme_completion = NULL;
2452         u8 scsi_status = MPI2_SCSI_STATUS_GOOD;
2453
2454         mpi_reply =(Mpi26NVMeEncapsulatedErrorReply_t *)cm->cm_reply;
2455         if (le16toh(mpi_reply->ErrorResponseCount)){
2456                 nvme_completion = (struct nvme_completion *)cm->cm_sense;
2457                 scsi_status = mprsas_nvme_trans_status_code(
2458                     nvme_completion->status, cm);
2459         }
2460         return scsi_status;
2461 }
2462
2463 static void
2464 mprsas_scsiio_complete(struct mpr_softc *sc, struct mpr_command *cm)
2465 {
2466         MPI2_SCSI_IO_REPLY *rep;
2467         union ccb *ccb;
2468         struct ccb_scsiio *csio;
2469         struct mprsas_softc *sassc;
2470         struct scsi_vpd_supported_page_list *vpd_list = NULL;
2471         u8 *TLR_bits, TLR_on, *scsi_cdb;
2472         int dir = 0, i;
2473         u16 alloc_len;
2474         struct mprsas_target *target;
2475         target_id_t target_id;
2476
2477         MPR_FUNCTRACE(sc);
2478         mpr_dprint(sc, MPR_TRACE,
2479             "cm %p SMID %u ccb %p reply %p outstanding %u\n", cm,
2480             cm->cm_desc.Default.SMID, cm->cm_ccb, cm->cm_reply,
2481             cm->cm_targ->outstanding);
2482
2483         callout_stop(&cm->cm_callout);
2484         mtx_assert(&sc->mpr_mtx, MA_OWNED);
2485
2486         sassc = sc->sassc;
2487         ccb = cm->cm_complete_data;
2488         csio = &ccb->csio;
2489         target_id = csio->ccb_h.target_id;
2490         rep = (MPI2_SCSI_IO_REPLY *)cm->cm_reply;
2491         /*
2492          * XXX KDM if the chain allocation fails, does it matter if we do
2493          * the sync and unload here?  It is simpler to do it in every case,
2494          * assuming it doesn't cause problems.
2495          */
2496         if (cm->cm_data != NULL) {
2497                 if (cm->cm_flags & MPR_CM_FLAGS_DATAIN)
2498                         dir = BUS_DMASYNC_POSTREAD;
2499                 else if (cm->cm_flags & MPR_CM_FLAGS_DATAOUT)
2500                         dir = BUS_DMASYNC_POSTWRITE;
2501                 bus_dmamap_sync(sc->buffer_dmat, cm->cm_dmamap, dir);
2502                 bus_dmamap_unload(sc->buffer_dmat, cm->cm_dmamap);
2503         }
2504
2505         cm->cm_targ->completed++;
2506         cm->cm_targ->outstanding--;
2507         TAILQ_REMOVE(&cm->cm_targ->commands, cm, cm_link);
2508         ccb->ccb_h.status &= ~(CAM_STATUS_MASK | CAM_SIM_QUEUED);
2509
2510         if (cm->cm_state == MPR_CM_STATE_TIMEDOUT) {
2511                 TAILQ_REMOVE(&cm->cm_targ->timedout_commands, cm, cm_recovery);
2512                 if (cm->cm_reply != NULL)
2513                         mprsas_log_command(cm, MPR_RECOVERY,
2514                             "completed timedout cm %p ccb %p during recovery "
2515                             "ioc %x scsi %x state %x xfer %u\n", cm, cm->cm_ccb,
2516                             le16toh(rep->IOCStatus), rep->SCSIStatus,
2517                             rep->SCSIState, le32toh(rep->TransferCount));
2518                 else
2519                         mprsas_log_command(cm, MPR_RECOVERY,
2520                             "completed timedout cm %p ccb %p during recovery\n",
2521                             cm, cm->cm_ccb);
2522         } else if (cm->cm_targ->tm != NULL) {
2523                 if (cm->cm_reply != NULL)
2524                         mprsas_log_command(cm, MPR_RECOVERY,
2525                             "completed cm %p ccb %p during recovery "
2526                             "ioc %x scsi %x state %x xfer %u\n",
2527                             cm, cm->cm_ccb, le16toh(rep->IOCStatus),
2528                             rep->SCSIStatus, rep->SCSIState,
2529                             le32toh(rep->TransferCount));
2530                 else
2531                         mprsas_log_command(cm, MPR_RECOVERY,
2532                             "completed cm %p ccb %p during recovery\n",
2533                             cm, cm->cm_ccb);
2534         } else if ((sc->mpr_flags & MPR_FLAGS_DIAGRESET) != 0) {
2535                 mprsas_log_command(cm, MPR_RECOVERY,
2536                     "reset completed cm %p ccb %p\n", cm, cm->cm_ccb);
2537         }
2538
2539         if ((cm->cm_flags & MPR_CM_FLAGS_ERROR_MASK) != 0) {
2540                 /*
2541                  * We ran into an error after we tried to map the command,
2542                  * so we're getting a callback without queueing the command
2543                  * to the hardware.  So we set the status here, and it will
2544                  * be retained below.  We'll go through the "fast path",
2545                  * because there can be no reply when we haven't actually
2546                  * gone out to the hardware.
2547                  */
2548                 mprsas_set_ccbstatus(ccb, CAM_REQUEUE_REQ);
2549
2550                 /*
2551                  * Currently the only error included in the mask is
2552                  * MPR_CM_FLAGS_CHAIN_FAILED, which means we're out of
2553                  * chain frames.  We need to freeze the queue until we get
2554                  * a command that completed without this error, which will
2555                  * hopefully have some chain frames attached that we can
2556                  * use.  If we wanted to get smarter about it, we would
2557                  * only unfreeze the queue in this condition when we're
2558                  * sure that we're getting some chain frames back.  That's
2559                  * probably unnecessary.
2560                  */
2561                 if ((sassc->flags & MPRSAS_QUEUE_FROZEN) == 0) {
2562                         xpt_freeze_simq(sassc->sim, 1);
2563                         sassc->flags |= MPRSAS_QUEUE_FROZEN;
2564                         mpr_dprint(sc, MPR_XINFO, "Error sending command, "
2565                             "freezing SIM queue\n");
2566                 }
2567         }
2568
2569         /*
2570          * Point to the SCSI CDB, which is dependent on the CAM_CDB_POINTER
2571          * flag, and use it in a few places in the rest of this function for
2572          * convenience. Use the macro if available.
2573          */
2574 #if __FreeBSD_version >= 1100103
2575         scsi_cdb = scsiio_cdb_ptr(csio);
2576 #else
2577         if (csio->ccb_h.flags & CAM_CDB_POINTER)
2578                 scsi_cdb = csio->cdb_io.cdb_ptr;
2579         else
2580                 scsi_cdb = csio->cdb_io.cdb_bytes;
2581 #endif
2582
2583         /*
2584          * If this is a Start Stop Unit command and it was issued by the driver
2585          * during shutdown, decrement the refcount to account for all of the
2586          * commands that were sent.  All SSU commands should be completed before
2587          * shutdown completes, meaning SSU_refcount will be 0 after SSU_started
2588          * is TRUE.
2589          */
2590         if (sc->SSU_started && (scsi_cdb[0] == START_STOP_UNIT)) {
2591                 mpr_dprint(sc, MPR_INFO, "Decrementing SSU count.\n");
2592                 sc->SSU_refcount--;
2593         }
2594
2595         /* Take the fast path to completion */
2596         if (cm->cm_reply == NULL) {
2597                 if (mprsas_get_ccbstatus(ccb) == CAM_REQ_INPROG) {
2598                         if ((sc->mpr_flags & MPR_FLAGS_DIAGRESET) != 0)
2599                                 mprsas_set_ccbstatus(ccb, CAM_SCSI_BUS_RESET);
2600                         else {
2601                                 mprsas_set_ccbstatus(ccb, CAM_REQ_CMP);
2602                                 csio->scsi_status = SCSI_STATUS_OK;
2603                         }
2604                         if (sassc->flags & MPRSAS_QUEUE_FROZEN) {
2605                                 ccb->ccb_h.status |= CAM_RELEASE_SIMQ;
2606                                 sassc->flags &= ~MPRSAS_QUEUE_FROZEN;
2607                                 mpr_dprint(sc, MPR_XINFO,
2608                                     "Unfreezing SIM queue\n");
2609                         }
2610                 }
2611
2612                 /*
2613                  * There are two scenarios where the status won't be
2614                  * CAM_REQ_CMP.  The first is if MPR_CM_FLAGS_ERROR_MASK is
2615                  * set, the second is in the MPR_FLAGS_DIAGRESET above.
2616                  */
2617                 if (mprsas_get_ccbstatus(ccb) != CAM_REQ_CMP) {
2618                         /*
2619                          * Freeze the dev queue so that commands are
2620                          * executed in the correct order after error
2621                          * recovery.
2622                          */
2623                         ccb->ccb_h.status |= CAM_DEV_QFRZN;
2624                         xpt_freeze_devq(ccb->ccb_h.path, /*count*/ 1);
2625                 }
2626                 mpr_free_command(sc, cm);
2627                 xpt_done(ccb);
2628                 return;
2629         }
2630
2631         target = &sassc->targets[target_id];
2632         if (scsi_cdb[0] == UNMAP &&
2633             target->is_nvme &&
2634             (csio->ccb_h.flags & CAM_DATA_MASK) == CAM_DATA_VADDR) {
2635                 rep->SCSIStatus = mprsas_complete_nvme_unmap(sc, cm);
2636                 csio->scsi_status = rep->SCSIStatus;
2637         }
2638
2639         mprsas_log_command(cm, MPR_XINFO,
2640             "ioc %x scsi %x state %x xfer %u\n",
2641             le16toh(rep->IOCStatus), rep->SCSIStatus, rep->SCSIState,
2642             le32toh(rep->TransferCount));
2643
2644         switch (le16toh(rep->IOCStatus) & MPI2_IOCSTATUS_MASK) {
2645         case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
2646                 csio->resid = cm->cm_length - le32toh(rep->TransferCount);
2647                 /* FALLTHROUGH */
2648         case MPI2_IOCSTATUS_SUCCESS:
2649         case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
2650                 if ((le16toh(rep->IOCStatus) & MPI2_IOCSTATUS_MASK) ==
2651                     MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR)
2652                         mprsas_log_command(cm, MPR_XINFO, "recovered error\n");
2653
2654                 /* Completion failed at the transport level. */
2655                 if (rep->SCSIState & (MPI2_SCSI_STATE_NO_SCSI_STATUS |
2656                     MPI2_SCSI_STATE_TERMINATED)) {
2657                         mprsas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
2658                         break;
2659                 }
2660
2661                 /* In a modern packetized environment, an autosense failure
2662                  * implies that there's not much else that can be done to
2663                  * recover the command.
2664                  */
2665                 if (rep->SCSIState & MPI2_SCSI_STATE_AUTOSENSE_FAILED) {
2666                         mprsas_set_ccbstatus(ccb, CAM_AUTOSENSE_FAIL);
2667                         break;
2668                 }
2669
2670                 /*
2671                  * CAM doesn't care about SAS Response Info data, but if this is
2672                  * the state check if TLR should be done.  If not, clear the
2673                  * TLR_bits for the target.
2674                  */
2675                 if ((rep->SCSIState & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) &&
2676                     ((le32toh(rep->ResponseInfo) & MPI2_SCSI_RI_MASK_REASONCODE)
2677                     == MPR_SCSI_RI_INVALID_FRAME)) {
2678                         sc->mapping_table[target_id].TLR_bits =
2679                             (u8)MPI2_SCSIIO_CONTROL_NO_TLR;
2680                 }
2681
2682                 /*
2683                  * Intentionally override the normal SCSI status reporting
2684                  * for these two cases.  These are likely to happen in a
2685                  * multi-initiator environment, and we want to make sure that
2686                  * CAM retries these commands rather than fail them.
2687                  */
2688                 if ((rep->SCSIStatus == MPI2_SCSI_STATUS_COMMAND_TERMINATED) ||
2689                     (rep->SCSIStatus == MPI2_SCSI_STATUS_TASK_ABORTED)) {
2690                         mprsas_set_ccbstatus(ccb, CAM_REQ_ABORTED);
2691                         break;
2692                 }
2693
2694                 /* Handle normal status and sense */
2695                 csio->scsi_status = rep->SCSIStatus;
2696                 if (rep->SCSIStatus == MPI2_SCSI_STATUS_GOOD)
2697                         mprsas_set_ccbstatus(ccb, CAM_REQ_CMP);
2698                 else
2699                         mprsas_set_ccbstatus(ccb, CAM_SCSI_STATUS_ERROR);
2700
2701                 if (rep->SCSIState & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
2702                         int sense_len, returned_sense_len;
2703
2704                         returned_sense_len = min(le32toh(rep->SenseCount),
2705                             sizeof(struct scsi_sense_data));
2706                         if (returned_sense_len < csio->sense_len)
2707                                 csio->sense_resid = csio->sense_len -
2708                                     returned_sense_len;
2709                         else
2710                                 csio->sense_resid = 0;
2711
2712                         sense_len = min(returned_sense_len,
2713                             csio->sense_len - csio->sense_resid);
2714                         bzero(&csio->sense_data, sizeof(csio->sense_data));
2715                         bcopy(cm->cm_sense, &csio->sense_data, sense_len);
2716                         ccb->ccb_h.status |= CAM_AUTOSNS_VALID;
2717                 }
2718
2719                 /*
2720                  * Check if this is an INQUIRY command.  If it's a VPD inquiry,
2721                  * and it's page code 0 (Supported Page List), and there is
2722                  * inquiry data, and this is for a sequential access device, and
2723                  * the device is an SSP target, and TLR is supported by the
2724                  * controller, turn the TLR_bits value ON if page 0x90 is
2725                  * supported.
2726                  */
2727                 if ((scsi_cdb[0] == INQUIRY) &&
2728                     (scsi_cdb[1] & SI_EVPD) &&
2729                     (scsi_cdb[2] == SVPD_SUPPORTED_PAGE_LIST) &&
2730                     ((csio->ccb_h.flags & CAM_DATA_MASK) == CAM_DATA_VADDR) &&
2731                     (csio->data_ptr != NULL) &&
2732                     ((csio->data_ptr[0] & 0x1f) == T_SEQUENTIAL) &&
2733                     (sc->control_TLR) &&
2734                     (sc->mapping_table[target_id].device_info &
2735                     MPI2_SAS_DEVICE_INFO_SSP_TARGET)) {
2736                         vpd_list = (struct scsi_vpd_supported_page_list *)
2737                             csio->data_ptr;
2738                         TLR_bits = &sc->mapping_table[target_id].TLR_bits;
2739                         *TLR_bits = (u8)MPI2_SCSIIO_CONTROL_NO_TLR;
2740                         TLR_on = (u8)MPI2_SCSIIO_CONTROL_TLR_ON;
2741                         alloc_len = ((u16)scsi_cdb[3] << 8) + scsi_cdb[4];
2742                         alloc_len -= csio->resid;
2743                         for (i = 0; i < MIN(vpd_list->length, alloc_len); i++) {
2744                                 if (vpd_list->list[i] == 0x90) {
2745                                         *TLR_bits = TLR_on;
2746                                         break;
2747                                 }
2748                         }
2749                 }
2750
2751                 /*
2752                  * If this is a SATA direct-access end device, mark it so that
2753                  * a SCSI StartStopUnit command will be sent to it when the
2754                  * driver is being shutdown.
2755                  */
2756                 if ((scsi_cdb[0] == INQUIRY) &&
2757                     (csio->data_ptr != NULL) &&
2758                     ((csio->data_ptr[0] & 0x1f) == T_DIRECT) &&
2759                     (sc->mapping_table[target_id].device_info &
2760                     MPI2_SAS_DEVICE_INFO_SATA_DEVICE) &&
2761                     ((sc->mapping_table[target_id].device_info &
2762                     MPI2_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) ==
2763                     MPI2_SAS_DEVICE_INFO_END_DEVICE)) {
2764                         target = &sassc->targets[target_id];
2765                         target->supports_SSU = TRUE;
2766                         mpr_dprint(sc, MPR_XINFO, "Target %d supports SSU\n",
2767                             target_id);
2768                 }
2769                 break;
2770         case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE:
2771         case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
2772                 /*
2773                  * If devinfo is 0 this will be a volume.  In that case don't
2774                  * tell CAM that the volume is not there.  We want volumes to
2775                  * be enumerated until they are deleted/removed, not just
2776                  * failed.
2777                  */
2778                 if (cm->cm_targ->devinfo == 0)
2779                         mprsas_set_ccbstatus(ccb, CAM_REQ_CMP);
2780                 else
2781                         mprsas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
2782                 break;
2783         case MPI2_IOCSTATUS_INVALID_SGL:
2784                 mpr_print_scsiio_cmd(sc, cm);
2785                 mprsas_set_ccbstatus(ccb, CAM_UNREC_HBA_ERROR);
2786                 break;
2787         case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
2788                 /*
2789                  * This is one of the responses that comes back when an I/O
2790                  * has been aborted.  If it is because of a timeout that we
2791                  * initiated, just set the status to CAM_CMD_TIMEOUT.
2792                  * Otherwise set it to CAM_REQ_ABORTED.  The effect on the
2793                  * command is the same (it gets retried, subject to the
2794                  * retry counter), the only difference is what gets printed
2795                  * on the console.
2796                  */
2797                 if (cm->cm_state == MPR_CM_STATE_TIMEDOUT)
2798                         mprsas_set_ccbstatus(ccb, CAM_CMD_TIMEOUT);
2799                 else
2800                         mprsas_set_ccbstatus(ccb, CAM_REQ_ABORTED);
2801                 break;
2802         case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
2803                 /* resid is ignored for this condition */
2804                 csio->resid = 0;
2805                 mprsas_set_ccbstatus(ccb, CAM_DATA_RUN_ERR);
2806                 break;
2807         case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
2808         case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
2809                 /*
2810                  * These can sometimes be transient transport-related
2811                  * errors, and sometimes persistent drive-related errors.
2812                  * We used to retry these without decrementing the retry
2813                  * count by returning CAM_REQUEUE_REQ.  Unfortunately, if
2814                  * we hit a persistent drive problem that returns one of
2815                  * these error codes, we would retry indefinitely.  So,
2816                  * return CAM_REQ_CMP_ERROR so that we decrement the retry
2817                  * count and avoid infinite retries.  We're taking the
2818                  * potential risk of flagging false failures in the event
2819                  * of a topology-related error (e.g. a SAS expander problem
2820                  * causes a command addressed to a drive to fail), but
2821                  * avoiding getting into an infinite retry loop.
2822                  */
2823                 mprsas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
2824                 mpr_dprint(sc, MPR_INFO,
2825                     "Controller reported %s tgt %u SMID %u loginfo %x\n",
2826                     mpr_describe_table(mpr_iocstatus_string,
2827                     le16toh(rep->IOCStatus) & MPI2_IOCSTATUS_MASK),
2828                     target_id, cm->cm_desc.Default.SMID,
2829                     le32toh(rep->IOCLogInfo));
2830                 mpr_dprint(sc, MPR_XINFO,
2831                     "SCSIStatus %x SCSIState %x xfercount %u\n",
2832                     rep->SCSIStatus, rep->SCSIState,
2833                     le32toh(rep->TransferCount));
2834                 break;
2835         case MPI2_IOCSTATUS_INVALID_FUNCTION:
2836         case MPI2_IOCSTATUS_INTERNAL_ERROR:
2837         case MPI2_IOCSTATUS_INVALID_VPID:
2838         case MPI2_IOCSTATUS_INVALID_FIELD:
2839         case MPI2_IOCSTATUS_INVALID_STATE:
2840         case MPI2_IOCSTATUS_OP_STATE_NOT_SUPPORTED:
2841         case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
2842         case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
2843         case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
2844         case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
2845         default:
2846                 mprsas_log_command(cm, MPR_XINFO,
2847                     "completed ioc %x loginfo %x scsi %x state %x xfer %u\n",
2848                     le16toh(rep->IOCStatus), le32toh(rep->IOCLogInfo),
2849                     rep->SCSIStatus, rep->SCSIState,
2850                     le32toh(rep->TransferCount));
2851                 csio->resid = cm->cm_length;
2852
2853                 if (scsi_cdb[0] == UNMAP &&
2854                     target->is_nvme &&
2855                     (csio->ccb_h.flags & CAM_DATA_MASK) == CAM_DATA_VADDR)
2856                         mprsas_set_ccbstatus(ccb, CAM_REQ_CMP);
2857                 else
2858                         mprsas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
2859
2860                 break;
2861         }
2862
2863         mpr_sc_failed_io_info(sc, csio, rep, cm->cm_targ);
2864
2865         if (sassc->flags & MPRSAS_QUEUE_FROZEN) {
2866                 ccb->ccb_h.status |= CAM_RELEASE_SIMQ;
2867                 sassc->flags &= ~MPRSAS_QUEUE_FROZEN;
2868                 mpr_dprint(sc, MPR_XINFO, "Command completed, unfreezing SIM "
2869                     "queue\n");
2870         }
2871
2872         if (mprsas_get_ccbstatus(ccb) != CAM_REQ_CMP) {
2873                 ccb->ccb_h.status |= CAM_DEV_QFRZN;
2874                 xpt_freeze_devq(ccb->ccb_h.path, /*count*/ 1);
2875         }
2876
2877         mpr_free_command(sc, cm);
2878         xpt_done(ccb);
2879 }
2880
2881 #if __FreeBSD_version >= 900026
2882 static void
2883 mprsas_smpio_complete(struct mpr_softc *sc, struct mpr_command *cm)
2884 {
2885         MPI2_SMP_PASSTHROUGH_REPLY *rpl;
2886         MPI2_SMP_PASSTHROUGH_REQUEST *req;
2887         uint64_t sasaddr;
2888         union ccb *ccb;
2889
2890         ccb = cm->cm_complete_data;
2891
2892         /*
2893          * Currently there should be no way we can hit this case.  It only
2894          * happens when we have a failure to allocate chain frames, and SMP
2895          * commands require two S/G elements only.  That should be handled
2896          * in the standard request size.
2897          */
2898         if ((cm->cm_flags & MPR_CM_FLAGS_ERROR_MASK) != 0) {
2899                 mpr_dprint(sc, MPR_ERROR, "%s: cm_flags = %#x on SMP "
2900                     "request!\n", __func__, cm->cm_flags);
2901                 mprsas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
2902                 goto bailout;
2903         }
2904
2905         rpl = (MPI2_SMP_PASSTHROUGH_REPLY *)cm->cm_reply;
2906         if (rpl == NULL) {
2907                 mpr_dprint(sc, MPR_ERROR, "%s: NULL cm_reply!\n", __func__);
2908                 mprsas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
2909                 goto bailout;
2910         }
2911
2912         req = (MPI2_SMP_PASSTHROUGH_REQUEST *)cm->cm_req;
2913         sasaddr = le32toh(req->SASAddress.Low);
2914         sasaddr |= ((uint64_t)(le32toh(req->SASAddress.High))) << 32;
2915
2916         if ((le16toh(rpl->IOCStatus) & MPI2_IOCSTATUS_MASK) !=
2917             MPI2_IOCSTATUS_SUCCESS ||
2918             rpl->SASStatus != MPI2_SASSTATUS_SUCCESS) {
2919                 mpr_dprint(sc, MPR_XINFO, "%s: IOCStatus %04x SASStatus %02x\n",
2920                     __func__, le16toh(rpl->IOCStatus), rpl->SASStatus);
2921                 mprsas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
2922                 goto bailout;
2923         }
2924
2925         mpr_dprint(sc, MPR_XINFO, "%s: SMP request to SAS address %#jx "
2926             "completed successfully\n", __func__, (uintmax_t)sasaddr);
2927
2928         if (ccb->smpio.smp_response[2] == SMP_FR_ACCEPTED)
2929                 mprsas_set_ccbstatus(ccb, CAM_REQ_CMP);
2930         else
2931                 mprsas_set_ccbstatus(ccb, CAM_SMP_STATUS_ERROR);
2932
2933 bailout:
2934         /*
2935          * We sync in both directions because we had DMAs in the S/G list
2936          * in both directions.
2937          */
2938         bus_dmamap_sync(sc->buffer_dmat, cm->cm_dmamap,
2939                         BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
2940         bus_dmamap_unload(sc->buffer_dmat, cm->cm_dmamap);
2941         mpr_free_command(sc, cm);
2942         xpt_done(ccb);
2943 }
2944
2945 static void
2946 mprsas_send_smpcmd(struct mprsas_softc *sassc, union ccb *ccb, uint64_t sasaddr)
2947 {
2948         struct mpr_command *cm;
2949         uint8_t *request, *response;
2950         MPI2_SMP_PASSTHROUGH_REQUEST *req;
2951         struct mpr_softc *sc;
2952         struct sglist *sg;
2953         int error;
2954
2955         sc = sassc->sc;
2956         sg = NULL;
2957         error = 0;
2958
2959 #if (__FreeBSD_version >= 1000028) || \
2960     ((__FreeBSD_version >= 902001) && (__FreeBSD_version < 1000000))
2961         switch (ccb->ccb_h.flags & CAM_DATA_MASK) {
2962         case CAM_DATA_PADDR:
2963         case CAM_DATA_SG_PADDR:
2964                 /*
2965                  * XXX We don't yet support physical addresses here.
2966                  */
2967                 mpr_dprint(sc, MPR_ERROR, "%s: physical addresses not "
2968                     "supported\n", __func__);
2969                 mprsas_set_ccbstatus(ccb, CAM_REQ_INVALID);
2970                 xpt_done(ccb);
2971                 return;
2972         case CAM_DATA_SG:
2973                 /*
2974                  * The chip does not support more than one buffer for the
2975                  * request or response.
2976                  */
2977                 if ((ccb->smpio.smp_request_sglist_cnt > 1)
2978                     || (ccb->smpio.smp_response_sglist_cnt > 1)) {
2979                         mpr_dprint(sc, MPR_ERROR, "%s: multiple request or "
2980                             "response buffer segments not supported for SMP\n",
2981                             __func__);
2982                         mprsas_set_ccbstatus(ccb, CAM_REQ_INVALID);
2983                         xpt_done(ccb);
2984                         return;
2985                 }
2986
2987                 /*
2988                  * The CAM_SCATTER_VALID flag was originally implemented
2989                  * for the XPT_SCSI_IO CCB, which only has one data pointer.
2990                  * We have two.  So, just take that flag to mean that we
2991                  * might have S/G lists, and look at the S/G segment count
2992                  * to figure out whether that is the case for each individual
2993                  * buffer.
2994                  */
2995                 if (ccb->smpio.smp_request_sglist_cnt != 0) {
2996                         bus_dma_segment_t *req_sg;
2997
2998                         req_sg = (bus_dma_segment_t *)ccb->smpio.smp_request;
2999                         request = (uint8_t *)(uintptr_t)req_sg[0].ds_addr;
3000                 } else
3001                         request = ccb->smpio.smp_request;
3002
3003                 if (ccb->smpio.smp_response_sglist_cnt != 0) {
3004                         bus_dma_segment_t *rsp_sg;
3005
3006                         rsp_sg = (bus_dma_segment_t *)ccb->smpio.smp_response;
3007                         response = (uint8_t *)(uintptr_t)rsp_sg[0].ds_addr;
3008                 } else
3009                         response = ccb->smpio.smp_response;
3010                 break;
3011         case CAM_DATA_VADDR:
3012                 request = ccb->smpio.smp_request;
3013                 response = ccb->smpio.smp_response;
3014                 break;
3015         default:
3016                 mprsas_set_ccbstatus(ccb, CAM_REQ_INVALID);
3017                 xpt_done(ccb);
3018                 return;
3019         }
3020 #else /* __FreeBSD_version < 1000028 */
3021         /*
3022          * XXX We don't yet support physical addresses here.
3023          */
3024         if (ccb->ccb_h.flags & (CAM_DATA_PHYS|CAM_SG_LIST_PHYS)) {
3025                 mpr_dprint(sc, MPR_ERROR, "%s: physical addresses not "
3026                     "supported\n", __func__);
3027                 mprsas_set_ccbstatus(ccb, CAM_REQ_INVALID);
3028                 xpt_done(ccb);
3029                 return;
3030         }
3031
3032         /*
3033          * If the user wants to send an S/G list, check to make sure they
3034          * have single buffers.
3035          */
3036         if (ccb->ccb_h.flags & CAM_SCATTER_VALID) {
3037                 /*
3038                  * The chip does not support more than one buffer for the
3039                  * request or response.
3040                  */
3041                 if ((ccb->smpio.smp_request_sglist_cnt > 1)
3042                   || (ccb->smpio.smp_response_sglist_cnt > 1)) {
3043                         mpr_dprint(sc, MPR_ERROR, "%s: multiple request or "
3044                             "response buffer segments not supported for SMP\n",
3045                             __func__);
3046                         mprsas_set_ccbstatus(ccb, CAM_REQ_INVALID);
3047                         xpt_done(ccb);
3048                         return;
3049                 }
3050
3051                 /*
3052                  * The CAM_SCATTER_VALID flag was originally implemented
3053                  * for the XPT_SCSI_IO CCB, which only has one data pointer.
3054                  * We have two.  So, just take that flag to mean that we
3055                  * might have S/G lists, and look at the S/G segment count
3056                  * to figure out whether that is the case for each individual
3057                  * buffer.
3058                  */
3059                 if (ccb->smpio.smp_request_sglist_cnt != 0) {
3060                         bus_dma_segment_t *req_sg;
3061
3062                         req_sg = (bus_dma_segment_t *)ccb->smpio.smp_request;
3063                         request = (uint8_t *)(uintptr_t)req_sg[0].ds_addr;
3064                 } else
3065                         request = ccb->smpio.smp_request;
3066
3067                 if (ccb->smpio.smp_response_sglist_cnt != 0) {
3068                         bus_dma_segment_t *rsp_sg;
3069
3070                         rsp_sg = (bus_dma_segment_t *)ccb->smpio.smp_response;
3071                         response = (uint8_t *)(uintptr_t)rsp_sg[0].ds_addr;
3072                 } else
3073                         response = ccb->smpio.smp_response;
3074         } else {
3075                 request = ccb->smpio.smp_request;
3076                 response = ccb->smpio.smp_response;
3077         }
3078 #endif /* __FreeBSD_version < 1000028 */
3079
3080         cm = mpr_alloc_command(sc);
3081         if (cm == NULL) {
3082                 mpr_dprint(sc, MPR_ERROR, "%s: cannot allocate command\n",
3083                     __func__);
3084                 mprsas_set_ccbstatus(ccb, CAM_RESRC_UNAVAIL);
3085                 xpt_done(ccb);
3086                 return;
3087         }
3088
3089         req = (MPI2_SMP_PASSTHROUGH_REQUEST *)cm->cm_req;
3090         bzero(req, sizeof(*req));
3091         req->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
3092
3093         /* Allow the chip to use any route to this SAS address. */
3094         req->PhysicalPort = 0xff;
3095
3096         req->RequestDataLength = htole16(ccb->smpio.smp_request_len);
3097         req->SGLFlags =
3098             MPI2_SGLFLAGS_SYSTEM_ADDRESS_SPACE | MPI2_SGLFLAGS_SGL_TYPE_MPI;
3099
3100         mpr_dprint(sc, MPR_XINFO, "%s: sending SMP request to SAS address "
3101             "%#jx\n", __func__, (uintmax_t)sasaddr);
3102
3103         mpr_init_sge(cm, req, &req->SGL);
3104
3105         /*
3106          * Set up a uio to pass into mpr_map_command().  This allows us to
3107          * do one map command, and one busdma call in there.
3108          */
3109         cm->cm_uio.uio_iov = cm->cm_iovec;
3110         cm->cm_uio.uio_iovcnt = 2;
3111         cm->cm_uio.uio_segflg = UIO_SYSSPACE;
3112
3113         /*
3114          * The read/write flag isn't used by busdma, but set it just in
3115          * case.  This isn't exactly accurate, either, since we're going in
3116          * both directions.
3117          */
3118         cm->cm_uio.uio_rw = UIO_WRITE;
3119
3120         cm->cm_iovec[0].iov_base = request;
3121         cm->cm_iovec[0].iov_len = le16toh(req->RequestDataLength);
3122         cm->cm_iovec[1].iov_base = response;
3123         cm->cm_iovec[1].iov_len = ccb->smpio.smp_response_len;
3124
3125         cm->cm_uio.uio_resid = cm->cm_iovec[0].iov_len +
3126                                cm->cm_iovec[1].iov_len;
3127
3128         /*
3129          * Trigger a warning message in mpr_data_cb() for the user if we
3130          * wind up exceeding two S/G segments.  The chip expects one
3131          * segment for the request and another for the response.
3132          */
3133         cm->cm_max_segs = 2;
3134
3135         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
3136         cm->cm_complete = mprsas_smpio_complete;
3137         cm->cm_complete_data = ccb;
3138
3139         /*
3140          * Tell the mapping code that we're using a uio, and that this is
3141          * an SMP passthrough request.  There is a little special-case
3142          * logic there (in mpr_data_cb()) to handle the bidirectional
3143          * transfer.
3144          */
3145         cm->cm_flags |= MPR_CM_FLAGS_USE_UIO | MPR_CM_FLAGS_SMP_PASS |
3146                         MPR_CM_FLAGS_DATAIN | MPR_CM_FLAGS_DATAOUT;
3147
3148         /* The chip data format is little endian. */
3149         req->SASAddress.High = htole32(sasaddr >> 32);
3150         req->SASAddress.Low = htole32(sasaddr);
3151
3152         /*
3153          * XXX Note that we don't have a timeout/abort mechanism here.
3154          * From the manual, it looks like task management requests only
3155          * work for SCSI IO and SATA passthrough requests.  We may need to
3156          * have a mechanism to retry requests in the event of a chip reset
3157          * at least.  Hopefully the chip will insure that any errors short
3158          * of that are relayed back to the driver.
3159          */
3160         error = mpr_map_command(sc, cm);
3161         if ((error != 0) && (error != EINPROGRESS)) {
3162                 mpr_dprint(sc, MPR_ERROR, "%s: error %d returned from "
3163                     "mpr_map_command()\n", __func__, error);
3164                 goto bailout_error;
3165         }
3166
3167         return;
3168
3169 bailout_error:
3170         mpr_free_command(sc, cm);
3171         mprsas_set_ccbstatus(ccb, CAM_RESRC_UNAVAIL);
3172         xpt_done(ccb);
3173         return;
3174 }
3175
3176 static void
3177 mprsas_action_smpio(struct mprsas_softc *sassc, union ccb *ccb)
3178 {
3179         struct mpr_softc *sc;
3180         struct mprsas_target *targ;
3181         uint64_t sasaddr = 0;
3182
3183         sc = sassc->sc;
3184
3185         /*
3186          * Make sure the target exists.
3187          */
3188         KASSERT(ccb->ccb_h.target_id < sassc->maxtargets,
3189             ("Target %d out of bounds in XPT_SMP_IO\n", ccb->ccb_h.target_id));
3190         targ = &sassc->targets[ccb->ccb_h.target_id];
3191         if (targ->handle == 0x0) {
3192                 mpr_dprint(sc, MPR_ERROR, "%s: target %d does not exist!\n",
3193                     __func__, ccb->ccb_h.target_id);
3194                 mprsas_set_ccbstatus(ccb, CAM_SEL_TIMEOUT);
3195                 xpt_done(ccb);
3196                 return;
3197         }
3198
3199         /*
3200          * If this device has an embedded SMP target, we'll talk to it
3201          * directly.
3202          * figure out what the expander's address is.
3203          */
3204         if ((targ->devinfo & MPI2_SAS_DEVICE_INFO_SMP_TARGET) != 0)
3205                 sasaddr = targ->sasaddr;
3206
3207         /*
3208          * If we don't have a SAS address for the expander yet, try
3209          * grabbing it from the page 0x83 information cached in the
3210          * transport layer for this target.  LSI expanders report the
3211          * expander SAS address as the port-associated SAS address in
3212          * Inquiry VPD page 0x83.  Maxim expanders don't report it in page
3213          * 0x83.
3214          *
3215          * XXX KDM disable this for now, but leave it commented out so that
3216          * it is obvious that this is another possible way to get the SAS
3217          * address.
3218          *
3219          * The parent handle method below is a little more reliable, and
3220          * the other benefit is that it works for devices other than SES
3221          * devices.  So you can send a SMP request to a da(4) device and it
3222          * will get routed to the expander that device is attached to.
3223          * (Assuming the da(4) device doesn't contain an SMP target...)
3224          */
3225 #if 0
3226         if (sasaddr == 0)
3227                 sasaddr = xpt_path_sas_addr(ccb->ccb_h.path);
3228 #endif
3229
3230         /*
3231          * If we still don't have a SAS address for the expander, look for
3232          * the parent device of this device, which is probably the expander.
3233          */
3234         if (sasaddr == 0) {
3235 #ifdef OLD_MPR_PROBE
3236                 struct mprsas_target *parent_target;
3237 #endif
3238
3239                 if (targ->parent_handle == 0x0) {
3240                         mpr_dprint(sc, MPR_ERROR, "%s: handle %d does not have "
3241                             "a valid parent handle!\n", __func__, targ->handle);
3242                         mprsas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
3243                         goto bailout;
3244                 }
3245 #ifdef OLD_MPR_PROBE
3246                 parent_target = mprsas_find_target_by_handle(sassc, 0,
3247                     targ->parent_handle);
3248
3249                 if (parent_target == NULL) {
3250                         mpr_dprint(sc, MPR_ERROR, "%s: handle %d does not have "
3251                             "a valid parent target!\n", __func__, targ->handle);
3252                         mprsas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
3253                         goto bailout;
3254                 }
3255
3256                 if ((parent_target->devinfo &
3257                      MPI2_SAS_DEVICE_INFO_SMP_TARGET) == 0) {
3258                         mpr_dprint(sc, MPR_ERROR, "%s: handle %d parent %d "
3259                             "does not have an SMP target!\n", __func__,
3260                             targ->handle, parent_target->handle);
3261                         mprsas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
3262                         goto bailout;
3263                 }
3264
3265                 sasaddr = parent_target->sasaddr;
3266 #else /* OLD_MPR_PROBE */
3267                 if ((targ->parent_devinfo &
3268                      MPI2_SAS_DEVICE_INFO_SMP_TARGET) == 0) {
3269                         mpr_dprint(sc, MPR_ERROR, "%s: handle %d parent %d "
3270                             "does not have an SMP target!\n", __func__,
3271                             targ->handle, targ->parent_handle);
3272                         mprsas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
3273                         goto bailout;
3274
3275                 }
3276                 if (targ->parent_sasaddr == 0x0) {
3277                         mpr_dprint(sc, MPR_ERROR, "%s: handle %d parent handle "
3278                             "%d does not have a valid SAS address!\n", __func__,
3279                             targ->handle, targ->parent_handle);
3280                         mprsas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
3281                         goto bailout;
3282                 }
3283
3284                 sasaddr = targ->parent_sasaddr;
3285 #endif /* OLD_MPR_PROBE */
3286
3287         }
3288
3289         if (sasaddr == 0) {
3290                 mpr_dprint(sc, MPR_INFO, "%s: unable to find SAS address for "
3291                     "handle %d\n", __func__, targ->handle);
3292                 mprsas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
3293                 goto bailout;
3294         }
3295         mprsas_send_smpcmd(sassc, ccb, sasaddr);
3296
3297         return;
3298
3299 bailout:
3300         xpt_done(ccb);
3301
3302 }
3303 #endif //__FreeBSD_version >= 900026
3304
3305 static void
3306 mprsas_action_resetdev(struct mprsas_softc *sassc, union ccb *ccb)
3307 {
3308         MPI2_SCSI_TASK_MANAGE_REQUEST *req;
3309         struct mpr_softc *sc;
3310         struct mpr_command *tm;
3311         struct mprsas_target *targ;
3312
3313         MPR_FUNCTRACE(sassc->sc);
3314         mtx_assert(&sassc->sc->mpr_mtx, MA_OWNED);
3315
3316         KASSERT(ccb->ccb_h.target_id < sassc->maxtargets, ("Target %d out of "
3317             "bounds in XPT_RESET_DEV\n", ccb->ccb_h.target_id));
3318         sc = sassc->sc;
3319         tm = mpr_alloc_command(sc);
3320         if (tm == NULL) {
3321                 mpr_dprint(sc, MPR_ERROR, "command alloc failure in "
3322                     "mprsas_action_resetdev\n");
3323                 mprsas_set_ccbstatus(ccb, CAM_RESRC_UNAVAIL);
3324                 xpt_done(ccb);
3325                 return;
3326         }
3327
3328         targ = &sassc->targets[ccb->ccb_h.target_id];
3329         req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
3330         req->DevHandle = htole16(targ->handle);
3331         req->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
3332         req->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
3333
3334         /* SAS Hard Link Reset / SATA Link Reset */
3335         req->MsgFlags = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
3336
3337         tm->cm_data = NULL;
3338         tm->cm_desc.HighPriority.RequestFlags =
3339             MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY;
3340         tm->cm_complete = mprsas_resetdev_complete;
3341         tm->cm_complete_data = ccb;
3342
3343         mpr_dprint(sc, MPR_INFO, "%s: Sending reset for target ID %d\n",
3344             __func__, targ->tid);
3345         tm->cm_targ = targ;
3346         targ->flags |= MPRSAS_TARGET_INRESET;
3347
3348         mpr_map_command(sc, tm);
3349 }
3350
3351 static void
3352 mprsas_resetdev_complete(struct mpr_softc *sc, struct mpr_command *tm)
3353 {
3354         MPI2_SCSI_TASK_MANAGE_REPLY *resp;
3355         union ccb *ccb;
3356
3357         MPR_FUNCTRACE(sc);
3358         mtx_assert(&sc->mpr_mtx, MA_OWNED);
3359
3360         resp = (MPI2_SCSI_TASK_MANAGE_REPLY *)tm->cm_reply;
3361         ccb = tm->cm_complete_data;
3362
3363         /*
3364          * Currently there should be no way we can hit this case.  It only
3365          * happens when we have a failure to allocate chain frames, and
3366          * task management commands don't have S/G lists.
3367          */
3368         if ((tm->cm_flags & MPR_CM_FLAGS_ERROR_MASK) != 0) {
3369                 MPI2_SCSI_TASK_MANAGE_REQUEST *req;
3370
3371                 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
3372
3373                 mpr_dprint(sc, MPR_ERROR, "%s: cm_flags = %#x for reset of "
3374                     "handle %#04x! This should not happen!\n", __func__,
3375                     tm->cm_flags, req->DevHandle);
3376                 mprsas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
3377                 goto bailout;
3378         }
3379
3380         mpr_dprint(sc, MPR_XINFO, "%s: IOCStatus = 0x%x ResponseCode = 0x%x\n",
3381             __func__, le16toh(resp->IOCStatus), le32toh(resp->ResponseCode));
3382
3383         if (le32toh(resp->ResponseCode) == MPI2_SCSITASKMGMT_RSP_TM_COMPLETE) {
3384                 mprsas_set_ccbstatus(ccb, CAM_REQ_CMP);
3385                 mprsas_announce_reset(sc, AC_SENT_BDR, tm->cm_targ->tid,
3386                     CAM_LUN_WILDCARD);
3387         }
3388         else
3389                 mprsas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
3390
3391 bailout:
3392
3393         mprsas_free_tm(sc, tm);
3394         xpt_done(ccb);
3395 }
3396
3397 static void
3398 mprsas_poll(struct cam_sim *sim)
3399 {
3400         struct mprsas_softc *sassc;
3401
3402         sassc = cam_sim_softc(sim);
3403
3404         if (sassc->sc->mpr_debug & MPR_TRACE) {
3405                 /* frequent debug messages during a panic just slow
3406                  * everything down too much.
3407                  */
3408                 mpr_dprint(sassc->sc, MPR_XINFO, "%s clearing MPR_TRACE\n",
3409                     __func__);
3410                 sassc->sc->mpr_debug &= ~MPR_TRACE;
3411         }
3412
3413         mpr_intr_locked(sassc->sc);
3414 }
3415
3416 static void
3417 mprsas_async(void *callback_arg, uint32_t code, struct cam_path *path,
3418     void *arg)
3419 {
3420         struct mpr_softc *sc;
3421
3422         sc = (struct mpr_softc *)callback_arg;
3423
3424         switch (code) {
3425 #if (__FreeBSD_version >= 1000006) || \
3426     ((__FreeBSD_version >= 901503) && (__FreeBSD_version < 1000000))
3427         case AC_ADVINFO_CHANGED: {
3428                 struct mprsas_target *target;
3429                 struct mprsas_softc *sassc;
3430                 struct scsi_read_capacity_data_long rcap_buf;
3431                 struct ccb_dev_advinfo cdai;
3432                 struct mprsas_lun *lun;
3433                 lun_id_t lunid;
3434                 int found_lun;
3435                 uintptr_t buftype;
3436
3437                 buftype = (uintptr_t)arg;
3438
3439                 found_lun = 0;
3440                 sassc = sc->sassc;
3441
3442                 /*
3443                  * We're only interested in read capacity data changes.
3444                  */
3445                 if (buftype != CDAI_TYPE_RCAPLONG)
3446                         break;
3447
3448                 /*
3449                  * See the comment in mpr_attach_sas() for a detailed
3450                  * explanation.  In these versions of FreeBSD we register
3451                  * for all events and filter out the events that don't
3452                  * apply to us.
3453                  */
3454 #if (__FreeBSD_version < 1000703) || \
3455     ((__FreeBSD_version >= 1100000) && (__FreeBSD_version < 1100002))
3456                 if (xpt_path_path_id(path) != sassc->sim->path_id)
3457                         break;
3458 #endif
3459
3460                 /*
3461                  * We should have a handle for this, but check to make sure.
3462                  */
3463                 KASSERT(xpt_path_target_id(path) < sassc->maxtargets,
3464                     ("Target %d out of bounds in mprsas_async\n",
3465                     xpt_path_target_id(path)));
3466                 target = &sassc->targets[xpt_path_target_id(path)];
3467                 if (target->handle == 0)
3468                         break;
3469
3470                 lunid = xpt_path_lun_id(path);
3471
3472                 SLIST_FOREACH(lun, &target->luns, lun_link) {
3473                         if (lun->lun_id == lunid) {
3474                                 found_lun = 1;
3475                                 break;
3476                         }
3477                 }
3478
3479                 if (found_lun == 0) {
3480                         lun = malloc(sizeof(struct mprsas_lun), M_MPR,
3481                             M_NOWAIT | M_ZERO);
3482                         if (lun == NULL) {
3483                                 mpr_dprint(sc, MPR_ERROR, "Unable to alloc "
3484                                     "LUN for EEDP support.\n");
3485                                 break;
3486                         }
3487                         lun->lun_id = lunid;
3488                         SLIST_INSERT_HEAD(&target->luns, lun, lun_link);
3489                 }
3490
3491                 bzero(&rcap_buf, sizeof(rcap_buf));
3492                 xpt_setup_ccb(&cdai.ccb_h, path, CAM_PRIORITY_NORMAL);
3493                 cdai.ccb_h.func_code = XPT_DEV_ADVINFO;
3494                 cdai.ccb_h.flags = CAM_DIR_IN;
3495                 cdai.buftype = CDAI_TYPE_RCAPLONG;
3496 #if (__FreeBSD_version >= 1100061) || \
3497     ((__FreeBSD_version >= 1001510) && (__FreeBSD_version < 1100000))
3498                 cdai.flags = CDAI_FLAG_NONE;
3499 #else
3500                 cdai.flags = 0;
3501 #endif
3502                 cdai.bufsiz = sizeof(rcap_buf);
3503                 cdai.buf = (uint8_t *)&rcap_buf;
3504                 xpt_action((union ccb *)&cdai);
3505                 if ((cdai.ccb_h.status & CAM_DEV_QFRZN) != 0)
3506                         cam_release_devq(cdai.ccb_h.path, 0, 0, 0, FALSE);
3507
3508                 if ((mprsas_get_ccbstatus((union ccb *)&cdai) == CAM_REQ_CMP)
3509                     && (rcap_buf.prot & SRC16_PROT_EN)) {
3510                         lun->eedp_formatted = TRUE;
3511                         lun->eedp_block_size = scsi_4btoul(rcap_buf.length);
3512                 } else {
3513                         lun->eedp_formatted = FALSE;
3514                         lun->eedp_block_size = 0;
3515                 }
3516                 break;
3517         }
3518 #endif
3519         case AC_FOUND_DEVICE: {
3520                 struct ccb_getdev *cgd;
3521
3522                 /*
3523                  * See the comment in mpr_attach_sas() for a detailed
3524                  * explanation.  In these versions of FreeBSD we register
3525                  * for all events and filter out the events that don't
3526                  * apply to us.
3527                  */
3528 #if (__FreeBSD_version < 1000703) || \
3529     ((__FreeBSD_version >= 1100000) && (__FreeBSD_version < 1100002))
3530                 if (xpt_path_path_id(path) != sc->sassc->sim->path_id)
3531                         break;
3532 #endif
3533
3534                 cgd = arg;
3535 #if (__FreeBSD_version < 901503) || \
3536     ((__FreeBSD_version >= 1000000) && (__FreeBSD_version < 1000006))
3537                 mprsas_check_eedp(sc, path, cgd);
3538 #endif
3539                 break;
3540         }
3541         default:
3542                 break;
3543         }
3544 }
3545
3546 #if (__FreeBSD_version < 901503) || \
3547     ((__FreeBSD_version >= 1000000) && (__FreeBSD_version < 1000006))
3548 static void
3549 mprsas_check_eedp(struct mpr_softc *sc, struct cam_path *path,
3550     struct ccb_getdev *cgd)
3551 {
3552         struct mprsas_softc *sassc = sc->sassc;
3553         struct ccb_scsiio *csio;
3554         struct scsi_read_capacity_16 *scsi_cmd;
3555         struct scsi_read_capacity_eedp *rcap_buf;
3556         path_id_t pathid;
3557         target_id_t targetid;
3558         lun_id_t lunid;
3559         union ccb *ccb;
3560         struct cam_path *local_path;
3561         struct mprsas_target *target;
3562         struct mprsas_lun *lun;
3563         uint8_t found_lun;
3564         char path_str[64];
3565
3566         pathid = cam_sim_path(sassc->sim);
3567         targetid = xpt_path_target_id(path);
3568         lunid = xpt_path_lun_id(path);
3569
3570         KASSERT(targetid < sassc->maxtargets, ("Target %d out of bounds in "
3571             "mprsas_check_eedp\n", targetid));
3572         target = &sassc->targets[targetid];
3573         if (target->handle == 0x0)
3574                 return;
3575
3576         /*
3577          * Determine if the device is EEDP capable.
3578          *
3579          * If this flag is set in the inquiry data, the device supports
3580          * protection information, and must support the 16 byte read capacity
3581          * command, otherwise continue without sending read cap 16.
3582          */
3583         if ((cgd->inq_data.spc3_flags & SPC3_SID_PROTECT) == 0)
3584                 return;
3585
3586         /*
3587          * Issue a READ CAPACITY 16 command.  This info is used to determine if
3588          * the LUN is formatted for EEDP support.
3589          */
3590         ccb = xpt_alloc_ccb_nowait();
3591         if (ccb == NULL) {
3592                 mpr_dprint(sc, MPR_ERROR, "Unable to alloc CCB for EEDP "
3593                     "support.\n");
3594                 return;
3595         }
3596
3597         if (xpt_create_path(&local_path, xpt_periph, pathid, targetid, lunid) !=
3598             CAM_REQ_CMP) {
3599                 mpr_dprint(sc, MPR_ERROR, "Unable to create path for EEDP "
3600                     "support.\n");
3601                 xpt_free_ccb(ccb);
3602                 return;
3603         }
3604
3605         /*
3606          * If LUN is already in list, don't create a new one.
3607          */
3608         found_lun = FALSE;
3609         SLIST_FOREACH(lun, &target->luns, lun_link) {
3610                 if (lun->lun_id == lunid) {
3611                         found_lun = TRUE;
3612                         break;
3613                 }
3614         }
3615         if (!found_lun) {
3616                 lun = malloc(sizeof(struct mprsas_lun), M_MPR,
3617                     M_NOWAIT | M_ZERO);
3618                 if (lun == NULL) {
3619                         mpr_dprint(sc, MPR_ERROR, "Unable to alloc LUN for "
3620                             "EEDP support.\n");
3621                         xpt_free_path(local_path);
3622                         xpt_free_ccb(ccb);
3623                         return;
3624                 }
3625                 lun->lun_id = lunid;
3626                 SLIST_INSERT_HEAD(&target->luns, lun, lun_link);
3627         }
3628
3629         xpt_path_string(local_path, path_str, sizeof(path_str));
3630         mpr_dprint(sc, MPR_INFO, "Sending read cap: path %s handle %d\n",
3631             path_str, target->handle);
3632
3633         /*
3634          * Issue a READ CAPACITY 16 command for the LUN.  The
3635          * mprsas_read_cap_done function will load the read cap info into the
3636          * LUN struct.
3637          */
3638         rcap_buf = malloc(sizeof(struct scsi_read_capacity_eedp), M_MPR,
3639             M_NOWAIT | M_ZERO);
3640         if (rcap_buf == NULL) {
3641                 mpr_dprint(sc, MPR_ERROR, "Unable to alloc read capacity "
3642                     "buffer for EEDP support.\n");
3643                 xpt_free_path(ccb->ccb_h.path);
3644                 xpt_free_ccb(ccb);
3645                 return;
3646         }
3647         xpt_setup_ccb(&ccb->ccb_h, local_path, CAM_PRIORITY_XPT);
3648         csio = &ccb->csio;
3649         csio->ccb_h.func_code = XPT_SCSI_IO;
3650         csio->ccb_h.flags = CAM_DIR_IN;
3651         csio->ccb_h.retry_count = 4;
3652         csio->ccb_h.cbfcnp = mprsas_read_cap_done;
3653         csio->ccb_h.timeout = 60000;
3654         csio->data_ptr = (uint8_t *)rcap_buf;
3655         csio->dxfer_len = sizeof(struct scsi_read_capacity_eedp);
3656         csio->sense_len = MPR_SENSE_LEN;
3657         csio->cdb_len = sizeof(*scsi_cmd);
3658         csio->tag_action = MSG_SIMPLE_Q_TAG;
3659
3660         scsi_cmd = (struct scsi_read_capacity_16 *)&csio->cdb_io.cdb_bytes;
3661         bzero(scsi_cmd, sizeof(*scsi_cmd));
3662         scsi_cmd->opcode = 0x9E;
3663         scsi_cmd->service_action = SRC16_SERVICE_ACTION;
3664         ((uint8_t *)scsi_cmd)[13] = sizeof(struct scsi_read_capacity_eedp);
3665
3666         ccb->ccb_h.ppriv_ptr1 = sassc;
3667         xpt_action(ccb);
3668 }
3669
3670 static void
3671 mprsas_read_cap_done(struct cam_periph *periph, union ccb *done_ccb)
3672 {
3673         struct mprsas_softc *sassc;
3674         struct mprsas_target *target;
3675         struct mprsas_lun *lun;
3676         struct scsi_read_capacity_eedp *rcap_buf;
3677
3678         if (done_ccb == NULL)
3679                 return;
3680
3681         /* Driver need to release devq, it Scsi command is
3682          * generated by driver internally.
3683          * Currently there is a single place where driver
3684          * calls scsi command internally. In future if driver
3685          * calls more scsi command internally, it needs to release
3686          * devq internally, since those command will not go back to
3687          * cam_periph.
3688          */
3689         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) ) {
3690                 done_ccb->ccb_h.status &= ~CAM_DEV_QFRZN;
3691                 xpt_release_devq(done_ccb->ccb_h.path,
3692                                 /*count*/ 1, /*run_queue*/TRUE);
3693         }
3694
3695         rcap_buf = (struct scsi_read_capacity_eedp *)done_ccb->csio.data_ptr;
3696
3697         /*
3698          * Get the LUN ID for the path and look it up in the LUN list for the
3699          * target.
3700          */
3701         sassc = (struct mprsas_softc *)done_ccb->ccb_h.ppriv_ptr1;
3702         KASSERT(done_ccb->ccb_h.target_id < sassc->maxtargets, ("Target %d out "
3703             "of bounds in mprsas_read_cap_done\n", done_ccb->ccb_h.target_id));
3704         target = &sassc->targets[done_ccb->ccb_h.target_id];
3705         SLIST_FOREACH(lun, &target->luns, lun_link) {
3706                 if (lun->lun_id != done_ccb->ccb_h.target_lun)
3707                         continue;
3708
3709                 /*
3710                  * Got the LUN in the target's LUN list.  Fill it in with EEDP
3711                  * info. If the READ CAP 16 command had some SCSI error (common
3712                  * if command is not supported), mark the lun as not supporting
3713                  * EEDP and set the block size to 0.
3714                  */
3715                 if ((mprsas_get_ccbstatus(done_ccb) != CAM_REQ_CMP) ||
3716                     (done_ccb->csio.scsi_status != SCSI_STATUS_OK)) {
3717                         lun->eedp_formatted = FALSE;
3718                         lun->eedp_block_size = 0;
3719                         break;
3720                 }
3721
3722                 if (rcap_buf->protect & 0x01) {
3723                         mpr_dprint(sassc->sc, MPR_INFO, "LUN %d for target ID "
3724                             "%d is formatted for EEDP support.\n",
3725                             done_ccb->ccb_h.target_lun,
3726                             done_ccb->ccb_h.target_id);
3727                         lun->eedp_formatted = TRUE;
3728                         lun->eedp_block_size = scsi_4btoul(rcap_buf->length);
3729                 }
3730                 break;
3731         }
3732
3733         // Finished with this CCB and path.
3734         free(rcap_buf, M_MPR);
3735         xpt_free_path(done_ccb->ccb_h.path);
3736         xpt_free_ccb(done_ccb);
3737 }
3738 #endif /* (__FreeBSD_version < 901503) || \
3739           ((__FreeBSD_version >= 1000000) && (__FreeBSD_version < 1000006)) */
3740
3741 void
3742 mprsas_prepare_for_tm(struct mpr_softc *sc, struct mpr_command *tm,
3743     struct mprsas_target *target, lun_id_t lun_id)
3744 {
3745         union ccb *ccb;
3746         path_id_t path_id;
3747
3748         /*
3749          * Set the INRESET flag for this target so that no I/O will be sent to
3750          * the target until the reset has completed.  If an I/O request does
3751          * happen, the devq will be frozen.  The CCB holds the path which is
3752          * used to release the devq.  The devq is released and the CCB is freed
3753          * when the TM completes.
3754          */
3755         ccb = xpt_alloc_ccb_nowait();
3756         if (ccb) {
3757                 path_id = cam_sim_path(sc->sassc->sim);
3758                 if (xpt_create_path(&ccb->ccb_h.path, xpt_periph, path_id,
3759                     target->tid, lun_id) != CAM_REQ_CMP) {
3760                         xpt_free_ccb(ccb);
3761                 } else {
3762                         tm->cm_ccb = ccb;
3763                         tm->cm_targ = target;
3764                         target->flags |= MPRSAS_TARGET_INRESET;
3765                 }
3766         }
3767 }
3768
3769 int
3770 mprsas_startup(struct mpr_softc *sc)
3771 {
3772         /*
3773          * Send the port enable message and set the wait_for_port_enable flag.
3774          * This flag helps to keep the simq frozen until all discovery events
3775          * are processed.
3776          */
3777         sc->wait_for_port_enable = 1;
3778         mprsas_send_portenable(sc);
3779         return (0);
3780 }
3781
3782 static int
3783 mprsas_send_portenable(struct mpr_softc *sc)
3784 {
3785         MPI2_PORT_ENABLE_REQUEST *request;
3786         struct mpr_command *cm;
3787
3788         MPR_FUNCTRACE(sc);
3789
3790         if ((cm = mpr_alloc_command(sc)) == NULL)
3791                 return (EBUSY);
3792         request = (MPI2_PORT_ENABLE_REQUEST *)cm->cm_req;
3793         request->Function = MPI2_FUNCTION_PORT_ENABLE;
3794         request->MsgFlags = 0;
3795         request->VP_ID = 0;
3796         cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
3797         cm->cm_complete = mprsas_portenable_complete;
3798         cm->cm_data = NULL;
3799         cm->cm_sge = NULL;
3800
3801         mpr_map_command(sc, cm);
3802         mpr_dprint(sc, MPR_XINFO,
3803             "mpr_send_portenable finished cm %p req %p complete %p\n",
3804             cm, cm->cm_req, cm->cm_complete);
3805         return (0);
3806 }
3807
3808 static void
3809 mprsas_portenable_complete(struct mpr_softc *sc, struct mpr_command *cm)
3810 {
3811         MPI2_PORT_ENABLE_REPLY *reply;
3812         struct mprsas_softc *sassc;
3813
3814         MPR_FUNCTRACE(sc);
3815         sassc = sc->sassc;
3816
3817         /*
3818          * Currently there should be no way we can hit this case.  It only
3819          * happens when we have a failure to allocate chain frames, and
3820          * port enable commands don't have S/G lists.
3821          */
3822         if ((cm->cm_flags & MPR_CM_FLAGS_ERROR_MASK) != 0) {
3823                 mpr_dprint(sc, MPR_ERROR, "%s: cm_flags = %#x for port enable! "
3824                     "This should not happen!\n", __func__, cm->cm_flags);
3825         }
3826
3827         reply = (MPI2_PORT_ENABLE_REPLY *)cm->cm_reply;
3828         if (reply == NULL)
3829                 mpr_dprint(sc, MPR_FAULT, "Portenable NULL reply\n");
3830         else if (le16toh(reply->IOCStatus & MPI2_IOCSTATUS_MASK) !=
3831             MPI2_IOCSTATUS_SUCCESS)
3832                 mpr_dprint(sc, MPR_FAULT, "Portenable failed\n");
3833
3834         mpr_free_command(sc, cm);
3835         /*
3836          * Done waiting for port enable to complete.  Decrement the refcount.
3837          * If refcount is 0, discovery is complete and a rescan of the bus can
3838          * take place.
3839          */
3840         sc->wait_for_port_enable = 0;
3841         sc->port_enable_complete = 1;
3842         wakeup(&sc->port_enable_complete);
3843         mprsas_startup_decrement(sassc);
3844 }
3845
3846 int
3847 mprsas_check_id(struct mprsas_softc *sassc, int id)
3848 {
3849         struct mpr_softc *sc = sassc->sc;
3850         char *ids;
3851         char *name;
3852
3853         ids = &sc->exclude_ids[0];
3854         while((name = strsep(&ids, ",")) != NULL) {
3855                 if (name[0] == '\0')
3856                         continue;
3857                 if (strtol(name, NULL, 0) == (long)id)
3858                         return (1);
3859         }
3860
3861         return (0);
3862 }
3863
3864 void
3865 mprsas_realloc_targets(struct mpr_softc *sc, int maxtargets)
3866 {
3867         struct mprsas_softc *sassc;
3868         struct mprsas_lun *lun, *lun_tmp;
3869         struct mprsas_target *targ;
3870         int i;
3871
3872         sassc = sc->sassc;
3873         /*
3874          * The number of targets is based on IOC Facts, so free all of
3875          * the allocated LUNs for each target and then the target buffer
3876          * itself.
3877          */
3878         for (i=0; i< maxtargets; i++) {
3879                 targ = &sassc->targets[i];
3880                 SLIST_FOREACH_SAFE(lun, &targ->luns, lun_link, lun_tmp) {
3881                         free(lun, M_MPR);
3882                 }
3883         }
3884         free(sassc->targets, M_MPR);
3885
3886         sassc->targets = malloc(sizeof(struct mprsas_target) * maxtargets,
3887             M_MPR, M_WAITOK|M_ZERO);
3888         if (!sassc->targets) {
3889                 panic("%s failed to alloc targets with error %d\n",
3890                     __func__, ENOMEM);
3891         }
3892 }