cac.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: cac.c,v 1.37 2006/11/28 20:29:14 ad Exp $      */
    2 
    3 /*-
    4  * Copyright (c) 2000 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  * 3. All advertising materials mentioning features or use of this software
   19  *    must display the following acknowledgement:
   20  *        This product includes software developed by the NetBSD
   21  *        Foundation, Inc. and its contributors.
   22  * 4. Neither the name of The NetBSD Foundation nor the names of its
   23  *    contributors may be used to endorse or promote products derived
   24  *    from this software without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   36  * POSSIBILITY OF SUCH DAMAGE.
   37  */
   38 
   39 /*
   40  * Driver for Compaq array controllers.
   41  */
   42 
   43 #include <sys/cdefs.h>
   44 __KERNEL_RCSID(0, "$NetBSD: cac.c,v 1.37 2006/11/28 20:29:14 ad Exp $");
   45 
   46 #include <sys/param.h>
   47 #include <sys/systm.h>
   48 #include <sys/kernel.h>
   49 #include <sys/device.h>
   50 #include <sys/queue.h>
   51 #include <sys/proc.h>
   52 #include <sys/buf.h>
   53 #include <sys/endian.h>
   54 #include <sys/malloc.h>
   55 #include <sys/pool.h>
   56 
   57 #include <uvm/uvm_extern.h>
   58 
   59 #include <sys/bswap.h>
   60 #include <machine/bus.h>
   61 
   62 #include <dev/ic/cacreg.h>
   63 #include <dev/ic/cacvar.h>
   64 
   65 #include "locators.h"
   66 
   67 static struct   cac_ccb *cac_ccb_alloc(struct cac_softc *, int);
   68 static void     cac_ccb_done(struct cac_softc *, struct cac_ccb *);
   69 static void     cac_ccb_free(struct cac_softc *, struct cac_ccb *);
   70 static int      cac_ccb_poll(struct cac_softc *, struct cac_ccb *, int);
   71 static int      cac_ccb_start(struct cac_softc *, struct cac_ccb *);
   72 static int      cac_print(void *, const char *);
   73 static void     cac_shutdown(void *);
   74 
   75 static struct   cac_ccb *cac_l0_completed(struct cac_softc *);
   76 static int      cac_l0_fifo_full(struct cac_softc *);
   77 static void     cac_l0_intr_enable(struct cac_softc *, int);
   78 static int      cac_l0_intr_pending(struct cac_softc *);
   79 static void     cac_l0_submit(struct cac_softc *, struct cac_ccb *);
   80 
   81 static void     *cac_sdh;       /* shutdown hook */
   82 
   83 const struct cac_linkage cac_l0 = {
   84         cac_l0_completed,
   85         cac_l0_fifo_full,
   86         cac_l0_intr_enable,
   87         cac_l0_intr_pending,
   88         cac_l0_submit
   89 };
   90 
   91 /*
   92  * Initialise our interface to the controller.
   93  */
   94 int
   95 cac_init(struct cac_softc *sc, const char *intrstr, int startfw)
   96 {
   97         struct cac_controller_info cinfo;
   98         struct cac_attach_args caca;
   99         int error, rseg, size, i;
  100         bus_dma_segment_t seg;
  101         struct cac_ccb *ccb;
  102         int locs[CACCF_NLOCS];
  103 
  104         if (intrstr != NULL)
  105                 aprint_normal("%s: interrupting at %s\n", sc->sc_dv.dv_xname,
  106                     intrstr);
  107 
  108         SIMPLEQ_INIT(&sc->sc_ccb_free);
  109         SIMPLEQ_INIT(&sc->sc_ccb_queue);
  110 
  111         size = sizeof(struct cac_ccb) * CAC_MAX_CCBS;
  112 
  113         if ((error = bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &seg, 1,
  114             &rseg, BUS_DMA_NOWAIT)) != 0) {
  115                 aprint_error("%s: unable to allocate CCBs, error = %d\n",
  116                     sc->sc_dv.dv_xname, error);
  117                 return (-1);
  118         }
  119 
  120         if ((error = bus_dmamem_map(sc->sc_dmat, &seg, rseg, size,
  121             (caddr_t *)&sc->sc_ccbs,
  122             BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) {
  123                 aprint_error("%s: unable to map CCBs, error = %d\n",
  124                     sc->sc_dv.dv_xname, error);
  125                 return (-1);
  126         }
  127 
  128         if ((error = bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
  129             BUS_DMA_NOWAIT, &sc->sc_dmamap)) != 0) {
  130                 aprint_error("%s: unable to create CCB DMA map, error = %d\n",
  131                     sc->sc_dv.dv_xname, error);
  132                 return (-1);
  133         }
  134 
  135         if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_dmamap, sc->sc_ccbs,
  136             size, NULL, BUS_DMA_NOWAIT)) != 0) {
  137                 aprint_error("%s: unable to load CCB DMA map, error = %d\n",
  138                     sc->sc_dv.dv_xname, error);
  139                 return (-1);
  140         }
  141 
  142         sc->sc_ccbs_paddr = sc->sc_dmamap->dm_segs[0].ds_addr;
  143         memset(sc->sc_ccbs, 0, size);
  144         ccb = (struct cac_ccb *)sc->sc_ccbs;
  145 
  146         for (i = 0; i < CAC_MAX_CCBS; i++, ccb++) {
  147                 /* Create the DMA map for this CCB's data */
  148                 error = bus_dmamap_create(sc->sc_dmat, CAC_MAX_XFER,
  149                     CAC_SG_SIZE, CAC_MAX_XFER, 0,
  150                     BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
  151                     &ccb->ccb_dmamap_xfer);
  152 
  153                 if (error) {
  154                         aprint_error("%s: can't create ccb dmamap (%d)\n",
  155                             sc->sc_dv.dv_xname, error);
  156                         break;
  157                 }
  158 
  159                 ccb->ccb_flags = 0;
  160                 ccb->ccb_paddr = sc->sc_ccbs_paddr + i * sizeof(struct cac_ccb);
  161                 SIMPLEQ_INSERT_TAIL(&sc->sc_ccb_free, ccb, ccb_chain);
  162         }
  163 
  164         /* Start firmware background tasks, if needed. */
  165         if (startfw) {
  166                 if (cac_cmd(sc, CAC_CMD_START_FIRMWARE, &cinfo, sizeof(cinfo),
  167                     0, 0, CAC_CCB_DATA_IN, NULL)) {
  168                         aprint_error("%s: CAC_CMD_START_FIRMWARE failed\n",
  169                             sc->sc_dv.dv_xname);
  170                         return (-1);
  171                 }
  172         }
  173 
  174         if (cac_cmd(sc, CAC_CMD_GET_CTRL_INFO, &cinfo, sizeof(cinfo), 0, 0,
  175             CAC_CCB_DATA_IN, NULL)) {
  176                 aprint_error("%s: CAC_CMD_GET_CTRL_INFO failed\n",
  177                     sc->sc_dv.dv_xname);
  178                 return (-1);
  179         }
  180 
  181         sc->sc_nunits = cinfo.num_drvs;
  182         for (i = 0; i < cinfo.num_drvs; i++) {
  183                 caca.caca_unit = i;
  184 
  185                 locs[CACCF_UNIT] = i;
  186 
  187                 config_found_sm_loc(&sc->sc_dv, "cac", locs, &caca,
  188                                     cac_print, config_stdsubmatch);
  189         }
  190 
  191         /* Set our `shutdownhook' before we start any device activity. */
  192         if (cac_sdh == NULL)
  193                 cac_sdh = shutdownhook_establish(cac_shutdown, NULL);
  194 
  195         (*sc->sc_cl.cl_intr_enable)(sc, CAC_INTR_ENABLE);
  196         return (0);
  197 }
  198 
  199 /*
  200  * Shut down all `cac' controllers.
  201  */
  202 static void
  203 cac_shutdown(void *cookie)
  204 {
  205         extern struct cfdriver cac_cd;
  206         struct cac_softc *sc;
  207         u_int8_t tbuf[512];
  208         int i;
  209 
  210         for (i = 0; i < cac_cd.cd_ndevs; i++) {
  211                 if ((sc = device_lookup(&cac_cd, i)) == NULL)
  212                         continue;
  213                 memset(tbuf, 0, sizeof(tbuf));
  214                 tbuf[0] = 1;
  215                 cac_cmd(sc, CAC_CMD_FLUSH_CACHE, tbuf, sizeof(tbuf), 0, 0,
  216                     CAC_CCB_DATA_OUT, NULL);
  217         }
  218 }
  219 
  220 /*
  221  * Print autoconfiguration message for a sub-device.
  222  */
  223 static int
  224 cac_print(void *aux, const char *pnp)
  225 {
  226         struct cac_attach_args *caca;
  227 
  228         caca = (struct cac_attach_args *)aux;
  229 
  230         if (pnp != NULL)
  231                 aprint_normal("block device at %s", pnp);
  232         aprint_normal(" unit %d", caca->caca_unit);
  233         return (UNCONF);
  234 }
  235 
  236 /*
  237  * Handle an interrupt from the controller: process finished CCBs and
  238  * dequeue any waiting CCBs.
  239  */
  240 int
  241 cac_intr(void *cookie)
  242 {
  243         struct cac_softc *sc;
  244         struct cac_ccb *ccb;
  245 
  246         sc = (struct cac_softc *)cookie;
  247 
  248         if (!(*sc->sc_cl.cl_intr_pending)(sc)) {
  249 #ifdef DEBUG
  250                 printf("%s: spurious intr\n", sc->sc_dv.dv_xname);
  251 #endif
  252                 return (0);
  253         }
  254 
  255         while ((ccb = (*sc->sc_cl.cl_completed)(sc)) != NULL) {
  256                 cac_ccb_done(sc, ccb);
  257                 cac_ccb_start(sc, NULL);
  258         }
  259 
  260         return (1);
  261 }
  262 
  263 /*
  264  * Execute a [polled] command.
  265  */
  266 int
  267 cac_cmd(struct cac_softc *sc, int command, void *data, int datasize,
  268         int drive, int blkno, int flags, struct cac_context *context)
  269 {
  270         struct cac_ccb *ccb;
  271         struct cac_sgb *sgb;
  272         int s, i, rv, size, nsegs;
  273 
  274         size = 0;
  275 
  276         if ((ccb = cac_ccb_alloc(sc, 1)) == NULL) {
  277                 printf("%s: unable to alloc CCB", sc->sc_dv.dv_xname);
  278                 return (EAGAIN);
  279         }
  280 
  281         if ((flags & (CAC_CCB_DATA_IN | CAC_CCB_DATA_OUT)) != 0) {
  282                 bus_dmamap_load(sc->sc_dmat, ccb->ccb_dmamap_xfer,
  283                     (void *)data, datasize, NULL, BUS_DMA_NOWAIT |
  284                     BUS_DMA_STREAMING | ((flags & CAC_CCB_DATA_IN) ?
  285                     BUS_DMA_READ : BUS_DMA_WRITE));
  286 
  287                 bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap_xfer, 0, datasize,
  288                     (flags & CAC_CCB_DATA_IN) != 0 ? BUS_DMASYNC_PREREAD :
  289                     BUS_DMASYNC_PREWRITE);
  290 
  291                 sgb = ccb->ccb_seg;
  292                 nsegs = min(ccb->ccb_dmamap_xfer->dm_nsegs, CAC_SG_SIZE);
  293 
  294                 for (i = 0; i < nsegs; i++, sgb++) {
  295                         size += ccb->ccb_dmamap_xfer->dm_segs[i].ds_len;
  296                         sgb->length =
  297                             htole32(ccb->ccb_dmamap_xfer->dm_segs[i].ds_len);
  298                         sgb->addr =
  299                             htole32(ccb->ccb_dmamap_xfer->dm_segs[i].ds_addr);
  300                 }
  301         } else {
  302                 size = datasize;
  303                 nsegs = 0;
  304         }
  305 
  306         ccb->ccb_hdr.drive = drive;
  307         ccb->ccb_hdr.priority = 0;
  308         ccb->ccb_hdr.size = htole16((sizeof(struct cac_req) +
  309             sizeof(struct cac_sgb) * CAC_SG_SIZE) >> 2);
  310 
  311         ccb->ccb_req.next = 0;
  312         ccb->ccb_req.error = 0;
  313         ccb->ccb_req.reserved = 0;
  314         ccb->ccb_req.bcount = htole16(howmany(size, DEV_BSIZE));
  315         ccb->ccb_req.command = command;
  316         ccb->ccb_req.sgcount = nsegs;
  317         ccb->ccb_req.blkno = htole32(blkno);
  318 
  319         ccb->ccb_flags = flags;
  320         ccb->ccb_datasize = size;
  321 
  322         if (context == NULL) {
  323                 memset(&ccb->ccb_context, 0, sizeof(struct cac_context));
  324                 s = splbio();
  325 
  326                 /* Synchronous commands musn't wait. */
  327                 if ((*sc->sc_cl.cl_fifo_full)(sc)) {
  328                         cac_ccb_free(sc, ccb);
  329                         rv = EAGAIN;
  330                 } else {
  331 #ifdef DIAGNOSTIC
  332                         ccb->ccb_flags |= CAC_CCB_ACTIVE;
  333 #endif
  334                         (*sc->sc_cl.cl_submit)(sc, ccb);
  335                         rv = cac_ccb_poll(sc, ccb, 2000);
  336                         cac_ccb_free(sc, ccb);
  337                 }
  338         } else {
  339                 memcpy(&ccb->ccb_context, context, sizeof(struct cac_context));
  340                 s = splbio();
  341                 (void)cac_ccb_start(sc, ccb);
  342                 rv = 0;
  343         }
  344 
  345         splx(s);
  346         return (rv);
  347 }
  348 
  349 /*
  350  * Wait for the specified CCB to complete.  Must be called at splbio.
  351  */
  352 static int
  353 cac_ccb_poll(struct cac_softc *sc, struct cac_ccb *wantccb, int timo)
  354 {
  355         struct cac_ccb *ccb;
  356 
  357         timo *= 10;
  358 
  359         do {
  360                 for (; timo != 0; timo--) {
  361                         ccb = (*sc->sc_cl.cl_completed)(sc);
  362                         if (ccb != NULL)
  363                                 break;
  364                         DELAY(100);
  365                 }
  366 
  367                 if (timo == 0) {
  368                         printf("%s: timeout\n", sc->sc_dv.dv_xname);
  369                         return (EBUSY);
  370                 }
  371                 cac_ccb_done(sc, ccb);
  372         } while (ccb != wantccb);
  373 
  374         return (0);
  375 }
  376 
  377 /*
  378  * Enqueue the specified command (if any) and attempt to start all enqueued
  379  * commands.  Must be called at splbio.
  380  */
  381 static int
  382 cac_ccb_start(struct cac_softc *sc, struct cac_ccb *ccb)
  383 {
  384 
  385         if (ccb != NULL)
  386                 SIMPLEQ_INSERT_TAIL(&sc->sc_ccb_queue, ccb, ccb_chain);
  387 
  388         while ((ccb = SIMPLEQ_FIRST(&sc->sc_ccb_queue)) != NULL) {
  389                 if ((*sc->sc_cl.cl_fifo_full)(sc))
  390                         return (EAGAIN);
  391                 SIMPLEQ_REMOVE_HEAD(&sc->sc_ccb_queue, ccb_chain);
  392 #ifdef DIAGNOSTIC
  393                 ccb->ccb_flags |= CAC_CCB_ACTIVE;
  394 #endif
  395                 (*sc->sc_cl.cl_submit)(sc, ccb);
  396         }
  397 
  398         return (0);
  399 }
  400 
  401 /*
  402  * Process a finished CCB.
  403  */
  404 static void
  405 cac_ccb_done(struct cac_softc *sc, struct cac_ccb *ccb)
  406 {
  407         struct device *dv;
  408         void *context;
  409         int error;
  410 
  411         error = 0;
  412 
  413 #ifdef DIAGNOSTIC
  414         if ((ccb->ccb_flags & CAC_CCB_ACTIVE) == 0)
  415                 panic("cac_ccb_done: CCB not active");
  416         ccb->ccb_flags &= ~CAC_CCB_ACTIVE;
  417 #endif
  418 
  419         if ((ccb->ccb_flags & (CAC_CCB_DATA_IN | CAC_CCB_DATA_OUT)) != 0) {
  420                 bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmamap_xfer, 0,
  421                     ccb->ccb_datasize, ccb->ccb_flags & CAC_CCB_DATA_IN ?
  422                     BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
  423                 bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmamap_xfer);
  424         }
  425 
  426         error = ccb->ccb_req.error;
  427         if (ccb->ccb_context.cc_handler != NULL) {
  428                 dv = ccb->ccb_context.cc_dv;
  429                 context = ccb->ccb_context.cc_context;
  430                 cac_ccb_free(sc, ccb);
  431                 (*ccb->ccb_context.cc_handler)(dv, context, error);
  432         } else {
  433                 if ((error & CAC_RET_SOFT_ERROR) != 0)
  434                         printf("%s: soft error; array may be degraded\n",
  435                             sc->sc_dv.dv_xname);
  436                 if ((error & CAC_RET_HARD_ERROR) != 0)
  437                         printf("%s: hard error\n", sc->sc_dv.dv_xname);
  438                 if ((error & CAC_RET_CMD_REJECTED) != 0) {
  439                         error = 1;
  440                         printf("%s: invalid request\n", sc->sc_dv.dv_xname);
  441                 }
  442         }
  443 }
  444 
  445 /*
  446  * Allocate a CCB.
  447  */
  448 static struct cac_ccb *
  449 cac_ccb_alloc(struct cac_softc *sc, int nosleep)
  450 {
  451         struct cac_ccb *ccb;
  452         int s;
  453 
  454         s = splbio();
  455 
  456         for (;;) {
  457                 if ((ccb = SIMPLEQ_FIRST(&sc->sc_ccb_free)) != NULL) {
  458                         SIMPLEQ_REMOVE_HEAD(&sc->sc_ccb_free, ccb_chain);
  459                         break;
  460                 }
  461                 if (nosleep) {
  462                         ccb = NULL;
  463                         break;
  464                 }
  465                 tsleep(&sc->sc_ccb_free, PRIBIO, "cacccb", 0);
  466         }
  467 
  468         splx(s);
  469         return (ccb);
  470 }
  471 
  472 /*
  473  * Put a CCB onto the freelist.
  474  */
  475 static void
  476 cac_ccb_free(struct cac_softc *sc, struct cac_ccb *ccb)
  477 {
  478         int s;
  479 
  480         ccb->ccb_flags = 0;
  481         s = splbio();
  482         SIMPLEQ_INSERT_HEAD(&sc->sc_ccb_free, ccb, ccb_chain);
  483         if (SIMPLEQ_NEXT(ccb, ccb_chain) == NULL)
  484                 wakeup_one(&sc->sc_ccb_free);
  485         splx(s);
  486 }
  487 
  488 /*
  489  * Board specific linkage shared between multiple bus types.
  490  */
  491 
  492 static int
  493 cac_l0_fifo_full(struct cac_softc *sc)
  494 {
  495 
  496         return (cac_inl(sc, CAC_REG_CMD_FIFO) == 0);
  497 }
  498 
  499 static void
  500 cac_l0_submit(struct cac_softc *sc, struct cac_ccb *ccb)
  501 {
  502 
  503         bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap, (caddr_t)ccb - sc->sc_ccbs,
  504             sizeof(struct cac_ccb), BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
  505         cac_outl(sc, CAC_REG_CMD_FIFO, ccb->ccb_paddr);
  506 }
  507 
  508 static struct cac_ccb *
  509 cac_l0_completed(struct cac_softc *sc)
  510 {
  511         struct cac_ccb *ccb;
  512         paddr_t off;
  513 
  514         if ((off = cac_inl(sc, CAC_REG_DONE_FIFO)) == 0)
  515                 return (NULL);
  516 
  517         if ((off & 3) != 0)
  518                 printf("%s: failed command list returned: %lx\n",
  519                     sc->sc_dv.dv_xname, (long)off);
  520 
  521         off = (off & ~3) - sc->sc_ccbs_paddr;
  522         ccb = (struct cac_ccb *)(sc->sc_ccbs + off);
  523 
  524         bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap, off, sizeof(struct cac_ccb),
  525             BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
  526 
  527         if ((off & 3) != 0 && ccb->ccb_req.error == 0)
  528                 ccb->ccb_req.error = CAC_RET_CMD_REJECTED;
  529 
  530         return (ccb);
  531 }
  532 
  533 static int
  534 cac_l0_intr_pending(struct cac_softc *sc)
  535 {
  536 
  537         return (cac_inl(sc, CAC_REG_INTR_PENDING) & CAC_INTR_ENABLE);
  538 }
  539 
  540 static void
  541 cac_l0_intr_enable(struct cac_softc *sc, int state)
  542 {
  543 
  544         cac_outl(sc, CAC_REG_INTR_MASK,
  545             state ? CAC_INTR_ENABLE : CAC_INTR_DISABLE);
  546 }
Cache object: 444340f237756b3419afde3db167a6af
[ 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/cac.c

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