root/dev/cardbus/if_re_cardbus.c

DEFINITIONS

1. re_cardbus_probe
2. re_cardbus_attach
3. re_cardbus_setup
4. re_cardbus_detach
5. re_cardbus_shutdown
6. re_cardbus_powerhook

    1 /*      $OpenBSD: if_re_cardbus.c,v 1.11 2006/11/28 20:04:02 brad Exp $ */
    3 /*
    4  * Copyright (c) 2005 Peter Valchev <pvalchev@openbsd.org>
    5  *
    6  * Permission to use, copy, modify, and distribute this software for any
    7  * purpose with or without fee is hereby granted, provided that the above
    8  * copyright notice and this permission notice appear in all copies.
    9  *
   10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   17  */
   19 /*
   20  * Cardbus front-end for the Realtek 8169
   21  */
   23 #include <sys/param.h>
   24 #include <sys/endian.h>
   25 #include <sys/systm.h>
   26 #include <sys/sockio.h>
   27 #include <sys/mbuf.h>
   28 #include <sys/malloc.h>
   29 #include <sys/kernel.h>
   30 #include <sys/device.h>
   31 #include <sys/timeout.h>
   32 #include <sys/socket.h>
   34 #include <net/if.h>
   35 #include <net/if_dl.h>
   36 #include <net/if_media.h>
   38 #ifdef INET
   39 #include <netinet/in.h>
   40 #include <netinet/in_systm.h>
   41 #include <netinet/in_var.h>
   42 #include <netinet/ip.h>
   43 #include <netinet/if_ether.h>
   44 #endif
   46 #include <dev/mii/mii.h>
   47 #include <dev/mii/miivar.h>
   49 #include <dev/pci/pcidevs.h>
   51 #include <dev/cardbus/cardbusvar.h>
   53 #include <dev/ic/rtl81x9reg.h>
   54 #include <dev/ic/revar.h>
   56 struct re_cardbus_softc {
   57         /* General */
   58         struct rl_softc sc_rl;
   60         /* Cardbus-specific data */
   61         void *sc_ih;
cardbus_devfunc_t ct;
cardbustag_t sc_tag;
   64         int sc_csr;
   65         int sc_cben;
   66         int sc_bar_reg;
pcireg_t sc_bar_val;
   68         int sc_intrline;
bus_size_t sc_mapsize;
   71 };
   73 int     re_cardbus_probe(struct device *, void *, void *);
   74 void    re_cardbus_attach(struct device *, struct device *, void *);
   75 int     re_cardbus_detach(struct device *, int);
   76 void    re_cardbus_setup(struct rl_softc *);
   78 void    re_cardbus_shutdown(void *);
   79 void    re_cardbus_powerhook(int, void *);
   81 /*
   82  * Cardbus autoconfig definitions
   83  */
   84 struct cfattach re_cardbus_ca = {
   85         sizeof(struct re_cardbus_softc),
re_cardbus_probe,
re_cardbus_attach,
re_cardbus_detach
   89 };
   91 const struct cardbus_matchid re_cardbus_devices[] = {
   92         { PCI_VENDOR_REALTEK, PCI_PRODUCT_REALTEK_RT8169 },
   93 };
   95 /*
   96  * Probe for a RealTek 8169/8110 chip. Check the PCI vendor and device
   97  * IDs against our list and return a device name if we find a match.
   98  */
   99 int
re_cardbus_probe(struct device *parent, void *match, void *aux)
  101 {
  102         return (cardbus_matchbyid((struct cardbus_attach_args *)aux,
re_cardbus_devices,
  104             sizeof(re_cardbus_devices)/sizeof(re_cardbus_devices[0])));
  105 }
  107 /*
  108  * Attach the interface. Allocate softc structures, do ifmedia
  109  * setup and ethernet/BPF attach.
  110  */
  111 void
re_cardbus_attach(struct device *parent, struct device *self, void *aux)
  113 {
  114         struct re_cardbus_softc *csc = (struct re_cardbus_softc *)self;
  115         struct rl_softc         *sc = &csc->sc_rl;
  116         struct cardbus_attach_args *ca = aux;
  117         struct cardbus_softc *psc =
  118             (struct cardbus_softc *)sc->sc_dev.dv_parent;
cardbus_chipset_tag_t cc = psc->sc_cc;
cardbus_function_tag_t cf = psc->sc_cf;
cardbus_devfunc_t ct = ca->ca_ct;
bus_addr_t adr;
  123         char intrstr[16];
sc->sc_dmat = ca->ca_dmat;
csc->ct = ct;
csc->sc_tag = ca->ca_tag;
csc->sc_intrline = ca->ca_intrline;
  130         /*
  131          * Map control/status registers.
  132          */
  133         if (Cardbus_mapreg_map(ct, RL_PCI_LOMEM, CARDBUS_MAPREG_TYPE_MEM, 0,
  134             &sc->rl_btag, &sc->rl_bhandle, &adr, &csc->sc_mapsize) == 0) {
csc->sc_cben = CARDBUS_MEM_ENABLE;
csc->sc_csr |= CARDBUS_COMMAND_MEM_ENABLE;
csc->sc_bar_reg = RL_PCI_LOMEM;
csc->sc_bar_val = adr | CARDBUS_MAPREG_TYPE_MEM;
  139         } else {
printf(": can't map mem space\n");
  141                 return;
  142         }
  144         /* Enable power */
Cardbus_function_enable(ct);
  147         /* Get chip out of powersave mode (if applicable), initialize
  148          * config registers */
re_cardbus_setup(sc);
  151         /* Allocate interrupt */
csc->sc_ih = cardbus_intr_establish(cc, cf, csc->sc_intrline,
IPL_NET, re_intr, sc, sc->sc_dev.dv_xname);
  154         if (csc->sc_ih == NULL) {
printf(": couldn't establish interrupt at %s",
ca->ca_intrline);
Cardbus_function_disable(csc->ct);
  158                 return;
  159         }
snprintf(intrstr, sizeof(intrstr), "irq %d", ca->ca_intrline);
sc->sc_flags |= RL_ENABLED;
sc->rl_type = RL_8169;
sc->sc_sdhook = shutdownhook_establish(re_cardbus_shutdown, sc);
sc->sc_pwrhook = powerhook_establish(re_cardbus_powerhook, sc);
  168         /* Call bus-independent (common) attach routine */
re_attach(sc, intrstr);
  170 }
  172 /*
  173  * Get chip out of power-saving mode, init registers
  174  */
  175 void
re_cardbus_setup(struct rl_softc *sc)
  177 {
  178         struct re_cardbus_softc *csc = (struct re_cardbus_softc *)sc;
cardbus_devfunc_t ct = csc->ct;
cardbus_chipset_tag_t cc = ct->ct_cc;
cardbus_function_tag_t cf = ct->ct_cf;
pcireg_t reg, command;
  183         int pmreg;
  185         /* Handle power management nonsense */
  186         if (cardbus_get_capability(cc, cf, csc->sc_tag,
PCI_CAP_PWRMGMT, &pmreg, 0)) {
command = cardbus_conf_read(cc, cf, csc->sc_tag,
pmreg + PCI_PMCSR);
  191                 if (command & RL_PSTATE_MASK) {
pcireg_t iobase, membase, irq;
  194                         /* Save important PCI config data */
iobase = cardbus_conf_read(cc, cf, csc->sc_tag, RL_PCI_LOIO);
membase = cardbus_conf_read(cc, cf, csc->sc_tag, RL_PCI_LOMEM);
irq = cardbus_conf_read(cc, cf, csc->sc_tag, RL_PCI_INTLINE);
  199                         /* Reset the power state */
printf("%s: chip is in D%d power mode "
  201                             "-- setting to D0\n", sc->sc_dev.dv_xname,
command & RL_PSTATE_MASK);
command &= RL_PSTATE_MASK;
cardbus_conf_write(cc, cf, csc->sc_tag, pmreg + PCI_PMCSR,
command);
  207                         /* Restore PCI config data */
cardbus_conf_write(cc, cf, csc->sc_tag, RL_PCI_LOIO, iobase);
cardbus_conf_write(cc, cf, csc->sc_tag, RL_PCI_LOMEM, membase);
cardbus_conf_write(cc, cf, csc->sc_tag, RL_PCI_INTLINE, irq);
  211                 }
  212         }
  214         /* Make sure the right access type is on the Cardbus bridge */
  215         (*ct->ct_cf->cardbus_ctrl)(cc, csc->sc_cben);
  216         (*ct->ct_cf->cardbus_ctrl)(cc, CARDBUS_BM_ENABLE);
  218         /* Program the BAR */
cardbus_conf_write(cc, cf, csc->sc_tag, csc->sc_bar_reg, csc->sc_bar_val);
  221         /* Enable proper bits in CARDBUS CSR */
reg = cardbus_conf_read(cc, cf, csc->sc_tag, CARDBUS_COMMAND_STATUS_REG);
reg &= ~(CARDBUS_COMMAND_IO_ENABLE|CARDBUS_COMMAND_MEM_ENABLE);
reg |= csc->sc_csr;
cardbus_conf_write(cc, cf, csc->sc_tag, CARDBUS_COMMAND_STATUS_REG, reg);
  227         /* Make sure the latency timer is set to some reasonable value */
reg = cardbus_conf_read(cc, cf, csc->sc_tag, CARDBUS_BHLC_REG);
  229         if (CARDBUS_LATTIMER(reg) < 0x20) {
reg &= ~(CARDBUS_LATTIMER_MASK << CARDBUS_LATTIMER_SHIFT);
reg |= (0x20 << CARDBUS_LATTIMER_SHIFT);
cardbus_conf_write(cc, cf, csc->sc_tag, CARDBUS_BHLC_REG, reg);
  233         }
  234 }
  236 /*
  237  * Cardbus detach function: deallocate all resources
  238  */
  239 int
re_cardbus_detach(struct device *self, int flags)
  241 {
  242         struct re_cardbus_softc *csc = (void *)self;
  243         struct rl_softc *sc = &csc->sc_rl;
  244         struct cardbus_devfunc *ct = csc->ct;
  245         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
  247         /* Remove timeout handler */
timeout_del(&sc->timer_handle);
  250         /* Detach PHY */
  251         if (LIST_FIRST(&sc->sc_mii.mii_phys) != NULL)
mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);
  254         /* Delete media stuff */
ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);
ether_ifdetach(ifp);
if_detach(ifp);
  259         /* No more hooks */
  260         if (sc->sc_sdhook != NULL)
shutdownhook_disestablish(sc->sc_sdhook);
  262         if (sc->sc_pwrhook != NULL)
powerhook_disestablish(sc->sc_pwrhook);
  265         /* Disable interrupts */
  266         if (csc->sc_ih != NULL)
cardbus_intr_disestablish(ct->ct_cc, ct->ct_cf, csc->sc_ih);
  269         /* Free cardbus resources */
Cardbus_mapreg_unmap(ct, csc->sc_bar_reg, sc->rl_btag, sc->rl_bhandle,
csc->sc_mapsize);
  273         return (0);
  274 }
  276 void
re_cardbus_shutdown(void *arg)
  278 {
  279         struct rl_softc *sc = arg;
  280         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
re_stop(ifp, 1);
  283 }
  285 void
re_cardbus_powerhook(int why, void *arg)
  287 {
  288         struct rl_softc *sc = arg;
  289         struct ifnet *ifp = &sc->sc_arpcom.ac_if;
  291         if (why == PWR_RESUME)
re_init(ifp);
  293 }