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