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