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