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