Annotation of sys/dev/pci/if_wpi.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: if_wpi.c,v 1.50 2007/08/10 16:29:27 jasper Exp $ */
! 2:
! 3: /*-
! 4: * Copyright (c) 2006, 2007
! 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: */
! 19:
! 20: /*
! 21: * Driver for Intel PRO/Wireless 3945ABG 802.11 network adapters.
! 22: */
! 23:
! 24: #include "bpfilter.h"
! 25:
! 26: #include <sys/param.h>
! 27: #include <sys/sockio.h>
! 28: #include <sys/sysctl.h>
! 29: #include <sys/mbuf.h>
! 30: #include <sys/kernel.h>
! 31: #include <sys/socket.h>
! 32: #include <sys/systm.h>
! 33: #include <sys/malloc.h>
! 34: #include <sys/conf.h>
! 35: #include <sys/device.h>
! 36: #include <sys/sensors.h>
! 37:
! 38: #include <machine/bus.h>
! 39: #include <machine/endian.h>
! 40: #include <machine/intr.h>
! 41:
! 42: #include <dev/pci/pcireg.h>
! 43: #include <dev/pci/pcivar.h>
! 44: #include <dev/pci/pcidevs.h>
! 45:
! 46: #if NBPFILTER > 0
! 47: #include <net/bpf.h>
! 48: #endif
! 49: #include <net/if.h>
! 50: #include <net/if_arp.h>
! 51: #include <net/if_dl.h>
! 52: #include <net/if_media.h>
! 53: #include <net/if_types.h>
! 54:
! 55: #include <netinet/in.h>
! 56: #include <netinet/in_systm.h>
! 57: #include <netinet/in_var.h>
! 58: #include <netinet/if_ether.h>
! 59: #include <netinet/ip.h>
! 60:
! 61: #include <net80211/ieee80211_var.h>
! 62: #include <net80211/ieee80211_amrr.h>
! 63: #include <net80211/ieee80211_radiotap.h>
! 64:
! 65: #include <dev/pci/if_wpireg.h>
! 66: #include <dev/pci/if_wpivar.h>
! 67:
! 68: static const struct pci_matchid wpi_devices[] = {
! 69: { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_PRO_WL_3945ABG_1 },
! 70: { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_PRO_WL_3945ABG_2 }
! 71: };
! 72:
! 73: int wpi_match(struct device *, void *, void *);
! 74: void wpi_attach(struct device *, struct device *, void *);
! 75: void wpi_power(int, void *);
! 76: int wpi_dma_contig_alloc(bus_dma_tag_t, struct wpi_dma_info *,
! 77: void **, bus_size_t, bus_size_t, int);
! 78: void wpi_dma_contig_free(struct wpi_dma_info *);
! 79: int wpi_alloc_shared(struct wpi_softc *);
! 80: void wpi_free_shared(struct wpi_softc *);
! 81: int wpi_alloc_fwmem(struct wpi_softc *);
! 82: void wpi_free_fwmem(struct wpi_softc *);
! 83: struct wpi_rbuf *wpi_alloc_rbuf(struct wpi_softc *);
! 84: void wpi_free_rbuf(caddr_t, u_int, void *);
! 85: int wpi_alloc_rpool(struct wpi_softc *);
! 86: void wpi_free_rpool(struct wpi_softc *);
! 87: int wpi_alloc_rx_ring(struct wpi_softc *, struct wpi_rx_ring *);
! 88: void wpi_reset_rx_ring(struct wpi_softc *, struct wpi_rx_ring *);
! 89: void wpi_free_rx_ring(struct wpi_softc *, struct wpi_rx_ring *);
! 90: int wpi_alloc_tx_ring(struct wpi_softc *, struct wpi_tx_ring *,
! 91: int, int);
! 92: void wpi_reset_tx_ring(struct wpi_softc *, struct wpi_tx_ring *);
! 93: void wpi_free_tx_ring(struct wpi_softc *, struct wpi_tx_ring *);
! 94: struct ieee80211_node *wpi_node_alloc(struct ieee80211com *);
! 95: void wpi_newassoc(struct ieee80211com *, struct ieee80211_node *,
! 96: int);
! 97: int wpi_media_change(struct ifnet *);
! 98: int wpi_newstate(struct ieee80211com *, enum ieee80211_state, int);
! 99: void wpi_mem_lock(struct wpi_softc *);
! 100: void wpi_mem_unlock(struct wpi_softc *);
! 101: uint32_t wpi_mem_read(struct wpi_softc *, uint16_t);
! 102: void wpi_mem_write(struct wpi_softc *, uint16_t, uint32_t);
! 103: void wpi_mem_write_region_4(struct wpi_softc *, uint16_t,
! 104: const uint32_t *, int);
! 105: int wpi_read_prom_data(struct wpi_softc *, uint32_t, void *, int);
! 106: int wpi_load_microcode(struct wpi_softc *, const uint8_t *, int);
! 107: int wpi_load_firmware(struct wpi_softc *);
! 108: void wpi_calib_timeout(void *);
! 109: void wpi_iter_func(void *, struct ieee80211_node *);
! 110: void wpi_power_calibration(struct wpi_softc *, int);
! 111: void wpi_rx_intr(struct wpi_softc *, struct wpi_rx_desc *,
! 112: struct wpi_rx_data *);
! 113: void wpi_tx_intr(struct wpi_softc *, struct wpi_rx_desc *);
! 114: void wpi_cmd_intr(struct wpi_softc *, struct wpi_rx_desc *);
! 115: void wpi_notif_intr(struct wpi_softc *);
! 116: int wpi_intr(void *);
! 117: void wpi_read_eeprom(struct wpi_softc *);
! 118: void wpi_read_eeprom_channels(struct wpi_softc *, int);
! 119: void wpi_read_eeprom_group(struct wpi_softc *, int);
! 120: uint8_t wpi_plcp_signal(int);
! 121: int wpi_tx_data(struct wpi_softc *, struct mbuf *,
! 122: struct ieee80211_node *, int);
! 123: void wpi_start(struct ifnet *);
! 124: void wpi_watchdog(struct ifnet *);
! 125: int wpi_ioctl(struct ifnet *, u_long, caddr_t);
! 126: int wpi_cmd(struct wpi_softc *, int, const void *, int, int);
! 127: int wpi_mrr_setup(struct wpi_softc *);
! 128: void wpi_set_led(struct wpi_softc *, uint8_t, uint8_t, uint8_t);
! 129: void wpi_enable_tsf(struct wpi_softc *, struct ieee80211_node *);
! 130: int wpi_set_txpower(struct wpi_softc *,
! 131: struct ieee80211_channel *, int);
! 132: int wpi_get_power_index(struct wpi_softc *,
! 133: struct wpi_power_group *, struct ieee80211_channel *, int);
! 134: #ifdef notyet
! 135: int wpi_setup_beacon(struct wpi_softc *, struct ieee80211_node *);
! 136: #endif
! 137: int wpi_auth(struct wpi_softc *);
! 138: int wpi_scan(struct wpi_softc *, uint16_t);
! 139: int wpi_config(struct wpi_softc *);
! 140: void wpi_stop_master(struct wpi_softc *);
! 141: int wpi_power_up(struct wpi_softc *);
! 142: int wpi_reset(struct wpi_softc *);
! 143: void wpi_hw_config(struct wpi_softc *);
! 144: int wpi_init(struct ifnet *);
! 145: void wpi_stop(struct ifnet *, int);
! 146:
! 147: #ifdef WPI_DEBUG
! 148: #define DPRINTF(x) do { if (wpi_debug > 0) printf x; } while (0)
! 149: #define DPRINTFN(n, x) do { if (wpi_debug >= (n)) printf x; } while (0)
! 150: int wpi_debug = 1;
! 151: #else
! 152: #define DPRINTF(x)
! 153: #define DPRINTFN(n, x)
! 154: #endif
! 155:
! 156: struct cfattach wpi_ca = {
! 157: sizeof (struct wpi_softc), wpi_match, wpi_attach
! 158: };
! 159:
! 160: int
! 161: wpi_match(struct device *parent, void *match, void *aux)
! 162: {
! 163: return pci_matchbyid((struct pci_attach_args *)aux, wpi_devices,
! 164: sizeof (wpi_devices) / sizeof (wpi_devices[0]));
! 165: }
! 166:
! 167: /* Base Address Register */
! 168: #define WPI_PCI_BAR0 0x10
! 169:
! 170: void
! 171: wpi_attach(struct device *parent, struct device *self, void *aux)
! 172: {
! 173: struct wpi_softc *sc = (struct wpi_softc *)self;
! 174: struct ieee80211com *ic = &sc->sc_ic;
! 175: struct ifnet *ifp = &ic->ic_if;
! 176: struct pci_attach_args *pa = aux;
! 177: const char *intrstr;
! 178: bus_space_tag_t memt;
! 179: bus_space_handle_t memh;
! 180: pci_intr_handle_t ih;
! 181: pcireg_t data;
! 182: int ac, error;
! 183:
! 184: sc->sc_pct = pa->pa_pc;
! 185: sc->sc_pcitag = pa->pa_tag;
! 186:
! 187: /* clear device specific PCI configuration register 0x41 */
! 188: data = pci_conf_read(sc->sc_pct, sc->sc_pcitag, 0x40);
! 189: data &= ~0x0000ff00;
! 190: pci_conf_write(sc->sc_pct, sc->sc_pcitag, 0x40, data);
! 191:
! 192: /* map the register window */
! 193: error = pci_mapreg_map(pa, WPI_PCI_BAR0, PCI_MAPREG_TYPE_MEM |
! 194: PCI_MAPREG_MEM_TYPE_32BIT, 0, &memt, &memh, NULL, &sc->sc_sz, 0);
! 195: if (error != 0) {
! 196: printf(": could not map memory space\n");
! 197: return;
! 198: }
! 199:
! 200: sc->sc_st = memt;
! 201: sc->sc_sh = memh;
! 202: sc->sc_dmat = pa->pa_dmat;
! 203:
! 204: if (pci_intr_map(pa, &ih) != 0) {
! 205: printf(": could not map interrupt\n");
! 206: return;
! 207: }
! 208:
! 209: intrstr = pci_intr_string(sc->sc_pct, ih);
! 210: sc->sc_ih = pci_intr_establish(sc->sc_pct, ih, IPL_NET, wpi_intr, sc,
! 211: sc->sc_dev.dv_xname);
! 212: if (sc->sc_ih == NULL) {
! 213: printf(": could not establish interrupt");
! 214: if (intrstr != NULL)
! 215: printf(" at %s", intrstr);
! 216: printf("\n");
! 217: return;
! 218: }
! 219: printf(": %s", intrstr);
! 220:
! 221: /*
! 222: * Put adapter into a known state.
! 223: */
! 224: if ((error = wpi_reset(sc)) != 0) {
! 225: printf(": could not reset adapter\n");
! 226: return;
! 227: }
! 228:
! 229: /*
! 230: * Allocate DMA memory for firmware transfers.
! 231: */
! 232: if ((error = wpi_alloc_fwmem(sc)) != 0) {
! 233: printf(": could not allocate firmware memory\n");
! 234: return;
! 235: }
! 236:
! 237: /*
! 238: * Allocate shared page and Tx/Rx rings.
! 239: */
! 240: if ((error = wpi_alloc_shared(sc)) != 0) {
! 241: printf(": could not allocate shared area\n");
! 242: goto fail1;
! 243: }
! 244:
! 245: if ((error = wpi_alloc_rpool(sc)) != 0) {
! 246: printf(": could not allocate Rx buffers\n");
! 247: goto fail2;
! 248: }
! 249:
! 250: for (ac = 0; ac < 4; ac++) {
! 251: error = wpi_alloc_tx_ring(sc, &sc->txq[ac], WPI_TX_RING_COUNT,
! 252: ac);
! 253: if (error != 0) {
! 254: printf(": could not allocate Tx ring %d\n", ac);
! 255: goto fail3;
! 256: }
! 257: }
! 258:
! 259: error = wpi_alloc_tx_ring(sc, &sc->cmdq, WPI_CMD_RING_COUNT, 4);
! 260: if (error != 0) {
! 261: printf(": could not allocate command ring\n");
! 262: goto fail3;
! 263: }
! 264:
! 265: error = wpi_alloc_rx_ring(sc, &sc->rxq);
! 266: if (error != 0) {
! 267: printf(": could not allocate Rx ring\n");
! 268: goto fail4;
! 269: }
! 270:
! 271: ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
! 272: ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */
! 273: ic->ic_state = IEEE80211_S_INIT;
! 274:
! 275: /* set device capabilities */
! 276: ic->ic_caps =
! 277: IEEE80211_C_WEP | /* s/w WEP */
! 278: IEEE80211_C_MONITOR | /* monitor mode supported */
! 279: IEEE80211_C_TXPMGT | /* tx power management */
! 280: IEEE80211_C_SHSLOT | /* short slot time supported */
! 281: IEEE80211_C_SHPREAMBLE; /* short preamble supported */
! 282:
! 283: /* read supported channels and MAC address from EEPROM */
! 284: wpi_read_eeprom(sc);
! 285:
! 286: /* set supported .11a, .11b and .11g rates */
! 287: ic->ic_sup_rates[IEEE80211_MODE_11A] = ieee80211_std_rateset_11a;
! 288: ic->ic_sup_rates[IEEE80211_MODE_11B] = ieee80211_std_rateset_11b;
! 289: ic->ic_sup_rates[IEEE80211_MODE_11G] = ieee80211_std_rateset_11g;
! 290:
! 291: /* IBSS channel undefined for now */
! 292: ic->ic_ibss_chan = &ic->ic_channels[0];
! 293:
! 294: ifp->if_softc = sc;
! 295: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
! 296: ifp->if_init = wpi_init;
! 297: ifp->if_ioctl = wpi_ioctl;
! 298: ifp->if_start = wpi_start;
! 299: ifp->if_watchdog = wpi_watchdog;
! 300: IFQ_SET_READY(&ifp->if_snd);
! 301: memcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ);
! 302:
! 303: if_attach(ifp);
! 304: ieee80211_ifattach(ifp);
! 305: ic->ic_node_alloc = wpi_node_alloc;
! 306: ic->ic_newassoc = wpi_newassoc;
! 307:
! 308: /* override state transition machine */
! 309: sc->sc_newstate = ic->ic_newstate;
! 310: ic->ic_newstate = wpi_newstate;
! 311: ieee80211_media_init(ifp, wpi_media_change, ieee80211_media_status);
! 312:
! 313: sc->amrr.amrr_min_success_threshold = 1;
! 314: sc->amrr.amrr_max_success_threshold = 15;
! 315:
! 316: /* register thermal sensor with the sensor framework */
! 317: strlcpy(sc->sensordev.xname, sc->sc_dev.dv_xname,
! 318: sizeof sc->sensordev.xname);
! 319: strlcpy(sc->sensor.desc, "temperature 0 - 285",
! 320: sizeof sc->sensor.desc);
! 321: sc->sensor.type = SENSOR_INTEGER; /* not in muK! */
! 322: /* temperature invalid until interface is up */
! 323: sc->sensor.value = 0;
! 324: sc->sensor.flags = SENSOR_FINVALID;
! 325: sensor_attach(&sc->sensordev, &sc->sensor);
! 326: sensordev_install(&sc->sensordev);
! 327:
! 328: timeout_set(&sc->calib_to, wpi_calib_timeout, sc);
! 329:
! 330: sc->powerhook = powerhook_establish(wpi_power, sc);
! 331:
! 332: #if NBPFILTER > 0
! 333: bpfattach(&sc->sc_drvbpf, ifp, DLT_IEEE802_11_RADIO,
! 334: sizeof (struct ieee80211_frame) + IEEE80211_RADIOTAP_HDRLEN);
! 335:
! 336: sc->sc_rxtap_len = sizeof sc->sc_rxtapu;
! 337: sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len);
! 338: sc->sc_rxtap.wr_ihdr.it_present = htole32(WPI_RX_RADIOTAP_PRESENT);
! 339:
! 340: sc->sc_txtap_len = sizeof sc->sc_txtapu;
! 341: sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len);
! 342: sc->sc_txtap.wt_ihdr.it_present = htole32(WPI_TX_RADIOTAP_PRESENT);
! 343: #endif
! 344:
! 345: return;
! 346:
! 347: /* free allocated memory if something failed during attachment */
! 348: fail4: wpi_free_tx_ring(sc, &sc->cmdq);
! 349: fail3: while (--ac >= 0)
! 350: wpi_free_tx_ring(sc, &sc->txq[ac]);
! 351: wpi_free_rpool(sc);
! 352: fail2: wpi_free_shared(sc);
! 353: fail1: wpi_free_fwmem(sc);
! 354: }
! 355:
! 356: void
! 357: wpi_power(int why, void *arg)
! 358: {
! 359: struct wpi_softc *sc = arg;
! 360: struct ifnet *ifp;
! 361: pcireg_t data;
! 362: int s;
! 363:
! 364: if (why != PWR_RESUME)
! 365: return;
! 366:
! 367: /* clear device specific PCI configuration register 0x41 */
! 368: data = pci_conf_read(sc->sc_pct, sc->sc_pcitag, 0x40);
! 369: data &= ~0x0000ff00;
! 370: pci_conf_write(sc->sc_pct, sc->sc_pcitag, 0x40, data);
! 371:
! 372: s = splnet();
! 373: ifp = &sc->sc_ic.ic_if;
! 374: if (ifp->if_flags & IFF_UP) {
! 375: ifp->if_init(ifp);
! 376: if (ifp->if_flags & IFF_RUNNING)
! 377: ifp->if_start(ifp);
! 378: }
! 379: splx(s);
! 380: }
! 381:
! 382: int
! 383: wpi_dma_contig_alloc(bus_dma_tag_t tag, struct wpi_dma_info *dma, void **kvap,
! 384: bus_size_t size, bus_size_t alignment, int flags)
! 385: {
! 386: int nsegs, error;
! 387:
! 388: dma->tag = tag;
! 389: dma->size = size;
! 390:
! 391: error = bus_dmamap_create(tag, size, 1, size, 0, flags, &dma->map);
! 392: if (error != 0)
! 393: goto fail;
! 394:
! 395: error = bus_dmamem_alloc(tag, size, alignment, 0, &dma->seg, 1, &nsegs,
! 396: flags);
! 397: if (error != 0)
! 398: goto fail;
! 399:
! 400: error = bus_dmamem_map(tag, &dma->seg, 1, size, &dma->vaddr, flags);
! 401: if (error != 0)
! 402: goto fail;
! 403:
! 404: error = bus_dmamap_load_raw(tag, dma->map, &dma->seg, 1, size, flags);
! 405: if (error != 0)
! 406: goto fail;
! 407:
! 408: memset(dma->vaddr, 0, size);
! 409:
! 410: dma->paddr = dma->map->dm_segs[0].ds_addr;
! 411: if (kvap != NULL)
! 412: *kvap = dma->vaddr;
! 413:
! 414: return 0;
! 415:
! 416: fail: wpi_dma_contig_free(dma);
! 417: return error;
! 418: }
! 419:
! 420: void
! 421: wpi_dma_contig_free(struct wpi_dma_info *dma)
! 422: {
! 423: if (dma->map != NULL) {
! 424: if (dma->vaddr != NULL) {
! 425: bus_dmamap_unload(dma->tag, dma->map);
! 426: bus_dmamem_unmap(dma->tag, dma->vaddr, dma->size);
! 427: bus_dmamem_free(dma->tag, &dma->seg, 1);
! 428: dma->vaddr = NULL;
! 429: }
! 430: bus_dmamap_destroy(dma->tag, dma->map);
! 431: dma->map = NULL;
! 432: }
! 433: }
! 434:
! 435: /*
! 436: * Allocate a shared page between host and NIC.
! 437: */
! 438: int
! 439: wpi_alloc_shared(struct wpi_softc *sc)
! 440: {
! 441: /* must be aligned on a 4K-page boundary */
! 442: return wpi_dma_contig_alloc(sc->sc_dmat, &sc->shared_dma,
! 443: (void **)&sc->shared, sizeof (struct wpi_shared), PAGE_SIZE,
! 444: BUS_DMA_NOWAIT);
! 445: }
! 446:
! 447: void
! 448: wpi_free_shared(struct wpi_softc *sc)
! 449: {
! 450: wpi_dma_contig_free(&sc->shared_dma);
! 451: }
! 452:
! 453: /*
! 454: * Allocate DMA-safe memory for firmware transfer.
! 455: */
! 456: int
! 457: wpi_alloc_fwmem(struct wpi_softc *sc)
! 458: {
! 459: /* allocate enough contiguous space to store text and data */
! 460: return wpi_dma_contig_alloc(sc->sc_dmat, &sc->fw_dma, NULL,
! 461: WPI_FW_MAIN_TEXT_MAXSZ + WPI_FW_MAIN_DATA_MAXSZ, 0,
! 462: BUS_DMA_NOWAIT);
! 463: }
! 464:
! 465: void
! 466: wpi_free_fwmem(struct wpi_softc *sc)
! 467: {
! 468: wpi_dma_contig_free(&sc->fw_dma);
! 469: }
! 470:
! 471: struct wpi_rbuf *
! 472: wpi_alloc_rbuf(struct wpi_softc *sc)
! 473: {
! 474: struct wpi_rbuf *rbuf;
! 475:
! 476: rbuf = SLIST_FIRST(&sc->rxq.freelist);
! 477: if (rbuf == NULL)
! 478: return NULL;
! 479: SLIST_REMOVE_HEAD(&sc->rxq.freelist, next);
! 480: return rbuf;
! 481: }
! 482:
! 483: /*
! 484: * This is called automatically by the network stack when the mbuf to which our
! 485: * Rx buffer is attached is freed.
! 486: */
! 487: void
! 488: wpi_free_rbuf(caddr_t buf, u_int size, void *arg)
! 489: {
! 490: struct wpi_rbuf *rbuf = arg;
! 491: struct wpi_softc *sc = rbuf->sc;
! 492:
! 493: /* put the buffer back in the free list */
! 494: SLIST_INSERT_HEAD(&sc->rxq.freelist, rbuf, next);
! 495: }
! 496:
! 497: int
! 498: wpi_alloc_rpool(struct wpi_softc *sc)
! 499: {
! 500: struct wpi_rx_ring *ring = &sc->rxq;
! 501: int i, error;
! 502:
! 503: /* allocate a big chunk of DMA'able memory.. */
! 504: error = wpi_dma_contig_alloc(sc->sc_dmat, &ring->buf_dma, NULL,
! 505: WPI_RBUF_COUNT * WPI_RBUF_SIZE, PAGE_SIZE, BUS_DMA_NOWAIT);
! 506: if (error != 0) {
! 507: printf("%s: could not allocate Rx buffers DMA memory\n",
! 508: sc->sc_dev.dv_xname);
! 509: return error;
! 510: }
! 511:
! 512: /* ..and split it into 3KB chunks */
! 513: SLIST_INIT(&ring->freelist);
! 514: for (i = 0; i < WPI_RBUF_COUNT; i++) {
! 515: struct wpi_rbuf *rbuf = &ring->rbuf[i];
! 516:
! 517: rbuf->sc = sc; /* backpointer for callbacks */
! 518: rbuf->vaddr = ring->buf_dma.vaddr + i * WPI_RBUF_SIZE;
! 519: rbuf->paddr = ring->buf_dma.paddr + i * WPI_RBUF_SIZE;
! 520:
! 521: SLIST_INSERT_HEAD(&ring->freelist, rbuf, next);
! 522: }
! 523: return 0;
! 524: }
! 525:
! 526: void
! 527: wpi_free_rpool(struct wpi_softc *sc)
! 528: {
! 529: wpi_dma_contig_free(&sc->rxq.buf_dma);
! 530: }
! 531:
! 532: int
! 533: wpi_alloc_rx_ring(struct wpi_softc *sc, struct wpi_rx_ring *ring)
! 534: {
! 535: int i, error;
! 536:
! 537: ring->cur = 0;
! 538:
! 539: error = wpi_dma_contig_alloc(sc->sc_dmat, &ring->desc_dma,
! 540: (void **)&ring->desc, WPI_RX_RING_COUNT * sizeof (uint32_t),
! 541: WPI_RING_DMA_ALIGN, BUS_DMA_NOWAIT);
! 542: if (error != 0) {
! 543: printf("%s: could not allocate rx ring DMA memory\n",
! 544: sc->sc_dev.dv_xname);
! 545: goto fail;
! 546: }
! 547:
! 548: /*
! 549: * Setup Rx buffers.
! 550: */
! 551: for (i = 0; i < WPI_RX_RING_COUNT; i++) {
! 552: struct wpi_rx_data *data = &ring->data[i];
! 553: struct wpi_rbuf *rbuf;
! 554:
! 555: MGETHDR(data->m, M_DONTWAIT, MT_DATA);
! 556: if (data->m == NULL) {
! 557: printf("%s: could not allocate rx mbuf\n",
! 558: sc->sc_dev.dv_xname);
! 559: error = ENOMEM;
! 560: goto fail;
! 561: }
! 562: if ((rbuf = wpi_alloc_rbuf(sc)) == NULL) {
! 563: m_freem(data->m);
! 564: data->m = NULL;
! 565: printf("%s: could not allocate rx buffer\n",
! 566: sc->sc_dev.dv_xname);
! 567: error = ENOMEM;
! 568: goto fail;
! 569: }
! 570: /* attach Rx buffer to mbuf */
! 571: MEXTADD(data->m, rbuf->vaddr, WPI_RBUF_SIZE, 0, wpi_free_rbuf,
! 572: rbuf);
! 573:
! 574: ring->desc[i] = htole32(rbuf->paddr);
! 575: }
! 576:
! 577: return 0;
! 578:
! 579: fail: wpi_free_rx_ring(sc, ring);
! 580: return error;
! 581: }
! 582:
! 583: void
! 584: wpi_reset_rx_ring(struct wpi_softc *sc, struct wpi_rx_ring *ring)
! 585: {
! 586: int ntries;
! 587:
! 588: wpi_mem_lock(sc);
! 589:
! 590: WPI_WRITE(sc, WPI_RX_CONFIG, 0);
! 591: for (ntries = 0; ntries < 100; ntries++) {
! 592: if (WPI_READ(sc, WPI_RX_STATUS) & WPI_RX_IDLE)
! 593: break;
! 594: DELAY(10);
! 595: }
! 596: #ifdef WPI_DEBUG
! 597: if (ntries == 100 && wpi_debug > 0)
! 598: printf("%s: timeout resetting Rx ring\n", sc->sc_dev.dv_xname);
! 599: #endif
! 600: wpi_mem_unlock(sc);
! 601:
! 602: ring->cur = 0;
! 603: }
! 604:
! 605: void
! 606: wpi_free_rx_ring(struct wpi_softc *sc, struct wpi_rx_ring *ring)
! 607: {
! 608: int i;
! 609:
! 610: wpi_dma_contig_free(&ring->desc_dma);
! 611:
! 612: for (i = 0; i < WPI_RX_RING_COUNT; i++) {
! 613: if (ring->data[i].m != NULL)
! 614: m_freem(ring->data[i].m);
! 615: }
! 616: }
! 617:
! 618: int
! 619: wpi_alloc_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring, int count,
! 620: int qid)
! 621: {
! 622: int i, error;
! 623:
! 624: ring->qid = qid;
! 625: ring->count = count;
! 626: ring->queued = 0;
! 627: ring->cur = 0;
! 628:
! 629: error = wpi_dma_contig_alloc(sc->sc_dmat, &ring->desc_dma,
! 630: (void **)&ring->desc, count * sizeof (struct wpi_tx_desc),
! 631: WPI_RING_DMA_ALIGN, BUS_DMA_NOWAIT);
! 632: if (error != 0) {
! 633: printf("%s: could not allocate tx ring DMA memory\n",
! 634: sc->sc_dev.dv_xname);
! 635: goto fail;
! 636: }
! 637:
! 638: /* update shared page with ring's base address */
! 639: sc->shared->txbase[qid] = htole32(ring->desc_dma.paddr);
! 640:
! 641: error = wpi_dma_contig_alloc(sc->sc_dmat, &ring->cmd_dma,
! 642: (void **)&ring->cmd, count * sizeof (struct wpi_tx_cmd), 4,
! 643: BUS_DMA_NOWAIT);
! 644: if (error != 0) {
! 645: printf("%s: could not allocate tx cmd DMA memory\n",
! 646: sc->sc_dev.dv_xname);
! 647: goto fail;
! 648: }
! 649:
! 650: ring->data = malloc(count * sizeof (struct wpi_tx_data), M_DEVBUF,
! 651: M_NOWAIT);
! 652: if (ring->data == NULL) {
! 653: printf("%s: could not allocate tx data slots\n",
! 654: sc->sc_dev.dv_xname);
! 655: goto fail;
! 656: }
! 657:
! 658: memset(ring->data, 0, count * sizeof (struct wpi_tx_data));
! 659:
! 660: for (i = 0; i < count; i++) {
! 661: struct wpi_tx_data *data = &ring->data[i];
! 662:
! 663: error = bus_dmamap_create(sc->sc_dmat, MCLBYTES,
! 664: WPI_MAX_SCATTER - 1, MCLBYTES, 0, BUS_DMA_NOWAIT,
! 665: &data->map);
! 666: if (error != 0) {
! 667: printf("%s: could not create tx buf DMA map\n",
! 668: sc->sc_dev.dv_xname);
! 669: goto fail;
! 670: }
! 671: }
! 672:
! 673: return 0;
! 674:
! 675: fail: wpi_free_tx_ring(sc, ring);
! 676: return error;
! 677: }
! 678:
! 679: void
! 680: wpi_reset_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring)
! 681: {
! 682: int i, ntries;
! 683:
! 684: wpi_mem_lock(sc);
! 685:
! 686: WPI_WRITE(sc, WPI_TX_CONFIG(ring->qid), 0);
! 687: for (ntries = 0; ntries < 100; ntries++) {
! 688: if (WPI_READ(sc, WPI_TX_STATUS) & WPI_TX_IDLE(ring->qid))
! 689: break;
! 690: DELAY(10);
! 691: }
! 692: #ifdef WPI_DEBUG
! 693: if (ntries == 100 && wpi_debug > 0) {
! 694: printf("%s: timeout resetting Tx ring %d\n",
! 695: sc->sc_dev.dv_xname, ring->qid);
! 696: }
! 697: #endif
! 698: wpi_mem_unlock(sc);
! 699:
! 700: for (i = 0; i < ring->count; i++) {
! 701: struct wpi_tx_data *data = &ring->data[i];
! 702:
! 703: if (data->m != NULL) {
! 704: bus_dmamap_unload(sc->sc_dmat, data->map);
! 705: m_freem(data->m);
! 706: data->m = NULL;
! 707: }
! 708: }
! 709:
! 710: ring->queued = 0;
! 711: ring->cur = 0;
! 712: }
! 713:
! 714: void
! 715: wpi_free_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring)
! 716: {
! 717: int i;
! 718:
! 719: wpi_dma_contig_free(&ring->desc_dma);
! 720: wpi_dma_contig_free(&ring->cmd_dma);
! 721:
! 722: if (ring->data != NULL) {
! 723: for (i = 0; i < ring->count; i++) {
! 724: struct wpi_tx_data *data = &ring->data[i];
! 725:
! 726: if (data->m != NULL) {
! 727: bus_dmamap_unload(sc->sc_dmat, data->map);
! 728: m_freem(data->m);
! 729: }
! 730: }
! 731: free(ring->data, M_DEVBUF);
! 732: }
! 733: }
! 734:
! 735: struct ieee80211_node *
! 736: wpi_node_alloc(struct ieee80211com *ic)
! 737: {
! 738: struct wpi_node *wn;
! 739:
! 740: wn = malloc(sizeof (struct wpi_node), M_DEVBUF, M_NOWAIT);
! 741: if (wn != NULL)
! 742: memset(wn, 0, sizeof (struct wpi_node));
! 743: return (struct ieee80211_node *)wn;
! 744: }
! 745:
! 746: void
! 747: wpi_newassoc(struct ieee80211com *ic, struct ieee80211_node *ni, int isnew)
! 748: {
! 749: struct wpi_softc *sc = ic->ic_if.if_softc;
! 750: int i;
! 751:
! 752: ieee80211_amrr_node_init(&sc->amrr, &((struct wpi_node *)ni)->amn);
! 753:
! 754: /* set rate to some reasonable initial value */
! 755: for (i = ni->ni_rates.rs_nrates - 1;
! 756: i > 0 && (ni->ni_rates.rs_rates[i] & IEEE80211_RATE_VAL) > 72;
! 757: i--);
! 758: ni->ni_txrate = i;
! 759: }
! 760:
! 761: int
! 762: wpi_media_change(struct ifnet *ifp)
! 763: {
! 764: int error;
! 765:
! 766: error = ieee80211_media_change(ifp);
! 767: if (error != ENETRESET)
! 768: return error;
! 769:
! 770: if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING))
! 771: wpi_init(ifp);
! 772:
! 773: return 0;
! 774: }
! 775:
! 776: int
! 777: wpi_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
! 778: {
! 779: struct ifnet *ifp = &ic->ic_if;
! 780: struct wpi_softc *sc = ifp->if_softc;
! 781: struct ieee80211_node *ni;
! 782: int error;
! 783:
! 784: timeout_del(&sc->calib_to);
! 785:
! 786: if (ic->ic_state == IEEE80211_S_SCAN)
! 787: ic->ic_scan_lock = IEEE80211_SCAN_UNLOCKED;
! 788:
! 789: switch (nstate) {
! 790: case IEEE80211_S_SCAN:
! 791: /* make the link LED blink while we're scanning */
! 792: wpi_set_led(sc, WPI_LED_LINK, 20, 2);
! 793:
! 794: if ((error = wpi_scan(sc, IEEE80211_CHAN_G)) != 0) {
! 795: printf("%s: could not initiate scan\n",
! 796: sc->sc_dev.dv_xname);
! 797: return error;
! 798: }
! 799: ic->ic_state = nstate;
! 800: return 0;
! 801:
! 802: case IEEE80211_S_ASSOC:
! 803: if (ic->ic_state != IEEE80211_S_RUN)
! 804: break;
! 805: /* FALLTHROUGH */
! 806: case IEEE80211_S_AUTH:
! 807: /* reset state to handle reassociations correctly */
! 808: sc->config.associd = 0;
! 809: sc->config.filter &= ~htole32(WPI_FILTER_BSS);
! 810:
! 811: if ((error = wpi_auth(sc)) != 0) {
! 812: printf("%s: could not send authentication request\n",
! 813: sc->sc_dev.dv_xname);
! 814: return error;
! 815: }
! 816: break;
! 817:
! 818: case IEEE80211_S_RUN:
! 819: if (ic->ic_opmode == IEEE80211_M_MONITOR) {
! 820: /* link LED blinks while monitoring */
! 821: wpi_set_led(sc, WPI_LED_LINK, 5, 5);
! 822: break;
! 823: }
! 824: ni = ic->ic_bss;
! 825:
! 826: wpi_enable_tsf(sc, ni);
! 827:
! 828: /* update adapter's configuration */
! 829: sc->config.associd = htole16(ni->ni_associd & ~0xc000);
! 830: /* short preamble/slot time are negotiated when associating */
! 831: sc->config.flags &= ~htole32(WPI_CONFIG_SHPREAMBLE |
! 832: WPI_CONFIG_SHSLOT);
! 833: if (ic->ic_flags & IEEE80211_F_SHSLOT)
! 834: sc->config.flags |= htole32(WPI_CONFIG_SHSLOT);
! 835: if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
! 836: sc->config.flags |= htole32(WPI_CONFIG_SHPREAMBLE);
! 837: sc->config.filter |= htole32(WPI_FILTER_BSS);
! 838:
! 839: DPRINTF(("config chan %d flags %x\n", sc->config.chan,
! 840: sc->config.flags));
! 841: error = wpi_cmd(sc, WPI_CMD_CONFIGURE, &sc->config,
! 842: sizeof (struct wpi_config), 1);
! 843: if (error != 0) {
! 844: printf("%s: could not update configuration\n",
! 845: sc->sc_dev.dv_xname);
! 846: return error;
! 847: }
! 848:
! 849: /* configuration has changed, set Tx power accordingly */
! 850: if ((error = wpi_set_txpower(sc, ni->ni_chan, 1)) != 0) {
! 851: printf("%s: could not set Tx power\n",
! 852: sc->sc_dev.dv_xname);
! 853: return error;
! 854: }
! 855:
! 856: if (ic->ic_opmode == IEEE80211_M_STA) {
! 857: /* fake a join to init the tx rate */
! 858: wpi_newassoc(ic, ni, 1);
! 859: }
! 860:
! 861: /* start periodic calibration timer */
! 862: sc->calib_cnt = 0;
! 863: timeout_add(&sc->calib_to, hz / 2);
! 864:
! 865: /* link LED always on while associated */
! 866: wpi_set_led(sc, WPI_LED_LINK, 0, 1);
! 867: break;
! 868:
! 869: case IEEE80211_S_INIT:
! 870: break;
! 871: }
! 872:
! 873: return sc->sc_newstate(ic, nstate, arg);
! 874: }
! 875:
! 876: /*
! 877: * Grab exclusive access to NIC memory.
! 878: */
! 879: void
! 880: wpi_mem_lock(struct wpi_softc *sc)
! 881: {
! 882: uint32_t tmp;
! 883: int ntries;
! 884:
! 885: tmp = WPI_READ(sc, WPI_GPIO_CTL);
! 886: WPI_WRITE(sc, WPI_GPIO_CTL, tmp | WPI_GPIO_MAC);
! 887:
! 888: /* spin until we actually get the lock */
! 889: for (ntries = 0; ntries < 1000; ntries++) {
! 890: if ((WPI_READ(sc, WPI_GPIO_CTL) &
! 891: (WPI_GPIO_CLOCK | WPI_GPIO_SLEEP)) == WPI_GPIO_CLOCK)
! 892: break;
! 893: DELAY(10);
! 894: }
! 895: if (ntries == 1000)
! 896: printf("%s: could not lock memory\n", sc->sc_dev.dv_xname);
! 897: }
! 898:
! 899: /*
! 900: * Release lock on NIC memory.
! 901: */
! 902: void
! 903: wpi_mem_unlock(struct wpi_softc *sc)
! 904: {
! 905: uint32_t tmp = WPI_READ(sc, WPI_GPIO_CTL);
! 906: WPI_WRITE(sc, WPI_GPIO_CTL, tmp & ~WPI_GPIO_MAC);
! 907: }
! 908:
! 909: uint32_t
! 910: wpi_mem_read(struct wpi_softc *sc, uint16_t addr)
! 911: {
! 912: WPI_WRITE(sc, WPI_READ_MEM_ADDR, WPI_MEM_4 | addr);
! 913: return WPI_READ(sc, WPI_READ_MEM_DATA);
! 914: }
! 915:
! 916: void
! 917: wpi_mem_write(struct wpi_softc *sc, uint16_t addr, uint32_t data)
! 918: {
! 919: WPI_WRITE(sc, WPI_WRITE_MEM_ADDR, WPI_MEM_4 | addr);
! 920: WPI_WRITE(sc, WPI_WRITE_MEM_DATA, data);
! 921: }
! 922:
! 923: void
! 924: wpi_mem_write_region_4(struct wpi_softc *sc, uint16_t addr,
! 925: const uint32_t *data, int wlen)
! 926: {
! 927: for (; wlen > 0; wlen--, data++, addr += 4)
! 928: wpi_mem_write(sc, addr, *data);
! 929: }
! 930:
! 931: /*
! 932: * Read `len' bytes from the EEPROM. We access the EEPROM through the MAC
! 933: * instead of using the traditional bit-bang method.
! 934: */
! 935: int
! 936: wpi_read_prom_data(struct wpi_softc *sc, uint32_t addr, void *data, int len)
! 937: {
! 938: uint8_t *out = data;
! 939: uint32_t val;
! 940: int ntries;
! 941:
! 942: wpi_mem_lock(sc);
! 943: for (; len > 0; len -= 2, addr++) {
! 944: WPI_WRITE(sc, WPI_EEPROM_CTL, addr << 2);
! 945:
! 946: for (ntries = 0; ntries < 10; ntries++) {
! 947: if ((val = WPI_READ(sc, WPI_EEPROM_CTL)) &
! 948: WPI_EEPROM_READY)
! 949: break;
! 950: DELAY(5);
! 951: }
! 952: if (ntries == 10) {
! 953: printf("%s: could not read EEPROM\n",
! 954: sc->sc_dev.dv_xname);
! 955: return ETIMEDOUT;
! 956: }
! 957: *out++ = val >> 16;
! 958: if (len > 1)
! 959: *out++ = val >> 24;
! 960: }
! 961: wpi_mem_unlock(sc);
! 962:
! 963: return 0;
! 964: }
! 965:
! 966: /*
! 967: * The firmware boot code is small and is intended to be copied directly into
! 968: * the NIC internal memory.
! 969: */
! 970: int
! 971: wpi_load_microcode(struct wpi_softc *sc, const uint8_t *ucode, int size)
! 972: {
! 973: int ntries;
! 974:
! 975: size /= sizeof (uint32_t);
! 976:
! 977: wpi_mem_lock(sc);
! 978:
! 979: /* copy microcode image into NIC memory */
! 980: wpi_mem_write_region_4(sc, WPI_MEM_UCODE_BASE,
! 981: (const uint32_t *)ucode, size);
! 982:
! 983: wpi_mem_write(sc, WPI_MEM_UCODE_SRC, 0);
! 984: wpi_mem_write(sc, WPI_MEM_UCODE_DST, WPI_FW_TEXT);
! 985: wpi_mem_write(sc, WPI_MEM_UCODE_SIZE, size);
! 986:
! 987: /* run microcode */
! 988: wpi_mem_write(sc, WPI_MEM_UCODE_CTL, WPI_UC_RUN);
! 989:
! 990: /* wait for transfer to complete */
! 991: for (ntries = 0; ntries < 1000; ntries++) {
! 992: if (!(wpi_mem_read(sc, WPI_MEM_UCODE_CTL) & WPI_UC_RUN))
! 993: break;
! 994: DELAY(10);
! 995: }
! 996: if (ntries == 1000) {
! 997: wpi_mem_unlock(sc);
! 998: printf("%s: could not load boot firmware\n",
! 999: sc->sc_dev.dv_xname);
! 1000: return ETIMEDOUT;
! 1001: }
! 1002: wpi_mem_write(sc, WPI_MEM_UCODE_CTL, WPI_UC_ENABLE);
! 1003:
! 1004: wpi_mem_unlock(sc);
! 1005:
! 1006: return 0;
! 1007: }
! 1008:
! 1009: int
! 1010: wpi_load_firmware(struct wpi_softc *sc)
! 1011: {
! 1012: struct wpi_dma_info *dma = &sc->fw_dma;
! 1013: const struct wpi_firmware_hdr *hdr;
! 1014: const uint8_t *init_text, *init_data, *main_text, *main_data;
! 1015: const uint8_t *boot_text;
! 1016: uint32_t init_textsz, init_datasz, main_textsz, main_datasz;
! 1017: uint32_t boot_textsz;
! 1018: u_char *fw;
! 1019: size_t size;
! 1020: int error;
! 1021:
! 1022: /* load firmware image from disk */
! 1023: if ((error = loadfirmware("wpi-3945abg", &fw, &size)) != 0) {
! 1024: printf("%s: could not read firmware file\n",
! 1025: sc->sc_dev.dv_xname);
! 1026: goto fail1;
! 1027: }
! 1028:
! 1029: /* extract firmware header information */
! 1030: if (size < sizeof (struct wpi_firmware_hdr)) {
! 1031: printf("%s: truncated firmware header: %d bytes\n",
! 1032: sc->sc_dev.dv_xname, size);
! 1033: error = EINVAL;
! 1034: goto fail2;
! 1035: }
! 1036: hdr = (const struct wpi_firmware_hdr *)fw;
! 1037: main_textsz = letoh32(hdr->main_textsz);
! 1038: main_datasz = letoh32(hdr->main_datasz);
! 1039: init_textsz = letoh32(hdr->init_textsz);
! 1040: init_datasz = letoh32(hdr->init_datasz);
! 1041: boot_textsz = letoh32(hdr->boot_textsz);
! 1042:
! 1043: /* sanity-check firmware segments sizes */
! 1044: if (main_textsz > WPI_FW_MAIN_TEXT_MAXSZ ||
! 1045: main_datasz > WPI_FW_MAIN_DATA_MAXSZ ||
! 1046: init_textsz > WPI_FW_INIT_TEXT_MAXSZ ||
! 1047: init_datasz > WPI_FW_INIT_DATA_MAXSZ ||
! 1048: boot_textsz > WPI_FW_BOOT_TEXT_MAXSZ ||
! 1049: (boot_textsz & 3) != 0) {
! 1050: printf("%s: invalid firmware header\n", sc->sc_dev.dv_xname);
! 1051: error = EINVAL;
! 1052: goto fail2;
! 1053: }
! 1054:
! 1055: /* check that all firmware segments are present */
! 1056: if (size < sizeof (struct wpi_firmware_hdr) + main_textsz +
! 1057: main_datasz + init_textsz + init_datasz + boot_textsz) {
! 1058: printf("%s: firmware file too short: %d bytes\n",
! 1059: sc->sc_dev.dv_xname, size);
! 1060: error = EINVAL;
! 1061: goto fail2;
! 1062: }
! 1063:
! 1064: /* get pointers to firmware segments */
! 1065: main_text = (const uint8_t *)(hdr + 1);
! 1066: main_data = main_text + main_textsz;
! 1067: init_text = main_data + main_datasz;
! 1068: init_data = init_text + init_textsz;
! 1069: boot_text = init_data + init_datasz;
! 1070:
! 1071: /* copy initialization images into pre-allocated DMA-safe memory */
! 1072: memcpy(dma->vaddr, init_data, init_datasz);
! 1073: memcpy(dma->vaddr + WPI_FW_INIT_DATA_MAXSZ, init_text, init_textsz);
! 1074:
! 1075: /* tell adapter where to find initialization images */
! 1076: wpi_mem_lock(sc);
! 1077: wpi_mem_write(sc, WPI_MEM_DATA_BASE, dma->paddr);
! 1078: wpi_mem_write(sc, WPI_MEM_DATA_SIZE, init_datasz);
! 1079: wpi_mem_write(sc, WPI_MEM_TEXT_BASE,
! 1080: dma->paddr + WPI_FW_INIT_DATA_MAXSZ);
! 1081: wpi_mem_write(sc, WPI_MEM_TEXT_SIZE, init_textsz);
! 1082: wpi_mem_unlock(sc);
! 1083:
! 1084: /* load firmware boot code */
! 1085: if ((error = wpi_load_microcode(sc, boot_text, boot_textsz)) != 0) {
! 1086: printf("%s: could not load boot firmware\n",
! 1087: sc->sc_dev.dv_xname);
! 1088: goto fail2;
! 1089: }
! 1090:
! 1091: /* now press "execute" ;-) */
! 1092: WPI_WRITE(sc, WPI_RESET, 0);
! 1093:
! 1094: /* wait at most one second for first alive notification */
! 1095: if ((error = tsleep(sc, PCATCH, "wpiinit", hz)) != 0) {
! 1096: /* this isn't what was supposed to happen.. */
! 1097: printf("%s: timeout waiting for adapter to initialize\n",
! 1098: sc->sc_dev.dv_xname);
! 1099: goto fail2;
! 1100: }
! 1101:
! 1102: /* copy runtime images into pre-allocated DMA-safe memory */
! 1103: memcpy(dma->vaddr, main_data, main_datasz);
! 1104: memcpy(dma->vaddr + WPI_FW_MAIN_DATA_MAXSZ, main_text, main_textsz);
! 1105:
! 1106: /* tell adapter where to find runtime images */
! 1107: wpi_mem_lock(sc);
! 1108: wpi_mem_write(sc, WPI_MEM_DATA_BASE, dma->paddr);
! 1109: wpi_mem_write(sc, WPI_MEM_DATA_SIZE, main_datasz);
! 1110: wpi_mem_write(sc, WPI_MEM_TEXT_BASE,
! 1111: dma->paddr + WPI_FW_MAIN_DATA_MAXSZ);
! 1112: wpi_mem_write(sc, WPI_MEM_TEXT_SIZE, WPI_FW_UPDATED | main_textsz);
! 1113: wpi_mem_unlock(sc);
! 1114:
! 1115: /* wait at most one second for second alive notification */
! 1116: if ((error = tsleep(sc, PCATCH, "wpiinit", hz)) != 0) {
! 1117: /* this isn't what was supposed to happen.. */
! 1118: printf("%s: timeout waiting for adapter to initialize\n",
! 1119: sc->sc_dev.dv_xname);
! 1120: }
! 1121:
! 1122: fail2: free(fw, M_DEVBUF);
! 1123: fail1: return error;
! 1124: }
! 1125:
! 1126: void
! 1127: wpi_calib_timeout(void *arg)
! 1128: {
! 1129: struct wpi_softc *sc = arg;
! 1130: struct ieee80211com *ic = &sc->sc_ic;
! 1131: int temp, s;
! 1132:
! 1133: /* automatic rate control triggered every 500ms */
! 1134: if (ic->ic_fixed_rate == -1) {
! 1135: s = splnet();
! 1136: if (ic->ic_opmode == IEEE80211_M_STA)
! 1137: wpi_iter_func(sc, ic->ic_bss);
! 1138: else
! 1139: ieee80211_iterate_nodes(ic, wpi_iter_func, sc);
! 1140: splx(s);
! 1141: }
! 1142:
! 1143: /* update sensor data */
! 1144: temp = (int)WPI_READ(sc, WPI_TEMPERATURE);
! 1145: sc->sensor.value = temp + 260;
! 1146:
! 1147: /* automatic power calibration every 60s */
! 1148: if (++sc->calib_cnt >= 120) {
! 1149: wpi_power_calibration(sc, temp);
! 1150: sc->calib_cnt = 0;
! 1151: }
! 1152:
! 1153: timeout_add(&sc->calib_to, hz / 2);
! 1154: }
! 1155:
! 1156: void
! 1157: wpi_iter_func(void *arg, struct ieee80211_node *ni)
! 1158: {
! 1159: struct wpi_softc *sc = arg;
! 1160: struct wpi_node *wn = (struct wpi_node *)ni;
! 1161:
! 1162: ieee80211_amrr_choose(&sc->amrr, ni, &wn->amn);
! 1163: }
! 1164:
! 1165: /*
! 1166: * This function is called periodically (every 60 seconds) to adjust output
! 1167: * power to temperature changes.
! 1168: */
! 1169: void
! 1170: wpi_power_calibration(struct wpi_softc *sc, int temp)
! 1171: {
! 1172: /* sanity-check read value */
! 1173: if (temp < -260 || temp > 25) {
! 1174: /* this can't be correct, ignore */
! 1175: DPRINTF(("out-of-range temperature reported: %d\n", temp));
! 1176: return;
! 1177: }
! 1178:
! 1179: DPRINTF(("temperature %d->%d\n", sc->temp, temp));
! 1180:
! 1181: /* adjust Tx power if need be */
! 1182: if (abs(temp - sc->temp) <= 6)
! 1183: return;
! 1184:
! 1185: sc->temp = temp;
! 1186:
! 1187: if (wpi_set_txpower(sc, sc->sc_ic.ic_bss->ni_chan, 1) != 0) {
! 1188: /* just warn, too bad for the automatic calibration... */
! 1189: printf("%s: could not adjust Tx power\n",
! 1190: sc->sc_dev.dv_xname);
! 1191: }
! 1192: }
! 1193:
! 1194: void
! 1195: wpi_rx_intr(struct wpi_softc *sc, struct wpi_rx_desc *desc,
! 1196: struct wpi_rx_data *data)
! 1197: {
! 1198: struct ieee80211com *ic = &sc->sc_ic;
! 1199: struct ifnet *ifp = &ic->ic_if;
! 1200: struct wpi_rx_ring *ring = &sc->rxq;
! 1201: struct wpi_rx_stat *stat;
! 1202: struct wpi_rx_head *head;
! 1203: struct wpi_rx_tail *tail;
! 1204: struct wpi_rbuf *rbuf;
! 1205: struct ieee80211_frame *wh;
! 1206: struct ieee80211_node *ni;
! 1207: struct mbuf *m, *mnew;
! 1208:
! 1209: stat = (struct wpi_rx_stat *)(desc + 1);
! 1210:
! 1211: if (stat->len > WPI_STAT_MAXLEN) {
! 1212: printf("%s: invalid rx statistic header\n",
! 1213: sc->sc_dev.dv_xname);
! 1214: ifp->if_ierrors++;
! 1215: return;
! 1216: }
! 1217:
! 1218: head = (struct wpi_rx_head *)((caddr_t)(stat + 1) + stat->len);
! 1219: tail = (struct wpi_rx_tail *)((caddr_t)(head + 1) + letoh16(head->len));
! 1220:
! 1221: DPRINTFN(4, ("rx intr: idx=%d len=%d stat len=%d rssi=%d rate=%x "
! 1222: "chan=%d tstamp=%llu\n", ring->cur, letoh32(desc->len),
! 1223: letoh16(head->len), (int8_t)stat->rssi, head->rate, head->chan,
! 1224: letoh64(tail->tstamp)));
! 1225:
! 1226: /*
! 1227: * Discard Rx frames with bad CRC early (XXX we may want to pass them
! 1228: * to radiotap in monitor mode).
! 1229: */
! 1230: if ((letoh32(tail->flags) & WPI_RX_NOERROR) != WPI_RX_NOERROR) {
! 1231: DPRINTFN(2, ("rx tail flags error %x\n",
! 1232: letoh32(tail->flags)));
! 1233: ifp->if_ierrors++;
! 1234: return;
! 1235: }
! 1236:
! 1237: MGETHDR(mnew, M_DONTWAIT, MT_DATA);
! 1238: if (mnew == NULL) {
! 1239: ifp->if_ierrors++;
! 1240: return;
! 1241: }
! 1242: if ((rbuf = wpi_alloc_rbuf(sc)) == NULL) {
! 1243: m_freem(mnew);
! 1244: ifp->if_ierrors++;
! 1245: return;
! 1246: }
! 1247: /* attach Rx buffer to mbuf */
! 1248: MEXTADD(mnew, rbuf->vaddr, WPI_RBUF_SIZE, 0, wpi_free_rbuf, rbuf);
! 1249:
! 1250: m = data->m;
! 1251: data->m = mnew;
! 1252:
! 1253: /* update Rx descriptor */
! 1254: ring->desc[ring->cur] = htole32(rbuf->paddr);
! 1255:
! 1256: /* finalize mbuf */
! 1257: m->m_pkthdr.rcvif = ifp;
! 1258: m->m_data = (caddr_t)(head + 1);
! 1259: m->m_pkthdr.len = m->m_len = letoh16(head->len);
! 1260:
! 1261: #if NBPFILTER > 0
! 1262: if (sc->sc_drvbpf != NULL) {
! 1263: struct mbuf mb;
! 1264: struct wpi_rx_radiotap_header *tap = &sc->sc_rxtap;
! 1265:
! 1266: tap->wr_flags = 0;
! 1267: tap->wr_chan_freq =
! 1268: htole16(ic->ic_channels[head->chan].ic_freq);
! 1269: tap->wr_chan_flags =
! 1270: htole16(ic->ic_channels[head->chan].ic_flags);
! 1271: tap->wr_dbm_antsignal = (int8_t)(stat->rssi - WPI_RSSI_OFFSET);
! 1272: tap->wr_dbm_antnoise = (int8_t)letoh16(stat->noise);
! 1273: tap->wr_tsft = tail->tstamp;
! 1274: tap->wr_antenna = (letoh16(head->flags) >> 4) & 0xf;
! 1275: switch (head->rate) {
! 1276: /* CCK rates */
! 1277: case 10: tap->wr_rate = 2; break;
! 1278: case 20: tap->wr_rate = 4; break;
! 1279: case 55: tap->wr_rate = 11; break;
! 1280: case 110: tap->wr_rate = 22; break;
! 1281: /* OFDM rates */
! 1282: case 0xd: tap->wr_rate = 12; break;
! 1283: case 0xf: tap->wr_rate = 18; break;
! 1284: case 0x5: tap->wr_rate = 24; break;
! 1285: case 0x7: tap->wr_rate = 36; break;
! 1286: case 0x9: tap->wr_rate = 48; break;
! 1287: case 0xb: tap->wr_rate = 72; break;
! 1288: case 0x1: tap->wr_rate = 96; break;
! 1289: case 0x3: tap->wr_rate = 108; break;
! 1290: /* unknown rate: should not happen */
! 1291: default: tap->wr_rate = 0;
! 1292: }
! 1293: if (letoh16(head->flags) & 0x4)
! 1294: tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
! 1295:
! 1296: mb.m_data = (caddr_t)tap;
! 1297: mb.m_len = sc->sc_rxtap_len;
! 1298: mb.m_next = m;
! 1299: mb.m_nextpkt = NULL;
! 1300: mb.m_type = 0;
! 1301: mb.m_flags = 0;
! 1302: bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_IN);
! 1303: }
! 1304: #endif
! 1305:
! 1306: /* grab a reference to the source node */
! 1307: wh = mtod(m, struct ieee80211_frame *);
! 1308: ni = ieee80211_find_rxnode(ic, wh);
! 1309:
! 1310: /* send the frame to the 802.11 layer */
! 1311: ieee80211_input(ifp, m, ni, stat->rssi, 0);
! 1312:
! 1313: /* node is no longer needed */
! 1314: ieee80211_release_node(ic, ni);
! 1315: }
! 1316:
! 1317: void
! 1318: wpi_tx_intr(struct wpi_softc *sc, struct wpi_rx_desc *desc)
! 1319: {
! 1320: struct ieee80211com *ic = &sc->sc_ic;
! 1321: struct ifnet *ifp = &ic->ic_if;
! 1322: struct wpi_tx_ring *ring = &sc->txq[desc->qid & 0x3];
! 1323: struct wpi_tx_data *data = &ring->data[desc->idx];
! 1324: struct wpi_tx_stat *stat = (struct wpi_tx_stat *)(desc + 1);
! 1325: struct wpi_node *wn = (struct wpi_node *)data->ni;
! 1326:
! 1327: DPRINTFN(4, ("tx done: qid=%d idx=%d retries=%d nkill=%d rate=%x "
! 1328: "duration=%d status=%x\n", desc->qid, desc->idx, stat->ntries,
! 1329: stat->nkill, stat->rate, letoh32(stat->duration),
! 1330: letoh32(stat->status)));
! 1331:
! 1332: /*
! 1333: * Update rate control statistics for the node.
! 1334: * XXX we should not count mgmt frames since they're always sent at
! 1335: * the lowest available bit-rate.
! 1336: */
! 1337: wn->amn.amn_txcnt++;
! 1338: if (stat->ntries > 0) {
! 1339: DPRINTFN(3, ("tx intr ntries %d\n", stat->ntries));
! 1340: wn->amn.amn_retrycnt++;
! 1341: }
! 1342:
! 1343: if ((letoh32(stat->status) & 0xff) != 1)
! 1344: ifp->if_oerrors++;
! 1345: else
! 1346: ifp->if_opackets++;
! 1347:
! 1348: bus_dmamap_unload(sc->sc_dmat, data->map);
! 1349: m_freem(data->m);
! 1350: data->m = NULL;
! 1351: ieee80211_release_node(ic, data->ni);
! 1352: data->ni = NULL;
! 1353:
! 1354: ring->queued--;
! 1355:
! 1356: sc->sc_tx_timer = 0;
! 1357: ifp->if_flags &= ~IFF_OACTIVE;
! 1358: (*ifp->if_start)(ifp);
! 1359: }
! 1360:
! 1361: void
! 1362: wpi_cmd_intr(struct wpi_softc *sc, struct wpi_rx_desc *desc)
! 1363: {
! 1364: struct wpi_tx_ring *ring = &sc->cmdq;
! 1365: struct wpi_tx_data *data;
! 1366:
! 1367: if ((desc->qid & 7) != 4)
! 1368: return; /* not a command ack */
! 1369:
! 1370: data = &ring->data[desc->idx];
! 1371:
! 1372: /* if the command was mapped in a mbuf, free it */
! 1373: if (data->m != NULL) {
! 1374: bus_dmamap_unload(sc->sc_dmat, data->map);
! 1375: m_freem(data->m);
! 1376: data->m = NULL;
! 1377: }
! 1378:
! 1379: wakeup(&ring->cmd[desc->idx]);
! 1380: }
! 1381:
! 1382: void
! 1383: wpi_notif_intr(struct wpi_softc *sc)
! 1384: {
! 1385: struct ieee80211com *ic = &sc->sc_ic;
! 1386: struct ifnet *ifp = &ic->ic_if;
! 1387: uint32_t hw;
! 1388:
! 1389: hw = letoh32(sc->shared->next);
! 1390: while (sc->rxq.cur != hw) {
! 1391: struct wpi_rx_data *data = &sc->rxq.data[sc->rxq.cur];
! 1392: struct wpi_rx_desc *desc = mtod(data->m, struct wpi_rx_desc *);
! 1393:
! 1394: DPRINTFN(4, ("rx notification qid=%x idx=%d flags=%x type=%d "
! 1395: "len=%d\n", desc->qid, desc->idx, desc->flags, desc->type,
! 1396: letoh32(desc->len)));
! 1397:
! 1398: if (!(desc->qid & 0x80)) /* reply to a command */
! 1399: wpi_cmd_intr(sc, desc);
! 1400:
! 1401: switch (desc->type) {
! 1402: case WPI_RX_DONE:
! 1403: /* a 802.11 frame was received */
! 1404: wpi_rx_intr(sc, desc, data);
! 1405: break;
! 1406:
! 1407: case WPI_TX_DONE:
! 1408: /* a 802.11 frame has been transmitted */
! 1409: wpi_tx_intr(sc, desc);
! 1410: break;
! 1411:
! 1412: case WPI_UC_READY:
! 1413: {
! 1414: struct wpi_ucode_info *uc =
! 1415: (struct wpi_ucode_info *)(desc + 1);
! 1416:
! 1417: /* the microcontroller is ready */
! 1418: DPRINTF(("microcode alive notification version %x "
! 1419: "alive %x\n", letoh32(uc->version),
! 1420: letoh32(uc->valid)));
! 1421:
! 1422: if (letoh32(uc->valid) != 1) {
! 1423: printf("%s: microcontroller initialization "
! 1424: "failed\n", sc->sc_dev.dv_xname);
! 1425: }
! 1426: break;
! 1427: }
! 1428: case WPI_STATE_CHANGED:
! 1429: {
! 1430: uint32_t *status = (uint32_t *)(desc + 1);
! 1431:
! 1432: /* enabled/disabled notification */
! 1433: DPRINTF(("state changed to %x\n", letoh32(*status)));
! 1434:
! 1435: if (letoh32(*status) & 1) {
! 1436: /* the radio button has to be pushed */
! 1437: printf("%s: Radio transmitter is off\n",
! 1438: sc->sc_dev.dv_xname);
! 1439: /* turn the interface down */
! 1440: ifp->if_flags &= ~IFF_UP;
! 1441: wpi_stop(ifp, 1);
! 1442: return; /* no further processing */
! 1443: }
! 1444: break;
! 1445: }
! 1446: case WPI_START_SCAN:
! 1447: {
! 1448: struct wpi_start_scan *scan =
! 1449: (struct wpi_start_scan *)(desc + 1);
! 1450:
! 1451: DPRINTFN(2, ("scanning channel %d status %x\n",
! 1452: scan->chan, letoh32(scan->status)));
! 1453:
! 1454: /* fix current channel */
! 1455: ic->ic_bss->ni_chan = &ic->ic_channels[scan->chan];
! 1456: break;
! 1457: }
! 1458: case WPI_STOP_SCAN:
! 1459: {
! 1460: struct wpi_stop_scan *scan =
! 1461: (struct wpi_stop_scan *)(desc + 1);
! 1462:
! 1463: DPRINTF(("scan finished nchan=%d status=%d chan=%d\n",
! 1464: scan->nchan, scan->status, scan->chan));
! 1465:
! 1466: if (scan->status == 1 && scan->chan <= 14) {
! 1467: /*
! 1468: * We just finished scanning 802.11g channels,
! 1469: * start scanning 802.11a ones.
! 1470: */
! 1471: if (wpi_scan(sc, IEEE80211_CHAN_A) == 0)
! 1472: break;
! 1473: }
! 1474: ieee80211_end_scan(ifp);
! 1475: break;
! 1476: }
! 1477: }
! 1478:
! 1479: sc->rxq.cur = (sc->rxq.cur + 1) % WPI_RX_RING_COUNT;
! 1480: }
! 1481:
! 1482: /* tell the firmware what we have processed */
! 1483: hw = (hw == 0) ? WPI_RX_RING_COUNT - 1 : hw - 1;
! 1484: WPI_WRITE(sc, WPI_RX_WIDX, hw & ~7);
! 1485: }
! 1486:
! 1487: int
! 1488: wpi_intr(void *arg)
! 1489: {
! 1490: struct wpi_softc *sc = arg;
! 1491: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 1492: uint32_t r;
! 1493:
! 1494: r = WPI_READ(sc, WPI_INTR);
! 1495: if (r == 0 || r == 0xffffffff)
! 1496: return 0; /* not for us */
! 1497:
! 1498: DPRINTFN(6, ("interrupt reg %x\n", r));
! 1499:
! 1500: /* disable interrupts */
! 1501: WPI_WRITE(sc, WPI_MASK, 0);
! 1502: /* ack interrupts */
! 1503: WPI_WRITE(sc, WPI_INTR, r);
! 1504:
! 1505: if (r & (WPI_SW_ERROR | WPI_HW_ERROR)) {
! 1506: /* SYSTEM FAILURE, SYSTEM FAILURE */
! 1507: printf("%s: fatal firmware error\n", sc->sc_dev.dv_xname);
! 1508: ifp->if_flags &= ~IFF_UP;
! 1509: wpi_stop(ifp, 1);
! 1510: return 1;
! 1511: }
! 1512:
! 1513: if (r & WPI_RX_INTR)
! 1514: wpi_notif_intr(sc);
! 1515:
! 1516: if (r & WPI_ALIVE_INTR) /* firmware initialized */
! 1517: wakeup(sc);
! 1518:
! 1519: /* re-enable interrupts */
! 1520: if (ifp->if_flags & IFF_UP)
! 1521: WPI_WRITE(sc, WPI_MASK, WPI_INTR_MASK);
! 1522:
! 1523: return 1;
! 1524: }
! 1525:
! 1526: uint8_t
! 1527: wpi_plcp_signal(int rate)
! 1528: {
! 1529: switch (rate) {
! 1530: /* CCK rates (returned values are device-dependent) */
! 1531: case 2: return 10;
! 1532: case 4: return 20;
! 1533: case 11: return 55;
! 1534: case 22: return 110;
! 1535:
! 1536: /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
! 1537: /* R1-R4, (u)ral is R4-R1 */
! 1538: case 12: return 0xd;
! 1539: case 18: return 0xf;
! 1540: case 24: return 0x5;
! 1541: case 36: return 0x7;
! 1542: case 48: return 0x9;
! 1543: case 72: return 0xb;
! 1544: case 96: return 0x1;
! 1545: case 108: return 0x3;
! 1546:
! 1547: /* unsupported rates (should not get there) */
! 1548: default: return 0;
! 1549: }
! 1550: }
! 1551:
! 1552: /* quickly determine if a given rate is CCK or OFDM */
! 1553: #define WPI_RATE_IS_OFDM(rate) ((rate) >= 12 && (rate) != 22)
! 1554:
! 1555: int
! 1556: wpi_tx_data(struct wpi_softc *sc, struct mbuf *m0, struct ieee80211_node *ni,
! 1557: int ac)
! 1558: {
! 1559: struct ieee80211com *ic = &sc->sc_ic;
! 1560: struct wpi_tx_ring *ring = &sc->txq[ac];
! 1561: struct wpi_tx_desc *desc;
! 1562: struct wpi_tx_data *data;
! 1563: struct wpi_tx_cmd *cmd;
! 1564: struct wpi_cmd_data *tx;
! 1565: struct ieee80211_frame *wh;
! 1566: struct mbuf *mnew;
! 1567: int i, rate, error, ovhd = 0;
! 1568:
! 1569: desc = &ring->desc[ring->cur];
! 1570: data = &ring->data[ring->cur];
! 1571:
! 1572: wh = mtod(m0, struct ieee80211_frame *);
! 1573:
! 1574: /* pickup a rate */
! 1575: if (IEEE80211_IS_MULTICAST(wh->i_addr1) ||
! 1576: ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
! 1577: IEEE80211_FC0_TYPE_MGT)) {
! 1578: /* mgmt/multicast frames are sent at the lowest avail. rate */
! 1579: rate = ni->ni_rates.rs_rates[0];
! 1580: } else if (ic->ic_fixed_rate != -1) {
! 1581: rate = ic->ic_sup_rates[ic->ic_curmode].
! 1582: rs_rates[ic->ic_fixed_rate];
! 1583: } else
! 1584: rate = ni->ni_rates.rs_rates[ni->ni_txrate];
! 1585: rate &= IEEE80211_RATE_VAL;
! 1586:
! 1587: #if NBPFILTER > 0
! 1588: if (sc->sc_drvbpf != NULL) {
! 1589: struct mbuf mb;
! 1590: struct wpi_tx_radiotap_header *tap = &sc->sc_txtap;
! 1591:
! 1592: tap->wt_flags = 0;
! 1593: tap->wt_chan_freq = htole16(ni->ni_chan->ic_freq);
! 1594: tap->wt_chan_flags = htole16(ni->ni_chan->ic_flags);
! 1595: tap->wt_rate = rate;
! 1596: tap->wt_hwqueue = ac;
! 1597: if (wh->i_fc[1] & IEEE80211_FC1_WEP)
! 1598: tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP;
! 1599:
! 1600: mb.m_data = (caddr_t)tap;
! 1601: mb.m_len = sc->sc_txtap_len;
! 1602: mb.m_next = m0;
! 1603: mb.m_nextpkt = NULL;
! 1604: mb.m_type = 0;
! 1605: mb.m_flags = 0;
! 1606: bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_OUT);
! 1607: }
! 1608: #endif
! 1609:
! 1610: cmd = &ring->cmd[ring->cur];
! 1611: cmd->code = WPI_CMD_TX_DATA;
! 1612: cmd->flags = 0;
! 1613: cmd->qid = ring->qid;
! 1614: cmd->idx = ring->cur;
! 1615:
! 1616: tx = (struct wpi_cmd_data *)cmd->data;
! 1617: /* no need to zero tx, all fields are reinitialized here */
! 1618: tx->flags = 0;
! 1619:
! 1620: if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
! 1621: const struct ieee80211_key *key =
! 1622: &ic->ic_nw_keys[ic->ic_wep_txkey];
! 1623: if (key->k_cipher == IEEE80211_CIPHER_WEP40)
! 1624: tx->security = WPI_CIPHER_WEP40;
! 1625: else
! 1626: tx->security = WPI_CIPHER_WEP104;
! 1627: tx->security |= ic->ic_wep_txkey << 6;
! 1628: memcpy(&tx->key[3], key->k_key, key->k_len);
! 1629: /* compute crypto overhead */
! 1630: ovhd = IEEE80211_WEP_TOTLEN;
! 1631: } else
! 1632: tx->security = 0;
! 1633:
! 1634: if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
! 1635: tx->id = WPI_ID_BSS;
! 1636: tx->flags |= htole32(WPI_TX_NEED_ACK);
! 1637: } else
! 1638: tx->id = WPI_ID_BROADCAST;
! 1639:
! 1640: /* check if RTS/CTS or CTS-to-self protection must be used */
! 1641: if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
! 1642: /* multicast frames are not sent at OFDM rates in 802.11b/g */
! 1643: if (m0->m_pkthdr.len + ovhd + IEEE80211_CRC_LEN >
! 1644: ic->ic_rtsthreshold) {
! 1645: tx->flags |= htole32(WPI_TX_NEED_RTS |
! 1646: WPI_TX_FULL_TXOP);
! 1647: } else if ((ic->ic_flags & IEEE80211_F_USEPROT) &&
! 1648: WPI_RATE_IS_OFDM(rate)) {
! 1649: if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) {
! 1650: tx->flags |= htole32(WPI_TX_NEED_CTS |
! 1651: WPI_TX_FULL_TXOP);
! 1652: } else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) {
! 1653: tx->flags |= htole32(WPI_TX_NEED_RTS |
! 1654: WPI_TX_FULL_TXOP);
! 1655: }
! 1656: }
! 1657: }
! 1658:
! 1659: tx->flags |= htole32(WPI_TX_AUTO_SEQ);
! 1660:
! 1661: if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
! 1662: IEEE80211_FC0_TYPE_MGT) {
! 1663: uint8_t subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
! 1664:
! 1665: /* tell h/w to set timestamp in probe responses */
! 1666: if (subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP)
! 1667: tx->flags |= htole32(WPI_TX_INSERT_TSTAMP);
! 1668:
! 1669: if (subtype == IEEE80211_FC0_SUBTYPE_ASSOC_REQ ||
! 1670: subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ)
! 1671: tx->timeout = htole16(3);
! 1672: else
! 1673: tx->timeout = htole16(2);
! 1674: } else
! 1675: tx->timeout = htole16(0);
! 1676:
! 1677: tx->rate = wpi_plcp_signal(rate);
! 1678:
! 1679: /* be very persistant at sending frames out */
! 1680: tx->rts_ntries = 7;
! 1681: tx->data_ntries = 15;
! 1682:
! 1683: tx->ofdm_mask = 0xff;
! 1684: tx->cck_mask = 0x0f;
! 1685: tx->lifetime = htole32(WPI_LIFETIME_INFINITE);
! 1686:
! 1687: tx->len = htole16(m0->m_pkthdr.len);
! 1688:
! 1689: /* save and trim IEEE802.11 header */
! 1690: m_copydata(m0, 0, sizeof (struct ieee80211_frame), (caddr_t)&tx->wh);
! 1691: m_adj(m0, sizeof (struct ieee80211_frame));
! 1692:
! 1693: error = bus_dmamap_load_mbuf(sc->sc_dmat, data->map, m0,
! 1694: BUS_DMA_NOWAIT);
! 1695: if (error != 0 && error != EFBIG) {
! 1696: printf("%s: could not map mbuf (error %d)\n",
! 1697: sc->sc_dev.dv_xname, error);
! 1698: m_freem(m0);
! 1699: return error;
! 1700: }
! 1701: if (error != 0) {
! 1702: /* too many fragments, linearize */
! 1703:
! 1704: MGETHDR(mnew, M_DONTWAIT, MT_DATA);
! 1705: if (mnew == NULL) {
! 1706: m_freem(m0);
! 1707: return ENOMEM;
! 1708: }
! 1709: M_DUP_PKTHDR(mnew, m0);
! 1710: if (m0->m_pkthdr.len > MHLEN) {
! 1711: MCLGET(mnew, M_DONTWAIT);
! 1712: if (!(mnew->m_flags & M_EXT)) {
! 1713: m_freem(m0);
! 1714: m_freem(mnew);
! 1715: return ENOMEM;
! 1716: }
! 1717: }
! 1718:
! 1719: m_copydata(m0, 0, m0->m_pkthdr.len, mtod(mnew, caddr_t));
! 1720: m_freem(m0);
! 1721: mnew->m_len = mnew->m_pkthdr.len;
! 1722: m0 = mnew;
! 1723:
! 1724: error = bus_dmamap_load_mbuf(sc->sc_dmat, data->map, m0,
! 1725: BUS_DMA_NOWAIT);
! 1726: if (error != 0) {
! 1727: printf("%s: could not map mbuf (error %d)\n",
! 1728: sc->sc_dev.dv_xname, error);
! 1729: m_freem(m0);
! 1730: return error;
! 1731: }
! 1732: }
! 1733:
! 1734: data->m = m0;
! 1735: data->ni = ni;
! 1736:
! 1737: DPRINTFN(4, ("sending data: qid=%d idx=%d len=%d nsegs=%d\n",
! 1738: ring->qid, ring->cur, m0->m_pkthdr.len, data->map->dm_nsegs));
! 1739:
! 1740: /* first scatter/gather segment is used by the tx data command */
! 1741: desc->flags = htole32(WPI_PAD32(m0->m_pkthdr.len) << 28 |
! 1742: (1 + data->map->dm_nsegs) << 24);
! 1743: desc->segs[0].addr = htole32(ring->cmd_dma.paddr +
! 1744: ring->cur * sizeof (struct wpi_tx_cmd));
! 1745: desc->segs[0].len = htole32(4 + sizeof (struct wpi_cmd_data));
! 1746: for (i = 1; i <= data->map->dm_nsegs; i++) {
! 1747: desc->segs[i].addr =
! 1748: htole32(data->map->dm_segs[i - 1].ds_addr);
! 1749: desc->segs[i].len =
! 1750: htole32(data->map->dm_segs[i - 1].ds_len);
! 1751: }
! 1752:
! 1753: ring->queued++;
! 1754:
! 1755: /* kick ring */
! 1756: ring->cur = (ring->cur + 1) % WPI_TX_RING_COUNT;
! 1757: WPI_WRITE(sc, WPI_TX_WIDX, ring->qid << 8 | ring->cur);
! 1758:
! 1759: return 0;
! 1760: }
! 1761:
! 1762: void
! 1763: wpi_start(struct ifnet *ifp)
! 1764: {
! 1765: struct wpi_softc *sc = ifp->if_softc;
! 1766: struct ieee80211com *ic = &sc->sc_ic;
! 1767: struct ieee80211_node *ni;
! 1768: struct mbuf *m0;
! 1769:
! 1770: /*
! 1771: * net80211 may still try to send management frames even if the
! 1772: * IFF_RUNNING flag is not set...
! 1773: */
! 1774: if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
! 1775: return;
! 1776:
! 1777: for (;;) {
! 1778: IF_POLL(&ic->ic_mgtq, m0);
! 1779: if (m0 != NULL) {
! 1780: /* management frames go into ring 0 */
! 1781: if (sc->txq[0].queued >= sc->txq[0].count - 8) {
! 1782: ifp->if_flags |= IFF_OACTIVE;
! 1783: break;
! 1784: }
! 1785: IF_DEQUEUE(&ic->ic_mgtq, m0);
! 1786:
! 1787: ni = (struct ieee80211_node *)m0->m_pkthdr.rcvif;
! 1788: m0->m_pkthdr.rcvif = NULL;
! 1789: #if NBPFILTER > 0
! 1790: if (ic->ic_rawbpf != NULL)
! 1791: bpf_mtap(ic->ic_rawbpf, m0, BPF_DIRECTION_OUT);
! 1792: #endif
! 1793: if (wpi_tx_data(sc, m0, ni, 0) != 0)
! 1794: break;
! 1795:
! 1796: } else {
! 1797: if (ic->ic_state != IEEE80211_S_RUN)
! 1798: break;
! 1799: IFQ_POLL(&ifp->if_snd, m0);
! 1800: if (m0 == NULL)
! 1801: break;
! 1802: if (sc->txq[0].queued >= sc->txq[0].count - 8) {
! 1803: /* there is no place left in this ring */
! 1804: ifp->if_flags |= IFF_OACTIVE;
! 1805: break;
! 1806: }
! 1807: IFQ_DEQUEUE(&ifp->if_snd, m0);
! 1808: #if NBPFILTER > 0
! 1809: if (ifp->if_bpf != NULL)
! 1810: bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
! 1811: #endif
! 1812: m0 = ieee80211_encap(ifp, m0, &ni);
! 1813: if (m0 == NULL)
! 1814: continue;
! 1815: #if NBPFILTER > 0
! 1816: if (ic->ic_rawbpf != NULL)
! 1817: bpf_mtap(ic->ic_rawbpf, m0, BPF_DIRECTION_OUT);
! 1818: #endif
! 1819: if (wpi_tx_data(sc, m0, ni, 0) != 0) {
! 1820: if (ni != NULL)
! 1821: ieee80211_release_node(ic, ni);
! 1822: ifp->if_oerrors++;
! 1823: break;
! 1824: }
! 1825: }
! 1826:
! 1827: sc->sc_tx_timer = 5;
! 1828: ifp->if_timer = 1;
! 1829: }
! 1830: }
! 1831:
! 1832: void
! 1833: wpi_watchdog(struct ifnet *ifp)
! 1834: {
! 1835: struct wpi_softc *sc = ifp->if_softc;
! 1836:
! 1837: ifp->if_timer = 0;
! 1838:
! 1839: if (sc->sc_tx_timer > 0) {
! 1840: if (--sc->sc_tx_timer == 0) {
! 1841: printf("%s: device timeout\n", sc->sc_dev.dv_xname);
! 1842: ifp->if_flags &= ~IFF_UP;
! 1843: wpi_stop(ifp, 1);
! 1844: ifp->if_oerrors++;
! 1845: return;
! 1846: }
! 1847: ifp->if_timer = 1;
! 1848: }
! 1849:
! 1850: ieee80211_watchdog(ifp);
! 1851: }
! 1852:
! 1853: int
! 1854: wpi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
! 1855: {
! 1856: struct wpi_softc *sc = ifp->if_softc;
! 1857: struct ieee80211com *ic = &sc->sc_ic;
! 1858: struct ifaddr *ifa;
! 1859: struct ifreq *ifr;
! 1860: int s, error = 0;
! 1861:
! 1862: s = splnet();
! 1863:
! 1864: switch (cmd) {
! 1865: case SIOCSIFADDR:
! 1866: ifa = (struct ifaddr *)data;
! 1867: ifp->if_flags |= IFF_UP;
! 1868: #ifdef INET
! 1869: if (ifa->ifa_addr->sa_family == AF_INET)
! 1870: arp_ifinit(&ic->ic_ac, ifa);
! 1871: #endif
! 1872: /* FALLTHROUGH */
! 1873: case SIOCSIFFLAGS:
! 1874: if (ifp->if_flags & IFF_UP) {
! 1875: if (!(ifp->if_flags & IFF_RUNNING))
! 1876: wpi_init(ifp);
! 1877: } else {
! 1878: if (ifp->if_flags & IFF_RUNNING)
! 1879: wpi_stop(ifp, 1);
! 1880: }
! 1881: break;
! 1882:
! 1883: case SIOCADDMULTI:
! 1884: case SIOCDELMULTI:
! 1885: ifr = (struct ifreq *)data;
! 1886: error = (cmd == SIOCADDMULTI) ?
! 1887: ether_addmulti(ifr, &ic->ic_ac) :
! 1888: ether_delmulti(ifr, &ic->ic_ac);
! 1889:
! 1890: if (error == ENETRESET)
! 1891: error = 0;
! 1892: break;
! 1893:
! 1894: default:
! 1895: error = ieee80211_ioctl(ifp, cmd, data);
! 1896: }
! 1897:
! 1898: if (error == ENETRESET) {
! 1899: if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
! 1900: (IFF_UP | IFF_RUNNING))
! 1901: wpi_init(ifp);
! 1902: error = 0;
! 1903: }
! 1904:
! 1905: splx(s);
! 1906: return error;
! 1907: }
! 1908:
! 1909: void
! 1910: wpi_read_eeprom(struct wpi_softc *sc)
! 1911: {
! 1912: struct ieee80211com *ic = &sc->sc_ic;
! 1913: char domain[4];
! 1914: int i;
! 1915:
! 1916: wpi_read_prom_data(sc, WPI_EEPROM_CAPABILITIES, &sc->cap, 1);
! 1917: wpi_read_prom_data(sc, WPI_EEPROM_REVISION, &sc->rev, 2);
! 1918: wpi_read_prom_data(sc, WPI_EEPROM_TYPE, &sc->type, 1);
! 1919:
! 1920: DPRINTF(("cap=%x rev=%x type=%x\n", sc->cap, letoh16(sc->rev),
! 1921: sc->type));
! 1922:
! 1923: /* read and print regulatory domain */
! 1924: wpi_read_prom_data(sc, WPI_EEPROM_DOMAIN, domain, 4);
! 1925: printf(", %.4s", domain);
! 1926:
! 1927: /* read and print MAC address */
! 1928: wpi_read_prom_data(sc, WPI_EEPROM_MAC, ic->ic_myaddr, 6);
! 1929: printf(", address %s\n", ether_sprintf(ic->ic_myaddr));
! 1930:
! 1931: /* read the list of authorized channels */
! 1932: for (i = 0; i < WPI_CHAN_BANDS_COUNT; i++)
! 1933: wpi_read_eeprom_channels(sc, i);
! 1934:
! 1935: /* read the list of power groups */
! 1936: for (i = 0; i < WPI_POWER_GROUPS_COUNT; i++)
! 1937: wpi_read_eeprom_group(sc, i);
! 1938: }
! 1939:
! 1940: void
! 1941: wpi_read_eeprom_channels(struct wpi_softc *sc, int n)
! 1942: {
! 1943: struct ieee80211com *ic = &sc->sc_ic;
! 1944: const struct wpi_chan_band *band = &wpi_bands[n];
! 1945: struct wpi_eeprom_chan channels[WPI_MAX_CHAN_PER_BAND];
! 1946: int chan, i;
! 1947:
! 1948: wpi_read_prom_data(sc, band->addr, channels,
! 1949: band->nchan * sizeof (struct wpi_eeprom_chan));
! 1950:
! 1951: for (i = 0; i < band->nchan; i++) {
! 1952: if (!(channels[i].flags & WPI_EEPROM_CHAN_VALID))
! 1953: continue;
! 1954:
! 1955: chan = band->chan[i];
! 1956:
! 1957: if (n == 0) { /* 2GHz band */
! 1958: ic->ic_channels[chan].ic_freq =
! 1959: ieee80211_ieee2mhz(chan, IEEE80211_CHAN_2GHZ);
! 1960: ic->ic_channels[chan].ic_flags =
! 1961: IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM |
! 1962: IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ;
! 1963:
! 1964: } else { /* 5GHz band */
! 1965: /*
! 1966: * Some 3945ABG adapters support channels 7, 8, 11
! 1967: * and 12 in the 2GHz *and* 5GHz bands.
! 1968: * Because of limitations in our net80211(9) stack,
! 1969: * we can't support these channels in 5GHz band.
! 1970: */
! 1971: if (chan <= 14)
! 1972: continue;
! 1973:
! 1974: ic->ic_channels[chan].ic_freq =
! 1975: ieee80211_ieee2mhz(chan, IEEE80211_CHAN_5GHZ);
! 1976: ic->ic_channels[chan].ic_flags = IEEE80211_CHAN_A;
! 1977: }
! 1978:
! 1979: /* is active scan allowed on this channel? */
! 1980: if (!(channels[i].flags & WPI_EEPROM_CHAN_ACTIVE)) {
! 1981: ic->ic_channels[chan].ic_flags |=
! 1982: IEEE80211_CHAN_PASSIVE;
! 1983: }
! 1984:
! 1985: /* save maximum allowed power for this channel */
! 1986: sc->maxpwr[chan] = channels[i].maxpwr;
! 1987:
! 1988: DPRINTF(("adding chan %d flags=0x%x maxpwr=%d\n",
! 1989: chan, channels[i].flags, sc->maxpwr[chan]));
! 1990: }
! 1991: }
! 1992:
! 1993: void
! 1994: wpi_read_eeprom_group(struct wpi_softc *sc, int n)
! 1995: {
! 1996: struct wpi_power_group *group = &sc->groups[n];
! 1997: struct wpi_eeprom_group rgroup;
! 1998: int i;
! 1999:
! 2000: wpi_read_prom_data(sc, WPI_EEPROM_POWER_GRP + n * 32, &rgroup,
! 2001: sizeof rgroup);
! 2002:
! 2003: /* save power group information */
! 2004: group->chan = rgroup.chan;
! 2005: group->maxpwr = rgroup.maxpwr;
! 2006: /* temperature at which the samples were taken */
! 2007: group->temp = (int16_t)letoh16(rgroup.temp);
! 2008:
! 2009: DPRINTF(("power group %d: chan=%d maxpwr=%d temp=%d\n", n,
! 2010: group->chan, group->maxpwr, group->temp));
! 2011:
! 2012: for (i = 0; i < WPI_SAMPLES_COUNT; i++) {
! 2013: group->samples[i].index = rgroup.samples[i].index;
! 2014: group->samples[i].power = rgroup.samples[i].power;
! 2015:
! 2016: DPRINTF(("\tsample %d: index=%d power=%d\n", i,
! 2017: group->samples[i].index, group->samples[i].power));
! 2018: }
! 2019: }
! 2020:
! 2021: /*
! 2022: * Send a command to the firmware.
! 2023: */
! 2024: int
! 2025: wpi_cmd(struct wpi_softc *sc, int code, const void *buf, int size, int async)
! 2026: {
! 2027: struct wpi_tx_ring *ring = &sc->cmdq;
! 2028: struct wpi_tx_desc *desc;
! 2029: struct wpi_tx_cmd *cmd;
! 2030:
! 2031: KASSERT(size <= sizeof cmd->data);
! 2032:
! 2033: desc = &ring->desc[ring->cur];
! 2034: cmd = &ring->cmd[ring->cur];
! 2035:
! 2036: cmd->code = code;
! 2037: cmd->flags = 0;
! 2038: cmd->qid = ring->qid;
! 2039: cmd->idx = ring->cur;
! 2040: memcpy(cmd->data, buf, size);
! 2041:
! 2042: desc->flags = htole32(WPI_PAD32(size) << 28 | 1 << 24);
! 2043: desc->segs[0].addr = htole32(ring->cmd_dma.paddr +
! 2044: ring->cur * sizeof (struct wpi_tx_cmd));
! 2045: desc->segs[0].len = htole32(4 + size);
! 2046:
! 2047: /* kick cmd ring */
! 2048: ring->cur = (ring->cur + 1) % WPI_CMD_RING_COUNT;
! 2049: WPI_WRITE(sc, WPI_TX_WIDX, ring->qid << 8 | ring->cur);
! 2050:
! 2051: return async ? 0 : tsleep(cmd, PCATCH, "wpicmd", hz);
! 2052: }
! 2053:
! 2054: /*
! 2055: * Configure h/w multi-rate retries.
! 2056: */
! 2057: int
! 2058: wpi_mrr_setup(struct wpi_softc *sc)
! 2059: {
! 2060: struct ieee80211com *ic = &sc->sc_ic;
! 2061: struct wpi_mrr_setup mrr;
! 2062: int i, error;
! 2063:
! 2064: /* CCK rates (not used with 802.11a) */
! 2065: for (i = WPI_CCK1; i <= WPI_CCK11; i++) {
! 2066: mrr.rates[i].flags = 0;
! 2067: mrr.rates[i].plcp = wpi_ridx_to_plcp[i];
! 2068: /* fallback to the immediate lower CCK rate (if any) */
! 2069: mrr.rates[i].next = (i == WPI_CCK1) ? WPI_CCK1 : i - 1;
! 2070: /* try one time at this rate before falling back to "next" */
! 2071: mrr.rates[i].ntries = 1;
! 2072: }
! 2073:
! 2074: /* OFDM rates (not used with 802.11b) */
! 2075: for (i = WPI_OFDM6; i <= WPI_OFDM54; i++) {
! 2076: mrr.rates[i].flags = 0;
! 2077: mrr.rates[i].plcp = wpi_ridx_to_plcp[i];
! 2078: /* fallback to the immediate lower rate (if any) */
! 2079: /* we allow fallback from OFDM/6 to CCK/2 in 11b/g mode */
! 2080: mrr.rates[i].next = (i == WPI_OFDM6) ?
! 2081: ((ic->ic_curmode == IEEE80211_MODE_11A) ?
! 2082: WPI_OFDM6 : WPI_CCK2) :
! 2083: i - 1;
! 2084: /* try one time at this rate before falling back to "next" */
! 2085: mrr.rates[i].ntries = 1;
! 2086: }
! 2087:
! 2088: /* setup MRR for control frames */
! 2089: mrr.which = htole32(WPI_MRR_CTL);
! 2090: error = wpi_cmd(sc, WPI_CMD_MRR_SETUP, &mrr, sizeof mrr, 0);
! 2091: if (error != 0) {
! 2092: printf("%s: could not setup MRR for control frames\n",
! 2093: sc->sc_dev.dv_xname);
! 2094: return error;
! 2095: }
! 2096:
! 2097: /* setup MRR for data frames */
! 2098: mrr.which = htole32(WPI_MRR_DATA);
! 2099: error = wpi_cmd(sc, WPI_CMD_MRR_SETUP, &mrr, sizeof mrr, 0);
! 2100: if (error != 0) {
! 2101: printf("%s: could not setup MRR for data frames\n",
! 2102: sc->sc_dev.dv_xname);
! 2103: return error;
! 2104: }
! 2105:
! 2106: return 0;
! 2107: }
! 2108:
! 2109: void
! 2110: wpi_set_led(struct wpi_softc *sc, uint8_t which, uint8_t off, uint8_t on)
! 2111: {
! 2112: struct wpi_cmd_led led;
! 2113:
! 2114: led.which = which;
! 2115: led.unit = htole32(100000); /* on/off in unit of 100ms */
! 2116: led.off = off;
! 2117: led.on = on;
! 2118:
! 2119: (void)wpi_cmd(sc, WPI_CMD_SET_LED, &led, sizeof led, 1);
! 2120: }
! 2121:
! 2122: void
! 2123: wpi_enable_tsf(struct wpi_softc *sc, struct ieee80211_node *ni)
! 2124: {
! 2125: struct wpi_cmd_tsf tsf;
! 2126: uint64_t val, mod;
! 2127:
! 2128: memset(&tsf, 0, sizeof tsf);
! 2129: memcpy(&tsf.tstamp, ni->ni_tstamp, sizeof (uint64_t));
! 2130: tsf.bintval = htole16(ni->ni_intval);
! 2131: tsf.lintval = htole16(10);
! 2132:
! 2133: /* compute remaining time until next beacon */
! 2134: val = (uint64_t)ni->ni_intval * 1024; /* msecs -> usecs */
! 2135: mod = letoh64(tsf.tstamp) % val;
! 2136: tsf.binitval = htole32((uint32_t)(val - mod));
! 2137:
! 2138: DPRINTF(("TSF bintval=%u tstamp=%llu, init=%u\n",
! 2139: ni->ni_intval, letoh64(tsf.tstamp), (uint32_t)(val - mod)));
! 2140:
! 2141: if (wpi_cmd(sc, WPI_CMD_TSF, &tsf, sizeof tsf, 1) != 0)
! 2142: printf("%s: could not enable TSF\n", sc->sc_dev.dv_xname);
! 2143: }
! 2144:
! 2145: /*
! 2146: * Update Tx power to match what is defined for channel `c'.
! 2147: */
! 2148: int
! 2149: wpi_set_txpower(struct wpi_softc *sc, struct ieee80211_channel *c, int async)
! 2150: {
! 2151: struct ieee80211com *ic = &sc->sc_ic;
! 2152: struct wpi_power_group *group;
! 2153: struct wpi_cmd_txpower txpower;
! 2154: u_int chan;
! 2155: int i;
! 2156:
! 2157: /* get channel number */
! 2158: chan = ieee80211_chan2ieee(ic, c);
! 2159:
! 2160: /* find the power group to which this channel belongs */
! 2161: if (IEEE80211_IS_CHAN_5GHZ(c)) {
! 2162: for (group = &sc->groups[1]; group < &sc->groups[4]; group++)
! 2163: if (chan <= group->chan)
! 2164: break;
! 2165: } else
! 2166: group = &sc->groups[0];
! 2167:
! 2168: memset(&txpower, 0, sizeof txpower);
! 2169: txpower.band = IEEE80211_IS_CHAN_5GHZ(c) ? 0 : 1;
! 2170: txpower.chan = htole16(chan);
! 2171:
! 2172: /* set Tx power for all OFDM and CCK rates */
! 2173: for (i = 0; i <= 11 ; i++) {
! 2174: /* retrieve Tx power for this channel/rate combination */
! 2175: int idx = wpi_get_power_index(sc, group, c,
! 2176: wpi_ridx_to_rate[i]);
! 2177:
! 2178: txpower.rates[i].plcp = wpi_ridx_to_plcp[i];
! 2179:
! 2180: if (IEEE80211_IS_CHAN_5GHZ(c)) {
! 2181: txpower.rates[i].rf_gain = wpi_rf_gain_5ghz[idx];
! 2182: txpower.rates[i].dsp_gain = wpi_dsp_gain_5ghz[idx];
! 2183: } else {
! 2184: txpower.rates[i].rf_gain = wpi_rf_gain_2ghz[idx];
! 2185: txpower.rates[i].dsp_gain = wpi_dsp_gain_2ghz[idx];
! 2186: }
! 2187: DPRINTF(("chan %d/rate %d: power index %d\n", chan,
! 2188: wpi_ridx_to_rate[i], idx));
! 2189: }
! 2190:
! 2191: return wpi_cmd(sc, WPI_CMD_TXPOWER, &txpower, sizeof txpower, async);
! 2192: }
! 2193:
! 2194: /*
! 2195: * Determine Tx power index for a given channel/rate combination.
! 2196: * This takes into account the regulatory information from EEPROM and the
! 2197: * current temperature.
! 2198: */
! 2199: int
! 2200: wpi_get_power_index(struct wpi_softc *sc, struct wpi_power_group *group,
! 2201: struct ieee80211_channel *c, int rate)
! 2202: {
! 2203: /* fixed-point arithmetic division using a n-bit fractional part */
! 2204: #define fdivround(a, b, n) \
! 2205: ((((1 << n) * (a)) / (b) + (1 << n) / 2) / (1 << n))
! 2206:
! 2207: /* linear interpolation */
! 2208: #define interpolate(x, x1, y1, x2, y2, n) \
! 2209: ((y1) + fdivround(((x) - (x1)) * ((y2) - (y1)), (x2) - (x1), n))
! 2210:
! 2211: struct ieee80211com *ic = &sc->sc_ic;
! 2212: struct wpi_power_sample *sample;
! 2213: int pwr, idx;
! 2214: u_int chan;
! 2215:
! 2216: /* get channel number */
! 2217: chan = ieee80211_chan2ieee(ic, c);
! 2218:
! 2219: /* default power is group's maximum power - 3dB */
! 2220: pwr = group->maxpwr / 2;
! 2221:
! 2222: /* decrease power for highest OFDM rates to reduce distortion */
! 2223: switch (rate) {
! 2224: case 72: /* 36Mb/s */
! 2225: pwr -= IEEE80211_IS_CHAN_2GHZ(c) ? 0 : 5;
! 2226: break;
! 2227: case 96: /* 48Mb/s */
! 2228: pwr -= IEEE80211_IS_CHAN_2GHZ(c) ? 7 : 10;
! 2229: break;
! 2230: case 108: /* 54Mb/s */
! 2231: pwr -= IEEE80211_IS_CHAN_2GHZ(c) ? 9 : 12;
! 2232: break;
! 2233: }
! 2234:
! 2235: /* never exceed channel's maximum allowed Tx power */
! 2236: pwr = min(pwr, sc->maxpwr[chan]);
! 2237:
! 2238: /* retrieve power index into gain tables from samples */
! 2239: for (sample = group->samples; sample < &group->samples[3]; sample++)
! 2240: if (pwr > sample[1].power)
! 2241: break;
! 2242: /* fixed-point linear interpolation using a 19-bit fractional part */
! 2243: idx = interpolate(pwr, sample[0].power, sample[0].index,
! 2244: sample[1].power, sample[1].index, 19);
! 2245:
! 2246: /*-
! 2247: * Adjust power index based on current temperature:
! 2248: * - if cooler than factory-calibrated: decrease output power
! 2249: * - if warmer than factory-calibrated: increase output power
! 2250: */
! 2251: idx -= (sc->temp - group->temp) * 11 / 100;
! 2252:
! 2253: /* decrease power for CCK rates (-5dB) */
! 2254: if (!WPI_RATE_IS_OFDM(rate))
! 2255: idx += 10;
! 2256:
! 2257: /* keep power index in a valid range */
! 2258: if (idx < 0)
! 2259: return 0;
! 2260: if (idx > WPI_MAX_PWR_INDEX)
! 2261: return WPI_MAX_PWR_INDEX;
! 2262: return idx;
! 2263:
! 2264: #undef interpolate
! 2265: #undef fdivround
! 2266: }
! 2267:
! 2268: /*
! 2269: * Build a beacon frame that the firmware will broadcast periodically in
! 2270: * IBSS or HostAP modes.
! 2271: */
! 2272: #ifdef notyet
! 2273: int
! 2274: wpi_setup_beacon(struct wpi_softc *sc, struct ieee80211_node *ni)
! 2275: {
! 2276: struct ieee80211com *ic = &sc->sc_ic;
! 2277: struct wpi_tx_ring *ring = &sc->cmdq;
! 2278: struct wpi_tx_desc *desc;
! 2279: struct wpi_tx_data *data;
! 2280: struct wpi_tx_cmd *cmd;
! 2281: struct wpi_cmd_beacon *bcn;
! 2282: struct mbuf *m0;
! 2283: int error;
! 2284:
! 2285: desc = &ring->desc[ring->cur];
! 2286: data = &ring->data[ring->cur];
! 2287:
! 2288: m0 = ieee80211_beacon_alloc(ic, ni);
! 2289: if (m0 == NULL) {
! 2290: printf("%s: could not allocate beacon frame\n",
! 2291: sc->sc_dev.dv_xname);
! 2292: return ENOMEM;
! 2293: }
! 2294:
! 2295: cmd = &ring->cmd[ring->cur];
! 2296: cmd->code = WPI_CMD_SET_BEACON;
! 2297: cmd->flags = 0;
! 2298: cmd->qid = ring->qid;
! 2299: cmd->idx = ring->cur;
! 2300:
! 2301: bcn = (struct wpi_cmd_beacon *)cmd->data;
! 2302: memset(bcn, 0, sizeof (struct wpi_cmd_beacon));
! 2303: bcn->id = WPI_ID_BROADCAST;
! 2304: bcn->ofdm_mask = 0xff;
! 2305: bcn->cck_mask = 0x0f;
! 2306: bcn->lifetime = htole32(WPI_LIFETIME_INFINITE);
! 2307: bcn->len = htole16(m0->m_pkthdr.len);
! 2308: bcn->rate = (ic->ic_curmode == IEEE80211_MODE_11A) ?
! 2309: wpi_plcp_signal(12) : wpi_plcp_signal(2);
! 2310: bcn->flags = htole32(WPI_TX_AUTO_SEQ | WPI_TX_INSERT_TSTAMP);
! 2311:
! 2312: /* save and trim IEEE802.11 header */
! 2313: m_copydata(m0, 0, sizeof (struct ieee80211_frame), (caddr_t)&bcn->wh);
! 2314: m_adj(m0, sizeof (struct ieee80211_frame));
! 2315:
! 2316: /* assume beacon frame is contiguous */
! 2317: error = bus_dmamap_load(sc->sc_dmat, data->map, mtod(m0, void *),
! 2318: m0->m_pkthdr.len, NULL, BUS_DMA_NOWAIT);
! 2319: if (error != 0) {
! 2320: printf("%s: could not map beacon\n", sc->sc_dev.dv_xname);
! 2321: m_freem(m0);
! 2322: return error;
! 2323: }
! 2324:
! 2325: data->m = m0;
! 2326:
! 2327: /* first scatter/gather segment is used by the beacon command */
! 2328: desc->flags = htole32(WPI_PAD32(m0->m_pkthdr.len) << 28 | 2 << 24);
! 2329: desc->segs[0].addr = htole32(ring->cmd_dma.paddr +
! 2330: ring->cur * sizeof (struct wpi_tx_cmd));
! 2331: desc->segs[0].len = htole32(4 + sizeof (struct wpi_cmd_beacon));
! 2332: desc->segs[1].addr = htole32(data->map->dm_segs[0].ds_addr);
! 2333: desc->segs[1].len = htole32(data->map->dm_segs[0].ds_len);
! 2334:
! 2335: /* kick cmd ring */
! 2336: ring->cur = (ring->cur + 1) % WPI_CMD_RING_COUNT;
! 2337: WPI_WRITE(sc, WPI_TX_WIDX, ring->qid << 8 | ring->cur);
! 2338:
! 2339: return 0;
! 2340: }
! 2341: #endif
! 2342:
! 2343: int
! 2344: wpi_auth(struct wpi_softc *sc)
! 2345: {
! 2346: struct ieee80211com *ic = &sc->sc_ic;
! 2347: struct ieee80211_node *ni = ic->ic_bss;
! 2348: struct wpi_node_info node;
! 2349: int error;
! 2350:
! 2351: /* update adapter's configuration */
! 2352: IEEE80211_ADDR_COPY(sc->config.bssid, ni->ni_bssid);
! 2353: sc->config.chan = ieee80211_chan2ieee(ic, ni->ni_chan);
! 2354: if (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan)) {
! 2355: sc->config.flags |= htole32(WPI_CONFIG_AUTO |
! 2356: WPI_CONFIG_24GHZ);
! 2357: }
! 2358: switch (ic->ic_curmode) {
! 2359: case IEEE80211_MODE_11A:
! 2360: sc->config.cck_mask = 0;
! 2361: sc->config.ofdm_mask = 0x15;
! 2362: break;
! 2363: case IEEE80211_MODE_11B:
! 2364: sc->config.cck_mask = 0x03;
! 2365: sc->config.ofdm_mask = 0;
! 2366: break;
! 2367: default: /* assume 802.11b/g */
! 2368: sc->config.cck_mask = 0x0f;
! 2369: sc->config.ofdm_mask = 0x15;
! 2370: }
! 2371: if (ic->ic_flags & IEEE80211_F_SHSLOT)
! 2372: sc->config.flags |= htole32(WPI_CONFIG_SHSLOT);
! 2373: if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
! 2374: sc->config.flags |= htole32(WPI_CONFIG_SHPREAMBLE);
! 2375: DPRINTF(("config chan %d flags %x cck %x ofdm %x\n", sc->config.chan,
! 2376: sc->config.flags, sc->config.cck_mask, sc->config.ofdm_mask));
! 2377: error = wpi_cmd(sc, WPI_CMD_CONFIGURE, &sc->config,
! 2378: sizeof (struct wpi_config), 1);
! 2379: if (error != 0) {
! 2380: printf("%s: could not configure\n", sc->sc_dev.dv_xname);
! 2381: return error;
! 2382: }
! 2383:
! 2384: /* configuration has changed, set Tx power accordingly */
! 2385: if ((error = wpi_set_txpower(sc, ni->ni_chan, 1)) != 0) {
! 2386: printf("%s: could not set Tx power\n", sc->sc_dev.dv_xname);
! 2387: return error;
! 2388: }
! 2389:
! 2390: /* add default node */
! 2391: memset(&node, 0, sizeof node);
! 2392: IEEE80211_ADDR_COPY(node.bssid, ni->ni_bssid);
! 2393: node.id = WPI_ID_BSS;
! 2394: node.rate = (ic->ic_curmode == IEEE80211_MODE_11A) ?
! 2395: wpi_plcp_signal(12) : wpi_plcp_signal(2);
! 2396: node.action = htole32(WPI_ACTION_SET_RATE);
! 2397: node.antenna = WPI_ANTENNA_BOTH;
! 2398: error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1);
! 2399: if (error != 0) {
! 2400: printf("%s: could not add BSS node\n", sc->sc_dev.dv_xname);
! 2401: return error;
! 2402: }
! 2403:
! 2404: return 0;
! 2405: }
! 2406:
! 2407: /*
! 2408: * Send a scan request to the firmware. Since this command is huge, we map it
! 2409: * into a mbuf instead of using the pre-allocated set of commands.
! 2410: */
! 2411: int
! 2412: wpi_scan(struct wpi_softc *sc, uint16_t flags)
! 2413: {
! 2414: struct ieee80211com *ic = &sc->sc_ic;
! 2415: struct wpi_tx_ring *ring = &sc->cmdq;
! 2416: struct wpi_tx_desc *desc;
! 2417: struct wpi_tx_data *data;
! 2418: struct wpi_tx_cmd *cmd;
! 2419: struct wpi_scan_hdr *hdr;
! 2420: struct wpi_scan_chan *chan;
! 2421: struct ieee80211_frame *wh;
! 2422: struct ieee80211_rateset *rs;
! 2423: struct ieee80211_channel *c;
! 2424: enum ieee80211_phymode mode;
! 2425: uint8_t *frm;
! 2426: int pktlen, error;
! 2427:
! 2428: desc = &ring->desc[ring->cur];
! 2429: data = &ring->data[ring->cur];
! 2430:
! 2431: MGETHDR(data->m, M_DONTWAIT, MT_DATA);
! 2432: if (data->m == NULL) {
! 2433: printf("%s: could not allocate mbuf for scan command\n",
! 2434: sc->sc_dev.dv_xname);
! 2435: return ENOMEM;
! 2436: }
! 2437: MCLGET(data->m, M_DONTWAIT);
! 2438: if (!(data->m->m_flags & M_EXT)) {
! 2439: m_freem(data->m);
! 2440: data->m = NULL;
! 2441: printf("%s: could not allocate mbuf for scan command\n",
! 2442: sc->sc_dev.dv_xname);
! 2443: return ENOMEM;
! 2444: }
! 2445:
! 2446: cmd = mtod(data->m, struct wpi_tx_cmd *);
! 2447: cmd->code = WPI_CMD_SCAN;
! 2448: cmd->flags = 0;
! 2449: cmd->qid = ring->qid;
! 2450: cmd->idx = ring->cur;
! 2451:
! 2452: hdr = (struct wpi_scan_hdr *)cmd->data;
! 2453: memset(hdr, 0, sizeof (struct wpi_scan_hdr));
! 2454: hdr->txflags = htole32(WPI_TX_AUTO_SEQ);
! 2455: hdr->id = WPI_ID_BROADCAST;
! 2456: hdr->lifetime = htole32(WPI_LIFETIME_INFINITE);
! 2457: /*
! 2458: * Move to the next channel if no packets are received within 5 msecs
! 2459: * after sending the probe request (this helps to reduce the duration
! 2460: * of active scans).
! 2461: */
! 2462: hdr->quiet = htole16(5); /* timeout in milliseconds */
! 2463: hdr->plcp_threshold = htole16(1); /* min # of packets */
! 2464:
! 2465: if (flags & IEEE80211_CHAN_A) {
! 2466: hdr->crc_threshold = htole16(1);
! 2467: /* send probe requests at 6Mbps */
! 2468: hdr->rate = wpi_plcp_signal(12);
! 2469: } else {
! 2470: hdr->flags = htole32(WPI_CONFIG_24GHZ | WPI_CONFIG_AUTO);
! 2471: /* send probe requests at 1Mbps */
! 2472: hdr->rate = wpi_plcp_signal(2);
! 2473: }
! 2474:
! 2475: /* for directed scans, firmware inserts the essid IE itself */
! 2476: hdr->essid[0].id = IEEE80211_ELEMID_SSID;
! 2477: hdr->essid[0].len = ic->ic_des_esslen;
! 2478: memcpy(hdr->essid[0].data, ic->ic_des_essid, ic->ic_des_esslen);
! 2479:
! 2480: /*
! 2481: * Build a probe request frame. Most of the following code is a
! 2482: * copy & paste of what is done in net80211.
! 2483: */
! 2484: wh = (struct ieee80211_frame *)(hdr + 1);
! 2485: wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT |
! 2486: IEEE80211_FC0_SUBTYPE_PROBE_REQ;
! 2487: wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
! 2488: IEEE80211_ADDR_COPY(wh->i_addr1, etherbroadcastaddr);
! 2489: IEEE80211_ADDR_COPY(wh->i_addr2, ic->ic_myaddr);
! 2490: IEEE80211_ADDR_COPY(wh->i_addr3, etherbroadcastaddr);
! 2491: *(u_int16_t *)&wh->i_dur[0] = 0; /* filled by h/w */
! 2492: *(u_int16_t *)&wh->i_seq[0] = 0; /* filled by h/w */
! 2493:
! 2494: frm = (uint8_t *)(wh + 1);
! 2495:
! 2496: /* add empty essid IE (firmware generates it for directed scans) */
! 2497: *frm++ = IEEE80211_ELEMID_SSID;
! 2498: *frm++ = 0;
! 2499:
! 2500: mode = ieee80211_chan2mode(ic, ic->ic_ibss_chan);
! 2501: rs = &ic->ic_sup_rates[mode];
! 2502:
! 2503: /* add supported rates IE */
! 2504: frm = ieee80211_add_rates(frm, rs);
! 2505:
! 2506: /* add supported xrates IE */
! 2507: if (rs->rs_nrates > IEEE80211_RATE_SIZE)
! 2508: frm = ieee80211_add_xrates(frm, rs);
! 2509:
! 2510: /* setup length of probe request */
! 2511: hdr->paylen = htole16(frm - (uint8_t *)wh);
! 2512:
! 2513: chan = (struct wpi_scan_chan *)frm;
! 2514: for (c = &ic->ic_channels[1];
! 2515: c <= &ic->ic_channels[IEEE80211_CHAN_MAX]; c++) {
! 2516: if ((c->ic_flags & flags) != flags)
! 2517: continue;
! 2518:
! 2519: chan->chan = ieee80211_chan2ieee(ic, c);
! 2520: chan->flags = 0;
! 2521: if (!(c->ic_flags & IEEE80211_CHAN_PASSIVE)) {
! 2522: chan->flags |= WPI_CHAN_ACTIVE;
! 2523: if (ic->ic_des_esslen != 0)
! 2524: chan->flags |= WPI_CHAN_DIRECT;
! 2525: }
! 2526: chan->dsp_gain = 0x6e;
! 2527: if (IEEE80211_IS_CHAN_5GHZ(c)) {
! 2528: chan->rf_gain = 0x3b;
! 2529: chan->active = htole16(10);
! 2530: chan->passive = htole16(110);
! 2531: } else {
! 2532: chan->rf_gain = 0x28;
! 2533: chan->active = htole16(20);
! 2534: chan->passive = htole16(120);
! 2535: }
! 2536: hdr->nchan++;
! 2537: chan++;
! 2538:
! 2539: frm += sizeof (struct wpi_scan_chan);
! 2540: }
! 2541:
! 2542: hdr->len = htole16(frm - (uint8_t *)hdr);
! 2543: pktlen = frm - (uint8_t *)cmd;
! 2544:
! 2545: error = bus_dmamap_load(sc->sc_dmat, data->map, cmd, pktlen, NULL,
! 2546: BUS_DMA_NOWAIT);
! 2547: if (error != 0) {
! 2548: printf("%s: could not map scan command\n",
! 2549: sc->sc_dev.dv_xname);
! 2550: m_freem(data->m);
! 2551: data->m = NULL;
! 2552: return error;
! 2553: }
! 2554:
! 2555: desc->flags = htole32(WPI_PAD32(pktlen) << 28 | 1 << 24);
! 2556: desc->segs[0].addr = htole32(data->map->dm_segs[0].ds_addr);
! 2557: desc->segs[0].len = htole32(data->map->dm_segs[0].ds_len);
! 2558:
! 2559: /* kick cmd ring */
! 2560: ring->cur = (ring->cur + 1) % WPI_CMD_RING_COUNT;
! 2561: WPI_WRITE(sc, WPI_TX_WIDX, ring->qid << 8 | ring->cur);
! 2562:
! 2563: return 0; /* will be notified async. of failure/success */
! 2564: }
! 2565:
! 2566: int
! 2567: wpi_config(struct wpi_softc *sc)
! 2568: {
! 2569: struct ieee80211com *ic = &sc->sc_ic;
! 2570: struct ifnet *ifp = &ic->ic_if;
! 2571: struct wpi_power power;
! 2572: struct wpi_bluetooth bluetooth;
! 2573: struct wpi_node_info node;
! 2574: int error;
! 2575:
! 2576: /* set power mode */
! 2577: memset(&power, 0, sizeof power);
! 2578: power.flags = htole32(WPI_POWER_CAM | 0x8);
! 2579: error = wpi_cmd(sc, WPI_CMD_SET_POWER_MODE, &power, sizeof power, 0);
! 2580: if (error != 0) {
! 2581: printf("%s: could not set power mode\n", sc->sc_dev.dv_xname);
! 2582: return error;
! 2583: }
! 2584:
! 2585: /* configure bluetooth coexistence */
! 2586: memset(&bluetooth, 0, sizeof bluetooth);
! 2587: bluetooth.flags = 3;
! 2588: bluetooth.lead = 0xaa;
! 2589: bluetooth.kill = 1;
! 2590: error = wpi_cmd(sc, WPI_CMD_BLUETOOTH, &bluetooth, sizeof bluetooth,
! 2591: 0);
! 2592: if (error != 0) {
! 2593: printf("%s: could not configure bluetooth coexistence\n",
! 2594: sc->sc_dev.dv_xname);
! 2595: return error;
! 2596: }
! 2597:
! 2598: /* configure adapter */
! 2599: memset(&sc->config, 0, sizeof (struct wpi_config));
! 2600: IEEE80211_ADDR_COPY(ic->ic_myaddr, LLADDR(ifp->if_sadl));
! 2601: IEEE80211_ADDR_COPY(sc->config.myaddr, ic->ic_myaddr);
! 2602: /* set default channel */
! 2603: sc->config.chan = ieee80211_chan2ieee(ic, ic->ic_ibss_chan);
! 2604: sc->config.flags = htole32(WPI_CONFIG_TSF);
! 2605: if (IEEE80211_IS_CHAN_2GHZ(ic->ic_ibss_chan)) {
! 2606: sc->config.flags |= htole32(WPI_CONFIG_AUTO |
! 2607: WPI_CONFIG_24GHZ);
! 2608: }
! 2609: sc->config.filter = 0;
! 2610: switch (ic->ic_opmode) {
! 2611: case IEEE80211_M_STA:
! 2612: sc->config.mode = WPI_MODE_STA;
! 2613: sc->config.filter |= htole32(WPI_FILTER_MULTICAST);
! 2614: break;
! 2615: case IEEE80211_M_IBSS:
! 2616: case IEEE80211_M_AHDEMO:
! 2617: sc->config.mode = WPI_MODE_IBSS;
! 2618: break;
! 2619: case IEEE80211_M_HOSTAP:
! 2620: sc->config.mode = WPI_MODE_HOSTAP;
! 2621: break;
! 2622: case IEEE80211_M_MONITOR:
! 2623: sc->config.mode = WPI_MODE_MONITOR;
! 2624: sc->config.filter |= htole32(WPI_FILTER_MULTICAST |
! 2625: WPI_FILTER_CTL | WPI_FILTER_PROMISC);
! 2626: break;
! 2627: }
! 2628: sc->config.cck_mask = 0x0f; /* not yet negotiated */
! 2629: sc->config.ofdm_mask = 0xff; /* not yet negotiated */
! 2630: error = wpi_cmd(sc, WPI_CMD_CONFIGURE, &sc->config,
! 2631: sizeof (struct wpi_config), 0);
! 2632: if (error != 0) {
! 2633: printf("%s: configure command failed\n", sc->sc_dev.dv_xname);
! 2634: return error;
! 2635: }
! 2636:
! 2637: /* configuration has changed, set Tx power accordingly */
! 2638: if ((error = wpi_set_txpower(sc, ic->ic_ibss_chan, 0)) != 0) {
! 2639: printf("%s: could not set Tx power\n", sc->sc_dev.dv_xname);
! 2640: return error;
! 2641: }
! 2642:
! 2643: /* add broadcast node */
! 2644: memset(&node, 0, sizeof node);
! 2645: IEEE80211_ADDR_COPY(node.bssid, etherbroadcastaddr);
! 2646: node.id = WPI_ID_BROADCAST;
! 2647: node.rate = wpi_plcp_signal(2);
! 2648: node.action = htole32(WPI_ACTION_SET_RATE);
! 2649: node.antenna = WPI_ANTENNA_BOTH;
! 2650: error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 0);
! 2651: if (error != 0) {
! 2652: printf("%s: could not add broadcast node\n",
! 2653: sc->sc_dev.dv_xname);
! 2654: return error;
! 2655: }
! 2656:
! 2657: if ((error = wpi_mrr_setup(sc)) != 0) {
! 2658: printf("%s: could not setup MRR\n", sc->sc_dev.dv_xname);
! 2659: return error;
! 2660: }
! 2661:
! 2662: return 0;
! 2663: }
! 2664:
! 2665: void
! 2666: wpi_stop_master(struct wpi_softc *sc)
! 2667: {
! 2668: uint32_t tmp;
! 2669: int ntries;
! 2670:
! 2671: tmp = WPI_READ(sc, WPI_RESET);
! 2672: WPI_WRITE(sc, WPI_RESET, tmp | WPI_STOP_MASTER);
! 2673:
! 2674: tmp = WPI_READ(sc, WPI_GPIO_CTL);
! 2675: if ((tmp & WPI_GPIO_PWR_STATUS) == WPI_GPIO_PWR_SLEEP)
! 2676: return; /* already asleep */
! 2677:
! 2678: for (ntries = 0; ntries < 100; ntries++) {
! 2679: if (WPI_READ(sc, WPI_RESET) & WPI_MASTER_DISABLED)
! 2680: break;
! 2681: DELAY(10);
! 2682: }
! 2683: if (ntries == 100) {
! 2684: printf("%s: timeout waiting for master\n",
! 2685: sc->sc_dev.dv_xname);
! 2686: }
! 2687: }
! 2688:
! 2689: int
! 2690: wpi_power_up(struct wpi_softc *sc)
! 2691: {
! 2692: uint32_t tmp;
! 2693: int ntries;
! 2694:
! 2695: wpi_mem_lock(sc);
! 2696: tmp = wpi_mem_read(sc, WPI_MEM_POWER);
! 2697: wpi_mem_write(sc, WPI_MEM_POWER, tmp & ~0x03000000);
! 2698: wpi_mem_unlock(sc);
! 2699:
! 2700: for (ntries = 0; ntries < 5000; ntries++) {
! 2701: if (WPI_READ(sc, WPI_GPIO_STATUS) & WPI_POWERED)
! 2702: break;
! 2703: DELAY(10);
! 2704: }
! 2705: if (ntries == 5000) {
! 2706: printf("%s: timeout waiting for NIC to power up\n",
! 2707: sc->sc_dev.dv_xname);
! 2708: return ETIMEDOUT;
! 2709: }
! 2710: return 0;
! 2711: }
! 2712:
! 2713: int
! 2714: wpi_reset(struct wpi_softc *sc)
! 2715: {
! 2716: uint32_t tmp;
! 2717: int ntries;
! 2718:
! 2719: /* clear any pending interrupts */
! 2720: WPI_WRITE(sc, WPI_INTR, 0xffffffff);
! 2721:
! 2722: tmp = WPI_READ(sc, WPI_PLL_CTL);
! 2723: WPI_WRITE(sc, WPI_PLL_CTL, tmp | WPI_PLL_INIT);
! 2724:
! 2725: tmp = WPI_READ(sc, WPI_CHICKEN);
! 2726: WPI_WRITE(sc, WPI_CHICKEN, tmp | WPI_CHICKEN_RXNOLOS);
! 2727:
! 2728: tmp = WPI_READ(sc, WPI_GPIO_CTL);
! 2729: WPI_WRITE(sc, WPI_GPIO_CTL, tmp | WPI_GPIO_INIT);
! 2730:
! 2731: /* wait for clock stabilization */
! 2732: for (ntries = 0; ntries < 1000; ntries++) {
! 2733: if (WPI_READ(sc, WPI_GPIO_CTL) & WPI_GPIO_CLOCK)
! 2734: break;
! 2735: DELAY(10);
! 2736: }
! 2737: if (ntries == 1000) {
! 2738: printf("%s: timeout waiting for clock stabilization\n",
! 2739: sc->sc_dev.dv_xname);
! 2740: return ETIMEDOUT;
! 2741: }
! 2742:
! 2743: /* initialize EEPROM */
! 2744: tmp = WPI_READ(sc, WPI_EEPROM_STATUS);
! 2745: if ((tmp & WPI_EEPROM_VERSION) == 0) {
! 2746: printf("%s: EEPROM not found\n", sc->sc_dev.dv_xname);
! 2747: return EIO;
! 2748: }
! 2749: WPI_WRITE(sc, WPI_EEPROM_STATUS, tmp & ~WPI_EEPROM_LOCKED);
! 2750:
! 2751: return 0;
! 2752: }
! 2753:
! 2754: void
! 2755: wpi_hw_config(struct wpi_softc *sc)
! 2756: {
! 2757: uint32_t rev, hw;
! 2758:
! 2759: /* voodoo from the reference driver */
! 2760: hw = WPI_READ(sc, WPI_HWCONFIG);
! 2761:
! 2762: rev = pci_conf_read(sc->sc_pct, sc->sc_pcitag, PCI_CLASS_REG);
! 2763: rev = PCI_REVISION(rev);
! 2764: if ((rev & 0xc0) == 0x40)
! 2765: hw |= WPI_HW_ALM_MB;
! 2766: else if (!(rev & 0x80))
! 2767: hw |= WPI_HW_ALM_MM;
! 2768:
! 2769: if (sc->cap == 0x80)
! 2770: hw |= WPI_HW_SKU_MRC;
! 2771:
! 2772: hw &= ~WPI_HW_REV_D;
! 2773: if ((letoh16(sc->rev) & 0xf0) == 0xd0)
! 2774: hw |= WPI_HW_REV_D;
! 2775:
! 2776: if (sc->type > 1)
! 2777: hw |= WPI_HW_TYPE_B;
! 2778:
! 2779: DPRINTF(("setting h/w config %x\n", hw));
! 2780: WPI_WRITE(sc, WPI_HWCONFIG, hw);
! 2781: }
! 2782:
! 2783: int
! 2784: wpi_init(struct ifnet *ifp)
! 2785: {
! 2786: struct wpi_softc *sc = ifp->if_softc;
! 2787: struct ieee80211com *ic = &sc->sc_ic;
! 2788: uint32_t tmp;
! 2789: int qid, ntries, error;
! 2790:
! 2791: (void)wpi_reset(sc);
! 2792:
! 2793: wpi_mem_lock(sc);
! 2794: wpi_mem_write(sc, WPI_MEM_CLOCK1, 0xa00);
! 2795: DELAY(20);
! 2796: tmp = wpi_mem_read(sc, WPI_MEM_PCIDEV);
! 2797: wpi_mem_write(sc, WPI_MEM_PCIDEV, tmp | 0x800);
! 2798: wpi_mem_unlock(sc);
! 2799:
! 2800: (void)wpi_power_up(sc);
! 2801: wpi_hw_config(sc);
! 2802:
! 2803: /* init Rx ring */
! 2804: wpi_mem_lock(sc);
! 2805: WPI_WRITE(sc, WPI_RX_BASE, sc->rxq.desc_dma.paddr);
! 2806: WPI_WRITE(sc, WPI_RX_RIDX_PTR, sc->shared_dma.paddr +
! 2807: offsetof(struct wpi_shared, next));
! 2808: WPI_WRITE(sc, WPI_RX_WIDX, (WPI_RX_RING_COUNT - 1) & ~7);
! 2809: WPI_WRITE(sc, WPI_RX_CONFIG, 0xa9601010);
! 2810: wpi_mem_unlock(sc);
! 2811:
! 2812: /* init Tx rings */
! 2813: wpi_mem_lock(sc);
! 2814: wpi_mem_write(sc, WPI_MEM_MODE, 2); /* bypass mode */
! 2815: wpi_mem_write(sc, WPI_MEM_RA, 1); /* enable RA0 */
! 2816: wpi_mem_write(sc, WPI_MEM_TXCFG, 0x3f); /* enable all 6 Tx rings */
! 2817: wpi_mem_write(sc, WPI_MEM_BYPASS1, 0x10000);
! 2818: wpi_mem_write(sc, WPI_MEM_BYPASS2, 0x30002);
! 2819: wpi_mem_write(sc, WPI_MEM_MAGIC4, 4);
! 2820: wpi_mem_write(sc, WPI_MEM_MAGIC5, 5);
! 2821:
! 2822: WPI_WRITE(sc, WPI_TX_BASE_PTR, sc->shared_dma.paddr);
! 2823: WPI_WRITE(sc, WPI_MSG_CONFIG, 0xffff05a5);
! 2824:
! 2825: for (qid = 0; qid < 6; qid++) {
! 2826: WPI_WRITE(sc, WPI_TX_CTL(qid), 0);
! 2827: WPI_WRITE(sc, WPI_TX_BASE(qid), 0);
! 2828: WPI_WRITE(sc, WPI_TX_CONFIG(qid), 0x80200008);
! 2829: }
! 2830: wpi_mem_unlock(sc);
! 2831:
! 2832: /* clear "radio off" and "disable command" bits (reversed logic) */
! 2833: WPI_WRITE(sc, WPI_UCODE_CLR, WPI_RADIO_OFF);
! 2834: WPI_WRITE(sc, WPI_UCODE_CLR, WPI_DISABLE_CMD);
! 2835:
! 2836: /* clear any pending interrupts */
! 2837: WPI_WRITE(sc, WPI_INTR, 0xffffffff);
! 2838: /* enable interrupts */
! 2839: WPI_WRITE(sc, WPI_MASK, WPI_INTR_MASK);
! 2840:
! 2841: /* not sure why/if this is necessary... */
! 2842: WPI_WRITE(sc, WPI_UCODE_CLR, WPI_RADIO_OFF);
! 2843: WPI_WRITE(sc, WPI_UCODE_CLR, WPI_RADIO_OFF);
! 2844:
! 2845: if ((error = wpi_load_firmware(sc)) != 0) {
! 2846: printf("%s: could not load firmware\n", sc->sc_dev.dv_xname);
! 2847: goto fail1;
! 2848: }
! 2849:
! 2850: /* wait for thermal sensors to calibrate */
! 2851: for (ntries = 0; ntries < 1000; ntries++) {
! 2852: if ((sc->temp = (int)WPI_READ(sc, WPI_TEMPERATURE)) != 0)
! 2853: break;
! 2854: DELAY(10);
! 2855: }
! 2856: if (ntries == 1000) {
! 2857: printf("%s: timeout waiting for thermal sensors calibration\n",
! 2858: sc->sc_dev.dv_xname);
! 2859: error = ETIMEDOUT;
! 2860: goto fail1;
! 2861: }
! 2862: DPRINTF(("temperature %d\n", sc->temp));
! 2863: sc->sensor.value = sc->temp + 260;
! 2864: sc->sensor.flags &= ~SENSOR_FINVALID;
! 2865:
! 2866: if ((error = wpi_config(sc)) != 0) {
! 2867: printf("%s: could not configure device\n",
! 2868: sc->sc_dev.dv_xname);
! 2869: goto fail1;
! 2870: }
! 2871:
! 2872: ifp->if_flags &= ~IFF_OACTIVE;
! 2873: ifp->if_flags |= IFF_RUNNING;
! 2874:
! 2875: if (ic->ic_opmode != IEEE80211_M_MONITOR)
! 2876: ieee80211_begin_scan(ifp);
! 2877: else
! 2878: ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
! 2879:
! 2880: return 0;
! 2881:
! 2882: fail1: wpi_stop(ifp, 1);
! 2883: return error;
! 2884: }
! 2885:
! 2886: void
! 2887: wpi_stop(struct ifnet *ifp, int disable)
! 2888: {
! 2889: struct wpi_softc *sc = ifp->if_softc;
! 2890: struct ieee80211com *ic = &sc->sc_ic;
! 2891: uint32_t tmp;
! 2892: int ac;
! 2893:
! 2894: ifp->if_timer = sc->sc_tx_timer = 0;
! 2895: ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
! 2896:
! 2897: ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
! 2898:
! 2899: /* disable interrupts */
! 2900: WPI_WRITE(sc, WPI_MASK, 0);
! 2901: WPI_WRITE(sc, WPI_INTR, WPI_INTR_MASK);
! 2902: WPI_WRITE(sc, WPI_INTR_STATUS, 0xff);
! 2903: WPI_WRITE(sc, WPI_INTR_STATUS, 0x00070000);
! 2904:
! 2905: wpi_mem_lock(sc);
! 2906: wpi_mem_write(sc, WPI_MEM_MODE, 0);
! 2907: wpi_mem_unlock(sc);
! 2908:
! 2909: /* reset all Tx rings */
! 2910: for (ac = 0; ac < 4; ac++)
! 2911: wpi_reset_tx_ring(sc, &sc->txq[ac]);
! 2912: wpi_reset_tx_ring(sc, &sc->cmdq);
! 2913:
! 2914: /* reset Rx ring */
! 2915: wpi_reset_rx_ring(sc, &sc->rxq);
! 2916:
! 2917: /* temperature is no longer valid */
! 2918: sc->sensor.value = 0;
! 2919: sc->sensor.flags |= SENSOR_FINVALID;
! 2920:
! 2921: wpi_mem_lock(sc);
! 2922: wpi_mem_write(sc, WPI_MEM_CLOCK2, 0x200);
! 2923: wpi_mem_unlock(sc);
! 2924:
! 2925: DELAY(5);
! 2926:
! 2927: wpi_stop_master(sc);
! 2928:
! 2929: tmp = WPI_READ(sc, WPI_RESET);
! 2930: WPI_WRITE(sc, WPI_RESET, tmp | WPI_SW_RESET);
! 2931: }
! 2932:
! 2933: struct cfdriver wpi_cd = {
! 2934: NULL, "wpi", DV_IFNET
! 2935: };
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_wpi.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci