root/dev/cardbus/if_ral_cardbus.c

DEFINITIONS

1. ral_cardbus_match
2. ral_cardbus_attach
3. ral_cardbus_detach
4. ral_cardbus_enable
5. ral_cardbus_disable
6. ral_cardbus_power
7. ral_cardbus_setup

    1 /*      $OpenBSD: if_ral_cardbus.c,v 1.9 2006/10/22 12:14:44 damien Exp $  */
    3 /*-
    4  * Copyright (c) 2005, 2006
    5  *      Damien Bergamini <damien.bergamini@free.fr>
    6  *
    7  * Permission to use, copy, modify, and distribute this software for any
    8  * purpose with or without fee is hereby granted, provided that the above
    9  * copyright notice and this permission notice appear in all copies.
   10  *
   11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   18  */
   20 /*
   21  * CardBus front-end for the Ralink RT2560/RT2561/RT2561S/RT2661 driver.
   22  */
   24 #include "bpfilter.h"
   26 #include <sys/param.h>
   27 #include <sys/sockio.h>
   28 #include <sys/mbuf.h>
   29 #include <sys/kernel.h>
   30 #include <sys/socket.h>
   31 #include <sys/systm.h>
   32 #include <sys/malloc.h>
   33 #include <sys/timeout.h>
   34 #include <sys/device.h>
   36 #include <machine/bus.h>
   37 #include <machine/intr.h>
   39 #include <net/if.h>
   40 #include <net/if_dl.h>
   41 #include <net/if_media.h>
   43 #include <netinet/in.h>
   44 #include <netinet/if_ether.h>
   46 #include <net80211/ieee80211_var.h>
   47 #include <net80211/ieee80211_amrr.h>
   48 #include <net80211/ieee80211_radiotap.h>
   50 #include <dev/ic/rt2560var.h>
   51 #include <dev/ic/rt2661var.h>
   53 #include <dev/pci/pcireg.h>
   54 #include <dev/pci/pcivar.h>
   55 #include <dev/pci/pcidevs.h>
   57 #include <dev/cardbus/cardbusvar.h>
   59 static struct ral_opns {
   60         int     (*attach)(void *, int);
   61         int     (*detach)(void *);
   62         int     (*intr)(void *);
   64 }  ral_rt2560_opns = {
rt2560_attach,
rt2560_detach,
rt2560_intr
   69 }, ral_rt2661_opns = {
rt2661_attach,
rt2661_detach,
rt2661_intr
   73 };
   75 struct ral_cardbus_softc {
   76         union {
   77                 struct rt2560_softc     sc_rt2560;
   78                 struct rt2661_softc     sc_rt2661;
   79         } u;
   80 #define sc_sc   u.sc_rt2560
   82         /* cardbus specific goo */
   83         struct ral_opns         *sc_opns;
cardbus_devfunc_t       sc_ct;
cardbustag_t            sc_tag;
   86         void                    *sc_ih;
bus_size_t              sc_mapsize;
pcireg_t                sc_bar_val;
   89         int                     sc_intrline;
   90 };
   92 int     ral_cardbus_match(struct device *, void *, void *);
   93 void    ral_cardbus_attach(struct device *, struct device *, void *);
   94 int     ral_cardbus_detach(struct device *, int);
   96 struct cfattach ral_cardbus_ca = {
   97         sizeof (struct ral_cardbus_softc), ral_cardbus_match,
ral_cardbus_attach, ral_cardbus_detach
   99 };
  101 static const struct cardbus_matchid ral_cardbus_devices[] = {
  102         { PCI_VENDOR_RALINK, PCI_PRODUCT_RALINK_RT2560  },
  103         { PCI_VENDOR_RALINK, PCI_PRODUCT_RALINK_RT2561  },
  104         { PCI_VENDOR_RALINK, PCI_PRODUCT_RALINK_RT2561S },
  105         { PCI_VENDOR_RALINK, PCI_PRODUCT_RALINK_RT2661  }
  106 };
  108 int     ral_cardbus_enable(struct rt2560_softc *);
  109 void    ral_cardbus_disable(struct rt2560_softc *);
  110 void    ral_cardbus_power(struct rt2560_softc *, int);
  111 void    ral_cardbus_setup(struct ral_cardbus_softc *);
  113 int
ral_cardbus_match(struct device *parent, void *match, void *aux)
  115 {
  116         return (cardbus_matchbyid((struct cardbus_attach_args *)aux,
ral_cardbus_devices,
  118             sizeof (ral_cardbus_devices) / sizeof (ral_cardbus_devices[0])));
  119 }
  121 void
ral_cardbus_attach(struct device *parent, struct device *self, void *aux)
  123 {
  124         struct ral_cardbus_softc *csc = (struct ral_cardbus_softc *)self;
  125         struct rt2560_softc *sc = &csc->sc_sc;
  126         struct cardbus_attach_args *ca = aux;
cardbus_devfunc_t ct = ca->ca_ct;
bus_addr_t base;
  129         int error;
csc->sc_opns =
  132             (CARDBUS_PRODUCT(ca->ca_id) == PCI_PRODUCT_RALINK_RT2560) ?
  133             &ral_rt2560_opns : &ral_rt2661_opns;
sc->sc_dmat = ca->ca_dmat;
csc->sc_ct = ct;
csc->sc_tag = ca->ca_tag;
csc->sc_intrline = ca->ca_intrline;
  140         /* power management hooks */
sc->sc_enable = ral_cardbus_enable;
sc->sc_disable = ral_cardbus_disable;
sc->sc_power = ral_cardbus_power;
  145         /* map control/status registers */
error = Cardbus_mapreg_map(ct, CARDBUS_BASE0_REG,
CARDBUS_MAPREG_TYPE_MEM, 0, &sc->sc_st, &sc->sc_sh, &base,
  148             &csc->sc_mapsize);
  149         if (error != 0) {
printf(": could not map memory space\n");
  151                 return;
  152         }
csc->sc_bar_val = base | CARDBUS_MAPREG_TYPE_MEM;
  156         /* set up the PCI configuration registers */
ral_cardbus_setup(csc);
printf(": irq %d", csc->sc_intrline);
  161         (*csc->sc_opns->attach)(sc, CARDBUS_PRODUCT(ca->ca_id));
Cardbus_function_disable(ct);
  164 }
  166 int
ral_cardbus_detach(struct device *self, int flags)
  168 {
  169         struct ral_cardbus_softc *csc = (struct ral_cardbus_softc *)self;
  170         struct rt2560_softc *sc = &csc->sc_sc;
cardbus_devfunc_t ct = csc->sc_ct;
cardbus_chipset_tag_t cc = ct->ct_cc;
cardbus_function_tag_t cf = ct->ct_cf;
  174         int error;
error = (*csc->sc_opns->detach)(sc);
  177         if (error != 0)
  178                 return error;
  180         /* unhook the interrupt handler */
  181         if (csc->sc_ih != NULL) {
cardbus_intr_disestablish(cc, cf, csc->sc_ih);
csc->sc_ih = NULL;
  184         }
  186         /* release bus space and close window */
Cardbus_mapreg_unmap(ct, CARDBUS_BASE0_REG, sc->sc_st, sc->sc_sh,
csc->sc_mapsize);
  190         return 0;
  191 }
  193 int
ral_cardbus_enable(struct rt2560_softc *sc)
  195 {
  196         struct ral_cardbus_softc *csc = (struct ral_cardbus_softc *)sc;
cardbus_devfunc_t ct = csc->sc_ct;
cardbus_chipset_tag_t cc = ct->ct_cc;
cardbus_function_tag_t cf = ct->ct_cf;
  201         /* power on the socket */
Cardbus_function_enable(ct);
  204         /* setup the PCI configuration registers */
ral_cardbus_setup(csc);
  207         /* map and establish the interrupt handler */
csc->sc_ih = cardbus_intr_establish(cc, cf, csc->sc_intrline, IPL_NET,
csc->sc_opns->intr, sc, sc->sc_dev.dv_xname);
  210         if (csc->sc_ih == NULL) {
printf("%s: could not establish interrupt at %d\n",
sc->sc_dev.dv_xname, csc->sc_intrline);
Cardbus_function_disable(ct);
  214                 return 1;
  215         }
  217         return 0;
  218 }
  220 void
ral_cardbus_disable(struct rt2560_softc *sc)
  222 {
  223         struct ral_cardbus_softc *csc = (struct ral_cardbus_softc *)sc;
cardbus_devfunc_t ct = csc->sc_ct;
cardbus_chipset_tag_t cc = ct->ct_cc;
cardbus_function_tag_t cf = ct->ct_cf;
  228         /* unhook the interrupt handler */
cardbus_intr_disestablish(cc, cf, csc->sc_ih);
csc->sc_ih = NULL;
  232         /* power down the socket */
Cardbus_function_disable(ct);
  234 }
  236 void
ral_cardbus_power(struct rt2560_softc *sc, int why)
  238 {
  239         struct ral_cardbus_softc *csc = (struct ral_cardbus_softc *)sc;
  241         if (why == PWR_RESUME) {
  242                 /* kick the PCI configuration registers */
ral_cardbus_setup(csc);
  244         }
  245 }
  247 void
ral_cardbus_setup(struct ral_cardbus_softc *csc)
  249 {
cardbus_devfunc_t ct = csc->sc_ct;
cardbus_chipset_tag_t cc = ct->ct_cc;
cardbus_function_tag_t cf = ct->ct_cf;
pcireg_t reg;
  255         /* program the BAR */
cardbus_conf_write(cc, cf, csc->sc_tag, CARDBUS_BASE0_REG,
csc->sc_bar_val);
  259         /* make sure the right access type is on the cardbus bridge */
  260         (*cf->cardbus_ctrl)(cc, CARDBUS_MEM_ENABLE);
  261         (*cf->cardbus_ctrl)(cc, CARDBUS_BM_ENABLE);
  263         /* enable the appropriate bits in the PCI CSR */
reg = cardbus_conf_read(cc, cf, csc->sc_tag,
CARDBUS_COMMAND_STATUS_REG);
reg |= CARDBUS_COMMAND_MASTER_ENABLE | CARDBUS_COMMAND_MEM_ENABLE;
cardbus_conf_write(cc, cf, csc->sc_tag, CARDBUS_COMMAND_STATUS_REG,
reg);
  269 }