2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2009 Yahoo! Inc.
5 * Copyright (c) 2011-2015 LSI Corp.
6 * Copyright (c) 2013-2015 Avago Technologies
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * Avago Technologies (LSI) MPT-Fusion Host Adapter FreeBSD
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD$");
38 /* Communications core for Avago Technologies (LSI) MPT2 */
40 /* TODO Move headers to mpsvar */
41 #include <sys/types.h>
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/kernel.h>
45 #include <sys/selinfo.h>
46 #include <sys/module.h>
50 #include <sys/malloc.h>
52 #include <sys/sysctl.h>
53 #include <sys/endian.h>
54 #include <sys/queue.h>
55 #include <sys/kthread.h>
56 #include <sys/taskqueue.h>
59 #include <machine/bus.h>
60 #include <machine/resource.h>
63 #include <machine/stdarg.h>
66 #include <cam/cam_ccb.h>
67 #include <cam/cam_xpt.h>
68 #include <cam/cam_debug.h>
69 #include <cam/cam_sim.h>
70 #include <cam/cam_xpt_sim.h>
71 #include <cam/cam_xpt_periph.h>
72 #include <cam/cam_periph.h>
73 #include <cam/scsi/scsi_all.h>
74 #include <cam/scsi/scsi_message.h>
75 #if __FreeBSD_version >= 900026
76 #include <cam/scsi/smp_all.h>
79 #include <dev/mps/mpi/mpi2_type.h>
80 #include <dev/mps/mpi/mpi2.h>
81 #include <dev/mps/mpi/mpi2_ioc.h>
82 #include <dev/mps/mpi/mpi2_sas.h>
83 #include <dev/mps/mpi/mpi2_cnfg.h>
84 #include <dev/mps/mpi/mpi2_init.h>
85 #include <dev/mps/mpi/mpi2_tool.h>
86 #include <dev/mps/mps_ioctl.h>
87 #include <dev/mps/mpsvar.h>
88 #include <dev/mps/mps_table.h>
89 #include <dev/mps/mps_sas.h>
91 #define MPSSAS_DISCOVERY_TIMEOUT 20
92 #define MPSSAS_MAX_DISCOVERY_TIMEOUTS 10 /* 200 seconds */
95 * static array to check SCSI OpCode for EEDP protection bits
97 #define PRO_R MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP
98 #define PRO_W MPI2_SCSIIO_EEDPFLAGS_INSERT_OP
99 #define PRO_V MPI2_SCSIIO_EEDPFLAGS_INSERT_OP
100 static uint8_t op_code_prot[256] = {
101 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
102 0, 0, 0, 0, 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, PRO_W, 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 0, 0, 0, 0, 0, 0, 0, 0, PRO_R, 0, PRO_W, 0, 0, 0, PRO_W, PRO_V,
110 0, 0, 0, PRO_W, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
111 0, 0, 0, 0, 0, 0, 0, 0, PRO_R, 0, PRO_W, 0, 0, 0, PRO_W, PRO_V,
112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
113 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
114 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
115 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
116 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
119 MALLOC_DEFINE(M_MPSSAS, "MPSSAS", "MPS SAS memory");
121 static void mpssas_remove_device(struct mps_softc *, struct mps_command *);
122 static void mpssas_remove_complete(struct mps_softc *, struct mps_command *);
123 static void mpssas_action(struct cam_sim *sim, union ccb *ccb);
124 static void mpssas_poll(struct cam_sim *sim);
125 static int mpssas_send_abort(struct mps_softc *sc, struct mps_command *tm,
126 struct mps_command *cm);
127 static void mpssas_scsiio_timeout(void *data);
128 static void mpssas_abort_complete(struct mps_softc *sc, struct mps_command *cm);
129 static void mpssas_direct_drive_io(struct mpssas_softc *sassc,
130 struct mps_command *cm, union ccb *ccb);
131 static void mpssas_action_scsiio(struct mpssas_softc *, union ccb *);
132 static void mpssas_scsiio_complete(struct mps_softc *, struct mps_command *);
133 static void mpssas_action_resetdev(struct mpssas_softc *, union ccb *);
134 #if __FreeBSD_version >= 900026
135 static void mpssas_smpio_complete(struct mps_softc *sc, struct mps_command *cm);
136 static void mpssas_send_smpcmd(struct mpssas_softc *sassc, union ccb *ccb,
138 static void mpssas_action_smpio(struct mpssas_softc *sassc, union ccb *ccb);
139 #endif //FreeBSD_version >= 900026
140 static void mpssas_resetdev_complete(struct mps_softc *, struct mps_command *);
141 static void mpssas_async(void *callback_arg, uint32_t code,
142 struct cam_path *path, void *arg);
143 #if (__FreeBSD_version < 901503) || \
144 ((__FreeBSD_version >= 1000000) && (__FreeBSD_version < 1000006))
145 static void mpssas_check_eedp(struct mps_softc *sc, struct cam_path *path,
146 struct ccb_getdev *cgd);
147 static void mpssas_read_cap_done(struct cam_periph *periph, union ccb *done_ccb);
149 static int mpssas_send_portenable(struct mps_softc *sc);
150 static void mpssas_portenable_complete(struct mps_softc *sc,
151 struct mps_command *cm);
153 struct mpssas_target *
154 mpssas_find_target_by_handle(struct mpssas_softc *sassc, int start, uint16_t handle)
156 struct mpssas_target *target;
159 for (i = start; i < sassc->maxtargets; i++) {
160 target = &sassc->targets[i];
161 if (target->handle == handle)
168 /* we need to freeze the simq during attach and diag reset, to avoid failing
169 * commands before device handles have been found by discovery. Since
170 * discovery involves reading config pages and possibly sending commands,
171 * discovery actions may continue even after we receive the end of discovery
172 * event, so refcount discovery actions instead of assuming we can unfreeze
173 * the simq when we get the event.
176 mpssas_startup_increment(struct mpssas_softc *sassc)
178 MPS_FUNCTRACE(sassc->sc);
180 if ((sassc->flags & MPSSAS_IN_STARTUP) != 0) {
181 if (sassc->startup_refcount++ == 0) {
182 /* just starting, freeze the simq */
183 mps_dprint(sassc->sc, MPS_INIT,
184 "%s freezing simq\n", __func__);
185 #if __FreeBSD_version >= 1000039
188 xpt_freeze_simq(sassc->sim, 1);
190 mps_dprint(sassc->sc, MPS_INIT, "%s refcount %u\n", __func__,
191 sassc->startup_refcount);
196 mpssas_release_simq_reinit(struct mpssas_softc *sassc)
198 if (sassc->flags & MPSSAS_QUEUE_FROZEN) {
199 sassc->flags &= ~MPSSAS_QUEUE_FROZEN;
200 xpt_release_simq(sassc->sim, 1);
201 mps_dprint(sassc->sc, MPS_INFO, "Unfreezing SIM queue\n");
206 mpssas_startup_decrement(struct mpssas_softc *sassc)
208 MPS_FUNCTRACE(sassc->sc);
210 if ((sassc->flags & MPSSAS_IN_STARTUP) != 0) {
211 if (--sassc->startup_refcount == 0) {
212 /* finished all discovery-related actions, release
213 * the simq and rescan for the latest topology.
215 mps_dprint(sassc->sc, MPS_INIT,
216 "%s releasing simq\n", __func__);
217 sassc->flags &= ~MPSSAS_IN_STARTUP;
218 xpt_release_simq(sassc->sim, 1);
219 #if __FreeBSD_version >= 1000039
222 mpssas_rescan_target(sassc->sc, NULL);
225 mps_dprint(sassc->sc, MPS_INIT, "%s refcount %u\n", __func__,
226 sassc->startup_refcount);
231 * The firmware requires us to stop sending commands when we're doing task
233 * XXX The logic for serializing the device has been made lazy and moved to
234 * mpssas_prepare_for_tm().
237 mpssas_alloc_tm(struct mps_softc *sc)
239 MPI2_SCSI_TASK_MANAGE_REQUEST *req;
240 struct mps_command *tm;
242 tm = mps_alloc_high_priority_command(sc);
246 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
247 req->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
252 mpssas_free_tm(struct mps_softc *sc, struct mps_command *tm)
254 int target_id = 0xFFFFFFFF;
260 * For TM's the devq is frozen for the device. Unfreeze it here and
261 * free the resources used for freezing the devq. Must clear the
262 * INRESET flag as well or scsi I/O will not work.
264 if (tm->cm_targ != NULL) {
265 tm->cm_targ->flags &= ~MPSSAS_TARGET_INRESET;
266 target_id = tm->cm_targ->tid;
269 mps_dprint(sc, MPS_INFO, "Unfreezing devq for target ID %d\n",
271 xpt_release_devq(tm->cm_ccb->ccb_h.path, 1, TRUE);
272 xpt_free_path(tm->cm_ccb->ccb_h.path);
273 xpt_free_ccb(tm->cm_ccb);
276 mps_free_high_priority_command(sc, tm);
280 mpssas_rescan_target(struct mps_softc *sc, struct mpssas_target *targ)
282 struct mpssas_softc *sassc = sc->sassc;
284 target_id_t targetid;
288 pathid = cam_sim_path(sassc->sim);
290 targetid = CAM_TARGET_WILDCARD;
292 targetid = targ - sassc->targets;
295 * Allocate a CCB and schedule a rescan.
297 ccb = xpt_alloc_ccb_nowait();
299 mps_dprint(sc, MPS_ERROR, "unable to alloc CCB for rescan\n");
303 if (xpt_create_path(&ccb->ccb_h.path, NULL, pathid,
304 targetid, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
305 mps_dprint(sc, MPS_ERROR, "unable to create path for rescan\n");
310 if (targetid == CAM_TARGET_WILDCARD)
311 ccb->ccb_h.func_code = XPT_SCAN_BUS;
313 ccb->ccb_h.func_code = XPT_SCAN_TGT;
315 mps_dprint(sc, MPS_TRACE, "%s targetid %u\n", __func__, targetid);
320 mpssas_log_command(struct mps_command *cm, u_int level, const char *fmt, ...)
330 /* No need to be in here if debugging isn't enabled */
331 if ((cm->cm_sc->mps_debug & level) == 0)
334 sbuf_new(&sb, str, sizeof(str), 0);
338 if (cm->cm_ccb != NULL) {
339 xpt_path_string(cm->cm_ccb->csio.ccb_h.path, path_str,
341 sbuf_cat(&sb, path_str);
342 if (cm->cm_ccb->ccb_h.func_code == XPT_SCSI_IO) {
343 scsi_command_string(&cm->cm_ccb->csio, &sb);
344 sbuf_printf(&sb, "length %d ",
345 cm->cm_ccb->csio.dxfer_len);
349 sbuf_printf(&sb, "(noperiph:%s%d:%u:%u:%u): ",
350 cam_sim_name(cm->cm_sc->sassc->sim),
351 cam_sim_unit(cm->cm_sc->sassc->sim),
352 cam_sim_bus(cm->cm_sc->sassc->sim),
353 cm->cm_targ ? cm->cm_targ->tid : 0xFFFFFFFF,
357 sbuf_printf(&sb, "SMID %u ", cm->cm_desc.Default.SMID);
358 sbuf_vprintf(&sb, fmt, ap);
360 mps_print_field(cm->cm_sc, "%s", sbuf_data(&sb));
367 mpssas_remove_volume(struct mps_softc *sc, struct mps_command *tm)
369 MPI2_SCSI_TASK_MANAGE_REPLY *reply;
370 struct mpssas_target *targ;
375 reply = (MPI2_SCSI_TASK_MANAGE_REPLY *)tm->cm_reply;
376 handle = (uint16_t)(uintptr_t)tm->cm_complete_data;
380 /* XXX retry the remove after the diag reset completes? */
381 mps_dprint(sc, MPS_FAULT,
382 "%s NULL reply resetting device 0x%04x\n", __func__,
384 mpssas_free_tm(sc, tm);
388 if ((le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK) !=
389 MPI2_IOCSTATUS_SUCCESS) {
390 mps_dprint(sc, MPS_ERROR,
391 "IOCStatus = 0x%x while resetting device 0x%x\n",
392 le16toh(reply->IOCStatus), handle);
395 mps_dprint(sc, MPS_XINFO,
396 "Reset aborted %u commands\n", reply->TerminationCount);
397 mps_free_reply(sc, tm->cm_reply_data);
398 tm->cm_reply = NULL; /* Ensures the reply won't get re-freed */
400 mps_dprint(sc, MPS_XINFO,
401 "clearing target %u handle 0x%04x\n", targ->tid, handle);
404 * Don't clear target if remove fails because things will get confusing.
405 * Leave the devname and sasaddr intact so that we know to avoid reusing
406 * this target id if possible, and so we can assign the same target id
407 * to this device if it comes back in the future.
409 if ((le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK) ==
410 MPI2_IOCSTATUS_SUCCESS) {
413 targ->encl_handle = 0x0;
414 targ->encl_slot = 0x0;
415 targ->exp_dev_handle = 0x0;
417 targ->linkrate = 0x0;
422 mpssas_free_tm(sc, tm);
427 * No Need to call "MPI2_SAS_OP_REMOVE_DEVICE" For Volume removal.
428 * Otherwise Volume Delete is same as Bare Drive Removal.
431 mpssas_prepare_volume_remove(struct mpssas_softc *sassc, uint16_t handle)
433 MPI2_SCSI_TASK_MANAGE_REQUEST *req;
434 struct mps_softc *sc;
435 struct mps_command *tm;
436 struct mpssas_target *targ = NULL;
438 MPS_FUNCTRACE(sassc->sc);
443 * If this is a WD controller, determine if the disk should be exposed
444 * to the OS or not. If disk should be exposed, return from this
445 * function without doing anything.
447 if (sc->WD_available && (sc->WD_hide_expose ==
448 MPS_WD_EXPOSE_ALWAYS)) {
453 targ = mpssas_find_target_by_handle(sassc, 0, handle);
455 /* FIXME: what is the action? */
456 /* We don't know about this device? */
457 mps_dprint(sc, MPS_ERROR,
458 "%s %d : invalid handle 0x%x \n", __func__,__LINE__, handle);
462 targ->flags |= MPSSAS_TARGET_INREMOVAL;
464 tm = mpssas_alloc_tm(sc);
466 mps_dprint(sc, MPS_ERROR,
467 "%s: command alloc failure\n", __func__);
471 mpssas_rescan_target(sc, targ);
473 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
474 req->DevHandle = targ->handle;
475 req->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
477 /* SAS Hard Link Reset / SATA Link Reset */
478 req->MsgFlags = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
482 tm->cm_complete = mpssas_remove_volume;
483 tm->cm_complete_data = (void *)(uintptr_t)handle;
485 mps_dprint(sc, MPS_INFO, "%s: Sending reset for target ID %d\n",
486 __func__, targ->tid);
487 mpssas_prepare_for_tm(sc, tm, targ, CAM_LUN_WILDCARD);
489 mps_map_command(sc, tm);
493 * The MPT2 firmware performs debounce on the link to avoid transient link
494 * errors and false removals. When it does decide that link has been lost
495 * and a device need to go away, it expects that the host will perform a
496 * target reset and then an op remove. The reset has the side-effect of
497 * aborting any outstanding requests for the device, which is required for
498 * the op-remove to succeed. It's not clear if the host should check for
499 * the device coming back alive after the reset.
502 mpssas_prepare_remove(struct mpssas_softc *sassc, uint16_t handle)
504 MPI2_SCSI_TASK_MANAGE_REQUEST *req;
505 struct mps_softc *sc;
506 struct mps_command *cm;
507 struct mpssas_target *targ = NULL;
509 MPS_FUNCTRACE(sassc->sc);
513 targ = mpssas_find_target_by_handle(sassc, 0, handle);
515 /* FIXME: what is the action? */
516 /* We don't know about this device? */
517 mps_dprint(sc, MPS_ERROR,
518 "%s : invalid handle 0x%x \n", __func__, handle);
522 targ->flags |= MPSSAS_TARGET_INREMOVAL;
524 cm = mpssas_alloc_tm(sc);
526 mps_dprint(sc, MPS_ERROR,
527 "%s: command alloc failure\n", __func__);
531 mpssas_rescan_target(sc, targ);
533 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)cm->cm_req;
534 memset(req, 0, sizeof(*req));
535 req->DevHandle = htole16(targ->handle);
536 req->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
538 /* SAS Hard Link Reset / SATA Link Reset */
539 req->MsgFlags = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
543 cm->cm_complete = mpssas_remove_device;
544 cm->cm_complete_data = (void *)(uintptr_t)handle;
546 mps_dprint(sc, MPS_INFO, "%s: Sending reset for target ID %d\n",
547 __func__, targ->tid);
548 mpssas_prepare_for_tm(sc, cm, targ, CAM_LUN_WILDCARD);
550 mps_map_command(sc, cm);
554 mpssas_remove_device(struct mps_softc *sc, struct mps_command *tm)
556 MPI2_SCSI_TASK_MANAGE_REPLY *reply;
557 MPI2_SAS_IOUNIT_CONTROL_REQUEST *req;
558 struct mpssas_target *targ;
559 struct mps_command *next_cm;
564 reply = (MPI2_SCSI_TASK_MANAGE_REPLY *)tm->cm_reply;
565 handle = (uint16_t)(uintptr_t)tm->cm_complete_data;
569 * Currently there should be no way we can hit this case. It only
570 * happens when we have a failure to allocate chain frames, and
571 * task management commands don't have S/G lists.
573 if ((tm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) {
574 mps_dprint(sc, MPS_ERROR,
575 "%s: cm_flags = %#x for remove of handle %#04x! "
576 "This should not happen!\n", __func__, tm->cm_flags,
581 /* XXX retry the remove after the diag reset completes? */
582 mps_dprint(sc, MPS_FAULT,
583 "%s NULL reply resetting device 0x%04x\n", __func__,
585 mpssas_free_tm(sc, tm);
589 if ((le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK) !=
590 MPI2_IOCSTATUS_SUCCESS) {
591 mps_dprint(sc, MPS_ERROR,
592 "IOCStatus = 0x%x while resetting device 0x%x\n",
593 le16toh(reply->IOCStatus), handle);
596 mps_dprint(sc, MPS_XINFO, "Reset aborted %u commands\n",
597 le32toh(reply->TerminationCount));
598 mps_free_reply(sc, tm->cm_reply_data);
599 tm->cm_reply = NULL; /* Ensures the reply won't get re-freed */
601 /* Reuse the existing command */
602 req = (MPI2_SAS_IOUNIT_CONTROL_REQUEST *)tm->cm_req;
603 memset(req, 0, sizeof(*req));
604 req->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
605 req->Operation = MPI2_SAS_OP_REMOVE_DEVICE;
606 req->DevHandle = htole16(handle);
608 tm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
609 tm->cm_complete = mpssas_remove_complete;
610 tm->cm_complete_data = (void *)(uintptr_t)handle;
612 mps_map_command(sc, tm);
614 mps_dprint(sc, MPS_XINFO, "clearing target %u handle 0x%04x\n",
616 TAILQ_FOREACH_SAFE(tm, &targ->commands, cm_link, next_cm) {
619 mps_dprint(sc, MPS_XINFO, "Completing missed command %p\n", tm);
620 ccb = tm->cm_complete_data;
621 mpssas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
622 mpssas_scsiio_complete(sc, tm);
627 mpssas_remove_complete(struct mps_softc *sc, struct mps_command *tm)
629 MPI2_SAS_IOUNIT_CONTROL_REPLY *reply;
631 struct mpssas_target *targ;
632 struct mpssas_lun *lun;
636 reply = (MPI2_SAS_IOUNIT_CONTROL_REPLY *)tm->cm_reply;
637 handle = (uint16_t)(uintptr_t)tm->cm_complete_data;
640 * Currently there should be no way we can hit this case. It only
641 * happens when we have a failure to allocate chain frames, and
642 * task management commands don't have S/G lists.
644 if ((tm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) {
645 mps_dprint(sc, MPS_XINFO,
646 "%s: cm_flags = %#x for remove of handle %#04x! "
647 "This should not happen!\n", __func__, tm->cm_flags,
649 mpssas_free_tm(sc, tm);
654 /* most likely a chip reset */
655 mps_dprint(sc, MPS_FAULT,
656 "%s NULL reply removing device 0x%04x\n", __func__, handle);
657 mpssas_free_tm(sc, tm);
661 mps_dprint(sc, MPS_XINFO,
662 "%s on handle 0x%04x, IOCStatus= 0x%x\n", __func__,
663 handle, le16toh(reply->IOCStatus));
666 * Don't clear target if remove fails because things will get confusing.
667 * Leave the devname and sasaddr intact so that we know to avoid reusing
668 * this target id if possible, and so we can assign the same target id
669 * to this device if it comes back in the future.
671 if ((le16toh(reply->IOCStatus) & MPI2_IOCSTATUS_MASK) ==
672 MPI2_IOCSTATUS_SUCCESS) {
675 targ->encl_handle = 0x0;
676 targ->encl_slot = 0x0;
677 targ->exp_dev_handle = 0x0;
679 targ->linkrate = 0x0;
683 while(!SLIST_EMPTY(&targ->luns)) {
684 lun = SLIST_FIRST(&targ->luns);
685 SLIST_REMOVE_HEAD(&targ->luns, lun_link);
691 mpssas_free_tm(sc, tm);
695 mpssas_register_events(struct mps_softc *sc)
697 u32 events[MPI2_EVENT_NOTIFY_EVENTMASK_WORDS];
700 setbit(events, MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE);
701 setbit(events, MPI2_EVENT_SAS_DISCOVERY);
702 setbit(events, MPI2_EVENT_SAS_BROADCAST_PRIMITIVE);
703 setbit(events, MPI2_EVENT_SAS_INIT_DEVICE_STATUS_CHANGE);
704 setbit(events, MPI2_EVENT_SAS_INIT_TABLE_OVERFLOW);
705 setbit(events, MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST);
706 setbit(events, MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE);
707 setbit(events, MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST);
708 setbit(events, MPI2_EVENT_IR_VOLUME);
709 setbit(events, MPI2_EVENT_IR_PHYSICAL_DISK);
710 setbit(events, MPI2_EVENT_IR_OPERATION_STATUS);
711 setbit(events, MPI2_EVENT_LOG_ENTRY_ADDED);
713 mps_register_events(sc, events, mpssas_evt_handler, NULL,
714 &sc->sassc->mpssas_eh);
720 mps_attach_sas(struct mps_softc *sc)
722 struct mpssas_softc *sassc;
724 int unit, error = 0, reqs;
727 mps_dprint(sc, MPS_INIT, "%s entered\n", __func__);
729 sassc = malloc(sizeof(struct mpssas_softc), M_MPT2, M_WAITOK|M_ZERO);
731 mps_dprint(sc, MPS_INIT|MPS_ERROR,
732 "Cannot allocate SAS controller memory\n");
737 * XXX MaxTargets could change during a reinit. Since we don't
738 * resize the targets[] array during such an event, cache the value
739 * of MaxTargets here so that we don't get into trouble later. This
740 * should move into the reinit logic.
742 sassc->maxtargets = sc->facts->MaxTargets + sc->facts->MaxVolumes;
743 sassc->targets = malloc(sizeof(struct mpssas_target) *
744 sassc->maxtargets, M_MPT2, M_WAITOK|M_ZERO);
745 if(!sassc->targets) {
746 mps_dprint(sc, MPS_INIT|MPS_ERROR,
747 "Cannot allocate SAS target memory\n");
754 reqs = sc->num_reqs - sc->num_prireqs - 1;
755 if ((sassc->devq = cam_simq_alloc(reqs)) == NULL) {
756 mps_dprint(sc, MPS_ERROR, "Cannot allocate SIMQ\n");
761 unit = device_get_unit(sc->mps_dev);
762 sassc->sim = cam_sim_alloc(mpssas_action, mpssas_poll, "mps", sassc,
763 unit, &sc->mps_mtx, reqs, reqs, sassc->devq);
764 if (sassc->sim == NULL) {
765 mps_dprint(sc, MPS_INIT|MPS_ERROR, "Cannot allocate SIM\n");
770 TAILQ_INIT(&sassc->ev_queue);
772 /* Initialize taskqueue for Event Handling */
773 TASK_INIT(&sassc->ev_task, 0, mpssas_firmware_event_work, sc);
774 sassc->ev_tq = taskqueue_create("mps_taskq", M_NOWAIT | M_ZERO,
775 taskqueue_thread_enqueue, &sassc->ev_tq);
776 taskqueue_start_threads(&sassc->ev_tq, 1, PRIBIO, "%s taskq",
777 device_get_nameunit(sc->mps_dev));
782 * XXX There should be a bus for every port on the adapter, but since
783 * we're just going to fake the topology for now, we'll pretend that
784 * everything is just a target on a single bus.
786 if ((error = xpt_bus_register(sassc->sim, sc->mps_dev, 0)) != 0) {
787 mps_dprint(sc, MPS_INIT|MPS_ERROR,
788 "Error %d registering SCSI bus\n", error);
794 * Assume that discovery events will start right away.
796 * Hold off boot until discovery is complete.
798 sassc->flags |= MPSSAS_IN_STARTUP | MPSSAS_IN_DISCOVERY;
799 sc->sassc->startup_refcount = 0;
800 mpssas_startup_increment(sassc);
802 callout_init(&sassc->discovery_callout, 1 /*mpsafe*/);
805 * Register for async events so we can determine the EEDP
806 * capabilities of devices.
808 status = xpt_create_path(&sassc->path, /*periph*/NULL,
809 cam_sim_path(sc->sassc->sim), CAM_TARGET_WILDCARD,
811 if (status != CAM_REQ_CMP) {
812 mps_dprint(sc, MPS_ERROR|MPS_INIT,
813 "Error %#x creating sim path\n", status);
818 #if (__FreeBSD_version >= 1000006) || \
819 ((__FreeBSD_version >= 901503) && (__FreeBSD_version < 1000000))
820 event = AC_ADVINFO_CHANGED;
822 event = AC_FOUND_DEVICE;
824 status = xpt_register_async(event, mpssas_async, sc,
826 if (status != CAM_REQ_CMP) {
827 mps_dprint(sc, MPS_ERROR,
828 "Error %#x registering async handler for "
829 "AC_ADVINFO_CHANGED events\n", status);
830 xpt_free_path(sassc->path);
834 if (status != CAM_REQ_CMP) {
836 * EEDP use is the exception, not the rule.
837 * Warn the user, but do not fail to attach.
839 mps_printf(sc, "EEDP capabilities disabled.\n");
844 mpssas_register_events(sc);
849 mps_dprint(sc, MPS_INIT, "%s exit error= %d\n", __func__, error);
854 mps_detach_sas(struct mps_softc *sc)
856 struct mpssas_softc *sassc;
857 struct mpssas_lun *lun, *lun_tmp;
858 struct mpssas_target *targ;
863 if (sc->sassc == NULL)
867 mps_deregister_events(sc, sassc->mpssas_eh);
870 * Drain and free the event handling taskqueue with the lock
871 * unheld so that any parallel processing tasks drain properly
872 * without deadlocking.
874 if (sassc->ev_tq != NULL)
875 taskqueue_free(sassc->ev_tq);
877 /* Make sure CAM doesn't wedge if we had to bail out early. */
880 while (sassc->startup_refcount != 0)
881 mpssas_startup_decrement(sassc);
883 /* Deregister our async handler */
884 if (sassc->path != NULL) {
885 xpt_register_async(0, mpssas_async, sc, sassc->path);
886 xpt_free_path(sassc->path);
890 if (sassc->flags & MPSSAS_IN_STARTUP)
891 xpt_release_simq(sassc->sim, 1);
893 if (sassc->sim != NULL) {
894 xpt_bus_deregister(cam_sim_path(sassc->sim));
895 cam_sim_free(sassc->sim, FALSE);
900 if (sassc->devq != NULL)
901 cam_simq_free(sassc->devq);
903 for(i=0; i< sassc->maxtargets ;i++) {
904 targ = &sassc->targets[i];
905 SLIST_FOREACH_SAFE(lun, &targ->luns, lun_link, lun_tmp) {
909 free(sassc->targets, M_MPT2);
917 mpssas_discovery_end(struct mpssas_softc *sassc)
919 struct mps_softc *sc = sassc->sc;
923 if (sassc->flags & MPSSAS_DISCOVERY_TIMEOUT_PENDING)
924 callout_stop(&sassc->discovery_callout);
927 * After discovery has completed, check the mapping table for any
928 * missing devices and update their missing counts. Only do this once
929 * whenever the driver is initialized so that missing counts aren't
930 * updated unnecessarily. Note that just because discovery has
931 * completed doesn't mean that events have been processed yet. The
932 * check_devices function is a callout timer that checks if ALL devices
933 * are missing. If so, it will wait a little longer for events to
934 * complete and keep resetting itself until some device in the mapping
935 * table is not missing, meaning that event processing has started.
937 if (sc->track_mapping_events) {
938 mps_dprint(sc, MPS_XINFO | MPS_MAPPING, "Discovery has "
939 "completed. Check for missing devices in the mapping "
941 callout_reset(&sc->device_check_callout,
942 MPS_MISSING_CHECK_DELAY * hz, mps_mapping_check_devices,
948 mpssas_action(struct cam_sim *sim, union ccb *ccb)
950 struct mpssas_softc *sassc;
952 sassc = cam_sim_softc(sim);
954 MPS_FUNCTRACE(sassc->sc);
955 mps_dprint(sassc->sc, MPS_TRACE, "ccb func_code 0x%x\n",
956 ccb->ccb_h.func_code);
957 mtx_assert(&sassc->sc->mps_mtx, MA_OWNED);
959 switch (ccb->ccb_h.func_code) {
962 struct ccb_pathinq *cpi = &ccb->cpi;
963 struct mps_softc *sc = sassc->sc;
965 cpi->version_num = 1;
966 cpi->hba_inquiry = PI_SDTR_ABLE|PI_TAG_ABLE|PI_WIDE_16;
967 cpi->target_sprt = 0;
968 #if __FreeBSD_version >= 1000039
969 cpi->hba_misc = PIM_NOBUSRESET | PIM_UNMAPPED | PIM_NOSCAN;
971 cpi->hba_misc = PIM_NOBUSRESET | PIM_UNMAPPED;
973 cpi->hba_eng_cnt = 0;
974 cpi->max_target = sassc->maxtargets - 1;
978 * initiator_id is set here to an ID outside the set of valid
979 * target IDs (including volumes).
981 cpi->initiator_id = sassc->maxtargets;
982 strlcpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
983 strlcpy(cpi->hba_vid, "Avago Tech", HBA_IDLEN);
984 strlcpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
985 cpi->unit_number = cam_sim_unit(sim);
986 cpi->bus_id = cam_sim_bus(sim);
987 cpi->base_transfer_speed = 150000;
988 cpi->transport = XPORT_SAS;
989 cpi->transport_version = 0;
990 cpi->protocol = PROTO_SCSI;
991 cpi->protocol_version = SCSI_REV_SPC;
992 cpi->maxio = sc->maxio;
993 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP);
996 case XPT_GET_TRAN_SETTINGS:
998 struct ccb_trans_settings *cts;
999 struct ccb_trans_settings_sas *sas;
1000 struct ccb_trans_settings_scsi *scsi;
1001 struct mpssas_target *targ;
1004 sas = &cts->xport_specific.sas;
1005 scsi = &cts->proto_specific.scsi;
1007 KASSERT(cts->ccb_h.target_id < sassc->maxtargets,
1008 ("Target %d out of bounds in XPT_GET_TRANS_SETTINGS\n",
1009 cts->ccb_h.target_id));
1010 targ = &sassc->targets[cts->ccb_h.target_id];
1011 if (targ->handle == 0x0) {
1012 mpssas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
1016 cts->protocol_version = SCSI_REV_SPC2;
1017 cts->transport = XPORT_SAS;
1018 cts->transport_version = 0;
1020 sas->valid = CTS_SAS_VALID_SPEED;
1021 switch (targ->linkrate) {
1023 sas->bitrate = 150000;
1026 sas->bitrate = 300000;
1029 sas->bitrate = 600000;
1035 cts->protocol = PROTO_SCSI;
1036 scsi->valid = CTS_SCSI_VALID_TQ;
1037 scsi->flags = CTS_SCSI_FLAGS_TAG_ENB;
1039 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP);
1042 case XPT_CALC_GEOMETRY:
1043 cam_calc_geometry(&ccb->ccg, /*extended*/1);
1044 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP);
1047 mps_dprint(sassc->sc, MPS_XINFO, "mpssas_action XPT_RESET_DEV\n");
1048 mpssas_action_resetdev(sassc, ccb);
1053 mps_dprint(sassc->sc, MPS_XINFO,
1054 "mpssas_action faking success for abort or reset\n");
1055 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP);
1058 mpssas_action_scsiio(sassc, ccb);
1060 #if __FreeBSD_version >= 900026
1062 mpssas_action_smpio(sassc, ccb);
1066 mpssas_set_ccbstatus(ccb, CAM_FUNC_NOTAVAIL);
1074 mpssas_announce_reset(struct mps_softc *sc, uint32_t ac_code,
1075 target_id_t target_id, lun_id_t lun_id)
1077 path_id_t path_id = cam_sim_path(sc->sassc->sim);
1078 struct cam_path *path;
1080 mps_dprint(sc, MPS_XINFO, "%s code %x target %d lun %jx\n", __func__,
1081 ac_code, target_id, (uintmax_t)lun_id);
1083 if (xpt_create_path(&path, NULL,
1084 path_id, target_id, lun_id) != CAM_REQ_CMP) {
1085 mps_dprint(sc, MPS_ERROR, "unable to create path for reset "
1090 xpt_async(ac_code, path, NULL);
1091 xpt_free_path(path);
1095 mpssas_complete_all_commands(struct mps_softc *sc)
1097 struct mps_command *cm;
1102 mtx_assert(&sc->mps_mtx, MA_OWNED);
1104 /* complete all commands with a NULL reply */
1105 for (i = 1; i < sc->num_reqs; i++) {
1106 cm = &sc->commands[i];
1107 if (cm->cm_state == MPS_CM_STATE_FREE)
1110 cm->cm_state = MPS_CM_STATE_BUSY;
1111 cm->cm_reply = NULL;
1114 if (cm->cm_flags & MPS_CM_FLAGS_SATA_ID_TIMEOUT) {
1116 free(cm->cm_data, M_MPT2);
1120 if (cm->cm_flags & MPS_CM_FLAGS_POLLED)
1121 cm->cm_flags |= MPS_CM_FLAGS_COMPLETE;
1123 if (cm->cm_complete != NULL) {
1124 mpssas_log_command(cm, MPS_RECOVERY,
1125 "completing cm %p state %x ccb %p for diag reset\n",
1126 cm, cm->cm_state, cm->cm_ccb);
1128 cm->cm_complete(sc, cm);
1130 } else if (cm->cm_flags & MPS_CM_FLAGS_WAKEUP) {
1131 mpssas_log_command(cm, MPS_RECOVERY,
1132 "waking up cm %p state %x ccb %p for diag reset\n",
1133 cm, cm->cm_state, cm->cm_ccb);
1138 if ((completed == 0) && (cm->cm_state != MPS_CM_STATE_FREE)) {
1139 /* this should never happen, but if it does, log */
1140 mpssas_log_command(cm, MPS_RECOVERY,
1141 "cm %p state %x flags 0x%x ccb %p during diag "
1142 "reset\n", cm, cm->cm_state, cm->cm_flags,
1147 sc->io_cmds_active = 0;
1151 mpssas_handle_reinit(struct mps_softc *sc)
1155 /* Go back into startup mode and freeze the simq, so that CAM
1156 * doesn't send any commands until after we've rediscovered all
1157 * targets and found the proper device handles for them.
1159 * After the reset, portenable will trigger discovery, and after all
1160 * discovery-related activities have finished, the simq will be
1163 mps_dprint(sc, MPS_INIT, "%s startup\n", __func__);
1164 sc->sassc->flags |= MPSSAS_IN_STARTUP;
1165 sc->sassc->flags |= MPSSAS_IN_DISCOVERY;
1166 mpssas_startup_increment(sc->sassc);
1168 /* notify CAM of a bus reset */
1169 mpssas_announce_reset(sc, AC_BUS_RESET, CAM_TARGET_WILDCARD,
1172 /* complete and cleanup after all outstanding commands */
1173 mpssas_complete_all_commands(sc);
1175 mps_dprint(sc, MPS_INIT,
1176 "%s startup %u after command completion\n", __func__,
1177 sc->sassc->startup_refcount);
1179 /* zero all the target handles, since they may change after the
1180 * reset, and we have to rediscover all the targets and use the new
1183 for (i = 0; i < sc->sassc->maxtargets; i++) {
1184 if (sc->sassc->targets[i].outstanding != 0)
1185 mps_dprint(sc, MPS_INIT, "target %u outstanding %u\n",
1186 i, sc->sassc->targets[i].outstanding);
1187 sc->sassc->targets[i].handle = 0x0;
1188 sc->sassc->targets[i].exp_dev_handle = 0x0;
1189 sc->sassc->targets[i].outstanding = 0;
1190 sc->sassc->targets[i].flags = MPSSAS_TARGET_INDIAGRESET;
1195 mpssas_tm_timeout(void *data)
1197 struct mps_command *tm = data;
1198 struct mps_softc *sc = tm->cm_sc;
1200 mtx_assert(&sc->mps_mtx, MA_OWNED);
1202 mpssas_log_command(tm, MPS_INFO|MPS_RECOVERY,
1203 "task mgmt %p timed out\n", tm);
1205 KASSERT(tm->cm_state == MPS_CM_STATE_INQUEUE,
1206 ("command not inqueue\n"));
1208 tm->cm_state = MPS_CM_STATE_BUSY;
1213 mpssas_logical_unit_reset_complete(struct mps_softc *sc, struct mps_command *tm)
1215 MPI2_SCSI_TASK_MANAGE_REPLY *reply;
1216 MPI2_SCSI_TASK_MANAGE_REQUEST *req;
1217 unsigned int cm_count = 0;
1218 struct mps_command *cm;
1219 struct mpssas_target *targ;
1221 callout_stop(&tm->cm_callout);
1223 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
1224 reply = (MPI2_SCSI_TASK_MANAGE_REPLY *)tm->cm_reply;
1228 * Currently there should be no way we can hit this case. It only
1229 * happens when we have a failure to allocate chain frames, and
1230 * task management commands don't have S/G lists.
1231 * XXXSL So should it be an assertion?
1233 if ((tm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) {
1234 mps_dprint(sc, MPS_RECOVERY|MPS_ERROR,
1235 "%s: cm_flags = %#x for LUN reset! "
1236 "This should not happen!\n", __func__, tm->cm_flags);
1237 mpssas_free_tm(sc, tm);
1241 if (reply == NULL) {
1242 mps_dprint(sc, MPS_RECOVERY, "NULL reset reply for tm %p\n",
1244 if ((sc->mps_flags & MPS_FLAGS_DIAGRESET) != 0) {
1245 /* this completion was due to a reset, just cleanup */
1246 mps_dprint(sc, MPS_RECOVERY, "Hardware undergoing "
1247 "reset, ignoring NULL LUN reset reply\n");
1249 mpssas_free_tm(sc, tm);
1252 /* we should have gotten a reply. */
1253 mps_dprint(sc, MPS_INFO|MPS_RECOVERY, "NULL reply on "
1254 "LUN reset attempt, resetting controller\n");
1260 mps_dprint(sc, MPS_RECOVERY,
1261 "logical unit reset status 0x%x code 0x%x count %u\n",
1262 le16toh(reply->IOCStatus), le32toh(reply->ResponseCode),
1263 le32toh(reply->TerminationCount));
1266 * See if there are any outstanding commands for this LUN.
1267 * This could be made more efficient by using a per-LU data
1268 * structure of some sort.
1270 TAILQ_FOREACH(cm, &targ->commands, cm_link) {
1271 if (cm->cm_lun == tm->cm_lun)
1275 if (cm_count == 0) {
1276 mps_dprint(sc, MPS_RECOVERY|MPS_INFO,
1277 "Finished recovery after LUN reset for target %u\n",
1280 mpssas_announce_reset(sc, AC_SENT_BDR, targ->tid, tm->cm_lun);
1283 * We've finished recovery for this logical unit. check and
1284 * see if some other logical unit has a timedout command
1285 * that needs to be processed.
1287 cm = TAILQ_FIRST(&targ->timedout_commands);
1289 mps_dprint(sc, MPS_INFO|MPS_RECOVERY,
1290 "More commands to abort for target %u\n",
1292 mpssas_send_abort(sc, tm, cm);
1295 mpssas_free_tm(sc, tm);
1299 * If we still have commands for this LUN, the reset
1300 * effectively failed, regardless of the status reported.
1301 * Escalate to a target reset.
1303 mps_dprint(sc, MPS_INFO|MPS_RECOVERY,
1304 "logical unit reset complete for target %u, but still "
1305 "have %u command(s), sending target reset\n", targ->tid,
1307 mpssas_send_reset(sc, tm,
1308 MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET);
1313 mpssas_target_reset_complete(struct mps_softc *sc, struct mps_command *tm)
1315 MPI2_SCSI_TASK_MANAGE_REPLY *reply;
1316 MPI2_SCSI_TASK_MANAGE_REQUEST *req;
1317 struct mpssas_target *targ;
1319 callout_stop(&tm->cm_callout);
1321 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
1322 reply = (MPI2_SCSI_TASK_MANAGE_REPLY *)tm->cm_reply;
1326 * Currently there should be no way we can hit this case. It only
1327 * happens when we have a failure to allocate chain frames, and
1328 * task management commands don't have S/G lists.
1330 if ((tm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) {
1331 mps_dprint(sc, MPS_ERROR,"%s: cm_flags = %#x for target reset! "
1332 "This should not happen!\n", __func__, tm->cm_flags);
1333 mpssas_free_tm(sc, tm);
1337 if (reply == NULL) {
1338 mps_dprint(sc, MPS_RECOVERY,
1339 "NULL target reset reply for tm %pi TaskMID %u\n",
1340 tm, le16toh(req->TaskMID));
1341 if ((sc->mps_flags & MPS_FLAGS_DIAGRESET) != 0) {
1342 /* this completion was due to a reset, just cleanup */
1343 mps_dprint(sc, MPS_RECOVERY, "Hardware undergoing "
1344 "reset, ignoring NULL target reset reply\n");
1346 mpssas_free_tm(sc, tm);
1348 /* we should have gotten a reply. */
1349 mps_dprint(sc, MPS_INFO|MPS_RECOVERY, "NULL reply on "
1350 "target reset attempt, resetting controller\n");
1356 mps_dprint(sc, MPS_RECOVERY,
1357 "target reset status 0x%x code 0x%x count %u\n",
1358 le16toh(reply->IOCStatus), le32toh(reply->ResponseCode),
1359 le32toh(reply->TerminationCount));
1361 if (targ->outstanding == 0) {
1362 /* we've finished recovery for this target and all
1363 * of its logical units.
1365 mps_dprint(sc, MPS_RECOVERY|MPS_INFO,
1366 "Finished reset recovery for target %u\n", targ->tid);
1368 mpssas_announce_reset(sc, AC_SENT_BDR, tm->cm_targ->tid,
1372 mpssas_free_tm(sc, tm);
1375 * After a target reset, if this target still has
1376 * outstanding commands, the reset effectively failed,
1377 * regardless of the status reported. escalate.
1379 mps_dprint(sc, MPS_INFO|MPS_RECOVERY,
1380 "Target reset complete for target %u, but still have %u "
1381 "command(s), resetting controller\n", targ->tid,
1387 #define MPS_RESET_TIMEOUT 30
1390 mpssas_send_reset(struct mps_softc *sc, struct mps_command *tm, uint8_t type)
1392 MPI2_SCSI_TASK_MANAGE_REQUEST *req;
1393 struct mpssas_target *target;
1396 target = tm->cm_targ;
1397 if (target->handle == 0) {
1398 mps_dprint(sc, MPS_ERROR,"%s null devhandle for target_id %d\n",
1399 __func__, target->tid);
1403 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
1404 req->DevHandle = htole16(target->handle);
1405 req->TaskType = type;
1407 if (type == MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET) {
1408 /* XXX Need to handle invalid LUNs */
1409 MPS_SET_LUN(req->LUN, tm->cm_lun);
1410 tm->cm_targ->logical_unit_resets++;
1411 mps_dprint(sc, MPS_RECOVERY|MPS_INFO,
1412 "Sending logical unit reset to target %u lun %d\n",
1413 target->tid, tm->cm_lun);
1414 tm->cm_complete = mpssas_logical_unit_reset_complete;
1415 mpssas_prepare_for_tm(sc, tm, target, tm->cm_lun);
1416 } else if (type == MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET) {
1418 * Target reset method =
1419 * SAS Hard Link Reset / SATA Link Reset
1421 req->MsgFlags = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
1422 tm->cm_targ->target_resets++;
1423 mps_dprint(sc, MPS_RECOVERY|MPS_INFO,
1424 "Sending target reset to target %u\n", target->tid);
1425 tm->cm_complete = mpssas_target_reset_complete;
1426 mpssas_prepare_for_tm(sc, tm, target, CAM_LUN_WILDCARD);
1428 mps_dprint(sc, MPS_ERROR, "unexpected reset type 0x%x\n", type);
1433 tm->cm_complete_data = (void *)tm;
1435 callout_reset(&tm->cm_callout, MPS_RESET_TIMEOUT * hz,
1436 mpssas_tm_timeout, tm);
1438 err = mps_map_command(sc, tm);
1440 mps_dprint(sc, MPS_ERROR|MPS_RECOVERY,
1441 "error %d sending reset type %u\n",
1449 mpssas_abort_complete(struct mps_softc *sc, struct mps_command *tm)
1451 struct mps_command *cm;
1452 MPI2_SCSI_TASK_MANAGE_REPLY *reply;
1453 MPI2_SCSI_TASK_MANAGE_REQUEST *req;
1454 struct mpssas_target *targ;
1456 callout_stop(&tm->cm_callout);
1458 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
1459 reply = (MPI2_SCSI_TASK_MANAGE_REPLY *)tm->cm_reply;
1463 * Currently there should be no way we can hit this case. It only
1464 * happens when we have a failure to allocate chain frames, and
1465 * task management commands don't have S/G lists.
1467 if ((tm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) {
1468 mps_dprint(sc, MPS_RECOVERY,
1469 "cm_flags = %#x for abort %p TaskMID %u!\n",
1470 tm->cm_flags, tm, le16toh(req->TaskMID));
1471 mpssas_free_tm(sc, tm);
1475 if (reply == NULL) {
1476 mps_dprint(sc, MPS_RECOVERY,
1477 "NULL abort reply for tm %p TaskMID %u\n",
1478 tm, le16toh(req->TaskMID));
1479 if ((sc->mps_flags & MPS_FLAGS_DIAGRESET) != 0) {
1480 /* this completion was due to a reset, just cleanup */
1481 mps_dprint(sc, MPS_RECOVERY, "Hardware undergoing "
1482 "reset, ignoring NULL abort reply\n");
1484 mpssas_free_tm(sc, tm);
1486 /* we should have gotten a reply. */
1487 mps_dprint(sc, MPS_INFO|MPS_RECOVERY, "NULL reply on "
1488 "abort attempt, resetting controller\n");
1494 mps_dprint(sc, MPS_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));
1500 cm = TAILQ_FIRST(&tm->cm_targ->timedout_commands);
1503 * If there are no more timedout commands, we're done with
1504 * error recovery for this target.
1506 mps_dprint(sc, MPS_INFO|MPS_RECOVERY,
1507 "Finished abort recovery for target %u\n", targ->tid);
1510 mpssas_free_tm(sc, tm);
1511 } else if (le16toh(req->TaskMID) != cm->cm_desc.Default.SMID) {
1512 /* abort success, but we have more timedout commands to abort */
1513 mps_dprint(sc, MPS_INFO|MPS_RECOVERY,
1514 "Continuing abort recovery for target %u\n", targ->tid);
1516 mpssas_send_abort(sc, tm, cm);
1518 /* we didn't get a command completion, so the abort
1519 * failed as far as we're concerned. escalate.
1521 mps_dprint(sc, MPS_RECOVERY,
1522 "Abort failed for target %u, sending logical unit reset\n",
1525 mpssas_send_reset(sc, tm,
1526 MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET);
1530 #define MPS_ABORT_TIMEOUT 5
1533 mpssas_send_abort(struct mps_softc *sc, struct mps_command *tm, struct mps_command *cm)
1535 MPI2_SCSI_TASK_MANAGE_REQUEST *req;
1536 struct mpssas_target *targ;
1540 if (targ->handle == 0) {
1541 mps_dprint(sc, MPS_ERROR|MPS_RECOVERY,
1542 "%s null devhandle for target_id %d\n",
1543 __func__, cm->cm_ccb->ccb_h.target_id);
1547 mpssas_log_command(cm, MPS_RECOVERY|MPS_INFO,
1548 "Aborting command %p\n", cm);
1550 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
1551 req->DevHandle = htole16(targ->handle);
1552 req->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK;
1554 /* XXX Need to handle invalid LUNs */
1555 MPS_SET_LUN(req->LUN, cm->cm_ccb->ccb_h.target_lun);
1557 req->TaskMID = htole16(cm->cm_desc.Default.SMID);
1560 tm->cm_complete = mpssas_abort_complete;
1561 tm->cm_complete_data = (void *)tm;
1562 tm->cm_targ = cm->cm_targ;
1563 tm->cm_lun = cm->cm_lun;
1565 callout_reset(&tm->cm_callout, MPS_ABORT_TIMEOUT * hz,
1566 mpssas_tm_timeout, tm);
1570 mpssas_prepare_for_tm(sc, tm, targ, tm->cm_lun);
1572 err = mps_map_command(sc, tm);
1574 mps_dprint(sc, MPS_ERROR|MPS_RECOVERY,
1575 "error %d sending abort for cm %p SMID %u\n",
1576 err, cm, req->TaskMID);
1581 mpssas_scsiio_timeout(void *data)
1583 sbintime_t elapsed, now;
1585 struct mps_softc *sc;
1586 struct mps_command *cm;
1587 struct mpssas_target *targ;
1589 cm = (struct mps_command *)data;
1595 mtx_assert(&sc->mps_mtx, MA_OWNED);
1597 mps_dprint(sc, MPS_XINFO|MPS_RECOVERY, "Timeout checking cm %p\n", sc);
1600 * Run the interrupt handler to make sure it's not pending. This
1601 * isn't perfect because the command could have already completed
1602 * and been re-used, though this is unlikely.
1604 mps_intr_locked(sc);
1605 if (cm->cm_state != MPS_CM_STATE_INQUEUE) {
1606 mpssas_log_command(cm, MPS_XINFO,
1607 "SCSI command %p almost timed out\n", cm);
1611 if (cm->cm_ccb == NULL) {
1612 mps_dprint(sc, MPS_ERROR, "command timeout with NULL ccb\n");
1619 elapsed = now - ccb->ccb_h.qos.sim_data;
1620 mpssas_log_command(cm, MPS_INFO|MPS_RECOVERY,
1621 "Command timeout on target %u(0x%04x) %d set, %d.%d elapsed\n",
1622 targ->tid, targ->handle, ccb->ccb_h.timeout,
1623 sbintime_getsec(elapsed), elapsed & 0xffffffff);
1625 /* XXX first, check the firmware state, to see if it's still
1626 * operational. if not, do a diag reset.
1628 mpssas_set_ccbstatus(cm->cm_ccb, CAM_CMD_TIMEOUT);
1629 cm->cm_state = MPS_CM_STATE_TIMEDOUT;
1630 TAILQ_INSERT_TAIL(&targ->timedout_commands, cm, cm_recovery);
1632 if (targ->tm != NULL) {
1633 /* target already in recovery, just queue up another
1634 * timedout command to be processed later.
1636 mps_dprint(sc, MPS_RECOVERY,
1637 "queued timedout cm %p for processing by tm %p\n",
1639 } else if ((targ->tm = mpssas_alloc_tm(sc)) != NULL) {
1640 mps_dprint(sc, MPS_RECOVERY|MPS_INFO,
1641 "Sending abort to target %u for SMID %d\n", targ->tid,
1642 cm->cm_desc.Default.SMID);
1643 mps_dprint(sc, MPS_RECOVERY, "timedout cm %p allocated tm %p\n",
1646 /* start recovery by aborting the first timedout command */
1647 mpssas_send_abort(sc, targ->tm, cm);
1649 /* XXX queue this target up for recovery once a TM becomes
1650 * available. The firmware only has a limited number of
1651 * HighPriority credits for the high priority requests used
1652 * for task management, and we ran out.
1654 * Isilon: don't worry about this for now, since we have
1655 * more credits than disks in an enclosure, and limit
1656 * ourselves to one TM per target for recovery.
1658 mps_dprint(sc, MPS_ERROR|MPS_RECOVERY,
1659 "timedout cm %p failed to allocate a tm\n", cm);
1665 mpssas_action_scsiio(struct mpssas_softc *sassc, union ccb *ccb)
1667 MPI2_SCSI_IO_REQUEST *req;
1668 struct ccb_scsiio *csio;
1669 struct mps_softc *sc;
1670 struct mpssas_target *targ;
1671 struct mpssas_lun *lun;
1672 struct mps_command *cm;
1673 uint8_t i, lba_byte, *ref_tag_addr;
1674 uint16_t eedp_flags;
1675 uint32_t mpi_control;
1679 mtx_assert(&sc->mps_mtx, MA_OWNED);
1682 KASSERT(csio->ccb_h.target_id < sassc->maxtargets,
1683 ("Target %d out of bounds in XPT_SCSI_IO\n",
1684 csio->ccb_h.target_id));
1685 targ = &sassc->targets[csio->ccb_h.target_id];
1686 mps_dprint(sc, MPS_TRACE, "ccb %p target flag %x\n", ccb, targ->flags);
1687 if (targ->handle == 0x0) {
1688 mps_dprint(sc, MPS_ERROR, "%s NULL handle for target %u\n",
1689 __func__, csio->ccb_h.target_id);
1690 mpssas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
1694 if (targ->flags & MPS_TARGET_FLAGS_RAID_COMPONENT) {
1695 mps_dprint(sc, MPS_ERROR, "%s Raid component no SCSI IO "
1696 "supported %u\n", __func__, csio->ccb_h.target_id);
1697 mpssas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
1702 * Sometimes, it is possible to get a command that is not "In
1703 * Progress" and was actually aborted by the upper layer. Check for
1704 * this here and complete the command without error.
1706 if (mpssas_get_ccbstatus(ccb) != CAM_REQ_INPROG) {
1707 mps_dprint(sc, MPS_TRACE, "%s Command is not in progress for "
1708 "target %u\n", __func__, csio->ccb_h.target_id);
1713 * If devinfo is 0 this will be a volume. In that case don't tell CAM
1714 * that the volume has timed out. We want volumes to be enumerated
1715 * until they are deleted/removed, not just failed.
1717 if (targ->flags & MPSSAS_TARGET_INREMOVAL) {
1718 if (targ->devinfo == 0)
1719 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP);
1721 mpssas_set_ccbstatus(ccb, CAM_SEL_TIMEOUT);
1726 if ((sc->mps_flags & MPS_FLAGS_SHUTDOWN) != 0) {
1727 mps_dprint(sc, MPS_INFO, "%s shutting down\n", __func__);
1728 mpssas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
1734 * If target has a reset in progress, freeze the devq and return. The
1735 * devq will be released when the TM reset is finished.
1737 if (targ->flags & MPSSAS_TARGET_INRESET) {
1738 ccb->ccb_h.status = CAM_BUSY | CAM_DEV_QFRZN;
1739 mps_dprint(sc, MPS_INFO, "%s: Freezing devq for target ID %d\n",
1740 __func__, targ->tid);
1741 xpt_freeze_devq(ccb->ccb_h.path, 1);
1746 cm = mps_alloc_command(sc);
1747 if (cm == NULL || (sc->mps_flags & MPS_FLAGS_DIAGRESET)) {
1749 mps_free_command(sc, cm);
1751 if ((sassc->flags & MPSSAS_QUEUE_FROZEN) == 0) {
1752 xpt_freeze_simq(sassc->sim, 1);
1753 sassc->flags |= MPSSAS_QUEUE_FROZEN;
1755 ccb->ccb_h.status &= ~CAM_SIM_QUEUED;
1756 ccb->ccb_h.status |= CAM_REQUEUE_REQ;
1761 req = (MPI2_SCSI_IO_REQUEST *)cm->cm_req;
1762 bzero(req, sizeof(*req));
1763 req->DevHandle = htole16(targ->handle);
1764 req->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
1766 req->SenseBufferLowAddress = htole32(cm->cm_sense_busaddr);
1767 req->SenseBufferLength = MPS_SENSE_LEN;
1769 req->ChainOffset = 0;
1770 req->SGLOffset0 = 24; /* 32bit word offset to the SGL */
1775 req->DataLength = htole32(csio->dxfer_len);
1776 req->BidirectionalDataLength = 0;
1777 req->IoFlags = htole16(csio->cdb_len);
1780 /* Note: BiDirectional transfers are not supported */
1781 switch (csio->ccb_h.flags & CAM_DIR_MASK) {
1783 mpi_control = MPI2_SCSIIO_CONTROL_READ;
1784 cm->cm_flags |= MPS_CM_FLAGS_DATAIN;
1787 mpi_control = MPI2_SCSIIO_CONTROL_WRITE;
1788 cm->cm_flags |= MPS_CM_FLAGS_DATAOUT;
1792 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER;
1796 if (csio->cdb_len == 32)
1797 mpi_control |= 4 << MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT;
1799 * It looks like the hardware doesn't require an explicit tag
1800 * number for each transaction. SAM Task Management not supported
1803 switch (csio->tag_action) {
1804 case MSG_HEAD_OF_Q_TAG:
1805 mpi_control |= MPI2_SCSIIO_CONTROL_HEADOFQ;
1807 case MSG_ORDERED_Q_TAG:
1808 mpi_control |= MPI2_SCSIIO_CONTROL_ORDEREDQ;
1811 mpi_control |= MPI2_SCSIIO_CONTROL_ACAQ;
1813 case CAM_TAG_ACTION_NONE:
1814 case MSG_SIMPLE_Q_TAG:
1816 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
1819 mpi_control |= sc->mapping_table[csio->ccb_h.target_id].TLR_bits;
1820 req->Control = htole32(mpi_control);
1821 if (MPS_SET_LUN(req->LUN, csio->ccb_h.target_lun) != 0) {
1822 mps_free_command(sc, cm);
1823 mpssas_set_ccbstatus(ccb, CAM_LUN_INVALID);
1828 if (csio->ccb_h.flags & CAM_CDB_POINTER)
1829 bcopy(csio->cdb_io.cdb_ptr, &req->CDB.CDB32[0], csio->cdb_len);
1831 bcopy(csio->cdb_io.cdb_bytes, &req->CDB.CDB32[0],csio->cdb_len);
1832 req->IoFlags = htole16(csio->cdb_len);
1835 * Check if EEDP is supported and enabled. If it is then check if the
1836 * SCSI opcode could be using EEDP. If so, make sure the LUN exists and
1837 * is formatted for EEDP support. If all of this is true, set CDB up
1838 * for EEDP transfer.
1840 eedp_flags = op_code_prot[req->CDB.CDB32[0]];
1841 if (sc->eedp_enabled && eedp_flags) {
1842 SLIST_FOREACH(lun, &targ->luns, lun_link) {
1843 if (lun->lun_id == csio->ccb_h.target_lun) {
1848 if ((lun != NULL) && (lun->eedp_formatted)) {
1849 req->EEDPBlockSize = htole16(lun->eedp_block_size);
1850 eedp_flags |= (MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
1851 MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
1852 MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD);
1853 req->EEDPFlags = htole16(eedp_flags);
1856 * If CDB less than 32, fill in Primary Ref Tag with
1857 * low 4 bytes of LBA. If CDB is 32, tag stuff is
1858 * already there. Also, set protection bit. FreeBSD
1859 * currently does not support CDBs bigger than 16, but
1860 * the code doesn't hurt, and will be here for the
1863 if (csio->cdb_len != 32) {
1864 lba_byte = (csio->cdb_len == 16) ? 6 : 2;
1865 ref_tag_addr = (uint8_t *)&req->CDB.EEDP32.
1866 PrimaryReferenceTag;
1867 for (i = 0; i < 4; i++) {
1869 req->CDB.CDB32[lba_byte + i];
1872 req->CDB.EEDP32.PrimaryReferenceTag =
1873 htole32(req->CDB.EEDP32.PrimaryReferenceTag);
1874 req->CDB.EEDP32.PrimaryApplicationTagMask =
1876 req->CDB.CDB32[1] = (req->CDB.CDB32[1] & 0x1F) |
1880 MPI2_SCSIIO_EEDPFLAGS_INC_PRI_APPTAG;
1881 req->EEDPFlags = htole16(eedp_flags);
1882 req->CDB.CDB32[10] = (req->CDB.CDB32[10] &
1888 cm->cm_length = csio->dxfer_len;
1889 if (cm->cm_length != 0) {
1891 cm->cm_flags |= MPS_CM_FLAGS_USE_CCB;
1895 cm->cm_sge = &req->SGL;
1896 cm->cm_sglsize = (32 - 24) * 4;
1897 cm->cm_desc.SCSIIO.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO;
1898 cm->cm_desc.SCSIIO.DevHandle = htole16(targ->handle);
1899 cm->cm_complete = mpssas_scsiio_complete;
1900 cm->cm_complete_data = ccb;
1902 cm->cm_lun = csio->ccb_h.target_lun;
1906 * If HBA is a WD and the command is not for a retry, try to build a
1907 * direct I/O message. If failed, or the command is for a retry, send
1908 * the I/O to the IR volume itself.
1910 if (sc->WD_valid_config) {
1911 if (ccb->ccb_h.sim_priv.entries[0].field == MPS_WD_RETRY) {
1912 mpssas_direct_drive_io(sassc, cm, ccb);
1914 mpssas_set_ccbstatus(ccb, CAM_REQ_INPROG);
1918 #if defined(BUF_TRACKING) || defined(FULL_BUF_TRACKING)
1919 if (csio->bio != NULL)
1920 biotrack(csio->bio, __func__);
1922 csio->ccb_h.qos.sim_data = sbinuptime();
1923 callout_reset_sbt(&cm->cm_callout, SBT_1MS * ccb->ccb_h.timeout, 0,
1924 mpssas_scsiio_timeout, cm, 0);
1927 targ->outstanding++;
1928 TAILQ_INSERT_TAIL(&targ->commands, cm, cm_link);
1929 ccb->ccb_h.status |= CAM_SIM_QUEUED;
1931 mpssas_log_command(cm, MPS_XINFO, "%s cm %p ccb %p outstanding %u\n",
1932 __func__, cm, ccb, targ->outstanding);
1934 mps_map_command(sc, cm);
1939 * mps_sc_failed_io_info - translated non-succesfull SCSI_IO request
1942 mps_sc_failed_io_info(struct mps_softc *sc, struct ccb_scsiio *csio,
1943 Mpi2SCSIIOReply_t *mpi_reply)
1947 u16 ioc_status = le16toh(mpi_reply->IOCStatus) &
1948 MPI2_IOCSTATUS_MASK;
1949 u8 scsi_state = mpi_reply->SCSIState;
1950 u8 scsi_status = mpi_reply->SCSIStatus;
1951 u32 log_info = le32toh(mpi_reply->IOCLogInfo);
1952 const char *desc_ioc_state, *desc_scsi_status;
1954 if (log_info == 0x31170000)
1957 desc_ioc_state = mps_describe_table(mps_iocstatus_string,
1959 desc_scsi_status = mps_describe_table(mps_scsi_status_string,
1962 mps_dprint(sc, MPS_XINFO, "\thandle(0x%04x), ioc_status(%s)(0x%04x)\n",
1963 le16toh(mpi_reply->DevHandle), desc_ioc_state, ioc_status);
1966 *We can add more detail about underflow data here
1969 mps_dprint(sc, MPS_XINFO, "\tscsi_status(%s)(0x%02x), "
1970 "scsi_state %b\n", desc_scsi_status, scsi_status,
1971 scsi_state, "\20" "\1AutosenseValid" "\2AutosenseFailed"
1972 "\3NoScsiStatus" "\4Terminated" "\5Response InfoValid");
1974 if (sc->mps_debug & MPS_XINFO &&
1975 scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
1976 mps_dprint(sc, MPS_XINFO, "-> Sense Buffer Data : Start :\n");
1977 scsi_sense_print(csio);
1978 mps_dprint(sc, MPS_XINFO, "-> Sense Buffer Data : End :\n");
1981 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) {
1982 response_info = le32toh(mpi_reply->ResponseInfo);
1983 response_bytes = (u8 *)&response_info;
1984 mps_dprint(sc, MPS_XINFO, "response code(0x%1x): %s\n",
1986 mps_describe_table(mps_scsi_taskmgmt_string,
1987 response_bytes[0]));
1992 mpssas_scsiio_complete(struct mps_softc *sc, struct mps_command *cm)
1994 MPI2_SCSI_IO_REPLY *rep;
1996 struct ccb_scsiio *csio;
1997 struct mpssas_softc *sassc;
1998 struct scsi_vpd_supported_page_list *vpd_list = NULL;
1999 u8 *TLR_bits, TLR_on;
2002 struct mpssas_target *target;
2003 target_id_t target_id;
2006 mps_dprint(sc, MPS_TRACE,
2007 "cm %p SMID %u ccb %p reply %p outstanding %u\n", cm,
2008 cm->cm_desc.Default.SMID, cm->cm_ccb, cm->cm_reply,
2009 cm->cm_targ->outstanding);
2011 callout_stop(&cm->cm_callout);
2012 mtx_assert(&sc->mps_mtx, MA_OWNED);
2015 ccb = cm->cm_complete_data;
2017 target_id = csio->ccb_h.target_id;
2018 rep = (MPI2_SCSI_IO_REPLY *)cm->cm_reply;
2020 * XXX KDM if the chain allocation fails, does it matter if we do
2021 * the sync and unload here? It is simpler to do it in every case,
2022 * assuming it doesn't cause problems.
2024 if (cm->cm_data != NULL) {
2025 if (cm->cm_flags & MPS_CM_FLAGS_DATAIN)
2026 dir = BUS_DMASYNC_POSTREAD;
2027 else if (cm->cm_flags & MPS_CM_FLAGS_DATAOUT)
2028 dir = BUS_DMASYNC_POSTWRITE;
2029 bus_dmamap_sync(sc->buffer_dmat, cm->cm_dmamap, dir);
2030 bus_dmamap_unload(sc->buffer_dmat, cm->cm_dmamap);
2033 cm->cm_targ->completed++;
2034 cm->cm_targ->outstanding--;
2035 TAILQ_REMOVE(&cm->cm_targ->commands, cm, cm_link);
2036 ccb->ccb_h.status &= ~(CAM_STATUS_MASK | CAM_SIM_QUEUED);
2038 #if defined(BUF_TRACKING) || defined(FULL_BUF_TRACKING)
2039 if (ccb->csio.bio != NULL)
2040 biotrack(ccb->csio.bio, __func__);
2043 if (cm->cm_state == MPS_CM_STATE_TIMEDOUT) {
2044 TAILQ_REMOVE(&cm->cm_targ->timedout_commands, cm, cm_recovery);
2045 cm->cm_state = MPS_CM_STATE_BUSY;
2046 if (cm->cm_reply != NULL)
2047 mpssas_log_command(cm, MPS_RECOVERY,
2048 "completed timedout cm %p ccb %p during recovery "
2049 "ioc %x scsi %x state %x xfer %u\n",
2050 cm, cm->cm_ccb, le16toh(rep->IOCStatus),
2051 rep->SCSIStatus, rep->SCSIState,
2052 le32toh(rep->TransferCount));
2054 mpssas_log_command(cm, MPS_RECOVERY,
2055 "completed timedout cm %p ccb %p during recovery\n",
2057 } else if (cm->cm_targ->tm != NULL) {
2058 if (cm->cm_reply != NULL)
2059 mpssas_log_command(cm, MPS_RECOVERY,
2060 "completed cm %p ccb %p during recovery "
2061 "ioc %x scsi %x state %x xfer %u\n",
2062 cm, cm->cm_ccb, le16toh(rep->IOCStatus),
2063 rep->SCSIStatus, rep->SCSIState,
2064 le32toh(rep->TransferCount));
2066 mpssas_log_command(cm, MPS_RECOVERY,
2067 "completed cm %p ccb %p during recovery\n",
2069 } else if ((sc->mps_flags & MPS_FLAGS_DIAGRESET) != 0) {
2070 mpssas_log_command(cm, MPS_RECOVERY,
2071 "reset completed cm %p ccb %p\n",
2075 if ((cm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) {
2077 * We ran into an error after we tried to map the command,
2078 * so we're getting a callback without queueing the command
2079 * to the hardware. So we set the status here, and it will
2080 * be retained below. We'll go through the "fast path",
2081 * because there can be no reply when we haven't actually
2082 * gone out to the hardware.
2084 mpssas_set_ccbstatus(ccb, CAM_REQUEUE_REQ);
2087 * Currently the only error included in the mask is
2088 * MPS_CM_FLAGS_CHAIN_FAILED, which means we're out of
2089 * chain frames. We need to freeze the queue until we get
2090 * a command that completed without this error, which will
2091 * hopefully have some chain frames attached that we can
2092 * use. If we wanted to get smarter about it, we would
2093 * only unfreeze the queue in this condition when we're
2094 * sure that we're getting some chain frames back. That's
2095 * probably unnecessary.
2097 if ((sassc->flags & MPSSAS_QUEUE_FROZEN) == 0) {
2098 xpt_freeze_simq(sassc->sim, 1);
2099 sassc->flags |= MPSSAS_QUEUE_FROZEN;
2100 mps_dprint(sc, MPS_XINFO, "Error sending command, "
2101 "freezing SIM queue\n");
2106 * If this is a Start Stop Unit command and it was issued by the driver
2107 * during shutdown, decrement the refcount to account for all of the
2108 * commands that were sent. All SSU commands should be completed before
2109 * shutdown completes, meaning SSU_refcount will be 0 after SSU_started
2112 if (sc->SSU_started && (csio->cdb_io.cdb_bytes[0] == START_STOP_UNIT)) {
2113 mps_dprint(sc, MPS_INFO, "Decrementing SSU count.\n");
2117 /* Take the fast path to completion */
2118 if (cm->cm_reply == NULL) {
2119 if (mpssas_get_ccbstatus(ccb) == CAM_REQ_INPROG) {
2120 if ((sc->mps_flags & MPS_FLAGS_DIAGRESET) != 0)
2121 mpssas_set_ccbstatus(ccb, CAM_SCSI_BUS_RESET);
2123 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP);
2124 ccb->csio.scsi_status = SCSI_STATUS_OK;
2126 if (sassc->flags & MPSSAS_QUEUE_FROZEN) {
2127 ccb->ccb_h.status |= CAM_RELEASE_SIMQ;
2128 sassc->flags &= ~MPSSAS_QUEUE_FROZEN;
2129 mps_dprint(sc, MPS_XINFO,
2130 "Unfreezing SIM queue\n");
2135 * There are two scenarios where the status won't be
2136 * CAM_REQ_CMP. The first is if MPS_CM_FLAGS_ERROR_MASK is
2137 * set, the second is in the MPS_FLAGS_DIAGRESET above.
2139 if (mpssas_get_ccbstatus(ccb) != CAM_REQ_CMP) {
2141 * Freeze the dev queue so that commands are
2142 * executed in the correct order after error
2145 ccb->ccb_h.status |= CAM_DEV_QFRZN;
2146 xpt_freeze_devq(ccb->ccb_h.path, /*count*/ 1);
2148 mps_free_command(sc, cm);
2153 mpssas_log_command(cm, MPS_XINFO,
2154 "ioc %x scsi %x state %x xfer %u\n",
2155 le16toh(rep->IOCStatus), rep->SCSIStatus, rep->SCSIState,
2156 le32toh(rep->TransferCount));
2159 * If this is a Direct Drive I/O, reissue the I/O to the original IR
2160 * Volume if an error occurred (normal I/O retry). Use the original
2161 * CCB, but set a flag that this will be a retry so that it's sent to
2162 * the original volume. Free the command but reuse the CCB.
2164 if (cm->cm_flags & MPS_CM_FLAGS_DD_IO) {
2165 mps_free_command(sc, cm);
2166 ccb->ccb_h.sim_priv.entries[0].field = MPS_WD_RETRY;
2167 mpssas_action_scsiio(sassc, ccb);
2170 ccb->ccb_h.sim_priv.entries[0].field = 0;
2172 switch (le16toh(rep->IOCStatus) & MPI2_IOCSTATUS_MASK) {
2173 case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN:
2174 csio->resid = cm->cm_length - le32toh(rep->TransferCount);
2176 case MPI2_IOCSTATUS_SUCCESS:
2177 case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
2179 if ((le16toh(rep->IOCStatus) & MPI2_IOCSTATUS_MASK) ==
2180 MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR)
2181 mpssas_log_command(cm, MPS_XINFO, "recovered error\n");
2183 /* Completion failed at the transport level. */
2184 if (rep->SCSIState & (MPI2_SCSI_STATE_NO_SCSI_STATUS |
2185 MPI2_SCSI_STATE_TERMINATED)) {
2186 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
2190 /* In a modern packetized environment, an autosense failure
2191 * implies that there's not much else that can be done to
2192 * recover the command.
2194 if (rep->SCSIState & MPI2_SCSI_STATE_AUTOSENSE_FAILED) {
2195 mpssas_set_ccbstatus(ccb, CAM_AUTOSENSE_FAIL);
2200 * CAM doesn't care about SAS Response Info data, but if this is
2201 * the state check if TLR should be done. If not, clear the
2202 * TLR_bits for the target.
2204 if ((rep->SCSIState & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) &&
2205 ((le32toh(rep->ResponseInfo) &
2206 MPI2_SCSI_RI_MASK_REASONCODE) ==
2207 MPS_SCSI_RI_INVALID_FRAME)) {
2208 sc->mapping_table[target_id].TLR_bits =
2209 (u8)MPI2_SCSIIO_CONTROL_NO_TLR;
2213 * Intentionally override the normal SCSI status reporting
2214 * for these two cases. These are likely to happen in a
2215 * multi-initiator environment, and we want to make sure that
2216 * CAM retries these commands rather than fail them.
2218 if ((rep->SCSIStatus == MPI2_SCSI_STATUS_COMMAND_TERMINATED) ||
2219 (rep->SCSIStatus == MPI2_SCSI_STATUS_TASK_ABORTED)) {
2220 mpssas_set_ccbstatus(ccb, CAM_REQ_ABORTED);
2224 /* Handle normal status and sense */
2225 csio->scsi_status = rep->SCSIStatus;
2226 if (rep->SCSIStatus == MPI2_SCSI_STATUS_GOOD)
2227 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP);
2229 mpssas_set_ccbstatus(ccb, CAM_SCSI_STATUS_ERROR);
2231 if (rep->SCSIState & MPI2_SCSI_STATE_AUTOSENSE_VALID) {
2232 int sense_len, returned_sense_len;
2234 returned_sense_len = min(le32toh(rep->SenseCount),
2235 sizeof(struct scsi_sense_data));
2236 if (returned_sense_len < ccb->csio.sense_len)
2237 ccb->csio.sense_resid = ccb->csio.sense_len -
2240 ccb->csio.sense_resid = 0;
2242 sense_len = min(returned_sense_len,
2243 ccb->csio.sense_len - ccb->csio.sense_resid);
2244 bzero(&ccb->csio.sense_data,
2245 sizeof(ccb->csio.sense_data));
2246 bcopy(cm->cm_sense, &ccb->csio.sense_data, sense_len);
2247 ccb->ccb_h.status |= CAM_AUTOSNS_VALID;
2251 * Check if this is an INQUIRY command. If it's a VPD inquiry,
2252 * and it's page code 0 (Supported Page List), and there is
2253 * inquiry data, and this is for a sequential access device, and
2254 * the device is an SSP target, and TLR is supported by the
2255 * controller, turn the TLR_bits value ON if page 0x90 is
2258 if ((csio->cdb_io.cdb_bytes[0] == INQUIRY) &&
2259 (csio->cdb_io.cdb_bytes[1] & SI_EVPD) &&
2260 (csio->cdb_io.cdb_bytes[2] == SVPD_SUPPORTED_PAGE_LIST) &&
2261 ((csio->ccb_h.flags & CAM_DATA_MASK) == CAM_DATA_VADDR) &&
2262 (csio->data_ptr != NULL) &&
2263 ((csio->data_ptr[0] & 0x1f) == T_SEQUENTIAL) &&
2264 (sc->control_TLR) &&
2265 (sc->mapping_table[target_id].device_info &
2266 MPI2_SAS_DEVICE_INFO_SSP_TARGET)) {
2267 vpd_list = (struct scsi_vpd_supported_page_list *)
2269 TLR_bits = &sc->mapping_table[target_id].TLR_bits;
2270 *TLR_bits = (u8)MPI2_SCSIIO_CONTROL_NO_TLR;
2271 TLR_on = (u8)MPI2_SCSIIO_CONTROL_TLR_ON;
2272 alloc_len = ((u16)csio->cdb_io.cdb_bytes[3] << 8) +
2273 csio->cdb_io.cdb_bytes[4];
2274 alloc_len -= csio->resid;
2275 for (i = 0; i < MIN(vpd_list->length, alloc_len); i++) {
2276 if (vpd_list->list[i] == 0x90) {
2284 * If this is a SATA direct-access end device, mark it so that
2285 * a SCSI StartStopUnit command will be sent to it when the
2286 * driver is being shutdown.
2288 if ((csio->cdb_io.cdb_bytes[0] == INQUIRY) &&
2289 ((csio->data_ptr[0] & 0x1f) == T_DIRECT) &&
2290 (sc->mapping_table[target_id].device_info &
2291 MPI2_SAS_DEVICE_INFO_SATA_DEVICE) &&
2292 ((sc->mapping_table[target_id].device_info &
2293 MPI2_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) ==
2294 MPI2_SAS_DEVICE_INFO_END_DEVICE)) {
2295 target = &sassc->targets[target_id];
2296 target->supports_SSU = TRUE;
2297 mps_dprint(sc, MPS_XINFO, "Target %d supports SSU\n",
2301 case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE:
2302 case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE:
2304 * If devinfo is 0 this will be a volume. In that case don't
2305 * tell CAM that the volume is not there. We want volumes to
2306 * be enumerated until they are deleted/removed, not just
2309 if (cm->cm_targ->devinfo == 0)
2310 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP);
2312 mpssas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
2314 case MPI2_IOCSTATUS_INVALID_SGL:
2315 mps_print_scsiio_cmd(sc, cm);
2316 mpssas_set_ccbstatus(ccb, CAM_UNREC_HBA_ERROR);
2318 case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
2320 * This is one of the responses that comes back when an I/O
2321 * has been aborted. If it is because of a timeout that we
2322 * initiated, just set the status to CAM_CMD_TIMEOUT.
2323 * Otherwise set it to CAM_REQ_ABORTED. The effect on the
2324 * command is the same (it gets retried, subject to the
2325 * retry counter), the only difference is what gets printed
2328 if (cm->cm_state == MPS_CM_STATE_TIMEDOUT)
2329 mpssas_set_ccbstatus(ccb, CAM_CMD_TIMEOUT);
2331 mpssas_set_ccbstatus(ccb, CAM_REQ_ABORTED);
2333 case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN:
2334 /* resid is ignored for this condition */
2336 mpssas_set_ccbstatus(ccb, CAM_DATA_RUN_ERR);
2338 case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
2339 case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
2341 * These can sometimes be transient transport-related
2342 * errors, and sometimes persistent drive-related errors.
2343 * We used to retry these without decrementing the retry
2344 * count by returning CAM_REQUEUE_REQ. Unfortunately, if
2345 * we hit a persistent drive problem that returns one of
2346 * these error codes, we would retry indefinitely. So,
2347 * return CAM_REQ_CMP_ERROR so that we decrement the retry
2348 * count and avoid infinite retries. We're taking the
2349 * potential risk of flagging false failures in the event
2350 * of a topology-related error (e.g. a SAS expander problem
2351 * causes a command addressed to a drive to fail), but
2352 * avoiding getting into an infinite retry loop.
2354 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
2355 mps_dprint(sc, MPS_INFO,
2356 "Controller reported %s tgt %u SMID %u loginfo %x\n",
2357 mps_describe_table(mps_iocstatus_string,
2358 le16toh(rep->IOCStatus) & MPI2_IOCSTATUS_MASK),
2359 target_id, cm->cm_desc.Default.SMID,
2360 le32toh(rep->IOCLogInfo));
2361 mps_dprint(sc, MPS_XINFO,
2362 "SCSIStatus %x SCSIState %x xfercount %u\n",
2363 rep->SCSIStatus, rep->SCSIState,
2364 le32toh(rep->TransferCount));
2366 case MPI2_IOCSTATUS_INVALID_FUNCTION:
2367 case MPI2_IOCSTATUS_INTERNAL_ERROR:
2368 case MPI2_IOCSTATUS_INVALID_VPID:
2369 case MPI2_IOCSTATUS_INVALID_FIELD:
2370 case MPI2_IOCSTATUS_INVALID_STATE:
2371 case MPI2_IOCSTATUS_OP_STATE_NOT_SUPPORTED:
2372 case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR:
2373 case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR:
2374 case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH:
2375 case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED:
2377 mpssas_log_command(cm, MPS_XINFO,
2378 "completed ioc %x loginfo %x scsi %x state %x xfer %u\n",
2379 le16toh(rep->IOCStatus), le32toh(rep->IOCLogInfo),
2380 rep->SCSIStatus, rep->SCSIState,
2381 le32toh(rep->TransferCount));
2382 csio->resid = cm->cm_length;
2383 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
2387 mps_sc_failed_io_info(sc,csio,rep);
2389 if (sassc->flags & MPSSAS_QUEUE_FROZEN) {
2390 ccb->ccb_h.status |= CAM_RELEASE_SIMQ;
2391 sassc->flags &= ~MPSSAS_QUEUE_FROZEN;
2392 mps_dprint(sc, MPS_XINFO, "Command completed, "
2393 "unfreezing SIM queue\n");
2396 if (mpssas_get_ccbstatus(ccb) != CAM_REQ_CMP) {
2397 ccb->ccb_h.status |= CAM_DEV_QFRZN;
2398 xpt_freeze_devq(ccb->ccb_h.path, /*count*/ 1);
2401 mps_free_command(sc, cm);
2405 /* All Request reached here are Endian safe */
2407 mpssas_direct_drive_io(struct mpssas_softc *sassc, struct mps_command *cm,
2409 pMpi2SCSIIORequest_t pIO_req;
2410 struct mps_softc *sc = sassc->sc;
2412 uint32_t physLBA, stripe_offset, stripe_unit;
2413 uint32_t io_size, column;
2414 uint8_t *ptrLBA, lba_idx, physLBA_byte, *CDB;
2417 * If this is a valid SCSI command (Read6, Read10, Read16, Write6,
2418 * Write10, or Write16), build a direct I/O message. Otherwise, the I/O
2419 * will be sent to the IR volume itself. Since Read6 and Write6 are a
2420 * bit different than the 10/16 CDBs, handle them separately.
2422 pIO_req = (pMpi2SCSIIORequest_t)cm->cm_req;
2423 CDB = pIO_req->CDB.CDB32;
2426 * Handle 6 byte CDBs.
2428 if ((pIO_req->DevHandle == sc->DD_dev_handle) && ((CDB[0] == READ_6) ||
2429 (CDB[0] == WRITE_6))) {
2431 * Get the transfer size in blocks.
2433 io_size = (cm->cm_length >> sc->DD_block_exponent);
2436 * Get virtual LBA given in the CDB.
2438 virtLBA = ((uint64_t)(CDB[1] & 0x1F) << 16) |
2439 ((uint64_t)CDB[2] << 8) | (uint64_t)CDB[3];
2442 * Check that LBA range for I/O does not exceed volume's
2445 if ((virtLBA + (uint64_t)io_size - 1) <=
2448 * Check if the I/O crosses a stripe boundary. If not,
2449 * translate the virtual LBA to a physical LBA and set
2450 * the DevHandle for the PhysDisk to be used. If it
2451 * does cross a boundary, do normal I/O. To get the
2452 * right DevHandle to use, get the map number for the
2453 * column, then use that map number to look up the
2454 * DevHandle of the PhysDisk.
2456 stripe_offset = (uint32_t)virtLBA &
2457 (sc->DD_stripe_size - 1);
2458 if ((stripe_offset + io_size) <= sc->DD_stripe_size) {
2459 physLBA = (uint32_t)virtLBA >>
2460 sc->DD_stripe_exponent;
2461 stripe_unit = physLBA / sc->DD_num_phys_disks;
2462 column = physLBA % sc->DD_num_phys_disks;
2463 pIO_req->DevHandle =
2464 htole16(sc->DD_column_map[column].dev_handle);
2465 /* ???? Is this endian safe*/
2466 cm->cm_desc.SCSIIO.DevHandle =
2469 physLBA = (stripe_unit <<
2470 sc->DD_stripe_exponent) + stripe_offset;
2471 ptrLBA = &pIO_req->CDB.CDB32[1];
2472 physLBA_byte = (uint8_t)(physLBA >> 16);
2473 *ptrLBA = physLBA_byte;
2474 ptrLBA = &pIO_req->CDB.CDB32[2];
2475 physLBA_byte = (uint8_t)(physLBA >> 8);
2476 *ptrLBA = physLBA_byte;
2477 ptrLBA = &pIO_req->CDB.CDB32[3];
2478 physLBA_byte = (uint8_t)physLBA;
2479 *ptrLBA = physLBA_byte;
2482 * Set flag that Direct Drive I/O is
2485 cm->cm_flags |= MPS_CM_FLAGS_DD_IO;
2492 * Handle 10, 12 or 16 byte CDBs.
2494 if ((pIO_req->DevHandle == sc->DD_dev_handle) && ((CDB[0] == READ_10) ||
2495 (CDB[0] == WRITE_10) || (CDB[0] == READ_16) ||
2496 (CDB[0] == WRITE_16) || (CDB[0] == READ_12) ||
2497 (CDB[0] == WRITE_12))) {
2499 * For 16-byte CDB's, verify that the upper 4 bytes of the CDB
2500 * are 0. If not, this is accessing beyond 2TB so handle it in
2501 * the else section. 10-byte and 12-byte CDB's are OK.
2502 * FreeBSD sends very rare 12 byte READ/WRITE, but driver is
2503 * ready to accept 12byte CDB for Direct IOs.
2505 if ((CDB[0] == READ_10 || CDB[0] == WRITE_10) ||
2506 (CDB[0] == READ_12 || CDB[0] == WRITE_12) ||
2507 !(CDB[2] | CDB[3] | CDB[4] | CDB[5])) {
2509 * Get the transfer size in blocks.
2511 io_size = (cm->cm_length >> sc->DD_block_exponent);
2514 * Get virtual LBA. Point to correct lower 4 bytes of
2515 * LBA in the CDB depending on command.
2517 lba_idx = ((CDB[0] == READ_12) ||
2518 (CDB[0] == WRITE_12) ||
2519 (CDB[0] == READ_10) ||
2520 (CDB[0] == WRITE_10))? 2 : 6;
2521 virtLBA = ((uint64_t)CDB[lba_idx] << 24) |
2522 ((uint64_t)CDB[lba_idx + 1] << 16) |
2523 ((uint64_t)CDB[lba_idx + 2] << 8) |
2524 (uint64_t)CDB[lba_idx + 3];
2527 * Check that LBA range for I/O does not exceed volume's
2530 if ((virtLBA + (uint64_t)io_size - 1) <=
2533 * Check if the I/O crosses a stripe boundary.
2534 * If not, translate the virtual LBA to a
2535 * physical LBA and set the DevHandle for the
2536 * PhysDisk to be used. If it does cross a
2537 * boundary, do normal I/O. To get the right
2538 * DevHandle to use, get the map number for the
2539 * column, then use that map number to look up
2540 * the DevHandle of the PhysDisk.
2542 stripe_offset = (uint32_t)virtLBA &
2543 (sc->DD_stripe_size - 1);
2544 if ((stripe_offset + io_size) <=
2545 sc->DD_stripe_size) {
2546 physLBA = (uint32_t)virtLBA >>
2547 sc->DD_stripe_exponent;
2548 stripe_unit = physLBA /
2549 sc->DD_num_phys_disks;
2551 sc->DD_num_phys_disks;
2552 pIO_req->DevHandle =
2553 htole16(sc->DD_column_map[column].
2555 cm->cm_desc.SCSIIO.DevHandle =
2558 physLBA = (stripe_unit <<
2559 sc->DD_stripe_exponent) +
2562 &pIO_req->CDB.CDB32[lba_idx];
2563 physLBA_byte = (uint8_t)(physLBA >> 24);
2564 *ptrLBA = physLBA_byte;
2566 &pIO_req->CDB.CDB32[lba_idx + 1];
2567 physLBA_byte = (uint8_t)(physLBA >> 16);
2568 *ptrLBA = physLBA_byte;
2570 &pIO_req->CDB.CDB32[lba_idx + 2];
2571 physLBA_byte = (uint8_t)(physLBA >> 8);
2572 *ptrLBA = physLBA_byte;
2574 &pIO_req->CDB.CDB32[lba_idx + 3];
2575 physLBA_byte = (uint8_t)physLBA;
2576 *ptrLBA = physLBA_byte;
2579 * Set flag that Direct Drive I/O is
2582 cm->cm_flags |= MPS_CM_FLAGS_DD_IO;
2587 * 16-byte CDB and the upper 4 bytes of the CDB are not
2588 * 0. Get the transfer size in blocks.
2590 io_size = (cm->cm_length >> sc->DD_block_exponent);
2595 virtLBA = ((uint64_t)CDB[2] << 54) |
2596 ((uint64_t)CDB[3] << 48) |
2597 ((uint64_t)CDB[4] << 40) |
2598 ((uint64_t)CDB[5] << 32) |
2599 ((uint64_t)CDB[6] << 24) |
2600 ((uint64_t)CDB[7] << 16) |
2601 ((uint64_t)CDB[8] << 8) |
2605 * Check that LBA range for I/O does not exceed volume's
2608 if ((virtLBA + (uint64_t)io_size - 1) <=
2611 * Check if the I/O crosses a stripe boundary.
2612 * If not, translate the virtual LBA to a
2613 * physical LBA and set the DevHandle for the
2614 * PhysDisk to be used. If it does cross a
2615 * boundary, do normal I/O. To get the right
2616 * DevHandle to use, get the map number for the
2617 * column, then use that map number to look up
2618 * the DevHandle of the PhysDisk.
2620 stripe_offset = (uint32_t)virtLBA &
2621 (sc->DD_stripe_size - 1);
2622 if ((stripe_offset + io_size) <=
2623 sc->DD_stripe_size) {
2624 physLBA = (uint32_t)(virtLBA >>
2625 sc->DD_stripe_exponent);
2626 stripe_unit = physLBA /
2627 sc->DD_num_phys_disks;
2629 sc->DD_num_phys_disks;
2630 pIO_req->DevHandle =
2631 htole16(sc->DD_column_map[column].
2633 cm->cm_desc.SCSIIO.DevHandle =
2636 physLBA = (stripe_unit <<
2637 sc->DD_stripe_exponent) +
2641 * Set upper 4 bytes of LBA to 0. We
2642 * assume that the phys disks are less
2643 * than 2 TB's in size. Then, set the
2646 pIO_req->CDB.CDB32[2] = 0;
2647 pIO_req->CDB.CDB32[3] = 0;
2648 pIO_req->CDB.CDB32[4] = 0;
2649 pIO_req->CDB.CDB32[5] = 0;
2650 ptrLBA = &pIO_req->CDB.CDB32[6];
2651 physLBA_byte = (uint8_t)(physLBA >> 24);
2652 *ptrLBA = physLBA_byte;
2653 ptrLBA = &pIO_req->CDB.CDB32[7];
2654 physLBA_byte = (uint8_t)(physLBA >> 16);
2655 *ptrLBA = physLBA_byte;
2656 ptrLBA = &pIO_req->CDB.CDB32[8];
2657 physLBA_byte = (uint8_t)(physLBA >> 8);
2658 *ptrLBA = physLBA_byte;
2659 ptrLBA = &pIO_req->CDB.CDB32[9];
2660 physLBA_byte = (uint8_t)physLBA;
2661 *ptrLBA = physLBA_byte;
2664 * Set flag that Direct Drive I/O is
2667 cm->cm_flags |= MPS_CM_FLAGS_DD_IO;
2674 #if __FreeBSD_version >= 900026
2676 mpssas_smpio_complete(struct mps_softc *sc, struct mps_command *cm)
2678 MPI2_SMP_PASSTHROUGH_REPLY *rpl;
2679 MPI2_SMP_PASSTHROUGH_REQUEST *req;
2683 ccb = cm->cm_complete_data;
2686 * Currently there should be no way we can hit this case. It only
2687 * happens when we have a failure to allocate chain frames, and SMP
2688 * commands require two S/G elements only. That should be handled
2689 * in the standard request size.
2691 if ((cm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) {
2692 mps_dprint(sc, MPS_ERROR,"%s: cm_flags = %#x on SMP request!\n",
2693 __func__, cm->cm_flags);
2694 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
2698 rpl = (MPI2_SMP_PASSTHROUGH_REPLY *)cm->cm_reply;
2700 mps_dprint(sc, MPS_ERROR, "%s: NULL cm_reply!\n", __func__);
2701 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
2705 req = (MPI2_SMP_PASSTHROUGH_REQUEST *)cm->cm_req;
2706 sasaddr = le32toh(req->SASAddress.Low);
2707 sasaddr |= ((uint64_t)(le32toh(req->SASAddress.High))) << 32;
2709 if ((le16toh(rpl->IOCStatus) & MPI2_IOCSTATUS_MASK) !=
2710 MPI2_IOCSTATUS_SUCCESS ||
2711 rpl->SASStatus != MPI2_SASSTATUS_SUCCESS) {
2712 mps_dprint(sc, MPS_XINFO, "%s: IOCStatus %04x SASStatus %02x\n",
2713 __func__, le16toh(rpl->IOCStatus), rpl->SASStatus);
2714 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
2718 mps_dprint(sc, MPS_XINFO, "%s: SMP request to SAS address "
2719 "%#jx completed successfully\n", __func__,
2720 (uintmax_t)sasaddr);
2722 if (ccb->smpio.smp_response[2] == SMP_FR_ACCEPTED)
2723 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP);
2725 mpssas_set_ccbstatus(ccb, CAM_SMP_STATUS_ERROR);
2729 * We sync in both directions because we had DMAs in the S/G list
2730 * in both directions.
2732 bus_dmamap_sync(sc->buffer_dmat, cm->cm_dmamap,
2733 BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
2734 bus_dmamap_unload(sc->buffer_dmat, cm->cm_dmamap);
2735 mps_free_command(sc, cm);
2740 mpssas_send_smpcmd(struct mpssas_softc *sassc, union ccb *ccb, uint64_t sasaddr)
2742 struct mps_command *cm;
2743 uint8_t *request, *response;
2744 MPI2_SMP_PASSTHROUGH_REQUEST *req;
2745 struct mps_softc *sc;
2752 * XXX We don't yet support physical addresses here.
2754 switch ((ccb->ccb_h.flags & CAM_DATA_MASK)) {
2755 case CAM_DATA_PADDR:
2756 case CAM_DATA_SG_PADDR:
2757 mps_dprint(sc, MPS_ERROR,
2758 "%s: physical addresses not supported\n", __func__);
2759 mpssas_set_ccbstatus(ccb, CAM_REQ_INVALID);
2764 * The chip does not support more than one buffer for the
2765 * request or response.
2767 if ((ccb->smpio.smp_request_sglist_cnt > 1)
2768 || (ccb->smpio.smp_response_sglist_cnt > 1)) {
2769 mps_dprint(sc, MPS_ERROR,
2770 "%s: multiple request or response "
2771 "buffer segments not supported for SMP\n",
2773 mpssas_set_ccbstatus(ccb, CAM_REQ_INVALID);
2779 * The CAM_SCATTER_VALID flag was originally implemented
2780 * for the XPT_SCSI_IO CCB, which only has one data pointer.
2781 * We have two. So, just take that flag to mean that we
2782 * might have S/G lists, and look at the S/G segment count
2783 * to figure out whether that is the case for each individual
2786 if (ccb->smpio.smp_request_sglist_cnt != 0) {
2787 bus_dma_segment_t *req_sg;
2789 req_sg = (bus_dma_segment_t *)ccb->smpio.smp_request;
2790 request = (uint8_t *)(uintptr_t)req_sg[0].ds_addr;
2792 request = ccb->smpio.smp_request;
2794 if (ccb->smpio.smp_response_sglist_cnt != 0) {
2795 bus_dma_segment_t *rsp_sg;
2797 rsp_sg = (bus_dma_segment_t *)ccb->smpio.smp_response;
2798 response = (uint8_t *)(uintptr_t)rsp_sg[0].ds_addr;
2800 response = ccb->smpio.smp_response;
2802 case CAM_DATA_VADDR:
2803 request = ccb->smpio.smp_request;
2804 response = ccb->smpio.smp_response;
2807 mpssas_set_ccbstatus(ccb, CAM_REQ_INVALID);
2812 cm = mps_alloc_command(sc);
2814 mps_dprint(sc, MPS_ERROR,
2815 "%s: cannot allocate command\n", __func__);
2816 mpssas_set_ccbstatus(ccb, CAM_RESRC_UNAVAIL);
2821 req = (MPI2_SMP_PASSTHROUGH_REQUEST *)cm->cm_req;
2822 bzero(req, sizeof(*req));
2823 req->Function = MPI2_FUNCTION_SMP_PASSTHROUGH;
2825 /* Allow the chip to use any route to this SAS address. */
2826 req->PhysicalPort = 0xff;
2828 req->RequestDataLength = htole16(ccb->smpio.smp_request_len);
2830 MPI2_SGLFLAGS_SYSTEM_ADDRESS_SPACE | MPI2_SGLFLAGS_SGL_TYPE_MPI;
2832 mps_dprint(sc, MPS_XINFO, "%s: sending SMP request to SAS "
2833 "address %#jx\n", __func__, (uintmax_t)sasaddr);
2835 mpi_init_sge(cm, req, &req->SGL);
2838 * Set up a uio to pass into mps_map_command(). This allows us to
2839 * do one map command, and one busdma call in there.
2841 cm->cm_uio.uio_iov = cm->cm_iovec;
2842 cm->cm_uio.uio_iovcnt = 2;
2843 cm->cm_uio.uio_segflg = UIO_SYSSPACE;
2846 * The read/write flag isn't used by busdma, but set it just in
2847 * case. This isn't exactly accurate, either, since we're going in
2850 cm->cm_uio.uio_rw = UIO_WRITE;
2852 cm->cm_iovec[0].iov_base = request;
2853 cm->cm_iovec[0].iov_len = le16toh(req->RequestDataLength);
2854 cm->cm_iovec[1].iov_base = response;
2855 cm->cm_iovec[1].iov_len = ccb->smpio.smp_response_len;
2857 cm->cm_uio.uio_resid = cm->cm_iovec[0].iov_len +
2858 cm->cm_iovec[1].iov_len;
2861 * Trigger a warning message in mps_data_cb() for the user if we
2862 * wind up exceeding two S/G segments. The chip expects one
2863 * segment for the request and another for the response.
2865 cm->cm_max_segs = 2;
2867 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
2868 cm->cm_complete = mpssas_smpio_complete;
2869 cm->cm_complete_data = ccb;
2872 * Tell the mapping code that we're using a uio, and that this is
2873 * an SMP passthrough request. There is a little special-case
2874 * logic there (in mps_data_cb()) to handle the bidirectional
2877 cm->cm_flags |= MPS_CM_FLAGS_USE_UIO | MPS_CM_FLAGS_SMP_PASS |
2878 MPS_CM_FLAGS_DATAIN | MPS_CM_FLAGS_DATAOUT;
2880 /* The chip data format is little endian. */
2881 req->SASAddress.High = htole32(sasaddr >> 32);
2882 req->SASAddress.Low = htole32(sasaddr);
2885 * XXX Note that we don't have a timeout/abort mechanism here.
2886 * From the manual, it looks like task management requests only
2887 * work for SCSI IO and SATA passthrough requests. We may need to
2888 * have a mechanism to retry requests in the event of a chip reset
2889 * at least. Hopefully the chip will insure that any errors short
2890 * of that are relayed back to the driver.
2892 error = mps_map_command(sc, cm);
2893 if ((error != 0) && (error != EINPROGRESS)) {
2894 mps_dprint(sc, MPS_ERROR,
2895 "%s: error %d returned from mps_map_command()\n",
2903 mps_free_command(sc, cm);
2904 mpssas_set_ccbstatus(ccb, CAM_RESRC_UNAVAIL);
2911 mpssas_action_smpio(struct mpssas_softc *sassc, union ccb *ccb)
2913 struct mps_softc *sc;
2914 struct mpssas_target *targ;
2915 uint64_t sasaddr = 0;
2920 * Make sure the target exists.
2922 KASSERT(ccb->ccb_h.target_id < sassc->maxtargets,
2923 ("Target %d out of bounds in XPT_SMP_IO\n", ccb->ccb_h.target_id));
2924 targ = &sassc->targets[ccb->ccb_h.target_id];
2925 if (targ->handle == 0x0) {
2926 mps_dprint(sc, MPS_ERROR,
2927 "%s: target %d does not exist!\n", __func__,
2928 ccb->ccb_h.target_id);
2929 mpssas_set_ccbstatus(ccb, CAM_SEL_TIMEOUT);
2935 * If this device has an embedded SMP target, we'll talk to it
2937 * figure out what the expander's address is.
2939 if ((targ->devinfo & MPI2_SAS_DEVICE_INFO_SMP_TARGET) != 0)
2940 sasaddr = targ->sasaddr;
2943 * If we don't have a SAS address for the expander yet, try
2944 * grabbing it from the page 0x83 information cached in the
2945 * transport layer for this target. LSI expanders report the
2946 * expander SAS address as the port-associated SAS address in
2947 * Inquiry VPD page 0x83. Maxim expanders don't report it in page
2950 * XXX KDM disable this for now, but leave it commented out so that
2951 * it is obvious that this is another possible way to get the SAS
2954 * The parent handle method below is a little more reliable, and
2955 * the other benefit is that it works for devices other than SES
2956 * devices. So you can send a SMP request to a da(4) device and it
2957 * will get routed to the expander that device is attached to.
2958 * (Assuming the da(4) device doesn't contain an SMP target...)
2962 sasaddr = xpt_path_sas_addr(ccb->ccb_h.path);
2966 * If we still don't have a SAS address for the expander, look for
2967 * the parent device of this device, which is probably the expander.
2970 #ifdef OLD_MPS_PROBE
2971 struct mpssas_target *parent_target;
2974 if (targ->parent_handle == 0x0) {
2975 mps_dprint(sc, MPS_ERROR,
2976 "%s: handle %d does not have a valid "
2977 "parent handle!\n", __func__, targ->handle);
2978 mpssas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
2981 #ifdef OLD_MPS_PROBE
2982 parent_target = mpssas_find_target_by_handle(sassc, 0,
2983 targ->parent_handle);
2985 if (parent_target == NULL) {
2986 mps_dprint(sc, MPS_ERROR,
2987 "%s: handle %d does not have a valid "
2988 "parent target!\n", __func__, targ->handle);
2989 mpssas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
2993 if ((parent_target->devinfo &
2994 MPI2_SAS_DEVICE_INFO_SMP_TARGET) == 0) {
2995 mps_dprint(sc, MPS_ERROR,
2996 "%s: handle %d parent %d does not "
2997 "have an SMP target!\n", __func__,
2998 targ->handle, parent_target->handle);
2999 mpssas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
3004 sasaddr = parent_target->sasaddr;
3005 #else /* OLD_MPS_PROBE */
3006 if ((targ->parent_devinfo &
3007 MPI2_SAS_DEVICE_INFO_SMP_TARGET) == 0) {
3008 mps_dprint(sc, MPS_ERROR,
3009 "%s: handle %d parent %d does not "
3010 "have an SMP target!\n", __func__,
3011 targ->handle, targ->parent_handle);
3012 mpssas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
3016 if (targ->parent_sasaddr == 0x0) {
3017 mps_dprint(sc, MPS_ERROR,
3018 "%s: handle %d parent handle %d does "
3019 "not have a valid SAS address!\n",
3020 __func__, targ->handle, targ->parent_handle);
3021 mpssas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
3025 sasaddr = targ->parent_sasaddr;
3026 #endif /* OLD_MPS_PROBE */
3031 mps_dprint(sc, MPS_INFO,
3032 "%s: unable to find SAS address for handle %d\n",
3033 __func__, targ->handle);
3034 mpssas_set_ccbstatus(ccb, CAM_DEV_NOT_THERE);
3037 mpssas_send_smpcmd(sassc, ccb, sasaddr);
3045 #endif //__FreeBSD_version >= 900026
3048 mpssas_action_resetdev(struct mpssas_softc *sassc, union ccb *ccb)
3050 MPI2_SCSI_TASK_MANAGE_REQUEST *req;
3051 struct mps_softc *sc;
3052 struct mps_command *tm;
3053 struct mpssas_target *targ;
3055 MPS_FUNCTRACE(sassc->sc);
3056 mtx_assert(&sassc->sc->mps_mtx, MA_OWNED);
3058 KASSERT(ccb->ccb_h.target_id < sassc->maxtargets,
3059 ("Target %d out of bounds in XPT_RESET_DEV\n",
3060 ccb->ccb_h.target_id));
3062 tm = mpssas_alloc_tm(sc);
3064 mps_dprint(sc, MPS_ERROR,
3065 "command alloc failure in mpssas_action_resetdev\n");
3066 mpssas_set_ccbstatus(ccb, CAM_RESRC_UNAVAIL);
3071 targ = &sassc->targets[ccb->ccb_h.target_id];
3072 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
3073 req->DevHandle = htole16(targ->handle);
3074 req->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
3076 /* SAS Hard Link Reset / SATA Link Reset */
3077 req->MsgFlags = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET;
3080 tm->cm_complete = mpssas_resetdev_complete;
3081 tm->cm_complete_data = ccb;
3084 mpssas_prepare_for_tm(sc, tm, targ, CAM_LUN_WILDCARD);
3085 mps_map_command(sc, tm);
3089 mpssas_resetdev_complete(struct mps_softc *sc, struct mps_command *tm)
3091 MPI2_SCSI_TASK_MANAGE_REPLY *resp;
3095 mtx_assert(&sc->mps_mtx, MA_OWNED);
3097 resp = (MPI2_SCSI_TASK_MANAGE_REPLY *)tm->cm_reply;
3098 ccb = tm->cm_complete_data;
3101 * Currently there should be no way we can hit this case. It only
3102 * happens when we have a failure to allocate chain frames, and
3103 * task management commands don't have S/G lists.
3105 if ((tm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) {
3106 MPI2_SCSI_TASK_MANAGE_REQUEST *req;
3108 req = (MPI2_SCSI_TASK_MANAGE_REQUEST *)tm->cm_req;
3110 mps_dprint(sc, MPS_ERROR,
3111 "%s: cm_flags = %#x for reset of handle %#04x! "
3112 "This should not happen!\n", __func__, tm->cm_flags,
3114 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
3118 mps_dprint(sc, MPS_XINFO,
3119 "%s: IOCStatus = 0x%x ResponseCode = 0x%x\n", __func__,
3120 le16toh(resp->IOCStatus), le32toh(resp->ResponseCode));
3122 if (le32toh(resp->ResponseCode) == MPI2_SCSITASKMGMT_RSP_TM_COMPLETE) {
3123 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP);
3124 mpssas_announce_reset(sc, AC_SENT_BDR, tm->cm_targ->tid,
3128 mpssas_set_ccbstatus(ccb, CAM_REQ_CMP_ERR);
3132 mpssas_free_tm(sc, tm);
3137 mpssas_poll(struct cam_sim *sim)
3139 struct mpssas_softc *sassc;
3141 sassc = cam_sim_softc(sim);
3143 if (sassc->sc->mps_debug & MPS_TRACE) {
3144 /* frequent debug messages during a panic just slow
3145 * everything down too much.
3147 mps_printf(sassc->sc, "%s clearing MPS_TRACE\n", __func__);
3148 sassc->sc->mps_debug &= ~MPS_TRACE;
3151 mps_intr_locked(sassc->sc);
3155 mpssas_async(void *callback_arg, uint32_t code, struct cam_path *path,
3158 struct mps_softc *sc;
3160 sc = (struct mps_softc *)callback_arg;
3163 #if (__FreeBSD_version >= 1000006) || \
3164 ((__FreeBSD_version >= 901503) && (__FreeBSD_version < 1000000))
3165 case AC_ADVINFO_CHANGED: {
3166 struct mpssas_target *target;
3167 struct mpssas_softc *sassc;
3168 struct scsi_read_capacity_data_long rcap_buf;
3169 struct ccb_dev_advinfo cdai;
3170 struct mpssas_lun *lun;
3175 buftype = (uintptr_t)arg;
3181 * We're only interested in read capacity data changes.
3183 if (buftype != CDAI_TYPE_RCAPLONG)
3187 * We should have a handle for this, but check to make sure.
3189 KASSERT(xpt_path_target_id(path) < sassc->maxtargets,
3190 ("Target %d out of bounds in mpssas_async\n",
3191 xpt_path_target_id(path)));
3192 target = &sassc->targets[xpt_path_target_id(path)];
3193 if (target->handle == 0)
3196 lunid = xpt_path_lun_id(path);
3198 SLIST_FOREACH(lun, &target->luns, lun_link) {
3199 if (lun->lun_id == lunid) {
3205 if (found_lun == 0) {
3206 lun = malloc(sizeof(struct mpssas_lun), M_MPT2,
3209 mps_dprint(sc, MPS_ERROR, "Unable to alloc "
3210 "LUN for EEDP support.\n");
3213 lun->lun_id = lunid;
3214 SLIST_INSERT_HEAD(&target->luns, lun, lun_link);
3217 bzero(&rcap_buf, sizeof(rcap_buf));
3218 xpt_setup_ccb(&cdai.ccb_h, path, CAM_PRIORITY_NORMAL);
3219 cdai.ccb_h.func_code = XPT_DEV_ADVINFO;
3220 cdai.ccb_h.flags = CAM_DIR_IN;
3221 cdai.buftype = CDAI_TYPE_RCAPLONG;
3222 #if (__FreeBSD_version >= 1100061) || \
3223 ((__FreeBSD_version >= 1001510) && (__FreeBSD_version < 1100000))
3224 cdai.flags = CDAI_FLAG_NONE;
3228 cdai.bufsiz = sizeof(rcap_buf);
3229 cdai.buf = (uint8_t *)&rcap_buf;
3230 xpt_action((union ccb *)&cdai);
3231 if ((cdai.ccb_h.status & CAM_DEV_QFRZN) != 0)
3232 cam_release_devq(cdai.ccb_h.path,
3235 if ((mpssas_get_ccbstatus((union ccb *)&cdai) == CAM_REQ_CMP)
3236 && (rcap_buf.prot & SRC16_PROT_EN)) {
3237 switch (rcap_buf.prot & SRC16_P_TYPE) {
3240 lun->eedp_formatted = TRUE;
3241 lun->eedp_block_size =
3242 scsi_4btoul(rcap_buf.length);
3246 lun->eedp_formatted = FALSE;
3247 lun->eedp_block_size = 0;
3251 lun->eedp_formatted = FALSE;
3252 lun->eedp_block_size = 0;
3257 case AC_FOUND_DEVICE: {
3258 struct ccb_getdev *cgd;
3261 mpssas_check_eedp(sc, path, cgd);
3270 #if (__FreeBSD_version < 901503) || \
3271 ((__FreeBSD_version >= 1000000) && (__FreeBSD_version < 1000006))
3273 mpssas_check_eedp(struct mps_softc *sc, struct cam_path *path,
3274 struct ccb_getdev *cgd)
3276 struct mpssas_softc *sassc = sc->sassc;
3277 struct ccb_scsiio *csio;
3278 struct scsi_read_capacity_16 *scsi_cmd;
3279 struct scsi_read_capacity_eedp *rcap_buf;
3281 target_id_t targetid;
3284 struct cam_path *local_path;
3285 struct mpssas_target *target;
3286 struct mpssas_lun *lun;
3291 pathid = cam_sim_path(sassc->sim);
3292 targetid = xpt_path_target_id(path);
3293 lunid = xpt_path_lun_id(path);
3295 KASSERT(targetid < sassc->maxtargets,
3296 ("Target %d out of bounds in mpssas_check_eedp\n",
3298 target = &sassc->targets[targetid];
3299 if (target->handle == 0x0)
3303 * Determine if the device is EEDP capable.
3305 * If this flag is set in the inquiry data,
3306 * the device supports protection information,
3307 * and must support the 16 byte read
3308 * capacity command, otherwise continue without
3309 * sending read cap 16
3311 if ((cgd->inq_data.spc3_flags & SPC3_SID_PROTECT) == 0)
3315 * Issue a READ CAPACITY 16 command. This info
3316 * is used to determine if the LUN is formatted
3319 ccb = xpt_alloc_ccb_nowait();
3321 mps_dprint(sc, MPS_ERROR, "Unable to alloc CCB "
3322 "for EEDP support.\n");
3326 if (xpt_create_path(&local_path, xpt_periph,
3327 pathid, targetid, lunid) != CAM_REQ_CMP) {
3328 mps_dprint(sc, MPS_ERROR, "Unable to create "
3329 "path for EEDP support\n");
3335 * If LUN is already in list, don't create a new
3339 SLIST_FOREACH(lun, &target->luns, lun_link) {
3340 if (lun->lun_id == lunid) {
3346 lun = malloc(sizeof(struct mpssas_lun), M_MPT2,
3349 mps_dprint(sc, MPS_ERROR,
3350 "Unable to alloc LUN for EEDP support.\n");
3351 xpt_free_path(local_path);
3355 lun->lun_id = lunid;
3356 SLIST_INSERT_HEAD(&target->luns, lun,
3360 xpt_path_string(local_path, path_str, sizeof(path_str));
3362 mps_dprint(sc, MPS_INFO, "Sending read cap: path %s handle %d\n",
3363 path_str, target->handle);
3366 * Issue a READ CAPACITY 16 command for the LUN.
3367 * The mpssas_read_cap_done function will load
3368 * the read cap info into the LUN struct.
3370 rcap_buf = malloc(sizeof(struct scsi_read_capacity_eedp),
3371 M_MPT2, M_NOWAIT | M_ZERO);
3372 if (rcap_buf == NULL) {
3373 mps_dprint(sc, MPS_FAULT,
3374 "Unable to alloc read capacity buffer for EEDP support.\n");
3375 xpt_free_path(ccb->ccb_h.path);
3379 xpt_setup_ccb(&ccb->ccb_h, local_path, CAM_PRIORITY_XPT);
3381 csio->ccb_h.func_code = XPT_SCSI_IO;
3382 csio->ccb_h.flags = CAM_DIR_IN;
3383 csio->ccb_h.retry_count = 4;
3384 csio->ccb_h.cbfcnp = mpssas_read_cap_done;
3385 csio->ccb_h.timeout = 60000;
3386 csio->data_ptr = (uint8_t *)rcap_buf;
3387 csio->dxfer_len = sizeof(struct scsi_read_capacity_eedp);
3388 csio->sense_len = MPS_SENSE_LEN;
3389 csio->cdb_len = sizeof(*scsi_cmd);
3390 csio->tag_action = MSG_SIMPLE_Q_TAG;
3392 scsi_cmd = (struct scsi_read_capacity_16 *)&csio->cdb_io.cdb_bytes;
3393 bzero(scsi_cmd, sizeof(*scsi_cmd));
3394 scsi_cmd->opcode = 0x9E;
3395 scsi_cmd->service_action = SRC16_SERVICE_ACTION;
3396 ((uint8_t *)scsi_cmd)[13] = sizeof(struct scsi_read_capacity_eedp);
3398 ccb->ccb_h.ppriv_ptr1 = sassc;
3403 mpssas_read_cap_done(struct cam_periph *periph, union ccb *done_ccb)
3405 struct mpssas_softc *sassc;
3406 struct mpssas_target *target;
3407 struct mpssas_lun *lun;
3408 struct scsi_read_capacity_eedp *rcap_buf;
3410 if (done_ccb == NULL)
3413 /* Driver need to release devq, it Scsi command is
3414 * generated by driver internally.
3415 * Currently there is a single place where driver
3416 * calls scsi command internally. In future if driver
3417 * calls more scsi command internally, it needs to release
3418 * devq internally, since those command will not go back to
3421 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) ) {
3422 done_ccb->ccb_h.status &= ~CAM_DEV_QFRZN;
3423 xpt_release_devq(done_ccb->ccb_h.path,
3424 /*count*/ 1, /*run_queue*/TRUE);
3427 rcap_buf = (struct scsi_read_capacity_eedp *)done_ccb->csio.data_ptr;
3430 * Get the LUN ID for the path and look it up in the LUN list for the
3433 sassc = (struct mpssas_softc *)done_ccb->ccb_h.ppriv_ptr1;
3434 KASSERT(done_ccb->ccb_h.target_id < sassc->maxtargets,
3435 ("Target %d out of bounds in mpssas_read_cap_done\n",
3436 done_ccb->ccb_h.target_id));
3437 target = &sassc->targets[done_ccb->ccb_h.target_id];
3438 SLIST_FOREACH(lun, &target->luns, lun_link) {
3439 if (lun->lun_id != done_ccb->ccb_h.target_lun)
3443 * Got the LUN in the target's LUN list. Fill it in
3444 * with EEDP info. If the READ CAP 16 command had some
3445 * SCSI error (common if command is not supported), mark
3446 * the lun as not supporting EEDP and set the block size
3449 if ((mpssas_get_ccbstatus(done_ccb) != CAM_REQ_CMP)
3450 || (done_ccb->csio.scsi_status != SCSI_STATUS_OK)) {
3451 lun->eedp_formatted = FALSE;
3452 lun->eedp_block_size = 0;
3456 if (rcap_buf->protect & 0x01) {
3457 mps_dprint(sassc->sc, MPS_INFO, "LUN %d for "
3458 "target ID %d is formatted for EEDP "
3459 "support.\n", done_ccb->ccb_h.target_lun,
3460 done_ccb->ccb_h.target_id);
3461 lun->eedp_formatted = TRUE;
3462 lun->eedp_block_size = scsi_4btoul(rcap_buf->length);
3467 // Finished with this CCB and path.
3468 free(rcap_buf, M_MPT2);
3469 xpt_free_path(done_ccb->ccb_h.path);
3470 xpt_free_ccb(done_ccb);
3472 #endif /* (__FreeBSD_version < 901503) || \
3473 ((__FreeBSD_version >= 1000000) && (__FreeBSD_version < 1000006)) */
3476 * Set the INRESET flag for this target so that no I/O will be sent to
3477 * the target until the reset has completed. If an I/O request does
3478 * happen, the devq will be frozen. The CCB holds the path which is
3479 * used to release the devq. The devq is released and the CCB is freed
3480 * when the TM completes.
3483 mpssas_prepare_for_tm(struct mps_softc *sc, struct mps_command *tm,
3484 struct mpssas_target *target, lun_id_t lun_id)
3489 ccb = xpt_alloc_ccb_nowait();
3491 path_id = cam_sim_path(sc->sassc->sim);
3492 if (xpt_create_path(&ccb->ccb_h.path, xpt_periph, path_id,
3493 target->tid, lun_id) != CAM_REQ_CMP) {
3497 tm->cm_targ = target;
3498 target->flags |= MPSSAS_TARGET_INRESET;
3504 mpssas_startup(struct mps_softc *sc)
3508 * Send the port enable message and set the wait_for_port_enable flag.
3509 * This flag helps to keep the simq frozen until all discovery events
3512 sc->wait_for_port_enable = 1;
3513 mpssas_send_portenable(sc);
3518 mpssas_send_portenable(struct mps_softc *sc)
3520 MPI2_PORT_ENABLE_REQUEST *request;
3521 struct mps_command *cm;
3525 if ((cm = mps_alloc_command(sc)) == NULL)
3527 request = (MPI2_PORT_ENABLE_REQUEST *)cm->cm_req;
3528 request->Function = MPI2_FUNCTION_PORT_ENABLE;
3529 request->MsgFlags = 0;
3531 cm->cm_desc.Default.RequestFlags = MPI2_REQ_DESCRIPT_FLAGS_DEFAULT_TYPE;
3532 cm->cm_complete = mpssas_portenable_complete;
3536 mps_map_command(sc, cm);
3537 mps_dprint(sc, MPS_XINFO,
3538 "mps_send_portenable finished cm %p req %p complete %p\n",
3539 cm, cm->cm_req, cm->cm_complete);
3544 mpssas_portenable_complete(struct mps_softc *sc, struct mps_command *cm)
3546 MPI2_PORT_ENABLE_REPLY *reply;
3547 struct mpssas_softc *sassc;
3553 * Currently there should be no way we can hit this case. It only
3554 * happens when we have a failure to allocate chain frames, and
3555 * port enable commands don't have S/G lists.
3557 if ((cm->cm_flags & MPS_CM_FLAGS_ERROR_MASK) != 0) {
3558 mps_dprint(sc, MPS_ERROR, "%s: cm_flags = %#x for port enable! "
3559 "This should not happen!\n", __func__, cm->cm_flags);
3562 reply = (MPI2_PORT_ENABLE_REPLY *)cm->cm_reply;
3564 mps_dprint(sc, MPS_FAULT, "Portenable NULL reply\n");
3565 else if (le16toh(reply->IOCStatus & MPI2_IOCSTATUS_MASK) !=
3566 MPI2_IOCSTATUS_SUCCESS)
3567 mps_dprint(sc, MPS_FAULT, "Portenable failed\n");
3569 mps_free_command(sc, cm);
3572 * Get WarpDrive info after discovery is complete but before the scan
3573 * starts. At this point, all devices are ready to be exposed to the
3574 * OS. If devices should be hidden instead, take them out of the
3575 * 'targets' array before the scan. The devinfo for a disk will have
3576 * some info and a volume's will be 0. Use that to remove disks.
3578 mps_wd_config_pages(sc);
3581 * Done waiting for port enable to complete. Decrement the refcount.
3582 * If refcount is 0, discovery is complete and a rescan of the bus can
3583 * take place. Since the simq was explicitly frozen before port
3584 * enable, it must be explicitly released here to keep the
3585 * freeze/release count in sync.
3587 sc->wait_for_port_enable = 0;
3588 sc->port_enable_complete = 1;
3589 wakeup(&sc->port_enable_complete);
3590 mpssas_startup_decrement(sassc);
3594 mpssas_check_id(struct mpssas_softc *sassc, int id)
3596 struct mps_softc *sc = sassc->sc;
3600 ids = &sc->exclude_ids[0];
3601 while((name = strsep(&ids, ",")) != NULL) {
3602 if (name[0] == '\0')
3604 if (strtol(name, NULL, 0) == (long)id)
3612 mpssas_realloc_targets(struct mps_softc *sc, int maxtargets)
3614 struct mpssas_softc *sassc;
3615 struct mpssas_lun *lun, *lun_tmp;
3616 struct mpssas_target *targ;
3621 * The number of targets is based on IOC Facts, so free all of
3622 * the allocated LUNs for each target and then the target buffer
3625 for (i=0; i< maxtargets; i++) {
3626 targ = &sassc->targets[i];
3627 SLIST_FOREACH_SAFE(lun, &targ->luns, lun_link, lun_tmp) {
3631 free(sassc->targets, M_MPT2);
3633 sassc->targets = malloc(sizeof(struct mpssas_target) * maxtargets,
3634 M_MPT2, M_WAITOK|M_ZERO);
3635 if (!sassc->targets) {
3636 panic("%s failed to alloc targets with error %d\n",