The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/ic/uha.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: uha.c,v 1.32 2003/10/30 01:58:17 simonb Exp $  */
    2 
    3 /*-
    4  * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * This code is derived from software contributed to The NetBSD Foundation
    8  * by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace
    9  * Simulation Facility, NASA Ames Research Center.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *      This product includes software developed by the NetBSD
   22  *      Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   39 
   40 /*
   41  * Ported for use with the UltraStor 14f by Gary Close (gclose@wvnvms.wvnet.edu)
   42  * Slight fixes to timeouts to run with the 34F
   43  * Thanks to Julian Elischer for advice and help with this port.
   44  *
   45  * Originally written by Julian Elischer (julian@tfs.com)
   46  * for TRW Financial Systems for use under the MACH(2.5) operating system.
   47  *
   48  * TRW Financial Systems, in accordance with their agreement with Carnegie
   49  * Mellon University, makes this software available to CMU to distribute
   50  * or use in any manner that they see fit as long as this message is kept with
   51  * the software. For this reason TFS also grants any other persons or
   52  * organisations permission to use or modify this software.
   53  *
   54  * TFS supplies this software to be publicly redistributed
   55  * on the understanding that TFS is not responsible for the correct
   56  * functioning of this software in any circumstances.
   57  *
   58  * commenced: Sun Sep 27 18:14:01 PDT 1992
   59  * slight mod to make work with 34F as well: Wed Jun  2 18:05:48 WST 1993
   60  */
   61 
   62 #include <sys/cdefs.h>
   63 __KERNEL_RCSID(0, "$NetBSD: uha.c,v 1.32 2003/10/30 01:58:17 simonb Exp $");
   64 
   65 #undef UHADEBUG
   66 #ifdef DDB
   67 #define integrate
   68 #else
   69 #define integrate       static inline
   70 #endif
   71 
   72 #include <sys/param.h>
   73 #include <sys/systm.h>
   74 #include <sys/kernel.h>
   75 #include <sys/errno.h>
   76 #include <sys/ioctl.h>
   77 #include <sys/device.h>
   78 #include <sys/malloc.h>
   79 #include <sys/buf.h>
   80 #include <sys/proc.h>
   81 #include <sys/user.h>
   82 
   83 #include <uvm/uvm_extern.h>
   84 
   85 #include <machine/bus.h>
   86 #include <machine/intr.h>
   87 
   88 #include <dev/scsipi/scsi_all.h>
   89 #include <dev/scsipi/scsipi_all.h>
   90 #include <dev/scsipi/scsiconf.h>
   91 
   92 #include <dev/ic/uhareg.h>
   93 #include <dev/ic/uhavar.h>
   94 
   95 #ifndef DDB
   96 #define Debugger() panic("should call debugger here (uha.c)")
   97 #endif /* ! DDB */
   98 
   99 #define UHA_MAXXFER     ((UHA_NSEG - 1) << PGSHIFT)
  100 
  101 integrate void uha_reset_mscp __P((struct uha_softc *, struct uha_mscp *));
  102 void uha_free_mscp __P((struct uha_softc *, struct uha_mscp *));
  103 integrate int uha_init_mscp __P((struct uha_softc *, struct uha_mscp *));
  104 struct uha_mscp *uha_get_mscp __P((struct uha_softc *));
  105 void uhaminphys __P((struct buf *));
  106 void uha_scsipi_request __P((struct scsipi_channel *,
  107         scsipi_adapter_req_t, void *));
  108 int uha_create_mscps __P((struct uha_softc *, struct uha_mscp *, int));
  109 
  110 #define UHA_ABORT_TIMEOUT       2000    /* time to wait for abort (mSec) */
  111 
  112 /*
  113  * Attach all the sub-devices we can find
  114  */
  115 void
  116 uha_attach(sc, upd)
  117         struct uha_softc *sc;
  118         struct uha_probe_data *upd;
  119 {
  120         struct scsipi_adapter *adapt = &sc->sc_adapter;
  121         struct scsipi_channel *chan = &sc->sc_channel;
  122         bus_dma_segment_t seg;
  123         int i, error, rseg;
  124 
  125         TAILQ_INIT(&sc->sc_free_mscp);
  126 
  127         (sc->init)(sc);
  128 
  129         /*
  130          * Fill in the scsipi_adapter.
  131          */
  132         memset(adapt, 0, sizeof(*adapt));
  133         adapt->adapt_dev = &sc->sc_dev;
  134         adapt->adapt_nchannels = 1;
  135         /* adapt_openings initialized below */
  136         /* adapt_max_periph initialized below */
  137         adapt->adapt_request = uha_scsipi_request;
  138         adapt->adapt_minphys = uhaminphys;
  139 
  140         /*
  141          * Fill in the scsipi_channel.
  142          */
  143         memset(chan, 0, sizeof(*chan));
  144         chan->chan_adapter = adapt;
  145         chan->chan_bustype = &scsi_bustype;
  146         chan->chan_channel = 0;
  147         chan->chan_ntargets = 8;
  148         chan->chan_nluns = 8;
  149         chan->chan_id = upd->sc_scsi_dev;
  150 
  151 #define MSCPSIZE        (UHA_MSCP_MAX * sizeof(struct uha_mscp))
  152 
  153         /*
  154          * Allocate the MSCPs.
  155          */
  156         if ((error = bus_dmamem_alloc(sc->sc_dmat, MSCPSIZE,
  157             PAGE_SIZE, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT)) != 0) {
  158                 printf("%s: unable to allocate mscps, error = %d\n",
  159                     sc->sc_dev.dv_xname, error);
  160                 return;
  161         }
  162         if ((error = bus_dmamem_map(sc->sc_dmat, &seg, rseg,
  163             MSCPSIZE, (caddr_t *)&sc->sc_mscps,
  164             BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) != 0) {
  165                 printf("%s: unable to map mscps, error = %d\n",
  166                     sc->sc_dev.dv_xname, error);
  167                 return;
  168         }
  169 
  170         /*
  171          * Create and load the DMA map used for the mscps.
  172          */
  173         if ((error = bus_dmamap_create(sc->sc_dmat, MSCPSIZE,
  174             1, MSCPSIZE, 0, BUS_DMA_NOWAIT | sc->sc_dmaflags,
  175             &sc->sc_dmamap_mscp)) != 0) {
  176                 printf("%s: unable to create mscp DMA map, error = %d\n",
  177                     sc->sc_dev.dv_xname, error);
  178                 return;
  179         }
  180         if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_dmamap_mscp,
  181             sc->sc_mscps, MSCPSIZE, NULL, BUS_DMA_NOWAIT)) != 0) {
  182                 printf("%s: unable to load mscp DMA map, error = %d\n",
  183                     sc->sc_dev.dv_xname, error);
  184                 return;
  185         }
  186 
  187 #undef MSCPSIZE
  188 
  189         /*
  190          * Initialize the mscps.
  191          */
  192         i = uha_create_mscps(sc, sc->sc_mscps, UHA_MSCP_MAX);
  193         if (i == 0) {
  194                 printf("%s: unable to create mscps\n",
  195                     sc->sc_dev.dv_xname);
  196                 return;
  197         } else if (i != UHA_MSCP_MAX) {
  198                 printf("%s: WARNING: only %d of %d mscps created\n",
  199                     sc->sc_dev.dv_xname, i, UHA_MSCP_MAX);
  200         }
  201 
  202         adapt->adapt_openings = i;
  203         adapt->adapt_max_periph = adapt->adapt_openings;
  204 
  205         /*
  206          * ask the adapter what subunits are present
  207          */
  208         config_found(&sc->sc_dev, &sc->sc_channel, scsiprint);
  209 }
  210 
  211 integrate void
  212 uha_reset_mscp(sc, mscp)
  213         struct uha_softc *sc;
  214         struct uha_mscp *mscp;
  215 {
  216 
  217         mscp->flags = 0;
  218 }
  219 
  220 /*
  221  * A mscp (and hence a mbx-out) is put onto the free list.
  222  */
  223 void
  224 uha_free_mscp(sc, mscp)
  225         struct uha_softc *sc;
  226         struct uha_mscp *mscp;
  227 {
  228         int s;
  229 
  230         s = splbio();
  231         uha_reset_mscp(sc, mscp);
  232         TAILQ_INSERT_HEAD(&sc->sc_free_mscp, mscp, chain);
  233         splx(s);
  234 }
  235 
  236 integrate int
  237 uha_init_mscp(sc, mscp)
  238         struct uha_softc *sc;
  239         struct uha_mscp *mscp;
  240 {
  241         bus_dma_tag_t dmat = sc->sc_dmat;
  242         int hashnum, error;
  243 
  244         /*
  245          * Create the DMA map for this MSCP.
  246          */
  247         error = bus_dmamap_create(dmat, UHA_MAXXFER, UHA_NSEG, UHA_MAXXFER,
  248             0, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW | sc->sc_dmaflags,
  249             &mscp->dmamap_xfer);
  250         if (error) {
  251                 printf("%s: can't create mscp DMA map, error = %d\n",
  252                     sc->sc_dev.dv_xname, error);
  253                 return (error);
  254         }
  255 
  256         /*
  257          * put in the phystokv hash table
  258          * Never gets taken out.
  259          */
  260         mscp->hashkey = sc->sc_dmamap_mscp->dm_segs[0].ds_addr +
  261             UHA_MSCP_OFF(mscp);
  262         hashnum = MSCP_HASH(mscp->hashkey);
  263         mscp->nexthash = sc->sc_mscphash[hashnum];
  264         sc->sc_mscphash[hashnum] = mscp;
  265         uha_reset_mscp(sc, mscp);
  266         return (0);
  267 }
  268 
  269 /*
  270  * Create a set of MSCPs and add them to the free list.
  271  */
  272 int
  273 uha_create_mscps(sc, mscpstore, count)
  274         struct uha_softc *sc;
  275         struct uha_mscp *mscpstore;
  276         int count;
  277 {
  278         struct uha_mscp *mscp;
  279         int i, error;
  280 
  281         memset(mscpstore, 0, sizeof(struct uha_mscp) * count);
  282         for (i = 0; i < count; i++) {
  283                 mscp = &mscpstore[i];
  284                 if ((error = uha_init_mscp(sc, mscp)) != 0) {
  285                         printf("%s: unable to initialize mscp, error = %d\n",
  286                             sc->sc_dev.dv_xname, error);
  287                         goto out;
  288                 }
  289                 TAILQ_INSERT_TAIL(&sc->sc_free_mscp, mscp, chain);
  290         }
  291  out:
  292         return (i);
  293 }
  294 
  295 /*
  296  * Get a free mscp
  297  *
  298  * If there are none, see if we can allocate a new one.  If so, put it in the
  299  * hash table too otherwise either return an error or sleep.
  300  */
  301 struct uha_mscp *
  302 uha_get_mscp(sc)
  303         struct uha_softc *sc;
  304 {
  305         struct uha_mscp *mscp;
  306         int s;
  307 
  308         s = splbio();
  309         mscp = TAILQ_FIRST(&sc->sc_free_mscp);
  310         if (mscp != NULL) {
  311                 TAILQ_REMOVE(&sc->sc_free_mscp, mscp, chain);
  312                 mscp->flags |= MSCP_ALLOC;
  313         }
  314         splx(s);
  315         return (mscp);
  316 }
  317 
  318 /*
  319  * given a physical address, find the mscp that it corresponds to.
  320  */
  321 struct uha_mscp *
  322 uha_mscp_phys_kv(sc, mscp_phys)
  323         struct uha_softc *sc;
  324         u_long mscp_phys;
  325 {
  326         int hashnum = MSCP_HASH(mscp_phys);
  327         struct uha_mscp *mscp = sc->sc_mscphash[hashnum];
  328 
  329         while (mscp) {
  330                 if (mscp->hashkey == mscp_phys)
  331                         break;
  332                 mscp = mscp->nexthash;
  333         }
  334         return (mscp);
  335 }
  336 
  337 /*
  338  * We have a mscp which has been processed by the adaptor, now we look to see
  339  * how the operation went.
  340  */
  341 void
  342 uha_done(sc, mscp)
  343         struct uha_softc *sc;
  344         struct uha_mscp *mscp;
  345 {
  346         bus_dma_tag_t dmat = sc->sc_dmat;
  347         struct scsipi_sense_data *s1, *s2;
  348         struct scsipi_xfer *xs = mscp->xs;
  349 
  350         SC_DEBUG(xs->xs_periph, SCSIPI_DB2, ("uha_done\n"));
  351 
  352         bus_dmamap_sync(dmat, sc->sc_dmamap_mscp,
  353             UHA_MSCP_OFF(mscp), sizeof(struct uha_mscp),
  354             BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
  355 
  356         /*
  357          * If we were a data transfer, unload the map that described
  358          * the data buffer.
  359          */
  360         if (xs->datalen) {
  361                 bus_dmamap_sync(dmat, mscp->dmamap_xfer, 0,
  362                     mscp->dmamap_xfer->dm_mapsize,
  363                     (xs->xs_control & XS_CTL_DATA_IN) ? BUS_DMASYNC_POSTREAD :
  364                     BUS_DMASYNC_POSTWRITE);
  365                 bus_dmamap_unload(dmat, mscp->dmamap_xfer);
  366         }
  367 
  368         /*
  369          * Otherwise, put the results of the operation
  370          * into the xfer and call whoever started it
  371          */
  372         if ((mscp->flags & MSCP_ALLOC) == 0) {
  373                 printf("%s: exiting ccb not allocated!\n", sc->sc_dev.dv_xname);
  374                 Debugger();
  375                 return;
  376         }
  377         if (xs->error == XS_NOERROR) {
  378                 if (mscp->host_stat != UHA_NO_ERR) {
  379                         switch (mscp->host_stat) {
  380                         case UHA_SBUS_TIMEOUT:          /* No response */
  381                                 xs->error = XS_SELTIMEOUT;
  382                                 break;
  383                         default:        /* Other scsi protocol messes */
  384                                 printf("%s: host_stat %x\n",
  385                                     sc->sc_dev.dv_xname, mscp->host_stat);
  386                                 xs->error = XS_DRIVER_STUFFUP;
  387                         }
  388                 } else if (mscp->target_stat != SCSI_OK) {
  389                         switch (mscp->target_stat) {
  390                         case SCSI_CHECK:
  391                                 s1 = &mscp->mscp_sense;
  392                                 s2 = &xs->sense.scsi_sense;
  393                                 *s2 = *s1;
  394                                 xs->error = XS_SENSE;
  395                                 break;
  396                         case SCSI_BUSY:
  397                                 xs->error = XS_BUSY;
  398                                 break;
  399                         default:
  400                                 printf("%s: target_stat %x\n",
  401                                     sc->sc_dev.dv_xname, mscp->target_stat);
  402                                 xs->error = XS_DRIVER_STUFFUP;
  403                         }
  404                 } else
  405                         xs->resid = 0;
  406         }
  407         uha_free_mscp(sc, mscp);
  408         scsipi_done(xs);
  409 }
  410 
  411 void
  412 uhaminphys(bp)
  413         struct buf *bp;
  414 {
  415 
  416         if (bp->b_bcount > UHA_MAXXFER)
  417                 bp->b_bcount = UHA_MAXXFER;
  418         minphys(bp);
  419 }
  420 
  421 /*
  422  * start a scsi operation given the command and the data address.  Also
  423  * needs the unit, target and lu.
  424  */
  425 
  426 void
  427 uha_scsipi_request(chan, req, arg)
  428         struct scsipi_channel *chan;
  429         scsipi_adapter_req_t req;
  430         void *arg;
  431 {
  432         struct scsipi_xfer *xs;
  433         struct scsipi_periph *periph;
  434         struct uha_softc *sc = (void *)chan->chan_adapter->adapt_dev;
  435         bus_dma_tag_t dmat = sc->sc_dmat;
  436         struct uha_mscp *mscp;
  437         int error, seg, flags, s;
  438 
  439 
  440         switch (req) {
  441         case ADAPTER_REQ_RUN_XFER:
  442                 xs = arg;
  443                 periph = xs->xs_periph;
  444                 flags = xs->xs_control;
  445 
  446                 SC_DEBUG(periph, SCSIPI_DB2, ("uha_scsipi_request\n"));
  447 
  448                 /* Get an MSCP to use. */
  449                 mscp = uha_get_mscp(sc);
  450 #ifdef DIAGNOSTIC
  451                 /*
  452                  * This should never happen as we track the resources
  453                  * in the mid-layer.
  454                  */
  455                 if (mscp == NULL) {
  456                         scsipi_printaddr(periph);
  457                         printf("unable to allocate mscp\n");
  458                         panic("uha_scsipi_request");
  459                 }
  460 #endif
  461 
  462                 mscp->xs = xs;
  463                 mscp->timeout = xs->timeout;
  464 
  465                 /*
  466                  * Put all the arguments for the xfer in the mscp
  467                  */
  468                 if (flags & XS_CTL_RESET) {
  469                         mscp->opcode = UHA_SDR;
  470                         mscp->ca = 0x01;
  471                 } else {
  472                         mscp->opcode = UHA_TSP;
  473                         /* XXX Not for tapes. */
  474                         mscp->ca = 0x01;
  475                         memcpy(&mscp->scsi_cmd, xs->cmd, mscp->scsi_cmd_length);
  476                 }
  477                 mscp->xdir = UHA_SDET;
  478                 mscp->dcn = 0x00;
  479                 mscp->chan = 0x00;
  480                 mscp->target = periph->periph_target;
  481                 mscp->lun = periph->periph_lun;
  482                 mscp->scsi_cmd_length = xs->cmdlen;
  483                 mscp->sense_ptr = sc->sc_dmamap_mscp->dm_segs[0].ds_addr +
  484                     UHA_MSCP_OFF(mscp) + offsetof(struct uha_mscp, mscp_sense);
  485                 mscp->req_sense_length = sizeof(mscp->mscp_sense);
  486                 mscp->host_stat = 0x00;
  487                 mscp->target_stat = 0x00;
  488 
  489                 if (xs->datalen) {
  490                         seg = 0;
  491 #ifdef  TFS
  492                         if (flags & SCSI_DATA_UIO) {
  493                                 error = bus_dmamap_load_uio(dmat,
  494                                     mscp->dmamap_xfer, (struct uio *)xs->data,
  495                                     ((flags & XS_CTL_NOSLEEP) ? BUS_DMA_NOWAIT :
  496                                      BUS_DMA_WAITOK) | BUS_DMA_STREAMING |
  497                                      ((flags & XS_CTL_DATA_IN) ? BUS_DMA_READ :
  498                                       BUS_DMA_WRITE));
  499                         } else
  500 #endif /*TFS */
  501                         {
  502                                 error = bus_dmamap_load(dmat,
  503                                     mscp->dmamap_xfer, xs->data, xs->datalen,
  504                                     NULL,
  505                                     ((flags & XS_CTL_NOSLEEP) ? BUS_DMA_NOWAIT :
  506                                      BUS_DMA_WAITOK) | BUS_DMA_STREAMING |
  507                                      ((flags & XS_CTL_DATA_IN) ? BUS_DMA_READ :
  508                                       BUS_DMA_WRITE));
  509                         }
  510 
  511                         switch (error) {
  512                         case 0:
  513                                 break;
  514 
  515                         case ENOMEM:
  516                         case EAGAIN:
  517                                 xs->error = XS_RESOURCE_SHORTAGE;
  518                                 goto out_bad;
  519 
  520                         default:
  521                                 xs->error = XS_DRIVER_STUFFUP;
  522                                 printf("%s: error %d loading DMA map\n",
  523                                     sc->sc_dev.dv_xname, error);
  524  out_bad:
  525                                 uha_free_mscp(sc, mscp);
  526                                 scsipi_done(xs);
  527                                 return;
  528                         }
  529 
  530                         bus_dmamap_sync(dmat, mscp->dmamap_xfer, 0,
  531                             mscp->dmamap_xfer->dm_mapsize,
  532                             (flags & XS_CTL_DATA_IN) ? BUS_DMASYNC_PREREAD :
  533                             BUS_DMASYNC_PREWRITE);
  534 
  535                         /*
  536                          * Load the hardware scatter/gather map with the
  537                          * contents of the DMA map.
  538                          */
  539                         for (seg = 0;
  540                              seg < mscp->dmamap_xfer->dm_nsegs; seg++) {
  541                                 mscp->uha_dma[seg].seg_addr =
  542                                     mscp->dmamap_xfer->dm_segs[seg].ds_addr;
  543                                 mscp->uha_dma[seg].seg_len =
  544                                     mscp->dmamap_xfer->dm_segs[seg].ds_len;
  545                         }
  546 
  547                         mscp->data_addr =
  548                             sc->sc_dmamap_mscp->dm_segs[0].ds_addr +
  549                             UHA_MSCP_OFF(mscp) + offsetof(struct uha_mscp,
  550                             uha_dma);
  551                         mscp->data_length = xs->datalen;
  552                         mscp->sgth = 0x01;
  553                         mscp->sg_num = seg;
  554                 } else {                /* No data xfer, use non S/G values */
  555                         mscp->data_addr = (physaddr)0;
  556                         mscp->data_length = 0;
  557                         mscp->sgth = 0x00;
  558                         mscp->sg_num = 0;
  559                 }
  560                 mscp->link_id = 0;
  561                 mscp->link_addr = (physaddr)0;
  562 
  563                 bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_mscp,
  564                     UHA_MSCP_OFF(mscp), sizeof(struct uha_mscp),
  565                     BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
  566 
  567                 s = splbio();
  568                 (sc->start_mbox)(sc, mscp);
  569                 splx(s);
  570 
  571                 if ((flags & XS_CTL_POLL) == 0)
  572                         return;
  573 
  574                 /*
  575                  * If we can't use interrupts, poll on completion
  576                  */
  577                 if ((sc->poll)(sc, xs, mscp->timeout)) {
  578                         uha_timeout(mscp);
  579                         if ((sc->poll)(sc, xs, mscp->timeout))
  580                                 uha_timeout(mscp);
  581                 }
  582                 return;
  583 
  584         case ADAPTER_REQ_GROW_RESOURCES:
  585                 /* XXX Not supported. */
  586                 return;
  587 
  588         case ADAPTER_REQ_SET_XFER_MODE:
  589                 /*
  590                  * We can't really do this (the UltraStor controllers
  591                  * have their own config).
  592                  *
  593                  * XXX How do we query the config?
  594                  */
  595                 return;
  596         }
  597 }
  598 void
  599 uha_timeout(arg)
  600         void *arg;
  601 {
  602         struct uha_mscp *mscp = arg;
  603         struct scsipi_xfer *xs = mscp->xs;
  604         struct scsipi_periph *periph = xs->xs_periph;
  605         struct uha_softc *sc =
  606             (void *)periph->periph_channel->chan_adapter->adapt_dev;
  607         int s;
  608 
  609         scsipi_printaddr(periph);
  610         printf("timed out");
  611 
  612         s = splbio();
  613 
  614         if (mscp->flags & MSCP_ABORT) {
  615                 /* abort timed out */
  616                 printf(" AGAIN\n");
  617                 /* XXX Must reset! */
  618         } else {
  619                 /* abort the operation that has timed out */
  620                 printf("\n");
  621                 mscp->xs->error = XS_TIMEOUT;
  622                 mscp->timeout = UHA_ABORT_TIMEOUT;
  623                 mscp->flags |= MSCP_ABORT;
  624                 (sc->start_mbox)(sc, mscp);
  625         }
  626 
  627         splx(s);
  628 }

Cache object: 82fd8140fd784c0a0b13e4f8fb6fc96e


[ 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.