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