345 lines
9.5 KiB
C
345 lines
9.5 KiB
C
/* $NetBSD: icpsp.c,v 1.9 2003/09/18 01:33:59 mycroft Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2002 The NetBSD Foundation, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by Andrew Doran.
|
|
*
|
|
* 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 by the NetBSD
|
|
* Foundation, Inc. and its contributors.
|
|
* 4. Neither the name of The NetBSD Foundation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__KERNEL_RCSID(0, "$NetBSD: icpsp.c,v 1.9 2003/09/18 01:33:59 mycroft Exp $");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/device.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/proc.h>
|
|
#include <sys/buf.h>
|
|
#include <sys/endian.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/scsiio.h>
|
|
#include <sys/lock.h>
|
|
|
|
#include <machine/bswap.h>
|
|
#include <machine/bus.h>
|
|
|
|
#include <uvm/uvm_extern.h>
|
|
|
|
#include <dev/scsipi/scsi_all.h>
|
|
#include <dev/scsipi/scsi_disk.h>
|
|
#include <dev/scsipi/scsipi_all.h>
|
|
#include <dev/scsipi/scsiconf.h>
|
|
#include <dev/scsipi/scsi_message.h>
|
|
|
|
#include <dev/ic/icpreg.h>
|
|
#include <dev/ic/icpvar.h>
|
|
|
|
struct icpsp_softc {
|
|
struct device sc_dv;
|
|
struct scsipi_adapter sc_adapter;
|
|
struct scsipi_channel sc_channel;
|
|
int sc_busno;
|
|
int sc_openings;
|
|
};
|
|
|
|
void icpsp_attach(struct device *, struct device *, void *);
|
|
void icpsp_intr(struct icp_ccb *);
|
|
int icpsp_match(struct device *, struct cfdata *, void *);
|
|
void icpsp_scsipi_request(struct scsipi_channel *, scsipi_adapter_req_t,
|
|
void *);
|
|
|
|
void icpsp_adjqparam(struct device *, int);
|
|
|
|
CFATTACH_DECL(icpsp, sizeof(struct icpsp_softc),
|
|
icpsp_match, icpsp_attach, NULL, NULL);
|
|
|
|
static const struct icp_servicecb icpsp_servicecb = {
|
|
icpsp_adjqparam,
|
|
};
|
|
|
|
int
|
|
icpsp_match(struct device *parent, struct cfdata *match, void *aux)
|
|
{
|
|
struct icp_attach_args *icpa;
|
|
|
|
icpa = aux;
|
|
|
|
return (icpa->icpa_unit >= ICPA_UNIT_SCSI);
|
|
}
|
|
|
|
void
|
|
icpsp_attach(struct device *parent, struct device *self, void *aux)
|
|
{
|
|
struct icp_attach_args *icpa;
|
|
struct icpsp_softc *sc;
|
|
struct icp_softc *icp;
|
|
|
|
icpa = (struct icp_attach_args *)aux;
|
|
sc = (struct icpsp_softc *)self;
|
|
icp = (struct icp_softc *)parent;
|
|
|
|
sc->sc_busno = icpa->icpa_unit - ICPA_UNIT_SCSI;
|
|
sc->sc_openings = icp->icp_openings;
|
|
printf(": physical SCSI channel %d\n", sc->sc_busno);
|
|
|
|
icp_register_servicecb(icp, icpa->icpa_unit, &icpsp_servicecb);
|
|
|
|
sc->sc_adapter.adapt_dev = &sc->sc_dv;
|
|
sc->sc_adapter.adapt_nchannels = 1;
|
|
sc->sc_adapter.adapt_openings = icp->icp_openings;
|
|
sc->sc_adapter.adapt_max_periph = icp->icp_openings;
|
|
sc->sc_adapter.adapt_minphys = minphys;
|
|
sc->sc_adapter.adapt_request = icpsp_scsipi_request;
|
|
|
|
sc->sc_channel.chan_adapter = &sc->sc_adapter;
|
|
sc->sc_channel.chan_bustype = &scsi_bustype;
|
|
sc->sc_channel.chan_channel = 0;
|
|
sc->sc_channel.chan_ntargets = ((icp->icp_class & ICP_FC) != 0 ?
|
|
127 : 16); /* XXX bogus check */
|
|
sc->sc_channel.chan_nluns = 8;
|
|
sc->sc_channel.chan_id = icp->icp_bus_id[sc->sc_busno];
|
|
sc->sc_channel.chan_flags = SCSIPI_CHAN_NOSETTLE;
|
|
|
|
config_found(self, &sc->sc_channel, scsiprint);
|
|
}
|
|
|
|
void
|
|
icpsp_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req,
|
|
void *arg)
|
|
{
|
|
struct scsipi_xfer *xs;
|
|
struct scsipi_periph *periph;
|
|
struct icpsp_softc *sc;
|
|
struct icp_rawcmd *rc;
|
|
struct icp_softc *icp;
|
|
struct icp_ccb *ic;
|
|
int rv, flags, s, soff;
|
|
|
|
sc = (void *)chan->chan_adapter->adapt_dev;
|
|
icp = (struct icp_softc *)sc->sc_dv.dv_parent;
|
|
|
|
switch (req) {
|
|
case ADAPTER_REQ_RUN_XFER:
|
|
xs = arg;
|
|
periph = xs->xs_periph;
|
|
flags = xs->xs_control;
|
|
|
|
SC_DEBUG(periph, SCSIPI_DB2, ("icpsp_scsi_request run_xfer\n"));
|
|
|
|
if ((flags & XS_CTL_RESET) != 0) {
|
|
/* XXX Unimplemented. */
|
|
xs->error = XS_DRIVER_STUFFUP;
|
|
scsipi_done(xs);
|
|
return;
|
|
}
|
|
|
|
#if defined(ICP_DEBUG) || defined(SCSIDEBUG)
|
|
if (xs->cmdlen > sizeof(rc->rc_cdb))
|
|
panic("%s: CDB too large", sc->sc_dv.dv_xname);
|
|
#endif
|
|
|
|
/*
|
|
* Allocate a CCB.
|
|
*/
|
|
if (__predict_false((ic = icp_ccb_alloc(icp)) == NULL)) {
|
|
xs->error = XS_RESOURCE_SHORTAGE;
|
|
scsipi_done(xs);
|
|
return;
|
|
}
|
|
rc = &ic->ic_cmd.cmd_packet.rc;
|
|
ic->ic_sg = rc->rc_sg;
|
|
ic->ic_service = ICP_SCSIRAWSERVICE;
|
|
soff = ICP_SCRATCH_SENSE + ic->ic_ident *
|
|
sizeof(struct scsipi_sense_data);
|
|
|
|
/*
|
|
* Build the command. We don't need to actively prevent
|
|
* access to array components, since the controller kindly
|
|
* takes care of that for us.
|
|
*/
|
|
ic->ic_cmd.cmd_opcode = htole16(ICP_WRITE);
|
|
memcpy(rc->rc_cdb, xs->cmd, xs->cmdlen);
|
|
|
|
rc->rc_padding0 = 0;
|
|
rc->rc_direction = htole32((flags & XS_CTL_DATA_IN) != 0 ?
|
|
ICP_DATA_IN : ICP_DATA_OUT);
|
|
rc->rc_mdisc_time = 0;
|
|
rc->rc_mcon_time = 0;
|
|
rc->rc_clen = htole32(xs->cmdlen);
|
|
rc->rc_target = periph->periph_target;
|
|
rc->rc_lun = periph->periph_lun;
|
|
rc->rc_bus = sc->sc_busno;
|
|
rc->rc_priority = 0;
|
|
rc->rc_sense_len = htole32(sizeof(xs->sense.scsi_sense));
|
|
rc->rc_sense_addr =
|
|
htole32(soff + icp->icp_scr_seg[0].ds_addr);
|
|
rc->rc_padding1 = 0;
|
|
|
|
if (xs->datalen != 0) {
|
|
rv = icp_ccb_map(icp, ic, xs->data, xs->datalen,
|
|
(flags & XS_CTL_DATA_IN) != 0 ? IC_XFER_IN :
|
|
IC_XFER_OUT);
|
|
if (rv != 0) {
|
|
icp_ccb_free(icp, ic);
|
|
xs->error = XS_DRIVER_STUFFUP;
|
|
scsipi_done(xs);
|
|
return;
|
|
}
|
|
|
|
rc->rc_nsgent = htole32(ic->ic_nsgent);
|
|
rc->rc_sdata = ~0;
|
|
rc->rc_sdlen = htole32(xs->datalen);
|
|
} else {
|
|
rc->rc_nsgent = 0;
|
|
rc->rc_sdata = 0;
|
|
rc->rc_sdlen = 0;
|
|
}
|
|
|
|
ic->ic_cmdlen = (u_long)ic->ic_sg - (u_long)&ic->ic_cmd +
|
|
ic->ic_nsgent * sizeof(*ic->ic_sg);
|
|
|
|
bus_dmamap_sync(icp->icp_dmat, icp->icp_scr_dmamap, soff,
|
|
sizeof(xs->sense.scsi_sense), BUS_DMASYNC_PREREAD);
|
|
|
|
/*
|
|
* Fire it off to the controller.
|
|
*/
|
|
ic->ic_intr = icpsp_intr;
|
|
ic->ic_context = xs;
|
|
ic->ic_dv = &sc->sc_dv;
|
|
|
|
if ((flags & XS_CTL_POLL) != 0) {
|
|
s = splbio();
|
|
rv = icp_ccb_poll(icp, ic, xs->timeout);
|
|
if (rv != 0) {
|
|
if (xs->datalen != 0)
|
|
icp_ccb_unmap(icp, ic);
|
|
icp_ccb_free(icp, ic);
|
|
xs->error = XS_TIMEOUT;
|
|
scsipi_done(xs);
|
|
|
|
/*
|
|
* XXX We're now in a bad way, because we
|
|
* don't know how to abort the command.
|
|
* That shouldn't matter too much, since
|
|
* polled commands won't be used while the
|
|
* system is running.
|
|
*/
|
|
}
|
|
splx(s);
|
|
} else
|
|
icp_ccb_enqueue(icp, ic);
|
|
|
|
break;
|
|
|
|
case ADAPTER_REQ_GROW_RESOURCES:
|
|
case ADAPTER_REQ_SET_XFER_MODE:
|
|
/*
|
|
* Neither of these cases are supported, and neither of them
|
|
* is particulatly relevant, since we have an abstract view
|
|
* of the bus; the controller takes care of all the nitty
|
|
* gritty.
|
|
*/
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
icpsp_intr(struct icp_ccb *ic)
|
|
{
|
|
struct scsipi_xfer *xs;
|
|
struct icpsp_softc *sc;
|
|
struct icp_softc *icp;
|
|
int soff;
|
|
|
|
sc = (struct icpsp_softc *)ic->ic_dv;
|
|
xs = (struct scsipi_xfer *)ic->ic_context;
|
|
icp = (struct icp_softc *)ic->ic_dv->dv_parent;
|
|
soff = ICP_SCRATCH_SENSE + ic->ic_ident *
|
|
sizeof(struct scsipi_sense_data);
|
|
|
|
SC_DEBUG(xs->xs_periph, SCSIPI_DB2, ("icpsp_intr\n"));
|
|
|
|
bus_dmamap_sync(icp->icp_dmat, icp->icp_scr_dmamap, soff,
|
|
sizeof(xs->sense.scsi_sense), BUS_DMASYNC_POSTREAD);
|
|
|
|
if (ic->ic_status == ICP_S_OK) {
|
|
xs->status = SCSI_OK;
|
|
xs->resid = 0;
|
|
} else if (ic->ic_status != ICP_S_RAW_SCSI || icp->icp_info >= 0x100) {
|
|
xs->error = XS_SELTIMEOUT;
|
|
xs->resid = xs->datalen;
|
|
} else {
|
|
xs->status = icp->icp_info;
|
|
|
|
switch (xs->status) {
|
|
case SCSI_OK:
|
|
#ifdef DIAGNOSTIC
|
|
printf("%s: error return (%d), but SCSI_OK?\n",
|
|
sc->sc_dv.dv_xname, icp->icp_info);
|
|
#endif
|
|
xs->resid = 0;
|
|
break;
|
|
case SCSI_CHECK:
|
|
memcpy(&xs->sense.scsi_sense, icp->icp_scr + soff,
|
|
sizeof(xs->sense.scsi_sense));
|
|
xs->error = XS_SENSE;
|
|
/* FALLTHROUGH */
|
|
default:
|
|
/*
|
|
* XXX Don't know how to get residual count.
|
|
*/
|
|
xs->resid = xs->datalen;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (xs->datalen != 0)
|
|
icp_ccb_unmap(icp, ic);
|
|
icp_ccb_free(icp, ic);
|
|
scsipi_done(xs);
|
|
}
|
|
|
|
void
|
|
icpsp_adjqparam(struct device *dv, int openings)
|
|
{
|
|
struct icpsp_softc *sc = (struct icpsp_softc *) dv;
|
|
int s;
|
|
|
|
s = splbio();
|
|
sc->sc_adapter.adapt_openings += openings - sc->sc_openings;
|
|
sc->sc_openings = openings;
|
|
splx(s);
|
|
}
|