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