sys/dev/netif/an/if_an_pci.c

   1 /*
   2  * Copyright (c) 1997, 1998, 1999
   3  *      Bill Paul <wpaul@ctr.columbia.edu>.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by Bill Paul.
  16  * 4. Neither the name of the author nor the names of any co-contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
  24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  30  * THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * $FreeBSD: src/sys/dev/an/if_an_pci.c,v 1.2.2.8 2003/02/11 03:32:48 ambrisko Exp $
  33  * $DragonFly: src/sys/dev/netif/an/if_an_pci.c,v 1.5 2004/03/14 15:36:48 joerg Exp $
  34  *
  35  * $FreeBSD: src/sys/dev/an/if_an_pci.c,v 1.2.2.8 2003/02/11 03:32:48 ambrisko Exp $
  36  */
  37
  38 /*
  39  * This is a PCI shim for the Aironet PC4500/4800 wireless network
  40  * driver. Aironet makes PCMCIA, ISA and PCI versions of these devices,
  41  * which all have basically the same interface. The ISA and PCI cards
  42  * are actually bridge adapters with PCMCIA cards inserted into them,
  43  * however they appear as normal PCI or ISA devices to the host.
  44  *
  45  * All we do here is handle the PCI probe and attach and set up an
  46  * interrupt handler entry point. The PCI version of the card uses
  47  * a PLX 9050 PCI to "dumb bus" bridge chip, which provides us with
  48  * multiple PCI address space mappings. The primary mapping at PCI
  49  * register 0x14 is for the PLX chip itself, *NOT* the Aironet card.
  50  * The I/O address of the Aironet is actually at register 0x18, which
  51  * is the local bus mapping register for bus space 0. There are also
  52  * registers for additional register spaces at registers 0x1C and
  53  * 0x20, but these are unused in the Aironet devices. To find out
  54  * more, you need a datasheet for the 9050 from PLX, but you have
  55  * to go through their sales office to get it. Bleh.
  56  */
  57
  58 #include "opt_inet.h"
  59
  60 #ifdef INET
  61 #define ANCACHE
  62 #endif
  63
  64 #include <sys/param.h>
  65 #include <sys/systm.h>
  66 #include <sys/sockio.h>
  67 #include <sys/mbuf.h>
  68 #include <sys/malloc.h>
  69 #include <sys/kernel.h>
  70 #include <sys/socket.h>
  71
  72 #include <sys/module.h>
  73 #include <sys/bus.h>
  74 #include <machine/bus.h>
  75 #include <sys/rman.h>
  76 #include <machine/resource.h>
  77
  78 #include <net/if.h>
  79 #include <net/if_arp.h>
  80 #include <net/ethernet.h>
  81 #include <net/if_dl.h>
  82 #include <net/if_media.h>
  83
  84 #include <bus/pci/pcireg.h>
  85 #include <bus/pci/pcivar.h>
  86
  87 #include "if_aironet_ieee.h"
  88 #include "if_anreg.h"
  89
  90 struct an_type {
  91         u_int16_t               an_vid;
  92         u_int16_t               an_did;
  93         char                    *an_name;
  94 };
  95
  96 #define AIRONET_VENDORID        0x14B9
  97 #define AIRONET_DEVICEID_35x    0x0350
  98 #define AIRONET_DEVICEID_4500   0x4500
  99 #define AIRONET_DEVICEID_4800   0x4800
 100 #define AIRONET_DEVICEID_4xxx   0x0001
 101 #define AIRONET_DEVICEID_MPI350 0xA504
 102 #define AN_PCI_PLX_LOIO         0x14    /* PLX chip iobase */
 103 #define AN_PCI_LOIO             0x18    /* Aironet iobase */
 104
 105 static struct an_type an_devs[] = {
 106         { AIRONET_VENDORID, AIRONET_DEVICEID_35x, "Cisco Aironet 350 Series" },
 107         { AIRONET_VENDORID, AIRONET_DEVICEID_4500, "Aironet PCI4500" },
 108         { AIRONET_VENDORID, AIRONET_DEVICEID_4800, "Aironet PCI4800" },
 109         { AIRONET_VENDORID, AIRONET_DEVICEID_4xxx, "Aironet PCI4500/PCI4800" },
 110         { 0, 0, NULL }
 111 };
 112
 113 static int an_probe_pci         (device_t);
 114 static int an_attach_pci        (device_t);
 115 static int an_detach_pci        (device_t);
 116 static int an_suspend_pci       (device_t);
 117 static int an_resume_pci        (device_t);
 118
 119 static int
 120 an_probe_pci(device_t dev)
 121 {
 122         struct an_type          *t;
 123
 124         t = an_devs;
 125
 126         while (t->an_name != NULL) {
 127                 if (pci_get_vendor(dev) == t->an_vid &&
 128                     pci_get_device(dev) == t->an_did) {
 129                         device_set_desc(dev, t->an_name);
 130                         return(0);
 131                 }
 132                 t++;
 133         }
 134
 135         if (pci_get_vendor(dev) == AIRONET_VENDORID &&
 136             pci_get_device(dev) == AIRONET_DEVICEID_MPI350) {
 137                 device_set_desc(dev, "Cisco Aironet MPI350");
 138                 return(0);
 139         }
 140
 141         return(ENXIO);
 142 }
 143
 144 static int
 145 an_attach_pci(dev)
 146         device_t                dev;
 147 {
 148         int                     s;
 149         u_int32_t               command;
 150         struct an_softc         *sc;
 151         int                     unit, flags, error = 0;
 152
 153         s = splimp();
 154
 155         sc = device_get_softc(dev);
 156         unit = device_get_unit(dev);
 157         flags = device_get_flags(dev);
 158         bzero(sc, sizeof(struct an_softc));
 159
 160         if (pci_get_vendor(dev) == AIRONET_VENDORID &&
 161             pci_get_device(dev) == AIRONET_DEVICEID_MPI350) {
 162                 sc->mpi350 = 1;
 163                 sc->port_rid = PCIR_MAPS;
 164         } else {
 165                 /*
 166                  * Map control/status registers.
 167                  */
 168                 command = pci_read_config(dev, PCIR_COMMAND, 4);
 169                 command |= PCIM_CMD_PORTEN;
 170                 pci_write_config(dev, PCIR_COMMAND, command, 4);
 171                 command = pci_read_config(dev, PCIR_COMMAND, 4);
 172
 173                 if (!(command & PCIM_CMD_PORTEN)) {
 174                         printf("an%d: failed to enable I/O ports!\n", unit);
 175                         error = ENXIO;
 176                         goto fail;
 177                 }
 178                 sc->port_rid = AN_PCI_LOIO;
 179         }
 180         error = an_alloc_port(dev, sc->port_rid, 1);
 181
 182         if (error) {
 183                 printf("an%d: couldn't map ports\n", unit);
 184                 goto fail;
 185         }
 186
 187         sc->an_btag = rman_get_bustag(sc->port_res);
 188         sc->an_bhandle = rman_get_bushandle(sc->port_res);
 189
 190         /* Allocate memory for MPI350 */
 191         if (sc->mpi350) {
 192                 /* Allocate memory */
 193                 sc->mem_rid = PCIR_MAPS + 4;
 194                 error = an_alloc_memory(dev, sc->mem_rid, 1);
 195                 if (error) {
 196                         printf("an%d: couldn't map memory\n", unit);
 197                         goto fail;
 198                 }
 199                 sc->an_mem_btag = rman_get_bustag(sc->mem_res);
 200                 sc->an_mem_bhandle = rman_get_bushandle(sc->mem_res);
 201
 202                 /* Allocate aux. memory */
 203                 sc->mem_aux_rid = PCIR_MAPS + 8;
 204                 error = an_alloc_aux_memory(dev, sc->mem_aux_rid,
 205                     AN_AUXMEMSIZE);
 206                 if (error) {
 207                         printf("an%d: couldn't map aux memory\n", unit);
 208                         goto fail;
 209                 }
 210                 sc->an_mem_aux_btag = rman_get_bustag(sc->mem_aux_res);
 211                 sc->an_mem_aux_bhandle = rman_get_bushandle(sc->mem_aux_res);
 212
 213                 /* Allocate DMA region */
 214                 error = bus_dma_tag_create(NULL,        /* parent */
 215                                1, 0,                    /* alignment, bounds */
 216                                BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
 217                                BUS_SPACE_MAXADDR,       /* highaddr */
 218                                NULL, NULL,              /* filter, filterarg */
 219                                0x3ffff,                 /* maxsize XXX */
 220                                1,                       /* nsegments */
 221                                0xffff,                  /* maxsegsize XXX */
 222                                BUS_DMA_ALLOCNOW,        /* flags */
 223                                &sc->an_dtag);
 224                 if (error) {
 225                         printf("an%d: couldn't get DMA region\n", unit);
 226                         goto fail;
 227                 }
 228         }
 229
 230         /* Allocate interrupt */
 231         error = an_alloc_irq(dev, 0, RF_SHAREABLE);
 232         if (error) {
 233                 goto fail;
 234         }
 235
 236         error = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_NET,
 237             an_intr, sc, &sc->irq_handle);
 238         if (error) {
 239                 goto fail;
 240         }
 241
 242         sc->an_dev = dev;
 243         error = an_attach(sc, device_get_unit(dev), flags);
 244
 245 fail:
 246         if (error)
 247                 an_release_resources(dev);
 248         splx(s);
 249
 250         return(error);
 251 }
 252
 253 static int
 254 an_detach_pci(device_t dev)
 255 {
 256         struct an_softc         *sc = device_get_softc(dev);
 257         struct ifnet            *ifp = &sc->arpcom.ac_if;
 258
 259         an_stop(sc);
 260         ifmedia_removeall(&sc->an_ifmedia);
 261         ether_ifdetach(ifp);
 262         bus_teardown_intr(dev, sc->irq_res, sc->irq_handle);
 263         an_release_resources(dev);
 264
 265         return (0);
 266 }
 267
 268 static int
 269 an_suspend_pci(device_t dev)
 270 {
 271         an_shutdown(dev);
 272
 273         return (0);
 274 }
 275
 276 static int
 277 an_resume_pci(device_t dev)
 278 {
 279         an_resume(dev);
 280
 281         return (0);
 282 }
 283
 284 static device_method_t an_pci_methods[] = {
 285         /* Device interface */
 286         DEVMETHOD(device_probe,         an_probe_pci),
 287         DEVMETHOD(device_attach,        an_attach_pci),
 288         DEVMETHOD(device_detach,        an_detach_pci),
 289         DEVMETHOD(device_shutdown,      an_shutdown),
 290         DEVMETHOD(device_suspend,       an_suspend_pci),
 291         DEVMETHOD(device_resume,        an_resume_pci),
 292         { 0, 0 }
 293 };
 294
 295 static driver_t an_pci_driver = {
 296         "an",
 297         an_pci_methods,
 298         sizeof(struct an_softc),
 299 };
 300
 301 static devclass_t an_devclass;
 302
 303 DRIVER_MODULE(if_an, pci, an_pci_driver, an_devclass, 0, 0);