sys/dev/mpr/mpr_sas.c

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