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