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