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/firewire/fwohci_pci.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 /*-
    2  * Copyright (c) 2003 Hidetoshi Shimokawa
    3  * Copyright (c) 1998-2002 Katsushi Kobayashi and Hidetoshi Shimokawa
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  * 3. All advertising materials mentioning features or use of this software
   15  *    must display the acknowledgement as bellow:
   16  *
   17  *    This product includes software developed by K. Kobayashi and H. SHimokawa
   18  *
   19  * 4. The name of the author may not be used to endorse or promote products
   20  *    derived from this software without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   24  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   25  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
   26  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   27  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   28  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   30  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   31  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   32  * POSSIBILITY OF SUCH DAMAGE.
   33  * 
   34  * $FreeBSD$
   35  */
   36 
   37 #define BOUNCE_BUFFER_TEST      0
   38 
   39 #include <sys/param.h>
   40 #include <sys/systm.h>
   41 #include <sys/kernel.h>
   42 #include <sys/module.h>
   43 #include <sys/bus.h>
   44 #include <sys/queue.h>
   45 #include <machine/bus.h>
   46 #include <sys/rman.h>
   47 #include <sys/malloc.h>
   48 #if defined(__FreeBSD__) && __FreeBSD_version >= 501102
   49 #include <sys/lock.h>
   50 #include <sys/mutex.h>
   51 #endif
   52 #include <machine/resource.h>
   53 
   54 #if defined(__DragonFly__) || __FreeBSD_version < 500000
   55 #include <machine/clock.h>              /* for DELAY() */
   56 #endif
   57 
   58 #ifdef __DragonFly__
   59 #include <bus/pci/pcivar.h>
   60 #include <bus/pci/pcireg.h>
   61 
   62 #include "firewire.h"
   63 #include "firewirereg.h"
   64 
   65 #include "fwdma.h"
   66 #include "fwohcireg.h"
   67 #include "fwohcivar.h"
   68 #else
   69 #if __FreeBSD_version < 500000
   70 #include <pci/pcivar.h>
   71 #include <pci/pcireg.h>
   72 #else
   73 #include <dev/pci/pcivar.h>
   74 #include <dev/pci/pcireg.h>
   75 #endif
   76 
   77 #include <dev/firewire/firewire.h>
   78 #include <dev/firewire/firewirereg.h>
   79 
   80 #include <dev/firewire/fwdma.h>
   81 #include <dev/firewire/fwohcireg.h>
   82 #include <dev/firewire/fwohcivar.h>
   83 #endif
   84 
   85 static int fwohci_pci_attach(device_t self);
   86 static int fwohci_pci_detach(device_t self);
   87 
   88 /*
   89  * The probe routine.
   90  */
   91 static int
   92 fwohci_pci_probe( device_t dev )
   93 {
   94 #if 1
   95         uint32_t id;
   96 
   97         id = pci_get_devid(dev);
   98         if (id == (FW_VENDORID_NATSEMI | FW_DEVICE_CS4210)) {
   99                 device_set_desc(dev, "National Semiconductor CS4210");
  100                 return BUS_PROBE_DEFAULT;
  101         }
  102         if (id == (FW_VENDORID_NEC | FW_DEVICE_UPD861)) {
  103                 device_set_desc(dev, "NEC uPD72861");
  104                 return BUS_PROBE_DEFAULT;
  105         }
  106         if (id == (FW_VENDORID_NEC | FW_DEVICE_UPD871)) {
  107                 device_set_desc(dev, "NEC uPD72871/2");
  108                 return BUS_PROBE_DEFAULT;
  109         }
  110         if (id == (FW_VENDORID_NEC | FW_DEVICE_UPD72870)) {
  111                 device_set_desc(dev, "NEC uPD72870");
  112                 return BUS_PROBE_DEFAULT;
  113         }
  114         if (id == (FW_VENDORID_NEC | FW_DEVICE_UPD72873)) {
  115                 device_set_desc(dev, "NEC uPD72873");
  116                 return BUS_PROBE_DEFAULT;
  117         }
  118         if (id == (FW_VENDORID_NEC | FW_DEVICE_UPD72874)) {
  119                 device_set_desc(dev, "NEC uPD72874");
  120                 return BUS_PROBE_DEFAULT;
  121         }
  122         if (id == (FW_VENDORID_SIS | FW_DEVICE_7007)) {
  123                 /* It has no real identifier, using device id. */
  124                 device_set_desc(dev, "SiS 7007");
  125                 return BUS_PROBE_DEFAULT;
  126         }
  127         if (id == (FW_VENDORID_TI | FW_DEVICE_TITSB22)) {
  128                 device_set_desc(dev, "Texas Instruments TSB12LV22");
  129                 return BUS_PROBE_DEFAULT;
  130         }
  131         if (id == (FW_VENDORID_TI | FW_DEVICE_TITSB23)) {
  132                 device_set_desc(dev, "Texas Instruments TSB12LV23");
  133                 return BUS_PROBE_DEFAULT;
  134         }
  135         if (id == (FW_VENDORID_TI | FW_DEVICE_TITSB26)) {
  136                 device_set_desc(dev, "Texas Instruments TSB12LV26");
  137                 return BUS_PROBE_DEFAULT;
  138         }
  139         if (id == (FW_VENDORID_TI | FW_DEVICE_TITSB43)) {
  140                 device_set_desc(dev, "Texas Instruments TSB43AA22");
  141                 return BUS_PROBE_DEFAULT;
  142         }
  143         if (id == (FW_VENDORID_TI | FW_DEVICE_TITSB43A)) {
  144                 device_set_desc(dev, "Texas Instruments TSB43AB22/A");
  145                 return BUS_PROBE_DEFAULT;
  146         }
  147         if (id == (FW_VENDORID_TI | FW_DEVICE_TITSB43AB21)) {
  148                 device_set_desc(dev, "Texas Instruments TSB43AB21/A/AI/A-EP");
  149                 return BUS_PROBE_DEFAULT;
  150         }
  151         if (id == (FW_VENDORID_TI | FW_DEVICE_TITSB43AB23)) {
  152                 device_set_desc(dev, "Texas Instruments TSB43AB23");
  153                 return BUS_PROBE_DEFAULT;
  154         }
  155         if (id == (FW_VENDORID_TI | FW_DEVICE_TITSB82AA2)) {
  156                 device_set_desc(dev, "Texas Instruments TSB82AA2");
  157                 return BUS_PROBE_DEFAULT;
  158         }
  159         if (id == (FW_VENDORID_TI | FW_DEVICE_TIPCI4450)) {
  160                 device_set_desc(dev, "Texas Instruments PCI4450");
  161                 return BUS_PROBE_DEFAULT;
  162         }
  163         if (id == (FW_VENDORID_TI | FW_DEVICE_TIPCI4410A)) {
  164                 device_set_desc(dev, "Texas Instruments PCI4410A");
  165                 return BUS_PROBE_DEFAULT;
  166         }
  167         if (id == (FW_VENDORID_TI | FW_DEVICE_TIPCI4451)) {
  168                 device_set_desc(dev, "Texas Instruments PCI4451");
  169                 return BUS_PROBE_DEFAULT;
  170         }
  171         if (id == (FW_VENDORID_SONY | FW_DEVICE_CXD1947)) {
  172                 device_set_desc(dev, "Sony i.LINK (CXD1947)");
  173                 return BUS_PROBE_DEFAULT;
  174         }
  175         if (id == (FW_VENDORID_SONY | FW_DEVICE_CXD3222)) {
  176                 device_set_desc(dev, "Sony i.LINK (CXD3222)");
  177                 return BUS_PROBE_DEFAULT;
  178         }
  179         if (id == (FW_VENDORID_VIA | FW_DEVICE_VT6306)) {
  180                 device_set_desc(dev, "VIA Fire II (VT6306)");
  181                 return BUS_PROBE_DEFAULT;
  182         }
  183         if (id == (FW_VENDORID_RICOH | FW_DEVICE_R5C551)) {
  184                 device_set_desc(dev, "Ricoh R5C551");
  185                 return BUS_PROBE_DEFAULT;
  186         }
  187         if (id == (FW_VENDORID_RICOH | FW_DEVICE_R5C552)) {
  188                 device_set_desc(dev, "Ricoh R5C552");
  189                 return BUS_PROBE_DEFAULT;
  190         }
  191         if (id == (FW_VENDORID_APPLE | FW_DEVICE_PANGEA)) {
  192                 device_set_desc(dev, "Apple Pangea");
  193                 return BUS_PROBE_DEFAULT;
  194         }
  195         if (id == (FW_VENDORID_APPLE | FW_DEVICE_UNINORTH)) {
  196                 device_set_desc(dev, "Apple UniNorth");
  197                 return BUS_PROBE_DEFAULT;
  198         }
  199         if (id == (FW_VENDORID_LUCENT | FW_DEVICE_FW322)) {
  200                 device_set_desc(dev, "Lucent FW322/323");
  201                 return BUS_PROBE_DEFAULT;
  202         }
  203         if (id == (FW_VENDORID_INTEL | FW_DEVICE_82372FB)) {
  204                 device_set_desc(dev, "Intel 82372FB");
  205                 return BUS_PROBE_DEFAULT;
  206         }
  207         if (id == (FW_VENDORID_ADAPTEC | FW_DEVICE_AIC5800)) {
  208                 device_set_desc(dev, "Adaptec AHA-894x/AIC-5800");
  209                 return BUS_PROBE_DEFAULT;
  210         }
  211         if (id == (FW_VENDORID_SUN | FW_DEVICE_PCIO2FW)) {
  212                 device_set_desc(dev, "Sun PCIO-2");
  213                 return BUS_PROBE_DEFAULT;
  214         }
  215 #endif
  216         if (pci_get_class(dev) == PCIC_SERIALBUS
  217                         && pci_get_subclass(dev) == PCIS_SERIALBUS_FW
  218                         && pci_get_progif(dev) == PCI_INTERFACE_OHCI) {
  219                 if (bootverbose)
  220                         device_printf(dev, "vendor=%x, dev=%x\n",
  221                             pci_get_vendor(dev), pci_get_device(dev));
  222                 device_set_desc(dev, "1394 Open Host Controller Interface");
  223                 return BUS_PROBE_DEFAULT;
  224         }
  225 
  226         return ENXIO;
  227 }
  228 
  229 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  230 static void
  231 fwohci_dummy_intr(void *arg)
  232 {
  233         /* XXX do nothing */
  234 }
  235 #endif
  236 
  237 static int
  238 fwohci_pci_init(device_t self)
  239 {
  240         int olatency, latency, ocache_line, cache_line;
  241         uint16_t cmd;
  242 
  243         cmd = pci_read_config(self, PCIR_COMMAND, 2);
  244         cmd |= PCIM_CMD_MEMEN | PCIM_CMD_BUSMASTEREN | PCIM_CMD_MWRICEN;
  245 #if 1  /* for broken hardware */
  246         cmd &= ~PCIM_CMD_MWRICEN; 
  247 #endif
  248         pci_write_config(self, PCIR_COMMAND, cmd, 2);
  249 
  250         /*
  251          * Some Sun PCIO-2 FireWire controllers have their intpin register
  252          * bogusly set to 0, although it should be 3. Correct that.
  253          */
  254         if (pci_get_devid(self) == (FW_VENDORID_SUN | FW_DEVICE_PCIO2FW) &&
  255             pci_get_intpin(self) == 0)
  256                 pci_set_intpin(self, 3);
  257 
  258         latency = olatency = pci_read_config(self, PCIR_LATTIMER, 1);
  259 #define DEF_LATENCY 0x20
  260         if (olatency < DEF_LATENCY) {
  261                 latency = DEF_LATENCY;
  262                 pci_write_config(self, PCIR_LATTIMER, latency, 1);
  263         }
  264 
  265         cache_line = ocache_line = pci_read_config(self, PCIR_CACHELNSZ, 1);
  266 #define DEF_CACHE_LINE 8
  267         if (ocache_line < DEF_CACHE_LINE) {
  268                 cache_line = DEF_CACHE_LINE;
  269                 pci_write_config(self, PCIR_CACHELNSZ, cache_line, 1);
  270         }
  271 
  272         if (firewire_debug) {
  273                 device_printf(self, "latency timer %d -> %d.\n",
  274                         olatency, latency);
  275                 device_printf(self, "cache size %d -> %d.\n",
  276                         ocache_line, cache_line);
  277         }
  278 
  279         return 0;
  280 }
  281 
  282 static int
  283 fwohci_pci_attach(device_t self)
  284 {
  285         fwohci_softc_t *sc = device_get_softc(self);
  286         int err;
  287         int rid;
  288 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  289         int intr;
  290         /* For the moment, put in a message stating what is wrong */
  291         intr = pci_read_config(self, PCIR_INTLINE, 1);
  292         if (intr == 0 || intr == 255) {
  293                 device_printf(self, "Invalid irq %d\n", intr);
  294 #ifdef __i386__
  295                 device_printf(self, "Please switch PNP-OS to 'No' in BIOS\n");
  296 #endif
  297         }
  298 #endif
  299 
  300 #if 0
  301         if (bootverbose)
  302                 firewire_debug = bootverbose;
  303 #endif
  304 
  305         fwohci_pci_init(self);
  306 
  307         rid = PCI_CBMEM;
  308 #if __FreeBSD_version >= 502109
  309         sc->bsr = bus_alloc_resource_any(self, SYS_RES_MEMORY, &rid, RF_ACTIVE);
  310 #else
  311         sc->bsr = bus_alloc_resource(self, SYS_RES_MEMORY, &rid,
  312             0, ~0, 1, RF_ACTIVE);
  313 #endif
  314         if (!sc->bsr) {
  315                 device_printf(self, "Could not map memory\n");
  316                 return ENXIO;
  317         }
  318 
  319         sc->bst = rman_get_bustag(sc->bsr);
  320         sc->bsh = rman_get_bushandle(sc->bsr);
  321 
  322         rid = 0;
  323 #if __FreeBSD_version >= 502109
  324         sc->irq_res = bus_alloc_resource_any(self, SYS_RES_IRQ, &rid,
  325                                      RF_SHAREABLE | RF_ACTIVE);
  326 #else
  327         sc->irq_res = bus_alloc_resource(self, SYS_RES_IRQ, &rid, 0, ~0, 1,
  328                                      RF_SHAREABLE | RF_ACTIVE);
  329 #endif
  330         if (sc->irq_res == NULL) {
  331                 device_printf(self, "Could not allocate irq\n");
  332                 fwohci_pci_detach(self);
  333                 return ENXIO;
  334         }
  335 
  336 
  337         err = bus_setup_intr(self, sc->irq_res,
  338 #if FWOHCI_TASKQUEUE
  339                         INTR_TYPE_NET | INTR_MPSAFE,
  340 #else
  341                         INTR_TYPE_NET,
  342 #endif
  343                      (driver_intr_t *) fwohci_intr, sc, &sc->ih);
  344 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  345         /* XXX splcam() should mask this irq for sbp.c*/
  346         err = bus_setup_intr(self, sc->irq_res, INTR_TYPE_CAM,
  347                      (driver_intr_t *) fwohci_dummy_intr, sc, &sc->ih_cam);
  348         /* XXX splbio() should mask this irq for physio()/fwmem_strategy() */
  349         err = bus_setup_intr(self, sc->irq_res, INTR_TYPE_BIO,
  350                      (driver_intr_t *) fwohci_dummy_intr, sc, &sc->ih_bio);
  351 #endif
  352         if (err) {
  353                 device_printf(self, "Could not setup irq, %d\n", err);
  354                 fwohci_pci_detach(self);
  355                 return ENXIO;
  356         }
  357 
  358         err = bus_dma_tag_create(/*parent*/NULL, /*alignment*/1,
  359                                 /*boundary*/0,
  360 #if BOUNCE_BUFFER_TEST
  361                                 /*lowaddr*/BUS_SPACE_MAXADDR_24BIT,
  362 #else
  363                                 /*lowaddr*/BUS_SPACE_MAXADDR_32BIT,
  364 #endif
  365                                 /*highaddr*/BUS_SPACE_MAXADDR,
  366                                 /*filter*/NULL, /*filterarg*/NULL,
  367                                 /*maxsize*/0x100000,
  368                                 /*nsegments*/0x20,
  369                                 /*maxsegsz*/0x8000,
  370                                 /*flags*/BUS_DMA_ALLOCNOW,
  371 #if defined(__FreeBSD__) && __FreeBSD_version >= 501102
  372                                 /*lockfunc*/busdma_lock_mutex,
  373                                 /*lockarg*/&Giant,
  374 #endif
  375                                 &sc->fc.dmat);
  376         if (err != 0) {
  377                 printf("fwohci_pci_attach: Could not allocate DMA tag "
  378                         "- error %d\n", err);
  379                         return (ENOMEM);
  380         }
  381 
  382         err = fwohci_init(sc, self);
  383 
  384         if (err) {
  385                 device_printf(self, "fwohci_init failed with err=%d\n", err);
  386                 fwohci_pci_detach(self);
  387                 return EIO;
  388         }
  389 
  390         /* probe and attach a child device(firewire) */
  391         bus_generic_probe(self);
  392         bus_generic_attach(self);
  393 
  394         return 0;
  395 }
  396 
  397 static int
  398 fwohci_pci_detach(device_t self)
  399 {
  400         fwohci_softc_t *sc = device_get_softc(self);
  401         int s;
  402 
  403 
  404         s = splfw();
  405 
  406         if (sc->bsr)
  407                 fwohci_stop(sc, self);
  408 
  409         bus_generic_detach(self);
  410         if (sc->fc.bdev) {
  411                 device_delete_child(self, sc->fc.bdev);
  412                 sc->fc.bdev = NULL;
  413         }
  414 
  415         /* disable interrupts that might have been switched on */
  416         if (sc->bst && sc->bsh)
  417                 bus_space_write_4(sc->bst, sc->bsh,
  418                                   FWOHCI_INTMASKCLR, OHCI_INT_EN);
  419 
  420         if (sc->irq_res) {
  421                 int err;
  422                 if (sc->ih) {
  423                         err = bus_teardown_intr(self, sc->irq_res, sc->ih);
  424                         if (err)
  425                                 device_printf(self,
  426                                          "Could not tear down irq, %d\n", err);
  427 #if defined(__DragonFly__) || __FreeBSD_version < 500000
  428                         bus_teardown_intr(self, sc->irq_res, sc->ih_cam);
  429                         bus_teardown_intr(self, sc->irq_res, sc->ih_bio);
  430 #endif
  431                         sc->ih = NULL;
  432                 }
  433                 bus_release_resource(self, SYS_RES_IRQ, 0, sc->irq_res);
  434                 sc->irq_res = NULL;
  435         }
  436 
  437         if (sc->bsr) {
  438                 bus_release_resource(self, SYS_RES_MEMORY,PCI_CBMEM,sc->bsr);
  439                 sc->bsr = NULL;
  440                 sc->bst = 0;
  441                 sc->bsh = 0;
  442         }
  443 
  444         fwohci_detach(sc, self);
  445         splx(s);
  446 
  447         return 0;
  448 }
  449 
  450 static int
  451 fwohci_pci_suspend(device_t dev)
  452 {
  453         fwohci_softc_t *sc = device_get_softc(dev);
  454         int err;
  455 
  456         device_printf(dev, "fwohci_pci_suspend\n");
  457         err = bus_generic_suspend(dev);
  458         if (err)
  459                 return err;
  460         fwohci_stop(sc, dev);
  461         return 0;
  462 }
  463 
  464 static int
  465 fwohci_pci_resume(device_t dev)
  466 {
  467         fwohci_softc_t *sc = device_get_softc(dev);
  468 
  469         fwohci_pci_init(dev);
  470         fwohci_resume(sc, dev);
  471         return 0;
  472 }
  473 
  474 static int
  475 fwohci_pci_shutdown(device_t dev)
  476 {
  477         fwohci_softc_t *sc = device_get_softc(dev);
  478 
  479         bus_generic_shutdown(dev);
  480         fwohci_stop(sc, dev);
  481         return 0;
  482 }
  483 
  484 static device_t
  485 fwohci_pci_add_child(device_t dev, int order, const char *name, int unit)
  486 {
  487         struct fwohci_softc *sc;
  488         device_t child;
  489         int s, err = 0;
  490 
  491         sc = (struct fwohci_softc *)device_get_softc(dev);
  492         child = device_add_child(dev, name, unit);
  493         if (child == NULL)
  494                 return (child);
  495 
  496         sc->fc.bdev = child;
  497         device_set_ivars(child, (void *)&sc->fc);
  498 
  499         err = device_probe_and_attach(child);
  500         if (err) {
  501                 device_printf(dev, "probe_and_attach failed with err=%d\n",
  502                     err);
  503                 fwohci_pci_detach(dev);
  504                 device_delete_child(dev, child);
  505                 return NULL;
  506         }
  507 
  508         /* XXX
  509          * Clear the bus reset event flag to start transactions even when
  510          * interrupt is disabled during the boot process.
  511          */
  512         if (cold) {
  513                 DELAY(250); /* 2 cycles */
  514                 s = splfw();
  515                 fwohci_poll((void *)sc, 0, -1);
  516                 splx(s);
  517         }
  518 
  519         return (child);
  520 }
  521 
  522 static device_method_t fwohci_methods[] = {
  523         /* Device interface */
  524         DEVMETHOD(device_probe,         fwohci_pci_probe),
  525         DEVMETHOD(device_attach,        fwohci_pci_attach),
  526         DEVMETHOD(device_detach,        fwohci_pci_detach),
  527         DEVMETHOD(device_suspend,       fwohci_pci_suspend),
  528         DEVMETHOD(device_resume,        fwohci_pci_resume),
  529         DEVMETHOD(device_shutdown,      fwohci_pci_shutdown),
  530 
  531         /* Bus interface */
  532         DEVMETHOD(bus_add_child,        fwohci_pci_add_child),
  533         DEVMETHOD(bus_print_child,      bus_generic_print_child),
  534 
  535         { 0, 0 }
  536 };
  537 
  538 static driver_t fwohci_driver = {
  539         "fwohci",
  540         fwohci_methods,
  541         sizeof(fwohci_softc_t),
  542 };
  543 
  544 static devclass_t fwohci_devclass;
  545 
  546 #ifdef FWOHCI_MODULE
  547 MODULE_DEPEND(fwohci, firewire, 1, 1, 1);
  548 #endif
  549 DRIVER_MODULE(fwohci, pci, fwohci_driver, fwohci_devclass, 0, 0);
  550 DRIVER_MODULE(fwohci, cardbus, fwohci_driver, fwohci_devclass, 0, 0);

Cache object: 2a5b0e53f93d87e28823268e22b83213


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