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