sys/dev/malo/if_malo_pci.c

   1 /*-
   2  * Copyright (c) 2007 Marvell Semiconductor, Inc.
   3  * Copyright (c) 2007 Sam Leffler, Errno Consulting
   4  * Copyright (c) 2008 Weongyo Jeong <weongyo@freebsd.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer,
  12  *    without modification.
  13  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  14  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
  15  *    redistribution must be conditioned upon including a substantially
  16  *    similar Disclaimer requirement for further binary redistribution.
  17  *
  18  * NO WARRANTY
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
  22  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  23  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
  24  * OR 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
  27  * IN 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
  29  * THE POSSIBILITY OF SUCH DAMAGES.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #ifdef __FreeBSD__
  34 __FBSDID("$FreeBSD$");
  35 #endif
  36
  37 /*
  38  * PCI front-end for the Marvell 88W8335 Wireless LAN controller driver.
  39  */
  40
  41 #include <sys/param.h>
  42 #include <sys/kernel.h>
  43 #include <sys/malloc.h>
  44 #include <sys/module.h>
  45 #include <sys/socket.h>
  46 #include <sys/sysctl.h>
  47
  48 #include <machine/bus.h>
  49 #include <sys/bus.h>
  50 #include <sys/rman.h>
  51
  52 #include <net/if.h>
  53 #include <net/if_var.h>
  54 #include <net/if_media.h>
  55 #include <net/ethernet.h>
  56
  57 #include <net80211/ieee80211_var.h>
  58
  59 #include <dev/malo/if_malo.h>
  60
  61 #include <dev/pci/pcivar.h>
  62 #include <dev/pci/pcireg.h>
  63
  64 /*
  65  * PCI glue.
  66  */
  67
  68 #define MALO_RESOURCE_MAX               2
  69 #define MALO_MSI_MESSAGES               1
  70
  71 struct malo_pci_softc {
  72         struct malo_softc               malo_sc;
  73         struct resource_spec            *malo_mem_spec;
  74         struct resource                 *malo_res_mem[MALO_RESOURCE_MAX];
  75         struct resource_spec            *malo_irq_spec;
  76         struct resource                 *malo_res_irq[MALO_MSI_MESSAGES];
  77         void                            *malo_intrhand[MALO_MSI_MESSAGES];
  78         int                             malo_msi;
  79 };
  80
  81 /*
  82  * Tunable variables.
  83  */
  84 SYSCTL_DECL(_hw_malo);
  85 static SYSCTL_NODE(_hw_malo, OID_AUTO, pci, CTLFLAG_RD, 0,
  86     "Marvell 88W8335 driver PCI parameters");
  87
  88 static int msi_disable = 0;                             /* MSI disabled  */
  89 SYSCTL_INT(_hw_malo_pci, OID_AUTO, msi_disable, CTLFLAG_RWTUN, &msi_disable,
  90             0, "MSI disabled");
  91
  92 /*
  93  * Devices supported by this driver.
  94  */
  95 #define VENDORID_MARVELL                0X11AB
  96 #define DEVICEID_MRVL_88W8310           0X1FA7
  97 #define DEVICEID_MRVL_88W8335R1         0X1FAA
  98 #define DEVICEID_MRVL_88W8335R2         0X1FAB
  99
 100 static struct malo_product {
 101         uint16_t                        mp_vendorid;
 102         uint16_t                        mp_deviceid;
 103         const char                      *mp_name;
 104 } malo_products[] = {
 105         { VENDORID_MARVELL, DEVICEID_MRVL_88W8310,
 106             "Marvell Libertas 88W8310 802.11g Wireless Adapter" },
 107         { VENDORID_MARVELL, DEVICEID_MRVL_88W8335R1,
 108             "Marvell Libertas 88W8335 802.11g Wireless Adapter" },
 109         { VENDORID_MARVELL, DEVICEID_MRVL_88W8335R2,
 110             "Marvell Libertas 88W8335 802.11g Wireless Adapter" }
 111 };
 112
 113 static struct resource_spec malo_res_spec_mem[] = {
 114         { SYS_RES_MEMORY,       PCIR_BAR(0),    RF_ACTIVE },
 115         { SYS_RES_MEMORY,       PCIR_BAR(1),    RF_ACTIVE },
 116         { -1,                   0,              0 }
 117 };
 118
 119 static struct resource_spec malo_res_spec_legacy[] = {
 120         { SYS_RES_IRQ,          0,              RF_ACTIVE | RF_SHAREABLE },
 121         { -1,                   0,              0 }
 122 };
 123
 124 static struct resource_spec malo_res_spec_msi[] = {
 125         { SYS_RES_IRQ,          1,              RF_ACTIVE },
 126         { -1,                   0,              0 }
 127 };
 128
 129 static int      malo_pci_detach(device_t);
 130
 131 static int
 132 malo_pci_probe(device_t dev)
 133 {
 134 #define N(a)    (sizeof(a) / sizeof((a)[0]))
 135         struct malo_product *mp;
 136         uint16_t vendor, devid;
 137         int i;
 138
 139         vendor = pci_get_vendor(dev);
 140         devid = pci_get_device(dev);
 141         mp = malo_products;
 142
 143         for (i = 0; i < N(malo_products); i++, mp++) {
 144                 if (vendor == mp->mp_vendorid && devid == mp->mp_deviceid) {
 145                         device_set_desc(dev, mp->mp_name);
 146                         return (BUS_PROBE_DEFAULT);
 147                 }
 148         }
 149
 150         return (ENXIO);
 151 #undef N
 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_MAXADDR,       /* maxsize */
 229                                0,                       /* nsegments */
 230                                BUS_SPACE_MAXADDR,       /* 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 static  devclass_t malo_devclass;
 351 DRIVER_MODULE(malo, pci, malo_pci_driver, malo_devclass, 0, 0);
 352 MODULE_VERSION(malo, 1);
 353 MODULE_DEPEND(malo, wlan, 1, 1, 1);             /* 802.11 media layer */
 354 MODULE_DEPEND(malo, firmware, 1, 1, 1);