if_ath_cardbus.c revision 1.18.28.2
1 /* $NetBSD: if_ath_cardbus.c,v 1.18.28.2 2007/11/21 21:19:28 bouyer Exp $ */ 2 /* 3 * Copyright (c) 2003 4 * Ichiro FUKUHARA <ichiro (at) ichiro.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 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Ichiro FUKUHARA. 18 * 4. The name of the company nor the name of the author may be used to 19 * endorse or promote products derived from this software without specific 20 * prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY ICHIRO FUKUHARA ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL ICHIRO FUKUHARA OR THE VOICES IN HIS HEAD BE LIABLE FOR 26 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 /* 35 * CardBus bus front-end for the AR5001 Wireless LAN 802.11a/b/g CardBus. 36 */ 37 38 #include <sys/cdefs.h> 39 __KERNEL_RCSID(0, "$NetBSD: if_ath_cardbus.c,v 1.18.28.2 2007/11/21 21:19:28 bouyer Exp $"); 40 41 #include "opt_inet.h" 42 #include "bpfilter.h" 43 44 #include <sys/param.h> 45 #include <sys/systm.h> 46 #include <sys/mbuf.h> 47 #include <sys/malloc.h> 48 #include <sys/kernel.h> 49 #include <sys/socket.h> 50 #include <sys/ioctl.h> 51 #include <sys/errno.h> 52 #include <sys/device.h> 53 54 #include <machine/endian.h> 55 56 #include <net/if.h> 57 #include <net/if_dl.h> 58 #include <net/if_media.h> 59 #include <net/if_ether.h> 60 61 #include <net80211/ieee80211_netbsd.h> 62 #include <net80211/ieee80211_var.h> 63 64 #if NBPFILTER > 0 65 #include <net/bpf.h> 66 #endif 67 68 #ifdef INET 69 #include <netinet/in.h> 70 #include <netinet/if_inarp.h> 71 #endif 72 73 74 #include <sys/bus.h> 75 #include <sys/intr.h> 76 77 #include <dev/mii/miivar.h> 78 #include <dev/mii/mii_bitbang.h> 79 80 #include <dev/ic/ath_netbsd.h> 81 #include <dev/ic/athvar.h> 82 #include <contrib/dev/ath/ah.h> 83 84 #include <dev/pci/pcivar.h> 85 #include <dev/pci/pcireg.h> 86 #include <dev/pci/pcidevs.h> 87 88 #include <dev/cardbus/cardbusvar.h> 89 #include <dev/pci/pcidevs.h> 90 91 /* 92 * PCI configuration space registers 93 */ 94 #define ATH_PCI_MMBA 0x10 /* memory mapped base */ 95 96 struct ath_cardbus_softc { 97 struct ath_softc sc_ath; 98 99 /* CardBus-specific goo. */ 100 void *sc_ih; /* interrupt handle */ 101 cardbus_devfunc_t sc_ct; /* our CardBus devfuncs */ 102 cardbustag_t sc_tag; /* our CardBus tag */ 103 bus_size_t sc_mapsize; /* the size of mapped bus space region */ 104 105 pcireg_t sc_bar_val; /* value of the BAR */ 106 107 int sc_intrline; /* interrupt line */ 108 bus_space_tag_t sc_iot; 109 bus_space_handle_t sc_ioh; 110 void *sc_sdhook; 111 }; 112 113 int ath_cardbus_match(struct device *, struct cfdata *, void *); 114 void ath_cardbus_attach(struct device *, struct device *, void *); 115 int ath_cardbus_detach(struct device *, int); 116 void ath_cardbus_shutdown(void *arg); 117 118 CFATTACH_DECL(ath_cardbus, sizeof(struct ath_cardbus_softc), 119 ath_cardbus_match, ath_cardbus_attach, ath_cardbus_detach, ath_activate); 120 121 void ath_cardbus_setup(struct ath_cardbus_softc *); 122 123 int ath_cardbus_enable(struct ath_softc *); 124 void ath_cardbus_disable(struct ath_softc *); 125 void ath_cardbus_power(struct ath_softc *, int); 126 127 int 128 ath_cardbus_match(struct device *parent, struct cfdata *match, 129 void *aux) 130 { 131 struct cardbus_attach_args *ca = aux; 132 const char* devname; 133 134 devname = ath_hal_probe(PCI_VENDOR(ca->ca_id), 135 PCI_PRODUCT(ca->ca_id)); 136 137 if (devname) 138 return (1); 139 140 return (0); 141 } 142 143 void 144 ath_cardbus_attach(struct device *parent, struct device *self, 145 void *aux) 146 { 147 struct ath_cardbus_softc *csc = device_private(self); 148 struct ath_softc *sc = &csc->sc_ath; 149 struct cardbus_attach_args *ca = aux; 150 cardbus_devfunc_t ct = ca->ca_ct; 151 bus_addr_t adr; 152 153 sc->sc_dmat = ca->ca_dmat; 154 csc->sc_ct = ct; 155 csc->sc_tag = ca->ca_tag; 156 157 printf("\n"); 158 159 /* 160 * Power management hooks. 161 */ 162 sc->sc_enable = ath_cardbus_enable; 163 sc->sc_disable = ath_cardbus_disable; 164 sc->sc_power = ath_cardbus_power; 165 166 csc->sc_sdhook = shutdownhook_establish(ath_cardbus_shutdown, csc); 167 if (csc->sc_sdhook == NULL) { 168 aprint_error("couldn't establish shutdown hook\n"); 169 return; 170 } 171 172 /* 173 * Map the device. 174 */ 175 if (Cardbus_mapreg_map(ct, ATH_PCI_MMBA, CARDBUS_MAPREG_TYPE_MEM, 0, 176 &csc->sc_iot, &csc->sc_ioh, &adr, &csc->sc_mapsize) == 0) { 177 #if rbus 178 #else 179 (*ct->ct_cf->cardbus_mem_open)(cc, 0, adr, adr+csc->sc_mapsize); 180 #endif 181 csc->sc_bar_val = adr | CARDBUS_MAPREG_TYPE_MEM; 182 } 183 184 else { 185 printf("%s: unable to map device registers\n", 186 sc->sc_dev.dv_xname); 187 shutdownhook_disestablish(csc->sc_sdhook); 188 return; 189 } 190 191 sc->sc_st = HALTAG(csc->sc_iot); 192 sc->sc_sh = HALHANDLE(csc->sc_ioh); 193 194 /* 195 * Set up the PCI configuration registers. 196 */ 197 ath_cardbus_setup(csc); 198 199 /* Remember which interrupt line. */ 200 csc->sc_intrline = ca->ca_intrline; 201 202 /* 203 * Finish off the attach. 204 */ 205 ath_attach(PCI_PRODUCT(ca->ca_id), sc); 206 207 /* 208 * Power down the socket. 209 */ 210 Cardbus_function_disable(csc->sc_ct); 211 } 212 213 int 214 ath_cardbus_detach(struct device *self, int flags) 215 { 216 struct ath_cardbus_softc *csc = device_private(self); 217 struct ath_softc *sc = &csc->sc_ath; 218 struct cardbus_devfunc *ct = csc->sc_ct; 219 int rv; 220 221 #if defined(DIAGNOSTIC) 222 if (ct == NULL) 223 panic("%s: data structure lacks", sc->sc_dev.dv_xname); 224 #endif 225 226 shutdownhook_disestablish(csc->sc_sdhook); 227 228 rv = ath_detach(sc); 229 if (rv) 230 return (rv); 231 232 /* 233 * Unhook the interrupt handler. 234 */ 235 if (csc->sc_ih != NULL) 236 cardbus_intr_disestablish(ct->ct_cc, ct->ct_cf, csc->sc_ih); 237 csc->sc_ih = NULL; 238 239 /* 240 * Release bus space and close window. 241 */ 242 Cardbus_mapreg_unmap(ct, ATH_PCI_MMBA, csc->sc_iot, csc->sc_ioh, 243 csc->sc_mapsize); 244 245 return (0); 246 } 247 248 void 249 ath_cardbus_shutdown(void *arg) 250 { 251 struct ath_cardbus_softc *csc; 252 253 csc = arg; 254 255 ath_shutdown(&csc->sc_ath); 256 } 257 258 int 259 ath_cardbus_enable(struct ath_softc *sc) 260 { 261 struct ath_cardbus_softc *csc = (void *) sc; 262 cardbus_devfunc_t ct = csc->sc_ct; 263 cardbus_chipset_tag_t cc = ct->ct_cc; 264 cardbus_function_tag_t cf = ct->ct_cf; 265 266 /* 267 * Power on the socket. 268 */ 269 Cardbus_function_enable(ct); 270 271 /* 272 * Set up the PCI configuration registers. 273 */ 274 ath_cardbus_setup(csc); 275 276 /* 277 * Map and establish the interrupt. 278 */ 279 csc->sc_ih = cardbus_intr_establish(cc, cf, csc->sc_intrline, IPL_NET, 280 ath_intr, sc); 281 if (csc->sc_ih == NULL) { 282 printf("%s: unable to establish interrupt at %d\n", 283 sc->sc_dev.dv_xname, csc->sc_intrline); 284 Cardbus_function_disable(csc->sc_ct); 285 return (1); 286 } 287 printf("%s: interrupting at %d\n", sc->sc_dev.dv_xname, 288 csc->sc_intrline); 289 290 return (0); 291 } 292 293 void 294 ath_cardbus_disable(struct ath_softc *sc) 295 { 296 struct ath_cardbus_softc *csc = (void *) sc; 297 cardbus_devfunc_t ct = csc->sc_ct; 298 cardbus_chipset_tag_t cc = ct->ct_cc; 299 cardbus_function_tag_t cf = ct->ct_cf; 300 301 /* Unhook the interrupt handler. */ 302 cardbus_intr_disestablish(cc, cf, csc->sc_ih); 303 csc->sc_ih = NULL; 304 305 /* Power down the socket. */ 306 Cardbus_function_disable(ct); 307 } 308 309 void 310 ath_cardbus_power(struct ath_softc *sc, int why) 311 { 312 struct ath_cardbus_softc *csc = (void *) sc; 313 314 printf("%s: ath_cardbus_power\n", sc->sc_dev.dv_xname); 315 316 if (why == PWR_RESUME) { 317 /* 318 * Give the PCI configuration registers a kick 319 * in the head. 320 */ 321 #ifdef DIAGNOSTIC 322 if (ATH_IS_ENABLED(sc) == 0) 323 panic("ath_cardbus_power"); 324 #endif 325 ath_cardbus_setup(csc); 326 } 327 } 328 329 void 330 ath_cardbus_setup(struct ath_cardbus_softc *csc) 331 { 332 struct ath_softc *sc = &csc->sc_ath; 333 cardbus_devfunc_t ct = csc->sc_ct; 334 cardbus_chipset_tag_t cc = ct->ct_cc; 335 cardbus_function_tag_t cf = ct->ct_cf; 336 int error; 337 pcireg_t reg; 338 339 if ((error = cardbus_setpowerstate(sc->sc_dev.dv_xname, ct, csc->sc_tag, 340 PCI_PWR_D0)) != 0) 341 aprint_debug("%s: cardbus_setpowerstate %d\n", __func__, error); 342 343 /* Program the BAR. */ 344 cardbus_conf_write(cc, cf, csc->sc_tag, ATH_PCI_MMBA, 345 csc->sc_bar_val); 346 347 /* Make sure the right access type is on the CardBus bridge. */ 348 (*ct->ct_cf->cardbus_ctrl)(cc, CARDBUS_MEM_ENABLE); 349 (*ct->ct_cf->cardbus_ctrl)(cc, CARDBUS_BM_ENABLE); 350 351 /* Enable the appropriate bits in the PCI CSR. */ 352 reg = cardbus_conf_read(cc, cf, csc->sc_tag, 353 CARDBUS_COMMAND_STATUS_REG); 354 reg |= CARDBUS_COMMAND_MASTER_ENABLE | CARDBUS_COMMAND_MEM_ENABLE; 355 cardbus_conf_write(cc, cf, csc->sc_tag, CARDBUS_COMMAND_STATUS_REG, 356 reg); 357 } 358
Indexes created Sat Oct 18 23:09:54 GMT 2025