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