16607310bSBenjamin Close /*- 26607310bSBenjamin Close * Copyright (c) 2006,2007 36607310bSBenjamin Close * Damien Bergamini <damien.bergamini@free.fr> 46607310bSBenjamin Close * Benjamin Close <Benjamin.Close@clearchain.com> 56607310bSBenjamin Close * 66607310bSBenjamin Close * Permission to use, copy, modify, and distribute this software for any 76607310bSBenjamin Close * purpose with or without fee is hereby granted, provided that the above 86607310bSBenjamin Close * copyright notice and this permission notice appear in all copies. 96607310bSBenjamin Close * 106607310bSBenjamin Close * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 116607310bSBenjamin Close * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 126607310bSBenjamin Close * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 136607310bSBenjamin Close * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 146607310bSBenjamin Close * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 156607310bSBenjamin Close * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 166607310bSBenjamin Close * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 176607310bSBenjamin Close */ 186607310bSBenjamin Close 196607310bSBenjamin Close #include <sys/cdefs.h> 206607310bSBenjamin Close __FBSDID("$FreeBSD$"); 216607310bSBenjamin Close 226607310bSBenjamin Close /* 236607310bSBenjamin Close * Driver for Intel PRO/Wireless 3945ABG 802.11 network adapters. 246607310bSBenjamin Close * 256607310bSBenjamin Close * The 3945ABG network adapter doesn't use traditional hardware as 266607310bSBenjamin Close * many other adaptors do. Instead at run time the eeprom is set into a known 276607310bSBenjamin Close * state and told to load boot firmware. The boot firmware loads an init and a 286607310bSBenjamin Close * main binary firmware image into SRAM on the card via DMA. 296607310bSBenjamin Close * Once the firmware is loaded, the driver/hw then 306bccea7cSRebecca Cran * communicate by way of circular dma rings via the SRAM to the firmware. 316607310bSBenjamin Close * 326607310bSBenjamin Close * There is 6 memory rings. 1 command ring, 1 rx data ring & 4 tx data rings. 336607310bSBenjamin Close * The 4 tx data rings allow for prioritization QoS. 346607310bSBenjamin Close * 356607310bSBenjamin Close * The rx data ring consists of 32 dma buffers. Two registers are used to 366607310bSBenjamin Close * indicate where in the ring the driver and the firmware are up to. The 376607310bSBenjamin Close * driver sets the initial read index (reg1) and the initial write index (reg2), 386607310bSBenjamin Close * the firmware updates the read index (reg1) on rx of a packet and fires an 396607310bSBenjamin Close * interrupt. The driver then processes the buffers starting at reg1 indicating 406607310bSBenjamin Close * to the firmware which buffers have been accessed by updating reg2. At the 416607310bSBenjamin Close * same time allocating new memory for the processed buffer. 426607310bSBenjamin Close * 436607310bSBenjamin Close * A similar thing happens with the tx rings. The difference is the firmware 446607310bSBenjamin Close * stop processing buffers once the queue is full and until confirmation 45fae61c69SAdrian Chadd * of a successful transmition (tx_done) has occurred. 466607310bSBenjamin Close * 476607310bSBenjamin Close * The command ring operates in the same manner as the tx queues. 486607310bSBenjamin Close * 496607310bSBenjamin Close * All communication direct to the card (ie eeprom) is classed as Stage1 506607310bSBenjamin Close * communication 516607310bSBenjamin Close * 526607310bSBenjamin Close * All communication via the firmware to the card is classed as State2. 536607310bSBenjamin Close * The firmware consists of 2 parts. A bootstrap firmware and a runtime 546607310bSBenjamin Close * firmware. The bootstrap firmware and runtime firmware are loaded 556607310bSBenjamin Close * from host memory via dma to the card then told to execute. From this point 566607310bSBenjamin Close * on the majority of communications between the driver and the card goes 576607310bSBenjamin Close * via the firmware. 586607310bSBenjamin Close */ 596607310bSBenjamin Close 6081c2214dSAdrian Chadd #include "opt_wlan.h" 61692ad7caSAdrian Chadd #include "opt_wpi.h" 6281c2214dSAdrian Chadd 636607310bSBenjamin Close #include <sys/param.h> 646607310bSBenjamin Close #include <sys/sysctl.h> 656607310bSBenjamin Close #include <sys/sockio.h> 666607310bSBenjamin Close #include <sys/mbuf.h> 676607310bSBenjamin Close #include <sys/kernel.h> 686607310bSBenjamin Close #include <sys/socket.h> 696607310bSBenjamin Close #include <sys/systm.h> 706607310bSBenjamin Close #include <sys/malloc.h> 716607310bSBenjamin Close #include <sys/queue.h> 726607310bSBenjamin Close #include <sys/taskqueue.h> 736607310bSBenjamin Close #include <sys/module.h> 746607310bSBenjamin Close #include <sys/bus.h> 756607310bSBenjamin Close #include <sys/endian.h> 766607310bSBenjamin Close #include <sys/linker.h> 776607310bSBenjamin Close #include <sys/firmware.h> 786607310bSBenjamin Close 796607310bSBenjamin Close #include <machine/bus.h> 806607310bSBenjamin Close #include <machine/resource.h> 816607310bSBenjamin Close #include <sys/rman.h> 826607310bSBenjamin Close 836607310bSBenjamin Close #include <dev/pci/pcireg.h> 846607310bSBenjamin Close #include <dev/pci/pcivar.h> 856607310bSBenjamin Close 866607310bSBenjamin Close #include <net/bpf.h> 876607310bSBenjamin Close #include <net/if.h> 8876039bc8SGleb Smirnoff #include <net/if_var.h> 896607310bSBenjamin Close #include <net/if_arp.h> 906607310bSBenjamin Close #include <net/ethernet.h> 916607310bSBenjamin Close #include <net/if_dl.h> 926607310bSBenjamin Close #include <net/if_media.h> 936607310bSBenjamin Close #include <net/if_types.h> 946607310bSBenjamin Close 95692ad7caSAdrian Chadd #include <netinet/in.h> 96692ad7caSAdrian Chadd #include <netinet/in_systm.h> 97692ad7caSAdrian Chadd #include <netinet/in_var.h> 98692ad7caSAdrian Chadd #include <netinet/if_ether.h> 99692ad7caSAdrian Chadd #include <netinet/ip.h> 100692ad7caSAdrian Chadd 1016607310bSBenjamin Close #include <net80211/ieee80211_var.h> 1026607310bSBenjamin Close #include <net80211/ieee80211_radiotap.h> 1036607310bSBenjamin Close #include <net80211/ieee80211_regdomain.h> 104b6108616SRui Paulo #include <net80211/ieee80211_ratectl.h> 1056607310bSBenjamin Close 1066607310bSBenjamin Close #include <dev/wpi/if_wpireg.h> 1076607310bSBenjamin Close #include <dev/wpi/if_wpivar.h> 108692ad7caSAdrian Chadd #include <dev/wpi/if_wpi_debug.h> 1096607310bSBenjamin Close 1106607310bSBenjamin Close struct wpi_ident { 1116607310bSBenjamin Close uint16_t vendor; 1126607310bSBenjamin Close uint16_t device; 1136607310bSBenjamin Close uint16_t subdevice; 1146607310bSBenjamin Close const char *name; 1156607310bSBenjamin Close }; 1166607310bSBenjamin Close 1176607310bSBenjamin Close static const struct wpi_ident wpi_ident_table[] = { 1186607310bSBenjamin Close /* The below entries support ABG regardless of the subid */ 1196607310bSBenjamin Close { 0x8086, 0x4222, 0x0, "Intel(R) PRO/Wireless 3945ABG" }, 1206607310bSBenjamin Close { 0x8086, 0x4227, 0x0, "Intel(R) PRO/Wireless 3945ABG" }, 1216607310bSBenjamin Close /* The below entries only support BG */ 12234f004ceSBenjamin Close { 0x8086, 0x4222, 0x1005, "Intel(R) PRO/Wireless 3945BG" }, 12334f004ceSBenjamin Close { 0x8086, 0x4222, 0x1034, "Intel(R) PRO/Wireless 3945BG" }, 12434f004ceSBenjamin Close { 0x8086, 0x4227, 0x1014, "Intel(R) PRO/Wireless 3945BG" }, 12534f004ceSBenjamin Close { 0x8086, 0x4222, 0x1044, "Intel(R) PRO/Wireless 3945BG" }, 1266607310bSBenjamin Close { 0, 0, 0, NULL } 1276607310bSBenjamin Close }; 1286607310bSBenjamin Close 129692ad7caSAdrian Chadd static int wpi_probe(device_t); 130692ad7caSAdrian Chadd static int wpi_attach(device_t); 131692ad7caSAdrian Chadd static void wpi_radiotap_attach(struct wpi_softc *); 132692ad7caSAdrian Chadd static void wpi_sysctlattach(struct wpi_softc *); 13321f6580eSAdrian Chadd static void wpi_init_beacon(struct wpi_vap *); 134b032f27cSSam Leffler static struct ieee80211vap *wpi_vap_create(struct ieee80211com *, 135fcd9500fSBernhard Schmidt const char [IFNAMSIZ], int, enum ieee80211_opmode, int, 136fcd9500fSBernhard Schmidt const uint8_t [IEEE80211_ADDR_LEN], 137fcd9500fSBernhard Schmidt const uint8_t [IEEE80211_ADDR_LEN]); 138b032f27cSSam Leffler static void wpi_vap_delete(struct ieee80211vap *); 139692ad7caSAdrian Chadd static int wpi_detach(device_t); 140692ad7caSAdrian Chadd static int wpi_shutdown(device_t); 141692ad7caSAdrian Chadd static int wpi_suspend(device_t); 142692ad7caSAdrian Chadd static int wpi_resume(device_t); 143692ad7caSAdrian Chadd static int wpi_nic_lock(struct wpi_softc *); 144692ad7caSAdrian Chadd static int wpi_read_prom_data(struct wpi_softc *, uint32_t, void *, int); 1456607310bSBenjamin Close static void wpi_dma_map_addr(void *, bus_dma_segment_t *, int, int); 146692ad7caSAdrian Chadd static int wpi_dma_contig_alloc(struct wpi_softc *, struct wpi_dma_info *, 147692ad7caSAdrian Chadd void **, bus_size_t, bus_size_t); 148692ad7caSAdrian Chadd static void wpi_dma_contig_free(struct wpi_dma_info *); 1496607310bSBenjamin Close static int wpi_alloc_shared(struct wpi_softc *); 1506607310bSBenjamin Close static void wpi_free_shared(struct wpi_softc *); 1516607310bSBenjamin Close static int wpi_alloc_fwmem(struct wpi_softc *); 1526607310bSBenjamin Close static void wpi_free_fwmem(struct wpi_softc *); 153692ad7caSAdrian Chadd static int wpi_alloc_rx_ring(struct wpi_softc *); 154692ad7caSAdrian Chadd static void wpi_update_rx_ring(struct wpi_softc *); 155692ad7caSAdrian Chadd static void wpi_reset_rx_ring(struct wpi_softc *); 156692ad7caSAdrian Chadd static void wpi_free_rx_ring(struct wpi_softc *); 157692ad7caSAdrian Chadd static int wpi_alloc_tx_ring(struct wpi_softc *, struct wpi_tx_ring *, 158692ad7caSAdrian Chadd int); 159692ad7caSAdrian Chadd static void wpi_update_tx_ring(struct wpi_softc *, struct wpi_tx_ring *); 160692ad7caSAdrian Chadd static void wpi_reset_tx_ring(struct wpi_softc *, struct wpi_tx_ring *); 161692ad7caSAdrian Chadd static void wpi_free_tx_ring(struct wpi_softc *, struct wpi_tx_ring *); 162692ad7caSAdrian Chadd static int wpi_read_eeprom(struct wpi_softc *, 163692ad7caSAdrian Chadd uint8_t macaddr[IEEE80211_ADDR_LEN]); 164692ad7caSAdrian Chadd static uint32_t wpi_eeprom_channel_flags(struct wpi_eeprom_chan *); 165692ad7caSAdrian Chadd static void wpi_read_eeprom_band(struct wpi_softc *, int); 166692ad7caSAdrian Chadd static int wpi_read_eeprom_channels(struct wpi_softc *, int); 167692ad7caSAdrian Chadd static struct wpi_eeprom_chan *wpi_find_eeprom_channel(struct wpi_softc *, 168692ad7caSAdrian Chadd struct ieee80211_channel *); 169692ad7caSAdrian Chadd static int wpi_setregdomain(struct ieee80211com *, 170692ad7caSAdrian Chadd struct ieee80211_regdomain *, int, 171692ad7caSAdrian Chadd struct ieee80211_channel[]); 172692ad7caSAdrian Chadd static int wpi_read_eeprom_group(struct wpi_softc *, int); 173eca2eb39SAdrian Chadd static int wpi_add_node_entry_adhoc(struct wpi_softc *); 174692ad7caSAdrian Chadd static void wpi_node_free(struct ieee80211_node *); 175692ad7caSAdrian Chadd static struct ieee80211_node *wpi_node_alloc(struct ieee80211vap *, 176692ad7caSAdrian Chadd const uint8_t mac[IEEE80211_ADDR_LEN]); 177692ad7caSAdrian Chadd static int wpi_newstate(struct ieee80211vap *, enum ieee80211_state, int); 178692ad7caSAdrian Chadd static void wpi_calib_timeout(void *); 179692ad7caSAdrian Chadd static void wpi_rx_done(struct wpi_softc *, struct wpi_rx_desc *, 1806607310bSBenjamin Close struct wpi_rx_data *); 181692ad7caSAdrian Chadd static void wpi_rx_statistics(struct wpi_softc *, struct wpi_rx_desc *, 182692ad7caSAdrian Chadd struct wpi_rx_data *); 183692ad7caSAdrian Chadd static void wpi_tx_done(struct wpi_softc *, struct wpi_rx_desc *); 184692ad7caSAdrian Chadd static void wpi_cmd_done(struct wpi_softc *, struct wpi_rx_desc *); 1856607310bSBenjamin Close static void wpi_notif_intr(struct wpi_softc *); 186692ad7caSAdrian Chadd static void wpi_wakeup_intr(struct wpi_softc *); 187a6df6cfeSAdrian Chadd #ifdef WPI_DEBUG 188a6df6cfeSAdrian Chadd static void wpi_debug_registers(struct wpi_softc *); 189a6df6cfeSAdrian Chadd #endif 190692ad7caSAdrian Chadd static void wpi_fatal_intr(struct wpi_softc *); 1916607310bSBenjamin Close static void wpi_intr(void *); 192692ad7caSAdrian Chadd static int wpi_cmd2(struct wpi_softc *, struct wpi_buf *); 1936607310bSBenjamin Close static int wpi_tx_data(struct wpi_softc *, struct mbuf *, 194692ad7caSAdrian Chadd struct ieee80211_node *); 195692ad7caSAdrian Chadd static int wpi_tx_data_raw(struct wpi_softc *, struct mbuf *, 196692ad7caSAdrian Chadd struct ieee80211_node *, 197692ad7caSAdrian Chadd const struct ieee80211_bpf_params *); 198b032f27cSSam Leffler static int wpi_raw_xmit(struct ieee80211_node *, struct mbuf *, 199b032f27cSSam Leffler const struct ieee80211_bpf_params *); 200692ad7caSAdrian Chadd static void wpi_start(struct ifnet *); 2014eaf2ee3SAdrian Chadd static void wpi_start_task(void *, int); 202692ad7caSAdrian Chadd static void wpi_watchdog_rfkill(void *); 2030bc39fc6SAdrian Chadd static void wpi_scan_timeout(void *); 204d74e544aSAdrian Chadd static void wpi_tx_timeout(void *); 205692ad7caSAdrian Chadd static int wpi_ioctl(struct ifnet *, u_long, caddr_t); 206692ad7caSAdrian Chadd static int wpi_cmd(struct wpi_softc *, int, const void *, size_t, int); 207692ad7caSAdrian Chadd static int wpi_mrr_setup(struct wpi_softc *); 208692ad7caSAdrian Chadd static int wpi_add_node(struct wpi_softc *, struct ieee80211_node *); 209692ad7caSAdrian Chadd static int wpi_add_broadcast_node(struct wpi_softc *, int); 210692ad7caSAdrian Chadd static int wpi_add_ibss_node(struct wpi_softc *, struct ieee80211_node *); 211692ad7caSAdrian Chadd static void wpi_del_node(struct wpi_softc *, struct ieee80211_node *); 212692ad7caSAdrian Chadd static int wpi_updateedca(struct ieee80211com *); 213692ad7caSAdrian Chadd static void wpi_set_promisc(struct wpi_softc *); 214692ad7caSAdrian Chadd static void wpi_update_promisc(struct ifnet *); 215692ad7caSAdrian Chadd static void wpi_update_mcast(struct ifnet *); 216692ad7caSAdrian Chadd static void wpi_set_led(struct wpi_softc *, uint8_t, uint8_t, uint8_t); 217692ad7caSAdrian Chadd static int wpi_set_timing(struct wpi_softc *, struct ieee80211_node *); 218692ad7caSAdrian Chadd static void wpi_power_calibration(struct wpi_softc *); 219692ad7caSAdrian Chadd static int wpi_set_txpower(struct wpi_softc *, int); 220692ad7caSAdrian Chadd static int wpi_get_power_index(struct wpi_softc *, 221655e8ba8SAdrian Chadd struct wpi_power_group *, uint8_t, int, int); 222692ad7caSAdrian Chadd static int wpi_set_pslevel(struct wpi_softc *, uint8_t, int, int); 223692ad7caSAdrian Chadd static int wpi_send_btcoex(struct wpi_softc *); 224692ad7caSAdrian Chadd static int wpi_send_rxon(struct wpi_softc *, int, int); 225692ad7caSAdrian Chadd static int wpi_config(struct wpi_softc *); 226692ad7caSAdrian Chadd static uint16_t wpi_get_active_dwell_time(struct wpi_softc *, 227692ad7caSAdrian Chadd struct ieee80211_channel *, uint8_t); 228692ad7caSAdrian Chadd static uint16_t wpi_limit_dwell(struct wpi_softc *, uint16_t); 229692ad7caSAdrian Chadd static uint16_t wpi_get_passive_dwell_time(struct wpi_softc *, 230692ad7caSAdrian Chadd struct ieee80211_channel *); 231efccc3c6SAdrian Chadd static uint32_t wpi_get_scan_pause_time(uint32_t, uint16_t); 232692ad7caSAdrian Chadd static int wpi_scan(struct wpi_softc *, struct ieee80211_channel *); 233692ad7caSAdrian Chadd static int wpi_auth(struct wpi_softc *, struct ieee80211vap *); 2346f8421f8SAdrian Chadd static int wpi_config_beacon(struct wpi_vap *); 235692ad7caSAdrian Chadd static int wpi_setup_beacon(struct wpi_softc *, struct ieee80211_node *); 2366f8421f8SAdrian Chadd static void wpi_update_beacon(struct ieee80211vap *, int); 237d138d3baSAdrian Chadd static void wpi_newassoc(struct ieee80211_node *, int); 238692ad7caSAdrian Chadd static int wpi_run(struct wpi_softc *, struct ieee80211vap *); 239d29fcfb7SAdrian Chadd static int wpi_load_key(struct ieee80211_node *, 240d29fcfb7SAdrian Chadd const struct ieee80211_key *); 241d29fcfb7SAdrian Chadd static void wpi_load_key_cb(void *, struct ieee80211_node *); 242d29fcfb7SAdrian Chadd static int wpi_set_global_keys(struct ieee80211_node *); 243d29fcfb7SAdrian Chadd static int wpi_del_key(struct ieee80211_node *, 244d29fcfb7SAdrian Chadd const struct ieee80211_key *); 245d29fcfb7SAdrian Chadd static void wpi_del_key_cb(void *, struct ieee80211_node *); 246d29fcfb7SAdrian Chadd static int wpi_process_key(struct ieee80211vap *, 247d29fcfb7SAdrian Chadd const struct ieee80211_key *, int); 248692ad7caSAdrian Chadd static int wpi_key_set(struct ieee80211vap *, 249692ad7caSAdrian Chadd const struct ieee80211_key *, 250692ad7caSAdrian Chadd const uint8_t mac[IEEE80211_ADDR_LEN]); 251692ad7caSAdrian Chadd static int wpi_key_delete(struct ieee80211vap *, 252692ad7caSAdrian Chadd const struct ieee80211_key *); 253692ad7caSAdrian Chadd static int wpi_post_alive(struct wpi_softc *); 254692ad7caSAdrian Chadd static int wpi_load_bootcode(struct wpi_softc *, const uint8_t *, int); 255692ad7caSAdrian Chadd static int wpi_load_firmware(struct wpi_softc *); 256692ad7caSAdrian Chadd static int wpi_read_firmware(struct wpi_softc *); 257692ad7caSAdrian Chadd static void wpi_unload_firmware(struct wpi_softc *); 258692ad7caSAdrian Chadd static int wpi_clock_wait(struct wpi_softc *); 259692ad7caSAdrian Chadd static int wpi_apm_init(struct wpi_softc *); 260692ad7caSAdrian Chadd static void wpi_apm_stop_master(struct wpi_softc *); 261692ad7caSAdrian Chadd static void wpi_apm_stop(struct wpi_softc *); 262692ad7caSAdrian Chadd static void wpi_nic_config(struct wpi_softc *); 263692ad7caSAdrian Chadd static int wpi_hw_init(struct wpi_softc *); 264692ad7caSAdrian Chadd static void wpi_hw_stop(struct wpi_softc *); 265692ad7caSAdrian Chadd static void wpi_radio_on(void *, int); 266692ad7caSAdrian Chadd static void wpi_radio_off(void *, int); 267692ad7caSAdrian Chadd static void wpi_init(void *); 268692ad7caSAdrian Chadd static void wpi_stop_locked(struct wpi_softc *); 269692ad7caSAdrian Chadd static void wpi_stop(struct wpi_softc *); 2706607310bSBenjamin Close static void wpi_scan_start(struct ieee80211com *); 2716607310bSBenjamin Close static void wpi_scan_end(struct ieee80211com *); 2726607310bSBenjamin Close static void wpi_set_channel(struct ieee80211com *); 273b032f27cSSam Leffler static void wpi_scan_curchan(struct ieee80211_scan_state *, unsigned long); 274b032f27cSSam Leffler static void wpi_scan_mindwell(struct ieee80211_scan_state *); 275692ad7caSAdrian Chadd static void wpi_hw_reset(void *, int); 2766607310bSBenjamin Close 2776607310bSBenjamin Close static device_method_t wpi_methods[] = { 2786607310bSBenjamin Close /* Device interface */ 2796607310bSBenjamin Close DEVMETHOD(device_probe, wpi_probe), 2806607310bSBenjamin Close DEVMETHOD(device_attach, wpi_attach), 2816607310bSBenjamin Close DEVMETHOD(device_detach, wpi_detach), 2826607310bSBenjamin Close DEVMETHOD(device_shutdown, wpi_shutdown), 2836607310bSBenjamin Close DEVMETHOD(device_suspend, wpi_suspend), 2846607310bSBenjamin Close DEVMETHOD(device_resume, wpi_resume), 2856607310bSBenjamin Close 286da67681dSMarius Strobl DEVMETHOD_END 2876607310bSBenjamin Close }; 2886607310bSBenjamin Close 2896607310bSBenjamin Close static driver_t wpi_driver = { 2906607310bSBenjamin Close "wpi", 2916607310bSBenjamin Close wpi_methods, 2926607310bSBenjamin Close sizeof (struct wpi_softc) 2936607310bSBenjamin Close }; 2946607310bSBenjamin Close static devclass_t wpi_devclass; 2956607310bSBenjamin Close 296da67681dSMarius Strobl DRIVER_MODULE(wpi, pci, wpi_driver, wpi_devclass, NULL, NULL); 2976607310bSBenjamin Close 298129145a4SBernhard Schmidt MODULE_VERSION(wpi, 1); 299129145a4SBernhard Schmidt 300692ad7caSAdrian Chadd MODULE_DEPEND(wpi, pci, 1, 1, 1); 301692ad7caSAdrian Chadd MODULE_DEPEND(wpi, wlan, 1, 1, 1); 302692ad7caSAdrian Chadd MODULE_DEPEND(wpi, firmware, 1, 1, 1); 3036607310bSBenjamin Close 3046607310bSBenjamin Close static int 3056607310bSBenjamin Close wpi_probe(device_t dev) 3066607310bSBenjamin Close { 3076607310bSBenjamin Close const struct wpi_ident *ident; 3086607310bSBenjamin Close 3096607310bSBenjamin Close for (ident = wpi_ident_table; ident->name != NULL; ident++) { 3106607310bSBenjamin Close if (pci_get_vendor(dev) == ident->vendor && 3116607310bSBenjamin Close pci_get_device(dev) == ident->device) { 3126607310bSBenjamin Close device_set_desc(dev, ident->name); 313da67681dSMarius Strobl return (BUS_PROBE_DEFAULT); 3146607310bSBenjamin Close } 3156607310bSBenjamin Close } 3166607310bSBenjamin Close return ENXIO; 3176607310bSBenjamin Close } 3186607310bSBenjamin Close 3196607310bSBenjamin Close static int 3206607310bSBenjamin Close wpi_attach(device_t dev) 3216607310bSBenjamin Close { 322692ad7caSAdrian Chadd struct wpi_softc *sc = (struct wpi_softc *)device_get_softc(dev); 323b032f27cSSam Leffler struct ieee80211com *ic; 324692ad7caSAdrian Chadd struct ifnet *ifp; 325cb0de40fSAdrian Chadd int i, error, rid; 326cb0de40fSAdrian Chadd #ifdef WPI_DEBUG 327cb0de40fSAdrian Chadd int supportsa = 1; 3286607310bSBenjamin Close const struct wpi_ident *ident; 329cb0de40fSAdrian Chadd #endif 33029aca940SSam Leffler uint8_t macaddr[IEEE80211_ADDR_LEN]; 3316607310bSBenjamin Close 3326607310bSBenjamin Close sc->sc_dev = dev; 3336607310bSBenjamin Close 334692ad7caSAdrian Chadd #ifdef WPI_DEBUG 335692ad7caSAdrian Chadd error = resource_int_value(device_get_name(sc->sc_dev), 336692ad7caSAdrian Chadd device_get_unit(sc->sc_dev), "debug", &(sc->sc_debug)); 337692ad7caSAdrian Chadd if (error != 0) 338692ad7caSAdrian Chadd sc->sc_debug = 0; 339692ad7caSAdrian Chadd #else 340692ad7caSAdrian Chadd sc->sc_debug = 0; 341692ad7caSAdrian Chadd #endif 342692ad7caSAdrian Chadd 343692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 344692ad7caSAdrian Chadd 345692ad7caSAdrian Chadd /* 346692ad7caSAdrian Chadd * Get the offset of the PCI Express Capability Structure in PCI 347692ad7caSAdrian Chadd * Configuration Space. 348692ad7caSAdrian Chadd */ 349692ad7caSAdrian Chadd error = pci_find_cap(dev, PCIY_EXPRESS, &sc->sc_cap_off); 350692ad7caSAdrian Chadd if (error != 0) { 351692ad7caSAdrian Chadd device_printf(dev, "PCIe capability structure not found!\n"); 352692ad7caSAdrian Chadd return error; 353692ad7caSAdrian Chadd } 3546607310bSBenjamin Close 3556607310bSBenjamin Close /* 3566607310bSBenjamin Close * Some card's only support 802.11b/g not a, check to see if 3576607310bSBenjamin Close * this is one such card. A 0x0 in the subdevice table indicates 3586607310bSBenjamin Close * the entire subdevice range is to be ignored. 3596607310bSBenjamin Close */ 360cb0de40fSAdrian Chadd #ifdef WPI_DEBUG 3616607310bSBenjamin Close for (ident = wpi_ident_table; ident->name != NULL; ident++) { 3626607310bSBenjamin Close if (ident->subdevice && 3636607310bSBenjamin Close pci_get_subdevice(dev) == ident->subdevice) { 3646607310bSBenjamin Close supportsa = 0; 3656607310bSBenjamin Close break; 3666607310bSBenjamin Close } 3676607310bSBenjamin Close } 368cb0de40fSAdrian Chadd #endif 3696607310bSBenjamin Close 370692ad7caSAdrian Chadd /* Clear device-specific "PCI retry timeout" register (41h). */ 3716607310bSBenjamin Close pci_write_config(dev, 0x41, 0, 1); 3726607310bSBenjamin Close 373692ad7caSAdrian Chadd /* Enable bus-mastering. */ 3746607310bSBenjamin Close pci_enable_busmaster(dev); 3756607310bSBenjamin Close 376da67681dSMarius Strobl rid = PCIR_BAR(0); 377da67681dSMarius Strobl sc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 3786607310bSBenjamin Close RF_ACTIVE); 3796607310bSBenjamin Close if (sc->mem == NULL) { 380692ad7caSAdrian Chadd device_printf(dev, "can't map mem space\n"); 381419435b8SAdrian Chadd return ENOMEM; 3826607310bSBenjamin Close } 3836607310bSBenjamin Close sc->sc_st = rman_get_bustag(sc->mem); 3846607310bSBenjamin Close sc->sc_sh = rman_get_bushandle(sc->mem); 3856607310bSBenjamin Close 386692ad7caSAdrian Chadd i = 1; 387da67681dSMarius Strobl rid = 0; 388692ad7caSAdrian Chadd if (pci_alloc_msi(dev, &i) == 0) 389692ad7caSAdrian Chadd rid = 1; 390692ad7caSAdrian Chadd /* Install interrupt handler. */ 391692ad7caSAdrian Chadd sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE | 392692ad7caSAdrian Chadd (rid != 0 ? 0 : RF_SHAREABLE)); 3936607310bSBenjamin Close if (sc->irq == NULL) { 394692ad7caSAdrian Chadd device_printf(dev, "can't map interrupt\n"); 3956607310bSBenjamin Close error = ENOMEM; 3966607310bSBenjamin Close goto fail; 3976607310bSBenjamin Close } 3986607310bSBenjamin Close 399692ad7caSAdrian Chadd WPI_LOCK_INIT(sc); 4005effcbfdSAdrian Chadd WPI_TX_LOCK_INIT(sc); 401446685e4SAdrian Chadd WPI_RXON_LOCK_INIT(sc); 4027964dd56SAdrian Chadd WPI_NT_LOCK_INIT(sc); 40363f57699SAdrian Chadd WPI_TXQ_LOCK_INIT(sc); 404fc5870b4SAdrian Chadd WPI_TXQ_STATE_LOCK_INIT(sc); 405692ad7caSAdrian Chadd 406692ad7caSAdrian Chadd /* Allocate DMA memory for firmware transfers. */ 4076607310bSBenjamin Close if ((error = wpi_alloc_fwmem(sc)) != 0) { 408692ad7caSAdrian Chadd device_printf(dev, 409692ad7caSAdrian Chadd "could not allocate memory for firmware, error %d\n", 410692ad7caSAdrian Chadd error); 4116607310bSBenjamin Close goto fail; 4126607310bSBenjamin Close } 4136607310bSBenjamin Close 414692ad7caSAdrian Chadd /* Allocate shared page. */ 4156607310bSBenjamin Close if ((error = wpi_alloc_shared(sc)) != 0) { 4166607310bSBenjamin Close device_printf(dev, "could not allocate shared page\n"); 4176607310bSBenjamin Close goto fail; 4186607310bSBenjamin Close } 4196607310bSBenjamin Close 420692ad7caSAdrian Chadd /* Allocate TX rings - 4 for QoS purposes, 1 for commands. */ 421692ad7caSAdrian Chadd for (i = 0; i < WPI_NTXQUEUES; i++) { 422692ad7caSAdrian Chadd if ((error = wpi_alloc_tx_ring(sc, &sc->txq[i], i)) != 0) { 423692ad7caSAdrian Chadd device_printf(dev, 424692ad7caSAdrian Chadd "could not allocate TX ring %d, error %d\n", i, 425692ad7caSAdrian Chadd error); 4266607310bSBenjamin Close goto fail; 4276607310bSBenjamin Close } 4286607310bSBenjamin Close } 4296607310bSBenjamin Close 430692ad7caSAdrian Chadd /* Allocate RX ring. */ 431692ad7caSAdrian Chadd if ((error = wpi_alloc_rx_ring(sc)) != 0) { 432692ad7caSAdrian Chadd device_printf(dev, "could not allocate RX ring, error %d\n", 433692ad7caSAdrian Chadd error); 4346607310bSBenjamin Close goto fail; 4356607310bSBenjamin Close } 4366607310bSBenjamin Close 437692ad7caSAdrian Chadd /* Clear pending interrupts. */ 438692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, 0xffffffff); 4396607310bSBenjamin Close 440b032f27cSSam Leffler ifp = sc->sc_ifp = if_alloc(IFT_IEEE80211); 4416607310bSBenjamin Close if (ifp == NULL) { 442692ad7caSAdrian Chadd device_printf(dev, "can not allocate ifnet structure\n"); 4436607310bSBenjamin Close goto fail; 4446607310bSBenjamin Close } 4456607310bSBenjamin Close 446692ad7caSAdrian Chadd ic = ifp->if_l2com; 4476607310bSBenjamin Close ic->ic_ifp = ifp; 4486607310bSBenjamin Close ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */ 4496607310bSBenjamin Close ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */ 4506607310bSBenjamin Close 451692ad7caSAdrian Chadd /* Set device capabilities. */ 4526607310bSBenjamin Close ic->ic_caps = 453c43feedeSSam Leffler IEEE80211_C_STA /* station mode supported */ 454692ad7caSAdrian Chadd | IEEE80211_C_IBSS /* IBSS mode supported */ 455726ddc26SAdrian Chadd | IEEE80211_C_HOSTAP /* Host access point mode */ 456c43feedeSSam Leffler | IEEE80211_C_MONITOR /* monitor mode supported */ 457692ad7caSAdrian Chadd | IEEE80211_C_AHDEMO /* adhoc demo mode */ 458692ad7caSAdrian Chadd | IEEE80211_C_BGSCAN /* capable of bg scanning */ 4596607310bSBenjamin Close | IEEE80211_C_TXPMGT /* tx power management */ 4606607310bSBenjamin Close | IEEE80211_C_SHSLOT /* short slot time supported */ 4616607310bSBenjamin Close | IEEE80211_C_WPA /* 802.11i */ 462692ad7caSAdrian Chadd | IEEE80211_C_SHPREAMBLE /* short preamble supported */ 463692ad7caSAdrian Chadd | IEEE80211_C_WME /* 802.11e */ 464692ad7caSAdrian Chadd | IEEE80211_C_PMGT /* Station-side power mgmt */ 4656607310bSBenjamin Close ; 4666607310bSBenjamin Close 467692ad7caSAdrian Chadd ic->ic_cryptocaps = 468692ad7caSAdrian Chadd IEEE80211_CRYPTO_AES_CCM; 469692ad7caSAdrian Chadd 4706607310bSBenjamin Close /* 4716607310bSBenjamin Close * Read in the eeprom and also setup the channels for 4726607310bSBenjamin Close * net80211. We don't set the rates as net80211 does this for us 4736607310bSBenjamin Close */ 474692ad7caSAdrian Chadd if ((error = wpi_read_eeprom(sc, macaddr)) != 0) { 475692ad7caSAdrian Chadd device_printf(dev, "could not read EEPROM, error %d\n", 476692ad7caSAdrian Chadd error); 477692ad7caSAdrian Chadd goto fail; 478692ad7caSAdrian Chadd } 4796607310bSBenjamin Close 480692ad7caSAdrian Chadd #ifdef WPI_DEBUG 481692ad7caSAdrian Chadd if (bootverbose) { 482bb086d4eSAdrian Chadd device_printf(sc->sc_dev, "Regulatory Domain: %.4s\n", 483bb086d4eSAdrian Chadd sc->domain); 4846607310bSBenjamin Close device_printf(sc->sc_dev, "Hardware Type: %c\n", 4856607310bSBenjamin Close sc->type > 1 ? 'B': '?'); 4866607310bSBenjamin Close device_printf(sc->sc_dev, "Hardware Revision: %c\n", 487f736d898SAdrian Chadd ((sc->rev & 0xf0) == 0xd0) ? 'D': '?'); 4886607310bSBenjamin Close device_printf(sc->sc_dev, "SKU %s support 802.11a\n", 4896607310bSBenjamin Close supportsa ? "does" : "does not"); 4906607310bSBenjamin Close 491bb086d4eSAdrian Chadd /* XXX hw_config uses the PCIDEV for the Hardware rev. Must 492bb086d4eSAdrian Chadd check what sc->rev really represents - benjsc 20070615 */ 4936607310bSBenjamin Close } 494692ad7caSAdrian Chadd #endif 4956607310bSBenjamin Close 4966607310bSBenjamin Close if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 4976607310bSBenjamin Close ifp->if_softc = sc; 4986607310bSBenjamin Close ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 4996607310bSBenjamin Close ifp->if_init = wpi_init; 5006607310bSBenjamin Close ifp->if_ioctl = wpi_ioctl; 5016607310bSBenjamin Close ifp->if_start = wpi_start; 502e50d35e6SMaxim Sobolev IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen); 503e50d35e6SMaxim Sobolev ifp->if_snd.ifq_drv_maxlen = ifqmaxlen; 5046607310bSBenjamin Close IFQ_SET_READY(&ifp->if_snd); 5056607310bSBenjamin Close 50629aca940SSam Leffler ieee80211_ifattach(ic, macaddr); 507692ad7caSAdrian Chadd ic->ic_vap_create = wpi_vap_create; 508692ad7caSAdrian Chadd ic->ic_vap_delete = wpi_vap_delete; 509b032f27cSSam Leffler ic->ic_raw_xmit = wpi_raw_xmit; 510692ad7caSAdrian Chadd ic->ic_node_alloc = wpi_node_alloc; 511692ad7caSAdrian Chadd sc->sc_node_free = ic->ic_node_free; 512692ad7caSAdrian Chadd ic->ic_node_free = wpi_node_free; 513692ad7caSAdrian Chadd ic->ic_wme.wme_update = wpi_updateedca; 514692ad7caSAdrian Chadd ic->ic_update_promisc = wpi_update_promisc; 515692ad7caSAdrian Chadd ic->ic_update_mcast = wpi_update_mcast; 516d138d3baSAdrian Chadd ic->ic_newassoc = wpi_newassoc; 5176607310bSBenjamin Close ic->ic_scan_start = wpi_scan_start; 5186607310bSBenjamin Close ic->ic_scan_end = wpi_scan_end; 5196607310bSBenjamin Close ic->ic_set_channel = wpi_set_channel; 5206607310bSBenjamin Close ic->ic_scan_curchan = wpi_scan_curchan; 5216607310bSBenjamin Close ic->ic_scan_mindwell = wpi_scan_mindwell; 522692ad7caSAdrian Chadd ic->ic_setregdomain = wpi_setregdomain; 5236607310bSBenjamin Close 524692ad7caSAdrian Chadd wpi_radiotap_attach(sc); 5256607310bSBenjamin Close 526446685e4SAdrian Chadd callout_init_mtx(&sc->calib_to, &sc->rxon_mtx, 0); 527446685e4SAdrian Chadd callout_init_mtx(&sc->scan_timeout, &sc->rxon_mtx, 0); 528fc5870b4SAdrian Chadd callout_init_mtx(&sc->tx_timeout, &sc->txq_state_mtx, 0); 529692ad7caSAdrian Chadd callout_init_mtx(&sc->watchdog_rfkill, &sc->sc_mtx, 0); 530692ad7caSAdrian Chadd TASK_INIT(&sc->sc_reinittask, 0, wpi_hw_reset, sc); 531692ad7caSAdrian Chadd TASK_INIT(&sc->sc_radiooff_task, 0, wpi_radio_off, sc); 532692ad7caSAdrian Chadd TASK_INIT(&sc->sc_radioon_task, 0, wpi_radio_on, sc); 5334eaf2ee3SAdrian Chadd TASK_INIT(&sc->sc_start_task, 0, wpi_start_task, sc); 534692ad7caSAdrian Chadd 535e2ad4371SAdrian Chadd sc->sc_tq = taskqueue_create("wpi_taskq", M_WAITOK, 536e2ad4371SAdrian Chadd taskqueue_thread_enqueue, &sc->sc_tq); 537e2ad4371SAdrian Chadd error = taskqueue_start_threads(&sc->sc_tq, 1, 0, "wpi_taskq"); 538e2ad4371SAdrian Chadd if (error != 0) { 539e2ad4371SAdrian Chadd device_printf(dev, "can't start threads, error %d\n", error); 540e2ad4371SAdrian Chadd goto fail; 541e2ad4371SAdrian Chadd } 542e2ad4371SAdrian Chadd 543692ad7caSAdrian Chadd wpi_sysctlattach(sc); 5446607310bSBenjamin Close 5456607310bSBenjamin Close /* 5466607310bSBenjamin Close * Hook our interrupt after all initialization is complete. 5476607310bSBenjamin Close */ 5486607310bSBenjamin Close error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET | INTR_MPSAFE, 54982f1b132SAndrew Thompson NULL, wpi_intr, sc, &sc->sc_ih); 5506607310bSBenjamin Close if (error != 0) { 551692ad7caSAdrian Chadd device_printf(dev, "can't establish interrupt, error %d\n", 552692ad7caSAdrian Chadd error); 5536607310bSBenjamin Close goto fail; 5546607310bSBenjamin Close } 5556607310bSBenjamin Close 55682f1b132SAndrew Thompson if (bootverbose) 5576607310bSBenjamin Close ieee80211_announce(ic); 558692ad7caSAdrian Chadd 559692ad7caSAdrian Chadd #ifdef WPI_DEBUG 560692ad7caSAdrian Chadd if (sc->sc_debug & WPI_DEBUG_HW) 5616607310bSBenjamin Close ieee80211_announce_channels(ic); 5626607310bSBenjamin Close #endif 563692ad7caSAdrian Chadd 564692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 5656607310bSBenjamin Close return 0; 5666607310bSBenjamin Close 5676607310bSBenjamin Close fail: wpi_detach(dev); 568692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 569692ad7caSAdrian Chadd return error; 5706607310bSBenjamin Close } 5716607310bSBenjamin Close 572692ad7caSAdrian Chadd /* 573692ad7caSAdrian Chadd * Attach the interface to 802.11 radiotap. 574692ad7caSAdrian Chadd */ 575692ad7caSAdrian Chadd static void 576692ad7caSAdrian Chadd wpi_radiotap_attach(struct wpi_softc *sc) 5776607310bSBenjamin Close { 578b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 579692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 580692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 581692ad7caSAdrian Chadd ieee80211_radiotap_attach(ic, 582692ad7caSAdrian Chadd &sc->sc_txtap.wt_ihdr, sizeof(sc->sc_txtap), 583692ad7caSAdrian Chadd WPI_TX_RADIOTAP_PRESENT, 584692ad7caSAdrian Chadd &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap), 585692ad7caSAdrian Chadd WPI_RX_RADIOTAP_PRESENT); 586692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 5876607310bSBenjamin Close } 5886607310bSBenjamin Close 589692ad7caSAdrian Chadd static void 590692ad7caSAdrian Chadd wpi_sysctlattach(struct wpi_softc *sc) 591692ad7caSAdrian Chadd { 592692ad7caSAdrian Chadd #ifdef WPI_DEBUG 593692ad7caSAdrian Chadd struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev); 594692ad7caSAdrian Chadd struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev); 5956607310bSBenjamin Close 596692ad7caSAdrian Chadd SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 597692ad7caSAdrian Chadd "debug", CTLFLAG_RW, &sc->sc_debug, sc->sc_debug, 598692ad7caSAdrian Chadd "control debugging printfs"); 599692ad7caSAdrian Chadd #endif 6006607310bSBenjamin Close } 6016607310bSBenjamin Close 60221f6580eSAdrian Chadd static void 60321f6580eSAdrian Chadd wpi_init_beacon(struct wpi_vap *wvp) 60421f6580eSAdrian Chadd { 60521f6580eSAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 60621f6580eSAdrian Chadd struct wpi_cmd_beacon *cmd = (struct wpi_cmd_beacon *)&bcn->data; 60721f6580eSAdrian Chadd 60821f6580eSAdrian Chadd cmd->id = WPI_ID_BROADCAST; 60921f6580eSAdrian Chadd cmd->ofdm_mask = 0xff; 61021f6580eSAdrian Chadd cmd->cck_mask = 0x0f; 61121f6580eSAdrian Chadd cmd->lifetime = htole32(WPI_LIFETIME_INFINITE); 612c39df5f4SAdrian Chadd 613c39df5f4SAdrian Chadd /* 614c39df5f4SAdrian Chadd * XXX WPI_TX_AUTO_SEQ seems to be ignored - workaround this issue 615c39df5f4SAdrian Chadd * XXX by using WPI_TX_NEED_ACK instead (with some side effects). 616c39df5f4SAdrian Chadd */ 617c39df5f4SAdrian Chadd cmd->flags = htole32(WPI_TX_NEED_ACK | WPI_TX_INSERT_TSTAMP); 61821f6580eSAdrian Chadd 61921f6580eSAdrian Chadd bcn->code = WPI_CMD_SET_BEACON; 62021f6580eSAdrian Chadd bcn->ac = WPI_CMD_QUEUE_NUM; 62121f6580eSAdrian Chadd bcn->size = sizeof(struct wpi_cmd_beacon); 62221f6580eSAdrian Chadd } 62321f6580eSAdrian Chadd 624b032f27cSSam Leffler static struct ieee80211vap * 625fcd9500fSBernhard Schmidt wpi_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit, 626fcd9500fSBernhard Schmidt enum ieee80211_opmode opmode, int flags, 627b032f27cSSam Leffler const uint8_t bssid[IEEE80211_ADDR_LEN], 628b032f27cSSam Leffler const uint8_t mac[IEEE80211_ADDR_LEN]) 629b032f27cSSam Leffler { 630b032f27cSSam Leffler struct wpi_vap *wvp; 631b032f27cSSam Leffler struct ieee80211vap *vap; 632b032f27cSSam Leffler 633b032f27cSSam Leffler if (!TAILQ_EMPTY(&ic->ic_vaps)) /* only one at a time */ 634b032f27cSSam Leffler return NULL; 635692ad7caSAdrian Chadd 636b032f27cSSam Leffler wvp = (struct wpi_vap *) malloc(sizeof(struct wpi_vap), 637b032f27cSSam Leffler M_80211_VAP, M_NOWAIT | M_ZERO); 638b032f27cSSam Leffler if (wvp == NULL) 639b032f27cSSam Leffler return NULL; 640d036bb20SAdrian Chadd vap = &wvp->wv_vap; 641b032f27cSSam Leffler ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid, mac); 642692ad7caSAdrian Chadd 643726ddc26SAdrian Chadd if (opmode == IEEE80211_M_IBSS || opmode == IEEE80211_M_HOSTAP) { 644b56fed3dSAdrian Chadd WPI_VAP_LOCK_INIT(wvp); 64521f6580eSAdrian Chadd wpi_init_beacon(wvp); 646b56fed3dSAdrian Chadd } 64721f6580eSAdrian Chadd 648692ad7caSAdrian Chadd /* Override with driver methods. */ 649692ad7caSAdrian Chadd vap->iv_key_set = wpi_key_set; 650692ad7caSAdrian Chadd vap->iv_key_delete = wpi_key_delete; 651d036bb20SAdrian Chadd wvp->wv_newstate = vap->iv_newstate; 652b032f27cSSam Leffler vap->iv_newstate = wpi_newstate; 653692ad7caSAdrian Chadd vap->iv_update_beacon = wpi_update_beacon; 654726ddc26SAdrian Chadd vap->iv_max_aid = WPI_ID_IBSS_MAX - WPI_ID_IBSS_MIN + 1; 655b032f27cSSam Leffler 656b6108616SRui Paulo ieee80211_ratectl_init(vap); 657692ad7caSAdrian Chadd /* Complete setup. */ 6587167f5fcSAdrian Chadd ieee80211_vap_attach(vap, ieee80211_media_change, 6597167f5fcSAdrian Chadd ieee80211_media_status); 660b032f27cSSam Leffler ic->ic_opmode = opmode; 661b032f27cSSam Leffler return vap; 662b032f27cSSam Leffler } 663b032f27cSSam Leffler 664b032f27cSSam Leffler static void 665b032f27cSSam Leffler wpi_vap_delete(struct ieee80211vap *vap) 666b032f27cSSam Leffler { 667b032f27cSSam Leffler struct wpi_vap *wvp = WPI_VAP(vap); 6686f8421f8SAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 6696f8421f8SAdrian Chadd enum ieee80211_opmode opmode = vap->iv_opmode; 670b032f27cSSam Leffler 671b6108616SRui Paulo ieee80211_ratectl_deinit(vap); 672b032f27cSSam Leffler ieee80211_vap_detach(vap); 673692ad7caSAdrian Chadd 674726ddc26SAdrian Chadd if (opmode == IEEE80211_M_IBSS || opmode == IEEE80211_M_HOSTAP) { 6756f8421f8SAdrian Chadd if (bcn->m != NULL) 6766f8421f8SAdrian Chadd m_freem(bcn->m); 677b56fed3dSAdrian Chadd 678b56fed3dSAdrian Chadd WPI_VAP_LOCK_DESTROY(wvp); 6796f8421f8SAdrian Chadd } 6806f8421f8SAdrian Chadd 681b032f27cSSam Leffler free(wvp, M_80211_VAP); 682b032f27cSSam Leffler } 683b032f27cSSam Leffler 6846607310bSBenjamin Close static int 685692ad7caSAdrian Chadd wpi_detach(device_t dev) 6866607310bSBenjamin Close { 687692ad7caSAdrian Chadd struct wpi_softc *sc = device_get_softc(dev); 688692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 689692ad7caSAdrian Chadd struct ieee80211com *ic; 690692ad7caSAdrian Chadd int qid; 6916607310bSBenjamin Close 692692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 6936607310bSBenjamin Close 694692ad7caSAdrian Chadd if (ifp != NULL) { 695692ad7caSAdrian Chadd ic = ifp->if_l2com; 6966607310bSBenjamin Close 6970c66281cSAdrian Chadd ieee80211_draintask(ic, &sc->sc_radioon_task); 6984eaf2ee3SAdrian Chadd ieee80211_draintask(ic, &sc->sc_start_task); 699692ad7caSAdrian Chadd 700692ad7caSAdrian Chadd wpi_stop(sc); 701692ad7caSAdrian Chadd 702e2ad4371SAdrian Chadd taskqueue_drain_all(sc->sc_tq); 703e2ad4371SAdrian Chadd taskqueue_free(sc->sc_tq); 704e2ad4371SAdrian Chadd 705692ad7caSAdrian Chadd callout_drain(&sc->watchdog_rfkill); 706d74e544aSAdrian Chadd callout_drain(&sc->tx_timeout); 7070bc39fc6SAdrian Chadd callout_drain(&sc->scan_timeout); 708692ad7caSAdrian Chadd callout_drain(&sc->calib_to); 709692ad7caSAdrian Chadd ieee80211_ifdetach(ic); 7106607310bSBenjamin Close } 7116607310bSBenjamin Close 712692ad7caSAdrian Chadd /* Uninstall interrupt handler. */ 713692ad7caSAdrian Chadd if (sc->irq != NULL) { 714692ad7caSAdrian Chadd bus_teardown_intr(dev, sc->irq, sc->sc_ih); 715692ad7caSAdrian Chadd bus_release_resource(dev, SYS_RES_IRQ, rman_get_rid(sc->irq), 716692ad7caSAdrian Chadd sc->irq); 717692ad7caSAdrian Chadd pci_release_msi(dev); 71882f1b132SAndrew Thompson } 7196607310bSBenjamin Close 720692ad7caSAdrian Chadd if (sc->txq[0].data_dmat) { 721692ad7caSAdrian Chadd /* Free DMA resources. */ 722692ad7caSAdrian Chadd for (qid = 0; qid < WPI_NTXQUEUES; qid++) 723692ad7caSAdrian Chadd wpi_free_tx_ring(sc, &sc->txq[qid]); 724692ad7caSAdrian Chadd 725692ad7caSAdrian Chadd wpi_free_rx_ring(sc); 726692ad7caSAdrian Chadd wpi_free_shared(sc); 7276607310bSBenjamin Close } 7286607310bSBenjamin Close 729692ad7caSAdrian Chadd if (sc->fw_dma.tag) 730692ad7caSAdrian Chadd wpi_free_fwmem(sc); 7316607310bSBenjamin Close 732692ad7caSAdrian Chadd if (sc->mem != NULL) 733692ad7caSAdrian Chadd bus_release_resource(dev, SYS_RES_MEMORY, 734692ad7caSAdrian Chadd rman_get_rid(sc->mem), sc->mem); 735692ad7caSAdrian Chadd 736692ad7caSAdrian Chadd if (ifp != NULL) 737692ad7caSAdrian Chadd if_free(ifp); 738692ad7caSAdrian Chadd 739692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 740fc5870b4SAdrian Chadd WPI_TXQ_STATE_LOCK_DESTROY(sc); 74163f57699SAdrian Chadd WPI_TXQ_LOCK_DESTROY(sc); 7427964dd56SAdrian Chadd WPI_NT_LOCK_DESTROY(sc); 743446685e4SAdrian Chadd WPI_RXON_LOCK_DESTROY(sc); 7445effcbfdSAdrian Chadd WPI_TX_LOCK_DESTROY(sc); 745692ad7caSAdrian Chadd WPI_LOCK_DESTROY(sc); 7466607310bSBenjamin Close return 0; 7476607310bSBenjamin Close } 7486607310bSBenjamin Close 7496607310bSBenjamin Close static int 7506607310bSBenjamin Close wpi_shutdown(device_t dev) 7516607310bSBenjamin Close { 7526607310bSBenjamin Close struct wpi_softc *sc = device_get_softc(dev); 7536607310bSBenjamin Close 754692ad7caSAdrian Chadd wpi_stop(sc); 7556607310bSBenjamin Close return 0; 7566607310bSBenjamin Close } 7576607310bSBenjamin Close 7586607310bSBenjamin Close static int 7596607310bSBenjamin Close wpi_suspend(device_t dev) 7606607310bSBenjamin Close { 7616607310bSBenjamin Close struct wpi_softc *sc = device_get_softc(dev); 762ada977b1SBernhard Schmidt struct ieee80211com *ic = sc->sc_ifp->if_l2com; 7636607310bSBenjamin Close 764ada977b1SBernhard Schmidt ieee80211_suspend_all(ic); 7656607310bSBenjamin Close return 0; 7666607310bSBenjamin Close } 7676607310bSBenjamin Close 7686607310bSBenjamin Close static int 7696607310bSBenjamin Close wpi_resume(device_t dev) 7706607310bSBenjamin Close { 7716607310bSBenjamin Close struct wpi_softc *sc = device_get_softc(dev); 772ada977b1SBernhard Schmidt struct ieee80211com *ic = sc->sc_ifp->if_l2com; 7736607310bSBenjamin Close 774692ad7caSAdrian Chadd /* Clear device-specific "PCI retry timeout" register (41h). */ 7756607310bSBenjamin Close pci_write_config(dev, 0x41, 0, 1); 7766607310bSBenjamin Close 777ada977b1SBernhard Schmidt ieee80211_resume_all(ic); 7786607310bSBenjamin Close return 0; 7796607310bSBenjamin Close } 7806607310bSBenjamin Close 781692ad7caSAdrian Chadd /* 782692ad7caSAdrian Chadd * Grab exclusive access to NIC memory. 783692ad7caSAdrian Chadd */ 784692ad7caSAdrian Chadd static int 785692ad7caSAdrian Chadd wpi_nic_lock(struct wpi_softc *sc) 786692ad7caSAdrian Chadd { 787692ad7caSAdrian Chadd int ntries; 788692ad7caSAdrian Chadd 789692ad7caSAdrian Chadd /* Request exclusive access to NIC. */ 790692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 791692ad7caSAdrian Chadd 792692ad7caSAdrian Chadd /* Spin until we actually get the lock. */ 793692ad7caSAdrian Chadd for (ntries = 0; ntries < 1000; ntries++) { 794692ad7caSAdrian Chadd if ((WPI_READ(sc, WPI_GP_CNTRL) & 795692ad7caSAdrian Chadd (WPI_GP_CNTRL_MAC_ACCESS_ENA | WPI_GP_CNTRL_SLEEP)) == 796692ad7caSAdrian Chadd WPI_GP_CNTRL_MAC_ACCESS_ENA) 797692ad7caSAdrian Chadd return 0; 798692ad7caSAdrian Chadd DELAY(10); 799692ad7caSAdrian Chadd } 800692ad7caSAdrian Chadd 801692ad7caSAdrian Chadd device_printf(sc->sc_dev, "could not lock memory\n"); 802692ad7caSAdrian Chadd 803692ad7caSAdrian Chadd return ETIMEDOUT; 804692ad7caSAdrian Chadd } 805692ad7caSAdrian Chadd 806692ad7caSAdrian Chadd /* 807692ad7caSAdrian Chadd * Release lock on NIC memory. 808692ad7caSAdrian Chadd */ 809692ad7caSAdrian Chadd static __inline void 810692ad7caSAdrian Chadd wpi_nic_unlock(struct wpi_softc *sc) 811692ad7caSAdrian Chadd { 812692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 813692ad7caSAdrian Chadd } 814692ad7caSAdrian Chadd 815692ad7caSAdrian Chadd static __inline uint32_t 816692ad7caSAdrian Chadd wpi_prph_read(struct wpi_softc *sc, uint32_t addr) 817692ad7caSAdrian Chadd { 818692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_PRPH_RADDR, WPI_PRPH_DWORD | addr); 819692ad7caSAdrian Chadd WPI_BARRIER_READ_WRITE(sc); 820692ad7caSAdrian Chadd return WPI_READ(sc, WPI_PRPH_RDATA); 821692ad7caSAdrian Chadd } 822692ad7caSAdrian Chadd 823692ad7caSAdrian Chadd static __inline void 824692ad7caSAdrian Chadd wpi_prph_write(struct wpi_softc *sc, uint32_t addr, uint32_t data) 825692ad7caSAdrian Chadd { 826692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_PRPH_WADDR, WPI_PRPH_DWORD | addr); 827692ad7caSAdrian Chadd WPI_BARRIER_WRITE(sc); 828692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_PRPH_WDATA, data); 829692ad7caSAdrian Chadd } 830692ad7caSAdrian Chadd 831692ad7caSAdrian Chadd static __inline void 832692ad7caSAdrian Chadd wpi_prph_setbits(struct wpi_softc *sc, uint32_t addr, uint32_t mask) 833692ad7caSAdrian Chadd { 834692ad7caSAdrian Chadd wpi_prph_write(sc, addr, wpi_prph_read(sc, addr) | mask); 835692ad7caSAdrian Chadd } 836692ad7caSAdrian Chadd 837692ad7caSAdrian Chadd static __inline void 838692ad7caSAdrian Chadd wpi_prph_clrbits(struct wpi_softc *sc, uint32_t addr, uint32_t mask) 839692ad7caSAdrian Chadd { 840692ad7caSAdrian Chadd wpi_prph_write(sc, addr, wpi_prph_read(sc, addr) & ~mask); 841692ad7caSAdrian Chadd } 842692ad7caSAdrian Chadd 843692ad7caSAdrian Chadd static __inline void 844692ad7caSAdrian Chadd wpi_prph_write_region_4(struct wpi_softc *sc, uint32_t addr, 845692ad7caSAdrian Chadd const uint32_t *data, int count) 846692ad7caSAdrian Chadd { 847692ad7caSAdrian Chadd for (; count > 0; count--, data++, addr += 4) 848692ad7caSAdrian Chadd wpi_prph_write(sc, addr, *data); 849692ad7caSAdrian Chadd } 850692ad7caSAdrian Chadd 851692ad7caSAdrian Chadd static __inline uint32_t 852692ad7caSAdrian Chadd wpi_mem_read(struct wpi_softc *sc, uint32_t addr) 853692ad7caSAdrian Chadd { 854692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_MEM_RADDR, addr); 855692ad7caSAdrian Chadd WPI_BARRIER_READ_WRITE(sc); 856692ad7caSAdrian Chadd return WPI_READ(sc, WPI_MEM_RDATA); 857692ad7caSAdrian Chadd } 858692ad7caSAdrian Chadd 859692ad7caSAdrian Chadd static __inline void 860692ad7caSAdrian Chadd wpi_mem_read_region_4(struct wpi_softc *sc, uint32_t addr, uint32_t *data, 861692ad7caSAdrian Chadd int count) 862692ad7caSAdrian Chadd { 863692ad7caSAdrian Chadd for (; count > 0; count--, addr += 4) 864692ad7caSAdrian Chadd *data++ = wpi_mem_read(sc, addr); 865692ad7caSAdrian Chadd } 866692ad7caSAdrian Chadd 867692ad7caSAdrian Chadd static int 868692ad7caSAdrian Chadd wpi_read_prom_data(struct wpi_softc *sc, uint32_t addr, void *data, int count) 869692ad7caSAdrian Chadd { 870692ad7caSAdrian Chadd uint8_t *out = data; 871692ad7caSAdrian Chadd uint32_t val; 872692ad7caSAdrian Chadd int error, ntries; 873692ad7caSAdrian Chadd 874692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 875692ad7caSAdrian Chadd 876692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 877692ad7caSAdrian Chadd return error; 878692ad7caSAdrian Chadd 879692ad7caSAdrian Chadd for (; count > 0; count -= 2, addr++) { 880692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_EEPROM, addr << 2); 881692ad7caSAdrian Chadd for (ntries = 0; ntries < 10; ntries++) { 882692ad7caSAdrian Chadd val = WPI_READ(sc, WPI_EEPROM); 883692ad7caSAdrian Chadd if (val & WPI_EEPROM_READ_VALID) 884692ad7caSAdrian Chadd break; 885692ad7caSAdrian Chadd DELAY(5); 886692ad7caSAdrian Chadd } 887692ad7caSAdrian Chadd if (ntries == 10) { 888692ad7caSAdrian Chadd device_printf(sc->sc_dev, 889692ad7caSAdrian Chadd "timeout reading ROM at 0x%x\n", addr); 890692ad7caSAdrian Chadd return ETIMEDOUT; 891692ad7caSAdrian Chadd } 892692ad7caSAdrian Chadd *out++= val >> 16; 893692ad7caSAdrian Chadd if (count > 1) 894692ad7caSAdrian Chadd *out ++= val >> 24; 895692ad7caSAdrian Chadd } 896692ad7caSAdrian Chadd 897692ad7caSAdrian Chadd wpi_nic_unlock(sc); 898692ad7caSAdrian Chadd 899692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 900692ad7caSAdrian Chadd 901692ad7caSAdrian Chadd return 0; 902692ad7caSAdrian Chadd } 903692ad7caSAdrian Chadd 904692ad7caSAdrian Chadd static void 905692ad7caSAdrian Chadd wpi_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 906692ad7caSAdrian Chadd { 907692ad7caSAdrian Chadd if (error != 0) 908692ad7caSAdrian Chadd return; 909692ad7caSAdrian Chadd KASSERT(nsegs == 1, ("too many DMA segments, %d should be 1", nsegs)); 910692ad7caSAdrian Chadd *(bus_addr_t *)arg = segs[0].ds_addr; 911692ad7caSAdrian Chadd } 912692ad7caSAdrian Chadd 913692ad7caSAdrian Chadd /* 914692ad7caSAdrian Chadd * Allocates a contiguous block of dma memory of the requested size and 915692ad7caSAdrian Chadd * alignment. 916692ad7caSAdrian Chadd */ 917692ad7caSAdrian Chadd static int 918692ad7caSAdrian Chadd wpi_dma_contig_alloc(struct wpi_softc *sc, struct wpi_dma_info *dma, 919692ad7caSAdrian Chadd void **kvap, bus_size_t size, bus_size_t alignment) 920692ad7caSAdrian Chadd { 921692ad7caSAdrian Chadd int error; 922692ad7caSAdrian Chadd 923692ad7caSAdrian Chadd dma->tag = NULL; 924692ad7caSAdrian Chadd dma->size = size; 925692ad7caSAdrian Chadd 926692ad7caSAdrian Chadd error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), alignment, 927692ad7caSAdrian Chadd 0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, size, 928692ad7caSAdrian Chadd 1, size, BUS_DMA_NOWAIT, NULL, NULL, &dma->tag); 929692ad7caSAdrian Chadd if (error != 0) 930692ad7caSAdrian Chadd goto fail; 931692ad7caSAdrian Chadd 932692ad7caSAdrian Chadd error = bus_dmamem_alloc(dma->tag, (void **)&dma->vaddr, 933692ad7caSAdrian Chadd BUS_DMA_NOWAIT | BUS_DMA_ZERO | BUS_DMA_COHERENT, &dma->map); 934692ad7caSAdrian Chadd if (error != 0) 935692ad7caSAdrian Chadd goto fail; 936692ad7caSAdrian Chadd 937692ad7caSAdrian Chadd error = bus_dmamap_load(dma->tag, dma->map, dma->vaddr, size, 938692ad7caSAdrian Chadd wpi_dma_map_addr, &dma->paddr, BUS_DMA_NOWAIT); 939692ad7caSAdrian Chadd if (error != 0) 940692ad7caSAdrian Chadd goto fail; 941692ad7caSAdrian Chadd 942692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 943692ad7caSAdrian Chadd 944692ad7caSAdrian Chadd if (kvap != NULL) 945692ad7caSAdrian Chadd *kvap = dma->vaddr; 946692ad7caSAdrian Chadd 947692ad7caSAdrian Chadd return 0; 948692ad7caSAdrian Chadd 949692ad7caSAdrian Chadd fail: wpi_dma_contig_free(dma); 950692ad7caSAdrian Chadd return error; 951692ad7caSAdrian Chadd } 952692ad7caSAdrian Chadd 953692ad7caSAdrian Chadd static void 954692ad7caSAdrian Chadd wpi_dma_contig_free(struct wpi_dma_info *dma) 955692ad7caSAdrian Chadd { 956692ad7caSAdrian Chadd if (dma->vaddr != NULL) { 957692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, 958692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 959692ad7caSAdrian Chadd bus_dmamap_unload(dma->tag, dma->map); 960692ad7caSAdrian Chadd bus_dmamem_free(dma->tag, dma->vaddr, dma->map); 961692ad7caSAdrian Chadd dma->vaddr = NULL; 962692ad7caSAdrian Chadd } 963692ad7caSAdrian Chadd if (dma->tag != NULL) { 964692ad7caSAdrian Chadd bus_dma_tag_destroy(dma->tag); 965692ad7caSAdrian Chadd dma->tag = NULL; 966692ad7caSAdrian Chadd } 967692ad7caSAdrian Chadd } 968692ad7caSAdrian Chadd 969692ad7caSAdrian Chadd /* 970692ad7caSAdrian Chadd * Allocate a shared page between host and NIC. 971692ad7caSAdrian Chadd */ 972692ad7caSAdrian Chadd static int 973692ad7caSAdrian Chadd wpi_alloc_shared(struct wpi_softc *sc) 974692ad7caSAdrian Chadd { 975692ad7caSAdrian Chadd /* Shared buffer must be aligned on a 4KB boundary. */ 976692ad7caSAdrian Chadd return wpi_dma_contig_alloc(sc, &sc->shared_dma, 977692ad7caSAdrian Chadd (void **)&sc->shared, sizeof (struct wpi_shared), 4096); 978692ad7caSAdrian Chadd } 979692ad7caSAdrian Chadd 980692ad7caSAdrian Chadd static void 981692ad7caSAdrian Chadd wpi_free_shared(struct wpi_softc *sc) 982692ad7caSAdrian Chadd { 983692ad7caSAdrian Chadd wpi_dma_contig_free(&sc->shared_dma); 984692ad7caSAdrian Chadd } 985692ad7caSAdrian Chadd 986692ad7caSAdrian Chadd /* 987692ad7caSAdrian Chadd * Allocate DMA-safe memory for firmware transfer. 988692ad7caSAdrian Chadd */ 989692ad7caSAdrian Chadd static int 990692ad7caSAdrian Chadd wpi_alloc_fwmem(struct wpi_softc *sc) 991692ad7caSAdrian Chadd { 992692ad7caSAdrian Chadd /* Must be aligned on a 16-byte boundary. */ 993692ad7caSAdrian Chadd return wpi_dma_contig_alloc(sc, &sc->fw_dma, NULL, 994692ad7caSAdrian Chadd WPI_FW_TEXT_MAXSZ + WPI_FW_DATA_MAXSZ, 16); 995692ad7caSAdrian Chadd } 996692ad7caSAdrian Chadd 997692ad7caSAdrian Chadd static void 998692ad7caSAdrian Chadd wpi_free_fwmem(struct wpi_softc *sc) 999692ad7caSAdrian Chadd { 1000692ad7caSAdrian Chadd wpi_dma_contig_free(&sc->fw_dma); 1001692ad7caSAdrian Chadd } 1002692ad7caSAdrian Chadd 1003692ad7caSAdrian Chadd static int 1004692ad7caSAdrian Chadd wpi_alloc_rx_ring(struct wpi_softc *sc) 1005692ad7caSAdrian Chadd { 1006692ad7caSAdrian Chadd struct wpi_rx_ring *ring = &sc->rxq; 1007692ad7caSAdrian Chadd bus_size_t size; 1008692ad7caSAdrian Chadd int i, error; 1009692ad7caSAdrian Chadd 1010692ad7caSAdrian Chadd ring->cur = 0; 1011692ad7caSAdrian Chadd ring->update = 0; 1012692ad7caSAdrian Chadd 1013692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1014692ad7caSAdrian Chadd 1015692ad7caSAdrian Chadd /* Allocate RX descriptors (16KB aligned.) */ 1016692ad7caSAdrian Chadd size = WPI_RX_RING_COUNT * sizeof (uint32_t); 1017692ad7caSAdrian Chadd error = wpi_dma_contig_alloc(sc, &ring->desc_dma, 1018692ad7caSAdrian Chadd (void **)&ring->desc, size, WPI_RING_DMA_ALIGN); 1019692ad7caSAdrian Chadd if (error != 0) { 1020692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1021692ad7caSAdrian Chadd "%s: could not allocate RX ring DMA memory, error %d\n", 1022692ad7caSAdrian Chadd __func__, error); 1023692ad7caSAdrian Chadd goto fail; 1024692ad7caSAdrian Chadd } 1025692ad7caSAdrian Chadd 1026692ad7caSAdrian Chadd /* Create RX buffer DMA tag. */ 1027692ad7caSAdrian Chadd error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, 1028692ad7caSAdrian Chadd BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 1029692ad7caSAdrian Chadd MJUMPAGESIZE, 1, MJUMPAGESIZE, BUS_DMA_NOWAIT, NULL, NULL, 1030692ad7caSAdrian Chadd &ring->data_dmat); 1031692ad7caSAdrian Chadd if (error != 0) { 1032692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1033692ad7caSAdrian Chadd "%s: could not create RX buf DMA tag, error %d\n", 1034692ad7caSAdrian Chadd __func__, error); 1035692ad7caSAdrian Chadd goto fail; 1036692ad7caSAdrian Chadd } 1037692ad7caSAdrian Chadd 1038692ad7caSAdrian Chadd /* 1039692ad7caSAdrian Chadd * Allocate and map RX buffers. 1040692ad7caSAdrian Chadd */ 1041692ad7caSAdrian Chadd for (i = 0; i < WPI_RX_RING_COUNT; i++) { 1042692ad7caSAdrian Chadd struct wpi_rx_data *data = &ring->data[i]; 1043692ad7caSAdrian Chadd bus_addr_t paddr; 1044692ad7caSAdrian Chadd 1045692ad7caSAdrian Chadd error = bus_dmamap_create(ring->data_dmat, 0, &data->map); 1046692ad7caSAdrian Chadd if (error != 0) { 1047692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1048692ad7caSAdrian Chadd "%s: could not create RX buf DMA map, error %d\n", 1049692ad7caSAdrian Chadd __func__, error); 1050692ad7caSAdrian Chadd goto fail; 1051692ad7caSAdrian Chadd } 1052692ad7caSAdrian Chadd 1053692ad7caSAdrian Chadd data->m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); 1054692ad7caSAdrian Chadd if (data->m == NULL) { 1055692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1056692ad7caSAdrian Chadd "%s: could not allocate RX mbuf\n", __func__); 1057692ad7caSAdrian Chadd error = ENOBUFS; 1058692ad7caSAdrian Chadd goto fail; 1059692ad7caSAdrian Chadd } 1060692ad7caSAdrian Chadd 1061692ad7caSAdrian Chadd error = bus_dmamap_load(ring->data_dmat, data->map, 1062692ad7caSAdrian Chadd mtod(data->m, void *), MJUMPAGESIZE, wpi_dma_map_addr, 1063692ad7caSAdrian Chadd &paddr, BUS_DMA_NOWAIT); 1064692ad7caSAdrian Chadd if (error != 0 && error != EFBIG) { 1065692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1066692ad7caSAdrian Chadd "%s: can't map mbuf (error %d)\n", __func__, 1067692ad7caSAdrian Chadd error); 1068692ad7caSAdrian Chadd goto fail; 1069692ad7caSAdrian Chadd } 1070692ad7caSAdrian Chadd 1071692ad7caSAdrian Chadd /* Set physical address of RX buffer. */ 1072692ad7caSAdrian Chadd ring->desc[i] = htole32(paddr); 1073692ad7caSAdrian Chadd } 1074692ad7caSAdrian Chadd 1075692ad7caSAdrian Chadd bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 1076692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1077692ad7caSAdrian Chadd 1078692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1079692ad7caSAdrian Chadd 1080692ad7caSAdrian Chadd return 0; 1081692ad7caSAdrian Chadd 1082692ad7caSAdrian Chadd fail: wpi_free_rx_ring(sc); 1083692ad7caSAdrian Chadd 1084692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1085692ad7caSAdrian Chadd 1086692ad7caSAdrian Chadd return error; 1087692ad7caSAdrian Chadd } 1088692ad7caSAdrian Chadd 1089692ad7caSAdrian Chadd static void 1090692ad7caSAdrian Chadd wpi_update_rx_ring(struct wpi_softc *sc) 1091692ad7caSAdrian Chadd { 1092692ad7caSAdrian Chadd struct wpi_rx_ring *ring = &sc->rxq; 1093692ad7caSAdrian Chadd 109401729242SAdrian Chadd if (ring->update != 0) { 109501729242SAdrian Chadd /* Wait for INT_WAKEUP event. */ 109601729242SAdrian Chadd return; 109701729242SAdrian Chadd } 109801729242SAdrian Chadd 1099692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_UCODE_GP1) & WPI_UCODE_GP1_MAC_SLEEP) { 1100692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_PWRSAVE, "%s: wakeup request\n", 1101692ad7caSAdrian Chadd __func__); 1102692ad7caSAdrian Chadd 1103692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 1104692ad7caSAdrian Chadd ring->update = 1; 1105692ad7caSAdrian Chadd } else 1106692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_WPTR, ring->cur & ~7); 1107692ad7caSAdrian Chadd } 1108692ad7caSAdrian Chadd 1109692ad7caSAdrian Chadd static void 1110692ad7caSAdrian Chadd wpi_reset_rx_ring(struct wpi_softc *sc) 1111692ad7caSAdrian Chadd { 1112692ad7caSAdrian Chadd struct wpi_rx_ring *ring = &sc->rxq; 1113692ad7caSAdrian Chadd int ntries; 1114692ad7caSAdrian Chadd 1115692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 1116692ad7caSAdrian Chadd 1117692ad7caSAdrian Chadd if (wpi_nic_lock(sc) == 0) { 1118692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_CONFIG, 0); 1119692ad7caSAdrian Chadd for (ntries = 0; ntries < 1000; ntries++) { 1120692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_FH_RX_STATUS) & 1121692ad7caSAdrian Chadd WPI_FH_RX_STATUS_IDLE) 1122692ad7caSAdrian Chadd break; 1123692ad7caSAdrian Chadd DELAY(10); 1124692ad7caSAdrian Chadd } 1125692ad7caSAdrian Chadd wpi_nic_unlock(sc); 1126692ad7caSAdrian Chadd } 1127692ad7caSAdrian Chadd 1128692ad7caSAdrian Chadd ring->cur = 0; 1129692ad7caSAdrian Chadd ring->update = 0; 1130692ad7caSAdrian Chadd } 1131692ad7caSAdrian Chadd 1132692ad7caSAdrian Chadd static void 1133692ad7caSAdrian Chadd wpi_free_rx_ring(struct wpi_softc *sc) 1134692ad7caSAdrian Chadd { 1135692ad7caSAdrian Chadd struct wpi_rx_ring *ring = &sc->rxq; 1136692ad7caSAdrian Chadd int i; 1137692ad7caSAdrian Chadd 1138692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 1139692ad7caSAdrian Chadd 1140692ad7caSAdrian Chadd wpi_dma_contig_free(&ring->desc_dma); 1141692ad7caSAdrian Chadd 1142692ad7caSAdrian Chadd for (i = 0; i < WPI_RX_RING_COUNT; i++) { 1143692ad7caSAdrian Chadd struct wpi_rx_data *data = &ring->data[i]; 1144692ad7caSAdrian Chadd 1145692ad7caSAdrian Chadd if (data->m != NULL) { 1146692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 1147692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 1148692ad7caSAdrian Chadd bus_dmamap_unload(ring->data_dmat, data->map); 1149692ad7caSAdrian Chadd m_freem(data->m); 1150692ad7caSAdrian Chadd data->m = NULL; 1151692ad7caSAdrian Chadd } 1152692ad7caSAdrian Chadd if (data->map != NULL) 1153692ad7caSAdrian Chadd bus_dmamap_destroy(ring->data_dmat, data->map); 1154692ad7caSAdrian Chadd } 1155692ad7caSAdrian Chadd if (ring->data_dmat != NULL) { 1156692ad7caSAdrian Chadd bus_dma_tag_destroy(ring->data_dmat); 1157692ad7caSAdrian Chadd ring->data_dmat = NULL; 1158692ad7caSAdrian Chadd } 1159692ad7caSAdrian Chadd } 1160692ad7caSAdrian Chadd 1161692ad7caSAdrian Chadd static int 1162692ad7caSAdrian Chadd wpi_alloc_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring, int qid) 1163692ad7caSAdrian Chadd { 1164692ad7caSAdrian Chadd bus_addr_t paddr; 1165692ad7caSAdrian Chadd bus_size_t size; 1166692ad7caSAdrian Chadd int i, error; 1167692ad7caSAdrian Chadd 1168692ad7caSAdrian Chadd ring->qid = qid; 1169692ad7caSAdrian Chadd ring->queued = 0; 1170692ad7caSAdrian Chadd ring->cur = 0; 1171692ad7caSAdrian Chadd ring->update = 0; 1172692ad7caSAdrian Chadd 1173692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1174692ad7caSAdrian Chadd 1175692ad7caSAdrian Chadd /* Allocate TX descriptors (16KB aligned.) */ 1176692ad7caSAdrian Chadd size = WPI_TX_RING_COUNT * sizeof (struct wpi_tx_desc); 1177692ad7caSAdrian Chadd error = wpi_dma_contig_alloc(sc, &ring->desc_dma, (void **)&ring->desc, 1178692ad7caSAdrian Chadd size, WPI_RING_DMA_ALIGN); 1179692ad7caSAdrian Chadd if (error != 0) { 1180692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1181692ad7caSAdrian Chadd "%s: could not allocate TX ring DMA memory, error %d\n", 1182692ad7caSAdrian Chadd __func__, error); 1183692ad7caSAdrian Chadd goto fail; 1184692ad7caSAdrian Chadd } 1185692ad7caSAdrian Chadd 1186692ad7caSAdrian Chadd /* Update shared area with ring physical address. */ 1187692ad7caSAdrian Chadd sc->shared->txbase[qid] = htole32(ring->desc_dma.paddr); 1188692ad7caSAdrian Chadd bus_dmamap_sync(sc->shared_dma.tag, sc->shared_dma.map, 1189692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1190692ad7caSAdrian Chadd 1191692ad7caSAdrian Chadd /* 1192692ad7caSAdrian Chadd * We only use rings 0 through 4 (4 EDCA + cmd) so there is no need 1193692ad7caSAdrian Chadd * to allocate commands space for other rings. 1194692ad7caSAdrian Chadd * XXX Do we really need to allocate descriptors for other rings? 1195692ad7caSAdrian Chadd */ 1196cec45f04SAdrian Chadd if (qid > WPI_CMD_QUEUE_NUM) { 1197cec45f04SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1198692ad7caSAdrian Chadd return 0; 1199cec45f04SAdrian Chadd } 1200692ad7caSAdrian Chadd 1201692ad7caSAdrian Chadd size = WPI_TX_RING_COUNT * sizeof (struct wpi_tx_cmd); 1202692ad7caSAdrian Chadd error = wpi_dma_contig_alloc(sc, &ring->cmd_dma, (void **)&ring->cmd, 1203692ad7caSAdrian Chadd size, 4); 1204692ad7caSAdrian Chadd if (error != 0) { 1205692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1206692ad7caSAdrian Chadd "%s: could not allocate TX cmd DMA memory, error %d\n", 1207692ad7caSAdrian Chadd __func__, error); 1208692ad7caSAdrian Chadd goto fail; 1209692ad7caSAdrian Chadd } 1210692ad7caSAdrian Chadd 1211692ad7caSAdrian Chadd error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, 1212692ad7caSAdrian Chadd BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES, 1213692ad7caSAdrian Chadd WPI_MAX_SCATTER - 1, MCLBYTES, BUS_DMA_NOWAIT, NULL, NULL, 1214692ad7caSAdrian Chadd &ring->data_dmat); 1215692ad7caSAdrian Chadd if (error != 0) { 1216692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1217692ad7caSAdrian Chadd "%s: could not create TX buf DMA tag, error %d\n", 1218692ad7caSAdrian Chadd __func__, error); 1219692ad7caSAdrian Chadd goto fail; 1220692ad7caSAdrian Chadd } 1221692ad7caSAdrian Chadd 1222692ad7caSAdrian Chadd paddr = ring->cmd_dma.paddr; 1223692ad7caSAdrian Chadd for (i = 0; i < WPI_TX_RING_COUNT; i++) { 1224692ad7caSAdrian Chadd struct wpi_tx_data *data = &ring->data[i]; 1225692ad7caSAdrian Chadd 1226692ad7caSAdrian Chadd data->cmd_paddr = paddr; 1227692ad7caSAdrian Chadd paddr += sizeof (struct wpi_tx_cmd); 1228692ad7caSAdrian Chadd 1229692ad7caSAdrian Chadd error = bus_dmamap_create(ring->data_dmat, 0, &data->map); 1230692ad7caSAdrian Chadd if (error != 0) { 1231692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1232692ad7caSAdrian Chadd "%s: could not create TX buf DMA map, error %d\n", 1233692ad7caSAdrian Chadd __func__, error); 1234692ad7caSAdrian Chadd goto fail; 1235692ad7caSAdrian Chadd } 1236692ad7caSAdrian Chadd } 1237692ad7caSAdrian Chadd 1238692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1239692ad7caSAdrian Chadd 1240692ad7caSAdrian Chadd return 0; 1241692ad7caSAdrian Chadd 1242692ad7caSAdrian Chadd fail: wpi_free_tx_ring(sc, ring); 1243692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1244692ad7caSAdrian Chadd return error; 1245692ad7caSAdrian Chadd } 1246692ad7caSAdrian Chadd 1247692ad7caSAdrian Chadd static void 1248692ad7caSAdrian Chadd wpi_update_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring) 1249692ad7caSAdrian Chadd { 125001729242SAdrian Chadd if (ring->update != 0) { 125101729242SAdrian Chadd /* Wait for INT_WAKEUP event. */ 125201729242SAdrian Chadd return; 125301729242SAdrian Chadd } 125401729242SAdrian Chadd 1255692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_UCODE_GP1) & WPI_UCODE_GP1_MAC_SLEEP) { 1256692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_PWRSAVE, "%s (%d): requesting wakeup\n", 1257692ad7caSAdrian Chadd __func__, ring->qid); 1258692ad7caSAdrian Chadd 1259692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 1260692ad7caSAdrian Chadd ring->update = 1; 1261692ad7caSAdrian Chadd } else 1262692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_HBUS_TARG_WRPTR, ring->qid << 8 | ring->cur); 1263692ad7caSAdrian Chadd } 1264692ad7caSAdrian Chadd 1265692ad7caSAdrian Chadd static void 1266692ad7caSAdrian Chadd wpi_reset_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring) 1267692ad7caSAdrian Chadd { 1268692ad7caSAdrian Chadd int i; 1269692ad7caSAdrian Chadd 1270692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 1271692ad7caSAdrian Chadd 1272692ad7caSAdrian Chadd for (i = 0; i < WPI_TX_RING_COUNT; i++) { 1273692ad7caSAdrian Chadd struct wpi_tx_data *data = &ring->data[i]; 1274692ad7caSAdrian Chadd 1275692ad7caSAdrian Chadd if (data->m != NULL) { 1276692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 1277692ad7caSAdrian Chadd BUS_DMASYNC_POSTWRITE); 1278692ad7caSAdrian Chadd bus_dmamap_unload(ring->data_dmat, data->map); 1279692ad7caSAdrian Chadd m_freem(data->m); 1280692ad7caSAdrian Chadd data->m = NULL; 1281692ad7caSAdrian Chadd } 1282*978d805fSAdrian Chadd if (data->ni != NULL) { 1283*978d805fSAdrian Chadd ieee80211_free_node(data->ni); 1284*978d805fSAdrian Chadd data->ni = NULL; 1285*978d805fSAdrian Chadd } 1286692ad7caSAdrian Chadd } 1287692ad7caSAdrian Chadd /* Clear TX descriptors. */ 1288692ad7caSAdrian Chadd memset(ring->desc, 0, ring->desc_dma.size); 1289692ad7caSAdrian Chadd bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 1290692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1291692ad7caSAdrian Chadd sc->qfullmsk &= ~(1 << ring->qid); 1292692ad7caSAdrian Chadd ring->queued = 0; 1293692ad7caSAdrian Chadd ring->cur = 0; 1294692ad7caSAdrian Chadd ring->update = 0; 1295692ad7caSAdrian Chadd } 1296692ad7caSAdrian Chadd 1297692ad7caSAdrian Chadd static void 1298692ad7caSAdrian Chadd wpi_free_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring) 1299692ad7caSAdrian Chadd { 1300692ad7caSAdrian Chadd int i; 1301692ad7caSAdrian Chadd 1302692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 1303692ad7caSAdrian Chadd 1304692ad7caSAdrian Chadd wpi_dma_contig_free(&ring->desc_dma); 1305692ad7caSAdrian Chadd wpi_dma_contig_free(&ring->cmd_dma); 1306692ad7caSAdrian Chadd 1307692ad7caSAdrian Chadd for (i = 0; i < WPI_TX_RING_COUNT; i++) { 1308692ad7caSAdrian Chadd struct wpi_tx_data *data = &ring->data[i]; 1309692ad7caSAdrian Chadd 1310692ad7caSAdrian Chadd if (data->m != NULL) { 1311692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 1312692ad7caSAdrian Chadd BUS_DMASYNC_POSTWRITE); 1313692ad7caSAdrian Chadd bus_dmamap_unload(ring->data_dmat, data->map); 1314692ad7caSAdrian Chadd m_freem(data->m); 1315692ad7caSAdrian Chadd } 1316692ad7caSAdrian Chadd if (data->map != NULL) 1317692ad7caSAdrian Chadd bus_dmamap_destroy(ring->data_dmat, data->map); 1318692ad7caSAdrian Chadd } 1319692ad7caSAdrian Chadd if (ring->data_dmat != NULL) { 1320692ad7caSAdrian Chadd bus_dma_tag_destroy(ring->data_dmat); 1321692ad7caSAdrian Chadd ring->data_dmat = NULL; 1322692ad7caSAdrian Chadd } 1323692ad7caSAdrian Chadd } 1324692ad7caSAdrian Chadd 1325692ad7caSAdrian Chadd /* 1326692ad7caSAdrian Chadd * Extract various information from EEPROM. 1327692ad7caSAdrian Chadd */ 1328692ad7caSAdrian Chadd static int 1329692ad7caSAdrian Chadd wpi_read_eeprom(struct wpi_softc *sc, uint8_t macaddr[IEEE80211_ADDR_LEN]) 1330692ad7caSAdrian Chadd { 1331692ad7caSAdrian Chadd #define WPI_CHK(res) do { \ 1332692ad7caSAdrian Chadd if ((error = res) != 0) \ 1333692ad7caSAdrian Chadd goto fail; \ 1334692ad7caSAdrian Chadd } while (0) 1335692ad7caSAdrian Chadd int error, i; 1336692ad7caSAdrian Chadd 1337692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1338692ad7caSAdrian Chadd 1339692ad7caSAdrian Chadd /* Adapter has to be powered on for EEPROM access to work. */ 1340692ad7caSAdrian Chadd if ((error = wpi_apm_init(sc)) != 0) { 1341692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1342692ad7caSAdrian Chadd "%s: could not power ON adapter, error %d\n", __func__, 1343692ad7caSAdrian Chadd error); 1344692ad7caSAdrian Chadd return error; 1345692ad7caSAdrian Chadd } 1346692ad7caSAdrian Chadd 1347692ad7caSAdrian Chadd if ((WPI_READ(sc, WPI_EEPROM_GP) & 0x6) == 0) { 1348692ad7caSAdrian Chadd device_printf(sc->sc_dev, "bad EEPROM signature\n"); 1349692ad7caSAdrian Chadd error = EIO; 1350692ad7caSAdrian Chadd goto fail; 1351692ad7caSAdrian Chadd } 1352692ad7caSAdrian Chadd /* Clear HW ownership of EEPROM. */ 1353692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_EEPROM_GP, WPI_EEPROM_GP_IF_OWNER); 1354692ad7caSAdrian Chadd 1355692ad7caSAdrian Chadd /* Read the hardware capabilities, revision and SKU type. */ 1356692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_SKU_CAP, &sc->cap, 1357692ad7caSAdrian Chadd sizeof(sc->cap))); 1358692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_REVISION, &sc->rev, 1359692ad7caSAdrian Chadd sizeof(sc->rev))); 1360692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_TYPE, &sc->type, 1361692ad7caSAdrian Chadd sizeof(sc->type))); 1362692ad7caSAdrian Chadd 1363f736d898SAdrian Chadd sc->rev = le16toh(sc->rev); 13647167f5fcSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, "cap=%x rev=%x type=%x\n", sc->cap, 1365f736d898SAdrian Chadd sc->rev, sc->type); 1366692ad7caSAdrian Chadd 1367692ad7caSAdrian Chadd /* Read the regulatory domain (4 ASCII characters.) */ 1368692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_DOMAIN, sc->domain, 1369692ad7caSAdrian Chadd sizeof(sc->domain))); 1370692ad7caSAdrian Chadd 1371692ad7caSAdrian Chadd /* Read MAC address. */ 1372692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_MAC, macaddr, 1373692ad7caSAdrian Chadd IEEE80211_ADDR_LEN)); 1374692ad7caSAdrian Chadd 1375692ad7caSAdrian Chadd /* Read the list of authorized channels. */ 1376692ad7caSAdrian Chadd for (i = 0; i < WPI_CHAN_BANDS_COUNT; i++) 1377692ad7caSAdrian Chadd WPI_CHK(wpi_read_eeprom_channels(sc, i)); 1378692ad7caSAdrian Chadd 1379692ad7caSAdrian Chadd /* Read the list of TX power groups. */ 1380692ad7caSAdrian Chadd for (i = 0; i < WPI_POWER_GROUPS_COUNT; i++) 1381692ad7caSAdrian Chadd WPI_CHK(wpi_read_eeprom_group(sc, i)); 1382692ad7caSAdrian Chadd 1383692ad7caSAdrian Chadd fail: wpi_apm_stop(sc); /* Power OFF adapter. */ 1384692ad7caSAdrian Chadd 1385692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, error ? TRACE_STR_END_ERR : TRACE_STR_END, 1386692ad7caSAdrian Chadd __func__); 1387692ad7caSAdrian Chadd 1388692ad7caSAdrian Chadd return error; 1389692ad7caSAdrian Chadd #undef WPI_CHK 1390692ad7caSAdrian Chadd } 1391692ad7caSAdrian Chadd 1392692ad7caSAdrian Chadd /* 1393692ad7caSAdrian Chadd * Translate EEPROM flags to net80211. 1394692ad7caSAdrian Chadd */ 1395692ad7caSAdrian Chadd static uint32_t 1396692ad7caSAdrian Chadd wpi_eeprom_channel_flags(struct wpi_eeprom_chan *channel) 1397692ad7caSAdrian Chadd { 1398692ad7caSAdrian Chadd uint32_t nflags; 1399692ad7caSAdrian Chadd 1400692ad7caSAdrian Chadd nflags = 0; 1401692ad7caSAdrian Chadd if ((channel->flags & WPI_EEPROM_CHAN_ACTIVE) == 0) 1402692ad7caSAdrian Chadd nflags |= IEEE80211_CHAN_PASSIVE; 1403692ad7caSAdrian Chadd if ((channel->flags & WPI_EEPROM_CHAN_IBSS) == 0) 1404692ad7caSAdrian Chadd nflags |= IEEE80211_CHAN_NOADHOC; 1405692ad7caSAdrian Chadd if (channel->flags & WPI_EEPROM_CHAN_RADAR) { 1406692ad7caSAdrian Chadd nflags |= IEEE80211_CHAN_DFS; 1407692ad7caSAdrian Chadd /* XXX apparently IBSS may still be marked */ 1408692ad7caSAdrian Chadd nflags |= IEEE80211_CHAN_NOADHOC; 1409692ad7caSAdrian Chadd } 1410692ad7caSAdrian Chadd 1411726ddc26SAdrian Chadd /* XXX HOSTAP uses WPI_MODE_IBSS */ 1412726ddc26SAdrian Chadd if (nflags & IEEE80211_CHAN_NOADHOC) 1413726ddc26SAdrian Chadd nflags |= IEEE80211_CHAN_NOHOSTAP; 1414726ddc26SAdrian Chadd 1415692ad7caSAdrian Chadd return nflags; 1416692ad7caSAdrian Chadd } 1417692ad7caSAdrian Chadd 1418692ad7caSAdrian Chadd static void 1419692ad7caSAdrian Chadd wpi_read_eeprom_band(struct wpi_softc *sc, int n) 1420692ad7caSAdrian Chadd { 1421692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 1422692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 1423692ad7caSAdrian Chadd struct wpi_eeprom_chan *channels = sc->eeprom_channels[n]; 1424692ad7caSAdrian Chadd const struct wpi_chan_band *band = &wpi_bands[n]; 1425692ad7caSAdrian Chadd struct ieee80211_channel *c; 1426692ad7caSAdrian Chadd uint8_t chan; 1427692ad7caSAdrian Chadd int i, nflags; 1428692ad7caSAdrian Chadd 1429692ad7caSAdrian Chadd for (i = 0; i < band->nchan; i++) { 1430692ad7caSAdrian Chadd if (!(channels[i].flags & WPI_EEPROM_CHAN_VALID)) { 14317e0d5232SAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, 1432692ad7caSAdrian Chadd "Channel Not Valid: %d, band %d\n", 1433692ad7caSAdrian Chadd band->chan[i],n); 1434692ad7caSAdrian Chadd continue; 1435692ad7caSAdrian Chadd } 1436692ad7caSAdrian Chadd 1437692ad7caSAdrian Chadd chan = band->chan[i]; 1438692ad7caSAdrian Chadd nflags = wpi_eeprom_channel_flags(&channels[i]); 1439692ad7caSAdrian Chadd 1440692ad7caSAdrian Chadd c = &ic->ic_channels[ic->ic_nchans++]; 1441692ad7caSAdrian Chadd c->ic_ieee = chan; 1442692ad7caSAdrian Chadd c->ic_maxregpower = channels[i].maxpwr; 1443692ad7caSAdrian Chadd c->ic_maxpower = 2*c->ic_maxregpower; 1444692ad7caSAdrian Chadd 1445692ad7caSAdrian Chadd if (n == 0) { /* 2GHz band */ 14467167f5fcSAdrian Chadd c->ic_freq = ieee80211_ieee2mhz(chan, 14477167f5fcSAdrian Chadd IEEE80211_CHAN_G); 14487167f5fcSAdrian Chadd 1449692ad7caSAdrian Chadd /* G =>'s B is supported */ 1450692ad7caSAdrian Chadd c->ic_flags = IEEE80211_CHAN_B | nflags; 1451692ad7caSAdrian Chadd c = &ic->ic_channels[ic->ic_nchans++]; 1452692ad7caSAdrian Chadd c[0] = c[-1]; 1453692ad7caSAdrian Chadd c->ic_flags = IEEE80211_CHAN_G | nflags; 1454692ad7caSAdrian Chadd } else { /* 5GHz band */ 14557167f5fcSAdrian Chadd c->ic_freq = ieee80211_ieee2mhz(chan, 14567167f5fcSAdrian Chadd IEEE80211_CHAN_A); 14577167f5fcSAdrian Chadd 1458692ad7caSAdrian Chadd c->ic_flags = IEEE80211_CHAN_A | nflags; 1459692ad7caSAdrian Chadd } 1460692ad7caSAdrian Chadd 1461692ad7caSAdrian Chadd /* Save maximum allowed TX power for this channel. */ 1462692ad7caSAdrian Chadd sc->maxpwr[chan] = channels[i].maxpwr; 1463692ad7caSAdrian Chadd 1464692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, 1465692ad7caSAdrian Chadd "adding chan %d (%dMHz) flags=0x%x maxpwr=%d passive=%d," 1466692ad7caSAdrian Chadd " offset %d\n", chan, c->ic_freq, 1467692ad7caSAdrian Chadd channels[i].flags, sc->maxpwr[chan], 1468fae61c69SAdrian Chadd IEEE80211_IS_CHAN_PASSIVE(c), ic->ic_nchans); 1469692ad7caSAdrian Chadd } 1470692ad7caSAdrian Chadd } 1471692ad7caSAdrian Chadd 1472692ad7caSAdrian Chadd /** 1473692ad7caSAdrian Chadd * Read the eeprom to find out what channels are valid for the given 1474692ad7caSAdrian Chadd * band and update net80211 with what we find. 1475692ad7caSAdrian Chadd */ 1476692ad7caSAdrian Chadd static int 1477692ad7caSAdrian Chadd wpi_read_eeprom_channels(struct wpi_softc *sc, int n) 1478692ad7caSAdrian Chadd { 1479692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 1480692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 1481692ad7caSAdrian Chadd const struct wpi_chan_band *band = &wpi_bands[n]; 1482692ad7caSAdrian Chadd int error; 1483692ad7caSAdrian Chadd 1484692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1485692ad7caSAdrian Chadd 1486692ad7caSAdrian Chadd error = wpi_read_prom_data(sc, band->addr, &sc->eeprom_channels[n], 1487692ad7caSAdrian Chadd band->nchan * sizeof (struct wpi_eeprom_chan)); 1488692ad7caSAdrian Chadd if (error != 0) { 1489692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1490692ad7caSAdrian Chadd return error; 1491692ad7caSAdrian Chadd } 1492692ad7caSAdrian Chadd 1493692ad7caSAdrian Chadd wpi_read_eeprom_band(sc, n); 1494692ad7caSAdrian Chadd 1495692ad7caSAdrian Chadd ieee80211_sort_channels(ic->ic_channels, ic->ic_nchans); 1496692ad7caSAdrian Chadd 1497692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1498692ad7caSAdrian Chadd 1499692ad7caSAdrian Chadd return 0; 1500692ad7caSAdrian Chadd } 1501692ad7caSAdrian Chadd 1502692ad7caSAdrian Chadd static struct wpi_eeprom_chan * 1503692ad7caSAdrian Chadd wpi_find_eeprom_channel(struct wpi_softc *sc, struct ieee80211_channel *c) 1504692ad7caSAdrian Chadd { 1505692ad7caSAdrian Chadd int i, j; 1506692ad7caSAdrian Chadd 1507692ad7caSAdrian Chadd for (j = 0; j < WPI_CHAN_BANDS_COUNT; j++) 1508692ad7caSAdrian Chadd for (i = 0; i < wpi_bands[j].nchan; i++) 1509692ad7caSAdrian Chadd if (wpi_bands[j].chan[i] == c->ic_ieee) 1510692ad7caSAdrian Chadd return &sc->eeprom_channels[j][i]; 1511692ad7caSAdrian Chadd 1512692ad7caSAdrian Chadd return NULL; 1513692ad7caSAdrian Chadd } 1514692ad7caSAdrian Chadd 1515692ad7caSAdrian Chadd /* 1516692ad7caSAdrian Chadd * Enforce flags read from EEPROM. 1517692ad7caSAdrian Chadd */ 1518692ad7caSAdrian Chadd static int 1519692ad7caSAdrian Chadd wpi_setregdomain(struct ieee80211com *ic, struct ieee80211_regdomain *rd, 1520692ad7caSAdrian Chadd int nchan, struct ieee80211_channel chans[]) 1521692ad7caSAdrian Chadd { 1522692ad7caSAdrian Chadd struct ifnet *ifp = ic->ic_ifp; 1523692ad7caSAdrian Chadd struct wpi_softc *sc = ifp->if_softc; 1524692ad7caSAdrian Chadd int i; 1525692ad7caSAdrian Chadd 1526692ad7caSAdrian Chadd for (i = 0; i < nchan; i++) { 1527692ad7caSAdrian Chadd struct ieee80211_channel *c = &chans[i]; 1528692ad7caSAdrian Chadd struct wpi_eeprom_chan *channel; 1529692ad7caSAdrian Chadd 1530692ad7caSAdrian Chadd channel = wpi_find_eeprom_channel(sc, c); 1531692ad7caSAdrian Chadd if (channel == NULL) { 1532692ad7caSAdrian Chadd if_printf(ic->ic_ifp, 1533692ad7caSAdrian Chadd "%s: invalid channel %u freq %u/0x%x\n", 1534692ad7caSAdrian Chadd __func__, c->ic_ieee, c->ic_freq, c->ic_flags); 1535692ad7caSAdrian Chadd return EINVAL; 1536692ad7caSAdrian Chadd } 1537692ad7caSAdrian Chadd c->ic_flags |= wpi_eeprom_channel_flags(channel); 1538692ad7caSAdrian Chadd } 1539692ad7caSAdrian Chadd 1540692ad7caSAdrian Chadd return 0; 1541692ad7caSAdrian Chadd } 1542692ad7caSAdrian Chadd 1543692ad7caSAdrian Chadd static int 1544692ad7caSAdrian Chadd wpi_read_eeprom_group(struct wpi_softc *sc, int n) 1545692ad7caSAdrian Chadd { 1546692ad7caSAdrian Chadd struct wpi_power_group *group = &sc->groups[n]; 1547692ad7caSAdrian Chadd struct wpi_eeprom_group rgroup; 1548692ad7caSAdrian Chadd int i, error; 1549692ad7caSAdrian Chadd 1550692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1551692ad7caSAdrian Chadd 1552692ad7caSAdrian Chadd if ((error = wpi_read_prom_data(sc, WPI_EEPROM_POWER_GRP + n * 32, 1553692ad7caSAdrian Chadd &rgroup, sizeof rgroup)) != 0) { 1554692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1555692ad7caSAdrian Chadd return error; 1556692ad7caSAdrian Chadd } 1557692ad7caSAdrian Chadd 1558692ad7caSAdrian Chadd /* Save TX power group information. */ 1559692ad7caSAdrian Chadd group->chan = rgroup.chan; 1560692ad7caSAdrian Chadd group->maxpwr = rgroup.maxpwr; 1561692ad7caSAdrian Chadd /* Retrieve temperature at which the samples were taken. */ 1562692ad7caSAdrian Chadd group->temp = (int16_t)le16toh(rgroup.temp); 1563692ad7caSAdrian Chadd 1564692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, 1565692ad7caSAdrian Chadd "power group %d: chan=%d maxpwr=%d temp=%d\n", n, group->chan, 1566692ad7caSAdrian Chadd group->maxpwr, group->temp); 1567692ad7caSAdrian Chadd 1568692ad7caSAdrian Chadd for (i = 0; i < WPI_SAMPLES_COUNT; i++) { 1569692ad7caSAdrian Chadd group->samples[i].index = rgroup.samples[i].index; 1570692ad7caSAdrian Chadd group->samples[i].power = rgroup.samples[i].power; 1571692ad7caSAdrian Chadd 1572692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, 1573692ad7caSAdrian Chadd "\tsample %d: index=%d power=%d\n", i, 1574692ad7caSAdrian Chadd group->samples[i].index, group->samples[i].power); 1575692ad7caSAdrian Chadd } 1576692ad7caSAdrian Chadd 1577692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1578692ad7caSAdrian Chadd 1579692ad7caSAdrian Chadd return 0; 1580692ad7caSAdrian Chadd } 1581692ad7caSAdrian Chadd 1582eca2eb39SAdrian Chadd static int 1583eca2eb39SAdrian Chadd wpi_add_node_entry_adhoc(struct wpi_softc *sc) 1584eca2eb39SAdrian Chadd { 1585eca2eb39SAdrian Chadd int newid = WPI_ID_IBSS_MIN; 1586eca2eb39SAdrian Chadd 1587eca2eb39SAdrian Chadd for (; newid <= WPI_ID_IBSS_MAX; newid++) { 1588eca2eb39SAdrian Chadd if ((sc->nodesmsk & (1 << newid)) == 0) { 1589eca2eb39SAdrian Chadd sc->nodesmsk |= 1 << newid; 1590eca2eb39SAdrian Chadd return newid; 1591eca2eb39SAdrian Chadd } 1592eca2eb39SAdrian Chadd } 1593eca2eb39SAdrian Chadd 1594eca2eb39SAdrian Chadd return WPI_ID_UNDEFINED; 1595eca2eb39SAdrian Chadd } 1596eca2eb39SAdrian Chadd 1597eca2eb39SAdrian Chadd static __inline int 15980ebca245SAdrian Chadd wpi_add_node_entry_sta(struct wpi_softc *sc) 15990ebca245SAdrian Chadd { 16000ebca245SAdrian Chadd sc->nodesmsk |= 1 << WPI_ID_BSS; 16010ebca245SAdrian Chadd 16020ebca245SAdrian Chadd return WPI_ID_BSS; 16030ebca245SAdrian Chadd } 16040ebca245SAdrian Chadd 16050ebca245SAdrian Chadd static __inline int 1606eca2eb39SAdrian Chadd wpi_check_node_entry(struct wpi_softc *sc, uint8_t id) 1607eca2eb39SAdrian Chadd { 1608eca2eb39SAdrian Chadd if (id == WPI_ID_UNDEFINED) 1609eca2eb39SAdrian Chadd return 0; 1610eca2eb39SAdrian Chadd 1611eca2eb39SAdrian Chadd return (sc->nodesmsk >> id) & 1; 1612eca2eb39SAdrian Chadd } 1613eca2eb39SAdrian Chadd 1614eca2eb39SAdrian Chadd static __inline void 1615eca2eb39SAdrian Chadd wpi_clear_node_table(struct wpi_softc *sc) 1616eca2eb39SAdrian Chadd { 1617eca2eb39SAdrian Chadd sc->nodesmsk = 0; 1618eca2eb39SAdrian Chadd } 1619eca2eb39SAdrian Chadd 1620eca2eb39SAdrian Chadd static __inline void 1621eca2eb39SAdrian Chadd wpi_del_node_entry(struct wpi_softc *sc, uint8_t id) 1622eca2eb39SAdrian Chadd { 1623eca2eb39SAdrian Chadd sc->nodesmsk &= ~(1 << id); 1624eca2eb39SAdrian Chadd } 1625eca2eb39SAdrian Chadd 1626692ad7caSAdrian Chadd static struct ieee80211_node * 1627692ad7caSAdrian Chadd wpi_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN]) 1628692ad7caSAdrian Chadd { 1629692ad7caSAdrian Chadd struct wpi_node *wn; 1630692ad7caSAdrian Chadd 1631692ad7caSAdrian Chadd wn = malloc(sizeof (struct wpi_node), M_80211_NODE, 1632692ad7caSAdrian Chadd M_NOWAIT | M_ZERO); 1633692ad7caSAdrian Chadd 1634692ad7caSAdrian Chadd if (wn == NULL) 1635692ad7caSAdrian Chadd return NULL; 1636692ad7caSAdrian Chadd 1637692ad7caSAdrian Chadd wn->id = WPI_ID_UNDEFINED; 1638692ad7caSAdrian Chadd 1639692ad7caSAdrian Chadd return &wn->ni; 1640692ad7caSAdrian Chadd } 1641692ad7caSAdrian Chadd 1642692ad7caSAdrian Chadd static void 1643692ad7caSAdrian Chadd wpi_node_free(struct ieee80211_node *ni) 1644692ad7caSAdrian Chadd { 1645692ad7caSAdrian Chadd struct ieee80211com *ic = ni->ni_ic; 1646692ad7caSAdrian Chadd struct wpi_softc *sc = ic->ic_ifp->if_softc; 1647a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 1648692ad7caSAdrian Chadd 16490ebca245SAdrian Chadd if (wn->id != WPI_ID_UNDEFINED) { 16507964dd56SAdrian Chadd WPI_NT_LOCK(sc); 1651eca2eb39SAdrian Chadd if (wpi_check_node_entry(sc, wn->id)) { 1652eca2eb39SAdrian Chadd wpi_del_node_entry(sc, wn->id); 1653692ad7caSAdrian Chadd wpi_del_node(sc, ni); 1654eca2eb39SAdrian Chadd } 16557964dd56SAdrian Chadd WPI_NT_UNLOCK(sc); 1656692ad7caSAdrian Chadd } 1657692ad7caSAdrian Chadd 1658692ad7caSAdrian Chadd sc->sc_node_free(ni); 1659692ad7caSAdrian Chadd } 1660692ad7caSAdrian Chadd 1661621f1a75SAdrian Chadd static __inline int 1662621f1a75SAdrian Chadd wpi_check_bss_filter(struct wpi_softc *sc) 1663621f1a75SAdrian Chadd { 1664621f1a75SAdrian Chadd return (sc->rxon.filter & htole32(WPI_FILTER_BSS)) != 0; 1665621f1a75SAdrian Chadd } 1666621f1a75SAdrian Chadd 16676607310bSBenjamin Close /** 16686607310bSBenjamin Close * Called by net80211 when ever there is a change to 80211 state machine 16696607310bSBenjamin Close */ 16706607310bSBenjamin Close static int 1671b032f27cSSam Leffler wpi_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 16726607310bSBenjamin Close { 1673b032f27cSSam Leffler struct wpi_vap *wvp = WPI_VAP(vap); 1674b032f27cSSam Leffler struct ieee80211com *ic = vap->iv_ic; 16756607310bSBenjamin Close struct ifnet *ifp = ic->ic_ifp; 16766607310bSBenjamin Close struct wpi_softc *sc = ifp->if_softc; 1677692ad7caSAdrian Chadd int error = 0; 16786607310bSBenjamin Close 1679692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1680692ad7caSAdrian Chadd 1681692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, "%s: %s -> %s\n", __func__, 1682b032f27cSSam Leffler ieee80211_state_name[vap->iv_state], 1683692ad7caSAdrian Chadd ieee80211_state_name[nstate]); 16846607310bSBenjamin Close 16853289bbc9SAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN && nstate < IEEE80211_S_RUN) { 16862e79e293SAdrian Chadd if ((error = wpi_set_pslevel(sc, 0, 0, 1)) != 0) { 16872e79e293SAdrian Chadd device_printf(sc->sc_dev, 16882e79e293SAdrian Chadd "%s: could not set power saving level\n", 16892e79e293SAdrian Chadd __func__); 16902e79e293SAdrian Chadd return error; 16912e79e293SAdrian Chadd } 16923289bbc9SAdrian Chadd 16933289bbc9SAdrian Chadd wpi_set_led(sc, WPI_LED_LINK, 1, 0); 16942e79e293SAdrian Chadd } 16952e79e293SAdrian Chadd 1696692ad7caSAdrian Chadd switch (nstate) { 1697692ad7caSAdrian Chadd case IEEE80211_S_SCAN: 1698446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 1699a4703831SAdrian Chadd if (wpi_check_bss_filter(sc) != 0) { 1700692ad7caSAdrian Chadd sc->rxon.filter &= ~htole32(WPI_FILTER_BSS); 1701692ad7caSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { 17023934c8a5SBernhard Schmidt device_printf(sc->sc_dev, 1703692ad7caSAdrian Chadd "%s: could not send RXON\n", __func__); 17043934c8a5SBernhard Schmidt } 17053934c8a5SBernhard Schmidt } 1706446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 1707692ad7caSAdrian Chadd break; 1708692ad7caSAdrian Chadd 1709692ad7caSAdrian Chadd case IEEE80211_S_ASSOC: 1710692ad7caSAdrian Chadd if (vap->iv_state != IEEE80211_S_RUN) 1711692ad7caSAdrian Chadd break; 1712692ad7caSAdrian Chadd /* FALLTHROUGH */ 1713692ad7caSAdrian Chadd case IEEE80211_S_AUTH: 17143934c8a5SBernhard Schmidt /* 171589023da2SAdrian Chadd * NB: do not optimize AUTH -> AUTH state transmission - 171689023da2SAdrian Chadd * this will break powersave with non-QoS AP! 171789023da2SAdrian Chadd */ 171889023da2SAdrian Chadd 171989023da2SAdrian Chadd /* 17203934c8a5SBernhard Schmidt * The node must be registered in the firmware before auth. 17213934c8a5SBernhard Schmidt * Also the associd must be cleared on RUN -> ASSOC 17223934c8a5SBernhard Schmidt * transitions. 17233934c8a5SBernhard Schmidt */ 1724692ad7caSAdrian Chadd if ((error = wpi_auth(sc, vap)) != 0) { 17255efea30fSAndrew Thompson device_printf(sc->sc_dev, 1726692ad7caSAdrian Chadd "%s: could not move to AUTH state, error %d\n", 17275efea30fSAndrew Thompson __func__, error); 17285efea30fSAndrew Thompson } 1729692ad7caSAdrian Chadd break; 1730692ad7caSAdrian Chadd 1731692ad7caSAdrian Chadd case IEEE80211_S_RUN: 1732692ad7caSAdrian Chadd /* 1733692ad7caSAdrian Chadd * RUN -> RUN transition; Just restart the timers. 1734692ad7caSAdrian Chadd */ 1735692ad7caSAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN) { 1736446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 1737b032f27cSSam Leffler wpi_calib_timeout(sc); 1738446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 1739692ad7caSAdrian Chadd break; 1740692ad7caSAdrian Chadd } 1741692ad7caSAdrian Chadd 1742692ad7caSAdrian Chadd /* 1743692ad7caSAdrian Chadd * !RUN -> RUN requires setting the association id 1744692ad7caSAdrian Chadd * which is done with a firmware cmd. We also defer 1745692ad7caSAdrian Chadd * starting the timers until that work is done. 1746692ad7caSAdrian Chadd */ 1747692ad7caSAdrian Chadd if ((error = wpi_run(sc, vap)) != 0) { 1748692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1749692ad7caSAdrian Chadd "%s: could not move to RUN state\n", __func__); 1750692ad7caSAdrian Chadd } 1751692ad7caSAdrian Chadd break; 1752692ad7caSAdrian Chadd 1753692ad7caSAdrian Chadd default: 1754692ad7caSAdrian Chadd break; 1755b032f27cSSam Leffler } 1756692ad7caSAdrian Chadd if (error != 0) { 1757692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1758692ad7caSAdrian Chadd return error; 1759692ad7caSAdrian Chadd } 1760692ad7caSAdrian Chadd 1761692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1762692ad7caSAdrian Chadd 1763d036bb20SAdrian Chadd return wvp->wv_newstate(vap, nstate, arg); 17646607310bSBenjamin Close } 17656607310bSBenjamin Close 17666607310bSBenjamin Close static void 1767692ad7caSAdrian Chadd wpi_calib_timeout(void *arg) 17686607310bSBenjamin Close { 1769692ad7caSAdrian Chadd struct wpi_softc *sc = arg; 17706607310bSBenjamin Close 1771621f1a75SAdrian Chadd if (wpi_check_bss_filter(sc) == 0) 1772692ad7caSAdrian Chadd return; 17736607310bSBenjamin Close 1774692ad7caSAdrian Chadd wpi_power_calibration(sc); 1775692ad7caSAdrian Chadd 1776692ad7caSAdrian Chadd callout_reset(&sc->calib_to, 60*hz, wpi_calib_timeout, sc); 17776607310bSBenjamin Close } 17786607310bSBenjamin Close 1779692ad7caSAdrian Chadd static __inline uint8_t 1780692ad7caSAdrian Chadd rate2plcp(const uint8_t rate) 17816607310bSBenjamin Close { 1782692ad7caSAdrian Chadd switch (rate) { 1783692ad7caSAdrian Chadd case 12: return 0xd; 1784692ad7caSAdrian Chadd case 18: return 0xf; 1785692ad7caSAdrian Chadd case 24: return 0x5; 1786692ad7caSAdrian Chadd case 36: return 0x7; 1787692ad7caSAdrian Chadd case 48: return 0x9; 1788692ad7caSAdrian Chadd case 72: return 0xb; 1789692ad7caSAdrian Chadd case 96: return 0x1; 1790692ad7caSAdrian Chadd case 108: return 0x3; 1791692ad7caSAdrian Chadd case 2: return 10; 1792692ad7caSAdrian Chadd case 4: return 20; 1793692ad7caSAdrian Chadd case 11: return 55; 1794692ad7caSAdrian Chadd case 22: return 110; 1795692ad7caSAdrian Chadd default: return 0; 1796692ad7caSAdrian Chadd } 17976607310bSBenjamin Close } 17986607310bSBenjamin Close 1799692ad7caSAdrian Chadd static __inline uint8_t 1800692ad7caSAdrian Chadd plcp2rate(const uint8_t plcp) 18016607310bSBenjamin Close { 1802692ad7caSAdrian Chadd switch (plcp) { 1803692ad7caSAdrian Chadd case 0xd: return 12; 1804692ad7caSAdrian Chadd case 0xf: return 18; 1805692ad7caSAdrian Chadd case 0x5: return 24; 1806692ad7caSAdrian Chadd case 0x7: return 36; 1807692ad7caSAdrian Chadd case 0x9: return 48; 1808692ad7caSAdrian Chadd case 0xb: return 72; 1809692ad7caSAdrian Chadd case 0x1: return 96; 1810692ad7caSAdrian Chadd case 0x3: return 108; 1811692ad7caSAdrian Chadd case 10: return 2; 1812692ad7caSAdrian Chadd case 20: return 4; 1813692ad7caSAdrian Chadd case 55: return 11; 1814692ad7caSAdrian Chadd case 110: return 22; 1815692ad7caSAdrian Chadd default: return 0; 18166607310bSBenjamin Close } 1817692ad7caSAdrian Chadd } 1818692ad7caSAdrian Chadd 1819692ad7caSAdrian Chadd /* Quickly determine if a given rate is CCK or OFDM. */ 1820692ad7caSAdrian Chadd #define WPI_RATE_IS_OFDM(rate) ((rate) >= 12 && (rate) != 22) 18216607310bSBenjamin Close 18226607310bSBenjamin Close static void 1823692ad7caSAdrian Chadd wpi_rx_done(struct wpi_softc *sc, struct wpi_rx_desc *desc, 18246607310bSBenjamin Close struct wpi_rx_data *data) 18256607310bSBenjamin Close { 1826b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 1827b032f27cSSam Leffler struct ieee80211com *ic = ifp->if_l2com; 18286607310bSBenjamin Close struct wpi_rx_ring *ring = &sc->rxq; 18296607310bSBenjamin Close struct wpi_rx_stat *stat; 18306607310bSBenjamin Close struct wpi_rx_head *head; 18316607310bSBenjamin Close struct wpi_rx_tail *tail; 1832692ad7caSAdrian Chadd struct ieee80211_frame *wh; 18336607310bSBenjamin Close struct ieee80211_node *ni; 1834692ad7caSAdrian Chadd struct mbuf *m, *m1; 183582f1b132SAndrew Thompson bus_addr_t paddr; 1836692ad7caSAdrian Chadd uint32_t flags; 1837692ad7caSAdrian Chadd uint16_t len; 183882f1b132SAndrew Thompson int error; 18396607310bSBenjamin Close 18406607310bSBenjamin Close stat = (struct wpi_rx_stat *)(desc + 1); 18416607310bSBenjamin Close 18426607310bSBenjamin Close if (stat->len > WPI_STAT_MAXLEN) { 1843692ad7caSAdrian Chadd device_printf(sc->sc_dev, "invalid RX statistic header\n"); 1844fae61c69SAdrian Chadd goto fail1; 18456607310bSBenjamin Close } 18466607310bSBenjamin Close 1847a71ad787SBernhard Schmidt bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_POSTREAD); 18486607310bSBenjamin Close head = (struct wpi_rx_head *)((caddr_t)(stat + 1) + stat->len); 1849692ad7caSAdrian Chadd len = le16toh(head->len); 1850692ad7caSAdrian Chadd tail = (struct wpi_rx_tail *)((caddr_t)(head + 1) + len); 1851692ad7caSAdrian Chadd flags = le32toh(tail->flags); 18526607310bSBenjamin Close 1853692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RECV, "%s: idx %d len %d stat len %u rssi %d" 1854692ad7caSAdrian Chadd " rate %x chan %d tstamp %ju\n", __func__, ring->cur, 1855692ad7caSAdrian Chadd le32toh(desc->len), len, (int8_t)stat->rssi, 1856692ad7caSAdrian Chadd head->plcp, head->chan, (uintmax_t)le64toh(tail->tstamp)); 18576607310bSBenjamin Close 1858692ad7caSAdrian Chadd /* Discard frames with a bad FCS early. */ 1859692ad7caSAdrian Chadd if ((flags & WPI_RX_NOERROR) != WPI_RX_NOERROR) { 1860692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RECV, "%s: RX flags error %x\n", 1861692ad7caSAdrian Chadd __func__, flags); 1862fae61c69SAdrian Chadd goto fail1; 1863fcec677dSJuli Mallett } 1864692ad7caSAdrian Chadd /* Discard frames that are too short. */ 1865692ad7caSAdrian Chadd if (len < sizeof (*wh)) { 1866692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RECV, "%s: frame too short: %d\n", 1867692ad7caSAdrian Chadd __func__, len); 1868fae61c69SAdrian Chadd goto fail1; 1869fcec677dSJuli Mallett } 1870fcec677dSJuli Mallett 1871692ad7caSAdrian Chadd m1 = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); 1872692ad7caSAdrian Chadd if (m1 == NULL) { 1873692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_ANY, "%s: no mbuf to restock ring\n", 1874692ad7caSAdrian Chadd __func__); 1875fae61c69SAdrian Chadd goto fail1; 187682f1b132SAndrew Thompson } 1877a71ad787SBernhard Schmidt bus_dmamap_unload(ring->data_dmat, data->map); 1878a71ad787SBernhard Schmidt 1879692ad7caSAdrian Chadd error = bus_dmamap_load(ring->data_dmat, data->map, mtod(m1, void *), 1880692ad7caSAdrian Chadd MJUMPAGESIZE, wpi_dma_map_addr, &paddr, BUS_DMA_NOWAIT); 188182f1b132SAndrew Thompson if (error != 0 && error != EFBIG) { 188282f1b132SAndrew Thompson device_printf(sc->sc_dev, 188382f1b132SAndrew Thompson "%s: bus_dmamap_load failed, error %d\n", __func__, error); 1884692ad7caSAdrian Chadd m_freem(m1); 1885692ad7caSAdrian Chadd 1886692ad7caSAdrian Chadd /* Try to reload the old mbuf. */ 1887692ad7caSAdrian Chadd error = bus_dmamap_load(ring->data_dmat, data->map, 1888692ad7caSAdrian Chadd mtod(data->m, void *), MJUMPAGESIZE, wpi_dma_map_addr, 1889692ad7caSAdrian Chadd &paddr, BUS_DMA_NOWAIT); 1890692ad7caSAdrian Chadd if (error != 0 && error != EFBIG) { 1891692ad7caSAdrian Chadd panic("%s: could not load old RX mbuf", __func__); 1892692ad7caSAdrian Chadd } 1893692ad7caSAdrian Chadd /* Physical address may have changed. */ 1894692ad7caSAdrian Chadd ring->desc[ring->cur] = htole32(paddr); 1895692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, ring->desc_dma.map, 1896692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1897fae61c69SAdrian Chadd goto fail1; 189882f1b132SAndrew Thompson } 18996607310bSBenjamin Close 190082f1b132SAndrew Thompson m = data->m; 1901692ad7caSAdrian Chadd data->m = m1; 1902692ad7caSAdrian Chadd /* Update RX descriptor. */ 1903692ad7caSAdrian Chadd ring->desc[ring->cur] = htole32(paddr); 1904692ad7caSAdrian Chadd bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 1905692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1906692ad7caSAdrian Chadd 1907692ad7caSAdrian Chadd /* Finalize mbuf. */ 19086607310bSBenjamin Close m->m_pkthdr.rcvif = ifp; 19096607310bSBenjamin Close m->m_data = (caddr_t)(head + 1); 1910692ad7caSAdrian Chadd m->m_pkthdr.len = m->m_len = len; 19116607310bSBenjamin Close 1912692ad7caSAdrian Chadd /* Grab a reference to the source node. */ 1913692ad7caSAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 1914692ad7caSAdrian Chadd 1915692ad7caSAdrian Chadd if ((wh->i_fc[1] & IEEE80211_FC1_PROTECTED) && 1916d29fcfb7SAdrian Chadd (flags & WPI_RX_CIPHER_MASK) == WPI_RX_CIPHER_CCMP) { 1917692ad7caSAdrian Chadd /* Check whether decryption was successful or not. */ 1918692ad7caSAdrian Chadd if ((flags & WPI_RX_DECRYPT_MASK) != WPI_RX_DECRYPT_OK) { 1919692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RECV, 1920692ad7caSAdrian Chadd "CCMP decryption failed 0x%x\n", flags); 1921fae61c69SAdrian Chadd goto fail2; 1922692ad7caSAdrian Chadd } 1923692ad7caSAdrian Chadd m->m_flags |= M_WEP; 1924692ad7caSAdrian Chadd } 19256607310bSBenjamin Close 1926d29fcfb7SAdrian Chadd ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh); 1927d29fcfb7SAdrian Chadd 19285463c4a4SSam Leffler if (ieee80211_radiotap_active(ic)) { 19296607310bSBenjamin Close struct wpi_rx_radiotap_header *tap = &sc->sc_rxtap; 19306607310bSBenjamin Close 19316607310bSBenjamin Close tap->wr_flags = 0; 1932692ad7caSAdrian Chadd if (head->flags & htole16(WPI_STAT_FLAG_SHPREAMBLE)) 1933692ad7caSAdrian Chadd tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTPRE; 19348e4cf38aSAdrian Chadd tap->wr_dbm_antsignal = (int8_t)(stat->rssi + WPI_RSSI_OFFSET); 19350b455e8fSAdrian Chadd tap->wr_dbm_antnoise = WPI_RSSI_OFFSET; 19366607310bSBenjamin Close tap->wr_tsft = tail->tstamp; 19376607310bSBenjamin Close tap->wr_antenna = (le16toh(head->flags) >> 4) & 0xf; 1938692ad7caSAdrian Chadd tap->wr_rate = plcp2rate(head->plcp); 19396607310bSBenjamin Close } 19406607310bSBenjamin Close 19416607310bSBenjamin Close WPI_UNLOCK(sc); 19426607310bSBenjamin Close 1943692ad7caSAdrian Chadd /* Send the frame to the 802.11 layer. */ 1944b032f27cSSam Leffler if (ni != NULL) { 19458e4cf38aSAdrian Chadd (void)ieee80211_input(ni, m, stat->rssi, WPI_RSSI_OFFSET); 1946692ad7caSAdrian Chadd /* Node is no longer needed. */ 19476607310bSBenjamin Close ieee80211_free_node(ni); 1948b032f27cSSam Leffler } else 19498e4cf38aSAdrian Chadd (void)ieee80211_input_all(ic, m, stat->rssi, WPI_RSSI_OFFSET); 1950b032f27cSSam Leffler 19516607310bSBenjamin Close WPI_LOCK(sc); 1952fae61c69SAdrian Chadd 1953fae61c69SAdrian Chadd return; 1954fae61c69SAdrian Chadd 1955d29fcfb7SAdrian Chadd fail2: m_freem(m); 1956fae61c69SAdrian Chadd 1957fae61c69SAdrian Chadd fail1: if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 19586607310bSBenjamin Close } 19596607310bSBenjamin Close 19606607310bSBenjamin Close static void 1961692ad7caSAdrian Chadd wpi_rx_statistics(struct wpi_softc *sc, struct wpi_rx_desc *desc, 1962692ad7caSAdrian Chadd struct wpi_rx_data *data) 19636607310bSBenjamin Close { 1964692ad7caSAdrian Chadd /* Ignore */ 19656607310bSBenjamin Close } 19666607310bSBenjamin Close 19676607310bSBenjamin Close static void 1968692ad7caSAdrian Chadd wpi_tx_done(struct wpi_softc *sc, struct wpi_rx_desc *desc) 19696607310bSBenjamin Close { 1970692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 1971692ad7caSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[desc->qid & 0x3]; 1972692ad7caSAdrian Chadd struct wpi_tx_data *data = &ring->data[desc->idx]; 1973692ad7caSAdrian Chadd struct wpi_tx_stat *stat = (struct wpi_tx_stat *)(desc + 1); 1974692ad7caSAdrian Chadd struct mbuf *m; 1975692ad7caSAdrian Chadd struct ieee80211_node *ni; 1976692ad7caSAdrian Chadd struct ieee80211vap *vap; 19774eaf2ee3SAdrian Chadd struct ieee80211com *ic; 1978b52207dbSAdrian Chadd uint32_t status = le32toh(stat->status); 197930b60481SAdrian Chadd int ackfailcnt = stat->ackfailcnt / WPI_NTRIES_DEFAULT; 1980692ad7caSAdrian Chadd 1981692ad7caSAdrian Chadd KASSERT(data->ni != NULL, ("no node")); 198239060fa9SAdrian Chadd KASSERT(data->m != NULL, ("no mbuf")); 1983692ad7caSAdrian Chadd 1984692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1985692ad7caSAdrian Chadd 1986692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_XMIT, "%s: " 1987692ad7caSAdrian Chadd "qid %d idx %d retries %d btkillcnt %d rate %x duration %d " 198830b60481SAdrian Chadd "status %x\n", __func__, desc->qid, desc->idx, stat->ackfailcnt, 1989692ad7caSAdrian Chadd stat->btkillcnt, stat->rate, le32toh(stat->duration), status); 1990692ad7caSAdrian Chadd 1991692ad7caSAdrian Chadd /* Unmap and free mbuf. */ 1992692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_POSTWRITE); 1993692ad7caSAdrian Chadd bus_dmamap_unload(ring->data_dmat, data->map); 1994692ad7caSAdrian Chadd m = data->m, data->m = NULL; 1995692ad7caSAdrian Chadd ni = data->ni, data->ni = NULL; 1996692ad7caSAdrian Chadd vap = ni->ni_vap; 19974eaf2ee3SAdrian Chadd ic = vap->iv_ic; 1998692ad7caSAdrian Chadd 1999692ad7caSAdrian Chadd /* 2000692ad7caSAdrian Chadd * Update rate control statistics for the node. 2001692ad7caSAdrian Chadd */ 20023d9089a6SAdrian Chadd if (status & WPI_TX_STATUS_FAIL) { 2003692ad7caSAdrian Chadd if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 2004692ad7caSAdrian Chadd ieee80211_ratectl_tx_complete(vap, ni, 2005fae61c69SAdrian Chadd IEEE80211_RATECTL_TX_FAILURE, &ackfailcnt, NULL); 2006692ad7caSAdrian Chadd } else { 2007692ad7caSAdrian Chadd if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); 2008692ad7caSAdrian Chadd ieee80211_ratectl_tx_complete(vap, ni, 2009fae61c69SAdrian Chadd IEEE80211_RATECTL_TX_SUCCESS, &ackfailcnt, NULL); 2010692ad7caSAdrian Chadd } 2011692ad7caSAdrian Chadd 20123d9089a6SAdrian Chadd ieee80211_tx_complete(ni, m, (status & WPI_TX_STATUS_FAIL) != 0); 2013692ad7caSAdrian Chadd 2014fc5870b4SAdrian Chadd WPI_TXQ_STATE_LOCK(sc); 2015d74e544aSAdrian Chadd ring->queued -= 1; 2016a6b6ca52SAdrian Chadd if (ring->queued > 0) { 2017d74e544aSAdrian Chadd callout_reset(&sc->tx_timeout, 5*hz, wpi_tx_timeout, sc); 2018d74e544aSAdrian Chadd 2019a6b6ca52SAdrian Chadd if (sc->qfullmsk != 0 && 2020a6b6ca52SAdrian Chadd ring->queued < WPI_TX_RING_LOMARK) { 2021692ad7caSAdrian Chadd sc->qfullmsk &= ~(1 << ring->qid); 2022b9858d86SAdrian Chadd IF_LOCK(&ifp->if_snd); 2023692ad7caSAdrian Chadd if (sc->qfullmsk == 0 && 2024692ad7caSAdrian Chadd (ifp->if_drv_flags & IFF_DRV_OACTIVE)) { 2025692ad7caSAdrian Chadd ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 2026b9858d86SAdrian Chadd IF_UNLOCK(&ifp->if_snd); 20274eaf2ee3SAdrian Chadd ieee80211_runtask(ic, &sc->sc_start_task); 2028b9858d86SAdrian Chadd } else 2029b9858d86SAdrian Chadd IF_UNLOCK(&ifp->if_snd); 2030692ad7caSAdrian Chadd } 2031a6b6ca52SAdrian Chadd } else 2032a6b6ca52SAdrian Chadd callout_stop(&sc->tx_timeout); 2033fc5870b4SAdrian Chadd WPI_TXQ_STATE_UNLOCK(sc); 2034692ad7caSAdrian Chadd 2035692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 2036692ad7caSAdrian Chadd } 2037692ad7caSAdrian Chadd 2038692ad7caSAdrian Chadd /* 2039692ad7caSAdrian Chadd * Process a "command done" firmware notification. This is where we wakeup 2040692ad7caSAdrian Chadd * processes waiting for a synchronous command completion. 2041692ad7caSAdrian Chadd */ 2042692ad7caSAdrian Chadd static void 2043692ad7caSAdrian Chadd wpi_cmd_done(struct wpi_softc *sc, struct wpi_rx_desc *desc) 2044692ad7caSAdrian Chadd { 20458e4cf38aSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[WPI_CMD_QUEUE_NUM]; 20466607310bSBenjamin Close struct wpi_tx_data *data; 20476607310bSBenjamin Close 2048cec45f04SAdrian Chadd DPRINTF(sc, WPI_DEBUG_CMD, "cmd notification qid %x idx %d flags %x " 2049cec45f04SAdrian Chadd "type %s len %d\n", desc->qid, desc->idx, 20506607310bSBenjamin Close desc->flags, wpi_cmd_str(desc->type), 2051692ad7caSAdrian Chadd le32toh(desc->len)); 20526607310bSBenjamin Close 20538e4cf38aSAdrian Chadd if ((desc->qid & WPI_RX_DESC_QID_MSK) != WPI_CMD_QUEUE_NUM) 2054692ad7caSAdrian Chadd return; /* Not a command ack. */ 20556607310bSBenjamin Close 205645ac43f3SAdrian Chadd KASSERT(ring->queued == 0, ("ring->queued must be 0")); 205745ac43f3SAdrian Chadd 20586607310bSBenjamin Close data = &ring->data[desc->idx]; 20596607310bSBenjamin Close 2060692ad7caSAdrian Chadd /* If the command was mapped in an mbuf, free it. */ 20616607310bSBenjamin Close if (data->m != NULL) { 2062692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 2063692ad7caSAdrian Chadd BUS_DMASYNC_POSTWRITE); 20646607310bSBenjamin Close bus_dmamap_unload(ring->data_dmat, data->map); 20656607310bSBenjamin Close m_freem(data->m); 20666607310bSBenjamin Close data->m = NULL; 20676607310bSBenjamin Close } 20686607310bSBenjamin Close 20696607310bSBenjamin Close wakeup(&ring->cmd[desc->idx]); 20706607310bSBenjamin Close } 20716607310bSBenjamin Close 20726607310bSBenjamin Close static void 20736607310bSBenjamin Close wpi_notif_intr(struct wpi_softc *sc) 20746607310bSBenjamin Close { 2075b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 2076b032f27cSSam Leffler struct ieee80211com *ic = ifp->if_l2com; 2077692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 2078b52207dbSAdrian Chadd uint32_t hw; 20796607310bSBenjamin Close 2080f015cb78SBernhard Schmidt bus_dmamap_sync(sc->shared_dma.tag, sc->shared_dma.map, 2081f015cb78SBernhard Schmidt BUS_DMASYNC_POSTREAD); 2082f015cb78SBernhard Schmidt 20836607310bSBenjamin Close hw = le32toh(sc->shared->next); 2084692ad7caSAdrian Chadd hw = (hw == 0) ? WPI_RX_RING_COUNT - 1 : hw - 1; 2085692ad7caSAdrian Chadd 2086fae61c69SAdrian Chadd while (sc->rxq.cur != hw) { 2087692ad7caSAdrian Chadd sc->rxq.cur = (sc->rxq.cur + 1) % WPI_RX_RING_COUNT; 2088692ad7caSAdrian Chadd 2089692ad7caSAdrian Chadd struct wpi_rx_data *data = &sc->rxq.data[sc->rxq.cur]; 2090692ad7caSAdrian Chadd struct wpi_rx_desc *desc; 2091f015cb78SBernhard Schmidt 2092f015cb78SBernhard Schmidt bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2093f015cb78SBernhard Schmidt BUS_DMASYNC_POSTREAD); 2094692ad7caSAdrian Chadd desc = mtod(data->m, struct wpi_rx_desc *); 20956607310bSBenjamin Close 2096692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_NOTIFY, 2097692ad7caSAdrian Chadd "%s: cur=%d; qid %x idx %d flags %x type %d(%s) len %d\n", 2098692ad7caSAdrian Chadd __func__, sc->rxq.cur, desc->qid, desc->idx, desc->flags, 2099692ad7caSAdrian Chadd desc->type, wpi_cmd_str(desc->type), le32toh(desc->len)); 21006607310bSBenjamin Close 21018e4cf38aSAdrian Chadd if (!(desc->qid & WPI_UNSOLICITED_RX_NOTIF)) { 21028e4cf38aSAdrian Chadd /* Reply to a command. */ 2103692ad7caSAdrian Chadd wpi_cmd_done(sc, desc); 21048e4cf38aSAdrian Chadd } 21056607310bSBenjamin Close 21066607310bSBenjamin Close switch (desc->type) { 21076607310bSBenjamin Close case WPI_RX_DONE: 2108692ad7caSAdrian Chadd /* An 802.11 frame has been received. */ 2109692ad7caSAdrian Chadd wpi_rx_done(sc, desc, data); 211071258eb2SAdrian Chadd 211171258eb2SAdrian Chadd if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) { 211271258eb2SAdrian Chadd /* wpi_stop() was called. */ 211371258eb2SAdrian Chadd return; 211471258eb2SAdrian Chadd } 211571258eb2SAdrian Chadd 21166607310bSBenjamin Close break; 21176607310bSBenjamin Close 21186607310bSBenjamin Close case WPI_TX_DONE: 2119692ad7caSAdrian Chadd /* An 802.11 frame has been transmitted. */ 2120692ad7caSAdrian Chadd wpi_tx_done(sc, desc); 21216607310bSBenjamin Close break; 21226607310bSBenjamin Close 2123692ad7caSAdrian Chadd case WPI_RX_STATISTICS: 2124692ad7caSAdrian Chadd case WPI_BEACON_STATISTICS: 2125692ad7caSAdrian Chadd wpi_rx_statistics(sc, desc, data); 2126692ad7caSAdrian Chadd break; 2127692ad7caSAdrian Chadd 2128692ad7caSAdrian Chadd case WPI_BEACON_MISSED: 2129692ad7caSAdrian Chadd { 2130692ad7caSAdrian Chadd struct wpi_beacon_missed *miss = 2131692ad7caSAdrian Chadd (struct wpi_beacon_missed *)(desc + 1); 21325c015919SAdrian Chadd uint32_t expected, misses, received, threshold; 2133692ad7caSAdrian Chadd 2134692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2135692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 2136b4324a50SAdrian Chadd 2137692ad7caSAdrian Chadd misses = le32toh(miss->consecutive); 2138b4324a50SAdrian Chadd expected = le32toh(miss->expected); 2139b4324a50SAdrian Chadd received = le32toh(miss->received); 21405c015919SAdrian Chadd threshold = MAX(2, vap->iv_bmissthreshold); 2141692ad7caSAdrian Chadd 21423e54d9fdSAdrian Chadd DPRINTF(sc, WPI_DEBUG_BMISS, 2143cf990903SAdrian Chadd "%s: beacons missed %u(%u) (received %u/%u)\n", 2144cf990903SAdrian Chadd __func__, misses, le32toh(miss->total), received, 2145cf990903SAdrian Chadd expected); 2146692ad7caSAdrian Chadd 21476f506674SAdrian Chadd if (misses >= threshold || 21486f506674SAdrian Chadd (received == 0 && expected >= threshold)) { 21496f506674SAdrian Chadd WPI_RXON_LOCK(sc); 21506f506674SAdrian Chadd if (callout_pending(&sc->scan_timeout)) { 21516f506674SAdrian Chadd wpi_cmd(sc, WPI_CMD_SCAN_ABORT, NULL, 21526f506674SAdrian Chadd 0, 1); 21536f506674SAdrian Chadd } 21546f506674SAdrian Chadd WPI_RXON_UNLOCK(sc); 2155692ad7caSAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN && 21566f506674SAdrian Chadd (ic->ic_flags & IEEE80211_F_SCAN) == 0) 2157692ad7caSAdrian Chadd ieee80211_beacon_miss(ic); 21586f506674SAdrian Chadd } 2159fd06b537SAdrian Chadd 2160692ad7caSAdrian Chadd break; 2161692ad7caSAdrian Chadd } 21626ddc7d4dSAdrian Chadd #ifdef WPI_DEBUG 21636ddc7d4dSAdrian Chadd case WPI_BEACON_SENT: 21646ddc7d4dSAdrian Chadd { 21656ddc7d4dSAdrian Chadd struct wpi_tx_stat *stat = 21666ddc7d4dSAdrian Chadd (struct wpi_tx_stat *)(desc + 1); 21676ddc7d4dSAdrian Chadd uint64_t *tsf = (uint64_t *)(stat + 1); 21686ddc7d4dSAdrian Chadd uint32_t *mode = (uint32_t *)(tsf + 1); 21696ddc7d4dSAdrian Chadd 21706ddc7d4dSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 21716ddc7d4dSAdrian Chadd BUS_DMASYNC_POSTREAD); 21726ddc7d4dSAdrian Chadd 21736ddc7d4dSAdrian Chadd DPRINTF(sc, WPI_DEBUG_BEACON, 21746ddc7d4dSAdrian Chadd "beacon sent: rts %u, ack %u, btkill %u, rate %u, " 21756ddc7d4dSAdrian Chadd "duration %u, status %x, tsf %ju, mode %x\n", 21766ddc7d4dSAdrian Chadd stat->rtsfailcnt, stat->ackfailcnt, 21776ddc7d4dSAdrian Chadd stat->btkillcnt, stat->rate, le32toh(stat->duration), 21786ddc7d4dSAdrian Chadd le32toh(stat->status), *tsf, *mode); 21796ddc7d4dSAdrian Chadd 21806ddc7d4dSAdrian Chadd break; 21816ddc7d4dSAdrian Chadd } 21826ddc7d4dSAdrian Chadd #endif 21836607310bSBenjamin Close case WPI_UC_READY: 21846607310bSBenjamin Close { 21856607310bSBenjamin Close struct wpi_ucode_info *uc = 21866607310bSBenjamin Close (struct wpi_ucode_info *)(desc + 1); 21876607310bSBenjamin Close 2188692ad7caSAdrian Chadd /* The microcontroller is ready. */ 2189692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2190692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 2191692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RESET, 2192692ad7caSAdrian Chadd "microcode alive notification version=%d.%d " 2193692ad7caSAdrian Chadd "subtype=%x alive=%x\n", uc->major, uc->minor, 2194692ad7caSAdrian Chadd uc->subtype, le32toh(uc->valid)); 21956607310bSBenjamin Close 21966607310bSBenjamin Close if (le32toh(uc->valid) != 1) { 21976607310bSBenjamin Close device_printf(sc->sc_dev, 21986607310bSBenjamin Close "microcontroller initialization failed\n"); 21996607310bSBenjamin Close wpi_stop_locked(sc); 22006607310bSBenjamin Close } 2201692ad7caSAdrian Chadd /* Save the address of the error log in SRAM. */ 2202692ad7caSAdrian Chadd sc->errptr = le32toh(uc->errptr); 22036607310bSBenjamin Close break; 22046607310bSBenjamin Close } 22056607310bSBenjamin Close case WPI_STATE_CHANGED: 22066607310bSBenjamin Close { 2207692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2208692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 2209692ad7caSAdrian Chadd 22106607310bSBenjamin Close uint32_t *status = (uint32_t *)(desc + 1); 2211fae61c69SAdrian Chadd 2212692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, "state changed to %x\n", 2213692ad7caSAdrian Chadd le32toh(*status)); 2214fae61c69SAdrian Chadd 22156607310bSBenjamin Close if (le32toh(*status) & 1) { 22167964dd56SAdrian Chadd WPI_NT_LOCK(sc); 2217eca2eb39SAdrian Chadd wpi_clear_node_table(sc); 22187964dd56SAdrian Chadd WPI_NT_UNLOCK(sc); 2219b3cd88daSAdrian Chadd taskqueue_enqueue(sc->sc_tq, 2220b3cd88daSAdrian Chadd &sc->sc_radiooff_task); 2221692ad7caSAdrian Chadd return; 22226607310bSBenjamin Close } 22236607310bSBenjamin Close break; 22246607310bSBenjamin Close } 2225cbaa7080SAdrian Chadd #ifdef WPI_DEBUG 22266607310bSBenjamin Close case WPI_START_SCAN: 22276607310bSBenjamin Close { 2228692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2229692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 2230cbaa7080SAdrian Chadd 22316607310bSBenjamin Close struct wpi_start_scan *scan = 22326607310bSBenjamin Close (struct wpi_start_scan *)(desc + 1); 2233692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_SCAN, 2234692ad7caSAdrian Chadd "%s: scanning channel %d status %x\n", 2235692ad7caSAdrian Chadd __func__, scan->chan, le32toh(scan->status)); 2236cbaa7080SAdrian Chadd 22376607310bSBenjamin Close break; 22386607310bSBenjamin Close } 2239cbaa7080SAdrian Chadd #endif 22406607310bSBenjamin Close case WPI_STOP_SCAN: 22416607310bSBenjamin Close { 2242692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2243692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 22446f506674SAdrian Chadd 22456607310bSBenjamin Close struct wpi_stop_scan *scan = 22466607310bSBenjamin Close (struct wpi_stop_scan *)(desc + 1); 22476f506674SAdrian Chadd 2248692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_SCAN, 2249692ad7caSAdrian Chadd "scan finished nchan=%d status=%d chan=%d\n", 2250692ad7caSAdrian Chadd scan->nchan, scan->status, scan->chan); 22516f506674SAdrian Chadd 2252446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 22530bc39fc6SAdrian Chadd callout_stop(&sc->scan_timeout); 2254446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 22556f506674SAdrian Chadd if (scan->status == WPI_SCAN_ABORTED) 22566f506674SAdrian Chadd ieee80211_cancel_scan(vap); 22576f506674SAdrian Chadd else 2258b032f27cSSam Leffler ieee80211_scan_next(vap); 22596607310bSBenjamin Close break; 22606607310bSBenjamin Close } 2261692ad7caSAdrian Chadd } 2262692ad7caSAdrian Chadd 2263a5403e31SAdrian Chadd if (sc->rxq.cur % 8 == 0) { 2264692ad7caSAdrian Chadd /* Tell the firmware what we have processed. */ 2265692ad7caSAdrian Chadd wpi_update_rx_ring(sc); 2266692ad7caSAdrian Chadd } 2267a5403e31SAdrian Chadd } 2268a5403e31SAdrian Chadd } 2269692ad7caSAdrian Chadd 2270692ad7caSAdrian Chadd /* 2271692ad7caSAdrian Chadd * Process an INT_WAKEUP interrupt raised when the microcontroller wakes up 2272692ad7caSAdrian Chadd * from power-down sleep mode. 2273692ad7caSAdrian Chadd */ 2274692ad7caSAdrian Chadd static void 2275692ad7caSAdrian Chadd wpi_wakeup_intr(struct wpi_softc *sc) 2276a7099588SBenjamin Close { 2277692ad7caSAdrian Chadd int qid; 2278a7099588SBenjamin Close 2279692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_PWRSAVE, 2280692ad7caSAdrian Chadd "%s: ucode wakeup from power-down sleep\n", __func__); 2281692ad7caSAdrian Chadd 2282692ad7caSAdrian Chadd /* Wakeup RX and TX rings. */ 2283692ad7caSAdrian Chadd if (sc->rxq.update) { 2284692ad7caSAdrian Chadd sc->rxq.update = 0; 2285fae61c69SAdrian Chadd wpi_update_rx_ring(sc); 2286a7099588SBenjamin Close } 228763f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 2288ebf62e08SAdrian Chadd for (qid = 0; qid < WPI_DRV_NTXQUEUES; qid++) { 2289692ad7caSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[qid]; 2290692ad7caSAdrian Chadd 2291692ad7caSAdrian Chadd if (ring->update) { 2292692ad7caSAdrian Chadd ring->update = 0; 2293fae61c69SAdrian Chadd wpi_update_tx_ring(sc, ring); 2294a7099588SBenjamin Close } 22956607310bSBenjamin Close } 229663f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 22976607310bSBenjamin Close 2298692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 22996607310bSBenjamin Close } 23006607310bSBenjamin Close 2301692ad7caSAdrian Chadd /* 2302a6df6cfeSAdrian Chadd * This function prints firmware registers 2303a6df6cfeSAdrian Chadd */ 2304a6df6cfeSAdrian Chadd #ifdef WPI_DEBUG 2305a6df6cfeSAdrian Chadd static void 2306a6df6cfeSAdrian Chadd wpi_debug_registers(struct wpi_softc *sc) 2307a6df6cfeSAdrian Chadd { 2308a6df6cfeSAdrian Chadd int i; 2309a6df6cfeSAdrian Chadd static const uint32_t csr_tbl[] = { 2310a6df6cfeSAdrian Chadd WPI_HW_IF_CONFIG, 2311a6df6cfeSAdrian Chadd WPI_INT, 2312a6df6cfeSAdrian Chadd WPI_INT_MASK, 2313a6df6cfeSAdrian Chadd WPI_FH_INT, 2314a6df6cfeSAdrian Chadd WPI_GPIO_IN, 2315a6df6cfeSAdrian Chadd WPI_RESET, 2316a6df6cfeSAdrian Chadd WPI_GP_CNTRL, 2317a6df6cfeSAdrian Chadd WPI_EEPROM, 2318a6df6cfeSAdrian Chadd WPI_EEPROM_GP, 2319a6df6cfeSAdrian Chadd WPI_GIO, 2320a6df6cfeSAdrian Chadd WPI_UCODE_GP1, 2321a6df6cfeSAdrian Chadd WPI_UCODE_GP2, 2322a6df6cfeSAdrian Chadd WPI_GIO_CHICKEN, 2323a6df6cfeSAdrian Chadd WPI_ANA_PLL, 2324a6df6cfeSAdrian Chadd WPI_DBG_HPET_MEM, 2325a6df6cfeSAdrian Chadd }; 2326a6df6cfeSAdrian Chadd static const uint32_t prph_tbl[] = { 2327a6df6cfeSAdrian Chadd WPI_APMG_CLK_CTRL, 2328a6df6cfeSAdrian Chadd WPI_APMG_PS, 2329a6df6cfeSAdrian Chadd WPI_APMG_PCI_STT, 2330a6df6cfeSAdrian Chadd WPI_APMG_RFKILL, 2331a6df6cfeSAdrian Chadd }; 2332a6df6cfeSAdrian Chadd 2333a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER,"%s","\n"); 2334a6df6cfeSAdrian Chadd 233512e0ff3bSAdrian Chadd for (i = 0; i < nitems(csr_tbl); i++) { 2336a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, " %-18s: 0x%08x ", 2337a6df6cfeSAdrian Chadd wpi_get_csr_string(csr_tbl[i]), WPI_READ(sc, csr_tbl[i])); 2338a6df6cfeSAdrian Chadd 2339a6df6cfeSAdrian Chadd if ((i + 1) % 2 == 0) 2340a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, "\n"); 2341a6df6cfeSAdrian Chadd } 2342a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, "\n\n"); 2343a6df6cfeSAdrian Chadd 2344a6df6cfeSAdrian Chadd if (wpi_nic_lock(sc) == 0) { 234512e0ff3bSAdrian Chadd for (i = 0; i < nitems(prph_tbl); i++) { 2346a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, " %-18s: 0x%08x ", 2347a6df6cfeSAdrian Chadd wpi_get_prph_string(prph_tbl[i]), 2348a6df6cfeSAdrian Chadd wpi_prph_read(sc, prph_tbl[i])); 2349a6df6cfeSAdrian Chadd 2350a6df6cfeSAdrian Chadd if ((i + 1) % 2 == 0) 2351a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, "\n"); 2352a6df6cfeSAdrian Chadd } 2353a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, "\n"); 2354a6df6cfeSAdrian Chadd wpi_nic_unlock(sc); 2355a6df6cfeSAdrian Chadd } else { 2356a6df6cfeSAdrian Chadd DPRINTF(sc, WPI_DEBUG_REGISTER, 2357a6df6cfeSAdrian Chadd "Cannot access internal registers.\n"); 2358a6df6cfeSAdrian Chadd } 2359a6df6cfeSAdrian Chadd } 2360a6df6cfeSAdrian Chadd #endif 2361a6df6cfeSAdrian Chadd 2362a6df6cfeSAdrian Chadd /* 2363692ad7caSAdrian Chadd * Dump the error log of the firmware when a firmware panic occurs. Although 2364692ad7caSAdrian Chadd * we can't debug the firmware because it is neither open source nor free, it 2365692ad7caSAdrian Chadd * can help us to identify certain classes of problems. 2366692ad7caSAdrian Chadd */ 2367692ad7caSAdrian Chadd static void 2368692ad7caSAdrian Chadd wpi_fatal_intr(struct wpi_softc *sc) 2369692ad7caSAdrian Chadd { 2370692ad7caSAdrian Chadd struct wpi_fw_dump dump; 2371692ad7caSAdrian Chadd uint32_t i, offset, count; 2372692ad7caSAdrian Chadd 2373692ad7caSAdrian Chadd /* Check that the error log address is valid. */ 2374692ad7caSAdrian Chadd if (sc->errptr < WPI_FW_DATA_BASE || 2375692ad7caSAdrian Chadd sc->errptr + sizeof (dump) > 2376692ad7caSAdrian Chadd WPI_FW_DATA_BASE + WPI_FW_DATA_MAXSZ) { 2377692ad7caSAdrian Chadd printf("%s: bad firmware error log address 0x%08x\n", __func__, 2378692ad7caSAdrian Chadd sc->errptr); 2379692ad7caSAdrian Chadd return; 2380692ad7caSAdrian Chadd } 2381692ad7caSAdrian Chadd if (wpi_nic_lock(sc) != 0) { 2382692ad7caSAdrian Chadd printf("%s: could not read firmware error log\n", __func__); 2383692ad7caSAdrian Chadd return; 2384692ad7caSAdrian Chadd } 2385692ad7caSAdrian Chadd /* Read number of entries in the log. */ 2386692ad7caSAdrian Chadd count = wpi_mem_read(sc, sc->errptr); 2387692ad7caSAdrian Chadd if (count == 0 || count * sizeof (dump) > WPI_FW_DATA_MAXSZ) { 2388692ad7caSAdrian Chadd printf("%s: invalid count field (count = %u)\n", __func__, 2389692ad7caSAdrian Chadd count); 2390692ad7caSAdrian Chadd wpi_nic_unlock(sc); 2391692ad7caSAdrian Chadd return; 2392692ad7caSAdrian Chadd } 2393692ad7caSAdrian Chadd /* Skip "count" field. */ 2394692ad7caSAdrian Chadd offset = sc->errptr + sizeof (uint32_t); 2395692ad7caSAdrian Chadd printf("firmware error log (count = %u):\n", count); 2396692ad7caSAdrian Chadd for (i = 0; i < count; i++) { 2397692ad7caSAdrian Chadd wpi_mem_read_region_4(sc, offset, (uint32_t *)&dump, 2398692ad7caSAdrian Chadd sizeof (dump) / sizeof (uint32_t)); 2399692ad7caSAdrian Chadd 2400692ad7caSAdrian Chadd printf(" error type = \"%s\" (0x%08X)\n", 240112e0ff3bSAdrian Chadd (dump.desc < nitems(wpi_fw_errmsg)) ? 2402692ad7caSAdrian Chadd wpi_fw_errmsg[dump.desc] : "UNKNOWN", 2403692ad7caSAdrian Chadd dump.desc); 2404692ad7caSAdrian Chadd printf(" error data = 0x%08X\n", 2405692ad7caSAdrian Chadd dump.data); 2406692ad7caSAdrian Chadd printf(" branch link = 0x%08X%08X\n", 2407692ad7caSAdrian Chadd dump.blink[0], dump.blink[1]); 2408692ad7caSAdrian Chadd printf(" interrupt link = 0x%08X%08X\n", 2409692ad7caSAdrian Chadd dump.ilink[0], dump.ilink[1]); 2410692ad7caSAdrian Chadd printf(" time = %u\n", dump.time); 2411692ad7caSAdrian Chadd 2412692ad7caSAdrian Chadd offset += sizeof (dump); 2413692ad7caSAdrian Chadd } 2414692ad7caSAdrian Chadd wpi_nic_unlock(sc); 2415692ad7caSAdrian Chadd /* Dump driver status (TX and RX rings) while we're here. */ 2416692ad7caSAdrian Chadd printf("driver status:\n"); 241763f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 2418ebf62e08SAdrian Chadd for (i = 0; i < WPI_DRV_NTXQUEUES; i++) { 2419692ad7caSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[i]; 2420692ad7caSAdrian Chadd printf(" tx ring %2d: qid=%-2d cur=%-3d queued=%-3d\n", 2421692ad7caSAdrian Chadd i, ring->qid, ring->cur, ring->queued); 2422692ad7caSAdrian Chadd } 242363f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 2424692ad7caSAdrian Chadd printf(" rx ring: cur=%d\n", sc->rxq.cur); 24256607310bSBenjamin Close } 24266607310bSBenjamin Close 24276607310bSBenjamin Close static void 24286607310bSBenjamin Close wpi_intr(void *arg) 24296607310bSBenjamin Close { 24306607310bSBenjamin Close struct wpi_softc *sc = arg; 2431692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 2432692ad7caSAdrian Chadd uint32_t r1, r2; 24336607310bSBenjamin Close 24346607310bSBenjamin Close WPI_LOCK(sc); 24356607310bSBenjamin Close 2436692ad7caSAdrian Chadd /* Disable interrupts. */ 2437692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT_MASK, 0); 2438692ad7caSAdrian Chadd 2439692ad7caSAdrian Chadd r1 = WPI_READ(sc, WPI_INT); 2440692ad7caSAdrian Chadd 24417f1299c5SAdrian Chadd if (r1 == 0xffffffff || (r1 & 0xfffffff0) == 0xa5a5a5a0) 24427f1299c5SAdrian Chadd goto end; /* Hardware gone! */ 24436607310bSBenjamin Close 2444692ad7caSAdrian Chadd r2 = WPI_READ(sc, WPI_FH_INT); 24456607310bSBenjamin Close 2446692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_INTR, "%s: reg1=0x%08x reg2=0x%08x\n", __func__, 2447692ad7caSAdrian Chadd r1, r2); 2448692ad7caSAdrian Chadd 2449692ad7caSAdrian Chadd if (r1 == 0 && r2 == 0) 2450692ad7caSAdrian Chadd goto done; /* Interrupt not for us. */ 2451692ad7caSAdrian Chadd 2452692ad7caSAdrian Chadd /* Acknowledge interrupts. */ 2453692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, r1); 2454692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_INT, r2); 2455692ad7caSAdrian Chadd 2456692ad7caSAdrian Chadd if (r1 & (WPI_INT_SW_ERR | WPI_INT_HW_ERR)) { 24576607310bSBenjamin Close device_printf(sc->sc_dev, "fatal firmware error\n"); 2458a6df6cfeSAdrian Chadd #ifdef WPI_DEBUG 2459a6df6cfeSAdrian Chadd wpi_debug_registers(sc); 2460a6df6cfeSAdrian Chadd #endif 2461692ad7caSAdrian Chadd wpi_fatal_intr(sc); 2462692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_HW, 2463692ad7caSAdrian Chadd "(%s)\n", (r1 & WPI_INT_SW_ERR) ? "(Software Error)" : 2464692ad7caSAdrian Chadd "(Hardware Error)"); 2465e2ad4371SAdrian Chadd taskqueue_enqueue(sc->sc_tq, &sc->sc_reinittask); 24667f1299c5SAdrian Chadd goto end; 24676607310bSBenjamin Close } 24686607310bSBenjamin Close 2469692ad7caSAdrian Chadd if ((r1 & (WPI_INT_FH_RX | WPI_INT_SW_RX)) || 2470692ad7caSAdrian Chadd (r2 & WPI_FH_INT_RX)) 24716607310bSBenjamin Close wpi_notif_intr(sc); 24726607310bSBenjamin Close 2473692ad7caSAdrian Chadd if (r1 & WPI_INT_ALIVE) 2474692ad7caSAdrian Chadd wakeup(sc); /* Firmware is alive. */ 24756607310bSBenjamin Close 2476692ad7caSAdrian Chadd if (r1 & WPI_INT_WAKEUP) 2477692ad7caSAdrian Chadd wpi_wakeup_intr(sc); 2478692ad7caSAdrian Chadd 2479692ad7caSAdrian Chadd done: 2480692ad7caSAdrian Chadd /* Re-enable interrupts. */ 2481692ad7caSAdrian Chadd if (ifp->if_flags & IFF_UP) 2482692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT_MASK, WPI_INT_MASK_DEF); 24836607310bSBenjamin Close 24847f1299c5SAdrian Chadd end: WPI_UNLOCK(sc); 24856607310bSBenjamin Close } 24866607310bSBenjamin Close 24876607310bSBenjamin Close static int 2488692ad7caSAdrian Chadd wpi_cmd2(struct wpi_softc *sc, struct wpi_buf *buf) 24896607310bSBenjamin Close { 249084ad7b36SAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 24916607310bSBenjamin Close struct ieee80211_frame *wh; 2492692ad7caSAdrian Chadd struct wpi_tx_cmd *cmd; 2493692ad7caSAdrian Chadd struct wpi_tx_data *data; 2494692ad7caSAdrian Chadd struct wpi_tx_desc *desc; 2495692ad7caSAdrian Chadd struct wpi_tx_ring *ring; 2496692ad7caSAdrian Chadd struct mbuf *m1; 2497692ad7caSAdrian Chadd bus_dma_segment_t *seg, segs[WPI_MAX_SCATTER]; 24988a28176aSAdrian Chadd int error, i, hdrlen, nsegs, totlen, pad; 24996607310bSBenjamin Close 250063f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 250163f57699SAdrian Chadd 2502565248e2SAdrian Chadd KASSERT(buf->size <= sizeof(buf->data), ("buffer overflow")); 2503565248e2SAdrian Chadd 2504692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 2505692ad7caSAdrian Chadd 250663f57699SAdrian Chadd if (sc->txq_active == 0) { 250763f57699SAdrian Chadd /* wpi_stop() was called */ 250863f57699SAdrian Chadd error = ENETDOWN; 250963f57699SAdrian Chadd goto fail; 251063f57699SAdrian Chadd } 251163f57699SAdrian Chadd 2512692ad7caSAdrian Chadd wh = mtod(buf->m, struct ieee80211_frame *); 25138a28176aSAdrian Chadd hdrlen = ieee80211_anyhdrsize(wh); 2514692ad7caSAdrian Chadd totlen = buf->m->m_pkthdr.len; 2515692ad7caSAdrian Chadd 25168a28176aSAdrian Chadd if (hdrlen & 3) { 25178a28176aSAdrian Chadd /* First segment length must be a multiple of 4. */ 25188a28176aSAdrian Chadd pad = 4 - (hdrlen & 3); 25198a28176aSAdrian Chadd } else 25208a28176aSAdrian Chadd pad = 0; 25218a28176aSAdrian Chadd 2522692ad7caSAdrian Chadd ring = &sc->txq[buf->ac]; 25236607310bSBenjamin Close desc = &ring->desc[ring->cur]; 25246607310bSBenjamin Close data = &ring->data[ring->cur]; 25256607310bSBenjamin Close 2526692ad7caSAdrian Chadd /* Prepare TX firmware command. */ 25276607310bSBenjamin Close cmd = &ring->cmd[ring->cur]; 2528692ad7caSAdrian Chadd cmd->code = buf->code; 25296607310bSBenjamin Close cmd->flags = 0; 25306607310bSBenjamin Close cmd->qid = ring->qid; 25316607310bSBenjamin Close cmd->idx = ring->cur; 25326607310bSBenjamin Close 2533692ad7caSAdrian Chadd memcpy(cmd->data, buf->data, buf->size); 25346607310bSBenjamin Close 2535692ad7caSAdrian Chadd /* Save and trim IEEE802.11 header. */ 25368a28176aSAdrian Chadd memcpy((uint8_t *)(cmd->data + buf->size), wh, hdrlen); 25378a28176aSAdrian Chadd m_adj(buf->m, hdrlen); 25386607310bSBenjamin Close 2539692ad7caSAdrian Chadd error = bus_dmamap_load_mbuf_sg(ring->data_dmat, data->map, buf->m, 2540692ad7caSAdrian Chadd segs, &nsegs, BUS_DMA_NOWAIT); 25416607310bSBenjamin Close if (error != 0 && error != EFBIG) { 2542692ad7caSAdrian Chadd device_printf(sc->sc_dev, 2543692ad7caSAdrian Chadd "%s: can't map mbuf (error %d)\n", __func__, error); 254463f57699SAdrian Chadd goto fail; 25456607310bSBenjamin Close } 25466607310bSBenjamin Close if (error != 0) { 2547692ad7caSAdrian Chadd /* Too many DMA segments, linearize mbuf. */ 2548893edbeaSAdrian Chadd m1 = m_collapse(buf->m, M_NOWAIT, WPI_MAX_SCATTER - 1); 2549692ad7caSAdrian Chadd if (m1 == NULL) { 25506607310bSBenjamin Close device_printf(sc->sc_dev, 2551692ad7caSAdrian Chadd "%s: could not defrag mbuf\n", __func__); 255263f57699SAdrian Chadd error = ENOBUFS; 255363f57699SAdrian Chadd goto fail; 25546607310bSBenjamin Close } 2555692ad7caSAdrian Chadd buf->m = m1; 25566607310bSBenjamin Close 25576607310bSBenjamin Close error = bus_dmamap_load_mbuf_sg(ring->data_dmat, data->map, 2558692ad7caSAdrian Chadd buf->m, segs, &nsegs, BUS_DMA_NOWAIT); 25596607310bSBenjamin Close if (error != 0) { 25606607310bSBenjamin Close device_printf(sc->sc_dev, 25617167f5fcSAdrian Chadd "%s: can't map mbuf (error %d)\n", __func__, 25627167f5fcSAdrian Chadd error); 256363f57699SAdrian Chadd goto fail; 25646607310bSBenjamin Close } 25656607310bSBenjamin Close } 25666607310bSBenjamin Close 2567893edbeaSAdrian Chadd KASSERT(nsegs < WPI_MAX_SCATTER, 2568893edbeaSAdrian Chadd ("too many DMA segments, nsegs (%d) should be less than %d", 2569893edbeaSAdrian Chadd nsegs, WPI_MAX_SCATTER)); 2570893edbeaSAdrian Chadd 2571692ad7caSAdrian Chadd data->m = buf->m; 2572692ad7caSAdrian Chadd data->ni = buf->ni; 25736607310bSBenjamin Close 2574692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_XMIT, "%s: qid %d idx %d len %d nsegs %d\n", 2575692ad7caSAdrian Chadd __func__, ring->qid, ring->cur, totlen, nsegs); 25766607310bSBenjamin Close 2577692ad7caSAdrian Chadd /* Fill TX descriptor. */ 25788a28176aSAdrian Chadd desc->nsegs = WPI_PAD32(totlen + pad) << 4 | (1 + nsegs); 2579692ad7caSAdrian Chadd /* First DMA segment is used by the TX command. */ 2580692ad7caSAdrian Chadd desc->segs[0].addr = htole32(data->cmd_paddr); 25818a28176aSAdrian Chadd desc->segs[0].len = htole32(4 + buf->size + hdrlen + pad); 2582692ad7caSAdrian Chadd /* Other DMA segments are for data payload. */ 2583692ad7caSAdrian Chadd seg = &segs[0]; 25846607310bSBenjamin Close for (i = 1; i <= nsegs; i++) { 2585692ad7caSAdrian Chadd desc->segs[i].addr = htole32(seg->ds_addr); 2586692ad7caSAdrian Chadd desc->segs[i].len = htole32(seg->ds_len); 2587692ad7caSAdrian Chadd seg++; 25886607310bSBenjamin Close } 25896607310bSBenjamin Close 25906607310bSBenjamin Close bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_PREWRITE); 2591692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, ring->cmd_dma.map, 2592692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 25936607310bSBenjamin Close bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 25946607310bSBenjamin Close BUS_DMASYNC_PREWRITE); 25956607310bSBenjamin Close 2596692ad7caSAdrian Chadd /* Kick TX ring. */ 25976607310bSBenjamin Close ring->cur = (ring->cur + 1) % WPI_TX_RING_COUNT; 2598692ad7caSAdrian Chadd wpi_update_tx_ring(sc, ring); 2599692ad7caSAdrian Chadd 260045ac43f3SAdrian Chadd if (ring->qid < WPI_CMD_QUEUE_NUM) { 2601692ad7caSAdrian Chadd /* Mark TX ring as full if we reach a certain threshold. */ 2602fc5870b4SAdrian Chadd WPI_TXQ_STATE_LOCK(sc); 260384ad7b36SAdrian Chadd if (++ring->queued > WPI_TX_RING_HIMARK) { 2604692ad7caSAdrian Chadd sc->qfullmsk |= 1 << ring->qid; 2605692ad7caSAdrian Chadd 260684ad7b36SAdrian Chadd IF_LOCK(&ifp->if_snd); 260784ad7b36SAdrian Chadd ifp->if_drv_flags |= IFF_DRV_OACTIVE; 260884ad7b36SAdrian Chadd IF_UNLOCK(&ifp->if_snd); 260984ad7b36SAdrian Chadd } 261084ad7b36SAdrian Chadd 2611d74e544aSAdrian Chadd callout_reset(&sc->tx_timeout, 5*hz, wpi_tx_timeout, sc); 2612fc5870b4SAdrian Chadd WPI_TXQ_STATE_UNLOCK(sc); 261345ac43f3SAdrian Chadd } 261410550f61SAdrian Chadd 2615692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 2616692ad7caSAdrian Chadd 261763f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 261863f57699SAdrian Chadd 2619692ad7caSAdrian Chadd return 0; 262063f57699SAdrian Chadd 262163f57699SAdrian Chadd fail: m_freem(buf->m); 262263f57699SAdrian Chadd 262363f57699SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 262463f57699SAdrian Chadd 262563f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 262663f57699SAdrian Chadd 262763f57699SAdrian Chadd return error; 2628692ad7caSAdrian Chadd } 2629692ad7caSAdrian Chadd 2630692ad7caSAdrian Chadd /* 2631692ad7caSAdrian Chadd * Construct the data packet for a transmit buffer. 2632692ad7caSAdrian Chadd */ 2633692ad7caSAdrian Chadd static int 2634692ad7caSAdrian Chadd wpi_tx_data(struct wpi_softc *sc, struct mbuf *m, struct ieee80211_node *ni) 2635692ad7caSAdrian Chadd { 2636692ad7caSAdrian Chadd const struct ieee80211_txparam *tp; 2637692ad7caSAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 2638692ad7caSAdrian Chadd struct ieee80211com *ic = ni->ni_ic; 2639a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 2640692ad7caSAdrian Chadd struct ieee80211_channel *chan; 2641692ad7caSAdrian Chadd struct ieee80211_frame *wh; 2642692ad7caSAdrian Chadd struct ieee80211_key *k = NULL; 2643692ad7caSAdrian Chadd struct wpi_buf tx_data; 2644565248e2SAdrian Chadd struct wpi_cmd_data *tx = (struct wpi_cmd_data *)&tx_data.data; 2645692ad7caSAdrian Chadd uint32_t flags; 2646692ad7caSAdrian Chadd uint16_t qos; 2647692ad7caSAdrian Chadd uint8_t tid, type; 2648f15520d9SAdrian Chadd int ac, error, swcrypt, rate, ismcast, totlen; 2649692ad7caSAdrian Chadd 2650692ad7caSAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 2651692ad7caSAdrian Chadd type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK; 2652692ad7caSAdrian Chadd ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1); 2653692ad7caSAdrian Chadd 2654692ad7caSAdrian Chadd /* Select EDCA Access Category and TX ring for this frame. */ 2655692ad7caSAdrian Chadd if (IEEE80211_QOS_HAS_SEQ(wh)) { 2656692ad7caSAdrian Chadd qos = ((const struct ieee80211_qosframe *)wh)->i_qos[0]; 2657692ad7caSAdrian Chadd tid = qos & IEEE80211_QOS_TID; 2658692ad7caSAdrian Chadd } else { 2659692ad7caSAdrian Chadd qos = 0; 2660692ad7caSAdrian Chadd tid = 0; 2661692ad7caSAdrian Chadd } 2662692ad7caSAdrian Chadd ac = M_WME_GETAC(m); 2663692ad7caSAdrian Chadd 2664692ad7caSAdrian Chadd chan = (ni->ni_chan != IEEE80211_CHAN_ANYC) ? 2665692ad7caSAdrian Chadd ni->ni_chan : ic->ic_curchan; 2666692ad7caSAdrian Chadd tp = &vap->iv_txparms[ieee80211_chan2mode(chan)]; 2667692ad7caSAdrian Chadd 2668692ad7caSAdrian Chadd /* Choose a TX rate index. */ 2669692ad7caSAdrian Chadd if (type == IEEE80211_FC0_TYPE_MGT) 2670692ad7caSAdrian Chadd rate = tp->mgmtrate; 2671692ad7caSAdrian Chadd else if (ismcast) 2672692ad7caSAdrian Chadd rate = tp->mcastrate; 2673692ad7caSAdrian Chadd else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) 2674692ad7caSAdrian Chadd rate = tp->ucastrate; 2675692ad7caSAdrian Chadd else if (m->m_flags & M_EAPOL) 2676692ad7caSAdrian Chadd rate = tp->mgmtrate; 2677692ad7caSAdrian Chadd else { 2678692ad7caSAdrian Chadd /* XXX pass pktlen */ 2679692ad7caSAdrian Chadd (void) ieee80211_ratectl_rate(ni, NULL, 0); 2680692ad7caSAdrian Chadd rate = ni->ni_txrate; 2681692ad7caSAdrian Chadd } 2682692ad7caSAdrian Chadd 2683692ad7caSAdrian Chadd /* Encrypt the frame if need be. */ 2684692ad7caSAdrian Chadd if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) { 2685692ad7caSAdrian Chadd /* Retrieve key for TX. */ 2686692ad7caSAdrian Chadd k = ieee80211_crypto_encap(ni, m); 2687692ad7caSAdrian Chadd if (k == NULL) { 2688692ad7caSAdrian Chadd error = ENOBUFS; 2689692ad7caSAdrian Chadd goto fail; 2690692ad7caSAdrian Chadd } 2691f15520d9SAdrian Chadd swcrypt = k->wk_flags & IEEE80211_KEY_SWCRYPT; 2692f15520d9SAdrian Chadd 2693692ad7caSAdrian Chadd /* 802.11 header may have moved. */ 2694692ad7caSAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 2695692ad7caSAdrian Chadd } 26968a28176aSAdrian Chadd totlen = m->m_pkthdr.len; 2697692ad7caSAdrian Chadd 2698692ad7caSAdrian Chadd if (ieee80211_radiotap_active_vap(vap)) { 2699692ad7caSAdrian Chadd struct wpi_tx_radiotap_header *tap = &sc->sc_txtap; 2700692ad7caSAdrian Chadd 27018a28176aSAdrian Chadd tap->wt_flags = 0; 2702692ad7caSAdrian Chadd tap->wt_rate = rate; 2703692ad7caSAdrian Chadd if (k != NULL) 2704692ad7caSAdrian Chadd tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP; 2705692ad7caSAdrian Chadd 2706692ad7caSAdrian Chadd ieee80211_radiotap_tx(vap, m); 2707692ad7caSAdrian Chadd } 2708692ad7caSAdrian Chadd 2709692ad7caSAdrian Chadd flags = 0; 2710692ad7caSAdrian Chadd if (!ismcast) { 2711692ad7caSAdrian Chadd /* Unicast frame, check if an ACK is expected. */ 2712692ad7caSAdrian Chadd if (!qos || (qos & IEEE80211_QOS_ACKPOLICY) != 2713692ad7caSAdrian Chadd IEEE80211_QOS_ACKPOLICY_NOACK) 2714692ad7caSAdrian Chadd flags |= WPI_TX_NEED_ACK; 2715692ad7caSAdrian Chadd } 2716692ad7caSAdrian Chadd 2717fae61c69SAdrian Chadd if (wh->i_fc[1] & IEEE80211_FC1_MORE_FRAG) 2718fae61c69SAdrian Chadd flags |= WPI_TX_MORE_FRAG; /* Cannot happen yet. */ 2719fae61c69SAdrian Chadd 2720692ad7caSAdrian Chadd /* Check if frame must be protected using RTS/CTS or CTS-to-self. */ 2721692ad7caSAdrian Chadd if (!ismcast) { 2722692ad7caSAdrian Chadd /* NB: Group frames are sent using CCK in 802.11b/g. */ 2723692ad7caSAdrian Chadd if (totlen + IEEE80211_CRC_LEN > vap->iv_rtsthreshold) { 2724692ad7caSAdrian Chadd flags |= WPI_TX_NEED_RTS; 2725692ad7caSAdrian Chadd } else if ((ic->ic_flags & IEEE80211_F_USEPROT) && 2726692ad7caSAdrian Chadd WPI_RATE_IS_OFDM(rate)) { 2727692ad7caSAdrian Chadd if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) 2728692ad7caSAdrian Chadd flags |= WPI_TX_NEED_CTS; 2729692ad7caSAdrian Chadd else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) 2730692ad7caSAdrian Chadd flags |= WPI_TX_NEED_RTS; 2731692ad7caSAdrian Chadd } 2732692ad7caSAdrian Chadd 2733692ad7caSAdrian Chadd if (flags & (WPI_TX_NEED_RTS | WPI_TX_NEED_CTS)) 2734692ad7caSAdrian Chadd flags |= WPI_TX_FULL_TXOP; 2735692ad7caSAdrian Chadd } 2736692ad7caSAdrian Chadd 2737565248e2SAdrian Chadd memset(tx, 0, sizeof (struct wpi_cmd_data)); 2738692ad7caSAdrian Chadd if (type == IEEE80211_FC0_TYPE_MGT) { 2739692ad7caSAdrian Chadd uint8_t subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; 2740692ad7caSAdrian Chadd 2741692ad7caSAdrian Chadd /* Tell HW to set timestamp in probe responses. */ 2742692ad7caSAdrian Chadd if (subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP) 2743692ad7caSAdrian Chadd flags |= WPI_TX_INSERT_TSTAMP; 2744692ad7caSAdrian Chadd if (subtype == IEEE80211_FC0_SUBTYPE_ASSOC_REQ || 2745692ad7caSAdrian Chadd subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ) 2746565248e2SAdrian Chadd tx->timeout = htole16(3); 2747692ad7caSAdrian Chadd else 2748565248e2SAdrian Chadd tx->timeout = htole16(2); 2749692ad7caSAdrian Chadd } 2750692ad7caSAdrian Chadd 2751692ad7caSAdrian Chadd if (ismcast || type != IEEE80211_FC0_TYPE_DATA) 2752565248e2SAdrian Chadd tx->id = WPI_ID_BROADCAST; 2753692ad7caSAdrian Chadd else { 2754692ad7caSAdrian Chadd if (wn->id == WPI_ID_UNDEFINED) { 2755692ad7caSAdrian Chadd device_printf(sc->sc_dev, 2756692ad7caSAdrian Chadd "%s: undefined node id\n", __func__); 2757692ad7caSAdrian Chadd error = EINVAL; 2758692ad7caSAdrian Chadd goto fail; 2759692ad7caSAdrian Chadd } 2760692ad7caSAdrian Chadd 2761565248e2SAdrian Chadd tx->id = wn->id; 2762692ad7caSAdrian Chadd } 2763692ad7caSAdrian Chadd 2764f15520d9SAdrian Chadd if (k != NULL && !swcrypt) { 2765f15520d9SAdrian Chadd switch (k->wk_cipher->ic_cipher) { 2766f15520d9SAdrian Chadd case IEEE80211_CIPHER_AES_CCM: 2767565248e2SAdrian Chadd tx->security = WPI_CIPHER_CCMP; 2768f15520d9SAdrian Chadd break; 2769f15520d9SAdrian Chadd 2770f15520d9SAdrian Chadd default: 2771f15520d9SAdrian Chadd break; 2772f15520d9SAdrian Chadd } 2773f15520d9SAdrian Chadd 2774565248e2SAdrian Chadd memcpy(tx->key, k->wk_key, k->wk_keylen); 2775f15520d9SAdrian Chadd } 2776f15520d9SAdrian Chadd 2777565248e2SAdrian Chadd tx->len = htole16(totlen); 2778565248e2SAdrian Chadd tx->flags = htole32(flags); 2779565248e2SAdrian Chadd tx->plcp = rate2plcp(rate); 2780565248e2SAdrian Chadd tx->tid = tid; 2781565248e2SAdrian Chadd tx->lifetime = htole32(WPI_LIFETIME_INFINITE); 2782565248e2SAdrian Chadd tx->ofdm_mask = 0xff; 2783565248e2SAdrian Chadd tx->cck_mask = 0x0f; 2784565248e2SAdrian Chadd tx->rts_ntries = 7; 2785b625a56aSAdrian Chadd tx->data_ntries = tp->maxretry; 2786692ad7caSAdrian Chadd 2787692ad7caSAdrian Chadd tx_data.ni = ni; 2788692ad7caSAdrian Chadd tx_data.m = m; 2789565248e2SAdrian Chadd tx_data.size = sizeof(struct wpi_cmd_data); 2790692ad7caSAdrian Chadd tx_data.code = WPI_CMD_TX_DATA; 2791692ad7caSAdrian Chadd tx_data.ac = ac; 2792692ad7caSAdrian Chadd 2793692ad7caSAdrian Chadd return wpi_cmd2(sc, &tx_data); 2794692ad7caSAdrian Chadd 2795692ad7caSAdrian Chadd fail: m_freem(m); 2796692ad7caSAdrian Chadd return error; 2797692ad7caSAdrian Chadd } 2798692ad7caSAdrian Chadd 2799692ad7caSAdrian Chadd static int 28007167f5fcSAdrian Chadd wpi_tx_data_raw(struct wpi_softc *sc, struct mbuf *m, 28017167f5fcSAdrian Chadd struct ieee80211_node *ni, const struct ieee80211_bpf_params *params) 2802692ad7caSAdrian Chadd { 2803692ad7caSAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 2804735c6067SAdrian Chadd struct ieee80211_key *k = NULL; 2805692ad7caSAdrian Chadd struct ieee80211_frame *wh; 2806692ad7caSAdrian Chadd struct wpi_buf tx_data; 2807565248e2SAdrian Chadd struct wpi_cmd_data *tx = (struct wpi_cmd_data *)&tx_data.data; 2808692ad7caSAdrian Chadd uint32_t flags; 2809692ad7caSAdrian Chadd uint8_t type; 2810735c6067SAdrian Chadd int ac, rate, swcrypt, totlen; 2811692ad7caSAdrian Chadd 2812692ad7caSAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 2813692ad7caSAdrian Chadd type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK; 2814692ad7caSAdrian Chadd 2815692ad7caSAdrian Chadd ac = params->ibp_pri & 3; 2816692ad7caSAdrian Chadd 2817692ad7caSAdrian Chadd /* Choose a TX rate index. */ 2818692ad7caSAdrian Chadd rate = params->ibp_rate0; 2819692ad7caSAdrian Chadd 2820692ad7caSAdrian Chadd flags = 0; 2821692ad7caSAdrian Chadd if ((params->ibp_flags & IEEE80211_BPF_NOACK) == 0) 2822692ad7caSAdrian Chadd flags |= WPI_TX_NEED_ACK; 2823692ad7caSAdrian Chadd if (params->ibp_flags & IEEE80211_BPF_RTS) 2824692ad7caSAdrian Chadd flags |= WPI_TX_NEED_RTS; 2825692ad7caSAdrian Chadd if (params->ibp_flags & IEEE80211_BPF_CTS) 2826692ad7caSAdrian Chadd flags |= WPI_TX_NEED_CTS; 2827692ad7caSAdrian Chadd if (flags & (WPI_TX_NEED_RTS | WPI_TX_NEED_CTS)) 2828692ad7caSAdrian Chadd flags |= WPI_TX_FULL_TXOP; 2829692ad7caSAdrian Chadd 2830735c6067SAdrian Chadd /* Encrypt the frame if need be. */ 2831735c6067SAdrian Chadd if (params->ibp_flags & IEEE80211_BPF_CRYPTO) { 2832735c6067SAdrian Chadd /* Retrieve key for TX. */ 2833735c6067SAdrian Chadd k = ieee80211_crypto_encap(ni, m); 2834735c6067SAdrian Chadd if (k == NULL) { 2835735c6067SAdrian Chadd m_freem(m); 2836735c6067SAdrian Chadd return ENOBUFS; 2837735c6067SAdrian Chadd } 2838735c6067SAdrian Chadd swcrypt = k->wk_flags & IEEE80211_KEY_SWCRYPT; 2839735c6067SAdrian Chadd 2840735c6067SAdrian Chadd /* 802.11 header may have moved. */ 2841735c6067SAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 2842735c6067SAdrian Chadd } 2843735c6067SAdrian Chadd totlen = m->m_pkthdr.len; 2844735c6067SAdrian Chadd 2845692ad7caSAdrian Chadd if (ieee80211_radiotap_active_vap(vap)) { 2846692ad7caSAdrian Chadd struct wpi_tx_radiotap_header *tap = &sc->sc_txtap; 2847692ad7caSAdrian Chadd 2848692ad7caSAdrian Chadd tap->wt_flags = 0; 2849692ad7caSAdrian Chadd tap->wt_rate = rate; 2850735c6067SAdrian Chadd if (params->ibp_flags & IEEE80211_BPF_CRYPTO) 2851735c6067SAdrian Chadd tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP; 2852692ad7caSAdrian Chadd 2853692ad7caSAdrian Chadd ieee80211_radiotap_tx(vap, m); 2854692ad7caSAdrian Chadd } 2855692ad7caSAdrian Chadd 2856565248e2SAdrian Chadd memset(tx, 0, sizeof (struct wpi_cmd_data)); 2857692ad7caSAdrian Chadd if (type == IEEE80211_FC0_TYPE_MGT) { 2858692ad7caSAdrian Chadd uint8_t subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; 2859692ad7caSAdrian Chadd 2860692ad7caSAdrian Chadd /* Tell HW to set timestamp in probe responses. */ 2861692ad7caSAdrian Chadd if (subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP) 2862692ad7caSAdrian Chadd flags |= WPI_TX_INSERT_TSTAMP; 2863692ad7caSAdrian Chadd if (subtype == IEEE80211_FC0_SUBTYPE_ASSOC_REQ || 2864692ad7caSAdrian Chadd subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ) 2865565248e2SAdrian Chadd tx->timeout = htole16(3); 2866692ad7caSAdrian Chadd else 2867565248e2SAdrian Chadd tx->timeout = htole16(2); 2868692ad7caSAdrian Chadd } 2869692ad7caSAdrian Chadd 2870735c6067SAdrian Chadd if (k != NULL && !swcrypt) { 2871735c6067SAdrian Chadd switch (k->wk_cipher->ic_cipher) { 2872735c6067SAdrian Chadd case IEEE80211_CIPHER_AES_CCM: 2873735c6067SAdrian Chadd tx->security = WPI_CIPHER_CCMP; 2874735c6067SAdrian Chadd break; 2875735c6067SAdrian Chadd 2876735c6067SAdrian Chadd default: 2877735c6067SAdrian Chadd break; 2878735c6067SAdrian Chadd } 2879735c6067SAdrian Chadd 2880735c6067SAdrian Chadd memcpy(tx->key, k->wk_key, k->wk_keylen); 2881735c6067SAdrian Chadd } 2882735c6067SAdrian Chadd 2883565248e2SAdrian Chadd tx->len = htole16(totlen); 2884565248e2SAdrian Chadd tx->flags = htole32(flags); 2885565248e2SAdrian Chadd tx->plcp = rate2plcp(rate); 2886565248e2SAdrian Chadd tx->id = WPI_ID_BROADCAST; 2887565248e2SAdrian Chadd tx->lifetime = htole32(WPI_LIFETIME_INFINITE); 2888565248e2SAdrian Chadd tx->rts_ntries = params->ibp_try1; 2889565248e2SAdrian Chadd tx->data_ntries = params->ibp_try0; 2890692ad7caSAdrian Chadd 2891692ad7caSAdrian Chadd tx_data.ni = ni; 2892692ad7caSAdrian Chadd tx_data.m = m; 2893565248e2SAdrian Chadd tx_data.size = sizeof(struct wpi_cmd_data); 2894692ad7caSAdrian Chadd tx_data.code = WPI_CMD_TX_DATA; 2895692ad7caSAdrian Chadd tx_data.ac = ac; 2896692ad7caSAdrian Chadd 2897692ad7caSAdrian Chadd return wpi_cmd2(sc, &tx_data); 2898692ad7caSAdrian Chadd } 2899692ad7caSAdrian Chadd 2900692ad7caSAdrian Chadd static int 2901692ad7caSAdrian Chadd wpi_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, 2902692ad7caSAdrian Chadd const struct ieee80211_bpf_params *params) 2903692ad7caSAdrian Chadd { 2904692ad7caSAdrian Chadd struct ieee80211com *ic = ni->ni_ic; 2905692ad7caSAdrian Chadd struct ifnet *ifp = ic->ic_ifp; 2906692ad7caSAdrian Chadd struct wpi_softc *sc = ifp->if_softc; 2907692ad7caSAdrian Chadd int error = 0; 2908692ad7caSAdrian Chadd 2909692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 2910692ad7caSAdrian Chadd 2911692ad7caSAdrian Chadd if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) { 2912692ad7caSAdrian Chadd ieee80211_free_node(ni); 2913692ad7caSAdrian Chadd m_freem(m); 2914692ad7caSAdrian Chadd return ENETDOWN; 2915692ad7caSAdrian Chadd } 2916692ad7caSAdrian Chadd 29175effcbfdSAdrian Chadd WPI_TX_LOCK(sc); 2918692ad7caSAdrian Chadd if (params == NULL) { 2919692ad7caSAdrian Chadd /* 2920692ad7caSAdrian Chadd * Legacy path; interpret frame contents to decide 2921692ad7caSAdrian Chadd * precisely how to send the frame. 2922692ad7caSAdrian Chadd */ 2923692ad7caSAdrian Chadd error = wpi_tx_data(sc, m, ni); 2924692ad7caSAdrian Chadd } else { 2925692ad7caSAdrian Chadd /* 2926692ad7caSAdrian Chadd * Caller supplied explicit parameters to use in 2927692ad7caSAdrian Chadd * sending the frame. 2928692ad7caSAdrian Chadd */ 2929692ad7caSAdrian Chadd error = wpi_tx_data_raw(sc, m, ni, params); 2930692ad7caSAdrian Chadd } 29315effcbfdSAdrian Chadd WPI_TX_UNLOCK(sc); 2932692ad7caSAdrian Chadd 2933692ad7caSAdrian Chadd if (error != 0) { 2934692ad7caSAdrian Chadd /* NB: m is reclaimed on tx failure */ 2935692ad7caSAdrian Chadd ieee80211_free_node(ni); 2936692ad7caSAdrian Chadd if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 2937692ad7caSAdrian Chadd 2938692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 2939692ad7caSAdrian Chadd 2940692ad7caSAdrian Chadd return error; 2941692ad7caSAdrian Chadd } 2942692ad7caSAdrian Chadd 2943692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 29446607310bSBenjamin Close 29456607310bSBenjamin Close return 0; 29466607310bSBenjamin Close } 29476607310bSBenjamin Close 29486607310bSBenjamin Close /** 29496607310bSBenjamin Close * Process data waiting to be sent on the IFNET output queue 29506607310bSBenjamin Close */ 29516607310bSBenjamin Close static void 29526607310bSBenjamin Close wpi_start(struct ifnet *ifp) 29536607310bSBenjamin Close { 29546607310bSBenjamin Close struct wpi_softc *sc = ifp->if_softc; 29556607310bSBenjamin Close struct ieee80211_node *ni; 2956b032f27cSSam Leffler struct mbuf *m; 2957b032f27cSSam Leffler 29585effcbfdSAdrian Chadd WPI_TX_LOCK(sc); 2959692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_XMIT, "%s: called\n", __func__); 2960692ad7caSAdrian Chadd 296184ad7b36SAdrian Chadd for (;;) { 2962b9858d86SAdrian Chadd IF_LOCK(&ifp->if_snd); 2963692ad7caSAdrian Chadd if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || 2964b9858d86SAdrian Chadd (ifp->if_drv_flags & IFF_DRV_OACTIVE)) { 2965b9858d86SAdrian Chadd IF_UNLOCK(&ifp->if_snd); 296684ad7b36SAdrian Chadd break; 2967b9858d86SAdrian Chadd } 2968b9858d86SAdrian Chadd IF_UNLOCK(&ifp->if_snd); 296982f1b132SAndrew Thompson 2970fcec677dSJuli Mallett IFQ_DRV_DEQUEUE(&ifp->if_snd, m); 2971b032f27cSSam Leffler if (m == NULL) 29726607310bSBenjamin Close break; 2973b032f27cSSam Leffler ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; 2974692ad7caSAdrian Chadd if (wpi_tx_data(sc, m, ni) != 0) { 29756607310bSBenjamin Close ieee80211_free_node(ni); 2976692ad7caSAdrian Chadd if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 297710550f61SAdrian Chadd } 2978b032f27cSSam Leffler } 2979b032f27cSSam Leffler 2980692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_XMIT, "%s: done\n", __func__); 29815effcbfdSAdrian Chadd WPI_TX_UNLOCK(sc); 2982692ad7caSAdrian Chadd } 2983b032f27cSSam Leffler 2984692ad7caSAdrian Chadd static void 29854eaf2ee3SAdrian Chadd wpi_start_task(void *arg0, int pending) 29864eaf2ee3SAdrian Chadd { 29874eaf2ee3SAdrian Chadd struct wpi_softc *sc = arg0; 29884eaf2ee3SAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 29894eaf2ee3SAdrian Chadd 29904eaf2ee3SAdrian Chadd wpi_start(ifp); 29914eaf2ee3SAdrian Chadd } 29924eaf2ee3SAdrian Chadd 29934eaf2ee3SAdrian Chadd static void 2994692ad7caSAdrian Chadd wpi_watchdog_rfkill(void *arg) 2995692ad7caSAdrian Chadd { 2996692ad7caSAdrian Chadd struct wpi_softc *sc = arg; 2997692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 2998692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 2999692ad7caSAdrian Chadd 3000692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_WATCHDOG, "RFkill Watchdog: tick\n"); 3001692ad7caSAdrian Chadd 3002692ad7caSAdrian Chadd /* No need to lock firmware memory. */ 3003692ad7caSAdrian Chadd if ((wpi_prph_read(sc, WPI_APMG_RFKILL) & 0x1) == 0) { 3004692ad7caSAdrian Chadd /* Radio kill switch is still off. */ 3005692ad7caSAdrian Chadd callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill, 3006692ad7caSAdrian Chadd sc); 3007692ad7caSAdrian Chadd } else 3008692ad7caSAdrian Chadd ieee80211_runtask(ic, &sc->sc_radioon_task); 3009692ad7caSAdrian Chadd } 3010692ad7caSAdrian Chadd 30110bc39fc6SAdrian Chadd static void 30120bc39fc6SAdrian Chadd wpi_scan_timeout(void *arg) 30130bc39fc6SAdrian Chadd { 30140bc39fc6SAdrian Chadd struct wpi_softc *sc = arg; 30150bc39fc6SAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 30160bc39fc6SAdrian Chadd 30170bc39fc6SAdrian Chadd if_printf(ifp, "scan timeout\n"); 3018e2ad4371SAdrian Chadd taskqueue_enqueue(sc->sc_tq, &sc->sc_reinittask); 30190bc39fc6SAdrian Chadd } 30200bc39fc6SAdrian Chadd 3021692ad7caSAdrian Chadd static void 3022d74e544aSAdrian Chadd wpi_tx_timeout(void *arg) 3023692ad7caSAdrian Chadd { 3024692ad7caSAdrian Chadd struct wpi_softc *sc = arg; 3025692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 3026692ad7caSAdrian Chadd 3027692ad7caSAdrian Chadd if_printf(ifp, "device timeout\n"); 3028c8dfaf38SGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 3029e2ad4371SAdrian Chadd taskqueue_enqueue(sc->sc_tq, &sc->sc_reinittask); 3030692ad7caSAdrian Chadd } 30316607310bSBenjamin Close 30326607310bSBenjamin Close static int 30336607310bSBenjamin Close wpi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 30346607310bSBenjamin Close { 30356607310bSBenjamin Close struct wpi_softc *sc = ifp->if_softc; 3036b032f27cSSam Leffler struct ieee80211com *ic = ifp->if_l2com; 3037692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 3038b032f27cSSam Leffler struct ifreq *ifr = (struct ifreq *) data; 30395ca77395SAdrian Chadd int error = 0; 30406607310bSBenjamin Close 30416607310bSBenjamin Close switch (cmd) { 3042692ad7caSAdrian Chadd case SIOCGIFADDR: 3043692ad7caSAdrian Chadd error = ether_ioctl(ifp, cmd, data); 3044692ad7caSAdrian Chadd break; 30456607310bSBenjamin Close case SIOCSIFFLAGS: 3046692ad7caSAdrian Chadd if (ifp->if_flags & IFF_UP) { 30475ca77395SAdrian Chadd wpi_init(sc); 30485ca77395SAdrian Chadd 30495ca77395SAdrian Chadd if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 && 30505ca77395SAdrian Chadd vap != NULL) 3051692ad7caSAdrian Chadd ieee80211_stop(vap); 30525ca77395SAdrian Chadd } else if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) 30535ca77395SAdrian Chadd wpi_stop(sc); 305431a8c1edSAndrew Thompson break; 305531a8c1edSAndrew Thompson case SIOCGIFMEDIA: 305631a8c1edSAndrew Thompson error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd); 305731a8c1edSAndrew Thompson break; 305831a8c1edSAndrew Thompson default: 305931a8c1edSAndrew Thompson error = EINVAL; 306031a8c1edSAndrew Thompson break; 306131a8c1edSAndrew Thompson } 30626607310bSBenjamin Close return error; 30636607310bSBenjamin Close } 30646607310bSBenjamin Close 30656607310bSBenjamin Close /* 30666607310bSBenjamin Close * Send a command to the firmware. 30676607310bSBenjamin Close */ 30686607310bSBenjamin Close static int 3069692ad7caSAdrian Chadd wpi_cmd(struct wpi_softc *sc, int code, const void *buf, size_t size, 3070692ad7caSAdrian Chadd int async) 30716607310bSBenjamin Close { 30728e4cf38aSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[WPI_CMD_QUEUE_NUM]; 30736607310bSBenjamin Close struct wpi_tx_desc *desc; 3074692ad7caSAdrian Chadd struct wpi_tx_data *data; 30756607310bSBenjamin Close struct wpi_tx_cmd *cmd; 3076692ad7caSAdrian Chadd struct mbuf *m; 3077692ad7caSAdrian Chadd bus_addr_t paddr; 3078692ad7caSAdrian Chadd int totlen, error; 30796607310bSBenjamin Close 308063f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 308163f57699SAdrian Chadd 3082692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 3083692ad7caSAdrian Chadd 308463f57699SAdrian Chadd if (sc->txq_active == 0) { 308563f57699SAdrian Chadd /* wpi_stop() was called */ 308663f57699SAdrian Chadd error = 0; 308763f57699SAdrian Chadd goto fail; 308863f57699SAdrian Chadd } 308963f57699SAdrian Chadd 3090692ad7caSAdrian Chadd if (async == 0) 30916607310bSBenjamin Close WPI_LOCK_ASSERT(sc); 30926607310bSBenjamin Close 3093cec45f04SAdrian Chadd DPRINTF(sc, WPI_DEBUG_CMD, "%s: cmd %s size %zu async %d\n", 3094cec45f04SAdrian Chadd __func__, wpi_cmd_str(code), size, async); 30956607310bSBenjamin Close 30966607310bSBenjamin Close desc = &ring->desc[ring->cur]; 3097692ad7caSAdrian Chadd data = &ring->data[ring->cur]; 3098692ad7caSAdrian Chadd totlen = 4 + size; 3099692ad7caSAdrian Chadd 3100692ad7caSAdrian Chadd if (size > sizeof cmd->data) { 3101692ad7caSAdrian Chadd /* Command is too large to fit in a descriptor. */ 310263f57699SAdrian Chadd if (totlen > MCLBYTES) { 310363f57699SAdrian Chadd error = EINVAL; 310463f57699SAdrian Chadd goto fail; 310563f57699SAdrian Chadd } 3106692ad7caSAdrian Chadd m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); 310763f57699SAdrian Chadd if (m == NULL) { 310863f57699SAdrian Chadd error = ENOMEM; 310963f57699SAdrian Chadd goto fail; 311063f57699SAdrian Chadd } 3111692ad7caSAdrian Chadd cmd = mtod(m, struct wpi_tx_cmd *); 3112692ad7caSAdrian Chadd error = bus_dmamap_load(ring->data_dmat, data->map, cmd, 3113692ad7caSAdrian Chadd totlen, wpi_dma_map_addr, &paddr, BUS_DMA_NOWAIT); 3114692ad7caSAdrian Chadd if (error != 0) { 3115692ad7caSAdrian Chadd m_freem(m); 311663f57699SAdrian Chadd goto fail; 3117692ad7caSAdrian Chadd } 3118692ad7caSAdrian Chadd data->m = m; 3119692ad7caSAdrian Chadd } else { 31206607310bSBenjamin Close cmd = &ring->cmd[ring->cur]; 3121692ad7caSAdrian Chadd paddr = data->cmd_paddr; 3122692ad7caSAdrian Chadd } 31236607310bSBenjamin Close 31246607310bSBenjamin Close cmd->code = code; 31256607310bSBenjamin Close cmd->flags = 0; 31266607310bSBenjamin Close cmd->qid = ring->qid; 31276607310bSBenjamin Close cmd->idx = ring->cur; 31286607310bSBenjamin Close memcpy(cmd->data, buf, size); 31296607310bSBenjamin Close 3130692ad7caSAdrian Chadd desc->nsegs = 1 + (WPI_PAD32(size) << 4); 3131692ad7caSAdrian Chadd desc->segs[0].addr = htole32(paddr); 3132692ad7caSAdrian Chadd desc->segs[0].len = htole32(totlen); 31336607310bSBenjamin Close 3134692ad7caSAdrian Chadd if (size > sizeof cmd->data) { 3135692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 3136692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 3137692ad7caSAdrian Chadd } else { 3138692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, ring->cmd_dma.map, 3139692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 3140692ad7caSAdrian Chadd } 3141692ad7caSAdrian Chadd bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 3142692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 3143692ad7caSAdrian Chadd 3144692ad7caSAdrian Chadd /* Kick command ring. */ 3145692ad7caSAdrian Chadd ring->cur = (ring->cur + 1) % WPI_TX_RING_COUNT; 3146692ad7caSAdrian Chadd wpi_update_tx_ring(sc, ring); 3147692ad7caSAdrian Chadd 3148692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 31496607310bSBenjamin Close 315063f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 315163f57699SAdrian Chadd 3152ff62db1dSAdrian Chadd if (async) 31536607310bSBenjamin Close return 0; 31546607310bSBenjamin Close 315576fdf7ebSAdrian Chadd return mtx_sleep(cmd, &sc->sc_mtx, PCATCH, "wpicmd", hz); 315663f57699SAdrian Chadd 315763f57699SAdrian Chadd fail: DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 315863f57699SAdrian Chadd 315963f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 316063f57699SAdrian Chadd 316163f57699SAdrian Chadd return error; 31626607310bSBenjamin Close } 31636607310bSBenjamin Close 31646607310bSBenjamin Close /* 3165692ad7caSAdrian Chadd * Configure HW multi-rate retries. 31666607310bSBenjamin Close */ 31676607310bSBenjamin Close static int 31686607310bSBenjamin Close wpi_mrr_setup(struct wpi_softc *sc) 31696607310bSBenjamin Close { 3170b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 3171b032f27cSSam Leffler struct ieee80211com *ic = ifp->if_l2com; 31726607310bSBenjamin Close struct wpi_mrr_setup mrr; 31736607310bSBenjamin Close int i, error; 31746607310bSBenjamin Close 3175692ad7caSAdrian Chadd /* CCK rates (not used with 802.11a). */ 3176692ad7caSAdrian Chadd for (i = WPI_RIDX_CCK1; i <= WPI_RIDX_CCK11; i++) { 31776607310bSBenjamin Close mrr.rates[i].flags = 0; 3178692ad7caSAdrian Chadd mrr.rates[i].plcp = wpi_ridx_to_plcp[i]; 3179692ad7caSAdrian Chadd /* Fallback to the immediate lower CCK rate (if any.) */ 3180692ad7caSAdrian Chadd mrr.rates[i].next = 3181692ad7caSAdrian Chadd (i == WPI_RIDX_CCK1) ? WPI_RIDX_CCK1 : i - 1; 318230b60481SAdrian Chadd /* Try twice at this rate before falling back to "next". */ 318330b60481SAdrian Chadd mrr.rates[i].ntries = WPI_NTRIES_DEFAULT; 31846607310bSBenjamin Close } 3185692ad7caSAdrian Chadd /* OFDM rates (not used with 802.11b). */ 3186692ad7caSAdrian Chadd for (i = WPI_RIDX_OFDM6; i <= WPI_RIDX_OFDM54; i++) { 31876607310bSBenjamin Close mrr.rates[i].flags = 0; 3188692ad7caSAdrian Chadd mrr.rates[i].plcp = wpi_ridx_to_plcp[i]; 3189692ad7caSAdrian Chadd /* Fallback to the immediate lower rate (if any.) */ 3190692ad7caSAdrian Chadd /* We allow fallback from OFDM/6 to CCK/2 in 11b/g mode. */ 3191692ad7caSAdrian Chadd mrr.rates[i].next = (i == WPI_RIDX_OFDM6) ? 31926607310bSBenjamin Close ((ic->ic_curmode == IEEE80211_MODE_11A) ? 3193692ad7caSAdrian Chadd WPI_RIDX_OFDM6 : WPI_RIDX_CCK2) : 31946607310bSBenjamin Close i - 1; 319530b60481SAdrian Chadd /* Try twice at this rate before falling back to "next". */ 319630b60481SAdrian Chadd mrr.rates[i].ntries = WPI_NTRIES_DEFAULT; 31976607310bSBenjamin Close } 3198692ad7caSAdrian Chadd /* Setup MRR for control frames. */ 3199692ad7caSAdrian Chadd mrr.which = htole32(WPI_MRR_CTL); 32006607310bSBenjamin Close error = wpi_cmd(sc, WPI_CMD_MRR_SETUP, &mrr, sizeof mrr, 0); 32016607310bSBenjamin Close if (error != 0) { 32026607310bSBenjamin Close device_printf(sc->sc_dev, 32036607310bSBenjamin Close "could not setup MRR for control frames\n"); 32046607310bSBenjamin Close return error; 32056607310bSBenjamin Close } 3206692ad7caSAdrian Chadd /* Setup MRR for data frames. */ 3207692ad7caSAdrian Chadd mrr.which = htole32(WPI_MRR_DATA); 32086607310bSBenjamin Close error = wpi_cmd(sc, WPI_CMD_MRR_SETUP, &mrr, sizeof mrr, 0); 32096607310bSBenjamin Close if (error != 0) { 32106607310bSBenjamin Close device_printf(sc->sc_dev, 32116607310bSBenjamin Close "could not setup MRR for data frames\n"); 32126607310bSBenjamin Close return error; 32136607310bSBenjamin Close } 32146607310bSBenjamin Close return 0; 32156607310bSBenjamin Close } 32166607310bSBenjamin Close 3217692ad7caSAdrian Chadd static int 3218692ad7caSAdrian Chadd wpi_add_node(struct wpi_softc *sc, struct ieee80211_node *ni) 3219692ad7caSAdrian Chadd { 3220692ad7caSAdrian Chadd struct ieee80211com *ic = ni->ni_ic; 3221d29fcfb7SAdrian Chadd struct wpi_vap *wvp = WPI_VAP(ni->ni_vap); 3222a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 3223692ad7caSAdrian Chadd struct wpi_node_info node; 3224d29fcfb7SAdrian Chadd int error; 3225692ad7caSAdrian Chadd 3226692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3227692ad7caSAdrian Chadd 3228692ad7caSAdrian Chadd if (wn->id == WPI_ID_UNDEFINED) 3229692ad7caSAdrian Chadd return EINVAL; 3230692ad7caSAdrian Chadd 3231692ad7caSAdrian Chadd memset(&node, 0, sizeof node); 32323de934a7SAdrian Chadd IEEE80211_ADDR_COPY(node.macaddr, ni->ni_macaddr); 3233692ad7caSAdrian Chadd node.id = wn->id; 3234692ad7caSAdrian Chadd node.plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ? 3235692ad7caSAdrian Chadd wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1]; 3236692ad7caSAdrian Chadd node.action = htole32(WPI_ACTION_SET_RATE); 3237692ad7caSAdrian Chadd node.antenna = WPI_ANTENNA_BOTH; 3238692ad7caSAdrian Chadd 32390528191aSAdrian Chadd DPRINTF(sc, WPI_DEBUG_NODE, "%s: adding node %d (%s)\n", __func__, 32400528191aSAdrian Chadd wn->id, ether_sprintf(ni->ni_macaddr)); 32410528191aSAdrian Chadd 3242d29fcfb7SAdrian Chadd error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1); 3243d29fcfb7SAdrian Chadd if (error != 0) { 3244d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, 3245d29fcfb7SAdrian Chadd "%s: wpi_cmd() call failed with error code %d\n", __func__, 3246d29fcfb7SAdrian Chadd error); 3247d29fcfb7SAdrian Chadd return error; 3248d29fcfb7SAdrian Chadd } 3249d29fcfb7SAdrian Chadd 3250d29fcfb7SAdrian Chadd if (wvp->wv_gtk != 0) { 3251d29fcfb7SAdrian Chadd error = wpi_set_global_keys(ni); 3252d29fcfb7SAdrian Chadd if (error != 0) { 3253d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, 3254d29fcfb7SAdrian Chadd "%s: error while setting global keys\n", __func__); 3255d29fcfb7SAdrian Chadd return ENXIO; 3256d29fcfb7SAdrian Chadd } 3257d29fcfb7SAdrian Chadd } 3258d29fcfb7SAdrian Chadd 3259d29fcfb7SAdrian Chadd return 0; 3260692ad7caSAdrian Chadd } 3261692ad7caSAdrian Chadd 3262692ad7caSAdrian Chadd /* 3263692ad7caSAdrian Chadd * Broadcast node is used to send group-addressed and management frames. 3264692ad7caSAdrian Chadd */ 3265692ad7caSAdrian Chadd static int 3266692ad7caSAdrian Chadd wpi_add_broadcast_node(struct wpi_softc *sc, int async) 3267692ad7caSAdrian Chadd { 3268692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 3269692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 3270692ad7caSAdrian Chadd struct wpi_node_info node; 3271692ad7caSAdrian Chadd 3272692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3273692ad7caSAdrian Chadd 3274692ad7caSAdrian Chadd memset(&node, 0, sizeof node); 3275692ad7caSAdrian Chadd IEEE80211_ADDR_COPY(node.macaddr, ifp->if_broadcastaddr); 3276692ad7caSAdrian Chadd node.id = WPI_ID_BROADCAST; 3277692ad7caSAdrian Chadd node.plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ? 3278692ad7caSAdrian Chadd wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1]; 3279692ad7caSAdrian Chadd node.action = htole32(WPI_ACTION_SET_RATE); 3280692ad7caSAdrian Chadd node.antenna = WPI_ANTENNA_BOTH; 3281692ad7caSAdrian Chadd 32820528191aSAdrian Chadd DPRINTF(sc, WPI_DEBUG_NODE, "%s: adding broadcast node\n", __func__); 32830528191aSAdrian Chadd 3284692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, async); 3285692ad7caSAdrian Chadd } 3286692ad7caSAdrian Chadd 3287692ad7caSAdrian Chadd static int 32880ebca245SAdrian Chadd wpi_add_sta_node(struct wpi_softc *sc, struct ieee80211_node *ni) 32890ebca245SAdrian Chadd { 32900ebca245SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 32910ebca245SAdrian Chadd int error; 32920ebca245SAdrian Chadd 32930ebca245SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 32940ebca245SAdrian Chadd 32950ebca245SAdrian Chadd wn->id = wpi_add_node_entry_sta(sc); 32960ebca245SAdrian Chadd 32970ebca245SAdrian Chadd if ((error = wpi_add_node(sc, ni)) != 0) { 32980ebca245SAdrian Chadd wpi_del_node_entry(sc, wn->id); 32990ebca245SAdrian Chadd wn->id = WPI_ID_UNDEFINED; 33000ebca245SAdrian Chadd return error; 33010ebca245SAdrian Chadd } 33020ebca245SAdrian Chadd 33030ebca245SAdrian Chadd return 0; 33040ebca245SAdrian Chadd } 33050ebca245SAdrian Chadd 33060ebca245SAdrian Chadd static int 3307692ad7caSAdrian Chadd wpi_add_ibss_node(struct wpi_softc *sc, struct ieee80211_node *ni) 3308692ad7caSAdrian Chadd { 3309a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 3310eca2eb39SAdrian Chadd int error; 3311692ad7caSAdrian Chadd 331239060fa9SAdrian Chadd KASSERT(wn->id == WPI_ID_UNDEFINED, 331339060fa9SAdrian Chadd ("the node %d was added before", wn->id)); 3314692ad7caSAdrian Chadd 331539060fa9SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3316692ad7caSAdrian Chadd 3317eca2eb39SAdrian Chadd if ((wn->id = wpi_add_node_entry_adhoc(sc)) == WPI_ID_UNDEFINED) { 3318eca2eb39SAdrian Chadd device_printf(sc->sc_dev, "%s: h/w table is full\n", __func__); 3319eca2eb39SAdrian Chadd return ENOMEM; 3320eca2eb39SAdrian Chadd } 3321692ad7caSAdrian Chadd 3322eca2eb39SAdrian Chadd if ((error = wpi_add_node(sc, ni)) != 0) { 3323eca2eb39SAdrian Chadd wpi_del_node_entry(sc, wn->id); 3324eca2eb39SAdrian Chadd wn->id = WPI_ID_UNDEFINED; 3325eca2eb39SAdrian Chadd return error; 3326eca2eb39SAdrian Chadd } 3327692ad7caSAdrian Chadd 3328eca2eb39SAdrian Chadd return 0; 3329692ad7caSAdrian Chadd } 3330692ad7caSAdrian Chadd 3331692ad7caSAdrian Chadd static void 3332692ad7caSAdrian Chadd wpi_del_node(struct wpi_softc *sc, struct ieee80211_node *ni) 3333692ad7caSAdrian Chadd { 3334a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 3335692ad7caSAdrian Chadd struct wpi_cmd_del_node node; 3336692ad7caSAdrian Chadd int error; 3337692ad7caSAdrian Chadd 333839060fa9SAdrian Chadd KASSERT(wn->id != WPI_ID_UNDEFINED, ("undefined node id passed")); 3339692ad7caSAdrian Chadd 334039060fa9SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3341692ad7caSAdrian Chadd 3342692ad7caSAdrian Chadd memset(&node, 0, sizeof node); 33433de934a7SAdrian Chadd IEEE80211_ADDR_COPY(node.macaddr, ni->ni_macaddr); 3344692ad7caSAdrian Chadd node.count = 1; 3345692ad7caSAdrian Chadd 33460528191aSAdrian Chadd DPRINTF(sc, WPI_DEBUG_NODE, "%s: deleting node %d (%s)\n", __func__, 33470528191aSAdrian Chadd wn->id, ether_sprintf(ni->ni_macaddr)); 33480528191aSAdrian Chadd 3349692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_DEL_NODE, &node, sizeof node, 1); 3350692ad7caSAdrian Chadd if (error != 0) { 3351692ad7caSAdrian Chadd device_printf(sc->sc_dev, 3352692ad7caSAdrian Chadd "%s: could not delete node %u, error %d\n", __func__, 3353692ad7caSAdrian Chadd wn->id, error); 3354692ad7caSAdrian Chadd } 3355692ad7caSAdrian Chadd } 3356692ad7caSAdrian Chadd 3357692ad7caSAdrian Chadd static int 3358692ad7caSAdrian Chadd wpi_updateedca(struct ieee80211com *ic) 3359692ad7caSAdrian Chadd { 3360692ad7caSAdrian Chadd #define WPI_EXP2(x) ((1 << (x)) - 1) /* CWmin = 2^ECWmin - 1 */ 3361692ad7caSAdrian Chadd struct wpi_softc *sc = ic->ic_ifp->if_softc; 3362692ad7caSAdrian Chadd struct wpi_edca_params cmd; 3363692ad7caSAdrian Chadd int aci, error; 3364692ad7caSAdrian Chadd 3365692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 3366692ad7caSAdrian Chadd 3367692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3368692ad7caSAdrian Chadd cmd.flags = htole32(WPI_EDCA_UPDATE); 3369692ad7caSAdrian Chadd for (aci = 0; aci < WME_NUM_AC; aci++) { 3370692ad7caSAdrian Chadd const struct wmeParams *ac = 3371692ad7caSAdrian Chadd &ic->ic_wme.wme_chanParams.cap_wmeParams[aci]; 3372692ad7caSAdrian Chadd cmd.ac[aci].aifsn = ac->wmep_aifsn; 3373692ad7caSAdrian Chadd cmd.ac[aci].cwmin = htole16(WPI_EXP2(ac->wmep_logcwmin)); 3374692ad7caSAdrian Chadd cmd.ac[aci].cwmax = htole16(WPI_EXP2(ac->wmep_logcwmax)); 3375692ad7caSAdrian Chadd cmd.ac[aci].txoplimit = 3376692ad7caSAdrian Chadd htole16(IEEE80211_TXOP_TO_US(ac->wmep_txopLimit)); 3377692ad7caSAdrian Chadd 3378692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EDCA, 3379692ad7caSAdrian Chadd "setting WME for queue %d aifsn=%d cwmin=%d cwmax=%d " 3380692ad7caSAdrian Chadd "txoplimit=%d\n", aci, cmd.ac[aci].aifsn, 3381692ad7caSAdrian Chadd cmd.ac[aci].cwmin, cmd.ac[aci].cwmax, 3382692ad7caSAdrian Chadd cmd.ac[aci].txoplimit); 3383692ad7caSAdrian Chadd } 3384692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_EDCA_PARAMS, &cmd, sizeof cmd, 1); 3385692ad7caSAdrian Chadd 3386692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 3387692ad7caSAdrian Chadd 3388692ad7caSAdrian Chadd return error; 3389692ad7caSAdrian Chadd #undef WPI_EXP2 3390692ad7caSAdrian Chadd } 3391692ad7caSAdrian Chadd 3392692ad7caSAdrian Chadd static void 3393692ad7caSAdrian Chadd wpi_set_promisc(struct wpi_softc *sc) 3394692ad7caSAdrian Chadd { 3395692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 3396726ddc26SAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 3397726ddc26SAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 3398692ad7caSAdrian Chadd uint32_t promisc_filter; 3399692ad7caSAdrian Chadd 3400726ddc26SAdrian Chadd promisc_filter = WPI_FILTER_CTL; 3401726ddc26SAdrian Chadd if (vap != NULL && vap->iv_opmode != IEEE80211_M_HOSTAP) 3402726ddc26SAdrian Chadd promisc_filter |= WPI_FILTER_PROMISC; 3403692ad7caSAdrian Chadd 3404692ad7caSAdrian Chadd if (ifp->if_flags & IFF_PROMISC) 3405692ad7caSAdrian Chadd sc->rxon.filter |= htole32(promisc_filter); 3406692ad7caSAdrian Chadd else 3407692ad7caSAdrian Chadd sc->rxon.filter &= ~htole32(promisc_filter); 3408692ad7caSAdrian Chadd } 3409692ad7caSAdrian Chadd 3410692ad7caSAdrian Chadd static void 3411692ad7caSAdrian Chadd wpi_update_promisc(struct ifnet *ifp) 3412692ad7caSAdrian Chadd { 3413692ad7caSAdrian Chadd struct wpi_softc *sc = ifp->if_softc; 3414692ad7caSAdrian Chadd 3415446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 3416692ad7caSAdrian Chadd wpi_set_promisc(sc); 3417692ad7caSAdrian Chadd 3418692ad7caSAdrian Chadd if (wpi_send_rxon(sc, 1, 1) != 0) { 3419692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not send RXON\n", 3420692ad7caSAdrian Chadd __func__); 3421692ad7caSAdrian Chadd } 3422446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 3423692ad7caSAdrian Chadd } 3424692ad7caSAdrian Chadd 3425692ad7caSAdrian Chadd static void 3426692ad7caSAdrian Chadd wpi_update_mcast(struct ifnet *ifp) 3427692ad7caSAdrian Chadd { 3428692ad7caSAdrian Chadd /* Ignore */ 3429692ad7caSAdrian Chadd } 3430692ad7caSAdrian Chadd 34316607310bSBenjamin Close static void 34326607310bSBenjamin Close wpi_set_led(struct wpi_softc *sc, uint8_t which, uint8_t off, uint8_t on) 34336607310bSBenjamin Close { 34346607310bSBenjamin Close struct wpi_cmd_led led; 34356607310bSBenjamin Close 3436692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3437692ad7caSAdrian Chadd 34386607310bSBenjamin Close led.which = which; 34396607310bSBenjamin Close led.unit = htole32(100000); /* on/off in unit of 100ms */ 34406607310bSBenjamin Close led.off = off; 34416607310bSBenjamin Close led.on = on; 34426607310bSBenjamin Close (void)wpi_cmd(sc, WPI_CMD_SET_LED, &led, sizeof led, 1); 34436607310bSBenjamin Close } 34446607310bSBenjamin Close 3445692ad7caSAdrian Chadd static int 3446692ad7caSAdrian Chadd wpi_set_timing(struct wpi_softc *sc, struct ieee80211_node *ni) 34476607310bSBenjamin Close { 3448692ad7caSAdrian Chadd struct wpi_cmd_timing cmd; 34496607310bSBenjamin Close uint64_t val, mod; 34506607310bSBenjamin Close 3451692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 34526607310bSBenjamin Close 3453692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3454692ad7caSAdrian Chadd memcpy(&cmd.tstamp, ni->ni_tstamp.data, sizeof (uint64_t)); 3455692ad7caSAdrian Chadd cmd.bintval = htole16(ni->ni_intval); 3456692ad7caSAdrian Chadd cmd.lintval = htole16(10); 34576607310bSBenjamin Close 3458692ad7caSAdrian Chadd /* Compute remaining time until next beacon. */ 3459692ad7caSAdrian Chadd val = (uint64_t)ni->ni_intval * IEEE80211_DUR_TU; 3460692ad7caSAdrian Chadd mod = le64toh(cmd.tstamp) % val; 3461692ad7caSAdrian Chadd cmd.binitval = htole32((uint32_t)(val - mod)); 34626607310bSBenjamin Close 3463692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RESET, "timing bintval=%u tstamp=%ju, init=%u\n", 3464692ad7caSAdrian Chadd ni->ni_intval, le64toh(cmd.tstamp), (uint32_t)(val - mod)); 34656607310bSBenjamin Close 3466692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_TIMING, &cmd, sizeof cmd, 1); 34676607310bSBenjamin Close } 34686607310bSBenjamin Close 34696607310bSBenjamin Close /* 3470692ad7caSAdrian Chadd * This function is called periodically (every 60 seconds) to adjust output 3471692ad7caSAdrian Chadd * power to temperature changes. 3472692ad7caSAdrian Chadd */ 3473692ad7caSAdrian Chadd static void 3474692ad7caSAdrian Chadd wpi_power_calibration(struct wpi_softc *sc) 3475692ad7caSAdrian Chadd { 3476692ad7caSAdrian Chadd int temp; 3477692ad7caSAdrian Chadd 3478692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3479692ad7caSAdrian Chadd 3480692ad7caSAdrian Chadd /* Update sensor data. */ 3481692ad7caSAdrian Chadd temp = (int)WPI_READ(sc, WPI_UCODE_GP2); 3482692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, "Temp in calibration is: %d\n", temp); 3483692ad7caSAdrian Chadd 3484692ad7caSAdrian Chadd /* Sanity-check read value. */ 3485692ad7caSAdrian Chadd if (temp < -260 || temp > 25) { 3486692ad7caSAdrian Chadd /* This can't be correct, ignore. */ 3487692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, 3488692ad7caSAdrian Chadd "out-of-range temperature reported: %d\n", temp); 3489692ad7caSAdrian Chadd return; 3490692ad7caSAdrian Chadd } 3491692ad7caSAdrian Chadd 3492692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, "temperature %d->%d\n", sc->temp, temp); 3493692ad7caSAdrian Chadd 3494692ad7caSAdrian Chadd /* Adjust Tx power if need be. */ 3495692ad7caSAdrian Chadd if (abs(temp - sc->temp) <= 6) 3496692ad7caSAdrian Chadd return; 3497692ad7caSAdrian Chadd 3498692ad7caSAdrian Chadd sc->temp = temp; 3499692ad7caSAdrian Chadd 3500692ad7caSAdrian Chadd if (wpi_set_txpower(sc, 1) != 0) { 3501692ad7caSAdrian Chadd /* just warn, too bad for the automatic calibration... */ 3502692ad7caSAdrian Chadd device_printf(sc->sc_dev,"could not adjust Tx power\n"); 3503692ad7caSAdrian Chadd } 3504692ad7caSAdrian Chadd } 3505692ad7caSAdrian Chadd 3506692ad7caSAdrian Chadd /* 3507692ad7caSAdrian Chadd * Set TX power for current channel. 35086607310bSBenjamin Close */ 35096607310bSBenjamin Close static int 3510692ad7caSAdrian Chadd wpi_set_txpower(struct wpi_softc *sc, int async) 35116607310bSBenjamin Close { 3512692ad7caSAdrian Chadd struct wpi_power_group *group; 3513692ad7caSAdrian Chadd struct wpi_cmd_txpower cmd; 3514692ad7caSAdrian Chadd uint8_t chan; 3515655e8ba8SAdrian Chadd int idx, is_chan_5ghz, i; 35166607310bSBenjamin Close 3517692ad7caSAdrian Chadd /* Retrieve current channel from last RXON. */ 3518692ad7caSAdrian Chadd chan = sc->rxon.chan; 3519655e8ba8SAdrian Chadd is_chan_5ghz = (sc->rxon.flags & htole32(WPI_RXON_24GHZ)) == 0; 35206607310bSBenjamin Close 3521692ad7caSAdrian Chadd /* Find the TX power group to which this channel belongs. */ 3522655e8ba8SAdrian Chadd if (is_chan_5ghz) { 3523692ad7caSAdrian Chadd for (group = &sc->groups[1]; group < &sc->groups[4]; group++) 3524692ad7caSAdrian Chadd if (chan <= group->chan) 3525692ad7caSAdrian Chadd break; 3526692ad7caSAdrian Chadd } else 3527692ad7caSAdrian Chadd group = &sc->groups[0]; 3528692ad7caSAdrian Chadd 3529692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3530655e8ba8SAdrian Chadd cmd.band = is_chan_5ghz ? WPI_BAND_5GHZ : WPI_BAND_2GHZ; 3531692ad7caSAdrian Chadd cmd.chan = htole16(chan); 3532692ad7caSAdrian Chadd 3533692ad7caSAdrian Chadd /* Set TX power for all OFDM and CCK rates. */ 3534692ad7caSAdrian Chadd for (i = 0; i <= WPI_RIDX_MAX ; i++) { 3535692ad7caSAdrian Chadd /* Retrieve TX power for this channel/rate. */ 3536655e8ba8SAdrian Chadd idx = wpi_get_power_index(sc, group, chan, is_chan_5ghz, i); 3537692ad7caSAdrian Chadd 3538692ad7caSAdrian Chadd cmd.rates[i].plcp = wpi_ridx_to_plcp[i]; 3539692ad7caSAdrian Chadd 3540655e8ba8SAdrian Chadd if (is_chan_5ghz) { 3541692ad7caSAdrian Chadd cmd.rates[i].rf_gain = wpi_rf_gain_5ghz[idx]; 3542692ad7caSAdrian Chadd cmd.rates[i].dsp_gain = wpi_dsp_gain_5ghz[idx]; 3543692ad7caSAdrian Chadd } else { 3544692ad7caSAdrian Chadd cmd.rates[i].rf_gain = wpi_rf_gain_2ghz[idx]; 3545692ad7caSAdrian Chadd cmd.rates[i].dsp_gain = wpi_dsp_gain_2ghz[idx]; 3546692ad7caSAdrian Chadd } 3547692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, 3548692ad7caSAdrian Chadd "chan %d/ridx %d: power index %d\n", chan, i, idx); 3549692ad7caSAdrian Chadd } 3550692ad7caSAdrian Chadd 3551692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_TXPOWER, &cmd, sizeof cmd, async); 3552692ad7caSAdrian Chadd } 3553692ad7caSAdrian Chadd 3554692ad7caSAdrian Chadd /* 3555692ad7caSAdrian Chadd * Determine Tx power index for a given channel/rate combination. 3556692ad7caSAdrian Chadd * This takes into account the regulatory information from EEPROM and the 3557692ad7caSAdrian Chadd * current temperature. 3558692ad7caSAdrian Chadd */ 3559692ad7caSAdrian Chadd static int 3560692ad7caSAdrian Chadd wpi_get_power_index(struct wpi_softc *sc, struct wpi_power_group *group, 3561655e8ba8SAdrian Chadd uint8_t chan, int is_chan_5ghz, int ridx) 3562692ad7caSAdrian Chadd { 3563692ad7caSAdrian Chadd /* Fixed-point arithmetic division using a n-bit fractional part. */ 3564692ad7caSAdrian Chadd #define fdivround(a, b, n) \ 3565692ad7caSAdrian Chadd ((((1 << n) * (a)) / (b) + (1 << n) / 2) / (1 << n)) 3566692ad7caSAdrian Chadd 3567692ad7caSAdrian Chadd /* Linear interpolation. */ 3568692ad7caSAdrian Chadd #define interpolate(x, x1, y1, x2, y2, n) \ 3569692ad7caSAdrian Chadd ((y1) + fdivround(((x) - (x1)) * ((y2) - (y1)), (x2) - (x1), n)) 3570692ad7caSAdrian Chadd 3571692ad7caSAdrian Chadd struct wpi_power_sample *sample; 3572692ad7caSAdrian Chadd int pwr, idx; 3573692ad7caSAdrian Chadd 3574692ad7caSAdrian Chadd /* Default TX power is group maximum TX power minus 3dB. */ 3575692ad7caSAdrian Chadd pwr = group->maxpwr / 2; 3576692ad7caSAdrian Chadd 3577692ad7caSAdrian Chadd /* Decrease TX power for highest OFDM rates to reduce distortion. */ 3578692ad7caSAdrian Chadd switch (ridx) { 3579692ad7caSAdrian Chadd case WPI_RIDX_OFDM36: 3580655e8ba8SAdrian Chadd pwr -= is_chan_5ghz ? 5 : 0; 3581692ad7caSAdrian Chadd break; 3582692ad7caSAdrian Chadd case WPI_RIDX_OFDM48: 3583655e8ba8SAdrian Chadd pwr -= is_chan_5ghz ? 10 : 7; 3584692ad7caSAdrian Chadd break; 3585692ad7caSAdrian Chadd case WPI_RIDX_OFDM54: 3586655e8ba8SAdrian Chadd pwr -= is_chan_5ghz ? 12 : 9; 3587692ad7caSAdrian Chadd break; 3588692ad7caSAdrian Chadd } 3589692ad7caSAdrian Chadd 3590692ad7caSAdrian Chadd /* Never exceed the channel maximum allowed TX power. */ 3591692ad7caSAdrian Chadd pwr = min(pwr, sc->maxpwr[chan]); 3592692ad7caSAdrian Chadd 3593692ad7caSAdrian Chadd /* Retrieve TX power index into gain tables from samples. */ 3594692ad7caSAdrian Chadd for (sample = group->samples; sample < &group->samples[3]; sample++) 3595692ad7caSAdrian Chadd if (pwr > sample[1].power) 3596692ad7caSAdrian Chadd break; 3597692ad7caSAdrian Chadd /* Fixed-point linear interpolation using a 19-bit fractional part. */ 3598692ad7caSAdrian Chadd idx = interpolate(pwr, sample[0].power, sample[0].index, 3599692ad7caSAdrian Chadd sample[1].power, sample[1].index, 19); 3600692ad7caSAdrian Chadd 3601692ad7caSAdrian Chadd /*- 3602692ad7caSAdrian Chadd * Adjust power index based on current temperature: 3603692ad7caSAdrian Chadd * - if cooler than factory-calibrated: decrease output power 3604692ad7caSAdrian Chadd * - if warmer than factory-calibrated: increase output power 3605692ad7caSAdrian Chadd */ 3606692ad7caSAdrian Chadd idx -= (sc->temp - group->temp) * 11 / 100; 3607692ad7caSAdrian Chadd 3608692ad7caSAdrian Chadd /* Decrease TX power for CCK rates (-5dB). */ 3609692ad7caSAdrian Chadd if (ridx >= WPI_RIDX_CCK1) 3610692ad7caSAdrian Chadd idx += 10; 3611692ad7caSAdrian Chadd 3612692ad7caSAdrian Chadd /* Make sure idx stays in a valid range. */ 3613692ad7caSAdrian Chadd if (idx < 0) 3614692ad7caSAdrian Chadd return 0; 3615692ad7caSAdrian Chadd if (idx > WPI_MAX_PWR_INDEX) 3616692ad7caSAdrian Chadd return WPI_MAX_PWR_INDEX; 3617692ad7caSAdrian Chadd return idx; 3618692ad7caSAdrian Chadd 3619692ad7caSAdrian Chadd #undef interpolate 3620692ad7caSAdrian Chadd #undef fdivround 3621692ad7caSAdrian Chadd } 3622692ad7caSAdrian Chadd 3623692ad7caSAdrian Chadd /* 3624692ad7caSAdrian Chadd * Set STA mode power saving level (between 0 and 5). 3625692ad7caSAdrian Chadd * Level 0 is CAM (Continuously Aware Mode), 5 is for maximum power saving. 3626692ad7caSAdrian Chadd */ 3627692ad7caSAdrian Chadd static int 3628692ad7caSAdrian Chadd wpi_set_pslevel(struct wpi_softc *sc, uint8_t dtim, int level, int async) 3629692ad7caSAdrian Chadd { 3630692ad7caSAdrian Chadd struct wpi_pmgt_cmd cmd; 3631692ad7caSAdrian Chadd const struct wpi_pmgt *pmgt; 3632692ad7caSAdrian Chadd uint32_t max, skip_dtim; 3633692ad7caSAdrian Chadd uint32_t reg; 3634692ad7caSAdrian Chadd int i; 3635692ad7caSAdrian Chadd 3636692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_PWRSAVE, 3637692ad7caSAdrian Chadd "%s: dtim=%d, level=%d, async=%d\n", 3638692ad7caSAdrian Chadd __func__, dtim, level, async); 3639692ad7caSAdrian Chadd 3640692ad7caSAdrian Chadd /* Select which PS parameters to use. */ 3641692ad7caSAdrian Chadd if (dtim <= 10) 3642692ad7caSAdrian Chadd pmgt = &wpi_pmgt[0][level]; 3643692ad7caSAdrian Chadd else 3644692ad7caSAdrian Chadd pmgt = &wpi_pmgt[1][level]; 3645692ad7caSAdrian Chadd 3646692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3647692ad7caSAdrian Chadd if (level != 0) /* not CAM */ 3648692ad7caSAdrian Chadd cmd.flags |= htole16(WPI_PS_ALLOW_SLEEP); 3649692ad7caSAdrian Chadd /* Retrieve PCIe Active State Power Management (ASPM). */ 3650692ad7caSAdrian Chadd reg = pci_read_config(sc->sc_dev, sc->sc_cap_off + 0x10, 1); 3651692ad7caSAdrian Chadd if (!(reg & 0x1)) /* L0s Entry disabled. */ 3652692ad7caSAdrian Chadd cmd.flags |= htole16(WPI_PS_PCI_PMGT); 3653692ad7caSAdrian Chadd 3654692ad7caSAdrian Chadd cmd.rxtimeout = htole32(pmgt->rxtimeout * IEEE80211_DUR_TU); 3655692ad7caSAdrian Chadd cmd.txtimeout = htole32(pmgt->txtimeout * IEEE80211_DUR_TU); 3656692ad7caSAdrian Chadd 3657692ad7caSAdrian Chadd if (dtim == 0) { 3658692ad7caSAdrian Chadd dtim = 1; 3659692ad7caSAdrian Chadd skip_dtim = 0; 3660692ad7caSAdrian Chadd } else 3661692ad7caSAdrian Chadd skip_dtim = pmgt->skip_dtim; 3662692ad7caSAdrian Chadd 3663692ad7caSAdrian Chadd if (skip_dtim != 0) { 3664692ad7caSAdrian Chadd cmd.flags |= htole16(WPI_PS_SLEEP_OVER_DTIM); 3665692ad7caSAdrian Chadd max = pmgt->intval[4]; 3666692ad7caSAdrian Chadd if (max == (uint32_t)-1) 3667692ad7caSAdrian Chadd max = dtim * (skip_dtim + 1); 3668692ad7caSAdrian Chadd else if (max > dtim) 3669692ad7caSAdrian Chadd max = (max / dtim) * dtim; 3670692ad7caSAdrian Chadd } else 3671692ad7caSAdrian Chadd max = dtim; 3672692ad7caSAdrian Chadd 3673692ad7caSAdrian Chadd for (i = 0; i < 5; i++) 3674692ad7caSAdrian Chadd cmd.intval[i] = htole32(MIN(max, pmgt->intval[i])); 3675692ad7caSAdrian Chadd 3676692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_SET_POWER_MODE, &cmd, sizeof cmd, async); 3677692ad7caSAdrian Chadd } 3678692ad7caSAdrian Chadd 3679692ad7caSAdrian Chadd static int 3680692ad7caSAdrian Chadd wpi_send_btcoex(struct wpi_softc *sc) 3681692ad7caSAdrian Chadd { 3682692ad7caSAdrian Chadd struct wpi_bluetooth cmd; 3683692ad7caSAdrian Chadd 3684692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3685692ad7caSAdrian Chadd cmd.flags = WPI_BT_COEX_MODE_4WIRE; 3686692ad7caSAdrian Chadd cmd.lead_time = WPI_BT_LEAD_TIME_DEF; 3687692ad7caSAdrian Chadd cmd.max_kill = WPI_BT_MAX_KILL_DEF; 3688692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RESET, "%s: configuring bluetooth coexistence\n", 3689692ad7caSAdrian Chadd __func__); 3690692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_BT_COEX, &cmd, sizeof(cmd), 0); 3691692ad7caSAdrian Chadd } 3692692ad7caSAdrian Chadd 3693692ad7caSAdrian Chadd static int 3694692ad7caSAdrian Chadd wpi_send_rxon(struct wpi_softc *sc, int assoc, int async) 3695692ad7caSAdrian Chadd { 3696692ad7caSAdrian Chadd int error; 3697692ad7caSAdrian Chadd 3698446685e4SAdrian Chadd if (async) 3699446685e4SAdrian Chadd WPI_RXON_LOCK_ASSERT(sc); 3700446685e4SAdrian Chadd 3701621f1a75SAdrian Chadd if (assoc && wpi_check_bss_filter(sc) != 0) { 3702692ad7caSAdrian Chadd struct wpi_assoc rxon_assoc; 3703692ad7caSAdrian Chadd 3704692ad7caSAdrian Chadd rxon_assoc.flags = sc->rxon.flags; 3705692ad7caSAdrian Chadd rxon_assoc.filter = sc->rxon.filter; 3706692ad7caSAdrian Chadd rxon_assoc.ofdm_mask = sc->rxon.ofdm_mask; 3707692ad7caSAdrian Chadd rxon_assoc.cck_mask = sc->rxon.cck_mask; 3708692ad7caSAdrian Chadd rxon_assoc.reserved = 0; 3709692ad7caSAdrian Chadd 3710692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_RXON_ASSOC, &rxon_assoc, 3711692ad7caSAdrian Chadd sizeof (struct wpi_assoc), async); 3712cfe9b1ceSAdrian Chadd if (error != 0) { 3713cfe9b1ceSAdrian Chadd device_printf(sc->sc_dev, 3714cfe9b1ceSAdrian Chadd "RXON_ASSOC command failed, error %d\n", error); 3715cfe9b1ceSAdrian Chadd return error; 3716cfe9b1ceSAdrian Chadd } 3717692ad7caSAdrian Chadd } else { 3718cfe9b1ceSAdrian Chadd if (async) { 37197964dd56SAdrian Chadd WPI_NT_LOCK(sc); 3720692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_RXON, &sc->rxon, 3721692ad7caSAdrian Chadd sizeof (struct wpi_rxon), async); 3722cfe9b1ceSAdrian Chadd if (error == 0) 3723eca2eb39SAdrian Chadd wpi_clear_node_table(sc); 37247964dd56SAdrian Chadd WPI_NT_UNLOCK(sc); 3725cfe9b1ceSAdrian Chadd } else { 3726cfe9b1ceSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_RXON, &sc->rxon, 3727cfe9b1ceSAdrian Chadd sizeof (struct wpi_rxon), async); 3728cfe9b1ceSAdrian Chadd if (error == 0) 3729cfe9b1ceSAdrian Chadd wpi_clear_node_table(sc); 3730692ad7caSAdrian Chadd } 3731cfe9b1ceSAdrian Chadd 3732692ad7caSAdrian Chadd if (error != 0) { 37336607310bSBenjamin Close device_printf(sc->sc_dev, 3734cfe9b1ceSAdrian Chadd "RXON command failed, error %d\n", error); 37356607310bSBenjamin Close return error; 37366607310bSBenjamin Close } 37376607310bSBenjamin Close 3738692ad7caSAdrian Chadd /* Add broadcast node. */ 3739692ad7caSAdrian Chadd error = wpi_add_broadcast_node(sc, async); 3740692ad7caSAdrian Chadd if (error != 0) { 3741692ad7caSAdrian Chadd device_printf(sc->sc_dev, 3742692ad7caSAdrian Chadd "could not add broadcast node, error %d\n", error); 3743692ad7caSAdrian Chadd return error; 3744692ad7caSAdrian Chadd } 3745692ad7caSAdrian Chadd } 37466607310bSBenjamin Close 3747cfe9b1ceSAdrian Chadd /* Configuration has changed, set Tx power accordingly. */ 3748cfe9b1ceSAdrian Chadd if ((error = wpi_set_txpower(sc, async)) != 0) { 3749cfe9b1ceSAdrian Chadd device_printf(sc->sc_dev, 3750cfe9b1ceSAdrian Chadd "%s: could not set TX power, error %d\n", __func__, error); 3751cfe9b1ceSAdrian Chadd return error; 3752cfe9b1ceSAdrian Chadd } 3753cfe9b1ceSAdrian Chadd 3754692ad7caSAdrian Chadd return 0; 37556607310bSBenjamin Close } 37566607310bSBenjamin Close 37576607310bSBenjamin Close /** 37586607310bSBenjamin Close * Configure the card to listen to a particular channel, this transisions the 37596607310bSBenjamin Close * card in to being able to receive frames from remote devices. 37606607310bSBenjamin Close */ 37616607310bSBenjamin Close static int 37626607310bSBenjamin Close wpi_config(struct wpi_softc *sc) 37636607310bSBenjamin Close { 3764b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 3765b032f27cSSam Leffler struct ieee80211com *ic = ifp->if_l2com; 37663de934a7SAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 37676b997e0cSAdrian Chadd struct ieee80211_channel *c = ic->ic_curchan; 37686607310bSBenjamin Close int error; 37696607310bSBenjamin Close 3770692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 3771692ad7caSAdrian Chadd 3772692ad7caSAdrian Chadd /* Set power saving level to CAM during initialization. */ 3773692ad7caSAdrian Chadd if ((error = wpi_set_pslevel(sc, 0, 0, 0)) != 0) { 3774692ad7caSAdrian Chadd device_printf(sc->sc_dev, 3775692ad7caSAdrian Chadd "%s: could not set power saving level\n", __func__); 37766607310bSBenjamin Close return error; 37776607310bSBenjamin Close } 37786607310bSBenjamin Close 3779692ad7caSAdrian Chadd /* Configure bluetooth coexistence. */ 3780692ad7caSAdrian Chadd if ((error = wpi_send_btcoex(sc)) != 0) { 37816607310bSBenjamin Close device_printf(sc->sc_dev, 37826607310bSBenjamin Close "could not configure bluetooth coexistence\n"); 37836607310bSBenjamin Close return error; 37846607310bSBenjamin Close } 37856607310bSBenjamin Close 3786692ad7caSAdrian Chadd /* Configure adapter. */ 3787692ad7caSAdrian Chadd memset(&sc->rxon, 0, sizeof (struct wpi_rxon)); 37883de934a7SAdrian Chadd IEEE80211_ADDR_COPY(sc->rxon.myaddr, vap->iv_myaddr); 3789692ad7caSAdrian Chadd 3790692ad7caSAdrian Chadd /* Set default channel. */ 37916b997e0cSAdrian Chadd sc->rxon.chan = ieee80211_chan2ieee(ic, c); 3792692ad7caSAdrian Chadd sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF); 37936b997e0cSAdrian Chadd if (IEEE80211_IS_CHAN_2GHZ(c)) 3794692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ); 3795692ad7caSAdrian Chadd 3796fae61c69SAdrian Chadd sc->rxon.filter = WPI_FILTER_MULTICAST; 37976607310bSBenjamin Close switch (ic->ic_opmode) { 37986607310bSBenjamin Close case IEEE80211_M_STA: 3799692ad7caSAdrian Chadd sc->rxon.mode = WPI_MODE_STA; 38006607310bSBenjamin Close break; 38016607310bSBenjamin Close case IEEE80211_M_IBSS: 3802692ad7caSAdrian Chadd sc->rxon.mode = WPI_MODE_IBSS; 3803fae61c69SAdrian Chadd sc->rxon.filter |= WPI_FILTER_BEACON; 38046607310bSBenjamin Close break; 38056607310bSBenjamin Close case IEEE80211_M_HOSTAP: 3806726ddc26SAdrian Chadd /* XXX workaround for beaconing */ 3807726ddc26SAdrian Chadd sc->rxon.mode = WPI_MODE_IBSS; 3808726ddc26SAdrian Chadd sc->rxon.filter |= WPI_FILTER_ASSOC | WPI_FILTER_PROMISC; 3809726ddc26SAdrian Chadd break; 3810726ddc26SAdrian Chadd case IEEE80211_M_AHDEMO: 3811692ad7caSAdrian Chadd sc->rxon.mode = WPI_MODE_HOSTAP; 38126607310bSBenjamin Close break; 38136607310bSBenjamin Close case IEEE80211_M_MONITOR: 3814692ad7caSAdrian Chadd sc->rxon.mode = WPI_MODE_MONITOR; 38156607310bSBenjamin Close break; 3816820e6a1fSRui Paulo default: 38177167f5fcSAdrian Chadd device_printf(sc->sc_dev, "unknown opmode %d\n", 38187167f5fcSAdrian Chadd ic->ic_opmode); 3819820e6a1fSRui Paulo return EINVAL; 38206607310bSBenjamin Close } 3821fae61c69SAdrian Chadd sc->rxon.filter = htole32(sc->rxon.filter); 3822692ad7caSAdrian Chadd wpi_set_promisc(sc); 3823692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x0f; /* not yet negotiated */ 3824692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0xff; /* not yet negotiated */ 3825692ad7caSAdrian Chadd 382664c9b99bSAdrian Chadd /* XXX Current configuration may be unusable. */ 382764c9b99bSAdrian Chadd if (IEEE80211_IS_CHAN_NOADHOC(c) && sc->rxon.mode == WPI_MODE_IBSS) { 382864c9b99bSAdrian Chadd device_printf(sc->sc_dev, 382964c9b99bSAdrian Chadd "%s: invalid channel (%d) selected for IBSS mode\n", 383064c9b99bSAdrian Chadd __func__, ieee80211_chan2ieee(ic, c)); 383164c9b99bSAdrian Chadd return EINVAL; 383264c9b99bSAdrian Chadd } 383364c9b99bSAdrian Chadd 3834692ad7caSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 0)) != 0) { 3835692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not send RXON\n", 3836692ad7caSAdrian Chadd __func__); 3837692ad7caSAdrian Chadd return error; 3838692ad7caSAdrian Chadd } 3839692ad7caSAdrian Chadd 3840692ad7caSAdrian Chadd /* Setup rate scalling. */ 3841692ad7caSAdrian Chadd if ((error = wpi_mrr_setup(sc)) != 0) { 3842692ad7caSAdrian Chadd device_printf(sc->sc_dev, "could not setup MRR, error %d\n", 3843692ad7caSAdrian Chadd error); 3844692ad7caSAdrian Chadd return error; 3845692ad7caSAdrian Chadd } 3846692ad7caSAdrian Chadd 3847692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 3848692ad7caSAdrian Chadd 3849692ad7caSAdrian Chadd return 0; 3850692ad7caSAdrian Chadd } 3851692ad7caSAdrian Chadd 3852692ad7caSAdrian Chadd static uint16_t 3853692ad7caSAdrian Chadd wpi_get_active_dwell_time(struct wpi_softc *sc, 3854692ad7caSAdrian Chadd struct ieee80211_channel *c, uint8_t n_probes) 3855692ad7caSAdrian Chadd { 3856692ad7caSAdrian Chadd /* No channel? Default to 2GHz settings. */ 3857692ad7caSAdrian Chadd if (c == NULL || IEEE80211_IS_CHAN_2GHZ(c)) { 3858692ad7caSAdrian Chadd return (WPI_ACTIVE_DWELL_TIME_2GHZ + 3859692ad7caSAdrian Chadd WPI_ACTIVE_DWELL_FACTOR_2GHZ * (n_probes + 1)); 3860692ad7caSAdrian Chadd } 3861692ad7caSAdrian Chadd 3862692ad7caSAdrian Chadd /* 5GHz dwell time. */ 3863692ad7caSAdrian Chadd return (WPI_ACTIVE_DWELL_TIME_5GHZ + 3864692ad7caSAdrian Chadd WPI_ACTIVE_DWELL_FACTOR_5GHZ * (n_probes + 1)); 3865692ad7caSAdrian Chadd } 3866692ad7caSAdrian Chadd 3867692ad7caSAdrian Chadd /* 386842946b7dSAdrian Chadd * Limit the total dwell time. 3869692ad7caSAdrian Chadd * 3870692ad7caSAdrian Chadd * Returns the dwell time in milliseconds. 3871692ad7caSAdrian Chadd */ 3872692ad7caSAdrian Chadd static uint16_t 3873692ad7caSAdrian Chadd wpi_limit_dwell(struct wpi_softc *sc, uint16_t dwell_time) 3874692ad7caSAdrian Chadd { 3875692ad7caSAdrian Chadd struct ieee80211com *ic = sc->sc_ifp->if_l2com; 38767d4ee533SAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 3877692ad7caSAdrian Chadd int bintval = 0; 3878692ad7caSAdrian Chadd 3879692ad7caSAdrian Chadd /* bintval is in TU (1.024mS) */ 38807d4ee533SAdrian Chadd if (vap != NULL) 3881692ad7caSAdrian Chadd bintval = vap->iv_bss->ni_intval; 3882692ad7caSAdrian Chadd 3883692ad7caSAdrian Chadd /* 3884692ad7caSAdrian Chadd * If it's non-zero, we should calculate the minimum of 3885692ad7caSAdrian Chadd * it and the DWELL_BASE. 3886692ad7caSAdrian Chadd * 3887692ad7caSAdrian Chadd * XXX Yes, the math should take into account that bintval 3888692ad7caSAdrian Chadd * is 1.024mS, not 1mS.. 3889692ad7caSAdrian Chadd */ 3890692ad7caSAdrian Chadd if (bintval > 0) { 3891692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_SCAN, "%s: bintval=%d\n", __func__, 3892692ad7caSAdrian Chadd bintval); 389342946b7dSAdrian Chadd return (MIN(dwell_time, bintval - WPI_CHANNEL_TUNE_TIME * 2)); 3894692ad7caSAdrian Chadd } 3895692ad7caSAdrian Chadd 3896692ad7caSAdrian Chadd /* No association context? Default. */ 389742946b7dSAdrian Chadd return dwell_time; 3898692ad7caSAdrian Chadd } 3899692ad7caSAdrian Chadd 3900692ad7caSAdrian Chadd static uint16_t 3901692ad7caSAdrian Chadd wpi_get_passive_dwell_time(struct wpi_softc *sc, struct ieee80211_channel *c) 3902692ad7caSAdrian Chadd { 3903692ad7caSAdrian Chadd uint16_t passive; 3904692ad7caSAdrian Chadd 3905692ad7caSAdrian Chadd if (c == NULL || IEEE80211_IS_CHAN_2GHZ(c)) 3906692ad7caSAdrian Chadd passive = WPI_PASSIVE_DWELL_BASE + WPI_PASSIVE_DWELL_TIME_2GHZ; 3907692ad7caSAdrian Chadd else 3908692ad7caSAdrian Chadd passive = WPI_PASSIVE_DWELL_BASE + WPI_PASSIVE_DWELL_TIME_5GHZ; 3909692ad7caSAdrian Chadd 3910692ad7caSAdrian Chadd /* Clamp to the beacon interval if we're associated. */ 3911692ad7caSAdrian Chadd return (wpi_limit_dwell(sc, passive)); 3912692ad7caSAdrian Chadd } 3913692ad7caSAdrian Chadd 3914efccc3c6SAdrian Chadd static uint32_t 3915efccc3c6SAdrian Chadd wpi_get_scan_pause_time(uint32_t time, uint16_t bintval) 3916efccc3c6SAdrian Chadd { 3917efccc3c6SAdrian Chadd uint32_t mod = (time % bintval) * IEEE80211_DUR_TU; 3918efccc3c6SAdrian Chadd uint32_t nbeacons = time / bintval; 3919efccc3c6SAdrian Chadd 3920efccc3c6SAdrian Chadd if (mod > WPI_PAUSE_MAX_TIME) 3921efccc3c6SAdrian Chadd mod = WPI_PAUSE_MAX_TIME; 3922efccc3c6SAdrian Chadd 3923efccc3c6SAdrian Chadd return WPI_PAUSE_SCAN(nbeacons, mod); 3924efccc3c6SAdrian Chadd } 3925efccc3c6SAdrian Chadd 3926692ad7caSAdrian Chadd /* 3927692ad7caSAdrian Chadd * Send a scan request to the firmware. 3928692ad7caSAdrian Chadd */ 3929692ad7caSAdrian Chadd static int 3930692ad7caSAdrian Chadd wpi_scan(struct wpi_softc *sc, struct ieee80211_channel *c) 3931692ad7caSAdrian Chadd { 3932692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 3933692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 3934692ad7caSAdrian Chadd struct ieee80211_scan_state *ss = ic->ic_scan; 39353de934a7SAdrian Chadd struct ieee80211vap *vap = ss->ss_vap; 3936692ad7caSAdrian Chadd struct wpi_scan_hdr *hdr; 3937692ad7caSAdrian Chadd struct wpi_cmd_data *tx; 3938692ad7caSAdrian Chadd struct wpi_scan_essid *essids; 3939692ad7caSAdrian Chadd struct wpi_scan_chan *chan; 3940692ad7caSAdrian Chadd struct ieee80211_frame *wh; 3941692ad7caSAdrian Chadd struct ieee80211_rateset *rs; 3942692ad7caSAdrian Chadd uint16_t dwell_active, dwell_passive; 3943692ad7caSAdrian Chadd uint8_t *buf, *frm; 394442946b7dSAdrian Chadd int bgscan, bintval, buflen, error, i, nssid; 3945692ad7caSAdrian Chadd 3946692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 3947692ad7caSAdrian Chadd 3948692ad7caSAdrian Chadd /* 3949692ad7caSAdrian Chadd * We are absolutely not allowed to send a scan command when another 3950692ad7caSAdrian Chadd * scan command is pending. 3951692ad7caSAdrian Chadd */ 39520bc39fc6SAdrian Chadd if (callout_pending(&sc->scan_timeout)) { 3953692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: called whilst scanning!\n", 3954692ad7caSAdrian Chadd __func__); 395542946b7dSAdrian Chadd error = EAGAIN; 395642946b7dSAdrian Chadd goto fail; 395742946b7dSAdrian Chadd } 395896dadeb0SAdrian Chadd 395942946b7dSAdrian Chadd bgscan = wpi_check_bss_filter(sc); 396042946b7dSAdrian Chadd bintval = vap->iv_bss->ni_intval; 396142946b7dSAdrian Chadd if (bgscan != 0 && 396242946b7dSAdrian Chadd bintval < WPI_QUIET_TIME_DEFAULT + WPI_CHANNEL_TUNE_TIME * 2) { 396342946b7dSAdrian Chadd error = EOPNOTSUPP; 396442946b7dSAdrian Chadd goto fail; 3965692ad7caSAdrian Chadd } 3966692ad7caSAdrian Chadd 3967692ad7caSAdrian Chadd buf = malloc(WPI_SCAN_MAXSZ, M_DEVBUF, M_NOWAIT | M_ZERO); 3968692ad7caSAdrian Chadd if (buf == NULL) { 3969692ad7caSAdrian Chadd device_printf(sc->sc_dev, 3970692ad7caSAdrian Chadd "%s: could not allocate buffer for scan command\n", 3971692ad7caSAdrian Chadd __func__); 397296dadeb0SAdrian Chadd error = ENOMEM; 397396dadeb0SAdrian Chadd goto fail; 3974692ad7caSAdrian Chadd } 3975692ad7caSAdrian Chadd hdr = (struct wpi_scan_hdr *)buf; 3976692ad7caSAdrian Chadd 3977692ad7caSAdrian Chadd /* 3978692ad7caSAdrian Chadd * Move to the next channel if no packets are received within 10 msecs 3979692ad7caSAdrian Chadd * after sending the probe request. 3980692ad7caSAdrian Chadd */ 398142946b7dSAdrian Chadd hdr->quiet_time = htole16(WPI_QUIET_TIME_DEFAULT); 398242946b7dSAdrian Chadd hdr->quiet_threshold = htole16(1); 3983efccc3c6SAdrian Chadd 3984efccc3c6SAdrian Chadd if (bgscan != 0) { 3985692ad7caSAdrian Chadd /* 3986692ad7caSAdrian Chadd * Max needs to be greater than active and passive and quiet! 3987692ad7caSAdrian Chadd * It's also in microseconds! 3988692ad7caSAdrian Chadd */ 3989692ad7caSAdrian Chadd hdr->max_svc = htole32(250 * IEEE80211_DUR_TU); 3990efccc3c6SAdrian Chadd hdr->pause_svc = htole32(wpi_get_scan_pause_time(100, 3991efccc3c6SAdrian Chadd bintval)); 3992efccc3c6SAdrian Chadd } 3993efccc3c6SAdrian Chadd 3994692ad7caSAdrian Chadd hdr->filter = htole32(WPI_FILTER_MULTICAST | WPI_FILTER_BEACON); 3995692ad7caSAdrian Chadd 3996692ad7caSAdrian Chadd tx = (struct wpi_cmd_data *)(hdr + 1); 3997692ad7caSAdrian Chadd tx->flags = htole32(WPI_TX_AUTO_SEQ); 3998692ad7caSAdrian Chadd tx->id = WPI_ID_BROADCAST; 3999692ad7caSAdrian Chadd tx->lifetime = htole32(WPI_LIFETIME_INFINITE); 4000692ad7caSAdrian Chadd 4001692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_5GHZ(c)) { 4002692ad7caSAdrian Chadd /* Send probe requests at 6Mbps. */ 4003692ad7caSAdrian Chadd tx->plcp = wpi_ridx_to_plcp[WPI_RIDX_OFDM6]; 4004692ad7caSAdrian Chadd rs = &ic->ic_sup_rates[IEEE80211_MODE_11A]; 4005692ad7caSAdrian Chadd } else { 4006692ad7caSAdrian Chadd hdr->flags = htole32(WPI_RXON_24GHZ | WPI_RXON_AUTO); 4007692ad7caSAdrian Chadd /* Send probe requests at 1Mbps. */ 4008692ad7caSAdrian Chadd tx->plcp = wpi_ridx_to_plcp[WPI_RIDX_CCK1]; 4009692ad7caSAdrian Chadd rs = &ic->ic_sup_rates[IEEE80211_MODE_11G]; 4010692ad7caSAdrian Chadd } 4011692ad7caSAdrian Chadd 4012692ad7caSAdrian Chadd essids = (struct wpi_scan_essid *)(tx + 1); 4013692ad7caSAdrian Chadd nssid = MIN(ss->ss_nssid, WPI_SCAN_MAX_ESSIDS); 4014692ad7caSAdrian Chadd for (i = 0; i < nssid; i++) { 4015692ad7caSAdrian Chadd essids[i].id = IEEE80211_ELEMID_SSID; 4016692ad7caSAdrian Chadd essids[i].len = MIN(ss->ss_ssid[i].len, IEEE80211_NWID_LEN); 4017692ad7caSAdrian Chadd memcpy(essids[i].data, ss->ss_ssid[i].ssid, essids[i].len); 4018692ad7caSAdrian Chadd #ifdef WPI_DEBUG 4019692ad7caSAdrian Chadd if (sc->sc_debug & WPI_DEBUG_SCAN) { 4020692ad7caSAdrian Chadd printf("Scanning Essid: "); 4021692ad7caSAdrian Chadd ieee80211_print_essid(essids[i].data, essids[i].len); 4022692ad7caSAdrian Chadd printf("\n"); 4023692ad7caSAdrian Chadd } 4024692ad7caSAdrian Chadd #endif 4025692ad7caSAdrian Chadd } 4026692ad7caSAdrian Chadd 4027692ad7caSAdrian Chadd /* 4028692ad7caSAdrian Chadd * Build a probe request frame. Most of the following code is a 4029692ad7caSAdrian Chadd * copy & paste of what is done in net80211. 4030692ad7caSAdrian Chadd */ 4031692ad7caSAdrian Chadd wh = (struct ieee80211_frame *)(essids + WPI_SCAN_MAX_ESSIDS); 4032692ad7caSAdrian Chadd wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT | 4033692ad7caSAdrian Chadd IEEE80211_FC0_SUBTYPE_PROBE_REQ; 4034692ad7caSAdrian Chadd wh->i_fc[1] = IEEE80211_FC1_DIR_NODS; 4035692ad7caSAdrian Chadd IEEE80211_ADDR_COPY(wh->i_addr1, ifp->if_broadcastaddr); 40363de934a7SAdrian Chadd IEEE80211_ADDR_COPY(wh->i_addr2, vap->iv_myaddr); 4037692ad7caSAdrian Chadd IEEE80211_ADDR_COPY(wh->i_addr3, ifp->if_broadcastaddr); 4038692ad7caSAdrian Chadd *(uint16_t *)&wh->i_dur[0] = 0; /* filled by h/w */ 4039692ad7caSAdrian Chadd *(uint16_t *)&wh->i_seq[0] = 0; /* filled by h/w */ 4040692ad7caSAdrian Chadd 4041692ad7caSAdrian Chadd frm = (uint8_t *)(wh + 1); 4042692ad7caSAdrian Chadd frm = ieee80211_add_ssid(frm, NULL, 0); 4043692ad7caSAdrian Chadd frm = ieee80211_add_rates(frm, rs); 4044692ad7caSAdrian Chadd if (rs->rs_nrates > IEEE80211_RATE_SIZE) 4045692ad7caSAdrian Chadd frm = ieee80211_add_xrates(frm, rs); 4046692ad7caSAdrian Chadd 4047692ad7caSAdrian Chadd /* Set length of probe request. */ 4048692ad7caSAdrian Chadd tx->len = htole16(frm - (uint8_t *)wh); 4049692ad7caSAdrian Chadd 4050692ad7caSAdrian Chadd /* 4051692ad7caSAdrian Chadd * Construct information about the channel that we 4052692ad7caSAdrian Chadd * want to scan. The firmware expects this to be directly 4053692ad7caSAdrian Chadd * after the scan probe request 4054692ad7caSAdrian Chadd */ 4055692ad7caSAdrian Chadd chan = (struct wpi_scan_chan *)frm; 4056692ad7caSAdrian Chadd chan->chan = htole16(ieee80211_chan2ieee(ic, c)); 4057692ad7caSAdrian Chadd chan->flags = 0; 4058692ad7caSAdrian Chadd if (nssid) { 4059692ad7caSAdrian Chadd hdr->crc_threshold = WPI_SCAN_CRC_TH_DEFAULT; 4060692ad7caSAdrian Chadd chan->flags |= WPI_CHAN_NPBREQS(nssid); 4061692ad7caSAdrian Chadd } else 4062692ad7caSAdrian Chadd hdr->crc_threshold = WPI_SCAN_CRC_TH_NEVER; 4063692ad7caSAdrian Chadd 4064fae61c69SAdrian Chadd if (!IEEE80211_IS_CHAN_PASSIVE(c)) 4065692ad7caSAdrian Chadd chan->flags |= WPI_CHAN_ACTIVE; 4066692ad7caSAdrian Chadd 4067692ad7caSAdrian Chadd /* 4068692ad7caSAdrian Chadd * Calculate the active/passive dwell times. 4069692ad7caSAdrian Chadd */ 4070692ad7caSAdrian Chadd 4071692ad7caSAdrian Chadd dwell_active = wpi_get_active_dwell_time(sc, c, nssid); 4072692ad7caSAdrian Chadd dwell_passive = wpi_get_passive_dwell_time(sc, c); 4073692ad7caSAdrian Chadd 4074692ad7caSAdrian Chadd /* Make sure they're valid. */ 407542946b7dSAdrian Chadd if (dwell_active > dwell_passive) 407642946b7dSAdrian Chadd dwell_active = dwell_passive; 4077692ad7caSAdrian Chadd 4078692ad7caSAdrian Chadd chan->active = htole16(dwell_active); 4079692ad7caSAdrian Chadd chan->passive = htole16(dwell_passive); 4080692ad7caSAdrian Chadd 4081692ad7caSAdrian Chadd chan->dsp_gain = 0x6e; /* Default level */ 4082692ad7caSAdrian Chadd 4083692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_5GHZ(c)) 4084692ad7caSAdrian Chadd chan->rf_gain = 0x3b; 4085692ad7caSAdrian Chadd else 4086692ad7caSAdrian Chadd chan->rf_gain = 0x28; 4087692ad7caSAdrian Chadd 4088692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_SCAN, "Scanning %u Passive: %d\n", 4089fae61c69SAdrian Chadd chan->chan, IEEE80211_IS_CHAN_PASSIVE(c)); 4090692ad7caSAdrian Chadd 4091692ad7caSAdrian Chadd hdr->nchan++; 4092e948ddb6SAdrian Chadd 4093e948ddb6SAdrian Chadd if (hdr->nchan == 1 && sc->rxon.chan == chan->chan) { 4094e948ddb6SAdrian Chadd /* XXX Force probe request transmission. */ 4095e948ddb6SAdrian Chadd memcpy(chan + 1, chan, sizeof (struct wpi_scan_chan)); 4096e948ddb6SAdrian Chadd 4097e948ddb6SAdrian Chadd chan++; 4098e948ddb6SAdrian Chadd 4099e948ddb6SAdrian Chadd /* Reduce unnecessary delay. */ 4100e948ddb6SAdrian Chadd chan->flags = 0; 4101e948ddb6SAdrian Chadd chan->passive = chan->active = hdr->quiet_time; 4102e948ddb6SAdrian Chadd 4103e948ddb6SAdrian Chadd hdr->nchan++; 4104e948ddb6SAdrian Chadd } 4105e948ddb6SAdrian Chadd 4106692ad7caSAdrian Chadd chan++; 4107692ad7caSAdrian Chadd 4108692ad7caSAdrian Chadd buflen = (uint8_t *)chan - buf; 4109692ad7caSAdrian Chadd hdr->len = htole16(buflen); 4110692ad7caSAdrian Chadd 4111692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_CMD, "sending scan command nchan=%d\n", 4112692ad7caSAdrian Chadd hdr->nchan); 4113692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_SCAN, buf, buflen, 1); 4114692ad7caSAdrian Chadd free(buf, M_DEVBUF); 4115692ad7caSAdrian Chadd 411696dadeb0SAdrian Chadd if (error != 0) 411796dadeb0SAdrian Chadd goto fail; 411896dadeb0SAdrian Chadd 41190bc39fc6SAdrian Chadd callout_reset(&sc->scan_timeout, 5*hz, wpi_scan_timeout, sc); 4120692ad7caSAdrian Chadd 4121692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 4122692ad7caSAdrian Chadd 412396dadeb0SAdrian Chadd return 0; 412496dadeb0SAdrian Chadd 412596dadeb0SAdrian Chadd fail: DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 412696dadeb0SAdrian Chadd 41276607310bSBenjamin Close return error; 41286607310bSBenjamin Close } 41296607310bSBenjamin Close 4130692ad7caSAdrian Chadd static int 4131692ad7caSAdrian Chadd wpi_auth(struct wpi_softc *sc, struct ieee80211vap *vap) 4132692ad7caSAdrian Chadd { 4133692ad7caSAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 4134692ad7caSAdrian Chadd struct ieee80211_node *ni = vap->iv_bss; 41356b997e0cSAdrian Chadd struct ieee80211_channel *c = ni->ni_chan; 4136692ad7caSAdrian Chadd int error; 4137692ad7caSAdrian Chadd 4138446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 4139446685e4SAdrian Chadd 4140692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 4141692ad7caSAdrian Chadd 4142692ad7caSAdrian Chadd /* Update adapter configuration. */ 4143692ad7caSAdrian Chadd sc->rxon.associd = 0; 4144692ad7caSAdrian Chadd sc->rxon.filter &= ~htole32(WPI_FILTER_BSS); 4145692ad7caSAdrian Chadd IEEE80211_ADDR_COPY(sc->rxon.bssid, ni->ni_bssid); 41466b997e0cSAdrian Chadd sc->rxon.chan = ieee80211_chan2ieee(ic, c); 4147692ad7caSAdrian Chadd sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF); 41486b997e0cSAdrian Chadd if (IEEE80211_IS_CHAN_2GHZ(c)) 4149692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ); 4150692ad7caSAdrian Chadd if (ic->ic_flags & IEEE80211_F_SHSLOT) 4151692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_SHSLOT); 4152692ad7caSAdrian Chadd if (ic->ic_flags & IEEE80211_F_SHPREAMBLE) 4153692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_SHPREAMBLE); 41546b997e0cSAdrian Chadd if (IEEE80211_IS_CHAN_A(c)) { 4155692ad7caSAdrian Chadd sc->rxon.cck_mask = 0; 4156692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0x15; 41576b997e0cSAdrian Chadd } else if (IEEE80211_IS_CHAN_B(c)) { 4158692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x03; 4159692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0; 4160692ad7caSAdrian Chadd } else { 4161692ad7caSAdrian Chadd /* Assume 802.11b/g. */ 4162692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x0f; 4163692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0x15; 4164692ad7caSAdrian Chadd } 4165692ad7caSAdrian Chadd 4166692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, "rxon chan %d flags %x cck %x ofdm %x\n", 4167692ad7caSAdrian Chadd sc->rxon.chan, sc->rxon.flags, sc->rxon.cck_mask, 4168692ad7caSAdrian Chadd sc->rxon.ofdm_mask); 4169692ad7caSAdrian Chadd 4170692ad7caSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { 4171692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not send RXON\n", 4172692ad7caSAdrian Chadd __func__); 4173692ad7caSAdrian Chadd } 4174692ad7caSAdrian Chadd 4175692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 4176692ad7caSAdrian Chadd 4177446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 4178446685e4SAdrian Chadd 4179692ad7caSAdrian Chadd return error; 4180692ad7caSAdrian Chadd } 4181692ad7caSAdrian Chadd 4182692ad7caSAdrian Chadd static int 41836f8421f8SAdrian Chadd wpi_config_beacon(struct wpi_vap *wvp) 41846f8421f8SAdrian Chadd { 4185d036bb20SAdrian Chadd struct ieee80211com *ic = wvp->wv_vap.iv_ic; 41866f8421f8SAdrian Chadd struct ieee80211_beacon_offsets *bo = &wvp->wv_boff; 41876f8421f8SAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 41886f8421f8SAdrian Chadd struct wpi_softc *sc = ic->ic_ifp->if_softc; 41896f8421f8SAdrian Chadd struct wpi_cmd_beacon *cmd = (struct wpi_cmd_beacon *)&bcn->data; 41906f8421f8SAdrian Chadd struct ieee80211_tim_ie *tie; 41916f8421f8SAdrian Chadd struct mbuf *m; 41926f8421f8SAdrian Chadd uint8_t *ptr; 41936f8421f8SAdrian Chadd int error; 41946f8421f8SAdrian Chadd 41956f8421f8SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 41966f8421f8SAdrian Chadd 4197b56fed3dSAdrian Chadd WPI_VAP_LOCK_ASSERT(wvp); 41986f8421f8SAdrian Chadd 41996f8421f8SAdrian Chadd cmd->len = htole16(bcn->m->m_pkthdr.len); 42006f8421f8SAdrian Chadd cmd->plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ? 42016f8421f8SAdrian Chadd wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1]; 42026f8421f8SAdrian Chadd 42036f8421f8SAdrian Chadd /* XXX seems to be unused */ 42046f8421f8SAdrian Chadd if (*(bo->bo_tim) == IEEE80211_ELEMID_TIM) { 42056f8421f8SAdrian Chadd tie = (struct ieee80211_tim_ie *) bo->bo_tim; 42066f8421f8SAdrian Chadd ptr = mtod(bcn->m, uint8_t *); 42076f8421f8SAdrian Chadd 42086f8421f8SAdrian Chadd cmd->tim = htole16(bo->bo_tim - ptr); 42096f8421f8SAdrian Chadd cmd->timsz = tie->tim_len; 42106f8421f8SAdrian Chadd } 42116f8421f8SAdrian Chadd 42126f8421f8SAdrian Chadd /* Necessary for recursion in ieee80211_beacon_update(). */ 42136f8421f8SAdrian Chadd m = bcn->m; 42146f8421f8SAdrian Chadd bcn->m = m_dup(m, M_NOWAIT); 42156f8421f8SAdrian Chadd if (bcn->m == NULL) { 42166f8421f8SAdrian Chadd device_printf(sc->sc_dev, 42176f8421f8SAdrian Chadd "%s: could not copy beacon frame\n", __func__); 42186f8421f8SAdrian Chadd error = ENOMEM; 42196f8421f8SAdrian Chadd goto end; 42206f8421f8SAdrian Chadd } 42216f8421f8SAdrian Chadd 42226f8421f8SAdrian Chadd if ((error = wpi_cmd2(sc, bcn)) != 0) { 42236f8421f8SAdrian Chadd device_printf(sc->sc_dev, 42246f8421f8SAdrian Chadd "%s: could not update beacon frame, error %d", __func__, 42256f8421f8SAdrian Chadd error); 42266f8421f8SAdrian Chadd } 42276f8421f8SAdrian Chadd 42286f8421f8SAdrian Chadd /* Restore mbuf. */ 42296f8421f8SAdrian Chadd end: bcn->m = m; 42306f8421f8SAdrian Chadd 42316f8421f8SAdrian Chadd return error; 42326f8421f8SAdrian Chadd } 42336f8421f8SAdrian Chadd 42346f8421f8SAdrian Chadd static int 4235692ad7caSAdrian Chadd wpi_setup_beacon(struct wpi_softc *sc, struct ieee80211_node *ni) 4236692ad7caSAdrian Chadd { 4237565248e2SAdrian Chadd struct wpi_vap *wvp = WPI_VAP(ni->ni_vap); 4238692ad7caSAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 42396f8421f8SAdrian Chadd struct ieee80211_beacon_offsets *bo = &wvp->wv_boff; 4240692ad7caSAdrian Chadd struct mbuf *m; 42416f8421f8SAdrian Chadd int error; 4242692ad7caSAdrian Chadd 4243692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4244692ad7caSAdrian Chadd 4245692ad7caSAdrian Chadd if (ni->ni_chan == IEEE80211_CHAN_ANYC) 4246692ad7caSAdrian Chadd return EINVAL; 4247692ad7caSAdrian Chadd 42486f8421f8SAdrian Chadd m = ieee80211_beacon_alloc(ni, bo); 4249692ad7caSAdrian Chadd if (m == NULL) { 4250692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4251692ad7caSAdrian Chadd "%s: could not allocate beacon frame\n", __func__); 4252692ad7caSAdrian Chadd return ENOMEM; 4253692ad7caSAdrian Chadd } 4254692ad7caSAdrian Chadd 4255b56fed3dSAdrian Chadd WPI_VAP_LOCK(wvp); 42566f8421f8SAdrian Chadd if (bcn->m != NULL) 42576f8421f8SAdrian Chadd m_freem(bcn->m); 4258692ad7caSAdrian Chadd 4259692ad7caSAdrian Chadd bcn->m = m; 4260692ad7caSAdrian Chadd 42616f8421f8SAdrian Chadd error = wpi_config_beacon(wvp); 4262b56fed3dSAdrian Chadd WPI_VAP_UNLOCK(wvp); 42636f8421f8SAdrian Chadd 42646f8421f8SAdrian Chadd return error; 4265692ad7caSAdrian Chadd } 4266692ad7caSAdrian Chadd 4267692ad7caSAdrian Chadd static void 4268692ad7caSAdrian Chadd wpi_update_beacon(struct ieee80211vap *vap, int item) 4269692ad7caSAdrian Chadd { 42705f25a0e9SAdrian Chadd struct wpi_softc *sc = vap->iv_ic->ic_ifp->if_softc; 42716f8421f8SAdrian Chadd struct wpi_vap *wvp = WPI_VAP(vap); 42726f8421f8SAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 42736f8421f8SAdrian Chadd struct ieee80211_beacon_offsets *bo = &wvp->wv_boff; 4274692ad7caSAdrian Chadd struct ieee80211_node *ni = vap->iv_bss; 42756f8421f8SAdrian Chadd int mcast = 0; 42766f8421f8SAdrian Chadd 42776f8421f8SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 4278692ad7caSAdrian Chadd 4279b56fed3dSAdrian Chadd WPI_VAP_LOCK(wvp); 42806f8421f8SAdrian Chadd if (bcn->m == NULL) { 42816f8421f8SAdrian Chadd bcn->m = ieee80211_beacon_alloc(ni, bo); 42826f8421f8SAdrian Chadd if (bcn->m == NULL) { 4283692ad7caSAdrian Chadd device_printf(sc->sc_dev, 42846f8421f8SAdrian Chadd "%s: could not allocate beacon frame\n", __func__); 42856f8421f8SAdrian Chadd 42866f8421f8SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, 42876f8421f8SAdrian Chadd __func__); 42886f8421f8SAdrian Chadd 4289b56fed3dSAdrian Chadd WPI_VAP_UNLOCK(wvp); 42906f8421f8SAdrian Chadd return; 42916f8421f8SAdrian Chadd } 4292692ad7caSAdrian Chadd } 4293b56fed3dSAdrian Chadd WPI_VAP_UNLOCK(wvp); 42946f8421f8SAdrian Chadd 42956f8421f8SAdrian Chadd if (item == IEEE80211_BEACON_TIM) 42966f8421f8SAdrian Chadd mcast = 1; /* TODO */ 42976f8421f8SAdrian Chadd 42986f8421f8SAdrian Chadd setbit(bo->bo_flags, item); 42996f8421f8SAdrian Chadd ieee80211_beacon_update(ni, bo, bcn->m, mcast); 43006f8421f8SAdrian Chadd 4301b56fed3dSAdrian Chadd WPI_VAP_LOCK(wvp); 43026f8421f8SAdrian Chadd wpi_config_beacon(wvp); 4303b56fed3dSAdrian Chadd WPI_VAP_UNLOCK(wvp); 43046f8421f8SAdrian Chadd 43056f8421f8SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 4306692ad7caSAdrian Chadd } 4307692ad7caSAdrian Chadd 4308d138d3baSAdrian Chadd static void 4309d138d3baSAdrian Chadd wpi_newassoc(struct ieee80211_node *ni, int isnew) 4310d138d3baSAdrian Chadd { 4311d138d3baSAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 4312d138d3baSAdrian Chadd struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc; 4313d138d3baSAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 4314d138d3baSAdrian Chadd int error; 4315d138d3baSAdrian Chadd 4316d138d3baSAdrian Chadd WPI_NT_LOCK(sc); 4317d138d3baSAdrian Chadd 4318d138d3baSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4319d138d3baSAdrian Chadd 4320d138d3baSAdrian Chadd if (vap->iv_opmode != IEEE80211_M_STA && wn->id == WPI_ID_UNDEFINED) { 4321d138d3baSAdrian Chadd if ((error = wpi_add_ibss_node(sc, ni)) != 0) { 4322d138d3baSAdrian Chadd device_printf(sc->sc_dev, 4323d138d3baSAdrian Chadd "%s: could not add IBSS node, error %d\n", 4324d138d3baSAdrian Chadd __func__, error); 4325d138d3baSAdrian Chadd } 4326d138d3baSAdrian Chadd } 4327d138d3baSAdrian Chadd WPI_NT_UNLOCK(sc); 4328d138d3baSAdrian Chadd } 4329d138d3baSAdrian Chadd 4330692ad7caSAdrian Chadd static int 4331692ad7caSAdrian Chadd wpi_run(struct wpi_softc *sc, struct ieee80211vap *vap) 4332692ad7caSAdrian Chadd { 4333692ad7caSAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 4334692ad7caSAdrian Chadd struct ieee80211_node *ni = vap->iv_bss; 43356b997e0cSAdrian Chadd struct ieee80211_channel *c = ni->ni_chan; 4336692ad7caSAdrian Chadd int error; 4337692ad7caSAdrian Chadd 4338692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 4339692ad7caSAdrian Chadd 4340692ad7caSAdrian Chadd if (vap->iv_opmode == IEEE80211_M_MONITOR) { 4341692ad7caSAdrian Chadd /* Link LED blinks while monitoring. */ 4342692ad7caSAdrian Chadd wpi_set_led(sc, WPI_LED_LINK, 5, 5); 4343692ad7caSAdrian Chadd return 0; 4344692ad7caSAdrian Chadd } 4345692ad7caSAdrian Chadd 4346692ad7caSAdrian Chadd /* XXX kernel panic workaround */ 43476b997e0cSAdrian Chadd if (c == IEEE80211_CHAN_ANYC) { 4348692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: incomplete configuration\n", 4349692ad7caSAdrian Chadd __func__); 4350692ad7caSAdrian Chadd return EINVAL; 4351692ad7caSAdrian Chadd } 4352692ad7caSAdrian Chadd 4353692ad7caSAdrian Chadd if ((error = wpi_set_timing(sc, ni)) != 0) { 4354692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4355692ad7caSAdrian Chadd "%s: could not set timing, error %d\n", __func__, error); 4356692ad7caSAdrian Chadd return error; 4357692ad7caSAdrian Chadd } 4358692ad7caSAdrian Chadd 4359692ad7caSAdrian Chadd /* Update adapter configuration. */ 4360446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 4361692ad7caSAdrian Chadd IEEE80211_ADDR_COPY(sc->rxon.bssid, ni->ni_bssid); 4362692ad7caSAdrian Chadd sc->rxon.associd = htole16(IEEE80211_NODE_AID(ni)); 43636b997e0cSAdrian Chadd sc->rxon.chan = ieee80211_chan2ieee(ic, c); 4364692ad7caSAdrian Chadd sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF); 43656b997e0cSAdrian Chadd if (IEEE80211_IS_CHAN_2GHZ(c)) 4366692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ); 4367692ad7caSAdrian Chadd if (ic->ic_flags & IEEE80211_F_SHSLOT) 4368692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_SHSLOT); 4369692ad7caSAdrian Chadd if (ic->ic_flags & IEEE80211_F_SHPREAMBLE) 4370692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_SHPREAMBLE); 43716b997e0cSAdrian Chadd if (IEEE80211_IS_CHAN_A(c)) { 4372692ad7caSAdrian Chadd sc->rxon.cck_mask = 0; 4373692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0x15; 43746b997e0cSAdrian Chadd } else if (IEEE80211_IS_CHAN_B(c)) { 4375692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x03; 4376692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0; 4377692ad7caSAdrian Chadd } else { 4378692ad7caSAdrian Chadd /* Assume 802.11b/g. */ 4379692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x0f; 4380692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0x15; 4381692ad7caSAdrian Chadd } 4382692ad7caSAdrian Chadd sc->rxon.filter |= htole32(WPI_FILTER_BSS); 4383692ad7caSAdrian Chadd 4384692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, "rxon chan %d flags %x\n", 4385692ad7caSAdrian Chadd sc->rxon.chan, sc->rxon.flags); 4386692ad7caSAdrian Chadd 4387692ad7caSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { 4388692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not send RXON\n", 4389692ad7caSAdrian Chadd __func__); 4390692ad7caSAdrian Chadd return error; 4391692ad7caSAdrian Chadd } 4392692ad7caSAdrian Chadd 4393446685e4SAdrian Chadd /* Start periodic calibration timer. */ 4394446685e4SAdrian Chadd callout_reset(&sc->calib_to, 60*hz, wpi_calib_timeout, sc); 4395446685e4SAdrian Chadd 4396446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 4397446685e4SAdrian Chadd 4398726ddc26SAdrian Chadd if (vap->iv_opmode == IEEE80211_M_IBSS || 4399726ddc26SAdrian Chadd vap->iv_opmode == IEEE80211_M_HOSTAP) { 4400692ad7caSAdrian Chadd if ((error = wpi_setup_beacon(sc, ni)) != 0) { 4401692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4402692ad7caSAdrian Chadd "%s: could not setup beacon, error %d\n", __func__, 4403692ad7caSAdrian Chadd error); 4404692ad7caSAdrian Chadd return error; 4405692ad7caSAdrian Chadd } 4406692ad7caSAdrian Chadd } 4407692ad7caSAdrian Chadd 4408692ad7caSAdrian Chadd if (vap->iv_opmode == IEEE80211_M_STA) { 4409692ad7caSAdrian Chadd /* Add BSS node. */ 44107964dd56SAdrian Chadd WPI_NT_LOCK(sc); 44110ebca245SAdrian Chadd error = wpi_add_sta_node(sc, ni); 44127964dd56SAdrian Chadd WPI_NT_UNLOCK(sc); 44130ebca245SAdrian Chadd if (error != 0) { 4414692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4415692ad7caSAdrian Chadd "%s: could not add BSS node, error %d\n", __func__, 4416692ad7caSAdrian Chadd error); 4417692ad7caSAdrian Chadd return error; 4418692ad7caSAdrian Chadd } 4419692ad7caSAdrian Chadd } 4420692ad7caSAdrian Chadd 4421692ad7caSAdrian Chadd /* Link LED always on while associated. */ 4422692ad7caSAdrian Chadd wpi_set_led(sc, WPI_LED_LINK, 0, 1); 4423692ad7caSAdrian Chadd 4424692ad7caSAdrian Chadd /* Enable power-saving mode if requested by user. */ 44250b90e845SAdrian Chadd if ((vap->iv_flags & IEEE80211_F_PMGTON) && 44260b90e845SAdrian Chadd vap->iv_opmode != IEEE80211_M_IBSS) 4427692ad7caSAdrian Chadd (void)wpi_set_pslevel(sc, 0, 3, 1); 4428692ad7caSAdrian Chadd 4429692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 4430692ad7caSAdrian Chadd 4431692ad7caSAdrian Chadd return 0; 4432692ad7caSAdrian Chadd } 4433692ad7caSAdrian Chadd 4434692ad7caSAdrian Chadd static int 4435d29fcfb7SAdrian Chadd wpi_load_key(struct ieee80211_node *ni, const struct ieee80211_key *k) 4436692ad7caSAdrian Chadd { 4437692ad7caSAdrian Chadd const struct ieee80211_cipher *cip = k->wk_cipher; 4438d29fcfb7SAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 4439d29fcfb7SAdrian Chadd struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc; 4440a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 4441692ad7caSAdrian Chadd struct wpi_node_info node; 4442692ad7caSAdrian Chadd uint16_t kflags; 4443692ad7caSAdrian Chadd int error; 4444692ad7caSAdrian Chadd 4445692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4446692ad7caSAdrian Chadd 4447d29fcfb7SAdrian Chadd if (wpi_check_node_entry(sc, wn->id) == 0) { 4448d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, "%s: node does not exist\n", 4449d29fcfb7SAdrian Chadd __func__); 4450d29fcfb7SAdrian Chadd return 0; 4451692ad7caSAdrian Chadd } 4452692ad7caSAdrian Chadd 4453d29fcfb7SAdrian Chadd switch (cip->ic_cipher) { 4454d29fcfb7SAdrian Chadd case IEEE80211_CIPHER_AES_CCM: 4455d29fcfb7SAdrian Chadd kflags = WPI_KFLAG_CCMP; 4456d29fcfb7SAdrian Chadd break; 4457d29fcfb7SAdrian Chadd 4458d29fcfb7SAdrian Chadd default: 4459d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, "%s: unknown cipher %d\n", __func__, 4460d29fcfb7SAdrian Chadd cip->ic_cipher); 4461692ad7caSAdrian Chadd return 0; 4462d29fcfb7SAdrian Chadd } 4463692ad7caSAdrian Chadd 4464692ad7caSAdrian Chadd kflags |= WPI_KFLAG_KID(k->wk_keyix); 4465692ad7caSAdrian Chadd if (k->wk_flags & IEEE80211_KEY_GROUP) 4466692ad7caSAdrian Chadd kflags |= WPI_KFLAG_MULTICAST; 4467692ad7caSAdrian Chadd 44686607310bSBenjamin Close memset(&node, 0, sizeof node); 4469692ad7caSAdrian Chadd node.id = wn->id; 4470692ad7caSAdrian Chadd node.control = WPI_NODE_UPDATE; 4471692ad7caSAdrian Chadd node.flags = WPI_FLAG_KEY_SET; 4472692ad7caSAdrian Chadd node.kflags = htole16(kflags); 4473692ad7caSAdrian Chadd memcpy(node.key, k->wk_key, k->wk_keylen); 4474d29fcfb7SAdrian Chadd again: 4475d29fcfb7SAdrian Chadd DPRINTF(sc, WPI_DEBUG_KEY, 4476d29fcfb7SAdrian Chadd "%s: setting %s key id %d for node %d (%s)\n", __func__, 4477d29fcfb7SAdrian Chadd (kflags & WPI_KFLAG_MULTICAST) ? "group" : "ucast", k->wk_keyix, 4478d29fcfb7SAdrian Chadd node.id, ether_sprintf(ni->ni_macaddr)); 4479692ad7caSAdrian Chadd 4480692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1); 44816607310bSBenjamin Close if (error != 0) { 4482692ad7caSAdrian Chadd device_printf(sc->sc_dev, "can't update node info, error %d\n", 4483692ad7caSAdrian Chadd error); 4484d29fcfb7SAdrian Chadd return !error; 4485d29fcfb7SAdrian Chadd } 4486d29fcfb7SAdrian Chadd 4487d29fcfb7SAdrian Chadd if (!(kflags & WPI_KFLAG_MULTICAST) && &vap->iv_nw_keys[0] <= k && 4488d29fcfb7SAdrian Chadd k < &vap->iv_nw_keys[IEEE80211_WEP_NKID]) { 4489d29fcfb7SAdrian Chadd kflags |= WPI_KFLAG_MULTICAST; 4490d29fcfb7SAdrian Chadd node.kflags = htole16(kflags); 4491d29fcfb7SAdrian Chadd 4492d29fcfb7SAdrian Chadd goto again; 4493692ad7caSAdrian Chadd } 4494692ad7caSAdrian Chadd 4495692ad7caSAdrian Chadd return 1; 4496692ad7caSAdrian Chadd } 4497692ad7caSAdrian Chadd 4498d29fcfb7SAdrian Chadd static void 4499d29fcfb7SAdrian Chadd wpi_load_key_cb(void *arg, struct ieee80211_node *ni) 4500d29fcfb7SAdrian Chadd { 4501d29fcfb7SAdrian Chadd const struct ieee80211_key *k = arg; 4502d29fcfb7SAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 4503d29fcfb7SAdrian Chadd struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc; 4504d29fcfb7SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 4505d29fcfb7SAdrian Chadd int error; 4506d29fcfb7SAdrian Chadd 4507d29fcfb7SAdrian Chadd if (vap->iv_bss == ni && wn->id == WPI_ID_UNDEFINED) 4508d29fcfb7SAdrian Chadd return; 4509d29fcfb7SAdrian Chadd 4510d29fcfb7SAdrian Chadd WPI_NT_LOCK(sc); 4511d29fcfb7SAdrian Chadd error = wpi_load_key(ni, k); 4512d29fcfb7SAdrian Chadd WPI_NT_UNLOCK(sc); 4513d29fcfb7SAdrian Chadd 4514d29fcfb7SAdrian Chadd if (error == 0) { 4515d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, "%s: error while setting key\n", 4516d29fcfb7SAdrian Chadd __func__); 4517d29fcfb7SAdrian Chadd } 4518d29fcfb7SAdrian Chadd } 4519d29fcfb7SAdrian Chadd 4520692ad7caSAdrian Chadd static int 4521d29fcfb7SAdrian Chadd wpi_set_global_keys(struct ieee80211_node *ni) 4522692ad7caSAdrian Chadd { 4523d29fcfb7SAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 4524d29fcfb7SAdrian Chadd struct ieee80211_key *wk = &vap->iv_nw_keys[0]; 4525d29fcfb7SAdrian Chadd int error = 1; 4526d29fcfb7SAdrian Chadd 4527d29fcfb7SAdrian Chadd for (; wk < &vap->iv_nw_keys[IEEE80211_WEP_NKID] && error; wk++) 4528d29fcfb7SAdrian Chadd if (wk->wk_keyix != IEEE80211_KEYIX_NONE) 4529d29fcfb7SAdrian Chadd error = wpi_load_key(ni, wk); 4530d29fcfb7SAdrian Chadd 4531d29fcfb7SAdrian Chadd return !error; 4532d29fcfb7SAdrian Chadd } 4533d29fcfb7SAdrian Chadd 4534d29fcfb7SAdrian Chadd static int 4535d29fcfb7SAdrian Chadd wpi_del_key(struct ieee80211_node *ni, const struct ieee80211_key *k) 4536d29fcfb7SAdrian Chadd { 4537d29fcfb7SAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 4538d29fcfb7SAdrian Chadd struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc; 4539a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 4540692ad7caSAdrian Chadd struct wpi_node_info node; 4541d29fcfb7SAdrian Chadd uint16_t kflags; 4542d29fcfb7SAdrian Chadd int error; 4543692ad7caSAdrian Chadd 4544692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4545692ad7caSAdrian Chadd 4546d29fcfb7SAdrian Chadd if (wpi_check_node_entry(sc, wn->id) == 0) { 4547d29fcfb7SAdrian Chadd DPRINTF(sc, WPI_DEBUG_KEY, "%s: node was removed\n", __func__); 4548d29fcfb7SAdrian Chadd return 1; /* Nothing to do. */ 4549692ad7caSAdrian Chadd } 4550692ad7caSAdrian Chadd 4551d29fcfb7SAdrian Chadd kflags = WPI_KFLAG_KID(k->wk_keyix); 4552d29fcfb7SAdrian Chadd if (k->wk_flags & IEEE80211_KEY_GROUP) 4553d29fcfb7SAdrian Chadd kflags |= WPI_KFLAG_MULTICAST; 4554692ad7caSAdrian Chadd 4555692ad7caSAdrian Chadd memset(&node, 0, sizeof node); 4556692ad7caSAdrian Chadd node.id = wn->id; 4557692ad7caSAdrian Chadd node.control = WPI_NODE_UPDATE; 4558692ad7caSAdrian Chadd node.flags = WPI_FLAG_KEY_SET; 4559d29fcfb7SAdrian Chadd node.kflags = htole16(kflags); 4560d29fcfb7SAdrian Chadd again: 4561d29fcfb7SAdrian Chadd DPRINTF(sc, WPI_DEBUG_KEY, "%s: deleting %s key %d for node %d (%s)\n", 4562d29fcfb7SAdrian Chadd __func__, (kflags & WPI_KFLAG_MULTICAST) ? "group" : "ucast", 4563d29fcfb7SAdrian Chadd k->wk_keyix, node.id, ether_sprintf(ni->ni_macaddr)); 4564692ad7caSAdrian Chadd 4565d29fcfb7SAdrian Chadd error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1); 4566d29fcfb7SAdrian Chadd if (error != 0) { 4567d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, "can't update node info, error %d\n", 4568d29fcfb7SAdrian Chadd error); 4569d29fcfb7SAdrian Chadd return !error; 4570d29fcfb7SAdrian Chadd } 4571d29fcfb7SAdrian Chadd 4572d29fcfb7SAdrian Chadd if (!(kflags & WPI_KFLAG_MULTICAST) && &vap->iv_nw_keys[0] <= k && 4573d29fcfb7SAdrian Chadd k < &vap->iv_nw_keys[IEEE80211_WEP_NKID]) { 4574d29fcfb7SAdrian Chadd kflags |= WPI_KFLAG_MULTICAST; 4575d29fcfb7SAdrian Chadd node.kflags = htole16(kflags); 4576d29fcfb7SAdrian Chadd 4577d29fcfb7SAdrian Chadd goto again; 4578d29fcfb7SAdrian Chadd } 4579692ad7caSAdrian Chadd 4580692ad7caSAdrian Chadd return 1; 4581692ad7caSAdrian Chadd } 4582692ad7caSAdrian Chadd 4583d29fcfb7SAdrian Chadd static void 4584d29fcfb7SAdrian Chadd wpi_del_key_cb(void *arg, struct ieee80211_node *ni) 4585d29fcfb7SAdrian Chadd { 4586d29fcfb7SAdrian Chadd const struct ieee80211_key *k = arg; 4587d29fcfb7SAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 4588d29fcfb7SAdrian Chadd struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc; 4589d29fcfb7SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 4590d29fcfb7SAdrian Chadd int error; 4591d29fcfb7SAdrian Chadd 4592d29fcfb7SAdrian Chadd if (vap->iv_bss == ni && wn->id == WPI_ID_UNDEFINED) 4593d29fcfb7SAdrian Chadd return; 4594d29fcfb7SAdrian Chadd 4595d29fcfb7SAdrian Chadd WPI_NT_LOCK(sc); 4596d29fcfb7SAdrian Chadd error = wpi_del_key(ni, k); 4597d29fcfb7SAdrian Chadd WPI_NT_UNLOCK(sc); 4598d29fcfb7SAdrian Chadd 4599d29fcfb7SAdrian Chadd if (error == 0) { 4600d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, "%s: error while deleting key\n", 4601d29fcfb7SAdrian Chadd __func__); 4602d29fcfb7SAdrian Chadd } 4603d29fcfb7SAdrian Chadd } 4604d29fcfb7SAdrian Chadd 4605d29fcfb7SAdrian Chadd static int 4606d29fcfb7SAdrian Chadd wpi_process_key(struct ieee80211vap *vap, const struct ieee80211_key *k, 4607d29fcfb7SAdrian Chadd int set) 4608d29fcfb7SAdrian Chadd { 4609d29fcfb7SAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 4610d29fcfb7SAdrian Chadd struct wpi_softc *sc = ic->ic_ifp->if_softc; 4611d29fcfb7SAdrian Chadd struct wpi_vap *wvp = WPI_VAP(vap); 4612d29fcfb7SAdrian Chadd struct ieee80211_node *ni; 4613d29fcfb7SAdrian Chadd int error, ni_ref = 0; 4614d29fcfb7SAdrian Chadd 4615d29fcfb7SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4616d29fcfb7SAdrian Chadd 4617d29fcfb7SAdrian Chadd if (k->wk_flags & IEEE80211_KEY_SWCRYPT) { 4618d29fcfb7SAdrian Chadd /* Not for us. */ 4619d29fcfb7SAdrian Chadd return 1; 4620d29fcfb7SAdrian Chadd } 4621d29fcfb7SAdrian Chadd 4622d29fcfb7SAdrian Chadd if (!(k->wk_flags & IEEE80211_KEY_RECV)) { 4623d29fcfb7SAdrian Chadd /* XMIT keys are handled in wpi_tx_data(). */ 4624d29fcfb7SAdrian Chadd return 1; 4625d29fcfb7SAdrian Chadd } 4626d29fcfb7SAdrian Chadd 4627d29fcfb7SAdrian Chadd /* Handle group keys. */ 4628d29fcfb7SAdrian Chadd if (&vap->iv_nw_keys[0] <= k && 4629d29fcfb7SAdrian Chadd k < &vap->iv_nw_keys[IEEE80211_WEP_NKID]) { 4630d29fcfb7SAdrian Chadd WPI_NT_LOCK(sc); 4631d29fcfb7SAdrian Chadd if (set) 4632d29fcfb7SAdrian Chadd wvp->wv_gtk |= WPI_VAP_KEY(k->wk_keyix); 4633d29fcfb7SAdrian Chadd else 4634d29fcfb7SAdrian Chadd wvp->wv_gtk &= ~WPI_VAP_KEY(k->wk_keyix); 4635d29fcfb7SAdrian Chadd WPI_NT_UNLOCK(sc); 4636d29fcfb7SAdrian Chadd 4637d29fcfb7SAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN) { 4638d29fcfb7SAdrian Chadd ieee80211_iterate_nodes(&ic->ic_sta, 463969a2ec4aSKonstantin Belousov set ? wpi_load_key_cb : wpi_del_key_cb, 464069a2ec4aSKonstantin Belousov __DECONST(void *, k)); 4641d29fcfb7SAdrian Chadd } 4642d29fcfb7SAdrian Chadd 4643d29fcfb7SAdrian Chadd return 1; 4644d29fcfb7SAdrian Chadd } 4645d29fcfb7SAdrian Chadd 4646d29fcfb7SAdrian Chadd switch (vap->iv_opmode) { 4647d29fcfb7SAdrian Chadd case IEEE80211_M_STA: 4648d29fcfb7SAdrian Chadd ni = vap->iv_bss; 4649d29fcfb7SAdrian Chadd break; 4650d29fcfb7SAdrian Chadd 4651d29fcfb7SAdrian Chadd case IEEE80211_M_IBSS: 4652d29fcfb7SAdrian Chadd case IEEE80211_M_AHDEMO: 4653726ddc26SAdrian Chadd case IEEE80211_M_HOSTAP: 4654d29fcfb7SAdrian Chadd ni = ieee80211_find_vap_node(&ic->ic_sta, vap, k->wk_macaddr); 4655d29fcfb7SAdrian Chadd if (ni == NULL) 4656d29fcfb7SAdrian Chadd return 0; /* should not happen */ 4657d29fcfb7SAdrian Chadd 4658d29fcfb7SAdrian Chadd ni_ref = 1; 4659d29fcfb7SAdrian Chadd break; 4660d29fcfb7SAdrian Chadd 4661d29fcfb7SAdrian Chadd default: 4662d29fcfb7SAdrian Chadd device_printf(sc->sc_dev, "%s: unknown opmode %d\n", __func__, 4663d29fcfb7SAdrian Chadd vap->iv_opmode); 4664d29fcfb7SAdrian Chadd return 0; 4665d29fcfb7SAdrian Chadd } 4666d29fcfb7SAdrian Chadd 4667d29fcfb7SAdrian Chadd WPI_NT_LOCK(sc); 4668d29fcfb7SAdrian Chadd if (set) 4669d29fcfb7SAdrian Chadd error = wpi_load_key(ni, k); 4670d29fcfb7SAdrian Chadd else 4671d29fcfb7SAdrian Chadd error = wpi_del_key(ni, k); 4672d29fcfb7SAdrian Chadd WPI_NT_UNLOCK(sc); 4673d29fcfb7SAdrian Chadd 4674d29fcfb7SAdrian Chadd if (ni_ref) 4675d29fcfb7SAdrian Chadd ieee80211_node_decref(ni); 4676d29fcfb7SAdrian Chadd 4677d29fcfb7SAdrian Chadd return error; 4678d29fcfb7SAdrian Chadd } 4679d29fcfb7SAdrian Chadd 4680d29fcfb7SAdrian Chadd static int 4681d29fcfb7SAdrian Chadd wpi_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k, 4682d29fcfb7SAdrian Chadd const uint8_t mac[IEEE80211_ADDR_LEN]) 4683d29fcfb7SAdrian Chadd { 4684d29fcfb7SAdrian Chadd return wpi_process_key(vap, k, 1); 4685d29fcfb7SAdrian Chadd } 4686d29fcfb7SAdrian Chadd 4687d29fcfb7SAdrian Chadd static int 4688d29fcfb7SAdrian Chadd wpi_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k) 4689d29fcfb7SAdrian Chadd { 4690d29fcfb7SAdrian Chadd return wpi_process_key(vap, k, 0); 4691d29fcfb7SAdrian Chadd } 4692d29fcfb7SAdrian Chadd 4693692ad7caSAdrian Chadd /* 4694692ad7caSAdrian Chadd * This function is called after the runtime firmware notifies us of its 4695692ad7caSAdrian Chadd * readiness (called in a process context). 4696692ad7caSAdrian Chadd */ 4697692ad7caSAdrian Chadd static int 4698692ad7caSAdrian Chadd wpi_post_alive(struct wpi_softc *sc) 4699692ad7caSAdrian Chadd { 4700692ad7caSAdrian Chadd int ntries, error; 4701692ad7caSAdrian Chadd 4702692ad7caSAdrian Chadd /* Check (again) that the radio is not disabled. */ 4703692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4704692ad7caSAdrian Chadd return error; 4705692ad7caSAdrian Chadd 4706692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4707692ad7caSAdrian Chadd 4708692ad7caSAdrian Chadd /* NB: Runtime firmware must be up and running. */ 4709692ad7caSAdrian Chadd if (!(wpi_prph_read(sc, WPI_APMG_RFKILL) & 1)) { 4710692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4711692ad7caSAdrian Chadd "RF switch: radio disabled (%s)\n", __func__); 4712692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4713692ad7caSAdrian Chadd return EPERM; /* :-) */ 4714692ad7caSAdrian Chadd } 4715692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4716692ad7caSAdrian Chadd 4717692ad7caSAdrian Chadd /* Wait for thermal sensor to calibrate. */ 4718692ad7caSAdrian Chadd for (ntries = 0; ntries < 1000; ntries++) { 4719692ad7caSAdrian Chadd if ((sc->temp = (int)WPI_READ(sc, WPI_UCODE_GP2)) != 0) 4720692ad7caSAdrian Chadd break; 4721692ad7caSAdrian Chadd DELAY(10); 4722692ad7caSAdrian Chadd } 4723692ad7caSAdrian Chadd 4724692ad7caSAdrian Chadd if (ntries == 1000) { 4725692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4726692ad7caSAdrian Chadd "timeout waiting for thermal sensor calibration\n"); 4727692ad7caSAdrian Chadd return ETIMEDOUT; 4728692ad7caSAdrian Chadd } 4729692ad7caSAdrian Chadd 4730692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, "temperature %d\n", sc->temp); 4731692ad7caSAdrian Chadd return 0; 4732692ad7caSAdrian Chadd } 4733692ad7caSAdrian Chadd 4734692ad7caSAdrian Chadd /* 4735692ad7caSAdrian Chadd * The firmware boot code is small and is intended to be copied directly into 4736692ad7caSAdrian Chadd * the NIC internal memory (no DMA transfer). 4737692ad7caSAdrian Chadd */ 4738692ad7caSAdrian Chadd static int 4739692ad7caSAdrian Chadd wpi_load_bootcode(struct wpi_softc *sc, const uint8_t *ucode, int size) 4740692ad7caSAdrian Chadd { 4741692ad7caSAdrian Chadd int error, ntries; 4742692ad7caSAdrian Chadd 4743692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_HW, "Loading microcode size 0x%x\n", size); 4744692ad7caSAdrian Chadd 4745692ad7caSAdrian Chadd size /= sizeof (uint32_t); 4746692ad7caSAdrian Chadd 4747692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4748692ad7caSAdrian Chadd return error; 4749692ad7caSAdrian Chadd 4750692ad7caSAdrian Chadd /* Copy microcode image into NIC memory. */ 4751692ad7caSAdrian Chadd wpi_prph_write_region_4(sc, WPI_BSM_SRAM_BASE, 4752692ad7caSAdrian Chadd (const uint32_t *)ucode, size); 4753692ad7caSAdrian Chadd 4754692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_MEM_SRC, 0); 4755692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_MEM_DST, WPI_FW_TEXT_BASE); 4756692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_DWCOUNT, size); 4757692ad7caSAdrian Chadd 4758692ad7caSAdrian Chadd /* Start boot load now. */ 4759692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_CTRL, WPI_BSM_WR_CTRL_START); 4760692ad7caSAdrian Chadd 4761692ad7caSAdrian Chadd /* Wait for transfer to complete. */ 4762692ad7caSAdrian Chadd for (ntries = 0; ntries < 1000; ntries++) { 4763692ad7caSAdrian Chadd uint32_t status = WPI_READ(sc, WPI_FH_TX_STATUS); 4764692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_HW, 4765692ad7caSAdrian Chadd "firmware status=0x%x, val=0x%x, result=0x%x\n", status, 4766692ad7caSAdrian Chadd WPI_FH_TX_STATUS_IDLE(6), 4767692ad7caSAdrian Chadd status & WPI_FH_TX_STATUS_IDLE(6)); 4768692ad7caSAdrian Chadd if (status & WPI_FH_TX_STATUS_IDLE(6)) { 4769692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_HW, 4770692ad7caSAdrian Chadd "Status Match! - ntries = %d\n", ntries); 4771692ad7caSAdrian Chadd break; 4772692ad7caSAdrian Chadd } 4773692ad7caSAdrian Chadd DELAY(10); 4774692ad7caSAdrian Chadd } 4775692ad7caSAdrian Chadd if (ntries == 1000) { 4776692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not load boot firmware\n", 4777692ad7caSAdrian Chadd __func__); 4778692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4779692ad7caSAdrian Chadd return ETIMEDOUT; 4780692ad7caSAdrian Chadd } 4781692ad7caSAdrian Chadd 4782692ad7caSAdrian Chadd /* Enable boot after power up. */ 4783692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_CTRL, WPI_BSM_WR_CTRL_START_EN); 4784692ad7caSAdrian Chadd 4785692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4786692ad7caSAdrian Chadd return 0; 4787692ad7caSAdrian Chadd } 4788692ad7caSAdrian Chadd 4789692ad7caSAdrian Chadd static int 4790692ad7caSAdrian Chadd wpi_load_firmware(struct wpi_softc *sc) 4791692ad7caSAdrian Chadd { 4792692ad7caSAdrian Chadd struct wpi_fw_info *fw = &sc->fw; 4793692ad7caSAdrian Chadd struct wpi_dma_info *dma = &sc->fw_dma; 4794692ad7caSAdrian Chadd int error; 4795692ad7caSAdrian Chadd 4796692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4797692ad7caSAdrian Chadd 4798692ad7caSAdrian Chadd /* Copy initialization sections into pre-allocated DMA-safe memory. */ 4799692ad7caSAdrian Chadd memcpy(dma->vaddr, fw->init.data, fw->init.datasz); 4800692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 4801692ad7caSAdrian Chadd memcpy(dma->vaddr + WPI_FW_DATA_MAXSZ, fw->init.text, fw->init.textsz); 4802692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 4803692ad7caSAdrian Chadd 4804692ad7caSAdrian Chadd /* Tell adapter where to find initialization sections. */ 4805692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4806692ad7caSAdrian Chadd return error; 4807692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_DATA_ADDR, dma->paddr); 4808692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_DATA_SIZE, fw->init.datasz); 4809692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_ADDR, 4810692ad7caSAdrian Chadd dma->paddr + WPI_FW_DATA_MAXSZ); 4811692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_SIZE, fw->init.textsz); 4812692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4813692ad7caSAdrian Chadd 4814692ad7caSAdrian Chadd /* Load firmware boot code. */ 4815692ad7caSAdrian Chadd error = wpi_load_bootcode(sc, fw->boot.text, fw->boot.textsz); 4816692ad7caSAdrian Chadd if (error != 0) { 4817692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not load boot firmware\n", 4818692ad7caSAdrian Chadd __func__); 48196607310bSBenjamin Close return error; 48206607310bSBenjamin Close } 48216607310bSBenjamin Close 4822692ad7caSAdrian Chadd /* Now press "execute". */ 4823692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_RESET, 0); 4824692ad7caSAdrian Chadd 4825692ad7caSAdrian Chadd /* Wait at most one second for first alive notification. */ 482676fdf7ebSAdrian Chadd if ((error = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) { 4827692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4828692ad7caSAdrian Chadd "%s: timeout waiting for adapter to initialize, error %d\n", 4829692ad7caSAdrian Chadd __func__, error); 48306607310bSBenjamin Close return error; 48316607310bSBenjamin Close } 48326607310bSBenjamin Close 4833692ad7caSAdrian Chadd /* Copy runtime sections into pre-allocated DMA-safe memory. */ 4834692ad7caSAdrian Chadd memcpy(dma->vaddr, fw->main.data, fw->main.datasz); 4835692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 4836692ad7caSAdrian Chadd memcpy(dma->vaddr + WPI_FW_DATA_MAXSZ, fw->main.text, fw->main.textsz); 4837692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 4838692ad7caSAdrian Chadd 4839692ad7caSAdrian Chadd /* Tell adapter where to find runtime sections. */ 4840692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4841692ad7caSAdrian Chadd return error; 4842692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_DATA_ADDR, dma->paddr); 4843692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_DATA_SIZE, fw->main.datasz); 4844692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_ADDR, 4845692ad7caSAdrian Chadd dma->paddr + WPI_FW_DATA_MAXSZ); 4846692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_SIZE, 4847692ad7caSAdrian Chadd WPI_FW_UPDATED | fw->main.textsz); 4848692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4849692ad7caSAdrian Chadd 4850692ad7caSAdrian Chadd return 0; 4851692ad7caSAdrian Chadd } 4852692ad7caSAdrian Chadd 4853692ad7caSAdrian Chadd static int 4854692ad7caSAdrian Chadd wpi_read_firmware(struct wpi_softc *sc) 4855692ad7caSAdrian Chadd { 4856692ad7caSAdrian Chadd const struct firmware *fp; 4857692ad7caSAdrian Chadd struct wpi_fw_info *fw = &sc->fw; 4858692ad7caSAdrian Chadd const struct wpi_firmware_hdr *hdr; 4859692ad7caSAdrian Chadd int error; 4860692ad7caSAdrian Chadd 4861692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4862692ad7caSAdrian Chadd 4863692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, 4864692ad7caSAdrian Chadd "Attempting Loading Firmware from %s module\n", WPI_FW_NAME); 4865692ad7caSAdrian Chadd 4866692ad7caSAdrian Chadd WPI_UNLOCK(sc); 4867692ad7caSAdrian Chadd fp = firmware_get(WPI_FW_NAME); 4868692ad7caSAdrian Chadd WPI_LOCK(sc); 4869692ad7caSAdrian Chadd 4870692ad7caSAdrian Chadd if (fp == NULL) { 4871692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4872692ad7caSAdrian Chadd "could not load firmware image '%s'\n", WPI_FW_NAME); 4873692ad7caSAdrian Chadd return EINVAL; 4874692ad7caSAdrian Chadd } 4875692ad7caSAdrian Chadd 4876692ad7caSAdrian Chadd sc->fw_fp = fp; 4877692ad7caSAdrian Chadd 4878692ad7caSAdrian Chadd if (fp->datasize < sizeof (struct wpi_firmware_hdr)) { 4879692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4880692ad7caSAdrian Chadd "firmware file too short: %zu bytes\n", fp->datasize); 4881692ad7caSAdrian Chadd error = EINVAL; 4882692ad7caSAdrian Chadd goto fail; 4883692ad7caSAdrian Chadd } 4884692ad7caSAdrian Chadd 4885692ad7caSAdrian Chadd fw->size = fp->datasize; 4886692ad7caSAdrian Chadd fw->data = (const uint8_t *)fp->data; 4887692ad7caSAdrian Chadd 4888692ad7caSAdrian Chadd /* Extract firmware header information. */ 4889692ad7caSAdrian Chadd hdr = (const struct wpi_firmware_hdr *)fw->data; 4890692ad7caSAdrian Chadd 4891692ad7caSAdrian Chadd /* | RUNTIME FIRMWARE | INIT FIRMWARE | BOOT FW | 4892692ad7caSAdrian Chadd |HDR|<--TEXT-->|<--DATA-->|<--TEXT-->|<--DATA-->|<--TEXT-->| */ 4893692ad7caSAdrian Chadd 4894692ad7caSAdrian Chadd fw->main.textsz = le32toh(hdr->rtextsz); 4895692ad7caSAdrian Chadd fw->main.datasz = le32toh(hdr->rdatasz); 4896692ad7caSAdrian Chadd fw->init.textsz = le32toh(hdr->itextsz); 4897692ad7caSAdrian Chadd fw->init.datasz = le32toh(hdr->idatasz); 4898692ad7caSAdrian Chadd fw->boot.textsz = le32toh(hdr->btextsz); 4899692ad7caSAdrian Chadd fw->boot.datasz = 0; 4900692ad7caSAdrian Chadd 4901692ad7caSAdrian Chadd /* Sanity-check firmware header. */ 4902692ad7caSAdrian Chadd if (fw->main.textsz > WPI_FW_TEXT_MAXSZ || 4903692ad7caSAdrian Chadd fw->main.datasz > WPI_FW_DATA_MAXSZ || 4904692ad7caSAdrian Chadd fw->init.textsz > WPI_FW_TEXT_MAXSZ || 4905692ad7caSAdrian Chadd fw->init.datasz > WPI_FW_DATA_MAXSZ || 4906692ad7caSAdrian Chadd fw->boot.textsz > WPI_FW_BOOT_TEXT_MAXSZ || 4907692ad7caSAdrian Chadd (fw->boot.textsz & 3) != 0) { 4908692ad7caSAdrian Chadd device_printf(sc->sc_dev, "invalid firmware header\n"); 4909692ad7caSAdrian Chadd error = EINVAL; 4910692ad7caSAdrian Chadd goto fail; 4911692ad7caSAdrian Chadd } 4912692ad7caSAdrian Chadd 4913692ad7caSAdrian Chadd /* Check that all firmware sections fit. */ 4914692ad7caSAdrian Chadd if (fw->size < sizeof (*hdr) + fw->main.textsz + fw->main.datasz + 4915692ad7caSAdrian Chadd fw->init.textsz + fw->init.datasz + fw->boot.textsz) { 4916692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4917692ad7caSAdrian Chadd "firmware file too short: %zu bytes\n", fw->size); 4918692ad7caSAdrian Chadd error = EINVAL; 4919692ad7caSAdrian Chadd goto fail; 4920692ad7caSAdrian Chadd } 4921692ad7caSAdrian Chadd 4922692ad7caSAdrian Chadd /* Get pointers to firmware sections. */ 4923692ad7caSAdrian Chadd fw->main.text = (const uint8_t *)(hdr + 1); 4924692ad7caSAdrian Chadd fw->main.data = fw->main.text + fw->main.textsz; 4925692ad7caSAdrian Chadd fw->init.text = fw->main.data + fw->main.datasz; 4926692ad7caSAdrian Chadd fw->init.data = fw->init.text + fw->init.textsz; 4927692ad7caSAdrian Chadd fw->boot.text = fw->init.data + fw->init.datasz; 4928692ad7caSAdrian Chadd 4929692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, 4930692ad7caSAdrian Chadd "Firmware Version: Major %d, Minor %d, Driver %d, \n" 49317167f5fcSAdrian Chadd "runtime (text: %u, data: %u) init (text: %u, data %u) " 49327167f5fcSAdrian Chadd "boot (text %u)\n", hdr->major, hdr->minor, le32toh(hdr->driver), 4933692ad7caSAdrian Chadd fw->main.textsz, fw->main.datasz, 4934692ad7caSAdrian Chadd fw->init.textsz, fw->init.datasz, fw->boot.textsz); 4935692ad7caSAdrian Chadd 4936692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->main.text %p\n", fw->main.text); 4937692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->main.data %p\n", fw->main.data); 4938692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->init.text %p\n", fw->init.text); 4939692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->init.data %p\n", fw->init.data); 4940692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->boot.text %p\n", fw->boot.text); 4941692ad7caSAdrian Chadd 4942692ad7caSAdrian Chadd return 0; 4943692ad7caSAdrian Chadd 4944692ad7caSAdrian Chadd fail: wpi_unload_firmware(sc); 4945692ad7caSAdrian Chadd return error; 4946692ad7caSAdrian Chadd } 4947692ad7caSAdrian Chadd 4948692ad7caSAdrian Chadd /** 4949692ad7caSAdrian Chadd * Free the referenced firmware image 4950692ad7caSAdrian Chadd */ 4951692ad7caSAdrian Chadd static void 4952692ad7caSAdrian Chadd wpi_unload_firmware(struct wpi_softc *sc) 4953692ad7caSAdrian Chadd { 4954692ad7caSAdrian Chadd if (sc->fw_fp != NULL) { 4955692ad7caSAdrian Chadd firmware_put(sc->fw_fp, FIRMWARE_UNLOAD); 4956692ad7caSAdrian Chadd sc->fw_fp = NULL; 4957692ad7caSAdrian Chadd } 4958692ad7caSAdrian Chadd } 4959692ad7caSAdrian Chadd 4960692ad7caSAdrian Chadd static int 4961692ad7caSAdrian Chadd wpi_clock_wait(struct wpi_softc *sc) 4962692ad7caSAdrian Chadd { 4963692ad7caSAdrian Chadd int ntries; 4964692ad7caSAdrian Chadd 4965692ad7caSAdrian Chadd /* Set "initialization complete" bit. */ 4966692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_INIT_DONE); 4967692ad7caSAdrian Chadd 4968692ad7caSAdrian Chadd /* Wait for clock stabilization. */ 4969692ad7caSAdrian Chadd for (ntries = 0; ntries < 2500; ntries++) { 4970692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_MAC_CLOCK_READY) 4971692ad7caSAdrian Chadd return 0; 4972692ad7caSAdrian Chadd DELAY(100); 4973692ad7caSAdrian Chadd } 4974692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4975692ad7caSAdrian Chadd "%s: timeout waiting for clock stabilization\n", __func__); 4976692ad7caSAdrian Chadd 4977692ad7caSAdrian Chadd return ETIMEDOUT; 4978692ad7caSAdrian Chadd } 4979692ad7caSAdrian Chadd 4980692ad7caSAdrian Chadd static int 4981692ad7caSAdrian Chadd wpi_apm_init(struct wpi_softc *sc) 4982692ad7caSAdrian Chadd { 4983692ad7caSAdrian Chadd uint32_t reg; 4984692ad7caSAdrian Chadd int error; 4985692ad7caSAdrian Chadd 4986692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4987692ad7caSAdrian Chadd 4988692ad7caSAdrian Chadd /* Disable L0s exit timer (NMI bug workaround). */ 4989692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GIO_CHICKEN, WPI_GIO_CHICKEN_DIS_L0S_TIMER); 4990692ad7caSAdrian Chadd /* Don't wait for ICH L0s (ICH bug workaround). */ 4991692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GIO_CHICKEN, WPI_GIO_CHICKEN_L1A_NO_L0S_RX); 4992692ad7caSAdrian Chadd 4993692ad7caSAdrian Chadd /* Set FH wait threshold to max (HW bug under stress workaround). */ 4994692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_DBG_HPET_MEM, 0xffff0000); 4995692ad7caSAdrian Chadd 4996692ad7caSAdrian Chadd /* Retrieve PCIe Active State Power Management (ASPM). */ 4997692ad7caSAdrian Chadd reg = pci_read_config(sc->sc_dev, sc->sc_cap_off + 0x10, 1); 4998692ad7caSAdrian Chadd /* Workaround for HW instability in PCIe L0->L0s->L1 transition. */ 4999692ad7caSAdrian Chadd if (reg & 0x02) /* L1 Entry enabled. */ 5000692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GIO, WPI_GIO_L0S_ENA); 5001692ad7caSAdrian Chadd else 5002692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_GIO, WPI_GIO_L0S_ENA); 5003692ad7caSAdrian Chadd 5004692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_ANA_PLL, WPI_ANA_PLL_INIT); 5005692ad7caSAdrian Chadd 5006692ad7caSAdrian Chadd /* Wait for clock stabilization before accessing prph. */ 5007692ad7caSAdrian Chadd if ((error = wpi_clock_wait(sc)) != 0) 5008692ad7caSAdrian Chadd return error; 5009692ad7caSAdrian Chadd 5010692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 5011692ad7caSAdrian Chadd return error; 501202d49915SAdrian Chadd /* Cleanup. */ 501302d49915SAdrian Chadd wpi_prph_write(sc, WPI_APMG_CLK_DIS, 0x00000400); 501402d49915SAdrian Chadd wpi_prph_clrbits(sc, WPI_APMG_PS, 0x00000200); 501502d49915SAdrian Chadd 5016692ad7caSAdrian Chadd /* Enable DMA and BSM (Bootstrap State Machine). */ 5017692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_APMG_CLK_EN, 5018692ad7caSAdrian Chadd WPI_APMG_CLK_CTRL_DMA_CLK_RQT | WPI_APMG_CLK_CTRL_BSM_CLK_RQT); 5019692ad7caSAdrian Chadd DELAY(20); 5020692ad7caSAdrian Chadd /* Disable L1-Active. */ 5021692ad7caSAdrian Chadd wpi_prph_setbits(sc, WPI_APMG_PCI_STT, WPI_APMG_PCI_STT_L1A_DIS); 5022692ad7caSAdrian Chadd wpi_nic_unlock(sc); 5023692ad7caSAdrian Chadd 50246607310bSBenjamin Close return 0; 50256607310bSBenjamin Close } 50266607310bSBenjamin Close 50276607310bSBenjamin Close static void 5028692ad7caSAdrian Chadd wpi_apm_stop_master(struct wpi_softc *sc) 50296607310bSBenjamin Close { 50306607310bSBenjamin Close int ntries; 50316607310bSBenjamin Close 5032692ad7caSAdrian Chadd /* Stop busmaster DMA activity. */ 5033692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_RESET, WPI_RESET_STOP_MASTER); 50346607310bSBenjamin Close 5035692ad7caSAdrian Chadd if ((WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_PS_MASK) == 5036692ad7caSAdrian Chadd WPI_GP_CNTRL_MAC_PS) 5037692ad7caSAdrian Chadd return; /* Already asleep. */ 50386607310bSBenjamin Close 50396607310bSBenjamin Close for (ntries = 0; ntries < 100; ntries++) { 5040692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_RESET) & WPI_RESET_MASTER_DISABLED) 5041692ad7caSAdrian Chadd return; 50426607310bSBenjamin Close DELAY(10); 50436607310bSBenjamin Close } 50447167f5fcSAdrian Chadd device_printf(sc->sc_dev, "%s: timeout waiting for master\n", 50457167f5fcSAdrian Chadd __func__); 50466607310bSBenjamin Close } 5047692ad7caSAdrian Chadd 5048692ad7caSAdrian Chadd static void 5049692ad7caSAdrian Chadd wpi_apm_stop(struct wpi_softc *sc) 5050692ad7caSAdrian Chadd { 5051692ad7caSAdrian Chadd wpi_apm_stop_master(sc); 5052692ad7caSAdrian Chadd 5053692ad7caSAdrian Chadd /* Reset the entire device. */ 5054692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_RESET, WPI_RESET_SW); 5055692ad7caSAdrian Chadd DELAY(10); 5056692ad7caSAdrian Chadd /* Clear "initialization complete" bit. */ 5057692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_INIT_DONE); 5058692ad7caSAdrian Chadd } 5059692ad7caSAdrian Chadd 5060692ad7caSAdrian Chadd static void 5061692ad7caSAdrian Chadd wpi_nic_config(struct wpi_softc *sc) 5062692ad7caSAdrian Chadd { 5063692ad7caSAdrian Chadd uint32_t rev; 5064692ad7caSAdrian Chadd 5065692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 5066692ad7caSAdrian Chadd 5067692ad7caSAdrian Chadd /* voodoo from the Linux "driver".. */ 5068692ad7caSAdrian Chadd rev = pci_read_config(sc->sc_dev, PCIR_REVID, 1); 5069692ad7caSAdrian Chadd if ((rev & 0xc0) == 0x40) 5070692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_ALM_MB); 5071692ad7caSAdrian Chadd else if (!(rev & 0x80)) 5072692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_ALM_MM); 5073692ad7caSAdrian Chadd 5074692ad7caSAdrian Chadd if (sc->cap == 0x80) 5075692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_SKU_MRC); 5076692ad7caSAdrian Chadd 5077f736d898SAdrian Chadd if ((sc->rev & 0xf0) == 0xd0) 5078692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_REV_D); 5079692ad7caSAdrian Chadd else 5080692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_REV_D); 5081692ad7caSAdrian Chadd 5082692ad7caSAdrian Chadd if (sc->type > 1) 5083692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_TYPE_B); 50846607310bSBenjamin Close } 50856607310bSBenjamin Close 50866607310bSBenjamin Close static int 5087692ad7caSAdrian Chadd wpi_hw_init(struct wpi_softc *sc) 50886607310bSBenjamin Close { 5089692ad7caSAdrian Chadd int chnl, ntries, error; 50906607310bSBenjamin Close 5091692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 50926607310bSBenjamin Close 5093692ad7caSAdrian Chadd /* Clear pending interrupts. */ 5094692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, 0xffffffff); 5095692ad7caSAdrian Chadd 5096692ad7caSAdrian Chadd if ((error = wpi_apm_init(sc)) != 0) { 5097692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5098692ad7caSAdrian Chadd "%s: could not power ON adapter, error %d\n", __func__, 5099692ad7caSAdrian Chadd error); 5100692ad7caSAdrian Chadd return error; 5101692ad7caSAdrian Chadd } 5102692ad7caSAdrian Chadd 5103692ad7caSAdrian Chadd /* Select VMAIN power source. */ 5104692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 5105692ad7caSAdrian Chadd return error; 5106692ad7caSAdrian Chadd wpi_prph_clrbits(sc, WPI_APMG_PS, WPI_APMG_PS_PWR_SRC_MASK); 5107692ad7caSAdrian Chadd wpi_nic_unlock(sc); 5108692ad7caSAdrian Chadd /* Spin until VMAIN gets selected. */ 51096607310bSBenjamin Close for (ntries = 0; ntries < 5000; ntries++) { 5110692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_GPIO_IN) & WPI_GPIO_IN_VMAIN) 51116607310bSBenjamin Close break; 51126607310bSBenjamin Close DELAY(10); 51136607310bSBenjamin Close } 51146607310bSBenjamin Close if (ntries == 5000) { 5115692ad7caSAdrian Chadd device_printf(sc->sc_dev, "timeout selecting power source\n"); 51166607310bSBenjamin Close return ETIMEDOUT; 51176607310bSBenjamin Close } 5118692ad7caSAdrian Chadd 5119692ad7caSAdrian Chadd /* Perform adapter initialization. */ 5120692ad7caSAdrian Chadd wpi_nic_config(sc); 5121692ad7caSAdrian Chadd 5122692ad7caSAdrian Chadd /* Initialize RX ring. */ 5123692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 5124692ad7caSAdrian Chadd return error; 5125692ad7caSAdrian Chadd /* Set physical address of RX ring. */ 5126692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_BASE, sc->rxq.desc_dma.paddr); 5127692ad7caSAdrian Chadd /* Set physical address of RX read pointer. */ 5128692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_RPTR_ADDR, sc->shared_dma.paddr + 5129692ad7caSAdrian Chadd offsetof(struct wpi_shared, next)); 5130692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_WPTR, 0); 5131692ad7caSAdrian Chadd /* Enable RX. */ 5132692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_CONFIG, 5133692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_DMA_ENA | 5134692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_RDRBD_ENA | 5135692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_WRSTATUS_ENA | 5136692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_MAXFRAG | 5137692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_NRBD(WPI_RX_RING_COUNT_LOG) | 5138692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_IRQ_DST_HOST | 5139692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_IRQ_TIMEOUT(1)); 5140692ad7caSAdrian Chadd (void)WPI_READ(sc, WPI_FH_RSSR_TBL); /* barrier */ 5141692ad7caSAdrian Chadd wpi_nic_unlock(sc); 5142692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_WPTR, (WPI_RX_RING_COUNT - 1) & ~7); 5143692ad7caSAdrian Chadd 5144692ad7caSAdrian Chadd /* Initialize TX rings. */ 5145692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 5146692ad7caSAdrian Chadd return error; 5147692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_MODE, 2); /* bypass mode */ 5148692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_ARASTAT, 1); /* enable RA0 */ 5149692ad7caSAdrian Chadd /* Enable all 6 TX rings. */ 5150692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_TXFACT, 0x3f); 5151692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_SBYPASS_MODE1, 0x10000); 5152692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_SBYPASS_MODE2, 0x30002); 5153692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_TXF4MF, 4); 5154692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_TXF5MF, 5); 5155692ad7caSAdrian Chadd /* Set physical address of TX rings. */ 5156692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_TX_BASE, sc->shared_dma.paddr); 5157692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_MSG_CONFIG, 0xffff05a5); 5158692ad7caSAdrian Chadd 5159692ad7caSAdrian Chadd /* Enable all DMA channels. */ 5160692ad7caSAdrian Chadd for (chnl = 0; chnl < WPI_NDMACHNLS; chnl++) { 5161692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_CBBC_CTRL(chnl), 0); 5162692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_CBBC_BASE(chnl), 0); 5163692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_TX_CONFIG(chnl), 0x80200008); 5164692ad7caSAdrian Chadd } 5165692ad7caSAdrian Chadd wpi_nic_unlock(sc); 5166692ad7caSAdrian Chadd (void)WPI_READ(sc, WPI_FH_TX_BASE); /* barrier */ 5167692ad7caSAdrian Chadd 5168692ad7caSAdrian Chadd /* Clear "radio off" and "commands blocked" bits. */ 5169692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL); 5170692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_CMD_BLOCKED); 5171692ad7caSAdrian Chadd 5172692ad7caSAdrian Chadd /* Clear pending interrupts. */ 5173692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, 0xffffffff); 5174692ad7caSAdrian Chadd /* Enable interrupts. */ 5175692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT_MASK, WPI_INT_MASK_DEF); 5176692ad7caSAdrian Chadd 5177692ad7caSAdrian Chadd /* _Really_ make sure "radio off" bit is cleared! */ 5178692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL); 5179692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL); 5180692ad7caSAdrian Chadd 5181692ad7caSAdrian Chadd if ((error = wpi_load_firmware(sc)) != 0) { 5182692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5183692ad7caSAdrian Chadd "%s: could not load firmware, error %d\n", __func__, 5184692ad7caSAdrian Chadd error); 5185692ad7caSAdrian Chadd return error; 5186692ad7caSAdrian Chadd } 5187692ad7caSAdrian Chadd /* Wait at most one second for firmware alive notification. */ 518876fdf7ebSAdrian Chadd if ((error = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) { 5189692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5190692ad7caSAdrian Chadd "%s: timeout waiting for adapter to initialize, error %d\n", 5191692ad7caSAdrian Chadd __func__, error); 5192692ad7caSAdrian Chadd return error; 51936607310bSBenjamin Close } 51946607310bSBenjamin Close 5195692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 5196692ad7caSAdrian Chadd 5197692ad7caSAdrian Chadd /* Do post-firmware initialization. */ 5198692ad7caSAdrian Chadd return wpi_post_alive(sc); 5199692ad7caSAdrian Chadd } 5200692ad7caSAdrian Chadd 5201692ad7caSAdrian Chadd static void 5202692ad7caSAdrian Chadd wpi_hw_stop(struct wpi_softc *sc) 52036607310bSBenjamin Close { 5204692ad7caSAdrian Chadd int chnl, qid, ntries; 52056607310bSBenjamin Close 5206692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 52076607310bSBenjamin Close 5208692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_UCODE_GP1) & WPI_UCODE_GP1_MAC_SLEEP) 5209692ad7caSAdrian Chadd wpi_nic_lock(sc); 52106607310bSBenjamin Close 5211692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_RESET, WPI_RESET_NEVO); 52126607310bSBenjamin Close 5213692ad7caSAdrian Chadd /* Disable interrupts. */ 5214692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT_MASK, 0); 5215692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, 0xffffffff); 5216692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_INT, 0xffffffff); 52176607310bSBenjamin Close 5218692ad7caSAdrian Chadd /* Make sure we no longer hold the NIC lock. */ 5219692ad7caSAdrian Chadd wpi_nic_unlock(sc); 52206607310bSBenjamin Close 5221692ad7caSAdrian Chadd if (wpi_nic_lock(sc) == 0) { 5222692ad7caSAdrian Chadd /* Stop TX scheduler. */ 5223692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_MODE, 0); 5224692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_TXFACT, 0); 5225692ad7caSAdrian Chadd 5226692ad7caSAdrian Chadd /* Stop all DMA channels. */ 5227692ad7caSAdrian Chadd for (chnl = 0; chnl < WPI_NDMACHNLS; chnl++) { 5228692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_TX_CONFIG(chnl), 0); 5229692ad7caSAdrian Chadd for (ntries = 0; ntries < 200; ntries++) { 5230692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_FH_TX_STATUS) & 5231692ad7caSAdrian Chadd WPI_FH_TX_STATUS_IDLE(chnl)) 52326607310bSBenjamin Close break; 52336607310bSBenjamin Close DELAY(10); 52346607310bSBenjamin Close } 5235692ad7caSAdrian Chadd } 5236692ad7caSAdrian Chadd wpi_nic_unlock(sc); 52376607310bSBenjamin Close } 52386607310bSBenjamin Close 5239692ad7caSAdrian Chadd /* Stop RX ring. */ 5240692ad7caSAdrian Chadd wpi_reset_rx_ring(sc); 52416607310bSBenjamin Close 5242692ad7caSAdrian Chadd /* Reset all TX rings. */ 5243692ad7caSAdrian Chadd for (qid = 0; qid < WPI_NTXQUEUES; qid++) 5244692ad7caSAdrian Chadd wpi_reset_tx_ring(sc, &sc->txq[qid]); 5245692ad7caSAdrian Chadd 5246692ad7caSAdrian Chadd if (wpi_nic_lock(sc) == 0) { 5247692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_APMG_CLK_DIS, 5248692ad7caSAdrian Chadd WPI_APMG_CLK_CTRL_DMA_CLK_RQT); 5249692ad7caSAdrian Chadd wpi_nic_unlock(sc); 52506607310bSBenjamin Close } 5251692ad7caSAdrian Chadd DELAY(5); 5252692ad7caSAdrian Chadd /* Power OFF adapter. */ 5253692ad7caSAdrian Chadd wpi_apm_stop(sc); 52546607310bSBenjamin Close } 52556607310bSBenjamin Close 52566607310bSBenjamin Close static void 5257692ad7caSAdrian Chadd wpi_radio_on(void *arg0, int pending) 52586607310bSBenjamin Close { 5259692ad7caSAdrian Chadd struct wpi_softc *sc = arg0; 526082f1b132SAndrew Thompson struct ifnet *ifp = sc->sc_ifp; 5261b032f27cSSam Leffler struct ieee80211com *ic = ifp->if_l2com; 5262b032f27cSSam Leffler struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 526382f1b132SAndrew Thompson 5264692ad7caSAdrian Chadd device_printf(sc->sc_dev, "RF switch: radio enabled\n"); 526582f1b132SAndrew Thompson 5266b032f27cSSam Leffler if (vap != NULL) { 5267692ad7caSAdrian Chadd wpi_init(sc); 5268692ad7caSAdrian Chadd ieee80211_init(vap); 526982f1b132SAndrew Thompson } 527082f1b132SAndrew Thompson 5271692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_RFKILL) { 5272692ad7caSAdrian Chadd WPI_LOCK(sc); 5273692ad7caSAdrian Chadd callout_stop(&sc->watchdog_rfkill); 5274692ad7caSAdrian Chadd WPI_UNLOCK(sc); 5275692ad7caSAdrian Chadd } 527682f1b132SAndrew Thompson } 527782f1b132SAndrew Thompson 527882f1b132SAndrew Thompson static void 5279692ad7caSAdrian Chadd wpi_radio_off(void *arg0, int pending) 5280692ad7caSAdrian Chadd { 5281692ad7caSAdrian Chadd struct wpi_softc *sc = arg0; 5282692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 5283692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 5284692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 5285692ad7caSAdrian Chadd 5286692ad7caSAdrian Chadd device_printf(sc->sc_dev, "RF switch: radio disabled\n"); 5287692ad7caSAdrian Chadd 5288692ad7caSAdrian Chadd wpi_stop(sc); 5289692ad7caSAdrian Chadd if (vap != NULL) 5290692ad7caSAdrian Chadd ieee80211_stop(vap); 5291692ad7caSAdrian Chadd 5292811fe0a8SAdrian Chadd WPI_LOCK(sc); 5293692ad7caSAdrian Chadd callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill, sc); 5294811fe0a8SAdrian Chadd WPI_UNLOCK(sc); 5295692ad7caSAdrian Chadd } 5296692ad7caSAdrian Chadd 5297692ad7caSAdrian Chadd static void 529877cf0b82SAdrian Chadd wpi_init(void *arg) 529982f1b132SAndrew Thompson { 530077cf0b82SAdrian Chadd struct wpi_softc *sc = arg; 5301b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 530277cf0b82SAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 5303692ad7caSAdrian Chadd int error; 53046607310bSBenjamin Close 530577cf0b82SAdrian Chadd WPI_LOCK(sc); 530677cf0b82SAdrian Chadd 5307692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 53086607310bSBenjamin Close 530977cf0b82SAdrian Chadd if ((ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) 531077cf0b82SAdrian Chadd goto end; 53116607310bSBenjamin Close 5312692ad7caSAdrian Chadd /* Check that the radio is not disabled by hardware switch. */ 5313692ad7caSAdrian Chadd if (!(WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_RFKILL)) { 53146607310bSBenjamin Close device_printf(sc->sc_dev, 5315692ad7caSAdrian Chadd "RF switch: radio disabled (%s)\n", __func__); 5316692ad7caSAdrian Chadd callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill, 5317692ad7caSAdrian Chadd sc); 531877cf0b82SAdrian Chadd goto end; 53196607310bSBenjamin Close } 53206607310bSBenjamin Close 5321692ad7caSAdrian Chadd /* Read firmware images from the filesystem. */ 5322692ad7caSAdrian Chadd if ((error = wpi_read_firmware(sc)) != 0) { 53236607310bSBenjamin Close device_printf(sc->sc_dev, 5324692ad7caSAdrian Chadd "%s: could not read firmware, error %d\n", __func__, 5325692ad7caSAdrian Chadd error); 5326692ad7caSAdrian Chadd goto fail; 53276607310bSBenjamin Close } 53286607310bSBenjamin Close 5329692ad7caSAdrian Chadd /* Initialize hardware and upload firmware. */ 5330692ad7caSAdrian Chadd error = wpi_hw_init(sc); 5331692ad7caSAdrian Chadd wpi_unload_firmware(sc); 5332692ad7caSAdrian Chadd if (error != 0) { 5333692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5334692ad7caSAdrian Chadd "%s: could not initialize hardware, error %d\n", __func__, 5335692ad7caSAdrian Chadd error); 5336692ad7caSAdrian Chadd goto fail; 5337692ad7caSAdrian Chadd } 5338692ad7caSAdrian Chadd 5339692ad7caSAdrian Chadd /* Configure adapter now that it is ready. */ 534063f57699SAdrian Chadd sc->txq_active = 1; 5341692ad7caSAdrian Chadd if ((error = wpi_config(sc)) != 0) { 5342692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5343692ad7caSAdrian Chadd "%s: could not configure device, error %d\n", __func__, 5344692ad7caSAdrian Chadd error); 5345692ad7caSAdrian Chadd goto fail; 534682f1b132SAndrew Thompson } 534782f1b132SAndrew Thompson 5348b9858d86SAdrian Chadd IF_LOCK(&ifp->if_snd); 53496607310bSBenjamin Close ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 53506607310bSBenjamin Close ifp->if_drv_flags |= IFF_DRV_RUNNING; 5351b9858d86SAdrian Chadd IF_UNLOCK(&ifp->if_snd); 5352692ad7caSAdrian Chadd 5353692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 5354692ad7caSAdrian Chadd 535577cf0b82SAdrian Chadd WPI_UNLOCK(sc); 535677cf0b82SAdrian Chadd 535777cf0b82SAdrian Chadd ieee80211_start_all(ic); 535877cf0b82SAdrian Chadd 5359692ad7caSAdrian Chadd return; 5360692ad7caSAdrian Chadd 5361692ad7caSAdrian Chadd fail: wpi_stop_locked(sc); 536277cf0b82SAdrian Chadd end: DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 53636607310bSBenjamin Close WPI_UNLOCK(sc); 53646607310bSBenjamin Close } 5365b032f27cSSam Leffler 53666607310bSBenjamin Close static void 53676607310bSBenjamin Close wpi_stop_locked(struct wpi_softc *sc) 53686607310bSBenjamin Close { 5369b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 53706607310bSBenjamin Close 5371692ad7caSAdrian Chadd WPI_LOCK_ASSERT(sc); 5372692ad7caSAdrian Chadd 537363f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 537463f57699SAdrian Chadd sc->txq_active = 0; 537563f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 537663f57699SAdrian Chadd 5377fc5870b4SAdrian Chadd WPI_TXQ_STATE_LOCK(sc); 5378d74e544aSAdrian Chadd callout_stop(&sc->tx_timeout); 5379fc5870b4SAdrian Chadd WPI_TXQ_STATE_UNLOCK(sc); 5380446685e4SAdrian Chadd 5381446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 53820bc39fc6SAdrian Chadd callout_stop(&sc->scan_timeout); 538382f1b132SAndrew Thompson callout_stop(&sc->calib_to); 5384446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 5385b9858d86SAdrian Chadd 5386b9858d86SAdrian Chadd IF_LOCK(&ifp->if_snd); 5387692ad7caSAdrian Chadd ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 5388b9858d86SAdrian Chadd IF_UNLOCK(&ifp->if_snd); 538982f1b132SAndrew Thompson 5390692ad7caSAdrian Chadd /* Power OFF hardware. */ 5391692ad7caSAdrian Chadd wpi_hw_stop(sc); 53926607310bSBenjamin Close } 53936607310bSBenjamin Close 53946607310bSBenjamin Close static void 5395b032f27cSSam Leffler wpi_stop(struct wpi_softc *sc) 53966607310bSBenjamin Close { 5397b032f27cSSam Leffler WPI_LOCK(sc); 5398b032f27cSSam Leffler wpi_stop_locked(sc); 5399b032f27cSSam Leffler WPI_UNLOCK(sc); 54006607310bSBenjamin Close } 54016607310bSBenjamin Close 54026607310bSBenjamin Close /* 5403692ad7caSAdrian Chadd * Callback from net80211 to start a scan. 54046607310bSBenjamin Close */ 54056607310bSBenjamin Close static void 54066607310bSBenjamin Close wpi_scan_start(struct ieee80211com *ic) 54076607310bSBenjamin Close { 5408f319a41cSAdrian Chadd struct wpi_softc *sc = ic->ic_ifp->if_softc; 54096607310bSBenjamin Close 54105efea30fSAndrew Thompson wpi_set_led(sc, WPI_LED_LINK, 20, 2); 54116607310bSBenjamin Close } 54126607310bSBenjamin Close 5413692ad7caSAdrian Chadd /* 5414692ad7caSAdrian Chadd * Callback from net80211 to terminate a scan. 54156607310bSBenjamin Close */ 54166607310bSBenjamin Close static void 54176607310bSBenjamin Close wpi_scan_end(struct ieee80211com *ic) 54186607310bSBenjamin Close { 5419692ad7caSAdrian Chadd struct ifnet *ifp = ic->ic_ifp; 5420692ad7caSAdrian Chadd struct wpi_softc *sc = ifp->if_softc; 5421692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 5422692ad7caSAdrian Chadd 54230b093122SAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN) 5424692ad7caSAdrian Chadd wpi_set_led(sc, WPI_LED_LINK, 0, 1); 54256607310bSBenjamin Close } 54266607310bSBenjamin Close 54276607310bSBenjamin Close /** 54286607310bSBenjamin Close * Called by the net80211 framework to indicate to the driver 54296607310bSBenjamin Close * that the channel should be changed 54306607310bSBenjamin Close */ 54316607310bSBenjamin Close static void 54326607310bSBenjamin Close wpi_set_channel(struct ieee80211com *ic) 54336607310bSBenjamin Close { 5434692ad7caSAdrian Chadd const struct ieee80211_channel *c = ic->ic_curchan; 54356607310bSBenjamin Close struct ifnet *ifp = ic->ic_ifp; 54366607310bSBenjamin Close struct wpi_softc *sc = ifp->if_softc; 54375efea30fSAndrew Thompson int error; 54386607310bSBenjamin Close 5439692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 5440692ad7caSAdrian Chadd 5441692ad7caSAdrian Chadd WPI_LOCK(sc); 5442692ad7caSAdrian Chadd sc->sc_rxtap.wr_chan_freq = htole16(c->ic_freq); 5443692ad7caSAdrian Chadd sc->sc_rxtap.wr_chan_flags = htole16(c->ic_flags); 54445effcbfdSAdrian Chadd WPI_UNLOCK(sc); 54455effcbfdSAdrian Chadd WPI_TX_LOCK(sc); 5446692ad7caSAdrian Chadd sc->sc_txtap.wt_chan_freq = htole16(c->ic_freq); 5447692ad7caSAdrian Chadd sc->sc_txtap.wt_chan_flags = htole16(c->ic_flags); 54485effcbfdSAdrian Chadd WPI_TX_UNLOCK(sc); 5449692ad7caSAdrian Chadd 545082f1b132SAndrew Thompson /* 545182f1b132SAndrew Thompson * Only need to set the channel in Monitor mode. AP scanning and auth 545282f1b132SAndrew Thompson * are already taken care of by their respective firmware commands. 545382f1b132SAndrew Thompson */ 54545efea30fSAndrew Thompson if (ic->ic_opmode == IEEE80211_M_MONITOR) { 5455446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 5456692ad7caSAdrian Chadd sc->rxon.chan = ieee80211_chan2ieee(ic, c); 5457692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_2GHZ(c)) { 5458692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_AUTO | 5459692ad7caSAdrian Chadd WPI_RXON_24GHZ); 5460692ad7caSAdrian Chadd } else { 5461692ad7caSAdrian Chadd sc->rxon.flags &= ~htole32(WPI_RXON_AUTO | 5462692ad7caSAdrian Chadd WPI_RXON_24GHZ); 54635efea30fSAndrew Thompson } 5464446685e4SAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 1)) != 0) 5465692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5466cec45f04SAdrian Chadd "%s: error %d setting channel\n", __func__, 5467692ad7caSAdrian Chadd error); 5468446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 5469692ad7caSAdrian Chadd } 54706607310bSBenjamin Close } 54716607310bSBenjamin Close 54726607310bSBenjamin Close /** 54736607310bSBenjamin Close * Called by net80211 to indicate that we need to scan the current 54746607310bSBenjamin Close * channel. The channel is previously be set via the wpi_set_channel 54756607310bSBenjamin Close * callback. 54766607310bSBenjamin Close */ 54776607310bSBenjamin Close static void 5478b032f27cSSam Leffler wpi_scan_curchan(struct ieee80211_scan_state *ss, unsigned long maxdwell) 54796607310bSBenjamin Close { 5480b032f27cSSam Leffler struct ieee80211vap *vap = ss->ss_vap; 5481692ad7caSAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 5482f319a41cSAdrian Chadd struct wpi_softc *sc = ic->ic_ifp->if_softc; 5483692ad7caSAdrian Chadd int error; 54846607310bSBenjamin Close 5485446685e4SAdrian Chadd WPI_RXON_LOCK(sc); 5486692ad7caSAdrian Chadd error = wpi_scan(sc, ic->ic_curchan); 5487446685e4SAdrian Chadd WPI_RXON_UNLOCK(sc); 5488692ad7caSAdrian Chadd if (error != 0) 5489692ad7caSAdrian Chadd ieee80211_cancel_scan(vap); 54906607310bSBenjamin Close } 54916607310bSBenjamin Close 54926607310bSBenjamin Close /** 54936607310bSBenjamin Close * Called by the net80211 framework to indicate 54946607310bSBenjamin Close * the minimum dwell time has been met, terminate the scan. 54956607310bSBenjamin Close * We don't actually terminate the scan as the firmware will notify 54966607310bSBenjamin Close * us when it's finished and we have no way to interrupt it. 54976607310bSBenjamin Close */ 54986607310bSBenjamin Close static void 5499b032f27cSSam Leffler wpi_scan_mindwell(struct ieee80211_scan_state *ss) 55006607310bSBenjamin Close { 55016607310bSBenjamin Close /* NB: don't try to abort scan; wait for firmware to finish */ 55026607310bSBenjamin Close } 55036607310bSBenjamin Close 55046607310bSBenjamin Close static void 5505692ad7caSAdrian Chadd wpi_hw_reset(void *arg, int pending) 55066607310bSBenjamin Close { 55076607310bSBenjamin Close struct wpi_softc *sc = arg; 550882f1b132SAndrew Thompson struct ifnet *ifp = sc->sc_ifp; 55095efea30fSAndrew Thompson struct ieee80211com *ic = ifp->if_l2com; 5510b032f27cSSam Leffler struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 551182f1b132SAndrew Thompson 5512692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 55136607310bSBenjamin Close 55140bc39fc6SAdrian Chadd if (vap != NULL && (ic->ic_flags & IEEE80211_F_SCAN)) 55150bc39fc6SAdrian Chadd ieee80211_cancel_scan(vap); 55160bc39fc6SAdrian Chadd 5517692ad7caSAdrian Chadd wpi_stop(sc); 5518692ad7caSAdrian Chadd if (vap != NULL) 5519692ad7caSAdrian Chadd ieee80211_stop(vap); 5520692ad7caSAdrian Chadd wpi_init(sc); 5521692ad7caSAdrian Chadd if (vap != NULL) 5522692ad7caSAdrian Chadd ieee80211_init(vap); 55236607310bSBenjamin Close } 5524