sys/dev/mps/mps_sas.c

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