sys/dev/mpr/mpr_sas.c

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