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