Annotation of sys/dev/pci/if_iwi.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: if_iwi.c,v 1.83 2007/07/18 18:10:31 damien Exp $ */
! 2:
! 3: /*-
! 4: * Copyright (c) 2004-2006
! 5: * Damien Bergamini <damien.bergamini@free.fr>. All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice unmodified, this list of conditions, and the following
! 12: * disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: *
! 17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
! 18: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 19: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 20: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
! 21: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 22: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 23: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 25: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 26: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 27: * SUCH DAMAGE.
! 28: */
! 29:
! 30: /*
! 31: * Driver for Intel PRO/Wireless 2200BG/2915ABG 802.11 network adapters.
! 32: */
! 33:
! 34: #include "bpfilter.h"
! 35:
! 36: #include <sys/param.h>
! 37: #include <sys/sockio.h>
! 38: #include <sys/sysctl.h>
! 39: #include <sys/mbuf.h>
! 40: #include <sys/kernel.h>
! 41: #include <sys/socket.h>
! 42: #include <sys/systm.h>
! 43: #include <sys/malloc.h>
! 44: #include <sys/conf.h>
! 45: #include <sys/device.h>
! 46:
! 47: #include <machine/bus.h>
! 48: #include <machine/endian.h>
! 49: #include <machine/intr.h>
! 50:
! 51: #include <dev/pci/pcireg.h>
! 52: #include <dev/pci/pcivar.h>
! 53: #include <dev/pci/pcidevs.h>
! 54:
! 55: #if NBPFILTER > 0
! 56: #include <net/bpf.h>
! 57: #endif
! 58: #include <net/if.h>
! 59: #include <net/if_arp.h>
! 60: #include <net/if_dl.h>
! 61: #include <net/if_media.h>
! 62: #include <net/if_types.h>
! 63:
! 64: #include <netinet/in.h>
! 65: #include <netinet/in_systm.h>
! 66: #include <netinet/in_var.h>
! 67: #include <netinet/if_ether.h>
! 68: #include <netinet/ip.h>
! 69:
! 70: #include <net80211/ieee80211_var.h>
! 71: #include <net80211/ieee80211_radiotap.h>
! 72:
! 73: #include <dev/rndvar.h>
! 74: #include <crypto/arc4.h>
! 75:
! 76: #include <dev/pci/if_iwireg.h>
! 77: #include <dev/pci/if_iwivar.h>
! 78:
! 79: const struct pci_matchid iwi_devices[] = {
! 80: { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_PRO_WL_2200BG },
! 81: { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_PRO_WL_2225BG },
! 82: { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_PRO_WL_2915ABG_1 },
! 83: { PCI_VENDOR_INTEL, PCI_PRODUCT_INTEL_PRO_WL_2915ABG_2 }
! 84: };
! 85:
! 86: int iwi_match(struct device *, void *, void *);
! 87: void iwi_attach(struct device *, struct device *, void *);
! 88: void iwi_power(int, void *);
! 89: int iwi_alloc_cmd_ring(struct iwi_softc *, struct iwi_cmd_ring *);
! 90: void iwi_reset_cmd_ring(struct iwi_softc *, struct iwi_cmd_ring *);
! 91: void iwi_free_cmd_ring(struct iwi_softc *, struct iwi_cmd_ring *);
! 92: int iwi_alloc_tx_ring(struct iwi_softc *, struct iwi_tx_ring *,
! 93: bus_size_t, bus_size_t);
! 94: void iwi_reset_tx_ring(struct iwi_softc *, struct iwi_tx_ring *);
! 95: void iwi_free_tx_ring(struct iwi_softc *, struct iwi_tx_ring *);
! 96: int iwi_alloc_rx_ring(struct iwi_softc *, struct iwi_rx_ring *);
! 97: void iwi_reset_rx_ring(struct iwi_softc *, struct iwi_rx_ring *);
! 98: void iwi_free_rx_ring(struct iwi_softc *, struct iwi_rx_ring *);
! 99: int iwi_media_change(struct ifnet *);
! 100: void iwi_media_status(struct ifnet *, struct ifmediareq *);
! 101: uint16_t iwi_read_prom_word(struct iwi_softc *, uint8_t);
! 102: int iwi_find_txnode(struct iwi_softc *, const uint8_t *);
! 103: int iwi_newstate(struct ieee80211com *, enum ieee80211_state, int);
! 104: uint8_t iwi_rate(int);
! 105: void iwi_frame_intr(struct iwi_softc *, struct iwi_rx_data *,
! 106: struct iwi_frame *);
! 107: void iwi_notification_intr(struct iwi_softc *, struct iwi_rx_data *,
! 108: struct iwi_notif *);
! 109: void iwi_rx_intr(struct iwi_softc *);
! 110: void iwi_tx_intr(struct iwi_softc *, struct iwi_tx_ring *);
! 111: int iwi_intr(void *);
! 112: int iwi_cmd(struct iwi_softc *, uint8_t, void *, uint8_t, int);
! 113: int iwi_tx_start(struct ifnet *, struct mbuf *,
! 114: struct ieee80211_node *);
! 115: void iwi_start(struct ifnet *);
! 116: void iwi_watchdog(struct ifnet *);
! 117: int iwi_ioctl(struct ifnet *, u_long, caddr_t);
! 118: void iwi_stop_master(struct iwi_softc *);
! 119: int iwi_reset(struct iwi_softc *);
! 120: int iwi_load_ucode(struct iwi_softc *, const char *, int);
! 121: int iwi_load_firmware(struct iwi_softc *, const char *, int);
! 122: int iwi_config(struct iwi_softc *);
! 123: int iwi_set_chan(struct iwi_softc *, struct ieee80211_channel *);
! 124: int iwi_scan(struct iwi_softc *);
! 125: int iwi_auth_and_assoc(struct iwi_softc *);
! 126: int iwi_init(struct ifnet *);
! 127: void iwi_stop(struct ifnet *, int);
! 128:
! 129: static __inline uint8_t
! 130: MEM_READ_1(struct iwi_softc *sc, uint32_t addr)
! 131: {
! 132: CSR_WRITE_4(sc, IWI_CSR_INDIRECT_ADDR, addr);
! 133: return CSR_READ_1(sc, IWI_CSR_INDIRECT_DATA);
! 134: }
! 135:
! 136: static __inline uint32_t
! 137: MEM_READ_4(struct iwi_softc *sc, uint32_t addr)
! 138: {
! 139: CSR_WRITE_4(sc, IWI_CSR_INDIRECT_ADDR, addr);
! 140: return CSR_READ_4(sc, IWI_CSR_INDIRECT_DATA);
! 141: }
! 142:
! 143: #ifdef IWI_DEBUG
! 144: #define DPRINTF(x) do { if (iwi_debug > 0) printf x; } while (0)
! 145: #define DPRINTFN(n, x) do { if (iwi_debug >= (n)) printf x; } while (0)
! 146: int iwi_debug = 0;
! 147: #else
! 148: #define DPRINTF(x)
! 149: #define DPRINTFN(n, x)
! 150: #endif
! 151:
! 152: struct cfattach iwi_ca = {
! 153: sizeof (struct iwi_softc), iwi_match, iwi_attach
! 154: };
! 155:
! 156: int
! 157: iwi_match(struct device *parent, void *match, void *aux)
! 158: {
! 159: return pci_matchbyid((struct pci_attach_args *)aux, iwi_devices,
! 160: sizeof (iwi_devices) / sizeof (iwi_devices[0]));
! 161: }
! 162:
! 163: /* Base Address Register */
! 164: #define IWI_PCI_BAR0 0x10
! 165:
! 166: void
! 167: iwi_attach(struct device *parent, struct device *self, void *aux)
! 168: {
! 169: struct iwi_softc *sc = (struct iwi_softc *)self;
! 170: struct ieee80211com *ic = &sc->sc_ic;
! 171: struct ifnet *ifp = &ic->ic_if;
! 172: struct pci_attach_args *pa = aux;
! 173: const char *intrstr;
! 174: bus_space_tag_t memt;
! 175: bus_space_handle_t memh;
! 176: pci_intr_handle_t ih;
! 177: pcireg_t data;
! 178: uint16_t val;
! 179: int error, i;
! 180:
! 181: sc->sc_pct = pa->pa_pc;
! 182: sc->sc_pcitag = pa->pa_tag;
! 183:
! 184: /* clear device specific PCI configuration register 0x41 */
! 185: data = pci_conf_read(sc->sc_pct, sc->sc_pcitag, 0x40);
! 186: data &= ~0x0000ff00;
! 187: pci_conf_write(sc->sc_pct, sc->sc_pcitag, 0x40, data);
! 188:
! 189: /* map the register window */
! 190: error = pci_mapreg_map(pa, IWI_PCI_BAR0, PCI_MAPREG_TYPE_MEM |
! 191: PCI_MAPREG_MEM_TYPE_32BIT, 0, &memt, &memh, NULL, &sc->sc_sz, 0);
! 192: if (error != 0) {
! 193: printf(": could not map memory space\n");
! 194: return;
! 195: }
! 196:
! 197: sc->sc_st = memt;
! 198: sc->sc_sh = memh;
! 199: sc->sc_dmat = pa->pa_dmat;
! 200:
! 201: if (pci_intr_map(pa, &ih) != 0) {
! 202: printf(": could not map interrupt\n");
! 203: return;
! 204: }
! 205:
! 206: intrstr = pci_intr_string(sc->sc_pct, ih);
! 207: sc->sc_ih = pci_intr_establish(sc->sc_pct, ih, IPL_NET, iwi_intr, sc,
! 208: sc->sc_dev.dv_xname);
! 209: if (sc->sc_ih == NULL) {
! 210: printf(": could not establish interrupt");
! 211: if (intrstr != NULL)
! 212: printf(" at %s", intrstr);
! 213: printf("\n");
! 214: return;
! 215: }
! 216: printf(": %s", intrstr);
! 217:
! 218: if (iwi_reset(sc) != 0) {
! 219: printf(": could not reset adapter\n");
! 220: return;
! 221: }
! 222:
! 223: /*
! 224: * Allocate rings.
! 225: */
! 226: error = iwi_alloc_cmd_ring(sc, &sc->cmdq);
! 227: if (error != 0) {
! 228: printf(": could not allocate Cmd ring\n");
! 229: return;
! 230: }
! 231:
! 232: error = iwi_alloc_tx_ring(sc, &sc->txq[0], IWI_CSR_TX1_RIDX,
! 233: IWI_CSR_TX1_WIDX);
! 234: if (error != 0) {
! 235: printf(": could not allocate Tx ring 1\n");
! 236: goto fail1;
! 237: }
! 238:
! 239: error = iwi_alloc_tx_ring(sc, &sc->txq[1], IWI_CSR_TX2_RIDX,
! 240: IWI_CSR_TX2_WIDX);
! 241: if (error != 0) {
! 242: printf(": could not allocate Tx ring 2\n");
! 243: goto fail2;
! 244: }
! 245:
! 246: error = iwi_alloc_tx_ring(sc, &sc->txq[2], IWI_CSR_TX3_RIDX,
! 247: IWI_CSR_TX3_WIDX);
! 248: if (error != 0) {
! 249: printf(": could not allocate Tx ring 3\n");
! 250: goto fail3;
! 251: }
! 252:
! 253: error = iwi_alloc_tx_ring(sc, &sc->txq[3], IWI_CSR_TX4_RIDX,
! 254: IWI_CSR_TX4_WIDX);
! 255: if (error != 0) {
! 256: printf(": could not allocate Tx ring 4\n");
! 257: goto fail4;
! 258: }
! 259:
! 260: error = iwi_alloc_rx_ring(sc, &sc->rxq);
! 261: if (error != 0) {
! 262: printf(": could not allocate Rx ring\n");
! 263: goto fail5;
! 264: }
! 265:
! 266: ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
! 267: ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */
! 268: ic->ic_state = IEEE80211_S_INIT;
! 269:
! 270: /* set device capabilities */
! 271: ic->ic_caps =
! 272: IEEE80211_C_IBSS | /* IBSS mode supported */
! 273: IEEE80211_C_MONITOR | /* monitor mode supported */
! 274: IEEE80211_C_TXPMGT | /* tx power management */
! 275: IEEE80211_C_SHPREAMBLE | /* short preamble supported */
! 276: IEEE80211_C_SHSLOT | /* short slot time supported */
! 277: IEEE80211_C_WEP | /* h/w WEP supported */
! 278: IEEE80211_C_SCANALL; /* h/w scanning */
! 279:
! 280: /* read MAC address from EEPROM */
! 281: val = iwi_read_prom_word(sc, IWI_EEPROM_MAC + 0);
! 282: ic->ic_myaddr[0] = val & 0xff;
! 283: ic->ic_myaddr[1] = val >> 8;
! 284: val = iwi_read_prom_word(sc, IWI_EEPROM_MAC + 1);
! 285: ic->ic_myaddr[2] = val & 0xff;
! 286: ic->ic_myaddr[3] = val >> 8;
! 287: val = iwi_read_prom_word(sc, IWI_EEPROM_MAC + 2);
! 288: ic->ic_myaddr[4] = val & 0xff;
! 289: ic->ic_myaddr[5] = val >> 8;
! 290:
! 291: printf(", address %s\n", ether_sprintf(ic->ic_myaddr));
! 292:
! 293: if (PCI_PRODUCT(pa->pa_id) >= PCI_PRODUCT_INTEL_PRO_WL_2915ABG_1) {
! 294: /* set supported .11a rates */
! 295: ic->ic_sup_rates[IEEE80211_MODE_11A] = ieee80211_std_rateset_11a;
! 296:
! 297: /* set supported .11a channels */
! 298: for (i = 36; i <= 64; i += 4) {
! 299: ic->ic_channels[i].ic_freq =
! 300: ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ);
! 301: ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A;
! 302: }
! 303: for (i = 149; i <= 165; i += 4) {
! 304: ic->ic_channels[i].ic_freq =
! 305: ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ);
! 306: ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A;
! 307: }
! 308: }
! 309:
! 310: /* set supported .11b and .11g rates */
! 311: ic->ic_sup_rates[IEEE80211_MODE_11B] = ieee80211_std_rateset_11b;
! 312: ic->ic_sup_rates[IEEE80211_MODE_11G] = ieee80211_std_rateset_11g;
! 313:
! 314: /* set supported .11b and .11g channels (1 through 14) */
! 315: for (i = 1; i <= 14; i++) {
! 316: ic->ic_channels[i].ic_freq =
! 317: ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ);
! 318: ic->ic_channels[i].ic_flags =
! 319: IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM |
! 320: IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ;
! 321: }
! 322:
! 323: /* IBSS channel undefined for now */
! 324: ic->ic_ibss_chan = &ic->ic_channels[0];
! 325:
! 326: ifp->if_softc = sc;
! 327: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
! 328: ifp->if_init = iwi_init;
! 329: ifp->if_ioctl = iwi_ioctl;
! 330: ifp->if_start = iwi_start;
! 331: ifp->if_watchdog = iwi_watchdog;
! 332: IFQ_SET_READY(&ifp->if_snd);
! 333: bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
! 334:
! 335: if_attach(ifp);
! 336: ieee80211_ifattach(ifp);
! 337: /* override state transition machine */
! 338: sc->sc_newstate = ic->ic_newstate;
! 339: ic->ic_newstate = iwi_newstate;
! 340: ieee80211_media_init(ifp, iwi_media_change, iwi_media_status);
! 341:
! 342: sc->powerhook = powerhook_establish(iwi_power, sc);
! 343:
! 344: #if NBPFILTER > 0
! 345: bpfattach(&sc->sc_drvbpf, ifp, DLT_IEEE802_11_RADIO,
! 346: sizeof (struct ieee80211_frame) + IEEE80211_RADIOTAP_HDRLEN);
! 347:
! 348: sc->sc_rxtap_len = sizeof sc->sc_rxtapu;
! 349: sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len);
! 350: sc->sc_rxtap.wr_ihdr.it_present = htole32(IWI_RX_RADIOTAP_PRESENT);
! 351:
! 352: sc->sc_txtap_len = sizeof sc->sc_txtapu;
! 353: sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len);
! 354: sc->sc_txtap.wt_ihdr.it_present = htole32(IWI_TX_RADIOTAP_PRESENT);
! 355: #endif
! 356:
! 357: return;
! 358:
! 359: fail5: iwi_free_tx_ring(sc, &sc->txq[3]);
! 360: fail4: iwi_free_tx_ring(sc, &sc->txq[2]);
! 361: fail3: iwi_free_tx_ring(sc, &sc->txq[1]);
! 362: fail2: iwi_free_tx_ring(sc, &sc->txq[0]);
! 363: fail1: iwi_free_cmd_ring(sc, &sc->cmdq);
! 364: }
! 365:
! 366: void
! 367: iwi_power(int why, void *arg)
! 368: {
! 369: struct iwi_softc *sc = arg;
! 370: struct ifnet *ifp;
! 371: pcireg_t data;
! 372:
! 373: if (why != PWR_RESUME)
! 374: return;
! 375:
! 376: /* clear device specific PCI configuration register 0x41 */
! 377: data = pci_conf_read(sc->sc_pct, sc->sc_pcitag, 0x40);
! 378: data &= ~0x0000ff00;
! 379: pci_conf_write(sc->sc_pct, sc->sc_pcitag, 0x40, data);
! 380:
! 381: ifp = &sc->sc_ic.ic_if;
! 382: if (ifp->if_flags & IFF_UP) {
! 383: ifp->if_init(ifp);
! 384: if (ifp->if_flags & IFF_RUNNING)
! 385: ifp->if_start(ifp);
! 386: }
! 387: }
! 388:
! 389: int
! 390: iwi_alloc_cmd_ring(struct iwi_softc *sc, struct iwi_cmd_ring *ring)
! 391: {
! 392: int nsegs, error;
! 393:
! 394: ring->queued = 0;
! 395: ring->cur = ring->next = 0;
! 396:
! 397: error = bus_dmamap_create(sc->sc_dmat,
! 398: sizeof (struct iwi_cmd_desc) * IWI_CMD_RING_COUNT, 1,
! 399: sizeof (struct iwi_cmd_desc) * IWI_CMD_RING_COUNT, 0,
! 400: BUS_DMA_NOWAIT, &ring->map);
! 401: if (error != 0) {
! 402: printf("%s: could not create cmd ring DMA map\n",
! 403: sc->sc_dev.dv_xname);
! 404: goto fail;
! 405: }
! 406:
! 407: error = bus_dmamem_alloc(sc->sc_dmat,
! 408: sizeof (struct iwi_cmd_desc) * IWI_CMD_RING_COUNT, PAGE_SIZE, 0,
! 409: &ring->seg, 1, &nsegs, BUS_DMA_NOWAIT);
! 410: if (error != 0) {
! 411: printf("%s: could not allocate cmd ring DMA memory\n",
! 412: sc->sc_dev.dv_xname);
! 413: goto fail;
! 414: }
! 415:
! 416: error = bus_dmamem_map(sc->sc_dmat, &ring->seg, nsegs,
! 417: sizeof (struct iwi_cmd_desc) * IWI_CMD_RING_COUNT,
! 418: (caddr_t *)&ring->desc, BUS_DMA_NOWAIT);
! 419: if (error != 0) {
! 420: printf("%s: could not map cmd ring DMA memory\n",
! 421: sc->sc_dev.dv_xname);
! 422: goto fail;
! 423: }
! 424:
! 425: error = bus_dmamap_load(sc->sc_dmat, ring->map, ring->desc,
! 426: sizeof (struct iwi_cmd_desc) * IWI_CMD_RING_COUNT, NULL,
! 427: BUS_DMA_NOWAIT);
! 428: if (error != 0) {
! 429: printf("%s: could not load cmd ring DMA map\n",
! 430: sc->sc_dev.dv_xname);
! 431: goto fail;
! 432: }
! 433:
! 434: bzero(ring->desc, sizeof (struct iwi_cmd_desc) * IWI_CMD_RING_COUNT);
! 435: return 0;
! 436:
! 437: fail: iwi_free_cmd_ring(sc, ring);
! 438: return error;
! 439: }
! 440:
! 441: void
! 442: iwi_reset_cmd_ring(struct iwi_softc *sc, struct iwi_cmd_ring *ring)
! 443: {
! 444: ring->queued = 0;
! 445: ring->cur = ring->next = 0;
! 446: }
! 447:
! 448: void
! 449: iwi_free_cmd_ring(struct iwi_softc *sc, struct iwi_cmd_ring *ring)
! 450: {
! 451: if (ring->map != NULL) {
! 452: if (ring->desc != NULL) {
! 453: bus_dmamap_unload(sc->sc_dmat, ring->map);
! 454: bus_dmamem_unmap(sc->sc_dmat, (caddr_t)ring->desc,
! 455: sizeof (struct iwi_cmd_desc) * IWI_CMD_RING_COUNT);
! 456: bus_dmamem_free(sc->sc_dmat, &ring->seg, 1);
! 457: }
! 458: bus_dmamap_destroy(sc->sc_dmat, ring->map);
! 459: }
! 460: }
! 461:
! 462: int
! 463: iwi_alloc_tx_ring(struct iwi_softc *sc, struct iwi_tx_ring *ring,
! 464: bus_size_t csr_ridx, bus_size_t csr_widx)
! 465: {
! 466: struct iwi_tx_data *data;
! 467: int i, nsegs, error;
! 468:
! 469: ring->queued = 0;
! 470: ring->cur = ring->next = 0;
! 471: ring->csr_ridx = csr_ridx;
! 472: ring->csr_widx = csr_widx;
! 473:
! 474: error = bus_dmamap_create(sc->sc_dmat,
! 475: sizeof (struct iwi_tx_desc) * IWI_TX_RING_COUNT, 1,
! 476: sizeof (struct iwi_tx_desc) * IWI_TX_RING_COUNT, 0, BUS_DMA_NOWAIT,
! 477: &ring->map);
! 478: if (error != 0) {
! 479: printf("%s: could not create tx ring DMA map\n",
! 480: sc->sc_dev.dv_xname);
! 481: goto fail;
! 482: }
! 483:
! 484: error = bus_dmamem_alloc(sc->sc_dmat,
! 485: sizeof (struct iwi_tx_desc) * IWI_TX_RING_COUNT, PAGE_SIZE, 0,
! 486: &ring->seg, 1, &nsegs, BUS_DMA_NOWAIT);
! 487: if (error != 0) {
! 488: printf("%s: could not allocate tx ring DMA memory\n",
! 489: sc->sc_dev.dv_xname);
! 490: goto fail;
! 491: }
! 492:
! 493: error = bus_dmamem_map(sc->sc_dmat, &ring->seg, nsegs,
! 494: sizeof (struct iwi_tx_desc) * IWI_TX_RING_COUNT,
! 495: (caddr_t *)&ring->desc, BUS_DMA_NOWAIT);
! 496: if (error != 0) {
! 497: printf("%s: could not map tx ring DMA memory\n",
! 498: sc->sc_dev.dv_xname);
! 499: goto fail;
! 500: }
! 501:
! 502: error = bus_dmamap_load(sc->sc_dmat, ring->map, ring->desc,
! 503: sizeof (struct iwi_tx_desc) * IWI_TX_RING_COUNT, NULL,
! 504: BUS_DMA_NOWAIT);
! 505: if (error != 0) {
! 506: printf("%s: could not load tx ring DMA map\n",
! 507: sc->sc_dev.dv_xname);
! 508: goto fail;
! 509: }
! 510:
! 511: bzero(ring->desc, sizeof (struct iwi_tx_desc) * IWI_TX_RING_COUNT);
! 512:
! 513: for (i = 0; i < IWI_TX_RING_COUNT; i++) {
! 514: data = &ring->data[i];
! 515:
! 516: error = bus_dmamap_create(sc->sc_dmat, MCLBYTES,
! 517: IWI_MAX_SCATTER, MCLBYTES, 0, BUS_DMA_NOWAIT, &data->map);
! 518: if (error != 0) {
! 519: printf("%s: could not create tx buf DMA map\n",
! 520: sc->sc_dev.dv_xname);
! 521: goto fail;
! 522: }
! 523: }
! 524:
! 525: return 0;
! 526:
! 527: fail: iwi_free_tx_ring(sc, ring);
! 528: return error;
! 529: }
! 530:
! 531: void
! 532: iwi_reset_tx_ring(struct iwi_softc *sc, struct iwi_tx_ring *ring)
! 533: {
! 534: struct iwi_tx_data *data;
! 535: int i;
! 536:
! 537: for (i = 0; i < IWI_TX_RING_COUNT; i++) {
! 538: data = &ring->data[i];
! 539:
! 540: if (data->m != NULL) {
! 541: bus_dmamap_unload(sc->sc_dmat, data->map);
! 542: m_freem(data->m);
! 543: data->m = NULL;
! 544: }
! 545: }
! 546:
! 547: ring->queued = 0;
! 548: ring->cur = ring->next = 0;
! 549: }
! 550:
! 551: void
! 552: iwi_free_tx_ring(struct iwi_softc *sc, struct iwi_tx_ring *ring)
! 553: {
! 554: struct iwi_tx_data *data;
! 555: int i;
! 556:
! 557: if (ring->map != NULL) {
! 558: if (ring->desc != NULL) {
! 559: bus_dmamap_unload(sc->sc_dmat, ring->map);
! 560: bus_dmamem_unmap(sc->sc_dmat, (caddr_t)ring->desc,
! 561: sizeof (struct iwi_tx_desc) * IWI_TX_RING_COUNT);
! 562: bus_dmamem_free(sc->sc_dmat, &ring->seg, 1);
! 563: }
! 564: bus_dmamap_destroy(sc->sc_dmat, ring->map);
! 565: }
! 566:
! 567: for (i = 0; i < IWI_TX_RING_COUNT; i++) {
! 568: data = &ring->data[i];
! 569:
! 570: if (data->m != NULL) {
! 571: bus_dmamap_unload(sc->sc_dmat, data->map);
! 572: m_freem(data->m);
! 573: }
! 574: bus_dmamap_destroy(sc->sc_dmat, data->map);
! 575: }
! 576: }
! 577:
! 578: int
! 579: iwi_alloc_rx_ring(struct iwi_softc *sc, struct iwi_rx_ring *ring)
! 580: {
! 581: struct iwi_rx_data *data;
! 582: int i, error;
! 583:
! 584: ring->cur = 0;
! 585:
! 586: for (i = 0; i < IWI_RX_RING_COUNT; i++) {
! 587: data = &sc->rxq.data[i];
! 588:
! 589: error = bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1, MCLBYTES,
! 590: 0, BUS_DMA_NOWAIT, &data->map);
! 591: if (error != 0) {
! 592: printf("%s: could not create rx buf DMA map\n",
! 593: sc->sc_dev.dv_xname);
! 594: goto fail;
! 595: }
! 596:
! 597: MGETHDR(data->m, M_DONTWAIT, MT_DATA);
! 598: if (data->m == NULL) {
! 599: printf("%s: could not allocate rx mbuf\n",
! 600: sc->sc_dev.dv_xname);
! 601: error = ENOMEM;
! 602: goto fail;
! 603: }
! 604:
! 605: MCLGET(data->m, M_DONTWAIT);
! 606: if (!(data->m->m_flags & M_EXT)) {
! 607: m_freem(data->m);
! 608: data->m = NULL;
! 609: printf("%s: could not allocate rx mbuf cluster\n",
! 610: sc->sc_dev.dv_xname);
! 611: error = ENOMEM;
! 612: goto fail;
! 613: }
! 614:
! 615: error = bus_dmamap_load(sc->sc_dmat, data->map,
! 616: mtod(data->m, void *), MCLBYTES, NULL, BUS_DMA_NOWAIT);
! 617: if (error != 0) {
! 618: printf("%s: could not load rx buf DMA map\n",
! 619: sc->sc_dev.dv_xname);
! 620: goto fail;
! 621: }
! 622:
! 623: data->reg = IWI_CSR_RX_BASE + i * 4;
! 624: }
! 625:
! 626: return 0;
! 627:
! 628: fail: iwi_free_rx_ring(sc, ring);
! 629: return error;
! 630: }
! 631:
! 632: void
! 633: iwi_reset_rx_ring(struct iwi_softc *sc, struct iwi_rx_ring *ring)
! 634: {
! 635: ring->cur = 0;
! 636: }
! 637:
! 638: void
! 639: iwi_free_rx_ring(struct iwi_softc *sc, struct iwi_rx_ring *ring)
! 640: {
! 641: struct iwi_rx_data *data;
! 642: int i;
! 643:
! 644: for (i = 0; i < IWI_RX_RING_COUNT; i++) {
! 645: data = &sc->rxq.data[i];
! 646:
! 647: if (data->m != NULL) {
! 648: bus_dmamap_unload(sc->sc_dmat, data->map);
! 649: m_freem(data->m);
! 650: }
! 651: bus_dmamap_destroy(sc->sc_dmat, data->map);
! 652: }
! 653: }
! 654:
! 655: int
! 656: iwi_media_change(struct ifnet *ifp)
! 657: {
! 658: int error;
! 659:
! 660: error = ieee80211_media_change(ifp);
! 661: if (error != ENETRESET)
! 662: return error;
! 663:
! 664: if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING))
! 665: iwi_init(ifp);
! 666:
! 667: return 0;
! 668: }
! 669:
! 670: void
! 671: iwi_media_status(struct ifnet *ifp, struct ifmediareq *imr)
! 672: {
! 673: struct iwi_softc *sc = ifp->if_softc;
! 674: struct ieee80211com *ic = &sc->sc_ic;
! 675: uint32_t val;
! 676: int rate;
! 677:
! 678: imr->ifm_status = IFM_AVALID;
! 679: imr->ifm_active = IFM_IEEE80211;
! 680: if (ic->ic_state == IEEE80211_S_RUN)
! 681: imr->ifm_status |= IFM_ACTIVE;
! 682:
! 683: /* read current transmission rate from adapter */
! 684: val = CSR_READ_4(sc, IWI_CSR_CURRENT_TX_RATE);
! 685: /* convert PLCP signal to 802.11 rate */
! 686: rate = iwi_rate(val);
! 687:
! 688: imr->ifm_active |= ieee80211_rate2media(ic, rate, ic->ic_curmode);
! 689: switch (ic->ic_opmode) {
! 690: case IEEE80211_M_STA:
! 691: break;
! 692: case IEEE80211_M_IBSS:
! 693: imr->ifm_active |= IFM_IEEE80211_ADHOC;
! 694: break;
! 695: case IEEE80211_M_MONITOR:
! 696: imr->ifm_active |= IFM_IEEE80211_MONITOR;
! 697: break;
! 698: case IEEE80211_M_AHDEMO:
! 699: case IEEE80211_M_HOSTAP:
! 700: /* should not get there */
! 701: break;
! 702: }
! 703: }
! 704:
! 705: /*
! 706: * This is only used for IBSS mode where the firmware expect an index to an
! 707: * internal node table instead of a destination address.
! 708: */
! 709: int
! 710: iwi_find_txnode(struct iwi_softc *sc, const uint8_t *macaddr)
! 711: {
! 712: struct iwi_node node;
! 713: int i;
! 714:
! 715: for (i = 0; i < sc->nsta; i++)
! 716: if (IEEE80211_ADDR_EQ(sc->sta[i], macaddr))
! 717: return i; /* already existing node */
! 718:
! 719: if (i == IWI_MAX_NODE)
! 720: return -1; /* no place left in neighbor table */
! 721:
! 722: /* save this new node in our softc table */
! 723: IEEE80211_ADDR_COPY(sc->sta[i], macaddr);
! 724: sc->nsta = i;
! 725:
! 726: /* write node information into NIC memory */
! 727: bzero(&node, sizeof node);
! 728: IEEE80211_ADDR_COPY(node.bssid, macaddr);
! 729:
! 730: CSR_WRITE_REGION_1(sc, IWI_CSR_NODE_BASE + i * sizeof node,
! 731: (uint8_t *)&node, sizeof node);
! 732:
! 733: return i;
! 734: }
! 735:
! 736: int
! 737: iwi_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
! 738: {
! 739: struct iwi_softc *sc = ic->ic_softc;
! 740: enum ieee80211_state ostate;
! 741: uint32_t tmp;
! 742:
! 743: ostate = ic->ic_state;
! 744:
! 745: switch (nstate) {
! 746: case IEEE80211_S_SCAN:
! 747: iwi_scan(sc);
! 748: break;
! 749:
! 750: case IEEE80211_S_AUTH:
! 751: iwi_auth_and_assoc(sc);
! 752: break;
! 753:
! 754: case IEEE80211_S_RUN:
! 755: if (ic->ic_opmode == IEEE80211_M_IBSS) {
! 756: sc->nsta = 0; /* flush IBSS nodes */
! 757: ieee80211_new_state(ic, IEEE80211_S_AUTH, -1);
! 758: } else if (ic->ic_opmode == IEEE80211_M_MONITOR)
! 759: iwi_set_chan(sc, ic->ic_ibss_chan);
! 760:
! 761: /* assoc led on */
! 762: tmp = MEM_READ_4(sc, IWI_MEM_EVENT_CTL) & IWI_LED_MASK;
! 763: MEM_WRITE_4(sc, IWI_MEM_EVENT_CTL, tmp | IWI_LED_ASSOC);
! 764: break;
! 765:
! 766: case IEEE80211_S_INIT:
! 767: if (ostate != IEEE80211_S_RUN)
! 768: break;
! 769:
! 770: /* assoc led off */
! 771: tmp = MEM_READ_4(sc, IWI_MEM_EVENT_CTL) & IWI_LED_MASK;
! 772: MEM_WRITE_4(sc, IWI_MEM_EVENT_CTL, tmp & ~IWI_LED_ASSOC);
! 773: break;
! 774:
! 775: case IEEE80211_S_ASSOC:
! 776: break;
! 777: }
! 778:
! 779: ic->ic_state = nstate;
! 780: return 0;
! 781: }
! 782:
! 783: /*
! 784: * Read 16 bits at address 'addr' from the serial EEPROM.
! 785: * DON'T PLAY WITH THIS CODE UNLESS YOU KNOW *EXACTLY* WHAT YOU'RE DOING!
! 786: */
! 787: uint16_t
! 788: iwi_read_prom_word(struct iwi_softc *sc, uint8_t addr)
! 789: {
! 790: uint32_t tmp;
! 791: uint16_t val;
! 792: int n;
! 793:
! 794: /* clock C once before the first command */
! 795: IWI_EEPROM_CTL(sc, 0);
! 796: IWI_EEPROM_CTL(sc, IWI_EEPROM_S);
! 797: IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_C);
! 798: IWI_EEPROM_CTL(sc, IWI_EEPROM_S);
! 799:
! 800: /* write start bit (1) */
! 801: IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_D);
! 802: IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_D | IWI_EEPROM_C);
! 803:
! 804: /* write READ opcode (10) */
! 805: IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_D);
! 806: IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_D | IWI_EEPROM_C);
! 807: IWI_EEPROM_CTL(sc, IWI_EEPROM_S);
! 808: IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_C);
! 809:
! 810: /* write address A7-A0 */
! 811: for (n = 7; n >= 0; n--) {
! 812: IWI_EEPROM_CTL(sc, IWI_EEPROM_S |
! 813: (((addr >> n) & 1) << IWI_EEPROM_SHIFT_D));
! 814: IWI_EEPROM_CTL(sc, IWI_EEPROM_S |
! 815: (((addr >> n) & 1) << IWI_EEPROM_SHIFT_D) | IWI_EEPROM_C);
! 816: }
! 817:
! 818: IWI_EEPROM_CTL(sc, IWI_EEPROM_S);
! 819:
! 820: /* read data Q15-Q0 */
! 821: val = 0;
! 822: for (n = 15; n >= 0; n--) {
! 823: IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_C);
! 824: IWI_EEPROM_CTL(sc, IWI_EEPROM_S);
! 825: tmp = MEM_READ_4(sc, IWI_MEM_EEPROM_CTL);
! 826: val |= ((tmp & IWI_EEPROM_Q) >> IWI_EEPROM_SHIFT_Q) << n;
! 827: }
! 828:
! 829: IWI_EEPROM_CTL(sc, 0);
! 830:
! 831: /* clear Chip Select and clock C */
! 832: IWI_EEPROM_CTL(sc, IWI_EEPROM_S);
! 833: IWI_EEPROM_CTL(sc, 0);
! 834: IWI_EEPROM_CTL(sc, IWI_EEPROM_C);
! 835:
! 836: return val;
! 837: }
! 838:
! 839: uint8_t
! 840: iwi_rate(int plcp)
! 841: {
! 842: switch (plcp) {
! 843: /* CCK rates (values are device-dependent) */
! 844: case 10: return 2;
! 845: case 20: return 4;
! 846: case 55: return 11;
! 847: case 110: return 22;
! 848:
! 849: /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
! 850: case 0xd: return 12;
! 851: case 0xf: return 18;
! 852: case 0x5: return 24;
! 853: case 0x7: return 36;
! 854: case 0x9: return 48;
! 855: case 0xb: return 72;
! 856: case 0x1: return 96;
! 857: case 0x3: return 108;
! 858:
! 859: /* unknown rate: should not happen */
! 860: default: return 0;
! 861: }
! 862: }
! 863:
! 864: void
! 865: iwi_frame_intr(struct iwi_softc *sc, struct iwi_rx_data *data,
! 866: struct iwi_frame *frame)
! 867: {
! 868: struct ieee80211com *ic = &sc->sc_ic;
! 869: struct ifnet *ifp = &ic->ic_if;
! 870: struct mbuf *mnew, *m;
! 871: struct ieee80211_frame *wh;
! 872: struct ieee80211_node *ni;
! 873: int error;
! 874:
! 875: DPRINTFN(5, ("received frame len=%u chan=%u rssi=%u\n",
! 876: letoh16(frame->len), frame->chan, frame->rssi_dbm));
! 877:
! 878: if (letoh16(frame->len) < sizeof (struct ieee80211_frame_min) ||
! 879: letoh16(frame->len) > MCLBYTES) {
! 880: DPRINTF(("%s: bad frame length\n", sc->sc_dev.dv_xname));
! 881: ifp->if_ierrors++;
! 882: return;
! 883: }
! 884:
! 885: /*
! 886: * Try to allocate a new mbuf for this ring element and load it before
! 887: * processing the current mbuf. If the ring element cannot be loaded,
! 888: * drop the received packet and reuse the old mbuf. In the unlikely
! 889: * case that the old mbuf can't be reloaded either, explicitly panic.
! 890: */
! 891: MGETHDR(mnew, M_DONTWAIT, MT_DATA);
! 892: if (mnew == NULL) {
! 893: ifp->if_ierrors++;
! 894: return;
! 895: }
! 896:
! 897: MCLGET(mnew, M_DONTWAIT);
! 898: if (!(mnew->m_flags & M_EXT)) {
! 899: m_freem(mnew);
! 900: ifp->if_ierrors++;
! 901: return;
! 902: }
! 903:
! 904: bus_dmamap_unload(sc->sc_dmat, data->map);
! 905:
! 906: error = bus_dmamap_load(sc->sc_dmat, data->map, mtod(mnew, void *),
! 907: MCLBYTES, NULL, BUS_DMA_NOWAIT);
! 908: if (error != 0) {
! 909: m_freem(mnew);
! 910:
! 911: /* try to reload the old mbuf */
! 912: error = bus_dmamap_load(sc->sc_dmat, data->map,
! 913: mtod(data->m, void *), MCLBYTES, NULL, BUS_DMA_NOWAIT);
! 914: if (error != 0) {
! 915: /* very unlikely that it will fail... */
! 916: panic("%s: could not load old rx mbuf",
! 917: sc->sc_dev.dv_xname);
! 918: }
! 919: ifp->if_ierrors++;
! 920: return;
! 921: }
! 922:
! 923: m = data->m;
! 924: data->m = mnew;
! 925: CSR_WRITE_4(sc, data->reg, data->map->dm_segs[0].ds_addr);
! 926:
! 927: /* finalize mbuf */
! 928: m->m_pkthdr.rcvif = ifp;
! 929: m->m_pkthdr.len = m->m_len = sizeof (struct iwi_hdr) +
! 930: sizeof (struct iwi_frame) + letoh16(frame->len);
! 931: m_adj(m, sizeof (struct iwi_hdr) + sizeof (struct iwi_frame));
! 932:
! 933: wh = mtod(m, struct ieee80211_frame *);
! 934:
! 935: if ((wh->i_fc[1] & IEEE80211_FC1_WEP) &&
! 936: ic->ic_opmode != IEEE80211_M_MONITOR) {
! 937: /*
! 938: * Hardware decrypts the frame itself but leaves the WEP bit
! 939: * set in the 802.11 header and doesn't remove the IV and CRC
! 940: * fields.
! 941: */
! 942: wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
! 943: ovbcopy(wh, (char *)wh + IEEE80211_WEP_IVLEN +
! 944: IEEE80211_WEP_KIDLEN, sizeof (struct ieee80211_frame));
! 945: m_adj(m, IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN);
! 946: m_adj(m, -IEEE80211_WEP_CRCLEN);
! 947: wh = mtod(m, struct ieee80211_frame *);
! 948: }
! 949:
! 950: #if NBPFILTER > 0
! 951: if (sc->sc_drvbpf != NULL) {
! 952: struct mbuf mb;
! 953: struct iwi_rx_radiotap_header *tap = &sc->sc_rxtap;
! 954:
! 955: tap->wr_flags = 0;
! 956: tap->wr_rate = iwi_rate(frame->rate);
! 957: tap->wr_chan_freq =
! 958: htole16(ic->ic_channels[frame->chan].ic_freq);
! 959: tap->wr_chan_flags =
! 960: htole16(ic->ic_channels[frame->chan].ic_flags);
! 961: tap->wr_antsignal = frame->signal;
! 962: tap->wr_antenna = frame->antenna & 0x3;
! 963: if (frame->antenna & 0x40)
! 964: tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
! 965:
! 966: mb.m_data = (caddr_t)tap;
! 967: mb.m_len = sc->sc_rxtap_len;
! 968: mb.m_next = m;
! 969: mb.m_nextpkt = NULL;
! 970: mb.m_type = 0;
! 971: mb.m_flags = 0;
! 972: bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_IN);
! 973: }
! 974: #endif
! 975:
! 976: ni = ieee80211_find_rxnode(ic, wh);
! 977:
! 978: /* send the frame to the upper layer */
! 979: ieee80211_input(ifp, m, ni, frame->rssi_dbm, 0);
! 980:
! 981: /* node is no longer needed */
! 982: ieee80211_release_node(ic, ni);
! 983: }
! 984:
! 985: void
! 986: iwi_notification_intr(struct iwi_softc *sc, struct iwi_rx_data *data,
! 987: struct iwi_notif *notif)
! 988: {
! 989: struct ieee80211com *ic = &sc->sc_ic;
! 990: struct ifnet *ifp = &ic->ic_if;
! 991:
! 992: switch (notif->type) {
! 993: case IWI_NOTIF_TYPE_SCAN_CHANNEL:
! 994: {
! 995: #ifdef IWI_DEBUG
! 996: struct iwi_notif_scan_channel *chan =
! 997: (struct iwi_notif_scan_channel *)(notif + 1);
! 998: #endif
! 999: DPRINTFN(2, ("Scanning channel (%u)\n", chan->nchan));
! 1000: break;
! 1001: }
! 1002: case IWI_NOTIF_TYPE_SCAN_COMPLETE:
! 1003: {
! 1004: #ifdef IWI_DEBUG
! 1005: struct iwi_notif_scan_complete *scan =
! 1006: (struct iwi_notif_scan_complete *)(notif + 1);
! 1007: #endif
! 1008: DPRINTFN(2, ("Scan completed (%u, %u)\n", scan->nchan,
! 1009: scan->status));
! 1010:
! 1011: /* monitor mode uses scan to set the channel ... */
! 1012: if (ic->ic_opmode != IEEE80211_M_MONITOR)
! 1013: ieee80211_end_scan(ifp);
! 1014: else
! 1015: iwi_set_chan(sc, ic->ic_ibss_chan);
! 1016: break;
! 1017: }
! 1018: case IWI_NOTIF_TYPE_AUTHENTICATION:
! 1019: {
! 1020: struct iwi_notif_authentication *auth =
! 1021: (struct iwi_notif_authentication *)(notif + 1);
! 1022:
! 1023: DPRINTFN(2, ("Authentication (%u)\n", auth->state));
! 1024:
! 1025: switch (auth->state) {
! 1026: case IWI_AUTHENTICATED:
! 1027: ieee80211_new_state(ic, IEEE80211_S_ASSOC, -1);
! 1028: break;
! 1029:
! 1030: case IWI_DEAUTHENTICATED:
! 1031: break;
! 1032:
! 1033: default:
! 1034: printf("%s: unknown authentication state %u\n",
! 1035: sc->sc_dev.dv_xname, auth->state);
! 1036: }
! 1037: break;
! 1038: }
! 1039: case IWI_NOTIF_TYPE_ASSOCIATION:
! 1040: {
! 1041: struct iwi_notif_association *assoc =
! 1042: (struct iwi_notif_association *)(notif + 1);
! 1043:
! 1044: DPRINTFN(2, ("Association (%u, %u)\n", assoc->state,
! 1045: assoc->status));
! 1046:
! 1047: switch (assoc->state) {
! 1048: case IWI_AUTHENTICATED:
! 1049: /* re-association, do nothing */
! 1050: break;
! 1051:
! 1052: case IWI_ASSOCIATED:
! 1053: ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
! 1054: break;
! 1055:
! 1056: case IWI_DEASSOCIATED:
! 1057: ieee80211_begin_scan(ifp);
! 1058: break;
! 1059:
! 1060: default:
! 1061: printf("%s: unknown association state %u\n",
! 1062: sc->sc_dev.dv_xname, assoc->state);
! 1063: }
! 1064: break;
! 1065: }
! 1066: case IWI_NOTIF_TYPE_BEACON:
! 1067: {
! 1068: struct iwi_notif_beacon *beacon =
! 1069: (struct iwi_notif_beacon *)(notif + 1);
! 1070:
! 1071: if (letoh32(beacon->status) == IWI_BEACON_MISSED) {
! 1072: /* XXX should roam when too many beacons missed */
! 1073: DPRINTFN(2, ("%s: %u beacon(s) missed\n",
! 1074: sc->sc_dev.dv_xname, letoh32(beacon->count)));
! 1075: }
! 1076: break;
! 1077: }
! 1078: case IWI_NOTIF_TYPE_BAD_LINK:
! 1079: DPRINTFN(2, ("link deterioration detected\n"));
! 1080: break;
! 1081:
! 1082: case IWI_NOTIF_TYPE_NOISE:
! 1083: DPRINTFN(5, ("Measured noise %u\n",
! 1084: letoh32(*(uint32_t *)(notif + 1)) & 0xff));
! 1085: break;
! 1086:
! 1087: default:
! 1088: DPRINTFN(5, ("Notification (%u)\n", notif->type));
! 1089: }
! 1090: }
! 1091:
! 1092: void
! 1093: iwi_rx_intr(struct iwi_softc *sc)
! 1094: {
! 1095: struct iwi_rx_data *data;
! 1096: struct iwi_hdr *hdr;
! 1097: uint32_t hw;
! 1098:
! 1099: hw = CSR_READ_4(sc, IWI_CSR_RX_RIDX);
! 1100:
! 1101: for (; sc->rxq.cur != hw;) {
! 1102: data = &sc->rxq.data[sc->rxq.cur];
! 1103:
! 1104: bus_dmamap_sync(sc->sc_dmat, data->map, 0, MCLBYTES,
! 1105: BUS_DMASYNC_POSTREAD);
! 1106:
! 1107: hdr = mtod(data->m, struct iwi_hdr *);
! 1108:
! 1109: switch (hdr->type) {
! 1110: case IWI_HDR_TYPE_FRAME:
! 1111: iwi_frame_intr(sc, data,
! 1112: (struct iwi_frame *)(hdr + 1));
! 1113: break;
! 1114:
! 1115: case IWI_HDR_TYPE_NOTIF:
! 1116: iwi_notification_intr(sc, data,
! 1117: (struct iwi_notif *)(hdr + 1));
! 1118: break;
! 1119:
! 1120: default:
! 1121: printf("%s: unknown hdr type %u\n",
! 1122: sc->sc_dev.dv_xname, hdr->type);
! 1123: }
! 1124:
! 1125: sc->rxq.cur = (sc->rxq.cur + 1) % IWI_RX_RING_COUNT;
! 1126: }
! 1127:
! 1128: /* tell the firmware what we have processed */
! 1129: hw = (hw == 0) ? IWI_RX_RING_COUNT - 1 : hw - 1;
! 1130: CSR_WRITE_4(sc, IWI_CSR_RX_WIDX, hw);
! 1131: }
! 1132:
! 1133: void
! 1134: iwi_tx_intr(struct iwi_softc *sc, struct iwi_tx_ring *txq)
! 1135: {
! 1136: struct ieee80211com *ic = &sc->sc_ic;
! 1137: struct ifnet *ifp = &ic->ic_if;
! 1138: struct iwi_tx_data *data;
! 1139: uint32_t hw;
! 1140:
! 1141: hw = CSR_READ_4(sc, txq->csr_ridx);
! 1142:
! 1143: for (; txq->next != hw;) {
! 1144: data = &txq->data[txq->next];
! 1145:
! 1146: bus_dmamap_unload(sc->sc_dmat, data->map);
! 1147: m_freem(data->m);
! 1148: data->m = NULL;
! 1149: ieee80211_release_node(ic, data->ni);
! 1150: data->ni = NULL;
! 1151:
! 1152: ifp->if_opackets++;
! 1153:
! 1154: txq->queued--;
! 1155: txq->next = (txq->next + 1) % IWI_TX_RING_COUNT;
! 1156: }
! 1157:
! 1158: sc->sc_tx_timer = 0;
! 1159: ifp->if_flags &= ~IFF_OACTIVE;
! 1160: (*ifp->if_start)(ifp);
! 1161: }
! 1162:
! 1163: int
! 1164: iwi_intr(void *arg)
! 1165: {
! 1166: struct iwi_softc *sc = arg;
! 1167: struct ifnet *ifp = &sc->sc_ic.ic_if;
! 1168: uint32_t r;
! 1169:
! 1170: if ((r = CSR_READ_4(sc, IWI_CSR_INTR)) == 0 || r == 0xffffffff)
! 1171: return 0;
! 1172:
! 1173: /* disable interrupts */
! 1174: CSR_WRITE_4(sc, IWI_CSR_INTR_MASK, 0);
! 1175:
! 1176: /* acknowledge interrupts */
! 1177: CSR_WRITE_4(sc, IWI_CSR_INTR, r);
! 1178:
! 1179: if (r & IWI_INTR_FATAL_ERROR) {
! 1180: printf("%s: fatal firmware error\n", sc->sc_dev.dv_xname);
! 1181: ifp->if_flags &= ~IFF_UP;
! 1182: iwi_stop(ifp, 1);
! 1183: return 1;
! 1184: }
! 1185:
! 1186: if (r & IWI_INTR_FW_INITED)
! 1187: wakeup(sc);
! 1188:
! 1189: if (r & IWI_INTR_RADIO_OFF) {
! 1190: DPRINTF(("radio transmitter off\n"));
! 1191: ifp->if_flags &= ~IFF_UP;
! 1192: iwi_stop(ifp, 1);
! 1193: return 1;
! 1194: }
! 1195:
! 1196: if (r & IWI_INTR_CMD_DONE) {
! 1197: /* kick next pending command if any */
! 1198: sc->cmdq.next = (sc->cmdq.next + 1) % IWI_CMD_RING_COUNT;
! 1199: if (--sc->cmdq.queued > 0)
! 1200: CSR_WRITE_4(sc, IWI_CSR_CMD_WIDX, sc->cmdq.next);
! 1201:
! 1202: wakeup(sc);
! 1203: }
! 1204:
! 1205: if (r & IWI_INTR_TX1_DONE)
! 1206: iwi_tx_intr(sc, &sc->txq[0]);
! 1207:
! 1208: if (r & IWI_INTR_TX2_DONE)
! 1209: iwi_tx_intr(sc, &sc->txq[1]);
! 1210:
! 1211: if (r & IWI_INTR_TX3_DONE)
! 1212: iwi_tx_intr(sc, &sc->txq[2]);
! 1213:
! 1214: if (r & IWI_INTR_TX4_DONE)
! 1215: iwi_tx_intr(sc, &sc->txq[3]);
! 1216:
! 1217: if (r & IWI_INTR_RX_DONE)
! 1218: iwi_rx_intr(sc);
! 1219:
! 1220: /* re-enable interrupts */
! 1221: CSR_WRITE_4(sc, IWI_CSR_INTR_MASK, IWI_INTR_MASK);
! 1222:
! 1223: return 1;
! 1224: }
! 1225:
! 1226: int
! 1227: iwi_cmd(struct iwi_softc *sc, uint8_t type, void *data, uint8_t len, int async)
! 1228: {
! 1229: struct iwi_cmd_desc *desc;
! 1230:
! 1231: desc = &sc->cmdq.desc[sc->cmdq.cur];
! 1232: desc->hdr.type = IWI_HDR_TYPE_COMMAND;
! 1233: desc->hdr.flags = IWI_HDR_FLAG_IRQ;
! 1234: desc->type = type;
! 1235: desc->len = len;
! 1236: bcopy(data, desc->data, len);
! 1237:
! 1238: bus_dmamap_sync(sc->sc_dmat, sc->cmdq.map,
! 1239: sc->cmdq.cur * sizeof (struct iwi_cmd_desc),
! 1240: sizeof (struct iwi_cmd_desc), BUS_DMASYNC_PREWRITE);
! 1241:
! 1242: DPRINTFN(2, ("sending command idx=%u type=%u len=%u\n", sc->cmdq.cur,
! 1243: type, len));
! 1244:
! 1245: sc->cmdq.cur = (sc->cmdq.cur + 1) % IWI_CMD_RING_COUNT;
! 1246:
! 1247: /* don't kick cmd immediately if another async command is pending */
! 1248: if (++sc->cmdq.queued == 1) {
! 1249: sc->cmdq.next = sc->cmdq.cur;
! 1250: CSR_WRITE_4(sc, IWI_CSR_CMD_WIDX, sc->cmdq.next);
! 1251: }
! 1252:
! 1253: return async ? 0 : tsleep(sc, 0, "iwicmd", hz);
! 1254: }
! 1255:
! 1256: int
! 1257: iwi_tx_start(struct ifnet *ifp, struct mbuf *m0, struct ieee80211_node *ni)
! 1258: {
! 1259: struct iwi_softc *sc = ifp->if_softc;
! 1260: struct ieee80211com *ic = &sc->sc_ic;
! 1261: struct iwi_tx_data *data;
! 1262: struct iwi_tx_desc *desc;
! 1263: struct iwi_tx_ring *txq = &sc->txq[0];
! 1264: struct mbuf *mnew;
! 1265: int error, i, station = 0;
! 1266:
! 1267: #if NBPFILTER > 0
! 1268: if (sc->sc_drvbpf != NULL) {
! 1269: struct mbuf mb;
! 1270: struct iwi_tx_radiotap_header *tap = &sc->sc_txtap;
! 1271:
! 1272: tap->wt_flags = 0;
! 1273: tap->wt_chan_freq = htole16(ic->ic_bss->ni_chan->ic_freq);
! 1274: tap->wt_chan_flags = htole16(ic->ic_bss->ni_chan->ic_flags);
! 1275:
! 1276: mb.m_data = (caddr_t)tap;
! 1277: mb.m_len = sc->sc_txtap_len;
! 1278: mb.m_next = m0;
! 1279: mb.m_nextpkt = NULL;
! 1280: mb.m_type = 0;
! 1281: mb.m_flags = 0;
! 1282: bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_OUT);
! 1283: }
! 1284: #endif
! 1285:
! 1286: data = &txq->data[txq->cur];
! 1287: desc = &txq->desc[txq->cur];
! 1288:
! 1289: /* save and trim IEEE802.11 header */
! 1290: m_copydata(m0, 0, sizeof (struct ieee80211_frame), (caddr_t)&desc->wh);
! 1291: m_adj(m0, sizeof (struct ieee80211_frame));
! 1292:
! 1293: if (ic->ic_opmode == IEEE80211_M_IBSS) {
! 1294: station = iwi_find_txnode(sc, desc->wh.i_addr1);
! 1295: if (station == -1) {
! 1296: m_freem(m0);
! 1297: ieee80211_release_node(ic, ni);
! 1298: ifp->if_oerrors++;
! 1299: return 0;
! 1300: }
! 1301: }
! 1302:
! 1303: error = bus_dmamap_load_mbuf(sc->sc_dmat, data->map, m0,
! 1304: BUS_DMA_NOWAIT);
! 1305: if (error != 0 && error != EFBIG) {
! 1306: printf("%s: could not map mbuf (error %d)\n",
! 1307: sc->sc_dev.dv_xname, error);
! 1308: m_freem(m0);
! 1309: return error;
! 1310: }
! 1311: if (error != 0) {
! 1312: /* too many fragments, linearize */
! 1313:
! 1314: MGETHDR(mnew, M_DONTWAIT, MT_DATA);
! 1315: if (mnew == NULL) {
! 1316: m_freem(m0);
! 1317: return ENOMEM;
! 1318: }
! 1319:
! 1320: M_DUP_PKTHDR(mnew, m0);
! 1321: if (m0->m_pkthdr.len > MHLEN) {
! 1322: MCLGET(mnew, M_DONTWAIT);
! 1323: if (!(mnew->m_flags & M_EXT)) {
! 1324: m_freem(m0);
! 1325: m_freem(mnew);
! 1326: return ENOMEM;
! 1327: }
! 1328: }
! 1329:
! 1330: m_copydata(m0, 0, m0->m_pkthdr.len, mtod(mnew, caddr_t));
! 1331: m_freem(m0);
! 1332: mnew->m_len = mnew->m_pkthdr.len;
! 1333: m0 = mnew;
! 1334:
! 1335: error = bus_dmamap_load_mbuf(sc->sc_dmat, data->map, m0,
! 1336: BUS_DMA_NOWAIT);
! 1337: if (error != 0) {
! 1338: printf("%s: could not map mbuf (error %d)\n",
! 1339: sc->sc_dev.dv_xname, error);
! 1340: m_freem(m0);
! 1341: return error;
! 1342: }
! 1343: }
! 1344:
! 1345: data->m = m0;
! 1346: data->ni = ni;
! 1347:
! 1348: desc->hdr.type = IWI_HDR_TYPE_DATA;
! 1349: desc->hdr.flags = IWI_HDR_FLAG_IRQ;
! 1350: desc->cmd = IWI_DATA_CMD_TX;
! 1351: desc->len = htole16(m0->m_pkthdr.len);
! 1352: desc->station = station;
! 1353: desc->flags = 0;
! 1354: desc->xflags = 0;
! 1355:
! 1356: if (!IEEE80211_IS_MULTICAST(desc->wh.i_addr1))
! 1357: desc->flags |= IWI_DATA_FLAG_NEED_ACK;
! 1358:
! 1359: if (desc->wh.i_fc[1] & IEEE80211_FC1_WEP) {
! 1360: desc->wep_txkey = ic->ic_wep_txkey |
! 1361: ((ic->ic_nw_keys[ic->ic_wep_txkey].k_cipher ==
! 1362: IEEE80211_CIPHER_WEP40) ? IWI_DATA_KEY_WEP40 :
! 1363: IWI_DATA_KEY_WEP104);
! 1364: } else {
! 1365: desc->flags |= IWI_DATA_FLAG_NO_WEP;
! 1366: desc->wep_txkey = 0;
! 1367: }
! 1368: if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
! 1369: desc->flags |= IWI_DATA_FLAG_SHPREAMBLE;
! 1370:
! 1371: if (ic->ic_curmode == IEEE80211_MODE_11B)
! 1372: desc->xflags |= IWI_DATA_XFLAG_CCK;
! 1373:
! 1374: desc->nseg = htole32(data->map->dm_nsegs);
! 1375: for (i = 0; i < data->map->dm_nsegs; i++) {
! 1376: desc->seg_addr[i] = htole32(data->map->dm_segs[i].ds_addr);
! 1377: desc->seg_len[i] = htole16(data->map->dm_segs[i].ds_len);
! 1378: }
! 1379:
! 1380: bus_dmamap_sync(sc->sc_dmat, data->map, 0, data->map->dm_mapsize,
! 1381: BUS_DMASYNC_PREWRITE);
! 1382: bus_dmamap_sync(sc->sc_dmat, txq->map,
! 1383: txq->cur * sizeof (struct iwi_tx_desc),
! 1384: sizeof (struct iwi_tx_desc), BUS_DMASYNC_PREWRITE);
! 1385:
! 1386: DPRINTFN(5, ("sending data frame idx=%u len=%u nseg=%u\n", txq->cur,
! 1387: letoh16(desc->len), data->map->dm_nsegs));
! 1388:
! 1389: txq->queued++;
! 1390: txq->cur = (txq->cur + 1) % IWI_TX_RING_COUNT;
! 1391: CSR_WRITE_4(sc, txq->csr_widx, txq->cur);
! 1392:
! 1393: return 0;
! 1394: }
! 1395:
! 1396: void
! 1397: iwi_start(struct ifnet *ifp)
! 1398: {
! 1399: struct iwi_softc *sc = ifp->if_softc;
! 1400: struct ieee80211com *ic = &sc->sc_ic;
! 1401: struct mbuf *m0;
! 1402: struct ieee80211_node *ni;
! 1403:
! 1404: if (ic->ic_state != IEEE80211_S_RUN)
! 1405: return;
! 1406:
! 1407: for (;;) {
! 1408: IFQ_POLL(&ifp->if_snd, m0);
! 1409: if (m0 == NULL)
! 1410: break;
! 1411:
! 1412: if (sc->txq[0].queued >= IWI_TX_RING_COUNT - 8) {
! 1413: ifp->if_flags |= IFF_OACTIVE;
! 1414: break;
! 1415: }
! 1416: IFQ_DEQUEUE(&ifp->if_snd, m0);
! 1417: #if NBPFILTER > 0
! 1418: if (ifp->if_bpf != NULL)
! 1419: bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
! 1420: #endif
! 1421:
! 1422: m0 = ieee80211_encap(ifp, m0, &ni);
! 1423: if (m0 == NULL)
! 1424: continue;
! 1425:
! 1426: #if NBPFILTER > 0
! 1427: if (ic->ic_rawbpf != NULL)
! 1428: bpf_mtap(ic->ic_rawbpf, m0, BPF_DIRECTION_OUT);
! 1429: #endif
! 1430:
! 1431: if (iwi_tx_start(ifp, m0, ni) != 0) {
! 1432: if (ni != NULL)
! 1433: ieee80211_release_node(ic, ni);
! 1434: ifp->if_oerrors++;
! 1435: break;
! 1436: }
! 1437:
! 1438: /* start watchdog timer */
! 1439: sc->sc_tx_timer = 5;
! 1440: ifp->if_timer = 1;
! 1441: }
! 1442: }
! 1443:
! 1444: void
! 1445: iwi_watchdog(struct ifnet *ifp)
! 1446: {
! 1447: struct iwi_softc *sc = ifp->if_softc;
! 1448:
! 1449: ifp->if_timer = 0;
! 1450:
! 1451: if (sc->sc_tx_timer > 0) {
! 1452: if (--sc->sc_tx_timer == 0) {
! 1453: printf("%s: device timeout\n", sc->sc_dev.dv_xname);
! 1454: ifp->if_flags &= ~IFF_UP;
! 1455: iwi_stop(ifp, 1);
! 1456: ifp->if_oerrors++;
! 1457: return;
! 1458: }
! 1459: ifp->if_timer = 1;
! 1460: }
! 1461:
! 1462: ieee80211_watchdog(ifp);
! 1463: }
! 1464:
! 1465: int
! 1466: iwi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
! 1467: {
! 1468: struct iwi_softc *sc = ifp->if_softc;
! 1469: struct ieee80211com *ic = &sc->sc_ic;
! 1470: struct ifaddr *ifa;
! 1471: struct ifreq *ifr;
! 1472: int s, error = 0;
! 1473:
! 1474: s = splnet();
! 1475:
! 1476: switch (cmd) {
! 1477: case SIOCSIFADDR:
! 1478: ifa = (struct ifaddr *)data;
! 1479: ifp->if_flags |= IFF_UP;
! 1480: #ifdef INET
! 1481: if (ifa->ifa_addr->sa_family == AF_INET)
! 1482: arp_ifinit(&ic->ic_ac, ifa);
! 1483: #endif
! 1484: /* FALLTHROUGH */
! 1485: case SIOCSIFFLAGS:
! 1486: if (ifp->if_flags & IFF_UP) {
! 1487: if (!(ifp->if_flags & IFF_RUNNING))
! 1488: iwi_init(ifp);
! 1489: } else {
! 1490: if (ifp->if_flags & IFF_RUNNING)
! 1491: iwi_stop(ifp, 1);
! 1492: }
! 1493: break;
! 1494:
! 1495: case SIOCADDMULTI:
! 1496: case SIOCDELMULTI:
! 1497: ifr = (struct ifreq *)data;
! 1498: error = (cmd == SIOCADDMULTI) ?
! 1499: ether_addmulti(ifr, &ic->ic_ac) :
! 1500: ether_delmulti(ifr, &ic->ic_ac);
! 1501:
! 1502: if (error == ENETRESET)
! 1503: error = 0;
! 1504: break;
! 1505:
! 1506: case SIOCG80211TXPOWER:
! 1507: /*
! 1508: * If the hardware radio transmitter switch is off, report a
! 1509: * tx power of IEEE80211_TXPOWER_MIN to indicate that radio
! 1510: * transmitter is killed.
! 1511: */
! 1512: ((struct ieee80211_txpower *)data)->i_val =
! 1513: (CSR_READ_4(sc, IWI_CSR_IO) & IWI_IO_RADIO_ENABLED) ?
! 1514: sc->sc_ic.ic_txpower : IEEE80211_TXPOWER_MIN;
! 1515: break;
! 1516:
! 1517: default:
! 1518: error = ieee80211_ioctl(ifp, cmd, data);
! 1519: }
! 1520:
! 1521: if (error == ENETRESET) {
! 1522: if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
! 1523: (IFF_UP | IFF_RUNNING))
! 1524: iwi_init(ifp);
! 1525: error = 0;
! 1526: }
! 1527:
! 1528: splx(s);
! 1529: return error;
! 1530: }
! 1531:
! 1532: void
! 1533: iwi_stop_master(struct iwi_softc *sc)
! 1534: {
! 1535: int ntries;
! 1536:
! 1537: /* disable interrupts */
! 1538: CSR_WRITE_4(sc, IWI_CSR_INTR_MASK, 0);
! 1539:
! 1540: CSR_WRITE_4(sc, IWI_CSR_RST, IWI_RST_STOP_MASTER);
! 1541: for (ntries = 0; ntries < 5; ntries++) {
! 1542: if (CSR_READ_4(sc, IWI_CSR_RST) & IWI_RST_MASTER_DISABLED)
! 1543: break;
! 1544: DELAY(10);
! 1545: }
! 1546: if (ntries == 5) {
! 1547: printf("%s: timeout waiting for master\n",
! 1548: sc->sc_dev.dv_xname);
! 1549: }
! 1550:
! 1551: CSR_WRITE_4(sc, IWI_CSR_RST, CSR_READ_4(sc, IWI_CSR_RST) |
! 1552: IWI_RST_PRINCETON_RESET);
! 1553:
! 1554: sc->flags &= ~IWI_FLAG_FW_INITED;
! 1555: }
! 1556:
! 1557: int
! 1558: iwi_reset(struct iwi_softc *sc)
! 1559: {
! 1560: int i, ntries;
! 1561:
! 1562: iwi_stop_master(sc);
! 1563:
! 1564: /* move adapter to D0 state */
! 1565: CSR_WRITE_4(sc, IWI_CSR_CTL, CSR_READ_4(sc, IWI_CSR_CTL) |
! 1566: IWI_CTL_INIT);
! 1567:
! 1568: CSR_WRITE_4(sc, IWI_CSR_READ_INT, IWI_READ_INT_INIT_HOST);
! 1569:
! 1570: /* wait for clock stabilization */
! 1571: for (ntries = 0; ntries < 1000; ntries++) {
! 1572: if (CSR_READ_4(sc, IWI_CSR_CTL) & IWI_CTL_CLOCK_READY)
! 1573: break;
! 1574: DELAY(200);
! 1575: }
! 1576: if (ntries == 1000) {
! 1577: printf("%s: timeout waiting for clock stabilization\n",
! 1578: sc->sc_dev.dv_xname);
! 1579: return ETIMEDOUT;
! 1580: }
! 1581:
! 1582: CSR_WRITE_4(sc, IWI_CSR_RST, CSR_READ_4(sc, IWI_CSR_RST) |
! 1583: IWI_RST_SW_RESET);
! 1584:
! 1585: DELAY(10);
! 1586:
! 1587: CSR_WRITE_4(sc, IWI_CSR_CTL, CSR_READ_4(sc, IWI_CSR_CTL) |
! 1588: IWI_CTL_INIT);
! 1589:
! 1590: /* clear NIC memory */
! 1591: CSR_WRITE_4(sc, IWI_CSR_AUTOINC_ADDR, 0);
! 1592: for (i = 0; i < 0xc000; i++)
! 1593: CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, 0);
! 1594:
! 1595: return 0;
! 1596: }
! 1597:
! 1598: int
! 1599: iwi_load_ucode(struct iwi_softc *sc, const char *data, int size)
! 1600: {
! 1601: const uint16_t *w;
! 1602: int ntries, i;
! 1603:
! 1604: CSR_WRITE_4(sc, IWI_CSR_RST, CSR_READ_4(sc, IWI_CSR_RST) |
! 1605: IWI_RST_STOP_MASTER);
! 1606: for (ntries = 0; ntries < 5; ntries++) {
! 1607: if (CSR_READ_4(sc, IWI_CSR_RST) & IWI_RST_MASTER_DISABLED)
! 1608: break;
! 1609: DELAY(10);
! 1610: }
! 1611: if (ntries == 5) {
! 1612: printf("%s: timeout waiting for master\n",
! 1613: sc->sc_dev.dv_xname);
! 1614: return ETIMEDOUT;
! 1615: }
! 1616:
! 1617: MEM_WRITE_4(sc, 0x3000e0, 0x80000000);
! 1618: DELAY(5000);
! 1619:
! 1620: CSR_WRITE_4(sc, IWI_CSR_RST, CSR_READ_4(sc, IWI_CSR_RST) &
! 1621: ~IWI_RST_PRINCETON_RESET);
! 1622:
! 1623: DELAY(5000);
! 1624: MEM_WRITE_4(sc, 0x3000e0, 0);
! 1625: DELAY(1000);
! 1626: MEM_WRITE_4(sc, IWI_MEM_EVENT_CTL, 1);
! 1627: DELAY(1000);
! 1628: MEM_WRITE_4(sc, IWI_MEM_EVENT_CTL, 0);
! 1629: DELAY(1000);
! 1630: MEM_WRITE_1(sc, 0x200000, 0x00);
! 1631: MEM_WRITE_1(sc, 0x200000, 0x40);
! 1632: DELAY(1000);
! 1633:
! 1634: /* adapter is buggy, we must set the address for each word */
! 1635: for (w = (const uint16_t *)data; size > 0; w++, size -= 2)
! 1636: MEM_WRITE_2(sc, 0x200010, htole16(*w));
! 1637:
! 1638: MEM_WRITE_1(sc, 0x200000, 0x00);
! 1639: MEM_WRITE_1(sc, 0x200000, 0x80);
! 1640:
! 1641: /* wait until we get an answer */
! 1642: for (ntries = 0; ntries < 100; ntries++) {
! 1643: if (MEM_READ_1(sc, 0x200000) & 1)
! 1644: break;
! 1645: DELAY(100);
! 1646: }
! 1647: if (ntries == 100) {
! 1648: printf("%s: timeout waiting for ucode to initialize\n",
! 1649: sc->sc_dev.dv_xname);
! 1650: return ETIMEDOUT;
! 1651: }
! 1652:
! 1653: /* read the answer or the firmware will not initialize properly */
! 1654: for (i = 0; i < 7; i++)
! 1655: MEM_READ_4(sc, 0x200004);
! 1656:
! 1657: MEM_WRITE_1(sc, 0x200000, 0x00);
! 1658:
! 1659: return 0;
! 1660: }
! 1661:
! 1662: /* macro to handle unaligned little endian data in firmware image */
! 1663: #define GETLE32(p) ((p)[0] | (p)[1] << 8 | (p)[2] << 16 | (p)[3] << 24)
! 1664:
! 1665: int
! 1666: iwi_load_firmware(struct iwi_softc *sc, const char *data, int size)
! 1667: {
! 1668: bus_dmamap_t map;
! 1669: bus_dma_segment_t seg;
! 1670: caddr_t virtaddr;
! 1671: u_char *p, *end;
! 1672: uint32_t sentinel, ctl, src, dst, sum, len, mlen;
! 1673: int ntries, nsegs, error;
! 1674:
! 1675: /* allocate DMA memory to store firmware image */
! 1676: error = bus_dmamap_create(sc->sc_dmat, size, 1, size, 0,
! 1677: BUS_DMA_NOWAIT, &map);
! 1678: if (error != 0) {
! 1679: printf("%s: could not create firmware DMA map\n",
! 1680: sc->sc_dev.dv_xname);
! 1681: goto fail1;
! 1682: }
! 1683:
! 1684: error = bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, &seg, 1,
! 1685: &nsegs, BUS_DMA_NOWAIT);
! 1686: if (error != 0) {
! 1687: printf("%s: could not allocate firmware DMA memory\n",
! 1688: sc->sc_dev.dv_xname);
! 1689: goto fail2;
! 1690: }
! 1691:
! 1692: error = bus_dmamem_map(sc->sc_dmat, &seg, nsegs, size, &virtaddr,
! 1693: BUS_DMA_NOWAIT);
! 1694: if (error != 0) {
! 1695: printf("%s: could not map firmware DMA memory\n",
! 1696: sc->sc_dev.dv_xname);
! 1697: goto fail3;
! 1698: }
! 1699:
! 1700: error = bus_dmamap_load(sc->sc_dmat, map, virtaddr, size, NULL,
! 1701: BUS_DMA_NOWAIT);
! 1702: if (error != 0) {
! 1703: printf("%s: could not load firmware DMA map\n",
! 1704: sc->sc_dev.dv_xname);
! 1705: goto fail4;
! 1706: }
! 1707:
! 1708: /* copy firmware image to DMA memory */
! 1709: bcopy(data, virtaddr, size);
! 1710:
! 1711: /* make sure the adapter will get up-to-date values */
! 1712: bus_dmamap_sync(sc->sc_dmat, map, 0, size, BUS_DMASYNC_PREWRITE);
! 1713:
! 1714: /* tell the adapter where the command blocks are stored */
! 1715: MEM_WRITE_4(sc, 0x3000a0, 0x27000);
! 1716:
! 1717: /*
! 1718: * Store command blocks into adapter's internal memory using register
! 1719: * indirections. The adapter will read the firmware image through DMA
! 1720: * using information stored in command blocks.
! 1721: */
! 1722: src = map->dm_segs[0].ds_addr;
! 1723: p = virtaddr;
! 1724: end = p + size;
! 1725: CSR_WRITE_4(sc, IWI_CSR_AUTOINC_ADDR, 0x27000);
! 1726:
! 1727: while (p < end) {
! 1728: dst = GETLE32(p); p += 4; src += 4;
! 1729: len = GETLE32(p); p += 4; src += 4;
! 1730: p += len;
! 1731:
! 1732: while (len > 0) {
! 1733: mlen = min(len, IWI_CB_MAXDATALEN);
! 1734:
! 1735: ctl = IWI_CB_DEFAULT_CTL | mlen;
! 1736: sum = ctl ^ src ^ dst;
! 1737:
! 1738: /* write a command block */
! 1739: CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, ctl);
! 1740: CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, src);
! 1741: CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, dst);
! 1742: CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, sum);
! 1743:
! 1744: src += mlen;
! 1745: dst += mlen;
! 1746: len -= mlen;
! 1747: }
! 1748: }
! 1749:
! 1750: /* write a fictive final command block (sentinel) */
! 1751: sentinel = CSR_READ_4(sc, IWI_CSR_AUTOINC_ADDR);
! 1752: CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, 0);
! 1753:
! 1754: CSR_WRITE_4(sc, IWI_CSR_RST, CSR_READ_4(sc, IWI_CSR_RST) &
! 1755: ~(IWI_RST_MASTER_DISABLED | IWI_RST_STOP_MASTER));
! 1756:
! 1757: /* tell the adapter to start processing command blocks */
! 1758: MEM_WRITE_4(sc, 0x3000a4, 0x540100);
! 1759:
! 1760: /* wait until the adapter has processed all command blocks */
! 1761: for (ntries = 0; ntries < 400; ntries++) {
! 1762: if (MEM_READ_4(sc, 0x3000d0) >= sentinel)
! 1763: break;
! 1764: DELAY(100);
! 1765: }
! 1766: if (ntries == 400) {
! 1767: printf("%s: timeout processing cb\n", sc->sc_dev.dv_xname);
! 1768: error = ETIMEDOUT;
! 1769: goto fail5;
! 1770: }
! 1771:
! 1772: /* we're done with command blocks processing */
! 1773: MEM_WRITE_4(sc, 0x3000a4, 0x540c00);
! 1774:
! 1775: /* allow interrupts so we know when the firmware is inited */
! 1776: CSR_WRITE_4(sc, IWI_CSR_INTR_MASK, IWI_INTR_MASK);
! 1777:
! 1778: /* tell the adapter to initialize the firmware */
! 1779: CSR_WRITE_4(sc, IWI_CSR_RST, 0);
! 1780:
! 1781: CSR_WRITE_4(sc, IWI_CSR_CTL, CSR_READ_4(sc, IWI_CSR_CTL) |
! 1782: IWI_CTL_ALLOW_STANDBY);
! 1783:
! 1784: /* wait at most one second for firmware initialization to complete */
! 1785: if ((error = tsleep(sc, 0, "iwiinit", hz)) != 0) {
! 1786: printf("%s: timeout waiting for firmware initialization to "
! 1787: "complete\n", sc->sc_dev.dv_xname);
! 1788: goto fail5;
! 1789: }
! 1790:
! 1791: fail5: bus_dmamap_sync(sc->sc_dmat, map, 0, size, BUS_DMASYNC_POSTWRITE);
! 1792: bus_dmamap_unload(sc->sc_dmat, map);
! 1793: fail4: bus_dmamem_unmap(sc->sc_dmat, virtaddr, size);
! 1794: fail3: bus_dmamem_free(sc->sc_dmat, &seg, 1);
! 1795: fail2: bus_dmamap_destroy(sc->sc_dmat, map);
! 1796: fail1: return error;
! 1797: }
! 1798:
! 1799: int
! 1800: iwi_config(struct iwi_softc *sc)
! 1801: {
! 1802: struct ieee80211com *ic = &sc->sc_ic;
! 1803: struct ifnet *ifp = &ic->ic_if;
! 1804: struct iwi_configuration config;
! 1805: struct iwi_rateset rs;
! 1806: struct iwi_txpower power;
! 1807: struct ieee80211_key *k;
! 1808: struct iwi_wep_key wepkey;
! 1809: uint32_t data;
! 1810: int error, nchan, i;
! 1811:
! 1812: IEEE80211_ADDR_COPY(ic->ic_myaddr, LLADDR(ifp->if_sadl));
! 1813: DPRINTF(("Setting MAC address to %s\n", ether_sprintf(ic->ic_myaddr)));
! 1814: error = iwi_cmd(sc, IWI_CMD_SET_MAC_ADDRESS, ic->ic_myaddr,
! 1815: IEEE80211_ADDR_LEN, 0);
! 1816: if (error != 0)
! 1817: return error;
! 1818:
! 1819: bzero(&config, sizeof config);
! 1820: config.multicast_enabled = 1;
! 1821: config.silence_threshold = 30;
! 1822: config.report_noise = 1;
! 1823: config.answer_pbreq = (ic->ic_opmode == IEEE80211_M_IBSS) ? 1 : 0;
! 1824: DPRINTF(("Configuring adapter\n"));
! 1825: error = iwi_cmd(sc, IWI_CMD_SET_CONFIG, &config, sizeof config, 0);
! 1826: if (error != 0)
! 1827: return error;
! 1828:
! 1829: data = htole32(IWI_POWER_MODE_CAM);
! 1830: DPRINTF(("Setting power mode to %u\n", letoh32(data)));
! 1831: error = iwi_cmd(sc, IWI_CMD_SET_POWER_MODE, &data, sizeof data, 0);
! 1832: if (error != 0)
! 1833: return error;
! 1834:
! 1835: data = htole32(ic->ic_rtsthreshold);
! 1836: DPRINTF(("Setting RTS threshold to %u\n", letoh32(data)));
! 1837: error = iwi_cmd(sc, IWI_CMD_SET_RTS_THRESHOLD, &data, sizeof data, 0);
! 1838: if (error != 0)
! 1839: return error;
! 1840:
! 1841: data = htole32(ic->ic_fragthreshold);
! 1842: DPRINTF(("Setting fragmentation threshold to %u\n", letoh32(data)));
! 1843: error = iwi_cmd(sc, IWI_CMD_SET_FRAG_THRESHOLD, &data, sizeof data, 0);
! 1844: if (error != 0)
! 1845: return error;
! 1846:
! 1847: /*
! 1848: * Set default Tx power for 802.11b/g and 802.11a channels.
! 1849: */
! 1850: nchan = 0;
! 1851: for (i = 0; i <= IEEE80211_CHAN_MAX; i++) {
! 1852: if (!IEEE80211_IS_CHAN_2GHZ(&ic->ic_channels[i]))
! 1853: continue;
! 1854: power.chan[nchan].chan = i;
! 1855: power.chan[nchan].power = IWI_TXPOWER_MAX;
! 1856: nchan++;
! 1857: }
! 1858: power.nchan = nchan;
! 1859:
! 1860: power.mode = IWI_MODE_11G;
! 1861: DPRINTF(("Setting .11g channels tx power\n"));
! 1862: error = iwi_cmd(sc, IWI_CMD_SET_TX_POWER, &power, sizeof power, 0);
! 1863: if (error != 0)
! 1864: return error;
! 1865:
! 1866: power.mode = IWI_MODE_11B;
! 1867: DPRINTF(("Setting .11b channels tx power\n"));
! 1868: error = iwi_cmd(sc, IWI_CMD_SET_TX_POWER, &power, sizeof power, 0);
! 1869: if (error != 0)
! 1870: return error;
! 1871:
! 1872: nchan = 0;
! 1873: for (i = 0; i <= IEEE80211_CHAN_MAX; i++) {
! 1874: if (!IEEE80211_IS_CHAN_5GHZ(&ic->ic_channels[i]))
! 1875: continue;
! 1876: power.chan[nchan].chan = i;
! 1877: power.chan[nchan].power = IWI_TXPOWER_MAX;
! 1878: nchan++;
! 1879: }
! 1880: power.nchan = nchan;
! 1881:
! 1882: if (nchan > 0) { /* 2915ABG only */
! 1883: power.mode = IWI_MODE_11A;
! 1884: DPRINTF(("Setting .11a channels tx power\n"));
! 1885: error = iwi_cmd(sc, IWI_CMD_SET_TX_POWER, &power, sizeof power,
! 1886: 0);
! 1887: if (error != 0)
! 1888: return error;
! 1889: }
! 1890:
! 1891: rs.mode = IWI_MODE_11G;
! 1892: rs.type = IWI_RATESET_TYPE_SUPPORTED;
! 1893: rs.nrates = ic->ic_sup_rates[IEEE80211_MODE_11G].rs_nrates;
! 1894: bcopy(ic->ic_sup_rates[IEEE80211_MODE_11G].rs_rates, rs.rates,
! 1895: rs.nrates);
! 1896: DPRINTF(("Setting .11bg supported rates (%u)\n", rs.nrates));
! 1897: error = iwi_cmd(sc, IWI_CMD_SET_RATES, &rs, sizeof rs, 0);
! 1898: if (error != 0)
! 1899: return error;
! 1900:
! 1901: rs.mode = IWI_MODE_11A;
! 1902: rs.type = IWI_RATESET_TYPE_SUPPORTED;
! 1903: rs.nrates = ic->ic_sup_rates[IEEE80211_MODE_11A].rs_nrates;
! 1904: bcopy(ic->ic_sup_rates[IEEE80211_MODE_11A].rs_rates, rs.rates,
! 1905: rs.nrates);
! 1906: DPRINTF(("Setting .11a supported rates (%u)\n", rs.nrates));
! 1907: error = iwi_cmd(sc, IWI_CMD_SET_RATES, &rs, sizeof rs, 0);
! 1908: if (error != 0)
! 1909: return error;
! 1910:
! 1911: /* if we have a desired ESSID, set it now */
! 1912: if (ic->ic_des_esslen != 0) {
! 1913: #ifdef IWI_DEBUG
! 1914: if (iwi_debug > 0) {
! 1915: printf("Setting desired ESSID to ");
! 1916: ieee80211_print_essid(ic->ic_des_essid,
! 1917: ic->ic_des_esslen);
! 1918: printf("\n");
! 1919: }
! 1920: #endif
! 1921: error = iwi_cmd(sc, IWI_CMD_SET_ESSID, ic->ic_des_essid,
! 1922: ic->ic_des_esslen, 0);
! 1923: if (error != 0)
! 1924: return error;
! 1925: }
! 1926:
! 1927: data = htole32(arc4random());
! 1928: DPRINTF(("Setting initialization vector to %u\n", letoh32(data)));
! 1929: error = iwi_cmd(sc, IWI_CMD_SET_IV, &data, sizeof data, 0);
! 1930: if (error != 0)
! 1931: return error;
! 1932:
! 1933: if (ic->ic_flags & IEEE80211_F_WEPON) {
! 1934: k = ic->ic_nw_keys;
! 1935: for (i = 0; i < IEEE80211_WEP_NKID; i++, k++) {
! 1936: wepkey.cmd = IWI_WEP_KEY_CMD_SETKEY;
! 1937: wepkey.idx = i;
! 1938: wepkey.len = k->k_len;
! 1939: bzero(wepkey.key, sizeof wepkey.key);
! 1940: bcopy(k->k_key, wepkey.key, k->k_len);
! 1941: DPRINTF(("Setting wep key index %u len %u\n",
! 1942: wepkey.idx, wepkey.len));
! 1943: error = iwi_cmd(sc, IWI_CMD_SET_WEP_KEY, &wepkey,
! 1944: sizeof wepkey, 0);
! 1945: if (error != 0)
! 1946: return error;
! 1947: }
! 1948: }
! 1949:
! 1950: /* enable adapter */
! 1951: DPRINTF(("Enabling adapter\n"));
! 1952: return iwi_cmd(sc, IWI_CMD_ENABLE, NULL, 0, 0);
! 1953: }
! 1954:
! 1955: int
! 1956: iwi_set_chan(struct iwi_softc *sc, struct ieee80211_channel *chan)
! 1957: {
! 1958: struct ieee80211com *ic = &sc->sc_ic;
! 1959: struct iwi_scan scan;
! 1960:
! 1961: bzero(&scan, sizeof scan);
! 1962: memset(scan.type, IWI_SCAN_TYPE_PASSIVE, sizeof scan.type);
! 1963: scan.passive = htole16(2000);
! 1964: scan.channels[0] = 1 |
! 1965: (IEEE80211_IS_CHAN_5GHZ(chan) ? IWI_CHAN_5GHZ : IWI_CHAN_2GHZ);
! 1966: scan.channels[1] = ieee80211_chan2ieee(ic, chan);
! 1967:
! 1968: DPRINTF(("Setting channel to %u\n", ieee80211_chan2ieee(ic, chan)));
! 1969: return iwi_cmd(sc, IWI_CMD_SCAN, &scan, sizeof scan, 1);
! 1970: }
! 1971:
! 1972: int
! 1973: iwi_scan(struct iwi_softc *sc)
! 1974: {
! 1975: struct ieee80211com *ic = &sc->sc_ic;
! 1976: struct iwi_scan scan;
! 1977: uint8_t *p;
! 1978: int i, count;
! 1979:
! 1980: bzero(&scan, sizeof scan);
! 1981:
! 1982: if (ic->ic_des_esslen != 0) {
! 1983: scan.bdirected = htole16(40);
! 1984: memset(scan.type, IWI_SCAN_TYPE_BDIRECTED, sizeof scan.type);
! 1985: } else {
! 1986: scan.broadcast = htole16(40);
! 1987: memset(scan.type, IWI_SCAN_TYPE_BROADCAST, sizeof scan.type);
! 1988: }
! 1989:
! 1990: p = scan.channels;
! 1991: count = 0;
! 1992: for (i = 0; i <= IEEE80211_CHAN_MAX; i++) {
! 1993: if (IEEE80211_IS_CHAN_5GHZ(&ic->ic_channels[i])) {
! 1994: *++p = i;
! 1995: count++;
! 1996: }
! 1997: }
! 1998: *(p - count) = IWI_CHAN_5GHZ | count;
! 1999:
! 2000: p = (count > 0) ? p + 1 : scan.channels;
! 2001: count = 0;
! 2002: for (i = 0; i <= IEEE80211_CHAN_MAX; i++) {
! 2003: if (IEEE80211_IS_CHAN_2GHZ(&ic->ic_channels[i])) {
! 2004: *++p = i;
! 2005: count++;
! 2006: }
! 2007: }
! 2008: *(p - count) = IWI_CHAN_2GHZ | count;
! 2009:
! 2010: DPRINTF(("Start scanning\n"));
! 2011: return iwi_cmd(sc, IWI_CMD_SCAN, &scan, sizeof scan, 1);
! 2012: }
! 2013:
! 2014: int
! 2015: iwi_auth_and_assoc(struct iwi_softc *sc)
! 2016: {
! 2017: struct ieee80211com *ic = &sc->sc_ic;
! 2018: struct ieee80211_node *ni = ic->ic_bss;
! 2019: struct iwi_configuration config;
! 2020: struct iwi_associate assoc;
! 2021: struct iwi_rateset rs;
! 2022: uint16_t capinfo;
! 2023: uint32_t data;
! 2024: int error;
! 2025:
! 2026: /* update adapter configuration */
! 2027: bzero(&config, sizeof config);
! 2028: config.multicast_enabled = 1;
! 2029: config.silence_threshold = 30;
! 2030: config.report_noise = 1;
! 2031: config.answer_pbreq = (ic->ic_opmode == IEEE80211_M_IBSS) ? 1 : 0;
! 2032: if (ic->ic_curmode == IEEE80211_MODE_11G)
! 2033: config.bg_autodetection = 1;
! 2034: DPRINTF(("Configuring adapter\n"));
! 2035: error = iwi_cmd(sc, IWI_CMD_SET_CONFIG, &config, sizeof config, 1);
! 2036: if (error != 0)
! 2037: return error;
! 2038:
! 2039: #ifdef IWI_DEBUG
! 2040: if (iwi_debug > 0) {
! 2041: printf("Setting ESSID to ");
! 2042: ieee80211_print_essid(ni->ni_essid, ni->ni_esslen);
! 2043: printf("\n");
! 2044: }
! 2045: #endif
! 2046: error = iwi_cmd(sc, IWI_CMD_SET_ESSID, ni->ni_essid, ni->ni_esslen, 1);
! 2047: if (error != 0)
! 2048: return error;
! 2049:
! 2050: /* the rate set has already been "negotiated" */
! 2051: rs.mode = IEEE80211_IS_CHAN_5GHZ(ni->ni_chan) ? IWI_MODE_11A :
! 2052: IWI_MODE_11G;
! 2053: rs.type = IWI_RATESET_TYPE_NEGOTIATED;
! 2054: rs.nrates = ni->ni_rates.rs_nrates;
! 2055: if (rs.nrates > sizeof rs.rates) {
! 2056: #ifdef DIAGNOSTIC
! 2057: /* should not happen since the rates are negotiated */
! 2058: printf("%s: XXX too many rates (count=%d, last=%d)\n",
! 2059: sc->sc_dev.dv_xname, ni->ni_rates.rs_nrates,
! 2060: ni->ni_rates.rs_rates[ni->ni_rates.rs_nrates - 1] &
! 2061: IEEE80211_RATE_VAL);
! 2062: #endif
! 2063: rs.nrates = sizeof rs.rates;
! 2064: }
! 2065: bcopy(ni->ni_rates.rs_rates, rs.rates, rs.nrates);
! 2066: DPRINTF(("Setting negotiated rates (%u)\n", rs.nrates));
! 2067: error = iwi_cmd(sc, IWI_CMD_SET_RATES, &rs, sizeof rs, 1);
! 2068: if (error != 0)
! 2069: return error;
! 2070:
! 2071: data = htole32(ni->ni_rssi);
! 2072: DPRINTF(("Setting sensitivity to %d\n", (int8_t)ni->ni_rssi));
! 2073: error = iwi_cmd(sc, IWI_CMD_SET_SENSITIVITY, &data, sizeof data, 1);
! 2074: if (error != 0)
! 2075: return error;
! 2076:
! 2077: bzero(&assoc, sizeof assoc);
! 2078: if (ic->ic_flags & IEEE80211_F_SIBSS)
! 2079: assoc.type = IWI_ASSOC_SIBSS;
! 2080: else
! 2081: assoc.type = IWI_ASSOC_ASSOCIATE;
! 2082: if (ic->ic_curmode == IEEE80211_MODE_11A)
! 2083: assoc.mode = IWI_MODE_11A;
! 2084: else if (ic->ic_curmode == IEEE80211_MODE_11B)
! 2085: assoc.mode = IWI_MODE_11B;
! 2086: else /* assume 802.11b/g */
! 2087: assoc.mode = IWI_MODE_11G;
! 2088: assoc.chan = ieee80211_chan2ieee(ic, ni->ni_chan);
! 2089: #if 0
! 2090: if (ni->ni_challenge != NULL) /* XXX */
! 2091: assoc.auth = (ic->ic_wep_txkey << 4) | IWI_AUTH_SHARED;
! 2092: #endif
! 2093: if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
! 2094: assoc.plen = IWI_ASSOC_SHPREAMBLE;
! 2095: bcopy(ni->ni_tstamp, assoc.tstamp, 8);
! 2096: capinfo = IEEE80211_CAPINFO_ESS;
! 2097: if (ic->ic_flags & IEEE80211_F_WEPON)
! 2098: capinfo |= IEEE80211_CAPINFO_PRIVACY;
! 2099: if ((ic->ic_flags & IEEE80211_F_SHPREAMBLE) &&
! 2100: IEEE80211_IS_CHAN_2GHZ(ni->ni_chan))
! 2101: capinfo |= IEEE80211_CAPINFO_SHORT_PREAMBLE;
! 2102: if (ic->ic_flags & IEEE80211_F_SHSLOT)
! 2103: capinfo |= IEEE80211_CAPINFO_SHORT_SLOTTIME;
! 2104: assoc.capinfo = htole16(capinfo);
! 2105:
! 2106: assoc.lintval = htole16(ic->ic_lintval);
! 2107: assoc.intval = htole16(ni->ni_intval);
! 2108: IEEE80211_ADDR_COPY(assoc.bssid, ni->ni_bssid);
! 2109: if (ic->ic_opmode == IEEE80211_M_IBSS)
! 2110: IEEE80211_ADDR_COPY(assoc.dst, etherbroadcastaddr);
! 2111: else
! 2112: IEEE80211_ADDR_COPY(assoc.dst, ni->ni_bssid);
! 2113:
! 2114: DPRINTF(("Trying to associate to %s channel %u auth %u\n",
! 2115: ether_sprintf(assoc.bssid), assoc.chan, assoc.auth));
! 2116: return iwi_cmd(sc, IWI_CMD_ASSOCIATE, &assoc, sizeof assoc, 1);
! 2117: }
! 2118:
! 2119: int
! 2120: iwi_init(struct ifnet *ifp)
! 2121: {
! 2122: struct iwi_softc *sc = ifp->if_softc;
! 2123: struct ieee80211com *ic = &sc->sc_ic;
! 2124: struct iwi_firmware_hdr *hdr;
! 2125: const char *name, *fw;
! 2126: u_char *data;
! 2127: size_t size;
! 2128: int i, error;
! 2129:
! 2130: iwi_stop(ifp, 0);
! 2131:
! 2132: if ((error = iwi_reset(sc)) != 0) {
! 2133: printf("%s: could not reset adapter\n", sc->sc_dev.dv_xname);
! 2134: goto fail1;
! 2135: }
! 2136:
! 2137: switch (sc->sc_ic.ic_opmode) {
! 2138: case IEEE80211_M_STA:
! 2139: case IEEE80211_M_HOSTAP:
! 2140: name = "iwi-bss";
! 2141: break;
! 2142: case IEEE80211_M_IBSS:
! 2143: case IEEE80211_M_AHDEMO:
! 2144: name = "iwi-ibss";
! 2145: break;
! 2146: case IEEE80211_M_MONITOR:
! 2147: name = "iwi-monitor";
! 2148: break;
! 2149: default:
! 2150: name = NULL; /* should not get there */
! 2151: }
! 2152:
! 2153: if ((error = loadfirmware(name, &data, &size)) != 0) {
! 2154: printf("%s: could not read firmware %s\n",
! 2155: sc->sc_dev.dv_xname, name);
! 2156: goto fail1;
! 2157: }
! 2158:
! 2159: if (size < sizeof (struct iwi_firmware_hdr)) {
! 2160: printf("%s: firmware image too short: %u bytes\n",
! 2161: sc->sc_dev.dv_xname, size);
! 2162: error = EINVAL;
! 2163: goto fail2;
! 2164: }
! 2165:
! 2166: hdr = (struct iwi_firmware_hdr *)data;
! 2167:
! 2168: if (hdr->vermaj < 3 || hdr->bootsz == 0 || hdr->ucodesz == 0 ||
! 2169: hdr->mainsz == 0) {
! 2170: printf("%s: firmware image too old (need at least 3.0)\n",
! 2171: sc->sc_dev.dv_xname);
! 2172: error = EINVAL;
! 2173: goto fail2;
! 2174: }
! 2175:
! 2176: if (size < sizeof (struct iwi_firmware_hdr) + letoh32(hdr->bootsz) +
! 2177: letoh32(hdr->ucodesz) + letoh32(hdr->mainsz)) {
! 2178: printf("%s: firmware image too short: %u bytes\n",
! 2179: sc->sc_dev.dv_xname, size);
! 2180: error = EINVAL;
! 2181: goto fail2;
! 2182: }
! 2183:
! 2184: fw = (const char *)data + sizeof (struct iwi_firmware_hdr);
! 2185: if ((error = iwi_load_firmware(sc, fw, letoh32(hdr->bootsz))) != 0) {
! 2186: printf("%s: could not load boot firmware\n",
! 2187: sc->sc_dev.dv_xname);
! 2188: goto fail2;
! 2189: }
! 2190:
! 2191: fw = (const char *)data + sizeof (struct iwi_firmware_hdr) +
! 2192: letoh32(hdr->bootsz);
! 2193: if ((error = iwi_load_ucode(sc, fw, letoh32(hdr->ucodesz))) != 0) {
! 2194: printf("%s: could not load microcode\n", sc->sc_dev.dv_xname);
! 2195: goto fail2;
! 2196: }
! 2197:
! 2198: iwi_stop_master(sc);
! 2199:
! 2200: CSR_WRITE_4(sc, IWI_CSR_CMD_BASE, sc->cmdq.map->dm_segs[0].ds_addr);
! 2201: CSR_WRITE_4(sc, IWI_CSR_CMD_SIZE, IWI_CMD_RING_COUNT);
! 2202: CSR_WRITE_4(sc, IWI_CSR_CMD_WIDX, sc->cmdq.cur);
! 2203:
! 2204: CSR_WRITE_4(sc, IWI_CSR_TX1_BASE, sc->txq[0].map->dm_segs[0].ds_addr);
! 2205: CSR_WRITE_4(sc, IWI_CSR_TX1_SIZE, IWI_TX_RING_COUNT);
! 2206: CSR_WRITE_4(sc, IWI_CSR_TX1_WIDX, sc->txq[0].cur);
! 2207:
! 2208: CSR_WRITE_4(sc, IWI_CSR_TX2_BASE, sc->txq[1].map->dm_segs[0].ds_addr);
! 2209: CSR_WRITE_4(sc, IWI_CSR_TX2_SIZE, IWI_TX_RING_COUNT);
! 2210: CSR_WRITE_4(sc, IWI_CSR_TX2_WIDX, sc->txq[1].cur);
! 2211:
! 2212: CSR_WRITE_4(sc, IWI_CSR_TX3_BASE, sc->txq[2].map->dm_segs[0].ds_addr);
! 2213: CSR_WRITE_4(sc, IWI_CSR_TX3_SIZE, IWI_TX_RING_COUNT);
! 2214: CSR_WRITE_4(sc, IWI_CSR_TX3_WIDX, sc->txq[2].cur);
! 2215:
! 2216: CSR_WRITE_4(sc, IWI_CSR_TX4_BASE, sc->txq[3].map->dm_segs[0].ds_addr);
! 2217: CSR_WRITE_4(sc, IWI_CSR_TX4_SIZE, IWI_TX_RING_COUNT);
! 2218: CSR_WRITE_4(sc, IWI_CSR_TX4_WIDX, sc->txq[3].cur);
! 2219:
! 2220: for (i = 0; i < IWI_RX_RING_COUNT; i++) {
! 2221: struct iwi_rx_data *data = &sc->rxq.data[i];
! 2222: CSR_WRITE_4(sc, data->reg, data->map->dm_segs[0].ds_addr);
! 2223: }
! 2224:
! 2225: CSR_WRITE_4(sc, IWI_CSR_RX_WIDX, IWI_RX_RING_COUNT - 1);
! 2226:
! 2227: fw = (const char *)data + sizeof (struct iwi_firmware_hdr) +
! 2228: letoh32(hdr->bootsz) + letoh32(hdr->ucodesz);
! 2229: if ((error = iwi_load_firmware(sc, fw, letoh32(hdr->mainsz))) != 0) {
! 2230: printf("%s: could not load main firmware\n",
! 2231: sc->sc_dev.dv_xname);
! 2232: goto fail2;
! 2233: }
! 2234:
! 2235: free(data, M_DEVBUF);
! 2236: sc->flags |= IWI_FLAG_FW_INITED;
! 2237:
! 2238: if ((error = iwi_config(sc)) != 0) {
! 2239: printf("%s: device configuration failed\n",
! 2240: sc->sc_dev.dv_xname);
! 2241: goto fail1;
! 2242: }
! 2243:
! 2244: ifp->if_flags &= ~IFF_OACTIVE;
! 2245: ifp->if_flags |= IFF_RUNNING;
! 2246:
! 2247: if (ic->ic_opmode != IEEE80211_M_MONITOR)
! 2248: ieee80211_begin_scan(ifp);
! 2249: else
! 2250: ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
! 2251:
! 2252: return 0;
! 2253:
! 2254: fail2: free(data, M_DEVBUF);
! 2255: fail1: iwi_stop(ifp, 0);
! 2256: return error;
! 2257: }
! 2258:
! 2259: void
! 2260: iwi_stop(struct ifnet *ifp, int disable)
! 2261: {
! 2262: struct iwi_softc *sc = ifp->if_softc;
! 2263: struct ieee80211com *ic = &sc->sc_ic;
! 2264: int i;
! 2265:
! 2266: sc->sc_tx_timer = 0;
! 2267: ifp->if_timer = 0;
! 2268: ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
! 2269:
! 2270: ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
! 2271:
! 2272: iwi_stop_master(sc);
! 2273:
! 2274: CSR_WRITE_4(sc, IWI_CSR_RST, IWI_RST_SW_RESET);
! 2275:
! 2276: /* reset rings */
! 2277: iwi_reset_cmd_ring(sc, &sc->cmdq);
! 2278: for (i = 0; i < 4; i++)
! 2279: iwi_reset_tx_ring(sc, &sc->txq[i]);
! 2280: iwi_reset_rx_ring(sc, &sc->rxq);
! 2281: }
! 2282:
! 2283: struct cfdriver iwi_cd = {
! 2284: NULL, "iwi", DV_IFNET
! 2285: };
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_iwi.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci