sys/dev/mpr/mpr_sas.c

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