1 /*- 2 * Copyright (c) 2009 Yahoo! Inc. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 /* Communications core for LSI MPT2 */ 31 32 #include <sys/types.h> 33 #include <sys/param.h> 34 #include <sys/systm.h> 35 #include <sys/kernel.h> 36 #include <sys/selinfo.h> 37 #include <sys/module.h> 38 #include <sys/bus.h> 39 #include <sys/conf.h> 40 #include <sys/bio.h> 41 #include <sys/malloc.h> 42 #include <sys/uio.h> 43 #include <sys/sysctl.h> 44 #include <sys/sglist.h> 45 #include <sys/endian.h> 46 47 #include <machine/bus.h> 48 #include <machine/resource.h> 49 #include <sys/rman.h> 50 51 #include <cam/cam.h> 52 #include <cam/cam_ccb.h> 53 #include <cam/cam_debug.h> 54 #include <cam/cam_sim.h> 55 #include <cam/cam_xpt_sim.h> 56 #include <cam/cam_xpt_periph.h> 57 #include <cam/cam_periph.h> 58 #include <cam/scsi/scsi_all.h> 59 #include <cam/scsi/scsi_message.h> 60 #if __FreeBSD_version >= 900026 61 #include <cam/scsi/smp_all.h> 62 #endif 63 64 #include <dev/mps/mpi/mpi2_type.h> 65 #include <dev/mps/mpi/mpi2.h> 66 #include <dev/mps/mpi/mpi2_ioc.h> 67 #include <dev/mps/mpi/mpi2_sas.h> 68 #include <dev/mps/mpi/mpi2_cnfg.h> 69 #include <dev/mps/mpi/mpi2_init.h> 70 #include <dev/mps/mpsvar.h> 71 #include <dev/mps/mps_table.h> 72 73 struct mpssas_target { 74 uint16_t handle; 75 uint8_t linkrate; 76 uint64_t devname; 77 uint64_t sasaddr; 78 uint32_t devinfo; 79 uint16_t encl_handle; 80 uint16_t encl_slot; 81 uint16_t parent_handle; 82 int flags; 83 #define MPSSAS_TARGET_INABORT (1 << 0) 84 #define MPSSAS_TARGET_INRESET (1 << 1) 85 #define MPSSAS_TARGET_INCHIPRESET (1 << 2) 86 #define MPSSAS_TARGET_INRECOVERY 0x7 87 uint16_t tid; 88 }; 89 90 struct mpssas_softc { 91 struct mps_softc *sc; 92 u_int flags; 93 #define MPSSAS_IN_DISCOVERY (1 << 0) 94 #define MPSSAS_IN_STARTUP (1 << 1) 95 #define MPSSAS_DISCOVERY_TIMEOUT_PENDING (1 << 2) 96 #define MPSSAS_QUEUE_FROZEN (1 << 3) 97 struct mpssas_target *targets; 98 struct cam_devq *devq; 99 struct cam_sim *sim; 100 struct cam_path *path; 101 struct intr_config_hook sas_ich; 102 struct callout discovery_callout; 103 u_int discovery_timeouts; 104 struct mps_event_handle *mpssas_eh; 105 }; 106 107 struct mpssas_devprobe { 108 struct mps_config_params params; 109 u_int state; 110 #define MPSSAS_PROBE_DEV1 0x01 111 #define MPSSAS_PROBE_DEV2 0x02 112 #define MPSSAS_PROBE_PHY 0x03 113 #define MPSSAS_PROBE_EXP 0x04 114 #define MPSSAS_PROBE_PHY2 0x05 115 #define MPSSAS_PROBE_EXP2 0x06 116 struct mpssas_target target; 117 }; 118 119 #define MPSSAS_DISCOVERY_TIMEOUT 20 120 #define MPSSAS_MAX_DISCOVERY_TIMEOUTS 10 /* 200 seconds */ 121 122 static MALLOC_DEFINE(M_MPSSAS, "MPSSAS", "MPS SAS memory"); 123 124 static __inline int mpssas_set_lun(uint8_t *lun, u_int ccblun); 125 static struct mpssas_target * mpssas_alloc_target(struct mpssas_softc *, 126 struct mpssas_target *); 127 static struct mpssas_target * mpssas_find_target(struct mpssas_softc *, int, 128 uint16_t); 129 static void mpssas_announce_device(struct mpssas_softc *, 130 struct mpssas_target *); 131 static void mpssas_startup(void *data); 132 static void mpssas_discovery_end(struct mpssas_softc *sassc); 133 static void mpssas_discovery_timeout(void *data); 134 static void mpssas_prepare_remove(struct mpssas_softc *, 135 MPI2_EVENT_SAS_TOPO_PHY_ENTRY *); 136 static void mpssas_remove_device(struct mps_softc *, struct mps_command *); 137 static void mpssas_remove_complete(struct mps_softc *, struct mps_command *); 138 static void mpssas_action(struct cam_sim *sim, union ccb *ccb); 139 static void mpssas_poll(struct cam_sim *sim); 140 static void mpssas_probe_device(struct mps_softc *sc, uint16_t handle); 141 static void mpssas_probe_device_complete(struct mps_softc *sc, 142 struct mps_config_params *params); 143 static void mpssas_scsiio_timeout(void *data); 144 static void mpssas_abort_complete(struct mps_softc *sc, struct mps_command *cm); 145 static void mpssas_recovery(struct mps_softc *, struct mps_command *); 146 static int mpssas_map_tm_request(struct mps_softc *sc, struct mps_command *cm); 147 static void mpssas_issue_tm_request(struct mps_softc *sc, 148 struct mps_command *cm); 149 static void mpssas_tm_complete(struct mps_softc *sc, struct mps_command *cm, 150 int error); 151 static int mpssas_complete_tm_request(struct mps_softc *sc, 152 struct mps_command *cm, int free_cm); 153 static void mpssas_action_scsiio(struct mpssas_softc *, union ccb *); 154 static void mpssas_scsiio_complete(struct mps_softc *, struct mps_command *); 155 #if __FreeBSD_version >= 900026 156 static void mpssas_smpio_complete(struct mps_softc *sc, struct mps_command *cm); 157 static void mpssas_send_smpcmd(struct mpssas_softc *sassc, union ccb *ccb, 158 uint64_t sasaddr); 159 static void mpssas_action_smpio(struct mpssas_softc *sassc, union ccb *ccb); 160 #endif /* __FreeBSD_version >= 900026 */ 161 static void mpssas_resetdev(struct mpssas_softc *, struct mps_command *); 162 static void mpssas_action_resetdev(struct mpssas_softc *, union ccb *); 163 static void mpssas_resetdev_complete(struct mps_softc *, struct mps_command *); 164 static void mpssas_freeze_device(struct mpssas_softc *, struct mpssas_target *); 165 static void mpssas_unfreeze_device(struct mpssas_softc *, struct mpssas_target *) __unused; 166 167 /* 168 * Abstracted so that the driver can be backwards and forwards compatible 169 * with future versions of CAM that will provide this functionality. 170 */ 171 #define MPS_SET_LUN(lun, ccblun) \ 172 mpssas_set_lun(lun, ccblun) 173 174 static __inline int 175 mpssas_set_lun(uint8_t *lun, u_int ccblun) 176 { 177 uint64_t *newlun; 178 179 newlun = (uint64_t *)lun; 180 *newlun = 0; 181 if (ccblun <= 0xff) { 182 /* Peripheral device address method, LUN is 0 to 255 */ 183 lun[1] = ccblun; 184 } else if (ccblun <= 0x3fff) { 185 /* Flat space address method, LUN is <= 16383 */ 186 scsi_ulto2b(ccblun, lun); 187 lun[0] |= 0x40; 188 } else if (ccblun <= 0xffffff) { 189 /* Extended flat space address method, LUN is <= 16777215 */ 190 scsi_ulto3b(ccblun, &lun[1]); 191 /* Extended Flat space address method */ 192 lun[0] = 0xc0; 193 /* Length = 1, i.e. LUN is 3 bytes long */ 194 lun[0] |= 0x10; 195 /* Extended Address Method */ 196 lun[0] |= 0x02; 197 } else { 198 return (EINVAL); 199 } 200 201 return (0); 202 } 203 204 static struct mpssas_target * 205 mpssas_alloc_target(struct mpssas_softc *sassc, struct mpssas_target *probe) 206 { 207 struct mpssas_target *target; 208 int start; 209 210 mps_dprint(sassc->sc, MPS_TRACE, "%s\n", __func__); 211 212 /* 213 * If it's not a sata or sas target, CAM won't be able to see it. Put 214 * it into a high-numbered slot so that it's accessible but not 215 * interrupting the target numbering sequence of real drives. 216 */ 217 if ((probe->devinfo & (MPI2_SAS_DEVICE_INFO_SSP_TARGET | 218 MPI2_SAS_DEVICE_INFO_STP_TARGET | MPI2_SAS_DEVICE_INFO_SATA_DEVICE)) 219 == 0) { 220 start = 200; 221 } else { 222 /* 223 * Use the enclosure number and slot number as a hint for target 224 * numbering. If that doesn't produce a sane result, search the 225 * entire space. 226 */ 227 #if 0 228 start = probe->encl_handle * 16 + probe->encl_slot; 229 #else 230 start = probe->encl_slot; 231 #endif 232 if (start >= sassc->sc->facts->MaxTargets) 233 start = 0; 234 } 235 236 target = mpssas_find_target(sassc, start, 0); 237 238 /* 239 * Nothing found on the first pass, try a second pass that searches the 240 * entire space. 241 */ 242 if (target == NULL) 243 target = mpssas_find_target(sassc, 0, 0); 244 245 return (target); 246 } 247 248 static struct mpssas_target * 249 mpssas_find_target(struct mpssas_softc *sassc, int start, uint16_t handle) 250 { 251 struct mpssas_target *target; 252 int i; 253 254 for (i = start; i < sassc->sc->facts->MaxTargets; i++) { 255 target = &sassc->targets[i]; 256 if (target->handle == handle) 257 return (target); 258 } 259 260 return (NULL); 261 } 262 263 /* 264 * Start the probe sequence for a given device handle. This will not 265 * block. 266 */ 267 static void 268 mpssas_probe_device(struct mps_softc *sc, uint16_t handle) 269 { 270 struct mpssas_devprobe *probe; 271 struct mps_config_params *params; 272 MPI2_CONFIG_EXTENDED_PAGE_HEADER *hdr; 273 int error; 274 275 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 276 277 probe = malloc(sizeof(*probe), M_MPSSAS, M_NOWAIT | M_ZERO); 278 if (probe == NULL) { 279 mps_dprint(sc, MPS_FAULT, "Out of memory starting probe\n"); 280 return; 281 } 282 params = &probe->params; 283 hdr = ¶ms->hdr.Ext; 284 285 params->action = MPI2_CONFIG_ACTION_PAGE_HEADER; 286 params->page_address = MPI2_SAS_DEVICE_PGAD_FORM_HANDLE | handle; 287 hdr->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_DEVICE; 288 hdr->ExtPageLength = 0; 289 hdr->PageNumber = 0; 290 hdr->PageVersion = 0; 291 params->buffer = NULL; 292 params->length = 0; 293 params->callback = mpssas_probe_device_complete; 294 params->cbdata = probe; 295 probe->target.handle = handle; 296 probe->state = MPSSAS_PROBE_DEV1; 297 298 if ((error = mps_read_config_page(sc, params)) != 0) { 299 free(probe, M_MPSSAS); 300 mps_dprint(sc, MPS_FAULT, "Failure starting device probe\n"); 301 return; 302 } 303 } 304 305 static void 306 mpssas_probe_device_complete(struct mps_softc *sc, 307 struct mps_config_params *params) 308 { 309 MPI2_CONFIG_EXTENDED_PAGE_HEADER *hdr; 310 struct mpssas_devprobe *probe; 311 int error; 312 313 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 314 315 hdr = ¶ms->hdr.Ext; 316 probe = params->cbdata; 317 318 switch (probe->state) { 319 case MPSSAS_PROBE_DEV1: 320 case MPSSAS_PROBE_PHY: 321 case MPSSAS_PROBE_EXP: 322 if (params->status != MPI2_IOCSTATUS_SUCCESS) { 323 mps_dprint(sc, MPS_FAULT, 324 "Probe Failure 0x%x state %d\n", params->status, 325 probe->state); 326 free(probe, M_MPSSAS); 327 return; 328 } 329 params->action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT; 330 params->length = hdr->ExtPageLength * 4; 331 params->buffer = malloc(params->length, M_MPSSAS, 332 M_ZERO|M_NOWAIT); 333 if (params->buffer == NULL) { 334 mps_dprint(sc, MPS_FAULT, "Out of memory at state " 335 "0x%x, size 0x%x\n", probe->state, params->length); 336 free(probe, M_MPSSAS); 337 return; 338 } 339 if (probe->state == MPSSAS_PROBE_DEV1) 340 probe->state = MPSSAS_PROBE_DEV2; 341 else if (probe->state == MPSSAS_PROBE_PHY) 342 probe->state = MPSSAS_PROBE_PHY2; 343 else if (probe->state == MPSSAS_PROBE_EXP) 344 probe->state = MPSSAS_PROBE_EXP2; 345 error = mps_read_config_page(sc, params); 346 break; 347 case MPSSAS_PROBE_DEV2: 348 { 349 MPI2_CONFIG_PAGE_SAS_DEV_0 *buf; 350 351 if (params->status != MPI2_IOCSTATUS_SUCCESS) { 352 mps_dprint(sc, MPS_FAULT, 353 "Probe Failure 0x%x state %d\n", params->status, 354 probe->state); 355 free(params->buffer, M_MPSSAS); 356 free(probe, M_MPSSAS); 357 return; 358 } 359 buf = params->buffer; 360 mps_print_sasdev0(sc, buf); 361 362 probe->target.devname = mps_to_u64(&buf->DeviceName); 363 probe->target.devinfo = buf->DeviceInfo; 364 probe->target.encl_handle = buf->EnclosureHandle; 365 probe->target.encl_slot = buf->Slot; 366 probe->target.sasaddr = mps_to_u64(&buf->SASAddress); 367 probe->target.parent_handle = buf->ParentDevHandle; 368 369 if (buf->DeviceInfo & MPI2_SAS_DEVICE_INFO_DIRECT_ATTACH) { 370 params->page_address = 371 MPI2_SAS_PHY_PGAD_FORM_PHY_NUMBER | buf->PhyNum; 372 hdr->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_PHY; 373 hdr->PageNumber = 0; 374 probe->state = MPSSAS_PROBE_PHY; 375 } else { 376 params->page_address = 377 MPI2_SAS_EXPAND_PGAD_FORM_HNDL_PHY_NUM | 378 buf->ParentDevHandle | (buf->PhyNum << 16); 379 hdr->ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_EXPANDER; 380 hdr->PageNumber = 1; 381 probe->state = MPSSAS_PROBE_EXP; 382 } 383 params->action = MPI2_CONFIG_ACTION_PAGE_HEADER; 384 hdr->ExtPageLength = 0; 385 hdr->PageVersion = 0; 386 params->buffer = NULL; 387 params->length = 0; 388 free(buf, M_MPSSAS); 389 error = mps_read_config_page(sc, params); 390 break; 391 } 392 case MPSSAS_PROBE_PHY2: 393 case MPSSAS_PROBE_EXP2: 394 { 395 MPI2_CONFIG_PAGE_SAS_PHY_0 *phy; 396 MPI2_CONFIG_PAGE_EXPANDER_1 *exp; 397 struct mpssas_softc *sassc; 398 struct mpssas_target *targ; 399 char devstring[80]; 400 uint16_t handle; 401 402 if (params->status != MPI2_IOCSTATUS_SUCCESS) { 403 mps_dprint(sc, MPS_FAULT, 404 "Probe Failure 0x%x state %d\n", params->status, 405 probe->state); 406 free(params->buffer, M_MPSSAS); 407 free(probe, M_MPSSAS); 408 return; 409 } 410 411 if (probe->state == MPSSAS_PROBE_PHY2) { 412 phy = params->buffer; 413 mps_print_sasphy0(sc, phy); 414 probe->target.linkrate = phy->NegotiatedLinkRate & 0xf; 415 } else { 416 exp = params->buffer; 417 mps_print_expander1(sc, exp); 418 probe->target.linkrate = exp->NegotiatedLinkRate & 0xf; 419 } 420 free(params->buffer, M_MPSSAS); 421 422 sassc = sc->sassc; 423 handle = probe->target.handle; 424 if ((targ = mpssas_find_target(sassc, 0, handle)) != NULL) { 425 mps_printf(sc, "Ignoring dup device handle 0x%04x\n", 426 handle); 427 free(probe, M_MPSSAS); 428 return; 429 } 430 if ((targ = mpssas_alloc_target(sassc, &probe->target)) == NULL) { 431 mps_printf(sc, "Target table overflow, handle 0x%04x\n", 432 handle); 433 free(probe, M_MPSSAS); 434 return; 435 } 436 437 *targ = probe->target; /* Copy the attributes */ 438 targ->tid = targ - sassc->targets; 439 mps_describe_devinfo(targ->devinfo, devstring, 80); 440 if (bootverbose) 441 mps_printf(sc, "Found device <%s> <%s> <0x%04x> " 442 "<%d/%d>\n", devstring, 443 mps_describe_table(mps_linkrate_names, 444 targ->linkrate), targ->handle, targ->encl_handle, 445 targ->encl_slot); 446 447 free(probe, M_MPSSAS); 448 mpssas_announce_device(sassc, targ); 449 break; 450 } 451 default: 452 printf("what?\n"); 453 } 454 } 455 456 /* 457 * The MPT2 firmware performs debounce on the link to avoid transient link errors 458 * and false removals. When it does decide that link has been lost and a device 459 * need to go away, it expects that the host will perform a target reset and then 460 * an op remove. The reset has the side-effect of aborting any outstanding 461 * requests for the device, which is required for the op-remove to succeed. It's 462 * not clear if the host should check for the device coming back alive after the 463 * reset. 464 */ 465 static void 466 mpssas_prepare_remove(struct mpssas_softc *sassc, MPI2_EVENT_SAS_TOPO_PHY_ENTRY *phy) 467 { 468 MPI2_SCSI_TASK_MANAGE_REQUEST *req; 469 struct mps_softc *sc; 470 struct mps_command *cm; 471 struct mpssas_target *targ = NULL; 472 uint16_t handle; 473 474 mps_dprint(sassc->sc, MPS_TRACE, "%s\n", __func__); 475 476 handle = phy->AttachedDevHandle; 477 targ = mpssas_find_target(sassc, 0, handle); 478 if (targ == NULL) 479 /* We don't know about this device? */ 480 return; 481 482 sc = sassc->sc; 483 cm = mps_alloc_command(sc); 484 if (cm == NULL) { 485 mps_printf(sc, "comand alloc failure in mpssas_prepare_remove\n"); 486 return; 487 } 488 489 mps_dprint(sc, MPS_INFO, "Preparing to remove target %d\n", targ->tid); 490 491 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)cm->cm_req; 492 memset(req, 0, sizeof(*req)); 493 req->DevHandle = targ->handle; 494 req->Function = MPI2_FUNCTION_SCSI_TASK_MGMT; 495 req->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET; 496 497 /* SAS Hard Link Reset / SATA Link Reset */ 498 req->MsgFlags = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET; 499 500 cm->cm_data = NULL; 501 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 502 cm->cm_complete = mpssas_remove_device; 503 cm->cm_targ = targ; 504 mpssas_issue_tm_request(sc, cm); 505 } 506 507 static void 508 mpssas_remove_device(struct mps_softc *sc, struct mps_command *cm) 509 { 510 MPI2_SCSI_TASK_MANAGE_REPLY *reply; 511 MPI2_SAS_IOUNIT_CONTROL_REQUEST *req; 512 struct mpssas_target *targ; 513 struct mps_command *next_cm; 514 uint16_t handle; 515 516 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 517 518 reply = (MPI2_SCSI_TASK_MANAGE_REPLY *)cm->cm_reply; 519 handle = cm->cm_targ->handle; 520 521 mpssas_complete_tm_request(sc, cm, /*free_cm*/ 0); 522 523 /* 524 * Currently there should be no way we can hit this case. It only 525 * happens when we have a failure to allocate chain frames, and 526 * task management commands don't have S/G lists. 527 */ 528 if ((cm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) { 529 mps_printf(sc, "%s: cm_flags = %#x for remove of handle %#04x! " 530 "This should not happen!\n", __func__, cm->cm_flags, 531 handle); 532 return; 533 } 534 535 if (reply->IOCStatus != MPI2_IOCSTATUS_SUCCESS) { 536 mps_printf(sc, "Failure 0x%x reseting device 0x%04x\n", 537 reply->IOCStatus, handle); 538 mps_free_command(sc, cm); 539 return; 540 } 541 542 mps_dprint(sc, MPS_INFO, "Reset aborted %u commands\n", 543 reply->TerminationCount); 544 mps_free_reply(sc, cm->cm_reply_data); 545 546 /* Reuse the existing command */ 547 req = (MPI2_SAS_IOUNIT_CONTROL_REQUEST *)cm->cm_req; 548 memset(req, 0, sizeof(*req)); 549 req->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL; 550 req->Operation = MPI2_SAS_OP_REMOVE_DEVICE; 551 req->DevHandle = handle; 552 cm->cm_data = NULL; 553 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 554 cm->cm_flags &= ~MPS_CM_FLAGS_COMPLETE; 555 cm->cm_complete = mpssas_remove_complete; 556 557 mps_map_command(sc, cm); 558 559 mps_dprint(sc, MPS_INFO, "clearing target handle 0x%04x\n", handle); 560 TAILQ_FOREACH_SAFE(cm, &sc->io_list, cm_link, next_cm) { 561 union ccb *ccb; 562 563 if (cm->cm_targ->handle != handle) 564 continue; 565 566 mps_dprint(sc, MPS_INFO, "Completing missed command %p\n", cm); 567 ccb = cm->cm_complete_data; 568 ccb->ccb_h.status = CAM_DEV_NOT_THERE; 569 mpssas_scsiio_complete(sc, cm); 570 } 571 targ = mpssas_find_target(sc->sassc, 0, handle); 572 if (targ != NULL) { 573 targ->handle = 0x0; 574 mpssas_announce_device(sc->sassc, targ); 575 } 576 } 577 578 static void 579 mpssas_remove_complete(struct mps_softc *sc, struct mps_command *cm) 580 { 581 MPI2_SAS_IOUNIT_CONTROL_REPLY *reply; 582 583 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 584 585 reply = (MPI2_SAS_IOUNIT_CONTROL_REPLY *)cm->cm_reply; 586 587 mps_printf(sc, "mpssas_remove_complete on target 0x%04x," 588 " IOCStatus= 0x%x\n", cm->cm_targ->tid, reply->IOCStatus); 589 590 mps_free_command(sc, cm); 591 } 592 593 static void 594 mpssas_evt_handler(struct mps_softc *sc, uintptr_t data, 595 MPI2_EVENT_NOTIFICATION_REPLY *event) 596 { 597 struct mpssas_softc *sassc; 598 599 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 600 601 sassc = sc->sassc; 602 mps_print_evt_sas(sc, event); 603 604 switch (event->Event) { 605 case MPI2_EVENT_SAS_DISCOVERY: 606 { 607 MPI2_EVENT_DATA_SAS_DISCOVERY *data; 608 609 data = (MPI2_EVENT_DATA_SAS_DISCOVERY *)&event->EventData; 610 611 if (data->ReasonCode & MPI2_EVENT_SAS_DISC_RC_STARTED) 612 mps_dprint(sc, MPS_TRACE,"SAS discovery start event\n"); 613 if (data->ReasonCode & MPI2_EVENT_SAS_DISC_RC_COMPLETED) { 614 mps_dprint(sc, MPS_TRACE, "SAS discovery end event\n"); 615 sassc->flags &= ~MPSSAS_IN_DISCOVERY; 616 mpssas_discovery_end(sassc); 617 } 618 break; 619 } 620 case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST: 621 { 622 MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST *data; 623 MPI2_EVENT_SAS_TOPO_PHY_ENTRY *phy; 624 int i; 625 626 data = (MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST *) 627 &event->EventData; 628 629 if (data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED) { 630 if (bootverbose) 631 printf("Expander found at enclosure %d\n", 632 data->EnclosureHandle); 633 mpssas_probe_device(sc, data->ExpanderDevHandle); 634 } 635 636 for (i = 0; i < data->NumEntries; i++) { 637 phy = &data->PHY[i]; 638 switch (phy->PhyStatus & MPI2_EVENT_SAS_TOPO_RC_MASK) { 639 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED: 640 mpssas_probe_device(sc, phy->AttachedDevHandle); 641 break; 642 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING: 643 mpssas_prepare_remove(sassc, phy); 644 break; 645 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED: 646 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE: 647 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING: 648 default: 649 break; 650 } 651 } 652 653 break; 654 } 655 case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE: 656 break; 657 default: 658 break; 659 } 660 661 mps_free_reply(sc, data); 662 } 663 664 static int 665 mpssas_register_events(struct mps_softc *sc) 666 { 667 uint8_t events[16]; 668 669 bzero(events, 16); 670 setbit(events, MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE); 671 setbit(events, MPI2_EVENT_SAS_DISCOVERY); 672 setbit(events, MPI2_EVENT_SAS_BROADCAST_PRIMITIVE); 673 setbit(events, MPI2_EVENT_SAS_INIT_DEVICE_STATUS_CHANGE); 674 setbit(events, MPI2_EVENT_SAS_INIT_TABLE_OVERFLOW); 675 setbit(events, MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST); 676 setbit(events, MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE); 677 678 mps_register_events(sc, events, mpssas_evt_handler, NULL, 679 &sc->sassc->mpssas_eh); 680 681 return (0); 682 } 683 684 int 685 mps_attach_sas(struct mps_softc *sc) 686 { 687 struct mpssas_softc *sassc; 688 int error = 0; 689 int num_sim_reqs; 690 691 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 692 693 sassc = malloc(sizeof(struct mpssas_softc), M_MPT2, M_WAITOK|M_ZERO); 694 sassc->targets = malloc(sizeof(struct mpssas_target) * 695 sc->facts->MaxTargets, M_MPT2, M_WAITOK|M_ZERO); 696 sc->sassc = sassc; 697 sassc->sc = sc; 698 699 /* 700 * Tell CAM that we can handle 5 fewer requests than we have 701 * allocated. If we allow the full number of requests, all I/O 702 * will halt when we run out of resources. Things work fine with 703 * just 1 less request slot given to CAM than we have allocated. 704 * We also need a couple of extra commands so that we can send down 705 * abort, reset, etc. requests when commands time out. Otherwise 706 * we could wind up in a situation with sc->num_reqs requests down 707 * on the card and no way to send an abort. 708 * 709 * XXX KDM need to figure out why I/O locks up if all commands are 710 * used. 711 */ 712 num_sim_reqs = sc->num_reqs - 5; 713 714 if ((sassc->devq = cam_simq_alloc(num_sim_reqs)) == NULL) { 715 mps_dprint(sc, MPS_FAULT, "Cannot allocate SIMQ\n"); 716 error = ENOMEM; 717 goto out; 718 } 719 720 sassc->sim = cam_sim_alloc(mpssas_action, mpssas_poll, "mps", sassc, 721 device_get_unit(sc->mps_dev), &sc->mps_mtx, num_sim_reqs, 722 num_sim_reqs, sassc->devq); 723 if (sassc->sim == NULL) { 724 mps_dprint(sc, MPS_FAULT, "Cannot allocate SIM\n"); 725 error = EINVAL; 726 goto out; 727 } 728 729 /* 730 * XXX There should be a bus for every port on the adapter, but since 731 * we're just going to fake the topology for now, we'll pretend that 732 * everything is just a target on a single bus. 733 */ 734 mps_lock(sc); 735 if ((error = xpt_bus_register(sassc->sim, sc->mps_dev, 0)) != 0) { 736 mps_dprint(sc, MPS_FAULT, "Error %d registering SCSI bus\n", 737 error); 738 mps_unlock(sc); 739 goto out; 740 } 741 742 /* 743 * Assume that discovery events will start right away. Freezing 744 * the simq will prevent the CAM boottime scanner from running 745 * before discovery is complete. 746 */ 747 sassc->flags = MPSSAS_IN_STARTUP | MPSSAS_IN_DISCOVERY; 748 xpt_freeze_simq(sassc->sim, 1); 749 750 mps_unlock(sc); 751 752 callout_init(&sassc->discovery_callout, 1 /*mpsafe*/); 753 sassc->discovery_timeouts = 0; 754 755 mpssas_register_events(sc); 756 out: 757 if (error) 758 mps_detach_sas(sc); 759 return (error); 760 } 761 762 int 763 mps_detach_sas(struct mps_softc *sc) 764 { 765 struct mpssas_softc *sassc; 766 767 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 768 769 if (sc->sassc == NULL) 770 return (0); 771 772 sassc = sc->sassc; 773 774 /* Make sure CAM doesn't wedge if we had to bail out early. */ 775 mps_lock(sc); 776 if (sassc->flags & MPSSAS_IN_STARTUP) 777 xpt_release_simq(sassc->sim, 1); 778 mps_unlock(sc); 779 780 if (sassc->mpssas_eh != NULL) 781 mps_deregister_events(sc, sassc->mpssas_eh); 782 783 mps_lock(sc); 784 785 if (sassc->sim != NULL) { 786 xpt_bus_deregister(cam_sim_path(sassc->sim)); 787 cam_sim_free(sassc->sim, FALSE); 788 } 789 mps_unlock(sc); 790 791 if (sassc->devq != NULL) 792 cam_simq_free(sassc->devq); 793 794 free(sassc->targets, M_MPT2); 795 free(sassc, M_MPT2); 796 sc->sassc = NULL; 797 798 return (0); 799 } 800 801 static void 802 mpssas_discovery_end(struct mpssas_softc *sassc) 803 { 804 struct mps_softc *sc = sassc->sc; 805 806 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 807 808 if (sassc->flags & MPSSAS_DISCOVERY_TIMEOUT_PENDING) 809 callout_stop(&sassc->discovery_callout); 810 811 if ((sassc->flags & MPSSAS_IN_STARTUP) != 0) { 812 mps_dprint(sc, MPS_INFO, 813 "mpssas_discovery_end: removing confighook\n"); 814 sassc->flags &= ~MPSSAS_IN_STARTUP; 815 xpt_release_simq(sassc->sim, 1); 816 } 817 #if 0 818 mpssas_announce_device(sassc, NULL); 819 #endif 820 821 } 822 823 static void 824 mpssas_announce_device(struct mpssas_softc *sassc, struct mpssas_target *targ) 825 { 826 union ccb *ccb; 827 int bus, tid, lun; 828 829 /* 830 * Force a rescan, a hackish way to announce devices. 831 * XXX Doing a scan on an individual device is hackish in that it 832 * won't scan the LUNs. 833 * XXX Does it matter if any of this fails? 834 */ 835 bus = cam_sim_path(sassc->sim); 836 if (targ != NULL) { 837 tid = targ->tid; 838 lun = 0; 839 } else { 840 tid = CAM_TARGET_WILDCARD; 841 lun = CAM_LUN_WILDCARD; 842 } 843 ccb = xpt_alloc_ccb_nowait(); 844 if (ccb == NULL) 845 return; 846 if (xpt_create_path(&ccb->ccb_h.path, xpt_periph, bus, tid, 847 CAM_LUN_WILDCARD) != CAM_REQ_CMP) { 848 xpt_free_ccb(ccb); 849 return; 850 } 851 mps_dprint(sassc->sc, MPS_INFO, "Triggering rescan of %d:%d:-1\n", 852 bus, tid); 853 xpt_rescan(ccb); 854 } 855 856 static void 857 mpssas_startup(void *data) 858 { 859 struct mpssas_softc *sassc = data; 860 861 mps_dprint(sassc->sc, MPS_TRACE, "%s\n", __func__); 862 863 mps_lock(sassc->sc); 864 if ((sassc->flags & MPSSAS_IN_DISCOVERY) == 0) { 865 mpssas_discovery_end(sassc); 866 } else { 867 if (sassc->discovery_timeouts < MPSSAS_MAX_DISCOVERY_TIMEOUTS) { 868 sassc->flags |= MPSSAS_DISCOVERY_TIMEOUT_PENDING; 869 callout_reset(&sassc->discovery_callout, 870 MPSSAS_DISCOVERY_TIMEOUT * hz, 871 mpssas_discovery_timeout, sassc); 872 sassc->discovery_timeouts++; 873 } else { 874 mps_dprint(sassc->sc, MPS_FAULT, 875 "Discovery timed out, continuing.\n"); 876 sassc->flags &= ~MPSSAS_IN_DISCOVERY; 877 mpssas_discovery_end(sassc); 878 } 879 } 880 mps_unlock(sassc->sc); 881 882 return; 883 } 884 885 static void 886 mpssas_discovery_timeout(void *data) 887 { 888 struct mpssas_softc *sassc = data; 889 struct mps_softc *sc; 890 891 sc = sassc->sc; 892 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 893 894 mps_lock(sc); 895 mps_printf(sc, 896 "Timeout waiting for discovery, interrupts may not be working!\n"); 897 sassc->flags &= ~MPSSAS_DISCOVERY_TIMEOUT_PENDING; 898 899 /* Poll the hardware for events in case interrupts aren't working */ 900 mps_intr_locked(sc); 901 mps_unlock(sc); 902 903 /* Check the status of discovery and re-arm the timeout if needed */ 904 mpssas_startup(sassc); 905 } 906 907 static void 908 mpssas_action(struct cam_sim *sim, union ccb *ccb) 909 { 910 struct mpssas_softc *sassc; 911 912 sassc = cam_sim_softc(sim); 913 914 mps_dprint(sassc->sc, MPS_TRACE, "%s func 0x%x\n", __func__, 915 ccb->ccb_h.func_code); 916 917 switch (ccb->ccb_h.func_code) { 918 case XPT_PATH_INQ: 919 { 920 struct ccb_pathinq *cpi = &ccb->cpi; 921 922 cpi->version_num = 1; 923 cpi->hba_inquiry = PI_SDTR_ABLE|PI_TAG_ABLE|PI_WIDE_16; 924 cpi->target_sprt = 0; 925 cpi->hba_misc = PIM_NOBUSRESET; 926 cpi->hba_eng_cnt = 0; 927 cpi->max_target = sassc->sc->facts->MaxTargets - 1; 928 cpi->max_lun = 8; 929 cpi->initiator_id = 255; 930 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); 931 strncpy(cpi->hba_vid, "LSILogic", HBA_IDLEN); 932 strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN); 933 cpi->unit_number = cam_sim_unit(sim); 934 cpi->bus_id = cam_sim_bus(sim); 935 cpi->base_transfer_speed = 150000; 936 cpi->transport = XPORT_SAS; 937 cpi->transport_version = 0; 938 cpi->protocol = PROTO_SCSI; 939 cpi->protocol_version = SCSI_REV_SPC; 940 cpi->ccb_h.status = CAM_REQ_CMP; 941 break; 942 } 943 case XPT_GET_TRAN_SETTINGS: 944 { 945 struct ccb_trans_settings *cts; 946 struct ccb_trans_settings_sas *sas; 947 struct ccb_trans_settings_scsi *scsi; 948 struct mpssas_target *targ; 949 950 cts = &ccb->cts; 951 sas = &cts->xport_specific.sas; 952 scsi = &cts->proto_specific.scsi; 953 954 targ = &sassc->targets[cts->ccb_h.target_id]; 955 if (targ->handle == 0x0) { 956 cts->ccb_h.status = CAM_TID_INVALID; 957 break; 958 } 959 960 cts->protocol_version = SCSI_REV_SPC2; 961 cts->transport = XPORT_SAS; 962 cts->transport_version = 0; 963 964 sas->valid = CTS_SAS_VALID_SPEED; 965 switch (targ->linkrate) { 966 case 0x08: 967 sas->bitrate = 150000; 968 break; 969 case 0x09: 970 sas->bitrate = 300000; 971 break; 972 case 0x0a: 973 sas->bitrate = 600000; 974 break; 975 default: 976 sas->valid = 0; 977 } 978 979 cts->protocol = PROTO_SCSI; 980 scsi->valid = CTS_SCSI_VALID_TQ; 981 scsi->flags = CTS_SCSI_FLAGS_TAG_ENB; 982 983 cts->ccb_h.status = CAM_REQ_CMP; 984 break; 985 } 986 case XPT_CALC_GEOMETRY: 987 cam_calc_geometry(&ccb->ccg, /*extended*/1); 988 ccb->ccb_h.status = CAM_REQ_CMP; 989 break; 990 case XPT_RESET_DEV: 991 mpssas_action_resetdev(sassc, ccb); 992 return; 993 case XPT_RESET_BUS: 994 case XPT_ABORT: 995 case XPT_TERM_IO: 996 ccb->ccb_h.status = CAM_REQ_CMP; 997 break; 998 case XPT_SCSI_IO: 999 mpssas_action_scsiio(sassc, ccb); 1000 return; 1001 #if __FreeBSD_version >= 900026 1002 case XPT_SMP_IO: 1003 mpssas_action_smpio(sassc, ccb); 1004 return; 1005 #endif /* __FreeBSD_version >= 900026 */ 1006 default: 1007 ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; 1008 break; 1009 } 1010 xpt_done(ccb); 1011 1012 } 1013 1014 #if 0 1015 static void 1016 mpssas_resettimeout_complete(struct mps_softc *sc, struct mps_command *cm) 1017 { 1018 MPI2_SCSI_TASK_MANAGE_REPLY *resp; 1019 uint16_t code; 1020 1021 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 1022 1023 resp = (MPI2_SCSI_TASK_MANAGE_REPLY *)cm->cm_reply; 1024 code = resp->ResponseCode; 1025 1026 mps_free_command(sc, cm); 1027 mpssas_unfreeze_device(sassc, targ); 1028 1029 if (code != MPI2_SCSITASKMGMT_RSP_TM_COMPLETE) { 1030 mps_reset_controller(sc); 1031 } 1032 1033 return; 1034 } 1035 #endif 1036 1037 static void 1038 mpssas_scsiio_timeout(void *data) 1039 { 1040 union ccb *ccb; 1041 struct mps_softc *sc; 1042 struct mps_command *cm; 1043 struct mpssas_target *targ; 1044 #if 0 1045 char cdb_str[(SCSI_MAX_CDBLEN * 3) + 1]; 1046 #endif 1047 1048 cm = (struct mps_command *)data; 1049 sc = cm->cm_sc; 1050 1051 /* 1052 * Run the interrupt handler to make sure it's not pending. This 1053 * isn't perfect because the command could have already completed 1054 * and been re-used, though this is unlikely. 1055 */ 1056 mps_lock(sc); 1057 mps_intr_locked(sc); 1058 if (cm->cm_state == MPS_CM_STATE_FREE) { 1059 mps_unlock(sc); 1060 return; 1061 } 1062 1063 ccb = cm->cm_complete_data; 1064 targ = cm->cm_targ; 1065 if (targ == 0x00) 1066 /* Driver bug */ 1067 targ = &sc->sassc->targets[ccb->ccb_h.target_id]; 1068 1069 xpt_print(ccb->ccb_h.path, "SCSI command timeout on device handle " 1070 "0x%04x SMID %d\n", targ->handle, cm->cm_desc.Default.SMID); 1071 /* 1072 * XXX KDM this is useful for debugging purposes, but the existing 1073 * scsi_op_desc() implementation can't handle a NULL value for 1074 * inq_data. So this will remain commented out until I bring in 1075 * those changes as well. 1076 */ 1077 #if 0 1078 xpt_print(ccb->ccb_h.path, "Timed out command: %s. CDB %s\n", 1079 scsi_op_desc((ccb->ccb_h.flags & CAM_CDB_POINTER) ? 1080 ccb->csio.cdb_io.cdb_ptr[0] : 1081 ccb->csio.cdb_io.cdb_bytes[0], NULL), 1082 scsi_cdb_string((ccb->ccb_h.flags & CAM_CDB_POINTER) ? 1083 ccb->csio.cdb_io.cdb_ptr : 1084 ccb->csio.cdb_io.cdb_bytes, cdb_str, 1085 sizeof(cdb_str))); 1086 #endif 1087 1088 /* Inform CAM about the timeout and that recovery is starting. */ 1089 #if 0 1090 if ((targ->flags & MPSSAS_TARGET_INRECOVERY) == 0) { 1091 mpssas_freeze_device(sc->sassc, targ); 1092 ccb->ccb_h.status = CAM_CMD_TIMEOUT; 1093 xpt_done(ccb); 1094 } 1095 #endif 1096 mpssas_freeze_device(sc->sassc, targ); 1097 ccb->ccb_h.status = CAM_CMD_TIMEOUT; 1098 1099 /* 1100 * recycle the command into recovery so that there's no risk of 1101 * command allocation failure. 1102 */ 1103 cm->cm_state = MPS_CM_STATE_TIMEDOUT; 1104 mpssas_recovery(sc, cm); 1105 mps_unlock(sc); 1106 } 1107 1108 static void 1109 mpssas_abort_complete(struct mps_softc *sc, struct mps_command *cm) 1110 { 1111 MPI2_SCSI_TASK_MANAGE_REQUEST *req; 1112 1113 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)cm->cm_req; 1114 1115 /* 1116 * Currently there should be no way we can hit this case. It only 1117 * happens when we have a failure to allocate chain frames, and 1118 * task management commands don't have S/G lists. 1119 */ 1120 if ((cm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) { 1121 mps_printf(sc, "%s: cm_flags = %#x for abort on handle %#04x! " 1122 "This should not happen!\n", __func__, cm->cm_flags, 1123 req->DevHandle); 1124 } 1125 1126 mps_printf(sc, "%s: abort request on handle %#04x SMID %d " 1127 "complete\n", __func__, req->DevHandle, req->TaskMID); 1128 1129 mpssas_complete_tm_request(sc, cm, /*free_cm*/ 1); 1130 } 1131 1132 static void 1133 mpssas_recovery(struct mps_softc *sc, struct mps_command *abort_cm) 1134 { 1135 struct mps_command *cm; 1136 MPI2_SCSI_TASK_MANAGE_REQUEST *req, *orig_req; 1137 1138 cm = mps_alloc_command(sc); 1139 if (cm == NULL) { 1140 mps_printf(sc, "%s: command allocation failure\n", __func__); 1141 return; 1142 } 1143 1144 cm->cm_targ = abort_cm->cm_targ; 1145 cm->cm_complete = mpssas_abort_complete; 1146 1147 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)cm->cm_req; 1148 orig_req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)abort_cm->cm_req; 1149 req->DevHandle = abort_cm->cm_targ->handle; 1150 req->Function = MPI2_FUNCTION_SCSI_TASK_MGMT; 1151 req->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK; 1152 memcpy(req->LUN, orig_req->LUN, sizeof(req->LUN)); 1153 req->TaskMID = abort_cm->cm_desc.Default.SMID; 1154 1155 cm->cm_data = NULL; 1156 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 1157 1158 mpssas_issue_tm_request(sc, cm); 1159 1160 } 1161 1162 /* 1163 * Can return 0 or EINPROGRESS on success. Any other value means failure. 1164 */ 1165 static int 1166 mpssas_map_tm_request(struct mps_softc *sc, struct mps_command *cm) 1167 { 1168 int error; 1169 1170 error = 0; 1171 1172 cm->cm_flags |= MPS_CM_FLAGS_ACTIVE; 1173 error = mps_map_command(sc, cm); 1174 if ((error == 0) 1175 || (error == EINPROGRESS)) 1176 sc->tm_cmds_active++; 1177 1178 return (error); 1179 } 1180 1181 static void 1182 mpssas_issue_tm_request(struct mps_softc *sc, struct mps_command *cm) 1183 { 1184 int freeze_queue, send_command, error; 1185 1186 freeze_queue = 0; 1187 send_command = 0; 1188 error = 0; 1189 1190 mtx_assert(&sc->mps_mtx, MA_OWNED); 1191 1192 /* 1193 * If there are no other pending task management commands, go 1194 * ahead and send this one. There is a small amount of anecdotal 1195 * evidence that sending lots of task management commands at once 1196 * may cause the controller to lock up. Or, if the user has 1197 * configured the driver (via the allow_multiple_tm_cmds variable) to 1198 * not serialize task management commands, go ahead and send the 1199 * command if even other task management commands are pending. 1200 */ 1201 if (TAILQ_FIRST(&sc->tm_list) == NULL) { 1202 send_command = 1; 1203 freeze_queue = 1; 1204 } else if (sc->allow_multiple_tm_cmds != 0) 1205 send_command = 1; 1206 1207 TAILQ_INSERT_TAIL(&sc->tm_list, cm, cm_link); 1208 if (send_command != 0) { 1209 /* 1210 * Freeze the SIM queue while we issue the task management 1211 * command. According to the Fusion-MPT 2.0 spec, task 1212 * management requests are serialized, and so the host 1213 * should not send any I/O requests while task management 1214 * requests are pending. 1215 */ 1216 if (freeze_queue != 0) 1217 xpt_freeze_simq(sc->sassc->sim, 1); 1218 1219 error = mpssas_map_tm_request(sc, cm); 1220 1221 /* 1222 * At present, there is no error path back from 1223 * mpssas_map_tm_request() (which calls mps_map_command()) 1224 * when cm->cm_data == NULL. But since there is a return 1225 * value, we check it just in case the implementation 1226 * changes later. 1227 */ 1228 if ((error != 0) 1229 && (error != EINPROGRESS)) 1230 mpssas_tm_complete(sc, cm, 1231 MPI2_SCSITASKMGMT_RSP_TM_FAILED); 1232 } 1233 } 1234 1235 static void 1236 mpssas_tm_complete(struct mps_softc *sc, struct mps_command *cm, int error) 1237 { 1238 MPI2_SCSI_TASK_MANAGE_REPLY *resp; 1239 1240 resp = (MPI2_SCSI_TASK_MANAGE_REPLY *)cm->cm_reply; 1241 1242 if (resp != NULL) 1243 resp->ResponseCode = error; 1244 1245 /* 1246 * Call the callback for this command, it will be 1247 * removed from the list and freed via the callback. 1248 */ 1249 cm->cm_complete(sc, cm); 1250 } 1251 1252 /* 1253 * Complete a task management request. The basic completion operation will 1254 * always succeed. Returns status for sending any further task management 1255 * commands that were queued. 1256 */ 1257 static int 1258 mpssas_complete_tm_request(struct mps_softc *sc, struct mps_command *cm, 1259 int free_cm) 1260 { 1261 int error; 1262 1263 error = 0; 1264 1265 mtx_assert(&sc->mps_mtx, MA_OWNED); 1266 1267 TAILQ_REMOVE(&sc->tm_list, cm, cm_link); 1268 cm->cm_flags &= ~MPS_CM_FLAGS_ACTIVE; 1269 sc->tm_cmds_active--; 1270 1271 if (free_cm != 0) 1272 mps_free_command(sc, cm); 1273 1274 if (TAILQ_FIRST(&sc->tm_list) == NULL) { 1275 /* 1276 * Release the SIM queue, we froze it when we sent the first 1277 * task management request. 1278 */ 1279 xpt_release_simq(sc->sassc->sim, 1); 1280 } else if ((sc->tm_cmds_active == 0) 1281 || (sc->allow_multiple_tm_cmds != 0)) { 1282 int error; 1283 struct mps_command *cm2; 1284 1285 restart_traversal: 1286 1287 /* 1288 * We don't bother using TAILQ_FOREACH_SAFE here, but 1289 * rather use the standard version and just restart the 1290 * list traversal if we run into the error case. 1291 * TAILQ_FOREACH_SAFE allows safe removal of the current 1292 * list element, but if you have a queue of task management 1293 * commands, all of which have mapping errors, you'll end 1294 * up with recursive calls to this routine and so you could 1295 * wind up removing more than just the current list element. 1296 */ 1297 TAILQ_FOREACH(cm2, &sc->tm_list, cm_link) { 1298 MPI2_SCSI_TASK_MANAGE_REQUEST *req; 1299 1300 /* This command is active, no need to send it again */ 1301 if (cm2->cm_flags & MPS_CM_FLAGS_ACTIVE) 1302 continue; 1303 1304 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)cm2->cm_req; 1305 1306 mps_printf(sc, "%s: sending deferred task management " 1307 "request for handle %#04x SMID %d\n", __func__, 1308 req->DevHandle, req->TaskMID); 1309 1310 error = mpssas_map_tm_request(sc, cm2); 1311 1312 /* 1313 * Check for errors. If we had an error, complete 1314 * this command with an error, and keep going through 1315 * the list until we are able to send at least one 1316 * command or all of them are completed with errors. 1317 * 1318 * We don't want to wind up in a situation where 1319 * we're stalled out with no way for queued task 1320 * management commands to complete. 1321 * 1322 * Note that there is not currently an error path 1323 * back from mpssas_map_tm_request() (which calls 1324 * mps_map_command()) when cm->cm_data == NULL. 1325 * But we still want to check for errors here in 1326 * case the implementation changes, or in case 1327 * there is some reason for a data payload here. 1328 */ 1329 if ((error != 0) 1330 && (error != EINPROGRESS)) { 1331 mpssas_tm_complete(sc, cm, 1332 MPI2_SCSITASKMGMT_RSP_TM_FAILED); 1333 1334 /* 1335 * If we don't currently have any commands 1336 * active, go back to the beginning and see 1337 * if there are any more that can be started. 1338 * Otherwise, we're done here. 1339 */ 1340 if (sc->tm_cmds_active == 0) 1341 goto restart_traversal; 1342 else 1343 break; 1344 } 1345 1346 /* 1347 * If the user only wants one task management command 1348 * active at a time, we're done, since we've 1349 * already successfully sent a command at this point. 1350 */ 1351 if (sc->allow_multiple_tm_cmds == 0) 1352 break; 1353 } 1354 } 1355 1356 return (error); 1357 } 1358 1359 static void 1360 mpssas_action_scsiio(struct mpssas_softc *sassc, union ccb *ccb) 1361 { 1362 MPI2_SCSI_IO_REQUEST *req; 1363 struct ccb_scsiio *csio; 1364 struct mps_softc *sc; 1365 struct mpssas_target *targ; 1366 struct mps_command *cm; 1367 1368 mps_dprint(sassc->sc, MPS_TRACE, "%s\n", __func__); 1369 1370 sc = sassc->sc; 1371 1372 csio = &ccb->csio; 1373 targ = &sassc->targets[csio->ccb_h.target_id]; 1374 if (targ->handle == 0x0) { 1375 csio->ccb_h.status = CAM_SEL_TIMEOUT; 1376 xpt_done(ccb); 1377 return; 1378 } 1379 1380 cm = mps_alloc_command(sc); 1381 if (cm == NULL) { 1382 if ((sassc->flags & MPSSAS_QUEUE_FROZEN) == 0) { 1383 xpt_freeze_simq(sassc->sim, 1); 1384 sassc->flags |= MPSSAS_QUEUE_FROZEN; 1385 } 1386 ccb->ccb_h.status &= ~CAM_SIM_QUEUED; 1387 ccb->ccb_h.status |= CAM_REQUEUE_REQ; 1388 xpt_done(ccb); 1389 return; 1390 } 1391 1392 req = (MPI2_SCSI_IO_REQUEST *)cm->cm_req; 1393 bzero(req, sizeof(*req)); 1394 req->DevHandle = targ->handle; 1395 req->Function = MPI2_FUNCTION_SCSI_IO_REQUEST; 1396 req->MsgFlags = 0; 1397 req->SenseBufferLowAddress = cm->cm_sense_busaddr; 1398 req->SenseBufferLength = MPS_SENSE_LEN; 1399 req->SGLFlags = 0; 1400 req->ChainOffset = 0; 1401 req->SGLOffset0 = 24; /* 32bit word offset to the SGL */ 1402 req->SGLOffset1= 0; 1403 req->SGLOffset2= 0; 1404 req->SGLOffset3= 0; 1405 req->SkipCount = 0; 1406 req->DataLength = csio->dxfer_len; 1407 req->BidirectionalDataLength = 0; 1408 req->IoFlags = csio->cdb_len; 1409 req->EEDPFlags = 0; 1410 1411 /* Note: BiDirectional transfers are not supported */ 1412 switch (csio->ccb_h.flags & CAM_DIR_MASK) { 1413 case CAM_DIR_IN: 1414 req->Control = MPI2_SCSIIO_CONTROL_READ; 1415 cm->cm_flags |= MPS_CM_FLAGS_DATAIN; 1416 break; 1417 case CAM_DIR_OUT: 1418 req->Control = MPI2_SCSIIO_CONTROL_WRITE; 1419 cm->cm_flags |= MPS_CM_FLAGS_DATAOUT; 1420 break; 1421 case CAM_DIR_NONE: 1422 default: 1423 req->Control = MPI2_SCSIIO_CONTROL_NODATATRANSFER; 1424 break; 1425 } 1426 1427 /* 1428 * It looks like the hardware doesn't require an explicit tag 1429 * number for each transaction. SAM Task Management not supported 1430 * at the moment. 1431 */ 1432 switch (csio->tag_action) { 1433 case MSG_HEAD_OF_Q_TAG: 1434 req->Control |= MPI2_SCSIIO_CONTROL_HEADOFQ; 1435 break; 1436 case MSG_ORDERED_Q_TAG: 1437 req->Control |= MPI2_SCSIIO_CONTROL_ORDEREDQ; 1438 break; 1439 case MSG_ACA_TASK: 1440 req->Control |= MPI2_SCSIIO_CONTROL_ACAQ; 1441 break; 1442 case CAM_TAG_ACTION_NONE: 1443 case MSG_SIMPLE_Q_TAG: 1444 default: 1445 req->Control |= MPI2_SCSIIO_CONTROL_SIMPLEQ; 1446 break; 1447 } 1448 1449 if (MPS_SET_LUN(req->LUN, csio->ccb_h.target_lun) != 0) { 1450 mps_free_command(sc, cm); 1451 ccb->ccb_h.status = CAM_LUN_INVALID; 1452 xpt_done(ccb); 1453 return; 1454 } 1455 1456 if (csio->ccb_h.flags & CAM_CDB_POINTER) 1457 bcopy(csio->cdb_io.cdb_ptr, &req->CDB.CDB32[0], csio->cdb_len); 1458 else 1459 bcopy(csio->cdb_io.cdb_bytes, &req->CDB.CDB32[0],csio->cdb_len); 1460 req->IoFlags = csio->cdb_len; 1461 1462 /* 1463 * XXX need to handle S/G lists and physical addresses here. 1464 */ 1465 cm->cm_data = csio->data_ptr; 1466 cm->cm_length = csio->dxfer_len; 1467 cm->cm_sge = &req->SGL; 1468 cm->cm_sglsize = (32 - 24) * 4; 1469 cm->cm_desc.SCSIIO.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO; 1470 cm->cm_desc.SCSIIO.DevHandle = targ->handle; 1471 cm->cm_complete = mpssas_scsiio_complete; 1472 cm->cm_complete_data = ccb; 1473 cm->cm_targ = targ; 1474 1475 sc->io_cmds_active++; 1476 if (sc->io_cmds_active > sc->io_cmds_highwater) 1477 sc->io_cmds_highwater = sc->io_cmds_active; 1478 1479 TAILQ_INSERT_TAIL(&sc->io_list, cm, cm_link); 1480 callout_reset(&cm->cm_callout, (ccb->ccb_h.timeout * hz) / 1000, 1481 mpssas_scsiio_timeout, cm); 1482 1483 mps_map_command(sc, cm); 1484 return; 1485 } 1486 1487 static void 1488 mpssas_scsiio_complete(struct mps_softc *sc, struct mps_command *cm) 1489 { 1490 MPI2_SCSI_IO_REPLY *rep; 1491 union ccb *ccb; 1492 struct mpssas_softc *sassc; 1493 int dir = 0; 1494 1495 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 1496 1497 callout_stop(&cm->cm_callout); 1498 TAILQ_REMOVE(&sc->io_list, cm, cm_link); 1499 sc->io_cmds_active--; 1500 1501 sassc = sc->sassc; 1502 ccb = cm->cm_complete_data; 1503 rep = (MPI2_SCSI_IO_REPLY *)cm->cm_reply; 1504 1505 /* 1506 * XXX KDM if the chain allocation fails, does it matter if we do 1507 * the sync and unload here? It is simpler to do it in every case, 1508 * assuming it doesn't cause problems. 1509 */ 1510 if (cm->cm_data != NULL) { 1511 if (cm->cm_flags & MPS_CM_FLAGS_DATAIN) 1512 dir = BUS_DMASYNC_POSTREAD; 1513 else if (cm->cm_flags & MPS_CM_FLAGS_DATAOUT) 1514 dir = BUS_DMASYNC_POSTWRITE;; 1515 bus_dmamap_sync(sc->buffer_dmat, cm->cm_dmamap, dir); 1516 bus_dmamap_unload(sc->buffer_dmat, cm->cm_dmamap); 1517 } 1518 1519 if ((cm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) { 1520 /* 1521 * We ran into an error after we tried to map the command, 1522 * so we're getting a callback without queueing the command 1523 * to the hardware. So we set the status here, and it will 1524 * be retained below. We'll go through the "fast path", 1525 * because there can be no reply when we haven't actually 1526 * gone out to the hardware. 1527 */ 1528 ccb->ccb_h.status |= CAM_REQUEUE_REQ; 1529 1530 /* 1531 * Currently the only error included in the mask is 1532 * MPS_CM_FLAGS_CHAIN_FAILED, which means we're out of 1533 * chain frames. We need to freeze the queue until we get 1534 * a command that completed without this error, which will 1535 * hopefully have some chain frames attached that we can 1536 * use. If we wanted to get smarter about it, we would 1537 * only unfreeze the queue in this condition when we're 1538 * sure that we're getting some chain frames back. That's 1539 * probably unnecessary. 1540 */ 1541 if ((sassc->flags & MPSSAS_QUEUE_FROZEN) == 0) { 1542 xpt_freeze_simq(sassc->sim, 1); 1543 sassc->flags |= MPSSAS_QUEUE_FROZEN; 1544 mps_dprint(sc, MPS_INFO, "Error sending command, " 1545 "freezing SIM queue\n"); 1546 } 1547 } 1548 1549 /* Take the fast path to completion */ 1550 if (cm->cm_reply == NULL) { 1551 if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INPROG) { 1552 ccb->ccb_h.status = CAM_REQ_CMP; 1553 ccb->csio.scsi_status = SCSI_STATUS_OK; 1554 1555 if (sassc->flags & MPSSAS_QUEUE_FROZEN) { 1556 ccb->ccb_h.status |= CAM_RELEASE_SIMQ; 1557 sassc->flags &= ~MPSSAS_QUEUE_FROZEN; 1558 mps_dprint(sc, MPS_INFO, 1559 "Unfreezing SIM queue\n"); 1560 } 1561 } else { 1562 ccb->ccb_h.status |= CAM_DEV_QFRZN; 1563 xpt_freeze_devq(ccb->ccb_h.path, /*count*/ 1); 1564 } 1565 mps_free_command(sc, cm); 1566 xpt_done(ccb); 1567 return; 1568 } 1569 1570 mps_dprint(sc, MPS_INFO, "(%d:%d:%d) IOCStatus= 0x%x, " 1571 "ScsiStatus= 0x%x, SCSIState= 0x%x TransferCount= 0x%x\n", 1572 xpt_path_path_id(ccb->ccb_h.path), 1573 xpt_path_target_id(ccb->ccb_h.path), 1574 xpt_path_lun_id(ccb->ccb_h.path), rep->IOCStatus, 1575 rep->SCSIStatus, rep->SCSIState, rep->TransferCount); 1576 1577 switch (rep->IOCStatus & MPI2_IOCSTATUS_MASK) { 1578 case MPI2_IOCSTATUS_BUSY: 1579 case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES: 1580 /* 1581 * The controller is overloaded, try waiting a bit for it 1582 * to free up. 1583 */ 1584 ccb->ccb_h.status = CAM_BUSY; 1585 break; 1586 case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN: 1587 ccb->csio.resid = cm->cm_length - rep->TransferCount; 1588 /* FALLTHROUGH */ 1589 case MPI2_IOCSTATUS_SUCCESS: 1590 case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR: 1591 ccb->ccb_h.status = CAM_REQ_CMP; 1592 break; 1593 case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN: 1594 /* resid is ignored for this condition */ 1595 ccb->csio.resid = 0; 1596 ccb->ccb_h.status = CAM_DATA_RUN_ERR; 1597 break; 1598 case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE: 1599 case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE: 1600 ccb->ccb_h.status = CAM_DEV_NOT_THERE; 1601 break; 1602 case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED: 1603 /* 1604 * This is one of the responses that comes back when an I/O 1605 * has been aborted. If it is because of a timeout that we 1606 * initiated, just set the status to CAM_CMD_TIMEOUT. 1607 * Otherwise set it to CAM_REQ_ABORTED. The effect on the 1608 * command is the same (it gets retried, subject to the 1609 * retry counter), the only difference is what gets printed 1610 * on the console. 1611 */ 1612 if (cm->cm_state == MPS_CM_STATE_TIMEDOUT) 1613 ccb->ccb_h.status = CAM_CMD_TIMEOUT; 1614 else 1615 ccb->ccb_h.status = CAM_REQ_ABORTED; 1616 break; 1617 case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED: 1618 case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED: 1619 #if 0 1620 ccb->ccb_h.status = CAM_REQ_ABORTED; 1621 #endif 1622 mps_printf(sc, "(%d:%d:%d) terminated ioc %x scsi %x state %x " 1623 "xfer %u\n", xpt_path_path_id(ccb->ccb_h.path), 1624 xpt_path_target_id(ccb->ccb_h.path), 1625 xpt_path_lun_id(ccb->ccb_h.path), 1626 rep->IOCStatus, rep->SCSIStatus, rep->SCSIState, 1627 rep->TransferCount); 1628 ccb->ccb_h.status = CAM_REQUEUE_REQ; 1629 break; 1630 case MPI2_IOCSTATUS_INVALID_SGL: 1631 mps_print_scsiio_cmd(sc, cm); 1632 ccb->ccb_h.status = CAM_UNREC_HBA_ERROR; 1633 break; 1634 case MPI2_IOCSTATUS_INVALID_FUNCTION: 1635 case MPI2_IOCSTATUS_INTERNAL_ERROR: 1636 case MPI2_IOCSTATUS_INVALID_VPID: 1637 case MPI2_IOCSTATUS_INVALID_FIELD: 1638 case MPI2_IOCSTATUS_INVALID_STATE: 1639 case MPI2_IOCSTATUS_OP_STATE_NOT_SUPPORTED: 1640 case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR: 1641 case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR: 1642 case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: 1643 case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED: 1644 default: 1645 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 1646 } 1647 1648 1649 if ((rep->SCSIState & MPI2_SCSI_STATE_NO_SCSI_STATUS) == 0) { 1650 ccb->csio.scsi_status = rep->SCSIStatus; 1651 1652 switch (rep->SCSIStatus) { 1653 case MPI2_SCSI_STATUS_TASK_SET_FULL: 1654 case MPI2_SCSI_STATUS_CHECK_CONDITION: 1655 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR; 1656 break; 1657 case MPI2_SCSI_STATUS_COMMAND_TERMINATED: 1658 case MPI2_SCSI_STATUS_TASK_ABORTED: 1659 ccb->ccb_h.status = CAM_REQ_ABORTED; 1660 break; 1661 case MPI2_SCSI_STATUS_GOOD: 1662 default: 1663 break; 1664 } 1665 } 1666 1667 if (rep->SCSIState & MPI2_SCSI_STATE_AUTOSENSE_VALID) { 1668 int sense_len; 1669 1670 if (rep->SenseCount < ccb->csio.sense_len) 1671 ccb->csio.sense_resid = ccb->csio.sense_len - 1672 rep->SenseCount; 1673 else 1674 ccb->csio.sense_resid = 0; 1675 1676 sense_len = min(rep->SenseCount, ccb->csio.sense_len - 1677 ccb->csio.sense_resid); 1678 bzero(&ccb->csio.sense_data, sizeof(&ccb->csio.sense_data)); 1679 bcopy(cm->cm_sense, &ccb->csio.sense_data, sense_len); 1680 ccb->ccb_h.status |= CAM_AUTOSNS_VALID; 1681 } 1682 1683 if (rep->SCSIState & MPI2_SCSI_STATE_AUTOSENSE_FAILED) 1684 ccb->ccb_h.status = CAM_AUTOSENSE_FAIL; 1685 1686 if (rep->SCSIState & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) 1687 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 1688 1689 if (sassc->flags & MPSSAS_QUEUE_FROZEN) { 1690 ccb->ccb_h.status |= CAM_RELEASE_SIMQ; 1691 sassc->flags &= ~MPSSAS_QUEUE_FROZEN; 1692 mps_printf(sc, "Command completed, unfreezing SIM queue\n"); 1693 } 1694 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 1695 ccb->ccb_h.status |= CAM_DEV_QFRZN; 1696 xpt_freeze_devq(ccb->ccb_h.path, /*count*/ 1); 1697 } 1698 mps_free_command(sc, cm); 1699 xpt_done(ccb); 1700 } 1701 1702 #if __FreeBSD_version >= 900026 1703 static void 1704 mpssas_smpio_complete(struct mps_softc *sc, struct mps_command *cm) 1705 { 1706 MPI2_SMP_PASSTHROUGH_REPLY *rpl; 1707 MPI2_SMP_PASSTHROUGH_REQUEST *req; 1708 uint64_t sasaddr; 1709 union ccb *ccb; 1710 1711 ccb = cm->cm_complete_data; 1712 1713 /* 1714 * Currently there should be no way we can hit this case. It only 1715 * happens when we have a failure to allocate chain frames, and SMP 1716 * commands require two S/G elements only. That should be handled 1717 * in the standard request size. 1718 */ 1719 if ((cm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) { 1720 mps_printf(sc, "%s: cm_flags = %#x on SMP request!\n", 1721 __func__, cm->cm_flags); 1722 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 1723 goto bailout; 1724 } 1725 1726 rpl = (MPI2_SMP_PASSTHROUGH_REPLY *)cm->cm_reply; 1727 if (rpl == NULL) { 1728 mps_dprint(sc, MPS_INFO, "%s: NULL cm_reply!\n", __func__); 1729 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 1730 goto bailout; 1731 } 1732 1733 req = (MPI2_SMP_PASSTHROUGH_REQUEST *)cm->cm_req; 1734 sasaddr = le32toh(req->SASAddress.Low); 1735 sasaddr |= ((uint64_t)(le32toh(req->SASAddress.High))) << 32; 1736 1737 if ((rpl->IOCStatus & MPI2_IOCSTATUS_MASK) != MPI2_IOCSTATUS_SUCCESS || 1738 rpl->SASStatus != MPI2_SASSTATUS_SUCCESS) { 1739 mps_dprint(sc, MPS_INFO, "%s: IOCStatus %04x SASStatus %02x\n", 1740 __func__, rpl->IOCStatus, rpl->SASStatus); 1741 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 1742 goto bailout; 1743 } 1744 1745 mps_dprint(sc, MPS_INFO, "%s: SMP request to SAS address " 1746 "%#jx completed successfully\n", __func__, 1747 (uintmax_t)sasaddr); 1748 1749 if (ccb->smpio.smp_response[2] == SMP_FR_ACCEPTED) 1750 ccb->ccb_h.status = CAM_REQ_CMP; 1751 else 1752 ccb->ccb_h.status = CAM_SMP_STATUS_ERROR; 1753 1754 bailout: 1755 /* 1756 * We sync in both directions because we had DMAs in the S/G list 1757 * in both directions. 1758 */ 1759 bus_dmamap_sync(sc->buffer_dmat, cm->cm_dmamap, 1760 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 1761 bus_dmamap_unload(sc->buffer_dmat, cm->cm_dmamap); 1762 mps_free_command(sc, cm); 1763 xpt_done(ccb); 1764 } 1765 1766 static void 1767 mpssas_send_smpcmd(struct mpssas_softc *sassc, union ccb *ccb, uint64_t sasaddr) 1768 { 1769 struct mps_command *cm; 1770 uint8_t *request, *response; 1771 MPI2_SMP_PASSTHROUGH_REQUEST *req; 1772 struct mps_softc *sc; 1773 struct sglist *sg; 1774 int error; 1775 1776 sc = sassc->sc; 1777 sg = NULL; 1778 error = 0; 1779 1780 /* 1781 * XXX We don't yet support physical addresses here. 1782 */ 1783 if (ccb->ccb_h.flags & (CAM_DATA_PHYS|CAM_SG_LIST_PHYS)) { 1784 mps_printf(sc, "%s: physical addresses not supported\n", 1785 __func__); 1786 ccb->ccb_h.status = CAM_REQ_INVALID; 1787 xpt_done(ccb); 1788 return; 1789 } 1790 1791 /* 1792 * If the user wants to send an S/G list, check to make sure they 1793 * have single buffers. 1794 */ 1795 if (ccb->ccb_h.flags & CAM_SCATTER_VALID) { 1796 /* 1797 * The chip does not support more than one buffer for the 1798 * request or response. 1799 */ 1800 if ((ccb->smpio.smp_request_sglist_cnt > 1) 1801 || (ccb->smpio.smp_response_sglist_cnt > 1)) { 1802 mps_printf(sc, "%s: multiple request or response " 1803 "buffer segments not supported for SMP\n", 1804 __func__); 1805 ccb->ccb_h.status = CAM_REQ_INVALID; 1806 xpt_done(ccb); 1807 return; 1808 } 1809 1810 /* 1811 * The CAM_SCATTER_VALID flag was originally implemented 1812 * for the XPT_SCSI_IO CCB, which only has one data pointer. 1813 * We have two. So, just take that flag to mean that we 1814 * might have S/G lists, and look at the S/G segment count 1815 * to figure out whether that is the case for each individual 1816 * buffer. 1817 */ 1818 if (ccb->smpio.smp_request_sglist_cnt != 0) { 1819 bus_dma_segment_t *req_sg; 1820 1821 req_sg = (bus_dma_segment_t *)ccb->smpio.smp_request; 1822 request = (uint8_t *)req_sg[0].ds_addr; 1823 } else 1824 request = ccb->smpio.smp_request; 1825 1826 if (ccb->smpio.smp_response_sglist_cnt != 0) { 1827 bus_dma_segment_t *rsp_sg; 1828 1829 rsp_sg = (bus_dma_segment_t *)ccb->smpio.smp_response; 1830 response = (uint8_t *)rsp_sg[0].ds_addr; 1831 } else 1832 response = ccb->smpio.smp_response; 1833 } else { 1834 request = ccb->smpio.smp_request; 1835 response = ccb->smpio.smp_response; 1836 } 1837 1838 cm = mps_alloc_command(sc); 1839 if (cm == NULL) { 1840 mps_printf(sc, "%s: cannot allocate command\n", __func__); 1841 ccb->ccb_h.status = CAM_RESRC_UNAVAIL; 1842 xpt_done(ccb); 1843 return; 1844 } 1845 1846 req = (MPI2_SMP_PASSTHROUGH_REQUEST *)cm->cm_req; 1847 bzero(req, sizeof(*req)); 1848 req->Function = MPI2_FUNCTION_SMP_PASSTHROUGH; 1849 1850 /* Allow the chip to use any route to this SAS address. */ 1851 req->PhysicalPort = 0xff; 1852 1853 req->RequestDataLength = ccb->smpio.smp_request_len; 1854 req->SGLFlags = 1855 MPI2_SGLFLAGS_SYSTEM_ADDRESS_SPACE | MPI2_SGLFLAGS_SGL_TYPE_MPI; 1856 1857 mps_dprint(sc, MPS_INFO, "%s: sending SMP request to SAS " 1858 "address %#jx\n", __func__, (uintmax_t)sasaddr); 1859 1860 mpi_init_sge(cm, req, &req->SGL); 1861 1862 /* 1863 * Set up a uio to pass into mps_map_command(). This allows us to 1864 * do one map command, and one busdma call in there. 1865 */ 1866 cm->cm_uio.uio_iov = cm->cm_iovec; 1867 cm->cm_uio.uio_iovcnt = 2; 1868 cm->cm_uio.uio_segflg = UIO_SYSSPACE; 1869 1870 /* 1871 * The read/write flag isn't used by busdma, but set it just in 1872 * case. This isn't exactly accurate, either, since we're going in 1873 * both directions. 1874 */ 1875 cm->cm_uio.uio_rw = UIO_WRITE; 1876 1877 cm->cm_iovec[0].iov_base = request; 1878 cm->cm_iovec[0].iov_len = req->RequestDataLength; 1879 cm->cm_iovec[1].iov_base = response; 1880 cm->cm_iovec[1].iov_len = ccb->smpio.smp_response_len; 1881 1882 cm->cm_uio.uio_resid = cm->cm_iovec[0].iov_len + 1883 cm->cm_iovec[1].iov_len; 1884 1885 /* 1886 * Trigger a warning message in mps_data_cb() for the user if we 1887 * wind up exceeding two S/G segments. The chip expects one 1888 * segment for the request and another for the response. 1889 */ 1890 cm->cm_max_segs = 2; 1891 1892 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 1893 cm->cm_complete = mpssas_smpio_complete; 1894 cm->cm_complete_data = ccb; 1895 1896 /* 1897 * Tell the mapping code that we're using a uio, and that this is 1898 * an SMP passthrough request. There is a little special-case 1899 * logic there (in mps_data_cb()) to handle the bidirectional 1900 * transfer. 1901 */ 1902 cm->cm_flags |= MPS_CM_FLAGS_USE_UIO | MPS_CM_FLAGS_SMP_PASS | 1903 MPS_CM_FLAGS_DATAIN | MPS_CM_FLAGS_DATAOUT; 1904 1905 /* The chip data format is little endian. */ 1906 req->SASAddress.High = htole32(sasaddr >> 32); 1907 req->SASAddress.Low = htole32(sasaddr); 1908 1909 /* 1910 * XXX Note that we don't have a timeout/abort mechanism here. 1911 * From the manual, it looks like task management requests only 1912 * work for SCSI IO and SATA passthrough requests. We may need to 1913 * have a mechanism to retry requests in the event of a chip reset 1914 * at least. Hopefully the chip will insure that any errors short 1915 * of that are relayed back to the driver. 1916 */ 1917 error = mps_map_command(sc, cm); 1918 if ((error != 0) && (error != EINPROGRESS)) { 1919 mps_printf(sc, "%s: error %d returned from mps_map_command()\n", 1920 __func__, error); 1921 goto bailout_error; 1922 } 1923 1924 return; 1925 1926 bailout_error: 1927 mps_free_command(sc, cm); 1928 ccb->ccb_h.status = CAM_RESRC_UNAVAIL; 1929 xpt_done(ccb); 1930 return; 1931 1932 } 1933 1934 static void 1935 mpssas_action_smpio(struct mpssas_softc *sassc, union ccb *ccb) 1936 { 1937 struct mps_softc *sc; 1938 struct mpssas_target *targ; 1939 uint64_t sasaddr = 0; 1940 1941 sc = sassc->sc; 1942 1943 /* 1944 * Make sure the target exists. 1945 */ 1946 targ = &sassc->targets[ccb->ccb_h.target_id]; 1947 if (targ->handle == 0x0) { 1948 mps_printf(sc, "%s: target %d does not exist!\n", __func__, 1949 ccb->ccb_h.target_id); 1950 ccb->ccb_h.status = CAM_SEL_TIMEOUT; 1951 xpt_done(ccb); 1952 return; 1953 } 1954 1955 /* 1956 * If this device has an embedded SMP target, we'll talk to it 1957 * directly. 1958 * figure out what the expander's address is. 1959 */ 1960 if ((targ->devinfo & MPI2_SAS_DEVICE_INFO_SMP_TARGET) != 0) 1961 sasaddr = targ->sasaddr; 1962 1963 /* 1964 * If we don't have a SAS address for the expander yet, try 1965 * grabbing it from the page 0x83 information cached in the 1966 * transport layer for this target. LSI expanders report the 1967 * expander SAS address as the port-associated SAS address in 1968 * Inquiry VPD page 0x83. Maxim expanders don't report it in page 1969 * 0x83. 1970 * 1971 * XXX KDM disable this for now, but leave it commented out so that 1972 * it is obvious that this is another possible way to get the SAS 1973 * address. 1974 * 1975 * The parent handle method below is a little more reliable, and 1976 * the other benefit is that it works for devices other than SES 1977 * devices. So you can send a SMP request to a da(4) device and it 1978 * will get routed to the expander that device is attached to. 1979 * (Assuming the da(4) device doesn't contain an SMP target...) 1980 */ 1981 #if 0 1982 if (sasaddr == 0) 1983 sasaddr = xpt_path_sas_addr(ccb->ccb_h.path); 1984 #endif 1985 1986 /* 1987 * If we still don't have a SAS address for the expander, look for 1988 * the parent device of this device, which is probably the expander. 1989 */ 1990 if (sasaddr == 0) { 1991 struct mpssas_target *parent_target; 1992 1993 if (targ->parent_handle == 0x0) { 1994 mps_printf(sc, "%s: handle %d does not have a valid " 1995 "parent handle!\n", __func__, targ->handle); 1996 ccb->ccb_h.status = CAM_REQ_INVALID; 1997 goto bailout; 1998 } 1999 parent_target = mpssas_find_target(sassc, 0, 2000 targ->parent_handle); 2001 2002 if (parent_target == NULL) { 2003 mps_printf(sc, "%s: handle %d does not have a valid " 2004 "parent target!\n", __func__, targ->handle); 2005 ccb->ccb_h.status = CAM_REQ_INVALID; 2006 goto bailout; 2007 } 2008 2009 if ((parent_target->devinfo & 2010 MPI2_SAS_DEVICE_INFO_SMP_TARGET) == 0) { 2011 mps_printf(sc, "%s: handle %d parent %d does not " 2012 "have an SMP target!\n", __func__, 2013 targ->handle, parent_target->handle); 2014 ccb->ccb_h.status = CAM_REQ_INVALID; 2015 goto bailout; 2016 2017 } 2018 2019 sasaddr = parent_target->sasaddr; 2020 } 2021 2022 if (sasaddr == 0) { 2023 mps_printf(sc, "%s: unable to find SAS address for handle %d\n", 2024 __func__, targ->handle); 2025 ccb->ccb_h.status = CAM_REQ_INVALID; 2026 goto bailout; 2027 } 2028 mpssas_send_smpcmd(sassc, ccb, sasaddr); 2029 2030 return; 2031 2032 bailout: 2033 xpt_done(ccb); 2034 2035 } 2036 2037 #endif /* __FreeBSD_version >= 900026 */ 2038 2039 static void 2040 mpssas_action_resetdev(struct mpssas_softc *sassc, union ccb *ccb) 2041 { 2042 struct mps_softc *sc; 2043 struct mps_command *cm; 2044 struct mpssas_target *targ; 2045 2046 sc = sassc->sc; 2047 targ = &sassc->targets[ccb->ccb_h.target_id]; 2048 2049 if (targ->flags & MPSSAS_TARGET_INRECOVERY) { 2050 ccb->ccb_h.status = CAM_RESRC_UNAVAIL; 2051 xpt_done(ccb); 2052 return; 2053 } 2054 2055 cm = mps_alloc_command(sc); 2056 if (cm == NULL) { 2057 mps_printf(sc, "%s: cannot alloc command\n", __func__); 2058 ccb->ccb_h.status = CAM_RESRC_UNAVAIL; 2059 xpt_done(ccb); 2060 return; 2061 } 2062 2063 cm->cm_targ = targ; 2064 cm->cm_complete = mpssas_resetdev_complete; 2065 cm->cm_complete_data = ccb; 2066 2067 mpssas_resetdev(sassc, cm); 2068 } 2069 2070 static void 2071 mpssas_resetdev(struct mpssas_softc *sassc, struct mps_command *cm) 2072 { 2073 MPI2_SCSI_TASK_MANAGE_REQUEST *req; 2074 struct mps_softc *sc; 2075 2076 mps_dprint(sassc->sc, MPS_TRACE, "%s\n", __func__); 2077 2078 sc = sassc->sc; 2079 2080 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)cm->cm_req; 2081 req->DevHandle = cm->cm_targ->handle; 2082 req->Function = MPI2_FUNCTION_SCSI_TASK_MGMT; 2083 req->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET; 2084 2085 /* SAS Hard Link Reset / SATA Link Reset */ 2086 req->MsgFlags = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET; 2087 2088 cm->cm_data = NULL; 2089 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE; 2090 2091 mpssas_issue_tm_request(sc, cm); 2092 } 2093 2094 static void 2095 mpssas_resetdev_complete(struct mps_softc *sc, struct mps_command *cm) 2096 { 2097 MPI2_SCSI_TASK_MANAGE_REPLY *resp; 2098 union ccb *ccb; 2099 2100 mps_dprint(sc, MPS_TRACE, "%s\n", __func__); 2101 2102 resp = (MPI2_SCSI_TASK_MANAGE_REPLY *)cm->cm_reply; 2103 ccb = cm->cm_complete_data; 2104 2105 if ((cm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) { 2106 MPI2_SCSI_TASK_MANAGE_REQUEST *req; 2107 2108 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)cm->cm_req; 2109 2110 mps_printf(sc, "%s: cm_flags = %#x for reset of handle %#04x! " 2111 "This should not happen!\n", __func__, cm->cm_flags, 2112 req->DevHandle); 2113 2114 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 2115 goto bailout; 2116 } 2117 2118 printf("resetdev complete IOCStatus= 0x%x ResponseCode= 0x%x\n", 2119 resp->IOCStatus, resp->ResponseCode); 2120 2121 if (resp->ResponseCode == MPI2_SCSITASKMGMT_RSP_TM_COMPLETE) 2122 ccb->ccb_h.status = CAM_REQ_CMP; 2123 else 2124 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 2125 2126 bailout: 2127 mpssas_complete_tm_request(sc, cm, /*free_cm*/ 1); 2128 2129 xpt_done(ccb); 2130 } 2131 2132 static void 2133 mpssas_poll(struct cam_sim *sim) 2134 { 2135 struct mpssas_softc *sassc; 2136 2137 sassc = cam_sim_softc(sim); 2138 mps_intr_locked(sassc->sc); 2139 } 2140 2141 static void 2142 mpssas_freeze_device(struct mpssas_softc *sassc, struct mpssas_target *targ) 2143 { 2144 } 2145 2146 static void 2147 mpssas_unfreeze_device(struct mpssas_softc *sassc, struct mpssas_target *targ) 2148 { 2149 } 2150 2151