16607310bSBenjamin Close /*- 26607310bSBenjamin Close * Copyright (c) 2006,2007 36607310bSBenjamin Close * Damien Bergamini <damien.bergamini@free.fr> 46607310bSBenjamin Close * Benjamin Close <Benjamin.Close@clearchain.com> 5ce036b51SAndriy Voskoboinyk * Copyright (c) 2015 Andriy Voskoboinyk <avos@FreeBSD.org> 66607310bSBenjamin Close * 76607310bSBenjamin Close * Permission to use, copy, modify, and distribute this software for any 86607310bSBenjamin Close * purpose with or without fee is hereby granted, provided that the above 96607310bSBenjamin Close * copyright notice and this permission notice appear in all copies. 106607310bSBenjamin Close * 116607310bSBenjamin Close * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 126607310bSBenjamin Close * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 136607310bSBenjamin Close * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 146607310bSBenjamin Close * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 156607310bSBenjamin Close * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 166607310bSBenjamin Close * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 176607310bSBenjamin Close * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 186607310bSBenjamin Close */ 196607310bSBenjamin Close 206607310bSBenjamin Close #include <sys/cdefs.h> 216607310bSBenjamin Close __FBSDID("$FreeBSD$"); 226607310bSBenjamin Close 236607310bSBenjamin Close /* 246607310bSBenjamin Close * Driver for Intel PRO/Wireless 3945ABG 802.11 network adapters. 256607310bSBenjamin Close * 266607310bSBenjamin Close * The 3945ABG network adapter doesn't use traditional hardware as 276607310bSBenjamin Close * many other adaptors do. Instead at run time the eeprom is set into a known 286607310bSBenjamin Close * state and told to load boot firmware. The boot firmware loads an init and a 296607310bSBenjamin Close * main binary firmware image into SRAM on the card via DMA. 306607310bSBenjamin Close * Once the firmware is loaded, the driver/hw then 316bccea7cSRebecca Cran * communicate by way of circular dma rings via the SRAM to the firmware. 326607310bSBenjamin Close * 336607310bSBenjamin Close * There is 6 memory rings. 1 command ring, 1 rx data ring & 4 tx data rings. 346607310bSBenjamin Close * The 4 tx data rings allow for prioritization QoS. 356607310bSBenjamin Close * 366607310bSBenjamin Close * The rx data ring consists of 32 dma buffers. Two registers are used to 376607310bSBenjamin Close * indicate where in the ring the driver and the firmware are up to. The 386607310bSBenjamin Close * driver sets the initial read index (reg1) and the initial write index (reg2), 396607310bSBenjamin Close * the firmware updates the read index (reg1) on rx of a packet and fires an 406607310bSBenjamin Close * interrupt. The driver then processes the buffers starting at reg1 indicating 416607310bSBenjamin Close * to the firmware which buffers have been accessed by updating reg2. At the 426607310bSBenjamin Close * same time allocating new memory for the processed buffer. 436607310bSBenjamin Close * 446607310bSBenjamin Close * A similar thing happens with the tx rings. The difference is the firmware 456607310bSBenjamin Close * stop processing buffers once the queue is full and until confirmation 46fae61c69SAdrian Chadd * of a successful transmition (tx_done) has occurred. 476607310bSBenjamin Close * 486607310bSBenjamin Close * The command ring operates in the same manner as the tx queues. 496607310bSBenjamin Close * 506607310bSBenjamin Close * All communication direct to the card (ie eeprom) is classed as Stage1 516607310bSBenjamin Close * communication 526607310bSBenjamin Close * 536607310bSBenjamin Close * All communication via the firmware to the card is classed as State2. 546607310bSBenjamin Close * The firmware consists of 2 parts. A bootstrap firmware and a runtime 556607310bSBenjamin Close * firmware. The bootstrap firmware and runtime firmware are loaded 566607310bSBenjamin Close * from host memory via dma to the card then told to execute. From this point 576607310bSBenjamin Close * on the majority of communications between the driver and the card goes 586607310bSBenjamin Close * via the firmware. 596607310bSBenjamin Close */ 606607310bSBenjamin Close 6181c2214dSAdrian Chadd #include "opt_wlan.h" 62692ad7caSAdrian Chadd #include "opt_wpi.h" 6381c2214dSAdrian Chadd 646607310bSBenjamin Close #include <sys/param.h> 656607310bSBenjamin Close #include <sys/sysctl.h> 666607310bSBenjamin Close #include <sys/sockio.h> 676607310bSBenjamin Close #include <sys/mbuf.h> 686607310bSBenjamin Close #include <sys/kernel.h> 696607310bSBenjamin Close #include <sys/socket.h> 706607310bSBenjamin Close #include <sys/systm.h> 716607310bSBenjamin Close #include <sys/malloc.h> 726607310bSBenjamin Close #include <sys/queue.h> 736607310bSBenjamin Close #include <sys/taskqueue.h> 746607310bSBenjamin Close #include <sys/module.h> 756607310bSBenjamin Close #include <sys/bus.h> 766607310bSBenjamin Close #include <sys/endian.h> 776607310bSBenjamin Close #include <sys/linker.h> 786607310bSBenjamin Close #include <sys/firmware.h> 796607310bSBenjamin Close 806607310bSBenjamin Close #include <machine/bus.h> 816607310bSBenjamin Close #include <machine/resource.h> 826607310bSBenjamin Close #include <sys/rman.h> 836607310bSBenjamin Close 846607310bSBenjamin Close #include <dev/pci/pcireg.h> 856607310bSBenjamin Close #include <dev/pci/pcivar.h> 866607310bSBenjamin Close 876607310bSBenjamin Close #include <net/bpf.h> 886607310bSBenjamin Close #include <net/if.h> 8976039bc8SGleb Smirnoff #include <net/if_var.h> 906607310bSBenjamin Close #include <net/if_arp.h> 916607310bSBenjamin Close #include <net/ethernet.h> 926607310bSBenjamin Close #include <net/if_dl.h> 936607310bSBenjamin Close #include <net/if_media.h> 946607310bSBenjamin Close #include <net/if_types.h> 956607310bSBenjamin Close 96692ad7caSAdrian Chadd #include <netinet/in.h> 97692ad7caSAdrian Chadd #include <netinet/in_systm.h> 98692ad7caSAdrian Chadd #include <netinet/in_var.h> 99692ad7caSAdrian Chadd #include <netinet/if_ether.h> 100692ad7caSAdrian Chadd #include <netinet/ip.h> 101692ad7caSAdrian Chadd 1026607310bSBenjamin Close #include <net80211/ieee80211_var.h> 1036607310bSBenjamin Close #include <net80211/ieee80211_radiotap.h> 1046607310bSBenjamin Close #include <net80211/ieee80211_regdomain.h> 105b6108616SRui Paulo #include <net80211/ieee80211_ratectl.h> 1066607310bSBenjamin Close 1076607310bSBenjamin Close #include <dev/wpi/if_wpireg.h> 1086607310bSBenjamin Close #include <dev/wpi/if_wpivar.h> 109692ad7caSAdrian Chadd #include <dev/wpi/if_wpi_debug.h> 1106607310bSBenjamin Close 1116607310bSBenjamin Close struct wpi_ident { 1126607310bSBenjamin Close uint16_t vendor; 1136607310bSBenjamin Close uint16_t device; 1146607310bSBenjamin Close uint16_t subdevice; 1156607310bSBenjamin Close const char *name; 1166607310bSBenjamin Close }; 1176607310bSBenjamin Close 1186607310bSBenjamin Close static const struct wpi_ident wpi_ident_table[] = { 1196607310bSBenjamin Close /* The below entries support ABG regardless of the subid */ 1206607310bSBenjamin Close { 0x8086, 0x4222, 0x0, "Intel(R) PRO/Wireless 3945ABG" }, 1216607310bSBenjamin Close { 0x8086, 0x4227, 0x0, "Intel(R) PRO/Wireless 3945ABG" }, 1226607310bSBenjamin Close /* The below entries only support BG */ 12334f004ceSBenjamin Close { 0x8086, 0x4222, 0x1005, "Intel(R) PRO/Wireless 3945BG" }, 12434f004ceSBenjamin Close { 0x8086, 0x4222, 0x1034, "Intel(R) PRO/Wireless 3945BG" }, 12534f004ceSBenjamin Close { 0x8086, 0x4227, 0x1014, "Intel(R) PRO/Wireless 3945BG" }, 12634f004ceSBenjamin Close { 0x8086, 0x4222, 0x1044, "Intel(R) PRO/Wireless 3945BG" }, 1276607310bSBenjamin Close { 0, 0, 0, NULL } 1286607310bSBenjamin Close }; 1296607310bSBenjamin Close 130692ad7caSAdrian Chadd static int wpi_probe(device_t); 131692ad7caSAdrian Chadd static int wpi_attach(device_t); 132692ad7caSAdrian Chadd static void wpi_radiotap_attach(struct wpi_softc *); 133692ad7caSAdrian Chadd static void wpi_sysctlattach(struct wpi_softc *); 13421f6580eSAdrian Chadd static void wpi_init_beacon(struct wpi_vap *); 135b032f27cSSam Leffler static struct ieee80211vap *wpi_vap_create(struct ieee80211com *, 136fcd9500fSBernhard Schmidt const char [IFNAMSIZ], int, enum ieee80211_opmode, int, 137fcd9500fSBernhard Schmidt const uint8_t [IEEE80211_ADDR_LEN], 138fcd9500fSBernhard Schmidt const uint8_t [IEEE80211_ADDR_LEN]); 139b032f27cSSam Leffler static void wpi_vap_delete(struct ieee80211vap *); 140692ad7caSAdrian Chadd static int wpi_detach(device_t); 141692ad7caSAdrian Chadd static int wpi_shutdown(device_t); 142692ad7caSAdrian Chadd static int wpi_suspend(device_t); 143692ad7caSAdrian Chadd static int wpi_resume(device_t); 144692ad7caSAdrian Chadd static int wpi_nic_lock(struct wpi_softc *); 145692ad7caSAdrian Chadd static int wpi_read_prom_data(struct wpi_softc *, uint32_t, void *, int); 1466607310bSBenjamin Close static void wpi_dma_map_addr(void *, bus_dma_segment_t *, int, int); 147692ad7caSAdrian Chadd static int wpi_dma_contig_alloc(struct wpi_softc *, struct wpi_dma_info *, 148692ad7caSAdrian Chadd void **, bus_size_t, bus_size_t); 149692ad7caSAdrian Chadd static void wpi_dma_contig_free(struct wpi_dma_info *); 1506607310bSBenjamin Close static int wpi_alloc_shared(struct wpi_softc *); 1516607310bSBenjamin Close static void wpi_free_shared(struct wpi_softc *); 1526607310bSBenjamin Close static int wpi_alloc_fwmem(struct wpi_softc *); 1536607310bSBenjamin Close static void wpi_free_fwmem(struct wpi_softc *); 154692ad7caSAdrian Chadd static int wpi_alloc_rx_ring(struct wpi_softc *); 155692ad7caSAdrian Chadd static void wpi_update_rx_ring(struct wpi_softc *); 1565cacb17fSAdrian Chadd static void wpi_update_rx_ring_ps(struct wpi_softc *); 157692ad7caSAdrian Chadd static void wpi_reset_rx_ring(struct wpi_softc *); 158692ad7caSAdrian Chadd static void wpi_free_rx_ring(struct wpi_softc *); 159692ad7caSAdrian Chadd static int wpi_alloc_tx_ring(struct wpi_softc *, struct wpi_tx_ring *, 160525a3d47SAdrian Chadd uint8_t); 161692ad7caSAdrian Chadd static void wpi_update_tx_ring(struct wpi_softc *, struct wpi_tx_ring *); 1625cacb17fSAdrian Chadd static void wpi_update_tx_ring_ps(struct wpi_softc *, 1635cacb17fSAdrian Chadd struct wpi_tx_ring *); 164692ad7caSAdrian Chadd static void wpi_reset_tx_ring(struct wpi_softc *, struct wpi_tx_ring *); 165692ad7caSAdrian Chadd static void wpi_free_tx_ring(struct wpi_softc *, struct wpi_tx_ring *); 166692ad7caSAdrian Chadd static int wpi_read_eeprom(struct wpi_softc *, 167692ad7caSAdrian Chadd uint8_t macaddr[IEEE80211_ADDR_LEN]); 168692ad7caSAdrian Chadd static uint32_t wpi_eeprom_channel_flags(struct wpi_eeprom_chan *); 1691c6b43dfSAndriy Voskoboinyk static void wpi_read_eeprom_band(struct wpi_softc *, uint8_t, int, int *, 1701c6b43dfSAndriy Voskoboinyk struct ieee80211_channel[]); 171525a3d47SAdrian Chadd static int wpi_read_eeprom_channels(struct wpi_softc *, uint8_t); 172692ad7caSAdrian Chadd static struct wpi_eeprom_chan *wpi_find_eeprom_channel(struct wpi_softc *, 173692ad7caSAdrian Chadd struct ieee80211_channel *); 1741c6b43dfSAndriy Voskoboinyk static void wpi_getradiocaps(struct ieee80211com *, int, int *, 1751c6b43dfSAndriy Voskoboinyk struct ieee80211_channel[]); 176692ad7caSAdrian Chadd static int wpi_setregdomain(struct ieee80211com *, 177692ad7caSAdrian Chadd struct ieee80211_regdomain *, int, 178692ad7caSAdrian Chadd struct ieee80211_channel[]); 179525a3d47SAdrian Chadd static int wpi_read_eeprom_group(struct wpi_softc *, uint8_t); 180692ad7caSAdrian Chadd static struct ieee80211_node *wpi_node_alloc(struct ieee80211vap *, 181692ad7caSAdrian Chadd const uint8_t mac[IEEE80211_ADDR_LEN]); 182a20c9affSAdrian Chadd static void wpi_node_free(struct ieee80211_node *); 18357c61f5dSAdrian Chadd static void wpi_ibss_recv_mgmt(struct ieee80211_node *, struct mbuf *, int, 184b66af287SAdrian Chadd const struct ieee80211_rx_stats *, 185b66af287SAdrian Chadd int, int); 186a20c9affSAdrian Chadd static void wpi_restore_node(void *, struct ieee80211_node *); 187a20c9affSAdrian Chadd static void wpi_restore_node_table(struct wpi_softc *, struct wpi_vap *); 188692ad7caSAdrian Chadd static int wpi_newstate(struct ieee80211vap *, enum ieee80211_state, int); 189692ad7caSAdrian Chadd static void wpi_calib_timeout(void *); 190692ad7caSAdrian Chadd static void wpi_rx_done(struct wpi_softc *, struct wpi_rx_desc *, 1916607310bSBenjamin Close struct wpi_rx_data *); 192692ad7caSAdrian Chadd static void wpi_rx_statistics(struct wpi_softc *, struct wpi_rx_desc *, 193692ad7caSAdrian Chadd struct wpi_rx_data *); 194692ad7caSAdrian Chadd static void wpi_tx_done(struct wpi_softc *, struct wpi_rx_desc *); 195692ad7caSAdrian Chadd static void wpi_cmd_done(struct wpi_softc *, struct wpi_rx_desc *); 1966607310bSBenjamin Close static void wpi_notif_intr(struct wpi_softc *); 197692ad7caSAdrian Chadd static void wpi_wakeup_intr(struct wpi_softc *); 198a6df6cfeSAdrian Chadd #ifdef WPI_DEBUG 199a6df6cfeSAdrian Chadd static void wpi_debug_registers(struct wpi_softc *); 200a6df6cfeSAdrian Chadd #endif 201692ad7caSAdrian Chadd static void wpi_fatal_intr(struct wpi_softc *); 2026607310bSBenjamin Close static void wpi_intr(void *); 203940aa808SAdrian Chadd static void wpi_free_txfrags(struct wpi_softc *, uint16_t); 204692ad7caSAdrian Chadd static int wpi_cmd2(struct wpi_softc *, struct wpi_buf *); 2056607310bSBenjamin Close static int wpi_tx_data(struct wpi_softc *, struct mbuf *, 206692ad7caSAdrian Chadd struct ieee80211_node *); 207692ad7caSAdrian Chadd static int wpi_tx_data_raw(struct wpi_softc *, struct mbuf *, 208692ad7caSAdrian Chadd struct ieee80211_node *, 209692ad7caSAdrian Chadd const struct ieee80211_bpf_params *); 210b032f27cSSam Leffler static int wpi_raw_xmit(struct ieee80211_node *, struct mbuf *, 211b032f27cSSam Leffler const struct ieee80211_bpf_params *); 2127a79cebfSGleb Smirnoff static int wpi_transmit(struct ieee80211com *, struct mbuf *); 213692ad7caSAdrian Chadd static void wpi_watchdog_rfkill(void *); 2140bc39fc6SAdrian Chadd static void wpi_scan_timeout(void *); 215d74e544aSAdrian Chadd static void wpi_tx_timeout(void *); 2167a79cebfSGleb Smirnoff static void wpi_parent(struct ieee80211com *); 217525a3d47SAdrian Chadd static int wpi_cmd(struct wpi_softc *, uint8_t, const void *, uint16_t, 218525a3d47SAdrian Chadd int); 219692ad7caSAdrian Chadd static int wpi_mrr_setup(struct wpi_softc *); 220692ad7caSAdrian Chadd static int wpi_add_node(struct wpi_softc *, struct ieee80211_node *); 221692ad7caSAdrian Chadd static int wpi_add_broadcast_node(struct wpi_softc *, int); 222692ad7caSAdrian Chadd static int wpi_add_ibss_node(struct wpi_softc *, struct ieee80211_node *); 223692ad7caSAdrian Chadd static void wpi_del_node(struct wpi_softc *, struct ieee80211_node *); 224692ad7caSAdrian Chadd static int wpi_updateedca(struct ieee80211com *); 225692ad7caSAdrian Chadd static void wpi_set_promisc(struct wpi_softc *); 226272f6adeSGleb Smirnoff static void wpi_update_promisc(struct ieee80211com *); 227272f6adeSGleb Smirnoff static void wpi_update_mcast(struct ieee80211com *); 228692ad7caSAdrian Chadd static void wpi_set_led(struct wpi_softc *, uint8_t, uint8_t, uint8_t); 229692ad7caSAdrian Chadd static int wpi_set_timing(struct wpi_softc *, struct ieee80211_node *); 230692ad7caSAdrian Chadd static void wpi_power_calibration(struct wpi_softc *); 231692ad7caSAdrian Chadd static int wpi_set_txpower(struct wpi_softc *, int); 232692ad7caSAdrian Chadd static int wpi_get_power_index(struct wpi_softc *, 233655e8ba8SAdrian Chadd struct wpi_power_group *, uint8_t, int, int); 234692ad7caSAdrian Chadd static int wpi_set_pslevel(struct wpi_softc *, uint8_t, int, int); 235692ad7caSAdrian Chadd static int wpi_send_btcoex(struct wpi_softc *); 236692ad7caSAdrian Chadd static int wpi_send_rxon(struct wpi_softc *, int, int); 237692ad7caSAdrian Chadd static int wpi_config(struct wpi_softc *); 238692ad7caSAdrian Chadd static uint16_t wpi_get_active_dwell_time(struct wpi_softc *, 239692ad7caSAdrian Chadd struct ieee80211_channel *, uint8_t); 240692ad7caSAdrian Chadd static uint16_t wpi_limit_dwell(struct wpi_softc *, uint16_t); 241692ad7caSAdrian Chadd static uint16_t wpi_get_passive_dwell_time(struct wpi_softc *, 242692ad7caSAdrian Chadd struct ieee80211_channel *); 243efccc3c6SAdrian Chadd static uint32_t wpi_get_scan_pause_time(uint32_t, uint16_t); 244692ad7caSAdrian Chadd static int wpi_scan(struct wpi_softc *, struct ieee80211_channel *); 245692ad7caSAdrian Chadd static int wpi_auth(struct wpi_softc *, struct ieee80211vap *); 2466f8421f8SAdrian Chadd static int wpi_config_beacon(struct wpi_vap *); 247692ad7caSAdrian Chadd static int wpi_setup_beacon(struct wpi_softc *, struct ieee80211_node *); 2486f8421f8SAdrian Chadd static void wpi_update_beacon(struct ieee80211vap *, int); 249d138d3baSAdrian Chadd static void wpi_newassoc(struct ieee80211_node *, int); 250692ad7caSAdrian Chadd static int wpi_run(struct wpi_softc *, struct ieee80211vap *); 251d29fcfb7SAdrian Chadd static int wpi_load_key(struct ieee80211_node *, 252d29fcfb7SAdrian Chadd const struct ieee80211_key *); 253d29fcfb7SAdrian Chadd static void wpi_load_key_cb(void *, struct ieee80211_node *); 254d29fcfb7SAdrian Chadd static int wpi_set_global_keys(struct ieee80211_node *); 255d29fcfb7SAdrian Chadd static int wpi_del_key(struct ieee80211_node *, 256d29fcfb7SAdrian Chadd const struct ieee80211_key *); 257d29fcfb7SAdrian Chadd static void wpi_del_key_cb(void *, struct ieee80211_node *); 258d29fcfb7SAdrian Chadd static int wpi_process_key(struct ieee80211vap *, 259d29fcfb7SAdrian Chadd const struct ieee80211_key *, int); 260692ad7caSAdrian Chadd static int wpi_key_set(struct ieee80211vap *, 261bc813c40SAdrian Chadd const struct ieee80211_key *); 262692ad7caSAdrian Chadd static int wpi_key_delete(struct ieee80211vap *, 263692ad7caSAdrian Chadd const struct ieee80211_key *); 264692ad7caSAdrian Chadd static int wpi_post_alive(struct wpi_softc *); 265525a3d47SAdrian Chadd static int wpi_load_bootcode(struct wpi_softc *, const uint8_t *, 266525a3d47SAdrian Chadd uint32_t); 267692ad7caSAdrian Chadd static int wpi_load_firmware(struct wpi_softc *); 268692ad7caSAdrian Chadd static int wpi_read_firmware(struct wpi_softc *); 269692ad7caSAdrian Chadd static void wpi_unload_firmware(struct wpi_softc *); 270692ad7caSAdrian Chadd static int wpi_clock_wait(struct wpi_softc *); 271692ad7caSAdrian Chadd static int wpi_apm_init(struct wpi_softc *); 272692ad7caSAdrian Chadd static void wpi_apm_stop_master(struct wpi_softc *); 273692ad7caSAdrian Chadd static void wpi_apm_stop(struct wpi_softc *); 274692ad7caSAdrian Chadd static void wpi_nic_config(struct wpi_softc *); 275692ad7caSAdrian Chadd static int wpi_hw_init(struct wpi_softc *); 276692ad7caSAdrian Chadd static void wpi_hw_stop(struct wpi_softc *); 277692ad7caSAdrian Chadd static void wpi_radio_on(void *, int); 278692ad7caSAdrian Chadd static void wpi_radio_off(void *, int); 2797a79cebfSGleb Smirnoff static int wpi_init(struct wpi_softc *); 280692ad7caSAdrian Chadd static void wpi_stop_locked(struct wpi_softc *); 281692ad7caSAdrian Chadd static void wpi_stop(struct wpi_softc *); 2826607310bSBenjamin Close static void wpi_scan_start(struct ieee80211com *); 2836607310bSBenjamin Close static void wpi_scan_end(struct ieee80211com *); 2846607310bSBenjamin Close static void wpi_set_channel(struct ieee80211com *); 285b032f27cSSam Leffler static void wpi_scan_curchan(struct ieee80211_scan_state *, unsigned long); 286b032f27cSSam Leffler static void wpi_scan_mindwell(struct ieee80211_scan_state *); 2876607310bSBenjamin Close 2886607310bSBenjamin Close static device_method_t wpi_methods[] = { 2896607310bSBenjamin Close /* Device interface */ 2906607310bSBenjamin Close DEVMETHOD(device_probe, wpi_probe), 2916607310bSBenjamin Close DEVMETHOD(device_attach, wpi_attach), 2926607310bSBenjamin Close DEVMETHOD(device_detach, wpi_detach), 2936607310bSBenjamin Close DEVMETHOD(device_shutdown, wpi_shutdown), 2946607310bSBenjamin Close DEVMETHOD(device_suspend, wpi_suspend), 2956607310bSBenjamin Close DEVMETHOD(device_resume, wpi_resume), 2966607310bSBenjamin Close 297da67681dSMarius Strobl DEVMETHOD_END 2986607310bSBenjamin Close }; 2996607310bSBenjamin Close 3006607310bSBenjamin Close static driver_t wpi_driver = { 3016607310bSBenjamin Close "wpi", 3026607310bSBenjamin Close wpi_methods, 3036607310bSBenjamin Close sizeof (struct wpi_softc) 3046607310bSBenjamin Close }; 3056607310bSBenjamin Close static devclass_t wpi_devclass; 3066607310bSBenjamin Close 307da67681dSMarius Strobl DRIVER_MODULE(wpi, pci, wpi_driver, wpi_devclass, NULL, NULL); 3086607310bSBenjamin Close 309129145a4SBernhard Schmidt MODULE_VERSION(wpi, 1); 310129145a4SBernhard Schmidt 311692ad7caSAdrian Chadd MODULE_DEPEND(wpi, pci, 1, 1, 1); 312692ad7caSAdrian Chadd MODULE_DEPEND(wpi, wlan, 1, 1, 1); 313692ad7caSAdrian Chadd MODULE_DEPEND(wpi, firmware, 1, 1, 1); 3146607310bSBenjamin Close 3156607310bSBenjamin Close static int 3166607310bSBenjamin Close wpi_probe(device_t dev) 3176607310bSBenjamin Close { 3186607310bSBenjamin Close const struct wpi_ident *ident; 3196607310bSBenjamin Close 3206607310bSBenjamin Close for (ident = wpi_ident_table; ident->name != NULL; ident++) { 3216607310bSBenjamin Close if (pci_get_vendor(dev) == ident->vendor && 3226607310bSBenjamin Close pci_get_device(dev) == ident->device) { 3236607310bSBenjamin Close device_set_desc(dev, ident->name); 324da67681dSMarius Strobl return (BUS_PROBE_DEFAULT); 3256607310bSBenjamin Close } 3266607310bSBenjamin Close } 3276607310bSBenjamin Close return ENXIO; 3286607310bSBenjamin Close } 3296607310bSBenjamin Close 3306607310bSBenjamin Close static int 3316607310bSBenjamin Close wpi_attach(device_t dev) 3326607310bSBenjamin Close { 333692ad7caSAdrian Chadd struct wpi_softc *sc = (struct wpi_softc *)device_get_softc(dev); 334b032f27cSSam Leffler struct ieee80211com *ic; 335525a3d47SAdrian Chadd uint8_t i; 336525a3d47SAdrian Chadd int error, rid; 337cb0de40fSAdrian Chadd #ifdef WPI_DEBUG 338cb0de40fSAdrian Chadd int supportsa = 1; 3396607310bSBenjamin Close const struct wpi_ident *ident; 340cb0de40fSAdrian Chadd #endif 3416607310bSBenjamin Close 3426607310bSBenjamin Close sc->sc_dev = dev; 3436607310bSBenjamin Close 344692ad7caSAdrian Chadd #ifdef WPI_DEBUG 345692ad7caSAdrian Chadd error = resource_int_value(device_get_name(sc->sc_dev), 346692ad7caSAdrian Chadd device_get_unit(sc->sc_dev), "debug", &(sc->sc_debug)); 347692ad7caSAdrian Chadd if (error != 0) 348692ad7caSAdrian Chadd sc->sc_debug = 0; 349692ad7caSAdrian Chadd #else 350692ad7caSAdrian Chadd sc->sc_debug = 0; 351692ad7caSAdrian Chadd #endif 352692ad7caSAdrian Chadd 353692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 354692ad7caSAdrian Chadd 355692ad7caSAdrian Chadd /* 356692ad7caSAdrian Chadd * Get the offset of the PCI Express Capability Structure in PCI 357692ad7caSAdrian Chadd * Configuration Space. 358692ad7caSAdrian Chadd */ 359692ad7caSAdrian Chadd error = pci_find_cap(dev, PCIY_EXPRESS, &sc->sc_cap_off); 360692ad7caSAdrian Chadd if (error != 0) { 361692ad7caSAdrian Chadd device_printf(dev, "PCIe capability structure not found!\n"); 362692ad7caSAdrian Chadd return error; 363692ad7caSAdrian Chadd } 3646607310bSBenjamin Close 3656607310bSBenjamin Close /* 3666607310bSBenjamin Close * Some card's only support 802.11b/g not a, check to see if 3676607310bSBenjamin Close * this is one such card. A 0x0 in the subdevice table indicates 3686607310bSBenjamin Close * the entire subdevice range is to be ignored. 3696607310bSBenjamin Close */ 370cb0de40fSAdrian Chadd #ifdef WPI_DEBUG 3716607310bSBenjamin Close for (ident = wpi_ident_table; ident->name != NULL; ident++) { 3726607310bSBenjamin Close if (ident->subdevice && 3736607310bSBenjamin Close pci_get_subdevice(dev) == ident->subdevice) { 3746607310bSBenjamin Close supportsa = 0; 3756607310bSBenjamin Close break; 3766607310bSBenjamin Close } 3776607310bSBenjamin Close } 378cb0de40fSAdrian Chadd #endif 3796607310bSBenjamin Close 380692ad7caSAdrian Chadd /* Clear device-specific "PCI retry timeout" register (41h). */ 3816607310bSBenjamin Close pci_write_config(dev, 0x41, 0, 1); 3826607310bSBenjamin Close 383692ad7caSAdrian Chadd /* Enable bus-mastering. */ 3846607310bSBenjamin Close pci_enable_busmaster(dev); 3856607310bSBenjamin Close 386da67681dSMarius Strobl rid = PCIR_BAR(0); 387da67681dSMarius Strobl sc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 3886607310bSBenjamin Close RF_ACTIVE); 3896607310bSBenjamin Close if (sc->mem == NULL) { 390692ad7caSAdrian Chadd device_printf(dev, "can't map mem space\n"); 391419435b8SAdrian Chadd return ENOMEM; 3926607310bSBenjamin Close } 3936607310bSBenjamin Close sc->sc_st = rman_get_bustag(sc->mem); 3946607310bSBenjamin Close sc->sc_sh = rman_get_bushandle(sc->mem); 3956607310bSBenjamin Close 396692ad7caSAdrian Chadd rid = 1; 397525a3d47SAdrian Chadd if (pci_alloc_msi(dev, &rid) == 0) 398525a3d47SAdrian Chadd rid = 1; 399525a3d47SAdrian Chadd else 400525a3d47SAdrian Chadd rid = 0; 401692ad7caSAdrian Chadd /* Install interrupt handler. */ 402692ad7caSAdrian Chadd sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE | 403692ad7caSAdrian Chadd (rid != 0 ? 0 : RF_SHAREABLE)); 4046607310bSBenjamin Close if (sc->irq == NULL) { 405692ad7caSAdrian Chadd device_printf(dev, "can't map interrupt\n"); 4066607310bSBenjamin Close error = ENOMEM; 4076607310bSBenjamin Close goto fail; 4086607310bSBenjamin Close } 4096607310bSBenjamin Close 410692ad7caSAdrian Chadd WPI_LOCK_INIT(sc); 4115effcbfdSAdrian Chadd WPI_TX_LOCK_INIT(sc); 412446685e4SAdrian Chadd WPI_RXON_LOCK_INIT(sc); 4137964dd56SAdrian Chadd WPI_NT_LOCK_INIT(sc); 41463f57699SAdrian Chadd WPI_TXQ_LOCK_INIT(sc); 415fc5870b4SAdrian Chadd WPI_TXQ_STATE_LOCK_INIT(sc); 416692ad7caSAdrian Chadd 417692ad7caSAdrian Chadd /* Allocate DMA memory for firmware transfers. */ 4186607310bSBenjamin Close if ((error = wpi_alloc_fwmem(sc)) != 0) { 419692ad7caSAdrian Chadd device_printf(dev, 420692ad7caSAdrian Chadd "could not allocate memory for firmware, error %d\n", 421692ad7caSAdrian Chadd error); 4226607310bSBenjamin Close goto fail; 4236607310bSBenjamin Close } 4246607310bSBenjamin Close 425692ad7caSAdrian Chadd /* Allocate shared page. */ 4266607310bSBenjamin Close if ((error = wpi_alloc_shared(sc)) != 0) { 4276607310bSBenjamin Close device_printf(dev, "could not allocate shared page\n"); 4286607310bSBenjamin Close goto fail; 4296607310bSBenjamin Close } 4306607310bSBenjamin Close 431692ad7caSAdrian Chadd /* Allocate TX rings - 4 for QoS purposes, 1 for commands. */ 43219053a54SAdrian Chadd for (i = 0; i < WPI_DRV_NTXQUEUES; i++) { 433692ad7caSAdrian Chadd if ((error = wpi_alloc_tx_ring(sc, &sc->txq[i], i)) != 0) { 434692ad7caSAdrian Chadd device_printf(dev, 435692ad7caSAdrian Chadd "could not allocate TX ring %d, error %d\n", i, 436692ad7caSAdrian Chadd error); 4376607310bSBenjamin Close goto fail; 4386607310bSBenjamin Close } 4396607310bSBenjamin Close } 4406607310bSBenjamin Close 441692ad7caSAdrian Chadd /* Allocate RX ring. */ 442692ad7caSAdrian Chadd if ((error = wpi_alloc_rx_ring(sc)) != 0) { 443692ad7caSAdrian Chadd device_printf(dev, "could not allocate RX ring, error %d\n", 444692ad7caSAdrian Chadd error); 4456607310bSBenjamin Close goto fail; 4466607310bSBenjamin Close } 4476607310bSBenjamin Close 448692ad7caSAdrian Chadd /* Clear pending interrupts. */ 449692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, 0xffffffff); 4506607310bSBenjamin Close 4517a79cebfSGleb Smirnoff ic = &sc->sc_ic; 45259686fe9SGleb Smirnoff ic->ic_softc = sc; 453c8550c02SGleb Smirnoff ic->ic_name = device_get_nameunit(dev); 4546607310bSBenjamin Close ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */ 4556607310bSBenjamin Close ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */ 4566607310bSBenjamin Close 457692ad7caSAdrian Chadd /* Set device capabilities. */ 4586607310bSBenjamin Close ic->ic_caps = 459c43feedeSSam Leffler IEEE80211_C_STA /* station mode supported */ 460692ad7caSAdrian Chadd | IEEE80211_C_IBSS /* IBSS mode supported */ 461726ddc26SAdrian Chadd | IEEE80211_C_HOSTAP /* Host access point mode */ 462c43feedeSSam Leffler | IEEE80211_C_MONITOR /* monitor mode supported */ 463692ad7caSAdrian Chadd | IEEE80211_C_AHDEMO /* adhoc demo mode */ 464692ad7caSAdrian Chadd | IEEE80211_C_BGSCAN /* capable of bg scanning */ 465940aa808SAdrian Chadd | IEEE80211_C_TXFRAG /* handle tx frags */ 4666607310bSBenjamin Close | IEEE80211_C_TXPMGT /* tx power management */ 4676607310bSBenjamin Close | IEEE80211_C_SHSLOT /* short slot time supported */ 4686607310bSBenjamin Close | IEEE80211_C_WPA /* 802.11i */ 469692ad7caSAdrian Chadd | IEEE80211_C_SHPREAMBLE /* short preamble supported */ 470692ad7caSAdrian Chadd | IEEE80211_C_WME /* 802.11e */ 471692ad7caSAdrian Chadd | IEEE80211_C_PMGT /* Station-side power mgmt */ 4726607310bSBenjamin Close ; 4736607310bSBenjamin Close 474692ad7caSAdrian Chadd ic->ic_cryptocaps = 475692ad7caSAdrian Chadd IEEE80211_CRYPTO_AES_CCM; 476692ad7caSAdrian Chadd 4776607310bSBenjamin Close /* 4786607310bSBenjamin Close * Read in the eeprom and also setup the channels for 4796607310bSBenjamin Close * net80211. We don't set the rates as net80211 does this for us 4806607310bSBenjamin Close */ 4817a79cebfSGleb Smirnoff if ((error = wpi_read_eeprom(sc, ic->ic_macaddr)) != 0) { 482692ad7caSAdrian Chadd device_printf(dev, "could not read EEPROM, error %d\n", 483692ad7caSAdrian Chadd error); 484692ad7caSAdrian Chadd goto fail; 485692ad7caSAdrian Chadd } 4866607310bSBenjamin Close 487692ad7caSAdrian Chadd #ifdef WPI_DEBUG 488692ad7caSAdrian Chadd if (bootverbose) { 489bb086d4eSAdrian Chadd device_printf(sc->sc_dev, "Regulatory Domain: %.4s\n", 490bb086d4eSAdrian Chadd sc->domain); 4916607310bSBenjamin Close device_printf(sc->sc_dev, "Hardware Type: %c\n", 4926607310bSBenjamin Close sc->type > 1 ? 'B': '?'); 4936607310bSBenjamin Close device_printf(sc->sc_dev, "Hardware Revision: %c\n", 494f736d898SAdrian Chadd ((sc->rev & 0xf0) == 0xd0) ? 'D': '?'); 4956607310bSBenjamin Close device_printf(sc->sc_dev, "SKU %s support 802.11a\n", 4966607310bSBenjamin Close supportsa ? "does" : "does not"); 4976607310bSBenjamin Close 498bb086d4eSAdrian Chadd /* XXX hw_config uses the PCIDEV for the Hardware rev. Must 499bb086d4eSAdrian Chadd check what sc->rev really represents - benjsc 20070615 */ 5006607310bSBenjamin Close } 501692ad7caSAdrian Chadd #endif 5026607310bSBenjamin Close 5037a79cebfSGleb Smirnoff ieee80211_ifattach(ic); 504692ad7caSAdrian Chadd ic->ic_vap_create = wpi_vap_create; 505692ad7caSAdrian Chadd ic->ic_vap_delete = wpi_vap_delete; 5067a79cebfSGleb Smirnoff ic->ic_parent = wpi_parent; 507b032f27cSSam Leffler ic->ic_raw_xmit = wpi_raw_xmit; 5087a79cebfSGleb Smirnoff ic->ic_transmit = wpi_transmit; 509692ad7caSAdrian Chadd ic->ic_node_alloc = wpi_node_alloc; 510692ad7caSAdrian Chadd sc->sc_node_free = ic->ic_node_free; 511692ad7caSAdrian Chadd ic->ic_node_free = wpi_node_free; 512692ad7caSAdrian Chadd ic->ic_wme.wme_update = wpi_updateedca; 513692ad7caSAdrian Chadd ic->ic_update_promisc = wpi_update_promisc; 514692ad7caSAdrian Chadd ic->ic_update_mcast = wpi_update_mcast; 515d138d3baSAdrian Chadd ic->ic_newassoc = wpi_newassoc; 5166607310bSBenjamin Close ic->ic_scan_start = wpi_scan_start; 5176607310bSBenjamin Close ic->ic_scan_end = wpi_scan_end; 5186607310bSBenjamin Close ic->ic_set_channel = wpi_set_channel; 5196607310bSBenjamin Close ic->ic_scan_curchan = wpi_scan_curchan; 5206607310bSBenjamin Close ic->ic_scan_mindwell = wpi_scan_mindwell; 5211c6b43dfSAndriy Voskoboinyk ic->ic_getradiocaps = wpi_getradiocaps; 522692ad7caSAdrian Chadd ic->ic_setregdomain = wpi_setregdomain; 5236607310bSBenjamin Close 5245cacb17fSAdrian Chadd sc->sc_update_rx_ring = wpi_update_rx_ring; 5255cacb17fSAdrian Chadd sc->sc_update_tx_ring = wpi_update_tx_ring; 5265cacb17fSAdrian Chadd 527692ad7caSAdrian Chadd wpi_radiotap_attach(sc); 5286607310bSBenjamin Close 529f6930becSAndriy Voskoboinyk /* Setup Tx status flags (constant). */ 530*3f3d4d61SAndriy Voskoboinyk sc->sc_txs.flags = IEEE80211_RATECTL_STATUS_PKTLEN | 531*3f3d4d61SAndriy Voskoboinyk IEEE80211_RATECTL_STATUS_SHORT_RETRY | 532f6930becSAndriy Voskoboinyk IEEE80211_RATECTL_STATUS_LONG_RETRY; 533f6930becSAndriy Voskoboinyk 534446685e4SAdrian Chadd callout_init_mtx(&sc->calib_to, &sc->rxon_mtx, 0); 535446685e4SAdrian Chadd callout_init_mtx(&sc->scan_timeout, &sc->rxon_mtx, 0); 536fc5870b4SAdrian Chadd callout_init_mtx(&sc->tx_timeout, &sc->txq_state_mtx, 0); 537692ad7caSAdrian Chadd callout_init_mtx(&sc->watchdog_rfkill, &sc->sc_mtx, 0); 538692ad7caSAdrian Chadd TASK_INIT(&sc->sc_radiooff_task, 0, wpi_radio_off, sc); 539692ad7caSAdrian Chadd TASK_INIT(&sc->sc_radioon_task, 0, wpi_radio_on, sc); 540692ad7caSAdrian Chadd 541692ad7caSAdrian Chadd wpi_sysctlattach(sc); 5426607310bSBenjamin Close 5436607310bSBenjamin Close /* 5446607310bSBenjamin Close * Hook our interrupt after all initialization is complete. 5456607310bSBenjamin Close */ 5466607310bSBenjamin Close error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET | INTR_MPSAFE, 54782f1b132SAndrew Thompson NULL, wpi_intr, sc, &sc->sc_ih); 5486607310bSBenjamin Close if (error != 0) { 549692ad7caSAdrian Chadd device_printf(dev, "can't establish interrupt, error %d\n", 550692ad7caSAdrian Chadd error); 5516607310bSBenjamin Close goto fail; 5526607310bSBenjamin Close } 5536607310bSBenjamin Close 55482f1b132SAndrew Thompson if (bootverbose) 5556607310bSBenjamin Close ieee80211_announce(ic); 556692ad7caSAdrian Chadd 557692ad7caSAdrian Chadd #ifdef WPI_DEBUG 558692ad7caSAdrian Chadd if (sc->sc_debug & WPI_DEBUG_HW) 5596607310bSBenjamin Close ieee80211_announce_channels(ic); 5606607310bSBenjamin Close #endif 561692ad7caSAdrian Chadd 562692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 5636607310bSBenjamin Close return 0; 5646607310bSBenjamin Close 5656607310bSBenjamin Close fail: wpi_detach(dev); 566692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 567692ad7caSAdrian Chadd return error; 5686607310bSBenjamin Close } 5696607310bSBenjamin Close 570692ad7caSAdrian Chadd /* 571692ad7caSAdrian Chadd * Attach the interface to 802.11 radiotap. 572692ad7caSAdrian Chadd */ 573692ad7caSAdrian Chadd static void 574692ad7caSAdrian Chadd wpi_radiotap_attach(struct wpi_softc *sc) 5756607310bSBenjamin Close { 5767a79cebfSGleb Smirnoff struct wpi_rx_radiotap_header *rxtap = &sc->sc_rxtap; 5777a79cebfSGleb Smirnoff struct wpi_tx_radiotap_header *txtap = &sc->sc_txtap; 5787a79cebfSGleb Smirnoff 579692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 5807a79cebfSGleb Smirnoff ieee80211_radiotap_attach(&sc->sc_ic, 5817a79cebfSGleb Smirnoff &txtap->wt_ihdr, sizeof(*txtap), WPI_TX_RADIOTAP_PRESENT, 5827a79cebfSGleb Smirnoff &rxtap->wr_ihdr, sizeof(*rxtap), WPI_RX_RADIOTAP_PRESENT); 583692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 5846607310bSBenjamin Close } 5856607310bSBenjamin Close 586692ad7caSAdrian Chadd static void 587692ad7caSAdrian Chadd wpi_sysctlattach(struct wpi_softc *sc) 588692ad7caSAdrian Chadd { 589692ad7caSAdrian Chadd #ifdef WPI_DEBUG 590692ad7caSAdrian Chadd struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev); 591692ad7caSAdrian Chadd struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev); 5926607310bSBenjamin Close 593692ad7caSAdrian Chadd SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 594692ad7caSAdrian Chadd "debug", CTLFLAG_RW, &sc->sc_debug, sc->sc_debug, 595692ad7caSAdrian Chadd "control debugging printfs"); 596692ad7caSAdrian Chadd #endif 5976607310bSBenjamin Close } 5986607310bSBenjamin Close 59921f6580eSAdrian Chadd static void 60021f6580eSAdrian Chadd wpi_init_beacon(struct wpi_vap *wvp) 60121f6580eSAdrian Chadd { 60221f6580eSAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 60321f6580eSAdrian Chadd struct wpi_cmd_beacon *cmd = (struct wpi_cmd_beacon *)&bcn->data; 60421f6580eSAdrian Chadd 60521f6580eSAdrian Chadd cmd->id = WPI_ID_BROADCAST; 60621f6580eSAdrian Chadd cmd->ofdm_mask = 0xff; 60721f6580eSAdrian Chadd cmd->cck_mask = 0x0f; 60821f6580eSAdrian Chadd cmd->lifetime = htole32(WPI_LIFETIME_INFINITE); 609c39df5f4SAdrian Chadd 610c39df5f4SAdrian Chadd /* 611c39df5f4SAdrian Chadd * XXX WPI_TX_AUTO_SEQ seems to be ignored - workaround this issue 612c39df5f4SAdrian Chadd * XXX by using WPI_TX_NEED_ACK instead (with some side effects). 613c39df5f4SAdrian Chadd */ 614c39df5f4SAdrian Chadd cmd->flags = htole32(WPI_TX_NEED_ACK | WPI_TX_INSERT_TSTAMP); 61521f6580eSAdrian Chadd 61621f6580eSAdrian Chadd bcn->code = WPI_CMD_SET_BEACON; 61721f6580eSAdrian Chadd bcn->ac = WPI_CMD_QUEUE_NUM; 61821f6580eSAdrian Chadd bcn->size = sizeof(struct wpi_cmd_beacon); 61921f6580eSAdrian Chadd } 62021f6580eSAdrian Chadd 621b032f27cSSam Leffler static struct ieee80211vap * 622fcd9500fSBernhard Schmidt wpi_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit, 623fcd9500fSBernhard Schmidt enum ieee80211_opmode opmode, int flags, 624b032f27cSSam Leffler const uint8_t bssid[IEEE80211_ADDR_LEN], 625b032f27cSSam Leffler const uint8_t mac[IEEE80211_ADDR_LEN]) 626b032f27cSSam Leffler { 627b032f27cSSam Leffler struct wpi_vap *wvp; 628b032f27cSSam Leffler struct ieee80211vap *vap; 629b032f27cSSam Leffler 630b032f27cSSam Leffler if (!TAILQ_EMPTY(&ic->ic_vaps)) /* only one at a time */ 631b032f27cSSam Leffler return NULL; 632692ad7caSAdrian Chadd 6337a79cebfSGleb Smirnoff wvp = malloc(sizeof(struct wpi_vap), M_80211_VAP, M_WAITOK | M_ZERO); 634d036bb20SAdrian Chadd vap = &wvp->wv_vap; 6357a79cebfSGleb Smirnoff ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid); 636692ad7caSAdrian Chadd 637726ddc26SAdrian Chadd if (opmode == IEEE80211_M_IBSS || opmode == IEEE80211_M_HOSTAP) { 638b56fed3dSAdrian Chadd WPI_VAP_LOCK_INIT(wvp); 63921f6580eSAdrian Chadd wpi_init_beacon(wvp); 640b56fed3dSAdrian Chadd } 64121f6580eSAdrian Chadd 642692ad7caSAdrian Chadd /* Override with driver methods. */ 643692ad7caSAdrian Chadd vap->iv_key_set = wpi_key_set; 644692ad7caSAdrian Chadd vap->iv_key_delete = wpi_key_delete; 64557c61f5dSAdrian Chadd if (opmode == IEEE80211_M_IBSS) { 646a20c9affSAdrian Chadd wvp->wv_recv_mgmt = vap->iv_recv_mgmt; 64757c61f5dSAdrian Chadd vap->iv_recv_mgmt = wpi_ibss_recv_mgmt; 64857c61f5dSAdrian Chadd } 649d036bb20SAdrian Chadd wvp->wv_newstate = vap->iv_newstate; 650b032f27cSSam Leffler vap->iv_newstate = wpi_newstate; 651692ad7caSAdrian Chadd vap->iv_update_beacon = wpi_update_beacon; 652726ddc26SAdrian Chadd vap->iv_max_aid = WPI_ID_IBSS_MAX - WPI_ID_IBSS_MIN + 1; 653b032f27cSSam Leffler 654b6108616SRui Paulo ieee80211_ratectl_init(vap); 655692ad7caSAdrian Chadd /* Complete setup. */ 6567167f5fcSAdrian Chadd ieee80211_vap_attach(vap, ieee80211_media_change, 6577a79cebfSGleb Smirnoff ieee80211_media_status, mac); 658b032f27cSSam Leffler ic->ic_opmode = opmode; 659b032f27cSSam Leffler return vap; 660b032f27cSSam Leffler } 661b032f27cSSam Leffler 662b032f27cSSam Leffler static void 663b032f27cSSam Leffler wpi_vap_delete(struct ieee80211vap *vap) 664b032f27cSSam Leffler { 665b032f27cSSam Leffler struct wpi_vap *wvp = WPI_VAP(vap); 6666f8421f8SAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 6676f8421f8SAdrian Chadd enum ieee80211_opmode opmode = vap->iv_opmode; 668b032f27cSSam Leffler 669b6108616SRui Paulo ieee80211_ratectl_deinit(vap); 670b032f27cSSam Leffler ieee80211_vap_detach(vap); 671692ad7caSAdrian Chadd 672726ddc26SAdrian Chadd if (opmode == IEEE80211_M_IBSS || opmode == IEEE80211_M_HOSTAP) { 6736f8421f8SAdrian Chadd if (bcn->m != NULL) 6746f8421f8SAdrian Chadd m_freem(bcn->m); 675b56fed3dSAdrian Chadd 676b56fed3dSAdrian Chadd WPI_VAP_LOCK_DESTROY(wvp); 6776f8421f8SAdrian Chadd } 6786f8421f8SAdrian Chadd 679b032f27cSSam Leffler free(wvp, M_80211_VAP); 680b032f27cSSam Leffler } 681b032f27cSSam Leffler 6826607310bSBenjamin Close static int 683692ad7caSAdrian Chadd wpi_detach(device_t dev) 6846607310bSBenjamin Close { 685692ad7caSAdrian Chadd struct wpi_softc *sc = device_get_softc(dev); 6867a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 687525a3d47SAdrian Chadd uint8_t qid; 6886607310bSBenjamin Close 689692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 6906607310bSBenjamin Close 6917a79cebfSGleb Smirnoff if (ic->ic_vap_create == wpi_vap_create) { 6920c66281cSAdrian Chadd ieee80211_draintask(ic, &sc->sc_radioon_task); 693abd89aa2SAndriy Voskoboinyk ieee80211_draintask(ic, &sc->sc_radiooff_task); 694692ad7caSAdrian Chadd 695692ad7caSAdrian Chadd wpi_stop(sc); 696692ad7caSAdrian Chadd 697692ad7caSAdrian Chadd callout_drain(&sc->watchdog_rfkill); 698d74e544aSAdrian Chadd callout_drain(&sc->tx_timeout); 6990bc39fc6SAdrian Chadd callout_drain(&sc->scan_timeout); 700692ad7caSAdrian Chadd callout_drain(&sc->calib_to); 701692ad7caSAdrian Chadd ieee80211_ifdetach(ic); 7026607310bSBenjamin Close } 7036607310bSBenjamin Close 704692ad7caSAdrian Chadd /* Uninstall interrupt handler. */ 705692ad7caSAdrian Chadd if (sc->irq != NULL) { 706692ad7caSAdrian Chadd bus_teardown_intr(dev, sc->irq, sc->sc_ih); 707692ad7caSAdrian Chadd bus_release_resource(dev, SYS_RES_IRQ, rman_get_rid(sc->irq), 708692ad7caSAdrian Chadd sc->irq); 709692ad7caSAdrian Chadd pci_release_msi(dev); 71082f1b132SAndrew Thompson } 7116607310bSBenjamin Close 712692ad7caSAdrian Chadd if (sc->txq[0].data_dmat) { 713692ad7caSAdrian Chadd /* Free DMA resources. */ 71419053a54SAdrian Chadd for (qid = 0; qid < WPI_DRV_NTXQUEUES; qid++) 715692ad7caSAdrian Chadd wpi_free_tx_ring(sc, &sc->txq[qid]); 716692ad7caSAdrian Chadd 717692ad7caSAdrian Chadd wpi_free_rx_ring(sc); 718692ad7caSAdrian Chadd wpi_free_shared(sc); 7196607310bSBenjamin Close } 7206607310bSBenjamin Close 721692ad7caSAdrian Chadd if (sc->fw_dma.tag) 722692ad7caSAdrian Chadd wpi_free_fwmem(sc); 7236607310bSBenjamin Close 724692ad7caSAdrian Chadd if (sc->mem != NULL) 725692ad7caSAdrian Chadd bus_release_resource(dev, SYS_RES_MEMORY, 726692ad7caSAdrian Chadd rman_get_rid(sc->mem), sc->mem); 727692ad7caSAdrian Chadd 728692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 729fc5870b4SAdrian Chadd WPI_TXQ_STATE_LOCK_DESTROY(sc); 73063f57699SAdrian Chadd WPI_TXQ_LOCK_DESTROY(sc); 7317964dd56SAdrian Chadd WPI_NT_LOCK_DESTROY(sc); 732446685e4SAdrian Chadd WPI_RXON_LOCK_DESTROY(sc); 7335effcbfdSAdrian Chadd WPI_TX_LOCK_DESTROY(sc); 734692ad7caSAdrian Chadd WPI_LOCK_DESTROY(sc); 7356607310bSBenjamin Close return 0; 7366607310bSBenjamin Close } 7376607310bSBenjamin Close 7386607310bSBenjamin Close static int 7396607310bSBenjamin Close wpi_shutdown(device_t dev) 7406607310bSBenjamin Close { 7416607310bSBenjamin Close struct wpi_softc *sc = device_get_softc(dev); 7426607310bSBenjamin Close 743692ad7caSAdrian Chadd wpi_stop(sc); 7446607310bSBenjamin Close return 0; 7456607310bSBenjamin Close } 7466607310bSBenjamin Close 7476607310bSBenjamin Close static int 7486607310bSBenjamin Close wpi_suspend(device_t dev) 7496607310bSBenjamin Close { 7506607310bSBenjamin Close struct wpi_softc *sc = device_get_softc(dev); 7517a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 7526607310bSBenjamin Close 753ada977b1SBernhard Schmidt ieee80211_suspend_all(ic); 7546607310bSBenjamin Close return 0; 7556607310bSBenjamin Close } 7566607310bSBenjamin Close 7576607310bSBenjamin Close static int 7586607310bSBenjamin Close wpi_resume(device_t dev) 7596607310bSBenjamin Close { 7606607310bSBenjamin Close struct wpi_softc *sc = device_get_softc(dev); 7617a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 7626607310bSBenjamin Close 763692ad7caSAdrian Chadd /* Clear device-specific "PCI retry timeout" register (41h). */ 7646607310bSBenjamin Close pci_write_config(dev, 0x41, 0, 1); 7656607310bSBenjamin Close 766ada977b1SBernhard Schmidt ieee80211_resume_all(ic); 7676607310bSBenjamin Close return 0; 7686607310bSBenjamin Close } 7696607310bSBenjamin Close 770692ad7caSAdrian Chadd /* 771692ad7caSAdrian Chadd * Grab exclusive access to NIC memory. 772692ad7caSAdrian Chadd */ 773692ad7caSAdrian Chadd static int 774692ad7caSAdrian Chadd wpi_nic_lock(struct wpi_softc *sc) 775692ad7caSAdrian Chadd { 776692ad7caSAdrian Chadd int ntries; 777692ad7caSAdrian Chadd 778692ad7caSAdrian Chadd /* Request exclusive access to NIC. */ 779692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 780692ad7caSAdrian Chadd 781692ad7caSAdrian Chadd /* Spin until we actually get the lock. */ 782692ad7caSAdrian Chadd for (ntries = 0; ntries < 1000; ntries++) { 783692ad7caSAdrian Chadd if ((WPI_READ(sc, WPI_GP_CNTRL) & 784692ad7caSAdrian Chadd (WPI_GP_CNTRL_MAC_ACCESS_ENA | WPI_GP_CNTRL_SLEEP)) == 785692ad7caSAdrian Chadd WPI_GP_CNTRL_MAC_ACCESS_ENA) 786692ad7caSAdrian Chadd return 0; 787692ad7caSAdrian Chadd DELAY(10); 788692ad7caSAdrian Chadd } 789692ad7caSAdrian Chadd 790692ad7caSAdrian Chadd device_printf(sc->sc_dev, "could not lock memory\n"); 791692ad7caSAdrian Chadd 792692ad7caSAdrian Chadd return ETIMEDOUT; 793692ad7caSAdrian Chadd } 794692ad7caSAdrian Chadd 795692ad7caSAdrian Chadd /* 796692ad7caSAdrian Chadd * Release lock on NIC memory. 797692ad7caSAdrian Chadd */ 798692ad7caSAdrian Chadd static __inline void 799692ad7caSAdrian Chadd wpi_nic_unlock(struct wpi_softc *sc) 800692ad7caSAdrian Chadd { 801692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 802692ad7caSAdrian Chadd } 803692ad7caSAdrian Chadd 804692ad7caSAdrian Chadd static __inline uint32_t 805692ad7caSAdrian Chadd wpi_prph_read(struct wpi_softc *sc, uint32_t addr) 806692ad7caSAdrian Chadd { 807692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_PRPH_RADDR, WPI_PRPH_DWORD | addr); 808692ad7caSAdrian Chadd WPI_BARRIER_READ_WRITE(sc); 809692ad7caSAdrian Chadd return WPI_READ(sc, WPI_PRPH_RDATA); 810692ad7caSAdrian Chadd } 811692ad7caSAdrian Chadd 812692ad7caSAdrian Chadd static __inline void 813692ad7caSAdrian Chadd wpi_prph_write(struct wpi_softc *sc, uint32_t addr, uint32_t data) 814692ad7caSAdrian Chadd { 815692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_PRPH_WADDR, WPI_PRPH_DWORD | addr); 816692ad7caSAdrian Chadd WPI_BARRIER_WRITE(sc); 817692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_PRPH_WDATA, data); 818692ad7caSAdrian Chadd } 819692ad7caSAdrian Chadd 820692ad7caSAdrian Chadd static __inline void 821692ad7caSAdrian Chadd wpi_prph_setbits(struct wpi_softc *sc, uint32_t addr, uint32_t mask) 822692ad7caSAdrian Chadd { 823692ad7caSAdrian Chadd wpi_prph_write(sc, addr, wpi_prph_read(sc, addr) | mask); 824692ad7caSAdrian Chadd } 825692ad7caSAdrian Chadd 826692ad7caSAdrian Chadd static __inline void 827692ad7caSAdrian Chadd wpi_prph_clrbits(struct wpi_softc *sc, uint32_t addr, uint32_t mask) 828692ad7caSAdrian Chadd { 829692ad7caSAdrian Chadd wpi_prph_write(sc, addr, wpi_prph_read(sc, addr) & ~mask); 830692ad7caSAdrian Chadd } 831692ad7caSAdrian Chadd 832692ad7caSAdrian Chadd static __inline void 833692ad7caSAdrian Chadd wpi_prph_write_region_4(struct wpi_softc *sc, uint32_t addr, 834525a3d47SAdrian Chadd const uint32_t *data, uint32_t count) 835692ad7caSAdrian Chadd { 836525a3d47SAdrian Chadd for (; count != 0; count--, data++, addr += 4) 837692ad7caSAdrian Chadd wpi_prph_write(sc, addr, *data); 838692ad7caSAdrian Chadd } 839692ad7caSAdrian Chadd 840692ad7caSAdrian Chadd static __inline uint32_t 841692ad7caSAdrian Chadd wpi_mem_read(struct wpi_softc *sc, uint32_t addr) 842692ad7caSAdrian Chadd { 843692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_MEM_RADDR, addr); 844692ad7caSAdrian Chadd WPI_BARRIER_READ_WRITE(sc); 845692ad7caSAdrian Chadd return WPI_READ(sc, WPI_MEM_RDATA); 846692ad7caSAdrian Chadd } 847692ad7caSAdrian Chadd 848692ad7caSAdrian Chadd static __inline void 849692ad7caSAdrian Chadd wpi_mem_read_region_4(struct wpi_softc *sc, uint32_t addr, uint32_t *data, 850692ad7caSAdrian Chadd int count) 851692ad7caSAdrian Chadd { 852692ad7caSAdrian Chadd for (; count > 0; count--, addr += 4) 853692ad7caSAdrian Chadd *data++ = wpi_mem_read(sc, addr); 854692ad7caSAdrian Chadd } 855692ad7caSAdrian Chadd 856692ad7caSAdrian Chadd static int 857692ad7caSAdrian Chadd wpi_read_prom_data(struct wpi_softc *sc, uint32_t addr, void *data, int count) 858692ad7caSAdrian Chadd { 859692ad7caSAdrian Chadd uint8_t *out = data; 860692ad7caSAdrian Chadd uint32_t val; 861692ad7caSAdrian Chadd int error, ntries; 862692ad7caSAdrian Chadd 863692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 864692ad7caSAdrian Chadd 865692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 866692ad7caSAdrian Chadd return error; 867692ad7caSAdrian Chadd 868692ad7caSAdrian Chadd for (; count > 0; count -= 2, addr++) { 869692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_EEPROM, addr << 2); 870692ad7caSAdrian Chadd for (ntries = 0; ntries < 10; ntries++) { 871692ad7caSAdrian Chadd val = WPI_READ(sc, WPI_EEPROM); 872692ad7caSAdrian Chadd if (val & WPI_EEPROM_READ_VALID) 873692ad7caSAdrian Chadd break; 874692ad7caSAdrian Chadd DELAY(5); 875692ad7caSAdrian Chadd } 876692ad7caSAdrian Chadd if (ntries == 10) { 877692ad7caSAdrian Chadd device_printf(sc->sc_dev, 878692ad7caSAdrian Chadd "timeout reading ROM at 0x%x\n", addr); 879692ad7caSAdrian Chadd return ETIMEDOUT; 880692ad7caSAdrian Chadd } 881692ad7caSAdrian Chadd *out++= val >> 16; 882692ad7caSAdrian Chadd if (count > 1) 883692ad7caSAdrian Chadd *out ++= val >> 24; 884692ad7caSAdrian Chadd } 885692ad7caSAdrian Chadd 886692ad7caSAdrian Chadd wpi_nic_unlock(sc); 887692ad7caSAdrian Chadd 888692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 889692ad7caSAdrian Chadd 890692ad7caSAdrian Chadd return 0; 891692ad7caSAdrian Chadd } 892692ad7caSAdrian Chadd 893692ad7caSAdrian Chadd static void 894692ad7caSAdrian Chadd wpi_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 895692ad7caSAdrian Chadd { 896692ad7caSAdrian Chadd if (error != 0) 897692ad7caSAdrian Chadd return; 898692ad7caSAdrian Chadd KASSERT(nsegs == 1, ("too many DMA segments, %d should be 1", nsegs)); 899692ad7caSAdrian Chadd *(bus_addr_t *)arg = segs[0].ds_addr; 900692ad7caSAdrian Chadd } 901692ad7caSAdrian Chadd 902692ad7caSAdrian Chadd /* 903692ad7caSAdrian Chadd * Allocates a contiguous block of dma memory of the requested size and 904692ad7caSAdrian Chadd * alignment. 905692ad7caSAdrian Chadd */ 906692ad7caSAdrian Chadd static int 907692ad7caSAdrian Chadd wpi_dma_contig_alloc(struct wpi_softc *sc, struct wpi_dma_info *dma, 908692ad7caSAdrian Chadd void **kvap, bus_size_t size, bus_size_t alignment) 909692ad7caSAdrian Chadd { 910692ad7caSAdrian Chadd int error; 911692ad7caSAdrian Chadd 912692ad7caSAdrian Chadd dma->tag = NULL; 913692ad7caSAdrian Chadd dma->size = size; 914692ad7caSAdrian Chadd 915692ad7caSAdrian Chadd error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), alignment, 916692ad7caSAdrian Chadd 0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, size, 917b020e15eSKevin Lo 1, size, 0, NULL, NULL, &dma->tag); 918692ad7caSAdrian Chadd if (error != 0) 919692ad7caSAdrian Chadd goto fail; 920692ad7caSAdrian Chadd 921692ad7caSAdrian Chadd error = bus_dmamem_alloc(dma->tag, (void **)&dma->vaddr, 922692ad7caSAdrian Chadd BUS_DMA_NOWAIT | BUS_DMA_ZERO | BUS_DMA_COHERENT, &dma->map); 923692ad7caSAdrian Chadd if (error != 0) 924692ad7caSAdrian Chadd goto fail; 925692ad7caSAdrian Chadd 926692ad7caSAdrian Chadd error = bus_dmamap_load(dma->tag, dma->map, dma->vaddr, size, 927692ad7caSAdrian Chadd wpi_dma_map_addr, &dma->paddr, BUS_DMA_NOWAIT); 928692ad7caSAdrian Chadd if (error != 0) 929692ad7caSAdrian Chadd goto fail; 930692ad7caSAdrian Chadd 931692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 932692ad7caSAdrian Chadd 933692ad7caSAdrian Chadd if (kvap != NULL) 934692ad7caSAdrian Chadd *kvap = dma->vaddr; 935692ad7caSAdrian Chadd 936692ad7caSAdrian Chadd return 0; 937692ad7caSAdrian Chadd 938692ad7caSAdrian Chadd fail: wpi_dma_contig_free(dma); 939692ad7caSAdrian Chadd return error; 940692ad7caSAdrian Chadd } 941692ad7caSAdrian Chadd 942692ad7caSAdrian Chadd static void 943692ad7caSAdrian Chadd wpi_dma_contig_free(struct wpi_dma_info *dma) 944692ad7caSAdrian Chadd { 945692ad7caSAdrian Chadd if (dma->vaddr != NULL) { 946692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, 947692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 948692ad7caSAdrian Chadd bus_dmamap_unload(dma->tag, dma->map); 949692ad7caSAdrian Chadd bus_dmamem_free(dma->tag, dma->vaddr, dma->map); 950692ad7caSAdrian Chadd dma->vaddr = NULL; 951692ad7caSAdrian Chadd } 952692ad7caSAdrian Chadd if (dma->tag != NULL) { 953692ad7caSAdrian Chadd bus_dma_tag_destroy(dma->tag); 954692ad7caSAdrian Chadd dma->tag = NULL; 955692ad7caSAdrian Chadd } 956692ad7caSAdrian Chadd } 957692ad7caSAdrian Chadd 958692ad7caSAdrian Chadd /* 959692ad7caSAdrian Chadd * Allocate a shared page between host and NIC. 960692ad7caSAdrian Chadd */ 961692ad7caSAdrian Chadd static int 962692ad7caSAdrian Chadd wpi_alloc_shared(struct wpi_softc *sc) 963692ad7caSAdrian Chadd { 964692ad7caSAdrian Chadd /* Shared buffer must be aligned on a 4KB boundary. */ 965692ad7caSAdrian Chadd return wpi_dma_contig_alloc(sc, &sc->shared_dma, 966692ad7caSAdrian Chadd (void **)&sc->shared, sizeof (struct wpi_shared), 4096); 967692ad7caSAdrian Chadd } 968692ad7caSAdrian Chadd 969692ad7caSAdrian Chadd static void 970692ad7caSAdrian Chadd wpi_free_shared(struct wpi_softc *sc) 971692ad7caSAdrian Chadd { 972692ad7caSAdrian Chadd wpi_dma_contig_free(&sc->shared_dma); 973692ad7caSAdrian Chadd } 974692ad7caSAdrian Chadd 975692ad7caSAdrian Chadd /* 976692ad7caSAdrian Chadd * Allocate DMA-safe memory for firmware transfer. 977692ad7caSAdrian Chadd */ 978692ad7caSAdrian Chadd static int 979692ad7caSAdrian Chadd wpi_alloc_fwmem(struct wpi_softc *sc) 980692ad7caSAdrian Chadd { 981692ad7caSAdrian Chadd /* Must be aligned on a 16-byte boundary. */ 982692ad7caSAdrian Chadd return wpi_dma_contig_alloc(sc, &sc->fw_dma, NULL, 983692ad7caSAdrian Chadd WPI_FW_TEXT_MAXSZ + WPI_FW_DATA_MAXSZ, 16); 984692ad7caSAdrian Chadd } 985692ad7caSAdrian Chadd 986692ad7caSAdrian Chadd static void 987692ad7caSAdrian Chadd wpi_free_fwmem(struct wpi_softc *sc) 988692ad7caSAdrian Chadd { 989692ad7caSAdrian Chadd wpi_dma_contig_free(&sc->fw_dma); 990692ad7caSAdrian Chadd } 991692ad7caSAdrian Chadd 992692ad7caSAdrian Chadd static int 993692ad7caSAdrian Chadd wpi_alloc_rx_ring(struct wpi_softc *sc) 994692ad7caSAdrian Chadd { 995692ad7caSAdrian Chadd struct wpi_rx_ring *ring = &sc->rxq; 996692ad7caSAdrian Chadd bus_size_t size; 997692ad7caSAdrian Chadd int i, error; 998692ad7caSAdrian Chadd 999692ad7caSAdrian Chadd ring->cur = 0; 1000692ad7caSAdrian Chadd ring->update = 0; 1001692ad7caSAdrian Chadd 1002692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1003692ad7caSAdrian Chadd 1004692ad7caSAdrian Chadd /* Allocate RX descriptors (16KB aligned.) */ 1005692ad7caSAdrian Chadd size = WPI_RX_RING_COUNT * sizeof (uint32_t); 1006692ad7caSAdrian Chadd error = wpi_dma_contig_alloc(sc, &ring->desc_dma, 1007692ad7caSAdrian Chadd (void **)&ring->desc, size, WPI_RING_DMA_ALIGN); 1008692ad7caSAdrian Chadd if (error != 0) { 1009692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1010692ad7caSAdrian Chadd "%s: could not allocate RX ring DMA memory, error %d\n", 1011692ad7caSAdrian Chadd __func__, error); 1012692ad7caSAdrian Chadd goto fail; 1013692ad7caSAdrian Chadd } 1014692ad7caSAdrian Chadd 1015692ad7caSAdrian Chadd /* Create RX buffer DMA tag. */ 1016692ad7caSAdrian Chadd error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, 1017692ad7caSAdrian Chadd BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 1018b020e15eSKevin Lo MJUMPAGESIZE, 1, MJUMPAGESIZE, 0, NULL, NULL, &ring->data_dmat); 1019692ad7caSAdrian Chadd if (error != 0) { 1020692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1021692ad7caSAdrian Chadd "%s: could not create RX buf DMA tag, error %d\n", 1022692ad7caSAdrian Chadd __func__, error); 1023692ad7caSAdrian Chadd goto fail; 1024692ad7caSAdrian Chadd } 1025692ad7caSAdrian Chadd 1026692ad7caSAdrian Chadd /* 1027692ad7caSAdrian Chadd * Allocate and map RX buffers. 1028692ad7caSAdrian Chadd */ 1029692ad7caSAdrian Chadd for (i = 0; i < WPI_RX_RING_COUNT; i++) { 1030692ad7caSAdrian Chadd struct wpi_rx_data *data = &ring->data[i]; 1031692ad7caSAdrian Chadd bus_addr_t paddr; 1032692ad7caSAdrian Chadd 1033692ad7caSAdrian Chadd error = bus_dmamap_create(ring->data_dmat, 0, &data->map); 1034692ad7caSAdrian Chadd if (error != 0) { 1035692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1036692ad7caSAdrian Chadd "%s: could not create RX buf DMA map, error %d\n", 1037692ad7caSAdrian Chadd __func__, error); 1038692ad7caSAdrian Chadd goto fail; 1039692ad7caSAdrian Chadd } 1040692ad7caSAdrian Chadd 1041692ad7caSAdrian Chadd data->m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); 1042692ad7caSAdrian Chadd if (data->m == NULL) { 1043692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1044692ad7caSAdrian Chadd "%s: could not allocate RX mbuf\n", __func__); 1045692ad7caSAdrian Chadd error = ENOBUFS; 1046692ad7caSAdrian Chadd goto fail; 1047692ad7caSAdrian Chadd } 1048692ad7caSAdrian Chadd 1049692ad7caSAdrian Chadd error = bus_dmamap_load(ring->data_dmat, data->map, 1050692ad7caSAdrian Chadd mtod(data->m, void *), MJUMPAGESIZE, wpi_dma_map_addr, 1051692ad7caSAdrian Chadd &paddr, BUS_DMA_NOWAIT); 1052692ad7caSAdrian Chadd if (error != 0 && error != EFBIG) { 1053692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1054692ad7caSAdrian Chadd "%s: can't map mbuf (error %d)\n", __func__, 1055692ad7caSAdrian Chadd error); 1056692ad7caSAdrian Chadd goto fail; 1057692ad7caSAdrian Chadd } 1058692ad7caSAdrian Chadd 1059692ad7caSAdrian Chadd /* Set physical address of RX buffer. */ 1060692ad7caSAdrian Chadd ring->desc[i] = htole32(paddr); 1061692ad7caSAdrian Chadd } 1062692ad7caSAdrian Chadd 1063692ad7caSAdrian Chadd bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 1064692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1065692ad7caSAdrian Chadd 1066692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1067692ad7caSAdrian Chadd 1068692ad7caSAdrian Chadd return 0; 1069692ad7caSAdrian Chadd 1070692ad7caSAdrian Chadd fail: wpi_free_rx_ring(sc); 1071692ad7caSAdrian Chadd 1072692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1073692ad7caSAdrian Chadd 1074692ad7caSAdrian Chadd return error; 1075692ad7caSAdrian Chadd } 1076692ad7caSAdrian Chadd 1077692ad7caSAdrian Chadd static void 1078692ad7caSAdrian Chadd wpi_update_rx_ring(struct wpi_softc *sc) 1079692ad7caSAdrian Chadd { 10805cacb17fSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_WPTR, sc->rxq.cur & ~7); 10815cacb17fSAdrian Chadd } 10825cacb17fSAdrian Chadd 10835cacb17fSAdrian Chadd static void 10845cacb17fSAdrian Chadd wpi_update_rx_ring_ps(struct wpi_softc *sc) 10855cacb17fSAdrian Chadd { 1086692ad7caSAdrian Chadd struct wpi_rx_ring *ring = &sc->rxq; 1087692ad7caSAdrian Chadd 108801729242SAdrian Chadd if (ring->update != 0) { 108901729242SAdrian Chadd /* Wait for INT_WAKEUP event. */ 109001729242SAdrian Chadd return; 109101729242SAdrian Chadd } 109201729242SAdrian Chadd 1093431ebc90SAdrian Chadd WPI_TXQ_LOCK(sc); 10945cacb17fSAdrian Chadd WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 10955cacb17fSAdrian Chadd if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_SLEEP) { 1096692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_PWRSAVE, "%s: wakeup request\n", 1097692ad7caSAdrian Chadd __func__); 1098692ad7caSAdrian Chadd ring->update = 1; 10995cacb17fSAdrian Chadd } else { 11005cacb17fSAdrian Chadd wpi_update_rx_ring(sc); 11015cacb17fSAdrian Chadd WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 11025cacb17fSAdrian Chadd } 1103431ebc90SAdrian Chadd WPI_TXQ_UNLOCK(sc); 1104692ad7caSAdrian Chadd } 1105692ad7caSAdrian Chadd 1106692ad7caSAdrian Chadd static void 1107692ad7caSAdrian Chadd wpi_reset_rx_ring(struct wpi_softc *sc) 1108692ad7caSAdrian Chadd { 1109692ad7caSAdrian Chadd struct wpi_rx_ring *ring = &sc->rxq; 1110692ad7caSAdrian Chadd int ntries; 1111692ad7caSAdrian Chadd 1112692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 1113692ad7caSAdrian Chadd 1114692ad7caSAdrian Chadd if (wpi_nic_lock(sc) == 0) { 1115692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_CONFIG, 0); 1116692ad7caSAdrian Chadd for (ntries = 0; ntries < 1000; ntries++) { 1117692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_FH_RX_STATUS) & 1118692ad7caSAdrian Chadd WPI_FH_RX_STATUS_IDLE) 1119692ad7caSAdrian Chadd break; 1120692ad7caSAdrian Chadd DELAY(10); 1121692ad7caSAdrian Chadd } 1122692ad7caSAdrian Chadd wpi_nic_unlock(sc); 1123692ad7caSAdrian Chadd } 1124692ad7caSAdrian Chadd 1125692ad7caSAdrian Chadd ring->cur = 0; 1126692ad7caSAdrian Chadd ring->update = 0; 1127692ad7caSAdrian Chadd } 1128692ad7caSAdrian Chadd 1129692ad7caSAdrian Chadd static void 1130692ad7caSAdrian Chadd wpi_free_rx_ring(struct wpi_softc *sc) 1131692ad7caSAdrian Chadd { 1132692ad7caSAdrian Chadd struct wpi_rx_ring *ring = &sc->rxq; 1133692ad7caSAdrian Chadd int i; 1134692ad7caSAdrian Chadd 1135692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 1136692ad7caSAdrian Chadd 1137692ad7caSAdrian Chadd wpi_dma_contig_free(&ring->desc_dma); 1138692ad7caSAdrian Chadd 1139692ad7caSAdrian Chadd for (i = 0; i < WPI_RX_RING_COUNT; i++) { 1140692ad7caSAdrian Chadd struct wpi_rx_data *data = &ring->data[i]; 1141692ad7caSAdrian Chadd 1142692ad7caSAdrian Chadd if (data->m != NULL) { 1143692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 1144692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 1145692ad7caSAdrian Chadd bus_dmamap_unload(ring->data_dmat, data->map); 1146692ad7caSAdrian Chadd m_freem(data->m); 1147692ad7caSAdrian Chadd data->m = NULL; 1148692ad7caSAdrian Chadd } 1149692ad7caSAdrian Chadd if (data->map != NULL) 1150692ad7caSAdrian Chadd bus_dmamap_destroy(ring->data_dmat, data->map); 1151692ad7caSAdrian Chadd } 1152692ad7caSAdrian Chadd if (ring->data_dmat != NULL) { 1153692ad7caSAdrian Chadd bus_dma_tag_destroy(ring->data_dmat); 1154692ad7caSAdrian Chadd ring->data_dmat = NULL; 1155692ad7caSAdrian Chadd } 1156692ad7caSAdrian Chadd } 1157692ad7caSAdrian Chadd 1158692ad7caSAdrian Chadd static int 1159525a3d47SAdrian Chadd wpi_alloc_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring, uint8_t qid) 1160692ad7caSAdrian Chadd { 1161692ad7caSAdrian Chadd bus_addr_t paddr; 1162692ad7caSAdrian Chadd bus_size_t size; 1163692ad7caSAdrian Chadd int i, error; 1164692ad7caSAdrian Chadd 1165692ad7caSAdrian Chadd ring->qid = qid; 1166692ad7caSAdrian Chadd ring->queued = 0; 1167692ad7caSAdrian Chadd ring->cur = 0; 1168940aa808SAdrian Chadd ring->pending = 0; 1169692ad7caSAdrian Chadd ring->update = 0; 1170692ad7caSAdrian Chadd 1171692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1172692ad7caSAdrian Chadd 1173692ad7caSAdrian Chadd /* Allocate TX descriptors (16KB aligned.) */ 1174692ad7caSAdrian Chadd size = WPI_TX_RING_COUNT * sizeof (struct wpi_tx_desc); 1175692ad7caSAdrian Chadd error = wpi_dma_contig_alloc(sc, &ring->desc_dma, (void **)&ring->desc, 1176692ad7caSAdrian Chadd size, WPI_RING_DMA_ALIGN); 1177692ad7caSAdrian Chadd if (error != 0) { 1178692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1179692ad7caSAdrian Chadd "%s: could not allocate TX ring DMA memory, error %d\n", 1180692ad7caSAdrian Chadd __func__, error); 1181692ad7caSAdrian Chadd goto fail; 1182692ad7caSAdrian Chadd } 1183692ad7caSAdrian Chadd 1184692ad7caSAdrian Chadd /* Update shared area with ring physical address. */ 1185692ad7caSAdrian Chadd sc->shared->txbase[qid] = htole32(ring->desc_dma.paddr); 1186692ad7caSAdrian Chadd bus_dmamap_sync(sc->shared_dma.tag, sc->shared_dma.map, 1187692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1188692ad7caSAdrian Chadd 1189692ad7caSAdrian Chadd size = WPI_TX_RING_COUNT * sizeof (struct wpi_tx_cmd); 1190692ad7caSAdrian Chadd error = wpi_dma_contig_alloc(sc, &ring->cmd_dma, (void **)&ring->cmd, 1191692ad7caSAdrian Chadd size, 4); 1192692ad7caSAdrian Chadd if (error != 0) { 1193692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1194692ad7caSAdrian Chadd "%s: could not allocate TX cmd DMA memory, error %d\n", 1195692ad7caSAdrian Chadd __func__, error); 1196692ad7caSAdrian Chadd goto fail; 1197692ad7caSAdrian Chadd } 1198692ad7caSAdrian Chadd 1199692ad7caSAdrian Chadd error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, 1200692ad7caSAdrian Chadd BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES, 1201b020e15eSKevin Lo WPI_MAX_SCATTER - 1, MCLBYTES, 0, NULL, NULL, &ring->data_dmat); 1202692ad7caSAdrian Chadd if (error != 0) { 1203692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1204692ad7caSAdrian Chadd "%s: could not create TX buf DMA tag, error %d\n", 1205692ad7caSAdrian Chadd __func__, error); 1206692ad7caSAdrian Chadd goto fail; 1207692ad7caSAdrian Chadd } 1208692ad7caSAdrian Chadd 1209692ad7caSAdrian Chadd paddr = ring->cmd_dma.paddr; 1210692ad7caSAdrian Chadd for (i = 0; i < WPI_TX_RING_COUNT; i++) { 1211692ad7caSAdrian Chadd struct wpi_tx_data *data = &ring->data[i]; 1212692ad7caSAdrian Chadd 1213692ad7caSAdrian Chadd data->cmd_paddr = paddr; 1214692ad7caSAdrian Chadd paddr += sizeof (struct wpi_tx_cmd); 1215692ad7caSAdrian Chadd 1216692ad7caSAdrian Chadd error = bus_dmamap_create(ring->data_dmat, 0, &data->map); 1217692ad7caSAdrian Chadd if (error != 0) { 1218692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1219692ad7caSAdrian Chadd "%s: could not create TX buf DMA map, error %d\n", 1220692ad7caSAdrian Chadd __func__, error); 1221692ad7caSAdrian Chadd goto fail; 1222692ad7caSAdrian Chadd } 1223692ad7caSAdrian Chadd } 1224692ad7caSAdrian Chadd 1225692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1226692ad7caSAdrian Chadd 1227692ad7caSAdrian Chadd return 0; 1228692ad7caSAdrian Chadd 1229692ad7caSAdrian Chadd fail: wpi_free_tx_ring(sc, ring); 1230692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1231692ad7caSAdrian Chadd return error; 1232692ad7caSAdrian Chadd } 1233692ad7caSAdrian Chadd 1234692ad7caSAdrian Chadd static void 1235692ad7caSAdrian Chadd wpi_update_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring) 1236692ad7caSAdrian Chadd { 12375cacb17fSAdrian Chadd WPI_WRITE(sc, WPI_HBUS_TARG_WRPTR, ring->qid << 8 | ring->cur); 12385cacb17fSAdrian Chadd } 12395cacb17fSAdrian Chadd 12405cacb17fSAdrian Chadd static void 12415cacb17fSAdrian Chadd wpi_update_tx_ring_ps(struct wpi_softc *sc, struct wpi_tx_ring *ring) 12425cacb17fSAdrian Chadd { 12435cacb17fSAdrian Chadd 124401729242SAdrian Chadd if (ring->update != 0) { 124501729242SAdrian Chadd /* Wait for INT_WAKEUP event. */ 124601729242SAdrian Chadd return; 124701729242SAdrian Chadd } 124801729242SAdrian Chadd 12495cacb17fSAdrian Chadd WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 12505cacb17fSAdrian Chadd if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_SLEEP) { 1251692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_PWRSAVE, "%s (%d): requesting wakeup\n", 1252692ad7caSAdrian Chadd __func__, ring->qid); 1253692ad7caSAdrian Chadd ring->update = 1; 12545cacb17fSAdrian Chadd } else { 12555cacb17fSAdrian Chadd wpi_update_tx_ring(sc, ring); 12565cacb17fSAdrian Chadd WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 12575cacb17fSAdrian Chadd } 1258692ad7caSAdrian Chadd } 1259692ad7caSAdrian Chadd 1260692ad7caSAdrian Chadd static void 1261692ad7caSAdrian Chadd wpi_reset_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring) 1262692ad7caSAdrian Chadd { 1263692ad7caSAdrian Chadd int i; 1264692ad7caSAdrian Chadd 1265692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 1266692ad7caSAdrian Chadd 1267692ad7caSAdrian Chadd for (i = 0; i < WPI_TX_RING_COUNT; i++) { 1268692ad7caSAdrian Chadd struct wpi_tx_data *data = &ring->data[i]; 1269692ad7caSAdrian Chadd 1270692ad7caSAdrian Chadd if (data->m != NULL) { 1271692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 1272692ad7caSAdrian Chadd BUS_DMASYNC_POSTWRITE); 1273692ad7caSAdrian Chadd bus_dmamap_unload(ring->data_dmat, data->map); 1274692ad7caSAdrian Chadd m_freem(data->m); 1275692ad7caSAdrian Chadd data->m = NULL; 1276692ad7caSAdrian Chadd } 1277978d805fSAdrian Chadd if (data->ni != NULL) { 1278978d805fSAdrian Chadd ieee80211_free_node(data->ni); 1279978d805fSAdrian Chadd data->ni = NULL; 1280978d805fSAdrian Chadd } 1281692ad7caSAdrian Chadd } 1282692ad7caSAdrian Chadd /* Clear TX descriptors. */ 1283692ad7caSAdrian Chadd memset(ring->desc, 0, ring->desc_dma.size); 1284692ad7caSAdrian Chadd bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 1285692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1286692ad7caSAdrian Chadd ring->queued = 0; 1287692ad7caSAdrian Chadd ring->cur = 0; 1288940aa808SAdrian Chadd ring->pending = 0; 1289692ad7caSAdrian Chadd ring->update = 0; 1290692ad7caSAdrian Chadd } 1291692ad7caSAdrian Chadd 1292692ad7caSAdrian Chadd static void 1293692ad7caSAdrian Chadd wpi_free_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring) 1294692ad7caSAdrian Chadd { 1295692ad7caSAdrian Chadd int i; 1296692ad7caSAdrian Chadd 1297692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 1298692ad7caSAdrian Chadd 1299692ad7caSAdrian Chadd wpi_dma_contig_free(&ring->desc_dma); 1300692ad7caSAdrian Chadd wpi_dma_contig_free(&ring->cmd_dma); 1301692ad7caSAdrian Chadd 1302692ad7caSAdrian Chadd for (i = 0; i < WPI_TX_RING_COUNT; i++) { 1303692ad7caSAdrian Chadd struct wpi_tx_data *data = &ring->data[i]; 1304692ad7caSAdrian Chadd 1305692ad7caSAdrian Chadd if (data->m != NULL) { 1306692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 1307692ad7caSAdrian Chadd BUS_DMASYNC_POSTWRITE); 1308692ad7caSAdrian Chadd bus_dmamap_unload(ring->data_dmat, data->map); 1309692ad7caSAdrian Chadd m_freem(data->m); 1310692ad7caSAdrian Chadd } 1311692ad7caSAdrian Chadd if (data->map != NULL) 1312692ad7caSAdrian Chadd bus_dmamap_destroy(ring->data_dmat, data->map); 1313692ad7caSAdrian Chadd } 1314692ad7caSAdrian Chadd if (ring->data_dmat != NULL) { 1315692ad7caSAdrian Chadd bus_dma_tag_destroy(ring->data_dmat); 1316692ad7caSAdrian Chadd ring->data_dmat = NULL; 1317692ad7caSAdrian Chadd } 1318692ad7caSAdrian Chadd } 1319692ad7caSAdrian Chadd 1320692ad7caSAdrian Chadd /* 1321692ad7caSAdrian Chadd * Extract various information from EEPROM. 1322692ad7caSAdrian Chadd */ 1323692ad7caSAdrian Chadd static int 1324692ad7caSAdrian Chadd wpi_read_eeprom(struct wpi_softc *sc, uint8_t macaddr[IEEE80211_ADDR_LEN]) 1325692ad7caSAdrian Chadd { 1326692ad7caSAdrian Chadd #define WPI_CHK(res) do { \ 1327692ad7caSAdrian Chadd if ((error = res) != 0) \ 1328692ad7caSAdrian Chadd goto fail; \ 1329692ad7caSAdrian Chadd } while (0) 1330525a3d47SAdrian Chadd uint8_t i; 1331525a3d47SAdrian Chadd int error; 1332692ad7caSAdrian Chadd 1333692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1334692ad7caSAdrian Chadd 1335692ad7caSAdrian Chadd /* Adapter has to be powered on for EEPROM access to work. */ 1336692ad7caSAdrian Chadd if ((error = wpi_apm_init(sc)) != 0) { 1337692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1338692ad7caSAdrian Chadd "%s: could not power ON adapter, error %d\n", __func__, 1339692ad7caSAdrian Chadd error); 1340692ad7caSAdrian Chadd return error; 1341692ad7caSAdrian Chadd } 1342692ad7caSAdrian Chadd 1343692ad7caSAdrian Chadd if ((WPI_READ(sc, WPI_EEPROM_GP) & 0x6) == 0) { 1344692ad7caSAdrian Chadd device_printf(sc->sc_dev, "bad EEPROM signature\n"); 1345692ad7caSAdrian Chadd error = EIO; 1346692ad7caSAdrian Chadd goto fail; 1347692ad7caSAdrian Chadd } 1348692ad7caSAdrian Chadd /* Clear HW ownership of EEPROM. */ 1349692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_EEPROM_GP, WPI_EEPROM_GP_IF_OWNER); 1350692ad7caSAdrian Chadd 1351692ad7caSAdrian Chadd /* Read the hardware capabilities, revision and SKU type. */ 1352692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_SKU_CAP, &sc->cap, 1353692ad7caSAdrian Chadd sizeof(sc->cap))); 1354692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_REVISION, &sc->rev, 1355692ad7caSAdrian Chadd sizeof(sc->rev))); 1356692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_TYPE, &sc->type, 1357692ad7caSAdrian Chadd sizeof(sc->type))); 1358692ad7caSAdrian Chadd 1359f736d898SAdrian Chadd sc->rev = le16toh(sc->rev); 13607167f5fcSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, "cap=%x rev=%x type=%x\n", sc->cap, 1361f736d898SAdrian Chadd sc->rev, sc->type); 1362692ad7caSAdrian Chadd 1363692ad7caSAdrian Chadd /* Read the regulatory domain (4 ASCII characters.) */ 1364692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_DOMAIN, sc->domain, 1365692ad7caSAdrian Chadd sizeof(sc->domain))); 1366692ad7caSAdrian Chadd 1367692ad7caSAdrian Chadd /* Read MAC address. */ 1368692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_MAC, macaddr, 1369692ad7caSAdrian Chadd IEEE80211_ADDR_LEN)); 1370692ad7caSAdrian Chadd 1371692ad7caSAdrian Chadd /* Read the list of authorized channels. */ 1372692ad7caSAdrian Chadd for (i = 0; i < WPI_CHAN_BANDS_COUNT; i++) 1373692ad7caSAdrian Chadd WPI_CHK(wpi_read_eeprom_channels(sc, i)); 1374692ad7caSAdrian Chadd 1375692ad7caSAdrian Chadd /* Read the list of TX power groups. */ 1376692ad7caSAdrian Chadd for (i = 0; i < WPI_POWER_GROUPS_COUNT; i++) 1377692ad7caSAdrian Chadd WPI_CHK(wpi_read_eeprom_group(sc, i)); 1378692ad7caSAdrian Chadd 1379692ad7caSAdrian Chadd fail: wpi_apm_stop(sc); /* Power OFF adapter. */ 1380692ad7caSAdrian Chadd 1381692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, error ? TRACE_STR_END_ERR : TRACE_STR_END, 1382692ad7caSAdrian Chadd __func__); 1383692ad7caSAdrian Chadd 1384692ad7caSAdrian Chadd return error; 1385692ad7caSAdrian Chadd #undef WPI_CHK 1386692ad7caSAdrian Chadd } 1387692ad7caSAdrian Chadd 1388692ad7caSAdrian Chadd /* 1389692ad7caSAdrian Chadd * Translate EEPROM flags to net80211. 1390692ad7caSAdrian Chadd */ 1391692ad7caSAdrian Chadd static uint32_t 1392692ad7caSAdrian Chadd wpi_eeprom_channel_flags(struct wpi_eeprom_chan *channel) 1393692ad7caSAdrian Chadd { 1394692ad7caSAdrian Chadd uint32_t nflags; 1395692ad7caSAdrian Chadd 1396692ad7caSAdrian Chadd nflags = 0; 1397692ad7caSAdrian Chadd if ((channel->flags & WPI_EEPROM_CHAN_ACTIVE) == 0) 1398692ad7caSAdrian Chadd nflags |= IEEE80211_CHAN_PASSIVE; 1399692ad7caSAdrian Chadd if ((channel->flags & WPI_EEPROM_CHAN_IBSS) == 0) 1400692ad7caSAdrian Chadd nflags |= IEEE80211_CHAN_NOADHOC; 1401692ad7caSAdrian Chadd if (channel->flags & WPI_EEPROM_CHAN_RADAR) { 1402692ad7caSAdrian Chadd nflags |= IEEE80211_CHAN_DFS; 1403692ad7caSAdrian Chadd /* XXX apparently IBSS may still be marked */ 1404692ad7caSAdrian Chadd nflags |= IEEE80211_CHAN_NOADHOC; 1405692ad7caSAdrian Chadd } 1406692ad7caSAdrian Chadd 1407726ddc26SAdrian Chadd /* XXX HOSTAP uses WPI_MODE_IBSS */ 1408726ddc26SAdrian Chadd if (nflags & IEEE80211_CHAN_NOADHOC) 1409726ddc26SAdrian Chadd nflags |= IEEE80211_CHAN_NOHOSTAP; 1410726ddc26SAdrian Chadd 1411692ad7caSAdrian Chadd return nflags; 1412692ad7caSAdrian Chadd } 1413692ad7caSAdrian Chadd 1414692ad7caSAdrian Chadd static void 14151c6b43dfSAndriy Voskoboinyk wpi_read_eeprom_band(struct wpi_softc *sc, uint8_t n, int maxchans, 14161c6b43dfSAndriy Voskoboinyk int *nchans, struct ieee80211_channel chans[]) 1417692ad7caSAdrian Chadd { 1418692ad7caSAdrian Chadd struct wpi_eeprom_chan *channels = sc->eeprom_channels[n]; 1419692ad7caSAdrian Chadd const struct wpi_chan_band *band = &wpi_bands[n]; 1420525a3d47SAdrian Chadd uint32_t nflags; 14215763d9dbSAndriy Voskoboinyk uint8_t bands[IEEE80211_MODE_BYTES]; 1422525a3d47SAdrian Chadd uint8_t chan, i; 14235763d9dbSAndriy Voskoboinyk int error; 14245763d9dbSAndriy Voskoboinyk 14255763d9dbSAndriy Voskoboinyk memset(bands, 0, sizeof(bands)); 14265763d9dbSAndriy Voskoboinyk 14275763d9dbSAndriy Voskoboinyk if (n == 0) { 14285763d9dbSAndriy Voskoboinyk setbit(bands, IEEE80211_MODE_11B); 14295763d9dbSAndriy Voskoboinyk setbit(bands, IEEE80211_MODE_11G); 14305763d9dbSAndriy Voskoboinyk } else 14315763d9dbSAndriy Voskoboinyk setbit(bands, IEEE80211_MODE_11A); 1432692ad7caSAdrian Chadd 1433692ad7caSAdrian Chadd for (i = 0; i < band->nchan; i++) { 1434692ad7caSAdrian Chadd if (!(channels[i].flags & WPI_EEPROM_CHAN_VALID)) { 14357e0d5232SAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, 1436692ad7caSAdrian Chadd "Channel Not Valid: %d, band %d\n", 1437692ad7caSAdrian Chadd band->chan[i],n); 1438692ad7caSAdrian Chadd continue; 1439692ad7caSAdrian Chadd } 1440692ad7caSAdrian Chadd 1441692ad7caSAdrian Chadd chan = band->chan[i]; 1442692ad7caSAdrian Chadd nflags = wpi_eeprom_channel_flags(&channels[i]); 14435763d9dbSAndriy Voskoboinyk error = ieee80211_add_channel(chans, maxchans, nchans, 14445763d9dbSAndriy Voskoboinyk chan, 0, channels[i].maxpwr, nflags, bands); 14455763d9dbSAndriy Voskoboinyk if (error != 0) 14461c6b43dfSAndriy Voskoboinyk break; 14471c6b43dfSAndriy Voskoboinyk 1448692ad7caSAdrian Chadd /* Save maximum allowed TX power for this channel. */ 1449692ad7caSAdrian Chadd sc->maxpwr[chan] = channels[i].maxpwr; 1450692ad7caSAdrian Chadd 1451692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, 14525763d9dbSAndriy Voskoboinyk "adding chan %d flags=0x%x maxpwr=%d, offset %d\n", 14535763d9dbSAndriy Voskoboinyk chan, channels[i].flags, sc->maxpwr[chan], *nchans); 1454692ad7caSAdrian Chadd } 1455692ad7caSAdrian Chadd } 1456692ad7caSAdrian Chadd 1457692ad7caSAdrian Chadd /** 1458692ad7caSAdrian Chadd * Read the eeprom to find out what channels are valid for the given 1459692ad7caSAdrian Chadd * band and update net80211 with what we find. 1460692ad7caSAdrian Chadd */ 1461692ad7caSAdrian Chadd static int 1462525a3d47SAdrian Chadd wpi_read_eeprom_channels(struct wpi_softc *sc, uint8_t n) 1463692ad7caSAdrian Chadd { 14647a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 1465692ad7caSAdrian Chadd const struct wpi_chan_band *band = &wpi_bands[n]; 1466692ad7caSAdrian Chadd int error; 1467692ad7caSAdrian Chadd 1468692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1469692ad7caSAdrian Chadd 1470692ad7caSAdrian Chadd error = wpi_read_prom_data(sc, band->addr, &sc->eeprom_channels[n], 1471692ad7caSAdrian Chadd band->nchan * sizeof (struct wpi_eeprom_chan)); 1472692ad7caSAdrian Chadd if (error != 0) { 1473692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1474692ad7caSAdrian Chadd return error; 1475692ad7caSAdrian Chadd } 1476692ad7caSAdrian Chadd 14771c6b43dfSAndriy Voskoboinyk wpi_read_eeprom_band(sc, n, IEEE80211_CHAN_MAX, &ic->ic_nchans, 14781c6b43dfSAndriy Voskoboinyk ic->ic_channels); 1479692ad7caSAdrian Chadd 1480692ad7caSAdrian Chadd ieee80211_sort_channels(ic->ic_channels, ic->ic_nchans); 1481692ad7caSAdrian Chadd 1482692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1483692ad7caSAdrian Chadd 1484692ad7caSAdrian Chadd return 0; 1485692ad7caSAdrian Chadd } 1486692ad7caSAdrian Chadd 1487692ad7caSAdrian Chadd static struct wpi_eeprom_chan * 1488692ad7caSAdrian Chadd wpi_find_eeprom_channel(struct wpi_softc *sc, struct ieee80211_channel *c) 1489692ad7caSAdrian Chadd { 1490692ad7caSAdrian Chadd int i, j; 1491692ad7caSAdrian Chadd 1492692ad7caSAdrian Chadd for (j = 0; j < WPI_CHAN_BANDS_COUNT; j++) 1493692ad7caSAdrian Chadd for (i = 0; i < wpi_bands[j].nchan; i++) 149486d9f8fcSAndriy Voskoboinyk if (wpi_bands[j].chan[i] == c->ic_ieee && 149586d9f8fcSAndriy Voskoboinyk ((j == 0) ^ IEEE80211_IS_CHAN_A(c)) == 1) 1496692ad7caSAdrian Chadd return &sc->eeprom_channels[j][i]; 1497692ad7caSAdrian Chadd 1498692ad7caSAdrian Chadd return NULL; 1499692ad7caSAdrian Chadd } 1500692ad7caSAdrian Chadd 15011c6b43dfSAndriy Voskoboinyk static void 15021c6b43dfSAndriy Voskoboinyk wpi_getradiocaps(struct ieee80211com *ic, 15031c6b43dfSAndriy Voskoboinyk int maxchans, int *nchans, struct ieee80211_channel chans[]) 15041c6b43dfSAndriy Voskoboinyk { 15051c6b43dfSAndriy Voskoboinyk struct wpi_softc *sc = ic->ic_softc; 15061c6b43dfSAndriy Voskoboinyk int i; 15071c6b43dfSAndriy Voskoboinyk 15081c6b43dfSAndriy Voskoboinyk /* Parse the list of authorized channels. */ 15091c6b43dfSAndriy Voskoboinyk for (i = 0; i < WPI_CHAN_BANDS_COUNT && *nchans < maxchans; i++) 15101c6b43dfSAndriy Voskoboinyk wpi_read_eeprom_band(sc, i, maxchans, nchans, chans); 15111c6b43dfSAndriy Voskoboinyk } 15121c6b43dfSAndriy Voskoboinyk 1513692ad7caSAdrian Chadd /* 1514692ad7caSAdrian Chadd * Enforce flags read from EEPROM. 1515692ad7caSAdrian Chadd */ 1516692ad7caSAdrian Chadd static int 1517692ad7caSAdrian Chadd wpi_setregdomain(struct ieee80211com *ic, struct ieee80211_regdomain *rd, 1518692ad7caSAdrian Chadd int nchan, struct ieee80211_channel chans[]) 1519692ad7caSAdrian Chadd { 15202cb71df1SAdrian Chadd struct wpi_softc *sc = ic->ic_softc; 1521692ad7caSAdrian Chadd int i; 1522692ad7caSAdrian Chadd 1523692ad7caSAdrian Chadd for (i = 0; i < nchan; i++) { 1524692ad7caSAdrian Chadd struct ieee80211_channel *c = &chans[i]; 1525692ad7caSAdrian Chadd struct wpi_eeprom_chan *channel; 1526692ad7caSAdrian Chadd 1527692ad7caSAdrian Chadd channel = wpi_find_eeprom_channel(sc, c); 1528692ad7caSAdrian Chadd if (channel == NULL) { 15297a79cebfSGleb Smirnoff ic_printf(ic, "%s: invalid channel %u freq %u/0x%x\n", 1530692ad7caSAdrian Chadd __func__, c->ic_ieee, c->ic_freq, c->ic_flags); 1531692ad7caSAdrian Chadd return EINVAL; 1532692ad7caSAdrian Chadd } 1533692ad7caSAdrian Chadd c->ic_flags |= wpi_eeprom_channel_flags(channel); 1534692ad7caSAdrian Chadd } 1535692ad7caSAdrian Chadd 1536692ad7caSAdrian Chadd return 0; 1537692ad7caSAdrian Chadd } 1538692ad7caSAdrian Chadd 1539692ad7caSAdrian Chadd static int 1540525a3d47SAdrian Chadd wpi_read_eeprom_group(struct wpi_softc *sc, uint8_t n) 1541692ad7caSAdrian Chadd { 1542692ad7caSAdrian Chadd struct wpi_power_group *group = &sc->groups[n]; 1543692ad7caSAdrian Chadd struct wpi_eeprom_group rgroup; 1544692ad7caSAdrian Chadd int i, error; 1545692ad7caSAdrian Chadd 1546692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1547692ad7caSAdrian Chadd 1548692ad7caSAdrian Chadd if ((error = wpi_read_prom_data(sc, WPI_EEPROM_POWER_GRP + n * 32, 1549692ad7caSAdrian Chadd &rgroup, sizeof rgroup)) != 0) { 1550692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1551692ad7caSAdrian Chadd return error; 1552692ad7caSAdrian Chadd } 1553692ad7caSAdrian Chadd 1554692ad7caSAdrian Chadd /* Save TX power group information. */ 1555692ad7caSAdrian Chadd group->chan = rgroup.chan; 1556692ad7caSAdrian Chadd group->maxpwr = rgroup.maxpwr; 1557692ad7caSAdrian Chadd /* Retrieve temperature at which the samples were taken. */ 1558692ad7caSAdrian Chadd group->temp = (int16_t)le16toh(rgroup.temp); 1559692ad7caSAdrian Chadd 1560692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, 1561692ad7caSAdrian Chadd "power group %d: chan=%d maxpwr=%d temp=%d\n", n, group->chan, 1562692ad7caSAdrian Chadd group->maxpwr, group->temp); 1563692ad7caSAdrian Chadd 1564692ad7caSAdrian Chadd for (i = 0; i < WPI_SAMPLES_COUNT; i++) { 1565692ad7caSAdrian Chadd group->samples[i].index = rgroup.samples[i].index; 1566692ad7caSAdrian Chadd group->samples[i].power = rgroup.samples[i].power; 1567692ad7caSAdrian Chadd 1568692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, 1569692ad7caSAdrian Chadd "\tsample %d: index=%d power=%d\n", i, 1570692ad7caSAdrian Chadd group->samples[i].index, group->samples[i].power); 1571692ad7caSAdrian Chadd } 1572692ad7caSAdrian Chadd 1573692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1574692ad7caSAdrian Chadd 1575692ad7caSAdrian Chadd return 0; 1576692ad7caSAdrian Chadd } 1577692ad7caSAdrian Chadd 1578525a3d47SAdrian Chadd static __inline uint8_t 1579eca2eb39SAdrian Chadd wpi_add_node_entry_adhoc(struct wpi_softc *sc) 1580eca2eb39SAdrian Chadd { 1581525a3d47SAdrian Chadd uint8_t newid = WPI_ID_IBSS_MIN; 1582eca2eb39SAdrian Chadd 1583eca2eb39SAdrian Chadd for (; newid <= WPI_ID_IBSS_MAX; newid++) { 1584eca2eb39SAdrian Chadd if ((sc->nodesmsk & (1 << newid)) == 0) { 1585eca2eb39SAdrian Chadd sc->nodesmsk |= 1 << newid; 1586eca2eb39SAdrian Chadd return newid; 1587eca2eb39SAdrian Chadd } 1588eca2eb39SAdrian Chadd } 1589eca2eb39SAdrian Chadd 1590eca2eb39SAdrian Chadd return WPI_ID_UNDEFINED; 1591eca2eb39SAdrian Chadd } 1592eca2eb39SAdrian Chadd 1593525a3d47SAdrian Chadd static __inline uint8_t 15940ebca245SAdrian Chadd wpi_add_node_entry_sta(struct wpi_softc *sc) 15950ebca245SAdrian Chadd { 15960ebca245SAdrian Chadd sc->nodesmsk |= 1 << WPI_ID_BSS; 15970ebca245SAdrian Chadd 15980ebca245SAdrian Chadd return WPI_ID_BSS; 15990ebca245SAdrian Chadd } 16000ebca245SAdrian Chadd 16010ebca245SAdrian Chadd static __inline int 1602eca2eb39SAdrian Chadd wpi_check_node_entry(struct wpi_softc *sc, uint8_t id) 1603eca2eb39SAdrian Chadd { 1604eca2eb39SAdrian Chadd if (id == WPI_ID_UNDEFINED) 1605eca2eb39SAdrian Chadd return 0; 1606eca2eb39SAdrian Chadd 1607eca2eb39SAdrian Chadd return (sc->nodesmsk >> id) & 1; 1608eca2eb39SAdrian Chadd } 1609eca2eb39SAdrian Chadd 1610eca2eb39SAdrian Chadd static __inline void 1611eca2eb39SAdrian Chadd wpi_clear_node_table(struct wpi_softc *sc) 1612eca2eb39SAdrian Chadd { 1613eca2eb39SAdrian Chadd sc->nodesmsk = 0; 1614eca2eb39SAdrian Chadd } 1615eca2eb39SAdrian Chadd 1616eca2eb39SAdrian Chadd static __inline void 1617eca2eb39SAdrian Chadd wpi_del_node_entry(struct wpi_softc *sc, uint8_t id) 1618eca2eb39SAdrian Chadd { 1619eca2eb39SAdrian Chadd sc->nodesmsk &= ~(1 << id); 1620eca2eb39SAdrian Chadd } 1621eca2eb39SAdrian Chadd 1622692ad7caSAdrian Chadd static struct ieee80211_node * 1623692ad7caSAdrian Chadd wpi_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN]) 1624692ad7caSAdrian Chadd { 1625692ad7caSAdrian Chadd struct wpi_node *wn; 1626692ad7caSAdrian Chadd 1627692ad7caSAdrian Chadd wn = malloc(sizeof (struct wpi_node), M_80211_NODE, 1628692ad7caSAdrian Chadd M_NOWAIT | M_ZERO); 1629692ad7caSAdrian Chadd 1630692ad7caSAdrian Chadd if (wn == NULL) 1631692ad7caSAdrian Chadd return NULL; 1632692ad7caSAdrian Chadd 1633692ad7caSAdrian Chadd wn->id = WPI_ID_UNDEFINED; 1634692ad7caSAdrian Chadd 1635692ad7caSAdrian Chadd return &wn->ni; 1636692ad7caSAdrian Chadd } 1637692ad7caSAdrian Chadd 1638692ad7caSAdrian Chadd static void 1639692ad7caSAdrian Chadd wpi_node_free(struct ieee80211_node *ni) 1640692ad7caSAdrian Chadd { 16417a79cebfSGleb Smirnoff struct wpi_softc *sc = ni->ni_ic->ic_softc; 1642a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 1643692ad7caSAdrian Chadd 16440ebca245SAdrian Chadd if (wn->id != WPI_ID_UNDEFINED) { 16457964dd56SAdrian Chadd WPI_NT_LOCK(sc); 1646eca2eb39SAdrian Chadd if (wpi_check_node_entry(sc, wn->id)) { 1647eca2eb39SAdrian Chadd wpi_del_node_entry(sc, wn->id); 1648692ad7caSAdrian Chadd wpi_del_node(sc, ni); 1649eca2eb39SAdrian Chadd } 16507964dd56SAdrian Chadd WPI_NT_UNLOCK(sc); 1651692ad7caSAdrian Chadd } 1652692ad7caSAdrian Chadd 1653692ad7caSAdrian Chadd sc->sc_node_free(ni); 1654692ad7caSAdrian Chadd } 1655692ad7caSAdrian Chadd 1656621f1a75SAdrian Chadd static __inline int 1657621f1a75SAdrian Chadd wpi_check_bss_filter(struct wpi_softc *sc) 1658621f1a75SAdrian Chadd { 1659621f1a75SAdrian Chadd return (sc->rxon.filter & htole32(WPI_FILTER_BSS)) != 0; 1660621f1a75SAdrian Chadd } 1661621f1a75SAdrian Chadd 1662a20c9affSAdrian Chadd static void 166357c61f5dSAdrian Chadd wpi_ibss_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m, int subtype, 1664b66af287SAdrian Chadd const struct ieee80211_rx_stats *rxs, 1665b66af287SAdrian Chadd int rssi, int nf) 1666a20c9affSAdrian Chadd { 1667a20c9affSAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 16682cb71df1SAdrian Chadd struct wpi_softc *sc = vap->iv_ic->ic_softc; 1669a20c9affSAdrian Chadd struct wpi_vap *wvp = WPI_VAP(vap); 1670a20c9affSAdrian Chadd uint64_t ni_tstamp, rx_tstamp; 1671a20c9affSAdrian Chadd 1672b66af287SAdrian Chadd wvp->wv_recv_mgmt(ni, m, subtype, rxs, rssi, nf); 1673a20c9affSAdrian Chadd 167457c61f5dSAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN && 1675a20c9affSAdrian Chadd (subtype == IEEE80211_FC0_SUBTYPE_BEACON || 1676a20c9affSAdrian Chadd subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP)) { 1677a20c9affSAdrian Chadd ni_tstamp = le64toh(ni->ni_tstamp.tsf); 1678a20c9affSAdrian Chadd rx_tstamp = le64toh(sc->rx_tstamp); 1679a20c9affSAdrian Chadd 1680a20c9affSAdrian Chadd if (ni_tstamp >= rx_tstamp) { 1681a20c9affSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, 1682a20c9affSAdrian Chadd "ibss merge, tsf %ju tstamp %ju\n", 1683a20c9affSAdrian Chadd (uintmax_t)rx_tstamp, (uintmax_t)ni_tstamp); 1684a20c9affSAdrian Chadd (void) ieee80211_ibss_merge(ni); 1685a20c9affSAdrian Chadd } 1686a20c9affSAdrian Chadd } 1687a20c9affSAdrian Chadd } 1688a20c9affSAdrian Chadd 1689a20c9affSAdrian Chadd static void 1690a20c9affSAdrian Chadd wpi_restore_node(void *arg, struct ieee80211_node *ni) 1691a20c9affSAdrian Chadd { 1692a20c9affSAdrian Chadd struct wpi_softc *sc = arg; 1693a20c9affSAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 1694a20c9affSAdrian Chadd int error; 1695a20c9affSAdrian Chadd 1696a20c9affSAdrian Chadd WPI_NT_LOCK(sc); 1697a20c9affSAdrian Chadd if (wn->id != WPI_ID_UNDEFINED) { 1698a20c9affSAdrian Chadd wn->id = WPI_ID_UNDEFINED; 1699a20c9affSAdrian Chadd if ((error = wpi_add_ibss_node(sc, ni)) != 0) { 1700a20c9affSAdrian Chadd device_printf(sc->sc_dev, 1701a20c9affSAdrian Chadd "%s: could not add IBSS node, error %d\n", 1702a20c9affSAdrian Chadd __func__, error); 1703a20c9affSAdrian Chadd } 1704a20c9affSAdrian Chadd } 1705a20c9affSAdrian Chadd WPI_NT_UNLOCK(sc); 1706a20c9affSAdrian Chadd } 1707a20c9affSAdrian Chadd 1708a20c9affSAdrian Chadd static void 1709a20c9affSAdrian Chadd wpi_restore_node_table(struct wpi_softc *sc, struct wpi_vap *wvp) 1710a20c9affSAdrian Chadd { 17117a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 1712a20c9affSAdrian Chadd 1713a20c9affSAdrian Chadd /* Set group keys once. */ 1714a20c9affSAdrian Chadd WPI_NT_LOCK(sc); 1715a20c9affSAdrian Chadd wvp->wv_gtk = 0; 1716a20c9affSAdrian Chadd WPI_NT_UNLOCK(sc); 1717a20c9affSAdrian Chadd 1718a20c9affSAdrian Chadd ieee80211_iterate_nodes(&ic->ic_sta, wpi_restore_node, sc); 1719a20c9affSAdrian Chadd ieee80211_crypto_reload_keys(ic); 1720a20c9affSAdrian Chadd } 1721a20c9affSAdrian Chadd 17226607310bSBenjamin Close /** 17236607310bSBenjamin Close * Called by net80211 when ever there is a change to 80211 state machine 17246607310bSBenjamin Close */ 17256607310bSBenjamin Close static int 1726b032f27cSSam Leffler wpi_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 17276607310bSBenjamin Close { 1728b032f27cSSam Leffler struct wpi_vap *wvp = WPI_VAP(vap); 1729b032f27cSSam Leffler struct ieee80211com *ic = vap->iv_ic; 17302cb71df1SAdrian Chadd struct wpi_softc *sc = ic->ic_softc; 1731692ad7caSAdrian Chadd int error = 0; 17326607310bSBenjamin Close 1733692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1734692ad7caSAdrian Chadd 17357a79cebfSGleb Smirnoff WPI_TXQ_LOCK(sc); 17367a79cebfSGleb Smirnoff if (nstate > IEEE80211_S_INIT && sc->sc_running == 0) { 17377a79cebfSGleb Smirnoff DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 17387a79cebfSGleb Smirnoff WPI_TXQ_UNLOCK(sc); 17397a79cebfSGleb Smirnoff 17407a79cebfSGleb Smirnoff return ENXIO; 17417a79cebfSGleb Smirnoff } 17427a79cebfSGleb Smirnoff WPI_TXQ_UNLOCK(sc); 17437a79cebfSGleb Smirnoff 1744692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, "%s: %s -> %s\n", __func__, 1745b032f27cSSam Leffler ieee80211_state_name[vap->iv_state], 1746692ad7caSAdrian Chadd ieee80211_state_name[nstate]); 17476607310bSBenjamin Close 17483289bbc9SAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN && nstate < IEEE80211_S_RUN) { 17492e79e293SAdrian Chadd if ((error = wpi_set_pslevel(sc, 0, 0, 1)) != 0) { 17502e79e293SAdrian Chadd device_printf(sc->sc_dev, 17512e79e293SAdrian Chadd "%s: could not set power saving level\n", 17522e79e293SAdrian Chadd __func__); 17532e79e293SAdrian Chadd return error; 17542e79e293SAdrian Chadd } 17553289bbc9SAdrian Chadd 17563289bbc9SAdrian Chadd wpi_set_led(sc, WPI_LED_LINK, 1, 0); 17572e79e293SAdrian Chadd } 17582e79e293SAdrian Chadd 1759692ad7caSAdrian Chadd switch (nstate) { 1760692ad7caSAdrian Chadd case IEEE80211_S_SCAN: 1761446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 1762a4703831SAdrian Chadd if (wpi_check_bss_filter(sc) != 0) { 1763692ad7caSAdrian Chadd sc->rxon.filter &= ~htole32(WPI_FILTER_BSS); 1764692ad7caSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { 17653934c8a5SBernhard Schmidt device_printf(sc->sc_dev, 1766692ad7caSAdrian Chadd "%s: could not send RXON\n", __func__); 17673934c8a5SBernhard Schmidt } 17683934c8a5SBernhard Schmidt } 1769446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 1770692ad7caSAdrian Chadd break; 1771692ad7caSAdrian Chadd 1772692ad7caSAdrian Chadd case IEEE80211_S_ASSOC: 1773692ad7caSAdrian Chadd if (vap->iv_state != IEEE80211_S_RUN) 1774692ad7caSAdrian Chadd break; 1775692ad7caSAdrian Chadd /* FALLTHROUGH */ 1776692ad7caSAdrian Chadd case IEEE80211_S_AUTH: 17773934c8a5SBernhard Schmidt /* 177889023da2SAdrian Chadd * NB: do not optimize AUTH -> AUTH state transmission - 177989023da2SAdrian Chadd * this will break powersave with non-QoS AP! 178089023da2SAdrian Chadd */ 178189023da2SAdrian Chadd 178289023da2SAdrian Chadd /* 17833934c8a5SBernhard Schmidt * The node must be registered in the firmware before auth. 17843934c8a5SBernhard Schmidt * Also the associd must be cleared on RUN -> ASSOC 17853934c8a5SBernhard Schmidt * transitions. 17863934c8a5SBernhard Schmidt */ 1787692ad7caSAdrian Chadd if ((error = wpi_auth(sc, vap)) != 0) { 17885efea30fSAndrew Thompson device_printf(sc->sc_dev, 1789692ad7caSAdrian Chadd "%s: could not move to AUTH state, error %d\n", 17905efea30fSAndrew Thompson __func__, error); 17915efea30fSAndrew Thompson } 1792692ad7caSAdrian Chadd break; 1793692ad7caSAdrian Chadd 1794692ad7caSAdrian Chadd case IEEE80211_S_RUN: 1795692ad7caSAdrian Chadd /* 1796a20c9affSAdrian Chadd * RUN -> RUN transition: 1797a20c9affSAdrian Chadd * STA mode: Just restart the timers. 1798a20c9affSAdrian Chadd * IBSS mode: Process IBSS merge. 1799692ad7caSAdrian Chadd */ 1800692ad7caSAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN) { 1801a20c9affSAdrian Chadd if (vap->iv_opmode != IEEE80211_M_IBSS) { 1802446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 1803b032f27cSSam Leffler wpi_calib_timeout(sc); 1804446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 1805692ad7caSAdrian Chadd break; 1806a20c9affSAdrian Chadd } else { 1807a20c9affSAdrian Chadd /* 1808a20c9affSAdrian Chadd * Drop the BSS_FILTER bit 1809a20c9affSAdrian Chadd * (there is no another way to change bssid). 1810a20c9affSAdrian Chadd */ 1811a20c9affSAdrian Chadd WPI_RXON_LOCK(sc); 1812a20c9affSAdrian Chadd sc->rxon.filter &= ~htole32(WPI_FILTER_BSS); 1813a20c9affSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { 1814a20c9affSAdrian Chadd device_printf(sc->sc_dev, 1815a20c9affSAdrian Chadd "%s: could not send RXON\n", 1816a20c9affSAdrian Chadd __func__); 1817a20c9affSAdrian Chadd } 1818a20c9affSAdrian Chadd WPI_RXON_UNLOCK(sc); 1819a20c9affSAdrian Chadd 1820a20c9affSAdrian Chadd /* Restore all what was lost. */ 1821a20c9affSAdrian Chadd wpi_restore_node_table(sc, wvp); 1822a20c9affSAdrian Chadd 1823a20c9affSAdrian Chadd /* XXX set conditionally? */ 1824a20c9affSAdrian Chadd wpi_updateedca(ic); 1825a20c9affSAdrian Chadd } 1826692ad7caSAdrian Chadd } 1827692ad7caSAdrian Chadd 1828692ad7caSAdrian Chadd /* 1829692ad7caSAdrian Chadd * !RUN -> RUN requires setting the association id 1830692ad7caSAdrian Chadd * which is done with a firmware cmd. We also defer 1831692ad7caSAdrian Chadd * starting the timers until that work is done. 1832692ad7caSAdrian Chadd */ 1833692ad7caSAdrian Chadd if ((error = wpi_run(sc, vap)) != 0) { 1834692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1835692ad7caSAdrian Chadd "%s: could not move to RUN state\n", __func__); 1836692ad7caSAdrian Chadd } 1837692ad7caSAdrian Chadd break; 1838692ad7caSAdrian Chadd 1839692ad7caSAdrian Chadd default: 1840692ad7caSAdrian Chadd break; 1841b032f27cSSam Leffler } 1842692ad7caSAdrian Chadd if (error != 0) { 1843692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1844692ad7caSAdrian Chadd return error; 1845692ad7caSAdrian Chadd } 1846692ad7caSAdrian Chadd 1847692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1848692ad7caSAdrian Chadd 1849d036bb20SAdrian Chadd return wvp->wv_newstate(vap, nstate, arg); 18506607310bSBenjamin Close } 18516607310bSBenjamin Close 18526607310bSBenjamin Close static void 1853692ad7caSAdrian Chadd wpi_calib_timeout(void *arg) 18546607310bSBenjamin Close { 1855692ad7caSAdrian Chadd struct wpi_softc *sc = arg; 18566607310bSBenjamin Close 1857621f1a75SAdrian Chadd if (wpi_check_bss_filter(sc) == 0) 1858692ad7caSAdrian Chadd return; 18596607310bSBenjamin Close 1860692ad7caSAdrian Chadd wpi_power_calibration(sc); 1861692ad7caSAdrian Chadd 1862692ad7caSAdrian Chadd callout_reset(&sc->calib_to, 60*hz, wpi_calib_timeout, sc); 18636607310bSBenjamin Close } 18646607310bSBenjamin Close 1865692ad7caSAdrian Chadd static __inline uint8_t 1866692ad7caSAdrian Chadd rate2plcp(const uint8_t rate) 18676607310bSBenjamin Close { 1868692ad7caSAdrian Chadd switch (rate) { 1869692ad7caSAdrian Chadd case 12: return 0xd; 1870692ad7caSAdrian Chadd case 18: return 0xf; 1871692ad7caSAdrian Chadd case 24: return 0x5; 1872692ad7caSAdrian Chadd case 36: return 0x7; 1873692ad7caSAdrian Chadd case 48: return 0x9; 1874692ad7caSAdrian Chadd case 72: return 0xb; 1875692ad7caSAdrian Chadd case 96: return 0x1; 1876692ad7caSAdrian Chadd case 108: return 0x3; 1877692ad7caSAdrian Chadd case 2: return 10; 1878692ad7caSAdrian Chadd case 4: return 20; 1879692ad7caSAdrian Chadd case 11: return 55; 1880692ad7caSAdrian Chadd case 22: return 110; 1881692ad7caSAdrian Chadd default: return 0; 1882692ad7caSAdrian Chadd } 18836607310bSBenjamin Close } 18846607310bSBenjamin Close 1885692ad7caSAdrian Chadd static __inline uint8_t 1886692ad7caSAdrian Chadd plcp2rate(const uint8_t plcp) 18876607310bSBenjamin Close { 1888692ad7caSAdrian Chadd switch (plcp) { 1889692ad7caSAdrian Chadd case 0xd: return 12; 1890692ad7caSAdrian Chadd case 0xf: return 18; 1891692ad7caSAdrian Chadd case 0x5: return 24; 1892692ad7caSAdrian Chadd case 0x7: return 36; 1893692ad7caSAdrian Chadd case 0x9: return 48; 1894692ad7caSAdrian Chadd case 0xb: return 72; 1895692ad7caSAdrian Chadd case 0x1: return 96; 1896692ad7caSAdrian Chadd case 0x3: return 108; 1897692ad7caSAdrian Chadd case 10: return 2; 1898692ad7caSAdrian Chadd case 20: return 4; 1899692ad7caSAdrian Chadd case 55: return 11; 1900692ad7caSAdrian Chadd case 110: return 22; 1901692ad7caSAdrian Chadd default: return 0; 19026607310bSBenjamin Close } 1903692ad7caSAdrian Chadd } 1904692ad7caSAdrian Chadd 1905692ad7caSAdrian Chadd /* Quickly determine if a given rate is CCK or OFDM. */ 1906692ad7caSAdrian Chadd #define WPI_RATE_IS_OFDM(rate) ((rate) >= 12 && (rate) != 22) 19076607310bSBenjamin Close 19086607310bSBenjamin Close static void 1909692ad7caSAdrian Chadd wpi_rx_done(struct wpi_softc *sc, struct wpi_rx_desc *desc, 19106607310bSBenjamin Close struct wpi_rx_data *data) 19116607310bSBenjamin Close { 19127a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 19136607310bSBenjamin Close struct wpi_rx_ring *ring = &sc->rxq; 19146607310bSBenjamin Close struct wpi_rx_stat *stat; 19156607310bSBenjamin Close struct wpi_rx_head *head; 19166607310bSBenjamin Close struct wpi_rx_tail *tail; 1917692ad7caSAdrian Chadd struct ieee80211_frame *wh; 19186607310bSBenjamin Close struct ieee80211_node *ni; 1919692ad7caSAdrian Chadd struct mbuf *m, *m1; 192082f1b132SAndrew Thompson bus_addr_t paddr; 1921692ad7caSAdrian Chadd uint32_t flags; 1922692ad7caSAdrian Chadd uint16_t len; 192382f1b132SAndrew Thompson int error; 19246607310bSBenjamin Close 19256607310bSBenjamin Close stat = (struct wpi_rx_stat *)(desc + 1); 19266607310bSBenjamin Close 1927859f6ddcSAdrian Chadd if (__predict_false(stat->len > WPI_STAT_MAXLEN)) { 1928692ad7caSAdrian Chadd device_printf(sc->sc_dev, "invalid RX statistic header\n"); 1929fae61c69SAdrian Chadd goto fail1; 19306607310bSBenjamin Close } 19316607310bSBenjamin Close 1932a71ad787SBernhard Schmidt bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_POSTREAD); 19336607310bSBenjamin Close head = (struct wpi_rx_head *)((caddr_t)(stat + 1) + stat->len); 1934692ad7caSAdrian Chadd len = le16toh(head->len); 1935692ad7caSAdrian Chadd tail = (struct wpi_rx_tail *)((caddr_t)(head + 1) + len); 1936692ad7caSAdrian Chadd flags = le32toh(tail->flags); 19376607310bSBenjamin Close 1938692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RECV, "%s: idx %d len %d stat len %u rssi %d" 1939692ad7caSAdrian Chadd " rate %x chan %d tstamp %ju\n", __func__, ring->cur, 1940692ad7caSAdrian Chadd le32toh(desc->len), len, (int8_t)stat->rssi, 1941692ad7caSAdrian Chadd head->plcp, head->chan, (uintmax_t)le64toh(tail->tstamp)); 19426607310bSBenjamin Close 1943692ad7caSAdrian Chadd /* Discard frames with a bad FCS early. */ 1944692ad7caSAdrian Chadd if ((flags & WPI_RX_NOERROR) != WPI_RX_NOERROR) { 1945692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RECV, "%s: RX flags error %x\n", 1946692ad7caSAdrian Chadd __func__, flags); 1947fae61c69SAdrian Chadd goto fail1; 1948fcec677dSJuli Mallett } 1949692ad7caSAdrian Chadd /* Discard frames that are too short. */ 19503077c104SAdrian Chadd if (len < sizeof (struct ieee80211_frame_ack)) { 1951692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RECV, "%s: frame too short: %d\n", 1952692ad7caSAdrian Chadd __func__, len); 1953fae61c69SAdrian Chadd goto fail1; 1954fcec677dSJuli Mallett } 1955fcec677dSJuli Mallett 1956692ad7caSAdrian Chadd m1 = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); 1957859f6ddcSAdrian Chadd if (__predict_false(m1 == NULL)) { 1958692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_ANY, "%s: no mbuf to restock ring\n", 1959692ad7caSAdrian Chadd __func__); 1960fae61c69SAdrian Chadd goto fail1; 196182f1b132SAndrew Thompson } 1962a71ad787SBernhard Schmidt bus_dmamap_unload(ring->data_dmat, data->map); 1963a71ad787SBernhard Schmidt 1964692ad7caSAdrian Chadd error = bus_dmamap_load(ring->data_dmat, data->map, mtod(m1, void *), 1965692ad7caSAdrian Chadd MJUMPAGESIZE, wpi_dma_map_addr, &paddr, BUS_DMA_NOWAIT); 1966859f6ddcSAdrian Chadd if (__predict_false(error != 0 && error != EFBIG)) { 196782f1b132SAndrew Thompson device_printf(sc->sc_dev, 196882f1b132SAndrew Thompson "%s: bus_dmamap_load failed, error %d\n", __func__, error); 1969692ad7caSAdrian Chadd m_freem(m1); 1970692ad7caSAdrian Chadd 1971692ad7caSAdrian Chadd /* Try to reload the old mbuf. */ 1972692ad7caSAdrian Chadd error = bus_dmamap_load(ring->data_dmat, data->map, 1973692ad7caSAdrian Chadd mtod(data->m, void *), MJUMPAGESIZE, wpi_dma_map_addr, 1974692ad7caSAdrian Chadd &paddr, BUS_DMA_NOWAIT); 1975692ad7caSAdrian Chadd if (error != 0 && error != EFBIG) { 1976692ad7caSAdrian Chadd panic("%s: could not load old RX mbuf", __func__); 1977692ad7caSAdrian Chadd } 1978692ad7caSAdrian Chadd /* Physical address may have changed. */ 1979692ad7caSAdrian Chadd ring->desc[ring->cur] = htole32(paddr); 1980692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, ring->desc_dma.map, 1981692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1982fae61c69SAdrian Chadd goto fail1; 198382f1b132SAndrew Thompson } 19846607310bSBenjamin Close 198582f1b132SAndrew Thompson m = data->m; 1986692ad7caSAdrian Chadd data->m = m1; 1987692ad7caSAdrian Chadd /* Update RX descriptor. */ 1988692ad7caSAdrian Chadd ring->desc[ring->cur] = htole32(paddr); 1989692ad7caSAdrian Chadd bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 1990692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1991692ad7caSAdrian Chadd 1992692ad7caSAdrian Chadd /* Finalize mbuf. */ 19936607310bSBenjamin Close m->m_data = (caddr_t)(head + 1); 1994692ad7caSAdrian Chadd m->m_pkthdr.len = m->m_len = len; 19956607310bSBenjamin Close 1996692ad7caSAdrian Chadd /* Grab a reference to the source node. */ 1997692ad7caSAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 1998692ad7caSAdrian Chadd 1999692ad7caSAdrian Chadd if ((wh->i_fc[1] & IEEE80211_FC1_PROTECTED) && 2000d29fcfb7SAdrian Chadd (flags & WPI_RX_CIPHER_MASK) == WPI_RX_CIPHER_CCMP) { 2001692ad7caSAdrian Chadd /* Check whether decryption was successful or not. */ 2002692ad7caSAdrian Chadd if ((flags & WPI_RX_DECRYPT_MASK) != WPI_RX_DECRYPT_OK) { 2003692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RECV, 2004692ad7caSAdrian Chadd "CCMP decryption failed 0x%x\n", flags); 2005fae61c69SAdrian Chadd goto fail2; 2006692ad7caSAdrian Chadd } 2007692ad7caSAdrian Chadd m->m_flags |= M_WEP; 2008692ad7caSAdrian Chadd } 20096607310bSBenjamin Close 20103077c104SAdrian Chadd if (len >= sizeof(struct ieee80211_frame_min)) 2011d29fcfb7SAdrian Chadd ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh); 20123077c104SAdrian Chadd else 20133077c104SAdrian Chadd ni = NULL; 20143077c104SAdrian Chadd 2015a20c9affSAdrian Chadd sc->rx_tstamp = tail->tstamp; 2016d29fcfb7SAdrian Chadd 20175463c4a4SSam Leffler if (ieee80211_radiotap_active(ic)) { 20186607310bSBenjamin Close struct wpi_rx_radiotap_header *tap = &sc->sc_rxtap; 20196607310bSBenjamin Close 20206607310bSBenjamin Close tap->wr_flags = 0; 2021692ad7caSAdrian Chadd if (head->flags & htole16(WPI_STAT_FLAG_SHPREAMBLE)) 2022692ad7caSAdrian Chadd tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTPRE; 20238e4cf38aSAdrian Chadd tap->wr_dbm_antsignal = (int8_t)(stat->rssi + WPI_RSSI_OFFSET); 20240b455e8fSAdrian Chadd tap->wr_dbm_antnoise = WPI_RSSI_OFFSET; 20256607310bSBenjamin Close tap->wr_tsft = tail->tstamp; 20266607310bSBenjamin Close tap->wr_antenna = (le16toh(head->flags) >> 4) & 0xf; 2027692ad7caSAdrian Chadd tap->wr_rate = plcp2rate(head->plcp); 20286607310bSBenjamin Close } 20296607310bSBenjamin Close 20306607310bSBenjamin Close WPI_UNLOCK(sc); 20316607310bSBenjamin Close 2032692ad7caSAdrian Chadd /* Send the frame to the 802.11 layer. */ 2033b032f27cSSam Leffler if (ni != NULL) { 20348e4cf38aSAdrian Chadd (void)ieee80211_input(ni, m, stat->rssi, WPI_RSSI_OFFSET); 2035692ad7caSAdrian Chadd /* Node is no longer needed. */ 20366607310bSBenjamin Close ieee80211_free_node(ni); 2037b032f27cSSam Leffler } else 20388e4cf38aSAdrian Chadd (void)ieee80211_input_all(ic, m, stat->rssi, WPI_RSSI_OFFSET); 2039b032f27cSSam Leffler 20406607310bSBenjamin Close WPI_LOCK(sc); 2041fae61c69SAdrian Chadd 2042fae61c69SAdrian Chadd return; 2043fae61c69SAdrian Chadd 2044d29fcfb7SAdrian Chadd fail2: m_freem(m); 2045fae61c69SAdrian Chadd 20467a79cebfSGleb Smirnoff fail1: counter_u64_add(ic->ic_ierrors, 1); 20476607310bSBenjamin Close } 20486607310bSBenjamin Close 20496607310bSBenjamin Close static void 2050692ad7caSAdrian Chadd wpi_rx_statistics(struct wpi_softc *sc, struct wpi_rx_desc *desc, 2051692ad7caSAdrian Chadd struct wpi_rx_data *data) 20526607310bSBenjamin Close { 2053692ad7caSAdrian Chadd /* Ignore */ 20546607310bSBenjamin Close } 20556607310bSBenjamin Close 20566607310bSBenjamin Close static void 2057692ad7caSAdrian Chadd wpi_tx_done(struct wpi_softc *sc, struct wpi_rx_desc *desc) 20586607310bSBenjamin Close { 2059f6930becSAndriy Voskoboinyk struct ieee80211_ratectl_tx_status *txs = &sc->sc_txs; 2060692ad7caSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[desc->qid & 0x3]; 2061692ad7caSAdrian Chadd struct wpi_tx_data *data = &ring->data[desc->idx]; 2062692ad7caSAdrian Chadd struct wpi_tx_stat *stat = (struct wpi_tx_stat *)(desc + 1); 2063692ad7caSAdrian Chadd struct mbuf *m; 2064692ad7caSAdrian Chadd struct ieee80211_node *ni; 2065b52207dbSAdrian Chadd uint32_t status = le32toh(stat->status); 2066692ad7caSAdrian Chadd 2067692ad7caSAdrian Chadd KASSERT(data->ni != NULL, ("no node")); 206839060fa9SAdrian Chadd KASSERT(data->m != NULL, ("no mbuf")); 2069692ad7caSAdrian Chadd 2070692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 2071692ad7caSAdrian Chadd 2072692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_XMIT, "%s: " 2073692ad7caSAdrian Chadd "qid %d idx %d retries %d btkillcnt %d rate %x duration %d " 207430b60481SAdrian Chadd "status %x\n", __func__, desc->qid, desc->idx, stat->ackfailcnt, 2075692ad7caSAdrian Chadd stat->btkillcnt, stat->rate, le32toh(stat->duration), status); 2076692ad7caSAdrian Chadd 2077692ad7caSAdrian Chadd /* Unmap and free mbuf. */ 2078692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_POSTWRITE); 2079692ad7caSAdrian Chadd bus_dmamap_unload(ring->data_dmat, data->map); 2080692ad7caSAdrian Chadd m = data->m, data->m = NULL; 2081692ad7caSAdrian Chadd ni = data->ni, data->ni = NULL; 2082692ad7caSAdrian Chadd 2083*3f3d4d61SAndriy Voskoboinyk /* Restore frame header. */ 2084*3f3d4d61SAndriy Voskoboinyk KASSERT(M_LEADINGSPACE(m) >= data->hdrlen, ("no frame header!")); 2085*3f3d4d61SAndriy Voskoboinyk M_PREPEND(m, data->hdrlen, M_NOWAIT); 2086*3f3d4d61SAndriy Voskoboinyk KASSERT(m != NULL, ("%s: m is NULL\n", __func__)); 2087*3f3d4d61SAndriy Voskoboinyk 2088692ad7caSAdrian Chadd /* 2089692ad7caSAdrian Chadd * Update rate control statistics for the node. 2090692ad7caSAdrian Chadd */ 2091*3f3d4d61SAndriy Voskoboinyk txs->pktlen = m->m_pkthdr.len; 2092f6930becSAndriy Voskoboinyk txs->short_retries = stat->rtsfailcnt; 2093f6930becSAndriy Voskoboinyk txs->long_retries = stat->ackfailcnt / WPI_NTRIES_DEFAULT; 2094f6930becSAndriy Voskoboinyk if (!(status & WPI_TX_STATUS_FAIL)) 2095f6930becSAndriy Voskoboinyk txs->status = IEEE80211_RATECTL_TX_SUCCESS; 2096f6930becSAndriy Voskoboinyk else { 2097f6930becSAndriy Voskoboinyk switch (status & 0xff) { 2098f6930becSAndriy Voskoboinyk case WPI_TX_STATUS_FAIL_SHORT_LIMIT: 2099f6930becSAndriy Voskoboinyk txs->status = IEEE80211_RATECTL_TX_FAIL_SHORT; 2100f6930becSAndriy Voskoboinyk break; 2101f6930becSAndriy Voskoboinyk case WPI_TX_STATUS_FAIL_LONG_LIMIT: 2102f6930becSAndriy Voskoboinyk txs->status = IEEE80211_RATECTL_TX_FAIL_LONG; 2103f6930becSAndriy Voskoboinyk break; 2104f6930becSAndriy Voskoboinyk case WPI_TX_STATUS_FAIL_LIFE_EXPIRE: 2105f6930becSAndriy Voskoboinyk txs->status = IEEE80211_RATECTL_TX_FAIL_EXPIRED; 2106f6930becSAndriy Voskoboinyk break; 2107f6930becSAndriy Voskoboinyk default: 2108f6930becSAndriy Voskoboinyk txs->status = IEEE80211_RATECTL_TX_FAIL_UNSPECIFIED; 2109f6930becSAndriy Voskoboinyk break; 2110f6930becSAndriy Voskoboinyk } 2111f6930becSAndriy Voskoboinyk } 2112692ad7caSAdrian Chadd 2113f6930becSAndriy Voskoboinyk ieee80211_ratectl_tx_complete(ni, txs); 21143d9089a6SAdrian Chadd ieee80211_tx_complete(ni, m, (status & WPI_TX_STATUS_FAIL) != 0); 2115692ad7caSAdrian Chadd 2116fc5870b4SAdrian Chadd WPI_TXQ_STATE_LOCK(sc); 2117753ca9efSAdrian Chadd if (--ring->queued > 0) 2118d74e544aSAdrian Chadd callout_reset(&sc->tx_timeout, 5*hz, wpi_tx_timeout, sc); 2119753ca9efSAdrian Chadd else 2120a6b6ca52SAdrian Chadd callout_stop(&sc->tx_timeout); 2121fc5870b4SAdrian Chadd WPI_TXQ_STATE_UNLOCK(sc); 2122692ad7caSAdrian Chadd 2123692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 2124692ad7caSAdrian Chadd } 2125692ad7caSAdrian Chadd 2126692ad7caSAdrian Chadd /* 2127692ad7caSAdrian Chadd * Process a "command done" firmware notification. This is where we wakeup 2128692ad7caSAdrian Chadd * processes waiting for a synchronous command completion. 2129692ad7caSAdrian Chadd */ 2130692ad7caSAdrian Chadd static void 2131692ad7caSAdrian Chadd wpi_cmd_done(struct wpi_softc *sc, struct wpi_rx_desc *desc) 2132692ad7caSAdrian Chadd { 21338e4cf38aSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[WPI_CMD_QUEUE_NUM]; 21346607310bSBenjamin Close struct wpi_tx_data *data; 2135c34db420SAdrian Chadd struct wpi_tx_cmd *cmd; 21366607310bSBenjamin Close 2137cec45f04SAdrian Chadd DPRINTF(sc, WPI_DEBUG_CMD, "cmd notification qid %x idx %d flags %x " 2138cec45f04SAdrian Chadd "type %s len %d\n", desc->qid, desc->idx, 21396607310bSBenjamin Close desc->flags, wpi_cmd_str(desc->type), 2140692ad7caSAdrian Chadd le32toh(desc->len)); 21416607310bSBenjamin Close 21428e4cf38aSAdrian Chadd if ((desc->qid & WPI_RX_DESC_QID_MSK) != WPI_CMD_QUEUE_NUM) 2143692ad7caSAdrian Chadd return; /* Not a command ack. */ 21446607310bSBenjamin Close 214545ac43f3SAdrian Chadd KASSERT(ring->queued == 0, ("ring->queued must be 0")); 214645ac43f3SAdrian Chadd 21476607310bSBenjamin Close data = &ring->data[desc->idx]; 2148c34db420SAdrian Chadd cmd = &ring->cmd[desc->idx]; 21496607310bSBenjamin Close 2150692ad7caSAdrian Chadd /* If the command was mapped in an mbuf, free it. */ 21516607310bSBenjamin Close if (data->m != NULL) { 2152692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 2153692ad7caSAdrian Chadd BUS_DMASYNC_POSTWRITE); 21546607310bSBenjamin Close bus_dmamap_unload(ring->data_dmat, data->map); 21556607310bSBenjamin Close m_freem(data->m); 21566607310bSBenjamin Close data->m = NULL; 21576607310bSBenjamin Close } 21586607310bSBenjamin Close 2159c34db420SAdrian Chadd wakeup(cmd); 21605cacb17fSAdrian Chadd 21615cacb17fSAdrian Chadd if (desc->type == WPI_CMD_SET_POWER_MODE) { 2162c34db420SAdrian Chadd struct wpi_pmgt_cmd *pcmd = (struct wpi_pmgt_cmd *)cmd->data; 2163c34db420SAdrian Chadd 2164c34db420SAdrian Chadd bus_dmamap_sync(ring->data_dmat, ring->cmd_dma.map, 2165c34db420SAdrian Chadd BUS_DMASYNC_POSTREAD); 2166c34db420SAdrian Chadd 21675cacb17fSAdrian Chadd WPI_TXQ_LOCK(sc); 2168c34db420SAdrian Chadd if (le16toh(pcmd->flags) & WPI_PS_ALLOW_SLEEP) { 21695cacb17fSAdrian Chadd sc->sc_update_rx_ring = wpi_update_rx_ring_ps; 21705cacb17fSAdrian Chadd sc->sc_update_tx_ring = wpi_update_tx_ring_ps; 21715cacb17fSAdrian Chadd } else { 21725cacb17fSAdrian Chadd sc->sc_update_rx_ring = wpi_update_rx_ring; 21735cacb17fSAdrian Chadd sc->sc_update_tx_ring = wpi_update_tx_ring; 21745cacb17fSAdrian Chadd } 21755cacb17fSAdrian Chadd WPI_TXQ_UNLOCK(sc); 21765cacb17fSAdrian Chadd } 21776607310bSBenjamin Close } 21786607310bSBenjamin Close 21796607310bSBenjamin Close static void 21806607310bSBenjamin Close wpi_notif_intr(struct wpi_softc *sc) 21816607310bSBenjamin Close { 21827a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 2183692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 2184b52207dbSAdrian Chadd uint32_t hw; 21856607310bSBenjamin Close 2186f015cb78SBernhard Schmidt bus_dmamap_sync(sc->shared_dma.tag, sc->shared_dma.map, 2187f015cb78SBernhard Schmidt BUS_DMASYNC_POSTREAD); 2188f015cb78SBernhard Schmidt 2189e43b274aSAdrian Chadd hw = le32toh(sc->shared->next) & 0xfff; 2190692ad7caSAdrian Chadd hw = (hw == 0) ? WPI_RX_RING_COUNT - 1 : hw - 1; 2191692ad7caSAdrian Chadd 2192fae61c69SAdrian Chadd while (sc->rxq.cur != hw) { 2193692ad7caSAdrian Chadd sc->rxq.cur = (sc->rxq.cur + 1) % WPI_RX_RING_COUNT; 2194692ad7caSAdrian Chadd 2195692ad7caSAdrian Chadd struct wpi_rx_data *data = &sc->rxq.data[sc->rxq.cur]; 2196692ad7caSAdrian Chadd struct wpi_rx_desc *desc; 2197f015cb78SBernhard Schmidt 2198f015cb78SBernhard Schmidt bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2199f015cb78SBernhard Schmidt BUS_DMASYNC_POSTREAD); 2200692ad7caSAdrian Chadd desc = mtod(data->m, struct wpi_rx_desc *); 22016607310bSBenjamin Close 2202692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_NOTIFY, 2203692ad7caSAdrian Chadd "%s: cur=%d; qid %x idx %d flags %x type %d(%s) len %d\n", 2204692ad7caSAdrian Chadd __func__, sc->rxq.cur, desc->qid, desc->idx, desc->flags, 2205692ad7caSAdrian Chadd desc->type, wpi_cmd_str(desc->type), le32toh(desc->len)); 22066607310bSBenjamin Close 22078e4cf38aSAdrian Chadd if (!(desc->qid & WPI_UNSOLICITED_RX_NOTIF)) { 22088e4cf38aSAdrian Chadd /* Reply to a command. */ 2209692ad7caSAdrian Chadd wpi_cmd_done(sc, desc); 22108e4cf38aSAdrian Chadd } 22116607310bSBenjamin Close 22126607310bSBenjamin Close switch (desc->type) { 22136607310bSBenjamin Close case WPI_RX_DONE: 2214692ad7caSAdrian Chadd /* An 802.11 frame has been received. */ 2215692ad7caSAdrian Chadd wpi_rx_done(sc, desc, data); 221671258eb2SAdrian Chadd 2217859f6ddcSAdrian Chadd if (__predict_false(sc->sc_running == 0)) { 221871258eb2SAdrian Chadd /* wpi_stop() was called. */ 221971258eb2SAdrian Chadd return; 222071258eb2SAdrian Chadd } 222171258eb2SAdrian Chadd 22226607310bSBenjamin Close break; 22236607310bSBenjamin Close 22246607310bSBenjamin Close case WPI_TX_DONE: 2225692ad7caSAdrian Chadd /* An 802.11 frame has been transmitted. */ 2226692ad7caSAdrian Chadd wpi_tx_done(sc, desc); 22276607310bSBenjamin Close break; 22286607310bSBenjamin Close 2229692ad7caSAdrian Chadd case WPI_RX_STATISTICS: 2230692ad7caSAdrian Chadd case WPI_BEACON_STATISTICS: 2231692ad7caSAdrian Chadd wpi_rx_statistics(sc, desc, data); 2232692ad7caSAdrian Chadd break; 2233692ad7caSAdrian Chadd 2234692ad7caSAdrian Chadd case WPI_BEACON_MISSED: 2235692ad7caSAdrian Chadd { 2236692ad7caSAdrian Chadd struct wpi_beacon_missed *miss = 2237692ad7caSAdrian Chadd (struct wpi_beacon_missed *)(desc + 1); 22385c015919SAdrian Chadd uint32_t expected, misses, received, threshold; 2239692ad7caSAdrian Chadd 2240692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2241692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 2242b4324a50SAdrian Chadd 2243692ad7caSAdrian Chadd misses = le32toh(miss->consecutive); 2244b4324a50SAdrian Chadd expected = le32toh(miss->expected); 2245b4324a50SAdrian Chadd received = le32toh(miss->received); 22465c015919SAdrian Chadd threshold = MAX(2, vap->iv_bmissthreshold); 2247692ad7caSAdrian Chadd 22483e54d9fdSAdrian Chadd DPRINTF(sc, WPI_DEBUG_BMISS, 2249cf990903SAdrian Chadd "%s: beacons missed %u(%u) (received %u/%u)\n", 2250cf990903SAdrian Chadd __func__, misses, le32toh(miss->total), received, 2251cf990903SAdrian Chadd expected); 2252692ad7caSAdrian Chadd 22536f506674SAdrian Chadd if (misses >= threshold || 22546f506674SAdrian Chadd (received == 0 && expected >= threshold)) { 22556f506674SAdrian Chadd WPI_RXON_LOCK(sc); 22566f506674SAdrian Chadd if (callout_pending(&sc->scan_timeout)) { 22576f506674SAdrian Chadd wpi_cmd(sc, WPI_CMD_SCAN_ABORT, NULL, 22586f506674SAdrian Chadd 0, 1); 22596f506674SAdrian Chadd } 22606f506674SAdrian Chadd WPI_RXON_UNLOCK(sc); 2261692ad7caSAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN && 22626f506674SAdrian Chadd (ic->ic_flags & IEEE80211_F_SCAN) == 0) 2263692ad7caSAdrian Chadd ieee80211_beacon_miss(ic); 22646f506674SAdrian Chadd } 2265fd06b537SAdrian Chadd 2266692ad7caSAdrian Chadd break; 2267692ad7caSAdrian Chadd } 22686ddc7d4dSAdrian Chadd #ifdef WPI_DEBUG 22696ddc7d4dSAdrian Chadd case WPI_BEACON_SENT: 22706ddc7d4dSAdrian Chadd { 22716ddc7d4dSAdrian Chadd struct wpi_tx_stat *stat = 22726ddc7d4dSAdrian Chadd (struct wpi_tx_stat *)(desc + 1); 22736ddc7d4dSAdrian Chadd uint64_t *tsf = (uint64_t *)(stat + 1); 22746ddc7d4dSAdrian Chadd uint32_t *mode = (uint32_t *)(tsf + 1); 22756ddc7d4dSAdrian Chadd 22766ddc7d4dSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 22776ddc7d4dSAdrian Chadd BUS_DMASYNC_POSTREAD); 22786ddc7d4dSAdrian Chadd 22796ddc7d4dSAdrian Chadd DPRINTF(sc, WPI_DEBUG_BEACON, 22806ddc7d4dSAdrian Chadd "beacon sent: rts %u, ack %u, btkill %u, rate %u, " 22816ddc7d4dSAdrian Chadd "duration %u, status %x, tsf %ju, mode %x\n", 22826ddc7d4dSAdrian Chadd stat->rtsfailcnt, stat->ackfailcnt, 22836ddc7d4dSAdrian Chadd stat->btkillcnt, stat->rate, le32toh(stat->duration), 22844c09e592SAdrian Chadd le32toh(stat->status), le64toh(*tsf), 22854c09e592SAdrian Chadd le32toh(*mode)); 22866ddc7d4dSAdrian Chadd 22876ddc7d4dSAdrian Chadd break; 22886ddc7d4dSAdrian Chadd } 22896ddc7d4dSAdrian Chadd #endif 22906607310bSBenjamin Close case WPI_UC_READY: 22916607310bSBenjamin Close { 22926607310bSBenjamin Close struct wpi_ucode_info *uc = 22936607310bSBenjamin Close (struct wpi_ucode_info *)(desc + 1); 22946607310bSBenjamin Close 2295692ad7caSAdrian Chadd /* The microcontroller is ready. */ 2296692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2297692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 2298692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RESET, 2299692ad7caSAdrian Chadd "microcode alive notification version=%d.%d " 2300692ad7caSAdrian Chadd "subtype=%x alive=%x\n", uc->major, uc->minor, 2301692ad7caSAdrian Chadd uc->subtype, le32toh(uc->valid)); 23026607310bSBenjamin Close 23036607310bSBenjamin Close if (le32toh(uc->valid) != 1) { 23046607310bSBenjamin Close device_printf(sc->sc_dev, 23056607310bSBenjamin Close "microcontroller initialization failed\n"); 23066607310bSBenjamin Close wpi_stop_locked(sc); 23077a79cebfSGleb Smirnoff return; 23086607310bSBenjamin Close } 2309692ad7caSAdrian Chadd /* Save the address of the error log in SRAM. */ 2310692ad7caSAdrian Chadd sc->errptr = le32toh(uc->errptr); 23116607310bSBenjamin Close break; 23126607310bSBenjamin Close } 23136607310bSBenjamin Close case WPI_STATE_CHANGED: 23146607310bSBenjamin Close { 2315692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2316692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 2317692ad7caSAdrian Chadd 23186607310bSBenjamin Close uint32_t *status = (uint32_t *)(desc + 1); 2319fae61c69SAdrian Chadd 2320692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, "state changed to %x\n", 2321692ad7caSAdrian Chadd le32toh(*status)); 2322fae61c69SAdrian Chadd 23236607310bSBenjamin Close if (le32toh(*status) & 1) { 23247964dd56SAdrian Chadd WPI_NT_LOCK(sc); 2325eca2eb39SAdrian Chadd wpi_clear_node_table(sc); 23267964dd56SAdrian Chadd WPI_NT_UNLOCK(sc); 2327abd89aa2SAndriy Voskoboinyk ieee80211_runtask(ic, 2328b3cd88daSAdrian Chadd &sc->sc_radiooff_task); 2329692ad7caSAdrian Chadd return; 23306607310bSBenjamin Close } 23316607310bSBenjamin Close break; 23326607310bSBenjamin Close } 2333cbaa7080SAdrian Chadd #ifdef WPI_DEBUG 23346607310bSBenjamin Close case WPI_START_SCAN: 23356607310bSBenjamin Close { 2336692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2337692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 2338cbaa7080SAdrian Chadd 23396607310bSBenjamin Close struct wpi_start_scan *scan = 23406607310bSBenjamin Close (struct wpi_start_scan *)(desc + 1); 2341692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_SCAN, 2342692ad7caSAdrian Chadd "%s: scanning channel %d status %x\n", 2343692ad7caSAdrian Chadd __func__, scan->chan, le32toh(scan->status)); 2344cbaa7080SAdrian Chadd 23456607310bSBenjamin Close break; 23466607310bSBenjamin Close } 2347cbaa7080SAdrian Chadd #endif 23486607310bSBenjamin Close case WPI_STOP_SCAN: 23496607310bSBenjamin Close { 2350692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2351692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 23526f506674SAdrian Chadd 23536607310bSBenjamin Close struct wpi_stop_scan *scan = 23546607310bSBenjamin Close (struct wpi_stop_scan *)(desc + 1); 23556f506674SAdrian Chadd 2356692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_SCAN, 2357692ad7caSAdrian Chadd "scan finished nchan=%d status=%d chan=%d\n", 2358692ad7caSAdrian Chadd scan->nchan, scan->status, scan->chan); 23596f506674SAdrian Chadd 2360446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 23610bc39fc6SAdrian Chadd callout_stop(&sc->scan_timeout); 2362446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 23636f506674SAdrian Chadd if (scan->status == WPI_SCAN_ABORTED) 23646f506674SAdrian Chadd ieee80211_cancel_scan(vap); 23656f506674SAdrian Chadd else 2366b032f27cSSam Leffler ieee80211_scan_next(vap); 23676607310bSBenjamin Close break; 23686607310bSBenjamin Close } 2369692ad7caSAdrian Chadd } 2370692ad7caSAdrian Chadd 2371a5403e31SAdrian Chadd if (sc->rxq.cur % 8 == 0) { 2372692ad7caSAdrian Chadd /* Tell the firmware what we have processed. */ 23735cacb17fSAdrian Chadd sc->sc_update_rx_ring(sc); 2374692ad7caSAdrian Chadd } 2375a5403e31SAdrian Chadd } 2376a5403e31SAdrian Chadd } 2377692ad7caSAdrian Chadd 2378692ad7caSAdrian Chadd /* 2379692ad7caSAdrian Chadd * Process an INT_WAKEUP interrupt raised when the microcontroller wakes up 2380692ad7caSAdrian Chadd * from power-down sleep mode. 2381692ad7caSAdrian Chadd */ 2382692ad7caSAdrian Chadd static void 2383692ad7caSAdrian Chadd wpi_wakeup_intr(struct wpi_softc *sc) 2384a7099588SBenjamin Close { 2385692ad7caSAdrian Chadd int qid; 2386a7099588SBenjamin Close 2387692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_PWRSAVE, 2388692ad7caSAdrian Chadd "%s: ucode wakeup from power-down sleep\n", __func__); 2389692ad7caSAdrian Chadd 2390692ad7caSAdrian Chadd /* Wakeup RX and TX rings. */ 2391692ad7caSAdrian Chadd if (sc->rxq.update) { 2392692ad7caSAdrian Chadd sc->rxq.update = 0; 2393fae61c69SAdrian Chadd wpi_update_rx_ring(sc); 2394a7099588SBenjamin Close } 239563f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 2396ebf62e08SAdrian Chadd for (qid = 0; qid < WPI_DRV_NTXQUEUES; qid++) { 2397692ad7caSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[qid]; 2398692ad7caSAdrian Chadd 2399692ad7caSAdrian Chadd if (ring->update) { 2400692ad7caSAdrian Chadd ring->update = 0; 2401fae61c69SAdrian Chadd wpi_update_tx_ring(sc, ring); 2402a7099588SBenjamin Close } 24036607310bSBenjamin Close } 2404692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 24055cacb17fSAdrian Chadd WPI_TXQ_UNLOCK(sc); 24066607310bSBenjamin Close } 24076607310bSBenjamin Close 2408692ad7caSAdrian Chadd /* 2409a6df6cfeSAdrian Chadd * This function prints firmware registers 2410a6df6cfeSAdrian Chadd */ 2411a6df6cfeSAdrian Chadd #ifdef WPI_DEBUG 2412a6df6cfeSAdrian Chadd static void 2413a6df6cfeSAdrian Chadd wpi_debug_registers(struct wpi_softc *sc) 2414a6df6cfeSAdrian Chadd { 2415e43b274aSAdrian Chadd size_t i; 2416a6df6cfeSAdrian Chadd static const uint32_t csr_tbl[] = { 2417a6df6cfeSAdrian Chadd WPI_HW_IF_CONFIG, 2418a6df6cfeSAdrian Chadd WPI_INT, 2419a6df6cfeSAdrian Chadd WPI_INT_MASK, 2420a6df6cfeSAdrian Chadd WPI_FH_INT, 2421a6df6cfeSAdrian Chadd WPI_GPIO_IN, 2422a6df6cfeSAdrian Chadd WPI_RESET, 2423a6df6cfeSAdrian Chadd WPI_GP_CNTRL, 2424a6df6cfeSAdrian Chadd WPI_EEPROM, 2425a6df6cfeSAdrian Chadd WPI_EEPROM_GP, 2426a6df6cfeSAdrian Chadd WPI_GIO, 2427a6df6cfeSAdrian Chadd WPI_UCODE_GP1, 2428a6df6cfeSAdrian Chadd WPI_UCODE_GP2, 2429a6df6cfeSAdrian Chadd WPI_GIO_CHICKEN, 2430a6df6cfeSAdrian Chadd WPI_ANA_PLL, 2431a6df6cfeSAdrian Chadd WPI_DBG_HPET_MEM, 2432a6df6cfeSAdrian Chadd }; 2433a6df6cfeSAdrian Chadd static const uint32_t prph_tbl[] = { 2434a6df6cfeSAdrian Chadd WPI_APMG_CLK_CTRL, 2435a6df6cfeSAdrian Chadd WPI_APMG_PS, 2436a6df6cfeSAdrian Chadd WPI_APMG_PCI_STT, 2437a6df6cfeSAdrian Chadd WPI_APMG_RFKILL, 2438a6df6cfeSAdrian Chadd }; 2439a6df6cfeSAdrian Chadd 2440a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER,"%s","\n"); 2441a6df6cfeSAdrian Chadd 244212e0ff3bSAdrian Chadd for (i = 0; i < nitems(csr_tbl); i++) { 2443a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, " %-18s: 0x%08x ", 2444a6df6cfeSAdrian Chadd wpi_get_csr_string(csr_tbl[i]), WPI_READ(sc, csr_tbl[i])); 2445a6df6cfeSAdrian Chadd 2446a6df6cfeSAdrian Chadd if ((i + 1) % 2 == 0) 2447a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, "\n"); 2448a6df6cfeSAdrian Chadd } 2449a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, "\n\n"); 2450a6df6cfeSAdrian Chadd 2451a6df6cfeSAdrian Chadd if (wpi_nic_lock(sc) == 0) { 245212e0ff3bSAdrian Chadd for (i = 0; i < nitems(prph_tbl); i++) { 2453a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, " %-18s: 0x%08x ", 2454a6df6cfeSAdrian Chadd wpi_get_prph_string(prph_tbl[i]), 2455a6df6cfeSAdrian Chadd wpi_prph_read(sc, prph_tbl[i])); 2456a6df6cfeSAdrian Chadd 2457a6df6cfeSAdrian Chadd if ((i + 1) % 2 == 0) 2458a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, "\n"); 2459a6df6cfeSAdrian Chadd } 2460a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, "\n"); 2461a6df6cfeSAdrian Chadd wpi_nic_unlock(sc); 2462a6df6cfeSAdrian Chadd } else { 2463a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, 2464a6df6cfeSAdrian Chadd "Cannot access internal registers.\n"); 2465a6df6cfeSAdrian Chadd } 2466a6df6cfeSAdrian Chadd } 2467a6df6cfeSAdrian Chadd #endif 2468a6df6cfeSAdrian Chadd 2469a6df6cfeSAdrian Chadd /* 2470692ad7caSAdrian Chadd * Dump the error log of the firmware when a firmware panic occurs. Although 2471692ad7caSAdrian Chadd * we can't debug the firmware because it is neither open source nor free, it 2472692ad7caSAdrian Chadd * can help us to identify certain classes of problems. 2473692ad7caSAdrian Chadd */ 2474692ad7caSAdrian Chadd static void 2475692ad7caSAdrian Chadd wpi_fatal_intr(struct wpi_softc *sc) 2476692ad7caSAdrian Chadd { 2477692ad7caSAdrian Chadd struct wpi_fw_dump dump; 2478692ad7caSAdrian Chadd uint32_t i, offset, count; 2479692ad7caSAdrian Chadd 2480692ad7caSAdrian Chadd /* Check that the error log address is valid. */ 2481692ad7caSAdrian Chadd if (sc->errptr < WPI_FW_DATA_BASE || 2482692ad7caSAdrian Chadd sc->errptr + sizeof (dump) > 2483692ad7caSAdrian Chadd WPI_FW_DATA_BASE + WPI_FW_DATA_MAXSZ) { 2484692ad7caSAdrian Chadd printf("%s: bad firmware error log address 0x%08x\n", __func__, 2485692ad7caSAdrian Chadd sc->errptr); 2486692ad7caSAdrian Chadd return; 2487692ad7caSAdrian Chadd } 2488692ad7caSAdrian Chadd if (wpi_nic_lock(sc) != 0) { 2489692ad7caSAdrian Chadd printf("%s: could not read firmware error log\n", __func__); 2490692ad7caSAdrian Chadd return; 2491692ad7caSAdrian Chadd } 2492692ad7caSAdrian Chadd /* Read number of entries in the log. */ 2493692ad7caSAdrian Chadd count = wpi_mem_read(sc, sc->errptr); 2494692ad7caSAdrian Chadd if (count == 0 || count * sizeof (dump) > WPI_FW_DATA_MAXSZ) { 2495692ad7caSAdrian Chadd printf("%s: invalid count field (count = %u)\n", __func__, 2496692ad7caSAdrian Chadd count); 2497692ad7caSAdrian Chadd wpi_nic_unlock(sc); 2498692ad7caSAdrian Chadd return; 2499692ad7caSAdrian Chadd } 2500692ad7caSAdrian Chadd /* Skip "count" field. */ 2501692ad7caSAdrian Chadd offset = sc->errptr + sizeof (uint32_t); 2502692ad7caSAdrian Chadd printf("firmware error log (count = %u):\n", count); 2503692ad7caSAdrian Chadd for (i = 0; i < count; i++) { 2504692ad7caSAdrian Chadd wpi_mem_read_region_4(sc, offset, (uint32_t *)&dump, 2505692ad7caSAdrian Chadd sizeof (dump) / sizeof (uint32_t)); 2506692ad7caSAdrian Chadd 2507692ad7caSAdrian Chadd printf(" error type = \"%s\" (0x%08X)\n", 250812e0ff3bSAdrian Chadd (dump.desc < nitems(wpi_fw_errmsg)) ? 2509692ad7caSAdrian Chadd wpi_fw_errmsg[dump.desc] : "UNKNOWN", 2510692ad7caSAdrian Chadd dump.desc); 2511692ad7caSAdrian Chadd printf(" error data = 0x%08X\n", 2512692ad7caSAdrian Chadd dump.data); 2513692ad7caSAdrian Chadd printf(" branch link = 0x%08X%08X\n", 2514692ad7caSAdrian Chadd dump.blink[0], dump.blink[1]); 2515692ad7caSAdrian Chadd printf(" interrupt link = 0x%08X%08X\n", 2516692ad7caSAdrian Chadd dump.ilink[0], dump.ilink[1]); 2517692ad7caSAdrian Chadd printf(" time = %u\n", dump.time); 2518692ad7caSAdrian Chadd 2519692ad7caSAdrian Chadd offset += sizeof (dump); 2520692ad7caSAdrian Chadd } 2521692ad7caSAdrian Chadd wpi_nic_unlock(sc); 2522692ad7caSAdrian Chadd /* Dump driver status (TX and RX rings) while we're here. */ 2523692ad7caSAdrian Chadd printf("driver status:\n"); 252463f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 2525ebf62e08SAdrian Chadd for (i = 0; i < WPI_DRV_NTXQUEUES; i++) { 2526692ad7caSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[i]; 2527692ad7caSAdrian Chadd printf(" tx ring %2d: qid=%-2d cur=%-3d queued=%-3d\n", 2528692ad7caSAdrian Chadd i, ring->qid, ring->cur, ring->queued); 2529692ad7caSAdrian Chadd } 253063f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 2531692ad7caSAdrian Chadd printf(" rx ring: cur=%d\n", sc->rxq.cur); 25326607310bSBenjamin Close } 25336607310bSBenjamin Close 25346607310bSBenjamin Close static void 25356607310bSBenjamin Close wpi_intr(void *arg) 25366607310bSBenjamin Close { 25376607310bSBenjamin Close struct wpi_softc *sc = arg; 2538692ad7caSAdrian Chadd uint32_t r1, r2; 25396607310bSBenjamin Close 25406607310bSBenjamin Close WPI_LOCK(sc); 25416607310bSBenjamin Close 2542692ad7caSAdrian Chadd /* Disable interrupts. */ 2543692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT_MASK, 0); 2544692ad7caSAdrian Chadd 2545692ad7caSAdrian Chadd r1 = WPI_READ(sc, WPI_INT); 2546692ad7caSAdrian Chadd 2547859f6ddcSAdrian Chadd if (__predict_false(r1 == 0xffffffff || 2548859f6ddcSAdrian Chadd (r1 & 0xfffffff0) == 0xa5a5a5a0)) 25497f1299c5SAdrian Chadd goto end; /* Hardware gone! */ 25506607310bSBenjamin Close 2551692ad7caSAdrian Chadd r2 = WPI_READ(sc, WPI_FH_INT); 25526607310bSBenjamin Close 2553692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_INTR, "%s: reg1=0x%08x reg2=0x%08x\n", __func__, 2554692ad7caSAdrian Chadd r1, r2); 2555692ad7caSAdrian Chadd 2556692ad7caSAdrian Chadd if (r1 == 0 && r2 == 0) 2557692ad7caSAdrian Chadd goto done; /* Interrupt not for us. */ 2558692ad7caSAdrian Chadd 2559692ad7caSAdrian Chadd /* Acknowledge interrupts. */ 2560692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, r1); 2561692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_INT, r2); 2562692ad7caSAdrian Chadd 2563859f6ddcSAdrian Chadd if (__predict_false(r1 & (WPI_INT_SW_ERR | WPI_INT_HW_ERR))) { 2564abd89aa2SAndriy Voskoboinyk struct ieee80211com *ic = &sc->sc_ic; 2565abd89aa2SAndriy Voskoboinyk 25666607310bSBenjamin Close device_printf(sc->sc_dev, "fatal firmware error\n"); 2567a6df6cfeSAdrian Chadd #ifdef WPI_DEBUG 2568a6df6cfeSAdrian Chadd wpi_debug_registers(sc); 2569a6df6cfeSAdrian Chadd #endif 2570692ad7caSAdrian Chadd wpi_fatal_intr(sc); 2571692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_HW, 2572692ad7caSAdrian Chadd "(%s)\n", (r1 & WPI_INT_SW_ERR) ? "(Software Error)" : 2573692ad7caSAdrian Chadd "(Hardware Error)"); 2574abd89aa2SAndriy Voskoboinyk ieee80211_restart_all(ic); 25757f1299c5SAdrian Chadd goto end; 25766607310bSBenjamin Close } 25776607310bSBenjamin Close 2578692ad7caSAdrian Chadd if ((r1 & (WPI_INT_FH_RX | WPI_INT_SW_RX)) || 2579692ad7caSAdrian Chadd (r2 & WPI_FH_INT_RX)) 25806607310bSBenjamin Close wpi_notif_intr(sc); 25816607310bSBenjamin Close 2582692ad7caSAdrian Chadd if (r1 & WPI_INT_ALIVE) 2583692ad7caSAdrian Chadd wakeup(sc); /* Firmware is alive. */ 25846607310bSBenjamin Close 2585692ad7caSAdrian Chadd if (r1 & WPI_INT_WAKEUP) 2586692ad7caSAdrian Chadd wpi_wakeup_intr(sc); 2587692ad7caSAdrian Chadd 2588692ad7caSAdrian Chadd done: 2589692ad7caSAdrian Chadd /* Re-enable interrupts. */ 2590859f6ddcSAdrian Chadd if (__predict_true(sc->sc_running)) 2591692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT_MASK, WPI_INT_MASK_DEF); 25926607310bSBenjamin Close 25937f1299c5SAdrian Chadd end: WPI_UNLOCK(sc); 25946607310bSBenjamin Close } 25956607310bSBenjamin Close 2596940aa808SAdrian Chadd static void 2597940aa808SAdrian Chadd wpi_free_txfrags(struct wpi_softc *sc, uint16_t ac) 2598940aa808SAdrian Chadd { 2599940aa808SAdrian Chadd struct wpi_tx_ring *ring; 2600940aa808SAdrian Chadd struct wpi_tx_data *data; 2601940aa808SAdrian Chadd uint8_t cur; 2602940aa808SAdrian Chadd 2603940aa808SAdrian Chadd WPI_TXQ_LOCK(sc); 2604940aa808SAdrian Chadd ring = &sc->txq[ac]; 2605940aa808SAdrian Chadd 2606940aa808SAdrian Chadd while (ring->pending != 0) { 2607940aa808SAdrian Chadd ring->pending--; 2608940aa808SAdrian Chadd cur = (ring->cur + ring->pending) % WPI_TX_RING_COUNT; 2609940aa808SAdrian Chadd data = &ring->data[cur]; 2610940aa808SAdrian Chadd 2611940aa808SAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 2612940aa808SAdrian Chadd BUS_DMASYNC_POSTWRITE); 2613940aa808SAdrian Chadd bus_dmamap_unload(ring->data_dmat, data->map); 2614940aa808SAdrian Chadd m_freem(data->m); 2615940aa808SAdrian Chadd data->m = NULL; 2616940aa808SAdrian Chadd 2617940aa808SAdrian Chadd ieee80211_node_decref(data->ni); 2618940aa808SAdrian Chadd data->ni = NULL; 2619940aa808SAdrian Chadd } 2620940aa808SAdrian Chadd 2621940aa808SAdrian Chadd WPI_TXQ_UNLOCK(sc); 2622940aa808SAdrian Chadd } 2623940aa808SAdrian Chadd 26246607310bSBenjamin Close static int 2625692ad7caSAdrian Chadd wpi_cmd2(struct wpi_softc *sc, struct wpi_buf *buf) 26266607310bSBenjamin Close { 26276607310bSBenjamin Close struct ieee80211_frame *wh; 2628692ad7caSAdrian Chadd struct wpi_tx_cmd *cmd; 2629692ad7caSAdrian Chadd struct wpi_tx_data *data; 2630692ad7caSAdrian Chadd struct wpi_tx_desc *desc; 2631692ad7caSAdrian Chadd struct wpi_tx_ring *ring; 2632692ad7caSAdrian Chadd struct mbuf *m1; 2633692ad7caSAdrian Chadd bus_dma_segment_t *seg, segs[WPI_MAX_SCATTER]; 2634940aa808SAdrian Chadd uint8_t cur, pad; 2635525a3d47SAdrian Chadd uint16_t hdrlen; 2636940aa808SAdrian Chadd int error, i, nsegs, totlen, frag; 26376607310bSBenjamin Close 263863f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 263963f57699SAdrian Chadd 2640565248e2SAdrian Chadd KASSERT(buf->size <= sizeof(buf->data), ("buffer overflow")); 2641565248e2SAdrian Chadd 2642692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 2643692ad7caSAdrian Chadd 2644859f6ddcSAdrian Chadd if (__predict_false(sc->sc_running == 0)) { 264563f57699SAdrian Chadd /* wpi_stop() was called */ 264663f57699SAdrian Chadd error = ENETDOWN; 2647823e17dbSAdrian Chadd goto end; 264863f57699SAdrian Chadd } 264963f57699SAdrian Chadd 2650692ad7caSAdrian Chadd wh = mtod(buf->m, struct ieee80211_frame *); 26518a28176aSAdrian Chadd hdrlen = ieee80211_anyhdrsize(wh); 2652692ad7caSAdrian Chadd totlen = buf->m->m_pkthdr.len; 2653940aa808SAdrian Chadd frag = ((buf->m->m_flags & (M_FRAG | M_LASTFRAG)) == M_FRAG); 2654692ad7caSAdrian Chadd 2655fbcf1662SAdrian Chadd if (__predict_false(totlen < sizeof(struct ieee80211_frame_min))) { 2656fbcf1662SAdrian Chadd error = EINVAL; 2657823e17dbSAdrian Chadd goto end; 2658fbcf1662SAdrian Chadd } 2659fbcf1662SAdrian Chadd 26608a28176aSAdrian Chadd if (hdrlen & 3) { 26618a28176aSAdrian Chadd /* First segment length must be a multiple of 4. */ 26628a28176aSAdrian Chadd pad = 4 - (hdrlen & 3); 26638a28176aSAdrian Chadd } else 26648a28176aSAdrian Chadd pad = 0; 26658a28176aSAdrian Chadd 2666692ad7caSAdrian Chadd ring = &sc->txq[buf->ac]; 2667940aa808SAdrian Chadd cur = (ring->cur + ring->pending) % WPI_TX_RING_COUNT; 2668940aa808SAdrian Chadd desc = &ring->desc[cur]; 2669940aa808SAdrian Chadd data = &ring->data[cur]; 26706607310bSBenjamin Close 2671692ad7caSAdrian Chadd /* Prepare TX firmware command. */ 2672940aa808SAdrian Chadd cmd = &ring->cmd[cur]; 2673692ad7caSAdrian Chadd cmd->code = buf->code; 26746607310bSBenjamin Close cmd->flags = 0; 26756607310bSBenjamin Close cmd->qid = ring->qid; 2676940aa808SAdrian Chadd cmd->idx = cur; 26776607310bSBenjamin Close 2678692ad7caSAdrian Chadd memcpy(cmd->data, buf->data, buf->size); 26796607310bSBenjamin Close 2680692ad7caSAdrian Chadd /* Save and trim IEEE802.11 header. */ 26818a28176aSAdrian Chadd memcpy((uint8_t *)(cmd->data + buf->size), wh, hdrlen); 26828a28176aSAdrian Chadd m_adj(buf->m, hdrlen); 26836607310bSBenjamin Close 2684692ad7caSAdrian Chadd error = bus_dmamap_load_mbuf_sg(ring->data_dmat, data->map, buf->m, 2685692ad7caSAdrian Chadd segs, &nsegs, BUS_DMA_NOWAIT); 26866607310bSBenjamin Close if (error != 0 && error != EFBIG) { 2687692ad7caSAdrian Chadd device_printf(sc->sc_dev, 2688692ad7caSAdrian Chadd "%s: can't map mbuf (error %d)\n", __func__, error); 2689823e17dbSAdrian Chadd goto end; 26906607310bSBenjamin Close } 26916607310bSBenjamin Close if (error != 0) { 2692692ad7caSAdrian Chadd /* Too many DMA segments, linearize mbuf. */ 2693893edbeaSAdrian Chadd m1 = m_collapse(buf->m, M_NOWAIT, WPI_MAX_SCATTER - 1); 2694692ad7caSAdrian Chadd if (m1 == NULL) { 26956607310bSBenjamin Close device_printf(sc->sc_dev, 2696692ad7caSAdrian Chadd "%s: could not defrag mbuf\n", __func__); 269763f57699SAdrian Chadd error = ENOBUFS; 2698823e17dbSAdrian Chadd goto end; 26996607310bSBenjamin Close } 2700692ad7caSAdrian Chadd buf->m = m1; 27016607310bSBenjamin Close 27026607310bSBenjamin Close error = bus_dmamap_load_mbuf_sg(ring->data_dmat, data->map, 2703692ad7caSAdrian Chadd buf->m, segs, &nsegs, BUS_DMA_NOWAIT); 2704859f6ddcSAdrian Chadd if (__predict_false(error != 0)) { 2705823e17dbSAdrian Chadd /* XXX fix this (applicable to the iwn(4) too) */ 2706823e17dbSAdrian Chadd /* 2707823e17dbSAdrian Chadd * NB: Do not return error; 2708823e17dbSAdrian Chadd * original mbuf does not exist anymore. 2709823e17dbSAdrian Chadd */ 27106607310bSBenjamin Close device_printf(sc->sc_dev, 27117167f5fcSAdrian Chadd "%s: can't map mbuf (error %d)\n", __func__, 27127167f5fcSAdrian Chadd error); 2713823e17dbSAdrian Chadd if (ring->qid < WPI_CMD_QUEUE_NUM) { 2714823e17dbSAdrian Chadd if_inc_counter(buf->ni->ni_vap->iv_ifp, 2715823e17dbSAdrian Chadd IFCOUNTER_OERRORS, 1); 2716940aa808SAdrian Chadd if (!frag) 2717823e17dbSAdrian Chadd ieee80211_free_node(buf->ni); 2718823e17dbSAdrian Chadd } 2719823e17dbSAdrian Chadd m_freem(buf->m); 2720823e17dbSAdrian Chadd error = 0; 2721823e17dbSAdrian Chadd goto end; 27226607310bSBenjamin Close } 27236607310bSBenjamin Close } 27246607310bSBenjamin Close 2725893edbeaSAdrian Chadd KASSERT(nsegs < WPI_MAX_SCATTER, 2726893edbeaSAdrian Chadd ("too many DMA segments, nsegs (%d) should be less than %d", 2727893edbeaSAdrian Chadd nsegs, WPI_MAX_SCATTER)); 2728893edbeaSAdrian Chadd 2729692ad7caSAdrian Chadd data->m = buf->m; 2730692ad7caSAdrian Chadd data->ni = buf->ni; 2731*3f3d4d61SAndriy Voskoboinyk data->hdrlen = hdrlen; 27326607310bSBenjamin Close 2733692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_XMIT, "%s: qid %d idx %d len %d nsegs %d\n", 2734940aa808SAdrian Chadd __func__, ring->qid, cur, totlen, nsegs); 27356607310bSBenjamin Close 2736692ad7caSAdrian Chadd /* Fill TX descriptor. */ 27378a28176aSAdrian Chadd desc->nsegs = WPI_PAD32(totlen + pad) << 4 | (1 + nsegs); 2738692ad7caSAdrian Chadd /* First DMA segment is used by the TX command. */ 2739692ad7caSAdrian Chadd desc->segs[0].addr = htole32(data->cmd_paddr); 27408a28176aSAdrian Chadd desc->segs[0].len = htole32(4 + buf->size + hdrlen + pad); 2741692ad7caSAdrian Chadd /* Other DMA segments are for data payload. */ 2742692ad7caSAdrian Chadd seg = &segs[0]; 27436607310bSBenjamin Close for (i = 1; i <= nsegs; i++) { 2744692ad7caSAdrian Chadd desc->segs[i].addr = htole32(seg->ds_addr); 2745692ad7caSAdrian Chadd desc->segs[i].len = htole32(seg->ds_len); 2746692ad7caSAdrian Chadd seg++; 27476607310bSBenjamin Close } 27486607310bSBenjamin Close 27496607310bSBenjamin Close bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_PREWRITE); 2750692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, ring->cmd_dma.map, 2751692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 27526607310bSBenjamin Close bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 27536607310bSBenjamin Close BUS_DMASYNC_PREWRITE); 27546607310bSBenjamin Close 2755940aa808SAdrian Chadd ring->pending += 1; 2756692ad7caSAdrian Chadd 2757940aa808SAdrian Chadd if (!frag) { 275845ac43f3SAdrian Chadd if (ring->qid < WPI_CMD_QUEUE_NUM) { 2759fc5870b4SAdrian Chadd WPI_TXQ_STATE_LOCK(sc); 2760940aa808SAdrian Chadd ring->queued += ring->pending; 2761940aa808SAdrian Chadd callout_reset(&sc->tx_timeout, 5*hz, wpi_tx_timeout, 2762940aa808SAdrian Chadd sc); 2763fc5870b4SAdrian Chadd WPI_TXQ_STATE_UNLOCK(sc); 276445ac43f3SAdrian Chadd } 276510550f61SAdrian Chadd 2766940aa808SAdrian Chadd /* Kick TX ring. */ 2767940aa808SAdrian Chadd ring->cur = (ring->cur + ring->pending) % WPI_TX_RING_COUNT; 2768940aa808SAdrian Chadd ring->pending = 0; 2769940aa808SAdrian Chadd sc->sc_update_tx_ring(sc, ring); 2770940aa808SAdrian Chadd } else 2771940aa808SAdrian Chadd ieee80211_node_incref(data->ni); 2772940aa808SAdrian Chadd 2773823e17dbSAdrian Chadd end: DPRINTF(sc, WPI_DEBUG_TRACE, error ? TRACE_STR_END_ERR : TRACE_STR_END, 2774823e17dbSAdrian Chadd __func__); 2775692ad7caSAdrian Chadd 277663f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 277763f57699SAdrian Chadd 2778823e17dbSAdrian Chadd return (error); 2779692ad7caSAdrian Chadd } 2780692ad7caSAdrian Chadd 2781692ad7caSAdrian Chadd /* 2782692ad7caSAdrian Chadd * Construct the data packet for a transmit buffer. 2783692ad7caSAdrian Chadd */ 2784692ad7caSAdrian Chadd static int 2785692ad7caSAdrian Chadd wpi_tx_data(struct wpi_softc *sc, struct mbuf *m, struct ieee80211_node *ni) 2786692ad7caSAdrian Chadd { 2787692ad7caSAdrian Chadd const struct ieee80211_txparam *tp; 2788692ad7caSAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 2789692ad7caSAdrian Chadd struct ieee80211com *ic = ni->ni_ic; 2790a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 2791692ad7caSAdrian Chadd struct ieee80211_channel *chan; 2792692ad7caSAdrian Chadd struct ieee80211_frame *wh; 2793692ad7caSAdrian Chadd struct ieee80211_key *k = NULL; 2794692ad7caSAdrian Chadd struct wpi_buf tx_data; 2795565248e2SAdrian Chadd struct wpi_cmd_data *tx = (struct wpi_cmd_data *)&tx_data.data; 2796692ad7caSAdrian Chadd uint32_t flags; 2797525a3d47SAdrian Chadd uint16_t ac, qos; 2798525a3d47SAdrian Chadd uint8_t tid, type, rate; 2799823e17dbSAdrian Chadd int swcrypt, ismcast, totlen; 2800692ad7caSAdrian Chadd 2801692ad7caSAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 2802692ad7caSAdrian Chadd type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK; 2803692ad7caSAdrian Chadd ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1); 280419ea23a0SAdrian Chadd swcrypt = 1; 2805692ad7caSAdrian Chadd 2806692ad7caSAdrian Chadd /* Select EDCA Access Category and TX ring for this frame. */ 2807692ad7caSAdrian Chadd if (IEEE80211_QOS_HAS_SEQ(wh)) { 2808692ad7caSAdrian Chadd qos = ((const struct ieee80211_qosframe *)wh)->i_qos[0]; 2809692ad7caSAdrian Chadd tid = qos & IEEE80211_QOS_TID; 2810692ad7caSAdrian Chadd } else { 2811692ad7caSAdrian Chadd qos = 0; 2812692ad7caSAdrian Chadd tid = 0; 2813692ad7caSAdrian Chadd } 2814692ad7caSAdrian Chadd ac = M_WME_GETAC(m); 2815692ad7caSAdrian Chadd 2816692ad7caSAdrian Chadd chan = (ni->ni_chan != IEEE80211_CHAN_ANYC) ? 2817692ad7caSAdrian Chadd ni->ni_chan : ic->ic_curchan; 2818692ad7caSAdrian Chadd tp = &vap->iv_txparms[ieee80211_chan2mode(chan)]; 2819692ad7caSAdrian Chadd 2820692ad7caSAdrian Chadd /* Choose a TX rate index. */ 2821692ad7caSAdrian Chadd if (type == IEEE80211_FC0_TYPE_MGT) 2822692ad7caSAdrian Chadd rate = tp->mgmtrate; 2823692ad7caSAdrian Chadd else if (ismcast) 2824692ad7caSAdrian Chadd rate = tp->mcastrate; 2825692ad7caSAdrian Chadd else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) 2826692ad7caSAdrian Chadd rate = tp->ucastrate; 2827692ad7caSAdrian Chadd else if (m->m_flags & M_EAPOL) 2828692ad7caSAdrian Chadd rate = tp->mgmtrate; 2829692ad7caSAdrian Chadd else { 2830692ad7caSAdrian Chadd /* XXX pass pktlen */ 2831692ad7caSAdrian Chadd (void) ieee80211_ratectl_rate(ni, NULL, 0); 2832692ad7caSAdrian Chadd rate = ni->ni_txrate; 2833692ad7caSAdrian Chadd } 2834692ad7caSAdrian Chadd 2835692ad7caSAdrian Chadd /* Encrypt the frame if need be. */ 2836692ad7caSAdrian Chadd if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) { 2837692ad7caSAdrian Chadd /* Retrieve key for TX. */ 2838692ad7caSAdrian Chadd k = ieee80211_crypto_encap(ni, m); 2839823e17dbSAdrian Chadd if (k == NULL) 2840823e17dbSAdrian Chadd return (ENOBUFS); 2841823e17dbSAdrian Chadd 2842f15520d9SAdrian Chadd swcrypt = k->wk_flags & IEEE80211_KEY_SWCRYPT; 2843f15520d9SAdrian Chadd 2844692ad7caSAdrian Chadd /* 802.11 header may have moved. */ 2845692ad7caSAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 2846692ad7caSAdrian Chadd } 28478a28176aSAdrian Chadd totlen = m->m_pkthdr.len; 2848692ad7caSAdrian Chadd 2849692ad7caSAdrian Chadd if (ieee80211_radiotap_active_vap(vap)) { 2850692ad7caSAdrian Chadd struct wpi_tx_radiotap_header *tap = &sc->sc_txtap; 2851692ad7caSAdrian Chadd 28528a28176aSAdrian Chadd tap->wt_flags = 0; 2853692ad7caSAdrian Chadd tap->wt_rate = rate; 2854692ad7caSAdrian Chadd if (k != NULL) 2855692ad7caSAdrian Chadd tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP; 2856940aa808SAdrian Chadd if (wh->i_fc[1] & IEEE80211_FC1_MORE_FRAG) 2857940aa808SAdrian Chadd tap->wt_flags |= IEEE80211_RADIOTAP_F_FRAG; 2858692ad7caSAdrian Chadd 2859692ad7caSAdrian Chadd ieee80211_radiotap_tx(vap, m); 2860692ad7caSAdrian Chadd } 2861692ad7caSAdrian Chadd 2862692ad7caSAdrian Chadd flags = 0; 2863692ad7caSAdrian Chadd if (!ismcast) { 2864692ad7caSAdrian Chadd /* Unicast frame, check if an ACK is expected. */ 2865692ad7caSAdrian Chadd if (!qos || (qos & IEEE80211_QOS_ACKPOLICY) != 2866692ad7caSAdrian Chadd IEEE80211_QOS_ACKPOLICY_NOACK) 2867692ad7caSAdrian Chadd flags |= WPI_TX_NEED_ACK; 2868692ad7caSAdrian Chadd } 2869692ad7caSAdrian Chadd 28709b7cc717SAdrian Chadd if (!IEEE80211_QOS_HAS_SEQ(wh)) 28719b7cc717SAdrian Chadd flags |= WPI_TX_AUTO_SEQ; 2872fae61c69SAdrian Chadd if (wh->i_fc[1] & IEEE80211_FC1_MORE_FRAG) 2873940aa808SAdrian Chadd flags |= WPI_TX_MORE_FRAG; 2874fae61c69SAdrian Chadd 2875692ad7caSAdrian Chadd /* Check if frame must be protected using RTS/CTS or CTS-to-self. */ 2876692ad7caSAdrian Chadd if (!ismcast) { 2877692ad7caSAdrian Chadd /* NB: Group frames are sent using CCK in 802.11b/g. */ 2878692ad7caSAdrian Chadd if (totlen + IEEE80211_CRC_LEN > vap->iv_rtsthreshold) { 2879692ad7caSAdrian Chadd flags |= WPI_TX_NEED_RTS; 2880692ad7caSAdrian Chadd } else if ((ic->ic_flags & IEEE80211_F_USEPROT) && 2881692ad7caSAdrian Chadd WPI_RATE_IS_OFDM(rate)) { 2882692ad7caSAdrian Chadd if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) 2883692ad7caSAdrian Chadd flags |= WPI_TX_NEED_CTS; 2884692ad7caSAdrian Chadd else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) 2885692ad7caSAdrian Chadd flags |= WPI_TX_NEED_RTS; 2886692ad7caSAdrian Chadd } 2887692ad7caSAdrian Chadd 2888692ad7caSAdrian Chadd if (flags & (WPI_TX_NEED_RTS | WPI_TX_NEED_CTS)) 2889692ad7caSAdrian Chadd flags |= WPI_TX_FULL_TXOP; 2890692ad7caSAdrian Chadd } 2891692ad7caSAdrian Chadd 2892565248e2SAdrian Chadd memset(tx, 0, sizeof (struct wpi_cmd_data)); 2893692ad7caSAdrian Chadd if (type == IEEE80211_FC0_TYPE_MGT) { 2894692ad7caSAdrian Chadd uint8_t subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; 2895692ad7caSAdrian Chadd 2896692ad7caSAdrian Chadd /* Tell HW to set timestamp in probe responses. */ 2897692ad7caSAdrian Chadd if (subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP) 2898692ad7caSAdrian Chadd flags |= WPI_TX_INSERT_TSTAMP; 2899692ad7caSAdrian Chadd if (subtype == IEEE80211_FC0_SUBTYPE_ASSOC_REQ || 2900692ad7caSAdrian Chadd subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ) 2901565248e2SAdrian Chadd tx->timeout = htole16(3); 2902692ad7caSAdrian Chadd else 2903565248e2SAdrian Chadd tx->timeout = htole16(2); 2904692ad7caSAdrian Chadd } 2905692ad7caSAdrian Chadd 2906692ad7caSAdrian Chadd if (ismcast || type != IEEE80211_FC0_TYPE_DATA) 2907565248e2SAdrian Chadd tx->id = WPI_ID_BROADCAST; 2908692ad7caSAdrian Chadd else { 2909692ad7caSAdrian Chadd if (wn->id == WPI_ID_UNDEFINED) { 2910692ad7caSAdrian Chadd device_printf(sc->sc_dev, 2911692ad7caSAdrian Chadd "%s: undefined node id\n", __func__); 2912823e17dbSAdrian Chadd return (EINVAL); 2913692ad7caSAdrian Chadd } 2914692ad7caSAdrian Chadd 2915565248e2SAdrian Chadd tx->id = wn->id; 2916692ad7caSAdrian Chadd } 2917692ad7caSAdrian Chadd 291819ea23a0SAdrian Chadd if (!swcrypt) { 2919f15520d9SAdrian Chadd switch (k->wk_cipher->ic_cipher) { 2920f15520d9SAdrian Chadd case IEEE80211_CIPHER_AES_CCM: 2921565248e2SAdrian Chadd tx->security = WPI_CIPHER_CCMP; 2922f15520d9SAdrian Chadd break; 2923f15520d9SAdrian Chadd 2924f15520d9SAdrian Chadd default: 2925f15520d9SAdrian Chadd break; 2926f15520d9SAdrian Chadd } 2927f15520d9SAdrian Chadd 2928565248e2SAdrian Chadd memcpy(tx->key, k->wk_key, k->wk_keylen); 2929f15520d9SAdrian Chadd } 2930f15520d9SAdrian Chadd 2931940aa808SAdrian Chadd if (wh->i_fc[1] & IEEE80211_FC1_MORE_FRAG) { 2932940aa808SAdrian Chadd struct mbuf *next = m->m_nextpkt; 2933940aa808SAdrian Chadd 2934940aa808SAdrian Chadd tx->lnext = htole16(next->m_pkthdr.len); 2935940aa808SAdrian Chadd tx->fnext = htole32(tx->security | 2936940aa808SAdrian Chadd (flags & WPI_TX_NEED_ACK) | 2937940aa808SAdrian Chadd WPI_NEXT_STA_ID(tx->id)); 2938940aa808SAdrian Chadd } 2939940aa808SAdrian Chadd 2940565248e2SAdrian Chadd tx->len = htole16(totlen); 2941565248e2SAdrian Chadd tx->flags = htole32(flags); 2942565248e2SAdrian Chadd tx->plcp = rate2plcp(rate); 2943565248e2SAdrian Chadd tx->tid = tid; 2944565248e2SAdrian Chadd tx->lifetime = htole32(WPI_LIFETIME_INFINITE); 2945565248e2SAdrian Chadd tx->ofdm_mask = 0xff; 2946565248e2SAdrian Chadd tx->cck_mask = 0x0f; 2947565248e2SAdrian Chadd tx->rts_ntries = 7; 2948b625a56aSAdrian Chadd tx->data_ntries = tp->maxretry; 2949692ad7caSAdrian Chadd 2950692ad7caSAdrian Chadd tx_data.ni = ni; 2951692ad7caSAdrian Chadd tx_data.m = m; 2952565248e2SAdrian Chadd tx_data.size = sizeof(struct wpi_cmd_data); 2953692ad7caSAdrian Chadd tx_data.code = WPI_CMD_TX_DATA; 2954692ad7caSAdrian Chadd tx_data.ac = ac; 2955692ad7caSAdrian Chadd 2956692ad7caSAdrian Chadd return wpi_cmd2(sc, &tx_data); 2957692ad7caSAdrian Chadd } 2958692ad7caSAdrian Chadd 2959692ad7caSAdrian Chadd static int 29607167f5fcSAdrian Chadd wpi_tx_data_raw(struct wpi_softc *sc, struct mbuf *m, 29617167f5fcSAdrian Chadd struct ieee80211_node *ni, const struct ieee80211_bpf_params *params) 2962692ad7caSAdrian Chadd { 2963692ad7caSAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 2964735c6067SAdrian Chadd struct ieee80211_key *k = NULL; 2965692ad7caSAdrian Chadd struct ieee80211_frame *wh; 2966692ad7caSAdrian Chadd struct wpi_buf tx_data; 2967565248e2SAdrian Chadd struct wpi_cmd_data *tx = (struct wpi_cmd_data *)&tx_data.data; 2968692ad7caSAdrian Chadd uint32_t flags; 2969525a3d47SAdrian Chadd uint8_t ac, type, rate; 2970525a3d47SAdrian Chadd int swcrypt, totlen; 2971692ad7caSAdrian Chadd 2972692ad7caSAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 2973692ad7caSAdrian Chadd type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK; 297419ea23a0SAdrian Chadd swcrypt = 1; 2975692ad7caSAdrian Chadd 2976692ad7caSAdrian Chadd ac = params->ibp_pri & 3; 2977692ad7caSAdrian Chadd 2978692ad7caSAdrian Chadd /* Choose a TX rate index. */ 2979692ad7caSAdrian Chadd rate = params->ibp_rate0; 2980692ad7caSAdrian Chadd 2981692ad7caSAdrian Chadd flags = 0; 29829b7cc717SAdrian Chadd if (!IEEE80211_QOS_HAS_SEQ(wh)) 29839b7cc717SAdrian Chadd flags |= WPI_TX_AUTO_SEQ; 2984692ad7caSAdrian Chadd if ((params->ibp_flags & IEEE80211_BPF_NOACK) == 0) 2985692ad7caSAdrian Chadd flags |= WPI_TX_NEED_ACK; 2986692ad7caSAdrian Chadd if (params->ibp_flags & IEEE80211_BPF_RTS) 2987692ad7caSAdrian Chadd flags |= WPI_TX_NEED_RTS; 2988692ad7caSAdrian Chadd if (params->ibp_flags & IEEE80211_BPF_CTS) 2989692ad7caSAdrian Chadd flags |= WPI_TX_NEED_CTS; 2990692ad7caSAdrian Chadd if (flags & (WPI_TX_NEED_RTS | WPI_TX_NEED_CTS)) 2991692ad7caSAdrian Chadd flags |= WPI_TX_FULL_TXOP; 2992692ad7caSAdrian Chadd 2993735c6067SAdrian Chadd /* Encrypt the frame if need be. */ 2994735c6067SAdrian Chadd if (params->ibp_flags & IEEE80211_BPF_CRYPTO) { 2995735c6067SAdrian Chadd /* Retrieve key for TX. */ 2996735c6067SAdrian Chadd k = ieee80211_crypto_encap(ni, m); 2997823e17dbSAdrian Chadd if (k == NULL) 2998823e17dbSAdrian Chadd return (ENOBUFS); 2999823e17dbSAdrian Chadd 3000735c6067SAdrian Chadd swcrypt = k->wk_flags & IEEE80211_KEY_SWCRYPT; 3001735c6067SAdrian Chadd 3002735c6067SAdrian Chadd /* 802.11 header may have moved. */ 3003735c6067SAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 3004735c6067SAdrian Chadd } 3005735c6067SAdrian Chadd totlen = m->m_pkthdr.len; 3006735c6067SAdrian Chadd 3007692ad7caSAdrian Chadd if (ieee80211_radiotap_active_vap(vap)) { 3008692ad7caSAdrian Chadd struct wpi_tx_radiotap_header *tap = &sc->sc_txtap; 3009692ad7caSAdrian Chadd 3010692ad7caSAdrian Chadd tap->wt_flags = 0; 3011692ad7caSAdrian Chadd tap->wt_rate = rate; 3012735c6067SAdrian Chadd if (params->ibp_flags & IEEE80211_BPF_CRYPTO) 3013735c6067SAdrian Chadd tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP; 3014692ad7caSAdrian Chadd 3015692ad7caSAdrian Chadd ieee80211_radiotap_tx(vap, m); 3016692ad7caSAdrian Chadd } 3017692ad7caSAdrian Chadd 3018565248e2SAdrian Chadd memset(tx, 0, sizeof (struct wpi_cmd_data)); 3019692ad7caSAdrian Chadd if (type == IEEE80211_FC0_TYPE_MGT) { 3020692ad7caSAdrian Chadd uint8_t subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; 3021692ad7caSAdrian Chadd 3022692ad7caSAdrian Chadd /* Tell HW to set timestamp in probe responses. */ 3023692ad7caSAdrian Chadd if (subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP) 3024692ad7caSAdrian Chadd flags |= WPI_TX_INSERT_TSTAMP; 3025692ad7caSAdrian Chadd if (subtype == IEEE80211_FC0_SUBTYPE_ASSOC_REQ || 3026692ad7caSAdrian Chadd subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ) 3027565248e2SAdrian Chadd tx->timeout = htole16(3); 3028692ad7caSAdrian Chadd else 3029565248e2SAdrian Chadd tx->timeout = htole16(2); 3030692ad7caSAdrian Chadd } 3031692ad7caSAdrian Chadd 303219ea23a0SAdrian Chadd if (!swcrypt) { 3033735c6067SAdrian Chadd switch (k->wk_cipher->ic_cipher) { 3034735c6067SAdrian Chadd case IEEE80211_CIPHER_AES_CCM: 3035735c6067SAdrian Chadd tx->security = WPI_CIPHER_CCMP; 3036735c6067SAdrian Chadd break; 3037735c6067SAdrian Chadd 3038735c6067SAdrian Chadd default: 3039735c6067SAdrian Chadd break; 3040735c6067SAdrian Chadd } 3041735c6067SAdrian Chadd 3042735c6067SAdrian Chadd memcpy(tx->key, k->wk_key, k->wk_keylen); 3043735c6067SAdrian Chadd } 3044735c6067SAdrian Chadd 3045565248e2SAdrian Chadd tx->len = htole16(totlen); 3046565248e2SAdrian Chadd tx->flags = htole32(flags); 3047565248e2SAdrian Chadd tx->plcp = rate2plcp(rate); 3048565248e2SAdrian Chadd tx->id = WPI_ID_BROADCAST; 3049565248e2SAdrian Chadd tx->lifetime = htole32(WPI_LIFETIME_INFINITE); 3050565248e2SAdrian Chadd tx->rts_ntries = params->ibp_try1; 3051565248e2SAdrian Chadd tx->data_ntries = params->ibp_try0; 3052692ad7caSAdrian Chadd 3053692ad7caSAdrian Chadd tx_data.ni = ni; 3054692ad7caSAdrian Chadd tx_data.m = m; 3055565248e2SAdrian Chadd tx_data.size = sizeof(struct wpi_cmd_data); 3056692ad7caSAdrian Chadd tx_data.code = WPI_CMD_TX_DATA; 3057692ad7caSAdrian Chadd tx_data.ac = ac; 3058692ad7caSAdrian Chadd 3059692ad7caSAdrian Chadd return wpi_cmd2(sc, &tx_data); 3060692ad7caSAdrian Chadd } 3061692ad7caSAdrian Chadd 30627a79cebfSGleb Smirnoff static __inline int 3063940aa808SAdrian Chadd wpi_tx_ring_free_space(struct wpi_softc *sc, uint16_t ac) 30647a79cebfSGleb Smirnoff { 30657a79cebfSGleb Smirnoff struct wpi_tx_ring *ring = &sc->txq[ac]; 30667a79cebfSGleb Smirnoff int retval; 30677a79cebfSGleb Smirnoff 30687a79cebfSGleb Smirnoff WPI_TXQ_STATE_LOCK(sc); 3069940aa808SAdrian Chadd retval = WPI_TX_RING_HIMARK - ring->queued; 30707a79cebfSGleb Smirnoff WPI_TXQ_STATE_UNLOCK(sc); 30717a79cebfSGleb Smirnoff 30727a79cebfSGleb Smirnoff return retval; 30737a79cebfSGleb Smirnoff } 30747a79cebfSGleb Smirnoff 3075692ad7caSAdrian Chadd static int 3076692ad7caSAdrian Chadd wpi_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, 3077692ad7caSAdrian Chadd const struct ieee80211_bpf_params *params) 3078692ad7caSAdrian Chadd { 3079692ad7caSAdrian Chadd struct ieee80211com *ic = ni->ni_ic; 30802cb71df1SAdrian Chadd struct wpi_softc *sc = ic->ic_softc; 3081525a3d47SAdrian Chadd uint16_t ac; 3082525a3d47SAdrian Chadd int error = 0; 3083692ad7caSAdrian Chadd 3084692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 3085692ad7caSAdrian Chadd 30867a79cebfSGleb Smirnoff ac = M_WME_GETAC(m); 308779d2c5e8SGleb Smirnoff 3088ba2c1fbcSAdrian Chadd WPI_TX_LOCK(sc); 30897a79cebfSGleb Smirnoff 3090940aa808SAdrian Chadd /* NB: no fragments here */ 3091940aa808SAdrian Chadd if (sc->sc_running == 0 || wpi_tx_ring_free_space(sc, ac) < 1) { 30927a79cebfSGleb Smirnoff error = sc->sc_running ? ENOBUFS : ENETDOWN; 30937a79cebfSGleb Smirnoff goto unlock; 30947a79cebfSGleb Smirnoff } 30957a79cebfSGleb Smirnoff 3096692ad7caSAdrian Chadd if (params == NULL) { 3097692ad7caSAdrian Chadd /* 3098692ad7caSAdrian Chadd * Legacy path; interpret frame contents to decide 3099692ad7caSAdrian Chadd * precisely how to send the frame. 3100692ad7caSAdrian Chadd */ 3101692ad7caSAdrian Chadd error = wpi_tx_data(sc, m, ni); 3102692ad7caSAdrian Chadd } else { 3103692ad7caSAdrian Chadd /* 3104692ad7caSAdrian Chadd * Caller supplied explicit parameters to use in 3105692ad7caSAdrian Chadd * sending the frame. 3106692ad7caSAdrian Chadd */ 3107692ad7caSAdrian Chadd error = wpi_tx_data_raw(sc, m, ni, params); 3108692ad7caSAdrian Chadd } 31097a79cebfSGleb Smirnoff 31107a79cebfSGleb Smirnoff unlock: WPI_TX_UNLOCK(sc); 3111692ad7caSAdrian Chadd 3112692ad7caSAdrian Chadd if (error != 0) { 3113823e17dbSAdrian Chadd m_freem(m); 3114692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 3115692ad7caSAdrian Chadd 3116692ad7caSAdrian Chadd return error; 3117692ad7caSAdrian Chadd } 3118692ad7caSAdrian Chadd 3119692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 31206607310bSBenjamin Close 31216607310bSBenjamin Close return 0; 31226607310bSBenjamin Close } 31236607310bSBenjamin Close 31247a79cebfSGleb Smirnoff static int 31257a79cebfSGleb Smirnoff wpi_transmit(struct ieee80211com *ic, struct mbuf *m) 312679d2c5e8SGleb Smirnoff { 31277a79cebfSGleb Smirnoff struct wpi_softc *sc = ic->ic_softc; 312879d2c5e8SGleb Smirnoff struct ieee80211_node *ni; 3129940aa808SAdrian Chadd struct mbuf *mnext; 3130525a3d47SAdrian Chadd uint16_t ac; 3131940aa808SAdrian Chadd int error, nmbufs; 313279d2c5e8SGleb Smirnoff 313379d2c5e8SGleb Smirnoff WPI_TX_LOCK(sc); 313479d2c5e8SGleb Smirnoff DPRINTF(sc, WPI_DEBUG_XMIT, "%s: called\n", __func__); 313579d2c5e8SGleb Smirnoff 31367a79cebfSGleb Smirnoff /* Check if interface is up & running. */ 3137859f6ddcSAdrian Chadd if (__predict_false(sc->sc_running == 0)) { 31387a79cebfSGleb Smirnoff error = ENXIO; 31397a79cebfSGleb Smirnoff goto unlock; 3140ba2c1fbcSAdrian Chadd } 314179d2c5e8SGleb Smirnoff 3142940aa808SAdrian Chadd nmbufs = 1; 3143940aa808SAdrian Chadd for (mnext = m->m_nextpkt; mnext != NULL; mnext = mnext->m_nextpkt) 3144940aa808SAdrian Chadd nmbufs++; 3145940aa808SAdrian Chadd 31467a79cebfSGleb Smirnoff /* Check for available space. */ 31477a79cebfSGleb Smirnoff ac = M_WME_GETAC(m); 3148940aa808SAdrian Chadd if (wpi_tx_ring_free_space(sc, ac) < nmbufs) { 3149753ca9efSAdrian Chadd error = ENOBUFS; 31507a79cebfSGleb Smirnoff goto unlock; 31517a79cebfSGleb Smirnoff } 31527a79cebfSGleb Smirnoff 31537a79cebfSGleb Smirnoff error = 0; 315479d2c5e8SGleb Smirnoff ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; 3155940aa808SAdrian Chadd do { 3156940aa808SAdrian Chadd mnext = m->m_nextpkt; 315779d2c5e8SGleb Smirnoff if (wpi_tx_data(sc, m, ni) != 0) { 3158940aa808SAdrian Chadd if_inc_counter(ni->ni_vap->iv_ifp, IFCOUNTER_OERRORS, 3159940aa808SAdrian Chadd nmbufs); 3160940aa808SAdrian Chadd wpi_free_txfrags(sc, ac); 3161940aa808SAdrian Chadd ieee80211_free_mbuf(m); 3162f7cd3e18SAdrian Chadd ieee80211_free_node(ni); 3163940aa808SAdrian Chadd break; 31647a79cebfSGleb Smirnoff } 3165940aa808SAdrian Chadd } while((m = mnext) != NULL); 31667a79cebfSGleb Smirnoff 31677a79cebfSGleb Smirnoff DPRINTF(sc, WPI_DEBUG_XMIT, "%s: done\n", __func__); 31687a79cebfSGleb Smirnoff 31697a79cebfSGleb Smirnoff unlock: WPI_TX_UNLOCK(sc); 31707a79cebfSGleb Smirnoff 31717a79cebfSGleb Smirnoff return (error); 31727a79cebfSGleb Smirnoff } 31737a79cebfSGleb Smirnoff 31744eaf2ee3SAdrian Chadd static void 3175692ad7caSAdrian Chadd wpi_watchdog_rfkill(void *arg) 3176692ad7caSAdrian Chadd { 3177692ad7caSAdrian Chadd struct wpi_softc *sc = arg; 31787a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 3179692ad7caSAdrian Chadd 3180692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_WATCHDOG, "RFkill Watchdog: tick\n"); 3181692ad7caSAdrian Chadd 3182692ad7caSAdrian Chadd /* No need to lock firmware memory. */ 3183692ad7caSAdrian Chadd if ((wpi_prph_read(sc, WPI_APMG_RFKILL) & 0x1) == 0) { 3184692ad7caSAdrian Chadd /* Radio kill switch is still off. */ 3185692ad7caSAdrian Chadd callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill, 3186692ad7caSAdrian Chadd sc); 3187692ad7caSAdrian Chadd } else 3188692ad7caSAdrian Chadd ieee80211_runtask(ic, &sc->sc_radioon_task); 3189692ad7caSAdrian Chadd } 3190692ad7caSAdrian Chadd 31910bc39fc6SAdrian Chadd static void 31920bc39fc6SAdrian Chadd wpi_scan_timeout(void *arg) 31930bc39fc6SAdrian Chadd { 31940bc39fc6SAdrian Chadd struct wpi_softc *sc = arg; 31957a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 31960bc39fc6SAdrian Chadd 31977a79cebfSGleb Smirnoff ic_printf(ic, "scan timeout\n"); 3198abd89aa2SAndriy Voskoboinyk ieee80211_restart_all(ic); 31990bc39fc6SAdrian Chadd } 32000bc39fc6SAdrian Chadd 3201692ad7caSAdrian Chadd static void 3202d74e544aSAdrian Chadd wpi_tx_timeout(void *arg) 3203692ad7caSAdrian Chadd { 3204692ad7caSAdrian Chadd struct wpi_softc *sc = arg; 32057a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 3206692ad7caSAdrian Chadd 32077a79cebfSGleb Smirnoff ic_printf(ic, "device timeout\n"); 3208abd89aa2SAndriy Voskoboinyk ieee80211_restart_all(ic); 3209692ad7caSAdrian Chadd } 32106607310bSBenjamin Close 32117a79cebfSGleb Smirnoff static void 32127a79cebfSGleb Smirnoff wpi_parent(struct ieee80211com *ic) 32136607310bSBenjamin Close { 32147a79cebfSGleb Smirnoff struct wpi_softc *sc = ic->ic_softc; 3215692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 32166607310bSBenjamin Close 32177a79cebfSGleb Smirnoff if (ic->ic_nrunning > 0) { 32187a79cebfSGleb Smirnoff if (wpi_init(sc) == 0) { 32197a79cebfSGleb Smirnoff ieee80211_notify_radio(ic, 1); 32207a79cebfSGleb Smirnoff ieee80211_start_all(ic); 32217a79cebfSGleb Smirnoff } else { 32227a79cebfSGleb Smirnoff ieee80211_notify_radio(ic, 0); 3223692ad7caSAdrian Chadd ieee80211_stop(vap); 3224ba2c1fbcSAdrian Chadd } 3225abd89aa2SAndriy Voskoboinyk } else { 3226abd89aa2SAndriy Voskoboinyk ieee80211_notify_radio(ic, 0); 32277a79cebfSGleb Smirnoff wpi_stop(sc); 32286607310bSBenjamin Close } 3229abd89aa2SAndriy Voskoboinyk } 32306607310bSBenjamin Close 32316607310bSBenjamin Close /* 32326607310bSBenjamin Close * Send a command to the firmware. 32336607310bSBenjamin Close */ 32346607310bSBenjamin Close static int 3235525a3d47SAdrian Chadd wpi_cmd(struct wpi_softc *sc, uint8_t code, const void *buf, uint16_t size, 3236692ad7caSAdrian Chadd int async) 32376607310bSBenjamin Close { 32388e4cf38aSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[WPI_CMD_QUEUE_NUM]; 32396607310bSBenjamin Close struct wpi_tx_desc *desc; 3240692ad7caSAdrian Chadd struct wpi_tx_data *data; 32416607310bSBenjamin Close struct wpi_tx_cmd *cmd; 3242692ad7caSAdrian Chadd struct mbuf *m; 3243692ad7caSAdrian Chadd bus_addr_t paddr; 3244525a3d47SAdrian Chadd uint16_t totlen; 3245525a3d47SAdrian Chadd int error; 32466607310bSBenjamin Close 324763f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 324863f57699SAdrian Chadd 3249692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 3250692ad7caSAdrian Chadd 3251859f6ddcSAdrian Chadd if (__predict_false(sc->sc_running == 0)) { 325263f57699SAdrian Chadd /* wpi_stop() was called */ 32537a79cebfSGleb Smirnoff if (code == WPI_CMD_SCAN) 32547a79cebfSGleb Smirnoff error = ENETDOWN; 32557a79cebfSGleb Smirnoff else 325663f57699SAdrian Chadd error = 0; 32577a79cebfSGleb Smirnoff 325863f57699SAdrian Chadd goto fail; 325963f57699SAdrian Chadd } 326063f57699SAdrian Chadd 3261692ad7caSAdrian Chadd if (async == 0) 32626607310bSBenjamin Close WPI_LOCK_ASSERT(sc); 32636607310bSBenjamin Close 3264525a3d47SAdrian Chadd DPRINTF(sc, WPI_DEBUG_CMD, "%s: cmd %s size %u async %d\n", 3265cec45f04SAdrian Chadd __func__, wpi_cmd_str(code), size, async); 32666607310bSBenjamin Close 32676607310bSBenjamin Close desc = &ring->desc[ring->cur]; 3268692ad7caSAdrian Chadd data = &ring->data[ring->cur]; 3269692ad7caSAdrian Chadd totlen = 4 + size; 3270692ad7caSAdrian Chadd 3271692ad7caSAdrian Chadd if (size > sizeof cmd->data) { 3272692ad7caSAdrian Chadd /* Command is too large to fit in a descriptor. */ 327363f57699SAdrian Chadd if (totlen > MCLBYTES) { 327463f57699SAdrian Chadd error = EINVAL; 327563f57699SAdrian Chadd goto fail; 327663f57699SAdrian Chadd } 3277692ad7caSAdrian Chadd m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); 327863f57699SAdrian Chadd if (m == NULL) { 327963f57699SAdrian Chadd error = ENOMEM; 328063f57699SAdrian Chadd goto fail; 328163f57699SAdrian Chadd } 3282692ad7caSAdrian Chadd cmd = mtod(m, struct wpi_tx_cmd *); 3283692ad7caSAdrian Chadd error = bus_dmamap_load(ring->data_dmat, data->map, cmd, 3284692ad7caSAdrian Chadd totlen, wpi_dma_map_addr, &paddr, BUS_DMA_NOWAIT); 3285692ad7caSAdrian Chadd if (error != 0) { 3286692ad7caSAdrian Chadd m_freem(m); 328763f57699SAdrian Chadd goto fail; 3288692ad7caSAdrian Chadd } 3289692ad7caSAdrian Chadd data->m = m; 3290692ad7caSAdrian Chadd } else { 32916607310bSBenjamin Close cmd = &ring->cmd[ring->cur]; 3292692ad7caSAdrian Chadd paddr = data->cmd_paddr; 3293692ad7caSAdrian Chadd } 32946607310bSBenjamin Close 32956607310bSBenjamin Close cmd->code = code; 32966607310bSBenjamin Close cmd->flags = 0; 32976607310bSBenjamin Close cmd->qid = ring->qid; 32986607310bSBenjamin Close cmd->idx = ring->cur; 32996607310bSBenjamin Close memcpy(cmd->data, buf, size); 33006607310bSBenjamin Close 3301692ad7caSAdrian Chadd desc->nsegs = 1 + (WPI_PAD32(size) << 4); 3302692ad7caSAdrian Chadd desc->segs[0].addr = htole32(paddr); 3303692ad7caSAdrian Chadd desc->segs[0].len = htole32(totlen); 33046607310bSBenjamin Close 3305692ad7caSAdrian Chadd if (size > sizeof cmd->data) { 3306692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 3307692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 3308692ad7caSAdrian Chadd } else { 3309692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, ring->cmd_dma.map, 3310692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 3311692ad7caSAdrian Chadd } 3312692ad7caSAdrian Chadd bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 3313692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 3314692ad7caSAdrian Chadd 3315692ad7caSAdrian Chadd /* Kick command ring. */ 3316692ad7caSAdrian Chadd ring->cur = (ring->cur + 1) % WPI_TX_RING_COUNT; 33175cacb17fSAdrian Chadd sc->sc_update_tx_ring(sc, ring); 3318692ad7caSAdrian Chadd 3319692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 33206607310bSBenjamin Close 332163f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 332263f57699SAdrian Chadd 33237a79cebfSGleb Smirnoff return async ? 0 : mtx_sleep(cmd, &sc->sc_mtx, PCATCH, "wpicmd", hz); 332463f57699SAdrian Chadd 332563f57699SAdrian Chadd fail: DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 332663f57699SAdrian Chadd 332763f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 332863f57699SAdrian Chadd 332963f57699SAdrian Chadd return error; 33306607310bSBenjamin Close } 33316607310bSBenjamin Close 33326607310bSBenjamin Close /* 3333692ad7caSAdrian Chadd * Configure HW multi-rate retries. 33346607310bSBenjamin Close */ 33356607310bSBenjamin Close static int 33366607310bSBenjamin Close wpi_mrr_setup(struct wpi_softc *sc) 33376607310bSBenjamin Close { 33387a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 33396607310bSBenjamin Close struct wpi_mrr_setup mrr; 3340525a3d47SAdrian Chadd uint8_t i; 3341525a3d47SAdrian Chadd int error; 33426607310bSBenjamin Close 3343692ad7caSAdrian Chadd /* CCK rates (not used with 802.11a). */ 3344692ad7caSAdrian Chadd for (i = WPI_RIDX_CCK1; i <= WPI_RIDX_CCK11; i++) { 33456607310bSBenjamin Close mrr.rates[i].flags = 0; 3346692ad7caSAdrian Chadd mrr.rates[i].plcp = wpi_ridx_to_plcp[i]; 3347692ad7caSAdrian Chadd /* Fallback to the immediate lower CCK rate (if any.) */ 3348692ad7caSAdrian Chadd mrr.rates[i].next = 3349692ad7caSAdrian Chadd (i == WPI_RIDX_CCK1) ? WPI_RIDX_CCK1 : i - 1; 335030b60481SAdrian Chadd /* Try twice at this rate before falling back to "next". */ 335130b60481SAdrian Chadd mrr.rates[i].ntries = WPI_NTRIES_DEFAULT; 33526607310bSBenjamin Close } 3353692ad7caSAdrian Chadd /* OFDM rates (not used with 802.11b). */ 3354692ad7caSAdrian Chadd for (i = WPI_RIDX_OFDM6; i <= WPI_RIDX_OFDM54; i++) { 33556607310bSBenjamin Close mrr.rates[i].flags = 0; 3356692ad7caSAdrian Chadd mrr.rates[i].plcp = wpi_ridx_to_plcp[i]; 3357692ad7caSAdrian Chadd /* Fallback to the immediate lower rate (if any.) */ 3358692ad7caSAdrian Chadd /* We allow fallback from OFDM/6 to CCK/2 in 11b/g mode. */ 3359692ad7caSAdrian Chadd mrr.rates[i].next = (i == WPI_RIDX_OFDM6) ? 33606607310bSBenjamin Close ((ic->ic_curmode == IEEE80211_MODE_11A) ? 3361692ad7caSAdrian Chadd WPI_RIDX_OFDM6 : WPI_RIDX_CCK2) : 33626607310bSBenjamin Close i - 1; 336330b60481SAdrian Chadd /* Try twice at this rate before falling back to "next". */ 336430b60481SAdrian Chadd mrr.rates[i].ntries = WPI_NTRIES_DEFAULT; 33656607310bSBenjamin Close } 3366692ad7caSAdrian Chadd /* Setup MRR for control frames. */ 3367692ad7caSAdrian Chadd mrr.which = htole32(WPI_MRR_CTL); 33686607310bSBenjamin Close error = wpi_cmd(sc, WPI_CMD_MRR_SETUP, &mrr, sizeof mrr, 0); 33696607310bSBenjamin Close if (error != 0) { 33706607310bSBenjamin Close device_printf(sc->sc_dev, 33716607310bSBenjamin Close "could not setup MRR for control frames\n"); 33726607310bSBenjamin Close return error; 33736607310bSBenjamin Close } 3374692ad7caSAdrian Chadd /* Setup MRR for data frames. */ 3375692ad7caSAdrian Chadd mrr.which = htole32(WPI_MRR_DATA); 33766607310bSBenjamin Close error = wpi_cmd(sc, WPI_CMD_MRR_SETUP, &mrr, sizeof mrr, 0); 33776607310bSBenjamin Close if (error != 0) { 33786607310bSBenjamin Close device_printf(sc->sc_dev, 33796607310bSBenjamin Close "could not setup MRR for data frames\n"); 33806607310bSBenjamin Close return error; 33816607310bSBenjamin Close } 33826607310bSBenjamin Close return 0; 33836607310bSBenjamin Close } 33846607310bSBenjamin Close 3385692ad7caSAdrian Chadd static int 3386692ad7caSAdrian Chadd wpi_add_node(struct wpi_softc *sc, struct ieee80211_node *ni) 3387692ad7caSAdrian Chadd { 3388692ad7caSAdrian Chadd struct ieee80211com *ic = ni->ni_ic; 3389d29fcfb7SAdrian Chadd struct wpi_vap *wvp = WPI_VAP(ni->ni_vap); 3390a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 3391692ad7caSAdrian Chadd struct wpi_node_info node; 3392d29fcfb7SAdrian Chadd int error; 3393692ad7caSAdrian Chadd 3394692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3395692ad7caSAdrian Chadd 3396692ad7caSAdrian Chadd if (wn->id == WPI_ID_UNDEFINED) 3397692ad7caSAdrian Chadd return EINVAL; 3398692ad7caSAdrian Chadd 3399692ad7caSAdrian Chadd memset(&node, 0, sizeof node); 34003de934a7SAdrian Chadd IEEE80211_ADDR_COPY(node.macaddr, ni->ni_macaddr); 3401692ad7caSAdrian Chadd node.id = wn->id; 3402692ad7caSAdrian Chadd node.plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ? 3403692ad7caSAdrian Chadd wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1]; 3404692ad7caSAdrian Chadd node.action = htole32(WPI_ACTION_SET_RATE); 3405692ad7caSAdrian Chadd node.antenna = WPI_ANTENNA_BOTH; 3406692ad7caSAdrian Chadd 34070528191aSAdrian Chadd DPRINTF(sc, WPI_DEBUG_NODE, "%s: adding node %d (%s)\n", __func__, 34080528191aSAdrian Chadd wn->id, ether_sprintf(ni->ni_macaddr)); 34090528191aSAdrian Chadd 3410d29fcfb7SAdrian Chadd error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1); 3411d29fcfb7SAdrian Chadd if (error != 0) { 3412d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, 3413d29fcfb7SAdrian Chadd "%s: wpi_cmd() call failed with error code %d\n", __func__, 3414d29fcfb7SAdrian Chadd error); 3415d29fcfb7SAdrian Chadd return error; 3416d29fcfb7SAdrian Chadd } 3417d29fcfb7SAdrian Chadd 3418d29fcfb7SAdrian Chadd if (wvp->wv_gtk != 0) { 3419d29fcfb7SAdrian Chadd error = wpi_set_global_keys(ni); 3420d29fcfb7SAdrian Chadd if (error != 0) { 3421d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, 3422d29fcfb7SAdrian Chadd "%s: error while setting global keys\n", __func__); 3423d29fcfb7SAdrian Chadd return ENXIO; 3424d29fcfb7SAdrian Chadd } 3425d29fcfb7SAdrian Chadd } 3426d29fcfb7SAdrian Chadd 3427d29fcfb7SAdrian Chadd return 0; 3428692ad7caSAdrian Chadd } 3429692ad7caSAdrian Chadd 3430692ad7caSAdrian Chadd /* 3431692ad7caSAdrian Chadd * Broadcast node is used to send group-addressed and management frames. 3432692ad7caSAdrian Chadd */ 3433692ad7caSAdrian Chadd static int 3434692ad7caSAdrian Chadd wpi_add_broadcast_node(struct wpi_softc *sc, int async) 3435692ad7caSAdrian Chadd { 34367a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 3437692ad7caSAdrian Chadd struct wpi_node_info node; 3438692ad7caSAdrian Chadd 3439692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3440692ad7caSAdrian Chadd 3441692ad7caSAdrian Chadd memset(&node, 0, sizeof node); 34427a79cebfSGleb Smirnoff IEEE80211_ADDR_COPY(node.macaddr, ieee80211broadcastaddr); 3443692ad7caSAdrian Chadd node.id = WPI_ID_BROADCAST; 3444692ad7caSAdrian Chadd node.plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ? 3445692ad7caSAdrian Chadd wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1]; 3446692ad7caSAdrian Chadd node.action = htole32(WPI_ACTION_SET_RATE); 3447692ad7caSAdrian Chadd node.antenna = WPI_ANTENNA_BOTH; 3448692ad7caSAdrian Chadd 34490528191aSAdrian Chadd DPRINTF(sc, WPI_DEBUG_NODE, "%s: adding broadcast node\n", __func__); 34500528191aSAdrian Chadd 3451692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, async); 3452692ad7caSAdrian Chadd } 3453692ad7caSAdrian Chadd 3454692ad7caSAdrian Chadd static int 34550ebca245SAdrian Chadd wpi_add_sta_node(struct wpi_softc *sc, struct ieee80211_node *ni) 34560ebca245SAdrian Chadd { 34570ebca245SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 34580ebca245SAdrian Chadd int error; 34590ebca245SAdrian Chadd 34600ebca245SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 34610ebca245SAdrian Chadd 34620ebca245SAdrian Chadd wn->id = wpi_add_node_entry_sta(sc); 34630ebca245SAdrian Chadd 34640ebca245SAdrian Chadd if ((error = wpi_add_node(sc, ni)) != 0) { 34650ebca245SAdrian Chadd wpi_del_node_entry(sc, wn->id); 34660ebca245SAdrian Chadd wn->id = WPI_ID_UNDEFINED; 34670ebca245SAdrian Chadd return error; 34680ebca245SAdrian Chadd } 34690ebca245SAdrian Chadd 34700ebca245SAdrian Chadd return 0; 34710ebca245SAdrian Chadd } 34720ebca245SAdrian Chadd 34730ebca245SAdrian Chadd static int 3474692ad7caSAdrian Chadd wpi_add_ibss_node(struct wpi_softc *sc, struct ieee80211_node *ni) 3475692ad7caSAdrian Chadd { 3476a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 3477eca2eb39SAdrian Chadd int error; 3478692ad7caSAdrian Chadd 347939060fa9SAdrian Chadd KASSERT(wn->id == WPI_ID_UNDEFINED, 348039060fa9SAdrian Chadd ("the node %d was added before", wn->id)); 3481692ad7caSAdrian Chadd 348239060fa9SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3483692ad7caSAdrian Chadd 3484eca2eb39SAdrian Chadd if ((wn->id = wpi_add_node_entry_adhoc(sc)) == WPI_ID_UNDEFINED) { 3485eca2eb39SAdrian Chadd device_printf(sc->sc_dev, "%s: h/w table is full\n", __func__); 3486eca2eb39SAdrian Chadd return ENOMEM; 3487eca2eb39SAdrian Chadd } 3488692ad7caSAdrian Chadd 3489eca2eb39SAdrian Chadd if ((error = wpi_add_node(sc, ni)) != 0) { 3490eca2eb39SAdrian Chadd wpi_del_node_entry(sc, wn->id); 3491eca2eb39SAdrian Chadd wn->id = WPI_ID_UNDEFINED; 3492eca2eb39SAdrian Chadd return error; 3493eca2eb39SAdrian Chadd } 3494692ad7caSAdrian Chadd 3495eca2eb39SAdrian Chadd return 0; 3496692ad7caSAdrian Chadd } 3497692ad7caSAdrian Chadd 3498692ad7caSAdrian Chadd static void 3499692ad7caSAdrian Chadd wpi_del_node(struct wpi_softc *sc, struct ieee80211_node *ni) 3500692ad7caSAdrian Chadd { 3501a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 3502692ad7caSAdrian Chadd struct wpi_cmd_del_node node; 3503692ad7caSAdrian Chadd int error; 3504692ad7caSAdrian Chadd 350539060fa9SAdrian Chadd KASSERT(wn->id != WPI_ID_UNDEFINED, ("undefined node id passed")); 3506692ad7caSAdrian Chadd 350739060fa9SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3508692ad7caSAdrian Chadd 3509692ad7caSAdrian Chadd memset(&node, 0, sizeof node); 35103de934a7SAdrian Chadd IEEE80211_ADDR_COPY(node.macaddr, ni->ni_macaddr); 3511692ad7caSAdrian Chadd node.count = 1; 3512692ad7caSAdrian Chadd 35130528191aSAdrian Chadd DPRINTF(sc, WPI_DEBUG_NODE, "%s: deleting node %d (%s)\n", __func__, 35140528191aSAdrian Chadd wn->id, ether_sprintf(ni->ni_macaddr)); 35150528191aSAdrian Chadd 3516692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_DEL_NODE, &node, sizeof node, 1); 3517692ad7caSAdrian Chadd if (error != 0) { 3518692ad7caSAdrian Chadd device_printf(sc->sc_dev, 3519692ad7caSAdrian Chadd "%s: could not delete node %u, error %d\n", __func__, 3520692ad7caSAdrian Chadd wn->id, error); 3521692ad7caSAdrian Chadd } 3522692ad7caSAdrian Chadd } 3523692ad7caSAdrian Chadd 3524692ad7caSAdrian Chadd static int 3525692ad7caSAdrian Chadd wpi_updateedca(struct ieee80211com *ic) 3526692ad7caSAdrian Chadd { 3527692ad7caSAdrian Chadd #define WPI_EXP2(x) ((1 << (x)) - 1) /* CWmin = 2^ECWmin - 1 */ 35282cb71df1SAdrian Chadd struct wpi_softc *sc = ic->ic_softc; 3529692ad7caSAdrian Chadd struct wpi_edca_params cmd; 3530692ad7caSAdrian Chadd int aci, error; 3531692ad7caSAdrian Chadd 3532692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 3533692ad7caSAdrian Chadd 3534692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3535692ad7caSAdrian Chadd cmd.flags = htole32(WPI_EDCA_UPDATE); 3536692ad7caSAdrian Chadd for (aci = 0; aci < WME_NUM_AC; aci++) { 3537692ad7caSAdrian Chadd const struct wmeParams *ac = 3538692ad7caSAdrian Chadd &ic->ic_wme.wme_chanParams.cap_wmeParams[aci]; 3539692ad7caSAdrian Chadd cmd.ac[aci].aifsn = ac->wmep_aifsn; 3540692ad7caSAdrian Chadd cmd.ac[aci].cwmin = htole16(WPI_EXP2(ac->wmep_logcwmin)); 3541692ad7caSAdrian Chadd cmd.ac[aci].cwmax = htole16(WPI_EXP2(ac->wmep_logcwmax)); 3542692ad7caSAdrian Chadd cmd.ac[aci].txoplimit = 3543692ad7caSAdrian Chadd htole16(IEEE80211_TXOP_TO_US(ac->wmep_txopLimit)); 3544692ad7caSAdrian Chadd 3545692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EDCA, 3546692ad7caSAdrian Chadd "setting WME for queue %d aifsn=%d cwmin=%d cwmax=%d " 3547692ad7caSAdrian Chadd "txoplimit=%d\n", aci, cmd.ac[aci].aifsn, 3548692ad7caSAdrian Chadd cmd.ac[aci].cwmin, cmd.ac[aci].cwmax, 3549692ad7caSAdrian Chadd cmd.ac[aci].txoplimit); 3550692ad7caSAdrian Chadd } 3551692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_EDCA_PARAMS, &cmd, sizeof cmd, 1); 3552692ad7caSAdrian Chadd 3553692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 3554692ad7caSAdrian Chadd 3555692ad7caSAdrian Chadd return error; 3556692ad7caSAdrian Chadd #undef WPI_EXP2 3557692ad7caSAdrian Chadd } 3558692ad7caSAdrian Chadd 3559692ad7caSAdrian Chadd static void 3560692ad7caSAdrian Chadd wpi_set_promisc(struct wpi_softc *sc) 3561692ad7caSAdrian Chadd { 35627a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 3563726ddc26SAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 3564692ad7caSAdrian Chadd uint32_t promisc_filter; 3565692ad7caSAdrian Chadd 3566726ddc26SAdrian Chadd promisc_filter = WPI_FILTER_CTL; 3567726ddc26SAdrian Chadd if (vap != NULL && vap->iv_opmode != IEEE80211_M_HOSTAP) 3568726ddc26SAdrian Chadd promisc_filter |= WPI_FILTER_PROMISC; 3569692ad7caSAdrian Chadd 35707a79cebfSGleb Smirnoff if (ic->ic_promisc > 0) 3571692ad7caSAdrian Chadd sc->rxon.filter |= htole32(promisc_filter); 3572692ad7caSAdrian Chadd else 3573692ad7caSAdrian Chadd sc->rxon.filter &= ~htole32(promisc_filter); 3574692ad7caSAdrian Chadd } 3575692ad7caSAdrian Chadd 3576692ad7caSAdrian Chadd static void 3577272f6adeSGleb Smirnoff wpi_update_promisc(struct ieee80211com *ic) 3578692ad7caSAdrian Chadd { 3579272f6adeSGleb Smirnoff struct wpi_softc *sc = ic->ic_softc; 3580692ad7caSAdrian Chadd 358154b27b35SAndriy Voskoboinyk WPI_LOCK(sc); 358254b27b35SAndriy Voskoboinyk if (sc->sc_running == 0) { 358354b27b35SAndriy Voskoboinyk WPI_UNLOCK(sc); 358454b27b35SAndriy Voskoboinyk return; 358554b27b35SAndriy Voskoboinyk } 358654b27b35SAndriy Voskoboinyk WPI_UNLOCK(sc); 358754b27b35SAndriy Voskoboinyk 3588446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 3589692ad7caSAdrian Chadd wpi_set_promisc(sc); 3590692ad7caSAdrian Chadd 3591692ad7caSAdrian Chadd if (wpi_send_rxon(sc, 1, 1) != 0) { 3592692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not send RXON\n", 3593692ad7caSAdrian Chadd __func__); 3594692ad7caSAdrian Chadd } 3595446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 3596692ad7caSAdrian Chadd } 3597692ad7caSAdrian Chadd 3598692ad7caSAdrian Chadd static void 3599272f6adeSGleb Smirnoff wpi_update_mcast(struct ieee80211com *ic) 3600692ad7caSAdrian Chadd { 3601692ad7caSAdrian Chadd /* Ignore */ 3602692ad7caSAdrian Chadd } 3603692ad7caSAdrian Chadd 36046607310bSBenjamin Close static void 36056607310bSBenjamin Close wpi_set_led(struct wpi_softc *sc, uint8_t which, uint8_t off, uint8_t on) 36066607310bSBenjamin Close { 36076607310bSBenjamin Close struct wpi_cmd_led led; 36086607310bSBenjamin Close 3609692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3610692ad7caSAdrian Chadd 36116607310bSBenjamin Close led.which = which; 36126607310bSBenjamin Close led.unit = htole32(100000); /* on/off in unit of 100ms */ 36136607310bSBenjamin Close led.off = off; 36146607310bSBenjamin Close led.on = on; 36156607310bSBenjamin Close (void)wpi_cmd(sc, WPI_CMD_SET_LED, &led, sizeof led, 1); 36166607310bSBenjamin Close } 36176607310bSBenjamin Close 3618692ad7caSAdrian Chadd static int 3619692ad7caSAdrian Chadd wpi_set_timing(struct wpi_softc *sc, struct ieee80211_node *ni) 36206607310bSBenjamin Close { 3621692ad7caSAdrian Chadd struct wpi_cmd_timing cmd; 36226607310bSBenjamin Close uint64_t val, mod; 36236607310bSBenjamin Close 3624692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 36256607310bSBenjamin Close 3626692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3627692ad7caSAdrian Chadd memcpy(&cmd.tstamp, ni->ni_tstamp.data, sizeof (uint64_t)); 3628692ad7caSAdrian Chadd cmd.bintval = htole16(ni->ni_intval); 3629692ad7caSAdrian Chadd cmd.lintval = htole16(10); 36306607310bSBenjamin Close 3631692ad7caSAdrian Chadd /* Compute remaining time until next beacon. */ 3632692ad7caSAdrian Chadd val = (uint64_t)ni->ni_intval * IEEE80211_DUR_TU; 3633692ad7caSAdrian Chadd mod = le64toh(cmd.tstamp) % val; 3634692ad7caSAdrian Chadd cmd.binitval = htole32((uint32_t)(val - mod)); 36356607310bSBenjamin Close 3636692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RESET, "timing bintval=%u tstamp=%ju, init=%u\n", 3637692ad7caSAdrian Chadd ni->ni_intval, le64toh(cmd.tstamp), (uint32_t)(val - mod)); 36386607310bSBenjamin Close 3639692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_TIMING, &cmd, sizeof cmd, 1); 36406607310bSBenjamin Close } 36416607310bSBenjamin Close 36426607310bSBenjamin Close /* 3643692ad7caSAdrian Chadd * This function is called periodically (every 60 seconds) to adjust output 3644692ad7caSAdrian Chadd * power to temperature changes. 3645692ad7caSAdrian Chadd */ 3646692ad7caSAdrian Chadd static void 3647692ad7caSAdrian Chadd wpi_power_calibration(struct wpi_softc *sc) 3648692ad7caSAdrian Chadd { 3649692ad7caSAdrian Chadd int temp; 3650692ad7caSAdrian Chadd 3651692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3652692ad7caSAdrian Chadd 3653692ad7caSAdrian Chadd /* Update sensor data. */ 3654692ad7caSAdrian Chadd temp = (int)WPI_READ(sc, WPI_UCODE_GP2); 3655692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, "Temp in calibration is: %d\n", temp); 3656692ad7caSAdrian Chadd 3657692ad7caSAdrian Chadd /* Sanity-check read value. */ 3658692ad7caSAdrian Chadd if (temp < -260 || temp > 25) { 3659692ad7caSAdrian Chadd /* This can't be correct, ignore. */ 3660692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, 3661692ad7caSAdrian Chadd "out-of-range temperature reported: %d\n", temp); 3662692ad7caSAdrian Chadd return; 3663692ad7caSAdrian Chadd } 3664692ad7caSAdrian Chadd 3665692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, "temperature %d->%d\n", sc->temp, temp); 3666692ad7caSAdrian Chadd 3667692ad7caSAdrian Chadd /* Adjust Tx power if need be. */ 3668692ad7caSAdrian Chadd if (abs(temp - sc->temp) <= 6) 3669692ad7caSAdrian Chadd return; 3670692ad7caSAdrian Chadd 3671692ad7caSAdrian Chadd sc->temp = temp; 3672692ad7caSAdrian Chadd 3673692ad7caSAdrian Chadd if (wpi_set_txpower(sc, 1) != 0) { 3674692ad7caSAdrian Chadd /* just warn, too bad for the automatic calibration... */ 3675692ad7caSAdrian Chadd device_printf(sc->sc_dev,"could not adjust Tx power\n"); 3676692ad7caSAdrian Chadd } 3677692ad7caSAdrian Chadd } 3678692ad7caSAdrian Chadd 3679692ad7caSAdrian Chadd /* 3680692ad7caSAdrian Chadd * Set TX power for current channel. 36816607310bSBenjamin Close */ 36826607310bSBenjamin Close static int 3683692ad7caSAdrian Chadd wpi_set_txpower(struct wpi_softc *sc, int async) 36846607310bSBenjamin Close { 3685692ad7caSAdrian Chadd struct wpi_power_group *group; 3686692ad7caSAdrian Chadd struct wpi_cmd_txpower cmd; 3687692ad7caSAdrian Chadd uint8_t chan; 3688655e8ba8SAdrian Chadd int idx, is_chan_5ghz, i; 36896607310bSBenjamin Close 3690692ad7caSAdrian Chadd /* Retrieve current channel from last RXON. */ 3691692ad7caSAdrian Chadd chan = sc->rxon.chan; 3692655e8ba8SAdrian Chadd is_chan_5ghz = (sc->rxon.flags & htole32(WPI_RXON_24GHZ)) == 0; 36936607310bSBenjamin Close 3694692ad7caSAdrian Chadd /* Find the TX power group to which this channel belongs. */ 3695655e8ba8SAdrian Chadd if (is_chan_5ghz) { 3696692ad7caSAdrian Chadd for (group = &sc->groups[1]; group < &sc->groups[4]; group++) 3697692ad7caSAdrian Chadd if (chan <= group->chan) 3698692ad7caSAdrian Chadd break; 3699692ad7caSAdrian Chadd } else 3700692ad7caSAdrian Chadd group = &sc->groups[0]; 3701692ad7caSAdrian Chadd 3702692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3703655e8ba8SAdrian Chadd cmd.band = is_chan_5ghz ? WPI_BAND_5GHZ : WPI_BAND_2GHZ; 3704692ad7caSAdrian Chadd cmd.chan = htole16(chan); 3705692ad7caSAdrian Chadd 3706692ad7caSAdrian Chadd /* Set TX power for all OFDM and CCK rates. */ 3707692ad7caSAdrian Chadd for (i = 0; i <= WPI_RIDX_MAX ; i++) { 3708692ad7caSAdrian Chadd /* Retrieve TX power for this channel/rate. */ 3709655e8ba8SAdrian Chadd idx = wpi_get_power_index(sc, group, chan, is_chan_5ghz, i); 3710692ad7caSAdrian Chadd 3711692ad7caSAdrian Chadd cmd.rates[i].plcp = wpi_ridx_to_plcp[i]; 3712692ad7caSAdrian Chadd 3713655e8ba8SAdrian Chadd if (is_chan_5ghz) { 3714692ad7caSAdrian Chadd cmd.rates[i].rf_gain = wpi_rf_gain_5ghz[idx]; 3715692ad7caSAdrian Chadd cmd.rates[i].dsp_gain = wpi_dsp_gain_5ghz[idx]; 3716692ad7caSAdrian Chadd } else { 3717692ad7caSAdrian Chadd cmd.rates[i].rf_gain = wpi_rf_gain_2ghz[idx]; 3718692ad7caSAdrian Chadd cmd.rates[i].dsp_gain = wpi_dsp_gain_2ghz[idx]; 3719692ad7caSAdrian Chadd } 3720692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, 3721692ad7caSAdrian Chadd "chan %d/ridx %d: power index %d\n", chan, i, idx); 3722692ad7caSAdrian Chadd } 3723692ad7caSAdrian Chadd 3724692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_TXPOWER, &cmd, sizeof cmd, async); 3725692ad7caSAdrian Chadd } 3726692ad7caSAdrian Chadd 3727692ad7caSAdrian Chadd /* 3728692ad7caSAdrian Chadd * Determine Tx power index for a given channel/rate combination. 3729692ad7caSAdrian Chadd * This takes into account the regulatory information from EEPROM and the 3730692ad7caSAdrian Chadd * current temperature. 3731692ad7caSAdrian Chadd */ 3732692ad7caSAdrian Chadd static int 3733692ad7caSAdrian Chadd wpi_get_power_index(struct wpi_softc *sc, struct wpi_power_group *group, 3734655e8ba8SAdrian Chadd uint8_t chan, int is_chan_5ghz, int ridx) 3735692ad7caSAdrian Chadd { 3736692ad7caSAdrian Chadd /* Fixed-point arithmetic division using a n-bit fractional part. */ 3737692ad7caSAdrian Chadd #define fdivround(a, b, n) \ 3738692ad7caSAdrian Chadd ((((1 << n) * (a)) / (b) + (1 << n) / 2) / (1 << n)) 3739692ad7caSAdrian Chadd 3740692ad7caSAdrian Chadd /* Linear interpolation. */ 3741692ad7caSAdrian Chadd #define interpolate(x, x1, y1, x2, y2, n) \ 3742692ad7caSAdrian Chadd ((y1) + fdivround(((x) - (x1)) * ((y2) - (y1)), (x2) - (x1), n)) 3743692ad7caSAdrian Chadd 3744692ad7caSAdrian Chadd struct wpi_power_sample *sample; 3745692ad7caSAdrian Chadd int pwr, idx; 3746692ad7caSAdrian Chadd 3747692ad7caSAdrian Chadd /* Default TX power is group maximum TX power minus 3dB. */ 3748692ad7caSAdrian Chadd pwr = group->maxpwr / 2; 3749692ad7caSAdrian Chadd 3750692ad7caSAdrian Chadd /* Decrease TX power for highest OFDM rates to reduce distortion. */ 3751692ad7caSAdrian Chadd switch (ridx) { 3752692ad7caSAdrian Chadd case WPI_RIDX_OFDM36: 3753655e8ba8SAdrian Chadd pwr -= is_chan_5ghz ? 5 : 0; 3754692ad7caSAdrian Chadd break; 3755692ad7caSAdrian Chadd case WPI_RIDX_OFDM48: 3756655e8ba8SAdrian Chadd pwr -= is_chan_5ghz ? 10 : 7; 3757692ad7caSAdrian Chadd break; 3758692ad7caSAdrian Chadd case WPI_RIDX_OFDM54: 3759655e8ba8SAdrian Chadd pwr -= is_chan_5ghz ? 12 : 9; 3760692ad7caSAdrian Chadd break; 3761692ad7caSAdrian Chadd } 3762692ad7caSAdrian Chadd 3763692ad7caSAdrian Chadd /* Never exceed the channel maximum allowed TX power. */ 3764692ad7caSAdrian Chadd pwr = min(pwr, sc->maxpwr[chan]); 3765692ad7caSAdrian Chadd 3766692ad7caSAdrian Chadd /* Retrieve TX power index into gain tables from samples. */ 3767692ad7caSAdrian Chadd for (sample = group->samples; sample < &group->samples[3]; sample++) 3768692ad7caSAdrian Chadd if (pwr > sample[1].power) 3769692ad7caSAdrian Chadd break; 3770692ad7caSAdrian Chadd /* Fixed-point linear interpolation using a 19-bit fractional part. */ 3771692ad7caSAdrian Chadd idx = interpolate(pwr, sample[0].power, sample[0].index, 3772692ad7caSAdrian Chadd sample[1].power, sample[1].index, 19); 3773692ad7caSAdrian Chadd 3774692ad7caSAdrian Chadd /*- 3775692ad7caSAdrian Chadd * Adjust power index based on current temperature: 3776692ad7caSAdrian Chadd * - if cooler than factory-calibrated: decrease output power 3777692ad7caSAdrian Chadd * - if warmer than factory-calibrated: increase output power 3778692ad7caSAdrian Chadd */ 3779692ad7caSAdrian Chadd idx -= (sc->temp - group->temp) * 11 / 100; 3780692ad7caSAdrian Chadd 3781692ad7caSAdrian Chadd /* Decrease TX power for CCK rates (-5dB). */ 3782692ad7caSAdrian Chadd if (ridx >= WPI_RIDX_CCK1) 3783692ad7caSAdrian Chadd idx += 10; 3784692ad7caSAdrian Chadd 3785692ad7caSAdrian Chadd /* Make sure idx stays in a valid range. */ 3786692ad7caSAdrian Chadd if (idx < 0) 3787692ad7caSAdrian Chadd return 0; 3788692ad7caSAdrian Chadd if (idx > WPI_MAX_PWR_INDEX) 3789692ad7caSAdrian Chadd return WPI_MAX_PWR_INDEX; 3790692ad7caSAdrian Chadd return idx; 3791692ad7caSAdrian Chadd 3792692ad7caSAdrian Chadd #undef interpolate 3793692ad7caSAdrian Chadd #undef fdivround 3794692ad7caSAdrian Chadd } 3795692ad7caSAdrian Chadd 3796692ad7caSAdrian Chadd /* 3797692ad7caSAdrian Chadd * Set STA mode power saving level (between 0 and 5). 3798692ad7caSAdrian Chadd * Level 0 is CAM (Continuously Aware Mode), 5 is for maximum power saving. 3799692ad7caSAdrian Chadd */ 3800692ad7caSAdrian Chadd static int 3801692ad7caSAdrian Chadd wpi_set_pslevel(struct wpi_softc *sc, uint8_t dtim, int level, int async) 3802692ad7caSAdrian Chadd { 3803692ad7caSAdrian Chadd struct wpi_pmgt_cmd cmd; 3804692ad7caSAdrian Chadd const struct wpi_pmgt *pmgt; 3805525a3d47SAdrian Chadd uint32_t max, reg; 3806525a3d47SAdrian Chadd uint8_t skip_dtim; 3807692ad7caSAdrian Chadd int i; 3808692ad7caSAdrian Chadd 3809692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_PWRSAVE, 3810692ad7caSAdrian Chadd "%s: dtim=%d, level=%d, async=%d\n", 3811692ad7caSAdrian Chadd __func__, dtim, level, async); 3812692ad7caSAdrian Chadd 3813692ad7caSAdrian Chadd /* Select which PS parameters to use. */ 3814692ad7caSAdrian Chadd if (dtim <= 10) 3815692ad7caSAdrian Chadd pmgt = &wpi_pmgt[0][level]; 3816692ad7caSAdrian Chadd else 3817692ad7caSAdrian Chadd pmgt = &wpi_pmgt[1][level]; 3818692ad7caSAdrian Chadd 3819692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3820c34db420SAdrian Chadd if (level != 0) /* not CAM */ 3821692ad7caSAdrian Chadd cmd.flags |= htole16(WPI_PS_ALLOW_SLEEP); 3822692ad7caSAdrian Chadd /* Retrieve PCIe Active State Power Management (ASPM). */ 38237c2e8d33SAndriy Voskoboinyk reg = pci_read_config(sc->sc_dev, sc->sc_cap_off + PCIER_LINK_CTL, 1); 38247c2e8d33SAndriy Voskoboinyk if (!(reg & PCIEM_LINK_CTL_ASPMC_L0S)) /* L0s Entry disabled. */ 3825692ad7caSAdrian Chadd cmd.flags |= htole16(WPI_PS_PCI_PMGT); 3826692ad7caSAdrian Chadd 3827692ad7caSAdrian Chadd cmd.rxtimeout = htole32(pmgt->rxtimeout * IEEE80211_DUR_TU); 3828692ad7caSAdrian Chadd cmd.txtimeout = htole32(pmgt->txtimeout * IEEE80211_DUR_TU); 3829692ad7caSAdrian Chadd 3830692ad7caSAdrian Chadd if (dtim == 0) { 3831692ad7caSAdrian Chadd dtim = 1; 3832692ad7caSAdrian Chadd skip_dtim = 0; 3833692ad7caSAdrian Chadd } else 3834692ad7caSAdrian Chadd skip_dtim = pmgt->skip_dtim; 3835692ad7caSAdrian Chadd 3836692ad7caSAdrian Chadd if (skip_dtim != 0) { 3837692ad7caSAdrian Chadd cmd.flags |= htole16(WPI_PS_SLEEP_OVER_DTIM); 3838692ad7caSAdrian Chadd max = pmgt->intval[4]; 3839692ad7caSAdrian Chadd if (max == (uint32_t)-1) 3840692ad7caSAdrian Chadd max = dtim * (skip_dtim + 1); 3841692ad7caSAdrian Chadd else if (max > dtim) 38424ed3c0e7SPedro F. Giffuni max = rounddown(max, dtim); 3843692ad7caSAdrian Chadd } else 3844692ad7caSAdrian Chadd max = dtim; 3845692ad7caSAdrian Chadd 3846692ad7caSAdrian Chadd for (i = 0; i < 5; i++) 3847692ad7caSAdrian Chadd cmd.intval[i] = htole32(MIN(max, pmgt->intval[i])); 3848692ad7caSAdrian Chadd 3849692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_SET_POWER_MODE, &cmd, sizeof cmd, async); 3850692ad7caSAdrian Chadd } 3851692ad7caSAdrian Chadd 3852692ad7caSAdrian Chadd static int 3853692ad7caSAdrian Chadd wpi_send_btcoex(struct wpi_softc *sc) 3854692ad7caSAdrian Chadd { 3855692ad7caSAdrian Chadd struct wpi_bluetooth cmd; 3856692ad7caSAdrian Chadd 3857692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3858692ad7caSAdrian Chadd cmd.flags = WPI_BT_COEX_MODE_4WIRE; 3859692ad7caSAdrian Chadd cmd.lead_time = WPI_BT_LEAD_TIME_DEF; 3860692ad7caSAdrian Chadd cmd.max_kill = WPI_BT_MAX_KILL_DEF; 3861692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RESET, "%s: configuring bluetooth coexistence\n", 3862692ad7caSAdrian Chadd __func__); 3863692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_BT_COEX, &cmd, sizeof(cmd), 0); 3864692ad7caSAdrian Chadd } 3865692ad7caSAdrian Chadd 3866692ad7caSAdrian Chadd static int 3867692ad7caSAdrian Chadd wpi_send_rxon(struct wpi_softc *sc, int assoc, int async) 3868692ad7caSAdrian Chadd { 3869692ad7caSAdrian Chadd int error; 3870692ad7caSAdrian Chadd 3871446685e4SAdrian Chadd if (async) 3872446685e4SAdrian Chadd WPI_RXON_LOCK_ASSERT(sc); 3873446685e4SAdrian Chadd 3874621f1a75SAdrian Chadd if (assoc && wpi_check_bss_filter(sc) != 0) { 3875692ad7caSAdrian Chadd struct wpi_assoc rxon_assoc; 3876692ad7caSAdrian Chadd 3877692ad7caSAdrian Chadd rxon_assoc.flags = sc->rxon.flags; 3878692ad7caSAdrian Chadd rxon_assoc.filter = sc->rxon.filter; 3879692ad7caSAdrian Chadd rxon_assoc.ofdm_mask = sc->rxon.ofdm_mask; 3880692ad7caSAdrian Chadd rxon_assoc.cck_mask = sc->rxon.cck_mask; 3881692ad7caSAdrian Chadd rxon_assoc.reserved = 0; 3882692ad7caSAdrian Chadd 3883692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_RXON_ASSOC, &rxon_assoc, 3884692ad7caSAdrian Chadd sizeof (struct wpi_assoc), async); 3885cfe9b1ceSAdrian Chadd if (error != 0) { 3886cfe9b1ceSAdrian Chadd device_printf(sc->sc_dev, 3887cfe9b1ceSAdrian Chadd "RXON_ASSOC command failed, error %d\n", error); 3888cfe9b1ceSAdrian Chadd return error; 3889cfe9b1ceSAdrian Chadd } 3890692ad7caSAdrian Chadd } else { 3891cfe9b1ceSAdrian Chadd if (async) { 38927964dd56SAdrian Chadd WPI_NT_LOCK(sc); 3893692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_RXON, &sc->rxon, 3894692ad7caSAdrian Chadd sizeof (struct wpi_rxon), async); 3895cfe9b1ceSAdrian Chadd if (error == 0) 3896eca2eb39SAdrian Chadd wpi_clear_node_table(sc); 38977964dd56SAdrian Chadd WPI_NT_UNLOCK(sc); 3898cfe9b1ceSAdrian Chadd } else { 3899cfe9b1ceSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_RXON, &sc->rxon, 3900cfe9b1ceSAdrian Chadd sizeof (struct wpi_rxon), async); 3901cfe9b1ceSAdrian Chadd if (error == 0) 3902cfe9b1ceSAdrian Chadd wpi_clear_node_table(sc); 3903692ad7caSAdrian Chadd } 3904cfe9b1ceSAdrian Chadd 3905692ad7caSAdrian Chadd if (error != 0) { 39066607310bSBenjamin Close device_printf(sc->sc_dev, 3907cfe9b1ceSAdrian Chadd "RXON command failed, error %d\n", error); 39086607310bSBenjamin Close return error; 39096607310bSBenjamin Close } 39106607310bSBenjamin Close 3911692ad7caSAdrian Chadd /* Add broadcast node. */ 3912692ad7caSAdrian Chadd error = wpi_add_broadcast_node(sc, async); 3913692ad7caSAdrian Chadd if (error != 0) { 3914692ad7caSAdrian Chadd device_printf(sc->sc_dev, 3915692ad7caSAdrian Chadd "could not add broadcast node, error %d\n", error); 3916692ad7caSAdrian Chadd return error; 3917692ad7caSAdrian Chadd } 3918692ad7caSAdrian Chadd } 39196607310bSBenjamin Close 3920cfe9b1ceSAdrian Chadd /* Configuration has changed, set Tx power accordingly. */ 3921cfe9b1ceSAdrian Chadd if ((error = wpi_set_txpower(sc, async)) != 0) { 3922cfe9b1ceSAdrian Chadd device_printf(sc->sc_dev, 3923cfe9b1ceSAdrian Chadd "%s: could not set TX power, error %d\n", __func__, error); 3924cfe9b1ceSAdrian Chadd return error; 3925cfe9b1ceSAdrian Chadd } 3926cfe9b1ceSAdrian Chadd 3927692ad7caSAdrian Chadd return 0; 39286607310bSBenjamin Close } 39296607310bSBenjamin Close 39306607310bSBenjamin Close /** 39316607310bSBenjamin Close * Configure the card to listen to a particular channel, this transisions the 39326607310bSBenjamin Close * card in to being able to receive frames from remote devices. 39336607310bSBenjamin Close */ 39346607310bSBenjamin Close static int 39356607310bSBenjamin Close wpi_config(struct wpi_softc *sc) 39366607310bSBenjamin Close { 39377a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 39383de934a7SAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 39396b997e0cSAdrian Chadd struct ieee80211_channel *c = ic->ic_curchan; 39406607310bSBenjamin Close int error; 39416607310bSBenjamin Close 3942692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 3943692ad7caSAdrian Chadd 3944692ad7caSAdrian Chadd /* Set power saving level to CAM during initialization. */ 3945692ad7caSAdrian Chadd if ((error = wpi_set_pslevel(sc, 0, 0, 0)) != 0) { 3946692ad7caSAdrian Chadd device_printf(sc->sc_dev, 3947692ad7caSAdrian Chadd "%s: could not set power saving level\n", __func__); 39486607310bSBenjamin Close return error; 39496607310bSBenjamin Close } 39506607310bSBenjamin Close 3951692ad7caSAdrian Chadd /* Configure bluetooth coexistence. */ 3952692ad7caSAdrian Chadd if ((error = wpi_send_btcoex(sc)) != 0) { 39536607310bSBenjamin Close device_printf(sc->sc_dev, 39546607310bSBenjamin Close "could not configure bluetooth coexistence\n"); 39556607310bSBenjamin Close return error; 39566607310bSBenjamin Close } 39576607310bSBenjamin Close 3958692ad7caSAdrian Chadd /* Configure adapter. */ 3959692ad7caSAdrian Chadd memset(&sc->rxon, 0, sizeof (struct wpi_rxon)); 39603de934a7SAdrian Chadd IEEE80211_ADDR_COPY(sc->rxon.myaddr, vap->iv_myaddr); 3961692ad7caSAdrian Chadd 3962692ad7caSAdrian Chadd /* Set default channel. */ 39636b997e0cSAdrian Chadd sc->rxon.chan = ieee80211_chan2ieee(ic, c); 3964692ad7caSAdrian Chadd sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF); 39656b997e0cSAdrian Chadd if (IEEE80211_IS_CHAN_2GHZ(c)) 3966692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ); 3967692ad7caSAdrian Chadd 3968fae61c69SAdrian Chadd sc->rxon.filter = WPI_FILTER_MULTICAST; 39696607310bSBenjamin Close switch (ic->ic_opmode) { 39706607310bSBenjamin Close case IEEE80211_M_STA: 3971692ad7caSAdrian Chadd sc->rxon.mode = WPI_MODE_STA; 39726607310bSBenjamin Close break; 39736607310bSBenjamin Close case IEEE80211_M_IBSS: 3974692ad7caSAdrian Chadd sc->rxon.mode = WPI_MODE_IBSS; 3975fae61c69SAdrian Chadd sc->rxon.filter |= WPI_FILTER_BEACON; 39766607310bSBenjamin Close break; 39776607310bSBenjamin Close case IEEE80211_M_HOSTAP: 3978726ddc26SAdrian Chadd /* XXX workaround for beaconing */ 3979726ddc26SAdrian Chadd sc->rxon.mode = WPI_MODE_IBSS; 3980726ddc26SAdrian Chadd sc->rxon.filter |= WPI_FILTER_ASSOC | WPI_FILTER_PROMISC; 3981726ddc26SAdrian Chadd break; 3982726ddc26SAdrian Chadd case IEEE80211_M_AHDEMO: 3983692ad7caSAdrian Chadd sc->rxon.mode = WPI_MODE_HOSTAP; 39846607310bSBenjamin Close break; 39856607310bSBenjamin Close case IEEE80211_M_MONITOR: 3986692ad7caSAdrian Chadd sc->rxon.mode = WPI_MODE_MONITOR; 39876607310bSBenjamin Close break; 3988820e6a1fSRui Paulo default: 39897167f5fcSAdrian Chadd device_printf(sc->sc_dev, "unknown opmode %d\n", 39907167f5fcSAdrian Chadd ic->ic_opmode); 3991820e6a1fSRui Paulo return EINVAL; 39926607310bSBenjamin Close } 3993fae61c69SAdrian Chadd sc->rxon.filter = htole32(sc->rxon.filter); 3994692ad7caSAdrian Chadd wpi_set_promisc(sc); 3995692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x0f; /* not yet negotiated */ 3996692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0xff; /* not yet negotiated */ 3997692ad7caSAdrian Chadd 3998692ad7caSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 0)) != 0) { 3999692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not send RXON\n", 4000692ad7caSAdrian Chadd __func__); 4001692ad7caSAdrian Chadd return error; 4002692ad7caSAdrian Chadd } 4003692ad7caSAdrian Chadd 4004692ad7caSAdrian Chadd /* Setup rate scalling. */ 4005692ad7caSAdrian Chadd if ((error = wpi_mrr_setup(sc)) != 0) { 4006692ad7caSAdrian Chadd device_printf(sc->sc_dev, "could not setup MRR, error %d\n", 4007692ad7caSAdrian Chadd error); 4008692ad7caSAdrian Chadd return error; 4009692ad7caSAdrian Chadd } 4010692ad7caSAdrian Chadd 4011692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 4012692ad7caSAdrian Chadd 4013692ad7caSAdrian Chadd return 0; 4014692ad7caSAdrian Chadd } 4015692ad7caSAdrian Chadd 4016692ad7caSAdrian Chadd static uint16_t 4017692ad7caSAdrian Chadd wpi_get_active_dwell_time(struct wpi_softc *sc, 4018692ad7caSAdrian Chadd struct ieee80211_channel *c, uint8_t n_probes) 4019692ad7caSAdrian Chadd { 4020692ad7caSAdrian Chadd /* No channel? Default to 2GHz settings. */ 4021692ad7caSAdrian Chadd if (c == NULL || IEEE80211_IS_CHAN_2GHZ(c)) { 4022692ad7caSAdrian Chadd return (WPI_ACTIVE_DWELL_TIME_2GHZ + 4023692ad7caSAdrian Chadd WPI_ACTIVE_DWELL_FACTOR_2GHZ * (n_probes + 1)); 4024692ad7caSAdrian Chadd } 4025692ad7caSAdrian Chadd 4026692ad7caSAdrian Chadd /* 5GHz dwell time. */ 4027692ad7caSAdrian Chadd return (WPI_ACTIVE_DWELL_TIME_5GHZ + 4028692ad7caSAdrian Chadd WPI_ACTIVE_DWELL_FACTOR_5GHZ * (n_probes + 1)); 4029692ad7caSAdrian Chadd } 4030692ad7caSAdrian Chadd 4031692ad7caSAdrian Chadd /* 403242946b7dSAdrian Chadd * Limit the total dwell time. 4033692ad7caSAdrian Chadd * 4034692ad7caSAdrian Chadd * Returns the dwell time in milliseconds. 4035692ad7caSAdrian Chadd */ 4036692ad7caSAdrian Chadd static uint16_t 4037692ad7caSAdrian Chadd wpi_limit_dwell(struct wpi_softc *sc, uint16_t dwell_time) 4038692ad7caSAdrian Chadd { 40397a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 40407d4ee533SAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 4041525a3d47SAdrian Chadd uint16_t bintval = 0; 4042692ad7caSAdrian Chadd 4043692ad7caSAdrian Chadd /* bintval is in TU (1.024mS) */ 40447d4ee533SAdrian Chadd if (vap != NULL) 4045692ad7caSAdrian Chadd bintval = vap->iv_bss->ni_intval; 4046692ad7caSAdrian Chadd 4047692ad7caSAdrian Chadd /* 4048692ad7caSAdrian Chadd * If it's non-zero, we should calculate the minimum of 4049692ad7caSAdrian Chadd * it and the DWELL_BASE. 4050692ad7caSAdrian Chadd * 4051692ad7caSAdrian Chadd * XXX Yes, the math should take into account that bintval 4052692ad7caSAdrian Chadd * is 1.024mS, not 1mS.. 4053692ad7caSAdrian Chadd */ 4054692ad7caSAdrian Chadd if (bintval > 0) { 4055692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_SCAN, "%s: bintval=%d\n", __func__, 4056692ad7caSAdrian Chadd bintval); 405742946b7dSAdrian Chadd return (MIN(dwell_time, bintval - WPI_CHANNEL_TUNE_TIME * 2)); 4058692ad7caSAdrian Chadd } 4059692ad7caSAdrian Chadd 4060692ad7caSAdrian Chadd /* No association context? Default. */ 406142946b7dSAdrian Chadd return dwell_time; 4062692ad7caSAdrian Chadd } 4063692ad7caSAdrian Chadd 4064692ad7caSAdrian Chadd static uint16_t 4065692ad7caSAdrian Chadd wpi_get_passive_dwell_time(struct wpi_softc *sc, struct ieee80211_channel *c) 4066692ad7caSAdrian Chadd { 4067692ad7caSAdrian Chadd uint16_t passive; 4068692ad7caSAdrian Chadd 4069692ad7caSAdrian Chadd if (c == NULL || IEEE80211_IS_CHAN_2GHZ(c)) 4070692ad7caSAdrian Chadd passive = WPI_PASSIVE_DWELL_BASE + WPI_PASSIVE_DWELL_TIME_2GHZ; 4071692ad7caSAdrian Chadd else 4072692ad7caSAdrian Chadd passive = WPI_PASSIVE_DWELL_BASE + WPI_PASSIVE_DWELL_TIME_5GHZ; 4073692ad7caSAdrian Chadd 4074692ad7caSAdrian Chadd /* Clamp to the beacon interval if we're associated. */ 4075692ad7caSAdrian Chadd return (wpi_limit_dwell(sc, passive)); 4076692ad7caSAdrian Chadd } 4077692ad7caSAdrian Chadd 4078efccc3c6SAdrian Chadd static uint32_t 4079efccc3c6SAdrian Chadd wpi_get_scan_pause_time(uint32_t time, uint16_t bintval) 4080efccc3c6SAdrian Chadd { 4081efccc3c6SAdrian Chadd uint32_t mod = (time % bintval) * IEEE80211_DUR_TU; 4082efccc3c6SAdrian Chadd uint32_t nbeacons = time / bintval; 4083efccc3c6SAdrian Chadd 4084efccc3c6SAdrian Chadd if (mod > WPI_PAUSE_MAX_TIME) 4085efccc3c6SAdrian Chadd mod = WPI_PAUSE_MAX_TIME; 4086efccc3c6SAdrian Chadd 4087efccc3c6SAdrian Chadd return WPI_PAUSE_SCAN(nbeacons, mod); 4088efccc3c6SAdrian Chadd } 4089efccc3c6SAdrian Chadd 4090692ad7caSAdrian Chadd /* 4091692ad7caSAdrian Chadd * Send a scan request to the firmware. 4092692ad7caSAdrian Chadd */ 4093692ad7caSAdrian Chadd static int 4094692ad7caSAdrian Chadd wpi_scan(struct wpi_softc *sc, struct ieee80211_channel *c) 4095692ad7caSAdrian Chadd { 40967a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 4097692ad7caSAdrian Chadd struct ieee80211_scan_state *ss = ic->ic_scan; 40983de934a7SAdrian Chadd struct ieee80211vap *vap = ss->ss_vap; 4099692ad7caSAdrian Chadd struct wpi_scan_hdr *hdr; 4100692ad7caSAdrian Chadd struct wpi_cmd_data *tx; 4101692ad7caSAdrian Chadd struct wpi_scan_essid *essids; 4102692ad7caSAdrian Chadd struct wpi_scan_chan *chan; 4103692ad7caSAdrian Chadd struct ieee80211_frame *wh; 4104692ad7caSAdrian Chadd struct ieee80211_rateset *rs; 4105525a3d47SAdrian Chadd uint16_t bintval, buflen, dwell_active, dwell_passive; 4106525a3d47SAdrian Chadd uint8_t *buf, *frm, i, nssid; 4107525a3d47SAdrian Chadd int bgscan, error; 4108692ad7caSAdrian Chadd 4109692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 4110692ad7caSAdrian Chadd 4111692ad7caSAdrian Chadd /* 4112692ad7caSAdrian Chadd * We are absolutely not allowed to send a scan command when another 4113692ad7caSAdrian Chadd * scan command is pending. 4114692ad7caSAdrian Chadd */ 41150bc39fc6SAdrian Chadd if (callout_pending(&sc->scan_timeout)) { 4116692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: called whilst scanning!\n", 4117692ad7caSAdrian Chadd __func__); 411842946b7dSAdrian Chadd error = EAGAIN; 411942946b7dSAdrian Chadd goto fail; 412042946b7dSAdrian Chadd } 412196dadeb0SAdrian Chadd 412242946b7dSAdrian Chadd bgscan = wpi_check_bss_filter(sc); 412342946b7dSAdrian Chadd bintval = vap->iv_bss->ni_intval; 412442946b7dSAdrian Chadd if (bgscan != 0 && 412542946b7dSAdrian Chadd bintval < WPI_QUIET_TIME_DEFAULT + WPI_CHANNEL_TUNE_TIME * 2) { 412642946b7dSAdrian Chadd error = EOPNOTSUPP; 412742946b7dSAdrian Chadd goto fail; 4128692ad7caSAdrian Chadd } 4129692ad7caSAdrian Chadd 4130692ad7caSAdrian Chadd buf = malloc(WPI_SCAN_MAXSZ, M_DEVBUF, M_NOWAIT | M_ZERO); 4131692ad7caSAdrian Chadd if (buf == NULL) { 4132692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4133692ad7caSAdrian Chadd "%s: could not allocate buffer for scan command\n", 4134692ad7caSAdrian Chadd __func__); 413596dadeb0SAdrian Chadd error = ENOMEM; 413696dadeb0SAdrian Chadd goto fail; 4137692ad7caSAdrian Chadd } 4138692ad7caSAdrian Chadd hdr = (struct wpi_scan_hdr *)buf; 4139692ad7caSAdrian Chadd 4140692ad7caSAdrian Chadd /* 4141692ad7caSAdrian Chadd * Move to the next channel if no packets are received within 10 msecs 4142692ad7caSAdrian Chadd * after sending the probe request. 4143692ad7caSAdrian Chadd */ 414442946b7dSAdrian Chadd hdr->quiet_time = htole16(WPI_QUIET_TIME_DEFAULT); 414542946b7dSAdrian Chadd hdr->quiet_threshold = htole16(1); 4146efccc3c6SAdrian Chadd 4147efccc3c6SAdrian Chadd if (bgscan != 0) { 4148692ad7caSAdrian Chadd /* 4149692ad7caSAdrian Chadd * Max needs to be greater than active and passive and quiet! 4150692ad7caSAdrian Chadd * It's also in microseconds! 4151692ad7caSAdrian Chadd */ 4152692ad7caSAdrian Chadd hdr->max_svc = htole32(250 * IEEE80211_DUR_TU); 4153efccc3c6SAdrian Chadd hdr->pause_svc = htole32(wpi_get_scan_pause_time(100, 4154efccc3c6SAdrian Chadd bintval)); 4155efccc3c6SAdrian Chadd } 4156efccc3c6SAdrian Chadd 4157692ad7caSAdrian Chadd hdr->filter = htole32(WPI_FILTER_MULTICAST | WPI_FILTER_BEACON); 4158692ad7caSAdrian Chadd 4159692ad7caSAdrian Chadd tx = (struct wpi_cmd_data *)(hdr + 1); 4160692ad7caSAdrian Chadd tx->flags = htole32(WPI_TX_AUTO_SEQ); 4161692ad7caSAdrian Chadd tx->id = WPI_ID_BROADCAST; 4162692ad7caSAdrian Chadd tx->lifetime = htole32(WPI_LIFETIME_INFINITE); 4163692ad7caSAdrian Chadd 4164692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_5GHZ(c)) { 4165692ad7caSAdrian Chadd /* Send probe requests at 6Mbps. */ 4166692ad7caSAdrian Chadd tx->plcp = wpi_ridx_to_plcp[WPI_RIDX_OFDM6]; 4167692ad7caSAdrian Chadd rs = &ic->ic_sup_rates[IEEE80211_MODE_11A]; 4168692ad7caSAdrian Chadd } else { 4169692ad7caSAdrian Chadd hdr->flags = htole32(WPI_RXON_24GHZ | WPI_RXON_AUTO); 4170692ad7caSAdrian Chadd /* Send probe requests at 1Mbps. */ 4171692ad7caSAdrian Chadd tx->plcp = wpi_ridx_to_plcp[WPI_RIDX_CCK1]; 4172692ad7caSAdrian Chadd rs = &ic->ic_sup_rates[IEEE80211_MODE_11G]; 4173692ad7caSAdrian Chadd } 4174692ad7caSAdrian Chadd 4175692ad7caSAdrian Chadd essids = (struct wpi_scan_essid *)(tx + 1); 4176692ad7caSAdrian Chadd nssid = MIN(ss->ss_nssid, WPI_SCAN_MAX_ESSIDS); 4177692ad7caSAdrian Chadd for (i = 0; i < nssid; i++) { 4178692ad7caSAdrian Chadd essids[i].id = IEEE80211_ELEMID_SSID; 4179692ad7caSAdrian Chadd essids[i].len = MIN(ss->ss_ssid[i].len, IEEE80211_NWID_LEN); 4180692ad7caSAdrian Chadd memcpy(essids[i].data, ss->ss_ssid[i].ssid, essids[i].len); 4181692ad7caSAdrian Chadd #ifdef WPI_DEBUG 4182692ad7caSAdrian Chadd if (sc->sc_debug & WPI_DEBUG_SCAN) { 4183692ad7caSAdrian Chadd printf("Scanning Essid: "); 4184692ad7caSAdrian Chadd ieee80211_print_essid(essids[i].data, essids[i].len); 4185692ad7caSAdrian Chadd printf("\n"); 4186692ad7caSAdrian Chadd } 4187692ad7caSAdrian Chadd #endif 4188692ad7caSAdrian Chadd } 4189692ad7caSAdrian Chadd 4190692ad7caSAdrian Chadd /* 4191692ad7caSAdrian Chadd * Build a probe request frame. Most of the following code is a 4192692ad7caSAdrian Chadd * copy & paste of what is done in net80211. 4193692ad7caSAdrian Chadd */ 4194692ad7caSAdrian Chadd wh = (struct ieee80211_frame *)(essids + WPI_SCAN_MAX_ESSIDS); 4195692ad7caSAdrian Chadd wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT | 4196692ad7caSAdrian Chadd IEEE80211_FC0_SUBTYPE_PROBE_REQ; 4197692ad7caSAdrian Chadd wh->i_fc[1] = IEEE80211_FC1_DIR_NODS; 41987a79cebfSGleb Smirnoff IEEE80211_ADDR_COPY(wh->i_addr1, ieee80211broadcastaddr); 41993de934a7SAdrian Chadd IEEE80211_ADDR_COPY(wh->i_addr2, vap->iv_myaddr); 42007a79cebfSGleb Smirnoff IEEE80211_ADDR_COPY(wh->i_addr3, ieee80211broadcastaddr); 4201692ad7caSAdrian Chadd 4202692ad7caSAdrian Chadd frm = (uint8_t *)(wh + 1); 4203692ad7caSAdrian Chadd frm = ieee80211_add_ssid(frm, NULL, 0); 4204692ad7caSAdrian Chadd frm = ieee80211_add_rates(frm, rs); 4205692ad7caSAdrian Chadd if (rs->rs_nrates > IEEE80211_RATE_SIZE) 4206692ad7caSAdrian Chadd frm = ieee80211_add_xrates(frm, rs); 4207692ad7caSAdrian Chadd 4208692ad7caSAdrian Chadd /* Set length of probe request. */ 4209692ad7caSAdrian Chadd tx->len = htole16(frm - (uint8_t *)wh); 4210692ad7caSAdrian Chadd 4211692ad7caSAdrian Chadd /* 4212692ad7caSAdrian Chadd * Construct information about the channel that we 4213692ad7caSAdrian Chadd * want to scan. The firmware expects this to be directly 4214692ad7caSAdrian Chadd * after the scan probe request 4215692ad7caSAdrian Chadd */ 4216692ad7caSAdrian Chadd chan = (struct wpi_scan_chan *)frm; 42174c09e592SAdrian Chadd chan->chan = ieee80211_chan2ieee(ic, c); 4218692ad7caSAdrian Chadd chan->flags = 0; 4219692ad7caSAdrian Chadd if (nssid) { 4220692ad7caSAdrian Chadd hdr->crc_threshold = WPI_SCAN_CRC_TH_DEFAULT; 4221692ad7caSAdrian Chadd chan->flags |= WPI_CHAN_NPBREQS(nssid); 4222692ad7caSAdrian Chadd } else 4223692ad7caSAdrian Chadd hdr->crc_threshold = WPI_SCAN_CRC_TH_NEVER; 4224692ad7caSAdrian Chadd 4225fae61c69SAdrian Chadd if (!IEEE80211_IS_CHAN_PASSIVE(c)) 4226692ad7caSAdrian Chadd chan->flags |= WPI_CHAN_ACTIVE; 4227692ad7caSAdrian Chadd 4228692ad7caSAdrian Chadd /* 4229692ad7caSAdrian Chadd * Calculate the active/passive dwell times. 4230692ad7caSAdrian Chadd */ 4231692ad7caSAdrian Chadd dwell_active = wpi_get_active_dwell_time(sc, c, nssid); 4232692ad7caSAdrian Chadd dwell_passive = wpi_get_passive_dwell_time(sc, c); 4233692ad7caSAdrian Chadd 4234692ad7caSAdrian Chadd /* Make sure they're valid. */ 423542946b7dSAdrian Chadd if (dwell_active > dwell_passive) 423642946b7dSAdrian Chadd dwell_active = dwell_passive; 4237692ad7caSAdrian Chadd 4238692ad7caSAdrian Chadd chan->active = htole16(dwell_active); 4239692ad7caSAdrian Chadd chan->passive = htole16(dwell_passive); 4240692ad7caSAdrian Chadd 4241692ad7caSAdrian Chadd chan->dsp_gain = 0x6e; /* Default level */ 4242692ad7caSAdrian Chadd 4243692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_5GHZ(c)) 4244692ad7caSAdrian Chadd chan->rf_gain = 0x3b; 4245692ad7caSAdrian Chadd else 4246692ad7caSAdrian Chadd chan->rf_gain = 0x28; 4247692ad7caSAdrian Chadd 4248692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_SCAN, "Scanning %u Passive: %d\n", 4249fae61c69SAdrian Chadd chan->chan, IEEE80211_IS_CHAN_PASSIVE(c)); 4250692ad7caSAdrian Chadd 4251692ad7caSAdrian Chadd hdr->nchan++; 4252e948ddb6SAdrian Chadd 4253e948ddb6SAdrian Chadd if (hdr->nchan == 1 && sc->rxon.chan == chan->chan) { 4254e948ddb6SAdrian Chadd /* XXX Force probe request transmission. */ 4255e948ddb6SAdrian Chadd memcpy(chan + 1, chan, sizeof (struct wpi_scan_chan)); 4256e948ddb6SAdrian Chadd 4257e948ddb6SAdrian Chadd chan++; 4258e948ddb6SAdrian Chadd 4259e948ddb6SAdrian Chadd /* Reduce unnecessary delay. */ 4260e948ddb6SAdrian Chadd chan->flags = 0; 4261e948ddb6SAdrian Chadd chan->passive = chan->active = hdr->quiet_time; 4262e948ddb6SAdrian Chadd 4263e948ddb6SAdrian Chadd hdr->nchan++; 4264e948ddb6SAdrian Chadd } 4265e948ddb6SAdrian Chadd 4266692ad7caSAdrian Chadd chan++; 4267692ad7caSAdrian Chadd 4268692ad7caSAdrian Chadd buflen = (uint8_t *)chan - buf; 4269692ad7caSAdrian Chadd hdr->len = htole16(buflen); 4270692ad7caSAdrian Chadd 4271692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_CMD, "sending scan command nchan=%d\n", 4272692ad7caSAdrian Chadd hdr->nchan); 4273692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_SCAN, buf, buflen, 1); 4274692ad7caSAdrian Chadd free(buf, M_DEVBUF); 4275692ad7caSAdrian Chadd 427696dadeb0SAdrian Chadd if (error != 0) 427796dadeb0SAdrian Chadd goto fail; 427896dadeb0SAdrian Chadd 42790bc39fc6SAdrian Chadd callout_reset(&sc->scan_timeout, 5*hz, wpi_scan_timeout, sc); 4280692ad7caSAdrian Chadd 4281692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 4282692ad7caSAdrian Chadd 428396dadeb0SAdrian Chadd return 0; 428496dadeb0SAdrian Chadd 428596dadeb0SAdrian Chadd fail: DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 428696dadeb0SAdrian Chadd 42876607310bSBenjamin Close return error; 42886607310bSBenjamin Close } 42896607310bSBenjamin Close 4290692ad7caSAdrian Chadd static int 4291692ad7caSAdrian Chadd wpi_auth(struct wpi_softc *sc, struct ieee80211vap *vap) 4292692ad7caSAdrian Chadd { 4293692ad7caSAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 4294692ad7caSAdrian Chadd struct ieee80211_node *ni = vap->iv_bss; 42956b997e0cSAdrian Chadd struct ieee80211_channel *c = ni->ni_chan; 4296692ad7caSAdrian Chadd int error; 4297692ad7caSAdrian Chadd 4298446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 4299446685e4SAdrian Chadd 4300692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 4301692ad7caSAdrian Chadd 4302692ad7caSAdrian Chadd /* Update adapter configuration. */ 4303692ad7caSAdrian Chadd sc->rxon.associd = 0; 4304692ad7caSAdrian Chadd sc->rxon.filter &= ~htole32(WPI_FILTER_BSS); 4305692ad7caSAdrian Chadd IEEE80211_ADDR_COPY(sc->rxon.bssid, ni->ni_bssid); 43066b997e0cSAdrian Chadd sc->rxon.chan = ieee80211_chan2ieee(ic, c); 4307692ad7caSAdrian Chadd sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF); 43086b997e0cSAdrian Chadd if (IEEE80211_IS_CHAN_2GHZ(c)) 4309692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ); 4310692ad7caSAdrian Chadd if (ic->ic_flags & IEEE80211_F_SHSLOT) 4311692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_SHSLOT); 4312692ad7caSAdrian Chadd if (ic->ic_flags & IEEE80211_F_SHPREAMBLE) 4313692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_SHPREAMBLE); 43146b997e0cSAdrian Chadd if (IEEE80211_IS_CHAN_A(c)) { 4315692ad7caSAdrian Chadd sc->rxon.cck_mask = 0; 4316692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0x15; 43176b997e0cSAdrian Chadd } else if (IEEE80211_IS_CHAN_B(c)) { 4318692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x03; 4319692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0; 4320692ad7caSAdrian Chadd } else { 4321692ad7caSAdrian Chadd /* Assume 802.11b/g. */ 4322692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x0f; 4323692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0x15; 4324692ad7caSAdrian Chadd } 4325692ad7caSAdrian Chadd 4326692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, "rxon chan %d flags %x cck %x ofdm %x\n", 4327692ad7caSAdrian Chadd sc->rxon.chan, sc->rxon.flags, sc->rxon.cck_mask, 4328692ad7caSAdrian Chadd sc->rxon.ofdm_mask); 4329692ad7caSAdrian Chadd 4330692ad7caSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { 4331692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not send RXON\n", 4332692ad7caSAdrian Chadd __func__); 4333692ad7caSAdrian Chadd } 4334692ad7caSAdrian Chadd 4335692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 4336692ad7caSAdrian Chadd 4337446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 4338446685e4SAdrian Chadd 4339692ad7caSAdrian Chadd return error; 4340692ad7caSAdrian Chadd } 4341692ad7caSAdrian Chadd 4342692ad7caSAdrian Chadd static int 43436f8421f8SAdrian Chadd wpi_config_beacon(struct wpi_vap *wvp) 43446f8421f8SAdrian Chadd { 43450cf00015SAdrian Chadd struct ieee80211vap *vap = &wvp->wv_vap; 43460cf00015SAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 43470cf00015SAdrian Chadd struct ieee80211_beacon_offsets *bo = &vap->iv_bcn_off; 43486f8421f8SAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 43492cb71df1SAdrian Chadd struct wpi_softc *sc = ic->ic_softc; 43506f8421f8SAdrian Chadd struct wpi_cmd_beacon *cmd = (struct wpi_cmd_beacon *)&bcn->data; 43516f8421f8SAdrian Chadd struct ieee80211_tim_ie *tie; 43526f8421f8SAdrian Chadd struct mbuf *m; 43536f8421f8SAdrian Chadd uint8_t *ptr; 43546f8421f8SAdrian Chadd int error; 43556f8421f8SAdrian Chadd 43566f8421f8SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 43576f8421f8SAdrian Chadd 4358b56fed3dSAdrian Chadd WPI_VAP_LOCK_ASSERT(wvp); 43596f8421f8SAdrian Chadd 43606f8421f8SAdrian Chadd cmd->len = htole16(bcn->m->m_pkthdr.len); 43616f8421f8SAdrian Chadd cmd->plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ? 43626f8421f8SAdrian Chadd wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1]; 43636f8421f8SAdrian Chadd 43646f8421f8SAdrian Chadd /* XXX seems to be unused */ 43656f8421f8SAdrian Chadd if (*(bo->bo_tim) == IEEE80211_ELEMID_TIM) { 43666f8421f8SAdrian Chadd tie = (struct ieee80211_tim_ie *) bo->bo_tim; 43676f8421f8SAdrian Chadd ptr = mtod(bcn->m, uint8_t *); 43686f8421f8SAdrian Chadd 43696f8421f8SAdrian Chadd cmd->tim = htole16(bo->bo_tim - ptr); 43706f8421f8SAdrian Chadd cmd->timsz = tie->tim_len; 43716f8421f8SAdrian Chadd } 43726f8421f8SAdrian Chadd 43736f8421f8SAdrian Chadd /* Necessary for recursion in ieee80211_beacon_update(). */ 43746f8421f8SAdrian Chadd m = bcn->m; 43756f8421f8SAdrian Chadd bcn->m = m_dup(m, M_NOWAIT); 43766f8421f8SAdrian Chadd if (bcn->m == NULL) { 43776f8421f8SAdrian Chadd device_printf(sc->sc_dev, 43786f8421f8SAdrian Chadd "%s: could not copy beacon frame\n", __func__); 43796f8421f8SAdrian Chadd error = ENOMEM; 43806f8421f8SAdrian Chadd goto end; 43816f8421f8SAdrian Chadd } 43826f8421f8SAdrian Chadd 43836f8421f8SAdrian Chadd if ((error = wpi_cmd2(sc, bcn)) != 0) { 43846f8421f8SAdrian Chadd device_printf(sc->sc_dev, 43856f8421f8SAdrian Chadd "%s: could not update beacon frame, error %d", __func__, 43866f8421f8SAdrian Chadd error); 4387823e17dbSAdrian Chadd m_freem(bcn->m); 43886f8421f8SAdrian Chadd } 43896f8421f8SAdrian Chadd 43906f8421f8SAdrian Chadd /* Restore mbuf. */ 43916f8421f8SAdrian Chadd end: bcn->m = m; 43926f8421f8SAdrian Chadd 43936f8421f8SAdrian Chadd return error; 43946f8421f8SAdrian Chadd } 43956f8421f8SAdrian Chadd 43966f8421f8SAdrian Chadd static int 4397692ad7caSAdrian Chadd wpi_setup_beacon(struct wpi_softc *sc, struct ieee80211_node *ni) 4398692ad7caSAdrian Chadd { 43990cf00015SAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 44000cf00015SAdrian Chadd struct wpi_vap *wvp = WPI_VAP(vap); 4401692ad7caSAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 4402692ad7caSAdrian Chadd struct mbuf *m; 44036f8421f8SAdrian Chadd int error; 4404692ad7caSAdrian Chadd 4405692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4406692ad7caSAdrian Chadd 4407692ad7caSAdrian Chadd if (ni->ni_chan == IEEE80211_CHAN_ANYC) 4408692ad7caSAdrian Chadd return EINVAL; 4409692ad7caSAdrian Chadd 4410210ab3c2SAdrian Chadd m = ieee80211_beacon_alloc(ni); 4411692ad7caSAdrian Chadd if (m == NULL) { 4412692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4413692ad7caSAdrian Chadd "%s: could not allocate beacon frame\n", __func__); 4414692ad7caSAdrian Chadd return ENOMEM; 4415692ad7caSAdrian Chadd } 4416692ad7caSAdrian Chadd 4417b56fed3dSAdrian Chadd WPI_VAP_LOCK(wvp); 44186f8421f8SAdrian Chadd if (bcn->m != NULL) 44196f8421f8SAdrian Chadd m_freem(bcn->m); 4420692ad7caSAdrian Chadd 4421692ad7caSAdrian Chadd bcn->m = m; 4422692ad7caSAdrian Chadd 44236f8421f8SAdrian Chadd error = wpi_config_beacon(wvp); 4424b56fed3dSAdrian Chadd WPI_VAP_UNLOCK(wvp); 44256f8421f8SAdrian Chadd 44266f8421f8SAdrian Chadd return error; 4427692ad7caSAdrian Chadd } 4428692ad7caSAdrian Chadd 4429692ad7caSAdrian Chadd static void 4430692ad7caSAdrian Chadd wpi_update_beacon(struct ieee80211vap *vap, int item) 4431692ad7caSAdrian Chadd { 44322cb71df1SAdrian Chadd struct wpi_softc *sc = vap->iv_ic->ic_softc; 44336f8421f8SAdrian Chadd struct wpi_vap *wvp = WPI_VAP(vap); 44346f8421f8SAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 44350cf00015SAdrian Chadd struct ieee80211_beacon_offsets *bo = &vap->iv_bcn_off; 4436692ad7caSAdrian Chadd struct ieee80211_node *ni = vap->iv_bss; 44376f8421f8SAdrian Chadd int mcast = 0; 44386f8421f8SAdrian Chadd 44396f8421f8SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 4440692ad7caSAdrian Chadd 4441b56fed3dSAdrian Chadd WPI_VAP_LOCK(wvp); 44426f8421f8SAdrian Chadd if (bcn->m == NULL) { 4443210ab3c2SAdrian Chadd bcn->m = ieee80211_beacon_alloc(ni); 44446f8421f8SAdrian Chadd if (bcn->m == NULL) { 4445692ad7caSAdrian Chadd device_printf(sc->sc_dev, 44466f8421f8SAdrian Chadd "%s: could not allocate beacon frame\n", __func__); 44476f8421f8SAdrian Chadd 44486f8421f8SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, 44496f8421f8SAdrian Chadd __func__); 44506f8421f8SAdrian Chadd 4451b56fed3dSAdrian Chadd WPI_VAP_UNLOCK(wvp); 44526f8421f8SAdrian Chadd return; 44536f8421f8SAdrian Chadd } 4454692ad7caSAdrian Chadd } 4455b56fed3dSAdrian Chadd WPI_VAP_UNLOCK(wvp); 44566f8421f8SAdrian Chadd 44576f8421f8SAdrian Chadd if (item == IEEE80211_BEACON_TIM) 44586f8421f8SAdrian Chadd mcast = 1; /* TODO */ 44596f8421f8SAdrian Chadd 44606f8421f8SAdrian Chadd setbit(bo->bo_flags, item); 4461210ab3c2SAdrian Chadd ieee80211_beacon_update(ni, bcn->m, mcast); 44626f8421f8SAdrian Chadd 4463b56fed3dSAdrian Chadd WPI_VAP_LOCK(wvp); 44646f8421f8SAdrian Chadd wpi_config_beacon(wvp); 4465b56fed3dSAdrian Chadd WPI_VAP_UNLOCK(wvp); 44666f8421f8SAdrian Chadd 44676f8421f8SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 4468692ad7caSAdrian Chadd } 4469692ad7caSAdrian Chadd 4470d138d3baSAdrian Chadd static void 4471d138d3baSAdrian Chadd wpi_newassoc(struct ieee80211_node *ni, int isnew) 4472d138d3baSAdrian Chadd { 4473d138d3baSAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 44742cb71df1SAdrian Chadd struct wpi_softc *sc = ni->ni_ic->ic_softc; 4475d138d3baSAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 4476d138d3baSAdrian Chadd int error; 4477d138d3baSAdrian Chadd 4478d138d3baSAdrian Chadd WPI_NT_LOCK(sc); 4479d138d3baSAdrian Chadd 4480d138d3baSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4481d138d3baSAdrian Chadd 4482d138d3baSAdrian Chadd if (vap->iv_opmode != IEEE80211_M_STA && wn->id == WPI_ID_UNDEFINED) { 4483d138d3baSAdrian Chadd if ((error = wpi_add_ibss_node(sc, ni)) != 0) { 4484d138d3baSAdrian Chadd device_printf(sc->sc_dev, 4485d138d3baSAdrian Chadd "%s: could not add IBSS node, error %d\n", 4486d138d3baSAdrian Chadd __func__, error); 4487d138d3baSAdrian Chadd } 4488d138d3baSAdrian Chadd } 4489d138d3baSAdrian Chadd WPI_NT_UNLOCK(sc); 4490d138d3baSAdrian Chadd } 4491d138d3baSAdrian Chadd 4492692ad7caSAdrian Chadd static int 4493692ad7caSAdrian Chadd wpi_run(struct wpi_softc *sc, struct ieee80211vap *vap) 4494692ad7caSAdrian Chadd { 4495692ad7caSAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 4496692ad7caSAdrian Chadd struct ieee80211_node *ni = vap->iv_bss; 44976b997e0cSAdrian Chadd struct ieee80211_channel *c = ni->ni_chan; 4498692ad7caSAdrian Chadd int error; 4499692ad7caSAdrian Chadd 4500692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 4501692ad7caSAdrian Chadd 4502692ad7caSAdrian Chadd if (vap->iv_opmode == IEEE80211_M_MONITOR) { 4503692ad7caSAdrian Chadd /* Link LED blinks while monitoring. */ 4504692ad7caSAdrian Chadd wpi_set_led(sc, WPI_LED_LINK, 5, 5); 4505692ad7caSAdrian Chadd return 0; 4506692ad7caSAdrian Chadd } 4507692ad7caSAdrian Chadd 4508692ad7caSAdrian Chadd /* XXX kernel panic workaround */ 45096b997e0cSAdrian Chadd if (c == IEEE80211_CHAN_ANYC) { 4510692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: incomplete configuration\n", 4511692ad7caSAdrian Chadd __func__); 4512692ad7caSAdrian Chadd return EINVAL; 4513692ad7caSAdrian Chadd } 4514692ad7caSAdrian Chadd 4515692ad7caSAdrian Chadd if ((error = wpi_set_timing(sc, ni)) != 0) { 4516692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4517692ad7caSAdrian Chadd "%s: could not set timing, error %d\n", __func__, error); 4518692ad7caSAdrian Chadd return error; 4519692ad7caSAdrian Chadd } 4520692ad7caSAdrian Chadd 4521692ad7caSAdrian Chadd /* Update adapter configuration. */ 4522446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 4523692ad7caSAdrian Chadd IEEE80211_ADDR_COPY(sc->rxon.bssid, ni->ni_bssid); 4524692ad7caSAdrian Chadd sc->rxon.associd = htole16(IEEE80211_NODE_AID(ni)); 45256b997e0cSAdrian Chadd sc->rxon.chan = ieee80211_chan2ieee(ic, c); 4526692ad7caSAdrian Chadd sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF); 45276b997e0cSAdrian Chadd if (IEEE80211_IS_CHAN_2GHZ(c)) 4528692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ); 4529692ad7caSAdrian Chadd if (ic->ic_flags & IEEE80211_F_SHSLOT) 4530692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_SHSLOT); 4531692ad7caSAdrian Chadd if (ic->ic_flags & IEEE80211_F_SHPREAMBLE) 4532692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_SHPREAMBLE); 45336b997e0cSAdrian Chadd if (IEEE80211_IS_CHAN_A(c)) { 4534692ad7caSAdrian Chadd sc->rxon.cck_mask = 0; 4535692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0x15; 45366b997e0cSAdrian Chadd } else if (IEEE80211_IS_CHAN_B(c)) { 4537692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x03; 4538692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0; 4539692ad7caSAdrian Chadd } else { 4540692ad7caSAdrian Chadd /* Assume 802.11b/g. */ 4541692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x0f; 4542692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0x15; 4543692ad7caSAdrian Chadd } 4544692ad7caSAdrian Chadd sc->rxon.filter |= htole32(WPI_FILTER_BSS); 4545692ad7caSAdrian Chadd 4546692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, "rxon chan %d flags %x\n", 4547692ad7caSAdrian Chadd sc->rxon.chan, sc->rxon.flags); 4548692ad7caSAdrian Chadd 4549692ad7caSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { 4550692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not send RXON\n", 4551692ad7caSAdrian Chadd __func__); 4552692ad7caSAdrian Chadd return error; 4553692ad7caSAdrian Chadd } 4554692ad7caSAdrian Chadd 4555446685e4SAdrian Chadd /* Start periodic calibration timer. */ 4556446685e4SAdrian Chadd callout_reset(&sc->calib_to, 60*hz, wpi_calib_timeout, sc); 4557446685e4SAdrian Chadd 4558446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 4559446685e4SAdrian Chadd 4560726ddc26SAdrian Chadd if (vap->iv_opmode == IEEE80211_M_IBSS || 4561726ddc26SAdrian Chadd vap->iv_opmode == IEEE80211_M_HOSTAP) { 4562692ad7caSAdrian Chadd if ((error = wpi_setup_beacon(sc, ni)) != 0) { 4563692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4564692ad7caSAdrian Chadd "%s: could not setup beacon, error %d\n", __func__, 4565692ad7caSAdrian Chadd error); 4566692ad7caSAdrian Chadd return error; 4567692ad7caSAdrian Chadd } 4568692ad7caSAdrian Chadd } 4569692ad7caSAdrian Chadd 4570692ad7caSAdrian Chadd if (vap->iv_opmode == IEEE80211_M_STA) { 4571692ad7caSAdrian Chadd /* Add BSS node. */ 45727964dd56SAdrian Chadd WPI_NT_LOCK(sc); 45730ebca245SAdrian Chadd error = wpi_add_sta_node(sc, ni); 45747964dd56SAdrian Chadd WPI_NT_UNLOCK(sc); 45750ebca245SAdrian Chadd if (error != 0) { 4576692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4577692ad7caSAdrian Chadd "%s: could not add BSS node, error %d\n", __func__, 4578692ad7caSAdrian Chadd error); 4579692ad7caSAdrian Chadd return error; 4580692ad7caSAdrian Chadd } 4581692ad7caSAdrian Chadd } 4582692ad7caSAdrian Chadd 4583692ad7caSAdrian Chadd /* Link LED always on while associated. */ 4584692ad7caSAdrian Chadd wpi_set_led(sc, WPI_LED_LINK, 0, 1); 4585692ad7caSAdrian Chadd 4586692ad7caSAdrian Chadd /* Enable power-saving mode if requested by user. */ 45870b90e845SAdrian Chadd if ((vap->iv_flags & IEEE80211_F_PMGTON) && 45880b90e845SAdrian Chadd vap->iv_opmode != IEEE80211_M_IBSS) 4589692ad7caSAdrian Chadd (void)wpi_set_pslevel(sc, 0, 3, 1); 4590692ad7caSAdrian Chadd 4591692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 4592692ad7caSAdrian Chadd 4593692ad7caSAdrian Chadd return 0; 4594692ad7caSAdrian Chadd } 4595692ad7caSAdrian Chadd 4596692ad7caSAdrian Chadd static int 4597d29fcfb7SAdrian Chadd wpi_load_key(struct ieee80211_node *ni, const struct ieee80211_key *k) 4598692ad7caSAdrian Chadd { 4599692ad7caSAdrian Chadd const struct ieee80211_cipher *cip = k->wk_cipher; 4600d29fcfb7SAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 46012cb71df1SAdrian Chadd struct wpi_softc *sc = ni->ni_ic->ic_softc; 4602a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 4603692ad7caSAdrian Chadd struct wpi_node_info node; 4604692ad7caSAdrian Chadd uint16_t kflags; 4605692ad7caSAdrian Chadd int error; 4606692ad7caSAdrian Chadd 4607692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4608692ad7caSAdrian Chadd 4609d29fcfb7SAdrian Chadd if (wpi_check_node_entry(sc, wn->id) == 0) { 4610d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, "%s: node does not exist\n", 4611d29fcfb7SAdrian Chadd __func__); 4612d29fcfb7SAdrian Chadd return 0; 4613692ad7caSAdrian Chadd } 4614692ad7caSAdrian Chadd 4615d29fcfb7SAdrian Chadd switch (cip->ic_cipher) { 4616d29fcfb7SAdrian Chadd case IEEE80211_CIPHER_AES_CCM: 4617d29fcfb7SAdrian Chadd kflags = WPI_KFLAG_CCMP; 4618d29fcfb7SAdrian Chadd break; 4619d29fcfb7SAdrian Chadd 4620d29fcfb7SAdrian Chadd default: 4621d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, "%s: unknown cipher %d\n", __func__, 4622d29fcfb7SAdrian Chadd cip->ic_cipher); 4623692ad7caSAdrian Chadd return 0; 4624d29fcfb7SAdrian Chadd } 4625692ad7caSAdrian Chadd 4626692ad7caSAdrian Chadd kflags |= WPI_KFLAG_KID(k->wk_keyix); 4627692ad7caSAdrian Chadd if (k->wk_flags & IEEE80211_KEY_GROUP) 4628692ad7caSAdrian Chadd kflags |= WPI_KFLAG_MULTICAST; 4629692ad7caSAdrian Chadd 46306607310bSBenjamin Close memset(&node, 0, sizeof node); 4631692ad7caSAdrian Chadd node.id = wn->id; 4632692ad7caSAdrian Chadd node.control = WPI_NODE_UPDATE; 4633692ad7caSAdrian Chadd node.flags = WPI_FLAG_KEY_SET; 4634692ad7caSAdrian Chadd node.kflags = htole16(kflags); 4635692ad7caSAdrian Chadd memcpy(node.key, k->wk_key, k->wk_keylen); 4636d29fcfb7SAdrian Chadd again: 4637d29fcfb7SAdrian Chadd DPRINTF(sc, WPI_DEBUG_KEY, 4638d29fcfb7SAdrian Chadd "%s: setting %s key id %d for node %d (%s)\n", __func__, 4639d29fcfb7SAdrian Chadd (kflags & WPI_KFLAG_MULTICAST) ? "group" : "ucast", k->wk_keyix, 4640d29fcfb7SAdrian Chadd node.id, ether_sprintf(ni->ni_macaddr)); 4641692ad7caSAdrian Chadd 4642692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1); 46436607310bSBenjamin Close if (error != 0) { 4644692ad7caSAdrian Chadd device_printf(sc->sc_dev, "can't update node info, error %d\n", 4645692ad7caSAdrian Chadd error); 4646d29fcfb7SAdrian Chadd return !error; 4647d29fcfb7SAdrian Chadd } 4648d29fcfb7SAdrian Chadd 4649d29fcfb7SAdrian Chadd if (!(kflags & WPI_KFLAG_MULTICAST) && &vap->iv_nw_keys[0] <= k && 4650d29fcfb7SAdrian Chadd k < &vap->iv_nw_keys[IEEE80211_WEP_NKID]) { 4651d29fcfb7SAdrian Chadd kflags |= WPI_KFLAG_MULTICAST; 4652d29fcfb7SAdrian Chadd node.kflags = htole16(kflags); 4653d29fcfb7SAdrian Chadd 4654d29fcfb7SAdrian Chadd goto again; 4655692ad7caSAdrian Chadd } 4656692ad7caSAdrian Chadd 4657692ad7caSAdrian Chadd return 1; 4658692ad7caSAdrian Chadd } 4659692ad7caSAdrian Chadd 4660d29fcfb7SAdrian Chadd static void 4661d29fcfb7SAdrian Chadd wpi_load_key_cb(void *arg, struct ieee80211_node *ni) 4662d29fcfb7SAdrian Chadd { 4663d29fcfb7SAdrian Chadd const struct ieee80211_key *k = arg; 4664d29fcfb7SAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 46652cb71df1SAdrian Chadd struct wpi_softc *sc = ni->ni_ic->ic_softc; 4666d29fcfb7SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 4667d29fcfb7SAdrian Chadd int error; 4668d29fcfb7SAdrian Chadd 4669d29fcfb7SAdrian Chadd if (vap->iv_bss == ni && wn->id == WPI_ID_UNDEFINED) 4670d29fcfb7SAdrian Chadd return; 4671d29fcfb7SAdrian Chadd 4672d29fcfb7SAdrian Chadd WPI_NT_LOCK(sc); 4673d29fcfb7SAdrian Chadd error = wpi_load_key(ni, k); 4674d29fcfb7SAdrian Chadd WPI_NT_UNLOCK(sc); 4675d29fcfb7SAdrian Chadd 4676d29fcfb7SAdrian Chadd if (error == 0) { 4677d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, "%s: error while setting key\n", 4678d29fcfb7SAdrian Chadd __func__); 4679d29fcfb7SAdrian Chadd } 4680d29fcfb7SAdrian Chadd } 4681d29fcfb7SAdrian Chadd 4682692ad7caSAdrian Chadd static int 4683d29fcfb7SAdrian Chadd wpi_set_global_keys(struct ieee80211_node *ni) 4684692ad7caSAdrian Chadd { 4685d29fcfb7SAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 4686d29fcfb7SAdrian Chadd struct ieee80211_key *wk = &vap->iv_nw_keys[0]; 4687d29fcfb7SAdrian Chadd int error = 1; 4688d29fcfb7SAdrian Chadd 4689d29fcfb7SAdrian Chadd for (; wk < &vap->iv_nw_keys[IEEE80211_WEP_NKID] && error; wk++) 4690d29fcfb7SAdrian Chadd if (wk->wk_keyix != IEEE80211_KEYIX_NONE) 4691d29fcfb7SAdrian Chadd error = wpi_load_key(ni, wk); 4692d29fcfb7SAdrian Chadd 4693d29fcfb7SAdrian Chadd return !error; 4694d29fcfb7SAdrian Chadd } 4695d29fcfb7SAdrian Chadd 4696d29fcfb7SAdrian Chadd static int 4697d29fcfb7SAdrian Chadd wpi_del_key(struct ieee80211_node *ni, const struct ieee80211_key *k) 4698d29fcfb7SAdrian Chadd { 4699d29fcfb7SAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 47002cb71df1SAdrian Chadd struct wpi_softc *sc = ni->ni_ic->ic_softc; 4701a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 4702692ad7caSAdrian Chadd struct wpi_node_info node; 4703d29fcfb7SAdrian Chadd uint16_t kflags; 4704d29fcfb7SAdrian Chadd int error; 4705692ad7caSAdrian Chadd 4706692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4707692ad7caSAdrian Chadd 4708d29fcfb7SAdrian Chadd if (wpi_check_node_entry(sc, wn->id) == 0) { 4709d29fcfb7SAdrian Chadd DPRINTF(sc, WPI_DEBUG_KEY, "%s: node was removed\n", __func__); 4710d29fcfb7SAdrian Chadd return 1; /* Nothing to do. */ 4711692ad7caSAdrian Chadd } 4712692ad7caSAdrian Chadd 4713d29fcfb7SAdrian Chadd kflags = WPI_KFLAG_KID(k->wk_keyix); 4714d29fcfb7SAdrian Chadd if (k->wk_flags & IEEE80211_KEY_GROUP) 4715d29fcfb7SAdrian Chadd kflags |= WPI_KFLAG_MULTICAST; 4716692ad7caSAdrian Chadd 4717692ad7caSAdrian Chadd memset(&node, 0, sizeof node); 4718692ad7caSAdrian Chadd node.id = wn->id; 4719692ad7caSAdrian Chadd node.control = WPI_NODE_UPDATE; 4720692ad7caSAdrian Chadd node.flags = WPI_FLAG_KEY_SET; 4721d29fcfb7SAdrian Chadd node.kflags = htole16(kflags); 4722d29fcfb7SAdrian Chadd again: 4723d29fcfb7SAdrian Chadd DPRINTF(sc, WPI_DEBUG_KEY, "%s: deleting %s key %d for node %d (%s)\n", 4724d29fcfb7SAdrian Chadd __func__, (kflags & WPI_KFLAG_MULTICAST) ? "group" : "ucast", 4725d29fcfb7SAdrian Chadd k->wk_keyix, node.id, ether_sprintf(ni->ni_macaddr)); 4726692ad7caSAdrian Chadd 4727d29fcfb7SAdrian Chadd error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1); 4728d29fcfb7SAdrian Chadd if (error != 0) { 4729d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, "can't update node info, error %d\n", 4730d29fcfb7SAdrian Chadd error); 4731d29fcfb7SAdrian Chadd return !error; 4732d29fcfb7SAdrian Chadd } 4733d29fcfb7SAdrian Chadd 4734d29fcfb7SAdrian Chadd if (!(kflags & WPI_KFLAG_MULTICAST) && &vap->iv_nw_keys[0] <= k && 4735d29fcfb7SAdrian Chadd k < &vap->iv_nw_keys[IEEE80211_WEP_NKID]) { 4736d29fcfb7SAdrian Chadd kflags |= WPI_KFLAG_MULTICAST; 4737d29fcfb7SAdrian Chadd node.kflags = htole16(kflags); 4738d29fcfb7SAdrian Chadd 4739d29fcfb7SAdrian Chadd goto again; 4740d29fcfb7SAdrian Chadd } 4741692ad7caSAdrian Chadd 4742692ad7caSAdrian Chadd return 1; 4743692ad7caSAdrian Chadd } 4744692ad7caSAdrian Chadd 4745d29fcfb7SAdrian Chadd static void 4746d29fcfb7SAdrian Chadd wpi_del_key_cb(void *arg, struct ieee80211_node *ni) 4747d29fcfb7SAdrian Chadd { 4748d29fcfb7SAdrian Chadd const struct ieee80211_key *k = arg; 4749d29fcfb7SAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 47502cb71df1SAdrian Chadd struct wpi_softc *sc = ni->ni_ic->ic_softc; 4751d29fcfb7SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 4752d29fcfb7SAdrian Chadd int error; 4753d29fcfb7SAdrian Chadd 4754d29fcfb7SAdrian Chadd if (vap->iv_bss == ni && wn->id == WPI_ID_UNDEFINED) 4755d29fcfb7SAdrian Chadd return; 4756d29fcfb7SAdrian Chadd 4757d29fcfb7SAdrian Chadd WPI_NT_LOCK(sc); 4758d29fcfb7SAdrian Chadd error = wpi_del_key(ni, k); 4759d29fcfb7SAdrian Chadd WPI_NT_UNLOCK(sc); 4760d29fcfb7SAdrian Chadd 4761d29fcfb7SAdrian Chadd if (error == 0) { 4762d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, "%s: error while deleting key\n", 4763d29fcfb7SAdrian Chadd __func__); 4764d29fcfb7SAdrian Chadd } 4765d29fcfb7SAdrian Chadd } 4766d29fcfb7SAdrian Chadd 4767d29fcfb7SAdrian Chadd static int 4768d29fcfb7SAdrian Chadd wpi_process_key(struct ieee80211vap *vap, const struct ieee80211_key *k, 4769d29fcfb7SAdrian Chadd int set) 4770d29fcfb7SAdrian Chadd { 4771d29fcfb7SAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 47722cb71df1SAdrian Chadd struct wpi_softc *sc = ic->ic_softc; 4773d29fcfb7SAdrian Chadd struct wpi_vap *wvp = WPI_VAP(vap); 4774d29fcfb7SAdrian Chadd struct ieee80211_node *ni; 4775d29fcfb7SAdrian Chadd int error, ni_ref = 0; 4776d29fcfb7SAdrian Chadd 4777d29fcfb7SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4778d29fcfb7SAdrian Chadd 4779d29fcfb7SAdrian Chadd if (k->wk_flags & IEEE80211_KEY_SWCRYPT) { 4780d29fcfb7SAdrian Chadd /* Not for us. */ 4781d29fcfb7SAdrian Chadd return 1; 4782d29fcfb7SAdrian Chadd } 4783d29fcfb7SAdrian Chadd 4784d29fcfb7SAdrian Chadd if (!(k->wk_flags & IEEE80211_KEY_RECV)) { 4785d29fcfb7SAdrian Chadd /* XMIT keys are handled in wpi_tx_data(). */ 4786d29fcfb7SAdrian Chadd return 1; 4787d29fcfb7SAdrian Chadd } 4788d29fcfb7SAdrian Chadd 4789d29fcfb7SAdrian Chadd /* Handle group keys. */ 4790d29fcfb7SAdrian Chadd if (&vap->iv_nw_keys[0] <= k && 4791d29fcfb7SAdrian Chadd k < &vap->iv_nw_keys[IEEE80211_WEP_NKID]) { 4792d29fcfb7SAdrian Chadd WPI_NT_LOCK(sc); 4793d29fcfb7SAdrian Chadd if (set) 4794d29fcfb7SAdrian Chadd wvp->wv_gtk |= WPI_VAP_KEY(k->wk_keyix); 4795d29fcfb7SAdrian Chadd else 4796d29fcfb7SAdrian Chadd wvp->wv_gtk &= ~WPI_VAP_KEY(k->wk_keyix); 4797d29fcfb7SAdrian Chadd WPI_NT_UNLOCK(sc); 4798d29fcfb7SAdrian Chadd 4799d29fcfb7SAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN) { 4800d29fcfb7SAdrian Chadd ieee80211_iterate_nodes(&ic->ic_sta, 480169a2ec4aSKonstantin Belousov set ? wpi_load_key_cb : wpi_del_key_cb, 480269a2ec4aSKonstantin Belousov __DECONST(void *, k)); 4803d29fcfb7SAdrian Chadd } 4804d29fcfb7SAdrian Chadd 4805d29fcfb7SAdrian Chadd return 1; 4806d29fcfb7SAdrian Chadd } 4807d29fcfb7SAdrian Chadd 4808d29fcfb7SAdrian Chadd switch (vap->iv_opmode) { 4809d29fcfb7SAdrian Chadd case IEEE80211_M_STA: 4810d29fcfb7SAdrian Chadd ni = vap->iv_bss; 4811d29fcfb7SAdrian Chadd break; 4812d29fcfb7SAdrian Chadd 4813d29fcfb7SAdrian Chadd case IEEE80211_M_IBSS: 4814d29fcfb7SAdrian Chadd case IEEE80211_M_AHDEMO: 4815726ddc26SAdrian Chadd case IEEE80211_M_HOSTAP: 4816d29fcfb7SAdrian Chadd ni = ieee80211_find_vap_node(&ic->ic_sta, vap, k->wk_macaddr); 4817d29fcfb7SAdrian Chadd if (ni == NULL) 4818d29fcfb7SAdrian Chadd return 0; /* should not happen */ 4819d29fcfb7SAdrian Chadd 4820d29fcfb7SAdrian Chadd ni_ref = 1; 4821d29fcfb7SAdrian Chadd break; 4822d29fcfb7SAdrian Chadd 4823d29fcfb7SAdrian Chadd default: 4824d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, "%s: unknown opmode %d\n", __func__, 4825d29fcfb7SAdrian Chadd vap->iv_opmode); 4826d29fcfb7SAdrian Chadd return 0; 4827d29fcfb7SAdrian Chadd } 4828d29fcfb7SAdrian Chadd 4829d29fcfb7SAdrian Chadd WPI_NT_LOCK(sc); 4830d29fcfb7SAdrian Chadd if (set) 4831d29fcfb7SAdrian Chadd error = wpi_load_key(ni, k); 4832d29fcfb7SAdrian Chadd else 4833d29fcfb7SAdrian Chadd error = wpi_del_key(ni, k); 4834d29fcfb7SAdrian Chadd WPI_NT_UNLOCK(sc); 4835d29fcfb7SAdrian Chadd 4836d29fcfb7SAdrian Chadd if (ni_ref) 4837d29fcfb7SAdrian Chadd ieee80211_node_decref(ni); 4838d29fcfb7SAdrian Chadd 4839d29fcfb7SAdrian Chadd return error; 4840d29fcfb7SAdrian Chadd } 4841d29fcfb7SAdrian Chadd 4842d29fcfb7SAdrian Chadd static int 4843bc813c40SAdrian Chadd wpi_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k) 4844d29fcfb7SAdrian Chadd { 4845d29fcfb7SAdrian Chadd return wpi_process_key(vap, k, 1); 4846d29fcfb7SAdrian Chadd } 4847d29fcfb7SAdrian Chadd 4848d29fcfb7SAdrian Chadd static int 4849d29fcfb7SAdrian Chadd wpi_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k) 4850d29fcfb7SAdrian Chadd { 4851d29fcfb7SAdrian Chadd return wpi_process_key(vap, k, 0); 4852d29fcfb7SAdrian Chadd } 4853d29fcfb7SAdrian Chadd 4854692ad7caSAdrian Chadd /* 4855692ad7caSAdrian Chadd * This function is called after the runtime firmware notifies us of its 4856692ad7caSAdrian Chadd * readiness (called in a process context). 4857692ad7caSAdrian Chadd */ 4858692ad7caSAdrian Chadd static int 4859692ad7caSAdrian Chadd wpi_post_alive(struct wpi_softc *sc) 4860692ad7caSAdrian Chadd { 4861692ad7caSAdrian Chadd int ntries, error; 4862692ad7caSAdrian Chadd 4863692ad7caSAdrian Chadd /* Check (again) that the radio is not disabled. */ 4864692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4865692ad7caSAdrian Chadd return error; 4866692ad7caSAdrian Chadd 4867692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4868692ad7caSAdrian Chadd 4869692ad7caSAdrian Chadd /* NB: Runtime firmware must be up and running. */ 4870692ad7caSAdrian Chadd if (!(wpi_prph_read(sc, WPI_APMG_RFKILL) & 1)) { 4871692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4872692ad7caSAdrian Chadd "RF switch: radio disabled (%s)\n", __func__); 4873692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4874692ad7caSAdrian Chadd return EPERM; /* :-) */ 4875692ad7caSAdrian Chadd } 4876692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4877692ad7caSAdrian Chadd 4878692ad7caSAdrian Chadd /* Wait for thermal sensor to calibrate. */ 4879692ad7caSAdrian Chadd for (ntries = 0; ntries < 1000; ntries++) { 4880692ad7caSAdrian Chadd if ((sc->temp = (int)WPI_READ(sc, WPI_UCODE_GP2)) != 0) 4881692ad7caSAdrian Chadd break; 4882692ad7caSAdrian Chadd DELAY(10); 4883692ad7caSAdrian Chadd } 4884692ad7caSAdrian Chadd 4885692ad7caSAdrian Chadd if (ntries == 1000) { 4886692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4887692ad7caSAdrian Chadd "timeout waiting for thermal sensor calibration\n"); 4888692ad7caSAdrian Chadd return ETIMEDOUT; 4889692ad7caSAdrian Chadd } 4890692ad7caSAdrian Chadd 4891692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, "temperature %d\n", sc->temp); 4892692ad7caSAdrian Chadd return 0; 4893692ad7caSAdrian Chadd } 4894692ad7caSAdrian Chadd 4895692ad7caSAdrian Chadd /* 4896692ad7caSAdrian Chadd * The firmware boot code is small and is intended to be copied directly into 4897692ad7caSAdrian Chadd * the NIC internal memory (no DMA transfer). 4898692ad7caSAdrian Chadd */ 4899692ad7caSAdrian Chadd static int 4900525a3d47SAdrian Chadd wpi_load_bootcode(struct wpi_softc *sc, const uint8_t *ucode, uint32_t size) 4901692ad7caSAdrian Chadd { 4902692ad7caSAdrian Chadd int error, ntries; 4903692ad7caSAdrian Chadd 4904692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_HW, "Loading microcode size 0x%x\n", size); 4905692ad7caSAdrian Chadd 4906692ad7caSAdrian Chadd size /= sizeof (uint32_t); 4907692ad7caSAdrian Chadd 4908692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4909692ad7caSAdrian Chadd return error; 4910692ad7caSAdrian Chadd 4911692ad7caSAdrian Chadd /* Copy microcode image into NIC memory. */ 4912692ad7caSAdrian Chadd wpi_prph_write_region_4(sc, WPI_BSM_SRAM_BASE, 4913692ad7caSAdrian Chadd (const uint32_t *)ucode, size); 4914692ad7caSAdrian Chadd 4915692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_MEM_SRC, 0); 4916692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_MEM_DST, WPI_FW_TEXT_BASE); 4917692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_DWCOUNT, size); 4918692ad7caSAdrian Chadd 4919692ad7caSAdrian Chadd /* Start boot load now. */ 4920692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_CTRL, WPI_BSM_WR_CTRL_START); 4921692ad7caSAdrian Chadd 4922692ad7caSAdrian Chadd /* Wait for transfer to complete. */ 4923692ad7caSAdrian Chadd for (ntries = 0; ntries < 1000; ntries++) { 4924692ad7caSAdrian Chadd uint32_t status = WPI_READ(sc, WPI_FH_TX_STATUS); 4925692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_HW, 4926692ad7caSAdrian Chadd "firmware status=0x%x, val=0x%x, result=0x%x\n", status, 4927692ad7caSAdrian Chadd WPI_FH_TX_STATUS_IDLE(6), 4928692ad7caSAdrian Chadd status & WPI_FH_TX_STATUS_IDLE(6)); 4929692ad7caSAdrian Chadd if (status & WPI_FH_TX_STATUS_IDLE(6)) { 4930692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_HW, 4931692ad7caSAdrian Chadd "Status Match! - ntries = %d\n", ntries); 4932692ad7caSAdrian Chadd break; 4933692ad7caSAdrian Chadd } 4934692ad7caSAdrian Chadd DELAY(10); 4935692ad7caSAdrian Chadd } 4936692ad7caSAdrian Chadd if (ntries == 1000) { 4937692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not load boot firmware\n", 4938692ad7caSAdrian Chadd __func__); 4939692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4940692ad7caSAdrian Chadd return ETIMEDOUT; 4941692ad7caSAdrian Chadd } 4942692ad7caSAdrian Chadd 4943692ad7caSAdrian Chadd /* Enable boot after power up. */ 4944692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_CTRL, WPI_BSM_WR_CTRL_START_EN); 4945692ad7caSAdrian Chadd 4946692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4947692ad7caSAdrian Chadd return 0; 4948692ad7caSAdrian Chadd } 4949692ad7caSAdrian Chadd 4950692ad7caSAdrian Chadd static int 4951692ad7caSAdrian Chadd wpi_load_firmware(struct wpi_softc *sc) 4952692ad7caSAdrian Chadd { 4953692ad7caSAdrian Chadd struct wpi_fw_info *fw = &sc->fw; 4954692ad7caSAdrian Chadd struct wpi_dma_info *dma = &sc->fw_dma; 4955692ad7caSAdrian Chadd int error; 4956692ad7caSAdrian Chadd 4957692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4958692ad7caSAdrian Chadd 4959692ad7caSAdrian Chadd /* Copy initialization sections into pre-allocated DMA-safe memory. */ 4960692ad7caSAdrian Chadd memcpy(dma->vaddr, fw->init.data, fw->init.datasz); 4961692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 4962692ad7caSAdrian Chadd memcpy(dma->vaddr + WPI_FW_DATA_MAXSZ, fw->init.text, fw->init.textsz); 4963692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 4964692ad7caSAdrian Chadd 4965692ad7caSAdrian Chadd /* Tell adapter where to find initialization sections. */ 4966692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4967692ad7caSAdrian Chadd return error; 4968692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_DATA_ADDR, dma->paddr); 4969692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_DATA_SIZE, fw->init.datasz); 4970692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_ADDR, 4971692ad7caSAdrian Chadd dma->paddr + WPI_FW_DATA_MAXSZ); 4972692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_SIZE, fw->init.textsz); 4973692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4974692ad7caSAdrian Chadd 4975692ad7caSAdrian Chadd /* Load firmware boot code. */ 4976692ad7caSAdrian Chadd error = wpi_load_bootcode(sc, fw->boot.text, fw->boot.textsz); 4977692ad7caSAdrian Chadd if (error != 0) { 4978692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not load boot firmware\n", 4979692ad7caSAdrian Chadd __func__); 49806607310bSBenjamin Close return error; 49816607310bSBenjamin Close } 49826607310bSBenjamin Close 4983692ad7caSAdrian Chadd /* Now press "execute". */ 4984692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_RESET, 0); 4985692ad7caSAdrian Chadd 4986692ad7caSAdrian Chadd /* Wait at most one second for first alive notification. */ 498776fdf7ebSAdrian Chadd if ((error = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) { 4988692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4989692ad7caSAdrian Chadd "%s: timeout waiting for adapter to initialize, error %d\n", 4990692ad7caSAdrian Chadd __func__, error); 49916607310bSBenjamin Close return error; 49926607310bSBenjamin Close } 49936607310bSBenjamin Close 4994692ad7caSAdrian Chadd /* Copy runtime sections into pre-allocated DMA-safe memory. */ 4995692ad7caSAdrian Chadd memcpy(dma->vaddr, fw->main.data, fw->main.datasz); 4996692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 4997692ad7caSAdrian Chadd memcpy(dma->vaddr + WPI_FW_DATA_MAXSZ, fw->main.text, fw->main.textsz); 4998692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 4999692ad7caSAdrian Chadd 5000692ad7caSAdrian Chadd /* Tell adapter where to find runtime sections. */ 5001692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 5002692ad7caSAdrian Chadd return error; 5003692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_DATA_ADDR, dma->paddr); 5004692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_DATA_SIZE, fw->main.datasz); 5005692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_ADDR, 5006692ad7caSAdrian Chadd dma->paddr + WPI_FW_DATA_MAXSZ); 5007692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_SIZE, 5008692ad7caSAdrian Chadd WPI_FW_UPDATED | fw->main.textsz); 5009692ad7caSAdrian Chadd wpi_nic_unlock(sc); 5010692ad7caSAdrian Chadd 5011692ad7caSAdrian Chadd return 0; 5012692ad7caSAdrian Chadd } 5013692ad7caSAdrian Chadd 5014692ad7caSAdrian Chadd static int 5015692ad7caSAdrian Chadd wpi_read_firmware(struct wpi_softc *sc) 5016692ad7caSAdrian Chadd { 5017692ad7caSAdrian Chadd const struct firmware *fp; 5018692ad7caSAdrian Chadd struct wpi_fw_info *fw = &sc->fw; 5019692ad7caSAdrian Chadd const struct wpi_firmware_hdr *hdr; 5020692ad7caSAdrian Chadd int error; 5021692ad7caSAdrian Chadd 5022692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 5023692ad7caSAdrian Chadd 5024692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, 5025692ad7caSAdrian Chadd "Attempting Loading Firmware from %s module\n", WPI_FW_NAME); 5026692ad7caSAdrian Chadd 5027692ad7caSAdrian Chadd WPI_UNLOCK(sc); 5028692ad7caSAdrian Chadd fp = firmware_get(WPI_FW_NAME); 5029692ad7caSAdrian Chadd WPI_LOCK(sc); 5030692ad7caSAdrian Chadd 5031692ad7caSAdrian Chadd if (fp == NULL) { 5032692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5033692ad7caSAdrian Chadd "could not load firmware image '%s'\n", WPI_FW_NAME); 5034692ad7caSAdrian Chadd return EINVAL; 5035692ad7caSAdrian Chadd } 5036692ad7caSAdrian Chadd 5037692ad7caSAdrian Chadd sc->fw_fp = fp; 5038692ad7caSAdrian Chadd 5039692ad7caSAdrian Chadd if (fp->datasize < sizeof (struct wpi_firmware_hdr)) { 5040692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5041692ad7caSAdrian Chadd "firmware file too short: %zu bytes\n", fp->datasize); 5042692ad7caSAdrian Chadd error = EINVAL; 5043692ad7caSAdrian Chadd goto fail; 5044692ad7caSAdrian Chadd } 5045692ad7caSAdrian Chadd 5046692ad7caSAdrian Chadd fw->size = fp->datasize; 5047692ad7caSAdrian Chadd fw->data = (const uint8_t *)fp->data; 5048692ad7caSAdrian Chadd 5049692ad7caSAdrian Chadd /* Extract firmware header information. */ 5050692ad7caSAdrian Chadd hdr = (const struct wpi_firmware_hdr *)fw->data; 5051692ad7caSAdrian Chadd 5052692ad7caSAdrian Chadd /* | RUNTIME FIRMWARE | INIT FIRMWARE | BOOT FW | 5053692ad7caSAdrian Chadd |HDR|<--TEXT-->|<--DATA-->|<--TEXT-->|<--DATA-->|<--TEXT-->| */ 5054692ad7caSAdrian Chadd 5055692ad7caSAdrian Chadd fw->main.textsz = le32toh(hdr->rtextsz); 5056692ad7caSAdrian Chadd fw->main.datasz = le32toh(hdr->rdatasz); 5057692ad7caSAdrian Chadd fw->init.textsz = le32toh(hdr->itextsz); 5058692ad7caSAdrian Chadd fw->init.datasz = le32toh(hdr->idatasz); 5059692ad7caSAdrian Chadd fw->boot.textsz = le32toh(hdr->btextsz); 5060692ad7caSAdrian Chadd fw->boot.datasz = 0; 5061692ad7caSAdrian Chadd 5062692ad7caSAdrian Chadd /* Sanity-check firmware header. */ 5063692ad7caSAdrian Chadd if (fw->main.textsz > WPI_FW_TEXT_MAXSZ || 5064692ad7caSAdrian Chadd fw->main.datasz > WPI_FW_DATA_MAXSZ || 5065692ad7caSAdrian Chadd fw->init.textsz > WPI_FW_TEXT_MAXSZ || 5066692ad7caSAdrian Chadd fw->init.datasz > WPI_FW_DATA_MAXSZ || 5067692ad7caSAdrian Chadd fw->boot.textsz > WPI_FW_BOOT_TEXT_MAXSZ || 5068692ad7caSAdrian Chadd (fw->boot.textsz & 3) != 0) { 5069692ad7caSAdrian Chadd device_printf(sc->sc_dev, "invalid firmware header\n"); 5070692ad7caSAdrian Chadd error = EINVAL; 5071692ad7caSAdrian Chadd goto fail; 5072692ad7caSAdrian Chadd } 5073692ad7caSAdrian Chadd 5074692ad7caSAdrian Chadd /* Check that all firmware sections fit. */ 5075692ad7caSAdrian Chadd if (fw->size < sizeof (*hdr) + fw->main.textsz + fw->main.datasz + 5076692ad7caSAdrian Chadd fw->init.textsz + fw->init.datasz + fw->boot.textsz) { 5077692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5078692ad7caSAdrian Chadd "firmware file too short: %zu bytes\n", fw->size); 5079692ad7caSAdrian Chadd error = EINVAL; 5080692ad7caSAdrian Chadd goto fail; 5081692ad7caSAdrian Chadd } 5082692ad7caSAdrian Chadd 5083692ad7caSAdrian Chadd /* Get pointers to firmware sections. */ 5084692ad7caSAdrian Chadd fw->main.text = (const uint8_t *)(hdr + 1); 5085692ad7caSAdrian Chadd fw->main.data = fw->main.text + fw->main.textsz; 5086692ad7caSAdrian Chadd fw->init.text = fw->main.data + fw->main.datasz; 5087692ad7caSAdrian Chadd fw->init.data = fw->init.text + fw->init.textsz; 5088692ad7caSAdrian Chadd fw->boot.text = fw->init.data + fw->init.datasz; 5089692ad7caSAdrian Chadd 5090692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, 5091692ad7caSAdrian Chadd "Firmware Version: Major %d, Minor %d, Driver %d, \n" 50927167f5fcSAdrian Chadd "runtime (text: %u, data: %u) init (text: %u, data %u) " 50937167f5fcSAdrian Chadd "boot (text %u)\n", hdr->major, hdr->minor, le32toh(hdr->driver), 5094692ad7caSAdrian Chadd fw->main.textsz, fw->main.datasz, 5095692ad7caSAdrian Chadd fw->init.textsz, fw->init.datasz, fw->boot.textsz); 5096692ad7caSAdrian Chadd 5097692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->main.text %p\n", fw->main.text); 5098692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->main.data %p\n", fw->main.data); 5099692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->init.text %p\n", fw->init.text); 5100692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->init.data %p\n", fw->init.data); 5101692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->boot.text %p\n", fw->boot.text); 5102692ad7caSAdrian Chadd 5103692ad7caSAdrian Chadd return 0; 5104692ad7caSAdrian Chadd 5105692ad7caSAdrian Chadd fail: wpi_unload_firmware(sc); 5106692ad7caSAdrian Chadd return error; 5107692ad7caSAdrian Chadd } 5108692ad7caSAdrian Chadd 5109692ad7caSAdrian Chadd /** 5110692ad7caSAdrian Chadd * Free the referenced firmware image 5111692ad7caSAdrian Chadd */ 5112692ad7caSAdrian Chadd static void 5113692ad7caSAdrian Chadd wpi_unload_firmware(struct wpi_softc *sc) 5114692ad7caSAdrian Chadd { 5115692ad7caSAdrian Chadd if (sc->fw_fp != NULL) { 5116692ad7caSAdrian Chadd firmware_put(sc->fw_fp, FIRMWARE_UNLOAD); 5117692ad7caSAdrian Chadd sc->fw_fp = NULL; 5118692ad7caSAdrian Chadd } 5119692ad7caSAdrian Chadd } 5120692ad7caSAdrian Chadd 5121692ad7caSAdrian Chadd static int 5122692ad7caSAdrian Chadd wpi_clock_wait(struct wpi_softc *sc) 5123692ad7caSAdrian Chadd { 5124692ad7caSAdrian Chadd int ntries; 5125692ad7caSAdrian Chadd 5126692ad7caSAdrian Chadd /* Set "initialization complete" bit. */ 5127692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_INIT_DONE); 5128692ad7caSAdrian Chadd 5129692ad7caSAdrian Chadd /* Wait for clock stabilization. */ 5130692ad7caSAdrian Chadd for (ntries = 0; ntries < 2500; ntries++) { 5131692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_MAC_CLOCK_READY) 5132692ad7caSAdrian Chadd return 0; 5133692ad7caSAdrian Chadd DELAY(100); 5134692ad7caSAdrian Chadd } 5135692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5136692ad7caSAdrian Chadd "%s: timeout waiting for clock stabilization\n", __func__); 5137692ad7caSAdrian Chadd 5138692ad7caSAdrian Chadd return ETIMEDOUT; 5139692ad7caSAdrian Chadd } 5140692ad7caSAdrian Chadd 5141692ad7caSAdrian Chadd static int 5142692ad7caSAdrian Chadd wpi_apm_init(struct wpi_softc *sc) 5143692ad7caSAdrian Chadd { 5144692ad7caSAdrian Chadd uint32_t reg; 5145692ad7caSAdrian Chadd int error; 5146692ad7caSAdrian Chadd 5147692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 5148692ad7caSAdrian Chadd 5149692ad7caSAdrian Chadd /* Disable L0s exit timer (NMI bug workaround). */ 5150692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GIO_CHICKEN, WPI_GIO_CHICKEN_DIS_L0S_TIMER); 5151692ad7caSAdrian Chadd /* Don't wait for ICH L0s (ICH bug workaround). */ 5152692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GIO_CHICKEN, WPI_GIO_CHICKEN_L1A_NO_L0S_RX); 5153692ad7caSAdrian Chadd 5154692ad7caSAdrian Chadd /* Set FH wait threshold to max (HW bug under stress workaround). */ 5155692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_DBG_HPET_MEM, 0xffff0000); 5156692ad7caSAdrian Chadd 5157692ad7caSAdrian Chadd /* Retrieve PCIe Active State Power Management (ASPM). */ 51587c2e8d33SAndriy Voskoboinyk reg = pci_read_config(sc->sc_dev, sc->sc_cap_off + PCIER_LINK_CTL, 1); 5159692ad7caSAdrian Chadd /* Workaround for HW instability in PCIe L0->L0s->L1 transition. */ 51607c2e8d33SAndriy Voskoboinyk if (reg & PCIEM_LINK_CTL_ASPMC_L1) /* L1 Entry enabled. */ 5161692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GIO, WPI_GIO_L0S_ENA); 5162692ad7caSAdrian Chadd else 5163692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_GIO, WPI_GIO_L0S_ENA); 5164692ad7caSAdrian Chadd 5165692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_ANA_PLL, WPI_ANA_PLL_INIT); 5166692ad7caSAdrian Chadd 5167692ad7caSAdrian Chadd /* Wait for clock stabilization before accessing prph. */ 5168692ad7caSAdrian Chadd if ((error = wpi_clock_wait(sc)) != 0) 5169692ad7caSAdrian Chadd return error; 5170692ad7caSAdrian Chadd 5171692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 5172692ad7caSAdrian Chadd return error; 517302d49915SAdrian Chadd /* Cleanup. */ 517402d49915SAdrian Chadd wpi_prph_write(sc, WPI_APMG_CLK_DIS, 0x00000400); 517502d49915SAdrian Chadd wpi_prph_clrbits(sc, WPI_APMG_PS, 0x00000200); 517602d49915SAdrian Chadd 5177692ad7caSAdrian Chadd /* Enable DMA and BSM (Bootstrap State Machine). */ 5178692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_APMG_CLK_EN, 5179692ad7caSAdrian Chadd WPI_APMG_CLK_CTRL_DMA_CLK_RQT | WPI_APMG_CLK_CTRL_BSM_CLK_RQT); 5180692ad7caSAdrian Chadd DELAY(20); 5181692ad7caSAdrian Chadd /* Disable L1-Active. */ 5182692ad7caSAdrian Chadd wpi_prph_setbits(sc, WPI_APMG_PCI_STT, WPI_APMG_PCI_STT_L1A_DIS); 5183692ad7caSAdrian Chadd wpi_nic_unlock(sc); 5184692ad7caSAdrian Chadd 51856607310bSBenjamin Close return 0; 51866607310bSBenjamin Close } 51876607310bSBenjamin Close 51886607310bSBenjamin Close static void 5189692ad7caSAdrian Chadd wpi_apm_stop_master(struct wpi_softc *sc) 51906607310bSBenjamin Close { 51916607310bSBenjamin Close int ntries; 51926607310bSBenjamin Close 5193692ad7caSAdrian Chadd /* Stop busmaster DMA activity. */ 5194692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_RESET, WPI_RESET_STOP_MASTER); 51956607310bSBenjamin Close 5196692ad7caSAdrian Chadd if ((WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_PS_MASK) == 5197692ad7caSAdrian Chadd WPI_GP_CNTRL_MAC_PS) 5198692ad7caSAdrian Chadd return; /* Already asleep. */ 51996607310bSBenjamin Close 52006607310bSBenjamin Close for (ntries = 0; ntries < 100; ntries++) { 5201692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_RESET) & WPI_RESET_MASTER_DISABLED) 5202692ad7caSAdrian Chadd return; 52036607310bSBenjamin Close DELAY(10); 52046607310bSBenjamin Close } 52057167f5fcSAdrian Chadd device_printf(sc->sc_dev, "%s: timeout waiting for master\n", 52067167f5fcSAdrian Chadd __func__); 52076607310bSBenjamin Close } 5208692ad7caSAdrian Chadd 5209692ad7caSAdrian Chadd static void 5210692ad7caSAdrian Chadd wpi_apm_stop(struct wpi_softc *sc) 5211692ad7caSAdrian Chadd { 5212692ad7caSAdrian Chadd wpi_apm_stop_master(sc); 5213692ad7caSAdrian Chadd 5214692ad7caSAdrian Chadd /* Reset the entire device. */ 5215692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_RESET, WPI_RESET_SW); 5216692ad7caSAdrian Chadd DELAY(10); 5217692ad7caSAdrian Chadd /* Clear "initialization complete" bit. */ 5218692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_INIT_DONE); 5219692ad7caSAdrian Chadd } 5220692ad7caSAdrian Chadd 5221692ad7caSAdrian Chadd static void 5222692ad7caSAdrian Chadd wpi_nic_config(struct wpi_softc *sc) 5223692ad7caSAdrian Chadd { 5224692ad7caSAdrian Chadd uint32_t rev; 5225692ad7caSAdrian Chadd 5226692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 5227692ad7caSAdrian Chadd 5228692ad7caSAdrian Chadd /* voodoo from the Linux "driver".. */ 5229692ad7caSAdrian Chadd rev = pci_read_config(sc->sc_dev, PCIR_REVID, 1); 5230692ad7caSAdrian Chadd if ((rev & 0xc0) == 0x40) 5231692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_ALM_MB); 5232692ad7caSAdrian Chadd else if (!(rev & 0x80)) 5233692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_ALM_MM); 5234692ad7caSAdrian Chadd 5235692ad7caSAdrian Chadd if (sc->cap == 0x80) 5236692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_SKU_MRC); 5237692ad7caSAdrian Chadd 5238f736d898SAdrian Chadd if ((sc->rev & 0xf0) == 0xd0) 5239692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_REV_D); 5240692ad7caSAdrian Chadd else 5241692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_REV_D); 5242692ad7caSAdrian Chadd 5243692ad7caSAdrian Chadd if (sc->type > 1) 5244692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_TYPE_B); 52456607310bSBenjamin Close } 52466607310bSBenjamin Close 52476607310bSBenjamin Close static int 5248692ad7caSAdrian Chadd wpi_hw_init(struct wpi_softc *sc) 52496607310bSBenjamin Close { 5250525a3d47SAdrian Chadd uint8_t chnl; 5251525a3d47SAdrian Chadd int ntries, error; 52526607310bSBenjamin Close 5253692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 52546607310bSBenjamin Close 5255692ad7caSAdrian Chadd /* Clear pending interrupts. */ 5256692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, 0xffffffff); 5257692ad7caSAdrian Chadd 5258692ad7caSAdrian Chadd if ((error = wpi_apm_init(sc)) != 0) { 5259692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5260692ad7caSAdrian Chadd "%s: could not power ON adapter, error %d\n", __func__, 5261692ad7caSAdrian Chadd error); 5262692ad7caSAdrian Chadd return error; 5263692ad7caSAdrian Chadd } 5264692ad7caSAdrian Chadd 5265692ad7caSAdrian Chadd /* Select VMAIN power source. */ 5266692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 5267692ad7caSAdrian Chadd return error; 5268692ad7caSAdrian Chadd wpi_prph_clrbits(sc, WPI_APMG_PS, WPI_APMG_PS_PWR_SRC_MASK); 5269692ad7caSAdrian Chadd wpi_nic_unlock(sc); 5270692ad7caSAdrian Chadd /* Spin until VMAIN gets selected. */ 52716607310bSBenjamin Close for (ntries = 0; ntries < 5000; ntries++) { 5272692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_GPIO_IN) & WPI_GPIO_IN_VMAIN) 52736607310bSBenjamin Close break; 52746607310bSBenjamin Close DELAY(10); 52756607310bSBenjamin Close } 52766607310bSBenjamin Close if (ntries == 5000) { 5277692ad7caSAdrian Chadd device_printf(sc->sc_dev, "timeout selecting power source\n"); 52786607310bSBenjamin Close return ETIMEDOUT; 52796607310bSBenjamin Close } 5280692ad7caSAdrian Chadd 5281692ad7caSAdrian Chadd /* Perform adapter initialization. */ 5282692ad7caSAdrian Chadd wpi_nic_config(sc); 5283692ad7caSAdrian Chadd 5284692ad7caSAdrian Chadd /* Initialize RX ring. */ 5285692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 5286692ad7caSAdrian Chadd return error; 5287692ad7caSAdrian Chadd /* Set physical address of RX ring. */ 5288692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_BASE, sc->rxq.desc_dma.paddr); 5289692ad7caSAdrian Chadd /* Set physical address of RX read pointer. */ 5290692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_RPTR_ADDR, sc->shared_dma.paddr + 5291692ad7caSAdrian Chadd offsetof(struct wpi_shared, next)); 5292692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_WPTR, 0); 5293692ad7caSAdrian Chadd /* Enable RX. */ 5294692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_CONFIG, 5295692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_DMA_ENA | 5296692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_RDRBD_ENA | 5297692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_WRSTATUS_ENA | 5298692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_MAXFRAG | 5299692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_NRBD(WPI_RX_RING_COUNT_LOG) | 5300692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_IRQ_DST_HOST | 5301692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_IRQ_TIMEOUT(1)); 5302692ad7caSAdrian Chadd (void)WPI_READ(sc, WPI_FH_RSSR_TBL); /* barrier */ 5303692ad7caSAdrian Chadd wpi_nic_unlock(sc); 5304692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_WPTR, (WPI_RX_RING_COUNT - 1) & ~7); 5305692ad7caSAdrian Chadd 5306692ad7caSAdrian Chadd /* Initialize TX rings. */ 5307692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 5308692ad7caSAdrian Chadd return error; 5309692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_MODE, 2); /* bypass mode */ 5310692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_ARASTAT, 1); /* enable RA0 */ 5311692ad7caSAdrian Chadd /* Enable all 6 TX rings. */ 5312692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_TXFACT, 0x3f); 5313692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_SBYPASS_MODE1, 0x10000); 5314692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_SBYPASS_MODE2, 0x30002); 5315692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_TXF4MF, 4); 5316692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_TXF5MF, 5); 5317692ad7caSAdrian Chadd /* Set physical address of TX rings. */ 5318692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_TX_BASE, sc->shared_dma.paddr); 5319692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_MSG_CONFIG, 0xffff05a5); 5320692ad7caSAdrian Chadd 5321692ad7caSAdrian Chadd /* Enable all DMA channels. */ 5322692ad7caSAdrian Chadd for (chnl = 0; chnl < WPI_NDMACHNLS; chnl++) { 5323692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_CBBC_CTRL(chnl), 0); 5324692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_CBBC_BASE(chnl), 0); 5325692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_TX_CONFIG(chnl), 0x80200008); 5326692ad7caSAdrian Chadd } 5327692ad7caSAdrian Chadd wpi_nic_unlock(sc); 5328692ad7caSAdrian Chadd (void)WPI_READ(sc, WPI_FH_TX_BASE); /* barrier */ 5329692ad7caSAdrian Chadd 5330692ad7caSAdrian Chadd /* Clear "radio off" and "commands blocked" bits. */ 5331692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL); 5332692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_CMD_BLOCKED); 5333692ad7caSAdrian Chadd 5334692ad7caSAdrian Chadd /* Clear pending interrupts. */ 5335692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, 0xffffffff); 5336692ad7caSAdrian Chadd /* Enable interrupts. */ 5337692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT_MASK, WPI_INT_MASK_DEF); 5338692ad7caSAdrian Chadd 5339692ad7caSAdrian Chadd /* _Really_ make sure "radio off" bit is cleared! */ 5340692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL); 5341692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL); 5342692ad7caSAdrian Chadd 5343692ad7caSAdrian Chadd if ((error = wpi_load_firmware(sc)) != 0) { 5344692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5345692ad7caSAdrian Chadd "%s: could not load firmware, error %d\n", __func__, 5346692ad7caSAdrian Chadd error); 5347692ad7caSAdrian Chadd return error; 5348692ad7caSAdrian Chadd } 5349692ad7caSAdrian Chadd /* Wait at most one second for firmware alive notification. */ 535076fdf7ebSAdrian Chadd if ((error = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) { 5351692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5352692ad7caSAdrian Chadd "%s: timeout waiting for adapter to initialize, error %d\n", 5353692ad7caSAdrian Chadd __func__, error); 5354692ad7caSAdrian Chadd return error; 53556607310bSBenjamin Close } 53566607310bSBenjamin Close 5357692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 5358692ad7caSAdrian Chadd 5359692ad7caSAdrian Chadd /* Do post-firmware initialization. */ 5360692ad7caSAdrian Chadd return wpi_post_alive(sc); 5361692ad7caSAdrian Chadd } 5362692ad7caSAdrian Chadd 5363692ad7caSAdrian Chadd static void 5364692ad7caSAdrian Chadd wpi_hw_stop(struct wpi_softc *sc) 53656607310bSBenjamin Close { 5366525a3d47SAdrian Chadd uint8_t chnl, qid; 5367525a3d47SAdrian Chadd int ntries; 53686607310bSBenjamin Close 5369692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 53706607310bSBenjamin Close 5371692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_UCODE_GP1) & WPI_UCODE_GP1_MAC_SLEEP) 5372692ad7caSAdrian Chadd wpi_nic_lock(sc); 53736607310bSBenjamin Close 5374692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_RESET, WPI_RESET_NEVO); 53756607310bSBenjamin Close 5376692ad7caSAdrian Chadd /* Disable interrupts. */ 5377692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT_MASK, 0); 5378692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, 0xffffffff); 5379692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_INT, 0xffffffff); 53806607310bSBenjamin Close 5381692ad7caSAdrian Chadd /* Make sure we no longer hold the NIC lock. */ 5382692ad7caSAdrian Chadd wpi_nic_unlock(sc); 53836607310bSBenjamin Close 5384692ad7caSAdrian Chadd if (wpi_nic_lock(sc) == 0) { 5385692ad7caSAdrian Chadd /* Stop TX scheduler. */ 5386692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_MODE, 0); 5387692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_TXFACT, 0); 5388692ad7caSAdrian Chadd 5389692ad7caSAdrian Chadd /* Stop all DMA channels. */ 5390692ad7caSAdrian Chadd for (chnl = 0; chnl < WPI_NDMACHNLS; chnl++) { 5391692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_TX_CONFIG(chnl), 0); 5392692ad7caSAdrian Chadd for (ntries = 0; ntries < 200; ntries++) { 5393692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_FH_TX_STATUS) & 5394692ad7caSAdrian Chadd WPI_FH_TX_STATUS_IDLE(chnl)) 53956607310bSBenjamin Close break; 53966607310bSBenjamin Close DELAY(10); 53976607310bSBenjamin Close } 5398692ad7caSAdrian Chadd } 5399692ad7caSAdrian Chadd wpi_nic_unlock(sc); 54006607310bSBenjamin Close } 54016607310bSBenjamin Close 5402692ad7caSAdrian Chadd /* Stop RX ring. */ 5403692ad7caSAdrian Chadd wpi_reset_rx_ring(sc); 54046607310bSBenjamin Close 5405692ad7caSAdrian Chadd /* Reset all TX rings. */ 540619053a54SAdrian Chadd for (qid = 0; qid < WPI_DRV_NTXQUEUES; qid++) 5407692ad7caSAdrian Chadd wpi_reset_tx_ring(sc, &sc->txq[qid]); 5408692ad7caSAdrian Chadd 5409692ad7caSAdrian Chadd if (wpi_nic_lock(sc) == 0) { 5410692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_APMG_CLK_DIS, 5411692ad7caSAdrian Chadd WPI_APMG_CLK_CTRL_DMA_CLK_RQT); 5412692ad7caSAdrian Chadd wpi_nic_unlock(sc); 54136607310bSBenjamin Close } 5414692ad7caSAdrian Chadd DELAY(5); 5415692ad7caSAdrian Chadd /* Power OFF adapter. */ 5416692ad7caSAdrian Chadd wpi_apm_stop(sc); 54176607310bSBenjamin Close } 54186607310bSBenjamin Close 54196607310bSBenjamin Close static void 5420692ad7caSAdrian Chadd wpi_radio_on(void *arg0, int pending) 54216607310bSBenjamin Close { 5422692ad7caSAdrian Chadd struct wpi_softc *sc = arg0; 54237a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 5424b032f27cSSam Leffler struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 542582f1b132SAndrew Thompson 5426692ad7caSAdrian Chadd device_printf(sc->sc_dev, "RF switch: radio enabled\n"); 542782f1b132SAndrew Thompson 5428692ad7caSAdrian Chadd WPI_LOCK(sc); 5429692ad7caSAdrian Chadd callout_stop(&sc->watchdog_rfkill); 5430692ad7caSAdrian Chadd WPI_UNLOCK(sc); 54317a79cebfSGleb Smirnoff 54327a79cebfSGleb Smirnoff if (vap != NULL) 54337a79cebfSGleb Smirnoff ieee80211_init(vap); 543482f1b132SAndrew Thompson } 543582f1b132SAndrew Thompson 543682f1b132SAndrew Thompson static void 5437692ad7caSAdrian Chadd wpi_radio_off(void *arg0, int pending) 5438692ad7caSAdrian Chadd { 5439692ad7caSAdrian Chadd struct wpi_softc *sc = arg0; 54407a79cebfSGleb Smirnoff struct ieee80211com *ic = &sc->sc_ic; 5441692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 5442692ad7caSAdrian Chadd 5443692ad7caSAdrian Chadd device_printf(sc->sc_dev, "RF switch: radio disabled\n"); 5444692ad7caSAdrian Chadd 54457a79cebfSGleb Smirnoff ieee80211_notify_radio(ic, 0); 5446692ad7caSAdrian Chadd wpi_stop(sc); 5447692ad7caSAdrian Chadd if (vap != NULL) 5448692ad7caSAdrian Chadd ieee80211_stop(vap); 5449692ad7caSAdrian Chadd 5450811fe0a8SAdrian Chadd WPI_LOCK(sc); 5451692ad7caSAdrian Chadd callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill, sc); 5452811fe0a8SAdrian Chadd WPI_UNLOCK(sc); 5453692ad7caSAdrian Chadd } 5454692ad7caSAdrian Chadd 54557a79cebfSGleb Smirnoff static int 54567a79cebfSGleb Smirnoff wpi_init(struct wpi_softc *sc) 545782f1b132SAndrew Thompson { 54587a79cebfSGleb Smirnoff int error = 0; 54596607310bSBenjamin Close 546077cf0b82SAdrian Chadd WPI_LOCK(sc); 546177cf0b82SAdrian Chadd 5462692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 54636607310bSBenjamin Close 54647a79cebfSGleb Smirnoff if (sc->sc_running != 0) 546577cf0b82SAdrian Chadd goto end; 54666607310bSBenjamin Close 5467692ad7caSAdrian Chadd /* Check that the radio is not disabled by hardware switch. */ 5468692ad7caSAdrian Chadd if (!(WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_RFKILL)) { 54696607310bSBenjamin Close device_printf(sc->sc_dev, 5470692ad7caSAdrian Chadd "RF switch: radio disabled (%s)\n", __func__); 5471692ad7caSAdrian Chadd callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill, 5472692ad7caSAdrian Chadd sc); 54737a79cebfSGleb Smirnoff error = EINPROGRESS; 547477cf0b82SAdrian Chadd goto end; 54756607310bSBenjamin Close } 54766607310bSBenjamin Close 5477692ad7caSAdrian Chadd /* Read firmware images from the filesystem. */ 5478692ad7caSAdrian Chadd if ((error = wpi_read_firmware(sc)) != 0) { 54796607310bSBenjamin Close device_printf(sc->sc_dev, 5480692ad7caSAdrian Chadd "%s: could not read firmware, error %d\n", __func__, 5481692ad7caSAdrian Chadd error); 54827a79cebfSGleb Smirnoff goto end; 54836607310bSBenjamin Close } 54846607310bSBenjamin Close 54857a79cebfSGleb Smirnoff sc->sc_running = 1; 54867a79cebfSGleb Smirnoff 5487692ad7caSAdrian Chadd /* Initialize hardware and upload firmware. */ 5488692ad7caSAdrian Chadd error = wpi_hw_init(sc); 5489692ad7caSAdrian Chadd wpi_unload_firmware(sc); 5490692ad7caSAdrian Chadd if (error != 0) { 5491692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5492692ad7caSAdrian Chadd "%s: could not initialize hardware, error %d\n", __func__, 5493692ad7caSAdrian Chadd error); 5494692ad7caSAdrian Chadd goto fail; 5495692ad7caSAdrian Chadd } 5496692ad7caSAdrian Chadd 5497692ad7caSAdrian Chadd /* Configure adapter now that it is ready. */ 5498692ad7caSAdrian Chadd if ((error = wpi_config(sc)) != 0) { 5499692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5500692ad7caSAdrian Chadd "%s: could not configure device, error %d\n", __func__, 5501692ad7caSAdrian Chadd error); 5502692ad7caSAdrian Chadd goto fail; 550382f1b132SAndrew Thompson } 550482f1b132SAndrew Thompson 5505692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 5506692ad7caSAdrian Chadd 550777cf0b82SAdrian Chadd WPI_UNLOCK(sc); 550877cf0b82SAdrian Chadd 55097a79cebfSGleb Smirnoff return 0; 5510692ad7caSAdrian Chadd 5511692ad7caSAdrian Chadd fail: wpi_stop_locked(sc); 55127a79cebfSGleb Smirnoff 551377cf0b82SAdrian Chadd end: DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 55146607310bSBenjamin Close WPI_UNLOCK(sc); 55157a79cebfSGleb Smirnoff 55167a79cebfSGleb Smirnoff return error; 55176607310bSBenjamin Close } 5518b032f27cSSam Leffler 55196607310bSBenjamin Close static void 55206607310bSBenjamin Close wpi_stop_locked(struct wpi_softc *sc) 55216607310bSBenjamin Close { 55226607310bSBenjamin Close 5523692ad7caSAdrian Chadd WPI_LOCK_ASSERT(sc); 5524692ad7caSAdrian Chadd 55257a79cebfSGleb Smirnoff if (sc->sc_running == 0) 55267a79cebfSGleb Smirnoff return; 55277a79cebfSGleb Smirnoff 55287a79cebfSGleb Smirnoff WPI_TX_LOCK(sc); 552963f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 55307a79cebfSGleb Smirnoff sc->sc_running = 0; 553163f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 55327a79cebfSGleb Smirnoff WPI_TX_UNLOCK(sc); 553363f57699SAdrian Chadd 5534fc5870b4SAdrian Chadd WPI_TXQ_STATE_LOCK(sc); 5535d74e544aSAdrian Chadd callout_stop(&sc->tx_timeout); 5536fc5870b4SAdrian Chadd WPI_TXQ_STATE_UNLOCK(sc); 5537446685e4SAdrian Chadd 5538446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 55390bc39fc6SAdrian Chadd callout_stop(&sc->scan_timeout); 554082f1b132SAndrew Thompson callout_stop(&sc->calib_to); 5541446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 5542b9858d86SAdrian Chadd 5543692ad7caSAdrian Chadd /* Power OFF hardware. */ 5544692ad7caSAdrian Chadd wpi_hw_stop(sc); 55456607310bSBenjamin Close } 55466607310bSBenjamin Close 55476607310bSBenjamin Close static void 5548b032f27cSSam Leffler wpi_stop(struct wpi_softc *sc) 55496607310bSBenjamin Close { 5550b032f27cSSam Leffler WPI_LOCK(sc); 5551b032f27cSSam Leffler wpi_stop_locked(sc); 5552b032f27cSSam Leffler WPI_UNLOCK(sc); 55536607310bSBenjamin Close } 55546607310bSBenjamin Close 55556607310bSBenjamin Close /* 5556692ad7caSAdrian Chadd * Callback from net80211 to start a scan. 55576607310bSBenjamin Close */ 55586607310bSBenjamin Close static void 55596607310bSBenjamin Close wpi_scan_start(struct ieee80211com *ic) 55606607310bSBenjamin Close { 55612cb71df1SAdrian Chadd struct wpi_softc *sc = ic->ic_softc; 55626607310bSBenjamin Close 55635efea30fSAndrew Thompson wpi_set_led(sc, WPI_LED_LINK, 20, 2); 55646607310bSBenjamin Close } 55656607310bSBenjamin Close 5566692ad7caSAdrian Chadd /* 5567692ad7caSAdrian Chadd * Callback from net80211 to terminate a scan. 55686607310bSBenjamin Close */ 55696607310bSBenjamin Close static void 55706607310bSBenjamin Close wpi_scan_end(struct ieee80211com *ic) 55716607310bSBenjamin Close { 55722cb71df1SAdrian Chadd struct wpi_softc *sc = ic->ic_softc; 5573692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 5574692ad7caSAdrian Chadd 55750b093122SAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN) 5576692ad7caSAdrian Chadd wpi_set_led(sc, WPI_LED_LINK, 0, 1); 55776607310bSBenjamin Close } 55786607310bSBenjamin Close 55796607310bSBenjamin Close /** 55806607310bSBenjamin Close * Called by the net80211 framework to indicate to the driver 55816607310bSBenjamin Close * that the channel should be changed 55826607310bSBenjamin Close */ 55836607310bSBenjamin Close static void 55846607310bSBenjamin Close wpi_set_channel(struct ieee80211com *ic) 55856607310bSBenjamin Close { 5586692ad7caSAdrian Chadd const struct ieee80211_channel *c = ic->ic_curchan; 55872cb71df1SAdrian Chadd struct wpi_softc *sc = ic->ic_softc; 55885efea30fSAndrew Thompson int error; 55896607310bSBenjamin Close 5590692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 5591692ad7caSAdrian Chadd 5592692ad7caSAdrian Chadd WPI_LOCK(sc); 5593692ad7caSAdrian Chadd sc->sc_rxtap.wr_chan_freq = htole16(c->ic_freq); 5594692ad7caSAdrian Chadd sc->sc_rxtap.wr_chan_flags = htole16(c->ic_flags); 55955effcbfdSAdrian Chadd WPI_UNLOCK(sc); 55965effcbfdSAdrian Chadd WPI_TX_LOCK(sc); 5597692ad7caSAdrian Chadd sc->sc_txtap.wt_chan_freq = htole16(c->ic_freq); 5598692ad7caSAdrian Chadd sc->sc_txtap.wt_chan_flags = htole16(c->ic_flags); 55995effcbfdSAdrian Chadd WPI_TX_UNLOCK(sc); 5600692ad7caSAdrian Chadd 560182f1b132SAndrew Thompson /* 560282f1b132SAndrew Thompson * Only need to set the channel in Monitor mode. AP scanning and auth 560382f1b132SAndrew Thompson * are already taken care of by their respective firmware commands. 560482f1b132SAndrew Thompson */ 56055efea30fSAndrew Thompson if (ic->ic_opmode == IEEE80211_M_MONITOR) { 5606446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 5607692ad7caSAdrian Chadd sc->rxon.chan = ieee80211_chan2ieee(ic, c); 5608692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_2GHZ(c)) { 5609692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_AUTO | 5610692ad7caSAdrian Chadd WPI_RXON_24GHZ); 5611692ad7caSAdrian Chadd } else { 5612692ad7caSAdrian Chadd sc->rxon.flags &= ~htole32(WPI_RXON_AUTO | 5613692ad7caSAdrian Chadd WPI_RXON_24GHZ); 56145efea30fSAndrew Thompson } 5615446685e4SAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 1)) != 0) 5616692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5617cec45f04SAdrian Chadd "%s: error %d setting channel\n", __func__, 5618692ad7caSAdrian Chadd error); 5619446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 5620692ad7caSAdrian Chadd } 56216607310bSBenjamin Close } 56226607310bSBenjamin Close 56236607310bSBenjamin Close /** 56246607310bSBenjamin Close * Called by net80211 to indicate that we need to scan the current 56256607310bSBenjamin Close * channel. The channel is previously be set via the wpi_set_channel 56266607310bSBenjamin Close * callback. 56276607310bSBenjamin Close */ 56286607310bSBenjamin Close static void 5629b032f27cSSam Leffler wpi_scan_curchan(struct ieee80211_scan_state *ss, unsigned long maxdwell) 56306607310bSBenjamin Close { 5631b032f27cSSam Leffler struct ieee80211vap *vap = ss->ss_vap; 5632692ad7caSAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 56332cb71df1SAdrian Chadd struct wpi_softc *sc = ic->ic_softc; 5634692ad7caSAdrian Chadd int error; 56356607310bSBenjamin Close 5636446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 5637692ad7caSAdrian Chadd error = wpi_scan(sc, ic->ic_curchan); 5638446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 5639692ad7caSAdrian Chadd if (error != 0) 5640692ad7caSAdrian Chadd ieee80211_cancel_scan(vap); 56416607310bSBenjamin Close } 56426607310bSBenjamin Close 56436607310bSBenjamin Close /** 56446607310bSBenjamin Close * Called by the net80211 framework to indicate 56456607310bSBenjamin Close * the minimum dwell time has been met, terminate the scan. 56466607310bSBenjamin Close * We don't actually terminate the scan as the firmware will notify 56476607310bSBenjamin Close * us when it's finished and we have no way to interrupt it. 56486607310bSBenjamin Close */ 56496607310bSBenjamin Close static void 5650b032f27cSSam Leffler wpi_scan_mindwell(struct ieee80211_scan_state *ss) 56516607310bSBenjamin Close { 56526607310bSBenjamin Close /* NB: don't try to abort scan; wait for firmware to finish */ 56536607310bSBenjamin Close } 5654