/* $NetBSD: mpt_netbsd.c,v 1.40 2024/02/09 22:08:34 andvar Exp $ */ /* * Copyright (c) 2003 Wasabi Systems, Inc. * All rights reserved. * * Written by Jason R. Thorpe for Wasabi Systems, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed for the NetBSD Project by * Wasabi Systems, Inc. * 4. The name of Wasabi Systems, Inc. may not be used to endorse * or promote products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /* * Copyright (c) 2000, 2001 by Greg Ansley * Partially derived from Matt Jacob's ISP driver. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice immediately at the beginning of the file, without modification, * this list of conditions, and the following disclaimer. * 2. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * Additional Copyright (c) 2002 by Matthew Jacob under same license. */ /* * mpt_netbsd.c: * * NetBSD-specific routines for LSI Fusion adapters. Includes some * bus_dma glue, and SCSIPI glue. * * Adapted from the FreeBSD "mpt" driver by Jason R. Thorpe for * Wasabi Systems, Inc. * * Additional contributions by Garrett D'Amore on behalf of TELES AG. */ #include __KERNEL_RCSID(0, "$NetBSD: mpt_netbsd.c,v 1.40 2024/02/09 22:08:34 andvar Exp $"); #include "bio.h" #include /* pulls in all headers */ #include #if NBIO > 0 #include #endif static int mpt_poll(mpt_softc_t *, struct scsipi_xfer *, int); static void mpt_timeout(void *); static void mpt_restart(mpt_softc_t *, request_t *); static void mpt_done(mpt_softc_t *, uint32_t); static int mpt_drain_queue(mpt_softc_t *); static void mpt_run_xfer(mpt_softc_t *, struct scsipi_xfer *); static void mpt_set_xfer_mode(mpt_softc_t *, struct scsipi_xfer_mode *); static void mpt_get_xfer_mode(mpt_softc_t *, struct scsipi_periph *); static void mpt_ctlop(mpt_softc_t *, void *vmsg, uint32_t); static void mpt_event_notify_reply(mpt_softc_t *, MSG_EVENT_NOTIFY_REPLY *); static void mpt_bus_reset(mpt_softc_t *); static void mpt_scsipi_request(struct scsipi_channel *, scsipi_adapter_req_t, void *); static void mpt_minphys(struct buf *); static int mpt_ioctl(struct scsipi_channel *, u_long, void *, int, struct proc *); #if NBIO > 0 static bool mpt_is_raid(mpt_softc_t *); static int mpt_bio_ioctl(device_t, u_long, void *); static int mpt_bio_ioctl_inq(mpt_softc_t *, struct bioc_inq *); static int mpt_bio_ioctl_vol(mpt_softc_t *, struct bioc_vol *); static int mpt_bio_ioctl_disk(mpt_softc_t *, struct bioc_disk *); static int mpt_bio_ioctl_disk_novol(mpt_softc_t *, struct bioc_disk *); #endif void mpt_scsipi_attach(mpt_softc_t *mpt) { struct scsipi_adapter *adapt = &mpt->sc_adapter; struct scsipi_channel *chan = &mpt->sc_channel; int maxq; mpt->bus = 0; /* XXX ?? */ maxq = (mpt->mpt_global_credits < MPT_MAX_REQUESTS(mpt)) ? mpt->mpt_global_credits : MPT_MAX_REQUESTS(mpt); /* Fill in the scsipi_adapter. */ memset(adapt, 0, sizeof(*adapt)); adapt->adapt_dev = mpt->sc_dev; adapt->adapt_nchannels = 1; adapt->adapt_openings = maxq - 2; /* Reserve 2 for driver use*/ adapt->adapt_max_periph = maxq - 2; adapt->adapt_request = mpt_scsipi_request; adapt->adapt_minphys = mpt_minphys; adapt->adapt_ioctl = mpt_ioctl; /* Fill in the scsipi_channel. */ memset(chan, 0, sizeof(*chan)); chan->chan_adapter = adapt; if (mpt->is_sas) { chan->chan_bustype = &scsi_sas_bustype; } else if (mpt->is_fc) { chan->chan_bustype = &scsi_fc_bustype; } else { chan->chan_bustype = &scsi_bustype; } chan->chan_channel = 0; chan->chan_flags = 0; chan->chan_nluns = 8; chan->chan_ntargets = mpt->mpt_max_devices ? mpt->mpt_max_devices : 256; chan->chan_id = mpt->mpt_ini_id; /* * Save the output of the config so we can rescan the bus in case of * errors */ mpt->sc_scsibus_dv = config_found(mpt->sc_dev, &mpt->sc_channel, scsiprint, CFARGS_NONE); #if NBIO > 0 if (mpt_is_raid(mpt)) { if (bio_register(mpt->sc_dev, mpt_bio_ioctl) != 0) panic("%s: controller registration failed", device_xname(mpt->sc_dev)); } #endif } int mpt_dma_mem_alloc(mpt_softc_t *mpt) { bus_dma_segment_t reply_seg, request_seg; int reply_rseg, request_rseg; bus_addr_t pptr, end; char *vptr; size_t len; int error, i; /* Check if we have already allocated the reply memory. */ if (mpt->reply != NULL) return (0); /* * Allocate the request pool. This isn't really DMA'd memory, * but it's a convenient place to do it. */ len = sizeof(request_t) * MPT_MAX_REQUESTS(mpt); mpt->request_pool = malloc(len, M_DEVBUF, M_WAITOK | M_ZERO); if (mpt->request_pool == NULL) { aprint_error_dev(mpt->sc_dev, "unable to allocate request pool\n"); return (ENOMEM); } /* * Allocate DMA resources for reply buffers. */ error = bus_dmamem_alloc(mpt->sc_dmat, PAGE_SIZE, PAGE_SIZE, 0, &reply_seg, 1, &reply_rseg, 0); if (error) { aprint_error_dev(mpt->sc_dev, "unable to allocate reply area, error = %d\n", error); goto fail_0; } error = bus_dmamem_map(mpt->sc_dmat, &reply_seg, reply_rseg, PAGE_SIZE, (void **) &mpt->reply, BUS_DMA_COHERENT/*XXX*/); if (error) { aprint_error_dev(mpt->sc_dev, "unable to map reply area, error = %d\n", error); goto fail_1; } error = bus_dmamap_create(mpt->sc_dmat, PAGE_SIZE, 1, PAGE_SIZE, 0, 0, &mpt->reply_dmap); if (error) { aprint_error_dev(mpt->sc_dev, "unable to create reply DMA map, error = %d\n", error); goto fail_2; } error = bus_dmamap_load(mpt->sc_dmat, mpt->reply_dmap, mpt->reply, PAGE_SIZE, NULL, 0); if (error) { aprint_error_dev(mpt->sc_dev, "unable to load reply DMA map, error = %d\n", error); goto fail_3; } mpt->reply_phys = mpt->reply_dmap->dm_segs[0].ds_addr; /* * Allocate DMA resources for request buffers. */ error = bus_dmamem_alloc(mpt->sc_dmat, MPT_REQ_MEM_SIZE(mpt), PAGE_SIZE, 0, &request_seg, 1, &request_rseg, 0); if (error) { aprint_error_dev(mpt->sc_dev, "unable to allocate request area, " "error = %d\n", error); goto fail_4; } error = bus_dmamem_map(mpt->sc_dmat, &request_seg, request_rseg, MPT_REQ_MEM_SIZE(mpt), (void **) &mpt->request, 0); if (error) { aprint_error_dev(mpt->sc_dev, "unable to map request area, error = %d\n", error); goto fail_5; } error = bus_dmamap_create(mpt->sc_dmat, MPT_REQ_MEM_SIZE(mpt), 1, MPT_REQ_MEM_SIZE(mpt), 0, 0, &mpt->request_dmap); if (error) { aprint_error_dev(mpt->sc_dev, "unable to create request DMA map, " "error = %d\n", error); goto fail_6; } error = bus_dmamap_load(mpt->sc_dmat, mpt->request_dmap, mpt->request, MPT_REQ_MEM_SIZE(mpt), NULL, 0); if (error) { aprint_error_dev(mpt->sc_dev, "unable to load request DMA map, error = %d\n", error); goto fail_7; } mpt->request_phys = mpt->request_dmap->dm_segs[0].ds_addr; pptr = mpt->request_phys; vptr = (void *) mpt->request; end = pptr + MPT_REQ_MEM_SIZE(mpt); for (i = 0; pptr < end; i++) { request_t *req = &mpt->request_pool[i]; req->index = i; /* Store location of Request Data */ req->req_pbuf = pptr; req->req_vbuf = vptr; pptr += MPT_REQUEST_AREA; vptr += MPT_REQUEST_AREA; req->sense_pbuf = (pptr - MPT_SENSE_SIZE); req->sense_vbuf = (vptr - MPT_SENSE_SIZE); error = bus_dmamap_create(mpt->sc_dmat, MAXPHYS, MPT_SGL_MAX, MAXPHYS, 0, 0, &req->dmap); if (error) { aprint_error_dev(mpt->sc_dev, "unable to create req %d DMA map, " "error = %d\n", i, error); goto fail_8; } } return (0); fail_8: for (--i; i >= 0; i--) { request_t *req = &mpt->request_pool[i]; if (req->dmap != NULL) bus_dmamap_destroy(mpt->sc_dmat, req->dmap); } bus_dmamap_unload(mpt->sc_dmat, mpt->request_dmap); fail_7: bus_dmamap_destroy(mpt->sc_dmat, mpt->request_dmap); fail_6: bus_dmamem_unmap(mpt->sc_dmat, (void *)mpt->request, PAGE_SIZE); fail_5: bus_dmamem_free(mpt->sc_dmat, &request_seg, request_rseg); fail_4: bus_dmamap_unload(mpt->sc_dmat, mpt->reply_dmap); fail_3: bus_dmamap_destroy(mpt->sc_dmat, mpt->reply_dmap); fail_2: bus_dmamem_unmap(mpt->sc_dmat, (void *)mpt->reply, PAGE_SIZE); fail_1: bus_dmamem_free(mpt->sc_dmat, &reply_seg, reply_rseg); fail_0: free(mpt->request_pool, M_DEVBUF); mpt->reply = NULL; mpt->request = NULL; mpt->request_pool = NULL; return (error); } int mpt_intr(void *arg) { mpt_softc_t *mpt = arg; int nrepl = 0; if ((mpt_read(mpt, MPT_OFFSET_INTR_STATUS) & MPT_INTR_REPLY_READY) == 0) return (0); nrepl = mpt_drain_queue(mpt); return (nrepl != 0); } void mpt_prt(mpt_softc_t *mpt, const char *fmt, ...) { va_list ap; printf("%s: ", device_xname(mpt->sc_dev)); va_start(ap, fmt); vprintf(fmt, ap); va_end(ap); printf("\n"); } static int mpt_poll(mpt_softc_t *mpt, struct scsipi_xfer *xs, int count) { /* Timeouts are in msec, so we loop in 1000usec cycles */ while (count) { mpt_intr(mpt); if (xs->xs_status & XS_STS_DONE) return (0); delay(1000); /* only happens in boot, so ok */ count--; } return (1); } static void mpt_timeout(void *arg) { request_t *req = arg; struct scsipi_xfer *xs; struct scsipi_periph *periph; mpt_softc_t *mpt; uint32_t oseq; int s, nrepl = 0; if (req->xfer == NULL) { printf("mpt_timeout: NULL xfer for request index 0x%x, sequenc 0x%x\n", req->index, req->sequence); return; } xs = req->xfer; periph = xs->xs_periph; mpt = device_private(periph->periph_channel->chan_adapter->adapt_dev); scsipi_printaddr(periph); printf("command timeout\n"); s = splbio(); oseq = req->sequence; mpt->timeouts++; if (mpt_intr(mpt)) { if (req->sequence != oseq) { mpt->success++; mpt_prt(mpt, "recovered from command timeout"); splx(s); return; } } /* * Ensure the IOC is really done giving us data since it appears it can * sometimes fail to give us interrupts under heavy load. */ nrepl = mpt_drain_queue(mpt); if (nrepl ) { mpt_prt(mpt, "mpt_timeout: recovered %d commands",nrepl); } if (req->sequence != oseq) { mpt->success++; splx(s); return; } mpt_prt(mpt, "timeout on request index = 0x%x, seq = 0x%08x", req->index, req->sequence); mpt_check_doorbell(mpt); mpt_prt(mpt, "Status 0x%08x, Mask 0x%08x, Doorbell 0x%08x", mpt_read(mpt, MPT_OFFSET_INTR_STATUS), mpt_read(mpt, MPT_OFFSET_INTR_MASK), mpt_read(mpt, MPT_OFFSET_DOORBELL)); mpt_prt(mpt, "request state: %s", mpt_req_state(req->debug)); if (mpt->verbose > 1) mpt_print_scsi_io_request((MSG_SCSI_IO_REQUEST *)req->req_vbuf); xs->error = XS_TIMEOUT; splx(s); mpt_restart(mpt, req); } static void mpt_restart(mpt_softc_t *mpt, request_t *req0) { int i, s, nreq; request_t *req; struct scsipi_xfer *xs; /* first, reset the IOC, leaving stopped so all requests are idle */ if (mpt_soft_reset(mpt) != MPT_OK) { mpt_prt(mpt, "soft reset failed"); /* * Don't try a hard reset since this mangles the PCI * configuration registers. */ return; } /* Freeze the channel so scsipi doesn't queue more commands. */ scsipi_channel_freeze(&mpt->sc_channel, 1); /* Return all pending requests to scsipi and de-allocate them. */ s = splbio(); nreq = 0; for (i = 0; i < MPT_MAX_REQUESTS(mpt); i++) { req = &mpt->request_pool[i]; xs = req->xfer; if (xs != NULL) { if (xs->datalen != 0) bus_dmamap_unload(mpt->sc_dmat, req->dmap); req->xfer = NULL; callout_stop(&xs->xs_callout); if (req != req0) { nreq++; xs->error = XS_REQUEUE; } scsipi_done(xs); /* * Don't need to mpt_free_request() since mpt_init() * below will free all requests anyway. */ mpt_free_request(mpt, req); } } splx(s); if (nreq > 0) mpt_prt(mpt, "re-queued %d requests", nreq); /* Re-initialize the IOC (which restarts it). */ if (mpt_init(mpt, MPT_DB_INIT_HOST) == 0) mpt_prt(mpt, "restart succeeded"); /* else error message already printed */ /* Thaw the channel, causing scsipi to re-queue the commands. */ scsipi_channel_thaw(&mpt->sc_channel, 1); } static int mpt_drain_queue(mpt_softc_t *mpt) { int nrepl = 0; uint32_t reply; reply = mpt_pop_reply_queue(mpt); while (reply != MPT_REPLY_EMPTY) { nrepl++; if (mpt->verbose > 1) { if ((reply & MPT_CONTEXT_REPLY) != 0) { /* Address reply; IOC has something to say */ mpt_print_reply(MPT_REPLY_PTOV(mpt, reply)); } else { /* Context reply; all went well */ mpt_prt(mpt, "context %u reply OK", reply); } } mpt_done(mpt, reply); reply = mpt_pop_reply_queue(mpt); } return (nrepl); } static void mpt_done(mpt_softc_t *mpt, uint32_t reply) { struct scsipi_xfer *xs = NULL; struct scsipi_periph *periph; int index; request_t *req; MSG_REQUEST_HEADER *mpt_req; MSG_SCSI_IO_REPLY *mpt_reply; int restart = 0; /* nonzero if we need to restart the IOC*/ if (__predict_true((reply & MPT_CONTEXT_REPLY) == 0)) { /* context reply (ok) */ mpt_reply = NULL; index = reply & MPT_CONTEXT_MASK; } else { /* address reply (error) */ /* XXX BUS_DMASYNC_POSTREAD XXX */ mpt_reply = MPT_REPLY_PTOV(mpt, reply); if (mpt_reply != NULL) { if (mpt->verbose > 1) { uint32_t *pReply = (uint32_t *) mpt_reply; mpt_prt(mpt, "Address Reply (index %u):", le32toh(mpt_reply->MsgContext) & 0xffff); mpt_prt(mpt, "%08x %08x %08x %08x", pReply[0], pReply[1], pReply[2], pReply[3]); mpt_prt(mpt, "%08x %08x %08x %08x", pReply[4], pReply[5], pReply[6], pReply[7]); mpt_prt(mpt, "%08x %08x %08x %08x", pReply[8], pReply[9], pReply[10], pReply[11]); } index = le32toh(mpt_reply->MsgContext); } else index = reply & MPT_CONTEXT_MASK; } /* * Address reply with MessageContext high bit set. * This is most likely a notify message, so we try * to process it, then free it. */ if (__predict_false((index & 0x80000000) != 0)) { if (mpt_reply != NULL) mpt_ctlop(mpt, mpt_reply, reply); else mpt_prt(mpt, "%s: index 0x%x, NULL reply", __func__, index); return; } /* Did we end up with a valid index into the table? */ if (__predict_false(index < 0 || index >= MPT_MAX_REQUESTS(mpt))) { mpt_prt(mpt, "%s: invalid index (0x%x) in reply", __func__, index); return; } req = &mpt->request_pool[index]; /* Make sure memory hasn't been trashed. */ if (__predict_false(req->index != index)) { mpt_prt(mpt, "%s: corrupted request_t (0x%x)", __func__, index); return; } MPT_SYNC_REQ(mpt, req, BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE); mpt_req = req->req_vbuf; /* Short cut for task management replies; nothing more for us to do. */ if (__predict_false(mpt_req->Function == MPI_FUNCTION_SCSI_TASK_MGMT)) { if (mpt->verbose > 1) mpt_prt(mpt, "%s: TASK MGMT", __func__); KASSERT(req == mpt->mngt_req); mpt->mngt_req = NULL; goto done; } if (__predict_false(mpt_req->Function == MPI_FUNCTION_PORT_ENABLE)) goto done; /* * At this point, it had better be a SCSI I/O command, but don't * crash if it isn't. */ if (__predict_false(mpt_req->Function != MPI_FUNCTION_SCSI_IO_REQUEST)) { if (mpt->verbose > 1) mpt_prt(mpt, "%s: unknown Function 0x%x (0x%x)", __func__, mpt_req->Function, index); goto done; } /* Recover scsipi_xfer from the request structure. */ xs = req->xfer; /* Can't have a SCSI command without a scsipi_xfer. */ if (__predict_false(xs == NULL)) { mpt_prt(mpt, "%s: no scsipi_xfer, index = 0x%x, seq = 0x%08x", __func__, req->index, req->sequence); mpt_prt(mpt, "request state: %s", mpt_req_state(req->debug)); mpt_prt(mpt, "mpt_request:"); mpt_print_scsi_io_request((MSG_SCSI_IO_REQUEST *)req->req_vbuf); if (mpt_reply != NULL) { mpt_prt(mpt, "mpt_reply:"); mpt_print_reply(mpt_reply); } else { mpt_prt(mpt, "context reply: 0x%08x", reply); } goto done; } callout_stop(&xs->xs_callout); periph = xs->xs_periph; /* * If we were a data transfer, unload the map that described * the data buffer. */ if (__predict_true(xs->datalen != 0)) { bus_dmamap_sync(mpt->sc_dmat, req->dmap, 0, req->dmap->dm_mapsize, (xs->xs_control & XS_CTL_DATA_IN) ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE); bus_dmamap_unload(mpt->sc_dmat, req->dmap); } if (__predict_true(mpt_reply == NULL)) { /* * Context reply; report that the command was * successful! * * Also report the xfer mode, if necessary. */ if (__predict_false(mpt->mpt_report_xfer_mode != 0)) { if ((mpt->mpt_report_xfer_mode & (1 << periph->periph_target)) != 0) mpt_get_xfer_mode(mpt, periph); } xs->error = XS_NOERROR; xs->status = SCSI_OK; xs->resid = 0; mpt_free_request(mpt, req); scsipi_done(xs); return; } xs->status = mpt_reply->SCSIStatus; switch (le16toh(mpt_reply->IOCStatus) & MPI_IOCSTATUS_MASK) { case MPI_IOCSTATUS_SCSI_DATA_OVERRUN: xs->error = XS_DRIVER_STUFFUP; mpt_prt(mpt, "%s: IOC overrun!", __func__); break; case MPI_IOCSTATUS_SCSI_DATA_UNDERRUN: /* * Yikes! Tagged queue full comes through this path! * * So we'll change it to a status error and anything * that returns status should probably be a status * error as well. */ xs->resid = xs->datalen - le32toh(mpt_reply->TransferCount); if (mpt_reply->SCSIState & MPI_SCSI_STATE_NO_SCSI_STATUS) { xs->error = XS_DRIVER_STUFFUP; break; } /* FALLTHROUGH */ case MPI_IOCSTATUS_SUCCESS: case MPI_IOCSTATUS_SCSI_RECOVERED_ERROR: switch (xs->status) { case SCSI_OK: /* Report the xfer mode, if necessary. */ if ((mpt->mpt_report_xfer_mode & (1 << periph->periph_target)) != 0) mpt_get_xfer_mode(mpt, periph); xs->resid = 0; break; case SCSI_CHECK: xs->error = XS_SENSE; break; case SCSI_BUSY: case SCSI_QUEUE_FULL: xs->error = XS_BUSY; break; default: scsipi_printaddr(periph); printf("invalid status code %d\n", xs->status); xs->error = XS_DRIVER_STUFFUP; break; } break; case MPI_IOCSTATUS_BUSY: case MPI_IOCSTATUS_INSUFFICIENT_RESOURCES: xs->error = XS_RESOURCE_SHORTAGE; break; case MPI_IOCSTATUS_SCSI_INVALID_BUS: case MPI_IOCSTATUS_SCSI_INVALID_TARGETID: case MPI_IOCSTATUS_SCSI_DEVICE_NOT_THERE: xs->error = XS_SELTIMEOUT; break; case MPI_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: xs->error = XS_DRIVER_STUFFUP; mpt_prt(mpt, "%s: IOC SCSI residual mismatch!", __func__); restart = 1; break; case MPI_IOCSTATUS_SCSI_TASK_TERMINATED: /* XXX What should we do here? */ mpt_prt(mpt, "%s: IOC SCSI task terminated!", __func__); restart = 1; break; case MPI_IOCSTATUS_SCSI_TASK_MGMT_FAILED: /* XXX */ xs->error = XS_DRIVER_STUFFUP; mpt_prt(mpt, "%s: IOC SCSI task failed!", __func__); restart = 1; break; case MPI_IOCSTATUS_SCSI_IOC_TERMINATED: /* XXX */ xs->error = XS_DRIVER_STUFFUP; mpt_prt(mpt, "%s: IOC task terminated!", __func__); restart = 1; break; case MPI_IOCSTATUS_SCSI_EXT_TERMINATED: /* XXX This is a bus-reset */ xs->error = XS_DRIVER_STUFFUP; mpt_prt(mpt, "%s: IOC SCSI bus reset!", __func__); restart = 1; break; case MPI_IOCSTATUS_SCSI_PROTOCOL_ERROR: /* * FreeBSD and Linux indicate this is a phase error between * the IOC and the drive itself. When this happens, the IOC * becomes unhappy and stops processing all transactions. * Call mpt_timeout which knows how to get the IOC back * on its feet. */ mpt_prt(mpt, "%s: IOC indicates protocol error -- " "recovering...", __func__); xs->error = XS_TIMEOUT; restart = 1; break; default: /* XXX unrecognized HBA error */ xs->error = XS_DRIVER_STUFFUP; mpt_prt(mpt, "%s: IOC returned unknown code: 0x%x", __func__, le16toh(mpt_reply->IOCStatus)); restart = 1; break; } if (mpt_reply != NULL) { if (mpt_reply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_VALID) { memcpy(&xs->sense.scsi_sense, req->sense_vbuf, sizeof(xs->sense.scsi_sense)); } else if (mpt_reply->SCSIState & MPI_SCSI_STATE_AUTOSENSE_FAILED) { /* * This will cause the scsipi layer to issue * a REQUEST SENSE. */ if (xs->status == SCSI_CHECK) xs->error = XS_BUSY; } } done: if (mpt_reply != NULL && le16toh(mpt_reply->IOCStatus) & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) { mpt_prt(mpt, "%s: IOC has error - logging...\n", __func__); mpt_ctlop(mpt, mpt_reply, reply); } /* If IOC done with this request, free it up. */ if (mpt_reply == NULL || (mpt_reply->MsgFlags & 0x80) == 0) mpt_free_request(mpt, req); /* If address reply, give the buffer back to the IOC. */ if (mpt_reply != NULL) mpt_free_reply(mpt, (reply << 1)); if (xs != NULL) scsipi_done(xs); if (restart) { mpt_prt(mpt, "%s: IOC fatal error: restarting...", __func__); mpt_restart(mpt, NULL); } } static void mpt_run_xfer(mpt_softc_t *mpt, struct scsipi_xfer *xs) { struct scsipi_periph *periph = xs->xs_periph; request_t *req; MSG_SCSI_IO_REQUEST *mpt_req; int error, s; s = splbio(); req = mpt_get_request(mpt); if (__predict_false(req == NULL)) { /* This should happen very infrequently. */ xs->error = XS_RESOURCE_SHORTAGE; scsipi_done(xs); splx(s); return; } splx(s); /* Link the req and the scsipi_xfer. */ req->xfer = xs; /* Now we build the command for the IOC */ mpt_req = req->req_vbuf; memset(mpt_req, 0, sizeof(*mpt_req)); mpt_req->Function = MPI_FUNCTION_SCSI_IO_REQUEST; mpt_req->Bus = mpt->bus; mpt_req->SenseBufferLength = (sizeof(xs->sense.scsi_sense) < MPT_SENSE_SIZE) ? sizeof(xs->sense.scsi_sense) : MPT_SENSE_SIZE; /* * We use the message context to find the request structure when * we get the command completion interrupt from the IOC. */ mpt_req->MsgContext = htole32(req->index); /* Which physical device to do the I/O on. */ mpt_req->TargetID = periph->periph_target; mpt_req->LUN[1] = periph->periph_lun; /* Set the direction of the transfer. */ if (xs->xs_control & XS_CTL_DATA_IN) mpt_req->Control = MPI_SCSIIO_CONTROL_READ; else if (xs->xs_control & XS_CTL_DATA_OUT) mpt_req->Control = MPI_SCSIIO_CONTROL_WRITE; else mpt_req->Control = MPI_SCSIIO_CONTROL_NODATATRANSFER; /* Set the queue behavior. */ if (__predict_true((!mpt->is_scsi) || (mpt->mpt_tag_enable & (1 << periph->periph_target)))) { switch (XS_CTL_TAGTYPE(xs)) { case XS_CTL_HEAD_TAG: mpt_req->Control |= MPI_SCSIIO_CONTROL_HEADOFQ; break; #if 0 /* XXX */ case XS_CTL_ACA_TAG: mpt_req->Control |= MPI_SCSIIO_CONTROL_ACAQ; break; #endif case XS_CTL_ORDERED_TAG: mpt_req->Control |= MPI_SCSIIO_CONTROL_ORDEREDQ; break; case XS_CTL_SIMPLE_TAG: mpt_req->Control |= MPI_SCSIIO_CONTROL_SIMPLEQ; break; default: if (mpt->is_scsi) mpt_req->Control |= MPI_SCSIIO_CONTROL_UNTAGGED; else mpt_req->Control |= MPI_SCSIIO_CONTROL_SIMPLEQ; break; } } else mpt_req->Control |= MPI_SCSIIO_CONTROL_UNTAGGED; if (__predict_false(mpt->is_scsi && (mpt->mpt_disc_enable & (1 << periph->periph_target)) == 0)) mpt_req->Control |= MPI_SCSIIO_CONTROL_NO_DISCONNECT; mpt_req->Control = htole32(mpt_req->Control); /* Copy the SCSI command block into place. */ memcpy(mpt_req->CDB, xs->cmd, xs->cmdlen); mpt_req->CDBLength = xs->cmdlen; mpt_req->DataLength = htole32(xs->datalen); mpt_req->SenseBufferLowAddr = htole32(req->sense_pbuf); /* * Map the DMA transfer. */ if (xs->datalen) { SGE_SIMPLE32 *se; error = bus_dmamap_load(mpt->sc_dmat, req->dmap, xs->data, xs->datalen, NULL, ((xs->xs_control & XS_CTL_NOSLEEP) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK) | BUS_DMA_STREAMING | ((xs->xs_control & XS_CTL_DATA_IN) ? BUS_DMA_READ : BUS_DMA_WRITE)); switch (error) { case 0: break; case ENOMEM: case EAGAIN: xs->error = XS_RESOURCE_SHORTAGE; goto out_bad; default: xs->error = XS_DRIVER_STUFFUP; mpt_prt(mpt, "error %d loading DMA map", error); out_bad: s = splbio(); mpt_free_request(mpt, req); scsipi_done(xs); splx(s); return; } if (req->dmap->dm_nsegs > MPT_NSGL_FIRST(mpt)) { int seg, i, nleft = req->dmap->dm_nsegs; uint32_t flags; SGE_CHAIN32 *ce; seg = 0; flags = MPI_SGE_FLAGS_SIMPLE_ELEMENT; if (xs->xs_control & XS_CTL_DATA_OUT) flags |= MPI_SGE_FLAGS_HOST_TO_IOC; se = (SGE_SIMPLE32 *) &mpt_req->SGL; for (i = 0; i < MPT_NSGL_FIRST(mpt) - 1; i++, se++, seg++) { uint32_t tf; memset(se, 0, sizeof(*se)); se->Address = htole32(req->dmap->dm_segs[seg].ds_addr); MPI_pSGE_SET_LENGTH(se, req->dmap->dm_segs[seg].ds_len); tf = flags; if (i == MPT_NSGL_FIRST(mpt) - 2) tf |= MPI_SGE_FLAGS_LAST_ELEMENT; MPI_pSGE_SET_FLAGS(se, tf); se->FlagsLength = htole32(se->FlagsLength); nleft--; } /* * Tell the IOC where to find the first chain element. */ mpt_req->ChainOffset = ((char *)se - (char *)mpt_req) >> 2; /* * Until we're finished with all segments... */ while (nleft) { int ntodo; /* * Construct the chain element that points to * the next segment. */ ce = (SGE_CHAIN32 *) se++; if (nleft > MPT_NSGL(mpt)) { ntodo = MPT_NSGL(mpt) - 1; ce->NextChainOffset = (MPT_RQSL(mpt) - sizeof(SGE_SIMPLE32)) >> 2; ce->Length = htole16(MPT_NSGL(mpt) * sizeof(SGE_SIMPLE32)); } else { ntodo = nleft; ce->NextChainOffset = 0; ce->Length = htole16(ntodo * sizeof(SGE_SIMPLE32)); } ce->Address = htole32(req->req_pbuf + ((char *)se - (char *)mpt_req)); ce->Flags = MPI_SGE_FLAGS_CHAIN_ELEMENT; for (i = 0; i < ntodo; i++, se++, seg++) { uint32_t tf; memset(se, 0, sizeof(*se)); se->Address = htole32( req->dmap->dm_segs[seg].ds_addr); MPI_pSGE_SET_LENGTH(se, req->dmap->dm_segs[seg].ds_len); tf = flags; if (i == ntodo - 1) { tf |= MPI_SGE_FLAGS_LAST_ELEMENT; if (ce->NextChainOffset == 0) { tf |= MPI_SGE_FLAGS_END_OF_LIST | MPI_SGE_FLAGS_END_OF_BUFFER; } } MPI_pSGE_SET_FLAGS(se, tf); se->FlagsLength = htole32(se->FlagsLength); nleft--; } } bus_dmamap_sync(mpt->sc_dmat, req->dmap, 0, req->dmap->dm_mapsize, (xs->xs_control & XS_CTL_DATA_IN) ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE); } else { int i; uint32_t flags; flags = MPI_SGE_FLAGS_SIMPLE_ELEMENT; if (xs->xs_control & XS_CTL_DATA_OUT) flags |= MPI_SGE_FLAGS_HOST_TO_IOC; /* Copy the segments into our SG list. */ se = (SGE_SIMPLE32 *) &mpt_req->SGL; for (i = 0; i < req->dmap->dm_nsegs; i++, se++) { uint32_t tf; memset(se, 0, sizeof(*se)); se->Address = htole32(req->dmap->dm_segs[i].ds_addr); MPI_pSGE_SET_LENGTH(se, req->dmap->dm_segs[i].ds_len); tf = flags; if (i == req->dmap->dm_nsegs - 1) { tf |= MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER | MPI_SGE_FLAGS_END_OF_LIST; } MPI_pSGE_SET_FLAGS(se, tf); se->FlagsLength = htole32(se->FlagsLength); } bus_dmamap_sync(mpt->sc_dmat, req->dmap, 0, req->dmap->dm_mapsize, (xs->xs_control & XS_CTL_DATA_IN) ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE); } } else { /* * No data to transfer; just make a single simple SGL * with zero length. */ SGE_SIMPLE32 *se = (SGE_SIMPLE32 *) &mpt_req->SGL; memset(se, 0, sizeof(*se)); MPI_pSGE_SET_FLAGS(se, (MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER | MPI_SGE_FLAGS_SIMPLE_ELEMENT | MPI_SGE_FLAGS_END_OF_LIST)); se->FlagsLength = htole32(se->FlagsLength); } if (mpt->verbose > 1) mpt_print_scsi_io_request(mpt_req); if (xs->timeout == 0) { mpt_prt(mpt, "mpt_run_xfer: no timeout specified for request: 0x%x\n", req->index); xs->timeout = 500; } s = splbio(); if (__predict_true((xs->xs_control & XS_CTL_POLL) == 0)) callout_reset(&xs->xs_callout, mstohz(xs->timeout), mpt_timeout, req); mpt_send_cmd(mpt, req); splx(s); if (__predict_true((xs->xs_control & XS_CTL_POLL) == 0)) return; /* * If we can't use interrupts, poll on completion. */ if (mpt_poll(mpt, xs, xs->timeout)) mpt_timeout(req); } static void mpt_set_xfer_mode(mpt_softc_t *mpt, struct scsipi_xfer_mode *xm) { fCONFIG_PAGE_SCSI_DEVICE_1 tmp; if (xm->xm_mode & PERIPH_CAP_TQING) mpt->mpt_tag_enable |= (1 << xm->xm_target); else mpt->mpt_tag_enable &= ~(1 << xm->xm_target); if (mpt->is_scsi) { /* * Always allow disconnect; we don't have a way to disable * it right now, in any case. */ mpt->mpt_disc_enable |= (1 << xm->xm_target); /* * SCSI transport settings only make any sense for * SCSI */ tmp = mpt->mpt_dev_page1[xm->xm_target]; /* * Set the wide/narrow parameter for the target. */ if (xm->xm_mode & PERIPH_CAP_WIDE16) tmp.RequestedParameters |= MPI_SCSIDEVPAGE1_RP_WIDE; else tmp.RequestedParameters &= ~MPI_SCSIDEVPAGE1_RP_WIDE; /* * Set the synchronous parameters for the target. * * XXX If we request sync transfers, we just go ahead and * XXX request the maximum available. We need finer control * XXX in order to implement Domain Validation. */ tmp.RequestedParameters &= ~(MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK | MPI_SCSIDEVPAGE1_RP_MAX_SYNC_OFFSET_MASK | MPI_SCSIDEVPAGE1_RP_DT | MPI_SCSIDEVPAGE1_RP_QAS | MPI_SCSIDEVPAGE1_RP_IU); if (xm->xm_mode & PERIPH_CAP_SYNC) { int factor, offset, np; factor = (mpt->mpt_port_page0.Capabilities >> 8) & 0xff; offset = (mpt->mpt_port_page0.Capabilities >> 16) & 0xff; np = 0; if (factor < 0x9) { /* Ultra320 */ np |= MPI_SCSIDEVPAGE1_RP_QAS | MPI_SCSIDEVPAGE1_RP_IU; } if (factor < 0xa) { /* at least Ultra160 */ np |= MPI_SCSIDEVPAGE1_RP_DT; } np |= (factor << 8) | (offset << 16); tmp.RequestedParameters |= np; } host2mpt_config_page_scsi_device_1(&tmp); if (mpt_write_cfg_page(mpt, xm->xm_target, &tmp.Header)) { mpt_prt(mpt, "unable to write Device Page 1"); return; } if (mpt_read_cfg_page(mpt, xm->xm_target, &tmp.Header)) { mpt_prt(mpt, "unable to read back Device Page 1"); return; } mpt2host_config_page_scsi_device_1(&tmp); mpt->mpt_dev_page1[xm->xm_target] = tmp; if (mpt->verbose > 1) { mpt_prt(mpt, "SPI Target %d Page 1: RequestedParameters %x Config %x", xm->xm_target, mpt->mpt_dev_page1[xm->xm_target].RequestedParameters, mpt->mpt_dev_page1[xm->xm_target].Configuration); } } /* * Make a note that we should perform an async callback at the * end of the next successful command completion to report the * negotiated transfer mode. */ mpt->mpt_report_xfer_mode |= (1 << xm->xm_target); } static void mpt_get_xfer_mode(mpt_softc_t *mpt, struct scsipi_periph *periph) { fCONFIG_PAGE_SCSI_DEVICE_0 tmp; struct scsipi_xfer_mode xm; int period, offset; tmp = mpt->mpt_dev_page0[periph->periph_target]; host2mpt_config_page_scsi_device_0(&tmp); if (mpt_read_cfg_page(mpt, periph->periph_target, &tmp.Header)) { mpt_prt(mpt, "unable to read Device Page 0"); return; } mpt2host_config_page_scsi_device_0(&tmp); if (mpt->verbose > 1) { mpt_prt(mpt, "SPI Tgt %d Page 0: NParms %x Information %x", periph->periph_target, tmp.NegotiatedParameters, tmp.Information); } xm.xm_target = periph->periph_target; xm.xm_mode = 0; if (tmp.NegotiatedParameters & MPI_SCSIDEVPAGE0_NP_WIDE) xm.xm_mode |= PERIPH_CAP_WIDE16; period = (tmp.NegotiatedParameters >> 8) & 0xff; offset = (tmp.NegotiatedParameters >> 16) & 0xff; if (offset) { xm.xm_period = period; xm.xm_offset = offset; xm.xm_mode |= PERIPH_CAP_SYNC; } /* * Tagged queueing is all controlled by us; there is no * other setting to query. */ if (mpt->mpt_tag_enable & (1 << periph->periph_target)) xm.xm_mode |= PERIPH_CAP_TQING; /* * We're going to deliver the async event, so clear the marker. */ mpt->mpt_report_xfer_mode &= ~(1 << periph->periph_target); scsipi_async_event(&mpt->sc_channel, ASYNC_EVENT_XFER_MODE, &xm); } static void mpt_ctlop(mpt_softc_t *mpt, void *vmsg, uint32_t reply) { MSG_DEFAULT_REPLY *dmsg = vmsg; switch (dmsg->Function) { case MPI_FUNCTION_EVENT_NOTIFICATION: mpt_event_notify_reply(mpt, vmsg); mpt_free_reply(mpt, (reply << 1)); break; case MPI_FUNCTION_EVENT_ACK: { MSG_EVENT_ACK_REPLY *msg = vmsg; int index = le32toh(msg->MsgContext) & ~0x80000000; mpt_free_reply(mpt, (reply << 1)); if (index >= 0 && index < MPT_MAX_REQUESTS(mpt)) { request_t *req = &mpt->request_pool[index]; mpt_free_request(mpt, req); } break; } case MPI_FUNCTION_PORT_ENABLE: { MSG_PORT_ENABLE_REPLY *msg = vmsg; int index = le32toh(msg->MsgContext) & ~0x80000000; if (mpt->verbose > 1) mpt_prt(mpt, "enable port reply index %d", index); if (index >= 0 && index < MPT_MAX_REQUESTS(mpt)) { request_t *req = &mpt->request_pool[index]; req->debug = REQ_DONE; } mpt_free_reply(mpt, (reply << 1)); break; } case MPI_FUNCTION_CONFIG: { MSG_CONFIG_REPLY *msg = vmsg; int index = le32toh(msg->MsgContext) & ~0x80000000; if (index >= 0 && index < MPT_MAX_REQUESTS(mpt)) { request_t *req = &mpt->request_pool[index]; req->debug = REQ_DONE; req->sequence = reply; } else mpt_free_reply(mpt, (reply << 1)); break; } default: mpt_prt(mpt, "unknown ctlop: 0x%x", dmsg->Function); } } static void mpt_event_notify_reply(mpt_softc_t *mpt, MSG_EVENT_NOTIFY_REPLY *msg) { switch (le32toh(msg->Event)) { case MPI_EVENT_LOG_DATA: { int i; /* Some error occurrerd that the Fusion wants logged. */ mpt_prt(mpt, "EvtLogData: IOCLogInfo: 0x%08x", msg->IOCLogInfo); mpt_prt(mpt, "EvtLogData: Event Data:"); for (i = 0; i < msg->EventDataLength; i++) { if ((i % 4) == 0) printf("%s:\t", device_xname(mpt->sc_dev)); printf("0x%08x%c", msg->Data[i], ((i % 4) == 3) ? '\n' : ' '); } if ((i % 4) != 0) printf("\n"); break; } case MPI_EVENT_UNIT_ATTENTION: mpt_prt(mpt, "Unit Attn: Bus 0x%02x Target 0x%02x", (msg->Data[0] >> 8) & 0xff, msg->Data[0] & 0xff); break; case MPI_EVENT_IOC_BUS_RESET: /* We generated a bus reset. */ mpt_prt(mpt, "IOC Bus Reset Port %d", (msg->Data[0] >> 8) & 0xff); break; case MPI_EVENT_EXT_BUS_RESET: /* Someone else generated a bus reset. */ mpt_prt(mpt, "External Bus Reset"); /* * These replies don't return EventData like the MPI * spec says they do. */ /* XXX Send an async event? */ break; case MPI_EVENT_RESCAN: /* * In general, this means a device has been added * to the loop. */ mpt_prt(mpt, "Rescan Port %d", (msg->Data[0] >> 8) & 0xff); /* XXX Send an async event? */ break; case MPI_EVENT_LINK_STATUS_CHANGE: mpt_prt(mpt, "Port %d: Link state %s", (msg->Data[1] >> 8) & 0xff, (msg->Data[0] & 0xff) == 0 ? "Failed" : "Active"); break; case MPI_EVENT_LOOP_STATE_CHANGE: switch ((msg->Data[0] >> 16) & 0xff) { case 0x01: mpt_prt(mpt, "Port %d: FC Link Event: LIP(%02x,%02x) " "(Loop Initialization)", (msg->Data[1] >> 8) & 0xff, (msg->Data[0] >> 8) & 0xff, (msg->Data[0] ) & 0xff); switch ((msg->Data[0] >> 8) & 0xff) { case 0xf7: if ((msg->Data[0] & 0xff) == 0xf7) mpt_prt(mpt, "\tDevice needs AL_PA"); else mpt_prt(mpt, "\tDevice %02x doesn't " "like FC performance", msg->Data[0] & 0xff); break; case 0xf8: if ((msg->Data[0] & 0xff) == 0xf7) mpt_prt(mpt, "\tDevice detected loop " "failure before acquiring AL_PA"); else mpt_prt(mpt, "\tDevice %02x detected " "loop failure", msg->Data[0] & 0xff); break; default: mpt_prt(mpt, "\tDevice %02x requests that " "device %02x reset itself", msg->Data[0] & 0xff, (msg->Data[0] >> 8) & 0xff); break; } break; case 0x02: mpt_prt(mpt, "Port %d: FC Link Event: LPE(%02x,%02x) " "(Loop Port Enable)", (msg->Data[1] >> 8) & 0xff, (msg->Data[0] >> 8) & 0xff, (msg->Data[0] ) & 0xff); break; case 0x03: mpt_prt(mpt, "Port %d: FC Link Event: LPB(%02x,%02x) " "(Loop Port Bypass)", (msg->Data[1] >> 8) & 0xff, (msg->Data[0] >> 8) & 0xff, (msg->Data[0] ) & 0xff); break; default: mpt_prt(mpt, "Port %d: FC Link Event: " "Unknown event (%02x %02x %02x)", (msg->Data[1] >> 8) & 0xff, (msg->Data[0] >> 16) & 0xff, (msg->Data[0] >> 8) & 0xff, (msg->Data[0] ) & 0xff); break; } break; case MPI_EVENT_LOGOUT: mpt_prt(mpt, "Port %d: FC Logout: N_PortID: %02x", (msg->Data[1] >> 8) & 0xff, msg->Data[0]); break; case MPI_EVENT_EVENT_CHANGE: /* * This is just an acknowledgement of our * mpt_send_event_request(). */ break; case MPI_EVENT_SAS_PHY_LINK_STATUS: switch ((msg->Data[0] >> 12) & 0x0f) { case 0x00: mpt_prt(mpt, "Phy %d: Link Status Unknown", msg->Data[0] & 0xff); break; case 0x01: mpt_prt(mpt, "Phy %d: Link Disabled", msg->Data[0] & 0xff); break; case 0x02: mpt_prt(mpt, "Phy %d: Failed Speed Negotiation", msg->Data[0] & 0xff); break; case 0x03: mpt_prt(mpt, "Phy %d: SATA OOB Complete", msg->Data[0] & 0xff); break; case 0x08: mpt_prt(mpt, "Phy %d: Link Rate 1.5 Gbps", msg->Data[0] & 0xff); break; case 0x09: mpt_prt(mpt, "Phy %d: Link Rate 3.0 Gbps", msg->Data[0] & 0xff); break; default: mpt_prt(mpt, "Phy %d: SAS Phy Link Status Event: " "Unknown event (%0x)", msg->Data[0] & 0xff, (msg->Data[0] >> 8) & 0xff); } break; case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE: case MPI_EVENT_SAS_DISCOVERY: /* ignore these events for now */ break; case MPI_EVENT_QUEUE_FULL: /* This can get a little chatty */ if (mpt->verbose > 0) mpt_prt(mpt, "Queue Full Event"); break; default: mpt_prt(mpt, "Unknown async event: 0x%x", msg->Event); break; } if (msg->AckRequired) { MSG_EVENT_ACK *ackp; request_t *req; if ((req = mpt_get_request(mpt)) == NULL) { /* XXX XXX XXX XXXJRT */ panic("mpt_event_notify_reply: unable to allocate " "request structure"); } ackp = (MSG_EVENT_ACK *) req->req_vbuf; memset(ackp, 0, sizeof(*ackp)); ackp->Function = MPI_FUNCTION_EVENT_ACK; ackp->Event = msg->Event; ackp->EventContext = msg->EventContext; ackp->MsgContext = htole32(req->index | 0x80000000); mpt_check_doorbell(mpt); mpt_send_cmd(mpt, req); } } static void mpt_bus_reset(mpt_softc_t *mpt) { request_t *req; MSG_SCSI_TASK_MGMT *mngt_req; int s; s = splbio(); if (mpt->mngt_req) { /* request already queued; can't do more */ splx(s); return; } req = mpt_get_request(mpt); if (__predict_false(req == NULL)) { mpt_prt(mpt, "no mngt request\n"); splx(s); return; } mpt->mngt_req = req; splx(s); mngt_req = req->req_vbuf; memset(mngt_req, 0, sizeof(*mngt_req)); mngt_req->Function = MPI_FUNCTION_SCSI_TASK_MGMT; mngt_req->Bus = mpt->bus; mngt_req->TargetID = 0; mngt_req->ChainOffset = 0; mngt_req->TaskType = MPI_SCSITASKMGMT_TASKTYPE_RESET_BUS; mngt_req->Reserved1 = 0; mngt_req->MsgFlags = mpt->is_fc ? MPI_SCSITASKMGMT_MSGFLAGS_LIP_RESET_OPTION : 0; mngt_req->MsgContext = req->index; mngt_req->TaskMsgContext = 0; s = splbio(); mpt_send_handshake_cmd(mpt, sizeof(*mngt_req), mngt_req); splx(s); } /***************************************************************************** * SCSI interface routines *****************************************************************************/ static void mpt_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req, void *arg) { struct scsipi_adapter *adapt = chan->chan_adapter; mpt_softc_t *mpt = device_private(adapt->adapt_dev); switch (req) { case ADAPTER_REQ_RUN_XFER: mpt_run_xfer(mpt, (struct scsipi_xfer *) arg); return; case ADAPTER_REQ_GROW_RESOURCES: /* Not supported. */ return; case ADAPTER_REQ_SET_XFER_MODE: mpt_set_xfer_mode(mpt, (struct scsipi_xfer_mode *) arg); return; } } static void mpt_minphys(struct buf *bp) { /* * Subtract one from the SGL limit, since we need an extra one to handle * an non-page-aligned transfer. */ #define MPT_MAX_XFER ((MPT_SGL_MAX - 1) * PAGE_SIZE) if (bp->b_bcount > MPT_MAX_XFER) bp->b_bcount = MPT_MAX_XFER; minphys(bp); } static int mpt_ioctl(struct scsipi_channel *chan, u_long cmd, void *arg, int flag, struct proc *p) { mpt_softc_t *mpt; int s; mpt = device_private(chan->chan_adapter->adapt_dev); switch (cmd) { case SCBUSIORESET: mpt_bus_reset(mpt); s = splbio(); mpt_intr(mpt); splx(s); return(0); default: return (ENOTTY); } } #if NBIO > 0 static fCONFIG_PAGE_IOC_2 * mpt_get_cfg_page_ioc2(mpt_softc_t *mpt) { fCONFIG_PAGE_HEADER hdr; fCONFIG_PAGE_IOC_2 *ioc2; int rv; rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_IOC, 2, 0, &hdr); if (rv) return NULL; ioc2 = malloc(hdr.PageLength * 4, M_DEVBUF, M_WAITOK | M_ZERO); if (ioc2 == NULL) return NULL; memcpy(ioc2, &hdr, sizeof(hdr)); rv = mpt_read_cfg_page(mpt, 0, &ioc2->Header); if (rv) goto fail; mpt2host_config_page_ioc_2(ioc2); return ioc2; fail: free(ioc2, M_DEVBUF); return NULL; } static fCONFIG_PAGE_IOC_3 * mpt_get_cfg_page_ioc3(mpt_softc_t *mpt) { fCONFIG_PAGE_HEADER hdr; fCONFIG_PAGE_IOC_3 *ioc3; int rv; rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_IOC, 3, 0, &hdr); if (rv) return NULL; ioc3 = malloc(hdr.PageLength * 4, M_DEVBUF, M_WAITOK | M_ZERO); if (ioc3 == NULL) return NULL; memcpy(ioc3, &hdr, sizeof(hdr)); rv = mpt_read_cfg_page(mpt, 0, &ioc3->Header); if (rv) goto fail; return ioc3; fail: free(ioc3, M_DEVBUF); return NULL; } static fCONFIG_PAGE_RAID_VOL_0 * mpt_get_cfg_page_raid_vol0(mpt_softc_t *mpt, int address) { fCONFIG_PAGE_HEADER hdr; fCONFIG_PAGE_RAID_VOL_0 *rvol0; int rv; rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_RAID_VOLUME, 0, address, &hdr); if (rv) return NULL; rvol0 = malloc(hdr.PageLength * 4, M_DEVBUF, M_WAITOK | M_ZERO); if (rvol0 == NULL) return NULL; memcpy(rvol0, &hdr, sizeof(hdr)); rv = mpt_read_cfg_page(mpt, address, &rvol0->Header); if (rv) goto fail; mpt2host_config_page_raid_vol_0(rvol0); return rvol0; fail: free(rvol0, M_DEVBUF); return NULL; } static fCONFIG_PAGE_RAID_PHYS_DISK_0 * mpt_get_cfg_page_raid_phys_disk0(mpt_softc_t *mpt, int address) { fCONFIG_PAGE_HEADER hdr; fCONFIG_PAGE_RAID_PHYS_DISK_0 *physdisk0; int rv; rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_RAID_PHYSDISK, 0, address, &hdr); if (rv) return NULL; physdisk0 = malloc(hdr.PageLength * 4, M_DEVBUF, M_WAITOK | M_ZERO); if (physdisk0 == NULL) return NULL; memcpy(physdisk0, &hdr, sizeof(hdr)); rv = mpt_read_cfg_page(mpt, address, &physdisk0->Header); if (rv) goto fail; mpt2host_config_page_raid_phys_disk_0(physdisk0); return physdisk0; fail: free(physdisk0, M_DEVBUF); return NULL; } static bool mpt_is_raid(mpt_softc_t *mpt) { fCONFIG_PAGE_IOC_2 *ioc2; bool is_raid = false; ioc2 = mpt_get_cfg_page_ioc2(mpt); if (ioc2 == NULL) return false; if (ioc2->CapabilitiesFlags != 0xdeadbeef) { is_raid = !!(ioc2->CapabilitiesFlags & (MPI_IOCPAGE2_CAP_FLAGS_IS_SUPPORT| MPI_IOCPAGE2_CAP_FLAGS_IME_SUPPORT| MPI_IOCPAGE2_CAP_FLAGS_IM_SUPPORT)); } free(ioc2, M_DEVBUF); return is_raid; } static int mpt_bio_ioctl(device_t dev, u_long cmd, void *addr) { mpt_softc_t *mpt = device_private(dev); int error, s; KERNEL_LOCK(1, curlwp); s = splbio(); switch (cmd) { case BIOCINQ: error = mpt_bio_ioctl_inq(mpt, addr); break; case BIOCVOL: error = mpt_bio_ioctl_vol(mpt, addr); break; case BIOCDISK_NOVOL: error = mpt_bio_ioctl_disk_novol(mpt, addr); break; case BIOCDISK: error = mpt_bio_ioctl_disk(mpt, addr); break; default: error = EINVAL; break; } splx(s); KERNEL_UNLOCK_ONE(curlwp); return error; } static int mpt_bio_ioctl_inq(mpt_softc_t *mpt, struct bioc_inq *bi) { fCONFIG_PAGE_IOC_2 *ioc2; fCONFIG_PAGE_IOC_3 *ioc3; ioc2 = mpt_get_cfg_page_ioc2(mpt); if (ioc2 == NULL) return EIO; ioc3 = mpt_get_cfg_page_ioc3(mpt); if (ioc3 == NULL) { free(ioc2, M_DEVBUF); return EIO; } strlcpy(bi->bi_dev, device_xname(mpt->sc_dev), sizeof(bi->bi_dev)); bi->bi_novol = ioc2->NumActiveVolumes; bi->bi_nodisk = ioc3->NumPhysDisks; free(ioc2, M_DEVBUF); free(ioc3, M_DEVBUF); return 0; } static int mpt_bio_ioctl_vol(mpt_softc_t *mpt, struct bioc_vol *bv) { fCONFIG_PAGE_IOC_2 *ioc2 = NULL; fCONFIG_PAGE_IOC_2_RAID_VOL *ioc2rvol; fCONFIG_PAGE_RAID_VOL_0 *rvol0 = NULL; struct scsipi_periph *periph; struct scsipi_inquiry_data inqbuf; char vendor[9], product[17], revision[5]; int address; ioc2 = mpt_get_cfg_page_ioc2(mpt); if (ioc2 == NULL) return EIO; if (bv->bv_volid < 0 || bv->bv_volid >= ioc2->NumActiveVolumes) goto fail; ioc2rvol = &ioc2->RaidVolume[bv->bv_volid]; address = ioc2rvol->VolumeID | (ioc2rvol->VolumeBus << 8); rvol0 = mpt_get_cfg_page_raid_vol0(mpt, address); if (rvol0 == NULL) goto fail; bv->bv_dev[0] = '\0'; bv->bv_vendor[0] = '\0'; periph = scsipi_lookup_periph(&mpt->sc_channel, ioc2rvol->VolumeBus, 0); if (periph != NULL) { if (periph->periph_dev != NULL) { snprintf(bv->bv_dev, sizeof(bv->bv_dev), "%s", device_xname(periph->periph_dev)); } memset(&inqbuf, 0, sizeof(inqbuf)); if (scsipi_inquire(periph, &inqbuf, XS_CTL_DISCOVERY | XS_CTL_SILENT) == 0) { strnvisx(vendor, sizeof(vendor), inqbuf.vendor, sizeof(inqbuf.vendor), VIS_TRIM|VIS_SAFE|VIS_OCTAL); strnvisx(product, sizeof(product), inqbuf.product, sizeof(inqbuf.product), VIS_TRIM|VIS_SAFE|VIS_OCTAL); strnvisx(revision, sizeof(revision), inqbuf.revision, sizeof(inqbuf.revision), VIS_TRIM|VIS_SAFE|VIS_OCTAL); snprintf(bv->bv_vendor, sizeof(bv->bv_vendor), "%s %s %s", vendor, product, revision); } snprintf(bv->bv_dev, sizeof(bv->bv_dev), "%s", device_xname(periph->periph_dev)); } bv->bv_nodisk = rvol0->NumPhysDisks; bv->bv_size = (uint64_t)rvol0->MaxLBA * 512; bv->bv_stripe_size = rvol0->StripeSize; bv->bv_percent = -1; bv->bv_seconds = 0; switch (rvol0->VolumeStatus.State) { case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL: bv->bv_status = BIOC_SVONLINE; break; case MPI_RAIDVOL0_STATUS_STATE_DEGRADED: bv->bv_status = BIOC_SVDEGRADED; break; case MPI_RAIDVOL0_STATUS_STATE_FAILED: bv->bv_status = BIOC_SVOFFLINE; break; default: bv->bv_status = BIOC_SVINVALID; break; } switch (ioc2rvol->VolumeType) { case MPI_RAID_VOL_TYPE_IS: bv->bv_level = 0; break; case MPI_RAID_VOL_TYPE_IME: case MPI_RAID_VOL_TYPE_IM: bv->bv_level = 1; break; default: bv->bv_level = -1; break; } free(ioc2, M_DEVBUF); free(rvol0, M_DEVBUF); return 0; fail: if (ioc2) free(ioc2, M_DEVBUF); if (rvol0) free(rvol0, M_DEVBUF); return EINVAL; } static void mpt_bio_ioctl_disk_common(mpt_softc_t *mpt, struct bioc_disk *bd, int address) { fCONFIG_PAGE_RAID_PHYS_DISK_0 *phys = NULL; char vendor_id[9], product_id[17], product_rev_level[5]; phys = mpt_get_cfg_page_raid_phys_disk0(mpt, address); if (phys == NULL) return; strnvisx(vendor_id, sizeof(vendor_id), phys->InquiryData.VendorID, sizeof(phys->InquiryData.VendorID), VIS_TRIM|VIS_SAFE|VIS_OCTAL); strnvisx(product_id, sizeof(product_id), phys->InquiryData.ProductID, sizeof(phys->InquiryData.ProductID), VIS_TRIM|VIS_SAFE|VIS_OCTAL); strnvisx(product_rev_level, sizeof(product_rev_level), phys->InquiryData.ProductRevLevel, sizeof(phys->InquiryData.ProductRevLevel), VIS_TRIM|VIS_SAFE|VIS_OCTAL); snprintf(bd->bd_vendor, sizeof(bd->bd_vendor), "%s %s %s", vendor_id, product_id, product_rev_level); strlcpy(bd->bd_serial, phys->InquiryData.Info, sizeof(bd->bd_serial)); bd->bd_procdev[0] = '\0'; bd->bd_channel = phys->PhysDiskBus; bd->bd_target = phys->PhysDiskID; bd->bd_lun = 0; bd->bd_size = (uint64_t)phys->MaxLBA * 512; switch (phys->PhysDiskStatus.State) { case MPI_PHYSDISK0_STATUS_ONLINE: bd->bd_status = BIOC_SDONLINE; break; case MPI_PHYSDISK0_STATUS_MISSING: case MPI_PHYSDISK0_STATUS_FAILED: bd->bd_status = BIOC_SDFAILED; break; case MPI_PHYSDISK0_STATUS_OFFLINE_REQUESTED: case MPI_PHYSDISK0_STATUS_FAILED_REQUESTED: case MPI_PHYSDISK0_STATUS_OTHER_OFFLINE: bd->bd_status = BIOC_SDOFFLINE; break; case MPI_PHYSDISK0_STATUS_INITIALIZING: bd->bd_status = BIOC_SDSCRUB; break; case MPI_PHYSDISK0_STATUS_NOT_COMPATIBLE: default: bd->bd_status = BIOC_SDINVALID; break; } free(phys, M_DEVBUF); } static int mpt_bio_ioctl_disk_novol(mpt_softc_t *mpt, struct bioc_disk *bd) { fCONFIG_PAGE_IOC_2 *ioc2 = NULL; fCONFIG_PAGE_IOC_3 *ioc3 = NULL; fCONFIG_PAGE_RAID_VOL_0 *rvol0 = NULL; fCONFIG_PAGE_IOC_2_RAID_VOL *ioc2rvol; int address, v, d; ioc2 = mpt_get_cfg_page_ioc2(mpt); if (ioc2 == NULL) return EIO; ioc3 = mpt_get_cfg_page_ioc3(mpt); if (ioc3 == NULL) { free(ioc2, M_DEVBUF); return EIO; } if (bd->bd_diskid < 0 || bd->bd_diskid >= ioc3->NumPhysDisks) goto fail; address = ioc3->PhysDisk[bd->bd_diskid].PhysDiskNum; mpt_bio_ioctl_disk_common(mpt, bd, address); bd->bd_disknovol = true; for (v = 0; bd->bd_disknovol && v < ioc2->NumActiveVolumes; v++) { ioc2rvol = &ioc2->RaidVolume[v]; address = ioc2rvol->VolumeID | (ioc2rvol->VolumeBus << 8); rvol0 = mpt_get_cfg_page_raid_vol0(mpt, address); if (rvol0 == NULL) continue; for (d = 0; d < rvol0->NumPhysDisks; d++) { if (rvol0->PhysDisk[d].PhysDiskNum == ioc3->PhysDisk[bd->bd_diskid].PhysDiskNum) { bd->bd_disknovol = false; bd->bd_volid = v; break; } } free(rvol0, M_DEVBUF); } free(ioc3, M_DEVBUF); free(ioc2, M_DEVBUF); return 0; fail: if (ioc3) free(ioc3, M_DEVBUF); if (ioc2) free(ioc2, M_DEVBUF); return EINVAL; } static int mpt_bio_ioctl_disk(mpt_softc_t *mpt, struct bioc_disk *bd) { fCONFIG_PAGE_IOC_2 *ioc2 = NULL; fCONFIG_PAGE_RAID_VOL_0 *rvol0 = NULL; fCONFIG_PAGE_IOC_2_RAID_VOL *ioc2rvol; int address; ioc2 = mpt_get_cfg_page_ioc2(mpt); if (ioc2 == NULL) return EIO; if (bd->bd_volid < 0 || bd->bd_volid >= ioc2->NumActiveVolumes) goto fail; ioc2rvol = &ioc2->RaidVolume[bd->bd_volid]; address = ioc2rvol->VolumeID | (ioc2rvol->VolumeBus << 8); rvol0 = mpt_get_cfg_page_raid_vol0(mpt, address); if (rvol0 == NULL) goto fail; if (bd->bd_diskid < 0 || bd->bd_diskid >= rvol0->NumPhysDisks) goto fail; address = rvol0->PhysDisk[bd->bd_diskid].PhysDiskNum; mpt_bio_ioctl_disk_common(mpt, bd, address); free(ioc2, M_DEVBUF); return 0; fail: if (ioc2) free(ioc2, M_DEVBUF); return EINVAL; } #endif