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