ld_icp.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: ld_icp.c,v 1.22.4.1 2009/02/02 20:24:38 snj 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 /*
   33  * ICP-Vortex "GDT" front-end for ld(4) driver.
   34  */
   35 
   36 #include <sys/cdefs.h>
   37 __KERNEL_RCSID(0, "$NetBSD: ld_icp.c,v 1.22.4.1 2009/02/02 20:24:38 snj Exp $");
   38 
   39 #include "rnd.h"
   40 
   41 #include <sys/param.h>
   42 #include <sys/systm.h>
   43 #include <sys/kernel.h>
   44 #include <sys/device.h>
   45 #include <sys/buf.h>
   46 #include <sys/bufq.h>
   47 #include <sys/endian.h>
   48 #include <sys/dkio.h>
   49 #include <sys/disk.h>
   50 #if NRND > 0
   51 #include <sys/rnd.h>
   52 #endif
   53 
   54 #include <uvm/uvm_extern.h>
   55 
   56 #include <sys/bus.h>
   57 
   58 #include <dev/ldvar.h>
   59 
   60 #include <dev/ic/icpreg.h>
   61 #include <dev/ic/icpvar.h>
   62 
   63 struct ld_icp_softc {
   64         struct  ld_softc sc_ld;
   65         int     sc_hwunit;
   66 };
   67 
   68 void    ld_icp_attach(device_t, device_t, void *);
   69 int     ld_icp_detach(device_t, int);
   70 int     ld_icp_dobio(struct ld_icp_softc *, void *, int, int, int,
   71                      struct buf *);
   72 int     ld_icp_dump(struct ld_softc *, void *, int, int);
   73 int     ld_icp_flush(struct ld_softc *, int);
   74 void    ld_icp_intr(struct icp_ccb *);
   75 int     ld_icp_match(device_t, cfdata_t, void *);
   76 int     ld_icp_start(struct ld_softc *, struct buf *);
   77 
   78 void    ld_icp_adjqparam(device_t, int);
   79 
   80 CFATTACH_DECL_NEW(ld_icp, sizeof(struct ld_icp_softc),
   81     ld_icp_match, ld_icp_attach, ld_icp_detach, NULL);
   82 
   83 static const struct icp_servicecb ld_icp_servicecb = {
   84         ld_icp_adjqparam,
   85 };
   86 
   87 int
   88 ld_icp_match(device_t parent, cfdata_t match, void *aux)
   89 {
   90         struct icp_attach_args *icpa;
   91 
   92         icpa = aux;
   93 
   94         return (icpa->icpa_unit < ICPA_UNIT_SCSI);
   95 }
   96 
   97 void
   98 ld_icp_attach(device_t parent, device_t self, void *aux)
   99 {
  100         struct icp_attach_args *icpa = aux;
  101         struct ld_icp_softc *sc = device_private(self);
  102         struct ld_softc *ld = &sc->sc_ld;
  103         struct icp_softc *icp = device_private(parent);
  104         struct icp_cachedrv *cd = &icp->icp_cdr[icpa->icpa_unit];
  105         struct icp_cdevinfo *cdi;
  106         const char *str;
  107         int t;
  108 
  109         ld->sc_dv = self;
  110 
  111         icp_register_servicecb(icp, icpa->icpa_unit, &ld_icp_servicecb);
  112 
  113         sc->sc_hwunit = icpa->icpa_unit;
  114         ld->sc_maxxfer = ICP_MAX_XFER;
  115         ld->sc_secsize = ICP_SECTOR_SIZE;
  116         ld->sc_start = ld_icp_start;
  117         ld->sc_dump = ld_icp_dump;
  118         ld->sc_flush = ld_icp_flush;
  119         ld->sc_secperunit = cd->cd_size;
  120         ld->sc_flags = LDF_ENABLED;
  121         ld->sc_maxqueuecnt = icp->icp_openings;
  122 
  123         if (!icp_cmd(icp, ICP_CACHESERVICE, ICP_IOCTL, ICP_CACHE_DRV_INFO,
  124             sc->sc_hwunit, sizeof(struct icp_cdevinfo))) {
  125                 aprint_error(": unable to retrieve device info\n");
  126                 ld->sc_flags = LDF_ENABLED;
  127                 goto out;
  128         }
  129         cdi = (struct icp_cdevinfo *)icp->icp_scr;
  130 
  131         aprint_normal(": <%.8s>, ", cdi->ld_name);
  132         t = le32toh(cdi->ld_dtype) >> 16;
  133 
  134         /*
  135          * Print device type.
  136          */
  137         if (le32toh(cdi->ld_dcnt) > 1 || le32toh(cdi->ld_slave) != -1)
  138                 str = "RAID-1";
  139         else if (t == 0)
  140                 str = "JBOD";
  141         else if (t == 1)
  142                 str = "RAID-0";
  143         else if (t == 2)
  144                 str = "Chain";
  145         else
  146                 str = "unknown type";
  147 
  148         aprint_normal("type: %s, ", str);
  149 
  150         /*
  151          * Print device status.
  152          */
  153         if (t > 2)
  154                 str = "missing";
  155         else if ((cdi->ld_error & 1) != 0) {
  156                 str = "fault";
  157                 ld->sc_flags = LDF_ENABLED;
  158         } else if ((cdi->ld_error & 2) != 0)
  159                 str = "invalid";
  160         else {
  161                 str = "optimal";
  162                 ld->sc_flags = LDF_ENABLED;
  163         }
  164 
  165         aprint_normal("status: %s\n", str);
  166 
  167  out:
  168         ldattach(ld);
  169 }
  170 
  171 int
  172 ld_icp_detach(device_t dv, int flags)
  173 {
  174         int rv;
  175 
  176         if ((rv = ldbegindetach((struct ld_softc *)dv, flags)) != 0)
  177                 return (rv);
  178         ldenddetach((struct ld_softc *) dv);
  179 
  180         return (0);
  181 }
  182 
  183 int
  184 ld_icp_dobio(struct ld_icp_softc *sc, void *data, int datasize, int blkno,
  185              int dowrite, struct buf *bp)
  186 {
  187         struct icp_cachecmd *cc;
  188         struct icp_ccb *ic;
  189         struct icp_softc *icp;
  190         int s, rv;
  191 
  192         icp = device_private(device_parent(sc->sc_ld.sc_dv));
  193 
  194         /*
  195          * Allocate a command control block.
  196          */
  197         if (__predict_false((ic = icp_ccb_alloc(icp)) == NULL))
  198                 return (EAGAIN);
  199 
  200         /*
  201          * Map the data transfer.
  202          */
  203         cc = &ic->ic_cmd.cmd_packet.cc;
  204         ic->ic_sg = cc->cc_sg;
  205         ic->ic_service = ICP_CACHESERVICE;
  206 
  207         rv = icp_ccb_map(icp, ic, data, datasize,
  208             dowrite ? IC_XFER_OUT : IC_XFER_IN);
  209         if (rv != 0) {
  210                 icp_ccb_free(icp, ic);
  211                 return (rv);
  212         }
  213 
  214         /*
  215          * Build the command.
  216          */
  217         ic->ic_cmd.cmd_opcode = htole16((dowrite ? ICP_WRITE : ICP_READ));
  218         cc->cc_deviceno = htole16(sc->sc_hwunit);
  219         cc->cc_blockno = htole32(blkno);
  220         cc->cc_blockcnt = htole32(datasize / ICP_SECTOR_SIZE);
  221         cc->cc_addr = ~0;       /* scatter gather */
  222         cc->cc_nsgent = htole32(ic->ic_nsgent);
  223 
  224         ic->ic_cmdlen = (u_long)ic->ic_sg - (u_long)&ic->ic_cmd +
  225             ic->ic_nsgent * sizeof(*ic->ic_sg);
  226 
  227         /*
  228          * Fire it off to the controller.
  229          */
  230         if (bp == NULL) {
  231                 s = splbio();
  232                 rv = icp_ccb_poll(icp, ic, 10000);
  233                 icp_ccb_unmap(icp, ic);
  234                 icp_ccb_free(icp, ic);
  235                 splx(s);
  236         } else {
  237                 ic->ic_intr = ld_icp_intr;
  238                 ic->ic_context = bp;
  239                 ic->ic_dv = sc->sc_ld.sc_dv;
  240                 icp_ccb_enqueue(icp, ic);
  241         }
  242 
  243         return (rv);
  244 }
  245 
  246 int
  247 ld_icp_start(struct ld_softc *ld, struct buf *bp)
  248 {
  249 
  250         return (ld_icp_dobio((struct ld_icp_softc *)ld, bp->b_data,
  251             bp->b_bcount, bp->b_rawblkno, (bp->b_flags & B_READ) == 0, bp));
  252 }
  253 
  254 int
  255 ld_icp_dump(struct ld_softc *ld, void *data, int blkno, int blkcnt)
  256 {
  257 
  258         return (ld_icp_dobio((struct ld_icp_softc *)ld, data,
  259             blkcnt * ld->sc_secsize, blkno, 1, NULL));
  260 }
  261 
  262 int
  263 ld_icp_flush(struct ld_softc *ld, int flags)
  264 {
  265         struct ld_icp_softc *sc;
  266         struct icp_softc *icp;
  267         struct icp_cachecmd *cc;
  268         struct icp_ccb *ic;
  269         int rv;
  270 
  271         sc = (struct ld_icp_softc *)ld;
  272         icp = device_private(device_parent(ld->sc_dv));
  273 
  274         ic = icp_ccb_alloc_wait(icp);
  275         ic->ic_cmd.cmd_opcode = htole16(ICP_FLUSH);
  276 
  277         cc = &ic->ic_cmd.cmd_packet.cc;
  278         cc->cc_deviceno = htole16(sc->sc_hwunit);
  279         cc->cc_blockno = htole32(1);
  280         cc->cc_blockcnt = 0;
  281         cc->cc_addr = 0;
  282         cc->cc_nsgent = 0;
  283 
  284         ic->ic_cmdlen = (u_long)&cc->cc_sg - (u_long)&ic->ic_cmd;
  285         ic->ic_service = ICP_CACHESERVICE;
  286 
  287         rv = icp_ccb_wait(icp, ic, 30000);
  288         icp_ccb_free(icp, ic);
  289 
  290         return (rv);
  291 }
  292 
  293 void
  294 ld_icp_intr(struct icp_ccb *ic)
  295 {
  296         struct buf *bp;
  297         struct ld_icp_softc *sc;
  298         struct icp_softc *icp;
  299 
  300         bp = ic->ic_context;
  301         sc = (struct ld_icp_softc *)device_private(ic->ic_dv);
  302         icp = device_private(device_parent(sc->sc_ld.sc_dv));
  303 
  304         if (ic->ic_status != ICP_S_OK) {
  305                 aprint_error_dev(ic->ic_dv, "request failed; status=0x%04x\n",
  306                     ic->ic_status);
  307                 bp->b_error = EIO;
  308                 bp->b_resid = bp->b_bcount;
  309 
  310                 icp->icp_evt.size = sizeof(icp->icp_evt.eu.sync);
  311                 icp->icp_evt.eu.sync.ionode = device_unit(&icp->icp_dv);
  312                 icp->icp_evt.eu.sync.service = icp->icp_service;
  313                 icp->icp_evt.eu.sync.status = icp->icp_status;
  314                 icp->icp_evt.eu.sync.info = icp->icp_info;
  315                 icp->icp_evt.eu.sync.hostdrive = sc->sc_hwunit;
  316                 if (icp->icp_status >= 0x8000)
  317                         icp_store_event(icp, GDT_ES_SYNC, 0, &icp->icp_evt);
  318                 else
  319                         icp_store_event(icp, GDT_ES_SYNC, icp->icp_service,
  320                             &icp->icp_evt);
  321         } else
  322                 bp->b_resid = 0;
  323 
  324         icp_ccb_unmap(icp, ic);
  325         icp_ccb_free(icp, ic);
  326         lddone(&sc->sc_ld, bp);
  327 }
  328 
  329 void
  330 ld_icp_adjqparam(device_t dv, int openings)
  331 {
  332 
  333         ldadjqparam((struct ld_softc *) dv, openings);
  334 }
Cache object: 46b2b04f644c6616bac50256ea91ed17
[ 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/ld_icp.c

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