sys/dev/wpi/if_wpi.c

   1 /*-
   2  * Copyright (c) 2006,2007
   3  *      Damien Bergamini <damien.bergamini@free.fr>
   4  *      Benjamin Close <Benjamin.Close@clearchain.com>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include <sys/cdefs.h>
  20 __FBSDID("$FreeBSD$");
  21
  22 /*
  23  * Driver for Intel PRO/Wireless 3945ABG 802.11 network adapters.
  24  *
  25  * The 3945ABG network adapter doesn't use traditional hardware as
  26  * many other adaptors do. Instead at run time the eeprom is set into a known
  27  * state and told to load boot firmware. The boot firmware loads an init and a
  28  * main  binary firmware image into SRAM on the card via DMA.
  29  * Once the firmware is loaded, the driver/hw then
  30  * communicate by way of circular dma rings via the SRAM to the firmware.
  31  *
  32  * There is 6 memory rings. 1 command ring, 1 rx data ring & 4 tx data rings.
  33  * The 4 tx data rings allow for prioritization QoS.
  34  *
  35  * The rx data ring consists of 32 dma buffers. Two registers are used to
  36  * indicate where in the ring the driver and the firmware are up to. The
  37  * driver sets the initial read index (reg1) and the initial write index (reg2),
  38  * the firmware updates the read index (reg1) on rx of a packet and fires an
  39  * interrupt. The driver then processes the buffers starting at reg1 indicating
  40  * to the firmware which buffers have been accessed by updating reg2. At the
  41  * same time allocating new memory for the processed buffer.
  42  *
  43  * A similar thing happens with the tx rings. The difference is the firmware
  44  * stop processing buffers once the queue is full and until confirmation
  45  * of a successful transmition (tx_done) has occurred.
  46  *
  47  * The command ring operates in the same manner as the tx queues.
  48  *
  49  * All communication direct to the card (ie eeprom) is classed as Stage1
  50  * communication
  51  *
  52  * All communication via the firmware to the card is classed as State2.
  53  * The firmware consists of 2 parts. A bootstrap firmware and a runtime
  54  * firmware. The bootstrap firmware and runtime firmware are loaded
  55  * from host memory via dma to the card then told to execute. From this point
  56  * on the majority of communications between the driver and the card goes
  57  * via the firmware.
  58  */
  59
  60 #include "opt_wlan.h"
  61 #include "opt_wpi.h"
  62
  63 #include <sys/param.h>
  64 #include <sys/sysctl.h>
  65 #include <sys/sockio.h>
  66 #include <sys/mbuf.h>
  67 #include <sys/kernel.h>
  68 #include <sys/socket.h>
  69 #include <sys/systm.h>
  70 #include <sys/malloc.h>
  71 #include <sys/queue.h>
  72 #include <sys/taskqueue.h>
  73 #include <sys/module.h>
  74 #include <sys/bus.h>
  75 #include <sys/endian.h>
  76 #include <sys/linker.h>
  77 #include <sys/firmware.h>
  78
  79 #include <machine/bus.h>
  80 #include <machine/resource.h>
  81 #include <sys/rman.h>
  82
  83 #include <dev/pci/pcireg.h>
  84 #include <dev/pci/pcivar.h>
  85
  86 #include <net/bpf.h>
  87 #include <net/if.h>
  88 #include <net/if_var.h>
  89 #include <net/if_arp.h>
  90 #include <net/ethernet.h>
  91 #include <net/if_dl.h>
  92 #include <net/if_media.h>
  93 #include <net/if_types.h>
  94
  95 #include <netinet/in.h>
  96 #include <netinet/in_systm.h>
  97 #include <netinet/in_var.h>
  98 #include <netinet/if_ether.h>
  99 #include <netinet/ip.h>
 100
 101 #include <net80211/ieee80211_var.h>
 102 #include <net80211/ieee80211_radiotap.h>
 103 #include <net80211/ieee80211_regdomain.h>
 104 #include <net80211/ieee80211_ratectl.h>
 105
 106 #include <dev/wpi/if_wpireg.h>
 107 #include <dev/wpi/if_wpivar.h>
 108 #include <dev/wpi/if_wpi_debug.h>
 109
 110 struct wpi_ident {
 111         uint16_t        vendor;
 112         uint16_t        device;
 113         uint16_t        subdevice;
 114         const char      *name;
 115 };
 116
 117 static const struct wpi_ident wpi_ident_table[] = {
 118         /* The below entries support ABG regardless of the subid */
 119         { 0x8086, 0x4222,    0x0, "Intel(R) PRO/Wireless 3945ABG" },
 120         { 0x8086, 0x4227,    0x0, "Intel(R) PRO/Wireless 3945ABG" },
 121         /* The below entries only support BG */
 122         { 0x8086, 0x4222, 0x1005, "Intel(R) PRO/Wireless 3945BG"  },
 123         { 0x8086, 0x4222, 0x1034, "Intel(R) PRO/Wireless 3945BG"  },
 124         { 0x8086, 0x4227, 0x1014, "Intel(R) PRO/Wireless 3945BG"  },
 125         { 0x8086, 0x4222, 0x1044, "Intel(R) PRO/Wireless 3945BG"  },
 126         { 0, 0, 0, NULL }
 127 };
 128
 129 static int      wpi_probe(device_t);
 130 static int      wpi_attach(device_t);
 131 static void     wpi_radiotap_attach(struct wpi_softc *);
 132 static void     wpi_sysctlattach(struct wpi_softc *);
 133 static void     wpi_init_beacon(struct wpi_vap *);
 134 static struct ieee80211vap *wpi_vap_create(struct ieee80211com *,
 135                     const char [IFNAMSIZ], int, enum ieee80211_opmode, int,
 136                     const uint8_t [IEEE80211_ADDR_LEN],
 137                     const uint8_t [IEEE80211_ADDR_LEN]);
 138 static void     wpi_vap_delete(struct ieee80211vap *);
 139 static int      wpi_detach(device_t);
 140 static int      wpi_shutdown(device_t);
 141 static int      wpi_suspend(device_t);
 142 static int      wpi_resume(device_t);
 143 static int      wpi_nic_lock(struct wpi_softc *);
 144 static int      wpi_read_prom_data(struct wpi_softc *, uint32_t, void *, int);
 145 static void     wpi_dma_map_addr(void *, bus_dma_segment_t *, int, int);
 146 static int      wpi_dma_contig_alloc(struct wpi_softc *, struct wpi_dma_info *,
 147                     void **, bus_size_t, bus_size_t);
 148 static void     wpi_dma_contig_free(struct wpi_dma_info *);
 149 static int      wpi_alloc_shared(struct wpi_softc *);
 150 static void     wpi_free_shared(struct wpi_softc *);
 151 static int      wpi_alloc_fwmem(struct wpi_softc *);
 152 static void     wpi_free_fwmem(struct wpi_softc *);
 153 static int      wpi_alloc_rx_ring(struct wpi_softc *);
 154 static void     wpi_update_rx_ring(struct wpi_softc *);
 155 static void     wpi_update_rx_ring_ps(struct wpi_softc *);
 156 static void     wpi_reset_rx_ring(struct wpi_softc *);
 157 static void     wpi_free_rx_ring(struct wpi_softc *);
 158 static int      wpi_alloc_tx_ring(struct wpi_softc *, struct wpi_tx_ring *,
 159                     int);
 160 static void     wpi_update_tx_ring(struct wpi_softc *, struct wpi_tx_ring *);
 161 static void     wpi_update_tx_ring_ps(struct wpi_softc *,
 162                     struct wpi_tx_ring *);
 163 static void     wpi_reset_tx_ring(struct wpi_softc *, struct wpi_tx_ring *);
 164 static void     wpi_free_tx_ring(struct wpi_softc *, struct wpi_tx_ring *);
 165 static int      wpi_read_eeprom(struct wpi_softc *,
 166                     uint8_t macaddr[IEEE80211_ADDR_LEN]);
 167 static uint32_t wpi_eeprom_channel_flags(struct wpi_eeprom_chan *);
 168 static void     wpi_read_eeprom_band(struct wpi_softc *, int);
 169 static int      wpi_read_eeprom_channels(struct wpi_softc *, int);
 170 static struct wpi_eeprom_chan *wpi_find_eeprom_channel(struct wpi_softc *,
 171                     struct ieee80211_channel *);
 172 static int      wpi_setregdomain(struct ieee80211com *,
 173                     struct ieee80211_regdomain *, int,
 174                     struct ieee80211_channel[]);
 175 static int      wpi_read_eeprom_group(struct wpi_softc *, int);
 176 static int      wpi_add_node_entry_adhoc(struct wpi_softc *);
 177 static struct ieee80211_node *wpi_node_alloc(struct ieee80211vap *,
 178                     const uint8_t mac[IEEE80211_ADDR_LEN]);
 179 static void     wpi_node_free(struct ieee80211_node *);
 180 static void     wpi_recv_mgmt(struct ieee80211_node *, struct mbuf *, int, int,
 181                     int);
 182 static void     wpi_restore_node(void *, struct ieee80211_node *);
 183 static void     wpi_restore_node_table(struct wpi_softc *, struct wpi_vap *);
 184 static int      wpi_newstate(struct ieee80211vap *, enum ieee80211_state, int);
 185 static void     wpi_calib_timeout(void *);
 186 static void     wpi_rx_done(struct wpi_softc *, struct wpi_rx_desc *,
 187                     struct wpi_rx_data *);
 188 static void     wpi_rx_statistics(struct wpi_softc *, struct wpi_rx_desc *,
 189                     struct wpi_rx_data *);
 190 static void     wpi_tx_done(struct wpi_softc *, struct wpi_rx_desc *);
 191 static void     wpi_cmd_done(struct wpi_softc *, struct wpi_rx_desc *);
 192 static void     wpi_notif_intr(struct wpi_softc *);
 193 static void     wpi_wakeup_intr(struct wpi_softc *);
 194 #ifdef WPI_DEBUG
 195 static void     wpi_debug_registers(struct wpi_softc *);
 196 #endif
 197 static void     wpi_fatal_intr(struct wpi_softc *);
 198 static void     wpi_intr(void *);
 199 static int      wpi_cmd2(struct wpi_softc *, struct wpi_buf *);
 200 static int      wpi_tx_data(struct wpi_softc *, struct mbuf *,
 201                     struct ieee80211_node *);
 202 static int      wpi_tx_data_raw(struct wpi_softc *, struct mbuf *,
 203                     struct ieee80211_node *,
 204                     const struct ieee80211_bpf_params *);
 205 static int      wpi_raw_xmit(struct ieee80211_node *, struct mbuf *,
 206                     const struct ieee80211_bpf_params *);
 207 static void     wpi_start(struct ifnet *);
 208 static void     wpi_start_task(void *, int);
 209 static void     wpi_watchdog_rfkill(void *);
 210 static void     wpi_scan_timeout(void *);
 211 static void     wpi_tx_timeout(void *);
 212 static int      wpi_ioctl(struct ifnet *, u_long, caddr_t);
 213 static int      wpi_cmd(struct wpi_softc *, int, const void *, size_t, int);
 214 static int      wpi_mrr_setup(struct wpi_softc *);
 215 static int      wpi_add_node(struct wpi_softc *, struct ieee80211_node *);
 216 static int      wpi_add_broadcast_node(struct wpi_softc *, int);
 217 static int      wpi_add_ibss_node(struct wpi_softc *, struct ieee80211_node *);
 218 static void     wpi_del_node(struct wpi_softc *, struct ieee80211_node *);
 219 static int      wpi_updateedca(struct ieee80211com *);
 220 static void     wpi_set_promisc(struct wpi_softc *);
 221 static void     wpi_update_promisc(struct ifnet *);
 222 static void     wpi_update_mcast(struct ifnet *);
 223 static void     wpi_set_led(struct wpi_softc *, uint8_t, uint8_t, uint8_t);
 224 static int      wpi_set_timing(struct wpi_softc *, struct ieee80211_node *);
 225 static void     wpi_power_calibration(struct wpi_softc *);
 226 static int      wpi_set_txpower(struct wpi_softc *, int);
 227 static int      wpi_get_power_index(struct wpi_softc *,
 228                     struct wpi_power_group *, uint8_t, int, int);
 229 static int      wpi_set_pslevel(struct wpi_softc *, uint8_t, int, int);
 230 static int      wpi_send_btcoex(struct wpi_softc *);
 231 static int      wpi_send_rxon(struct wpi_softc *, int, int);
 232 static int      wpi_config(struct wpi_softc *);
 233 static uint16_t wpi_get_active_dwell_time(struct wpi_softc *,
 234                     struct ieee80211_channel *, uint8_t);
 235 static uint16_t wpi_limit_dwell(struct wpi_softc *, uint16_t);
 236 static uint16_t wpi_get_passive_dwell_time(struct wpi_softc *,
 237                     struct ieee80211_channel *);
 238 static uint32_t wpi_get_scan_pause_time(uint32_t, uint16_t);
 239 static int      wpi_scan(struct wpi_softc *, struct ieee80211_channel *);
 240 static int      wpi_auth(struct wpi_softc *, struct ieee80211vap *);
 241 static int      wpi_config_beacon(struct wpi_vap *);
 242 static int      wpi_setup_beacon(struct wpi_softc *, struct ieee80211_node *);
 243 static void     wpi_update_beacon(struct ieee80211vap *, int);
 244 static void     wpi_newassoc(struct ieee80211_node *, int);
 245 static int      wpi_run(struct wpi_softc *, struct ieee80211vap *);
 246 static int      wpi_load_key(struct ieee80211_node *,
 247                     const struct ieee80211_key *);
 248 static void     wpi_load_key_cb(void *, struct ieee80211_node *);
 249 static int      wpi_set_global_keys(struct ieee80211_node *);
 250 static int      wpi_del_key(struct ieee80211_node *,
 251                     const struct ieee80211_key *);
 252 static void     wpi_del_key_cb(void *, struct ieee80211_node *);
 253 static int      wpi_process_key(struct ieee80211vap *,
 254                     const struct ieee80211_key *, int);
 255 static int      wpi_key_set(struct ieee80211vap *,
 256                     const struct ieee80211_key *,
 257                     const uint8_t mac[IEEE80211_ADDR_LEN]);
 258 static int      wpi_key_delete(struct ieee80211vap *,
 259                     const struct ieee80211_key *);
 260 static int      wpi_post_alive(struct wpi_softc *);
 261 static int      wpi_load_bootcode(struct wpi_softc *, const uint8_t *, int);
 262 static int      wpi_load_firmware(struct wpi_softc *);
 263 static int      wpi_read_firmware(struct wpi_softc *);
 264 static void     wpi_unload_firmware(struct wpi_softc *);
 265 static int      wpi_clock_wait(struct wpi_softc *);
 266 static int      wpi_apm_init(struct wpi_softc *);
 267 static void     wpi_apm_stop_master(struct wpi_softc *);
 268 static void     wpi_apm_stop(struct wpi_softc *);
 269 static void     wpi_nic_config(struct wpi_softc *);
 270 static int      wpi_hw_init(struct wpi_softc *);
 271 static void     wpi_hw_stop(struct wpi_softc *);
 272 static void     wpi_radio_on(void *, int);
 273 static void     wpi_radio_off(void *, int);
 274 static void     wpi_init(void *);
 275 static void     wpi_stop_locked(struct wpi_softc *);
 276 static void     wpi_stop(struct wpi_softc *);
 277 static void     wpi_scan_start(struct ieee80211com *);
 278 static void     wpi_scan_end(struct ieee80211com *);
 279 static void     wpi_set_channel(struct ieee80211com *);
 280 static void     wpi_scan_curchan(struct ieee80211_scan_state *, unsigned long);
 281 static void     wpi_scan_mindwell(struct ieee80211_scan_state *);
 282 static void     wpi_hw_reset(void *, int);
 283
 284 static device_method_t wpi_methods[] = {
 285         /* Device interface */
 286         DEVMETHOD(device_probe,         wpi_probe),
 287         DEVMETHOD(device_attach,        wpi_attach),
 288         DEVMETHOD(device_detach,        wpi_detach),
 289         DEVMETHOD(device_shutdown,      wpi_shutdown),
 290         DEVMETHOD(device_suspend,       wpi_suspend),
 291         DEVMETHOD(device_resume,        wpi_resume),
 292
 293         DEVMETHOD_END
 294 };
 295
 296 static driver_t wpi_driver = {
 297         "wpi",
 298         wpi_methods,
 299         sizeof (struct wpi_softc)
 300 };
 301 static devclass_t wpi_devclass;
 302
 303 DRIVER_MODULE(wpi, pci, wpi_driver, wpi_devclass, NULL, NULL);
 304
 305 MODULE_VERSION(wpi, 1);
 306
 307 MODULE_DEPEND(wpi, pci,  1, 1, 1);
 308 MODULE_DEPEND(wpi, wlan, 1, 1, 1);
 309 MODULE_DEPEND(wpi, firmware, 1, 1, 1);
 310
 311 static int
 312 wpi_probe(device_t dev)
 313 {
 314         const struct wpi_ident *ident;
 315
 316         for (ident = wpi_ident_table; ident->name != NULL; ident++) {
 317                 if (pci_get_vendor(dev) == ident->vendor &&
 318                     pci_get_device(dev) == ident->device) {
 319                         device_set_desc(dev, ident->name);
 320                         return (BUS_PROBE_DEFAULT);
 321                 }
 322         }
 323         return ENXIO;
 324 }
 325
 326 static int
 327 wpi_attach(device_t dev)
 328 {
 329         struct wpi_softc *sc = (struct wpi_softc *)device_get_softc(dev);
 330         struct ieee80211com *ic;
 331         struct ifnet *ifp;
 332         int i, error, rid;
 333 #ifdef WPI_DEBUG
 334         int supportsa = 1;
 335         const struct wpi_ident *ident;
 336 #endif
 337         uint8_t macaddr[IEEE80211_ADDR_LEN];
 338
 339         sc->sc_dev = dev;
 340
 341 #ifdef WPI_DEBUG
 342         error = resource_int_value(device_get_name(sc->sc_dev),
 343             device_get_unit(sc->sc_dev), "debug", &(sc->sc_debug));
 344         if (error != 0)
 345                 sc->sc_debug = 0;
 346 #else
 347         sc->sc_debug = 0;
 348 #endif
 349
 350         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
 351
 352         /*
 353          * Get the offset of the PCI Express Capability Structure in PCI
 354          * Configuration Space.
 355          */
 356         error = pci_find_cap(dev, PCIY_EXPRESS, &sc->sc_cap_off);
 357         if (error != 0) {
 358                 device_printf(dev, "PCIe capability structure not found!\n");
 359                 return error;
 360         }
 361
 362         /*
 363          * Some card's only support 802.11b/g not a, check to see if
 364          * this is one such card. A 0x0 in the subdevice table indicates
 365          * the entire subdevice range is to be ignored.
 366          */
 367 #ifdef WPI_DEBUG
 368         for (ident = wpi_ident_table; ident->name != NULL; ident++) {
 369                 if (ident->subdevice &&
 370                     pci_get_subdevice(dev) == ident->subdevice) {
 371                     supportsa = 0;
 372                     break;
 373                 }
 374         }
 375 #endif
 376
 377         /* Clear device-specific "PCI retry timeout" register (41h). */
 378         pci_write_config(dev, 0x41, 0, 1);
 379
 380         /* Enable bus-mastering. */
 381         pci_enable_busmaster(dev);
 382
 383         rid = PCIR_BAR(0);
 384         sc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
 385             RF_ACTIVE);
 386         if (sc->mem == NULL) {
 387                 device_printf(dev, "can't map mem space\n");
 388                 return ENOMEM;
 389         }
 390         sc->sc_st = rman_get_bustag(sc->mem);
 391         sc->sc_sh = rman_get_bushandle(sc->mem);
 392
 393         i = 1;
 394         rid = 0;
 395         if (pci_alloc_msi(dev, &i) == 0)
 396                 rid = 1;
 397         /* Install interrupt handler. */
 398         sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE |
 399             (rid != 0 ? 0 : RF_SHAREABLE));
 400         if (sc->irq == NULL) {
 401                 device_printf(dev, "can't map interrupt\n");
 402                 error = ENOMEM;
 403                 goto fail;
 404         }
 405
 406         WPI_LOCK_INIT(sc);
 407         WPI_TX_LOCK_INIT(sc);
 408         WPI_RXON_LOCK_INIT(sc);
 409         WPI_NT_LOCK_INIT(sc);
 410         WPI_TXQ_LOCK_INIT(sc);
 411         WPI_TXQ_STATE_LOCK_INIT(sc);
 412
 413         /* Allocate DMA memory for firmware transfers. */
 414         if ((error = wpi_alloc_fwmem(sc)) != 0) {
 415                 device_printf(dev,
 416                     "could not allocate memory for firmware, error %d\n",
 417                     error);
 418                 goto fail;
 419         }
 420
 421         /* Allocate shared page. */
 422         if ((error = wpi_alloc_shared(sc)) != 0) {
 423                 device_printf(dev, "could not allocate shared page\n");
 424                 goto fail;
 425         }
 426
 427         /* Allocate TX rings - 4 for QoS purposes, 1 for commands. */
 428         for (i = 0; i < WPI_NTXQUEUES; i++) {
 429                 if ((error = wpi_alloc_tx_ring(sc, &sc->txq[i], i)) != 0) {
 430                         device_printf(dev,
 431                             "could not allocate TX ring %d, error %d\n", i,
 432                             error);
 433                         goto fail;
 434                 }
 435         }
 436
 437         /* Allocate RX ring. */
 438         if ((error = wpi_alloc_rx_ring(sc)) != 0) {
 439                 device_printf(dev, "could not allocate RX ring, error %d\n",
 440                     error);
 441                 goto fail;
 442         }
 443
 444         /* Clear pending interrupts. */
 445         WPI_WRITE(sc, WPI_INT, 0xffffffff);
 446
 447         ifp = sc->sc_ifp = if_alloc(IFT_IEEE80211);
 448         if (ifp == NULL) {
 449                 device_printf(dev, "can not allocate ifnet structure\n");
 450                 goto fail;
 451         }
 452
 453         ic = ifp->if_l2com;
 454         ic->ic_ifp = ifp;
 455         ic->ic_phytype = IEEE80211_T_OFDM;      /* not only, but not used */
 456         ic->ic_opmode = IEEE80211_M_STA;        /* default to BSS mode */
 457
 458         /* Set device capabilities. */
 459         ic->ic_caps =
 460                   IEEE80211_C_STA               /* station mode supported */
 461                 | IEEE80211_C_IBSS              /* IBSS mode supported */
 462                 | IEEE80211_C_HOSTAP            /* Host access point mode */
 463                 | IEEE80211_C_MONITOR           /* monitor mode supported */
 464                 | IEEE80211_C_AHDEMO            /* adhoc demo mode */
 465                 | IEEE80211_C_BGSCAN            /* capable of bg scanning */
 466                 | IEEE80211_C_TXPMGT            /* tx power management */
 467                 | IEEE80211_C_SHSLOT            /* short slot time supported */
 468                 | IEEE80211_C_WPA               /* 802.11i */
 469                 | IEEE80211_C_SHPREAMBLE        /* short preamble supported */
 470                 | IEEE80211_C_WME               /* 802.11e */
 471                 | IEEE80211_C_PMGT              /* Station-side power mgmt */
 472                 ;
 473
 474         ic->ic_cryptocaps =
 475                   IEEE80211_CRYPTO_AES_CCM;
 476
 477         /*
 478          * Read in the eeprom and also setup the channels for
 479          * net80211. We don't set the rates as net80211 does this for us
 480          */
 481         if ((error = wpi_read_eeprom(sc, macaddr)) != 0) {
 482                 device_printf(dev, "could not read EEPROM, error %d\n",
 483                     error);
 484                 goto fail;
 485         }
 486
 487 #ifdef WPI_DEBUG
 488         if (bootverbose) {
 489                 device_printf(sc->sc_dev, "Regulatory Domain: %.4s\n",
 490                     sc->domain);
 491                 device_printf(sc->sc_dev, "Hardware Type: %c\n",
 492                     sc->type > 1 ? 'B': '?');
 493                 device_printf(sc->sc_dev, "Hardware Revision: %c\n",
 494                     ((sc->rev & 0xf0) == 0xd0) ? 'D': '?');
 495                 device_printf(sc->sc_dev, "SKU %s support 802.11a\n",
 496                     supportsa ? "does" : "does not");
 497
 498                 /* XXX hw_config uses the PCIDEV for the Hardware rev. Must
 499                    check what sc->rev really represents - benjsc 20070615 */
 500         }
 501 #endif
 502
 503         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
 504         ifp->if_softc = sc;
 505         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 506         ifp->if_init = wpi_init;
 507         ifp->if_ioctl = wpi_ioctl;
 508         ifp->if_start = wpi_start;
 509         IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
 510         ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
 511         IFQ_SET_READY(&ifp->if_snd);
 512
 513         ieee80211_ifattach(ic, macaddr);
 514         ic->ic_vap_create = wpi_vap_create;
 515         ic->ic_vap_delete = wpi_vap_delete;
 516         ic->ic_raw_xmit = wpi_raw_xmit;
 517         ic->ic_node_alloc = wpi_node_alloc;
 518         sc->sc_node_free = ic->ic_node_free;
 519         ic->ic_node_free = wpi_node_free;
 520         ic->ic_wme.wme_update = wpi_updateedca;
 521         ic->ic_update_promisc = wpi_update_promisc;
 522         ic->ic_update_mcast = wpi_update_mcast;
 523         ic->ic_newassoc = wpi_newassoc;
 524         ic->ic_scan_start = wpi_scan_start;
 525         ic->ic_scan_end = wpi_scan_end;
 526         ic->ic_set_channel = wpi_set_channel;
 527         ic->ic_scan_curchan = wpi_scan_curchan;
 528         ic->ic_scan_mindwell = wpi_scan_mindwell;
 529         ic->ic_setregdomain = wpi_setregdomain;
 530
 531         sc->sc_update_rx_ring = wpi_update_rx_ring;
 532         sc->sc_update_tx_ring = wpi_update_tx_ring;
 533
 534         wpi_radiotap_attach(sc);
 535
 536         callout_init_mtx(&sc->calib_to, &sc->rxon_mtx, 0);
 537         callout_init_mtx(&sc->scan_timeout, &sc->rxon_mtx, 0);
 538         callout_init_mtx(&sc->tx_timeout, &sc->txq_state_mtx, 0);
 539         callout_init_mtx(&sc->watchdog_rfkill, &sc->sc_mtx, 0);
 540         TASK_INIT(&sc->sc_reinittask, 0, wpi_hw_reset, sc);
 541         TASK_INIT(&sc->sc_radiooff_task, 0, wpi_radio_off, sc);
 542         TASK_INIT(&sc->sc_radioon_task, 0, wpi_radio_on, sc);
 543         TASK_INIT(&sc->sc_start_task, 0, wpi_start_task, sc);
 544
 545         sc->sc_tq = taskqueue_create("wpi_taskq", M_WAITOK,
 546             taskqueue_thread_enqueue, &sc->sc_tq);
 547         error = taskqueue_start_threads(&sc->sc_tq, 1, 0, "wpi_taskq");
 548         if (error != 0) {
 549                 device_printf(dev, "can't start threads, error %d\n", error);
 550                 goto fail;
 551         }
 552
 553         wpi_sysctlattach(sc);
 554
 555         /*
 556          * Hook our interrupt after all initialization is complete.
 557          */
 558         error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET | INTR_MPSAFE,
 559             NULL, wpi_intr, sc, &sc->sc_ih);
 560         if (error != 0) {
 561                 device_printf(dev, "can't establish interrupt, error %d\n",
 562                     error);
 563                 goto fail;
 564         }
 565
 566         if (bootverbose)
 567                 ieee80211_announce(ic);
 568
 569 #ifdef WPI_DEBUG
 570         if (sc->sc_debug & WPI_DEBUG_HW)
 571                 ieee80211_announce_channels(ic);
 572 #endif
 573
 574         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
 575         return 0;
 576
 577 fail:   wpi_detach(dev);
 578         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__);
 579         return error;
 580 }
 581
 582 /*
 583  * Attach the interface to 802.11 radiotap.
 584  */
 585 static void
 586 wpi_radiotap_attach(struct wpi_softc *sc)
 587 {
 588         struct ifnet *ifp = sc->sc_ifp;
 589         struct ieee80211com *ic = ifp->if_l2com;
 590         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
 591         ieee80211_radiotap_attach(ic,
 592             &sc->sc_txtap.wt_ihdr, sizeof(sc->sc_txtap),
 593                 WPI_TX_RADIOTAP_PRESENT,
 594             &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap),
 595                 WPI_RX_RADIOTAP_PRESENT);
 596         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
 597 }
 598
 599 static void
 600 wpi_sysctlattach(struct wpi_softc *sc)
 601 {
 602 #ifdef WPI_DEBUG
 603         struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev);
 604         struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
 605
 606         SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
 607             "debug", CTLFLAG_RW, &sc->sc_debug, sc->sc_debug,
 608                 "control debugging printfs");
 609 #endif
 610 }
 611
 612 static void
 613 wpi_init_beacon(struct wpi_vap *wvp)
 614 {
 615         struct wpi_buf *bcn = &wvp->wv_bcbuf;
 616         struct wpi_cmd_beacon *cmd = (struct wpi_cmd_beacon *)&bcn->data;
 617
 618         cmd->id = WPI_ID_BROADCAST;
 619         cmd->ofdm_mask = 0xff;
 620         cmd->cck_mask = 0x0f;
 621         cmd->lifetime = htole32(WPI_LIFETIME_INFINITE);
 622
 623         /*
 624          * XXX WPI_TX_AUTO_SEQ seems to be ignored - workaround this issue
 625          * XXX by using WPI_TX_NEED_ACK instead (with some side effects).
 626          */
 627         cmd->flags = htole32(WPI_TX_NEED_ACK | WPI_TX_INSERT_TSTAMP);
 628
 629         bcn->code = WPI_CMD_SET_BEACON;
 630         bcn->ac = WPI_CMD_QUEUE_NUM;
 631         bcn->size = sizeof(struct wpi_cmd_beacon);
 632 }
 633
 634 static struct ieee80211vap *
 635 wpi_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit,
 636     enum ieee80211_opmode opmode, int flags,
 637     const uint8_t bssid[IEEE80211_ADDR_LEN],
 638     const uint8_t mac[IEEE80211_ADDR_LEN])
 639 {
 640         struct wpi_vap *wvp;
 641         struct ieee80211vap *vap;
 642
 643         if (!TAILQ_EMPTY(&ic->ic_vaps))         /* only one at a time */
 644                 return NULL;
 645
 646         wvp = (struct wpi_vap *) malloc(sizeof(struct wpi_vap),
 647             M_80211_VAP, M_NOWAIT | M_ZERO);
 648         if (wvp == NULL)
 649                 return NULL;
 650         vap = &wvp->wv_vap;
 651         ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid, mac);
 652
 653         if (opmode == IEEE80211_M_IBSS || opmode == IEEE80211_M_HOSTAP) {
 654                 WPI_VAP_LOCK_INIT(wvp);
 655                 wpi_init_beacon(wvp);
 656         }
 657
 658         /* Override with driver methods. */
 659         vap->iv_key_set = wpi_key_set;
 660         vap->iv_key_delete = wpi_key_delete;
 661         wvp->wv_recv_mgmt = vap->iv_recv_mgmt;
 662         vap->iv_recv_mgmt = wpi_recv_mgmt;
 663         wvp->wv_newstate = vap->iv_newstate;
 664         vap->iv_newstate = wpi_newstate;
 665         vap->iv_update_beacon = wpi_update_beacon;
 666         vap->iv_max_aid = WPI_ID_IBSS_MAX - WPI_ID_IBSS_MIN + 1;
 667
 668         ieee80211_ratectl_init(vap);
 669         /* Complete setup. */
 670         ieee80211_vap_attach(vap, ieee80211_media_change,
 671             ieee80211_media_status);
 672         ic->ic_opmode = opmode;
 673         return vap;
 674 }
 675
 676 static void
 677 wpi_vap_delete(struct ieee80211vap *vap)
 678 {
 679         struct wpi_vap *wvp = WPI_VAP(vap);
 680         struct wpi_buf *bcn = &wvp->wv_bcbuf;
 681         enum ieee80211_opmode opmode = vap->iv_opmode;
 682
 683         ieee80211_ratectl_deinit(vap);
 684         ieee80211_vap_detach(vap);
 685
 686         if (opmode == IEEE80211_M_IBSS || opmode == IEEE80211_M_HOSTAP) {
 687                 if (bcn->m != NULL)
 688                         m_freem(bcn->m);
 689
 690                 WPI_VAP_LOCK_DESTROY(wvp);
 691         }
 692
 693         free(wvp, M_80211_VAP);
 694 }
 695
 696 static int
 697 wpi_detach(device_t dev)
 698 {
 699         struct wpi_softc *sc = device_get_softc(dev);
 700         struct ifnet *ifp = sc->sc_ifp;
 701         struct ieee80211com *ic;
 702         int qid;
 703
 704         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
 705
 706         if (ifp != NULL) {
 707                 ic = ifp->if_l2com;
 708
 709                 ieee80211_draintask(ic, &sc->sc_radioon_task);
 710                 ieee80211_draintask(ic, &sc->sc_start_task);
 711
 712                 wpi_stop(sc);
 713
 714                 taskqueue_drain_all(sc->sc_tq);
 715                 taskqueue_free(sc->sc_tq);
 716
 717                 callout_drain(&sc->watchdog_rfkill);
 718                 callout_drain(&sc->tx_timeout);
 719                 callout_drain(&sc->scan_timeout);
 720                 callout_drain(&sc->calib_to);
 721                 ieee80211_ifdetach(ic);
 722         }
 723
 724         /* Uninstall interrupt handler. */
 725         if (sc->irq != NULL) {
 726                 bus_teardown_intr(dev, sc->irq, sc->sc_ih);
 727                 bus_release_resource(dev, SYS_RES_IRQ, rman_get_rid(sc->irq),
 728                     sc->irq);
 729                 pci_release_msi(dev);
 730         }
 731
 732         if (sc->txq[0].data_dmat) {
 733                 /* Free DMA resources. */
 734                 for (qid = 0; qid < WPI_NTXQUEUES; qid++)
 735                         wpi_free_tx_ring(sc, &sc->txq[qid]);
 736
 737                 wpi_free_rx_ring(sc);
 738                 wpi_free_shared(sc);
 739         }
 740
 741         if (sc->fw_dma.tag)
 742                 wpi_free_fwmem(sc);
 743
 744         if (sc->mem != NULL)
 745                 bus_release_resource(dev, SYS_RES_MEMORY,
 746                     rman_get_rid(sc->mem), sc->mem);
 747
 748         if (ifp != NULL)
 749                 if_free(ifp);
 750
 751         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
 752         WPI_TXQ_STATE_LOCK_DESTROY(sc);
 753         WPI_TXQ_LOCK_DESTROY(sc);
 754         WPI_NT_LOCK_DESTROY(sc);
 755         WPI_RXON_LOCK_DESTROY(sc);
 756         WPI_TX_LOCK_DESTROY(sc);
 757         WPI_LOCK_DESTROY(sc);
 758         return 0;
 759 }
 760
 761 static int
 762 wpi_shutdown(device_t dev)
 763 {
 764         struct wpi_softc *sc = device_get_softc(dev);
 765
 766         wpi_stop(sc);
 767         return 0;
 768 }
 769
 770 static int
 771 wpi_suspend(device_t dev)
 772 {
 773         struct wpi_softc *sc = device_get_softc(dev);
 774         struct ieee80211com *ic = sc->sc_ifp->if_l2com;
 775
 776         ieee80211_suspend_all(ic);
 777         return 0;
 778 }
 779
 780 static int
 781 wpi_resume(device_t dev)
 782 {
 783         struct wpi_softc *sc = device_get_softc(dev);
 784         struct ieee80211com *ic = sc->sc_ifp->if_l2com;
 785
 786         /* Clear device-specific "PCI retry timeout" register (41h). */
 787         pci_write_config(dev, 0x41, 0, 1);
 788
 789         ieee80211_resume_all(ic);
 790         return 0;
 791 }
 792
 793 /*
 794  * Grab exclusive access to NIC memory.
 795  */
 796 static int
 797 wpi_nic_lock(struct wpi_softc *sc)
 798 {
 799         int ntries;
 800
 801         /* Request exclusive access to NIC. */
 802         WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ);
 803
 804         /* Spin until we actually get the lock. */
 805         for (ntries = 0; ntries < 1000; ntries++) {
 806                 if ((WPI_READ(sc, WPI_GP_CNTRL) &
 807                     (WPI_GP_CNTRL_MAC_ACCESS_ENA | WPI_GP_CNTRL_SLEEP)) ==
 808                     WPI_GP_CNTRL_MAC_ACCESS_ENA)
 809                         return 0;
 810                 DELAY(10);
 811         }
 812
 813         device_printf(sc->sc_dev, "could not lock memory\n");
 814
 815         return ETIMEDOUT;
 816 }
 817
 818 /*
 819  * Release lock on NIC memory.
 820  */
 821 static __inline void
 822 wpi_nic_unlock(struct wpi_softc *sc)
 823 {
 824         WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ);
 825 }
 826
 827 static __inline uint32_t
 828 wpi_prph_read(struct wpi_softc *sc, uint32_t addr)
 829 {
 830         WPI_WRITE(sc, WPI_PRPH_RADDR, WPI_PRPH_DWORD | addr);
 831         WPI_BARRIER_READ_WRITE(sc);
 832         return WPI_READ(sc, WPI_PRPH_RDATA);
 833 }
 834
 835 static __inline void
 836 wpi_prph_write(struct wpi_softc *sc, uint32_t addr, uint32_t data)
 837 {
 838         WPI_WRITE(sc, WPI_PRPH_WADDR, WPI_PRPH_DWORD | addr);
 839         WPI_BARRIER_WRITE(sc);
 840         WPI_WRITE(sc, WPI_PRPH_WDATA, data);
 841 }
 842
 843 static __inline void
 844 wpi_prph_setbits(struct wpi_softc *sc, uint32_t addr, uint32_t mask)
 845 {
 846         wpi_prph_write(sc, addr, wpi_prph_read(sc, addr) | mask);
 847 }
 848
 849 static __inline void
 850 wpi_prph_clrbits(struct wpi_softc *sc, uint32_t addr, uint32_t mask)
 851 {
 852         wpi_prph_write(sc, addr, wpi_prph_read(sc, addr) & ~mask);
 853 }
 854
 855 static __inline void
 856 wpi_prph_write_region_4(struct wpi_softc *sc, uint32_t addr,
 857     const uint32_t *data, int count)
 858 {
 859         for (; count > 0; count--, data++, addr += 4)
 860                 wpi_prph_write(sc, addr, *data);
 861 }
 862
 863 static __inline uint32_t
 864 wpi_mem_read(struct wpi_softc *sc, uint32_t addr)
 865 {
 866         WPI_WRITE(sc, WPI_MEM_RADDR, addr);
 867         WPI_BARRIER_READ_WRITE(sc);
 868         return WPI_READ(sc, WPI_MEM_RDATA);
 869 }
 870
 871 static __inline void
 872 wpi_mem_read_region_4(struct wpi_softc *sc, uint32_t addr, uint32_t *data,
 873     int count)
 874 {
 875         for (; count > 0; count--, addr += 4)
 876                 *data++ = wpi_mem_read(sc, addr);
 877 }
 878
 879 static int
 880 wpi_read_prom_data(struct wpi_softc *sc, uint32_t addr, void *data, int count)
 881 {
 882         uint8_t *out = data;
 883         uint32_t val;
 884         int error, ntries;
 885
 886         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
 887
 888         if ((error = wpi_nic_lock(sc)) != 0)
 889                 return error;
 890
 891         for (; count > 0; count -= 2, addr++) {
 892                 WPI_WRITE(sc, WPI_EEPROM, addr << 2);
 893                 for (ntries = 0; ntries < 10; ntries++) {
 894                         val = WPI_READ(sc, WPI_EEPROM);
 895                         if (val & WPI_EEPROM_READ_VALID)
 896                                 break;
 897                         DELAY(5);
 898                 }
 899                 if (ntries == 10) {
 900                         device_printf(sc->sc_dev,
 901                             "timeout reading ROM at 0x%x\n", addr);
 902                         return ETIMEDOUT;
 903                 }
 904                 *out++= val >> 16;
 905                 if (count > 1)
 906                         *out ++= val >> 24;
 907         }
 908
 909         wpi_nic_unlock(sc);
 910
 911         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
 912
 913         return 0;
 914 }
 915
 916 static void
 917 wpi_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nsegs, int error)
 918 {
 919         if (error != 0)
 920                 return;
 921         KASSERT(nsegs == 1, ("too many DMA segments, %d should be 1", nsegs));
 922         *(bus_addr_t *)arg = segs[0].ds_addr;
 923 }
 924
 925 /*
 926  * Allocates a contiguous block of dma memory of the requested size and
 927  * alignment.
 928  */
 929 static int
 930 wpi_dma_contig_alloc(struct wpi_softc *sc, struct wpi_dma_info *dma,
 931     void **kvap, bus_size_t size, bus_size_t alignment)
 932 {
 933         int error;
 934
 935         dma->tag = NULL;
 936         dma->size = size;
 937
 938         error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), alignment,
 939             0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, size,
 940             1, size, BUS_DMA_NOWAIT, NULL, NULL, &dma->tag);
 941         if (error != 0)
 942                 goto fail;
 943
 944         error = bus_dmamem_alloc(dma->tag, (void **)&dma->vaddr,
 945             BUS_DMA_NOWAIT | BUS_DMA_ZERO | BUS_DMA_COHERENT, &dma->map);
 946         if (error != 0)
 947                 goto fail;
 948
 949         error = bus_dmamap_load(dma->tag, dma->map, dma->vaddr, size,
 950             wpi_dma_map_addr, &dma->paddr, BUS_DMA_NOWAIT);
 951         if (error != 0)
 952                 goto fail;
 953
 954         bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE);
 955
 956         if (kvap != NULL)
 957                 *kvap = dma->vaddr;
 958
 959         return 0;
 960
 961 fail:   wpi_dma_contig_free(dma);
 962         return error;
 963 }
 964
 965 static void
 966 wpi_dma_contig_free(struct wpi_dma_info *dma)
 967 {
 968         if (dma->vaddr != NULL) {
 969                 bus_dmamap_sync(dma->tag, dma->map,
 970                     BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
 971                 bus_dmamap_unload(dma->tag, dma->map);
 972                 bus_dmamem_free(dma->tag, dma->vaddr, dma->map);
 973                 dma->vaddr = NULL;
 974         }
 975         if (dma->tag != NULL) {
 976                 bus_dma_tag_destroy(dma->tag);
 977                 dma->tag = NULL;
 978         }
 979 }
 980
 981 /*
 982  * Allocate a shared page between host and NIC.
 983  */
 984 static int
 985 wpi_alloc_shared(struct wpi_softc *sc)
 986 {
 987         /* Shared buffer must be aligned on a 4KB boundary. */
 988         return wpi_dma_contig_alloc(sc, &sc->shared_dma,
 989             (void **)&sc->shared, sizeof (struct wpi_shared), 4096);
 990 }
 991
 992 static void
 993 wpi_free_shared(struct wpi_softc *sc)
 994 {
 995         wpi_dma_contig_free(&sc->shared_dma);
 996 }
 997
 998 /*
 999  * Allocate DMA-safe memory for firmware transfer.
1000  */
1001 static int
1002 wpi_alloc_fwmem(struct wpi_softc *sc)
1003 {
1004         /* Must be aligned on a 16-byte boundary. */
1005         return wpi_dma_contig_alloc(sc, &sc->fw_dma, NULL,
1006             WPI_FW_TEXT_MAXSZ + WPI_FW_DATA_MAXSZ, 16);
1007 }
1008
1009 static void
1010 wpi_free_fwmem(struct wpi_softc *sc)
1011 {
1012         wpi_dma_contig_free(&sc->fw_dma);
1013 }
1014
1015 static int
1016 wpi_alloc_rx_ring(struct wpi_softc *sc)
1017 {
1018         struct wpi_rx_ring *ring = &sc->rxq;
1019         bus_size_t size;
1020         int i, error;
1021
1022         ring->cur = 0;
1023         ring->update = 0;
1024
1025         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
1026
1027         /* Allocate RX descriptors (16KB aligned.) */
1028         size = WPI_RX_RING_COUNT * sizeof (uint32_t);
1029         error = wpi_dma_contig_alloc(sc, &ring->desc_dma,
1030             (void **)&ring->desc, size, WPI_RING_DMA_ALIGN);
1031         if (error != 0) {
1032                 device_printf(sc->sc_dev,
1033                     "%s: could not allocate RX ring DMA memory, error %d\n",
1034                     __func__, error);
1035                 goto fail;
1036         }
1037
1038         /* Create RX buffer DMA tag. */
1039         error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0,
1040             BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
1041             MJUMPAGESIZE, 1, MJUMPAGESIZE, BUS_DMA_NOWAIT, NULL, NULL,
1042             &ring->data_dmat);
1043         if (error != 0) {
1044                 device_printf(sc->sc_dev,
1045                     "%s: could not create RX buf DMA tag, error %d\n",
1046                     __func__, error);
1047                 goto fail;
1048         }
1049
1050         /*
1051          * Allocate and map RX buffers.
1052          */
1053         for (i = 0; i < WPI_RX_RING_COUNT; i++) {
1054                 struct wpi_rx_data *data = &ring->data[i];
1055                 bus_addr_t paddr;
1056
1057                 error = bus_dmamap_create(ring->data_dmat, 0, &data->map);
1058                 if (error != 0) {
1059                         device_printf(sc->sc_dev,
1060                             "%s: could not create RX buf DMA map, error %d\n",
1061                             __func__, error);
1062                         goto fail;
1063                 }
1064
1065                 data->m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
1066                 if (data->m == NULL) {
1067                         device_printf(sc->sc_dev,
1068                             "%s: could not allocate RX mbuf\n", __func__);
1069                         error = ENOBUFS;
1070                         goto fail;
1071                 }
1072
1073                 error = bus_dmamap_load(ring->data_dmat, data->map,
1074                     mtod(data->m, void *), MJUMPAGESIZE, wpi_dma_map_addr,
1075                     &paddr, BUS_DMA_NOWAIT);
1076                 if (error != 0 && error != EFBIG) {
1077                         device_printf(sc->sc_dev,
1078                             "%s: can't map mbuf (error %d)\n", __func__,
1079                             error);
1080                         goto fail;
1081                 }
1082
1083                 /* Set physical address of RX buffer. */
1084                 ring->desc[i] = htole32(paddr);
1085         }
1086
1087         bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map,
1088             BUS_DMASYNC_PREWRITE);
1089
1090         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
1091
1092         return 0;
1093
1094 fail:   wpi_free_rx_ring(sc);
1095
1096         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__);
1097
1098         return error;
1099 }
1100
1101 static void
1102 wpi_update_rx_ring(struct wpi_softc *sc)
1103 {
1104         WPI_WRITE(sc, WPI_FH_RX_WPTR, sc->rxq.cur & ~7);
1105 }
1106
1107 static void
1108 wpi_update_rx_ring_ps(struct wpi_softc *sc)
1109 {
1110         struct wpi_rx_ring *ring = &sc->rxq;
1111
1112         if (ring->update != 0) {
1113                 /* Wait for INT_WAKEUP event. */
1114                 return;
1115         }
1116
1117         WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ);
1118         if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_SLEEP) {
1119                 DPRINTF(sc, WPI_DEBUG_PWRSAVE, "%s: wakeup request\n",
1120                     __func__);
1121                 ring->update = 1;
1122         } else {
1123                 wpi_update_rx_ring(sc);
1124                 WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ);
1125         }
1126 }
1127
1128 static void
1129 wpi_reset_rx_ring(struct wpi_softc *sc)
1130 {
1131         struct wpi_rx_ring *ring = &sc->rxq;
1132         int ntries;
1133
1134         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
1135
1136         if (wpi_nic_lock(sc) == 0) {
1137                 WPI_WRITE(sc, WPI_FH_RX_CONFIG, 0);
1138                 for (ntries = 0; ntries < 1000; ntries++) {
1139                         if (WPI_READ(sc, WPI_FH_RX_STATUS) &
1140                             WPI_FH_RX_STATUS_IDLE)
1141                                 break;
1142                         DELAY(10);
1143                 }
1144                 wpi_nic_unlock(sc);
1145         }
1146
1147         ring->cur = 0;
1148         ring->update = 0;
1149 }
1150
1151 static void
1152 wpi_free_rx_ring(struct wpi_softc *sc)
1153 {
1154         struct wpi_rx_ring *ring = &sc->rxq;
1155         int i;
1156
1157         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
1158
1159         wpi_dma_contig_free(&ring->desc_dma);
1160
1161         for (i = 0; i < WPI_RX_RING_COUNT; i++) {
1162                 struct wpi_rx_data *data = &ring->data[i];
1163
1164                 if (data->m != NULL) {
1165                         bus_dmamap_sync(ring->data_dmat, data->map,
1166                             BUS_DMASYNC_POSTREAD);
1167                         bus_dmamap_unload(ring->data_dmat, data->map);
1168                         m_freem(data->m);
1169                         data->m = NULL;
1170                 }
1171                 if (data->map != NULL)
1172                         bus_dmamap_destroy(ring->data_dmat, data->map);
1173         }
1174         if (ring->data_dmat != NULL) {
1175                 bus_dma_tag_destroy(ring->data_dmat);
1176                 ring->data_dmat = NULL;
1177         }
1178 }
1179
1180 static int
1181 wpi_alloc_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring, int qid)
1182 {
1183         bus_addr_t paddr;
1184         bus_size_t size;
1185         int i, error;
1186
1187         ring->qid = qid;
1188         ring->queued = 0;
1189         ring->cur = 0;
1190         ring->update = 0;
1191
1192         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
1193
1194         /* Allocate TX descriptors (16KB aligned.) */
1195         size = WPI_TX_RING_COUNT * sizeof (struct wpi_tx_desc);
1196         error = wpi_dma_contig_alloc(sc, &ring->desc_dma, (void **)&ring->desc,
1197             size, WPI_RING_DMA_ALIGN);
1198         if (error != 0) {
1199                 device_printf(sc->sc_dev,
1200                     "%s: could not allocate TX ring DMA memory, error %d\n",
1201                     __func__, error);
1202                 goto fail;
1203         }
1204
1205         /* Update shared area with ring physical address. */
1206         sc->shared->txbase[qid] = htole32(ring->desc_dma.paddr);
1207         bus_dmamap_sync(sc->shared_dma.tag, sc->shared_dma.map,
1208             BUS_DMASYNC_PREWRITE);
1209
1210         /*
1211          * We only use rings 0 through 4 (4 EDCA + cmd) so there is no need
1212          * to allocate commands space for other rings.
1213          * XXX Do we really need to allocate descriptors for other rings?
1214          */
1215         if (qid > WPI_CMD_QUEUE_NUM) {
1216                 DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
1217                 return 0;
1218         }
1219
1220         size = WPI_TX_RING_COUNT * sizeof (struct wpi_tx_cmd);
1221         error = wpi_dma_contig_alloc(sc, &ring->cmd_dma, (void **)&ring->cmd,
1222             size, 4);
1223         if (error != 0) {
1224                 device_printf(sc->sc_dev,
1225                     "%s: could not allocate TX cmd DMA memory, error %d\n",
1226                     __func__, error);
1227                 goto fail;
1228         }
1229
1230         error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0,
1231             BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES,
1232             WPI_MAX_SCATTER - 1, MCLBYTES, BUS_DMA_NOWAIT, NULL, NULL,
1233             &ring->data_dmat);
1234         if (error != 0) {
1235                 device_printf(sc->sc_dev,
1236                     "%s: could not create TX buf DMA tag, error %d\n",
1237                     __func__, error);
1238                 goto fail;
1239         }
1240
1241         paddr = ring->cmd_dma.paddr;
1242         for (i = 0; i < WPI_TX_RING_COUNT; i++) {
1243                 struct wpi_tx_data *data = &ring->data[i];
1244
1245                 data->cmd_paddr = paddr;
1246                 paddr += sizeof (struct wpi_tx_cmd);
1247
1248                 error = bus_dmamap_create(ring->data_dmat, 0, &data->map);
1249                 if (error != 0) {
1250                         device_printf(sc->sc_dev,
1251                             "%s: could not create TX buf DMA map, error %d\n",
1252                             __func__, error);
1253                         goto fail;
1254                 }
1255         }
1256
1257         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
1258
1259         return 0;
1260
1261 fail:   wpi_free_tx_ring(sc, ring);
1262         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__);
1263         return error;
1264 }
1265
1266 static void
1267 wpi_update_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring)
1268 {
1269         WPI_WRITE(sc, WPI_HBUS_TARG_WRPTR, ring->qid << 8 | ring->cur);
1270 }
1271
1272 static void
1273 wpi_update_tx_ring_ps(struct wpi_softc *sc, struct wpi_tx_ring *ring)
1274 {
1275
1276         if (ring->update != 0) {
1277                 /* Wait for INT_WAKEUP event. */
1278                 return;
1279         }
1280
1281         WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ);
1282         if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_SLEEP) {
1283                 DPRINTF(sc, WPI_DEBUG_PWRSAVE, "%s (%d): requesting wakeup\n",
1284                     __func__, ring->qid);
1285                 ring->update = 1;
1286         } else {
1287                 wpi_update_tx_ring(sc, ring);
1288                 WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ);
1289         }
1290 }
1291
1292 static void
1293 wpi_reset_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring)
1294 {
1295         int i;
1296
1297         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
1298
1299         for (i = 0; i < WPI_TX_RING_COUNT; i++) {
1300                 struct wpi_tx_data *data = &ring->data[i];
1301
1302                 if (data->m != NULL) {
1303                         bus_dmamap_sync(ring->data_dmat, data->map,
1304                             BUS_DMASYNC_POSTWRITE);
1305                         bus_dmamap_unload(ring->data_dmat, data->map);
1306                         m_freem(data->m);
1307                         data->m = NULL;
1308                 }
1309                 if (data->ni != NULL) {
1310                         ieee80211_free_node(data->ni);
1311                         data->ni = NULL;
1312                 }
1313         }
1314         /* Clear TX descriptors. */
1315         memset(ring->desc, 0, ring->desc_dma.size);
1316         bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map,
1317             BUS_DMASYNC_PREWRITE);
1318         sc->qfullmsk &= ~(1 << ring->qid);
1319         ring->queued = 0;
1320         ring->cur = 0;
1321         ring->update = 0;
1322 }
1323
1324 static void
1325 wpi_free_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring)
1326 {
1327         int i;
1328
1329         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
1330
1331         wpi_dma_contig_free(&ring->desc_dma);
1332         wpi_dma_contig_free(&ring->cmd_dma);
1333
1334         for (i = 0; i < WPI_TX_RING_COUNT; i++) {
1335                 struct wpi_tx_data *data = &ring->data[i];
1336
1337                 if (data->m != NULL) {
1338                         bus_dmamap_sync(ring->data_dmat, data->map,
1339                             BUS_DMASYNC_POSTWRITE);
1340                         bus_dmamap_unload(ring->data_dmat, data->map);
1341                         m_freem(data->m);
1342                 }
1343                 if (data->map != NULL)
1344                         bus_dmamap_destroy(ring->data_dmat, data->map);
1345         }
1346         if (ring->data_dmat != NULL) {
1347                 bus_dma_tag_destroy(ring->data_dmat);
1348                 ring->data_dmat = NULL;
1349         }
1350 }
1351
1352 /*
1353  * Extract various information from EEPROM.
1354  */
1355 static int
1356 wpi_read_eeprom(struct wpi_softc *sc, uint8_t macaddr[IEEE80211_ADDR_LEN])
1357 {
1358 #define WPI_CHK(res) do {               \
1359         if ((error = res) != 0)         \
1360                 goto fail;              \
1361 } while (0)
1362         int error, i;
1363
1364         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
1365
1366         /* Adapter has to be powered on for EEPROM access to work. */
1367         if ((error = wpi_apm_init(sc)) != 0) {
1368                 device_printf(sc->sc_dev,
1369                     "%s: could not power ON adapter, error %d\n", __func__,
1370                     error);
1371                 return error;
1372         }
1373
1374         if ((WPI_READ(sc, WPI_EEPROM_GP) & 0x6) == 0) {
1375                 device_printf(sc->sc_dev, "bad EEPROM signature\n");
1376                 error = EIO;
1377                 goto fail;
1378         }
1379         /* Clear HW ownership of EEPROM. */
1380         WPI_CLRBITS(sc, WPI_EEPROM_GP, WPI_EEPROM_GP_IF_OWNER);
1381
1382         /* Read the hardware capabilities, revision and SKU type. */
1383         WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_SKU_CAP, &sc->cap,
1384             sizeof(sc->cap)));
1385         WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_REVISION, &sc->rev,
1386             sizeof(sc->rev)));
1387         WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_TYPE, &sc->type,
1388             sizeof(sc->type)));
1389
1390         sc->rev = le16toh(sc->rev);
1391         DPRINTF(sc, WPI_DEBUG_EEPROM, "cap=%x rev=%x type=%x\n", sc->cap,
1392             sc->rev, sc->type);
1393
1394         /* Read the regulatory domain (4 ASCII characters.) */
1395         WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_DOMAIN, sc->domain,
1396             sizeof(sc->domain)));
1397
1398         /* Read MAC address. */
1399         WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_MAC, macaddr,
1400             IEEE80211_ADDR_LEN));
1401
1402         /* Read the list of authorized channels. */
1403         for (i = 0; i < WPI_CHAN_BANDS_COUNT; i++)
1404                 WPI_CHK(wpi_read_eeprom_channels(sc, i));
1405
1406         /* Read the list of TX power groups. */
1407         for (i = 0; i < WPI_POWER_GROUPS_COUNT; i++)
1408                 WPI_CHK(wpi_read_eeprom_group(sc, i));
1409
1410 fail:   wpi_apm_stop(sc);       /* Power OFF adapter. */
1411
1412         DPRINTF(sc, WPI_DEBUG_TRACE, error ? TRACE_STR_END_ERR : TRACE_STR_END,
1413             __func__);
1414
1415         return error;
1416 #undef WPI_CHK
1417 }
1418
1419 /*
1420  * Translate EEPROM flags to net80211.
1421  */
1422 static uint32_t
1423 wpi_eeprom_channel_flags(struct wpi_eeprom_chan *channel)
1424 {
1425         uint32_t nflags;
1426
1427         nflags = 0;
1428         if ((channel->flags & WPI_EEPROM_CHAN_ACTIVE) == 0)
1429                 nflags |= IEEE80211_CHAN_PASSIVE;
1430         if ((channel->flags & WPI_EEPROM_CHAN_IBSS) == 0)
1431                 nflags |= IEEE80211_CHAN_NOADHOC;
1432         if (channel->flags & WPI_EEPROM_CHAN_RADAR) {
1433                 nflags |= IEEE80211_CHAN_DFS;
1434                 /* XXX apparently IBSS may still be marked */
1435                 nflags |= IEEE80211_CHAN_NOADHOC;
1436         }
1437
1438         /* XXX HOSTAP uses WPI_MODE_IBSS */
1439         if (nflags & IEEE80211_CHAN_NOADHOC)
1440                 nflags |= IEEE80211_CHAN_NOHOSTAP;
1441
1442         return nflags;
1443 }
1444
1445 static void
1446 wpi_read_eeprom_band(struct wpi_softc *sc, int n)
1447 {
1448         struct ifnet *ifp = sc->sc_ifp;
1449         struct ieee80211com *ic = ifp->if_l2com;
1450         struct wpi_eeprom_chan *channels = sc->eeprom_channels[n];
1451         const struct wpi_chan_band *band = &wpi_bands[n];
1452         struct ieee80211_channel *c;
1453         uint8_t chan;
1454         int i, nflags;
1455
1456         for (i = 0; i < band->nchan; i++) {
1457                 if (!(channels[i].flags & WPI_EEPROM_CHAN_VALID)) {
1458                         DPRINTF(sc, WPI_DEBUG_EEPROM,
1459                             "Channel Not Valid: %d, band %d\n",
1460                              band->chan[i],n);
1461                         continue;
1462                 }
1463
1464                 chan = band->chan[i];
1465                 nflags = wpi_eeprom_channel_flags(&channels[i]);
1466
1467                 c = &ic->ic_channels[ic->ic_nchans++];
1468                 c->ic_ieee = chan;
1469                 c->ic_maxregpower = channels[i].maxpwr;
1470                 c->ic_maxpower = 2*c->ic_maxregpower;
1471
1472                 if (n == 0) {   /* 2GHz band */
1473                         c->ic_freq = ieee80211_ieee2mhz(chan,
1474                             IEEE80211_CHAN_G);
1475
1476                         /* G =>'s B is supported */
1477                         c->ic_flags = IEEE80211_CHAN_B | nflags;
1478                         c = &ic->ic_channels[ic->ic_nchans++];
1479                         c[0] = c[-1];
1480                         c->ic_flags = IEEE80211_CHAN_G | nflags;
1481                 } else {        /* 5GHz band */
1482                         c->ic_freq = ieee80211_ieee2mhz(chan,
1483                             IEEE80211_CHAN_A);
1484
1485                         c->ic_flags = IEEE80211_CHAN_A | nflags;
1486                 }
1487
1488                 /* Save maximum allowed TX power for this channel. */
1489                 sc->maxpwr[chan] = channels[i].maxpwr;
1490
1491                 DPRINTF(sc, WPI_DEBUG_EEPROM,
1492                     "adding chan %d (%dMHz) flags=0x%x maxpwr=%d passive=%d,"
1493                     " offset %d\n", chan, c->ic_freq,
1494                     channels[i].flags, sc->maxpwr[chan],
1495                     IEEE80211_IS_CHAN_PASSIVE(c), ic->ic_nchans);
1496         }
1497 }
1498
1499 /**
1500  * Read the eeprom to find out what channels are valid for the given
1501  * band and update net80211 with what we find.
1502  */
1503 static int
1504 wpi_read_eeprom_channels(struct wpi_softc *sc, int n)
1505 {
1506         struct ifnet *ifp = sc->sc_ifp;
1507         struct ieee80211com *ic = ifp->if_l2com;
1508         const struct wpi_chan_band *band = &wpi_bands[n];
1509         int error;
1510
1511         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
1512
1513         error = wpi_read_prom_data(sc, band->addr, &sc->eeprom_channels[n],
1514             band->nchan * sizeof (struct wpi_eeprom_chan));
1515         if (error != 0) {
1516                 DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__);
1517                 return error;
1518         }
1519
1520         wpi_read_eeprom_band(sc, n);
1521
1522         ieee80211_sort_channels(ic->ic_channels, ic->ic_nchans);
1523
1524         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
1525
1526         return 0;
1527 }
1528
1529 static struct wpi_eeprom_chan *
1530 wpi_find_eeprom_channel(struct wpi_softc *sc, struct ieee80211_channel *c)
1531 {
1532         int i, j;
1533
1534         for (j = 0; j < WPI_CHAN_BANDS_COUNT; j++)
1535                 for (i = 0; i < wpi_bands[j].nchan; i++)
1536                         if (wpi_bands[j].chan[i] == c->ic_ieee)
1537                                 return &sc->eeprom_channels[j][i];
1538
1539         return NULL;
1540 }
1541
1542 /*
1543  * Enforce flags read from EEPROM.
1544  */
1545 static int
1546 wpi_setregdomain(struct ieee80211com *ic, struct ieee80211_regdomain *rd,
1547     int nchan, struct ieee80211_channel chans[])
1548 {
1549         struct ifnet *ifp = ic->ic_ifp;
1550         struct wpi_softc *sc = ifp->if_softc;
1551         int i;
1552
1553         for (i = 0; i < nchan; i++) {
1554                 struct ieee80211_channel *c = &chans[i];
1555                 struct wpi_eeprom_chan *channel;
1556
1557                 channel = wpi_find_eeprom_channel(sc, c);
1558                 if (channel == NULL) {
1559                         if_printf(ic->ic_ifp,
1560                             "%s: invalid channel %u freq %u/0x%x\n",
1561                             __func__, c->ic_ieee, c->ic_freq, c->ic_flags);
1562                         return EINVAL;
1563                 }
1564                 c->ic_flags |= wpi_eeprom_channel_flags(channel);
1565         }
1566
1567         return 0;
1568 }
1569
1570 static int
1571 wpi_read_eeprom_group(struct wpi_softc *sc, int n)
1572 {
1573         struct wpi_power_group *group = &sc->groups[n];
1574         struct wpi_eeprom_group rgroup;
1575         int i, error;
1576
1577         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
1578
1579         if ((error = wpi_read_prom_data(sc, WPI_EEPROM_POWER_GRP + n * 32,
1580             &rgroup, sizeof rgroup)) != 0) {
1581                 DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__);
1582                 return error;
1583         }
1584
1585         /* Save TX power group information. */
1586         group->chan   = rgroup.chan;
1587         group->maxpwr = rgroup.maxpwr;
1588         /* Retrieve temperature at which the samples were taken. */
1589         group->temp   = (int16_t)le16toh(rgroup.temp);
1590
1591         DPRINTF(sc, WPI_DEBUG_EEPROM,
1592             "power group %d: chan=%d maxpwr=%d temp=%d\n", n, group->chan,
1593             group->maxpwr, group->temp);
1594
1595         for (i = 0; i < WPI_SAMPLES_COUNT; i++) {
1596                 group->samples[i].index = rgroup.samples[i].index;
1597                 group->samples[i].power = rgroup.samples[i].power;
1598
1599                 DPRINTF(sc, WPI_DEBUG_EEPROM,
1600                     "\tsample %d: index=%d power=%d\n", i,
1601                     group->samples[i].index, group->samples[i].power);
1602         }
1603
1604         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
1605
1606         return 0;
1607 }
1608
1609 static int
1610 wpi_add_node_entry_adhoc(struct wpi_softc *sc)
1611 {
1612         int newid = WPI_ID_IBSS_MIN;
1613
1614         for (; newid <= WPI_ID_IBSS_MAX; newid++) {
1615                 if ((sc->nodesmsk & (1 << newid)) == 0) {
1616                         sc->nodesmsk |= 1 << newid;
1617                         return newid;
1618                 }
1619         }
1620
1621         return WPI_ID_UNDEFINED;
1622 }
1623
1624 static __inline int
1625 wpi_add_node_entry_sta(struct wpi_softc *sc)
1626 {
1627         sc->nodesmsk |= 1 << WPI_ID_BSS;
1628
1629         return WPI_ID_BSS;
1630 }
1631
1632 static __inline int
1633 wpi_check_node_entry(struct wpi_softc *sc, uint8_t id)
1634 {
1635         if (id == WPI_ID_UNDEFINED)
1636                 return 0;
1637
1638         return (sc->nodesmsk >> id) & 1;
1639 }
1640
1641 static __inline void
1642 wpi_clear_node_table(struct wpi_softc *sc)
1643 {
1644         sc->nodesmsk = 0;
1645 }
1646
1647 static __inline void
1648 wpi_del_node_entry(struct wpi_softc *sc, uint8_t id)
1649 {
1650         sc->nodesmsk &= ~(1 << id);
1651 }
1652
1653 static struct ieee80211_node *
1654 wpi_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN])
1655 {
1656         struct wpi_node *wn;
1657
1658         wn = malloc(sizeof (struct wpi_node), M_80211_NODE,
1659             M_NOWAIT | M_ZERO);
1660
1661         if (wn == NULL)
1662                 return NULL;
1663
1664         wn->id = WPI_ID_UNDEFINED;
1665
1666         return &wn->ni;
1667 }
1668
1669 static void
1670 wpi_node_free(struct ieee80211_node *ni)
1671 {
1672         struct ieee80211com *ic = ni->ni_ic;
1673         struct wpi_softc *sc = ic->ic_ifp->if_softc;
1674         struct wpi_node *wn = WPI_NODE(ni);
1675
1676         if (wn->id != WPI_ID_UNDEFINED) {
1677                 WPI_NT_LOCK(sc);
1678                 if (wpi_check_node_entry(sc, wn->id)) {
1679                         wpi_del_node_entry(sc, wn->id);
1680                         wpi_del_node(sc, ni);
1681                 }
1682                 WPI_NT_UNLOCK(sc);
1683         }
1684
1685         sc->sc_node_free(ni);
1686 }
1687
1688 static __inline int
1689 wpi_check_bss_filter(struct wpi_softc *sc)
1690 {
1691         return (sc->rxon.filter & htole32(WPI_FILTER_BSS)) != 0;
1692 }
1693
1694 static void
1695 wpi_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m, int subtype, int rssi,
1696     int nf)
1697 {
1698         struct ieee80211vap *vap = ni->ni_vap;
1699         struct wpi_softc *sc = vap->iv_ic->ic_ifp->if_softc;
1700         struct wpi_vap *wvp = WPI_VAP(vap);
1701         uint64_t ni_tstamp, rx_tstamp;
1702
1703         wvp->wv_recv_mgmt(ni, m, subtype, rssi, nf);
1704
1705         if (vap->iv_opmode == IEEE80211_M_IBSS &&
1706             vap->iv_state == IEEE80211_S_RUN &&
1707             (subtype == IEEE80211_FC0_SUBTYPE_BEACON ||
1708             subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP)) {
1709                 ni_tstamp = le64toh(ni->ni_tstamp.tsf);
1710                 rx_tstamp = le64toh(sc->rx_tstamp);
1711
1712                 if (ni_tstamp >= rx_tstamp) {
1713                         DPRINTF(sc, WPI_DEBUG_STATE,
1714                             "ibss merge, tsf %ju tstamp %ju\n",
1715                             (uintmax_t)rx_tstamp, (uintmax_t)ni_tstamp);
1716                         (void) ieee80211_ibss_merge(ni);
1717                 }
1718         }
1719 }
1720
1721 static void
1722 wpi_restore_node(void *arg, struct ieee80211_node *ni)
1723 {
1724         struct wpi_softc *sc = arg;
1725         struct wpi_node *wn = WPI_NODE(ni);
1726         int error;
1727
1728         WPI_NT_LOCK(sc);
1729         if (wn->id != WPI_ID_UNDEFINED) {
1730                 wn->id = WPI_ID_UNDEFINED;
1731                 if ((error = wpi_add_ibss_node(sc, ni)) != 0) {
1732                         device_printf(sc->sc_dev,
1733                             "%s: could not add IBSS node, error %d\n",
1734                             __func__, error);
1735                 }
1736         }
1737         WPI_NT_UNLOCK(sc);
1738 }
1739
1740 static void
1741 wpi_restore_node_table(struct wpi_softc *sc, struct wpi_vap *wvp)
1742 {
1743         struct ieee80211com *ic = sc->sc_ifp->if_l2com;
1744
1745         /* Set group keys once. */
1746         WPI_NT_LOCK(sc);
1747         wvp->wv_gtk = 0;
1748         WPI_NT_UNLOCK(sc);
1749
1750         ieee80211_iterate_nodes(&ic->ic_sta, wpi_restore_node, sc);
1751         ieee80211_crypto_reload_keys(ic);
1752 }
1753
1754 /**
1755  * Called by net80211 when ever there is a change to 80211 state machine
1756  */
1757 static int
1758 wpi_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
1759 {
1760         struct wpi_vap *wvp = WPI_VAP(vap);
1761         struct ieee80211com *ic = vap->iv_ic;
1762         struct ifnet *ifp = ic->ic_ifp;
1763         struct wpi_softc *sc = ifp->if_softc;
1764         int error = 0;
1765
1766         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
1767
1768         DPRINTF(sc, WPI_DEBUG_STATE, "%s: %s -> %s\n", __func__,
1769                 ieee80211_state_name[vap->iv_state],
1770                 ieee80211_state_name[nstate]);
1771
1772         if (vap->iv_state == IEEE80211_S_RUN && nstate < IEEE80211_S_RUN) {
1773                 if ((error = wpi_set_pslevel(sc, 0, 0, 1)) != 0) {
1774                         device_printf(sc->sc_dev,
1775                             "%s: could not set power saving level\n",
1776                             __func__);
1777                         return error;
1778                 }
1779
1780                 wpi_set_led(sc, WPI_LED_LINK, 1, 0);
1781         }
1782
1783         switch (nstate) {
1784         case IEEE80211_S_SCAN:
1785                 WPI_RXON_LOCK(sc);
1786                 if (wpi_check_bss_filter(sc) != 0) {
1787                         sc->rxon.filter &= ~htole32(WPI_FILTER_BSS);
1788                         if ((error = wpi_send_rxon(sc, 0, 1)) != 0) {
1789                                 device_printf(sc->sc_dev,
1790                                     "%s: could not send RXON\n", __func__);
1791                         }
1792                 }
1793                 WPI_RXON_UNLOCK(sc);
1794                 break;
1795
1796         case IEEE80211_S_ASSOC:
1797                 if (vap->iv_state != IEEE80211_S_RUN)
1798                         break;
1799                 /* FALLTHROUGH */
1800         case IEEE80211_S_AUTH:
1801                 /*
1802                  * NB: do not optimize AUTH -> AUTH state transmission -
1803                  * this will break powersave with non-QoS AP!
1804                  */
1805
1806                 /*
1807                  * The node must be registered in the firmware before auth.
1808                  * Also the associd must be cleared on RUN -> ASSOC
1809                  * transitions.
1810                  */
1811                 if ((error = wpi_auth(sc, vap)) != 0) {
1812                         device_printf(sc->sc_dev,
1813                             "%s: could not move to AUTH state, error %d\n",
1814                             __func__, error);
1815                 }
1816                 break;
1817
1818         case IEEE80211_S_RUN:
1819                 /*
1820                  * RUN -> RUN transition:
1821                  * STA mode: Just restart the timers.
1822                  * IBSS mode: Process IBSS merge.
1823                  */
1824                 if (vap->iv_state == IEEE80211_S_RUN) {
1825                         if (vap->iv_opmode != IEEE80211_M_IBSS) {
1826                                 WPI_RXON_LOCK(sc);
1827                                 wpi_calib_timeout(sc);
1828                                 WPI_RXON_UNLOCK(sc);
1829                                 break;
1830                         } else {
1831                                 /*
1832                                  * Drop the BSS_FILTER bit
1833                                  * (there is no another way to change bssid).
1834                                  */
1835                                 WPI_RXON_LOCK(sc);
1836                                 sc->rxon.filter &= ~htole32(WPI_FILTER_BSS);
1837                                 if ((error = wpi_send_rxon(sc, 0, 1)) != 0) {
1838                                         device_printf(sc->sc_dev,
1839                                             "%s: could not send RXON\n",
1840                                             __func__);
1841                                 }
1842                                 WPI_RXON_UNLOCK(sc);
1843
1844                                 /* Restore all what was lost. */
1845                                 wpi_restore_node_table(sc, wvp);
1846
1847                                 /* XXX set conditionally? */
1848                                 wpi_updateedca(ic);
1849                         }
1850                 }
1851
1852                 /*
1853                  * !RUN -> RUN requires setting the association id
1854                  * which is done with a firmware cmd.  We also defer
1855                  * starting the timers until that work is done.
1856                  */
1857                 if ((error = wpi_run(sc, vap)) != 0) {
1858                         device_printf(sc->sc_dev,
1859                             "%s: could not move to RUN state\n", __func__);
1860                 }
1861                 break;
1862
1863         default:
1864                 break;
1865         }
1866         if (error != 0) {
1867                 DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__);
1868                 return error;
1869         }
1870
1871         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
1872
1873         return wvp->wv_newstate(vap, nstate, arg);
1874 }
1875
1876 static void
1877 wpi_calib_timeout(void *arg)
1878 {
1879         struct wpi_softc *sc = arg;
1880
1881         if (wpi_check_bss_filter(sc) == 0)
1882                 return;
1883
1884         wpi_power_calibration(sc);
1885
1886         callout_reset(&sc->calib_to, 60*hz, wpi_calib_timeout, sc);
1887 }
1888
1889 static __inline uint8_t
1890 rate2plcp(const uint8_t rate)
1891 {
1892         switch (rate) {
1893         case 12:        return 0xd;
1894         case 18:        return 0xf;
1895         case 24:        return 0x5;
1896         case 36:        return 0x7;
1897         case 48:        return 0x9;
1898         case 72:        return 0xb;
1899         case 96:        return 0x1;
1900         case 108:       return 0x3;
1901         case 2:         return 10;
1902         case 4:         return 20;
1903         case 11:        return 55;
1904         case 22:        return 110;
1905         default:        return 0;
1906         }
1907 }
1908
1909 static __inline uint8_t
1910 plcp2rate(const uint8_t plcp)
1911 {
1912         switch (plcp) {
1913         case 0xd:       return 12;
1914         case 0xf:       return 18;
1915         case 0x5:       return 24;
1916         case 0x7:       return 36;
1917         case 0x9:       return 48;
1918         case 0xb:       return 72;
1919         case 0x1:       return 96;
1920         case 0x3:       return 108;
1921         case 10:        return 2;
1922         case 20:        return 4;
1923         case 55:        return 11;
1924         case 110:       return 22;
1925         default:        return 0;
1926         }
1927 }
1928
1929 /* Quickly determine if a given rate is CCK or OFDM. */
1930 #define WPI_RATE_IS_OFDM(rate)  ((rate) >= 12 && (rate) != 22)
1931
1932 static void
1933 wpi_rx_done(struct wpi_softc *sc, struct wpi_rx_desc *desc,
1934     struct wpi_rx_data *data)
1935 {
1936         struct ifnet *ifp = sc->sc_ifp;
1937         struct ieee80211com *ic = ifp->if_l2com;
1938         struct wpi_rx_ring *ring = &sc->rxq;
1939         struct wpi_rx_stat *stat;
1940         struct wpi_rx_head *head;
1941         struct wpi_rx_tail *tail;
1942         struct ieee80211_frame *wh;
1943         struct ieee80211_node *ni;
1944         struct mbuf *m, *m1;
1945         bus_addr_t paddr;
1946         uint32_t flags;
1947         uint16_t len;
1948         int error;
1949
1950         stat = (struct wpi_rx_stat *)(desc + 1);
1951
1952         if (stat->len > WPI_STAT_MAXLEN) {
1953                 device_printf(sc->sc_dev, "invalid RX statistic header\n");
1954                 goto fail1;
1955         }
1956
1957         bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_POSTREAD);
1958         head = (struct wpi_rx_head *)((caddr_t)(stat + 1) + stat->len);
1959         len = le16toh(head->len);
1960         tail = (struct wpi_rx_tail *)((caddr_t)(head + 1) + len);
1961         flags = le32toh(tail->flags);
1962
1963         DPRINTF(sc, WPI_DEBUG_RECV, "%s: idx %d len %d stat len %u rssi %d"
1964             " rate %x chan %d tstamp %ju\n", __func__, ring->cur,
1965             le32toh(desc->len), len, (int8_t)stat->rssi,
1966             head->plcp, head->chan, (uintmax_t)le64toh(tail->tstamp));
1967
1968         /* Discard frames with a bad FCS early. */
1969         if ((flags & WPI_RX_NOERROR) != WPI_RX_NOERROR) {
1970                 DPRINTF(sc, WPI_DEBUG_RECV, "%s: RX flags error %x\n",
1971                     __func__, flags);
1972                 goto fail1;
1973         }
1974         /* Discard frames that are too short. */
1975         if (len < sizeof (*wh)) {
1976                 DPRINTF(sc, WPI_DEBUG_RECV, "%s: frame too short: %d\n",
1977                     __func__, len);
1978                 goto fail1;
1979         }
1980
1981         m1 = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
1982         if (m1 == NULL) {
1983                 DPRINTF(sc, WPI_DEBUG_ANY, "%s: no mbuf to restock ring\n",
1984                     __func__);
1985                 goto fail1;
1986         }
1987         bus_dmamap_unload(ring->data_dmat, data->map);
1988
1989         error = bus_dmamap_load(ring->data_dmat, data->map, mtod(m1, void *),
1990             MJUMPAGESIZE, wpi_dma_map_addr, &paddr, BUS_DMA_NOWAIT);
1991         if (error != 0 && error != EFBIG) {
1992                 device_printf(sc->sc_dev,
1993                     "%s: bus_dmamap_load failed, error %d\n", __func__, error);
1994                 m_freem(m1);
1995
1996                 /* Try to reload the old mbuf. */
1997                 error = bus_dmamap_load(ring->data_dmat, data->map,
1998                     mtod(data->m, void *), MJUMPAGESIZE, wpi_dma_map_addr,
1999                     &paddr, BUS_DMA_NOWAIT);
2000                 if (error != 0 && error != EFBIG) {
2001                         panic("%s: could not load old RX mbuf", __func__);
2002                 }
2003                 /* Physical address may have changed. */
2004                 ring->desc[ring->cur] = htole32(paddr);
2005                 bus_dmamap_sync(ring->data_dmat, ring->desc_dma.map,
2006                     BUS_DMASYNC_PREWRITE);
2007                 goto fail1;
2008         }
2009
2010         m = data->m;
2011         data->m = m1;
2012         /* Update RX descriptor. */
2013         ring->desc[ring->cur] = htole32(paddr);
2014         bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map,
2015             BUS_DMASYNC_PREWRITE);
2016
2017         /* Finalize mbuf. */
2018         m->m_pkthdr.rcvif = ifp;
2019         m->m_data = (caddr_t)(head + 1);
2020         m->m_pkthdr.len = m->m_len = len;
2021
2022         /* Grab a reference to the source node. */
2023         wh = mtod(m, struct ieee80211_frame *);
2024
2025         if ((wh->i_fc[1] & IEEE80211_FC1_PROTECTED) &&
2026             (flags & WPI_RX_CIPHER_MASK) == WPI_RX_CIPHER_CCMP) {
2027                 /* Check whether decryption was successful or not. */
2028                 if ((flags & WPI_RX_DECRYPT_MASK) != WPI_RX_DECRYPT_OK) {
2029                         DPRINTF(sc, WPI_DEBUG_RECV,
2030                             "CCMP decryption failed 0x%x\n", flags);
2031                         goto fail2;
2032                 }
2033                 m->m_flags |= M_WEP;
2034         }
2035
2036         ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh);
2037         sc->rx_tstamp = tail->tstamp;
2038
2039         if (ieee80211_radiotap_active(ic)) {
2040                 struct wpi_rx_radiotap_header *tap = &sc->sc_rxtap;
2041
2042                 tap->wr_flags = 0;
2043                 if (head->flags & htole16(WPI_STAT_FLAG_SHPREAMBLE))
2044                         tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
2045                 tap->wr_dbm_antsignal = (int8_t)(stat->rssi + WPI_RSSI_OFFSET);
2046                 tap->wr_dbm_antnoise = WPI_RSSI_OFFSET;
2047                 tap->wr_tsft = tail->tstamp;
2048                 tap->wr_antenna = (le16toh(head->flags) >> 4) & 0xf;
2049                 tap->wr_rate = plcp2rate(head->plcp);
2050         }
2051
2052         WPI_UNLOCK(sc);
2053
2054         /* Send the frame to the 802.11 layer. */
2055         if (ni != NULL) {
2056                 (void)ieee80211_input(ni, m, stat->rssi, WPI_RSSI_OFFSET);
2057                 /* Node is no longer needed. */
2058                 ieee80211_free_node(ni);
2059         } else
2060                 (void)ieee80211_input_all(ic, m, stat->rssi, WPI_RSSI_OFFSET);
2061
2062         WPI_LOCK(sc);
2063
2064         return;
2065
2066 fail2:  m_freem(m);
2067
2068 fail1:  if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);
2069 }
2070
2071 static void
2072 wpi_rx_statistics(struct wpi_softc *sc, struct wpi_rx_desc *desc,
2073     struct wpi_rx_data *data)
2074 {
2075         /* Ignore */
2076 }
2077
2078 static void
2079 wpi_tx_done(struct wpi_softc *sc, struct wpi_rx_desc *desc)
2080 {
2081         struct ifnet *ifp = sc->sc_ifp;
2082         struct wpi_tx_ring *ring = &sc->txq[desc->qid & 0x3];
2083         struct wpi_tx_data *data = &ring->data[desc->idx];
2084         struct wpi_tx_stat *stat = (struct wpi_tx_stat *)(desc + 1);
2085         struct mbuf *m;
2086         struct ieee80211_node *ni;
2087         struct ieee80211vap *vap;
2088         struct ieee80211com *ic;
2089         uint32_t status = le32toh(stat->status);
2090         int ackfailcnt = stat->ackfailcnt / WPI_NTRIES_DEFAULT;
2091
2092         KASSERT(data->ni != NULL, ("no node"));
2093         KASSERT(data->m != NULL, ("no mbuf"));
2094
2095         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
2096
2097         DPRINTF(sc, WPI_DEBUG_XMIT, "%s: "
2098             "qid %d idx %d retries %d btkillcnt %d rate %x duration %d "
2099             "status %x\n", __func__, desc->qid, desc->idx, stat->ackfailcnt,
2100             stat->btkillcnt, stat->rate, le32toh(stat->duration), status);
2101
2102         /* Unmap and free mbuf. */
2103         bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_POSTWRITE);
2104         bus_dmamap_unload(ring->data_dmat, data->map);
2105         m = data->m, data->m = NULL;
2106         ni = data->ni, data->ni = NULL;
2107         vap = ni->ni_vap;
2108         ic = vap->iv_ic;
2109
2110         /*
2111          * Update rate control statistics for the node.
2112          */
2113         if (status & WPI_TX_STATUS_FAIL) {
2114                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
2115                 ieee80211_ratectl_tx_complete(vap, ni,
2116                     IEEE80211_RATECTL_TX_FAILURE, &ackfailcnt, NULL);
2117         } else {
2118                 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
2119                 ieee80211_ratectl_tx_complete(vap, ni,
2120                     IEEE80211_RATECTL_TX_SUCCESS, &ackfailcnt, NULL);
2121         }
2122
2123         ieee80211_tx_complete(ni, m, (status & WPI_TX_STATUS_FAIL) != 0);
2124
2125         WPI_TXQ_STATE_LOCK(sc);
2126         ring->queued -= 1;
2127         if (ring->queued > 0) {
2128                 callout_reset(&sc->tx_timeout, 5*hz, wpi_tx_timeout, sc);
2129
2130                 if (sc->qfullmsk != 0 &&
2131                     ring->queued < WPI_TX_RING_LOMARK) {
2132                         sc->qfullmsk &= ~(1 << ring->qid);
2133                         IF_LOCK(&ifp->if_snd);
2134                         if (sc->qfullmsk == 0 &&
2135                             (ifp->if_drv_flags & IFF_DRV_OACTIVE)) {
2136                                 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
2137                                 IF_UNLOCK(&ifp->if_snd);
2138                                 ieee80211_runtask(ic, &sc->sc_start_task);
2139                         } else
2140                                 IF_UNLOCK(&ifp->if_snd);
2141                 }
2142         } else
2143                 callout_stop(&sc->tx_timeout);
2144         WPI_TXQ_STATE_UNLOCK(sc);
2145
2146         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
2147 }
2148
2149 /*
2150  * Process a "command done" firmware notification.  This is where we wakeup
2151  * processes waiting for a synchronous command completion.
2152  */
2153 static void
2154 wpi_cmd_done(struct wpi_softc *sc, struct wpi_rx_desc *desc)
2155 {
2156         struct wpi_tx_ring *ring = &sc->txq[WPI_CMD_QUEUE_NUM];
2157         struct wpi_tx_data *data;
2158
2159         DPRINTF(sc, WPI_DEBUG_CMD, "cmd notification qid %x idx %d flags %x "
2160                                    "type %s len %d\n", desc->qid, desc->idx,
2161                                    desc->flags, wpi_cmd_str(desc->type),
2162                                    le32toh(desc->len));
2163
2164         if ((desc->qid & WPI_RX_DESC_QID_MSK) != WPI_CMD_QUEUE_NUM)
2165                 return; /* Not a command ack. */
2166
2167         KASSERT(ring->queued == 0, ("ring->queued must be 0"));
2168
2169         data = &ring->data[desc->idx];
2170
2171         /* If the command was mapped in an mbuf, free it. */
2172         if (data->m != NULL) {
2173                 bus_dmamap_sync(ring->data_dmat, data->map,
2174                     BUS_DMASYNC_POSTWRITE);
2175                 bus_dmamap_unload(ring->data_dmat, data->map);
2176                 m_freem(data->m);
2177                 data->m = NULL;
2178         }
2179
2180         wakeup(&ring->cmd[desc->idx]);
2181
2182         if (desc->type == WPI_CMD_SET_POWER_MODE) {
2183                 WPI_TXQ_LOCK(sc);
2184                 if (sc->sc_flags & WPI_PS_PATH) {
2185                         sc->sc_update_rx_ring = wpi_update_rx_ring_ps;
2186                         sc->sc_update_tx_ring = wpi_update_tx_ring_ps;
2187                 } else {
2188                         sc->sc_update_rx_ring = wpi_update_rx_ring;
2189                         sc->sc_update_tx_ring = wpi_update_tx_ring;
2190                 }
2191                 WPI_TXQ_UNLOCK(sc);
2192         }
2193 }
2194
2195 static void
2196 wpi_notif_intr(struct wpi_softc *sc)
2197 {
2198         struct ifnet *ifp = sc->sc_ifp;
2199         struct ieee80211com *ic = ifp->if_l2com;
2200         struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
2201         uint32_t hw;
2202
2203         bus_dmamap_sync(sc->shared_dma.tag, sc->shared_dma.map,
2204             BUS_DMASYNC_POSTREAD);
2205
2206         hw = le32toh(sc->shared->next) & 0xfff;
2207         hw = (hw == 0) ? WPI_RX_RING_COUNT - 1 : hw - 1;
2208
2209         while (sc->rxq.cur != hw) {
2210                 sc->rxq.cur = (sc->rxq.cur + 1) % WPI_RX_RING_COUNT;
2211
2212                 struct wpi_rx_data *data = &sc->rxq.data[sc->rxq.cur];
2213                 struct wpi_rx_desc *desc;
2214
2215                 bus_dmamap_sync(sc->rxq.data_dmat, data->map,
2216                     BUS_DMASYNC_POSTREAD);
2217                 desc = mtod(data->m, struct wpi_rx_desc *);
2218
2219                 DPRINTF(sc, WPI_DEBUG_NOTIFY,
2220                     "%s: cur=%d; qid %x idx %d flags %x type %d(%s) len %d\n",
2221                     __func__, sc->rxq.cur, desc->qid, desc->idx, desc->flags,
2222                     desc->type, wpi_cmd_str(desc->type), le32toh(desc->len));
2223
2224                 if (!(desc->qid & WPI_UNSOLICITED_RX_NOTIF)) {
2225                         /* Reply to a command. */
2226                         wpi_cmd_done(sc, desc);
2227                 }
2228
2229                 switch (desc->type) {
2230                 case WPI_RX_DONE:
2231                         /* An 802.11 frame has been received. */
2232                         wpi_rx_done(sc, desc, data);
2233
2234                         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
2235                                 /* wpi_stop() was called. */
2236                                 return;
2237                         }
2238
2239                         break;
2240
2241                 case WPI_TX_DONE:
2242                         /* An 802.11 frame has been transmitted. */
2243                         wpi_tx_done(sc, desc);
2244                         break;
2245
2246                 case WPI_RX_STATISTICS:
2247                 case WPI_BEACON_STATISTICS:
2248                         wpi_rx_statistics(sc, desc, data);
2249                         break;
2250
2251                 case WPI_BEACON_MISSED:
2252                 {
2253                         struct wpi_beacon_missed *miss =
2254                             (struct wpi_beacon_missed *)(desc + 1);
2255                         uint32_t expected, misses, received, threshold;
2256
2257                         bus_dmamap_sync(sc->rxq.data_dmat, data->map,
2258                             BUS_DMASYNC_POSTREAD);
2259
2260                         misses = le32toh(miss->consecutive);
2261                         expected = le32toh(miss->expected);
2262                         received = le32toh(miss->received);
2263                         threshold = MAX(2, vap->iv_bmissthreshold);
2264
2265                         DPRINTF(sc, WPI_DEBUG_BMISS,
2266                             "%s: beacons missed %u(%u) (received %u/%u)\n",
2267                             __func__, misses, le32toh(miss->total), received,
2268                             expected);
2269
2270                         if (misses >= threshold ||
2271                             (received == 0 && expected >= threshold)) {
2272                                 WPI_RXON_LOCK(sc);
2273                                 if (callout_pending(&sc->scan_timeout)) {
2274                                         wpi_cmd(sc, WPI_CMD_SCAN_ABORT, NULL,
2275                                             0, 1);
2276                                 }
2277                                 WPI_RXON_UNLOCK(sc);
2278                                 if (vap->iv_state == IEEE80211_S_RUN &&
2279                                     (ic->ic_flags & IEEE80211_F_SCAN) == 0)
2280                                         ieee80211_beacon_miss(ic);
2281                         }
2282
2283                         break;
2284                 }
2285 #ifdef WPI_DEBUG
2286                 case WPI_BEACON_SENT:
2287                 {
2288                         struct wpi_tx_stat *stat =
2289                             (struct wpi_tx_stat *)(desc + 1);
2290                         uint64_t *tsf = (uint64_t *)(stat + 1);
2291                         uint32_t *mode = (uint32_t *)(tsf + 1);
2292
2293                         bus_dmamap_sync(sc->rxq.data_dmat, data->map,
2294                             BUS_DMASYNC_POSTREAD);
2295
2296                         DPRINTF(sc, WPI_DEBUG_BEACON,
2297                             "beacon sent: rts %u, ack %u, btkill %u, rate %u, "
2298                             "duration %u, status %x, tsf %ju, mode %x\n",
2299                             stat->rtsfailcnt, stat->ackfailcnt,
2300                             stat->btkillcnt, stat->rate, le32toh(stat->duration),
2301                             le32toh(stat->status), *tsf, *mode);
2302
2303                         break;
2304                 }
2305 #endif
2306                 case WPI_UC_READY:
2307                 {
2308                         struct wpi_ucode_info *uc =
2309                             (struct wpi_ucode_info *)(desc + 1);
2310
2311                         /* The microcontroller is ready. */
2312                         bus_dmamap_sync(sc->rxq.data_dmat, data->map,
2313                             BUS_DMASYNC_POSTREAD);
2314                         DPRINTF(sc, WPI_DEBUG_RESET,
2315                             "microcode alive notification version=%d.%d "
2316                             "subtype=%x alive=%x\n", uc->major, uc->minor,
2317                             uc->subtype, le32toh(uc->valid));
2318
2319                         if (le32toh(uc->valid) != 1) {
2320                                 device_printf(sc->sc_dev,
2321                                     "microcontroller initialization failed\n");
2322                                 wpi_stop_locked(sc);
2323                         }
2324                         /* Save the address of the error log in SRAM. */
2325                         sc->errptr = le32toh(uc->errptr);
2326                         break;
2327                 }
2328                 case WPI_STATE_CHANGED:
2329                 {
2330                         bus_dmamap_sync(sc->rxq.data_dmat, data->map,
2331                             BUS_DMASYNC_POSTREAD);
2332
2333                         uint32_t *status = (uint32_t *)(desc + 1);
2334
2335                         DPRINTF(sc, WPI_DEBUG_STATE, "state changed to %x\n",
2336                             le32toh(*status));
2337
2338                         if (le32toh(*status) & 1) {
2339                                 WPI_NT_LOCK(sc);
2340                                 wpi_clear_node_table(sc);
2341                                 WPI_NT_UNLOCK(sc);
2342                                 taskqueue_enqueue(sc->sc_tq,
2343                                     &sc->sc_radiooff_task);
2344                                 return;
2345                         }
2346                         break;
2347                 }
2348 #ifdef WPI_DEBUG
2349                 case WPI_START_SCAN:
2350                 {
2351                         bus_dmamap_sync(sc->rxq.data_dmat, data->map,
2352                             BUS_DMASYNC_POSTREAD);
2353
2354                         struct wpi_start_scan *scan =
2355                             (struct wpi_start_scan *)(desc + 1);
2356                         DPRINTF(sc, WPI_DEBUG_SCAN,
2357                             "%s: scanning channel %d status %x\n",
2358                             __func__, scan->chan, le32toh(scan->status));
2359
2360                         break;
2361                 }
2362 #endif
2363                 case WPI_STOP_SCAN:
2364                 {
2365                         bus_dmamap_sync(sc->rxq.data_dmat, data->map,
2366                             BUS_DMASYNC_POSTREAD);
2367
2368                         struct wpi_stop_scan *scan =
2369                             (struct wpi_stop_scan *)(desc + 1);
2370
2371                         DPRINTF(sc, WPI_DEBUG_SCAN,
2372                             "scan finished nchan=%d status=%d chan=%d\n",
2373                             scan->nchan, scan->status, scan->chan);
2374
2375                         WPI_RXON_LOCK(sc);
2376                         callout_stop(&sc->scan_timeout);
2377                         WPI_RXON_UNLOCK(sc);
2378                         if (scan->status == WPI_SCAN_ABORTED)
2379                                 ieee80211_cancel_scan(vap);
2380                         else
2381                                 ieee80211_scan_next(vap);
2382                         break;
2383                 }
2384                 }
2385
2386                 if (sc->rxq.cur % 8 == 0) {
2387                         /* Tell the firmware what we have processed. */
2388                         sc->sc_update_rx_ring(sc);
2389                 }
2390         }
2391 }
2392
2393 /*
2394  * Process an INT_WAKEUP interrupt raised when the microcontroller wakes up
2395  * from power-down sleep mode.
2396  */
2397 static void
2398 wpi_wakeup_intr(struct wpi_softc *sc)
2399 {
2400         int qid;
2401
2402         DPRINTF(sc, WPI_DEBUG_PWRSAVE,
2403             "%s: ucode wakeup from power-down sleep\n", __func__);
2404
2405         /* Wakeup RX and TX rings. */
2406         if (sc->rxq.update) {
2407                 sc->rxq.update = 0;
2408                 wpi_update_rx_ring(sc);
2409         }
2410         WPI_TXQ_LOCK(sc);
2411         for (qid = 0; qid < WPI_DRV_NTXQUEUES; qid++) {
2412                 struct wpi_tx_ring *ring = &sc->txq[qid];
2413
2414                 if (ring->update) {
2415                         ring->update = 0;
2416                         wpi_update_tx_ring(sc, ring);
2417                 }
2418         }
2419         WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ);
2420         WPI_TXQ_UNLOCK(sc);
2421 }
2422
2423 /*
2424  * This function prints firmware registers
2425  */
2426 #ifdef WPI_DEBUG
2427 static void
2428 wpi_debug_registers(struct wpi_softc *sc)
2429 {
2430         size_t i;
2431         static const uint32_t csr_tbl[] = {
2432                 WPI_HW_IF_CONFIG,
2433                 WPI_INT,
2434                 WPI_INT_MASK,
2435                 WPI_FH_INT,
2436                 WPI_GPIO_IN,
2437                 WPI_RESET,
2438                 WPI_GP_CNTRL,
2439                 WPI_EEPROM,
2440                 WPI_EEPROM_GP,
2441                 WPI_GIO,
2442                 WPI_UCODE_GP1,
2443                 WPI_UCODE_GP2,
2444                 WPI_GIO_CHICKEN,
2445                 WPI_ANA_PLL,
2446                 WPI_DBG_HPET_MEM,
2447         };
2448         static const uint32_t prph_tbl[] = {
2449                 WPI_APMG_CLK_CTRL,
2450                 WPI_APMG_PS,
2451                 WPI_APMG_PCI_STT,
2452                 WPI_APMG_RFKILL,
2453         };
2454
2455         DPRINTF(sc, WPI_DEBUG_REGISTER,"%s","\n");
2456
2457         for (i = 0; i < nitems(csr_tbl); i++) {
2458                 DPRINTF(sc, WPI_DEBUG_REGISTER, "  %-18s: 0x%08x ",
2459                     wpi_get_csr_string(csr_tbl[i]), WPI_READ(sc, csr_tbl[i]));
2460
2461                 if ((i + 1) % 2 == 0)
2462                         DPRINTF(sc, WPI_DEBUG_REGISTER, "\n");
2463         }
2464         DPRINTF(sc, WPI_DEBUG_REGISTER, "\n\n");
2465
2466         if (wpi_nic_lock(sc) == 0) {
2467                 for (i = 0; i < nitems(prph_tbl); i++) {
2468                         DPRINTF(sc, WPI_DEBUG_REGISTER, "  %-18s: 0x%08x ",
2469                             wpi_get_prph_string(prph_tbl[i]),
2470                             wpi_prph_read(sc, prph_tbl[i]));
2471
2472                         if ((i + 1) % 2 == 0)
2473                                 DPRINTF(sc, WPI_DEBUG_REGISTER, "\n");
2474                 }
2475                 DPRINTF(sc, WPI_DEBUG_REGISTER, "\n");
2476                 wpi_nic_unlock(sc);
2477         } else {
2478                 DPRINTF(sc, WPI_DEBUG_REGISTER,
2479                     "Cannot access internal registers.\n");
2480         }
2481 }
2482 #endif
2483
2484 /*
2485  * Dump the error log of the firmware when a firmware panic occurs.  Although
2486  * we can't debug the firmware because it is neither open source nor free, it
2487  * can help us to identify certain classes of problems.
2488  */
2489 static void
2490 wpi_fatal_intr(struct wpi_softc *sc)
2491 {
2492         struct wpi_fw_dump dump;
2493         uint32_t i, offset, count;
2494
2495         /* Check that the error log address is valid. */
2496         if (sc->errptr < WPI_FW_DATA_BASE ||
2497             sc->errptr + sizeof (dump) >
2498             WPI_FW_DATA_BASE + WPI_FW_DATA_MAXSZ) {
2499                 printf("%s: bad firmware error log address 0x%08x\n", __func__,
2500                     sc->errptr);
2501                 return;
2502         }
2503         if (wpi_nic_lock(sc) != 0) {
2504                 printf("%s: could not read firmware error log\n", __func__);
2505                 return;
2506         }
2507         /* Read number of entries in the log. */
2508         count = wpi_mem_read(sc, sc->errptr);
2509         if (count == 0 || count * sizeof (dump) > WPI_FW_DATA_MAXSZ) {
2510                 printf("%s: invalid count field (count = %u)\n", __func__,
2511                     count);
2512                 wpi_nic_unlock(sc);
2513                 return;
2514         }
2515         /* Skip "count" field. */
2516         offset = sc->errptr + sizeof (uint32_t);
2517         printf("firmware error log (count = %u):\n", count);
2518         for (i = 0; i < count; i++) {
2519                 wpi_mem_read_region_4(sc, offset, (uint32_t *)&dump,
2520                     sizeof (dump) / sizeof (uint32_t));
2521
2522                 printf("  error type = \"%s\" (0x%08X)\n",
2523                     (dump.desc < nitems(wpi_fw_errmsg)) ?
2524                         wpi_fw_errmsg[dump.desc] : "UNKNOWN",
2525                     dump.desc);
2526                 printf("  error data      = 0x%08X\n",
2527                     dump.data);
2528                 printf("  branch link     = 0x%08X%08X\n",
2529                     dump.blink[0], dump.blink[1]);
2530                 printf("  interrupt link  = 0x%08X%08X\n",
2531                     dump.ilink[0], dump.ilink[1]);
2532                 printf("  time            = %u\n", dump.time);
2533
2534                 offset += sizeof (dump);
2535         }
2536         wpi_nic_unlock(sc);
2537         /* Dump driver status (TX and RX rings) while we're here. */
2538         printf("driver status:\n");
2539         WPI_TXQ_LOCK(sc);
2540         for (i = 0; i < WPI_DRV_NTXQUEUES; i++) {
2541                 struct wpi_tx_ring *ring = &sc->txq[i];
2542                 printf("  tx ring %2d: qid=%-2d cur=%-3d queued=%-3d\n",
2543                     i, ring->qid, ring->cur, ring->queued);
2544         }
2545         WPI_TXQ_UNLOCK(sc);
2546         printf("  rx ring: cur=%d\n", sc->rxq.cur);
2547 }
2548
2549 static void
2550 wpi_intr(void *arg)
2551 {
2552         struct wpi_softc *sc = arg;
2553         struct ifnet *ifp = sc->sc_ifp;
2554         uint32_t r1, r2;
2555
2556         WPI_LOCK(sc);
2557
2558         /* Disable interrupts. */
2559         WPI_WRITE(sc, WPI_INT_MASK, 0);
2560
2561         r1 = WPI_READ(sc, WPI_INT);
2562
2563         if (r1 == 0xffffffff || (r1 & 0xfffffff0) == 0xa5a5a5a0)
2564                 goto end;       /* Hardware gone! */
2565
2566         r2 = WPI_READ(sc, WPI_FH_INT);
2567
2568         DPRINTF(sc, WPI_DEBUG_INTR, "%s: reg1=0x%08x reg2=0x%08x\n", __func__,
2569             r1, r2);
2570
2571         if (r1 == 0 && r2 == 0)
2572                 goto done;      /* Interrupt not for us. */
2573
2574         /* Acknowledge interrupts. */
2575         WPI_WRITE(sc, WPI_INT, r1);
2576         WPI_WRITE(sc, WPI_FH_INT, r2);
2577
2578         if (r1 & (WPI_INT_SW_ERR | WPI_INT_HW_ERR)) {
2579                 device_printf(sc->sc_dev, "fatal firmware error\n");
2580 #ifdef WPI_DEBUG
2581                 wpi_debug_registers(sc);
2582 #endif
2583                 wpi_fatal_intr(sc);
2584                 DPRINTF(sc, WPI_DEBUG_HW,
2585                     "(%s)\n", (r1 & WPI_INT_SW_ERR) ? "(Software Error)" :
2586                     "(Hardware Error)");
2587                 taskqueue_enqueue(sc->sc_tq, &sc->sc_reinittask);
2588                 goto end;
2589         }
2590
2591         if ((r1 & (WPI_INT_FH_RX | WPI_INT_SW_RX)) ||
2592             (r2 & WPI_FH_INT_RX))
2593                 wpi_notif_intr(sc);
2594
2595         if (r1 & WPI_INT_ALIVE)
2596                 wakeup(sc);     /* Firmware is alive. */
2597
2598         if (r1 & WPI_INT_WAKEUP)
2599                 wpi_wakeup_intr(sc);
2600
2601 done:
2602         /* Re-enable interrupts. */
2603         if (ifp->if_flags & IFF_UP)
2604                 WPI_WRITE(sc, WPI_INT_MASK, WPI_INT_MASK_DEF);
2605
2606 end:    WPI_UNLOCK(sc);
2607 }
2608
2609 static int
2610 wpi_cmd2(struct wpi_softc *sc, struct wpi_buf *buf)
2611 {
2612         struct ifnet *ifp = sc->sc_ifp;
2613         struct ieee80211_frame *wh;
2614         struct wpi_tx_cmd *cmd;
2615         struct wpi_tx_data *data;
2616         struct wpi_tx_desc *desc;
2617         struct wpi_tx_ring *ring;
2618         struct mbuf *m1;
2619         bus_dma_segment_t *seg, segs[WPI_MAX_SCATTER];
2620         int error, i, hdrlen, nsegs, totlen, pad;
2621
2622         WPI_TXQ_LOCK(sc);
2623
2624         KASSERT(buf->size <= sizeof(buf->data), ("buffer overflow"));
2625
2626         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
2627
2628         if (sc->txq_active == 0) {
2629                 /* wpi_stop() was called */
2630                 error = ENETDOWN;
2631                 goto fail;
2632         }
2633
2634         wh = mtod(buf->m, struct ieee80211_frame *);
2635         hdrlen = ieee80211_anyhdrsize(wh);
2636         totlen = buf->m->m_pkthdr.len;
2637
2638         if (hdrlen & 3) {
2639                 /* First segment length must be a multiple of 4. */
2640                 pad = 4 - (hdrlen & 3);
2641         } else
2642                 pad = 0;
2643
2644         ring = &sc->txq[buf->ac];
2645         desc = &ring->desc[ring->cur];
2646         data = &ring->data[ring->cur];
2647
2648         /* Prepare TX firmware command. */
2649         cmd = &ring->cmd[ring->cur];
2650         cmd->code = buf->code;
2651         cmd->flags = 0;
2652         cmd->qid = ring->qid;
2653         cmd->idx = ring->cur;
2654
2655         memcpy(cmd->data, buf->data, buf->size);
2656
2657         /* Save and trim IEEE802.11 header. */
2658         memcpy((uint8_t *)(cmd->data + buf->size), wh, hdrlen);
2659         m_adj(buf->m, hdrlen);
2660
2661         error = bus_dmamap_load_mbuf_sg(ring->data_dmat, data->map, buf->m,
2662             segs, &nsegs, BUS_DMA_NOWAIT);
2663         if (error != 0 && error != EFBIG) {
2664                 device_printf(sc->sc_dev,
2665                     "%s: can't map mbuf (error %d)\n", __func__, error);
2666                 goto fail;
2667         }
2668         if (error != 0) {
2669                 /* Too many DMA segments, linearize mbuf. */
2670                 m1 = m_collapse(buf->m, M_NOWAIT, WPI_MAX_SCATTER - 1);
2671                 if (m1 == NULL) {
2672                         device_printf(sc->sc_dev,
2673                             "%s: could not defrag mbuf\n", __func__);
2674                         error = ENOBUFS;
2675                         goto fail;
2676                 }
2677                 buf->m = m1;
2678
2679                 error = bus_dmamap_load_mbuf_sg(ring->data_dmat, data->map,
2680                     buf->m, segs, &nsegs, BUS_DMA_NOWAIT);
2681                 if (error != 0) {
2682                         device_printf(sc->sc_dev,
2683                             "%s: can't map mbuf (error %d)\n", __func__,
2684                             error);
2685                         goto fail;
2686                 }
2687         }
2688
2689         KASSERT(nsegs < WPI_MAX_SCATTER,
2690             ("too many DMA segments, nsegs (%d) should be less than %d",
2691              nsegs, WPI_MAX_SCATTER));
2692
2693         data->m = buf->m;
2694         data->ni = buf->ni;
2695
2696         DPRINTF(sc, WPI_DEBUG_XMIT, "%s: qid %d idx %d len %d nsegs %d\n",
2697             __func__, ring->qid, ring->cur, totlen, nsegs);
2698
2699         /* Fill TX descriptor. */
2700         desc->nsegs = WPI_PAD32(totlen + pad) << 4 | (1 + nsegs);
2701         /* First DMA segment is used by the TX command. */
2702         desc->segs[0].addr = htole32(data->cmd_paddr);
2703         desc->segs[0].len  = htole32(4 + buf->size + hdrlen + pad);
2704         /* Other DMA segments are for data payload. */
2705         seg = &segs[0];
2706         for (i = 1; i <= nsegs; i++) {
2707                 desc->segs[i].addr = htole32(seg->ds_addr);
2708                 desc->segs[i].len  = htole32(seg->ds_len);
2709                 seg++;
2710         }
2711
2712         bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_PREWRITE);
2713         bus_dmamap_sync(ring->data_dmat, ring->cmd_dma.map,
2714             BUS_DMASYNC_PREWRITE);
2715         bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map,
2716             BUS_DMASYNC_PREWRITE);
2717
2718         /* Kick TX ring. */
2719         ring->cur = (ring->cur + 1) % WPI_TX_RING_COUNT;
2720         sc->sc_update_tx_ring(sc, ring);
2721
2722         if (ring->qid < WPI_CMD_QUEUE_NUM) {
2723                 /* Mark TX ring as full if we reach a certain threshold. */
2724                 WPI_TXQ_STATE_LOCK(sc);
2725                 if (++ring->queued > WPI_TX_RING_HIMARK) {
2726                         sc->qfullmsk |= 1 << ring->qid;
2727
2728                         IF_LOCK(&ifp->if_snd);
2729                         ifp->if_drv_flags |= IFF_DRV_OACTIVE;
2730                         IF_UNLOCK(&ifp->if_snd);
2731                 }
2732
2733                 callout_reset(&sc->tx_timeout, 5*hz, wpi_tx_timeout, sc);
2734                 WPI_TXQ_STATE_UNLOCK(sc);
2735         }
2736
2737         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
2738
2739         WPI_TXQ_UNLOCK(sc);
2740
2741         return 0;
2742
2743 fail:   m_freem(buf->m);
2744
2745         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__);
2746
2747         WPI_TXQ_UNLOCK(sc);
2748
2749         return error;
2750 }
2751
2752 /*
2753  * Construct the data packet for a transmit buffer.
2754  */
2755 static int
2756 wpi_tx_data(struct wpi_softc *sc, struct mbuf *m, struct ieee80211_node *ni)
2757 {
2758         const struct ieee80211_txparam *tp;
2759         struct ieee80211vap *vap = ni->ni_vap;
2760         struct ieee80211com *ic = ni->ni_ic;
2761         struct wpi_node *wn = WPI_NODE(ni);
2762         struct ieee80211_channel *chan;
2763         struct ieee80211_frame *wh;
2764         struct ieee80211_key *k = NULL;
2765         struct wpi_buf tx_data;
2766         struct wpi_cmd_data *tx = (struct wpi_cmd_data *)&tx_data.data;
2767         uint32_t flags;
2768         uint16_t qos;
2769         uint8_t tid, type;
2770         int ac, error, swcrypt, rate, ismcast, totlen;
2771
2772         wh = mtod(m, struct ieee80211_frame *);
2773         type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
2774         ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1);
2775
2776         /* Select EDCA Access Category and TX ring for this frame. */
2777         if (IEEE80211_QOS_HAS_SEQ(wh)) {
2778                 qos = ((const struct ieee80211_qosframe *)wh)->i_qos[0];
2779                 tid = qos & IEEE80211_QOS_TID;
2780         } else {
2781                 qos = 0;
2782                 tid = 0;
2783         }
2784         ac = M_WME_GETAC(m);
2785
2786         chan = (ni->ni_chan != IEEE80211_CHAN_ANYC) ?
2787                 ni->ni_chan : ic->ic_curchan;
2788         tp = &vap->iv_txparms[ieee80211_chan2mode(chan)];
2789
2790         /* Choose a TX rate index. */
2791         if (type == IEEE80211_FC0_TYPE_MGT)
2792                 rate = tp->mgmtrate;
2793         else if (ismcast)
2794                 rate = tp->mcastrate;
2795         else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
2796                 rate = tp->ucastrate;
2797         else if (m->m_flags & M_EAPOL)
2798                 rate = tp->mgmtrate;
2799         else {
2800                 /* XXX pass pktlen */
2801                 (void) ieee80211_ratectl_rate(ni, NULL, 0);
2802                 rate = ni->ni_txrate;
2803         }
2804
2805         /* Encrypt the frame if need be. */
2806         if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
2807                 /* Retrieve key for TX. */
2808                 k = ieee80211_crypto_encap(ni, m);
2809                 if (k == NULL) {
2810                         error = ENOBUFS;
2811                         goto fail;
2812                 }
2813                 swcrypt = k->wk_flags & IEEE80211_KEY_SWCRYPT;
2814
2815                 /* 802.11 header may have moved. */
2816                 wh = mtod(m, struct ieee80211_frame *);
2817         }
2818         totlen = m->m_pkthdr.len;
2819
2820         if (ieee80211_radiotap_active_vap(vap)) {
2821                 struct wpi_tx_radiotap_header *tap = &sc->sc_txtap;
2822
2823                 tap->wt_flags = 0;
2824                 tap->wt_rate = rate;
2825                 if (k != NULL)
2826                         tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP;
2827
2828                 ieee80211_radiotap_tx(vap, m);
2829         }
2830
2831         flags = 0;
2832         if (!ismcast) {
2833                 /* Unicast frame, check if an ACK is expected. */
2834                 if (!qos || (qos & IEEE80211_QOS_ACKPOLICY) !=
2835                     IEEE80211_QOS_ACKPOLICY_NOACK)
2836                         flags |= WPI_TX_NEED_ACK;
2837         }
2838
2839         if (!IEEE80211_QOS_HAS_SEQ(wh))
2840                 flags |= WPI_TX_AUTO_SEQ;
2841         if (wh->i_fc[1] & IEEE80211_FC1_MORE_FRAG)
2842                 flags |= WPI_TX_MORE_FRAG;      /* Cannot happen yet. */
2843
2844         /* Check if frame must be protected using RTS/CTS or CTS-to-self. */
2845         if (!ismcast) {
2846                 /* NB: Group frames are sent using CCK in 802.11b/g. */
2847                 if (totlen + IEEE80211_CRC_LEN > vap->iv_rtsthreshold) {
2848                         flags |= WPI_TX_NEED_RTS;
2849                 } else if ((ic->ic_flags & IEEE80211_F_USEPROT) &&
2850                     WPI_RATE_IS_OFDM(rate)) {
2851                         if (ic->ic_protmode == IEEE80211_PROT_CTSONLY)
2852                                 flags |= WPI_TX_NEED_CTS;
2853                         else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS)
2854                                 flags |= WPI_TX_NEED_RTS;
2855                 }
2856
2857                 if (flags & (WPI_TX_NEED_RTS | WPI_TX_NEED_CTS))
2858                         flags |= WPI_TX_FULL_TXOP;
2859         }
2860
2861         memset(tx, 0, sizeof (struct wpi_cmd_data));
2862         if (type == IEEE80211_FC0_TYPE_MGT) {
2863                 uint8_t subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
2864
2865                 /* Tell HW to set timestamp in probe responses. */
2866                 if (subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP)
2867                         flags |= WPI_TX_INSERT_TSTAMP;
2868                 if (subtype == IEEE80211_FC0_SUBTYPE_ASSOC_REQ ||
2869                     subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ)
2870                         tx->timeout = htole16(3);
2871                 else
2872                         tx->timeout = htole16(2);
2873         }
2874
2875         if (ismcast || type != IEEE80211_FC0_TYPE_DATA)
2876                 tx->id = WPI_ID_BROADCAST;
2877         else {
2878                 if (wn->id == WPI_ID_UNDEFINED) {
2879                         device_printf(sc->sc_dev,
2880                             "%s: undefined node id\n", __func__);
2881                         error = EINVAL;
2882                         goto fail;
2883                 }
2884
2885                 tx->id = wn->id;
2886         }
2887
2888         if (k != NULL && !swcrypt) {
2889                 switch (k->wk_cipher->ic_cipher) {
2890                 case IEEE80211_CIPHER_AES_CCM:
2891                         tx->security = WPI_CIPHER_CCMP;
2892                         break;
2893
2894                 default:
2895                         break;
2896                 }
2897
2898                 memcpy(tx->key, k->wk_key, k->wk_keylen);
2899         }
2900
2901         tx->len = htole16(totlen);
2902         tx->flags = htole32(flags);
2903         tx->plcp = rate2plcp(rate);
2904         tx->tid = tid;
2905         tx->lifetime = htole32(WPI_LIFETIME_INFINITE);
2906         tx->ofdm_mask = 0xff;
2907         tx->cck_mask = 0x0f;
2908         tx->rts_ntries = 7;
2909         tx->data_ntries = tp->maxretry;
2910
2911         tx_data.ni = ni;
2912         tx_data.m = m;
2913         tx_data.size = sizeof(struct wpi_cmd_data);
2914         tx_data.code = WPI_CMD_TX_DATA;
2915         tx_data.ac = ac;
2916
2917         return wpi_cmd2(sc, &tx_data);
2918
2919 fail:   m_freem(m);
2920         return error;
2921 }
2922
2923 static int
2924 wpi_tx_data_raw(struct wpi_softc *sc, struct mbuf *m,
2925     struct ieee80211_node *ni, const struct ieee80211_bpf_params *params)
2926 {
2927         struct ieee80211vap *vap = ni->ni_vap;
2928         struct ieee80211_key *k = NULL;
2929         struct ieee80211_frame *wh;
2930         struct wpi_buf tx_data;
2931         struct wpi_cmd_data *tx = (struct wpi_cmd_data *)&tx_data.data;
2932         uint32_t flags;
2933         uint8_t type;
2934         int ac, rate, swcrypt, totlen;
2935
2936         wh = mtod(m, struct ieee80211_frame *);
2937         type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
2938
2939         ac = params->ibp_pri & 3;
2940
2941         /* Choose a TX rate index. */
2942         rate = params->ibp_rate0;
2943
2944         flags = 0;
2945         if (!IEEE80211_QOS_HAS_SEQ(wh))
2946                 flags |= WPI_TX_AUTO_SEQ;
2947         if ((params->ibp_flags & IEEE80211_BPF_NOACK) == 0)
2948                 flags |= WPI_TX_NEED_ACK;
2949         if (params->ibp_flags & IEEE80211_BPF_RTS)
2950                 flags |= WPI_TX_NEED_RTS;
2951         if (params->ibp_flags & IEEE80211_BPF_CTS)
2952                 flags |= WPI_TX_NEED_CTS;
2953         if (flags & (WPI_TX_NEED_RTS | WPI_TX_NEED_CTS))
2954                 flags |= WPI_TX_FULL_TXOP;
2955
2956         /* Encrypt the frame if need be. */
2957         if (params->ibp_flags & IEEE80211_BPF_CRYPTO) {
2958                 /* Retrieve key for TX. */
2959                 k = ieee80211_crypto_encap(ni, m);
2960                 if (k == NULL) {
2961                         m_freem(m);
2962                         return ENOBUFS;
2963                 }
2964                 swcrypt = k->wk_flags & IEEE80211_KEY_SWCRYPT;
2965
2966                 /* 802.11 header may have moved. */
2967                 wh = mtod(m, struct ieee80211_frame *);
2968         }
2969         totlen = m->m_pkthdr.len;
2970
2971         if (ieee80211_radiotap_active_vap(vap)) {
2972                 struct wpi_tx_radiotap_header *tap = &sc->sc_txtap;
2973
2974                 tap->wt_flags = 0;
2975                 tap->wt_rate = rate;
2976                 if (params->ibp_flags & IEEE80211_BPF_CRYPTO)
2977                         tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP;
2978
2979                 ieee80211_radiotap_tx(vap, m);
2980         }
2981
2982         memset(tx, 0, sizeof (struct wpi_cmd_data));
2983         if (type == IEEE80211_FC0_TYPE_MGT) {
2984                 uint8_t subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
2985
2986                 /* Tell HW to set timestamp in probe responses. */
2987                 if (subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP)
2988                         flags |= WPI_TX_INSERT_TSTAMP;
2989                 if (subtype == IEEE80211_FC0_SUBTYPE_ASSOC_REQ ||
2990                     subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ)
2991                         tx->timeout = htole16(3);
2992                 else
2993                         tx->timeout = htole16(2);
2994         }
2995
2996         if (k != NULL && !swcrypt) {
2997                 switch (k->wk_cipher->ic_cipher) {
2998                 case IEEE80211_CIPHER_AES_CCM:
2999                         tx->security = WPI_CIPHER_CCMP;
3000                         break;
3001
3002                 default:
3003                         break;
3004                 }
3005
3006                 memcpy(tx->key, k->wk_key, k->wk_keylen);
3007         }
3008
3009         tx->len = htole16(totlen);
3010         tx->flags = htole32(flags);
3011         tx->plcp = rate2plcp(rate);
3012         tx->id = WPI_ID_BROADCAST;
3013         tx->lifetime = htole32(WPI_LIFETIME_INFINITE);
3014         tx->rts_ntries = params->ibp_try1;
3015         tx->data_ntries = params->ibp_try0;
3016
3017         tx_data.ni = ni;
3018         tx_data.m = m;
3019         tx_data.size = sizeof(struct wpi_cmd_data);
3020         tx_data.code = WPI_CMD_TX_DATA;
3021         tx_data.ac = ac;
3022
3023         return wpi_cmd2(sc, &tx_data);
3024 }
3025
3026 static int
3027 wpi_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
3028     const struct ieee80211_bpf_params *params)
3029 {
3030         struct ieee80211com *ic = ni->ni_ic;
3031         struct ifnet *ifp = ic->ic_ifp;
3032         struct wpi_softc *sc = ifp->if_softc;
3033         int error = 0;
3034
3035         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
3036
3037         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
3038                 ieee80211_free_node(ni);
3039                 m_freem(m);
3040                 return ENETDOWN;
3041         }
3042
3043         WPI_TX_LOCK(sc);
3044         if (params == NULL) {
3045                 /*
3046                  * Legacy path; interpret frame contents to decide
3047                  * precisely how to send the frame.
3048                  */
3049                 error = wpi_tx_data(sc, m, ni);
3050         } else {
3051                 /*
3052                  * Caller supplied explicit parameters to use in
3053                  * sending the frame.
3054                  */
3055                 error = wpi_tx_data_raw(sc, m, ni, params);
3056         }
3057         WPI_TX_UNLOCK(sc);
3058
3059         if (error != 0) {
3060                 /* NB: m is reclaimed on tx failure */
3061                 ieee80211_free_node(ni);
3062                 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
3063
3064                 DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__);
3065
3066                 return error;
3067         }
3068
3069         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
3070
3071         return 0;
3072 }
3073
3074 /**
3075  * Process data waiting to be sent on the IFNET output queue
3076  */
3077 static void
3078 wpi_start(struct ifnet *ifp)
3079 {
3080         struct wpi_softc *sc = ifp->if_softc;
3081         struct ieee80211_node *ni;
3082         struct mbuf *m;
3083
3084         WPI_TX_LOCK(sc);
3085         DPRINTF(sc, WPI_DEBUG_XMIT, "%s: called\n", __func__);
3086
3087         for (;;) {
3088                 IF_LOCK(&ifp->if_snd);
3089                 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 ||
3090                     (ifp->if_drv_flags & IFF_DRV_OACTIVE)) {
3091                         IF_UNLOCK(&ifp->if_snd);
3092                         break;
3093                 }
3094                 IF_UNLOCK(&ifp->if_snd);
3095
3096                 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
3097                 if (m == NULL)
3098                         break;
3099                 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
3100                 if (wpi_tx_data(sc, m, ni) != 0) {
3101                         ieee80211_free_node(ni);
3102                         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
3103                 }
3104         }
3105
3106         DPRINTF(sc, WPI_DEBUG_XMIT, "%s: done\n", __func__);
3107         WPI_TX_UNLOCK(sc);
3108 }
3109
3110 static void
3111 wpi_start_task(void *arg0, int pending)
3112 {
3113         struct wpi_softc *sc = arg0;
3114         struct ifnet *ifp = sc->sc_ifp;
3115
3116         wpi_start(ifp);
3117 }
3118
3119 static void
3120 wpi_watchdog_rfkill(void *arg)
3121 {
3122         struct wpi_softc *sc = arg;
3123         struct ifnet *ifp = sc->sc_ifp;
3124         struct ieee80211com *ic = ifp->if_l2com;
3125
3126         DPRINTF(sc, WPI_DEBUG_WATCHDOG, "RFkill Watchdog: tick\n");
3127
3128         /* No need to lock firmware memory. */
3129         if ((wpi_prph_read(sc, WPI_APMG_RFKILL) & 0x1) == 0) {
3130                 /* Radio kill switch is still off. */
3131                 callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill,
3132                     sc);
3133         } else
3134                 ieee80211_runtask(ic, &sc->sc_radioon_task);
3135 }
3136
3137 static void
3138 wpi_scan_timeout(void *arg)
3139 {
3140         struct wpi_softc *sc = arg;
3141         struct ifnet *ifp = sc->sc_ifp;
3142
3143         if_printf(ifp, "scan timeout\n");
3144         taskqueue_enqueue(sc->sc_tq, &sc->sc_reinittask);
3145 }
3146
3147 static void
3148 wpi_tx_timeout(void *arg)
3149 {
3150         struct wpi_softc *sc = arg;
3151         struct ifnet *ifp = sc->sc_ifp;
3152
3153         if_printf(ifp, "device timeout\n");
3154         if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
3155         taskqueue_enqueue(sc->sc_tq, &sc->sc_reinittask);
3156 }
3157
3158 static int
3159 wpi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
3160 {
3161         struct wpi_softc *sc = ifp->if_softc;
3162         struct ieee80211com *ic = ifp->if_l2com;
3163         struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
3164         struct ifreq *ifr = (struct ifreq *) data;
3165         int error = 0;
3166
3167         switch (cmd) {
3168         case SIOCGIFADDR:
3169                 error = ether_ioctl(ifp, cmd, data);
3170                 break;
3171         case SIOCSIFFLAGS:
3172                 if (ifp->if_flags & IFF_UP) {
3173                         wpi_init(sc);
3174
3175                         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 &&
3176                             vap != NULL)
3177                                 ieee80211_stop(vap);
3178                 } else if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0)
3179                         wpi_stop(sc);
3180                 break;
3181         case SIOCGIFMEDIA:
3182                 error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd);
3183                 break;
3184         default:
3185                 error = EINVAL;
3186                 break;
3187         }
3188         return error;
3189 }
3190
3191 /*
3192  * Send a command to the firmware.
3193  */
3194 static int
3195 wpi_cmd(struct wpi_softc *sc, int code, const void *buf, size_t size,
3196     int async)
3197 {
3198         struct wpi_tx_ring *ring = &sc->txq[WPI_CMD_QUEUE_NUM];
3199         struct wpi_tx_desc *desc;
3200         struct wpi_tx_data *data;
3201         struct wpi_tx_cmd *cmd;
3202         struct mbuf *m;
3203         bus_addr_t paddr;
3204         int totlen, error;
3205
3206         WPI_TXQ_LOCK(sc);
3207
3208         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
3209
3210         if (sc->txq_active == 0) {
3211                 /* wpi_stop() was called */
3212                 error = 0;
3213                 goto fail;
3214         }
3215
3216         if (async == 0)
3217                 WPI_LOCK_ASSERT(sc);
3218
3219         DPRINTF(sc, WPI_DEBUG_CMD, "%s: cmd %s size %zu async %d\n",
3220             __func__, wpi_cmd_str(code), size, async);
3221
3222         desc = &ring->desc[ring->cur];
3223         data = &ring->data[ring->cur];
3224         totlen = 4 + size;
3225
3226         if (size > sizeof cmd->data) {
3227                 /* Command is too large to fit in a descriptor. */
3228                 if (totlen > MCLBYTES) {
3229                         error = EINVAL;
3230                         goto fail;
3231                 }
3232                 m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
3233                 if (m == NULL) {
3234                         error = ENOMEM;
3235                         goto fail;
3236                 }
3237                 cmd = mtod(m, struct wpi_tx_cmd *);
3238                 error = bus_dmamap_load(ring->data_dmat, data->map, cmd,
3239                     totlen, wpi_dma_map_addr, &paddr, BUS_DMA_NOWAIT);
3240                 if (error != 0) {
3241                         m_freem(m);
3242                         goto fail;
3243                 }
3244                 data->m = m;
3245         } else {
3246                 cmd = &ring->cmd[ring->cur];
3247                 paddr = data->cmd_paddr;
3248         }
3249
3250         cmd->code = code;
3251         cmd->flags = 0;
3252         cmd->qid = ring->qid;
3253         cmd->idx = ring->cur;
3254         memcpy(cmd->data, buf, size);
3255
3256         desc->nsegs = 1 + (WPI_PAD32(size) << 4);
3257         desc->segs[0].addr = htole32(paddr);
3258         desc->segs[0].len  = htole32(totlen);
3259
3260         if (size > sizeof cmd->data) {
3261                 bus_dmamap_sync(ring->data_dmat, data->map,
3262                     BUS_DMASYNC_PREWRITE);
3263         } else {
3264                 bus_dmamap_sync(ring->data_dmat, ring->cmd_dma.map,
3265                     BUS_DMASYNC_PREWRITE);
3266         }
3267         bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map,
3268             BUS_DMASYNC_PREWRITE);
3269
3270         /* Kick command ring. */
3271         ring->cur = (ring->cur + 1) % WPI_TX_RING_COUNT;
3272         sc->sc_update_tx_ring(sc, ring);
3273
3274         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
3275
3276         WPI_TXQ_UNLOCK(sc);
3277
3278         if (async)
3279                 return 0;
3280
3281         return mtx_sleep(cmd, &sc->sc_mtx, PCATCH, "wpicmd", hz);
3282
3283 fail:   DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__);
3284
3285         WPI_TXQ_UNLOCK(sc);
3286
3287         return error;
3288 }
3289
3290 /*
3291  * Configure HW multi-rate retries.
3292  */
3293 static int
3294 wpi_mrr_setup(struct wpi_softc *sc)
3295 {
3296         struct ifnet *ifp = sc->sc_ifp;
3297         struct ieee80211com *ic = ifp->if_l2com;
3298         struct wpi_mrr_setup mrr;
3299         int i, error;
3300
3301         /* CCK rates (not used with 802.11a). */
3302         for (i = WPI_RIDX_CCK1; i <= WPI_RIDX_CCK11; i++) {
3303                 mrr.rates[i].flags = 0;
3304                 mrr.rates[i].plcp = wpi_ridx_to_plcp[i];
3305                 /* Fallback to the immediate lower CCK rate (if any.) */
3306                 mrr.rates[i].next =
3307                     (i == WPI_RIDX_CCK1) ? WPI_RIDX_CCK1 : i - 1;
3308                 /* Try twice at this rate before falling back to "next". */
3309                 mrr.rates[i].ntries = WPI_NTRIES_DEFAULT;
3310         }
3311         /* OFDM rates (not used with 802.11b). */
3312         for (i = WPI_RIDX_OFDM6; i <= WPI_RIDX_OFDM54; i++) {
3313                 mrr.rates[i].flags = 0;
3314                 mrr.rates[i].plcp = wpi_ridx_to_plcp[i];
3315                 /* Fallback to the immediate lower rate (if any.) */
3316                 /* We allow fallback from OFDM/6 to CCK/2 in 11b/g mode. */
3317                 mrr.rates[i].next = (i == WPI_RIDX_OFDM6) ?
3318                     ((ic->ic_curmode == IEEE80211_MODE_11A) ?
3319                         WPI_RIDX_OFDM6 : WPI_RIDX_CCK2) :
3320                     i - 1;
3321                 /* Try twice at this rate before falling back to "next". */
3322                 mrr.rates[i].ntries = WPI_NTRIES_DEFAULT;
3323         }
3324         /* Setup MRR for control frames. */
3325         mrr.which = htole32(WPI_MRR_CTL);
3326         error = wpi_cmd(sc, WPI_CMD_MRR_SETUP, &mrr, sizeof mrr, 0);
3327         if (error != 0) {
3328                 device_printf(sc->sc_dev,
3329                     "could not setup MRR for control frames\n");
3330                 return error;
3331         }
3332         /* Setup MRR for data frames. */
3333         mrr.which = htole32(WPI_MRR_DATA);
3334         error = wpi_cmd(sc, WPI_CMD_MRR_SETUP, &mrr, sizeof mrr, 0);
3335         if (error != 0) {
3336                 device_printf(sc->sc_dev,
3337                     "could not setup MRR for data frames\n");
3338                 return error;
3339         }
3340         return 0;
3341 }
3342
3343 static int
3344 wpi_add_node(struct wpi_softc *sc, struct ieee80211_node *ni)
3345 {
3346         struct ieee80211com *ic = ni->ni_ic;
3347         struct wpi_vap *wvp = WPI_VAP(ni->ni_vap);
3348         struct wpi_node *wn = WPI_NODE(ni);
3349         struct wpi_node_info node;
3350         int error;
3351
3352         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
3353
3354         if (wn->id == WPI_ID_UNDEFINED)
3355                 return EINVAL;
3356
3357         memset(&node, 0, sizeof node);
3358         IEEE80211_ADDR_COPY(node.macaddr, ni->ni_macaddr);
3359         node.id = wn->id;
3360         node.plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ?
3361             wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1];
3362         node.action = htole32(WPI_ACTION_SET_RATE);
3363         node.antenna = WPI_ANTENNA_BOTH;
3364
3365         DPRINTF(sc, WPI_DEBUG_NODE, "%s: adding node %d (%s)\n", __func__,
3366             wn->id, ether_sprintf(ni->ni_macaddr));
3367
3368         error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1);
3369         if (error != 0) {
3370                 device_printf(sc->sc_dev,
3371                     "%s: wpi_cmd() call failed with error code %d\n", __func__,
3372                     error);
3373                 return error;
3374         }
3375
3376         if (wvp->wv_gtk != 0) {
3377                 error = wpi_set_global_keys(ni);
3378                 if (error != 0) {
3379                         device_printf(sc->sc_dev,
3380                             "%s: error while setting global keys\n", __func__);
3381                         return ENXIO;
3382                 }
3383         }
3384
3385         return 0;
3386 }
3387
3388 /*
3389  * Broadcast node is used to send group-addressed and management frames.
3390  */
3391 static int
3392 wpi_add_broadcast_node(struct wpi_softc *sc, int async)
3393 {
3394         struct ifnet *ifp = sc->sc_ifp;
3395         struct ieee80211com *ic = ifp->if_l2com;
3396         struct wpi_node_info node;
3397
3398         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
3399
3400         memset(&node, 0, sizeof node);
3401         IEEE80211_ADDR_COPY(node.macaddr, ifp->if_broadcastaddr);
3402         node.id = WPI_ID_BROADCAST;
3403         node.plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ?
3404             wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1];
3405         node.action = htole32(WPI_ACTION_SET_RATE);
3406         node.antenna = WPI_ANTENNA_BOTH;
3407
3408         DPRINTF(sc, WPI_DEBUG_NODE, "%s: adding broadcast node\n", __func__);
3409
3410         return wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, async);
3411 }
3412
3413 static int
3414 wpi_add_sta_node(struct wpi_softc *sc, struct ieee80211_node *ni)
3415 {
3416         struct wpi_node *wn = WPI_NODE(ni);
3417         int error;
3418
3419         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
3420
3421         wn->id = wpi_add_node_entry_sta(sc);
3422
3423         if ((error = wpi_add_node(sc, ni)) != 0) {
3424                 wpi_del_node_entry(sc, wn->id);
3425                 wn->id = WPI_ID_UNDEFINED;
3426                 return error;
3427         }
3428
3429         return 0;
3430 }
3431
3432 static int
3433 wpi_add_ibss_node(struct wpi_softc *sc, struct ieee80211_node *ni)
3434 {
3435         struct wpi_node *wn = WPI_NODE(ni);
3436         int error;
3437
3438         KASSERT(wn->id == WPI_ID_UNDEFINED,
3439             ("the node %d was added before", wn->id));
3440
3441         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
3442
3443         if ((wn->id = wpi_add_node_entry_adhoc(sc)) == WPI_ID_UNDEFINED) {
3444                 device_printf(sc->sc_dev, "%s: h/w table is full\n", __func__);
3445                 return ENOMEM;
3446         }
3447
3448         if ((error = wpi_add_node(sc, ni)) != 0) {
3449                 wpi_del_node_entry(sc, wn->id);
3450                 wn->id = WPI_ID_UNDEFINED;
3451                 return error;
3452         }
3453
3454         return 0;
3455 }
3456
3457 static void
3458 wpi_del_node(struct wpi_softc *sc, struct ieee80211_node *ni)
3459 {
3460         struct wpi_node *wn = WPI_NODE(ni);
3461         struct wpi_cmd_del_node node;
3462         int error;
3463
3464         KASSERT(wn->id != WPI_ID_UNDEFINED, ("undefined node id passed"));
3465
3466         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
3467
3468         memset(&node, 0, sizeof node);
3469         IEEE80211_ADDR_COPY(node.macaddr, ni->ni_macaddr);
3470         node.count = 1;
3471
3472         DPRINTF(sc, WPI_DEBUG_NODE, "%s: deleting node %d (%s)\n", __func__,
3473             wn->id, ether_sprintf(ni->ni_macaddr));
3474
3475         error = wpi_cmd(sc, WPI_CMD_DEL_NODE, &node, sizeof node, 1);
3476         if (error != 0) {
3477                 device_printf(sc->sc_dev,
3478                     "%s: could not delete node %u, error %d\n", __func__,
3479                     wn->id, error);
3480         }
3481 }
3482
3483 static int
3484 wpi_updateedca(struct ieee80211com *ic)
3485 {
3486 #define WPI_EXP2(x)     ((1 << (x)) - 1)        /* CWmin = 2^ECWmin - 1 */
3487         struct wpi_softc *sc = ic->ic_ifp->if_softc;
3488         struct wpi_edca_params cmd;
3489         int aci, error;
3490
3491         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
3492
3493         memset(&cmd, 0, sizeof cmd);
3494         cmd.flags = htole32(WPI_EDCA_UPDATE);
3495         for (aci = 0; aci < WME_NUM_AC; aci++) {
3496                 const struct wmeParams *ac =
3497                     &ic->ic_wme.wme_chanParams.cap_wmeParams[aci];
3498                 cmd.ac[aci].aifsn = ac->wmep_aifsn;
3499                 cmd.ac[aci].cwmin = htole16(WPI_EXP2(ac->wmep_logcwmin));
3500                 cmd.ac[aci].cwmax = htole16(WPI_EXP2(ac->wmep_logcwmax));
3501                 cmd.ac[aci].txoplimit =
3502                     htole16(IEEE80211_TXOP_TO_US(ac->wmep_txopLimit));
3503
3504                 DPRINTF(sc, WPI_DEBUG_EDCA,
3505                     "setting WME for queue %d aifsn=%d cwmin=%d cwmax=%d "
3506                     "txoplimit=%d\n", aci, cmd.ac[aci].aifsn,
3507                     cmd.ac[aci].cwmin, cmd.ac[aci].cwmax,
3508                     cmd.ac[aci].txoplimit);
3509         }
3510         error = wpi_cmd(sc, WPI_CMD_EDCA_PARAMS, &cmd, sizeof cmd, 1);
3511
3512         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
3513
3514         return error;
3515 #undef WPI_EXP2
3516 }
3517
3518 static void
3519 wpi_set_promisc(struct wpi_softc *sc)
3520 {
3521         struct ifnet *ifp = sc->sc_ifp;
3522         struct ieee80211com *ic = ifp->if_l2com;
3523         struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
3524         uint32_t promisc_filter;
3525
3526         promisc_filter = WPI_FILTER_CTL;
3527         if (vap != NULL && vap->iv_opmode != IEEE80211_M_HOSTAP)
3528                 promisc_filter |= WPI_FILTER_PROMISC;
3529
3530         if (ifp->if_flags & IFF_PROMISC)
3531                 sc->rxon.filter |= htole32(promisc_filter);
3532         else
3533                 sc->rxon.filter &= ~htole32(promisc_filter);
3534 }
3535
3536 static void
3537 wpi_update_promisc(struct ifnet *ifp)
3538 {
3539         struct wpi_softc *sc = ifp->if_softc;
3540
3541         WPI_RXON_LOCK(sc);
3542         wpi_set_promisc(sc);
3543
3544         if (wpi_send_rxon(sc, 1, 1) != 0) {
3545                 device_printf(sc->sc_dev, "%s: could not send RXON\n",
3546                     __func__);
3547         }
3548         WPI_RXON_UNLOCK(sc);
3549 }
3550
3551 static void
3552 wpi_update_mcast(struct ifnet *ifp)
3553 {
3554         /* Ignore */
3555 }
3556
3557 static void
3558 wpi_set_led(struct wpi_softc *sc, uint8_t which, uint8_t off, uint8_t on)
3559 {
3560         struct wpi_cmd_led led;
3561
3562         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
3563
3564         led.which = which;
3565         led.unit = htole32(100000);     /* on/off in unit of 100ms */
3566         led.off = off;
3567         led.on = on;
3568         (void)wpi_cmd(sc, WPI_CMD_SET_LED, &led, sizeof led, 1);
3569 }
3570
3571 static int
3572 wpi_set_timing(struct wpi_softc *sc, struct ieee80211_node *ni)
3573 {
3574         struct wpi_cmd_timing cmd;
3575         uint64_t val, mod;
3576
3577         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
3578
3579         memset(&cmd, 0, sizeof cmd);
3580         memcpy(&cmd.tstamp, ni->ni_tstamp.data, sizeof (uint64_t));
3581         cmd.bintval = htole16(ni->ni_intval);
3582         cmd.lintval = htole16(10);
3583
3584         /* Compute remaining time until next beacon. */
3585         val = (uint64_t)ni->ni_intval * IEEE80211_DUR_TU;
3586         mod = le64toh(cmd.tstamp) % val;
3587         cmd.binitval = htole32((uint32_t)(val - mod));
3588
3589         DPRINTF(sc, WPI_DEBUG_RESET, "timing bintval=%u tstamp=%ju, init=%u\n",
3590             ni->ni_intval, le64toh(cmd.tstamp), (uint32_t)(val - mod));
3591
3592         return wpi_cmd(sc, WPI_CMD_TIMING, &cmd, sizeof cmd, 1);
3593 }
3594
3595 /*
3596  * This function is called periodically (every 60 seconds) to adjust output
3597  * power to temperature changes.
3598  */
3599 static void
3600 wpi_power_calibration(struct wpi_softc *sc)
3601 {
3602         int temp;
3603
3604         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
3605
3606         /* Update sensor data. */
3607         temp = (int)WPI_READ(sc, WPI_UCODE_GP2);
3608         DPRINTF(sc, WPI_DEBUG_TEMP, "Temp in calibration is: %d\n", temp);
3609
3610         /* Sanity-check read value. */
3611         if (temp < -260 || temp > 25) {
3612                 /* This can't be correct, ignore. */
3613                 DPRINTF(sc, WPI_DEBUG_TEMP,
3614                     "out-of-range temperature reported: %d\n", temp);
3615                 return;
3616         }
3617
3618         DPRINTF(sc, WPI_DEBUG_TEMP, "temperature %d->%d\n", sc->temp, temp);
3619
3620         /* Adjust Tx power if need be. */
3621         if (abs(temp - sc->temp) <= 6)
3622                 return;
3623
3624         sc->temp = temp;
3625
3626         if (wpi_set_txpower(sc, 1) != 0) {
3627                 /* just warn, too bad for the automatic calibration... */
3628                 device_printf(sc->sc_dev,"could not adjust Tx power\n");
3629         }
3630 }
3631
3632 /*
3633  * Set TX power for current channel.
3634  */
3635 static int
3636 wpi_set_txpower(struct wpi_softc *sc, int async)
3637 {
3638         struct wpi_power_group *group;
3639         struct wpi_cmd_txpower cmd;
3640         uint8_t chan;
3641         int idx, is_chan_5ghz, i;
3642
3643         /* Retrieve current channel from last RXON. */
3644         chan = sc->rxon.chan;
3645         is_chan_5ghz = (sc->rxon.flags & htole32(WPI_RXON_24GHZ)) == 0;
3646
3647         /* Find the TX power group to which this channel belongs. */
3648         if (is_chan_5ghz) {
3649                 for (group = &sc->groups[1]; group < &sc->groups[4]; group++)
3650                         if (chan <= group->chan)
3651                                 break;
3652         } else
3653                 group = &sc->groups[0];
3654
3655         memset(&cmd, 0, sizeof cmd);
3656         cmd.band = is_chan_5ghz ? WPI_BAND_5GHZ : WPI_BAND_2GHZ;
3657         cmd.chan = htole16(chan);
3658
3659         /* Set TX power for all OFDM and CCK rates. */
3660         for (i = 0; i <= WPI_RIDX_MAX ; i++) {
3661                 /* Retrieve TX power for this channel/rate. */
3662                 idx = wpi_get_power_index(sc, group, chan, is_chan_5ghz, i);
3663
3664                 cmd.rates[i].plcp = wpi_ridx_to_plcp[i];
3665
3666                 if (is_chan_5ghz) {
3667                         cmd.rates[i].rf_gain = wpi_rf_gain_5ghz[idx];
3668                         cmd.rates[i].dsp_gain = wpi_dsp_gain_5ghz[idx];
3669                 } else {
3670                         cmd.rates[i].rf_gain = wpi_rf_gain_2ghz[idx];
3671                         cmd.rates[i].dsp_gain = wpi_dsp_gain_2ghz[idx];
3672                 }
3673                 DPRINTF(sc, WPI_DEBUG_TEMP,
3674                     "chan %d/ridx %d: power index %d\n", chan, i, idx);
3675         }
3676
3677         return wpi_cmd(sc, WPI_CMD_TXPOWER, &cmd, sizeof cmd, async);
3678 }
3679
3680 /*
3681  * Determine Tx power index for a given channel/rate combination.
3682  * This takes into account the regulatory information from EEPROM and the
3683  * current temperature.
3684  */
3685 static int
3686 wpi_get_power_index(struct wpi_softc *sc, struct wpi_power_group *group,
3687     uint8_t chan, int is_chan_5ghz, int ridx)
3688 {
3689 /* Fixed-point arithmetic division using a n-bit fractional part. */
3690 #define fdivround(a, b, n)      \
3691         ((((1 << n) * (a)) / (b) + (1 << n) / 2) / (1 << n))
3692
3693 /* Linear interpolation. */
3694 #define interpolate(x, x1, y1, x2, y2, n)       \
3695         ((y1) + fdivround(((x) - (x1)) * ((y2) - (y1)), (x2) - (x1), n))
3696
3697         struct wpi_power_sample *sample;
3698         int pwr, idx;
3699
3700         /* Default TX power is group maximum TX power minus 3dB. */
3701         pwr = group->maxpwr / 2;
3702
3703         /* Decrease TX power for highest OFDM rates to reduce distortion. */
3704         switch (ridx) {
3705         case WPI_RIDX_OFDM36:
3706                 pwr -= is_chan_5ghz ?  5 : 0;
3707                 break;
3708         case WPI_RIDX_OFDM48:
3709                 pwr -= is_chan_5ghz ? 10 : 7;
3710                 break;
3711         case WPI_RIDX_OFDM54:
3712                 pwr -= is_chan_5ghz ? 12 : 9;
3713                 break;
3714         }
3715
3716         /* Never exceed the channel maximum allowed TX power. */
3717         pwr = min(pwr, sc->maxpwr[chan]);
3718
3719         /* Retrieve TX power index into gain tables from samples. */
3720         for (sample = group->samples; sample < &group->samples[3]; sample++)
3721                 if (pwr > sample[1].power)
3722                         break;
3723         /* Fixed-point linear interpolation using a 19-bit fractional part. */
3724         idx = interpolate(pwr, sample[0].power, sample[0].index,
3725             sample[1].power, sample[1].index, 19);
3726
3727         /*-
3728          * Adjust power index based on current temperature:
3729          * - if cooler than factory-calibrated: decrease output power
3730          * - if warmer than factory-calibrated: increase output power
3731          */
3732         idx -= (sc->temp - group->temp) * 11 / 100;
3733
3734         /* Decrease TX power for CCK rates (-5dB). */
3735         if (ridx >= WPI_RIDX_CCK1)
3736                 idx += 10;
3737
3738         /* Make sure idx stays in a valid range. */
3739         if (idx < 0)
3740                 return 0;
3741         if (idx > WPI_MAX_PWR_INDEX)
3742                 return WPI_MAX_PWR_INDEX;
3743         return idx;
3744
3745 #undef interpolate
3746 #undef fdivround
3747 }
3748
3749 /*
3750  * Set STA mode power saving level (between 0 and 5).
3751  * Level 0 is CAM (Continuously Aware Mode), 5 is for maximum power saving.
3752  */
3753 static int
3754 wpi_set_pslevel(struct wpi_softc *sc, uint8_t dtim, int level, int async)
3755 {
3756         struct wpi_pmgt_cmd cmd;
3757         const struct wpi_pmgt *pmgt;
3758         uint32_t max, skip_dtim;
3759         uint32_t reg;
3760         int i;
3761
3762         DPRINTF(sc, WPI_DEBUG_PWRSAVE,
3763             "%s: dtim=%d, level=%d, async=%d\n",
3764             __func__, dtim, level, async);
3765
3766         /* Select which PS parameters to use. */
3767         if (dtim <= 10)
3768                 pmgt = &wpi_pmgt[0][level];
3769         else
3770                 pmgt = &wpi_pmgt[1][level];
3771
3772         memset(&cmd, 0, sizeof cmd);
3773         WPI_TXQ_LOCK(sc);
3774         if (level != 0) {       /* not CAM */
3775                 cmd.flags |= htole16(WPI_PS_ALLOW_SLEEP);
3776                 sc->sc_flags |= WPI_PS_PATH;
3777         } else
3778                 sc->sc_flags &= ~WPI_PS_PATH;
3779         WPI_TXQ_UNLOCK(sc);
3780         /* Retrieve PCIe Active State Power Management (ASPM). */
3781         reg = pci_read_config(sc->sc_dev, sc->sc_cap_off + 0x10, 1);
3782         if (!(reg & 0x1))       /* L0s Entry disabled. */
3783                 cmd.flags |= htole16(WPI_PS_PCI_PMGT);
3784
3785         cmd.rxtimeout = htole32(pmgt->rxtimeout * IEEE80211_DUR_TU);
3786         cmd.txtimeout = htole32(pmgt->txtimeout * IEEE80211_DUR_TU);
3787
3788         if (dtim == 0) {
3789                 dtim = 1;
3790                 skip_dtim = 0;
3791         } else
3792                 skip_dtim = pmgt->skip_dtim;
3793
3794         if (skip_dtim != 0) {
3795                 cmd.flags |= htole16(WPI_PS_SLEEP_OVER_DTIM);
3796                 max = pmgt->intval[4];
3797                 if (max == (uint32_t)-1)
3798                         max = dtim * (skip_dtim + 1);
3799                 else if (max > dtim)
3800                         max = (max / dtim) * dtim;
3801         } else
3802                 max = dtim;
3803
3804         for (i = 0; i < 5; i++)
3805                 cmd.intval[i] = htole32(MIN(max, pmgt->intval[i]));
3806
3807         return wpi_cmd(sc, WPI_CMD_SET_POWER_MODE, &cmd, sizeof cmd, async);
3808 }
3809
3810 static int
3811 wpi_send_btcoex(struct wpi_softc *sc)
3812 {
3813         struct wpi_bluetooth cmd;
3814
3815         memset(&cmd, 0, sizeof cmd);
3816         cmd.flags = WPI_BT_COEX_MODE_4WIRE;
3817         cmd.lead_time = WPI_BT_LEAD_TIME_DEF;
3818         cmd.max_kill = WPI_BT_MAX_KILL_DEF;
3819         DPRINTF(sc, WPI_DEBUG_RESET, "%s: configuring bluetooth coexistence\n",
3820             __func__);
3821         return wpi_cmd(sc, WPI_CMD_BT_COEX, &cmd, sizeof(cmd), 0);
3822 }
3823
3824 static int
3825 wpi_send_rxon(struct wpi_softc *sc, int assoc, int async)
3826 {
3827         int error;
3828
3829         if (async)
3830                 WPI_RXON_LOCK_ASSERT(sc);
3831
3832         if (assoc && wpi_check_bss_filter(sc) != 0) {
3833                 struct wpi_assoc rxon_assoc;
3834
3835                 rxon_assoc.flags = sc->rxon.flags;
3836                 rxon_assoc.filter = sc->rxon.filter;
3837                 rxon_assoc.ofdm_mask = sc->rxon.ofdm_mask;
3838                 rxon_assoc.cck_mask = sc->rxon.cck_mask;
3839                 rxon_assoc.reserved = 0;
3840
3841                 error = wpi_cmd(sc, WPI_CMD_RXON_ASSOC, &rxon_assoc,
3842                     sizeof (struct wpi_assoc), async);
3843                 if (error != 0) {
3844                         device_printf(sc->sc_dev,
3845                             "RXON_ASSOC command failed, error %d\n", error);
3846                         return error;
3847                 }
3848         } else {
3849                 if (async) {
3850                         WPI_NT_LOCK(sc);
3851                         error = wpi_cmd(sc, WPI_CMD_RXON, &sc->rxon,
3852                             sizeof (struct wpi_rxon), async);
3853                         if (error == 0)
3854                                 wpi_clear_node_table(sc);
3855                         WPI_NT_UNLOCK(sc);
3856                 } else {
3857                         error = wpi_cmd(sc, WPI_CMD_RXON, &sc->rxon,
3858                             sizeof (struct wpi_rxon), async);
3859                         if (error == 0)
3860                                 wpi_clear_node_table(sc);
3861                 }
3862
3863                 if (error != 0) {
3864                         device_printf(sc->sc_dev,
3865                             "RXON command failed, error %d\n", error);
3866                         return error;
3867                 }
3868
3869                 /* Add broadcast node. */
3870                 error = wpi_add_broadcast_node(sc, async);
3871                 if (error != 0) {
3872                         device_printf(sc->sc_dev,
3873                             "could not add broadcast node, error %d\n", error);
3874                         return error;
3875                 }
3876         }
3877
3878         /* Configuration has changed, set Tx power accordingly. */
3879         if ((error = wpi_set_txpower(sc, async)) != 0) {
3880                 device_printf(sc->sc_dev,
3881                     "%s: could not set TX power, error %d\n", __func__, error);
3882                 return error;
3883         }
3884
3885         return 0;
3886 }
3887
3888 /**
3889  * Configure the card to listen to a particular channel, this transisions the
3890  * card in to being able to receive frames from remote devices.
3891  */
3892 static int
3893 wpi_config(struct wpi_softc *sc)
3894 {
3895         struct ifnet *ifp = sc->sc_ifp;
3896         struct ieee80211com *ic = ifp->if_l2com;
3897         struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
3898         struct ieee80211_channel *c = ic->ic_curchan;
3899         int error;
3900
3901         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
3902
3903         /* Set power saving level to CAM during initialization. */
3904         if ((error = wpi_set_pslevel(sc, 0, 0, 0)) != 0) {
3905                 device_printf(sc->sc_dev,
3906                     "%s: could not set power saving level\n", __func__);
3907                 return error;
3908         }
3909
3910         /* Configure bluetooth coexistence. */
3911         if ((error = wpi_send_btcoex(sc)) != 0) {
3912                 device_printf(sc->sc_dev,
3913                     "could not configure bluetooth coexistence\n");
3914                 return error;
3915         }
3916
3917         /* Configure adapter. */
3918         memset(&sc->rxon, 0, sizeof (struct wpi_rxon));
3919         IEEE80211_ADDR_COPY(sc->rxon.myaddr, vap->iv_myaddr);
3920
3921         /* Set default channel. */
3922         sc->rxon.chan = ieee80211_chan2ieee(ic, c);
3923         sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF);
3924         if (IEEE80211_IS_CHAN_2GHZ(c))
3925                 sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ);
3926
3927         sc->rxon.filter = WPI_FILTER_MULTICAST;
3928         switch (ic->ic_opmode) {
3929         case IEEE80211_M_STA:
3930                 sc->rxon.mode = WPI_MODE_STA;
3931                 break;
3932         case IEEE80211_M_IBSS:
3933                 sc->rxon.mode = WPI_MODE_IBSS;
3934                 sc->rxon.filter |= WPI_FILTER_BEACON;
3935                 break;
3936         case IEEE80211_M_HOSTAP:
3937                 /* XXX workaround for beaconing */
3938                 sc->rxon.mode = WPI_MODE_IBSS;
3939                 sc->rxon.filter |= WPI_FILTER_ASSOC | WPI_FILTER_PROMISC;
3940                 break;
3941         case IEEE80211_M_AHDEMO:
3942                 sc->rxon.mode = WPI_MODE_HOSTAP;
3943                 break;
3944         case IEEE80211_M_MONITOR:
3945                 sc->rxon.mode = WPI_MODE_MONITOR;
3946                 break;
3947         default:
3948                 device_printf(sc->sc_dev, "unknown opmode %d\n",
3949                     ic->ic_opmode);
3950                 return EINVAL;
3951         }
3952         sc->rxon.filter = htole32(sc->rxon.filter);
3953         wpi_set_promisc(sc);
3954         sc->rxon.cck_mask  = 0x0f;      /* not yet negotiated */
3955         sc->rxon.ofdm_mask = 0xff;      /* not yet negotiated */
3956
3957         /* XXX Current configuration may be unusable. */
3958         if (IEEE80211_IS_CHAN_NOADHOC(c) && sc->rxon.mode == WPI_MODE_IBSS) {
3959                 device_printf(sc->sc_dev,
3960                     "%s: invalid channel (%d) selected for IBSS mode\n",
3961                     __func__, ieee80211_chan2ieee(ic, c));
3962                 return EINVAL;
3963         }
3964
3965         if ((error = wpi_send_rxon(sc, 0, 0)) != 0) {
3966                 device_printf(sc->sc_dev, "%s: could not send RXON\n",
3967                     __func__);
3968                 return error;
3969         }
3970
3971         /* Setup rate scalling. */
3972         if ((error = wpi_mrr_setup(sc)) != 0) {
3973                 device_printf(sc->sc_dev, "could not setup MRR, error %d\n",
3974                     error);
3975                 return error;
3976         }
3977
3978         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
3979
3980         return 0;
3981 }
3982
3983 static uint16_t
3984 wpi_get_active_dwell_time(struct wpi_softc *sc,
3985     struct ieee80211_channel *c, uint8_t n_probes)
3986 {
3987         /* No channel? Default to 2GHz settings. */
3988         if (c == NULL || IEEE80211_IS_CHAN_2GHZ(c)) {
3989                 return (WPI_ACTIVE_DWELL_TIME_2GHZ +
3990                 WPI_ACTIVE_DWELL_FACTOR_2GHZ * (n_probes + 1));
3991         }
3992
3993         /* 5GHz dwell time. */
3994         return (WPI_ACTIVE_DWELL_TIME_5GHZ +
3995             WPI_ACTIVE_DWELL_FACTOR_5GHZ * (n_probes + 1));
3996 }
3997
3998 /*
3999  * Limit the total dwell time.
4000  *
4001  * Returns the dwell time in milliseconds.
4002  */
4003 static uint16_t
4004 wpi_limit_dwell(struct wpi_softc *sc, uint16_t dwell_time)
4005 {
4006         struct ieee80211com *ic = sc->sc_ifp->if_l2com;
4007         struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
4008         int bintval = 0;
4009
4010         /* bintval is in TU (1.024mS) */
4011         if (vap != NULL)
4012                 bintval = vap->iv_bss->ni_intval;
4013
4014         /*
4015          * If it's non-zero, we should calculate the minimum of
4016          * it and the DWELL_BASE.
4017          *
4018          * XXX Yes, the math should take into account that bintval
4019          * is 1.024mS, not 1mS..
4020          */
4021         if (bintval > 0) {
4022                 DPRINTF(sc, WPI_DEBUG_SCAN, "%s: bintval=%d\n", __func__,
4023                     bintval);
4024                 return (MIN(dwell_time, bintval - WPI_CHANNEL_TUNE_TIME * 2));
4025         }
4026
4027         /* No association context? Default. */
4028         return dwell_time;
4029 }
4030
4031 static uint16_t
4032 wpi_get_passive_dwell_time(struct wpi_softc *sc, struct ieee80211_channel *c)
4033 {
4034         uint16_t passive;
4035
4036         if (c == NULL || IEEE80211_IS_CHAN_2GHZ(c))
4037                 passive = WPI_PASSIVE_DWELL_BASE + WPI_PASSIVE_DWELL_TIME_2GHZ;
4038         else
4039                 passive = WPI_PASSIVE_DWELL_BASE + WPI_PASSIVE_DWELL_TIME_5GHZ;
4040
4041         /* Clamp to the beacon interval if we're associated. */
4042         return (wpi_limit_dwell(sc, passive));
4043 }
4044
4045 static uint32_t
4046 wpi_get_scan_pause_time(uint32_t time, uint16_t bintval)
4047 {
4048         uint32_t mod = (time % bintval) * IEEE80211_DUR_TU;
4049         uint32_t nbeacons = time / bintval;
4050
4051         if (mod > WPI_PAUSE_MAX_TIME)
4052                 mod = WPI_PAUSE_MAX_TIME;
4053
4054         return WPI_PAUSE_SCAN(nbeacons, mod);
4055 }
4056
4057 /*
4058  * Send a scan request to the firmware.
4059  */
4060 static int
4061 wpi_scan(struct wpi_softc *sc, struct ieee80211_channel *c)
4062 {
4063         struct ifnet *ifp = sc->sc_ifp;
4064         struct ieee80211com *ic = ifp->if_l2com;
4065         struct ieee80211_scan_state *ss = ic->ic_scan;
4066         struct ieee80211vap *vap = ss->ss_vap;
4067         struct wpi_scan_hdr *hdr;
4068         struct wpi_cmd_data *tx;
4069         struct wpi_scan_essid *essids;
4070         struct wpi_scan_chan *chan;
4071         struct ieee80211_frame *wh;
4072         struct ieee80211_rateset *rs;
4073         uint16_t dwell_active, dwell_passive;
4074         uint8_t *buf, *frm;
4075         int bgscan, bintval, buflen, error, i, nssid;
4076
4077         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
4078
4079         /*
4080          * We are absolutely not allowed to send a scan command when another
4081          * scan command is pending.
4082          */
4083         if (callout_pending(&sc->scan_timeout)) {
4084                 device_printf(sc->sc_dev, "%s: called whilst scanning!\n",
4085                     __func__);
4086                 error = EAGAIN;
4087                 goto fail;
4088         }
4089
4090         bgscan = wpi_check_bss_filter(sc);
4091         bintval = vap->iv_bss->ni_intval;
4092         if (bgscan != 0 &&
4093             bintval < WPI_QUIET_TIME_DEFAULT + WPI_CHANNEL_TUNE_TIME * 2) {
4094                 error = EOPNOTSUPP;
4095                 goto fail;
4096         }
4097
4098         buf = malloc(WPI_SCAN_MAXSZ, M_DEVBUF, M_NOWAIT | M_ZERO);
4099         if (buf == NULL) {
4100                 device_printf(sc->sc_dev,
4101                     "%s: could not allocate buffer for scan command\n",
4102                     __func__);
4103                 error = ENOMEM;
4104                 goto fail;
4105         }
4106         hdr = (struct wpi_scan_hdr *)buf;
4107
4108         /*
4109          * Move to the next channel if no packets are received within 10 msecs
4110          * after sending the probe request.
4111          */
4112         hdr->quiet_time = htole16(WPI_QUIET_TIME_DEFAULT);
4113         hdr->quiet_threshold = htole16(1);
4114
4115         if (bgscan != 0) {
4116                 /*
4117                  * Max needs to be greater than active and passive and quiet!
4118                  * It's also in microseconds!
4119                  */
4120                 hdr->max_svc = htole32(250 * IEEE80211_DUR_TU);
4121                 hdr->pause_svc = htole32(wpi_get_scan_pause_time(100,
4122                     bintval));
4123         }
4124
4125         hdr->filter = htole32(WPI_FILTER_MULTICAST | WPI_FILTER_BEACON);
4126
4127         tx = (struct wpi_cmd_data *)(hdr + 1);
4128         tx->flags = htole32(WPI_TX_AUTO_SEQ);
4129         tx->id = WPI_ID_BROADCAST;
4130         tx->lifetime = htole32(WPI_LIFETIME_INFINITE);
4131
4132         if (IEEE80211_IS_CHAN_5GHZ(c)) {
4133                 /* Send probe requests at 6Mbps. */
4134                 tx->plcp = wpi_ridx_to_plcp[WPI_RIDX_OFDM6];
4135                 rs = &ic->ic_sup_rates[IEEE80211_MODE_11A];
4136         } else {
4137                 hdr->flags = htole32(WPI_RXON_24GHZ | WPI_RXON_AUTO);
4138                 /* Send probe requests at 1Mbps. */
4139                 tx->plcp = wpi_ridx_to_plcp[WPI_RIDX_CCK1];
4140                 rs = &ic->ic_sup_rates[IEEE80211_MODE_11G];
4141         }
4142
4143         essids = (struct wpi_scan_essid *)(tx + 1);
4144         nssid = MIN(ss->ss_nssid, WPI_SCAN_MAX_ESSIDS);
4145         for (i = 0; i < nssid; i++) {
4146                 essids[i].id = IEEE80211_ELEMID_SSID;
4147                 essids[i].len = MIN(ss->ss_ssid[i].len, IEEE80211_NWID_LEN);
4148                 memcpy(essids[i].data, ss->ss_ssid[i].ssid, essids[i].len);
4149 #ifdef WPI_DEBUG
4150                 if (sc->sc_debug & WPI_DEBUG_SCAN) {
4151                         printf("Scanning Essid: ");
4152                         ieee80211_print_essid(essids[i].data, essids[i].len);
4153                         printf("\n");
4154                 }
4155 #endif
4156         }
4157
4158         /*
4159          * Build a probe request frame.  Most of the following code is a
4160          * copy & paste of what is done in net80211.
4161          */
4162         wh = (struct ieee80211_frame *)(essids + WPI_SCAN_MAX_ESSIDS);
4163         wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT |
4164                 IEEE80211_FC0_SUBTYPE_PROBE_REQ;
4165         wh->i_fc[1] = IEEE80211_FC1_DIR_NODS;
4166         IEEE80211_ADDR_COPY(wh->i_addr1, ifp->if_broadcastaddr);
4167         IEEE80211_ADDR_COPY(wh->i_addr2, vap->iv_myaddr);
4168         IEEE80211_ADDR_COPY(wh->i_addr3, ifp->if_broadcastaddr);
4169         *(uint16_t *)&wh->i_dur[0] = 0; /* filled by h/w */
4170         *(uint16_t *)&wh->i_seq[0] = 0; /* filled by h/w */
4171
4172         frm = (uint8_t *)(wh + 1);
4173         frm = ieee80211_add_ssid(frm, NULL, 0);
4174         frm = ieee80211_add_rates(frm, rs);
4175         if (rs->rs_nrates > IEEE80211_RATE_SIZE)
4176                 frm = ieee80211_add_xrates(frm, rs);
4177
4178         /* Set length of probe request. */
4179         tx->len = htole16(frm - (uint8_t *)wh);
4180
4181         /*
4182          * Construct information about the channel that we
4183          * want to scan. The firmware expects this to be directly
4184          * after the scan probe request
4185          */
4186         chan = (struct wpi_scan_chan *)frm;
4187         chan->chan = htole16(ieee80211_chan2ieee(ic, c));
4188         chan->flags = 0;
4189         if (nssid) {
4190                 hdr->crc_threshold = WPI_SCAN_CRC_TH_DEFAULT;
4191                 chan->flags |= WPI_CHAN_NPBREQS(nssid);
4192         } else
4193                 hdr->crc_threshold = WPI_SCAN_CRC_TH_NEVER;
4194
4195         if (!IEEE80211_IS_CHAN_PASSIVE(c))
4196                 chan->flags |= WPI_CHAN_ACTIVE;
4197
4198         /*
4199          * Calculate the active/passive dwell times.
4200          */
4201
4202         dwell_active = wpi_get_active_dwell_time(sc, c, nssid);
4203         dwell_passive = wpi_get_passive_dwell_time(sc, c);
4204
4205         /* Make sure they're valid. */
4206         if (dwell_active > dwell_passive)
4207                 dwell_active = dwell_passive;
4208
4209         chan->active = htole16(dwell_active);
4210         chan->passive = htole16(dwell_passive);
4211
4212         chan->dsp_gain = 0x6e;  /* Default level */
4213
4214         if (IEEE80211_IS_CHAN_5GHZ(c))
4215                 chan->rf_gain = 0x3b;
4216         else
4217                 chan->rf_gain = 0x28;
4218
4219         DPRINTF(sc, WPI_DEBUG_SCAN, "Scanning %u Passive: %d\n",
4220             chan->chan, IEEE80211_IS_CHAN_PASSIVE(c));
4221
4222         hdr->nchan++;
4223
4224         if (hdr->nchan == 1 && sc->rxon.chan == chan->chan) {
4225                 /* XXX Force probe request transmission. */
4226                 memcpy(chan + 1, chan, sizeof (struct wpi_scan_chan));
4227
4228                 chan++;
4229
4230                 /* Reduce unnecessary delay. */
4231                 chan->flags = 0;
4232                 chan->passive = chan->active = hdr->quiet_time;
4233
4234                 hdr->nchan++;
4235         }
4236
4237         chan++;
4238
4239         buflen = (uint8_t *)chan - buf;
4240         hdr->len = htole16(buflen);
4241
4242         DPRINTF(sc, WPI_DEBUG_CMD, "sending scan command nchan=%d\n",
4243             hdr->nchan);
4244         error = wpi_cmd(sc, WPI_CMD_SCAN, buf, buflen, 1);
4245         free(buf, M_DEVBUF);
4246
4247         if (error != 0)
4248                 goto fail;
4249
4250         callout_reset(&sc->scan_timeout, 5*hz, wpi_scan_timeout, sc);
4251
4252         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
4253
4254         return 0;
4255
4256 fail:   DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__);
4257
4258         return error;
4259 }
4260
4261 static int
4262 wpi_auth(struct wpi_softc *sc, struct ieee80211vap *vap)
4263 {
4264         struct ieee80211com *ic = vap->iv_ic;
4265         struct ieee80211_node *ni = vap->iv_bss;
4266         struct ieee80211_channel *c = ni->ni_chan;
4267         int error;
4268
4269         WPI_RXON_LOCK(sc);
4270
4271         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
4272
4273         /* Update adapter configuration. */
4274         sc->rxon.associd = 0;
4275         sc->rxon.filter &= ~htole32(WPI_FILTER_BSS);
4276         IEEE80211_ADDR_COPY(sc->rxon.bssid, ni->ni_bssid);
4277         sc->rxon.chan = ieee80211_chan2ieee(ic, c);
4278         sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF);
4279         if (IEEE80211_IS_CHAN_2GHZ(c))
4280                 sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ);
4281         if (ic->ic_flags & IEEE80211_F_SHSLOT)
4282                 sc->rxon.flags |= htole32(WPI_RXON_SHSLOT);
4283         if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
4284                 sc->rxon.flags |= htole32(WPI_RXON_SHPREAMBLE);
4285         if (IEEE80211_IS_CHAN_A(c)) {
4286                 sc->rxon.cck_mask  = 0;
4287                 sc->rxon.ofdm_mask = 0x15;
4288         } else if (IEEE80211_IS_CHAN_B(c)) {
4289                 sc->rxon.cck_mask  = 0x03;
4290                 sc->rxon.ofdm_mask = 0;
4291         } else {
4292                 /* Assume 802.11b/g. */
4293                 sc->rxon.cck_mask  = 0x0f;
4294                 sc->rxon.ofdm_mask = 0x15;
4295         }
4296
4297         DPRINTF(sc, WPI_DEBUG_STATE, "rxon chan %d flags %x cck %x ofdm %x\n",
4298             sc->rxon.chan, sc->rxon.flags, sc->rxon.cck_mask,
4299             sc->rxon.ofdm_mask);
4300
4301         if ((error = wpi_send_rxon(sc, 0, 1)) != 0) {
4302                 device_printf(sc->sc_dev, "%s: could not send RXON\n",
4303                     __func__);
4304         }
4305
4306         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
4307
4308         WPI_RXON_UNLOCK(sc);
4309
4310         return error;
4311 }
4312
4313 static int
4314 wpi_config_beacon(struct wpi_vap *wvp)
4315 {
4316         struct ieee80211com *ic = wvp->wv_vap.iv_ic;
4317         struct ieee80211_beacon_offsets *bo = &wvp->wv_boff;
4318         struct wpi_buf *bcn = &wvp->wv_bcbuf;
4319         struct wpi_softc *sc = ic->ic_ifp->if_softc;
4320         struct wpi_cmd_beacon *cmd = (struct wpi_cmd_beacon *)&bcn->data;
4321         struct ieee80211_tim_ie *tie;
4322         struct mbuf *m;
4323         uint8_t *ptr;
4324         int error;
4325
4326         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
4327
4328         WPI_VAP_LOCK_ASSERT(wvp);
4329
4330         cmd->len = htole16(bcn->m->m_pkthdr.len);
4331         cmd->plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ?
4332             wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1];
4333
4334         /* XXX seems to be unused */
4335         if (*(bo->bo_tim) == IEEE80211_ELEMID_TIM) {
4336                 tie = (struct ieee80211_tim_ie *) bo->bo_tim;
4337                 ptr = mtod(bcn->m, uint8_t *);
4338
4339                 cmd->tim = htole16(bo->bo_tim - ptr);
4340                 cmd->timsz = tie->tim_len;
4341         }
4342
4343         /* Necessary for recursion in ieee80211_beacon_update(). */
4344         m = bcn->m;
4345         bcn->m = m_dup(m, M_NOWAIT);
4346         if (bcn->m == NULL) {
4347                 device_printf(sc->sc_dev,
4348                     "%s: could not copy beacon frame\n", __func__);
4349                 error = ENOMEM;
4350                 goto end;
4351         }
4352
4353         if ((error = wpi_cmd2(sc, bcn)) != 0) {
4354                 device_printf(sc->sc_dev,
4355                     "%s: could not update beacon frame, error %d", __func__,
4356                     error);
4357         }
4358
4359         /* Restore mbuf. */
4360 end:    bcn->m = m;
4361
4362         return error;
4363 }
4364
4365 static int
4366 wpi_setup_beacon(struct wpi_softc *sc, struct ieee80211_node *ni)
4367 {
4368         struct wpi_vap *wvp = WPI_VAP(ni->ni_vap);
4369         struct wpi_buf *bcn = &wvp->wv_bcbuf;
4370         struct ieee80211_beacon_offsets *bo = &wvp->wv_boff;
4371         struct mbuf *m;
4372         int error;
4373
4374         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
4375
4376         if (ni->ni_chan == IEEE80211_CHAN_ANYC)
4377                 return EINVAL;
4378
4379         m = ieee80211_beacon_alloc(ni, bo);
4380         if (m == NULL) {
4381                 device_printf(sc->sc_dev,
4382                     "%s: could not allocate beacon frame\n", __func__);
4383                 return ENOMEM;
4384         }
4385
4386         WPI_VAP_LOCK(wvp);
4387         if (bcn->m != NULL)
4388                 m_freem(bcn->m);
4389
4390         bcn->m = m;
4391
4392         error = wpi_config_beacon(wvp);
4393         WPI_VAP_UNLOCK(wvp);
4394
4395         return error;
4396 }
4397
4398 static void
4399 wpi_update_beacon(struct ieee80211vap *vap, int item)
4400 {
4401         struct wpi_softc *sc = vap->iv_ic->ic_ifp->if_softc;
4402         struct wpi_vap *wvp = WPI_VAP(vap);
4403         struct wpi_buf *bcn = &wvp->wv_bcbuf;
4404         struct ieee80211_beacon_offsets *bo = &wvp->wv_boff;
4405         struct ieee80211_node *ni = vap->iv_bss;
4406         int mcast = 0;
4407
4408         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
4409
4410         WPI_VAP_LOCK(wvp);
4411         if (bcn->m == NULL) {
4412                 bcn->m = ieee80211_beacon_alloc(ni, bo);
4413                 if (bcn->m == NULL) {
4414                         device_printf(sc->sc_dev,
4415                             "%s: could not allocate beacon frame\n", __func__);
4416
4417                         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR,
4418                             __func__);
4419
4420                         WPI_VAP_UNLOCK(wvp);
4421                         return;
4422                 }
4423         }
4424         WPI_VAP_UNLOCK(wvp);
4425
4426         if (item == IEEE80211_BEACON_TIM)
4427                 mcast = 1;      /* TODO */
4428
4429         setbit(bo->bo_flags, item);
4430         ieee80211_beacon_update(ni, bo, bcn->m, mcast);
4431
4432         WPI_VAP_LOCK(wvp);
4433         wpi_config_beacon(wvp);
4434         WPI_VAP_UNLOCK(wvp);
4435
4436         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
4437 }
4438
4439 static void
4440 wpi_newassoc(struct ieee80211_node *ni, int isnew)
4441 {
4442         struct ieee80211vap *vap = ni->ni_vap;
4443         struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc;
4444         struct wpi_node *wn = WPI_NODE(ni);
4445         int error;
4446
4447         WPI_NT_LOCK(sc);
4448
4449         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
4450
4451         if (vap->iv_opmode != IEEE80211_M_STA && wn->id == WPI_ID_UNDEFINED) {
4452                 if ((error = wpi_add_ibss_node(sc, ni)) != 0) {
4453                         device_printf(sc->sc_dev,
4454                             "%s: could not add IBSS node, error %d\n",
4455                             __func__, error);
4456                 }
4457         }
4458         WPI_NT_UNLOCK(sc);
4459 }
4460
4461 static int
4462 wpi_run(struct wpi_softc *sc, struct ieee80211vap *vap)
4463 {
4464         struct ieee80211com *ic = vap->iv_ic;
4465         struct ieee80211_node *ni = vap->iv_bss;
4466         struct ieee80211_channel *c = ni->ni_chan;
4467         int error;
4468
4469         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
4470
4471         if (vap->iv_opmode == IEEE80211_M_MONITOR) {
4472                 /* Link LED blinks while monitoring. */
4473                 wpi_set_led(sc, WPI_LED_LINK, 5, 5);
4474                 return 0;
4475         }
4476
4477         /* XXX kernel panic workaround */
4478         if (c == IEEE80211_CHAN_ANYC) {
4479                 device_printf(sc->sc_dev, "%s: incomplete configuration\n",
4480                     __func__);
4481                 return EINVAL;
4482         }
4483
4484         if ((error = wpi_set_timing(sc, ni)) != 0) {
4485                 device_printf(sc->sc_dev,
4486                     "%s: could not set timing, error %d\n", __func__, error);
4487                 return error;
4488         }
4489
4490         /* Update adapter configuration. */
4491         WPI_RXON_LOCK(sc);
4492         IEEE80211_ADDR_COPY(sc->rxon.bssid, ni->ni_bssid);
4493         sc->rxon.associd = htole16(IEEE80211_NODE_AID(ni));
4494         sc->rxon.chan = ieee80211_chan2ieee(ic, c);
4495         sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF);
4496         if (IEEE80211_IS_CHAN_2GHZ(c))
4497                 sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ);
4498         if (ic->ic_flags & IEEE80211_F_SHSLOT)
4499                 sc->rxon.flags |= htole32(WPI_RXON_SHSLOT);
4500         if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
4501                 sc->rxon.flags |= htole32(WPI_RXON_SHPREAMBLE);
4502         if (IEEE80211_IS_CHAN_A(c)) {
4503                 sc->rxon.cck_mask  = 0;
4504                 sc->rxon.ofdm_mask = 0x15;
4505         } else if (IEEE80211_IS_CHAN_B(c)) {
4506                 sc->rxon.cck_mask  = 0x03;
4507                 sc->rxon.ofdm_mask = 0;
4508         } else {
4509                 /* Assume 802.11b/g. */
4510                 sc->rxon.cck_mask  = 0x0f;
4511                 sc->rxon.ofdm_mask = 0x15;
4512         }
4513         sc->rxon.filter |= htole32(WPI_FILTER_BSS);
4514
4515         DPRINTF(sc, WPI_DEBUG_STATE, "rxon chan %d flags %x\n",
4516             sc->rxon.chan, sc->rxon.flags);
4517
4518         if ((error = wpi_send_rxon(sc, 0, 1)) != 0) {
4519                 device_printf(sc->sc_dev, "%s: could not send RXON\n",
4520                     __func__);
4521                 return error;
4522         }
4523
4524         /* Start periodic calibration timer. */
4525         callout_reset(&sc->calib_to, 60*hz, wpi_calib_timeout, sc);
4526
4527         WPI_RXON_UNLOCK(sc);
4528
4529         if (vap->iv_opmode == IEEE80211_M_IBSS ||
4530             vap->iv_opmode == IEEE80211_M_HOSTAP) {
4531                 if ((error = wpi_setup_beacon(sc, ni)) != 0) {
4532                         device_printf(sc->sc_dev,
4533                             "%s: could not setup beacon, error %d\n", __func__,
4534                             error);
4535                         return error;
4536                 }
4537         }
4538
4539         if (vap->iv_opmode == IEEE80211_M_STA) {
4540                 /* Add BSS node. */
4541                 WPI_NT_LOCK(sc);
4542                 error = wpi_add_sta_node(sc, ni);
4543                 WPI_NT_UNLOCK(sc);
4544                 if (error != 0) {
4545                         device_printf(sc->sc_dev,
4546                             "%s: could not add BSS node, error %d\n", __func__,
4547                             error);
4548                         return error;
4549                 }
4550         }
4551
4552         /* Link LED always on while associated. */
4553         wpi_set_led(sc, WPI_LED_LINK, 0, 1);
4554
4555         /* Enable power-saving mode if requested by user. */
4556         if ((vap->iv_flags & IEEE80211_F_PMGTON) &&
4557             vap->iv_opmode != IEEE80211_M_IBSS)
4558                 (void)wpi_set_pslevel(sc, 0, 3, 1);
4559
4560         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
4561
4562         return 0;
4563 }
4564
4565 static int
4566 wpi_load_key(struct ieee80211_node *ni, const struct ieee80211_key *k)
4567 {
4568         const struct ieee80211_cipher *cip = k->wk_cipher;
4569         struct ieee80211vap *vap = ni->ni_vap;
4570         struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc;
4571         struct wpi_node *wn = WPI_NODE(ni);
4572         struct wpi_node_info node;
4573         uint16_t kflags;
4574         int error;
4575
4576         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
4577
4578         if (wpi_check_node_entry(sc, wn->id) == 0) {
4579                 device_printf(sc->sc_dev, "%s: node does not exist\n",
4580                     __func__);
4581                 return 0;
4582         }
4583
4584         switch (cip->ic_cipher) {
4585         case IEEE80211_CIPHER_AES_CCM:
4586                 kflags = WPI_KFLAG_CCMP;
4587                 break;
4588
4589         default:
4590                 device_printf(sc->sc_dev, "%s: unknown cipher %d\n", __func__,
4591                     cip->ic_cipher);
4592                 return 0;
4593         }
4594
4595         kflags |= WPI_KFLAG_KID(k->wk_keyix);
4596         if (k->wk_flags & IEEE80211_KEY_GROUP)
4597                 kflags |= WPI_KFLAG_MULTICAST;
4598
4599         memset(&node, 0, sizeof node);
4600         node.id = wn->id;
4601         node.control = WPI_NODE_UPDATE;
4602         node.flags = WPI_FLAG_KEY_SET;
4603         node.kflags = htole16(kflags);
4604         memcpy(node.key, k->wk_key, k->wk_keylen);
4605 again:
4606         DPRINTF(sc, WPI_DEBUG_KEY,
4607             "%s: setting %s key id %d for node %d (%s)\n", __func__,
4608             (kflags & WPI_KFLAG_MULTICAST) ? "group" : "ucast", k->wk_keyix,
4609             node.id, ether_sprintf(ni->ni_macaddr));
4610
4611         error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1);
4612         if (error != 0) {
4613                 device_printf(sc->sc_dev, "can't update node info, error %d\n",
4614                     error);
4615                 return !error;
4616         }
4617
4618         if (!(kflags & WPI_KFLAG_MULTICAST) && &vap->iv_nw_keys[0] <= k &&
4619             k < &vap->iv_nw_keys[IEEE80211_WEP_NKID]) {
4620                 kflags |= WPI_KFLAG_MULTICAST;
4621                 node.kflags = htole16(kflags);
4622
4623                 goto again;
4624         }
4625
4626         return 1;
4627 }
4628
4629 static void
4630 wpi_load_key_cb(void *arg, struct ieee80211_node *ni)
4631 {
4632         const struct ieee80211_key *k = arg;
4633         struct ieee80211vap *vap = ni->ni_vap;
4634         struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc;
4635         struct wpi_node *wn = WPI_NODE(ni);
4636         int error;
4637
4638         if (vap->iv_bss == ni && wn->id == WPI_ID_UNDEFINED)
4639                 return;
4640
4641         WPI_NT_LOCK(sc);
4642         error = wpi_load_key(ni, k);
4643         WPI_NT_UNLOCK(sc);
4644
4645         if (error == 0) {
4646                 device_printf(sc->sc_dev, "%s: error while setting key\n",
4647                     __func__);
4648         }
4649 }
4650
4651 static int
4652 wpi_set_global_keys(struct ieee80211_node *ni)
4653 {
4654         struct ieee80211vap *vap = ni->ni_vap;
4655         struct ieee80211_key *wk = &vap->iv_nw_keys[0];
4656         int error = 1;
4657
4658         for (; wk < &vap->iv_nw_keys[IEEE80211_WEP_NKID] && error; wk++)
4659                 if (wk->wk_keyix != IEEE80211_KEYIX_NONE)
4660                         error = wpi_load_key(ni, wk);
4661
4662         return !error;
4663 }
4664
4665 static int
4666 wpi_del_key(struct ieee80211_node *ni, const struct ieee80211_key *k)
4667 {
4668         struct ieee80211vap *vap = ni->ni_vap;
4669         struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc;
4670         struct wpi_node *wn = WPI_NODE(ni);
4671         struct wpi_node_info node;
4672         uint16_t kflags;
4673         int error;
4674
4675         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
4676
4677         if (wpi_check_node_entry(sc, wn->id) == 0) {
4678                 DPRINTF(sc, WPI_DEBUG_KEY, "%s: node was removed\n", __func__);
4679                 return 1;       /* Nothing to do. */
4680         }
4681
4682         kflags = WPI_KFLAG_KID(k->wk_keyix);
4683         if (k->wk_flags & IEEE80211_KEY_GROUP)
4684                 kflags |= WPI_KFLAG_MULTICAST;
4685
4686         memset(&node, 0, sizeof node);
4687         node.id = wn->id;
4688         node.control = WPI_NODE_UPDATE;
4689         node.flags = WPI_FLAG_KEY_SET;
4690         node.kflags = htole16(kflags);
4691 again:
4692         DPRINTF(sc, WPI_DEBUG_KEY, "%s: deleting %s key %d for node %d (%s)\n",
4693             __func__, (kflags & WPI_KFLAG_MULTICAST) ? "group" : "ucast",
4694             k->wk_keyix, node.id, ether_sprintf(ni->ni_macaddr));
4695
4696         error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1);
4697         if (error != 0) {
4698                 device_printf(sc->sc_dev, "can't update node info, error %d\n",
4699                     error);
4700                 return !error;
4701         }
4702
4703         if (!(kflags & WPI_KFLAG_MULTICAST) && &vap->iv_nw_keys[0] <= k &&
4704             k < &vap->iv_nw_keys[IEEE80211_WEP_NKID]) {
4705                 kflags |= WPI_KFLAG_MULTICAST;
4706                 node.kflags = htole16(kflags);
4707
4708                 goto again;
4709         }
4710
4711         return 1;
4712 }
4713
4714 static void
4715 wpi_del_key_cb(void *arg, struct ieee80211_node *ni)
4716 {
4717         const struct ieee80211_key *k = arg;
4718         struct ieee80211vap *vap = ni->ni_vap;
4719         struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc;
4720         struct wpi_node *wn = WPI_NODE(ni);
4721         int error;
4722
4723         if (vap->iv_bss == ni && wn->id == WPI_ID_UNDEFINED)
4724                 return;
4725
4726         WPI_NT_LOCK(sc);
4727         error = wpi_del_key(ni, k);
4728         WPI_NT_UNLOCK(sc);
4729
4730         if (error == 0) {
4731                 device_printf(sc->sc_dev, "%s: error while deleting key\n",
4732                     __func__);
4733         }
4734 }
4735
4736 static int
4737 wpi_process_key(struct ieee80211vap *vap, const struct ieee80211_key *k,
4738     int set)
4739 {
4740         struct ieee80211com *ic = vap->iv_ic;
4741         struct wpi_softc *sc = ic->ic_ifp->if_softc;
4742         struct wpi_vap *wvp = WPI_VAP(vap);
4743         struct ieee80211_node *ni;
4744         int error, ni_ref = 0;
4745
4746         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
4747
4748         if (k->wk_flags & IEEE80211_KEY_SWCRYPT) {
4749                 /* Not for us. */
4750                 return 1;
4751         }
4752
4753         if (!(k->wk_flags & IEEE80211_KEY_RECV)) {
4754                 /* XMIT keys are handled in wpi_tx_data(). */
4755                 return 1;
4756         }
4757
4758         /* Handle group keys. */
4759         if (&vap->iv_nw_keys[0] <= k &&
4760             k < &vap->iv_nw_keys[IEEE80211_WEP_NKID]) {
4761                 WPI_NT_LOCK(sc);
4762                 if (set)
4763                         wvp->wv_gtk |= WPI_VAP_KEY(k->wk_keyix);
4764                 else
4765                         wvp->wv_gtk &= ~WPI_VAP_KEY(k->wk_keyix);
4766                 WPI_NT_UNLOCK(sc);
4767
4768                 if (vap->iv_state == IEEE80211_S_RUN) {
4769                         ieee80211_iterate_nodes(&ic->ic_sta,
4770                             set ? wpi_load_key_cb : wpi_del_key_cb,
4771                             __DECONST(void *, k));
4772                 }
4773
4774                 return 1;
4775         }
4776
4777         switch (vap->iv_opmode) {
4778         case IEEE80211_M_STA:
4779                 ni = vap->iv_bss;
4780                 break;
4781
4782         case IEEE80211_M_IBSS:
4783         case IEEE80211_M_AHDEMO:
4784         case IEEE80211_M_HOSTAP:
4785                 ni = ieee80211_find_vap_node(&ic->ic_sta, vap, k->wk_macaddr);
4786                 if (ni == NULL)
4787                         return 0;       /* should not happen */
4788
4789                 ni_ref = 1;
4790                 break;
4791
4792         default:
4793                 device_printf(sc->sc_dev, "%s: unknown opmode %d\n", __func__,
4794                     vap->iv_opmode);
4795                 return 0;
4796         }
4797
4798         WPI_NT_LOCK(sc);
4799         if (set)
4800                 error = wpi_load_key(ni, k);
4801         else
4802                 error = wpi_del_key(ni, k);
4803         WPI_NT_UNLOCK(sc);
4804
4805         if (ni_ref)
4806                 ieee80211_node_decref(ni);
4807
4808         return error;
4809 }
4810
4811 static int
4812 wpi_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k,
4813     const uint8_t mac[IEEE80211_ADDR_LEN])
4814 {
4815         return wpi_process_key(vap, k, 1);
4816 }
4817
4818 static int
4819 wpi_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k)
4820 {
4821         return wpi_process_key(vap, k, 0);
4822 }
4823
4824 /*
4825  * This function is called after the runtime firmware notifies us of its
4826  * readiness (called in a process context).
4827  */
4828 static int
4829 wpi_post_alive(struct wpi_softc *sc)
4830 {
4831         int ntries, error;
4832
4833         /* Check (again) that the radio is not disabled. */
4834         if ((error = wpi_nic_lock(sc)) != 0)
4835                 return error;
4836
4837         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
4838
4839         /* NB: Runtime firmware must be up and running. */
4840         if (!(wpi_prph_read(sc, WPI_APMG_RFKILL) & 1)) {
4841                 device_printf(sc->sc_dev,
4842                     "RF switch: radio disabled (%s)\n", __func__);
4843                 wpi_nic_unlock(sc);
4844                 return EPERM;   /* :-) */
4845         }
4846         wpi_nic_unlock(sc);
4847
4848         /* Wait for thermal sensor to calibrate. */
4849         for (ntries = 0; ntries < 1000; ntries++) {
4850                 if ((sc->temp = (int)WPI_READ(sc, WPI_UCODE_GP2)) != 0)
4851                         break;
4852                 DELAY(10);
4853         }
4854
4855         if (ntries == 1000) {
4856                 device_printf(sc->sc_dev,
4857                     "timeout waiting for thermal sensor calibration\n");
4858                 return ETIMEDOUT;
4859         }
4860
4861         DPRINTF(sc, WPI_DEBUG_TEMP, "temperature %d\n", sc->temp);
4862         return 0;
4863 }
4864
4865 /*
4866  * The firmware boot code is small and is intended to be copied directly into
4867  * the NIC internal memory (no DMA transfer).
4868  */
4869 static int
4870 wpi_load_bootcode(struct wpi_softc *sc, const uint8_t *ucode, int size)
4871 {
4872         int error, ntries;
4873
4874         DPRINTF(sc, WPI_DEBUG_HW, "Loading microcode size 0x%x\n", size);
4875
4876         size /= sizeof (uint32_t);
4877
4878         if ((error = wpi_nic_lock(sc)) != 0)
4879                 return error;
4880
4881         /* Copy microcode image into NIC memory. */
4882         wpi_prph_write_region_4(sc, WPI_BSM_SRAM_BASE,
4883             (const uint32_t *)ucode, size);
4884
4885         wpi_prph_write(sc, WPI_BSM_WR_MEM_SRC, 0);
4886         wpi_prph_write(sc, WPI_BSM_WR_MEM_DST, WPI_FW_TEXT_BASE);
4887         wpi_prph_write(sc, WPI_BSM_WR_DWCOUNT, size);
4888
4889         /* Start boot load now. */
4890         wpi_prph_write(sc, WPI_BSM_WR_CTRL, WPI_BSM_WR_CTRL_START);
4891
4892         /* Wait for transfer to complete. */
4893         for (ntries = 0; ntries < 1000; ntries++) {
4894                 uint32_t status = WPI_READ(sc, WPI_FH_TX_STATUS);
4895                 DPRINTF(sc, WPI_DEBUG_HW,
4896                     "firmware status=0x%x, val=0x%x, result=0x%x\n", status,
4897                     WPI_FH_TX_STATUS_IDLE(6),
4898                     status & WPI_FH_TX_STATUS_IDLE(6));
4899                 if (status & WPI_FH_TX_STATUS_IDLE(6)) {
4900                         DPRINTF(sc, WPI_DEBUG_HW,
4901                             "Status Match! - ntries = %d\n", ntries);
4902                         break;
4903                 }
4904                 DELAY(10);
4905         }
4906         if (ntries == 1000) {
4907                 device_printf(sc->sc_dev, "%s: could not load boot firmware\n",
4908                     __func__);
4909                 wpi_nic_unlock(sc);
4910                 return ETIMEDOUT;
4911         }
4912
4913         /* Enable boot after power up. */
4914         wpi_prph_write(sc, WPI_BSM_WR_CTRL, WPI_BSM_WR_CTRL_START_EN);
4915
4916         wpi_nic_unlock(sc);
4917         return 0;
4918 }
4919
4920 static int
4921 wpi_load_firmware(struct wpi_softc *sc)
4922 {
4923         struct wpi_fw_info *fw = &sc->fw;
4924         struct wpi_dma_info *dma = &sc->fw_dma;
4925         int error;
4926
4927         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
4928
4929         /* Copy initialization sections into pre-allocated DMA-safe memory. */
4930         memcpy(dma->vaddr, fw->init.data, fw->init.datasz);
4931         bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE);
4932         memcpy(dma->vaddr + WPI_FW_DATA_MAXSZ, fw->init.text, fw->init.textsz);
4933         bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE);
4934
4935         /* Tell adapter where to find initialization sections. */
4936         if ((error = wpi_nic_lock(sc)) != 0)
4937                 return error;
4938         wpi_prph_write(sc, WPI_BSM_DRAM_DATA_ADDR, dma->paddr);
4939         wpi_prph_write(sc, WPI_BSM_DRAM_DATA_SIZE, fw->init.datasz);
4940         wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_ADDR,
4941             dma->paddr + WPI_FW_DATA_MAXSZ);
4942         wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_SIZE, fw->init.textsz);
4943         wpi_nic_unlock(sc);
4944
4945         /* Load firmware boot code. */
4946         error = wpi_load_bootcode(sc, fw->boot.text, fw->boot.textsz);
4947         if (error != 0) {
4948                 device_printf(sc->sc_dev, "%s: could not load boot firmware\n",
4949                     __func__);
4950                 return error;
4951         }
4952
4953         /* Now press "execute". */
4954         WPI_WRITE(sc, WPI_RESET, 0);
4955
4956         /* Wait at most one second for first alive notification. */
4957         if ((error = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) {
4958                 device_printf(sc->sc_dev,
4959                     "%s: timeout waiting for adapter to initialize, error %d\n",
4960                     __func__, error);
4961                 return error;
4962         }
4963
4964         /* Copy runtime sections into pre-allocated DMA-safe memory. */
4965         memcpy(dma->vaddr, fw->main.data, fw->main.datasz);
4966         bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE);
4967         memcpy(dma->vaddr + WPI_FW_DATA_MAXSZ, fw->main.text, fw->main.textsz);
4968         bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE);
4969
4970         /* Tell adapter where to find runtime sections. */
4971         if ((error = wpi_nic_lock(sc)) != 0)
4972                 return error;
4973         wpi_prph_write(sc, WPI_BSM_DRAM_DATA_ADDR, dma->paddr);
4974         wpi_prph_write(sc, WPI_BSM_DRAM_DATA_SIZE, fw->main.datasz);
4975         wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_ADDR,
4976             dma->paddr + WPI_FW_DATA_MAXSZ);
4977         wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_SIZE,
4978             WPI_FW_UPDATED | fw->main.textsz);
4979         wpi_nic_unlock(sc);
4980
4981         return 0;
4982 }
4983
4984 static int
4985 wpi_read_firmware(struct wpi_softc *sc)
4986 {
4987         const struct firmware *fp;
4988         struct wpi_fw_info *fw = &sc->fw;
4989         const struct wpi_firmware_hdr *hdr;
4990         int error;
4991
4992         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
4993
4994         DPRINTF(sc, WPI_DEBUG_FIRMWARE,
4995             "Attempting Loading Firmware from %s module\n", WPI_FW_NAME);
4996
4997         WPI_UNLOCK(sc);
4998         fp = firmware_get(WPI_FW_NAME);
4999         WPI_LOCK(sc);
5000
5001         if (fp == NULL) {
5002                 device_printf(sc->sc_dev,
5003                     "could not load firmware image '%s'\n", WPI_FW_NAME);
5004                 return EINVAL;
5005         }
5006
5007         sc->fw_fp = fp;
5008
5009         if (fp->datasize < sizeof (struct wpi_firmware_hdr)) {
5010                 device_printf(sc->sc_dev,
5011                     "firmware file too short: %zu bytes\n", fp->datasize);
5012                 error = EINVAL;
5013                 goto fail;
5014         }
5015
5016         fw->size = fp->datasize;
5017         fw->data = (const uint8_t *)fp->data;
5018
5019         /* Extract firmware header information. */
5020         hdr = (const struct wpi_firmware_hdr *)fw->data;
5021
5022         /*     |  RUNTIME FIRMWARE   |    INIT FIRMWARE    | BOOT FW  |
5023            |HDR|<--TEXT-->|<--DATA-->|<--TEXT-->|<--DATA-->|<--TEXT-->| */
5024
5025         fw->main.textsz = le32toh(hdr->rtextsz);
5026         fw->main.datasz = le32toh(hdr->rdatasz);
5027         fw->init.textsz = le32toh(hdr->itextsz);
5028         fw->init.datasz = le32toh(hdr->idatasz);
5029         fw->boot.textsz = le32toh(hdr->btextsz);
5030         fw->boot.datasz = 0;
5031
5032         /* Sanity-check firmware header. */
5033         if (fw->main.textsz > WPI_FW_TEXT_MAXSZ ||
5034             fw->main.datasz > WPI_FW_DATA_MAXSZ ||
5035             fw->init.textsz > WPI_FW_TEXT_MAXSZ ||
5036             fw->init.datasz > WPI_FW_DATA_MAXSZ ||
5037             fw->boot.textsz > WPI_FW_BOOT_TEXT_MAXSZ ||
5038             (fw->boot.textsz & 3) != 0) {
5039                 device_printf(sc->sc_dev, "invalid firmware header\n");
5040                 error = EINVAL;
5041                 goto fail;
5042         }
5043
5044         /* Check that all firmware sections fit. */
5045         if (fw->size < sizeof (*hdr) + fw->main.textsz + fw->main.datasz +
5046             fw->init.textsz + fw->init.datasz + fw->boot.textsz) {
5047                 device_printf(sc->sc_dev,
5048                     "firmware file too short: %zu bytes\n", fw->size);
5049                 error = EINVAL;
5050                 goto fail;
5051         }
5052
5053         /* Get pointers to firmware sections. */
5054         fw->main.text = (const uint8_t *)(hdr + 1);
5055         fw->main.data = fw->main.text + fw->main.textsz;
5056         fw->init.text = fw->main.data + fw->main.datasz;
5057         fw->init.data = fw->init.text + fw->init.textsz;
5058         fw->boot.text = fw->init.data + fw->init.datasz;
5059
5060         DPRINTF(sc, WPI_DEBUG_FIRMWARE,
5061             "Firmware Version: Major %d, Minor %d, Driver %d, \n"
5062             "runtime (text: %u, data: %u) init (text: %u, data %u) "
5063             "boot (text %u)\n", hdr->major, hdr->minor, le32toh(hdr->driver),
5064             fw->main.textsz, fw->main.datasz,
5065             fw->init.textsz, fw->init.datasz, fw->boot.textsz);
5066
5067         DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->main.text %p\n", fw->main.text);
5068         DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->main.data %p\n", fw->main.data);
5069         DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->init.text %p\n", fw->init.text);
5070         DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->init.data %p\n", fw->init.data);
5071         DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->boot.text %p\n", fw->boot.text);
5072
5073         return 0;
5074
5075 fail:   wpi_unload_firmware(sc);
5076         return error;
5077 }
5078
5079 /**
5080  * Free the referenced firmware image
5081  */
5082 static void
5083 wpi_unload_firmware(struct wpi_softc *sc)
5084 {
5085         if (sc->fw_fp != NULL) {
5086                 firmware_put(sc->fw_fp, FIRMWARE_UNLOAD);
5087                 sc->fw_fp = NULL;
5088         }
5089 }
5090
5091 static int
5092 wpi_clock_wait(struct wpi_softc *sc)
5093 {
5094         int ntries;
5095
5096         /* Set "initialization complete" bit. */
5097         WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_INIT_DONE);
5098
5099         /* Wait for clock stabilization. */
5100         for (ntries = 0; ntries < 2500; ntries++) {
5101                 if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_MAC_CLOCK_READY)
5102                         return 0;
5103                 DELAY(100);
5104         }
5105         device_printf(sc->sc_dev,
5106             "%s: timeout waiting for clock stabilization\n", __func__);
5107
5108         return ETIMEDOUT;
5109 }
5110
5111 static int
5112 wpi_apm_init(struct wpi_softc *sc)
5113 {
5114         uint32_t reg;
5115         int error;
5116
5117         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
5118
5119         /* Disable L0s exit timer (NMI bug workaround). */
5120         WPI_SETBITS(sc, WPI_GIO_CHICKEN, WPI_GIO_CHICKEN_DIS_L0S_TIMER);
5121         /* Don't wait for ICH L0s (ICH bug workaround). */
5122         WPI_SETBITS(sc, WPI_GIO_CHICKEN, WPI_GIO_CHICKEN_L1A_NO_L0S_RX);
5123
5124         /* Set FH wait threshold to max (HW bug under stress workaround). */
5125         WPI_SETBITS(sc, WPI_DBG_HPET_MEM, 0xffff0000);
5126
5127         /* Retrieve PCIe Active State Power Management (ASPM). */
5128         reg = pci_read_config(sc->sc_dev, sc->sc_cap_off + 0x10, 1);
5129         /* Workaround for HW instability in PCIe L0->L0s->L1 transition. */
5130         if (reg & 0x02) /* L1 Entry enabled. */
5131                 WPI_SETBITS(sc, WPI_GIO, WPI_GIO_L0S_ENA);
5132         else
5133                 WPI_CLRBITS(sc, WPI_GIO, WPI_GIO_L0S_ENA);
5134
5135         WPI_SETBITS(sc, WPI_ANA_PLL, WPI_ANA_PLL_INIT);
5136
5137         /* Wait for clock stabilization before accessing prph. */
5138         if ((error = wpi_clock_wait(sc)) != 0)
5139                 return error;
5140
5141         if ((error = wpi_nic_lock(sc)) != 0)
5142                 return error;
5143         /* Cleanup. */
5144         wpi_prph_write(sc, WPI_APMG_CLK_DIS, 0x00000400);
5145         wpi_prph_clrbits(sc, WPI_APMG_PS, 0x00000200);
5146
5147         /* Enable DMA and BSM (Bootstrap State Machine). */
5148         wpi_prph_write(sc, WPI_APMG_CLK_EN,
5149             WPI_APMG_CLK_CTRL_DMA_CLK_RQT | WPI_APMG_CLK_CTRL_BSM_CLK_RQT);
5150         DELAY(20);
5151         /* Disable L1-Active. */
5152         wpi_prph_setbits(sc, WPI_APMG_PCI_STT, WPI_APMG_PCI_STT_L1A_DIS);
5153         wpi_nic_unlock(sc);
5154
5155         return 0;
5156 }
5157
5158 static void
5159 wpi_apm_stop_master(struct wpi_softc *sc)
5160 {
5161         int ntries;
5162
5163         /* Stop busmaster DMA activity. */
5164         WPI_SETBITS(sc, WPI_RESET, WPI_RESET_STOP_MASTER);
5165
5166         if ((WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_PS_MASK) ==
5167             WPI_GP_CNTRL_MAC_PS)
5168                 return; /* Already asleep. */
5169
5170         for (ntries = 0; ntries < 100; ntries++) {
5171                 if (WPI_READ(sc, WPI_RESET) & WPI_RESET_MASTER_DISABLED)
5172                         return;
5173                 DELAY(10);
5174         }
5175         device_printf(sc->sc_dev, "%s: timeout waiting for master\n",
5176             __func__);
5177 }
5178
5179 static void
5180 wpi_apm_stop(struct wpi_softc *sc)
5181 {
5182         wpi_apm_stop_master(sc);
5183
5184         /* Reset the entire device. */
5185         WPI_SETBITS(sc, WPI_RESET, WPI_RESET_SW);
5186         DELAY(10);
5187         /* Clear "initialization complete" bit. */
5188         WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_INIT_DONE);
5189 }
5190
5191 static void
5192 wpi_nic_config(struct wpi_softc *sc)
5193 {
5194         uint32_t rev;
5195
5196         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
5197
5198         /* voodoo from the Linux "driver".. */
5199         rev = pci_read_config(sc->sc_dev, PCIR_REVID, 1);
5200         if ((rev & 0xc0) == 0x40)
5201                 WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_ALM_MB);
5202         else if (!(rev & 0x80))
5203                 WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_ALM_MM);
5204
5205         if (sc->cap == 0x80)
5206                 WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_SKU_MRC);
5207
5208         if ((sc->rev & 0xf0) == 0xd0)
5209                 WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_REV_D);
5210         else
5211                 WPI_CLRBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_REV_D);
5212
5213         if (sc->type > 1)
5214                 WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_TYPE_B);
5215 }
5216
5217 static int
5218 wpi_hw_init(struct wpi_softc *sc)
5219 {
5220         int chnl, ntries, error;
5221
5222         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
5223
5224         /* Clear pending interrupts. */
5225         WPI_WRITE(sc, WPI_INT, 0xffffffff);
5226
5227         if ((error = wpi_apm_init(sc)) != 0) {
5228                 device_printf(sc->sc_dev,
5229                     "%s: could not power ON adapter, error %d\n", __func__,
5230                     error);
5231                 return error;
5232         }
5233
5234         /* Select VMAIN power source. */
5235         if ((error = wpi_nic_lock(sc)) != 0)
5236                 return error;
5237         wpi_prph_clrbits(sc, WPI_APMG_PS, WPI_APMG_PS_PWR_SRC_MASK);
5238         wpi_nic_unlock(sc);
5239         /* Spin until VMAIN gets selected. */
5240         for (ntries = 0; ntries < 5000; ntries++) {
5241                 if (WPI_READ(sc, WPI_GPIO_IN) & WPI_GPIO_IN_VMAIN)
5242                         break;
5243                 DELAY(10);
5244         }
5245         if (ntries == 5000) {
5246                 device_printf(sc->sc_dev, "timeout selecting power source\n");
5247                 return ETIMEDOUT;
5248         }
5249
5250         /* Perform adapter initialization. */
5251         wpi_nic_config(sc);
5252
5253         /* Initialize RX ring. */
5254         if ((error = wpi_nic_lock(sc)) != 0)
5255                 return error;
5256         /* Set physical address of RX ring. */
5257         WPI_WRITE(sc, WPI_FH_RX_BASE, sc->rxq.desc_dma.paddr);
5258         /* Set physical address of RX read pointer. */
5259         WPI_WRITE(sc, WPI_FH_RX_RPTR_ADDR, sc->shared_dma.paddr +
5260             offsetof(struct wpi_shared, next));
5261         WPI_WRITE(sc, WPI_FH_RX_WPTR, 0);
5262         /* Enable RX. */
5263         WPI_WRITE(sc, WPI_FH_RX_CONFIG,
5264             WPI_FH_RX_CONFIG_DMA_ENA |
5265             WPI_FH_RX_CONFIG_RDRBD_ENA |
5266             WPI_FH_RX_CONFIG_WRSTATUS_ENA |
5267             WPI_FH_RX_CONFIG_MAXFRAG |
5268             WPI_FH_RX_CONFIG_NRBD(WPI_RX_RING_COUNT_LOG) |
5269             WPI_FH_RX_CONFIG_IRQ_DST_HOST |
5270             WPI_FH_RX_CONFIG_IRQ_TIMEOUT(1));
5271         (void)WPI_READ(sc, WPI_FH_RSSR_TBL);    /* barrier */
5272         wpi_nic_unlock(sc);
5273         WPI_WRITE(sc, WPI_FH_RX_WPTR, (WPI_RX_RING_COUNT - 1) & ~7);
5274
5275         /* Initialize TX rings. */
5276         if ((error = wpi_nic_lock(sc)) != 0)
5277                 return error;
5278         wpi_prph_write(sc, WPI_ALM_SCHED_MODE, 2);      /* bypass mode */
5279         wpi_prph_write(sc, WPI_ALM_SCHED_ARASTAT, 1);   /* enable RA0 */
5280         /* Enable all 6 TX rings. */
5281         wpi_prph_write(sc, WPI_ALM_SCHED_TXFACT, 0x3f);
5282         wpi_prph_write(sc, WPI_ALM_SCHED_SBYPASS_MODE1, 0x10000);
5283         wpi_prph_write(sc, WPI_ALM_SCHED_SBYPASS_MODE2, 0x30002);
5284         wpi_prph_write(sc, WPI_ALM_SCHED_TXF4MF, 4);
5285         wpi_prph_write(sc, WPI_ALM_SCHED_TXF5MF, 5);
5286         /* Set physical address of TX rings. */
5287         WPI_WRITE(sc, WPI_FH_TX_BASE, sc->shared_dma.paddr);
5288         WPI_WRITE(sc, WPI_FH_MSG_CONFIG, 0xffff05a5);
5289
5290         /* Enable all DMA channels. */
5291         for (chnl = 0; chnl < WPI_NDMACHNLS; chnl++) {
5292                 WPI_WRITE(sc, WPI_FH_CBBC_CTRL(chnl), 0);
5293                 WPI_WRITE(sc, WPI_FH_CBBC_BASE(chnl), 0);
5294                 WPI_WRITE(sc, WPI_FH_TX_CONFIG(chnl), 0x80200008);
5295         }
5296         wpi_nic_unlock(sc);
5297         (void)WPI_READ(sc, WPI_FH_TX_BASE);     /* barrier */
5298
5299         /* Clear "radio off" and "commands blocked" bits. */
5300         WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL);
5301         WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_CMD_BLOCKED);
5302
5303         /* Clear pending interrupts. */
5304         WPI_WRITE(sc, WPI_INT, 0xffffffff);
5305         /* Enable interrupts. */
5306         WPI_WRITE(sc, WPI_INT_MASK, WPI_INT_MASK_DEF);
5307
5308         /* _Really_ make sure "radio off" bit is cleared! */
5309         WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL);
5310         WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL);
5311
5312         if ((error = wpi_load_firmware(sc)) != 0) {
5313                 device_printf(sc->sc_dev,
5314                     "%s: could not load firmware, error %d\n", __func__,
5315                     error);
5316                 return error;
5317         }
5318         /* Wait at most one second for firmware alive notification. */
5319         if ((error = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) {
5320                 device_printf(sc->sc_dev,
5321                     "%s: timeout waiting for adapter to initialize, error %d\n",
5322                     __func__, error);
5323                 return error;
5324         }
5325
5326         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
5327
5328         /* Do post-firmware initialization. */
5329         return wpi_post_alive(sc);
5330 }
5331
5332 static void
5333 wpi_hw_stop(struct wpi_softc *sc)
5334 {
5335         int chnl, qid, ntries;
5336
5337         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
5338
5339         if (WPI_READ(sc, WPI_UCODE_GP1) & WPI_UCODE_GP1_MAC_SLEEP)
5340                 wpi_nic_lock(sc);
5341
5342         WPI_WRITE(sc, WPI_RESET, WPI_RESET_NEVO);
5343
5344         /* Disable interrupts. */
5345         WPI_WRITE(sc, WPI_INT_MASK, 0);
5346         WPI_WRITE(sc, WPI_INT, 0xffffffff);
5347         WPI_WRITE(sc, WPI_FH_INT, 0xffffffff);
5348
5349         /* Make sure we no longer hold the NIC lock. */
5350         wpi_nic_unlock(sc);
5351
5352         if (wpi_nic_lock(sc) == 0) {
5353                 /* Stop TX scheduler. */
5354                 wpi_prph_write(sc, WPI_ALM_SCHED_MODE, 0);
5355                 wpi_prph_write(sc, WPI_ALM_SCHED_TXFACT, 0);
5356
5357                 /* Stop all DMA channels. */
5358                 for (chnl = 0; chnl < WPI_NDMACHNLS; chnl++) {
5359                         WPI_WRITE(sc, WPI_FH_TX_CONFIG(chnl), 0);
5360                         for (ntries = 0; ntries < 200; ntries++) {
5361                                 if (WPI_READ(sc, WPI_FH_TX_STATUS) &
5362                                     WPI_FH_TX_STATUS_IDLE(chnl))
5363                                         break;
5364                                 DELAY(10);
5365                         }
5366                 }
5367                 wpi_nic_unlock(sc);
5368         }
5369
5370         /* Stop RX ring. */
5371         wpi_reset_rx_ring(sc);
5372
5373         /* Reset all TX rings. */
5374         for (qid = 0; qid < WPI_NTXQUEUES; qid++)
5375                 wpi_reset_tx_ring(sc, &sc->txq[qid]);
5376
5377         if (wpi_nic_lock(sc) == 0) {
5378                 wpi_prph_write(sc, WPI_APMG_CLK_DIS,
5379                     WPI_APMG_CLK_CTRL_DMA_CLK_RQT);
5380                 wpi_nic_unlock(sc);
5381         }
5382         DELAY(5);
5383         /* Power OFF adapter. */
5384         wpi_apm_stop(sc);
5385 }
5386
5387 static void
5388 wpi_radio_on(void *arg0, int pending)
5389 {
5390         struct wpi_softc *sc = arg0;
5391         struct ifnet *ifp = sc->sc_ifp;
5392         struct ieee80211com *ic = ifp->if_l2com;
5393         struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
5394
5395         device_printf(sc->sc_dev, "RF switch: radio enabled\n");
5396
5397         if (vap != NULL) {
5398                 wpi_init(sc);
5399                 ieee80211_init(vap);
5400         }
5401
5402         if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_RFKILL) {
5403                 WPI_LOCK(sc);
5404                 callout_stop(&sc->watchdog_rfkill);
5405                 WPI_UNLOCK(sc);
5406         }
5407 }
5408
5409 static void
5410 wpi_radio_off(void *arg0, int pending)
5411 {
5412         struct wpi_softc *sc = arg0;
5413         struct ifnet *ifp = sc->sc_ifp;
5414         struct ieee80211com *ic = ifp->if_l2com;
5415         struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
5416
5417         device_printf(sc->sc_dev, "RF switch: radio disabled\n");
5418
5419         wpi_stop(sc);
5420         if (vap != NULL)
5421                 ieee80211_stop(vap);
5422
5423         WPI_LOCK(sc);
5424         callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill, sc);
5425         WPI_UNLOCK(sc);
5426 }
5427
5428 static void
5429 wpi_init(void *arg)
5430 {
5431         struct wpi_softc *sc = arg;
5432         struct ifnet *ifp = sc->sc_ifp;
5433         struct ieee80211com *ic = ifp->if_l2com;
5434         int error;
5435
5436         WPI_LOCK(sc);
5437
5438         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__);
5439
5440         if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0)
5441                 goto end;
5442
5443         /* Check that the radio is not disabled by hardware switch. */
5444         if (!(WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_RFKILL)) {
5445                 device_printf(sc->sc_dev,
5446                     "RF switch: radio disabled (%s)\n", __func__);
5447                 callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill,
5448                     sc);
5449                 goto end;
5450         }
5451
5452         /* Read firmware images from the filesystem. */
5453         if ((error = wpi_read_firmware(sc)) != 0) {
5454                 device_printf(sc->sc_dev,
5455                     "%s: could not read firmware, error %d\n", __func__,
5456                     error);
5457                 goto fail;
5458         }
5459
5460         /* Initialize hardware and upload firmware. */
5461         error = wpi_hw_init(sc);
5462         wpi_unload_firmware(sc);
5463         if (error != 0) {
5464                 device_printf(sc->sc_dev,
5465                     "%s: could not initialize hardware, error %d\n", __func__,
5466                     error);
5467                 goto fail;
5468         }
5469
5470         /* Configure adapter now that it is ready. */
5471         sc->txq_active = 1;
5472         if ((error = wpi_config(sc)) != 0) {
5473                 device_printf(sc->sc_dev,
5474                     "%s: could not configure device, error %d\n", __func__,
5475                     error);
5476                 goto fail;
5477         }
5478
5479         IF_LOCK(&ifp->if_snd);
5480         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
5481         ifp->if_drv_flags |= IFF_DRV_RUNNING;
5482         IF_UNLOCK(&ifp->if_snd);
5483
5484         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__);
5485
5486         WPI_UNLOCK(sc);
5487
5488         ieee80211_start_all(ic);
5489
5490         return;
5491
5492 fail:   wpi_stop_locked(sc);
5493 end:    DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__);
5494         WPI_UNLOCK(sc);
5495 }
5496
5497 static void
5498 wpi_stop_locked(struct wpi_softc *sc)
5499 {
5500         struct ifnet *ifp = sc->sc_ifp;
5501
5502         WPI_LOCK_ASSERT(sc);
5503
5504         WPI_TXQ_LOCK(sc);
5505         sc->txq_active = 0;
5506         WPI_TXQ_UNLOCK(sc);
5507
5508         WPI_TXQ_STATE_LOCK(sc);
5509         callout_stop(&sc->tx_timeout);
5510         WPI_TXQ_STATE_UNLOCK(sc);
5511
5512         WPI_RXON_LOCK(sc);
5513         callout_stop(&sc->scan_timeout);
5514         callout_stop(&sc->calib_to);
5515         WPI_RXON_UNLOCK(sc);
5516
5517         IF_LOCK(&ifp->if_snd);
5518         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
5519         IF_UNLOCK(&ifp->if_snd);
5520
5521         /* Power OFF hardware. */
5522         wpi_hw_stop(sc);
5523 }
5524
5525 static void
5526 wpi_stop(struct wpi_softc *sc)
5527 {
5528         WPI_LOCK(sc);
5529         wpi_stop_locked(sc);
5530         WPI_UNLOCK(sc);
5531 }
5532
5533 /*
5534  * Callback from net80211 to start a scan.
5535  */
5536 static void
5537 wpi_scan_start(struct ieee80211com *ic)
5538 {
5539         struct wpi_softc *sc = ic->ic_ifp->if_softc;
5540
5541         wpi_set_led(sc, WPI_LED_LINK, 20, 2);
5542 }
5543
5544 /*
5545  * Callback from net80211 to terminate a scan.
5546  */
5547 static void
5548 wpi_scan_end(struct ieee80211com *ic)
5549 {
5550         struct ifnet *ifp = ic->ic_ifp;
5551         struct wpi_softc *sc = ifp->if_softc;
5552         struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
5553
5554         if (vap->iv_state == IEEE80211_S_RUN)
5555                 wpi_set_led(sc, WPI_LED_LINK, 0, 1);
5556 }
5557
5558 /**
5559  * Called by the net80211 framework to indicate to the driver
5560  * that the channel should be changed
5561  */
5562 static void
5563 wpi_set_channel(struct ieee80211com *ic)
5564 {
5565         const struct ieee80211_channel *c = ic->ic_curchan;
5566         struct ifnet *ifp = ic->ic_ifp;
5567         struct wpi_softc *sc = ifp->if_softc;
5568         int error;
5569
5570         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
5571
5572         WPI_LOCK(sc);
5573         sc->sc_rxtap.wr_chan_freq = htole16(c->ic_freq);
5574         sc->sc_rxtap.wr_chan_flags = htole16(c->ic_flags);
5575         WPI_UNLOCK(sc);
5576         WPI_TX_LOCK(sc);
5577         sc->sc_txtap.wt_chan_freq = htole16(c->ic_freq);
5578         sc->sc_txtap.wt_chan_flags = htole16(c->ic_flags);
5579         WPI_TX_UNLOCK(sc);
5580
5581         /*
5582          * Only need to set the channel in Monitor mode. AP scanning and auth
5583          * are already taken care of by their respective firmware commands.
5584          */
5585         if (ic->ic_opmode == IEEE80211_M_MONITOR) {
5586                 WPI_RXON_LOCK(sc);
5587                 sc->rxon.chan = ieee80211_chan2ieee(ic, c);
5588                 if (IEEE80211_IS_CHAN_2GHZ(c)) {
5589                         sc->rxon.flags |= htole32(WPI_RXON_AUTO |
5590                             WPI_RXON_24GHZ);
5591                 } else {
5592                         sc->rxon.flags &= ~htole32(WPI_RXON_AUTO |
5593                             WPI_RXON_24GHZ);
5594                 }
5595                 if ((error = wpi_send_rxon(sc, 0, 1)) != 0)
5596                         device_printf(sc->sc_dev,
5597                             "%s: error %d setting channel\n", __func__,
5598                             error);
5599                 WPI_RXON_UNLOCK(sc);
5600         }
5601 }
5602
5603 /**
5604  * Called by net80211 to indicate that we need to scan the current
5605  * channel. The channel is previously be set via the wpi_set_channel
5606  * callback.
5607  */
5608 static void
5609 wpi_scan_curchan(struct ieee80211_scan_state *ss, unsigned long maxdwell)
5610 {
5611         struct ieee80211vap *vap = ss->ss_vap;
5612         struct ieee80211com *ic = vap->iv_ic;
5613         struct wpi_softc *sc = ic->ic_ifp->if_softc;
5614         int error;
5615
5616         WPI_RXON_LOCK(sc);
5617         error = wpi_scan(sc, ic->ic_curchan);
5618         WPI_RXON_UNLOCK(sc);
5619         if (error != 0)
5620                 ieee80211_cancel_scan(vap);
5621 }
5622
5623 /**
5624  * Called by the net80211 framework to indicate
5625  * the minimum dwell time has been met, terminate the scan.
5626  * We don't actually terminate the scan as the firmware will notify
5627  * us when it's finished and we have no way to interrupt it.
5628  */
5629 static void
5630 wpi_scan_mindwell(struct ieee80211_scan_state *ss)
5631 {
5632         /* NB: don't try to abort scan; wait for firmware to finish */
5633 }
5634
5635 static void
5636 wpi_hw_reset(void *arg, int pending)
5637 {
5638         struct wpi_softc *sc = arg;
5639         struct ifnet *ifp = sc->sc_ifp;
5640         struct ieee80211com *ic = ifp->if_l2com;
5641         struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
5642
5643         DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__);
5644
5645         if (vap != NULL && (ic->ic_flags & IEEE80211_F_SCAN))
5646                 ieee80211_cancel_scan(vap);
5647
5648         wpi_stop(sc);
5649         if (vap != NULL)
5650                 ieee80211_stop(vap);
5651         wpi_init(sc);
5652         if (vap != NULL)
5653                 ieee80211_init(vap);
5654 }