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