icpsp.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*      $NetBSD: icpsp.c,v 1.21 2008/04/28 20:23:50 martin Exp $        */
    2 
    3 /*-
    4  * Copyright (c) 2002 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * This code is derived from software contributed to The NetBSD Foundation
    8  * by Andrew Doran.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   29  * POSSIBILITY OF SUCH DAMAGE.
   30  */
   31 
   32 #include <sys/cdefs.h>
   33 __KERNEL_RCSID(0, "$NetBSD: icpsp.c,v 1.21 2008/04/28 20:23:50 martin Exp $");
   34 
   35 #include <sys/param.h>
   36 #include <sys/systm.h>
   37 #include <sys/kernel.h>
   38 #include <sys/device.h>
   39 #include <sys/queue.h>
   40 #include <sys/proc.h>
   41 #include <sys/buf.h>
   42 #include <sys/endian.h>
   43 #include <sys/malloc.h>
   44 #include <sys/scsiio.h>
   45 
   46 #include <sys/bswap.h>
   47 #include <sys/bus.h>
   48 
   49 #include <uvm/uvm_extern.h>
   50 
   51 #include <dev/scsipi/scsi_all.h>
   52 #include <dev/scsipi/scsi_disk.h>
   53 #include <dev/scsipi/scsipi_all.h>
   54 #include <dev/scsipi/scsiconf.h>
   55 #include <dev/scsipi/scsi_message.h>
   56 
   57 #include <dev/ic/icpreg.h>
   58 #include <dev/ic/icpvar.h>
   59 
   60 struct icpsp_softc {
   61         struct  device sc_dv;
   62         struct  scsipi_adapter sc_adapter;
   63         struct  scsipi_channel sc_channel;
   64         int     sc_busno;
   65         int     sc_openings;
   66 };
   67 
   68 void    icpsp_attach(struct device *, struct device *, void *);
   69 void    icpsp_intr(struct icp_ccb *);
   70 int     icpsp_match(struct device *, struct cfdata *, void *);
   71 void    icpsp_scsipi_request(struct scsipi_channel *, scsipi_adapter_req_t,
   72                              void *);
   73 
   74 void    icpsp_adjqparam(struct device *, int);
   75 
   76 CFATTACH_DECL(icpsp, sizeof(struct icpsp_softc),
   77     icpsp_match, icpsp_attach, NULL, NULL);
   78 
   79 static const struct icp_servicecb icpsp_servicecb = {
   80         icpsp_adjqparam,
   81 };
   82 
   83 int
   84 icpsp_match(struct device *parent, struct cfdata *match,
   85     void *aux)
   86 {
   87         struct icp_attach_args *icpa;
   88 
   89         icpa = aux;
   90 
   91         return (icpa->icpa_unit >= ICPA_UNIT_SCSI);
   92 }
   93 
   94 void
   95 icpsp_attach(struct device *parent, struct device *self, void *aux)
   96 {
   97         struct icp_attach_args *icpa;
   98         struct icpsp_softc *sc;
   99         struct icp_softc *icp;
  100 
  101         icpa = (struct icp_attach_args *)aux;
  102         sc = (struct icpsp_softc *)self;
  103         icp = (struct icp_softc *)parent;
  104 
  105         sc->sc_busno = icpa->icpa_unit - ICPA_UNIT_SCSI;
  106         sc->sc_openings = icp->icp_openings;
  107         printf(": physical SCSI channel %d\n", sc->sc_busno);
  108 
  109         icp_register_servicecb(icp, icpa->icpa_unit, &icpsp_servicecb);
  110 
  111         sc->sc_adapter.adapt_dev = &sc->sc_dv;
  112         sc->sc_adapter.adapt_nchannels = 1;
  113         sc->sc_adapter.adapt_openings = icp->icp_openings;
  114         sc->sc_adapter.adapt_max_periph = icp->icp_openings;
  115         sc->sc_adapter.adapt_minphys = minphys;
  116         sc->sc_adapter.adapt_request = icpsp_scsipi_request;
  117 
  118         sc->sc_channel.chan_adapter = &sc->sc_adapter;
  119         sc->sc_channel.chan_bustype = &scsi_bustype;
  120         sc->sc_channel.chan_channel = 0;
  121         sc->sc_channel.chan_ntargets = ((icp->icp_class & ICP_FC) != 0 ?
  122             127 : 16); /* XXX bogus check */
  123         sc->sc_channel.chan_nluns = 8;
  124         sc->sc_channel.chan_id = icp->icp_bus_id[sc->sc_busno];
  125         sc->sc_channel.chan_flags = SCSIPI_CHAN_NOSETTLE;
  126 
  127         config_found(self, &sc->sc_channel, scsiprint);
  128 }
  129 
  130 void
  131 icpsp_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req,
  132                      void *arg)
  133 {
  134         struct scsipi_xfer *xs;
  135         struct scsipi_periph *periph;
  136         struct icpsp_softc *sc;
  137         struct icp_rawcmd *rc;
  138         struct icp_softc *icp;
  139         struct icp_ccb *ic;
  140         int rv, flags, s, soff;
  141 
  142         sc = (void *)chan->chan_adapter->adapt_dev;
  143         icp = (struct icp_softc *)device_parent(&sc->sc_dv);
  144 
  145         switch (req) {
  146         case ADAPTER_REQ_RUN_XFER:
  147                 xs = arg;
  148                 periph = xs->xs_periph;
  149                 flags = xs->xs_control;
  150 
  151                 SC_DEBUG(periph, SCSIPI_DB2, ("icpsp_scsi_request run_xfer\n"));
  152 
  153                 if ((flags & XS_CTL_RESET) != 0) {
  154                         /* XXX Unimplemented. */
  155                         xs->error = XS_DRIVER_STUFFUP;
  156                         scsipi_done(xs);
  157                         return;
  158                 }
  159 
  160 #if defined(ICP_DEBUG) || defined(SCSIDEBUG)
  161                 if (xs->cmdlen > sizeof(rc->rc_cdb))
  162                         panic("%s: CDB too large", device_xname(&sc->sc_dv));
  163 #endif
  164 
  165                 /*
  166                  * Allocate a CCB.
  167                  */
  168                 if (__predict_false((ic = icp_ccb_alloc(icp)) == NULL)) {
  169                         xs->error = XS_RESOURCE_SHORTAGE;
  170                         scsipi_done(xs);
  171                         return;
  172                 }
  173                 rc = &ic->ic_cmd.cmd_packet.rc;
  174                 ic->ic_sg = rc->rc_sg;
  175                 ic->ic_service = ICP_SCSIRAWSERVICE;
  176                 soff = ICP_SCRATCH_SENSE + ic->ic_ident *
  177                     sizeof(struct scsi_sense_data);
  178 
  179                 /*
  180                  * Build the command.  We don't need to actively prevent
  181                  * access to array components, since the controller kindly
  182                  * takes care of that for us.
  183                  */
  184                 ic->ic_cmd.cmd_opcode = htole16(ICP_WRITE);
  185                 memcpy(rc->rc_cdb, xs->cmd, xs->cmdlen);
  186 
  187                 rc->rc_padding0 = 0;
  188                 rc->rc_direction = htole32((flags & XS_CTL_DATA_IN) != 0 ?
  189                     ICP_DATA_IN : ICP_DATA_OUT);
  190                 rc->rc_mdisc_time = 0;
  191                 rc->rc_mcon_time = 0;
  192                 rc->rc_clen = htole32(xs->cmdlen);
  193                 rc->rc_target = periph->periph_target;
  194                 rc->rc_lun = periph->periph_lun;
  195                 rc->rc_bus = sc->sc_busno;
  196                 rc->rc_priority = 0;
  197                 rc->rc_sense_len = htole32(sizeof(xs->sense.scsi_sense));
  198                 rc->rc_sense_addr =
  199                     htole32(soff + icp->icp_scr_seg[0].ds_addr);
  200                 rc->rc_padding1 = 0;
  201 
  202                 if (xs->datalen != 0) {
  203                         rv = icp_ccb_map(icp, ic, xs->data, xs->datalen,
  204                            (flags & XS_CTL_DATA_IN) != 0 ? IC_XFER_IN :
  205                            IC_XFER_OUT);
  206                         if (rv != 0) {
  207                                 icp_ccb_free(icp, ic);
  208                                 xs->error = XS_DRIVER_STUFFUP;
  209                                 scsipi_done(xs);
  210                                 return;
  211                         }
  212 
  213                         rc->rc_nsgent = htole32(ic->ic_nsgent);
  214                         rc->rc_sdata = ~0;
  215                         rc->rc_sdlen = htole32(xs->datalen);
  216                 } else {
  217                         rc->rc_nsgent = 0;
  218                         rc->rc_sdata = 0;
  219                         rc->rc_sdlen = 0;
  220                 }
  221 
  222                 ic->ic_cmdlen = (u_long)ic->ic_sg - (u_long)&ic->ic_cmd +
  223                     ic->ic_nsgent * sizeof(*ic->ic_sg);
  224 
  225                 bus_dmamap_sync(icp->icp_dmat, icp->icp_scr_dmamap, soff,
  226                     sizeof(xs->sense.scsi_sense), BUS_DMASYNC_PREREAD);
  227 
  228                 /*
  229                  * Fire it off to the controller.
  230                  */
  231                 ic->ic_intr = icpsp_intr;
  232                 ic->ic_context = xs;
  233                 ic->ic_dv = &sc->sc_dv;
  234 
  235                 if ((flags & XS_CTL_POLL) != 0) {
  236                         s = splbio();
  237                         rv = icp_ccb_poll(icp, ic, xs->timeout);
  238                         if (rv != 0) {
  239                                 if (xs->datalen != 0)
  240                                         icp_ccb_unmap(icp, ic);
  241                                 icp_ccb_free(icp, ic);
  242                                 xs->error = XS_TIMEOUT;
  243                                 scsipi_done(xs);
  244 
  245                                 /*
  246                                  * XXX We're now in a bad way, because we
  247                                  * don't know how to abort the command.
  248                                  * That shouldn't matter too much, since
  249                                  * polled commands won't be used while the
  250                                  * system is running.
  251                                  */
  252                         }
  253                         splx(s);
  254                 } else
  255                         icp_ccb_enqueue(icp, ic);
  256 
  257                 break;
  258 
  259         case ADAPTER_REQ_GROW_RESOURCES:
  260         case ADAPTER_REQ_SET_XFER_MODE:
  261                 /*
  262                  * Neither of these cases are supported, and neither of them
  263                  * is particulatly relevant, since we have an abstract view
  264                  * of the bus; the controller takes care of all the nitty
  265                  * gritty.
  266                  */
  267                 break;
  268         }
  269 }
  270 
  271 void
  272 icpsp_intr(struct icp_ccb *ic)
  273 {
  274         struct scsipi_xfer *xs;
  275         struct icpsp_softc *sc;
  276         struct icp_softc *icp;
  277         int soff;
  278 
  279         sc = (struct icpsp_softc *)ic->ic_dv;
  280         xs = (struct scsipi_xfer *)ic->ic_context;
  281         icp = (struct icp_softc *)device_parent(ic->ic_dv);
  282         soff = ICP_SCRATCH_SENSE + ic->ic_ident *
  283             sizeof(struct scsi_sense_data);
  284 
  285         SC_DEBUG(xs->xs_periph, SCSIPI_DB2, ("icpsp_intr\n"));
  286 
  287         bus_dmamap_sync(icp->icp_dmat, icp->icp_scr_dmamap, soff,
  288             sizeof(xs->sense.scsi_sense), BUS_DMASYNC_POSTREAD);
  289 
  290         if (ic->ic_status == ICP_S_OK) {
  291                 xs->status = SCSI_OK;
  292                 xs->resid = 0;
  293         } else if (ic->ic_status != ICP_S_RAW_SCSI || icp->icp_info >= 0x100) {
  294                 xs->error = XS_SELTIMEOUT;
  295                 xs->resid = xs->datalen;
  296         } else {
  297                 xs->status = icp->icp_info;
  298 
  299                 switch (xs->status) {
  300                 case SCSI_OK:
  301 #ifdef DIAGNOSTIC
  302                         printf("%s: error return (%d), but SCSI_OK?\n",
  303                             device_xname(&sc->sc_dv), icp->icp_info);
  304 #endif
  305                         xs->resid = 0;
  306                         break;
  307                 case SCSI_CHECK:
  308                         memcpy(&xs->sense.scsi_sense,
  309                             (char *)icp->icp_scr + soff,
  310                             sizeof(xs->sense.scsi_sense));
  311                         xs->error = XS_SENSE;
  312                         /* FALLTHROUGH */
  313                 default:
  314                         /*
  315                          * XXX Don't know how to get residual count.
  316                          */
  317                         xs->resid = xs->datalen;
  318                         break;
  319                 }
  320         }
  321 
  322         if (xs->datalen != 0)
  323                 icp_ccb_unmap(icp, ic);
  324         icp_ccb_free(icp, ic);
  325         scsipi_done(xs);
  326 }
  327 
  328 void
  329 icpsp_adjqparam(struct device *dv, int openings)
  330 {
  331         struct icpsp_softc *sc = (struct icpsp_softc *) dv;
  332         int s;
  333 
  334         s = splbio();
  335         sc->sc_adapter.adapt_openings += openings - sc->sc_openings;
  336         sc->sc_openings = openings;
  337         splx(s);
  338 }
Cache object: dbf5b20bd7d23807e05da37f29a0a985
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/ic/icpsp.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/ic/icpsp.c
