sys/dev/gem/if_gem_pci.c

   1 /*-
   2  * Copyright (C) 2001 Eduardo Horvath.
   3  * All rights reserved.
   4  *
   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  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR  ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR  BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  *      from: NetBSD: if_gem_pci.c,v 1.7 2001/10/18 15:09:15 thorpej Exp
  28  *
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 /*
  35  * PCI bindings for Sun GEM ethernet controllers.
  36  */
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/bus.h>
  41 #include <sys/malloc.h>
  42 #include <sys/kernel.h>
  43 #include <sys/lock.h>
  44 #include <sys/module.h>
  45 #include <sys/mutex.h>
  46 #include <sys/resource.h>
  47 #include <sys/socket.h>
  48
  49 #include <machine/endian.h>
  50
  51 #include <net/ethernet.h>
  52 #include <net/if.h>
  53 #include <net/if_arp.h>
  54 #include <net/if_dl.h>
  55 #include <net/if_media.h>
  56
  57 #include <machine/bus.h>
  58 #include <machine/resource.h>
  59 #include <dev/ofw/openfirm.h>
  60 #include <machine/ofw_machdep.h>
  61
  62 #include <sys/rman.h>
  63
  64 #include <dev/mii/mii.h>
  65 #include <dev/mii/miivar.h>
  66
  67 #include <dev/gem/if_gemreg.h>
  68 #include <dev/gem/if_gemvar.h>
  69
  70 #include <dev/pci/pcivar.h>
  71 #include <dev/pci/pcireg.h>
  72
  73 #include "miibus_if.h"
  74
  75 struct gem_pci_softc {
  76         struct  gem_softc       gsc_gem;        /* GEM device */
  77         struct  resource        *gsc_sres;
  78         int                     gsc_srid;
  79         struct  resource        *gsc_ires;
  80         int                     gsc_irid;
  81         void                    *gsc_ih;
  82 };
  83
  84 static int      gem_pci_probe(device_t);
  85 static int      gem_pci_attach(device_t);
  86 static int      gem_pci_detach(device_t);
  87 static int      gem_pci_suspend(device_t);
  88 static int      gem_pci_resume(device_t);
  89
  90 static device_method_t gem_pci_methods[] = {
  91         /* Device interface */
  92         DEVMETHOD(device_probe,         gem_pci_probe),
  93         DEVMETHOD(device_attach,        gem_pci_attach),
  94         DEVMETHOD(device_detach,        gem_pci_detach),
  95         DEVMETHOD(device_suspend,       gem_pci_suspend),
  96         DEVMETHOD(device_resume,        gem_pci_resume),
  97         /* Use the suspend handler here, it is all that is required. */
  98         DEVMETHOD(device_shutdown,      gem_pci_suspend),
  99
 100         /* bus interface */
 101         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 102         DEVMETHOD(bus_driver_added,     bus_generic_driver_added),
 103
 104         /* MII interface */
 105         DEVMETHOD(miibus_readreg,       gem_mii_readreg),
 106         DEVMETHOD(miibus_writereg,      gem_mii_writereg),
 107         DEVMETHOD(miibus_statchg,       gem_mii_statchg),
 108
 109         { 0, 0 }
 110 };
 111
 112 static driver_t gem_pci_driver = {
 113         "gem",
 114         gem_pci_methods,
 115         sizeof(struct gem_pci_softc)
 116 };
 117
 118
 119 DRIVER_MODULE(gem, pci, gem_pci_driver, gem_devclass, 0, 0);
 120 MODULE_DEPEND(gem, pci, 1, 1, 1);
 121 MODULE_DEPEND(gem, ether, 1, 1, 1);
 122
 123 struct gem_pci_dev {
 124         u_int32_t       gpd_devid;
 125         int     gpd_variant;
 126         char    *gpd_desc;
 127 } gem_pci_devlist[] = {
 128         { 0x1101108e, GEM_SUN_GEM,      "Sun ERI 10/100 Ethernet Adaptor" },
 129         { 0x2bad108e, GEM_SUN_GEM,      "Sun GEM Gigabit Ethernet Adaptor" },
 130         { 0x0021106b, GEM_APPLE_GMAC,   "Apple GMAC Ethernet Adaptor" },
 131         { 0x0024106b, GEM_APPLE_GMAC,   "Apple GMAC2 Ethernet Adaptor" },
 132         { 0x0032106b, GEM_APPLE_GMAC,   "Apple GMAC3 Ethernet Adaptor" },
 133         { 0, 0, NULL }
 134 };
 135
 136 /*
 137  * Attach routines need to be split out to different bus-specific files.
 138  */
 139 static int
 140 gem_pci_probe(dev)
 141         device_t dev;
 142 {
 143         int i;
 144         u_int32_t devid;
 145         struct gem_pci_softc *gsc;
 146
 147         devid = pci_get_devid(dev);
 148         for (i = 0; gem_pci_devlist[i].gpd_desc != NULL; i++) {
 149                 if (devid == gem_pci_devlist[i].gpd_devid) {
 150                         device_set_desc(dev, gem_pci_devlist[i].gpd_desc);
 151                         gsc = device_get_softc(dev);
 152                         gsc->gsc_gem.sc_variant =
 153                             gem_pci_devlist[i].gpd_variant;
 154                         return (BUS_PROBE_DEFAULT);
 155                 }
 156         }
 157
 158         return (ENXIO);
 159 }
 160
 161 static int
 162 gem_pci_attach(dev)
 163         device_t dev;
 164 {
 165         struct gem_pci_softc *gsc = device_get_softc(dev);
 166         struct gem_softc *sc = &gsc->gsc_gem;
 167
 168         pci_enable_busmaster(dev);
 169
 170         /*
 171          * Some Sun GEMs/ERIs do have their intpin register bogusly set to 0,
 172          * although it should be 1. correct that.
 173          */
 174         if (pci_get_intpin(dev) == 0)
 175                 pci_set_intpin(dev, 1);
 176
 177         sc->sc_dev = dev;
 178         sc->sc_pci = 1;         /* XXX */
 179
 180         GEM_LOCK_INIT(sc, device_get_nameunit(dev));
 181
 182         gsc->gsc_srid = PCI_GEM_BASEADDR;
 183         gsc->gsc_sres = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
 184             &gsc->gsc_srid, RF_ACTIVE);
 185         if (gsc->gsc_sres == NULL) {
 186                 device_printf(dev, "failed to allocate bus space resource\n");
 187                 goto fail_mtx;
 188         }
 189
 190         gsc->gsc_irid = 0;
 191         gsc->gsc_ires = bus_alloc_resource_any(dev, SYS_RES_IRQ,
 192             &gsc->gsc_irid, RF_SHAREABLE | RF_ACTIVE);
 193         if (gsc->gsc_ires == NULL) {
 194                 device_printf(dev, "failed to allocate interrupt resource\n");
 195                 goto fail_sres;
 196         }
 197
 198         sc->sc_bustag = rman_get_bustag(gsc->gsc_sres);
 199         sc->sc_h = rman_get_bushandle(gsc->gsc_sres);
 200
 201         /* All platform that this driver is used on must provide this. */
 202         OF_getetheraddr(dev, sc->sc_enaddr);
 203
 204         /*
 205          * call the main configure
 206          */
 207         if (gem_attach(sc) != 0) {
 208                 device_printf(dev, "could not be configured\n");
 209                 goto fail_ires;
 210         }
 211
 212         if (bus_setup_intr(dev, gsc->gsc_ires, INTR_TYPE_NET | INTR_MPSAFE,
 213             gem_intr, sc, &gsc->gsc_ih) != 0) {
 214                 device_printf(dev, "failed to set up interrupt\n");
 215                 gem_detach(sc);
 216                 goto fail_ires;
 217         }
 218         return (0);
 219
 220 fail_ires:
 221         bus_release_resource(dev, SYS_RES_IRQ, gsc->gsc_irid, gsc->gsc_ires);
 222 fail_sres:
 223         bus_release_resource(dev, SYS_RES_MEMORY, gsc->gsc_srid, gsc->gsc_sres);
 224 fail_mtx:
 225         GEM_LOCK_DESTROY(sc);
 226         return (ENXIO);
 227 }
 228
 229 static int
 230 gem_pci_detach(dev)
 231         device_t dev;
 232 {
 233         struct gem_pci_softc *gsc = device_get_softc(dev);
 234         struct gem_softc *sc = &gsc->gsc_gem;
 235
 236         bus_teardown_intr(dev, gsc->gsc_ires, gsc->gsc_ih);
 237         gem_detach(sc);
 238         bus_release_resource(dev, SYS_RES_IRQ, gsc->gsc_irid, gsc->gsc_ires);
 239         bus_release_resource(dev, SYS_RES_MEMORY, gsc->gsc_srid, gsc->gsc_sres);
 240         GEM_LOCK_DESTROY(sc);
 241         return (0);
 242 }
 243
 244 static int
 245 gem_pci_suspend(dev)
 246         device_t dev;
 247 {
 248         struct gem_pci_softc *gsc = device_get_softc(dev);
 249         struct gem_softc *sc = &gsc->gsc_gem;
 250
 251         gem_suspend(sc);
 252         return (0);
 253 }
 254
 255 static int
 256 gem_pci_resume(dev)
 257         device_t dev;
 258 {
 259         struct gem_pci_softc *gsc = device_get_softc(dev);
 260         struct gem_softc *sc = &gsc->gsc_gem;
 261
 262         gem_resume(sc);
 263         return (0);
 264 }