sys/dev/mpr/mpr_sas.c

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