if_malo_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  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2007 Marvell Semiconductor, Inc.
    5  * Copyright (c) 2007 Sam Leffler, Errno Consulting
    6  * Copyright (c) 2008 Weongyo Jeong <weongyo@freebsd.org>
    7  * All rights reserved.
    8  *
    9  * Redistribution and use in source and binary forms, with or without
   10  * modification, are permitted provided that the following conditions
   11  * are met:
   12  * 1. Redistributions of source code must retain the above copyright
   13  *    notice, this list of conditions and the following disclaimer,
   14  *    without modification.
   15  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
   16  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
   17  *    redistribution must be conditioned upon including a substantially
   18  *    similar Disclaimer requirement for further binary redistribution.
   19  *
   20  * NO WARRANTY
   21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   23  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
   24  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
   25  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
   26  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
   29  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
   31  * THE POSSIBILITY OF SUCH DAMAGES.
   32  */
   33 
   34 #include <sys/cdefs.h>
   35 #ifdef __FreeBSD__
   36 __FBSDID("$FreeBSD$");
   37 #endif
   38 
   39 /*
   40  * PCI front-end for the Marvell 88W8335 Wireless LAN controller driver.
   41  */
   42 
   43 #include <sys/param.h>
   44 #include <sys/kernel.h>
   45 #include <sys/malloc.h>
   46 #include <sys/module.h>
   47 #include <sys/socket.h>
   48 #include <sys/sysctl.h>
   49 
   50 #include <machine/bus.h>
   51 #include <sys/bus.h>
   52 #include <sys/rman.h>
   53  
   54 #include <net/if.h>
   55 #include <net/if_var.h>
   56 #include <net/if_media.h>
   57 #include <net/ethernet.h>
   58 
   59 #include <net80211/ieee80211_var.h>
   60 
   61 #include <dev/malo/if_malo.h>
   62 
   63 #include <dev/pci/pcivar.h>
   64 #include <dev/pci/pcireg.h>
   65 
   66 /*
   67  * PCI glue.
   68  */
   69 
   70 #define MALO_RESOURCE_MAX               2
   71 #define MALO_MSI_MESSAGES               1
   72 
   73 struct malo_pci_softc {
   74         struct malo_softc               malo_sc;
   75         struct resource_spec            *malo_mem_spec;
   76         struct resource                 *malo_res_mem[MALO_RESOURCE_MAX];
   77         struct resource_spec            *malo_irq_spec;
   78         struct resource                 *malo_res_irq[MALO_MSI_MESSAGES];
   79         void                            *malo_intrhand[MALO_MSI_MESSAGES];
   80         int                             malo_msi;
   81 };
   82 
   83 /*
   84  * Tunable variables.
   85  */
   86 SYSCTL_DECL(_hw_malo);
   87 static SYSCTL_NODE(_hw_malo, OID_AUTO, pci, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
   88     "Marvell 88W8335 driver PCI parameters");
   89 
   90 static int msi_disable = 0;                             /* MSI disabled  */
   91 SYSCTL_INT(_hw_malo_pci, OID_AUTO, msi_disable, CTLFLAG_RWTUN, &msi_disable,
   92             0, "MSI disabled");
   93 
   94 /*
   95  * Devices supported by this driver.
   96  */
   97 #define VENDORID_MARVELL                0X11AB
   98 #define DEVICEID_MRVL_88W8310           0X1FA7
   99 #define DEVICEID_MRVL_88W8335R1         0X1FAA
  100 #define DEVICEID_MRVL_88W8335R2         0X1FAB
  101 
  102 static struct malo_product {
  103         uint16_t                        mp_vendorid;
  104         uint16_t                        mp_deviceid;
  105         const char                      *mp_name;
  106 } malo_products[] = {
  107         { VENDORID_MARVELL, DEVICEID_MRVL_88W8310,
  108             "Marvell Libertas 88W8310 802.11g Wireless Adapter" },
  109         { VENDORID_MARVELL, DEVICEID_MRVL_88W8335R1,
  110             "Marvell Libertas 88W8335 802.11g Wireless Adapter" },
  111         { VENDORID_MARVELL, DEVICEID_MRVL_88W8335R2,
  112             "Marvell Libertas 88W8335 802.11g Wireless Adapter" }
  113 };
  114 
  115 static struct resource_spec malo_res_spec_mem[] = {
  116         { SYS_RES_MEMORY,       PCIR_BAR(0),    RF_ACTIVE },
  117         { SYS_RES_MEMORY,       PCIR_BAR(1),    RF_ACTIVE },
  118         { -1,                   0,              0 }
  119 };
  120 
  121 static struct resource_spec malo_res_spec_legacy[] = {
  122         { SYS_RES_IRQ,          0,              RF_ACTIVE | RF_SHAREABLE },
  123         { -1,                   0,              0 }
  124 };
  125 
  126 static struct resource_spec malo_res_spec_msi[] = {
  127         { SYS_RES_IRQ,          1,              RF_ACTIVE },
  128         { -1,                   0,              0 }
  129 };
  130 
  131 static int      malo_pci_detach(device_t);
  132 
  133 static int
  134 malo_pci_probe(device_t dev)
  135 {
  136         struct malo_product *mp;
  137         uint16_t vendor, devid;
  138         int i;
  139 
  140         vendor = pci_get_vendor(dev);
  141         devid = pci_get_device(dev);
  142         mp = malo_products;
  143 
  144         for (i = 0; i < nitems(malo_products); i++, mp++) {
  145                 if (vendor == mp->mp_vendorid && devid == mp->mp_deviceid) {
  146                         device_set_desc(dev, mp->mp_name);
  147                         return (BUS_PROBE_DEFAULT);
  148                 }
  149         }
  150 
  151         return (ENXIO);
  152 }
  153 
  154 static int
  155 malo_pci_attach(device_t dev)
  156 {
  157         int error = ENXIO, i, msic, reg;
  158         struct malo_pci_softc *psc = device_get_softc(dev);
  159         struct malo_softc *sc = &psc->malo_sc;
  160 
  161         sc->malo_dev = dev;
  162         
  163         pci_enable_busmaster(dev);
  164 
  165         /* 
  166          * Setup memory-mapping of PCI registers.
  167          */
  168         psc->malo_mem_spec = malo_res_spec_mem;
  169         error = bus_alloc_resources(dev, psc->malo_mem_spec, psc->malo_res_mem);
  170         if (error) {
  171                 device_printf(dev, "couldn't allocate memory resources\n");
  172                 return (ENXIO);
  173         }
  174 
  175         /*
  176          * Arrange and allocate interrupt line.
  177          */
  178         sc->malo_invalid = 1;
  179 
  180         if (pci_find_cap(dev, PCIY_EXPRESS, &reg) == 0) {
  181                 msic = pci_msi_count(dev);
  182                 if (bootverbose)
  183                         device_printf(dev, "MSI count : %d\n", msic);
  184         } else
  185                 msic = 0;
  186 
  187         psc->malo_irq_spec = malo_res_spec_legacy;
  188         if (msic == MALO_MSI_MESSAGES && msi_disable == 0) {
  189                 if (pci_alloc_msi(dev, &msic) == 0) {
  190                         if (msic == MALO_MSI_MESSAGES) {
  191                                 device_printf(dev, "Using %d MSI messages\n",
  192                                     msic);
  193                                 psc->malo_irq_spec = malo_res_spec_msi;
  194                                 psc->malo_msi = 1;
  195                         } else
  196                                 pci_release_msi(dev);
  197                 }
  198         }
  199 
  200         error = bus_alloc_resources(dev, psc->malo_irq_spec, psc->malo_res_irq);
  201         if (error) {
  202                 device_printf(dev, "couldn't allocate IRQ resources\n");
  203                 goto bad;
  204         }
  205 
  206         if (psc->malo_msi == 0)
  207                 error = bus_setup_intr(dev, psc->malo_res_irq[0],
  208                     INTR_TYPE_NET | INTR_MPSAFE, malo_intr, NULL, sc,
  209                     &psc->malo_intrhand[0]);
  210         else {
  211                 for (i = 0; i < MALO_MSI_MESSAGES; i++) {
  212                         error = bus_setup_intr(dev, psc->malo_res_irq[i],
  213                             INTR_TYPE_NET | INTR_MPSAFE, malo_intr, NULL, sc,
  214                             &psc->malo_intrhand[i]);
  215                         if (error != 0)
  216                                 break;
  217                 }
  218         }
  219 
  220         /*
  221          * Setup DMA descriptor area.
  222          */
  223         if (bus_dma_tag_create(bus_get_dma_tag(dev),    /* parent */
  224                                1, 0,                    /* alignment, bounds */
  225                                BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
  226                                BUS_SPACE_MAXADDR,       /* highaddr */
  227                                NULL, NULL,              /* filter, filterarg */
  228                                BUS_SPACE_MAXSIZE,       /* maxsize */
  229                                0,                       /* nsegments */
  230                                BUS_SPACE_MAXSIZE,       /* maxsegsize */
  231                                0,                       /* flags */
  232                                NULL,                    /* lockfunc */
  233                                NULL,                    /* lockarg */
  234                                &sc->malo_dmat)) {
  235                 device_printf(dev, "cannot allocate DMA tag\n");
  236                 goto bad1;
  237         }
  238 
  239         sc->malo_io0t = rman_get_bustag(psc->malo_res_mem[0]);
  240         sc->malo_io0h = rman_get_bushandle(psc->malo_res_mem[0]);
  241         sc->malo_io1t = rman_get_bustag(psc->malo_res_mem[1]);
  242         sc->malo_io1h = rman_get_bushandle(psc->malo_res_mem[1]);
  243 
  244         error = malo_attach(pci_get_device(dev), sc);
  245 
  246         if (error != 0)
  247                 goto bad2;
  248 
  249         return (error);
  250 
  251 bad2:
  252         bus_dma_tag_destroy(sc->malo_dmat);
  253 bad1:
  254         if (psc->malo_msi == 0)
  255                 bus_teardown_intr(dev, psc->malo_res_irq[0],
  256                     psc->malo_intrhand[0]);
  257         else {
  258                 for (i = 0; i < MALO_MSI_MESSAGES; i++)
  259                         bus_teardown_intr(dev, psc->malo_res_irq[i],
  260                             psc->malo_intrhand[i]);
  261         }
  262         bus_release_resources(dev, psc->malo_irq_spec, psc->malo_res_irq);
  263 bad:
  264         if (psc->malo_msi != 0)
  265                 pci_release_msi(dev);
  266         bus_release_resources(dev, psc->malo_mem_spec, psc->malo_res_mem);
  267 
  268         return (error);
  269 }
  270 
  271 static int
  272 malo_pci_detach(device_t dev)
  273 {
  274         int i;
  275         struct malo_pci_softc *psc = device_get_softc(dev);
  276         struct malo_softc *sc = &psc->malo_sc;
  277 
  278         /* check if device was removed */
  279         sc->malo_invalid = !bus_child_present(dev);
  280 
  281         malo_detach(sc);
  282 
  283         bus_generic_detach(dev);
  284 
  285         if (psc->malo_msi == 0)
  286                 bus_teardown_intr(dev, psc->malo_res_irq[0],
  287                     psc->malo_intrhand[0]);
  288         else {
  289                 for (i = 0; i < MALO_MSI_MESSAGES; i++)
  290                         bus_teardown_intr(dev, psc->malo_res_irq[i],
  291                             psc->malo_intrhand[i]);
  292 
  293                 pci_release_msi(dev);
  294         }
  295 
  296         bus_release_resources(dev, psc->malo_irq_spec, psc->malo_res_irq);
  297         bus_dma_tag_destroy(sc->malo_dmat);
  298         bus_release_resources(dev, psc->malo_mem_spec, psc->malo_res_mem);
  299 
  300         return (0);
  301 }
  302 
  303 static int
  304 malo_pci_shutdown(device_t dev)
  305 {
  306         struct malo_pci_softc *psc = device_get_softc(dev);
  307 
  308         malo_shutdown(&psc->malo_sc);
  309 
  310         return (0);
  311 }
  312 
  313 static int
  314 malo_pci_suspend(device_t dev)
  315 {
  316         struct malo_pci_softc *psc = device_get_softc(dev);
  317 
  318         malo_suspend(&psc->malo_sc);
  319 
  320         return (0);
  321 }
  322 
  323 static int
  324 malo_pci_resume(device_t dev)
  325 {
  326         struct malo_pci_softc *psc = device_get_softc(dev);
  327 
  328         malo_resume(&psc->malo_sc);
  329 
  330         return (0);
  331 }
  332 
  333 static device_method_t malo_pci_methods[] = {
  334         /* Device interface */
  335         DEVMETHOD(device_probe,         malo_pci_probe),
  336         DEVMETHOD(device_attach,        malo_pci_attach),
  337         DEVMETHOD(device_detach,        malo_pci_detach),
  338         DEVMETHOD(device_shutdown,      malo_pci_shutdown),
  339         DEVMETHOD(device_suspend,       malo_pci_suspend),
  340         DEVMETHOD(device_resume,        malo_pci_resume),
  341         { 0,0 }
  342 };
  343 
  344 static driver_t malo_pci_driver = {
  345         "malo",
  346         malo_pci_methods,
  347         sizeof(struct malo_pci_softc)
  348 };
  349 
  350 DRIVER_MODULE(malo, pci, malo_pci_driver, 0, 0);
  351 MODULE_VERSION(malo, 1);
  352 MODULE_DEPEND(malo, wlan, 1, 1, 1);             /* 802.11 media layer */
  353 MODULE_DEPEND(malo, firmware, 1, 1, 1);
Cache object: 4a206e325aa5c31159ef8a8f0dba5a6f
[ 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/malo/if_malo_pci.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/malo/if_malo_pci.c
