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